Repository: pdeitel/CPlusPlus20FundamentalsLiveLessons
Branch: master
Commit: 555893304801
Files: 1954
Total size: 18.9 MB

Directory structure:
gitextract_ns33kz0v/

├── README.md
└── examples/
    ├── docker/
    │   └── gcc13/
    │       └── dockerfile
    ├── lesson01/
    │   └── GuessNumber.cpp
    ├── lesson02/
    │   ├── fig02_01.cpp
    │   ├── fig02_02.cpp
    │   ├── fig02_03.cpp
    │   ├── fig02_04.cpp
    │   ├── fig02_05.cpp
    │   └── fig02_06.cpp
    ├── lesson03/
    │   ├── fig03_01.cpp
    │   ├── fig03_02.cpp
    │   ├── fig03_03.cpp
    │   ├── fig03_04.cpp
    │   └── fig03_05.cpp
    ├── lesson04/
    │   ├── decimalformatter.h
    │   ├── decimalformatter_fmt.h
    │   ├── ex04_06.cpp
    │   ├── fig04_01.cpp
    │   ├── fig04_02.cpp
    │   ├── fig04_03.cpp
    │   ├── fig04_03fmt.cpp
    │   ├── fig04_04.cpp
    │   ├── fig04_04fmt.cpp
    │   ├── fig04_05.cpp
    │   ├── fig04_06.cpp
    │   ├── fig04_06fmt.cpp
    │   ├── fig04_07.cpp
    │   ├── fig04_07_with_error.cpp
    │   ├── fig04_07fmt.cpp
    │   ├── fig04_08.cpp
    │   ├── fig04_09.cpp
    │   ├── fig04_10.cpp
    │   ├── fig04_11.cpp
    │   ├── fig04_12/
    │   │   ├── fig04_12.cpp
    │   │   ├── fmt/
    │   │   │   ├── core.h
    │   │   │   ├── format-inl.h
    │   │   │   └── format.h
    │   │   └── format.cc
    │   ├── fig04_17.cpp
    │   └── fig04_17fmt.cpp
    ├── lesson05/
    │   ├── cipher.h
    │   ├── ex05_31.cpp
    │   ├── fig05_01.cpp
    │   ├── fig05_02.cpp
    │   ├── fig05_03.cpp
    │   ├── fig05_04.cpp
    │   ├── fig05_05.cpp
    │   ├── fig05_06.cpp
    │   ├── fig05_07.cpp
    │   ├── fig05_08.cpp
    │   ├── fig05_09.cpp
    │   ├── fig05_10.cpp
    │   ├── fig05_11.cpp
    │   ├── fig05_12.cpp
    │   ├── fig05_13.cpp
    │   ├── fig05_14.cpp
    │   ├── fig05_15.cpp
    │   ├── fig05_16.cpp
    │   ├── fig05_17.cpp
    │   ├── fig05_18.cpp
    │   ├── fig05_19.cpp
    │   ├── fig05_20.cpp
    │   └── maximum.h
    ├── lesson06/
    │   ├── fig06_01.cpp
    │   ├── fig06_02.cpp
    │   ├── fig06_03.cpp
    │   ├── fig06_04.cpp
    │   ├── fig06_05.cpp
    │   ├── fig06_06.cpp
    │   ├── fig06_07.cpp
    │   ├── fig06_08.cpp
    │   ├── fig06_09.cpp
    │   ├── fig06_10.cpp
    │   ├── fig06_11.cpp
    │   ├── fig06_12.cpp
    │   ├── fig06_13.cpp
    │   └── fig06_14.cpp
    ├── lesson07/
    │   ├── fig07_01.cpp
    │   ├── fig07_02.cpp
    │   ├── fig07_03.cpp
    │   ├── fig07_06.cpp
    │   ├── fig07_07.cpp
    │   ├── fig07_08.cpp
    │   ├── fig07_09.cpp
    │   ├── fig07_10.cpp
    │   ├── fig07_11.cpp
    │   ├── fig07_12.cpp
    │   ├── fig07_13.cpp
    │   └── fig07_14.cpp
    ├── lesson08/
    │   ├── accounts.csv
    │   ├── fig08_01.cpp
    │   ├── fig08_02.cpp
    │   ├── fig08_03.cpp
    │   ├── fig08_04.cpp
    │   ├── fig08_05.cpp
    │   ├── fig08_06.cpp
    │   ├── fig08_07.cpp
    │   ├── fig08_08.cpp
    │   ├── fig08_09.cpp
    │   ├── fig08_10.cpp
    │   ├── fig08_11.cpp
    │   ├── fig08_12.cpp
    │   ├── fig08_13.cpp
    │   ├── fig08_14.cpp
    │   ├── fig08_15.cpp
    │   ├── fig08_16.cpp
    │   ├── fig08_17.cpp
    │   ├── fig08_18.cpp
    │   ├── format.cc
    │   └── titanic.csv
    ├── lesson09/
    │   ├── fig09_01-02/
    │   │   ├── Account.h
    │   │   └── AccountTest.cpp
    │   ├── fig09_03-04/
    │   │   ├── Account.h
    │   │   └── AccountTest.cpp
    │   ├── fig09_05-06/
    │   │   ├── Account.h
    │   │   └── AccountTest.cpp
    │   ├── fig09_07-09/
    │   │   ├── Time.cpp
    │   │   ├── Time.h
    │   │   └── fig09_09.cpp
    │   ├── fig09_10-12/
    │   │   ├── Time.cpp
    │   │   ├── Time.h
    │   │   └── fig09_12.cpp
    │   ├── fig09_13-15/
    │   │   ├── CreateAndDestroy.cpp
    │   │   ├── CreateAndDestroy.h
    │   │   └── fig09_15.cpp
    │   ├── fig09_16-18/
    │   │   ├── Time.cpp
    │   │   ├── Time.h
    │   │   └── fig09_18.cpp
    │   ├── fig09_19-21/
    │   │   ├── Date.cpp
    │   │   ├── Date.h
    │   │   └── fig09_21.cpp
    │   ├── fig09_22/
    │   │   ├── Time.cpp
    │   │   ├── Time.h
    │   │   └── fig09_22.cpp
    │   ├── fig09_23-27/
    │   │   ├── Date.cpp
    │   │   ├── Date.h
    │   │   ├── Employee.cpp
    │   │   ├── Employee.h
    │   │   └── fig09_27.cpp
    │   ├── fig09_28/
    │   │   └── fig09_28.cpp
    │   ├── fig09_29/
    │   │   └── fig09_29.cpp
    │   ├── fig09_30-32/
    │   │   ├── Time.cpp
    │   │   ├── Time.h
    │   │   └── fig09_32.cpp
    │   ├── fig09_33-35/
    │   │   ├── Employee.cpp
    │   │   ├── Employee.h
    │   │   └── fig09_35.cpp
    │   ├── fig09_36-37/
    │   │   ├── cipher.h
    │   │   └── fig09_36.cpp
    │   └── fig09_38/
    │       ├── fig09_38.cpp
    │       └── records.json
    ├── lesson10/
    │   ├── fig10_01-03/
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_03.cpp
    │   ├── fig10_04-06/
    │   │   ├── SalariedCommissionEmployee.cpp
    │   │   ├── SalariedCommissionEmployee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_06.cpp
    │   ├── fig10_07/
    │   │   ├── SalariedCommissionEmployee.cpp
    │   │   ├── SalariedCommissionEmployee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_07.cpp
    │   ├── fig10_08/
    │   │   ├── SalariedCommissionEmployee.cpp
    │   │   ├── SalariedCommissionEmployee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_08.cpp
    │   ├── fig10_09/
    │   │   ├── SalariedCommissionEmployee.cpp
    │   │   ├── SalariedCommissionEmployee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_09.cpp
    │   ├── fig10_10/
    │   │   ├── SalariedCommissionEmployee.cpp
    │   │   ├── SalariedCommissionEmployee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_10.cpp
    │   ├── fig10_11-17/
    │   │   ├── CommissionEmployee.cpp
    │   │   ├── CommissionEmployee.h
    │   │   ├── Employee.cpp
    │   │   ├── Employee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig10_17.cpp
    │   └── fig10_19-26/
    │       ├── Commission.cpp
    │       ├── Commission.h
    │       ├── CompensationModel.h
    │       ├── Employee.cpp
    │       ├── Employee.h
    │       ├── Salaried.cpp
    │       ├── Salaried.h
    │       └── fig10_26.cpp
    ├── lesson11/
    │   ├── fig11_01/
    │   │   └── fig11_01.cpp
    │   ├── fig11_02/
    │   │   └── fig11_02.cpp
    │   ├── fig11_03-05/
    │   │   ├── MyArray.cpp
    │   │   ├── MyArray.h
    │   │   ├── a.out
    │   │   └── fig11_03.cpp
    │   ├── fig11_06/
    │   │   └── fig11_06.cpp
    │   ├── fig11_07/
    │   │   ├── MyArray.cpp
    │   │   ├── MyArray.h
    │   │   └── fig11_07.cpp
    │   └── fig11_08/
    │       ├── MyArray.cpp
    │       ├── MyArray.h
    │       └── fig11_08.cpp
    ├── lesson12/
    │   ├── fig12_01-02/
    │   │   ├── DivideByZeroException.h
    │   │   └── fig12_02.cpp
    │   ├── fig12_03/
    │   │   └── fig12_03.cpp
    │   ├── fig12_04/
    │   │   ├── fig12_04.cpp
    │   │   └── fig12_04modified.cpp
    │   ├── fig12_05/
    │   │   └── fig12_05.cpp
    │   ├── fig12_06/
    │   │   └── fig12_06.cpp
    │   ├── fig12_07/
    │   │   └── fig12_07.cpp
    │   ├── fig12_08/
    │   │   └── fig12_08.cpp
    │   └── fig12_09/
    │       └── fig12_09.cpp
    ├── lesson13/
    │   ├── fig13_01.cpp
    │   ├── fig13_02.cpp
    │   ├── fig13_03.cpp
    │   ├── fig13_04.cpp
    │   ├── fig13_05.cpp
    │   ├── fig13_06.cpp
    │   ├── fig13_07.cpp
    │   ├── fig13_08.cpp
    │   ├── fig13_09.cpp
    │   ├── fig13_10.cpp
    │   ├── fig13_11.cpp
    │   └── fig13_12.cpp
    ├── lesson14/
    │   ├── fig14_01.cpp
    │   ├── fig14_02.cpp
    │   ├── fig14_03.cpp
    │   ├── fig14_04.cpp
    │   ├── fig14_05.cpp
    │   ├── fig14_06.cpp
    │   ├── fig14_07.cpp
    │   ├── fig14_08.cpp
    │   ├── fig14_09.cpp
    │   ├── fig14_10.cpp
    │   ├── fig14_11.cpp
    │   ├── fig14_12.cpp
    │   ├── fig14_13.cpp
    │   ├── fig14_14.cpp
    │   ├── fig14_15.cpp
    │   ├── fig14_16.cpp
    │   ├── fig14_17.cpp
    │   └── fig14_18.cpp
    ├── lesson15/
    │   ├── fig15_01-02/
    │   │   ├── Stack.h
    │   │   └── fig15_02.cpp
    │   ├── fig15_03.cpp
    │   ├── fig15_04.cpp
    │   ├── fig15_05.cpp
    │   ├── fig15_06.cpp
    │   ├── fig15_07.cpp
    │   ├── fig15_08.cpp
    │   ├── fig15_09.cpp
    │   ├── fig15_10.cpp
    │   ├── fig15_11-12/
    │   │   ├── MyArray.h
    │   │   ├── fig15_12.cpp
    │   │   └── sorttest.cpp
    │   ├── fig15_13.cpp
    │   ├── fig15_14.cpp
    │   ├── fig15_15.cpp
    │   ├── fig15_16.cpp
    │   ├── fig15_17.cpp
    │   ├── fig15_18.cpp
    │   ├── fig15_19.cpp
    │   ├── fig15_20.cpp
    │   └── fig15_21.cpp
    ├── lesson16/
    │   ├── compilation_commands.txt
    │   ├── fig16_01/
    │   │   └── fig16_01.cpp
    │   ├── fig16_02-03/
    │   │   ├── fig16_03.cpp
    │   │   └── welcome.ixx
    │   ├── fig16_04-05/
    │   │   ├── deitel.math.ixx
    │   │   └── fig16_05.cpp
    │   ├── fig16_06-08/
    │   │   ├── deitel.math-impl.cpp
    │   │   ├── deitel.math.ixx
    │   │   └── fig16_08.cpp
    │   ├── fig16_09-11/
    │   │   ├── deitel.time-impl.cpp
    │   │   ├── deitel.time.ixx
    │   │   └── fig16_11.cpp
    │   ├── fig16_12-15/
    │   │   ├── deitel.math-powers.ixx
    │   │   ├── deitel.math-roots.ixx
    │   │   ├── deitel.math.ixx
    │   │   └── fig16_15.cpp
    │   ├── fig16_12-15clang/
    │   │   ├── deitel.math-powers.ixx
    │   │   ├── deitel.math-roots.ixx
    │   │   ├── deitel.math.ixx
    │   │   └── fig16_15.cpp
    │   ├── fig16_16-21/
    │   │   ├── deitel.math.ixx
    │   │   ├── deitel.math.powers.ixx
    │   │   ├── deitel.math.roots.ixx
    │   │   ├── fig16_17.cpp
    │   │   ├── fig16_19.cpp
    │   │   └── fig16_21.cpp
    │   ├── fig16_16-21clang/
    │   │   ├── deitel.math.ixx
    │   │   ├── deitel.math.powers.ixx
    │   │   ├── deitel.math.roots.ixx
    │   │   ├── fig16_17.cpp
    │   │   ├── fig16_19.cpp
    │   │   └── fig16_21.cpp
    │   ├── fig16_22/
    │   │   └── fig16_22.cpp
    │   ├── fig16_23-24/
    │   │   ├── moduleA.ixx
    │   │   └── moduleB.ixx
    │   ├── fig16_25-27/
    │   │   ├── fig16_27.cpp
    │   │   ├── moduleA.ixx
    │   │   └── moduleB.ixx
    │   └── fig16_28-29/
    │       ├── deitel.time-impl.cpp
    │       ├── deitel.time.ixx
    │       └── fig16_29.cpp
    ├── lesson17/
    │   ├── fig17_01/
    │   │   └── fig17_01.cpp
    │   ├── fig17_02/
    │   │   └── fig17_02.cpp
    │   ├── fig17_03-04/
    │   │   ├── printtask.cpp
    │   │   └── printtask.h
    │   ├── fig17_05-06/
    │   │   ├── SharedBufferTest.cpp
    │   │   └── UnsynchronizedBuffer.h
    │   ├── fig17_07-08/
    │   │   ├── SharedBufferTest.cpp
    │   │   └── SynchronizedBuffer.h
    │   ├── fig17_09-10/
    │   │   ├── CircularBuffer.h
    │   │   └── SharedBufferTest.cpp
    │   ├── fig17_11/
    │   │   ├── CooperativeCancelation.cpp
    │   │   └── CooperativeCancelationFMT.cpp
    │   ├── fig17_12/
    │   │   ├── async.cpp
    │   │   ├── async.o
    │   │   └── format.o
    │   ├── fig17_13/
    │   │   └── atomic.cpp
    │   ├── fig17_14/
    │   │   └── LatchDemo.cpp
    │   ├── fig17_15/
    │   │   └── BarrierDemo.cpp
    │   └── fig17_16/
    │       ├── SharedBufferTest.cpp
    │       └── SynchronizedBuffer.h
    ├── lesson18/
    │   ├── fig18_01.cpp
    │   ├── fig18_02.cpp
    │   ├── fig18_03.cpp
    │   └── vcpkg.json
    ├── lesson19/
    │   ├── fig19_01.cpp
    │   ├── fig19_02.cpp
    │   ├── fig19_03.cpp
    │   ├── fig19_04.cpp
    │   ├── fig19_05.cpp
    │   ├── fig19_06.cpp
    │   ├── fig19_07.cpp
    │   ├── fig19_08.cpp
    │   ├── fig19_09.cpp
    │   ├── fig19_10.cpp
    │   ├── fig19_11.cpp
    │   ├── fig19_12.cpp
    │   ├── fig19_13.cpp
    │   ├── fig19_14.cpp
    │   ├── fig19_15.cpp
    │   ├── fig19_16.cpp
    │   ├── fig19_17.cpp
    │   ├── fig19_18.cpp
    │   ├── fig19_19.cpp
    │   ├── fig19_20.cpp
    │   ├── fig19_21.cpp
    │   ├── fig19_22.cpp
    │   └── fig19_23.cpp
    ├── lesson20/
    │   ├── fig20_01.cpp
    │   ├── fig20_02.cpp
    │   ├── fig20_03.cpp
    │   ├── fig20_04.cpp
    │   ├── fig20_05.cpp
    │   ├── fig20_06/
    │   │   ├── CommissionEmployee.cpp
    │   │   ├── CommissionEmployee.h
    │   │   ├── Employee.cpp
    │   │   ├── Employee.h
    │   │   ├── SalariedEmployee.cpp
    │   │   ├── SalariedEmployee.h
    │   │   └── fig20_06.cpp
    │   ├── fig20_07.cpp
    │   ├── fig20_08.cpp
    │   ├── fig20_09-13/
    │   │   ├── Author.cpp
    │   │   ├── Author.h
    │   │   ├── Book.cpp
    │   │   ├── Book.h
    │   │   └── fig20_13.cpp
    │   └── fig20_14.cpp
    ├── libraries/
    │   ├── BigNumber/
    │   │   ├── CMakeLists.txt
    │   │   ├── LICENSE.md
    │   │   ├── README.md
    │   │   ├── bin/
    │   │   │   └── BigNumber/
    │   │   │       ├── include/
    │   │   │       │   └── bignumber.h
    │   │   │       └── lib/
    │   │   │           └── libBigNumber.a
    │   │   ├── main.cpp
    │   │   └── src/
    │   │       ├── bignumber.cpp
    │   │       └── bignumber.h
    │   ├── GSL/
    │   │   ├── .clang-format
    │   │   ├── .github/
    │   │   │   └── workflows/
    │   │   │       └── main.yml
    │   │   ├── .gitignore
    │   │   ├── .travis.yml
    │   │   ├── CMakeLists.txt
    │   │   ├── CMakeSettings.json
    │   │   ├── CONTRIBUTING.md
    │   │   ├── GSL.natvis
    │   │   ├── LICENSE
    │   │   ├── README.md
    │   │   ├── ThirdPartyNotices.txt
    │   │   ├── appveyor.yml
    │   │   ├── include/
    │   │   │   └── gsl/
    │   │   │       ├── gsl
    │   │   │       ├── gsl_algorithm
    │   │   │       ├── gsl_assert
    │   │   │       ├── gsl_byte
    │   │   │       ├── gsl_util
    │   │   │       ├── multi_span
    │   │   │       ├── pointers
    │   │   │       ├── span
    │   │   │       ├── span_ext
    │   │   │       └── string_span
    │   │   └── tests/
    │   │       ├── CMakeLists.txt
    │   │       ├── CMakeLists.txt.in
    │   │       ├── algorithm_tests.cpp
    │   │       ├── assertion_tests.cpp
    │   │       ├── at_tests.cpp
    │   │       ├── bounds_tests.cpp
    │   │       ├── byte_tests.cpp
    │   │       ├── multi_span_tests.cpp
    │   │       ├── no_exception_ensure_tests.cpp
    │   │       ├── notnull_tests.cpp
    │   │       ├── owner_tests.cpp
    │   │       ├── span_compatibility_tests.cpp
    │   │       ├── span_ext_tests.cpp
    │   │       ├── span_tests.cpp
    │   │       ├── strict_notnull_tests.cpp
    │   │       ├── strided_span_tests.cpp
    │   │       ├── string_span_tests.cpp
    │   │       └── utils_tests.cpp
    │   ├── cereal-1.3.0/
    │   │   ├── .gitignore
    │   │   ├── .travis.yml
    │   │   ├── CMakeLists.txt
    │   │   ├── LICENSE
    │   │   ├── README.md
    │   │   ├── appveyor.yml
    │   │   ├── doc/
    │   │   │   ├── CMakeLists.txt
    │   │   │   ├── DoxygenLayout.xml
    │   │   │   ├── doxygen.in
    │   │   │   ├── footer.html
    │   │   │   └── mainpage.dox
    │   │   ├── include/
    │   │   │   └── cereal/
    │   │   │       ├── access.hpp
    │   │   │       ├── archives/
    │   │   │       │   ├── adapters.hpp
    │   │   │       │   ├── binary.hpp
    │   │   │       │   ├── json.hpp
    │   │   │       │   ├── portable_binary.hpp
    │   │   │       │   └── xml.hpp
    │   │   │       ├── cereal.hpp
    │   │   │       ├── details/
    │   │   │       │   ├── helpers.hpp
    │   │   │       │   ├── polymorphic_impl.hpp
    │   │   │       │   ├── polymorphic_impl_fwd.hpp
    │   │   │       │   ├── static_object.hpp
    │   │   │       │   ├── traits.hpp
    │   │   │       │   └── util.hpp
    │   │   │       ├── external/
    │   │   │       │   ├── base64.hpp
    │   │   │       │   ├── rapidjson/
    │   │   │       │   │   ├── allocators.h
    │   │   │       │   │   ├── cursorstreamwrapper.h
    │   │   │       │   │   ├── document.h
    │   │   │       │   │   ├── encodedstream.h
    │   │   │       │   │   ├── encodings.h
    │   │   │       │   │   ├── error/
    │   │   │       │   │   │   ├── en.h
    │   │   │       │   │   │   └── error.h
    │   │   │       │   │   ├── filereadstream.h
    │   │   │       │   │   ├── filewritestream.h
    │   │   │       │   │   ├── fwd.h
    │   │   │       │   │   ├── internal/
    │   │   │       │   │   │   ├── biginteger.h
    │   │   │       │   │   │   ├── diyfp.h
    │   │   │       │   │   │   ├── dtoa.h
    │   │   │       │   │   │   ├── ieee754.h
    │   │   │       │   │   │   ├── itoa.h
    │   │   │       │   │   │   ├── meta.h
    │   │   │       │   │   │   ├── pow10.h
    │   │   │       │   │   │   ├── regex.h
    │   │   │       │   │   │   ├── stack.h
    │   │   │       │   │   │   ├── strfunc.h
    │   │   │       │   │   │   ├── strtod.h
    │   │   │       │   │   │   └── swap.h
    │   │   │       │   │   ├── istreamwrapper.h
    │   │   │       │   │   ├── memorybuffer.h
    │   │   │       │   │   ├── memorystream.h
    │   │   │       │   │   ├── msinttypes/
    │   │   │       │   │   │   ├── inttypes.h
    │   │   │       │   │   │   └── stdint.h
    │   │   │       │   │   ├── ostreamwrapper.h
    │   │   │       │   │   ├── pointer.h
    │   │   │       │   │   ├── prettywriter.h
    │   │   │       │   │   ├── rapidjson.h
    │   │   │       │   │   ├── reader.h
    │   │   │       │   │   ├── schema.h
    │   │   │       │   │   ├── stream.h
    │   │   │       │   │   ├── stringbuffer.h
    │   │   │       │   │   └── writer.h
    │   │   │       │   └── rapidxml/
    │   │   │       │       ├── license.txt
    │   │   │       │       ├── manual.html
    │   │   │       │       ├── rapidxml.hpp
    │   │   │       │       ├── rapidxml_iterators.hpp
    │   │   │       │       ├── rapidxml_print.hpp
    │   │   │       │       └── rapidxml_utils.hpp
    │   │   │       ├── macros.hpp
    │   │   │       ├── specialize.hpp
    │   │   │       ├── types/
    │   │   │       │   ├── array.hpp
    │   │   │       │   ├── atomic.hpp
    │   │   │       │   ├── base_class.hpp
    │   │   │       │   ├── bitset.hpp
    │   │   │       │   ├── boost_variant.hpp
    │   │   │       │   ├── chrono.hpp
    │   │   │       │   ├── common.hpp
    │   │   │       │   ├── complex.hpp
    │   │   │       │   ├── concepts/
    │   │   │       │   │   └── pair_associative_container.hpp
    │   │   │       │   ├── deque.hpp
    │   │   │       │   ├── forward_list.hpp
    │   │   │       │   ├── functional.hpp
    │   │   │       │   ├── list.hpp
    │   │   │       │   ├── map.hpp
    │   │   │       │   ├── memory.hpp
    │   │   │       │   ├── optional.hpp
    │   │   │       │   ├── polymorphic.hpp
    │   │   │       │   ├── queue.hpp
    │   │   │       │   ├── set.hpp
    │   │   │       │   ├── stack.hpp
    │   │   │       │   ├── string.hpp
    │   │   │       │   ├── tuple.hpp
    │   │   │       │   ├── unordered_map.hpp
    │   │   │       │   ├── unordered_set.hpp
    │   │   │       │   ├── utility.hpp
    │   │   │       │   ├── valarray.hpp
    │   │   │       │   ├── variant.hpp
    │   │   │       │   └── vector.hpp
    │   │   │       └── version.hpp
    │   │   ├── sandbox/
    │   │   │   ├── CMakeLists.txt
    │   │   │   ├── performance.cpp
    │   │   │   ├── sandbox.cpp
    │   │   │   ├── sandbox_json.cpp
    │   │   │   ├── sandbox_rtti.cpp
    │   │   │   ├── sandbox_shared_lib/
    │   │   │   │   ├── CMakeLists.txt
    │   │   │   │   ├── base.cpp
    │   │   │   │   ├── base.hpp
    │   │   │   │   ├── derived.cpp
    │   │   │   │   └── derived.hpp
    │   │   │   └── sandbox_vs.cpp
    │   │   ├── scripts/
    │   │   │   ├── add_rapidjson_prefix.sh
    │   │   │   ├── appveyor.bat
    │   │   │   ├── renameincludes.sh
    │   │   │   ├── updatecoverage.sh
    │   │   │   └── updatedoc.in
    │   │   └── unittests/
    │   │       ├── CMakeLists.txt
    │   │       ├── array.cpp
    │   │       ├── array.hpp
    │   │       ├── atomic.cpp
    │   │       ├── atomic.hpp
    │   │       ├── basic_string.cpp
    │   │       ├── basic_string.hpp
    │   │       ├── bitset.cpp
    │   │       ├── bitset.hpp
    │   │       ├── boost/
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── boost_variant.cpp
    │   │       │   └── boost_variant.hpp
    │   │       ├── chrono.cpp
    │   │       ├── chrono.hpp
    │   │       ├── cmake-config-module.cmake
    │   │       ├── common.hpp
    │   │       ├── complex.cpp
    │   │       ├── complex.hpp
    │   │       ├── cpp17/
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── optional.cpp
    │   │       │   ├── optional.hpp
    │   │       │   ├── variant.cpp
    │   │       │   └── variant.hpp
    │   │       ├── defer.cpp
    │   │       ├── defer.hpp
    │   │       ├── deque.cpp
    │   │       ├── deque.hpp
    │   │       ├── doctest.h
    │   │       ├── forward_list.cpp
    │   │       ├── forward_list.hpp
    │   │       ├── list.cpp
    │   │       ├── list.hpp
    │   │       ├── load_construct.cpp
    │   │       ├── load_construct.hpp
    │   │       ├── map.cpp
    │   │       ├── map.hpp
    │   │       ├── memory.cpp
    │   │       ├── memory.hpp
    │   │       ├── memory_cycles.cpp
    │   │       ├── memory_cycles.hpp
    │   │       ├── multimap.cpp
    │   │       ├── multimap.hpp
    │   │       ├── multiset.cpp
    │   │       ├── multiset.hpp
    │   │       ├── pair.cpp
    │   │       ├── pair.hpp
    │   │       ├── pod.cpp
    │   │       ├── pod.hpp
    │   │       ├── polymorphic.cpp
    │   │       ├── polymorphic.hpp
    │   │       ├── portability_test.cpp
    │   │       ├── portable_binary_archive.cpp
    │   │       ├── portable_binary_archive.hpp
    │   │       ├── priority_queue.cpp
    │   │       ├── priority_queue.hpp
    │   │       ├── queue.cpp
    │   │       ├── queue.hpp
    │   │       ├── run_portability_test.cmake
    │   │       ├── run_valgrind.sh
    │   │       ├── set.cpp
    │   │       ├── set.hpp
    │   │       ├── stack.cpp
    │   │       ├── stack.hpp
    │   │       ├── structs.cpp
    │   │       ├── structs.hpp
    │   │       ├── structs_minimal.cpp
    │   │       ├── structs_minimal.hpp
    │   │       ├── structs_specialized.cpp
    │   │       ├── structs_specialized.hpp
    │   │       ├── tuple.cpp
    │   │       ├── tuple.hpp
    │   │       ├── unordered_loads.cpp
    │   │       ├── unordered_loads.hpp
    │   │       ├── unordered_map.cpp
    │   │       ├── unordered_map.hpp
    │   │       ├── unordered_multimap.cpp
    │   │       ├── unordered_multimap.hpp
    │   │       ├── unordered_multiset.cpp
    │   │       ├── unordered_multiset.hpp
    │   │       ├── unordered_set.cpp
    │   │       ├── unordered_set.hpp
    │   │       ├── user_data_adapters.cpp
    │   │       ├── user_data_adapters.hpp
    │   │       ├── valarray.cpp
    │   │       ├── valarray.hpp
    │   │       ├── vector.cpp
    │   │       ├── vector.hpp
    │   │       ├── versioning.cpp
    │   │       └── versioning.hpp
    │   ├── fmt/
    │   │   ├── .clang-format
    │   │   ├── .github/
    │   │   │   ├── pull_request_template.md
    │   │   │   └── workflows/
    │   │   │       ├── doc.yml
    │   │   │       ├── linux.yml
    │   │   │       ├── macos.yml
    │   │   │       └── windows.yml
    │   │   ├── .gitignore
    │   │   ├── CMakeLists.txt
    │   │   ├── CONTRIBUTING.md
    │   │   ├── ChangeLog.rst
    │   │   ├── LICENSE.rst
    │   │   ├── README.rst
    │   │   ├── doc/
    │   │   │   ├── CMakeLists.txt
    │   │   │   ├── _static/
    │   │   │   │   └── breathe.css
    │   │   │   ├── _templates/
    │   │   │   │   ├── layout.html
    │   │   │   │   └── search.html
    │   │   │   ├── api.rst
    │   │   │   ├── basic-bootstrap/
    │   │   │   │   ├── README
    │   │   │   │   ├── layout.html
    │   │   │   │   └── theme.conf
    │   │   │   ├── bootstrap/
    │   │   │   │   ├── alerts.less
    │   │   │   │   ├── badges.less
    │   │   │   │   ├── bootstrap.less
    │   │   │   │   ├── breadcrumbs.less
    │   │   │   │   ├── button-groups.less
    │   │   │   │   ├── buttons.less
    │   │   │   │   ├── carousel.less
    │   │   │   │   ├── close.less
    │   │   │   │   ├── code.less
    │   │   │   │   ├── component-animations.less
    │   │   │   │   ├── dropdowns.less
    │   │   │   │   ├── forms.less
    │   │   │   │   ├── glyphicons.less
    │   │   │   │   ├── grid.less
    │   │   │   │   ├── input-groups.less
    │   │   │   │   ├── jumbotron.less
    │   │   │   │   ├── labels.less
    │   │   │   │   ├── list-group.less
    │   │   │   │   ├── media.less
    │   │   │   │   ├── mixins/
    │   │   │   │   │   ├── alerts.less
    │   │   │   │   │   ├── background-variant.less
    │   │   │   │   │   ├── border-radius.less
    │   │   │   │   │   ├── buttons.less
    │   │   │   │   │   ├── center-block.less
    │   │   │   │   │   ├── clearfix.less
    │   │   │   │   │   ├── forms.less
    │   │   │   │   │   ├── gradients.less
    │   │   │   │   │   ├── grid-framework.less
    │   │   │   │   │   ├── grid.less
    │   │   │   │   │   ├── hide-text.less
    │   │   │   │   │   ├── image.less
    │   │   │   │   │   ├── labels.less
    │   │   │   │   │   ├── list-group.less
    │   │   │   │   │   ├── nav-divider.less
    │   │   │   │   │   ├── nav-vertical-align.less
    │   │   │   │   │   ├── opacity.less
    │   │   │   │   │   ├── pagination.less
    │   │   │   │   │   ├── panels.less
    │   │   │   │   │   ├── progress-bar.less
    │   │   │   │   │   ├── reset-filter.less
    │   │   │   │   │   ├── resize.less
    │   │   │   │   │   ├── responsive-visibility.less
    │   │   │   │   │   ├── size.less
    │   │   │   │   │   ├── tab-focus.less
    │   │   │   │   │   ├── table-row.less
    │   │   │   │   │   ├── text-emphasis.less
    │   │   │   │   │   ├── text-overflow.less
    │   │   │   │   │   └── vendor-prefixes.less
    │   │   │   │   ├── mixins.less
    │   │   │   │   ├── modals.less
    │   │   │   │   ├── navbar.less
    │   │   │   │   ├── navs.less
    │   │   │   │   ├── normalize.less
    │   │   │   │   ├── pager.less
    │   │   │   │   ├── pagination.less
    │   │   │   │   ├── panels.less
    │   │   │   │   ├── popovers.less
    │   │   │   │   ├── print.less
    │   │   │   │   ├── progress-bars.less
    │   │   │   │   ├── responsive-embed.less
    │   │   │   │   ├── responsive-utilities.less
    │   │   │   │   ├── scaffolding.less
    │   │   │   │   ├── tables.less
    │   │   │   │   ├── theme.less
    │   │   │   │   ├── thumbnails.less
    │   │   │   │   ├── tooltip.less
    │   │   │   │   ├── type.less
    │   │   │   │   ├── utilities.less
    │   │   │   │   ├── variables.less
    │   │   │   │   └── wells.less
    │   │   │   ├── build.py
    │   │   │   ├── conf.py
    │   │   │   ├── contents.rst
    │   │   │   ├── fmt.less
    │   │   │   ├── index.rst
    │   │   │   ├── python-license.txt
    │   │   │   ├── syntax.rst
    │   │   │   └── usage.rst
    │   │   ├── include/
    │   │   │   └── fmt/
    │   │   │       ├── args.h
    │   │   │       ├── chrono.h
    │   │   │       ├── color.h
    │   │   │       ├── compile.h
    │   │   │       ├── core.h
    │   │   │       ├── format-inl.h
    │   │   │       ├── format.h
    │   │   │       ├── locale.h
    │   │   │       ├── os.h
    │   │   │       ├── ostream.h
    │   │   │       ├── printf.h
    │   │   │       ├── ranges.h
    │   │   │       └── xchar.h
    │   │   ├── src/
    │   │   │   ├── fmt.cc
    │   │   │   ├── format.cc
    │   │   │   └── os.cc
    │   │   ├── support/
    │   │   │   ├── Android.mk
    │   │   │   ├── AndroidManifest.xml
    │   │   │   ├── C++.sublime-syntax
    │   │   │   ├── README
    │   │   │   ├── Vagrantfile
    │   │   │   ├── appveyor-build.py
    │   │   │   ├── appveyor.yml
    │   │   │   ├── build-docs.py
    │   │   │   ├── build.gradle
    │   │   │   ├── cmake/
    │   │   │   │   ├── FindSetEnv.cmake
    │   │   │   │   ├── JoinPaths.cmake
    │   │   │   │   ├── cxx14.cmake
    │   │   │   │   ├── fmt-config.cmake.in
    │   │   │   │   └── fmt.pc.in
    │   │   │   ├── compute-powers.py
    │   │   │   ├── docopt.py
    │   │   │   ├── manage.py
    │   │   │   ├── rst2md.py
    │   │   │   └── rtd/
    │   │   │       ├── conf.py
    │   │   │       ├── index.rst
    │   │   │       └── theme/
    │   │   │           ├── layout.html
    │   │   │           └── theme.conf
    │   │   └── test/
    │   │       ├── CMakeLists.txt
    │   │       ├── add-subdirectory-test/
    │   │       │   ├── CMakeLists.txt
    │   │       │   └── main.cc
    │   │       ├── args-test.cc
    │   │       ├── assert-test.cc
    │   │       ├── chrono-test.cc
    │   │       ├── color-test.cc
    │   │       ├── compile-error-test/
    │   │       │   └── CMakeLists.txt
    │   │       ├── compile-test.cc
    │   │       ├── core-test.cc
    │   │       ├── cuda-test/
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── cpp14.cc
    │   │       │   └── cuda-cpp14.cu
    │   │       ├── enforce-checks-test.cc
    │   │       ├── find-package-test/
    │   │       │   ├── CMakeLists.txt
    │   │       │   └── main.cc
    │   │       ├── format
    │   │       ├── format-impl-test.cc
    │   │       ├── format-test.cc
    │   │       ├── fuzzing/
    │   │       │   ├── .gitignore
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── README.md
    │   │       │   ├── build.sh
    │   │       │   ├── chrono-duration.cc
    │   │       │   ├── float.cc
    │   │       │   ├── fuzzer-common.h
    │   │       │   ├── main.cc
    │   │       │   ├── named-arg.cc
    │   │       │   ├── one-arg.cc
    │   │       │   └── two-args.cc
    │   │       ├── gtest/
    │   │       │   ├── .clang-format
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── gmock/
    │   │       │   │   └── gmock.h
    │   │       │   ├── gmock-gtest-all.cc
    │   │       │   └── gtest/
    │   │       │       ├── gtest-spi.h
    │   │       │       └── gtest.h
    │   │       ├── gtest-extra-test.cc
    │   │       ├── gtest-extra.cc
    │   │       ├── gtest-extra.h
    │   │       ├── header-only-test.cc
    │   │       ├── mock-allocator.h
    │   │       ├── module-test.cc
    │   │       ├── os-test.cc
    │   │       ├── ostream-test.cc
    │   │       ├── posix-mock-test.cc
    │   │       ├── posix-mock.h
    │   │       ├── printf-test.cc
    │   │       ├── ranges-test.cc
    │   │       ├── scan-test.cc
    │   │       ├── scan.h
    │   │       ├── static-export-test/
    │   │       │   ├── CMakeLists.txt
    │   │       │   ├── library.cc
    │   │       │   └── main.cc
    │   │       ├── std-format-test.cc
    │   │       ├── test-assert.h
    │   │       ├── test-main.cc
    │   │       ├── unicode-test.cc
    │   │       ├── util.cc
    │   │       ├── util.h
    │   │       └── xchar-test.cc
    │   ├── multiprecision-Boost_1_81_0/
    │   │   ├── .circleci/
    │   │   │   └── config.yml
    │   │   ├── .clang-format
    │   │   ├── .drone/
    │   │   │   ├── after-success.sh
    │   │   │   ├── before-install.sh
    │   │   │   ├── before-script.sh
    │   │   │   └── boost.sh
    │   │   ├── .drone.star
    │   │   ├── .gitattributes
    │   │   ├── .github/
    │   │   │   └── workflows/
    │   │   │       └── multiprecision.yml
    │   │   ├── .gitignore
    │   │   ├── CMakeLists.txt
    │   │   ├── LICENSE
    │   │   ├── README.md
    │   │   ├── config/
    │   │   │   ├── Jamfile.v2
    │   │   │   ├── has_big_obj.cpp
    │   │   │   ├── has_constexpr_limits_cmd.cpp
    │   │   │   ├── has_eigen.cpp
    │   │   │   ├── has_f2c.cpp
    │   │   │   ├── has_float128.cpp
    │   │   │   ├── has_gmp.cpp
    │   │   │   ├── has_intel_quad.cpp
    │   │   │   ├── has_is_constant_evaluated.cpp
    │   │   │   ├── has_mpc.cpp
    │   │   │   ├── has_mpfi.cpp
    │   │   │   ├── has_mpfr.cpp
    │   │   │   ├── has_tommath.cpp
    │   │   │   └── is_ci_sanitizer_run.cpp
    │   │   ├── doc/
    │   │   │   ├── Jamfile.v2
    │   │   │   ├── floating_point_eg1.mml
    │   │   │   ├── floating_point_eg2.mml
    │   │   │   ├── floating_point_eg3.mml
    │   │   │   ├── generate.sh
    │   │   │   ├── history.qbk
    │   │   │   ├── html/
    │   │   │   │   ├── boost_multiprecision/
    │   │   │   │   │   ├── indexes/
    │   │   │   │   │   │   ├── s01.html
    │   │   │   │   │   │   ├── s02.html
    │   │   │   │   │   │   ├── s03.html
    │   │   │   │   │   │   └── s04.html
    │   │   │   │   │   ├── indexes.html
    │   │   │   │   │   ├── intro.html
    │   │   │   │   │   ├── map/
    │   │   │   │   │   │   ├── ack.html
    │   │   │   │   │   │   ├── faq.html
    │   │   │   │   │   │   ├── hist.html
    │   │   │   │   │   │   └── todo.html
    │   │   │   │   │   ├── map.html
    │   │   │   │   │   ├── perf/
    │   │   │   │   │   │   ├── float_performance.html
    │   │   │   │   │   │   ├── int_real_world.html
    │   │   │   │   │   │   ├── integer_performance.html
    │   │   │   │   │   │   ├── overhead.html
    │   │   │   │   │   │   ├── rational_performance.html
    │   │   │   │   │   │   ├── rational_real_world.html
    │   │   │   │   │   │   └── realworld.html
    │   │   │   │   │   ├── perf.html
    │   │   │   │   │   ├── ref/
    │   │   │   │   │   │   ├── backendconc.html
    │   │   │   │   │   │   ├── cpp_bin_float_ref.html
    │   │   │   │   │   │   ├── cpp_dec_ref.html
    │   │   │   │   │   │   ├── cpp_int_ref.html
    │   │   │   │   │   │   ├── gmp_int_ref.html
    │   │   │   │   │   │   ├── headers.html
    │   │   │   │   │   │   ├── internals.html
    │   │   │   │   │   │   ├── mpf_ref.html
    │   │   │   │   │   │   ├── mpfr_ref.html
    │   │   │   │   │   │   ├── number.html
    │   │   │   │   │   │   └── tom_int_ref.html
    │   │   │   │   │   ├── ref.html
    │   │   │   │   │   ├── tut/
    │   │   │   │   │   │   ├── complex/
    │   │   │   │   │   │   │   ├── complex128.html
    │   │   │   │   │   │   │   ├── complex_adaptor.html
    │   │   │   │   │   │   │   ├── cpp_complex.html
    │   │   │   │   │   │   │   └── mpc_complex.html
    │   │   │   │   │   │   ├── complex.html
    │   │   │   │   │   │   ├── conversions.html
    │   │   │   │   │   │   ├── eigen.html
    │   │   │   │   │   │   ├── floats/
    │   │   │   │   │   │   │   ├── cpp_bin_float.html
    │   │   │   │   │   │   │   ├── cpp_dec_float.html
    │   │   │   │   │   │   │   ├── float128.html
    │   │   │   │   │   │   │   ├── fp_eg/
    │   │   │   │   │   │   │   │   ├── aos.html
    │   │   │   │   │   │   │   │   ├── caveats.html
    │   │   │   │   │   │   │   │   ├── floatbuiltinctor.html
    │   │   │   │   │   │   │   │   ├── gauss_lagerre_quadrature.html
    │   │   │   │   │   │   │   │   ├── gi.html
    │   │   │   │   │   │   │   │   ├── jel.html
    │   │   │   │   │   │   │   │   ├── nd.html
    │   │   │   │   │   │   │   │   ├── poly_eg.html
    │   │   │   │   │   │   │   │   └── variable_precision.html
    │   │   │   │   │   │   │   ├── fp_eg.html
    │   │   │   │   │   │   │   ├── gmp_float.html
    │   │   │   │   │   │   │   └── mpfr_float.html
    │   │   │   │   │   │   ├── floats.html
    │   │   │   │   │   │   ├── gen_int.html
    │   │   │   │   │   │   ├── hash.html
    │   │   │   │   │   │   ├── import_export.html
    │   │   │   │   │   │   ├── input_output.html
    │   │   │   │   │   │   ├── interval/
    │   │   │   │   │   │   │   └── mpfi.html
    │   │   │   │   │   │   ├── interval.html
    │   │   │   │   │   │   ├── ints/
    │   │   │   │   │   │   │   ├── cpp_int.html
    │   │   │   │   │   │   │   ├── egs/
    │   │   │   │   │   │   │   │   ├── bitops.html
    │   │   │   │   │   │   │   │   └── factorials.html
    │   │   │   │   │   │   │   ├── egs.html
    │   │   │   │   │   │   │   ├── gmp_int.html
    │   │   │   │   │   │   │   └── tom_int.html
    │   │   │   │   │   │   ├── ints.html
    │   │   │   │   │   │   ├── limits/
    │   │   │   │   │   │   │   ├── constants.html
    │   │   │   │   │   │   │   ├── functions.html
    │   │   │   │   │   │   │   ├── how_to_tell.html
    │   │   │   │   │   │   │   └── limits32.html
    │   │   │   │   │   │   ├── limits.html
    │   │   │   │   │   │   ├── lits.html
    │   │   │   │   │   │   ├── misc/
    │   │   │   │   │   │   │   ├── debug_adaptor.html
    │   │   │   │   │   │   │   ├── logged_adaptor.html
    │   │   │   │   │   │   │   └── visualizers.html
    │   │   │   │   │   │   ├── misc.html
    │   │   │   │   │   │   ├── mixed.html
    │   │   │   │   │   │   ├── new_backend.html
    │   │   │   │   │   │   ├── primetest.html
    │   │   │   │   │   │   ├── random.html
    │   │   │   │   │   │   ├── rational/
    │   │   │   │   │   │   │   ├── cpp_rational.html
    │   │   │   │   │   │   │   ├── gmp_rational.html
    │   │   │   │   │   │   │   ├── rational_adaptor.html
    │   │   │   │   │   │   │   ├── tommath_rational.html
    │   │   │   │   │   │   │   └── tommath_rational0.html
    │   │   │   │   │   │   ├── rational.html
    │   │   │   │   │   │   ├── rounding.html
    │   │   │   │   │   │   ├── serial.html
    │   │   │   │   │   │   └── variable.html
    │   │   │   │   │   └── tut.html
    │   │   │   │   ├── index.html
    │   │   │   │   └── multiprecision.css
    │   │   │   ├── html4_symbols.qbk
    │   │   │   ├── index.idx
    │   │   │   ├── introduction.qbk
    │   │   │   ├── multiprecision.css
    │   │   │   ├── multiprecision.qbk
    │   │   │   ├── numeric_limits_32_tables.qbk
    │   │   │   ├── numeric_limits_qbk.cpp
    │   │   │   ├── performance.qbk
    │   │   │   ├── performance_float.qbk
    │   │   │   ├── performance_integer.qbk
    │   │   │   ├── performance_integer_real_world.qbk
    │   │   │   ├── performance_overhead.qbk
    │   │   │   ├── performance_rational.qbk
    │   │   │   ├── performance_rational_real_world.qbk
    │   │   │   ├── performance_real_world.qbk
    │   │   │   ├── reference.qbk
    │   │   │   ├── reference_backend_requirements.qbk
    │   │   │   ├── reference_cpp_bin_float.qbk
    │   │   │   ├── reference_cpp_dec_float.qbk
    │   │   │   ├── reference_cpp_int.qbk
    │   │   │   ├── reference_gmp_float.qbk
    │   │   │   ├── reference_gmp_int.qbk
    │   │   │   ├── reference_header_structure.qbk
    │   │   │   ├── reference_internal_support.qbk
    │   │   │   ├── reference_mpfr_float.qbk
    │   │   │   ├── reference_number.qbk
    │   │   │   ├── reference_tom_int.qbk
    │   │   │   ├── tutorial.qbk
    │   │   │   ├── tutorial_boost_rational.qbk
    │   │   │   ├── tutorial_complex.qbk
    │   │   │   ├── tutorial_complex_adaptor.qbk
    │   │   │   ├── tutorial_constexpr.qbk
    │   │   │   ├── tutorial_conversions.qbk
    │   │   │   ├── tutorial_cpp_bin_float.qbk
    │   │   │   ├── tutorial_cpp_complex.qbk
    │   │   │   ├── tutorial_cpp_dec_float.qbk
    │   │   │   ├── tutorial_cpp_int.qbk
    │   │   │   ├── tutorial_cpp_rational.qbk
    │   │   │   ├── tutorial_debug_adaptor.qbk
    │   │   │   ├── tutorial_eigen.qbk
    │   │   │   ├── tutorial_float128.qbk
    │   │   │   ├── tutorial_float128_complex.qbk
    │   │   │   ├── tutorial_float_builtin_ctor.qbk
    │   │   │   ├── tutorial_float_eg.qbk
    │   │   │   ├── tutorial_floats.qbk
    │   │   │   ├── tutorial_gmp_float.qbk
    │   │   │   ├── tutorial_gmp_int.qbk
    │   │   │   ├── tutorial_gmp_rational.qbk
    │   │   │   ├── tutorial_hash.qbk
    │   │   │   ├── tutorial_import_export.qbk
    │   │   │   ├── tutorial_integer.qbk
    │   │   │   ├── tutorial_integer_examples.qbk
    │   │   │   ├── tutorial_integer_ops.qbk
    │   │   │   ├── tutorial_interval_mpfi.qbk
    │   │   │   ├── tutorial_io.qbk
    │   │   │   ├── tutorial_logged_adaptor.qbk
    │   │   │   ├── tutorial_misc_backends.qbk
    │   │   │   ├── tutorial_mixed_precision.qbk
    │   │   │   ├── tutorial_mpc_complex.qbk
    │   │   │   ├── tutorial_mpfr_float.qbk
    │   │   │   ├── tutorial_new_backend.qbk
    │   │   │   ├── tutorial_numeric_limits.qbk
    │   │   │   ├── tutorial_primality.qbk
    │   │   │   ├── tutorial_random.qbk
    │   │   │   ├── tutorial_rational.qbk
    │   │   │   ├── tutorial_rational_adaptor.qbk
    │   │   │   ├── tutorial_rounding.qbk
    │   │   │   ├── tutorial_serialization.qbk
    │   │   │   ├── tutorial_tommath.qbk
    │   │   │   ├── tutorial_tommath_rational.qbk
    │   │   │   ├── tutorial_variable_precision.qbk
    │   │   │   └── tutorial_visualizers.qbk
    │   │   ├── example/
    │   │   │   ├── Jamfile.v2
    │   │   │   ├── big_seventh.cpp
    │   │   │   ├── complex128_examples.cpp
    │   │   │   ├── constexpr_float_arithmetic_examples.cpp
    │   │   │   ├── cpp_bin_float_import_export.cpp
    │   │   │   ├── cpp_bin_float_snips.cpp
    │   │   │   ├── cpp_complex_examples.cpp
    │   │   │   ├── cpp_dec_float_snips.cpp
    │   │   │   ├── cpp_int_import_export.cpp
    │   │   │   ├── cpp_int_mul_timing.cpp
    │   │   │   ├── cpp_int_snips.cpp
    │   │   │   ├── debug_adaptor_snips.cpp
    │   │   │   ├── eigen_example.cpp
    │   │   │   ├── exercise_threading_log_agm.cpp
    │   │   │   ├── float128_snips.cpp
    │   │   │   ├── floating_point_examples.cpp
    │   │   │   ├── gauss_laguerre_quadrature.cpp
    │   │   │   ├── gmp_snips.cpp
    │   │   │   ├── hashing_examples.cpp
    │   │   │   ├── hypergeometric_luke_algorithms.cpp
    │   │   │   ├── integer_examples.cpp
    │   │   │   ├── logged_adaptor.cpp
    │   │   │   ├── mixed_integer_arithmetic.cpp
    │   │   │   ├── mpc_examples.cpp
    │   │   │   ├── mpfi_snips.cpp
    │   │   │   ├── mpfr_precision.cpp
    │   │   │   ├── mpfr_snips.cpp
    │   │   │   ├── numeric_limits_snips.cpp
    │   │   │   ├── random_snips.cpp
    │   │   │   ├── safe_prime.cpp
    │   │   │   ├── scoped_precision_example.cpp
    │   │   │   ├── standalone_bernoulli_tgamma.cpp
    │   │   │   └── tommath_snips.cpp
    │   │   ├── include/
    │   │   │   └── boost/
    │   │   │       ├── config/
    │   │   │       │   ├── abi/
    │   │   │       │   │   ├── borland_prefix.hpp
    │   │   │       │   │   ├── borland_suffix.hpp
    │   │   │       │   │   ├── msvc_prefix.hpp
    │   │   │       │   │   └── msvc_suffix.hpp
    │   │   │       │   ├── abi_prefix.hpp
    │   │   │       │   ├── abi_suffix.hpp
    │   │   │       │   ├── assert_cxx03.hpp
    │   │   │       │   ├── assert_cxx11.hpp
    │   │   │       │   ├── assert_cxx14.hpp
    │   │   │       │   ├── assert_cxx17.hpp
    │   │   │       │   ├── assert_cxx20.hpp
    │   │   │       │   ├── assert_cxx98.hpp
    │   │   │       │   ├── auto_link.hpp
    │   │   │       │   ├── compiler/
    │   │   │       │   │   ├── borland.hpp
    │   │   │       │   │   ├── clang.hpp
    │   │   │       │   │   ├── clang_version.hpp
    │   │   │       │   │   ├── codegear.hpp
    │   │   │       │   │   ├── comeau.hpp
    │   │   │       │   │   ├── common_edg.hpp
    │   │   │       │   │   ├── compaq_cxx.hpp
    │   │   │       │   │   ├── cray.hpp
    │   │   │       │   │   ├── diab.hpp
    │   │   │       │   │   ├── digitalmars.hpp
    │   │   │       │   │   ├── gcc.hpp
    │   │   │       │   │   ├── gcc_xml.hpp
    │   │   │       │   │   ├── greenhills.hpp
    │   │   │       │   │   ├── hp_acc.hpp
    │   │   │       │   │   ├── intel.hpp
    │   │   │       │   │   ├── kai.hpp
    │   │   │       │   │   ├── metrowerks.hpp
    │   │   │       │   │   ├── mpw.hpp
    │   │   │       │   │   ├── nvcc.hpp
    │   │   │       │   │   ├── pathscale.hpp
    │   │   │       │   │   ├── pgi.hpp
    │   │   │       │   │   ├── sgi_mipspro.hpp
    │   │   │       │   │   ├── sunpro_cc.hpp
    │   │   │       │   │   ├── vacpp.hpp
    │   │   │       │   │   ├── visualc.hpp
    │   │   │       │   │   ├── xlcpp.hpp
    │   │   │       │   │   └── xlcpp_zos.hpp
    │   │   │       │   ├── detail/
    │   │   │       │   │   ├── cxx_composite.hpp
    │   │   │       │   │   ├── posix_features.hpp
    │   │   │       │   │   ├── select_compiler_config.hpp
    │   │   │       │   │   ├── select_platform_config.hpp
    │   │   │       │   │   ├── select_stdlib_config.hpp
    │   │   │       │   │   └── suffix.hpp
    │   │   │       │   ├── header_deprecated.hpp
    │   │   │       │   ├── helper_macros.hpp
    │   │   │       │   ├── no_tr1/
    │   │   │       │   │   ├── cmath.hpp
    │   │   │       │   │   ├── complex.hpp
    │   │   │       │   │   ├── functional.hpp
    │   │   │       │   │   ├── memory.hpp
    │   │   │       │   │   └── utility.hpp
    │   │   │       │   ├── platform/
    │   │   │       │   │   ├── aix.hpp
    │   │   │       │   │   ├── amigaos.hpp
    │   │   │       │   │   ├── beos.hpp
    │   │   │       │   │   ├── bsd.hpp
    │   │   │       │   │   ├── cloudabi.hpp
    │   │   │       │   │   ├── cray.hpp
    │   │   │       │   │   ├── cygwin.hpp
    │   │   │       │   │   ├── haiku.hpp
    │   │   │       │   │   ├── hpux.hpp
    │   │   │       │   │   ├── irix.hpp
    │   │   │       │   │   ├── linux.hpp
    │   │   │       │   │   ├── macos.hpp
    │   │   │       │   │   ├── qnxnto.hpp
    │   │   │       │   │   ├── solaris.hpp
    │   │   │       │   │   ├── symbian.hpp
    │   │   │       │   │   ├── vms.hpp
    │   │   │       │   │   ├── vxworks.hpp
    │   │   │       │   │   ├── wasm.hpp
    │   │   │       │   │   ├── win32.hpp
    │   │   │       │   │   └── zos.hpp
    │   │   │       │   ├── pragma_message.hpp
    │   │   │       │   ├── requires_threads.hpp
    │   │   │       │   ├── stdlib/
    │   │   │       │   │   ├── dinkumware.hpp
    │   │   │       │   │   ├── libcomo.hpp
    │   │   │       │   │   ├── libcpp.hpp
    │   │   │       │   │   ├── libstdcpp3.hpp
    │   │   │       │   │   ├── modena.hpp
    │   │   │       │   │   ├── msl.hpp
    │   │   │       │   │   ├── roguewave.hpp
    │   │   │       │   │   ├── sgi.hpp
    │   │   │       │   │   ├── stlport.hpp
    │   │   │       │   │   ├── vacpp.hpp
    │   │   │       │   │   └── xlcpp_zos.hpp
    │   │   │       │   ├── user.hpp
    │   │   │       │   ├── warning_disable.hpp
    │   │   │       │   └── workaround.hpp
    │   │   │       ├── config.hpp
    │   │   │       ├── cstdint.hpp
    │   │   │       ├── cxx11_char_types.hpp
    │   │   │       ├── detail/
    │   │   │       │   └── workaround.hpp
    │   │   │       ├── limits.hpp
    │   │   │       ├── multiprecision/
    │   │   │       │   ├── complex128.hpp
    │   │   │       │   ├── complex_adaptor.hpp
    │   │   │       │   ├── concepts/
    │   │   │       │   │   └── mp_number_archetypes.hpp
    │   │   │       │   ├── cpp_bin_float/
    │   │   │       │   │   ├── io.hpp
    │   │   │       │   │   └── transcendental.hpp
    │   │   │       │   ├── cpp_bin_float.hpp
    │   │   │       │   ├── cpp_complex.hpp
    │   │   │       │   ├── cpp_dec_float.hpp
    │   │   │       │   ├── cpp_int/
    │   │   │       │   │   ├── add.hpp
    │   │   │       │   │   ├── add_unsigned.hpp
    │   │   │       │   │   ├── bitwise.hpp
    │   │   │       │   │   ├── checked.hpp
    │   │   │       │   │   ├── comparison.hpp
    │   │   │       │   │   ├── cpp_int_config.hpp
    │   │   │       │   │   ├── divide.hpp
    │   │   │       │   │   ├── import_export.hpp
    │   │   │       │   │   ├── intel_intrinsics.hpp
    │   │   │       │   │   ├── limits.hpp
    │   │   │       │   │   ├── literals.hpp
    │   │   │       │   │   ├── misc.hpp
    │   │   │       │   │   ├── multiply.hpp
    │   │   │       │   │   ├── serialize.hpp
    │   │   │       │   │   └── value_pack.hpp
    │   │   │       │   ├── cpp_int.hpp
    │   │   │       │   ├── debug_adaptor.hpp
    │   │   │       │   ├── detail/
    │   │   │       │   │   ├── assert.hpp
    │   │   │       │   │   ├── atomic.hpp
    │   │   │       │   │   ├── bitscan.hpp
    │   │   │       │   │   ├── check_cpp11_config.hpp
    │   │   │       │   │   ├── constexpr.hpp
    │   │   │       │   │   ├── default_ops.hpp
    │   │   │       │   │   ├── digits.hpp
    │   │   │       │   │   ├── dynamic_array.hpp
    │   │   │       │   │   ├── empty_value.hpp
    │   │   │       │   │   ├── endian.hpp
    │   │   │       │   │   ├── et_ops.hpp
    │   │   │       │   │   ├── float128_functions.hpp
    │   │   │       │   │   ├── float_string_cvt.hpp
    │   │   │       │   │   ├── fpclassify.hpp
    │   │   │       │   │   ├── functions/
    │   │   │       │   │   │   ├── constants.hpp
    │   │   │       │   │   │   ├── pow.hpp
    │   │   │       │   │   │   ├── trig.hpp
    │   │   │       │   │   │   └── trunc.hpp
    │   │   │       │   │   ├── generic_interconvert.hpp
    │   │   │       │   │   ├── hash.hpp
    │   │   │       │   │   ├── integer_ops.hpp
    │   │   │       │   │   ├── itos.hpp
    │   │   │       │   │   ├── min_max.hpp
    │   │   │       │   │   ├── no_et_ops.hpp
    │   │   │       │   │   ├── no_exceptions_support.hpp
    │   │   │       │   │   ├── number_base.hpp
    │   │   │       │   │   ├── number_compare.hpp
    │   │   │       │   │   ├── precision.hpp
    │   │   │       │   │   ├── rebind.hpp
    │   │   │       │   │   ├── standalone_config.hpp
    │   │   │       │   │   ├── static_array.hpp
    │   │   │       │   │   ├── tables.hpp
    │   │   │       │   │   ├── ublas_interop.hpp
    │   │   │       │   │   ├── uniform_int_distribution.hpp
    │   │   │       │   │   └── utype_helper.hpp
    │   │   │       │   ├── eigen.hpp
    │   │   │       │   ├── float128.hpp
    │   │   │       │   ├── gmp.hpp
    │   │   │       │   ├── integer.hpp
    │   │   │       │   ├── logged_adaptor.hpp
    │   │   │       │   ├── miller_rabin.hpp
    │   │   │       │   ├── mpc.hpp
    │   │   │       │   ├── mpfi.hpp
    │   │   │       │   ├── mpfr.hpp
    │   │   │       │   ├── number.hpp
    │   │   │       │   ├── random.hpp
    │   │   │       │   ├── rational_adaptor.hpp
    │   │   │       │   ├── tommath.hpp
    │   │   │       │   └── traits/
    │   │   │       │       ├── explicit_conversion.hpp
    │   │   │       │       ├── extract_exponent_type.hpp
    │   │   │       │       ├── is_backend.hpp
    │   │   │       │       ├── is_byte_container.hpp
    │   │   │       │       ├── is_complex.hpp
    │   │   │       │       ├── is_convertible_arithmetic.hpp
    │   │   │       │       ├── is_restricted_conversion.hpp
    │   │   │       │       ├── is_variable_precision.hpp
    │   │   │       │       ├── max_digits10.hpp
    │   │   │       │       ├── std_integer_traits.hpp
    │   │   │       │       └── transcendental_reduction_type.hpp
    │   │   │       └── version.hpp
    │   │   ├── index.html
    │   │   ├── meta/
    │   │   │   └── libraries.json
    │   │   ├── performance/
    │   │   │   ├── Jamfile.v2
    │   │   │   ├── arithmetic_backend.hpp
    │   │   │   ├── cpp_bin_float_conversion_performance.cpp
    │   │   │   ├── delaunay_test.cpp
    │   │   │   ├── delaunay_test.log
    │   │   │   ├── gcd_bench.cpp
    │   │   │   ├── linpack-benchmark.cpp
    │   │   │   ├── miller_rabin_performance.cpp
    │   │   │   ├── miller_rabin_performance.hpp
    │   │   │   ├── miller_rabin_performance.log
    │   │   │   ├── miller_rabin_performance_files/
    │   │   │   │   ├── test01.cpp
    │   │   │   │   ├── test02.cpp
    │   │   │   │   ├── test03.cpp
    │   │   │   │   ├── test04.cpp
    │   │   │   │   ├── test05.cpp
    │   │   │   │   ├── test06.cpp
    │   │   │   │   ├── test07.cpp
    │   │   │   │   ├── test08.cpp
    │   │   │   │   ├── test09.cpp
    │   │   │   │   ├── test10.cpp
    │   │   │   │   ├── test11.cpp
    │   │   │   │   └── test12.cpp
    │   │   │   ├── mixed_equivalent_types_bench.cpp
    │   │   │   ├── performance_test-gcc-linux.log
    │   │   │   ├── performance_test-intel-linux.log
    │   │   │   ├── performance_test-msvc-10.log
    │   │   │   ├── performance_test.cpp
    │   │   │   ├── performance_test.hpp
    │   │   │   ├── performance_test.log
    │   │   │   ├── performance_test_files/
    │   │   │   │   ├── test01.cpp
    │   │   │   │   ├── test02.cpp
    │   │   │   │   ├── test03.cpp
    │   │   │   │   ├── test04.cpp
    │   │   │   │   ├── test05.cpp
    │   │   │   │   ├── test06.cpp
    │   │   │   │   ├── test07.cpp
    │   │   │   │   ├── test08.cpp
    │   │   │   │   ├── test09.cpp
    │   │   │   │   ├── test10.cpp
    │   │   │   │   ├── test11.cpp
    │   │   │   │   ├── test12.cpp
    │   │   │   │   ├── test13.cpp
    │   │   │   │   ├── test14.cpp
    │   │   │   │   ├── test15.cpp
    │   │   │   │   ├── test16.cpp
    │   │   │   │   ├── test17.cpp
    │   │   │   │   ├── test18.cpp
    │   │   │   │   ├── test19.cpp
    │   │   │   │   ├── test20.cpp
    │   │   │   │   ├── test21.cpp
    │   │   │   │   ├── test22.cpp
    │   │   │   │   ├── test23.cpp
    │   │   │   │   ├── test24.cpp
    │   │   │   │   ├── test25.cpp
    │   │   │   │   ├── test26.cpp
    │   │   │   │   ├── test27.cpp
    │   │   │   │   ├── test28.cpp
    │   │   │   │   ├── test29.cpp
    │   │   │   │   ├── test30.cpp
    │   │   │   │   ├── test31.cpp
    │   │   │   │   ├── test32.cpp
    │   │   │   │   ├── test33.cpp
    │   │   │   │   ├── test34.cpp
    │   │   │   │   ├── test35.cpp
    │   │   │   │   ├── test36.cpp
    │   │   │   │   ├── test37.cpp
    │   │   │   │   ├── test38.cpp
    │   │   │   │   ├── test39.cpp
    │   │   │   │   ├── test40.cpp
    │   │   │   │   ├── test41.cpp
    │   │   │   │   ├── test42.cpp
    │   │   │   │   ├── test43.cpp
    │   │   │   │   ├── test44.cpp
    │   │   │   │   ├── test45.cpp
    │   │   │   │   ├── test46.cpp
    │   │   │   │   ├── test47.cpp
    │   │   │   │   ├── test48.cpp
    │   │   │   │   ├── test49.cpp
    │   │   │   │   ├── test50.cpp
    │   │   │   │   └── test51.cpp
    │   │   │   ├── rational_bernoulli_allocations.cpp
    │   │   │   ├── rational_bernoulli_allocations.log
    │   │   │   ├── rational_bernoulli_bench.cpp
    │   │   │   ├── rational_bernoulli_bench.log
    │   │   │   ├── rational_determinant_bench.cpp
    │   │   │   ├── rational_determinant_bench.log
    │   │   │   ├── rational_zeta18_bench.cpp
    │   │   │   ├── sf_performance-msvc-10.log
    │   │   │   ├── sf_performance.cpp
    │   │   │   ├── sf_performance.hpp
    │   │   │   ├── sf_performance.log
    │   │   │   ├── sf_performance_basic.cpp
    │   │   │   ├── sf_performance_bessel.cpp
    │   │   │   ├── sf_performance_files/
    │   │   │   │   ├── sf_performance_basic_1.cpp
    │   │   │   │   ├── sf_performance_basic_2.cpp
    │   │   │   │   ├── sf_performance_basic_3.cpp
    │   │   │   │   ├── sf_performance_basic_4.cpp
    │   │   │   │   ├── sf_performance_basic_5.cpp
    │   │   │   │   ├── sf_performance_basic_6.cpp
    │   │   │   │   ├── sf_performance_basic_7.cpp
    │   │   │   │   ├── sf_performance_basic_8.cpp
    │   │   │   │   ├── sf_performance_basic_9.cpp
    │   │   │   │   ├── sf_performance_bessel_01.cpp
    │   │   │   │   ├── sf_performance_bessel_02.cpp
    │   │   │   │   ├── sf_performance_bessel_03.cpp
    │   │   │   │   ├── sf_performance_bessel_04.cpp
    │   │   │   │   ├── sf_performance_bessel_05.cpp
    │   │   │   │   ├── sf_performance_bessel_06.cpp
    │   │   │   │   ├── sf_performance_bessel_07.cpp
    │   │   │   │   ├── sf_performance_bessel_08.cpp
    │   │   │   │   ├── sf_performance_bessel_09.cpp
    │   │   │   │   ├── sf_performance_bessel_10.cpp
    │   │   │   │   ├── sf_performance_bessel_11.cpp
    │   │   │   │   ├── sf_performance_bessel_12.cpp
    │   │   │   │   ├── sf_performance_bessel_13.cpp
    │   │   │   │   ├── sf_performance_bessel_14.cpp
    │   │   │   │   ├── sf_performance_bessel_15.cpp
    │   │   │   │   ├── sf_performance_bessel_16.cpp
    │   │   │   │   ├── sf_performance_bessel_17.cpp
    │   │   │   │   ├── sf_performance_bessel_18.cpp
    │   │   │   │   ├── sf_performance_bessel_19.cpp
    │   │   │   │   ├── sf_performance_nct_01.cpp
    │   │   │   │   ├── sf_performance_nct_02.cpp
    │   │   │   │   ├── sf_performance_nct_03.cpp
    │   │   │   │   ├── sf_performance_nct_04.cpp
    │   │   │   │   ├── sf_performance_nct_05.cpp
    │   │   │   │   ├── sf_performance_nct_06.cpp
    │   │   │   │   ├── sf_performance_nct_07.cpp
    │   │   │   │   ├── sf_performance_nct_08.cpp
    │   │   │   │   ├── sf_performance_nct_09.cpp
    │   │   │   │   ├── sf_performance_nct_10.cpp
    │   │   │   │   ├── sf_performance_nct_11.cpp
    │   │   │   │   ├── sf_performance_nct_12.cpp
    │   │   │   │   ├── sf_performance_nct_13.cpp
    │   │   │   │   ├── sf_performance_nct_14.cpp
    │   │   │   │   ├── sf_performance_nct_15.cpp
    │   │   │   │   ├── sf_performance_nct_16.cpp
    │   │   │   │   ├── sf_performance_nct_17.cpp
    │   │   │   │   ├── sf_performance_nct_18.cpp
    │   │   │   │   ├── sf_performance_nct_19.cpp
    │   │   │   │   ├── sf_performance_nct_20.cpp
    │   │   │   │   ├── sf_performance_poly_01.cpp
    │   │   │   │   ├── sf_performance_poly_02.cpp
    │   │   │   │   ├── sf_performance_poly_03.cpp
    │   │   │   │   ├── sf_performance_poly_04.cpp
    │   │   │   │   ├── sf_performance_poly_05.cpp
    │   │   │   │   ├── sf_performance_poly_06.cpp
    │   │   │   │   ├── sf_performance_poly_07.cpp
    │   │   │   │   ├── sf_performance_poly_08.cpp
    │   │   │   │   ├── sf_performance_poly_09.cpp
    │   │   │   │   ├── sf_performance_poly_10.cpp
    │   │   │   │   ├── sf_performance_poly_11.cpp
    │   │   │   │   ├── sf_performance_poly_12.cpp
    │   │   │   │   ├── sf_performance_poly_13.cpp
    │   │   │   │   ├── sf_performance_poly_14.cpp
    │   │   │   │   ├── sf_performance_poly_15.cpp
    │   │   │   │   ├── sf_performance_poly_16.cpp
    │   │   │   │   ├── sf_performance_poly_17.cpp
    │   │   │   │   └── sf_performance_poly_18.cpp
    │   │   │   ├── sf_performance_nct.cpp
    │   │   │   ├── sf_performance_poly.cpp
    │   │   │   ├── sqrt_bench.cpp
    │   │   │   ├── veronoi_performance.log
    │   │   │   └── voronoi_performance.cpp
    │   │   ├── plots/
    │   │   │   ├── cpp_bin_float_acos_errors.cpp
    │   │   │   ├── cpp_bin_float_asin_errors.cpp
    │   │   │   ├── cpp_bin_float_atan_errors.cpp
    │   │   │   ├── cpp_bin_float_cos_errors.cpp
    │   │   │   ├── cpp_bin_float_erf_errors.cpp
    │   │   │   ├── cpp_bin_float_erfc_errors.cpp
    │   │   │   ├── cpp_bin_float_exp_errors.cpp
    │   │   │   ├── cpp_bin_float_log_errors.cpp
    │   │   │   ├── cpp_bin_float_sin_errors.cpp
    │   │   │   ├── cpp_bin_float_tan_errors.cpp
    │   │   │   └── cpp_bin_float_tgamma_errors.cpp
    │   │   ├── test/
    │   │   │   ├── Jamfile.v2
    │   │   │   ├── bug11922.cpp
    │   │   │   ├── bug12039.cpp
    │   │   │   ├── compile_fail/
    │   │   │   │   ├── conv_fail_01.cpp
    │   │   │   │   ├── conv_fail_02.cpp
    │   │   │   │   ├── conv_fail_03.cpp
    │   │   │   │   ├── conv_fail_04.cpp
    │   │   │   │   ├── conv_fail_05.cpp
    │   │   │   │   ├── conv_fail_06.cpp
    │   │   │   │   ├── conv_fail_07.cpp
    │   │   │   │   ├── conv_fail_08.cpp
    │   │   │   │   ├── conv_fail_09.cpp
    │   │   │   │   ├── conv_fail_10.cpp
    │   │   │   │   ├── conv_fail_11.cpp
    │   │   │   │   ├── conv_fail_12.cpp
    │   │   │   │   ├── conv_fail_13.cpp
    │   │   │   │   ├── conv_fail_14.cpp
    │   │   │   │   ├── conv_fail_15.cpp
    │   │   │   │   ├── conv_fail_16.cpp
    │   │   │   │   ├── conv_fail_18.cpp
    │   │   │   │   ├── conv_fail_20.cpp
    │   │   │   │   ├── conv_fail_21.cpp
    │   │   │   │   ├── conv_fail_22.cpp
    │   │   │   │   ├── conv_fail_23.cpp
    │   │   │   │   ├── conv_fail_24.cpp
    │   │   │   │   ├── conv_fail_25.cpp
    │   │   │   │   ├── conv_fail_26.cpp
    │   │   │   │   ├── conv_fail_27.cpp
    │   │   │   │   ├── conv_fail_28.cpp
    │   │   │   │   ├── conv_fail_29.cpp
    │   │   │   │   ├── conv_fail_30.cpp
    │   │   │   │   ├── conv_fail_31.cpp
    │   │   │   │   ├── conv_fail_32.cpp
    │   │   │   │   ├── conv_fail_33.cpp
    │   │   │   │   ├── conv_fail_34.cpp
    │   │   │   │   ├── conv_fail_35.cpp
    │   │   │   │   ├── conv_fail_36.cpp
    │   │   │   │   ├── conv_fail_37.cpp
    │   │   │   │   ├── conv_fail_38.cpp
    │   │   │   │   ├── conv_fail_39.cpp
    │   │   │   │   ├── conv_fail_40.cpp
    │   │   │   │   ├── conv_fail_41.cpp
    │   │   │   │   ├── conv_fail_42.cpp
    │   │   │   │   ├── conv_fail_43.cpp
    │   │   │   │   ├── conv_fail_44.cpp
    │   │   │   │   ├── conv_fail_45.cpp
    │   │   │   │   ├── conv_fail_46.cpp
    │   │   │   │   ├── conv_fail_47.cpp
    │   │   │   │   ├── conv_fail_48.cpp
    │   │   │   │   ├── conv_fail_49.cpp
    │   │   │   │   ├── conv_fail_50.cpp
    │   │   │   │   ├── conv_fail_51.cpp
    │   │   │   │   ├── conv_fail_52.cpp
    │   │   │   │   ├── conv_fail_53.cpp
    │   │   │   │   ├── conv_fail_54.cpp
    │   │   │   │   ├── conv_fail_55.cpp
    │   │   │   │   ├── conv_fail_56.cpp
    │   │   │   │   ├── conv_fail_57.cpp
    │   │   │   │   ├── conv_fail_58.cpp
    │   │   │   │   ├── conv_fail_59.cpp
    │   │   │   │   ├── cpp_int_complement.cpp
    │   │   │   │   ├── cpp_int_negate_1.cpp
    │   │   │   │   ├── cpp_int_negate_2.cpp
    │   │   │   │   ├── operator_fail_01.cpp
    │   │   │   │   ├── operator_fail_02.cpp
    │   │   │   │   ├── operator_fail_03.cpp
    │   │   │   │   ├── operator_fail_04.cpp
    │   │   │   │   ├── operator_fail_05.cpp
    │   │   │   │   ├── operator_fail_06.cpp
    │   │   │   │   ├── operator_fail_07.cpp
    │   │   │   │   ├── operator_fail_08.cpp
    │   │   │   │   ├── operator_fail_09.cpp
    │   │   │   │   ├── operator_fail_10.cpp
    │   │   │   │   ├── operator_fail_11.cpp
    │   │   │   │   ├── operator_fail_12.cpp
    │   │   │   │   ├── operator_fail_13.cpp
    │   │   │   │   ├── operator_fail_14.cpp
    │   │   │   │   ├── operator_fail_15.cpp
    │   │   │   │   ├── operator_fail_16.cpp
    │   │   │   │   ├── operator_fail_17.cpp
    │   │   │   │   └── operator_fail_18.cpp
    │   │   │   ├── concepts/
    │   │   │   │   ├── number_concept_check.cpp
    │   │   │   │   ├── sf_concept_check_basic.cpp
    │   │   │   │   ├── sf_concept_check_bessel.cpp
    │   │   │   │   ├── sf_concept_check_beta.cpp
    │   │   │   │   ├── sf_concept_check_beta_2.cpp
    │   │   │   │   ├── sf_concept_check_beta_3.cpp
    │   │   │   │   ├── sf_concept_check_elliptic.cpp
    │   │   │   │   ├── sf_concept_check_gamma.cpp
    │   │   │   │   └── sf_concept_check_poly.cpp
    │   │   │   ├── constexpr_arithmetric_test.hpp
    │   │   │   ├── constexpr_test_arithmetic_backend.cpp
    │   │   │   ├── constexpr_test_cpp_int.cpp
    │   │   │   ├── constexpr_test_cpp_int_2.cpp
    │   │   │   ├── constexpr_test_cpp_int_3.cpp
    │   │   │   ├── constexpr_test_cpp_int_4.cpp
    │   │   │   ├── constexpr_test_cpp_int_5.cpp
    │   │   │   ├── constexpr_test_cpp_int_6.cpp
    │   │   │   ├── constexpr_test_cpp_int_7.cpp
    │   │   │   ├── constexpr_test_float128.cpp
    │   │   │   ├── eigen.hpp
    │   │   │   ├── git_issue_167.cpp
    │   │   │   ├── git_issue_175.cpp
    │   │   │   ├── git_issue_248.cpp
    │   │   │   ├── git_issue_265.cpp
    │   │   │   ├── git_issue_277.cpp
    │   │   │   ├── git_issue_30.cpp
    │   │   │   ├── git_issue_313.cpp
    │   │   │   ├── git_issue_370.cpp
    │   │   │   ├── git_issue_393.cpp
    │   │   │   ├── git_issue_426.cpp
    │   │   │   ├── git_issue_464.cpp
    │   │   │   ├── git_issue_488.cpp
    │   │   │   ├── git_issue_98.cpp
    │   │   │   ├── include_test/
    │   │   │   │   ├── cpp_bin_float_include_test.cpp
    │   │   │   │   ├── cpp_dec_float_include_test.cpp
    │   │   │   │   ├── cpp_int_include_test.cpp
    │   │   │   │   ├── gmp_include_test.cpp
    │   │   │   │   ├── mpfr_include_test.cpp
    │   │   │   │   └── tommath_include_test.cpp
    │   │   │   ├── issue_13148.cpp
    │   │   │   ├── issue_13301.cpp
    │   │   │   ├── math/
    │   │   │   │   ├── high_prec/
    │   │   │   │   │   ├── gamma.ipp
    │   │   │   │   │   ├── gamma_0.ipp
    │   │   │   │   │   ├── gamma_1_2.ipp
    │   │   │   │   │   ├── gamma_neg.ipp
    │   │   │   │   │   ├── readme.txt
    │   │   │   │   │   ├── test_gamma.cpp
    │   │   │   │   │   └── test_gamma.hpp
    │   │   │   │   ├── instances/
    │   │   │   │   │   ├── Jamfile.v2
    │   │   │   │   │   └── instances.cpp
    │   │   │   │   ├── log1p_expm1_test.cpp
    │   │   │   │   ├── powm1_sqrtp1m1_test.cpp
    │   │   │   │   ├── readme.txt
    │   │   │   │   ├── setup.hpp
    │   │   │   │   ├── table_type.hpp
    │   │   │   │   ├── test_bessel_i.cpp
    │   │   │   │   ├── test_bessel_j.cpp
    │   │   │   │   ├── test_bessel_k.cpp
    │   │   │   │   ├── test_bessel_y.cpp
    │   │   │   │   ├── test_beta.cpp
    │   │   │   │   ├── test_binomial_coeff.cpp
    │   │   │   │   ├── test_carlson_1.cpp
    │   │   │   │   ├── test_carlson_2.cpp
    │   │   │   │   ├── test_carlson_3.cpp
    │   │   │   │   ├── test_carlson_4.cpp
    │   │   │   │   ├── test_cbrt.cpp
    │   │   │   │   ├── test_digamma.cpp
    │   │   │   │   ├── test_ellint_1.cpp
    │   │   │   │   ├── test_ellint_2.cpp
    │   │   │   │   ├── test_ellint_3.cpp
    │   │   │   │   ├── test_erf.cpp
    │   │   │   │   ├── test_expint.cpp
    │   │   │   │   ├── test_gamma.cpp
    │   │   │   │   ├── test_hermite.cpp
    │   │   │   │   ├── test_ibeta.cpp
    │   │   │   │   ├── test_ibeta_2.cpp
    │   │   │   │   ├── test_ibeta_3.cpp
    │   │   │   │   ├── test_ibeta_4.cpp
    │   │   │   │   ├── test_ibeta_inv_1.cpp
    │   │   │   │   ├── test_ibeta_inv_ab_4.cpp
    │   │   │   │   ├── test_igamma.cpp
    │   │   │   │   ├── test_igamma_inv.cpp
    │   │   │   │   ├── test_igamma_inva.cpp
    │   │   │   │   ├── test_laguerre.cpp
    │   │   │   │   ├── test_legendre.cpp
    │   │   │   │   ├── test_tgamma_ratio.cpp
    │   │   │   │   └── test_zeta.cpp
    │   │   │   ├── no_eh_test_support.cpp
    │   │   │   ├── serial_txts/
    │   │   │   │   ├── boost-no-inspect
    │   │   │   │   ├── cpp_int1024_serial32.txt
    │   │   │   │   ├── cpp_int1024_serial64.txt
    │   │   │   │   ├── cpp_int128_serial32.txt
    │   │   │   │   ├── cpp_int128_serial64.txt
    │   │   │   │   ├── cpp_int64_serial32.txt
    │   │   │   │   └── cpp_int64_serial64.txt
    │   │   │   ├── sincos.ipp
    │   │   │   ├── skeleton_backend.hpp
    │   │   │   ├── standalone_constexpr_test_cpp_int.cpp
    │   │   │   ├── standalone_constexpr_test_float128.cpp
    │   │   │   ├── standalone_test_arithmetic_complex128.cpp
    │   │   │   ├── standalone_test_arithmetic_cpp_bin_float.cpp
    │   │   │   ├── standalone_test_arithmetic_cpp_dec_float.cpp
    │   │   │   ├── standalone_test_arithmetic_cpp_int.cpp
    │   │   │   ├── standalone_test_arithmetic_cpp_rational.cpp
    │   │   │   ├── standalone_test_arithmetic_float_128.cpp
    │   │   │   ├── standalone_test_arithmetic_gmp.cpp
    │   │   │   ├── standalone_test_arithmetic_int512.cpp
    │   │   │   ├── standalone_test_arithmetic_mpf_logged_adptr.cpp
    │   │   │   ├── standalone_test_arithmetic_mpz_rat.cpp
    │   │   │   ├── standalone_test_arithmetic_tommath.cpp
    │   │   │   ├── standalone_test_convert_from_tom_int.cpp
    │   │   │   ├── standalone_test_miller_rabin.cpp
    │   │   │   ├── string_data.ipp
    │   │   │   ├── test.hpp
    │   │   │   ├── test_acos.cpp
    │   │   │   ├── test_adapt_serial.cpp
    │   │   │   ├── test_arithmetic.hpp
    │   │   │   ├── test_arithmetic_ab_1.cpp
    │   │   │   ├── test_arithmetic_ab_2.cpp
    │   │   │   ├── test_arithmetic_ab_3.cpp
    │   │   │   ├── test_arithmetic_backend_concept.cpp
    │   │   │   ├── test_arithmetic_complex128.cpp
    │   │   │   ├── test_arithmetic_complex_adaptor.cpp
    │   │   │   ├── test_arithmetic_complex_adaptor_2.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_1.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_2.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_2m.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_3.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_4.cpp
    │   │   │   ├── test_arithmetic_cpp_bin_float_5.cpp
    │   │   │   ├── test_arithmetic_cpp_complex_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_cpp_complex_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_cpp_dec_float_1.cpp
    │   │   │   ├── test_arithmetic_cpp_dec_float_2.cpp
    │   │   │   ├── test_arithmetic_cpp_dec_float_3.cpp
    │   │   │   ├── test_arithmetic_cpp_dec_float_3m.cpp
    │   │   │   ├── test_arithmetic_cpp_int_1.cpp
    │   │   │   ├── test_arithmetic_cpp_int_10.cpp
    │   │   │   ├── test_arithmetic_cpp_int_11.cpp
    │   │   │   ├── test_arithmetic_cpp_int_12.cpp
    │   │   │   ├── test_arithmetic_cpp_int_13.cpp
    │   │   │   ├── test_arithmetic_cpp_int_14.cpp
    │   │   │   ├── test_arithmetic_cpp_int_15.cpp
    │   │   │   ├── test_arithmetic_cpp_int_16.cpp
    │   │   │   ├── test_arithmetic_cpp_int_17.cpp
    │   │   │   ├── test_arithmetic_cpp_int_18.cpp
    │   │   │   ├── test_arithmetic_cpp_int_19.cpp
    │   │   │   ├── test_arithmetic_cpp_int_2.cpp
    │   │   │   ├── test_arithmetic_cpp_int_20.cpp
    │   │   │   ├── test_arithmetic_cpp_int_21.cpp
    │   │   │   ├── test_arithmetic_cpp_int_22.cpp
    │   │   │   ├── test_arithmetic_cpp_int_23.cpp
    │   │   │   ├── test_arithmetic_cpp_int_3.cpp
    │   │   │   ├── test_arithmetic_cpp_int_4.cpp
    │   │   │   ├── test_arithmetic_cpp_int_5.cpp
    │   │   │   ├── test_arithmetic_cpp_int_6.cpp
    │   │   │   ├── test_arithmetic_cpp_int_7.cpp
    │   │   │   ├── test_arithmetic_cpp_int_8.cpp
    │   │   │   ├── test_arithmetic_cpp_int_9.cpp
    │   │   │   ├── test_arithmetic_cpp_int_br.cpp
    │   │   │   ├── test_arithmetic_cpp_int_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_cpp_int_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_cpp_rat_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_cpp_rat_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_dbg_adptr1.cpp
    │   │   │   ├── test_arithmetic_dbg_adptr1m.cpp
    │   │   │   ├── test_arithmetic_dbg_adptr2.cpp
    │   │   │   ├── test_arithmetic_float_128.cpp
    │   │   │   ├── test_arithmetic_logged_1.cpp
    │   │   │   ├── test_arithmetic_logged_2.cpp
    │   │   │   ├── test_arithmetic_mpc.cpp
    │   │   │   ├── test_arithmetic_mpc_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpc_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpf.cpp
    │   │   │   ├── test_arithmetic_mpf_50.cpp
    │   │   │   ├── test_arithmetic_mpf_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpf_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpfi_50.cpp
    │   │   │   ├── test_arithmetic_mpfi_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpfi_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpfr.cpp
    │   │   │   ├── test_arithmetic_mpfr_50.cpp
    │   │   │   ├── test_arithmetic_mpfr_50_mixed.cpp
    │   │   │   ├── test_arithmetic_mpfr_50_static.cpp
    │   │   │   ├── test_arithmetic_mpfr_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpfr_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpq.cpp
    │   │   │   ├── test_arithmetic_mpq_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpq_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpz.cpp
    │   │   │   ├── test_arithmetic_mpz_br.cpp
    │   │   │   ├── test_arithmetic_mpz_dbg_adptr.cpp
    │   │   │   ├── test_arithmetic_mpz_logged_adptr.cpp
    │   │   │   ├── test_arithmetic_mpz_rat.cpp
    │   │   │   ├── test_arithmetic_skeleton.cpp
    │   │   │   ├── test_arithmetic_tommath.cpp
    │   │   │   ├── test_arithmetic_tommath_br.cpp
    │   │   │   ├── test_arithmetic_tommath_rat.cpp
    │   │   │   ├── test_asin.cpp
    │   │   │   ├── test_assume_uniform_precision.cpp
    │   │   │   ├── test_atan.cpp
    │   │   │   ├── test_checked_cpp_int.cpp
    │   │   │   ├── test_checked_mixed_cpp_int.cpp
    │   │   │   ├── test_complex.cpp
    │   │   │   ├── test_complex_signed_zero.cpp
    │   │   │   ├── test_constants.cpp
    │   │   │   ├── test_constexpr.cpp
    │   │   │   ├── test_convert_cpp_int_2_float.cpp
    │   │   │   ├── test_convert_from_cpp_bin_float.cpp
    │   │   │   ├── test_convert_from_cpp_dec_float.cpp
    │   │   │   ├── test_convert_from_cpp_int.cpp
    │   │   │   ├── test_convert_from_cpp_rational.cpp
    │   │   │   ├── test_convert_from_float128.cpp
    │   │   │   ├── test_convert_from_gmp_rational.cpp
    │   │   │   ├── test_convert_from_mpf_float.cpp
    │   │   │   ├── test_convert_from_mpfi_float.cpp
    │   │   │   ├── test_convert_from_mpfr_float.cpp
    │   │   │   ├── test_convert_from_mpz_int.cpp
    │   │   │   ├── test_convert_from_tom_int.cpp
    │   │   │   ├── test_convert_from_tom_rational.cpp
    │   │   │   ├── test_cos.cpp
    │   │   │   ├── test_cos_near_half_pi.cpp
    │   │   │   ├── test_cosh.cpp
    │   │   │   ├── test_cpp_bin_float.cpp
    │   │   │   ├── test_cpp_bin_float_conv.cpp
    │   │   │   ├── test_cpp_bin_float_io.cpp
    │   │   │   ├── test_cpp_bin_float_round.cpp
    │   │   │   ├── test_cpp_bin_float_serial.cpp
    │   │   │   ├── test_cpp_bin_float_tgamma.cpp
    │   │   │   ├── test_cpp_dec_float_conv.cpp
    │   │   │   ├── test_cpp_dec_float_round.cpp
    │   │   │   ├── test_cpp_dec_float_serial.cpp
    │   │   │   ├── test_cpp_dec_float_tgamma.cpp
    │   │   │   ├── test_cpp_int.cpp
    │   │   │   ├── test_cpp_int_conv.cpp
    │   │   │   ├── test_cpp_int_deserial.cpp
    │   │   │   ├── test_cpp_int_import_export.cpp
    │   │   │   ├── test_cpp_int_karatsuba.cpp
    │   │   │   ├── test_cpp_int_left_shift.cpp
    │   │   │   ├── test_cpp_int_lit.cpp
    │   │   │   ├── test_cpp_int_serial.cpp
    │   │   │   ├── test_cpp_rat_serial.cpp
    │   │   │   ├── test_cpp_rational.cpp
    │   │   │   ├── test_eigen_interop.cpp
    │   │   │   ├── test_eigen_interop_cpp_bin_float_1.cpp
    │   │   │   ├── test_eigen_interop_cpp_bin_float_2.cpp
    │   │   │   ├── test_eigen_interop_cpp_bin_float_3.cpp
    │   │   │   ├── test_eigen_interop_cpp_dec_float.cpp
    │   │   │   ├── test_eigen_interop_cpp_dec_float_2.cpp
    │   │   │   ├── test_eigen_interop_cpp_dec_float_3.cpp
    │   │   │   ├── test_eigen_interop_cpp_int.cpp
    │   │   │   ├── test_eigen_interop_gmp.cpp
    │   │   │   ├── test_eigen_interop_gmp_2.cpp
    │   │   │   ├── test_eigen_interop_mpc.cpp
    │   │   │   ├── test_eigen_interop_mpfr_1.cpp
    │   │   │   ├── test_eigen_interop_mpfr_2.cpp
    │   │   │   ├── test_eigen_interop_mpfr_3.cpp
    │   │   │   ├── test_eigen_interop_mpfr_4.cpp
    │   │   │   ├── test_eigen_interop_mpfr_5.cpp
    │   │   │   ├── test_eigen_interop_mpfr_6.cpp
    │   │   │   ├── test_exp.cpp
    │   │   │   ├── test_fixed_int.cpp
    │   │   │   ├── test_fixed_zero_precision_io.cpp
    │   │   │   ├── test_float128_serial.cpp
    │   │   │   ├── test_float_conversions.cpp
    │   │   │   ├── test_float_io.cpp
    │   │   │   ├── test_float_serial.hpp
    │   │   │   ├── test_fpclassify.cpp
    │   │   │   ├── test_gcd.cpp
    │   │   │   ├── test_generic_conv.cpp
    │   │   │   ├── test_gmp_conversions.cpp
    │   │   │   ├── test_hash.cpp
    │   │   │   ├── test_int_io.cpp
    │   │   │   ├── test_int_sqrt.cpp
    │   │   │   ├── test_log.cpp
    │   │   │   ├── test_miller_rabin.cpp
    │   │   │   ├── test_mixed.hpp
    │   │   │   ├── test_mixed_cpp_bin_float.cpp
    │   │   │   ├── test_mixed_cpp_dec_float.cpp
    │   │   │   ├── test_mixed_cpp_int.cpp
    │   │   │   ├── test_mixed_float.cpp
    │   │   │   ├── test_mixed_move_cpp_int.cpp
    │   │   │   ├── test_mixed_mpf_float.cpp
    │   │   │   ├── test_mixed_mpfr_float.cpp
    │   │   │   ├── test_move.cpp
    │   │   │   ├── test_mpc_conversions.cpp
    │   │   │   ├── test_mpc_overloads.cpp
    │   │   │   ├── test_mpf_precisions.cpp
    │   │   │   ├── test_mpfi.cpp
    │   │   │   ├── test_mpfi_precisions.cpp
    │   │   │   ├── test_mpfr_conversions.cpp
    │   │   │   ├── test_mpfr_mpc_precisions.cpp
    │   │   │   ├── test_native_integer.cpp
    │   │   │   ├── test_nothrow_cpp_bin_float.cpp
    │   │   │   ├── test_nothrow_cpp_dec_float.cpp
    │   │   │   ├── test_nothrow_cpp_int.cpp
    │   │   │   ├── test_nothrow_cpp_rational.cpp
    │   │   │   ├── test_nothrow_float128.cpp
    │   │   │   ├── test_nothrow_gmp.cpp
    │   │   │   ├── test_nothrow_mpfr.cpp
    │   │   │   ├── test_numeric_limits.cpp
    │   │   │   ├── test_optional_compat.cpp
    │   │   │   ├── test_pow.cpp
    │   │   │   ├── test_preserve_all_precision.cpp
    │   │   │   ├── test_preserve_component_precision.cpp
    │   │   │   ├── test_preserve_related_precision.cpp
    │   │   │   ├── test_preserve_source_precision.cpp
    │   │   │   ├── test_preserve_target_precision.cpp
    │   │   │   ├── test_rat_float_interconv.cpp
    │   │   │   ├── test_rational_io.cpp
    │   │   │   ├── test_roots_10k_digits.cpp
    │   │   │   ├── test_round.cpp
    │   │   │   ├── test_sf_import_c99.cpp
    │   │   │   ├── test_signed_zero.cpp
    │   │   │   ├── test_sin.cpp
    │   │   │   ├── test_sin_near_half_pi.cpp
    │   │   │   ├── test_sinh.cpp
    │   │   │   ├── test_sqrt.cpp
    │   │   │   ├── test_tan.cpp
    │   │   │   ├── test_tanh.cpp
    │   │   │   ├── test_test.cpp
    │   │   │   ├── test_threaded_precision.cpp
    │   │   │   ├── test_trailing_io_delim.cpp
    │   │   │   ├── test_unchecked_cpp_int.cpp
    │   │   │   ├── timer.hpp
    │   │   │   └── ublas_interop/
    │   │   │       ├── common/
    │   │   │       │   ├── init.hpp
    │   │   │       │   └── testhelper.hpp
    │   │   │       ├── test1.cpp
    │   │   │       ├── test1.hpp
    │   │   │       ├── test11.cpp
    │   │   │       ├── test12.cpp
    │   │   │       ├── test13.cpp
    │   │   │       ├── test2.cpp
    │   │   │       ├── test2.hpp
    │   │   │       ├── test21.cpp
    │   │   │       ├── test22.cpp
    │   │   │       ├── test23.cpp
    │   │   │       ├── test3.cpp
    │   │   │       ├── test3.hpp
    │   │   │       ├── test31.cpp
    │   │   │       ├── test32.cpp
    │   │   │       ├── test33.cpp
    │   │   │       ├── test4.cpp
    │   │   │       ├── test4.hpp
    │   │   │       ├── test42.cpp
    │   │   │       ├── test43.cpp
    │   │   │       ├── test5.cpp
    │   │   │       ├── test5.hpp
    │   │   │       ├── test52.cpp
    │   │   │       ├── test53.cpp
    │   │   │       ├── test6.cpp
    │   │   │       ├── test6.hpp
    │   │   │       ├── test62.cpp
    │   │   │       ├── test63.cpp
    │   │   │       ├── test7.cpp
    │   │   │       ├── test7.hpp
    │   │   │       ├── test71.cpp
    │   │   │       ├── test72.cpp
    │   │   │       └── test73.cpp
    │   │   └── tools/
    │   │       └── sincos.cpp
    │   └── rapidcsv/
    │       ├── .travis.yml
    │       ├── CMakeLists.txt
    │       ├── LICENSE
    │       ├── README.md
    │       ├── appveyor.yml
    │       ├── doc/
    │       │   ├── README.md
    │       │   ├── rapidcsv_Converter.md
    │       │   ├── rapidcsv_ConverterParams.md
    │       │   ├── rapidcsv_Document.md
    │       │   ├── rapidcsv_LabelParams.md
    │       │   ├── rapidcsv_SeparatorParams.md
    │       │   └── rapidcsv_no_converter.md
    │       ├── examples/
    │       │   ├── colhdr.csv
    │       │   ├── colrowhdr.csv
    │       │   ├── ex001.cpp
    │       │   ├── ex002.cpp
    │       │   ├── ex003.cpp
    │       │   ├── ex004.cpp
    │       │   ├── ex005.cpp
    │       │   ├── ex006.cpp
    │       │   ├── ex007.cpp
    │       │   ├── ex008.cpp
    │       │   ├── ex009.cpp
    │       │   ├── nohdr.csv
    │       │   ├── rowhdr.csv
    │       │   └── semi.csv
    │       ├── run.sh
    │       ├── src/
    │       │   └── rapidcsv.h
    │       ├── tests/
    │       │   ├── msft.csv
    │       │   ├── perftest.h
    │       │   ├── ptest001.cpp
    │       │   ├── ptest002.cpp
    │       │   ├── test001.cpp
    │       │   ├── test002.cpp
    │       │   ├── test003.cpp
    │       │   ├── test004.cpp
    │       │   ├── test005.cpp
    │       │   ├── test006.cpp
    │       │   ├── test007.cpp
    │       │   ├── test008.cpp
    │       │   ├── test009.cpp
    │       │   ├── test010.cpp
    │       │   ├── test011.cpp
    │       │   ├── test012.cpp
    │       │   ├── test013.cpp
    │       │   ├── test014.cpp
    │       │   ├── test015.cpp
    │       │   ├── test016.cpp
    │       │   ├── test017.cpp
    │       │   ├── test018.cpp
    │       │   ├── test019.cpp
    │       │   ├── test020.cpp
    │       │   ├── test021.cpp
    │       │   ├── test022.cpp
    │       │   ├── test023.cpp
    │       │   ├── test024.cpp
    │       │   ├── test025.cpp
    │       │   ├── test026.cpp
    │       │   ├── test027.cpp
    │       │   ├── test028.cpp
    │       │   ├── test029.cpp
    │       │   ├── test030.cpp
    │       │   ├── test031.cpp
    │       │   ├── test032.cpp
    │       │   ├── test033.cpp
    │       │   ├── test034.cpp
    │       │   ├── test035.cpp
    │       │   ├── test036.cpp
    │       │   ├── test037.cpp
    │       │   ├── test038.cpp
    │       │   ├── test039.cpp
    │       │   ├── test040.cpp
    │       │   ├── test040b.cpp
    │       │   ├── test041.cpp
    │       │   ├── test042.cpp
    │       │   ├── test043.cpp
    │       │   ├── test044.cpp
    │       │   ├── test045.cpp
    │       │   ├── test046.cpp
    │       │   ├── test047.cpp
    │       │   ├── test048.cpp
    │       │   ├── test049.cpp
    │       │   ├── test050.cpp
    │       │   ├── test051.cpp
    │       │   ├── test052.cpp
    │       │   ├── test053.cpp
    │       │   ├── test054.cpp
    │       │   ├── test055.cpp
    │       │   ├── test056.cpp
    │       │   ├── test057.cpp
    │       │   ├── test058.cpp
    │       │   ├── test059.cpp
    │       │   ├── test060.cpp
    │       │   ├── test061.cpp
    │       │   ├── test062.cpp
    │       │   ├── test063.cpp
    │       │   ├── test064.cpp
    │       │   ├── test065.cpp
    │       │   ├── test066.cpp
    │       │   └── unittest.h
    │       └── uncrustify.cfg
    └── test.ipynb

================================================
FILE CONTENTS
================================================

================================================
FILE: README.md
================================================
# C++20 Fundamentals LiveLessons Code Examples
Source code examples for our **C++20 Fundamentals LiveLessons** Videos.

At the moment, these videos are available only to O'Reilly Online Learning subscribers. For all our books, LiveLessons videos and Full Throttle live webinars on O'Reilly Online Learning, visit: https://deitel.com/LearnWithDeitel

These source-code files are (C) Copyright 2021 by Deitel & Associates, Inc. and Pearson Education, Inc. All Rights Reserved.

You may use these files for your personal purposes, but please do not repost them without our express written consent.

If you have any questions, open an issue in the Issues tab or email us: deitel at deitel dot com.

The authors and publisher of this video product have used their best efforts in preparing these videos. These efforts include the development, research, and testing of the theories and programs to determine their effectiveness. The authors and publisher make no warranty of any kind, expressed or implied, with regard to these programs or to the documentation contained in these videos. The authors and publisher shall not be liable in any event for incidental or consequential damages in connection with, or arising out of, the furnishing, performance, or use of these programs.


================================================
FILE: examples/docker/gcc13/dockerfile
================================================
FROM ubuntu:20.04
RUN apt-get update -y
RUN apt-get install -y build-essential wget
RUN wget --quiet --content-disposition http://kayari.org/gcc-latest/gcc-latest.deb
RUN dpkg -i gcc-latest*.deb
RUN /opt/gcc-latest/bin/g++ --version



================================================
FILE: examples/lesson01/GuessNumber.cpp
================================================
// Randomly generate numbers between 1 and 1000 for user to guess.
#include <iostream>
#include <random> // contains C++11 random number generation features 
using namespace std;

bool isCorrect(int, int); // function prototype

int main() {
   // use the default random-number generation engine to                
   // produce uniformly distributed pseudorandom int values from 1 to 1000
   default_random_engine engine{random_device{}()};
   uniform_int_distribution<int> randomInt{1, 1000};

   char response = 'n'; // determines whether to continue playing

   // loop until user types 'n' to quit game
   do {
      // generate random number between 1 and 1000
      // 1 is shift, 1000 is scaling factor
      const int answer{randomInt(engine)};

      // prompt for guess
      cout << "I have a number between 1 and 1000.\n"
         << "Can you guess my number?\n"
         << "Please type your first guess.\n? ";
      int guess;
      cin >> guess;

      // loop until correct number
      while (!isCorrect(guess, answer)) {
         cin >> guess;
      }

      // prompt for another game
      cout << "\nExcellent! You guessed the number!\n"
         << "Would you like to play again (y or n)? ";
      cin >> response;

      cout << endl;
   } while (response == 'y');

   return 0; // indicate successful termination
} 

// isCorrect returns true if guess equals answer;
// otherwise it displays a hint and returns false
bool isCorrect(int guess, int answer) {
   // guess is correct
   if (guess == answer) {
      return true;
   }

   // guess is incorrect; display hint
   if (guess < answer) {
      cout << "Too low. Try again.\n? ";
   }
   else {
      cout << "Too high. Try again.\n? ";
   }

   return false;
} // end function isCorrect



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_01.cpp
================================================
// fig02_01.cpp
// Text-printing program.
#include <iostream> // enables program to output data to the screen

// function main begins program execution
int main() {
   std::cout << "Welcome to C++!\n"; // display message
   
   return 0; // indicate that program ended successfully
} // end function main











 /*************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_02.cpp
================================================
// fig02_02.cpp
// Displaying a line of text with multiple statements.
#include <iostream> // enables program to output data to the screen

// function main begins program execution
int main() {
   std::cout << "Welcome ";
   std::cout << "to C++!\n";
} // end function main












/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_03.cpp
================================================
// fig02_03.cpp
// Displayings multiple lines of text with a single statement.
#include <iostream> // enables program to output data to the screen

// function main begins program execution
int main() {
   std::cout << "Welcome\nto\n\nC++!\n";
} // end function main



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_04.cpp
================================================
// fig02_04.cpp
// Addition program that displays the sum of two integers.
#include <iostream> // enables program to perform input and output

// function main begins program execution
int main() {
   // declaring and initializing variables
   int number1{0}; // first integer to add (initialized to 0)  
   int number2{0}; // second integer to add (initialized to 0) 
   int sum{0}; // sum of number1 and number2 (initialized to 0)

   std::cout << "Enter first integer: "; // prompt user for data
   std::cin >> number1; // read first integer from user into number1

   std::cout << "Enter second integer: "; // prompt user for data
   std::cin >> number2; // read second integer from user into number2

   sum = number1 + number2; // add the numbers; store result in sum

   std::cout << "Sum is " << sum << "\n"; // display sum
} // end function main



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_05.cpp
================================================
// fig02_05.cpp
// Comparing integers using if statements, relational operators
// and equality operators.
#include <iostream> // enables program to perform input and output

using std::cout; // program uses cout
using std::cin; // program uses cin

// function main begins program execution
int main() {
   int number1{0}; // first integer to compare (initialized to 0)
   int number2{0}; // second integer to compare (initialized to 0)
   
   cout << "Enter two integers to compare: "; // prompt user for data
   cin >> number1 >> number2; // read two integers from user

   if (number1 == number2) {
      cout << number1 << " == " << number2 << "\n";
   }

   if (number1 != number2) {
      cout << number1 << " != " << number2 << "\n";
   }

   if (number1 < number2) {
      cout << number1 << " < " << number2 << "\n";
   }

   if (number1 > number2) {
      cout << number1 << " > " << number2 << "\n";
   }

   if (number1 <= number2) {
      cout << number1 << " <= " << number2 << "\n";
   }

   if (number1 >= number2) {
      cout << number1 << " >= " << number2 << "\n";
   }
} // end function main


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson02/fig02_06.cpp
================================================
// fig02_06.cpp
// Standard library string class test program. 
#include <iostream>
#include <string> 
using namespace std;

int main() {
   string s1{"happy"};    
   string s2{" birthday"};
   string s3; // creates an empty string
              
   // display the strings and show their lengths (length is C++20)
   cout << "s1: \"" << s1 << "\"; length: " << s1.length()
      << "\ns2: \"" << s2 << "\"; length: " << s2.length()
      << "\ns3: \"" << s3 << "\"; length: " << s3.length();

   // compare strings with == and !=
   cout << "\n\nThe results of comparing s2 and s1:" << boolalpha
      << "\ns2 == s1: " << (s2 == s1)
      << "\ns2 != s1: " << (s2 != s1);
   
   // test string member function empty 
   cout << "\n\nTesting s3.empty():\n";

   if (s3.empty()) {
      cout << "s3 is empty; assigning to s3;\n";
      s3 = s1 + s2; // assign s3 the result of concatenating s1 and s2
      cout << "s3: \"" << s3 << "\"";
   } 

   // testing new C++20 string member functions 
   cout << "\n\ns1 starts with \"ha\": " << s1.starts_with("ha") << "\n";
   cout << "s2 starts with \"ha\": " << s2.starts_with("ha") << "\n";
   cout << "s1 ends with \"ay\": " << s1.ends_with("ay") << "\n";
   cout << "s2 ends with \"ay\": " << s2.ends_with("ay") << "\n";
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson03/fig03_01.cpp
================================================
// fig03_01.cpp
// Solving the class-average problem using counter-controlled iteration.
#include <iostream>
using namespace std;

int main() {
   // initialization phase
   int total{0}; // initialize sum of grades entered by the user
   int gradeCounter{1}; // initialize grade # to be entered next

   // processing phase uses counter-controlled iteration
   while (gradeCounter <= 10) { // loop 10 times
      cout << "Enter grade: "; // prompt 
      int grade;
      cin >> grade; // input next grade
      total = total + grade; // add grade to total
      gradeCounter = gradeCounter + 1; // increment counter by 1
   } 

   // termination phase
   int average{total / 10}; // int division yields int result

   // display total and average of grades
   cout << "\nTotal of all 10 grades is " << total;
   cout << "\nClass average is " << average << "\n";
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson03/fig03_02.cpp
================================================
// fig03_02.cpp
// Solving the class-average problem using sentinel-controlled iteration. 
#include <iostream>
#include <iomanip> // parameterized stream manipulators  
using namespace std;

int main() {
   // initialization phase
   double total{0.0}; // initialize sum of grades
   int gradeCounter{0}; // initialize # of grades entered so far
   
   // processing phase
   // prompt for input and read grade from user
   cout << "Enter grade or -1 to quit: "; 
   int grade; 
   cin >> grade; 

   // loop until sentinel value is read from user
   while (grade != -1) {
      total = total + grade; // add grade to total
      gradeCounter = gradeCounter + 1; // increment counter 

      // prompt for input and read next grade from user
      cout << "Enter grade or -1 to quit: "; 
      cin >> grade; 
   }

   // termination phase
   // if user entered at least one grade
   if (gradeCounter != 0) { // avoid division by zero
      // calculate average of grades
      double average{total / gradeCounter};

      // display total and average (with two digits of precision)
      cout << "\nTotal of the " << gradeCounter 
         << " grades entered is " << total;
      cout << setprecision(2) << fixed; 
      cout << "\nClass average is " << average << "\n"; 
   } 
   else { // no grades were entered, so output appropriate message
      cout << "No grades were entered\n"; 
   }
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson03/fig03_03.cpp
================================================
// fig03_03.cpp
// Analysis of examination results using nested control statements.
#include <iostream>
using namespace std;

int main() {
   // initializing variables in declarations
   int passes{0}; 
   int failures{0};
   int studentCounter{1}; 

   // process 10 students using counter-controlled loop
   while (studentCounter <= 10) {
      // prompt user for input and obtain value from user
      cout << "Enter result (1 = pass, 2 = fail): ";
      int result;
      cin >> result;

      // if...else is nested in the while statement           
      if (result == 1) {         
         passes = passes + 1;  
      }
      else {    
         failures = failures + 1; 
      }

      // increment studentCounter so loop eventually terminates
      studentCounter = studentCounter + 1;  
   } 

   // termination phase; prepare and display results
   cout << "Passed: " << passes << "\nFailed: " << failures << "\n";

   // determine whether more than 8 students passed
   if (passes > 8) {
      cout << "Bonus to instructor!\n";
   }
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson03/fig03_04.cpp
================================================
// fig03_04.cpp
// Prefix increment and postfix increment operators.
#include <iostream>
using namespace std;

int main() {
   // demonstrate postfix increment operator
   int c{5}; 
   cout << "c before postincrement: " << c << "\n"; // prints 5
   cout << "    postincrementing c: " << c++ << "\n"; // prints 5
   cout << " c after postincrement: " << c << "\n"; // prints 6                     

   cout << "\n"; // skip a line

   // demonstrate prefix increment operator
   c = 5;  
   cout << " c before preincrement: " << c << "\n"; // prints 5
   cout << "     preincrementing c: " << ++c << "\n"; // prints 6
   cout << "  c after preincrement: " << c << "\n"; // prints 6                     
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson03/fig03_05.cpp
================================================
// fig03_05.cpp
// Conveniently creating and manipulating super-sized integers
// with objects of the Boost Multiprecision library's cpp_int class.
#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
using namespace std;
using boost::multiprecision::cpp_int;
	
int main() {
   // initializing cpp_ints
   const cpp_int value1{"100000000000000000000000000000"}; // 30 digits
   const cpp_int value2{9223372036854775807LL}; // long long max
   const int value3{3}; 
   
   cout << "INITIAL VALUES"
      << "\ncpp_int value1: " << value1
      << "\ncpp_int value2: " << value2
      << "\n    int value3: " << value3;
   
   // arithmetic with cpp_ints
   cout << "\n\nADD, SUBTRACT AND MULTIPLY CPP_INT OBJECTS"
      << "\nvalue1 + value2: " << value1 + value2
      << "\nvalue1 - value2: " << value1 - value2
      << "\nvalue1 * value2: " << value1 * value2;
   
   // arithmetic mixing cpp_ints and integers
   cout << "\n\nMULTIPLY A CPP_INT OBJECT BY INT VALUES"
      << "\nvalue1 * value3: " << value1 * value3
      << "\n    value1 * 17: " << value1 * 17 << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson04/decimalformatter.h
================================================
// decimalformatter.h
// Custom std::formatter that formats a 
// boost::multiprecision::cpp_dec_float_50 as a std::string
// with two digits to the right of the decimal point.
#pragma once
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <format> 
#include <iomanip>
#include <sstream>
#include <string>

// short name for boost::multiprecision::cpp_dec_float_50
using decimal = boost::multiprecision::cpp_dec_float_50;

// Custom formatter for boost::multiprecision::cpp_dec_float_50. 
// Formats as a string with two digits to the right of the decimal point.
// More info at: https://fmt.dev/latest/api.html#format-api
template<> struct std::formatter<decimal> : std::formatter<string_view> {
   template <typename FormatContext>
   auto format(decimal d, FormatContext& ctx) const {
      std::ostringstream out{};
      out << std::fixed << std::setprecision(2) << d;
      return formatter<string_view>::format(out.str(), ctx);
   }
};

================================================
FILE: examples/lesson04/decimalformatter_fmt.h
================================================
// decimalformatter.h
// Custom fmt::formatter that formats a 
// boost::multiprecision::cpp_dec_float_50 as a std::string
// with two digits to the right of the decimal point.
#pragma once
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <fmt/format.h> // in C++20, this will be #include <format>
#include <iomanip>
#include <sstream>
#include <string>

// short name for boost::multiprecision::cpp_dec_float_50
using decimal = boost::multiprecision::cpp_dec_float_50;

// Custom formatter for boost::multiprecision::cpp_dec_float_50. 
// Formats as a string with two digits to the right of the decimal point.
// More info at: https://fmt.dev/latest/api.html#format-api
template<> struct fmt::formatter<decimal> : fmt::formatter<string_view> {
   template <typename FormatContext>
   auto format(decimal d, FormatContext& ctx) const {
      std::ostringstream out{};
      out << std::fixed << std::setprecision(2) << d;
      return formatter<string_view>::format(out.str(), ctx);
   }
};

================================================
FILE: examples/lesson04/ex04_06.cpp
================================================
// ex04_06.cpp
#include <iostream>
using namespace std;

int main() {
   for (int i{1}; i <= 10; i++) {
      for (int j{1}; j <= 5; j++) {
         cout << '@';
      }

      cout << '\n';
   } 
} 

/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_01.cpp
================================================
// fig04_01.cpp
// Counter-controlled iteration with the while iteration statement.
#include <iostream>
using namespace std;

int main() {      
   int counter{1}; // declare and initialize control variable

   while (counter <= 10) { // loop-continuation condition
      cout << counter << "  ";
      ++counter; // increment control variable 
   } 

   cout << "\n"; 
} 

/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_02.cpp
================================================
// fig04_02.cpp
// Counter-controlled iteration with the for iteration statement.
#include <iostream>
using namespace std;

int main() {
   // for statement header includes initialization,  
   // loop-continuation condition and increment
   for (int counter{1}; counter <= 10; ++counter) { 
      cout << counter << "  ";
   }

   cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_03.cpp
================================================
// fig04_03.cpp
// Summing integers with the for statement; introducing text formatting.
#include <format> 
#include <iostream>
using namespace std;

int main() {
   int total{0};

   // total even integers from 2 through 20
   for (int number{2}; number <= 20; number += 2) {
      total += number;                             
   }

   cout << format("Sum is {}\n", total);
} 




/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_03fmt.cpp
================================================
// fig04_03.cpp
// Summing integers with the for statement; introducing text formatting.
#include <fmt/format.h> // C++20: This will be #include <format> 
#include <iostream>
using namespace std;

int main() {
   int total{0};

   // total even integers from 2 through 20
   for (int number{2}; number <= 20; number += 2) {
      total += number;                             
   }

   cout << fmt::format("Sum is {}\n", total);
} 




/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_04.cpp
================================================
// fig04_04.cpp
// Compound-interest calculations with for.
#include <format> 
#include <iostream>
#include <cmath> // for pow function
using namespace std;

int main() {
   double principal{1000.00}; // initial amount before interest
   double rate{0.05}; // interest rate

   cout << format("Initial principal: {:>7.2f}\n", principal)
        << format("    Interest rate: {:>7.2f}\n", rate);

   // display headers
   cout << format("\n{}{:>20}\n", "Year",  "Amount on deposit");

   // calculate amount on deposit for each of ten years              
   for (int year{1}; year <= 10; ++year) {                           
      // calculate amount on deposit at the end of the specified year
      double amount{principal * pow(1.0 + rate, year)} ;             
                                                                     
      // display the year and the amount                             
      cout << format("{:>4d}{:>20.2f}\n", year, amount);
   }                                                                 
}



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_04fmt.cpp
================================================
// fig04_04.cpp
// Compound-interest calculations with for.
#include <fmt/format.h> // C++20: This will be #include <format> 
#include <iostream>
#include <cmath> // for pow function
using namespace std;

int main() {
   double principal{1000.00}; // initial amount before interest
   double rate{0.05}; // interest rate

   cout << fmt::format("Initial principal: {:>7.2f}\n", principal)
        << fmt::format("    Interest rate: {:>7.2f}\n", rate);

   // display headers
   cout << fmt::format("\n{}{:>20}\n", "Year",  "Amount on deposit");

   // calculate amount on deposit for each of ten years              
   for (int year{1}; year <= 10; ++year) {                           
      // calculate amount on deposit at the end of the specified year
      double amount{principal * pow(1.0 + rate, year)} ;             
                                                                     
      // display the year and the amount                             
      cout << fmt::format("{:>4d}{:>20.2f}\n", year, amount);
   }                                                                 
}



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_05.cpp
================================================
// fig04_05.cpp
// do...while iteration statement.
#include <iostream>
using namespace std;

int main() {
   int counter{1}; 

   do {
      cout << counter << "  ";
      ++counter;
   } while (counter <= 10); // end do...while 

   cout << "\n"; 
} 


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_06.cpp
================================================
// fig04_06.cpp
// Using a switch statement to count letter grades.
#include <format>
#include <iostream>
using namespace std;

int main() {
   double total{0.0}; // sum of grades                  
   int gradeCounter{0}; // number of grades entered
   int aCount{0}; // count of A grades             
   int bCount{0}; // count of B grades             
   int cCount{0}; // count of C grades             
   int dCount{0}; // count of D grades             
   int fCount{0}; // count of F grades             

   cout << "Enter the integer grades in the range 0-100.\n"
      << "Type the end-of-file indicator to terminate input:\n"
      << "   On UNIX/Linux/macOS type <Ctrl> d then press Enter\n"
      << "   On Windows type <Ctrl> z then press Enter\n";

   int grade;

   // loop until user enters the end-of-file indicator
   while (cin >> grade) { 
      total += grade; // add grade to total
      ++gradeCounter; // increment number of grades
      
      //  increment appropriate letter-grade counter
      switch (grade / 10) {                        
         case 9:  // grade was between 90          
         case 10: // and 100, inclusive            
            ++aCount;                              
            break; // exits switch                 
                                                   
         case 8: // grade was between 80 and 89    
            ++bCount;                              
            break; // exits switch                 
                                                   
         case 7: // grade was between 70 and 79    
            ++cCount;                              
            break; // exits switch                 
                                                   
         case 6: // grade was between 60 and 69    
            ++dCount;                              
            break; // exits switch                 
                                                   
         default: // grade was less than 60        
            ++fCount;                              
            break; // optional; exits switch anyway
      } // end switch                              
   } // end while 

   // display grade report
   cout << "\nGrade Report:\n";

   // if user entered at least one grade...
   if (gradeCounter != 0) {
      // calculate average of all grades entered
      double average{total / gradeCounter};

      // output summary of results
      cout << format("Total of the {} grades entered is {}\n", 
                 gradeCounter, total)
           << format("Class average is {:.2f}\n\n", average)  
           << "Summary of student's grades:\n"
           << format("A: {}\nB: {}\nC: {}\nD: {}\nF: {}\n",
                 aCount, bCount, cCount, dCount, fCount); 
   } 
   else { // no grades were entered, so output appropriate message
      cout << "No grades were entered\n";
   }
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_06fmt.cpp
================================================
// fig04_06.cpp
// Using a switch statement to count letter grades.
#include <fmt/format.h> // C++20: This will be #include <format> 
#include <iostream>
using namespace std;

int main() {
   double total{0.0}; // sum of grades                  
   int gradeCounter{0}; // number of grades entered
   int aCount{0}; // count of A grades             
   int bCount{0}; // count of B grades             
   int cCount{0}; // count of C grades             
   int dCount{0}; // count of D grades             
   int fCount{0}; // count of F grades             

   cout << "Enter the integer grades in the range 0-100.\n"
      << "Type the end-of-file indicator to terminate input:\n"
      << "   On UNIX/Linux/macOS type <Ctrl> d then press Enter\n"
      << "   On Windows type <Ctrl> z then press Enter\n";

   int grade;

   // loop until user enters the end-of-file indicator
   while (cin >> grade) { 
      total += grade; // add grade to total
      ++gradeCounter; // increment number of grades
      
      //  increment appropriate letter-grade counter
      switch (grade / 10) {                        
         case 9:  // grade was between 90          
         case 10: // and 100, inclusive            
            ++aCount;                              
            break; // exits switch                 
                                                   
         case 8: // grade was between 80 and 89    
            ++bCount;                              
            break; // exits switch                 
                                                   
         case 7: // grade was between 70 and 79    
            ++cCount;                              
            break; // exits switch                 
                                                   
         case 6: // grade was between 60 and 69    
            ++dCount;                              
            break; // exits switch                 
                                                   
         default: // grade was less than 60        
            ++fCount;                              
            break; // optional; exits switch anyway
      } // end switch                              
   } // end while 

   // display grade report
   cout << "\nGrade Report:\n";

   // if user entered at least one grade...
   if (gradeCounter != 0) {
      // calculate average of all grades entered
      double average{total / gradeCounter};

      // output summary of results
      cout << fmt::format("Total of the {} grades entered is {}\n", 
                 gradeCounter, total)
           << fmt::format("Class average is {:.2f}\n\n", average)  
           << "Summary of student's grades:\n"
           << fmt::format("A: {}\nB: {}\nC: {}\nD: {}\nF: {}\n",
                 aCount, bCount, cCount, dCount, fCount); 
   } 
   else { // no grades were entered, so output appropriate message
      cout << "No grades were entered\n";
   }
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_07.cpp
================================================
// fig04_07.cpp
// if statements with initializers.
#include <format> 
#include <iostream>
using namespace std;

int main() {
   if (int value{7}; value == 7) {
      cout << format("value is {}\n", value);
   }
   else {
      cout << format("value is not 7; it is {}\n", value);
   }

   if (int value{13}; value == 9) {
      cout << format("value is {}\n", value);
   }
   else {
      cout << format("value is not 9; it is {}\n", value);
   }
}



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson04/fig04_07_with_error.cpp
================================================
// fig04_07_with_error.cpp
// C++17 if statements with initializers.
#include <iostream>
using namespace std;

int main() {
   if (int value{7}; value == 7) {
      cout << "value is " << value << endl;
   }
   else {
      cout << "value is not 7; it is " << value << endl;
   }

   if (int value{13}; value == 9) {
      cout << "value is " << value << endl;
   }
   else {
      cout << "value is not 9; it is " << value << endl;
   }

   cout << value;
}


/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson04/fig04_07fmt.cpp
================================================
// fig04_07.cpp
// if statements with initializers.
#include <fmt/format.h> // C++20: This will be #include <format> 
#include <iostream>
using namespace std;

int main() {
   if (int value{7}; value == 7) {
      cout << fmt::format("value is {}\n", value);
   }
   else {
      cout << fmt::format("value is not 7; it is {}\n", value);
   }

   if (int value{13}; value == 9) {
      cout << fmt::format("value is {}\n", value);
   }
   else {
      cout << fmt::format("value is not 9; it is {}\n", value);
   }
}



/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson04/fig04_08.cpp
================================================
// fig04_08.cpp
// break statement exiting a for statement.
#include <iostream>
using namespace std;

int main() {
   int count; // control variable also used after loop 
   
   for (count = 1; count <= 10; ++count) { // loop 10 times
      if (count == 5) {
         break; // terminates for loop if count is 5
      }

      cout << count << " ";
   }

   cout << "\nBroke out of loop at count = " << count << "\n";
} 


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_09.cpp
================================================
// fig04_09.cpp
// continue statement terminating an iteration of a for statement.
#include <iostream>
using namespace std;

int main() {
   for (int count{1}; count <= 10; ++count) { // loop 10 times
      if (count == 5) {
         continue; // skip remaining code in loop body if count is 5
      }

      cout << count << " ";
   } 

   cout << "\nUsed continue to skip printing 5\n";
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_10.cpp
================================================
// fig04_10.cpp
// Logical operators.
#include <format>
#include <iostream>
using namespace std;

int main() {
   // create truth table for && (logical AND) operator
   cout << "Logical AND (&&)\n"
      << format("false && false: {}\n", false && false)
      << format("false && true: {}\n", false && true)
      << format("true && false: {}\n", true && false)
      << format("true && true: {}\n\n", true && true);

   // create truth table for || (logical OR) operator
   cout << "Logical OR (||)\n"
      << format("false || false: {}\n", false || false)
      << format("false || true: {}\n", false || true)
      << format("true || false: {}\n", true || false)
      << format("true || true: {}\n\n", true || true);

   // create truth table for ! (logical negation) operator
   cout << "Logical negation (!)\n"
      << format("!false: {}\n", !false)
      << format("!true: {}\n", !true);
} 


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_11.cpp
================================================
// fig04_11.cpp
// Using the miniz-cpp header-only library to write and read a ZIP file.
#include <iostream>
#include <string>
#include "zip_file.hpp"
using namespace std;

int main() {
   cout << "Enter a ZIP file name: ";
   string zipFileName;
   getline(cin, zipFileName); // inputs a line of text

   // strings literals separated only by whitespace are combined 
   // into a single string by the compiler
   string content{ 
      "This chapter introduces all but one of the remaining control "
      "statements--the for, do...while, switch, break and continue "
      "statements. We explore the essentials of counter-controlled "
      "iteration. We use compound-interest calculations to begin "
      "investigating the issues of processing monetary amounts. First, "
      "we discuss the representational errors associated with "
      "floating-point types. We use a switch statement to count the "
      "number of A, B, C, D and F grade equivalents in a set of "
      "numeric grades. We show C++17's enhancements that allow you to "
      "initialize one or more variables of the same type in the "
      "headers of if and switch statements."};

   cout << "\ncontent.length(): " << content.length();

   miniz_cpp::zip_file output; // create zip_file object

   // write content into a text file in outputZipFile
   output.writestr("intro.txt", content); // create file in ZIP
   output.save(zipFileName); // save outputZipFile to zipFileName

   miniz_cpp::zip_file input{zipFileName}; // load zipFileName

   // display input's file name and directory listing
   cout << "\n\nZIP file's name: " << input.get_filename()
      << "\n\nZIP file's directory listing:\n";
   input.printdir(); 

   // display info about the compressed intro.txt file
   miniz_cpp::zip_info info{input.getinfo("intro.txt")};

   cout << "\nFile name: " << info.filename
      << "\nOriginal size: " << info.file_size
      << "\nCompressed size: " << info.compress_size;

   // original file contents
   string extractedContent{input.read(info)};

   cout << "\n\nOriginal contents of intro.txt:\n" << 
      extractedContent << endl;
}

/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson04/fig04_12/fig04_12.cpp
================================================
// fig04_12.cpp
// Compound-interest example with C++20 text formatting.
#include <iostream>
#include <cmath> // for pow function
#include "fmt/format.h" // in C++20, this will be #include <format>
using namespace std;
using namespace fmt; // not needed in C++20

int main() {
   double principal{1000.00}; // initial amount before interest
   double rate{0.05}; // interest rate

   cout << format("Initial principal: {:>7.2f}\n", principal)
        << format("    Interest rate: {:>7.2f}\n", rate);

   // display headers
   cout << format("\n{}{:>20}\n", "Year", "Amount on deposit");

   // calculate amount on deposit for each of ten years
   for (int year{1}; year <= 10; ++year) {
      // calculate amount on deposit at the end of the specified year
      double amount = principal * pow(1.0 + rate, year);

      // display the year and the amount
      cout << format("{:>4d}{:>20.2f}\n", year, amount);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson04/fig04_12/fmt/core.h
================================================
// Formatting library for C++ - the core API
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_CORE_H_
#define FMT_CORE_H_

#include <cstdio>  // std::FILE
#include <cstring>
#include <functional>
#include <iterator>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 60200

#ifdef __has_feature
#  define FMT_HAS_FEATURE(x) __has_feature(x)
#else
#  define FMT_HAS_FEATURE(x) 0
#endif

#if defined(__has_include) && !defined(__INTELLISENSE__) && \
    !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
#  define FMT_HAS_INCLUDE(x) __has_include(x)
#else
#  define FMT_HAS_INCLUDE(x) 0
#endif

#ifdef __has_cpp_attribute
#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif

#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
  (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
  (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#ifdef __clang__
#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
#else
#  define FMT_CLANG_VERSION 0
#endif

#if defined(__GNUC__) && !defined(__clang__)
#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#else
#  define FMT_GCC_VERSION 0
#endif

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#else
#  define FMT_HAS_GXX_CXX11 0
#endif

#ifdef __NVCC__
#  define FMT_NVCC __NVCC__
#else
#  define FMT_NVCC 0
#endif

#ifdef _MSC_VER
#  define FMT_MSC_VER _MSC_VER
#else
#  define FMT_MSC_VER 0
#endif

// Check if relaxed C++14 constexpr is supported.
// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
#ifndef FMT_USE_CONSTEXPR
#  define FMT_USE_CONSTEXPR                                           \
    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
        !FMT_NVCC
#endif
#if FMT_USE_CONSTEXPR
#  define FMT_CONSTEXPR constexpr
#  define FMT_CONSTEXPR_DECL constexpr
#else
#  define FMT_CONSTEXPR inline
#  define FMT_CONSTEXPR_DECL
#endif

#ifndef FMT_OVERRIDE
#  if FMT_HAS_FEATURE(cxx_override) || \
      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
#    define FMT_OVERRIDE override
#  else
#    define FMT_OVERRIDE
#  endif
#endif

// Check if exceptions are disabled.
#ifndef FMT_EXCEPTIONS
#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
      FMT_MSC_VER && !_HAS_EXCEPTIONS
#    define FMT_EXCEPTIONS 0
#  else
#    define FMT_EXCEPTIONS 1
#  endif
#endif

// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
#  define FMT_USE_NOEXCEPT 0
#endif

#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
#  define FMT_DETECTED_NOEXCEPT noexcept
#  define FMT_HAS_CXX11_NOEXCEPT 1
#else
#  define FMT_DETECTED_NOEXCEPT throw()
#  define FMT_HAS_CXX11_NOEXCEPT 0
#endif

#ifndef FMT_NOEXCEPT
#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
#  else
#    define FMT_NOEXCEPT
#  endif
#endif

// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
// warnings.
#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
    !FMT_NVCC
#  define FMT_NORETURN [[noreturn]]
#else
#  define FMT_NORETURN
#endif

#ifndef FMT_MAYBE_UNUSED
#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
#    define FMT_MAYBE_UNUSED [[maybe_unused]]
#  else
#    define FMT_MAYBE_UNUSED
#  endif
#endif

#ifndef FMT_DEPRECATED
#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
#    define FMT_DEPRECATED [[deprecated]]
#  else
#    if defined(__GNUC__) || defined(__clang__)
#      define FMT_DEPRECATED __attribute__((deprecated))
#    elif FMT_MSC_VER
#      define FMT_DEPRECATED __declspec(deprecated)
#    else
#      define FMT_DEPRECATED /* deprecated */
#    endif
#  endif
#endif

// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
#if defined(__INTEL_COMPILER) || defined(__PGI) || FMT_NVCC
#  define FMT_DEPRECATED_ALIAS
#else
#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
#endif

#ifndef FMT_BEGIN_NAMESPACE
#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
      FMT_MSC_VER >= 1900
#    define FMT_INLINE_NAMESPACE inline namespace
#    define FMT_END_NAMESPACE \
      }                       \
      }
#  else
#    define FMT_INLINE_NAMESPACE namespace
#    define FMT_END_NAMESPACE \
      }                       \
      using namespace v6;     \
      }
#  endif
#  define FMT_BEGIN_NAMESPACE \
    namespace fmt {           \
    FMT_INLINE_NAMESPACE v6 {
#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
#  if FMT_MSC_VER
#    define FMT_NO_W4275 __pragma(warning(suppress : 4275))
#  else
#    define FMT_NO_W4275
#  endif
#  define FMT_CLASS_API FMT_NO_W4275
#  ifdef FMT_EXPORT
#    define FMT_API __declspec(dllexport)
#  elif defined(FMT_SHARED)
#    define FMT_API __declspec(dllimport)
#    define FMT_EXTERN_TEMPLATE_API FMT_API
#  endif
#endif
#ifndef FMT_CLASS_API
#  define FMT_CLASS_API
#endif
#ifndef FMT_API
#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
#    define FMT_API __attribute__((visibility("default")))
#    define FMT_EXTERN_TEMPLATE_API FMT_API
#    define FMT_INSTANTIATION_DEF_API
#  else
#    define FMT_API
#  endif
#endif
#ifndef FMT_EXTERN_TEMPLATE_API
#  define FMT_EXTERN_TEMPLATE_API
#endif
#ifndef FMT_INSTANTIATION_DEF_API
#  define FMT_INSTANTIATION_DEF_API FMT_API
#endif

#ifndef FMT_HEADER_ONLY
#  define FMT_EXTERN extern
#else
#  define FMT_EXTERN
#endif

// libc++ supports string_view in pre-c++17.
#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
#  include <string_view>
#  define FMT_USE_STRING_VIEW
#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
#  include <experimental/string_view>
#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
#endif

#ifndef FMT_UNICODE
#  define FMT_UNICODE !FMT_MSC_VER
#endif
#if FMT_UNICODE && FMT_MSC_VER
#  pragma execution_character_set("utf-8")
#endif

FMT_BEGIN_NAMESPACE

// Implementations of enable_if_t and other metafunctions for older systems.
template <bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template <bool B, class T, class F>
using conditional_t = typename std::conditional<B, T, F>::type;
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <typename T>
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
template <typename T> struct type_identity { using type = T; };
template <typename T> using type_identity_t = typename type_identity<T>::type;

struct monostate {};

// An enable_if helper to be used in template parameters which results in much
// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0

namespace internal {

// A helper function to suppress bogus "conditional expression is constant"
// warnings.
template <typename T> FMT_CONSTEXPR T const_check(T value) { return value; }

// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
template <typename... Ts> struct void_t_impl { using type = void; };

FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
                                      const char* message);

#ifndef FMT_ASSERT
#  ifdef NDEBUG
// FMT_ASSERT is not empty to avoid -Werror=empty-body.
#    define FMT_ASSERT(condition, message) ((void)0)
#  else
#    define FMT_ASSERT(condition, message)                                    \
      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
           ? (void)0                                                          \
           : ::fmt::internal::assert_fail(__FILE__, __LINE__, (message)))
#  endif
#endif

#if defined(FMT_USE_STRING_VIEW)
template <typename Char> using std_string_view = std::basic_string_view<Char>;
#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
template <typename Char>
using std_string_view = std::experimental::basic_string_view<Char>;
#else
template <typename T> struct std_string_view {};
#endif

#ifdef FMT_USE_INT128
// Do nothing.
#elif defined(__SIZEOF_INT128__) && !FMT_NVCC
#  define FMT_USE_INT128 1
using int128_t = __int128_t;
using uint128_t = __uint128_t;
#else
#  define FMT_USE_INT128 0
#endif
#if !FMT_USE_INT128
struct int128_t {};
struct uint128_t {};
#endif

// Casts a nonnegative integer to unsigned.
template <typename Int>
FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
  FMT_ASSERT(value >= 0, "negative value");
  return static_cast<typename std::make_unsigned<Int>::type>(value);
}

constexpr unsigned char micro[] = "\u00B5";

template <typename Char> constexpr bool is_unicode() {
  return FMT_UNICODE || sizeof(Char) != 1 ||
         (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);
}

#ifdef __cpp_char8_t
using char8_type = char8_t;
#else
enum char8_type : unsigned char {};
#endif
}  // namespace internal

template <typename... Ts>
using void_t = typename internal::void_t_impl<Ts...>::type;

/**
  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
  subset of the API. ``fmt::basic_string_view`` is used for format strings even
  if ``std::string_view`` is available to prevent issues when a library is
  compiled with a different ``-std`` option than the client code (which is not
  recommended).
 */
template <typename Char> class basic_string_view {
 private:
  const Char* data_;
  size_t size_;

 public:
  using char_type FMT_DEPRECATED_ALIAS = Char;
  using value_type = Char;
  using iterator = const Char*;

  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}

  /** Constructs a string reference object from a C string and a size. */
  FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
      : data_(s),
        size_(count) {}

  /**
    \rst
    Constructs a string reference object from a C string computing
    the size with ``std::char_traits<Char>::length``.
    \endrst
   */
#if __cplusplus >= 201703L  // C++17's char_traits::length() is constexpr.
  FMT_CONSTEXPR
#endif
  basic_string_view(const Char* s)
      : data_(s), size_(std::char_traits<Char>::length(s)) {}

  /** Constructs a string reference from a ``std::basic_string`` object. */
  template <typename Traits, typename Alloc>
  FMT_CONSTEXPR basic_string_view(
      const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
      : data_(s.data()),
        size_(s.size()) {}

  template <
      typename S,
      FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
  FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
                                                      size_(s.size()) {}

  /** Returns a pointer to the string data. */
  FMT_CONSTEXPR const Char* data() const { return data_; }

  /** Returns the string size. */
  FMT_CONSTEXPR size_t size() const { return size_; }

  FMT_CONSTEXPR iterator begin() const { return data_; }
  FMT_CONSTEXPR iterator end() const { return data_ + size_; }

  FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }

  FMT_CONSTEXPR void remove_prefix(size_t n) {
    data_ += n;
    size_ -= n;
  }

  // Lexicographically compare this string reference to other.
  int compare(basic_string_view other) const {
    size_t str_size = size_ < other.size_ ? size_ : other.size_;
    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
    if (result == 0)
      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
    return result;
  }

  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) == 0;
  }
  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) != 0;
  }
  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) < 0;
  }
  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) <= 0;
  }
  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) > 0;
  }
  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
    return lhs.compare(rhs) >= 0;
  }
};

using string_view = basic_string_view<char>;
using wstring_view = basic_string_view<wchar_t>;

#ifndef __cpp_char8_t
// char8_t is deprecated; use char instead.
using char8_t FMT_DEPRECATED_ALIAS = internal::char8_type;
#endif

/** Specifies if ``T`` is a character type. Can be specialized by users. */
template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};
template <> struct is_char<wchar_t> : std::true_type {};
template <> struct is_char<internal::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {};

/**
  \rst
  Returns a string view of `s`. In order to add custom string type support to
  {fmt} provide an overload of `to_string_view` for it in the same namespace as
  the type for the argument-dependent lookup to work.

  **Example**::

    namespace my_ns {
    inline string_view to_string_view(const my_string& s) {
      return {s.data(), s.length()};
    }
    }
    std::string message = fmt::format(my_string("The answer is {}"), 42);
  \endrst
 */
template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
inline basic_string_view<Char> to_string_view(const Char* s) {
  return s;
}

template <typename Char, typename Traits, typename Alloc>
inline basic_string_view<Char> to_string_view(
    const std::basic_string<Char, Traits, Alloc>& s) {
  return s;
}

template <typename Char>
inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
  return s;
}

template <typename Char,
          FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
inline basic_string_view<Char> to_string_view(
    internal::std_string_view<Char> s) {
  return s;
}

// A base class for compile-time strings. It is defined in the fmt namespace to
// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
struct compile_string {};

template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};

template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
  return s;
}

namespace internal {
void to_string_view(...);
using fmt::v6::to_string_view;

// Specifies whether S is a string type convertible to fmt::basic_string_view.
// It should be a constexpr function but MSVC 2017 fails to compile it in
// enable_if and MSVC 2015 fails to compile it as an alias template.
template <typename S>
struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
};

template <typename S, typename = void> struct char_t_impl {};
template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
  using result = decltype(to_string_view(std::declval<S>()));
  using type = typename result::value_type;
};

struct error_handler {
  FMT_CONSTEXPR error_handler() = default;
  FMT_CONSTEXPR error_handler(const error_handler&) = default;

  // This function is intentionally not constexpr to give a compile-time error.
  FMT_NORETURN FMT_API void on_error(const char* message);
};
}  // namespace internal

/** String's character type. */
template <typename S> using char_t = typename internal::char_t_impl<S>::type;

/**
  \rst
  Parsing context consisting of a format string range being parsed and an
  argument counter for automatic indexing.

  You can use one of the following type aliases for common character types:

  +-----------------------+-------------------------------------+
  | Type                  | Definition                          |
  +=======================+=====================================+
  | format_parse_context  | basic_format_parse_context<char>    |
  +-----------------------+-------------------------------------+
  | wformat_parse_context | basic_format_parse_context<wchar_t> |
  +-----------------------+-------------------------------------+
  \endrst
 */
template <typename Char, typename ErrorHandler = internal::error_handler>
class basic_format_parse_context : private ErrorHandler {
 private:
  basic_string_view<Char> format_str_;
  int next_arg_id_;

 public:
  using char_type = Char;
  using iterator = typename basic_string_view<Char>::iterator;

  explicit FMT_CONSTEXPR basic_format_parse_context(
      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
      : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}

  /**
    Returns an iterator to the beginning of the format string range being
    parsed.
   */
  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
    return format_str_.begin();
  }

  /**
    Returns an iterator past the end of the format string range being parsed.
   */
  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }

  /** Advances the begin iterator to ``it``. */
  FMT_CONSTEXPR void advance_to(iterator it) {
    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
  }

  /**
    Reports an error if using the manual argument indexing; otherwise returns
    the next argument index and switches to the automatic indexing.
   */
  FMT_CONSTEXPR int next_arg_id() {
    if (next_arg_id_ >= 0) return next_arg_id_++;
    on_error("cannot switch from manual to automatic argument indexing");
    return 0;
  }

  /**
    Reports an error if using the automatic argument indexing; otherwise
    switches to the manual indexing.
   */
  FMT_CONSTEXPR void check_arg_id(int) {
    if (next_arg_id_ > 0)
      on_error("cannot switch from automatic to manual argument indexing");
    else
      next_arg_id_ = -1;
  }

  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}

  FMT_CONSTEXPR void on_error(const char* message) {
    ErrorHandler::on_error(message);
  }

  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
};

using format_parse_context = basic_format_parse_context<char>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;

template <typename Char, typename ErrorHandler = internal::error_handler>
using basic_parse_context FMT_DEPRECATED_ALIAS =
    basic_format_parse_context<Char, ErrorHandler>;
using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<char>;
using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<wchar_t>;

template <typename Context> class basic_format_arg;
template <typename Context> class basic_format_args;

// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
  // A deleted default constructor indicates a disabled formatter.
  formatter() = delete;
};

template <typename T, typename Char, typename Enable = void>
struct FMT_DEPRECATED convert_to_int
    : bool_constant<!std::is_arithmetic<T>::value &&
                    std::is_convertible<T, int>::value> {};

// Specifies if T has an enabled formatter specialization. A type can be
// formattable even if it doesn't have a formatter e.g. via a conversion.
template <typename T, typename Context>
using has_formatter =
    std::is_constructible<typename Context::template formatter_type<T>>;

namespace internal {

/** A contiguous memory buffer with an optional growing ability. */
template <typename T> class buffer {
 private:
  T* ptr_;
  std::size_t size_;
  std::size_t capacity_;

 protected:
  // Don't initialize ptr_ since it is not accessed to save a few cycles.
  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}

  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
      : ptr_(p),
        size_(sz),
        capacity_(cap) {}

  /** Sets the buffer data and capacity. */
  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
    ptr_ = buf_data;
    capacity_ = buf_capacity;
  }

  /** Increases the buffer capacity to hold at least *capacity* elements. */
  virtual void grow(std::size_t capacity) = 0;

 public:
  using value_type = T;
  using const_reference = const T&;

  buffer(const buffer&) = delete;
  void operator=(const buffer&) = delete;
  virtual ~buffer() = default;

  T* begin() FMT_NOEXCEPT { return ptr_; }
  T* end() FMT_NOEXCEPT { return ptr_ + size_; }

  const T* begin() const FMT_NOEXCEPT { return ptr_; }
  const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }

  /** Returns the size of this buffer. */
  std::size_t size() const FMT_NOEXCEPT { return size_; }

  /** Returns the capacity of this buffer. */
  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }

  /** Returns a pointer to the buffer data. */
  T* data() FMT_NOEXCEPT { return ptr_; }

  /** Returns a pointer to the buffer data. */
  const T* data() const FMT_NOEXCEPT { return ptr_; }

  /**
    Resizes the buffer. If T is a POD type new elements may not be initialized.
   */
  void resize(std::size_t new_size) {
    reserve(new_size);
    size_ = new_size;
  }

  /** Clears this buffer. */
  void clear() { size_ = 0; }

  /** Reserves space to store at least *capacity* elements. */
  void reserve(std::size_t new_capacity) {
    if (new_capacity > capacity_) grow(new_capacity);
  }

  void push_back(const T& value) {
    reserve(size_ + 1);
    ptr_[size_++] = value;
  }

  /** Appends data to the end of the buffer. */
  template <typename U> void append(const U* begin, const U* end);

  template <typename I> T& operator[](I index) { return ptr_[index]; }
  template <typename I> const T& operator[](I index) const {
    return ptr_[index];
  }
};

// A container-backed buffer.
template <typename Container>
class container_buffer : public buffer<typename Container::value_type> {
 private:
  Container& container_;

 protected:
  void grow(std::size_t capacity) FMT_OVERRIDE {
    container_.resize(capacity);
    this->set(&container_[0], capacity);
  }

 public:
  explicit container_buffer(Container& c)
      : buffer<typename Container::value_type>(c.size()), container_(c) {}
};

// Extracts a reference to the container from back_insert_iterator.
template <typename Container>
inline Container& get_container(std::back_insert_iterator<Container> it) {
  using bi_iterator = std::back_insert_iterator<Container>;
  struct accessor : bi_iterator {
    accessor(bi_iterator iter) : bi_iterator(iter) {}
    using bi_iterator::container;
  };
  return *accessor(it).container;
}

template <typename T, typename Char = char, typename Enable = void>
struct fallback_formatter {
  fallback_formatter() = delete;
};

// Specifies if T has an enabled fallback_formatter specialization.
template <typename T, typename Context>
using has_fallback_formatter =
    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;

template <typename Char> struct named_arg_base;
template <typename T, typename Char> struct named_arg;

enum class type {
  none_type,
  named_arg_type,
  // Integer types should go first,
  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  int128_type,
  uint128_type,
  bool_type,
  char_type,
  last_integer_type = char_type,
  // followed by floating-point types.
  float_type,
  double_type,
  long_double_type,
  last_numeric_type = long_double_type,
  cstring_type,
  string_type,
  pointer_type,
  custom_type
};

// Maps core type T to the corresponding type enum constant.
template <typename T, typename Char>
struct type_constant : std::integral_constant<type, type::custom_type> {};

#define FMT_TYPE_CONSTANT(Type, constant) \
  template <typename Char>                \
  struct type_constant<Type, Char>        \
      : std::integral_constant<type, type::constant> {}

FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
FMT_TYPE_CONSTANT(int, int_type);
FMT_TYPE_CONSTANT(unsigned, uint_type);
FMT_TYPE_CONSTANT(long long, long_long_type);
FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
FMT_TYPE_CONSTANT(int128_t, int128_type);
FMT_TYPE_CONSTANT(uint128_t, uint128_type);
FMT_TYPE_CONSTANT(bool, bool_type);
FMT_TYPE_CONSTANT(Char, char_type);
FMT_TYPE_CONSTANT(float, float_type);
FMT_TYPE_CONSTANT(double, double_type);
FMT_TYPE_CONSTANT(long double, long_double_type);
FMT_TYPE_CONSTANT(const Char*, cstring_type);
FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
FMT_TYPE_CONSTANT(const void*, pointer_type);

FMT_CONSTEXPR bool is_integral_type(type t) {
  FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
  return t > type::none_type && t <= type::last_integer_type;
}

FMT_CONSTEXPR bool is_arithmetic_type(type t) {
  FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
  return t > type::none_type && t <= type::last_numeric_type;
}

template <typename Char> struct string_value {
  const Char* data;
  std::size_t size;
};

template <typename Context> struct custom_value {
  using parse_context = basic_format_parse_context<typename Context::char_type>;
  const void* value;
  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
};

// A formatting argument value.
template <typename Context> class value {
 public:
  using char_type = typename Context::char_type;

  union {
    int int_value;
    unsigned uint_value;
    long long long_long_value;
    unsigned long long ulong_long_value;
    int128_t int128_value;
    uint128_t uint128_value;
    bool bool_value;
    char_type char_value;
    float float_value;
    double double_value;
    long double long_double_value;
    const void* pointer;
    string_value<char_type> string;
    custom_value<Context> custom;
    const named_arg_base<char_type>* named_arg;
  };

  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
  FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
  value(long long val) : long_long_value(val) {}
  value(unsigned long long val) : ulong_long_value(val) {}
  value(int128_t val) : int128_value(val) {}
  value(uint128_t val) : uint128_value(val) {}
  value(float val) : float_value(val) {}
  value(double val) : double_value(val) {}
  value(long double val) : long_double_value(val) {}
  value(bool val) : bool_value(val) {}
  value(char_type val) : char_value(val) {}
  value(const char_type* val) { string.data = val; }
  value(basic_string_view<char_type> val) {
    string.data = val.data();
    string.size = val.size();
  }
  value(const void* val) : pointer(val) {}

  template <typename T> value(const T& val) {
    custom.value = &val;
    // Get the formatter type through the context to allow different contexts
    // have different extension points, e.g. `formatter<T>` for `format` and
    // `printf_formatter<T>` for `printf`.
    custom.format = format_custom_arg<
        T, conditional_t<has_formatter<T, Context>::value,
                         typename Context::template formatter_type<T>,
                         fallback_formatter<T, char_type>>>;
  }

  value(const named_arg_base<char_type>& val) { named_arg = &val; }

 private:
  // Formats an argument of a custom type, such as a user-defined class.
  template <typename T, typename Formatter>
  static void format_custom_arg(
      const void* arg, basic_format_parse_context<char_type>& parse_ctx,
      Context& ctx) {
    Formatter f;
    parse_ctx.advance_to(f.parse(parse_ctx));
    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
  }
};

template <typename Context, typename T>
FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);

// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
enum { long_short = sizeof(long) == sizeof(int) };
using long_type = conditional_t<long_short, int, long long>;
using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;

// Maps formatting arguments to core types.
template <typename Context> struct arg_mapper {
  using char_type = typename Context::char_type;

  FMT_CONSTEXPR int map(signed char val) { return val; }
  FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
  FMT_CONSTEXPR int map(short val) { return val; }
  FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
  FMT_CONSTEXPR int map(int val) { return val; }
  FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
  FMT_CONSTEXPR long_type map(long val) { return val; }
  FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
  FMT_CONSTEXPR long long map(long long val) { return val; }
  FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
  FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
  FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
  FMT_CONSTEXPR bool map(bool val) { return val; }

  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
  FMT_CONSTEXPR char_type map(T val) {
    static_assert(
        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
        "mixing character types is disallowed");
    return val;
  }

  FMT_CONSTEXPR float map(float val) { return val; }
  FMT_CONSTEXPR double map(double val) { return val; }
  FMT_CONSTEXPR long double map(long double val) { return val; }

  FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
  FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
    static_assert(std::is_same<char_type, char_t<T>>::value,
                  "mixing character types is disallowed");
    return to_string_view(val);
  }
  template <typename T,
            FMT_ENABLE_IF(
                std::is_constructible<basic_string_view<char_type>, T>::value &&
                !is_string<T>::value && !has_formatter<T, Context>::value &&
                !has_fallback_formatter<T, Context>::value)>
  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
    return basic_string_view<char_type>(val);
  }
  template <
      typename T,
      FMT_ENABLE_IF(
          std::is_constructible<std_string_view<char_type>, T>::value &&
          !std::is_constructible<basic_string_view<char_type>, T>::value &&
          !is_string<T>::value && !has_formatter<T, Context>::value &&
          !has_fallback_formatter<T, Context>::value)>
  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
    return std_string_view<char_type>(val);
  }
  FMT_CONSTEXPR const char* map(const signed char* val) {
    static_assert(std::is_same<char_type, char>::value, "invalid string type");
    return reinterpret_cast<const char*>(val);
  }
  FMT_CONSTEXPR const char* map(const unsigned char* val) {
    static_assert(std::is_same<char_type, char>::value, "invalid string type");
    return reinterpret_cast<const char*>(val);
  }

  FMT_CONSTEXPR const void* map(void* val) { return val; }
  FMT_CONSTEXPR const void* map(const void* val) { return val; }
  FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
  template <typename T> FMT_CONSTEXPR int map(const T*) {
    // Formatting of arbitrary pointers is disallowed. If you want to output
    // a pointer cast it to "void *" or "const void *". In particular, this
    // forbids formatting of "[const] volatile char *" which is printed as bool
    // by iostreams.
    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
    return 0;
  }

  template <typename T,
            FMT_ENABLE_IF(std::is_enum<T>::value &&
                          !has_formatter<T, Context>::value &&
                          !has_fallback_formatter<T, Context>::value)>
  FMT_CONSTEXPR auto map(const T& val)
      -> decltype(std::declval<arg_mapper>().map(
          static_cast<typename std::underlying_type<T>::type>(val))) {
    return map(static_cast<typename std::underlying_type<T>::type>(val));
  }
  template <typename T,
            FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
                          (has_formatter<T, Context>::value ||
                           has_fallback_formatter<T, Context>::value))>
  FMT_CONSTEXPR const T& map(const T& val) {
    return val;
  }

  template <typename T>
  FMT_CONSTEXPR const named_arg_base<char_type>& map(
      const named_arg<T, char_type>& val) {
    auto arg = make_arg<Context>(val.value);
    std::memcpy(val.data, &arg, sizeof(arg));
    return val;
  }

  int map(...) {
    constexpr bool formattable = sizeof(Context) == 0;
    static_assert(
        formattable,
        "Cannot format argument. To make type T formattable provide a "
        "formatter<T> specialization: "
        "https://fmt.dev/latest/api.html#formatting-user-defined-types");
    return 0;
  }
};

// A type constant after applying arg_mapper<Context>.
template <typename T, typename Context>
using mapped_type_constant =
    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
                  typename Context::char_type>;

enum { packed_arg_bits = 5 };
// Maximum number of arguments with packed types.
enum { max_packed_args = 63 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };

template <typename Context> class arg_map;
}  // namespace internal

// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in basic_memory_buffer.
template <typename Context> class basic_format_arg {
 private:
  internal::value<Context> value_;
  internal::type type_;

  template <typename ContextType, typename T>
  friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
      const T& value);

  template <typename Visitor, typename Ctx>
  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
                                             const basic_format_arg<Ctx>& arg)
      -> decltype(vis(0));

  friend class basic_format_args<Context>;
  friend class internal::arg_map<Context>;

  using char_type = typename Context::char_type;

 public:
  class handle {
   public:
    explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}

    void format(basic_format_parse_context<char_type>& parse_ctx,
                Context& ctx) const {
      custom_.format(custom_.value, parse_ctx, ctx);
    }

   private:
    internal::custom_value<Context> custom_;
  };

  FMT_CONSTEXPR basic_format_arg() : type_(internal::type::none_type) {}

  FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {
    return type_ != internal::type::none_type;
  }

  internal::type type() const { return type_; }

  bool is_integral() const { return internal::is_integral_type(type_); }
  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
};

/**
  \rst
  Visits an argument dispatching to the appropriate visit method based on
  the argument type. For example, if the argument type is ``double`` then
  ``vis(value)`` will be called with the value of type ``double``.
  \endrst
 */
template <typename Visitor, typename Context>
FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
                                    const basic_format_arg<Context>& arg)
    -> decltype(vis(0)) {
  using char_type = typename Context::char_type;
  switch (arg.type_) {
  case internal::type::none_type:
    break;
  case internal::type::named_arg_type:
    FMT_ASSERT(false, "invalid argument type");
    break;
  case internal::type::int_type:
    return vis(arg.value_.int_value);
  case internal::type::uint_type:
    return vis(arg.value_.uint_value);
  case internal::type::long_long_type:
    return vis(arg.value_.long_long_value);
  case internal::type::ulong_long_type:
    return vis(arg.value_.ulong_long_value);
#if FMT_USE_INT128
  case internal::type::int128_type:
    return vis(arg.value_.int128_value);
  case internal::type::uint128_type:
    return vis(arg.value_.uint128_value);
#else
  case internal::type::int128_type:
  case internal::type::uint128_type:
    break;
#endif
  case internal::type::bool_type:
    return vis(arg.value_.bool_value);
  case internal::type::char_type:
    return vis(arg.value_.char_value);
  case internal::type::float_type:
    return vis(arg.value_.float_value);
  case internal::type::double_type:
    return vis(arg.value_.double_value);
  case internal::type::long_double_type:
    return vis(arg.value_.long_double_value);
  case internal::type::cstring_type:
    return vis(arg.value_.string.data);
  case internal::type::string_type:
    return vis(basic_string_view<char_type>(arg.value_.string.data,
                                            arg.value_.string.size));
  case internal::type::pointer_type:
    return vis(arg.value_.pointer);
  case internal::type::custom_type:
    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
  }
  return vis(monostate());
}

namespace internal {
// A map from argument names to their values for named arguments.
template <typename Context> class arg_map {
 private:
  using char_type = typename Context::char_type;

  struct entry {
    basic_string_view<char_type> name;
    basic_format_arg<Context> arg;
  };

  entry* map_;
  unsigned size_;

  void push_back(value<Context> val) {
    const auto& named = *val.named_arg;
    map_[size_] = {named.name, named.template deserialize<Context>()};
    ++size_;
  }

 public:
  arg_map(const arg_map&) = delete;
  void operator=(const arg_map&) = delete;
  arg_map() : map_(nullptr), size_(0) {}
  void init(const basic_format_args<Context>& args);
  ~arg_map() { delete[] map_; }

  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
    // The list is unsorted, so just return the first matching name.
    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
      if (it->name == name) return it->arg;
    }
    return {};
  }
};

// A type-erased reference to an std::locale to avoid heavy <locale> include.
class locale_ref {
 private:
  const void* locale_;  // A type-erased pointer to std::locale.

 public:
  locale_ref() : locale_(nullptr) {}
  template <typename Locale> explicit locale_ref(const Locale& loc);

  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }

  template <typename Locale> Locale get() const;
};

template <typename> constexpr unsigned long long encode_types() { return 0; }

template <typename Context, typename Arg, typename... Args>
constexpr unsigned long long encode_types() {
  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
         (encode_types<Context, Args...>() << packed_arg_bits);
}

template <typename Context, typename T>
FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
  basic_format_arg<Context> arg;
  arg.type_ = mapped_type_constant<T, Context>::value;
  arg.value_ = arg_mapper<Context>().map(value);
  return arg;
}

template <bool IS_PACKED, typename Context, typename T,
          FMT_ENABLE_IF(IS_PACKED)>
inline value<Context> make_arg(const T& val) {
  return arg_mapper<Context>().map(val);
}

template <bool IS_PACKED, typename Context, typename T,
          FMT_ENABLE_IF(!IS_PACKED)>
inline basic_format_arg<Context> make_arg(const T& value) {
  return make_arg<Context>(value);
}

template <typename T> struct is_reference_wrapper : std::false_type {};

template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};

class dynamic_arg_list {
  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
  // templates it doesn't complain about inability to deduce single translation
  // unit for placing vtable. So storage_node_base is made a fake template.
  template <typename = void> struct node {
    virtual ~node() = default;
    std::unique_ptr<node<>> next;
  };

  template <typename T> struct typed_node : node<> {
    T value;

    template <typename Arg>
    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}

    template <typename Char>
    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
        : value(arg.data(), arg.size()) {}
  };

  std::unique_ptr<node<>> head_;

 public:
  template <typename T, typename Arg> const T& push(const Arg& arg) {
    auto node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
    auto& value = node->value;
    node->next = std::move(head_);
    head_ = std::move(node);
    return value;
  }
};
}  // namespace internal

// Formatting context.
template <typename OutputIt, typename Char> class basic_format_context {
 public:
  /** The character type for the output. */
  using char_type = Char;

 private:
  OutputIt out_;
  basic_format_args<basic_format_context> args_;
  internal::arg_map<basic_format_context> map_;
  internal::locale_ref loc_;

 public:
  using iterator = OutputIt;
  using format_arg = basic_format_arg<basic_format_context>;
  template <typename T> using formatter_type = formatter<T, char_type>;

  basic_format_context(const basic_format_context&) = delete;
  void operator=(const basic_format_context&) = delete;
  /**
   Constructs a ``basic_format_context`` object. References to the arguments are
   stored in the object so make sure they have appropriate lifetimes.
   */
  basic_format_context(OutputIt out,
                       basic_format_args<basic_format_context> ctx_args,
                       internal::locale_ref loc = internal::locale_ref())
      : out_(out), args_(ctx_args), loc_(loc) {}

  format_arg arg(int id) const { return args_.get(id); }

  // Checks if manual indexing is used and returns the argument with the
  // specified name.
  format_arg arg(basic_string_view<char_type> name);

  internal::error_handler error_handler() { return {}; }
  void on_error(const char* message) { error_handler().on_error(message); }

  // Returns an iterator to the beginning of the output range.
  iterator out() { return out_; }

  // Advances the begin iterator to ``it``.
  void advance_to(iterator it) { out_ = it; }

  internal::locale_ref locale() { return loc_; }
};

template <typename Char>
using buffer_context =
    basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
                         Char>;
using format_context = buffer_context<char>;
using wformat_context = buffer_context<wchar_t>;

/**
  \rst
  An array of references to arguments. It can be implicitly converted into
  `~fmt::basic_format_args` for passing into type-erased formatting functions
  such as `~fmt::vformat`.
  \endrst
 */
template <typename Context, typename... Args>
class format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
    // Workaround a GCC template argument substitution bug.
    : public basic_format_args<Context>
#endif
{
 private:
  static const size_t num_args = sizeof...(Args);
  static const bool is_packed = num_args < internal::max_packed_args;

  using value_type = conditional_t<is_packed, internal::value<Context>,
                                   basic_format_arg<Context>>;

  // If the arguments are not packed, add one more element to mark the end.
  value_type data_[num_args + (num_args == 0 ? 1 : 0)];

  friend class basic_format_args<Context>;

 public:
  static constexpr unsigned long long types =
      is_packed ? internal::encode_types<Context, Args...>()
                : internal::is_unpacked_bit | num_args;

  format_arg_store(const Args&... args)
      :
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
        basic_format_args<Context>(*this),
#endif
        data_{internal::make_arg<is_packed, Context>(args)...} {
  }
};

/**
  \rst
  Constructs an `~fmt::format_arg_store` object that contains references to
  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
  can be omitted in which case it defaults to `~fmt::context`.
  See `~fmt::arg` for lifetime considerations.
  \endrst
 */
template <typename Context = format_context, typename... Args>
inline format_arg_store<Context, Args...> make_format_args(
    const Args&... args) {
  return {args...};
}

/**
  \rst
  A dynamic version of `fmt::format_arg_store<>`.
  It's equipped with a storage to potentially temporary objects which lifetime
  could be shorter than the format arguments object.

  It can be implicitly converted into `~fmt::basic_format_args` for passing
  into type-erased formatting functions such as `~fmt::vformat`.
  \endrst
 */
template <typename Context>
class dynamic_format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
    // Workaround a GCC template argument substitution bug.
    : public basic_format_args<Context>
#endif
{
 private:
  using char_type = typename Context::char_type;

  template <typename T> struct need_copy {
    static constexpr internal::type mapped_type =
        internal::mapped_type_constant<T, Context>::value;

    enum {
      value = !(internal::is_reference_wrapper<T>::value ||
                std::is_same<T, basic_string_view<char_type>>::value ||
                std::is_same<T, internal::std_string_view<char_type>>::value ||
                (mapped_type != internal::type::cstring_type &&
                 mapped_type != internal::type::string_type &&
                 mapped_type != internal::type::custom_type &&
                 mapped_type != internal::type::named_arg_type))
    };
  };

  template <typename T>
  using stored_type = conditional_t<internal::is_string<T>::value,
                                    std::basic_string<char_type>, T>;

  // Storage of basic_format_arg must be contiguous.
  std::vector<basic_format_arg<Context>> data_;

  // Storage of arguments not fitting into basic_format_arg must grow
  // without relocation because items in data_ refer to it.
  internal::dynamic_arg_list dynamic_args_;

  friend class basic_format_args<Context>;

  unsigned long long get_types() const {
    return internal::is_unpacked_bit | data_.size();
  }

  template <typename T> void emplace_arg(const T& arg) {
    data_.emplace_back(internal::make_arg<Context>(arg));
  }

 public:
  /**
    \rst
    Adds an argument into the dynamic store for later passing to a formating
    function.

    Note that custom types and string types (but not string views!) are copied
    into the store with dynamic memory (in addition to resizing vector).

    **Example**::

      fmt::dynamic_format_arg_store<fmt::format_context> store;
      store.push_back(42);
      store.push_back("abc");
      store.push_back(1.5f);
      std::string result = fmt::vformat("{} and {} and {}", store);
    \endrst
  */
  template <typename T> void push_back(const T& arg) {
    static_assert(
        !std::is_base_of<internal::named_arg_base<char_type>, T>::value,
        "named arguments are not supported yet");
    if (internal::const_check(need_copy<T>::value))
      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
    else
      emplace_arg(arg);
  }

  /**
    Adds a reference to the argument into the dynamic store for later passing to
    a formating function.
  */
  template <typename T> void push_back(std::reference_wrapper<T> arg) {
    static_assert(
        need_copy<T>::value,
        "objects of built-in types and string views are always copied");
    emplace_arg(arg.get());
  }
};

/**
  \rst
  A view of a collection of formatting arguments. To avoid lifetime issues it
  should only be used as a parameter type in type-erased functions such as
  ``vformat``::

    void vlog(string_view format_str, format_args args);  // OK
    format_args args = make_format_args(42);  // Error: dangling reference
  \endrst
 */
template <typename Context> class basic_format_args {
 public:
  using size_type = int;
  using format_arg = basic_format_arg<Context>;

 private:
  // To reduce compiled code size per formatting function call, types of first
  // max_packed_args arguments are passed in the types_ field.
  unsigned long long types_;
  union {
    // If the number of arguments is less than max_packed_args, the argument
    // values are stored in values_, otherwise they are stored in args_.
    // This is done to reduce compiled code size as storing larger objects
    // may require more code (at least on x86-64) even if the same amount of
    // data is actually copied to stack. It saves ~10% on the bloat test.
    const internal::value<Context>* values_;
    const format_arg* args_;
  };

  bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }

  internal::type type(int index) const {
    int shift = index * internal::packed_arg_bits;
    unsigned int mask = (1 << internal::packed_arg_bits) - 1;
    return static_cast<internal::type>((types_ >> shift) & mask);
  }

  friend class internal::arg_map<Context>;

  void set_data(const internal::value<Context>* values) { values_ = values; }
  void set_data(const format_arg* args) { args_ = args; }

  format_arg do_get(int index) const {
    format_arg arg;
    if (!is_packed()) {
      auto num_args = max_size();
      if (index < num_args) arg = args_[index];
      return arg;
    }
    if (index > internal::max_packed_args) return arg;
    arg.type_ = type(index);
    if (arg.type_ == internal::type::none_type) return arg;
    internal::value<Context>& val = arg.value_;
    val = values_[index];
    return arg;
  }

 public:
  basic_format_args() : types_(0) {}

  /**
   \rst
   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
   \endrst
   */
  template <typename... Args>
  basic_format_args(const format_arg_store<Context, Args...>& store)
      : types_(store.types) {
    set_data(store.data_);
  }

  /**
   \rst
   Constructs a `basic_format_args` object from
   `~fmt::dynamic_format_arg_store`.
   \endrst
   */
  basic_format_args(const dynamic_format_arg_store<Context>& store)
      : types_(store.get_types()) {
    set_data(store.data_.data());
  }

  /**
   \rst
   Constructs a `basic_format_args` object from a dynamic set of arguments.
   \endrst
   */
  basic_format_args(const format_arg* args, int count)
      : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {
    set_data(args);
  }

  /** Returns the argument at specified index. */
  format_arg get(int index) const {
    format_arg arg = do_get(index);
    if (arg.type_ == internal::type::named_arg_type)
      arg = arg.value_.named_arg->template deserialize<Context>();
    return arg;
  }

  int max_size() const {
    unsigned long long max_packed = internal::max_packed_args;
    return static_cast<int>(is_packed() ? max_packed
                                        : types_ & ~internal::is_unpacked_bit);
  }
};

/** An alias to ``basic_format_args<context>``. */
// It is a separate type rather than an alias to make symbols readable.
struct format_args : basic_format_args<format_context> {
  template <typename... Args>
  format_args(Args&&... args)
      : basic_format_args<format_context>(static_cast<Args&&>(args)...) {}
};
struct wformat_args : basic_format_args<wformat_context> {
  template <typename... Args>
  wformat_args(Args&&... args)
      : basic_format_args<wformat_context>(static_cast<Args&&>(args)...) {}
};

template <typename Container> struct is_contiguous : std::false_type {};

template <typename Char>
struct is_contiguous<std::basic_string<Char>> : std::true_type {};

template <typename Char>
struct is_contiguous<internal::buffer<Char>> : std::true_type {};

namespace internal {

template <typename OutputIt>
struct is_contiguous_back_insert_iterator : std::false_type {};
template <typename Container>
struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
    : is_contiguous<Container> {};

template <typename Char> struct named_arg_base {
  basic_string_view<Char> name;

  // Serialized value<context>.
  mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];

  named_arg_base(basic_string_view<Char> nm) : name(nm) {}

  template <typename Context> basic_format_arg<Context> deserialize() const {
    basic_format_arg<Context> arg;
    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
    return arg;
  }
};

struct view {};

template <typename T, typename Char>
struct named_arg : view, named_arg_base<Char> {
  const T& value;

  named_arg(basic_string_view<Char> name, const T& val)
      : named_arg_base<Char>(name), value(val) {}
};

template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
inline void check_format_string(const S&) {
#if defined(FMT_ENFORCE_COMPILE_STRING)
  static_assert(is_compile_string<S>::value,
                "FMT_ENFORCE_COMPILE_STRING requires all format strings to "
                "utilize FMT_STRING() or fmt().");
#endif
}
template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
void check_format_string(S);

template <bool...> struct bool_pack;
template <bool... Args>
using all_true =
    std::is_same<bool_pack<Args..., true>, bool_pack<true, Args...>>;

template <typename... Args, typename S, typename Char = char_t<S>>
inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
make_args_checked(const S& format_str,
                  const remove_reference_t<Args>&... args) {
  static_assert(
      all_true<(!std::is_base_of<view, remove_reference_t<Args>>::value ||
                !std::is_reference<Args>::value)...>::value,
      "passing views as lvalues is disallowed");
  check_format_string<Args...>(format_str);
  return {args...};
}

template <typename Char>
std::basic_string<Char> vformat(
    basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args);

template <typename Char>
typename buffer_context<Char>::iterator vformat_to(
    buffer<Char>& buf, basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args);

template <typename Char, typename Args,
          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
inline void vprint_mojibake(std::FILE*, basic_string_view<Char>, const Args&) {}

FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
#ifndef _WIN32
inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
#endif
}  // namespace internal

/**
  \rst
  Returns a named argument to be used in a formatting function. It should only
  be used in a call to a formatting function.

  **Example**::

    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
  \endrst
 */
template <typename S, typename T, typename Char = char_t<S>>
inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
  static_assert(internal::is_string<S>::value, "");
  return {name, arg};
}

// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``.
template <typename S, typename T, typename Char>
void arg(S, internal::named_arg<T, Char>) = delete;

/** Formats a string and writes the output to ``out``. */
// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
template <typename OutputIt, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(
              internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
OutputIt vformat_to(
    OutputIt out, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  using container = remove_reference_t<decltype(internal::get_container(out))>;
  internal::container_buffer<container> buf((internal::get_container(out)));
  internal::vformat_to(buf, to_string_view(format_str), args);
  return out;
}

template <typename Container, typename S, typename... Args,
          FMT_ENABLE_IF(
              is_contiguous<Container>::value&& internal::is_string<S>::value)>
inline std::back_insert_iterator<Container> format_to(
    std::back_insert_iterator<Container> out, const S& format_str,
    Args&&... args) {
  return vformat_to(out, to_string_view(format_str),
                    internal::make_args_checked<Args...>(format_str, args...));
}

template <typename S, typename Char = char_t<S>>
inline std::basic_string<Char> vformat(
    const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  return internal::vformat(to_string_view(format_str), args);
}

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    #include <fmt/core.h>
    std::string message = fmt::format("The answer is {}", 42);
  \endrst
*/
// Pass char_t as a default template parameter instead of using
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... Args, typename Char = char_t<S>>
inline std::basic_string<Char> format(const S& format_str, Args&&... args) {
  return internal::vformat(
      to_string_view(format_str),
      internal::make_args_checked<Args...>(format_str, args...));
}

FMT_API void vprint(string_view, format_args);
FMT_API void vprint(std::FILE*, string_view, format_args);

/**
  \rst
  Formats ``args`` according to specifications in ``format_str`` and writes the
  output to the file ``f``. Strings are assumed to be Unicode-encoded unless the
  ``FMT_UNICODE`` macro is set to 0.

  **Example**::

    fmt::print(stderr, "Don't {}!", "panic");
  \endrst
 */
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(std::FILE* f, const S& format_str, Args&&... args) {
  return internal::is_unicode<Char>()
             ? vprint(f, to_string_view(format_str),
                      internal::make_args_checked<Args...>(format_str, args...))
             : internal::vprint_mojibake(
                   f, to_string_view(format_str),
                   internal::make_args_checked<Args...>(format_str, args...));
}

/**
  \rst
  Formats ``args`` according to specifications in ``format_str`` and writes
  the output to ``stdout``. Strings are assumed to be Unicode-encoded unless
  the ``FMT_UNICODE`` macro is set to 0.

  **Example**::

    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(const S& format_str, Args&&... args) {
  return internal::is_unicode<Char>()
             ? vprint(to_string_view(format_str),
                      internal::make_args_checked<Args...>(format_str, args...))
             : internal::vprint_mojibake(
                   stdout, to_string_view(format_str),
                   internal::make_args_checked<Args...>(format_str, args...));
}
FMT_END_NAMESPACE

#endif  // FMT_CORE_H_


================================================
FILE: examples/lesson04/fig04_12/fmt/format-inl.h
================================================
// Formatting library for C++ - implementation
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_

#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstring>  // for std::memmove
#include <cwchar>

#include "format.h"
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
#  include <locale>
#endif

#ifdef _WIN32
#  include <io.h>
#  include <windows.h>
#endif

#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable : 4702)  // unreachable code
#endif

// Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available.
inline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }

FMT_BEGIN_NAMESPACE
namespace internal {

FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
  print(stderr, "{}:{}: assertion failed: {}", file, line, message);
  std::abort();
}

#ifndef _MSC_VER
#  define FMT_SNPRINTF snprintf
#else  // _MSC_VER
inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
  va_end(args);
  return result;
}
#  define FMT_SNPRINTF fmt_snprintf
#endif  // _MSC_VER

// A portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code.
// This can be either a pointer to a string stored in buffer,
// or a pointer to some static immutable string.
// Returns one of the following values:
//   0      - success
//   ERANGE - buffer is not large enough to store the error message
//   other  - failure
// Buffer should be at least of size 1.
FMT_FUNC int safe_strerror(int error_code, char*& buffer,
                           std::size_t buffer_size) FMT_NOEXCEPT {
  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");

  class dispatcher {
   private:
    int error_code_;
    char*& buffer_;
    std::size_t buffer_size_;

    // A noop assignment operator to avoid bogus warnings.
    void operator=(const dispatcher&) {}

    // Handle the result of XSI-compliant version of strerror_r.
    int handle(int result) {
      // glibc versions before 2.13 return result in errno.
      return result == -1 ? errno : result;
    }

    // Handle the result of GNU-specific version of strerror_r.
    FMT_MAYBE_UNUSED
    int handle(char* message) {
      // If the buffer is full then the message is probably truncated.
      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
        return ERANGE;
      buffer_ = message;
      return 0;
    }

    // Handle the case when strerror_r is not available.
    FMT_MAYBE_UNUSED
    int handle(internal::null<>) {
      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
    }

    // Fallback to strerror_s when strerror_r is not available.
    FMT_MAYBE_UNUSED
    int fallback(int result) {
      // If the buffer is full then the message is probably truncated.
      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
                                                                : result;
    }

#if !FMT_MSC_VER
    // Fallback to strerror if strerror_r and strerror_s are not available.
    int fallback(internal::null<>) {
      errno = 0;
      buffer_ = strerror(error_code_);
      return errno;
    }
#endif

   public:
    dispatcher(int err_code, char*& buf, std::size_t buf_size)
        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}

    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
  };
  return dispatcher(error_code, buffer, buffer_size).run();
}

FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
                                string_view message) FMT_NOEXCEPT {
  // Report error code making sure that the output fits into
  // inline_buffer_size to avoid dynamic memory allocation and potential
  // bad_alloc.
  out.resize(0);
  static const char SEP[] = ": ";
  static const char ERROR_STR[] = "error ";
  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
  if (internal::is_negative(error_code)) {
    abs_value = 0 - abs_value;
    ++error_code_size;
  }
  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
  internal::writer w(out);
  if (message.size() <= inline_buffer_size - error_code_size) {
    w.write(message);
    w.write(SEP);
  }
  w.write(ERROR_STR);
  w.write(error_code);
  assert(out.size() <= inline_buffer_size);
}

FMT_FUNC void report_error(format_func func, int error_code,
                           string_view message) FMT_NOEXCEPT {
  memory_buffer full_message;
  func(full_message, error_code, message);
  // Don't use fwrite_fully because the latter may throw.
  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
  std::fputc('\n', stderr);
}

// A wrapper around fwrite that throws on error.
FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
                           FILE* stream) {
  size_t written = std::fwrite(ptr, size, count, stream);
  if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
}
}  // namespace internal

#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
namespace internal {

template <typename Locale>
locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
  static_assert(std::is_same<Locale, std::locale>::value, "");
}

template <typename Locale> Locale locale_ref::get() const {
  static_assert(std::is_same<Locale, std::locale>::value, "");
  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
}

template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
}
template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
      .thousands_sep();
}
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
      .decimal_point();
}
}  // namespace internal
#else
template <typename Char>
FMT_FUNC std::string internal::grouping_impl(locale_ref) {
  return "\03";
}
template <typename Char>
FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
  return FMT_STATIC_THOUSANDS_SEPARATOR;
}
template <typename Char>
FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
  return '.';
}
#endif

FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default;

FMT_FUNC void system_error::init(int err_code, string_view format_str,
                                 format_args args) {
  error_code_ = err_code;
  memory_buffer buffer;
  format_system_error(buffer, err_code, vformat(format_str, args));
  std::runtime_error& base = *this;
  base = std::runtime_error(to_string(buffer));
}

namespace internal {

template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
  // fallback_uintptr is always stored in little endian.
  int i = static_cast<int>(sizeof(void*)) - 1;
  while (i > 0 && n.value[i] == 0) --i;
  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
}

template <typename T>
const char basic_data<T>::digits[] =
    "0001020304050607080910111213141516171819"
    "2021222324252627282930313233343536373839"
    "4041424344454647484950515253545556575859"
    "6061626364656667686970717273747576777879"
    "8081828384858687888990919293949596979899";

template <typename T>
const char basic_data<T>::hex_digits[] = "0123456789abcdef";

#define FMT_POWERS_OF_10(factor)                                             \
  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
      (factor)*1000000000

template <typename T>
const uint64_t basic_data<T>::powers_of_10_64[] = {
    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
    10000000000000000000ULL};

template <typename T>
const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
                                                           FMT_POWERS_OF_10(1)};

template <typename T>
const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
    10000000000000000000ULL};

// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
// These are generated by support/compute-powers.py.
template <typename T>
const uint64_t basic_data<T>::pow10_significands[] = {
    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
};

// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
// to significands above.
template <typename T>
const int16_t basic_data<T>::pow10_exponents[] = {
    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};

template <typename T>
const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
template <typename T>
const char basic_data<T>::background_color[] = "\x1b[48;2;";
template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};

template <typename T> struct bits {
  static FMT_CONSTEXPR_DECL const int value =
      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
};

class fp;
template <int SHIFT = 0> fp normalize(fp value);

// Lower (upper) boundary is a value half way between a floating-point value
// and its predecessor (successor). Boundaries have the same exponent as the
// value so only significands are stored.
struct boundaries {
  uint64_t lower;
  uint64_t upper;
};

// A handmade floating-point number f * pow(2, e).
class fp {
 private:
  using significand_type = uint64_t;

 public:
  significand_type f;
  int e;

  // All sizes are in bits.
  // Subtract 1 to account for an implicit most significant bit in the
  // normalized form.
  static FMT_CONSTEXPR_DECL const int double_significand_size =
      std::numeric_limits<double>::digits - 1;
  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
      1ULL << double_significand_size;
  static FMT_CONSTEXPR_DECL const int significand_size =
      bits<significand_type>::value;

  fp() : f(0), e(0) {}
  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}

  // Constructs fp from an IEEE754 double. It is a template to prevent compile
  // errors on platforms where double is not IEEE754.
  template <typename Double> explicit fp(Double d) { assign(d); }

  // Assigns d to this and return true iff predecessor is closer than successor.
  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
  bool assign(Double d) {
    // Assume double is in the format [sign][exponent][significand].
    using limits = std::numeric_limits<Double>;
    const int exponent_size =
        bits<Double>::value - double_significand_size - 1;  // -1 for sign
    const uint64_t significand_mask = implicit_bit - 1;
    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
    auto u = bit_cast<uint64_t>(d);
    f = u & significand_mask;
    int biased_e =
        static_cast<int>((u & exponent_mask) >> double_significand_size);
    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
    // the smallest normalized number (biased_e > 1).
    bool is_predecessor_closer = f == 0 && biased_e > 1;
    if (biased_e != 0)
      f += implicit_bit;
    else
      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
    e = biased_e - exponent_bias - double_significand_size;
    return is_predecessor_closer;
  }

  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
  bool assign(Double) {
    *this = fp();
    return false;
  }

  // Assigns d to this together with computing lower and upper boundaries,
  // where a boundary is a value half way between the number and its predecessor
  // (lower) or successor (upper). The upper boundary is normalized and lower
  // has the same exponent but may be not normalized.
  template <typename Double> boundaries assign_with_boundaries(Double d) {
    bool is_lower_closer = assign(d);
    fp lower =
        is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
    // 1 in normalize accounts for the exponent shift above.
    fp upper = normalize<1>(fp((f << 1) + 1, e - 1));
    lower.f <<= lower.e - upper.e;
    return boundaries{lower.f, upper.f};
  }

  template <typename Double> boundaries assign_float_with_boundaries(Double d) {
    assign(d);
    constexpr int min_normal_e = std::numeric_limits<float>::min_exponent -
                                 std::numeric_limits<double>::digits;
    significand_type half_ulp = 1 << (std::numeric_limits<double>::digits -
                                      std::numeric_limits<float>::digits - 1);
    if (min_normal_e > e) half_ulp <<= min_normal_e - e;
    fp upper = normalize<0>(fp(f + half_ulp, e));
    fp lower = fp(
        f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
    lower.f <<= lower.e - upper.e;
    return boundaries{lower.f, upper.f};
  }
};

// Normalizes the value converted from double and multiplied by (1 << SHIFT).
template <int SHIFT> fp normalize(fp value) {
  // Handle subnormals.
  const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
  while ((value.f & shifted_implicit_bit) == 0) {
    value.f <<= 1;
    --value.e;
  }
  // Subtract 1 to account for hidden bit.
  const auto offset =
      fp::significand_size - fp::double_significand_size - SHIFT - 1;
  value.f <<= offset;
  value.e -= offset;
  return value;
}

inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }

// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
#if FMT_USE_INT128
  auto product = static_cast<__uint128_t>(lhs) * rhs;
  auto f = static_cast<uint64_t>(product >> 64);
  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
#else
  // Multiply 32-bit parts of significands.
  uint64_t mask = (1ULL << 32) - 1;
  uint64_t a = lhs >> 32, b = lhs & mask;
  uint64_t c = rhs >> 32, d = rhs & mask;
  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
  // Compute mid 64-bit of result and round.
  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
#endif
}

inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }

// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
  const int64_t one_over_log2_10 = 0x4d104d42;  // round(pow(2, 32) / log2(10))
  int index = static_cast<int>(
      ((min_exponent + fp::significand_size - 1) * one_over_log2_10 +
       ((int64_t(1) << 32) - 1))  // ceil
      >> 32                       // arithmetic shift
  );
  // Decimal exponent of the first (smallest) cached power of 10.
  const int first_dec_exp = -348;
  // Difference between 2 consecutive decimal exponents in cached powers of 10.
  const int dec_exp_step = 8;
  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
  pow10_exponent = first_dec_exp + index * dec_exp_step;
  return {data::pow10_significands[index], data::pow10_exponents[index]};
}

// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
// is not available.
struct accumulator {
  uint64_t lower;
  uint64_t upper;

  accumulator() : lower(0), upper(0) {}
  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }

  void operator+=(uint64_t n) {
    lower += n;
    if (lower < n) ++upper;
  }
  void operator>>=(int shift) {
    assert(shift == 32);
    (void)shift;
    lower = (upper << 32) | (lower >> 32);
    upper >>= 32;
  }
};

class bigint {
 private:
  // A bigint is stored as an array of bigits (big digits), with bigit at index
  // 0 being the least significant one.
  using bigit = uint32_t;
  using double_bigit = uint64_t;
  enum { bigits_capacity = 32 };
  basic_memory_buffer<bigit, bigits_capacity> bigits_;
  int exp_;

  bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
  bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }

  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;

  friend struct formatter<bigint>;

  void subtract_bigits(int index, bigit other, bigit& borrow) {
    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
    (*this)[index] = static_cast<bigit>(result);
    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
  }

  void remove_leading_zeros() {
    int num_bigits = static_cast<int>(bigits_.size()) - 1;
    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
    bigits_.resize(to_unsigned(num_bigits + 1));
  }

  // Computes *this -= other assuming aligned bigints and *this >= other.
  void subtract_aligned(const bigint& other) {
    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
    FMT_ASSERT(compare(*this, other) >= 0, "");
    bigit borrow = 0;
    int i = other.exp_ - exp_;
    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) {
      subtract_bigits(i, other.bigits_[j], borrow);
    }
    while (borrow > 0) subtract_bigits(i, 0, borrow);
    remove_leading_zeros();
  }

  void multiply(uint32_t value) {
    const double_bigit wide_value = value;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      double_bigit result = bigits_[i] * wide_value + carry;
      bigits_[i] = static_cast<bigit>(result);
      carry = static_cast<bigit>(result >> bigit_bits);
    }
    if (carry != 0) bigits_.push_back(carry);
  }

  void multiply(uint64_t value) {
    const bigit mask = ~bigit(0);
    const double_bigit lower = value & mask;
    const double_bigit upper = value >> bigit_bits;
    double_bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      double_bigit result = bigits_[i] * lower + (carry & mask);
      carry =
          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
      bigits_[i] = static_cast<bigit>(result);
    }
    while (carry != 0) {
      bigits_.push_back(carry & mask);
      carry >>= bigit_bits;
    }
  }

 public:
  bigint() : exp_(0) {}
  explicit bigint(uint64_t n) { assign(n); }
  ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }

  bigint(const bigint&) = delete;
  void operator=(const bigint&) = delete;

  void assign(const bigint& other) {
    bigits_.resize(other.bigits_.size());
    auto data = other.bigits_.data();
    std::copy(data, data + other.bigits_.size(), bigits_.data());
    exp_ = other.exp_;
  }

  void assign(uint64_t n) {
    size_t num_bigits = 0;
    do {
      bigits_[num_bigits++] = n & ~bigit(0);
      n >>= bigit_bits;
    } while (n != 0);
    bigits_.resize(num_bigits);
    exp_ = 0;
  }

  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }

  bigint& operator<<=(int shift) {
    assert(shift >= 0);
    exp_ += shift / bigit_bits;
    shift %= bigit_bits;
    if (shift == 0) return *this;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      bigit c = bigits_[i] >> (bigit_bits - shift);
      bigits_[i] = (bigits_[i] << shift) + carry;
      carry = c;
    }
    if (carry != 0) bigits_.push_back(carry);
    return *this;
  }

  template <typename Int> bigint& operator*=(Int value) {
    FMT_ASSERT(value > 0, "");
    multiply(uint32_or_64_or_128_t<Int>(value));
    return *this;
  }

  friend int compare(const bigint& lhs, const bigint& rhs) {
    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
    if (num_lhs_bigits != num_rhs_bigits)
      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
    int i = static_cast<int>(lhs.bigits_.size()) - 1;
    int j = static_cast<int>(rhs.bigits_.size()) - 1;
    int end = i - j;
    if (end < 0) end = 0;
    for (; i >= end; --i, --j) {
      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
    }
    if (i != j) return i > j ? 1 : -1;
    return 0;
  }

  // Returns compare(lhs1 + lhs2, rhs).
  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
                         const bigint& rhs) {
    int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
    int num_rhs_bigits = rhs.num_bigits();
    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
    if (max_lhs_bigits > num_rhs_bigits) return 1;
    auto get_bigit = [](const bigint& n, int i) -> bigit {
      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
    };
    double_bigit borrow = 0;
    int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
      double_bigit sum =
          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
      bigit rhs_bigit = get_bigit(rhs, i);
      if (sum > rhs_bigit + borrow) return 1;
      borrow = rhs_bigit + borrow - sum;
      if (borrow > 1) return -1;
      borrow <<= bigit_bits;
    }
    return borrow != 0 ? -1 : 0;
  }

  // Assigns pow(10, exp) to this bigint.
  void assign_pow10(int exp) {
    assert(exp >= 0);
    if (exp == 0) return assign(1);
    // Find the top bit.
    int bitmask = 1;
    while (exp >= bitmask) bitmask <<= 1;
    bitmask >>= 1;
    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
    // repeated squaring and multiplication.
    assign(5);
    bitmask >>= 1;
    while (bitmask != 0) {
      square();
      if ((exp & bitmask) != 0) *this *= 5;
      bitmask >>= 1;
    }
    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
  }

  void square() {
    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
    int num_bigits = static_cast<int>(bigits_.size());
    int num_result_bigits = 2 * num_bigits;
    bigits_.resize(to_unsigned(num_result_bigits));
    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
    auto sum = accumulator_t();
    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
      // Compute bigit at position bigit_index of the result by adding
      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
        // Most terms are multiplied twice which can be optimized in the future.
        sum += static_cast<double_bigit>(n[i]) * n[j];
      }
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= bits<bigit>::value;  // Compute the carry.
    }
    // Do the same for the top half.
    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
         ++bigit_index) {
      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
        sum += static_cast<double_bigit>(n[i++]) * n[j--];
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= bits<bigit>::value;
    }
    --num_result_bigits;
    remove_leading_zeros();
    exp_ *= 2;
  }

  // Divides this bignum by divisor, assigning the remainder to this and
  // returning the quotient.
  int divmod_assign(const bigint& divisor) {
    FMT_ASSERT(this != &divisor, "");
    if (compare(*this, divisor) < 0) return 0;
    int num_bigits = static_cast<int>(bigits_.size());
    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
    int exp_difference = exp_ - divisor.exp_;
    if (exp_difference > 0) {
      // Align bigints by adding trailing zeros to simplify subtraction.
      bigits_.resize(to_unsigned(num_bigits + exp_difference));
      for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
        bigits_[j] = bigits_[i];
      std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
      exp_ -= exp_difference;
    }
    int quotient = 0;
    do {
      subtract_aligned(divisor);
      ++quotient;
    } while (compare(*this, divisor) >= 0);
    return quotient;
  }
};

enum class round_direction { unknown, up, down };

// Given the divisor (normally a power of 10), the remainder = v % divisor for
// some number v and the error, returns whether v should be rounded up, down, or
// whether the rounding direction can't be determined due to error.
// error should be less than divisor / 2.
inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
                                           uint64_t error) {
  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
  // Round down if (remainder + error) * 2 <= divisor.
  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
    return round_direction::down;
  // Round up if (remainder - error) * 2 >= divisor.
  if (remainder >= error &&
      remainder - error >= divisor - (remainder - error)) {
    return round_direction::up;
  }
  return round_direction::unknown;
}

namespace digits {
enum result {
  more,  // Generate more digits.
  done,  // Done generating digits.
  error  // Digit generation cancelled due to an error.
};
}

// A version of count_digits optimized for grisu_gen_digits.
inline int grisu_count_digits(uint32_t n) {
  if (n < 10) return 1;
  if (n < 100) return 2;
  if (n < 1000) return 3;
  if (n < 10000) return 4;
  if (n < 100000) return 5;
  if (n < 1000000) return 6;
  if (n < 10000000) return 7;
  if (n < 100000000) return 8;
  if (n < 1000000000) return 9;
  return 10;
}

// Generates output using the Grisu digit-gen algorithm.
// error: the size of the region (lower, upper) outside of which numbers
// definitely do not round to value (Delta in Grisu3).
template <typename Handler>
FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
                                                  int& exp, Handler& handler) {
  const fp one(1ULL << -value.e, value.e);
  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
  // zero because it contains a product of two 64-bit numbers with MSB set (due
  // to normalization) - 1, shifted right by at most 60 bits.
  auto integral = static_cast<uint32_t>(value.f >> -one.e);
  FMT_ASSERT(integral != 0, "");
  FMT_ASSERT(integral == value.f >> -one.e, "");
  // The fractional part of scaled value (p2 in Grisu) c = value % one.
  uint64_t fractional = value.f & (one.f - 1);
  exp = grisu_count_digits(integral);  // kappa in Grisu.
  // Divide by 10 to prevent overflow.
  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
                                 value.f / 10, error * 10, exp);
  if (result != digits::more) return result;
  // Generate digits for the integral part. This can produce up to 10 digits.
  do {
    uint32_t digit = 0;
    auto divmod_integral = [&](uint32_t divisor) {
      digit = integral / divisor;
      integral %= divisor;
    };
    // This optimization by Milo Yip reduces the number of integer divisions by
    // one per iteration.
    switch (exp) {
    case 10:
      divmod_integral(1000000000);
      break;
    case 9:
      divmod_integral(100000000);
      break;
    case 8:
      divmod_integral(10000000);
      break;
    case 7:
      divmod_integral(1000000);
      break;
    case 6:
      divmod_integral(100000);
      break;
    case 5:
      divmod_integral(10000);
      break;
    case 4:
      divmod_integral(1000);
      break;
    case 3:
      divmod_integral(100);
      break;
    case 2:
      divmod_integral(10);
      break;
    case 1:
      digit = integral;
      integral = 0;
      break;
    default:
      FMT_ASSERT(false, "invalid number of digits");
    }
    --exp;
    uint64_t remainder =
        (static_cast<uint64_t>(integral) << -one.e) + fractional;
    result = handler.on_digit(static_cast<char>('0' + digit),
                              data::powers_of_10_64[exp] << -one.e, remainder,
                              error, exp, true);
    if (result != digits::more) return result;
  } while (exp > 0);
  // Generate digits for the fractional part.
  for (;;) {
    fractional *= 10;
    error *= 10;
    char digit =
        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
    fractional &= one.f - 1;
    --exp;
    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
    if (result != digits::more) return result;
  }
}

// The fixed precision digit handler.
struct fixed_handler {
  char* buf;
  int size;
  int precision;
  int exp10;
  bool fixed;

  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
                          int& exp) {
    // Non-fixed formats require at least one digit and no precision adjustment.
    if (!fixed) return digits::more;
    // Adjust fixed precision by exponent because it is relative to decimal
    // point.
    precision += exp + exp10;
    // Check if precision is satisfied just by leading zeros, e.g.
    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
    if (precision > 0) return digits::more;
    if (precision < 0) return digits::done;
    auto dir = get_round_direction(divisor, remainder, error);
    if (dir == round_direction::unknown) return digits::error;
    buf[size++] = dir == round_direction::up ? '1' : '0';
    return digits::done;
  }

  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
                          uint64_t error, int, bool integral) {
    FMT_ASSERT(remainder < divisor, "");
    buf[size++] = digit;
    if (size < precision) return digits::more;
    if (!integral) {
      // Check if error * 2 < divisor with overflow prevention.
      // The check is not needed for the integral part because error = 1
      // and divisor > (1 << 32) there.
      if (error >= divisor || error >= divisor - error) return digits::error;
    } else {
      FMT_ASSERT(error == 1 && divisor > 2, "");
    }
    auto dir = get_round_direction(divisor, remainder, error);
    if (dir != round_direction::up)
      return dir == round_direction::down ? digits::done : digits::error;
    ++buf[size - 1];
    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
      buf[i] = '0';
      ++buf[i - 1];
    }
    if (buf[0] > '9') {
      buf[0] = '1';
      buf[size++] = '0';
    }
    return digits::done;
  }
};

// The shortest representation digit handler.
struct grisu_shortest_handler {
  char* buf;
  int size;
  // Distance between scaled value and upper bound (wp_W in Grisu3).
  uint64_t diff;

  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
    return digits::more;
  }

  // Decrement the generated number approaching value from above.
  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
             uint64_t error) {
    while (
        remainder < d && error - remainder >= divisor &&
        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
      --buf[size - 1];
      remainder += divisor;
    }
  }

  // Implements Grisu's round_weed.
  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
                          uint64_t error, int exp, bool integral) {
    buf[size++] = digit;
    if (remainder >= error) return digits::more;
    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
    uint64_t up = (diff - 1) * unit;  // wp_Wup
    round(up, divisor, remainder, error);
    uint64_t down = (diff + 1) * unit;  // wp_Wdown
    if (remainder < down && error - remainder >= divisor &&
        (remainder + divisor < down ||
         down - remainder > remainder + divisor - down)) {
      return digits::error;
    }
    return 2 * unit <= remainder && remainder <= error - 4 * unit
               ? digits::done
               : digits::error;
  }
};

// Formats value using a variation of the Fixed-Precision Positive
// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
// https://fmt.dev/p372-steele.pdf.
template <typename Double>
void fallback_format(Double d, buffer<char>& buf, int& exp10) {
  bigint numerator;    // 2 * R in (FPP)^2.
  bigint denominator;  // 2 * S in (FPP)^2.
  // lower and upper are differences between value and corresponding boundaries.
  bigint lower;             // (M^- in (FPP)^2).
  bigint upper_store;       // upper's value if different from lower.
  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
  fp value;
  // Shift numerator and denominator by an extra bit or two (if lower boundary
  // is closer) to make lower and upper integers. This eliminates multiplication
  // by 2 during later computations.
  // TODO: handle float
  int shift = value.assign(d) ? 2 : 1;
  uint64_t significand = value.f << shift;
  if (value.e >= 0) {
    numerator.assign(significand);
    numerator <<= value.e;
    lower.assign(1);
    lower <<= value.e;
    if (shift != 1) {
      upper_store.assign(1);
      upper_store <<= value.e + 1;
      upper = &upper_store;
    }
    denominator.assign_pow10(exp10);
    denominator <<= 1;
  } else if (exp10 < 0) {
    numerator.assign_pow10(-exp10);
    lower.assign(numerator);
    if (shift != 1) {
      upper_store.assign(numerator);
      upper_store <<= 1;
      upper = &upper_store;
    }
    numerator *= significand;
    denominator.assign(1);
    denominator <<= shift - value.e;
  } else {
    numerator.assign(significand);
    denominator.assign_pow10(exp10);
    denominator <<= shift - value.e;
    lower.assign(1);
    if (shift != 1) {
      upper_store.assign(1ULL << 1);
      upper = &upper_store;
    }
  }
  if (!upper) upper = &lower;
  // Invariant: value == (numerator / denominator) * pow(10, exp10).
  bool even = (value.f & 1) == 0;
  int num_digits = 0;
  char* data = buf.data();
  for (;;) {
    int digit = numerator.divmod_assign(denominator);
    bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
    // numerator + upper >[=] pow10:
    bool high = add_compare(numerator, *upper, denominator) + even > 0;
    data[num_digits++] = static_cast<char>('0' + digit);
    if (low || high) {
      if (!low) {
        ++data[num_digits - 1];
      } else if (high) {
        int result = add_compare(numerator, numerator, denominator);
        // Round half to even.
        if (result > 0 || (result == 0 && (digit % 2) != 0))
          ++data[num_digits - 1];
      }
      buf.resize(to_unsigned(num_digits));
      exp10 -= num_digits - 1;
      return;
    }
    numerator *= 10;
    lower *= 10;
    if (upper != &lower) *upper *= 10;
  }
}

// Formats value using the Grisu algorithm
// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.
template <typename T>
int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
  static_assert(!std::is_same<T, float>::value, "");
  FMT_ASSERT(value >= 0, "value is negative");

  const bool fixed = specs.format == float_format::fixed;
  if (value <= 0) {  // <= instead of == to silence a warning.
    if (precision <= 0 || !fixed) {
      buf.push_back('0');
      return 0;
    }
    buf.resize(to_unsigned(precision));
    std::uninitialized_fill_n(buf.data(), precision, '0');
    return -precision;
  }

  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);

  int exp = 0;
  const int min_exp = -60;  // alpha in Grisu.
  int cached_exp10 = 0;     // K in Grisu.
  if (precision < 0) {
    fp fp_value;
    auto boundaries = specs.binary32
                          ? fp_value.assign_float_with_boundaries(value)
                          : fp_value.assign_with_boundaries(value);
    fp_value = normalize(fp_value);
    // Find a cached power of 10 such that multiplying value by it will bring
    // the exponent in the range [min_exp, -32].
    const fp cached_pow = get_cached_power(
        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
    // Multiply value and boundaries by the cached power of 10.
    fp_value = fp_value * cached_pow;
    boundaries.lower = multiply(boundaries.lower, cached_pow.f);
    boundaries.upper = multiply(boundaries.upper, cached_pow.f);
    assert(min_exp <= fp_value.e && fp_value.e <= -32);
    --boundaries.lower;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
    ++boundaries.upper;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
    // Numbers outside of (lower, upper) definitely do not round to value.
    grisu_shortest_handler handler{buf.data(), 0,
                                   boundaries.upper - fp_value.f};
    auto result =
        grisu_gen_digits(fp(boundaries.upper, fp_value.e),
                         boundaries.upper - boundaries.lower, exp, handler);
    if (result == digits::error) {
      exp += handler.size - cached_exp10 - 1;
      fallback_format(value, buf, exp);
      return exp;
    }
    buf.resize(to_unsigned(handler.size));
  } else {
    if (precision > 17) return snprintf_float(value, precision, specs, buf);
    fp normalized = normalize(fp(value));
    const auto cached_pow = get_cached_power(
        min_exp - (normalized.e + fp::significand_size), cached_exp10);
    normalized = normalized * cached_pow;
    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
    if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
      return snprintf_float(value, precision, specs, buf);
    int num_digits = handler.size;
    if (!fixed) {
      // Remove trailing zeros.
      while (num_digits > 0 && buf[num_digits - 1] == '0') {
        --num_digits;
        ++exp;
      }
    }
    buf.resize(to_unsigned(num_digits));
  }
  return exp - cached_exp10;
}

template <typename T>
int snprintf_float(T value, int precision, float_specs specs,
                   buffer<char>& buf) {
  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
  static_assert(!std::is_same<T, float>::value, "");

  // Subtract 1 to account for the difference in precision since we use %e for
  // both general and exponent format.
  if (specs.format == float_format::general ||
      specs.format == float_format::exp)
    precision = (precision >= 0 ? precision : 6) - 1;

  // Build the format string.
  enum { max_format_size = 7 };  // Ths longest format is "%#.*Le".
  char format[max_format_size];
  char* format_ptr = format;
  *format_ptr++ = '%';
  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
  if (precision >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }
  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
  *format_ptr++ = specs.format != float_format::hex
                      ? (specs.format == float_format::fixed ? 'f' : 'e')
                      : (specs.upper ? 'A' : 'a');
  *format_ptr = '\0';

  // Format using snprintf.
  auto offset = buf.size();
  for (;;) {
    auto begin = buf.data() + offset;
    auto capacity = buf.capacity() - offset;
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    if (precision > 100000)
      throw std::runtime_error(
          "fuzz mode - avoid large allocation inside snprintf");
#endif
    // Suppress the warning about a nonliteral format string.
    // Cannot use auto becase of a bug in MinGW (#1532).
    int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
    int result = precision >= 0
                     ? snprintf_ptr(begin, capacity, format, precision, value)
                     : snprintf_ptr(begin, capacity, format, value);
    if (result < 0) {
      buf.reserve(buf.capacity() + 1);  // The buffer will grow exponentially.
      continue;
    }
    auto size = to_unsigned(result);
    // Size equal to capacity means that the last character was truncated.
    if (size >= capacity) {
      buf.reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
      continue;
    }
    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
    if (specs.format == float_format::fixed) {
      if (precision == 0) {
        buf.resize(size);
        return 0;
      }
      // Find and remove the decimal point.
      auto end = begin + size, p = end;
      do {
        --p;
      } while (is_digit(*p));
      int fraction_size = static_cast<int>(end - p - 1);
      std::memmove(p, p + 1, to_unsigned(fraction_size));
      buf.resize(size - 1);
      return -fraction_size;
    }
    if (specs.format == float_format::hex) {
      buf.resize(size + offset);
      return 0;
    }
    // Find and parse the exponent.
    auto end = begin + size, exp_pos = end;
    do {
      --exp_pos;
    } while (*exp_pos != 'e');
    char sign = exp_pos[1];
    assert(sign == '+' || sign == '-');
    int exp = 0;
    auto p = exp_pos + 2;  // Skip 'e' and sign.
    do {
      assert(is_digit(*p));
      exp = exp * 10 + (*p++ - '0');
    } while (p != end);
    if (sign == '-') exp = -exp;
    int fraction_size = 0;
    if (exp_pos != begin + 1) {
      // Remove trailing zeros.
      auto fraction_end = exp_pos - 1;
      while (*fraction_end == '0') --fraction_end;
      // Move the fractional part left to get rid of the decimal point.
      fraction_size = static_cast<int>(fraction_end - begin - 1);
      std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
    }
    buf.resize(to_unsigned(fraction_size) + offset + 1);
    return exp - fraction_size;
  }
}

// A public domain branchless UTF-8 decoder by Christopher Wellons:
// https://github.com/skeeto/branchless-utf8
/* Decode the next character, c, from buf, reporting errors in e.
 *
 * Since this is a branchless decoder, four bytes will be read from the
 * buffer regardless of the actual length of the next character. This
 * means the buffer _must_ have at least three bytes of zero padding
 * following the end of the data stream.
 *
 * Errors are reported in e, which will be non-zero if the parsed
 * character was somehow invalid: invalid byte sequence, non-canonical
 * encoding, or a surrogate half.
 *
 * The function returns a pointer to the next character. When an error
 * occurs, this pointer will be a guess that depends on the particular
 * error, but it will always advance at least one byte.
 */
FMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
  static const char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                                 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
                                 0, 0, 2, 2, 2, 2, 3, 3, 4, 0};
  static const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
  static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
  static const int shiftc[] = {0, 18, 12, 6, 0};
  static const int shifte[] = {0, 6, 4, 2, 0};

  auto s = reinterpret_cast<const unsigned char*>(buf);
  int len = lengths[s[0] >> 3];

  // Compute the pointer to the next character early so that the next
  // iteration can start working on the next character. Neither Clang
  // nor GCC figure out this reordering on their own.
  const char* next = buf + len + !len;

  // Assume a four-byte character and load four bytes. Unused bits are
  // shifted out.
  *c = uint32_t(s[0] & masks[len]) << 18;
  *c |= uint32_t(s[1] & 0x3f) << 12;
  *c |= uint32_t(s[2] & 0x3f) << 6;
  *c |= uint32_t(s[3] & 0x3f) << 0;
  *c >>= shiftc[len];

  // Accumulate the various error conditions.
  *e = (*c < mins[len]) << 6;       // non-canonical encoding
  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
  *e |= (*c > 0x10FFFF) << 8;       // out of range?
  *e |= (s[1] & 0xc0) >> 2;
  *e |= (s[2] & 0xc0) >> 4;
  *e |= (s[3]) >> 6;
  *e ^= 0x2a;  // top two bits of each tail byte correct?
  *e >>= shifte[len];

  return next;
}
}  // namespace internal

template <> struct formatter<internal::bigint> {
  format_parse_context::iterator parse(format_parse_context& ctx) {
    return ctx.begin();
  }

  format_context::iterator format(const internal::bigint& n,
                                  format_context& ctx) {
    auto out = ctx.out();
    bool first = true;
    for (auto i = n.bigits_.size(); i > 0; --i) {
      auto value = n.bigits_[i - 1u];
      if (first) {
        out = format_to(out, "{:x}", value);
        first = false;
        continue;
      }
      out = format_to(out, "{:08x}", value);
    }
    if (n.exp_ > 0)
      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
    return out;
  }
};

FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
  auto transcode = [this](const char* p) {
    auto cp = uint32_t();
    auto error = 0;
    p = utf8_decode(p, &cp, &error);
    if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
    if (cp <= 0xFFFF) {
      buffer_.push_back(static_cast<wchar_t>(cp));
    } else {
      cp -= 0x10000;
      buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
      buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
    }
    return p;
  };
  auto p = s.data();
  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.
  if (s.size() >= block_size) {
    for (auto end = p + s.size() - block_size + 1; p < end;) p = transcode(p);
  }
  if (auto num_chars_left = s.data() + s.size() - p) {
    char buf[2 * block_size - 1] = {};
    memcpy(buf, p, to_unsigned(num_chars_left));
    p = buf;
    do {
      p = transcode(p);
    } while (p - buf < num_chars_left);
  }
  buffer_.push_back(0);
}

FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
                                  string_view message) FMT_NOEXCEPT {
  FMT_TRY {
    memory_buffer buf;
    buf.resize(inline_buffer_size);
    for (;;) {
      char* system_message = &buf[0];
      int result =
          internal::safe_strerror(error_code, system_message, buf.size());
      if (result == 0) {
        internal::writer w(out);
        w.write(message);
        w.write(": ");
        w.write(system_message);
        return;
      }
      if (result != ERANGE)
        break;  // Can't get error message, report error code instead.
      buf.resize(buf.size() * 2);
    }
  }
  FMT_CATCH(...) {}
  format_error_code(out, error_code, message);
}

FMT_FUNC void internal::error_handler::on_error(const char* message) {
  FMT_THROW(format_error(message));
}

FMT_FUNC void report_system_error(int error_code,
                                  fmt::string_view message) FMT_NOEXCEPT {
  report_error(format_system_error, error_code, message);
}

FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
  memory_buffer buffer;
  internal::vformat_to(buffer, format_str,
                       basic_format_args<buffer_context<char>>(args));
#ifdef _WIN32
  auto fd = _fileno(f);
  if (_isatty(fd)) {
    internal::utf8_to_utf16 u16(string_view(buffer.data(), buffer.size()));
    auto written = DWORD();
    if (!WriteConsoleW(reinterpret_cast<HANDLE>(_get_osfhandle(fd)),
                       u16.c_str(), static_cast<DWORD>(u16.size()), &written,
                       nullptr)) {
      FMT_THROW(format_error("failed to write to console"));
    }
    return;
  }
#endif
  internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);
}

#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void internal::vprint_mojibake(std::FILE* f, string_view format_str,
                                        format_args args) {
  memory_buffer buffer;
  internal::vformat_to(buffer, format_str,
                       basic_format_args<buffer_context<char>>(args));
  fwrite_fully(buffer.data(), 1, buffer.size(), f);
}
#endif

FMT_FUNC void vprint(string_view format_str, format_args args) {
  vprint(stdout, format_str, args);
}

FMT_END_NAMESPACE

#ifdef _MSC_VER
#  pragma warning(pop)
#endif

#endif  // FMT_FORMAT_INL_H_


================================================
FILE: examples/lesson04/fig04_12/fmt/format.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - present, Victor Zverovich

 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.

 --- Optional exception to the license ---

 As an exception, if, as a result of your compiling your source code, portions
 of this Software are embedded into a machine-executable object form of such
 source code, you may redistribute such embedded portions in such object form
 without including the above copyright and permission notices.
 */

#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_

#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>

#include "core.h"

#ifdef FMT_DEPRECATED_INCLUDE_OS
#  include "os.h"
#endif

#ifdef __INTEL_COMPILER
#  define FMT_ICC_VERSION __INTEL_COMPILER
#elif defined(__ICL)
#  define FMT_ICC_VERSION __ICL
#else
#  define FMT_ICC_VERSION 0
#endif

#ifdef __NVCC__
#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
#else
#  define FMT_CUDA_VERSION 0
#endif

#ifdef __has_builtin
#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
#  define FMT_HAS_BUILTIN(x) 0
#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_NOINLINE __attribute__((noinline))
#else
#  define FMT_NOINLINE
#endif

#if __cplusplus == 201103L || __cplusplus == 201402L
#  if defined(__clang__)
#    define FMT_FALLTHROUGH [[clang::fallthrough]]
#  elif FMT_GCC_VERSION >= 700 && !defined(__PGI)
#    define FMT_FALLTHROUGH [[gnu::fallthrough]]
#  else
#    define FMT_FALLTHROUGH
#  endif
#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#  define FMT_FALLTHROUGH [[fallthrough]]
#else
#  define FMT_FALLTHROUGH
#endif

#ifndef FMT_THROW
#  if FMT_EXCEPTIONS
#    if FMT_MSC_VER || FMT_NVCC
FMT_BEGIN_NAMESPACE
namespace internal {
template <typename Exception> inline void do_throw(const Exception& x) {
  // Silence unreachable code warnings in MSVC and NVCC because these
  // are nearly impossible to fix in a generic code.
  volatile bool b = true;
  if (b) throw x;
}
}  // namespace internal
FMT_END_NAMESPACE
#      define FMT_THROW(x) internal::do_throw(x)
#    else
#      define FMT_THROW(x) throw x
#    endif
#  else
#    define FMT_THROW(x)              \
      do {                            \
        static_cast<void>(sizeof(x)); \
        FMT_ASSERT(false, "");        \
      } while (false)
#  endif
#endif

#if FMT_EXCEPTIONS
#  define FMT_TRY try
#  define FMT_CATCH(x) catch (x)
#else
#  define FMT_TRY if (true)
#  define FMT_CATCH(x) if (false)
#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS
// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
       FMT_MSC_VER >= 1900) &&                                              \
      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
       FMT_CUDA_VERSION >= 700)
#    define FMT_USE_USER_DEFINED_LITERALS 1
#  else
#    define FMT_USE_USER_DEFINED_LITERALS 0
#  endif
#endif

#ifndef FMT_USE_UDL_TEMPLATE
// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly
// support UDL templates and GCC >= 9 warns about them.
#  if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
      FMT_CUDA_VERSION == 0 &&                                 \
      ((FMT_GCC_VERSION >= 604 && FMT_GCC_VERSION <= 900 &&    \
        __cplusplus >= 201402L) ||                             \
       FMT_CLANG_VERSION >= 304)
#    define FMT_USE_UDL_TEMPLATE 1
#  else
#    define FMT_USE_UDL_TEMPLATE 0
#  endif
#endif

#ifndef FMT_USE_FLOAT
#  define FMT_USE_FLOAT 1
#endif

#ifndef FMT_USE_DOUBLE
#  define FMT_USE_DOUBLE 1
#endif

#ifndef FMT_USE_LONG_DOUBLE
#  define FMT_USE_LONG_DOUBLE 1
#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
#endif
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
#endif

// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
// MSVC intrinsics if the clz and clzll builtins are not available.
#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64

FMT_BEGIN_NAMESPACE
namespace internal {
// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
#  ifndef __clang__
#    pragma intrinsic(_BitScanReverse)
#  endif
inline uint32_t clz(uint32_t x) {
  unsigned long r = 0;
  _BitScanReverse(&r, x);

  FMT_ASSERT(x != 0, "");
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
#  pragma warning(suppress : 6102)
  return 31 - r;
}
#  define FMT_BUILTIN_CLZ(n) internal::clz(n)

#  if defined(_WIN64) && !defined(__clang__)
#    pragma intrinsic(_BitScanReverse64)
#  endif

inline uint32_t clzll(uint64_t x) {
  unsigned long r = 0;
#  ifdef _WIN64
  _BitScanReverse64(&r, x);
#  else
  // Scan the high 32 bits.
  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);

  // Scan the low 32 bits.
  _BitScanReverse(&r, static_cast<uint32_t>(x));
#  endif

  FMT_ASSERT(x != 0, "");
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
#  pragma warning(suppress : 6102)
  return 63 - r;
}
#  define FMT_BUILTIN_CLZLL(n) internal::clzll(n)
}  // namespace internal
FMT_END_NAMESPACE
#endif

// Enable the deprecated numeric alignment.
#ifndef FMT_NUMERIC_ALIGN
#  define FMT_NUMERIC_ALIGN 1
#endif

// Enable the deprecated percent specifier.
#ifndef FMT_DEPRECATED_PERCENT
#  define FMT_DEPRECATED_PERCENT 0
#endif

FMT_BEGIN_NAMESPACE
namespace internal {

// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
// undefined behavior (e.g. due to type aliasing).
// Example: uint64_t d = bit_cast<uint64_t>(2.718);
template <typename Dest, typename Source>
inline Dest bit_cast(const Source& source) {
  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
  Dest dest;
  std::memcpy(&dest, &source, sizeof(dest));
  return dest;
}

inline bool is_big_endian() {
  const auto u = 1u;
  struct bytes {
    char data[sizeof(u)];
  };
  return bit_cast<bytes>(u).data[0] == 0;
}

// A fallback implementation of uintptr_t for systems that lack it.
struct fallback_uintptr {
  unsigned char value[sizeof(void*)];

  fallback_uintptr() = default;
  explicit fallback_uintptr(const void* p) {
    *this = bit_cast<fallback_uintptr>(p);
    if (is_big_endian()) {
      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
        std::swap(value[i], value[j]);
    }
  }
};
#ifdef UINTPTR_MAX
using uintptr_t = ::uintptr_t;
inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
#else
using uintptr_t = fallback_uintptr;
inline fallback_uintptr to_uintptr(const void* p) {
  return fallback_uintptr(p);
}
#endif

// Returns the largest possible value for type T. Same as
// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
template <typename T> constexpr T max_value() {
  return (std::numeric_limits<T>::max)();
}
template <typename T> constexpr int num_bits() {
  return std::numeric_limits<T>::digits;
}
template <> constexpr int num_bits<fallback_uintptr>() {
  return static_cast<int>(sizeof(void*) *
                          std::numeric_limits<unsigned char>::digits);
}

// An approximation of iterator_t for pre-C++20 systems.
template <typename T>
using iterator_t = decltype(std::begin(std::declval<T&>()));

// Detect the iterator category of *any* given type in a SFINAE-friendly way.
// Unfortunately, older implementations of std::iterator_traits are not safe
// for use in a SFINAE-context.
template <typename It, typename Enable = void>
struct iterator_category : std::false_type {};

template <typename T> struct iterator_category<T*> {
  using type = std::random_access_iterator_tag;
};

template <typename It>
struct iterator_category<It, void_t<typename It::iterator_category>> {
  using type = typename It::iterator_category;
};

// Detect if *any* given type models the OutputIterator concept.
template <typename It> class is_output_iterator {
  // Check for mutability because all iterator categories derived from
  // std::input_iterator_tag *may* also meet the requirements of an
  // OutputIterator, thereby falling into the category of 'mutable iterators'
  // [iterator.requirements.general] clause 4. The compiler reveals this
  // property only at the point of *actually dereferencing* the iterator!
  template <typename U>
  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
  template <typename U> static char& test(std::output_iterator_tag);
  template <typename U> static const char& test(...);

  using type = decltype(test<It>(typename iterator_category<It>::type{}));

 public:
  enum { value = !std::is_const<remove_reference_t<type>>::value };
};

// A workaround for std::string not having mutable data() until C++17.
template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
  return &s[0];
}
template <typename Container>
inline typename Container::value_type* get_data(Container& c) {
  return c.data();
}

#if defined(_SECURE_SCL) && _SECURE_SCL
// Make a checked iterator to avoid MSVC warnings.
template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
  return {p, size};
}
#else
template <typename T> using checked_ptr = T*;
template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
#endif

template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
inline checked_ptr<typename Container::value_type> reserve(
    std::back_insert_iterator<Container>& it, std::size_t n) {
  Container& c = get_container(it);
  std::size_t size = c.size();
  c.resize(size + n);
  return make_checked(get_data(c) + size, n);
}

template <typename Iterator>
inline Iterator& reserve(Iterator& it, std::size_t) {
  return it;
}

// An output iterator that counts the number of objects written to it and
// discards them.
class counting_iterator {
 private:
  std::size_t count_;

 public:
  using iterator_category = std::output_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.

  struct value_type {
    template <typename T> void operator=(const T&) {}
  };

  counting_iterator() : count_(0) {}

  std::size_t count() const { return count_; }

  counting_iterator& operator++() {
    ++count_;
    return *this;
  }

  counting_iterator operator++(int) {
    auto it = *this;
    ++*this;
    return it;
  }

  value_type operator*() const { return {}; }
};

template <typename OutputIt> class truncating_iterator_base {
 protected:
  OutputIt out_;
  std::size_t limit_;
  std::size_t count_;

  truncating_iterator_base(OutputIt out, std::size_t limit)
      : out_(out), limit_(limit), count_(0) {}

 public:
  using iterator_category = std::output_iterator_tag;
  using value_type = typename std::iterator_traits<OutputIt>::value_type;
  using difference_type = void;
  using pointer = void;
  using reference = void;
  using _Unchecked_type =
      truncating_iterator_base;  // Mark iterator as checked.

  OutputIt base() const { return out_; }
  std::size_t count() const { return count_; }
};

// An output iterator that truncates the output and counts the number of objects
// written to it.
template <typename OutputIt,
          typename Enable = typename std::is_void<
              typename std::iterator_traits<OutputIt>::value_type>::type>
class truncating_iterator;

template <typename OutputIt>
class truncating_iterator<OutputIt, std::false_type>
    : public truncating_iterator_base<OutputIt> {
  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;

 public:
  using value_type = typename truncating_iterator_base<OutputIt>::value_type;

  truncating_iterator(OutputIt out, std::size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}

  truncating_iterator& operator++() {
    if (this->count_++ < this->limit_) ++this->out_;
    return *this;
  }

  truncating_iterator operator++(int) {
    auto it = *this;
    ++*this;
    return it;
  }

  value_type& operator*() const {
    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
  }
};

template <typename OutputIt>
class truncating_iterator<OutputIt, std::true_type>
    : public truncating_iterator_base<OutputIt> {
 public:
  truncating_iterator(OutputIt out, std::size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}

  template <typename T> truncating_iterator& operator=(T val) {
    if (this->count_++ < this->limit_) *this->out_++ = val;
    return *this;
  }

  truncating_iterator& operator++() { return *this; }
  truncating_iterator& operator++(int) { return *this; }
  truncating_iterator& operator*() { return *this; }
};

// A range with the specified output iterator and value type.
template <typename OutputIt, typename T = typename OutputIt::value_type>
class output_range {
 private:
  OutputIt it_;

 public:
  using value_type = T;
  using iterator = OutputIt;
  struct sentinel {};

  explicit output_range(OutputIt it) : it_(it) {}
  OutputIt begin() const { return it_; }
  sentinel end() const { return {}; }  // Sentinel is not used yet.
};

template <typename Char>
inline size_t count_code_points(basic_string_view<Char> s) {
  return s.size();
}

// Counts the number of code points in a UTF-8 string.
inline size_t count_code_points(basic_string_view<char> s) {
  const char* data = s.data();
  size_t num_code_points = 0;
  for (size_t i = 0, size = s.size(); i != size; ++i) {
    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
  }
  return num_code_points;
}

inline size_t count_code_points(basic_string_view<char8_type> s) {
  return count_code_points(basic_string_view<char>(
      reinterpret_cast<const char*>(s.data()), s.size()));
}

template <typename Char>
inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
  size_t size = s.size();
  return n < size ? n : size;
}

// Calculates the index of the nth code point in a UTF-8 string.
inline size_t code_point_index(basic_string_view<char8_type> s, size_t n) {
  const char8_type* data = s.data();
  size_t num_code_points = 0;
  for (size_t i = 0, size = s.size(); i != size; ++i) {
    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
      return i;
    }
  }
  return s.size();
}

inline char8_type to_char8_t(char c) { return static_cast<char8_type>(c); }

template <typename InputIt, typename OutChar>
using needs_conversion = bool_constant<
    std::is_same<typename std::iterator_traits<InputIt>::value_type,
                 char>::value &&
    std::is_same<OutChar, char8_type>::value>;

template <typename OutChar, typename InputIt, typename OutputIt,
          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
  return std::copy(begin, end, it);
}

template <typename OutChar, typename InputIt, typename OutputIt,
          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
  return std::transform(begin, end, it, to_char8_t);
}

#ifndef FMT_USE_GRISU
#  define FMT_USE_GRISU 1
#endif

template <typename T> constexpr bool use_grisu() {
  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
         sizeof(T) <= sizeof(double);
}

template <typename T>
template <typename U>
void buffer<T>::append(const U* begin, const U* end) {
  std::size_t new_size = size_ + to_unsigned(end - begin);
  reserve(new_size);
  std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
  size_ = new_size;
}
}  // namespace internal

// A range with an iterator appending to a buffer.
template <typename T>
class buffer_range : public internal::output_range<
                         std::back_insert_iterator<internal::buffer<T>>, T> {
 public:
  using iterator = std::back_insert_iterator<internal::buffer<T>>;
  using internal::output_range<iterator, T>::output_range;
  buffer_range(internal::buffer<T>& buf)
      : internal::output_range<iterator, T>(std::back_inserter(buf)) {}
};

class FMT_DEPRECATED u8string_view
    : public basic_string_view<internal::char8_type> {
 public:
  u8string_view(const char* s)
      : basic_string_view<internal::char8_type>(
            reinterpret_cast<const internal::char8_type*>(s)) {}
  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
      : basic_string_view<internal::char8_type>(
            reinterpret_cast<const internal::char8_type*>(s), count) {}
};

#if FMT_USE_USER_DEFINED_LITERALS
inline namespace literals {
FMT_DEPRECATED inline basic_string_view<internal::char8_type> operator"" _u(
    const char* s, std::size_t n) {
  return {reinterpret_cast<const internal::char8_type*>(s), n};
}
}  // namespace literals
#endif

// The number of characters to store in the basic_memory_buffer object itself
// to avoid dynamic memory allocation.
enum { inline_buffer_size = 500 };

/**
  \rst
  A dynamically growing memory buffer for trivially copyable/constructible types
  with the first ``SIZE`` elements stored in the object itself.

  You can use one of the following type aliases for common character types:

  +----------------+------------------------------+
  | Type           | Definition                   |
  +================+==============================+
  | memory_buffer  | basic_memory_buffer<char>    |
  +----------------+------------------------------+
  | wmemory_buffer | basic_memory_buffer<wchar_t> |
  +----------------+------------------------------+

  **Example**::

     fmt::memory_buffer out;
     format_to(out, "The answer is {}.", 42);

  This will append the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42.

  The output can be converted to an ``std::string`` with ``to_string(out)``.
  \endrst
 */
template <typename T, std::size_t SIZE = inline_buffer_size,
          typename Allocator = std::allocator<T>>
class basic_memory_buffer : private Allocator, public internal::buffer<T> {
 private:
  T store_[SIZE];

  // Deallocate memory allocated by the buffer.
  void deallocate() {
    T* data = this->data();
    if (data != store_) Allocator::deallocate(data, this->capacity());
  }

 protected:
  void grow(std::size_t size) FMT_OVERRIDE;

 public:
  using value_type = T;
  using const_reference = const T&;

  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
      : Allocator(alloc) {
    this->set(store_, SIZE);
  }
  ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }

 private:
  // Move data from other to this buffer.
  void move(basic_memory_buffer& other) {
    Allocator &this_alloc = *this, &other_alloc = other;
    this_alloc = std::move(other_alloc);
    T* data = other.data();
    std::size_t size = other.size(), capacity = other.capacity();
    if (data == other.store_) {
      this->set(store_, capacity);
      std::uninitialized_copy(other.store_, other.store_ + size,
                              internal::make_checked(store_, capacity));
    } else {
      this->set(data, capacity);
      // Set pointer to the inline array so that delete is not called
      // when deallocating.
      other.set(other.store_, 0);
    }
    this->resize(size);
  }

 public:
  /**
    \rst
    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
    of the other object to it.
    \endrst
   */
  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }

  /**
    \rst
    Moves the content of the other ``basic_memory_buffer`` object to this one.
    \endrst
   */
  basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
    FMT_ASSERT(this != &other, "");
    deallocate();
    move(other);
    return *this;
  }

  // Returns a copy of the allocator associated with this buffer.
  Allocator get_allocator() const { return *this; }
};

template <typename T, std::size_t SIZE, typename Allocator>
void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
  std::size_t old_capacity = this->capacity();
  std::size_t new_capacity = old_capacity + old_capacity / 2;
  if (size > new_capacity) new_capacity = size;
  T* old_data = this->data();
  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
  // The following code doesn't throw, so the raw pointer above doesn't leak.
  std::uninitialized_copy(old_data, old_data + this->size(),
                          internal::make_checked(new_data, new_capacity));
  this->set(new_data, new_capacity);
  // deallocate must not throw according to the standard, but even if it does,
  // the buffer already uses the new storage and will deallocate it in
  // destructor.
  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
}

using memory_buffer = basic_memory_buffer<char>;
using wmemory_buffer = basic_memory_buffer<wchar_t>;

/** A formatting error such as invalid format string. */
FMT_CLASS_API
class FMT_API format_error : public std::runtime_error {
 public:
  explicit format_error(const char* message) : std::runtime_error(message) {}
  explicit format_error(const std::string& message)
      : std::runtime_error(message) {}
  format_error(const format_error&) = default;
  format_error& operator=(const format_error&) = default;
  format_error(format_error&&) = default;
  format_error& operator=(format_error&&) = default;
  ~format_error() FMT_NOEXCEPT FMT_OVERRIDE;
};

namespace internal {

// Returns true if value is negative, false otherwise.
// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
FMT_CONSTEXPR bool is_negative(T value) {
  return value < 0;
}
template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
FMT_CONSTEXPR bool is_negative(T) {
  return false;
}

template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
FMT_CONSTEXPR bool is_supported_floating_point(T) {
  return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
         (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
         (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
}

// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
// represent all values of T.
template <typename T>
using uint32_or_64_or_128_t = conditional_t<
    std::numeric_limits<T>::digits <= 32, uint32_t,
    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;

// Static data is placed in this class template for the header-only config.
template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
  static const uint64_t powers_of_10_64[];
  static const uint32_t zero_or_powers_of_10_32[];
  static const uint64_t zero_or_powers_of_10_64[];
  static const uint64_t pow10_significands[];
  static const int16_t pow10_exponents[];
  static const char digits[];
  static const char hex_digits[];
  static const char foreground_color[];
  static const char background_color[];
  static const char reset_color[5];
  static const wchar_t wreset_color[5];
  static const char signs[];
};

FMT_EXTERN template struct basic_data<void>;

// This is a struct rather than an alias to avoid shadowing warnings in gcc.
struct data : basic_data<> {};

#ifdef FMT_BUILTIN_CLZLL
// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
inline int count_digits(uint64_t n) {
  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
}
#else
// Fallback version of count_digits used when __builtin_clz is not available.
inline int count_digits(uint64_t n) {
  int count = 1;
  for (;;) {
    // Integer division is slow so do it for a group of four digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000u;
    count += 4;
  }
}
#endif

#if FMT_USE_INT128
inline int count_digits(uint128_t n) {
  int count = 1;
  for (;;) {
    // Integer division is slow so do it for a group of four digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000U;
    count += 4;
  }
}
#endif

// Counts the number of digits in n. BITS = log2(radix).
template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
  int num_digits = 0;
  do {
    ++num_digits;
  } while ((n >>= BITS) != 0);
  return num_digits;
}

template <> int count_digits<4>(internal::fallback_uintptr n);

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
#else
#  define FMT_ALWAYS_INLINE
#endif

#ifdef FMT_BUILTIN_CLZ
// Optional version of count_digits for better performance on 32-bit platforms.
inline int count_digits(uint32_t n) {
  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
}
#endif

template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
template <typename Char> inline std::string grouping(locale_ref loc) {
  return grouping_impl<char>(loc);
}
template <> inline std::string grouping<wchar_t>(locale_ref loc) {
  return grouping_impl<wchar_t>(loc);
}

template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
template <typename Char> inline Char thousands_sep(locale_ref loc) {
  return Char(thousands_sep_impl<char>(loc));
}
template <> inline wchar_t thousands_sep(locale_ref loc) {
  return thousands_sep_impl<wchar_t>(loc);
}

template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
template <typename Char> inline Char decimal_point(locale_ref loc) {
  return Char(decimal_point_impl<char>(loc));
}
template <> inline wchar_t decimal_point(locale_ref loc) {
  return decimal_point_impl<wchar_t>(loc);
}

// Formats a decimal unsigned integer value writing into buffer.
// add_thousands_sep is called after writing each char to add a thousands
// separator if necessary.
template <typename UInt, typename Char, typename F>
inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
                            F add_thousands_sep) {
  FMT_ASSERT(num_digits >= 0, "invalid digit count");
  buffer += num_digits;
  Char* end = buffer;
  while (value >= 100) {
    // Integer division is slow so do it for a group of two digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    auto index = static_cast<unsigned>((value % 100) * 2);
    value /= 100;
    *--buffer = static_cast<Char>(data::digits[index + 1]);
    add_thousands_sep(buffer);
    *--buffer = static_cast<Char>(data::digits[index]);
    add_thousands_sep(buffer);
  }
  if (value < 10) {
    *--buffer = static_cast<Char>('0' + value);
    return end;
  }
  auto index = static_cast<unsigned>(value * 2);
  *--buffer = static_cast<Char>(data::digits[index + 1]);
  add_thousands_sep(buffer);
  *--buffer = static_cast<Char>(data::digits[index]);
  return end;
}

template <typename Int> constexpr int digits10() FMT_NOEXCEPT {
  return std::numeric_limits<Int>::digits10;
}
template <> constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }
template <> constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }

template <typename Char, typename UInt, typename Iterator, typename F>
inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
                               F add_thousands_sep) {
  FMT_ASSERT(num_digits >= 0, "invalid digit count");
  // Buffer should be large enough to hold all digits (<= digits10 + 1).
  enum { max_size = digits10<UInt>() + 1 };
  Char buffer[2 * max_size];
  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
  return internal::copy_str<Char>(buffer, end, out);
}

template <typename Char, typename It, typename UInt>
inline It format_decimal(It out, UInt value, int num_digits) {
  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
}

template <unsigned BASE_BITS, typename Char, typename UInt>
inline Char* format_uint(Char* buffer, UInt value, int num_digits,
                         bool upper = false) {
  buffer += num_digits;
  Char* end = buffer;
  do {
    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
    unsigned digit = (value & ((1 << BASE_BITS) - 1));
    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
                                                : digits[digit]);
  } while ((value >>= BASE_BITS) != 0);
  return end;
}

template <unsigned BASE_BITS, typename Char>
Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
                  bool = false) {
  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
  int start = (num_digits + char_digits - 1) / char_digits - 1;
  if (int start_digits = num_digits % char_digits) {
    unsigned value = n.value[start--];
    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
  }
  for (; start >= 0; --start) {
    unsigned value = n.value[start];
    buffer += char_digits;
    auto p = buffer;
    for (int i = 0; i < char_digits; ++i) {
      unsigned digit = (value & ((1 << BASE_BITS) - 1));
      *--p = static_cast<Char>(data::hex_digits[digit]);
      value >>= BASE_BITS;
    }
  }
  return buffer;
}

template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
  char buffer[num_bits<UInt>() / BASE_BITS + 1];
  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
}

// A converter from UTF-8 to UTF-16.
class utf8_to_utf16 {
 private:
  wmemory_buffer buffer_;

 public:
  FMT_API explicit utf8_to_utf16(string_view s);
  operator wstring_view() const { return {&buffer_[0], size()}; }
  size_t size() const { return buffer_.size() - 1; }
  const wchar_t* c_str() const { return &buffer_[0]; }
  std::wstring str() const { return {&buffer_[0], size()}; }
};

template <typename T = void> struct null {};

// Workaround an array initialization issue in gcc 4.8.
template <typename Char> struct fill_t {
 private:
  enum { max_size = 4 };
  Char data_[max_size];
  unsigned char size_;

 public:
  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
    auto size = s.size();
    if (size > max_size) {
      FMT_THROW(format_error("invalid fill"));
      return;
    }
    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
    size_ = static_cast<unsigned char>(size);
  }

  size_t size() const { return size_; }
  const Char* data() const { return data_; }

  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
  FMT_CONSTEXPR const Char& operator[](size_t index) const {
    return data_[index];
  }

  static FMT_CONSTEXPR fill_t<Char> make() {
    auto fill = fill_t<Char>();
    fill[0] = Char(' ');
    fill.size_ = 1;
    return fill;
  }
};
}  // namespace internal

// We cannot use enum classes as bit fields because of a gcc bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
namespace align {
enum type { none, left, right, center, numeric };
}
using align_t = align::type;

namespace sign {
enum type { none, minus, plus, space };
}
using sign_t = sign::type;

// Format specifiers for built-in and string types.
template <typename Char> struct basic_format_specs {
  int width;
  int precision;
  char type;
  align_t align : 4;
  sign_t sign : 3;
  bool alt : 1;  // Alternate form ('#').
  internal::fill_t<Char> fill;

  constexpr basic_format_specs()
      : width(0),
        precision(-1),
        type(0),
        align(align::none),
        sign(sign::none),
        alt(false),
        fill(internal::fill_t<Char>::make()) {}
};

using format_specs = basic_format_specs<char>;

namespace internal {

// A floating-point presentation format.
enum class float_format : unsigned char {
  general,  // General: exponent notation or fixed point based on magnitude.
  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
  hex
};

struct float_specs {
  int precision;
  float_format format : 8;
  sign_t sign : 8;
  bool upper : 1;
  bool locale : 1;
  bool percent : 1;
  bool binary32 : 1;
  bool use_grisu : 1;
  bool showpoint : 1;
};

// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
template <typename Char, typename It> It write_exponent(int exp, It it) {
  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  if (exp < 0) {
    *it++ = static_cast<Char>('-');
    exp = -exp;
  } else {
    *it++ = static_cast<Char>('+');
  }
  if (exp >= 100) {
    const char* top = data::digits + (exp / 100) * 2;
    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
    *it++ = static_cast<Char>(top[1]);
    exp %= 100;
  }
  const char* d = data::digits + exp * 2;
  *it++ = static_cast<Char>(d[0]);
  *it++ = static_cast<Char>(d[1]);
  return it;
}

template <typename Char> class float_writer {
 private:
  // The number is given as v = digits_ * pow(10, exp_).
  const char* digits_;
  int num_digits_;
  int exp_;
  size_t size_;
  float_specs specs_;
  Char decimal_point_;

  template <typename It> It prettify(It it) const {
    // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
    int full_exp = num_digits_ + exp_;
    if (specs_.format == float_format::exp) {
      // Insert a decimal point after the first digit and add an exponent.
      *it++ = static_cast<Char>(*digits_);
      int num_zeros = specs_.precision - num_digits_;
      if (num_digits_ > 1 || specs_.showpoint) *it++ = decimal_point_;
      it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
      if (num_zeros > 0 && specs_.showpoint)
        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
      *it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
      return write_exponent<Char>(full_exp - 1, it);
    }
    if (num_digits_ <= full_exp) {
      // 1234e7 -> 12340000000[.0+]
      it = copy_str<Char>(digits_, digits_ + num_digits_, it);
      it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
      if (specs_.showpoint || specs_.precision < 0) {
        *it++ = decimal_point_;
        int num_zeros = specs_.precision - full_exp;
        if (num_zeros <= 0) {
          if (specs_.format != float_format::fixed)
            *it++ = static_cast<Char>('0');
          return it;
        }
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
        if (num_zeros > 1000)
          throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
      }
    } else if (full_exp > 0) {
      // 1234e-2 -> 12.34[0+]
      it = copy_str<Char>(digits_, digits_ + full_exp, it);
      if (!specs_.showpoint) {
        // Remove trailing zeros.
        int num_digits = num_digits_;
        while (num_digits > full_exp && digits_[num_digits - 1] == '0')
          --num_digits;
        if (num_digits != full_exp) *it++ = decimal_point_;
        return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
      }
      *it++ = decimal_point_;
      it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
      if (specs_.precision > num_digits_) {
        // Add trailing zeros.
        int num_zeros = specs_.precision - num_digits_;
        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
      }
    } else {
      // 1234e-6 -> 0.001234
      *it++ = static_cast<Char>('0');
      int num_zeros = -full_exp;
      int num_digits = num_digits_;
      if (num_digits == 0 && specs_.precision >= 0 &&
          specs_.precision < num_zeros) {
        num_zeros = specs_.precision;
      }
      // Remove trailing zeros.
      if (!specs_.showpoint)
        while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
      if (num_zeros != 0 || num_digits != 0 || specs_.showpoint) {
        *it++ = decimal_point_;
        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
        it = copy_str<Char>(digits_, digits_ + num_digits, it);
      }
    }
    return it;
  }

 public:
  float_writer(const char* digits, int num_digits, int exp, float_specs specs,
               Char decimal_point)
      : digits_(digits),
        num_digits_(num_digits),
        exp_(exp),
        specs_(specs),
        decimal_point_(decimal_point) {
    int full_exp = num_digits + exp - 1;
    int precision = specs.precision > 0 ? specs.precision : 16;
    if (specs_.format == float_format::general &&
        !(full_exp >= -4 && full_exp < precision)) {
      specs_.format = float_format::exp;
    }
    size_ = prettify(counting_iterator()).count();
    size_ += specs.sign ? 1 : 0;
  }

  size_t size() const { return size_; }
  size_t width() const { return size(); }

  template <typename It> void operator()(It&& it) {
    if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
    it = prettify(it);
  }
};

template <typename T>
int format_float(T value, int precision, float_specs specs, buffer<char>& buf);

// Formats a floating-point number with snprintf.
template <typename T>
int snprintf_float(T value, int precision, float_specs specs,
                   buffer<char>& buf);

template <typename T> T promote_float(T value) { return value; }
inline double promote_float(float value) { return static_cast<double>(value); }

template <typename Handler>
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
  switch (spec) {
  case 0:
  case 'd':
    handler.on_dec();
    break;
  case 'x':
  case 'X':
    handler.on_hex();
    break;
  case 'b':
  case 'B':
    handler.on_bin();
    break;
  case 'o':
    handler.on_oct();
    break;
  case 'n':
  case 'L':
    handler.on_num();
    break;
  default:
    handler.on_error();
  }
}

template <typename ErrorHandler = error_handler, typename Char>
FMT_CONSTEXPR float_specs parse_float_type_spec(
    const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
  auto result = float_specs();
  result.showpoint = specs.alt;
  switch (specs.type) {
  case 0:
    result.format = float_format::general;
    result.showpoint |= specs.precision > 0;
    break;
  case 'G':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'g':
    result.format = float_format::general;
    break;
  case 'E':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'e':
    result.format = float_format::exp;
    result.showpoint |= specs.precision != 0;
    break;
  case 'F':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'f':
    result.format = float_format::fixed;
    result.showpoint |= specs.precision != 0;
    break;
#if FMT_DEPRECATED_PERCENT
  case '%':
    result.format = float_format::fixed;
    result.percent = true;
    break;
#endif
  case 'A':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'a':
    result.format = float_format::hex;
    break;
  case 'n':
    result.locale = true;
    break;
  default:
    eh.on_error("invalid type specifier");
    break;
  }
  return result;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
                                     Handler&& handler) {
  if (!specs) return handler.on_char();
  if (specs->type && specs->type != 'c') return handler.on_int();
  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
    handler.on_error("invalid format specifier for char");
  handler.on_char();
}

template <typename Char, typename Handler>
FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
  if (spec == 0 || spec == 's')
    handler.on_string();
  else if (spec == 'p')
    handler.on_pointer();
  else
    handler.on_error("invalid type specifier");
}

template <typename Char, typename ErrorHandler>
FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
}

template <typename Char, typename ErrorHandler>
FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
}

template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
 public:
  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}

  FMT_CONSTEXPR void on_dec() {}
  FMT_CONSTEXPR void on_hex() {}
  FMT_CONSTEXPR void on_bin() {}
  FMT_CONSTEXPR void on_oct() {}
  FMT_CONSTEXPR void on_num() {}

  FMT_CONSTEXPR void on_error() {
    ErrorHandler::on_error("invalid type specifier");
  }
};

template <typename ErrorHandler>
class char_specs_checker : public ErrorHandler {
 private:
  char type_;

 public:
  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
      : ErrorHandler(eh), type_(type) {}

  FMT_CONSTEXPR void on_int() {
    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
  }
  FMT_CONSTEXPR void on_char() {}
};

template <typename ErrorHandler>
class cstring_type_checker : public ErrorHandler {
 public:
  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
      : ErrorHandler(eh) {}

  FMT_CONSTEXPR void on_string() {}
  FMT_CONSTEXPR void on_pointer() {}
};

template <typename Context>
void arg_map<Context>::init(const basic_format_args<Context>& args) {
  if (map_) return;
  map_ = new entry[internal::to_unsigned(args.max_size())];
  if (args.is_packed()) {
    for (int i = 0;; ++i) {
      internal::type arg_type = args.type(i);
      if (arg_type == internal::type::none_type) return;
      if (arg_type == internal::type::named_arg_type)
        push_back(args.values_[i]);
    }
  }
  for (int i = 0, n = args.max_size(); i < n; ++i) {
    auto type = args.args_[i].type_;
    if (type == internal::type::named_arg_type) push_back(args.args_[i].value_);
  }
}

template <typename Char> struct nonfinite_writer {
  sign_t sign;
  const char* str;
  static constexpr size_t str_size = 3;

  size_t size() const { return str_size + (sign ? 1 : 0); }
  size_t width() const { return size(); }

  template <typename It> void operator()(It&& it) const {
    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
    it = copy_str<Char>(str, str + str_size, it);
  }
};

template <typename OutputIt, typename Char>
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
  auto fill_size = fill.size();
  if (fill_size == 1) return std::fill_n(it, n, fill[0]);
  for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
  return it;
}

// This template provides operations for formatting and writing data into a
// character range.
template <typename Range> class basic_writer {
 public:
  using char_type = typename Range::value_type;
  using iterator = typename Range::iterator;
  using format_specs = basic_format_specs<char_type>;

 private:
  iterator out_;  // Output iterator.
  locale_ref locale_;

  // Attempts to reserve space for n extra characters in the output range.
  // Returns a pointer to the reserved range or a reference to out_.
  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
    return internal::reserve(out_, n);
  }

  template <typename F> struct padded_int_writer {
    size_t size_;
    string_view prefix;
    char_type fill;
    std::size_t padding;
    F f;

    size_t size() const { return size_; }
    size_t width() const { return size_; }

    template <typename It> void operator()(It&& it) const {
      if (prefix.size() != 0)
        it = copy_str<char_type>(prefix.begin(), prefix.end(), it);
      it = std::fill_n(it, padding, fill);
      f(it);
    }
  };

  // Writes an integer in the format
  //   <left-padding><prefix><numeric-padding><digits><right-padding>
  // where <digits> are written by f(it).
  template <typename F>
  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
    std::size_t size = prefix.size() + to_unsigned(num_digits);
    char_type fill = specs.fill[0];
    std::size_t padding = 0;
    if (specs.align == align::numeric) {
      auto unsiged_width = to_unsigned(specs.width);
      if (unsiged_width > size) {
        padding = unsiged_width - size;
        size = unsiged_width;
      }
    } else if (specs.precision > num_digits) {
      size = prefix.size() + to_unsigned(specs.precision);
      padding = to_unsigned(specs.precision - num_digits);
      fill = static_cast<char_type>('0');
    }
    if (specs.align == align::none) specs.align = align::right;
    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
  }

  // Writes a decimal integer.
  template <typename Int> void write_decimal(Int value) {
    auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
    bool negative = is_negative(value);
    // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
    if (negative) abs_value = ~abs_value + 1;
    int num_digits = count_digits(abs_value);
    auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
    if (negative) *it++ = static_cast<char_type>('-');
    it = format_decimal<char_type>(it, abs_value, num_digits);
  }

  // The handle_int_type_spec handler that writes an integer.
  template <typename Int, typename Specs> struct int_writer {
    using unsigned_type = uint32_or_64_or_128_t<Int>;

    basic_writer<Range>& writer;
    const Specs& specs;
    unsigned_type abs_value;
    char prefix[4];
    unsigned prefix_size;

    string_view get_prefix() const { return string_view(prefix, prefix_size); }

    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
        : writer(w),
          specs(s),
          abs_value(static_cast<unsigned_type>(value)),
          prefix_size(0) {
      if (is_negative(value)) {
        prefix[0] = '-';
        ++prefix_size;
        abs_value = 0 - abs_value;
      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
        ++prefix_size;
      }
    }

    struct dec_writer {
      unsigned_type abs_value;
      int num_digits;

      template <typename It> void operator()(It&& it) const {
        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
      }
    };

    void on_dec() {
      int num_digits = count_digits(abs_value);
      writer.write_int(num_digits, get_prefix(), specs,
                       dec_writer{abs_value, num_digits});
    }

    struct hex_writer {
      int_writer& self;
      int num_digits;

      template <typename It> void operator()(It&& it) const {
        it = format_uint<4, char_type>(it, self.abs_value, num_digits,
                                       self.specs.type != 'x');
      }
    };

    void on_hex() {
      if (specs.alt) {
        prefix[prefix_size++] = '0';
        prefix[prefix_size++] = specs.type;
      }
      int num_digits = count_digits<4>(abs_value);
      writer.write_int(num_digits, get_prefix(), specs,
                       hex_writer{*this, num_digits});
    }

    template <int BITS> struct bin_writer {
      unsigned_type abs_value;
      int num_digits;

      template <typename It> void operator()(It&& it) const {
        it = format_uint<BITS, char_type>(it, abs_value, num_digits);
      }
    };

    void on_bin() {
      if (specs.alt) {
        prefix[prefix_size++] = '0';
        prefix[prefix_size++] = static_cast<char>(specs.type);
      }
      int num_digits = count_digits<1>(abs_value);
      writer.write_int(num_digits, get_prefix(), specs,
                       bin_writer<1>{abs_value, num_digits});
    }

    void on_oct() {
      int num_digits = count_digits<3>(abs_value);
      if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
        // Octal prefix '0' is counted as a digit, so only add it if precision
        // is not greater than the number of digits.
        prefix[prefix_size++] = '0';
      }
      writer.write_int(num_digits, get_prefix(), specs,
                       bin_writer<3>{abs_value, num_digits});
    }

    enum { sep_size = 1 };

    struct num_writer {
      unsigned_type abs_value;
      int size;
      const std::string& groups;
      char_type sep;

      template <typename It> void operator()(It&& it) const {
        basic_string_view<char_type> s(&sep, sep_size);
        // Index of a decimal digit with the least significant digit having
        // index 0.
        int digit_index = 0;
        std::string::const_iterator group = groups.cbegin();
        it = format_decimal<char_type>(
            it, abs_value, size,
            [this, s, &group, &digit_index](char_type*& buffer) {
              if (*group <= 0 || ++digit_index % *group != 0 ||
                  *group == max_value<char>())
                return;
              if (group + 1 != groups.cend()) {
                digit_index = 0;
                ++group;
              }
              buffer -= s.size();
              std::uninitialized_copy(s.data(), s.data() + s.size(),
                                      make_checked(buffer, s.size()));
            });
      }
    };

    void on_num() {
      std::string groups = grouping<char_type>(writer.locale_);
      if (groups.empty()) return on_dec();
      auto sep = thousands_sep<char_type>(writer.locale_);
      if (!sep) return on_dec();
      int num_digits = count_digits(abs_value);
      int size = num_digits;
      std::string::const_iterator group = groups.cbegin();
      while (group != groups.cend() && num_digits > *group && *group > 0 &&
             *group != max_value<char>()) {
        size += sep_size;
        num_digits -= *group;
        ++group;
      }
      if (group == groups.cend())
        size += sep_size * ((num_digits - 1) / groups.back());
      writer.write_int(size, get_prefix(), specs,
                       num_writer{abs_value, size, groups, sep});
    }

    FMT_NORETURN void on_error() {
      FMT_THROW(format_error("invalid type specifier"));
    }
  };

  template <typename Char> struct str_writer {
    const Char* s;
    size_t size_;

    size_t size() const { return size_; }
    size_t width() const {
      return count_code_points(basic_string_view<Char>(s, size_));
    }

    template <typename It> void operator()(It&& it) const {
      it = copy_str<char_type>(s, s + size_, it);
    }
  };

  struct bytes_writer {
    string_view bytes;

    size_t size() const { return bytes.size(); }
    size_t width() const { return bytes.size(); }

    template <typename It> void operator()(It&& it) const {
      const char* data = bytes.data();
      it = copy_str<char>(data, data + size(), it);
    }
  };

  template <typename UIntPtr> struct pointer_writer {
    UIntPtr value;
    int num_digits;

    size_t size() const { return to_unsigned(num_digits) + 2; }
    size_t width() const { return size(); }

    template <typename It> void operator()(It&& it) const {
      *it++ = static_cast<char_type>('0');
      *it++ = static_cast<char_type>('x');
      it = format_uint<4, char_type>(it, value, num_digits);
    }
  };

 public:
  explicit basic_writer(Range out, locale_ref loc = locale_ref())
      : out_(out.begin()), locale_(loc) {}

  iterator out() const { return out_; }

  // Writes a value in the format
  //   <left-padding><value><right-padding>
  // where <value> is written by f(it).
  template <typename F> void write_padded(const format_specs& specs, F&& f) {
    // User-perceived width (in code points).
    unsigned width = to_unsigned(specs.width);
    size_t size = f.size();  // The number of code units.
    size_t num_code_points = width != 0 ? f.width() : size;
    if (width <= num_code_points) return f(reserve(size));
    size_t padding = width - num_code_points;
    size_t fill_size = specs.fill.size();
    auto&& it = reserve(size + padding * fill_size);
    if (specs.align == align::right) {
      it = fill(it, padding, specs.fill);
      f(it);
    } else if (specs.align == align::center) {
      std::size_t left_padding = padding / 2;
      it = fill(it, left_padding, specs.fill);
      f(it);
      it = fill(it, padding - left_padding, specs.fill);
    } else {
      f(it);
      it = fill(it, padding, specs.fill);
    }
  }

  void write(int value) { write_decimal(value); }
  void write(long value) { write_decimal(value); }
  void write(long long value) { write_decimal(value); }

  void write(unsigned value) { write_decimal(value); }
  void write(unsigned long value) { write_decimal(value); }
  void write(unsigned long long value) { write_decimal(value); }

#if FMT_USE_INT128
  void write(int128_t value) { write_decimal(value); }
  void write(uint128_t value) { write_decimal(value); }
#endif

  template <typename T, typename Spec>
  void write_int(T value, const Spec& spec) {
    handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
  void write(T value, format_specs specs = {}) {
    if (const_check(!is_supported_floating_point(value))) {
      return;
    }
    float_specs fspecs = parse_float_type_spec(specs);
    fspecs.sign = specs.sign;
    if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
      fspecs.sign = sign::minus;
      value = -value;
    } else if (fspecs.sign == sign::minus) {
      fspecs.sign = sign::none;
    }

    if (!std::isfinite(value)) {
      auto str = std::isinf(value) ? (fspecs.upper ? "INF" : "inf")
                                   : (fspecs.upper ? "NAN" : "nan");
      return write_padded(specs, nonfinite_writer<char_type>{fspecs.sign, str});
    }

    if (specs.align == align::none) {
      specs.align = align::right;
    } else if (specs.align == align::numeric) {
      if (fspecs.sign) {
        auto&& it = reserve(1);
        *it++ = static_cast<char_type>(data::signs[fspecs.sign]);
        fspecs.sign = sign::none;
        if (specs.width != 0) --specs.width;
      }
      specs.align = align::right;
    }

    memory_buffer buffer;
    if (fspecs.format == float_format::hex) {
      if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
      snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
      write_padded(specs, str_writer<char>{buffer.data(), buffer.size()});
      return;
    }
    int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
    if (fspecs.format == float_format::exp) {
      if (precision == max_value<int>())
        FMT_THROW(format_error("number is too big"));
      else
        ++precision;
    }
    if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
    fspecs.use_grisu = use_grisu<T>();
    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;
    int exp = format_float(promote_float(value), precision, fspecs, buffer);
    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {
      buffer.push_back('%');
      --exp;  // Adjust decimal place position.
    }
    fspecs.precision = precision;
    char_type point = fspecs.locale ? decimal_point<char_type>(locale_)
                                    : static_cast<char_type>('.');
    write_padded(specs, float_writer<char_type>(buffer.data(),
                                                static_cast<int>(buffer.size()),
                                                exp, fspecs, point));
  }

  void write(char value) {
    auto&& it = reserve(1);
    *it++ = value;
  }

  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
  void write(Char value) {
    auto&& it = reserve(1);
    *it++ = value;
  }

  void write(string_view value) {
    auto&& it = reserve(value.size());
    it = copy_str<char_type>(value.begin(), value.end(), it);
  }
  void write(wstring_view value) {
    static_assert(std::is_same<char_type, wchar_t>::value, "");
    auto&& it = reserve(value.size());
    it = std::copy(value.begin(), value.end(), it);
  }

  template <typename Char>
  void write(const Char* s, std::size_t size, const format_specs& specs) {
    write_padded(specs, str_writer<Char>{s, size});
  }

  template <typename Char>
  void write(basic_string_view<Char> s, const format_specs& specs = {}) {
    const Char* data = s.data();
    std::size_t size = s.size();
    if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
      size = code_point_index(s, to_unsigned(specs.precision));
    write(data, size, specs);
  }

  void write_bytes(string_view bytes, const format_specs& specs) {
    write_padded(specs, bytes_writer{bytes});
  }

  template <typename UIntPtr>
  void write_pointer(UIntPtr value, const format_specs* specs) {
    int num_digits = count_digits<4>(value);
    auto pw = pointer_writer<UIntPtr>{value, num_digits};
    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
    format_specs specs_copy = *specs;
    if (specs_copy.align == align::none) specs_copy.align = align::right;
    write_padded(specs_copy, pw);
  }
};

using writer = basic_writer<buffer_range<char>>;

template <typename T> struct is_integral : std::is_integral<T> {};
template <> struct is_integral<int128_t> : std::true_type {};
template <> struct is_integral<uint128_t> : std::true_type {};

template <typename Range, typename ErrorHandler = internal::error_handler>
class arg_formatter_base {
 public:
  using char_type = typename Range::value_type;
  using iterator = typename Range::iterator;
  using format_specs = basic_format_specs<char_type>;

 private:
  using writer_type = basic_writer<Range>;
  writer_type writer_;
  format_specs* specs_;

  struct char_writer {
    char_type value;

    size_t size() const { return 1; }
    size_t width() const { return 1; }

    template <typename It> void operator()(It&& it) const { *it++ = value; }
  };

  void write_char(char_type value) {
    if (specs_)
      writer_.write_padded(*specs_, char_writer{value});
    else
      writer_.write(value);
  }

  void write_pointer(const void* p) {
    writer_.write_pointer(internal::to_uintptr(p), specs_);
  }

 protected:
  writer_type& writer() { return writer_; }
  FMT_DEPRECATED format_specs* spec() { return specs_; }
  format_specs* specs() { return specs_; }
  iterator out() { return writer_.out(); }

  void write(bool value) {
    string_view sv(value ? "true" : "false");
    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
  }

  void write(const char_type* value) {
    if (!value) {
      FMT_THROW(format_error("string pointer is null"));
    } else {
      auto length = std::char_traits<char_type>::length(value);
      basic_string_view<char_type> sv(value, length);
      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
    }
  }

 public:
  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
      : writer_(r, loc), specs_(s) {}

  iterator operator()(monostate) {
    FMT_ASSERT(false, "invalid argument type");
    return out();
  }

  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
  iterator operator()(T value) {
    if (specs_)
      writer_.write_int(value, *specs_);
    else
      writer_.write(value);
    return out();
  }

  iterator operator()(char_type value) {
    internal::handle_char_specs(
        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
    return out();
  }

  iterator operator()(bool value) {
    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
    write(value != 0);
    return out();
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
  iterator operator()(T value) {
    if (const_check(is_supported_floating_point(value)))
      writer_.write(value, specs_ ? *specs_ : format_specs());
    else
      FMT_ASSERT(false, "unsupported float argument type");
    return out();
  }

  struct char_spec_handler : ErrorHandler {
    arg_formatter_base& formatter;
    char_type value;

    char_spec_handler(arg_formatter_base& f, char_type val)
        : formatter(f), value(val) {}

    void on_int() {
      if (formatter.specs_)
        formatter.writer_.write_int(value, *formatter.specs_);
      else
        formatter.writer_.write(value);
    }
    void on_char() { formatter.write_char(value); }
  };

  struct cstring_spec_handler : internal::error_handler {
    arg_formatter_base& formatter;
    const char_type* value;

    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
        : formatter(f), value(val) {}

    void on_string() { formatter.write(value); }
    void on_pointer() { formatter.write_pointer(value); }
  };

  iterator operator()(const char_type* value) {
    if (!specs_) return write(value), out();
    internal::handle_cstring_type_spec(specs_->type,
                                       cstring_spec_handler(*this, value));
    return out();
  }

  iterator operator()(basic_string_view<char_type> value) {
    if (specs_) {
      internal::check_string_type_spec(specs_->type, internal::error_handler());
      writer_.write(value, *specs_);
    } else {
      writer_.write(value);
    }
    return out();
  }

  iterator operator()(const void* value) {
    if (specs_)
      check_pointer_type_spec(specs_->type, internal::error_handler());
    write_pointer(value);
    return out();
  }
};

template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}

// Parses the range [begin, end) as an unsigned integer. This function assumes
// that the range is non-empty and the first character is a digit.
template <typename Char, typename ErrorHandler>
FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
                                        ErrorHandler&& eh) {
  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
  unsigned value = 0;
  // Convert to unsigned to prevent a warning.
  constexpr unsigned max_int = max_value<int>();
  unsigned big = max_int / 10;
  do {
    // Check for overflow.
    if (value > big) {
      value = max_int + 1;
      break;
    }
    value = value * 10 + unsigned(*begin - '0');
    ++begin;
  } while (begin != end && '0' <= *begin && *begin <= '9');
  if (value > max_int) eh.on_error("number is too big");
  return static_cast<int>(value);
}

template <typename Context> class custom_formatter {
 private:
  using char_type = typename Context::char_type;

  basic_format_parse_context<char_type>& parse_ctx_;
  Context& ctx_;

 public:
  explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
                            Context& ctx)
      : parse_ctx_(parse_ctx), ctx_(ctx) {}

  bool operator()(typename basic_format_arg<Context>::handle h) const {
    h.format(parse_ctx_, ctx_);
    return true;
  }

  template <typename T> bool operator()(T) const { return false; }
};

template <typename T>
using is_integer =
    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
                  !std::is_same<T, char>::value &&
                  !std::is_same<T, wchar_t>::value>;

template <typename ErrorHandler> class width_checker {
 public:
  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}

  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
  FMT_CONSTEXPR unsigned long long operator()(T value) {
    if (is_negative(value)) handler_.on_error("negative width");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
  FMT_CONSTEXPR unsigned long long operator()(T) {
    handler_.on_error("width is not integer");
    return 0;
  }

 private:
  ErrorHandler& handler_;
};

template <typename ErrorHandler> class precision_checker {
 public:
  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}

  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
  FMT_CONSTEXPR unsigned long long operator()(T value) {
    if (is_negative(value)) handler_.on_error("negative precision");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
  FMT_CONSTEXPR unsigned long long operator()(T) {
    handler_.on_error("precision is not integer");
    return 0;
  }

 private:
  ErrorHandler& handler_;
};

// A format specifier handler that sets fields in basic_format_specs.
template <typename Char> class specs_setter {
 public:
  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
      : specs_(specs) {}

  FMT_CONSTEXPR specs_setter(const specs_setter& other)
      : specs_(other.specs_) {}

  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
  FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
    specs_.fill = fill;
  }
  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }

  FMT_CONSTEXPR void on_zero() {
    specs_.align = align::numeric;
    specs_.fill[0] = Char('0');
  }

  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
  FMT_CONSTEXPR void on_precision(int precision) {
    specs_.precision = precision;
  }
  FMT_CONSTEXPR void end_precision() {}

  FMT_CONSTEXPR void on_type(Char type) {
    specs_.type = static_cast<char>(type);
  }

 protected:
  basic_format_specs<Char>& specs_;
};

template <typename ErrorHandler> class numeric_specs_checker {
 public:
  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
      : error_handler_(eh), arg_type_(arg_type) {}

  FMT_CONSTEXPR void require_numeric_argument() {
    if (!is_arithmetic_type(arg_type_))
      error_handler_.on_error("format specifier requires numeric argument");
  }

  FMT_CONSTEXPR void check_sign() {
    require_numeric_argument();
    if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
      error_handler_.on_error("format specifier requires signed argument");
    }
  }

  FMT_CONSTEXPR void check_precision() {
    if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
      error_handler_.on_error("precision not allowed for this argument type");
  }

 private:
  ErrorHandler& error_handler_;
  internal::type arg_type_;
};

// A format specifier handler that checks if specifiers are consistent with the
// argument type.
template <typename Handler> class specs_checker : public Handler {
 public:
  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
      : Handler(handler), checker_(*this, arg_type) {}

  FMT_CONSTEXPR specs_checker(const specs_checker& other)
      : Handler(other), checker_(*this, other.arg_type_) {}

  FMT_CONSTEXPR void on_align(align_t align) {
    if (align == align::numeric) checker_.require_numeric_argument();
    Handler::on_align(align);
  }

  FMT_CONSTEXPR void on_plus() {
    checker_.check_sign();
    Handler::on_plus();
  }

  FMT_CONSTEXPR void on_minus() {
    checker_.check_sign();
    Handler::on_minus();
  }

  FMT_CONSTEXPR void on_space() {
    checker_.check_sign();
    Handler::on_space();
  }

  FMT_CONSTEXPR void on_hash() {
    checker_.require_numeric_argument();
    Handler::on_hash();
  }

  FMT_CONSTEXPR void on_zero() {
    checker_.require_numeric_argument();
    Handler::on_zero();
  }

  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }

 private:
  numeric_specs_checker<Handler> checker_;
};

template <template <typename> class Handler, typename FormatArg,
          typename ErrorHandler>
FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
  return static_cast<int>(value);
}

struct auto_id {};

template <typename Context>
FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
  auto arg = ctx.arg(id);
  if (!arg) ctx.on_error("argument index out of range");
  return arg;
}

// The standard format specifier handler with checking.
template <typename ParseContext, typename Context>
class specs_handler : public specs_setter<typename Context::char_type> {
 public:
  using char_type = typename Context::char_type;

  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
                              ParseContext& parse_ctx, Context& ctx)
      : specs_setter<char_type>(specs),
        parse_context_(parse_ctx),
        context_(ctx) {}

  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
    this->specs_.width = get_dynamic_spec<width_checker>(
        get_arg(arg_id), context_.error_handler());
  }

  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
    this->specs_.precision = get_dynamic_spec<precision_checker>(
        get_arg(arg_id), context_.error_handler());
  }

  void on_error(const char* message) { context_.on_error(message); }

 private:
  // This is only needed for compatibility with gcc 4.4.
  using format_arg = typename Context::format_arg;

  FMT_CONSTEXPR format_arg get_arg(auto_id) {
    return internal::get_arg(context_, parse_context_.next_arg_id());
  }

  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
    parse_context_.check_arg_id(arg_id);
    return internal::get_arg(context_, arg_id);
  }

  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
    parse_context_.check_arg_id(arg_id);
    return context_.arg(arg_id);
  }

  ParseContext& parse_context_;
  Context& context_;
};

enum class arg_id_kind { none, index, name };

// An argument reference.
template <typename Char> struct arg_ref {
  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}

  FMT_CONSTEXPR explicit arg_ref(int index)
      : kind(arg_id_kind::index), val(index) {}
  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
      : kind(arg_id_kind::name), val(name) {}

  FMT_CONSTEXPR arg_ref& operator=(int idx) {
    kind = arg_id_kind::index;
    val.index = idx;
    return *this;
  }

  arg_id_kind kind;
  union value {
    FMT_CONSTEXPR value(int id = 0) : index{id} {}
    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}

    int index;
    basic_string_view<Char> name;
  } val;
};

// Format specifiers with width and precision resolved at formatting rather
// than parsing time to allow re-using the same parsed specifiers with
// different sets of arguments (precompilation of format strings).
template <typename Char>
struct dynamic_format_specs : basic_format_specs<Char> {
  arg_ref<Char> width_ref;
  arg_ref<Char> precision_ref;
};

// Format spec handler that saves references to arguments representing dynamic
// width and precision to be resolved at formatting time.
template <typename ParseContext>
class dynamic_specs_handler
    : public specs_setter<typename ParseContext::char_type> {
 public:
  using char_type = typename ParseContext::char_type;

  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
                                      ParseContext& ctx)
      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}

  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
      : specs_setter<char_type>(other),
        specs_(other.specs_),
        context_(other.context_) {}

  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
    specs_.width_ref = make_arg_ref(arg_id);
  }

  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
    specs_.precision_ref = make_arg_ref(arg_id);
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    context_.on_error(message);
  }

 private:
  using arg_ref_type = arg_ref<char_type>;

  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
    context_.check_arg_id(arg_id);
    return arg_ref_type(arg_id);
  }

  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
    return arg_ref_type(context_.next_arg_id());
  }

  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
    context_.check_arg_id(arg_id);
    basic_string_view<char_type> format_str(
        context_.begin(), to_unsigned(context_.end() - context_.begin()));
    return arg_ref_type(arg_id);
  }

  dynamic_format_specs<char_type>& specs_;
  ParseContext& context_;
};

template <typename Char, typename IDHandler>
FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
                                       IDHandler&& handler) {
  FMT_ASSERT(begin != end, "");
  Char c = *begin;
  if (c == '}' || c == ':') {
    handler();
    return begin;
  }
  if (c >= '0' && c <= '9') {
    int index = 0;
    if (c != '0')
      index = parse_nonnegative_int(begin, end, handler);
    else
      ++begin;
    if (begin == end || (*begin != '}' && *begin != ':'))
      handler.on_error("invalid format string");
    else
      handler(index);
    return begin;
  }
  if (!is_name_start(c)) {
    handler.on_error("invalid format string");
    return begin;
  }
  auto it = begin;
  do {
    ++it;
  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
  return it;
}

// Adapts SpecHandler to IDHandler API for dynamic width.
template <typename SpecHandler, typename Char> struct width_adapter {
  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}

  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
    handler.on_dynamic_width(id);
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    handler.on_error(message);
  }

  SpecHandler& handler;
};

// Adapts SpecHandler to IDHandler API for dynamic precision.
template <typename SpecHandler, typename Char> struct precision_adapter {
  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}

  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
    handler.on_dynamic_precision(id);
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    handler.on_error(message);
  }

  SpecHandler& handler;
};

template <typename Char>
FMT_CONSTEXPR const Char* next_code_point(const Char* begin, const Char* end) {
  if (const_check(sizeof(Char) != 1) || (*begin & 0x80) == 0) return begin + 1;
  do {
    ++begin;
  } while (begin != end && (*begin & 0xc0) == 0x80);
  return begin;
}

// Parses fill and alignment.
template <typename Char, typename Handler>
FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
                                      Handler&& handler) {
  FMT_ASSERT(begin != end, "");
  auto align = align::none;
  auto p = next_code_point(begin, end);
  if (p == end) p = begin;
  for (;;) {
    switch (static_cast<char>(*p)) {
    case '<':
      align = align::left;
      break;
    case '>':
      align = align::right;
      break;
#if FMT_NUMERIC_ALIGN
    case '=':
      align = align::numeric;
      break;
#endif
    case '^':
      align = align::center;
      break;
    }
    if (align != align::none) {
      if (p != begin) {
        auto c = *begin;
        if (c == '{')
          return handler.on_error("invalid fill character '{'"), begin;
        handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
        begin = p + 1;
      } else
        ++begin;
      handler.on_align(align);
      break;
    } else if (p == begin) {
      break;
    }
    p = begin;
  }
  return begin;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
                                      Handler&& handler) {
  FMT_ASSERT(begin != end, "");
  if ('0' <= *begin && *begin <= '9') {
    handler.on_width(parse_nonnegative_int(begin, end, handler));
  } else if (*begin == '{') {
    ++begin;
    if (begin != end)
      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
    if (begin == end || *begin != '}')
      return handler.on_error("invalid format string"), begin;
    ++begin;
  }
  return begin;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
                                          Handler&& handler) {
  ++begin;
  auto c = begin != end ? *begin : Char();
  if ('0' <= c && c <= '9') {
    handler.on_precision(parse_nonnegative_int(begin, end, handler));
  } else if (c == '{') {
    ++begin;
    if (begin != end) {
      begin =
          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
    }
    if (begin == end || *begin++ != '}')
      return handler.on_error("invalid format string"), begin;
  } else {
    return handler.on_error("missing precision specifier"), begin;
  }
  handler.end_precision();
  return begin;
}

// Parses standard format specifiers and sends notifications about parsed
// components to handler.
template <typename Char, typename SpecHandler>
FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
                                             SpecHandler&& handler) {
  if (begin == end || *begin == '}') return begin;

  begin = parse_align(begin, end, handler);
  if (begin == end) return begin;

  // Parse sign.
  switch (static_cast<char>(*begin)) {
  case '+':
    handler.on_plus();
    ++begin;
    break;
  case '-':
    handler.on_minus();
    ++begin;
    break;
  case ' ':
    handler.on_space();
    ++begin;
    break;
  }
  if (begin == end) return begin;

  if (*begin == '#') {
    handler.on_hash();
    if (++begin == end) return begin;
  }

  // Parse zero flag.
  if (*begin == '0') {
    handler.on_zero();
    if (++begin == end) return begin;
  }

  begin = parse_width(begin, end, handler);
  if (begin == end) return begin;

  // Parse precision.
  if (*begin == '.') {
    begin = parse_precision(begin, end, handler);
  }

  // Parse type.
  if (begin != end && *begin != '}') handler.on_type(*begin++);
  return begin;
}

// Return the result via the out param to workaround gcc bug 77539.
template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
  for (out = first; out != last; ++out) {
    if (*out == value) return true;
  }
  return false;
}

template <>
inline bool find<false, char>(const char* first, const char* last, char value,
                              const char*& out) {
  out = static_cast<const char*>(
      std::memchr(first, value, internal::to_unsigned(last - first)));
  return out != nullptr;
}

template <typename Handler, typename Char> struct id_adapter {
  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
    handler.on_arg_id(id);
  }
  FMT_CONSTEXPR void on_error(const char* message) {
    handler.on_error(message);
  }
  Handler& handler;
};

template <bool IS_CONSTEXPR, typename Char, typename Handler>
FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
                                       Handler&& handler) {
  struct pfs_writer {
    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
      if (begin == end) return;
      for (;;) {
        const Char* p = nullptr;
        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
          return handler_.on_text(begin, end);
        ++p;
        if (p == end || *p != '}')
          return handler_.on_error("unmatched '}' in format string");
        handler_.on_text(begin, p);
        begin = p + 1;
      }
    }
    Handler& handler_;
  } write{handler};
  auto begin = format_str.data();
  auto end = begin + format_str.size();
  while (begin != end) {
    // Doing two passes with memchr (one for '{' and another for '}') is up to
    // 2.5x faster than the naive one-pass implementation on big format strings.
    const Char* p = begin;
    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, '{', p))
      return write(begin, end);
    write(begin, p);
    ++p;
    if (p == end) return handler.on_error("invalid format string");
    if (static_cast<char>(*p) == '}') {
      handler.on_arg_id();
      handler.on_replacement_field(p);
    } else if (*p == '{') {
      handler.on_text(p, p + 1);
    } else {
      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
      Char c = p != end ? *p : Char();
      if (c == '}') {
        handler.on_replacement_field(p);
      } else if (c == ':') {
        p = handler.on_format_specs(p + 1, end);
        if (p == end || *p != '}')
          return handler.on_error("unknown format specifier");
      } else {
        return handler.on_error("missing '}' in format string");
      }
    }
    begin = p + 1;
  }
}

template <typename T, typename ParseContext>
FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
    ParseContext& ctx) {
  using char_type = typename ParseContext::char_type;
  using context = buffer_context<char_type>;
  using mapped_type =
      conditional_t<internal::mapped_type_constant<T, context>::value !=
                        type::custom_type,
                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
  auto f = conditional_t<has_formatter<mapped_type, context>::value,
                         formatter<mapped_type, char_type>,
                         internal::fallback_formatter<T, char_type>>();
  return f.parse(ctx);
}

template <typename Char, typename ErrorHandler, typename... Args>
class format_string_checker {
 public:
  explicit FMT_CONSTEXPR format_string_checker(
      basic_string_view<Char> format_str, ErrorHandler eh)
      : arg_id_(-1),
        context_(format_str, eh),
        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}

  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}

  FMT_CONSTEXPR void on_arg_id() {
    arg_id_ = context_.next_arg_id();
    check_arg_id();
  }
  FMT_CONSTEXPR void on_arg_id(int id) {
    arg_id_ = id;
    context_.check_arg_id(id);
    check_arg_id();
  }
  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
    on_error("compile-time checks don't support named arguments");
  }

  FMT_CONSTEXPR void on_replacement_field(const Char*) {}

  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
    advance_to(context_, begin);
    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    context_.on_error(message);
  }

 private:
  using parse_context_type = basic_format_parse_context<Char, ErrorHandler>;
  enum { num_args = sizeof...(Args) };

  FMT_CONSTEXPR void check_arg_id() {
    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
  }

  // Format specifier parsing function.
  using parse_func = const Char* (*)(parse_context_type&);

  int arg_id_;
  parse_context_type context_;
  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
};

template <typename Char, typename ErrorHandler, typename... Args>
FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
                                          ErrorHandler eh = ErrorHandler()) {
  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
  parse_format_string<true>(s, checker);
  return true;
}

template <typename... Args, typename S,
          enable_if_t<(is_compile_string<S>::value), int>>
void check_format_string(S format_str) {
  FMT_CONSTEXPR_DECL bool invalid_format = internal::do_check_format_string<
      typename S::char_type, internal::error_handler,
      remove_const_t<remove_reference_t<Args>>...>(to_string_view(format_str));
  (void)invalid_format;
}

template <template <typename> class Handler, typename Context>
void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
                         Context& ctx) {
  switch (ref.kind) {
  case arg_id_kind::none:
    break;
  case arg_id_kind::index:
    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
                                                ctx.error_handler());
    break;
  case arg_id_kind::name:
    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
                                                ctx.error_handler());
    break;
  }
}

using format_func = void (*)(internal::buffer<char>&, int, string_view);

FMT_API void format_error_code(buffer<char>& out, int error_code,
                               string_view message) FMT_NOEXCEPT;

FMT_API void report_error(format_func func, int error_code,
                          string_view message) FMT_NOEXCEPT;
}  // namespace internal

template <typename Range>
using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
using writer FMT_DEPRECATED_ALIAS = internal::writer;
using wwriter FMT_DEPRECATED_ALIAS =
    internal::basic_writer<buffer_range<wchar_t>>;

/** The default argument formatter. */
template <typename Range>
class arg_formatter : public internal::arg_formatter_base<Range> {
 private:
  using char_type = typename Range::value_type;
  using base = internal::arg_formatter_base<Range>;
  using context_type = basic_format_context<typename base::iterator, char_type>;

  context_type& ctx_;
  basic_format_parse_context<char_type>* parse_ctx_;

 public:
  using range = Range;
  using iterator = typename base::iterator;
  using format_specs = typename base::format_specs;

  /**
    \rst
    Constructs an argument formatter object.
    *ctx* is a reference to the formatting context,
    *specs* contains format specifier information for standard argument types.
    \endrst
   */
  explicit arg_formatter(
      context_type& ctx,
      basic_format_parse_context<char_type>* parse_ctx = nullptr,
      format_specs* specs = nullptr)
      : base(Range(ctx.out()), specs, ctx.locale()),
        ctx_(ctx),
        parse_ctx_(parse_ctx) {}

  using base::operator();

  /** Formats an argument of a user-defined type. */
  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
    handle.format(*parse_ctx_, ctx_);
    return ctx_.out();
  }
};

/**
 An error returned by an operating system or a language runtime,
 for example a file opening error.
*/
FMT_CLASS_API
class FMT_API system_error : public std::runtime_error {
 private:
  void init(int err_code, string_view format_str, format_args args);

 protected:
  int error_code_;

  system_error() : std::runtime_error(""), error_code_(0) {}

 public:
  /**
   \rst
   Constructs a :class:`fmt::system_error` object with a description
   formatted with `fmt::format_system_error`. *message* and additional
   arguments passed into the constructor are formatted similarly to
   `fmt::format`.

   **Example**::

     // This throws a system_error with the description
     //   cannot open file 'madeup': No such file or directory
     // or similar (system message may vary).
     const char *filename = "madeup";
     std::FILE *file = std::fopen(filename, "r");
     if (!file)
       throw fmt::system_error(errno, "cannot open file '{}'", filename);
   \endrst
  */
  template <typename... Args>
  system_error(int error_code, string_view message, const Args&... args)
      : std::runtime_error("") {
    init(error_code, message, make_format_args(args...));
  }
  system_error(const system_error&) = default;
  system_error& operator=(const system_error&) = default;
  system_error(system_error&&) = default;
  system_error& operator=(system_error&&) = default;
  ~system_error() FMT_NOEXCEPT FMT_OVERRIDE;

  int error_code() const { return error_code_; }
};

/**
  \rst
  Formats an error returned by an operating system or a language runtime,
  for example a file opening error, and writes it to *out* in the following
  form:

  .. parsed-literal::
     *<message>*: *<system-message>*

  where *<message>* is the passed message and *<system-message>* is
  the system message corresponding to the error code.
  *error_code* is a system error code as given by ``errno``.
  If *error_code* is not a valid error code such as -1, the system message
  may look like "Unknown error -1" and is platform-dependent.
  \endrst
 */
FMT_API void format_system_error(internal::buffer<char>& out, int error_code,
                                 string_view message) FMT_NOEXCEPT;

// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code,
                                 string_view message) FMT_NOEXCEPT;

/** Fast integer formatter. */
class format_int {
 private:
  // Buffer should be large enough to hold all digits (digits10 + 1),
  // a sign and a null character.
  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
  mutable char buffer_[buffer_size];
  char* str_;

  // Formats value in reverse and returns a pointer to the beginning.
  char* format_decimal(unsigned long long value) {
    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
    while (value >= 100) {
      // Integer division is slow so do it for a group of two digits instead
      // of for every digit. The idea comes from the talk by Alexandrescu
      // "Three Optimization Tips for C++". See speed-test for a comparison.
      auto index = static_cast<unsigned>((value % 100) * 2);
      value /= 100;
      *--ptr = internal::data::digits[index + 1];
      *--ptr = internal::data::digits[index];
    }
    if (value < 10) {
      *--ptr = static_cast<char>('0' + value);
      return ptr;
    }
    auto index = static_cast<unsigned>(value * 2);
    *--ptr = internal::data::digits[index + 1];
    *--ptr = internal::data::digits[index];
    return ptr;
  }

  void format_signed(long long value) {
    auto abs_value = static_cast<unsigned long long>(value);
    bool negative = value < 0;
    if (negative) abs_value = 0 - abs_value;
    str_ = format_decimal(abs_value);
    if (negative) *--str_ = '-';
  }

 public:
  explicit format_int(int value) { format_signed(value); }
  explicit format_int(long value) { format_signed(value); }
  explicit format_int(long long value) { format_signed(value); }
  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
  explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}

  /** Returns the number of characters written to the output buffer. */
  std::size_t size() const {
    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
  }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  const char* data() const { return str_; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  const char* c_str() const {
    buffer_[buffer_size - 1] = '\0';
    return str_;
  }

  /**
    \rst
    Returns the content of the output buffer as an ``std::string``.
    \endrst
   */
  std::string str() const { return std::string(str_, size()); }
};

// A formatter specialization for the core types corresponding to internal::type
// constants.
template <typename T, typename Char>
struct formatter<T, Char,
                 enable_if_t<internal::type_constant<T, Char>::value !=
                             internal::type::custom_type>> {
  FMT_CONSTEXPR formatter() = default;

  // Parses format specifiers stopping either at the end of the range or at the
  // terminating '}'.
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    using handler_type = internal::dynamic_specs_handler<ParseContext>;
    auto type = internal::type_constant<T, Char>::value;
    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                  type);
    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
    auto eh = ctx.error_handler();
    switch (type) {
    case internal::type::none_type:
    case internal::type::named_arg_type:
      FMT_ASSERT(false, "invalid argument type");
      break;
    case internal::type::int_type:
    case internal::type::uint_type:
    case internal::type::long_long_type:
    case internal::type::ulong_long_type:
    case internal::type::int128_type:
    case internal::type::uint128_type:
    case internal::type::bool_type:
      handle_int_type_spec(specs_.type,
                           internal::int_type_checker<decltype(eh)>(eh));
      break;
    case internal::type::char_type:
      handle_char_specs(
          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
      break;
    case internal::type::float_type:
      if (internal::const_check(FMT_USE_FLOAT)) {
        internal::parse_float_type_spec(specs_, eh);
      } else {
        FMT_ASSERT(false, "float support disabled");
      }
      break;
    case internal::type::double_type:
      if (internal::const_check(FMT_USE_DOUBLE)) {
        internal::parse_float_type_spec(specs_, eh);
      } else {
        FMT_ASSERT(false, "double support disabled");
      }
      break;
    case internal::type::long_double_type:
      if (internal::const_check(FMT_USE_LONG_DOUBLE)) {
        internal::parse_float_type_spec(specs_, eh);
      } else {
        FMT_ASSERT(false, "long double support disabled");
      }
      break;
    case internal::type::cstring_type:
      internal::handle_cstring_type_spec(
          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
      break;
    case internal::type::string_type:
      internal::check_string_type_spec(specs_.type, eh);
      break;
    case internal::type::pointer_type:
      internal::check_pointer_type_spec(specs_.type, eh);
      break;
    case internal::type::custom_type:
      // Custom format specifiers should be checked in parse functions of
      // formatter specializations.
      break;
    }
    return it;
  }

  template <typename FormatContext>
  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
    internal::handle_dynamic_spec<internal::width_checker>(
        specs_.width, specs_.width_ref, ctx);
    internal::handle_dynamic_spec<internal::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    using range_type =
        internal::output_range<typename FormatContext::iterator,
                               typename FormatContext::char_type>;
    return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
                            internal::make_arg<FormatContext>(val));
  }

 private:
  internal::dynamic_format_specs<Char> specs_;
};

#define FMT_FORMAT_AS(Type, Base)                                             \
  template <typename Char>                                                    \
  struct formatter<Type, Char> : formatter<Base, Char> {                      \
    template <typename FormatContext>                                         \
    auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
      return formatter<Base, Char>::format(val, ctx);                         \
    }                                                                         \
  }

FMT_FORMAT_AS(signed char, int);
FMT_FORMAT_AS(unsigned char, unsigned);
FMT_FORMAT_AS(short, int);
FMT_FORMAT_AS(unsigned short, unsigned);
FMT_FORMAT_AS(long, long long);
FMT_FORMAT_AS(unsigned long, unsigned long long);
FMT_FORMAT_AS(Char*, const Char*);
FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
FMT_FORMAT_AS(std::nullptr_t, const void*);
FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);

template <typename Char>
struct formatter<void*, Char> : formatter<const void*, Char> {
  template <typename FormatContext>
  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
    return formatter<const void*, Char>::format(val, ctx);
  }
};

template <typename Char, size_t N>
struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
  template <typename FormatContext>
  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
  }
};

// A formatter for types known only at run time such as variant alternatives.
//
// Usage:
//   using variant = std::variant<int, std::string>;
//   template <>
//   struct formatter<variant>: dynamic_formatter<> {
//     void format(buffer &buf, const variant &v, context &ctx) {
//       visit([&](const auto &val) { format(buf, val, ctx); }, v);
//     }
//   };
template <typename Char = char> class dynamic_formatter {
 private:
  struct null_handler : internal::error_handler {
    void on_align(align_t) {}
    void on_plus() {}
    void on_minus() {}
    void on_space() {}
    void on_hash() {}
  };

 public:
  template <typename ParseContext>
  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    format_str_ = ctx.begin();
    // Checks are deferred to formatting time when the argument type is known.
    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
    return parse_format_specs(ctx.begin(), ctx.end(), handler);
  }

  template <typename T, typename FormatContext>
  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
    handle_specs(ctx);
    internal::specs_checker<null_handler> checker(
        null_handler(),
        internal::mapped_type_constant<T, FormatContext>::value);
    checker.on_align(specs_.align);
    switch (specs_.sign) {
    case sign::none:
      break;
    case sign::plus:
      checker.on_plus();
      break;
    case sign::minus:
      checker.on_minus();
      break;
    case sign::space:
      checker.on_space();
      break;
    }
    if (specs_.alt) checker.on_hash();
    if (specs_.precision >= 0) checker.end_precision();
    using range = internal::output_range<typename FormatContext::iterator,
                                         typename FormatContext::char_type>;
    visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
                     internal::make_arg<FormatContext>(val));
    return ctx.out();
  }

 private:
  template <typename Context> void handle_specs(Context& ctx) {
    internal::handle_dynamic_spec<internal::width_checker>(
        specs_.width, specs_.width_ref, ctx);
    internal::handle_dynamic_spec<internal::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
  }

  internal::dynamic_format_specs<Char> specs_;
  const Char* format_str_;
};

template <typename Range, typename Char>
typename basic_format_context<Range, Char>::format_arg
basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
  map_.init(args_);
  format_arg arg = map_.find(name);
  if (arg.type() == internal::type::none_type)
    this->on_error("argument not found");
  return arg;
}

template <typename Char, typename ErrorHandler>
FMT_CONSTEXPR void advance_to(
    basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
  ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
}

template <typename ArgFormatter, typename Char, typename Context>
struct format_handler : internal::error_handler {
  using range = typename ArgFormatter::range;

  format_handler(range r, basic_string_view<Char> str,
                 basic_format_args<Context> format_args,
                 internal::locale_ref loc)
      : parse_context(str), context(r.begin(), format_args, loc) {}

  void on_text(const Char* begin, const Char* end) {
    auto size = internal::to_unsigned(end - begin);
    auto out = context.out();
    auto&& it = internal::reserve(out, size);
    it = std::copy_n(begin, size, it);
    context.advance_to(out);
  }

  void get_arg(int id) { arg = internal::get_arg(context, id); }

  void on_arg_id() { get_arg(parse_context.next_arg_id()); }
  void on_arg_id(int id) {
    parse_context.check_arg_id(id);
    get_arg(id);
  }
  void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }

  void on_replacement_field(const Char* p) {
    advance_to(parse_context, p);
    context.advance_to(
        visit_format_arg(ArgFormatter(context, &parse_context), arg));
  }

  const Char* on_format_specs(const Char* begin, const Char* end) {
    advance_to(parse_context, begin);
    internal::custom_formatter<Context> f(parse_context, context);
    if (visit_format_arg(f, arg)) return parse_context.begin();
    basic_format_specs<Char> specs;
    using internal::specs_handler;
    using parse_context_t = basic_format_parse_context<Char>;
    internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
        specs_handler<parse_context_t, Context>(specs, parse_context, context),
        arg.type());
    begin = parse_format_specs(begin, end, handler);
    if (begin == end || *begin != '}') on_error("missing '}' in format string");
    advance_to(parse_context, begin);
    context.advance_to(
        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
    return begin;
  }

  basic_format_parse_context<Char> parse_context;
  Context context;
  basic_format_arg<Context> arg;
};

/** Formats arguments and writes the output to the range. */
template <typename ArgFormatter, typename Char, typename Context>
typename Context::iterator vformat_to(
    typename ArgFormatter::range out, basic_string_view<Char> format_str,
    basic_format_args<Context> args,
    internal::locale_ref loc = internal::locale_ref()) {
  format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
  internal::parse_format_string<false>(format_str, h);
  return h.context.out();
}

// Casts ``p`` to ``const void*`` for pointer formatting.
// Example:
//   auto s = format("{}", ptr(p));
template <typename T> inline const void* ptr(const T* p) { return p; }
template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
  return p.get();
}
template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
  return p.get();
}

class bytes {
 private:
  string_view data_;
  friend struct formatter<bytes>;

 public:
  explicit bytes(string_view data) : data_(data) {}
};

template <> struct formatter<bytes> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    using handler_type = internal::dynamic_specs_handler<ParseContext>;
    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                  internal::type::string_type);
    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
    internal::check_string_type_spec(specs_.type, ctx.error_handler());
    return it;
  }

  template <typename FormatContext>
  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
    internal::handle_dynamic_spec<internal::width_checker>(
        specs_.width, specs_.width_ref, ctx);
    internal::handle_dynamic_spec<internal::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    using range_type =
        internal::output_range<typename FormatContext::iterator, char>;
    internal::basic_writer<range_type> writer(range_type(ctx.out()));
    writer.write_bytes(b.data_, specs_);
    return writer.out();
  }

 private:
  internal::dynamic_format_specs<char> specs_;
};

template <typename It, typename Char> struct arg_join : internal::view {
  It begin;
  It end;
  basic_string_view<Char> sep;

  arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
};

template <typename It, typename Char>
struct formatter<arg_join<It, Char>, Char>
    : formatter<typename std::iterator_traits<It>::value_type, Char> {
  template <typename FormatContext>
  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
      -> decltype(ctx.out()) {
    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
    auto it = value.begin;
    auto out = ctx.out();
    if (it != value.end) {
      out = base::format(*it++, ctx);
      while (it != value.end) {
        out = std::copy(value.sep.begin(), value.sep.end(), out);
        ctx.advance_to(out);
        out = base::format(*it++, ctx);
      }
    }
    return out;
  }
};

/**
  Returns an object that formats the iterator range `[begin, end)` with elements
  separated by `sep`.
 */
template <typename It>
arg_join<It, char> join(It begin, It end, string_view sep) {
  return {begin, end, sep};
}

template <typename It>
arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
  return {begin, end, sep};
}

/**
  \rst
  Returns an object that formats `range` with elements separated by `sep`.

  **Example**::

    std::vector<int> v = {1, 2, 3};
    fmt::print("{}", fmt::join(v, ", "));
    // Output: "1, 2, 3"

  ``fmt::join`` applies passed format specifiers to the range elements::

    fmt::print("{:02}", fmt::join(v, ", "));
    // Output: "01, 02, 03"
  \endrst
 */
template <typename Range>
arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
                                                       string_view sep) {
  return join(std::begin(range), std::end(range), sep);
}

template <typename Range>
arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
                                                          wstring_view sep) {
  return join(std::begin(range), std::end(range), sep);
}

/**
  \rst
  Converts *value* to ``std::string`` using the default format for type *T*.

  **Example**::

    #include <fmt/format.h>

    std::string answer = fmt::to_string(42);
  \endrst
 */
template <typename T> inline std::string to_string(const T& value) {
  return format("{}", value);
}

/**
  Converts *value* to ``std::wstring`` using the default format for type *T*.
 */
template <typename T> inline std::wstring to_wstring(const T& value) {
  return format(L"{}", value);
}

template <typename Char, std::size_t SIZE>
std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
  return std::basic_string<Char>(buf.data(), buf.size());
}

template <typename Char>
typename buffer_context<Char>::iterator internal::vformat_to(
    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  using range = buffer_range<Char>;
  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
                                          args);
}

template <typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(internal::is_string<S>::value)>
inline typename buffer_context<Char>::iterator vformat_to(
    internal::buffer<Char>& buf, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  return internal::vformat_to(buf, to_string_view(format_str), args);
}

template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
inline typename buffer_context<Char>::iterator format_to(
    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
  internal::check_format_string<Args...>(format_str);
  using context = buffer_context<Char>;
  return internal::vformat_to(buf, to_string_view(format_str),
                              make_format_args<context>(args...));
}

template <typename OutputIt, typename Char = char>
using format_context_t = basic_format_context<OutputIt, Char>;

template <typename OutputIt, typename Char = char>
using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;

template <typename S, typename OutputIt, typename... Args,
          FMT_ENABLE_IF(
              internal::is_output_iterator<OutputIt>::value &&
              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
inline OutputIt vformat_to(
    OutputIt out, const S& format_str,
    format_args_t<type_identity_t<OutputIt>, char_t<S>> args) {
  using range = internal::output_range<OutputIt, char_t<S>>;
  return vformat_to<arg_formatter<range>>(range(out),
                                          to_string_view(format_str), args);
}

/**
 \rst
 Formats arguments, writes the result to the output iterator ``out`` and returns
 the iterator past the end of the output range.

 **Example**::

   std::vector<char> out;
   fmt::format_to(std::back_inserter(out), "{}", 42);
 \endrst
 */
template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(
              internal::is_output_iterator<OutputIt>::value &&
              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
              internal::is_string<S>::value)>
inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
  internal::check_format_string<Args...>(format_str);
  using context = format_context_t<OutputIt, char_t<S>>;
  return vformat_to(out, to_string_view(format_str),
                    make_format_args<context>(args...));
}

template <typename OutputIt> struct format_to_n_result {
  /** Iterator past the end of the output range. */
  OutputIt out;
  /** Total (not truncated) output size. */
  std::size_t size;
};

template <typename OutputIt, typename Char = typename OutputIt::value_type>
using format_to_n_context =
    format_context_t<internal::truncating_iterator<OutputIt>, Char>;

template <typename OutputIt, typename Char = typename OutputIt::value_type>
using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;

template <typename OutputIt, typename Char, typename... Args>
inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
make_format_to_n_args(const Args&... args) {
  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
      args...);
}

template <typename OutputIt, typename Char, typename... Args,
          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
inline format_to_n_result<OutputIt> vformat_to_n(
    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
    format_to_n_args<type_identity_t<OutputIt>, type_identity_t<Char>> args) {
  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
                       format_str, args);
  return {it.base(), it.count()};
}

/**
 \rst
 Formats arguments, writes up to ``n`` characters of the result to the output
 iterator ``out`` and returns the total output size and the iterator past the
 end of the output range.
 \endrst
 */
template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(internal::is_string<S>::value&&
                            internal::is_output_iterator<OutputIt>::value)>
inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
                                                const S& format_str,
                                                const Args&... args) {
  internal::check_format_string<Args...>(format_str);
  using context = format_to_n_context<OutputIt, char_t<S>>;
  return vformat_to_n(out, n, to_string_view(format_str),
                      make_format_args<context>(args...));
}

template <typename Char>
inline std::basic_string<Char> internal::vformat(
    basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buffer;
  internal::vformat_to(buffer, format_str, args);
  return to_string(buffer);
}

/**
  Returns the number of characters in the output of
  ``format(format_str, args...)``.
 */
template <typename... Args>
inline std::size_t formatted_size(string_view format_str, const Args&... args) {
  return format_to(internal::counting_iterator(), format_str, args...).count();
}

template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
void vprint(std::FILE* f, basic_string_view<Char> format_str,
            wformat_args args) {
  wmemory_buffer buffer;
  internal::vformat_to(buffer, format_str, args);
  buffer.push_back(L'\0');
  if (std::fputws(buffer.data(), f) == -1)
    FMT_THROW(system_error(errno, "cannot write to file"));
}

template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
void vprint(basic_string_view<Char> format_str, wformat_args args) {
  vprint(stdout, format_str, args);
}

#if FMT_USE_USER_DEFINED_LITERALS
namespace internal {

#  if FMT_USE_UDL_TEMPLATE
template <typename Char, Char... CHARS> class udl_formatter {
 public:
  template <typename... Args>
  std::basic_string<Char> operator()(Args&&... args) const {
    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
    FMT_CONSTEXPR_DECL bool invalid_format =
        do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
            basic_string_view<Char>(s, sizeof...(CHARS)));
    (void)invalid_format;
    return format(s, std::forward<Args>(args)...);
  }
};
#  else
template <typename Char> struct udl_formatter {
  basic_string_view<Char> str;

  template <typename... Args>
  std::basic_string<Char> operator()(Args&&... args) const {
    return format(str, std::forward<Args>(args)...);
  }
};
#  endif  // FMT_USE_UDL_TEMPLATE

template <typename Char> struct udl_arg {
  basic_string_view<Char> str;

  template <typename T> named_arg<T, Char> operator=(T&& value) const {
    return {str, std::forward<T>(value)};
  }
};

// Converts string literals to basic_string_view.
template <typename Char, size_t N>
FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
    const Char (&s)[N]) {
  // Remove trailing null character if needed. Won't be present if this is used
  // with raw character array (i.e. not defined as a string).
  return {s,
          N - ((std::char_traits<Char>::to_int_type(s[N - 1]) == 0) ? 1 : 0)};
}

// Converts string_view to basic_string_view.
template <typename Char>
FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
    const std_string_view<Char>& s) {
  return {s.data(), s.size()};
}
}  // namespace internal

inline namespace literals {
#  if FMT_USE_UDL_TEMPLATE
#    pragma GCC diagnostic push
#    if FMT_CLANG_VERSION
#      pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
#    endif
template <typename Char, Char... CHARS>
FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
  return {};
}
#    pragma GCC diagnostic pop
#  else
/**
  \rst
  User-defined literal equivalent of :func:`fmt::format`.

  **Example**::

    using namespace fmt::literals;
    std::string message = "The answer is {}"_format(42);
  \endrst
 */
FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
                                                               std::size_t n) {
  return {{s, n}};
}
FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
    const wchar_t* s, std::size_t n) {
  return {{s, n}};
}
#  endif  // FMT_USE_UDL_TEMPLATE

/**
  \rst
  User-defined literal equivalent of :func:`fmt::arg`.

  **Example**::

    using namespace fmt::literals;
    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
  \endrst
 */
FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
                                                    std::size_t n) {
  return {{s, n}};
}
FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
                                                       std::size_t n) {
  return {{s, n}};
}
}  // namespace literals
#endif  // FMT_USE_USER_DEFINED_LITERALS
FMT_END_NAMESPACE

#define FMT_STRING_IMPL(s, ...)                                     \
  [] {                                                              \
    /* Use a macro-like name to avoid shadowing warnings. */        \
    struct FMT_COMPILE_STRING : fmt::compile_string {               \
      using char_type = fmt::remove_cvref_t<decltype(s[0])>;        \
      FMT_MAYBE_UNUSED __VA_ARGS__ FMT_CONSTEXPR                    \
      operator fmt::basic_string_view<char_type>() const {          \
        return fmt::internal::compile_string_to_view<char_type>(s); \
      }                                                             \
    };                                                              \
    return FMT_COMPILE_STRING();                                    \
  }()

/**
  \rst
  Constructs a compile-time format string from a string literal *s*.

  **Example**::

    // A compile-time error because 'd' is an invalid specifier for strings.
    std::string s = format(FMT_STRING("{:d}"), "foo");
  \endrst
 */
#define FMT_STRING(s) FMT_STRING_IMPL(s, )

#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
#  define fmt(s) FMT_STRING_IMPL(s, [[deprecated]])
#endif

#ifdef FMT_HEADER_ONLY
#  define FMT_FUNC inline
#  include "format-inl.h"
#else
#  define FMT_FUNC
#endif

#endif  // FMT_FORMAT_H_


================================================
FILE: examples/lesson04/fig04_12/format.cc
================================================
// Formatting library for C++
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/format-inl.h"

FMT_BEGIN_NAMESPACE
namespace internal {

template <typename T>
int format_float(char* buf, std::size_t size, const char* format, int precision,
                 T value) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  if (precision > 100000)
    throw std::runtime_error(
        "fuzz mode - avoid large allocation inside snprintf");
#endif
  // Suppress the warning about nonliteral format string.
  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
  return precision < 0 ? snprintf_ptr(buf, size, format, value)
                       : snprintf_ptr(buf, size, format, precision, value);
}
struct sprintf_specs {
  int precision;
  char type;
  bool alt : 1;

  template <typename Char>
  constexpr sprintf_specs(basic_format_specs<Char> specs)
      : precision(specs.precision), type(specs.type), alt(specs.alt) {}

  constexpr bool has_precision() const { return precision >= 0; }
};

// This is deprecated and is kept only to preserve ABI compatibility.
template <typename Double>
char* sprintf_format(Double value, internal::buffer<char>& buf,
                     sprintf_specs specs) {
  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
  FMT_ASSERT(buf.capacity() != 0, "empty buffer");

  // Build format string.
  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
  char format[max_format_size];
  char* format_ptr = format;
  *format_ptr++ = '%';
  if (specs.alt || !specs.type) *format_ptr++ = '#';
  if (specs.precision >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }
  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';

  char type = specs.type;

  if (type == '%')
    type = 'f';
  else if (type == 0 || type == 'n')
    type = 'g';
#if FMT_MSC_VER
  if (type == 'F') {
    // MSVC's printf doesn't support 'F'.
    type = 'f';
  }
#endif
  *format_ptr++ = type;
  *format_ptr = '\0';

  // Format using snprintf.
  char* start = nullptr;
  char* decimal_point_pos = nullptr;
  for (;;) {
    std::size_t buffer_size = buf.capacity();
    start = &buf[0];
    int result =
        format_float(start, buffer_size, format, specs.precision, value);
    if (result >= 0) {
      unsigned n = internal::to_unsigned(result);
      if (n < buf.capacity()) {
        // Find the decimal point.
        auto p = buf.data(), end = p + n;
        if (*p == '+' || *p == '-') ++p;
        if (specs.type != 'a' && specs.type != 'A') {
          while (p < end && *p >= '0' && *p <= '9') ++p;
          if (p < end && *p != 'e' && *p != 'E') {
            decimal_point_pos = p;
            if (!specs.type) {
              // Keep only one trailing zero after the decimal point.
              ++p;
              if (*p == '0') ++p;
              while (p != end && *p >= '1' && *p <= '9') ++p;
              char* where = p;
              while (p != end && *p == '0') ++p;
              if (p == end || *p < '0' || *p > '9') {
                if (p != end) std::memmove(where, p, to_unsigned(end - p));
                n -= static_cast<unsigned>(p - where);
              }
            }
          }
        }
        buf.resize(n);
        break;  // The buffer is large enough - continue with formatting.
      }
      buf.reserve(n + 1);
    } else {
      // If result is negative we ask to increase the capacity by at least 1,
      // but as std::vector, the buffer grows exponentially.
      buf.reserve(buf.capacity() + 1);
    }
  }
  return decimal_point_pos;
}
}  // namespace internal

template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&,
                                                sprintf_specs);
template FMT_API char* internal::sprintf_format(long double,
                                                internal::buffer<char>&,
                                                sprintf_specs);

template struct FMT_INSTANTIATION_DEF_API internal::basic_data<void>;

// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
int (*instantiate_format_float)(double, int, internal::float_specs,
                                internal::buffer<char>&) =
    internal::format_float;

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
#endif

// Explicit instantiations for char.

template FMT_API std::string internal::grouping_impl<char>(locale_ref);
template FMT_API char internal::thousands_sep_impl(locale_ref);
template FMT_API char internal::decimal_point_impl(locale_ref);

template FMT_API void internal::buffer<char>::append(const char*, const char*);

template FMT_API void internal::arg_map<format_context>::init(
    const basic_format_args<format_context>& args);

template FMT_API std::string internal::vformat<char>(
    string_view, basic_format_args<format_context>);

template FMT_API format_context::iterator internal::vformat_to(
    internal::buffer<char>&, string_view, basic_format_args<format_context>);

template FMT_API int internal::snprintf_float(double, int,
                                              internal::float_specs,
                                              internal::buffer<char>&);
template FMT_API int internal::snprintf_float(long double, int,
                                              internal::float_specs,
                                              internal::buffer<char>&);
template FMT_API int internal::format_float(double, int, internal::float_specs,
                                            internal::buffer<char>&);
template FMT_API int internal::format_float(long double, int,
                                            internal::float_specs,
                                            internal::buffer<char>&);

// Explicit instantiations for wchar_t.

template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
template FMT_API wchar_t internal::decimal_point_impl(locale_ref);

template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*,
                                                        const wchar_t*);

template FMT_API std::wstring internal::vformat<wchar_t>(
    wstring_view, basic_format_args<wformat_context>);
FMT_END_NAMESPACE


================================================
FILE: examples/lesson04/fig04_17.cpp
================================================
// fig04_17.cpp
// Compound-interest example with boost::multiprecision::cpp_dec_float_50. 
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <format> 
#include <iostream>
#include "decimalformatter.h" 

using namespace std;
using boost::multiprecision::cpp_dec_float_50;

int main() {
   cpp_dec_float_50 principal{1000}; // $1000 initial principal
   cpp_dec_float_50 rate{"0.05"}; // 5% interest rate
 
   cout << format("Initial principal: {:>7}\n", principal)
        << format("    Interest rate: {:>7}\n\n", rate);

   // display headers
   cout << format("{}{:>20}\n", "Year", "Amount on deposit");

   // calculate amount on deposit for each of 10 years
   for (int year{1}; year <= 10; ++year) {
      cpp_dec_float_50 amount{principal * pow(1 + rate, year)};
      cout << format("{:>4}{:>20}\n", year, amount);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson04/fig04_17fmt.cpp
================================================
// fig04_17.cpp
// Compound-interest example with boost::multiprecision::cpp_dec_float_50. 
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <fmt/format.h> // in C++20, this will be #include <format>
#include <iostream>
#include "decimalformatter_fmt.h" 

using namespace std;
using boost::multiprecision::cpp_dec_float_50;

int main() {
   cpp_dec_float_50 principal{1000}; // $1000 initial principal
   cpp_dec_float_50 rate{"0.05"}; // 5% interest rate
 
   cout << fmt::format("Initial principal: {:>7}\n", principal)
      << fmt::format("    Interest rate: {:>7}\n\n", rate);

   // display headers
   cout << fmt::format("{}{:>20}\n", "Year", "Amount on deposit");

   // calculate amount on deposit for each of 10 years
   for (int year{1}; year <= 10; ++year) {
      cpp_dec_float_50 amount{principal * pow(1 + rate, year)};
      cout << fmt::format("{:>4}{:>20}\n", year, amount);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/cipher.h
================================================
// Fig. 9.37: cipher.h
// Vigenre cipher implementation. 
#pragma once
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <string_view>
#include <cctype>
#include <stdexcept>

class Cipher {
public:
   // constructor to initialize the Vigenre square 
   Cipher() {
      // array to store the 26 characters A-Z that will be 
      // used to initialize each row of the Vigenre square
      std::array<char, m_size> alphabet{};

      // fill alphabet with A-Z
      for (size_t i{0}; i < m_size; ++i) {
         // convert 'A' + i to a char and place in alphabet
         alphabet.at(i) = static_cast<char>('A' + i);
      }

      // copy alphabet into row 0 of the Vigenre square
      m_square.at(0) = alphabet;

      // for each remaining row of the Vigenre square, move alphabet's
      // first letter to the end then copy alphabet into the row
      for (int row{1}; row < m_size; ++row) {
         // rotate alphabet, moving its first letter to the end
         std::ranges::rotate(alphabet, std::begin(alphabet) + 1);

         // copy alphabet into current row of the Vigenre square
         m_square.at(row) = alphabet;
      }
   }

   // encrypt receives the plaintext and secret key, applies 
   // the Vigenre cipher returns the encrypted ciphertext
   std::string encrypt(
      std::string_view plaintext, std::string_view secret) {

      checkKey(secret); // ensure secret key contains only letters

      std::string ciphertext{}; // stores encrypted text
      size_t keyIndex{0}; // current letter index in secret key

      // iterate through each character in plaintext
      for (size_t i{0}; i < plaintext.length(); ++i) {
         // determine whether character at i is lowercase so we can 
         // place a corresponding lowercase letter in the ciphertext
         const bool lower{std::islower(plaintext.at(i)) ? true : false};

         // convert currentChar to uppercase; for uppercase 
         // letters and non-letters the character remains the same
         const char currentChar{static_cast<const char>(
            std::toupper(plaintext.at(i)))};

         // if the current character is a letter, encrypt it  
         // and add it to cipherText in its original case
         if ('A' <= currentChar && currentChar <= 'Z') {
            // to get the row index in the Vigenre square, select the 
            // character at keyIndex in the secret key, convert it to 
            // uppercase and subtract 'A' from it
            const int row{std::toupper(secret.at(keyIndex)) - 'A'};

            // increment the keyIndex, ensuring that it is  
            // reset to 0 if keyIndex reaches secret.length()
            keyIndex = (keyIndex + 1) % secret.length();

            // to get the column index in the Vigenre square,  
            // subtract 'A' from the currentChar
            const int column{currentChar - 'A'};

            // select the substitute character from the Vigenre square
            const char substituteChar{m_square.at(row).at(column)};

            // add substituteChar to the ciphertext, ensuring that
            // it's lowercase if the plaintext character was lowerase
            ciphertext +=
               (lower ? std::tolower(substituteChar) : substituteChar);
         }
         else {
            ciphertext += currentChar; // add non-letter to ciphertext
         }
      }

      return ciphertext; // return the encrypted text
   }

   // decrypt receives the ciphertext and secret key, reverses
   // Vigenre cipher process and returns the unencrypted plaintext
   std::string decrypt(
      std::string_view ciphertext, std::string_view secret) {

      checkKey(secret); // ensure secret key contains only letters

      std::string plaintext{}; // stores unencrypted text
      size_t keyIndex{0}; // current letter index in secret key

      for (size_t i{0}; i < ciphertext.length(); ++i) {
         // determine whether character at i is lowercase so we can 
         // place a corresponding lowercase letter in plainText
         const bool lower{std::islower(ciphertext.at(i)) ? true : false};

         // convert currentChar to uppercase; for uppercase 
         // letters and non-letters the character remains the same
         const char currentChar{static_cast<const char>(
            std::toupper(ciphertext.at(i)))};

         // if current is a letter decrypt it
         if ('A' <= currentChar && currentChar <= 'Z') {
            // to get the row index in the Vigenre square, select the 
            // character at keyIndex in the secret key, convert it to 
            // uppercase and subtract 'A' from it
            const int row{std::toupper(secret.at(keyIndex)) - 'A'};

            // increment the keyIndex, ensuring that it is  
            // reset to 0 if keyIndex reaches secret.length()
            keyIndex = (keyIndex + 1) % secret.length();

            // column in the Vigenre square
            int column{-1};

            // find currentChar's column in Vigenre square's current row
            for (int i{0}; i < m_square.at(row).size(); ++i) {
               if (m_square.at(row).at(i) == currentChar) {
                  column = i;
                  break;
               }
            }

            // determine original character  
            const char originalChar{
               static_cast<const char>('A' + column)};

            // add originalChar to plaintext in the correct case
            plaintext +=
               (lower ? std::tolower(originalChar) : originalChar);
         }
         else {
            plaintext += currentChar; // add non-letter to plaintext
         }
      }

      return plaintext; // return the unencrypted text
   }
private:
   // number of rows and columns in the Vigenre square
   static constexpr size_t m_size{26};

   // 26-by-26 array of characters to store the Vigenre square
   std::array<std::array<char, m_size>, m_size> m_square;

   // utility function checks that secret key contains only letters; 
   // throws an invalid_argument exception if key contains non-letters
   static void checkKey(std::string_view secret) {
      for (size_t i{0}; i < secret.size(); ++i) {
         // if the uppercase version of the character at index i 
         // is not a letter throw an invalid_argument exception
         if (std::toupper(secret.at(i)) < 'A' ||
            std::toupper(secret.at(i)) > 'Z') {
            throw std::invalid_argument(
               "key must contain only letters A-Z or a-z");
         }
      }
   }
};

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/ex05_31.cpp
================================================
// ex05_31.cpp
// What does this program do?
#include <iostream>
using namespace std;

int mystery(int, int); // function prototype
      
int main() {
   cout << "Enter two integers: ";
   int x{0};
   int y{0};
   cin >> x >> y;
   cout << "The result is " << mystery(x, y) << endl;
} 
   
// Parameter b must be a positive integer to prevent infinite recursion
int mystery(int a, int b) {
   if (1 == b) { // base case
      return a;
   } 
   else { // recursion step
      return a + mystery(a, b - 1);
   } 
} 


/*************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
*************************************************************************/


================================================
FILE: examples/lesson05/fig05_01.cpp
================================================
// fig05_01.cpp
// maximum function with a function prototype.
#include <iostream>

using namespace std;

int maximum(int x, int y, int z); // function prototype 

int main() {
   cout << "Enter three integer values: ";
   int int1, int2, int3;
   cin >> int1 >> int2 >> int3;

   // invoke maximum 
   cout << "The maximum integer value is: " 
      << maximum(int1, int2, int3) << '\n';
}

// returns the largest of three integers   
int maximum(int x, int y, int z) {
   int maximumValue{x}; // assume x is the largest to start

   // determine whether y is greater than maximumValue
   if (y > maximumValue) {
      maximumValue = y; // make y the new maximumValue
   }

   // determine whether z is greater than maximumValue
   if (z > maximumValue) {
      maximumValue = z; // make z the new maximumValue
   }

   return maximumValue;
}


/*************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
*************************************************************************/


================================================
FILE: examples/lesson05/fig05_02.cpp
================================================
// fig05_02.cpp
// Producing random integers in the range 1 through 6.
#include <iostream>
#include <random> // contains random-number generation features 
using namespace std;

int main() {
   // engine that produces random numbers 
   default_random_engine engine{};

   // distribution that produces the int values 1-6 with equal likelihood
   uniform_int_distribution randomDie{1, 6};

   // display 10 random die rolls
   for (int counter{1}; counter <= 10; ++counter) {
      cout << randomDie(engine) << " "; 
   } 

   cout << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_03.cpp
================================================
// fig05_03.cpp
// Rolling a six-sided die randomly 60,000,000 times.
#include <format>
#include <iostream>
#include <random> 
using namespace std;

int main() {
   // set up random-number generation
   default_random_engine engine{};
   uniform_int_distribution randomDie{1, 6};

   int frequency1{0}; // count of 1s rolled
   int frequency2{0}; // count of 2s rolled
   int frequency3{0}; // count of 3s rolled 
   int frequency4{0}; // count of 4s rolled
   int frequency5{0}; // count of 5s rolled
   int frequency6{0}; // count of 6s rolled

   // summarize results of 60,000,000 rolls of a die
   for (int roll{1}; roll <= 60'000'000; ++roll) {
      // determine roll value 1-6 and increment appropriate counter
      switch (const int face{randomDie(engine)}) {
         case 1:          
            ++frequency1; // increment the 1s counter
            break;
         case 2:          
            ++frequency2; // increment the 2s counter
            break;
         case 3:          
            ++frequency3; // increment the 3s counter
            break;
         case 4:         
            ++frequency4; // increment the 4s counter
            break;
         case 5:          
            ++frequency5; // increment the 5s counter
            break;
         case 6:         
            ++frequency6; // increment the 6s counter
            break;
         default: // invalid value
            cout << "Program should never get here!";
            break;
      } 
   } 

   cout << format("{:>4}{:>13}\n", "Face", "Frequency"); // headers
   cout << format("{:>4d}{:>13d}\n", 1, frequency1)
      << format("{:>4d}{:>13d}\n", 2, frequency2)
      << format("{:>4d}{:>13d}\n", 3, frequency3)
      << format("{:>4d}{:>13d}\n", 4, frequency4)
      << format("{:>4d}{:>13d}\n", 5, frequency5)
      << format("{:>4d}{:>13d}\n", 6, frequency6);
} 




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_04.cpp
================================================
// fig05_04.cpp
// Randomizing the die-rolling program.
#include <iostream>
#include <random>

using namespace std;

int main() {
   unsigned int seed{0}; // stores the seed entered by the user

   cout << "Enter seed: ";
   cin >> seed;

   // set up random-number generation
   default_random_engine engine{seed}; // seed the engine
   uniform_int_distribution randomDie{1, 6};

   // display 10 random die rolls
   for (int counter{1}; counter <= 10; ++counter) {
      cout << randomDie(engine) << " ";
   } 

   cout << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_05.cpp
================================================
// fig05_05.cpp
// Craps simulation.
#include <format>
#include <iostream>
#include <random> 
using namespace std;

int rollDice(); // rolls dice, calculates and displays sum 

int main() {
   // scoped enumeration with constants that represent the game status
   enum class Status {keepRolling, won, lost};   
   
   int myPoint{0}; // point if no win or loss on first roll
   Status gameStatus{Status::keepRolling}; // game is not over 

   // determine game status and point (if needed) based on first roll
   switch (const int sumOfDice{rollDice()}) {
      case 7: // win with 7 on first roll
      case 11: // win with 11 on first roll           
         gameStatus = Status::won;
         break;
      case 2: // lose with 2 on first roll
      case 3: // lose with 3 on first roll
      case 12: // lose with 12 on first roll             
         gameStatus = Status::lost;
         break;
      default: // did not win or lose, so remember point
         myPoint = sumOfDice; // remember the point
         cout << format("Point is {}\n", myPoint);
         break; // optional (but recommended) at end of switch  
   }

   // while game is not complete
   while (Status::keepRolling == gameStatus) { // not won or lost
      // roll dice again and determine game status
      if (const int sumOfDice{rollDice()}; sumOfDice == myPoint) {
         gameStatus = Status::won;
      }
      else if (sumOfDice == 7) { // lose by rolling 7 before point
         gameStatus = Status::lost;
      }
   }

   // display won or lost message
   if (Status::won == gameStatus) {
      cout << "Player wins\n";
   }
   else {
      cout << "Player loses\n";
   }
}

// roll dice, calculate sum and display results
int rollDice() {
   // set up random-number generation
   static random_device rd; // used to seed the default_random_engine
   static default_random_engine engine{rd()}; // rd() produces a seed 
   static uniform_int_distribution randomDie{1, 6};

   const int die1{randomDie(engine)}; // first die roll
   const int die2{randomDie(engine)}; // second die roll
   const int sum{die1 + die2}; // compute sum of die values

   // display results of this roll
   cout << format("Player rolled {} + {} = {}\n", die1, die2, sum);

   return sum;
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_06.cpp
================================================
// fig05_06.cpp
// square function used to demonstrate the function 
// call stack and activation records.
#include <iostream>
using namespace std;

int square(int); // prototype for function square

int main() {
   int a{10}; // value to square (local variable in main)

   int result{square(a)}; // calculate s squared and store in result
} 

// returns the square of an integer
int square(int x) { // x is a local variable
   return x * x; // calculate square and return result
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_07.cpp
================================================
// fig05_07.cpp
// inline function that calculates the volume of a cube.
#include <iostream> 
using namespace std;

// Definition of inline function cube. Definition of function appears 
// before function is called, so a function prototype is not required. 
// First line of function definition also acts as the prototype.
inline double cube(double side) {               
   return side * side * side; // calculate cube 
}                                               

int main() {
   double sideValue; // stores value entered by user 
   cout << "Enter the side length of your cube: ";
   cin >> sideValue; // read value from user

   // calculate cube of sideValue and display result
   cout << "Volume of cube with side " 
      << sideValue << " is " << cube(sideValue) << '\n';
} 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_08.cpp
================================================
// fig05_08.cpp
// Passing arguments by value and by reference.
#include <iostream>
using namespace std;

int squareByValue(int number); // prototype (for value pass)             
void squareByReference(int& numberRef); // prototype (for reference pass)
   
int main() {
   int x{2}; // value to square using squareByValue
   int z{4}; // value to square using squareByReference

   // demonstrate squareByValue
   cout << "x = " << x << " before squareByValue\n";
   cout << "Value returned by squareByValue: " 
      << squareByValue(x) << '\n';  
   cout << "x = " << x << " after squareByValue\n\n";

   // demonstrate squareByReference
   cout << "z = " << z << " before squareByReference\n";
   squareByReference(z);
   cout << "z = " << z << " after squareByReference\n";
} 

// squareByValue multiplies number by itself, stores the     
// result in number and returns the new value of number      
int squareByValue(int number) {                               
   return number *= number; // caller's argument not modified 
}                                                             

// squareByReference multiplies numberRef by itself and stores the result
// in the variable to which numberRef refers in function main            
void squareByReference(int& numberRef) {                 
   numberRef *= numberRef; // caller's argument modified 
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_09.cpp
================================================
// fig05_09.cpp
// Using default arguments.
#include <iostream>
using namespace std;

// function prototype that specifies default arguments
int boxVolume(int length = 1, int width = 1, int height = 1); 
 
int main() {
   // no arguments--use default values for all dimensions
   cout << "The default box volume is: " << boxVolume();
   
   // specify length; default width and height
   cout << "\n\nThe volume of a box with length 10,\n"
      << "width 1 and height 1 is: " << boxVolume(10);
        
   // specify length and width; default height
   cout << "\n\nThe volume of a box with length 10,\n" 
      << "width 5 and height 1 is: " << boxVolume(10, 5);
   
   // specify all arguments 
   cout << "\n\nThe volume of a box with length 10,\n"
      << "width 5 and height 2 is: " << boxVolume(10, 5, 2)
      << '\n';
} 

// function boxVolume calculates the volume of a box
int boxVolume(int length, int width, int height) {                                       
   return length * width * height;                              
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_10.cpp
================================================
// fig05_10.cpp
// Overloaded square functions.
#include <iostream>
using namespace std;

// function square for int values              
int square(int x) {                            
   cout << "square of integer " << x << " is ";
   return x * x;                               
} 

// function square for double values           
double square(double y) {                     
   cout << "square of double " << y << " is "; 
   return y * y;                               
} 

int main() {
   cout << square(7); // calls int version
   cout << '\n';
   cout << square(7.5); // calls double version
   cout << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_11.cpp
================================================
// fig05_11.cpp
// Name mangling to enable type-safe linkage.

// function square for int values
int square(int x) {
   return x * x; 
} 

// function square for double values
double square(double y) {
   return y * y; 
} 

// function that receives arguments of types 
// int, float, char and int&
void nothing1(int a, float b, char c, int& d) { }

// function that receives arguments of types 
// char, int, float& and double&
int nothing2(char a, int b, float& c, double& d) {
   return 0; 
} 

int main() { }

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_12.cpp
================================================
// fig05_12.cpp
// Overloaded square functions.
#include <iostream>
using namespace std;

// function square for int values              
int square(int x) {
   cout << "square of integer " << x << " is ";
   return x * x;
}

// function square for double values           
double square(double y) {
   cout << "square of double " << y << " is ";
   return y * y;
}

int main() {
   cout << square(7); // calls int version
   cout << endl;
   cout << square(7.5); // calls double version
   cout << endl;
}

/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_13.cpp
================================================
// fig05_13.cpp
// Function template maximum test program.
#include <iostream>
#include "maximum.h" // include definition of function template maximum 
using namespace std;

int main() {
   // demonstrate maximum with int values
   cout << "Input three integer values: ";
   int int1, int2, int3;
   cin >> int1 >> int2 >> int3;

   // invoke int version of maximum
   cout << "The maximum integer value is: "
      << maximum(int1, int2, int3);        

   // demonstrate maximum with double values
   cout << "\n\nInput three double values: ";
   double double1, double2, double3;
   cin >> double1 >> double2 >> double3;

   // invoke double version of maximum
   cout << "The maximum double value is: "
      << maximum(double1, double2, double3);

   // demonstrate maximum with char values
   cout << "\n\nInput three characters: ";
   char char1, char2, char3;
   cin >> char1 >> char2 >> char3;

   // invoke char version of maximum
   cout << "The maximum character value is: "
      << maximum(char1, char2, char3) << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_14.cpp
================================================
// fig05_14.cpp
// Recursive function factorial.
#include <boost/multiprecision/cpp_int.hpp>
#include <format>
#include <iostream>
using boost::multiprecision::cpp_int;
using namespace std;

cpp_int factorial(int number); // function prototype 

int main() {
   // calculate the factorials of 0 through 10
   for (int counter{0}; counter <= 10; ++counter) {
      cout << format("{:>2}! = ", counter) << factorial(counter) 
         << '\n';
   } 

   // display factorials of 20, 30 and 40
   cout << format("\n{:>2}! = ", 20) << factorial(20) 
      << format("\n{:>2}! = ", 30) << factorial(30) 
      << format("\n{:>2}! = ", 40) << factorial(40) << '\n';
} 

// recursive definition of function factorial    
cpp_int factorial(int number) {                     
   if (number <= 1) { // test for base case      
      return 1; // base cases: 0! = 1 and 1! = 1 
   }                                             
   else { // recursion step                      
      return number * factorial(number - 1);     
   }                                             
}                                                


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_15.cpp
================================================
// fig05_15.cpp
// Recursive function fibonacci.
#include <format>  
#include <iostream>
using namespace std;

long fibonacci(long number); // function prototype 

int main() {
   // calculate the fibonacci values of 0 through 10
   for (int counter{0}; counter <= 10; ++counter) {
      cout << format("fibonacci({}) = {}\n", 
         counter, fibonacci(counter));
   }

   // display higher fibonacci values
   cout << format("\nfibonacci(20) = {}\n", fibonacci(20))
      << format("fibonacci(30) = {}\n", fibonacci(30))
      << format("fibonacci(35) = {}\n", fibonacci(35));
} 

// recursive function fibonacci                            
long fibonacci(long number) {            
   if ((0 == number) || (1 == number)) { // base cases     
      return number;                                       
   }                                                       
   else { // recursion step                                
      return fibonacci(number - 1) + fibonacci(number - 2);
   }                                                       
}                                                          


/*************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
*************************************************************************/


================================================
FILE: examples/lesson05/fig05_16.cpp
================================================
// fig05_16.cpp
// Scoping example.
#include <iostream>
using namespace std;

void useLocal(); // function prototype
void useStaticLocal(); // function prototype
void useGlobal(); // function prototype

int x{1}; // global variable 

int main() {
   cout << "global x in main is " << x << '\n'; 

   const int x{5}; // local variable to main

   cout << "local x in main's outer scope is " << x << '\n';
 
   { // block starts a new scope                                  
      const int x{7}; // hides both x in outer scope and global x 
                                                                  
      cout << "local x in main's inner scope is " << x << '\n';   
   }                                                               
 
   cout << "local x in main's outer scope is " << x << '\n';

   useLocal(); // useLocal has local x
   useStaticLocal(); // useStaticLocal has static local x
   useGlobal(); // useGlobal uses global x
   useLocal(); // useLocal reinitializes its local x
   useStaticLocal(); // static local x retains its prior value
   useGlobal(); // global x also retains its prior value

   cout << "\nlocal x in main is " << x << '\n';
} // end of main 

// useLocal reinitializes local variable x during each call
void useLocal() {
   int x{25}; // initialized each time useLocal is called

   cout << "\nlocal x is " << x << " on entering useLocal\n";
   ++x;
   cout << "local x is " << x << " on exiting useLocal\n";
} 

// useStaticLocal initializes static local variable x only the
// first time the function is called; value of x is saved
// between calls to this function
void useStaticLocal() {
   static int x{50}; // initialized first time useStaticLocal is called

   cout << "\nlocal static x is " << x 
      << " on entering useStaticLocal\n";
   ++x; 
   cout << "local static x is " << x 
      << " on exiting useStaticLocal\n";
} 

// useGlobal modifies global variable x during each call
void useGlobal() {
   cout << "\nglobal x is " << x << " on entering useGlobal\n";
   x *= 10;
   cout << "global x is " << x << " on exiting useGlobal\n";
} 

/*************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
*************************************************************************/


================================================
FILE: examples/lesson05/fig05_17.cpp
================================================
// fig05_17.cpp
// Unary scope resolution operator.
#include <iostream>
using namespace std;

const int number{7}; // global variable named number 

int main() {
   const double number{10.5}; // local variable named number

   // display values of local and global variables
   cout << "Local double value of number = " << number
      << "\nGlobal int value of number = " << ::number << '\n';
} 


/*************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
*************************************************************************/


================================================
FILE: examples/lesson05/fig05_18.cpp
================================================
// fig05_18.cpp
// Encrypting and decrypting text with a Vigenre cipher. 
#include "cipher.h"
#include <iostream>
#include <string>
using namespace std;

int main() {
   string plainText;
   cout << "Enter the text to encrypt:\n";
   getline(cin, plainText);

   string secretKey;
   cout << "\nEnter the secret key:\n";
   getline(cin, secretKey);

   Cipher cipher; 

   // encrypt plainText using secretKey
   string cipherText{cipher.encrypt(plainText, secretKey)};
   cout << "\nEncrypted:\n   " << cipherText << '\n';

   // decrypt cipherText
   cout << "\nDecrypted:\n   "  
      << cipher.decrypt(cipherText, secretKey) << '\n';
   
   // decrypt ciphertext entered by the user
   cout << "\nEnter the ciphertext to decipher:\n";
   getline(cin, cipherText);
   cout << "\nDecrypted:\n   " 
      << cipher.decrypt(cipherText, secretKey) << '\n';
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_19.cpp
================================================
// fig05_19.cpp
// C++17 [[nodiscard]] attribute.

[[nodiscard]]
int cube(int x) {
   return x * x * x;
}

int main() {
   cube(10); // generates a compiler warning
}

/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/fig05_20.cpp
================================================
// fig15_20.cpp
// Encrypting and decrypting text with a Vigenre cipher. 
#include "cipher.h"
#include <iostream>
#include <string>
using namespace std;

int main() {
   string plainText;
   cout << "Enter the text to encrypt:\n";
   getline(cin, plainText);

   string secretKey;
   cout << "\nEnter the secret key:\n";
   getline(cin, secretKey);

   Cipher cipher; 

   // encrypt plainText using secretKey
   string cipherText{cipher.encrypt(plainText, secretKey)};
   cout << "\nEncrypted:\n   " << cipherText << endl;

   // decrypt cipherText
   cout << "\nDecrypted:\n   "  
      << cipher.decrypt(cipherText, secretKey) << endl;
   
   // decrypt ciphertext entered by the user
   cout << "\nEnter the ciphertext to decipher:\n";
   getline(cin, cipherText);
   cout << "\nDecrypted:\n   " 
      << cipher.decrypt(cipherText, secretKey) << endl;
}

/**************************************************************************
 * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson05/maximum.h
================================================
// Fig. 5.12: maximum.h
// Function template maximum header.
template <typename T>  // or template <class T>      
T maximum(T value1, T value2, T value3) {                 
   T maximumValue{value1}; // assume value1 is maximum   

   // determine whether value2 is greater than maximumValue
   if (value2 > maximumValue) {                           
      maximumValue = value2;                               
   }                                                        

   // determine whether value3 is greater than maximumValue
   if (value3 > maximumValue) {                           
      maximumValue = value3;                               
   }                                                        
   
   return maximumValue;                                    
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_01.cpp
================================================
// fig06_01.cpp
// Initializing an array's elements to zeros and printing the array.
#include <format>
#include <iostream>
#include <array>

int main() {
   std::array<int, 5> values; // values is an array of 5 int values

   // initialize elements of array values to 0        
   for (size_t i{0}; i < values.size(); ++i) {
      values[i] = 0; // set element at location i to 0
   }

   std::cout << std::format("{:>7}{:>10}\n", "Element", "Value");

   // output each array element's value
   for (size_t i{0}; i < values.size(); ++i) {
      std::cout << std::format("{:>7}{:>10}\n", i, values[i]);
   }

   std::cout << std::format("\n{:>7}{:>10}\n", "Element", "Value");

   // access elements via the at member function
   for (size_t i{0}; i < values.size(); ++i) {
      std::cout << std::format("{:>7}{:>10}\n", i, values.at(i));
   }

   // accessing an element outside the array's bounds with at
   values.at(10); // throws an exception
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_02.cpp
================================================
// fig06_02.cpp
// Initializing an array in a declaration.
#include <format>
#include <iostream>
#include <array>

int main() {
   std::array<int, 5> values{32, 27, 64, 18, 95}; // braced initializer

   // output each array element's value
   for (size_t i{0}; i < values.size(); ++i) {
      std::cout << std::format("{}  ", values.at(i));
   }

   std::cout << "\n\n";

   // using class template argument deduction to determine values2's type
   std::array values2{1.1, 2.2, 3.3, 4.4};

   // output each array element's value
   for (size_t i{0}; i < values2.size(); ++i) {
      std::cout << std::format("{}  ", values2.at(i));
   }

   std::cout << '\n';
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_03.cpp
================================================
// fig06_03.cpp
// Using range-based for.
#include <format>
#include <iostream>
#include <array>

int main() {
   std::array items{1, 2, 3, 4, 5}; // type inferred as array<int, 5>

   // display items before modification
   std::cout << "items before modification: ";
   for (const int& item : items) { // item is a reference to a const int
      std::cout << std::format("{} ", item); 
   }                       
 
   // multiply the elements of items by 2
   for (int& item : items) { // item is a reference to an int
      item *= 2;
   }

   // display items after modification
   std::cout << "\nitems after modification: ";
   for (const int& item : items) {
      std::cout << std::format("{} ", item);
   }

   // sum elements of items using range-based for with initialization
   std::cout << "\n\ncalculating a running total of items' values:\n";
   for (int runningTotal{0}; const int& item : items) {
      runningTotal += item;
      std::cout << std::format("item: {}; running total: {}\n",
         item, runningTotal);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_04.cpp
================================================
// fig06_04.cpp
// Set array values to the even integers from 2 to 10.
#include <format>
#include <iostream>
#include <array>

int main() {
   // constant can be used to specify array size
   constexpr size_t arraySize{5}; // must initialize in declaration

   std::array<int, arraySize> values{}; // array values has 5 elements

   for (int i{0}; i < values.size(); ++i) { // set the values
      values.at(i) = 2 + 2 * i;
   }

   // output contents of array values in tabular format
   for (const int& value : values) {
      std::cout << std::format("{}  ", value);
   }

   std::cout << '\n';
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_05.cpp
================================================
// fig06_05.cpp
// Compute the sum of an array's elements.
#include <format>
#include <iostream>
#include <array>

int main() {
   std::array items{10, 20, 30, 40}; // type inferred as array<int, 4>
   int total{0};

   // sum the contents of items            
   for (const int& item : items) {
      total += item;
   }

   std::cout << std::format("Total of array elements: {}\n", total);
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_06.cpp
================================================
// fig06_06.cpp
// Printing a student grade distribution as a primitive bar chart.
#include <format>
#include <iostream>
#include <array>

int main() {
   constexpr std::array frequencies{0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1};

   std::cout << "Grade distribution:\n";

   // for each element of frequencies, output a bar of the chart
   for (int i{0}; const int& frequency : frequencies) {
      // output bar labels ("00-09:", ..., "90-99:", "100:")
      if (i < 10) {
         std::cout << std::format("{:02d}-{:02d}: ",
            i * 10, (i * 10) + 9);
      }
      else {
         std::cout << std::format("{:>5d}: ", 100);
      }

      ++i;

      // print bar of asterisks
      for (int stars{0}; stars < frequency; ++stars) {
         std::cout << '*';
      }

      std::cout << '\n'; // start a new line of output
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_07.cpp
================================================
// fig06_07.cpp
// Die-rolling program using an array instead of switch.
#include <format>
#include <iostream>
#include <array>
#include <random>

int main() {
   // set up random-number generation
   std::random_device rd; // used to seed the default_random_engine
   std::default_random_engine engine{rd()}; // rd() produces a seed 
   std::uniform_int_distribution randomDie{1, 6};

   constexpr size_t arraySize{7}; // ignore element zero
   std::array<int, arraySize> frequency{}; // initialize to 0s

   // roll die 60,000,000 times; use die value as frequency index
   for (int roll{1}; roll <= 60'000'000; ++roll) {
      ++frequency.at(randomDie(engine));
   }

   std::cout << std::format("{}{:>13}\n", "Face", "Frequency");

   // output each array element's value
   for (size_t face{1}; face < frequency.size(); ++face) {
      std::cout << std::format("{:>4}{:>13}\n", face, frequency.at(face));
   }
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_08.cpp
================================================
// fig06_08.cpp
// Poll analysis program.
#include <format>
#include <iostream>
#include <array>

int main() {
   // place survey responses in array responses
   constexpr std::array responses{
      1, 2, 5, 4, 3, 5, 2, 1, 3, 1, 4, 3, 3, 3, 2, 3, 3, 2, 2, 5};

   // initialize frequency counters to 0
   constexpr size_t frequencySize{6}; // size of array frequency
   std::array<int, frequencySize> frequency{};

   // for each response in responses, use that value 
   // as frequency index to determine element to increment
   for (const int& response : responses) {
      ++frequency.at(response);
   }

   std::cout << std::format("{}{:>12}\n", "Rating", "Frequency");

   // output each array element's value
   for (size_t rating{1}; rating < frequency.size(); ++rating) {
      std::cout << std::format("{:>6}{:>12}\n",
         rating, frequency.at(rating));
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_09.cpp
================================================
// fig06_09.cpp
// Sorting and searching arrays.
#include <array>
#include <algorithm> // contains sort and binary_search
#include <format>
#include <iostream>
#include <string>

int main() {
   using namespace std::string_literals; // enables string object literals

   // colors is inferred to be an array<string, 7>
   std::array colors{"red"s, "orange"s, "yellow"s,
      "green"s, "blue"s, "indigo"s, "violet"s};

   // output original array
   std::cout << "Unsorted colors array:\n   ";
   for (const std::string& color : colors) {
      std::cout << std::format("{} ", color);
   }

   // sort contents of colors
   std::sort(std::begin(colors), std::end(colors));

   // output sorted array
   std::cout << "\nSorted colors array:\n   ";
   for (const std::string& color : colors) {
      std::cout << std::format("{} ", color);
   }

   // search for "indigo" in colors
   bool found{std::binary_search(
      std::begin(colors), std::end(colors), "indigo")};
   std::cout << std::format("\n\n\"indigo\" {} found in colors array\n",
      found ? "was" : "was not");

   // search for "cyan" in colors
   found = std::binary_search(
      std::begin(colors), std::end(colors), "cyan");
   std::cout << std::format("\"cyan\" {} found in colors array\n",
      found ? "was" : "was not");
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_10.cpp
================================================
// fig06_10.cpp
// Initializing multidimensional arrays.
#include <iostream> 
#include <array> 

constexpr size_t rows{2};
constexpr size_t columns{3};
void printArray(const std::array<std::array<int, columns>, rows>& a);

int main() {
   constexpr std::array values1{std::array{1, 2, 3}, std::array{4, 5, 6}};
   constexpr std::array values2{std::array{1, 2, 3}, std::array{4, 5, 0}};

   std::cout << "values1 by row:\n";
   printArray(values1);

   std::cout << "\nvalues2 by row:\n";
   printArray(values2);
}

// output array with two rows and three columns                 
void printArray(const std::array<std::array<int, columns>, rows>& a) {
   // loop through array's rows             
   for (const auto& row : a) {
      // loop through columns of current row                
      for (const auto& element : row) {
         std::cout << element << ' ';
      }

      std::cout << '\n'; // start new line of output             
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_11.cpp
================================================
// fig06_11.cpp
// Compute the sum of the elements of an array using accumulate.
#include <array>
#include <format>
#include <iostream>
#include <numeric>

int main() {
   constexpr std::array integers{10, 20, 30, 40};
   std::cout << std::format("Total of array elements: {}\n",
      std::accumulate(std::begin(integers), std::end(integers), 0));
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_12.cpp
================================================
// fig06_12.cpp
// Compute the product of an array's elements using accumulate.
#include <array>
#include <format>
#include <iostream>
#include <numeric>

int multiply(int x, int y) {
   return x * y;
}

int main() {
   constexpr std::array integers{1, 2, 3, 4, 5};

   std::cout << std::format("Product of integers: {}\n", std::accumulate(
      std::begin(integers), std::end(integers), 1, multiply));

   std::cout << std::format("Product of integers with a lambda: {}\n",
      std::accumulate(std::begin(integers), std::end(integers), 1,
         [](const auto& x, const auto& y) {return x * y;}));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson06/fig06_13.cpp
================================================
// fig06_13.cpp
// Functional-style programming with C++20 ranges and views.
#include <array>
#include <format>
#include <iostream>
#include <numeric>
#include <ranges>

int main() {
   // lambda to display results of range operations
   auto showValues{
      [](auto& values, const std::string& message) {
         std::cout << std::format("{}: ", message);

         for (const auto& value : values) {
            std::cout << std::format("{} ", value);
         }

         std::cout << '\n';
      }
   };

   auto values1{std::views::iota(1, 11)}; // generate integers 1-10
   showValues(values1, "Generate integers 1-10");

   // filter each value in values1, keeping only the even integers
   auto values2{values1 |
      std::views::filter([](const auto& x) {return x % 2 == 0;})};
   showValues(values2, "Filtering even integers");

   // map each value in values2 to its square
   auto values3{
      values2 | std::views::transform([](const auto& x) {return x * x;})};
   showValues(values3, "Mapping even integers to squares");

   // combine filter and transform to get squares of the even integers
   auto values4{
      values1 | std::views::filter([](const auto& x) {return x % 2 == 0;})
              | std::views::transform([](const auto& x) {return x * x; })};
   showValues(values4, "Squares of even integers");

   // total the squares of the even integers 
   std::cout << std::format("Sum squares of even integers 2-10: {}\n",
      std::accumulate(std::begin(values4), std::end(values4), 0));

   // process a container's elements
   constexpr std::array numbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   auto values5{
      numbers | std::views::filter([](const auto& x) {return x % 2 == 0;})
              | std::views::transform([](const auto& x) {return x * x;})};
   showValues(values5, "Squares of even integers in array numbers");
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson06/fig06_14.cpp
================================================
// fig06_14.cpp
// Demonstrating C++ standard library class template vector.
#include <iostream>
#include <vector>    
#include <stdexcept> 

void outputVector(const std::vector<int>& items); // display the vector
void inputVector(std::vector<int>& items); // input values into the vector

int main() {
   std::vector<int> integers1(7); // 7-element vector<int>  
   std::vector<int> integers2(10); // 10-element vector<int>

   // print integers1 size and contents
   std::cout << "Size of vector integers1 is " << integers1.size()
      << "\nvector after initialization: ";
   outputVector(integers1);

   // print integers2 size and contents
   std::cout << "\nSize of vector integers2 is " << integers2.size()
      << "\nvector after initialization: ";
   outputVector(integers2);

   // input and print integers1 and integers2
   std::cout << "\nEnter 17 integers:\n";
   inputVector(integers1);
   inputVector(integers2);

   std::cout << "\nAfter input, the vectors contain:\n"
      << "integers1: ";
   outputVector(integers1);
   std::cout << "integers2: ";
   outputVector(integers2);

   // use inequality (!=) operator with vector objects
   std::cout << "\nEvaluating: integers1 != integers2\n";

   if (integers1 != integers2) {
      std::cout << "integers1 and integers2 are not equal\n";
   }

   // create vector integers3 using integers1 as an     
   // initializer; print size and contents              
   std::vector integers3{integers1}; // copy constructor

   std::cout << "\nSize of vector integers3 is " << integers3.size()
      << "\nvector after initialization: ";
   outputVector(integers3);

   // use overloaded assignment (=) operator              
   std::cout << "\nAssigning integers2 to integers1:\n";
   integers1 = integers2; // assign integers2 to integers1

   std::cout << "integers1: ";
   outputVector(integers1);
   std::cout << "integers2: ";
   outputVector(integers2);

   // use equality (==) operator with vector objects
   std::cout << "\nEvaluating: integers1 == integers2\n";

   if (integers1 == integers2) {
      std::cout << "integers1 and integers2 are equal\n";
   }

   // use the value at location 5 as an rvalue
   std::cout << "\nintegers1.at(5) is " << integers1.at(5);

   // use integers1.at(5) as an lvalue
   std::cout << "\n\nAssigning 1000 to integers1.at(5)\n";
   integers1.at(5) = 1000;
   std::cout << "integers1: ";
   outputVector(integers1);

   // attempt to use out-of-range index                   
   try {
      std::cout << "\nAttempt to display integers1.at(15)\n";
      std::cout << integers1.at(15) << '\n'; // ERROR: out of range
   }
   catch (const std::out_of_range& ex) {
      std::cerr << "An exception occurred: " << ex.what() << '\n';
   }

   // changing the size of a vector
   std::cout << "\nCurrent integers3 size is: " << integers3.size();
   integers3.push_back(1000); // add 1000 to the end of the vector
   std::cout << "\nNew integers3 size is: " << integers3.size()
      << "\nintegers3 now contains: ";
   outputVector(integers3);
}

// output vector contents
void outputVector(const std::vector<int>& items) {
   for (const int& item : items) {
      std::cout << item << ' ';
   }

   std::cout << '\n';
}

// input vector contents
void inputVector(std::vector<int>& items) {
   for (int& item : items) {
      std::cin >> item;
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_01.cpp
================================================
// fig07_01.cpp
// Pointer operators & and *.
#include <iostream>
using namespace std;

int main() {
   constexpr int a{7}; // initialize a with 7
   const int* aPtr{&a}; // initialize aPtr with address of int variable a

   std::cout << "The address of a is " << &a
      << "\nThe value of aPtr is " << aPtr;
   std::cout << "\n\nThe value of a is " << a
      << "\nThe value of *aPtr is " << *aPtr << '\n';
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_02.cpp
================================================
// fig07_02.cpp
// Pass-by-value used to cube a variable's value.
#include <format>
#include <iostream>

int cubeByValue(int n); // prototype 

int main() {
   int number{5};

   std::cout << std::format("Original value of number is {}\n", number);
   number = cubeByValue(number); // pass number by value to cubeByValue
   std::cout << std::format("New value of number is {}\n", number);
}

// calculate and return cube of integer argument                
int cubeByValue(int n) {
   return n * n * n; // cube local variable n and return result 
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_03.cpp
================================================
// fig07_03.cpp
// Pass-by-reference with a pointer argument used to cube a 
// variable's value.
#include <format>
#include <iostream>

void cubeByReference(int* nPtr); // prototype 

int main() {
   int number{5};

   std::cout << std::format("Original value of number is {}\n", number);
   cubeByReference(&number); // pass number address to cubeByReference
   std::cout << std::format("New value of number is {}\n", number);
}

// calculate cube of *nPtr; modifies variable number in main 
void cubeByReference(int* nPtr) {
   *nPtr = *nPtr * *nPtr * *nPtr; // cube *nPtr              
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_06.cpp
================================================
// fig07_06.cpp
// C++20: Creating std::arrays with to_array.
#include <format>
#include <iostream>
#include <array>

int main() {
   // generic lambda to display a collection of items
   const auto display{
      [](const auto& items) {
         for (const auto& item : items) {
            std::cout << std::format("{} ", item);
         }
      }
   };

   const int values1[]{10, 20, 30};

   // creating a std::array from a built-in array
   const auto array1{std::to_array(values1)};

   std::cout << std::format("array1.size() = {}\n", array1.size())
      << "array1: ";
   display(array1); // use lambda to display contents

   // creating a std::array from an initializer list
   const auto array2{std::to_array({1, 2, 3, 4})};
   std::cout << std::format("\n\narray2.size() = {}\n", array2.size())
      << "array2: ";
   display(array2); // use lambda to display contents

   std::cout << '\n';
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_07.cpp
================================================
// fig07_07.cpp
// Attempting to modify data through a 
// nonconstant pointer to constant data.

int main() {
   int y{0};
   const int* yPtr{&y};
   *yPtr = 100; // error: cannot modify a const object 
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_08.cpp
================================================
// fig07_08.cpp
// Attempting to modify a constant pointer to nonconstant data.

int main() {
   int x, y;

   // ptr is a constant pointer to an integer that can be modified 
   // through ptr, but ptr always points to the same memory location.                                  
   int* const ptr{&x}; // const pointer must be initialized 

   *ptr = 7; // allowed: *ptr is not const
   ptr = &y; // error: ptr is const; cannot assign to it a new address
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson07/fig07_09.cpp
================================================
// fig07_09.cpp
// Attempting to modify a constant pointer to constant data.
#include <iostream>
using namespace std;

int main() {
   int x{5}, y;

   // ptr is a constant pointer to a constant integer. 
   // ptr always points to the same location; the integer
   // at that location cannot be modified.
   const int* const ptr{&x};

   cout << *ptr << "\n";

   *ptr = 7; // error: *ptr is const; cannot assign new value 
   ptr = &y; // error: ptr is const; cannot assign new address
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_10.cpp
================================================
// fig07_10.cpp
// Sizeof operator when used on a built-in array's name
// returns the number of bytes in the built-in array.
#include <format>
#include <iostream>

size_t getSize(double* ptr); // prototype

int main() {
   double numbers[20]; // 20 doubles; occupies 160 bytes on our system

   std::cout << std::format("Number of bytes in numbers is {}\n",
      sizeof(numbers));

   std::cout << std::format("Number of bytes returned by getSize is {}\n",
      getSize(numbers));
}

// return size of ptr         
size_t getSize(double* ptr) {
   return sizeof(ptr);
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_11.cpp
================================================
// fig07_11.cpp
// sizeof operator used to determine standard data type sizes.
#include <format>
#include <iostream>

int main() {
   constexpr char c{}; // variable of type char
   constexpr short s{}; // variable of type short
   constexpr int i{}; // variable of type int
   constexpr long l{}; // variable of type long
   constexpr long long ll{}; // variable of type long long
   constexpr float f{}; // variable of type float
   constexpr double d{}; // variable of type double
   constexpr long double ld{}; // variable of type long double
   constexpr int array[20]{}; // built-in array of int
   const int* const ptr{array}; // variable of type int*

   std::cout << std::format("sizeof c = {}\tsizeof(char) = {}\n",
      sizeof c, sizeof(char));
   std::cout << std::format("sizeof s = {}\tsizeof(short) = {}\n",
      sizeof s, sizeof(short));
   std::cout << std::format("sizeof i = {}\tsizeof(int) = {}\n",
      sizeof i, sizeof(int));
   std::cout << std::format("sizeof l = {}\tsizeof(long) = {}\n",
      sizeof l, sizeof(long));
   std::cout << std::format("sizeof ll = {}\tsizeof(long long) = {}\n",
      sizeof ll, sizeof(long long));
   std::cout << std::format("sizeof f = {}\tsizeof(float) = {}\n",
      sizeof f, sizeof(float));
   std::cout << std::format("sizeof d = {}\tsizeof(double) = {}\n",
      sizeof d, sizeof(double));
   std::cout << std::format("sizeof ld = {}\tsizeof(long double) = {}\n",
      sizeof ld, sizeof(long double));
   std::cout << std::format("sizeof array = {}\n", sizeof array);
   std::cout << std::format("sizeof ptr = {}\n", sizeof ptr);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_12.cpp
================================================
// fig07_12.cpp
// C++20 spans: Creating views into containers.
#include <array>
#include <format>
#include <iostream>
#include <numeric>
#include <span>
#include <vector>

// items parameter is treated as a const int* so we also need the size to
// know how to iterate over items with counter-controlled iteration
void displayArray(const int items[], size_t size) {
   for (size_t i{0}; i < size; ++i) {
      std::cout << std::format("{} ", items[i]);
   }
}

// span parameter contains both the location of the first item
// and the number of elements, so we can iterate using range-based for
void displaySpan(std::span<const int> items) {
   for (const auto& item : items) { // spans are iterable
      std::cout << std::format("{} ", item);
   }
}

// spans can be used to modify elements in the original data structure
void times2(std::span<int> items) {
   for (int& item : items) {
      item *= 2;
   }
}

int main() {
   int values1[]{1, 2, 3, 4, 5};
   std::array values2{6, 7, 8, 9, 10};
   std::vector values3{11, 12, 13, 14, 15};

   // must specify size because the compiler treats displayArray's items 
   // parameter as a pointer to the first element of the argument
   std::cout << "values1 via displayArray: ";
   displayArray(values1, 5);

   // compiler knows values1's size and automatically creates a span
   // representing &values1[0] and the array's length
   std::cout << "\nvalues1 via displaySpan: ";
   displaySpan(values1);

   // compiler also can create spans from std::arrays and std::vectors
   std::cout << "\nvalues2 via displaySpan: ";
   displaySpan(values2);
   std::cout << "\nvalues3 via displaySpan: ";
   displaySpan(values3);

   // changing a span's contents modifies the original data
   times2(values1);
   std::cout << "\n\nvalues1 after times2 modifies its span argument: ";
   displaySpan(values1);

   // spans have various array-and-vector-like capabilities
   std::span mySpan{values1}; // span<int>
   std::cout << "\n\nmySpan's first element: " << mySpan.front()
      << "\nmySpan's last element: " << mySpan.back();

   // spans can be used with standard library algorithms
   std::cout << "\n\nSum of mySpan's elements: "
      << std::accumulate(std::begin(mySpan), std::end(mySpan), 0);

   // spans can be used to create subviews of a container
   std::cout << "\n\nFirst three elements of mySpan: ";
   displaySpan(mySpan.first(3));
   std::cout << "\nLast three elements of mySpan: ";
   displaySpan(mySpan.last(3));
   std::cout << "\nMiddle three elements of mySpan: ";
   displaySpan(mySpan.subspan(1, 3));

   // changing a subview's contents modifies the original data
   times2(mySpan.subspan(1, 3));
   std::cout << "\n\nvalues1 after modifying elements via span: ";
   displaySpan(values1);

   // access a span element via []
   std::cout << "\n\nThe element at index 2 is: " << mySpan[2];
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_13.cpp
================================================
// fig07_13.cpp
// Reading in command-line arguments.
#include <format>
#include <iostream>

int main(int argc, char* argv[]) {
   std::cout << std::format("Number of arguments: {}\n\n", argc);

   for (int i{0}; i < argc; ++i) {
      std::cout << std::format("{}\n", argv[i]);
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson07/fig07_14.cpp
================================================
// fig07_14.cpp
// C++20: Creating std::arrays from string literals with to_array.
#include <format>
#include <iostream>
#include <array>

int main() {
   // lambda to display a collection of items
   const auto display{
      [](const auto& items) {
         for (const auto& item : items) {
            std::cout << std::format("{} ", item);
         }
       }
   };

   // initializing an array with a string literal
   // creates a one-element array<const char*>
   const auto array1{std::array{"abc"}};
   std::cout << std::format("array1.size() = {}\narray1: ",
      array1.size());
   display(array1); // use lambda to display contents

   // creating std::array of characters from a string literal 
   const auto array2{std::to_array("C++20")};
   std::cout << std::format("\n\narray2.size() = {}\narray2: ",
      array2.size());
   display(array2); // use lambda to display contents

   std::cout << '\n';
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/accounts.csv
================================================
account,name,balance
100,Devi,24.98
200,Taylor,345.67
300,Huber,0.0
400,Karimov,-42.16
500,Sosa,224.62

================================================
FILE: examples/lesson08/fig08_01.cpp
================================================
// fig08_01.cpp
// Demonstrating string assignment and concatenation.
#include <format> 
#include <iostream>
#include <string> 

int main() {
   std::string s1{"cat"};
   std::string s2; // initialized to the empty string
   std::string s3; // initialized to the empty string

   s2 = s1; // assign s1 to s2      
   s3.assign(s1); // assign s1 to s3
   std::cout << std::format("s1: {}\ns2: {}\ns3: {}\n\n", s1, s2, s3);

   s2.at(0) = 'r'; // modify s2 
   s3.at(2) = 'r'; // modify s3
   std::cout << std::format("After changes:\ns2: {}\ns3: {}", s2, s3);

   std::cout << "\n\nAfter concatenations:\n";
   std::string s4{s1 + "apult"}; // concatenation
   s1.append("acomb"); // create "catacomb"
   s3 += "pet"; // create "carpet" with overloaded +=
   std::cout << std::format("s1: {}\ns3: {}\ns4: {}\n", s1, s3, s4);

   // append locations 4 through end of s1 to
   // create string "comb" (s5 was initially empty)    
   std::string s5; // initialized to the empty string
   s5.append(s1, 4, s1.size() - 4);
   std::cout << std::format("s5: {}\n", s5);
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_02.cpp
================================================
// fig08_02.cpp
// Comparing strings.
#include <format>
#include <iostream>
#include <string>

void displayResult(const std::string& s, int result) {
   if (result == 0) {
      std::cout << std::format("{} == 0\n", s);
   }
   else if (result > 0) {
      std::cout << std::format("{} > 0\n", s);
   }
   else { // result < 0
      std::cout << std::format("{} < 0\n", s);
   }
}

int main() {
   const std::string s1{"Testing the comparison functions."};
   const std::string s2{"Hello"};
   const std::string s3{"stinger"};
   const std::string s4{s2}; // "Hello"

   std::cout << std::format("s1: {}\ns2: {}\ns3: {}\ns4: {}\n\n",
      s1, s2, s3, s4);

   // comparing s1 and s4
   if (s1 > s4) {
      std::cout << "s1 > s4\n";
   }

   // comparing s1 and s2
   displayResult("s1.compare(s2)", s1.compare(s2));

   // comparing s1 (elements 2-6) and s3 (elements 0-4)
   displayResult("s1.compare(2, 5, s3, 0, 5)",
      s1.compare(2, 5, s3, 0, 5));

   // comparing s2 and s4
   displayResult("s4.compare(0, s2.size(), s2)",
      s4.compare(0, s2.size(), s2));

   // comparing s2 and s4
   displayResult("s2.compare(0, 3, s4)", s2.compare(0, 3, s4));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_03.cpp
================================================
// fig08_03.cpp
// Demonstrating string member function substr.
#include <iostream>
#include <string>

int main() {
   const std::string s{"airplane"};
   std::cout << s.substr(3, 4) << '\n'; // retrieve substring "plan" 
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson08/fig08_04.cpp
================================================
// fig08_04.cpp
// Using the swap function to swap two strings.
#include <format> 
#include <iostream>
#include <string>

int main() {
   std::string s1{"one"};
   std::string s2{"two"};

   std::cout << std::format("Before swap:\ns1: {}; s2: {}\n\n", s1, s2);
   s1.swap(s2); // swap strings
   std::cout << std::format("After swap:\ns1: {}; s2: {}\n", s1, s2);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_05.cpp
================================================
// fig08_05.cpp
// Printing string characteristics.
#include <format> 
#include <iostream>
#include <string>

// display string statistics
void printStatistics(const std::string& s) {
   std::cout << std::format(
      "capacity: {}\nmax size: {}\nsize: {}\nempty: {}",
      s.capacity(), s.max_size(), s.size(), s.empty());
}

int main() {
   std::string string1; // empty string

   std::cout << "Statistics before input:\n";
   printStatistics(string1);

   std::cout << "\n\nEnter a string: ";
   std::cin >> string1; // delimited by whitespace
   std::cout << std::format("The string entered was: {}\n", string1);
   std::cout << "Statistics after input:\n";
   printStatistics(string1);

   std::cout << "\n\nEnter a string: ";
   std::cin >> string1; // delimited by whitespace
   std::cout << std::format("The string entered was: {}\n", string1);
   std::cout << "Statistics after input:\n";
   printStatistics(string1);

   // append 46 characters to string1
   string1 += "1234567890abcdefghijklmnopqrstuvwxyz1234567890";
   std::cout << std::format("\n\nstring1 is now: {}\n", string1);
   std::cout << "Statistics after concatenation:\n";
   printStatistics(string1);

   string1.resize(string1.size() + 10); // add 10 elements to string1
   std::cout << "\n\nStatistics after resizing to add 10 characters:\n";
   printStatistics(string1);
   std::cout << '\n';
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_06.cpp
================================================
// fig08_06.cpp
// Demonstrating the string find member functions.
#include <format> 
#include <iostream>
#include <string>

int main() {
   const std::string s{"noon is 12pm; midnight is not"};
   std::cout << "Original string: " << s;

   // find "is" from the beginning and end of s
   std::cout << std::format("\ns.find(\"is\"): {}\ns.rfind(\"is\"): {}",
      s.find("is"), s.rfind("is"));

   // find 'o' from beginning
   auto location{s.find_first_of("misop")};
   std::cout << std::format("\ns.find_first_of(\"misop\") found {} at {}",
      s.at(location), location);

   // find 'o' from end
   location = s.find_last_of("misop");
   std::cout << std::format("\ns.find_last_of(\"misop\") found {} at {}",
      s.at(location), location);

   // find '1' from beginning
   location = s.find_first_not_of("noi spm");
   std::cout << std::format(
      "\ns.find_first_not_of(\"noi spm\") found {} at {}",
      s.at(location), location);

   // find ';' at location 12
   location = s.find_first_not_of("12noi spm");
   std::cout << std::format(
      "\ns.find_first_not_of(\"12noi spm\") found {} at {}",
      s.at(location), location);

   // search for characters not in "noon is 12pm; midnight is not"
   location = s.find_first_not_of("noon is 12pm; midnight is not");

   if (location == std::string::npos) {
      std::cout << std::format("\n{}: not found\n",
         "s.find_first_not_of(\"noon is 12pm; midnight is not\")");
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_07.cpp
================================================
// fig08_07.cpp
// Demonstrating string member functions erase and replace.
#include <format> 
#include <iostream>
#include <string>

int main() {
   // compiler concatenates all parts into one string
   std::string string1{"The values in any left subtree"
      "\nare less than the value in the"
      "\nparent node and the values in"
      "\nany right subtree are greater"
      "\nthan the value in the parent node"};

   std::cout << std::format("Original string:\n{}\n\n", string1);

   string1.erase(62); // remove from index 62 through end of string1
   std::cout << std::format("string1 after erase:\n{}\n\n", string1);

   size_t position{string1.find(" ")}; // find first space

   // replace all spaces with period
   while (position != std::string::npos) {
      string1.replace(position, 1, ".");
      position = string1.find(" ", position + 1);
   }

   std::cout << std::format("After first replacement:\n{}\n\n", string1);

   position = string1.find("."); // find first period

   // replace all periods with two semicolons
   // NOTE: this will overwrite characters
   while (position != std::string::npos) {
      string1.replace(position, 2, "xxxxx;;yyy", 5, 2);
      position = string1.find(".", position + 2);
   }

   std::cout << std::format("After second replacement:\n{}\n", string1);
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson08/fig08_08.cpp
================================================
// fig08_08.cpp
// Demonstrating std::string insert member functions.
#include <format> 
#include <iostream>
#include <string>

int main() {
   std::string s1{"beginning end"};
   std::string s2{"12345678"};

   std::cout << std::format("Initial strings:\ns1: {}\ns2: {}\n\n",
      s1, s2);

   s1.insert(10, "middle "); // insert "middle " at location 10 
   s2.insert(3, "xx", 0, std::string::npos); // insert "xx" at location 3

   std::cout << std::format("Strings after insert:\ns1: {}\ns2: {}\n",
      s1, s2);
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_09.cpp
================================================
// fig08_09.cpp
// Demonstrating string_view.
#include <format> 
#include <iostream>
#include <string>
#include <string_view> 

int main() {
   std::string s1{"red"};
   std::string s2{s1};
   std::string_view v1{s1}; // v1 "sees" the contents of s1
   std::cout << std::format("s1: {}\ns2: {}\nv1: {}\n\n", s1, s2, v1);

   // string_views see changes to the characters they view
   s1.at(0) = 'R'; // capitalize s1
   std::cout << std::format("s1: {}\ns2: {}\nv1: {}\n\n", s1, s2, v1);

   // string_views are comparable with strings or string_views
   std::cout << std::format("s1 == v1: {}\ns2 == v1: {}\n\n",
      s1 == v1, s2 == v1);

   // string_view can remove a prefix or suffix
   v1.remove_prefix(1); // remove one character from the front
   v1.remove_suffix(1); // remove one character from the back
   std::cout << std::format("s1: {}\nv1: {}\n\n", s1, v1);

   // string_views are iterable
   std::string_view v2{"C-string"};
   std::cout << "The characters in v2 are: ";
   for (char c : v2) {
      std::cout << c << " ";
   }

   // string_views enable various string operations on C-Strings
   std::cout << std::format("\n\nv2.size(): {}\n", v2.size());
   std::cout << std::format("v2.find('-'): {}\n", v2.find('-'));
   std::cout << std::format("v2.starts_with('C'): {}\n",
      v2.starts_with('C'));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_10.cpp
================================================
// fig08_10.cpp
// Creating a sequential file.
#include <cstdlib> // exit function prototype              
#include <format> 
#include <fstream> // contains file stream processing types
#include <iostream>
#include <string>

int main() {
   // ofstream opens the file                
   if (std::ofstream output{"clients.txt", std::ios::out}) {
      std::cout << "Enter the account, name, and balance.\n"
         << "Enter end-of-file to end input.\n? ";

      int account;
      std::string name;
      double balance;

      // read account, name and balance from cin, then place in file
      while (std::cin >> account >> name >> balance) {
         output << std::format("{} {} {}\n", account, name, balance);
         std::cout << "? ";
      }
   }
   else {
      std::cerr << "File could not be opened\n";
      std::exit(EXIT_FAILURE);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_11.cpp
================================================
// fig08_11.cpp
// Reading and printing a sequential file.
#include <cstdlib> 
#include <format> 
#include <fstream> // file stream        
#include <iostream>
#include <string>

int main() {
   // ifstream opens the file          
   if (std::ifstream input{"clients.txt", std::ios::in}) {
      std::cout << std::format("{:<10}{:<13}{:>7}\n",
         "Account", "Name", "Balance");

      int account;
      std::string name;
      double balance;

      // display each record in file
      while (input >> account >> name >> balance) {
         std::cout << std::format("{:<10}{:<13}{:>7.2f}\n",
            account, name, balance);
      }
   }
   else {
      std::cerr << "File could not be opened\n";
      std::exit(EXIT_FAILURE);
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_12.cpp
================================================
// fig08_12.cpp
// Using an ostringstream object.
#include <iostream>
#include <sstream> // header for string stream processing
#include <string>

int main() {
   std::ostringstream output; // create ostringstream object

   const std::string string1{"Output of several data types "};
   const std::string string2{"to an ostringstream object:"};
   const std::string string3{"\ndouble: "};
   const std::string string4{"\n   int: "};

   constexpr double d{123.4567};
   constexpr int i{22};

   // output strings, double and int to ostringstream 
   output << string1 << string2 << string3 << d << string4 << i;

   // call str to obtain string contents of the ostringstream
   std::cout << "output contains:\n" << output.str();

   // add additional characters and call str to output string
   output << "\nmore characters added";
   std::cout << "\n\noutput now contains:\n" << output.str() << '\n';
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_13.cpp
================================================
// fig08_13.cpp
// Demonstrating input from an istringstream object.
#include <format> 
#include <iostream>
#include <sstream> 
#include <string>

int main() {
   const std::string inputString{"Atonia test 123 4.7 A"};
   std::istringstream input{inputString};
   std::string s1;
   std::string s2;
   int i;
   double d;
   char c;

   input >> s1 >> s2 >> i >> d >> c;

   std::cout << "Items extracted from the istringstream object:\n"
      << std::format("{}\n{}\n{}\n{}\n{}\n", s1, s2, i, d, c);

   // attempt to read from empty stream
   if (long value; input >> value) {
      std::cout << std::format("\nlong value is: {}\n", value);
   }
   else {
      std::cout << std::format("\ninput is empty\n");
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_14.cpp
================================================
// fig08_14.cpp
// Reading from a CSV file.
#include <format> 
#include <iostream>
#include <rapidcsv.h> 
#include <vector>

int main() {
   rapidcsv::Document document{"accounts.csv"}; // loads accounts.csv
   std::vector<int> accounts{document.GetColumn<int>("account")};
   std::vector<std::string> names{
      document.GetColumn<std::string>("name")};
   std::vector<double> balances{document.GetColumn<double>("balance")};

   std::cout << std::format(
      "{:<10}{:<13}{:>7}\n", "Account", "Name", "Balance");

   for (size_t i{0}; i < accounts.size(); ++i) {
      std::cout << std::format("{:<10}{:<13}{:>7.2f}\n",
         accounts.at(i), names.at(i), balances.at(i));
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_15.cpp
================================================
// fig08_15.cpp
// Reading the Titanic dataset from a CSV file, then analyzing it.
#include <format> 
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <ranges>
#include <rapidcsv.h> 
#include <string>
#include <vector>

int main() {
   // load Titanic dataset; treat missing age values as NaN
   rapidcsv::Document titanic{"titanic.csv",
      rapidcsv::LabelParams{}, rapidcsv::SeparatorParams{},
      rapidcsv::ConverterParams{true}};

   // GetColumn returns column's data as a vector of the appropriate type
   auto survived{titanic.GetColumn<int>("survived")};
   auto sex{titanic.GetColumn<std::string>("sex")};
   auto age{titanic.GetColumn<double>("age")};
   auto pclass{titanic.GetColumn<int>("pclass")};

   // display first 5 rows
   std::cout << std::format("First five rows:\n{:<10}{:<8}{:<6}{}\n",
      "survived", "sex", "age", "class");
   for (size_t i{0}; i < 5; ++i) {
      std::cout << std::format("{:<10}{:<8}{:<6.1f}{}\n",
         survived.at(i), sex.at(i), age.at(i), pclass.at(i));
   }

   // display last 5 rows
   std::cout << std::format("\nLast five rows:\n{:<10}{:<8}{:<6}{}\n",
      "survived", "sex", "age", "class");
   const auto count{titanic.GetRowCount()};
   for (size_t i{count - 5}; i < count; ++i) {
      std::cout << std::format("{:<10}{:<8}{:<6.1f}{}\n",
         survived.at(i), sex.at(i), age.at(i), pclass.at(i));
   }

   // use C++20 ranges to eliminate missing values from age column
   auto removeNaN{age |
      std::views::filter([](const auto& x) {return !std::isnan(x);})};
   std::vector<double> cleanAge{
      std::begin(removeNaN), std::end(removeNaN)};

   // descriptive statistics for cleaned ages column
   std::sort(std::begin(cleanAge), std::end(cleanAge));
   size_t size{cleanAge.size()};
   double median{};

   if (size % 2 == 0) { // find median value for even number of items
      median = (cleanAge.at(size / 2 - 1) + cleanAge.at(size / 2)) / 2;
   }
   else { // find median value for odd number of items
      median = cleanAge.at(size / 2);
   }

   std::cout << "\nDescriptive statistics for the age column:\n"
      << std::format("Passengers with age data: {}\n", size)
      << std::format("Average age: {:.2f}\n", std::accumulate(
         std::begin(cleanAge), std::end(cleanAge), 0.0) / size)
      << std::format("Minimum age: {:.2f}\n", cleanAge.front())
      << std::format("Maximum age: {:.2f}\n", cleanAge.back())
      << std::format("Median age: {:.2f}\n", median);

   // passenger counts by class
   auto countClass{
      [](const auto& column, const int classNumber) {
         return std::ranges::count_if(column, 
            [classNumber](int x) {return classNumber == x;});
      }
   };

   constexpr int firstClass{1};
   constexpr int secondClass{2};
   constexpr int thirdClass{3};
   const auto firstCount{countClass(pclass, firstClass)};
   const auto secondCount{countClass(pclass, secondClass)};
   const auto thirdCount{countClass(pclass, thirdClass)};

   std::cout << "\nPassenger counts by class:\n"
      << std::format("1st: {}\n2nd: {}\n3rd: {}\n\n",
         firstCount, secondCount, thirdCount);

   // percentage of people who survived
   const auto survivorCount{
      std::ranges::count_if(survived, [](auto x) {return x;})
   };

   std::cout << std::format("Survived count: {}\nDied count: {}\n",
      survivorCount, survived.size() - survivorCount);
   std::cout << std::format("Percent who survived: {:.2f}%\n\n",
      100.0 * survivorCount / survived.size());

   // count who survived by male/female, 1st/2nd/3rd class
   int survivingMales{0};
   int survivingFemales{0};
   int surviving1st{0};
   int surviving2nd{0};
   int surviving3rd{0};

   for (size_t i{0}; i < survived.size(); ++i) {
      if (survived.at(i)) {
         sex.at(i) == "female" ? ++survivingFemales : ++survivingMales;

         if (firstClass == pclass.at(i)) {
            ++surviving1st;
         }
         else if (secondClass == pclass.at(i)) {
            ++surviving2nd;
         }
         else { // third class
            ++surviving3rd;
         }
      }
   }

   // percentages who survived by male/female, 1st/2nd/3rd class
   std::cout << std::format("Female survivor percentage: {:.2f}%\n",
      100.0 * survivingFemales / survivorCount)
      << std::format("Male survivor percentage: {:.2f}%\n\n",
         100.0 * survivingMales / survivorCount)
      << std::format("1st class survivor percentage: {:.2f}%\n",
         100.0 * surviving1st / survivorCount)
      << std::format("2nd class survivor percentage: {:.2f}%\n",
         100.0 * surviving2nd / survivorCount)
      << std::format("3rd class survivor percentage: {:.2f}%\n",
         100.0 * surviving3rd / survivorCount);
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_16.cpp
================================================
// fig08_16.cpp
// Matching entire strings to regular expressions.
#include <format> 
#include <iostream>
#include <regex>

int main() {
   // fully match a pattern of literal characters
   std::regex r1{"02215"};
   std::cout << "Matching against: 02215\n"
      << std::format("02215: {}; 51220: {}\n\n",
            std::regex_match("02215", r1), std::regex_match("51220", r1));

   // fully match five digits
   std::regex r2{R"(\d{5})"};
   std::cout << R"(Matching against: \d{5})" << "\n"
      << std::format("02215: {}; 9876: {}\n\n",
            std::regex_match("02215", r2),
            std::regex_match("9876", r2));

   // match a word that starts with a capital letter
   std::regex r3{"[A-Z][a-z]*"};
   std::cout << "Matching against: [A-Z][a-z]*\n"
      << std::format("Angel: {}; tina: {}\n\n",
            std::regex_match("Angel", r3), std::regex_match("tina", r3));

   // match any character that's not a lowercase letter
   std::regex r4{"[^a-z]"};
   std::cout << "Matching against: [^a-z]\n"
      << std::format("A: {}; a: {}\n\n",
            std::regex_match("A", r4), std::regex_match("a", r4));

   // match metacharacters as literals in a custom character class
   std::regex r5{"[*+$]"};
   std::cout << "Matching against: [*+$]\n"
      << std::format("*: {}; !: {}\n\n",
            std::regex_match("*", r5), std::regex_match("!", r5));

   // matching a capital letter followed by at least one lowercase letter 
   std::regex r6{"[A-Z][a-z]+"};
   std::cout << "Matching against: [A-Z][a-z]+\n"
      << std::format("Angel: {}; T: {}\n\n",
            std::regex_match("Angel", r6), std::regex_match("T", r6));

   // matching zero or one occurrences of a subexpression
   std::regex r7{"labell?ed"};
   std::cout << "Matching against: labell?ed\n"
      << std::format("labelled: {}; labeled: {}; labellled: {}\n\n",
            std::regex_match("labelled", r7),
            std::regex_match("labeled", r7),
            std::regex_match("labellled", r7));

   // matching n (3) or more occurrences of a subexpression
   std::regex r8{R"(\d{3,})"};
   std::cout << R"(Matching against: \d{3,})" << "\n"
      << std::format("123: {}; 1234567890: {}; 12: {}\n\n",
            std::regex_match("123", r8),
            std::regex_match("1234567890", r8),
            std::regex_match("12", r8));

   // matching n to m inclusive (3-6), occurrences of a subexpression
   std::regex r9{R"(\d{3,6})"};
   std::cout << R"(Matching against: \d{3,6})" << "\n"
      << std::format("123: {}; 123456: {}; 1234567: {}; 12: {}\n",
            std::regex_match("123", r9), std::regex_match("123456", r9),
            std::regex_match("1234567", r9), std::regex_match("12", r9));
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_17.cpp
================================================
// fig08_17.cpp
// Regular expression replacements.
#include <format> 
#include <iostream>
#include <regex>
#include <string>

int main() {
   // replace tabs with commas
   std::string s1{"1\t2\t3\t4"};
   std::cout << std::format("Original string: {}\n", R"(1\t2\t3\t4)")
      << std::format("After replacing tabs with commas: {}\n",
            std::regex_replace(s1, std::regex{"\t"}, ","));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/fig08_18.cpp
================================================
// fig08_18.cpp
// Matching patterns throughout a string.
#include <format> 
#include <iostream>
#include <regex>
#include <string>

int main() {
   // performing a simple match
   std::string s1{"Programming is fun"};
   std::cout << std::format("s1: {}\n\n", s1);
   std::cout << "Search anywhere in s1:\n"
      << std::format("Programming: {}; fun: {}; fn: {}\n\n",
            std::regex_search(s1, std::regex{"Programming"}),
            std::regex_search(s1, std::regex{"fun"}),
            std::regex_search(s1, std::regex{"fn"}));

   // ignoring case
   std::string s2{"AZUEL MAGAR"};
   std::smatch match; // store the text that matches the pattern
   std::cout << std::format("s2: {}\n\n", s2);
   std::cout << "Case insensitive search for Azuel in s2:\n"
      << std::format("Azuel: {}\n", std::regex_search(s2, match,
            std::regex{"Azuel", std::regex_constants::icase}))
      << std::format("Matched text: {}\n\n", match.str());

   // finding all matches
   std::string contact{
      "Ando Devi, Home: 555-555-1234, Work: 555-555-4321"};
   std::regex phone{R"(\d{3}-\d{3}-\d{4})"};

   std::cout << std::format("Finding phone numbers in:\n{}\n", contact);
   while (std::regex_search(contact, match, phone)) {
      std::cout << std::format("   {}\n", match.str());
      contact = match.suffix();
   }
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson08/format.cc
================================================
// Formatting library for C++
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/format-inl.h"

FMT_BEGIN_NAMESPACE
namespace internal {

template <typename T>
int format_float(char* buf, std::size_t size, const char* format, int precision,
                 T value) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  if (precision > 100000)
    throw std::runtime_error(
        "fuzz mode - avoid large allocation inside snprintf");
#endif
  // Suppress the warning about nonliteral format string.
  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
  return precision < 0 ? snprintf_ptr(buf, size, format, value)
                       : snprintf_ptr(buf, size, format, precision, value);
}
struct sprintf_specs {
  int precision;
  char type;
  bool alt : 1;

  template <typename Char>
  constexpr sprintf_specs(basic_format_specs<Char> specs)
      : precision(specs.precision), type(specs.type), alt(specs.alt) {}

  constexpr bool has_precision() const { return precision >= 0; }
};

// This is deprecated and is kept only to preserve ABI compatibility.
template <typename Double>
char* sprintf_format(Double value, internal::buffer<char>& buf,
                     sprintf_specs specs) {
  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
  FMT_ASSERT(buf.capacity() != 0, "empty buffer");

  // Build format string.
  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
  char format[max_format_size];
  char* format_ptr = format;
  *format_ptr++ = '%';
  if (specs.alt || !specs.type) *format_ptr++ = '#';
  if (specs.precision >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }
  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';

  char type = specs.type;

  if (type == '%')
    type = 'f';
  else if (type == 0 || type == 'n')
    type = 'g';
#if FMT_MSC_VER
  if (type == 'F') {
    // MSVC's printf doesn't support 'F'.
    type = 'f';
  }
#endif
  *format_ptr++ = type;
  *format_ptr = '\0';

  // Format using snprintf.
  char* start = nullptr;
  char* decimal_point_pos = nullptr;
  for (;;) {
    std::size_t buffer_size = buf.capacity();
    start = &buf[0];
    int result =
        format_float(start, buffer_size, format, specs.precision, value);
    if (result >= 0) {
      unsigned n = internal::to_unsigned(result);
      if (n < buf.capacity()) {
        // Find the decimal point.
        auto p = buf.data(), end = p + n;
        if (*p == '+' || *p == '-') ++p;
        if (specs.type != 'a' && specs.type != 'A') {
          while (p < end && *p >= '0' && *p <= '9') ++p;
          if (p < end && *p != 'e' && *p != 'E') {
            decimal_point_pos = p;
            if (!specs.type) {
              // Keep only one trailing zero after the decimal point.
              ++p;
              if (*p == '0') ++p;
              while (p != end && *p >= '1' && *p <= '9') ++p;
              char* where = p;
              while (p != end && *p == '0') ++p;
              if (p == end || *p < '0' || *p > '9') {
                if (p != end) std::memmove(where, p, to_unsigned(end - p));
                n -= static_cast<unsigned>(p - where);
              }
            }
          }
        }
        buf.resize(n);
        break;  // The buffer is large enough - continue with formatting.
      }
      buf.reserve(n + 1);
    } else {
      // If result is negative we ask to increase the capacity by at least 1,
      // but as std::vector, the buffer grows exponentially.
      buf.reserve(buf.capacity() + 1);
    }
  }
  return decimal_point_pos;
}
}  // namespace internal

template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&,
                                                sprintf_specs);
template FMT_API char* internal::sprintf_format(long double,
                                                internal::buffer<char>&,
                                                sprintf_specs);

template struct FMT_INSTANTIATION_DEF_API internal::basic_data<void>;

// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
int (*instantiate_format_float)(double, int, internal::float_specs,
                                internal::buffer<char>&) =
    internal::format_float;

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
#endif

// Explicit instantiations for char.

template FMT_API std::string internal::grouping_impl<char>(locale_ref);
template FMT_API char internal::thousands_sep_impl(locale_ref);
template FMT_API char internal::decimal_point_impl(locale_ref);

template FMT_API void internal::buffer<char>::append(const char*, const char*);

template FMT_API void internal::arg_map<format_context>::init(
    const basic_format_args<format_context>& args);

template FMT_API std::string internal::vformat<char>(
    string_view, basic_format_args<format_context>);

template FMT_API format_context::iterator internal::vformat_to(
    internal::buffer<char>&, string_view, basic_format_args<format_context>);

template FMT_API int internal::snprintf_float(double, int,
                                              internal::float_specs,
                                              internal::buffer<char>&);
template FMT_API int internal::snprintf_float(long double, int,
                                              internal::float_specs,
                                              internal::buffer<char>&);
template FMT_API int internal::format_float(double, int, internal::float_specs,
                                            internal::buffer<char>&);
template FMT_API int internal::format_float(long double, int,
                                            internal::float_specs,
                                            internal::buffer<char>&);

// Explicit instantiations for wchar_t.

template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
template FMT_API wchar_t internal::decimal_point_impl(locale_ref);

template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*,
                                                        const wchar_t*);

template FMT_API std::wstring internal::vformat<wchar_t>(
    wstring_view, basic_format_args<wformat_context>);
FMT_END_NAMESPACE


================================================
FILE: examples/lesson08/titanic.csv
================================================
"pclass","survived","name","sex","age","sibsp","parch","ticket","fare","cabin","embarked","boat","body","home.dest"
1,1,"Allen, Miss. Elisabeth Walton","female",29,0,0,"24160",211.3375,"B5","S","2",?,"St Louis, MO"
1,1,"Allison, Master. Hudson Trevor","male",0.9167,1,2,"113781",151.55,"C22 C26","S","11",?,"Montreal, PQ / Chesterville, ON"
1,0,"Allison, Miss. Helen Loraine","female",2,1,2,"113781",151.55,"C22 C26","S",?,?,"Montreal, PQ / Chesterville, ON"
1,0,"Allison, Mr. Hudson Joshua Creighton","male",30,1,2,"113781",151.55,"C22 C26","S",?,135,"Montreal, PQ / Chesterville, ON"
1,0,"Allison, Mrs. Hudson J C (Bessie Waldo Daniels)","female",25,1,2,"113781",151.55,"C22 C26","S",?,?,"Montreal, PQ / Chesterville, ON"
1,1,"Anderson, Mr. Harry","male",48,0,0,"19952",26.55,"E12","S","3",?,"New York, NY"
1,1,"Andrews, Miss. Kornelia Theodosia","female",63,1,0,"13502",77.9583,"D7","S","10",?,"Hudson, NY"
1,0,"Andrews, Mr. Thomas Jr","male",39,0,0,"112050",0,"A36","S",?,?,"Belfast, NI"
1,1,"Appleton, Mrs. Edward Dale (Charlotte Lamson)","female",53,2,0,"11769",51.4792,"C101","S","D",?,"Bayside, Queens, NY"
1,0,"Artagaveytia, Mr. Ramon","male",71,0,0,"PC 17609",49.5042,?,"C",?,22,"Montevideo, Uruguay"
1,0,"Astor, Col. John Jacob","male",47,1,0,"PC 17757",227.525,"C62 C64","C",?,124,"New York, NY"
1,1,"Astor, Mrs. John Jacob (Madeleine Talmadge Force)","female",18,1,0,"PC 17757",227.525,"C62 C64","C","4",?,"New York, NY"
1,1,"Aubart, Mme. Leontine Pauline","female",24,0,0,"PC 17477",69.3,"B35","C","9",?,"Paris, France"
1,1,"Barber, Miss. Ellen 'Nellie'","female",26,0,0,"19877",78.85,?,"S","6",?,?
1,1,"Barkworth, Mr. Algernon Henry Wilson","male",80,0,0,"27042",30,"A23","S","B",?,"Hessle, Yorks"
1,0,"Baumann, Mr. John D","male",?,0,0,"PC 17318",25.925,?,"S",?,?,"New York, NY"
1,0,"Baxter, Mr. Quigg Edmond","male",24,0,1,"PC 17558",247.5208,"B58 B60","C",?,?,"Montreal, PQ"
1,1,"Baxter, Mrs. James (Helene DeLaudeniere Chaput)","female",50,0,1,"PC 17558",247.5208,"B58 B60","C","6",?,"Montreal, PQ"
1,1,"Bazzani, Miss. Albina","female",32,0,0,"11813",76.2917,"D15","C","8",?,?
1,0,"Beattie, Mr. Thomson","male",36,0,0,"13050",75.2417,"C6","C","A",?,"Winnipeg, MN"
1,1,"Beckwith, Mr. Richard Leonard","male",37,1,1,"11751",52.5542,"D35","S","5",?,"New York, NY"
1,1,"Beckwith, Mrs. Richard Leonard (Sallie Monypeny)","female",47,1,1,"11751",52.5542,"D35","S","5",?,"New York, NY"
1,1,"Behr, Mr. Karl Howell","male",26,0,0,"111369",30,"C148","C","5",?,"New York, NY"
1,1,"Bidois, Miss. Rosalie","female",42,0,0,"PC 17757",227.525,?,"C","4",?,?
1,1,"Bird, Miss. Ellen","female",29,0,0,"PC 17483",221.7792,"C97","S","8",?,?
1,0,"Birnbaum, Mr. Jakob","male",25,0,0,"13905",26,?,"C",?,148,"San Francisco, CA"
1,1,"Bishop, Mr. Dickinson H","male",25,1,0,"11967",91.0792,"B49","C","7",?,"Dowagiac, MI"
1,1,"Bishop, Mrs. Dickinson H (Helen Walton)","female",19,1,0,"11967",91.0792,"B49","C","7",?,"Dowagiac, MI"
1,1,"Bissette, Miss. Amelia","female",35,0,0,"PC 17760",135.6333,"C99","S","8",?,?
1,1,"Bjornstrom-Steffansson, Mr. Mauritz Hakan","male",28,0,0,"110564",26.55,"C52","S","D",?,"Stockholm, Sweden / Washington, DC"
1,0,"Blackwell, Mr. Stephen Weart","male",45,0,0,"113784",35.5,"T","S",?,?,"Trenton, NJ"
1,1,"Blank, Mr. Henry","male",40,0,0,"112277",31,"A31","C","7",?,"Glen Ridge, NJ"
1,1,"Bonnell, Miss. Caroline","female",30,0,0,"36928",164.8667,"C7","S","8",?,"Youngstown, OH"
1,1,"Bonnell, Miss. Elizabeth","female",58,0,0,"113783",26.55,"C103","S","8",?,"Birkdale, England Cleveland, Ohio"
1,0,"Borebank, Mr. John James","male",42,0,0,"110489",26.55,"D22","S",?,?,"London / Winnipeg, MB"
1,1,"Bowen, Miss. Grace Scott","female",45,0,0,"PC 17608",262.375,?,"C","4",?,"Cooperstown, NY"
1,1,"Bowerman, Miss. Elsie Edith","female",22,0,1,"113505",55,"E33","S","6",?,"St Leonards-on-Sea, England Ohio"
1,1,"Bradley, Mr. George ('George Arthur Brayton')","male",?,0,0,"111427",26.55,?,"S","9",?,"Los Angeles, CA"
1,0,"Brady, Mr. John Bertram","male",41,0,0,"113054",30.5,"A21","S",?,?,"Pomeroy, WA"
1,0,"Brandeis, Mr. Emil","male",48,0,0,"PC 17591",50.4958,"B10","C",?,208,"Omaha, NE"
1,0,"Brewe, Dr. Arthur Jackson","male",?,0,0,"112379",39.6,?,"C",?,?,"Philadelphia, PA"
1,1,"Brown, Mrs. James Joseph (Margaret Tobin)","female",44,0,0,"PC 17610",27.7208,"B4","C","6",?,"Denver, CO"
1,1,"Brown, Mrs. John Murray (Caroline Lane Lamson)","female",59,2,0,"11769",51.4792,"C101","S","D",?,"Belmont, MA"
1,1,"Bucknell, Mrs. William Robert (Emma Eliza Ward)","female",60,0,0,"11813",76.2917,"D15","C","8",?,"Philadelphia, PA"
1,1,"Burns, Miss. Elizabeth Margaret","female",41,0,0,"16966",134.5,"E40","C","3",?,?
1,0,"Butt, Major. Archibald Willingham","male",45,0,0,"113050",26.55,"B38","S",?,?,"Washington, DC"
1,0,"Cairns, Mr. Alexander","male",?,0,0,"113798",31,?,"S",?,?,?
1,1,"Calderhead, Mr. Edward Pennington","male",42,0,0,"PC 17476",26.2875,"E24","S","5",?,"New York, NY"
1,1,"Candee, Mrs. Edward (Helen Churchill Hungerford)","female",53,0,0,"PC 17606",27.4458,?,"C","6",?,"Washington, DC"
1,1,"Cardeza, Mr. Thomas Drake Martinez","male",36,0,1,"PC 17755",512.3292,"B51 B53 B55","C","3",?,"Austria-Hungary / Germantown, Philadelphia, PA"
1,1,"Cardeza, Mrs. James Warburton Martinez (Charlotte Wardle Drake)","female",58,0,1,"PC 17755",512.3292,"B51 B53 B55","C","3",?,"Germantown, Philadelphia, PA"
1,0,"Carlsson, Mr. Frans Olof","male",33,0,0,"695",5,"B51 B53 B55","S",?,?,"New York, NY"
1,0,"Carrau, Mr. Francisco M","male",28,0,0,"113059",47.1,?,"S",?,?,"Montevideo, Uruguay"
1,0,"Carrau, Mr. Jose Pedro","male",17,0,0,"113059",47.1,?,"S",?,?,"Montevideo, Uruguay"
1,1,"Carter, Master. William Thornton II","male",11,1,2,"113760",120,"B96 B98","S","4",?,"Bryn Mawr, PA"
1,1,"Carter, Miss. Lucile Polk","female",14,1,2,"113760",120,"B96 B98","S","4",?,"Bryn Mawr, PA"
1,1,"Carter, Mr. William Ernest","male",36,1,2,"113760",120,"B96 B98","S","C",?,"Bryn Mawr, PA"
1,1,"Carter, Mrs. William Ernest (Lucile Polk)","female",36,1,2,"113760",120,"B96 B98","S","4",?,"Bryn Mawr, PA"
1,0,"Case, Mr. Howard Brown","male",49,0,0,"19924",26,?,"S",?,?,"Ascot, Berkshire / Rochester, NY"
1,1,"Cassebeer, Mrs. Henry Arthur Jr (Eleanor Genevieve Fosdick)","female",?,0,0,"17770",27.7208,?,"C","5",?,"New York, NY"
1,0,"Cavendish, Mr. Tyrell William","male",36,1,0,"19877",78.85,"C46","S",?,172,"Little Onn Hall, Staffs"
1,1,"Cavendish, Mrs. Tyrell William (Julia Florence Siegel)","female",76,1,0,"19877",78.85,"C46","S","6",?,"Little Onn Hall, Staffs"
1,0,"Chaffee, Mr. Herbert Fuller","male",46,1,0,"W.E.P. 5734",61.175,"E31","S",?,?,"Amenia, ND"
1,1,"Chaffee, Mrs. Herbert Fuller (Carrie Constance Toogood)","female",47,1,0,"W.E.P. 5734",61.175,"E31","S","4",?,"Amenia, ND"
1,1,"Chambers, Mr. Norman Campbell","male",27,1,0,"113806",53.1,"E8","S","5",?,"New York, NY / Ithaca, NY"
1,1,"Chambers, Mrs. Norman Campbell (Bertha Griggs)","female",33,1,0,"113806",53.1,"E8","S","5",?,"New York, NY / Ithaca, NY"
1,1,"Chaudanson, Miss. Victorine","female",36,0,0,"PC 17608",262.375,"B61","C","4",?,?
1,1,"Cherry, Miss. Gladys","female",30,0,0,"110152",86.5,"B77","S","8",?,"London, England"
1,1,"Chevre, Mr. Paul Romaine","male",45,0,0,"PC 17594",29.7,"A9","C","7",?,"Paris, France"
1,1,"Chibnall, Mrs. (Edith Martha Bowerman)","female",?,0,1,"113505",55,"E33","S","6",?,"St Leonards-on-Sea, England Ohio"
1,0,"Chisholm, Mr. Roderick Robert Crispin","male",?,0,0,"112051",0,?,"S",?,?,"Liverpool, England / Belfast"
1,0,"Clark, Mr. Walter Miller","male",27,1,0,"13508",136.7792,"C89","C",?,?,"Los Angeles, CA"
1,1,"Clark, Mrs. Walter Miller (Virginia McDowell)","female",26,1,0,"13508",136.7792,"C89","C","4",?,"Los Angeles, CA"
1,1,"Cleaver, Miss. Alice","female",22,0,0,"113781",151.55,?,"S","11",?,?
1,0,"Clifford, Mr. George Quincy","male",?,0,0,"110465",52,"A14","S",?,?,"Stoughton, MA"
1,0,"Colley, Mr. Edward Pomeroy","male",47,0,0,"5727",25.5875,"E58","S",?,?,"Victoria, BC"
1,1,"Compton, Miss. Sara Rebecca","female",39,1,1,"PC 17756",83.1583,"E49","C","14",?,"Lakewood, NJ"
1,0,"Compton, Mr. Alexander Taylor Jr","male",37,1,1,"PC 17756",83.1583,"E52","C",?,?,"Lakewood, NJ"
1,1,"Compton, Mrs. Alexander Taylor (Mary Eliza Ingersoll)","female",64,0,2,"PC 17756",83.1583,"E45","C","14",?,"Lakewood, NJ"
1,1,"Cornell, Mrs. Robert Clifford (Malvina Helen Lamson)","female",55,2,0,"11770",25.7,"C101","S","2",?,"New York, NY"
1,0,"Crafton, Mr. John Bertram","male",?,0,0,"113791",26.55,?,"S",?,?,"Roachdale, IN"
1,0,"Crosby, Capt. Edward Gifford","male",70,1,1,"WE/P 5735",71,"B22","S",?,269,"Milwaukee, WI"
1,1,"Crosby, Miss. Harriet R","female",36,0,2,"WE/P 5735",71,"B22","S","7",?,"Milwaukee, WI"
1,1,"Crosby, Mrs. Edward Gifford (Catherine Elizabeth Halstead)","female",64,1,1,"112901",26.55,"B26","S","7",?,"Milwaukee, WI"
1,0,"Cumings, Mr. John Bradley","male",39,1,0,"PC 17599",71.2833,"C85","C",?,?,"New York, NY"
1,1,"Cumings, Mrs. John Bradley (Florence Briggs Thayer)","female",38,1,0,"PC 17599",71.2833,"C85","C","4",?,"New York, NY"
1,1,"Daly, Mr. Peter Denis","male",51,0,0,"113055",26.55,"E17","S","5 9",?,"Lima, Peru"
1,1,"Daniel, Mr. Robert Williams","male",27,0,0,"113804",30.5,?,"S","3",?,"Philadelphia, PA"
1,1,"Daniels, Miss. Sarah","female",33,0,0,"113781",151.55,?,"S","8",?,?
1,0,"Davidson, Mr. Thornton","male",31,1,0,"F.C. 12750",52,"B71","S",?,?,"Montreal, PQ"
1,1,"Davidson, Mrs. Thornton (Orian Hays)","female",27,1,2,"F.C. 12750",52,"B71","S","3",?,"Montreal, PQ"
1,1,"Dick, Mr. Albert Adrian","male",31,1,0,"17474",57,"B20","S","3",?,"Calgary, AB"
1,1,"Dick, Mrs. Albert Adrian (Vera Gillespie)","female",17,1,0,"17474",57,"B20","S","3",?,"Calgary, AB"
1,1,"Dodge, Dr. Washington","male",53,1,1,"33638",81.8583,"A34","S","13",?,"San Francisco, CA"
1,1,"Dodge, Master. Washington","male",4,0,2,"33638",81.8583,"A34","S","5",?,"San Francisco, CA"
1,1,"Dodge, Mrs. Washington (Ruth Vidaver)","female",54,1,1,"33638",81.8583,"A34","S","5",?,"San Francisco, CA"
1,0,"Douglas, Mr. Walter Donald","male",50,1,0,"PC 17761",106.425,"C86","C",?,62,"Deephaven, MN / Cedar Rapids, IA"
1,1,"Douglas, Mrs. Frederick Charles (Mary Helene Baxter)","female",27,1,1,"PC 17558",247.5208,"B58 B60","C","6",?,"Montreal, PQ"
1,1,"Douglas, Mrs. Walter Donald (Mahala Dutton)","female",48,1,0,"PC 17761",106.425,"C86","C","2",?,"Deephaven, MN / Cedar Rapids, IA"
1,1,"Duff Gordon, Lady. (Lucille Christiana Sutherland) ('Mrs Morgan')","female",48,1,0,"11755",39.6,"A16","C","1",?,"London / Paris"
1,1,"Duff Gordon, Sir. Cosmo Edmund ('Mr Morgan')","male",49,1,0,"PC 17485",56.9292,"A20","C","1",?,"London / Paris"
1,0,"Dulles, Mr. William Crothers","male",39,0,0,"PC 17580",29.7,"A18","C",?,133,"Philadelphia, PA"
1,1,"Earnshaw, Mrs. Boulton (Olive Potter)","female",23,0,1,"11767",83.1583,"C54","C","7",?,"Mt Airy, Philadelphia, PA"
1,1,"Endres, Miss. Caroline Louise","female",38,0,0,"PC 17757",227.525,"C45","C","4",?,"New York, NY"
1,1,"Eustis, Miss. Elizabeth Mussey","female",54,1,0,"36947",78.2667,"D20","C","4",?,"Brookline, MA"
1,0,"Evans, Miss. Edith Corse","female",36,0,0,"PC 17531",31.6792,"A29","C",?,?,"New York, NY"
1,0,"Farthing, Mr. John","male",?,0,0,"PC 17483",221.7792,"C95","S",?,?,?
1,1,"Flegenheim, Mrs. Alfred (Antoinette)","female",?,0,0,"PC 17598",31.6833,?,"S","7",?,"New York, NY"
1,1,"Fleming, Miss. Margaret","female",?,0,0,"17421",110.8833,?,"C","4",?,?
1,1,"Flynn, Mr. John Irwin ('Irving')","male",36,0,0,"PC 17474",26.3875,"E25","S","5",?,"Brooklyn, NY"
1,0,"Foreman, Mr. Benjamin Laventall","male",30,0,0,"113051",27.75,"C111","C",?,?,"New York, NY"
1,1,"Fortune, Miss. Alice Elizabeth","female",24,3,2,"19950",263,"C23 C25 C27","S","10",?,"Winnipeg, MB"
1,1,"Fortune, Miss. Ethel Flora","female",28,3,2,"19950",263,"C23 C25 C27","S","10",?,"Winnipeg, MB"
1,1,"Fortune, Miss. Mabel Helen","female",23,3,2,"19950",263,"C23 C25 C27","S","10",?,"Winnipeg, MB"
1,0,"Fortune, Mr. Charles Alexander","male",19,3,2,"19950",263,"C23 C25 C27","S",?,?,"Winnipeg, MB"
1,0,"Fortune, Mr. Mark","male",64,1,4,"19950",263,"C23 C25 C27","S",?,?,"Winnipeg, MB"
1,1,"Fortune, Mrs. Mark (Mary McDougald)","female",60,1,4,"19950",263,"C23 C25 C27","S","10",?,"Winnipeg, MB"
1,1,"Francatelli, Miss. Laura Mabel","female",30,0,0,"PC 17485",56.9292,"E36","C","1",?,?
1,0,"Franklin, Mr. Thomas Parham","male",?,0,0,"113778",26.55,"D34","S",?,?,"Westcliff-on-Sea, Essex"
1,1,"Frauenthal, Dr. Henry William","male",50,2,0,"PC 17611",133.65,?,"S","5",?,"New York, NY"
1,1,"Frauenthal, Mr. Isaac Gerald","male",43,1,0,"17765",27.7208,"D40","C","5",?,"New York, NY"
1,1,"Frauenthal, Mrs. Henry William (Clara Heinsheimer)","female",?,1,0,"PC 17611",133.65,?,"S","5",?,"New York, NY"
1,1,"Frolicher, Miss. Hedwig Margaritha","female",22,0,2,"13568",49.5,"B39","C","5",?,"Zurich, Switzerland"
1,1,"Frolicher-Stehli, Mr. Maxmillian","male",60,1,1,"13567",79.2,"B41","C","5",?,"Zurich, Switzerland"
1,1,"Frolicher-Stehli, Mrs. Maxmillian (Margaretha Emerentia Stehli)","female",48,1,1,"13567",79.2,"B41","C","5",?,"Zurich, Switzerland"
1,0,"Fry, Mr. Richard","male",?,0,0,"112058",0,"B102","S",?,?,?
1,0,"Futrelle, Mr. Jacques Heath","male",37,1,0,"113803",53.1,"C123","S",?,?,"Scituate, MA"
1,1,"Futrelle, Mrs. Jacques Heath (Lily May Peel)","female",35,1,0,"113803",53.1,"C123","S","D",?,"Scituate, MA"
1,0,"Gee, Mr. Arthur H","male",47,0,0,"111320",38.5,"E63","S",?,275,"St Anne's-on-Sea, Lancashire"
1,1,"Geiger, Miss. Amalie","female",35,0,0,"113503",211.5,"C130","C","4",?,?
1,1,"Gibson, Miss. Dorothy Winifred","female",22,0,1,"112378",59.4,?,"C","7",?,"New York, NY"
1,1,"Gibson, Mrs. Leonard (Pauline C Boeson)","female",45,0,1,"112378",59.4,?,"C","7",?,"New York, NY"
1,0,"Giglio, Mr. Victor","male",24,0,0,"PC 17593",79.2,"B86","C",?,?,?
1,1,"Goldenberg, Mr. Samuel L","male",49,1,0,"17453",89.1042,"C92","C","5",?,"Paris, France / New York, NY"
1,1,"Goldenberg, Mrs. Samuel L (Edwiga Grabowska)","female",?,1,0,"17453",89.1042,"C92","C","5",?,"Paris, France / New York, NY"
1,0,"Goldschmidt, Mr. George B","male",71,0,0,"PC 17754",34.6542,"A5","C",?,?,"New York, NY"
1,1,"Gracie, Col. Archibald IV","male",53,0,0,"113780",28.5,"C51","C","B",?,"Washington, DC"
1,1,"Graham, Miss. Margaret Edith","female",19,0,0,"112053",30,"B42","S","3",?,"Greenwich, CT"
1,0,"Graham, Mr. George Edward","male",38,0,1,"PC 17582",153.4625,"C91","S",?,147,"Winnipeg, MB"
1,1,"Graham, Mrs. William Thompson (Edith Junkins)","female",58,0,1,"PC 17582",153.4625,"C125","S","3",?,"Greenwich, CT"
1,1,"Greenfield, Mr. William Bertram","male",23,0,1,"PC 17759",63.3583,"D10 D12","C","7",?,"New York, NY"
1,1,"Greenfield, Mrs. Leo David (Blanche Strouse)","female",45,0,1,"PC 17759",63.3583,"D10 D12","C","7",?,"New York, NY"
1,0,"Guggenheim, Mr. Benjamin","male",46,0,0,"PC 17593",79.2,"B82 B84","C",?,?,"New York, NY"
1,1,"Harder, Mr. George Achilles","male",25,1,0,"11765",55.4417,"E50","C","5",?,"Brooklyn, NY"
1,1,"Harder, Mrs. George Achilles (Dorothy Annan)","female",25,1,0,"11765",55.4417,"E50","C","5",?,"Brooklyn, NY"
1,1,"Harper, Mr. Henry Sleeper","male",48,1,0,"PC 17572",76.7292,"D33","C","3",?,"New York, NY"
1,1,"Harper, Mrs. Henry Sleeper (Myna Haxtun)","female",49,1,0,"PC 17572",76.7292,"D33","C","3",?,"New York, NY"
1,0,"Harrington, Mr. Charles H","male",?,0,0,"113796",42.4,?,"S",?,?,?
1,0,"Harris, Mr. Henry Birkhardt","male",45,1,0,"36973",83.475,"C83","S",?,?,"New York, NY"
1,1,"Harris, Mrs. Henry Birkhardt (Irene Wallach)","female",35,1,0,"36973",83.475,"C83","S","D",?,"New York, NY"
1,0,"Harrison, Mr. William","male",40,0,0,"112059",0,"B94","S",?,110,?
1,1,"Hassab, Mr. Hammad","male",27,0,0,"PC 17572",76.7292,"D49","C","3",?,?
1,1,"Hawksford, Mr. Walter James","male",?,0,0,"16988",30,"D45","S","3",?,"Kingston, Surrey"
1,1,"Hays, Miss. Margaret Bechstein","female",24,0,0,"11767",83.1583,"C54","C","7",?,"New York, NY"
1,0,"Hays, Mr. Charles Melville","male",55,1,1,"12749",93.5,"B69","S",?,307,"Montreal, PQ"
1,1,"Hays, Mrs. Charles Melville (Clara Jennings Gregg)","female",52,1,1,"12749",93.5,"B69","S","3",?,"Montreal, PQ"
1,0,"Head, Mr. Christopher","male",42,0,0,"113038",42.5,"B11","S",?,?,"London / Middlesex"
1,0,"Hilliard, Mr. Herbert Henry","male",?,0,0,"17463",51.8625,"E46","S",?,?,"Brighton, MA"
1,0,"Hipkins, Mr. William Edward","male",55,0,0,"680",50,"C39","S",?,?,"London / Birmingham"
1,1,"Hippach, Miss. Jean Gertrude","female",16,0,1,"111361",57.9792,"B18","C","4",?,"Chicago, IL"
1,1,"Hippach, Mrs. Louis Albert (Ida Sophia Fischer)","female",44,0,1,"111361",57.9792,"B18","C","4",?,"Chicago, IL"
1,1,"Hogeboom, Mrs. John C (Anna Andrews)","female",51,1,0,"13502",77.9583,"D11","S","10",?,"Hudson, NY"
1,0,"Holverson, Mr. Alexander Oskar","male",42,1,0,"113789",52,?,"S",?,38,"New York, NY"
1,1,"Holverson, Mrs. Alexander Oskar (Mary Aline Towner)","female",35,1,0,"113789",52,?,"S","8",?,"New York, NY"
1,1,"Homer, Mr. Harry ('Mr E Haven')","male",35,0,0,"111426",26.55,?,"C","15",?,"Indianapolis, IN"
1,1,"Hoyt, Mr. Frederick Maxfield","male",38,1,0,"19943",90,"C93","S","D",?,"New York, NY /  Stamford CT"
1,0,"Hoyt, Mr. William Fisher","male",?,0,0,"PC 17600",30.6958,?,"C","14",?,"New York, NY"
1,1,"Hoyt, Mrs. Frederick Maxfield (Jane Anne Forby)","female",35,1,0,"19943",90,"C93","S","D",?,"New York, NY /  Stamford CT"
1,1,"Icard, Miss. Amelie","female",38,0,0,"113572",80,"B28",?,"6",?,?
1,0,"Isham, Miss. Ann Elizabeth","female",50,0,0,"PC 17595",28.7125,"C49","C",?,?,"Paris, France New York, NY"
1,1,"Ismay, Mr. Joseph Bruce","male",49,0,0,"112058",0,"B52 B54 B56","S","C",?,"Liverpool"
1,0,"Jones, Mr. Charles Cresson","male",46,0,0,"694",26,?,"S",?,80,"Bennington, VT"
1,0,"Julian, Mr. Henry Forbes","male",50,0,0,"113044",26,"E60","S",?,?,"London"
1,0,"Keeping, Mr. Edwin","male",32.5,0,0,"113503",211.5,"C132","C",?,45,?
1,0,"Kent, Mr. Edward Austin","male",58,0,0,"11771",29.7,"B37","C",?,258,"Buffalo, NY"
1,0,"Kenyon, Mr. Frederick R","male",41,1,0,"17464",51.8625,"D21","S",?,?,"Southington / Noank, CT"
1,1,"Kenyon, Mrs. Frederick R (Marion)","female",?,1,0,"17464",51.8625,"D21","S","8",?,"Southington / Noank, CT"
1,1,"Kimball, Mr. Edwin Nelson Jr","male",42,1,0,"11753",52.5542,"D19","S","5",?,"Boston, MA"
1,1,"Kimball, Mrs. Edwin Nelson Jr (Gertrude Parsons)","female",45,1,0,"11753",52.5542,"D19","S","5",?,"Boston, MA"
1,0,"Klaber, Mr. Herman","male",?,0,0,"113028",26.55,"C124","S",?,?,"Portland, OR"
1,1,"Kreuchen, Miss. Emilie","female",39,0,0,"24160",211.3375,?,"S","2",?,?
1,1,"Leader, Dr. Alice (Farnham)","female",49,0,0,"17465",25.9292,"D17","S","8",?,"New York, NY"
1,1,"LeRoy, Miss. Bertha","female",30,0,0,"PC 17761",106.425,?,"C","2",?,?
1,1,"Lesurer, Mr. Gustave J","male",35,0,0,"PC 17755",512.3292,"B101","C","3",?,?
1,0,"Lewy, Mr. Ervin G","male",?,0,0,"PC 17612",27.7208,?,"C",?,?,"Chicago, IL"
1,0,"Lindeberg-Lind, Mr. Erik Gustaf ('Mr Edward Lingrey')","male",42,0,0,"17475",26.55,?,"S",?,?,"Stockholm, Sweden"
1,1,"Lindstrom, Mrs. Carl Johan (Sigrid Posse)","female",55,0,0,"112377",27.7208,?,"C","6",?,"Stockholm, Sweden"
1,1,"Lines, Miss. Mary Conover","female",16,0,1,"PC 17592",39.4,"D28","S","9",?,"Paris, France"
1,1,"Lines, Mrs. Ernest H (Elizabeth Lindsey James)","female",51,0,1,"PC 17592",39.4,"D28","S","9",?,"Paris, France"
1,0,"Long, Mr. Milton Clyde","male",29,0,0,"113501",30,"D6","S",?,126,"Springfield, MA"
1,1,"Longley, Miss. Gretchen Fiske","female",21,0,0,"13502",77.9583,"D9","S","10",?,"Hudson, NY"
1,0,"Loring, Mr. Joseph Holland","male",30,0,0,"113801",45.5,?,"S",?,?,"London / New York, NY"
1,1,"Lurette, Miss. Elise","female",58,0,0,"PC 17569",146.5208,"B80","C",?,?,?
1,1,"Madill, Miss. Georgette Alexandra","female",15,0,1,"24160",211.3375,"B5","S","2",?,"St Louis, MO"
1,0,"Maguire, Mr. John Edward","male",30,0,0,"110469",26,"C106","S",?,?,"Brockton, MA"
1,1,"Maioni, Miss. Roberta","female",16,0,0,"110152",86.5,"B79","S","8",?,?
1,1,"Marechal, Mr. Pierre","male",?,0,0,"11774",29.7,"C47","C","7",?,"Paris, France"
1,0,"Marvin, Mr. Daniel Warner","male",19,1,0,"113773",53.1,"D30","S",?,?,"New York, NY"
1,1,"Marvin, Mrs. Daniel Warner (Mary Graham Carmichael Farquarson)","female",18,1,0,"113773",53.1,"D30","S","10",?,"New York, NY"
1,1,"Mayne, Mlle. Berthe Antonine ('Mrs de Villiers')","female",24,0,0,"PC 17482",49.5042,"C90","C","6",?,"Belgium  Montreal, PQ"
1,0,"McCaffry, Mr. Thomas Francis","male",46,0,0,"13050",75.2417,"C6","C",?,292,"Vancouver, BC"
1,0,"McCarthy, Mr. Timothy J","male",54,0,0,"17463",51.8625,"E46","S",?,175,"Dorchester, MA"
1,1,"McGough, Mr. James Robert","male",36,0,0,"PC 17473",26.2875,"E25","S","7",?,"Philadelphia, PA"
1,0,"Meyer, Mr. Edgar Joseph","male",28,1,0,"PC 17604",82.1708,?,"C",?,?,"New York, NY"
1,1,"Meyer, Mrs. Edgar Joseph (Leila Saks)","female",?,1,0,"PC 17604",82.1708,?,"C","6",?,"New York, NY"
1,0,"Millet, Mr. Francis Davis","male",65,0,0,"13509",26.55,"E38","S",?,249,"East Bridgewater, MA"
1,0,"Minahan, Dr. William Edward","male",44,2,0,"19928",90,"C78","Q",?,230,"Fond du Lac, WI"
1,1,"Minahan, Miss. Daisy E","female",33,1,0,"19928",90,"C78","Q","14",?,"Green Bay, WI"
1,1,"Minahan, Mrs. William Edward (Lillian E Thorpe)","female",37,1,0,"19928",90,"C78","Q","14",?,"Fond du Lac, WI"
1,1,"Mock, Mr. Philipp Edmund","male",30,1,0,"13236",57.75,"C78","C","11",?,"New York, NY"
1,0,"Molson, Mr. Harry Markland","male",55,0,0,"113787",30.5,"C30","S",?,?,"Montreal, PQ"
1,0,"Moore, Mr. Clarence Bloomfield","male",47,0,0,"113796",42.4,?,"S",?,?,"Washington, DC"
1,0,"Natsch, Mr. Charles H","male",37,0,1,"PC 17596",29.7,"C118","C",?,?,"Brooklyn, NY"
1,1,"Newell, Miss. Madeleine","female",31,1,0,"35273",113.275,"D36","C","6",?,"Lexington, MA"
1,1,"Newell, Miss. Marjorie","female",23,1,0,"35273",113.275,"D36","C","6",?,"Lexington, MA"
1,0,"Newell, Mr. Arthur Webster","male",58,0,2,"35273",113.275,"D48","C",?,122,"Lexington, MA"
1,1,"Newsom, Miss. Helen Monypeny","female",19,0,2,"11752",26.2833,"D47","S","5",?,"New York, NY"
1,0,"Nicholson, Mr. Arthur Ernest","male",64,0,0,"693",26,?,"S",?,263,"Isle of Wight, England"
1,1,"Oliva y Ocana, Dona. Fermina","female",39,0,0,"PC 17758",108.9,"C105","C","8",?,?
1,1,"Omont, Mr. Alfred Fernand","male",?,0,0,"F.C. 12998",25.7417,?,"C","7",?,"Paris, France"
1,1,"Ostby, Miss. Helene Ragnhild","female",22,0,1,"113509",61.9792,"B36","C","5",?,"Providence, RI"
1,0,"Ostby, Mr. Engelhart Cornelius","male",65,0,1,"113509",61.9792,"B30","C",?,234,"Providence, RI"
1,0,"Ovies y Rodriguez, Mr. Servando","male",28.5,0,0,"PC 17562",27.7208,"D43","C",?,189,"?Havana, Cuba"
1,0,"Parr, Mr. William Henry Marsh","male",?,0,0,"112052",0,?,"S",?,?,"Belfast"
1,0,"Partner, Mr. Austen","male",45.5,0,0,"113043",28.5,"C124","S",?,166,"Surbiton Hill, Surrey"
1,0,"Payne, Mr. Vivian Ponsonby","male",23,0,0,"12749",93.5,"B24","S",?,?,"Montreal, PQ"
1,0,"Pears, Mr. Thomas Clinton","male",29,1,0,"113776",66.6,"C2","S",?,?,"Isleworth, England"
1,1,"Pears, Mrs. Thomas (Edith Wearne)","female",22,1,0,"113776",66.6,"C2","S","8",?,"Isleworth, England"
1,0,"Penasco y Castellana, Mr. Victor de Satode","male",18,1,0,"PC 17758",108.9,"C65","C",?,?,"Madrid, Spain"
1,1,"Penasco y Castellana, Mrs. Victor de Satode (Maria Josefa Perez de Soto y Vallejo)","female",17,1,0,"PC 17758",108.9,"C65","C","8",?,"Madrid, Spain"
1,1,"Perreault, Miss. Anne","female",30,0,0,"12749",93.5,"B73","S","3",?,?
1,1,"Peuchen, Major. Arthur Godfrey","male",52,0,0,"113786",30.5,"C104","S","6",?,"Toronto, ON"
1,0,"Porter, Mr. Walter Chamberlain","male",47,0,0,"110465",52,"C110","S",?,207,"Worcester, MA"
1,1,"Potter, Mrs. Thomas Jr (Lily Alexenia Wilson)","female",56,0,1,"11767",83.1583,"C50","C","7",?,"Mt Airy, Philadelphia, PA"
1,0,"Reuchlin, Jonkheer. John George","male",38,0,0,"19972",0,?,"S",?,?,"Rotterdam, Netherlands"
1,1,"Rheims, Mr. George Alexander Lucien","male",?,0,0,"PC 17607",39.6,?,"S","A",?,"Paris /  New York, NY"
1,0,"Ringhini, Mr. Sante","male",22,0,0,"PC 17760",135.6333,?,"C",?,232,?
1,0,"Robbins, Mr. Victor","male",?,0,0,"PC 17757",227.525,?,"C",?,?,?
1,1,"Robert, Mrs. Edward Scott (Elisabeth Walton McMillan)","female",43,0,1,"24160",211.3375,"B3","S","2",?,"St Louis, MO"
1,0,"Roebling, Mr. Washington Augustus II","male",31,0,0,"PC 17590",50.4958,"A24","S",?,?,"Trenton, NJ"
1,1,"Romaine, Mr. Charles Hallace ('Mr C Rolmane')","male",45,0,0,"111428",26.55,?,"S","9",?,"New York, NY"
1,0,"Rood, Mr. Hugh Roscoe","male",?,0,0,"113767",50,"A32","S",?,?,"Seattle, WA"
1,1,"Rosenbaum, Miss. Edith Louise","female",33,0,0,"PC 17613",27.7208,"A11","C","11",?,"Paris, France"
1,0,"Rosenshine, Mr. George ('Mr George Thorne')","male",46,0,0,"PC 17585",79.2,?,"C",?,16,"New York, NY"
1,0,"Ross, Mr. John Hugo","male",36,0,0,"13049",40.125,"A10","C",?,?,"Winnipeg, MB"
1,1,"Rothes, the Countess. of (Lucy Noel Martha Dyer-Edwards)","female",33,0,0,"110152",86.5,"B77","S","8",?,"London  Vancouver, BC"
1,0,"Rothschild, Mr. Martin","male",55,1,0,"PC 17603",59.4,?,"C",?,?,"New York, NY"
1,1,"Rothschild, Mrs. Martin (Elizabeth L. Barrett)","female",54,1,0,"PC 17603",59.4,?,"C","6",?,"New York, NY"
1,0,"Rowe, Mr. Alfred G","male",33,0,0,"113790",26.55,?,"S",?,109,"London"
1,1,"Ryerson, Master. John Borie","male",13,2,2,"PC 17608",262.375,"B57 B59 B63 B66","C","4",?,"Haverford, PA / Cooperstown, NY"
1,1,"Ryerson, Miss. Emily Borie","female",18,2,2,"PC 17608",262.375,"B57 B59 B63 B66","C","4",?,"Haverford, PA / Cooperstown, NY"
1,1,"Ryerson, Miss. Susan Parker 'Suzette'","female",21,2,2,"PC 17608",262.375,"B57 B59 B63 B66","C","4",?,"Haverford, PA / Cooperstown, NY"
1,0,"Ryerson, Mr. Arthur Larned","male",61,1,3,"PC 17608",262.375,"B57 B59 B63 B66","C",?,?,"Haverford, PA / Cooperstown, NY"
1,1,"Ryerson, Mrs. Arthur Larned (Emily Maria Borie)","female",48,1,3,"PC 17608",262.375,"B57 B59 B63 B66","C","4",?,"Haverford, PA / Cooperstown, NY"
1,1,"Saalfeld, Mr. Adolphe","male",?,0,0,"19988",30.5,"C106","S","3",?,"Manchester, England"
1,1,"Sagesser, Mlle. Emma","female",24,0,0,"PC 17477",69.3,"B35","C","9",?,?
1,1,"Salomon, Mr. Abraham L","male",?,0,0,"111163",26,?,"S","1",?,"New York, NY"
1,1,"Schabert, Mrs. Paul (Emma Mock)","female",35,1,0,"13236",57.75,"C28","C","11",?,"New York, NY"
1,1,"Serepeca, Miss. Augusta","female",30,0,0,"113798",31,?,"C","4",?,?
1,1,"Seward, Mr. Frederic Kimber","male",34,0,0,"113794",26.55,?,"S","7",?,"New York, NY"
1,1,"Shutes, Miss. Elizabeth W","female",40,0,0,"PC 17582",153.4625,"C125","S","3",?,"New York, NY / Greenwich CT"
1,1,"Silverthorne, Mr. Spencer Victor","male",35,0,0,"PC 17475",26.2875,"E24","S","5",?,"St Louis, MO"
1,0,"Silvey, Mr. William Baird","male",50,1,0,"13507",55.9,"E44","S",?,?,"Duluth, MN"
1,1,"Silvey, Mrs. William Baird (Alice Munger)","female",39,1,0,"13507",55.9,"E44","S","11",?,"Duluth, MN"
1,1,"Simonius-Blumer, Col. Oberst Alfons","male",56,0,0,"13213",35.5,"A26","C","3",?,"Basel, Switzerland"
1,1,"Sloper, Mr. William Thompson","male",28,0,0,"113788",35.5,"A6","S","7",?,"New Britain, CT"
1,0,"Smart, Mr. John Montgomery","male",56,0,0,"113792",26.55,?,"S",?,?,"New York, NY"
1,0,"Smith, Mr. James Clinch","male",56,0,0,"17764",30.6958,"A7","C",?,?,"St James, Long Island, NY"
1,0,"Smith, Mr. Lucien Philip","male",24,1,0,"13695",60,"C31","S",?,?,"Huntington, WV"
1,0,"Smith, Mr. Richard William","male",?,0,0,"113056",26,"A19","S",?,?,"Streatham, Surrey"
1,1,"Smith, Mrs. Lucien Philip (Mary Eloise Hughes)","female",18,1,0,"13695",60,"C31","S","6",?,"Huntington, WV"
1,1,"Snyder, Mr. John Pillsbury","male",24,1,0,"21228",82.2667,"B45","S","7",?,"Minneapolis, MN"
1,1,"Snyder, Mrs. John Pillsbury (Nelle Stevenson)","female",23,1,0,"21228",82.2667,"B45","S","7",?,"Minneapolis, MN"
1,1,"Spedden, Master. Robert Douglas","male",6,0,2,"16966",134.5,"E34","C","3",?,"Tuxedo Park, NY"
1,1,"Spedden, Mr. Frederic Oakley","male",45,1,1,"16966",134.5,"E34","C","3",?,"Tuxedo Park, NY"
1,1,"Spedden, Mrs. Frederic Oakley (Margaretta Corning Stone)","female",40,1,1,"16966",134.5,"E34","C","3",?,"Tuxedo Park, NY"
1,0,"Spencer, Mr. William Augustus","male",57,1,0,"PC 17569",146.5208,"B78","C",?,?,"Paris, France"
1,1,"Spencer, Mrs. William Augustus (Marie Eugenie)","female",?,1,0,"PC 17569",146.5208,"B78","C","6",?,"Paris, France"
1,1,"Stahelin-Maeglin, Dr. Max","male",32,0,0,"13214",30.5,"B50","C","3",?,"Basel, Switzerland"
1,0,"Stead, Mr. William Thomas","male",62,0,0,"113514",26.55,"C87","S",?,?,"Wimbledon Park, London / Hayling Island, Hants"
1,1,"Stengel, Mr. Charles Emil Henry","male",54,1,0,"11778",55.4417,"C116","C","1",?,"Newark, NJ"
1,1,"Stengel, Mrs. Charles Emil Henry (Annie May Morris)","female",43,1,0,"11778",55.4417,"C116","C","5",?,"Newark, NJ"
1,1,"Stephenson, Mrs. Walter Bertram (Martha Eustis)","female",52,1,0,"36947",78.2667,"D20","C","4",?,"Haverford, PA"
1,0,"Stewart, Mr. Albert A","male",?,0,0,"PC 17605",27.7208,?,"C",?,?,"Gallipolis, Ohio / ? Paris / New York"
1,1,"Stone, Mrs. George Nelson (Martha Evelyn)","female",62,0,0,"113572",80,"B28",?,"6",?,"Cincinatti, OH"
1,0,"Straus, Mr. Isidor","male",67,1,0,"PC 17483",221.7792,"C55 C57","S",?,96,"New York, NY"
1,0,"Straus, Mrs. Isidor (Rosalie Ida Blun)","female",63,1,0,"PC 17483",221.7792,"C55 C57","S",?,?,"New York, NY"
1,0,"Sutton, Mr. Frederick","male",61,0,0,"36963",32.3208,"D50","S",?,46,"Haddenfield, NJ"
1,1,"Swift, Mrs. Frederick Joel (Margaret Welles Barron)","female",48,0,0,"17466",25.9292,"D17","S","8",?,"Brooklyn, NY"
1,1,"Taussig, Miss. Ruth","female",18,0,2,"110413",79.65,"E68","S","8",?,"New York, NY"
1,0,"Taussig, Mr. Emil","male",52,1,1,"110413",79.65,"E67","S",?,?,"New York, NY"
1,1,"Taussig, Mrs. Emil (Tillie Mandelbaum)","female",39,1,1,"110413",79.65,"E67","S","8",?,"New York, NY"
1,1,"Taylor, Mr. Elmer Zebley","male",48,1,0,"19996",52,"C126","S","5 7",?,"London /  East Orange, NJ"
1,1,"Taylor, Mrs. Elmer Zebley (Juliet Cummins Wright)","female",?,1,0,"19996",52,"C126","S","5 7",?,"London /  East Orange, NJ"
1,0,"Thayer, Mr. John Borland","male",49,1,1,"17421",110.8833,"C68","C",?,?,"Haverford, PA"
1,1,"Thayer, Mr. John Borland Jr","male",17,0,2,"17421",110.8833,"C70","C","B",?,"Haverford, PA"
1,1,"Thayer, Mrs. John Borland (Marian Longstreth Morris)","female",39,1,1,"17421",110.8833,"C68","C","4",?,"Haverford, PA"
1,1,"Thorne, Mrs. Gertrude Maybelle","female",?,0,0,"PC 17585",79.2,?,"C","D",?,"New York, NY"
1,1,"Tucker, Mr. Gilbert Milligan Jr","male",31,0,0,"2543",28.5375,"C53","C","7",?,"Albany, NY"
1,0,"Uruchurtu, Don. Manuel E","male",40,0,0,"PC 17601",27.7208,?,"C",?,?,"Mexico City, Mexico"
1,0,"Van der hoef, Mr. Wyckoff","male",61,0,0,"111240",33.5,"B19","S",?,245,"Brooklyn, NY"
1,0,"Walker, Mr. William Anderson","male",47,0,0,"36967",34.0208,"D46","S",?,?,"East Orange, NJ"
1,1,"Ward, Miss. Anna","female",35,0,0,"PC 17755",512.3292,?,"C","3",?,?
1,0,"Warren, Mr. Frank Manley","male",64,1,0,"110813",75.25,"D37","C",?,?,"Portland, OR"
1,1,"Warren, Mrs. Frank Manley (Anna Sophia Atkinson)","female",60,1,0,"110813",75.25,"D37","C","5",?,"Portland, OR"
1,0,"Weir, Col. John","male",60,0,0,"113800",26.55,?,"S",?,?,"England Salt Lake City, Utah"
1,0,"White, Mr. Percival Wayland","male",54,0,1,"35281",77.2875,"D26","S",?,?,"Brunswick, ME"
1,0,"White, Mr. Richard Frasar","male",21,0,1,"35281",77.2875,"D26","S",?,169,"Brunswick, ME"
1,1,"White, Mrs. John Stuart (Ella Holmes)","female",55,0,0,"PC 17760",135.6333,"C32","C","8",?,"New York, NY / Briarcliff Manor NY"
1,1,"Wick, Miss. Mary Natalie","female",31,0,2,"36928",164.8667,"C7","S","8",?,"Youngstown, OH"
1,0,"Wick, Mr. George Dennick","male",57,1,1,"36928",164.8667,?,"S",?,?,"Youngstown, OH"
1,1,"Wick, Mrs. George Dennick (Mary Hitchcock)","female",45,1,1,"36928",164.8667,?,"S","8",?,"Youngstown, OH"
1,0,"Widener, Mr. George Dunton","male",50,1,1,"113503",211.5,"C80","C",?,?,"Elkins Park, PA"
1,0,"Widener, Mr. Harry Elkins","male",27,0,2,"113503",211.5,"C82","C",?,?,"Elkins Park, PA"
1,1,"Widener, Mrs. George Dunton (Eleanor Elkins)","female",50,1,1,"113503",211.5,"C80","C","4",?,"Elkins Park, PA"
1,1,"Willard, Miss. Constance","female",21,0,0,"113795",26.55,?,"S","8 10",?,"Duluth, MN"
1,0,"Williams, Mr. Charles Duane","male",51,0,1,"PC 17597",61.3792,?,"C",?,?,"Geneva, Switzerland / Radnor, PA"
1,1,"Williams, Mr. Richard Norris II","male",21,0,1,"PC 17597",61.3792,?,"C","A",?,"Geneva, Switzerland / Radnor, PA"
1,0,"Williams-Lambert, Mr. Fletcher Fellows","male",?,0,0,"113510",35,"C128","S",?,?,"London, England"
1,1,"Wilson, Miss. Helen Alice","female",31,0,0,"16966",134.5,"E39 E41","C","3",?,?
1,1,"Woolner, Mr. Hugh","male",?,0,0,"19947",35.5,"C52","S","D",?,"London, England"
1,0,"Wright, Mr. George","male",62,0,0,"113807",26.55,?,"S",?,?,"Halifax, NS"
1,1,"Young, Miss. Marie Grice","female",36,0,0,"PC 17760",135.6333,"C32","C","8",?,"New York, NY / Washington, DC"
2,0,"Abelson, Mr. Samuel","male",30,1,0,"P/PP 3381",24,?,"C",?,?,"Russia New York, NY"
2,1,"Abelson, Mrs. Samuel (Hannah Wizosky)","female",28,1,0,"P/PP 3381",24,?,"C","10",?,"Russia New York, NY"
2,0,"Aldworth, Mr. Charles Augustus","male",30,0,0,"248744",13,?,"S",?,?,"Bryn Mawr, PA, USA"
2,0,"Andrew, Mr. Edgardo Samuel","male",18,0,0,"231945",11.5,?,"S",?,?,"Buenos Aires, Argentina / New Jersey, NJ"
2,0,"Andrew, Mr. Frank Thomas","male",25,0,0,"C.A. 34050",10.5,?,"S",?,?,"Cornwall, England Houghton, MI"
2,0,"Angle, Mr. William A","male",34,1,0,"226875",26,?,"S",?,?,"Warwick, England"
2,1,"Angle, Mrs. William A (Florence 'Mary' Agnes Hughes)","female",36,1,0,"226875",26,?,"S","11",?,"Warwick, England"
2,0,"Ashby, Mr. John","male",57,0,0,"244346",13,?,"S",?,?,"West Hoboken, NJ"
2,0,"Bailey, Mr. Percy Andrew","male",18,0,0,"29108",11.5,?,"S",?,?,"Penzance, Cornwall / Akron, OH"
2,0,"Baimbrigge, Mr. Charles Robert","male",23,0,0,"C.A. 31030",10.5,?,"S",?,?,"Guernsey"
2,1,"Ball, Mrs. (Ada E Hall)","female",36,0,0,"28551",13,"D","S","10",?,"Bristol, Avon / Jacksonville, FL"
2,0,"Banfield, Mr. Frederick James","male",28,0,0,"C.A./SOTON 34068",10.5,?,"S",?,?,"Plymouth, Dorset / Houghton, MI"
2,0,"Bateman, Rev. Robert James","male",51,0,0,"S.O.P. 1166",12.525,?,"S",?,174,"Jacksonville, FL"
2,1,"Beane, Mr. Edward","male",32,1,0,"2908",26,?,"S","13",?,"Norwich / New York, NY"
2,1,"Beane, Mrs. Edward (Ethel Clarke)","female",19,1,0,"2908",26,?,"S","13",?,"Norwich / New York, NY"
2,0,"Beauchamp, Mr. Henry James","male",28,0,0,"244358",26,?,"S",?,?,"England"
2,1,"Becker, Master. Richard F","male",1,2,1,"230136",39,"F4","S","11",?,"Guntur, India / Benton Harbour, MI"
2,1,"Becker, Miss. Marion Louise","female",4,2,1,"230136",39,"F4","S","11",?,"Guntur, India / Benton Harbour, MI"
2,1,"Becker, Miss. Ruth Elizabeth","female",12,2,1,"230136",39,"F4","S","13",?,"Guntur, India / Benton Harbour, MI"
2,1,"Becker, Mrs. Allen Oliver (Nellie E Baumgardner)","female",36,0,3,"230136",39,"F4","S","11",?,"Guntur, India / Benton Harbour, MI"
2,1,"Beesley, Mr. Lawrence","male",34,0,0,"248698",13,"D56","S","13",?,"London"
2,1,"Bentham, Miss. Lilian W","female",19,0,0,"28404",13,?,"S","12",?,"Rochester, NY"
2,0,"Berriman, Mr. William John","male",23,0,0,"28425",13,?,"S",?,?,"St Ives, Cornwall / Calumet, MI"
2,0,"Botsford, Mr. William Hull","male",26,0,0,"237670",13,?,"S",?,?,"Elmira, NY / Orange, NJ"
2,0,"Bowenur, Mr. Solomon","male",42,0,0,"211535",13,?,"S",?,?,"London"
2,0,"Bracken, Mr. James H","male",27,0,0,"220367",13,?,"S",?,?,"Lake Arthur, Chavez County, NM"
2,1,"Brown, Miss. Amelia 'Mildred'","female",24,0,0,"248733",13,"F33","S","11",?,"London / Montreal, PQ"
2,1,"Brown, Miss. Edith Eileen","female",15,0,2,"29750",39,?,"S","14",?,"Cape Town, South Africa / Seattle, WA"
2,0,"Brown, Mr. Thomas William Solomon","male",60,1,1,"29750",39,?,"S",?,?,"Cape Town, South Africa / Seattle, WA"
2,1,"Brown, Mrs. Thomas William Solomon (Elizabeth Catherine Ford)","female",40,1,1,"29750",39,?,"S","14",?,"Cape Town, South Africa / Seattle, WA"
2,1,"Bryhl, Miss. Dagmar Jenny Ingeborg","female",20,1,0,"236853",26,?,"S","12",?,"Skara, Sweden / Rockford, IL"
2,0,"Bryhl, Mr. Kurt Arnold Gottfrid","male",25,1,0,"236853",26,?,"S",?,?,"Skara, Sweden / Rockford, IL"
2,1,"Buss, Miss. Kate","female",36,0,0,"27849",13,?,"S","9",?,"Sittingbourne, England / San Diego, CA"
2,0,"Butler, Mr. Reginald Fenton","male",25,0,0,"234686",13,?,"S",?,97,"Southsea, Hants"
2,0,"Byles, Rev. Thomas Roussel Davids","male",42,0,0,"244310",13,?,"S",?,?,"London"
2,1,"Bystrom, Mrs. (Karolina)","female",42,0,0,"236852",13,?,"S",?,?,"New York, NY"
2,1,"Caldwell, Master. Alden Gates","male",0.8333,0,2,"248738",29,?,"S","13",?,"Bangkok, Thailand / Roseville, IL"
2,1,"Caldwell, Mr. Albert Francis","male",26,1,1,"248738",29,?,"S","13",?,"Bangkok, Thailand / Roseville, IL"
2,1,"Caldwell, Mrs. Albert Francis (Sylvia Mae Harbaugh)","female",22,1,1,"248738",29,?,"S","13",?,"Bangkok, Thailand / Roseville, IL"
2,1,"Cameron, Miss. Clear Annie","female",35,0,0,"F.C.C. 13528",21,?,"S","14",?,"Mamaroneck, NY"
2,0,"Campbell, Mr. William","male",?,0,0,"239853",0,?,"S",?,?,"Belfast"
2,0,"Carbines, Mr. William","male",19,0,0,"28424",13,?,"S",?,18,"St Ives, Cornwall / Calumet, MI"
2,0,"Carter, Mrs. Ernest Courtenay (Lilian Hughes)","female",44,1,0,"244252",26,?,"S",?,?,"London"
2,0,"Carter, Rev. Ernest Courtenay","male",54,1,0,"244252",26,?,"S",?,?,"London"
2,0,"Chapman, Mr. Charles Henry","male",52,0,0,"248731",13.5,?,"S",?,130,"Bronx, NY"
2,0,"Chapman, Mr. John Henry","male",37,1,0,"SC/AH 29037",26,?,"S",?,17,"Cornwall / Spokane, WA"
2,0,"Chapman, Mrs. John Henry (Sara Elizabeth Lawry)","female",29,1,0,"SC/AH 29037",26,?,"S",?,?,"Cornwall / Spokane, WA"
2,1,"Christy, Miss. Julie Rachel","female",25,1,1,"237789",30,?,"S","12",?,"London"
2,1,"Christy, Mrs. (Alice Frances)","female",45,0,2,"237789",30,?,"S","12",?,"London"
2,0,"Clarke, Mr. Charles Valentine","male",29,1,0,"2003",26,?,"S",?,?,"England / San Francisco, CA"
2,1,"Clarke, Mrs. Charles V (Ada Maria Winfield)","female",28,1,0,"2003",26,?,"S","14",?,"England / San Francisco, CA"
2,0,"Coleridge, Mr. Reginald Charles","male",29,0,0,"W./C. 14263",10.5,?,"S",?,?,"Hartford, Huntingdonshire"
2,0,"Collander, Mr. Erik Gustaf","male",28,0,0,"248740",13,?,"S",?,?,"Helsinki, Finland Ashtabula, Ohio"
2,1,"Collett, Mr. Sidney C Stuart","male",24,0,0,"28034",10.5,?,"S","9",?,"London / Fort Byron, NY"
2,1,"Collyer, Miss. Marjorie 'Lottie'","female",8,0,2,"C.A. 31921",26.25,?,"S","14",?,"Bishopstoke, Hants / Fayette Valley, ID"
2,0,"Collyer, Mr. Harvey","male",31,1,1,"C.A. 31921",26.25,?,"S",?,?,"Bishopstoke, Hants / Fayette Valley, ID"
2,1,"Collyer, Mrs. Harvey (Charlotte Annie Tate)","female",31,1,1,"C.A. 31921",26.25,?,"S","14",?,"Bishopstoke, Hants / Fayette Valley, ID"
2,1,"Cook, Mrs. (Selena Rogers)","female",22,0,0,"W./C. 14266",10.5,"F33","S","14",?,"Pennsylvania"
2,0,"Corbett, Mrs. Walter H (Irene Colvin)","female",30,0,0,"237249",13,?,"S",?,?,"Provo, UT"
2,0,"Corey, Mrs. Percy C (Mary Phyllis Elizabeth Miller)","female",?,0,0,"F.C.C. 13534",21,?,"S",?,?,"Upper Burma, India Pittsburgh, PA"
2,0,"Cotterill, Mr. Henry 'Harry'","male",21,0,0,"29107",11.5,?,"S",?,?,"Penzance, Cornwall / Akron, OH"
2,0,"Cunningham, Mr. Alfred Fleming","male",?,0,0,"239853",0,?,"S",?,?,"Belfast"
2,1,"Davies, Master. John Morgan Jr","male",8,1,1,"C.A. 33112",36.75,?,"S","14",?,"St Ives, Cornwall / Hancock, MI"
2,0,"Davies, Mr. Charles Henry","male",18,0,0,"S.O.C. 14879",73.5,?,"S",?,?,"Lyndhurst, England"
2,1,"Davies, Mrs. John Morgan (Elizabeth Agnes Mary White)","female",48,0,2,"C.A. 33112",36.75,?,"S","14",?,"St Ives, Cornwall / Hancock, MI"
2,1,"Davis, Miss. Mary","female",28,0,0,"237668",13,?,"S","13",?,"London / Staten Island, NY"
2,0,"de Brito, Mr. Jose Joaquim","male",32,0,0,"244360",13,?,"S",?,?,"Portugal / Sau Paulo, Brazil"
2,0,"Deacon, Mr. Percy William","male",17,0,0,"S.O.C. 14879",73.5,?,"S",?,?,?
2,0,"del Carlo, Mr. Sebastiano","male",29,1,0,"SC/PARIS 2167",27.7208,?,"C",?,295,"Lucca, Italy / California"
2,1,"del Carlo, Mrs. Sebastiano (Argenia Genovesi)","female",24,1,0,"SC/PARIS 2167",27.7208,?,"C","12",?,"Lucca, Italy / California"
2,0,"Denbury, Mr. Herbert","male",25,0,0,"C.A. 31029",31.5,?,"S",?,?,"Guernsey / Elizabeth, NJ"
2,0,"Dibden, Mr. William","male",18,0,0,"S.O.C. 14879",73.5,?,"S",?,?,"New Forest, England"
2,1,"Doling, Miss. Elsie","female",18,0,1,"231919",23,?,"S",?,?,"Southampton"
2,1,"Doling, Mrs. John T (Ada Julia Bone)","female",34,0,1,"231919",23,?,"S",?,?,"Southampton"
2,0,"Downton, Mr. William James","male",54,0,0,"28403",26,?,"S",?,?,"Holley, NY"
2,1,"Drew, Master. Marshall Brines","male",8,0,2,"28220",32.5,?,"S","10",?,"Greenport, NY"
2,0,"Drew, Mr. James Vivian","male",42,1,1,"28220",32.5,?,"S",?,?,"Greenport, NY"
2,1,"Drew, Mrs. James Vivian (Lulu Thorne Christian)","female",34,1,1,"28220",32.5,?,"S","10",?,"Greenport, NY"
2,1,"Duran y More, Miss. Asuncion","female",27,1,0,"SC/PARIS 2149",13.8583,?,"C","12",?,"Barcelona, Spain / Havana, Cuba"
2,1,"Duran y More, Miss. Florentina","female",30,1,0,"SC/PARIS 2148",13.8583,?,"C","12",?,"Barcelona, Spain / Havana, Cuba"
2,0,"Eitemiller, Mr. George Floyd","male",23,0,0,"29751",13,?,"S",?,?,"England / Detroit, MI"
2,0,"Enander, Mr. Ingvar","male",21,0,0,"236854",13,?,"S",?,?,"Goteborg, Sweden / Rockford, IL"
2,0,"Fahlstrom, Mr. Arne Jonas","male",18,0,0,"236171",13,?,"S",?,?,"Oslo, Norway Bayonne, NJ"
2,0,"Faunthorpe, Mr. Harry","male",40,1,0,"2926",26,?,"S",?,286,"England / Philadelphia, PA"
2,1,"Faunthorpe, Mrs. Lizzie (Elizabeth Anne Wilkinson)","female",29,1,0,"2926",26,?,"S","16",?,?
2,0,"Fillbrook, Mr. Joseph Charles","male",18,0,0,"C.A. 15185",10.5,?,"S",?,?,"Cornwall / Houghton, MI"
2,0,"Fox, Mr. Stanley Hubert","male",36,0,0,"229236",13,?,"S",?,236,"Rochester, NY"
2,0,"Frost, Mr. Anthony Wood 'Archie'","male",?,0,0,"239854",0,?,"S",?,?,"Belfast"
2,0,"Funk, Miss. Annie Clemmer","female",38,0,0,"237671",13,?,"S",?,?,"Janjgir, India / Pennsylvania"
2,0,"Fynney, Mr. Joseph J","male",35,0,0,"239865",26,?,"S",?,322,"Liverpool / Montreal, PQ"
2,0,"Gale, Mr. Harry","male",38,1,0,"28664",21,?,"S",?,?,"Cornwall / Clear Creek, CO"
2,0,"Gale, Mr. Shadrach","male",34,1,0,"28664",21,?,"S",?,?,"Cornwall / Clear Creek, CO"
2,1,"Garside, Miss. Ethel","female",34,0,0,"243880",13,?,"S","12",?,"Brooklyn, NY"
2,0,"Gaskell, Mr. Alfred","male",16,0,0,"239865",26,?,"S",?,?,"Liverpool / Montreal, PQ"
2,0,"Gavey, Mr. Lawrence","male",26,0,0,"31028",10.5,?,"S",?,?,"Guernsey / Elizabeth, NJ"
2,0,"Gilbert, Mr. William","male",47,0,0,"C.A. 30769",10.5,?,"S",?,?,"Cornwall"
2,0,"Giles, Mr. Edgar","male",21,1,0,"28133",11.5,?,"S",?,?,"Cornwall / Camden, NJ"
2,0,"Giles, Mr. Frederick Edward","male",21,1,0,"28134",11.5,?,"S",?,?,"Cornwall / Camden, NJ"
2,0,"Giles, Mr. Ralph","male",24,0,0,"248726",13.5,?,"S",?,297,"West Kensington, London"
2,0,"Gill, Mr. John William","male",24,0,0,"233866",13,?,"S",?,155,"Clevedon, England"
2,0,"Gillespie, Mr. William Henry","male",34,0,0,"12233",13,?,"S",?,?,"Vancouver, BC"
2,0,"Givard, Mr. Hans Kristensen","male",30,0,0,"250646",13,?,"S",?,305,?
2,0,"Greenberg, Mr. Samuel","male",52,0,0,"250647",13,?,"S",?,19,"Bronx, NY"
2,0,"Hale, Mr. Reginald","male",30,0,0,"250653",13,?,"S",?,75,"Auburn, NY"
2,1,"Hamalainen, Master. Viljo","male",0.6667,1,1,"250649",14.5,?,"S","4",?,"Detroit, MI"
2,1,"Hamalainen, Mrs. William (Anna)","female",24,0,2,"250649",14.5,?,"S","4",?,"Detroit, MI"
2,0,"Harbeck, Mr. William H","male",44,0,0,"248746",13,?,"S",?,35,"Seattle, WA / Toledo, OH"
2,1,"Harper, Miss. Annie Jessie 'Nina'","female",6,0,1,"248727",33,?,"S","11",?,"Denmark Hill, Surrey / Chicago"
2,0,"Harper, Rev. John","male",28,0,1,"248727",33,?,"S",?,?,"Denmark Hill, Surrey / Chicago"
2,1,"Harris, Mr. George","male",62,0,0,"S.W./PP 752",10.5,?,"S","15",?,"London"
2,0,"Harris, Mr. Walter","male",30,0,0,"W/C 14208",10.5,?,"S",?,?,"Walthamstow, England"
2,1,"Hart, Miss. Eva Miriam","female",7,0,2,"F.C.C. 13529",26.25,?,"S","14",?,"Ilford, Essex / Winnipeg, MB"
2,0,"Hart, Mr. Benjamin","male",43,1,1,"F.C.C. 13529",26.25,?,"S",?,?,"Ilford, Essex / Winnipeg, MB"
2,1,"Hart, Mrs. Benjamin (Esther Ada Bloomfield)","female",45,1,1,"F.C.C. 13529",26.25,?,"S","14",?,"Ilford, Essex / Winnipeg, MB"
2,1,"Herman, Miss. Alice","female",24,1,2,"220845",65,?,"S","9",?,"Somerset / Bernardsville, NJ"
2,1,"Herman, Miss. Kate","female",24,1,2,"220845",65,?,"S","9",?,"Somerset / Bernardsville, NJ"
2,0,"Herman, Mr. Samuel","male",49,1,2,"220845",65,?,"S",?,?,"Somerset / Bernardsville, NJ"
2,1,"Herman, Mrs. Samuel (Jane Laver)","female",48,1,2,"220845",65,?,"S","9",?,"Somerset / Bernardsville, NJ"
2,1,"Hewlett, Mrs. (Mary D Kingcome)","female",55,0,0,"248706",16,?,"S","13",?,"India / Rapid City, SD"
2,0,"Hickman, Mr. Leonard Mark","male",24,2,0,"S.O.C. 14879",73.5,?,"S",?,?,"West Hampstead, London / Neepawa, MB"
2,0,"Hickman, Mr. Lewis","male",32,2,0,"S.O.C. 14879",73.5,?,"S",?,256,"West Hampstead, London / Neepawa, MB"
2,0,"Hickman, Mr. Stanley George","male",21,2,0,"S.O.C. 14879",73.5,?,"S",?,?,"West Hampstead, London / Neepawa, MB"
2,0,"Hiltunen, Miss. Marta","female",18,1,1,"250650",13,?,"S",?,?,"Kontiolahti, Finland / Detroit, MI"
2,1,"Hocking, Miss. Ellen 'Nellie'","female",20,2,1,"29105",23,?,"S","4",?,"Cornwall / Akron, OH"
2,0,"Hocking, Mr. Richard George","male",23,2,1,"29104",11.5,?,"S",?,?,"Cornwall / Akron, OH"
2,0,"Hocking, Mr. Samuel James Metcalfe","male",36,0,0,"242963",13,?,"S",?,?,"Devonport, England"
2,1,"Hocking, Mrs. Elizabeth (Eliza Needs)","female",54,1,3,"29105",23,?,"S","4",?,"Cornwall / Akron, OH"
2,0,"Hodges, Mr. Henry Price","male",50,0,0,"250643",13,?,"S",?,149,"Southampton"
2,0,"Hold, Mr. Stephen","male",44,1,0,"26707",26,?,"S",?,?,"England / Sacramento, CA"
2,1,"Hold, Mrs. Stephen (Annie Margaret Hill)","female",29,1,0,"26707",26,?,"S","10",?,"England / Sacramento, CA"
2,0,"Hood, Mr. Ambrose Jr","male",21,0,0,"S.O.C. 14879",73.5,?,"S",?,?,"New Forest, England"
2,1,"Hosono, Mr. Masabumi","male",42,0,0,"237798",13,?,"S","10",?,"Tokyo, Japan"
2,0,"Howard, Mr. Benjamin","male",63,1,0,"24065",26,?,"S",?,?,"Swindon, England"
2,0,"Howard, Mrs. Benjamin (Ellen Truelove Arman)","female",60,1,0,"24065",26,?,"S",?,?,"Swindon, England"
2,0,"Hunt, Mr. George Henry","male",33,0,0,"SCO/W 1585",12.275,?,"S",?,?,"Philadelphia, PA"
2,1,"Ilett, Miss. Bertha","female",17,0,0,"SO/C 14885",10.5,?,"S",?,?,"Guernsey"
2,0,"Jacobsohn, Mr. Sidney Samuel","male",42,1,0,"243847",27,?,"S",?,?,"London"
2,1,"Jacobsohn, Mrs. Sidney Samuel (Amy Frances Christy)","female",24,2,1,"243847",27,?,"S","12",?,"London"
2,0,"Jarvis, Mr. John Denzil","male",47,0,0,"237565",15,?,"S",?,?,"North Evington, England"
2,0,"Jefferys, Mr. Clifford Thomas","male",24,2,0,"C.A. 31029",31.5,?,"S",?,?,"Guernsey / Elizabeth, NJ"
2,0,"Jefferys, Mr. Ernest Wilfred","male",22,2,0,"C.A. 31029",31.5,?,"S",?,?,"Guernsey / Elizabeth, NJ"
2,0,"Jenkin, Mr. Stephen Curnow","male",32,0,0,"C.A. 33111",10.5,?,"S",?,?,"St Ives, Cornwall / Houghton, MI"
2,1,"Jerwan, Mrs. Amin S (Marie Marthe Thuillard)","female",23,0,0,"SC/AH Basle 541",13.7917,"D","C","11",?,"New York, NY"
2,0,"Kantor, Mr. Sinai","male",34,1,0,"244367",26,?,"S",?,283,"Moscow / Bronx, NY"
2,1,"Kantor, Mrs. Sinai (Miriam Sternin)","female",24,1,0,"244367",26,?,"S","12",?,"Moscow / Bronx, NY"
2,0,"Karnes, Mrs. J Frank (Claire Bennett)","female",22,0,0,"F.C.C. 13534",21,?,"S",?,?,"India / Pittsburgh, PA"
2,1,"Keane, Miss. Nora A","female",?,0,0,"226593",12.35,"E101","Q","10",?,"Harrisburg, PA"
2,0,"Keane, Mr. Daniel","male",35,0,0,"233734",12.35,?,"Q",?,?,?
2,1,"Kelly, Mrs. Florence 'Fannie'","female",45,0,0,"223596",13.5,?,"S","9",?,"London / New York, NY"
2,0,"Kirkland, Rev. Charles Leonard","male",57,0,0,"219533",12.35,?,"Q",?,?,"Glasgow / Bangor, ME"
2,0,"Knight, Mr. Robert J","male",?,0,0,"239855",0,?,"S",?,?,"Belfast"
2,0,"Kvillner, Mr. Johan Henrik Johannesson","male",31,0,0,"C.A. 18723",10.5,?,"S",?,165,"Sweden / Arlington, NJ"
2,0,"Lahtinen, Mrs. William (Anna Sylfven)","female",26,1,1,"250651",26,?,"S",?,?,"Minneapolis, MN"
2,0,"Lahtinen, Rev. William","male",30,1,1,"250651",26,?,"S",?,?,"Minneapolis, MN"
2,0,"Lamb, Mr. John Joseph","male",?,0,0,"240261",10.7083,?,"Q",?,?,?
2,1,"Laroche, Miss. Louise","female",1,1,2,"SC/Paris 2123",41.5792,?,"C","14",?,"Paris / Haiti"
2,1,"Laroche, Miss. Simonne Marie Anne Andree","female",3,1,2,"SC/Paris 2123",41.5792,?,"C","14",?,"Paris / Haiti"
2,0,"Laroche, Mr. Joseph Philippe Lemercier","male",25,1,2,"SC/Paris 2123",41.5792,?,"C",?,?,"Paris / Haiti"
2,1,"Laroche, Mrs. Joseph (Juliette Marie Louise Lafargue)","female",22,1,2,"SC/Paris 2123",41.5792,?,"C","14",?,"Paris / Haiti"
2,1,"Lehmann, Miss. Bertha","female",17,0,0,"SC 1748",12,?,"C","12",?,"Berne, Switzerland / Central City, IA"
2,1,"Leitch, Miss. Jessie Wills","female",?,0,0,"248727",33,?,"S","11",?,"London / Chicago, IL"
2,1,"Lemore, Mrs. (Amelia Milley)","female",34,0,0,"C.A. 34260",10.5,"F33","S","14",?,"Chicago, IL"
2,0,"Levy, Mr. Rene Jacques","male",36,0,0,"SC/Paris 2163",12.875,"D","C",?,?,"Montreal, PQ"
2,0,"Leyson, Mr. Robert William Norman","male",24,0,0,"C.A. 29566",10.5,?,"S",?,108,?
2,0,"Lingane, Mr. John","male",61,0,0,"235509",12.35,?,"Q",?,?,?
2,0,"Louch, Mr. Charles Alexander","male",50,1,0,"SC/AH 3085",26,?,"S",?,121,"Weston-Super-Mare, Somerset"
2,1,"Louch, Mrs. Charles Alexander (Alice Adelaide Slow)","female",42,1,0,"SC/AH 3085",26,?,"S",?,?,"Weston-Super-Mare, Somerset"
2,0,"Mack, Mrs. (Mary)","female",57,0,0,"S.O./P.P. 3",10.5,"E77","S",?,52,"Southampton / New York, NY"
2,0,"Malachard, Mr. Noel","male",?,0,0,"237735",15.0458,"D","C",?,?,"Paris"
2,1,"Mallet, Master. Andre","male",1,0,2,"S.C./PARIS 2079",37.0042,?,"C","10",?,"Paris / Montreal, PQ"
2,0,"Mallet, Mr. Albert","male",31,1,1,"S.C./PARIS 2079",37.0042,?,"C",?,?,"Paris / Montreal, PQ"
2,1,"Mallet, Mrs. Albert (Antoinette Magnin)","female",24,1,1,"S.C./PARIS 2079",37.0042,?,"C","10",?,"Paris / Montreal, PQ"
2,0,"Mangiavacchi, Mr. Serafino Emilio","male",?,0,0,"SC/A.3 2861",15.5792,?,"C",?,?,"New York, NY"
2,0,"Matthews, Mr. William John","male",30,0,0,"28228",13,?,"S",?,?,"St Austall, Cornwall"
2,0,"Maybery, Mr. Frank Hubert","male",40,0,0,"239059",16,?,"S",?,?,"Weston-Super-Mare / Moose Jaw, SK"
2,0,"McCrae, Mr. Arthur Gordon","male",32,0,0,"237216",13.5,?,"S",?,209,"Sydney, Australia"
2,0,"McCrie, Mr. James Matthew","male",30,0,0,"233478",13,?,"S",?,?,"Sarnia, ON"
2,0,"McKane, Mr. Peter David","male",46,0,0,"28403",26,?,"S",?,?,"Rochester, NY"
2,1,"Mellinger, Miss. Madeleine Violet","female",13,0,1,"250644",19.5,?,"S","14",?,"England / Bennington, VT"
2,1,"Mellinger, Mrs. (Elizabeth Anne Maidment)","female",41,0,1,"250644",19.5,?,"S","14",?,"England / Bennington, VT"
2,1,"Mellors, Mr. William John","male",19,0,0,"SW/PP 751",10.5,?,"S","B",?,"Chelsea, London"
2,0,"Meyer, Mr. August","male",39,0,0,"248723",13,?,"S",?,?,"Harrow-on-the-Hill, Middlesex"
2,0,"Milling, Mr. Jacob Christian","male",48,0,0,"234360",13,?,"S",?,271,"Copenhagen, Denmark"
2,0,"Mitchell, Mr. Henry Michael","male",70,0,0,"C.A. 24580",10.5,?,"S",?,?,"Guernsey / Montclair, NJ and/or Toledo, Ohio"
2,0,"Montvila, Rev. Juozas","male",27,0,0,"211536",13,?,"S",?,?,"Worcester, MA"
2,0,"Moraweck, Dr. Ernest","male",54,0,0,"29011",14,?,"S",?,?,"Frankfort, KY"
2,0,"Morley, Mr. Henry Samuel ('Mr Henry Marshall')","male",39,0,0,"250655",26,?,"S",?,?,?
2,0,"Mudd, Mr. Thomas Charles","male",16,0,0,"S.O./P.P. 3",10.5,?,"S",?,?,"Halesworth, England"
2,0,"Myles, Mr. Thomas Francis","male",62,0,0,"240276",9.6875,?,"Q",?,?,"Cambridge, MA"
2,0,"Nasser, Mr. Nicholas","male",32.5,1,0,"237736",30.0708,?,"C",?,43,"New York, NY"
2,1,"Nasser, Mrs. Nicholas (Adele Achem)","female",14,1,0,"237736",30.0708,?,"C",?,?,"New York, NY"
2,1,"Navratil, Master. Edmond Roger","male",2,1,1,"230080",26,"F2","S","D",?,"Nice, France"
2,1,"Navratil, Master. Michel M","male",3,1,1,"230080",26,"F2","S","D",?,"Nice, France"
2,0,"Navratil, Mr. Michel ('Louis M Hoffman')","male",36.5,0,2,"230080",26,"F2","S",?,15,"Nice, France"
2,0,"Nesson, Mr. Israel","male",26,0,0,"244368",13,"F2","S",?,?,"Boston, MA"
2,0,"Nicholls, Mr. Joseph Charles","male",19,1,1,"C.A. 33112",36.75,?,"S",?,101,"Cornwall / Hancock, MI"
2,0,"Norman, Mr. Robert Douglas","male",28,0,0,"218629",13.5,?,"S",?,287,"Glasgow"
2,1,"Nourney, Mr. Alfred ('Baron von Drachstedt')","male",20,0,0,"SC/PARIS 2166",13.8625,"D38","C","7",?,"Cologne, Germany"
2,1,"Nye, Mrs. (Elizabeth Ramell)","female",29,0,0,"C.A. 29395",10.5,"F33","S","11",?,"Folkstone, Kent / New York, NY"
2,0,"Otter, Mr. Richard","male",39,0,0,"28213",13,?,"S",?,?,"Middleburg Heights, OH"
2,1,"Oxenham, Mr. Percy Thomas","male",22,0,0,"W./C. 14260",10.5,?,"S","13",?,"Pondersend, England / New Durham, NJ"
2,1,"Padro y Manent, Mr. Julian","male",?,0,0,"SC/PARIS 2146",13.8625,?,"C","9",?,"Spain / Havana, Cuba"
2,0,"Pain, Dr. Alfred","male",23,0,0,"244278",10.5,?,"S",?,?,"Hamilton, ON"
2,1,"Pallas y Castello, Mr. Emilio","male",29,0,0,"SC/PARIS 2147",13.8583,?,"C","9",?,"Spain / Havana, Cuba"
2,0,"Parker, Mr. Clifford Richard","male",28,0,0,"SC 14888",10.5,?,"S",?,?,"St Andrews, Guernsey"
2,0,"Parkes, Mr. Francis 'Frank'","male",?,0,0,"239853",0,?,"S",?,?,"Belfast"
2,1,"Parrish, Mrs. (Lutie Davis)","female",50,0,1,"230433",26,?,"S","12",?,"Woodford County, KY"
2,0,"Pengelly, Mr. Frederick William","male",19,0,0,"28665",10.5,?,"S",?,?,"Gunnislake, England / Butte, MT"
2,0,"Pernot, Mr. Rene","male",?,0,0,"SC/PARIS 2131",15.05,?,"C",?,?,?
2,0,"Peruschitz, Rev. Joseph Maria","male",41,0,0,"237393",13,?,"S",?,?,?
2,1,"Phillips, Miss. Alice Frances Louisa","female",21,0,1,"S.O./P.P. 2",21,?,"S","12",?,"Ilfracombe, Devon"
2,1,"Phillips, Miss. Kate Florence ('Mrs Kate Louise Phillips Marshall')","female",19,0,0,"250655",26,?,"S","11",?,"Worcester, England"
2,0,"Phillips, Mr. Escott Robert","male",43,0,1,"S.O./P.P. 2",21,?,"S",?,?,"Ilfracombe, Devon"
2,1,"Pinsky, Mrs. (Rosa)","female",32,0,0,"234604",13,?,"S","9",?,"Russia"
2,0,"Ponesell, Mr. Martin","male",34,0,0,"250647",13,?,"S",?,?,"Denmark / New York, NY"
2,1,"Portaluppi, Mr. Emilio Ilario Giuseppe","male",30,0,0,"C.A. 34644",12.7375,?,"C","14",?,"Milford, NH"
2,0,"Pulbaum, Mr. Franz","male",27,0,0,"SC/PARIS 2168",15.0333,?,"C",?,?,"Paris"
2,1,"Quick, Miss. Phyllis May","female",2,1,1,"26360",26,?,"S","11",?,"Plymouth, Devon / Detroit, MI"
2,1,"Quick, Miss. Winifred Vera","female",8,1,1,"26360",26,?,"S","11",?,"Plymouth, Devon / Detroit, MI"
2,1,"Quick, Mrs. Frederick Charles (Jane Richards)","female",33,0,2,"26360",26,?,"S","11",?,"Plymouth, Devon / Detroit, MI"
2,0,"Reeves, Mr. David","male",36,0,0,"C.A. 17248",10.5,?,"S",?,?,"Brighton, Sussex"
2,0,"Renouf, Mr. Peter Henry","male",34,1,0,"31027",21,?,"S","12",?,"Elizabeth, NJ"
2,1,"Renouf, Mrs. Peter Henry (Lillian Jefferys)","female",30,3,0,"31027",21,?,"S",?,?,"Elizabeth, NJ"
2,1,"Reynaldo, Ms. Encarnacion","female",28,0,0,"230434",13,?,"S","9",?,"Spain"
2,0,"Richard, Mr. Emile","male",23,0,0,"SC/PARIS 2133",15.0458,?,"C",?,?,"Paris / Montreal, PQ"
2,1,"Richards, Master. George Sibley","male",0.8333,1,1,"29106",18.75,?,"S","4",?,"Cornwall / Akron, OH"
2,1,"Richards, Master. William Rowe","male",3,1,1,"29106",18.75,?,"S","4",?,"Cornwall / Akron, OH"
2,1,"Richards, Mrs. Sidney (Emily Hocking)","female",24,2,3,"29106",18.75,?,"S","4",?,"Cornwall / Akron, OH"
2,1,"Ridsdale, Miss. Lucy","female",50,0,0,"W./C. 14258",10.5,?,"S","13",?,"London, England / Marietta, Ohio and Milwaukee, WI"
2,0,"Rogers, Mr. Reginald Harry","male",19,0,0,"28004",10.5,?,"S",?,?,?
2,1,"Rugg, Miss. Emily","female",21,0,0,"C.A. 31026",10.5,?,"S","12",?,"Guernsey / Wilmington, DE"
2,0,"Schmidt, Mr. August","male",26,0,0,"248659",13,?,"S",?,?,"Newark, NJ"
2,0,"Sedgwick, Mr. Charles Frederick Waddington","male",25,0,0,"244361",13,?,"S",?,?,"Liverpool"
2,0,"Sharp, Mr. Percival James R","male",27,0,0,"244358",26,?,"S",?,?,"Hornsey, England"
2,1,"Shelley, Mrs. William (Imanita Parrish Hall)","female",25,0,1,"230433",26,?,"S","12",?,"Deer Lodge, MT"
2,1,"Silven, Miss. Lyyli Karoliina","female",18,0,2,"250652",13,?,"S","16",?,"Finland / Minneapolis, MN"
2,1,"Sincock, Miss. Maude","female",20,0,0,"C.A. 33112",36.75,?,"S","11",?,"Cornwall / Hancock, MI"
2,1,"Sinkkonen, Miss. Anna","female",30,0,0,"250648",13,?,"S","10",?,"Finland / Washington, DC"
2,0,"Sjostedt, Mr. Ernst Adolf","male",59,0,0,"237442",13.5,?,"S",?,?,"Sault St Marie, ON"
2,1,"Slayter, Miss. Hilda Mary","female",30,0,0,"234818",12.35,?,"Q","13",?,"Halifax, NS"
2,0,"Slemen, Mr. Richard James","male",35,0,0,"28206",10.5,?,"S",?,?,"Cornwall"
2,1,"Smith, Miss. Marion Elsie","female",40,0,0,"31418",13,?,"S","9",?,?
2,0,"Sobey, Mr. Samuel James Hayden","male",25,0,0,"C.A. 29178",13,?,"S",?,?,"Cornwall / Houghton, MI"
2,0,"Stanton, Mr. Samuel Ward","male",41,0,0,"237734",15.0458,?,"C",?,?,"New York, NY"
2,0,"Stokes, Mr. Philip Joseph","male",25,0,0,"F.C.C. 13540",10.5,?,"S",?,81,"Catford, Kent / Detroit, MI"
2,0,"Swane, Mr. George","male",18.5,0,0,"248734",13,"F","S",?,294,?
2,0,"Sweet, Mr. George Frederick","male",14,0,0,"220845",65,?,"S",?,?,"Somerset / Bernardsville, NJ"
2,1,"Toomey, Miss. Ellen","female",50,0,0,"F.C.C. 13531",10.5,?,"S","9",?,"Indianapolis, IN"
2,0,"Troupiansky, Mr. Moses Aaron","male",23,0,0,"233639",13,?,"S",?,?,?
2,1,"Trout, Mrs. William H (Jessie L)","female",28,0,0,"240929",12.65,?,"S",?,?,"Columbus, OH"
2,1,"Troutt, Miss. Edwina Celia 'Winnie'","female",27,0,0,"34218",10.5,"E101","S","16",?,"Bath, England / Massachusetts"
2,0,"Turpin, Mr. William John Robert","male",29,1,0,"11668",21,?,"S",?,?,"Plymouth, England"
2,0,"Turpin, Mrs. William John Robert (Dorothy Ann Wonnacott)","female",27,1,0,"11668",21,?,"S",?,?,"Plymouth, England"
2,0,"Veal, Mr. James","male",40,0,0,"28221",13,?,"S",?,?,"Barre, Co Washington, VT"
2,1,"Walcroft, Miss. Nellie","female",31,0,0,"F.C.C. 13528",21,?,"S","14",?,"Mamaroneck, NY"
2,0,"Ware, Mr. John James","male",30,1,0,"CA 31352",21,?,"S",?,?,"Bristol, England / New Britain, CT"
2,0,"Ware, Mr. William Jeffery","male",23,1,0,"28666",10.5,?,"S",?,?,?
2,1,"Ware, Mrs. John James (Florence Louise Long)","female",31,0,0,"CA 31352",21,?,"S","10",?,"Bristol, England / New Britain, CT"
2,0,"Watson, Mr. Ennis Hastings","male",?,0,0,"239856",0,?,"S",?,?,"Belfast"
2,1,"Watt, Miss. Bertha J","female",12,0,0,"C.A. 33595",15.75,?,"S","9",?,"Aberdeen / Portland, OR"
2,1,"Watt, Mrs. James (Elizabeth 'Bessie' Inglis Milne)","female",40,0,0,"C.A. 33595",15.75,?,"S","9",?,"Aberdeen / Portland, OR"
2,1,"Webber, Miss. Susan","female",32.5,0,0,"27267",13,"E101","S","12",?,"England / Hartford, CT"
2,0,"Weisz, Mr. Leopold","male",27,1,0,"228414",26,?,"S",?,293,"Bromsgrove, England / Montreal, PQ"
2,1,"Weisz, Mrs. Leopold (Mathilde Francoise Pede)","female",29,1,0,"228414",26,?,"S","10",?,"Bromsgrove, England / Montreal, PQ"
2,1,"Wells, Master. Ralph Lester","male",2,1,1,"29103",23,?,"S","14",?,"Cornwall / Akron, OH"
2,1,"Wells, Miss. Joan","female",4,1,1,"29103",23,?,"S","14",?,"Cornwall / Akron, OH"
2,1,"Wells, Mrs. Arthur Henry ('Addie' Dart Trevaskis)","female",29,0,2,"29103",23,?,"S","14",?,"Cornwall / Akron, OH"
2,1,"West, Miss. Barbara J","female",0.9167,1,2,"C.A. 34651",27.75,?,"S","10",?,"Bournmouth, England"
2,1,"West, Miss. Constance Mirium","female",5,1,2,"C.A. 34651",27.75,?,"S","10",?,"Bournmouth, England"
2,0,"West, Mr. Edwy Arthur","male",36,1,2,"C.A. 34651",27.75,?,"S",?,?,"Bournmouth, England"
2,1,"West, Mrs. Edwy Arthur (Ada Mary Worth)","female",33,1,2,"C.A. 34651",27.75,?,"S","10",?,"Bournmouth, England"
2,0,"Wheadon, Mr. Edward H","male",66,0,0,"C.A. 24579",10.5,?,"S",?,?,"Guernsey, England / Edgewood, RI"
2,0,"Wheeler, Mr. Edwin 'Frederick'","male",?,0,0,"SC/PARIS 2159",12.875,?,"S",?,?,?
2,1,"Wilhelms, Mr. Charles","male",31,0,0,"244270",13,?,"S","9",?,"London, England"
2,1,"Williams, Mr. Charles Eugene","male",?,0,0,"244373",13,?,"S","14",?,"Harrow, England"
2,1,"Wright, Miss. Marion","female",26,0,0,"220844",13.5,?,"S","9",?,"Yoevil, England / Cottage Grove, OR"
2,0,"Yrois, Miss. Henriette ('Mrs Harbeck')","female",24,0,0,"248747",13,?,"S",?,?,"Paris"
3,0,"Abbing, Mr. Anthony","male",42,0,0,"C.A. 5547",7.55,?,"S",?,?,?
3,0,"Abbott, Master. Eugene Joseph","male",13,0,2,"C.A. 2673",20.25,?,"S",?,?,"East Providence, RI"
3,0,"Abbott, Mr. Rossmore Edward","male",16,1,1,"C.A. 2673",20.25,?,"S",?,190,"East Providence, RI"
3,1,"Abbott, Mrs. Stanton (Rosa Hunt)","female",35,1,1,"C.A. 2673",20.25,?,"S","A",?,"East Providence, RI"
3,1,"Abelseth, Miss. Karen Marie","female",16,0,0,"348125",7.65,?,"S","16",?,"Norway Los Angeles, CA"
3,1,"Abelseth, Mr. Olaus Jorgensen","male",25,0,0,"348122",7.65,"F G63","S","A",?,"Perkins County, SD"
3,1,"Abrahamsson, Mr. Abraham August Johannes","male",20,0,0,"SOTON/O2 3101284",7.925,?,"S","15",?,"Taalintehdas, Finland Hoboken, NJ"
3,1,"Abrahim, Mrs. Joseph (Sophie Halaut Easu)","female",18,0,0,"2657",7.2292,?,"C","C",?,"Greensburg, PA"
3,0,"Adahl, Mr. Mauritz Nils Martin","male",30,0,0,"C 7076",7.25,?,"S",?,72,"Asarum, Sweden Brooklyn, NY"
3,0,"Adams, Mr. John","male",26,0,0,"341826",8.05,?,"S",?,103,"Bournemouth, England"
3,0,"Ahlin, Mrs. Johan (Johanna Persdotter Larsson)","female",40,1,0,"7546",9.475,?,"S",?,?,"Sweden Akeley, MN"
3,1,"Aks, Master. Philip Frank","male",0.8333,0,1,"392091",9.35,?,"S","11",?,"London, England Norfolk, VA"
3,1,"Aks, Mrs. Sam (Leah Rosen)","female",18,0,1,"392091",9.35,?,"S","13",?,"London, England Norfolk, VA"
3,1,"Albimona, Mr. Nassef Cassem","male",26,0,0,"2699",18.7875,?,"C","15",?,"Syria Fredericksburg, VA"
3,0,"Alexander, Mr. William","male",26,0,0,"3474",7.8875,?,"S",?,?,"England Albion, NY"
3,0,"Alhomaki, Mr. Ilmari Rudolf","male",20,0,0,"SOTON/O2 3101287",7.925,?,"S",?,?,"Salo, Finland Astoria, OR"
3,0,"Ali, Mr. Ahmed","male",24,0,0,"SOTON/O.Q. 3101311",7.05,?,"S",?,?,?
3,0,"Ali, Mr. William","male",25,0,0,"SOTON/O.Q. 3101312",7.05,?,"S",?,79,"Argentina"
3,0,"Allen, Mr. William Henry","male",35,0,0,"373450",8.05,?,"S",?,?,"Lower Clapton, Middlesex or Erdington, Birmingham"
3,0,"Allum, Mr. Owen George","male",18,0,0,"2223",8.3,?,"S",?,259,"Windsor, England New York, NY"
3,0,"Andersen, Mr. Albert Karvin","male",32,0,0,"C 4001",22.525,?,"S",?,260,"Bergen, Norway"
3,1,"Andersen-Jensen, Miss. Carla Christine Nielsine","female",19,1,0,"350046",7.8542,?,"S","16",?,?
3,0,"Andersson, Master. Sigvard Harald Elias","male",4,4,2,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,0,"Andersson, Miss. Ebba Iris Alfrida","female",6,4,2,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,0,"Andersson, Miss. Ellis Anna Maria","female",2,4,2,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,1,"Andersson, Miss. Erna Alexandra","female",17,4,2,"3101281",7.925,?,"S","D",?,"Ruotsinphyhtaa, Finland New York, NY"
3,0,"Andersson, Miss. Ida Augusta Margareta","female",38,4,2,"347091",7.775,?,"S",?,?,"Vadsbro, Sweden Ministee, MI"
3,0,"Andersson, Miss. Ingeborg Constanzia","female",9,4,2,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,0,"Andersson, Miss. Sigrid Elisabeth","female",11,4,2,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,0,"Andersson, Mr. Anders Johan","male",39,1,5,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,1,"Andersson, Mr. August Edvard ('Wennerstrom')","male",27,0,0,"350043",7.7958,?,"S","A",?,?
3,0,"Andersson, Mr. Johan Samuel","male",26,0,0,"347075",7.775,?,"S",?,?,"Hartford, CT"
3,0,"Andersson, Mrs. Anders Johan (Alfrida Konstantia Brogren)","female",39,1,5,"347082",31.275,?,"S",?,?,"Sweden Winnipeg, MN"
3,0,"Andreasson, Mr. Paul Edvin","male",20,0,0,"347466",7.8542,?,"S",?,?,"Sweden Chicago, IL"
3,0,"Angheloff, Mr. Minko","male",26,0,0,"349202",7.8958,?,"S",?,?,"Bulgaria Chicago, IL"
3,0,"Arnold-Franchi, Mr. Josef","male",25,1,0,"349237",17.8,?,"S",?,?,"Altdorf, Switzerland"
3,0,"Arnold-Franchi, Mrs. Josef (Josefine Franchi)","female",18,1,0,"349237",17.8,?,"S",?,?,"Altdorf, Switzerland"
3,0,"Aronsson, Mr. Ernst Axel Algot","male",24,0,0,"349911",7.775,?,"S",?,?,"Sweden Joliet, IL"
3,0,"Asim, Mr. Adola","male",35,0,0,"SOTON/O.Q. 3101310",7.05,?,"S",?,?,?
3,0,"Asplund, Master. Carl Edgar","male",5,4,2,"347077",31.3875,?,"S",?,?,"Sweden  Worcester, MA"
3,0,"Asplund, Master. Clarence Gustaf Hugo","male",9,4,2,"347077",31.3875,?,"S",?,?,"Sweden Worcester, MA"
3,1,"Asplund, Master. Edvin Rojj Felix","male",3,4,2,"347077",31.3875,?,"S","15",?,"Sweden Worcester, MA"
3,0,"Asplund, Master. Filip Oscar","male",13,4,2,"347077",31.3875,?,"S",?,?,"Sweden Worcester, MA"
3,1,"Asplund, Miss. Lillian Gertrud","female",5,4,2,"347077",31.3875,?,"S","15",?,"Sweden Worcester, MA"
3,0,"Asplund, Mr. Carl Oscar Vilhelm Gustafsson","male",40,1,5,"347077",31.3875,?,"S",?,142,"Sweden  Worcester, MA"
3,1,"Asplund, Mr. Johan Charles","male",23,0,0,"350054",7.7958,?,"S","13",?,"Oskarshamn, Sweden Minneapolis, MN"
3,1,"Asplund, Mrs. Carl Oscar (Selma Augusta Emilia Johansson)","female",38,1,5,"347077",31.3875,?,"S","15",?,"Sweden  Worcester, MA"
3,1,"Assaf Khalil, Mrs. Mariana ('Miriam')","female",45,0,0,"2696",7.225,?,"C","C",?,"Ottawa, ON"
3,0,"Assaf, Mr. Gerios","male",21,0,0,"2692",7.225,?,"C",?,?,"Ottawa, ON"
3,0,"Assam, Mr. Ali","male",23,0,0,"SOTON/O.Q. 3101309",7.05,?,"S",?,?,?
3,0,"Attalah, Miss. Malake","female",17,0,0,"2627",14.4583,?,"C",?,?,?
3,0,"Attalah, Mr. Sleiman","male",30,0,0,"2694",7.225,?,"C",?,?,"Ottawa, ON"
3,0,"Augustsson, Mr. Albert","male",23,0,0,"347468",7.8542,?,"S",?,?,"Krakoryd, Sweden Bloomington, IL"
3,1,"Ayoub, Miss. Banoura","female",13,0,0,"2687",7.2292,?,"C","C",?,"Syria Youngstown, OH"
3,0,"Baccos, Mr. Raffull","male",20,0,0,"2679",7.225,?,"C",?,?,?
3,0,"Backstrom, Mr. Karl Alfred","male",32,1,0,"3101278",15.85,?,"S","D",?,"Ruotsinphytaa, Finland New York, NY"
3,1,"Backstrom, Mrs. Karl Alfred (Maria Mathilda Gustafsson)","female",33,3,0,"3101278",15.85,?,"S",?,?,"Ruotsinphytaa, Finland New York, NY"
3,1,"Baclini, Miss. Eugenie","female",0.75,2,1,"2666",19.2583,?,"C","C",?,"Syria New York, NY"
3,1,"Baclini, Miss. Helene Barbara","female",0.75,2,1,"2666",19.2583,?,"C","C",?,"Syria New York, NY"
3,1,"Baclini, Miss. Marie Catherine","female",5,2,1,"2666",19.2583,?,"C","C",?,"Syria New York, NY"
3,1,"Baclini, Mrs. Solomon (Latifa Qurban)","female",24,0,3,"2666",19.2583,?,"C","C",?,"Syria New York, NY"
3,1,"Badman, Miss. Emily Louisa","female",18,0,0,"A/4 31416",8.05,?,"S","C",?,"London Skanteales, NY"
3,0,"Badt, Mr. Mohamed","male",40,0,0,"2623",7.225,?,"C",?,?,?
3,0,"Balkic, Mr. Cerin","male",26,0,0,"349248",7.8958,?,"S",?,?,?
3,1,"Barah, Mr. Hanna Assi","male",20,0,0,"2663",7.2292,?,"C","15",?,?
3,0,"Barbara, Miss. Saiide","female",18,0,1,"2691",14.4542,?,"C",?,?,"Syria Ottawa, ON"
3,0,"Barbara, Mrs. (Catherine David)","female",45,0,1,"2691",14.4542,?,"C",?,?,"Syria Ottawa, ON"
3,0,"Barry, Miss. Julia","female",27,0,0,"330844",7.8792,?,"Q",?,?,"New York, NY"
3,0,"Barton, Mr. David John","male",22,0,0,"324669",8.05,?,"S",?,?,"England New York, NY"
3,0,"Beavan, Mr. William Thomas","male",19,0,0,"323951",8.05,?,"S",?,?,"England"
3,0,"Bengtsson, Mr. John Viktor","male",26,0,0,"347068",7.775,?,"S",?,?,"Krakudden, Sweden Moune, IL"
3,0,"Berglund, Mr. Karl Ivar Sven","male",22,0,0,"PP 4348",9.35,?,"S",?,?,"Tranvik, Finland New York"
3,0,"Betros, Master. Seman","male",?,0,0,"2622",7.2292,?,"C",?,?,?
3,0,"Betros, Mr. Tannous","male",20,0,0,"2648",4.0125,?,"C",?,?,"Syria"
3,1,"Bing, Mr. Lee","male",32,0,0,"1601",56.4958,?,"S","C",?,"Hong Kong New York, NY"
3,0,"Birkeland, Mr. Hans Martin Monsen","male",21,0,0,"312992",7.775,?,"S",?,?,"Brennes, Norway New York"
3,0,"Bjorklund, Mr. Ernst Herbert","male",18,0,0,"347090",7.75,?,"S",?,?,"Stockholm, Sweden New York"
3,0,"Bostandyeff, Mr. Guentcho","male",26,0,0,"349224",7.8958,?,"S",?,?,"Bulgaria Chicago, IL"
3,0,"Boulos, Master. Akar","male",6,1,1,"2678",15.2458,?,"C",?,?,"Syria Kent, ON"
3,0,"Boulos, Miss. Nourelain","female",9,1,1,"2678",15.2458,?,"C",?,?,"Syria Kent, ON"
3,0,"Boulos, Mr. Hanna","male",?,0,0,"2664",7.225,?,"C",?,?,"Syria"
3,0,"Boulos, Mrs. Joseph (Sultana)","female",?,0,2,"2678",15.2458,?,"C",?,?,"Syria Kent, ON"
3,0,"Bourke, Miss. Mary","female",?,0,2,"364848",7.75,?,"Q",?,?,"Ireland Chicago, IL"
3,0,"Bourke, Mr. John","male",40,1,1,"364849",15.5,?,"Q",?,?,"Ireland Chicago, IL"
3,0,"Bourke, Mrs. John (Catherine)","female",32,1,1,"364849",15.5,?,"Q",?,?,"Ireland Chicago, IL"
3,0,"Bowen, Mr. David John 'Dai'","male",21,0,0,"54636",16.1,?,"S",?,?,"Treherbert, Cardiff, Wales"
3,1,"Bradley, Miss. Bridget Delia","female",22,0,0,"334914",7.725,?,"Q","13",?,"Kingwilliamstown, Co Cork, Ireland Glens Falls, NY"
3,0,"Braf, Miss. Elin Ester Maria","female",20,0,0,"347471",7.8542,?,"S",?,?,"Medeltorp, Sweden Chicago, IL"
3,0,"Braund, Mr. Lewis Richard","male",29,1,0,"3460",7.0458,?,"S",?,?,"Bridgerule, Devon"
3,0,"Braund, Mr. Owen Harris","male",22,1,0,"A/5 21171",7.25,?,"S",?,?,"Bridgerule, Devon"
3,0,"Brobeck, Mr. Karl Rudolf","male",22,0,0,"350045",7.7958,?,"S",?,?,"Sweden Worcester, MA"
3,0,"Brocklebank, Mr. William Alfred","male",35,0,0,"364512",8.05,?,"S",?,?,"Broomfield, Chelmsford, England"
3,0,"Buckley, Miss. Katherine","female",18.5,0,0,"329944",7.2833,?,"Q",?,299,"Co Cork, Ireland Roxbury, MA"
3,1,"Buckley, Mr. Daniel","male",21,0,0,"330920",7.8208,?,"Q","13",?,"Kingwilliamstown, Co Cork, Ireland New York, NY"
3,0,"Burke, Mr. Jeremiah","male",19,0,0,"365222",6.75,?,"Q",?,?,"Co Cork, Ireland Charlestown, MA"
3,0,"Burns, Miss. Mary Delia","female",18,0,0,"330963",7.8792,?,"Q",?,?,"Co Sligo, Ireland New York, NY"
3,0,"Cacic, Miss. Manda","female",21,0,0,"315087",8.6625,?,"S",?,?,?
3,0,"Cacic, Miss. Marija","female",30,0,0,"315084",8.6625,?,"S",?,?,?
3,0,"Cacic, Mr. Jego Grga","male",18,0,0,"315091",8.6625,?,"S",?,?,?
3,0,"Cacic, Mr. Luka","male",38,0,0,"315089",8.6625,?,"S",?,?,"Croatia"
3,0,"Calic, Mr. Jovo","male",17,0,0,"315093",8.6625,?,"S",?,?,?
3,0,"Calic, Mr. Petar","male",17,0,0,"315086",8.6625,?,"S",?,?,?
3,0,"Canavan, Miss. Mary","female",21,0,0,"364846",7.75,?,"Q",?,?,?
3,0,"Canavan, Mr. Patrick","male",21,0,0,"364858",7.75,?,"Q",?,?,"Ireland Philadelphia, PA"
3,0,"Cann, Mr. Ernest Charles","male",21,0,0,"A./5. 2152",8.05,?,"S",?,?,?
3,0,"Caram, Mr. Joseph","male",?,1,0,"2689",14.4583,?,"C",?,?,"Ottawa, ON"
3,0,"Caram, Mrs. Joseph (Maria Elias)","female",?,1,0,"2689",14.4583,?,"C",?,?,"Ottawa, ON"
3,0,"Carlsson, Mr. August Sigfrid","male",28,0,0,"350042",7.7958,?,"S",?,?,"Dagsas, Sweden Fower, MN"
3,0,"Carlsson, Mr. Carl Robert","male",24,0,0,"350409",7.8542,?,"S",?,?,"Goteborg, Sweden Huntley, IL"
3,1,"Carr, Miss. Helen 'Ellen'","female",16,0,0,"367231",7.75,?,"Q","16",?,"Co Longford, Ireland New York, NY"
3,0,"Carr, Miss. Jeannie","female",37,0,0,"368364",7.75,?,"Q",?,?,"Co Sligo, Ireland Hartford, CT"
3,0,"Carver, Mr. Alfred John","male",28,0,0,"392095",7.25,?,"S",?,?,"St Denys, Southampton, Hants"
3,0,"Celotti, Mr. Francesco","male",24,0,0,"343275",8.05,?,"S",?,?,"London"
3,0,"Charters, Mr. David","male",21,0,0,"A/5. 13032",7.7333,?,"Q",?,?,"Ireland New York, NY"
3,1,"Chip, Mr. Chang","male",32,0,0,"1601",56.4958,?,"S","C",?,"Hong Kong New York, NY"
3,0,"Christmann, Mr. Emil","male",29,0,0,"343276",8.05,?,"S",?,?,?
3,0,"Chronopoulos, Mr. Apostolos","male",26,1,0,"2680",14.4542,?,"C",?,?,"Greece"
3,0,"Chronopoulos, Mr. Demetrios","male",18,1,0,"2680",14.4542,?,"C",?,?,"Greece"
3,0,"Coelho, Mr. Domingos Fernandeo","male",20,0,0,"SOTON/O.Q. 3101307",7.05,?,"S",?,?,"Portugal"
3,1,"Cohen, Mr. Gurshon 'Gus'","male",18,0,0,"A/5 3540",8.05,?,"S","12",?,"London Brooklyn, NY"
3,0,"Colbert, Mr. Patrick","male",24,0,0,"371109",7.25,?,"Q",?,?,"Co Limerick, Ireland Sherbrooke, PQ"
3,0,"Coleff, Mr. Peju","male",36,0,0,"349210",7.4958,?,"S",?,?,"Bulgaria Chicago, IL"
3,0,"Coleff, Mr. Satio","male",24,0,0,"349209",7.4958,?,"S",?,?,?
3,0,"Conlon, Mr. Thomas Henry","male",31,0,0,"21332",7.7333,?,"Q",?,?,"Philadelphia, PA"
3,0,"Connaghton, Mr. Michael","male",31,0,0,"335097",7.75,?,"Q",?,?,"Ireland Brooklyn, NY"
3,1,"Connolly, Miss. Kate","female",22,0,0,"370373",7.75,?,"Q","13",?,"Ireland"
3,0,"Connolly, Miss. Kate","female",30,0,0,"330972",7.6292,?,"Q",?,?,"Ireland"
3,0,"Connors, Mr. Patrick","male",70.5,0,0,"370369",7.75,?,"Q",?,171,?
3,0,"Cook, Mr. Jacob","male",43,0,0,"A/5 3536",8.05,?,"S",?,?,?
3,0,"Cor, Mr. Bartol","male",35,0,0,"349230",7.8958,?,"S",?,?,"Austria"
3,0,"Cor, Mr. Ivan","male",27,0,0,"349229",7.8958,?,"S",?,?,"Austria"
3,0,"Cor, Mr. Liudevit","male",19,0,0,"349231",7.8958,?,"S",?,?,"Austria"
3,0,"Corn, Mr. Harry","male",30,0,0,"SOTON/OQ 392090",8.05,?,"S",?,?,"London"
3,1,"Coutts, Master. Eden Leslie 'Neville'","male",9,1,1,"C.A. 37671",15.9,?,"S","2",?,"England Brooklyn, NY"
3,1,"Coutts, Master. William Loch 'William'","male",3,1,1,"C.A. 37671",15.9,?,"S","2",?,"England Brooklyn, NY"
3,1,"Coutts, Mrs. William (Winnie 'Minnie' Treanor)","female",36,0,2,"C.A. 37671",15.9,?,"S","2",?,"England Brooklyn, NY"
3,0,"Coxon, Mr. Daniel","male",59,0,0,"364500",7.25,?,"S",?,?,"Merrill, WI"
3,0,"Crease, Mr. Ernest James","male",19,0,0,"S.P. 3464",8.1583,?,"S",?,?,"Bristol, England Cleveland, OH"
3,1,"Cribb, Miss. Laura Alice","female",17,0,1,"371362",16.1,?,"S","12",?,"Bournemouth, England Newark, NJ"
3,0,"Cribb, Mr. John Hatfield","male",44,0,1,"371362",16.1,?,"S",?,?,"Bournemouth, England Newark, NJ"
3,0,"Culumovic, Mr. Jeso","male",17,0,0,"315090",8.6625,?,"S",?,?,"Austria-Hungary"
3,0,"Daher, Mr. Shedid","male",22.5,0,0,"2698",7.225,?,"C",?,9,?
3,1,"Dahl, Mr. Karl Edwart","male",45,0,0,"7598",8.05,?,"S","15",?,"Australia Fingal, ND"
3,0,"Dahlberg, Miss. Gerda Ulrika","female",22,0,0,"7552",10.5167,?,"S",?,?,"Norrlot, Sweden Chicago, IL"
3,0,"Dakic, Mr. Branko","male",19,0,0,"349228",10.1708,?,"S",?,?,"Austria"
3,1,"Daly, Miss. Margaret Marcella 'Maggie'","female",30,0,0,"382650",6.95,?,"Q","15",?,"Co Athlone, Ireland New York, NY"
3,1,"Daly, Mr. Eugene Patrick","male",29,0,0,"382651",7.75,?,"Q","13 15 B",?,"Co Athlone, Ireland New York, NY"
3,0,"Danbom, Master. Gilbert Sigvard Emanuel","male",0.3333,0,2,"347080",14.4,?,"S",?,?,"Stanton, IA"
3,0,"Danbom, Mr. Ernst Gilbert","male",34,1,1,"347080",14.4,?,"S",?,197,"Stanton, IA"
3,0,"Danbom, Mrs. Ernst Gilbert (Anna Sigrid Maria Brogren)","female",28,1,1,"347080",14.4,?,"S",?,?,"Stanton, IA"
3,0,"Danoff, Mr. Yoto","male",27,0,0,"349219",7.8958,?,"S",?,?,"Bulgaria Chicago, IL"
3,0,"Dantcheff, Mr. Ristiu","male",25,0,0,"349203",7.8958,?,"S",?,?,"Bulgaria Chicago, IL"
3,0,"Davies, Mr. Alfred J","male",24,2,0,"A/4 48871",24.15,?,"S",?,?,"West Bromwich, England Pontiac, MI"
3,0,"Davies, Mr. Evan","male",22,0,0,"SC/A4 23568",8.05,?,"S",?,?,?
3,0,"Davies, Mr. John Samuel","male",21,2,0,"A/4 48871",24.15,?,"S",?,?,"West Bromwich, England Pontiac, MI"
3,0,"Davies, Mr. Joseph","male",17,2,0,"A/4 48873",8.05,?,"S",?,?,"West Bromwich, England Pontiac, MI"
3,0,"Davison, Mr. Thomas Henry","male",?,1,0,"386525",16.1,?,"S",?,?,"Liverpool, England Bedford, OH"
3,1,"Davison, Mrs. Thomas Henry (Mary E Finck)","female",?,1,0,"386525",16.1,?,"S","16",?,"Liverpool, England Bedford, OH"
3,1,"de Messemaeker, Mr. Guillaume Joseph","male",36.5,1,0,"345572",17.4,?,"S","15",?,"Tampico, MT"
3,1,"de Messemaeker, Mrs. Guillaume Joseph (Emma)","female",36,1,0,"345572",17.4,?,"S","13",?,"Tampico, MT"
3,1,"de Mulder, Mr. Theodore","male",30,0,0,"345774",9.5,?,"S","11",?,"Belgium Detroit, MI"
3,0,"de Pelsmaeker, Mr. Alfons","male",16,0,0,"345778",9.5,?,"S",?,?,?
3,1,"Dean, Master. Bertram Vere","male",1,1,2,"C.A. 2315",20.575,?,"S","10",?,"Devon, England Wichita, KS"
3,1,"Dean, Miss. Elizabeth Gladys 'Millvina'","female",0.1667,1,2,"C.A. 2315",20.575,?,"S","10",?,"Devon, England Wichita, KS"
3,0,"Dean, Mr. Bertram Frank","male",26,1,2,"C.A. 2315",20.575,?,"S",?,?,"Devon, England Wichita, KS"
3,1,"Dean, Mrs. Bertram (Eva Georgetta Light)","female",33,1,2,"C.A. 2315",20.575,?,"S","10",?,"Devon, England Wichita, KS"
3,0,"Delalic, Mr. Redjo","male",25,0,0,"349250",7.8958,?,"S",?,?,?
3,0,"Demetri, Mr. Marinko","male",?,0,0,"349238",7.8958,?,"S",?,?,?
3,0,"Denkoff, Mr. Mitto","male",?,0,0,"349225",7.8958,?,"S",?,?,"Bulgaria Coon Rapids, IA"
3,0,"Dennis, Mr. Samuel","male",22,0,0,"A/5 21172",7.25,?,"S",?,?,?
3,0,"Dennis, Mr. William","male",36,0,0,"A/5 21175",7.25,?,"S",?,?,?
3,1,"Devaney, Miss. Margaret Delia","female",19,0,0,"330958",7.8792,?,"Q","C",?,"Kilmacowen, Co Sligo, Ireland New York, NY"
3,0,"Dika, Mr. Mirko","male",17,0,0,"349232",7.8958,?,"S",?,?,?
3,0,"Dimic, Mr. Jovan","male",42,0,0,"315088",8.6625,?,"S",?,?,?
3,0,"Dintcheff, Mr. Valtcho","male",43,0,0,"349226",7.8958,?,"S",?,?,?
3,0,"Doharr, Mr. Tannous","male",?,0,0,"2686",7.2292,?,"C",?,?,?
3,0,"Dooley, Mr. Patrick","male",32,0,0,"370376",7.75,?,"Q",?,?,"Ireland New York, NY"
3,1,"Dorking, Mr. Edward Arthur","male",19,0,0,"A/5. 10482",8.05,?,"S","B",?,"England Oglesby, IL"
3,1,"Dowdell, Miss. Elizabeth","female",30,0,0,"364516",12.475,?,"S","13",?,"Union Hill, NJ"
3,0,"Doyle, Miss. Elizabeth","female",24,0,0,"368702",7.75,?,"Q",?,?,"Ireland New York, NY"
3,1,"Drapkin, Miss. Jennie","female",23,0,0,"SOTON/OQ 392083",8.05,?,"S",?,?,"London New York, NY"
3,0,"Drazenoic, Mr. Jozef","male",33,0,0,"349241",7.8958,?,"C",?,51,"Austria Niagara Falls, NY"
3,0,"Duane, Mr. Frank","male",65,0,0,"336439",7.75,?,"Q",?,?,?
3,1,"Duquemin, Mr. Joseph","male",24,0,0,"S.O./P.P. 752",7.55,?,"S","D",?,"England Albion, NY"
3,0,"Dyker, Mr. Adolf Fredrik","male",23,1,0,"347072",13.9,?,"S",?,?,"West Haven, CT"
3,1,"Dyker, Mrs. Adolf Fredrik (Anna Elisabeth Judith Andersson)","female",22,1,0,"347072",13.9,?,"S","16",?,"West Haven, CT"
3,0,"Edvardsson, Mr. Gustaf Hjalmar","male",18,0,0,"349912",7.775,?,"S",?,?,"Tofta, Sweden Joliet, IL"
3,0,"Eklund, Mr. Hans Linus","male",16,0,0,"347074",7.775,?,"S",?,?,"Karberg, Sweden Jerome Junction, AZ"
3,0,"Ekstrom, Mr. Johan","male",45,0,0,"347061",6.975,?,"S",?,?,"Effington Rut, SD"
3,0,"Elias, Mr. Dibo","male",?,0,0,"2674",7.225,?,"C",?,?,?
3,0,"Elias, Mr. Joseph","male",39,0,2,"2675",7.2292,?,"C",?,?,"Syria Ottawa, ON"
3,0,"Elias, Mr. Joseph Jr","male",17,1,1,"2690",7.2292,?,"C",?,?,?
3,0,"Elias, Mr. Tannous","male",15,1,1,"2695",7.2292,?,"C",?,?,"Syria"
3,0,"Elsbury, Mr. William James","male",47,0,0,"A/5 3902",7.25,?,"S",?,?,"Illinois, USA"
3,1,"Emanuel, Miss. Virginia Ethel","female",5,0,0,"364516",12.475,?,"S","13",?,"New York, NY"
3,0,"Emir, Mr. Farred Chehab","male",?,0,0,"2631",7.225,?,"C",?,?,?
3,0,"Everett, Mr. Thomas James","male",40.5,0,0,"C.A. 6212",15.1,?,"S",?,187,?
3,0,"Farrell, Mr. James","male",40.5,0,0,"367232",7.75,?,"Q",?,68,"Aughnacliff, Co Longford, Ireland New York, NY"
3,1,"Finoli, Mr. Luigi","male",?,0,0,"SOTON/O.Q. 3101308",7.05,?,"S","15",?,"Italy Philadelphia, PA"
3,0,"Fischer, Mr. Eberhard Thelander","male",18,0,0,"350036",7.7958,?,"S",?,?,?
3,0,"Fleming, Miss. Honora","female",?,0,0,"364859",7.75,?,"Q",?,?,?
3,0,"Flynn, Mr. James","male",?,0,0,"364851",7.75,?,"Q",?,?,?
3,0,"Flynn, Mr. John","male",?,0,0,"368323",6.95,?,"Q",?,?,?
3,0,"Foley, Mr. Joseph","male",26,0,0,"330910",7.8792,?,"Q",?,?,"Ireland Chicago, IL"
3,0,"Foley, Mr. William","male",?,0,0,"365235",7.75,?,"Q",?,?,"Ireland"
3,1,"Foo, Mr. Choong","male",?,0,0,"1601",56.4958,?,"S","13",?,"Hong Kong New York, NY"
3,0,"Ford, Miss. Doolina Margaret 'Daisy'","female",21,2,2,"W./C. 6608",34.375,?,"S",?,?,"Rotherfield, Sussex, England Essex Co, MA"
3,0,"Ford, Miss. Robina Maggie 'Ruby'","female",9,2,2,"W./C. 6608",34.375,?,"S",?,?,"Rotherfield, Sussex, England Essex Co, MA"
3,0,"Ford, Mr. Arthur","male",?,0,0,"A/5 1478",8.05,?,"S",?,?,"Bridgwater, Somerset, England"
3,0,"Ford, Mr. Edward Watson","male",18,2,2,"W./C. 6608",34.375,?,"S",?,?,"Rotherfield, Sussex, England Essex Co, MA"
3,0,"Ford, Mr. William Neal","male",16,1,3,"W./C. 6608",34.375,?,"S",?,?,"Rotherfield, Sussex, England Essex Co, MA"
3,0,"Ford, Mrs. Edward (Margaret Ann Watson)","female",48,1,3,"W./C. 6608",34.375,?,"S",?,?,"Rotherfield, Sussex, England Essex Co, MA"
3,0,"Fox, Mr. Patrick","male",?,0,0,"368573",7.75,?,"Q",?,?,"Ireland New York, NY"
3,0,"Franklin, Mr. Charles (Charles Fardon)","male",?,0,0,"SOTON/O.Q. 3101314",7.25,?,"S",?,?,?
3,0,"Gallagher, Mr. Martin","male",25,0,0,"36864",7.7417,?,"Q",?,?,"New York, NY"
3,0,"Garfirth, Mr. John","male",?,0,0,"358585",14.5,?,"S",?,?,?
3,0,"Gheorgheff, Mr. Stanio","male",?,0,0,"349254",7.8958,?,"C",?,?,?
3,0,"Gilinski, Mr. Eliezer","male",22,0,0,"14973",8.05,?,"S",?,47,?
3,1,"Gilnagh, Miss. Katherine 'Katie'","female",16,0,0,"35851",7.7333,?,"Q","16",?,"Co Longford, Ireland New York, NY"
3,1,"Glynn, Miss. Mary Agatha","female",?,0,0,"335677",7.75,?,"Q","13",?,"Co Clare, Ireland Washington, DC"
3,1,"Goldsmith, Master. Frank John William 'Frankie'","male",9,0,2,"363291",20.525,?,"S","C D",?,"Strood, Kent, England Detroit, MI"
3,0,"Goldsmith, Mr. Frank John","male",33,1,1,"363291",20.525,?,"S",?,?,"Strood, Kent, England Detroit, MI"
3,0,"Goldsmith, Mr. Nathan","male",41,0,0,"SOTON/O.Q. 3101263",7.85,?,"S",?,?,"Philadelphia, PA"
3,1,"Goldsmith, Mrs. Frank John (Emily Alice Brown)","female",31,1,1,"363291",20.525,?,"S","C D",?,"Strood, Kent, England Detroit, MI"
3,0,"Goncalves, Mr. Manuel Estanslas","male",38,0,0,"SOTON/O.Q. 3101306",7.05,?,"S",?,?,"Portugal"
3,0,"Goodwin, Master. Harold Victor","male",9,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Master. Sidney Leonard","male",1,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Master. William Frederick","male",11,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Miss. Jessie Allis","female",10,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Miss. Lillian Amy","female",16,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Mr. Charles Edward","male",14,5,2,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Mr. Charles Frederick","male",40,1,6,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Goodwin, Mrs. Frederick (Augusta Tyler)","female",43,1,6,"CA 2144",46.9,?,"S",?,?,"Wiltshire, England Niagara Falls, NY"
3,0,"Green, Mr. George Henry","male",51,0,0,"21440",8.05,?,"S",?,?,"Dorking, Surrey, England"
3,0,"Gronnestad, Mr. Daniel Danielsen","male",32,0,0,"8471",8.3625,?,"S",?,?,"Foresvik, Norway Portland, ND"
3,0,"Guest, Mr. Robert","male",?,0,0,"376563",8.05,?,"S",?,?,?
3,0,"Gustafsson, Mr. Alfred Ossian","male",20,0,0,"7534",9.8458,?,"S",?,?,"Waukegan, Chicago, IL"
3,0,"Gustafsson, Mr. Anders Vilhelm","male",37,2,0,"3101276",7.925,?,"S",?,98,"Ruotsinphytaa, Finland New York, NY"
3,0,"Gustafsson, Mr. Johan Birger","male",28,2,0,"3101277",7.925,?,"S",?,?,"Ruotsinphytaa, Finland New York, NY"
3,0,"Gustafsson, Mr. Karl Gideon","male",19,0,0,"347069",7.775,?,"S",?,?,"Myren, Sweden New York, NY"
3,0,"Haas, Miss. Aloisia","female",24,0,0,"349236",8.85,?,"S",?,?,?
3,0,"Hagardon, Miss. Kate","female",17,0,0,"AQ/3. 30631",7.7333,?,"Q",?,?,?
3,0,"Hagland, Mr. Ingvald Olai Olsen","male",?,1,0,"65303",19.9667,?,"S",?,?,?
3,0,"Hagland, Mr. Konrad Mathias Reiersen","male",?,1,0,"65304",19.9667,?,"S",?,?,?
3,0,"Hakkarainen, Mr. Pekka Pietari","male",28,1,0,"STON/O2. 3101279",15.85,?,"S",?,?,?
3,1,"Hakkarainen, Mrs. Pekka Pietari (Elin Matilda Dolck)","female",24,1,0,"STON/O2. 3101279",15.85,?,"S","15",?,?
3,0,"Hampe, Mr. Leon","male",20,0,0,"345769",9.5,?,"S",?,?,?
3,0,"Hanna, Mr. Mansour","male",23.5,0,0,"2693",7.2292,?,"C",?,188,?
3,0,"Hansen, Mr. Claus Peter","male",41,2,0,"350026",14.1083,?,"S",?,?,?
3,0,"Hansen, Mr. Henrik Juul","male",26,1,0,"350025",7.8542,?,"S",?,?,?
3,0,"Hansen, Mr. Henry Damsgaard","male",21,0,0,"350029",7.8542,?,"S",?,69,?
3,1,"Hansen, Mrs. Claus Peter (Jennie L Howard)","female",45,1,0,"350026",14.1083,?,"S","11",?,?
3,0,"Harknett, Miss. Alice Phoebe","female",?,0,0,"W./C. 6609",7.55,?,"S",?,?,?
3,0,"Harmer, Mr. Abraham (David Lishin)","male",25,0,0,"374887",7.25,?,"S","B",?,?
3,0,"Hart, Mr. Henry","male",?,0,0,"394140",6.8583,?,"Q",?,?,?
3,0,"Hassan, Mr. Houssein G N","male",11,0,0,"2699",18.7875,?,"C",?,?,?
3,1,"Healy, Miss. Hanora 'Nora'","female",?,0,0,"370375",7.75,?,"Q","16",?,?
3,1,"Hedman, Mr. Oskar Arvid","male",27,0,0,"347089",6.975,?,"S","15",?,?
3,1,"Hee, Mr. Ling","male",?,0,0,"1601",56.4958,?,"S","C",?,?
3,0,"Hegarty, Miss. Hanora 'Nora'","female",18,0,0,"365226",6.75,?,"Q",?,?,?
3,1,"Heikkinen, Miss. Laina","female",26,0,0,"STON/O2. 3101282",7.925,?,"S",?,?,?
3,0,"Heininen, Miss. Wendla Maria","female",23,0,0,"STON/O2. 3101290",7.925,?,"S",?,?,?
3,1,"Hellstrom, Miss. Hilda Maria","female",22,0,0,"7548",8.9625,?,"S","C",?,?
3,0,"Hendekovic, Mr. Ignjac","male",28,0,0,"349243",7.8958,?,"S",?,306,?
3,0,"Henriksson, Miss. Jenny Lovisa","female",28,0,0,"347086",7.775,?,"S",?,?,?
3,0,"Henry, Miss. Delia","female",?,0,0,"382649",7.75,?,"Q",?,?,?
3,1,"Hirvonen, Miss. Hildur E","female",2,0,1,"3101298",12.2875,?,"S","15",?,?
3,1,"Hirvonen, Mrs. Alexander (Helga E Lindqvist)","female",22,1,1,"3101298",12.2875,?,"S","15",?,?
3,0,"Holm, Mr. John Fredrik Alexander","male",43,0,0,"C 7075",6.45,?,"S",?,?,?
3,0,"Holthen, Mr. Johan Martin","male",28,0,0,"C 4001",22.525,?,"S",?,?,?
3,1,"Honkanen, Miss. Eliina","female",27,0,0,"STON/O2. 3101283",7.925,?,"S",?,?,?
3,0,"Horgan, Mr. John","male",?,0,0,"370377",7.75,?,"Q",?,?,?
3,1,"Howard, Miss. May Elizabeth","female",?,0,0,"A. 2. 39186",8.05,?,"S","C",?,?
3,0,"Humblen, Mr. Adolf Mathias Nicolai Olsen","male",42,0,0,"348121",7.65,"F G63","S",?,120,?
3,1,"Hyman, Mr. Abraham","male",?,0,0,"3470",7.8875,?,"S","C",?,?
3,0,"Ibrahim Shawah, Mr. Yousseff","male",30,0,0,"2685",7.2292,?,"C",?,?,?
3,0,"Ilieff, Mr. Ylio","male",?,0,0,"349220",7.8958,?,"S",?,?,?
3,0,"Ilmakangas, Miss. Ida Livija","female",27,1,0,"STON/O2. 3101270",7.925,?,"S",?,?,?
3,0,"Ilmakangas, Miss. Pieta Sofia","female",25,1,0,"STON/O2. 3101271",7.925,?,"S",?,?,?
3,0,"Ivanoff, Mr. Kanio","male",?,0,0,"349201",7.8958,?,"S",?,?,?
3,1,"Jalsevac, Mr. Ivan","male",29,0,0,"349240",7.8958,?,"C","15",?,?
3,1,"Jansson, Mr. Carl Olof","male",21,0,0,"350034",7.7958,?,"S","A",?,?
3,0,"Jardin, Mr. Jose Neto","male",?,0,0,"SOTON/O.Q. 3101305",7.05,?,"S",?,?,?
3,0,"Jensen, Mr. Hans Peder","male",20,0,0,"350050",7.8542,?,"S",?,?,?
3,0,"Jensen, Mr. Niels Peder","male",48,0,0,"350047",7.8542,?,"S",?,?,?
3,0,"Jensen, Mr. Svend Lauritz","male",17,1,0,"350048",7.0542,?,"S",?,?,?
3,1,"Jermyn, Miss. Annie","female",?,0,0,"14313",7.75,?,"Q","D",?,?
3,1,"Johannesen-Bratthammer, Mr. Bernt","male",?,0,0,"65306",8.1125,?,"S","13",?,?
3,0,"Johanson, Mr. Jakob Alfred","male",34,0,0,"3101264",6.4958,?,"S",?,143,?
3,1,"Johansson Palmquist, Mr. Oskar Leander","male",26,0,0,"347070",7.775,?,"S","15",?,?
3,0,"Johansson, Mr. Erik","male",22,0,0,"350052",7.7958,?,"S",?,156,?
3,0,"Johansson, Mr. Gustaf Joel","male",33,0,0,"7540",8.6542,?,"S",?,285,?
3,0,"Johansson, Mr. Karl Johan","male",31,0,0,"347063",7.775,?,"S",?,?,?
3,0,"Johansson, Mr. Nils","male",29,0,0,"347467",7.8542,?,"S",?,?,?
3,1,"Johnson, Master. Harold Theodor","male",4,1,1,"347742",11.1333,?,"S","15",?,?
3,1,"Johnson, Miss. Eleanor Ileen","female",1,1,1,"347742",11.1333,?,"S","15",?,?
3,0,"Johnson, Mr. Alfred","male",49,0,0,"LINE",0,?,"S",?,?,?
3,0,"Johnson, Mr. Malkolm Joackim","male",33,0,0,"347062",7.775,?,"S",?,37,?
3,0,"Johnson, Mr. William Cahoone Jr","male",19,0,0,"LINE",0,?,"S",?,?,?
3,1,"Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)","female",27,0,2,"347742",11.1333,?,"S","15",?,?
3,0,"Johnston, Master. William Arthur 'Willie'","male",?,1,2,"W./C. 6607",23.45,?,"S",?,?,?
3,0,"Johnston, Miss. Catherine Helen 'Carrie'","female",?,1,2,"W./C. 6607",23.45,?,"S",?,?,?
3,0,"Johnston, Mr. Andrew G","male",?,1,2,"W./C. 6607",23.45,?,"S",?,?,?
3,0,"Johnston, Mrs. Andrew G (Elizabeth 'Lily' Watson)","female",?,1,2,"W./C. 6607",23.45,?,"S",?,?,?
3,0,"Jonkoff, Mr. Lalio","male",23,0,0,"349204",7.8958,?,"S",?,?,?
3,1,"Jonsson, Mr. Carl","male",32,0,0,"350417",7.8542,?,"S","15",?,?
3,0,"Jonsson, Mr. Nils Hilding","male",27,0,0,"350408",7.8542,?,"S",?,?,?
3,0,"Jussila, Miss. Katriina","female",20,1,0,"4136",9.825,?,"S",?,?,?
3,0,"Jussila, Miss. Mari Aina","female",21,1,0,"4137",9.825,?,"S",?,?,?
3,1,"Jussila, Mr. Eiriik","male",32,0,0,"STON/O 2. 3101286",7.925,?,"S","15",?,?
3,0,"Kallio, Mr. Nikolai Erland","male",17,0,0,"STON/O 2. 3101274",7.125,?,"S",?,?,?
3,0,"Kalvik, Mr. Johannes Halvorsen","male",21,0,0,"8475",8.4333,?,"S",?,?,?
3,0,"Karaic, Mr. Milan","male",30,0,0,"349246",7.8958,?,"S",?,?,?
3,1,"Karlsson, Mr. Einar Gervasius","male",21,0,0,"350053",7.7958,?,"S","13",?,?
3,0,"Karlsson, Mr. Julius Konrad Eugen","male",33,0,0,"347465",7.8542,?,"S",?,?,?
3,0,"Karlsson, Mr. Nils August","male",22,0,0,"350060",7.5208,?,"S",?,?,?
3,1,"Karun, Miss. Manca","female",4,0,1,"349256",13.4167,?,"C","15",?,?
3,1,"Karun, Mr. Franz","male",39,0,1,"349256",13.4167,?,"C","15",?,?
3,0,"Kassem, Mr. Fared","male",?,0,0,"2700",7.2292,?,"C",?,?,?
3,0,"Katavelas, Mr. Vassilios ('Catavelas Vassilios')","male",18.5,0,0,"2682",7.2292,?,"C",?,58,?
3,0,"Keane, Mr. Andrew 'Andy'","male",?,0,0,"12460",7.75,?,"Q",?,?,?
3,0,"Keefe, Mr. Arthur","male",?,0,0,"323592",7.25,?,"S","A",?,?
3,1,"Kelly, Miss. Anna Katherine 'Annie Kate'","female",?,0,0,"9234",7.75,?,"Q","16",?,?
3,1,"Kelly, Miss. Mary","female",?,0,0,"14312",7.75,?,"Q","D",?,?
3,0,"Kelly, Mr. James","male",34.5,0,0,"330911",7.8292,?,"Q",?,70,?
3,0,"Kelly, Mr. James","male",44,0,0,"363592",8.05,?,"S",?,?,?
3,1,"Kennedy, Mr. John","male",?,0,0,"368783",7.75,?,"Q",?,?,?
3,0,"Khalil, Mr. Betros","male",?,1,0,"2660",14.4542,?,"C",?,?,?
3,0,"Khalil, Mrs. Betros (Zahie 'Maria' Elias)","female",?,1,0,"2660",14.4542,?,"C",?,?,?
3,0,"Kiernan, Mr. John","male",?,1,0,"367227",7.75,?,"Q",?,?,?
3,0,"Kiernan, Mr. Philip","male",?,1,0,"367229",7.75,?,"Q",?,?,?
3,0,"Kilgannon, Mr. Thomas J","male",?,0,0,"36865",7.7375,?,"Q",?,?,?
3,0,"Kink, Miss. Maria","female",22,2,0,"315152",8.6625,?,"S",?,?,?
3,0,"Kink, Mr. Vincenz","male",26,2,0,"315151",8.6625,?,"S",?,?,?
3,1,"Kink-Heilmann, Miss. Luise Gretchen","female",4,0,2,"315153",22.025,?,"S","2",?,?
3,1,"Kink-Heilmann, Mr. Anton","male",29,3,1,"315153",22.025,?,"S","2",?,?
3,1,"Kink-Heilmann, Mrs. Anton (Luise Heilmann)","female",26,1,1,"315153",22.025,?,"S","2",?,?
3,0,"Klasen, Miss. Gertrud Emilia","female",1,1,1,"350405",12.1833,?,"S",?,?,?
3,0,"Klasen, Mr. Klas Albin","male",18,1,1,"350404",7.8542,?,"S",?,?,?
3,0,"Klasen, Mrs. (Hulda Kristina Eugenia Lofqvist)","female",36,0,2,"350405",12.1833,?,"S",?,?,?
3,0,"Kraeff, Mr. Theodor","male",?,0,0,"349253",7.8958,?,"C",?,?,?
3,1,"Krekorian, Mr. Neshan","male",25,0,0,"2654",7.2292,"F E57","C","10",?,?
3,0,"Lahoud, Mr. Sarkis","male",?,0,0,"2624",7.225,?,"C",?,?,?
3,0,"Laitinen, Miss. Kristina Sofia","female",37,0,0,"4135",9.5875,?,"S",?,?,?
3,0,"Laleff, Mr. Kristo","male",?,0,0,"349217",7.8958,?,"S",?,?,?
3,1,"Lam, Mr. Ali","male",?,0,0,"1601",56.4958,?,"S","C",?,?
3,0,"Lam, Mr. Len","male",?,0,0,"1601",56.4958,?,"S",?,?,?
3,1,"Landergren, Miss. Aurora Adelia","female",22,0,0,"C 7077",7.25,?,"S","13",?,?
3,0,"Lane, Mr. Patrick","male",?,0,0,"7935",7.75,?,"Q",?,?,?
3,1,"Lang, Mr. Fang","male",26,0,0,"1601",56.4958,?,"S","14",?,?
3,0,"Larsson, Mr. August Viktor","male",29,0,0,"7545",9.4833,?,"S",?,?,?
3,0,"Larsson, Mr. Bengt Edvin","male",29,0,0,"347067",7.775,?,"S",?,?,?
3,0,"Larsson-Rondberg, Mr. Edvard A","male",22,0,0,"347065",7.775,?,"S",?,?,?
3,1,"Leeni, Mr. Fahim ('Philip Zenni')","male",22,0,0,"2620",7.225,?,"C","6",?,?
3,0,"Lefebre, Master. Henry Forbes","male",?,3,1,"4133",25.4667,?,"S",?,?,?
3,0,"Lefebre, Miss. Ida","female",?,3,1,"4133",25.4667,?,"S",?,?,?
3,0,"Lefebre, Miss. Jeannie","female",?,3,1,"4133",25.4667,?,"S",?,?,?
3,0,"Lefebre, Miss. Mathilde","female",?,3,1,"4133",25.4667,?,"S",?,?,?
3,0,"Lefebre, Mrs. Frank (Frances)","female",?,0,4,"4133",25.4667,?,"S",?,?,?
3,0,"Leinonen, Mr. Antti Gustaf","male",32,0,0,"STON/O 2. 3101292",7.925,?,"S",?,?,?
3,0,"Lemberopolous, Mr. Peter L","male",34.5,0,0,"2683",6.4375,?,"C",?,196,?
3,0,"Lennon, Miss. Mary","female",?,1,0,"370371",15.5,?,"Q",?,?,?
3,0,"Lennon, Mr. Denis","male",?,1,0,"370371",15.5,?,"Q",?,?,?
3,0,"Leonard, Mr. Lionel","male",36,0,0,"LINE",0,?,"S",?,?,?
3,0,"Lester, Mr. James","male",39,0,0,"A/4 48871",24.15,?,"S",?,?,?
3,0,"Lievens, Mr. Rene Aime","male",24,0,0,"345781",9.5,?,"S",?,?,?
3,0,"Lindahl, Miss. Agda Thorilda Viktoria","female",25,0,0,"347071",7.775,?,"S",?,?,?
3,0,"Lindblom, Miss. Augusta Charlotta","female",45,0,0,"347073",7.75,?,"S",?,?,?
3,0,"Lindell, Mr. Edvard Bengtsson","male",36,1,0,"349910",15.55,?,"S","A",?,?
3,0,"Lindell, Mrs. Edvard Bengtsson (Elin Gerda Persson)","female",30,1,0,"349910",15.55,?,"S","A",?,?
3,1,"Lindqvist, Mr. Eino William","male",20,1,0,"STON/O 2. 3101285",7.925,?,"S","15",?,?
3,0,"Linehan, Mr. Michael","male",?,0,0,"330971",7.8792,?,"Q",?,?,?
3,0,"Ling, Mr. Lee","male",28,0,0,"1601",56.4958,?,"S",?,?,?
3,0,"Lithman, Mr. Simon","male",?,0,0,"S.O./P.P. 251",7.55,?,"S",?,?,?
3,0,"Lobb, Mr. William Arthur","male",30,1,0,"A/5. 3336",16.1,?,"S",?,?,?
3,0,"Lobb, Mrs. William Arthur (Cordelia K Stanlick)","female",26,1,0,"A/5. 3336",16.1,?,"S",?,?,?
3,0,"Lockyer, Mr. Edward","male",?,0,0,"1222",7.8792,?,"S",?,153,?
3,0,"Lovell, Mr. John Hall ('Henry')","male",20.5,0,0,"A/5 21173",7.25,?,"S",?,?,?
3,1,"Lulic, Mr. Nikola","male",27,0,0,"315098",8.6625,?,"S","15",?,?
3,0,"Lundahl, Mr. Johan Svensson","male",51,0,0,"347743",7.0542,?,"S",?,?,?
3,1,"Lundin, Miss. Olga Elida","female",23,0,0,"347469",7.8542,?,"S","10",?,?
3,1,"Lundstrom, Mr. Thure Edvin","male",32,0,0,"350403",7.5792,?,"S","15",?,?
3,0,"Lyntakoff, Mr. Stanko","male",?,0,0,"349235",7.8958,?,"S",?,?,?
3,0,"MacKay, Mr. George William","male",?,0,0,"C.A. 42795",7.55,?,"S",?,?,?
3,1,"Madigan, Miss. Margaret 'Maggie'","female",?,0,0,"370370",7.75,?,"Q","15",?,?
3,1,"Madsen, Mr. Fridtjof Arne","male",24,0,0,"C 17369",7.1417,?,"S","13",?,?
3,0,"Maenpaa, Mr. Matti Alexanteri","male",22,0,0,"STON/O 2. 3101275",7.125,?,"S",?,?,?
3,0,"Mahon, Miss. Bridget Delia","female",?,0,0,"330924",7.8792,?,"Q",?,?,?
3,0,"Mahon, Mr. John","male",?,0,0,"AQ/4 3130",7.75,?,"Q",?,?,?
3,0,"Maisner, Mr. Simon","male",?,0,0,"A/S 2816",8.05,?,"S",?,?,?
3,0,"Makinen, Mr. Kalle Edvard","male",29,0,0,"STON/O 2. 3101268",7.925,?,"S",?,?,?
3,1,"Mamee, Mr. Hanna","male",?,0,0,"2677",7.2292,?,"C","15",?,?
3,0,"Mangan, Miss. Mary","female",30.5,0,0,"364850",7.75,?,"Q",?,61,?
3,1,"Mannion, Miss. Margareth","female",?,0,0,"36866",7.7375,?,"Q","16",?,?
3,0,"Mardirosian, Mr. Sarkis","male",?,0,0,"2655",7.2292,"F E46","C",?,?,?
3,0,"Markoff, Mr. Marin","male",35,0,0,"349213",7.8958,?,"C",?,?,?
3,0,"Markun, Mr. Johann","male",33,0,0,"349257",7.8958,?,"S",?,?,?
3,1,"Masselmani, Mrs. Fatima","female",?,0,0,"2649",7.225,?,"C","C",?,?
3,0,"Matinoff, Mr. Nicola","male",?,0,0,"349255",7.8958,?,"C",?,?,?
3,1,"McCarthy, Miss. Catherine 'Katie'","female",?,0,0,"383123",7.75,?,"Q","15 16",?,?
3,1,"McCormack, Mr. Thomas Joseph","male",?,0,0,"367228",7.75,?,"Q",?,?,?
3,1,"McCoy, Miss. Agnes","female",?,2,0,"367226",23.25,?,"Q","16",?,?
3,1,"McCoy, Miss. Alicia","female",?,2,0,"367226",23.25,?,"Q","16",?,?
3,1,"McCoy, Mr. Bernard","male",?,2,0,"367226",23.25,?,"Q","16",?,?
3,1,"McDermott, Miss. Brigdet Delia","female",?,0,0,"330932",7.7875,?,"Q","13",?,?
3,0,"McEvoy, Mr. Michael","male",?,0,0,"36568",15.5,?,"Q",?,?,?
3,1,"McGovern, Miss. Mary","female",?,0,0,"330931",7.8792,?,"Q","13",?,?
3,1,"McGowan, Miss. Anna 'Annie'","female",15,0,0,"330923",8.0292,?,"Q",?,?,?
3,0,"McGowan, Miss. Katherine","female",35,0,0,"9232",7.75,?,"Q",?,?,?
3,0,"McMahon, Mr. Martin","male",?,0,0,"370372",7.75,?,"Q",?,?,?
3,0,"McNamee, Mr. Neal","male",24,1,0,"376566",16.1,?,"S",?,?,?
3,0,"McNamee, Mrs. Neal (Eileen O'Leary)","female",19,1,0,"376566",16.1,?,"S",?,53,?
3,0,"McNeill, Miss. Bridget","female",?,0,0,"370368",7.75,?,"Q",?,?,?
3,0,"Meanwell, Miss. (Marion Ogden)","female",?,0,0,"SOTON/O.Q. 392087",8.05,?,"S",?,?,?
3,0,"Meek, Mrs. Thomas (Annie Louise Rowley)","female",?,0,0,"343095",8.05,?,"S",?,?,?
3,0,"Meo, Mr. Alfonzo","male",55.5,0,0,"A.5. 11206",8.05,?,"S",?,201,?
3,0,"Mernagh, Mr. Robert","male",?,0,0,"368703",7.75,?,"Q",?,?,?
3,1,"Midtsjo, Mr. Karl Albert","male",21,0,0,"345501",7.775,?,"S","15",?,?
3,0,"Miles, Mr. Frank","male",?,0,0,"359306",8.05,?,"S",?,?,?
3,0,"Mineff, Mr. Ivan","male",24,0,0,"349233",7.8958,?,"S",?,?,?
3,0,"Minkoff, Mr. Lazar","male",21,0,0,"349211",7.8958,?,"S",?,?,?
3,0,"Mionoff, Mr. Stoytcho","male",28,0,0,"349207",7.8958,?,"S",?,?,?
3,0,"Mitkoff, Mr. Mito","male",?,0,0,"349221",7.8958,?,"S",?,?,?
3,1,"Mockler, Miss. Helen Mary 'Ellie'","female",?,0,0,"330980",7.8792,?,"Q","16",?,?
3,0,"Moen, Mr. Sigurd Hansen","male",25,0,0,"348123",7.65,"F G73","S",?,309,?
3,1,"Moor, Master. Meier","male",6,0,1,"392096",12.475,"E121","S","14",?,?
3,1,"Moor, Mrs. (Beila)","female",27,0,1,"392096",12.475,"E121","S","14",?,?
3,0,"Moore, Mr. Leonard Charles","male",?,0,0,"A4. 54510",8.05,?,"S",?,?,?
3,1,"Moran, Miss. Bertha","female",?,1,0,"371110",24.15,?,"Q","16",?,?
3,0,"Moran, Mr. Daniel J","male",?,1,0,"371110",24.15,?,"Q",?,?,?
3,0,"Moran, Mr. James","male",?,0,0,"330877",8.4583,?,"Q",?,?,?
3,0,"Morley, Mr. William","male",34,0,0,"364506",8.05,?,"S",?,?,?
3,0,"Morrow, Mr. Thomas Rowan","male",?,0,0,"372622",7.75,?,"Q",?,?,?
3,1,"Moss, Mr. Albert Johan","male",?,0,0,"312991",7.775,?,"S","B",?,?
3,1,"Moubarek, Master. Gerios","male",?,1,1,"2661",15.2458,?,"C","C",?,?
3,1,"Moubarek, Master. Halim Gonios ('William George')","male",?,1,1,"2661",15.2458,?,"C","C",?,?
3,1,"Moubarek, Mrs. George (Omine 'Amenia' Alexander)","female",?,0,2,"2661",15.2458,?,"C","C",?,?
3,1,"Moussa, Mrs. (Mantoura Boulos)","female",?,0,0,"2626",7.2292,?,"C",?,?,?
3,0,"Moutal, Mr. Rahamin Haim","male",?,0,0,"374746",8.05,?,"S",?,?,?
3,1,"Mullens, Miss. Katherine 'Katie'","female",?,0,0,"35852",7.7333,?,"Q","16",?,?
3,1,"Mulvihill, Miss. Bertha E","female",24,0,0,"382653",7.75,?,"Q","15",?,?
3,0,"Murdlin, Mr. Joseph","male",?,0,0,"A./5. 3235",8.05,?,"S",?,?,?
3,1,"Murphy, Miss. Katherine 'Kate'","female",?,1,0,"367230",15.5,?,"Q","16",?,?
3,1,"Murphy, Miss. Margaret Jane","female",?,1,0,"367230",15.5,?,"Q","16",?,?
3,1,"Murphy, Miss. Nora","female",?,0,0,"36568",15.5,?,"Q","16",?,?
3,0,"Myhrman, Mr. Pehr Fabian Oliver Malkolm","male",18,0,0,"347078",7.75,?,"S",?,?,?
3,0,"Naidenoff, Mr. Penko","male",22,0,0,"349206",7.8958,?,"S",?,?,?
3,1,"Najib, Miss. Adele Kiamie 'Jane'","female",15,0,0,"2667",7.225,?,"C","C",?,?
3,1,"Nakid, Miss. Maria ('Mary')","female",1,0,2,"2653",15.7417,?,"C","C",?,?
3,1,"Nakid, Mr. Sahid","male",20,1,1,"2653",15.7417,?,"C","C",?,?
3,1,"Nakid, Mrs. Said (Waika 'Mary' Mowad)","female",19,1,1,"2653",15.7417,?,"C","C",?,?
3,0,"Nancarrow, Mr. William Henry","male",33,0,0,"A./5. 3338",8.05,?,"S",?,?,?
3,0,"Nankoff, Mr. Minko","male",?,0,0,"349218",7.8958,?,"S",?,?,?
3,0,"Nasr, Mr. Mustafa","male",?,0,0,"2652",7.2292,?,"C",?,?,?
3,0,"Naughton, Miss. Hannah","female",?,0,0,"365237",7.75,?,"Q",?,?,?
3,0,"Nenkoff, Mr. Christo","male",?,0,0,"349234",7.8958,?,"S",?,?,?
3,1,"Nicola-Yarred, Master. Elias","male",12,1,0,"2651",11.2417,?,"C","C",?,?
3,1,"Nicola-Yarred, Miss. Jamila","female",14,1,0,"2651",11.2417,?,"C","C",?,?
3,0,"Nieminen, Miss. Manta Josefina","female",29,0,0,"3101297",7.925,?,"S",?,?,?
3,0,"Niklasson, Mr. Samuel","male",28,0,0,"363611",8.05,?,"S",?,?,?
3,1,"Nilsson, Miss. Berta Olivia","female",18,0,0,"347066",7.775,?,"S","D",?,?
3,1,"Nilsson, Miss. Helmina Josefina","female",26,0,0,"347470",7.8542,?,"S","13",?,?
3,0,"Nilsson, Mr. August Ferdinand","male",21,0,0,"350410",7.8542,?,"S",?,?,?
3,0,"Nirva, Mr. Iisakki Antino Aijo","male",41,0,0,"SOTON/O2 3101272",7.125,?,"S",?,?,"Finland Sudbury, ON"
3,1,"Niskanen, Mr. Juha","male",39,0,0,"STON/O 2. 3101289",7.925,?,"S","9",?,?
3,0,"Nosworthy, Mr. Richard Cater","male",21,0,0,"A/4. 39886",7.8,?,"S",?,?,?
3,0,"Novel, Mr. Mansouer","male",28.5,0,0,"2697",7.2292,?,"C",?,181,?
3,1,"Nysten, Miss. Anna Sofia","female",22,0,0,"347081",7.75,?,"S","13",?,?
3,0,"Nysveen, Mr. Johan Hansen","male",61,0,0,"345364",6.2375,?,"S",?,?,?
3,0,"O'Brien, Mr. Thomas","male",?,1,0,"370365",15.5,?,"Q",?,?,?
3,0,"O'Brien, Mr. Timothy","male",?,0,0,"330979",7.8292,?,"Q",?,?,?
3,1,"O'Brien, Mrs. Thomas (Johanna 'Hannah' Godfrey)","female",?,1,0,"370365",15.5,?,"Q",?,?,?
3,0,"O'Connell, Mr. Patrick D","male",?,0,0,"334912",7.7333,?,"Q",?,?,?
3,0,"O'Connor, Mr. Maurice","male",?,0,0,"371060",7.75,?,"Q",?,?,?
3,0,"O'Connor, Mr. Patrick","male",?,0,0,"366713",7.75,?,"Q",?,?,?
3,0,"Odahl, Mr. Nils Martin","male",23,0,0,"7267",9.225,?,"S",?,?,?
3,0,"O'Donoghue, Ms. Bridget","female",?,0,0,"364856",7.75,?,"Q",?,?,?
3,1,"O'Driscoll, Miss. Bridget","female",?,0,0,"14311",7.75,?,"Q","D",?,?
3,1,"O'Dwyer, Miss. Ellen 'Nellie'","female",?,0,0,"330959",7.8792,?,"Q",?,?,?
3,1,"Ohman, Miss. Velin","female",22,0,0,"347085",7.775,?,"S","C",?,?
3,1,"O'Keefe, Mr. Patrick","male",?,0,0,"368402",7.75,?,"Q","B",?,?
3,1,"O'Leary, Miss. Hanora 'Norah'","female",?,0,0,"330919",7.8292,?,"Q","13",?,?
3,1,"Olsen, Master. Artur Karl","male",9,0,1,"C 17368",3.1708,?,"S","13",?,?
3,0,"Olsen, Mr. Henry Margido","male",28,0,0,"C 4001",22.525,?,"S",?,173,?
3,0,"Olsen, Mr. Karl Siegwart Andreas","male",42,0,1,"4579",8.4042,?,"S",?,?,?
3,0,"Olsen, Mr. Ole Martin","male",?,0,0,"Fa 265302",7.3125,?,"S",?,?,?
3,0,"Olsson, Miss. Elina","female",31,0,0,"350407",7.8542,?,"S",?,?,?
3,0,"Olsson, Mr. Nils Johan Goransson","male",28,0,0,"347464",7.8542,?,"S",?,?,?
3,1,"Olsson, Mr. Oscar Wilhelm","male",32,0,0,"347079",7.775,?,"S","A",?,?
3,0,"Olsvigen, Mr. Thor Anderson","male",20,0,0,"6563",9.225,?,"S",?,89,"Oslo, Norway Cameron, WI"
3,0,"Oreskovic, Miss. Jelka","female",23,0,0,"315085",8.6625,?,"S",?,?,?
3,0,"Oreskovic, Miss. Marija","female",20,0,0,"315096",8.6625,?,"S",?,?,?
3,0,"Oreskovic, Mr. Luka","male",20,0,0,"315094",8.6625,?,"S",?,?,?
3,0,"Osen, Mr. Olaf Elon","male",16,0,0,"7534",9.2167,?,"S",?,?,?
3,1,"Osman, Mrs. Mara","female",31,0,0,"349244",8.6833,?,"S",?,?,?
3,0,"O'Sullivan, Miss. Bridget Mary","female",?,0,0,"330909",7.6292,?,"Q",?,?,?
3,0,"Palsson, Master. Gosta Leonard","male",2,3,1,"349909",21.075,?,"S",?,4,?
3,0,"Palsson, Master. Paul Folke","male",6,3,1,"349909",21.075,?,"S",?,?,?
3,0,"Palsson, Miss. Stina Viola","female",3,3,1,"349909",21.075,?,"S",?,?,?
3,0,"Palsson, Miss. Torborg Danira","female",8,3,1,"349909",21.075,?,"S",?,?,?
3,0,"Palsson, Mrs. Nils (Alma Cornelia Berglund)","female",29,0,4,"349909",21.075,?,"S",?,206,?
3,0,"Panula, Master. Eino Viljami","male",1,4,1,"3101295",39.6875,?,"S",?,?,?
3,0,"Panula, Master. Juha Niilo","male",7,4,1,"3101295",39.6875,?,"S",?,?,?
3,0,"Panula, Master. Urho Abraham","male",2,4,1,"3101295",39.6875,?,"S",?,?,?
3,0,"Panula, Mr. Ernesti Arvid","male",16,4,1,"3101295",39.6875,?,"S",?,?,?
3,0,"Panula, Mr. Jaako Arnold","male",14,4,1,"3101295",39.6875,?,"S",?,?,?
3,0,"Panula, Mrs. Juha (Maria Emilia Ojala)","female",41,0,5,"3101295",39.6875,?,"S",?,?,?
3,0,"Pasic, Mr. Jakob","male",21,0,0,"315097",8.6625,?,"S",?,?,?
3,0,"Patchett, Mr. George","male",19,0,0,"358585",14.5,?,"S",?,?,?
3,0,"Paulner, Mr. Uscher","male",?,0,0,"3411",8.7125,?,"C",?,?,?
3,0,"Pavlovic, Mr. Stefo","male",32,0,0,"349242",7.8958,?,"S",?,?,?
3,0,"Peacock, Master. Alfred Edward","male",0.75,1,1,"SOTON/O.Q. 3101315",13.775,?,"S",?,?,?
3,0,"Peacock, Miss. Treasteall","female",3,1,1,"SOTON/O.Q. 3101315",13.775,?,"S",?,?,?
3,0,"Peacock, Mrs. Benjamin (Edith Nile)","female",26,0,2,"SOTON/O.Q. 3101315",13.775,?,"S",?,?,?
3,0,"Pearce, Mr. Ernest","male",?,0,0,"343271",7,?,"S",?,?,?
3,0,"Pedersen, Mr. Olaf","male",?,0,0,"345498",7.775,?,"S",?,?,?
3,0,"Peduzzi, Mr. Joseph","male",?,0,0,"A/5 2817",8.05,?,"S",?,?,?
3,0,"Pekoniemi, Mr. Edvard","male",21,0,0,"STON/O 2. 3101294",7.925,?,"S",?,?,?
3,0,"Peltomaki, Mr. Nikolai Johannes","male",25,0,0,"STON/O 2. 3101291",7.925,?,"S",?,?,?
3,0,"Perkin, Mr. John Henry","male",22,0,0,"A/5 21174",7.25,?,"S",?,?,?
3,1,"Persson, Mr. Ernst Ulrik","male",25,1,0,"347083",7.775,?,"S","15",?,?
3,1,"Peter, Master. Michael J","male",?,1,1,"2668",22.3583,?,"C","C",?,?
3,1,"Peter, Miss. Anna","female",?,1,1,"2668",22.3583,"F E69","C","D",?,?
3,1,"Peter, Mrs. Catherine (Catherine Rizk)","female",?,0,2,"2668",22.3583,?,"C","D",?,?
3,0,"Peters, Miss. Katie","female",?,0,0,"330935",8.1375,?,"Q",?,?,?
3,0,"Petersen, Mr. Marius","male",24,0,0,"342441",8.05,?,"S",?,?,?
3,0,"Petranec, Miss. Matilda","female",28,0,0,"349245",7.8958,?,"S",?,?,?
3,0,"Petroff, Mr. Nedelio","male",19,0,0,"349212",7.8958,?,"S",?,?,?
3,0,"Petroff, Mr. Pastcho ('Pentcho')","male",?,0,0,"349215",7.8958,?,"S",?,?,?
3,0,"Petterson, Mr. Johan Emil","male",25,1,0,"347076",7.775,?,"S",?,?,?
3,0,"Pettersson, Miss. Ellen Natalia","female",18,0,0,"347087",7.775,?,"S",?,?,?
3,1,"Pickard, Mr. Berk (Berk Trembisky)","male",32,0,0,"SOTON/O.Q. 392078",8.05,"E10","S","9",?,?
3,0,"Plotcharsky, Mr. Vasil","male",?,0,0,"349227",7.8958,?,"S",?,?,?
3,0,"Pokrnic, Mr. Mate","male",17,0,0,"315095",8.6625,?,"S",?,?,?
3,0,"Pokrnic, Mr. Tome","male",24,0,0,"315092",8.6625,?,"S",?,?,?
3,0,"Radeff, Mr. Alexander","male",?,0,0,"349223",7.8958,?,"S",?,?,?
3,0,"Rasmussen, Mrs. (Lena Jacobsen Solvang)","female",?,0,0,"65305",8.1125,?,"S",?,?,?
3,0,"Razi, Mr. Raihed","male",?,0,0,"2629",7.2292,?,"C",?,?,?
3,0,"Reed, Mr. James George","male",?,0,0,"362316",7.25,?,"S",?,?,?
3,0,"Rekic, Mr. Tido","male",38,0,0,"349249",7.8958,?,"S",?,?,?
3,0,"Reynolds, Mr. Harold J","male",21,0,0,"342684",8.05,?,"S",?,?,?
3,0,"Rice, Master. Albert","male",10,4,1,"382652",29.125,?,"Q",?,?,?
3,0,"Rice, Master. Arthur","male",4,4,1,"382652",29.125,?,"Q",?,?,?
3,0,"Rice, Master. Eric","male",7,4,1,"382652",29.125,?,"Q",?,?,?
3,0,"Rice, Master. Eugene","male",2,4,1,"382652",29.125,?,"Q",?,?,?
3,0,"Rice, Master. George Hugh","male",8,4,1,"382652",29.125,?,"Q",?,?,?
3,0,"Rice, Mrs. William (Margaret Norton)","female",39,0,5,"382652",29.125,?,"Q",?,327,?
3,0,"Riihivouri, Miss. Susanna Juhantytar 'Sanni'","female",22,0,0,"3101295",39.6875,?,"S",?,?,?
3,0,"Rintamaki, Mr. Matti","male",35,0,0,"STON/O 2. 3101273",7.125,?,"S",?,?,?
3,1,"Riordan, Miss. Johanna 'Hannah'","female",?,0,0,"334915",7.7208,?,"Q","13",?,?
3,0,"Risien, Mr. Samuel Beard","male",?,0,0,"364498",14.5,?,"S",?,?,?
3,0,"Risien, Mrs. Samuel (Emma)","female",?,0,0,"364498",14.5,?,"S",?,?,?
3,0,"Robins, Mr. Alexander A","male",50,1,0,"A/5. 3337",14.5,?,"S",?,119,?
3,0,"Robins, Mrs. Alexander A (Grace Charity Laury)","female",47,1,0,"A/5. 3337",14.5,?,"S",?,7,?
3,0,"Rogers, Mr. William John","male",?,0,0,"S.C./A.4. 23567",8.05,?,"S",?,?,?
3,0,"Rommetvedt, Mr. Knud Paust","male",?,0,0,"312993",7.775,?,"S",?,?,?
3,0,"Rosblom, Miss. Salli Helena","female",2,1,1,"370129",20.2125,?,"S",?,?,?
3,0,"Rosblom, Mr. Viktor Richard","male",18,1,1,"370129",20.2125,?,"S",?,?,?
3,0,"Rosblom, Mrs. Viktor (Helena Wilhelmina)","female",41,0,2,"370129",20.2125,?,"S",?,?,?
3,1,"Roth, Miss. Sarah A","female",?,0,0,"342712",8.05,?,"S","C",?,?
3,0,"Rouse, Mr. Richard Henry","male",50,0,0,"A/5 3594",8.05,?,"S",?,?,?
3,0,"Rush, Mr. Alfred George John","male",16,0,0,"A/4. 20589",8.05,?,"S",?,?,?
3,1,"Ryan, Mr. Edward","male",?,0,0,"383162",7.75,?,"Q","14",?,?
3,0,"Ryan, Mr. Patrick","male",?,0,0,"371110",24.15,?,"Q",?,?,?
3,0,"Saad, Mr. Amin","male",?,0,0,"2671",7.2292,?,"C",?,?,?
3,0,"Saad, Mr. Khalil","male",25,0,0,"2672",7.225,?,"C",?,?,?
3,0,"Saade, Mr. Jean Nassr","male",?,0,0,"2676",7.225,?,"C",?,?,?
3,0,"Sadlier, Mr. Matthew","male",?,0,0,"367655",7.7292,?,"Q",?,?,?
3,0,"Sadowitz, Mr. Harry","male",?,0,0,"LP 1588",7.575,?,"S",?,?,?
3,0,"Saether, Mr. Simon Sivertsen","male",38.5,0,0,"SOTON/O.Q. 3101262",7.25,?,"S",?,32,?
3,0,"Sage, Master. Thomas Henry","male",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Master. William Henry","male",14.5,8,2,"CA. 2343",69.55,?,"S",?,67,?
3,0,"Sage, Miss. Ada","female",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Miss. Constance Gladys","female",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Miss. Dorothy Edith 'Dolly'","female",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Miss. Stella Anna","female",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Mr. Douglas Bullen","male",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Mr. Frederick","male",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Mr. George John Jr","male",?,8,2,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Mr. John George","male",?,1,9,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Sage, Mrs. John (Annie Bullen)","female",?,1,9,"CA. 2343",69.55,?,"S",?,?,?
3,0,"Salander, Mr. Karl Johan","male",24,0,0,"7266",9.325,?,"S",?,?,?
3,1,"Salkjelsvik, Miss. Anna Kristine","female",21,0,0,"343120",7.65,?,"S","C",?,?
3,0,"Salonen, Mr. Johan Werner","male",39,0,0,"3101296",7.925,?,"S",?,?,?
3,0,"Samaan, Mr. Elias","male",?,2,0,"2662",21.6792,?,"C",?,?,?
3,0,"Samaan, Mr. Hanna","male",?,2,0,"2662",21.6792,?,"C",?,?,?
3,0,"Samaan, Mr. Youssef","male",?,2,0,"2662",21.6792,?,"C",?,?,?
3,1,"Sandstrom, Miss. Beatrice Irene","female",1,1,1,"PP 9549",16.7,"G6","S","13",?,?
3,1,"Sandstrom, Mrs. Hjalmar (Agnes Charlotta Bengtsson)","female",24,0,2,"PP 9549",16.7,"G6","S","13",?,?
3,1,"Sandstrom, Miss. Marguerite Rut","female",4,1,1,"PP 9549",16.7,"G6","S","13",?,?
3,1,"Sap, Mr. Julius","male",25,0,0,"345768",9.5,?,"S","11",?,?
3,0,"Saundercock, Mr. William Henry","male",20,0,0,"A/5. 2151",8.05,?,"S",?,?,?
3,0,"Sawyer, Mr. Frederick Charles","male",24.5,0,0,"342826",8.05,?,"S",?,284,?
3,0,"Scanlan, Mr. James","male",?,0,0,"36209",7.725,?,"Q",?,?,?
3,0,"Sdycoff, Mr. Todor","male",?,0,0,"349222",7.8958,?,"S",?,?,?
3,0,"Shaughnessy, Mr. Patrick","male",?,0,0,"370374",7.75,?,"Q",?,?,?
3,1,"Sheerlinck, Mr. Jan Baptist","male",29,0,0,"345779",9.5,?,"S","11",?,?
3,0,"Shellard, Mr. Frederick William","male",?,0,0,"C.A. 6212",15.1,?,"S",?,?,?
3,1,"Shine, Miss. Ellen Natalia","female",?,0,0,"330968",7.7792,?,"Q",?,?,?
3,0,"Shorney, Mr. Charles Joseph","male",?,0,0,"374910",8.05,?,"S",?,?,?
3,0,"Simmons, Mr. John","male",?,0,0,"SOTON/OQ 392082",8.05,?,"S",?,?,?
3,0,"Sirayanian, Mr. Orsen","male",22,0,0,"2669",7.2292,?,"C",?,?,?
3,0,"Sirota, Mr. Maurice","male",?,0,0,"392092",8.05,?,"S",?,?,?
3,0,"Sivic, Mr. Husein","male",40,0,0,"349251",7.8958,?,"S",?,?,?
3,0,"Sivola, Mr. Antti Wilhelm","male",21,0,0,"STON/O 2. 3101280",7.925,?,"S",?,?,?
3,1,"Sjoblom, Miss. Anna Sofia","female",18,0,0,"3101265",7.4958,?,"S","16",?,?
3,0,"Skoog, Master. Harald","male",4,3,2,"347088",27.9,?,"S",?,?,?
3,0,"Skoog, Master. Karl Thorsten","male",10,3,2,"347088",27.9,?,"S",?,?,?
3,0,"Skoog, Miss. Mabel","female",9,3,2,"347088",27.9,?,"S",?,?,?
3,0,"Skoog, Miss. Margit Elizabeth","female",2,3,2,"347088",27.9,?,"S",?,?,?
3,0,"Skoog, Mr. Wilhelm","male",40,1,4,"347088",27.9,?,"S",?,?,?
3,0,"Skoog, Mrs. William (Anna Bernhardina Karlsson)","female",45,1,4,"347088",27.9,?,"S",?,?,?
3,0,"Slabenoff, Mr. Petco","male",?,0,0,"349214",7.8958,?,"S",?,?,?
3,0,"Slocovski, Mr. Selman Francis","male",?,0,0,"SOTON/OQ 392086",8.05,?,"S",?,?,?
3,0,"Smiljanic, Mr. Mile","male",?,0,0,"315037",8.6625,?,"S",?,?,?
3,0,"Smith, Mr. Thomas","male",?,0,0,"384461",7.75,?,"Q",?,?,?
3,1,"Smyth, Miss. Julia","female",?,0,0,"335432",7.7333,?,"Q","13",?,?
3,0,"Soholt, Mr. Peter Andreas Lauritz Andersen","male",19,0,0,"348124",7.65,"F G73","S",?,?,?
3,0,"Somerton, Mr. Francis William","male",30,0,0,"A.5. 18509",8.05,?,"S",?,?,?
3,0,"Spector, Mr. Woolf","male",?,0,0,"A.5. 3236",8.05,?,"S",?,?,?
3,0,"Spinner, Mr. Henry John","male",32,0,0,"STON/OQ. 369943",8.05,?,"S",?,?,?
3,0,"Staneff, Mr. Ivan","male",?,0,0,"349208",7.8958,?,"S",?,?,?
3,0,"Stankovic, Mr. Ivan","male",33,0,0,"349239",8.6625,?,"C",?,?,?
3,1,"Stanley, Miss. Amy Zillah Elsie","female",23,0,0,"CA. 2314",7.55,?,"S","C",?,?
3,0,"Stanley, Mr. Edward Roland","male",21,0,0,"A/4 45380",8.05,?,"S",?,?,?
3,0,"Storey, Mr. Thomas","male",60.5,0,0,"3701",?,?,"S",?,261,?
3,0,"Stoytcheff, Mr. Ilia","male",19,0,0,"349205",7.8958,?,"S",?,?,?
3,0,"Strandberg, Miss. Ida Sofia","female",22,0,0,"7553",9.8375,?,"S",?,?,?
3,1,"Stranden, Mr. Juho","male",31,0,0,"STON/O 2. 3101288",7.925,?,"S","9",?,?
3,0,"Strilic, Mr. Ivan","male",27,0,0,"315083",8.6625,?,"S",?,?,?
3,0,"Strom, Miss. Telma Matilda","female",2,0,1,"347054",10.4625,"G6","S",?,?,?
3,0,"Strom, Mrs. Wilhelm (Elna Matilda Persson)","female",29,1,1,"347054",10.4625,"G6","S",?,?,?
3,1,"Sunderland, Mr. Victor Francis","male",16,0,0,"SOTON/OQ 392089",8.05,?,"S","B",?,?
3,1,"Sundman, Mr. Johan Julian","male",44,0,0,"STON/O 2. 3101269",7.925,?,"S","15",?,?
3,0,"Sutehall, Mr. Henry Jr","male",25,0,0,"SOTON/OQ 392076",7.05,?,"S",?,?,?
3,0,"Svensson, Mr. Johan","male",74,0,0,"347060",7.775,?,"S",?,?,?
3,1,"Svensson, Mr. Johan Cervin","male",14,0,0,"7538",9.225,?,"S","13",?,?
3,0,"Svensson, Mr. Olof","male",24,0,0,"350035",7.7958,?,"S",?,?,?
3,1,"Tenglin, Mr. Gunnar Isidor","male",25,0,0,"350033",7.7958,?,"S","13 15",?,?
3,0,"Theobald, Mr. Thomas Leonard","male",34,0,0,"363294",8.05,?,"S",?,176,?
3,1,"Thomas, Master. Assad Alexander","male",0.4167,0,1,"2625",8.5167,?,"C","16",?,?
3,0,"Thomas, Mr. Charles P","male",?,1,0,"2621",6.4375,?,"C",?,?,?
3,0,"Thomas, Mr. John","male",?,0,0,"2681",6.4375,?,"C",?,?,?
3,0,"Thomas, Mr. Tannous","male",?,0,0,"2684",7.225,?,"C",?,?,?
3,1,"Thomas, Mrs. Alexander (Thamine 'Thelma')","female",16,1,1,"2625",8.5167,?,"C","14",?,?
3,0,"Thomson, Mr. Alexander Morrison","male",?,0,0,"32302",8.05,?,"S",?,?,?
3,0,"Thorneycroft, Mr. Percival","male",?,1,0,"376564",16.1,?,"S",?,?,?
3,1,"Thorneycroft, Mrs. Percival (Florence Kate White)","female",?,1,0,"376564",16.1,?,"S","10",?,?
3,0,"Tikkanen, Mr. Juho","male",32,0,0,"STON/O 2. 3101293",7.925,?,"S",?,?,?
3,0,"Tobin, Mr. Roger","male",?,0,0,"383121",7.75,"F38","Q",?,?,?
3,0,"Todoroff, Mr. Lalio","male",?,0,0,"349216",7.8958,?,"S",?,?,?
3,0,"Tomlin, Mr. Ernest Portage","male",30.5,0,0,"364499",8.05,?,"S",?,50,?
3,0,"Torber, Mr. Ernst William","male",44,0,0,"364511",8.05,?,"S",?,?,?
3,0,"Torfa, Mr. Assad","male",?,0,0,"2673",7.2292,?,"C",?,?,?
3,1,"Tornquist, Mr. William Henry","male",25,0,0,"LINE",0,?,"S","15",?,?
3,0,"Toufik, Mr. Nakli","male",?,0,0,"2641",7.2292,?,"C",?,?,?
3,1,"Touma, Master. Georges Youssef","male",7,1,1,"2650",15.2458,?,"C","C",?,?
3,1,"Touma, Miss. Maria Youssef","female",9,1,1,"2650",15.2458,?,"C","C",?,?
3,1,"Touma, Mrs. Darwis (Hanne Youssef Razi)","female",29,0,2,"2650",15.2458,?,"C","C",?,?
3,0,"Turcin, Mr. Stjepan","male",36,0,0,"349247",7.8958,?,"S",?,?,?
3,1,"Turja, Miss. Anna Sofia","female",18,0,0,"4138",9.8417,?,"S","15",?,?
3,1,"Turkula, Mrs. (Hedwig)","female",63,0,0,"4134",9.5875,?,"S","15",?,?
3,0,"van Billiard, Master. James William","male",?,1,1,"A/5. 851",14.5,?,"S",?,?,?
3,0,"van Billiard, Master. Walter John","male",11.5,1,1,"A/5. 851",14.5,?,"S",?,1,?
3,0,"van Billiard, Mr. Austin Blyler","male",40.5,0,2,"A/5. 851",14.5,?,"S",?,255,?
3,0,"Van Impe, Miss. Catharina","female",10,0,2,"345773",24.15,?,"S",?,?,?
3,0,"Van Impe, Mr. Jean Baptiste","male",36,1,1,"345773",24.15,?,"S",?,?,?
3,0,"Van Impe, Mrs. Jean Baptiste (Rosalie Paula Govaert)","female",30,1,1,"345773",24.15,?,"S",?,?,?
3,0,"van Melkebeke, Mr. Philemon","male",?,0,0,"345777",9.5,?,"S",?,?,?
3,0,"Vande Velde, Mr. Johannes Joseph","male",33,0,0,"345780",9.5,?,"S",?,?,?
3,0,"Vande Walle, Mr. Nestor Cyriel","male",28,0,0,"345770",9.5,?,"S",?,?,?
3,0,"Vanden Steen, Mr. Leo Peter","male",28,0,0,"345783",9.5,?,"S",?,?,?
3,0,"Vander Cruyssen, Mr. Victor","male",47,0,0,"345765",9,?,"S",?,?,?
3,0,"Vander Planke, Miss. Augusta Maria","female",18,2,0,"345764",18,?,"S",?,?,?
3,0,"Vander Planke, Mr. Julius","male",31,3,0,"345763",18,?,"S",?,?,?
3,0,"Vander Planke, Mr. Leo Edmondus","male",16,2,0,"345764",18,?,"S",?,?,?
3,0,"Vander Planke, Mrs. Julius (Emelia Maria Vandemoortele)","female",31,1,0,"345763",18,?,"S",?,?,?
3,1,"Vartanian, Mr. David","male",22,0,0,"2658",7.225,?,"C","13 15",?,?
3,0,"Vendel, Mr. Olof Edvin","male",20,0,0,"350416",7.8542,?,"S",?,?,?
3,0,"Vestrom, Miss. Hulda Amanda Adolfina","female",14,0,0,"350406",7.8542,?,"S",?,?,?
3,0,"Vovk, Mr. Janko","male",22,0,0,"349252",7.8958,?,"S",?,?,?
3,0,"Waelens, Mr. Achille","male",22,0,0,"345767",9,?,"S",?,?,"Antwerp, Belgium / Stanton, OH"
3,0,"Ware, Mr. Frederick","male",?,0,0,"359309",8.05,?,"S",?,?,?
3,0,"Warren, Mr. Charles William","male",?,0,0,"C.A. 49867",7.55,?,"S",?,?,?
3,0,"Webber, Mr. James","male",?,0,0,"SOTON/OQ 3101316",8.05,?,"S",?,?,?
3,0,"Wenzel, Mr. Linhart","male",32.5,0,0,"345775",9.5,?,"S",?,298,?
3,1,"Whabee, Mrs. George Joseph (Shawneene Abi-Saab)","female",38,0,0,"2688",7.2292,?,"C","C",?,?
3,0,"Widegren, Mr. Carl/Charles Peter","male",51,0,0,"347064",7.75,?,"S",?,?,?
3,0,"Wiklund, Mr. Jakob Alfred","male",18,1,0,"3101267",6.4958,?,"S",?,314,?
3,0,"Wiklund, Mr. Karl Johan","male",21,1,0,"3101266",6.4958,?,"S",?,?,?
3,1,"Wilkes, Mrs. James (Ellen Needs)","female",47,1,0,"363272",7,?,"S",?,?,?
3,0,"Willer, Mr. Aaron ('Abi Weller')","male",?,0,0,"3410",8.7125,?,"S",?,?,?
3,0,"Willey, Mr. Edward","male",?,0,0,"S.O./P.P. 751",7.55,?,"S",?,?,?
3,0,"Williams, Mr. Howard Hugh 'Harry'","male",?,0,0,"A/5 2466",8.05,?,"S",?,?,?
3,0,"Williams, Mr. Leslie","male",28.5,0,0,"54636",16.1,?,"S",?,14,?
3,0,"Windelov, Mr. Einar","male",21,0,0,"SOTON/OQ 3101317",7.25,?,"S",?,?,?
3,0,"Wirz, Mr. Albert","male",27,0,0,"315154",8.6625,?,"S",?,131,?
3,0,"Wiseman, Mr. Phillippe","male",?,0,0,"A/4. 34244",7.25,?,"S",?,?,?
3,0,"Wittevrongel, Mr. Camille","male",36,0,0,"345771",9.5,?,"S",?,?,?
3,0,"Yasbeck, Mr. Antoni","male",27,1,0,"2659",14.4542,?,"C","C",?,?
3,1,"Yasbeck, Mrs. Antoni (Selini Alexander)","female",15,1,0,"2659",14.4542,?,"C",?,?,?
3,0,"Youseff, Mr. Gerious","male",45.5,0,0,"2628",7.225,?,"C",?,312,?
3,0,"Yousif, Mr. Wazli","male",?,0,0,"2647",7.225,?,"C",?,?,?
3,0,"Yousseff, Mr. Gerious","male",?,0,0,"2627",14.4583,?,"C",?,?,?
3,0,"Zabour, Miss. Hileni","female",14.5,1,0,"2665",14.4542,?,"C",?,328,?
3,0,"Zabour, Miss. Thamine","female",?,1,0,"2665",14.4542,?,"C",?,?,?
3,0,"Zakarian, Mr. Mapriededer","male",26.5,0,0,"2656",7.225,?,"C",?,304,?
3,0,"Zakarian, Mr. Ortin","male",27,0,0,"2670",7.225,?,"C",?,?,?
3,0,"Zimmerman, Mr. Leo","male",29,0,0,"315082",7.875,?,"S",?,?,?


================================================
FILE: examples/lesson09/fig09_01-02/Account.h
================================================
// Fig. 9.2: Account.h
// Account class with a data member and
// member functions to set and get its value.
#include <string> 
#include <string_view> 

class Account {
public:
   // member function that sets m_name in the object
   void setName(std::string_view name) {
      m_name = name; // replace m_name's value with name
   }

   // member function that retrieves the account name from the object
   const std::string& getName() const {
      return m_name; // return m_name's value to this function's caller 
   }
private:
   std::string m_name; // data member containing account holder's name
}; // end class Account





/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_01-02/AccountTest.cpp
================================================
// Fig. 9.1: AccountTest.cpp
// Creating and manipulating an Account object.
#include <format>
#include <iostream>
#include <string>
#include "Account.h"

int main() {
   Account myAccount{}; // create Account object myAccount

   // show that the initial value of myAccount's name is the empty string
   std::cout << std::format("Initial account name: {}\n",
      myAccount.getName());

   // prompt for and read the name
   std::cout << "Enter the account name: ";
   std::string name{};
   std::getline(std::cin, name); // read a line of text       
   myAccount.setName(name); // put name in the myAccount object

   // display the name stored in object myAccount
   std::cout << std::format("Updated account name: {}\n",
      myAccount.getName());
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_03-04/Account.h
================================================
// Fig. 9.3: Account.h
// Account class with a constructor that initializes the account name.
#include <string>
#include <string_view>

class Account {
public:
   // constructor initializes data member m_name with the parameter name
   explicit Account(std::string_view name)
      : m_name{name} { // member initializer  
     // empty body                                 
   }

   // function to set the account name
   void setName(std::string_view name) {
      m_name = name;
   }

   // function to retrieve the account name
   const std::string& getName() const {
      return m_name;
   }
private:
   std::string m_name; // account name 
}; // end class Account



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_03-04/AccountTest.cpp
================================================
// Fig. 9.4: AccountTest.cpp
// Using the Account constructor to initialize the m_name 
// data member when each Account object is created.
#include <format>
#include <iostream>
#include "Account.h"

int main() {
   // create two Account objects
   Account account1{"Mia Gonzalez"};
   Account account2{"Asahi Susuki"};

   // display each Account's corresponding name
   std::cout << std::format(
      "account1 name is: {}\naccount2 name is: {}\n",
      account1.getName(), account2.getName());
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_05-06/Account.h
================================================
// Fig. 9.5: Account.h
// Account class with m_name and m_balance data members, and a 
// constructor and deposit function that each perform validation.
#include <algorithm>
#include <string>
#include <string_view>

class Account {
public:
   // Account constructor with two parameters  
   Account(std::string_view name, double balance)
      : m_name{name}, m_balance{std::max(0.0, balance)} { // member init
      // empty body
   }

   // function that deposits (adds) only a valid amount to the balance
   void deposit(double amount) {
      if (amount > 0.0) { // if the amount is valid
         m_balance += amount; // add it to m_balance      
      }
   }

   // function that returns the account balance
   double getBalance() const {
      return m_balance;
   }

   // function that sets the account name
   void setName(std::string_view name) {
      m_name = name; // replace m_name's value with name
   }

   // function that returns the account name
   const std::string& getName() const {
      return m_name;
   }
private:
   std::string m_name; 
   double m_balance; 
}; // end class Account




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_05-06/AccountTest.cpp
================================================
// Fig. 9.6: AccountTest.cpp
// Displaying and updating Account balances.
#include <format>
#include <iostream>
#include "Account.h"

int main() {
   Account account1{"Mia Gonzalez", 50.00};
   Account account2{"Asahi Susuki", -7.00};

   // display initial balance of each object
   std::cout << std::format("account1: {} balance is ${:.2f}\n",
      account1.getName(), account1.getBalance());
   std::cout << std::format("account2: {} balance is ${:.2f}\n\n",
      account2.getName(), account2.getBalance());

   std::cout << "Enter deposit amount for account1: "; // prompt
   double amount;
   std::cin >> amount; // obtain user input
   std::cout << std::format(
      "adding ${:.2f} to account1 balance\n\n", amount);
   account1.deposit(amount); // add to account1's balance

   // display balances
   std::cout << std::format("account1: {} balance is ${:.2f}\n",
      account1.getName(), account1.getBalance());
   std::cout << std::format("account2: {} balance is ${:.2f}\n\n",
      account2.getName(), account2.getBalance());

   std::cout << "Enter deposit amount for account2: "; // prompt
   std::cin >> amount; // obtain user input
   std::cout << std::format(
      "adding ${:.2f} to account2 balance\n\n", amount);
   account2.deposit(amount); // add to account2 balance

   // display balances
   std::cout << std::format("account1: {} balance is ${:.2f}\n",
      account1.getName(), account1.getBalance());
   std::cout << std::format("account2: {} balance is ${:.2f}\n",
      account2.getName(), account2.getBalance());
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_07-09/Time.cpp
================================================
// Fig. 9.8: Time.cpp
// Time class member-function definitions. 
#include <format>
#include <stdexcept> // for invalid_argument exception class     
#include <string>
#include "Time.h" // include definition of class Time from Time.h 

// set new Time value using 24-hour time
void Time::setTime(int hour, int minute, int second) {
   // validate hour, minute and second
   if ((hour < 0 || hour >= 24) || (minute < 0 || minute >= 60) ||
      (second < 0 || second >= 60)) {
      throw std::invalid_argument{
         "hour, minute or second was out of range"};
   }

   m_hour = hour;
   m_minute = minute;
   m_second = second;
}

// return Time as a string in 24-hour format (HH:MM:SS)
std::string Time::to24HourString() const {
   return std::format("{:02d}:{:02d}:{:02d}", m_hour, m_minute, m_second);
}

// return Time as string in 12-hour format (HH:MM:SS AM or PM)
std::string Time::to12HourString() const {
   return std::format("{}:{:02d}:{:02d} {}",
      ((m_hour % 12 == 0) ? 12 : m_hour % 12), m_minute, m_second,
      (m_hour < 12 ? "AM" : "PM"));
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_07-09/Time.h
================================================
// Fig. 9.7: Time.h
// Time class definition.                   
// Member functions are defined in Time.cpp 
#pragma once // prevent multiple inclusions of header
#include <string>

// Time class definition
class Time {
public:
   void setTime(int hour, int minute, int second);
   std::string to24HourString() const; // 24-hour string format
   std::string to12HourString() const; // 12-hour string format
private:
   int m_hour{0}; // 0 - 23 (24-hour clock format)
   int m_minute{0}; // 0 - 59
   int m_second{0}; // 0 - 59
};
   

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_07-09/fig09_09.cpp
================================================
// fig09_09.cpp
// Program to test class Time.                     
// NOTE: This file must be linked with Time.cpp. 
#include <format>
#include <iostream>
#include <stdexcept> // invalid_argument exception class
#include <string_view> 
#include "Time.h" // definition of class Time from Time.h 

// displays a Time in 24-hour and 12-hour formats
void displayTime(std::string_view message, const Time& time) {
   std::cout << std::format("{}\n24-hour time: {}\n12-hour time: {}\n\n",
      message, time.to24HourString(), time.to12HourString());
}

int main() {
   Time t{}; // instantiate object t of class Time

   displayTime("Initial time:", t); // display t's initial value
   t.setTime(13, 27, 6); // change time
   displayTime("After setTime:", t); // display t's new value

   // attempt to set the time with invalid values
   try {
      t.setTime(99, 99, 99); // all values out of range
   }
   catch (const std::invalid_argument& e) {
      std::cout << std::format("Exception: {}\n\n", e.what());
   }

   // display t's value after attempting to set an invalid time
   displayTime("After attempting to set an invalid time:", t);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_10-12/Time.cpp
================================================
// Fig. 9.11: Time.cpp
// Member-function definitions for class Time.
#include <format>
#include <stdexcept>
#include <string>
#include "Time.h" // include definition of class Time from Time.h

// Time constructor initializes each data member    
Time::Time(int hour, int minute, int second) {             
   setTime(hour, minute, second);
}

// set new Time value using 24-hour time
void Time::setTime(int hour, int minute, int second) {
   // validate hour, minute and second
   if (hour < 0 || hour >= 24) {
      throw std::invalid_argument{"hour was out of range"};
   } 

   if (minute < 0 || minute >= 60) { 
      throw std::invalid_argument{"minute was out of range"};
   } 

   if (second < 0 || second >= 60) {
      throw std::invalid_argument{"second was out of range"};
   } 

   m_hour = hour;
   m_minute = minute;
   m_second = second;
} 

// set hour value
void Time::setHour(int hour) {setTime(hour, m_minute, m_second);}

// set minute value
void Time::setMinute(int minute) {setTime(m_hour, minute, m_second);}

// set second value
void Time::setSecond(int second) {setTime(m_hour, m_minute, second);}

// return hour value
int Time::getHour() const {return m_hour;}

// return minute value
int Time::getMinute() const {return m_minute;}

// return second value
int Time::getSecond() const {return m_second;}

// return Time as a string in 24-hour format (HH:MM:SS)
std::string Time::to24HourString() const {
   return std::format("{:02d}:{:02d}:{:02d}", 
      getHour(), getMinute(), getSecond());
} 

// return Time as a string in 12-hour format (HH:MM:SS AM or PM)
std::string Time::to12HourString() const {
   return std::format("{}:{:02d}:{:02d} {}", 
      ((getHour() % 12 == 0) ? 12 : getHour() % 12), 
      getMinute(), getSecond(), (getHour() < 12 ? "AM" : "PM"));
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_10-12/Time.h
================================================
// Fig. 9.10: Time.h
// Time class containing a constructor with default arguments.
// Member functions defined in Time.cpp.
#pragma once // prevent multiple inclusions of header
#include <string>

// Time class definition
class Time {
public:
   // default constructor because it can be called with no arguments
   explicit Time(int hour = 0, int minute = 0, int second = 0);

   // set functions
   void setTime(int hour, int minute, int second);
   void setHour(int hour); // set hour (after validation)
   void setMinute(int minute); // set minute (after validation)
   void setSecond(int second); // set second (after validation)

   // get functions
   int getHour() const; // return hour
   int getMinute() const; // return minute
   int getSecond() const; // return second

   std::string to24HourString() const; // 24-hour time format string
   std::string to12HourString() const; // 12-hour time format string
private:
   int m_hour{0}; // 0 - 23 (24-hour clock format)
   int m_minute{0}; // 0 - 59
   int m_second{0}; // 0 - 59
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_10-12/fig09_12.cpp
================================================
// fig09_12.cpp 
// Constructor with default arguments.
#include <format>
#include <iostream>
#include <stdexcept>
#include <string>
#include "Time.h" // include definition of class Time from Time.h

// displays a Time in 24-hour and 12-hour formats
void displayTime(std::string_view message, const Time& time) {
   std::cout << std::format("{}\n24-hour time: {}\n12-hour time: {}\n\n",
      message, time.to24HourString(), time.to12HourString());
}

int main() {
   const Time t1{}; // all arguments defaulted                            
   const Time t2{2}; // hour specified; minute & second defaulted     
   const Time t3{21, 34}; // hour & minute specified; second defaulted
   const Time t4{12, 25, 42}; // hour, minute & second specified      

   std::cout << "Constructed with:\n\n";
   displayTime("t1: all arguments defaulted", t1);
   displayTime("t2: hour specified; minute and second defaulted", t2);
   displayTime("t3: hour and minute specified; second defaulted", t3);
   displayTime("t4: hour, minute and second specified", t4);

   // attempt to initialize t5 with invalid values
   try {
      const Time t5{27, 74, 99}; // all bad values specified
   }
   catch (const std::invalid_argument& e) {
      std::cerr << std::format("t5 not created: {}\n", e.what());
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_13-15/CreateAndDestroy.cpp
================================================
// Fig. 9.14: CreateAndDestroy.cpp
// CreateAndDestroy class member-function definitions.
#include <format>
#include <iostream>
#include "CreateAndDestroy.h"// include CreateAndDestroy class definition

// constructor sets object's ID number and descriptive message
CreateAndDestroy::CreateAndDestroy(int ID, std::string_view message)
   : m_ID{ID}, m_message{message} {
   std::cout << std::format("Object {}   constructor runs   {}\n",
      m_ID, m_message);
}

// destructor                                               
CreateAndDestroy::~CreateAndDestroy() {
   // output newline for certain objects; helps readability 
   std::cout << std::format("{}Object {}   destructor runs    {}\n",
      (m_ID == 1 || m_ID == 6 ? "\n" : ""), m_ID, m_message);
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_13-15/CreateAndDestroy.h
================================================
// Fig. 9.13: CreateAndDestroy.h
// CreateAndDestroy class definition.
// Member functions defined in CreateAndDestroy.cpp.
#pragma once // prevent multiple inclusions of header
#include <string>
#include <string_view>

class CreateAndDestroy {
public:
   CreateAndDestroy(int ID, std::string_view message); // constructor
   ~CreateAndDestroy(); // destructor                
private:
   int m_ID; // ID number for object
   std::string m_message; // message describing object
};




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_13-15/fig09_15.cpp
================================================
// fig09_15.cpp
// Order in which constructors and 
// destructors are called.
#include <iostream>
#include "CreateAndDestroy.h" // include CreateAndDestroy class definition

void create(); // prototype

const CreateAndDestroy first{1, "(global before main)"}; // global object 

int main() {
   std::cout << "\nMAIN FUNCTION: EXECUTION BEGINS\n";
   const CreateAndDestroy second{2, "(local in main)"};
   static const CreateAndDestroy third{3, "(local static in main)"};

   create(); // call function to create objects

   std::cout << "\nMAIN FUNCTION: EXECUTION RESUMES\n";
   const CreateAndDestroy fourth{4, "(local in main)"};
   std::cout << "\nMAIN FUNCTION: EXECUTION ENDS\n";
}

// function to create objects
void create() {
   std::cout << "\nCREATE FUNCTION: EXECUTION BEGINS\n";
   const CreateAndDestroy fifth{5, "(local in create)"};
   static const CreateAndDestroy sixth{6, "(local static in create)"};
   const CreateAndDestroy seventh{7, "(local in create)"};
   std::cout << "\nCREATE FUNCTION: EXECUTION ENDS\n";
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_16-18/Time.cpp
================================================
// Fig. 9.17: Time.cpp
// Time class member-function definitions.
#include <stdexcept>
#include "Time.h" // include definition of class Time

// set new Time value using 24-hour time
void Time::setTime(int hour, int minute, int second) {
   // validate hour, minute and second
   if (hour < 0 || hour >= 24) {
      throw std::invalid_argument{"hour was out of range"};
   }

   if (minute < 0 || minute >= 60) {
      throw std::invalid_argument{"minute was out of range"};
   }

   if (second < 0 || second >= 60) {
      throw std::invalid_argument{"second was out of range"};
   }

   m_hour = hour;
   m_minute = minute;
   m_second = second;
}

// return hour value
int Time::getHour() const {return m_hour;}

// poor practice: returning a reference to a private data member. 
int& Time::badSetHour(int hour) {
   setTime(hour, m_minute, m_second);
   return m_hour; // dangerous reference return                    
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_16-18/Time.h
================================================
// Fig. 9.16: Time.h
// Time class definition.
// Member functions defined in Time.cpp

// prevent multiple inclusions of header
#pragma once 

class Time {
public:
   void setTime(int hour, int minute, int second);
   int getHour() const;
   int& badSetHour(int hour); // dangerous reference return
private:
   int m_hour{0};
   int m_minute{0};
   int m_second{0};
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_16-18/fig09_18.cpp
================================================
// fig09_18.cpp
// public member function that
// returns a reference to private data.
#include <iostream>
#include <format>
#include "Time.h" // include definition of class Time

int main() {
   Time t{}; // create Time object

   // initialize hourRef with the reference returned by badSetHour
   int& hourRef{t.badSetHour(20)}; // 20 is a valid hour 

   std::cout << std::format(
      "Valid hour before modification: {}\n", hourRef);
   hourRef = 30; // use hourRef to set invalid value in Time object t
   std::cout << std::format(
      "Invalid hour after modification: {}\n\n", t.getHour());

   // Dangerous: Function call that returns a reference can be 
   // used as an lvalue! POOR PROGRAMMING PRACTICE!!!!!!!!
   t.badSetHour(12) = 74; // assign another invalid value to hour

   std::cout << "After using t.badSetHour(12) as an lvalue, "
      << std::format("hour is: {}\n", t.getHour());
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_19-21/Date.cpp
================================================
// Fig. 9.20: Date.cpp
// Date class member-function definitions.
#include <format>
#include <string>
#include "Date.h" // include definition of class Date from Date.h

// Date constructor (should do range checking)
Date::Date(int year, int month, int day)
   : m_year{year}, m_month{month}, m_day{day} {}

// return string representation of a Date in the format yyyy-mm-dd
std::string Date::toString() const {
   return std::format("{}-{:02d}-{:02d}", m_year, m_month, m_day);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_19-21/Date.h
================================================
// Fig. 9.19: Date.h
// Date class declaration. Member functions are defined in Date.cpp.
#pragma once // prevent multiple inclusions of header
#include <string>

// class Date definition
class Date {
public:
   Date(int year, int month, int day);
   std::string toString() const;
private:
   int m_year;
   int m_month;
   int m_day;
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_19-21/fig09_21.cpp
================================================
// fig09_21.cpp 
// Demonstrating that class objects can be assigned
// to each other using the default assignment operator.
#include <format>
#include <iostream>
#include "Date.h" // include definition of class Date from Date.h

int main() {
   const Date date1{2006, 7, 4};
   Date date2{2022, 1, 1};

   std::cout << std::format("date1: {}\ndate2: {}\n\n",
      date1.toString(), date2.toString());
   date2 = date1; // uses the default assignment operator
   std::cout << std::format("After assignment, date2: {}\n",
      date2.toString());
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_22/Time.cpp
================================================
// Fig. 9.11: Time.cpp
// Member-function definitions for class Time.
#include <format>
#include <stdexcept>
#include <string>
#include "Time.h" // include definition of class Time from Time.h

// Time constructor initializes each data member    
Time::Time(int hour, int minute, int second) {             
   setTime(hour, minute, second);
}

// set new Time value using 24-hour time
void Time::setTime(int hour, int minute, int second) {
   // validate hour, minute and second
   if (hour < 0 || hour >= 24) {
      throw std::invalid_argument{"hour was out of range"};
   } 

   if (minute < 0 || minute >= 60) { 
      throw std::invalid_argument{"minute was out of range"};
   } 

   if (second < 0 || second >= 60) {
      throw std::invalid_argument{"second was out of range"};
   } 

   m_hour = hour;
   m_minute = minute;
   m_second = second;
} 

// set hour value
void Time::setHour(int hour) {setTime(hour, m_minute, m_second);}

// set minute value
void Time::setMinute(int minute) {setTime(m_hour, minute, m_second);}

// set second value
void Time::setSecond(int second) {setTime(m_hour, m_minute, second);}

// return hour value
int Time::getHour() const {return m_hour;}

// return minute value
int Time::getMinute() const {return m_minute;}

// return second value
int Time::getSecond() const {return m_second;}

// return Time as a string in 24-hour format (HH:MM:SS)
std::string Time::to24HourString() const {
   return std::format("{:02d}:{:02d}:{:02d}", 
      getHour(), getMinute(), getSecond());
} 

// return Time as string in 12-hour format (HH:MM:SS AM or PM)
std::string Time::to12HourString() {
   return std::format("{}:{:02d}:{:02d} {}", 
      ((getHour() % 12 == 0) ? 12 : getHour() % 12), 
      getMinute(), getSecond(), (getHour() < 12 ? "AM" : "PM"));
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_22/Time.h
================================================
// Fig. 9.10: Time.h
// Time class containing a constructor with default arguments.
// Member functions defined in Time.cpp.
#pragma once // prevent multiple inclusions of header
#include <string>

// Time class definition
class Time {
public:
   // default constructor because it can be called with no arguments
   explicit Time(int hour = 0, int minute = 0, int second = 0);

   // set functions
   void setTime(int hour, int minute, int second);
   void setHour(int hour); // set hour (after validation)
   void setMinute(int minute); // set minute (after validation)
   void setSecond(int second); // set second (after validation)

   // get functions
   int getHour() const; // return hour
   int getMinute() const; // return minute
   int getSecond() const; // return second

   std::string to24HourString() const; // 24-hour time format string
   std::string to12HourString(); // 12-hour time format string
private:
   int m_hour{0}; // 0 - 23 (24-hour clock format)
   int m_minute{0}; // 0 - 59
   int m_second{0}; // 0 - 59
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_22/fig09_22.cpp
================================================
// fig09_22.cpp
// const objects and const member functions.
#include "Time.h" // include Time class definition

int main() {
   Time wakeUp{6, 45, 0}; // non-constant object
   const Time noon{12, 0, 0}; // constant object

                             // OBJECT      MEMBER FUNCTION
   wakeUp.setHour(18);       // non-const   non-const
   noon.setHour(12);         // const       non-const
   wakeUp.getHour();         // non-const   const
   noon.getMinute();         // const       const
   noon.to24HourString();    // const       const
   noon.to12HourString();    // const       non-const
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_23-27/Date.cpp
================================================
// Fig. 9.24: Date.cpp
// Date class member-function definitions.
#include <array>
#include <format>
#include <iostream>
#include <stdexcept>
#include "Date.h" // include Date class definition

// constructor confirms proper value for month; calls
// utility function checkDay to confirm proper value for day
Date::Date(int year, int month, int day)
   : m_year{year}, m_month{month}, m_day{day} {
   if (m_month < 1 || m_month > monthsPerYear) { // validate the month
      throw std::invalid_argument{"month must be 1-12"};
   }

   if (!checkDay(day)) { // validate the day
      throw std::invalid_argument{
         "Invalid day for current month and year"};
   }

   // output Date object to show when its constructor is called
   std::cout << std::format("Date object constructor: {}\n", toString());
}

// gets string representation of a Date in the form yyyy-mm-dd
std::string Date::toString() const {
   return std::format("{}-{:02d}-{:02d}", m_year, m_month, m_day);
}

// output Date object to show when its destructor is called
Date::~Date() {
   std::cout << std::format("Date object destructor: {}\n", toString());
}

// utility function to confirm proper day value based on 
// month and year; handles leap years, too
bool Date::checkDay(int day) const {
   // we ignore element 0
   static const std::array daysPerMonth{
      0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

   // determine whether testDay is valid for specified month
   if (1 <= day && day <= daysPerMonth.at(m_month)) {
      return true;
   }

   // February 29 check for leap year 
   if (m_month == 2 && day == 29 && (m_year % 400 == 0 ||
      (m_year % 4 == 0 && m_year % 100 != 0))) {
      return true;
   }

   return false; // invalid day, based on current m_month and m_year
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_23-27/Date.h
================================================
// Fig. 9.23: Date.h 
// Date class definition; member functions defined in Date.cpp
#pragma once // prevent multiple inclusions of header
#include <string>

class Date {
public:
   static const int monthsPerYear{12}; // months in a year
   Date(int year, int month, int day);
   std::string toString() const; // date string in yyyy-mm-dd format
   ~Date(); // implementation displays when destruction occurs
private:
   int m_year; // any year
   int m_month; // 1-12 (January-December)
   int m_day; // 1-31 based on month

   // utility function to check if day is proper for month and year
   bool checkDay(int day) const;
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_23-27/Employee.cpp
================================================
// Fig. 9.26: Employee.cpp
// Employee class member-function definitions.
#include <format>
#include <iostream>
#include "Employee.h" // Employee class definition
using namespace std;

// constructor uses member initializer list to pass initializer 
// values to constructors of member objects 
Employee::Employee(std::string_view firstName, std::string_view lastName,
   const Date& birthDate, const Date& hireDate)
   : m_firstName{firstName}, m_lastName{lastName},
   m_birthDate{birthDate}, m_hireDate{hireDate} {
   // output Employee object to show when constructor is called
   std::cout << std::format("Employee object constructor: {} {}\n",
      m_firstName, m_lastName);
}

// gets string representation of an Employee object
std::string Employee::toString() const {
   return std::format("{}, {}  Hired: {}  Birthday: {}", m_lastName,
      m_firstName, m_hireDate.toString(), m_birthDate.toString());
}

// output Employee object to show when its destructor is called
Employee::~Employee() {
   cout << std::format("Employee object destructor: {}, {}\n",
      m_lastName, m_firstName);
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_23-27/Employee.h
================================================
// Fig. 9.25: Employee.h
// Employee class definition showing composition.
// Member functions defined in Employee.cpp.
#pragma once // prevent multiple inclusions of header
#include <string>
#include <string_view>
#include "Date.h" // include Date class definition

class Employee {
public:
   Employee(std::string_view firstName, std::string_view lastName,
      const Date& birthDate, const Date& hireDate);
   std::string toString() const;
   ~Employee(); // provided to confirm destruction order
private:
   std::string m_firstName; // composition: member object
   std::string m_lastName; // composition: member object
   Date m_birthDate; // composition: member object
   Date m_hireDate; // composition: member object
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_23-27/fig09_27.cpp
================================================
// fig09_27.cpp
// Demonstrating composition--an object with member objects.
#include <format>
#include <iostream>
#include "Date.h" // Date class definition
#include "Employee.h" // Employee class definition

int main() {
   const Date birth{1987 ,7, 24};
   const Date hire{2018, 3, 12};
   const Employee manager{"Aisha", "Khan", birth, hire};

   std::cout << std::format("\n{}\n\n", manager.toString());
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_28/fig09_28.cpp
================================================
// fig09_28.cpp  
// Friends can access private members of a class.
#include <format>
#include <iostream>

// Count class definition 
class Count {
   friend void modifyX(Count& c, int value); // friend declaration
public:
   int getX() const { return m_x; }
private:
   int m_x{0};
};

// function modifyX can modify private data of Count         
// because modifyX is declared as a friend of Count (line 8)
void modifyX(Count& c, int value) {
   c.m_x = value; // allowed because modifyX is a friend of Count 
}

int main() {
   Count counter{}; // create Count object

   std::cout << std::format("Initial counter.m_x: {}\n", counter.getX());
   modifyX(counter, 8); // change x's value using a friend function
   std::cout << std::format("counter.m_x after modifyX: {}\n",
      counter.getX());
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/

================================================
FILE: examples/lesson09/fig09_29/fig09_29.cpp
================================================
// fig09_29.cpp  
// Using the this pointer to refer to object members.
#include <format>
#include <iostream>

class Test {
public:
   explicit Test(int value);
   void print() const;
private:
   int m_x{0};
};

// constructor
Test::Test(int value) : m_x{value} {} // initialize x to value

// print x using implicit then explicit this pointers;
// the parentheses around *this are required due to precedence
void Test::print() const {
   // implicitly use the this pointer to access the member x
   std::cout << std::format("        m_x = {}\n", m_x);

   // explicitly use the this pointer and the arrow operator
   // to access the member x                                
   std::cout << std::format("  this->m_x = {}\n", this->m_x);

   // explicitly use the dereferenced this pointer and
   // the dot operator to access the member x         
   std::cout << std::format("(*this).m_x = {}\n", (*this).m_x);
}

int main() {
   const Test testObject{12}; // instantiate and initialize testObject
   testObject.print();
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_30-32/Time.cpp
================================================
// Fig. 9.31: Time.cpp 
// Time class member-function definitions.
#include <format>
#include <stdexcept>
#include "Time.h" // Time class definition

// Time constructor initializes each data member    
Time::Time(int hour, int minute, int second) {             
   setTime(hour, minute, second);
}

// set new Time value using 24-hour time
Time& Time::setTime(int hour, int minute, int second) {
   // validate hour, minute and second
   if (hour < 0 || hour >= 24) {
      throw std::invalid_argument{"hour was out of range"};
   } 

   if (minute < 0 || minute >= 60) { 
      throw std::invalid_argument{"minute was out of range"};
   } 

   if (second < 0 || second >= 60) {
      throw std::invalid_argument{"second was out of range"};
   } 

   m_hour = hour;
   m_minute = minute;
   m_second = second;
   return *this; // enables cascading
} 

// set hour value
Time& Time::setHour(int hour) {
   return setTime(hour, m_minute, m_second);
}

// set minute value
Time&  Time::setMinute(int minute) {
   return setTime(m_hour, minute, m_second);
}

// set second value
Time&  Time::setSecond(int second) {
   return setTime(m_hour, m_minute, second);
}

// get hour value
int Time::getHour() const {return m_hour;}

// get minute value
int Time::getMinute() const {return m_minute;}

// get second value
int Time::getSecond() const {return m_second;}

// return Time as a string in 24-hour format (HH:MM:SS)
std::string Time::to24HourString() const {
   return std::format("{:02d}:{:02d}:{:02d}", 
      getHour(), getMinute(), getSecond());
} 

// return Time as string in 12-hour format (HH:MM:SS AM or PM)
std::string Time::to12HourString() const {
   return std::format("{}:{:02d}:{:02d} {}", 
      ((getHour() % 12 == 0) ? 12 : getHour() % 12), 
      getMinute(), getSecond(), (getHour() < 12 ? "AM" : "PM"));
} 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_30-32/Time.h
================================================
// Fig. 9.30: Time.h
// Time class modified to enable cascaded member-function calls.
#pragma once // prevent multiple inclusions of header
#include <string>

class Time {
public:
   // default constructor because it can be called with no arguments
   explicit Time(int hour = 0, int minute = 0, int second = 0);

   // set functions
   Time& setTime(int hour, int minute, int second);
   Time& setHour(int hour); // set hour (after validation)
   Time& setMinute(int minute); // set minute (after validation)
   Time& setSecond(int second); // set second (after validation)

   int getHour() const; // return hour
   int getMinute() const; // return minute
   int getSecond() const; // return second
   std::string to24HourString() const; // 24-hour time format string
   std::string to12HourString() const; // 12-hour time format string
private:
   int m_hour{0}; // 0 - 23 (24-hour clock format)
   int m_minute{0}; // 0 - 59
   int m_second{0}; // 0 - 59
};




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_30-32/fig09_32.cpp
================================================
// fig09_32.cpp
// Cascading member-function calls with the this pointer.
#include <format>
#include <iostream>
#include "Time.h" // Time class definition
using namespace std;

int main() {
   Time t{}; // create Time object

   t.setHour(18).setMinute(30).setSecond(22); // cascaded function calls

   // output time in 24-hour and 12-hour formats
   std::cout << std::format("24-hour time: {}\n12-hour time: {}\n\n",
      t.to24HourString(), t.to12HourString());

   // cascaded function calls        
   std::cout << std::format("New 12-hour time: {}\n",
      t.setTime(20, 20, 20).to12HourString());
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_33-35/Employee.cpp
================================================
// Fig. 9.34: Employee.cpp
// Employee class member-function definitions.
#include <format>
#include <iostream>
#include "Employee.h" // Employee class definition 
using namespace std;

// define static member function that returns number of         
// Employee objects instantiated (declared static in Employee.h)
int Employee::getCount() {return m_count;} 

// constructor initializes non-static data members and 
// increments static data member count
Employee::Employee(string_view firstName, string_view lastName)
   : m_firstName(firstName), m_lastName(lastName) {
   ++m_count; // increment static count of employees
   std::cout << std::format("Employee constructor called for {} {}\n", 
      m_firstName, m_lastName);
} 

// destructor decrements the count
Employee::~Employee() {
   std::cout << std::format("~Employee() called for {} {}\n", 
      m_firstName, m_lastName);
   --m_count; // decrement static count of employees
}

// return first name of employee
const string& Employee::getFirstName() const {return m_firstName;}

// return last name of employee
const string& Employee::getLastName() const {return m_lastName;}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_33-35/Employee.h
================================================
// Fig. 9.33: Employee.h
// Employee class definition with a static data member to 
// track the number of Employee objects in memory
#pragma once
#include <string>
#include <string_view>

class Employee {
public:
   Employee(std::string_view firstName, std::string_view lastName);
   ~Employee(); // destructor
   const std::string& getFirstName() const; // return first name
   const std::string& getLastName() const; // return last name

   // static member function                                          
   static int getCount(); // return # of objects instantiated
private:
   std::string m_firstName;
   std::string m_lastName;

   // static data
   inline static int m_count{0}; // number of objects instantiated
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_33-35/fig09_35.cpp
================================================
// fig09_35.cpp
// static data member tracking the number of objects of a class.
#include <format>
#include <iostream>
#include "Employee.h" // Employee class definition

int main() {
   // no objects exist; use class name and scope resolution 
   // operator to access static member function getCount
   std::cout << std::format("Initial employee count: {}\n",
      Employee::getCount()); // use class name

   // the following scope creates and destroys 
   // Employee objects before main terminates
   {
      const Employee e1{"Susan", "Baker"};
      const Employee e2{"Robert", "Jones"};

      // two objects exist; call static member function getCount again 
      // using the class name and the scope resolution operator
      std::cout << std::format(
         "Employee count after creating objects: {}\n\n",
         Employee::getCount());

      std::cout << std::format("Employee 1: {} {}\nEmployee 2: {} {}\n\n",
         e1.getFirstName(), e1.getLastName(),
         e2.getFirstName(), e2.getLastName());
   }

   // no objects exist, so call static member function getCount again 
   // using the class name and the scope resolution operator
   std::cout << std::format(
      "Employee count after objects are destroyed: {}\n",
      Employee::getCount());
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_36-37/cipher.h
================================================
// Fig. 9.37: cipher.h
// Vigenre cipher implementation. 
#pragma once
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <string_view>
#include <cctype>
#include <stdexcept>
#include <gsl/gsl>

class Cipher {
public:
   // constructor to initialize the Vigenre square 
   Cipher() {
      // array to store the 26 characters A-Z that will be 
      // used to initialize each row of the Vigenre square
      std::array<char, m_size> alphabet{};

      // fill alphabet with A-Z
      for (size_t i{0}; i < m_size; ++i) {
         // convert 'A' + i to a char and place in alphabet
         alphabet.at(i) = gsl::narrow_cast<char>('A' + i);
      }

      // copy alphabet into row 0 of the Vigenre square
      m_square.at(0) = alphabet;

      // for each remaining row of the Vigenre square, move alphabet's
      // first letter to the end then copy alphabet into the row
      for (int row{1}; row < m_size; ++row) {
         // rotate alphabet, moving its first letter to the end
         std::ranges::rotate(alphabet, std::begin(alphabet) + 1);

         // copy alphabet into current row of the Vigenre square
         m_square.at(row) = alphabet;
      }
   }

   // encrypt receives the plaintext and secret key, applies 
   // the Vigenre cipher returns the encrypted ciphertext
   std::string encrypt(
      std::string_view plaintext, std::string_view secret) {

      checkKey(secret); // ensure secret key contains only letters

      std::string ciphertext{}; // stores encrypted text
      size_t keyIndex{0}; // current letter index in secret key

      // iterate through each character in plaintext
      for (size_t i{0}; i < plaintext.size(); ++i) {
         // determine whether character at i is lowercase so we can 
         // place a corresponding lowercase letter in the ciphertext
         const bool lower{std::islower(plaintext.at(i)) ? true : false};

         // convert currentChar to uppercase; for uppercase 
         // letters and non-letters the character remains the same
         const char currentChar{gsl::narrow_cast<const char>(
            std::toupper(plaintext.at(i)))};

         // if the current character is a letter, encrypt it  
         // and add it to cipherText in its original case
         if ('A' <= currentChar && currentChar <= 'Z') {
            // to get the row index in the Vigenre square, select the 
            // character at keyIndex in the secret key, convert it to 
            // uppercase and subtract 'A' from it
            const int row{std::toupper(secret.at(keyIndex)) - 'A'};

            // increment the keyIndex, ensuring that it is  
            // reset to 0 if keyIndex reaches secret.size()
            keyIndex = (keyIndex + 1) % secret.size();

            // to get the column index in the Vigenre square,  
            // subtract 'A' from the currentChar
            const int column{currentChar - 'A'};

            // select the substitute character from the Vigenre square
            const char substituteChar{m_square.at(row).at(column)};

            // add substituteChar to the ciphertext, ensuring that
            // it's lowercase if the plaintext character was lowerase
            ciphertext +=
               (lower ? std::tolower(substituteChar) : substituteChar);
         }
         else {
            ciphertext += currentChar; // add non-letter to ciphertext
         }
      }

      return ciphertext; // return the encrypted text
   }

   // decrypt receives the ciphertext and secret key, reverses
   // Vigenre cipher process and returns the unencrypted plaintext
   std::string decrypt(
      std::string_view ciphertext, std::string_view secret) {

      checkKey(secret); // ensure secret key contains only letters

      std::string plaintext{}; // stores unencrypted text
      size_t keyIndex{0}; // current letter index in secret key

      for (size_t i{0}; i < ciphertext.size(); ++i) {
         // determine whether character at i is lowercase so we can 
         // place a corresponding lowercase letter in plainText
         const bool lower{std::islower(ciphertext.at(i)) ? true : false};

         // convert currentChar to uppercase; for uppercase 
         // letters and non-letters the character remains the same
         const char currentChar{gsl::narrow_cast<const char>(
            std::toupper(ciphertext.at(i)))};

         // if current is a letter decrypt it
         if ('A' <= currentChar && currentChar <= 'Z') {
            // to get the row index in the Vigenre square, select the 
            // character at keyIndex in the secret key, convert it to 
            // uppercase and subtract 'A' from it
            const int row{std::toupper(secret.at(keyIndex)) - 'A'};

            // increment the keyIndex, ensuring that it is  
            // reset to 0 if keyIndex reaches secret.size()
            keyIndex = (keyIndex + 1) % secret.size();

            // column in the Vigenre square
            int column{-1};

            // find currentChar's column in Vigenre square's current row
            for (int i{0}; i < m_square.at(row).size(); ++i) {
               if (m_square.at(row).at(i) == currentChar) {
                  column = i;
                  break;
               }
            }

            // determine original character  
            const char originalChar{
               gsl::narrow_cast<const char>('A' + column)};

            // add originalChar to plaintext in the correct case
            plaintext +=
               (lower ? std::tolower(originalChar) : originalChar);
         }
         else {
            plaintext += currentChar; // add non-letter to plaintext
         }
      }

      return plaintext; // return the unencrypted text
   }
private:
   // number of rows and columns in the Vigenre square
   static constexpr size_t m_size{26};

   // 26-by-26 array of characters to store the Vigenre square
   std::array<std::array<char, m_size>, m_size> m_square;

   // utility function checks that secret key contains only letters; 
   // throws an invalid_argument exception if key contains non-letters
   static void checkKey(std::string_view secret) {
      for (size_t i{0}; i < secret.size(); ++i) {
         // if the uppercase version of the character at index i 
         // is not a letter throw an invalid_argument exception
         if (std::toupper(secret.at(i)) < 'A' ||
            std::toupper(secret.at(i)) > 'Z') {
            throw std::invalid_argument(
               "key must contain only letters A-Z or a-z");
         }
      }
   }
};

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_36-37/fig09_36.cpp
================================================
// fig09_36.cpp
// Encrypting and decrypting text with a Vigenre cipher. 
#include "cipher.h"
#include <iostream>
#include <string>

int main() {
   std::string plainText;
   std::cout << "Enter the text to encrypt:\n";
   std::getline(std::cin, plainText);

   std::string secretKey;
   std::cout << "\nEnter the secret key:\n";
   std::getline(std::cin, secretKey);

   Cipher cipher;

   // encrypt plainText using secretKey
   std::string cipherText{cipher.encrypt(plainText, secretKey)};
   std::cout << "\nEncrypted:\n   " << cipherText << '\n';

   // decrypt cipherText
   std::cout << "\nDecrypted:\n   " 
      << cipher.decrypt(cipherText, secretKey) << '\n';
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson09/fig09_38/fig09_38.cpp
================================================
// fig09_38.cpp
// Serializing and deserializing objects with the cereal library.
#include <cereal/archives/json.hpp> 
#include <cereal/types/vector.hpp>  
#include <format>
#include <fstream>
#include <iostream>
#include <vector>

struct Record {
   int account{};
   std::string first{};
   std::string last{};
   double balance{};
};

// function template serialize is responsible for serializing and 
// deserializing Record objects to/from the specified Archive
template <typename Archive>
void serialize(Archive& archive, Record& record) {
   archive(cereal::make_nvp("account", record.account),
      cereal::make_nvp("first", record.first),
      cereal::make_nvp("last", record.last),
      cereal::make_nvp("balance", record.balance));
}

// display record at command line
void displayRecords(const std::vector<Record>& records) {
   for (const auto& r : records) {
      std::cout << std::format("{} {} {} {:.2f}\n",
         r.account, r.first, r.last, r.balance);
   }
}

int main() {
   std::vector records{
      Record{100, "Bakary", "Zongo", 123.45},
      Record{200, "Sofia", "Smirnova", 987.65}
   };

   std::cout << "Records to serialize:\n";
   displayRecords(records);

   // serialize vector of Records to JSON and store in text file
   if (std::ofstream output{"records.json"}) {
      cereal::JSONOutputArchive archive{output};
      archive(cereal::make_nvp("records", records)); // serialize records
   }

   // deserialize JSON from text file into vector of Records
   if (std::ifstream input{"records.json"}) {
      cereal::JSONInputArchive archive{input};
      std::vector<Record> deserializedRecords{};
      archive(deserializedRecords); // deserialize records
      std::cout << "\nDeserialized records:\n";
      displayRecords(deserializedRecords);
   }
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 *************************************************************************/


================================================
FILE: examples/lesson09/fig09_38/records.json
================================================
{
    "records": [
        {
            "account": 100,
            "first": "Brian",
            "last": "Blue",
            "balance": 123.45
        },
        {
            "account": 200,
            "first": "Sue",
            "last": "Green",
            "balance": 987.65
        }
    ]
}

================================================
FILE: examples/lesson10/fig10_01-03/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_01-03/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_01-03/fig10_03.cpp
================================================
// fig10_03.cpp
// SalariedEmployee class test program.
#include <format>
#include <iostream>
#include "SalariedEmployee.h" // SalariedEmployee class definition

int main() {
   // instantiate a SalariedEmployee object     
   SalariedEmployee employee{"Sierra Dembo", 300.0};

   // get SalariedEmployee data
   std::cout << "Employee information obtained by get functions:\n"
      << std::format("name: {}\nsalary: ${:.2f}\n", employee.getName(),
            employee.getSalary());

   employee.setSalary(500.0); // change salary      
   std::cout << "\nUpdated employee information from function toString:\n"
      << employee.toString();

   // display only the employee's earnings
   std::cout << std::format("\nearnings: ${:.2f}\n", employee.earnings());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_04-06/SalariedCommissionEmployee.cpp
================================================
// Fig. 10.5: SalariedCommissionEmployee.cpp
// Class SalariedCommissionEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedCommissionEmployee.h"

// constructor
SalariedCommissionEmployee::SalariedCommissionEmployee(
   std::string_view name, double salary, double grossSales, 
   double commissionRate)
   : SalariedEmployee{name, salary} { // call base-class constructor 

   setGrossSales(grossSales); // validate & store gross sales   
   setCommissionRate(commissionRate); // validate & store commission rate
}                                                              

// set gross sales amount
void SalariedCommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double SalariedCommissionEmployee::getGrossSales() const {
   return m_grossSales;
}

// return commission rate
void SalariedCommissionEmployee::setCommissionRate(
   double commissionRate) {

   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// get commission rate
double SalariedCommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
}

// calculate earnings--uses SalariedEmployee::earnings()
double SalariedCommissionEmployee::earnings() const {
   return SalariedEmployee::earnings() + 
      getGrossSales() * getCommissionRate();
} 

// returns string representation of SalariedCommissionEmployee object
std::string SalariedCommissionEmployee::toString() const {
   return std::format(
      "{}gross sales: ${:.2f}\ncommission rate: {:.2f}\n",
      SalariedEmployee::toString(), getGrossSales(), getCommissionRate());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_04-06/SalariedCommissionEmployee.h
================================================
// Fig. 10.4: SalariedCommissionEmployee.h
// SalariedCommissionEmployee class derived from class SalariedEmployee.
#pragma once
#include <string> 
#include <string_view> 
#include "SalariedEmployee.h" 

class SalariedCommissionEmployee : public SalariedEmployee {
public:
   SalariedCommissionEmployee(std::string_view name, double salary,
      double grossSales, double commissionRate);

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   double earnings() const;
   std::string toString() const;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_04-06/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_04-06/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_04-06/fig10_06.cpp
================================================
// fig10_06.cpp
// SalariedCommissionEmployee class test program.
#include <format>
#include <iostream>
#include "SalariedCommissionEmployee.h" 

int main() {
   // instantiate SalariedCommissionEmployee object             
   SalariedCommissionEmployee employee{"Ivano Lal", 300.0, 5000.0, .04};

   // get SalariedCommissionEmployee data
   std::cout << "Employee information obtained by get functions:\n"
      << std::format("{}: {}\n{}: {:.2f}\n{}: {:.2f}\n{}: {:.2f}\n",
            "name", employee.getName(), "salary", employee.getSalary(),
            "gross sales", employee.getGrossSales(),
            "commission", employee.getCommissionRate());

   employee.setGrossSales(8000.0); // change gross sales      
   employee.setCommissionRate(0.1); // change commission rate
   std::cout << "\nUpdated employee information from function toString:\n"
      << employee.toString();

   // display the employee's earnings
   std::cout << std::format("\nearnings: ${:.2f}\n", employee.earnings());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_07/SalariedCommissionEmployee.cpp
================================================
// Fig. 10.5: SalariedCommissionEmployee.cpp
// Class SalariedCommissionEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedCommissionEmployee.h"

// constructor
SalariedCommissionEmployee::SalariedCommissionEmployee(
   std::string_view name, double salary, double grossSales, 
   double commissionRate)
   : SalariedEmployee{name, salary} { // call base-class constructor 

   setGrossSales(grossSales); // validate & store gross sales   
   setCommissionRate(commissionRate); // validate & store commission rate
}                                                              

// set gross sales amount
void SalariedCommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double SalariedCommissionEmployee::getGrossSales() const {
   return m_grossSales;
}

// return commission rate
void SalariedCommissionEmployee::setCommissionRate(
   double commissionRate) {

   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// get commission rate
double SalariedCommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
}

// calculate earnings--uses SalariedEmployee::earnings()
double SalariedCommissionEmployee::earnings() const {
   return SalariedEmployee::earnings() + 
      getGrossSales() * getCommissionRate();
} 

// returns string representation of SalariedCommissionEmployee object
std::string SalariedCommissionEmployee::toString() const {
   return std::format(
      "{}gross sales: ${:.2f}\ncommission rate: {:.2f}\n",
      SalariedEmployee::toString(), getGrossSales(), getCommissionRate());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_07/SalariedCommissionEmployee.h
================================================
// Fig. 10.4: SalariedCommissionEmployee.h
// SalariedCommissionEmployee class derived from class SalariedEmployee.
#pragma once
#include <string> 
#include <string_view> 
#include "SalariedEmployee.h" 

class SalariedCommissionEmployee : public SalariedEmployee {
public:
   SalariedCommissionEmployee(std::string_view name, double salary,
      double grossSales, double commissionRate);

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   double earnings() const;
   std::string toString() const;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_07/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_07/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_07/fig10_07.cpp
================================================
// fig10_07.cpp
// Aiming base-class and derived-class pointers at base-class
// and derived-class objects, respectively.
#include <format>
#include <iostream>
#include "SalariedEmployee.h"
#include "SalariedCommissionEmployee.h" 

int main() {
   // create base-class object
   SalariedEmployee salaried{"Sierra Dembo", 500.0};

   // create derived-class object
   SalariedCommissionEmployee salariedCommission{
      "Ivano Lal", 300.0, 5000.0, .04};

   // output objects salaried and salariedCommission
   std::cout << std::format("{}:\n{}\n{}\n",
      "DISPLAY BASE-CLASS AND DERIVED-CLASS OBJECTS",
      salaried.toString(), // base-class toString
      salariedCommission.toString()); // derived-class toString

   // natural: aim base-class pointer at base-class object        
   SalariedEmployee* salariedPtr{&salaried};
   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING TOSTRING WITH BASE-CLASS POINTER TO",
      "BASE-CLASS OBJECT INVOKES BASE-CLASS FUNCTIONALITY",
      salariedPtr->toString()); // base-class version

   // natural: aim derived-class pointer at derived-class object
   SalariedCommissionEmployee* salariedCommissionPtr{&salariedCommission};

   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING TOSTRING WITH DERIVED-CLASS POINTER TO",
      "DERIVED-CLASS OBJECT INVOKES DERIVED-CLASS FUNCTIONALITY",
      salariedCommissionPtr->toString()); // derived-class version

   // aim base-class pointer at derived-class object   
   salariedPtr = &salariedCommission;
   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING TOSTRING WITH BASE-CLASS POINTER TO DERIVED-CLASS",
      "OBJECT INVOKES BASE-CLASS FUNCTIONALITY",
      salariedPtr->toString()); // base class version
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_08/SalariedCommissionEmployee.cpp
================================================
// Fig. 10.5: SalariedCommissionEmployee.cpp
// Class SalariedCommissionEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedCommissionEmployee.h"

// constructor
SalariedCommissionEmployee::SalariedCommissionEmployee(
   std::string_view name, double salary, double grossSales, 
   double commissionRate)
   : SalariedEmployee{name, salary} { // call base-class constructor 

   setGrossSales(grossSales); // validate & store gross sales   
   setCommissionRate(commissionRate); // validate & store commission rate
}                                                              

// set gross sales amount
void SalariedCommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double SalariedCommissionEmployee::getGrossSales() const {
   return m_grossSales;
}

// return commission rate
void SalariedCommissionEmployee::setCommissionRate(
   double commissionRate) {

   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// get commission rate
double SalariedCommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
}

// calculate earnings--uses SalariedEmployee::earnings()
double SalariedCommissionEmployee::earnings() const {
   return SalariedEmployee::earnings() + 
      getGrossSales() * getCommissionRate();
} 

// returns string representation of SalariedCommissionEmployee object
std::string SalariedCommissionEmployee::toString() const {
   return std::format(
      "{}gross sales: ${:.2f}\ncommission rate: {:.2f}\n",
      SalariedEmployee::toString(), getGrossSales(), getCommissionRate());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_08/SalariedCommissionEmployee.h
================================================
// Fig. 10.4: SalariedCommissionEmployee.h
// SalariedCommissionEmployee class derived from class SalariedEmployee.
#pragma once
#include <string> 
#include <string_view> 
#include "SalariedEmployee.h" 

class SalariedCommissionEmployee : public SalariedEmployee {
public:
   SalariedCommissionEmployee(std::string_view name, double salary,
      double grossSales, double commissionRate);

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   double earnings() const;
   std::string toString() const;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_08/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_08/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_08/fig10_08.cpp
================================================
// fig10_08.cpp
// Aiming a derived-class pointer at a base-class object.
#include "SalariedEmployee.h"
#include "SalariedCommissionEmployee.h"

int main() {
   SalariedEmployee salaried{"Sierra Dembo", 500.0};

   // aim derived-class pointer at base-class object                 
   // Error: a SalariedEmployee is not a SalariedCommissionEmployee
   SalariedCommissionEmployee* salariedCommissionPtr{&salaried};
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_09/SalariedCommissionEmployee.cpp
================================================
// Fig. 10.5: SalariedCommissionEmployee.cpp
// Class SalariedCommissionEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedCommissionEmployee.h"

// constructor
SalariedCommissionEmployee::SalariedCommissionEmployee(
   std::string_view name, double salary, double grossSales, 
   double commissionRate)
   : SalariedEmployee{name, salary} { // call base-class constructor 

   setGrossSales(grossSales); // validate & store gross sales   
   setCommissionRate(commissionRate); // validate & store commission rate
}                                                              

// set gross sales amount
void SalariedCommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double SalariedCommissionEmployee::getGrossSales() const {
   return m_grossSales;
}

// return commission rate
void SalariedCommissionEmployee::setCommissionRate(
   double commissionRate) {

   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// get commission rate
double SalariedCommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
}

// calculate earnings--uses SalariedEmployee::earnings()
double SalariedCommissionEmployee::earnings() const {
   return SalariedEmployee::earnings() + 
      getGrossSales() * getCommissionRate();
} 

// returns string representation of SalariedCommissionEmployee object
std::string SalariedCommissionEmployee::toString() const {
   return std::format(
      "{}gross sales: ${:.2f}\ncommission rate: {:.2f}\n",
      SalariedEmployee::toString(), getGrossSales(), getCommissionRate());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_09/SalariedCommissionEmployee.h
================================================
// Fig. 10.4: SalariedCommissionEmployee.h
// SalariedCommissionEmployee class derived from class SalariedEmployee.
#pragma once
#include <string> 
#include <string_view> 
#include "SalariedEmployee.h" 

class SalariedCommissionEmployee : public SalariedEmployee {
public:
   SalariedCommissionEmployee(std::string_view name, double salary,
      double grossSales, double commissionRate);

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   double earnings() const;
   std::string toString() const;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_09/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_09/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_09/fig10_09.cpp
================================================
// fig10_09.cpp
// Attempting to call derived-class-only functions
// via a base-class pointer.
#include <string>
#include "SalariedEmployee.h"
#include "SalariedCommissionEmployee.h"

int main() {
   SalariedCommissionEmployee salariedCommission{
      "Ivano Lal", 300.0, 5000.0, .04};
   
   // aim base-class pointer at derived-class object (allowed)
   SalariedEmployee* salariedPtr{&salariedCommission};

   // invoke base-class member functions on derived-class
   // object through base-class pointer (allowed)
   std::string name{salariedPtr->getName()};
   double salary{salariedPtr->getSalary()};        
   
   // attempt to invoke derived-class-only member functions          
   // on derived-class object through base-class pointer (disallowed)
   double grossSales{salariedPtr->getGrossSales()};  
   double commissionRate{salariedPtr->getCommissionRate()}; 
   salariedPtr->setGrossSales(8000.0);                      
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_10/SalariedCommissionEmployee.cpp
================================================
// Fig. 10.5: SalariedCommissionEmployee.cpp
// Class SalariedCommissionEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedCommissionEmployee.h"

// constructor
SalariedCommissionEmployee::SalariedCommissionEmployee(
   std::string_view name, double salary, double grossSales, 
   double commissionRate)
   : SalariedEmployee{name, salary} { // call base-class constructor 

   setGrossSales(grossSales); // validate & store gross sales   
   setCommissionRate(commissionRate); // validate & store commission rate
}                                                              

// set gross sales amount
void SalariedCommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double SalariedCommissionEmployee::getGrossSales() const {
   return m_grossSales;
}

// return commission rate
void SalariedCommissionEmployee::setCommissionRate(
   double commissionRate) {

   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// get commission rate
double SalariedCommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
}

// calculate earnings--uses SalariedEmployee::earnings()
double SalariedCommissionEmployee::earnings() const {
   return SalariedEmployee::earnings() + 
      getGrossSales() * getCommissionRate();
} 

// returns string representation of SalariedCommissionEmployee object
std::string SalariedCommissionEmployee::toString() const {
   return std::format(
      "{}gross sales: ${:.2f}\ncommission rate: {:.2f}\n",
      SalariedEmployee::toString(), getGrossSales(), getCommissionRate());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_10/SalariedCommissionEmployee.h
================================================
// Fig. 10.4: SalariedCommissionEmployee.h
// SalariedCommissionEmployee class derived from class SalariedEmployee.
#pragma once
#include <string> 
#include <string_view> 
#include "SalariedEmployee.h" 

class SalariedCommissionEmployee : public SalariedEmployee {
public:
   SalariedCommissionEmployee(std::string_view name, double salary,
      double grossSales, double commissionRate);

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   double earnings() const override;
   std::string toString() const override;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_10/SalariedEmployee.cpp
================================================
// Fig. 10.2: SalariedEmployee.cpp
// Class SalariedEmployee member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor                                                        
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : m_name{name} {
   setSalary(salary); 
}                                                                     

// set name
void SalariedEmployee::setName(std::string_view name) {
   m_name = name; // should validate
} 

// return name
std::string SalariedEmployee::getName() const {return m_name;}

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {                                       
      throw std::invalid_argument("Salary must be >= 0.0");       
   } 

   m_salary = salary;                                     
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings                        
double SalariedEmployee::earnings() const {return getSalary();}

// return string representation of SalariedEmployee object        
std::string SalariedEmployee::toString() const {                       
   return std::format("name: {}\nsalary: ${:.2f}\n", getName(), 
      getSalary());
}                                                                   
                                                            


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_10/SalariedEmployee.h
================================================
// Fig. 10.1: SalariedEmployee.h
// SalariedEmployee class definition.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class SalariedEmployee {
public:
   SalariedEmployee(std::string_view name, double salary);

   void setName(std::string_view name);
   std::string getName() const;

   void setSalary(double salary);
   double getSalary() const;

   virtual double earnings() const;
   virtual std::string toString() const;
private:
   std::string m_name{};
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_10/fig10_10.cpp
================================================
// fig10_10.cpp
// Introducing polymorphism, virtual functions and dynamic binding.
#include <format>
#include <iostream>
#include "SalariedEmployee.h"
#include "SalariedCommissionEmployee.h" 

int main() {
   // create base-class object
   SalariedEmployee salaried{"Sierra Dembo", 500.0};

   // create derived-class object
   SalariedCommissionEmployee salariedCommission{
      "Ivano Lal", 300.0, 5000.0, .04};

   // output objects using static binding
   std::cout << std::format("{}\n{}:\n{}\n{}\n",
      "INVOKING TOSTRING FUNCTION ON BASE-CLASS AND",
      "DERIVED-CLASS OBJECTS WITH STATIC BINDING",
      salaried.toString(), // static binding
      salariedCommission.toString()); // static binding

   std::cout << "INVOKING TOSTRING FUNCTION ON BASE-CLASS AND\n"
      << "DERIVED-CLASS OBJECTS WITH DYNAMIC BINDING\n\n";

   // natural: aim base-class pointer at base-class object        
   SalariedEmployee* salariedPtr{&salaried};
   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING VIRTUAL FUNCTION TOSTRING WITH BASE-CLASS POINTER",
      "TO BASE-CLASS OBJECT INVOKES BASE-CLASS FUNCTIONALITY",
      salariedPtr->toString()); // base-class version

   // natural: aim derived-class pointer at derived-class object
   SalariedCommissionEmployee* salariedCommissionPtr{&salariedCommission};
   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING VIRTUAL FUNCTION TOSTRING WITH DERIVED-CLASS POINTER",
      "TO DERIVED-CLASS OBJECT INVOKES DERIVED-CLASS FUNCTIONALITY",
      salariedCommissionPtr->toString()); // derived-class version

   // aim base-class pointer at derived-class object
   salariedPtr = &salariedCommission;

   // runtime polymorphism: invokes SalariedCommissionEmployee
   // via base-class pointer to derived-class object  
   std::cout << std::format("{}\n{}:\n{}\n",
      "CALLING VIRTUAL FUNCTION TOSTRING WITH BASE-CLASS POINTER",
      "TO DERIVED-CLASS OBJECT INVOKES DERIVED-CLASS FUNCTIONALITY",
      salariedPtr->toString()); // derived-class version
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/CommissionEmployee.cpp
================================================
// Fig. 10.16: CommissionEmployee.cpp
// CommissionEmployee class member-function definitions.
#include <format>
#include <stdexcept>
#include "CommissionEmployee.h" // CommissionEmployee class definition

// constructor                                                        
CommissionEmployee::CommissionEmployee(std::string_view name, 
   double grossSales, double commissionRate) : Employee{name} {
   setGrossSales(grossSales); 
   setCommissionRate(commissionRate); 
}                                      

// set gross sales amount
void CommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double CommissionEmployee::getGrossSales() const {return m_grossSales;}

// set commission rate
void CommissionEmployee::setCommissionRate(double commissionRate) {
   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// return commission rate
double CommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
} 

// calculate earnings                        
double CommissionEmployee::earnings() const {
   return getGrossSales() * getCommissionRate();
}                                            

// return string representation of CommissionEmployee object        
std::string CommissionEmployee::toString() const {                       
   return std::format("{}\n{}: ${:.2f}\n{}: {:.2f}", Employee::toString(),
      "gross sales", getGrossSales(),
      "commission rate", getCommissionRate());                  
}                                                                   

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/CommissionEmployee.h
================================================
// Fig. 10.15: CommissionEmployee.h
// CommissionEmployee class derived from Employee.
#pragma once
#include <string> 
#include <string_view> 
#include "Employee.h" // Employee class definition

class CommissionEmployee final : public Employee {
public:
   CommissionEmployee(std::string_view name, double grossSales,
      double commissionRate);
   virtual ~CommissionEmployee() = default; // virtual destructor

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   // keyword override signals intent to override                 
   double earnings() const override; // calculate earnings        
   std::string toString() const override; // string representation
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/Employee.cpp
================================================
// Fig. 10.12: Employee.cpp
// Abstract-base-class Employee member-function definitions.
// Note: No definitions are given for pure virtual functions.
#include <format>
#include "Employee.h" // Employee class definition

// constructor                                                        
Employee::Employee(std::string_view name) : m_name{name} {} // empty body

// set name
void Employee::setName(std::string_view name) {m_name = name;}

// get name
std::string Employee::getName() const {return m_name;}

// return string representation of an Employee
std::string Employee::toString() const {                       
   return std::format("name: {}", getName());
}                                                                   
                                                                                                                 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/Employee.h
================================================
// Fig. 10.11: Employee.h
// Employee abstract base class.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class Employee {
public:
   explicit Employee(std::string_view name);
   virtual ~Employee() = default; // compiler generates virtual destructor

   void setName(std::string_view name);
   std::string getName() const;

   // pure virtual function makes Employee an abstract base class
   virtual double earnings() const = 0; // pure virtual
   virtual std::string toString() const; // virtual
private:
   std::string m_name;
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/SalariedEmployee.cpp
================================================
// Fig. 10.14: SalariedEmployee.cpp
// SalariedEmployee class member-function definitions.
#include <format>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor 
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : Employee{name} {
   setSalary(salary); 
} 

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {
      throw std::invalid_argument("Weekly salary must be >= 0.0");
   } 

   m_salary = salary;
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings; 
// override pure virtual function earnings in Employee
double SalariedEmployee::earnings() const {return getSalary();}

// return a string representation of SalariedEmployee
std::string SalariedEmployee::toString() const {
   return std::format("{}\n{}: ${:.2f}", Employee::toString(), 
      "salary", getSalary());
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/SalariedEmployee.h
================================================
// Fig. 10.13: SalariedEmployee.h
// SalariedEmployee class derived from Employee.
#pragma once
#include <string> // C++ standard string class
#include <string_view> 
#include "Employee.h" // Employee class definition

class SalariedEmployee final : public Employee {
public:
   SalariedEmployee(std::string_view name, double salary);
   virtual ~SalariedEmployee() = default; // virtual destructor

   void setSalary(double salary);
   double getSalary() const;

   // keyword override signals intent to override               
   double earnings() const override; // calculate earnings        
   std::string toString() const override; // string representation
private:
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_11-17/fig10_17.cpp
================================================
// fig10_17.cpp
// Processing Employee derived-class objects with variable-name handles 
// then polymorphically using base-class pointers and references
#include <format>
#include <iostream>
#include <vector>
#include "Employee.h"
#include "SalariedEmployee.h" 
#include "CommissionEmployee.h"  

void virtualViaPointer(const Employee* baseClassPtr); // prototype
void virtualViaReference(const Employee& baseClassRef); // prototype

int main() {
   // create derived-class objects                        
   SalariedEmployee salaried{"Pierre Simon", 800.0};
   CommissionEmployee commission{"Sierra Dembo", 10000, .06};

   // output each Employee
   std::cout << "EMPLOYEES PROCESSED INDIVIDUALLY VIA VARIABLE NAMES\n"
      << std::format("{}\n{}{:.2f}\n\n{}\n{}{:.2f}\n\n",
            salaried.toString(), "earned $", salaried.earnings(),
            commission.toString(), "earned $", commission.earnings());

   // create and initialize vector of base-class pointers        
   std::vector<Employee*> employees{&salaried, &commission};

   std::cout << "EMPLOYEES PROCESSED POLYMORPHICALLY VIA"
      << " DYNAMIC BINDING\n\n";

   // call virtualViaPointer to print each Employee
   // and earnings using dynamic binding
   std::cout << "VIRTUAL FUNCTION CALLS MADE VIA BASE-CLASS POINTERS\n";

   for (const Employee* employeePtr : employees) {
      virtualViaPointer(employeePtr);
   }

   // call virtualViaReference to print each Employee
   // and earnings using dynamic binding
   std::cout << "VIRTUAL FUNCTION CALLS MADE VIA BASE-CLASS REFERENCES\n";

   for (const Employee* employeePtr : employees) {
      virtualViaReference(*employeePtr); // note dereferenced pointer
   }
}

// call Employee virtual functions toString and earnings via a   
// base-class pointer using dynamic binding                   
void virtualViaPointer(const Employee* baseClassPtr) {
   std::cout << std::format("{}\nearned ${:.2f}\n\n",
      baseClassPtr->toString(), baseClassPtr->earnings());
}

// call Employee virtual functions toString and earnings via a  
// base-class reference using dynamic binding                
void virtualViaReference(const Employee& baseClassRef) {
   std::cout << std::format("{}\nearned ${:.2f}\n\n",
      baseClassRef.toString(), baseClassRef.earnings());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Commission.cpp
================================================
// Fig. 10.25: Commission.cpp
// Commission member-function definitions.
#include <format>
#include <stdexcept>
#include "Commission.h" // class definition

// constructor                                                        
Commission::Commission(double grossSales, double commissionRate)         
   : m_grossSales{grossSales}, m_commissionRate{commissionRate} {

   if (m_grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   if (m_commissionRate <= 0.0 || m_commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 
}                                      

// override CompensationModel pure virtual function earnings
double Commission::earnings() const {
   return m_grossSales * m_commissionRate;       
}                                            

// override CompensationModel pure virtual function toString  
std::string Commission::toString() const {                       
   return std::format("gross sales: ${:.2f}; commission rate: {:.2f}", 
      m_grossSales, m_commissionRate);
}       

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Commission.h
================================================
// Fig. 10.24: Commission.h
// Commission implements the CompensationModel interface.
#pragma once
#include <string> 
#include "CompensationModel.h" // CompensationModel definition

class Commission final : public CompensationModel {
public:
   Commission(double grossSales, double commissionRate);
   double earnings() const override;
   std::string toString() const override;
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/CompensationModel.h
================================================
// Fig. 10.19: CompensationModel.h
// CompensationModel "interface" is a pure abstract base class.
#pragma once // prevent multiple inclusions of header
#include <string> 

class CompensationModel {
public:
   virtual ~CompensationModel() = default; // generated destructor 
   virtual double earnings() const = 0; // pure virtual
   virtual std::string toString() const = 0; // pure virtual              
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Employee.cpp
================================================
// Fig. 10.21: Employee.cpp
// Class Employee member-function definitions.
#include <format> 
#include <string> 
#include "CompensationModel.h"
#include "Employee.h" 

// constructor performs "constructor injection" to initialize  
// the CompensationModel pointer to a CompensationModel implementation 
Employee::Employee(std::string_view name, CompensationModel* modelPtr)
   : m_name{name}, m_modelPtr{modelPtr} {}

// set function performs "property injection" to change the   
// CompensationModel pointer to a new CompensationModel implementation 
void Employee::setCompensationModel(CompensationModel* modelPtr) {
   m_modelPtr = modelPtr;
}

// use the CompensationModel to calculate the Employee's earnings
double Employee::earnings() const {
   return m_modelPtr->earnings();
}; 

// return string representation of Employee object        
std::string Employee::toString() const {                       
   return std::format("{}\n{}", m_name, m_modelPtr->toString());
}                    

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Employee.h
================================================
// Fig. 10.20: Employee.h
// An Employee "has a" CompensationModel.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 
#include "CompensationModel.h"

class Employee final {
public:
   Employee(std::string_view name, CompensationModel* modelPtr);
   void setCompensationModel(CompensationModel* modelPtr);
   double earnings() const;
   std::string toString() const;
private:
   std::string m_name{};
   CompensationModel* m_modelPtr{}; // pointer to an implementation object
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Salaried.cpp
================================================
// Fig. 10.23: Salaried.cpp
// Salaried compensation model member-function definitions.
#include <format>
#include <stdexcept>
#include "Salaried.h" // class definition

// constructor 
Salaried::Salaried(double salary) : m_salary{salary} {
   if (m_salary < 0.0) {
      throw std::invalid_argument("Weekly salary must be >= 0.0");
   } 
} 

// override CompensationModel pure virtual function earnings
double Salaried::earnings() const {return m_salary;}

// override CompensationModel pure virtual function toString  
std::string Salaried::toString() const {
   return std::format("salary: ${:.2f}", m_salary);
} 




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/Salaried.h
================================================
// Fig. 10.22: Salaried.h
// Salaried implements the CompensationModel interface.
#pragma once
#include <string> 
#include "CompensationModel.h" // CompensationModel definition

class Salaried final : public CompensationModel {
public:
   explicit Salaried(double salary);
   double earnings() const override;
   std::string toString() const override;
private:
   double m_salary{0.0};
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson10/fig10_19-26/fig10_26.cpp
================================================
// fig10_26.cpp
// Processing Employees with various CompensationModels.
#include <format>
#include <iostream>
#include <vector>
#include "Employee.h"
#include "Salaried.h" 
#include "Commission.h"  

int main() {
   // create CompensationModels and Employees
   Salaried salaried{800.0};
   Employee salariedEmployee{"Pierre Simon", &salaried};

   Commission commission{10000, .06};
   Employee commissionEmployee{"Sierra Dembo", &commission};

   // create and initialize vector of Employees
   std::vector employees{salariedEmployee, commissionEmployee};

   // print each Employee's information and earnings 
   for (const Employee& employee : employees) {
      std::cout << std::format("{}\nearned: ${:.2f}\n\n",
         employee.toString(), employee.earnings());
   }
}





/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_01/fig11_01.cpp
================================================
// fig11_01.cpp
// Standard library string class test program.
#include <iostream>
#include <string> 
#include <string_view> 
#include "fmt/format.h" // in C++20, this will be #include <format>
using namespace std;

int main() {
   string s1{"happy"}; // initialize string from char*
   string s2{" birthday"}; // initialize string from char*
   string s3; // creates an empty string
   string_view v{"hello"}; // initialize string_view from char*

   // output strings and string_view
   cout << fmt::format("s1: \"{}\"; s2: \"{}\"; s3: \"{}\"; v: \"{}\"\n\n",
              s1, s2, s3, v);

   // test overloaded equality and relational operators
   cout << "The results of comparing s2 and s1:\n"   
      << fmt::format("s2 == s1: {}\n", s2 == s1)
      << fmt::format("s2 != s1: {}\n", s2 != s1)
      << fmt::format("s2 > s1: {}\n", s2 > s1)
      << fmt::format("s2 < s1: {}\n", s2 < s1)
      << fmt::format("s2 >= s1: {}\n", s2 >= s1)
      << fmt::format("s2 <= s1: {}\n\n", s2 <= s1);
      
   // test string member function empty 
   cout << "Testing s3.empty():\n";

   if (s3.empty()) {
      cout << "s3 is empty; assigning s1 to s3;\n";
      s3 = s1; // assign s1 to s3
      cout << fmt::format("s3 is \"{}\"\n\n", s3);
   } 

   // test overloaded string concatenation assignment operator
   s1 += s2; // test overloaded concatenation
   cout << fmt::format("s1 += s2 yields s1 = {}\n\n", s1);

   // test string concatenation with a C string
   s1 += " to you";  
   cout << fmt::format("s1 += \" to you\" yields s1 = {}\n\n", s1);

   // test string concatenation with a C++14 string-object literal
   s1 += ", have a great day!"s; // s after " for string-object literal
   cout << fmt::format(
              "s1 += \", have a great day!\"s yields\ns1 = {}\n\n", s1);

   // test string member function substr
   cout << fmt::format("{} {}\n{}\n\n",
              "The substring of s1 starting at location 0 for",
              "14 characters, s1.substr(0, 14), is:", s1.substr(0, 14));

   // test substr "to-end-of-string" option
   cout << fmt::format("{} {}\n{}\n\n",
              "The substring of s1 starting at",
              "location 15, s1.substr(15), is:", s1.substr(15)); 

   // test copy constructor
   string s4{s1};
   cout << fmt::format("s4 = {}\n\n", s4);

   // test overloaded copy assignment (=) operator with self-assignment
   cout << "assigning s4 to s4\n";
   s4 = s4;
   cout << fmt::format("s4 = {}\n\n", s4);

   // test string's string_view constructor
   cout << "initializing s5 with string_view v\n";
   string s5{v};
   cout << fmt::format("s5 is {}\n\n", s5);

   // test using overloaded subscript operator to create lvalue
   s1[0] = 'H';
   s1[6] = 'B';
   cout << fmt::format("{}:\n{}\n\n", 
              "after s1[0] = 'H' and s1[6] = 'B', s1 is", s1);

   // test index out of range with string member function "at"   
   try {                                                              
      cout << "Attempt to assign 'd' to s1.at(100) yields:\n";
      s1.at(100) = 'd'; // ERROR: subscript out of range            
   } 
   catch (const out_of_range& ex) {                                       
      cout << fmt::format("An exception occurred: {}\n", ex.what());        
   }
} 


/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_02/fig11_02.cpp
================================================
// fig11_02.cpp
// Demonstrating unique_ptr.
#include <iostream>
#include <memory>
using namespace std;

class Integer {
public:
   // constructor
   Integer(int i) : value{i} {
      cout << "Constructor for Integer " << value << "\n";
   }

   // destructor
   ~Integer() {
      cout << "Destructor for Integer " << value << "\n";
   }

   int getValue() const {return value;} // return Integer value
private:
   int value{0};
};

// use unique_ptr to manipulate Integer object
int main() {
   cout << "Creating a unique_ptr object that points to an Integer\n";

   // create a unique_ptr object and "aim" it at a new Integer object 
   auto ptr{make_unique<Integer>(7)};

   // use unique_ptr to call an Integer member function
   cout << "Integer value: " << ptr->getValue()
      << "\n\nMain ends\n";
}



/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_03-05/MyArray.cpp
================================================
// Fig. 11.5: MyArray.cpp
// MyArray class member- and friend-function definitions.
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <span>
#include <sstream> 
#include <stdexcept>
#include <utility>
#include "fmt/format.h" // In C++20, this will be #include <format> 
#include "MyArray.h" // MyArray class definition
using namespace std;

// MyArray constructor to create a MyArray of size elements containing 0
MyArray::MyArray(size_t size) 
   : m_size{size}, m_ptr{make_unique<int[]>(size)} {
   cout << "MyArray(size_t) constructor\n";
}

// MyArray constructor that accepts an initializer list
MyArray::MyArray(initializer_list<int> list)
   : m_size{list.size()}, m_ptr{make_unique<int[]>(list.size())} {
   cout << "MyArray(initializer_list) constructor\n";

   // copy list argument's elements into m_ptr's underlying int array;
   // m_ptr.get() returns the int array's starting memory location
   copy(begin(list), end(list), m_ptr.get());
}

// copy constructor: must receive a reference to a MyArray
MyArray::MyArray(const MyArray& original)
   : m_size{original.size()}, m_ptr{make_unique<int[]>(original.size())} {
   cout << "MyArray copy constructor\n";

   // copy original's elements into m_ptr's underlying int array 
   const span<const int> source{original.m_ptr.get(), original.size()};
   copy(begin(source), end(source), m_ptr.get());
}

// copy assignment operator: implemented with copy-and-swap idiom
MyArray& MyArray::operator=(const MyArray& right) {
   cout << "MyArray copy assignment operator\n";
   MyArray temp{right}; // invoke copy constructor
   swap(*this, temp); // exchange contents of this object and temp
   return *this;
}

// move constructor: must receive an rvalue reference to a MyArray                      
MyArray::MyArray(MyArray&& original) noexcept
   : m_size{exchange(original.m_size, 0)}, 
     m_ptr{std::move(original.m_ptr)} {  // move original.m_ptr into m_ptr
   cout << "MyArray move constructor\n";
}

// move assignment operator
MyArray& MyArray::operator=(MyArray&& right) noexcept {
   cout << "MyArray move assignment operator\n";

   if (this != &right) { // avoid self-assignment  
      // move right's data into this MyArray
      m_size = std::exchange(right.m_size, 0); // indicate right is empty
      m_ptr = std::move(right.m_ptr);
   }

   return *this; // enables x = y = z, for example                    
}

// destructor: This could be compiler-generated. We included it here so
// we could output when each MyArray is destroyed.
MyArray::~MyArray() {
   cout << "MyArray destructor\n";
}

// return a string representation of a MyArray
string MyArray::toString() const {
   const span<const int> items{m_ptr.get(), m_size};
   ostringstream output;
   output << "{";
   
   // insert each item in the dynamic array into the ostringstream
   for (size_t count{0}; const auto& item : items) {
      ++count;
      output << item << (count < m_size ? ", " : "");
   }

   output << "}";
   return output.str();
}

// determine if two MyArrays are equal and
// return true, otherwise return false
bool MyArray::operator==(const MyArray& right) const noexcept {
   // compare corresponding elements of both MyArrays
   const span<const int> lhs{m_ptr.get(), size()};
   const span<const int> rhs{right.m_ptr.get(), right.size()};
   return equal(begin(lhs), end(lhs), begin(rhs), end(rhs));
} 

// overloaded subscript operator for non-const MyArrays;
// reference return creates a modifiable lvalue
int& MyArray::operator[](size_t index) {
   // check for index out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // reference return
} 

// overloaded subscript operator for const MyArrays;
// const reference return creates a non-modifiable lvalue
const int& MyArray::operator[](size_t index) const {
   // check for subscript out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // returns copy of this element
} 

// preincrement every element, then return updated MyArray  
MyArray& MyArray::operator++() {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), [](auto& item){++item;});
   return *this; 
}

// postincrement every element, and return copy of original MyArray  
MyArray MyArray::operator++(int) {
   MyArray temp(*this);
   ++(*this); // call preincrement operator++ to do the incrementing
   return temp; // return the temporary copy made before incrementing
}

// add value to every element, then return updated MyArray
MyArray& MyArray::operator+=(int value) {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), 
      [value](auto& item) {item += value;});
   return *this;
}

// overloaded input operator for class MyArray;
// inputs values for entire MyArray
istream& operator>>(istream& in, MyArray& a) {
   span<int> items{a.m_ptr.get(), a.m_size};

   for (auto& item : items) {
      in >> item;
   }

   return in; // enables cin >> x >> y;
} 

// overloaded output operator for class MyArray 
ostream& operator<<(ostream& out, const MyArray& a) {
   out << a.toString();
   return out; // enables cout << x << y;
} 

// swap function used to implement copy-and-swap copy assignment operator
void swap(MyArray& a, MyArray& b) noexcept {
   std::swap(a.m_size, b.m_size); // swap using std::swap
   a.m_ptr.swap(b.m_ptr); // swap using unique_ptr swap member function
}

/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_03-05/MyArray.h
================================================
// Fig. 11.4: MyArray.h
// MyArray class definition with overloaded operators.
#pragma once
#include <initializer_list>
#include <iostream>
#include <memory>

class MyArray final {
   // overloaded stream extraction operator
   friend std::istream& operator>>(std::istream& in, MyArray& a);

   // used by copy assignment operator to implement copy-and-swap idiom
   friend void swap(MyArray& a, MyArray& b) noexcept;

public:
   explicit MyArray(size_t size); // construct a MyArray of size elements

   // construct a MyArray with a braced-initializer list of ints
   explicit MyArray(std::initializer_list<int> list);

   MyArray(const MyArray& original); // copy constructor
   MyArray& operator=(const MyArray& right); // copy assignment operator

   MyArray(MyArray&& original) noexcept; // move constructor
   MyArray& operator=(MyArray&& right) noexcept; // move assignment

   ~MyArray(); // destructor                 

   size_t size() const noexcept {return m_size;}; // return size
   std::string toString() const; // create string representation

   // equality operator; compiler autogenerates !=
   bool operator==(const MyArray& right) const noexcept; 

   // subscript operator for non-const objects returns modifiable lvalue
   int& operator[](size_t index);

   // subscript operator for const objects returns non-modifiable lvalue
   const int& operator[](size_t index) const;

   // convert MyArray to a bool value: true if non-empty; false if empty
   explicit operator bool() const noexcept {return size() != 0;}
   
   // preincrement every element, then return updated MyArray  
   MyArray& operator++();      

   // postincrement every element, and return copy of original MyArray  
   MyArray operator++(int); // postfix increment operator

   // add value to every element, then return updated MyArray
   MyArray& operator+=(int value);
private:
   size_t m_size{0}; // pointer-based array size
   std::unique_ptr<int[]> m_ptr; // smart pointer to integer array
};

// overloaded operator<< is not a friend--does not access private data
std::ostream& operator<<(std::ostream& out, const MyArray& a);



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_03-05/fig11_03.cpp
================================================
// fig11_03.cpp
// MyArray class test program.
#include <iostream>
#include <stdexcept>
#include <utility> // for std::move
#include "MyArray.h"
using namespace std;

// function to return a MyArray by value
MyArray getArrayByValue() {
   MyArray localInts{10, 20, 30}; // create three-element MyArray
   return localInts; // return by value creates an rvalue
}

int main() {
   MyArray ints1(7); // 7-element MyArray; note () rather than {}
   MyArray ints2(10); // 10-element MyArray; note () rather than {}

   // print ints1 size and contents
   cout << "\nints1 size: " << ints1.size()
      << "\ncontents: " << ints1; // uses overloaded <<

   // print ints2 size and contents
   cout << "\n\nints2 size: " << ints2.size()
      << "\ncontents: " << ints2; // uses overloaded <<

   // input and print ints1 and ints2
   cout << "\n\nEnter 17 integers: ";
   cin >> ints1 >> ints2; // uses overloaded >>

   cout << "\nints1: " << ints1 << "\nints2: " << ints2;

   // use overloaded inequality (!=) operator
   cout << "\n\nEvaluating: ints1 != ints2\n";

   if (ints1 != ints2) {
      cout << "ints1 and ints2 are not equal\n\n";
   }

   // create MyArray ints3 by copying ints1      
   MyArray ints3{ints1}; // invokes copy constructor 

   // print ints3 size and contents                
   cout << "\nints3 size: " << ints3.size() << "\ncontents: " << ints3;

   // use overloaded copy assignment (=) operator
   cout << "\n\nAssigning ints2 to ints1:\n";
   ints1 = ints2; // note target MyArray is smaller
  
   cout << "\nints1: " << ints1 << "\nints2: " << ints2;

   // use overloaded equality (==) operator
   cout << "\n\nEvaluating: ints1 == ints2\n";

   if (ints1 == ints2) { 
      cout << "ints1 and ints2 are equal\n\n";
   }

   // use overloaded subscript operator to create an rvalue
   cout << "ints1[5] is " << ints1[5];

   // use overloaded subscript operator to create an lvalue
   cout << "\n\nAssigning 1000 to ints1[5]\n";
   ints1[5] = 1000;
   cout << "ints1: " << ints1;

   // attempt to use out-of-range subscript
   try {                                                              
      cout << "\n\nAttempt to assign 1000 to ints1[15]\n";
      ints1[15] = 1000; // ERROR: subscript out of range
   } 
   catch (const out_of_range& ex) {                                       
      cout << "An exception occurred: " << ex.what() << "\n";
   } 

   // initialize ints4 with contents of the MyArray returned by 
   // getArrayByValue; print size and contents
   cout << "\nInitialize ints4 with temporary MyArray object\n";
   MyArray ints4{getArrayByValue()}; 

   cout << "\nints4 size: " << ints4.size() << "\ncontents: " << ints4;

   // convert ints4 to an rvalue reference with std::move and
   // use the result to initialize MyArray ints5
   cout << "\n\nInitialize ints5 with the result of std::move(ints4)\n";
   MyArray ints5{std::move(ints4)}; // invokes move constructor

   cout << "\nints5 size: " << ints5.size() << "\ncontents: " << ints5;
   cout << "\n\nSize of ints4 is now: " << ints4.size();

   // move contents of ints5 into ints4
   cout << "\n\nMove ints5 into ints4 via move assignment\n";
   ints4 = std::move(ints5); // invokes move assignment

   cout << "\nints4 size: " << ints4.size() << "\ncontents: " << ints4;
   cout << "\n\nSize of ints5 is now: " << ints5.size();

   // check if ints5 is empty by contextually converting it to a bool
   if (ints5) { 
      cout << "\n\nints5 contains elements\n";
   }
   else {
      cout << "\n\nints5 is empty\n";
   }

   // add one to every element of ints4 using preincrement
   cout << "\nints4: " << ints4;
   cout << "\npreincrementing ints4: " << ++ints4;

   // add one to every element of ints4 using postincrement
   cout << "\n\npostincrementing ints4: " << ints4++ << "\n";
   cout << "\nints4 now contains: " << ints4;
   
   // add a value to every element of ints4 using +=
   cout << "\n\nAdd 7 to every ints4 element: " << (ints4 += 7) << "\n\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_06/fig11_06.cpp
================================================
// fig11_06.cpp
// C++20 three-way comparison (spaceship) operator.
#include <compare>
#include <iostream>
#include <string>
#include "fmt/format.h"
using namespace std;

class Time {
public:
   Time(int hr, int min, int sec) noexcept
      : m_hr{hr}, m_min{min}, m_sec{sec} {}

   string toString() const {
      return fmt::format("hr={}, min={}, sec={}", m_hr, m_min, m_sec);
   }

   // <=> operator automatically supports equality/relational operators
   auto operator<=>(const Time& t) const noexcept = default;
private:
   int m_hr{0};
   int m_min{0};
   int m_sec{0};
};

int main() {
   const Time t1(12, 15, 30);
   const Time t2(12, 15, 30);
   const Time t3(6, 30, 0);

   cout << fmt::format("t1: {}\nt2: {}\nt3: {}\n\n", 
              t1.toString(), t2.toString(), t3.toString());

   // using the equality and relational operators 
   cout << fmt::format("t1 == t2: {}\n", t1 == t2); // (t1 <=> t2) == 0 
   cout << fmt::format("t1 != t2: {}\n", t1 != t2); // (t1 <=> t2) != 0
   cout << fmt::format("t1 < t2: {}\n", t1 < t2);
   cout << fmt::format("t1 <= t2: {}\n", t1 <= t2);
   cout << fmt::format("t1 > t2: {}\n", t1 > t2);
   cout << fmt::format("t1 >= t2: {}\n\n", t1 >= t2);

   cout << fmt::format("t1 == t3: {}\n", t1 == t3);
   cout << fmt::format("t1 != t3: {}\n", t1 != t3);
   cout << fmt::format("t1 < t3: {}\n", t1 < t3);
   cout << fmt::format("t1 <= t3: {}\n", t1 <= t3);
   cout << fmt::format("t1 > t3: {}\n", t1 > t3);
   cout << fmt::format("t1 >= t3: {}\n\n", t1 >= t3);

   // using <=> to perform comparisons
   if ((t1 <=> t2) == 0) {
      cout << "t1 is equal to t2\n";
   }

   if ((t1 <=> t3) > 0) {
      cout << "t1 is greater than t3\n";
   }

   if ((t3 <=> t1) < 0) {
      cout << "t3 is less than t1\n";
   }
}


/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_07/MyArray.cpp
================================================
// Fig. 11.5: MyArray.cpp
// MyArray class member- and friend-function definitions.
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <span>
#include <sstream> 
#include <stdexcept>
#include <utility>
#include "fmt/format.h" // In C++20, this will be #include <format> 
#include "MyArray.h" // MyArray class definition
using namespace std;

// MyArray constructor to create a MyArray of size elements containing 0
MyArray::MyArray(size_t size) 
   : m_size{size}, m_ptr{make_unique<int[]>(size)} {
   cout << "MyArray(size_t) constructor\n";
}

// MyArray constructor that accepts an initializer list
MyArray::MyArray(initializer_list<int> list)
   : m_size{list.size()}, m_ptr{make_unique<int[]>(list.size())} {
   cout << "MyArray(initializer_list) constructor\n";

   // copy list argument's elements into m_ptr's underlying int array;
   // m_ptr.get() returns the int array's starting memory location
   copy(begin(list), end(list), m_ptr.get());
}

// copy constructor: must receive a reference to a MyArray
MyArray::MyArray(const MyArray& original)
   : m_size{original.size()}, m_ptr{make_unique<int[]>(original.size())} {
   cout << "MyArray copy constructor\n";

   // copy original's elements into m_ptr's underlying int array 
   const span<const int> source{original.m_ptr.get(), original.size()};
   copy(begin(source), end(source), m_ptr.get());
}

// copy assignment operator: implemented with copy-and-swap idiom
MyArray& MyArray::operator=(const MyArray& right) {
   cout << "MyArray copy assignment operator\n";
   MyArray temp{right}; // invoke copy constructor
   swap(*this, temp); // exchange contents of this object and temp
   return *this;
}

// move constructor: must receive an rvalue reference to a MyArray                      
MyArray::MyArray(MyArray&& original) noexcept
   : m_size{exchange(original.m_size, 0)}, 
     m_ptr{std::move(original.m_ptr)} {  // move original.m_ptr into m_ptr
   cout << "MyArray move constructor\n";
}

// move assignment operator
MyArray& MyArray::operator=(MyArray&& right) noexcept {
   cout << "MyArray move assignment operator\n";

   if (this != &right) { // avoid self-assignment  
      // move right's data into this MyArray
      m_size = std::exchange(right.m_size, 0); // indicate right is empty
      m_ptr = std::move(right.m_ptr);
   }

   return *this; // enables x = y = z, for example                    
}

// destructor: This could be compiler-generated. We included it here so
// we could output when each MyArray is destroyed.
MyArray::~MyArray() {
   cout << "MyArray destructor\n";
}

// return a string representation of a MyArray
string MyArray::toString() const {
   const span<const int> items{m_ptr.get(), m_size};
   ostringstream output;
   output << "{";
   
   // insert each item in the dynamic array into the ostringstream
   for (size_t count{0}; const auto& item : items) {
      ++count;
      output << item << (count < m_size ? ", " : "");
   }

   output << "}";
   return output.str();
}

// determine if two MyArrays are equal and
// return true, otherwise return false
bool MyArray::operator==(const MyArray& right) const noexcept {
   // compare corresponding elements of both MyArrays
   const span<const int> lhs{m_ptr.get(), size()};
   const span<const int> rhs{right.m_ptr.get(), right.size()};
   return equal(begin(lhs), end(lhs), begin(rhs), end(rhs));
} 

// overloaded subscript operator for non-const MyArrays;
// reference return creates a modifiable lvalue
int& MyArray::operator[](size_t index) {
   // check for index out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // reference return
} 

// overloaded subscript operator for const MyArrays;
// const reference return creates a non-modifiable lvalue
const int& MyArray::operator[](size_t index) const {
   // check for subscript out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // returns copy of this element
} 

// preincrement every element, then return updated MyArray  
MyArray& MyArray::operator++() {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), [](auto& item){++item;});
   return *this; 
}

// postincrement every element, and return copy of original MyArray  
MyArray MyArray::operator++(int) {
   MyArray temp(*this);
   ++(*this); // call preincrement operator++ to do the incrementing
   return temp; // return the temporary copy made before incrementing
}

// add value to every element, then return updated MyArray
MyArray& MyArray::operator+=(int value) {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), 
      [value](auto& item) {item += value;});
   return *this;
}

// overloaded input operator for class MyArray;
// inputs values for entire MyArray
istream& operator>>(istream& in, MyArray& a) {
   span<int> items{a.m_ptr.get(), a.m_size};

   for (auto& item : items) {
      in >> item;
   }

   return in; // enables cin >> x >> y;
} 

// overloaded output operator for class MyArray 
ostream& operator<<(ostream& out, const MyArray& a) {
   out << a.toString();
   return out; // enables cout << x << y;
} 

// swap function used to implement copy-and-swap copy assignment operator
void swap(MyArray& a, MyArray& b) noexcept {
   std::swap(a.m_size, b.m_size); // swap using std::swap
   a.m_ptr.swap(b.m_ptr); // swap using unique_ptr swap member function
}

/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_07/MyArray.h
================================================
// Fig. 11.4: MyArray.h
// MyArray class definition with overloaded operators.
#pragma once
#include <initializer_list>
#include <iostream>
#include <memory>

class MyArray final {
   // overloaded stream extraction operator
   friend std::istream& operator>>(std::istream& in, MyArray& a);

   // used by copy assignment operator to implement copy-and-swap idiom
   friend void swap(MyArray& a, MyArray& b) noexcept;

public:
   MyArray(size_t size); // construct a MyArray of size elements

   // construct a MyArray with a braced-initializer list of ints
   explicit MyArray(std::initializer_list<int> list);

   MyArray(const MyArray& original); // copy constructor
   MyArray& operator=(const MyArray& right); // copy assignment operator

   MyArray(MyArray&& original) noexcept; // move constructor
   MyArray& operator=(MyArray&& right) noexcept; // move assignment

   ~MyArray(); // destructor                 

   size_t size() const noexcept {return m_size;}; // return size
   std::string toString() const; // create string representation

   // equality operator; compiler autogenerates !=
   bool operator==(const MyArray& right) const noexcept; 

   // subscript operator for non-const objects returns modifiable lvalue
   int& operator[](size_t index);

   // subscript operator for const objects returns non-modifiable lvalue
   const int& operator[](size_t index) const;

   // convert MyArray to a bool value: true if non-empty; false if empty
   explicit operator bool() const noexcept {return size() != 0;}

   // preincrement every element, then return updated MyArray  
   MyArray& operator++();      

   // postincrement every element, and return copy of original MyArray  
   MyArray operator++(int); // postfix increment operator

   // add value to every element, then return updated MyArray
   MyArray& operator+=(int value);
private:
   size_t m_size{0}; // pointer-based array size
   std::unique_ptr<int[]> m_ptr; // smart pointer to integer array
};

// overloaded operator<< is not a friend--does not access private data
std::ostream& operator<<(std::ostream& out, const MyArray& a);



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_07/fig11_07.cpp
================================================
// fig11_07.cpp
// Single-argument constructors and implicit conversions.
#include <iostream>
#include "MyArray.h"
using namespace std;

void outputArray(const MyArray&); // prototype

int main() {
   MyArray ints1(7); // 7-element MyArray
   outputArray(ints1); // output MyArray ints1
   outputArray(3); // convert 3 to a MyArray and output the contents
}  

// print MyArray contents
void outputArray(const MyArray& arrayToOutput) {
   cout << "The MyArray received has " << arrayToOutput.size() 
      << " elements. The contents are: " << arrayToOutput << "\n";
} 



/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_08/MyArray.cpp
================================================
// Fig. 11.5: MyArray.cpp
// MyArray class member- and friend-function definitions.
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <span>
#include <sstream> 
#include <stdexcept>
#include <utility>
#include "fmt/format.h" // In C++20, this will be #include <format> 
#include "MyArray.h" // MyArray class definition
using namespace std;

// MyArray constructor to create a MyArray of size elements containing 0
MyArray::MyArray(size_t size) 
   : m_size{size}, m_ptr{make_unique<int[]>(size)} {
   cout << "MyArray(size_t) constructor\n";
}

// MyArray constructor that accepts an initializer list
MyArray::MyArray(initializer_list<int> list)
   : m_size{list.size()}, m_ptr{make_unique<int[]>(list.size())} {
   cout << "MyArray(initializer_list) constructor\n";

   // copy list argument's elements into m_ptr's underlying int array;
   // m_ptr.get() returns the int array's starting memory location
   copy(begin(list), end(list), m_ptr.get());
}

// copy constructor: must receive a reference to a MyArray
MyArray::MyArray(const MyArray& original)
   : m_size{original.size()}, m_ptr{make_unique<int[]>(original.size())} {
   cout << "MyArray copy constructor\n";

   // copy original's elements into m_ptr's underlying int array 
   const span<const int> source{original.m_ptr.get(), original.size()};
   copy(begin(source), end(source), m_ptr.get());
}

// copy assignment operator: implemented with copy-and-swap idiom
MyArray& MyArray::operator=(const MyArray& right) {
   cout << "MyArray copy assignment operator\n";
   MyArray temp{right}; // invoke copy constructor
   swap(*this, temp); // exchange contents of this object and temp
   return *this;
}

// move constructor: must receive an rvalue reference to a MyArray                      
MyArray::MyArray(MyArray&& original) noexcept
   : m_size{exchange(original.m_size, 0)}, 
     m_ptr{std::move(original.m_ptr)} {  // move original.m_ptr into m_ptr
   cout << "MyArray move constructor\n";
}

// move assignment operator
MyArray& MyArray::operator=(MyArray&& right) noexcept {
   cout << "MyArray move assignment operator\n";

   if (this != &right) { // avoid self-assignment  
      // move right's data into this MyArray
      m_size = std::exchange(right.m_size, 0); // indicate right is empty
      m_ptr = std::move(right.m_ptr);
   }

   return *this; // enables x = y = z, for example                    
}

// destructor: This could be compiler-generated. We included it here so
// we could output when each MyArray is destroyed.
MyArray::~MyArray() {
   cout << "MyArray destructor\n";
}

// return a string representation of a MyArray
string MyArray::toString() const {
   const span<const int> items{m_ptr.get(), m_size};
   ostringstream output;
   output << "{";
   
   // insert each item in the dynamic array into the ostringstream
   for (size_t count{0}; const auto& item : items) {
      ++count;
      output << item << (count < m_size ? ", " : "");
   }

   output << "}";
   return output.str();
}

// determine if two MyArrays are equal and
// return true, otherwise return false
bool MyArray::operator==(const MyArray& right) const noexcept {
   // compare corresponding elements of both MyArrays
   const span<const int> lhs{m_ptr.get(), size()};
   const span<const int> rhs{right.m_ptr.get(), right.size()};
   return equal(begin(lhs), end(lhs), begin(rhs), end(rhs));
} 

// overloaded subscript operator for non-const MyArrays;
// reference return creates a modifiable lvalue
int& MyArray::operator[](size_t index) {
   // check for index out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // reference return
} 

// overloaded subscript operator for const MyArrays;
// const reference return creates a non-modifiable lvalue
const int& MyArray::operator[](size_t index) const {
   // check for subscript out-of-range error
   if (index >= m_size) {
      throw out_of_range{"Index out of range"};
   }

   return m_ptr[index]; // returns copy of this element
} 

// preincrement every element, then return updated MyArray  
MyArray& MyArray::operator++() {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), [](auto& item){++item;});
   return *this; 
}

// postincrement every element, and return copy of original MyArray  
MyArray MyArray::operator++(int) {
   MyArray temp(*this);
   ++(*this); // call preincrement operator++ to do the incrementing
   return temp; // return the temporary copy made before incrementing
}

// add value to every element, then return updated MyArray
MyArray& MyArray::operator+=(int value) {
   // use a span and for_each to increment every element 
   const span<int> items{m_ptr.get(), m_size};
   for_each(begin(items), end(items), 
      [value](auto& item) {item += value;});
   return *this;
}

// overloaded input operator for class MyArray;
// inputs values for entire MyArray
istream& operator>>(istream& in, MyArray& a) {
   span<int> items{a.m_ptr.get(), a.m_size};

   for (auto& item : items) {
      in >> item;
   }

   return in; // enables cin >> x >> y;
} 

// overloaded output operator for class MyArray 
ostream& operator<<(ostream& out, const MyArray& a) {
   out << a.toString();
   return out; // enables cout << x << y;
} 

// swap function used to implement copy-and-swap copy assignment operator
void swap(MyArray& a, MyArray& b) noexcept {
   std::swap(a.m_size, b.m_size); // swap using std::swap
   a.m_ptr.swap(b.m_ptr); // swap using unique_ptr swap member function
}

/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_08/MyArray.h
================================================
// Fig. 11.4: MyArray.h
// MyArray class definition with overloaded operators.
#pragma once
#include <initializer_list>
#include <iostream>
#include <memory>

class MyArray final {
   // overloaded stream extraction operator
   friend std::istream& operator>>(std::istream& in, MyArray& a);

   // used by copy assignment operator to implement copy-and-swap idiom
   friend void swap(MyArray& a, MyArray& b) noexcept;

public:
   explicit MyArray(size_t size); // construct a MyArray of size elements

   // construct a MyArray with a braced-initializer list of ints
   explicit MyArray(std::initializer_list<int> list);

   MyArray(const MyArray& original); // copy constructor
   MyArray& operator=(const MyArray& right); // copy assignment operator

   MyArray(MyArray&& original) noexcept; // move constructor
   MyArray& operator=(MyArray&& right) noexcept; // move assignment

   ~MyArray(); // destructor                 

   size_t size() const noexcept {return m_size;}; // return size
   std::string toString() const; // create string representation

   // equality operator; compiler autogenerates !=
   bool operator==(const MyArray& right) const noexcept; 

   // subscript operator for non-const objects returns modifiable lvalue
   int& operator[](size_t index);

   // subscript operator for const objects returns non-modifiable lvalue
   const int& operator[](size_t index) const;

   // convert MyArray to a bool value: true if non-empty; false if empty
   explicit operator bool() const noexcept {return size() != 0;}

   // preincrement every element, then return updated MyArray  
   MyArray& operator++();      

   // postincrement every element, and return copy of original MyArray  
   MyArray operator++(int); // postfix increment operator

   // add value to every element, then return updated MyArray
   MyArray& operator+=(int value);
private:
   size_t m_size{0}; // pointer-based array size
   std::unique_ptr<int[]> m_ptr; // smart pointer to integer array
};

// overloaded operator<< is not a friend--does not access private data
std::ostream& operator<<(std::ostream& out, const MyArray& a);



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson11/fig11_08/fig11_08.cpp
================================================
// fig11_08.cpp
// Demonstrating an explicit constructor.
#include <iostream>
#include "MyArray.h"
using namespace std;

void outputArray(const MyArray&); // prototype

int main() {
   MyArray ints1(7); // 7-element MyArray
   outputArray(ints1); // output MyArray ints1
   outputArray(3); // convert 3 to a MyArray and output its contents
   outputArray(MyArray(3)); // explicit single-argument constructor call
}  

// print MyArray contents
void outputArray(const MyArray& arrayToOutput) {
   cout << "The MyArray received has " << arrayToOutput.size() 
      << " elements. The contents are: " << arrayToOutput << "\n";
} 



/**************************************************************************
 * (C) Copyright 1992-2017 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_01-02/DivideByZeroException.h
================================================
// Fig. 12.1: DivideByZeroException.h
// Class DivideByZeroException definition.
#include <stdexcept> // stdexcept header contains runtime_error          

// DivideByZeroException objects should be thrown 
// by functions upon detecting division-by-zero 
class DivideByZeroException : public std::runtime_error {
public:
   // constructor specifies default error message
   DivideByZeroException()
      : std::runtime_error{"attempted to divide by zero"} {}
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_01-02/fig12_02.cpp
================================================
// fig12_02.cpp
// Example that throws an exception on 
// an attempt to divide by zero.
#include <fmt/format.h>
#include <iostream>
#include "DivideByZeroException.h" // DivideByZeroException class 

// performs division only if the denominator is not zero; 
// otherwise, throws DivideByZeroException object 
double quotient(double numerator, double denominator) {
   // throw DivideByZeroException if trying to divide by zero
   if (denominator == 0.0) {
      throw DivideByZeroException{}; 
   }

   // return division result
   return numerator / denominator;
}

int main() {
   int number1{0}; // user-specified numerator
   int number2{0}; // user-specified denominator

   std::cout << "Enter two integers (end-of-file to end): ";

   // enable user to enter two integers to divide
   while (std::cin >> number1 >> number2) {
      // try block contains code that might throw exception       
      // and code that will not execute if an exception occurs    
      try {
         double result{quotient(number1, number2)};
         std::cout << fmt::format("The quotient is: {}\n", result);
      }
      catch (const DivideByZeroException& divideByZeroException) {
         std::cout << fmt::format("Exception occurred: {}\n",
            divideByZeroException.what());
      }

      std::cout << "\nEnter two integers (end-of-file to end): ";
   }

   std::cout << '\n';
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_03/fig12_03.cpp
================================================
// fig12_03.cpp
// Rethrowing an exception.
#include <iostream>
#include <exception>

// throw, catch and rethrow exception
void throwException() {
   // throw exception and catch it immediately
   try {
      std::cout << "  Function throwException throws an exception\n";
      throw std::exception{}; // generate exception
   }
   catch (const std::exception&) { // handle exception
      std::cout << "  Exception handled in function throwException"
         << "\n  Function throwException rethrows exception";
      throw; // rethrow exception for further processing
   }

   std::cout << "This should not print\n";
}

int main() {
   // call throwException
   try {
      std::cout << "main invokes function throwException\n";
      throwException();
      std::cout << "This should not print\n";
   }
   catch (const std::exception&) { // handle exception
      std::cout << "\n\nException handled in main\n";
   }

   std::cout << "Program control continues after catch in main\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_04/fig12_04.cpp
================================================
// fig12_04.cpp
// Demonstrating stack unwinding.
#include <iostream>
#include <stdexcept>     

// function3 throws runtime error
void function3() {
   std::cout << "In function 3\n";

   // no try block, stack unwinding occurs, return control to function2
   throw std::runtime_error{"runtime_error in function3"};
}

// function2 invokes function3
void function2() {
   std::cout << "function3 is called inside function2\n";
   function3(); // stack unwinding occurs, return control to function1
}

// function1 invokes function2
void function1() {
   std::cout << "function2 is called inside function1\n";
   function2(); // stack unwinding occurs, return control to main
}

// demonstrate stack unwinding
int main() {
   // invoke function1
   try {
      std::cout << "function1 is called inside main\n";
      function1(); // call function1 which leads to a runtime_error
   }
   catch (const std::runtime_error& error) { // handle runtime error
      std::cout << "Exception occurred: " << error.what()
         << "\nException handled in main\n";
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_04/fig12_04modified.cpp
================================================
// fig12_04.cpp
// Demonstrating stack unwinding.
#include <iostream>
#include <stdexcept>     

// function3 throws runtime error
void function3() {
   std::cout << "In function 3\n";

   // no try block, stack unwinding occurs, return control to function2
   throw std::runtime_error{"runtime_error in function3"}; 
} 

// function2 invokes function3
void function2() {
   std::cout << "function3 is called inside function2\n";
   function3(); // stack unwinding occurs, return control to function1
} 

// function1 invokes function2
void function1() {
   std::cout << "function2 is called inside function1\n";
   function2(); // stack unwinding occurs, return control to main
} 

// demonstrate stack unwinding
int main() {
   // invoke function1
   std::cout << "function1 is called inside main\n";
   function1(); // call function1 which leads to a runtime_error
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_05/fig12_05.cpp
================================================
// fig12_05.cpp
// Demonstrating a function try block.
#include <fmt/format.h>
#include <iostream>
#include <limits>
#include <stdexcept>

// class Integer purposely throws an exception from its constructor
class Integer {
public:
   explicit Integer(int i) : value{i} {
      std::cout << fmt::format("Integer constructor: {}\n", value)
         << "Purposely throwing exception from Integer constructor\n";
      throw std::runtime_error("Integer constructor failed");
   }
private:
   int value{};
};

class ResourceManager {
public:
   ResourceManager(int i) try : myInteger(i) {
      std::cout << "ResourceManager constructor called\n";
   }
   catch (const std::runtime_error& ex) {
      std::cout << fmt::format(
         "Exception while constructing ResourceManager: ", ex.what())
         << "\nAutomatically rethrowing the exception\n";
   }
private:
   Integer myInteger;
};

int main() {
   try {
      const ResourceManager resource{7};
   }
   catch (const std::runtime_error& ex) {
      std::cout << fmt::format("Rethrown exception caught in main: {}\n",
         ex.what());
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_06/fig12_06.cpp
================================================
// fig12_06.cpp
// Demonstrating standard new throwing bad_alloc when memory
// cannot be allocated.
#include <array>
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include <new> // bad_alloc class is defined here

int main() {
   std::array<std::unique_ptr<double[]>, 1000> items{};

   // aim each unique_ptr at a big block of memory
   try {
      for (int i{0}; auto & item : items) {
         item = std::make_unique<double[]>(500'000'000);
         std::cout << fmt::format(
            "items[{}] points to 500,000,000 doubles\n", i++);
      }
   }
   catch (const std::bad_alloc& memoryAllocationException) {
      std::cerr << fmt::format("Exception occurred: {}\n",
         memoryAllocationException.what());
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_07/fig12_07.cpp
================================================
// fig12_07.cpp
// Demonstrating set_new_handler.
#include <array>
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include <new> // set_new_handler is defined here

// handle memory allocation failure      
void customNewHandler() {
   std::cerr << "customNewHandler was called\n";
   std::exit(EXIT_FAILURE);
}

int main() {
   std::array<std::unique_ptr<double[]>, 1000> items{};

   // specify that customNewHandler should be called on 
   // memory allocation failure                         
   std::set_new_handler(customNewHandler);

   // aim each unique_ptr at a big block of memory
   for (int i{0}; auto & item : items) {
      item = std::make_unique<double[]>(500'000'000);
      std::cout << fmt::format(
         "items[{}] points to 500,000,000 doubles\n", i++);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_08/fig12_08.cpp
================================================
// fig12_08.cpp
// Division by zero with a precondition.
#include <iostream>

double quotient(double numerator, double denominator) 
   [[pre: denominator != 0.0]];

int main() {
   std::cout << "quotient(100, 7): " << quotient(100, 7)
      << "\nquotient(100, 0): " << quotient(100, 0) << '\n';
} 

// perform division 
double quotient(double numerator, double denominator) {
   return numerator / denominator;
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson12/fig12_09/fig12_09.cpp
================================================
// fig12_09.cpp
// binarySearch function with a precondition requiring a sorted vector.
#include <algorithm>
#include <iostream>
#include <vector>

template<class T>
int binarySearch(const std::vector<T>& items, const T& key)
   [[pre: items.size() > 0]]
   [[pre audit: std::is_sorted(items.begin(), items.end())]] {
   size_t low{0}; // low index of elements to search                 
   size_t high{items.size() - 1}; // high index
   size_t middle{(low + high + 1) / 2}; // middle element            
   int loc{-1}; // key's index; -1 if not found              

   do { // loop to search for element                             
      // if the element is found at the middle                
      if (key == items[middle]) {                             
         loc = middle; // loc is the current middle 
      }                                                       
      else if (key < items[middle]) { // middle is too high   
         high = middle - 1; // eliminate the higher half      
      }                                                       
      else { // middle element is too low                     
         low = middle + 1; // eliminate the lower half        
      }                                                       

      middle = (low + high + 1) / 2; // recalculate the middle
   } while ((low <= high) && (loc == -1));               

   return loc; // return location of key
} 

int main() {
   // sorted vector v1 satisfies binarySearch's sorted vector precondition
   std::vector v1{10, 20, 30, 40, 50, 60, 70, 80, 90};
   int result1{binarySearch(v1, 70)};
   std::cout << "70 was " << (result1 != -1 ? "" : "not ") << "found in v1\n";

   // unsorted vector v2 violates binarySearch's sorted vector precondition
   std::vector v2{60, 70, 80, 90, 10, 20, 30, 40, 50};
   int result2{binarySearch(v2, 60)};
   std::cout << "60 was " << (result2 != -1 ? "" : "not ") << "found in v2\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_01.cpp
================================================
// fig13_01.cpp
// Demonstrating input and output with iterators.
#include <iostream>
#include <iterator> // ostream_iterator and istream_iterator

int main() {
   std::cout << "Enter two integers: ";

   // create istream_iterator for reading int values from cin
   std::istream_iterator<int> inputInt{std::cin};

   const int number1{*inputInt}; // read int from standard input
   ++inputInt; // move iterator to next input value        
   const int number2{*inputInt}; // read int from standard input

   // create ostream_iterator for writing int values to cout
   std::ostream_iterator<int> outputInt{std::cout};

   std::cout << "The sum is: ";
   *outputInt = number1 + number2; // output result to cout
   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_02.cpp
================================================
// fig13_02.cpp
// Standard library vector class template.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <ranges>
#include <vector> // vector class-template definition

// display value appended to vector and updated vector size and capacity
void showResult(int value, size_t size, size_t capacity) {
   std::cout << fmt::format("appended: {}; size: {}; capacity: {}\n",
      value, size, capacity);
}

int main() {
   std::vector<int> integers{}; // create vector of ints

   std::cout << "Size of integers: " << integers.size()
      << "\nCapacity of integers: " << integers.capacity() << "\n\n";

   // append 1-10 to integers and display updated size and capacity
   for (int i : std::views::iota(1, 11)) {
      integers.push_back(i); // push_back is in vector, deque and list
      showResult(i, integers.size(), integers.capacity());
   }

   std::cout << "\nOutput integers using iterators: ";

   for (auto constIterator{integers.cbegin()};
      constIterator != integers.cend(); ++constIterator) {
      std::cout << *constIterator << ' ';
   }

   std::cout << "\nOutput integers in reverse using iterators: ";

   // display vector in reverse order using const_reverse_iterator
   for (auto reverseIterator{integers.crbegin()};
      reverseIterator != integers.crend(); ++reverseIterator) {
      std::cout << *reverseIterator << ' ';
   }

   std::cout << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_03.cpp
================================================
// fig13_03.cpp
// Testing standard library vector class template
// element-manipulation functions.
#include <algorithm> // copy algorithm
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <ranges> 
#include <iterator> // ostream_iterator iterator
#include <vector> 

int main() {
   std::vector values{1, 2, 3, 4, 5}; // class template argument deduction
   std::vector<int> integers{values.cbegin(), values.cend()};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "integers contains: ";
   std::copy(integers.cbegin(), integers.cend(), output);

   std::cout << fmt::format("\nfront: {}\nback: {}\n\n",
      integers.front(), integers.back());

   integers[0] = 7; // set first element to 7             
   integers.at(2) = 10; // set element at position 2 to 10

   // insert 22 as second element                  
   integers.insert(integers.cbegin() + 1, 22);

   std::cout << "Contents of vector integers after changes: ";
   std::ranges::copy(integers, output);

   integers.erase(integers.cbegin()); // erase first element
   std::cout << "\n\nintegers after erasing first element: ";
   std::ranges::copy(integers, output);

   // erase remaining elements                          
   integers.erase(integers.cbegin(), integers.cend());
   std::cout << fmt::format("\nErased all elements: integers {} empty\n",
      integers.empty() ? "is" : "is not");

   // insert elements from the vector values                             
   integers.insert(integers.cbegin(), values.cbegin(), values.cend());
   std::cout << "\nContents of vector integers before clear: ";
   std::ranges::copy(integers, output);

   // empty integers; clear empties a collection
   integers.clear();
   std::cout << fmt::format("\nAfter clear, integers {} empty\n",
      integers.empty() ? "is" : "is not");
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_04.cpp
================================================
// fig13_04.cpp
// Standard library list class template.
#include <algorithm> // copy algorithm
#include <iostream>
#include <iterator> // ostream_iterator
#include <list> // list class-template definition
#include <vector>

// printList function template definition; uses 
// ostream_iterator and copy algorithm to output list elements
template <typename T>
void printList(const std::list<T>& items) {
   if (items.empty()) { // list is empty
      std::cout << "List is empty";
   }
   else {
      std::ostream_iterator<T> output{std::cout, " "};
      std::ranges::copy(items, output);
   }
}

int main() {
   std::list<int> values{}; // create list of ints     

   // insert items in values
   values.push_front(1);
   values.push_front(2);
   values.push_back(4);
   values.push_back(3);

   std::cout << "values contains: ";
   printList(values);

   values.sort(); // sort values
   std::cout << "\nvalues after sorting contains: ";
   printList(values);

   // insert elements of ints into otherValues                            
   std::vector ints{2, 6, 4, 8};
   std::list<int> otherValues{}; // create list of ints
   otherValues.insert(otherValues.cbegin(), ints.cbegin(), ints.cend());
   std::cout << "\nAfter insert, otherValues contains: ";
   printList(otherValues);

   // remove otherValues elements and insert at end of values
   values.splice(values.cend(), otherValues);
   std::cout << "\nAfter splice, values contains: ";
   printList(values);

   values.sort(); // sort values
   std::cout << "\nAfter sort, values contains: ";
   printList(values);

   // insert elements of ints into otherValues                            
   otherValues.insert(otherValues.cbegin(), ints.cbegin(), ints.cend());
   otherValues.sort(); // sort the list                                 
   std::cout << "\nAfter insert and sort, otherValues contains: ";
   printList(otherValues);

   // remove otherValues elements and insert into values in sorted order
   values.merge(otherValues);
   std::cout << "\nAfter merge:\n   values contains: ";
   printList(values);
   std::cout << "\n   otherValues contains: ";
   printList(otherValues);

   values.pop_front(); // remove element from front
   values.pop_back(); // remove element from back  
   std::cout << "\nAfter pop_front and pop_back:\n   values contains: ";
   printList(values);

   values.unique(); // remove duplicate elements
   std::cout << "\nAfter unique, values contains: ";
   printList(values);

   values.swap(otherValues); // swap elements of values and otherValues
   std::cout << "\nAfter swap:\n   values contains: ";
   printList(values);
   std::cout << "\n   otherValues contains: ";
   printList(otherValues);

   // replace contents of values with elements of otherValues
   values.assign(otherValues.cbegin(), otherValues.cend());
   std::cout << "\nAfter assign, values contains: ";
   printList(values);

   // remove otherValues elements and insert into values in sorted order
   values.merge(otherValues);
   std::cout << "\nAfter merge, values contains: ";
   printList(values);

   values.remove(4); // remove all 4s
   std::cout << "\nAfter remove(4), values contains: ";
   printList(values);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/



================================================
FILE: examples/lesson13/fig13_05.cpp
================================================
// fig13_05.cpp
// Standard library deque class template.
#include <algorithm> // copy algorithm
#include <deque> // deque class-template definition
#include <iostream>
#include <iterator> // ostream_iterator

int main() {
   std::deque<double> values; // create deque of doubles
   std::ostream_iterator<double> output{std::cout, " "};

   // insert elements in values
   values.push_front(2.2);
   values.push_front(3.5);
   values.push_back(1.1);

   std::cout << "values contains: ";

   // use subscript operator to obtain elements of values
   for (size_t i{0}; i < values.size(); ++i) {
      std::cout << values[i] << ' ';
   }

   values.pop_front(); // remove first element
   std::cout << "\nAfter pop_front, values contains: ";
   std::ranges::copy(values, output);

   // use subscript operator to modify element at location 1
   values[1] = 5.4;
   std::cout << "\nAfter values[1] = 5.4, values contains: ";
   std::ranges::copy(values, output);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_06.cpp
================================================
// fig13_06.cpp
// Standard library multiset class template
#include <algorithm> // copy algorithm
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <iterator> // ostream_iterator
#include <ranges> 
#include <set> // multiset class-template definition
#include <vector>

int main() {
   std::multiset<int, std::less<int>> ints{}; // multiset of int values
   std::cout << fmt::format("15s in ints: {}\n", ints.count(15));

   std::cout << "\nInserting two 15s into ints\n";
   ints.insert(15); // insert 15 in ints
   ints.insert(15); // insert 15 in ints
   std::cout << fmt::format("15s in ints: {}\n\n", ints.count(15));

   // search for 15 and 20 in ints; find returns an iterator
   for (int i : {15, 20}) {
      if (auto result{ints.find(i)}; result != ints.end()) {
         std::cout << fmt::format("Found {} in ints\n", i);
      }
      else {
         std::cout << fmt::format("Did not find {} in ints\n", i);
      }
   }

   // search for 15 and 20 in ints; contains returns a bool
   for (int i : {15, 20}) {
      if (ints.contains(i)) {
         std::cout << fmt::format("Found {} in ints\n", i);
      }
      else {
         std::cout << fmt::format("Did not find {} in ints\n", i);
      }
   }

   // insert elements of vector values into ints
   const std::vector values{7, 22, 9, 1, 18, 30, 100, 22, 85, 13};
   ints.insert(values.cbegin(), values.cend());
   std::cout << "\nAfter insert, ints contains:\n";
   std::ranges::copy(ints, std::ostream_iterator<int>{std::cout, " "});

   // determine lower and upper bound of 22 in ints
   std::cout << fmt::format(
      "\n\nlower_bound(22): {}\nupper_bound(22): {}\n\n",
      *ints.lower_bound(22), *ints.upper_bound(22));

   // use equal_range to determine lower and upper bound of 22 in ints 
   auto p{ints.equal_range(22)};
   std::cout << fmt::format(
      "lower_bound(22): {}\nupper_bound(22): {}\n",
      *(p.first), *(p.second));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_07.cpp
================================================
// fig13_07.cpp
// Standard library set class template.
#include <algorithm>
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <iterator> // ostream_iterator
#include <set>

int main() {
   std::set doubles{2.1, 4.2, 9.5, 2.1, 3.7}; // CTAD 

   std::ostream_iterator<double> output{std::cout, " "};
   std::cout << "doubles contains: ";
   std::ranges::copy(doubles, output);

   // insert 13.8 in doubles; insert returns pair in which
   // p.first represents location of 13.8 in doubles and  
   // p.second represents whether 13.8 was inserted         
   auto p{doubles.insert(13.8)}; // value not in set   
   std::cout << fmt::format("\n{} {} inserted\n", *(p.first),
      (p.second ? "was" : "was not"));
   std::cout << "doubles contains: ";
   std::ranges::copy(doubles, output);

   // insert 9.5 in doubles                          
   p = doubles.insert(9.5); // value already in set
   std::cout << fmt::format("\n{} {} inserted\n", *(p.first),
      (p.second ? "was" : "was not"));
   std::cout << "doubles contains: ";
   std::ranges::copy(doubles, output);
   std::cout << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_08.cpp
================================================
// fig13_08.cpp
// Standard library multimap class template.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <map> // multimap class-template definition

int main() {
   std::multimap<int, double> pairs{}; // create multimap
   std::cout << fmt::format("Number of 15 keys in pairs: {}\n",
      pairs.count(15));

   // insert two pairs
   pairs.insert(std::make_pair(15, 99.3));
   pairs.insert(std::make_pair(15, 2.7));
   std::cout << fmt::format("Number of 15 keys in pairs: {}\n\n",
      pairs.count(15));

   // insert five pairs
   pairs.insert({30, 111.11});
   pairs.insert({10, 22.22});
   pairs.insert({25, 33.333});
   pairs.insert({20, 9.345});
   pairs.insert({5, 77.54});

   std::cout << "Multimap pairs contains:\nKey\tValue\n";

   // walk through elements of pairs                    
   for (const auto& mapItem : pairs) {
      std::cout << fmt::format("{}\t{}\n", mapItem.first, mapItem.second);
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_09.cpp
================================================
// fig13_09.cpp
// Standard library class map class template.
#include <iostream>
#include <fmt/format.h> // C++20: This will be #include <format>
#include <map> // map class-template definition

int main() {
   // create a map; duplicate keys are ignored
   std::map<int, double> pairs{{15, 2.7}, {30, 111.11}, {5, 1010.1},
      {10, 22.22}, {25, 33.333}, {5, 77.54}, {20, 9.345}, {15, 99.3}};

   // walk through elements of pairs
   std::cout << "pairs contains:\nKey\tValue\n";
   for (const auto& pair : pairs) {
      std::cout << fmt::format("{}\t{}\n", pair.first, pair.second);
   }
   
   pairs[25] = 9999.99; // use subscripting to change value for key 25
   pairs[40] = 8765.43; // use subscripting to insert value for key 40

   // walk through elements of pairs
   std::cout << "\nAfter updates, pairs contains:\nKey\tValue\n";
   for (const auto& pair : pairs) {
      std::cout << fmt::format("{}\t{}\n", pair.first, pair.second);
   }
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_10.cpp
================================================
// fig13_10.cpp
// Standard library stack adaptor class.
#include <iostream>
#include <list> // list class-template definition
#include <ranges> 
#include <stack> // stack adaptor definition
#include <vector> // vector class-template definition

// pushElements generic lambda to push values onto a stack
auto pushElements = [](auto& stack) {
   for (auto i : std::views::iota(0, 10)) {
      stack.push(i); // push element onto stack                  
      std::cout << stack.top() << ' '; // view (and display) top element
   }
};

// popElements generic lambda to pop elements off a stack
auto popElements = [](auto& stack) {
   while (!stack.empty()) {
      std::cout << stack.top() << ' '; // view (and display) top element
      stack.pop(); // remove top element                           
   }
};

int main() {
   std::stack<int> dequeStack{}; // uses a deque by default
   std::stack<int, std::vector<int>> vectorStack{}; // use a vector 
   std::stack<int, std::list<int>> listStack{}; // use a list

   // push the values 0-9 onto each stack 
   std::cout << "Pushing onto dequeStack: ";
   pushElements(dequeStack);
   std::cout << "\nPushing onto vectorStack: ";
   pushElements(vectorStack);
   std::cout << "\nPushing onto listStack: ";
   pushElements(listStack);

   // display and remove elements from each stack
   std::cout << "\n\nPopping from dequeStack: ";
   popElements(dequeStack);
   std::cout << "\nPopping from vectorStack: ";
   popElements(vectorStack);
   std::cout << "\nPopping from listStack: ";
   popElements(listStack);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_11.cpp
================================================
// fig13_11.cpp
// Standard library queue adaptor class template.
#include <iostream>
#include <queue> // queue adaptor definition

int main() {
   std::queue<double> values{}; // queue with doubles

   // push elements onto queue values
   values.push(3.2);
   values.push(9.8);
   values.push(5.4);

   std::cout << "Popping from values: ";

   // pop elements from queue
   while (!values.empty()) {
      std::cout << values.front() << ' '; // view front element
      values.pop(); // remove element                     
   }

   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson13/fig13_12.cpp
================================================
// fig13_12.cpp
// Standard library priority_queue adaptor class.
#include <iostream>
#include <queue> // priority_queue adaptor definition

int main() {
   std::priority_queue<double> priorities; // create priority_queue

   // push elements onto priorities
   priorities.push(3.2);
   priorities.push(9.8);
   priorities.push(5.4);

   std::cout << "Popping from priorities: ";

   // pop element from priority_queue
   while (!priorities.empty()) {
      std::cout << priorities.top() << ' '; // view top element
      priorities.pop(); // remove top element             
   }

   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_01.cpp
================================================
// fig14_01.cpp
// Lambda expressions.
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>

int main() {
   std::array values{1, 2, 3, 4}; // initialize values
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "values contains: ";
   std::ranges::copy(values, output);

   // output each element multiplied by two
   std::cout << "\nDisplay each element multiplied by two: ";
   std::ranges::for_each(values, [](auto i) {std::cout << i * 2 << " ";});

   // add each element to sum
   int sum{0}; // initialize sum to zero
   std::ranges::for_each(values, [&sum](auto i) {sum += i;});
   std::cout << "\nSum of value's elements is: " << sum << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_02.cpp
================================================
// fig14_02.cpp
// Algorithms fill, fill_n, generate and generate_n.
#include <algorithm> // algorithm definitions
#include <array> // array class-template definition
#include <iostream>
#include <iterator> // ostream_iterator

// returns the next letter (starts with A)
char nextLetter() {
   static char letter{'A'};
   return letter++;
}

int main() {
   std::array<char, 10> chars{};
   std::ranges::fill(chars, '5'); // fill chars with 5s

   std::cout << "chars after filling with 5s: ";
   std::ostream_iterator<char> output{std::cout, " "};
   std::ranges::copy(chars, output);

   // fill first five elements of chars with 'A's
   std::ranges::fill_n(chars.begin(), 5, 'A');

   std::cout << "\nchars after filling five elements with 'A's: ";
   std::ranges::copy(chars, output);

   // generate values for all elements of chars with nextLetter
   std::ranges::generate(chars, nextLetter);

   std::cout << "\nchars after generating letters A-J: ";
   std::ranges::copy(chars, output);

   // generate values for first five elements of chars with nextLetter
   std::ranges::generate_n(chars.begin(), 5, nextLetter);

   std::cout << "\nchars after generating K-O into elements 0-4: ";
   std::ranges::copy(chars, output);

   // generate values for first three elements of chars with a lambda
   std::ranges::generate_n(chars.begin(), 3,
      []() { // lambda that takes no arguments
         static char letter{'A'};
         return letter++;
      }
   );

   std::cout << "\nchars after generating A-C into elements 0-2: ";
   std::ranges::copy(chars, output);
   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_03.cpp
================================================
// fig14_03.cpp
// Algorithms equal, mismatch and lexicographical_compare.
#include <algorithm> // algorithm definitions
#include <array> // array class-template definition
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iomanip>
#include <iostream>
#include <iterator> // ostream_iterator
#include <string>

int main() {
   std::array a1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   std::array a2{a1}; // initializes a2 with copy of a1
   std::array a3{1, 2, 3, 4, 1000, 6, 7, 8, 9, 10};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "a1 contains: ";
   std::ranges::copy(a1, output);
   std::cout << "\na2 contains: ";
   std::ranges::copy(a2, output);
   std::cout << "\na3 contains: ";
   std::ranges::copy(a3, output);

   // compare a1 and a2 for equality                        
   std::cout << fmt::format("\n\na1 is equal to a2: {}\n",
      std::ranges::equal(a1, a2));

   // compare a1 and a3 for equality                     
   std::cout << fmt::format("a1 is equal to a3: {}\n",
      std::ranges::equal(a1, a3));

   // check for mismatch between a1 and a3 
   auto location{std::ranges::mismatch(a1, a3)};
   std::cout << fmt::format("a1 and a3 mismatch at index {} ({} vs. {})\n",
      (location.in1 - a1.begin()), *location.in1, *location.in2);

   std::string s1{"HELLO"};
   std::string s2{"BYE BYE"};

   // perform lexicographical comparison of c1 and c2  
   std::cout << fmt::format("\"{}\" < \"{}\": {}\n", s1, s2,
      std::ranges::lexicographical_compare(s1, s2));
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_04.cpp
================================================
// fig14_04.cpp
// Algorithms remove, remove_if, remove_copy and remove_copy_if.
#include <algorithm> // algorithm definitions
#include <iostream>
#include <iterator> // ostream_iterator
#include <vector> 

int main() {
   std::vector init{10, 2, 15, 4, 10, 6};
   std::ostream_iterator<int> output{std::cout, " "};

   std::vector v1{init}; // initialize with copy of init
   std::cout << "v1: ";
   std::ranges::copy(v1, output);

   // remove all 10s from v1                                
   auto removed{std::ranges::remove(v1, 10)};
   v1.erase(removed.begin(), removed.end());
   std::cout << "\nv1 after removing 10s: ";
   std::ranges::copy(v1, output);

   std::vector v2{init}; // initialize with copy of init
   std::cout << "\n\nv2: ";
   std::ranges::copy(v2, output);

   // copy from v2 to c1, removing 10s in the process    
   std::vector<int> c1{};
   std::ranges::remove_copy(v2, std::back_inserter(c1), 10);
   std::cout << "\nc1 after copying v2 without 10s: ";
   std::ranges::copy(c1, output);

   std::vector v3{init}; // initialize with copy of init
   std::cout << "\n\nv3: ";
   std::ranges::copy(v3, output);

   // remove elements greater than 9 from v3                    
   auto greaterThan9{[](auto x) {return x > 9;}};
   auto removed2{std::ranges::remove_if(v3, greaterThan9)};
   v3.erase(removed2.begin(), removed2.end());
   std::cout << "\nv3 after removing elements greater than 9: ";
   std::ranges::copy(v3, output);

   std::vector v4{init}; // initialize with copy of init
   std::cout << "\n\nv4: ";
   std::ranges::copy(v4, output);

   // copy elements from v4 to c2, removing elements greater than 9
   std::vector<int> c2{}; 
   std::ranges::remove_copy_if(v4, std::back_inserter(c2), greaterThan9);
   std::cout << "\nc2 after copying v4 without elements greater than 9: ";
   std::ranges::copy(c2, output);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_05.cpp
================================================
// fig14_05.cpp
// Algorithms replace, replace_if, replace_copy and replace_copy_if.
#include <algorithm>
#include <array>
#include <iostream>
#include <iterator> // ostream_iterator

int main() {
   std::ostream_iterator<int> output{std::cout, " "};

   std::array a1{10, 2, 15, 4, 10, 6};
   std::cout << "a1: ";
   std::ranges::copy(a1, output);

   // replace all 10s in a1 with 100        
   std::ranges::replace(a1, 10, 100);
   std::cout << "\na1 after replacing 10s with 100s: ";
   std::ranges::copy(a1, output);

   std::array a2{10, 2, 15, 4, 10, 6};
   std::array<int, a2.size()> c1{};
   std::cout << "\n\na2: ";
   std::ranges::copy(a2, output);

   // copy from a2 to c1, replacing 10s with 100s              
   std::ranges::replace_copy(a2, c1.begin(), 10, 100);
   std::cout << "\nc1 after replacing a2's 10s with 100s: ";
   std::ranges::copy(c1, output);

   std::array a3{10, 2, 15, 4, 10, 6};
   std::cout << "\n\na3: ";
   std::ranges::copy(a3, output);

   // replace values greater than 9 in a3 with 100   
   auto greaterThan9{[](auto x) {return x > 9; }};
   std::ranges::replace_if(a3, greaterThan9, 100);
   std::cout << "\na3 after replacing values greater than 9 with 100s: ";
   std::ranges::copy(a3, output);

   std::array a4{10, 2, 15, 4, 10, 6};
   std::array<int, a4.size()> c2{};
   std::cout << "\n\na4: ";
   std::ranges::copy(a4, output);

   // copy a4 to c2, replacing elements greater than 9 with 100         
   std::ranges::replace_copy_if(a4, c2.begin(), greaterThan9, 100);
   std::cout << "\nc2 after replacing a4's values "
      << "greater than 9 with 100s: ";
   std::ranges::copy(c2, output);
   std::cout << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_06.cpp
================================================
// fig14_06.cpp
// Shuffling, counting, and minimum and maximum element algorithms.
#include <algorithm> 
#include <array>
#include <iostream>
#include <iterator> 
#include <random> 

int main() {
   std::array a1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "a1: ";
   std::ranges::copy(a1, output);

   // create random-number engine and use it to help shuffle a1
   std::default_random_engine randomEngine{std::random_device{}()};
   std::ranges::shuffle(a1, randomEngine); // randomly order elements
   std::cout << "\na1 shuffled: ";
   std::ranges::copy(a1, output);

   std::array a2{100, 2, 8, 1, 50, 3, 8, 8, 9, 10};
   std::cout << "\n\na2: ";
   std::ranges::copy(a2, output);

   // count number of elements in a2 with value 8  
   auto result1{std::ranges::count(a2, 8)};
   std::cout << "\nCount of 8s in a2: " << result1;

   // count number of elements in a2 that are greater than 9
   auto result2{std::ranges::count_if(a2, [](auto x){return x > 9;})};
   std::cout << "\nCount of a2 elements greater than 9: " << result2;

   // locate minimum element in a2
   if (auto result{std::ranges::min_element(a2)}; result != a2.end()) {
      std::cout << "\n\na2 minimum element: " << *result;
   }

   // locate maximum element in a2
   if (auto result{std::ranges::max_element(a2)}; result != a2.end()) {
      std::cout << "\na2 maximum element: " << *result;
   }

   // locate minimum and maximum elements in a2
   auto [min, max] {std::ranges::minmax_element(a2)};
   std::cout << "\na2 minimum and maximum elements: "
      << *min << " and " << *max;

   // calculate cube of each element in a1; place results in cubes
   std::array<int, a1.size()> cubes{};
   std::ranges::transform(a1, cubes.begin(),
      [](auto x) {return x * x * x;});
   std::cout << "\n\na1 values cubed: ";
   std::ranges::copy(cubes, output);
   std::cout << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_07.cpp
================================================
// fig14_07.cpp
// Standard library search and sort algorithms.
#include <algorithm> // algorithm definitions
#include <array> // array class-template definition
#include <iostream>
#include <iterator> 

int main() {
   std::array values{10, 2, 17, 5, 16, 8, 13, 11, 20, 7};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "values contains: ";
   std::ranges::copy(values, output); // display output vector

   // locate first occurrence of 16 in values          
   if (auto loc1{std::ranges::find(values, 16)}; loc1 != values.cend()) {
      std::cout << "\n\nFound 16 at index: " << (loc1 - values.cbegin());
   }
   else { // 16 not found
      std::cout << "\n\n16 not found";
   }

   // locate first occurrence of 100 in values  
   if (auto loc2{std::ranges::find(values, 100)}; loc2 != values.cend()) {
      std::cout << "\nFound 100 at index: " << (loc2 - values.cbegin());
   }
   else { // 100 not found 
      std::cout << "\n100 not found";
   }

   // create variable to store lambda for reuse later
   auto isGreaterThan10{[](auto x) {return x > 10;}};

   // locate first occurrence of value greater than 10 in values
   auto loc3{std::ranges::find_if(values, isGreaterThan10)};

   if (loc3 != values.cend()) { // found value greater than 10
      std::cout << "\n\nFirst value greater than 10: " << *loc3
         << "\nfound at index: " << (loc3 - values.cbegin());
   }
   else { // value greater than 10 not found
      std::cout << "\n\nNo values greater than 10 were found";
   }

   // sort elements of values      
   std::ranges::sort(values);
   std::cout << "\n\nvalues after sort: ";
   std::ranges::copy(values, output);

   // use binary_search to check whether 13 exists in values
   if (std::ranges::binary_search(values, 13)) {
      std::cout << "\n\n13 was found in values";
   }
   else {
      std::cout << "\n\n13 was not found in values";
   }

   // use binary_search to check whether 100 exists in values
   if (std::ranges::binary_search(values, 100)) {
      std::cout << "\n100 was found in values";
   }
   else {
      std::cout << "\n100 was not found in values";
   }

   // determine whether all of values' elements are greater than 10
   if (std::ranges::all_of(values, isGreaterThan10)) {
      std::cout << "\n\nAll values elements are greater than 10";
   }
   else {
      std::cout << "\n\nSome values elements are not greater than 10";
   }

   // determine whether any of values' elements are greater than 10
   if (std::ranges::any_of(values, isGreaterThan10)) {
      std::cout << "\n\nSome values elements are greater than 10";
   }
   else {
      std::cout << "\n\nNo values elements are greater than 10";
   }

   // determine whether none of values' elements are greater than 10
   if (std::ranges::none_of(values, isGreaterThan10)) {
      std::cout << "\n\nNo values elements are greater than 10";
   }
   else {
      std::cout << "\n\nSome values elements are greater than 10";
   }

   // locate first occurrence of value that is not greater than 10
   auto loc4{std::ranges::find_if_not(values, isGreaterThan10)};

   if (loc4 != values.cend()) { // found a value less than or equal to 10
      std::cout << "\n\nFirst value not greater than 10: " << *loc4
         << "\nfound at index: " << (loc4 - values.cbegin());
   }
   else { // no values less than or equal to 10 were found
      std::cout << "\n\nOnly values greater than 10 were found";
   }

   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_08.cpp
================================================
// fig14_08.cpp
// Algorithms swap, iter_swap and swap_ranges.
#include <algorithm> 
#include <array>
#include <iostream>
#include <iterator> 

int main() {
   std::array values{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "values contains: ";
   std::ranges::copy(values, output);

   std::swap(values[0], values[1]); // swap elements at index 0 and 1

   std::cout << "\nafter std::swap of values[0] and values[1]: ";
   std::ranges::copy(values, output);

   // use iterators to swap elements at locations 0 and 1 
   std::iter_swap(values.begin(), values.begin() + 1);
   std::cout << "\nafter std::iter_swap of values[0] and values[1]: ";
   std::ranges::copy(values, output);

   // swap values and values2  
   std::array values2{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   std::cout << "\n\nBefore swap_ranges\nvalues contains: ";
   std::ranges::copy(values, output);
   std::cout << "\nvalues2 contains: ";
   std::ranges::copy(values2, output);
   std::ranges::swap_ranges(values, values2);
   std::cout << "\n\nAfter swap_ranges\nvalues contains: ";
   std::ranges::copy(values, output);
   std::cout << "\nvalues2 contains: ";
   std::ranges::copy(values2, output);

   // swap first five elements of values and values2
   std::ranges::swap_ranges(values.begin(), values.begin() + 5,
      values2.begin(), values2.begin() + 5);

   std::cout << "\n\nAfter swap_ranges for 5 elements"
      << "\nvalues contains: ";
   std::ranges::copy(values, output);
   std::cout << "\nvalues2 contains: ";
   std::ranges::copy(values2, output);
   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_09.cpp
================================================
// fig14_09.cpp
// Algorithms copy_backward, merge, unique, reverse, copy_if and copy_n.
#include <algorithm> 
#include <array>  
#include <iostream>
#include <iterator> 
#include <vector>

int main() {
   std::array a1{1, 3, 5, 7, 9};
   std::array a2{2, 4, 5, 7, 9};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "array a1 contains: ";
   std::ranges::copy(a1, output); // display a1
   std::cout << "\narray a2 contains: ";
   std::ranges::copy(a2, output); // display a2

   // place elements of a1 into results in reverse order  
   std::array<int, a1.size()> results{};
   std::ranges::copy_backward(a1, results.end());
   std::cout << "\n\nAfter copy_backward, results contains: ";
   std::ranges::copy(results, output);

   // merge elements of a1 and a2 into results2 in sorted order
   std::array<int, a1.size() + a2.size()> results2{};
   std::ranges::merge(a1, a2, results2.begin());

   std::cout << "\n\nAfter merge of a1 and a2, results2 contains: ";
   std::ranges::copy(results2, output);

   // eliminate duplicate values from v 
   std::vector v(results2.begin(), results2.end());
   auto [first, last] {std::ranges::unique(v)};
   v.erase(first, last); // remove elements that no longer contain values

   std::cout << "\n\nAfter unique v contains: ";
   std::ranges::copy(v, output);

   std::cout << "\n\nAfter reverse, a1 contains: ";
   std::ranges::reverse(a1); // reverse elements of a1
   std::ranges::copy(a1, output);

   // copy odd elements of a2 into v2
   std::vector<int> v2{};
   std::cout << "\n\nAfter copy_if, v2 contains: ";
   std::ranges::copy_if(a2, std::back_inserter(v2),
      [](auto x) {return x % 2 == 0; });
   std::ranges::copy(v2, output);

   // copy three elements of a2 into v3
   std::vector<int> v3{};
   std::cout << "\n\nAfter copy_n, v3 contains: ";
   std::ranges::copy_n(a2.begin(), 3, std::back_inserter(v3));
   std::ranges::copy(v3, output);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_10.cpp
================================================
// fig14_10.cpp
// Algorithms inplace_merge, unique_copy and reverse_copy.
#include <algorithm>
#include <array> 
#include <iostream>
#include <iterator> 
#include <vector> 

int main() {
   std::array a1{1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "array a1 contains: ";
   std::ranges::copy(a1, output);

   // merge first half of a1 with second half of a1 such that
   // a1 contains sorted set of elements after merge         
   std::ranges::inplace_merge(a1, a1.begin() + 5);
   std::cout << "\nAfter inplace_merge, a1 contains: ";
   std::ranges::copy(a1, output);

   // copy only unique elements of a1 into results1                 
   std::vector<int> results1{};
   std::ranges::unique_copy(a1, std::back_inserter(results1));
   std::cout << "\nAfter unique_copy, results1 contains: ";
   std::ranges::copy(results1, output);

   // copy elements of a1 into results2 in reverse order             
   std::vector<int> results2{};
   std::ranges::reverse_copy(a1, std::back_inserter(results2));
   std::cout << "\nAfter reverse_copy, results2 contains: ";
   std::ranges::copy(results2, output);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_11.cpp
================================================
// fig14_11.cpp
// Algorithms includes, set_difference, set_intersection, 
// set_symmetric_difference and set_union.
#include <array>
#include <algorithm>
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <iterator> 
#include <vector> 

int main() {
   std::array a1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   std::array a2{4, 5, 6, 7, 8};
   std::array a3{4, 5, 6, 11, 15};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "a1 contains: ";
   std::ranges::copy(a1, output); // display array a1
   std::cout << "\na2 contains: ";
   std::ranges::copy(a2, output); // display array a2
   std::cout << "\na3 contains: ";
   std::ranges::copy(a3, output); // display array a3

   // determine whether a2 is completely contained in a1
   std::cout << fmt::format("\n\na1 {} a2",
      std::ranges::includes(a1, a2) ? "includes" : "does not include");

   // determine whether a3 is completely contained in a1
   std::cout << fmt::format("\n\na1 {} a3",
      std::ranges::includes(a1, a3) ? "includes" : "does not include");

   // determine elements of a1 not in a2 
   std::vector<int> difference{};
   std::ranges::set_difference(a1, a2, std::back_inserter(difference));
   std::cout << "\n\nset_difference of a1 and a2 is: ";
   std::ranges::copy(difference, output);

   // determine elements in both a1 and a2                 
   std::vector<int> intersection{};
   std::ranges::set_intersection(a1, a2,
      std::back_inserter(intersection));
   std::cout << "\n\nset_intersection of a1 and a2 is: ";
   std::ranges::copy(intersection, output);

   // determine elements of a1 that are not in a3 and              
   // elements of a3 that are not in a1                            
   std::vector<int> symmetricDifference{};
   std::ranges::set_symmetric_difference(a1, a3,
      std::back_inserter(symmetricDifference));
   std::cout << "\n\nset_symmetric_difference of a1 and a3 is: ";
   std::ranges::copy(symmetricDifference, output);

   // determine elements that are in either or both sets
   std::vector<int> unionSet{};
   std::ranges::set_union(a1, a3, std::back_inserter(unionSet));
   std::cout << "\n\nset_union of a1 and a3 is: ";
   std::ranges::copy(unionSet, output);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_12.cpp
================================================
// fig14_12.cpp
// Algorithms lower_bound, upper_bound and 
// equal_range for a sorted sequence of values.
#include <algorithm> 
#include <array> 
#include <iostream>
#include <iterator> 

int main() {
   std::array values{2, 2, 4, 4, 4, 6, 6, 6, 6, 8};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "values contains: ";
   std::ranges::copy(values, output);

   // determine lower-bound insertion point for 6 in values 
   auto lower{std::ranges::lower_bound(values, 6)};
   std::cout << "\n\nLower bound of 6 is index: "
      << (lower - values.begin());

   // determine upper-bound insertion point for 6 in values 
   auto upper{std::ranges::upper_bound(values, 6)};
   std::cout << "\nUpper bound of 6 is index: "
      << (upper - values.begin());

   // use equal_range to determine the lower and upper bound of 6
   auto [first, last]{std::ranges::equal_range(values, 6)};
   std::cout << "\nUsing equal_range:\n   Lower bound of 6 is index: "
      << (first - values.begin());
   std::cout << "\n   Upper bound of 6 is index: "
      << (last - values.begin());

   // determine lower-bound insertion point for 3 in values
   std::cout << "\n\nUse lower_bound to locate the first point "
      << "at which 3 can be inserted in order";
   lower = std::ranges::lower_bound(values, 3);
   std::cout << "\n   Lower bound of 3 is index: "
      << (lower - values.begin());

   // determine upper-bound insertion point for 7 in values
   std::cout << "\n\nUse upper_bound to locate the last point "
      << "at which 7 can be inserted in order";
   upper = std::ranges::upper_bound(values, 7);
   std::cout << "\n   Upper bound of 7 is index: "
      << (upper - values.begin()) << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_13.cpp
================================================
// fig14_13.cpp
// Algorithms min, max and minmax.
#include <array>
#include <algorithm>
#include <iostream>

int main() {
   std::cout << "Minimum of 12 and 7 is: " << std::min(12, 7)
      << "\nMaximum of 12 and 7 is: " << std::max(12, 7)
      << "\nMinimum of 'G' and 'Z' is: '" << std::min('G', 'Z') << "'"
      << "\nMaximum of 'G' and 'Z' is: '" << std::max('G', 'Z') << "'"
      << "\nMinimum of 'z' and 'Z' is: '" << std::min('z', 'Z') << "'";

   // determine which argument is the min and which is the max
   auto [smaller, larger]{std::minmax(12, 7)};
   std::cout << "\n\nMinimum of 12 and 7 is: " << smaller
      << "\nMaximum of 12 and 7 is: " << larger;

   std::array items{3, 100, 52, 77, 22, 31, 1, 98, 13, 40};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "\n\nitems: ";
   std::ranges::copy(items, output);

   auto [smallest, largest]{std::ranges::minmax(items)};
   std::cout << "\nMinimum value in items: " << smallest
      << "\nMaximum value in items is: " << largest << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_14.cpp
================================================
// fig14_14.cpp
// Demonstrating algorithms gcd, lcm, iota, reduce and partial_sum.
#include <array> 
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric> 

int main() {
   std::ostream_iterator<int> output{std::cout, " "};

   // calculate the greatest common divisor of two integers
   std::cout << "std::gcd(75, 20): " << std::gcd(75, 20)
      << "\nstd::gcd(75, 13): " << std::gcd(75, 13);

   // calculate the least common multiple of two integers
   std::cout << "\n\nstd::lcm(3, 5): " << std::lcm(3, 5)
      << "\nstd::lcm(12, 9): " << std::lcm(12, 9);

   // fill an array with integers using the std::iota algorithm
   std::array<int, 5> ints{};
   std::iota(ints.begin(), ints.end(), 1);
   std::cout << "\n\nints: ";
   std::ranges::copy(ints, output);

   // reduce elements of a container to a single value
   std::cout << "\n\nsum of ints: "
      << std::reduce(ints.begin(), ints.end())
      << "\nproduct of ints: "
      << std::reduce(ints.begin(), ints.end(), 1, std::multiplies{});

   // calculate the partial sums of ints' elements 
   std::cout << "\n\nints: ";
   std::ranges::copy(ints, output);
   std::cout << "\n\npartial_sum of ints using std::plus by default: ";
   std::partial_sum(ints.begin(), ints.end(), output);
   std::cout << "\npartial_sum of ints using std::multiplies: ";
   std::partial_sum(ints.begin(), ints.end(), output, std::multiplies{});
   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_15.cpp
================================================
// fig14_15.cpp
// Algorithms make_heap, sort_heap, push_heap and pop_heap.
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <iterator> 

int main() {
   std::ostream_iterator<int> output{std::cout, " "};

   std::array heapArray{3, 100, 52, 77, 22, 31, 1, 98, 13, 40};
   std::cout << "heapArray before make_heap:\n";
   std::ranges::copy(heapArray, output);

   std::ranges::make_heap(heapArray); // create heap from heapArray
   std::cout << "\nheapArray after make_heap:\n";
   std::ranges::copy(heapArray, output);

   std::ranges::sort_heap(heapArray); // sort elements with sort_heap
   std::cout << "\nheapArray after sort_heap:\n";
   std::ranges::copy(heapArray, output);

   // lambda to add an int to a heap
   auto push{
      [&](std::vector<int>& heap, int value) {
         std::cout << "\n\npushing " << value << " onto heap";
         heap.push_back(value); // add value to the heap
         std::ranges::push_heap(heap); // insert last element into heap
         std::cout << "\nheap: ";
         std::ranges::copy(heap, output);
      }
   };

   // lambda to remove an item from the heap
   auto pop{
      [&](std::vector<int>& heap) {
         std::ranges::pop_heap(heap); // remove max item from heap
         std::cout << "\n\npopping highest priority item: " << heap.back();
         heap.pop_back(); // remove vector's last element
         std::cout << "\nheap: ";
         std::ranges::copy(heap, output);
      }
   };

   std::vector<int> heapVector{};

   // place five integers into heapVector, maintaining it as a heap
   for (auto value : {3, 52, 100}) {
      push(heapVector, value);
   }

   pop(heapVector); // remove max item 
   push(heapVector, 22); // add new item to heap

   pop(heapVector); // remove max item 
   push(heapVector, 77); // add new item to heap

   pop(heapVector); // remove max item 
   pop(heapVector); // remove max item 
   pop(heapVector); // remove max item 
   std::cout << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_16.cpp
================================================
// fig14_16.cpp
// Demonstrating function objects.
#include <array> 
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric> 

// binary function returns the sum of its first argument total 
// and the square of its second argument value
int sumSquares(int total, int value) {
   return total + value * value;
}

// class SumSquaresClass defines overloaded operator()
// that returns the sum of its first argument total 
// and the square of its second argument value               
class SumSquaresClass {
public:
   // add square of value to total and return result           
   int operator()(int total, int value) {
      return total + value * value;
   }
};

int main() {
   std::array integers{1, 2, 3, 4};
   std::ostream_iterator<int> output{std::cout, " "};

   std::cout << "array integers contains: ";
   std::ranges::copy(integers, output);

   // calculate sum of squares of elements of array integers
   // using binary function sumSquares                      
   int result{std::accumulate(integers.cbegin(), integers.cend(),
      0, sumSquares)};

   std::cout << "\n\nSum of squares\n"
      << "via binary function sumSquares: " << result;

   // calculate sum of squares of elements of array integers
   // using binary function object                           
   result = std::accumulate(integers.cbegin(), integers.cend(),
      0, SumSquaresClass{});

   std::cout << "\nvia a SumSquaresClass function object: " << result;

   // calculate sum of squares array
   result = std::accumulate(integers.cbegin(), integers.cend(),
      0, [](auto total, auto value) {return total + value * value;});

   std::cout << "\nvia a lambda: " << result << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_17.cpp
================================================
// fig14_17.cpp
// Demonstrating projections with C++20 range algorithms.
#include <array> 
#include <algorithm>
#include <fmt/format.h>
#include <iostream>
#include <iterator>
#include <string> 
#include <string_view> 

class Employee {
public:
   Employee(std::string_view first, std::string_view last, int salary)
      : m_first{first}, m_last{last}, m_salary{salary} {}
   std::string getFirst() const {return m_first;}
   std::string getLast() const {return m_last;}
   int getSalary() const {return m_salary;}
private:
   std::string m_first;
   std::string m_last;
   int m_salary;
};

// operator<< for an Employee
std::ostream& operator<<(std::ostream& out, const Employee& e) {
   out << fmt::format("{:10}{:10}{}", 
      e.getLast(), e.getFirst(), e.getSalary());
   return out;
}

int main() {
   std::array employees{
      Employee{"Jason", "Red", 5000},
      Employee{"Ashley", "Green", 7600},
      Employee{"Matthew", "Indigo", 3587}
   };

   std::ostream_iterator<Employee> output{std::cout, "\n"};

   std::cout << "Employees:\n";
   std::ranges::copy(employees, output);

   // sort Employees by salary; {} indicates that the algorithm should
   // use its default comparison function
   std::ranges::sort(employees, {},
      [](const auto& e) {return e.getSalary(); });
   std::cout << "\nEmployees sorted in ascending order by salary:\n";
   std::ranges::copy(employees, output);

   // sort Employees by salary in descending order
   std::ranges::sort(employees, std::ranges::greater{},
      &Employee::getSalary);
   std::cout << "\nEmployees sorted in descending order by salary:\n";
   std::ranges::copy(employees, output);
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson14/fig14_18.cpp
================================================
// fig14_18.cpp
// Working with C++20 std::views.
#include <algorithm>
#include <iostream>
#include <iterator>
#include <map> 
#include <ranges> 
#include <string> 
#include <vector> 

int main() {
   std::ostream_iterator<int> output{std::cout, " "};
   auto isEven{[](int x) {return x % 2 == 0;}}; // true if x is even

   // infinite view of even integers starting at 0
   auto evens{std::views::iota(0) | std::views::filter(isEven)};

   std::cout << "First five even ints: ";
   std::ranges::copy(evens | std::views::take(5), output);

   std::cout << "\nEven ints less than 12: ";
   auto lessThan12{
      evens | std::views::take_while([](int x) {return x < 12;})};
   std::ranges::copy(lessThan12, output);

   std::cout << "\nEven ints less than 12 reversed: ";
   std::ranges::copy(lessThan12 | std::views::reverse, output);

   std::cout << "\nSquares of even ints less than 12 reversed: ";
   std::ranges::copy(
      lessThan12
         | std::views::reverse
         | std::views::transform([](int x) {return x * x;}), 
      output);

   std::cout << "\nSkip 1000 even ints, then take five: ";
   std::ranges::copy(
      evens | std::views::drop(1000) | std::views::take(5),
      output);

   std::cout << "\nFirst five even ints greater than 1000: ";
   std::ranges::copy(
      evens
         | std::views::drop_while([](int x) {return x <= 1000;})
         | std::views::take(5),
      output);

   // allow std::string object literals
   using namespace std::string_literals;

   std::map<std::string, int> romanNumerals{
      {"I"s, 1}, {"II"s, 2}, {"III"s, 3}, {"IV"s, 4}, {"V"s, 5}};
   auto displayPair{[](const auto& p) {
         std::cout << p.first << " = " << p.second << "\n"; }};
   std::cout << "\n\nromanNumerals:\n";
   std::ranges::for_each(romanNumerals, displayPair);

   std::ostream_iterator<std::string> stringOutput{std::cout, " "};
   std::cout << "\nKeys in romanNumerals: ";
   std::ranges::copy(romanNumerals | std::views::keys, stringOutput);

   std::cout << "\nValues in romanNumerals: ";
   std::ranges::copy(romanNumerals | std::views::values, output);

   std::cout << "\nKeys in romanNumerals via std::views::elements: ";
   std::ranges::copy(
      romanNumerals | std::views::elements<0>, stringOutput);

   std::cout << "\nvalues in romanNumerals via std::views::elements: ";
   std::ranges::copy(romanNumerals | std::views::elements<1>, output);
   std::cout << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_01-02/Stack.h
================================================
// Fig. 15.1: Stack.h
// Stack class template.
#pragma once
#include <deque>

template<typename T>
class Stack {
public:
   // return the top element of Stack
   const T& top() const {return stack.front();}

   // push an element onto Stack
   void push(const T& pushValue) {stack.push_front(pushValue);}

   // pop an element from Stack
   void pop() {stack.pop_front();}

   // determine whether Stack is empty
   bool isEmpty() const {return stack.empty();}

   // return size of Stack
   size_t size() const {return stack.size();}
private:
   std::deque<T> stack{}; // internal representation of Stack
}; 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_01-02/fig15_02.cpp
================================================
// fig15_02.cpp
// Stack class template test program.
#include <iostream>
#include "Stack.h" // Stack class template definition

int main() {
   Stack<double> doubleStack{}; // create a Stack of double
   constexpr size_t doubleStackSize{5}; // stack size
   double doubleValue{1.1}; // first value to push

   std::cout << "Pushing elements onto doubleStack\n";

   // push 5 doubles onto doubleStack
   for (size_t i{0}; i < doubleStackSize; ++i) {
      doubleStack.push(doubleValue);
      std::cout << doubleValue << ' ';
      doubleValue += 1.1;
   } 

   std::cout << "\n\nPopping elements from doubleStack\n";

   // pop elements from doubleStack
   while (!doubleStack.isEmpty()) { // loop while Stack is not empty
      std::cout << doubleStack.top() << ' '; // display top element
      doubleStack.pop(); // remove top element
   } 

   std::cout << "\nStack is empty, cannot pop.\n";

   Stack<int> intStack{}; // create a Stack of int
   constexpr size_t intStackSize{10}; // stack size
   int intValue{1}; // first value to push

   std::cout << "\nPushing elements onto intStack\n";

   // push 10 integers onto intStack
   for (size_t i{0}; i < intStackSize; ++i) {
      intStack.push(intValue);
      std::cout << intValue++ << ' ';
   } 

   std::cout << "\n\nPopping elements from intStack\n";

   // pop elements from intStack
   while (!intStack.isEmpty()) { // loop while Stack is not empty
      std::cout << intStack.top() << ' '; // display top element
      intStack.pop(); // remove top element
   } 

   std::cout << "\nStack is empty, cannot pop.\n";
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_03.cpp
================================================
// fig15_03.cpp
// Abbreviated function template.
#include <array>
#include <iostream>
#include <string>
#include <vector>

// abbreviated function template printContainer displays a 
// container's elements separated by spaces.
void printContainer(const auto& items) {
   for (const auto& item : items) {
      std::cout << item << " ";
   }
}

int main() {
   using namespace std::string_literals; // for string object literals

   std::array ints{1, 2, 3, 4, 5};
   std::vector strings{"red"s, "green"s, "blue"s};

   std::cout << "ints: ";
   printContainer(ints);
   std::cout << "\nstrings: ";
   printContainer(strings);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_04.cpp
================================================
// fig15_04.cpp
// Simple unconstrained multiply function template.
#include <iostream>

template<typename T>
T multiply(T first, T second) {return first * second;}

int main() {
   std::cout << "Product of 5 and 3: " << multiply(5, 3)
      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0) << "\n";

   // std::string s1{"hi"};
   // std::string s2{"bye"};
   // auto result{multiply(s1, s2)}; // string does not have * operator
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_05.cpp
================================================
// fig15_05.cpp
// Constrained multiply function template that allows 
// only integers and floating-point values.
#include <concepts>
#include <iostream>

template<typename T>
   requires std::integral<T> || std::floating_point<T>
T multiply(T first, T second) {return first * second;}

int main() {
   std::cout << "Product of 5 and 3: " << multiply(5, 3)
      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0) << "\n";

   std::string s1{"hi"};
   std::string s2{"bye"};
   auto result{multiply(s1, s2)};
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_06.cpp
================================================
// fig15_06.cpp
// Using type traits to test whether types are 
// integral types, floating-point types or arithmetic types.
#include <fmt/format.h>
#include <iostream>
#include <string>
#include <type_traits> 

int main() {
   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
      "CHECK WITH TYPE TRAITS WHETHER TYPES ARE INTEGRAL",
      "std::is_integral<int>::value: ", std::is_integral<int>::value,
      "std::is_integral_v<int>: ", std::is_integral_v<int>,
      "std::is_integral_v<long>: ", std::is_integral_v<long>,
      "std::is_integral_v<float>: ", std::is_integral_v<float>,
      "std::is_integral_v<std::string>: ",
      std::is_integral_v<std::string>);

   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
      "CHECK WITH TYPE TRAITS WHETHER TYPES ARE FLOATING POINT",
      "std::is_floating_point<float>::value: ",
      std::is_floating_point<float>::value,
      "std::is_floating_point_v<float>: ",
      std::is_floating_point_v<float>,
      "std::is_floating_point_v<double>: ",
      std::is_floating_point_v<double>,
      "std::is_floating_point_v<int>: ",
      std::is_floating_point_v<int>,
      "std::is_floating_point_v<std::string>: ",
      std::is_floating_point_v<std::string>);

   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n{}{}\n",
      "CHECK WITH TYPE TRAITS WHETHER TYPES CAN BE USED IN ARITHMETIC",
      "std::is_arithmetic<int>::value: ", std::is_arithmetic<int>::value,
      "std::is_arithmetic_v<int>: ", std::is_arithmetic_v<int>,
      "std::is_arithmetic_v<double>: ", std::is_arithmetic_v<double>,
      "std::is_arithmetic_v<std::string>: ",
      std::is_arithmetic_v<std::string>);
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_07.cpp
================================================
// fig15_07.cpp
// Constrained multiply abbreviated function template.
#include <concepts>
#include <iostream>

// Numeric concept aggregates std::integral and std::floating_point
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// abbreviated function template with constrained auto
auto multiply(Numeric auto first, Numeric auto second) {
   return first * second;
}

int main() {
   std::cout << "Product of 5 and 3: " << multiply(5, 3)
      << "\nProduct of 7.25 and 2.0: " << multiply(7.25, 2.0)
      << "\nProduct of 5 and 7.25: " << multiply(5, 7.25) << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_08.cpp
================================================
// fig15_08.cpp
// Using concepts to select overloads.
#include <array>
#include <iostream>
#include <iterator>
#include <list>

// calculate the distance (number of items) between two iterators 
// using input iterators; requires incrementing between iterators, 
// so this is an O(n) operation
template <std::input_iterator Iterator>
auto customDistance(Iterator begin, Iterator end) {
   std::cout << "Called customDistance with input iterators\n";
   std::ptrdiff_t count{0};

   // increment from begin to end and count number of iterations
   for (auto& iter{begin}; iter != end; ++iter) {
      ++count;
   }

   return count;
}

// calculate the distance (number of items) between two iterators 
// using random-access iterators and an O(1) operation
template <std::random_access_iterator Iterator>
auto customDistance(Iterator begin, Iterator end) {
   std::cout << "Called customDistance with random-access iterators\n";
   return end - begin; // returns a std::ptrdiff_t value
}

int main() {
   std::array ints1{1, 2, 3, 4, 5}; // has random-access iterators
   std::list ints2{1, 2, 3}; // has bidirectional iterators

   auto result1{customDistance(ints1.begin(), ints1.end())};
   std::cout << "ints1 number of elements: " << result1 << "\n";
   auto result2{customDistance(ints2.begin(), ints2.end())};
   std::cout << "ints2 number of elements: " << result2 << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_09.cpp
================================================
// fig15_09.cpp
// Testing custom concepts with static_assert.
#include <iostream>
#include <string>

template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<typename T>     
auto multiply(T a, T b) {      
   static_assert(Numeric<T>);      
   return a * b;     
} 

int main() {
   using namespace std::string_literals;
   multiply(2, 5); // OK: int is Numeric
   multiply(2.5, 5.5); // OK: double is Numeric
   multiply("2"s, "5"s); // error: string is not Numeric
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_10.cpp
================================================
// fig15_10.cpp
// A custom algorithm to calculate the average of 
// a numeric input range's elements.
#include <algorithm>
#include <array>
#include <concepts>
#include <iostream>
#include <iterator>
#include <list>
#include <ranges>
#include <vector>

// concept for an input range containing integer or floating-point values
template<typename T>
concept NumericInputRange = std::ranges::input_range<T> &&
   (std::integral<typename T::value_type> ||
    std::floating_point<typename T::value_type>);

// calculate the average of a NumericInputRange's elements
auto average(NumericInputRange auto const& range) {
   long double total{0};

   for (auto i{range.begin()}; i != range.end(); ++i) {
      total += *i; // dereference iterator and add value to total  
   }

   // divide total by the number of elements in range
   return total / std::ranges::distance(range);
}

int main() {
   std::ostream_iterator<int> outputInt(std::cout, " ");
   const std::array ints{1, 2, 3, 4, 5};
   std::cout << "array ints: ";
   std::ranges::copy(ints, outputInt);
   std::cout << "\naverage of ints: " << average(ints);

   std::ostream_iterator<double> outputDouble(std::cout, " ");
   const std::vector doubles{10.1, 20.2, 35.3};
   std::cout << "\n\nvector doubles: ";
   std::ranges::copy(doubles, outputDouble);
   std::cout << "\naverage of doubles: " << average(doubles);

   std::ostream_iterator<long double> outputLongDouble(std::cout, " ");
   const std::list longDoubles{10.1L, 20.2L, 35.3L};
   std::cout << "\n\nlist longDoubles: ";
   std::ranges::copy(longDoubles, outputLongDouble);
   std::cout << "\naverage of longDoubles: " << average(longDoubles)
      << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_11-12/MyArray.h
================================================
// Fig. 15.11: MyArray.h
// Class template MyArray with custom iterators implemented 
// by class templates ConstIterator and Iterator
#pragma once
#include <algorithm>
#include <compare>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <stdexcept>
#include <utility>

// class template ConstIterator for a MyArray const iterator 
template <typename T>
class ConstIterator {
public:
   // public iterator nested type names
   using iterator_category = std::bidirectional_iterator_tag;
   using difference_type = std::ptrdiff_t; 
   using value_type = T;
   using pointer = const value_type*;
   using reference = const value_type&;

   // default constructor
   ConstIterator() = default;

   // initialize a ConstIterator with a pointer into a MyArray
   ConstIterator(pointer p) : m_ptr{p} {}
   
   // OPERATIONS ALL ITERATORS MUST PROVIDE
   // increment the iterator to the next element and 
   // return a reference to the iterator
   ConstIterator& operator++() noexcept {
      ++m_ptr;
      return *this;
   }

   // increment the iterator to the next element and 
   // return the iterator before the increment
   ConstIterator operator++(int) noexcept {
      ConstIterator temp{*this};
      ++(*this);
      return temp; 
   }

   // OPERATIONS INPUT ITERATORS MUST PROVIDE
   // return a const reference to the element m_ptr points to
   reference operator*() const noexcept {return *m_ptr;}

   // return a const pointer to the element m_ptr points to
   pointer operator->() const noexcept {return m_ptr;}

   // <=> operator automatically supports equality/relational operators.
   // Only == and != are needed for bidirectional iterators.
   // This implementation would support the <, <=, > and >= required 
   // by random-access iterators.
   auto operator<=>(const ConstIterator& other) const = default;

   // OPERATIONS BIDIRECTIONAL ITERATORS MUST PROVIDE
   // decrement the iterator to the previous element and 
   // return a reference to the iterator
   ConstIterator& operator--() noexcept {
      --m_ptr;
      return *this;
   }

   // decrement the iterator to the previous element and 
   // return the iterator before the decrement
   ConstIterator operator--(int) noexcept {
      ConstIterator temp{*this};
      --(*this);
      return temp; 
   }
private:
   pointer m_ptr{nullptr};
};

// class template Iterator for a MyArray non-const iterator;
// redefines several inherited operators to return non-const results
template <typename T>
class Iterator : public ConstIterator<T> {
public:
   // public iterator nested type names
   using iterator_category = std::bidirectional_iterator_tag;
   using difference_type = std::ptrdiff_t; 
   using value_type = T;
   using pointer = value_type*;
   using reference = value_type&;

   // inherit ConstIterator constructors
   using ConstIterator<T>::ConstIterator;

   // OPERATIONS ALL ITERATORS MUST PROVIDE
   // increment the iterator to the next element and 
   // return a reference to the iterator
   Iterator& operator++() noexcept {
      ConstIterator<T>::operator++(); // call base-class version
      return *this;
   }

   // increment the iterator to the next element and 
   // return the iterator before the increment
   Iterator operator++(int) noexcept {
      Iterator temp{*this};
      ConstIterator<T>::operator++(); // call base-class version
      return temp;
   }

   // OPERATIONS INPUT ITERATORS MUST PROVIDE
   // return a reference to the element m_ptr points to; this
   // operator returns a non-const reference for output iterator support
   reference operator*() const noexcept {
      return const_cast<reference>(ConstIterator<T>::operator*());
   }

   // return a pointer to the element m_ptr points to
   pointer operator->() const noexcept {
      return const_cast<pointer>(ConstIterator<T>::operator->());
   }

   // OPERATIONS BIDIRECTIONAL ITERATORS MUST PROVIDE
   // decrement the iterator to the previous element and 
   // return a reference to the iterator
   Iterator& operator--() noexcept {
      ConstIterator<T>::operator--(); // call base-class version
      return *this;
   }

   // decrement the iterator to the previous element and 
   // return the iterator before the decrement
   Iterator operator--(int) noexcept {
      Iterator temp{*this};
      ConstIterator<T>::operator--(); // call base-class version
      return temp;
   }
};

// class template MyArray contains a fixed-size T[SIZE] array;
// MyArray is an aggregate type with public data, like std::array
template <typename T, size_t SIZE>
struct MyArray {
   // type names used in standard library containers
   using value_type = T;
   using size_type = size_t;
   using difference_type = ptrdiff_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;

   // iterator type names used in standard library containers
   using iterator = Iterator<T>;
   using const_iterator = ConstIterator<T>;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;

   // Rule of Zero: MyArray's special member functions are autogenerated

   constexpr size_type size() const noexcept {return SIZE;} // return size

   // member functions that return iterators
   iterator begin() {return iterator{&m_data[0]};}
   iterator end() {return iterator{&m_data[0] + size()};}
   const_iterator begin() const {return const_iterator{&m_data[0]};}
   const_iterator end() const {
      return const_iterator{&m_data[0] + size()};
   }
   const_iterator cbegin() const {return begin();}
   const_iterator cend() const {return end();}

   // member functions that return reverse iterators
   reverse_iterator rbegin() {return reverse_iterator{end()};}
   reverse_iterator rend() {return reverse_iterator{begin()};}
   const_reverse_iterator rbegin() const {
      return const_reverse_iterator{end()};
   }
   const_reverse_iterator rend() const {
      return const_reverse_iterator{begin()};
   }
   const_reverse_iterator crbegin() const {return rbegin();}
   const_reverse_iterator crend() const {return rend();}

   // autogenerated three-way comparison operator
   auto operator<=>(const MyArray& t) const noexcept = default;

   // overloaded subscript operator for non-const MyArrays;
   // reference return creates a modifiable lvalue
   T& operator[](size_type index) {
      // check for index out-of-range error
      if (index >= size()) {
         throw std::out_of_range{"Index out of range"};
      }

      return m_data[index]; // reference return
   }

   // overloaded subscript operator for const MyArrays;
   // const reference return creates a non-modifiable lvalue
   const T& operator[](size_type index) const {
      // check for subscript out-of-range error
      if (index >= size()) {
         throw std::out_of_range{"Index out of range"};
      }

      return m_data[index]; // returns copy of this element
   }
	
   // like std::array the data is public to make this an aggregate type
   T m_data[SIZE]; // built-in array of type T with SIZE elements
};

// deduction guide to enable MyArrays to be brace initialized
template<typename T, std::same_as<T>... Us>
MyArray(T first, Us... rest) -> MyArray<T, 1 + sizeof...(Us)>;

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_11-12/fig15_12.cpp
================================================
// fig15_12.cpp
// Using MyArray with range-based for and with 
// C++ standard library algorithms.
#include <algorithm>
#include <iostream>
#include <iterator>
#include "MyArray.h"

int main() {
   std::ostream_iterator<int> outputInt{std::cout, " "};
   std::ostream_iterator<double> outputDouble{std::cout, " "};
   std::ostream_iterator<std::string> outputString{std::cout, " "};

   std::cout << "Displaying MyArrays with std::ranges::copy, "
      << "which requires input iterators:\n";
   MyArray ints{1, 2, 3, 4, 5, 6, 7, 8};
   std::cout << "ints: ";
   std::ranges::copy(ints, outputInt);

   MyArray doubles{1.1, 2.2, 3.3, 4.4, 5.5};
   std::cout << "\ndoubles: ";
   std::ranges::copy(doubles, outputDouble);

   using namespace std::string_literals; // for string object literals 
   MyArray strings{"red"s, "orange"s, "yellow"s};
   std::cout << "\nstrings: ";
   std::ranges::copy(strings, outputString);

   std::cout << "\n\nDisplaying a MyArray with a range-based for "
      << "statement, which requires input iterators:\n";
   for (const auto& item : doubles) {
      std::cout << item << " ";
   }

   std::cout << "\n\nCopying a MyArray with std::ranges::copy, "
      << "which requires an input range and output iterator:\n";
   MyArray<std::string, strings.size()> strings2{};
   std::ranges::copy(strings, strings2.begin());
   std::cout << "strings2 after copying from strings: ";
   std::ranges::copy(strings2, outputString);

   std::cout << "\n\nFinding min and max elements in a MyArray "
      << "with std::ranges::minmax_element, which requires "
      << "a forward range:\n";
   auto [min, max] {std::ranges::minmax_element(strings)};
   std::cout << "min and max elements of strings are: "
      << *min << ", " << *max;

   std::cout << "\n\nReversing a MyArray with std::ranges::reverse, "
      << "which requires a bidirectional range:\n";
   std::ranges::reverse(ints);
   std::cout << "ints after reversing elements: ";
   std::ranges::copy(ints, outputInt);
   std::cout << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_11-12/sorttest.cpp
================================================
// sorttest.cpp
// Using MyArray with range-based for and with 
// C++ standard library algorithms.
#include <algorithm>
#include "MyArray.h"

int main() {
   MyArray integers{10, 2, 33, 4, 7, 1, 80};
   std::ranges::sort(integers);
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_13.cpp
================================================
// fig15_13.cpp
// Manipulating tuples.
#include <fmt/format.h> 
#include <iostream>
#include <string>
#include <tuple>

// type alias for a tuple representing a hardware part's inventory
using Part = std::tuple<int, std::string, int, double>;

// return a part's inventory tuple 
Part getInventory(int partNumber) {
   using namespace std::string_literals; // for string object literals 

   switch (partNumber) {
   case 1:
      return {1, "Hammer"s, 32, 9.95}; // return a Part tuple
   case 2:
      return {2, "Screwdriver"s, 106, 6.99}; // return a Part tuple
   default:
      return {0, "INVALID PART"s, 0, 0.0}; // return a Part tuple
   }
}

int main() {
   // display the hardware part inventory
   for (int i{1}; i <= 2; ++i) {
      // unpack the returned tuple into four variables;
      // variables' types are inferred from the tuple's element values
      auto [partNumber, partName, quantity, price] {getInventory(i)};

      std::cout << fmt::format("{}: {}, {}: {}, {}: {}, {}: {:.2f}\n",
         "Part number", partNumber, "Tool", partName,
         "Quantity", quantity, "Price", price);
   }

   std::cout << "\nAccessing a tuple's elements by index number:\n";
   auto hammer{getInventory(1)};
   std::cout << fmt::format("{}: {}, {}: {}, {}: {}, {}: {:.2f}\n",
      "Part number", std::get<0>(hammer), "Tool", std::get<1>(hammer),
      "Quantity", std::get<2>(hammer), "Price", std::get<3>(hammer));

   std::cout << fmt::format("A Part tuple has {} elements\n",
      std::tuple_size<Part>{}); // get the tuple size
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_14.cpp
================================================
// fig15_14.cpp
// Variadic function templates.
#include <fmt/format.h> 
#include <iostream>
#include <string>

// base-case function for one argument 
template <typename T>
auto sum(T item) {
   return item;
}

// recursively add one or more arguments
template <typename FirstItem, typename... RemainingItems>
auto sum(FirstItem first, RemainingItems... theRest) {
   return first + sum(theRest...); // expand parameter pack for next call
}

// add one or more arguments with a fold expression
template <typename FirstItem, typename... RemainingItems>
auto foldingSum(FirstItem first, RemainingItems... theRest) {
   return (first + ... + theRest); // expand the parameter 
}

int main() {
   using namespace std::literals;

   std::cout << "Recursive variadic function template sum:"
      << fmt::format("\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
         "sum(1): ", sum(1), "sum(1, 2): ", sum(1, 2),
         "sum(1, 2, 3): ", sum(1, 2, 3),
         "sum(\"s\"s, \"u\"s, \"m\"s): ", sum("s"s, "u"s, "m"s));

   std::cout << "Variadic function template foldingSum:"
      << fmt::format("\n{}{}\n{}{}\n{}{}\n{}{}\n",
         "sum(1): ", foldingSum(1), "sum(1, 2): ", foldingSum(1, 2),
         "sum(1, 2, 3): ", foldingSum(1, 2, 3),
         "sum(\"s\"s, \"u\"s, \"m\"s): ",
         foldingSum("s"s, "u"s, "m"s));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_15.cpp
================================================
// fig15_15.cpp
// Unary fold expressions.
#include <fmt/format.h> 
#include <iostream>

template <typename... Items>
auto unaryLeftAdd(Items... items) {
   return (... + items); // unary left fold
}

template <typename... Items>
auto unaryRightAdd(Items... items) {
   return (items + ...); // unary right fold
}

template <typename... Items>
auto unaryLeftSubtract(Items... items) {
   return (... - items); // unary left fold
}

template <typename... Items>
auto unaryRightSubtract(Items... items) {
   return (items - ...); // unary right fold
}

int main() {
   std::cout << "Unary left and right fold with addition:"
      << fmt::format("\n{}{}\n{}{}\n\n",
         "unaryLeftAdd(1, 2, 3, 4): ", unaryLeftAdd(1, 2, 3, 4),
         "unaryRightAdd(1, 2, 3, 4): ", unaryRightAdd(1, 2, 3, 4));

   std::cout << "Unary left and right fold with subtraction:"
      << fmt::format("\n{}{}\n{}{}\n",
         "unaryLeftSubtract(1, 2, 3, 4): ",
         unaryLeftSubtract(1, 2, 3, 4),
         "unaryRightSubtract(1, 2, 3, 4): ",
         unaryRightSubtract(1, 2, 3, 4));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_16.cpp
================================================
// fig15_16.cpp
// Binary fold expressions.
#include <fmt/format.h> 
#include <iostream>

template <typename... Items>
auto binaryLeftAdd(Items... items) {
   return (0 + ... + items); // binary left fold
}

template <typename... Items>
auto binaryRightAdd(Items... items) {
   return (items + ... + 0); // binary right fold
}

template <typename... Items>
auto binaryLeftSubtract(Items... items) {
   return (0 - ... - items); // binary left fold
}

template <typename... Items>
auto binaryRightSubtract(Items... items) {
   return (items - ... - 0); // binary right fold
}

int main() {
   std::cout << "Binary left and right fold with addition:"
      << fmt::format("\n{}{}\n{}{}\n{}{}\n{}{}\n\n",
         "binaryLeftAdd(): ", binaryLeftAdd(),
         "binaryLeftAdd(1, 2, 3, 4): ", binaryLeftAdd(1, 2, 3, 4),
         "binaryRightAdd(): ", binaryRightAdd(),
         "binaryRightAdd(1, 2, 3, 4): ", binaryRightAdd(1, 2, 3, 4));

   std::cout << "Binary left and right fold with subtraction:"
      << fmt::format("\n{}{}\n{}{}\n{}{}\n{}{}\n",
         "binaryLeftSubtract(): ", binaryLeftSubtract(),
         "binaryLeftSubtract(1, 2, 3, 4): ",
         binaryLeftSubtract(1, 2, 3, 4),
         "binaryRightSubtract(): ", binaryRightSubtract(),
         "binaryRightSubtract(1, 2, 3, 4): ",
         binaryRightSubtract(1, 2, 3, 4));
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_17.cpp
================================================
// fig15_17.cpp
// Repeating a task using the comma operator and fold expressions.
#include <iostream>

template <typename... Items>
void printItems(Items... items) {
   ((std::cout << items << "\n"), ...); // unary right fold
}

int main() {
   std::cout << "printItems(1, 2.2, \"hello\"):\n";
   printItems(1, 2.2, "hello");
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_18.cpp
================================================
// fig15_18.cpp
// Constraining a variadic-function-template parameter pack to
// elements of the same type.
#include <concepts> 
#include <iostream>
#include <string>

template <typename T, typename... Us>
concept SameTypeElements = (std::same_as<T, Us> && ...);

// add one or more arguments with a fold expression
template <typename FirstItem, typename... RemainingItems>
   requires SameTypeElements<FirstItem, RemainingItems...>
auto foldingSum(FirstItem first, RemainingItems... theRest) {
   return (first + ... + theRest); // expand the parameter 
}

int main() {
   using namespace std::literals;

   foldingSum(1, 2, 3); // valid: all are int values
   foldingSum("s"s, "u"s, "m"s); // valid: all are std::string objects
   foldingSum(1, 2.2, "hello"s); // error: three different types
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/

================================================
FILE: examples/lesson15/fig15_19.cpp
================================================
// fig15_19.cpp
// Calculating factorials at compile time.
#include <iostream>

// Factorial value metafunction calculates factorials recursively
template <int N>
struct Factorial {
   static constexpr long long value{N * Factorial<N - 1>::value};
};

// Factorial specialization for the base case
template <>
struct Factorial<0> {
   static constexpr long long value{1}; // 0! is 1
};

// constexpr compile-time recursive factorial
constexpr long long recursiveFactorial(int number) {
   if (number <= 1) {
      return 1; // base cases: 0! = 1 and 1! = 1 
   }
   else { // recursion step                      
      return number * recursiveFactorial(number - 1);
   }
}

// constexpr compile-time iterative factorial
constexpr long long iterativeFactorial(int number) {
   long long factorial{1}; // result for 0! and 1!

   for (long long i{2}; i <= number; ++i) {
      factorial *= i;
   }

   return factorial;
}

int main() {
   // "calling" a value metafunction requires instantiating 
   // the template and accessing its static value member
   std::cout << "CALCULATING FACTORIALS AT COMPILE TIME "
      << "WITH A RECURSIVE METAFUNCTION"
      << "\nFactorial(0): " << Factorial<0>::value
      << "\nFactorial(1): " << Factorial<1>::value
      << "\nFactorial(2): " << Factorial<2>::value
      << "\nFactorial(3): " << Factorial<3>::value
      << "\nFactorial(4): " << Factorial<4>::value
      << "\nFactorial(5): " << Factorial<5>::value;

   // calling the recursive constexpr function recursiveFactorial
   std::cout << "\n\nCALCULATING FACTORIALS AT COMPILE TIME "
      << "WITH A RECURSIVE CONSTEXPR FUNCTION"
      << "\nrecursiveFactorial(0): " << recursiveFactorial(0)
      << "\nrecursiveFactorial(1): " << recursiveFactorial(1)
      << "\nrecursiveFactorial(2): " << recursiveFactorial(2)
      << "\nrecursiveFactorial(3): " << recursiveFactorial(3)
      << "\nrecursiveFactorial(4): " << recursiveFactorial(4)
      << "\nrecursiveFactorial(5): " << recursiveFactorial(5);

   // calling the iterative constexpr function iterativeFactorial
   std::cout << "\n\nCALCULATING FACTORIALS AT COMPILE TIME "
      << "WITH AN ITERATIVE CONSTEXPR FUNCTION"
      << "\niterativeFactorial(0): " << iterativeFactorial(0)
      << "\niterativeFactorial(1): " << iterativeFactorial(1)
      << "\niterativeFactorial(2): " << iterativeFactorial(2)
      << "\niterativeFactorial(3): " << iterativeFactorial(3)
      << "\niterativeFactorial(4): " << iterativeFactorial(4)
      << "\niterativeFactorial(5): " << iterativeFactorial(5) << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_20.cpp
================================================
// fig15_20.cpp
// Implementing customDistance using template metaprogramming.
#include <array>
#include <iostream>
#include <iterator>
#include <list>
#include <ranges>
#include <type_traits>

// calculate the distance (number of items) between two iterators;
// requires at least input iterators
template <std::input_iterator Iterator>
auto customDistance(Iterator begin, Iterator end) {
   // for random-access iterators subtract the iterators
   if constexpr (std::is_base_of_v<std::random_access_iterator_tag,
      typename Iterator::iterator_category>) {

      std::cout << "customDistance with random-access iterators\n";
      return end - begin; // O(1) operation for random-access iterators
   }
   else { // for all other iterators
      std::cout << "customDistance with non-random-access iterators\n";
      std::ptrdiff_t count{0};

      // increment from begin to end and count number of iterations;
      // O(n) operation for non-random-access iterators
      for (auto iter{begin}; iter != end; ++iter) {
         ++count;
      }

      return count;
   }
}

int main() {
   const std::array ints1{1, 2, 3, 4, 5}; // has random-access iterators
   const std::list ints2{1, 2, 3}; // has bidirectional iterators

   auto result1{customDistance(ints1.begin(), ints1.end())};
   std::cout << "ints1 number of elements: " << result1 << "\n";
   auto result2{customDistance(ints2.begin(), ints2.end())};
   std::cout << "ints2 number of elements: " << result2 << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson15/fig15_21.cpp
================================================
// fig15_21.cpp
// Adding and removing type attributes with type metafunctions.
#include <fmt/format.h>
#include <iostream>
#include <type_traits>

// add const to a type T
template <typename T>
struct my_add_const {
   using type = const T;
};

// general case: no pointer in type, so set nested type variable to T
template <typename T>
struct my_remove_ptr {
   using type = T;
};

// partial template specialization: T is a pointer type, so remove *
template <typename T>
struct my_remove_ptr<T*> {
   using type = T;
};

int main() {
   std::cout << fmt::format("{}\n{}{}\n{}{}\n\n",
      "ADD CONST TO A TYPE VIA A CUSTOM TYPE METAFUNCTION",
      "std::is_same_v<const int, my_add_const<int>::type>: ",
      std::is_same_v<const int, my_add_const<int>::type>,
      "std::is_same_v<int* const, my_add_const<int*>::type>: ",
      std::is_same_v<int* const, my_add_const<int*>::type>);

   std::cout << fmt::format("{}\n{}{}\n{}{}\n\n",
      "REMOVE POINTER FROM TYPES VIA A CUSTOM TYPE METAFUNCTION",
      "std::is_same_v<int, my_remove_ptr<int>::type>: ",
      std::is_same_v<int, my_remove_ptr<int>::type>,
      "std::is_same_v<int, my_remove_ptr<int*>::type>: ",
      std::is_same_v<int, my_remove_ptr<int*>::type>);

   std::cout << fmt::format("{}\n{}{}\n{}{}\n\n",
      "ADD REFERENCES TO TYPES USING STANDARD TYPE TRAITS",
      "std::is_same_v<int&, std::add_lvalue_reference<int>::type>: ",
      std::is_same_v<int&, std::add_lvalue_reference<int>::type>,
      "std::is_same_v<int&&, std::add_rvalue_reference<int>::type>: ",
      std::is_same_v<int&&, std::add_rvalue_reference<int>::type>);

   std::cout << fmt::format("{}\n{}{}\n{}{}\n{}{}\n",
      "REMOVE REFERENCES FROM TYPES USING STANDARD TYPE TRAITS",
      "std::is_same_v<int, std::remove_reference<int>::type>: ",
      std::is_same_v<int, std::remove_reference<int>::type>,
      "std::is_same_v<int, std::remove_reference<int&>::type>: ",
      std::is_same_v<int, std::remove_reference<int&>::type>,
      "std::is_same_v<int, std::remove_reference<int&&>::type>: ",
      std::is_same_v<int, std::remove_reference<int&&>::type>);
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/compilation_commands.txt
================================================
************
* fig16_01 *
************
g++:
------------
g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts fig16_01.cpp -o fig16_01


------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_01.cpp -o fig16_01



***************
* fig16_02-03 *
***************
g++:
------------
g++ -fmodules-ts -x c++-system-header string  

g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts -c -x c++ welcome.ixx 

g++ -fmodules-ts fig16_03.cpp welcome.o -o fig16_03

------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
clang++-16 -std=c++20 -xc++-system-header --precompile string -o string.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -fmodule-file=string.pcm -x c++-module welcome.ixx --precompile -o welcome.pcm 

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_03.cpp -fprebuilt-module-path=. string.pcm welcome.pcm -o fig16_03


***************
* fig16_04-05 *
***************
g++:
------------
g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts -c -x c++ deitel.math.ixx 

g++ -fmodules-ts fig16_05.cpp deitel.math.o 


------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -x c++-module deitel.math.ixx --precompile -o deitel.math.pcm 

clang++-16 -std=c++20 -fmodule-file=deitel.math.pcm -fmodule-file=iostream.pcm fig16_05.cpp -o fig16_05 


***************
* fig16_06-08 *
***************
g++:
------------
g++ -fmodules-ts -x c++-system-header algorithm 
g++ -fmodules-ts -x c++-system-header iostream 
g++ -fmodules-ts -x c++-system-header iterator 
g++ -fmodules-ts -x c++-system-header numeric 
g++ -fmodules-ts -x c++-system-header vector 

g++ -fmodules-ts -c -x c++ deitel.math.ixx 
g++ -fmodules-ts -c deitel.math-impl.cpp 
g++ -fmodules-ts fig16_08.cpp deitel.math.o deitel.math-impl.o -o fig16_08

------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
clang++-16 -std=c++20 -xc++-system-header --precompile algorithm -o algorithm.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile iterator -o iterator.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile numeric -o numeric.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile vector -o vector.pcm 

clang++-16 -std=c++20 -fmodule-file=vector.pcm -x c++-module deitel.math.ixx --precompile -o deitel.math.pcm 

clang++-16 -std=c++20 -fmodule-file=deitel.math.pcm -fmodule-file=vector.pcm -fmodule-file=numeric.pcm -c deitel.math-impl.cpp -o deitel.math-impl.o

clang++-16 -std=c++20 -fmodule-file=algorithm.pcm -fmodule-file=iostream.pcm -fmodule-file=iterator.pcm -fmodule-file=vector.pcm fig16_08.cpp deitel.math-impl.o -fprebuilt-module-path=. deitel.math.pcm -o fig16_08


***************
* fig16_09-11 *
***************
g++:
------------
Not working at the time of this writing. Investigating the issue.

g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts -x c++-system-header string 

g++ -fmodules-ts -x c++-system-header stdexcept 

g++ -fmodules-ts -c -x c++ deitel.time.ixx 

g++ -fmodules-ts -c deitel.time-impl.cpp

g++ -fmodules-ts fig16_11.cpp deitel.time.o deitel.time-impl.o -o fig16_11


------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile string -o string.pcm 

clang++-16 -std=c++20 -xc++-system-header --precompile stdexcept -o stdexcept.pcm 

clang++-16 -std=c++20 -fmodule-file=string.pcm -x c++-module deitel.time.ixx --precompile -o deitel.time.pcm 

clang++-16 -std=c++20 -fmodule-file=deitel.time.pcm -fmodule-file=string.pcm -fmodule-file=stdexcept.pcm -c deitel.time-impl.cpp -o deitel.time-impl.o

clang++-16 -std=c++20 fig16_11.cpp deitel.time-impl.o -fmodule-file=iostream.pcm -fmodule-file=string.pcm -fmodule-file=stdexcept.pcm -fprebuilt-module-path=. deitel.time.pcm -o fig16_11


***************
* fig16_12-15 *
***************
g++:
cd ..
g++ -fmodules-ts -x c++-system-header cmath 

g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts -c -x c++ deitel.math-powers.ixx 

g++ -fmodules-ts -c -x c++ deitel.math-roots.ixx 

g++ -fmodules-ts -c -x c++ deitel.math.ixx 

g++ -fmodules-ts fig16_15.cpp deitel.math-powers.o deitel.math-roots.o deitel.math.o -o fig16_15

------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
IMPORTANT: Use the version of this example in the folder fig16_12-15clang. At the time of this writing, clang++ would not compile the <cmath> header into a header unit. So we replaced the import statement with

	#include <cmath>
	
clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -x c++-module deitel.math-powers.ixx --precompile -o deitel.math-powers.pcm 

clang++-16 -std=c++20 -x c++-module deitel.math-roots.ixx --precompile -o deitel.math-roots.pcm 

clang++-16 -std=c++20 -x c++-module deitel.math.ixx -fprebuilt-module-path=. --precompile -o deitel.math.pcm

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_15.cpp -fprebuilt-module-path=. deitel.math	.pcm deitel.math-powers.pcm deitel.math-roots.pcm -o fig16_15


***************
* fig16_16-21 *
***************
g++:
------------
g++ -fmodules-ts -x c++-system-header iostream 

g++ -fmodules-ts -c -x c++ deitel.math.powers.ixx 

g++ -fmodules-ts fig16_17.cpp deitel.math.powers.o -o fig16_17


g++ -fmodules-ts -x c++-system-header cmath
 
g++ -fmodules-ts -c -x c++ deitel.math.roots.ixx 

g++ -fmodules-ts fig16_19.cpp deitel.math.roots.o -o fig16_19


g++ -fmodules-ts -c -x c++ deitel.math.ixx 

g++ -fmodules-ts fig16_21.cpp deitel.math.powers.o deitel.math.roots.o deitel.math.o -o fig16_21

------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
IMPORTANT: Use the version of this example in the folder fig16_16-21clang. At the time of this writing, clang++ would not compile the <cmath> header into a header unit. So we replaced the import statement with

	#include <cmath>

clang++-16 -std=c++20 -xc++-system-header --precompile iostream -o iostream.pcm 

clang++-16 -std=c++20 -x c++-module deitel.math.powers.ixx --precompile -o deitel.math.powers.pcm 

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_17.cpp -fprebuilt-module-path=. deitel.math.powers.pcm -o fig16_17


clang++-16 -std=c++20 -x c++-module deitel.math.roots.ixx --precompile -o deitel.math.roots.pcm 

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_19.cpp -fprebuilt-module-path=. deitel.math.roots.pcm -o fig16_19


clang++-16 -std=c++20 -x c++-module deitel.math.ixx -fprebuilt-module-path=. --precompile -o deitel.math.pcm

clang++-16 -std=c++20 -fmodule-file=iostream.pcm fig16_21.cpp -fprebuilt-module-path=. deitel.math.pcm deitel.math.powers.pcm deitel.math.roots.pcm -o fig16_21
	
	
************
* fig16_22 *
************
g++:
------------
No instructions--this example is currently only for Visual C++.

------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
No instructions--this example is currently only for Visual C++.



***************
* fig16_23-24 *
***************
No instructions--Visual C++ only.



***************
* fig16_25-27 *
***************
No instructions--see the error messages shown in the video



***************
* fig16_28-29 *
***************
g++:
------------
See the instructions for fig16_09-11.


------------------------------------------------------------------------------
clang++ (-16 may need to be removed or changed based on your clang++ version):
------------
See the instructions for fig16_09-11.


================================================
FILE: examples/lesson16/fig16_01/fig16_01.cpp
================================================
// fig16_01.cpp
// Importing a standard library header as a header unit.
import <iostream>; // instead of #include <iostream>

int main() {
   std::cout << "Welcome to C++20 Modules!\n"; 
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_02-03/fig16_03.cpp
================================================
// fig16_03.cpp
// Importing a module and using its exported items.
import <iostream>; 
import welcome; // import the welcome module

int main() {
   std::cout << welcomeStandalone() << '\n' 
      << welcomeFromExportBlock() << '\n'
      << TestNamespace1::welcomeFromTestNamespace1() << '\n'
      << TestNamespace2::welcomeFromTestNamespace2() << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_02-03/welcome.ixx
================================================
// Fig. 16.2: welcome.ixx
// Primary module interface for a module named welcome.
export module welcome; // introduces the module name

import <string>; // class string is used in this module

// exporting a function
export std::string welcomeStandalone() {
   return "welcomeStandalone function called";
}

// exporting all items in the braces that follow export
export {
   std::string welcomeFromExportBlock() {
      return "welcomeFromExportBlock function called";
   }
}

// exporting a namespace exports all items in the namespace
export namespace TestNamespace1 {
   std::string welcomeFromTestNamespace1() {
      return "welcomeFromTestNamespace1 function called";
   }
}

// exporting an item in a namespace exports the namespace name, too
namespace TestNamespace2 {
   export std::string welcomeFromTestNamespace2() {
      return "welcomeFromTestNamespace2 function called";
   }
}




/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_04-05/deitel.math.ixx
================================================
// Fig. 16.4: deitel.math.ixx
// Primary module interface for a module named deitel.math.
export module deitel.math; // introduces the module name

namespace deitel::math {
   // exported function square; namespace deitel::math implicitly exported
   export int square(int x) {
      return x * x;
   }

   // non-exported function cube is not implicitly exported
   int cube(int x) {
      return x * x * x;
   }
};

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_04-05/fig16_05.cpp
================================================
// fig16_05.cpp
// Showing that a module's non-exported identifiers are inaccessible.
import <iostream>; 
import deitel.math; // import the deitel.math module

int main() {
   // can call square because it's exported from namespace deitel::math, 
   // which implicitly exports the namespace
   std::cout << "square(3) = " << deitel::math::square(3) << '\n';

   // cannot call cube because it's not exported 
   std::cout << "cube(3) = " << deitel::math::cube(3) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_06-08/deitel.math-impl.cpp
================================================
// Fig. 16.7: deitel.math-impl.cpp
// Module implementation unit for the module deitel.math.
module deitel.math; // this file's contents belong to module deitel.math

import <numeric>;
import <vector>;

namespace deitel::math {
   // average function's implementation
   double average(const std::vector<int>& values) {
      double total{std::accumulate(values.begin(), values.end(), 0.0)};
      return total / values.size();
   }
};



/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_06-08/deitel.math.ixx
================================================
// Fig. 16.6: deitel.math.ixx
// Primary module interface for a module named deitel.math.
export module deitel.math; // introduces the module name

import <vector>;

export namespace deitel::math {
   // calculate the average of a vector<int>'s elements
   double average(const std::vector<int>& values);
};

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_06-08/fig16_08.cpp
================================================
// fig16_08.cpp
// Using the deitel.math modules average function.
import <algorithm>;
import <iostream>;
import <iterator>;
import <vector>;
import deitel.math; // import the deitel.math module

int main() {
   std::ostream_iterator<int> output(std::cout, " ");
   std::vector integers{1, 2, 3, 4};

   std::cout << "vector integers: ";
   std::copy(integers.begin(), integers.end(), output);

   std::cout << "\naverage of integer's elements: "
      << deitel::math::average(integers) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_09-11/deitel.time-impl.cpp
================================================
// Fig. 16.10: deitel.time-impl.cpp
// deitel.time module implementation unit containing the 
// Time class member function definitions. 
module deitel.time; // module implementation unit for deitel.time

import <stdexcept>;
import <string>;
using namespace deitel::time;

// Time constructor initializes each data member    
Time::Time(int hour, int minute, int second) {
   // validate hour, minute and second
   if ((hour < 0 || hour >= 24) || (minute < 0 || minute >= 60) ||
      (second < 0 || second >= 60)) {
      throw std::invalid_argument{
         "hour, minute or second was out of range" };
   }

   m_hour = hour;
   m_minute = minute;
   m_second = second;
}

// return a string representation of the Time
std::string Time::toString() const {
   using namespace std::string_literals;

   return "Hour: "s + std::to_string(m_hour) +
      "\nMinute: "s + std::to_string(m_minute) +
      "\nSecond: "s + std::to_string(m_second);
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_09-11/deitel.time.ixx
================================================
// Fig. 16.9: deitel.time.ixx
// Primary module interface for a simple Time class.
export module deitel.time; // declare the primary module interface

import <string>; // rather than #include <string>

export namespace deitel::time {
   class Time { 
   public:
      // default constructor because it can be called with no arguments
      explicit Time(int hour = 0, int minute = 0, int second = 0);

      std::string toString() const; 
   private:
      int m_hour{0}; // 0 - 23 (24-hour clock format)
      int m_minute{0}; // 0 - 59
      int m_second{0}; // 0 - 59
   };
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_09-11/fig16_11.cpp
================================================
// fig16_11.cpp 
// Importing the deitel.time module and using its Time class.
import <iostream>;
import <stdexcept>;
import <string>;

import deitel.time;
using namespace deitel::time;

int main() {
   const Time t{12, 25, 42}; // hour, minute and second specified      

   std::cout << "Time t:\n" << t.toString() << "\n\n";

   // attempt to initialize t2 with invalid values
   try {
      const Time t2{27, 74, 99}; // all bad values specified
   }
   catch (const std::invalid_argument& e) {
      std::cout << "t2 not created: " << e.what() << '\n';
   }
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15/deitel.math-powers.ixx
================================================
// Fig. 16.12: deitel.math-powers.ixx
// Module interface partition unit deitel.math:powers.
export module deitel.math:powers; 

export namespace deitel::math {
   double square(double x) {return x * x;}
   double cube(double x) {return x * x * x;}
}

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15/deitel.math-roots.ixx
================================================
// Fig. 16.13: deitel.math-roots.ixx
// Module interface partition unit deitel.math:roots. 
export module deitel.math:roots;

import <cmath>;

export namespace deitel::math {
   double squareRoot(double x) {return std::sqrt(x);}
   double cubeRoot(double x) {return std::cbrt(x);}
}


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15/deitel.math.ixx
================================================
// Fig. 16.14: deitel.math.ixx
// Primary module interface unit deitel.math exports declarations from
// the module interface partitions :powers and :roots.
export module deitel.math; // declares the primary module interface unit

// import and re-export the declarations in the module
// interface partitions :powers and :roots
export import :powers;
export import :roots;


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15/fig16_15.cpp
================================================
// fig16_15.cpp
// Using the deitel.math module's functions.
import <iostream>;
import deitel.math; // import the deitel.math module

using namespace deitel::math; 

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5)
      << "\nsquareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15clang/deitel.math-powers.ixx
================================================
// Fig. 16.12: deitel.math-powers.ixx
// Module interface partition unit deitel.math:powers.
export module deitel.math:powers; 

export namespace deitel::math {
   double square(double x) { return x * x; }
   double cube(double x) { return x * x * x; }
}

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15clang/deitel.math-roots.ixx
================================================
// Fig. 16.13: deitel.math-roots.ixx
// Module interface partition unit deitel.math:roots. 
export module deitel.math:roots;

//import <cmath>;
#include <cmath>

export namespace deitel::math {
   double squareRoot(double x) { return std::sqrt(x); }
   double cubeRoot(double x) { return std::cbrt(x); }
}


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15clang/deitel.math.ixx
================================================
// Fig. 16.14: deitel.math.ixx
// Primary module interface unit deitel.math exports declarations from
// the module interface partitions :powers and :roots.
export module deitel.math; // declares the primary module interface unit

// import and re-export the declarations in the module
// interface partitions :powers and :roots
export import :powers;
export import :roots;


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_12-15clang/fig16_15.cpp
================================================
// fig16_15.cpp
// Using the deitel.math module's functions.
import <iostream>;
import deitel.math; // import the deitel.math module

using namespace deitel::math; 

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5)
      << "\nsquareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/deitel.math.ixx
================================================
// Fig. 16.20: deitel.math.ixx
// Primary module interface unit deitel.math aggregates declarations
// from "submodules" deitel.math.powers and deitel.math.roots.
export module deitel.math; // primary module interface unit

// import and re-export deitel.math.powers and deitel.math.roots
export import deitel.math.powers;
export import deitel.math.roots;


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/deitel.math.powers.ixx
================================================
// Fig. 16.16: deitel.math.powers.ixx
// Primary module interface unit deitel.math.powers.
export module deitel.math.powers; 

export namespace deitel::math {
   double square(double x) { return x * x; }
   double cube(double x) { return x * x * x; }
}

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/deitel.math.roots.ixx
================================================
// Fig. 16.18: deitel.math.roots.ixx
// Primary module interface unit deitel.math.roots. 
export module deitel.math.roots;

import <cmath>;

export namespace deitel::math {
   double squareRoot(double x) { return std::sqrt(x); }
   double cubeRoot(double x) { return std::cbrt(x); }
}


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/fig16_17.cpp
================================================
// fig16_17.cpp
// Using the deitel.math.powers module's functions.
import <iostream>;
import deitel.math.powers; // import the deitel.math.powers module

using namespace deitel::math;

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5) << '\n';
}


 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/fig16_19.cpp
================================================
// fig16_19.cpp
// Using the deitel.math.roots module's functions.
import <iostream>;
import deitel.math.roots; // import the deitel.math.roots module

using namespace deitel::math; 

int main() {
   std::cout << "squareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21/fig16_21.cpp
================================================
// fig16_21.cpp
// Using the deitel.math module's functions.
import <iostream>;
import deitel.math; // import the deitel.math module

using namespace deitel::math; 

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5)
      << "\nsquareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/deitel.math.ixx
================================================
// Fig. 16.20: deitel.math.ixx
// Primary module interface unit deitel.math aggregates declarations
// from "submodules" deitel.math.powers and deitel.math.roots.
export module deitel.math; // primary module interface unit

// import and re-export deitel.math.powers and deitel.math.roots
export import deitel.math.powers;
export import deitel.math.roots;


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/deitel.math.powers.ixx
================================================
// Fig. 16.16: deitel.math.powers.ixx
// Primary module interface unit deitel.math.powers.
export module deitel.math.powers; 

export namespace deitel::math {
   double square(double x) { return x * x; }
   double cube(double x) { return x * x * x; }
}

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/deitel.math.roots.ixx
================================================
// Fig. 16.18: deitel.math.roots.ixx
// Primary module interface unit deitel.math.roots. 
module; 
#include <cmath>

export module deitel.math.roots;

export namespace deitel::math {
   double squareRoot(double x) { return std::sqrt(x); }
   double cubeRoot(double x) { return std::cbrt(x); }
}


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/fig16_17.cpp
================================================
// fig16_17.cpp
// Using the deitel.math.powers module's functions.
import <iostream>;
import deitel.math.powers; // import the deitel.math.powers module

using namespace deitel::math;

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5) << '\n';
}


 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/fig16_19.cpp
================================================
// fig16_19.cpp
// Using the deitel.math.roots module's functions.
import <iostream>;
import deitel.math.roots; // import the deitel.math.roots module

using namespace deitel::math; 

int main() {
   std::cout << "squareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_16-21clang/fig16_21.cpp
================================================
// fig16_21.cpp
// Using the deitel.math module's functions.
import <iostream>;
import deitel.math; // import the deitel.math module

using namespace deitel::math; 

int main() {
   std::cout << "square(6): " << square(6)
      << "\ncube(5): " << cube(5)
      << "\nsquareRoot(9): " << squareRoot(9)
      << "\ncubeRoot(1000): " << cubeRoot(1000) << '\n';
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_22/fig16_22.cpp
================================================
// fig16_22.cpp
// Importing Microsoft's modularized standard library.
import std.core; // provides access to most of the C++ standard library

int main() {
   std::cout << "Welcome to C++20 Modules!\n"; 
}





 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_23-24/moduleA.ixx
================================================
// Fig. 16.23: moduleA.ixx
// Primary module interface unit that imports moduleB.
export module moduleA; // declares the primary module interface unit

export import moduleB; // import and re-export moduleB


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_23-24/moduleB.ixx
================================================
// Fig. 16.24: moduleB.ixx
// Primary module interface unit that imports moduleA.
export module moduleB; // declares the primary module interface unit

export import moduleA; // import and re-export moduleA

/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_25-27/fig16_27.cpp
================================================
// fig16_27.cpp
// Showing that moduleB does not implicitly export moduleA's function.
import <iostream>;
import moduleB; 

int main() {
   std::cout << "square(6): " << square(6) // exported from moduleB
      << "\ncube(5): " << cube(5) << '\n'; // not exported from moduleB
}


 /*************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_25-27/moduleA.ixx
================================================
// Fig. 16.25: moduleA.ixx
// Primary module interface unit that exports function cube.
export module moduleA; // declares the primary module interface unit

export int cube(int x) { return x * x * x; }



/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_25-27/moduleB.ixx
================================================
// Fig. 16.26: moduleB.ixx
// Primary module interface unit that imports, but does not export, 
// moduleA and exports function square.
export module moduleB; // declares the primary module interface unit

import moduleA; // import but do not export moduleA

export int square(int x) {return x * x;}


/*************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
* Pearson Education, Inc. All Rights Reserved.                           *
*                                                                        *
* DISCLAIMER: The authors and publisher of this book have used their     *
* best efforts in preparing the book. These efforts include the          *
* development, research, and testing of the theories and programs        *
* to determine their effectiveness. The authors and publisher make       *
* no warranty of any kind, expressed or implied, with regard to these    *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or       *
* consequential damages in connection with, or arising out of, the       *
* furnishing, performance, or use of these programs.                     *
**************************************************************************/


================================================
FILE: examples/lesson16/fig16_28-29/deitel.time-impl.cpp
================================================
// Fig. 16.10: deitel.time-impl.cpp
// deitel.time module implementation unit containing the 
// Time class member function definitions. 
module deitel.time; // module implementation unit for deitel.time

import <stdexcept>;
import <string>;
using namespace deitel::time;

// Time constructor initializes each data member    
Time::Time(int hour, int minute, int second) {
   // validate hour, minute and second
   if ((hour < 0 || hour >= 24) || (minute < 0 || minute >= 60) ||
      (second < 0 || second >= 60)) {
      throw std::invalid_argument{
         "hour, minute or second was out of range" };
   }

   m_hour = hour;
   m_minute = minute;
   m_second = second;
}

// return a string representation of the Time
std::string Time::toString() const {
   using namespace std::string_literals;

   return "Hour: "s + std::to_string(m_hour) +
      "\nMinute: "s + std::to_string(m_minute) +
      "\nSecond: "s + std::to_string(m_second);
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_28-29/deitel.time.ixx
================================================
// Fig. 16.28: deitel.time.ixx
// Primary module interface unit for the deitel.time module.
export module deitel.time; // declare the primary module interface

import <string>; // rather than #include <string>

namespace deitel::time {
   class Time { // not exported
   public:
      // default constructor because it can be called with no arguments
      explicit Time(int hour = 0, int minute = 0, int second = 0);

      std::string toString() const; 
   private:
      int m_hour{0}; // 0 - 23 (24-hour clock format)
      int m_minute{0}; // 0 - 59
      int m_second{0}; // 0 - 59
   };

   // exported function returns a valid Time
   export Time getTime() {return Time(6, 45, 0);}
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson16/fig16_28-29/fig16_29.cpp
================================================
// fig16_29.cpp 
// Showing that type deitel::time::Time is reachable  
// and its public members are visible.
import <iostream>;
import deitel.time;

int main() {
   // initalize t with the object returned by getTime; cannot declare t 
   // as type Time because the type is not exported, and thus not visible
   auto t{deitel::time::getTime()};

   // Time's toString function is reachable, even though
   // class Time was not exported by module deitel.time
   std::cout << "Time t:\n" << t.toString() << "\n\n";
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson17/fig17_01/fig17_01.cpp
================================================
// fig17_01.cpp
// Profiling sequential and parallel sorting with the std::sort algorithm.
#include <algorithm>
#include <chrono> // for timing operations
#include <execution> // for execution policies
#include <iostream>
#include <iterator>
#include <random>
#include <vector>

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()}; 
   std::uniform_int_distribution ints{};

   std::cout << "Creating a vector v1 to hold 100,000,000 ints\n";
   std::vector<int> v1(100'000'000); // 100,000,000 element vector

   std::cout << "Filling vector v1 with random ints\n";
   std::ranges::generate(v1, [&]() {return ints(engine);});

   // copy v1 to create identical data sets for each sort demonstration
   std::cout << "Copying v1 to vector v2 to create identical data sets\n";
   std::vector v2{v1};

   // <chrono> library features we'll use for timing
   using std::chrono::steady_clock;
   using std::chrono::duration_cast;
   using std::chrono::milliseconds;

   // sequentially sort v1
   std::cout << "\nSorting 100,000,000 ints sequentially\n";
   auto start1{steady_clock::now()}; // get current time
   std::sort(v1.begin(), v1.end()); // sequential sort
   auto end1{steady_clock::now()}; // get current time

   // calculate and display time in milliseconds
   auto time1{duration_cast<milliseconds>(end1 - start1)};
   std::cout << "Time: " << (time1.count() / 1000.0) << " seconds\n";

   // parallel sort v2
   std::cout << "\nSorting the same 100,000,000 ints in parallel\n";
   auto start2{steady_clock::now()}; // get current time
   std::sort(std::execution::par, v2.begin(), v2.end()); // parallel sort
   auto end2{steady_clock::now()}; // get current time

   // calculate and display time in milliseconds
   auto time2{duration_cast<milliseconds>(end2 - start2)};
   std::cout << "Time: " << (time2.count() / 1000.0) << " seconds\n";
}



/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson17/fig17_02/fig17_02.cpp
================================================
// fig17_02.cpp
// Performing transforms with execution policies par and unseq.
#include <algorithm>
#include <chrono> // for timing operations
#include <cmath>
#include <execution> // for execution policies
#include <format>
#include <iostream>
#include <random>
#include <vector>

// time each std::transform call and return its duration in seconds
double timeTransform(auto policy, const std::vector<int>& v) {
   // <chrono> library features we'll use for timing
   using std::chrono::steady_clock;
   using std::chrono::duration_cast;
   using std::chrono::milliseconds;

   std::vector<double> result(v.size());
   auto start{steady_clock::now()}; // get current time
   std::transform(policy, v.begin(), v.end(),
      result.begin(), [](auto x) {return std::sqrt(x);});
   auto end{steady_clock::now()}; // get current time

   // calculate and return time in seconds
   auto time{duration_cast<milliseconds>(end - start)};
   return time.count() / 1000.0;
}

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()}; 
   std::uniform_int_distribution ints{0, 1000};

   std::cout << "Creating vectors\n";
   std::vector<int> v1(100'000'000); 
   std::vector<int> v2(1'000'000'000); 

   std::cout << "Filling vectors with random ints\n";
   std::generate(std::execution::par, v1.begin(), v1.end(),
      [&]() {return ints(engine);});
   std::generate(std::execution::par, v2.begin(), v2.end(),
      [&]() {return ints(engine);});

   std::cout << "\nCalculating square roots:\n";

   // time the transforms on 100,000,000 elements
   std::cout << std::format("{} elements with par\n", v1.size());
   double parTime1{timeTransform(std::execution::par, v1)};
   std::cout << std::format("{} elements with unseq\n", v1.size());
   double unseqTime1{timeTransform(std::execution::unseq, v1)};

   // time the transforms on 1,000,000,000 elements
   std::cout << std::format("{} elements with par\n", v2.size());
   double parTime2{timeTransform(std::execution::par, v2)};
   std::cout << std::format("{} elements with unseq\n", v2.size());
   double unseqTime2{timeTransform(std::execution::unseq, v2)};

   // display table of timing results
   std::cout << "\nExecution times (in seconds):\n\n"
      << std::format("{:>13}{:>17}{:>21}\n", "# of elements", 
            "par (parallel)", "unseq (vectorized)")
      << std::format("{:>13}{:>17.3f}{:>21.3f}\n",
            v1.size(), parTime1, unseqTime1)
      << std::format("{:>13}{:>17.3f}{:>21.3f}\n",
            v2.size(), parTime2, unseqTime2);
}

/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson17/fig17_03-04/printtask.cpp
================================================
// Fig. 17.4: printtask.cpp
// Concurrently executing tasks with std::jthreads.
#include <chrono>
#include <format>
#include <iostream>
#include <random>
#include <string>
#include <thread>
#include <vector>
#include "printtask.h"

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()}; 
   std::uniform_int_distribution ints{0, 5000};

   std::vector<std::jthread> threads; // stores the jthreads

   std::cout << "STARTING JTHREADS\n";

   // start two jthreads
   for (int i{1}; i < 3; ++i) {
      std::chrono::milliseconds sleepTime{ints(engine)};
      std::string name{std::format("Task {}", i)};

      // create a jthread that calls printTask, passing name and sleepTime
      // as arguments and store the jthread, so it is not destructed until
      // the vector goes out of scope at the end of main; each jthread's
      // destructor automatically joins the jthread
      threads.push_back(std::jthread{printTask, name, sleepTime});
   }

   std::cout << "\nJTHREADS STARTED\n";
   std::cout << "\nMAIN ENDS\n";
}



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_03-04/printtask.h
================================================
// Fig. 17.3: printtask.h
// Function printTask defines a task to perform in a separate thread.
#include <chrono>
#include <format> 
#include <iostream>
#include <sstream>
#include <string>
#include <thread>

// get current thread's ID as a string
std::string id() {
    std::ostringstream out;
    out << std::this_thread::get_id();
    return out.str();
}

// task to perform in a separate thread 
void printTask(const std::string& name, 
   std::chrono::milliseconds sleepTime) {

   // <chrono> library features we'll use for timing
   using std::chrono::steady_clock;
   using std::chrono::duration_cast;
   using std::chrono::milliseconds;

   std::cout << std::format("{} (ID {}) going to sleep for {} ms\n",
      name, id(), sleepTime.count());

   auto startTime{steady_clock::now()}; // get current time

   // put thread to sleep for sleepTime milliseconds 
   std::this_thread::sleep_for(sleepTime); 

   auto endTime{steady_clock::now()}; // get current time
   auto time{duration_cast<milliseconds>(endTime - startTime)};
   auto difference{duration_cast<milliseconds>(time - sleepTime)};
   std::cout << std::format("{} (ID {}) awakens after {} ms ({} + {})\n",
      name, id(), time.count(), sleepTime.count(), difference.count());
}


/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson17/fig17_05-06/SharedBufferTest.cpp
================================================
// Fig. 17.6: SharedBufferTest.cpp
// Application with concurrent jthreads sharing an unsynchronized buffer.
#include <chrono>
#include <format>
#include <iostream>
#include <random>
#include <thread>
#include "UnsynchronizedBuffer.h"

int main() {
   // create UnsynchronizedBuffer to store ints       
   UnsynchronizedBuffer buffer;

   // lambda expression that produces the values 1-10 and sums them 
   auto produce{
      [&buffer]() {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{0, 3000};

         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::chrono::milliseconds sleepTime{ints(engine)};
            std::this_thread::sleep_for(sleepTime);

            buffer.put(count); // set value in buffer
            sum += count; // add count to sum of values produced
            std::cout << std::format("\t{:2d}\n", sum);
         }
   
         std::cout << "Producer done producing\nTerminating Producer\n";      
      }
   };

   // lambda expression that consumes the values 1-10 and sums them
   auto consume{
      [&buffer]() {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{0, 3000};

         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::chrono::milliseconds sleepTime{ints(engine)};
            std::this_thread::sleep_for(sleepTime);

            sum += buffer.get(); // get buffer value and add to sum
            std::cout << std::format("\t\t\t{:2d}\n", sum);
        }

         std::cout << std::format("\n{} {}\n{}\n",
            "Consumer read values totaling", sum, "Terminating Consumer");
      }
   };

   std::cout << "Action\t\tValue\tSum of Produced\tSum of Consumed\n";
   std::cout << "------\t\t-----\t---------------\t---------------\n";

   std::jthread producer{produce}; // start producer jthread
   std::jthread consumer{consume}; // start consumer jthread 
} 


/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_05-06/UnsynchronizedBuffer.h
================================================
// Fig. 17.5: UnsynchronizedBuffer.h
// UnsynchronizedBuffer incorrectly maintains a shared integer that is 
// accessed by a producer thread and a consumer thread.
#pragma once
#include <format>
#include <iostream>
#include <string>

class UnsynchronizedBuffer {
public:
   // place value into buffer
   void put(int value) {
      std::cout << std::format("Producer writes\t{:2d}", value);
      m_buffer = value;
   }

   // return value from buffer
   int get() const {
      std::cout << std::format("Consumer reads\t{:2d}", m_buffer);
      return m_buffer;
   }
private:
   int m_buffer{-1}; // shared by producer and consumer threads
};


/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_07-08/SharedBufferTest.cpp
================================================
// Fig. 17.8: SharedBufferTest.cpp
// Concurrent threads correctly manipulating a synchronized buffer.
#include <chrono>
#include <format>
#include <iostream>
#include <mutex>
#include <random>
#include <thread>
#include "SynchronizedBuffer.h"

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()};
   std::uniform_int_distribution ints{0, 3000};
   std::mutex intsMutex;

   // lambda for synchronized random sleep time generation
   auto getSleepTime{
      [&]() {
         std::lock_guard lock{intsMutex};
         return std::chrono::milliseconds{ints(engine)};
      }
   };

   // create SynchronizedBuffer to store ints       
   SynchronizedBuffer buffer;

   // lambda expression that produces the values 1-10 and sums them 
   auto produce{
      [&buffer, &getSleepTime]() {
         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::this_thread::sleep_for(getSleepTime());

            buffer.put(count); // set value in buffer
            sum += count; // add count to sum of values produced
         }

         std::cout << "Producer done producing\nTerminating Producer\n";
      }
   };

   // lambda expression that consumes the values 1-10 and sums them
   auto consume{
      [&buffer, &getSleepTime]() {
         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::this_thread::sleep_for(getSleepTime());

            sum += buffer.get(); // get buffer value and add to sum
         }

         std::cout << std::format("\n{} {}\n{}\n",
            "Consumer read values totaling", sum, "Terminating Consumer");
      }
   };

   std::cout << std::format("{:<40}{}\t\t{}\n{:<40}{}\t\t{}\n\n",
      "Operation", "Buffer", "Occupied",
      "---------", "------", "--------");

   std::jthread producer{produce}; // start producer thread
   std::jthread consumer{consume}; // start consumer thread 
}

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_07-08/SynchronizedBuffer.h
================================================
// Fig. 17.7: SynchronizedBuffer.h 
// SynchronizedBuffer maintains synchronized access to a shared mutable
// integer that is accessed by a producer thread and a consumer thread.
#pragma once
#include <condition_variable> 
#include <format> 
#include <mutex>
#include <iostream>
#include <string>

using namespace std::string_literals;

class SynchronizedBuffer {
public:
   // place value into m_buffer
   void put(int value) {
      // critical section that requires a lock to modify shared data
      {
         // lock on m_mutex to be able to write to m_buffer
         std::unique_lock dataLock{m_mutex};

         if (m_occupied) {
            std::cout << std::format(
               "Producer tries to write.\n{:<40}{}\t\t{}\n\n",
               "Buffer full. Producer waits.", m_buffer, m_occupied);

            // wait on condition variable m_cv; the lambda in the second
            // argument ensures that if the thread gets the processor
            // before m_occupied is false, the thread continues waiting
            m_cv.wait(dataLock, [&]() {return !m_occupied;});
         }

         // write to m_buffer
         m_buffer = value;
         m_occupied = true;

         std::cout << std::format("{:<40}{}\t\t{}\n\n",
            "Producer writes "s + std::to_string(value),
            m_buffer, m_occupied);
      } // dataLock's destructor releases the lock on m_mutex 

      // if consumer is waiting, notify it that it can now read
      m_cv.notify_one();
   }

   // return value from m_buffer
   int get() {
      int value; // will store the value returned by get

      // critical section that requires a lock to modify shared data
      {
         // lock on m_mutex to be able to read from m_buffer
         std::unique_lock dataLock{m_mutex};

         if (!m_occupied) {
            std::cout << std::format(
               "Consumer tries to read.\n{:<40}{}\t\t{}\n\n",
               "Buffer empty. Consumer waits.", m_buffer, m_occupied);

            // wait on condition variable m_cv; the lambda in the second 
            // argument ensures that if the thread gets the processor
            // before m_occupied is true, the thread continues waiting
            m_cv.wait(dataLock, [&]() {return m_occupied;});
         }

         value = m_buffer;
         m_occupied = false;

         std::cout << std::format("{:<40}{}\t\t{}\n{}\n",
            "Consumer reads "s + std::to_string(m_buffer),
            m_buffer, m_occupied, std::string(64, '-'));
      } // dataLock's destructor releases the lock on m_mutex 

      // if producer is waiting, notify it that it can now write
      m_cv.notify_one();

      return value;
   }
private:
   int m_buffer{-1}; // shared by producer and consumer threads
   bool m_occupied{false};
   std::condition_variable m_cv;
   std::mutex m_mutex;
};


/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_09-10/CircularBuffer.h
================================================
// Fig. 17.9: CircularBuffer.h
// Synchronizing access to a shared three-element circular buffer.
#pragma once
#include <array> 
#include <condition_variable> 
#include <format> 
#include <mutex>
#include <iostream>
#include <string>
#include <string_view>

using namespace std::string_literals;

class CircularBuffer {
public:
   // place value into m_bu ffer
   void put(int value) {
      // critical section that requires a lock to modify shared data
      {
         // lock on m_mutex to be able to write to m_buffer
         std::unique_lock dataLock{m_mutex};

         // if no empty locations, wait on condition variable m_cv  
         if (m_occupiedCells == m_buffer.size()) {
            std::cout << "Buffer is full. Producer waits.\n\n";

            // wait on the condition variable; the lambda argument 
            // ensures that if the thread gets the processor before
            // the m_buffer has open cells, the thread continues waiting
            m_cv.wait(dataLock,
               [&] {return m_occupiedCells < m_buffer.size();});
         }

         m_buffer[m_writeIndex] = value; // write to m_buffer
         ++m_occupiedCells; // one more m_buffer cell is occupied
         m_writeIndex = (m_writeIndex + 1) % m_buffer.size();
         displayState(std::format("Producer writes {}", value));
      } // dataLock's destructor releases the lock on m_mutex here

      m_cv.notify_one(); // notify threads waiting to read from m_buffer
   }

   // return value from m_buffer
   int get() {
      int readValue; // will temporarily hold the next value read 

      // critical section that requires a lock to modify shared data
      {
         // lock on m_mutex to be able to write to m_buffer
         std::unique_lock dataLock{m_mutex};

         // if no data to read, place thread in waiting state
         if (m_occupiedCells == 0) {
            std::cout << "Buffer is empty. Consumer waits.\n\n";

            // wait on the condition variable; the lambda argument 
            // ensures that if the thread gets the processor before
            // there is data in the m_buffer, the thread continues waiting
            m_cv.wait(dataLock, [&]() {return m_occupiedCells > 0;});
         }

         readValue = m_buffer[m_readIndex]; // read value from m_buffer
         m_readIndex = (m_readIndex + 1) % m_buffer.size();
         --m_occupiedCells; // one fewer m_buffer cells is occupied
         displayState(std::format("Consumer reads {}", readValue));
      } // dataLock's destructor releases the lock on m_mutex here

      m_cv.notify_one(); // notify threads waiting to write to m_buffer
      return readValue;
   }

   // display current operation and m_buffer state
   void displayState(std::string_view operation) const {
      std::string s;

      // add operation argument and number of occupied m_buffer cells
      s += std::format("{} (buffer cells occupied: {})\n{:<15}",
         operation, m_occupiedCells, "buffer cells:");

      // add values in m_buffer 
      for (int value : m_buffer) {
         s += std::format(" {:2d}  ", value);
      }

      s += std::format("\n{:<15}", ""); // padding

      // add underlines
      for (int i{0}; i < m_buffer.size(); ++i) {
         s += "---- "s;
      }

      s += std::format("\n{:<15}", ""); // padding

      for (int i{0}; i < m_buffer.size(); ++i) {
         s += std::format(" {}{}  ",
            (i == m_writeIndex ? 'W' : ' '),
            (i == m_readIndex ? 'R' : ' '));
      }

      s += "\n\n";
      std::cout << s; // display the state string
   }
private:
   std::condition_variable m_cv;
   std::mutex m_mutex;

   std::array<int, 3> m_buffer{-1, -1, -1}; // shared m_buffer
   int m_occupiedCells{0}; // count number of buffers used
   int m_writeIndex{0}; // index of next element to write to
   int m_readIndex{0}; // index of next element to read
};

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/

================================================
FILE: examples/lesson17/fig17_09-10/SharedBufferTest.cpp
================================================
// Fig. 17.10: SharedBufferTest.cpp
// Concurrent threads manipulating a synchronized circular buffer.
#include <chrono>
#include <format>
#include <iostream>
#include <mutex>
#include <random>
#include <thread>
#include "CircularBuffer.h"

int main() {
   // create CircularBuffer to store ints and display initial state       
   CircularBuffer buffer;
   buffer.displayState("Initial State");

   // lambda expression that produces the values 1-10 and sums them 
   auto produce{
      [&buffer]() {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{0, 3000};

         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::chrono::milliseconds sleepTime{ints(engine)};
            std::this_thread::sleep_for(sleepTime);

            buffer.put(count); // set value in buffer
            sum += count; // add count to sum of values produced
         }
   
         std::cout << "Producer done producing\nTerminating Producer\n\n";
      }
   };

   // lambda expression that consumes the values 1-10 and sums them
   auto consume{
      [&buffer]() {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{0, 3000};

         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::chrono::milliseconds sleepTime{ints(engine)};
            std::this_thread::sleep_for(sleepTime);

            sum += buffer.get(); // get buffer value and add to sum
         }

         std::cout << std::format("{} {}\n{}\n\n",
            "Consumer read values totaling", sum, "Terminating Consumer");
      }
   };

   std::jthread producer{produce}; // start producer thread
   std::jthread consumer{consume}; // start consumer thread 
} 



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_11/CooperativeCancelation.cpp
================================================
// Fig. 17.11: CooperativeCancelation.cpp
// Using a std::jthread's built-in stop_source 
// to request that the std::jthread stop executing.
#include <chrono>
#include <format>
#include <iostream>
#include <mutex>
#include <random>
#include <sstream>
#include <stop_token>
#include <string>
#include <string_view>
#include <thread>

// get current thread's ID as a string
std::string id() {
    std::ostringstream out;
    out << std::this_thread::get_id();
    return out.str();
}

int main() {
   // each printTask iterates until a stop is requested by another thread
   auto printTask{
      [&](std::stop_token token, std::string name) {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{500, 1000};

         // register a function to call when a stop is requested 
         std::stop_callback callback(token, [&]() {
            std::cout << std::format(
               "{} told to stop by thread with id {}\n", name, id());
         });

         while (!token.stop_requested()) { // run until stop requested
            auto sleepTime{std::chrono::milliseconds{ints(engine)}};

            std::cout << std::format(
               "{} (id: {}) going to sleep for {} ms\n",
               name, id(), sleepTime.count());

            // put thread to sleep for sleepTime milliseconds 
            std::this_thread::sleep_for(sleepTime);

            // show that task woke up 
            std::cout << std::format("{} working.\n", name);
         }

         std::cout << std::format("{} terminating.\n", name);
      }
   };

   std::cout << std::format("MAIN (id: {}) STARTING TASKS\n", id());

   // create two jthreads that each call printTask with a string argument
   std::jthread task1{printTask, "Task 1"};
   std::jthread task2{printTask, "Task 2"};

   // put main thread to sleep for 2 seconds 
   std::cout << "\nMAIN GOING TO SLEEP FOR 2 SECONDS\n\n";
   std::this_thread::sleep_for(std::chrono::seconds{2});

   std::cout << std::format("\nMAIN (id: {}) ENDS\n\n", id()); 
}



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_11/CooperativeCancelationFMT.cpp
================================================
// Fig. 17.11: CooperativeCancelation.cpp
// Using a std::jthread's built-in stop_source 
// to request that the std::jthread stop executing.
#include <chrono>
#include <fmt/format.h>
#include <iostream>
#include <mutex>
#include <random>
#include <sstream>
#include <stop_token>
#include <string>
#include <string_view>
#include <thread>

// get current thread's ID as a string
std::string id() {
    std::ostringstream out;
    out << std::this_thread::get_id();
    return out.str();
}

int main() {
   // each printTask iterates until a stop is requested by another thread
   auto printTask{
      [&](std::stop_token token, std::string name) {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{500, 1000};

         // register a function to call when a stop is requested 
         std::stop_callback callback(token, [&]() {
            std::cout << fmt::format(
               "{} told to stop by thread with id {}\n", name, id());
         });

         while (!token.stop_requested()) { // run until stop requested
            auto sleepTime{std::chrono::milliseconds{ints(engine)}};

            std::cout << fmt::format(
               "{} (id: {}) going to sleep for {} ms\n",
               name, id(), sleepTime.count());

            // put thread to sleep for sleepTime milliseconds 
            std::this_thread::sleep_for(sleepTime);

            // show that task woke up 
            std::cout << fmt::format("{} working.\n", name);
         }

         std::cout << fmt::format("{} terminating.\n", name);
      }
   };

   std::cout << fmt::format("MAIN (id: {}) STARTING TASKS\n", id());

   // create two jthreads that each call printTask with a string argument
   std::jthread task1{printTask, "Task 1"};
   std::jthread task2{printTask, "Task 2"};

   // put main thread to sleep for 2 seconds 
   std::cout << "\nMAIN GOING TO SLEEP FOR 2 SECONDS\n\n";
   std::this_thread::sleep_for(std::chrono::seconds{2});

   std::cout << fmt::format("\nMAIN (id: {}) ENDS\n\n", id()); 
}



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_12/async.cpp
================================================
// Fig. 17.12: async.cpp
// Prime-factorization tasks performed in separate threads
#include <cmath>
#include <format>
#include <future> // std::async
#include <iostream>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>

// get current thread's ID as a string
std::string id() {
   std::ostringstream out;
   out << std::this_thread::get_id();
   return out.str();
}

// type alias for vector of factor/count pairs
using Factors = std::vector<std::pair<long long, int>>;

// type alias for a tuple containing a task name,   
// a number, whether the number is prime and its factors 
using FactorResults = std::tuple<std::string, long long, bool, Factors>;

// performs prime factorization   
FactorResults getFactors(std::string name, long long number) {
   std::cout << std::format(
      "{}: Thread {} executing getFactors for {}\n", name, id(), number);

   long long originalNumber{number}; // copy to place in FactorResults
   Factors factors; // vector of factor/count pairs

   // lambda that divides number by a factor and stores factor/count
   auto factorCount{
      [&](int factor) {
         int count{0}; // how many times number is divisible by factor

         // count how many times number is divisible by factor
         while (number % factor == 0) {
            ++count;
            number /= factor;
         }

         // store pair containing the factor and its count
         if (count > 0) {
            factors.push_back({factor, count});
         }
      }
   };

   factorCount(2); // count how many times number is divisible by 2

   // number is now odd; store each factor and its count 
   for (int i{3}; i <= std::sqrt(number); i += 2) {
      factorCount(i); // count how many times number is divisible by i
   }

   // add last prime factor
   if (number > 2) {
      factors.push_back({number, 1});
   }

   bool isPrime{factors.size() == 1 && get<int>(factors[0]) == 1};

   // initialize the FactorResults object returned by getFactors
   return {name, originalNumber, isPrime, factors};
}

// multiply the factors and confirm they reproduce number
void proveFactors(long long number, const Factors& factors) {
   long long proof{1};

   // for each factor/count pair, unpack it then multiply proof 
   // by factor the number of times specified by count
   for (const auto& [factor, count] : factors) {
      for (int i{0}; i < count; ++i) {
         proof *= factor;
      }
   }

   // confirm proof and number are equal
   if (proof == number) {
      std::cout << std::format(
         "\nProduct of factors matches original value ({})\n", proof);
   }
   else {
      std::cout << std::format("\n{} != {}\n", proof, number);
   }
}

// show a task's FactorResults
void displayResults(const FactorResults& results) {
   // unpack results into name (std::string), number (long long), 
   // isPrime (bool) and factors (Factors) 
   const auto& [name, number, isPrime, factors] {results};

   std::cout << std::format("\n{} results:\n", name);

   // display whether value is prime
   if (isPrime) {
      std::cout << std::format("{} is prime\n", number);
   }
   else { // display prime factors
      std::cout << std::format("{}'s prime factors:\n\n", number);
      std::cout << std::format("{:<12}{:<8}\n", "Factor", "Count");

      for (const auto& [factor, count] : factors) {
         std::cout << std::format("{:<12}{:<8}\n", factor, count);
      }
   }

   // if not prime, prove that factors produce the original number 
   if (!isPrime) {
      proveFactors(number, factors);
   }
}

int main() {
   std::cout << "MAIN LAUNCHING TASKS\n";
   auto future1{std::async(std::launch::async,
      getFactors, "Task 1", 1016669006116682993)}; // not prime
   auto future2{std::async(std::launch::async,
      getFactors, "Task 2", 1000000000000000003)}; // prime

   std::cout << "\nWAITING FOR TASK RESULTS\n";

   // wait for results from each task, then display the results    
   displayResults(future1.get());
   displayResults(future2.get());

   std::cout << "\nMAIN ENDS\n";
}


 

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_13/atomic.cpp
================================================
// Fig. 17.13: atomic.cpp
// Incrementing integers from concurrent threads 
// with and without atomics.
#include <atomic>
#include <format>
#include <iostream>
#include <thread>

int main() {
   int count1{0};
   std::atomic<int> atomicCount{0};
   int count2{0};
   std::atomic_ref<int> atomicRefCount{count2};

   {
      std::cout << "Two concurrent threads incrementing int count1, "
         << "atomicCount and atomicRefCount\n\n";

      // lambda to increment counters 
      auto incrementer{
         [&]() {
            for (int i{0}; i < 1000; ++i) {
               ++count1; // no synchronization
               ++atomicCount; // ++ is an atomic operation
               ++atomicRefCount; // ++ is an atomic operation
               std::this_thread::yield(); // force thread to give up CPU
            }
         }
      };

      std::jthread t1{incrementer};
      std::jthread t2{incrementer};
   }

   std::cout << std::format("Final count1: {}\n", count1);
   std::cout << std::format("Final atomicCount: {}\n", 
      atomicCount.load());
   std::cout << std::format("Final count2: {}\n", count2);
}

 

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/


================================================
FILE: examples/lesson17/fig17_14/LatchDemo.cpp
================================================
// Fig. 17.14: LatchDemo.cpp
// Coordinate threads with a std::latch object.
#include <chrono>
#include <format>
#include <iostream>
#include <latch>
#include <random>
#include <string_view>
#include <thread>
#include <vector>

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()};
   std::uniform_int_distribution ints{2000, 3000};

   // latch that 3 threads must signal before the main thread continues
   std::latch mainLatch{3};

   // lambda representing the task to execute
   auto task{
      [&](std::string_view name, std::chrono::milliseconds workTime) {
         std::cout << std::format("Proceeding with {} work for {} ms.\n",
            name, workTime.count());

         // simulate work by sleeping 
         std::this_thread::sleep_for(workTime);

         // show that task arrived at mainLatch
         std::cout << std::format("{} done; signals mainLatch.\n", name);
         mainLatch.count_down();
      }
   };

   std::vector<std::jthread> threads; // stores the threads
   std::cout << "Main starting three jthreads.\n";

   // start three jthreads
   for (int i{1}; i < 4; ++i) {
      // create jthread that calls task lambda, 
      // passing a task name and work time
      threads.push_back(std::jthread{task,
         std::format("Task {}", i),
         std::chrono::milliseconds{ints(engine)}});
   }

   std::cout << "\nMain waiting for jthreads to reach the latch.\n\n";
   mainLatch.wait();

   std::cout << "\nAll jthreads reached the latch. Main working.\n";
   std::cout << "Showing that mainLatch is permanently open.\n";
   mainLatch.wait(); // latch is already open 
   std::cout << "mainLatch is already open. Main continues.\n";
}



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_15/BarrierDemo.cpp
================================================
// Fig. 17.15: BarrierDemo.cpp
// Coordinating threads with a std::barrier object.
#include <barrier>
#include <chrono>
#include <format>
#include <iostream>
#include <random>
#include <string_view>
#include <thread>

int main() {
   // simulate moving car into painting position
   auto moveCarIntoPosition{
      []() {
         std::cout << "Moving next car into painting position.\n";
         std::this_thread::sleep_for(std::chrono::seconds(1)); 
         std::cout << "Car ready for painting.\n\n";
      }
   };

   int carsToPaint{3}; 

   // stop_source used to notify robots assembly line is shutting down
   std::stop_source assemblyLineStopSource;

   // stop_token used by paintingRobotTask to determine when to shut down
   std::stop_token stopToken{assemblyLineStopSource.get_token()};

   // assembly line waits for two painting robots to reach this barrier 
   std::barrier paintingDone{2, 
      [&]() noexcept { // lambda called when robots finish
         static int count{0}; // # of cars that have been painted
         std::cout << "Painting robots completed tasks\n\n";
         
         // check whether it's time to shut down the assembly line
         if (++count == carsToPaint) {
            std::cout << "Shutting down assembly line\n\n";
            assemblyLineStopSource.request_stop(); 
         }
         else { 
            moveCarIntoPosition();
         }
      }
   };

   // lambda that simulates painting work
   auto paintingRobotTask{
      [&](std::string_view name) {
         // set up random-number generation 
         std::random_device rd;
         std::default_random_engine engine{rd()};
         std::uniform_int_distribution ints{2500, 5000};

         // check whether the assembly line is shutting down
         // and, if not, do the painting work
         while (!stopToken.stop_requested()) {
            auto workTime{std::chrono::milliseconds{ints(engine)}};

            std::cout << std::format("{} painting for {} ms\n",
               name, workTime.count());
            std::this_thread::sleep_for(workTime); // simulate work

            // show that task woke up and arrived at continuationBarrier
            std::cout << std::format(
               "{} done painting. Waiting for next car.\n", name);

            // decrement paintingDone barrier's counter and
            // wait for other painting robots to arrive here
            paintingDone.arrive_and_wait(); 
         }

         std::cout << std::format("{} shut down.\n", name);
      }
   };

   moveCarIntoPosition(); // move the first car into position

   // start up two painting robots
   std::cout << "Starting robots.\n\n";
   std::jthread leftSideRobot{paintingRobotTask, "Left side robot"};
   std::jthread rightSideRobot{paintingRobotTask, "Right side robot"};
}


/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_16/SharedBufferTest.cpp
================================================
// Fig. 17.8: SharedBufferTest.cpp
// Concurrent threads correctly manipulating a synchronized buffer.
#include <chrono>
#include <format>
#include <iostream>
#include <mutex>
#include <random>
#include <thread>
#include "SynchronizedBuffer.h"

int main() {
   // set up random-number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()};
   std::uniform_int_distribution ints{0, 3000};
   std::mutex intsMutex;

   // lambda for synchronized random sleep time generation
   auto getSleepTime{
      [&]() {
         std::lock_guard lock{intsMutex};
         return std::chrono::milliseconds{ints(engine)};
      }
   };

   // create SynchronizedBuffer to store ints       
   SynchronizedBuffer buffer;

   // lambda expression that produces the values 1-10 and sums them 
   auto produce{
      [&buffer, &getSleepTime]() {
         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::this_thread::sleep_for(getSleepTime());

            buffer.put(count); // set value in buffer
            sum += count; // add count to sum of values produced
         }

         std::cout << "Producer done producing\nTerminating Producer\n";
      }
   };

   // lambda expression that consumes the values 1-10 and sums them
   auto consume{
      [&buffer, &getSleepTime]() {
         int sum{0};

         for (int count{1}; count <= 10; ++count) {
            // get random sleep time then sleep
            std::this_thread::sleep_for(getSleepTime());

            sum += buffer.get(); // get buffer value and add to sum
         }

         std::cout << std::format("\n{} {}\n{}\n",
            "Consumer read values totaling", sum, "Terminating Consumer");
      }
   };

   std::cout << std::format("{:<40}{}\t\t{}\n{:<40}{}\t\t{}\n\n",
      "Operation", "Buffer", "Occupied",
      "---------", "------", "--------");

   std::jthread producer{produce}; // start producer thread
   std::jthread consumer{consume}; // start consumer thread 
}

/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson17/fig17_16/SynchronizedBuffer.h
================================================
// Fig. 17.16: SynchronizedBuffer.h 
// SynchronizedBuffer using two binary_semaphores to  
// maintain synchronized access to a shared mutable int.
#pragma once
#include <format> 
#include <iostream>
#include <semaphore>
#include <string>

using namespace std::string_literals;

class SynchronizedBuffer {
public:
   // place value into m_buffer
   void put(int value) {
      // acquire m_produce semaphore to be able to write to m_buffer
      m_produce.acquire(); // blocks if it's not the producer's turn 

      m_buffer = value; // write to m_buffer
      m_occupied = true;

      std::cout << std::format("{:<40}{}\t\t{}\n",
         "Producer writes "s + std::to_string(value),
         m_buffer, m_occupied);

      m_consume.release(); // allow consumer to read
   }

   // return value from m_buffer
   int get() {
      int value; // will store the value returned by get

      // acquire m_consume semaphore to be able to read from m_buffer
      m_consume.acquire(); // blocks if it's not the consumer's turn

      value = m_buffer; // read from m_buffer
      m_occupied = false;

      std::cout << std::format("{:<40}{}\t\t{}\n",
         "Consumer reads "s + std::to_string(m_buffer),
         m_buffer, m_occupied);

      m_produce.release(); // allow producer to write
      return value;
   }
private:
   std::binary_semaphore m_produce{1}; // producer can produce
   std::binary_semaphore m_consume{0}; // consumer can't consume
   bool m_occupied{false};
   int m_buffer{-1}; // shared by producer and consumer threads
};



/************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and             *
 * Pearson Education, Inc. All Rights Reserved.                         *
 *                                                                      *
 * DISCLAIMER: The authors and publisher of this book have used their   *
 * best efforts in preparing the book. These efforts include the        *
 * development, research, and testing of the theories and programs      *
 * to determine their effectiveness. The authors and publisher make     *
 * no warranty of any kind, expressed or implied, with regard to these  *
 * programs or to the documentation contained in these books. The       *
 * authors and publisher shall not be liable in any event for           *
 * incidental or consequential damages in connection with, or arising   *
 * out of, the furnishing, performance, or use of these programs.       *
 ***********************************************************************/



================================================
FILE: examples/lesson18/fig18_01.cpp
================================================
// fig18_01.cpp
// Creating a generator coroutine with co_yield.
#include <fmt/format.h>
#include <iostream>
#include <sstream>
#include <thread> 
#include <tl/generator.hpp>

// get current thread's ID as a string
std::string id() {
   std::ostringstream out;
   out << std::this_thread::get_id();
   return out.str();
}

// coroutine that repeatedly yields the next Fibonacci value in sequence
tl::generator<int> fibonacciGenerator(int limit) {
   std::cout << fmt::format(
      "Thread {}: fibonacciGenerator started executing\n", id());

   int value1{0}; // Fibonacci(0)
   int value2{1}; // Fibonacci(1)

   for (int i{0}; i < limit; ++i) {
      co_yield value1; // yield current value of value1

      // update value1 and value2 for next iteration
      int temp{value1 + value2};
      value1 = value2;
      value2 = temp;
   }

   std::cout << fmt::format(
      "Thread {}: fibonacciGenerator finished executing\n", id());
}

int main() {
   std::cout << fmt::format("Thread {}: main begins\n", id());

   // display first 10 Fibonacci values 
   for (int i{0}; auto value : fibonacciGenerator(10)) {
      std::cout << fmt::format("Fibonacci({}) is {}\n", i++, value);
   }  

   std::cout << fmt::format("Thread {}: main ends\n", id());
}




/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson18/fig18_02.cpp
================================================
// fig18_02.cpp
// Setting up the concurrencpp::runtime and scheduling tasks with it.
#include <chrono>
#include <concurrencpp/concurrencpp.h>
#include <fmt/format.h>
#include <iostream>
#include <random>
#include <sstream>
#include <thread>
#include <vector>

// get current thread's ID as a string
std::string id() {
    std::ostringstream out;
    out << std::this_thread::get_id();
    return out.str();
}

// Function printTask sleeps for a specified period in milliseconds. 
// When it continues executing, it prints its name and completes.
void printTask(std::string name, std::chrono::milliseconds sleep) {
   std::cout << fmt::format(
      "{} (thread ID: {}) going to sleep for {} ms\n",
      name, id(), sleep.count());

   // put the calling thread to sleep for sleep milliseconds 
   std::this_thread::sleep_for(sleep);

   std::cout << fmt::format("{} (thread ID: {}) done sleeping\n",
      name, id());
}

int main() {
   // set up the concurrencpp runtime for scheduling tasks to execute
   concurrencpp::runtime runtime;

   std::cout << fmt::format("main's thread ID: {}\n\n", id());

   // set up random number generation for random sleep times
   std::random_device rd;
   std::default_random_engine engine{rd()};
   std::uniform_int_distribution ints{0, 5000};

   // stores the tasks so we can wait for them to complete later;
   // concurrencpp::result<void> indicates that each task returns void
   std::vector<concurrencpp::result<void>> results;

   std::cout << "STARTING THREE CONCURRENCPP TASKS\n";

   // schedule three tasks
   for (int i{1}; i < 4; ++i) {
      std::chrono::milliseconds sleepTime{ints(engine)};
      std::string name{fmt::format("Task {}", i)};

      // use a concurrencpp thread_pool_executor to schedule a call
      // to printTask with name and sleepTime as its arguments
      results.push_back(runtime.thread_pool_executor()->submit(
         printTask, name, sleepTime));
   }

   std::cout << "\nALL TASKS STARTED\n";
   std::cout << "\nWAITING FOR TASKS TO COMPLETE\n";
  
   // wait for each task to complete
   for (auto& result : results) {
      result.get(); // wait for each task to return its result
   } 

   std::cout << fmt::format("main's thread ID: {}\nMAIN ENDS\n", id());
}




/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson18/fig18_03.cpp
================================================
// fig18_03.cpp
// Implementing a coroutine with co_await and co_return.
#include <concurrencpp/concurrencpp.h>
#include <fmt/format.h>
#include <iostream>
#include <memory> // for shared_ptr
#include <random>
#include <sstream>
#include <string>
#include <thread>
#include <vector>

// get current thread's ID as a string
std::string id() {
   std::ostringstream out;
   out << std::this_thread::get_id();
   return out.str();
}

// coroutine that sorts a vector<int> using two tasks 
concurrencpp::result<void> sortCoroutine(
   std::shared_ptr<concurrencpp::thread_pool_executor> executor,
   std::vector<int>& values) {

   std::cout << fmt::format("Thread {}: sortCoroutine started\n\n", id());

   // lambda that sorts a portion of a vector
   auto sortTask{
      [&](auto begin, auto end) {
         std::cout << fmt::format(
            "Thread {}: Sorting {} elements\n", id(), end - begin);
         std::sort(begin, end); 
         std::cout << fmt::format("Thread {}: Finished sorting\n", id());
      }
   };

   // stores task results
   std::vector<concurrencpp::result<void>> results;

   size_t middle{values.size() / 2}; // middle element index

   std::cout << fmt::format(
      "Thread {}: sortCoroutine starting first half sortTask\n", id());

   // use a concurrencpp thread_pool_executor to schedule 
   // a sortTask call that sorts the first half of values
   results.push_back(
      executor->submit(
         [&]() {sortTask(values.begin(), values.begin() + middle);}
      )
   );

   std::cout << fmt::format(
      "Thread {}: sortCoroutine starting second half sortTask\n", id());

   // use a concurrencpp thread_pool_executor to schedule 
   // a sortTask call that sorts the second half of values
   results.push_back(
      executor->submit(
         [&]() {sortTask(values.begin() + middle, values.end());}
      )
   );

   // suspend coroutine while waiting for all sortTasks to complete 
   std::cout << fmt::format("\nThread {}: {}\n", id(),
      "sortCoroutine co_awaiting sortTask completion");
   co_await concurrencpp::when_all(
      executor, results.begin(), results.end());

   // merge the two sorted sub-vectors
   std::cout << fmt::format(
      "\nThread {}: sortCoroutine merging results\n", id());
   std::inplace_merge(
      values.begin(), values.begin() + middle, values.end());

   std::cout << fmt::format("Thread {}: sortCoroutine done\n", id());
   co_return; // terminate coroutine and resume caller
}

int main() {
   concurrencpp::runtime runtime; // set up concurrencpp runtime
   auto executor{runtime.thread_pool_executor()}; // get the executor

   // set up random number generation 
   std::random_device rd;
   std::default_random_engine engine{rd()};
   std::uniform_int_distribution ints;

   std::cout << fmt::format(
      "Thread {}: main creating vector of random ints\n", id());
   std::vector<int> values(100'000'000);
   std::ranges::generate(values, [&]() {return ints(engine);});

   std::cout << fmt::format(
      "Thread {}: main starting sortCoroutine\n", id());
   auto result{sortCoroutine(executor, values)};

   std::cout << fmt::format("\nThread {}: {}\n", id(),
     "main resumed. Waiting for sortCoroutine to complete.");
   result.get(); // wait for sortCoroutine to complete

   std::cout << fmt::format(
      "\nThread {}: main confirming that vector is sorted\n", id());
   bool sorted{std::ranges::is_sorted(values)};
   std::cout << fmt::format("Thread {}: values is{} sorted\n", 
      id(), sorted ? "" : " not");
}




/**************************************************************************
 * (C) Copyright 1992-2021 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson18/vcpkg.json
================================================
{
  "name": "cpp20-test",
  "version-string": "1.0.0",
  "dependencies": [
    "concurrencpp"
  ]
}


================================================
FILE: examples/lesson19/fig19_01.cpp
================================================
// fig19_01.cpp
// Printing the address stored in a char* variable.
#include <iostream>

int main() {
   const char* const word{"again"};

   // display the value of char* variable word, then display 
   // the value of word after a static_cast to void*
   std::cout << "Value of word is: " << word 
      << "\nValue of static_cast<const void*>(word) is: " 
      << static_cast<const void*>(word) << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_02.cpp
================================================
// fig19_02.cpp 
// get, put and eof member functions.
#include <format>
#include <iostream>

int main() {
   int character{0}; // use int, because char cannot represent EOF

   // prompt user to enter line of text
   std::cout << std::format("Before input, cin.eof(): {}", std::cin.eof())
      << "\nEnter a sentence followed by Enter and end-of-file:\n";

   // use get to read each character; use put to display it
   while ((character = std::cin.get()) != EOF) {
      std::cout.put(character);
   }

   // display end-of-file character
   std::cout << std::format("\nEOF on this system is: {}\n", character)
      << std::format("After EOF input, cin.eof(): {}\n", std::cin.eof());
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_03.cpp
================================================
// fig19_03.cpp 
// Contrasting input of a string via cin and cin.get.
#include <format>
#include <iostream>

int main() {
   // create two char arrays, each with 80 elements
   constexpr int size{80};
   char buffer1[size]{}; 
   char buffer2[size]{};

   // use cin to input characters into buffer1
   std::cout << "Enter a sentence:\n";
   std::cin >> buffer1;

   // display buffer1 contents
   std::cout << std::format("\nThe cin input was:\n{}\n\n", buffer1);
 
   // use cin.get to input characters into buffer2
   std::cin.get(buffer2, size);

   // display buffer2 contents
   std::cout << std::format("The cin.get input was:\n{}\n", buffer2);
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_04.cpp
================================================
// fig19_04.cpp 
// Inputting characters using cin member function getline.
#include <format>
#include <iostream>

int main() {
   const int size{80};
   char buffer[size]{}; // create array of 80 characters

   // input characters in buffer via cin function getline
   std::cout << "Enter a sentence:\n";
   std::cin.getline(buffer, size);

   // display buffer contents
   std::cout << std::format("\nYou entered:\n{}\n", buffer);
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_05.cpp
================================================
// fig19_05.cpp 
// Unformatted I/O using read, gcount and write.
#include <iostream>

int main() {
   char buffer[80]{}; // create array of 80 characters

   // use function read to input characters into buffer
   std::cout << "Enter a sentence:\n";
   std::cin.read(buffer, 20);

   // use functions write and gcount to display buffer characters
   std::cout << "\nThe sentence entered was:\n";
   std::cout.write(buffer, std::cin.gcount());
   std::cout << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_06.cpp
================================================
// fig19_06.cpp 
// Using stream manipulators dec, oct, hex and setbase.
#include <iomanip>
#include <iostream>

int main() {
   int number{0};

   std::cout << "Enter a decimal number: ";
   std::cin >> number; // input number

   // use hex stream manipulator to show hexadecimal number
   std::cout << number << " in hexadecimal is: "
      << std::hex << number << "\n";

   // use oct stream manipulator to show octal number
   std::cout << std::dec << number << " in octal is: "
      << std::oct << number << "\n";

   // use setbase stream manipulator to show decimal number
   std::cout << std::setbase(10) << number << " in decimal is: "
      << number << "\n";
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_07.cpp
================================================
// fig19_07.cpp 
// Controlling precision of floating-point values.
#include <iomanip>      
#include <iostream>
#include <cmath> 

int main() {
   double root2{std::sqrt(2.0)}; // calculate square root of 2

   std::cout << "Square root of 2 with precisions 0-9.\n"
      << "Precision set by ostream member function precision:\n";
   std::cout << std::fixed; // use fixed-point notation

   // display square root using ostream function precision
   for (int places{0}; places <= 9; ++places) {
      std::cout.precision(places);
      std::cout << root2 << "\n";
   } 

   std::cout << "\nPrecision set by stream manipulator setprecision:\n"; 

   // set precision for each digit, then display square root
   for (int places{0}; places <= 9; ++places) {
      std::cout << std::setprecision(places) << root2 << "\n";
   } 
} 




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_08.cpp
================================================
// fig19_08.cpp 
// width member function of classes istream and ostream.
#include <iostream>

int main() {
   int widthValue{4};
   char sentence[10]{};

   std::cout << "Enter a sentence:\n";
   std::cin.width(5); // input up to 4 characters from sentence

   // set field width, then display characters based on that width 
   while (std::cin >> sentence) {
      std::cout.width(widthValue++);
      std::cout << sentence << "\n";
      std::cin.width(5); // input up to 4 more characters from sentence
   } 
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_09.cpp
================================================
// fig19_09.cpp
// Creating and testing user-defined, nonparameterized 
// stream manipulators.
#include <iostream>

// bell manipulator (using escape sequence \a)
std::ostream& bell(std::ostream& output) {             
   return output << '\a'; // issue system beep
}

// tab manipulator (using escape sequence \t)
std::ostream& tab(std::ostream& output) {            
   return output << '\t'; // issue tab 
}

int main() {
   // use tab and bell manipulators
   std::cout << "Testing the tab manipulator:\n"
      << 'a' << tab << 'b' << tab << 'c' << '\n';

   std::cout << "Testing the bell manipulator\n" << bell;
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_10.cpp
================================================
// fig19_10.cpp 
// Displaying trailing zeros and decimal points in floating-point values.
#include <iostream>

int main() {
   // display double values with default stream format
   std::cout << "Before using showpoint"
      << "\n9.9900 prints as: " << 9.9900 
      << "\n9.9000 prints as: " << 9.9000 
      << "\n9.0000 prints as: " << 9.0000;

   // display double value after showpoint
   std::cout << std::showpoint
      << "\n\nAfter using showpoint" 
      << "\n9.9900 prints as: " << 9.9900 
      << "\n9.9000 prints as: " << 9.9000 
      << "\n9.0000 prints as: " << 9.0000 << '\n';
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_11.cpp
================================================
// fig19_11.cpp 
// Left and right alignment with stream manipulators left and right.
#include <iomanip>
#include <iostream>

int main() {
   int x{12345};

   // display x right aligned (default)
   std::cout << "Default is right aligned:\n\""
      << std::setw(10) << x << "\"";

   // use left manipulator to display x left aligned
   std::cout << "\n\nUse left to left align x:\n\""
      << std::left << std::setw(10) << x << "\"";

   // use right manipulator to display x right aligned
   std::cout << "\n\nUse right to right align x:\n\""
      << std::right << std::setw(10) << x << "\"\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_12.cpp
================================================
// fig19_12.cpp 
// Printing an integer with internal spacing and plus sign.
#include <iomanip>
#include <iostream>

int main() {
   // display value with internal spacing and plus sign
   std::cout << std::internal << std::showpos 
      << std::setw(10) << 123 << "\n";
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_13.cpp
================================================
// fig19_13.cpp 
// Using member function fill and stream manipulator setfill to change
// the padding character for fields larger than the printed value.
#include <iomanip>
#include <iostream>

int main() {
   int x{10000};

   // display x
   std::cout << x << " printed as int right and left aligned\n"
      << "and as hex with internal alignment.\n"
      << "Using the default pad character (space):\n";

   // display x 
   std::cout << std::setw(10) << x << "\n";

   // display x with left alignment
   std::cout << std::left << std::setw(10) << x << "\n";

   // display x with base as hex with internal alignment
   std::cout << std::showbase << std::internal << std::setw(10) 
      << std::hex << x << "\n\n";

   std::cout << "Using various padding characters:\n";

   // display x using padded characters (right alignment)
   std::cout << std::right;
   std::cout.fill('*');
   std::cout << std::setw(10) << std::dec << x << "\n";

   // display x using padded characters (left alignment)
   std::cout << std::left << std::setw(10) << std::setfill('%') 
      << x << "\n";

   // display x using padded characters (internal alignment)
   std::cout << std::internal << std::setw(10) 
      << std::setfill('^') << std::hex << x << "\n";
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_14.cpp
================================================
// fig19_14.cpp 
// Stream manipulator showbase.
#include <iostream>

int main() {
   int x{100};

   // use showbase to show number base
   std::cout << "Printing octal and hexadecimal values with showbase:\n" 
      << std::showbase;

   std::cout << x << "\n"; // print decimal value
   std::cout << std::oct << x << "\n"; // print octal value
   std::cout << std::hex << x << "\n"; // print hexadecimal value
} 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_15.cpp
================================================
// fig19_15.cpp 
// Floating-point values displayed in system default,
// scientific and fixed formats.
#include <iostream>

int main() {
   double x{0.001234567};
   double y{1.946e9};

   // display x and y in default format
   std::cout << "Displayed in default format:\n" << x << '\t' << y;

   // display x and y in scientific format
   std::cout << "\n\nDisplayed in scientific format:\n"
      << std::scientific << x << '\t' << y;

   // display x and y in fixed format
   std::cout << "\n\nDisplayed in fixed format:\n"
      << std::fixed << x << '\t' << y << "\n";
} 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_16.cpp
================================================
// fig19_16.cpp 
// Stream manipulator uppercase.
#include <iostream>

int main() {
   std::cout << "Printing uppercase letters in scientific\n"
      << "notation exponents and hexadecimal values:\n";

   // use std::uppercase to display uppercase letters; use std::hex and 
   // std::showbase to display hexadecimal value and its base
   std::cout << std::uppercase << 4.345e10 << "\n" 
      << std::hex << std::showbase << 123456789 << "\n";
} 




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_17.cpp
================================================
// fig19_17.cpp
// Stream manipulators boolalpha and noboolalpha.
#include <iostream>

int main() {
   bool booleanValue{true};

   // display default true booleanValue
   std::cout << "booleanValue is " << booleanValue;

   // display booleanValue after using boolalpha
   std::cout << "\nbooleanValue (after using boolalpha) is "
      << std::boolalpha << booleanValue;

   std::cout << "\n\nswitch booleanValue and use noboolalpha\n";
   booleanValue = false; // change booleanValue
   std::cout << std::noboolalpha; // use noboolalpha

   // display default false booleanValue after using noboolalpha
   std::cout << "\nbooleanValue is " << booleanValue;

   // display booleanValue after using boolalpha again
   std::cout << "\nbooleanValue (after using boolalpha) is "
      << std::boolalpha << booleanValue << "\n";
} 





/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_18.cpp
================================================
// fig19_18.cpp 
// flags member function.
#include <format>
#include <iostream>

int main() {
   int integerValue{1000};
   double doubleValue{0.0947628};

   // display flags value, int and double values (original format)
   std::cout << std::format("flags value: {}\n", std::cout.flags())
      << "int and double in original format:\n"
      << integerValue << '\t' << doubleValue << "\n\n";

   // save original format, then change the format
   auto originalFormat{std::cout.flags()};
   std::cout << std::showbase << std::oct << std::scientific;

   // display flags value, int and double values (new format)
   std::cout << std::format("flags value: {}\n", std::cout.flags())
      << "int and double in new format:\n"
      << integerValue << '\t' << doubleValue << "\n\n";

   std::cout.flags(originalFormat); // restore format

   // display flags value, int and double values (original format)
   std::cout << std::format("flags value: {}\n", std::cout.flags())
      << "int and double in original format:\n"
      << integerValue << '\t' << doubleValue << "\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_19.cpp
================================================
// fig19_19.cpp 
// Testing error states.
#include <iostream>

int main() {
   int integerValue{0};

   // display results of cin functions
   std::cout << std::boolalpha << "Before a bad input operation:"
      << "\ncin.rdstate(): " << std::cin.rdstate()
      << "\n    cin.eof(): " << std::cin.eof()
      << "\n   cin.fail(): " << std::cin.fail()
      << "\n    cin.bad(): " << std::cin.bad() 
      << "\n   cin.good(): " << std::cin.good()
      << "\n\nExpects an integer, but enter a character: ";

   std::cin >> integerValue; // enter character value

   // display results of cin functions after bad input
   std::cout << "\nAfter a bad input operation:"
      << "\ncin.rdstate(): " << std::cin.rdstate()
      << "\n    cin.eof(): " << std::cin.eof() 
      << "\n   cin.fail(): " << std::cin.fail()
      << "\n    cin.bad(): " << std::cin.bad()
      << "\n   cin.good(): " << std::cin.good();

   std::cin.clear(); // clear stream

   // display results of cin functions after clearing cin
   std::cout << "\n\nAfter cin.clear()" 
      << "\ncin.fail(): " << std::cin.fail()
      << "\ncin.good(): " << std::cin.good() << "\n";
} 


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_20.cpp
================================================
// fig19_20.cpp 
// C++20 text-formatting presentation types.
#include <format>
#include <iostream>

int main() {
   // floating-point presentation types
   std::cout << "Display 17.489 with default, .1 and .2 precisions:\n"
      << std::format("f: {0:f}\n.1f: {0:.1f}\n.2f: {0:.2f}\n\n", 17.489);

   std::cout << "Display 10000000000000000.0 with f, e, g and a\n"
      << std::format("f: {0:f}\ne: {0:e}\ng: {0:g}\na: {0:a}\n\n", 
            10000000000000000.0);

   // integer presentation types; # displays a base prefix
   std::cout << "Display 100 with d, #b, #o and #x:\n"
      << std::format(
            "d: {0:d}\n#b: {0:#b}\n#o: {0:#o}\n#x: {0:#x}\n\n", 100);

   // character presentation type
   std::cout << "Display 65 and 97 with c:\n"
      << std::format("{:c} {:c}\n\n", 65, 97);

   // string presentation type
   std::cout << "Display \"hello\" with s:\n" 
      << std::format("{:s}\n", "hello");
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_21.cpp
================================================
// fig19_21.cpp 
// C++20 text-formatting with field widths and alignment.
#include <format>
#include <iostream>

int main() {
   std::cout << "Default alignment with field width 10:\n"
      << std::format("[{:10d}]\n[{:10f}]\n[{:10}]\n\n", 27, 3.5, "hello");
   
   std::cout << "Specifying left or right alignment in a field:\n"
      << std::format("[{:<15d}]\n[{:<15f}]\n[{:>15}]\n\n", 
            27, 3.5, "hello");

   std::cout << "Centering text in a field:\n"
      << std::format("[{:^7d}]\n[{:^7.1f}]\n[{:^7}]\n", 27, 3.5, "hello");
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_22.cpp
================================================
// fig19_22.cpp 
// C++20 text-formatting numeric formatting options.
#include <format>
#include <iostream>

int main() {
   std::cout << "Displaying signs and padding with leading 0s:\n"
      << std::format("[{0:+10d}]\n[{0:+010d}]\n\n", 27);

   std::cout << "Displaying a space before a positive value:\n"
      << std::format("{0:d}\n{0: d}\n{1: d}\n\n", 27, -27);
   
   std::cout << "Displaying a base indicator before a number:\n"
      << std::format("{0:d}\n{0:#b}\n{0:#o}\n{0:#x}\n", 100);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson19/fig19_23.cpp
================================================
// fig19_23.cpp 
// C++20 text-formatting field width and precision placeholders.
#include <format>
#include <iostream>

int main() {
   std::cout << "Demonstrating field width and precision placeholders:\n";

   double value{123.456};
   int width{8};

   for (int precision{0}; precision < 5; ++precision) {
      std::cout << std::format("{:{}.{}f}\n", value, width, precision);
   }
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_01.cpp
================================================
// fig20_01.cpp
// Demonstrating const_cast.
#include <cctype> // contains prototype for function toupper
#include <iostream>
#include <string>

// returns the larger of two strings
const std::string& maximum(
   const std::string& first, const std::string& second) {
   return (first > second ? first : second);
}

int main() {
   std::string s1{"hello"}; // non-const string
   std::string s2{"goodbye"}; // non-const string

   // const_cast required to allow the const reference returned by 
   // maximum to be assigned to the std::string reference max
   std::string& max{const_cast<std::string&>(maximum(s1, s2))};

   std::cout << "The larger string is: " << max << "\n";

   for (char& character : max) {
      character = std::toupper(character);
   }

   std::cout << "The larger string capitalized is: " << max << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_02.cpp
================================================
// fig20_02.cpp
// Demonstrating storage-class specifier mutable.
#include <iostream>

// class TestMutable definition
class TestMutable {
public:
   TestMutable(int v = 0) : value{v} {}

   int getValue() const {
      return ++value; // increments value
   }
private:
   mutable int value; // mutable member
};

int main() {
   const TestMutable test{99};

   std::cout << "Initial value: " << test.getValue()
      << "\nModified value: " << test.getValue() << "\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_03.cpp
================================================
// fig20_03.cpp
// Demonstrating namespaces.
#include <fmt/format.h>
#include <iostream>

int integer1{98}; // global variable

// create namespace Example                           
namespace Example {
   // declare two constants and one variable          
   const double pi{3.14159};
   const double e{2.71828};
   int integer1{8};

   void printValues(); // prototype                   

   // nested namespace                                
   namespace Inner {
      // define enumeration                           
      enum Years { fiscal1 = 2020, fiscal2, fiscal3 };
   }
}

// create unnamed namespace                           
namespace {
   double doubleInUnnamed{88.22}; // declare variable
}

int main() {
   // output value doubleInUnnamed of unnamed namespace
   std::cout << fmt::format("doubleInUnnamed = {}\n", doubleInUnnamed);

   // output global variable
   std::cout << fmt::format("(global) integer1 = {}\n", integer1);

   // output values of Example namespace
   std::cout << fmt::format(
      "pi = {}\ne = {}\ninteger1 = {}\nfiscal3 = {}\n", Example::pi,
      Example::e, Example::integer1, Example::Inner::fiscal3);

   Example::printValues(); // invoke printValues function
}

// display variable and constant values
void Example::printValues() {
   std::cout << "\nIn printValues:\n";
   std::cout << fmt::format(
      "integer1 = {}\npi = {}\ne = {}\n", integer1, pi, e);
   std::cout << fmt::format(
      "doubleInUnnamed = {}\n(global) integer1 = {}\nfiscal3 = {}\n",
      doubleInUnnamed, ::integer1, Inner::fiscal3);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_04.cpp
================================================
// fig20_04.cpp
// Demonstrating operator keywords.
#include <fmt/format.h>
#include <iostream>

int main() {
   bool a{true};
   bool b{false};

   std::cout << fmt::format("a = {}; b = {}\n\n", a, b);

   std::cout << "Logical operator keywords:\n"
      << fmt::format("   a and a: {}\n", a and a)
      << fmt::format("   a and b: {}\n", a and b)
      << fmt::format("    a or a: {}\n", a or a)
      << fmt::format("    a or b: {}\n", a or b)
      << fmt::format("     not a: {}\n", not a)
      << fmt::format("     not b: {}\n", not b)
      << fmt::format("a not_eq b: {}\n", a not_eq b);
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_05.cpp
================================================
// fig20_05.cpp
// Demonstrating operators .* and ->*.
#include <iostream>

// class Test definition
class Test {
public:
   Test(int x) : value{x} {};

   void testFunction() {
      std::cout << "testFunction called\n";
   }

   int value; // public data member
};

void arrowStar(Test* ptr); // prototype
void dotStar(Test* ptr); // prototype

int main() {
   Test test{8};
   arrowStar(&test); // pass address to arrowStar
   dotStar(&test); // pass address to dotStar
}

// access member function of Test object using ->*
void arrowStar(Test* ptr) {
   auto functionPtr{&Test::testFunction}; // pointer to a member function
   (ptr->*functionPtr)(); // invoke function indirectly              
}

// access members of Test object data member using .*
void dotStar(Test* ptr) {
   auto valuePtr{&Test::value}; // pointer to a data member  
   std::cout << "value is " << (*ptr).*valuePtr << "\n"; // access value
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/CommissionEmployee.cpp
================================================
// Fig. 10.16: CommissionEmployee.cpp
// CommissionEmployee class member-function definitions.
#include <fmt/format.h>
#include <stdexcept>
#include "CommissionEmployee.h" // CommissionEmployee class definition

// constructor                                                        
CommissionEmployee::CommissionEmployee(std::string_view name, 
   double grossSales, double commissionRate) : Employee{name} {
   setGrossSales(grossSales); 
   setCommissionRate(commissionRate); 
}                                      

// set gross sales amount
void CommissionEmployee::setGrossSales(double grossSales) {
   if (grossSales < 0.0) {
      throw std::invalid_argument("Gross sales must be >= 0.0");
   } 

   m_grossSales = grossSales;
} 

// return gross sales amount
double CommissionEmployee::getGrossSales() const {return m_grossSales;}

// set commission rate
void CommissionEmployee::setCommissionRate(double commissionRate) {
   if (commissionRate <= 0.0 || commissionRate >= 1.0) {
      throw std::invalid_argument(
         "Commission rate must be > 0.0 and < 1.0");
   } 

   m_commissionRate = commissionRate;
} 

// return commission rate
double CommissionEmployee::getCommissionRate() const {
   return m_commissionRate;
} 

// calculate earnings                        
double CommissionEmployee::earnings() const {
   return getGrossSales() * getCommissionRate();
}                                            

// return string representation of CommissionEmployee object        
std::string CommissionEmployee::toString() const {                       
   return fmt::format("{}\n{}: ${:.2f}\n{}: {:.2f}", Employee::toString(),
      "gross sales", getGrossSales(),
      "commission rate", getCommissionRate());                  
}                                                                   

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/CommissionEmployee.h
================================================
// Fig. 10.15: CommissionEmployee.h
// CommissionEmployee class derived from Employee.
#pragma once
#include <string> 
#include <string_view> 
#include "Employee.h" // Employee class definition

class CommissionEmployee final : public Employee {
public:
   CommissionEmployee(std::string_view name, double grossSales,
      double commissionRate);
   virtual ~CommissionEmployee() = default; // virtual destructor

   void setGrossSales(double grossSales);
   double getGrossSales() const;

   void setCommissionRate(double commissionRate);
   double getCommissionRate() const;

   // keyword override signals intent to override                 
   double earnings() const override; // calculate earnings        
   std::string toString() const override; // string representation
private:
   double m_grossSales{0.0};
   double m_commissionRate{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/Employee.cpp
================================================
// Fig. 10.12: Employee.cpp
// Abstract-base-class Employee member-function definitions.
// Note: No definitions are given for pure virtual functions.
#include <fmt/format.h>
#include "Employee.h" // Employee class definition

// constructor                                                        
Employee::Employee(std::string_view name) : m_name{name} {} // empty body

// set name
void Employee::setName(std::string_view name) {m_name = name;}

// get name
std::string Employee::getName() const {return m_name;}

// return string representation of an Employee
std::string Employee::toString() const {                       
   return fmt::format("name: {}", getName());
}                                                                   
                                                                                                                 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/Employee.h
================================================
// Fig. 10.11: Employee.h
// Employee abstract base class.
#pragma once // prevent multiple inclusions of header
#include <string> 
#include <string_view> 

class Employee {
public:
   explicit Employee(std::string_view name);
   virtual ~Employee() = default; // compiler generates virtual destructor

   void setName(std::string_view name);
   std::string getName() const;

   // pure virtual function makes Employee an abstract base class
   virtual double earnings() const = 0; // pure virtual
   virtual std::string toString() const; // virtual
private:
   std::string m_name;
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/SalariedEmployee.cpp
================================================
// Fig. 10.14: SalariedEmployee.cpp
// SalariedEmployee class member-function definitions.
#include <fmt/format.h>
#include <stdexcept>
#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor 
SalariedEmployee::SalariedEmployee(std::string_view name, double salary)
   : Employee{name} {
   setSalary(salary); 
} 

// set salary
void SalariedEmployee::setSalary(double salary) {
   if (salary < 0.0) {
      throw std::invalid_argument("Weekly salary must be >= 0.0");
   } 

   m_salary = salary;
} 

// return salary
double SalariedEmployee::getSalary() const {return m_salary;}

// calculate earnings; 
// override pure virtual function earnings in Employee
double SalariedEmployee::earnings() const {return getSalary();}

// return a string representation of SalariedEmployee
std::string SalariedEmployee::toString() const {
   return fmt::format("{}\n{}: ${:.2f}", Employee::toString(), 
      "salary", getSalary());
} 

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/SalariedEmployee.h
================================================
// Fig. 10.13: SalariedEmployee.h
// SalariedEmployee class derived from Employee.
#pragma once
#include <string> // C++ standard string class
#include <string_view> 
#include "Employee.h" // Employee class definition

class SalariedEmployee final : public Employee {
public:
   SalariedEmployee(std::string_view name, double salary);
   virtual ~SalariedEmployee() = default; // virtual destructor

   void setSalary(double salary);
   double getSalary() const;

   // keyword override signals intent to override               
   double earnings() const override; // calculate earnings        
   std::string toString() const override; // string representation
private:
   double m_salary{0.0};
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_06/fig20_06.cpp
================================================
// fig20_06.cpp
// Demonstrating downcasting and runtime type information (RTTI). 
#include <fmt/format.h> 
#include <iostream>
#include <typeinfo>
#include <vector>
#include "Employee.h"
#include "SalariedEmployee.h" 
#include "CommissionEmployee.h"  

int main() {
   // create derived-class objects                        
   SalariedEmployee salaried{"John Smith", 800.0}; 
   CommissionEmployee commission{"Sue Jones", 10000.0, .06};

   // create and initialize vector of base-class pointers        
   std::vector<Employee*> employees{&salaried, &commission};
 
   // polymorphically process each element in vector employees
   for (Employee* employeePtr : employees) {
      std::cout << fmt::format("{}\n", employeePtr->toString());

      // determine whether employeePtr points to a SalariedEmployee; 
      // if not, dynamic_cast returns nullptr which evaluates to false
      if (auto ptr{dynamic_cast<SalariedEmployee*>(employeePtr)}) {
         double oldBaseSalary = ptr->getSalary();
         std::cout << fmt::format("old salary: ${:.2f}\n", oldBaseSalary);
         ptr->setSalary(1.10 * oldBaseSalary);
         std::cout << fmt::format(
            "new salary with 10% increase is: ${:.2f}\n",
            ptr->getSalary());
      } 
      
      std::cout << fmt::format("earned ${:.2f}\n\n", 
         employeePtr->earnings());
   } 
 
   // display each objects type
   for (const Employee* employeePtr : employees) {
      std::cout << fmt::format("{}\n", typeid(*employeePtr).name());
   } 
} 



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_07.cpp
================================================
// fig20_07.cpp
// [[nodiscard]] attribute.

[[nodiscard("Do not ignore! Otherwise, you won't know the cube of x.")]]
int cube(int x) {
   return x * x * x;
}

int main() {
   cube(10); // generates a compiler warning
}

/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_08.cpp
================================================
// fig20_08.cpp
// Demonstrate shared_ptrs.
#include <algorithm>
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <vector>

// class Book
class Book {
public:
   explicit Book(std::string_view bookTitle) : title{bookTitle} {}
   ~Book() { std::cout << fmt::format("Destroying Book: {}\n", title); }
   std::string title; // title of the Book
};

// a custom delete function for a pointer to a Book
void deleteBook(Book* book) {
   std::cout << "Custom deleter for a Book, ";
   delete book; // delete the Book pointer
}

// compare the titles of two Books for sorting
bool compareTitles(
   std::shared_ptr<Book> ptr1, std::shared_ptr<Book> ptr2) {
   return (ptr1->title < ptr2->title);
}

int main() {
   // create a shared_ptr to a Book and display the reference count
   std::shared_ptr<Book> bookPtr{
      std::make_shared<Book>("C++ How to Program")};
   std::cout << fmt::format("Reference count for Book {} is: {}\n",
      bookPtr->title, bookPtr.use_count());

   // create another shared_ptr to the Book and display reference count
   std::shared_ptr<Book> bookPtr2{bookPtr};
   std::cout << fmt::format("Reference count for Book {} is: {}\n",
      bookPtr->title, bookPtr.use_count());

   // change the Books title and access it from both pointers
   bookPtr2->title = "Java How to Program";
   std::cout << fmt::format(
      "Updated Book title:\nbookPtr: {}\nbookPtr2: {}\n",
      bookPtr->title, bookPtr2->title);

   // create a std::vector of shared_ptrs to Books (BookPtrs)
   std::vector<std::shared_ptr<Book>> books{
      std::make_shared<Book>("C How to Program"),
      std::make_shared<Book>("Intro to Python"),
      std::make_shared<Book>("C# How to Program"),
      std::make_shared<Book>("C++ How to Program")};

   // print the Books in the vector
   std::cout << "\nBooks before sorting:\n";
   for (auto book : books) {
      std::cout << book->title << "\n";
   }

   // sort the vector by Book title and print the sorted vector
   std::sort(books.begin(), books.end(), compareTitles);
   std::cout << "\nBooks after sorting:\n";
   for (auto book : books) {
      std::cout << book->title << "\n";
   }

   // create a shared_ptr with a custom deleter
   std::cout << "\nshared_ptr with a custom deleter.\n";
   std::shared_ptr<Book> bookPtr3{
      new Book("Android How to Program"), deleteBook};
   bookPtr3.reset(); // release the Book this shared_ptr manages

   // shared_ptrs are going out of scope
   std::cout << "\nEnd of main: shared_ptr objects going out of scope.\n";
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_09-13/Author.cpp
================================================
// Fig. 20.11: Author.cpp
// Author member-function definitions.
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include "Author.h"
#include "Book.h"

Author::Author(std::string_view authorName) : name(authorName) {}

Author::~Author() {
   std::cout << fmt::format("Destroying Author: {}\n", name);
}

// print the title of the Book this Author wrote
void Author::printBookTitle() {
   // if weakBookPtr.lock() returns a non-empty shared_ptr
   if (std::shared_ptr<Book> bookPtr{weakBookPtr.lock()}) {
      // show the reference count increase and print the Book's title
      std::cout << fmt::format("Reference count for Book {} is {}\n",
         bookPtr->title, bookPtr.use_count());
      std::cout << fmt::format("Author {} wrote the book {}\n", 
         name, bookPtr->title);
   }
   else { // weakBookPtr points to NULL
      std::cout << "This Author has no Books.\n";
   }
}




/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_09-13/Author.h
================================================
// Fig. 20.9: Author.h
// Author class definition.
#pragma once
#include <memory>
#include <string>
#include <string_view>

class Book; // forward declaration of class Book

// Author class definition
class Author {
public:
   explicit Author(std::string_view authorName);
   ~Author();

   // print the title of the Book this Author wrote
   void printBookTitle();

   std::string name; // name of the Author
   std::weak_ptr<Book> weakBookPtr; // Book the Author wrote    
   std::shared_ptr<Book> sharedBookPtr; // Book the Author wrote
};


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_09-13/Book.cpp
================================================
// Fig. 20.12: Book.cpp
// Book member-function definitions.
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include "Author.h"
#include "Book.h"

Book::Book(std::string_view bookTitle) : title(bookTitle) {}

Book::~Book() {
   std::cout << fmt::format("Destroying Book: {}\n", title);
}

// print the name of this Book's Author
void Book::printAuthorName() {
   // if weakAuthorPtr.lock() returns a non-empty shared_ptr
   if (std::shared_ptr<Author> authorPtr{weakAuthorPtr.lock()}) {
      // show the reference count increase and print the Author's name
      std::cout << fmt::format("Reference count for Author {} is {}\n",
         authorPtr->name, authorPtr.use_count());
      std::cout << fmt::format("The book {} was written by {}\n",
         title, authorPtr->name);
   }
   else { // weakAuthorPtr points to NULL
      std::cout << "This Book has no Author.\n";
   }
}


/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_09-13/Book.h
================================================
// Fig. 20.10: Book.h
// Book class definition.
#pragma once
#include <memory>
#include <string>
#include <string_view>

class Author; // forward declaration of class Author

// Book class definition
class Book {
public:
   explicit Book(std::string_view bookTitle);
   ~Book();

   // print the name of this Book's Author
   void printAuthorName();

   std::string title; // title of the Book
   std::weak_ptr<Author> weakAuthorPtr; // Author of the Book    
   std::shared_ptr<Author> sharedAuthorPtr; // Author of the Book
};



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_09-13/fig20_13.cpp
================================================
// fig20_13.cpp
// Demonstrate use of weak_ptr.
#include <fmt/format.h>
#include <iostream>
#include <memory>
#include "Author.h"
#include "Book.h"

int main() {
   // create a Book and an Author
   std::shared_ptr<Book> bookPtr(
      std::make_shared<Book>("C++ How to Program"));
   std::shared_ptr<Author> authorPtr(
      std::make_shared<Author>("Deitel & Deitel"));

   // reference the Book and Author to each other
   bookPtr->weakAuthorPtr = authorPtr;
   authorPtr->weakBookPtr = bookPtr;

   // set the shared_ptr data members to create the memory leak
   bookPtr->sharedAuthorPtr = authorPtr;
   authorPtr->sharedBookPtr = bookPtr;

   // reference count for bookPtr and authorPtr is two
   std::cout << fmt::format("Reference count for Book {} is {}\n",
      bookPtr->title, bookPtr.use_count());
   std::cout << fmt::format("Reference count for Author {} is {}\n\n",
      authorPtr->name, authorPtr.use_count());

   // access the cross references to print the data they point to
   std::cout << "Access Author name and Book title via weak_ptrs:\n";
   bookPtr->printAuthorName();
   std::cout << "\n";
   authorPtr->printBookTitle();

   // reference count for each shared_ptr is two
   std::cout << fmt::format("\nReference count for Book {} is {}\n",
      bookPtr->title, bookPtr.use_count());
   std::cout << fmt::format("Reference count for Author {} is {}\n\n",
      authorPtr->name, authorPtr.use_count());

   // the shared_ptrs go out of scope, the Book and Author are destroyed
   std::cout << "End of main. shared_ptrs going out of scope.\n";
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/lesson20/fig20_14.cpp
================================================
// fig20_14.cpp
// Summing the elements of a braced initializer
#include <fmt/format.h>
#include <initializer_list>
#include <iostream>
#include <string>

// sum the elements of an initializer_list
template <typename T>
T sum(std::initializer_list<T> list) {
   T total{}; // value initialize total based on type T

   // sum all the elements in list; requires += operator for type T 
   for (auto item : list) {
      total += item;
   }

   return total;
}

int main() {
   // display the sum of four ints contained in a braced initializer
   std::cout << fmt::format("The sum of {} is: {}\n",
      "{1, 2, 3, 4}", sum({1, 2, 3, 4}));

   // display the sum of three doubles contained in a braced initializer
   std::cout << fmt::format("The sum of {} is: {}\n",
      "{1.1, 2.2, 3.3}", sum({1.1, 2.2, 3.3}));
      
   // display the sum of two strings contained in a braced initializer
   std::string s1{"Happy "};
   std::string s2{"birthday!"};
   std::cout << fmt::format("The sum of {} is: {}\n",
      "{\"Happy \", \"birthday!\"}", sum({s1, s2}));
}



/**************************************************************************
 * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/


================================================
FILE: examples/libraries/BigNumber/CMakeLists.txt
================================================
# CMakeLists.txt
# Mark Guerra
# 11/1/2015

cmake_minimum_required(VERSION 2.8)
project(BigNumber)

set(BigNumber_VERSION_MAJOR 1)
set(BigNumber_VERSION_MINOR 0)

if (WIN32)
    set(c++version -std=gnu++14)
else()
    set(c++version -std=c++14)
endif()

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Weffc++ -pedantic -Wno-unused-function ${c++version}")

set(CMAKE_BUILD_TYPE Release)

set(SOURCE_FILES
        src/bignumber.cpp  main.cpp )

add_library(BigNumber ${SOURCE_FILES})

set(CMAKE_BUILD_TYPE Debug)

if(WIN32)
    install(TARGETS BigNumber DESTINATION C:/Libs/BigNumber/lib)
    install(FILES src/bignumber.h DESTINATION C:/Libs/BigNumber/include)
else()
    install(TARGETS BigNumber DESTINATION ~/Library/Frameworks/BigNumber/lib)
    install(FILES src/bignumber.h DESTINATION ~/Library/Frameworks/BigNumber/include)
endif()
install(TARGETS BigNumber DESTINATION ${CMAKE_CURRENT_LIST_DIR}/bin/BigNumber/lib)
install(FILES src/bignumber.h DESTINATION ${CMAKE_CURRENT_LIST_DIR}/bin/BigNumber/include)

add_custom_command(
        TARGET BigNumber
        POST_BUILD
        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target install
)

add_executable(BigNumberRun ${SOURCE_FILES})


================================================
FILE: examples/libraries/BigNumber/LICENSE.md
================================================
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2016-2017 Mark Guerra

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.


================================================
FILE: examples/libraries/BigNumber/README.md
================================================
# BigNumber

![BigNumber build](https://travis-ci.org/Limeoats/BigNumber.svg?branch=master)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Limeoats/BigNumber/blob/master/LICENSE.md)

BigNumber is a C++ class that allows for the creation and computation of arbitrary-length
integers.

The maximum possible length of a BigNumber is `std::string::max_size`.

## Installation
To add BigNumber to your C++ project, you can download the `bin` folder from this repository, which 
contains the library and include files.

Then, simply include the header file in whichever file you need a BigNumber and link to the library file.

`#include "bignumber.h"`

## Usage
### `BigNumber(string)`


You can also use the `=` operator to set a BigNumber equal to an existing BigNumber, a number, or 
a string of numbers.

Examples:

    BigNumber b("5");       //BigNumber b is created with value 5.
    BigNumber c("-20");     //BigNumber c is created with value -20.
    BigNumber d("0");       //BigNumber d is created with value 0.
    BigNumber e = b;        //BigNumber e is created with value 5.
    BigNumber f = 30;       //BigNumber f is created with value 30.
    BigNumber g = "2060";   //BigNumber g is created with value 2060.
    BigNumber h(22);        //BigNumber h is created with value 22.


## Methods
### `add(BigNumber other)`
Adds another BigNumber to the current instance

`BigNumber("4").add(BigNumber("20")) => BigNumber("24")`

### `subtract(BigNumber other)`
Subtracts another BigNumber from the current instance

`BigNumber("30").subtract(BigNumber("45")) => BigNumber("-15")`

### `multiply(BigNumber other)`
Multiplies the BigNumber by another BigNumber

`BigNumber("12").multiply(BigNumber("4")) => BigNumber("48")`

### `divide(BigNumber other)`
Divides the BigNumber by another BigNumber

`BigNumber("30").divide(BigNumber("5")) => BigNumber("6")`

### `pow(int exponent)`
Raises the BigNumber to the power of the exponent

`BigNumber("2").pow(3) => BigNumber("8")`

### `getString()`
Returns the BigNumber as an std::string

`BigNumber("3824").getString() => "3824"`

### `setString(std::string newStr)`
Sets the BigNumber's internal number string to a new string

`BigNumber("2847").setString("38") => BigNumber("38")`

### `negate()`
Changes the sign of the BigNumber

    BigNumber("3").negate() => BigNumber("-3")
    BigNumber("-27").negate() => BigNumber("27")

### `equals(BigNumber other)`
Checks if the other BigNumber is equal to this one

`BigNumber("24").equals(BigNumber("28")) => false`

### `digits()`
Returns the number of digits in the BigNumber

`BigNumber("28374").digits() => 5`

### `isNegative()`
Determines whether a BigNumber is negative

`BigNumber("-278").isNegative() => true`

### `isPositive()`
Determines whether a BigNumber is positive

`BigNumber("-3").isPositive() => false`

### `isEven()`
Determines whether a BigNumber is even

`BigNumber("28472310").isEven() => true`

### `isOdd()`
Determines whether a BigNumber is odd

`BigNumber("283427").isOdd() => true`

### `abs()`
Gets the absolute value of the BigNumber

`BigNumber("-26").abs() => BigNumber("26")`


## Operator overloads
The following operators have been overloaded to work with BigNumbers:

### `<<`
Output stream operator

`std::cout << BigNumber("26") << std::endl => 26`

### `+`
Addition operator

`BigNumber("2") + BigNumber("4") => BigNumber("6")`

### `-`
Subtraction operator

`BigNumber("0") - BigNumber("2000") => BigNumber("-2000")`

### `*`
Multiplication operator

`BigNumber("-20") * BigNumber("-5") => BigNumber("100")`

### `/`
Division operator

`BigNumber("10") / BigNumber("-2") => BigNumber("-5")`

### `==`
Equal to operator

`BigNumber("24") == BigNumber("24") => true`

### `>`
Greater than operator

`BigNumber("2") > BigNumber("6") => false`

### `<`
Less than operator

`BigNumber("2") < BigNumber("6") => true`

### `>=`
Greater than or equal to operator

`BigNumber("34") >= BigNumber("22") => true`

### `<=`
Less than or equal to operator

`BigNumber("383") <= BigNumber("383") => true`

### `=`
Assignment operator

`BigNumber c("3") = BigNumber("8") => BigNumber("8")`

### `+=`
Adds and assigns to the BigNumber

`BigNumber c("4") += BigNumber("3") => BigNumber("7")`

### `-=`
Subtracts and assigns to the BigNumber

`BigNumber c("28") -= BigNumber("3") => BigNumber("25")`

### `*=`
Multiplies and assigns to the BigNumber

`BigNumber c("3") *= BigNumber("4") => BigNumber("12")`

### `/=`
Divides and assigns to the BigNumber

`BigNumber c("30") /= BigNumber("30") => BigNumer("1")`

### `++ (Prefix)`
Increments the BigNumber and returns the newly incremented number

`++BigNumber("10") => BigNumber("11")`

### `-- (Prefix)`
Decrements the BigNumber and returns the newly decremented number

`--BigNumber("34") => BigNumber("33")`

### `++ (Postfix)`
Increments the BigNumber but returns the original value

`BigNumber("20")++ => BigNumber("20")`

### `-- (Postfix)`
Decrements the BigNumber but returns the original value

`BigNumber("14")-- => BigNumber("14")`

### `[]`
Indexing operator

`BigNumber d("26")[1] => 6`

## License
This project is under the [Apache License](https://github.com/Limeoats/BigNumber/blob/master/LICENSE.md).

## Credit
The BigNumber class was created by [Mark Guerra](http://www.twitter.com/Limeoats). Visit
[Limeoats.com](http://www.limeoats.com) for more information.


================================================
FILE: examples/libraries/BigNumber/bin/BigNumber/include/bignumber.h
================================================
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Mark Guerra
 *
 * 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 BIGNUMBER_H
#define BIGNUMBER_H

#include <vector>
#include <string>
#include <iostream>

/**
 * BigNumber class
 */
class BigNumber {
public:
    //@{
    /**
     * BigNumber constructor
     * @param number - The initial value of the BigNumber
     */
    BigNumber(std::string number);
    BigNumber(long long number);
    //@}

    /**
     * Add another BigNumber to the current instance
     * @param other - The other BigNumber
     * @return The sum of the two BigNumbers
     */
    BigNumber add(BigNumber other);

    /**
     * Subtract another BigNumber from the current instance
     * @param other - The other BigNumber
     * @return The difference of the two BigNumbers
     */
    BigNumber subtract(BigNumber other);

    /**
     * Multiply the current instance by another BigNumber
     * @param other - The other BigNumber
     * @return The product of the two BigNumbers
     */
    BigNumber multiply(BigNumber other);
    
    /**
     * Divide the current instance by another BigNumber
     * @param other - The other BigNumber
     * @return The quotient of the two BigNumbers
     */
    BigNumber divide(BigNumber other);

    /**
     * Raise the current instance to the power of an exponent
     * @param exponent - The power to be raised by
     * @return - The resulting BigNumber after exponentiation
     */
    BigNumber pow(int exponent);

    /**
     * Get the string value of the current instance
     * @return The BigNumber as a string
     */
    std::string getString();

    /**
     * Set the value of the current instance with a string
     * @param newStr - The new value for the BigNumber
     * @return The BigNumber with the new value
     */
    BigNumber setString(const std::string &newStr);

    /**
     * Negates the current instance
     * @return The BigNumber after negation
     */
    BigNumber negate();
    
    BigNumber trimLeadingZeros();

    //@{
    /**
     * Check if another BigNumber is equal to the current instance
     * @param other - The other BigNumber
     * @return True if equal, otherwise false
     */
    bool equals(const BigNumber &other);
    bool equals(const long long &other);
    bool equals(const std::string &other);
    //@}

    /**
     * Get the number of digits in the current instance
     * @return The number of digits
     */
    unsigned int digits();

    /**
     * Get whether or not the current instance is a negative number
     * @return True if negative, otherwise false
     */
    bool isNegative() const;

    /**
     * Get whether or not the current instance is a positive number
     * @return True if positive, otherwise false
     */
    bool isPositive();

    /**
     * Get whether or not the current instance is an even number
     * @return True if even, otherwise false
     */
    bool isEven();

    /**
     * Get whether or not the current instance is an odd number
     * @return True if odd, otherwise false
     */
    bool isOdd();

    /**
     * Get the absolute value of the current instance
     * @return The absolute value of the BigNumber
     */
    BigNumber abs() const;
    
    /**
     * Output stream operator
     * @param os The output stream
     * @param num The current instance
     * @return The output stream with the current instance
     */
    friend std::ostream &operator<<(std::ostream &os, const BigNumber &num);
    
    //@{
    /**
     * Addition operator
     * @param b1 - The current instance
     * @param b2 - The number being added
     * @return The sum of the two numbers
     */
    friend BigNumber operator+(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator+(BigNumber b1, const long long &b2);
    friend BigNumber operator+(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Subtraction operator
     * @param b1 - The current instance
     * @param b2 - The number being subtracted
     * @return The difference of the two numbers
     */
    friend BigNumber operator-(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator-(BigNumber b1, const long long &b2);
    friend BigNumber operator-(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Multiplication operator
     * @param b1 - The current instance
     * @param b2 - The number being multiplied by
     * @return The product of the two numbers
     */
    friend BigNumber operator*(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator*(BigNumber b1, const long long &b2);
    friend BigNumber operator*(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Division operator
     * @param b1 - The current instance
     * @param b2 - The number being divided by
     * @return The quotient of the two numbers
     */
    friend BigNumber operator/(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator/(BigNumber b1, const long long &b2);
    friend BigNumber operator/(BigNumber b1, const std::string &b2);
    //@}
    
    /**
     * Exponent operator
     * @param b1 - The current instance
     * @param b2 - The exponent
     * @return The value after exponentiation
     */
    friend BigNumber operator^(BigNumber b1, const int &b2);
    
    //@{
    /**
     * Equality operator
     * @param b1 - The current instance
     * @param b2 - Another value
     * @return True if equal, otherwise false
     */
    friend bool operator==(BigNumber b1, const BigNumber &b2);
    friend bool operator==(BigNumber b1, const long long &b2);
    friend bool operator==(BigNumber b1, const std::string &b2);
    //@}
    
    /**
     * Greater-than operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is greater, otherwise false
     */
    friend bool operator>(BigNumber b1, const BigNumber &b2);
    
    /**
     * Less-than operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is less, otherwise false
     */
    friend bool operator<(BigNumber b1, const BigNumber &b2);
    
    /**
     * Greater-than or equal-to operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is greater or equal, otherwise false
     */
    friend bool operator>=(BigNumber b1, const BigNumber &b2);
    
    /**
     * Less-than or equal-to operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is less or equal, otherwise false
     */
    friend bool operator<=(BigNumber b1, const BigNumber &b2);

    //@{
    /**
     * Assignment operator
     * @param other - The new value for the BigNumber
     * @return A BigNumber containing the new value
     */
    BigNumber& operator=(const BigNumber &other);
    BigNumber& operator=(const long long &other);
    BigNumber& operator=(const std::string &other);
    //@}
    
    //@{
    /**
     * Addition assignment operator\n
     * Adds and assigns a value to the current instance
     * @param other - The value being added
     * @return The new value after addition and assignment
     */
    BigNumber& operator+=(const BigNumber &other);
    BigNumber& operator+=(const long long &other);
    BigNumber& operator+=(const std::string &other);
    //@}
    
    //@{
    /**
     * Subtraction assignment operator\n
     * Subtracts and assigns a value to the current instance
     * @param other - The value being subtracted
     * @return The new value after subtraction and assignment
     */
    BigNumber& operator-=(const BigNumber &other);
    BigNumber& operator-=(const long long &other);
    BigNumber& operator-=(const std::string &other);
    //@}
    
    //@{
    /**
     * Multiplication assignment operator\n
     * Multiplies and assigns a value to the current instance
     * @param other - The value being multiplied
     * @return The new value after multiplication and assignment
     */
    BigNumber& operator*=(const BigNumber &other);
    BigNumber& operator*=(const long long &other);
    BigNumber& operator*=(const std::string &other);
    //@}
    
    //@{
    /**
     * Division assignment operator\n
     * Divides and assigns a value to the current instance
     * @param other - The value being divided
     * @return The new value after division and assignment
     */
    BigNumber& operator/=(const BigNumber &other);
    BigNumber& operator/=(const long long &other);
    BigNumber& operator/=(const std::string &other);
    //@}

    /**
     * Pre-increment operator
     * @return The incremented BigNumber
     */
    BigNumber& operator++();
    
    /**
     * Pre-decrement operator
     * @return The decremented BigNumber
     */
    BigNumber& operator--();
    
    /**
     * Post-increment operator
     * @return The incremented BigNumber
     */
    BigNumber operator++(int);
    
    /**
     * Post-decrement operator
     * @return The decremented BigNumber
     */
    BigNumber operator--(int);

    /**
     * The index operator
     * @param index The position being looked at
     * @return The number at the specified position in the BigNumber string
     */
    unsigned int operator[](int index);

private:
    std::string _numberString;      //The big number represented as a string

    //Methods
    BigNumber addll(const long long &other);
    BigNumber addstr(const std::string &other);
    BigNumber subtractll(const long long &other);
    BigNumber subtractstr(const std::string  &other);
    BigNumber multiplyll(const long long &other);
    BigNumber multiplystr(const std::string &other);
    BigNumber dividell(const long long &other);
    BigNumber dividestr(const std::string &other);
};



#endif

================================================
FILE: examples/libraries/BigNumber/main.cpp
================================================
////////////////////////////
//To make sure assert works:
#ifdef NDEBUG
#undef NDEBUG
#endif
////////////////////////////

#include "src/bignumber.h"
#include <assert.h>

int main() {
    //Addition
    assert((BigNumber(50) + BigNumber(32)).getString() == "82");
    assert((BigNumber(5) + BigNumber(622)).getString() == "627");
    assert((BigNumber("-33") + BigNumber("8")).getString() == "-25");
    assert((BigNumber("15535") + BigNumber("0")).getString() == "15535");
    assert((BigNumber("126") + BigNumber("39285")).getString() == "39411");
    assert((BigNumber("0") + BigNumber("0")).getString() == "0");
    assert(BigNumber(5) + 10 == 15);
    assert(BigNumber("-41") + 40 == -1);
    BigNumber ad1(600);
    ad1 += 50;
    ad1 += "50";
    assert(ad1.getString() == "700");
    assert(ad1 == 700);

    //Subtraction
    assert((BigNumber("50") - BigNumber("32")).getString() == "18");
    assert((BigNumber("50") - BigNumber("60")).getString() == "-10");
    assert((BigNumber("0") - BigNumber("46")).getString() == "-46");
    assert((BigNumber("50") - BigNumber("50")).getString() == "0");
    assert((BigNumber("482847") - BigNumber("89787941")).getString() == "-89305094");
    assert((BigNumber("6828") - BigNumber("1")).getString() == "6827");
    assert((BigNumber("100") - BigNumber("50")).getString() == "50");
    assert((BigNumber("42") - BigNumber("49")).getString() == "-7");
    assert((BigNumber("100") - BigNumber("5")) == 95);
    BigNumber sb1 = 200;
    sb1 -= 40;
    assert(sb1 == 160);
    sb1 = sb1 - 180;
    assert(sb1 == "-20");
    sb1 -= "20";
    assert(sb1 == BigNumber(-40));

    //Multiplication
    assert((BigNumber("4") * BigNumber("12")).getString() == "48");
    assert((BigNumber("3002") * BigNumber("1")).getString() == "3002");
    assert((BigNumber("99") * BigNumber("0")).getString() == "0");
    assert((BigNumber("-5") * BigNumber("5")).getString() == "-25");
    assert((BigNumber("-33") * BigNumber("-2")).getString() == "66");
    assert((BigNumber("283") * BigNumber("382871")).getString() == "108352493");
    BigNumber ml1 = 4;
    ml1 *= 6;
    assert(ml1 == "24");
    ml1 = BigNumber(5) * 6;
    assert(ml1 == 30);
    ml1 *= "5000";
    assert(ml1 == 150000);

    //Division
    assert(BigNumber("25").divide(BigNumber("5")) == 5);
    assert(BigNumber("48").divide(BigNumber("6")) == 8);
    assert(BigNumber("100").divide(BigNumber("5")) == 20);
    BigNumber dv1 = 100;
    dv1 /= 25;
    assert(dv1 == 4);
    dv1 = dv1 / dv1;
    assert(dv1 == 1);
    dv1 /= 1;
    assert(dv1 == 1);
    dv1 = -5;
    dv1 /= 5;
    assert(dv1 == -1);
    dv1 = 3000;
    dv1 /= 300;
    assert(dv1 == 10);
    dv1 = 25485;
    dv1 /= 5;
    assert(dv1 == "5097");

    //Exponentiation
    assert((BigNumber("2").pow(3)).getString() == "8");
    assert((BigNumber("1").pow(38)).getString() == "1");
    assert((BigNumber("5").pow(2)).getString() == "25");
    assert((BigNumber("10").pow(10)).getString() == "10000000000");
    assert((BigNumber("5").pow(1)).getString() == "5");
    assert((BigNumber("5").pow(0)).getString() == "1");
    assert((BigNumber("-5").pow(2)).getString() == "25");

    //Equals
    assert(BigNumber("4") == BigNumber("4"));
    assert(BigNumber("-3") == BigNumber("-3"));
    assert(BigNumber("0") == BigNumber("0"));
    assert(BigNumber("938283828178273") == BigNumber("938283828178273"));

    //Greater than
    assert(BigNumber("5") > BigNumber("2"));
    assert(BigNumber("30") > BigNumber("-40"));
    assert(BigNumber("-5") > BigNumber("-10"));
    assert(BigNumber("0") > BigNumber("-1"));

    //Less than
    assert(BigNumber("10") < BigNumber("20"));
    assert(BigNumber("-5") < BigNumber("0"));
    assert(BigNumber("30") < BigNumber("30000"));

    //Greater than or equal to
    assert(BigNumber("5") >= BigNumber("0"));
    assert(BigNumber("-5") >= BigNumber("-5"));
    assert(BigNumber("-5") >= BigNumber("-10"));
    assert(BigNumber("0") >= BigNumber("0"));
    assert(BigNumber("32") >= BigNumber("-32"));
    assert(BigNumber("2") >= BigNumber("0001"));

    //Less than or equal to
    assert(BigNumber("5") <= BigNumber("10"));
    assert(BigNumber("0") <= BigNumber("0"));
    assert(BigNumber("-5") <= BigNumber("0"));
    assert(BigNumber("30") <= BigNumber("30"));
    assert(BigNumber("400") <= BigNumber("392342"));

    //Index
    assert(BigNumber("423")[1] == 2);
    assert(BigNumber("0")[0] == 0);
    assert(BigNumber("-5")[1] == 5);

    //Even
    assert(BigNumber("426").isEven());
    assert(BigNumber("-20").isEven());

    //Odd
    assert(BigNumber("83").isOdd());
    assert(BigNumber("-27").isOdd());

    //Positive
    assert(BigNumber("38").isPositive());

    //Negative
    assert(BigNumber("-28382").isNegative());

    //Increment/Decrement operators
    assert(BigNumber("5")--.getString() == "5");
    assert((--BigNumber("5")).getString() == "4");
    assert(BigNumber("10")++.getString() == "10");
    assert((++BigNumber("10")).getString() == "11");

    BigNumber a("10");
    a++;
    assert(a.getString() == "11");
    ++a;
    assert(a.getString() == "12");
    a--;
    assert(a.getString() == "11");
    --a;
    assert(a.getString() == "10");

    //Absolute value
    assert(BigNumber("45").abs().getString() == "45");
    assert(BigNumber("-325").abs().getString() == "325");

    //Digits
    assert(BigNumber("28374765").digits() == 8);
    assert(BigNumber("-3092").digits() == 4);

    //Set string
    assert(BigNumber("234").setString("-45").getString() == "-45");

    //Assignment operator
    BigNumber c(10);
    c = 5;
    assert(c == 5);
    assert(c == BigNumber(5));
    assert(c == BigNumber("5"));
    c = "83833";
    assert(c == 83833);
    assert(c == BigNumber(83833));
    assert(c == BigNumber("83833"));

    //Equals testing
    BigNumber d(40);
    assert(d == 40);
    assert(d == "40");
    assert(d == BigNumber("40"));
    assert(d == BigNumber(40));
    d = 40;
    assert(d == 40);
    d = "40";
    assert(d == 40);


    std::cout << "BigNumber ran successfully." << std::endl;
}


================================================
FILE: examples/libraries/BigNumber/src/bignumber.cpp
================================================
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Mark Guerra
 *
 * 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 <sstream>
#include <stack>
#include <iostream>

#include "bignumber.h"


BigNumber::BigNumber(std::string number) :
        _numberString(number)
{
}

BigNumber::BigNumber(long long number) :
    _numberString(std::to_string(number))
{}

BigNumber BigNumber::add(BigNumber other) {
    BigNumber b1 = other > *this ? other : *this;
    BigNumber b2 = other > *this ? *this : other;
    if (b1.isNegative() || b2.isNegative()) {
        if (b1.isNegative() && b2.isNegative()) {
            return b1.negate().add(b2.negate()).negate();
        }
        else if (b1.isNegative() && !b2.isNegative()) {
            return b1.negate().subtract(b2).negate();
        }
        else {
            return b2.negate().subtract(b1).negate();
        }
    }
    std::string results;
    int carry = 0;
    int diff = int(b1._numberString.size() - b2._numberString.size());
    for (int i = 0; i < diff; ++i) {
        b2._numberString.insert(b2._numberString.begin(), '0');
    }
    for (int i = int(b1._numberString.size() - 1); i >= 0; --i) {
        int sum = (b1._numberString[i] - '0') + (b2._numberString[i] - '0') + carry;
        carry = 0;
        if (sum <= 9 || i == 0) {
            results.insert(0, std::to_string(sum));
        }
        else {
            results.insert(0, std::to_string(sum % 10));
            carry = 1;
        }
    }
    return BigNumber(results);
}

BigNumber BigNumber::addll(const long long &other) {
    return this->add(BigNumber(other));
}

BigNumber BigNumber::addstr(const std::string &other) {
    return this->add(BigNumber(other));
}


BigNumber BigNumber::subtract(BigNumber other) {
    BigNumber b1 = *this, b2 = other;
    if (b1.isNegative() || b2.isNegative()) {
        if (b1.isNegative() && b2.isNegative()) {
            return b1.negate().add(b2.negate()).negate();
        }
        else if (b1.isNegative() && !b2.isNegative()) {
            return b1.negate().add(b2).negate();
        }
        else {
            return b2.negate().add(b1);
        }
    }
    std::string results;
    int n = 0, p = 0;
    bool takeOffOne = false;
    bool shouldBeTen = false;

    if (b1 < b2) {
        //Negative answer
        std::string t = b2.subtract(*this).negate().getString();
        for (unsigned int i = 1; i < t.length(); ++i) {
            if (t[i] != '0') break;
            t.erase(1, 1);
        }
        return BigNumber(t);
    }

    //This next if-block fixes the case where the digit difference is greater than 1
    //100 - 5 is an example. This code adds 0's to make it, for example, 100 - 05, which
    //allows the rest of the subtraction code to work.
    if (b1._numberString.size() - b2.getString().size() > 1) {
        for (unsigned long i = 0; i < b1._numberString.size() - b2.getString().size() - 1; ++i) {
            b2._numberString.insert(b2._numberString.begin(), '0');
        }
    }
    int i = int(b1._numberString.size() - 1);
    for (int j = int(b2._numberString.size() - 1); j >= 0; --j) {
        if (((b1._numberString[i] - '0') < (b2._numberString[j] - '0')) && i > 0) {
            n = char((b1._numberString[i] - '0') + 10);
            takeOffOne = true;
            if (j > 0 || b1._numberString[i - 1] != '0') {
                p = char((b1._numberString[i - 1] - '0') - 1);
                if (p == -1) {
                    p = 9;
                    shouldBeTen = true;
                }
                takeOffOne = false;
            }
            if (shouldBeTen) {
                int index = i - 1;
                for (int a = i - 1; (b1._numberString[a] - '0') == 0; --a) {
                    b1._numberString[a] = static_cast<char>(p + '0');
                    --index;
                }
                int t = (b1._numberString[index] - '0') - 1;
                b1._numberString[index] = static_cast<char>(t + '0');
            }
            b1._numberString[i - 1] = static_cast<char>(p + '0');
            shouldBeTen = false;
        }
        std::stringstream ss;
        if (((b1._numberString[i] - '0') == (b2._numberString[j] - '0'))) {
            ss << "0";
        }
        else {
            if (n <= 0) {
                ss << ((b1._numberString[i] - '0') - (b2._numberString[j] - '0'));
            }
            else {
                ss << (n - (b2._numberString[j] - '0'));
            }
        }

        results.insert(0, ss.str());
        --i;
        n = 0;
    }
    if (takeOffOne) {
        std::string number = "";
        for (int j = b1._numberString.length() - b2._numberString.length() - 1; j >= 0; --j) {
            if (b1._numberString[j] == '0') {
                number += "0";
                continue;
            }
            else {
                number.insert(number.begin(), b1._numberString[j]);
                int t = atoi(number.c_str());
                --t;
                b1._numberString.replace(0, number.size(), std::to_string(t));
                break;
            }
        }
    }
    while (i >= 0) {
        std::stringstream ss;
        if (i == 0) {
            if (b1._numberString[i] - '0' != 0) {
                ss << (b1._numberString[i] - '0');
                results.insert(0, ss.str());
            }
        }
        else {
            ss << (b1._numberString[i] - '0');
            results.insert(0, ss.str());
        }

        --i;
    }
    //In the case of all 0's, we only want to return one of them
    if (results.find_first_not_of('0') == std::string::npos) {
        results = "0";
    }
    else if (results[0] == '0') {
        int index = results.find_first_not_of('0');
        results = results.substr(index, results.length() - 1);
    }
    return BigNumber(results);
}

BigNumber BigNumber::subtractll(const long long &other) {
    return this->subtract(BigNumber(other));
}

BigNumber BigNumber::subtractstr(const std::string &other) {
    return this->subtract(BigNumber(other));
}

BigNumber BigNumber::multiply(BigNumber other) {
    BigNumber b1 = other > *this ? other : *this;
    BigNumber b2 = other > *this ? *this : other;
    if (b1.isNegative() || b2.isNegative()) {
        if (b1.isNegative() && b2.isNegative()) {
            return b1.negate().multiply(b2.negate());
        }
        else if (b1.isNegative() && !b2.isNegative()) {
            return b1.negate().multiply(b2).negate();
        }
        else {
            return b2.negate().multiply(b1).negate();
        }
    }
    if (b1 == 0 || b2 == 0) return 0;
    int carry = 0;
    int zeroCounter = 0;
    BigNumber b = 0;
    
    for (unsigned int i = 0; i < b1._numberString.size() - b2._numberString.size(); ++i) {
        b2._numberString.insert(b2._numberString.begin(), '0');
    }
    for (long long int i = (b2._numberString.size() - 1); i >= 0; --i) {
        std::string rr;
        for (long long int j = int(b1._numberString.size() - 1); j >= 0; --j) {
            int val = ((b2._numberString[i] - '0') * (b1._numberString[j] - '0')) + carry;
            carry = 0;
            if (val > 9 && j != 0) {
                carry = val / 10;
                rr.insert(0, std::to_string(val % 10));
            }
            else {
                rr.insert(0, std::to_string(val));
            }
        }
        if (zeroCounter > 0) {
            for (int x = 0; x < zeroCounter; ++x) {
                rr.append("0");
            }
        }
        ++zeroCounter;
        b += BigNumber(rr);
    }
    if (b._numberString.find_first_not_of('0') != std::string::npos) {
        b.setString(b._numberString.erase(0, b._numberString.find_first_not_of('0')));
    }
    else {
        //In the case of all 0's, we only want to return one of them
        b.setString("0");
    }
    return b;
}

BigNumber BigNumber::multiplyll(const long long &other) {
    if (other == 0)
        return 0;
    if (other == 1)
        return *this;
    auto original = *this;
    for (auto i = 0; i < other - 1; ++i) {
        *this += original;
    }
    return *this;
}

BigNumber BigNumber::multiplystr(const std::string &other) {
    return this->multiply(BigNumber(other));
}

BigNumber BigNumber::divide(BigNumber other) {
    if (other == 0) {
        std::cerr << "You cannot divide by 0!" << std::endl;
    }
    BigNumber b1 = *this, b2 = other;
    bool sign = false;
    if (b1.isNegative() && b2.isNegative()) {
        b1.negate();
        b2.negate();
    }
    else if (b1.isNegative() && !b2.isNegative()) {
        b1.negate();
        sign = true;
    }
    else if (!b1.isNegative() && b2.isNegative()) {
        b2.negate();
        sign = true;
    }
    BigNumber quotient = 0;
    while (b1 >= b2) {
        b1 -= b2;
        ++quotient;
    }
    if (sign) quotient.negate();
    return quotient;
}

BigNumber BigNumber::dividell(const long long &other) {
    return this->divide(BigNumber(other));
}

BigNumber BigNumber::dividestr(const std::string &other) {
    return this->divide(BigNumber(other));
}

BigNumber BigNumber::pow(int exponent) {
    if (exponent < 0) std::cerr << "Powers less than 0 are not supported" << std::endl;
    if (exponent == 0) return BigNumber("1");
    if (exponent == 1) return *this;
    BigNumber result = 1, base = *this;
    while (exponent) {
        if (exponent & 1) {
            result *= base;
        }
        exponent >>= 1;
        base *= base;
    }
    return result;
}

std::string BigNumber::getString() {
    return this->_numberString;
}

BigNumber BigNumber::setString(const std::string &newStr) {
    this->_numberString = newStr;
    return *this;
}

BigNumber BigNumber::negate() {
    if (this->_numberString[0] == '-') {
        this->_numberString.erase(0, 1);
    }
    else {
        this->_numberString.insert(this->_numberString.begin(), '-');
    }
    return *this;
}

BigNumber BigNumber::trimLeadingZeros() {
    BigNumber b = *this;
    if (b._numberString.find_first_not_of('0') != std::string::npos) {
        b.setString(b._numberString.erase(0, b._numberString.find_first_not_of('0')));
    }
    return b;
}

bool BigNumber::equals(const BigNumber &other) {
    return this->_numberString == other._numberString;
}

bool BigNumber::equals(const long long &other) {
    return this->getString() == std::to_string(other);
}

bool BigNumber::equals(const std::string &other) {
    return this->getString() == other;
}

unsigned int BigNumber::digits() {
    return this->_numberString.length() - static_cast<int>(this->isNegative());
}

bool BigNumber::isNegative() const {
    return this->_numberString[0] == '-';
}

bool BigNumber::isPositive() {
    return !this->isNegative();
}

bool BigNumber::isEven() {
    return this->_numberString[this->_numberString.length() - 1] % 2 == 0;
}

bool BigNumber::isOdd() {
    return !this->isEven();
}

BigNumber BigNumber::abs() const {
    return BigNumber(this->_numberString.substr(static_cast<unsigned int>(this->isNegative())));
}

std::ostream &operator<<(std::ostream &os, const BigNumber &num) {
    os << num._numberString;
    return os;
}

BigNumber operator+(BigNumber b1, const BigNumber &b2) {
    return b1.add(b2);
}

BigNumber operator+(BigNumber b1, const long long &b2) {
    return b1.addll(b2);
}

BigNumber operator+(BigNumber b1, const std::string &b2) {
    return b1.addstr(b2);
}

BigNumber operator-(BigNumber b1, const BigNumber &b2) {
    return b1.subtract(b2);
}

BigNumber operator-(BigNumber b1, const long long &b2) {
    return b1.subtractll(b2);
}

BigNumber operator-(BigNumber b1, const std::string &b2) {
    return b1.subtractstr(b2);
}

BigNumber operator*(BigNumber b1, const BigNumber &b2) {
    return b1.multiply(b2);
}

BigNumber operator*(BigNumber b1, const long long &b2) {
    return b1.multiplyll(b2);
}

BigNumber operator*(BigNumber b1, const std::string &b2) {
    return b1.multiplystr(b2);
}

BigNumber operator/(BigNumber b1, const BigNumber &b2) {
    return b1.divide(b2);
}

BigNumber operator/(BigNumber b1, const long long &b2) {
    return b1.dividell(b2);
}

BigNumber operator/(BigNumber b1, const std::string &b2) {
    return b1.dividestr(b2);
}

BigNumber operator^(BigNumber b1, const int &b2) {
    return b1.pow(b2);
}

bool operator==(BigNumber b1, const BigNumber &b2) {
    return b1.equals(b2);
}

bool operator==(BigNumber b1, const long long &b2) {
    return b1.equals(b2);
}

bool operator==(BigNumber b1, const std::string &b2) {
    return b1.equals(b2);
}

bool operator>(BigNumber b1, const BigNumber &b2) {
    if (b1.isNegative() || b2.isNegative()) {
        if (b1.isNegative() && b2.isNegative()) {
            BigNumber bt = b2;
            b1._numberString.erase(0, 1);
            bt._numberString.erase(0, 1);
            return b1 < bt;
        }
        else {
            return !(b1.isNegative() && !b2.isNegative());
        }
    }
    b1 = b1.trimLeadingZeros();
    auto c = BigNumber(b2);
    c = c.trimLeadingZeros();
    if (b1 == c) {
        return false;
    }
    if (b1._numberString.size() > c._numberString.size()) {
        return true;
    }
    else if (c._numberString.size() > b1._numberString.size()) {
        return false;
    }
    else {
        for (unsigned int i = 0; i < b1._numberString.size(); ++i) {
            if (b1[i] == static_cast<unsigned int>(c._numberString[i] - '0')) {
                continue;
            }
            return b1[i] > static_cast<unsigned int>(c._numberString[i] - '0');
        }
    }
    return false;
}

bool operator<(BigNumber b1, const BigNumber &b2) {
    return !(b1 == b2) && !(b1 > b2);
}

bool operator>=(BigNumber b1, const BigNumber &b2) {
    return b1 > b2 || b1 == b2;
}

bool operator<=(BigNumber b1, const BigNumber &b2) {
    return b1 < b2 || b1 == b2;
}

unsigned int BigNumber::operator[](int index) {
    if (this->_numberString[index] == '-') {
        std::cerr << "You cannot get the negative sign from the number" << std::endl;
    }
    return static_cast<unsigned int>(this->_numberString[index] - '0');
}

BigNumber& BigNumber::operator=(const BigNumber &other) {
    this->_numberString = other._numberString;
    return *this;
}

BigNumber& BigNumber::operator=(const long long &other) {
    this->_numberString = std::to_string(other);
    return *this;
}

BigNumber& BigNumber::operator=(const std::string &other) {
    this->_numberString = other;
    return *this;
}

BigNumber& BigNumber::operator+=(const BigNumber &other) {
    *this = *this + other;
    return *this;
}

BigNumber& BigNumber::operator+=(const long long &other) {
    *this = *this + other;
    return *this;
}

BigNumber& BigNumber::operator+=(const std::string &other) {
    *this = *this + other;
    return *this;
}

BigNumber& BigNumber::operator-=(const BigNumber &other) {
    *this = *this - other;
    return *this;
}

BigNumber& BigNumber::operator-=(const long long &other) {
    *this = *this - other;
    return *this;
}

BigNumber& BigNumber::operator-=(const std::string &other) {
    *this = *this - other;
    return *this;
}

BigNumber& BigNumber::operator*=(const BigNumber &other) {
    *this = *this * other;
    return *this;
}

BigNumber& BigNumber::operator*=(const long long &other) {
    *this = *this * other;
    return *this;
}

BigNumber& BigNumber::operator*=(const std::string &other) {
    *this = *this * other;
    return *this;
}

BigNumber& BigNumber::operator/=(const BigNumber &other) {
    *this = *this / other;
    return *this;
}

BigNumber& BigNumber::operator/=(const long long &other) {
    *this = *this / other;
    return *this;
}

BigNumber& BigNumber::operator/=(const std::string &other) {
    *this = *this / other;
    return *this;
}

BigNumber& BigNumber::operator++() {
    *this += BigNumber("1");
    return *this;
}

BigNumber& BigNumber::operator--() {
    *this -= BigNumber("1");
    return *this;
}

BigNumber BigNumber::operator++(int) {
    BigNumber t(this->getString());
    ++(*this);
    return t;
}

BigNumber BigNumber::operator--(int) {
    BigNumber t(this->getString());
    --(*this);
    return t;
}

================================================
FILE: examples/libraries/BigNumber/src/bignumber.h
================================================
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Mark Guerra
 *
 * 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 BIGNUMBER_H
#define BIGNUMBER_H

#include <vector>
#include <string>
#include <iostream>

/**
 * BigNumber class
 */
class BigNumber {
public:
    //@{
    /**
     * BigNumber constructor
     * @param number - The initial value of the BigNumber
     */
    BigNumber(std::string number);
    BigNumber(long long number);
    //@}

    /**
     * Add another BigNumber to the current instance
     * @param other - The other BigNumber
     * @return The sum of the two BigNumbers
     */
    BigNumber add(BigNumber other);

    /**
     * Subtract another BigNumber from the current instance
     * @param other - The other BigNumber
     * @return The difference of the two BigNumbers
     */
    BigNumber subtract(BigNumber other);

    /**
     * Multiply the current instance by another BigNumber
     * @param other - The other BigNumber
     * @return The product of the two BigNumbers
     */
    BigNumber multiply(BigNumber other);
    
    /**
     * Divide the current instance by another BigNumber
     * @param other - The other BigNumber
     * @return The quotient of the two BigNumbers
     */
    BigNumber divide(BigNumber other);

    /**
     * Raise the current instance to the power of an exponent
     * @param exponent - The power to be raised by
     * @return - The resulting BigNumber after exponentiation
     */
    BigNumber pow(int exponent);

    /**
     * Get the string value of the current instance
     * @return The BigNumber as a string
     */
    std::string getString();

    /**
     * Set the value of the current instance with a string
     * @param newStr - The new value for the BigNumber
     * @return The BigNumber with the new value
     */
    BigNumber setString(const std::string &newStr);

    /**
     * Negates the current instance
     * @return The BigNumber after negation
     */
    BigNumber negate();
    
    BigNumber trimLeadingZeros();

    //@{
    /**
     * Check if another BigNumber is equal to the current instance
     * @param other - The other BigNumber
     * @return True if equal, otherwise false
     */
    bool equals(const BigNumber &other);
    bool equals(const long long &other);
    bool equals(const std::string &other);
    //@}

    /**
     * Get the number of digits in the current instance
     * @return The number of digits
     */
    unsigned int digits();

    /**
     * Get whether or not the current instance is a negative number
     * @return True if negative, otherwise false
     */
    bool isNegative() const;

    /**
     * Get whether or not the current instance is a positive number
     * @return True if positive, otherwise false
     */
    bool isPositive();

    /**
     * Get whether or not the current instance is an even number
     * @return True if even, otherwise false
     */
    bool isEven();

    /**
     * Get whether or not the current instance is an odd number
     * @return True if odd, otherwise false
     */
    bool isOdd();

    /**
     * Get the absolute value of the current instance
     * @return The absolute value of the BigNumber
     */
    BigNumber abs() const;
    
    /**
     * Output stream operator
     * @param os The output stream
     * @param num The current instance
     * @return The output stream with the current instance
     */
    friend std::ostream &operator<<(std::ostream &os, const BigNumber &num);
    
    //@{
    /**
     * Addition operator
     * @param b1 - The current instance
     * @param b2 - The number being added
     * @return The sum of the two numbers
     */
    friend BigNumber operator+(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator+(BigNumber b1, const long long &b2);
    friend BigNumber operator+(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Subtraction operator
     * @param b1 - The current instance
     * @param b2 - The number being subtracted
     * @return The difference of the two numbers
     */
    friend BigNumber operator-(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator-(BigNumber b1, const long long &b2);
    friend BigNumber operator-(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Multiplication operator
     * @param b1 - The current instance
     * @param b2 - The number being multiplied by
     * @return The product of the two numbers
     */
    friend BigNumber operator*(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator*(BigNumber b1, const long long &b2);
    friend BigNumber operator*(BigNumber b1, const std::string &b2);
    //@}
    
    //@{
    /**
     * Division operator
     * @param b1 - The current instance
     * @param b2 - The number being divided by
     * @return The quotient of the two numbers
     */
    friend BigNumber operator/(BigNumber b1, const BigNumber &b2);
    friend BigNumber operator/(BigNumber b1, const long long &b2);
    friend BigNumber operator/(BigNumber b1, const std::string &b2);
    //@}
    
    /**
     * Exponent operator
     * @param b1 - The current instance
     * @param b2 - The exponent
     * @return The value after exponentiation
     */
    friend BigNumber operator^(BigNumber b1, const int &b2);
    
    //@{
    /**
     * Equality operator
     * @param b1 - The current instance
     * @param b2 - Another value
     * @return True if equal, otherwise false
     */
    friend bool operator==(BigNumber b1, const BigNumber &b2);
    friend bool operator==(BigNumber b1, const long long &b2);
    friend bool operator==(BigNumber b1, const std::string &b2);
    //@}
    
    /**
     * Greater-than operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is greater, otherwise false
     */
    friend bool operator>(BigNumber b1, const BigNumber &b2);
    
    /**
     * Less-than operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is less, otherwise false
     */
    friend bool operator<(BigNumber b1, const BigNumber &b2);
    
    /**
     * Greater-than or equal-to operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is greater or equal, otherwise false
     */
    friend bool operator>=(BigNumber b1, const BigNumber &b2);
    
    /**
     * Less-than or equal-to operator
     * @param b1 - The current instance
     * @param b2 - Another BigNumber
     * @return True if current instance is less or equal, otherwise false
     */
    friend bool operator<=(BigNumber b1, const BigNumber &b2);

    //@{
    /**
     * Assignment operator
     * @param other - The new value for the BigNumber
     * @return A BigNumber containing the new value
     */
    BigNumber& operator=(const BigNumber &other);
    BigNumber& operator=(const long long &other);
    BigNumber& operator=(const std::string &other);
    //@}
    
    //@{
    /**
     * Addition assignment operator\n
     * Adds and assigns a value to the current instance
     * @param other - The value being added
     * @return The new value after addition and assignment
     */
    BigNumber& operator+=(const BigNumber &other);
    BigNumber& operator+=(const long long &other);
    BigNumber& operator+=(const std::string &other);
    //@}
    
    //@{
    /**
     * Subtraction assignment operator\n
     * Subtracts and assigns a value to the current instance
     * @param other - The value being subtracted
     * @return The new value after subtraction and assignment
     */
    BigNumber& operator-=(const BigNumber &other);
    BigNumber& operator-=(const long long &other);
    BigNumber& operator-=(const std::string &other);
    //@}
    
    //@{
    /**
     * Multiplication assignment operator\n
     * Multiplies and assigns a value to the current instance
     * @param other - The value being multiplied
     * @return The new value after multiplication and assignment
     */
    BigNumber& operator*=(const BigNumber &other);
    BigNumber& operator*=(const long long &other);
    BigNumber& operator*=(const std::string &other);
    //@}
    
    //@{
    /**
     * Division assignment operator\n
     * Divides and assigns a value to the current instance
     * @param other - The value being divided
     * @return The new value after division and assignment
     */
    BigNumber& operator/=(const BigNumber &other);
    BigNumber& operator/=(const long long &other);
    BigNumber& operator/=(const std::string &other);
    //@}

    /**
     * Pre-increment operator
     * @return The incremented BigNumber
     */
    BigNumber& operator++();
    
    /**
     * Pre-decrement operator
     * @return The decremented BigNumber
     */
    BigNumber& operator--();
    
    /**
     * Post-increment operator
     * @return The incremented BigNumber
     */
    BigNumber operator++(int);
    
    /**
     * Post-decrement operator
     * @return The decremented BigNumber
     */
    BigNumber operator--(int);

    /**
     * The index operator
     * @param index The position being looked at
     * @return The number at the specified position in the BigNumber string
     */
    unsigned int operator[](int index);

private:
    std::string _numberString;      //The big number represented as a string

    //Methods
    BigNumber addll(const long long &other);
    BigNumber addstr(const std::string &other);
    BigNumber subtractll(const long long &other);
    BigNumber subtractstr(const std::string  &other);
    BigNumber multiplyll(const long long &other);
    BigNumber multiplystr(const std::string &other);
    BigNumber dividell(const long long &other);
    BigNumber dividestr(const std::string &other);
};



#endif

================================================
FILE: examples/libraries/GSL/.clang-format
================================================
ColumnLimit: 100

UseTab: Never
IndentWidth: 4
AccessModifierOffset: -4
NamespaceIndentation: Inner

BreakBeforeBraces: Custom
BraceWrapping:
  AfterNamespace: true
  AfterEnum: true
  AfterStruct: true
  AfterClass: true
  SplitEmptyFunction: false
  AfterControlStatement: true
  AfterFunction: true
  AfterUnion: true
  BeforeElse: true


AlwaysBreakTemplateDeclarations: true
BreakConstructorInitializersBeforeComma: true
ConstructorInitializerAllOnOneLineOrOnePerLine: true
AllowShortBlocksOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true

PointerAlignment: Left
AlignConsecutiveAssignments: false
AlignTrailingComments: true

SpaceAfterCStyleCast: true
CommentPragmas: '^ NO-FORMAT:'


================================================
FILE: examples/libraries/GSL/.github/workflows/main.yml
================================================
name: CI
on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  iOS:
    runs-on: macos-latest
    defaults:
      run:
        working-directory: build
    steps:
      - uses: actions/checkout@v2

      - name: Create build directory
        run: mkdir -p build
        working-directory: .

      - name: Configure
        run: |
          cmake \
            -GXcode \
            -DCMAKE_SYSTEM_NAME=iOS \
            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
            -DCMAKE_OSX_DEPLOYMENT_TARGET=8 \
            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.0.1 \
            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.0.1 \
            ..

      - name: Build
        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator

      - name: Start simulator
        run: |
          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
          xcrun simctl bootstatus $UDID -b

      - name: Test
        run: |
          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
          do
            xcrun simctl install booted $TEST
            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
            xcrun simctl launch --console booted $TEST_ID
            xcrun simctl uninstall booted $TEST_ID
          done

  Android:
    runs-on: macos-latest
    defaults:
      run:
        working-directory: build
    steps:
      - uses: actions/checkout@v2

      - name: Create build directory
        run: mkdir -p build
        working-directory: .

      - name: Start emulator
        run: |
          echo "y" | $ANDROID_HOME/tools/bin/sdkmanager --install 'system-images;android-24;default;x86_64'
          echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-24;default;x86_64' --force
          $ANDROID_HOME/emulator/emulator -list-avds
          echo "Starting emulator"
          # Start emulator in background
          nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot > /dev/null 2>&1 &
          echo "Emulator starting"

      - name: Configure
        run: cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_HOME/ndk-bundle/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..

      - name: Build
        run: cmake --build . --parallel

      - name: Wait for emulator ready
        run: |
          $ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 10; done; input keyevent 82'
          $ANDROID_HOME/platform-tools/adb devices
          $ANDROID_HOME/platform-tools/adb shell getprop ro.product.cpu.abi
          echo "Emulator started"

      - name: Deploy tests
        run: |
          adb push tests /data/local/tmp
          adb shell find /data/local/tmp/tests -maxdepth 1 -exec chmod +x {} \\\;

      - name: Test
        run: adb shell find /data/local/tmp/tests -name "*_tests" -maxdepth 1 -exec {} \\\;

================================================
FILE: examples/libraries/GSL/.gitignore
================================================
CMakeFiles
build
tests/CMakeFiles
tests/Debug
*.opensdf
*.sdf
tests/*tests.dir
*.vcxproj
*.vcxproj.filters
*.sln
*.tlog
Testing/Temporary/*.*
CMakeCache.txt
*.suo
.vs/
.vscode/


================================================
FILE: examples/libraries/GSL/.travis.yml
================================================

language: cpp
notifications:
  email: false

# Use Linux unless specified otherwise
os: linux
dist: bionic

cache:
  directories:
    - ${TRAVIS_BUILD_DIR}/deps

stages:
  - name: Latest     # build jobs to run first and always
  - name: Validation # run other jobs
  - name: Legacy     # build with all other supported compilers

jobs:
  include:

    ##########################################################################
    # Validate CMake configuration
    ##########################################################################

    - name: CMake 3.1.3 - latest
      stage: Validation
      env: &CMAKE_VERSION_LIST
      - CMAKE_VERSION: '"3.17.0 3.16.5 3.15.7 3.14.7 3.13.5 3.12.4 3.11.4 3.10.3 3.9.6 3.8.2 3.7.2 3.6.3 3.5.2 3.4.3 3.3.2 3.2.3 3.1.3"'
      - GSL_CXX_STANDARD: 14
      addons: # Get latest release (candidate)
        apt:
          sources:
          - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic main'
            key_url: 'https://apt.kitware.com/keys/kitware-archive-latest.asc'
          - sourceline: 'deb https://apt.kitware.com/ubuntu/ bionic-rc main'
          packages:
          - cmake
      script:
      - |
        cd ./build
        ( set -eu
          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
          export CXX=clang++
          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
        )

    - name: CMake 3.2.3 - 3.17.0
      stage: Validation
      os: osx
      osx_image: xcode11.3
      env:
      - CMAKE_VERSION: '"3.17.0 3.16.5 3.15.7 3.14.7 3.13.5 3.12.4 3.11.4 3.10.3 3.9.6 3.8.2 3.7.2 3.6.3 3.5.2 3.4.3 3.3.2 3.2.3"'
      script:
      - |
        cd ./build
        ( set -eu
          for CMAKE in ${CMAKE_path[@]}; do test_CMake_generate $CMAKE; done
        )

    ##########################################################################
    # AppleClang on OSX
    ##########################################################################

    # Xcode 8.3
    - name: AppleClang Xcode-8.3 C++14 Debug
      stage: Legacy
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode8.3
    - name: AppleClang Xcode-8.3 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode8.3

    # Xcode 9.0 earliest C++17 support
    - name: AppleClang Xcode-9.0 C++17 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode9 # AppleClang 9.1.0 same compiler in Xcode 9.0, 9.1 and 9.2
    - name: AppleClang Xcode-9.0 C++17 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode9
    - name: AppleClang Xcode-9.0 C++14 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode9
    - name: AppleClang Xcode-9.0 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode9

    # Xcode 9.4
    - name: AppleClang Xcode-9.4 C++14 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode9.4 # AppleClang 9.1.0 same compiler as Xcode 9.3
    - name: AppleClang Xcode-9.4 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode9.4
    - name: AppleClang Xcode-9.4 C++17 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode9.4
    - name: AppleClang Xcode-9.4 C++17 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode9.4

    # Xcode 10.1
    - name: AppleClang Xcode-10.1 C++14 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode10.1 # AppleClang 10.0.0 same compiler as Xcode 10.0
    - name: AppleClang Xcode-10.1 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode10.1
    - name: AppleClang Xcode-10.1 C++17 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode10.1
    - name: AppleClang Xcode-10.1 C++17 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode10.1

    # Xcode 10.3
    - name: AppleClang Xcode-10.3 C++14 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode10.3 # AppleClang 10.0.1 same compiler as Xcode 10.2
    - name: AppleClang Xcode-10.3 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode10.3
    - name: AppleClang Xcode-10.3 C++17 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode10.3
    - name: AppleClang Xcode-10.3 C++17 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode10.3

    # Xcode 11.3
    - name: AppleClang Xcode-11.3 C++17 Debug
      stage: Latest
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode11.3 # AppleClang 11.0.0 linker update / same as Xcode 11.2
    - name: AppleClang Xcode-11.3 C++17 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=17
      os: osx
      osx_image: xcode11.3
    - name: AppleClang Xcode-11.3 C++14 Debug
      env: BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode11.3
    - name: AppleClang Xcode-11.3 C++14 Release
      env: BUILD_TYPE=Release GSL_CXX_STANDARD=14
      os: osx
      osx_image: xcode11.3

    ##########################################################################
    # Clang on Linux
    ##########################################################################

    # Clang 3.6
    - name: Clang-3.6 C++14 Debug
      stage: Legacy
      dist: xenial
      env: CXX=clang++-3.6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang36
        apt:
          packages:
            - clang-3.6
    - name: Clang-3.6 C++14 Release
      dist: xenial
      env: CXX=clang++-3.6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang36

    # Clang 3.7
    - name: Clang-3.7 C++14 Debug
      dist: xenial
      env: CXX=clang++-3.7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang37
        apt:
          packages:
            - clang-3.7
    - name: Clang-3.7 C++14 Release
      dist: xenial
      env: CXX=clang++-3.7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang37

    # Clang 3.8
    - name: Clang-3.8 C++14 Debug
      dist: xenial
      env: CXX=clang++-3.8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang38
        apt:
          packages:
            - clang-3.8
    - name: Clang-3.8 C++14 Release
      dist: xenial
      env: CXX=clang++-3.8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang38

    # Clang 3.9
    - name: Clang-3.9 C++14 Debug
      env: CXX=clang++-3.9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang39
        apt:
          packages:
            - clang-3.9
    - name: Clang-3.9 C++14 Release
      env: CXX=clang++-3.9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang39

    # Clang 4.0
    - name: Clang-4.0 C++14 Debug
      env: CXX=clang++-4.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang40
        apt:
          packages:
            - clang-4.0
    - name: Clang-4.0 C++14 Release
      env: CXX=clang++-4.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang40

    # Clang 5.0
    - name: Clang-5.0 C++14 Debug
      env: CXX=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang50
        apt:
          packages:
            - clang-5.0
    - name: Clang-5.0 C++14 Release
      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang50
    - name: Clang-5.0 C++17 Debug
      env: CXX=clang++-5.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *clang50
    - name: Clang 5.0 C++17 Release
      env: CXX=clang++-5.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *clang50

    # Clang 6.0
    - name: Clang-6.0 C++14 Debug
      env: CXX=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang60
        apt:
          packages:
            - clang-6.0
    - name: Clang 6.0 C++14 Release
      env: CXX=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang60
    - name: Clang-6.0 C++17 Debug
      env: CXX=clang++-6.0 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *clang60
    - name: Clang 6.0 C++17 Release
      env: CXX=clang++-6.0 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *clang60

    # Clang 7 (default on Xenial and Bionic images)
    - name: Clang-7 C++14 Debug
      env: CXX=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=14
    - name: Clang-7 C++14 Release
      env: CXX=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=14
    - name: Clang-7 C++17 Debug
      env: CXX=clang++ BUILD_TYPE=Debug GSL_CXX_STANDARD=17
    - name: Clang-7 C++17 Release
      env: CXX=clang++ BUILD_TYPE=Release GSL_CXX_STANDARD=17

    # Clang 8
    - name: Clang-8 C++14 Debug
      env: CXX=clang++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang8
        apt:
          sources:
          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main'
            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
          packages:
          - clang-8
    - name: Clang-8 C++14 Release
      env: CXX=clang++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang8
    - name: Clang-8 C++17 Debug
      env: CXX=clang++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *clang8
    - name: Clang-8 C++17 Release
      env: CXX=clang++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *clang8

    # Clang 9
    - name: Clang-9 C++14 Debug
      env: CXX=clang++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang9
        apt:
          sources:
          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
          packages:
          - clang-9
    - name: Clang-9 C++14 Release
      env: CXX=clang++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang9
    - name: Clang-9 C++17 Debug
      env: CXX=clang++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *clang9
    - name: Clang-9 C++17 Release
      env: CXX=clang++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *clang9

    # Clang 10
    - name: Clang-10 C++14 Debug
      stage: Latest
      env: CXX=clang++-10 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &clang10
        apt:
          sources:
          - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
            key_url: https://apt.llvm.org/llvm-snapshot.gpg.key
          packages:
          - clang-10
    - name: Clang-10 C++14 Release
      env: CXX=clang++-10 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *clang10
    - name: Clang-10 C++17 Debug
      env: CXX=clang++-10 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *clang10
    - name: Clang-10 C++17 Release
      env: CXX=clang++-10 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *clang10

    ##########################################################################
    # GCC on Linux
    ##########################################################################

    # GCC 5 (default on the Xenial image)
    - name: GCC-5 C++14 Debug
      stage: Legacy
      dist: xenial
      env: CXX=g++-5 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
    - name: GCC-5 C++14 Release
      dist: xenial
      env: CXX=g++-5 BUILD_TYPE=Release GSL_CXX_STANDARD=14

    # GCC 6
    - name: GCC-6 C++14 Debug
      env: CXX=g++-6 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &gcc6
        apt:
          packages: g++-6
    - name: GCC-6 C++14 Release
      env: CXX=g++-6 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *gcc6

    # GCC 7 (default on the Bionic image)
    - name: GCC-7 C++14 Debug
      env: CXX=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
    - name: GCC-7 C++14 Release
      env: CXX=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=14
    - name: GCC-7 C++17 Debug
      env: CXX=g++-7 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
    - name: GCC-7 C++17 Release
      env: CXX=g++-7 BUILD_TYPE=Release GSL_CXX_STANDARD=17

    # GCC 8
    - name: GCC-8 C++14 Debug
      env: CXX=g++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &gcc8
        apt:
          packages: g++-8
    - name: GCC-8 C++14 Release
      env: CXX=g++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *gcc8
    - name: GCC-8 C++17 Debug
      env: CXX=g++-8 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *gcc8
    - name: GCC-8 C++17 Release
      env: CXX=g++-8 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *gcc8

    # GCC 9
    - name: GCC-9 C++14 Debug
      stage: Latest
      env: CXX=g++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=14
      addons: &gcc9
        apt:
          sources:
          - sourceline: ppa:ubuntu-toolchain-r/test
          packages:
          - g++-9
    - name: GCC-9 C++14 Release
      env: CXX=g++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=14
      addons: *gcc9
    - name: GCC-9 C++17 Debug
      env: CXX=g++-9 BUILD_TYPE=Debug GSL_CXX_STANDARD=17
      addons: *gcc9
    - name: GCC-9 C++17 Release
      env: CXX=g++-9 BUILD_TYPE=Release GSL_CXX_STANDARD=17
      addons: *gcc9

before_install:
  - |
    # Configuration
    JOBS=2 # Travis machines have 2 cores
    # Dependencies required by the CI (cached directory)
    DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
  - |
    # Setup
    mkdir -p "${DEPS_DIR:?}" && cd "${DEPS_DIR:?}"
    mkdir -p ~/tools && cd ~/tools
    if [[ ${TRAVIS_OS_NAME:?} == "osx" ]]; then
      export PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
    fi
  - |
    # Helper functions
    # usage: if [[ $(check_url '<url>') ]]; then ...
    function check_url {( set +e
      if [[ "$1" =~ 'github.com' ]]; then # check for first byte
        if curl --fail --silent --output /dev/null --connect-timeout 12 --range 0-0 "$1"
        then echo true; fi
      else # request head
        if curl --fail --silent --output /dev/null --connect-timeout 12 --head "$1"
        then echo true; fi
      fi
      return
    )}

install:
  ############################################################################
  # Install a different CMake version (or several)
  ############################################################################
  - |
    # Install CMake versions
    ( set -euo pipefail
      if [[ ${CMAKE_VERSION:-} ]]; then
        if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
          OS="Linux"; EXT="sh"
          if [[ ! ("${CMAKE_VERSION:-}" =~ .+[' '].+) ]]; then
            # Single entry -> default CMake version
            CMAKE_DEFAULT_DIR="/usr/local"
          fi
        elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then OS="Darwin"; EXT="tar.gz"
        else echo "CMake install not supported for this OS."; exit 1
        fi
        CMAKE_INSTALLER="install-cmake.${EXT}"
      fi
      for VERSION in ${CMAKE_VERSION:-}; do
        CMAKE_URL="https://github.com/Kitware/CMake/releases/download/v${VERSION}/cmake-${VERSION}-${OS}-x86_64.${EXT}"
        if [[ $(check_url "$CMAKE_URL") ]]; then
          curl -sSL ${CMAKE_URL} -o ${CMAKE_INSTALLER}
          CMAKE_DIR="${CMAKE_DEFAULT_DIR:-"${HOME}/tools/cmake-${VERSION}"}"
          mkdir -p ${CMAKE_DIR}
          if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
            chmod +x ${CMAKE_INSTALLER}
            sudo ./${CMAKE_INSTALLER} --prefix=${CMAKE_DIR} --skip-license
          else # OSX
            mkdir -p ./CMake_tmp
            tar --extract --gzip --file=${CMAKE_INSTALLER} --directory=./CMake_tmp
            mv ./CMake_tmp/*/CMake.app/Contents/* ${CMAKE_DIR}
          fi
          rm --recursive --force ./CMake_tmp ${CMAKE_INSTALLER}
        else echo 'Invalid url!'; echo "Version: ${VERSION}"
        fi
      done
    )
    if [[ ${CMAKE_VERSION:-} && "${TRAVIS_OS_NAME:?}" == "osx" && ! ("${CMAKE_VERSION:-}" =~ .+[' '].+) ]]
    then # Single entry -> default CMake version
      export PATH=${HOME}/tools/cmake-${CMAKE_VERSION:?}/bin:$PATH
    fi
    CMAKE_path=("cmake") # start with installed CMake version
    for VERSION in ${CMAKE_VERSION:-}; do
      tmp_path="$HOME/tools/cmake-${VERSION:?}/bin/cmake"
      if [[ -x "$(command -v ${tmp_path:?})" ]]; then CMAKE_path+=("${tmp_path:?}"); fi
    done
    function test_CMake_generate {
      # $1: cmake or full path to cmake
      shopt -s extglob
      if [[ "$1" == "cmake" || -x "$(command -v $1)" && "$1" =~ .*cmake$ ]]; then
        echo "----------------"
        $1 --version
        echo "Configuration = ${BUILD_TYPE:-Debug}"
        $1 -DCMAKE_BUILD_TYPE=${BUILD_TYPE:-Debug} ${CMAKE_GEN_FLAGS[@]:?} ..
        rm -rf !(tests/googletest-*)
        if [[ ! ${BUILD_TYPE:-} ]]; then echo "" && echo "Configuration = Release"
          $1 -DCMAKE_BUILD_TYPE=Release ${CMAKE_GEN_FLAGS[@]:?} ..
          rm -rf !(tests/googletest-*)
        fi
      else echo "Non existing command: $1"
      fi
    }
  - |
    # CMake wrapper (Trusty, Xenial & Bionic); restore default behaviour.
    if [[ "${TRAVIS_OS_NAME:?}" == "linux" &&
          "$(lsb_release --codename)" =~ (trusty|xenial|bionic)$ ]]
    then
      if [[ -x $(command -v /usr/local/bin/cmake) ]]; then
        function cmake { command /usr/local/bin/cmake $@; }
      elif [[ -x $(command -v /usr/bin/cmake) ]]; then
        function cmake { command /usr/bin/cmake $@; }
      fi
    fi

  ############################################################################
  # [linux]: Install the right version of libc++
  # Based on https://github.com/ldionne/hana/blob/master/.travis.yml
  ############################################################################
  - |
    LLVM_INSTALL=${DEPS_DIR:?}/llvm/install
    # if in linux and compiler clang and llvm not installed
    if [[ "${TRAVIS_OS_NAME:?}" == "linux" && "${CXX%%+*}" == "clang" && -n "$(ls -A ${LLVM_INSTALL:?})" ]]; then
      if   [[ "${CXX}" == "clang++-3.6" ]]; then LLVM_VERSION="3.6.2";
      elif [[ "${CXX}" == "clang++-3.7" ]]; then LLVM_VERSION="3.7.1";
      elif [[ "${CXX}" == "clang++-3.8" ]]; then LLVM_VERSION="3.8.1";
      elif [[ "${CXX}" == "clang++-3.9" ]]; then LLVM_VERSION="3.9.1";
      fi
      LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/llvm-${LLVM_VERSION}.src.tar.xz"
      LIBCXX_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxx-${LLVM_VERSION}.src.tar.xz"
      LIBCXXABI_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxxabi-${LLVM_VERSION}.src.tar.xz"
      mkdir -p llvm llvm/build llvm/projects/libcxx llvm/projects/libcxxabi
      travis_retry wget -O - ${LLVM_URL} | tar --strip-components=1 -xJ -C llvm
      travis_retry wget -O - ${LIBCXX_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxx
      travis_retry wget -O - ${LIBCXXABI_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxxabi
      (cd llvm/build && cmake .. -DCMAKE_INSTALL_PREFIX=${LLVM_INSTALL})
      (cd llvm/build/projects/libcxx && make install -j2)
      (cd llvm/build/projects/libcxxabi && make install -j2)
      export CXXFLAGS="-isystem ${LLVM_INSTALL}/include/c++/v1"
      export LDFLAGS="-L ${LLVM_INSTALL}/lib -l c++ -l c++abi"
      export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${LLVM_INSTALL}/lib"
    fi

before_script:
  - |
    cd "${TRAVIS_BUILD_DIR:?}"
    mkdir build && cd build
    if [[ ${GSL_CXX_STANDARD:-} ]]; then 
      CMAKE_GEN_FLAGS=("-DGSL_CXX_STANDARD=$GSL_CXX_STANDARD")
    fi
    CMAKE_GEN_FLAGS+=("-Wdev -Werror=dev --warn-uninitialized")

script:
  # generate build files
  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE:?} ${CMAKE_GEN_FLAGS[@]:?}
  # build and run tests
  - cmake --build . -- -j${JOBS}
  - ctest --output-on-failure -j${JOBS}


================================================
FILE: examples/libraries/GSL/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1.3...3.16)

project(GSL VERSION 3.0.2 LANGUAGES CXX)

include(ExternalProject)
find_package(Git)

# Use GNUInstallDirs to provide the right locations on all platforms
include(GNUInstallDirs)

# creates a library GSL which is an interface (header files only)
add_library(GSL INTERFACE)

# determine whether this is a standalone project or included by other projects
set(GSL_STANDALONE_PROJECT OFF)
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
    set(GSL_STANDALONE_PROJECT ON)
endif ()

set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
set(GSL_CXX_STD "cxx_std_${GSL_CXX_STANDARD}")

if (MSVC)
    set(GSL_CXX_STD_OPT "-std:c++${GSL_CXX_STANDARD}")
else()
    set(GSL_CXX_STD_OPT "-std=c++${GSL_CXX_STANDARD}")
endif()

# when minimum version required is 3.8.0 remove if below
# both branches do exactly the same thing
if (CMAKE_VERSION VERSION_LESS 3.7.9)
    include(CheckCXXCompilerFlag)
    CHECK_CXX_COMPILER_FLAG("${GSL_CXX_STD_OPT}" COMPILER_SUPPORTS_CXX_STANDARD)

    if(COMPILER_SUPPORTS_CXX_STANDARD)
        target_compile_options(GSL INTERFACE "${GSL_CXX_STD_OPT}")
    else()
        message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no c++${GSL_CXX_STANDARD} support. Please use a different C++ compiler.")
    endif()
else ()
    target_compile_features(GSL INTERFACE "${GSL_CXX_STD}")
    # on *nix systems force the use of -std=c++XX instead of -std=gnu++XX (default)
    set(CMAKE_CXX_EXTENSIONS OFF)
endif()

# add definitions to the library and targets that consume it
target_compile_definitions(GSL INTERFACE
    $<$<CXX_COMPILER_ID:MSVC>:
        # remove unnecessary warnings about unchecked iterators
        _SCL_SECURE_NO_WARNINGS
        # remove deprecation warnings about std::uncaught_exception() (from catch)
        _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING
    >
)

# add include folders to the library and targets that consume it
# the SYSTEM keyword suppresses warnings for users of the library
if(GSL_STANDALONE_PROJECT)
    target_include_directories(GSL INTERFACE
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
    )
else()
    target_include_directories(GSL SYSTEM INTERFACE
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
    )
endif()


if (CMAKE_VERSION VERSION_GREATER 3.7.8)
    if (MSVC_IDE)
        option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
    else()
        set(VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
    endif()

    # add natvis file to the library so it will automatically be loaded into Visual Studio
    if(VS_ADD_NATIVE_VISUALIZERS)
        target_sources(GSL INTERFACE
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis>
        )
    endif()
endif()

install(TARGETS GSL EXPORT Microsoft.GSLConfig)
install(
    DIRECTORY include/gsl
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
# Make library importable by other projects
install(EXPORT Microsoft.GSLConfig NAMESPACE Microsoft.GSL:: DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
export(TARGETS GSL NAMESPACE Microsoft.GSL:: FILE Microsoft.GSLConfig.cmake)

# Add find_package() versioning support. The version for
# generated Microsoft.GSLConfigVersion.cmake will be used from
# last project() command. The version's compatibility is set between all
# minor versions (as it was in prev. GSL releases).
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
    COMPATIBILITY SameMajorVersion
)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)

# Add Microsoft.GSL::GSL alias for GSL so that dependents can be agnostic about
# whether GSL was added via `add_subdirectory` or `find_package`
add_library(Microsoft.GSL::GSL ALIAS GSL)

option(GSL_TEST "Generate tests." ${GSL_STANDALONE_PROJECT})
if (GSL_TEST)
    enable_testing()
    if(IOS)
        add_compile_definitions(
            GTEST_HAS_DEATH_TEST=1
        )
    endif()
    add_subdirectory(tests)
endif ()


================================================
FILE: examples/libraries/GSL/CMakeSettings.json
================================================
{
  "configurations": [
    {
      "name": "x64-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [
        "msvc_x64_x64"
      ],
      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
      "cmakeCommandArgs": "-DGSL_CXX_STANDARD=17",
      "buildCommandArgs": "-v",
      "ctestCommandArgs": "",
      "codeAnalysisRuleset": "CppCoreCheckRules.ruleset"
    }
  ]
}

================================================
FILE: examples/libraries/GSL/CONTRIBUTING.md
================================================
## Contributing to the Guidelines Support Library

The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines). GSL design changes are made only as a result of modifications to the Guidelines. 

GSL is accepting contributions that improve or refine any of the types in this library as well as ports to other platforms. Changes should have an issue 
tracking the suggestion that has been approved by the maintainers. Your pull request should include a link to the bug that you are fixing. If you've submitted 
a PR, please post a comment in the associated issue to avoid duplication of effort.

## Legal
You will need to complete a Contributor License Agreement (CLA). Briefly, this agreement testifies that you are granting us and the community permission to 
use the submitted change according to the terms of the project's license, and that the work being submitted is under appropriate copyright.

Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally.

## Housekeeping
Your pull request should: 

* Include a description of what your change intends to do
* Be a child commit of a reasonably recent commit in the **master** branch 
    * Requests need not be a single commit, but should be a linear sequence of commits (i.e. no merge commits in your PR)
* It is desirable, but not necessary, for the tests to pass at each commit. Please see [README.md](./README.md) for instructions to build the test suite. 
* Have clear commit messages 
    * e.g. "Fix issue", "Add tests for type", etc.
* Include appropriate tests 
    * Tests should include reasonable permutations of the target fix/change
    * Include baseline changes with your change
    * All changed code must have 100% code coverage
* To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration


================================================
FILE: examples/libraries/GSL/GSL.natvis
================================================
<?xml version="1.0" encoding="utf-8"?>
<!-- 
    This will make GitHub and some editors recognize this code as XML: 
    vim: syntax=xml
-->
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
    <!-- These types are from the gsl_assert header. -->
    <Type Name="gsl::fail_fast">
        <!-- na hides the address, otherwise it would appear as 0x.... "Message" -->
        <DisplayString>{_Data._What,nasb}</DisplayString>
    </Type>

    <!-- These types are from the gsl_util header. -->
    <Type Name="gsl::final_action&lt;*&gt;">
        <DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString>
        <Expand>
            <Item Name="[invoke]">invoke_</Item>
            <Item Name="[callback]">f_</Item>
        </Expand>
    </Type>

    <!-- These types are from the span header. -->
    <!-- This is for dynamic_extent spans. -->
    <Type Name="gsl::span&lt;*, -1&gt;">
        <DisplayString>{{ extent = {storage_.size_} }}</DisplayString>
        <Expand>
            <ArrayItems>
                <Size>storage_.size_</Size>
                <ValuePointer>storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>

    <!-- This works for constexpr size spans. -->
    <Type Name="gsl::span&lt;*, *&gt;">
        <DisplayString>{{ extent = {extent} }}</DisplayString>
        <Expand>
            <ArrayItems>
                <Size>extent</Size>
                <ValuePointer>storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>

    <!-- This is for dynamic_extent string_spans. -->
    <Type Name="gsl::basic_string_span&lt;*, -1&gt;">
        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
        <Expand>
            <Item Name="[size]">span_.storage_.size_</Item>
            <ArrayItems>
                <Size>span_.storage_.size_</Size>
                <ValuePointer>span_.storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>

    <!-- This works for constexpr size string_spans. -->
    <Type Name="gsl::basic_string_span&lt;*, *&gt;">
        <DisplayString>{span_.storage_.data_,[span_.extent]na}</DisplayString>
        <Expand>
            <Item Name="[size]">span_.extent</Item>
            <ArrayItems>
                <Size>span_.extent</Size>
                <ValuePointer>span_.storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>

    <!-- This is for dynamic_extent zstring_spans. -->
    <Type Name="gsl::basic_zstring_span&lt;*, -1&gt;">
        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
        <Expand>
            <Item Name="[size]">span_.storage_.size_</Item>
            <ArrayItems>
                <Size>span_.storage_.size_</Size>
                <ValuePointer>span_.storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>
    
    <!-- This works for constexpr size string_spans. -->
    <Type Name="gsl::basic_zstring_span&lt;*, *&gt;">
        <DisplayString>{span_.storage_.data_,[span_.extent]na}</DisplayString>
        <Expand>
            <Item Name="[size]">span_.extent</Item>
            <ArrayItems>
                <Size>span_.extent</Size>
                <ValuePointer>span_.storage_.data_</ValuePointer>
            </ArrayItems>
        </Expand>
    </Type>
    
    <!-- These types are from the gsl header. -->
    <Type Name="gsl::not_null&lt;*&gt;">
        <!-- We can always dereference this since it's an invariant. -->
        <DisplayString>value = {*ptr_}</DisplayString>
    </Type>
</AutoVisualizer>  


================================================
FILE: examples/libraries/GSL/LICENSE
================================================
Copyright (c) 2015 Microsoft Corporation. All rights reserved. 
 
This code is licensed under the MIT License (MIT). 

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. 


================================================
FILE: examples/libraries/GSL/README.md
================================================
# GSL: Guidelines Support Library [![Build Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL) [![Build status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)

The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org).
This repo contains Microsoft's implementation of GSL.

The library includes types like `span<T>`, `string_span`, `owner<>` and others.

The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support. There are specific workarounds to support MSVC 2015.

While some types have been broken out into their own headers (e.g. [gsl/span](./include/gsl/span)),
it is simplest to just include [gsl/gsl](./include/gsl/gsl) and gain access to the entire library.

> NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to
other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing.

# Project Code of Conduct
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

# Usage of Third Party Libraries
This project makes use of the [Google Test](https://github.com/google/googletest) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Google Test.

# Quick Start
## Supported Platforms
The test suite that exercises GSL has been built and passes successfully on the following platforms:<sup>1)</sup>

* Windows using Visual Studio 2015
* Windows using Visual Studio 2017
* Windows using Clang/LLVM 3.6
* Windows using Clang/LLVM 7.0.0
* Windows using GCC 5.1
* Windows using Intel C++ Compiler 18.0
* GNU/Linux using Clang/LLVM 3.6-3.9
* GNU/Linux using Clang/LLVM 4.0
* GNU/Linux using Clang/LLVM 5.0
* GNU/Linux using Clang/LLVM 6.0
* GNU/Linux using Clang/LLVM 7.0
* GNU/Linux using GCC 5.1
* OS X Mojave 10.14.4 using Apple LLVM version 10.0.0 (10.0.1.10010046)
* OS X Mojave 10.14.3 using Apple LLVM version 10.0.0 (clang-1000.11.45.5)
* OS X Yosemite using Xcode with Apple Clang 7.0.0.7000072
* OS X Yosemite using GCC-5.2.0
* OS X Sierra 10.12.4 using Apple LLVM version 8.1.0 (Clang-802.0.42)
* OS X El Capitan (10.11) using Xcode with AppleClang 8.0.0.8000042
* OS X High Sierra 10.13.2 (17C88) using Apple LLVM version 9.0.0 (clang-900.0.39.2)
* FreeBSD 10.x with Clang/LLVM 3.6
* iOS 8 and newer using AppleClang 11.0.3.11030032
* Android 4.1 and newer (API Level 16 and above) using NDK r21b

> If you successfully port GSL to another platform, we would love to hear from you. Please submit an issue to let us know. Also please consider
contributing any changes that were necessary back to this project to benefit the wider community.

<sup>1)</sup> For `gsl::byte` to work correctly with Clang and GCC you might have to use the ` -fno-strict-aliasing` compiler option.

## Building the tests
To build the tests, you will require the following:

* [CMake](http://cmake.org), version 3.1.3 (3.2.3 for AppleClang) or later to be installed and in your PATH.

These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.

1. Create a directory to contain the build outputs for a particular architecture (we name it c:\GSL\build-x86 in this example).

        cd GSL
        md build-x86
        cd build-x86

2. Configure CMake to use the compiler of your choice (you can see a list by running `cmake --help`).

        cmake -G "Visual Studio 14 2015" c:\GSL

3. Build the test suite (in this case, in the Debug configuration, Release is another good choice).

        cmake --build . --config Debug

4. Run the test suite.

        ctest -C Debug

All tests should pass - indicating your platform is fully supported and you are ready to use the GSL types!

## Building GSL - Using vcpkg

You can download and install GSL using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:

    git clone https://github.com/Microsoft/vcpkg.git
    cd vcpkg
    ./bootstrap-vcpkg.sh
    ./vcpkg integrate install
    vcpkg install ms-gsl

The GSL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.

## Using the libraries
As the types are entirely implemented inline in headers, there are no linking requirements.

You can copy the [gsl](./include/gsl) directory into your source tree so it is available
to your compiler, then include the appropriate headers in your program.

Alternatively set your compiler's *include path* flag to point to the GSL development folder (`c:\GSL\include` in the example above) or installation folder (after running the install). Eg.

MSVC++

    /I c:\GSL\include

GCC/clang

    -I$HOME/dev/GSL/include

Include the library using:

    #include <gsl/gsl>

## Usage in CMake

The library provides a Config file for CMake, once installed it can be found via

    find_package(Microsoft.GSL CONFIG)

Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
`target_link_libraries` mechanism.

## Debugging visualization support
For Visual Studio users, the file [GSL.natvis](./GSL.natvis) in the root directory of the repository can be added to your project if you would like more helpful visualization of GSL types in the Visual Studio debugger than would be offered by default.


================================================
FILE: examples/libraries/GSL/ThirdPartyNotices.txt
================================================

THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
Do Not Translate or Localize

GSL: Guidelines Support Library incorporates third party material from the projects listed below.

-------------------------------------------------------------------------------
Software: Google Test
Owner: Google Inc.
Source URL: github.com/google/googletest
License: BSD 3 - Clause
Text:
    Copyright 2008, Google Inc.
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are
    met:

        * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
        * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following disclaimer
    in the documentation and/or other materials provided with the
    distribution.
        * Neither the name of Google Inc. nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-------------------------------------------------------------------------------


================================================
FILE: examples/libraries/GSL/appveyor.yml
================================================
shallow_clone: true

platform:
  - x86
  - x64

configuration:
  - Debug
  - Release

image:
  - Visual Studio 2015
  - Visual Studio 2017
  - Visual Studio 2019

environment:
  NINJA_TAG: v1.8.2
  NINJA_SHA512: 9B9CE248240665FCD6404B989F3B3C27ED9682838225E6DC9B67B551774F251E4FF8A207504F941E7C811E7A8BE1945E7BCB94472A335EF15E23A0200A32E6D5
  NINJA_PATH: C:\Tools\ninja\ninja-%NINJA_TAG%
  VCVAR2015: 'C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat'
  VCVAR2017: 'C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat'
  VCVAR2019: 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat'
  matrix:
    - GSL_CXX_STANDARD: 14
      USE_TOOLSET: MSVC
      USE_GENERATOR: MSBuild
    - GSL_CXX_STANDARD: 17
      USE_TOOLSET: MSVC
      USE_GENERATOR: MSBuild
    - GSL_CXX_STANDARD: 14
      USE_TOOLSET: LLVM
      USE_GENERATOR: Ninja
    - GSL_CXX_STANDARD: 17
      USE_TOOLSET: LLVM
      USE_GENERATOR: Ninja

matrix:
    exclude:
    - image: Visual Studio 2015
      GSL_CXX_STANDARD: 17
    - image: Visual Studio 2015
      USE_TOOLSET: LLVM
      USE_GENERATOR: MSBuild

cache:
  - C:\cmake-3.14.4-win32-x86
  - C:\Tools\ninja

install:
  - ps: |
      if (![IO.File]::Exists("$env:NINJA_PATH\ninja.exe")) {
        Start-FileDownload `
          "https://github.com/ninja-build/ninja/releases/download/$env:NINJA_TAG/ninja-win.zip"
        $hash = (Get-FileHash ninja-win.zip -Algorithm SHA512).Hash
        if ($env:NINJA_SHA512 -eq $hash) {
          7z e -y -bso0 ninja-win.zip -o"$env:NINJA_PATH"
        } else { Write-Warning "Ninja download hash changed!"; Write-Output "$hash" }
      }
      if ([IO.File]::Exists("$env:NINJA_PATH\ninja.exe")) {
        $env:PATH = "$env:NINJA_PATH;$env:PATH"
      } else { Write-Warning "Failed to find ninja.exe in expected location." }
      if ($env:USE_TOOLSET -ne "LLVM") {
        if (![IO.File]::Exists("C:\cmake-3.14.0-win32-x86\bin\cmake.exe")) {
          Start-FileDownload 'https://cmake.org/files/v3.14/cmake-3.14.4-win32-x86.zip'
          7z x -y -bso0 cmake-3.14.4-win32-x86.zip -oC:\
        }
        $env:PATH="C:\cmake-3.14.4-win32-x86\bin;$env:PATH"
      }

before_build:
  - ps: |
      if ("$env:USE_GENERATOR" -eq "Ninja") {
        $GeneratorFlags = '-k 10'
        $Architecture = $env:PLATFORM
        if ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2015") {
          $env:VCVARSALL = "`"$env:VCVAR2015`" $Architecture"
        } elseif ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2017") {
          $env:VCVARSALL = "`"$env:VCVAR2017`" $Architecture"
        } else {
          $env:VCVARSALL = "`"$env:VCVAR2019`" $Architecture"
        }
        $env:CMakeGenFlags = "-G Ninja -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
      } else {
        $GeneratorFlags = '/m /v:minimal'
        if ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2015") {
          $Generator = 'Visual Studio 14 2015'
        } elseif ("$env:APPVEYOR_BUILD_WORKER_IMAGE" -eq "Visual Studio 2017") {
          $Generator = 'Visual Studio 15 2017'
        } else {
          $Generator = 'Visual Studio 16 2019'
        }
        if ("$env:PLATFORM" -eq "x86") { 
            $Architecture = "Win32"
        } else { 
            $Architecture = "x64" 
        }
        if ("$env:USE_TOOLSET" -eq "LLVM") {
          $env:CMakeGenFlags = "-G `"$Generator`" -A $Architecture -T llvm -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
        } else {
          $env:CMakeGenFlags = "-G `"$Generator`" -A $Architecture -DGSL_CXX_STANDARD=$env:GSL_CXX_STANDARD"
        }
      }
      if ("$env:USE_TOOLSET" -eq "LLVM") {
        $env:CC  = "clang-cl"
        $env:CXX = "clang-cl"
        if ("$env:PLATFORM" -eq "x86") {
          $env:CFLAGS   = "-m32";
          $env:CXXFLAGS = "-m32";
        } else {
          $env:CFLAGS   = "-m64";
          $env:CXXFLAGS = "-m64";
        }
      }
      $env:CMakeBuildFlags = "--config $env:CONFIGURATION -- $GeneratorFlags"
  - mkdir build
  - cd build
  - if %USE_GENERATOR%==Ninja (call %VCVARSALL%)
  - echo %CMakeGenFlags%
  - cmake .. %CMakeGenFlags%

build_script:
  - echo %CMakeBuildFlags%
  - cmake --build . %CMakeBuildFlags%

test_script:
  - ctest -j2

deploy: off


================================================
FILE: examples/libraries/GSL/include/gsl/gsl
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_GSL_H
#define GSL_GSL_H

#include <gsl/gsl_algorithm> // copy
#include <gsl/gsl_assert>    // Ensures/Expects
#include <gsl/gsl_byte>      // byte
#include <gsl/gsl_util>      // finally()/narrow()/narrow_cast()...
#include <gsl/multi_span>    // multi_span, strided_span...
#include <gsl/pointers>      // owner, not_null
#include <gsl/span>          // span
#include <gsl/string_span>   // zstring, string_span, zstring_builder...

#endif // GSL_GSL_H


================================================
FILE: examples/libraries/GSL/include/gsl/gsl_algorithm
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_ALGORITHM_H
#define GSL_ALGORITHM_H

#include <gsl/gsl_assert> // for Expects
#include <gsl/span>       // for dynamic_extent, span

#include <algorithm>   // for copy_n
#include <cstddef>     // for ptrdiff_t
#include <type_traits> // for is_assignable

#ifdef _MSC_VER
#pragma warning(push)

// turn off some warnings that are noisy about our Expects statements
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(disable : 4996) // unsafe use of std::copy_n

#endif // _MSC_VER

namespace gsl
{
// Note: this will generate faster code than std::copy using span iterator in older msvc+stl
// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
          std::size_t DestExtent>
void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
{
    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
                  "Elements of source span can not be assigned to elements of destination span");
    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
                      (SrcExtent <= DestExtent),
                  "Source range is longer than target range");

    Expects(dest.size() >= src.size());
    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
    std::copy_n(src.data(), src.size(), dest.data());
}

} // namespace gsl

#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER

#endif // GSL_ALGORITHM_H


================================================
FILE: examples/libraries/GSL/include/gsl/gsl_assert
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_CONTRACTS_H
#define GSL_CONTRACTS_H

//
// Temporary until MSVC STL supports no-exceptions mode.
// Currently terminate is a no-op in this mode, so we add termination behavior back
//
#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))

#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
#include <intrin.h>
#define RANGE_CHECKS_FAILURE 0

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-noreturn"
#endif // defined(__clang__)

#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))

#include <exception>

#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))

//
// make suppress attributes parse for some compilers
// Hopefully temporary until suppression standardization occurs
//
#if defined(__clang__)
#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
#else
#if defined(_MSC_VER)
#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
#else
#define GSL_SUPPRESS(x)
#endif // _MSC_VER
#endif // __clang__

#define GSL_STRINGIFY_DETAIL(x) #x
#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)

#if defined(__clang__) || defined(__GNUC__)
#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)

#else

#define GSL_LIKELY(x) (!!(x))
#define GSL_UNLIKELY(x) (!!(x))
#endif // defined(__clang__) || defined(__GNUC__)

//
// GSL_ASSUME(cond)
//
// Tell the optimizer that the predicate cond must hold. It is unspecified
// whether or not cond is actually evaluated.
//
#ifdef _MSC_VER
#define GSL_ASSUME(cond) __assume(cond)
#elif defined(__GNUC__)
#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
#else
#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
#endif

//
// GSL.assert: assertions
//

namespace gsl
{

namespace details
{
#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)

    typedef void(__cdecl* terminate_handler)();

    // clang-format off
    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
    // clang-format on
    [[noreturn]] inline void __cdecl default_terminate_handler()
    {
        __fastfail(RANGE_CHECKS_FAILURE);
    }

    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
    {
        static terminate_handler handler = &default_terminate_handler;
        return handler;
    }

#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)

    [[noreturn]] inline void terminate() noexcept
    {
#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
        (*gsl::details::get_terminate_handler())();
#else
        std::terminate();
#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
    }

} // namespace details
} // namespace gsl

#define GSL_CONTRACT_CHECK(type, cond)                                                             \
    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())

#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)

#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
#pragma clang diagnostic pop
#endif

#endif // GSL_CONTRACTS_H


================================================
FILE: examples/libraries/GSL/include/gsl/gsl_byte
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_BYTE_H
#define GSL_BYTE_H

//
// make suppress attributes work for some compilers
// Hopefully temporary until suppression standardization occurs
//
#if defined(__clang__)
#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
#else
#if defined(_MSC_VER)
#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
#else
#define GSL_SUPPRESS(x)
#endif // _MSC_VER
#endif // __clang__

#include <type_traits>

// VS2017 15.8 added support for the __cpp_lib_byte definition
// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires
#ifdef _MSC_VER

#pragma warning(push)

// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates does not always work

#ifndef GSL_USE_STD_BYTE
// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)

#define GSL_USE_STD_BYTE 1

#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)

#define GSL_USE_STD_BYTE 0

#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
#endif // GSL_USE_STD_BYTE

#else // _MSC_VER

#ifndef GSL_USE_STD_BYTE
#include <cstddef> /* __cpp_lib_byte */
// this tests if we are under GCC or Clang with enough -std:c++1z power to get us std::byte
// also check if libc++ version is sufficient (> 5.0) or libstc++ actually contains std::byte
#if defined(__cplusplus) && (__cplusplus >= 201703L) && \
  (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  || \
   defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))

#define GSL_USE_STD_BYTE 1

#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))

#define GSL_USE_STD_BYTE 0

#endif //defined(__cplusplus) && (__cplusplus >= 201703L) &&
       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
#endif // GSL_USE_STD_BYTE

#endif // _MSC_VER

// Use __may_alias__ attribute on gcc and clang
#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
#define byte_may_alias __attribute__((__may_alias__))
#else // defined __clang__ || defined __GNUC__
#define byte_may_alias
#endif // defined __clang__ || defined __GNUC__

#if GSL_USE_STD_BYTE
#include <cstddef>
#endif

namespace gsl
{
#if GSL_USE_STD_BYTE

using std::byte;
using std::to_integer;

#else // GSL_USE_STD_BYTE

// This is a simple definition for now that allows
// use of byte within span<> to be standards-compliant
enum class byte_may_alias byte : unsigned char
{
};

template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
{
    return b = byte(static_cast<unsigned char>(b) << shift);
}

template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr byte operator<<(byte b, IntegerType shift) noexcept
{
    return byte(static_cast<unsigned char>(b) << shift);
}

template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
{
    return b = byte(static_cast<unsigned char>(b) >> shift);
}

template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr byte operator>>(byte b, IntegerType shift) noexcept
{
    return byte(static_cast<unsigned char>(b) >> shift);
}

constexpr byte& operator|=(byte& l, byte r) noexcept
{
    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
}

constexpr byte operator|(byte l, byte r) noexcept
{
    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
}

constexpr byte& operator&=(byte& l, byte r) noexcept
{
    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
}

constexpr byte operator&(byte l, byte r) noexcept
{
    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
}

constexpr byte& operator^=(byte& l, byte r) noexcept
{
    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
}

constexpr byte operator^(byte l, byte r) noexcept
{
    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
}

constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }

template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
constexpr IntegerType to_integer(byte b) noexcept
{
    return static_cast<IntegerType>(b);
}

#endif // GSL_USE_STD_BYTE

template <bool E, typename T>
constexpr byte to_byte_impl(T t) noexcept
{
    static_assert(
        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
    return static_cast<byte>(t);
}
template <>
// NOTE: need suppression since c++14 does not allow "return {t}"
// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
{
    return byte(t);
}

template <typename T>
constexpr byte to_byte(T t) noexcept
{
    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
}

template <int I>
constexpr byte to_byte() noexcept
{
    static_assert(I >= 0 && I <= 255,
                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
    return static_cast<byte>(I);
}

} // namespace gsl

#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER

#endif // GSL_BYTE_H


================================================
FILE: examples/libraries/GSL/include/gsl/gsl_util
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_UTIL_H
#define GSL_UTIL_H

#include <gsl/gsl_assert> // for Expects

#include <array>
#include <cstddef>          // for ptrdiff_t, size_t
#include <initializer_list> // for initializer_list
#include <type_traits>      // for is_signed, integral_constant
#include <utility>          // for exchange, forward

#if defined(_MSC_VER) && !defined(__clang__)

#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant

#if _MSC_VER < 1910
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/
#endif            // _MSC_VER < 1910
#endif            // _MSC_VER

#if (defined(_MSC_VER) && _MSC_VER < 1910) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ < 6)
#define GSL_CONSTEXPR_NARROW 0
#else
#define GSL_CONSTEXPR_NARROW 1
#endif

namespace gsl
{
//
// GSL.util: utilities
//

// index type for all container indexes/subscripts/sizes
using index = std::ptrdiff_t;

// final_action allows you to ensure something gets run at the end of a scope
template <class F>
class final_action
{
public:
    explicit final_action(F f) noexcept : f_(std::move(f)) {}

    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false)) {}

    final_action(const final_action&) = delete;
    final_action& operator=(const final_action&) = delete;
    final_action& operator=(final_action&&) = delete;

    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // terminate if throws
    ~final_action() noexcept
    {
        if (invoke_) f_();
    }

private:
    F f_;
    bool invoke_{true};
};

// finally() - convenience function to generate a final_action
template <class F>
final_action<F> finally(const F& f) noexcept
{
    return final_action<F>(f);
}

template <class F>
final_action<F> finally(F&& f) noexcept
{
    return final_action<F>(std::forward<F>(f));
}

// narrow_cast(): a searchable way to do narrowing casts of values
template <class T, class U>
GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
constexpr T narrow_cast(U&& u) noexcept
{
    return static_cast<T>(std::forward<U>(u));
}

struct narrowing_error : public std::exception
{
};

namespace details
{
    template <class T, class U>
    struct is_same_signedness
        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
    {
    };
} // namespace details

// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
template <class T, class U>
GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
#if GSL_CONSTEXPR_NARROW
constexpr
#endif
T narrow(U u) noexcept(false)
{
    T t = narrow_cast<T>(u);
    if (static_cast<U>(t) != u) throw narrowing_error{};
    if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
        throw narrowing_error{};
    return t;
}

//
// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
//
template <class T, std::size_t N>
GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
constexpr T& at(T (&arr)[N], const index i)
{
    Expects(i >= 0 && i < narrow_cast<index>(N));
    return arr[narrow_cast<std::size_t>(i)];
}

template <class Cont>
GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
{
    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
    using size_type = decltype(cont.size());
    return cont[narrow_cast<size_type>(i)];
}

template <class T>
GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
constexpr T at(const std::initializer_list<T> cont, const index i)
{
    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
    return *(cont.begin() + i);
}

} // namespace gsl

#if defined(_MSC_VER) && !defined(__clang__)
#if _MSC_VER < 1910
#undef constexpr
#pragma pop_macro("constexpr")

#endif // _MSC_VER < 1910

#pragma warning(pop)

#endif // _MSC_VER

#endif // GSL_UTIL_H


================================================
FILE: examples/libraries/GSL/include/gsl/multi_span
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_MULTI_SPAN_H
#define GSL_MULTI_SPAN_H

#include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte>   // for byte
#include <gsl/gsl_util>   // for narrow_cast

#include <algorithm> // for transform, lexicographical_compare
#include <array>     // for array
#include <cstddef>          // for std::ptrdiff_t, size_t, nullptr_t
#include <cstdint>          // for PTRDIFF_MAX
#include <functional>       // for divides, multiplies, minus, negate, plus
#include <initializer_list> // for initializer_list
#include <iterator>         // for iterator, random_access_iterator_tag
#include <limits>           // for numeric_limits
#include <new>
#include <numeric>
#include <stdexcept>
#include <string>      // for basic_string
#include <type_traits> // for enable_if_t, remove_cv_t, is_same, is_co...
#include <utility>

#if defined(_MSC_VER) && !defined(__clang__)

// turn off some warnings that are noisy about our Expects statements
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(disable : 4702) // unreachable code

// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
#pragma warning(disable : 26495) // uninitalized member when constructor calls constructor
#pragma warning(disable : 26473) // in some instantiations we cast to the same type
#pragma warning(disable : 26490) // TODO: bug in parser - attributes and templates
#pragma warning(disable : 26465) // TODO: bug - suppression does not work on template functions
#pragma warning(disable : 4996)  // use of function or classes marked [[deprecated]]

#if _MSC_VER < 1910
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/

#endif // _MSC_VER < 1910
#endif // _MSC_VER

#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

// GCC 7 does not like the signed unsigned missmatch (size_t std::ptrdiff_t)
// While there is a conversion from signed to unsigned, it happens at
// compiletime, so the compiler wouldn't have to warn indiscriminently, but
// could check if the source value actually doesn't fit into the target type
// and only warn in those cases.
#if defined(__GNUC__) && __GNUC__ > 6
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif

namespace gsl
{

/*
** begin definitions of index and bounds
*/
namespace details
{
    template <typename SizeType>
    struct [[deprecated]] SizeTypeTraits
    {
        static const SizeType max_value = std::numeric_limits<SizeType>::max();
    };

    template <typename... Ts>
    class [[deprecated]] are_integral : public std::integral_constant<bool, true>
    {
    };

    template <typename T, typename... Ts>
    class [[deprecated]] are_integral<T, Ts...>
        : public std::integral_constant<bool,
                                        std::is_integral<T>::value && are_integral<Ts...>::value>
    {
    };
} // namespace details

template <std::size_t Rank>
class [[deprecated]] multi_span_index final {
    static_assert(Rank > 0, "Rank must be greater than 0!");

    template <std::size_t OtherRank>
    friend class multi_span_index;

public:
    static const std::size_t rank = Rank;
    using value_type = std::ptrdiff_t;
    using size_type = value_type;
    using reference = std::add_lvalue_reference_t<value_type>;
    using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>;

    constexpr multi_span_index() noexcept {}

    constexpr multi_span_index(const value_type(&values)[Rank]) noexcept
    {
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
        std::copy(values, values + Rank, elems);
    }

    template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) &&
                                                          details::are_integral<Ts...>::value>>
    constexpr multi_span_index(Ts... ds) noexcept : elems{narrow_cast<value_type>(ds)...}
    {}

    constexpr multi_span_index(const multi_span_index& other) noexcept = default;

    constexpr multi_span_index& operator=(const multi_span_index& rhs) noexcept = default;

    // Preconditions: component_idx < rank
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr reference operator[](std::size_t component_idx)
    {
        Expects(component_idx < Rank); // Component index must be less than rank
        return elems[component_idx];
    }

    // Preconditions: component_idx < rank
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr const_reference operator[](std::size_t component_idx) const
    {
        Expects(component_idx < Rank); // Component index must be less than rank
        return elems[component_idx];
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
    constexpr bool operator==(const multi_span_index& rhs) const
    {
        return std::equal(elems, elems + rank, rhs.elems);
    }

    constexpr bool operator!=(const multi_span_index& rhs) const { return !(*this == rhs); }

    constexpr multi_span_index operator+() const noexcept { return *this; }

    constexpr multi_span_index operator-() const
    {
        multi_span_index ret = *this;
        std::transform(ret, ret + rank, ret, std::negate<value_type>{});
        return ret;
    }

    constexpr multi_span_index operator+(const multi_span_index& rhs) const
    {
        multi_span_index ret = *this;
        ret += rhs;
        return ret;
    }

    constexpr multi_span_index operator-(const multi_span_index& rhs) const
    {
        multi_span_index ret = *this;
        ret -= rhs;
        return ret;
    }

    constexpr multi_span_index& operator+=(const multi_span_index& rhs)
    {
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
        std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
        return *this;
    }

    constexpr multi_span_index& operator-=(const multi_span_index& rhs)
    {
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
        std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{});
        return *this;
    }

    constexpr multi_span_index operator*(value_type v) const
    {
        multi_span_index ret = *this;
        ret *= v;
        return ret;
    }

    constexpr multi_span_index operator/(value_type v) const
    {
        multi_span_index ret = *this;
        ret /= v;
        return ret;
    }

    friend constexpr multi_span_index operator*(value_type v, const multi_span_index& rhs)
    {
        return rhs * v;
    }

    constexpr multi_span_index& operator*=(value_type v)
    {
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
        std::transform(elems, elems + rank, elems,
                       [v](value_type x) { return std::multiplies<value_type>{}(x, v); });
        return *this;
    }

    constexpr multi_span_index& operator/=(value_type v)
    {
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
        std::transform(elems, elems + rank, elems,
                       [v](value_type x) { return std::divides<value_type>{}(x, v); });
        return *this;
    }

private:
    value_type elems[Rank] = {};
};

#if !defined(_MSC_VER) || _MSC_VER >= 1910

struct [[deprecated]] static_bounds_dynamic_range_t
{
    template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
    constexpr operator T() const noexcept
    {
        return narrow_cast<T>(-1);
    }
};

constexpr bool operator==(static_bounds_dynamic_range_t, static_bounds_dynamic_range_t) noexcept
{
    return true;
}

constexpr bool operator!=(static_bounds_dynamic_range_t, static_bounds_dynamic_range_t) noexcept
{
    return false;
}

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
constexpr bool operator==(static_bounds_dynamic_range_t, T other) noexcept
{
    return narrow_cast<T>(-1) == other;
}

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
constexpr bool operator==(T left, static_bounds_dynamic_range_t right) noexcept
{
    return right == left;
}

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
constexpr bool operator!=(static_bounds_dynamic_range_t, T other) noexcept
{
    return narrow_cast<T>(-1) != other;
}

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) noexcept
{
    return right != left;
}

constexpr static_bounds_dynamic_range_t dynamic_range{};
#else
const std::ptrdiff_t dynamic_range = -1;
#endif

struct [[deprecated]] generalized_mapping_tag
{
};
struct[[deprecated]] contiguous_mapping_tag : generalized_mapping_tag{};

namespace details
{

    template <std::ptrdiff_t Left, std::ptrdiff_t Right>
    struct [[deprecated]] LessThan
    {
        static const bool value = Left < Right;
    };

    template <std::ptrdiff_t... Ranges>
    struct [[deprecated]] BoundsRanges {
        using size_type = std::ptrdiff_t;
        static const size_type Depth = 0;
        static const size_type DynamicNum = 0;
        static const size_type CurrentRange = 1;
        static const size_type TotalSize = 1;

        // TODO : following signature is for work around VS bug
        template <typename OtherRange>
        constexpr BoundsRanges(const OtherRange&, bool /* firstLevel */)
        {}

        constexpr BoundsRanges(const std::ptrdiff_t* const) {}
        constexpr BoundsRanges() noexcept = default;

        template <typename T, std::size_t Dim>
        constexpr void serialize(T&) const
        {}

        template <typename T, std::size_t Dim>
        constexpr size_type linearize(const T&) const
        {
            return 0;
        }

        template <typename T, std::size_t Dim>
        constexpr size_type contains(const T&) const
        {
            return -1;
        }

        constexpr size_type elementNum(std::size_t) const noexcept { return 0; }

        constexpr size_type totalSize() const noexcept { return TotalSize; }

        constexpr bool operator==(const BoundsRanges&) const noexcept { return true; }
    };

    template <std::ptrdiff_t... RestRanges>
    struct[[deprecated]] BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
    {
        using Base = BoundsRanges<RestRanges...>;
        using size_type = std::ptrdiff_t;
        static const std::size_t Depth = Base::Depth + 1;
        static const std::size_t DynamicNum = Base::DynamicNum + 1;
        static const size_type CurrentRange = dynamic_range;
        static const size_type TotalSize = dynamic_range;

    private:
        size_type m_bound;

    public:
        GSL_SUPPRESS(
            f.23) // NO-FORMAT: attribute // this pointer type is cannot be assigned nullptr - issue in not_null
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        constexpr BoundsRanges(const std::ptrdiff_t* const arr)
            : Base(arr + 1), m_bound(*arr * this->Base::totalSize())
        {
            Expects(0 <= *arr);
        }

        constexpr BoundsRanges() noexcept : m_bound(0) {}

        template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
        constexpr BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
                               bool /* firstLevel */ = true)
            : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
            , m_bound(other.totalSize())
        {}

        template <typename T, std::size_t Dim = 0>
        constexpr void serialize(T & arr) const
        {
            arr[Dim] = elementNum();
            this->Base::template serialize<T, Dim + 1>(arr);
        }

        template <typename T, std::size_t Dim = 0>
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
        constexpr size_type linearize(const T& arr) const
        {
            const size_type index = this->Base::totalSize() * arr[Dim];
            Expects(index < m_bound);
            return index + this->Base::template linearize<T, Dim + 1>(arr);
        }

        template <typename T, std::size_t Dim = 0>
        constexpr size_type contains(const T& arr) const
        {
            const std::ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr);
            if (last == -1) return -1;
            const std::ptrdiff_t cur = this->Base::totalSize() * arr[Dim];
            return cur < m_bound ? cur + last : -1;
        }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type totalSize() const noexcept { return m_bound; }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum() const noexcept
        {
            return totalSize() / this->Base::totalSize();
        }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum(std::size_t dim) const noexcept
        {
            if (dim > 0)
                return this->Base::elementNum(dim - 1);
            else
                return elementNum();
        }

        constexpr bool operator==(const BoundsRanges& rhs) const noexcept
        {
            return m_bound == rhs.m_bound &&
                   static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
        }
    };

    template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges>
    struct[[deprecated]] BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
    {
        using Base = BoundsRanges<RestRanges...>;
        using size_type = std::ptrdiff_t;
        static const std::size_t Depth = Base::Depth + 1;
        static const std::size_t DynamicNum = Base::DynamicNum;
        static const size_type CurrentRange = CurRange;
        static const size_type TotalSize =
            Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize;

        constexpr BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {}
        constexpr BoundsRanges() = default;

        template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges>
        constexpr BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other,
                               bool firstLevel = true)
            : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
        {
            GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
            (void) firstLevel;
        }

        template <typename T, std::size_t Dim = 0>
        constexpr void serialize(T & arr) const
        {
            arr[Dim] = elementNum();
            this->Base::template serialize<T, Dim + 1>(arr);
        }

        template <typename T, std::size_t Dim = 0>
        constexpr size_type linearize(const T& arr) const
        {
            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
            Expects(arr[Dim] >= 0 && arr[Dim] < CurrentRange); // Index is out of range
            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
            const std::ptrdiff_t d = arr[Dim];
            return this->Base::totalSize() * d + this->Base::template linearize<T, Dim + 1>(arr);
        }

        template <typename T, std::size_t Dim = 0>
        constexpr size_type contains(const T& arr) const
        {
            if (arr[Dim] >= CurrentRange) return -1;
            const size_type last = this->Base::template contains<T, Dim + 1>(arr);
            if (last == -1) return -1;
            return this->Base::totalSize() * arr[Dim] + last;
        }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type totalSize() const noexcept
        {
            return CurrentRange * this->Base::totalSize();
        }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum() const noexcept { return CurrentRange; }

        GSL_SUPPRESS(
            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum(std::size_t dim) const noexcept
        {
            if (dim > 0)
                return this->Base::elementNum(dim - 1);
            else
                return elementNum();
        }

        constexpr bool operator==(const BoundsRanges& rhs) const noexcept
        {
            return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs);
        }
    };

    template <typename SourceType, typename TargetType>
    struct[[deprecated]] BoundsRangeConvertible
        : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize ||
                                               TargetType::TotalSize == dynamic_range ||
                                               SourceType::TotalSize == dynamic_range ||
                                               TargetType::TotalSize == 0)>{};

    template <typename TypeChain>
    struct [[deprecated]] TypeListIndexer {
        const TypeChain& obj_;
        constexpr TypeListIndexer(const TypeChain& obj) : obj_(obj) {}

        template <std::size_t N>
        constexpr const TypeChain& getObj(std::true_type)
        {
            return obj_;
        }

        template <std::size_t N, typename MyChain = TypeChain,
                  typename MyBase = typename MyChain::Base>
        constexpr auto getObj(std::false_type)
            ->decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
        {
            return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>();
        }

        template <std::size_t N>
        constexpr auto get()->decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
        {
            return getObj<N - 1>(std::integral_constant<bool, N == 0>());
        }
    };

    template <typename TypeChain>
    constexpr TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj)
    {
        return TypeListIndexer<TypeChain>(obj);
    }

    template <std::size_t Rank, bool Enabled = (Rank > 1),
              typename Ret = std::enable_if_t<Enabled, multi_span_index<Rank - 1>>>
    constexpr Ret shift_left(const multi_span_index<Rank>& other) noexcept
    {
        Ret ret{};
        for (std::size_t i = 0; i < Rank - 1; ++i)
        {
            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
            ret[i] = other[i + 1];
        }
        return ret;
    }
} // namespace details

template <typename IndexType>
class [[deprecated]] bounds_iterator;

template <std::ptrdiff_t... Ranges>
class [[deprecated]] static_bounds {
public:
    static_bounds(const details::BoundsRanges<Ranges...>&) {}
};

template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges>
class[[deprecated]] static_bounds<FirstRange, RestRanges...>
{
    using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>;

    MyRanges m_ranges;
    constexpr static_bounds(const MyRanges& range) noexcept : m_ranges(range) {}

    template <std::ptrdiff_t... OtherRanges>
    friend class static_bounds;

public:
    static const std::size_t rank = MyRanges::Depth;
    static const std::size_t dynamic_rank = MyRanges::DynamicNum;
    static const std::ptrdiff_t static_size = MyRanges::TotalSize;

    using size_type = std::ptrdiff_t;
    using index_type = multi_span_index<rank>;
    using const_index_type = std::add_const_t<index_type>;
    using iterator = bounds_iterator<const_index_type>;
    using const_iterator = bounds_iterator<const_index_type>;
    using difference_type = std::ptrdiff_t;
    using sliced_type = static_bounds<RestRanges...>;
    using mapping_type = contiguous_mapping_tag;

    constexpr static_bounds() /*noexcept*/ = default;

    template <typename SourceType, typename TargetType, std::size_t Rank>
    struct BoundsRangeConvertible2;

    template <std::size_t Rank, typename SourceType, typename TargetType,
              typename Ret = BoundsRangeConvertible2<typename SourceType::Base,
                                                     typename TargetType::Base, Rank>>
    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type)->Ret;

    template <std::size_t Rank, typename SourceType, typename TargetType>
    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...)->std::false_type;

    template <typename SourceType, typename TargetType, std::size_t Rank>
    struct BoundsRangeConvertible2
        : decltype(helpBoundsRangeConvertible<Rank - 1>(
              SourceType(), TargetType(),
              std::integral_constant<bool,
                                     SourceType::Depth == TargetType::Depth &&
                                         (SourceType::CurrentRange == TargetType::CurrentRange ||
                                          TargetType::CurrentRange == dynamic_range ||
                                          SourceType::CurrentRange == dynamic_range)>()))
    {
    };

    template <typename SourceType, typename TargetType>
    struct BoundsRangeConvertible2<SourceType, TargetType, 0> : std::true_type
    {
    };

    template <typename SourceType, typename TargetType, std::ptrdiff_t Rank = TargetType::Depth>
    struct BoundsRangeConvertible
        : decltype(helpBoundsRangeConvertible<Rank - 1>(
              SourceType(), TargetType(),
              std::integral_constant<bool,
                                     SourceType::Depth == TargetType::Depth &&
                                         (!details::LessThan<SourceType::CurrentRange,
                                                             TargetType::CurrentRange>::value ||
                                          TargetType::CurrentRange == dynamic_range ||
                                          SourceType::CurrentRange == dynamic_range)>()))
    {
    };

    template <typename SourceType, typename TargetType>
    struct BoundsRangeConvertible<SourceType, TargetType, 0> : std::true_type
    {
    };

    template <std::ptrdiff_t... Ranges,
              typename = std::enable_if_t<details::BoundsRangeConvertible<
                  details::BoundsRanges<Ranges...>,
                  details::BoundsRanges<FirstRange, RestRanges...>>::value>>
    constexpr static_bounds(const static_bounds<Ranges...>& other) : m_ranges(other.m_ranges)
    {
        Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges<Ranges...>::DynamicNum == 0) ||
                MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize());
    }

    constexpr static_bounds(std::initializer_list<size_type> il) : m_ranges(il.begin())
    {
        // Size of the initializer list must match the rank of the array
        Expects((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) ||
                MyRanges::DynamicNum == il.size());
        // Size of the range must be less than the max element of the size type
        Expects(m_ranges.totalSize() <= PTRDIFF_MAX);
    }

    constexpr sliced_type slice() const noexcept
    {
        return sliced_type{static_cast<const details::BoundsRanges<RestRanges...>&>(m_ranges)};
    }

    constexpr size_type stride() const noexcept { return rank > 1 ? slice().size() : 1; }

    constexpr size_type size() const noexcept { return m_ranges.totalSize(); }

    constexpr size_type total_size() const noexcept { return m_ranges.totalSize(); }

    constexpr size_type linearize(const index_type& idx) const { return m_ranges.linearize(idx); }

    constexpr bool contains(const index_type& idx) const noexcept
    {
        return m_ranges.contains(idx) != -1;
    }

    constexpr size_type operator[](std::size_t idx) const noexcept
    {
        return m_ranges.elementNum(idx);
    }

    template <std::size_t Dim = 0>
    constexpr size_type extent() const noexcept
    {
        static_assert(Dim < rank,
                      "dimension should be less than rank (dimension count starts from 0)");
        return details::createTypeListIndexer(m_ranges).template get<Dim>().elementNum();
    }

    template <typename IntType>
    constexpr size_type extent(IntType dim) const
    {
        static_assert(std::is_integral<IntType>::value,
                      "Dimension parameter must be supplied as an integral type.");
        auto real_dim = narrow_cast<std::size_t>(dim);
        Expects(real_dim < rank);

        return m_ranges.elementNum(real_dim);
    }

    constexpr index_type index_bounds() const noexcept
    {
        size_type extents[rank] = {};
        m_ranges.serialize(extents);
        return {extents};
    }

    template <std::ptrdiff_t... Ranges>
    constexpr bool operator==(const static_bounds<Ranges...>& rhs) const noexcept
    {
        return this->size() == rhs.size();
    }

    template <std::ptrdiff_t... Ranges>
    constexpr bool operator!=(const static_bounds<Ranges...>& rhs) const noexcept
    {
        return !(*this == rhs);
    }

    constexpr const_iterator begin() const noexcept { return const_iterator(*this, index_type{}); }

    constexpr const_iterator end() const noexcept
    {
        return const_iterator(*this, this->index_bounds());
    }
};

template <std::size_t Rank>
class [[deprecated]] strided_bounds {
    template <std::size_t OtherRank>
    friend class strided_bounds;

public:
    static const std::size_t rank = Rank;
    using value_type = std::ptrdiff_t;
    using reference = std::add_lvalue_reference_t<value_type>;
    using const_reference = std::add_const_t<reference>;
    using size_type = value_type;
    using difference_type = value_type;
    using index_type = multi_span_index<rank>;
    using const_index_type = std::add_const_t<index_type>;
    using iterator = bounds_iterator<const_index_type>;
    using const_iterator = bounds_iterator<const_index_type>;
    static const value_type dynamic_rank = rank;
    static const value_type static_size = dynamic_range;
    using sliced_type = std::conditional_t<rank != 0, strided_bounds<rank - 1>, void>;
    using mapping_type = generalized_mapping_tag;

    constexpr strided_bounds(const strided_bounds&) noexcept = default;

    constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default;

    constexpr strided_bounds(const value_type(&values)[rank], index_type strides)
        : m_extents(values), m_strides(std::move(strides))
    {}

    constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept
        : m_extents(extents), m_strides(strides)
    {}

    constexpr index_type strides() const noexcept { return m_strides; }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr size_type total_size() const noexcept
    {
        size_type ret = 0;
        for (std::size_t i = 0; i < rank; ++i) { ret += (m_extents[i] - 1) * m_strides[i]; }
        return ret + 1;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr size_type size() const noexcept
    {
        size_type ret = 1;
        for (std::size_t i = 0; i < rank; ++i) { ret *= m_extents[i]; }
        return ret;
    }

    constexpr bool contains(const index_type& idx) const noexcept
    {
        for (std::size_t i = 0; i < rank; ++i)
        {
            if (idx[i] < 0 || idx[i] >= m_extents[i]) return false;
        }
        return true;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr size_type linearize(const index_type& idx) const
    {
        size_type ret = 0;
        for (std::size_t i = 0; i < rank; i++)
        {
            Expects(idx[i] < m_extents[i]); // index is out of bounds of the array
            ret += idx[i] * m_strides[i];
        }
        return ret;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr size_type stride() const noexcept { return m_strides[0]; }

    template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
    constexpr sliced_type slice() const
    {
        return {details::shift_left(m_extents), details::shift_left(m_strides)};
    }

    template <std::size_t Dim = 0>

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr size_type extent() const noexcept
    {
        static_assert(Dim < Rank,
                      "dimension should be less than rank (dimension count starts from 0)");
        return m_extents[Dim];
    }

    constexpr index_type index_bounds() const noexcept { return m_extents; }

    constexpr const_iterator begin() const noexcept { return const_iterator{*this, index_type{}}; }

    constexpr const_iterator end() const noexcept { return const_iterator{*this, index_bounds()}; }

private:
    index_type m_extents;
    index_type m_strides;
};

template <typename T>
struct[[deprecated]] is_bounds : std::integral_constant<bool, false>{};
template <std::ptrdiff_t... Ranges>
struct[[deprecated]] is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>{};
template <std::size_t Rank>
struct[[deprecated]] is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>{};

template <typename IndexType>
class [[deprecated]] bounds_iterator {
public:
    static const std::size_t rank = IndexType::rank;
    using iterator_category = std::random_access_iterator_tag;
    using value_type = IndexType;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
    using index_type = value_type;
    using index_size_type = typename IndexType::value_type;
    template <typename Bounds>
    explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept
        : boundary_(bnd.index_bounds()), curr_(std::move(curr))
    {
        static_assert(is_bounds<Bounds>::value, "Bounds type must be provided");
    }

    constexpr reference operator*() const noexcept { return curr_; }

    constexpr pointer operator->() const noexcept { return &curr_; }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
    constexpr bounds_iterator& operator++() noexcept

    {
        for (std::size_t i = rank; i-- > 0;)
        {
            if (curr_[i] < boundary_[i] - 1)
            {
                curr_[i]++;
                return *this;
            }
            curr_[i] = 0;
        }
        // If we're here we've wrapped over - set to past-the-end.
        curr_ = boundary_;
        return *this;
    }

    constexpr bounds_iterator operator++(int) noexcept
    {
        auto ret = *this;
        ++(*this);
        return ret;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr bounds_iterator& operator--()
    {
        if (!less(curr_, boundary_))
        {
            // if at the past-the-end, set to last element
            for (std::size_t i = 0; i < rank; ++i) { curr_[i] = boundary_[i] - 1; }
            return *this;
        }
        for (std::size_t i = rank; i-- > 0;)
        {
            if (curr_[i] >= 1)
            {
                curr_[i]--;
                return *this;
            }
            curr_[i] = boundary_[i] - 1;
        }
        // If we're here the preconditions were violated
        // "pre: there exists s such that r == ++s"
        Expects(false);
        return *this;
    }

    constexpr bounds_iterator operator--(int) noexcept
    {
        auto ret = *this;
        --(*this);
        return ret;
    }

    constexpr bounds_iterator operator+(difference_type n) const noexcept
    {
        bounds_iterator ret{*this};
        return ret += n;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr bounds_iterator& operator+=(difference_type n)
    {
        auto linear_idx = linearize(curr_) + n;
        std::remove_const_t<value_type> stride = 0;
        stride[rank - 1] = 1;
        for (std::size_t i = rank - 1; i-- > 0;) { stride[i] = stride[i + 1] * boundary_[i + 1]; }
        for (std::size_t i = 0; i < rank; ++i)
        {
            curr_[i] = linear_idx / stride[i];
            linear_idx = linear_idx % stride[i];
        }
        // index is out of bounds of the array
        Expects(!less(curr_, index_type{}) && !less(boundary_, curr_));
        return *this;
    }

    constexpr bounds_iterator operator-(difference_type n) const noexcept
    {
        bounds_iterator ret{*this};
        return ret -= n;
    }

    constexpr bounds_iterator& operator-=(difference_type n) noexcept { return *this += -n; }

    constexpr difference_type operator-(const bounds_iterator& rhs) const noexcept
    {
        return linearize(curr_) - linearize(rhs.curr_);
    }

    constexpr value_type operator[](difference_type n) const noexcept { return *(*this + n); }

    constexpr bool operator==(const bounds_iterator& rhs) const noexcept
    {
        return curr_ == rhs.curr_;
    }

    constexpr bool operator!=(const bounds_iterator& rhs) const noexcept { return !(*this == rhs); }

    constexpr bool operator<(const bounds_iterator& rhs) const noexcept
    {
        return less(curr_, rhs.curr_);
    }

    constexpr bool operator<=(const bounds_iterator& rhs) const noexcept { return !(rhs < *this); }

    constexpr bool operator>(const bounds_iterator& rhs) const noexcept { return rhs < *this; }

    constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); }

    void swap(bounds_iterator & rhs) noexcept
    {
        std::swap(boundary_, rhs.boundary_);
        std::swap(curr_, rhs.curr_);
    }

private:
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr bool less(index_type & one, index_type & other) const noexcept
    {
        for (std::size_t i = 0; i < rank; ++i)
        {
            if (one[i] < other[i]) return true;
        }
        return false;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    constexpr index_size_type linearize(const value_type& idx) const noexcept
    {
        // TODO: Smarter impl.
        // Check if past-the-end
        index_size_type multiplier = 1;
        index_size_type res = 0;
        if (!less(idx, boundary_))
        {
            res = 1;
            for (std::size_t i = rank; i-- > 0;)
            {
                res += (idx[i] - 1) * multiplier;
                multiplier *= boundary_[i];
            }
        }
        else
        {
            for (std::size_t i = rank; i-- > 0;)
            {
                res += idx[i] * multiplier;
                multiplier *= boundary_[i];
            }
        }
        return res;
    }

    value_type boundary_;
    std::remove_const_t<value_type> curr_;
};

template <typename IndexType>
bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::difference_type n,
                                     const bounds_iterator<IndexType>& rhs) noexcept
{
    return rhs + n;
}

namespace details
{
    template <typename Bounds>
    constexpr std::enable_if_t<
        std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value,
        typename Bounds::index_type>
    make_stride(const Bounds& bnd) noexcept
    {
        return bnd.strides();
    }

    // Make a stride vector from bounds, assuming contiguous memory.
    template <typename Bounds>
    constexpr std::enable_if_t<
        std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value,
        typename Bounds::index_type>
    make_stride(const Bounds& bnd) noexcept
    {
        auto extents = bnd.index_bounds();
        typename Bounds::size_type stride[Bounds::rank] = {};

        stride[Bounds::rank - 1] = 1;
        for (std::size_t i = 1; i < Bounds::rank; ++i)
        {
            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
            GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
            stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i];
        }
        return {stride};
    }

    template <typename BoundsSrc, typename BoundsDest>
    void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest)
    {
        static_assert(is_bounds<BoundsSrc>::value && is_bounds<BoundsDest>::value,
                      "The src type and dest type must be bounds");
        static_assert(std::is_same<typename BoundsSrc::mapping_type, contiguous_mapping_tag>::value,
                      "The source type must be a contiguous bounds");
        static_assert(BoundsDest::static_size == dynamic_range ||
                          BoundsSrc::static_size == dynamic_range ||
                          BoundsDest::static_size == BoundsSrc::static_size,
                      "The source bounds must have same size as dest bounds");
        Expects(src.size() == dest.size());
    }

} // namespace details

template <typename Span>
class [[deprecated]] contiguous_span_iterator;
template <typename Span>
class [[deprecated]] general_span_iterator;

template <std::ptrdiff_t DimSize = dynamic_range>
struct [[deprecated]] dim_t
{
    static const std::ptrdiff_t value = DimSize;
};
template <>
struct [[deprecated]] dim_t<dynamic_range>
{
    static const std::ptrdiff_t value = dynamic_range;
    const std::ptrdiff_t dvalue;
    constexpr dim_t(std::ptrdiff_t size) noexcept : dvalue(size) {}
};

template <std::ptrdiff_t N, class = std::enable_if_t<(N >= 0)>>
constexpr dim_t<N> dim() noexcept
{
    return dim_t<N>();
}

template <std::ptrdiff_t N = dynamic_range, class = std::enable_if_t<N == dynamic_range>>
constexpr dim_t<N> dim(std::ptrdiff_t n) noexcept
{
    return dim_t<>(n);
}

template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
          std::ptrdiff_t... RestDimensions>
class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span;

template <typename ValueType, std::size_t Rank>
class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span;

namespace details
{
    template <typename T, typename = std::true_type>
    struct [[deprecated]] SpanTypeTraits
    {
        using value_type = T;
        using size_type = std::size_t;
    };

    template <typename Traits>
    struct [[deprecated]] SpanTypeTraits<
        Traits, typename std::is_reference<typename Traits::span_traits&>::type>
    {
        using value_type = typename Traits::span_traits::value_type;
        using size_type = typename Traits::span_traits::size_type;
    };

    template <typename T, std::ptrdiff_t... Ranks>
    struct [[deprecated]] SpanArrayTraits
    {
        using type = multi_span<T, Ranks...>;
        using value_type = T;
        using bounds_type = static_bounds<Ranks...>;
        using pointer = T*;
        using reference = T&;
    };
    template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks>
    struct [[deprecated]] SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N>
    {
    };

    template <typename BoundsType>
    BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size
    {
        Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX);
        return BoundsType{totalSize};
    }
    template <typename BoundsType>
    BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size
    {
        Expects(BoundsType::static_size <= totalSize);
        return {};
    }
    template <typename BoundsType>
    BoundsType newBoundsHelper(std::ptrdiff_t totalSize)
    {
        static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1");
        return newBoundsHelperImpl<BoundsType>(
            totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>());
    }

    struct [[deprecated]] Sep
    {
    };

    template <typename T, typename... Args>
    T static_as_multi_span_helper(Sep, Args... args)
    {
        return T{narrow_cast<typename T::size_type>(args)...};
    }
    template <typename T, typename Arg, typename... Args>
    std::enable_if_t<
        !std::is_same<Arg, dim_t<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T>
    static_as_multi_span_helper(Arg, Args... args)
    {
        return static_as_multi_span_helper<T>(args...);
    }
    template <typename T, typename... Args>
    T static_as_multi_span_helper(dim_t<dynamic_range> val, Args... args)
    {
        return static_as_multi_span_helper<T>(args..., val.dvalue);
    }

    template <typename... Dimensions>
    struct [[deprecated]] static_as_multi_span_static_bounds_helper
    {
        using type = static_bounds<(Dimensions::value)...>;
    };

    template <typename T>
    struct [[deprecated]] is_multi_span_oracle : std::false_type
    {
    };

    template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
    struct [[deprecated]] is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
        : std::true_type
    {
    };

    template <typename ValueType, std::ptrdiff_t Rank>
    struct [[deprecated]] is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type
    {
    };

    template <typename T>
    struct [[deprecated]] is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>>
    {
    };
} // namespace details

template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span {
    // TODO do we still need this?
    template <typename ValueType2, std::ptrdiff_t FirstDimension2,
              std::ptrdiff_t... RestDimensions2>
    friend class multi_span;

public:
    using bounds_type = static_bounds<FirstDimension, RestDimensions...>;
    static const std::size_t Rank = bounds_type::rank;
    using size_type = typename bounds_type::size_type;
    using index_type = typename bounds_type::index_type;
    using value_type = ValueType;
    using const_value_type = std::add_const_t<value_type>;
    using pointer = std::add_pointer_t<value_type>;
    using reference = std::add_lvalue_reference_t<value_type>;
    using iterator = contiguous_span_iterator<multi_span>;
    using const_span = multi_span<const_value_type, FirstDimension, RestDimensions...>;
    using const_iterator = contiguous_span_iterator<const_span>;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using sliced_type =
        std::conditional_t<Rank == 1, value_type, multi_span<value_type, RestDimensions...>>;

private:
    pointer data_;
    bounds_type bounds_;

    friend iterator;
    friend const_iterator;

public:
    // default constructor - same as constructing from nullptr_t
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
    constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{})
    {
        static_assert(bounds_type::dynamic_rank != 0 ||
                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
                      "Default construction of multi_span<T> only possible "
                      "for dynamic or fixed, zero-length spans.");
    }

    // construct from nullptr - get an empty multi_span
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
    constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{})
    {
        static_assert(bounds_type::dynamic_rank != 0 ||
                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
                      "nullptr_t construction of multi_span<T> only possible "
                      "for dynamic or fixed, zero-length spans.");
    }

    // construct from nullptr with size of 0 (helps with template function calls)
    template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>>

    // GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive // TODO: parser bug
    constexpr multi_span(std::nullptr_t, IntType size) : multi_span(nullptr, bounds_type{})
    {
        static_assert(bounds_type::dynamic_rank != 0 ||
                          (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0),
                      "nullptr_t construction of multi_span<T> only possible "
                      "for dynamic or fixed, zero-length spans.");
        Expects(size == 0);
    }

    // construct from a single element

    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
    constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1})
    {
        static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 ||
                          bounds_type::static_size == 1,
                      "Construction from a single element only possible "
                      "for dynamic or fixed spans of length 0 or 1.");
    }

    // prevent constructing from temporaries for single-elements
    constexpr multi_span(value_type &&) = delete;

    // construct from pointer + length
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
    constexpr multi_span(pointer ptr, size_type size) : multi_span(ptr, bounds_type{size}) {}

    // construct from pointer + length - multidimensional
    constexpr multi_span(pointer data, bounds_type bounds) : data_(data), bounds_(std::move(bounds))
    {
        Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0);
    }

    // construct from begin,end pointer pair
    template <typename Ptr,
              typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value &&
                                          details::LessThan<bounds_type::dynamic_rank, 2>::value>>
    constexpr multi_span(pointer begin, Ptr end)
        : multi_span(begin,
                     details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin))
    {
        Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end));
    }

    // construct from n-dimensions static array
    template <typename T, std::size_t N, typename Helper = details::SpanArrayTraits<T, N>>
    constexpr multi_span(T(&arr)[N])
        : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}})
    {
        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
                      "Cannot convert from source type to target multi_span type.");
        static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value,
                      "Cannot construct a multi_span from an array with fewer elements.");
    }

    // construct from n-dimensions dynamic array (e.g. new int[m][4])
    // (precedence will be lower than the 1-dimension pointer)
    template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>>
    constexpr multi_span(T* const& data, size_type size)
        : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size})
    {
        static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value,
                      "Cannot convert from source type to target multi_span type.");
    }

    // construct from std::array
    template <typename T, std::size_t N>
    constexpr multi_span(std::array<T, N> & arr)
        : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
    {
        static_assert(
            std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value,
            "Cannot convert from source type to target multi_span type.");
        static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
                      "You cannot construct a multi_span from a std::array of smaller size.");
    }

    // construct from const std::array
    template <typename T, std::size_t N>
    constexpr multi_span(const std::array<T, N>& arr)
        : multi_span(arr.data(), bounds_type{static_bounds<N>{}})
    {
        static_assert(
            std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value,
            "Cannot convert from source type to target multi_span type.");
        static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value,
                      "You cannot construct a multi_span from a std::array of smaller size.");
    }

    // prevent constructing from temporary std::array
    template <typename T, std::size_t N>
    constexpr multi_span(std::array<T, N> && arr) = delete;

    // construct from containers
    // future: could use contiguous_iterator_traits to identify only contiguous containers
    // type-requirements: container must have .size(), operator[] which are value_type compatible
    template <typename Cont, typename DataType = typename Cont::value_type,
              typename = std::enable_if_t<
                  !details::is_multi_span<Cont>::value &&
                  std::is_convertible<DataType(*)[], value_type(*)[]>::value &&
                  std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                     *std::declval<Cont>().data())>,
                               DataType>::value>>
    constexpr multi_span(Cont & cont)
        : multi_span(static_cast<pointer>(cont.data()),
                     details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size())))
    {}

    // prevent constructing from temporary containers
    template <typename Cont, typename DataType = typename Cont::value_type,
              typename = std::enable_if_t<
                  !details::is_multi_span<Cont>::value &&
                  std::is_convertible<DataType(*)[], value_type(*)[]>::value &&
                  std::is_same<std::decay_t<decltype(std::declval<Cont>().size(),
                                                     *std::declval<Cont>().data())>,
                               DataType>::value>>
    explicit constexpr multi_span(Cont && cont) = delete;

    // construct from a convertible multi_span
    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename OtherBounds = static_bounds<OtherDimensions...>,
              typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value &&
                                          std::is_convertible<OtherBounds, bounds_type>::value>>
    constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other)
        : data_(other.data_), bounds_(other.bounds_)
    {}

    // trivial copy and move
    constexpr multi_span(const multi_span&) = default;
    constexpr multi_span(multi_span &&) = default;

    // trivial assignment
    constexpr multi_span& operator=(const multi_span&) = default;
    constexpr multi_span& operator=(multi_span&&) = default;

    // first() - extract the first Count elements into a new multi_span
    template <std::ptrdiff_t Count>

    constexpr multi_span<ValueType, Count> first() const
    {
        static_assert(Count >= 0, "Count must be >= 0.");
        static_assert(bounds_type::static_size == dynamic_range ||
                          Count <= bounds_type::static_size,
                      "Count is out of bounds.");

        Expects(bounds_type::static_size != dynamic_range || Count <= this->size());
        return {this->data(), Count};
    }

    // first() - extract the first count elements into a new multi_span
    constexpr multi_span<ValueType, dynamic_range> first(size_type count) const
    {
        Expects(count >= 0 && count <= this->size());
        return {this->data(), count};
    }

    // last() - extract the last Count elements into a new multi_span
    template <std::ptrdiff_t Count>
    constexpr multi_span<ValueType, Count> last() const
    {
        static_assert(Count >= 0, "Count must be >= 0.");
        static_assert(bounds_type::static_size == dynamic_range ||
                          Count <= bounds_type::static_size,
                      "Count is out of bounds.");

        Expects(bounds_type::static_size != dynamic_range || Count <= this->size());
        return {this->data() + this->size() - Count, Count};
    }

    // last() - extract the last count elements into a new multi_span
    constexpr multi_span<ValueType, dynamic_range> last(size_type count) const
    {
        Expects(count >= 0 && count <= this->size());
        return {this->data() + this->size() - count, count};
    }

    // subspan() - create a subview of Count elements starting at Offset
    template <std::ptrdiff_t Offset, std::ptrdiff_t Count>
    constexpr multi_span<ValueType, Count> subspan() const
    {
        static_assert(Count >= 0, "Count must be >= 0.");
        static_assert(Offset >= 0, "Offset must be >= 0.");
        static_assert(bounds_type::static_size == dynamic_range ||
                          ((Offset <= bounds_type::static_size) &&
                           Count <= bounds_type::static_size - Offset),
                      "You must describe a sub-range within bounds of the multi_span.");

        Expects(bounds_type::static_size != dynamic_range ||
                (Offset <= this->size() && Count <= this->size() - Offset));
        return {this->data() + Offset, Count};
    }

    // subspan() - create a subview of count elements starting at offset
    // supplying dynamic_range for count will consume all available elements from offset
    constexpr multi_span<ValueType, dynamic_range> subspan(size_type offset,
                                                           size_type count = dynamic_range) const
    {
        Expects((offset >= 0 && offset <= this->size()) &&
                (count == dynamic_range || (count <= this->size() - offset)));
        return {this->data() + offset, count == dynamic_range ? this->length() - offset : count};
    }

    // section - creates a non-contiguous, strided multi_span from a contiguous one
    constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const
    {
        const size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
        return {&this->operator[](origin), size,
                strided_bounds<Rank>{extents, details::make_stride(bounds())}};
    }

    // length of the multi_span in elements
    constexpr size_type size() const noexcept { return bounds_.size(); }

    // length of the multi_span in elements
    constexpr size_type length() const noexcept { return this->size(); }

    // length of the multi_span in bytes
    constexpr size_type size_bytes() const noexcept
    {
        return narrow_cast<size_type>(sizeof(value_type)) * this->size();
    }

    // length of the multi_span in bytes
    constexpr size_type length_bytes() const noexcept { return this->size_bytes(); }

    constexpr bool empty() const noexcept { return this->size() == 0; }

    static constexpr std::size_t rank() { return Rank; }

    template <std::size_t Dim = 0>
    constexpr size_type extent() const noexcept
    {
        static_assert(Dim < Rank,
                      "Dimension should be less than rank (dimension count starts from 0).");
        return bounds_.template extent<Dim>();
    }

    template <typename IntType>
    constexpr size_type extent(IntType dim) const
    {
        return bounds_.extent(dim);
    }

    constexpr bounds_type bounds() const noexcept { return bounds_; }

    constexpr pointer data() const noexcept { return data_; }

    template <typename FirstIndex>
    constexpr reference operator()(FirstIndex idx)
    {
        return this->operator[](narrow_cast<std::ptrdiff_t>(idx));
    }

    template <typename FirstIndex, typename... OtherIndices>
    constexpr reference operator()(FirstIndex firstIndex, OtherIndices... indices)
    {
        const index_type idx = {narrow_cast<std::ptrdiff_t>(firstIndex),
                                narrow_cast<std::ptrdiff_t>(indices)...};
        return this->operator[](idx);
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    constexpr reference operator[](const index_type& idx) const
    {
        return data_[bounds_.linearize(idx)];
    }

    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    constexpr Ret operator[](size_type idx) const
    {
        Expects(idx >= 0 && idx < bounds_.size()); // index is out of bounds of the array
        const size_type ridx = idx * bounds_.stride();

        // index is out of bounds of the underlying data
        Expects(ridx < bounds_.total_size());
        return Ret{data_ + ridx, bounds_.slice()};
    }

    constexpr iterator begin() const noexcept { return iterator{this, true}; }

    constexpr iterator end() const noexcept { return iterator{this, false}; }

    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    constexpr const_iterator cbegin() const noexcept
    {
        return const_iterator{reinterpret_cast<const const_span*>(this), true};
    }

    constexpr const_iterator cend() const noexcept
    {
        return const_iterator{reinterpret_cast<const const_span*>(this), false};
    }

    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }

    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }

    constexpr const_reverse_iterator crbegin() const noexcept
    {
        return const_reverse_iterator{cend()};
    }

    constexpr const_reverse_iterator crend() const noexcept
    {
        return const_reverse_iterator{cbegin()};
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const
    {
        return bounds_.size() == other.bounds_.size() &&
               (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const
    {
        return !(*this == other);
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const
    {
        return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const
    {
        return !(other < *this);
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other)
        const noexcept
    {
        return (other < *this);
    }

    template <typename OtherValueType, std::ptrdiff_t... OtherDimensions,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const
    {
        return !(*this < other);
    }
};

//
// Free functions for manipulating spans
//

// reshape a multi_span into a different dimensionality
// DimCount and Enabled here are workarounds for a bug in MSVC 2015
template <typename SpanType, typename... Dimensions2, std::size_t DimCount = sizeof...(Dimensions2),
          bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>>
constexpr auto as_multi_span(SpanType s, Dimensions2... dims)
    -> multi_span<typename SpanType::value_type, Dimensions2::value...>
{
    static_assert(details::is_multi_span<SpanType>::value,
                  "Variadic as_multi_span() is for reshaping existing spans.");
    using BoundsType =
        typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type;
    const auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{});
    details::verifyBoundsReshape(s.bounds(), tobounds);
    return {s.data(), tobounds};
}

// convert a multi_span<T> to a multi_span<const byte>
template <typename U, std::ptrdiff_t... Dimensions>
multi_span<const byte, dynamic_range>
as_bytes(multi_span<U, Dimensions...> s) noexcept
{
    static_assert(std::is_trivial<std::decay_t<U>>::value,
                  "The value_type of multi_span must be a trivial type.");
    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
}

// convert a multi_span<T> to a multi_span<byte> (a writeable byte multi_span)
// this is not currently a portable function that can be relied upon to work
// on all implementations. It should be considered an experimental extension
// to the standard GSL interface.
template <typename U, std::ptrdiff_t... Dimensions>
multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept
{
    static_assert(std::is_trivial<std::decay_t<U>>::value,
                  "The value_type of multi_span must be a trivial type.");
    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
}

// convert a multi_span<const byte> to a multi_span<const T>
// this is not currently a portable function that can be relied upon to work
// on all implementations. It should be considered an experimental extension
// to the standard GSL interface.
template <typename U, std::ptrdiff_t... Dimensions>
constexpr auto as_multi_span(multi_span<const byte, Dimensions...> s) -> multi_span<
    const U, static_cast<std::ptrdiff_t>(
                 multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range
                     ? (static_cast<std::size_t>(
                            multi_span<const byte, Dimensions...>::bounds_type::static_size) /
                        sizeof(U))
                     : dynamic_range)>
{
    using ConstByteSpan = multi_span<const byte, Dimensions...>;
    static_assert(
        std::is_trivial<std::decay_t<U>>::value &&
            (ConstByteSpan::bounds_type::static_size == dynamic_range ||
             ConstByteSpan::bounds_type::static_size % narrow_cast<std::ptrdiff_t>(sizeof(U)) == 0),
        "Target type must be a trivial type and its size must match the byte array size");

    Expects((s.size_bytes() % narrow_cast<std::ptrdiff_t>(sizeof(U))) == 0 &&
            (s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))) < PTRDIFF_MAX);
    return {reinterpret_cast<const U*>(s.data()),
            s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))};
}

// convert a multi_span<byte> to a multi_span<T>
// this is not currently a portable function that can be relied upon to work
// on all implementations. It should be considered an experimental extension
// to the standard GSL interface.
template <typename U, std::ptrdiff_t... Dimensions>
constexpr auto as_multi_span(multi_span<byte, Dimensions...> s)
    -> multi_span<U, narrow_cast<std::ptrdiff_t>(
                         multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range
                             ? static_cast<std::size_t>(
                                   multi_span<byte, Dimensions...>::bounds_type::static_size) /
                                   sizeof(U)
                             : dynamic_range)>
{
    using ByteSpan = multi_span<byte, Dimensions...>;
    static_assert(std::is_trivial<std::decay_t<U>>::value &&
                      (ByteSpan::bounds_type::static_size == dynamic_range ||
                       ByteSpan::bounds_type::static_size % sizeof(U) == 0),
                  "Target type must be a trivial type and its size must match the byte array size");

    Expects((s.size_bytes() % sizeof(U)) == 0);
    return {reinterpret_cast<U*>(s.data()),
            s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))};
}

template <typename T, std::ptrdiff_t... Dimensions>
constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args)
    -> multi_span<std::remove_all_extents_t<T>, Dimensions...>
{
    return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr),
            details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args...,
                                                                               details::Sep{})};
}

template <typename T>
constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) ->
    typename details::SpanArrayTraits<T, dynamic_range>::type
{
    return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len};
}

template <typename T, std::size_t N>
constexpr auto as_multi_span(T (&arr)[N]) ->
    typename details::SpanArrayTraits<T, N>::type
{
    return {arr};
}

template <typename T, std::size_t N>
constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr)
{
    return {arr};
}

template <typename T, std::size_t N>
constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete;

template <typename T, std::size_t N>
constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr)
{
    return {arr};
}

template <typename T>
constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end)
{
    return {begin, end};
}

template <typename Cont>
constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t<
    !details::is_multi_span<std::decay_t<Cont>>::value,
    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>>
{
    Expects(arr.size() < PTRDIFF_MAX);
    return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())};
}

template <typename Cont>
constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t<
    !details::is_multi_span<std::decay_t<Cont>>::value,
    multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete;

// from basic_string which doesn't have nonconst .data() member like other contiguous containers
template <typename CharT, typename Traits, typename Allocator>
GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
    -> multi_span<CharT, dynamic_range>
{
    Expects(str.size() < PTRDIFF_MAX);
    return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())};
}

// strided_span is an extension that is not strictly part of the GSL at this time.
// It is kept here while the multidimensional interface is still being defined.
template <typename ValueType, std::size_t Rank>
class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span
{
public:
    using bounds_type = strided_bounds<Rank>;
    using size_type = typename bounds_type::size_type;
    using index_type = typename bounds_type::index_type;
    using value_type = ValueType;
    using const_value_type = std::add_const_t<value_type>;
    using pointer = std::add_pointer_t<value_type>;
    using reference = std::add_lvalue_reference_t<value_type>;
    using iterator = general_span_iterator<strided_span>;
    using const_strided_span = strided_span<const_value_type, Rank>;
    using const_iterator = general_span_iterator<const_strided_span>;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using sliced_type =
        std::conditional_t<Rank == 1, value_type, strided_span<value_type, Rank - 1>>;

private:
    pointer data_;
    bounds_type bounds_;

    friend iterator;
    friend const_iterator;
    template <typename OtherValueType, std::size_t OtherRank>
    friend class strided_span;

public:
    // from raw data
    constexpr strided_span(pointer ptr, size_type size, bounds_type bounds)
        : data_(ptr), bounds_(std::move(bounds))
    {
        Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0);
        // Bounds cross data boundaries
        Expects(this->bounds().total_size() <= size);
        GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
        (void) size;
    }

    // from static array of size N
    template <size_type N>
    constexpr strided_span(value_type (&values)[N], bounds_type bounds)
        : strided_span(values, N, std::move(bounds))
    {}

    // from array view
    template <typename OtherValueType, std::ptrdiff_t... Dimensions,
              bool Enabled1 = (sizeof...(Dimensions) == Rank),
              bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value,
              typename = std::enable_if_t<Enabled1 && Enabled2>>
    constexpr strided_span(multi_span<OtherValueType, Dimensions...> av, bounds_type bounds)
        : strided_span(av.data(), av.bounds().total_size(), std::move(bounds))
    {}

    // convertible
    template <typename OtherValueType, typename = std::enable_if_t<std::is_convertible<
                                           OtherValueType (*)[], value_type (*)[]>::value>>
    constexpr strided_span(const strided_span<OtherValueType, Rank>& other)
        : data_(other.data_), bounds_(other.bounds_)
    {}

    // convert from bytes
    template <typename OtherValueType>
    constexpr strided_span<
        typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type,
        Rank>
    as_strided_span() const
    {
        static_assert((sizeof(OtherValueType) >= sizeof(value_type)) &&
                          (sizeof(OtherValueType) % sizeof(value_type) == 0),
                      "OtherValueType should have a size to contain a multiple of ValueTypes");
        auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type));

        const size_type size = this->bounds().total_size() / d;

        GSL_SUPPRESS(type.3) // NO-FORMAT: attribute
        return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())),
                size,
                bounds_type{resize_extent(this->bounds().index_bounds(), d),
                            resize_stride(this->bounds().strides(), d)}};
    }

    constexpr strided_span section(index_type origin, index_type extents) const
    {
        const size_type size = this->bounds().total_size() - this->bounds().linearize(origin);
        return {&this->operator[](origin), size,
                bounds_type{extents, details::make_stride(bounds())}};
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    constexpr reference operator[](const index_type& idx) const
    {
        return data_[bounds_.linearize(idx)];
    }

    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    constexpr Ret operator[](size_type idx) const
    {
        Expects(idx < bounds_.size()); // index is out of bounds of the array
        const size_type ridx = idx * bounds_.stride();

        // index is out of bounds of the underlying data
        Expects(ridx < bounds_.total_size());
        return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()};
    }

    constexpr bounds_type bounds() const noexcept { return bounds_; }

    template <std::size_t Dim = 0>
    constexpr size_type extent() const noexcept
    {
        static_assert(Dim < Rank,
                      "dimension should be less than Rank (dimension count starts from 0)");
        return bounds_.template extent<Dim>();
    }

    constexpr size_type size() const noexcept { return bounds_.size(); }

    constexpr pointer data() const noexcept { return data_; }

    constexpr bool empty() const noexcept { return this->size() == 0; }

    constexpr explicit operator bool() const noexcept { return data_ != nullptr; }

    constexpr iterator begin() const { return iterator{this, true}; }

    constexpr iterator end() const { return iterator{this, false}; }

    constexpr const_iterator cbegin() const
    {
        return const_iterator{reinterpret_cast<const const_strided_span*>(this), true};
    }

    constexpr const_iterator cend() const
    {
        return const_iterator{reinterpret_cast<const const_strided_span*>(this), false};
    }

    constexpr reverse_iterator rbegin() const { return reverse_iterator{end()}; }

    constexpr reverse_iterator rend() const { return reverse_iterator{begin()}; }

    constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; }

    constexpr const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator==(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return bounds_.size() == other.bounds_.size() &&
               (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin()));
    }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator!=(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return !(*this == other);
    }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator<(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end());
    }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator<=(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return !(other < *this);
    }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator>(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return (other < *this);
    }

    template <typename OtherValueType, std::ptrdiff_t OtherRank,
              typename = std::enable_if_t<std::is_same<std::remove_cv_t<value_type>,
                                                       std::remove_cv_t<OtherValueType>>::value>>
    constexpr bool operator>=(const strided_span<OtherValueType, OtherRank>& other) const
    {
        return !(*this < other);
    }

private:
    static index_type resize_extent(const index_type& extent, std::ptrdiff_t d)
    {
        // The last dimension of the array needs to contain a multiple of new type elements
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
        Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0));

        index_type ret = extent;
        ret[Rank - 1] /= d;

        return ret;
    }

    template <bool Enabled = (Rank == 1), typename = std::enable_if_t<Enabled>>
    static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = nullptr)
    {
        // Only strided arrays with regular strides can be resized
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
        Expects(strides[Rank - 1] == 1);

        return strides;
    }

    template <bool Enabled = (Rank > 1), typename = std::enable_if_t<Enabled>>
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    static index_type resize_stride(const index_type& strides, std::ptrdiff_t d)
    {
        // Only strided arrays with regular strides can be resized
        Expects(strides[Rank - 1] == 1);
        // The strides must have contiguous chunks of
        // memory that can contain a multiple of new type elements
        Expects(strides[Rank - 2] >= d && (strides[Rank - 2] % d == 0));

        for (std::size_t i = Rank - 1; i > 0; --i)
        {
            // Only strided arrays with regular strides can be resized
            Expects((strides[i - 1] >= strides[i]) && (strides[i - 1] % strides[i] == 0));
        }

        index_type ret = strides / d;
        ret[Rank - 1] = 1;

        return ret;
    }
};

template <class Span>
class [[deprecated]] contiguous_span_iterator {
public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = typename Span::value_type;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;

private:
    template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
    friend class multi_span;

    pointer data_;
    const Span* m_validator;

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    void validateThis() const
    {
        // iterator is out of range of the array
        Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size());
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    contiguous_span_iterator(const Span* container, bool isbegin)
        : data_(isbegin ? container->data_ : container->data_ + container->size())
        , m_validator(container)
    {}

public:
    reference operator*() const
    {
        validateThis();
        return *data_;
    }
    pointer operator->() const
    {
        validateThis();
        return data_;
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    contiguous_span_iterator& operator++() noexcept
    {
        ++data_;
        return *this;
    }
    contiguous_span_iterator operator++(int) noexcept
    {
        auto ret = *this;
        ++(*this);
        return ret;
    }

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    contiguous_span_iterator& operator--() noexcept
    {
        --data_;
        return *this;
    }
    contiguous_span_iterator operator--(int) noexcept
    {
        auto ret = *this;
        --(*this);
        return ret;
    }
    contiguous_span_iterator operator+(difference_type n) const noexcept
    {
        contiguous_span_iterator ret{*this};
        return ret += n;
    }
    contiguous_span_iterator& operator+=(difference_type n) noexcept
    {
        data_ += n;
        return *this;
    }
    contiguous_span_iterator operator-(difference_type n) const noexcept
    {
        contiguous_span_iterator ret{*this};
        return ret -= n;
    }

    contiguous_span_iterator& operator-=(difference_type n) { return *this += -n; }
    difference_type operator-(const contiguous_span_iterator& rhs) const
    {
        Expects(m_validator == rhs.m_validator);
        return data_ - rhs.data_;
    }
    reference operator[](difference_type n) const { return *(*this + n); }
    bool operator==(const contiguous_span_iterator& rhs) const
    {
        Expects(m_validator == rhs.m_validator);
        return data_ == rhs.data_;
    }

    bool operator!=(const contiguous_span_iterator& rhs) const { return !(*this == rhs); }

    bool operator<(const contiguous_span_iterator& rhs) const
    {
        Expects(m_validator == rhs.m_validator);
        return data_ < rhs.data_;
    }

    bool operator<=(const contiguous_span_iterator& rhs) const { return !(rhs < *this); }
    bool operator>(const contiguous_span_iterator& rhs) const { return rhs < *this; }
    bool operator>=(const contiguous_span_iterator& rhs) const { return !(rhs > *this); }

    void swap(contiguous_span_iterator & rhs) noexcept
    {
        std::swap(data_, rhs.data_);
        std::swap(m_validator, rhs.m_validator);
    }
};

template <typename Span>
contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>::difference_type n,
                                         const contiguous_span_iterator<Span>& rhs) noexcept
{
    return rhs + n;
}

template <typename Span>
class [[deprecated]] general_span_iterator {
public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = typename Span::value_type;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;

private:
    template <typename ValueType, std::size_t Rank>
    friend class strided_span;

    const Span* m_container;
    typename Span::bounds_type::iterator m_itr;
    general_span_iterator(const Span* container, bool isbegin)
        : m_container(container)
        , m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end())
    {}

public:
    reference operator*() noexcept { return (*m_container)[*m_itr]; }
    pointer operator->() noexcept { return &(*m_container)[*m_itr]; }
    general_span_iterator& operator++() noexcept
    {
        ++m_itr;
        return *this;
    }
    general_span_iterator operator++(int) noexcept
    {
        auto ret = *this;
        ++(*this);
        return ret;
    }
    general_span_iterator& operator--() noexcept
    {
        --m_itr;
        return *this;
    }
    general_span_iterator operator--(int) noexcept
    {
        auto ret = *this;
        --(*this);
        return ret;
    }
    general_span_iterator operator+(difference_type n) const noexcept
    {
        general_span_iterator ret{*this};
        return ret += n;
    }
    general_span_iterator& operator+=(difference_type n) noexcept
    {
        m_itr += n;
        return *this;
    }
    general_span_iterator operator-(difference_type n) const noexcept
    {
        general_span_iterator ret{*this};
        return ret -= n;
    }
    general_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; }
    difference_type operator-(const general_span_iterator& rhs) const
    {
        Expects(m_container == rhs.m_container);
        return m_itr - rhs.m_itr;
    }

    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    value_type operator[](difference_type n) const { return (*m_container)[m_itr[n]]; }

    bool operator==(const general_span_iterator& rhs) const
    {
        Expects(m_container == rhs.m_container);
        return m_itr == rhs.m_itr;
    }
    bool operator!=(const general_span_iterator& rhs) const { return !(*this == rhs); }
    bool operator<(const general_span_iterator& rhs) const
    {
        Expects(m_container == rhs.m_container);
        return m_itr < rhs.m_itr;
    }
    bool operator<=(const general_span_iterator& rhs) const { return !(rhs < *this); }
    bool operator>(const general_span_iterator& rhs) const { return rhs < *this; }
    bool operator>=(const general_span_iterator& rhs) const { return !(rhs > *this); }
    void swap(general_span_iterator & rhs) noexcept
    {
        std::swap(m_itr, rhs.m_itr);
        std::swap(m_container, rhs.m_container);
    }
};

template <typename Span>
general_span_iterator<Span> operator+(typename general_span_iterator<Span>::difference_type n,
                                      const general_span_iterator<Span>& rhs) noexcept
{
    return rhs + n;
}

} // namespace gsl

#if defined(_MSC_VER) && !defined(__clang__)
#if _MSC_VER < 1910

#undef constexpr
#pragma pop_macro("constexpr")
#endif // _MSC_VER < 1910

#pragma warning(pop)

#endif // _MSC_VER

#if defined(__GNUC__) && __GNUC__ > 6
#pragma GCC diagnostic pop
#endif // __GNUC__ > 6

#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic pop
#endif

#endif // GSL_MULTI_SPAN_H


================================================
FILE: examples/libraries/GSL/include/gsl/pointers
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_POINTERS_H
#define GSL_POINTERS_H

#include <gsl/gsl_assert>  // for Ensures, Expects

#include <algorithm>    // for forward
#include <iosfwd>       // for ptrdiff_t, nullptr_t, ostream, size_t
#include <memory>       // for shared_ptr, unique_ptr
#include <system_error> // for hash
#include <type_traits>  // for enable_if_t, is_convertible, is_assignable

#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/

#endif                          // defined(_MSC_VER) && _MSC_VER < 1910

namespace gsl
{

//
// GSL.owner: ownership pointers
//
using std::unique_ptr;
using std::shared_ptr;

//
// owner
//
// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some reason
//
// T must be a pointer type
// - disallow construction from any type other than pointer type
//
template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
using owner = T;

//
// not_null
//
// Restricts a pointer or smart pointer to only hold non-null values.
//
// Has zero size overhead over T.
//
// If T is a pointer (i.e. T == U*) then
// - allow construction from U*
// - disallow construction from nullptr_t
// - disallow default construction
// - ensure construction from null U* fails
// - allow implicit conversion to U*
//
template <class T>
class not_null
{
public:
    static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
    {
        Expects(ptr_ != nullptr);
    }

    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
    constexpr not_null(T u) : ptr_(u)
    {
        Expects(ptr_ != nullptr);
    }

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr not_null(const not_null<U>& other) : not_null(other.get())
    {
    }

    not_null(const not_null& other) = default;
    not_null& operator=(const not_null& other) = default;

    constexpr T get() const
    {
        Ensures(ptr_ != nullptr);
        return ptr_;
    }

    constexpr operator T() const { return get(); }
    constexpr T operator->() const { return get(); }
    constexpr decltype(auto) operator*() const { return *get(); }

    // prevents compilation when someone attempts to assign a null pointer constant
    not_null(std::nullptr_t) = delete;
    not_null& operator=(std::nullptr_t) = delete;

    // unwanted operators...pointers only point to single objects!
    not_null& operator++() = delete;
    not_null& operator--() = delete;
    not_null operator++(int) = delete;
    not_null operator--(int) = delete;
    not_null& operator+=(std::ptrdiff_t) = delete;
    not_null& operator-=(std::ptrdiff_t) = delete;
    void operator[](std::ptrdiff_t) const = delete;

private:
    T ptr_;
};

template <class T>
auto make_not_null(T&& t) {
    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
}

template <class T>
std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
{
    os << val.get();
    return os;
}

template <class T, class U>
auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() == rhs.get())
{
    return lhs.get() == rhs.get();
}

template <class T, class U>
auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() != rhs.get())
{
    return lhs.get() != rhs.get();
}

template <class T, class U>
auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() < rhs.get())
{
    return lhs.get() < rhs.get();
}

template <class T, class U>
auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() <= rhs.get())
{
    return lhs.get() <= rhs.get();
}

template <class T, class U>
auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() > rhs.get())
{
    return lhs.get() > rhs.get();
}

template <class T, class U>
auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() >= rhs.get())
{
    return lhs.get() >= rhs.get();
}

// more unwanted operators
template <class T, class U>
std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
template <class T>
not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
template <class T>
not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
template <class T>
not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;

} // namespace gsl

namespace std
{
template <class T>
struct hash<gsl::not_null<T>>
{
    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); }
};

} // namespace std

namespace gsl
{

//
// strict_not_null
//
// Restricts a pointer or smart pointer to only hold non-null values,
//
// - provides a strict (i.e. explicit constructor from T) wrapper of not_null
// - to be used for new code that wishes the design to be cleaner and make not_null
//   checks intentional, or in old code that would like to make the transition.
//
//   To make the transition from not_null, incrementally replace not_null
//   by strict_not_null and fix compilation errors
//
//   Expect to
//   - remove all unneeded conversions from raw pointer to not_null and back
//   - make API clear by specifying not_null in parameters where needed
//   - remove unnecessary asserts
//
template <class T>
class strict_not_null: public not_null<T>
{
public:

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr explicit strict_not_null(U&& u) :
        not_null<T>(std::forward<U>(u))
    {}

    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
    constexpr explicit strict_not_null(T u) :
        not_null<T>(u)
    {}

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr strict_not_null(const not_null<U>& other) :
        not_null<T>(other)
    {}

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr strict_not_null(const strict_not_null<U>& other) :
        not_null<T>(other)
    {}

    strict_not_null(strict_not_null&& other) = default;
    strict_not_null(const strict_not_null& other) = default;
    strict_not_null& operator=(const strict_not_null& other) = default;
    strict_not_null& operator=(const not_null<T>& other)
    {
        not_null<T>::operator=(other);
        return *this;
    }

    // prevents compilation when someone attempts to assign a null pointer constant
    strict_not_null(std::nullptr_t) = delete;
    strict_not_null& operator=(std::nullptr_t) = delete;

    // unwanted operators...pointers only point to single objects!
    strict_not_null& operator++() = delete;
    strict_not_null& operator--() = delete;
    strict_not_null operator++(int) = delete;
    strict_not_null operator--(int) = delete;
    strict_not_null& operator+=(std::ptrdiff_t) = delete;
    strict_not_null& operator-=(std::ptrdiff_t) = delete;
    void operator[](std::ptrdiff_t) const = delete;
};

// more unwanted operators
template <class T, class U>
std::ptrdiff_t operator-(const strict_not_null<T>&, const strict_not_null<U>&) = delete;
template <class T>
strict_not_null<T> operator-(const strict_not_null<T>&, std::ptrdiff_t) = delete;
template <class T>
strict_not_null<T> operator+(const strict_not_null<T>&, std::ptrdiff_t) = delete;
template <class T>
strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;

template <class T>
auto make_strict_not_null(T&& t) {
    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
}

#if ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

// deduction guides to prevent the ctad-maybe-unsupported warning
template <class T> not_null(T) -> not_null<T>;
template <class T> strict_not_null(T) -> strict_not_null<T>;

#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

} // namespace gsl

namespace std
{
template <class T>
struct hash<gsl::strict_not_null<T>>
{
    std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value); }
};

} // namespace std

#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)

#undef constexpr
#pragma pop_macro("constexpr")

#endif // defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)

#endif // GSL_POINTERS_H


================================================
FILE: examples/libraries/GSL/include/gsl/span
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_SPAN_H
#define GSL_SPAN_H

#include <gsl/gsl_assert> // for Expects
#include <gsl/gsl_byte>   // for byte

#include <array>       // for array
#include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
#include <iterator>    // for reverse_iterator, distance, random_access_...
#include <type_traits> // for enable_if_t, declval, is_convertible, inte...

#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)

// turn off some warnings that are noisy about our Expects statements
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(                                                                                   \
    disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
#pragma warning(disable : 4702) // unreachable code

// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
#pragma warning(disable : 26495) // uninitalized member when constructor calls constructor
#pragma warning(disable : 26446) // parser bug does not allow attributes on some templates

#if _MSC_VER < 1910
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/
#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND

#endif // _MSC_VER < 1910
#endif // _MSC_VER

// See if we have enough C++17 power to use a static constexpr data member
// without needing an out-of-line definition
#if !(defined(__cplusplus) && (__cplusplus >= 201703L))
#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))

// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
// While there is a conversion from signed to unsigned, it happens at
// compiletime, so the compiler wouldn't have to warn indiscriminately, but
// could check if the source value actually doesn't fit into the target type
// and only warn in those cases.
#if defined(__GNUC__) && __GNUC__ > 6
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif

namespace gsl
{

// [views.constants], constants
constexpr const std::size_t dynamic_extent = static_cast<std::size_t>(-1);

template <class ElementType, std::size_t Extent = dynamic_extent>
class span;

// implementation details
namespace details
{
    template <class T>
    struct is_span_oracle : std::false_type
    {
    };

    template <class ElementType, std::size_t Extent>
    struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
    {
    };

    template <class T>
    struct is_span : public is_span_oracle<std::remove_cv_t<T>>
    {
    };

    template <class T>
    struct is_std_array_oracle : std::false_type
    {
    };

    template <class ElementType, std::size_t Extent>
    struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type
    {
    };

    template <class T>
    struct is_std_array : is_std_array_oracle<std::remove_cv_t<T>>
    {
    };

    template <std::size_t From, std::size_t To>
    struct is_allowed_extent_conversion
        : std::integral_constant<bool, From == To || To == gsl::dynamic_extent>
    {
    };

    template <class From, class To>
    struct is_allowed_element_type_conversion
        : std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
    {
    };

    template <class Type>
    class span_iterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = std::remove_cv_t<Type>;
        using difference_type = std::ptrdiff_t;
        using pointer = Type*;
        using reference = Type&;

#ifdef _MSC_VER
        using _Unchecked_type = pointer;
#endif // _MSC_VER
        constexpr span_iterator() = default;

        constexpr span_iterator(pointer begin, pointer end, pointer current)
            : begin_(begin), end_(end), current_(current)
        {}

        constexpr operator span_iterator<const Type>() const noexcept
        {
            return {begin_, end_, current_};
        }

        constexpr reference operator*() const noexcept
        {
            Expects(begin_ && end_);
            Expects(begin_ <= current_ && current_ < end_);
            return *current_;
        }

        constexpr pointer operator->() const noexcept
        {
            Expects(begin_ && end_);
            Expects(begin_ <= current_ && current_ < end_);
            return current_;
        }
        constexpr span_iterator& operator++() noexcept
        {
            Expects(begin_ && current_ && end_);
            Expects(current_ < end_);
            ++current_;
            return *this;
        }

        constexpr span_iterator operator++(int) noexcept
        {
            span_iterator ret = *this;
            ++*this;
            return ret;
        }

        constexpr span_iterator& operator--() noexcept
        {
            Expects(begin_ && end_);
            Expects(begin_ < current_);
            --current_;
            return *this;
        }

        constexpr span_iterator operator--(int) noexcept
        {
            span_iterator ret = *this;
            --*this;
            return ret;
        }

        constexpr span_iterator& operator+=(const difference_type n) noexcept
        {
            if (n != 0) Expects(begin_ && current_ && end_);
            if (n > 0) Expects(end_ - current_ >= n);
            if (n < 0) Expects(current_ - begin_ >= -n);
            current_ += n;
            return *this;
        }

        constexpr span_iterator operator+(const difference_type n) const noexcept
        {
            span_iterator ret = *this;
            ret += n;
            return ret;
        }

        friend constexpr span_iterator operator+(const difference_type n,
                                                 const span_iterator& rhs) noexcept
        {
            return rhs + n;
        }

        constexpr span_iterator& operator-=(const difference_type n) noexcept
        {
            if (n != 0) Expects(begin_ && current_ && end_);
            if (n > 0) Expects(current_ - begin_ >= n);
            if (n < 0) Expects(end_ - current_ >= -n);
            current_ -= n;
            return *this;
        }

        constexpr span_iterator operator-(const difference_type n) const noexcept
        {
            span_iterator ret = *this;
            ret -= n;
            return ret;
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr difference_type operator-(const span_iterator<Type2>& rhs) const noexcept
        {
            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ - rhs.current_;
        }

        constexpr reference operator[](const difference_type n) const noexcept
        {
            return *(*this + n);
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator==(const span_iterator<Type2>& rhs) const noexcept
        {
            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ == rhs.current_;
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator!=(const span_iterator<Type2>& rhs) const noexcept
        {
            return !(*this == rhs);
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator<(const span_iterator<Type2>& rhs) const noexcept
        {
            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ < rhs.current_;
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator>(const span_iterator<Type2>& rhs) const noexcept
        {
            return rhs < *this;
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator<=(const span_iterator<Type2>& rhs) const noexcept
        {
            return !(rhs < *this);
        }

        template <
            class Type2,
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator>=(const span_iterator<Type2>& rhs) const noexcept
        {
            return !(*this < rhs);
        }

#ifdef _MSC_VER
        // MSVC++ iterator debugging support; allows STL algorithms in 15.8+
        // to unwrap span_iterator to a pointer type after a range check in STL
        // algorithm calls
        friend constexpr void _Verify_range(span_iterator lhs, span_iterator rhs) noexcept
        { // test that [lhs, rhs) forms a valid range inside an STL algorithm
            Expects(lhs.begin_ == rhs.begin_ // range spans have to match
                    && lhs.end_ == rhs.end_ &&
                    lhs.current_ <= rhs.current_); // range must not be transposed
        }

        constexpr void _Verify_offset(const difference_type n) const noexcept
        { // test that *this + n is within the range of this call
            if (n != 0) Expects(begin_ && current_ && end_);
            if (n > 0) Expects(end_ - current_ >= n);
            if (n < 0) Expects(current_ - begin_ >= -n);
        }

        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        constexpr pointer _Unwrapped() const noexcept
        { // after seeking *this to a high water mark, or using one of the
            // _Verify_xxx functions above, unwrap this span_iterator to a raw
            // pointer
            return current_;
        }

        // Tell the STL that span_iterator should not be unwrapped if it can't
        // validate in advance, even in release / optimized builds:
#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
        static constexpr const bool _Unwrap_when_unverified = false;
#else
        static constexpr bool _Unwrap_when_unverified = false;
#endif
        // clang-format off
        GSL_SUPPRESS(con.3) // NO-FORMAT: attribute // TODO: false positive
        // clang-format on
        constexpr void _Seek_to(const pointer p) noexcept
        { // adjust the position of *this to previously verified location p
            // after _Unwrapped
            current_ = p;
        }
#endif

        pointer begin_ = nullptr;
        pointer end_ = nullptr;
        pointer current_ = nullptr;
    };

    template <std::size_t Ext>
    class extent_type
    {
    public:
        using size_type = std::size_t;

        constexpr extent_type() noexcept = default;

        template <size_type Other>
        constexpr extent_type(extent_type<Other> ext)
        {
            static_assert(Other == Ext,
                          "Mismatch between fixed-size extent and size of initializing data.");
            Expects(ext.size() == Ext);
        }

        constexpr extent_type(size_type size) { Expects(size == Ext); }

        constexpr size_type size() const noexcept { return Ext; }
    };

    template <>
    class extent_type<dynamic_extent>
    {
    public:
        using size_type = std::size_t;

        template <size_type Other>
        explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size())
        {}

        explicit constexpr extent_type(size_type size) : size_(size)
        {
            Expects(size != dynamic_extent);
        }

        constexpr size_type size() const noexcept { return size_; }

    private:
        size_type size_;
    };

    template <class ElementType, std::size_t Extent, std::size_t Offset, std::size_t Count>
    struct calculate_subspan_type
    {
        using type = span<ElementType, Count != dynamic_extent
                                           ? Count
                                           : (Extent != dynamic_extent ? Extent - Offset : Extent)>;
    };
} // namespace details

// [span], class template span
template <class ElementType, std::size_t Extent>
class span
{
public:
    // constants and types
    using element_type = ElementType;
    using value_type = std::remove_cv_t<ElementType>;
    using size_type = std::size_t;
    using pointer = element_type*;
    using const_pointer = const element_type*;
    using reference = element_type&;
    using const_reference = const element_type&;
    using difference_type = std::ptrdiff_t;

    using iterator = details::span_iterator<ElementType>;
    using reverse_iterator = std::reverse_iterator<iterator>;

#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
    static constexpr const size_type extent{Extent};
#else
    static constexpr size_type extent{Extent};
#endif

    // [span.cons], span constructors, copy, assignment, and destructor
    template <bool Dependent = false,
              // "Dependent" is needed to make "std::enable_if_t<Dependent || Extent == 0 || Extent
              // == dynamic_extent>" SFINAE, since "std::enable_if_t<Extent == 0 || Extent ==
              // dynamic_extent>" is ill-formed when Extent is greater than 0.
              class = std::enable_if_t<(Dependent ||
                                        details::is_allowed_extent_conversion<0, Extent>::value)>>
    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
    {}

    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
    {
        if (Extent != dynamic_extent) Expects(count == Extent);
    }

    constexpr span(pointer firstElem, pointer lastElem) noexcept
        : storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))
    {
        if (Extent != dynamic_extent)
        { Expects(lastElem - firstElem == static_cast<difference_type>(Extent)); }
    }

    template <std::size_t N,
              std::enable_if_t<details::is_allowed_extent_conversion<N, Extent>::value, int> = 0>
    constexpr span(element_type (&arr)[N]) noexcept
        : storage_(KnownNotNull{arr + 0}, details::extent_type<N>())
    {}

    template <
        class T, std::size_t N,
        std::enable_if_t<(details::is_allowed_extent_conversion<N, Extent>::value &&
                          details::is_allowed_element_type_conversion<T, element_type>::value),
                         int> = 0>
    constexpr span(std::array<T, N>& arr) noexcept
        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
    {}

    template <class T, std::size_t N,
              std::enable_if_t<
                  (details::is_allowed_extent_conversion<N, Extent>::value &&
                   details::is_allowed_element_type_conversion<const T, element_type>::value),
                  int> = 0>
    constexpr span(const std::array<T, N>& arr) noexcept
        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
    {}

    // NB: the SFINAE here uses .data() as an incomplete/imperfect proxy for the requirement
    // on Container to be a contiguous sequence container.
    template <class Container,
              class = std::enable_if_t<
                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
                  std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
                  std::is_convertible<
                      std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
                      element_type (*)[]>::value>>
    constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
    {}

    template <class Container,
              class = std::enable_if_t<
                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
                  !details::is_std_array<Container>::value &&
                  std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
                  std::is_convertible<std::remove_pointer_t<
                                          decltype(std::declval<const Container&>().data())> (*)[],
                                      element_type (*)[]>::value>>
    constexpr span(const Container& cont) noexcept : span(cont.data(), cont.size())
    {}

    constexpr span(const span& other) noexcept = default;

    template <
        class OtherElementType, std::size_t OtherExtent,
        class = std::enable_if_t<
            details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>>
    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
    {}

    ~span() noexcept = default;
    constexpr span& operator=(const span& other) noexcept = default;

    // [span.sub], span subviews
    template <std::size_t Count>
    constexpr span<element_type, Count> first() const noexcept
    {
        Expects(Count <= size());
        return {data(), Count};
    }

    template <std::size_t Count>
    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        constexpr span<element_type, Count> last() const noexcept
    {
        Expects(Count <= size());
        return {data() + (size() - Count), Count};
    }

    template <std::size_t Offset, std::size_t Count = dynamic_extent>
    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        constexpr auto subspan() const noexcept ->
        typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
    {
        Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));

        return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
    }

    constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
    {
        Expects(count <= size());
        return {data(), count};
    }

    constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept
    {
        Expects(count <= size());
        return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
    }

    constexpr span<element_type, dynamic_extent> subspan(size_type offset,
                                                         size_type count = dynamic_extent) const
        noexcept
    {
        return make_subspan(offset, count, subspan_selector<Extent>{});
    }

    // [span.obs], span observers
    constexpr size_type size() const noexcept { return storage_.size(); }

    constexpr size_type size_bytes() const noexcept
    {
        Expects(size() < dynamic_extent / sizeof(element_type));
        return size() * sizeof(element_type);
    }

    constexpr bool empty() const noexcept { return size() == 0; }

    // [span.elem], span element access
    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    // clang-format on
    constexpr reference operator[](size_type idx) const noexcept
    {
        Expects(idx < size());
        return data()[idx];
    }

    constexpr reference front() const noexcept
    {
        Expects(size() > 0);
        return data()[0];
    }

    constexpr reference back() const noexcept
    {
        Expects(size() > 0);
        return data()[size() - 1];
    }

    constexpr pointer data() const noexcept { return storage_.data(); }

    // [span.iter], span iterator support
    constexpr iterator begin() const noexcept
    {
        const auto data = storage_.data();
        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        return {data, data + size(), data};
    }

    constexpr iterator end() const noexcept
    {
        const auto data = storage_.data();
        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        const auto endData = data + storage_.size();
        return {data, endData, endData};
    }

    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }

#ifdef _MSC_VER
    // Tell MSVC how to unwrap spans in range-based-for
    constexpr pointer _Unchecked_begin() const noexcept { return data(); }
    constexpr pointer _Unchecked_end() const noexcept
    {
        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        // clang-format on
        return data() + size();
    }
#endif // _MSC_VER

private:
    // Needed to remove unnecessary null check in subspans
    struct KnownNotNull
    {
        pointer p;
    };

    // this implementation detail class lets us take advantage of the
    // empty base class optimization to pay for only storage of a single
    // pointer in the case of fixed-size spans
    template <class ExtentType>
    class storage_type : public ExtentType
    {
    public:
        // KnownNotNull parameter is needed to remove unnecessary null check
        // in subspans and constructors from arrays
        template <class OtherExtentType>
        constexpr storage_type(KnownNotNull data, OtherExtentType ext)
            : ExtentType(ext), data_(data.p)
        {
            Expects(ExtentType::size() != dynamic_extent);
        }

        template <class OtherExtentType>
        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
        {
            Expects(ExtentType::size() != dynamic_extent);
            Expects(data || ExtentType::size() == 0);
        }

        constexpr pointer data() const noexcept { return data_; }

    private:
        pointer data_;
    };

    storage_type<details::extent_type<Extent>> storage_;

    // The rest is needed to remove unnecessary null check
    // in subspans and constructors from arrays
    constexpr span(KnownNotNull ptr, size_type count) noexcept : storage_(ptr, count) {}

    template <std::size_t CallerExtent>
    class subspan_selector
    {
    };

    template <std::size_t CallerExtent>
    constexpr span<element_type, dynamic_extent> make_subspan(size_type offset, size_type count,
                                                              subspan_selector<CallerExtent>) const
        noexcept
    {
        const span<element_type, dynamic_extent> tmp(*this);
        return tmp.subspan(offset, count);
    }

    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    // clang-format on
    constexpr span<element_type, dynamic_extent>
    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
    {
        Expects(size() >= offset);

        if (count == dynamic_extent) { return {KnownNotNull{data() + offset}, size() - offset}; }

        Expects(size() - offset >= count);
        return {KnownNotNull{data() + offset}, count};
    }
};

#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))

// Deduction Guides
template <class Type, std::size_t Extent>
span(Type (&)[Extent])->span<Type, Extent>;

template <class Type, std::size_t Size>
span(std::array<Type, Size>&)->span<Type, Size>;

template <class Type, std::size_t Size>
span(const std::array<Type, Size>&)->span<const Type, Size>;

#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
template <class ElementType, std::size_t Extent>
constexpr const typename span<ElementType, Extent>::size_type span<ElementType, Extent>::extent;
#endif

namespace details
{
    // if we only supported compilers with good constexpr support then
    // this pair of classes could collapse down to a constexpr function

    // we should use a narrow_cast<> to go to std::size_t, but older compilers may not see it as
    // constexpr
    // and so will fail compilation of the template
    template <class ElementType, std::size_t Extent>
    struct calculate_byte_size : std::integral_constant<std::size_t, sizeof(ElementType) * Extent>
    {
        static_assert(Extent < dynamic_extent / sizeof(ElementType), "Size is too big.");
    };

    template <class ElementType>
    struct calculate_byte_size<ElementType, dynamic_extent>
        : std::integral_constant<std::size_t, dynamic_extent>
    {
    };
} // namespace details

// [span.objectrep], views of object representation
template <class ElementType, std::size_t Extent>
span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
as_bytes(span<ElementType, Extent> s) noexcept
{
    // clang-format off
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    // clang-format on
    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
}

template <class ElementType, std::size_t Extent,
          std::enable_if_t<!std::is_const<ElementType>::value, int> = 0>
span<byte, details::calculate_byte_size<ElementType, Extent>::value>
as_writable_bytes(span<ElementType, Extent> s) noexcept
{
    // clang-format off
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    // clang-format on
    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
}

} // namespace gsl

#if defined(_MSC_VER) && !defined(__clang__)
#if _MSC_VER < 1910
#undef constexpr
#pragma pop_macro("constexpr")

#endif // _MSC_VER < 1910

#pragma warning(pop)
#endif // _MSC_VER

#if defined(__GNUC__) && __GNUC__ > 6
#pragma GCC diagnostic pop
#endif // __GNUC__ > 6

#endif // GSL_SPAN_H


================================================
FILE: examples/libraries/GSL/include/gsl/span_ext
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_SPAN_EXT_H
#define GSL_SPAN_EXT_H

///////////////////////////////////////////////////////////////////////////////
//
// File: span_ext
// Purpose: continue offering features that have been cut from the official
//   implementation of span.
//   While modernizing gsl::span a number of features needed to be removed to
//   be compliant with the design of std::span
//
///////////////////////////////////////////////////////////////////////////////


#include <gsl/gsl_util> // for narrow_cast, narrow
#include <gsl/span>     // for span

#include <algorithm> // for lexicographical_compare
#include <cstddef>   // for ptrdiff_t, size_t
#include <utility>

namespace gsl
{

// [span.comparison], span comparison operators
template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r)
{
    return std::equal(l.begin(), l.end(), r.begin(), r.end());
}

template <class ElementType, std::size_t Extent>
constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r)
{
    return !(l == r);
}

template <class ElementType, std::size_t Extent>
constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r)
{
    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
}

template <class ElementType, std::size_t Extent>
constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r)
{
    return !(l > r);
}

template <class ElementType, std::size_t Extent>
constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r)
{
    return r < l;
}

template <class ElementType, std::size_t Extent>
constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r)
{
    return !(l < r);
}

//
// make_span() - Utility functions for creating spans
//
template <class ElementType>
constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count)
{
    return span<ElementType>(ptr, count);
}

template <class ElementType>
constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
{
    return span<ElementType>(firstElem, lastElem);
}

template <class ElementType, std::size_t N>
constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
{
    return span<ElementType, N>(arr);
}

template <class Container>
constexpr span<typename Container::value_type> make_span(Container& cont)
{
    return span<typename Container::value_type>(cont);
}

template <class Container>
constexpr span<const typename Container::value_type> make_span(const Container& cont)
{
    return span<const typename Container::value_type>(cont);
}

template <class Ptr>
constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
{
    return span<typename Ptr::element_type>(cont, count);
}

template <class Ptr>
constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
{
    return span<typename Ptr::element_type>(cont);
}

// Specialization of gsl::at for span
template <class ElementType, std::size_t Extent>
constexpr ElementType& at(span<ElementType, Extent> s, index i)
{
    // No bounds checking here because it is done in span::operator[] called below
    Ensures(i >= 0);
    return s[narrow_cast<std::size_t>(i)];
}

// [span.obs] Free observer functions
template <class ElementType, std::size_t Extent>
constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
{
    return static_cast<std::ptrdiff_t>(s.size());
}

// [span.iter] Free functions for begin/end functions
template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::iterator
begin(const span<ElementType, Extent>& s) noexcept
{
    return s.begin();
}

template <class ElementType, std::size_t Extent = dynamic_extent>
constexpr typename span<ElementType, Extent>::iterator
end(const span<ElementType, Extent>& s) noexcept
{
    return s.end();
}

template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::reverse_iterator
rbegin(const span<ElementType, Extent>& s) noexcept
{
    return s.rbegin();
}

template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::reverse_iterator
rend(const span<ElementType, Extent>& s) noexcept
{
    return s.rend();
}

template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::iterator
cbegin(const span<ElementType, Extent>& s) noexcept
{
    return s.begin();
}

template <class ElementType, std::size_t Extent = dynamic_extent>
constexpr typename span<ElementType, Extent>::iterator
cend(const span<ElementType, Extent>& s) noexcept
{
    return s.end();
}

template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::reverse_iterator
crbegin(const span<ElementType, Extent>& s) noexcept
{
    return s.rbegin();
}

template <class ElementType, std::size_t Extent>
constexpr typename span<ElementType, Extent>::reverse_iterator
crend(const span<ElementType, Extent>& s) noexcept
{
    return s.rend();
}

} // namespace gsl

#endif // GSL_SPAN_EXT_H


================================================
FILE: examples/libraries/GSL/include/gsl/string_span
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 GSL_STRING_SPAN_H
#define GSL_STRING_SPAN_H

#include <gsl/gsl_assert> // for Ensures, Expects
#include <gsl/gsl_util>   // for narrow_cast
#include <gsl/span_ext>       // for operator!=, operator==, dynamic_extent

#include <algorithm> // for equal, lexicographical_compare
#include <array>     // for array
#include <cstddef>   // for size_t, nullptr_t
#include <cstdint>   // for PTRDIFF_MAX
#include <cstring>
#include <string>    // for basic_string, allocator, char_traits
#include <type_traits> // for declval, is_convertible, enable_if_t, add_...

#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)

// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
#pragma warning(disable : 26446) // TODO: bug in parser - attributes and templates
#pragma warning(disable : 26481) // TODO: suppress does not work inside templates sometimes

#if _MSC_VER < 1910
#pragma push_macro("constexpr")
#define constexpr /*constexpr*/

#endif // _MSC_VER < 1910
#endif // _MSC_VER

namespace gsl
{
//
// czstring and wzstring
//
// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
// that allow static analysis to help find bugs.
//
// There are no additional features/semantics that we can find a way to add inside the
// type system for these types that will not either incur significant runtime costs or
// (sometimes needlessly) break existing programs when introduced.
//

template <typename CharT, std::size_t Extent = dynamic_extent>
using basic_zstring = CharT*;

template <std::size_t Extent = dynamic_extent>
using czstring = basic_zstring<const char, Extent>;

template <std::size_t Extent = dynamic_extent>
using cwzstring = basic_zstring<const wchar_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using cu16zstring = basic_zstring<const char16_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using cu32zstring = basic_zstring<const char32_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using zstring = basic_zstring<char, Extent>;

template <std::size_t Extent = dynamic_extent>
using wzstring = basic_zstring<wchar_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using u16zstring = basic_zstring<char16_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using u32zstring = basic_zstring<char32_t, Extent>;

namespace details
{
    template <class CharT>
    std::size_t string_length(const CharT* str, std::size_t n)
    {
        if (str == nullptr || n == dynamic_extent) return 0;

        const span<const CharT> str_span{str, n};

        std::size_t len = 0;
        while (len < n && str_span[len]) len++;

        return len;
    }
} // namespace details

//
// ensure_sentinel()
//
// Provides a way to obtain an span from a contiguous sequence
// that ends with a (non-inclusive) sentinel value.
//
// Will fail-fast if sentinel cannot be found before max elements are examined.
//
template <typename T, const T Sentinel>
span<T, dynamic_extent> ensure_sentinel(T* seq,
                                        std::size_t max = static_cast<std::size_t>(-1))
{
    Ensures(seq != nullptr);

    GSL_SUPPRESS(
        f.23) // NO-FORMAT: attribute // TODO: false positive // TODO: suppress does not work
    auto cur = seq;
    Ensures(cur != nullptr); // workaround for removing the warning

    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute // TODO: suppress does not work
    while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;
    Ensures(*cur == Sentinel);
    return {seq, static_cast<std::size_t>(cur - seq)};
}

//
// ensure_z - creates a span for a zero terminated strings.
// Will fail fast if a null-terminator cannot be found before
// the limit of size_type.
//
template <typename CharT>
span<CharT, dynamic_extent> ensure_z(CharT* const& sz,
                                     std::size_t max = static_cast<std::size_t>(-1))
{
    return ensure_sentinel<CharT, CharT(0)>(sz, max);
}

template <typename CharT, std::size_t N>
span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
{
    return ensure_z(&sz[0], N);
}

template <class Cont>
span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
ensure_z(Cont& cont)
{
    return ensure_z(cont.data(), cont.size());
}

template <typename CharT, std::size_t>
class basic_string_span;

namespace details
{
    template <typename T>
    struct is_basic_string_span_oracle : std::false_type
    {
    };

    template <typename CharT, std::size_t Extent>
    struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type
    {
    };

    template <typename T>
    struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>>
    {
    };
} // namespace details

//
// string_span and relatives
//
template <typename CharT, std::size_t Extent = dynamic_extent>
class basic_string_span
{
public:
    using element_type = CharT;
    using value_type = std::remove_cv_t<element_type>;
    using pointer = std::add_pointer_t<element_type>;
    using reference = std::add_lvalue_reference_t<element_type>;
    using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>;
    using impl_type = span<element_type, Extent>;

    using size_type = typename impl_type::size_type;
    using iterator = typename impl_type::iterator;
    using reverse_iterator = typename impl_type::reverse_iterator;

    // default (empty)
    constexpr basic_string_span() noexcept = default;

    // copy
    constexpr basic_string_span(const basic_string_span& other) noexcept = default;

    // assign
    constexpr basic_string_span& operator=(const basic_string_span& other) noexcept = default;

    constexpr basic_string_span(pointer ptr, size_type length) : span_(ptr, length) {}
    constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}

    // From static arrays - if 0-terminated, remove 0 from the view
    // All other containers allow 0s within the length, so we do not remove them
    template <std::size_t N>
    constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
    {}

    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
    {}

    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
    {}

    // Container signature should work for basic_string after C++17 version exists
    template <class Traits, class Allocator>
    // GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute // TODO: parser bug
    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
        : span_(&str[0], str.length())
    {}

    template <class Traits, class Allocator>
    constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str)
        : span_(&str[0], str.length())
    {}

    // from containers. Containers must have a pointer type and data() function signatures
    template <class Container,
              class = std::enable_if_t<
                  !details::is_basic_string_span<Container>::value &&
                  std::is_convertible<typename Container::pointer, pointer>::value &&
                  std::is_convertible<typename Container::pointer,
                                      decltype(std::declval<Container>().data())>::value>>
    constexpr basic_string_span(Container& cont) : span_(cont)
    {}

    template <class Container,
              class = std::enable_if_t<
                  !details::is_basic_string_span<Container>::value &&
                  std::is_convertible<typename Container::pointer, pointer>::value &&
                  std::is_convertible<typename Container::pointer,
                                      decltype(std::declval<Container>().data())>::value>>
    constexpr basic_string_span(const Container& cont) : span_(cont)
    {}

    // from string_span
    template <
        class OtherValueType, std::size_t OtherExtent,
        class = std::enable_if_t<std::is_convertible<
            typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other)
        : span_(other.data(), other.length())
    {}

    template <size_type Count>
    constexpr basic_string_span<element_type, Count> first() const
    {
        return {span_.template first<Count>()};
    }

    constexpr basic_string_span<element_type, dynamic_extent> first(size_type count) const
    {
        return {span_.first(count)};
    }

    template <size_type Count>
    constexpr basic_string_span<element_type, Count> last() const
    {
        return {span_.template last<Count>()};
    }

    constexpr basic_string_span<element_type, dynamic_extent> last(size_type count) const
    {
        return {span_.last(count)};
    }

    template <size_type Offset, size_type Count>
    constexpr basic_string_span<element_type, Count> subspan() const
    {
        return {span_.template subspan<Offset, Count>()};
    }

    constexpr basic_string_span<element_type, dynamic_extent>
    subspan(size_type offset, size_type count = dynamic_extent) const
    {
        return {span_.subspan(offset, count)};
    }

    constexpr reference operator[](size_type idx) const { return span_[idx]; }
    constexpr reference operator()(size_type idx) const { return span_[idx]; }

    constexpr pointer data() const { return span_.data(); }

    constexpr size_type length() const noexcept { return span_.size(); }
    constexpr size_type size() const noexcept { return span_.size(); }
    constexpr size_type size_bytes() const noexcept { return span_.size_bytes(); }
    constexpr size_type length_bytes() const noexcept { return span_.length_bytes(); }
    constexpr bool empty() const noexcept { return size() == 0; }

    constexpr iterator begin() const noexcept { return span_.begin(); }
    constexpr iterator end() const noexcept { return span_.end(); }

    constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); }
    constexpr reverse_iterator rend() const noexcept { return span_.rend(); }

private:
    static impl_type remove_z(pointer const& sz, std::size_t max)
    {
        return {sz, details::string_length(sz, max)};
    }

    template <std::size_t N>
    static impl_type remove_z(element_type (&sz)[N])
    {
        return remove_z(&sz[0], N);
    }

    impl_type span_;
};

template <std::size_t Extent = dynamic_extent>
using string_span = basic_string_span<char, Extent>;

template <std::size_t Extent = dynamic_extent>
using cstring_span = basic_string_span<const char, Extent>;

template <std::size_t Extent = dynamic_extent>
using wstring_span = basic_string_span<wchar_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using cwstring_span = basic_string_span<const wchar_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using u16string_span = basic_string_span<char16_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using cu16string_span = basic_string_span<const char16_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using u32string_span = basic_string_span<char32_t, Extent>;

template <std::size_t Extent = dynamic_extent>
using cu32string_span = basic_string_span<const char32_t, Extent>;

//
// to_string() allow (explicit) conversions from string_span to string
//

template <typename CharT, std::size_t Extent>
std::basic_string<typename std::remove_const<CharT>::type>
to_string(basic_string_span<CharT, Extent> view)
{
    return {view.data(), narrow_cast<std::size_t>(view.length())};
}

template <typename CharT, typename Traits = typename std::char_traits<CharT>,
          typename Allocator = std::allocator<CharT>, typename gCharT, std::size_t Extent>
std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view)
{
    return {view.data(), narrow_cast<std::size_t>(view.length())};
}

template <class ElementType, std::size_t Extent>
basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
as_bytes(basic_string_span<ElementType, Extent> s) noexcept
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
}

template <class ElementType, std::size_t Extent,
          class = std::enable_if_t<!std::is_const<ElementType>::value>>
basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
as_writable_bytes(basic_string_span<ElementType, Extent> s) noexcept
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
}

// zero-terminated string span, used to convert
// zero-terminated spans to legacy strings
template <typename CharT, std::size_t Extent = dynamic_extent>
class basic_zstring_span
{
public:
    using value_type = CharT;
    using const_value_type = std::add_const_t<CharT>;

    using pointer = std::add_pointer_t<value_type>;
    using const_pointer = std::add_pointer_t<const_value_type>;

    using zstring_type = basic_zstring<value_type, Extent>;
    using const_zstring_type = basic_zstring<const_value_type, Extent>;

    using impl_type = span<value_type, Extent>;
    using string_span_type = basic_string_span<value_type, Extent>;

    constexpr basic_zstring_span(impl_type s) : span_(s)
    {
        // expects a zero-terminated span
        Expects(s[s.size() - 1] == '\0');
    }

    // copy
    constexpr basic_zstring_span(const basic_zstring_span& other) = default;

    // move
    constexpr basic_zstring_span(basic_zstring_span&& other) = default;

    // assign
    constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;

    // move assign
    constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;

    constexpr bool empty() const noexcept { return span_.size() == 0; }

    constexpr string_span_type as_string_span() const noexcept
    {
        const auto sz = span_.size();
        return {span_.data(), sz > 1 ? sz - 1 : 0};
    }
    constexpr string_span_type ensure_z() const { return gsl::ensure_z(span_); }

    constexpr const_zstring_type assume_z() const noexcept { return span_.data(); }

private:
    impl_type span_;
};

template <std::size_t Max = dynamic_extent>
using zstring_span = basic_zstring_span<char, Max>;

template <std::size_t Max = dynamic_extent>
using wzstring_span = basic_zstring_span<wchar_t, Max>;

template <std::size_t Max = dynamic_extent>
using u16zstring_span = basic_zstring_span<char16_t, Max>;

template <std::size_t Max = dynamic_extent>
using u32zstring_span = basic_zstring_span<char32_t, Max>;

template <std::size_t Max = dynamic_extent>
using czstring_span = basic_zstring_span<const char, Max>;

template <std::size_t Max = dynamic_extent>
using cwzstring_span = basic_zstring_span<const wchar_t, Max>;

template <std::size_t Max = dynamic_extent>
using cu16zstring_span = basic_zstring_span<const char16_t, Max>;

template <std::size_t Max = dynamic_extent>
using cu32zstring_span = basic_zstring_span<const char32_t, Max>;

// operator ==
template <class CharT, std::size_t Extent, class T,
          class = std::enable_if_t<
              details::is_basic_string_span<T>::value ||
              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other)
{
    const gsl::basic_string_span<std::add_const_t<CharT>> tmp(other);
    return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
}

template <class CharT, std::size_t Extent, class T,
          class = std::enable_if_t<
              !details::is_basic_string_span<T>::value &&
              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other)
{
    const gsl::basic_string_span<std::add_const_t<CharT>> tmp(one);
    return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end());
}

// operator !=
template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
          typename = std::enable_if_t<std::is_convertible<
              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return !(one == other);
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename = std::enable_if_t<
        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
        !gsl::details::is_basic_string_span<T>::value>>
bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return !(one == other);
}

// operator<
template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
          typename = std::enable_if_t<std::is_convertible<
              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    const gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename = std::enable_if_t<
        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
        !gsl::details::is_basic_string_span<T>::value>>
bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
}

#ifndef _MSC_VER

// VS treats temp and const containers as convertible to basic_string_span,
// so the cases below are already covered by the previous operators

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
}
#endif

// operator <=
template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
          typename = std::enable_if_t<std::is_convertible<
              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return !(other < one);
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename = std::enable_if_t<
        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
        !gsl::details::is_basic_string_span<T>::value>>
bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return !(other < one);
}

#ifndef _MSC_VER

// VS treats temp and const containers as convertible to basic_string_span,
// so the cases below are already covered by the previous operators

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return !(other < one);
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return !(other < one);
}
#endif

// operator>
template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
          typename = std::enable_if_t<std::is_convertible<
              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return other < one;
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename = std::enable_if_t<
        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
        !gsl::details::is_basic_string_span<T>::value>>
bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return other < one;
}

#ifndef _MSC_VER

// VS treats temp and const containers as convertible to basic_string_span,
// so the cases below are already covered by the previous operators

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return other < one;
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return other < one;
}
#endif

// operator >=
template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
          typename = std::enable_if_t<std::is_convertible<
              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return !(one < other);
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename = std::enable_if_t<
        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
        !gsl::details::is_basic_string_span<T>::value>>
bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return !(one < other);
}

#ifndef _MSC_VER

// VS treats temp and const containers as convertible to basic_string_span,
// so the cases below are already covered by the previous operators

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
{
    return !(one < other);
}

template <
    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
        std::is_convertible<DataType*, CharT*>::value &&
        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
                     DataType>::value>>
bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
{
    return !(one < other);
}
#endif
} // namespace gsl

#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)

#if _MSC_VER < 1910
#undef constexpr
#pragma pop_macro("constexpr")

#endif // _MSC_VER < 1910
#endif // _MSC_VER

#endif // GSL_STRING_SPAN_H


================================================
FILE: examples/libraries/GSL/tests/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.0.2)

project(GSLTests CXX)

# will make visual studio generated project group files
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
execute_process(
    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
    RESULT_VARIABLE result
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
)
if(result)
    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
endif()

execute_process(
    COMMAND ${CMAKE_COMMAND} --build .
    RESULT_VARIABLE result
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
)
if(result)
    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
endif()

set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)

add_subdirectory(
    ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
    EXCLUDE_FROM_ALL
)

if (MSVC AND (GSL_CXX_STANDARD EQUAL 17))
    set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
endif()

# this interface adds compile options to how the tests are run
# please try to keep entries ordered =)
add_library(gsl_tests_config INTERFACE)
if(MSVC) # MSVC or simulating MSVC
    target_compile_options(gsl_tests_config INTERFACE
        ${GSL_CPLUSPLUS_OPT}
        /EHsc
        /W4
        /WX
        $<$<CXX_COMPILER_ID:MSVC>:
          /wd4996  # Use of function or classes marked [[deprecated]]
          /wd26409 # CppCoreCheck - GTest
          /wd26426 # CppCoreCheck - GTest
          /wd26440 # CppCoreCheck - GTest
          /wd26446 # CppCoreCheck - prefer gsl::at()
          /wd26472 # CppCoreCheck - use gsl::narrow(_cast)
          /wd26481 # CppCoreCheck - use span instead of pointer arithmetic
          $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,1920>: # VS2015
            /wd4189 # variable is initialized but not referenced
            $<$<NOT:$<CONFIG:Debug>>: # Release, RelWithDebInfo
              /wd4702 # Unreachable code
            >
          >
        >
        $<$<CXX_COMPILER_ID:Clang>:
          -Weverything
          -Wno-c++98-compat
          -Wno-c++98-compat-pedantic
          -Wno-covered-switch-default # GTest
          -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
          -Wno-global-constructors # GTest
          -Wno-language-extension-token # GTest gtest-port.h
          -Wno-missing-braces
          -Wno-missing-prototypes
          -Wno-shift-sign-overflow # GTest gtest-port.h
          -Wno-undef # GTest
          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
            -Wno-unused-member-function
            -Wno-unused-variable
          >
        >
    )
else()
    target_compile_options(gsl_tests_config INTERFACE
        -fno-strict-aliasing
        -Wall
        -Wcast-align
        -Wconversion
        -Wctor-dtor-privacy
        -Werror
        -Wextra
        -Wpedantic
        -Wshadow
        -Wsign-conversion
        -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
          -Weverything
          -Wno-c++98-compat
          -Wno-c++98-compat-pedantic
          -Wno-missing-braces
          -Wno-covered-switch-default # GTest
          -Wno-global-constructors # GTest
          -Wno-missing-prototypes
          -Wno-padded
          -Wno-unknown-attributes
          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
          -Wno-weak-vtables
          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
            -Wno-unused-member-function
            -Wno-unused-variable
          >
        >
        $<$<CXX_COMPILER_ID:Clang>:
          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.99>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
          >
        >
        $<$<CXX_COMPILER_ID:AppleClang>:
          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,9.1>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,10>>:
            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
          >
        >
        $<$<CXX_COMPILER_ID:GNU>:
          -Wdouble-promotion # float implicit to double
          -Wlogical-op # suspicious uses of logical operators
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
            -Wduplicated-cond # duplicated if-else conditions
            -Wmisleading-indentation
            -Wnull-dereference
            $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
              -Wno-unused-variable
            >
          >
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
            -Wduplicated-branches # identical if-else branches
          >
        >
    )
endif(MSVC)

# for tests to find the gtest header
target_include_directories(gsl_tests_config SYSTEM INTERFACE
    googletest/googletest/include
)

set_property(TARGET  PROPERTY FOLDER "GSL_tests")

function(add_gsl_test name)
    add_executable(${name} ${name}.cpp)
    target_link_libraries(${name}
        GSL
        gsl_tests_config
        gtest_main
    )
    add_test(
        ${name}
        ${name}
    )
    # group all tests under GSL_tests
    set_property(TARGET ${name} PROPERTY FOLDER "GSL_tests")
endfunction()

add_gsl_test(span_tests)
add_gsl_test(span_ext_tests)
add_gsl_test(span_compatibility_tests)
add_gsl_test(multi_span_tests)
add_gsl_test(strided_span_tests)
add_gsl_test(string_span_tests)
add_gsl_test(at_tests)
add_gsl_test(bounds_tests)
add_gsl_test(notnull_tests)
add_gsl_test(assertion_tests)
add_gsl_test(utils_tests)
add_gsl_test(owner_tests)
add_gsl_test(byte_tests)
add_gsl_test(algorithm_tests)
add_gsl_test(strict_notnull_tests)


# No exception tests

foreach(flag_var
        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
    STRING (REGEX REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
endforeach(flag_var)

# this interface adds compile options to how the tests are run
# please try to keep entries ordered =)
add_library(gsl_tests_config_noexcept INTERFACE)
if(MSVC) # MSVC or simulating MSVC
    target_compile_definitions(gsl_tests_config_noexcept INTERFACE
        _HAS_EXCEPTIONS=0 # disable exceptions in the Microsoft STL
    )
    target_compile_options(gsl_tests_config_noexcept INTERFACE
        ${GSL_CPLUSPLUS_OPT}
        /W4
        /WX
        $<$<CXX_COMPILER_ID:MSVC>:
          /wd4577
          /wd4702
          /wd26440 # CppCoreCheck - GTest
          /wd26446 # CppCoreCheck - prefer gsl::at()
        >
        $<$<CXX_COMPILER_ID:Clang>:
          -Weverything
          -Wno-c++98-compat
          -Wno-c++98-compat-pedantic
          -Wno-missing-prototypes
          -Wno-unknown-attributes
        >
    )
else()
    target_compile_options(gsl_tests_config_noexcept INTERFACE
        -fno-exceptions
        -fno-strict-aliasing
        -Wall
        -Wcast-align
        -Wconversion
        -Wctor-dtor-privacy
        -Werror
        -Wextra
        -Wpedantic
        -Wshadow
        -Wsign-conversion
        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
          -Weverything
          -Wno-c++98-compat
          -Wno-c++98-compat-pedantic
          -Wno-missing-prototypes
          -Wno-unknown-attributes
          -Wno-weak-vtables
        >
        $<$<CXX_COMPILER_ID:GNU>:
          -Wdouble-promotion # float implicit to double
          -Wlogical-op # suspicious uses of logical operators
          -Wuseless-cast # casting to its own type
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
            -Wduplicated-cond # duplicated if-else conditions
            -Wmisleading-indentation
            -Wnull-dereference
          >
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
            -Wduplicated-branches # identical if-else branches
          >
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>>:
            -Wcast-align=strict # increase alignment (i.e. char* to int*)
          >
        >
    )
endif(MSVC)

function(add_gsl_test_noexcept name)
    add_executable(${name} ${name}.cpp)
    target_link_libraries(${name}
        GSL
        gsl_tests_config_noexcept
        gtest_main
    )
    add_test(
      ${name}
      ${name}
    )
    # group all tests under GSL_tests_noexcept
    set_property(TARGET ${name} PROPERTY FOLDER "GSL_tests_noexcept")
endfunction()

add_gsl_test_noexcept(no_exception_ensure_tests)


================================================
FILE: examples/libraries/GSL/tests/CMakeLists.txt.in
================================================
cmake_minimum_required(VERSION 3.0.2)
project(googletest-download NONE)

include(ExternalProject)
ExternalProject_Add(googletest
  GIT_REPOSITORY    https://github.com/google/googletest.git
  GIT_TAG           703bd9caab50b139428cea1aaff9974ebee5742e
  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND     ""
  INSTALL_COMMAND   ""
  TEST_COMMAND      ""
)


================================================
FILE: examples/libraries/GSL/tests/algorithm_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>
#include <gsl/gsl_algorithm> // for copy
#include <gsl/span>          // for span
#include <array>   // for array
#include <cstddef> // for size_t

namespace
{
    static constexpr char deathstring[] = "Expected Death";
}

namespace gsl
{
struct fail_fast;
} // namespace gsl

using namespace std;
using namespace gsl;

TEST(algorithm_tests, same_type)
{
    // dynamic source and destination span
    {
        std::array<int, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<int> src_span(src);
        const span<int> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // static source and dynamic destination span
    {
        std::array<int, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<int, 5> src_span(src);
        const span<int> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // dynamic source and static destination span
    {
        std::array<int, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<int> src_span(src);
        const span<int, 10> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // static source and destination span
    {
        std::array<int, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<int, 5> src_span(src);
        const span<int, 10> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }
}

TEST(algorithm_tests, compatible_type)
{
    // dynamic source and destination span
    {
        std::array<short, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<short> src_span(src);
        const span<int> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // static source and dynamic destination span
    {
        std::array<short, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<short, 5> src_span(src);
        const span<int> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // dynamic source and static destination span
    {
        std::array<short, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<short> src_span(src);
        const span<int, 10> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }

    // static source and destination span
    {
        std::array<short, 5> src{1, 2, 3, 4, 5};
        std::array<int, 10> dst{};

        const span<short, 5> src_span(src);
        const span<int, 10> dst_span(dst);

        copy(src_span, dst_span);
        copy(src_span, dst_span.subspan(src_span.size()));

        for (std::size_t i = 0; i < src.size(); ++i)
        {
            EXPECT_TRUE(dst[i] == src[i]);
            EXPECT_TRUE(dst[i + src.size()] == src[i]);
        }
    }
}

#ifdef CONFIRM_COMPILATION_ERRORS
TEST(algorithm_tests, incompatible_type)
{
    std::array<int, 4> src{1, 2, 3, 4};
    std::array<int*, 12> dst{};

    span<int> src_span_dyn(src);
    span<int, 4> src_span_static(src);
    span<int*> dst_span_dyn(dst);
    span<int*, 4> dst_span_static(dst);

    // every line should produce a compilation error
    copy(src_span_dyn, dst_span_dyn);
    copy(src_span_dyn, dst_span_static);
    copy(src_span_static, dst_span_dyn);
    copy(src_span_static, dst_span_static);
}
#endif

TEST(algorithm_tests, small_destination_span)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. small_destination_span";
        std::abort();
    });

    std::array<int, 12> src{1, 2, 3, 4};
    std::array<int, 4> dst{};

    const span<int> src_span_dyn(src);
    const span<int, 12> src_span_static(src);
    const span<int> dst_span_dyn(dst);
    const span<int, 4> dst_span_static(dst);

    EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), deathstring);
    EXPECT_DEATH(copy(src_span_dyn, dst_span_static), deathstring);
    EXPECT_DEATH(copy(src_span_static, dst_span_dyn), deathstring);

#ifdef CONFIRM_COMPILATION_ERRORS
    copy(src_span_static, dst_span_static);
#endif
}


================================================
FILE: examples/libraries/GSL/tests/assertion_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>
#include <gsl/gsl_assert> // for fail_fast (ptr only), Ensures, Expects

using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";

int f(int i)
{
    Expects(i > 0 && i < 10);
    return i;
}

int g(int i)
{
    i++;
    Ensures(i > 0 && i < 10);
    return i;
}
} // namespace

TEST(assertion_tests, expects)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. expects";
        std::abort();
    });

    EXPECT_TRUE(f(2) == 2);
    EXPECT_DEATH(f(10), deathstring);
}


TEST(assertion_tests, ensures)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. ensures";
        std::abort();
    });

    EXPECT_TRUE(g(2) == 3);
    EXPECT_DEATH(g(9), deathstring);
}


================================================
FILE: examples/libraries/GSL/tests/at_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_util> // for at

#include <array>            // for array
#include <cstddef>          // for size_t
#include <initializer_list> // for initializer_list
#include <vector>           // for vector

namespace
{
    static constexpr char deathstring[] = "Expected Death";
}

TEST(at_tests, static_array)
{
    int a[4] = {1, 2, 3, 4};
    const int(&c_a)[4] = a;

    for (int i = 0; i < 4; ++i) {
        EXPECT_TRUE(&gsl::at(a, i) == &a[i]);
        EXPECT_TRUE(&gsl::at(c_a, i) == &a[i]);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. static_array";
        std::abort();
    });

    EXPECT_DEATH(gsl::at(a, -1), deathstring);
    EXPECT_DEATH(gsl::at(a, 4), deathstring);
    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
}

TEST(at_tests, std_array)
{
    std::array<int, 4> a = {1, 2, 3, 4};
    const std::array<int, 4>& c_a = a;

    for (int i = 0; i < 4; ++i) {
        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. std_array";
        std::abort();
    });

    EXPECT_DEATH(gsl::at(a, -1), deathstring);
    EXPECT_DEATH(gsl::at(a, 4), deathstring);
    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
}

TEST(at_tests, std_vector)
{
    std::vector<int> a = {1, 2, 3, 4};
    const std::vector<int>& c_a = a;

    for (int i = 0; i < 4; ++i) {
        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. std_vector";
        std::abort();
    });

    EXPECT_DEATH(gsl::at(a, -1), deathstring);
    EXPECT_DEATH(gsl::at(a, 4), deathstring);
    EXPECT_DEATH(gsl::at(c_a, -1), deathstring);
    EXPECT_DEATH(gsl::at(c_a, 4), deathstring);
}

TEST(at_tests, InitializerList)
{
    const std::initializer_list<int> a = {1, 2, 3, 4};

    for (int i = 0; i < 4; ++i) {
        EXPECT_TRUE(gsl::at(a, i) == i + 1);
        EXPECT_TRUE(gsl::at({1, 2, 3, 4}, i) == i + 1);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. InitializerList";
        std::abort();
    });

    EXPECT_DEATH(gsl::at(a, -1), deathstring);
    EXPECT_DEATH(gsl::at(a, 4), deathstring);
    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, -1), deathstring);
    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, 4), deathstring);
}

#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
static constexpr bool test_constexpr()
{
    int a1[4] = {1, 2, 3, 4};
    const int(&c_a1)[4] = a1;
    std::array<int, 4> a2 = {1, 2, 3, 4};
    const std::array<int, 4>& c_a2 = a2;

    for (int i = 0; i < 4; ++i) {
        if (&gsl::at(a1, i) != &a1[i]) return false;
        if (&gsl::at(c_a1, i) != &a1[i]) return false;
        // requires C++17:
        // if (&gsl::at(a2, i) != &a2[static_cast<std::size_t>(i)]) return false;
        if (&gsl::at(c_a2, i) != &c_a2[static_cast<std::size_t>(i)]) return false;
        if (gsl::at({1, 2, 3, 4}, i) != i + 1) return false;
    }

    return true;
}

static_assert(test_constexpr(), "FAIL");
#endif


================================================
FILE: examples/libraries/GSL/tests/bounds_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/multi_span> // for static_bounds, static_bounds_dynamic_range_t

#include <cstddef> // for ptrdiff_t, size_t

using namespace std;
using namespace gsl;

namespace
{
void use(std::ptrdiff_t&) {}
}

TEST(bounds_tests, basic_bounds)
{
    for (auto point : static_bounds<dynamic_range, 3, 4>{2}) {
        for (decltype(point)::size_type j = 0;
             j < static_cast<decltype(point)::size_type>(decltype(point)::rank); j++)
        {
            use(j);
            use(point[static_cast<std::size_t>(j)]);
        }
    }
}

TEST(bounds_tests, bounds_basic)
{
    static_bounds<3, 4, 5> b;
    const auto a = b.slice();
    (void) a;
    static_bounds<4, dynamic_range, 2> x{4};
    x.slice().slice();
}

TEST(bounds_tests, arrayview_iterator)
{
    static_bounds<4, dynamic_range, 2> bounds{3};

    const auto itr = bounds.begin();
    (void) itr;
#ifdef CONFIRM_COMPILATION_ERRORS
    multi_span<int, 4, dynamic_range, 2> av(nullptr, bounds);

    auto itr2 = av.cbegin();

    for (auto& v : av) {
        v = 4;
    }
    fill(av.begin(), av.end(), 0);
#endif
}

TEST(bounds_tests, bounds_convertible)
{
    static_bounds<7, 4, 2> b1;
    static_bounds<7, dynamic_range, 2> b2 = b1;
    (void) b2;
#ifdef CONFIRM_COMPILATION_ERRORS
    static_bounds<7, dynamic_range, 1> b4 = b2;
#endif

    static_bounds<dynamic_range, dynamic_range, dynamic_range> b3 = b1;
    static_bounds<7, 4, 2> b4 = b3;
    (void) b4;

    static_bounds<dynamic_range> b5;
    static_bounds<34> b6;

    std::set_terminate([] {
        std::cerr << "Expected Death. bounds_convertible";
        std::abort();
    });

    b5 = static_bounds<20>();
    EXPECT_DEATH(b6 = b5, ".*");
    b5 = static_bounds<34>();
    b6 = b5;

    EXPECT_TRUE(b5 == b6);
    EXPECT_TRUE(b5.size() == b6.size());
}

#ifdef CONFIRM_COMPILATION_ERRORS
copy(src_span_static, dst_span_static);
#endif


================================================
FILE: examples/libraries/GSL/tests/byte_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...

using namespace std;
using namespace gsl;

namespace
{
int modify_both(gsl::byte& b, int& i)
{
    i = 10;
    b = to_byte<5>();
    return i;
}

TEST(byte_tests, construction)
{
    {
        const byte b = static_cast<byte>(4);
        EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
    }

    GSL_SUPPRESS(es.49)
    {
        const byte b = byte(12);
        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
    }

    {
        const byte b = to_byte<12>();
        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
    }
    {
        const unsigned char uc = 12;
        const byte b = to_byte(uc);
        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
    }

#if defined(__cplusplus) && (__cplusplus >= 201703L)
    {
        const byte b { 14 };
        EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
    }
#endif
}

TEST(byte_tests, bitwise_operations)
{
    const byte b = to_byte<0xFF>();

    byte a = to_byte<0x00>();
    EXPECT_TRUE((b | a) == to_byte<0xFF>());
    EXPECT_TRUE(a == to_byte<0x00>());

    a |= b;
    EXPECT_TRUE(a == to_byte<0xFF>());

    a = to_byte<0x01>();
    EXPECT_TRUE((b & a) == to_byte<0x01>());

    a &= b;
    EXPECT_TRUE(a == to_byte<0x01>());

    EXPECT_TRUE((b ^ a) == to_byte<0xFE>());

    EXPECT_TRUE(a == to_byte<0x01>());
    a ^= b;
    EXPECT_TRUE(a == to_byte<0xFE>());

    a = to_byte<0x01>();
    EXPECT_TRUE(~a == to_byte<0xFE>());

    a = to_byte<0xFF>();
    EXPECT_TRUE((a << 4) == to_byte<0xF0>());
    EXPECT_TRUE((a >> 4) == to_byte<0x0F>());

    a <<= 4;
    EXPECT_TRUE(a == to_byte<0xF0>());
    a >>= 4;
    EXPECT_TRUE(a == to_byte<0x0F>());
}

TEST(byte_tests, to_integer)
{
    const byte b = to_byte<0x12>();

    EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<long>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<long long>(b));

    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned char>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned short>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long>(b));
    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long long>(b));

    //      EXPECT_TRUE(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
    //      EXPECT_TRUE(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
}

TEST(byte_tests, aliasing)
{
    int i{0};
    const int res = modify_both(reinterpret_cast<byte&>(i), i);
    EXPECT_TRUE(res == i);
}

}

#ifdef CONFIRM_COMPILATION_ERRORS
copy(src_span_static, dst_span_static);
#endif


================================================
FILE: examples/libraries/GSL/tests/multi_span_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_byte>   // for byte
#include <gsl/gsl_util>   // for narrow_cast
#include <gsl/multi_span> // for multi_span, contiguous_span_iterator, dim

#include <algorithm> // for fill, for_each
#include <array>     // for array
#include <iostream>  // for ptrdiff_t, size_t
#include <iterator>  // for reverse_iterator, begin, end, operator!=
#include <numeric>   // for iota
#include <stddef.h>  // for ptrdiff_t
#include <string>    // for string
#include <vector>    // for vector

namespace gsl
{
struct fail_fast;
} // namespace gsl

using namespace std;
using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";
struct BaseClass
{
};
struct DerivedClass : BaseClass
{
};

void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int expected_value)
{
    for (auto val : exp) { EXPECT_TRUE(val == expected_value); }
}

void overloaded_func(multi_span<const char, dynamic_range, 3, 5> exp, char expected_value)
{
    for (auto val : exp) { EXPECT_TRUE(val == expected_value); }
}

void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av)
{
    auto length = av.size() / 2;

    // view to the second column
    auto section = av.section({0, 1}, {length, 1});

    EXPECT_TRUE(section.size() == length);
    for (auto i = 0; i < section.size(); ++i) { EXPECT_TRUE(section[i][0] == av[i][1]); }

    for (auto i = 0; i < section.size(); ++i)
    {
        auto idx = multi_span_index<2>{i, 0}; // avoid braces inside the CHECK macro
        EXPECT_TRUE(section[idx] == av[i][1]);
    }

    EXPECT_TRUE(section.bounds().index_bounds()[0] == length);
    EXPECT_TRUE(section.bounds().index_bounds()[1] == 1);
    for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i)
    {
        for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j)
        {
            auto idx = multi_span_index<2>{i, j}; // avoid braces inside the CHECK macro
            EXPECT_TRUE(section[idx] == av[i][1]);
        }
    }

    auto check_sum = 0;
    for (auto i = 0; i < length; ++i) { check_sum += av[i][1]; }

    {
        auto idx = 0;
        auto sum = 0;
        for (auto num : section)
        {
            EXPECT_TRUE(num == av[idx][1]);
            sum += num;
            idx++;
        }

        EXPECT_TRUE(sum == check_sum);
    }
    {
        auto idx = length - 1;
        auto sum = 0;
        for (auto iter = section.rbegin(); iter != section.rend(); ++iter)
        {
            EXPECT_TRUE(*iter == av[idx][1]);
            sum += *iter;
            idx--;
        }

        EXPECT_TRUE(sum == check_sum);
    }
}
template <class Bounds>
void fn(const Bounds&)
{
    static_assert(Bounds::static_size == 60, "static bounds is wrong size");
}

} // namespace

TEST(multi_span_test, default_constructor)
{
    {
        multi_span<int> s;
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int> cs;
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
        multi_span<int, 0> s;
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int, 0> cs;
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 1> s;
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == nullptr); // explains why it can't compile
#endif
    }

    {
        multi_span<int> s{};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int> cs{};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }
}

TEST(multi_span_test, from_nullptr_constructor)
{
    {
        multi_span<int> s = nullptr;
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int> cs = nullptr;
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
        multi_span<int, 0> s = nullptr;
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int, 0> cs = nullptr;
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 1> s = nullptr;
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == nullptr); // explains why it can't compile
#endif
    }

    {
        multi_span<int> s{nullptr};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int> cs{nullptr};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
        multi_span<int*> s{nullptr};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int*> cs{nullptr};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }
}

TEST(multi_span_test, from_nullptr_length_constructor) {
    {
        multi_span<int> s{nullptr, 0};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int> cs{nullptr, 0};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
        multi_span<int, 0> s{nullptr, 0};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int, 0> cs{nullptr, 0};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. from_nullptr_length_constructor";
        std::abort();
    });

    {
        auto workaround_macro = []() { const multi_span<int> s{nullptr, 1}; };
        EXPECT_DEATH(workaround_macro(), deathstring);

        auto const_workaround_macro = []() { const multi_span<const int> cs{nullptr, 1}; };
        EXPECT_DEATH(const_workaround_macro(), deathstring);
    }

    {
        auto workaround_macro = []() { const multi_span<int, 0> s{nullptr, 1}; };
        EXPECT_DEATH(workaround_macro(), deathstring);

        auto const_workaround_macro = []() { const multi_span<const int, 0> s{nullptr, 1}; };
        EXPECT_DEATH(const_workaround_macro(), deathstring);
    }

    {
        multi_span<int*> s{nullptr, 0};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);

        multi_span<const int*> cs{nullptr, 0};
        EXPECT_TRUE(cs.length() ==  0);
        EXPECT_TRUE(cs.data() == nullptr);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 1> s{nullptr, 0};
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == nullptr); // explains why it can't compile
#endif
    }
}

TEST(multi_span_test, from_element_constructor)
{
    int i = 5;

    {
        multi_span<int> s = i;
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == &i);
        EXPECT_TRUE(s[0] == 5);

        multi_span<const int> cs = i;
        EXPECT_TRUE(cs.length() ==  1);
        EXPECT_TRUE(cs.data() == &i);
        EXPECT_TRUE(cs[0] == 5);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const j = 1;
        multi_span<int, 0> s = j;
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 0> s = i;
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &i);
#endif
    }

    {
        multi_span<int, 1> s = i;
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == &i);
        EXPECT_TRUE(s[0] == 5);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 2> s = i;
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &i);
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_a_temp = []() -> int { return 4; };
        auto use_a_span = [](multi_span<int> s) { (void) s; };
        use_a_span(get_a_temp());
#endif
    }
}

TEST(multi_span_test, from_pointer_length_constructor)
{
    int arr[4] = {1, 2, 3, 4};

    {
        multi_span<int> s{&arr[0], 2};
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        multi_span<int, 2> s{&arr[0], 2};
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        int* p = nullptr;
        multi_span<int> s{p, 0};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == nullptr);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. from_pointer_length_constructor";
        std::abort();
    });

    {
        int* p = nullptr;
        auto workaround_macro = [=]() { const multi_span<int> s{p, 2}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }
}

TEST(multi_span_test, from_pointer_pointer_constructor)
{
    int arr[4] = {1, 2, 3, 4};

    {
        multi_span<int> s{&arr[0], &arr[2]};
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        multi_span<int, 2> s{&arr[0], &arr[2]};
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        multi_span<int> s{&arr[0], &arr[0]};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    {
        multi_span<int, 0> s{&arr[0], &arr[0]};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }


    std::set_terminate([] {
        std::cerr << "Expected Death. from_pointer_pointer_constructor";
        std::abort();
    });

    {
        auto workaround_macro = [&]() { const multi_span<int> s{&arr[1], &arr[0]}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;
        auto workaround_macro = [&]() { const multi_span<int> s{&arr[0], p}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;
        auto workaround_macro = [&]() { const multi_span<int> s{p, p}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;
        auto workaround_macro = [&]() { const multi_span<int> s{&arr[0], p}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }
}

TEST(multi_span_test, from_array_constructor)
{
    int arr[5] = {1, 2, 3, 4, 5};

    {
        multi_span<int> s{arr};
        EXPECT_TRUE(s.length() ==  5);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    {
        multi_span<int, 5> s{arr};
        EXPECT_TRUE(s.length() ==  5);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 6> s{arr};
#endif
    }

    {
        multi_span<int, 0> s{arr};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    int arr2d[2][3] = {1, 2, 3, 4, 5, 6};

    {
        multi_span<int> s{arr2d};
        EXPECT_TRUE(s.length() ==  6);
        EXPECT_TRUE(s.data() == &arr2d[0][0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[5] == 6);
    }

    {
        multi_span<int, 0> s{arr2d};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr2d[0][0]);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 5> s{arr2d};
#endif
    }

    {
        multi_span<int, 6> s{arr2d};
        EXPECT_TRUE(s.length() ==  6);
        EXPECT_TRUE(s.data() == &arr2d[0][0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[5] == 6);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 7> s{arr2d};
#endif
    }

    {
        multi_span<int[3]> s{arr2d[0]};
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == &arr2d[0]);
    }

    {
        multi_span<int, 2, 3> s{arr2d};
        EXPECT_TRUE(s.length() ==  6);
        EXPECT_TRUE(s.data() == &arr2d[0][0]);
        auto workaround_macro = [&]() { return s[{1, 2}] == 6; };
        EXPECT_TRUE(workaround_macro());
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 3, 3> s{arr2d};
#endif
    }

    int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    {
        multi_span<int> s{arr3d};
        EXPECT_TRUE(s.length() ==  12);
        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[11] == 12);
    }

    {
        multi_span<int, 0> s{arr3d};
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 11> s{arr3d};
#endif
    }

    {
        multi_span<int, 12> s{arr3d};
        EXPECT_TRUE(s.length() ==  12);
        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
        EXPECT_TRUE(s[0] ==  1);
        EXPECT_TRUE(s[5] == 6);
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 13> s{arr3d};
#endif
    }

    {
        multi_span<int[3][2]> s{arr3d[0]};
        EXPECT_TRUE(s.length() ==  1);
        EXPECT_TRUE(s.data() == &arr3d[0]);
    }

    {
        multi_span<int, 3, 2, 2> s{arr3d};
        EXPECT_TRUE(s.length() ==  12);
        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
        auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; };
        EXPECT_TRUE(workaround_macro());
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 3, 3, 3> s{arr3d};
#endif
    }
}

TEST(multi_span_test, from_dynamic_array_constructor)
{
    double(*arr)[3][4] = new double[100][3][4];

    std::set_terminate([] {
        std::cerr << "Expected Death. from_nullptr_length_constructor";
        std::abort();
    });

    {
        multi_span<double, dynamic_range, 3, 4> s(arr, 10);
        EXPECT_TRUE(s.length() ==  120);
        EXPECT_TRUE(s.data() == &arr[0][0][0]);
        EXPECT_DEATH(s[10][3][4], deathstring);
    }

    {
        multi_span<double, dynamic_range, 4, 3> s(arr, 10);
        EXPECT_TRUE(s.length() ==  120);
        EXPECT_TRUE(s.data() == &arr[0][0][0]);
    }

    {
        multi_span<double> s(arr, 10);
        EXPECT_TRUE(s.length() ==  120);
        EXPECT_TRUE(s.data() == &arr[0][0][0]);
    }

    {
        multi_span<double, dynamic_range, 3, 4> s(arr, 0);
        EXPECT_TRUE(s.length() ==  0);
        EXPECT_TRUE(s.data() == &arr[0][0][0]);
    }

    delete[] arr;
}

TEST(multi_span_test, from_std_array_constructor)
{
    std::array<int, 4> arr = {1, 2, 3, 4};

    {
        multi_span<int> s{arr};
        EXPECT_TRUE(s.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(s.data() == arr.data());

        multi_span<const int> cs{arr};
        EXPECT_TRUE(cs.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(cs.data() == arr.data());
    }

    {
        multi_span<int, 4> s{arr};
        EXPECT_TRUE(s.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(s.data() == arr.data());

        multi_span<const int, 4> cs{arr};
        EXPECT_TRUE(cs.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(cs.data() == arr.data());
    }

    {
        multi_span<int, 2> s{arr};
        EXPECT_TRUE(s.size() ==  2);
        EXPECT_TRUE(s.data() == arr.data());

        multi_span<const int, 2> cs{arr};
        EXPECT_TRUE(cs.size() ==  2);
        EXPECT_TRUE(cs.data() == arr.data());
    }

    {
        multi_span<int, 0> s{arr};
        EXPECT_TRUE(s.size() ==  0);
        EXPECT_TRUE(s.data() == arr.data());

        multi_span<const int, 0> cs{arr};
        EXPECT_TRUE(cs.size() ==  0);
        EXPECT_TRUE(cs.data() == arr.data());
    }

    // TODO This is currently an unsupported scenario. We will come back to it as we revise
    // the multidimensional interface and what transformations between dimensionality look like
    //{
    //    multi_span<int, 2, 2> s{arr};
    //    EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
    //    EXPECT_TRUE(s.data() == arr.data());
    //}

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<int, 5> s{arr};
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; };
        auto take_a_span = [](multi_span<int> s) { (void) s; };
        // try to take a temporary std::array
        take_a_span(get_an_array());
#endif
    }
}

TEST(multi_span_test, from_const_std_array_constructor)
{
    const std::array<int, 4> arr = {1, 2, 3, 4};

    {
        multi_span<const int> s{arr};
        EXPECT_TRUE(s.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(s.data() == arr.data());
    }

    {
        multi_span<const int, 4> s{arr};
        EXPECT_TRUE(s.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
        EXPECT_TRUE(s.data() == arr.data());
    }

    {
        multi_span<const int, 2> s{arr};
        EXPECT_TRUE(s.size() ==  2);
        EXPECT_TRUE(s.data() == arr.data());
    }

    {
        multi_span<const int, 0> s{arr};
        EXPECT_TRUE(s.size() ==  0);
        EXPECT_TRUE(s.data() == arr.data());
    }

    // TODO This is currently an unsupported scenario. We will come back to it as we revise
    // the multidimensional interface and what transformations between dimensionality look like
    //{
    //    multi_span<int, 2, 2> s{arr};
    //    EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
    //    EXPECT_TRUE(s.data() == arr.data());
    //}

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<const int, 5> s{arr};
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
        auto take_a_span = [](multi_span<const int> s) { (void) s; };
        // try to take a temporary std::array
        take_a_span(get_an_array());
#endif
    }
}

TEST(multi_span_test, from_container_constructor)
{
    std::vector<int> v = {1, 2, 3};
    const std::vector<int> cv = v;

    {
        multi_span<int> s{v};
        EXPECT_TRUE(s.size() ==  narrow_cast<std::ptrdiff_t>(v.size()));
        EXPECT_TRUE(s.data() == v.data());

        multi_span<const int> cs{v};
        EXPECT_TRUE(cs.size() ==  narrow_cast<std::ptrdiff_t>(v.size()));
        EXPECT_TRUE(cs.data() == v.data());
    }

    std::string str = "hello";
    const std::string cstr = "hello";

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<char> s{str};
        EXPECT_TRUE(s.size() ==  narrow_cast<std::ptrdiff_t>(str.size()));
        EXPECT_TRUE(s.data() == str.data());
#endif
        multi_span<const char> cs{str};
        EXPECT_TRUE(cs.size() ==  narrow_cast<std::ptrdiff_t>(str.size()));
        EXPECT_TRUE(cs.data() == str.data());
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        multi_span<char> s{cstr};
#endif
        multi_span<const char> cs{cstr};
        EXPECT_TRUE(cs.size() ==  narrow_cast<std::ptrdiff_t>(cstr.size()));
        EXPECT_TRUE(cs.data() == cstr.data());
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_temp_vector = []() -> std::vector<int> { return {}; };
        auto use_span = [](multi_span<int> s) { (void) s; };
        use_span(get_temp_vector());
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_temp_string = []() -> std::string { return {}; };
        auto use_span = [](multi_span<char> s) { (void) s; };
        use_span(get_temp_string());
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_temp_vector = []() -> const std::vector<int> { return {}; };
        auto use_span = [](multi_span<const char> s) { (void) s; };
        use_span(get_temp_vector());
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        auto get_temp_string = []() -> const std::string { return {}; };
        auto use_span = [](multi_span<const char> s) { (void) s; };
        use_span(get_temp_string());
#endif
    }

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::map<int, int> m;
        multi_span<int> s{m};
#endif
    }
}

TEST(multi_span_test, from_convertible_span_constructor)
{
#ifdef CONFIRM_COMPILATION_ERRORS
    multi_span<int, 7, 4, 2> av1(nullptr, b1);

    std::set_terminate([] {
        std::cerr << "Expected Death. from_convertible_span_constructor";
        std::abort();
    });

    auto f = [&]() { multi_span<int, 7, 4, 2> av1(nullptr); };
    EXPECT_DEATH(f(), deathstring);
#endif

#ifdef CONFIRM_COMPILATION_ERRORS
    static_bounds<std::size_t, 7, dynamic_range, 2> b12(b11);
    b12 = b11;
    b11 = b12;

    multi_span<int, dynamic_range> av1 = nullptr;
    multi_span<int, 7, dynamic_range, 2> av2(av1);
    multi_span<int, 7, 4, 2> av2(av1);
#endif

    multi_span<DerivedClass> avd;
#ifdef CONFIRM_COMPILATION_ERRORS
    multi_span<BaseClass> avb = avd;
#endif
    multi_span<const DerivedClass> avcd = avd;
    (void) avcd;
}

TEST(multi_span_test, copy_move_and_assignment)
{
    multi_span<int> s1;
    EXPECT_TRUE(s1.empty());

    int arr[] = {3, 4, 5};

    multi_span<const int> s2 = arr;
    EXPECT_TRUE(s2.length() ==  3);
    EXPECT_TRUE(s2.data() == &arr[0]);

    s2 = s1;
    EXPECT_TRUE(s2.empty());

    auto get_temp_span = [&]() -> multi_span<int> { return {&arr[1], 2}; };
    auto use_span = [&](multi_span<const int> s) {
        EXPECT_TRUE(s.length() ==  2);
        EXPECT_TRUE(s.data() == &arr[1]);
    };
    use_span(get_temp_span());

    s1 = get_temp_span();
    EXPECT_TRUE(s1.length() ==  2);
    EXPECT_TRUE(s1.data() == &arr[1]);
}

TEST(multi_span_test, as_multi_span_reshape)
{
    int a[3][4][5];
    auto av = as_multi_span(a);
    fn(av.bounds());
    auto av2 = as_multi_span(av, dim<60>());
    auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>());
    auto av4 = as_multi_span(av3, dim<4>(), dim(3), dim<5>());
    auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>());
    auto av6 = as_multi_span(av5, dim<12>(), dim(5));

    fill(av6.begin(), av6.end(), 1);

    auto av7 = as_bytes(av6);

    auto av8 = as_multi_span<int>(av7);

    EXPECT_TRUE(av8.size() == av6.size());
    for (auto i = 0; i < av8.size(); i++) { EXPECT_TRUE(av8[i] == 1); }
}

TEST(multi_span_test, first)
{
    int arr[5] = {1, 2, 3, 4, 5};

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.first<2>().bounds() == static_bounds<2>());
        EXPECT_TRUE(av.first<2>().length() == 2);
        EXPECT_TRUE(av.first(2).length() == 2);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.first<0>().bounds() == static_bounds<0>());
        EXPECT_TRUE(av.first<0>().length() == 0);
        EXPECT_TRUE(av.first(0).length() == 0);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.first<5>().bounds() == static_bounds<5>());
        EXPECT_TRUE(av.first<5>().length() == 5);
        EXPECT_TRUE(av.first(5).length() == 5);
    }

    {
        multi_span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(av.first<6>().bounds() == static_bounds<6>());
        EXPECT_TRUE(av.first<6>().length() == 6);
        EXPECT_TRUE(av.first<-1>().length() == -1);
#endif

        std::set_terminate([] {
            std::cerr << "Expected Death. first";
            std::abort();
        });

        EXPECT_DEATH(av.first(6).length(), deathstring);
    }

    {
        multi_span<int, dynamic_range> av;
        EXPECT_TRUE(av.first<0>().bounds() == static_bounds<0>());
        EXPECT_TRUE(av.first<0>().length() == 0);
        EXPECT_TRUE(av.first(0).length() == 0);
    }
}

TEST(multi_span_test, last)
{
    int arr[5] = {1, 2, 3, 4, 5};

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.last<2>().bounds() == static_bounds<2>());
        EXPECT_TRUE(av.last<2>().length() == 2);
        EXPECT_TRUE(av.last(2).length() == 2);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.last<0>().bounds() == static_bounds<0>());
        EXPECT_TRUE(av.last<0>().length() == 0);
        EXPECT_TRUE(av.last(0).length() == 0);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.last<5>().bounds() == static_bounds<5>());
        EXPECT_TRUE(av.last<5>().length() == 5);
        EXPECT_TRUE(av.last(5).length() == 5);
    }

    {
        multi_span<int, 5> av = arr;
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(av.last<6>().bounds() == static_bounds<6>());
        EXPECT_TRUE(av.last<6>().length() == 6);
#endif

        std::set_terminate([] {
            std::cerr << "Expected Death. last";
            std::abort();
        });

        EXPECT_DEATH(av.last(6).length(), deathstring);
    }

    {
        multi_span<int, dynamic_range> av;
        EXPECT_TRUE(av.last<0>().bounds() == static_bounds<0>());
        EXPECT_TRUE(av.last<0>().length() == 0);
        EXPECT_TRUE(av.last(0).length() == 0);
    }
}

TEST(multi_span_test, subspan)
{
    int arr[5] = {1, 2, 3, 4, 5};

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE((av.subspan<2, 2>().bounds()) == static_bounds<2>());
        EXPECT_TRUE((av.subspan<2, 2>().length()) == 2);
        EXPECT_TRUE(av.subspan(2, 2).length() == 2);
        EXPECT_TRUE(av.subspan(2, 3).length() == 3);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE((av.subspan<0, 0>().bounds()) == static_bounds<0>());
        EXPECT_TRUE((av.subspan<0, 0>().length()) == 0);
        EXPECT_TRUE(av.subspan(0, 0).length() == 0);
    }


    std::set_terminate([] {
        std::cerr << "Expected Death. subspan";
        std::abort();
    });
    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE((av.subspan<0, 5>().bounds()) == static_bounds<5>());
        EXPECT_TRUE((av.subspan<0, 5>().length()) == 5);
        EXPECT_TRUE(av.subspan(0, 5).length() == 5);
        EXPECT_DEATH(av.subspan(0, 6).length(), deathstring);
        EXPECT_DEATH(av.subspan(1, 5).length(), deathstring);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE((av.subspan<5, 0>().bounds()) == static_bounds<0>());
        EXPECT_TRUE((av.subspan<5, 0>().length()) == 0);
        EXPECT_TRUE(av.subspan(5, 0).length() == 0);
        EXPECT_DEATH(av.subspan(6, 0).length(), deathstring);
    }

    {
        multi_span<int, dynamic_range> av;
        EXPECT_TRUE((av.subspan<0, 0>().bounds()) == static_bounds<0>());
        EXPECT_TRUE((av.subspan<0, 0>().length()) == 0);
        EXPECT_TRUE(av.subspan(0, 0).length() == 0);
        EXPECT_DEATH((av.subspan<1, 0>().length()), deathstring);
    }

    {
        multi_span<int> av;
        EXPECT_TRUE(av.subspan(0).length() == 0);
        EXPECT_DEATH(av.subspan(1).length(), deathstring);
    }

    {
        multi_span<int> av = arr;
        EXPECT_TRUE(av.subspan(0).length() == 5);
        EXPECT_TRUE(av.subspan(1).length() == 4);
        EXPECT_TRUE(av.subspan(4).length() == 1);
        EXPECT_TRUE(av.subspan(5).length() == 0);
        // Disabled test instead of fixing since multi_span is deprecated. (PR#835)
#if !(defined(__GNUC__) && __GNUC__ == 8)
        EXPECT_DEATH(av.subspan(6).length(), deathstring);
#endif
        auto av2 = av.subspan(1);
        for (int i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == i + 2);
    }

    {
        multi_span<int, 5> av = arr;
        EXPECT_TRUE(av.subspan(0).length() == 5);
        EXPECT_TRUE(av.subspan(1).length() == 4);
        EXPECT_TRUE(av.subspan(4).length() == 1);
        EXPECT_TRUE(av.subspan(5).length() == 0);
        EXPECT_DEATH(av.subspan(6).length(), deathstring);
        auto av2 = av.subspan(1);
        for (int i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == i + 2);
    }
}

TEST(multi_span_test, rank)
{
    int arr[2] = {1, 2};

    {
        multi_span<int> s;
        EXPECT_TRUE(s.rank() == static_cast<size_t>(1));
    }

    {
        multi_span<int, 2> s = arr;
        EXPECT_TRUE(s.rank() == static_cast<size_t>(1));
    }

    int arr2d[1][1] = {};
    {
        multi_span<int, 1, 1> s = arr2d;
        EXPECT_TRUE(s.rank() == static_cast<size_t>(2));
    }
}

TEST(multi_span_test, extent)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. extent";
        std::abort();
    });

    {
        multi_span<int> s;
        EXPECT_TRUE(s.extent() == 0);
        EXPECT_TRUE(s.extent(0) == 0);
        EXPECT_DEATH(s.extent(1), deathstring);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(s.extent<1>() == 0);
#endif
    }

    {
        multi_span<int, 0> s;
        EXPECT_TRUE(s.extent() == 0);
        EXPECT_TRUE(s.extent(0) == 0);
        EXPECT_DEATH(s.extent(1), deathstring);
    }

    {
        int arr2d[1][2] = {};

        multi_span<int, 1, 2> s = arr2d;
        EXPECT_TRUE(s.extent() == 1);
        EXPECT_TRUE(s.extent<0>() == 1);
        EXPECT_TRUE(s.extent<1>() == 2);
        EXPECT_TRUE(s.extent(0) == 1);
        EXPECT_TRUE(s.extent(1) == 2);
        EXPECT_DEATH(s.extent(3), deathstring);
    }

    {
        int arr2d[1][2] = {};

        multi_span<int, 0, 2> s = arr2d;
        EXPECT_TRUE(s.extent() == 0);
        EXPECT_TRUE(s.extent<0>() == 0);
        EXPECT_TRUE(s.extent<1>() == 2);
        EXPECT_TRUE(s.extent(0) == 0);
        EXPECT_TRUE(s.extent(1) == 2);
        EXPECT_DEATH(s.extent(3), deathstring);
    }
}

TEST(multi_span_test, operator_function_call)
{
    int arr[4] = {1, 2, 3, 4};

    std::set_terminate([] {
        std::cerr << "Expected Death. operator_function_call";
        std::abort();
    });

    {
        multi_span<int> s = arr;
        EXPECT_TRUE(s(0) == 1);
        EXPECT_DEATH(s(5), deathstring);
    }

    int arr2d[2][3] = {1, 2, 3, 4, 5, 6};

    {
        multi_span<int, 2, 3> s = arr2d;
        EXPECT_TRUE(s(0, 0) == 1);
        EXPECT_TRUE(s(0, 1) == 2);
        EXPECT_TRUE(s(1, 2) == 6);
    }

    int arr3d[2][2][2] = {1, 2, 3, 4, 5, 6, 7, 8};

    {
        multi_span<int, 2, 2, 2> s = arr3d;
        EXPECT_TRUE(s(0, 0, 0) == 1);
        EXPECT_TRUE(s(1, 1, 1) == 8);
    }
}

TEST(multi_span_test, comparison_operators)
{
    {
        int arr[10][2];
        auto s1 = as_multi_span(arr);
        multi_span<const int, dynamic_range, 2> s2 = s1;

        EXPECT_TRUE(s1 == s2);

        multi_span<int, 20> s3 = as_multi_span(s1, dim(20));
        EXPECT_TRUE(s3 == s2);
        EXPECT_TRUE(s3 == s1);
    }
    {
        multi_span<int> s1 = nullptr;
        multi_span<int> s2 = nullptr;
        EXPECT_TRUE(s1 == s2);
        EXPECT_FALSE(s1 != s2);
        EXPECT_FALSE(s1 < s2);
        EXPECT_TRUE(s1 <= s2);
        EXPECT_FALSE(s1 > s2);
        EXPECT_TRUE(s1 >= s2);
        EXPECT_TRUE(s2 == s1);
        EXPECT_FALSE(s2 != s1);
        EXPECT_FALSE(s2 < s1);
        EXPECT_TRUE(s2 <= s1);
        EXPECT_FALSE(s2 > s1);
        EXPECT_TRUE(s2 >= s1);
    }


    {
        int arr[] = {2, 1}; // bigger

        multi_span<int> s1 = nullptr;
        multi_span<int> s2 = arr;

        EXPECT_TRUE(s1 != s2);
        EXPECT_TRUE(s2 != s1);
        EXPECT_FALSE(s1 == s2);
        EXPECT_FALSE(s2 == s1);
        EXPECT_TRUE(s1 < s2);
        EXPECT_FALSE(s2 < s1);
        EXPECT_TRUE(s1 <= s2);
        EXPECT_FALSE(s2 <= s1);
        EXPECT_TRUE(s2 > s1);
        EXPECT_FALSE(s1 > s2);
        EXPECT_TRUE(s2 >= s1);
        EXPECT_FALSE(s1 >= s2);
    }

    {
        int arr1[] = {1, 2};
        int arr2[] = {1, 2};
        multi_span<int> s1 = arr1;
        multi_span<int> s2 = arr2;

        EXPECT_TRUE(s1 == s2);
        EXPECT_FALSE(s1 != s2);
        EXPECT_FALSE(s1 < s2);
        EXPECT_TRUE(s1 <= s2);
        EXPECT_FALSE(s1 > s2);
        EXPECT_TRUE(s1 >= s2);
        EXPECT_TRUE(s2 == s1);
        EXPECT_FALSE(s2 != s1);
        EXPECT_FALSE(s2 < s1);
        EXPECT_TRUE(s2 <= s1);
        EXPECT_FALSE(s2 > s1);
        EXPECT_TRUE(s2 >= s1);
    }

    {
        int arr[] = {1, 2, 3};

        multi_span<int> s1 = {&arr[0], 2}; // shorter
        multi_span<int> s2 = arr;          // longer

        EXPECT_TRUE(s1 != s2);
        EXPECT_TRUE(s2 != s1);
        EXPECT_FALSE(s1 == s2);
        EXPECT_FALSE(s2 == s1);
        EXPECT_TRUE(s1 < s2);
        EXPECT_FALSE(s2 < s1);
        EXPECT_TRUE(s1 <= s2);
        EXPECT_FALSE(s2 <= s1);
        EXPECT_TRUE(s2 > s1);
        EXPECT_FALSE(s1 > s2);
        EXPECT_TRUE(s2 >= s1);
        EXPECT_FALSE(s1 >= s2);
    }

    {
        int arr1[] = {1, 2}; // smaller
        int arr2[] = {2, 1}; // bigger

        multi_span<int> s1 = arr1;
        multi_span<int> s2 = arr2;

        EXPECT_TRUE(s1 != s2);
        EXPECT_TRUE(s2 != s1);
        EXPECT_FALSE(s1 == s2);
        EXPECT_FALSE(s2 == s1);
        EXPECT_TRUE(s1 < s2);
        EXPECT_FALSE(s2 < s1);
        EXPECT_TRUE(s1 <= s2);
        EXPECT_FALSE(s2 <= s1);
        EXPECT_TRUE(s2 > s1);
        EXPECT_FALSE(s1 > s2);
        EXPECT_TRUE(s2 >= s1);
        EXPECT_FALSE(s1 >= s2);
    }
}

TEST(multi_span_test, basics)
{
    auto ptr = as_multi_span(new int[10], 10);
    fill(ptr.begin(), ptr.end(), 99);
    for (int num : ptr) { EXPECT_TRUE(num == 99); }

    delete[] ptr.data();
}

TEST(multi_span_test, bounds_checks)
{
    int arr[10][2];
    auto av = as_multi_span(arr);

    fill(begin(av), end(av), 0);

    av[2][0] = 1;
    av[1][1] = 3;

    std::set_terminate([] {
        std::cerr << "Expected Death. bounds_check";
        std::abort();
    });

    // out of bounds
    EXPECT_DEATH(av[1][3] = 3, deathstring);
    EXPECT_DEATH((av[{1, 3}] = 3), deathstring);

    EXPECT_DEATH(av[10][2], deathstring);
    EXPECT_DEATH((av[{10, 2}]), deathstring);

    EXPECT_DEATH(av[-1][0], deathstring);
    EXPECT_DEATH((av[{-1, 0}]), deathstring);

    EXPECT_DEATH(av[0][-1], deathstring);
    EXPECT_DEATH((av[{0, -1}]), deathstring);
}

TEST(multi_span_test, span_parameter_test)
{
    auto data = new int[4][3][5];

    auto av = as_multi_span(data, 4);

    EXPECT_TRUE(av.size() == 60);

    fill(av.begin(), av.end(), 34);

    int count = 0;
    for_each(av.rbegin(), av.rend(), [&](int val) { count += val; });
    EXPECT_TRUE(count == 34 * 60);
    overloaded_func(av, 34);

    overloaded_func(as_multi_span(av, dim(4), dim(3), dim(5)), 34);

    delete[] data;
}

TEST(multi_span_test, md_access)
{
    auto width = 5, height = 20;

    auto imgSize = width * height;
    auto image_ptr = new int[narrow_cast<std::size_t>(imgSize)][3];

    // size check will be done
    auto image_view =
        as_multi_span(as_multi_span(image_ptr, imgSize), dim(height), dim(width), dim<3>());

    iota(image_view.begin(), image_view.end(), 1);

    int expected = 0;
    for (auto i = 0; i < height; i++)
    {
        for (auto j = 0; j < width; j++)
        {
            EXPECT_TRUE(expected + 1 == image_view[i][j][0]);
            EXPECT_TRUE(expected + 2 == image_view[i][j][1]);
            EXPECT_TRUE(expected + 3 == image_view[i][j][2]);

            auto val = image_view[{i, j, 0}];
            EXPECT_TRUE(expected + 1 == val);
            val = image_view[{i, j, 1}];
            EXPECT_TRUE(expected + 2 == val);
            val = image_view[{i, j, 2}];
            EXPECT_TRUE(expected + 3 == val);

            expected += 3;
        }
    }

    delete[] image_ptr;
}

TEST(multi_span_test, as_multi_span)
{
    {
        int* arr = new int[150];

        auto av = as_multi_span(arr, dim<10>(), dim(3), dim<5>());

        fill(av.begin(), av.end(), 24);
        overloaded_func(av, 24);

        delete[] arr;

        array<int, 15> stdarr{0};
        auto av2 = as_multi_span(stdarr);
        overloaded_func(as_multi_span(av2, dim(1), dim<3>(), dim<5>()), 0);

        string str = "ttttttttttttttt"; // size = 15
        auto t = str.data();
        GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
        (void) t;
        auto av3 = as_multi_span(str);
        overloaded_func(as_multi_span(av3, dim(1), dim<3>(), dim<5>()), 't');
    }

    {
        string str;
        multi_span<char> strspan = as_multi_span(str);
        (void) strspan;
        const string cstr;
        multi_span<const char> cstrspan = as_multi_span(cstr);
        (void) cstrspan;
    }

    {
        int a[3][4][5];
        auto av = as_multi_span(a);
        const int(*b)[4][5];
        b = a;
        auto bv = as_multi_span(b, 3);

        EXPECT_TRUE(av == bv);

        const std::array<double, 3> arr = {0.0, 0.0, 0.0};
        auto cv = as_multi_span(arr);
        (void) cv;

        vector<float> vec(3);
        auto dv = as_multi_span(vec);
        (void) dv;

    #ifdef CONFIRM_COMPILATION_ERRORS
        auto dv2 = as_multi_span(std::move(vec));
    #endif

    }
}

TEST(multi_span_test, empty_spans)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. empty_spans";
        std::abort();
    });

    {
        multi_span<int, 0> empty_av(nullptr);

        EXPECT_TRUE(empty_av.bounds().index_bounds() == multi_span_index<1>{0});
        EXPECT_DEATH(empty_av[0], deathstring);
        EXPECT_DEATH(empty_av.begin()[0], deathstring);
        EXPECT_DEATH(empty_av.cbegin()[0], deathstring);
        for (auto& v : empty_av)
        {
            (void) v;
            EXPECT_TRUE(false);
        }
    }

    {
        multi_span<int> empty_av = {};
        EXPECT_TRUE(empty_av.bounds().index_bounds() == multi_span_index<1>{0});
        EXPECT_DEATH(empty_av[0], deathstring);
        EXPECT_DEATH(empty_av.begin()[0], deathstring);
        EXPECT_DEATH(empty_av.cbegin()[0], deathstring);
        for (auto& v : empty_av)
        {
            (void) v;
            EXPECT_TRUE(false);
        }
    }
}

TEST(multi_span_test, index_constructor)
{
    auto arr = new int[8];
    for (int i = 0; i < 4; ++i)
    {
        arr[2 * i] = 4 + i;
        arr[2 * i + 1] = i;
    }

    multi_span<int, dynamic_range> av(arr, 8);

    ptrdiff_t a[1] = {0};
    multi_span_index<1> i = a;

    EXPECT_TRUE(av[i] == 4);

    auto av2 = as_multi_span(av, dim<4>(), dim(2));
    ptrdiff_t a2[2] = {0, 1};
    multi_span_index<2> i2 = a2;

    EXPECT_TRUE(av2[i2] == 0);
    EXPECT_TRUE(av2[0][i] == 4);

    delete[] arr;
}

TEST(multi_span_test, index_constructors)
{
    {
        // components of the same type
        multi_span_index<3> i1(0, 1, 2);
        EXPECT_TRUE(i1[0] == 0);

        // components of different types
        std::size_t c0 = 0;
        std::size_t c1 = 1;
        multi_span_index<3> i2(c0, c1, 2);
        EXPECT_TRUE(i2[0] == 0);

        // from array
        multi_span_index<3> i3 = {0, 1, 2};
        EXPECT_TRUE(i3[0] == 0);

        // from other index of the same size type
        multi_span_index<3> i4 = i3;
        EXPECT_TRUE(i4[0] == 0);

        // default
        multi_span_index<3> i7;
        EXPECT_TRUE(i7[0] == 0);

        // default
        multi_span_index<3> i9 = {};
        EXPECT_TRUE(i9[0] == 0);
    }

    {
        // components of the same type
        multi_span_index<1> i1(0);
        EXPECT_TRUE(i1[0] == 0);

        // components of different types
        std::size_t c0 = 0;
        multi_span_index<1> i2(c0);
        EXPECT_TRUE(i2[0] == 0);

        // from array
        multi_span_index<1> i3 = {0};
        EXPECT_TRUE(i3[0] == 0);

        // from int
        multi_span_index<1> i4 = 0;
        EXPECT_TRUE(i4[0] == 0);

        // from other index of the same size type
        multi_span_index<1> i5 = i3;
        EXPECT_TRUE(i5[0] == 0);

        // default
        multi_span_index<1> i8;
        EXPECT_TRUE(i8[0] == 0);

        // default
        multi_span_index<1> i9 = {};
        EXPECT_TRUE(i9[0] == 0);
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        multi_span_index<3> i1(0, 1);
        multi_span_index<3> i2(0, 1, 2, 3);
        multi_span_index<3> i3 = {0};
        multi_span_index<3> i4 = {0, 1, 2, 3};
        multi_span_index<1> i5 = {0, 1};
    }
#endif
}

TEST(multi_span_test, index_operations)
{
    ptrdiff_t a[3] = {0, 1, 2};
    ptrdiff_t b[3] = {3, 4, 5};
    multi_span_index<3> i = a;
    multi_span_index<3> j = b;

    EXPECT_TRUE(i[0] == 0);
    EXPECT_TRUE(i[1] == 1);
    EXPECT_TRUE(i[2] == 2);

    {
        multi_span_index<3> k = i + j;

        EXPECT_TRUE(i[0] == 0);
        EXPECT_TRUE(i[1] == 1);
        EXPECT_TRUE(i[2] == 2);
        EXPECT_TRUE(k[0] == 3);
        EXPECT_TRUE(k[1] == 5);
        EXPECT_TRUE(k[2] == 7);
    }

    {
        multi_span_index<3> k = i * 3;

        EXPECT_TRUE(i[0] == 0);
        EXPECT_TRUE(i[1] == 1);
        EXPECT_TRUE(i[2] == 2);
        EXPECT_TRUE(k[0] == 0);
        EXPECT_TRUE(k[1] == 3);
        EXPECT_TRUE(k[2] == 6);
    }

    {
        multi_span_index<3> k = 3 * i;

        EXPECT_TRUE(i[0] == 0);
        EXPECT_TRUE(i[1] == 1);
        EXPECT_TRUE(i[2] == 2);
        EXPECT_TRUE(k[0] == 0);
        EXPECT_TRUE(k[1] == 3);
        EXPECT_TRUE(k[2] == 6);
    }

    {
        multi_span_index<2> k = details::shift_left(i);

        EXPECT_TRUE(i[0] == 0);
        EXPECT_TRUE(i[1] == 1);
        EXPECT_TRUE(i[2] == 2);
        EXPECT_TRUE(k[0] == 1);
        EXPECT_TRUE(k[1] == 2);
    }
}

TEST(multi_span_test, span_section_iteration)
{
    int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}};

    // static bounds
    {
        multi_span<int, 4, 2> av = arr;
        iterate_second_column(av);
    }
    // first bound is dynamic
    {
        multi_span<int, dynamic_range, 2> av = arr;
        iterate_second_column(av);
    }
    // second bound is dynamic
    {
        multi_span<int, 4, dynamic_range> av = arr;
        iterate_second_column(av);
    }
    // both bounds are dynamic
    {
        multi_span<int, dynamic_range, dynamic_range> av = arr;
        iterate_second_column(av);
    }
}

TEST(multi_span_test, dynamic_span_section_iteration)
{
    auto height = 4, width = 2;
    auto size = height * width;

    auto arr = new int[narrow_cast<std::size_t>(size)];
    for (auto i = 0; i < size; ++i) { arr[i] = i; }

    auto av = as_multi_span(arr, size);

    // first bound is dynamic
    {
        multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim(height), dim(width));
        iterate_second_column(av2);
    }
    // second bound is dynamic
    {
        multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim(height), dim(width));
        iterate_second_column(av2);
    }
    // both bounds are dynamic
    {
        multi_span<int, dynamic_range, dynamic_range> av2 =
            as_multi_span(av, dim(height), dim(width));
        iterate_second_column(av2);
    }

    delete[] arr;
}

TEST(multi_span_test, span_structure_size)
{
    double(*arr)[3][4] = new double[100][3][4];
    multi_span<double, dynamic_range, 3, 4> av1(arr, 10);

    struct EffectiveStructure
    {
        double* v1;
        ptrdiff_t v2;
    };
    EXPECT_TRUE(sizeof(av1) == sizeof(EffectiveStructure));

    std::set_terminate([] {
        std::cerr << "Expected Death. span_structure_size";
        std::abort();
    });

    EXPECT_DEATH(av1[10][3][4], deathstring);

    multi_span<const double, dynamic_range, 6, 4> av2 =
        as_multi_span(av1, dim(5), dim<6>(), dim<4>());
    (void) av2;

    delete[] arr;
}

TEST(multi_span_test, fixed_size_conversions)
{
    int arr[] = {1, 2, 3, 4};

    // converting to an multi_span from an equal size array is ok
    multi_span<int, 4> av4 = arr;
    EXPECT_TRUE(av4.length() == 4);

    // converting to dynamic_range a_v is always ok
    {
        multi_span<int, dynamic_range> av = av4;
        (void) av;
    }
    {
        multi_span<int, dynamic_range> av = arr;
        (void) av;
    }

// initialization or assignment to static multi_span that REDUCES size is NOT ok
#ifdef CONFIRM_COMPILATION_ERRORS
    {
        multi_span<int, 2> av2 = arr;
    }
    {
        multi_span<int, 2> av2 = av4;
    }
#endif

    {
        multi_span<int, dynamic_range> av = arr;
        multi_span<int, 2> av2 = av;
        (void) av2;
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        multi_span<int, dynamic_range> av = arr;
        multi_span<int, 2, 1> av2 = av.as_multi_span(dim<2>(), dim<2>());
    }
#endif

    {
        multi_span<int, dynamic_range> av = arr;
        multi_span<int, 2, 1> av2 = as_multi_span(av, dim(2), dim(2));
        auto workaround_macro = [&]() { return av2[{1, 0}] == 2; };
        EXPECT_TRUE(workaround_macro());
    }

    // but doing so explicitly is ok

    // you can convert statically
    {
        multi_span<int, 2> av2 = {arr, 2};
        (void) av2;
    }
    {
        multi_span<int, 1> av2 = av4.first<1>();
        (void) av2;
    }

    // ...or dynamically
    {
        // NB: implicit conversion to multi_span<int,2> from multi_span<int,dynamic_range>
        multi_span<int, 1> av2 = av4.first(1);
        (void) av2;
    }

    // initialization or assignment to static multi_span that requires size INCREASE is not ok.
    int arr2[2] = {1, 2};

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        multi_span<int, 4> av4 = arr2;
    }
    {
        multi_span<int, 2> av2 = arr2;
        multi_span<int, 4> av4 = av2;
    }
#endif

    std::set_terminate([] {
        std::cerr << "Expected Death. fixed_size_conversions";
        std::abort();
    });

    {
        auto f = [&]() {
            const multi_span<int, 4> av9 = {arr2, 2};
            (void) av9;
        };
        EXPECT_DEATH(f(), deathstring);
    }

    // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one
    multi_span<int, dynamic_range> av = arr2;
    auto f = [&]() {
        const multi_span<int, 4> av2 = av;
        (void) av2;
    };
    EXPECT_DEATH(f(), deathstring);
}

TEST(multi_span_test, as_writeable_bytes)
{
    int a[] = {1, 2, 3, 4};

    {
#ifdef CONFIRM_COMPILATION_ERRORS
        // you should not be able to get writeable bytes for const objects
        multi_span<const int, dynamic_range> av = a;
        auto wav = av.as_writeable_bytes();
#endif
    }

    {
        multi_span<int, dynamic_range> av;
        auto wav = as_writeable_bytes(av);
        EXPECT_TRUE(wav.length() == av.length());
        EXPECT_TRUE(wav.length() == 0);
        EXPECT_TRUE(wav.size_bytes() == 0);
    }

    {
        multi_span<int, dynamic_range> av = a;
        auto wav = as_writeable_bytes(av);
        EXPECT_TRUE(wav.data() == reinterpret_cast<byte*>(&a[0]));
        EXPECT_TRUE(static_cast<std::size_t>(wav.length()) == sizeof(a));
    }
}

TEST(multi_span_test, iterator)
{
    int a[] = {1, 2, 3, 4};

    {
        multi_span<int, dynamic_range> av = a;
        auto wav = as_writeable_bytes(av);
        for (auto& b : wav) {
#if defined(__cplusplus) && (__cplusplus >= 201703L)
            b = byte{0};
#else
            GSL_SUPPRESS(es.49)
            b = byte(0);
#endif
        }

        for (std::size_t i = 0; i < 4; ++i) {
            EXPECT_TRUE(a[i] == 0);
        }
    }

    {
        multi_span<int, dynamic_range> av = a;
        for (auto& n : av) {
            n = 1;
        }
        for (std::size_t i = 0; i < 4; ++i) {
            EXPECT_TRUE(a[i] == 1);
        }
    }
}

#ifdef CONFIRM_COMPILATION_ERRORS
copy(src_span_static, dst_span_static);
#endif


================================================
FILE: examples/libraries/GSL/tests/no_exception_ensure_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <cstdlib>  // for std::exit
#include <gsl/span> // for span

int operator_subscript_no_throw() noexcept
{
    int arr[10];
    const gsl::span<int> sp{arr};
    return sp[11];
}

[[noreturn]] void test_terminate() { std::exit(0); }

void setup_termination_handler() noexcept
{
#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)

    auto& handler = gsl::details::get_terminate_handler();
    handler = &test_terminate;

#else

    std::set_terminate(test_terminate);

#endif
}

int main() noexcept
{
    setup_termination_handler();
    operator_subscript_no_throw();
    return -1;
}


================================================
FILE: examples/libraries/GSL/tests/notnull_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/pointers> // for not_null, operator<, operator<=, operator>

#include <algorithm> // for addressof
#include <memory>    // for shared_ptr, make_shared, operator<, opera...
#include <sstream>   // for operator<<, ostringstream, basic_ostream:...
#include <stdint.h>  // for uint16_t
#include <string>    // for basic_string, operator==, string, operator<<
#include <typeinfo>  // for type_info

using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";
} //namespace

struct MyBase
{
};
struct MyDerived : public MyBase
{
};
struct Unrelated
{
};

// stand-in for a user-defined ref-counted class
template <typename T>
struct RefCounted
{
    RefCounted(T* p) : p_(p) {}
    operator T*() { return p_; }
    T* p_;
};

// user defined smart pointer with comparison operators returning non bool value
template <typename T>
struct CustomPtr
{
    CustomPtr(T* p) : p_(p) {}
    operator T*() { return p_; }
    bool operator!=(std::nullptr_t) const { return p_ != nullptr; }
    T* p_ = nullptr;
};

template <typename T, typename U>
std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) == reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
}

template <typename T, typename U>
std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) != reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
}

template <typename T, typename U>
std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) < reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                         : "false";
}

template <typename T, typename U>
std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) > reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                         : "false";
}

template <typename T, typename U>
std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) <= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
}

template <typename T, typename U>
std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
{
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
    return reinterpret_cast<const void*>(lhs.p_) >= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
}

struct NonCopyableNonMovable
{
    NonCopyableNonMovable() = default;
    NonCopyableNonMovable(const NonCopyableNonMovable&) = delete;
    NonCopyableNonMovable& operator=(const NonCopyableNonMovable&) = delete;
    NonCopyableNonMovable(NonCopyableNonMovable&&) = delete;
    NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
};

GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
bool helper(not_null<int*> p) { return *p == 12; }
GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
bool helper_const(not_null<const int*> p) { return *p == 12; }

int* return_pointer() { return nullptr; }

TEST(notnull_tests, TestNotNullConstructors)
{
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        not_null<int*> p = nullptr;          // yay...does not compile!
        not_null<std::vector<char>*> p1 = 0; // yay...does not compile!
        not_null<int*> p2;                   // yay...does not compile!
        std::unique_ptr<int> up = std::make_unique<int>(120);
        not_null<int*> p3 = up;

        // Forbid non-nullptr assignable types
        not_null<std::vector<int>> f(std::vector<int>{1});
        not_null<int> z(10);
        not_null<std::vector<int>> y({1, 2});
#endif
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. TestNotNullConstructors";
        std::abort();
    });
    {
        // from shared pointer
        int i = 12;
        auto rp = RefCounted<int>(&i);
        not_null<int*> p(rp);
        EXPECT_TRUE(p.get() == &i);

        not_null<std::shared_ptr<int>> x(
            std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable

        int* pi = nullptr;
        EXPECT_DEATH((not_null<decltype(pi)>(pi)), deathstring);
    }

    {
        // from pointer to local
        int t = 42;

        not_null<int*> x = &t;
        helper(&t);
        helper_const(&t);

        EXPECT_TRUE(*x == 42);
    }

    {
        // from raw pointer
        // from not_null pointer

        int t = 42;
        int* p = &t;

        not_null<int*> x = p;
        helper(p);
        helper_const(p);
        helper(x);
        helper_const(x);

        EXPECT_TRUE(*x == 42);
    }

    {
        // from raw const pointer
        // from not_null const pointer

        int t = 42;
        const int* cp = &t;

        not_null<const int*> x = cp;
        helper_const(cp);
        helper_const(x);

        EXPECT_TRUE(*x == 42);
    }

    {
        // from not_null const pointer, using auto
        int t = 42;
        const int* cp = &t;

        auto x = not_null<const int*>{cp};

        EXPECT_TRUE(*x == 42);
    }

    {
        // from returned pointer

        EXPECT_DEATH(helper(return_pointer()), deathstring);
        EXPECT_DEATH(helper_const(return_pointer()), deathstring);
    }
}

template <typename T>
void ostream_helper(T v)
{
    not_null<T*> p(&v);
    {
        std::ostringstream os;
        std::ostringstream ref;
        os << static_cast<void*>(p);
        ref << static_cast<void*>(&v);
        EXPECT_TRUE(os.str() == ref.str());
    }
    {
        std::ostringstream os;
        std::ostringstream ref;
        os << *p;
        ref << v;
        EXPECT_TRUE(os.str() == ref.str());
    }
}

TEST(notnull_tests, TestNotNullostream)
{
    ostream_helper<int>(17);
    ostream_helper<float>(21.5f);
    ostream_helper<double>(3.4566e-7);
    ostream_helper<char>('c');
    ostream_helper<uint16_t>(0x0123u);
    ostream_helper<const char*>("cstring");
    ostream_helper<std::string>("string");
}

TEST(notnull_tests, TestNotNullCasting)
{
    MyBase base;
    MyDerived derived;
    Unrelated unrelated;
    not_null<Unrelated*> u{&unrelated};
    (void) u;
    not_null<MyDerived*> p{&derived};
    not_null<MyBase*> q(&base);
    q = p; // allowed with heterogeneous copy ctor
    EXPECT_TRUE(q == p);

#ifdef CONFIRM_COMPILATION_ERRORS
    q = u; // no viable conversion possible between MyBase* and Unrelated*
    p = q; // not possible to implicitly convert MyBase* to MyDerived*

    not_null<Unrelated*> r = p;
    not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
#endif
    not_null<Unrelated*> t(reinterpret_cast<Unrelated*>(p.get()));
    EXPECT_TRUE(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
}

TEST(notnull_tests, TestNotNullAssignment)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. TestNotNullAssignmentd";
        std::abort();
    });

    int i = 12;
    not_null<int*> p(&i);
    EXPECT_TRUE(helper(p));

    int* q = nullptr;
    EXPECT_DEATH(p = not_null<int*>(q), deathstring);
}

TEST(notnull_tests, TestNotNullRawPointerComparison)
{
    int ints[2] = {42, 43};
    int* p1 = &ints[0];
    const int* p2 = &ints[1];

    using NotNull1 = not_null<decltype(p1)>;
    using NotNull2 = not_null<decltype(p2)>;

    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == true);
    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == false);

    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == false);
    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == true);

    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == false);
    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));

    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == false);
    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));

    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == true);
    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
}

TEST(notnull_tests, TestNotNullDereferenceOperator)
{
    {
        auto sp1 = std::make_shared<NonCopyableNonMovable>();

        using NotNullSp1 = not_null<decltype(sp1)>;
        EXPECT_TRUE(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
        EXPECT_TRUE(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
    }

    {
        int ints[1] = {42};
        CustomPtr<int> p1(&ints[0]);

        using NotNull1 = not_null<decltype(p1)>;
        EXPECT_TRUE(typeid(*NotNull1(p1)) == typeid(*p1));
        EXPECT_TRUE(*NotNull1(p1) == 42);
        *NotNull1(p1) = 43;
        EXPECT_TRUE(ints[0] == 43);
    }

    {
        int v = 42;
        gsl::not_null<int*> p(&v);
        EXPECT_TRUE(typeid(*p) == typeid(*(&v)));
        *p = 43;
        EXPECT_TRUE(v == 43);
    }
}

TEST(notnull_tests, TestNotNullSharedPtrComparison)
{
    auto sp1 = std::make_shared<int>(42);
    auto sp2 = std::make_shared<const int>(43);

    using NotNullSp1 = not_null<decltype(sp1)>;
    using NotNullSp2 = not_null<decltype(sp2)>;

    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);

    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);

    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
    EXPECT_TRUE((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));

    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
    EXPECT_TRUE((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));

    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
    EXPECT_TRUE((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));

    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
    EXPECT_TRUE((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
}

TEST(notnull_tests, TestNotNullCustomPtrComparison)
{
    int ints[2] = {42, 43};
    CustomPtr<int> p1(&ints[0]);
    CustomPtr<const int> p2(&ints[1]);

    using NotNull1 = not_null<decltype(p1)>;
    using NotNull2 = not_null<decltype(p2)>;

    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == "true");
    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == "false");

    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == "false");
    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == "true");

    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == "false");
    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));

    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == "false");
    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));

    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == "true");
    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));

    EXPECT_TRUE((NotNull1(p1) >= NotNull1(p1)) == "true");
    EXPECT_TRUE((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
    EXPECT_TRUE((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
}

#if defined(__cplusplus) && (__cplusplus >= 201703L)

TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
{
    {
        int i = 42;

        not_null x{&i};
        helper(not_null{&i});
        helper_const(not_null{&i});

        EXPECT_TRUE(*x == 42);
    }

    {
        int i = 42;
        int* p = &i;

        not_null x{p};
        helper(not_null{p});
        helper_const(not_null{p});

        EXPECT_TRUE(*x == 42);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
        std::abort();
    });

    {
        auto workaround_macro = []() {
            int* p1 = nullptr;
            const not_null x{p1};
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        auto workaround_macro = []() {
            const int* p1 = nullptr;
            const not_null x{p1};
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;

        EXPECT_DEATH(helper(not_null{p}), deathstring);
        EXPECT_DEATH(helper_const(not_null{p}), deathstring);
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        not_null x{nullptr};
        helper(not_null{nullptr});
        helper_const(not_null{nullptr});
    }
#endif
}
#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)

TEST(notnull_tests, TestMakeNotNull)
{
    {
        int i = 42;

        const auto x = make_not_null(&i);
        helper(make_not_null(&i));
        helper_const(make_not_null(&i));

        EXPECT_TRUE(*x == 42);
    }

    {
        int i = 42;
        int* p = &i;

        const auto x = make_not_null(p);
        helper(make_not_null(p));
        helper_const(make_not_null(p));

        EXPECT_TRUE(*x == 42);
    }

    std::set_terminate([] {
        std::cerr << "Expected Death. TestMakeNotNull";
        std::abort();
    });

    {
        const auto workaround_macro = []() {
            int* p1 = nullptr;
            const auto x = make_not_null(p1);
            EXPECT_TRUE(*x == 42);
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        const auto workaround_macro = []() {
            const int* p1 = nullptr;
            const auto x = make_not_null(p1);
            EXPECT_TRUE(*x == 42);
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;

        EXPECT_DEATH(helper(make_not_null(p)), deathstring);
        EXPECT_DEATH(helper_const(make_not_null(p)), deathstring);
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        EXPECT_DEATH(make_not_null(nullptr), deathstring);
        EXPECT_DEATH(helper(make_not_null(nullptr)), deathstring);
        EXPECT_DEATH(helper_const(make_not_null(nullptr)), deathstring);
    }
#endif
}


================================================
FILE: examples/libraries/GSL/tests/owner_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/pointers> // for owner

using namespace gsl;

GSL_SUPPRESS(f.23) // NO-FORMAT: attribute
void f(int* i) { *i += 1; }

TEST(owner_tests, basic_test)
{
    owner<int*> p = new int(120);
    EXPECT_TRUE(*p == 120);
    f(p);
    EXPECT_TRUE(*p == 121);
    delete p;
}

TEST(owner_tests, check_pointer_constraint)
{
    #ifdef CONFIRM_COMPILATION_ERRORS
    {
        owner<int> integerTest = 10;
        owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
    }
    #endif
}


================================================
FILE: examples/libraries/GSL/tests/span_compatibility_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_byte> // for byte
#include <gsl/span>     // for span, span_iterator, operator==, operator!=

#include <array>       // for array
#include <cstddef>     // for ptrdiff_t
#include <iterator>    // for reverse_iterator, operator-, operator==
#include <type_traits> // for integral_constant<>::value, is_default_co...
#include <utility>
#include <vector> // for vector

using namespace std;
using namespace gsl;

// Below are tests that verify the gsl interface support the same things as the std
// Ranges and Concepts support need to be added later.

struct Base
{
};
struct Derived : Base
{
};
static_assert(std::is_convertible<Derived*, Base*>::value, "std::is_convertible<Derived*, Base*>");
static_assert(!std::is_convertible<Derived (*)[], Base (*)[]>::value,
              "!std::is_convertible<Derived(*)[], Base(*)[]>");

// int*(*) [], int const* const(*)[] was identified as an issue in CWG330 and the resolution was
// provided with N4261.
template <class T = int>
void ArrayConvertibilityCheck()
{
#if __cplusplus >= 201703l
    if constexpr (std::is_convertible<T*(*) [], T const* const(*)[]>::value)
    {
        std::array<T*, 3> stl_nullptr{{nullptr, nullptr, nullptr}};
        gsl::span<const T* const> sp_const_nullptr_1{stl_nullptr};
        EXPECT_TRUE(sp_const_nullptr_1.data() == stl_nullptr.data());
        EXPECT_TRUE(sp_const_nullptr_1.size() == 3);

        span<const T* const> sp_const_nullptr_2{std::as_const(stl_nullptr)};
        EXPECT_TRUE(sp_const_nullptr_2.data() == stl_nullptr.data());
        EXPECT_TRUE(sp_const_nullptr_2.size() == 3);

        static_assert(std::is_same<decltype(span{stl_nullptr}), span<T*, 3>>::value,
                      "std::is_same< decltype(span{stl_nullptr}), span<T*, 3>>::value");
        static_assert(
            std::is_same<decltype(span{std::as_const(stl_nullptr)}), span<T* const, 3>>::value,
            "std::is_same< decltype(span{std::as_const(stl_nullptr)}), span<T* const, "
            "3>>::value");
    }
#endif
}

TEST(span_compatibility_tests, assertion_tests)
{
    int arr[3]{10, 20, 30};
    std::array<int, 3> stl{{100, 200, 300}};

    ArrayConvertibilityCheck();

    {
        gsl::span<int> sp_dyn;
        EXPECT_TRUE(sp_dyn.data() == nullptr);
        EXPECT_TRUE(sp_dyn.size() == 0);
        EXPECT_TRUE(sp_dyn.empty());
    }
    {
        gsl::span<int, 0> sp_zero;
        EXPECT_TRUE(sp_zero.data() == nullptr);
        EXPECT_TRUE(sp_zero.size() == 0);
        EXPECT_TRUE(sp_zero.empty());

        gsl::span<int> sp_dyn_a(arr, 3);
        gsl::span<int> sp_dyn_b(begin(arr), 3);
        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_dyn_b.data() == std::begin(arr));
        EXPECT_TRUE(sp_dyn_a.size() == 3);
        EXPECT_TRUE(sp_dyn_b.size() == 3);

        gsl::span<int, 3> sp_three_a(arr, 3);
        gsl::span<int, 3> sp_three_b(begin(arr), 3);
        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_three_b.data() == std::begin(arr));
        EXPECT_TRUE(sp_three_a.size() == 3);
        EXPECT_TRUE(sp_three_b.size() == 3);

        gsl::span<const int> sp_const_a(arr, 3);
        gsl::span<const int> sp_const_b(begin(arr), 3);
        EXPECT_TRUE(sp_const_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_b.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_a.size() == 3);
        EXPECT_TRUE(sp_const_b.size() == 3);

#if __cplusplus >= 201703l
        gsl::span<const int> sp_const_c(std::as_const(arr), 3);
        EXPECT_TRUE(sp_const_c.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_c.size() == 3);
#endif // __cplusplus >= 201703l

        gsl::span<const int> sp_const_d(cbegin(arr), 3);
        EXPECT_TRUE(sp_const_d.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_d.size() == 3);
    }
    {
        gsl::span<int> sp_dyn_a(begin(arr), std::end(arr));
        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_dyn_a.size() == 3);

        gsl::span<int, 3> sp_three_a(begin(arr), std::end(arr));
        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_three_a.size() == 3);

        gsl::span<const int> sp_const_a(begin(arr), std::end(arr));
        gsl::span<const int> sp_const_b(begin(arr), std::cend(arr));
        gsl::span<const int> sp_const_c(cbegin(arr), std::end(arr));
        gsl::span<const int> sp_const_d(cbegin(arr), std::cend(arr));
        EXPECT_TRUE(sp_const_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_b.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_c.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_d.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_a.size() == 3);
        EXPECT_TRUE(sp_const_b.size() == 3);
        EXPECT_TRUE(sp_const_c.size() == 3);
        EXPECT_TRUE(sp_const_d.size() == 3);
    }
    {
        gsl::span<int> sp_dyn_a(arr);
        gsl::span<int> sp_dyn_b(stl);
        gsl::span<int> sp_dyn_c{stl};
        gsl::span<const int> sp_dyn_d{stl};
        EXPECT_TRUE(sp_dyn_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_dyn_b.data() == stl.data());
        EXPECT_TRUE(sp_dyn_a.size() == 3);
        EXPECT_TRUE(sp_dyn_b.size() == 3);

        gsl::span<int, 3> sp_three_a(arr);
        gsl::span<int, 3> sp_three_b(stl);
        EXPECT_TRUE(sp_three_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_three_b.data() == stl.data());
        EXPECT_TRUE(sp_three_a.size() == 3);
        EXPECT_TRUE(sp_three_b.size() == 3);

        gsl::span<const int> sp_const_w(arr);
        gsl::span<const int> sp_const_y(stl);
        EXPECT_TRUE(sp_const_w.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_y.data() == stl.data());
        EXPECT_TRUE(sp_const_w.size() == 3);
        EXPECT_TRUE(sp_const_y.size() == 3);

#if __cplusplus >= 201703l
        gsl::span<const int> sp_const_x(std::as_const(arr));
        EXPECT_TRUE(sp_const_x.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_x.size() == 3);

        gsl::span<const int> sp_const_z(std::as_const(stl));
        EXPECT_TRUE(sp_const_z.data() == stl.data());
        EXPECT_TRUE(sp_const_z.size() == 3);
#endif // __cplusplus >= 201703l
    }
    {
        const gsl::span<int> orig_dyn(arr);
        const gsl::span<int, 3> orig_three(arr);
        const gsl::span<const int> orig_const_dyn(arr);
        const gsl::span<const int, 3> orig_const_three(arr);

        gsl::span<int> sp_a(orig_dyn);
        gsl::span<int> sp_b(orig_three);

        gsl::span<int, 3> sp_c(orig_three);

        gsl::span<const int> sp_d(orig_dyn);
        gsl::span<const int> sp_e(orig_three);
        gsl::span<const int> sp_f(orig_const_dyn);
        gsl::span<const int> sp_g(orig_const_three);

        gsl::span<const int, 3> sp_h(orig_three);
        gsl::span<const int, 3> sp_i(orig_const_three);

        EXPECT_TRUE(sp_a.data() == std::begin(arr));
        EXPECT_TRUE(sp_b.data() == std::begin(arr));
        EXPECT_TRUE(sp_c.data() == std::begin(arr));
        EXPECT_TRUE(sp_d.data() == std::begin(arr));
        EXPECT_TRUE(sp_e.data() == std::begin(arr));
        EXPECT_TRUE(sp_f.data() == std::begin(arr));
        EXPECT_TRUE(sp_g.data() == std::begin(arr));
        EXPECT_TRUE(sp_h.data() == std::begin(arr));
        EXPECT_TRUE(sp_i.data() == std::begin(arr));
        EXPECT_TRUE(sp_a.size() == 3);
        EXPECT_TRUE(sp_b.size() == 3);
        EXPECT_TRUE(sp_c.size() == 3);
        EXPECT_TRUE(sp_d.size() == 3);
        EXPECT_TRUE(sp_e.size() == 3);
        EXPECT_TRUE(sp_f.size() == 3);
        EXPECT_TRUE(sp_g.size() == 3);
        EXPECT_TRUE(sp_h.size() == 3);
        EXPECT_TRUE(sp_i.size() == 3);
    }
    {
        gsl::span<int> sp_dyn(arr);
        gsl::span<int, 3> sp_three(arr);
        gsl::span<const int> sp_const_dyn(arr);
        gsl::span<const int, 3> sp_const_three(arr);

        EXPECT_TRUE(sp_dyn.data() == std::begin(arr));
        EXPECT_TRUE(sp_three.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_dyn.data() == std::begin(arr));
        EXPECT_TRUE(sp_const_three.data() == std::begin(arr));
        EXPECT_TRUE(sp_dyn.size() == 3);
        EXPECT_TRUE(sp_three.size() == 3);
        EXPECT_TRUE(sp_const_dyn.size() == 3);
        EXPECT_TRUE(sp_const_three.size() == 3);

        int other[4]{12, 34, 56, 78};

        sp_dyn = gsl::span<int>{other};
        sp_three = gsl::span<int, 3>{stl};
        sp_const_dyn = gsl::span<const int>{other};
        sp_const_three = gsl::span<const int, 3>{stl};

        EXPECT_TRUE(sp_dyn.data() == std::begin(other));
        EXPECT_TRUE(sp_three.data() == stl.data());
        EXPECT_TRUE(sp_const_dyn.data() == std::begin(other));
        EXPECT_TRUE(sp_const_three.data() == stl.data());
        EXPECT_TRUE(sp_dyn.size() == 4);
        EXPECT_TRUE(sp_three.size() == 3);
        EXPECT_TRUE(sp_const_dyn.size() == 4);
        EXPECT_TRUE(sp_const_three.size() == 3);
    }
    {
        gsl::span<int>::iterator it_dyn{};

        {
            gsl::span<int> sp_dyn(arr);
            it_dyn = sp_dyn.begin();
        }

        EXPECT_TRUE(*it_dyn == arr[0]);
        EXPECT_TRUE(it_dyn[2] == arr[2]);

        gsl::span<int, 3>::iterator it_three{};

        {
            gsl::span<int, 3> sp_three(stl);
            it_three = sp_three.begin();
        }

        EXPECT_TRUE(*it_three == stl[0]);
        EXPECT_TRUE(it_three[2] == stl[2]);
    }

    {
        int sequence[9]{10, 20, 30, 40, 50, 60, 70, 80, 90};

        const gsl::span<int> sp_dyn(sequence);
        const gsl::span<int, 9> sp_nine(sequence);

        auto first_3 = sp_dyn.first<3>();
        auto first_4 = sp_nine.first<4>();
        auto first_5 = sp_dyn.first(5);
        auto first_6 = sp_nine.first(6);
        static_assert(noexcept(sp_dyn.first<3>()), "noexcept(sp_dyn.first<3>())");   // strengthened
        static_assert(noexcept(sp_nine.first<4>()), "noexcept(sp_nine.first<4>())"); // strengthened
        static_assert(noexcept(sp_dyn.first(5)), "noexcept(sp_dyn.first(5))");       // strengthened
        static_assert(noexcept(sp_nine.first(6)), "noexcept(sp_nine.first(6))");     // strengthened
        static_assert(is_same<decltype(first_3), gsl::span<int, 3>>::value,
                      "is_same<decltype(first_3), gsl::span<int, 3>>::value");
        static_assert(is_same<decltype(first_4), gsl::span<int, 4>>::value,
                      "is_same<decltype(first_4), gsl::span<int, 4>>::value");
        static_assert(is_same<decltype(first_5), gsl::span<int>>::value,
                      "is_same<decltype(first_5), gsl::span<int>>::value");
        static_assert(is_same<decltype(first_6), gsl::span<int>>::value,
                      "is_same<decltype(first_6), gsl::span<int>>::value");
        EXPECT_TRUE(first_3.data() == std::begin(sequence));
        EXPECT_TRUE(first_4.data() == std::begin(sequence));
        EXPECT_TRUE(first_5.data() == std::begin(sequence));
        EXPECT_TRUE(first_6.data() == std::begin(sequence));
        EXPECT_TRUE(first_3.size() == 3);
        EXPECT_TRUE(first_4.size() == 4);
        EXPECT_TRUE(first_5.size() == 5);
        EXPECT_TRUE(first_6.size() == 6);

        auto last_3 = sp_dyn.last<3>();
        auto last_4 = sp_nine.last<4>();
        auto last_5 = sp_dyn.last(5);
        auto last_6 = sp_nine.last(6);
        static_assert(noexcept(sp_dyn.last<3>()), "noexcept(sp_dyn.last<3>())");   // strengthened
        static_assert(noexcept(sp_nine.last<4>()), "noexcept(sp_nine.last<4>())"); // strengthened
        static_assert(noexcept(sp_dyn.last(5)), "noexcept(sp_dyn.last(5))");       // strengthened
        static_assert(noexcept(sp_nine.last(6)), "noexcept(sp_nine.last(6))");     // strengthened
        static_assert(is_same<decltype(last_3), gsl::span<int, 3>>::value,
                      "is_same<decltype(last_3), gsl::span<int, 3>>::value");
        static_assert(is_same<decltype(last_4), gsl::span<int, 4>>::value,
                      "is_same<decltype(last_4), gsl::span<int, 4>>::value");
        static_assert(is_same<decltype(last_5), gsl::span<int>>::value,
                      "is_same<decltype(last_5), gsl::span<int>>::value");
        static_assert(is_same<decltype(last_6), gsl::span<int>>::value,
                      "is_same<decltype(last_6), gsl::span<int>>::value");
        EXPECT_TRUE(last_3.data() == std::begin(sequence) + 6);
        EXPECT_TRUE(last_4.data() == std::begin(sequence) + 5);
        EXPECT_TRUE(last_5.data() == std::begin(sequence) + 4);
        EXPECT_TRUE(last_6.data() == std::begin(sequence) + 3);
        EXPECT_TRUE(last_3.size() == 3);
        EXPECT_TRUE(last_4.size() == 4);
        EXPECT_TRUE(last_5.size() == 5);
        EXPECT_TRUE(last_6.size() == 6);

        auto offset_3 = sp_dyn.subspan<3>();
        auto offset_4 = sp_nine.subspan<4>();
        auto offset_5 = sp_dyn.subspan(5);
        auto offset_6 = sp_nine.subspan(6);
        static_assert(noexcept(sp_dyn.subspan<3>()),
                      "noexcept(sp_dyn.subspan<3>())"); // strengthened
        static_assert(noexcept(sp_nine.subspan<4>()),
                      "noexcept(sp_nine.subspan<4>())");                             // strengthened
        static_assert(noexcept(sp_dyn.subspan(5)), "noexcept(sp_dyn.subspan(5))");   // strengthened
        static_assert(noexcept(sp_nine.subspan(6)), "noexcept(sp_nine.subspan(6))"); // strengthened
        static_assert(is_same<decltype(offset_3), gsl::span<int>>::value,
                      "is_same<decltype(offset_3), gsl::span<int>>::value");
        static_assert(is_same<decltype(offset_4), gsl::span<int, 5>>::value,
                      "is_same<decltype(offset_4), gsl::span<int, 5>>::value");
        static_assert(is_same<decltype(offset_5), gsl::span<int>>::value,
                      "is_same<decltype(offset_5), gsl::span<int>>::value");
        static_assert(is_same<decltype(offset_6), gsl::span<int>>::value,
                      "is_same<decltype(offset_6), gsl::span<int>>::value");
        EXPECT_TRUE(offset_3.data() == std::begin(sequence) + 3);
        EXPECT_TRUE(offset_4.data() == std::begin(sequence) + 4);
        EXPECT_TRUE(offset_5.data() == std::begin(sequence) + 5);
        EXPECT_TRUE(offset_6.data() == std::begin(sequence) + 6);
        EXPECT_TRUE(offset_3.size() == 6);
        EXPECT_TRUE(offset_4.size() == 5);
        EXPECT_TRUE(offset_5.size() == 4);
        EXPECT_TRUE(offset_6.size() == 3);

        auto subspan_3 = sp_dyn.subspan<3, 2>();
        auto subspan_4 = sp_nine.subspan<4, 2>();
        auto subspan_5 = sp_dyn.subspan(5, 2);
        auto subspan_6 = sp_nine.subspan(6, 2);
        static_assert(noexcept(sp_dyn.subspan<3, 2>()),
                      "noexcept(sp_dyn.subspan<3, 2>())"); // strengthened
        static_assert(noexcept(sp_nine.subspan<4, 2>()),
                      "noexcept(sp_nine.subspan<4, 2>())"); // strengthened
        static_assert(noexcept(sp_dyn.subspan(5, 2)),
                      "noexcept(sp_dyn.subspan(5, 2))"); // strengthened
        static_assert(noexcept(sp_nine.subspan(6, 2)),
                      "noexcept(sp_nine.subspan(6, 2))"); // strengthened
        static_assert(is_same<decltype(subspan_3), gsl::span<int, 2>>::value,
                      "is_same<decltype(subspan_3), gsl::span<int, 2>>::value");
        static_assert(is_same<decltype(subspan_4), gsl::span<int, 2>>::value,
                      "is_same<decltype(subspan_4), gsl::span<int, 2>>::value");
        static_assert(is_same<decltype(subspan_5), gsl::span<int>>::value,
                      "is_same<decltype(subspan_5), gsl::span<int>>::value");
        static_assert(is_same<decltype(subspan_6), gsl::span<int>>::value,
                      "is_same<decltype(subspan_6), gsl::span<int>>::value");
        EXPECT_TRUE(subspan_3.data() == std::begin(sequence) + 3);
        EXPECT_TRUE(subspan_4.data() == std::begin(sequence) + 4);
        EXPECT_TRUE(subspan_5.data() == std::begin(sequence) + 5);
        EXPECT_TRUE(subspan_6.data() == std::begin(sequence) + 6);
        EXPECT_TRUE(subspan_3.size() == 2);
        EXPECT_TRUE(subspan_4.size() == 2);
        EXPECT_TRUE(subspan_5.size() == 2);
        EXPECT_TRUE(subspan_6.size() == 2);

        static_assert(noexcept(sp_dyn.size()), "noexcept(sp_dyn.size())");
        static_assert(noexcept(sp_dyn.size_bytes()), "noexcept(sp_dyn.size_bytes())");
        static_assert(noexcept(sp_dyn.empty()), "noexcept(sp_dyn.empty())");
        static_assert(noexcept(sp_dyn[0]), "noexcept(sp_dyn[0])");           // strengthened
        static_assert(noexcept(sp_dyn.front()), "noexcept(sp_dyn.front())"); // strengthened
        static_assert(noexcept(sp_dyn.back()), "noexcept(sp_dyn.back())");   // strengthened
        static_assert(noexcept(sp_dyn.data()), "noexcept(sp_dyn.data())");
        static_assert(noexcept(sp_dyn.begin()), "noexcept(sp_dyn.begin())");
        static_assert(noexcept(sp_dyn.end()), "noexcept(sp_dyn.end())");
        static_assert(noexcept(sp_dyn.rbegin()), "noexcept(sp_dyn.rbegin())");
        static_assert(noexcept(sp_dyn.rend()), "noexcept(sp_dyn.rend())");

        static_assert(noexcept(sp_nine.size()), "noexcept(sp_nine.size())");
        static_assert(noexcept(sp_nine.size_bytes()), "noexcept(sp_nine.size_bytes())");
        static_assert(noexcept(sp_nine.empty()), "noexcept(sp_nine.empty())");
        static_assert(noexcept(sp_nine[0]), "noexcept(sp_nine[0])");           // strengthened
        static_assert(noexcept(sp_nine.front()), "noexcept(sp_nine.front())"); // strengthened
        static_assert(noexcept(sp_nine.back()), "noexcept(sp_nine.back())");   // strengthened
        static_assert(noexcept(sp_nine.data()), "noexcept(sp_nine.data())");
        static_assert(noexcept(sp_nine.begin()), "noexcept(sp_nine.begin())");
        static_assert(noexcept(sp_nine.end()), "noexcept(sp_nine.end())");
        static_assert(noexcept(sp_nine.rbegin()), "noexcept(sp_nine.rbegin())");
        static_assert(noexcept(sp_nine.rend()), "noexcept(sp_nine.rend())");

        EXPECT_TRUE(sp_dyn.size() == 9);
        EXPECT_TRUE(sp_nine.size() == 9);

        EXPECT_TRUE(sp_dyn.size_bytes() == 9 * sizeof(int));
        EXPECT_TRUE(sp_nine.size_bytes() == 9 * sizeof(int));

        EXPECT_TRUE(!sp_dyn.empty());
        EXPECT_TRUE(!sp_nine.empty());

        EXPECT_TRUE(sp_dyn[0] == 10);
        EXPECT_TRUE(sp_nine[0] == 10);
        EXPECT_TRUE(sp_dyn[8] == 90);
        EXPECT_TRUE(sp_nine[8] == 90);

        EXPECT_TRUE(sp_dyn.front() == 10);
        EXPECT_TRUE(sp_nine.front() == 10);

        EXPECT_TRUE(sp_dyn.back() == 90);
        EXPECT_TRUE(sp_nine.back() == 90);

        EXPECT_TRUE(&sp_dyn.front() == std::begin(sequence));
        EXPECT_TRUE(&sp_nine.front() == std::begin(sequence));
        EXPECT_TRUE(&sp_dyn[4] == std::begin(sequence) + 4);
        EXPECT_TRUE(&sp_nine[4] == std::begin(sequence) + 4);
        EXPECT_TRUE(&sp_dyn.back() == std::begin(sequence) + 8);
        EXPECT_TRUE(&sp_nine.back() == std::begin(sequence) + 8);

        EXPECT_TRUE(sp_dyn.data() == std::begin(sequence));
        EXPECT_TRUE(sp_nine.data() == std::begin(sequence));

        EXPECT_TRUE(*sp_dyn.begin() == 10);
        EXPECT_TRUE(*sp_nine.begin() == 10);

        EXPECT_TRUE(sp_dyn.end()[-2] == 80);
        EXPECT_TRUE(sp_nine.end()[-2] == 80);

        EXPECT_TRUE(*sp_dyn.rbegin() == 90);
        EXPECT_TRUE(*sp_nine.rbegin() == 90);

        EXPECT_TRUE(sp_dyn.rend()[-2] == 20);
        EXPECT_TRUE(sp_nine.rend()[-2] == 20);

        static_assert(is_same<decltype(sp_dyn.begin()), gsl::span<int>::iterator>::value,
                      "is_same<decltype(sp_dyn.begin()), gsl::span<int>::iterator>::value");
        static_assert(is_same<decltype(sp_nine.begin()), gsl::span<int, 9>::iterator>::value,
                      "is_same<decltype(sp_nine.begin()), gsl::span<int, 9>::iterator>::value");
        static_assert(is_same<decltype(sp_dyn.end()), gsl::span<int>::iterator>::value,
                      "is_same<decltype(sp_dyn.end()), gsl::span<int>::iterator>::value");
        static_assert(is_same<decltype(sp_nine.end()), gsl::span<int, 9>::iterator>::value,
                      "is_same<decltype(sp_nine.end()), gsl::span<int, 9>::iterator>::value");
        static_assert(
            is_same<decltype(sp_dyn.rbegin()), gsl::span<int>::reverse_iterator>::value,
            "is_same<decltype(sp_dyn.rbegin()), gsl::span<int>::reverse_iterator>::value");
        static_assert(
            is_same<decltype(sp_nine.rbegin()), gsl::span<int, 9>::reverse_iterator>::value,
            "is_same<decltype(sp_nine.rbegin()), gsl::span<int, 9>::reverse_iterator>::value");
        static_assert(is_same<decltype(sp_dyn.rend()), gsl::span<int>::reverse_iterator>::value,
                      "is_same<decltype(sp_dyn.rend()), gsl::span<int>::reverse_iterator>::value");
        static_assert(
            is_same<decltype(sp_nine.rend()), gsl::span<int, 9>::reverse_iterator>::value,
            "is_same<decltype(sp_nine.rend()), gsl::span<int, 9>::reverse_iterator>::value");
    }
    {
        int sequence[9]{10, 20, 30, 40, 50, 60, 70, 80, 90};

        constexpr size_t SizeBytes = sizeof(sequence);

        const gsl::span<int> sp_dyn(sequence);
        const gsl::span<int, 9> sp_nine(sequence);
        const gsl::span<const int> sp_const_dyn(sequence);
        const gsl::span<const int, 9> sp_const_nine(sequence);

        static_assert(noexcept(as_bytes(sp_dyn)), "noexcept(as_bytes(sp_dyn))");
        static_assert(noexcept(as_bytes(sp_nine)), "noexcept(as_bytes(sp_nine))");
        static_assert(noexcept(as_bytes(sp_const_dyn)), "noexcept(as_bytes(sp_const_dyn))");
        static_assert(noexcept(as_bytes(sp_const_nine)), "noexcept(as_bytes(sp_const_nine))");
        static_assert(noexcept(as_writable_bytes(sp_dyn)), "noexcept(as_writable_bytes(sp_dyn))");
        static_assert(noexcept(as_writable_bytes(sp_nine)), "noexcept(as_writable_bytes(sp_nine))");

        auto sp_1 = as_bytes(sp_dyn);
        auto sp_2 = as_bytes(sp_nine);
        auto sp_3 = as_bytes(sp_const_dyn);
        auto sp_4 = as_bytes(sp_const_nine);
        auto sp_5 = as_writable_bytes(sp_dyn);
        auto sp_6 = as_writable_bytes(sp_nine);

        static_assert(is_same<decltype(sp_1), gsl::span<const byte>>::value,
                      "is_same<decltype(sp_1), gsl::span<const byte>>::value");
        static_assert(is_same<decltype(sp_2), gsl::span<const byte, SizeBytes>>::value,
                      "is_same<decltype(sp_2), gsl::span<const byte, SizeBytes>>::value");
        static_assert(is_same<decltype(sp_3), gsl::span<const byte>>::value,
                      "is_same<decltype(sp_3), gsl::span<const byte>>::value");
        static_assert(is_same<decltype(sp_4), gsl::span<const byte, SizeBytes>>::value,
                      "is_same<decltype(sp_4), gsl::span<const byte, SizeBytes>>::value");
        static_assert(is_same<decltype(sp_5), gsl::span<byte>>::value,
                      "is_same<decltype(sp_5), gsl::span<byte>>::value");
        static_assert(is_same<decltype(sp_6), gsl::span<byte, SizeBytes>>::value,
                      "is_same<decltype(sp_6), gsl::span<byte, SizeBytes>>::value");

        EXPECT_TRUE(sp_1.data() == reinterpret_cast<const byte*>(begin(sequence)));
        EXPECT_TRUE(sp_2.data() == reinterpret_cast<const byte*>(begin(sequence)));
        EXPECT_TRUE(sp_3.data() == reinterpret_cast<const byte*>(begin(sequence)));
        EXPECT_TRUE(sp_4.data() == reinterpret_cast<const byte*>(begin(sequence)));
        EXPECT_TRUE(sp_5.data() == reinterpret_cast<byte*>(begin(sequence)));
        EXPECT_TRUE(sp_6.data() == reinterpret_cast<byte*>(begin(sequence)));

        EXPECT_TRUE(sp_1.size() == SizeBytes);
        EXPECT_TRUE(sp_2.size() == SizeBytes);
        EXPECT_TRUE(sp_3.size() == SizeBytes);
        EXPECT_TRUE(sp_4.size() == SizeBytes);
        EXPECT_TRUE(sp_5.size() == SizeBytes);
        EXPECT_TRUE(sp_6.size() == SizeBytes);
    }
}

// assertions for span's definition
static_assert(std::is_same<decltype(gsl::dynamic_extent), const std::size_t>::value,
              "gsl::dynamic_extent must be respresented as std::size_t");
static_assert(gsl::dynamic_extent == static_cast<std::size_t>(-1),
              "gsl::dynamic_extent must be defined as the max value of std::size_t");

static_assert(std::is_same<decltype(gsl::span<int>::extent), const std::size_t>::value,
              "Ensure that the type of  gsl::span::extent is std::size_t");
static_assert(gsl::span<int>::extent == gsl::dynamic_extent,
              "gsl::span<int>::extent should be equivalent to gsl::dynamic_extent");

static_assert(std::is_same<decltype(gsl::span<int, 3>::extent), const std::size_t>::value,
              "Ensure that the type of gsl::span::extent is std::size_t");
static_assert(gsl::span<int, 3>::extent == 3, "Ensure that span<int, 3>::extent is equal to 3");

static_assert(std::is_same<gsl::span<int>::element_type, int>::value,
              "span<int>::element_type should be int");
static_assert(std::is_same<gsl::span<int>::value_type, int>::value,
              "span<int>::value_type should be int");
static_assert(std::is_same<gsl::span<int>::size_type, std::size_t>::value,
              "span<int>::size_type should be std::size_t");
static_assert(std::is_same<gsl::span<int>::difference_type, ptrdiff_t>::value,
              "span<int>::difference_type should be std::ptrdiff_t");
static_assert(std::is_same<gsl::span<int>::pointer, int*>::value,
              "span<int>::pointer should be int*");
static_assert(std::is_same<gsl::span<int>::const_pointer, const int*>::value,
              "span<int>::const_pointer should be const int*");
static_assert(std::is_same<gsl::span<int>::reference, int&>::value,
              "span<int>::reference should be int&");
static_assert(std::is_same<gsl::span<int>::const_reference, const int&>::value,
              "span<int>::const_reference should be const int&");

static_assert(std::is_same<gsl::span<int, 3>::element_type, int>::value,
              "span<int, 3>::element_type should be int");
static_assert(std::is_same<gsl::span<int, 3>::value_type, int>::value,
              "span<int, 3>::value_type should be int");
static_assert(std::is_same<gsl::span<int, 3>::size_type, std::size_t>::value,
              "span<int, 3>::size_type should be std::size_t");
static_assert(std::is_same<gsl::span<int, 3>::difference_type, ptrdiff_t>::value,
              "span<int, 3>::difference_type should be std::ptrdiff_t");
static_assert(std::is_same<gsl::span<int, 3>::pointer, int*>::value,
              "span<int, 3>::pointer should be int*");
static_assert(std::is_same<gsl::span<int, 3>::const_pointer, const int*>::value,
              "span<int, 3>::const_pointer should be const int*");
static_assert(std::is_same<gsl::span<int, 3>::reference, int&>::value,
              "span<int, 3>::reference should be int&");
static_assert(std::is_same<gsl::span<int, 3>::const_reference, const int&>::value,
              "span<int, 3>::const_reference should be const int&");

static_assert(std::is_same<gsl::span<const int>::element_type, const int>::value,
              "span<const int>::element_type should be const int");
static_assert(std::is_same<gsl::span<const int>::value_type, int>::value,
              "span<const int>::value_type should be int");
static_assert(std::is_same<gsl::span<const int>::size_type, std::size_t>::value,
              "span<const int>::size_type should be size_t");
static_assert(std::is_same<gsl::span<const int>::difference_type, ptrdiff_t>::value,
              "span<const int>::difference_type should be ptrdiff_t");
static_assert(std::is_same<gsl::span<const int>::pointer, const int*>::value,
              "span<const int>::pointer should be const int*");
static_assert(std::is_same<gsl::span<const int>::const_pointer, const int*>::value,
              "span<const int>::const_pointer should be const int*");
static_assert(std::is_same<gsl::span<const int>::reference, const int&>::value,
              "span<const int>::reference should be const int&");
static_assert(std::is_same<gsl::span<const int>::const_reference, const int&>::value,
              "span<const int>::const_reference should be const int&");

static_assert(std::is_same<gsl::span<const int, 3>::element_type, const int>::value,
              "span<const int, 3>::element_type should be const int");
static_assert(std::is_same<gsl::span<const int, 3>::value_type, int>::value,
              "span<const int, 3>::value_type should be int");
static_assert(std::is_same<gsl::span<const int, 3>::size_type, std::size_t>::value,
              "span<const int, 3>::size_type should be size_t");
static_assert(std::is_same<gsl::span<const int, 3>::difference_type, ptrdiff_t>::value,
              "span<const int, 3>::difference_type should be ptrdiff_t");
static_assert(std::is_same<gsl::span<const int, 3>::pointer, const int*>::value,
              "span<const int, 3>::pointer should be const int*");
static_assert(std::is_same<gsl::span<const int, 3>::const_pointer, const int*>::value,
              "span<const int, 3>::const_pointer should be const int*");
static_assert(std::is_same<gsl::span<const int, 3>::reference, const int&>::value,
              "span<const int, 3>::reference should be const int&");
static_assert(std::is_same<gsl::span<const int, 3>::const_reference, const int&>::value,
              "span<const int, 3>::const_reference should be const int&");

// assertions for span_iterator
static_assert(std::is_same<std::iterator_traits<gsl::span<int>::iterator>::pointer, int*>::value,
              "span<int>::iterator's pointer should be int*");
static_assert(
    std::is_same<gsl::span<int>::reverse_iterator,
                 std::reverse_iterator<gsl::span<int>::iterator>>::value,
    "span<int>::reverse_iterator should equal std::reverse_iterator<span<int>::iterator>");

static_assert(std::is_same<std::iterator_traits<gsl::span<int, 3>::iterator>::pointer, int*>::value,
              "span<int, 3>::iterator's pointer should be int*");
static_assert(
    std::is_same<gsl::span<int, 3>::reverse_iterator,
                 std::reverse_iterator<gsl::span<int, 3>::iterator>>::value,
    "span<int, 3>::reverse_iterator should equal std::reverse_iterator<span<int, 3>::iterator>");

static_assert(
    std::is_same<std::iterator_traits<gsl::span<const int>::iterator>::pointer, const int*>::value,
    "span<const int>::iterator's pointer should be int*");
static_assert(std::is_same<gsl::span<const int>::reverse_iterator,
                           std::reverse_iterator<gsl::span<const int>::iterator>>::value,
              "span<const int>::reverse_iterator should equal std::reverse_iterator<span<const "
              "int>::iterator>");

static_assert(std::is_same<std::iterator_traits<gsl::span<const int, 3>::iterator>::pointer,
                           const int*>::value,
              "span<const int, 3>::iterator's pointer should be int*");
static_assert(std::is_same<gsl::span<const int, 3>::reverse_iterator,
                           std::reverse_iterator<gsl::span<const int, 3>::iterator>>::value,
              "span<const int, 3>::reverse_iterator should equal std::reverse_iterator<span<const "
              "int, 3>::iterator>");

// copyability assertions
static_assert(std::is_trivially_copyable<gsl::span<int>>::value,
              "span<int> should be trivially copyable");
static_assert(std::is_trivially_copyable<gsl::span<int>::iterator>::value,
              "span<int>::iterator should be trivially copyable");

static_assert(std::is_trivially_copyable<gsl::span<int, 3>>::value,
              "span<int, 3> should be trivially copyable");
static_assert(std::is_trivially_copyable<gsl::span<int, 3>::iterator>::value,
              "span<int, 3>::iterator should be trivially copyable");

static_assert(std::is_trivially_copyable<gsl::span<const int>>::value,
              "span<const int> should be trivially copyable");
static_assert(std::is_trivially_copyable<gsl::span<const int>::iterator>::value,
              "span<const int>::iterator should be trivially copyable");

static_assert(std::is_trivially_copyable<gsl::span<const int, 3>>::value,
              "span<const int, 3> should be trivially copyable");
static_assert(std::is_trivially_copyable<gsl::span<const int, 3>::iterator>::value,
              "span<const int, 3>::iterator should be trivially copyable");

// nothrow constructible assertions
static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, std::size_t>::value,
              "std::is_nothrow_constructible<gsl::span<int>, int*, std::size_t>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, std::uint16_t>::value,
              "std::is_nothrow_constructible<gsl::span<int>, int*, std::uint16_t>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, int*, int*>::value,
              "std::is_nothrow_constructible<gsl::span<int>, int*, int*>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, int (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<int>, int(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int>&>::value,
              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int>&>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 500>&>::value,
              "std::is_nothrow_constructible<gsl::span<int>, const gsl::span<int, 500>&>");
static_assert(std::is_nothrow_constructible<gsl::span<int>, std::array<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<int>, std::array<int, 3>&>");

static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::size_t>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::size_t>");
static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::uint16_t>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, std::uint16_t>");
static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int*, int*>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, int*, int*>");
static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, int (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, int(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, const gsl::span<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, const gsl::span<int, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<int, 3>, std::array<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<int, 3>, std::array<int, 3>&>");

static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, std::size_t>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, int*, std::size_t>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, int*>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, int*, int*>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, int*, const int*>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, int*, const int*>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, int (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, int(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, int*>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const int*, int*>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, const int*>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const int*, const int*>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int*, std::size_t>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const int*, std::size_t>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const int (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const int(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int>&>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int>&>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 500>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<int, 500>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 500>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int>, const gsl::span<const int, 500>&>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, std::array<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, std::array<int, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<const int>, const std::array<int, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<const int>, const std::array<int, 3>&>");

static_assert(
    std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<int, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<int, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<const int, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const int, 3>, const gsl::span<const int, 3>&>");

static_assert(std::is_nothrow_constructible<gsl::span<Base>, Base (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<Base>, Base(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base>&>::value,
              "std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base>&>");
static_assert(std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<Base>, const gsl::span<Base, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<Base>, std::array<Base, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<Base>, std::array<Base, 3>&>");

static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, Base (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<Base, 3>, Base(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, const gsl::span<Base, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<Base, 3>, const gsl::span<Base, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<Base, 3>, std::array<Base, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<Base, 3>, std::array<Base, 3>&>");

static_assert(std::is_nothrow_constructible<gsl::span<const Base>, Base (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<const Base>, Base(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<const Base>, const Base (&)[3]>::value,
              "std::is_nothrow_constructible<gsl::span<const Base>, const Base(&)[3]>");
static_assert(std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base>&>::value,
              "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<Base, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base>, const gsl::span<const Base, 3>&>");
static_assert(std::is_nothrow_constructible<gsl::span<const Base>, std::array<Base, 3>&>::value,
              "std::is_nothrow_constructible<gsl::span<const Base>, std::array<Base, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const Base>, const std::array<Base, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base>, const std::array<Base, 3>&>");

static_assert(
    std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<Base, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<Base, 3>&>");
static_assert(
    std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<const Base, 3>&>::value,
    "std::is_nothrow_constructible<gsl::span<const Base, 3>, const gsl::span<const Base, 3>&>");

// non-constructible assertions
static_assert(!std::is_constructible<gsl::span<int>, const int*, int*>::value,
              "!std::is_constructible<gsl::span<int>, const int*, int*>");
static_assert(!std::is_constructible<gsl::span<int>, const int*, const int*>::value,
              "!std::is_constructible<gsl::span<int>, const int*, const int*>");
static_assert(!std::is_constructible<gsl::span<int>, const int*, double*>::value,
              "!std::is_constructible<gsl::span<int>, const int*, double*>");
static_assert(!std::is_constructible<gsl::span<int>, const int*, std::size_t>::value,
              "!std::is_constructible<gsl::span<int>, const int*, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int>, const int (&)[3]>::value,
              "!std::is_constructible<gsl::span<int>, const int(&)[3]>");
static_assert(!std::is_constructible<gsl::span<int>, double*, int*>::value,
              "!std::is_constructible<gsl::span<int>, double*, int*>");
static_assert(!std::is_constructible<gsl::span<int>, double*, const int*>::value,
              "!std::is_constructible<gsl::span<int>, double*, const int*>");
static_assert(!std::is_constructible<gsl::span<int>, double*, double*>::value,
              "!std::is_constructible<gsl::span<int>, double*, double*>");
static_assert(!std::is_constructible<gsl::span<int>, double*, std::size_t>::value,
              "!std::is_constructible<gsl::span<int>, double*, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int>, double (&)[3]>::value,
              "!std::is_constructible<gsl::span<int>, double(&)[3]>");
static_assert(!std::is_constructible<gsl::span<int>, int*, double*>::value,
              "!std::is_constructible<gsl::span<int>, int*, double*>");
static_assert(!std::is_constructible<gsl::span<int>, std::size_t, int*>::value,
              "!std::is_constructible<gsl::span<int>, std::size_t, int*>");
static_assert(!std::is_constructible<gsl::span<int>, std::size_t, std::size_t>::value,
              "!std::is_constructible<gsl::span<int>, std::size_t, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int>&>::value,
              "!std::is_constructible<gsl::span<int>, const gsl::span<const int>&>");
static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int, 3>&>::value,
              "!std::is_constructible<gsl::span<int>, const gsl::span<const int, 3>&>");
static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<const int, 500>&>::value,
              "!std::is_constructible<gsl::span<int>, const gsl::span<const int, 500>&>");
static_assert(!std::is_constructible<gsl::span<int>, const gsl::span<double, 3>&>::value,
              "!std::is_constructible<gsl::span<int>, const gsl::span<double, 3>&>");
static_assert(!std::is_constructible<gsl::span<int>, std::array<double, 3>&>::value,
              "!std::is_constructible<gsl::span<int>, std::array<double, 3>&>");
static_assert(!std::is_constructible<gsl::span<int>, const std::array<int, 3>&>::value,
              "!std::is_constructible<gsl::span<int>, const std::array<int, 3>&>");

static_assert(!std::is_constructible<gsl::span<int, 3>, int*, double*>::value,
              "!std::is_constructible<gsl::span<int, 3>, int*, double*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, int (&)[500]>::value,
              "!std::is_constructible<gsl::span<int, 3>, int(&)[500]>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, int*>::value,
              "!std::is_constructible<gsl::span<int, 3>, const int*, int*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, const int*>::value,
              "!std::is_constructible<gsl::span<int, 3>, const int*, const int*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, std::size_t>::value,
              "!std::is_constructible<gsl::span<int, 3>, const int*, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const int*, double*>::value,
              "!std::is_constructible<gsl::span<int, 3>, const int*, double*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const int (&)[3]>::value,
              "!std::is_constructible<gsl::span<int, 3>, const int(&)[3]>");
static_assert(!std::is_constructible<gsl::span<int, 3>, double*, std::size_t>::value,
              "!std::is_constructible<gsl::span<int, 3>, double*, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int, 3>, double*, int*>::value,
              "!std::is_constructible<gsl::span<int, 3>, double*, int*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, double*, const int*>::value,
              "!std::is_constructible<gsl::span<int, 3>, double*, const int*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, double*, double*>::value,
              "!std::is_constructible<gsl::span<int, 3>, double*, double*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, double (&)[3]>::value,
              "!std::is_constructible<gsl::span<int, 3>, double(&)[3]>");

static_assert(!std::is_constructible<gsl::span<int, 3>, std::size_t, int*>::value,
              "!std::is_constructible<gsl::span<int, 3>, std::size_t, int*>");
static_assert(!std::is_constructible<gsl::span<int, 3>, std::size_t, std::size_t>::value,
              "!std::is_constructible<gsl::span<int, 3>, std::size_t, std::size_t>");
static_assert(!std::is_constructible<gsl::span<int, 3>, std::array<double, 3>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, std::array<double, 3>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, std::array<int, 500>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const std::array<int, 3>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<int, 500>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 3>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 3>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 500>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<const int, 500>&>");
static_assert(!std::is_constructible<gsl::span<int, 3>, const gsl::span<double, 3>&>::value,
              "!std::is_constructible<gsl::span<int, 3>, const gsl::span<double, 3>&>");

static_assert(!std::is_constructible<gsl::span<const int>, double (&)[3]>::value,
              "!std::is_constructible<gsl::span<const int>, double(&)[3]>");
static_assert(!std::is_constructible<gsl::span<const int>, std::array<double, 3>&>::value,
              "!std::is_constructible<gsl::span<const int>, std::array<double, 3>&>");
static_assert(!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>::value,
              "!std::is_constructible<gsl::span<const int>, const gsl::span<double, 3>&>");

static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>::value,
              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int>&>");
static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>::value,
              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<int, 500>&>");
static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>::value,
              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int>&>");
static_assert(
    !std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>::value,
    "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<const int, 500>&>");
static_assert(!std::is_constructible<gsl::span<const int, 3>, const gsl::span<double, 3>&>::value,
              "!std::is_constructible<gsl::span<const int, 3>, const gsl::span<double, 3>&>");

static_assert(!std::is_constructible<gsl::span<Base>, Derived (&)[3]>::value,
              "!std::is_constructible<gsl::span<Base>, Derived(&)[3]>");
static_assert(!std::is_constructible<gsl::span<Base>, std::array<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<Base>, std::array<Derived, 3>&>");
static_assert(!std::is_constructible<gsl::span<Base>, std::vector<Derived>&>::value,
              "!std::is_constructible<gsl::span<Base>, std::vector<Derived>&>");
static_assert(!std::is_constructible<gsl::span<Base>, const gsl::span<Derived>&>::value,
              "!std::is_constructible<gsl::span<Base>, const gsl::span<Derived>&>");
static_assert(!std::is_constructible<gsl::span<Base>, const gsl::span<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<Base>, const gsl::span<Derived, 3>&>");

static_assert(!std::is_constructible<gsl::span<Base, 3>, const gsl::span<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<Base, 3>, const gsl::span<Derived, 3>&>");
static_assert(!std::is_constructible<gsl::span<Base, 3>, Derived (&)[3]>::value,
              "!std::is_constructible<gsl::span<Base, 3>, Derived(&)[3]>");
static_assert(!std::is_constructible<gsl::span<Base, 3>, std::array<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<Base, 3>, std::array<Derived, 3>&>");

static_assert(!std::is_constructible<gsl::span<const Base>, Derived (&)[3]>::value,
              "!std::is_constructible<gsl::span<const Base>, Derived(&)[3]>");
static_assert(!std::is_constructible<gsl::span<const Base>, const Derived (&)[3]>::value,
              "!std::is_constructible<gsl::span<const Base>, const Derived(&)[3]>");
static_assert(!std::is_constructible<gsl::span<const Base>, std::array<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<const Base>, std::array<Derived, 3>&>");
static_assert(!std::is_constructible<gsl::span<const Base>, const std::array<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<const Base>, const std::array<Derived, 3>&>");
static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived>&>::value,
              "!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived>&>");
static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<const Base>, const gsl::span<Derived, 3>&>");
static_assert(!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived>&>::value,
              "!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived>&>");
static_assert(
    !std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived, 3>&>::value,
    "!std::is_constructible<gsl::span<const Base>, const gsl::span<const Derived, 3>&>");

static_assert(!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<Derived, 3>&>::value,
              "!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<Derived, 3>&>");
static_assert(
    !std::is_constructible<gsl::span<const Base, 3>, const gsl::span<const Derived, 3>&>::value,
    "!std::is_constructible<gsl::span<const Base, 3>, const gsl::span<const Derived, 3>&>");

static_assert(!std::is_constructible<gsl::span<const Derived>, std::array<Base, 3>&>::value,
              "!std::is_constructible<gsl::span<const Derived>, std::array<Base, 3>&>");
static_assert(!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>::value,
              "!std::is_constructible<gsl::span<const Derived>, const std::array<Base, 3>&>");

// no throw copy constructor
static_assert(std::is_nothrow_copy_constructible<gsl::span<int>>::value,
              "std::is_nothrow_copy_constructible<gsl::span<int>>");
static_assert(std::is_nothrow_copy_constructible<gsl::span<int, 3>>::value,
              "std::is_nothrow_copy_constructible<gsl::span<int, 3>>");
static_assert(std::is_nothrow_copy_constructible<gsl::span<const int>>::value,
              "std::is_nothrow_copy_constructible<gsl::span<const int>>");
static_assert(std::is_nothrow_copy_constructible<gsl::span<const int, 3>>::value,
              "std::is_nothrow_copy_constructible<gsl::span<const int, 3>>");

// no throw copy assignment
static_assert(std::is_nothrow_copy_assignable<gsl::span<int>>::value,
              "std::is_nothrow_copy_assignable<gsl::span<int>>");
static_assert(std::is_nothrow_copy_assignable<gsl::span<int, 3>>::value,
              "std::is_nothrow_copy_assignable<gsl::span<int, 3>>");
static_assert(std::is_nothrow_copy_assignable<gsl::span<const int>>::value,
              "std::is_nothrow_copy_assignable<gsl::span<const int>>");
static_assert(std::is_nothrow_copy_assignable<gsl::span<const int, 3>>::value,
              "std::is_nothrow_copy_assignable<gsl::span<const int, 3>>");

// no throw destruction
static_assert(std::is_nothrow_destructible<gsl::span<int>>::value,
              "std::is_nothrow_destructible<gsl::span<int>>");
static_assert(std::is_nothrow_destructible<gsl::span<int, 3>>::value,
              "std::is_nothrow_destructible<gsl::span<int, 3>>");
static_assert(std::is_nothrow_destructible<gsl::span<const int>>::value,
              "std::is_nothrow_destructible<gsl::span<const int>>");

// conversions
static_assert(std::is_convertible<int (&)[3], gsl::span<int>>::value,
              "std::is_convertible<int(&)[3], gsl::span<int>>");
static_assert(std::is_convertible<int (&)[3], gsl::span<int, 3>>::value,
              "std::is_convertible<int(&)[3], gsl::span<int, 3>>");
static_assert(std::is_convertible<int (&)[3], gsl::span<const int>>::value,
              "std::is_convertible<int(&)[3], gsl::span<const int>>");

static_assert(std::is_convertible<const int (&)[3], gsl::span<const int>>::value,
              "std::is_convertible<const int(&)[3], gsl::span<const int>>");

static_assert(std::is_convertible<const gsl::span<int>&, gsl::span<int>>::value,
              "std::is_convertible<const gsl::span<int>&, gsl::span<int>>");
static_assert(std::is_convertible<const gsl::span<int>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<int>&, gsl::span<const int>>");

static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<int>>::value,
              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<int>>");
static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<int, 3>>::value,
              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<int, 3>>");
static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int>>");
static_assert(std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int, 3>>::value,
              "std::is_convertible<const gsl::span<int, 3>&, gsl::span<const int, 3>>");
static_assert(std::is_convertible<const gsl::span<int, 500>&, gsl::span<int>>::value,
              "std::is_convertible<const gsl::span<int, 500>&, gsl::span<int>>");
static_assert(std::is_convertible<const gsl::span<int, 500>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<int, 500>&, gsl::span<const int>>");

static_assert(std::is_convertible<const gsl::span<const int>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<const int>&, gsl::span<const int>>");

static_assert(std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int>>");
static_assert(std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int, 3>>::value,
              "std::is_convertible<const gsl::span<const int, 3>&, gsl::span<const int, 3>>");
static_assert(std::is_convertible<const gsl::span<const int, 500>&, gsl::span<const int>>::value,
              "std::is_convertible<const gsl::span<const int, 500>&, gsl::span<const int>>");

static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<int>>::value,
              "std::is_convertible<std::array<int, 3>&, gsl::span<int>>");
static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<int, 3>>::value,
              "std::is_convertible<std::array<int, 3>&, gsl::span<int, 3>>");
static_assert(std::is_convertible<std::array<int, 3>&, gsl::span<const int>>::value,
              "std::is_convertible<std::array<int, 3>&, gsl::span<const int>>");

static_assert(std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>::value,
              "std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>");

#if __cplusplus >= 201703l
template <typename U, typename = void>
static constexpr bool AsWritableBytesCompilesFor = false;

template <typename U>
static constexpr bool
    AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> = true;

static_assert(AsWritableBytesCompilesFor<gsl::span<int>>,
              "AsWritableBytesCompilesFor<gsl::span<int>>");
static_assert(AsWritableBytesCompilesFor<gsl::span<int, 9>>,
              "AsWritableBytesCompilesFor<gsl::span<int, 9>>");
static_assert(!AsWritableBytesCompilesFor<gsl::span<const int>>,
              "!AsWritableBytesCompilesFor<gsl::span<const int>>");
static_assert(!AsWritableBytesCompilesFor<gsl::span<const int, 9>>,
              "!AsWritableBytesCompilesFor<gsl::span<const int, 9>>");
#endif // __cplusplus >= 201703l


================================================
FILE: examples/libraries/GSL/tests/span_ext_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_util> // for narrow_cast, at
#include <gsl/span_ext> // for operator==, operator!=, make_span

#include <array>       // for array
#include <iostream>    // for cerr
#include <vector>      // for vector

using namespace std;
using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";
} // namespace

TEST(span_ext_test, make_span_from_pointer_length_constructor)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. from_pointer_length_constructor";
        std::abort();
    });
    int arr[4] = {1, 2, 3, 4};

    {
        auto s = make_span(&arr[0], 2);
        EXPECT_TRUE(s.size() == 2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] == 1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        int* p = nullptr;
        auto s = make_span(p, narrow_cast<span<int>::size_type>(0));
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);
    }

    {
        int* p = nullptr;
        auto workaround_macro = [=]() { make_span(p, 2); };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }
}

TEST(span_ext_test, make_span_from_pointer_pointer_construction)
{
    int arr[4] = {1, 2, 3, 4};

    {
        auto s = make_span(&arr[0], &arr[2]);
        EXPECT_TRUE(s.size() == 2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] == 1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        auto s = make_span(&arr[0], &arr[0]);
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    {
        int* p = nullptr;
        auto s = make_span(p, p);
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);
    }
}

TEST(span_ext_test, make_span_from_array_constructor)
 {
     int arr[5] = {1, 2, 3, 4, 5};
     int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
     int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

     {
         const auto s = make_span(arr);
         EXPECT_TRUE(s.size() == 5);
         EXPECT_TRUE(s.data() == std::addressof(arr[0]));
     }

     {
         const auto s = make_span(std::addressof(arr2d[0]), 1);
         EXPECT_TRUE(s.size() == 1);
         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
     }

     {
         const auto s = make_span(std::addressof(arr3d[0]), 1);
         EXPECT_TRUE(s.size() == 1);
         EXPECT_TRUE(s.data() == std::addressof(arr3d[0]));
     }
 }

 TEST(span_ext_test, make_span_from_dynamic_array_constructor)
 {
     double(*arr)[3][4] = new double[100][3][4];

     {
         auto s = make_span(&arr[0][0][0], 10);
         EXPECT_TRUE(s.size() == 10);
         EXPECT_TRUE(s.data() == &arr[0][0][0]);
     }

     delete[] arr;
 }

 TEST(span_ext_test, make_span_from_std_array_constructor)
 {
     std::array<int, 4> arr = {1, 2, 3, 4};

     {
         auto s = make_span(arr);
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }

     // This test checks for the bug found in gcc 6.1, 6.2, 6.3, 6.4, 6.5 7.1, 7.2, 7.3 - issue #590
     {
         span<int> s1 = make_span(arr);

         static span<int> s2;
         s2 = s1;

 #if defined(__GNUC__) && __GNUC__ == 6 && (__GNUC_MINOR__ == 4 || __GNUC_MINOR__ == 5) &&          \
     __GNUC_PATCHLEVEL__ == 0 && defined(__OPTIMIZE__)
         // Known to be broken in gcc 6.4 and 6.5 with optimizations
         // Issue in gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83116
         EXPECT_TRUE(s1.size() == 4);
         EXPECT_TRUE(s2.size() == 0);
 #else
         EXPECT_TRUE(s1.size() == s2.size());
 #endif
     }
 }

 TEST(span_ext_test, make_span_from_const_std_array_constructor)
 {
     const std::array<int, 4> arr = {1, 2, 3, 4};

     {
         auto s = make_span(arr);
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }
 }

 TEST(span_ext_test, make_span_from_std_array_const_constructor)
 {
     std::array<const int, 4> arr = {1, 2, 3, 4};

     {
         auto s = make_span(arr);
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }
 }

 TEST(span_ext_test, make_span_from_container_constructor)
 {
     std::vector<int> v = {1, 2, 3};
     const std::vector<int> cv = v;

     {
         auto s = make_span(v);
         EXPECT_TRUE(s.size() == v.size());
         EXPECT_TRUE(s.data() == v.data());

         auto cs = make_span(cv);
         EXPECT_TRUE(cs.size() == cv.size());
         EXPECT_TRUE(cs.data() == cv.data());
     }
 }

 TEST(span_test, interop_with_gsl_at)
 {
     int arr[5] = {1, 2, 3, 4, 5};
     span<int> s{arr};
     EXPECT_TRUE(at(s, 0) ==  1);
     EXPECT_TRUE(at(s, 1) == 2);
 }

 TEST(span_ext_test, iterator_free_functions)
 {
     int a[] = {1, 2, 3, 4};
     span<int> s{a};

     EXPECT_TRUE((std::is_same<decltype(s.begin()), decltype(begin(s))>::value));
     EXPECT_TRUE((std::is_same<decltype(s.end()), decltype(end(s))>::value));

     EXPECT_TRUE((std::is_same<decltype(std::cbegin(s)), decltype(cbegin(s))>::value));
     EXPECT_TRUE((std::is_same<decltype(std::cend(s)), decltype(cend(s))>::value));

     EXPECT_TRUE((std::is_same<decltype(s.rbegin()), decltype(rbegin(s))>::value));
     EXPECT_TRUE((std::is_same<decltype(s.rend()), decltype(rend(s))>::value));

     EXPECT_TRUE((std::is_same<decltype(std::crbegin(s)), decltype(crbegin(s))>::value));
     EXPECT_TRUE((std::is_same<decltype(std::crend(s)), decltype(crend(s))>::value));

     EXPECT_TRUE(s.begin() == begin(s));
     EXPECT_TRUE(s.end() == end(s));

     EXPECT_TRUE(s.rbegin() == rbegin(s));
     EXPECT_TRUE(s.rend() == rend(s));

     EXPECT_TRUE(s.begin() == cbegin(s));
     EXPECT_TRUE(s.end() == cend(s));

     EXPECT_TRUE(s.rbegin() == crbegin(s));
     EXPECT_TRUE(s.rend() == crend(s));
 }

 TEST(span_ext_test, ssize_free_function)
 {
     int a[] = {1, 2, 3, 4};
     span<int> s{a};

     EXPECT_FALSE((std::is_same<decltype(s.size()), decltype(ssize(s))>::value));
     EXPECT_TRUE(s.size() == static_cast<std::size_t>(ssize(s)));
 }

  TEST(span_ext_test, comparison_operators)
 {
     {
         span<int> s1;
         span<int> s2;
         EXPECT_TRUE(s1 == s2);
         EXPECT_FALSE(s1 != s2);
         EXPECT_FALSE(s1 < s2);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s1 >= s2);
         EXPECT_TRUE(s2 == s1);
         EXPECT_FALSE(s2 != s1);
         EXPECT_FALSE(s2 != s1);
         EXPECT_TRUE(s2 <= s1);
         EXPECT_FALSE(s2 > s1);
         EXPECT_TRUE(s2 >= s1);
     }

     {
         int arr[] = {2, 1};
         span<int> s1 = arr;
         span<int> s2 = arr;

         EXPECT_TRUE(s1 == s2);
         EXPECT_FALSE(s1 != s2);
         EXPECT_FALSE(s1 < s2);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s1 >= s2);
         EXPECT_TRUE(s2 == s1);
         EXPECT_FALSE(s2 != s1);
         EXPECT_FALSE(s2 < s1);
         EXPECT_TRUE(s2 <= s1);
         EXPECT_FALSE(s2 > s1);
         EXPECT_TRUE(s2 >= s1);
     }

     {
         int arr[] = {2, 1}; // bigger

         span<int> s1;
         span<int> s2 = arr;

         EXPECT_TRUE(s1 != s2);
         EXPECT_TRUE(s2 != s1);
         EXPECT_FALSE(s1 == s2);
         EXPECT_FALSE(s2 == s1);
         EXPECT_TRUE(s1 < s2);
         EXPECT_FALSE(s2 < s1);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s2 <= s1);
         EXPECT_TRUE(s2 > s1);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s2 >= s1);
         EXPECT_FALSE(s1 >= s2);
     }

     {
         int arr1[] = {1, 2};
         int arr2[] = {1, 2};
         span<int> s1 = arr1;
         span<int> s2 = arr2;

         EXPECT_TRUE(s1 == s2);
         EXPECT_FALSE(s1 != s2);
         EXPECT_FALSE(s1 < s2);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s1 >= s2);
         EXPECT_TRUE(s2 == s1);
         EXPECT_FALSE(s2 != s1);
         EXPECT_FALSE(s2 < s1);
         EXPECT_TRUE(s2 <= s1);
         EXPECT_FALSE(s2 > s1);
         EXPECT_TRUE(s2 >= s1);
     }

     {
         int arr[] = {1, 2, 3};

         span<int> s1 = {&arr[0], 2}; // shorter
         span<int> s2 = arr;          // longer

         EXPECT_TRUE(s1 != s2);
         EXPECT_TRUE(s2 != s1);
         EXPECT_FALSE(s1 == s2);
         EXPECT_FALSE(s2 == s1);
         EXPECT_TRUE(s1 < s2);
         EXPECT_FALSE(s2 < s1);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s2 <= s1);
         EXPECT_TRUE(s2 > s1);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s2 >= s1);
         EXPECT_FALSE(s1 >= s2);
     }

     {
         int arr1[] = {1, 2}; // smaller
         int arr2[] = {2, 1}; // bigger

         span<int> s1 = arr1;
         span<int> s2 = arr2;

         EXPECT_TRUE(s1 != s2);
         EXPECT_TRUE(s2 != s1);
         EXPECT_FALSE(s1 == s2);
         EXPECT_FALSE(s2 == s1);
         EXPECT_TRUE(s1 < s2);
         EXPECT_FALSE(s2 < s1);
         EXPECT_TRUE(s1 <= s2);
         EXPECT_FALSE(s2 <= s1);
         EXPECT_TRUE(s2 > s1);
         EXPECT_FALSE(s1 > s2);
         EXPECT_TRUE(s2 >= s1);
         EXPECT_FALSE(s1 >= s2);
     }
 }


================================================
FILE: examples/libraries/GSL/tests/span_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_byte> // for byte
#include <gsl/gsl_util> // for narrow_cast, at
#include <gsl/span>     // for span, span_iterator, operator==, operator!=

#include <array>       // for array
#include <iostream>    // for ptrdiff_t
#include <iterator>    // for reverse_iterator, operator-, operator==
#include <memory>      // for unique_ptr, shared_ptr, make_unique, allo...
#include <regex>       // for match_results, sub_match, match_results<>...
#include <cstddef>     // for ptrdiff_t
#include <string>      // for string
#include <type_traits> // for integral_constant<>::value, is_default_co...
#include <vector>      // for vector
#include <utility>

using namespace std;
using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";

struct BaseClass
{
};
struct DerivedClass : BaseClass
{
};
struct AddressOverloaded
{
#if (__cplusplus > 201402L)
    [[maybe_unused]]
#endif
    AddressOverloaded
    operator&() const
    {
        return {};
    }
};
} // namespace

TEST(span_test, constructors)
{
    span<int> s;
    EXPECT_TRUE(s.size() == 0);
    EXPECT_TRUE(s.data() == nullptr);

    span<const int> cs;
    EXPECT_TRUE(cs.size() == 0);
    EXPECT_TRUE(cs.data() == nullptr);
}

TEST(span_test, constructors_with_extent)
{
    span<int, 0> s;
    EXPECT_TRUE(s.size() == 0);
    EXPECT_TRUE(s.data() == nullptr);

    span<const int, 0> cs;
    EXPECT_TRUE(cs.size() == 0);
    EXPECT_TRUE(cs.data() == nullptr);
}

TEST(span_test, constructors_with_bracket_init)
{
    span<int> s{};
    EXPECT_TRUE(s.size() == 0);
    EXPECT_TRUE(s.data() == nullptr);

    span<const int> cs{};
    EXPECT_TRUE(cs.size() == 0);
    EXPECT_TRUE(cs.data() == nullptr);
}

TEST(span_test, size_optimization)
{
    span<int> s;
    EXPECT_TRUE(sizeof(s) == sizeof(int*) + sizeof(ptrdiff_t));

    span<int, 0> se;
    EXPECT_TRUE(sizeof(se) == sizeof(int*));
}

TEST(span_test, from_nullptr_size_constructor)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. from_nullptr_size_constructor";
        std::abort();
    });
    {
        span<int> s{nullptr, narrow_cast<span<int>::size_type>(0)};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);

        span<int> cs{nullptr, narrow_cast<span<int>::size_type>(0)};
        EXPECT_TRUE(cs.size() == 0);
        EXPECT_TRUE(cs.data() == nullptr);
    }
    {
        auto workaround_macro = []() {
            const span<int, 1> s{nullptr, narrow_cast<span<int>::size_type>(0)};
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }
    {
        auto workaround_macro = []() { const span<int> s{nullptr, 1}; };
        EXPECT_DEATH(workaround_macro(), deathstring);

        auto const_workaround_macro = []() { const span<const int> s{nullptr, 1}; };
        EXPECT_DEATH(const_workaround_macro(), deathstring);
    }
    {
        auto workaround_macro = []() { const span<int, 0> s{nullptr, 1}; };
        EXPECT_DEATH(workaround_macro(), deathstring);

        auto const_workaround_macro = []() { const span<const int, 0> s{nullptr, 1}; };
        EXPECT_DEATH(const_workaround_macro(), deathstring);
    }
    {
        span<int*> s{nullptr, narrow_cast<span<int>::size_type>(0)};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);

        span<const int*> cs{nullptr, narrow_cast<span<int>::size_type>(0)};
        EXPECT_TRUE(cs.size() == 0);
        EXPECT_TRUE(cs.data() == nullptr);
    }
}

TEST(span_test, from_pointer_length_constructor)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. from_pointer_length_constructor";
        std::abort();
    });
    int arr[4] = {1, 2, 3, 4};

    {
        for (int i = 0; i < 4; ++i)
        {
            {
                span<int> s = {&arr[0], narrow_cast<std::size_t>(i)};
                EXPECT_TRUE(s.size() == narrow_cast<std::size_t>(i));
                EXPECT_TRUE(s.data() == &arr[0]);
                EXPECT_TRUE(s.empty() == (i == 0));
                for (int j = 0; j < i; ++j)
                    EXPECT_TRUE(arr[j] == s[narrow_cast<std::size_t>(j)]);
            }
            {
                span<int> s = {&arr[i], 4 - narrow_cast<std::size_t>(i)};
                EXPECT_TRUE(s.size() == 4 - narrow_cast<std::size_t>(i));
                EXPECT_TRUE(s.data() == &arr[i]);
                EXPECT_TRUE(s.empty() == ((4 - i) == 0));

                for (int j = 0; j < 4 - i; ++j)
                    EXPECT_TRUE(arr[j + i] == s[narrow_cast<std::size_t>(j)]);
            }
        }
    }

    {
        span<int, 2> s{&arr[0], 2};
        EXPECT_TRUE(s.size() == 2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] == 1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        int* p = nullptr;
        span<int> s{p, narrow_cast<span<int>::size_type>(0)};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);
    }

    {
        int* p = nullptr;
        auto workaround_macro = [=]() { const span<int> s{p, 2}; };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }
}

TEST(span_test, from_pointer_pointer_construction)
{
    int arr[4] = {1, 2, 3, 4};

    {
        span<int> s{&arr[0], &arr[2]};
        EXPECT_TRUE(s.size() == 2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] == 1);
        EXPECT_TRUE(s[1] == 2);
    }
    {
        span<int, 2> s{&arr[0], &arr[2]};
        EXPECT_TRUE(s.size() == 2);
        EXPECT_TRUE(s.data() == &arr[0]);
        EXPECT_TRUE(s[0] == 1);
        EXPECT_TRUE(s[1] == 2);
    }

    {
        span<int> s{&arr[0], &arr[0]};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    {
        span<int, 0> s{&arr[0], &arr[0]};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == &arr[0]);
    }

    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
    //{
    //    auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
    //    EXPECT_DEATH(workaround_macro(), deathstring);
    //}

    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
    //{
    //    int* p = nullptr;
    //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
    //    EXPECT_DEATH(workaround_macro(), deathstring);
    //}

    {
        int* p = nullptr;
        span<int> s{p, p};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);
    }

    {
        int* p = nullptr;
        span<int, 0> s{p, p};
        EXPECT_TRUE(s.size() == 0);
        EXPECT_TRUE(s.data() == nullptr);
    }

    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
    //{
    //    int* p = nullptr;
    //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
    //    EXPECT_DEATH(workaround_macro(), deathstring);
    //}
}

TEST(span_test, from_array_constructor)
 {
     int arr[5] = {1, 2, 3, 4, 5};

     {
         const span<int> s{arr};
         EXPECT_TRUE(s.size() == 5);
         EXPECT_TRUE(s.data() == &arr[0]);
     }

     {
         const span<int, 5> s{arr};
         EXPECT_TRUE(s.size() == 5);
         EXPECT_TRUE(s.data() == &arr[0]);
     }

     int arr2d[2][3] = {1, 2, 3, 4, 5, 6};

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<int, 6> s{arr};
     }

     {
         span<int, 0> s{arr};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == &arr[0]);
     }

     {
         span<int> s{arr2d};
         EXPECT_TRUE(s.size() == 6);
         EXPECT_TRUE(s.data() == &arr2d[0][0]);
         EXPECT_TRUE(s[0] == 1);
         EXPECT_TRUE(s[5] == 6);
     }

     {
         span<int, 0> s{arr2d};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == &arr2d[0][0]);
     }

     {
         span<int, 6> s{arr2d};
     }
 #endif
     {
         const span<int[3]> s{std::addressof(arr2d[0]), 1};
         EXPECT_TRUE(s.size() == 1);
         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
     }

     int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<int> s{arr3d};
         EXPECT_TRUE(s.size() == 12);
         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
         EXPECT_TRUE(s[0] == 1);
         EXPECT_TRUE(s[11] == 12);
     }

     {
         span<int, 0> s{arr3d};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
     }

     {
         span<int, 11> s{arr3d};
     }

     {
         span<int, 12> s{arr3d};
         EXPECT_TRUE(s.size() == 12);
         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
         EXPECT_TRUE(s[0] == 1);
         EXPECT_TRUE(s[5] == 6);
     }
 #endif
     {
         const span<int[3][2]> s{std::addressof(arr3d[0]), 1};
         EXPECT_TRUE(s.size() ==  1);
     }

     AddressOverloaded ao_arr[5] = {};

     {
         const span<AddressOverloaded, 5> s{ao_arr};
         EXPECT_TRUE(s.size() == 5);
         EXPECT_TRUE(s.data() == std::addressof(ao_arr[0]));
     }
 }

 TEST(span_test, from_dynamic_array_constructor)
 {
     double(*arr)[3][4] = new double[100][3][4];

     {
         span<double> s(&arr[0][0][0], 10);
         EXPECT_TRUE(s.size() == 10);
         EXPECT_TRUE(s.data() == &arr[0][0][0]);
     }

     delete[] arr;
 }

 TEST(span_test, from_std_array_constructor)
 {
     std::array<int, 4> arr = {1, 2, 3, 4};

     {
         span<int> s{arr};
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());

         span<const int> cs{arr};
         EXPECT_TRUE(cs.size() == arr.size());
         EXPECT_TRUE(cs.data() == arr.data());
     }

     {
         span<int, 4> s{arr};
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());

         span<const int, 4> cs{arr};
         EXPECT_TRUE(cs.size() == arr.size());
         EXPECT_TRUE(cs.data() == arr.data());
     }

     {
         std::array<int, 0> empty_arr{};
         span<int> s{empty_arr};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.empty());
     }

     std::array<AddressOverloaded, 4> ao_arr{};

     {
         span<AddressOverloaded, 4> fs{ao_arr};
         EXPECT_TRUE(fs.size() == ao_arr.size());
         EXPECT_TRUE(ao_arr.data() == fs.data());
     }

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<int, 2> s{arr};
         EXPECT_TRUE(s.size() == 2);
         EXPECT_TRUE(s.data() == arr.data());

         span<const int, 2> cs{arr};
         EXPECT_TRUE(cs.size() == 2);
         EXPECT_TRUE(cs.data() == arr.data());
     }

     {
         span<int, 0> s{arr};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == arr.data());

         span<const int, 0> cs{arr};
         EXPECT_TRUE(cs.size() == 0);
         EXPECT_TRUE(cs.data() == arr.data());
     }

     {
         span<int, 5> s{arr};
     }

     {
         auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
         auto take_a_span = [](span<int> s) { static_cast<void>(s); };
         // try to take a temporary std::array
         take_a_span(get_an_array());
     }
 #endif

     {
         auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
         auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
         // try to take a temporary std::array
         take_a_span(get_an_array());
     }
 }

 TEST(span_test, from_const_std_array_constructor)
 {
     const std::array<int, 4> arr = {1, 2, 3, 4};

     {
         span<const int> s{arr};
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 4> s{arr};
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }

     const std::array<AddressOverloaded, 4> ao_arr{};

     {
         span<const AddressOverloaded, 4> s{ao_arr};
         EXPECT_TRUE(s.size() == ao_arr.size());
         EXPECT_TRUE(s.data() == ao_arr.data());
     }

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<const int, 2> s{arr};
         EXPECT_TRUE(s.size() == 2);
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 0> s{arr};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 5> s{arr};
     }
 #endif

     {
         auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
         auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
         // try to take a temporary std::array
         take_a_span(get_an_array());
     }
 }

 TEST(span_test, from_std_array_const_constructor)
 {
     std::array<const int, 4> arr = {1, 2, 3, 4};

     {
         span<const int> s{arr};
         EXPECT_TRUE(s.size() == arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 4> s{arr};
         EXPECT_TRUE(s.size() ==  arr.size());
         EXPECT_TRUE(s.data() == arr.data());
     }

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<const int, 2> s{arr};
         EXPECT_TRUE(s.size() == 2);
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 0> s{arr};
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == arr.data());
     }

     {
         span<const int, 5> s{arr};
     }

     {
         span<int, 4> s{arr};
     }
 #endif
 }

 TEST(span_test, from_container_constructor)
 {
     std::vector<int> v = {1, 2, 3};
     const std::vector<int> cv = v;

     {
         span<int> s{v};
         EXPECT_TRUE(s.size() == v.size());
         EXPECT_TRUE(s.data() == v.data());

         span<const int> cs{v};
         EXPECT_TRUE(cs.size() == v.size());
         EXPECT_TRUE(cs.data() == v.data());
     }

     std::string str = "hello";
     const std::string cstr = "hello";

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         span<char> s{str};
         EXPECT_TRUE(s.size() == str.size());
         EXPECT_TRUE(s.data() == str.data()));
 #endif
         span<const char> cs{str};
         EXPECT_TRUE(cs.size() == str.size());
         EXPECT_TRUE(cs.data() == str.data());
     }

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         span<char> s{cstr};
 #endif
         span<const char> cs{cstr};
         EXPECT_TRUE(cs.size() == cstr.size());
         EXPECT_TRUE(cs.data() == cstr.data());
     }

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         auto get_temp_vector = []() -> std::vector<int> { return {}; };
         auto use_span = [](span<int> s) { static_cast<void>(s); };
         use_span(get_temp_vector());
 #endif
     }

     {
         auto get_temp_vector = []() -> std::vector<int> { return {}; };
         auto use_span = [](span<const int> s) { static_cast<void>(s); };
         use_span(get_temp_vector());
     }

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         auto get_temp_string = []() -> std::string { return {}; };
         auto use_span = [](span<char> s) { static_cast<void>(s); };
         use_span(get_temp_string());
 #endif
     }

     {
         auto get_temp_string = []() -> std::string { return {}; };
         auto use_span = [](span<const char> s) { static_cast<void>(s); };
         use_span(get_temp_string());
     }

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         auto get_temp_vector = []() -> const std::vector<int> { return {}; };
         auto use_span = [](span<const char> s) { static_cast<void>(s); };
         use_span(get_temp_vector());
 #endif
     }

     {
         auto get_temp_string = []() -> const std::string { return {}; };
         auto use_span = [](span<const char> s) { static_cast<void>(s); };
         use_span(get_temp_string());
     }

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         std::map<int, int> m;
         span<int> s{m};
 #endif
     }
 }

 TEST(span_test, from_convertible_span_constructor){{span<DerivedClass> avd;
 span<const DerivedClass> avcd = avd;
 static_cast<void>(avcd);
 }

 {
 #ifdef CONFIRM_COMPILATION_ERRORS
     span<DerivedClass> avd;
     span<BaseClass> avb = avd;
     static_cast<void>(avb);
 #endif
 }

 #ifdef CONFIRM_COMPILATION_ERRORS
 {
     span<int> s;
     span<unsigned int> s2 = s;
     static_cast<void>(s2);
 }

 {
     span<int> s;
     span<const unsigned int> s2 = s;
     static_cast<void>(s2);
 }

 {
     span<int> s;
     span<short> s2 = s;
     static_cast<void>(s2);
 }
 #endif
 }

 TEST(span_test, copy_move_and_assignment)
 {
     span<int> s1;
     EXPECT_TRUE(s1.empty());

     int arr[] = {3, 4, 5};

     span<const int> s2 = arr;
     EXPECT_TRUE(s2.size() ==  3);
     EXPECT_TRUE(s2.data() == &arr[0]);

     s2 = s1;
     EXPECT_TRUE(s2.empty());

     auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
     auto use_span = [&](span<const int> s) {
         EXPECT_TRUE(s.size() ==  2);
         EXPECT_TRUE(s.data() == &arr[1]);
     }; use_span(get_temp_span());

     s1 = get_temp_span();
     EXPECT_TRUE(s1.size() ==  2);
     EXPECT_TRUE(s1.data() == &arr[1]);
 }

 TEST(span_test, first)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. first";
        std::abort();
    });
     int arr[5] = {1, 2, 3, 4, 5};

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.first<2>().size() == 2);
         EXPECT_TRUE(av.first(2).size() == 2);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.first<0>().size() == 0);
         EXPECT_TRUE(av.first(0).size() == 0);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.first<5>().size() == 5);
         EXPECT_TRUE(av.first(5).size() == 5);
     }

     {
         span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
         EXPECT_TRUE(av.first<6>().size() == 6);
         EXPECT_TRUE(av.first<-1>().size() == -1);
 #endif
         EXPECT_DEATH(av.first(6).size(), deathstring);
     }

     {
         span<int> av;
         EXPECT_TRUE(av.first<0>().size() == 0);
         EXPECT_TRUE(av.first(0).size() == 0);
     }
 }

 TEST(span_test, last)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. last";
        std::abort();
    });
     int arr[5] = {1, 2, 3, 4, 5};

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.last<2>().size() == 2);
         EXPECT_TRUE(av.last(2).size() == 2);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.last<0>().size() == 0);
         EXPECT_TRUE(av.last(0).size() == 0);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.last<5>().size() == 5);
         EXPECT_TRUE(av.last(5).size() == 5);
     }

     {
         span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
         EXPECT_TRUE(av.last<6>().size() == 6);
 #endif
         EXPECT_DEATH(av.last(6).size(), deathstring);
     }

     {
         span<int> av;
         EXPECT_TRUE(av.last<0>().size() == 0);
         EXPECT_TRUE(av.last(0).size() == 0);
     }
 }

 TEST(span_test, subspan)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. subspan";
        std::abort();
    });
     int arr[5] = {1, 2, 3, 4, 5};

     {
         span<int, 5> av = arr;
         EXPECT_TRUE((av.subspan<2, 2>().size()) == 2);
         EXPECT_TRUE(decltype(av.subspan<2, 2>())::extent == 2);
         EXPECT_TRUE(av.subspan(2, 2).size() == 2);
         EXPECT_TRUE(av.subspan(2, 3).size() == 3);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE((av.subspan<0, 0>().size()) == 0);
         EXPECT_TRUE(decltype(av.subspan<0, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(0, 0).size() == 0);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE((av.subspan<0, 5>().size()) == 5);
         EXPECT_TRUE(decltype(av.subspan<0, 5>())::extent == 5);
         EXPECT_TRUE(av.subspan(0, 5).size() == 5);

         EXPECT_DEATH(av.subspan(0, 6).size(), deathstring);
         EXPECT_DEATH(av.subspan(1, 5).size(), deathstring);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE((av.subspan<4, 0>().size()) == 0);
         EXPECT_TRUE(decltype(av.subspan<4, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(4, 0).size() == 0);
         EXPECT_TRUE(av.subspan(5, 0).size() == 0);
         EXPECT_DEATH(av.subspan(6, 0).size(), deathstring);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.subspan<1>().size() == 4);
         EXPECT_TRUE(decltype(av.subspan<1>())::extent == 4);
     }

     {
         span<int> av;
         EXPECT_TRUE((av.subspan<0, 0>().size()) == 0);
         EXPECT_TRUE(decltype(av.subspan<0, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(0, 0).size() == 0);
         EXPECT_DEATH((av.subspan<1, 0>().size()), deathstring);
     }

     {
         span<int> av;
         EXPECT_TRUE(av.subspan(0).size() == 0);
         EXPECT_DEATH(av.subspan(1).size(), deathstring);
     }

     {
         span<int> av = arr;
         EXPECT_TRUE(av.subspan(0).size() == 5);
         EXPECT_TRUE(av.subspan(1).size() == 4);
         EXPECT_TRUE(av.subspan(4).size() == 1);
         EXPECT_TRUE(av.subspan(5).size() == 0);
         EXPECT_DEATH(av.subspan(6).size(), deathstring);
         const auto av2 = av.subspan(1);
         for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == static_cast<int>(i) + 2);
     }

     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.subspan(0).size() == 5);
         EXPECT_TRUE(av.subspan(1).size() == 4);
         EXPECT_TRUE(av.subspan(4).size() == 1);
         EXPECT_TRUE(av.subspan(5).size() == 0);
         EXPECT_DEATH(av.subspan(6).size(), deathstring);
         const auto av2 = av.subspan(1);
         for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == static_cast<int>(i) + 2);
     }
 }

 TEST(span_test, iterator_default_init)
 {
     span<int>::iterator it1;
     span<int>::iterator it2;
     EXPECT_TRUE(it1 == it2);
 }

 TEST(span_test, iterator_comparisons)
 {
     int a[] = {1, 2, 3, 4};
     {
         span<int> s = a;
         span<int>::iterator it = s.begin();
         auto it2 = it + 1;

         EXPECT_TRUE(it == it);
         EXPECT_TRUE(it == s.begin());
         EXPECT_TRUE(s.begin() == it);

         EXPECT_TRUE(it != it2);
         EXPECT_TRUE(it2 != it);
         EXPECT_TRUE(it != s.end());
         EXPECT_TRUE(it2 != s.end());
         EXPECT_TRUE(s.end() != it);

         EXPECT_TRUE(it < it2);
         EXPECT_TRUE(it <= it2);
         EXPECT_TRUE(it2 <= s.end());
         EXPECT_TRUE(it < s.end());

         EXPECT_TRUE(it2 > it);
         EXPECT_TRUE(it2 >= it);
         EXPECT_TRUE(s.end() > it2);
         EXPECT_TRUE(s.end() >= it2);
     }
 }

 TEST(span_test, incomparable_iterators)
 {
     std::set_terminate([] {
         std::cerr << "Expected Death. incomparable_iterators";
         std::abort();
     });

     int a[] = {1, 2, 3, 4};
     int b[] = {1, 2, 3, 4};
     {
         span<int> s = a;
         span<int> s2 = b;
#if (__cplusplus > 201402L)
         EXPECT_DEATH([[maybe_unused]] bool _ = (s.begin() == s2.begin()), deathstring);
         EXPECT_DEATH([[maybe_unused]] bool _ = (s.begin() <= s2.begin()), deathstring);
#else
         EXPECT_DEATH(bool _ = (s.begin() == s2.begin()), deathstring);
         EXPECT_DEATH(bool _ = (s.begin() <= s2.begin()), deathstring);
#endif
     }
 }

 TEST(span_test, begin_end)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. begin_end";
        std::abort();
    });
     {
         int a[] = {1, 2, 3, 4};
         span<int> s = a;

         span<int>::iterator it = s.begin();
         span<int>::iterator it2 = std::begin(s);
         EXPECT_TRUE(it == it2);

         it = s.end();
         it2 = std::end(s);
         EXPECT_TRUE(it == it2);
     }

     {
         int a[] = {1, 2, 3, 4};
         span<int> s = a;

         auto it = s.begin();
         auto first = it;
         EXPECT_TRUE(it == first);
         EXPECT_TRUE(*it == 1);

         auto beyond = s.end();
         EXPECT_TRUE(it != beyond);
         EXPECT_DEATH(*beyond, deathstring);

         EXPECT_TRUE(beyond - first == 4);
         EXPECT_TRUE(first - first == 0);
         EXPECT_TRUE(beyond - beyond == 0);

         ++it;
         EXPECT_TRUE(it - first == 1);
         EXPECT_TRUE(*it == 2);
         *it = 22;
         EXPECT_TRUE(*it == 22);
         EXPECT_TRUE(beyond - it == 3);

         it = first;
         EXPECT_TRUE(it == first);
         while (it != s.end())
         {
             *it = 5;
             ++it;
         }

         EXPECT_TRUE(it == beyond);
         EXPECT_TRUE(it - beyond == 0);

         for (const auto& n : s) { EXPECT_TRUE(n == 5); }
     }
 }

 TEST(span_test, rbegin_rend)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. rbegin_rend";
        std::abort();
    });
     {
         int a[] = {1, 2, 3, 4};
         span<int> s = a;

         auto it = s.rbegin();
         auto first = it;
         EXPECT_TRUE(it == first);
         EXPECT_TRUE(*it == 4);

         auto beyond = s.rend();
         EXPECT_TRUE(it != beyond);
#if (__cplusplus > 201402L)
        EXPECT_DEATH([[maybe_unused]] auto _ = *beyond , deathstring);
#else
        EXPECT_DEATH(auto _ = *beyond , deathstring);
#endif

         EXPECT_TRUE(beyond - first == 4);
         EXPECT_TRUE(first - first == 0);
         EXPECT_TRUE(beyond - beyond == 0);

         ++it;
         EXPECT_TRUE(it - s.rbegin() == 1);
         EXPECT_TRUE(*it == 3);
         *it = 22;
         EXPECT_TRUE(*it == 22);
         EXPECT_TRUE(beyond - it == 3);

         it = first;
         EXPECT_TRUE(it == first);
         while (it != s.rend())
         {
             *it = 5;
             ++it;
         }

         EXPECT_TRUE(it == beyond);
         EXPECT_TRUE(it - beyond == 0);

         for (const auto& n : s) { EXPECT_TRUE(n == 5); }
     }
 }

 TEST(span_test, as_bytes)
 {
     std::set_terminate([] {
         std::cerr << "Expected Death. as_bytes";
         std::abort();
     });

     int a[] = {1, 2, 3, 4};
     {
         const span<const int> s = a;
         EXPECT_TRUE(s.size() == 4);
         const span<const byte> bs = as_bytes(s);
         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
         EXPECT_TRUE(bs.size() == s.size_bytes());
     }

     {
         span<int> s;
         const auto bs = as_bytes(s);
         EXPECT_TRUE(bs.size() == s.size());
         EXPECT_TRUE(bs.size() == 0);
         EXPECT_TRUE(bs.size_bytes() == 0);
         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
         EXPECT_TRUE(bs.data() == nullptr);
     }

     {
         span<int> s = a;
         const auto bs = as_bytes(s);
         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
         EXPECT_TRUE(bs.size() == s.size_bytes());
     }

     int b[5] = {1, 2, 3, 4, 5};
     {
         span<int> sp(begin(b), static_cast<size_t>(-2));
         EXPECT_DEATH((void) sp.size_bytes(), deathstring);
     }
 }

 TEST(span_test, as_writable_bytes)
 {
     int a[] = {1, 2, 3, 4};

     {
 #ifdef CONFIRM_COMPILATION_ERRORS
         // you should not be able to get writeable bytes for const objects
         span<const int> s = a;
         EXPECT_TRUE(s.size() == 4);
         span<const byte> bs = as_writable_bytes(s);
         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
         EXPECT_TRUE(bs.size() == s.size_bytes());
 #endif
     }

     {
         span<int> s;
         const auto bs = as_writable_bytes(s);
         EXPECT_TRUE(bs.size() == s.size());
         EXPECT_TRUE(bs.size() == 0);
         EXPECT_TRUE(bs.size_bytes() == 0);
         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
         EXPECT_TRUE(bs.data() == nullptr);
     }

     {
         span<int> s = a;
         const auto bs = as_writable_bytes(s);
         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
         EXPECT_TRUE(bs.size() == s.size_bytes());
     }
 }

 TEST(span_test, fixed_size_conversions)
 {
    std::set_terminate([] {
        std::cerr << "Expected Death. fixed_size_conversions";
        std::abort();
    });
     int arr[] = {1, 2, 3, 4};

     // converting to an span from an equal size array is ok
     span<int, 4> s4 = arr;
     EXPECT_TRUE(s4.size() == 4);

     // converting to dynamic_range is always ok
     {
         span<int> s = s4;
         EXPECT_TRUE(s.size() == s4.size());
         static_cast<void>(s);
     }

 // initialization or assignment to static span that REDUCES size is NOT ok
 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<int, 2> s = arr;
     }
     {
         span<int, 2> s2 = s4;
         static_cast<void>(s2);
     }
 #endif

     // even when done dynamically
     {
         /*
         // this now results in a compile-time error, rather than runtime.
         // There is no suitable conversion from dynamic span to fixed span.
         span<int> s = arr;
         auto f = [&]() {
             const span<int, 2> s2 = s;
             static_cast<void>(s2);
         };
         EXPECT_DEATH(f(), deathstring);
         */
     }

     // but doing so explicitly is ok

     // you can convert statically
     {
         const span<int, 2> s2 = {&arr[0], 2};
         static_cast<void>(s2);
     }
     {
         const span<int, 1> s1 = s4.first<1>();
         static_cast<void>(s1);
     }

    /*
     // this is not a legal operation in std::span, so we are no longer supporting it
     // conversion from span<int, 4> to span<int, dynamic_extent> via call to `first`
     // then convert from span<int, dynamic_extent> to span<int, 1>
     // The dynamic to fixed extents are not supported in the standard
     // to make this work, span<int, 1> would need to be span<int>.
     {

         // NB: implicit conversion to span<int,1> from span<int>
         span<int, 1> s1 = s4.first(1);
         static_cast<void>(s1);
     }
     */

     // initialization or assignment to static span that requires size INCREASE is not ok.
     int arr2[2] = {1, 2};

 #ifdef CONFIRM_COMPILATION_ERRORS
     {
         span<int, 4> s3 = arr2;
     }
     {
         span<int, 2> s2 = arr2;
         span<int, 4> s4a = s2;
     }
 #endif
     {
         auto f = [&]() {
             const span<int, 4> _s4 = {arr2, 2};
             static_cast<void>(_s4);
         };
         EXPECT_DEATH(f(), deathstring);
     }

    /*
     // This no longer compiles. There is no suitable conversion from dynamic span to a fixed size span.
     // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one
     span<int> av = arr2; auto f = [&]() {
         const span<int, 4> _s4 = av;
         static_cast<void>(_s4);
     };
     EXPECT_DEATH(f(), deathstring);
     */
 }

 TEST(span_test, interop_with_std_regex)
 {
     char lat[] = {'1', '2', '3', '4', '5', '6', 'E', 'F', 'G'};
     span<char> s = lat;
     const auto f_it = s.begin() + 7;

     std::match_results<span<char>::iterator> match;

     std::regex_match(s.begin(), s.end(), match, std::regex(".*"));
     EXPECT_TRUE(match.ready());
     EXPECT_FALSE(match.empty());
     EXPECT_TRUE(match[0].matched);
     EXPECT_TRUE(match[0].first == s.begin());
     EXPECT_TRUE(match[0].second == s.end());

     std::regex_search(s.begin(), s.end(), match, std::regex("F"));
     EXPECT_TRUE(match.ready());
     EXPECT_FALSE(match.empty());
     EXPECT_TRUE(match[0].matched);
     EXPECT_TRUE(match[0].first == f_it);
     EXPECT_TRUE(match[0].second == (f_it + 1));
 }

 TEST(span_test, default_constructible)
 {
     EXPECT_TRUE((std::is_default_constructible<span<int>>::value));
     EXPECT_TRUE((std::is_default_constructible<span<int, 0>>::value));
     EXPECT_FALSE((std::is_default_constructible<span<int, 42>>::value));
 }

 TEST(span_test, front_back)
 {
    int arr[5] = {1,2,3,4,5};
    span<int> s{arr};
    EXPECT_TRUE(s.front() == 1);
    EXPECT_TRUE(s.back() == 5);

    std::set_terminate([] {
        std::cerr << "Expected Death. front_back";
        std::abort();
    });
    span<int> s2;
    EXPECT_DEATH(s2.front(), deathstring);
    EXPECT_DEATH(s2.back(), deathstring);
 }


================================================
FILE: examples/libraries/GSL/tests/strict_notnull_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>
#include <gsl/pointers>           // for not_null, operator<, operator<=, operator>

namespace gsl
{
struct fail_fast;
} // namespace gsl

using namespace gsl;

GSL_SUPPRESS(f.4)  // NO-FORMAT: attribute
bool helper(not_null<int*> p) { return *p == 12; }

GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
bool helper_const(not_null<const int*> p) { return *p == 12; }

GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
bool strict_helper(strict_not_null<int*> p) { return *p == 12; }

GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }

int* return_pointer() { return nullptr; }
const int* return_pointer_const() { return nullptr; }

TEST(strict_notnull_tests, TestStrictNotNull)
{
    {
        // raw ptr <-> strict_not_null
        int x = 42;

#ifdef CONFIRM_COMPILATION_ERRORS
        strict_not_null<int*> snn = &x;
        strict_helper(&x);
        strict_helper_const(&x);
        strict_helper(return_pointer());
        strict_helper_const(return_pointer_const());
#endif

        const strict_not_null<int*> snn1{&x};

        helper(snn1);
        helper_const(snn1);

        EXPECT_TRUE(*snn1 == 42);
    }

    {
        // strict_not_null -> strict_not_null
        int x = 42;

        strict_not_null<int*> snn1{&x};
        const strict_not_null<int*> snn2{&x};

        strict_helper(snn1);
        strict_helper_const(snn1);
        strict_helper_const(snn2);

        EXPECT_TRUE(snn1 == snn2);
    }

    {
        // strict_not_null -> not_null
        int x = 42;

        strict_not_null<int*> snn{&x};

        const not_null<int*> nn1 = snn;
        const not_null<int*> nn2{snn};

        helper(snn);
        helper_const(snn);

        EXPECT_TRUE(snn == nn1);
        EXPECT_TRUE(snn == nn2);
    }

    {
        // not_null -> strict_not_null
        int x = 42;

        not_null<int*> nn{&x};

        const strict_not_null<int*> snn1{nn};
        const strict_not_null<int*> snn2{nn};

        strict_helper(nn);
        strict_helper_const(nn);

        EXPECT_TRUE(snn1 == nn);
        EXPECT_TRUE(snn2 == nn);

        std::hash<strict_not_null<int*>> hash_snn;
        std::hash<not_null<int*>> hash_nn;

        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        strict_not_null<int*> p{nullptr};
    }
#endif
}

#if defined(__cplusplus) && (__cplusplus >= 201703L)
namespace
{
static constexpr char deathstring[] = "Expected Death";
}

TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. TestStrictNotNullConstructorTypeDeduction";
        std::abort();
    });

    {
        int i = 42;

        strict_not_null x{&i};
        helper(strict_not_null{&i});
        helper_const(strict_not_null{&i});

        EXPECT_TRUE(*x == 42);
    }

    {
        int i = 42;
        int* p = &i;

        strict_not_null x{p};
        helper(strict_not_null{p});
        helper_const(strict_not_null{p});

        EXPECT_TRUE(*x == 42);
    }

    {
        auto workaround_macro = []() {
            int* p1 = nullptr;
            const strict_not_null x{p1};
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        auto workaround_macro = []() {
            const int* p1 = nullptr;
            const strict_not_null x{p1};
        };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    {
        int* p = nullptr;

        EXPECT_DEATH(helper(strict_not_null{p}), deathstring);
        EXPECT_DEATH(helper_const(strict_not_null{p}), deathstring);
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        strict_not_null x{nullptr};
        helper(strict_not_null{nullptr});
        helper_const(strict_not_null{nullptr});
    }
#endif
}
#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)


================================================
FILE: examples/libraries/GSL/tests/strided_span_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>
#include <gsl/gsl_byte>   // for byte
#include <gsl/gsl_util>   // for narrow_cast
#include <gsl/multi_span> // for strided_span, index, multi_span, strided_...

#include <iostream>    // for size_t
#include <iterator>    // for begin, end
#include <numeric>     // for iota
#include <type_traits> // for integral_constant<>::value, is_convertible
#include <vector>      // for vector

using namespace std;
using namespace gsl;


namespace
{
static constexpr char deathstring[] = "Expected Death";

struct BaseClass
{
};
struct DerivedClass : BaseClass
{
};

GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
void iterate_every_other_element(multi_span<int, dynamic_range> av)
{
    // pick every other element

    auto length = av.size() / 2;
#if defined(_MSC_VER) && _MSC_VER > 1800
    auto bounds = strided_bounds<1>({length}, {2});
#else
    auto bounds = strided_bounds<1>(multi_span_index<1>{length}, multi_span_index<1>{2});
#endif
    strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds);

    EXPECT_TRUE(strided.size() == length);
    EXPECT_TRUE(strided.bounds().index_bounds()[0] == length);
    for (auto i = 0; i < strided.size(); ++i) {
        EXPECT_TRUE(strided[i] == av[2 * i + 1]);
    }

    int idx = 0;
    for (auto num : strided) {
        EXPECT_TRUE(num == av[2 * idx + 1]);
        idx++;
    }
}

GSL_SUPPRESS(con.4) // NO-FORMAT: attribute
GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute // TODO: does not work
void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av)
{
    const int expected[6] = {2, 3, 10, 11, 18, 19};
    auto section = av.section({0, 1, 0}, {3, 1, 2});

    for (auto i = 0; i < section.extent<0>(); ++i) {
        for (auto j = 0; j < section.extent<1>(); ++j)
            for (auto k = 0; k < section.extent<2>(); ++k) {
                auto idx = multi_span_index<3>{i, j, k}; // avoid braces in the EXPECT_TRUE macro
                EXPECT_TRUE(section[idx] == expected[2 * i + 2 * j + k]);
            }
    }

    for (auto i = 0; i < section.extent<0>(); ++i) {
        for (auto j = 0; j < section.extent<1>(); ++j)
            for (auto k = 0; k < section.extent<2>(); ++k)
                EXPECT_TRUE(section[i][j][k] == expected[2 * i + 2 * j + k]);
    }

    int i = 0;
    for (const auto num : section) {
        EXPECT_TRUE(num == expected[i]);
        i++;
    }
}

}

TEST(strided_span_tests, span_section_test)
{
    int a[30][4][5];

    const auto av = as_multi_span(a);
    const auto sub = av.section({15, 0, 0}, gsl::multi_span_index<3>{2, 2, 2});
    const auto subsub = sub.section({1, 0, 0}, gsl::multi_span_index<3>{1, 1, 1});
    (void) subsub;
}

TEST(strided_span_tests, span_section)
{
    std::vector<int> data(5 * 10);
    std::iota(begin(data), end(data), 0);
    const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());

    const strided_span<int, 2> av_section_1 = av.section({1, 2}, {3, 4});
    EXPECT_TRUE(!av_section_1.empty());
    EXPECT_TRUE((av_section_1[{0, 0}] == 12));
    EXPECT_TRUE((av_section_1[{0, 1}] == 13));
    EXPECT_TRUE((av_section_1[{1, 0}] == 22));
    EXPECT_TRUE((av_section_1[{2, 3}] == 35));

    const strided_span<int, 2> av_section_2 = av_section_1.section({1, 2}, {2, 2});
    EXPECT_TRUE(!av_section_2.empty());
    EXPECT_TRUE((av_section_2[{0, 0}] == 24));
    EXPECT_TRUE((av_section_2[{0, 1}] == 25));
    EXPECT_TRUE((av_section_2[{1, 0}] == 34));
}

TEST(strided_span_tests, strided_span_constructors)
{
    // EXPECT_TRUE stride constructor
    {
        int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        const int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        strided_span<int, 1> sav1{arr, {{9}, {1}}}; // T -> T
        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{9});
        EXPECT_TRUE(sav1.bounds().stride() == 1);
        EXPECT_TRUE(sav1[0] == 1);
        EXPECT_TRUE(sav1[8] == 9);

        strided_span<const int, 1> sav2{carr, {{4}, {2}}}; // const T -> const T
        EXPECT_TRUE(sav2.bounds().index_bounds() == multi_span_index<1>{4});
        EXPECT_TRUE(sav2.bounds().strides() == multi_span_index<1>{2});
        EXPECT_TRUE(sav2[0] == 1);
        EXPECT_TRUE(sav2[3] == 7);

        strided_span<int, 2> sav3{arr, {{2, 2}, {6, 2}}}; // T -> const T
        EXPECT_TRUE((sav3.bounds().index_bounds() == multi_span_index<2>{2, 2}));
        EXPECT_TRUE((sav3.bounds().strides() == multi_span_index<2>{6, 2}));
        EXPECT_TRUE((sav3[{0, 0}]) == 1);
        EXPECT_TRUE((sav3[{0, 1}]) ==  3);
        EXPECT_TRUE((sav3[{1, 0}]) == 7);
    }

    // EXPECT_TRUE multi_span constructor
    {
        int arr[] = {1, 2};

        // From non-cv-qualified source
        {
            const multi_span<int> src = arr;

            strided_span<int, 1> sav{src, {2, 1}};
            EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav[1] == 2);

#if defined(_MSC_VER) && _MSC_VER > 1800
            // strided_span<const int, 1> sav_c{ {src}, {2, 1} };
            strided_span<const int, 1> sav_c{multi_span<const int>{src},
                                             strided_bounds<1>{2, 1}};
#else
            strided_span<const int, 1> sav_c{multi_span<const int>{src},
                                             strided_bounds<1>{2, 1}};
#endif
            EXPECT_TRUE(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_c.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_c[1] == 2);

#if defined(_MSC_VER) && _MSC_VER > 1800
            strided_span<volatile int, 1> sav_v{src, {2, 1}};
#else
            strided_span<volatile int, 1> sav_v{multi_span<volatile int>{src},
                                                strided_bounds<1>{2, 1}};
#endif
            EXPECT_TRUE(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_v.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_v[1] == 2);

#if defined(_MSC_VER) && _MSC_VER > 1800
            strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
#else
            strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                       strided_bounds<1>{2, 1}};
#endif
            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_cv[1] == 2);
        }

        // From const-qualified source
        {
            const multi_span<const int> src{arr};

            strided_span<const int, 1> sav_c{src, {2, 1}};
            EXPECT_TRUE(sav_c.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_c.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_c[1] == 2);

#if defined(_MSC_VER) && _MSC_VER > 1800
            strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
#else
            strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                       strided_bounds<1>{2, 1}};
#endif

            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_cv[1] == 2);
        }

        // From volatile-qualified source
        {
            const multi_span<volatile int> src{arr};

            strided_span<volatile int, 1> sav_v{src, {2, 1}};
            EXPECT_TRUE(sav_v.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_v.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_v[1] == 2);

#if defined(_MSC_VER) && _MSC_VER > 1800
            strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
#else
            strided_span<const volatile int, 1> sav_cv{multi_span<const volatile int>{src},
                                                       strided_bounds<1>{2, 1}};
#endif
            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_cv[1] == 2);
        }

        // From cv-qualified source
        {
            const multi_span<const volatile int> src{arr};

            strided_span<const volatile int, 1> sav_cv{src, {2, 1}};
            EXPECT_TRUE(sav_cv.bounds().index_bounds() == multi_span_index<1>{2});
            EXPECT_TRUE(sav_cv.bounds().strides() == multi_span_index<1>{1});
            EXPECT_TRUE(sav_cv[1] == 2);
        }
    }

    // EXPECT_TRUE const-casting constructor
    {
        int arr[2] = {4, 5};

        const multi_span<int, 2> av(arr, 2);
        multi_span<const int, 2> av2{av};
        EXPECT_TRUE(av2[1] == 5);

        static_assert(
            std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value,
            "ctor is not implicit!");

        const strided_span<int, 1> src{arr, {2, 1}};
        strided_span<const int, 1> sav{src};
        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav.bounds().stride() == 1);
        EXPECT_TRUE(sav[1] == 5);

        static_assert(
            std::is_convertible<const strided_span<int, 1>, strided_span<const int, 1>>::value,
            "ctor is not implicit!");
    }

    // EXPECT_TRUE copy constructor
    {
        int arr1[2] = {3, 4};
        const strided_span<int, 1> src1{arr1, {2, 1}};
        strided_span<int, 1> sav1{src1};

        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav1.bounds().stride() == 1);
        EXPECT_TRUE(sav1[0] == 3);

        int arr2[6] = {1, 2, 3, 4, 5, 6};
        const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
        strided_span<const int, 2> sav2{src2};
        EXPECT_TRUE((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
        EXPECT_TRUE((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
        EXPECT_TRUE((sav2[{0, 0}]) ==  1);
        EXPECT_TRUE((sav2[{2, 0}]) == 5);
    }

    // EXPECT_TRUE const-casting assignment operator
    {
        int arr1[2] = {1, 2};
        int arr2[6] = {3, 4, 5, 6, 7, 8};

        const strided_span<int, 1> src{arr1, {{2}, {1}}};
        strided_span<const int, 1> sav{arr2, {{3}, {2}}};
        strided_span<const int, 1>& sav_ref = (sav = src);
        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav.bounds().strides() == multi_span_index<1>{1});
        EXPECT_TRUE(sav[0] == 1);
        EXPECT_TRUE(&sav_ref == &sav);
    }

    // EXPECT_TRUE copy assignment operator
    {
        int arr1[2] = {3, 4};
        int arr1b[1] = {0};
        const strided_span<int, 1> src1{arr1, {2, 1}};
        strided_span<int, 1> sav1{arr1b, {1, 1}};
        strided_span<int, 1>& sav1_ref = (sav1 = src1);
        EXPECT_TRUE(sav1.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav1.bounds().strides() == multi_span_index<1>{1});
        EXPECT_TRUE(sav1[0] == 3);
        EXPECT_TRUE(&sav1_ref == &sav1);

        const int arr2[6] = {1, 2, 3, 4, 5, 6};
        const int arr2b[1] = {0};
        const strided_span<const int, 2> src2{arr2, {{3, 2}, {2, 1}}};
        strided_span<const int, 2> sav2{arr2b, {{1, 1}, {1, 1}}};
        strided_span<const int, 2>& sav2_ref = (sav2 = src2);
        EXPECT_TRUE((sav2.bounds().index_bounds() == multi_span_index<2>{3, 2}));
        EXPECT_TRUE((sav2.bounds().strides() == multi_span_index<2>{2, 1}));
        EXPECT_TRUE((sav2[{0, 0}] == 1));
        EXPECT_TRUE((sav2[{2, 0}] == 5));
        EXPECT_TRUE(&sav2_ref == &sav2);
    }
}

TEST(strided_span_tests, strided_span_slice)
{
    std::vector<int> data(5 * 10);
    std::iota(begin(data), end(data), 0);
    const multi_span<int, 5, 10> src =
        as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>());

    const strided_span<int, 2> sav{src, {{5, 10}, {10, 1}}};
#ifdef CONFIRM_COMPILATION_ERRORS
    const strided_span<const int, 2> csav{{src}, {{5, 10}, {10, 1}}};
#endif
    const strided_span<const int, 2> csav{multi_span<const int, 5, 10>{src},
                                          {{5, 10}, {10, 1}}};

    strided_span<int, 1> sav_sl = sav[2];
    EXPECT_TRUE(sav_sl[0] == 20);
    EXPECT_TRUE(sav_sl[9] == 29);

    strided_span<const int, 1> csav_sl = sav[3];
    EXPECT_TRUE(csav_sl[0] == 30);
    EXPECT_TRUE(csav_sl[9] == 39);

    EXPECT_TRUE(sav[4][0] == 40);
    EXPECT_TRUE(sav[4][9] == 49);
}

TEST(strided_span_tests, strided_span_column_major)
{
    // strided_span may be used to accommodate more peculiar
    // use cases, such as column-major multidimensional array
    // (aka. "FORTRAN" layout).

    int cm_array[3 * 5] = {1, 4, 7, 10, 13, 2, 5, 8, 11, 14, 3, 6, 9, 12, 15};
    strided_span<int, 2> cm_sav{cm_array, {{5, 3}, {1, 5}}};

    // Accessing elements
    EXPECT_TRUE((cm_sav[{0, 0}] == 1));
    EXPECT_TRUE((cm_sav[{0, 1}] == 2));
    EXPECT_TRUE((cm_sav[{1, 0}] == 4));
    EXPECT_TRUE((cm_sav[{4, 2}] == 15));

    // Slice
    strided_span<int, 1> cm_sl = cm_sav[3];

    EXPECT_TRUE(cm_sl[0] == 10);
    EXPECT_TRUE(cm_sl[1] == 11);
    EXPECT_TRUE(cm_sl[2] == 12);

    // Section
    strided_span<int, 2> cm_sec = cm_sav.section({2, 1}, {3, 2});

    EXPECT_TRUE((cm_sec.bounds().index_bounds() == multi_span_index<2>{3, 2}));
    EXPECT_TRUE((cm_sec[{0, 0}] == 8));
    EXPECT_TRUE((cm_sec[{0, 1}] == 9));
    EXPECT_TRUE((cm_sec[{1, 0}] == 11));
    EXPECT_TRUE((cm_sec[{2, 1}] == 15));
}

TEST(strided_span_tests, strided_span_bounds)
{
    int arr[] = {0, 1, 2, 3};
    multi_span<int> av(arr);

    std::set_terminate([] {
        std::cerr << "Expected Death. strided_span_bounds";
        std::abort();
    });

    {
        // incorrect sections

        EXPECT_DEATH(av.section(0, 0)[0], deathstring);
        EXPECT_DEATH(av.section(1, 0)[0], deathstring);
        EXPECT_DEATH(av.section(1, 1)[1], deathstring);

        EXPECT_DEATH(av.section(2, 5), deathstring);
        EXPECT_DEATH(av.section(5, 2), deathstring);
        EXPECT_DEATH(av.section(5, 0), deathstring);
        EXPECT_DEATH(av.section(0, 5), deathstring);
        EXPECT_DEATH(av.section(5, 5), deathstring);
    }

    {
        // zero stride
        strided_span<int, 1> sav{av, {{4}, {}}};
        EXPECT_TRUE(sav[0] == 0);
        EXPECT_TRUE(sav[3] == 0);
        EXPECT_DEATH(sav[4], deathstring);
    }

    {
        // zero extent
        strided_span<int, 1> sav{av, {{}, {1}}};
        EXPECT_DEATH(sav[0], deathstring);
    }

    {
        // zero extent and stride
        strided_span<int, 1> sav{av, {{}, {}}};
        EXPECT_DEATH(sav[0], deathstring);
    }

    {
        // strided array ctor with matching strided bounds
        strided_span<int, 1> sav{arr, {4, 1}};
        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{4});
        EXPECT_TRUE(sav[3] == 3);
        EXPECT_DEATH(sav[4], deathstring);
    }

    {
        // strided array ctor with smaller strided bounds
        strided_span<int, 1> sav{arr, {2, 1}};
        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav[1] == 1);
        EXPECT_DEATH(sav[2], deathstring);
    }

    {
        // strided array ctor with fitting irregular bounds
        strided_span<int, 1> sav{arr, {2, 3}};
        EXPECT_TRUE(sav.bounds().index_bounds() == multi_span_index<1>{2});
        EXPECT_TRUE(sav[0] == 0);
        EXPECT_TRUE(sav[1] == 3);
        EXPECT_DEATH(sav[2], deathstring);
    }

    {
        // bounds cross data boundaries - from static arrays
        EXPECT_DEATH((strided_span<int, 1>{arr, {3, 2}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{arr, {3, 3}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{arr, {4, 5}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{arr, {5, 1}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{arr, {5, 5}}), deathstring);
    }

    {
        // bounds cross data boundaries - from array view
        EXPECT_DEATH((strided_span<int, 1>{av, {3, 2}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av, {3, 3}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av, {4, 5}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av, {5, 1}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av, {5, 5}}), deathstring);
    }

    {
        // bounds cross data boundaries - from dynamic arrays
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {3, 2}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {3, 3}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {4, 5}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {5, 1}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 4, {5, 5}}), deathstring);
        EXPECT_DEATH((strided_span<int, 1>{av.data(), 2, {2, 2}}), deathstring);
    }

#ifdef CONFIRM_COMPILATION_ERRORS
    {
        strided_span<int, 1> sav0{av.data(), {3, 2}};
        strided_span<int, 1> sav1{arr, {1}};
        strided_span<int, 1> sav2{arr, {1, 1, 1}};
        strided_span<int, 1> sav3{av, {1}};
        strided_span<int, 1> sav4{av, {1, 1, 1}};
        strided_span<int, 2> sav5{av.as_multi_span(dim<2>(), dim<2>()), {1}};
        strided_span<int, 2> sav6{av.as_multi_span(dim<2>(), dim<2>()), {1, 1, 1}};
        strided_span<int, 2> sav7{av.as_multi_span(dim<2>(), dim<2>()),
                                  {{1, 1}, {1, 1}, {1, 1}}};

        multi_span_index<1> index{0, 1};
        strided_span<int, 1> sav8{arr, {1, {1, 1}}};
        strided_span<int, 1> sav9{arr, {{1, 1}, {1, 1}}};
        strided_span<int, 1> sav10{av, {1, {1, 1}}};
        strided_span<int, 1> sav11{av, {{1, 1}, {1, 1}}};
        strided_span<int, 2> sav12{av.as_multi_span(dim<2>(), dim<2>()), {{1}, {1}}};
        strided_span<int, 2> sav13{av.as_multi_span(dim<2>(), dim<2>()), {{1}, {1, 1, 1}}};
        strided_span<int, 2> sav14{av.as_multi_span(dim<2>(), dim<2>()), {{1, 1, 1}, {1}}};
    }
#endif
}

TEST(strided_span_tests, strided_span_type_conversion)
{
    int arr[] = {0, 1, 2, 3};
    multi_span<int> av(arr);

    std::set_terminate([] {
        std::cerr << "Expected Death. strided_span_type_conversion";
        std::abort();
    });

    {
        strided_span<int, 1> sav{av.data(), av.size(), {av.size() / 2, 2}};
#ifdef CONFIRM_COMPILATION_ERRORS
        strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>();
#endif
    }
    {
        strided_span<int, 1> sav{av, {av.size() / 2, 2}};
#ifdef CONFIRM_COMPILATION_ERRORS
        strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>();
#endif
    }

    multi_span<const byte, dynamic_range> bytes = as_bytes(av);

    // retype strided array with regular strides - from raw data
    {
        strided_bounds<2> bounds{{2, bytes.size() / 4}, {bytes.size() / 2, 1}};
        strided_span<const byte, 2> sav2{bytes.data(), bytes.size(), bounds};
        strided_span<const int, 2> sav3 = sav2.as_strided_span<const int>();
        EXPECT_TRUE(sav3[0][0] == 0);
        EXPECT_TRUE(sav3[1][0] == 2);
        EXPECT_DEATH(sav3[1][1], deathstring);
        EXPECT_DEATH(sav3[0][1], deathstring);
    }

    // retype strided array with regular strides - from multi_span
    {
        strided_bounds<2> bounds{{2, bytes.size() / 4}, {bytes.size() / 2, 1}};
        multi_span<const byte, 2, dynamic_range> bytes2 =
            as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
        strided_span<const byte, 2> sav2{bytes2, bounds};
        strided_span<int, 2> sav3 = sav2.as_strided_span<int>();
        EXPECT_TRUE(sav3[0][0] == 0);
        EXPECT_TRUE(sav3[1][0] == 2);
        EXPECT_DEATH(sav3[1][1], deathstring);
        EXPECT_DEATH(sav3[0][1], deathstring);
    }

    // retype strided array with not enough elements - last dimension of the array is too small
    {
        strided_bounds<2> bounds{{4, 2}, {4, 1}};
        multi_span<const byte, 2, dynamic_range> bytes2 =
            as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
        strided_span<const byte, 2> sav2{bytes2, bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }

    // retype strided array with not enough elements - strides are too small
    {
        strided_bounds<2> bounds{{4, 2}, {2, 1}};
        multi_span<const byte, 2, dynamic_range> bytes2 =
            as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
        strided_span<const byte, 2> sav2{bytes2, bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }

    // retype strided array with not enough elements - last dimension does not divide by the new
    // typesize
    {
        strided_bounds<2> bounds{{2, 6}, {4, 1}};
        multi_span<const byte, 2, dynamic_range> bytes2 =
            as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
        strided_span<const byte, 2> sav2{bytes2, bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }

    // retype strided array with not enough elements - strides does not divide by the new
    // typesize
    {
        strided_bounds<2> bounds{{2, 1}, {6, 1}};
        multi_span<const byte, 2, dynamic_range> bytes2 =
            as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2));
        strided_span<const byte, 2> sav2{bytes2, bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }

    // retype strided array with irregular strides - from raw data
    {
        strided_bounds<1> bounds{bytes.size() / 2, 2};
        strided_span<const byte, 1> sav2{bytes.data(), bytes.size(), bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }

    // retype strided array with irregular strides - from multi_span
    {
        strided_bounds<1> bounds{bytes.size() / 2, 2};
        strided_span<const byte, 1> sav2{bytes, bounds};
        EXPECT_DEATH(sav2.as_strided_span<int>(), deathstring);
    }
}

TEST(strided_span_tests, empty_strided_spans)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. empty_strided_spans";
        std::abort();
    });

    {
        multi_span<int, 0> empty_av(nullptr);
        strided_span<int, 1> empty_sav{empty_av, {0, 1}};

        EXPECT_TRUE(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
        EXPECT_TRUE(empty_sav.empty());
        EXPECT_DEATH(empty_sav[0], deathstring);
        EXPECT_DEATH(empty_sav.begin()[0], deathstring);
        EXPECT_DEATH(empty_sav.cbegin()[0], deathstring);

        for (const auto& v : empty_sav) {
            (void) v;
            EXPECT_TRUE(false);
        }
    }

    {
        strided_span<int, 1> empty_sav{nullptr, 0, {0, 1}};

        EXPECT_TRUE(empty_sav.bounds().index_bounds() == multi_span_index<1>{0});
        EXPECT_DEATH(empty_sav[0], deathstring);
        EXPECT_DEATH(empty_sav.begin()[0], deathstring);
        EXPECT_DEATH(empty_sav.cbegin()[0], deathstring);

        for (const auto& v : empty_sav) {
            (void) v;
            EXPECT_TRUE(false);
        }
    }
}

TEST(strided_span_tests, strided_span_section_iteration)
{
    int arr[8] = {4, 0, 5, 1, 6, 2, 7, 3};

    // static bounds
    {
        multi_span<int, 8> av(arr, 8);
        iterate_every_other_element(av);
    }

    // dynamic bounds
    {
        multi_span<int, dynamic_range> av(arr, 8);
        iterate_every_other_element(av);
    }
}

TEST(strided_span_tests, dynamic_strided_span_section_iteration)
{
    auto arr = new int[8];
    for (int i = 0; i < 4; ++i) {
        arr[2 * i] = 4 + i;
        arr[2 * i + 1] = i;
    }

    auto av = as_multi_span(arr, 8);
    iterate_every_other_element(av);

    delete[] arr;
}

TEST(strided_span_tests, strided_span_section_iteration_3d)
{
    int arr[3][4][2]{};
    for (auto i = 0; i < 3; ++i) {
        for (auto j = 0; j < 4; ++j)
            for (auto k = 0; k < 2; ++k) arr[i][j][k] = 8 * i + 2 * j + k;
    }

    {
        multi_span<int, 3, 4, 2> av = arr;
        iterate_second_slice(av);
    }
}

TEST(strided_span_tests, dynamic_strided_span_section_iteration_3d)
{
    const auto height = 12, width = 2;
    const auto size = height * width;

    auto arr = new int[static_cast<std::size_t>(size)];
    for (auto i = 0; i < size; ++i) {
        arr[i] = i;
    }

    {
        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>());
        iterate_second_slice(av);
    }

    {
        auto av = as_multi_span(as_multi_span(arr, 24), dim(3), dim<4>(), dim<2>());
        iterate_second_slice(av);
    }

    {
        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim(4), dim<2>());
        iterate_second_slice(av);
    }

    {
        auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim(2));
        iterate_second_slice(av);
    }
    delete[] arr;
}

TEST(strided_span_tests, strided_span_conversion)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. strided_span_conversion";
        std::abort();
    });

    // get an multi_span of 'c' values from the list of X's

    struct X
    {
        int a;
        int b;
        int c;
    };

    X arr[4] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}};

    int s = sizeof(int) / sizeof(byte);
    auto d2 = 3 * s;
    auto d1 = narrow_cast<int>(sizeof(int)) * 12 / d2;

    // convert to 4x12 array of bytes
    auto av = as_multi_span(as_bytes(as_multi_span(&arr[0], 4)), dim(d1), dim(d2));

    EXPECT_TRUE(av.bounds().index_bounds()[0] == 4);
    EXPECT_TRUE(av.bounds().index_bounds()[1] == 12);

    // get the last 4 columns
    auto section = av.section({0, 2 * s}, {4, s}); // { { arr[0].c[0], arr[0].c[1], arr[0].c[2],
                                                   // arr[0].c[3] } , { arr[1].c[0], ... } , ...
                                                   // }

    // convert to array 4x1 array of integers
    auto cs = section.as_strided_span<int>(); // { { arr[0].c }, {arr[1].c } , ... }

    EXPECT_TRUE(cs.bounds().index_bounds()[0] == 4);
    EXPECT_TRUE(cs.bounds().index_bounds()[1] == 1);

    // transpose to 1x4 array
    strided_bounds<2> reverse_bounds{
        {cs.bounds().index_bounds()[1], cs.bounds().index_bounds()[0]},
        {cs.bounds().strides()[1], cs.bounds().strides()[0]}};

    strided_span<int, 2> transposed{cs.data(), cs.bounds().total_size(), reverse_bounds};

    // slice to get a one-dimensional array of c's
    strided_span<int, 1> result = transposed[0];

    EXPECT_TRUE(result.bounds().index_bounds()[0] == 4);
    EXPECT_DEATH(result.bounds().index_bounds()[1], deathstring);

    int i = 0;
    for (auto& num : result) {
        EXPECT_TRUE(num == arr[i].c);
        i++;
    }
}


================================================
FILE: examples/libraries/GSL/tests/string_span_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_assert>  // for Expects, fail_fast (ptr only)
#include <gsl/pointers>    // for owner
#include <gsl/span>        // for span, dynamic_extent
#include <gsl/string_span> // for basic_string_span, operator==, ensure_z

#include <algorithm>   // for move, find
#include <cstddef>     // for size_t
#include <map>         // for map
#include <string>      // for basic_string, string, char_traits, operat...
#include <type_traits> // for remove_reference<>::type
#include <vector>      // for vector, allocator

using namespace std;
using namespace gsl;

namespace
{
static constexpr char deathstring[] = "Expected Death";
}
// Generic string functions

namespace generic
{

template <typename CharT>
auto strlen(const CharT* s)
{
    auto p = s;
    while (*p) ++p;
    return p - s;
}

template <typename CharT>
auto strnlen(const CharT* s, std::size_t n)
{
    return std::find(s, s + n, CharT{0}) - s;
}

} // namespace generic

namespace
{

template <typename T>
T move_wrapper(T&& t)
{
    return std::move(t);
}

// not used otherwise
#ifdef CONFIRM_COMPILATION_ERRORS

template <class T>
T create()
{
    return T{};
}

template <class T>
void use(basic_string_span<T, gsl::dynamic_extent>)
{
}
#endif

czstring_span<> CreateTempName(string_span<> span)
{
    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
        span[0] = 't';
        span[1] = 'm';
        span[2] = 'p';
        last = 3;
    }
    span[last] = '\0';

    auto ret = span.subspan(0, 4);
    return {ret};
}

cwzstring_span<> CreateTempNameW(wstring_span<> span)
{
    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
        span[0] = L't';
        span[1] = L'm';
        span[2] = L'p';
        last = 3;
    }
    span[last] = L'\0';

    auto ret = span.subspan(0, 4);
    return {ret};
}

cu16zstring_span<> CreateTempNameU16(u16string_span<> span)
{
    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
        span[0] = u't';
        span[1] = u'm';
        span[2] = u'p';
        last = 3;
    }
    span[last] = u'\0';

    auto ret = span.subspan(0, 4);
    return {ret};
}

cu32zstring_span<> CreateTempNameU32(u32string_span<> span)
{
    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
        span[0] = U't';
        span[1] = U'm';
        span[2] = U'p';
        last = 3;
    }
    span[last] = U'\0';

    auto ret = span.subspan(0, 4);
    return {ret};
}
} // namespace

TEST(string_span_tests, TestLiteralConstruction)
{
    cwstring_span<> v = ensure_z(L"Hello");
    EXPECT_TRUE(5 == v.length());

#ifdef CONFIRM_COMPILATION_ERRORS
    wstring_span<> v2 = ensure0(L"Hello");
#endif
}

TEST(string_span_tests, TestConstructFromStdString)
{
    std::string s = "Hello there world";
    cstring_span<> v = s;
    EXPECT_TRUE(v.length() == static_cast<cstring_span<>::size_type>(s.length()));
}

TEST(string_span_tests, TestConstructFromStdVector)
{
    std::vector<char> vec(5, 'h');
    string_span<> v{vec};
    EXPECT_TRUE(v.length() == static_cast<string_span<>::size_type>(vec.size()));
}

TEST(string_span_tests, TestStackArrayConstruction)
{
    wchar_t stack_string[] = L"Hello";

    {
        cwstring_span<> v = ensure_z(stack_string);
        EXPECT_TRUE(v.length() == 5);
    }

    {
        cwstring_span<> v = stack_string;
        EXPECT_TRUE(v.length() == 5);
    }

    {
        wstring_span<> v = ensure_z(stack_string);
        EXPECT_TRUE(v.length() == 5);
    }

    {
        wstring_span<> v = stack_string;
        EXPECT_TRUE(v.length() == 5);
    }
}

TEST(string_span_tests, TestConstructFromConstCharPointer)
{
    const char* s = "Hello";
    cstring_span<> v = ensure_z(s);
    EXPECT_TRUE(v.length() == 5);
}

TEST(string_span_tests, TestConversionToConst)
{
    char stack_string[] = "Hello";
    string_span<> v = ensure_z(stack_string);
    cstring_span<> v2 = v;
    EXPECT_TRUE(v.length() == v2.length());
}

TEST(string_span_tests, TestConversionFromConst)
{
    char stack_string[] = "Hello";
    cstring_span<> v = ensure_z(stack_string);
    (void) v;
#ifdef CONFIRM_COMPILATION_ERRORS
    string_span<> v2 = v;
    string_span<> v3 = "Hello";
#endif
}

TEST(string_span_tests, TestToString)
{
    auto s = gsl::to_string(cstring_span<>{});
    EXPECT_TRUE(s.length() == static_cast<size_t>(0));

    char stack_string[] = "Hello";
    cstring_span<> v = ensure_z(stack_string);
    auto s2 = gsl::to_string(v);
    EXPECT_TRUE(static_cast<cstring_span<>::size_type>(s2.length()) == v.length());
    EXPECT_TRUE(s2.length() == static_cast<size_t>(5));
}

TEST(string_span_tests, TestToBasicString)
{
    auto s = gsl::to_basic_string<char, std::char_traits<char>, ::std::allocator<char>>(
        cstring_span<>{});
    EXPECT_TRUE(s.length() == static_cast<size_t>(0));

    char stack_string[] = "Hello";
    cstring_span<> v = ensure_z(stack_string);
    auto s2 = gsl::to_basic_string<char, std::char_traits<char>, ::std::allocator<char>>(v);
    EXPECT_TRUE(static_cast<cstring_span<>::size_type>(s2.length()) == v.length());
    EXPECT_TRUE(s2.length() == static_cast<size_t>(5));
}

TEST(string_span_tests, EqualityAndImplicitConstructors)
{
    {
        cstring_span<> span = "Hello";
        cstring_span<> span1;

        // comparison to empty span
        EXPECT_TRUE(span1 != span);
        EXPECT_TRUE(span != span1);
    }

    {
        cstring_span<> span = "Hello";
        cstring_span<> span1 = "Hello1";

        // comparison to different span
        EXPECT_TRUE(span1 != span);
        EXPECT_TRUE(span != span1);
    }

    {
        cstring_span<> span = "Hello";

        const char ar[] = {'H', 'e', 'l', 'l', 'o'};
        const char ar1[] = "Hello";
        const char ar2[10] = "Hello";
        const char* ptr = "Hello";
        const std::string str = "Hello";
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        gsl::span<const char> sp = ensure_z("Hello");

        // comparison to  literal
        EXPECT_TRUE(span == cstring_span<>("Hello"));

        // comparison to static array with no null termination
        EXPECT_TRUE(span == cstring_span<>(ar));

        // comparison to static array with null at the end
        EXPECT_TRUE(span == cstring_span<>(ar1));

        // comparison to static array with null in the middle
        EXPECT_TRUE(span == cstring_span<>(ar2));

        // comparison to null-terminated c string
        EXPECT_TRUE(span == cstring_span<>(ptr, 5));

        // comparison to string
        EXPECT_TRUE(span == cstring_span<>(str));

        // comparison to vector of charaters with no null termination
        EXPECT_TRUE(span == cstring_span<>(vec));

        // comparison to span
        EXPECT_TRUE(span == cstring_span<>(sp));

        // comparison to string_span
        EXPECT_TRUE(span == span);
    }

    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};

        string_span<> span = ar;

        char ar1[] = "Hello";
        char ar2[10] = "Hello";
        char* ptr = ar;
        std::string str = "Hello";
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        gsl::span<char> sp = ensure_z(ar1);

        // comparison to static array with no null termination
        EXPECT_TRUE(span == string_span<>(ar));

        // comparison to static array with null at the end
        EXPECT_TRUE(span == string_span<>(ar1));

        // comparison to static array with null in the middle
        EXPECT_TRUE(span == string_span<>(ar2));

        // comparison to null-terminated c string
        EXPECT_TRUE(span == string_span<>(ptr, 5));

        // comparison to string
        EXPECT_TRUE(span == string_span<>(str));

        // comparison to vector of charaters with no null termination
        EXPECT_TRUE(span == string_span<>(vec));

        // comparison to span
        EXPECT_TRUE(span == string_span<>(sp));

        // comparison to string_span
        EXPECT_TRUE(span == span);
    }

    {
        const char ar[] = {'H', 'e', 'l', 'l', 'o'};
        const char ar1[] = "Hello";
        const char ar2[10] = "Hello";
        const std::string str = "Hello";
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const gsl::span<const char> sp = ensure_z("Hello");

        cstring_span<> span = "Hello";

        // const span, const other type

        EXPECT_TRUE(span == "Hello");
        EXPECT_TRUE(span == ar);
        EXPECT_TRUE(span == ar1);
        EXPECT_TRUE(span == ar2);
#ifdef CONFIRM_COMPILATION_ERRORS
        const char* ptr = "Hello";
        EXPECT_TRUE(span == ptr);
#endif
        EXPECT_TRUE(span == str);
        EXPECT_TRUE(span == vec);
        EXPECT_TRUE(span == sp);

        EXPECT_TRUE("Hello" == span);
        EXPECT_TRUE(ar == span);
        EXPECT_TRUE(ar1 == span);
        EXPECT_TRUE(ar2 == span);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(ptr == span);
#endif
        EXPECT_TRUE(str == span);
        EXPECT_TRUE(vec == span);
        EXPECT_TRUE(sp == span);

        // const span, non-const other type

        char _ar[] = {'H', 'e', 'l', 'l', 'o'};
        char _ar1[] = "Hello";
        char _ar2[10] = "Hello";
        char* _ptr = _ar;
        std::string _str = "Hello";
        std::vector<char> _vec = {'H', 'e', 'l', 'l', 'o'};
        gsl::span<char> _sp{_ar, 5};

        EXPECT_TRUE(span == _ar);
        EXPECT_TRUE(span == _ar1);
        EXPECT_TRUE(span == _ar2);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(span == _ptr);
#endif
        EXPECT_TRUE(span == _str);
        EXPECT_TRUE(span == _vec);
        EXPECT_TRUE(span == _sp);

        EXPECT_TRUE(_ar == span);
        EXPECT_TRUE(_ar1 == span);
        EXPECT_TRUE(_ar2 == span);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(_ptr == span);
#endif
        EXPECT_TRUE(_str == span);
        EXPECT_TRUE(_vec == span);
        EXPECT_TRUE(_sp == span);

        string_span<> _span{_ptr, 5};

        // non-const span, non-const other type

        EXPECT_TRUE(_span == _ar);
        EXPECT_TRUE(_span == _ar1);
        EXPECT_TRUE(_span == _ar2);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(_span == _ptr);
#endif
        EXPECT_TRUE(_span == _str);
        EXPECT_TRUE(_span == _vec);
        EXPECT_TRUE(_span == _sp);

        EXPECT_TRUE(_ar == _span);
        EXPECT_TRUE(_ar1 == _span);
        EXPECT_TRUE(_ar2 == _span);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(_ptr == _span);
#endif
        EXPECT_TRUE(_str == _span);
        EXPECT_TRUE(_vec == _span);
        EXPECT_TRUE(_sp == _span);

        // non-const span, const other type

        EXPECT_TRUE(_span == "Hello");
        EXPECT_TRUE(_span == ar);
        EXPECT_TRUE(_span == ar1);
        EXPECT_TRUE(_span == ar2);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(_span == ptr);
#endif
        EXPECT_TRUE(_span == str);
        EXPECT_TRUE(_span == vec);
        EXPECT_TRUE(_span == sp);

        EXPECT_TRUE("Hello" == _span);
        EXPECT_TRUE(ar == _span);
        EXPECT_TRUE(ar1 == _span);
        EXPECT_TRUE(ar2 == _span);
#ifdef CONFIRM_COMPILATION_ERRORS
        EXPECT_TRUE(ptr == _span);
#endif
        EXPECT_TRUE(str == _span);
        EXPECT_TRUE(vec == _span);
        EXPECT_TRUE(sp == _span);

        // two spans

        EXPECT_TRUE(_span == span);
        EXPECT_TRUE(span == _span);
    }

    {
        std::vector<char> str1 = {'H', 'e', 'l', 'l', 'o'};
        cstring_span<> span1 = str1;
        std::vector<char> str2 = std::move(str1);
        cstring_span<> span2 = str2;

        // comparison of spans from the same vector before and after move (ok)
        EXPECT_TRUE(span1 == span2);
    }
}

TEST(string_span_tests, ComparisonAndImplicitConstructors)
{
    {
        cstring_span<> span = "Hello";

        const char ar[] = {'H', 'e', 'l', 'l', 'o'};
        const char ar1[] = "Hello";
        const char ar2[10] = "Hello";
        const char* ptr = "Hello";
        const std::string str = "Hello";
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};

        // comparison to  literal
        EXPECT_TRUE(span < cstring_span<>("Helloo"));
        EXPECT_TRUE(span > cstring_span<>("Hell"));

        // comparison to static array with no null termination
        EXPECT_TRUE(span >= cstring_span<>(ar));

        // comparison to static array with null at the end
        EXPECT_TRUE(span <= cstring_span<>(ar1));

        // comparison to static array with null in the middle
        EXPECT_TRUE(span >= cstring_span<>(ar2));

        // comparison to null-terminated c string
        EXPECT_TRUE(span <= cstring_span<>(ptr, 5));

        // comparison to string
        EXPECT_TRUE(span >= cstring_span<>(str));

        // comparison to vector of charaters with no null termination
        EXPECT_TRUE(span <= cstring_span<>(vec));
    }

    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};

        string_span<> span = ar;

        char larr[] = "Hell";
        char rarr[] = "Helloo";

        char ar1[] = "Hello";
        char ar2[10] = "Hello";
        char* ptr = ar;
        std::string str = "Hello";
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};

        // comparison to static array with no null termination
        EXPECT_TRUE(span <= string_span<>(ar));
        EXPECT_TRUE(span < string_span<>(rarr));
        EXPECT_TRUE(span > string_span<>(larr));

        // comparison to static array with null at the end
        EXPECT_TRUE(span >= string_span<>(ar1));

        // comparison to static array with null in the middle
        EXPECT_TRUE(span <= string_span<>(ar2));

        // comparison to null-terminated c string
        EXPECT_TRUE(span >= string_span<>(ptr, 5));

        // comparison to string
        EXPECT_TRUE(span <= string_span<>(str));

        // comparison to vector of charaters with no null termination
        EXPECT_TRUE(span >= string_span<>(vec));
    }
}

TEST(string_span_tests, ConstrutorsEnsureZ)
{
    // remove z from literals
    {
        cstring_span<> sp = "hello";
        EXPECT_TRUE(sp.length() == 5);
    }

    // take the string as is
    {
        auto str = std::string("hello");
        cstring_span<> sp = str;
        EXPECT_TRUE(sp.length() == 5);
    }

    // ensure z on c strings
    {
        gsl::owner<char*> ptr = new char[3];

        ptr[0] = 'a';
        ptr[1] = 'b';
        ptr[2] = '\0';

        string_span<> span = ensure_z(ptr);
        EXPECT_TRUE(span.length() == 2);

        delete[] ptr;
    }
}

TEST(string_span_tests, Constructors)
{
    // creating cstring_span

    // from span of a final extent
    {
        span<const char, 6> sp = "Hello";
        cstring_span<> span = sp;
        EXPECT_TRUE(span.length() == 6);
    }

// from const span of a final extent to non-const string_span
#ifdef CONFIRM_COMPILATION_ERRORS
    {
        span<const char, 6> sp = "Hello";
        string_span<> span = sp;
        EXPECT_TRUE(span.length() == 6);
    }
#endif

// from string temporary
#ifdef CONFIRM_COMPILATION_ERRORS
    {
        cstring_span<> span = std::string("Hello");
    }
#endif

    // default
    {
        cstring_span<> span;
        EXPECT_TRUE(span.length() == 0);
    }

    // from string literal
    {
        cstring_span<> span = "Hello";
        EXPECT_TRUE(span.length() == 5);
    }

    // from const static array
    {
        const char ar[] = {'H', 'e', 'l', 'l', 'o'};
        cstring_span<> span = ar;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const static array
    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};
        cstring_span<> span = ar;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const ptr and length
    {
        const char* ptr = "Hello";
        cstring_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
    }

    // from const ptr and length, include 0
    {
        const char* ptr = "Hello";
        cstring_span<> span{ptr, 6};
        EXPECT_TRUE(span.length() == 6);
    }

    // from const ptr and length, 0 inside
    {
        const char* ptr = "He\0lo";
        cstring_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const ptr and length
    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};
        char* ptr = ar;
        cstring_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const ptr and length, 0 inside
    {
        char ar[] = {'H', 'e', '\0', 'l', 'o'};
        char* ptr = ar;
        cstring_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
    }

    // from const string
    {
        const std::string str = "Hello";
        const cstring_span<> span = str;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const string
    {
        std::string str = "Hello";
        const cstring_span<> span = str;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const vector
    {
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const cstring_span<> span = vec;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const vector
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const cstring_span<> span = vec;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const span
    {
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const span<const char> inner = vec;
        const cstring_span<> span = inner;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const span
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const span<char> inner = vec;
        const cstring_span<> span = inner;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const string_span
    {
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const cstring_span<> tmp = vec;
        const cstring_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const string_span
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> tmp = vec;
        cstring_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
    }

    // creating string_span

    // from string literal
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        string_span<> span = "Hello";
#endif
    }

    // from const static array
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const char ar[] = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = ar;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const static array
    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = ar;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const ptr and length
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const char* ptr = "Hello";
        string_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const ptr and length
    {
        char ar[] = {'H', 'e', 'l', 'l', 'o'};
        char* ptr = ar;
        string_span<> span{ptr, 5};
        EXPECT_TRUE(span.length() == 5);
    }

    // from const string
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const std::string str = "Hello";
        string_span<> span = str;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const string
    {
        std::string str = "Hello";
        string_span<> span = str;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const vector
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = vec;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const vector
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = vec;
        EXPECT_TRUE(span.length() == 5);
    }

    // from const span
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const span<const char> inner = vec;
        string_span<> span = inner;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const span
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        span<char> inner = vec;
        string_span<> span = inner;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const span of non-const data from const vector
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const span<char> inner = vec;
        string_span<> span = inner;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from const string_span
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        cstring_span<> tmp = vec;
        string_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from non-const string_span
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const string_span<> tmp = vec;
        const string_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
    }

    // from non-const string_span from const vector
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        const std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> tmp = vec;
        string_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
#endif
    }

    // from const string_span of non-const data
    {
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        const string_span<> tmp = vec;
        const string_span<> span = tmp;
        EXPECT_TRUE(span.length() == 5);
    }
}

TEST(string_span_tests, MoveConstructors)
{
    // move string_span
    {
        cstring_span<> span = "Hello";
        const auto span1 = std::move(span);
        EXPECT_TRUE(span1.length() == 5);
    }
    {
        cstring_span<> span = "Hello";
        const auto span1 = move_wrapper(std::move(span));
        EXPECT_TRUE(span1.length() == 5);
    }
    {
        cstring_span<> span = "Hello";
        const auto span1 = move_wrapper(std::move(span));
        EXPECT_TRUE(span1.length() == 5);
    }

    // move span
    {
        span<const char> span = ensure_z("Hello");
        const cstring_span<> span1 = std::move(span);
        EXPECT_TRUE(span1.length() == 5);
    }
    {
        span<const char> span = ensure_z("Hello");
        const cstring_span<> span2 = move_wrapper(std::move(span));
        EXPECT_TRUE(span2.length() == 5);
    }

    // move string
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::string str = "Hello";
        string_span<> span = std::move(str);
        EXPECT_TRUE(span.length() == 5);
#endif
    }
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::string str = "Hello";
        string_span<> span = move_wrapper<std::string>(std::move(str));
        EXPECT_TRUE(span.length() == 5);
#endif
    }
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        use<char>(create<string>());
#endif
    }

    // move container
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = std::move(vec);
        EXPECT_TRUE(span.length() == 5);
#endif
    }
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
        string_span<> span = move_wrapper<std::vector<char>>(std::move(vec));
        EXPECT_TRUE(span.length() == 5);
#endif
    }
    {
#ifdef CONFIRM_COMPILATION_ERRORS
        use<char>(create<std::vector<char>>());
#endif
    }
}

TEST(string_span_tests, Conversion)
{
#ifdef CONFIRM_COMPILATION_ERRORS
    cstring_span<> span = "Hello";
    cwstring_span<> wspan{span};
    EXPECT_TRUE(wspan.length() == 5);
#endif
}

TEST(string_span_tests, zstring)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. zstring";
        std::abort();
    });

    // create zspan from zero terminated string
    {
        char buf[1];
        buf[0] = '\0';

        zstring_span<> zspan({buf, 1});

        EXPECT_TRUE(generic::strlen(zspan.assume_z()) == 0);
        EXPECT_TRUE(zspan.as_string_span().size() == 0);
        EXPECT_TRUE(zspan.ensure_z().size() == 0);
    }

    // create zspan from non-zero terminated string
    {
        char buf[1];
        buf[0] = 'a';

        auto workaround_macro = [&]() { const zstring_span<> zspan({buf, 1}); };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    // usage scenario: create zero-terminated temp file name and pass to a legacy API
    {
        char buf[10];

        auto name = CreateTempName({buf, 10});
        if (!name.empty()) {
            czstring<> str = name.assume_z();
            EXPECT_TRUE(generic::strlen(str) == 3);
            EXPECT_TRUE(*(str + 3) == '\0');
        }
    }
}

TEST(string_span_tests, wzstring)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. wzstring";
        std::abort();
    });

    // create zspan from zero terminated string
    {
        wchar_t buf[1];
        buf[0] = L'\0';

        wzstring_span<> zspan({buf, 1});

        EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
        EXPECT_TRUE(zspan.as_string_span().size() == 0);
        EXPECT_TRUE(zspan.ensure_z().size() == 0);
    }

    // create zspan from non-zero terminated string
    {
        wchar_t buf[1];
        buf[0] = L'a';

        const auto workaround_macro = [&]() { const wzstring_span<> zspan({buf, 1}); };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    // usage scenario: create zero-terminated temp file name and pass to a legacy API
    {
        wchar_t buf[10];

        const auto name = CreateTempNameW({buf, 10});
        if (!name.empty()) {
            cwzstring<> str = name.assume_z();
            EXPECT_TRUE(generic::strnlen(str, 10) == 3);
            EXPECT_TRUE(*(str + 3) == L'\0');
        }
    }
}

TEST(string_span_tests, u16zstring)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. u16zstring";
        std::abort();
    });

    // create zspan from zero terminated string
    {
        char16_t buf[1];
        buf[0] = L'\0';

        u16zstring_span<> zspan({buf, 1});

        EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
        EXPECT_TRUE(zspan.as_string_span().size() == 0);
        EXPECT_TRUE(zspan.ensure_z().size() == 0);
    }

    // create zspan from non-zero terminated string
    {
        char16_t buf[1];
        buf[0] = u'a';

        const auto workaround_macro = [&]() { const u16zstring_span<> zspan({buf, 1}); };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    // usage scenario: create zero-terminated temp file name and pass to a legacy API
    {
        char16_t buf[10];

        const auto name = CreateTempNameU16({buf, 10});
        if (!name.empty()) {
            cu16zstring<> str = name.assume_z();
            EXPECT_TRUE(generic::strnlen(str, 10) == 3);
            EXPECT_TRUE(*(str + 3) == L'\0');
        }
    }
}

TEST(string_span_tests, u32zstring)
{
    std::set_terminate([] {
        std::cerr << "Expected Death. u31zstring";
        std::abort();
    });

    // create zspan from zero terminated string
    {
        char32_t buf[1];
        buf[0] = L'\0';

        u32zstring_span<> zspan({buf, 1});

        EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
        EXPECT_TRUE(zspan.as_string_span().size() == 0);
        EXPECT_TRUE(zspan.ensure_z().size() == 0);
    }

    // create zspan from non-zero terminated string
    {
        char32_t buf[1];
        buf[0] = u'a';

        const auto workaround_macro = [&]() { const u32zstring_span<> zspan({buf, 1}); };
        EXPECT_DEATH(workaround_macro(), deathstring);
    }

    // usage scenario: create zero-terminated temp file name and pass to a legacy API
    {
        char32_t buf[10];

        const auto name = CreateTempNameU32({buf, 10});
        if (!name.empty()) {
            cu32zstring<> str = name.assume_z();
            EXPECT_TRUE(generic::strnlen(str, 10) == 3);
            EXPECT_TRUE(*(str + 3) == L'\0');
        }
    }
}

TEST(string_span_tests, Issue305)
{
    std::map<gsl::cstring_span<>, int> foo = {{"foo", 0}, {"bar", 1}};
    EXPECT_TRUE(foo["foo"] == 0);
    EXPECT_TRUE(foo["bar"] == 1);
}

TEST(string_span_tests, char16_t_type)
{
    gsl::cu16string_span<> ss1 = gsl::ensure_z(u"abc");
    EXPECT_TRUE(ss1.size() == 3);
    EXPECT_TRUE(ss1.size_bytes() == 6);

    std::u16string s1 = gsl::to_string(ss1);
    EXPECT_TRUE(s1 == u"abc");

    std::u16string s2 = u"abc";
    gsl::u16string_span<> ss2 = s2;
    EXPECT_TRUE(ss2.size() == 3);

    gsl::u16string_span<> ss3 = ss2.subspan(1, 1);
    EXPECT_TRUE(ss3.size() == 1);
    EXPECT_TRUE(ss3[0] == u'b');

    char16_t buf[4]{u'a', u'b', u'c', u'\0'};
    gsl::u16string_span<> ss4{buf, 4};
    EXPECT_TRUE(ss4[3] == u'\0');

    gsl::cu16zstring_span<> ss5(u"abc");
    EXPECT_TRUE((ss5.as_string_span().size()) == 3);

    gsl::cu16string_span<> ss6 = ss5.as_string_span();
    EXPECT_TRUE(ss6 == ss1);

    std::vector<char16_t> v7 = {u'a', u'b', u'c'};
    gsl::cu16string_span<> ss7{v7};
    EXPECT_TRUE(ss7 == ss1);

    gsl::cu16string_span<> ss8 = gsl::ensure_z(u"abc");
    gsl::cu16string_span<> ss9 = gsl::ensure_z(u"abc");
    EXPECT_TRUE(ss8 == ss9);

    ss9 = gsl::ensure_z(u"abd");
    EXPECT_TRUE(ss8 < ss9);
    EXPECT_TRUE(ss8 <= ss9);
    EXPECT_TRUE(ss8 != ss9);
}

TEST(string_span_tests, char32_t_type)
{
    gsl::cu32string_span<> ss1 = gsl::ensure_z(U"abc");
    EXPECT_TRUE(ss1.size() == 3);
    EXPECT_TRUE(ss1.size_bytes() == 12);

    std::u32string s1 = gsl::to_string(ss1);
    EXPECT_TRUE(s1 == U"abc");

    std::u32string s2 = U"abc";
    gsl::u32string_span<> ss2 = s2;
    EXPECT_TRUE(ss2.size() == 3);

    gsl::u32string_span<> ss3 = ss2.subspan(1, 1);
    EXPECT_TRUE(ss3.size() == 1);
    EXPECT_TRUE(ss3[0] == U'b');

    char32_t buf[4]{U'a', U'b', U'c', U'\0'};
    gsl::u32string_span<> ss4{buf, 4};
    EXPECT_TRUE(ss4[3] == u'\0');

    gsl::cu32zstring_span<> ss5(U"abc");
    EXPECT_TRUE(ss5.as_string_span().size() == 3);

    gsl::cu32string_span<> ss6 = ss5.as_string_span();
    EXPECT_TRUE(ss6 == ss1);

    gsl::cu32string_span<> ss8 = gsl::ensure_z(U"abc");
    gsl::cu32string_span<> ss9 = gsl::ensure_z(U"abc");
    EXPECT_TRUE(ss8 == ss9);

    ss9 = gsl::ensure_z(U"abd");
    EXPECT_TRUE(ss8 < ss9);
    EXPECT_TRUE(ss8 <= ss9);
    EXPECT_TRUE(ss8 != ss9);
}

TEST(string_span_tests, as_bytes)
{
    cwzstring_span<> v(L"qwerty");
    const auto s = v.as_string_span();
    const auto bs = as_bytes(s);
    EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
    EXPECT_TRUE(bs.size() == s.size_bytes());
}

TEST(string_span_tests, as_writable_bytes)
{
    wchar_t buf[]{L"qwerty"};
    wzstring_span<> v(buf);
    const auto s = v.as_string_span();
    const auto bs = as_writable_bytes(s);
    EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
    EXPECT_TRUE(bs.size() == s.size_bytes());
}


================================================
FILE: examples/libraries/GSL/tests/utils_tests.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
//
// This code is licensed under the MIT License (MIT).
//
// 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 <gtest/gtest.h>

#include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...

#include <algorithm>   // for move
#include <functional>  // for reference_wrapper, _Bind_helper<>::type
#include <limits>      // for numeric_limits
#include <stdint.h>    // for uint32_t, int32_t
#include <type_traits> // for is_same
#include <cstddef>     // for std::ptrdiff_t

using namespace gsl;

namespace
{
void f(int& i) { i += 1; }
static int j = 0;
void g() { j += 1; }
}


TEST(utils_tests, sanity_check_for_gsl_index_typedef)
{
    static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
                  "gsl::index represents wrong arithmetic type");
}

TEST(utils_tests, finally_lambda)
{
    int i = 0;
    {
        auto _ = finally([&]() { f(i); });
        EXPECT_TRUE(i == 0);
    }
    EXPECT_TRUE(i == 1);
}

TEST(utils_tests, finally_lambda_move)
{
    int i = 0;
    {
        auto _1 = finally([&]() { f(i); });
        {
            auto _2 = std::move(_1);
            EXPECT_TRUE(i == 0);
        }
        EXPECT_TRUE(i == 1);
        {
            auto _2 = std::move(_1);
            EXPECT_TRUE(i == 1);
        }
        EXPECT_TRUE(i == 1);
    }
    EXPECT_TRUE(i == 1);
}

TEST(utils_tests, finally_function_with_bind)
{
    int i = 0;
    {
        auto _ = finally(std::bind(&f, std::ref(i)));
        EXPECT_TRUE(i == 0);
    }
    EXPECT_TRUE(i == 1);
}

TEST(utils_tests, finally_function_ptr)
{
    j = 0;
    {
        auto _ = finally(&g);
        EXPECT_TRUE(j == 0);
    }
    EXPECT_TRUE(j == 1);
}

TEST(utils_tests, narrow_cast)
{
    int n = 120;
    char c = narrow_cast<char>(n);
    EXPECT_TRUE(c == 120);

    n = 300;
    unsigned char uc = narrow_cast<unsigned char>(n);
    EXPECT_TRUE(uc == 44);
}

TEST(utils_tests, narrow)
{
    int n = 120;
    const char c = narrow<char>(n);
    EXPECT_TRUE(c == 120);

    n = 300;
    EXPECT_THROW(narrow<char>(n), narrowing_error);

    const auto int32_max = std::numeric_limits<int32_t>::max();
    const auto int32_min = std::numeric_limits<int32_t>::min();

    EXPECT_TRUE(narrow<uint32_t>(int32_t(0)) == 0);
    EXPECT_TRUE(narrow<uint32_t>(int32_t(1)) == 1);
    EXPECT_TRUE(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));

    EXPECT_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
    EXPECT_THROW(narrow<uint32_t>(int32_min), narrowing_error);

    n = -42;
    EXPECT_THROW(narrow<unsigned>(n), narrowing_error);

#if GSL_CONSTEXPR_NARROW
    static_assert(narrow<char>(120) == 120, "Fix GSL_CONSTEXPR_NARROW");
#endif
}


================================================
FILE: examples/libraries/cereal-1.3.0/.gitignore
================================================
# Compiled Object files
*.slo
*.lo
*.o

# Compiled Dynamic libraries
*.so
*.dylib

# Compiled Static libraries
*.lai
*.la
*.a

# Visual studio cruft
*.opensdf
*.sdf
*.suo
*.user
*/x64
*\Debug*
*\Release*
*.log
*.tlog*
*.obj
*.VC.db
*.VC.VC.opendb
*.pdb
*.idb
*\build_*

# misc files mostly used for testing
out.txt
ptr.txt
test.txt
boost_serialize
arr.txt
performance
include_renamed
.ycm_extra_conf.py*
doc/html
rtti.txt
doc/latex
portability64
portability32
file.json
out.xml
cereal_version.out
xml_ordering.out
build
/out/

================================================
FILE: examples/libraries/cereal-1.3.0/.travis.yml
================================================
# Portions of this file based on https://github.com/Microsoft/GSL/blob/master/.travis.yml

language: cpp
os: linux
dist: trusty
sudo: false
group: beta

addons:
  apt:
    sources: &default_sources
      - ubuntu-toolchain-r-test
      - libboost-latest
    packages: &default_packages
      - libboost-serialization-dev
      - libboost-dev

matrix:
  include:

    # |---------- LINUX GCC ----------|
    - compiler: g++-4.7
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=g++-4.7"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-4.7', *default_packages]

    - compiler: g++-4.8
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=g++-4.8"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-4.8', *default_packages]
         
    - compiler: g++-4.9
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=g++-4.9"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-4.9', *default_packages]
         
    - compiler: g++-5
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=g++-5"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-5', *default_packages]
    
    - compiler: g++-5
      name: "g++-5 multilib"
      env: ["COMPILER=g++-5"]
      addons:
        apt:
          sources: *default_sources
          packages: ['gcc-multilib g++-5-multilib linux-libc-dev', *default_packages]
                  
    - compiler: g++-6
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=g++-6"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-6', *default_packages]

    - compiler: g++-7
      name: "g++-7 c++17"
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON -DCMAKE_CXX_STANDARD=17'", "COMPILER=g++-7"]
      addons:
        apt:
          sources: *default_sources
          packages: ['g++-7', *default_packages]

    # |---------- LINUX GCC ----------|
    - dist: xenial
      compiler: g++-8
      name: "g++-8 c++17"
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON -DCMAKE_CXX_STANDARD=17'", "COMPILER=g++-8"]
      addons:
        apt:
            sources: *default_sources
            packages: ['g++-8', *default_packages]


    # |---------- LINUX CLANG ----------|
    - compiler: clang++-3.5
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-3.5"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-precise-3.5]
          packages: ['clang-3.5', *default_packages]

    - compiler: clang++-3.6
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-3.6"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-precise-3.6]
          packages: ['clang-3.6', *default_packages]

    - compiler: clang++-3.7
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-3.7"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-precise-3.7]
          packages: ['clang-3.7', *default_packages]

    - compiler: clang++-3.8
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-3.8"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-precise-3.8]
          packages: ['clang-3.8', *default_packages]

    - compiler: clang++-3.9
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-3.9"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-precise-3.9]
          packages: ['clang-3.9', *default_packages]

    - compiler: clang++-4.0
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-4.0"]
      addons:
        apt:
          sources: [*default_sources, llvm-toolchain-trusty-4.0]
          packages: ['clang-4.0', 'g++-5', *default_packages]

    - compiler: clang++-5.0
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON'", "COMPILER=clang++-5.0"]
      addons: &clang50
        apt:
          packages: 
            - clang-5.0
            - g++-7
            - *default_packages
          sources: 
            - *default_sources
            - llvm-toolchain-trusty-5.0
            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main'
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'

    - env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON -DCMAKE_CXX_STANDARD=17'", "COMPILER=clang++-5.0"]
      name: "clang++-5.0 c++17"
      addons: *clang50

    - compiler: clang++-7
      name: "clang++-7 c++17"
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON -DCMAKE_CXX_STANDARD=17'", "COMPILER=clang++-7"]
      addons: 
        apt:
          packages: 
            - clang-7
            - g++-7
            - *default_packages
          sources: 
            - *default_sources
            - llvm-toolchain-trusty-7

    - compiler: clang++-8
      name: "clang++-8 c++17 libc++"
      env: ["CMAKE_OPTIONS='-DSKIP_PORTABILITY_TEST=ON -DCMAKE_CXX_STANDARD=17 -DCLANG_USE_LIBCPP=ON -DSKIP_PERFORMANCE_COMPARISON=ON'", "COMPILER=clang++-8"]
      addons: 
        apt:
          packages: 
            - clang-8
            - g++-8
            - libc++-8-dev
            - libc++abi-8-dev
            - *default_packages
          sources: 
            - *default_sources
            - llvm-toolchain-trusty-8

    # # |---------- LINUX CLANG (32-bit) ----------|
    # # Doesn't work.
    # - compiler: clang++
    #   addons:
    #     apt:
    #       sources: [*default_sources]
    #       packages: ['clang', 'gcc-multilib', 'g++-multilib', *default_packages]


    # |---------- OSX CLANG ----------|
    - compiler: clang++
      os: osx
      osx_image: xcode7.3
      env: COMPILER=clang++

    - compiler: clang++
      os: osx
      osx_image: xcode8
      env: COMPILER=clang++

    # # Missing CMake
    # - compiler: clang++
    #   os: osx
    #   osx_image: xcode8.1

    - compiler: clang++
      os: osx
      osx_image: xcode8.2
      env: COMPILER=clang++

    - compiler: clang++
      os: osx
      osx_image: xcode8.3
      env: COMPILER=clang++

    - compiler: clang++
      env: ["CMAKE_OPTIONS='-DWITH_WERROR=OFF'"]
      os: osx
      osx_image: xcode9
      env: COMPILER=clang++
    
    - compiler: clang++
      env: ["CMAKE_OPTIONS='-DWITH_WERROR=OFF'"]
      os: osx
      osx_image: xcode10
      env: COMPILER=clang++

install:
  # Set the ${CXX} variable properly
  - export CXX=${COMPILER}
  - ${CXX} --version

  # Dependencies required by the CI are installed in ${TRAVIS_BUILD_DIR}/deps/
  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
  - mkdir -p "${DEPS_DIR}"
  - cd "${DEPS_DIR}"

  - JOBS=2

  # [linux]: Install the right version of libc++
  - |
    LLVM_INSTALL=${DEPS_DIR}/llvm/install
    # if in linux and compiler clang and llvm not installed
    if [[ "${TRAVIS_OS_NAME}" == "linux" && "${CXX%%+*}" == "clang" && -n "$(ls -A ${LLVM_INSTALL})" ]]; then
      if   [[ "${CXX}" == "clang++-3.6" ]]; then LLVM_VERSION="3.6.2";
      elif [[ "${CXX}" == "clang++-3.7" ]]; then LLVM_VERSION="3.7.1";
      elif [[ "${CXX}" == "clang++-3.8" ]]; then LLVM_VERSION="3.8.1";
      elif [[ "${CXX}" == "clang++-3.9" ]]; then LLVM_VERSION="3.9.1";
      fi
      LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/llvm-${LLVM_VERSION}.src.tar.xz"
      LIBCXX_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxx-${LLVM_VERSION}.src.tar.xz"
      LIBCXXABI_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxxabi-${LLVM_VERSION}.src.tar.xz"
      mkdir -p llvm llvm/build llvm/projects/libcxx llvm/projects/libcxxabi
      travis_retry wget -O - ${LLVM_URL} | tar --strip-components=1 -xJ -C llvm
      travis_retry wget -O - ${LIBCXX_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxx
      travis_retry wget -O - ${LIBCXXABI_URL} | tar --strip-components=1 -xJ -C llvm/projects/libcxxabi
      (cd llvm/build && cmake .. -DCMAKE_INSTALL_PREFIX=${LLVM_INSTALL})
      (cd llvm/build/projects/libcxx && make install -j2)
      (cd llvm/build/projects/libcxxabi && make install -j2)
      export CXXFLAGS="-isystem ${LLVM_INSTALL}/include/c++/v1"
      export LDFLAGS="-L ${LLVM_INSTALL}/lib -l c++ -l c++abi"
      export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${LLVM_INSTALL}/lib"
    fi

script:
  - cd "${TRAVIS_BUILD_DIR}"
  - if [[ "${COMPILERCC}" != "" ]]; then export CC="${COMPILERCC}"; fi
  - if [[ "${COMPILER}" != "" ]]; then export CXX="${COMPILER}"; fi
  - $CXX --version
  - cmake --version
  - mkdir build && cd build
  - cmake ${CMAKE_OPTIONS} .. && make -j4
  - ctest . --output-on-failure

branches:
  only:
    - master


================================================
FILE: examples/libraries/cereal-1.3.0/CMakeLists.txt
================================================
cmake_minimum_required (VERSION 2.6.2)
project (cereal)

option(SKIP_PORTABILITY_TEST "Skip portability (32 bit) tests" OFF)
option(SKIP_PERFORMANCE_COMPARISON "Skip building performance comparison (requires boost)" OFF)
if(NOT CMAKE_VERSION VERSION_LESS 3.0) # installing cereal requires INTERFACE lib
    option(JUST_INSTALL_CEREAL "Don't do anything besides installing the library" OFF)
endif()

option(THREAD_SAFE "Use mutexes to ensure thread safety" OFF)
if(THREAD_SAFE)
    add_definitions(-DCEREAL_THREAD_SAFE=1)
    set(CEREAL_THREAD_LIBS "pthread")
else()
    set(CEREAL_THREAD_LIBS "")
endif()

if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /W3 /WX")
else()
    set(CMAKE_CXX_FLAGS "-Wall -g -Wextra -Wshadow -pedantic -Wold-style-cast ${CMAKE_CXX_FLAGS}")
    option(WITH_WERROR "Compile with '-Werror' C++ compiler flag" ON)
    if(WITH_WERROR)
        set(CMAKE_CXX_FLAGS "-Werror ${CMAKE_CXX_FLAGS}")
    endif(WITH_WERROR)

    option(CLANG_USE_LIBCPP "Use libc++ for clang compilation" OFF)
    if(CLANG_USE_LIBCPP)
        set(CMAKE_CXX_FLAGS "-stdlib=libc++ ${CMAKE_CXX_FLAGS}")
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -lc++abi")
    endif()

    if(CMAKE_VERSION VERSION_LESS 3.1)
        set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
    else()
      if(NOT DEFINED CMAKE_CXX_STANDARD OR CMAKE_CXX_STANDARD STREQUAL "98")
        set(CMAKE_CXX_STANDARD 11)
      endif()

      if(CMAKE_CXX_STANDARD GREATER 14)
        cmake_minimum_required(VERSION 3.8)
      endif()

      set(CMAKE_CXX_STANDARD_REQUIRED ON)
    endif()

endif()

if(NOT CMAKE_VERSION VERSION_LESS 3.0)
    add_library(cereal INTERFACE)
    target_include_directories(cereal INTERFACE
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
        $<INSTALL_INTERFACE:include>
    )
    install(TARGETS cereal EXPORT cereal
        DESTINATION lib) # ignored
    install(EXPORT cereal FILE cereal-config.cmake
        DESTINATION share/cmake/cereal)
    install(DIRECTORY include/cereal DESTINATION include)
endif()

if(JUST_INSTALL_CEREAL)
    return()
endif()

include_directories(./include)

if(NOT CMAKE_VERSION VERSION_LESS 3.12)
  cmake_policy(VERSION 3.12)
endif()

# Boost serialization for performance sandbox
find_package(Boost COMPONENTS serialization)

if(Boost_FOUND)
  include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
endif(Boost_FOUND)
  
enable_testing()
add_subdirectory(unittests)

add_subdirectory(sandbox)

add_subdirectory(doc)


================================================
FILE: examples/libraries/cereal-1.3.0/LICENSE
================================================
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of cereal nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: examples/libraries/cereal-1.3.0/README.md
================================================
cereal - A C++11 library for serialization
==========================================

<img src="http://uscilab.github.io/cereal/assets/img/cerealboxside.png" align="right"/><p>cereal is a header-only C++11 serialization library.  cereal takes arbitrary data types and reversibly turns them into different representations, such as compact binary encodings, XML, or JSON.  cereal was designed to be fast, light-weight, and easy to extend - it has no external dependencies and can be easily bundled with other code or used standalone.</p>

### cereal has great documentation

Looking for more information on how cereal works and its documentation?  Visit [cereal's web page](http://USCiLab.github.com/cereal) to get the latest information.

### cereal is easy to use

Installation and use of of cereal is fully documented on the [main web page](http://USCiLab.github.com/cereal), but this is a quick and dirty version:

* Download cereal and place the headers somewhere your code can see them
* Write serialization functions for your custom types or use the built in support for the standard library cereal provides
* Use the serialization archives to load and save data

```cpp
#include <cereal/types/unordered_map.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/archives/binary.hpp>
#include <fstream>
    
struct MyRecord
{
  uint8_t x, y;
  float z;
  
  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x, y, z );
  }
};
    
struct SomeData
{
  int32_t id;
  std::shared_ptr<std::unordered_map<uint32_t, MyRecord>> data;
  
  template <class Archive>
  void save( Archive & ar ) const
  {
    ar( data );
  }
      
  template <class Archive>
  void load( Archive & ar )
  {
    static int32_t idGen = 0;
    id = idGen++;
    ar( data );
  }
};

int main()
{
  std::ofstream os("out.cereal", std::ios::binary);
  cereal::BinaryOutputArchive archive( os );

  SomeData myData;
  archive( myData );

  return 0;
}
```    

### cereal has a mailing list

Either get in touch over <a href="mailto:cerealcpp@googlegroups.com">email</a> or [on the web](https://groups.google.com/forum/#!forum/cerealcpp).



## cereal has a permissive license

cereal is licensed under the [BSD license](http://opensource.org/licenses/BSD-3-Clause).

## cereal build status

* master : [![Build Status](https://travis-ci.com/USCiLab/cereal.svg?branch=master)](https://travis-ci.com/USCiLab/cereal)
[![Build status](https://ci.appveyor.com/api/projects/status/91aou6smj36or0vb/branch/master?svg=true)](https://ci.appveyor.com/project/AzothAmmo/cereal/branch/master)

---

Were you looking for the Haskell cereal?  Go <a href="https://github.com/GaloisInc/cereal">here</a>.


================================================
FILE: examples/libraries/cereal-1.3.0/appveyor.yml
================================================
# can use variables like {build} and {branch}
version: 1.2.{build}
pull_requests:
  do_not_increment_build_number: true

branches:
  only:
    - master

configuration:
  - Debug
  - Release

environment:
  matrix:
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      VS_VERSION_MAJOR: 12
      BOOST_ROOT: C:\Libraries\boost_1_58_0
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      VS_VERSION_MAJOR: 14
      BOOST_ROOT: C:\Libraries\boost_1_60_0
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      VS_VERSION_MAJOR: 15
      BOOST_ROOT: C:\Libraries\boost_1_66_0
      #    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 Preview
      #      VS_VERSION_MAJOR: 16
      #      BOOST_ROOT: C:\Libraries\boost_1_66_0

platform:
  - Win32
  - x64

before_build: "scripts\\appveyor.bat"

build:
  parallel: true
  project: build/cereal.sln
  verbosity: minimal

test_script: "scripts\\appveyor.bat test"

artifacts:
  - path: build\Testing
  - path: out


================================================
FILE: examples/libraries/cereal-1.3.0/doc/CMakeLists.txt
================================================
find_package(Doxygen)
if(DOXYGEN_FOUND)

  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/doxygen.in" "${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg" @ONLY)
  add_custom_target(doc
    COMMAND ${DOXYGEN_EXECUTABLE} "${CMAKE_CURRENT_BINARY_DIR}/doxygen.cfg"
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.."
    COMMENT "Generating API documentation with Doxygen" VERBATIM
    )

  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/../scripts/updatedoc.in" "${CMAKE_CURRENT_BINARY_DIR}/updatedoc.sh" @ONLY)
  add_custom_target(update-doc
    COMMAND "${CMAKE_CURRENT_BINARY_DIR}/updatedoc.sh"
    DEPENDS doc
    COMMENT "Copying documentation to gh-pages branch" VERBATIM
    )

endif(DOXYGEN_FOUND)

================================================
FILE: examples/libraries/cereal-1.3.0/doc/DoxygenLayout.xml
================================================
<doxygenlayout version="1.0">
  <!-- Generated by doxygen 1.8.3.1-20130402 -->
  <!-- Navigation index tabs for HTML output -->
  <navindex>
    <tab type="user" visible="true" title="cereal" url="../../index.html"/>
    <tab type="mainpage" visible="yes" title="Doxygen Documentation"/>
    <tab type="pages" visible="no" title="" intro=""/>
    <tab type="modules" visible="yes" title="Code Modules" intro=""/>
    <tab type="namespaces" visible="no" title="">
      <tab type="namespacelist" visible="yes" title="" intro=""/>
      <tab type="namespacemembers" visible="yes" title="" intro=""/>
    </tab>
    <tab type="classes" visible="no" title="">
      <tab type="classlist" visible="yes" title="" intro=""/>
      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
      <tab type="hierarchy" visible="yes" title="" intro=""/>
      <tab type="classmembers" visible="yes" title="" intro=""/>
    </tab>
    <tab type="files" visible="yes" title="Source File Documentation">
      <tab type="filelist" visible="yes" title="" intro=""/>
      <tab type="globals" visible="yes" title="" intro=""/>
    </tab>
    <tab type="examples" visible="no" title="" intro=""/>
    <tab type="user" visible="true" title="Github" url="https://github.com/USCiLab/cereal"/>
  </navindex>

  <!-- Layout definition for a class page -->
  <class>
    <briefdescription visible="yes"/>
    <includes visible="$SHOW_INCLUDE_FILES"/>
    <inheritancegraph visible="$CLASS_GRAPH"/>
    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
    <memberdecl>
      <nestedclasses visible="yes" title=""/>
      <publictypes title=""/>
      <publicslots title=""/>
      <signals title=""/>
      <publicmethods title=""/>
      <publicstaticmethods title=""/>
      <publicattributes title=""/>
      <publicstaticattributes title=""/>
      <protectedtypes title=""/>
      <protectedslots title=""/>
      <protectedmethods title=""/>
      <protectedstaticmethods title=""/>
      <protectedattributes title=""/>
      <protectedstaticattributes title=""/>
      <packagetypes title=""/>
      <packagemethods title=""/>
      <packagestaticmethods title=""/>
      <packageattributes title=""/>
      <packagestaticattributes title=""/>
      <properties title=""/>
      <events title=""/>
      <privatetypes title=""/>
      <privateslots title=""/>
      <privatemethods title=""/>
      <privatestaticmethods title=""/>
      <privateattributes title=""/>
      <privatestaticattributes title=""/>
      <friends title=""/>
      <related title="" subtitle=""/>
      <membergroups visible="yes"/>
    </memberdecl>
    <detaileddescription title=""/>
    <memberdef>
      <inlineclasses title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <constructors title=""/>
      <functions title=""/>
      <related title=""/>
      <variables title=""/>
      <properties title=""/>
      <events title=""/>
    </memberdef>
    <allmemberslink visible="yes"/>
    <usedfiles visible="$SHOW_USED_FILES"/>
    <authorsection visible="yes"/>
  </class>

  <!-- Layout definition for a namespace page -->
  <namespace>
    <briefdescription visible="yes"/>
    <memberdecl>
      <nestednamespaces visible="yes" title=""/>
      <classes visible="yes" title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <functions title=""/>
      <variables title=""/>
      <membergroups visible="yes"/>
    </memberdecl>
    <detaileddescription title=""/>
    <memberdef>
      <inlineclasses title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <functions title=""/>
      <variables title=""/>
    </memberdef>
    <authorsection visible="yes"/>
  </namespace>

  <!-- Layout definition for a file page -->
  <file>
    <briefdescription visible="yes"/>
    <includes visible="$SHOW_INCLUDE_FILES"/>
    <includegraph visible="$INCLUDE_GRAPH"/>
    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
    <sourcelink visible="yes"/>
    <memberdecl>
      <classes visible="yes" title=""/>
      <namespaces visible="yes" title=""/>
      <defines title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <functions title=""/>
      <variables title=""/>
      <membergroups visible="yes"/>
    </memberdecl>
    <detaileddescription title=""/>
    <memberdef>
      <inlineclasses title=""/>
      <defines title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <functions title=""/>
      <variables title=""/>
    </memberdef>
    <authorsection/>
  </file>

  <!-- Layout definition for a group page -->
  <group>
    <briefdescription visible="yes"/>
    <groupgraph visible="$GROUP_GRAPHS"/>
    <memberdecl>
      <nestedgroups visible="yes" title=""/>
      <dirs visible="yes" title=""/>
      <files visible="yes" title=""/>
      <namespaces visible="yes" title=""/>
      <classes visible="yes" title=""/>
      <defines title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <enumvalues title=""/>
      <functions title=""/>
      <variables title=""/>
      <signals title=""/>
      <publicslots title=""/>
      <protectedslots title=""/>
      <privateslots title=""/>
      <events title=""/>
      <properties title=""/>
      <friends title=""/>
      <membergroups visible="yes"/>
    </memberdecl>
    <detaileddescription title=""/>
    <memberdef>
      <pagedocs/>
      <inlineclasses title=""/>
      <defines title=""/>
      <typedefs title=""/>
      <enums title=""/>
      <enumvalues title=""/>
      <functions title=""/>
      <variables title=""/>
      <signals title=""/>
      <publicslots title=""/>
      <protectedslots title=""/>
      <privateslots title=""/>
      <events title=""/>
      <properties title=""/>
      <friends title=""/>
    </memberdef>
    <authorsection visible="yes"/>
  </group>

  <!-- Layout definition for a directory page -->
  <directory>
    <briefdescription visible="yes"/>
    <directorygraph visible="yes"/>
    <memberdecl>
      <dirs visible="yes"/>
      <files visible="yes"/>
    </memberdecl>
    <detaileddescription title=""/>
  </directory>
</doxygenlayout>


================================================
FILE: examples/libraries/cereal-1.3.0/doc/doxygen.in
================================================
# Doxyfile 1.8.3.1

# 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
#---------------------------------------------------------------------------

# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.

DOXYFILE_ENCODING      = UTF-8

# The PROJECT_NAME tag is a single word (or sequence of words) that should
# identify the project. Note that if you do not use Doxywizard you need
# to put quotes around the project name if it contains spaces.

PROJECT_NAME           = "cereal"

# 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         =

# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer
# a quick idea about the purpose of the project. Keep the description short.

PROJECT_BRIEF          = "A C++11 library for serialization"

# With the PROJECT_LOGO tag one can specify an logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.

PROJECT_LOGO           =

# 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       = @CMAKE_CURRENT_BINARY_DIR@/

# 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:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.

OUTPUT_LANGUAGE        = English

# 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. Note that you specify absolute paths here, but also
# relative paths, which will be relative from the directory where doxygen is
# started.

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    = include

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful if your file system
# 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 regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)

JAVADOC_AUTOBRIEF      = NO

# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)

QT_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 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 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               = 2

# 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                =

# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding
# "class=itcl::class" will allow you to use the command class in the
# itcl::class meaning.

TCL_SUBST              =

# 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 OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.

OPTIMIZE_FOR_FORTRAN   = NO

# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.

OPTIMIZE_OUTPUT_VHDL   = NO

# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given
# extension. Doxygen has a built-in mapping, but you can override or extend it
# using this tag. The format is ext=language, where ext is a file extension,
# and language is one of the parsers supported by doxygen: IDL, Java,
# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
# C++. For instance to make doxygen treat .inc files as Fortran files (default
# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
# that for custom extensions you also need to set FILE_PATTERNS otherwise the
# files are not read by doxygen.

EXTENSION_MAPPING      =

# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
# comments according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you
# can mix doxygen, HTML, and XML commands with Markdown formatting.
# Disable only in case of backward compatibilities issues.

MARKDOWN_SUPPORT       = YES

# When enabled doxygen tries to link words that correspond to documented classes,
# or namespaces to their corresponding documentation. Such a link can be
# prevented in individual cases by by putting a % sign in front of the word or
# globally by setting AUTOLINK_SUPPORT to NO.

AUTOLINK_SUPPORT       = YES

# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also makes the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.

BUILTIN_STL_SUPPORT    = YES

# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.

CPP_CLI_SUPPORT        = NO

# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.

SIP_SUPPORT            = NO

# For Microsoft's IDL there are propget and propput attributes to indicate
# getter and setter methods for a property. Setting this option to YES (the
# default) will make doxygen replace the get and set methods by a property in
# the documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.

IDL_PROPERTY_SUPPORT   = 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

# 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

# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
# unions are shown inside the group in which they are included (e.g. using
# @ingroup) instead of on a separate page (for HTML and Man pages) or
# section (for LaTeX and RTF).

INLINE_GROUPED_CLASSES = NO

# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
# unions with only public data fields will be shown inline in the documentation
# of the scope in which they are defined (i.e. file, namespace, or group
# documentation), provided this scope is documented. If set to NO (the default),
# structs, classes, and unions are shown on a separate page (for HTML and Man
# pages) or section (for LaTeX and RTF).

INLINE_SIMPLE_STRUCTS  = NO

# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.

TYPEDEF_HIDES_STRUCT   = NO

# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

#SYMBOL_CACHE_SIZE      = 0

# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
# their name and scope. Since this can be an expensive process and often the
# same symbol appear multiple times in the code, doxygen keeps a cache of
# pre-resolved symbols. If the cache is too small doxygen will become slower.
# If the cache is too large, memory is wasted. The cache size is given by this
# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols.

LOOKUP_CACHE_SIZE      = 0

#---------------------------------------------------------------------------
# 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_PACKAGE tag is set to YES all members with package or internal
# scope will be included in the documentation.

EXTRACT_PACKAGE        = 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  = YES

# 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 this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespaces are hidden.

EXTRACT_ANON_NSPACES   = 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     = NO

# 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     = NO

# 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 FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
# will list include files with double quotes in the documentation
# rather than with sharp brackets.

FORCE_LOCAL_INCLUDES   = NO

# 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_MEMBERS_CTORS_1ST tag is set to YES then doxygen
# will sort the (brief and detailed) documentation of class members so that
# constructors and destructors are listed first. If set to NO (the default)
# the constructors will appear in the respective orders defined by
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.

SORT_MEMBERS_CTORS_1ST = NO

# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.

SORT_GROUP_NAMES       = 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

# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
# do proper type resolution of all parameters of a function it will reject a
# match between the prototype and the implementation of a member function even
# if there is only one candidate or it is obvious which candidate to choose
# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
# will still accept a match between prototype and implementation in such cases.

STRICT_PROTO_MATCHING  = 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 section-label ... \endif
# and \cond section-label ... \endcond blocks.

ENABLED_SECTIONS       =

# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or macro 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 macros 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

# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.

SHOW_FILES             = YES

# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.

SHOW_NAMESPACES        = 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 <command> <input-file>, where <command> is the value of
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.

FILE_VERSION_FILTER    =

# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option.
# You can optionally specify a file name after the option, if omitted
# DoxygenLayout.xml will be used as the name of the layout file.

LAYOUT_FILE            = "@CMAKE_CURRENT_SOURCE_DIR@/DoxygenLayout.xml"

# The CITE_BIB_FILES tag can be used to specify one or more bib files
# containing the references data. This must be a list of .bib files. The
# .bib extension is automatically appended if omitted. Using this command
# requires the bibtex tool to be installed. See also
# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
# feature you need bibtex and perl available in the search path. Do not use
# file names with spaces, bibtex cannot handle them.

CITE_BIB_FILES         =

#---------------------------------------------------------------------------
# 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                  = YES

# 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   = NO

# 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

# The WARN_NO_PARAMDOC option can be enabled 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                  = @CMAKE_CURRENT_SOURCE_DIR@/../include @CMAKE_CURRENT_SOURCE_DIR@/

# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.

INPUT_ENCODING         = UTF-8

# 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++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
# *.f90 *.f *.for *.vhd *.vhdl

FILE_PATTERNS          = *.hpp
FILE_PATTERNS          += *.dox

# 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              = YES

# The EXCLUDE tag can be used to specify files and/or directories that should be
# 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.
# Note that relative paths are relative to the directory from which doxygen is
# run.

EXCLUDE                = @CMAKE_CURRENT_SOURCE_DIR@/../external

# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system 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. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*

EXCLUDE_PATTERNS       = .* *.cpp */external/*

# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test

EXCLUDE_SYMBOLS        =

# 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           =

# 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 <filter> <input-file>, where <filter>
# is the value of the INPUT_FILTER tag, and <input-file> 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 or if
# non of the patterns match the file name, INPUT_FILTER is applied.

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

# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
# and it is also possible to disable source filtering for a specific pattern
# using *.ext= (so without naming a filter). This option only has effect when
# FILTER_SOURCE_FILES is enabled.

FILTER_SOURCE_PATTERNS =

# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
# is part of the input, its contents will be placed on the main page (index.html).
# This can be useful if you have a project on for instance GitHub and want reuse
# the introduction page also for the doxygen output.

USE_MDFILE_AS_MAINPAGE =

#---------------------------------------------------------------------------
# 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, C++ and Fortran comments will always remain visible.

STRIP_CODE_COMMENTS    = YES

# If the REFERENCED_BY_RELATION tag is set to YES
# 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
# then for each documented function all documented entities
# called/used by that function will be listed.

REFERENCES_RELATION    = NO

# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.

REFERENCES_LINK_SOURCE = YES

# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.

USE_HTAGS              = 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       = YES

#---------------------------------------------------------------------------
# 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     = YES

# 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. Note that when using a custom header you are responsible
#  for the proper inclusion of any scripts and style sheets that doxygen
# needs, which is dependent on the configuration options used.
# It is advised to generate a default header using "doxygen -w html
# header.html footer.html stylesheet.css YourConfigFile" and then modify
# that header. Note that the header is subject to change so you typically
# have to redo this when upgrading to a newer version of doxygen or when
# changing the value of configuration settings such as GENERATE_TREEVIEW!

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            ="@CMAKE_CURRENT_SOURCE_DIR@/footer.html"

# 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 left blank doxygen will
# generate a default style sheet. Note that it is recommended to use
# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
# tag will in the future become obsolete.

HTML_STYLESHEET        =

# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
# user-defined cascading style sheet that is included after the standard
# style sheets created by doxygen. Using this option one can overrule
# certain style aspects. This is preferred over using HTML_STYLESHEET
# since it does not replace the standard style sheet and is therefor more
# robust against future updates. Doxygen will copy the style sheet file to
# the output directory.

HTML_EXTRA_STYLESHEET  =

# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that
# the files will be copied as-is; there are no commands or markers available.

HTML_EXTRA_FILES       =

# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
# Doxygen will adjust the colors in the style sheet and background images
# according to this color. Hue is specified as an angle on a colorwheel,
# see http://en.wikipedia.org/wiki/Hue for more information.
# For instance the value 0 represents red, 60 is yellow, 120 is green,
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
# The allowed range is 0 to 359.

HTML_COLORSTYLE_HUE    = 220

# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
# the colors in the HTML output. For a value of 0 the output will use
# grayscales only. A value of 255 will produce the most vivid colors.

HTML_COLORSTYLE_SAT    = 100

# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
# the luminance component of the colors in the HTML output. Values below
# 100 gradually make the output lighter, whereas values above 100 make
# the output darker. The value divided by 100 is the actual gamma applied,
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
# and 100 does not change the gamma.

HTML_COLORSTYLE_GAMMA  = 80

# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting
# this to NO can help when comparing the output of multiple runs.

HTML_TIMESTAMP         = YES

# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.

HTML_DYNAMIC_SECTIONS  = NO

# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
# entries shown in the various tree structured indices initially; the user
# can expand and collapse entries dynamically later on. Doxygen will expand
# the tree to such a level that at most the specified number of entries are
# visible (unless a fully collapsed tree already exceeds this amount).
# So setting the number of entries 1 will produce a full collapsed tree by
# default. 0 is a special value representing an infinite number of entries
# and will result in a full expanded tree by default.

HTML_INDEX_NUM_ENTRIES = 100

# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.

GENERATE_DOCSET        = NO

# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.

DOCSET_FEEDNAME        = "Doxygen generated docs"

# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.

DOCSET_BUNDLE_ID       = org.doxygen.Project

# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
# identify the documentation publisher. This should be a reverse domain-name
# style string, e.g. com.mycompany.MyDocSet.documentation.

DOCSET_PUBLISHER_ID    = org.doxygen.Publisher

# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.

DOCSET_PUBLISHER_NAME  = Publisher

# 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 compiled 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 CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.

CHM_INDEX_ENCODING     =

# 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

# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
# that can be used as input for Qt's qhelpgenerator to generate a
# Qt Compressed Help (.qch) of the generated HTML documentation.

GENERATE_QHP           = NO

# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.

QCH_FILE               =

# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace

QHP_NAMESPACE          = org.doxygen.Project

# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders

QHP_VIRTUAL_FOLDER     = doc

# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
# add. For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters

QHP_CUST_FILTER_NAME   =

# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see
# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
# Qt Help Project / Custom Filters</a>.

QHP_CUST_FILTER_ATTRS  =

# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's
# filter section matches.
# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
# Qt Help Project / Filter Attributes</a>.

QHP_SECT_FILTER_ATTRS  =

# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.

QHG_LOCATION           =

# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
#  will be generated, which together with the HTML files, form an Eclipse help
# plugin. To install this plugin and make it available under the help contents
# menu in Eclipse, the contents of the directory containing the HTML and XML
# files needs to be copied into the plugins directory of eclipse. The name of
# the directory within the plugins directory should be the same as
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
# the help appears.

GENERATE_ECLIPSEHELP   = NO

# A unique identifier for the eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have
# this name.

ECLIPSE_DOC_ID         = org.doxygen.Project

# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
# at top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it. Since the tabs have the same information as the
# navigation tree you can set this option to NO if you already set
# GENERATE_TREEVIEW to YES.

DISABLE_INDEX          = NO

# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value 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 (i.e. any modern browser).
# Windows users are probably better off using the HTML help feature.
# Since the tree basically has the same information as the tab index you
# could consider to set DISABLE_INDEX to NO when enabling this option.

GENERATE_TREEVIEW      = NO

# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
# (range [0,1..20]) that doxygen will group on one line in the generated HTML
# documentation. Note that a value of 0 will completely suppress the enum
# values from appearing in the overview section.

ENUM_VALUES_PER_LINE   = 4

# 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

# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
# links to external symbols imported via tag files in a separate window.

EXT_LINKS_IN_WINDOW    = NO

# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.

FORMULA_FONTSIZE       = 10

# Use the FORMULA_TRANPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are
# not supported properly for IE 6.0, but are supported on all modern browsers.
# Note that when changing this option you need to delete any form_*.png files
# in the HTML output before the changes have effect.

FORMULA_TRANSPARENT    = YES

# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
# (see http://www.mathjax.org) which uses client side Javascript for the
# rendering instead of using prerendered bitmaps. Use this if you do not
# have LaTeX installed or if you want to formulas look prettier in the HTML
# output. When enabled you may also need to install MathJax separately and
# configure the path to it using the MATHJAX_RELPATH option.

USE_MATHJAX            = NO

# When MathJax is enabled you can set the default output format to be used for
# thA MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
# SVG. The default value is HTML-CSS, which is slower, but has the best
# compatibility.

MATHJAX_FORMAT         = HTML-CSS

# When MathJax is enabled you need to specify the location relative to the
# HTML output directory using the MATHJAX_RELPATH option. The destination
# directory should contain the MathJax.js script. For instance, if the mathjax
# directory is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to
# the MathJax Content Delivery Network so you can quickly see the result without
# installing MathJax.
# However, it is strongly recommended to install a local
# copy of MathJax from http://www.mathjax.org before deployment.

MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest

# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
# names that should be enabled during MathJax rendering.

MATHJAX_EXTENSIONS     =

# When the SEARCHENGINE tag is enabled doxygen will generate a search box
# for the HTML output. The underlying search engine uses javascript
# and DHTML and should work on any modern browser. Note that when using
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# typically be disabled. For large projects the javascript based search engine
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.

SEARCHENGINE           = YES

# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using Javascript.
# There are two flavours of web server based search depending on the
# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
# searching and an index file used by the script. When EXTERNAL_SEARCH is
# enabled the indexing and searching needs to be provided by external tools.
# See the manual for details.

SERVER_BASED_SEARCH    = NO

# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
# script for searching. Instead the search results are written to an XML file
# which needs to be processed by an external indexer. Doxygen will invoke an
# external search engine pointed to by the SEARCHENGINE_URL option to obtain
# the search results. Doxygen ships with an example indexer (doxyindexer) and
# search engine (doxysearch.cgi) which are based on the open source search engine
# library Xapian. See the manual for configuration details.

EXTERNAL_SEARCH        = NO

# The SEARCHENGINE_URL should point to a search engine hosted by a web server
# which will returned the search results when EXTERNAL_SEARCH is enabled.
# Doxygen ships with an example search engine (doxysearch) which is based on
# the open source search engine library Xapian. See the manual for configuration
# details.

SEARCHENGINE_URL       =

# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
# search data is written to a file for indexing by an external tool. With the
# SEARCHDATA_FILE tag the name of this file can be specified.

SEARCHDATA_FILE        = searchdata.xml

# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
# projects and redirect the results back to the right project.

EXTERNAL_SEARCH_ID     =

# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
# projects other than the one defined by this configuration file, but that are
# all added to the same external search index. Each project needs to have a
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
# of to a relative location where the documentation can be found.
# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...

EXTRA_SEARCH_MAPPINGS  =

#---------------------------------------------------------------------------
# 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.
# Note that when enabling USE_PDFLATEX this option is only used for
# generating bitmaps for formulas in the HTML output, but not in the
# Makefile that is written to the output directory.

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, letter, legal and
# executive. If left blank a4wide will be used.

PAPER_TYPE             = a4

# 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           =

# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
# the generated latex document. The footer should contain everything after
# the last chapter. If it is left blank doxygen will generate a
# standard footer. Notice: only use this tag if you know what you are doing!

LATEX_FOOTER           =

# 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         = YES

# 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           = YES

# 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

# If LATEX_SOURCE_CODE is set to YES then doxygen will include
# source code with syntax highlighting in the LaTeX output.
# Note that which sources are shown also depends on other settings
# such as SOURCE_BROWSER.

LATEX_SOURCE_CODE      = NO

# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
# http://en.wikipedia.org/wiki/BibTeX for more info.

LATEX_BIB_STYLE        = plain

#---------------------------------------------------------------------------
# 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 style sheet 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_DEFINED tags.

EXPAND_ONLY_PREDEF     = NO

# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# pointed to by INCLUDE_PATH will be searched when 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 that
# overrules the definition found in the source code.

EXPAND_AS_DEFINED      =

# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
# that are alone on a line, have an all uppercase name, and do not end with a
# semicolon, because these 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. For each
# tag file the location of the external documentation should be added. 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. 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       = cereal.doxytags

# 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 also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.

CLASS_DIAGRAMS         = YES

# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.

MSCGEN_PATH            =

# 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

# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
# allowed to run in parallel. When set to 0 (the default) doxygen will
# base this on the number of processors available in the system. You can set it
# explicitly to a value larger than 0 to get control over the balance
# between CPU load and processing speed.

DOT_NUM_THREADS        = 0

# By default doxygen will use the Helvetica font for all dot files that
# doxygen generates. When you want a differently looking font you can specify
# the font name using DOT_FONTNAME. You need to make sure dot is able to find
# the font, which can be done by putting it in a standard location or by setting
# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
# directory containing the font.

DOT_FONTNAME           = Helvetica

# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.

DOT_FONTSIZE           = 10

# By default doxygen will tell dot to use the Helvetica font.
# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
# set the path where dot can find it.

DOT_FONTPATH           =

# 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
# 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 the UML_LOOK tag is enabled, the fields and methods are shown inside
# the class node. If there are many fields or methods and many nodes the
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
# threshold limits the number of items for each type to make the size more
# managable. Set this to 0 for no limit. Note that the threshold may be
# exceeded by 50% before the limit is enforced.

UML_LIMIT_NUM_FIELDS   = 10

# 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 options 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 CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller 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 caller
# graphs for selected functions only using the \callergraph command.

CALLER_GRAPH           = NO

# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will generate a graphical hierarchy of all classes instead of a textual one.

GRAPHICAL_HIERARCHY    = YES

# If the DIRECTORY_GRAPH 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 svg, png, jpg, or gif.
# If left blank png will be used. If you choose svg you need to set
# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible in IE 9+ (other browsers do not have this requirement).

DOT_IMAGE_FORMAT       = png

# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
# Note that this requires a modern browser other than Internet Explorer.
# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible. Older versions of IE do not have SVG support.

INTERACTIVE_SVG        = NO

# 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 MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the
# \mscfile command).

MSCFILE_DIRS           =

# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.

DOT_GRAPH_MAX_NODES    = 50

# 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 the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

MAX_DOT_GRAPH_DEPTH    = 0

# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. 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      = YES

# 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


================================================
FILE: examples/libraries/cereal-1.3.0/doc/footer.html
================================================
<!-- HTML footer for doxygen 1.8.3.1-->
<!-- start footer part -->
<!--BEGIN GENERATE_TREEVIEW-->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
  <ul>
    $navpath
    <li class="footer">$generatedby
    <a href="http://www.doxygen.org/index.html">
    <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
  </ul>
</div>
<!--END GENERATE_TREEVIEW-->
<!--BEGIN !GENERATE_TREEVIEW-->
<hr class="footer"/><address class="footer"><small>
$generatedby &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
</a> $doxygenversion
</small></address>
<!--END !GENERATE_TREEVIEW-->
<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-42360142-1', 'uscilab.github.io');
  ga('send', 'pageview');

</script>
</body>
</html>


================================================
FILE: examples/libraries/cereal-1.3.0/doc/mainpage.dox
================================================
/**
\mainpage cereal code documentation

\tableofcontents

Aside from the <a href="../../index.html">documentation</a> presented on the main cereal site, this doxygen
page offers code level documentation.

\section modules Browse modules

cereal's code is organized into modules of similar functionality.  Take a look at the <a href="modules.html">modules</a>
section to learn more.  Average users will not need to understand the workings of any code that falls under the
<i>internal</i> module.

\section files Browse files

If you need reference on a specific file, the <a href="files.html">files</a> page lists all files in cereal.
*/

  //! \defgroup Archives Input and Output Archive Types

  /*! \defgroup Access Access Control and Disambiguation
      Provides ways to give cereal access to protected member functions, disambiguate
      which serialization function cereal should use, and provide ways of using smart
      pointers with types that have no default constructor. */

  /*! \defgroup Utility Utility Functionality
      Name-value pairs, binary data wrappers, exceptions, and other utility functions */

  /*! \defgroup TypeSupport Support for Serializing Various Types
      Serialization of many types is shipped with cereal, including most of the standard library as well as a few others.  */

  /*! \defgroup STLSupport Standard Library Support
      Serialization methods for nearly all types found in the C++ standard library.
      \ingroup TypeSupport */
  
  /*! \defgroup TypeConcepts Abstract Type Concept Support
      Serialization methods for more abstract type concepts that can generalize over many types.
      \ingroup TypeSupport */

  /*! \defgroup OtherTypes Miscellaneous Types Support
      Support for various other types such as smart pointers to polymorphic base classes, boost::variant, etc.
      \ingroup TypeSupport */

  /*! \defgroup Internal Internal Functionality
      Various classes and functions that are critical for the operation of cereal but of no
      interest to users */


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/access.hpp
================================================
/*! \file access.hpp
    \brief Access control and default construction */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ACCESS_HPP_
#define CEREAL_ACCESS_HPP_

#include <type_traits>
#include <iostream>
#include <cstdint>
#include <functional>

#include "cereal/macros.hpp"
#include "cereal/specialize.hpp"
#include "cereal/details/helpers.hpp"

namespace cereal
{
  // ######################################################################
  //! A class that allows cereal to load smart pointers to types that have no default constructor
  /*! If your class does not have a default constructor, cereal will not be able
      to load any smart pointers to it unless you overload LoadAndConstruct
      for your class, and provide an appropriate load_and_construct method.  You can also
      choose to define a member static function instead of specializing this class.

      The specialization of LoadAndConstruct must be placed within the cereal namespace:

      @code{.cpp}
      struct MyType
      {
        MyType( int x ); // note: no default ctor
        int myX;

        // Define a serialize or load/save pair as you normally would
        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( myX );
        }
      };

      // Provide a specialization for LoadAndConstruct for your type
      namespace cereal
      {
        template <> struct LoadAndConstruct<MyType>
        {
          // load_and_construct will be passed the archive that you will be loading
          // from as well as a construct object which you can use as if it were the
          // constructor for your type.  cereal will handle all memory management for you.
          template <class Archive>
          static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
          {
            int x;
            ar( x );
            construct( x );
          }

          // if you require versioning, simply add a const std::uint32_t as the final parameter, e.g.:
          // load_and_construct( Archive & ar, cereal::construct<MyType> & construct, std::uint32_t const version )
        };
      } // end namespace cereal
      @endcode

      Please note that just as in using external serialization functions, you cannot get
      access to non-public members of your class by befriending cereal::access.  If you
      have the ability to modify the class you wish to serialize, it is recommended that you
      use member serialize functions and a static member load_and_construct function.

      load_and_construct functions, regardless of whether they are static members of your class or
      whether you create one in the LoadAndConstruct specialization, have the following signature:

      @code{.cpp}
      // generally Archive will be templated, but it can be specific if desired
      template <class Archive>
      static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct );
      // with an optional last parameter specifying the version: const std::uint32_t version
      @endcode

      Versioning behaves the same way as it does for standard serialization functions.

      @tparam T The type to specialize for
      @ingroup Access */
  template <class T>
  struct LoadAndConstruct
  { };

  // forward decl for construct
  //! @cond PRIVATE_NEVERDEFINED
  namespace memory_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
  namespace boost_variant_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
  //! @endcond

  //! Used to construct types with no default constructor
  /*! When serializing a type that has no default constructor, cereal
      will attempt to call either the class static function load_and_construct
      or the appropriate template specialization of LoadAndConstruct.  cereal
      will pass that function a reference to the archive as well as a reference
      to a construct object which should be used to perform the allocation once
      data has been appropriately loaded.

      @code{.cpp}
      struct MyType
      {
        // note the lack of default constructor
        MyType( int xx, int yy );

        int x, y;
        double notInConstructor;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( x, y );
          ar( notInConstructor );
        }

        template <class Archive>
        static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
        {
          int x, y;
          ar( x, y );

          // use construct object to initialize with loaded data
          construct( x, y );

          // access to member variables and functions via -> operator
          ar( construct->notInConstructor );

          // could also do the above section by:
          double z;
          ar( z );
          construct->notInConstructor = z;
        }
      };
      @endcode

      @tparam T The class type being serialized
      */
  template <class T>
  class construct
  {
    public:
      //! Construct and initialize the type T with the given arguments
      /*! This will forward all arguments to the underlying type T,
          calling an appropriate constructor.

          Calling this function more than once will result in an exception
          being thrown.

          @param args The arguments to the constructor for T
          @throw Exception If called more than once */
      template <class ... Args>
      void operator()( Args && ... args );
      // implementation deferred due to reliance on cereal::access

      //! Get a reference to the initialized underlying object
      /*! This must be called after the object has been initialized.

          @return A reference to the initialized object
          @throw Exception If called before initialization */
      T * operator->()
      {
        if( !itsValid )
          throw Exception("Object must be initialized prior to accessing members");

        return itsPtr;
      }

      //! Returns a raw pointer to the initialized underlying object
      /*! This is mainly intended for use with passing an instance of
          a constructed object to cereal::base_class.

          It is strongly recommended to avoid using this function in
          any other circumstance.

          @return A raw pointer to the initialized type */
      T * ptr()
      {
        return operator->();
      }

    private:
      template <class Ar, class TT> friend struct ::cereal::memory_detail::LoadAndConstructLoadWrapper;
      template <class Ar, class TT> friend struct ::cereal::boost_variant_detail::LoadAndConstructLoadWrapper;

      construct( T * p ) : itsPtr( p ), itsEnableSharedRestoreFunction( [](){} ), itsValid( false ) {}
      construct( T * p, std::function<void()> enableSharedFunc ) : // g++4.7 ice with default lambda to std func
        itsPtr( p ), itsEnableSharedRestoreFunction( enableSharedFunc ), itsValid( false ) {}
      construct( construct const & ) = delete;
      construct & operator=( construct const & ) = delete;

      T * itsPtr;
      std::function<void()> itsEnableSharedRestoreFunction;
      bool itsValid;
  };

  // ######################################################################
  //! A class that can be made a friend to give cereal access to non public functions
  /*! If you desire non-public serialization functions within a class, cereal can only
      access these if you declare cereal::access a friend.

      @code{.cpp}
      class MyClass
      {
        private:
          friend class cereal::access; // gives access to the private serialize

          template <class Archive>
          void serialize( Archive & ar )
          {
            // some code
          }
      };
      @endcode
      @ingroup Access */
  class access
  {
    public:
      // ####### Standard Serialization ########################################
      template<class Archive, class T> inline
      static auto member_serialize(Archive & ar, T & t) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar))
      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar); }

      template<class Archive, class T> inline
      static auto member_save(Archive & ar, T const & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }

      template<class Archive, class T> inline
      static auto member_save_non_const(Archive & ar, T & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }

      template<class Archive, class T> inline
      static auto member_load(Archive & ar, T & t) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar))
      { return t.CEREAL_LOAD_FUNCTION_NAME(ar); }

      template<class Archive, class T> inline
      static auto member_save_minimal(Archive const & ar, T const & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }

      template<class Archive, class T> inline
      static auto member_save_minimal_non_const(Archive const & ar, T & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }

      template<class Archive, class T, class U> inline
      static auto member_load_minimal(Archive const & ar, T & t, U && u) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)))
      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)); }

      // ####### Versioned Serialization #######################################
      template<class Archive, class T> inline
      static auto member_serialize(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version))
      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version); }

      template<class Archive, class T> inline
      static auto member_save(Archive & ar, T const & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }

      template<class Archive, class T> inline
      static auto member_save_non_const(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }

      template<class Archive, class T> inline
      static auto member_load(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar, version))
      { return t.CEREAL_LOAD_FUNCTION_NAME(ar, version); }

      template<class Archive, class T> inline
      static auto member_save_minimal(Archive const & ar, T const & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }

      template<class Archive, class T> inline
      static auto member_save_minimal_non_const(Archive const & ar, T & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }

      template<class Archive, class T, class U> inline
      static auto member_load_minimal(Archive const & ar, T & t, U && u, const std::uint32_t version) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version))
      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version); }

      // ####### Other Functionality ##########################################
      // for detecting inheritance from enable_shared_from_this
      template <class T> inline
      static auto shared_from_this(T & t) -> decltype(t.shared_from_this());

      // for placement new
      template <class T, class ... Args> inline
      static void construct( T *& ptr, Args && ... args )
      {
        new (ptr) T( std::forward<Args>( args )... );
      }

      // for non-placement new with a default constructor
      template <class T> inline
      static T * construct()
      {
        return new T();
      }

      template <class T> inline
      static std::false_type load_and_construct(...)
      { return std::false_type(); }

      template<class T, class Archive> inline
      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct) -> decltype(T::load_and_construct(ar, construct))
      {
        T::load_and_construct( ar, construct );
      }

      template<class T, class Archive> inline
      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct, const std::uint32_t version) -> decltype(T::load_and_construct(ar, construct, version))
      {
        T::load_and_construct( ar, construct, version );
      }
  }; // end class access

  // ######################################################################
  // Deferred Implementation, see construct for more information
  template <class T> template <class ... Args> inline
  void construct<T>::operator()( Args && ... args )
  {
    if( itsValid )
      throw Exception("Attempting to construct an already initialized object");

    ::cereal::access::construct( itsPtr, std::forward<Args>( args )... );
    itsEnableSharedRestoreFunction();
    itsValid = true;
  }
} // namespace cereal

#endif // CEREAL_ACCESS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/adapters.hpp
================================================
/*! \file adapters.hpp
    \brief Archive adapters that provide additional functionality
           on top of an existing archive */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ARCHIVES_ADAPTERS_HPP_
#define CEREAL_ARCHIVES_ADAPTERS_HPP_

#include "cereal/details/helpers.hpp"
#include <utility>

namespace cereal
{
  #ifdef CEREAL_FUTURE_EXPERIMENTAL

  // Forward declaration for friend access
  template <class U, class A> U & get_user_data( A & );

  //! Wraps an archive and gives access to user data
  /*! This adapter is useful if you require access to
      either raw pointers or references within your
      serialization functions.

      While cereal does not directly support serialization
      raw pointers or references, it is sometimes the case
      that you may want to supply something such as a raw
      pointer or global reference to some constructor.
      In this situation this adapter would likely be used
      with the construct class to allow for non-default
      constructors.

      @note This feature is experimental and may be altered or removed in a future release. See issue #46.

      @code{.cpp}
      struct MyUserData
      {
        int * myRawPointer;
        std::reference_wrapper<MyOtherType> myReference;
      };

      struct MyClass
      {
        // Note the raw pointer parameter
        MyClass( int xx, int * rawP );

        int x;

        template <class Archive>
        void serialize( Archive & ar )
        { ar( x ); }

        template <class Archive>
        static void load_and_construct( Archive & ar, cereal::construct<MyClass> & construct )
        {
          int xx;
          ar( xx );
          // note the need to use get_user_data to retrieve user data from the archive
          construct( xx, cereal::get_user_data<MyUserData>( ar ).myRawPointer );
        }
      };

      int main()
      {
        {
          MyUserData md;
          md.myRawPointer = &something;
          md.myReference = someInstanceOfType;

          std::ifstream is( "data.xml" );
          cereal::UserDataAdapter<MyUserData, cereal::XMLInputArchive> ar( md, is );

          std::unique_ptr<MyClass> sc;
          ar( sc ); // use as normal
        }

        return 0;
      }
      @endcode

      @relates get_user_data

      @tparam UserData The type to give the archive access to
      @tparam Archive The archive to wrap */
  template <class UserData, class Archive>
  class UserDataAdapter : public Archive
  {
    public:
      //! Construct the archive with some user data struct
      /*! This will forward all arguments (other than the user
          data) to the wrapped archive type.  The UserDataAdapter
          can then be used identically to the wrapped archive type

          @tparam Args The arguments to pass to the constructor of
                       the archive. */
      template <class ... Args>
      UserDataAdapter( UserData & ud, Args && ... args ) :
        Archive( std::forward<Args>( args )... ),
        userdata( ud )
      { }

    private:
      //! Overload the rtti function to enable dynamic_cast
      void rtti() {}
      friend UserData & get_user_data<UserData>( Archive & ar );
      UserData & userdata; //!< The actual user data
  };

  //! Retrieves user data from an archive wrapped by UserDataAdapter
  /*! This will attempt to retrieve the user data associated with
      some archive wrapped by UserDataAdapter.  If this is used on
      an archive that is not wrapped, a run-time exception will occur.

      @note This feature is experimental and may be altered or removed in a future release. See issue #46.

      @note The correct use of this function cannot be enforced at compile
            time.

      @relates UserDataAdapter
      @tparam UserData The data struct contained in the archive
      @tparam Archive The archive, which should be wrapped by UserDataAdapter
      @param ar The archive
      @throws Exception if the archive this is used upon is not wrapped with
                        UserDataAdapter. */
  template <class UserData, class Archive>
  UserData & get_user_data( Archive & ar )
  {
    try
    {
      return dynamic_cast<UserDataAdapter<UserData, Archive> &>( ar ).userdata;
    }
    catch( std::bad_cast const & )
    {
      throw ::cereal::Exception("Attempting to get user data from archive not wrapped in UserDataAdapter");
    }
  }
  #endif // CEREAL_FUTURE_EXPERIMENTAL
} // namespace cereal

#endif // CEREAL_ARCHIVES_ADAPTERS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/binary.hpp
================================================
/*! \file binary.hpp
    \brief Binary input and output archives */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ARCHIVES_BINARY_HPP_
#define CEREAL_ARCHIVES_BINARY_HPP_

#include "cereal/cereal.hpp"
#include <sstream>

namespace cereal
{
  // ######################################################################
  //! An output archive designed to save data in a compact binary representation
  /*! This archive outputs data to a stream in an extremely compact binary
      representation with as little extra metadata as possible.

      This archive does nothing to ensure that the endianness of the saved
      and loaded data is the same.  If you need to have portability over
      architectures with different endianness, use PortableBinaryOutputArchive.

      When using a binary archive and a file stream, you must use the
      std::ios::binary format flag to avoid having your data altered
      inadvertently.

      \ingroup Archives */
  class BinaryOutputArchive : public OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>
  {
    public:
      //! Construct, outputting to the provided stream
      /*! @param stream The stream to output to.  Can be a stringstream, a file stream, or
                        even cout! */
      BinaryOutputArchive(std::ostream & stream) :
        OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>(this),
        itsStream(stream)
      { }

      ~BinaryOutputArchive() CEREAL_NOEXCEPT = default;

      //! Writes size bytes of data to the output stream
      void saveBinary( const void * data, std::streamsize size )
      {
        auto const writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );

        if(writtenSize != size)
          throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
      }

    private:
      std::ostream & itsStream;
  };

  // ######################################################################
  //! An input archive designed to load data saved using BinaryOutputArchive
  /*  This archive does nothing to ensure that the endianness of the saved
      and loaded data is the same.  If you need to have portability over
      architectures with different endianness, use PortableBinaryOutputArchive.

      When using a binary archive and a file stream, you must use the
      std::ios::binary format flag to avoid having your data altered
      inadvertently.

      \ingroup Archives */
  class BinaryInputArchive : public InputArchive<BinaryInputArchive, AllowEmptyClassElision>
  {
    public:
      //! Construct, loading from the provided stream
      BinaryInputArchive(std::istream & stream) :
        InputArchive<BinaryInputArchive, AllowEmptyClassElision>(this),
        itsStream(stream)
      { }

      ~BinaryInputArchive() CEREAL_NOEXCEPT = default;

      //! Reads size bytes of data from the input stream
      void loadBinary( void * const data, std::streamsize size )
      {
        auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );

        if(readSize != size)
          throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
      }

    private:
      std::istream & itsStream;
  };

  // ######################################################################
  // Common BinaryArchive serialization functions

  //! Saving for POD types to binary
  template<class T> inline
  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, T const & t)
  {
    ar.saveBinary(std::addressof(t), sizeof(t));
  }

  //! Loading for POD types from binary
  template<class T> inline
  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, T & t)
  {
    ar.loadBinary(std::addressof(t), sizeof(t));
  }

  //! Serializing NVP types to binary
  template <class Archive, class T> inline
  CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, NameValuePair<T> & t )
  {
    ar( t.value );
  }

  //! Serializing SizeTags to binary
  template <class Archive, class T> inline
  CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
  {
    ar( t.size );
  }

  //! Saving binary data
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, BinaryData<T> const & bd)
  {
    ar.saveBinary( bd.data, static_cast<std::streamsize>( bd.size ) );
  }

  //! Loading binary data
  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, BinaryData<T> & bd)
  {
    ar.loadBinary(bd.data, static_cast<std::streamsize>( bd.size ) );
  }
} // namespace cereal

// register archives for polymorphic support
CEREAL_REGISTER_ARCHIVE(cereal::BinaryOutputArchive)
CEREAL_REGISTER_ARCHIVE(cereal::BinaryInputArchive)

// tie input and output archives together
CEREAL_SETUP_ARCHIVE_TRAITS(cereal::BinaryInputArchive, cereal::BinaryOutputArchive)

#endif // CEREAL_ARCHIVES_BINARY_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/json.hpp
================================================
/*! \file json.hpp
    \brief JSON input and output archives */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ARCHIVES_JSON_HPP_
#define CEREAL_ARCHIVES_JSON_HPP_

#include "cereal/cereal.hpp"
#include "cereal/details/util.hpp"

namespace cereal
{
  //! An exception thrown when rapidjson fails an internal assertion
  /*! @ingroup Utility */
  struct RapidJSONException : Exception
  { RapidJSONException( const char * what_ ) : Exception( what_ ) {} };
}

// Inform rapidjson that assert will throw
#ifndef CEREAL_RAPIDJSON_ASSERT_THROWS
#define CEREAL_RAPIDJSON_ASSERT_THROWS
#endif // CEREAL_RAPIDJSON_ASSERT_THROWS

// Override rapidjson assertions to throw exceptions by default
#ifndef CEREAL_RAPIDJSON_ASSERT
#define CEREAL_RAPIDJSON_ASSERT(x) if(!(x)){ \
  throw ::cereal::RapidJSONException("rapidjson internal assertion failure: " #x); }
#endif // RAPIDJSON_ASSERT

// Enable support for parsing of nan, inf, -inf
#ifndef CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNanAndInfFlag
#endif

// Enable support for parsing of nan, inf, -inf
#ifndef CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS kParseFullPrecisionFlag | kParseNanAndInfFlag
#endif

#include "cereal/external/rapidjson/prettywriter.h"
#include "cereal/external/rapidjson/ostreamwrapper.h"
#include "cereal/external/rapidjson/istreamwrapper.h"
#include "cereal/external/rapidjson/document.h"
#include "cereal/external/base64.hpp"

#include <limits>
#include <sstream>
#include <stack>
#include <vector>
#include <string>

namespace cereal
{
  // ######################################################################
  //! An output archive designed to save data to JSON
  /*! This archive uses RapidJSON to build serialize data to JSON.

      JSON archives provides a human readable output but at decreased
      performance (both in time and space) compared to binary archives.

      JSON archives are only guaranteed to finish flushing their contents
      upon destruction and should thus be used in an RAII fashion.

      JSON benefits greatly from name-value pairs, which if present, will
      name the nodes in the output.  If these are not present, each level
      of the output will be given an automatically generated delimited name.

      The precision of the output archive controls the number of decimals output
      for floating point numbers and should be sufficiently large (i.e. at least 20)
      if there is a desire to have binary equality between the numbers output and
      those read in.  In general you should expect a loss of precision when going
      from floating point to text and back.

      JSON archives do not output the size information for any dynamically sized structure
      and instead infer it from the number of children for a node.  This means that data
      can be hand edited for dynamic sized structures and will still be readable.  This
      is accomplished through the cereal::SizeTag object, which will cause the archive
      to output the data as a JSON array (e.g. marked by [] instead of {}), which indicates
      that the container is variable sized and may be edited.

      \ingroup Archives */
  class JSONOutputArchive : public OutputArchive<JSONOutputArchive>, public traits::TextArchive
  {
    enum class NodeType { StartObject, InObject, StartArray, InArray };

    using WriteStream = CEREAL_RAPIDJSON_NAMESPACE::OStreamWrapper;
    using JSONWriter = CEREAL_RAPIDJSON_NAMESPACE::PrettyWriter<WriteStream>;

    public:
      /*! @name Common Functionality
          Common use cases for directly interacting with an JSONOutputArchive */
      //! @{

      //! A class containing various advanced options for the JSON archive
      class Options
      {
        public:
          //! Default options
          static Options Default(){ return Options(); }

          //! Default options with no indentation
          static Options NoIndent(){ return Options( JSONWriter::kDefaultMaxDecimalPlaces, IndentChar::space, 0 ); }

          //! The character to use for indenting
          enum class IndentChar : char
          {
            space = ' ',
            tab = '\t',
            newline = '\n',
            carriage_return = '\r'
          };

          //! Specify specific options for the JSONOutputArchive
          /*! @param precision The precision used for floating point numbers
              @param indentChar The type of character to indent with
              @param indentLength The number of indentChar to use for indentation
                             (0 corresponds to no indentation) */
          explicit Options( int precision = JSONWriter::kDefaultMaxDecimalPlaces,
                            IndentChar indentChar = IndentChar::space,
                            unsigned int indentLength = 4 ) :
            itsPrecision( precision ),
            itsIndentChar( static_cast<char>(indentChar) ),
            itsIndentLength( indentLength ) { }

        private:
          friend class JSONOutputArchive;
          int itsPrecision;
          char itsIndentChar;
          unsigned int itsIndentLength;
      };

      //! Construct, outputting to the provided stream
      /*! @param stream The stream to output to.
          @param options The JSON specific options to use.  See the Options struct
                         for the values of default parameters */
      JSONOutputArchive(std::ostream & stream, Options const & options = Options::Default() ) :
        OutputArchive<JSONOutputArchive>(this),
        itsWriteStream(stream),
        itsWriter(itsWriteStream),
        itsNextName(nullptr)
      {
        itsWriter.SetMaxDecimalPlaces( options.itsPrecision );
        itsWriter.SetIndent( options.itsIndentChar, options.itsIndentLength );
        itsNameCounter.push(0);
        itsNodeStack.push(NodeType::StartObject);
      }

      //! Destructor, flushes the JSON
      ~JSONOutputArchive() CEREAL_NOEXCEPT
      {
        if (itsNodeStack.top() == NodeType::InObject)
          itsWriter.EndObject();
        else if (itsNodeStack.top() == NodeType::InArray)
          itsWriter.EndArray();
      }

      //! Saves some binary data, encoded as a base64 string, with an optional name
      /*! This will create a new node, optionally named, and insert a value that consists of
          the data encoded as a base64 string */
      void saveBinaryValue( const void * data, size_t size, const char * name = nullptr )
      {
        setNextName( name );
        writeName();

        auto base64string = base64::encode( reinterpret_cast<const unsigned char *>( data ), size );
        saveValue( base64string );
      };

      //! @}
      /*! @name Internal Functionality
          Functionality designed for use by those requiring control over the inner mechanisms of
          the JSONOutputArchive */
      //! @{

      //! Starts a new node in the JSON output
      /*! The node can optionally be given a name by calling setNextName prior
          to creating the node

          Nodes only need to be started for types that are themselves objects or arrays */
      void startNode()
      {
        writeName();
        itsNodeStack.push(NodeType::StartObject);
        itsNameCounter.push(0);
      }

      //! Designates the most recently added node as finished
      void finishNode()
      {
        // if we ended up serializing an empty object or array, writeName
        // will never have been called - so start and then immediately end
        // the object/array.
        //
        // We'll also end any object/arrays we happen to be in
        switch(itsNodeStack.top())
        {
          case NodeType::StartArray:
            itsWriter.StartArray();
            // fall through
          case NodeType::InArray:
            itsWriter.EndArray();
            break;
          case NodeType::StartObject:
            itsWriter.StartObject();
            // fall through
          case NodeType::InObject:
            itsWriter.EndObject();
            break;
        }

        itsNodeStack.pop();
        itsNameCounter.pop();
      }

      //! Sets the name for the next node created with startNode
      void setNextName( const char * name )
      {
        itsNextName = name;
      }

      //! Saves a bool to the current node
      void saveValue(bool b)                { itsWriter.Bool(b);                                                         }
      //! Saves an int to the current node
      void saveValue(int i)                 { itsWriter.Int(i);                                                          }
      //! Saves a uint to the current node
      void saveValue(unsigned u)            { itsWriter.Uint(u);                                                         }
      //! Saves an int64 to the current node
      void saveValue(int64_t i64)           { itsWriter.Int64(i64);                                                      }
      //! Saves a uint64 to the current node
      void saveValue(uint64_t u64)          { itsWriter.Uint64(u64);                                                     }
      //! Saves a double to the current node
      void saveValue(double d)              { itsWriter.Double(d);                                                       }
      //! Saves a string to the current node
      void saveValue(std::string const & s) { itsWriter.String(s.c_str(), static_cast<CEREAL_RAPIDJSON_NAMESPACE::SizeType>( s.size() )); }
      //! Saves a const char * to the current node
      void saveValue(char const * s)        { itsWriter.String(s);                                                       }
      //! Saves a nullptr to the current node
      void saveValue(std::nullptr_t)        { itsWriter.Null();                                                          }

    private:
      // Some compilers/OS have difficulty disambiguating the above for various flavors of longs, so we provide
      // special overloads to handle these cases.

      //! 32 bit signed long saving to current node
      template <class T, traits::EnableIf<sizeof(T) == sizeof(std::int32_t),
                                          std::is_signed<T>::value> = traits::sfinae> inline
      void saveLong(T l){ saveValue( static_cast<std::int32_t>( l ) ); }

      //! non 32 bit signed long saving to current node
      template <class T, traits::EnableIf<sizeof(T) != sizeof(std::int32_t),
                                          std::is_signed<T>::value> = traits::sfinae> inline
      void saveLong(T l){ saveValue( static_cast<std::int64_t>( l ) ); }

      //! 32 bit unsigned long saving to current node
      template <class T, traits::EnableIf<sizeof(T) == sizeof(std::int32_t),
                                          std::is_unsigned<T>::value> = traits::sfinae> inline
      void saveLong(T lu){ saveValue( static_cast<std::uint32_t>( lu ) ); }

      //! non 32 bit unsigned long saving to current node
      template <class T, traits::EnableIf<sizeof(T) != sizeof(std::int32_t),
                                          std::is_unsigned<T>::value> = traits::sfinae> inline
      void saveLong(T lu){ saveValue( static_cast<std::uint64_t>( lu ) ); }

    public:
#ifdef _MSC_VER
      //! MSVC only long overload to current node
      void saveValue( unsigned long lu ){ saveLong( lu ); };
#else // _MSC_VER
      //! Serialize a long if it would not be caught otherwise
      template <class T, traits::EnableIf<std::is_same<T, long>::value,
                                          !std::is_same<T, std::int32_t>::value,
                                          !std::is_same<T, std::int64_t>::value> = traits::sfinae> inline
      void saveValue( T t ){ saveLong( t ); }

      //! Serialize an unsigned long if it would not be caught otherwise
      template <class T, traits::EnableIf<std::is_same<T, unsigned long>::value,
                                          !std::is_same<T, std::uint32_t>::value,
                                          !std::is_same<T, std::uint64_t>::value> = traits::sfinae> inline
      void saveValue( T t ){ saveLong( t ); }
#endif // _MSC_VER

      //! Save exotic arithmetic as strings to current node
      /*! Handles long long (if distinct from other types), unsigned long (if distinct), and long double */
      template <class T, traits::EnableIf<std::is_arithmetic<T>::value,
                                          !std::is_same<T, long>::value,
                                          !std::is_same<T, unsigned long>::value,
                                          !std::is_same<T, std::int64_t>::value,
                                          !std::is_same<T, std::uint64_t>::value,
                                          (sizeof(T) >= sizeof(long double) || sizeof(T) >= sizeof(long long))> = traits::sfinae> inline
      void saveValue(T const & t)
      {
        std::stringstream ss; ss.precision( std::numeric_limits<long double>::max_digits10 );
        ss << t;
        saveValue( ss.str() );
      }

      //! Write the name of the upcoming node and prepare object/array state
      /*! Since writeName is called for every value that is output, regardless of
          whether it has a name or not, it is the place where we will do a deferred
          check of our node state and decide whether we are in an array or an object.

          The general workflow of saving to the JSON archive is:

            1. (optional) Set the name for the next node to be created, usually done by an NVP
            2. Start the node
            3. (if there is data to save) Write the name of the node (this function)
            4. (if there is data to save) Save the data (with saveValue)
            5. Finish the node
          */
      void writeName()
      {
        NodeType const & nodeType = itsNodeStack.top();

        // Start up either an object or an array, depending on state
        if(nodeType == NodeType::StartArray)
        {
          itsWriter.StartArray();
          itsNodeStack.top() = NodeType::InArray;
        }
        else if(nodeType == NodeType::StartObject)
        {
          itsNodeStack.top() = NodeType::InObject;
          itsWriter.StartObject();
        }

        // Array types do not output names
        if(nodeType == NodeType::InArray) return;

        if(itsNextName == nullptr)
        {
          std::string name = "value" + std::to_string( itsNameCounter.top()++ ) + "\0";
          saveValue(name);
        }
        else
        {
          saveValue(itsNextName);
          itsNextName = nullptr;
        }
      }

      //! Designates that the current node should be output as an array, not an object
      void makeArray()
      {
        itsNodeStack.top() = NodeType::StartArray;
      }

      //! @}

    private:
      WriteStream itsWriteStream;          //!< Rapidjson write stream
      JSONWriter itsWriter;                //!< Rapidjson writer
      char const * itsNextName;            //!< The next name
      std::stack<uint32_t> itsNameCounter; //!< Counter for creating unique names for unnamed nodes
      std::stack<NodeType> itsNodeStack;
  }; // JSONOutputArchive

  // ######################################################################
  //! An input archive designed to load data from JSON
  /*! This archive uses RapidJSON to read in a JSON archive.

      As with the output JSON archive, the preferred way to use this archive is in
      an RAII fashion, ensuring its destruction after all data has been read.

      Input JSON should have been produced by the JSONOutputArchive.  Data can
      only be added to dynamically sized containers (marked by JSON arrays) -
      the input archive will determine their size by looking at the number of child nodes.
      Only JSON originating from a JSONOutputArchive is officially supported, but data
      from other sources may work if properly formatted.

      The JSONInputArchive does not require that nodes are loaded in the same
      order they were saved by JSONOutputArchive.  Using name value pairs (NVPs),
      it is possible to load in an out of order fashion or otherwise skip/select
      specific nodes to load.

      The default behavior of the input archive is to read sequentially starting
      with the first node and exploring its children.  When a given NVP does
      not match the read in name for a node, the archive will search for that
      node at the current level and load it if it exists.  After loading an out of
      order node, the archive will then proceed back to loading sequentially from
      its new position.

      Consider this simple example where loading of some data is skipped:

      @code{cpp}
      // imagine the input file has someData(1-9) saved in order at the top level node
      ar( someData1, someData2, someData3 );        // XML loads in the order it sees in the file
      ar( cereal::make_nvp( "hello", someData6 ) ); // NVP given does not
                                                    // match expected NVP name, so we search
                                                    // for the given NVP and load that value
      ar( someData7, someData8, someData9 );        // with no NVP given, loading resumes at its
                                                    // current location, proceeding sequentially
      @endcode

      \ingroup Archives */
  class JSONInputArchive : public InputArchive<JSONInputArchive>, public traits::TextArchive
  {
    private:
      using ReadStream = CEREAL_RAPIDJSON_NAMESPACE::IStreamWrapper;
      typedef CEREAL_RAPIDJSON_NAMESPACE::GenericValue<CEREAL_RAPIDJSON_NAMESPACE::UTF8<>> JSONValue;
      typedef JSONValue::ConstMemberIterator MemberIterator;
      typedef JSONValue::ConstValueIterator ValueIterator;
      typedef CEREAL_RAPIDJSON_NAMESPACE::Document::GenericValue GenericValue;

    public:
      /*! @name Common Functionality
          Common use cases for directly interacting with an JSONInputArchive */
      //! @{

      //! Construct, reading from the provided stream
      /*! @param stream The stream to read from */
      JSONInputArchive(std::istream & stream) :
        InputArchive<JSONInputArchive>(this),
        itsNextName( nullptr ),
        itsReadStream(stream)
      {
        itsDocument.ParseStream<>(itsReadStream);
        if (itsDocument.IsArray())
          itsIteratorStack.emplace_back(itsDocument.Begin(), itsDocument.End());
        else
          itsIteratorStack.emplace_back(itsDocument.MemberBegin(), itsDocument.MemberEnd());
      }

      ~JSONInputArchive() CEREAL_NOEXCEPT = default;

      //! Loads some binary data, encoded as a base64 string
      /*! This will automatically start and finish a node to load the data, and can be called directly by
          users.

          Note that this follows the same ordering rules specified in the class description in regards
          to loading in/out of order */
      void loadBinaryValue( void * data, size_t size, const char * name = nullptr )
      {
        itsNextName = name;

        std::string encoded;
        loadValue( encoded );
        auto decoded = base64::decode( encoded );

        if( size != decoded.size() )
          throw Exception("Decoded binary data size does not match specified size");

        std::memcpy( data, decoded.data(), decoded.size() );
        itsNextName = nullptr;
      };

    private:
      //! @}
      /*! @name Internal Functionality
          Functionality designed for use by those requiring control over the inner mechanisms of
          the JSONInputArchive */
      //! @{

      //! An internal iterator that handles both array and object types
      /*! This class is a variant and holds both types of iterators that
          rapidJSON supports - one for arrays and one for objects. */
      class Iterator
      {
        public:
          Iterator() : itsIndex( 0 ), itsType(Null_) {}

          Iterator(MemberIterator begin, MemberIterator end) :
            itsMemberItBegin(begin), itsMemberItEnd(end), itsIndex(0), itsType(Member)
          {
            if( std::distance( begin, end ) == 0 )
              itsType = Null_;
          }

          Iterator(ValueIterator begin, ValueIterator end) :
            itsValueItBegin(begin), itsIndex(0), itsType(Value)
          {
            if( std::distance( begin, end ) == 0 )
              itsType = Null_;
          }

          //! Advance to the next node
          Iterator & operator++()
          {
            ++itsIndex;
            return *this;
          }

          //! Get the value of the current node
          GenericValue const & value()
          {
            switch(itsType)
            {
              case Value : return itsValueItBegin[itsIndex];
              case Member: return itsMemberItBegin[itsIndex].value;
              default: throw cereal::Exception("JSONInputArchive internal error: null or empty iterator to object or array!");
            }
          }

          //! Get the name of the current node, or nullptr if it has no name
          const char * name() const
          {
            if( itsType == Member && (itsMemberItBegin + itsIndex) != itsMemberItEnd )
              return itsMemberItBegin[itsIndex].name.GetString();
            else
              return nullptr;
          }

          //! Adjust our position such that we are at the node with the given name
          /*! @throws Exception if no such named node exists */
          inline void search( const char * searchName )
          {
            const auto len = std::strlen( searchName );
            size_t index = 0;
            for( auto it = itsMemberItBegin; it != itsMemberItEnd; ++it, ++index )
            {
              const auto currentName = it->name.GetString();
              if( ( std::strncmp( searchName, currentName, len ) == 0 ) &&
                  ( std::strlen( currentName ) == len ) )
              {
                itsIndex = index;
                return;
              }
            }

            throw Exception("JSON Parsing failed - provided NVP (" + std::string(searchName) + ") not found");
          }

        private:
          MemberIterator itsMemberItBegin, itsMemberItEnd; //!< The member iterator (object)
          ValueIterator itsValueItBegin;                   //!< The value iterator (array)
          size_t itsIndex;                                 //!< The current index of this iterator
          enum Type {Value, Member, Null_} itsType;        //!< Whether this holds values (array) or members (objects) or nothing
      };

      //! Searches for the expectedName node if it doesn't match the actualName
      /*! This needs to be called before every load or node start occurs.  This function will
          check to see if an NVP has been provided (with setNextName) and if so, see if that name matches the actual
          next name given.  If the names do not match, it will search in the current level of the JSON for that name.
          If the name is not found, an exception will be thrown.

          Resets the NVP name after called.

          @throws Exception if an expectedName is given and not found */
      inline void search()
      {
        // The name an NVP provided with setNextName()
        if( itsNextName )
        {
          // The actual name of the current node
          auto const actualName = itsIteratorStack.back().name();

          // Do a search if we don't see a name coming up, or if the names don't match
          if( !actualName || std::strcmp( itsNextName, actualName ) != 0 )
            itsIteratorStack.back().search( itsNextName );
        }

        itsNextName = nullptr;
      }

    public:
      //! Starts a new node, going into its proper iterator
      /*! This places an iterator for the next node to be parsed onto the iterator stack.  If the next
          node is an array, this will be a value iterator, otherwise it will be a member iterator.

          By default our strategy is to start with the document root node and then recursively iterate through
          all children in the order they show up in the document.
          We don't need to know NVPs to do this; we'll just blindly load in the order things appear in.

          If we were given an NVP, we will search for it if it does not match our the name of the next node
          that would normally be loaded.  This functionality is provided by search(). */
      void startNode()
      {
        search();

        if(itsIteratorStack.back().value().IsArray())
          itsIteratorStack.emplace_back(itsIteratorStack.back().value().Begin(), itsIteratorStack.back().value().End());
        else
          itsIteratorStack.emplace_back(itsIteratorStack.back().value().MemberBegin(), itsIteratorStack.back().value().MemberEnd());
      }

      //! Finishes the most recently started node
      void finishNode()
      {
        itsIteratorStack.pop_back();
        ++itsIteratorStack.back();
      }

      //! Retrieves the current node name
      /*! @return nullptr if no name exists */
      const char * getNodeName() const
      {
        return itsIteratorStack.back().name();
      }

      //! Sets the name for the next node created with startNode
      void setNextName( const char * name )
      {
        itsNextName = name;
      }

      //! Loads a value from the current node - small signed overload
      template <class T, traits::EnableIf<std::is_signed<T>::value,
                                          sizeof(T) < sizeof(int64_t)> = traits::sfinae> inline
      void loadValue(T & val)
      {
        search();

        val = static_cast<T>( itsIteratorStack.back().value().GetInt() );
        ++itsIteratorStack.back();
      }

      //! Loads a value from the current node - small unsigned overload
      template <class T, traits::EnableIf<std::is_unsigned<T>::value,
                                          sizeof(T) < sizeof(uint64_t),
                                          !std::is_same<bool, T>::value> = traits::sfinae> inline
      void loadValue(T & val)
      {
        search();

        val = static_cast<T>( itsIteratorStack.back().value().GetUint() );
        ++itsIteratorStack.back();
      }

      //! Loads a value from the current node - bool overload
      void loadValue(bool & val)        { search(); val = itsIteratorStack.back().value().GetBool(); ++itsIteratorStack.back(); }
      //! Loads a value from the current node - int64 overload
      void loadValue(int64_t & val)     { search(); val = itsIteratorStack.back().value().GetInt64(); ++itsIteratorStack.back(); }
      //! Loads a value from the current node - uint64 overload
      void loadValue(uint64_t & val)    { search(); val = itsIteratorStack.back().value().GetUint64(); ++itsIteratorStack.back(); }
      //! Loads a value from the current node - float overload
      void loadValue(float & val)       { search(); val = static_cast<float>(itsIteratorStack.back().value().GetDouble()); ++itsIteratorStack.back(); }
      //! Loads a value from the current node - double overload
      void loadValue(double & val)      { search(); val = itsIteratorStack.back().value().GetDouble(); ++itsIteratorStack.back(); }
      //! Loads a value from the current node - string overload
      void loadValue(std::string & val) { search(); val = itsIteratorStack.back().value().GetString(); ++itsIteratorStack.back(); }
      //! Loads a nullptr from the current node
      void loadValue(std::nullptr_t&)   { search(); CEREAL_RAPIDJSON_ASSERT(itsIteratorStack.back().value().IsNull()); ++itsIteratorStack.back(); }

      // Special cases to handle various flavors of long, which tend to conflict with
      // the int32_t or int64_t on various compiler/OS combinations.  MSVC doesn't need any of this.
      #ifndef _MSC_VER
    private:
      //! 32 bit signed long loading from current node
      template <class T> inline
      typename std::enable_if<sizeof(T) == sizeof(std::int32_t) && std::is_signed<T>::value, void>::type
      loadLong(T & l){ loadValue( reinterpret_cast<std::int32_t&>( l ) ); }

      //! non 32 bit signed long loading from current node
      template <class T> inline
      typename std::enable_if<sizeof(T) == sizeof(std::int64_t) && std::is_signed<T>::value, void>::type
      loadLong(T & l){ loadValue( reinterpret_cast<std::int64_t&>( l ) ); }

      //! 32 bit unsigned long loading from current node
      template <class T> inline
      typename std::enable_if<sizeof(T) == sizeof(std::uint32_t) && !std::is_signed<T>::value, void>::type
      loadLong(T & lu){ loadValue( reinterpret_cast<std::uint32_t&>( lu ) ); }

      //! non 32 bit unsigned long loading from current node
      template <class T> inline
      typename std::enable_if<sizeof(T) == sizeof(std::uint64_t) && !std::is_signed<T>::value, void>::type
      loadLong(T & lu){ loadValue( reinterpret_cast<std::uint64_t&>( lu ) ); }

    public:
      //! Serialize a long if it would not be caught otherwise
      template <class T> inline
      typename std::enable_if<std::is_same<T, long>::value &&
                              sizeof(T) >= sizeof(std::int64_t) &&
                              !std::is_same<T, std::int64_t>::value, void>::type
      loadValue( T & t ){ loadLong(t); }

      //! Serialize an unsigned long if it would not be caught otherwise
      template <class T> inline
      typename std::enable_if<std::is_same<T, unsigned long>::value &&
                              sizeof(T) >= sizeof(std::uint64_t) &&
                              !std::is_same<T, std::uint64_t>::value, void>::type
      loadValue( T & t ){ loadLong(t); }
      #endif // _MSC_VER

    private:
      //! Convert a string to a long long
      void stringToNumber( std::string const & str, long long & val ) { val = std::stoll( str ); }
      //! Convert a string to an unsigned long long
      void stringToNumber( std::string const & str, unsigned long long & val ) { val = std::stoull( str ); }
      //! Convert a string to a long double
      void stringToNumber( std::string const & str, long double & val ) { val = std::stold( str ); }

    public:
      //! Loads a value from the current node - long double and long long overloads
      template <class T, traits::EnableIf<std::is_arithmetic<T>::value,
                                          !std::is_same<T, long>::value,
                                          !std::is_same<T, unsigned long>::value,
                                          !std::is_same<T, std::int64_t>::value,
                                          !std::is_same<T, std::uint64_t>::value,
                                          (sizeof(T) >= sizeof(long double) || sizeof(T) >= sizeof(long long))> = traits::sfinae>
      inline void loadValue(T & val)
      {
        std::string encoded;
        loadValue( encoded );
        stringToNumber( encoded, val );
      }

      //! Loads the size for a SizeTag
      void loadSize(size_type & size)
      {
        if (itsIteratorStack.size() == 1)
          size = itsDocument.Size();
        else
          size = (itsIteratorStack.rbegin() + 1)->value().Size();
      }

      //! @}

    private:
      const char * itsNextName;               //!< Next name set by NVP
      ReadStream itsReadStream;               //!< Rapidjson write stream
      std::vector<Iterator> itsIteratorStack; //!< 'Stack' of rapidJSON iterators
      CEREAL_RAPIDJSON_NAMESPACE::Document itsDocument; //!< Rapidjson document
  };

  // ######################################################################
  // JSONArchive prologue and epilogue functions
  // ######################################################################

  // ######################################################################
  //! Prologue for NVPs for JSON archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void prologue( JSONOutputArchive &, NameValuePair<T> const & )
  { }

  //! Prologue for NVPs for JSON archives
  template <class T> inline
  void prologue( JSONInputArchive &, NameValuePair<T> const & )
  { }

  // ######################################################################
  //! Epilogue for NVPs for JSON archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void epilogue( JSONOutputArchive &, NameValuePair<T> const & )
  { }

  //! Epilogue for NVPs for JSON archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void epilogue( JSONInputArchive &, NameValuePair<T> const & )
  { }

  // ######################################################################
  //! Prologue for deferred data for JSON archives
  /*! Do nothing for the defer wrapper */
  template <class T> inline
  void prologue( JSONOutputArchive &, DeferredData<T> const & )
  { }

  //! Prologue for deferred data for JSON archives
  template <class T> inline
  void prologue( JSONInputArchive &, DeferredData<T> const & )
  { }

  // ######################################################################
  //! Epilogue for deferred for JSON archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void epilogue( JSONOutputArchive &, DeferredData<T> const & )
  { }

  //! Epilogue for deferred for JSON archives
  /*! Do nothing for the defer wrapper */
  template <class T> inline
  void epilogue( JSONInputArchive &, DeferredData<T> const & )
  { }

  // ######################################################################
  //! Prologue for SizeTags for JSON archives
  /*! SizeTags are strictly ignored for JSON, they just indicate
      that the current node should be made into an array */
  template <class T> inline
  void prologue( JSONOutputArchive & ar, SizeTag<T> const & )
  {
    ar.makeArray();
  }

  //! Prologue for SizeTags for JSON archives
  template <class T> inline
  void prologue( JSONInputArchive &, SizeTag<T> const & )
  { }

  // ######################################################################
  //! Epilogue for SizeTags for JSON archives
  /*! SizeTags are strictly ignored for JSON */
  template <class T> inline
  void epilogue( JSONOutputArchive &, SizeTag<T> const & )
  { }

  //! Epilogue for SizeTags for JSON archives
  template <class T> inline
  void epilogue( JSONInputArchive &, SizeTag<T> const & )
  { }

  // ######################################################################
  //! Prologue for all other types for JSON archives (except minimal types)
  /*! Starts a new node, named either automatically or by some NVP,
      that may be given data by the type about to be archived

      Minimal types do not start or finish nodes */
  template <class T, traits::EnableIf<!std::is_arithmetic<T>::value,
                                      !traits::has_minimal_base_class_serialization<T, traits::has_minimal_output_serialization, JSONOutputArchive>::value,
                                      !traits::has_minimal_output_serialization<T, JSONOutputArchive>::value> = traits::sfinae>
  inline void prologue( JSONOutputArchive & ar, T const & )
  {
    ar.startNode();
  }

  //! Prologue for all other types for JSON archives
  template <class T, traits::EnableIf<!std::is_arithmetic<T>::value,
                                      !traits::has_minimal_base_class_serialization<T, traits::has_minimal_input_serialization, JSONInputArchive>::value,
                                      !traits::has_minimal_input_serialization<T, JSONInputArchive>::value> = traits::sfinae>
  inline void prologue( JSONInputArchive & ar, T const & )
  {
    ar.startNode();
  }

  // ######################################################################
  //! Epilogue for all other types other for JSON archives (except minimal types)
  /*! Finishes the node created in the prologue

      Minimal types do not start or finish nodes */
  template <class T, traits::EnableIf<!std::is_arithmetic<T>::value,
                                      !traits::has_minimal_base_class_serialization<T, traits::has_minimal_output_serialization, JSONOutputArchive>::value,
                                      !traits::has_minimal_output_serialization<T, JSONOutputArchive>::value> = traits::sfinae>
  inline void epilogue( JSONOutputArchive & ar, T const & )
  {
    ar.finishNode();
  }

  //! Epilogue for all other types other for JSON archives
  template <class T, traits::EnableIf<!std::is_arithmetic<T>::value,
                                      !traits::has_minimal_base_class_serialization<T, traits::has_minimal_input_serialization, JSONInputArchive>::value,
                                      !traits::has_minimal_input_serialization<T, JSONInputArchive>::value> = traits::sfinae>
  inline void epilogue( JSONInputArchive & ar, T const & )
  {
    ar.finishNode();
  }

  // ######################################################################
  //! Prologue for arithmetic types for JSON archives
  inline
  void prologue( JSONOutputArchive & ar, std::nullptr_t const & )
  {
    ar.writeName();
  }

  //! Prologue for arithmetic types for JSON archives
  inline
  void prologue( JSONInputArchive &, std::nullptr_t const & )
  { }

  // ######################################################################
  //! Epilogue for arithmetic types for JSON archives
  inline
  void epilogue( JSONOutputArchive &, std::nullptr_t const & )
  { }

  //! Epilogue for arithmetic types for JSON archives
  inline
  void epilogue( JSONInputArchive &, std::nullptr_t const & )
  { }

  // ######################################################################
  //! Prologue for arithmetic types for JSON archives
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void prologue( JSONOutputArchive & ar, T const & )
  {
    ar.writeName();
  }

  //! Prologue for arithmetic types for JSON archives
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void prologue( JSONInputArchive &, T const & )
  { }

  // ######################################################################
  //! Epilogue for arithmetic types for JSON archives
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void epilogue( JSONOutputArchive &, T const & )
  { }

  //! Epilogue for arithmetic types for JSON archives
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void epilogue( JSONInputArchive &, T const & )
  { }

  // ######################################################################
  //! Prologue for strings for JSON archives
  template<class CharT, class Traits, class Alloc> inline
  void prologue(JSONOutputArchive & ar, std::basic_string<CharT, Traits, Alloc> const &)
  {
    ar.writeName();
  }

  //! Prologue for strings for JSON archives
  template<class CharT, class Traits, class Alloc> inline
  void prologue(JSONInputArchive &, std::basic_string<CharT, Traits, Alloc> const &)
  { }

  // ######################################################################
  //! Epilogue for strings for JSON archives
  template<class CharT, class Traits, class Alloc> inline
  void epilogue(JSONOutputArchive &, std::basic_string<CharT, Traits, Alloc> const &)
  { }

  //! Epilogue for strings for JSON archives
  template<class CharT, class Traits, class Alloc> inline
  void epilogue(JSONInputArchive &, std::basic_string<CharT, Traits, Alloc> const &)
  { }

  // ######################################################################
  // Common JSONArchive serialization functions
  // ######################################################################
  //! Serializing NVP types to JSON
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( JSONOutputArchive & ar, NameValuePair<T> const & t )
  {
    ar.setNextName( t.name );
    ar( t.value );
  }

  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( JSONInputArchive & ar, NameValuePair<T> & t )
  {
    ar.setNextName( t.name );
    ar( t.value );
  }

  //! Saving for nullptr to JSON
  inline
  void CEREAL_SAVE_FUNCTION_NAME(JSONOutputArchive & ar, std::nullptr_t const & t)
  {
    ar.saveValue( t );
  }

  //! Loading arithmetic from JSON
  inline
  void CEREAL_LOAD_FUNCTION_NAME(JSONInputArchive & ar, std::nullptr_t & t)
  {
    ar.loadValue( t );
  }

  //! Saving for arithmetic to JSON
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void CEREAL_SAVE_FUNCTION_NAME(JSONOutputArchive & ar, T const & t)
  {
    ar.saveValue( t );
  }

  //! Loading arithmetic from JSON
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void CEREAL_LOAD_FUNCTION_NAME(JSONInputArchive & ar, T & t)
  {
    ar.loadValue( t );
  }

  //! saving string to JSON
  template<class CharT, class Traits, class Alloc> inline
  void CEREAL_SAVE_FUNCTION_NAME(JSONOutputArchive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
  {
    ar.saveValue( str );
  }

  //! loading string from JSON
  template<class CharT, class Traits, class Alloc> inline
  void CEREAL_LOAD_FUNCTION_NAME(JSONInputArchive & ar, std::basic_string<CharT, Traits, Alloc> & str)
  {
    ar.loadValue( str );
  }

  // ######################################################################
  //! Saving SizeTags to JSON
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( JSONOutputArchive &, SizeTag<T> const & )
  {
    // nothing to do here, we don't explicitly save the size
  }

  //! Loading SizeTags from JSON
  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( JSONInputArchive & ar, SizeTag<T> & st )
  {
    ar.loadSize( st.size );
  }
} // namespace cereal

// register archives for polymorphic support
CEREAL_REGISTER_ARCHIVE(cereal::JSONInputArchive)
CEREAL_REGISTER_ARCHIVE(cereal::JSONOutputArchive)

// tie input and output archives together
CEREAL_SETUP_ARCHIVE_TRAITS(cereal::JSONInputArchive, cereal::JSONOutputArchive)

#endif // CEREAL_ARCHIVES_JSON_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/portable_binary.hpp
================================================
/*! \file binary.hpp
    \brief Binary input and output archives */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ARCHIVES_PORTABLE_BINARY_HPP_
#define CEREAL_ARCHIVES_PORTABLE_BINARY_HPP_

#include "cereal/cereal.hpp"
#include <sstream>
#include <limits>

namespace cereal
{
  namespace portable_binary_detail
  {
    //! Returns true if the current machine is little endian
    /*! @ingroup Internal */
    inline std::uint8_t is_little_endian()
    {
      static std::int32_t test = 1;
      return *reinterpret_cast<std::int8_t*>( &test ) == 1;
    }

    //! Swaps the order of bytes for some chunk of memory
    /*! @param data The data as a uint8_t pointer
        @tparam DataSize The true size of the data
        @ingroup Internal */
    template <std::size_t DataSize>
    inline void swap_bytes( std::uint8_t * data )
    {
      for( std::size_t i = 0, end = DataSize / 2; i < end; ++i )
        std::swap( data[i], data[DataSize - i - 1] );
    }
  } // end namespace portable_binary_detail

  // ######################################################################
  //! An output archive designed to save data in a compact binary representation portable over different architectures
  /*! This archive outputs data to a stream in an extremely compact binary
      representation with as little extra metadata as possible.

      This archive will record the endianness of the data as well as the desired in/out endianness
      and assuming that the user takes care of ensuring serialized types are the same size
      across machines, is portable over different architectures.

      When using a binary archive and a file stream, you must use the
      std::ios::binary format flag to avoid having your data altered
      inadvertently.

      \warning This archive has not been thoroughly tested across different architectures.
               Please report any issues, optimizations, or feature requests at
               <a href="www.github.com/USCiLab/cereal">the project github</a>.

    \ingroup Archives */
  class PortableBinaryOutputArchive : public OutputArchive<PortableBinaryOutputArchive, AllowEmptyClassElision>
  {
    public:
      //! A class containing various advanced options for the PortableBinaryOutput archive
      class Options
      {
        public:
          //! Represents desired endianness
          enum class Endianness : std::uint8_t
          { big, little };

          //! Default options, preserve system endianness
          static Options Default(){ return Options(); }

          //! Save as little endian
          static Options LittleEndian(){ return Options( Endianness::little ); }

          //! Save as big endian
          static Options BigEndian(){ return Options( Endianness::big ); }

          //! Specify specific options for the PortableBinaryOutputArchive
          /*! @param outputEndian The desired endianness of saved (output) data */
          explicit Options( Endianness outputEndian = getEndianness() ) :
            itsOutputEndianness( outputEndian ) { }

        private:
          //! Gets the endianness of the system
          inline static Endianness getEndianness()
          { return portable_binary_detail::is_little_endian() ? Endianness::little : Endianness::big; }

          //! Checks if Options is set for little endian
          inline std::uint8_t is_little_endian() const
          { return itsOutputEndianness == Endianness::little; }

          friend class PortableBinaryOutputArchive;
          Endianness itsOutputEndianness;
      };

      //! Construct, outputting to the provided stream
      /*! @param stream The stream to output to. Should be opened with std::ios::binary flag.
          @param options The PortableBinary specific options to use.  See the Options struct
                         for the values of default parameters */
      PortableBinaryOutputArchive(std::ostream & stream, Options const & options = Options::Default()) :
        OutputArchive<PortableBinaryOutputArchive, AllowEmptyClassElision>(this),
        itsStream(stream),
        itsConvertEndianness( portable_binary_detail::is_little_endian() ^ options.is_little_endian() )
      {
        this->operator()( options.is_little_endian() );
      }

      ~PortableBinaryOutputArchive() CEREAL_NOEXCEPT = default;

      //! Writes size bytes of data to the output stream
      template <std::streamsize DataSize> inline
      void saveBinary( const void * data, std::streamsize size )
      {
        std::streamsize writtenSize = 0;

        if( itsConvertEndianness )
        {
          for( std::streamsize i = 0; i < size; i += DataSize )
            for( std::streamsize j = 0; j < DataSize; ++j )
              writtenSize += itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ) + DataSize - j - 1 + i, 1 );
        }
        else
          writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );

        if(writtenSize != size)
          throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
      }

    private:
      std::ostream & itsStream;
      const uint8_t itsConvertEndianness; //!< If set to true, we will need to swap bytes upon saving
  };

  // ######################################################################
  //! An input archive designed to load data saved using PortableBinaryOutputArchive
  /*! This archive outputs data to a stream in an extremely compact binary
      representation with as little extra metadata as possible.

      This archive will load the endianness of the serialized data and
      if necessary transform it to match that of the local machine.  This comes
      at a significant performance cost compared to non portable archives if
      the transformation is necessary, and also causes a small performance hit
      even if it is not necessary.

      It is recommended to use portable archives only if you know that you will
      be sending binary data to machines with different endianness.

      The archive will do nothing to ensure types are the same size - that is
      the responsibility of the user.

      When using a binary archive and a file stream, you must use the
      std::ios::binary format flag to avoid having your data altered
      inadvertently.

      \warning This archive has not been thoroughly tested across different architectures.
               Please report any issues, optimizations, or feature requests at
               <a href="www.github.com/USCiLab/cereal">the project github</a>.

    \ingroup Archives */
  class PortableBinaryInputArchive : public InputArchive<PortableBinaryInputArchive, AllowEmptyClassElision>
  {
    public:
      //! A class containing various advanced options for the PortableBinaryInput archive
      class Options
      {
        public:
          //! Represents desired endianness
          enum class Endianness : std::uint8_t
          { big, little };

          //! Default options, preserve system endianness
          static Options Default(){ return Options(); }

          //! Load into little endian
          static Options LittleEndian(){ return Options( Endianness::little ); }

          //! Load into big endian
          static Options BigEndian(){ return Options( Endianness::big ); }

          //! Specify specific options for the PortableBinaryInputArchive
          /*! @param inputEndian The desired endianness of loaded (input) data */
          explicit Options( Endianness inputEndian = getEndianness() ) :
            itsInputEndianness( inputEndian ) { }

        private:
          //! Gets the endianness of the system
          inline static Endianness getEndianness()
          { return portable_binary_detail::is_little_endian() ? Endianness::little : Endianness::big; }

          //! Checks if Options is set for little endian
          inline std::uint8_t is_little_endian() const
          { return itsInputEndianness == Endianness::little; }

          friend class PortableBinaryInputArchive;
          Endianness itsInputEndianness;
      };

      //! Construct, loading from the provided stream
      /*! @param stream The stream to read from. Should be opened with std::ios::binary flag.
          @param options The PortableBinary specific options to use.  See the Options struct
                         for the values of default parameters */
      PortableBinaryInputArchive(std::istream & stream, Options const & options = Options::Default()) :
        InputArchive<PortableBinaryInputArchive, AllowEmptyClassElision>(this),
        itsStream(stream),
        itsConvertEndianness( false )
      {
        uint8_t streamLittleEndian;
        this->operator()( streamLittleEndian );
        itsConvertEndianness = options.is_little_endian() ^ streamLittleEndian;
      }

      ~PortableBinaryInputArchive() CEREAL_NOEXCEPT = default;

      //! Reads size bytes of data from the input stream
      /*! @param data The data to save
          @param size The number of bytes in the data
          @tparam DataSize T The size of the actual type of the data elements being loaded */
      template <std::streamsize DataSize> inline
      void loadBinary( void * const data, std::streamsize size )
      {
        // load data
        auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );

        if(readSize != size)
          throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));

        // flip bits if needed
        if( itsConvertEndianness )
        {
          std::uint8_t * ptr = reinterpret_cast<std::uint8_t*>( data );
          for( std::streamsize i = 0; i < size; i += DataSize )
            portable_binary_detail::swap_bytes<DataSize>( ptr + i );
        }
      }

    private:
      std::istream & itsStream;
      uint8_t itsConvertEndianness; //!< If set to true, we will need to swap bytes upon loading
  };

  // ######################################################################
  // Common BinaryArchive serialization functions

  //! Saving for POD types to portable binary
  template<class T> inline
  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME(PortableBinaryOutputArchive & ar, T const & t)
  {
    static_assert( !std::is_floating_point<T>::value ||
                   (std::is_floating_point<T>::value && std::numeric_limits<T>::is_iec559),
                   "Portable binary only supports IEEE 754 standardized floating point" );
    ar.template saveBinary<sizeof(T)>(std::addressof(t), sizeof(t));
  }

  //! Loading for POD types from portable binary
  template<class T> inline
  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME(PortableBinaryInputArchive & ar, T & t)
  {
    static_assert( !std::is_floating_point<T>::value ||
                   (std::is_floating_point<T>::value && std::numeric_limits<T>::is_iec559),
                   "Portable binary only supports IEEE 754 standardized floating point" );
    ar.template loadBinary<sizeof(T)>(std::addressof(t), sizeof(t));
  }

  //! Serializing NVP types to portable binary
  template <class Archive, class T> inline
  CEREAL_ARCHIVE_RESTRICT(PortableBinaryInputArchive, PortableBinaryOutputArchive)
  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, NameValuePair<T> & t )
  {
    ar( t.value );
  }

  //! Serializing SizeTags to portable binary
  template <class Archive, class T> inline
  CEREAL_ARCHIVE_RESTRICT(PortableBinaryInputArchive, PortableBinaryOutputArchive)
  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
  {
    ar( t.size );
  }

  //! Saving binary data to portable binary
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME(PortableBinaryOutputArchive & ar, BinaryData<T> const & bd)
  {
    typedef typename std::remove_pointer<T>::type TT;
    static_assert( !std::is_floating_point<TT>::value ||
                   (std::is_floating_point<TT>::value && std::numeric_limits<TT>::is_iec559),
                   "Portable binary only supports IEEE 754 standardized floating point" );

    ar.template saveBinary<sizeof(TT)>( bd.data, static_cast<std::streamsize>( bd.size ) );
  }

  //! Loading binary data from portable binary
  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME(PortableBinaryInputArchive & ar, BinaryData<T> & bd)
  {
    typedef typename std::remove_pointer<T>::type TT;
    static_assert( !std::is_floating_point<TT>::value ||
                   (std::is_floating_point<TT>::value && std::numeric_limits<TT>::is_iec559),
                   "Portable binary only supports IEEE 754 standardized floating point" );

    ar.template loadBinary<sizeof(TT)>( bd.data, static_cast<std::streamsize>( bd.size ) );
  }
} // namespace cereal

// register archives for polymorphic support
CEREAL_REGISTER_ARCHIVE(cereal::PortableBinaryOutputArchive)
CEREAL_REGISTER_ARCHIVE(cereal::PortableBinaryInputArchive)

// tie input and output archives together
CEREAL_SETUP_ARCHIVE_TRAITS(cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive)

#endif // CEREAL_ARCHIVES_PORTABLE_BINARY_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/xml.hpp
================================================
/*! \file xml.hpp
    \brief XML input and output archives */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_ARCHIVES_XML_HPP_
#define CEREAL_ARCHIVES_XML_HPP_
#include "cereal/cereal.hpp"
#include "cereal/details/util.hpp"

#include "cereal/external/rapidxml/rapidxml.hpp"
#include "cereal/external/rapidxml/rapidxml_print.hpp"
#include "cereal/external/base64.hpp"

#include <sstream>
#include <stack>
#include <vector>
#include <limits>
#include <string>
#include <cstring>
#include <cmath>

namespace cereal
{
  namespace xml_detail
  {
    #ifndef CEREAL_XML_STRING_VALUE
    //! The default name for the root node in a cereal xml archive.
    /*! You can define CEREAL_XML_STRING_VALUE to be different assuming you do so
        before this file is included. */
    #define CEREAL_XML_STRING_VALUE "cereal"
    #endif // CEREAL_XML_STRING_VALUE

    //! The name given to the root node in a cereal xml archive
    static const char * CEREAL_XML_STRING = CEREAL_XML_STRING_VALUE;

    //! Returns true if the character is whitespace
    inline bool isWhitespace( char c )
    {
      return c == ' ' || c == '\t' || c == '\n' || c == '\r';
    }
  }

  // ######################################################################
  //! An output archive designed to save data to XML
  /*! This archive uses RapidXML to build an in memory XML tree of the
      data it serializes before outputting it to its stream upon destruction.
      This archive should be used in an RAII fashion, letting
      the automatic destruction of the object cause the flush to its stream.

      XML archives provides a human readable output but at decreased
      performance (both in time and space) compared to binary archives.

      XML benefits greatly from name-value pairs, which if present, will
      name the nodes in the output.  If these are not present, each level
      of the output tree will be given an automatically generated delimited name.

      The precision of the output archive controls the number of decimals output
      for floating point numbers and should be sufficiently large (i.e. at least 20)
      if there is a desire to have binary equality between the numbers output and
      those read in.  In general you should expect a loss of precision when going
      from floating point to text and back.

      XML archives can optionally print the type of everything they serialize, which
      adds an attribute to each node.

      XML archives do not output the size information for any dynamically sized structure
      and instead infer it from the number of children for a node.  This means that data
      can be hand edited for dynamic sized structures and will still be readable.  This
      is accomplished through the cereal::SizeTag object, which will also add an attribute
      to its parent field.
      \ingroup Archives */
  class XMLOutputArchive : public OutputArchive<XMLOutputArchive>, public traits::TextArchive
  {
    public:
      /*! @name Common Functionality
          Common use cases for directly interacting with an XMLOutputArchive */
      //! @{

      //! A class containing various advanced options for the XML archive
      /*! Options can either be directly passed to the constructor, or chained using the
          modifier functions for an interface analogous to named parameters */
      class Options
      {
        public:
          //! Default options
          static Options Default(){ return Options(); }

          //! Specify specific options for the XMLOutputArchive
          /*! @param precision_ The precision used for floating point numbers
              @param indent_ Whether to indent each line of XML
              @param outputType_ Whether to output the type of each serialized object as an attribute
              @param sizeAttributes_ Whether dynamically sized containers output the size=dynamic attribute */
          explicit Options( int precision_ = std::numeric_limits<double>::max_digits10,
                            bool indent_ = true,
                            bool outputType_ = false,
                            bool sizeAttributes_ = true ) :
            itsPrecision( precision_ ),
            itsIndent( indent_ ),
            itsOutputType( outputType_ ),
            itsSizeAttributes( sizeAttributes_ )
          { }

          /*! @name Option Modifiers
              An interface for setting option settings analogous to named parameters.

              @code{cpp}
              cereal::XMLOutputArchive ar( myStream,
                                           cereal::XMLOutputArchive::Options()
                                           .indent(true)
                                           .sizeAttributes(false) );
              @endcode
              */
          //! @{

          //! Sets the precision used for floaing point numbers
          Options & precision( int value ){ itsPrecision = value; return * this; }
          //! Whether to indent each line of XML
          Options & indent( bool enable ){ itsIndent = enable; return *this; }
          //! Whether to output the type of each serialized object as an attribute
          Options & outputType( bool enable ){ itsOutputType = enable; return *this; }
          //! Whether dynamically sized containers (e.g. vector) output the size=dynamic attribute
          Options & sizeAttributes( bool enable ){ itsSizeAttributes = enable; return *this; }

          //! @}

        private:
          friend class XMLOutputArchive;
          int itsPrecision;
          bool itsIndent;
          bool itsOutputType;
          bool itsSizeAttributes;
      };

      //! Construct, outputting to the provided stream upon destruction
      /*! @param stream  The stream to output to.  Note that XML is only guaranteed to flush
                         its output to the stream upon destruction.
          @param options The XML specific options to use.  See the Options struct
                         for the values of default parameters */
      XMLOutputArchive( std::ostream & stream, Options const & options = Options::Default() ) :
        OutputArchive<XMLOutputArchive>(this),
        itsStream(stream),
        itsOutputType( options.itsOutputType ),
        itsIndent( options.itsIndent ),
        itsSizeAttributes(options.itsSizeAttributes)
      {
        // rapidxml will delete all allocations when xml_document is cleared
        auto node = itsXML.allocate_node( rapidxml::node_declaration );
        node->append_attribute( itsXML.allocate_attribute( "version", "1.0" ) );
        node->append_attribute( itsXML.allocate_attribute( "encoding", "utf-8" ) );
        itsXML.append_node( node );

        // allocate root node
        auto root = itsXML.allocate_node( rapidxml::node_element, xml_detail::CEREAL_XML_STRING );
        itsXML.append_node( root );
        itsNodes.emplace( root );

        // set attributes on the streams
        itsStream << std::boolalpha;
        itsStream.precision( options.itsPrecision );
        itsOS << std::boolalpha;
        itsOS.precision( options.itsPrecision );
      }

      //! Destructor, flushes the XML
      ~XMLOutputArchive() CEREAL_NOEXCEPT
      {
        const int flags = itsIndent ? 0x0 : rapidxml::print_no_indenting;
        rapidxml::print( itsStream, itsXML, flags );
        itsXML.clear();
      }

      //! Saves some binary data, encoded as a base64 string, with an optional name
      /*! This can be called directly by users and it will automatically create a child node for
          the current XML node, populate it with a base64 encoded string, and optionally name
          it.  The node will be finished after it has been populated.  */
      void saveBinaryValue( const void * data, size_t size, const char * name = nullptr )
      {
        itsNodes.top().name = name;

        startNode();

        auto base64string = base64::encode( reinterpret_cast<const unsigned char *>( data ), size );
        saveValue( base64string );

        if( itsOutputType )
          itsNodes.top().node->append_attribute( itsXML.allocate_attribute( "type", "cereal binary data" ) );

        finishNode();
      }

      //! @}
      /*! @name Internal Functionality
          Functionality designed for use by those requiring control over the inner mechanisms of
          the XMLOutputArchive */
      //! @{

      //! Creates a new node that is a child of the node at the top of the stack
      /*! Nodes will be given a name that has either been pre-set by a name value pair,
          or generated based upon a counter unique to the parent node.  If you want to
          give a node a specific name, use setNextName prior to calling startNode.

          The node will then be pushed onto the node stack. */
      void startNode()
      {
        // generate a name for this new node
        const auto nameString = itsNodes.top().getValueName();

        // allocate strings for all of the data in the XML object
        auto namePtr = itsXML.allocate_string( nameString.data(), nameString.length() + 1 );

        // insert into the XML
        auto node = itsXML.allocate_node( rapidxml::node_element, namePtr, nullptr, nameString.size() );
        itsNodes.top().node->append_node( node );
        itsNodes.emplace( node );
      }

      //! Designates the most recently added node as finished
      void finishNode()
      {
        itsNodes.pop();
      }

      //! Sets the name for the next node created with startNode
      void setNextName( const char * name )
      {
        itsNodes.top().name = name;
      }

      //! Saves some data, encoded as a string, into the current top level node
      /*! The data will be be named with the most recent name if one exists,
          otherwise it will be given some default delimited value that depends upon
          the parent node */
      template <class T> inline
      void saveValue( T const & value )
      {
        itsOS.clear(); itsOS.seekp( 0, std::ios::beg );
        itsOS << value << std::ends;

        auto strValue = itsOS.str();

        // itsOS.str() may contain data from previous calls after the first '\0' that was just inserted
        // and this data is counted in the length call. We make sure to remove that section so that the
        // whitespace validation is done properly
        strValue.resize(std::strlen(strValue.c_str()));

        // If the first or last character is a whitespace, add xml:space attribute
        const auto len = strValue.length();
        if ( len > 0 && ( xml_detail::isWhitespace( strValue[0] ) || xml_detail::isWhitespace( strValue[len - 1] ) ) )
        {
          itsNodes.top().node->append_attribute( itsXML.allocate_attribute( "xml:space", "preserve" ) );
        }

        // allocate strings for all of the data in the XML object
        auto dataPtr = itsXML.allocate_string(strValue.c_str(), strValue.length() + 1 );

        // insert into the XML
        itsNodes.top().node->append_node( itsXML.allocate_node( rapidxml::node_data, nullptr, dataPtr ) );
      }

      //! Overload for uint8_t prevents them from being serialized as characters
      void saveValue( uint8_t const & value )
      {
        saveValue( static_cast<uint32_t>( value ) );
      }

      //! Overload for int8_t prevents them from being serialized as characters
      void saveValue( int8_t const & value )
      {
        saveValue( static_cast<int32_t>( value ) );
      }

      //! Causes the type to be appended as an attribute to the most recently made node if output type is set to true
      template <class T> inline
      void insertType()
      {
        if( !itsOutputType )
          return;

        // generate a name for this new node
        const auto nameString = util::demangledName<T>();

        // allocate strings for all of the data in the XML object
        auto namePtr = itsXML.allocate_string( nameString.data(), nameString.length() + 1 );

        itsNodes.top().node->append_attribute( itsXML.allocate_attribute( "type", namePtr ) );
      }

      //! Appends an attribute to the current top level node
      void appendAttribute( const char * name, const char * value )
      {
        auto namePtr =  itsXML.allocate_string( name );
        auto valuePtr = itsXML.allocate_string( value );
        itsNodes.top().node->append_attribute( itsXML.allocate_attribute( namePtr, valuePtr ) );
      }

      bool hasSizeAttributes() const { return itsSizeAttributes; }

    protected:
      //! A struct that contains metadata about a node
      struct NodeInfo
      {
        NodeInfo( rapidxml::xml_node<> * n = nullptr,
                  const char * nm = nullptr ) :
          node( n ),
          counter( 0 ),
          name( nm )
        { }

        rapidxml::xml_node<> * node; //!< A pointer to this node
        size_t counter;              //!< The counter for naming child nodes
        const char * name;           //!< The name for the next child node

        //! Gets the name for the next child node created from this node
        /*! The name will be automatically generated using the counter if
            a name has not been previously set.  If a name has been previously
            set, that name will be returned only once */
        std::string getValueName()
        {
          if( name )
          {
            auto n = name;
            name = nullptr;
            return {n};
          }
          else
            return "value" + std::to_string( counter++ ) + "\0";
        }
      }; // NodeInfo

      //! @}

    private:
      std::ostream & itsStream;        //!< The output stream
      rapidxml::xml_document<> itsXML; //!< The XML document
      std::stack<NodeInfo> itsNodes;   //!< A stack of nodes added to the document
      std::ostringstream itsOS;        //!< Used to format strings internally
      bool itsOutputType;              //!< Controls whether type information is printed
      bool itsIndent;                  //!< Controls whether indenting is used
      bool itsSizeAttributes;          //!< Controls whether lists have a size attribute
  }; // XMLOutputArchive

  // ######################################################################
  //! An output archive designed to load data from XML
  /*! This archive uses RapidXML to build an in memory XML tree of the
      data in the stream it is given before loading any types serialized.

      As with the output XML archive, the preferred way to use this archive is in
      an RAII fashion, ensuring its destruction after all data has been read.

      Input XML should have been produced by the XMLOutputArchive.  Data can
      only be added to dynamically sized containers - the input archive will
      determine their size by looking at the number of child nodes.  Data that
      did not originate from an XMLOutputArchive is not officially supported,
      but may be possible to use if properly formatted.

      The XMLInputArchive does not require that nodes are loaded in the same
      order they were saved by XMLOutputArchive.  Using name value pairs (NVPs),
      it is possible to load in an out of order fashion or otherwise skip/select
      specific nodes to load.

      The default behavior of the input archive is to read sequentially starting
      with the first node and exploring its children.  When a given NVP does
      not match the read in name for a node, the archive will search for that
      node at the current level and load it if it exists.  After loading an out of
      order node, the archive will then proceed back to loading sequentially from
      its new position.

      Consider this simple example where loading of some data is skipped:

      @code{cpp}
      // imagine the input file has someData(1-9) saved in order at the top level node
      ar( someData1, someData2, someData3 );        // XML loads in the order it sees in the file
      ar( cereal::make_nvp( "hello", someData6 ) ); // NVP given does not
                                                    // match expected NVP name, so we search
                                                    // for the given NVP and load that value
      ar( someData7, someData8, someData9 );        // with no NVP given, loading resumes at its
                                                    // current location, proceeding sequentially
      @endcode

      \ingroup Archives */
  class XMLInputArchive : public InputArchive<XMLInputArchive>, public traits::TextArchive
  {
    public:
      /*! @name Common Functionality
          Common use cases for directly interacting with an XMLInputArchive */
      //! @{

      //! Construct, reading in from the provided stream
      /*! Reads in an entire XML document from some stream and parses it as soon
          as serialization starts

          @param stream The stream to read from.  Can be a stringstream or a file. */
      XMLInputArchive( std::istream & stream ) :
        InputArchive<XMLInputArchive>( this ),
        itsData( std::istreambuf_iterator<char>( stream ), std::istreambuf_iterator<char>() )
      {
        try
        {
          itsData.push_back('\0'); // rapidxml will do terrible things without the data being null terminated
          itsXML.parse<rapidxml::parse_trim_whitespace | rapidxml::parse_no_data_nodes | rapidxml::parse_declaration_node>( reinterpret_cast<char *>( itsData.data() ) );
        }
        catch( rapidxml::parse_error const & )
        {
          //std::cerr << "-----Original-----" << std::endl;
          //stream.seekg(0);
          //std::cout << std::string( std::istreambuf_iterator<char>( stream ), std::istreambuf_iterator<char>() ) << std::endl;

          //std::cerr << "-----Error-----" << std::endl;
          //std::cerr << e.what() << std::endl;
          //std::cerr << e.where<char>() << std::endl;
          throw Exception("XML Parsing failed - likely due to invalid characters or invalid naming");
        }

        // Parse the root
        auto root = itsXML.first_node( xml_detail::CEREAL_XML_STRING );
        if( root == nullptr )
          throw Exception("Could not detect cereal root node - likely due to empty or invalid input");
        else
          itsNodes.emplace( root );
      }

      ~XMLInputArchive() CEREAL_NOEXCEPT = default;

      //! Loads some binary data, encoded as a base64 string, optionally specified by some name
      /*! This will automatically start and finish a node to load the data, and can be called directly by
          users.

          Note that this follows the same ordering rules specified in the class description in regards
          to loading in/out of order */
      void loadBinaryValue( void * data, size_t size, const char * name = nullptr )
      {
        setNextName( name );
        startNode();

        std::string encoded;
        loadValue( encoded );

        auto decoded = base64::decode( encoded );

        if( size != decoded.size() )
          throw Exception("Decoded binary data size does not match specified size");

        std::memcpy( data, decoded.data(), decoded.size() );

        finishNode();
      }

      //! @}
      /*! @name Internal Functionality
          Functionality designed for use by those requiring control over the inner mechanisms of
          the XMLInputArchive */
      //! @{

      //! Prepares to start reading the next node
      /*! This places the next node to be parsed onto the nodes stack.

          By default our strategy is to start with the document root node and then
          recursively iterate through all children in the order they show up in the document.
          We don't need to know NVPs do to this; we'll just blindly load in the order things appear in.

          We check to see if the specified NVP matches what the next automatically loaded node is.  If they
          match, we just continue as normal, going in order.  If they don't match, we attempt to find a node
          named after the NVP that is being loaded.  If that NVP does not exist, we throw an exception. */
      void startNode()
      {
        auto next = itsNodes.top().child; // By default we would move to the next child node
        auto const expectedName = itsNodes.top().name; // this is the expected name from the NVP, if provided

        // If we were given an NVP name, look for it in the current level of the document.
        //    We only need to do this if either we have exhausted the siblings of the current level or
        //    the NVP name does not match the name of the node we would normally read next
        if( expectedName && ( next == nullptr || std::strcmp( next->name(), expectedName ) != 0 ) )
        {
          next = itsNodes.top().search( expectedName );

          if( next == nullptr )
            throw Exception("XML Parsing failed - provided NVP (" + std::string(expectedName) + ") not found");
        }

        itsNodes.emplace( next );
      }

      //! Finishes reading the current node
      void finishNode()
      {
        // remove current
        itsNodes.pop();

        // advance parent
        itsNodes.top().advance();

        // Reset name
        itsNodes.top().name = nullptr;
      }

      //! Retrieves the current node name
      //! will return @c nullptr if the node does not have a name
      const char * getNodeName() const
      {
        return itsNodes.top().getChildName();
      }

      //! Sets the name for the next node created with startNode
      void setNextName( const char * name )
      {
        itsNodes.top().name = name;
      }

      //! Loads a bool from the current top node
      template <class T, traits::EnableIf<std::is_unsigned<T>::value,
                                          std::is_same<T, bool>::value> = traits::sfinae> inline
      void loadValue( T & value )
      {
        std::istringstream is( itsNodes.top().node->value() );
        is.setf( std::ios::boolalpha );
        is >> value;
      }

      //! Loads a char (signed or unsigned) from the current top node
      template <class T, traits::EnableIf<std::is_integral<T>::value,
                                          !std::is_same<T, bool>::value,
                                          sizeof(T) == sizeof(char)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = *reinterpret_cast<T*>( itsNodes.top().node->value() );
      }

      //! Load an int8_t from the current top node (ensures we parse entire number)
      void loadValue( int8_t & value )
      {
        int32_t val; loadValue( val ); value = static_cast<int8_t>( val );
      }

      //! Load a uint8_t from the current top node (ensures we parse entire number)
      void loadValue( uint8_t & value )
      {
        uint32_t val; loadValue( val ); value = static_cast<uint8_t>( val );
      }

      //! Loads a type best represented as an unsigned long from the current top node
      template <class T, traits::EnableIf<std::is_unsigned<T>::value,
                                          !std::is_same<T, bool>::value,
                                          !std::is_same<T, char>::value,
                                          !std::is_same<T, unsigned char>::value,
                                          sizeof(T) < sizeof(long long)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = static_cast<T>( std::stoul( itsNodes.top().node->value() ) );
      }

      //! Loads a type best represented as an unsigned long long from the current top node
      template <class T, traits::EnableIf<std::is_unsigned<T>::value,
                                          !std::is_same<T, bool>::value,
                                          sizeof(T) >= sizeof(long long)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = static_cast<T>( std::stoull( itsNodes.top().node->value() ) );
      }

      //! Loads a type best represented as an int from the current top node
      template <class T, traits::EnableIf<std::is_signed<T>::value,
                                          !std::is_same<T, char>::value,
                                          sizeof(T) <= sizeof(int)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = static_cast<T>( std::stoi( itsNodes.top().node->value() ) );
      }

      //! Loads a type best represented as a long from the current top node
      template <class T, traits::EnableIf<std::is_signed<T>::value,
                                          (sizeof(T) > sizeof(int)),
                                          sizeof(T) <= sizeof(long)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = static_cast<T>( std::stol( itsNodes.top().node->value() ) );
      }

      //! Loads a type best represented as a long long from the current top node
      template <class T, traits::EnableIf<std::is_signed<T>::value,
                                          (sizeof(T) > sizeof(long)),
                                          sizeof(T) <= sizeof(long long)> = traits::sfinae> inline
      void loadValue( T & value )
      {
        value = static_cast<T>( std::stoll( itsNodes.top().node->value() ) );
      }

      //! Loads a type best represented as a float from the current top node
      void loadValue( float & value )
      {
        try
        {
          value = std::stof( itsNodes.top().node->value() );
        }
        catch( std::out_of_range const & )
        {
          // special case for denormalized values
          std::istringstream is( itsNodes.top().node->value() );
          is >> value;
          if( std::fpclassify( value ) != FP_SUBNORMAL )
            throw;
        }
      }

      //! Loads a type best represented as a double from the current top node
      void loadValue( double & value )
      {
        try
        {
          value = std::stod( itsNodes.top().node->value() );
        }
        catch( std::out_of_range const & )
        {
          // special case for denormalized values
          std::istringstream is( itsNodes.top().node->value() );
          is >> value;
          if( std::fpclassify( value ) != FP_SUBNORMAL )
            throw;
        }
      }

      //! Loads a type best represented as a long double from the current top node
      void loadValue( long double & value )
      {
        try
        {
          value = std::stold( itsNodes.top().node->value() );
        }
        catch( std::out_of_range const & )
        {
          // special case for denormalized values
          std::istringstream is( itsNodes.top().node->value() );
          is >> value;
          if( std::fpclassify( value ) != FP_SUBNORMAL )
            throw;
        }
      }

      //! Loads a string from the current node from the current top node
      template<class CharT, class Traits, class Alloc> inline
      void loadValue( std::basic_string<CharT, Traits, Alloc> & str )
      {
        std::basic_istringstream<CharT, Traits> is( itsNodes.top().node->value() );

        str.assign( std::istreambuf_iterator<CharT, Traits>( is ),
                    std::istreambuf_iterator<CharT, Traits>() );
      }

      //! Loads the size of the current top node
      template <class T> inline
      void loadSize( T & value )
      {
        value = getNumChildren( itsNodes.top().node );
      }

    protected:
      //! Gets the number of children (usually interpreted as size) for the specified node
      static size_t getNumChildren( rapidxml::xml_node<> * node )
      {
        size_t size = 0;
        node = node->first_node(); // get first child

        while( node != nullptr )
        {
          ++size;
          node = node->next_sibling();
        }

        return size;
      }

      //! A struct that contains metadata about a node
      /*! Keeps track of some top level node, its number of
          remaining children, and the current active child node */
      struct NodeInfo
      {
        NodeInfo( rapidxml::xml_node<> * n = nullptr ) :
          node( n ),
          child( n->first_node() ),
          size( XMLInputArchive::getNumChildren( n ) ),
          name( nullptr )
        { }

        //! Advances to the next sibling node of the child
        /*! If this is the last sibling child will be null after calling */
        void advance()
        {
          if( size > 0 )
          {
            --size;
            child = child->next_sibling();
          }
        }

        //! Searches for a child with the given name in this node
        /*! @param searchName The name to search for (must be null terminated)
            @return The node if found, nullptr otherwise */
        rapidxml::xml_node<> * search( const char * searchName )
        {
          if( searchName )
          {
            size_t new_size = XMLInputArchive::getNumChildren( node );
            const size_t name_size = rapidxml::internal::measure( searchName );

            for( auto new_child = node->first_node(); new_child != nullptr; new_child = new_child->next_sibling() )
            {
              if( rapidxml::internal::compare( new_child->name(), new_child->name_size(), searchName, name_size, true ) )
              {
                size = new_size;
                child = new_child;

                return new_child;
              }
              --new_size;
            }
          }

          return nullptr;
        }

        //! Returns the actual name of the next child node, if it exists
        const char * getChildName() const
        {
          return child ? child->name() : nullptr;
        }

        rapidxml::xml_node<> * node;  //!< A pointer to this node
        rapidxml::xml_node<> * child; //!< A pointer to its current child
        size_t size;                  //!< The remaining number of children for this node
        const char * name;            //!< The NVP name for next child node
      }; // NodeInfo

      //! @}

    private:
      std::vector<char> itsData;       //!< The raw data loaded
      rapidxml::xml_document<> itsXML; //!< The XML document
      std::stack<NodeInfo> itsNodes;   //!< A stack of nodes read from the document
  };

  // ######################################################################
  // XMLArchive prologue and epilogue functions
  // ######################################################################

  // ######################################################################
  //! Prologue for NVPs for XML output archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void prologue( XMLOutputArchive &, NameValuePair<T> const & )
  { }

  //! Prologue for NVPs for XML input archives
  template <class T> inline
  void prologue( XMLInputArchive &, NameValuePair<T> const & )
  { }

  // ######################################################################
  //! Epilogue for NVPs for XML output archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void epilogue( XMLOutputArchive &, NameValuePair<T> const & )
  { }

  //! Epilogue for NVPs for XML input archives
  template <class T> inline
  void epilogue( XMLInputArchive &, NameValuePair<T> const & )
  { }

  // ######################################################################
  //! Prologue for deferred data for XML archives
  /*! Do nothing for the defer wrapper */
  template <class T> inline
  void prologue( XMLOutputArchive &, DeferredData<T> const & )
  { }

  //! Prologue for deferred data for XML archives
  template <class T> inline
  void prologue( XMLInputArchive &, DeferredData<T> const & )
  { }

  // ######################################################################
  //! Epilogue for deferred for XML archives
  /*! NVPs do not start or finish nodes - they just set up the names */
  template <class T> inline
  void epilogue( XMLOutputArchive &, DeferredData<T> const & )
  { }

  //! Epilogue for deferred for XML archives
  /*! Do nothing for the defer wrapper */
  template <class T> inline
  void epilogue( XMLInputArchive &, DeferredData<T> const & )
  { }

  // ######################################################################
  //! Prologue for SizeTags for XML output archives
  /*! SizeTags do not start or finish nodes */
  template <class T> inline
  void prologue( XMLOutputArchive & ar, SizeTag<T> const & )
  {
      if (ar.hasSizeAttributes())
      {
          ar.appendAttribute("size", "dynamic");
      }
  }

  template <class T> inline
  void prologue( XMLInputArchive &, SizeTag<T> const & )
  { }

  //! Epilogue for SizeTags for XML output archives
  /*! SizeTags do not start or finish nodes */
  template <class T> inline
  void epilogue( XMLOutputArchive &, SizeTag<T> const & )
  { }

  template <class T> inline
  void epilogue( XMLInputArchive &, SizeTag<T> const & )
  { }

  // ######################################################################
  //! Prologue for all other types for XML output archives (except minimal types)
  /*! Starts a new node, named either automatically or by some NVP,
      that may be given data by the type about to be archived

      Minimal types do not start or end nodes */
  template <class T, traits::DisableIf<traits::has_minimal_base_class_serialization<T, traits::has_minimal_output_serialization, XMLOutputArchive>::value ||
                                       traits::has_minimal_output_serialization<T, XMLOutputArchive>::value> = traits::sfinae> inline
  void prologue( XMLOutputArchive & ar, T const & )
  {
    ar.startNode();
    ar.insertType<T>();
  }

  //! Prologue for all other types for XML input archives (except minimal types)
  template <class T, traits::DisableIf<traits::has_minimal_base_class_serialization<T, traits::has_minimal_input_serialization, XMLInputArchive>::value ||
                                       traits::has_minimal_input_serialization<T, XMLInputArchive>::value> = traits::sfinae> inline
  void prologue( XMLInputArchive & ar, T const & )
  {
    ar.startNode();
  }

  // ######################################################################
  //! Epilogue for all other types other for XML output archives (except minimal types)
  /*! Finishes the node created in the prologue

      Minimal types do not start or end nodes */
  template <class T, traits::DisableIf<traits::has_minimal_base_class_serialization<T, traits::has_minimal_output_serialization, XMLOutputArchive>::value ||
                                       traits::has_minimal_output_serialization<T, XMLOutputArchive>::value> = traits::sfinae> inline
  void epilogue( XMLOutputArchive & ar, T const & )
  {
    ar.finishNode();
  }

  //! Epilogue for all other types other for XML output archives (except minimal types)
  template <class T, traits::DisableIf<traits::has_minimal_base_class_serialization<T, traits::has_minimal_input_serialization, XMLInputArchive>::value ||
                                       traits::has_minimal_input_serialization<T, XMLInputArchive>::value> = traits::sfinae> inline
  void epilogue( XMLInputArchive & ar, T const & )
  {
    ar.finishNode();
  }

  // ######################################################################
  // Common XMLArchive serialization functions
  // ######################################################################

  //! Saving NVP types to XML
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( XMLOutputArchive & ar, NameValuePair<T> const & t )
  {
    ar.setNextName( t.name );
    ar( t.value );
  }

  //! Loading NVP types from XML
  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( XMLInputArchive & ar, NameValuePair<T> & t )
  {
    ar.setNextName( t.name );
    ar( t.value );
  }

  // ######################################################################
  //! Saving SizeTags to XML
  template <class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( XMLOutputArchive &, SizeTag<T> const & )
  { }

  //! Loading SizeTags from XML
  template <class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( XMLInputArchive & ar, SizeTag<T> & st )
  {
    ar.loadSize( st.size );
  }

  // ######################################################################
  //! Saving for POD types to xml
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void CEREAL_SAVE_FUNCTION_NAME(XMLOutputArchive & ar, T const & t)
  {
    ar.saveValue( t );
  }

  //! Loading for POD types from xml
  template <class T, traits::EnableIf<std::is_arithmetic<T>::value> = traits::sfinae> inline
  void CEREAL_LOAD_FUNCTION_NAME(XMLInputArchive & ar, T & t)
  {
    ar.loadValue( t );
  }

  // ######################################################################
  //! saving string to xml
  template<class CharT, class Traits, class Alloc> inline
  void CEREAL_SAVE_FUNCTION_NAME(XMLOutputArchive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
  {
    ar.saveValue( str );
  }

  //! loading string from xml
  template<class CharT, class Traits, class Alloc> inline
  void CEREAL_LOAD_FUNCTION_NAME(XMLInputArchive & ar, std::basic_string<CharT, Traits, Alloc> & str)
  {
    ar.loadValue( str );
  }
} // namespace cereal

// register archives for polymorphic support
CEREAL_REGISTER_ARCHIVE(cereal::XMLOutputArchive)
CEREAL_REGISTER_ARCHIVE(cereal::XMLInputArchive)

// tie input and output archives together
CEREAL_SETUP_ARCHIVE_TRAITS(cereal::XMLInputArchive, cereal::XMLOutputArchive)

#endif // CEREAL_ARCHIVES_XML_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/cereal.hpp
================================================
/*! \file cereal.hpp
    \brief Main cereal functionality */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_CEREAL_HPP_
#define CEREAL_CEREAL_HPP_

#include <type_traits>
#include <string>
#include <memory>
#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstddef>
#include <cstdint>
#include <functional>

#include "cereal/macros.hpp"
#include "cereal/details/traits.hpp"
#include "cereal/details/helpers.hpp"
#include "cereal/types/base_class.hpp"

namespace cereal
{
  // ######################################################################
  //! Creates a name value pair
  /*! @relates NameValuePair
      @ingroup Utility */
  template <class T> inline
  NameValuePair<T> make_nvp( std::string const & name, T && value )
  {
    return {name.c_str(), std::forward<T>(value)};
  }

  //! Creates a name value pair
  /*! @relates NameValuePair
      @ingroup Utility */
  template <class T> inline
  NameValuePair<T> make_nvp( const char * name, T && value )
  {
    return {name, std::forward<T>(value)};
  }

  //! Creates a name value pair for the variable T with the same name as the variable
  /*! @relates NameValuePair
      @ingroup Utility */
  #define CEREAL_NVP(T) ::cereal::make_nvp(#T, T)

  // ######################################################################
  //! Convenience function to create binary data for both const and non const pointers
  /*! @param data Pointer to beginning of the data
      @param size The size in bytes of the data
      @relates BinaryData
      @ingroup Utility */
  template <class T> inline
  BinaryData<T> binary_data( T && data, size_t size )
  {
    return {std::forward<T>(data), size};
  }

  // ######################################################################
  //! Creates a size tag from some variable.
  /*! Will normally be used to serialize size (e.g. size()) information for
      variable size containers.  If you have a variable sized container,
      the very first thing it serializes should be its size, wrapped in
      a SizeTag.

      @relates SizeTag
      @ingroup Utility */
  template <class T> inline
  SizeTag<T> make_size_tag( T && sz )
  {
    return {std::forward<T>(sz)};
  }

  // ######################################################################
  //! Marks data for deferred serialization
  /*! cereal performs a recursive depth-first traversal of data it serializes. When
      serializing smart pointers to large, nested, or cyclical data structures, it
      is possible to encounter a stack overflow from excessive recursion when following
      a chain of pointers.

      Deferment can help in these situations if the data can be serialized separately from
      the pointers used to traverse the structure. For example, a graph structure can have its
      nodes serialized before its edges:

      @code{.cpp}
      struct MyEdge
      {
        std::shared_ptr<MyNode> connection;
        int some_value;

        template<class Archive>
        void serialize(Archive & archive)
        {
          // when we serialize an edge, we'll defer serializing the associated node
          archive( cereal::defer( connection ),
                   some_value );
        }
      };

      struct MyGraphStructure
      {
        std::vector<MyEdge> edges;
        std::vector<MyNodes> nodes;

        template<class Archive>
        void serialize(Archive & archive)
        {
          // because of the deferment, we ensure all nodes are fully serialized
          // before any connection pointers to those nodes are serialized
          archive( edges, nodes );

          // we have to explicitly inform the archive when it is safe to serialize
          // the deferred data
          archive.serializeDeferments();
        }
      };
      @endcode

      @relates DeferredData
      @ingroup Utility */
  template <class T> inline
  DeferredData<T> defer( T && value )
  {
    return {std::forward<T>(value)};
  }

  // ######################################################################
  //! Called before a type is serialized to set up any special archive state
  //! for processing some type
  /*! If designing a serializer that needs to set up any kind of special
      state or output extra information for a type, specialize this function
      for the archive type and the types that require the extra information.
      @ingroup Internal */
  template <class Archive, class T> inline
  void prologue( Archive & /* archive */, T const & /* data */)
  { }

  //! Called after a type is serialized to tear down any special archive state
  //! for processing some type
  /*! @ingroup Internal */
  template <class Archive, class T> inline
  void epilogue( Archive & /* archive */, T const & /* data */)
  { }

  // ######################################################################
  //! Special flags for archives
  /*! AllowEmptyClassElision
        This allows for empty classes to be serialized even if they do not provide
        a serialization function.  Classes with no data members are considered to be
        empty.  Be warned that if this is enabled and you attempt to serialize an
        empty class with improperly formed serialize or load/save functions, no
        static error will occur - the error will propogate silently and your
        intended serialization functions may not be called.  You can manually
        ensure that your classes that have custom serialization are correct
        by using the traits is_output_serializable and is_input_serializable
        in cereal/details/traits.hpp.
      @ingroup Internal */
  enum Flags { AllowEmptyClassElision = 1 };

  // ######################################################################
  //! Registers a specific Archive type with cereal
  /*! This registration should be done once per archive.  A good place to
      put this is immediately following the definition of your archive.
      Archive registration is only strictly necessary if you wish to
      support pointers to polymorphic data types.  All archives that
      come with cereal are already registered.
      @ingroup Internal */
  #define CEREAL_REGISTER_ARCHIVE(Archive)                              \
  namespace cereal { namespace detail {                                 \
  template <class T, class BindingTag>                                  \
  typename polymorphic_serialization_support<Archive, T>::type          \
  instantiate_polymorphic_binding( T*, Archive*, BindingTag, adl_tag ); \
  } } /* end namespaces */

  //! Helper macro to omit unused warning
  #if defined(__GNUC__)
    // GCC / clang don't want the function
    #define CEREAL_UNUSED_FUNCTION
  #else
    #define CEREAL_UNUSED_FUNCTION static void unused() { (void)version; }
  #endif

  // ######################################################################
  //! Defines a class version for some type
  /*! Versioning information is optional and adds some small amount of
      overhead to serialization.  This overhead will occur both in terms of
      space in the archive (the version information for each class will be
      stored exactly once) as well as runtime (versioned serialization functions
      must check to see if they need to load or store version information).

      Versioning is useful if you plan on fundamentally changing the way some
      type is serialized in the future.  Versioned serialization functions
      cannot be used to load non-versioned data.

      By default, all types have an assumed version value of zero.  By
      using this macro, you may change the version number associated with
      some type.  cereal will then use this value as a second parameter
      to your serialization functions.

      The interface for the serialization functions is nearly identical
      to non-versioned serialization with the addition of a second parameter,
      const std::uint32_t version, which will be supplied with the correct
      version number.  Serializing the version number on a save happens
      automatically.

      Versioning cannot be mixed with non-versioned serialization functions.
      Having both types will result result in a compile time error.  Data
      serialized without versioning cannot be loaded by a serialization
      function with added versioning support.

      Example interface for versioning on a non-member serialize function:

      @code{cpp}
      CEREAL_CLASS_VERSION( Mytype, 77 ); // register class version

      template <class Archive>
      void serialize( Archive & ar, Mytype & t, const std::uint32_t version )
      {
        // When performing a load, the version associated with the class
        // is whatever it was when that data was originally serialized
        //
        // When we save, we'll use the version that is defined in the macro

        if( version >= some_number )
          // do this
        else
          // do that
      }
      @endcode

      Interfaces for other forms of serialization functions is similar.  This
      macro should be placed at global scope.
      @ingroup Utility */
  #define CEREAL_CLASS_VERSION(TYPE, VERSION_NUMBER)                             \
  namespace cereal { namespace detail {                                          \
    template <> struct Version<TYPE>                                             \
    {                                                                            \
      static const std::uint32_t version;                                        \
      static std::uint32_t registerVersion()                                     \
      {                                                                          \
        ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace( \
             std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER );        \
        return VERSION_NUMBER;                                                   \
      }                                                                          \
      CEREAL_UNUSED_FUNCTION                                                     \
    }; /* end Version */                                                         \
    const std::uint32_t Version<TYPE>::version =                                 \
      Version<TYPE>::registerVersion();                                          \
  } } // end namespaces

  // ######################################################################
  //! The base output archive class
  /*! This is the base output archive for all output archives.  If you create
      a custom archive class, it should derive from this, passing itself as
      a template parameter for the ArchiveType.

      The base class provides all of the functionality necessary to
      properly forward data to the correct serialization functions.

      Individual archives should use a combination of prologue and
      epilogue functions together with specializations of serialize, save,
      and load to alter the functionality of their serialization.

      @tparam ArchiveType The archive type that derives from OutputArchive
      @tparam Flags Flags to control advanced functionality.  See the Flags
                    enum for more information.
      @ingroup Internal */
  template<class ArchiveType, std::uint32_t Flags = 0>
  class OutputArchive : public detail::OutputArchiveBase
  {
    public:
      //! Construct the output archive
      /*! @param derived A pointer to the derived ArchiveType (pass this from the derived archive) */
      OutputArchive(ArchiveType * const derived) : self(derived), itsCurrentPointerId(1), itsCurrentPolymorphicTypeId(1)
      { }

      OutputArchive & operator=( OutputArchive const & ) = delete;

      //! Serializes all passed in data
      /*! This is the primary interface for serializing data with an archive */
      template <class ... Types> inline
      ArchiveType & operator()( Types && ... args )
      {
        self->process( std::forward<Types>( args )... );
        return *self;
      }

      //! Serializes any data marked for deferment using defer
      /*! This will cause any data wrapped in DeferredData to be immediately serialized */
      void serializeDeferments()
      {
        for( auto & deferment : itsDeferments )
          deferment();
      }

      /*! @name Boost Transition Layer
          Functionality that mirrors the syntax for Boost.  This is useful if you are transitioning
          a large project from Boost to cereal.  The preferred interface for cereal is using operator(). */
      //! @{

      //! Indicates this archive is not intended for loading
      /*! This ensures compatibility with boost archive types.  If you are transitioning
          from boost, you can check this value within a member or external serialize function
          (i.e., Archive::is_loading::value) to disable behavior specific to loading, until
          you can transition to split save/load or save_minimal/load_minimal functions */
      using is_loading = std::false_type;

      //! Indicates this archive is intended for saving
      /*! This ensures compatibility with boost archive types.  If you are transitioning
          from boost, you can check this value within a member or external serialize function
          (i.e., Archive::is_saving::value) to enable behavior specific to loading, until
          you can transition to split save/load or save_minimal/load_minimal functions */
      using is_saving = std::true_type;

      //! Serializes passed in data
      /*! This is a boost compatability layer and is not the preferred way of using
          cereal.  If you are transitioning from boost, use this until you can
          transition to the operator() overload */
      template <class T> inline
      ArchiveType & operator&( T && arg )
      {
        self->process( std::forward<T>( arg ) );
        return *self;
      }

      //! Serializes passed in data
      /*! This is a boost compatability layer and is not the preferred way of using
          cereal.  If you are transitioning from boost, use this until you can
          transition to the operator() overload */
      template <class T> inline
      ArchiveType & operator<<( T && arg )
      {
        self->process( std::forward<T>( arg ) );
        return *self;
      }

      //! @}

      //! Registers a shared pointer with the archive
      /*! This function is used to track shared pointer targets to prevent
          unnecessary saves from taking place if multiple shared pointers
          point to the same data.

          @internal
          @param addr The address (see shared_ptr get()) pointed to by the shared pointer
          @return A key that uniquely identifies the pointer */
      inline std::uint32_t registerSharedPointer( void const * addr )
      {
        // Handle null pointers by just returning 0
        if(addr == 0) return 0;

        auto id = itsSharedPointerMap.find( addr );
        if( id == itsSharedPointerMap.end() )
        {
          auto ptrId = itsCurrentPointerId++;
          itsSharedPointerMap.insert( {addr, ptrId} );
          return ptrId | detail::msb_32bit; // mask MSB to be 1
        }
        else
          return id->second;
      }

      //! Registers a polymorphic type name with the archive
      /*! This function is used to track polymorphic types to prevent
          unnecessary saves of identifying strings used by the polymorphic
          support functionality.

          @internal
          @param name The name to associate with a polymorphic type
          @return A key that uniquely identifies the polymorphic type name */
      inline std::uint32_t registerPolymorphicType( char const * name )
      {
        auto id = itsPolymorphicTypeMap.find( name );
        if( id == itsPolymorphicTypeMap.end() )
        {
          auto polyId = itsCurrentPolymorphicTypeId++;
          itsPolymorphicTypeMap.insert( {name, polyId} );
          return polyId | detail::msb_32bit; // mask MSB to be 1
        }
        else
          return id->second;
      }

    private:
      //! Serializes data after calling prologue, then calls epilogue
      template <class T> inline
      void process( T && head )
      {
        prologue( *self, head );
        self->processImpl( head );
        epilogue( *self, head );
      }

      //! Unwinds to process all data
      template <class T, class ... Other> inline
      void process( T && head, Other && ... tail )
      {
        self->process( std::forward<T>( head ) );
        self->process( std::forward<Other>( tail )... );
      }

      //! Serialization of a virtual_base_class wrapper
      /*! \sa virtual_base_class */
      template <class T> inline
      ArchiveType & processImpl(virtual_base_class<T> const & b)
      {
        traits::detail::base_class_id id(b.base_ptr);
        if(itsBaseClassSet.count(id) == 0)
        {
          itsBaseClassSet.insert(id);
          self->processImpl( *b.base_ptr );
        }
        return *self;
      }

      //! Serialization of a base_class wrapper
      /*! \sa base_class */
      template <class T> inline
      ArchiveType & processImpl(base_class<T> const & b)
      {
        self->processImpl( *b.base_ptr );
        return *self;
      }

      std::vector<std::function<void(void)>> itsDeferments;

      template <class T> inline
      ArchiveType & processImpl(DeferredData<T> const & d)
      {
        std::function<void(void)> deferment( [=](){ self->process( d.value ); } );
        itsDeferments.emplace_back( std::move(deferment) );

        return *self;
      }

      //! Helper macro that expands the requirements for activating an overload
      /*! Requirements:
            Has the requested serialization function
            Does not have version and unversioned at the same time
            Is output serializable AND
              is specialized for this type of function OR
              has no specialization at all */
      #define PROCESS_IF(name)                                                             \
      traits::EnableIf<traits::has_##name<T, ArchiveType>::value,                          \
                       !traits::has_invalid_output_versioning<T, ArchiveType>::value,      \
                       (traits::is_output_serializable<T, ArchiveType>::value &&           \
                        (traits::is_specialized_##name<T, ArchiveType>::value ||           \
                         !traits::is_specialized<T, ArchiveType>::value))> = traits::sfinae

      //! Member serialization
      template <class T, PROCESS_IF(member_serialize)> inline
      ArchiveType & processImpl(T const & t)
      {
        access::member_serialize(*self, const_cast<T &>(t));
        return *self;
      }

      //! Non member serialization
      template <class T, PROCESS_IF(non_member_serialize)> inline
      ArchiveType & processImpl(T const & t)
      {
        CEREAL_SERIALIZE_FUNCTION_NAME(*self, const_cast<T &>(t));
        return *self;
      }

      //! Member split (save)
      template <class T, PROCESS_IF(member_save)> inline
      ArchiveType & processImpl(T const & t)
      {
        access::member_save(*self, t);
        return *self;
      }

      //! Non member split (save)
      template <class T, PROCESS_IF(non_member_save)> inline
      ArchiveType & processImpl(T const & t)
      {
        CEREAL_SAVE_FUNCTION_NAME(*self, t);
        return *self;
      }

      //! Member split (save_minimal)
      template <class T, PROCESS_IF(member_save_minimal)> inline
      ArchiveType & processImpl(T const & t)
      {
        self->process( access::member_save_minimal(*self, t) );
        return *self;
      }

      //! Non member split (save_minimal)
      template <class T, PROCESS_IF(non_member_save_minimal)> inline
      ArchiveType & processImpl(T const & t)
      {
        self->process( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(*self, t) );
        return *self;
      }

      //! Empty class specialization
      template <class T, traits::EnableIf<(Flags & AllowEmptyClassElision),
                                          !traits::is_output_serializable<T, ArchiveType>::value,
                                          std::is_empty<T>::value> = traits::sfinae> inline
      ArchiveType & processImpl(T const &)
      {
        return *self;
      }

      //! No matching serialization
      /*! Invalid if we have invalid output versioning or
          we are not output serializable, and either
          don't allow empty class ellision or allow it but are not serializing an empty class */
      template <class T, traits::EnableIf<traits::has_invalid_output_versioning<T, ArchiveType>::value ||
                                          (!traits::is_output_serializable<T, ArchiveType>::value &&
                                           (!(Flags & AllowEmptyClassElision) || ((Flags & AllowEmptyClassElision) && !std::is_empty<T>::value)))> = traits::sfinae> inline
      ArchiveType & processImpl(T const &)
      {
        static_assert(traits::detail::count_output_serializers<T, ArchiveType>::value != 0,
            "cereal could not find any output serialization functions for the provided type and archive combination. \n\n "
            "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
            "Serialize functions generally have the following signature: \n\n "
            "template<class Archive> \n "
            "  void serialize(Archive & ar) \n "
            "  { \n "
            "    ar( member1, member2, member3 ); \n "
            "  } \n\n " );

        static_assert(traits::detail::count_output_serializers<T, ArchiveType>::value < 2,
            "cereal found more than one compatible output serialization function for the provided type and archive combination. \n\n "
            "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
            "Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions.  \n "
            "Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. \n "
            "In addition, you may not mix versioned with non-versioned serialization functions. \n\n ");

        return *self;
      }

      //! Registers a class version with the archive and serializes it if necessary
      /*! If this is the first time this class has been serialized, we will record its
          version number and serialize that.

          @tparam T The type of the class being serialized */
      template <class T> inline
      std::uint32_t registerClassVersion()
      {
        static const auto hash = std::type_index(typeid(T)).hash_code();
        const auto insertResult = itsVersionedTypes.insert( hash );
        const auto lock = detail::StaticObject<detail::Versions>::lock();
        const auto version =
          detail::StaticObject<detail::Versions>::getInstance().find( hash, detail::Version<T>::version );

        if( insertResult.second ) // insertion took place, serialize the version number
          process( make_nvp<ArchiveType>("cereal_class_version", version) );

        return version;
      }

      //! Member serialization
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_serialize)> inline
      ArchiveType & processImpl(T const & t)
      {
        access::member_serialize(*self, const_cast<T &>(t), registerClassVersion<T>());
        return *self;
      }

      //! Non member serialization
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_serialize)> inline
      ArchiveType & processImpl(T const & t)
      {
        CEREAL_SERIALIZE_FUNCTION_NAME(*self, const_cast<T &>(t), registerClassVersion<T>());
        return *self;
      }

      //! Member split (save)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_save)> inline
      ArchiveType & processImpl(T const & t)
      {
        access::member_save(*self, t, registerClassVersion<T>());
        return *self;
      }

      //! Non member split (save)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_save)> inline
      ArchiveType & processImpl(T const & t)
      {
        CEREAL_SAVE_FUNCTION_NAME(*self, t, registerClassVersion<T>());
        return *self;
      }

      //! Member split (save_minimal)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_save_minimal)> inline
      ArchiveType & processImpl(T const & t)
      {
        self->process( access::member_save_minimal(*self, t, registerClassVersion<T>()) );
        return *self;
      }

      //! Non member split (save_minimal)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_save_minimal)> inline
      ArchiveType & processImpl(T const & t)
      {
        self->process( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(*self, t, registerClassVersion<T>()) );
        return *self;
      }

    #undef PROCESS_IF

    private:
      ArchiveType * const self;

      //! A set of all base classes that have been serialized
      std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;

      //! Maps from addresses to pointer ids
      std::unordered_map<void const *, std::uint32_t> itsSharedPointerMap;

      //! The id to be given to the next pointer
      std::uint32_t itsCurrentPointerId;

      //! Maps from polymorphic type name strings to ids
      std::unordered_map<char const *, std::uint32_t> itsPolymorphicTypeMap;

      //! The id to be given to the next polymorphic type name
      std::uint32_t itsCurrentPolymorphicTypeId;

      //! Keeps track of classes that have versioning information associated with them
      std::unordered_set<size_type> itsVersionedTypes;
  }; // class OutputArchive

  // ######################################################################
  //! The base input archive class
  /*! This is the base input archive for all input archives.  If you create
      a custom archive class, it should derive from this, passing itself as
      a template parameter for the ArchiveType.

      The base class provides all of the functionality necessary to
      properly forward data to the correct serialization functions.

      Individual archives should use a combination of prologue and
      epilogue functions together with specializations of serialize, save,
      and load to alter the functionality of their serialization.

      @tparam ArchiveType The archive type that derives from InputArchive
      @tparam Flags Flags to control advanced functionality.  See the Flags
                    enum for more information.
      @ingroup Internal */
  template<class ArchiveType, std::uint32_t Flags = 0>
  class InputArchive : public detail::InputArchiveBase
  {
    public:
      //! Construct the output archive
      /*! @param derived A pointer to the derived ArchiveType (pass this from the derived archive) */
      InputArchive(ArchiveType * const derived) :
        self(derived),
        itsBaseClassSet(),
        itsSharedPointerMap(),
        itsPolymorphicTypeMap(),
        itsVersionedTypes()
      { }

      InputArchive & operator=( InputArchive const & ) = delete;

      //! Serializes all passed in data
      /*! This is the primary interface for serializing data with an archive */
      template <class ... Types> inline
      ArchiveType & operator()( Types && ... args )
      {
        process( std::forward<Types>( args )... );
        return *self;
      }

      //! Serializes any data marked for deferment using defer
      /*! This will cause any data wrapped in DeferredData to be immediately serialized */
      void serializeDeferments()
      {
        for( auto & deferment : itsDeferments )
          deferment();
      }

      /*! @name Boost Transition Layer
          Functionality that mirrors the syntax for Boost.  This is useful if you are transitioning
          a large project from Boost to cereal.  The preferred interface for cereal is using operator(). */
      //! @{

      //! Indicates this archive is intended for loading
      /*! This ensures compatibility with boost archive types.  If you are transitioning
          from boost, you can check this value within a member or external serialize function
          (i.e., Archive::is_loading::value) to enable behavior specific to loading, until
          you can transition to split save/load or save_minimal/load_minimal functions */
      using is_loading = std::true_type;

      //! Indicates this archive is not intended for saving
      /*! This ensures compatibility with boost archive types.  If you are transitioning
          from boost, you can check this value within a member or external serialize function
          (i.e., Archive::is_saving::value) to disable behavior specific to loading, until
          you can transition to split save/load or save_minimal/load_minimal functions */
      using is_saving = std::false_type;

      //! Serializes passed in data
      /*! This is a boost compatability layer and is not the preferred way of using
          cereal.  If you are transitioning from boost, use this until you can
          transition to the operator() overload */
      template <class T> inline
      ArchiveType & operator&( T && arg )
      {
        self->process( std::forward<T>( arg ) );
        return *self;
      }

      //! Serializes passed in data
      /*! This is a boost compatability layer and is not the preferred way of using
          cereal.  If you are transitioning from boost, use this until you can
          transition to the operator() overload */
      template <class T> inline
      ArchiveType & operator>>( T && arg )
      {
        self->process( std::forward<T>( arg ) );
        return *self;
      }

      //! @}

      //! Retrieves a shared pointer given a unique key for it
      /*! This is used to retrieve a previously registered shared_ptr
          which has already been loaded.

          @internal
          @param id The unique id that was serialized for the pointer
          @return A shared pointer to the data
          @throw Exception if the id does not exist */
      inline std::shared_ptr<void> getSharedPointer(std::uint32_t const id)
      {
        if(id == 0) return std::shared_ptr<void>(nullptr);

        auto iter = itsSharedPointerMap.find( id );
        if(iter == itsSharedPointerMap.end())
          throw Exception("Error while trying to deserialize a smart pointer. Could not find id " + std::to_string(id));

        return iter->second;
      }

      //! Registers a shared pointer to its unique identifier
      /*! After a shared pointer has been allocated for the first time, it should
          be registered with its loaded id for future references to it.

          @internal
          @param id The unique identifier for the shared pointer
          @param ptr The actual shared pointer */
      inline void registerSharedPointer(std::uint32_t const id, std::shared_ptr<void> ptr)
      {
        std::uint32_t const stripped_id = id & ~detail::msb_32bit;
        itsSharedPointerMap[stripped_id] = ptr;
      }

      //! Retrieves the string for a polymorphic type given a unique key for it
      /*! This is used to retrieve a string previously registered during
          a polymorphic load.

          @internal
          @param id The unique id that was serialized for the polymorphic type
          @return The string identifier for the tyep */
      inline std::string getPolymorphicName(std::uint32_t const id)
      {
        auto name = itsPolymorphicTypeMap.find( id );
        if(name == itsPolymorphicTypeMap.end())
        {
          throw Exception("Error while trying to deserialize a polymorphic pointer. Could not find type id " + std::to_string(id));
        }
        return name->second;
      }

      //! Registers a polymorphic name string to its unique identifier
      /*! After a polymorphic type has been loaded for the first time, it should
          be registered with its loaded id for future references to it.

          @internal
          @param id The unique identifier for the polymorphic type
          @param name The name associated with the tyep */
      inline void registerPolymorphicName(std::uint32_t const id, std::string const & name)
      {
        std::uint32_t const stripped_id = id & ~detail::msb_32bit;
        itsPolymorphicTypeMap.insert( {stripped_id, name} );
      }

    private:
      //! Serializes data after calling prologue, then calls epilogue
      template <class T> inline
      void process( T && head )
      {
        prologue( *self, head );
        self->processImpl( head );
        epilogue( *self, head );
      }

      //! Unwinds to process all data
      template <class T, class ... Other> inline
      void process( T && head, Other && ... tail )
      {
        process( std::forward<T>( head ) );
        process( std::forward<Other>( tail )... );
      }

      //! Serialization of a virtual_base_class wrapper
      /*! \sa virtual_base_class */
      template <class T> inline
      ArchiveType & processImpl(virtual_base_class<T> & b)
      {
        traits::detail::base_class_id id(b.base_ptr);
        if(itsBaseClassSet.count(id) == 0)
        {
          itsBaseClassSet.insert(id);
          self->processImpl( *b.base_ptr );
        }
        return *self;
      }

      //! Serialization of a base_class wrapper
      /*! \sa base_class */
      template <class T> inline
      ArchiveType & processImpl(base_class<T> & b)
      {
        self->processImpl( *b.base_ptr );
        return *self;
      }

      std::vector<std::function<void(void)>> itsDeferments;

      template <class T> inline
      ArchiveType & processImpl(DeferredData<T> const & d)
      {
        std::function<void(void)> deferment( [=](){ self->process( d.value ); } );
        itsDeferments.emplace_back( std::move(deferment) );

        return *self;
      }

      //! Helper macro that expands the requirements for activating an overload
      /*! Requirements:
            Has the requested serialization function
            Does not have version and unversioned at the same time
            Is input serializable AND
              is specialized for this type of function OR
              has no specialization at all */
      #define PROCESS_IF(name)                                                              \
      traits::EnableIf<traits::has_##name<T, ArchiveType>::value,                           \
                       !traits::has_invalid_input_versioning<T, ArchiveType>::value,        \
                       (traits::is_input_serializable<T, ArchiveType>::value &&             \
                        (traits::is_specialized_##name<T, ArchiveType>::value ||            \
                         !traits::is_specialized<T, ArchiveType>::value))> = traits::sfinae

      //! Member serialization
      template <class T, PROCESS_IF(member_serialize)> inline
      ArchiveType & processImpl(T & t)
      {
        access::member_serialize(*self, t);
        return *self;
      }

      //! Non member serialization
      template <class T, PROCESS_IF(non_member_serialize)> inline
      ArchiveType & processImpl(T & t)
      {
        CEREAL_SERIALIZE_FUNCTION_NAME(*self, t);
        return *self;
      }

      //! Member split (load)
      template <class T, PROCESS_IF(member_load)> inline
      ArchiveType & processImpl(T & t)
      {
        access::member_load(*self, t);
        return *self;
      }

      //! Non member split (load)
      template <class T, PROCESS_IF(non_member_load)> inline
      ArchiveType & processImpl(T & t)
      {
        CEREAL_LOAD_FUNCTION_NAME(*self, t);
        return *self;
      }

      //! Member split (load_minimal)
      template <class T, PROCESS_IF(member_load_minimal)> inline
      ArchiveType & processImpl(T & t)
      {
        using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
        typename traits::has_member_save_minimal<T, OutArchiveType>::type value;
        self->process( value );
        access::member_load_minimal(*self, t, value);
        return *self;
      }

      //! Non member split (load_minimal)
      template <class T, PROCESS_IF(non_member_load_minimal)> inline
      ArchiveType & processImpl(T & t)
      {
        using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
        typename traits::has_non_member_save_minimal<T, OutArchiveType>::type value;
        self->process( value );
        CEREAL_LOAD_MINIMAL_FUNCTION_NAME(*self, t, value);
        return *self;
      }

      //! Empty class specialization
      template <class T, traits::EnableIf<(Flags & AllowEmptyClassElision),
                                          !traits::is_input_serializable<T, ArchiveType>::value,
                                          std::is_empty<T>::value> = traits::sfinae> inline
      ArchiveType & processImpl(T const &)
      {
        return *self;
      }

      //! No matching serialization
      /*! Invalid if we have invalid input versioning or
          we are not input serializable, and either
          don't allow empty class ellision or allow it but are not serializing an empty class */
      template <class T, traits::EnableIf<traits::has_invalid_input_versioning<T, ArchiveType>::value ||
                                          (!traits::is_input_serializable<T, ArchiveType>::value &&
                                           (!(Flags & AllowEmptyClassElision) || ((Flags & AllowEmptyClassElision) && !std::is_empty<T>::value)))> = traits::sfinae> inline
      ArchiveType & processImpl(T const &)
      {
        static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value != 0,
            "cereal could not find any input serialization functions for the provided type and archive combination. \n\n "
            "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
            "Serialize functions generally have the following signature: \n\n "
            "template<class Archive> \n "
            "  void serialize(Archive & ar) \n "
            "  { \n "
            "    ar( member1, member2, member3 ); \n "
            "  } \n\n " );

        static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value < 2,
            "cereal found more than one compatible input serialization function for the provided type and archive combination. \n\n "
            "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
            "Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions.  \n "
            "Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. \n "
            "In addition, you may not mix versioned with non-versioned serialization functions. \n\n ");

        return *self;
      }

      //! Befriend for versioning in load_and_construct
      template <class A, class B, bool C, bool D, bool E, bool F> friend struct detail::Construct;

      //! Registers a class version with the archive and serializes it if necessary
      /*! If this is the first time this class has been serialized, we will record its
          version number and serialize that.

          @tparam T The type of the class being serialized */
      template <class T> inline
      std::uint32_t loadClassVersion()
      {
        static const auto hash = std::type_index(typeid(T)).hash_code();
        auto lookupResult = itsVersionedTypes.find( hash );

        if( lookupResult != itsVersionedTypes.end() ) // already exists
          return lookupResult->second;
        else // need to load
        {
          std::uint32_t version;

          process( make_nvp<ArchiveType>("cereal_class_version", version) );
          itsVersionedTypes.emplace_hint( lookupResult, hash, version );

          return version;
        }
      }

      //! Member serialization
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_serialize)> inline
      ArchiveType & processImpl(T & t)
      {
        const auto version = loadClassVersion<T>();
        access::member_serialize(*self, t, version);
        return *self;
      }

      //! Non member serialization
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_serialize)> inline
      ArchiveType & processImpl(T & t)
      {
        const auto version = loadClassVersion<T>();
        CEREAL_SERIALIZE_FUNCTION_NAME(*self, t, version);
        return *self;
      }

      //! Member split (load)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_load)> inline
      ArchiveType & processImpl(T & t)
      {
        const auto version = loadClassVersion<T>();
        access::member_load(*self, t, version);
        return *self;
      }

      //! Non member split (load)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_load)> inline
      ArchiveType & processImpl(T & t)
      {
        const auto version = loadClassVersion<T>();
        CEREAL_LOAD_FUNCTION_NAME(*self, t, version);
        return *self;
      }

      //! Member split (load_minimal)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(member_versioned_load_minimal)> inline
      ArchiveType & processImpl(T & t)
      {
        using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
        const auto version = loadClassVersion<T>();
        typename traits::has_member_versioned_save_minimal<T, OutArchiveType>::type value;
        self->process(value);
        access::member_load_minimal(*self, t, value, version);
        return *self;
      }

      //! Non member split (load_minimal)
      /*! Versioning implementation */
      template <class T, PROCESS_IF(non_member_versioned_load_minimal)> inline
      ArchiveType & processImpl(T & t)
      {
        using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
        const auto version = loadClassVersion<T>();
        typename traits::has_non_member_versioned_save_minimal<T, OutArchiveType>::type value;
        self->process(value);
        CEREAL_LOAD_MINIMAL_FUNCTION_NAME(*self, t, value, version);
        return *self;
      }

      #undef PROCESS_IF

    private:
      ArchiveType * const self;

      //! A set of all base classes that have been serialized
      std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;

      //! Maps from pointer ids to metadata
      std::unordered_map<std::uint32_t, std::shared_ptr<void>> itsSharedPointerMap;

      //! Maps from name ids to names
      std::unordered_map<std::uint32_t, std::string> itsPolymorphicTypeMap;

      //! Maps from type hash codes to version numbers
      std::unordered_map<std::size_t, std::uint32_t> itsVersionedTypes;
  }; // class InputArchive
} // namespace cereal

// This include needs to come after things such as binary_data, make_nvp, etc
#include "cereal/types/common.hpp"

#endif // CEREAL_CEREAL_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/helpers.hpp
================================================
/*! \file helpers.hpp
    \brief Internal helper functionality
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_DETAILS_HELPERS_HPP_
#define CEREAL_DETAILS_HELPERS_HPP_

#include <type_traits>
#include <cstdint>
#include <utility>
#include <memory>
#include <unordered_map>
#include <stdexcept>

#include "cereal/macros.hpp"
#include "cereal/details/static_object.hpp"

namespace cereal
{
  // ######################################################################
  //! An exception class thrown when things go wrong at runtime
  /*! @ingroup Utility */
  struct Exception : public std::runtime_error
  {
    explicit Exception( const std::string & what_ ) : std::runtime_error(what_) {}
    explicit Exception( const char * what_ ) : std::runtime_error(what_) {}
  };

  // ######################################################################
  //! The size type used by cereal
  /*! To ensure compatability between 32, 64, etc bit machines, we need to use
      a fixed size type instead of size_t, which may vary from machine to
      machine.

      The default value for CEREAL_SIZE_TYPE is specified in cereal/macros.hpp */
  using size_type = CEREAL_SIZE_TYPE;

  // forward decls
  class BinaryOutputArchive;
  class BinaryInputArchive;

  // ######################################################################
  namespace detail
  {
    struct NameValuePairCore {}; //!< Traits struct for NVPs
    struct DeferredDataCore {}; //!< Traits struct for DeferredData
  }

  // ######################################################################
  //! For holding name value pairs
  /*! This pairs a name (some string) with some value such that an archive
      can potentially take advantage of the pairing.

      In serialization functions, NameValuePairs are usually created like so:
      @code{.cpp}
      struct MyStruct
      {
        int a, b, c, d, e;

        template<class Archive>
        void serialize(Archive & archive)
        {
          archive( CEREAL_NVP(a),
                   CEREAL_NVP(b),
                   CEREAL_NVP(c),
                   CEREAL_NVP(d),
                   CEREAL_NVP(e) );
        }
      };
      @endcode

      Alternatively, you can give you data members custom names like so:
      @code{.cpp}
      struct MyStruct
      {
        int a, b, my_embarrassing_variable_name, d, e;

        template<class Archive>
        void serialize(Archive & archive)
        {
          archive( CEREAL_NVP(a),
                   CEREAL_NVP(b),
                   cereal::make_nvp("var", my_embarrassing_variable_name) );
                   CEREAL_NVP(d),
                   CEREAL_NVP(e) );
        }
      };
      @endcode

      There is a slight amount of overhead to creating NameValuePairs, so there
      is a third method which will elide the names when they are not used by
      the Archive:

      @code{.cpp}
      struct MyStruct
      {
        int a, b;

        template<class Archive>
        void serialize(Archive & archive)
        {
          archive( cereal::make_nvp<Archive>(a),
                   cereal::make_nvp<Archive>(b) );
        }
      };
      @endcode

      This third method is generally only used when providing generic type
      support.  Users writing their own serialize functions will normally
      explicitly control whether they want to use NVPs or not.

      @internal */
  template <class T>
  class NameValuePair : detail::NameValuePairCore
  {
    private:
      // If we get passed an array, keep the type as is, otherwise store
      // a reference if we were passed an l value reference, else copy the value
      using Type = typename std::conditional<std::is_array<typename std::remove_reference<T>::type>::value,
                                             typename std::remove_cv<T>::type,
                                             typename std::conditional<std::is_lvalue_reference<T>::value,
                                                                       T,
                                                                       typename std::decay<T>::type>::type>::type;

      // prevent nested nvps
      static_assert( !std::is_base_of<detail::NameValuePairCore, T>::value,
                     "Cannot pair a name to a NameValuePair" );

      NameValuePair & operator=( NameValuePair const & ) = delete;

    public:
      //! Constructs a new NameValuePair
      /*! @param n The name of the pair
          @param v The value to pair.  Ideally this should be an l-value reference so that
                   the value can be both loaded and saved to.  If you pass an r-value reference,
                   the NameValuePair will store a copy of it instead of a reference.  Thus you should
                   only pass r-values in cases where this makes sense, such as the result of some
                   size() call.
          @internal */
      NameValuePair( char const * n, T && v ) : name(n), value(std::forward<T>(v)) {}

      char const * name;
      Type value;
  };

  //! A specialization of make_nvp<> that simply forwards the value for binary archives
  /*! @relates NameValuePair
      @internal */
  template<class Archive, class T> inline
  typename
  std::enable_if<std::is_same<Archive, ::cereal::BinaryInputArchive>::value ||
                 std::is_same<Archive, ::cereal::BinaryOutputArchive>::value,
  T && >::type
  make_nvp( const char *, T && value )
  {
    return std::forward<T>(value);
  }

  //! A specialization of make_nvp<> that actually creates an nvp for non-binary archives
  /*! @relates NameValuePair
      @internal */
  template<class Archive, class T> inline
  typename
  std::enable_if<!std::is_same<Archive, ::cereal::BinaryInputArchive>::value &&
                 !std::is_same<Archive, ::cereal::BinaryOutputArchive>::value,
  NameValuePair<T> >::type
  make_nvp( const char * name, T && value)
  {
    return {name, std::forward<T>(value)};
  }

  //! Convenience for creating a templated NVP
  /*! For use in internal generic typing functions which have an
      Archive type declared
      @internal */
  #define CEREAL_NVP_(name, value) ::cereal::make_nvp<Archive>(name, value)

  // ######################################################################
  //! A wrapper around data that can be serialized in a binary fashion
  /*! This class is used to demarcate data that can safely be serialized
      as a binary chunk of data.  Individual archives can then choose how
      best represent this during serialization.

      @internal */
  template <class T>
  struct BinaryData
  {
    //! Internally store the pointer as a void *, keeping const if created with
    //! a const pointer
    using PT = typename std::conditional<std::is_const<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value,
                                         const void *,
                                         void *>::type;

    BinaryData( T && d, uint64_t s ) : data(std::forward<T>(d)), size(s) {}

    PT data;       //!< pointer to beginning of data
    uint64_t size; //!< size in bytes
  };

  // ######################################################################
  //! A wrapper around data that should be serialized after all non-deferred data
  /*! This class is used to demarcate data that can only be safely serialized after
      any data not wrapped in this class.

      @internal */
  template <class T>
  class DeferredData : detail::DeferredDataCore
  {
    private:
      // If we get passed an array, keep the type as is, otherwise store
      // a reference if we were passed an l value reference, else copy the value
      using Type = typename std::conditional<std::is_array<typename std::remove_reference<T>::type>::value,
                                             typename std::remove_cv<T>::type,
                                             typename std::conditional<std::is_lvalue_reference<T>::value,
                                                                       T,
                                                                       typename std::decay<T>::type>::type>::type;

      // prevent nested nvps
      static_assert( !std::is_base_of<detail::DeferredDataCore, T>::value,
                     "Cannot defer DeferredData" );

      DeferredData & operator=( DeferredData const & ) = delete;

    public:
      //! Constructs a new NameValuePair
      /*! @param v The value to defer.  Ideally this should be an l-value reference so that
                   the value can be both loaded and saved to.  If you pass an r-value reference,
                   the DeferredData will store a copy of it instead of a reference.  Thus you should
                   only pass r-values in cases where this makes sense, such as the result of some
                   size() call.
          @internal */
      DeferredData( T && v ) : value(std::forward<T>(v)) {}

      Type value;
  };

  // ######################################################################
  namespace detail
  {
    // base classes for type checking
    /* The rtti virtual function only exists to enable an archive to
       be used in a polymorphic fashion, if necessary.  See the
       archive adapters for an example of this */
    class OutputArchiveBase
    {
      public:
        OutputArchiveBase() = default;
        OutputArchiveBase( OutputArchiveBase && ) CEREAL_NOEXCEPT {}
        OutputArchiveBase & operator=( OutputArchiveBase && ) CEREAL_NOEXCEPT { return *this; }
        virtual ~OutputArchiveBase() CEREAL_NOEXCEPT = default;

      private:
        virtual void rtti() {}
    };

    class InputArchiveBase
    {
      public:
        InputArchiveBase() = default;
        InputArchiveBase( InputArchiveBase && ) CEREAL_NOEXCEPT {}
        InputArchiveBase & operator=( InputArchiveBase && ) CEREAL_NOEXCEPT { return *this; }
        virtual ~InputArchiveBase() CEREAL_NOEXCEPT = default;

      private:
        virtual void rtti() {}
    };

    // forward decls for polymorphic support
    template <class Archive, class T> struct polymorphic_serialization_support;
    struct adl_tag;

    // used during saving pointers
    static const uint32_t msb_32bit  = 0x80000000;
    static const int32_t msb2_32bit = 0x40000000;
  }

  // ######################################################################
  //! A wrapper around size metadata
  /*! This class provides a way for archives to have more flexibility over how
      they choose to serialize size metadata for containers.  For some archive
      types, the size may be implicitly encoded in the output (e.g. JSON) and
      not need an explicit entry.  Specializing serialize or load/save for
      your archive and SizeTags allows you to choose what happens.

      @internal */
  template <class T>
  class SizeTag
  {
    private:
      // Store a reference if passed an lvalue reference, otherwise
      // make a copy of the data
      using Type = typename std::conditional<std::is_lvalue_reference<T>::value,
                                             T,
                                             typename std::decay<T>::type>::type;

      SizeTag & operator=( SizeTag const & ) = delete;

    public:
      SizeTag( T && sz ) : size(std::forward<T>(sz)) {}

      Type size;
  };

  // ######################################################################
  //! A wrapper around a key and value for serializing data into maps.
  /*! This class just provides a grouping of keys and values into a struct for
      human readable archives. For example, XML archives will use this wrapper
      to write maps like so:

      @code{.xml}
      <mymap>
        <item0>
          <key>MyFirstKey</key>
          <value>MyFirstValue</value>
        </item0>
        <item1>
          <key>MySecondKey</key>
          <value>MySecondValue</value>
        </item1>
      </mymap>
      @endcode

      \sa make_map_item
      @internal */
  template <class Key, class Value>
  struct MapItem
  {
    using KeyType = typename std::conditional<
      std::is_lvalue_reference<Key>::value,
      Key,
      typename std::decay<Key>::type>::type;

    using ValueType = typename std::conditional<
      std::is_lvalue_reference<Value>::value,
      Value,
      typename std::decay<Value>::type>::type;

    //! Construct a MapItem from a key and a value
    /*! @internal */
    MapItem( Key && key_, Value && value_ ) : key(std::forward<Key>(key_)), value(std::forward<Value>(value_)) {}

    MapItem & operator=( MapItem const & ) = delete;

    KeyType key;
    ValueType value;

    //! Serialize the MapItem with the NVPs "key" and "value"
    template <class Archive> inline
    void CEREAL_SERIALIZE_FUNCTION_NAME(Archive & archive)
    {
      archive( make_nvp<Archive>("key",   key),
               make_nvp<Archive>("value", value) );
    }
  };

  //! Create a MapItem so that human readable archives will group keys and values together
  /*! @internal
      @relates MapItem */
  template <class KeyType, class ValueType> inline
  MapItem<KeyType, ValueType> make_map_item(KeyType && key, ValueType && value)
  {
    return {std::forward<KeyType>(key), std::forward<ValueType>(value)};
  }

  namespace detail
  {
    //! Tag for Version, which due to its anonymous namespace, becomes a different
    //! type in each translation unit
    /*! This allows CEREAL_CLASS_VERSION to be safely called in a header file */
    namespace{ struct version_binding_tag {}; }

    // ######################################################################
    //! Version information class
    /*! This is the base case for classes that have not been explicitly
        registered */
    template <class T, class BindingTag = version_binding_tag> struct Version
    {
      static const std::uint32_t version = 0;
      // we don't need to explicitly register these types since they
      // always get a version number of 0
    };

    //! Holds all registered version information
    struct Versions
    {
      std::unordered_map<std::size_t, std::uint32_t> mapping;

      std::uint32_t find( std::size_t hash, std::uint32_t version )
      {
        const auto result = mapping.emplace( hash, version );
        return result.first->second;
      }
    }; // struct Versions
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_HELPERS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/polymorphic_impl.hpp
================================================
/*! \file polymorphic_impl.hpp
    \brief Internal polymorphism support
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* This code is heavily inspired by the boost serialization implementation by the following authors

   (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
   Use, modification and distribution is subject to the Boost Software
   License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)

    See http://www.boost.org for updates, documentation, and revision history.

   (C) Copyright 2006 David Abrahams - http://www.boost.org.

   See /boost/serialization/export.hpp, /boost/archive/detail/register_archive.hpp,
   and /boost/serialization/void_cast.hpp for their implementation. Additional details
   found in other files split across serialization and archive.
*/
#ifndef CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_
#define CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_

#include "cereal/details/polymorphic_impl_fwd.hpp"
#include "cereal/details/static_object.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/types/string.hpp"
#include <functional>
#include <typeindex>
#include <map>
#include <limits>
#include <set>
#include <stack>

//! Helper macro to omit unused warning
#if defined(__GNUC__)
  // GCC / clang don't want the function
  #define CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION
#else
  #define CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION static void unused() { (void)b; }
#endif

//! Binds a polymorhic type to all registered archives
/*! This binds a polymorphic type to all compatible registered archives that
    have been registered with CEREAL_REGISTER_ARCHIVE.  This must be called
    after all archives are registered (usually after the archives themselves
    have been included). */
#define CEREAL_BIND_TO_ARCHIVES(...)                                     \
    namespace cereal {                                                   \
    namespace detail {                                                   \
    template<>                                                           \
    struct init_binding<__VA_ARGS__> {                                   \
        static bind_to_archives<__VA_ARGS__> const & b;                  \
        CEREAL_BIND_TO_ARCHIVES_UNUSED_FUNCTION                          \
    };                                                                   \
    bind_to_archives<__VA_ARGS__> const & init_binding<__VA_ARGS__>::b = \
        ::cereal::detail::StaticObject<                                  \
            bind_to_archives<__VA_ARGS__>                                \
        >::getInstance().bind();                                         \
    }} /* end namespaces */

namespace cereal
{
  /* Polymorphic casting support */
  namespace detail
  {
    //! Base type for polymorphic void casting
    /*! Contains functions for casting between registered base and derived types.

        This is necessary so that cereal can properly cast between polymorphic types
        even though void pointers are used, which normally have no type information.
        Runtime type information is used instead to index a compile-time made mapping
        that can perform the proper cast. In the case of multiple levels of inheritance,
        cereal will attempt to find the shortest path by using registered relationships to
        perform the cast.

        This class will be allocated as a StaticObject and only referenced by pointer,
        allowing a templated derived version of it to define strongly typed functions
        that cast between registered base and derived types. */
    struct PolymorphicCaster
    {
      PolymorphicCaster() = default;
      PolymorphicCaster( const PolymorphicCaster & ) = default;
      PolymorphicCaster & operator=( const PolymorphicCaster & ) = default;
      PolymorphicCaster( PolymorphicCaster && ) CEREAL_NOEXCEPT {}
      PolymorphicCaster & operator=( PolymorphicCaster && ) CEREAL_NOEXCEPT { return *this; }
      virtual ~PolymorphicCaster() CEREAL_NOEXCEPT = default;

      //! Downcasts to the proper derived type
      virtual void const * downcast( void const * const ptr ) const = 0;
      //! Upcast to proper base type
      virtual void * upcast( void * const ptr ) const = 0;
      //! Upcast to proper base type, shared_ptr version
      virtual std::shared_ptr<void> upcast( std::shared_ptr<void> const & ptr ) const = 0;
    };

    //! Holds registered mappings between base and derived types for casting
    /*! This will be allocated as a StaticObject and holds a map containing
        all registered mappings between base and derived types. */
    struct PolymorphicCasters
    {
      //! Maps from a derived type index to a set of chainable casters
      using DerivedCasterMap = std::unordered_map<std::type_index, std::vector<PolymorphicCaster const *>>;
      //! Maps from base type index to a map from derived type index to caster
      std::unordered_map<std::type_index, DerivedCasterMap> map;

      std::multimap<std::type_index, std::type_index> reverseMap;

      //! Error message used for unregistered polymorphic casts
      #define UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION(LoadSave)                                                                                                                \
        throw cereal::Exception("Trying to " #LoadSave " a registered polymorphic type with an unregistered polymorphic cast.\n"                                               \
                                "Could not find a path to a base class (" + util::demangle(baseInfo.name()) + ") for type: " + ::cereal::util::demangledName<Derived>() + "\n" \
                                "Make sure you either serialize the base class at some point via cereal::base_class or cereal::virtual_base_class.\n"                          \
                                "Alternatively, manually register the association with CEREAL_REGISTER_POLYMORPHIC_RELATION.");

      //! Checks if the mapping object that can perform the upcast or downcast exists, and returns it if so
      /*! Uses the type index from the base and derived class to find the matching
          registered caster. If no matching caster exists, the bool in the pair will be false and the vector
          reference should not be used. */
      static std::pair<bool, std::vector<PolymorphicCaster const *> const &>
      lookup_if_exists( std::type_index const & baseIndex, std::type_index const & derivedIndex )
      {
        // First phase of lookup - match base type index
        auto const & baseMap = StaticObject<PolymorphicCasters>::getInstance().map;
        auto baseIter = baseMap.find( baseIndex );
        if (baseIter == baseMap.end())
          return {false, {}};

        // Second phase - find a match from base to derived
        auto const & derivedMap = baseIter->second;
        auto derivedIter = derivedMap.find( derivedIndex );
        if (derivedIter == derivedMap.end())
          return {false, {}};

        return {true, derivedIter->second};
      }

      //! Gets the mapping object that can perform the upcast or downcast
      /*! Uses the type index from the base and derived class to find the matching
          registered caster. If no matching caster exists, calls the exception function.

          The returned PolymorphicCaster is capable of upcasting or downcasting between the two types. */
      template <class F> inline
      static std::vector<PolymorphicCaster const *> const & lookup( std::type_index const & baseIndex, std::type_index const & derivedIndex, F && exceptionFunc )
      {
        // First phase of lookup - match base type index
        auto const & baseMap = StaticObject<PolymorphicCasters>::getInstance().map;
        auto baseIter = baseMap.find( baseIndex );
        if( baseIter == baseMap.end() )
          exceptionFunc();

        // Second phase - find a match from base to derived
        auto const & derivedMap = baseIter->second;
        auto derivedIter = derivedMap.find( derivedIndex );
        if( derivedIter == derivedMap.end() )
          exceptionFunc();

        return derivedIter->second;
      }

      //! Performs a downcast to the derived type using a registered mapping
      template <class Derived> inline
      static const Derived * downcast( const void * dptr, std::type_info const & baseInfo )
      {
        auto const & mapping = lookup( baseInfo, typeid(Derived), [&](){ UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION(save) } );

        for( auto const * dmap : mapping )
          dptr = dmap->downcast( dptr );

        return static_cast<Derived const *>( dptr );
      }

      //! Performs an upcast to the registered base type using the given a derived type
      /*! The return is untyped because the final casting to the base type must happen in the polymorphic
          serialization function, where the type is known at compile time */
      template <class Derived> inline
      static void * upcast( Derived * const dptr, std::type_info const & baseInfo )
      {
        auto const & mapping = lookup( baseInfo, typeid(Derived), [&](){ UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION(load) } );

        void * uptr = dptr;
        for( auto mIter = mapping.rbegin(), mEnd = mapping.rend(); mIter != mEnd; ++mIter )
          uptr = (*mIter)->upcast( uptr );

        return uptr;
      }

      //! Upcasts for shared pointers
      template <class Derived> inline
      static std::shared_ptr<void> upcast( std::shared_ptr<Derived> const & dptr, std::type_info const & baseInfo )
      {
        auto const & mapping = lookup( baseInfo, typeid(Derived), [&](){ UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION(load) } );

        std::shared_ptr<void> uptr = dptr;
        for( auto mIter = mapping.rbegin(), mEnd = mapping.rend(); mIter != mEnd; ++mIter )
          uptr = (*mIter)->upcast( uptr );

        return uptr;
      }

      #undef UNREGISTERED_POLYMORPHIC_CAST_EXCEPTION
    };

    #ifdef CEREAL_OLDER_GCC
      #define CEREAL_EMPLACE_MAP(map, key, value)                     \
      map.insert( std::make_pair(std::move(key), std::move(value)) );
    #else // NOT CEREAL_OLDER_GCC
      #define CEREAL_EMPLACE_MAP(map, key, value)                     \
      map.emplace( key, value );
    #endif // NOT_CEREAL_OLDER_GCC

    //! Strongly typed derivation of PolymorphicCaster
    template <class Base, class Derived>
    struct PolymorphicVirtualCaster : PolymorphicCaster
    {
      //! Inserts an entry in the polymorphic casting map for this pairing
      /*! Creates an explicit mapping between Base and Derived in both upwards and
          downwards directions, allowing void pointers to either to be properly cast
          assuming dynamic type information is available */
      PolymorphicVirtualCaster()
      {
        const auto baseKey = std::type_index(typeid(Base));
        const auto derivedKey = std::type_index(typeid(Derived));

        // First insert the relation Base->Derived
        const auto lock = StaticObject<PolymorphicCasters>::lock();
        auto & baseMap = StaticObject<PolymorphicCasters>::getInstance().map;

        {
          auto & derivedMap = baseMap.insert( {baseKey, PolymorphicCasters::DerivedCasterMap{}} ).first->second;
          auto & derivedVec = derivedMap.insert( {derivedKey, {}} ).first->second;
          derivedVec.push_back( this );
        }

        // Insert reverse relation Derived->Base
        auto & reverseMap = StaticObject<PolymorphicCasters>::getInstance().reverseMap;
        CEREAL_EMPLACE_MAP(reverseMap, derivedKey, baseKey);

        // Find all chainable unregistered relations
        /* The strategy here is to process only the nodes in the class hierarchy graph that have been
           affected by the new insertion. The aglorithm iteratively processes a node an ensures that it
           is updated with all new shortest length paths. It then rocesses the parents of the active node,
           with the knowledge that all children have already been processed.

           Note that for the following, we'll use the nomenclature of parent and child to not confuse with
           the inserted base derived relationship */
        {
          // Checks whether there is a path from parent->child and returns a <dist, path> pair
          // dist is set to MAX if the path does not exist
          auto checkRelation = [](std::type_index const & parentInfo, std::type_index const & childInfo) ->
            std::pair<size_t, std::vector<PolymorphicCaster const *> const &>
          {
            auto result = PolymorphicCasters::lookup_if_exists( parentInfo, childInfo );
            if( result.first )
            {
              auto const & path = result.second;
              return {path.size(), path};
            }
            else
              return {(std::numeric_limits<size_t>::max)(), {}};
          };

          std::stack<std::type_index>         parentStack;      // Holds the parent nodes to be processed
          std::vector<std::type_index> dirtySet;                // Marks child nodes that have been changed
          std::unordered_set<std::type_index> processedParents; // Marks parent nodes that have been processed

          // Checks if a child has been marked dirty
          auto isDirty = [&](std::type_index const & c)
          {
            auto const dirtySetSize = dirtySet.size();
            for( size_t i = 0; i < dirtySetSize; ++i )
              if( dirtySet[i] == c )
                return true;

            return false;
          };

          // Begin processing the base key and mark derived as dirty
          parentStack.push( baseKey );
          dirtySet.emplace_back( derivedKey );

          while( !parentStack.empty() )
          {
            using Relations = std::unordered_multimap<std::type_index, std::pair<std::type_index, std::vector<PolymorphicCaster const *>>>;
            Relations unregisteredRelations; // Defer insertions until after main loop to prevent iterator invalidation

            const auto parent = parentStack.top();
            parentStack.pop();

            // Update paths to all children marked dirty
            for( auto const & childPair : baseMap[parent] )
            {
              const auto child = childPair.first;
              if( isDirty( child ) && baseMap.count( child ) )
              {
                auto parentChildPath = checkRelation( parent, child );

                // Search all paths from the child to its own children (finalChild),
                // looking for a shorter parth from parent to finalChild
                for( auto const & finalChildPair : baseMap[child] )
                {
                  const auto finalChild = finalChildPair.first;

                  auto parentFinalChildPath = checkRelation( parent, finalChild );
                  auto childFinalChildPath  = checkRelation( child, finalChild );

                  const size_t newLength = 1u + parentChildPath.first;

                  if( newLength < parentFinalChildPath.first )
                  {
                    std::vector<PolymorphicCaster const *> path = parentChildPath.second;
                    path.insert( path.end(), childFinalChildPath.second.begin(), childFinalChildPath.second.end() );

                    // Check to see if we have a previous uncommitted path in unregisteredRelations
                    // that is shorter. If so, ignore this path
                    auto hintRange = unregisteredRelations.equal_range( parent );
                    auto hint = hintRange.first;
                    for( ; hint != hintRange.second; ++hint )
                      if( hint->second.first == finalChild )
                        break;

                    const bool uncommittedExists = hint != unregisteredRelations.end();
                    if( uncommittedExists && (hint->second.second.size() <= newLength) )
                      continue;

                    auto newPath = std::pair<std::type_index, std::vector<PolymorphicCaster const *>>{finalChild, std::move(path)};

                    // Insert the new path if it doesn't exist, otherwise this will just lookup where to do the
                    // replacement
                    #ifdef CEREAL_OLDER_GCC
                    auto old = unregisteredRelations.insert( hint, std::make_pair(parent, newPath) );
                    #else // NOT CEREAL_OLDER_GCC
                    auto old = unregisteredRelations.emplace_hint( hint, parent, newPath );
                    #endif // NOT CEREAL_OLDER_GCC

                    // If there was an uncommitted path, we need to perform a replacement
                    if( uncommittedExists )
                      old->second = newPath;
                  }
                } // end loop over child's children
              } // end if dirty and child has children
            } // end loop over children

            // Insert chained relations
            for( auto const & it : unregisteredRelations )
            {
              auto & derivedMap = baseMap.find( it.first )->second;
              derivedMap[it.second.first] = it.second.second;
              CEREAL_EMPLACE_MAP(reverseMap, it.second.first, it.first );
            }

            // Mark current parent as modified
            dirtySet.emplace_back( parent );

            // Insert all parents of the current parent node that haven't yet been processed
            auto parentRange = reverseMap.equal_range( parent );
            for( auto pIter = parentRange.first; pIter != parentRange.second; ++pIter )
            {
              const auto pParent = pIter->second;
              if( !processedParents.count( pParent ) )
              {
                parentStack.push( pParent );
                processedParents.insert( pParent );
              }
            }
          } // end loop over parent stack
        } // end chainable relations
      } // end PolymorphicVirtualCaster()

      #undef CEREAL_EMPLACE_MAP

      //! Performs the proper downcast with the templated types
      void const * downcast( void const * const ptr ) const override
      {
        return dynamic_cast<Derived const*>( static_cast<Base const*>( ptr ) );
      }

      //! Performs the proper upcast with the templated types
      void * upcast( void * const ptr ) const override
      {
        return dynamic_cast<Base*>( static_cast<Derived*>( ptr ) );
      }

      //! Performs the proper upcast with the templated types (shared_ptr version)
      std::shared_ptr<void> upcast( std::shared_ptr<void> const & ptr ) const override
      {
        return std::dynamic_pointer_cast<Base>( std::static_pointer_cast<Derived>( ptr ) );
      }
    };

    //! Registers a polymorphic casting relation between a Base and Derived type
    /*! Registering a relation allows cereal to properly cast between the two types
        given runtime type information and void pointers.

        Registration happens automatically via cereal::base_class and cereal::virtual_base_class
        instantiations. For cases where neither is called, see the CEREAL_REGISTER_POLYMORPHIC_RELATION
        macro */
    template <class Base, class Derived>
    struct RegisterPolymorphicCaster
    {
      static PolymorphicCaster const * bind( std::true_type /* is_polymorphic<Base> */)
      {
        return &StaticObject<PolymorphicVirtualCaster<Base, Derived>>::getInstance();
      }

      static PolymorphicCaster const * bind( std::false_type /* is_polymorphic<Base> */ )
      { return nullptr; }

      //! Performs registration (binding) between Base and Derived
      /*! If the type is not polymorphic, nothing will happen */
      static PolymorphicCaster const * bind()
      { return bind( typename std::is_polymorphic<Base>::type() ); }
    };
  }

  /* General polymorphism support */
  namespace detail
  {
    //! Binds a compile time type with a user defined string
    template <class T>
    struct binding_name {};

    //! A structure holding a map from type_indices to output serializer functions
    /*! A static object of this map should be created for each registered archive
        type, containing entries for every registered type that describe how to
        properly cast the type to its real type in polymorphic scenarios for
        shared_ptr, weak_ptr, and unique_ptr. */
    template <class Archive>
    struct OutputBindingMap
    {
      //! A serializer function
      /*! Serializer functions return nothing and take an archive as
          their first parameter (will be cast properly inside the function,
          a pointer to actual data (contents of smart_ptr's get() function)
          as their second parameter, and the type info of the owning smart_ptr
          as their final parameter */
      typedef std::function<void(void*, void const *, std::type_info const &)> Serializer;

      //! Struct containing the serializer functions for all pointer types
      struct Serializers
      {
        Serializer shared_ptr, //!< Serializer function for shared/weak pointers
                   unique_ptr; //!< Serializer function for unique pointers
      };

      //! A map of serializers for pointers of all registered types
      std::map<std::type_index, Serializers> map;
    };

    //! An empty noop deleter
    template<class T> struct EmptyDeleter { void operator()(T *) const {} };

    //! A structure holding a map from type name strings to input serializer functions
    /*! A static object of this map should be created for each registered archive
        type, containing entries for every registered type that describe how to
        properly cast the type to its real type in polymorphic scenarios for
        shared_ptr, weak_ptr, and unique_ptr. */
    template <class Archive>
    struct InputBindingMap
    {
      //! Shared ptr serializer function
      /*! Serializer functions return nothing and take an archive as
          their first parameter (will be cast properly inside the function,
          a shared_ptr (or unique_ptr for the unique case) of any base
          type, and the type id of said base type as the third parameter.
          Internally it will properly be loaded and cast to the correct type. */
      typedef std::function<void(void*, std::shared_ptr<void> &, std::type_info const &)> SharedSerializer;
      //! Unique ptr serializer function
      typedef std::function<void(void*, std::unique_ptr<void, EmptyDeleter<void>> &, std::type_info const &)> UniqueSerializer;

      //! Struct containing the serializer functions for all pointer types
      struct Serializers
      {
        SharedSerializer shared_ptr; //!< Serializer function for shared/weak pointers
        UniqueSerializer unique_ptr; //!< Serializer function for unique pointers
      };

      //! A map of serializers for pointers of all registered types
      std::map<std::string, Serializers> map;
    };

    // forward decls for archives from cereal.hpp
    class InputArchiveBase;
    class OutputArchiveBase;

    //! Creates a binding (map entry) between an input archive type and a polymorphic type
    /*! Bindings are made when types are registered, assuming that at least one
        archive has already been registered.  When this struct is created,
        it will insert (at run time) an entry into a map that properly handles
        casting for serializing polymorphic objects */
    template <class Archive, class T> struct InputBindingCreator
    {
      //! Initialize the binding
      InputBindingCreator()
      {
        auto & map = StaticObject<InputBindingMap<Archive>>::getInstance().map;
        auto lock = StaticObject<InputBindingMap<Archive>>::lock();
        auto key = std::string(binding_name<T>::name());
        auto lb = map.lower_bound(key);

        if (lb != map.end() && lb->first == key)
          return;

        typename InputBindingMap<Archive>::Serializers serializers;

        serializers.shared_ptr =
          [](void * arptr, std::shared_ptr<void> & dptr, std::type_info const & baseInfo)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            std::shared_ptr<T> ptr;

            ar( CEREAL_NVP_("ptr_wrapper", ::cereal::memory_detail::make_ptr_wrapper(ptr)) );

            dptr = PolymorphicCasters::template upcast<T>( ptr, baseInfo );
          };

        serializers.unique_ptr =
          [](void * arptr, std::unique_ptr<void, EmptyDeleter<void>> & dptr, std::type_info const & baseInfo)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            std::unique_ptr<T> ptr;

            ar( CEREAL_NVP_("ptr_wrapper", ::cereal::memory_detail::make_ptr_wrapper(ptr)) );

            dptr.reset( PolymorphicCasters::template upcast<T>( ptr.release(), baseInfo ));
          };

        map.insert( lb, { std::move(key), std::move(serializers) } );
      }
    };

    //! Creates a binding (map entry) between an output archive type and a polymorphic type
    /*! Bindings are made when types are registered, assuming that at least one
        archive has already been registered.  When this struct is created,
        it will insert (at run time) an entry into a map that properly handles
        casting for serializing polymorphic objects */
    template <class Archive, class T> struct OutputBindingCreator
    {
      //! Writes appropriate metadata to the archive for this polymorphic type
      static void writeMetadata(Archive & ar)
      {
        // Register the polymorphic type name with the archive, and get the id
        char const * name = binding_name<T>::name();
        std::uint32_t id = ar.registerPolymorphicType(name);

        // Serialize the id
        ar( CEREAL_NVP_("polymorphic_id", id) );

        // If the msb of the id is 1, then the type name is new, and we should serialize it
        if( id & detail::msb_32bit )
        {
          std::string namestring(name);
          ar( CEREAL_NVP_("polymorphic_name", namestring) );
        }
      }

      //! Holds a properly typed shared_ptr to the polymorphic type
      class PolymorphicSharedPointerWrapper
      {
        public:
          /*! Wrap a raw polymorphic pointer in a shared_ptr to its true type

              The wrapped pointer will not be responsible for ownership of the held pointer
              so it will not attempt to destroy it; instead the refcount of the wrapped
              pointer will be tied to a fake 'ownership pointer' that will do nothing
              when it ultimately goes out of scope.

              The main reason for doing this, other than not to destroy the true object
              with our wrapper pointer, is to avoid meddling with the internal reference
              count in a polymorphic type that inherits from std::enable_shared_from_this.

              @param dptr A void pointer to the contents of the shared_ptr to serialize */
          PolymorphicSharedPointerWrapper( T const * dptr ) : refCount(), wrappedPtr( refCount, dptr )
          { }

          //! Get the wrapped shared_ptr */
          inline std::shared_ptr<T const> const & operator()() const { return wrappedPtr; }

        private:
          std::shared_ptr<void> refCount;      //!< The ownership pointer
          std::shared_ptr<T const> wrappedPtr; //!< The wrapped pointer
      };

      //! Does the actual work of saving a polymorphic shared_ptr
      /*! This function will properly create a shared_ptr from the void * that is passed in
          before passing it to the archive for serialization.

          In addition, this will also preserve the state of any internal enable_shared_from_this mechanisms

          @param ar The archive to serialize to
          @param dptr Pointer to the actual data held by the shared_ptr */
      static inline void savePolymorphicSharedPtr( Archive & ar, T const * dptr, std::true_type /* has_shared_from_this */ )
      {
        ::cereal::memory_detail::EnableSharedStateHelper<T> state( const_cast<T *>(dptr) );
        PolymorphicSharedPointerWrapper psptr( dptr );
        ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( psptr() ) ) );
      }

      //! Does the actual work of saving a polymorphic shared_ptr
      /*! This function will properly create a shared_ptr from the void * that is passed in
          before passing it to the archive for serialization.

          This version is for types that do not inherit from std::enable_shared_from_this.

          @param ar The archive to serialize to
          @param dptr Pointer to the actual data held by the shared_ptr */
      static inline void savePolymorphicSharedPtr( Archive & ar, T const * dptr, std::false_type /* has_shared_from_this */ )
      {
        PolymorphicSharedPointerWrapper psptr( dptr );
        ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( psptr() ) ) );
      }

      //! Initialize the binding
      OutputBindingCreator()
      {
        auto & map = StaticObject<OutputBindingMap<Archive>>::getInstance().map;
        auto key = std::type_index(typeid(T));
        auto lb = map.lower_bound(key);

        if (lb != map.end() && lb->first == key)
          return;

        typename OutputBindingMap<Archive>::Serializers serializers;

        serializers.shared_ptr =
          [&](void * arptr, void const * dptr, std::type_info const & baseInfo)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            writeMetadata(ar);

            auto ptr = PolymorphicCasters::template downcast<T>( dptr, baseInfo );

            #ifdef _MSC_VER
            savePolymorphicSharedPtr( ar, ptr, ::cereal::traits::has_shared_from_this<T>::type() ); // MSVC doesn't like typename here
            #else // not _MSC_VER
            savePolymorphicSharedPtr( ar, ptr, typename ::cereal::traits::has_shared_from_this<T>::type() );
            #endif // _MSC_VER
          };

        serializers.unique_ptr =
          [&](void * arptr, void const * dptr, std::type_info const & baseInfo)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            writeMetadata(ar);

            std::unique_ptr<T const, EmptyDeleter<T const>> const ptr( PolymorphicCasters::template downcast<T>( dptr, baseInfo ) );

            ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
          };

        map.insert( { std::move(key), std::move(serializers) } );
      }
    };

    //! Used to help out argument dependent lookup for finding potential overloads
    //! of instantiate_polymorphic_binding
    struct adl_tag {};

    //! Tag for init_binding, bind_to_archives and instantiate_polymorphic_binding. Due to the use of anonymous
    //! namespace it becomes a different type in each translation unit.
    namespace { struct polymorphic_binding_tag {}; }

    //! Causes the static object bindings between an archive type and a serializable type T
    template <class Archive, class T>
    struct create_bindings
    {
      static const InputBindingCreator<Archive, T> &
      load(std::true_type)
      {
        return cereal::detail::StaticObject<InputBindingCreator<Archive, T>>::getInstance();
      }

      static const OutputBindingCreator<Archive, T> &
      save(std::true_type)
      {
        return cereal::detail::StaticObject<OutputBindingCreator<Archive, T>>::getInstance();
      }

      inline static void load(std::false_type) {}
      inline static void save(std::false_type) {}
    };

    //! When specialized, causes the compiler to instantiate its parameter
    template <void(*)()>
    struct instantiate_function {};

    /*! This struct is used as the return type of instantiate_polymorphic_binding
        for specific Archive types.  When the compiler looks for overloads of
        instantiate_polymorphic_binding, it will be forced to instantiate this
        struct during overload resolution, even though it will not be part of a valid
        overload */
    template <class Archive, class T>
    struct polymorphic_serialization_support
    {
      #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
      //! Creates the appropriate bindings depending on whether the archive supports
      //! saving or loading
      virtual CEREAL_DLL_EXPORT void instantiate() CEREAL_USED;
      #else // NOT _MSC_VER
      //! Creates the appropriate bindings depending on whether the archive supports
      //! saving or loading
      static CEREAL_DLL_EXPORT void instantiate() CEREAL_USED;
      //! This typedef causes the compiler to instantiate this static function
      typedef instantiate_function<instantiate> unused;
      #endif // _MSC_VER
    };

    // instantiate implementation
    template <class Archive, class T>
    CEREAL_DLL_EXPORT void polymorphic_serialization_support<Archive,T>::instantiate()
    {
      create_bindings<Archive,T>::save( std::integral_constant<bool,
                                          std::is_base_of<detail::OutputArchiveBase, Archive>::value &&
                                          traits::is_output_serializable<T, Archive>::value>{} );

      create_bindings<Archive,T>::load( std::integral_constant<bool,
                                          std::is_base_of<detail::InputArchiveBase, Archive>::value &&
                                          traits::is_input_serializable<T, Archive>::value>{} );
    }

    //! Begins the binding process of a type to all registered archives
    /*! Archives need to be registered prior to this struct being instantiated via
        the CEREAL_REGISTER_ARCHIVE macro.  Overload resolution will then force
        several static objects to be made that allow us to bind together all
        registered archive types with the parameter type T. */
    template <class T, class Tag = polymorphic_binding_tag>
    struct bind_to_archives
    {
      //! Binding for non abstract types
      void bind(std::false_type) const
      {
        instantiate_polymorphic_binding(static_cast<T*>(nullptr), 0, Tag{}, adl_tag{});
      }

      //! Binding for abstract types
      void bind(std::true_type) const
      { }

      //! Binds the type T to all registered archives
      /*! If T is abstract, we will not serialize it and thus
          do not need to make a binding */
      bind_to_archives const & bind() const
      {
        static_assert( std::is_polymorphic<T>::value,
                       "Attempting to register non polymorphic type" );
        bind( std::is_abstract<T>() );
        return *this;
      }
    };

    //! Used to hide the static object used to bind T to registered archives
    template <class T, class Tag = polymorphic_binding_tag>
    struct init_binding;

    //! Base case overload for instantiation
    /*! This will end up always being the best overload due to the second
        parameter always being passed as an int.  All other overloads will
        accept pointers to archive types and have lower precedence than int.

        Since the compiler needs to check all possible overloads, the
        other overloads created via CEREAL_REGISTER_ARCHIVE, which will have
        lower precedence due to requring a conversion from int to (Archive*),
        will cause their return types to be instantiated through the static object
        mechanisms even though they are never called.

        See the documentation for the other functions to try and understand this */
    template <class T, typename BindingTag>
    void instantiate_polymorphic_binding( T*, int, BindingTag, adl_tag ) {}
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/polymorphic_impl_fwd.hpp
================================================
/*! \file polymorphic_impl_fwd.hpp
    \brief Internal polymorphism support forward declarations
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* This code is heavily inspired by the boost serialization implementation by the following authors

   (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
   Use, modification and distribution is subject to the Boost Software
   License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)

    See http://www.boost.org for updates, documentation, and revision history.

   (C) Copyright 2006 David Abrahams - http://www.boost.org.

   See /boost/serialization/export.hpp and /boost/archive/detail/register_archive.hpp for their
   implementation.
*/

#ifndef CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_
#define CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_

namespace cereal
{
  namespace detail
  {
    //! Forward declaration, see polymorphic_impl.hpp for more information
    template <class Base, class Derived>
    struct RegisterPolymorphicCaster;

    //! Forward declaration, see polymorphic_impl.hpp for more information
    struct PolymorphicCasters;

    //! Forward declaration, see polymorphic_impl.hpp for more information
    template <class Base, class Derived>
    struct PolymorphicRelation;
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_POLYMORPHIC_IMPL_FWD_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/static_object.hpp
================================================
/*! \file static_object.hpp
    \brief Internal polymorphism static object support
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_DETAILS_STATIC_OBJECT_HPP_
#define CEREAL_DETAILS_STATIC_OBJECT_HPP_

#include "cereal/macros.hpp"

#if CEREAL_THREAD_SAFE
#include <mutex>
#endif

//! Prevent link optimization from removing non-referenced static objects
/*! Especially for polymorphic support, we create static objects which
    may not ever be explicitly referenced.  Most linkers will detect this
    and remove the code causing various unpleasant runtime errors.  These
    macros, adopted from Boost (see force_include.hpp) prevent this
    (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt) */

#ifdef _MSC_VER
#   define CEREAL_DLL_EXPORT __declspec(dllexport)
#   define CEREAL_USED
#else // clang or gcc
#   define CEREAL_DLL_EXPORT __attribute__ ((visibility("default")))
#   define CEREAL_USED __attribute__ ((__used__))
#endif

namespace cereal
{
  namespace detail
  {
    //! A static, pre-execution object
    /*! This class will create a single copy (singleton) of some
        type and ensures that merely referencing this type will
        cause it to be instantiated and initialized pre-execution.
        For example, this is used heavily in the polymorphic pointer
        serialization mechanisms to bind various archive types with
        different polymorphic classes */
    template <class T>
    class CEREAL_DLL_EXPORT StaticObject
    {
      private:

        static T & create()
        {
          static T t;
          //! Forces instantiation at pre-execution time
          (void)instance;
          return t;
        }

        StaticObject( StaticObject const & /*other*/ ) {}

      public:
        static T & getInstance()
        {
          return create();
        }

        //! A class that acts like std::lock_guard
        class LockGuard
        {
          #if CEREAL_THREAD_SAFE
          public:
            LockGuard(std::mutex & m) : lock(m) {}
          private:
            std::unique_lock<std::mutex> lock;
          #else
          public:
	          LockGuard(LockGuard const &) = default; // prevents implicit copy ctor warning
            ~LockGuard() CEREAL_NOEXCEPT {} // prevents variable not used
          #endif
        };

        //! Attempts to lock this static object for the current scope
        /*! @note This function is a no-op if cereal is not compiled with
                  thread safety enabled (CEREAL_THREAD_SAFE = 1).

            This function returns an object that holds a lock for
            this StaticObject that will release its lock upon destruction. This
            call will block until the lock is available. */
        static LockGuard lock()
        {
          #if CEREAL_THREAD_SAFE
          static std::mutex instanceMutex;
          return LockGuard{instanceMutex};
          #else
          return LockGuard{};
          #endif
        }

      private:
        static T & instance;
    };

    template <class T> T & StaticObject<T>::instance = StaticObject<T>::create();
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_STATIC_OBJECT_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/traits.hpp
================================================
/*! \file traits.hpp
    \brief Internal type trait support
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_DETAILS_TRAITS_HPP_
#define CEREAL_DETAILS_TRAITS_HPP_

#ifndef __clang__
#if (__GNUC__ == 4 && __GNUC_MINOR__ <= 7)
#define CEREAL_OLDER_GCC
#endif // gcc 4.7 or earlier
#endif // __clang__

#include <type_traits>
#include <typeindex>

#include "cereal/macros.hpp"
#include "cereal/access.hpp"

namespace cereal
{
  namespace traits
  {
    using yes = std::true_type;
    using no  = std::false_type;

    namespace detail
    {
      // ######################################################################
      //! Used to delay a static_assert until template instantiation
      template <class T>
      struct delay_static_assert : std::false_type {};

      // ######################################################################
      // SFINAE Helpers
      #ifdef CEREAL_OLDER_GCC // when VS supports better SFINAE, we can use this as the default
      template<typename> struct Void { typedef void type; };
      #endif // CEREAL_OLDER_GCC

      //! Return type for SFINAE Enablers
      enum class sfinae {};

      // ######################################################################
      // Helper functionality for boolean integral constants and Enable/DisableIf
      template <bool H, bool ... T> struct meta_bool_and : std::integral_constant<bool, H && meta_bool_and<T...>::value> {};
      template <bool B> struct meta_bool_and<B> : std::integral_constant<bool, B> {};

      template <bool H, bool ... T> struct meta_bool_or : std::integral_constant<bool, H || meta_bool_or<T...>::value> {};
      template <bool B> struct meta_bool_or<B> : std::integral_constant<bool, B> {};

      // workaround needed due to bug in MSVC 2013, see
      // http://connect.microsoft.com/VisualStudio/feedback/details/800231/c-11-alias-template-issue
      template <bool ... Conditions>
      struct EnableIfHelper : std::enable_if<meta_bool_and<Conditions...>::value, sfinae> {};

      template <bool ... Conditions>
      struct DisableIfHelper : std::enable_if<!meta_bool_or<Conditions...>::value, sfinae> {};
    } // namespace detail

    //! Used as the default value for EnableIf and DisableIf template parameters
    /*! @relates EnableIf
        @relates DisableIf */
    static const detail::sfinae sfinae = {};

    // ######################################################################
    //! Provides a way to enable a function if conditions are met
    /*! This is intended to be used in a near identical fashion to std::enable_if
        while being significantly easier to read at the cost of not allowing for as
        complicated of a condition.

        This will compile (allow the function) if every condition evaluates to true.
        at compile time.  This should be used with SFINAE to ensure that at least
        one other candidate function works when one fails due to an EnableIf.

        This should be used as the las template parameter to a function as
        an unnamed parameter with a default value of cereal::traits::sfinae:

        @code{cpp}
        // using by making the last template argument variadic
        template <class T, EnableIf<std::is_same<T, bool>::value> = sfinae>
        void func(T t );
        @endcode

        Note that this performs a logical AND of all conditions, so you will need
        to construct more complicated requirements with this fact in mind.

        @relates DisableIf
        @relates sfinae
        @tparam Conditions The conditions which will be logically ANDed to enable the function. */
    template <bool ... Conditions>
    using EnableIf = typename detail::EnableIfHelper<Conditions...>::type;

    // ######################################################################
    //! Provides a way to disable a function if conditions are met
    /*! This is intended to be used in a near identical fashion to std::enable_if
        while being significantly easier to read at the cost of not allowing for as
        complicated of a condition.

        This will compile (allow the function) if every condition evaluates to false.
        This should be used with SFINAE to ensure that at least one other candidate
        function works when one fails due to a DisableIf.

        This should be used as the las template parameter to a function as
        an unnamed parameter with a default value of cereal::traits::sfinae:

        @code{cpp}
        // using by making the last template argument variadic
        template <class T, DisableIf<std::is_same<T, bool>::value> = sfinae>
        void func(T t );
        @endcode

        This is often used in conjunction with EnableIf to form an enable/disable pair of
        overloads.

        Note that this performs a logical AND of all conditions, so you will need
        to construct more complicated requirements with this fact in mind.  If all conditions
        hold, the function will be disabled.

        @relates EnableIf
        @relates sfinae
        @tparam Conditions The conditions which will be logically ANDed to disable the function. */
    template <bool ... Conditions>
    using DisableIf = typename detail::DisableIfHelper<Conditions...>::type;

    // ######################################################################
    namespace detail
    {
      template <class InputArchive>
      struct get_output_from_input : no
      {
        static_assert( detail::delay_static_assert<InputArchive>::value,
            "Could not find an associated output archive for input archive." );
      };

      template <class OutputArchive>
      struct get_input_from_output : no
      {
        static_assert( detail::delay_static_assert<OutputArchive>::value,
            "Could not find an associated input archive for output archive." );
      };
    }

    //! Sets up traits that relate an input archive to an output archive
    #define CEREAL_SETUP_ARCHIVE_TRAITS(InputArchive, OutputArchive)  \
    namespace cereal { namespace traits { namespace detail {          \
      template <> struct get_output_from_input<InputArchive>          \
      { using type = OutputArchive; };                                \
      template <> struct get_input_from_output<OutputArchive>         \
      { using type = InputArchive; }; } } } /* end namespaces */

    // ######################################################################
    //! Used to convert a MAKE_HAS_XXX macro into a versioned variant
    #define CEREAL_MAKE_VERSIONED_TEST ,0

    // ######################################################################
    //! Creates a test for whether a non const member function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param name The name of the function to test for (e.g. serialize, load, save)
        @param test_name The name to give the test for the function being tested for (e.g. serialize, versioned_serialize)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #ifdef CEREAL_OLDER_GCC
    #define CEREAL_MAKE_HAS_MEMBER_TEST(name, test_name, versioned)                                                                         \
    template <class T, class A, class SFINAE = void>                                                                                        \
    struct has_member_##test_name : no {};                                                                                                  \
    template <class T, class A>                                                                                                             \
    struct has_member_##test_name<T, A,                                                                                                     \
      typename detail::Void< decltype( cereal::access::member_##name( std::declval<A&>(), std::declval<T&>() versioned ) ) >::type> : yes {}
    #else // NOT CEREAL_OLDER_GCC
    #define CEREAL_MAKE_HAS_MEMBER_TEST(name, test_name, versioned)                                                                     \
    namespace detail                                                                                                                    \
    {                                                                                                                                   \
      template <class T, class A>                                                                                                       \
      struct has_member_##name##_##versioned##_impl                                                                                     \
      {                                                                                                                                 \
        template <class TT, class AA>                                                                                                   \
        static auto test(int) -> decltype( cereal::access::member_##name( std::declval<AA&>(), std::declval<TT&>() versioned ), yes()); \
        template <class, class>                                                                                                         \
        static no test(...);                                                                                                            \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;                                                    \
      };                                                                                                                                \
    } /* end namespace detail */                                                                                                        \
    template <class T, class A>                                                                                                         \
    struct has_member_##test_name : std::integral_constant<bool, detail::has_member_##name##_##versioned##_impl<T, A>::value> {}
    #endif // NOT CEREAL_OLDER_GCC

    // ######################################################################
    //! Creates a test for whether a non const non-member function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper non-member function for the given archive. */
    #define CEREAL_MAKE_HAS_NON_MEMBER_TEST(test_name, func, versioned)                                                         \
    namespace detail                                                                                                            \
    {                                                                                                                           \
      template <class T, class A>                                                                                               \
      struct has_non_member_##test_name##_impl                                                                                  \
      {                                                                                                                         \
        template <class TT, class AA>                                                                                           \
        static auto test(int) -> decltype( func( std::declval<AA&>(), std::declval<TT&>() versioned ), yes());                  \
        template <class, class>                                                                                                 \
        static no test( ... );                                                                                                  \
        static const bool value = std::is_same<decltype( test<T, A>( 0 ) ), yes>::value;                                        \
      };                                                                                                                        \
    } /* end namespace detail */                                                                                                \
    template <class T, class A>                                                                                                 \
    struct has_non_member_##test_name : std::integral_constant<bool, detail::has_non_member_##test_name##_impl<T, A>::value> {}

    // ######################################################################
    // Member Serialize
    CEREAL_MAKE_HAS_MEMBER_TEST(serialize, serialize,);

    // ######################################################################
    // Member Serialize (versioned)
    CEREAL_MAKE_HAS_MEMBER_TEST(serialize, versioned_serialize, CEREAL_MAKE_VERSIONED_TEST);

    // ######################################################################
    // Non Member Serialize
    CEREAL_MAKE_HAS_NON_MEMBER_TEST(serialize, CEREAL_SERIALIZE_FUNCTION_NAME,);

    // ######################################################################
    // Non Member Serialize (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_TEST(versioned_serialize, CEREAL_SERIALIZE_FUNCTION_NAME, CEREAL_MAKE_VERSIONED_TEST);

    // ######################################################################
    // Member Load
    CEREAL_MAKE_HAS_MEMBER_TEST(load, load,);

    // ######################################################################
    // Member Load (versioned)
    CEREAL_MAKE_HAS_MEMBER_TEST(load, versioned_load, CEREAL_MAKE_VERSIONED_TEST);

    // ######################################################################
    // Non Member Load
    CEREAL_MAKE_HAS_NON_MEMBER_TEST(load, CEREAL_LOAD_FUNCTION_NAME,);

    // ######################################################################
    // Non Member Load (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_TEST(versioned_load, CEREAL_LOAD_FUNCTION_NAME, CEREAL_MAKE_VERSIONED_TEST);

    // ######################################################################
    #undef CEREAL_MAKE_HAS_NON_MEMBER_TEST
    #undef CEREAL_MAKE_HAS_MEMBER_TEST

    // ######################################################################
    //! Creates a test for whether a member save function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param test_name The name to give the test (e.g. save or versioned_save)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #ifdef CEREAL_OLDER_GCC
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_IMPL(test_name, versioned)                                                                  \
    namespace detail                                                                                                                \
    {                                                                                                                               \
    template <class T, class A>                                                                                                     \
    struct has_member_##test_name##_impl                                                                                            \
      {                                                                                                                             \
        template <class TT, class AA, class SFINAE = void> struct test : no {};                                                     \
        template <class TT, class AA>                                                                                               \
        struct test<TT, AA,                                                                                                         \
          typename detail::Void< decltype( cereal::access::member_save( std::declval<AA&>(),                                        \
                                                                        std::declval<TT const &>() versioned ) ) >::type> : yes {}; \
        static const bool value = test<T, A>();                                                                                     \
                                                                                                                                    \
        template <class TT, class AA, class SFINAE = void> struct test2 : no {};                                                    \
        template <class TT, class AA>                                                                                               \
        struct test2<TT, AA,                                                                                                        \
          typename detail::Void< decltype( cereal::access::member_save_non_const(                                                   \
                                            std::declval<AA&>(),                                                                    \
                                            std::declval<typename std::remove_const<TT>::type&>() versioned ) ) >::type> : yes {};  \
        static const bool not_const_type = test2<T, A>();                                                                           \
      };                                                                                                                            \
    } /* end namespace detail */
    #else /* NOT CEREAL_OLDER_GCC =================================== */
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_IMPL(test_name, versioned)                                                                  \
    namespace detail                                                                                                                \
    {                                                                                                                               \
    template <class T, class A>                                                                                                     \
    struct has_member_##test_name##_impl                                                                                            \
      {                                                                                                                             \
        template <class TT, class AA>                                                                                               \
        static auto test(int) -> decltype( cereal::access::member_save( std::declval<AA&>(),                                        \
                                                                        std::declval<TT const &>() versioned ), yes());             \
        template <class, class> static no test(...);                                                                                \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;                                                \
                                                                                                                                    \
        template <class TT, class AA>                                                                                               \
        static auto test2(int) -> decltype( cereal::access::member_save_non_const(                                                  \
                                              std::declval<AA &>(),                                                                 \
                                              std::declval<typename std::remove_const<TT>::type&>() versioned ), yes());            \
        template <class, class> static no test2(...);                                                                               \
        static const bool not_const_type = std::is_same<decltype(test2<T, A>(0)), yes>::value;                                      \
      };                                                                                                                            \
    } /* end namespace detail */
    #endif /* NOT CEREAL_OLDER_GCC */

    // ######################################################################
    // Member Save
    CEREAL_MAKE_HAS_MEMBER_SAVE_IMPL(save, )

    template <class T, class A>
    struct has_member_save : std::integral_constant<bool, detail::has_member_save_impl<T, A>::value>
    {
      typedef typename detail::has_member_save_impl<T, A> check;
      static_assert( check::value || !check::not_const_type,
        "cereal detected a non-const save. \n "
        "save member functions must always be const" );
    };

    // ######################################################################
    // Member Save (versioned)
    CEREAL_MAKE_HAS_MEMBER_SAVE_IMPL(versioned_save, CEREAL_MAKE_VERSIONED_TEST)

    template <class T, class A>
    struct has_member_versioned_save : std::integral_constant<bool, detail::has_member_versioned_save_impl<T, A>::value>
    {
      typedef typename detail::has_member_versioned_save_impl<T, A> check;
      static_assert( check::value || !check::not_const_type,
        "cereal detected a versioned non-const save. \n "
        "save member functions must always be const" );
    };

    // ######################################################################
    #undef CEREAL_MAKE_HAS_MEMBER_SAVE_IMPL

    // ######################################################################
    //! Creates a test for whether a non-member save function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper non-member function for the given archive.

        @param test_name The name to give the test (e.g. save or versioned_save)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #define CEREAL_MAKE_HAS_NON_MEMBER_SAVE_TEST(test_name, versioned)                                                       \
    namespace detail                                                                                                         \
    {                                                                                                                        \
      template <class T, class A>                                                                                            \
      struct has_non_member_##test_name##_impl                                                                               \
      {                                                                                                                      \
        template <class TT, class AA>                                                                                        \
        static auto test(int) -> decltype( CEREAL_SAVE_FUNCTION_NAME(                                                        \
                                              std::declval<AA&>(),                                                           \
                                              std::declval<TT const &>() versioned ), yes());                                \
        template <class, class> static no test(...);                                                                         \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;                                         \
                                                                                                                             \
        template <class TT, class AA>                                                                                        \
        static auto test2(int) -> decltype( CEREAL_SAVE_FUNCTION_NAME(                                                       \
                                              std::declval<AA &>(),                                                          \
                                              std::declval<typename std::remove_const<TT>::type&>() versioned ), yes());     \
        template <class, class> static no test2(...);                                                                        \
        static const bool not_const_type = std::is_same<decltype(test2<T, A>(0)), yes>::value;                               \
      };                                                                                                                     \
    } /* end namespace detail */                                                                                             \
                                                                                                                             \
    template <class T, class A>                                                                                              \
    struct has_non_member_##test_name : std::integral_constant<bool, detail::has_non_member_##test_name##_impl<T, A>::value> \
    {                                                                                                                        \
      using check = typename detail::has_non_member_##test_name##_impl<T, A>;                                                \
      static_assert( check::value || !check::not_const_type,                                                                 \
        "cereal detected a non-const type parameter in non-member " #test_name ". \n "                                       \
        #test_name " non-member functions must always pass their types as const" );                                          \
    };

    // ######################################################################
    // Non Member Save
    CEREAL_MAKE_HAS_NON_MEMBER_SAVE_TEST(save, )

    // ######################################################################
    // Non Member Save (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_SAVE_TEST(versioned_save, CEREAL_MAKE_VERSIONED_TEST)

    // ######################################################################
    #undef CEREAL_MAKE_HAS_NON_MEMBER_SAVE_TEST

    // ######################################################################
    // Minimal Utilities
    namespace detail
    {
      // Determines if the provided type is an std::string
      template <class> struct is_string : std::false_type {};

      template <class CharT, class Traits, class Alloc>
      struct is_string<std::basic_string<CharT, Traits, Alloc>> : std::true_type {};
    }

    // Determines if the type is valid for use with a minimal serialize function
    template <class T>
    struct is_minimal_type : std::integral_constant<bool,
      detail::is_string<T>::value || std::is_arithmetic<T>::value> {};

    // ######################################################################
    //! Creates implementation details for whether a member save_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param test_name The name to give the test (e.g. save_minimal or versioned_save_minimal)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #ifdef CEREAL_OLDER_GCC
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_IMPL(test_name, versioned)                                                                        \
    namespace detail                                                                                                                              \
    {                                                                                                                                             \
      template <class T, class A>                                                                                                                 \
      struct has_member_##test_name##_impl                                                                                                        \
      {                                                                                                                                           \
        template <class TT, class AA, class SFINAE = void> struct test : no {};                                                                   \
        template <class TT, class AA>                                                                                                             \
        struct test<TT, AA, typename detail::Void< decltype(                                                                                      \
            cereal::access::member_save_minimal( std::declval<AA const &>(),                                                                      \
                                                 std::declval<TT const &>() versioned ) ) >::type> : yes {};                                      \
                                                                                                                                                  \
        static const bool value = test<T, A>();                                                                                                   \
                                                                                                                                                  \
        template <class TT, class AA, class SFINAE = void> struct test2 : no {};                                                                  \
        template <class TT, class AA>                                                                                                             \
        struct test2<TT, AA, typename detail::Void< decltype(                                                                                     \
            cereal::access::member_save_minimal_non_const( std::declval<AA const &>(),                                                            \
                                                           std::declval<typename std::remove_const<TT>::type&>() versioned ) ) >::type> : yes {}; \
        static const bool not_const_type = test2<T, A>();                                                                                         \
                                                                                                                                                  \
        static const bool valid = value || !not_const_type;                                                                                       \
      };                                                                                                                                          \
    } /* end namespace detail */
    #else /* NOT CEREAL_OLDER_GCC =================================== */
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_IMPL(test_name, versioned)                     \
    namespace detail                                                                           \
    {                                                                                          \
      template <class T, class A>                                                              \
      struct has_member_##test_name##_impl                                                     \
      {                                                                                        \
        template <class TT, class AA>                                                          \
        static auto test(int) -> decltype( cereal::access::member_save_minimal(                \
              std::declval<AA const &>(),                                                      \
              std::declval<TT const &>() versioned ), yes());                                  \
        template <class, class> static no test(...);                                           \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;           \
                                                                                               \
        template <class TT, class AA>                                                          \
        static auto test2(int) -> decltype( cereal::access::member_save_minimal_non_const(     \
              std::declval<AA const &>(),                                                      \
              std::declval<typename std::remove_const<TT>::type&>() versioned ), yes());       \
        template <class, class> static no test2(...);                                          \
        static const bool not_const_type = std::is_same<decltype(test2<T, A>(0)), yes>::value; \
                                                                                               \
        static const bool valid = value || !not_const_type;                                    \
      };                                                                                       \
    } /* end namespace detail */
    #endif // NOT CEREAL_OLDER_GCC

    // ######################################################################
    //! Creates helpers for minimal save functions
    /*! The get_member_*_type structs allow access to the return type of a save_minimal,
        assuming that the function actually exists.  If the function does not
        exist, the type will be void.

        @param test_name The name to give the test (e.g. save_minimal or versioned_save_minimal)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_HELPERS_IMPL(test_name, versioned)                           \
    namespace detail                                                                                         \
    {                                                                                                        \
      template <class T, class A, bool Valid>                                                                \
      struct get_member_##test_name##_type { using type = void; };                                           \
                                                                                                             \
      template <class T, class A>                                                                            \
      struct get_member_##test_name##_type<T, A, true>                                                       \
      {                                                                                                      \
        using type = decltype( cereal::access::member_save_minimal( std::declval<A const &>(),               \
                                                                    std::declval<T const &>() versioned ) ); \
      };                                                                                                     \
    } /* end namespace detail */

    // ######################################################################
    //! Creates a test for whether a member save_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param test_name The name to give the test (e.g. save_minimal or versioned_save_minimal) */
    #define CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_TEST(test_name)                                                      \
    template <class T, class A>                                                                                      \
    struct has_member_##test_name : std::integral_constant<bool, detail::has_member_##test_name##_impl<T, A>::value> \
    {                                                                                                                \
      using check = typename detail::has_member_##test_name##_impl<T, A>;                                            \
      static_assert( check::valid,                                                                                   \
        "cereal detected a non-const member " #test_name ". \n "                                                     \
        #test_name " member functions must always be const" );                                                       \
                                                                                                                     \
      using type = typename detail::get_member_##test_name##_type<T, A, check::value>::type;                         \
      static_assert( (check::value && is_minimal_type<type>::value) || !check::value,                                \
        "cereal detected a member " #test_name " with an invalid return type. \n "                                   \
        "return type must be arithmetic or string" );                                                                \
    };

    // ######################################################################
    // Member Save Minimal
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_IMPL(save_minimal, )
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_HELPERS_IMPL(save_minimal, )
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_TEST(save_minimal)

    // ######################################################################
    // Member Save Minimal (versioned)
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_IMPL(versioned_save_minimal, CEREAL_MAKE_VERSIONED_TEST)
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_HELPERS_IMPL(versioned_save_minimal, CEREAL_MAKE_VERSIONED_TEST)
    CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_TEST(versioned_save_minimal)

    // ######################################################################
    #undef CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_IMPL
    #undef CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_HELPERS_IMPL
    #undef CEREAL_MAKE_HAS_MEMBER_SAVE_MINIMAL_TEST

    // ######################################################################
    //! Creates a test for whether a non-member save_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param test_name The name to give the test (e.g. save_minimal or versioned_save_minimal)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #define CEREAL_MAKE_HAS_NON_MEMBER_SAVE_MINIMAL_TEST(test_name, versioned)                                               \
    namespace detail                                                                                                         \
    {                                                                                                                        \
      template <class T, class A>                                                                                            \
      struct has_non_member_##test_name##_impl                                                                               \
      {                                                                                                                      \
        template <class TT, class AA>                                                                                        \
        static auto test(int) -> decltype( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(                                                \
              std::declval<AA const &>(),                                                                                    \
              std::declval<TT const &>() versioned ), yes());                                                                \
        template <class, class> static no test(...);                                                                         \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;                                         \
                                                                                                                             \
        template <class TT, class AA>                                                                                        \
        static auto test2(int) -> decltype( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(                                               \
              std::declval<AA const &>(),                                                                                    \
              std::declval<typename std::remove_const<TT>::type&>() versioned ), yes());                                     \
        template <class, class> static no test2(...);                                                                        \
        static const bool not_const_type = std::is_same<decltype(test2<T, A>(0)), yes>::value;                               \
                                                                                                                             \
        static const bool valid = value || !not_const_type;                                                                  \
      };                                                                                                                     \
                                                                                                                             \
      template <class T, class A, bool Valid>                                                                                \
      struct get_non_member_##test_name##_type { using type = void; };                                                       \
                                                                                                                             \
      template <class T, class A>                                                                                            \
      struct get_non_member_##test_name##_type <T, A, true>                                                                  \
      {                                                                                                                      \
        using type = decltype( CEREAL_SAVE_MINIMAL_FUNCTION_NAME( std::declval<A const &>(),                                 \
                                                                  std::declval<T const &>() versioned ) );                   \
      };                                                                                                                     \
    } /* end namespace detail */                                                                                             \
                                                                                                                             \
    template <class T, class A>                                                                                              \
    struct has_non_member_##test_name : std::integral_constant<bool, detail::has_non_member_##test_name##_impl<T, A>::value> \
    {                                                                                                                        \
      using check = typename detail::has_non_member_##test_name##_impl<T, A>;                                                \
      static_assert( check::valid,                                                                                           \
        "cereal detected a non-const type parameter in non-member " #test_name ". \n "                                       \
        #test_name " non-member functions must always pass their types as const" );                                          \
                                                                                                                             \
      using type = typename detail::get_non_member_##test_name##_type<T, A, check::value>::type;                             \
      static_assert( (check::value && is_minimal_type<type>::value) || !check::value,                                        \
        "cereal detected a non-member " #test_name " with an invalid return type. \n "                                       \
        "return type must be arithmetic or string" );                                                                        \
    };

    // ######################################################################
    // Non-Member Save Minimal
    CEREAL_MAKE_HAS_NON_MEMBER_SAVE_MINIMAL_TEST(save_minimal, )

    // ######################################################################
    // Non-Member Save Minimal (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_SAVE_MINIMAL_TEST(versioned_save_minimal, CEREAL_MAKE_VERSIONED_TEST)

    // ######################################################################
    #undef CEREAL_MAKE_HAS_NON_MEMBER_SAVE_MINIMAL_TEST

    // ######################################################################
    // Load Minimal Utilities
    namespace detail
    {
      //! Used to help strip away conversion wrappers
      /*! If someone writes a non-member load/save minimal function that accepts its
          parameter as some generic template type and needs to perform trait checks
          on that type, our NoConvert wrappers will interfere with this.  Using
          the struct strip_minmal, users can strip away our wrappers to get to
          the underlying type, allowing traits to work properly */
      struct NoConvertBase {};

      //! A struct that prevents implicit conversion
      /*! Any type instantiated with this struct will be unable to implicitly convert
          to another type.  Is designed to only allow conversion to Source const &.

          @tparam Source the type of the original source */
      template <class Source>
      struct NoConvertConstRef : NoConvertBase
      {
        using type = Source; //!< Used to get underlying type easily

        template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
        operator Dest () = delete;

        //! only allow conversion if the types are the same and we are converting into a const reference
        template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
        operator Dest const & ();
      };

      //! A struct that prevents implicit conversion
      /*! Any type instantiated with this struct will be unable to implicitly convert
          to another type.  Is designed to only allow conversion to Source &.

          @tparam Source the type of the original source */
      template <class Source>
      struct NoConvertRef : NoConvertBase
      {
        using type = Source; //!< Used to get underlying type easily

        template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
        operator Dest () = delete;

        #ifdef __clang__
        template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
        operator Dest const & () = delete;
        #endif // __clang__

        //! only allow conversion if the types are the same and we are converting into a const reference
        template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
        operator Dest & ();
      };

      //! A type that can implicitly convert to anything else
      struct AnyConvert
      {
        template <class Dest>
        operator Dest & ();

        template <class Dest>
        operator Dest const & () const;
      };
    } // namespace detail

    // ######################################################################
    //! Creates a test for whether a member load_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        Our strategy here is to first check if a function matching the signature more or less exists
        (allow anything like load_minimal(xxx) using AnyConvert, and then secondly enforce
        that it has the correct signature using NoConvertConstRef

        @param test_name The name to give the test (e.g. load_minimal or versioned_load_minimal)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #ifdef CEREAL_OLDER_GCC
    #define CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_IMPL(test_name, versioned)                                                    \
    namespace detail                                                                                                          \
    {                                                                                                                         \
      template <class T, class A, class SFINAE = void> struct has_member_##test_name##_impl : no {};                          \
      template <class T, class A>                                                                                             \
      struct has_member_##test_name##_impl<T, A, typename detail::Void< decltype(                                             \
          cereal::access::member_load_minimal( std::declval<A const &>(),                                                     \
                                               std::declval<T &>(), AnyConvert() versioned ) ) >::type> : yes {};             \
                                                                                                                              \
        template <class T, class A, class U, class SFINAE = void> struct has_member_##test_name##_type_impl : no {};          \
        template <class T, class A, class U>                                                                                  \
        struct has_member_##test_name##_type_impl<T, A, U, typename detail::Void< decltype(                                   \
            cereal::access::member_load_minimal( std::declval<A const &>(),                                                   \
                                                 std::declval<T &>(), NoConvertConstRef<U>() versioned ) ) >::type> : yes {}; \
    } /* end namespace detail */
    #else /* NOT CEREAL_OLDER_GCC =================================== */
    #define CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_IMPL(test_name, versioned)              \
    namespace detail                                                                    \
    {                                                                                   \
      template <class T, class A>                                                       \
      struct has_member_##test_name##_impl                                              \
      {                                                                                 \
        template <class TT, class AA>                                                   \
        static auto test(int) -> decltype( cereal::access::member_load_minimal(         \
              std::declval<AA const &>(),                                               \
              std::declval<TT &>(), AnyConvert() versioned ), yes());                   \
        template <class, class> static no test(...);                                    \
        static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;    \
      };                                                                                \
      template <class T, class A, class U>                                              \
      struct has_member_##test_name##_type_impl                                         \
      {                                                                                 \
        template <class TT, class AA, class UU>                                         \
        static auto test(int) -> decltype( cereal::access::member_load_minimal(         \
              std::declval<AA const &>(),                                               \
              std::declval<TT &>(), NoConvertConstRef<UU>() versioned ), yes());        \
        template <class, class, class> static no test(...);                             \
        static const bool value = std::is_same<decltype(test<T, A, U>(0)), yes>::value; \
                                                                                        \
      };                                                                                \
    } /* end namespace detail */
    #endif // NOT CEREAL_OLDER_GCC

    // ######################################################################
    //! Creates helpers for minimal load functions
    /*! The has_member_*_wrapper structs ensure that the load and save types for the
        requested function type match appropriately.

        @param load_test_name The name to give the test (e.g. load_minimal or versioned_load_minimal)
        @param save_test_name The name to give the test (e.g. save_minimal or versioned_save_minimal,
                              should match the load name.
        @param save_test_prefix The name to give the test (e.g. save_minimal or versioned_save_minimal,
                              should match the load name, without the trailing "_minimal" (e.g.
                              save or versioned_save).  Needed because the preprocessor is an abomination.
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #define CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_HELPERS_IMPL(load_test_name, save_test_name, save_test_prefix, versioned) \
    namespace detail                                                                                                      \
    {                                                                                                                     \
      template <class T, class A, bool Valid>                                                                             \
      struct has_member_##load_test_name##_wrapper : std::false_type {};                                                  \
                                                                                                                          \
      template <class T, class A>                                                                                         \
      struct has_member_##load_test_name##_wrapper<T, A, true>                                                            \
      {                                                                                                                   \
        using AOut = typename detail::get_output_from_input<A>::type;                                                     \
                                                                                                                          \
        static_assert( has_member_##save_test_prefix##_minimal<T, AOut>::value,                                           \
          "cereal detected member " #load_test_name " but no valid member " #save_test_name ". \n "                       \
          "cannot evaluate correctness of " #load_test_name " without valid " #save_test_name "." );                      \
                                                                                                                          \
        using SaveType = typename detail::get_member_##save_test_prefix##_minimal_type<T, AOut, true>::type;              \
        const static bool value = has_member_##load_test_name##_impl<T, A>::value;                                        \
        const static bool valid = has_member_##load_test_name##_type_impl<T, A, SaveType>::value;                         \
                                                                                                                          \
        static_assert( valid || !value, "cereal detected different or invalid types in corresponding member "             \
            #load_test_name " and " #save_test_name " functions. \n "                                                     \
            "the paramater to " #load_test_name " must be a constant reference to the type that "                         \
            #save_test_name " returns." );                                                                                \
      };                                                                                                                  \
    } /* end namespace detail */

    // ######################################################################
    //! Creates a test for whether a member load_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        @param load_test_name The name to give the test (e.g. load_minimal or versioned_load_minimal)
        @param load_test_prefix The above parameter minus the trailing "_minimal" */
    #define CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_TEST(load_test_name, load_test_prefix)                                         \
    template <class T, class A>                                                                                                \
    struct has_member_##load_test_prefix##_minimal : std::integral_constant<bool,                                              \
      detail::has_member_##load_test_name##_wrapper<T, A, detail::has_member_##load_test_name##_impl<T, A>::value>::value> {};

    // ######################################################################
    // Member Load Minimal
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_IMPL(load_minimal, )
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_HELPERS_IMPL(load_minimal, save_minimal, save, )
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_TEST(load_minimal, load)

    // ######################################################################
    // Member Load Minimal (versioned)
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_IMPL(versioned_load_minimal, CEREAL_MAKE_VERSIONED_TEST)
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_HELPERS_IMPL(versioned_load_minimal, versioned_save_minimal, versioned_save, CEREAL_MAKE_VERSIONED_TEST)
    CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_TEST(versioned_load_minimal, versioned_load)

    // ######################################################################
    #undef CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_IMPL
    #undef CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_HELPERS_IMPL
    #undef CEREAL_MAKE_HAS_MEMBER_LOAD_MINIMAL_TEST

    // ######################################################################
    // Non-Member Load Minimal
    namespace detail
    {
      #ifdef CEREAL_OLDER_GCC
      void CEREAL_LOAD_MINIMAL_FUNCTION_NAME(); // prevents nonsense complaining about not finding this
      void CEREAL_SAVE_MINIMAL_FUNCTION_NAME();
      #endif // CEREAL_OLDER_GCC
    } // namespace detail

    // ######################################################################
    //! Creates a test for whether a non-member load_minimal function exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper member function for the given archive.

        See notes from member load_minimal implementation.

        Note that there should be an additional const check on load_minimal after the valid check,
        but this currently interferes with many valid uses of minimal serialization.  It has been
        removed (see #565 on github) and previously was:

        @code
        static_assert( check::const_valid || !check::exists,
            "cereal detected an invalid serialization type parameter in non-member " #test_name ".  "
            #test_name " non-member functions must accept their serialization type by non-const reference" );
        @endcode

        See #132, #436, #263, and #565 on https://github.com/USCiLab/cereal for more details.

        @param test_name The name to give the test (e.g. load_minimal or versioned_load_minimal)
        @param save_name The corresponding name the save test would have (e.g. save_minimal or versioned_save_minimal)
        @param versioned Either blank or the macro CEREAL_MAKE_VERSIONED_TEST */
    #define CEREAL_MAKE_HAS_NON_MEMBER_LOAD_MINIMAL_TEST(test_name, save_name, versioned)                                    \
    namespace detail                                                                                                         \
    {                                                                                                                        \
      template <class T, class A, class U = void>                                                                            \
      struct has_non_member_##test_name##_impl                                                                               \
      {                                                                                                                      \
        template <class TT, class AA>                                                                                        \
        static auto test(int) -> decltype( CEREAL_LOAD_MINIMAL_FUNCTION_NAME(                                                \
              std::declval<AA const &>(), std::declval<TT&>(), AnyConvert() versioned ), yes() );                            \
        template <class, class> static no test( ... );                                                                       \
        static const bool exists = std::is_same<decltype( test<T, A>( 0 ) ), yes>::value;                                    \
                                                                                                                             \
        template <class TT, class AA, class UU>                                                                              \
        static auto test2(int) -> decltype( CEREAL_LOAD_MINIMAL_FUNCTION_NAME(                                               \
              std::declval<AA const &>(), std::declval<TT&>(), NoConvertConstRef<UU>() versioned ), yes() );                 \
        template <class, class, class> static no test2( ... );                                                               \
        static const bool valid = std::is_same<decltype( test2<T, A, U>( 0 ) ), yes>::value;                                 \
                                                                                                                             \
        template <class TT, class AA>                                                                                        \
        static auto test3(int) -> decltype( CEREAL_LOAD_MINIMAL_FUNCTION_NAME(                                               \
              std::declval<AA const &>(), NoConvertRef<TT>(), AnyConvert() versioned ), yes() );                             \
        template <class, class> static no test3( ... );                                                                      \
        static const bool const_valid = std::is_same<decltype( test3<T, A>( 0 ) ), yes>::value;                              \
      };                                                                                                                     \
                                                                                                                             \
      template <class T, class A, bool Valid>                                                                                \
      struct has_non_member_##test_name##_wrapper : std::false_type {};                                                      \
                                                                                                                             \
      template <class T, class A>                                                                                            \
      struct has_non_member_##test_name##_wrapper<T, A, true>                                                                \
      {                                                                                                                      \
        using AOut = typename detail::get_output_from_input<A>::type;                                                        \
                                                                                                                             \
        static_assert( detail::has_non_member_##save_name##_impl<T, AOut>::valid,                                            \
          "cereal detected non-member " #test_name " but no valid non-member " #save_name ". \n "                            \
          "cannot evaluate correctness of " #test_name " without valid " #save_name "." );                                   \
                                                                                                                             \
        using SaveType = typename detail::get_non_member_##save_name##_type<T, AOut, true>::type;                            \
        using check = has_non_member_##test_name##_impl<T, A, SaveType>;                                                     \
        static const bool value = check::exists;                                                                             \
                                                                                                                             \
        static_assert( check::valid || !check::exists, "cereal detected different types in corresponding non-member "        \
            #test_name " and " #save_name " functions. \n "                                                                  \
            "the paramater to " #test_name " must be a constant reference to the type that " #save_name " returns." );       \
      };                                                                                                                     \
    } /* namespace detail */                                                                                                 \
                                                                                                                             \
    template <class T, class A>                                                                                              \
    struct has_non_member_##test_name : std::integral_constant<bool,                                                         \
      detail::has_non_member_##test_name##_wrapper<T, A, detail::has_non_member_##test_name##_impl<T, A>::exists>::value> {};

    // ######################################################################
    // Non-Member Load Minimal
    CEREAL_MAKE_HAS_NON_MEMBER_LOAD_MINIMAL_TEST(load_minimal, save_minimal, )

    // ######################################################################
    // Non-Member Load Minimal (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_LOAD_MINIMAL_TEST(versioned_load_minimal, versioned_save_minimal, CEREAL_MAKE_VERSIONED_TEST)

    // ######################################################################
    #undef CEREAL_MAKE_HAS_NON_MEMBER_LOAD_MINIMAL_TEST

    // ######################################################################
    namespace detail
    {
      // const stripped away before reaching here, prevents errors on conversion from
      // construct<const T> to construct<T>
      template<typename T, typename A>
      struct has_member_load_and_construct_impl : std::integral_constant<bool,
        std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>() ) ), void>::value>
      { };

      template<typename T, typename A>
      struct has_member_versioned_load_and_construct_impl : std::integral_constant<bool,
        std::is_same<decltype( access::load_and_construct<T>( std::declval<A&>(), std::declval< ::cereal::construct<T>&>(), 0 ) ), void>::value>
      { };
    } // namespace detail

    //! Member load and construct check
    template<typename T, typename A>
    struct has_member_load_and_construct : detail::has_member_load_and_construct_impl<typename std::remove_const<T>::type, A>
    { };

    //! Member load and construct check (versioned)
    template<typename T, typename A>
    struct has_member_versioned_load_and_construct : detail::has_member_versioned_load_and_construct_impl<typename std::remove_const<T>::type, A>
    { };

    // ######################################################################
    //! Creates a test for whether a non-member load_and_construct specialization exists
    /*! This creates a class derived from std::integral_constant that will be true if
        the type has the proper non-member function for the given archive. */
    #define CEREAL_MAKE_HAS_NON_MEMBER_LOAD_AND_CONSTRUCT_TEST(test_name, versioned)                                            \
    namespace detail                                                                                                            \
    {                                                                                                                           \
      template <class T, class A>                                                                                               \
      struct has_non_member_##test_name##_impl                                                                                  \
      {                                                                                                                         \
        template <class TT, class AA>                                                                                           \
        static auto test(int) -> decltype( LoadAndConstruct<TT>::load_and_construct(                                            \
                                           std::declval<AA&>(), std::declval< ::cereal::construct<TT>&>() versioned ), yes());  \
        template <class, class>                                                                                                 \
        static no test( ... );                                                                                                  \
        static const bool value = std::is_same<decltype( test<T, A>( 0 ) ), yes>::value;                                        \
      };                                                                                                                        \
    } /* end namespace detail */                                                                                                \
    template <class T, class A>                                                                                                 \
    struct has_non_member_##test_name :                                                                                         \
      std::integral_constant<bool, detail::has_non_member_##test_name##_impl<typename std::remove_const<T>::type, A>::value> {};

    // ######################################################################
    //! Non member load and construct check
    CEREAL_MAKE_HAS_NON_MEMBER_LOAD_AND_CONSTRUCT_TEST(load_and_construct, )

    // ######################################################################
    //! Non member load and construct check (versioned)
    CEREAL_MAKE_HAS_NON_MEMBER_LOAD_AND_CONSTRUCT_TEST(versioned_load_and_construct, CEREAL_MAKE_VERSIONED_TEST)

    // ######################################################################
    //! Has either a member or non member load and construct
    template<typename T, typename A>
    struct has_load_and_construct : std::integral_constant<bool,
      has_member_load_and_construct<T, A>::value || has_non_member_load_and_construct<T, A>::value ||
      has_member_versioned_load_and_construct<T, A>::value || has_non_member_versioned_load_and_construct<T, A>::value>
    { };

    // ######################################################################
    #undef CEREAL_MAKE_HAS_NON_MEMBER_LOAD_AND_CONSTRUCT_TEST

    // ######################################################################
    // End of serialization existence tests
    #undef CEREAL_MAKE_VERSIONED_TEST

    // ######################################################################
    template <class T, class InputArchive, class OutputArchive>
    struct has_member_split : std::integral_constant<bool,
      (has_member_load<T, InputArchive>::value && has_member_save<T, OutputArchive>::value) ||
      (has_member_versioned_load<T, InputArchive>::value && has_member_versioned_save<T, OutputArchive>::value)> {};

    // ######################################################################
    template <class T, class InputArchive, class OutputArchive>
    struct has_non_member_split : std::integral_constant<bool,
      (has_non_member_load<T, InputArchive>::value && has_non_member_save<T, OutputArchive>::value) ||
      (has_non_member_versioned_load<T, InputArchive>::value && has_non_member_versioned_save<T, OutputArchive>::value)> {};

    // ######################################################################
    template <class T, class OutputArchive>
    struct has_invalid_output_versioning : std::integral_constant<bool,
      (has_member_versioned_save<T, OutputArchive>::value && has_member_save<T, OutputArchive>::value) ||
      (has_non_member_versioned_save<T, OutputArchive>::value && has_non_member_save<T, OutputArchive>::value) ||
      (has_member_versioned_serialize<T, OutputArchive>::value && has_member_serialize<T, OutputArchive>::value) ||
      (has_non_member_versioned_serialize<T, OutputArchive>::value && has_non_member_serialize<T, OutputArchive>::value) ||
      (has_member_versioned_save_minimal<T, OutputArchive>::value && has_member_save_minimal<T, OutputArchive>::value) ||
      (has_non_member_versioned_save_minimal<T, OutputArchive>::value &&  has_non_member_save_minimal<T, OutputArchive>::value)> {};

    // ######################################################################
    template <class T, class InputArchive>
    struct has_invalid_input_versioning : std::integral_constant<bool,
      (has_member_versioned_load<T, InputArchive>::value && has_member_load<T, InputArchive>::value) ||
      (has_non_member_versioned_load<T, InputArchive>::value && has_non_member_load<T, InputArchive>::value) ||
      (has_member_versioned_serialize<T, InputArchive>::value && has_member_serialize<T, InputArchive>::value) ||
      (has_non_member_versioned_serialize<T, InputArchive>::value && has_non_member_serialize<T, InputArchive>::value) ||
      (has_member_versioned_load_minimal<T, InputArchive>::value && has_member_load_minimal<T, InputArchive>::value) ||
      (has_non_member_versioned_load_minimal<T, InputArchive>::value &&  has_non_member_load_minimal<T, InputArchive>::value)> {};

    // ######################################################################
    namespace detail
    {
      //! Create a test for a cereal::specialization entry
      #define CEREAL_MAKE_IS_SPECIALIZED_IMPL(name)                                          \
      template <class T, class A>                                                            \
      struct is_specialized_##name : std::integral_constant<bool,                            \
        !std::is_base_of<std::false_type, specialize<A, T, specialization::name>>::value> {}

      CEREAL_MAKE_IS_SPECIALIZED_IMPL(member_serialize);
      CEREAL_MAKE_IS_SPECIALIZED_IMPL(member_load_save);
      CEREAL_MAKE_IS_SPECIALIZED_IMPL(member_load_save_minimal);
      CEREAL_MAKE_IS_SPECIALIZED_IMPL(non_member_serialize);
      CEREAL_MAKE_IS_SPECIALIZED_IMPL(non_member_load_save);
      CEREAL_MAKE_IS_SPECIALIZED_IMPL(non_member_load_save_minimal);

      #undef CEREAL_MAKE_IS_SPECIALIZED_IMPL

      //! Number of specializations detected
      template <class T, class A>
      struct count_specializations : std::integral_constant<int,
        is_specialized_member_serialize<T, A>::value +
        is_specialized_member_load_save<T, A>::value +
        is_specialized_member_load_save_minimal<T, A>::value +
        is_specialized_non_member_serialize<T, A>::value +
        is_specialized_non_member_load_save<T, A>::value +
        is_specialized_non_member_load_save_minimal<T, A>::value> {};
    } // namespace detail

    //! Check if any specialization exists for a type
    template <class T, class A>
    struct is_specialized : std::integral_constant<bool,
      detail::is_specialized_member_serialize<T, A>::value ||
      detail::is_specialized_member_load_save<T, A>::value ||
      detail::is_specialized_member_load_save_minimal<T, A>::value ||
      detail::is_specialized_non_member_serialize<T, A>::value ||
      detail::is_specialized_non_member_load_save<T, A>::value ||
      detail::is_specialized_non_member_load_save_minimal<T, A>::value>
    {
      static_assert(detail::count_specializations<T, A>::value <= 1, "More than one explicit specialization detected for type.");
    };

    //! Create the static assertion for some specialization
    /*! This assertion will fail if the type is indeed specialized and does not have the appropriate
        type of serialization functions */
    #define CEREAL_MAKE_IS_SPECIALIZED_ASSERT(name, versioned_name, print_name, spec_name)                      \
    static_assert( (is_specialized<T, A>::value && detail::is_specialized_##spec_name<T, A>::value &&           \
                   (has_##name<T, A>::value || has_##versioned_name<T, A>::value))                              \
                   || !(is_specialized<T, A>::value && detail::is_specialized_##spec_name<T, A>::value),        \
                   "cereal detected " #print_name " specialization but no " #print_name " serialize function" )

    //! Generates a test for specialization for versioned and unversioned functions
    /*! This creates checks that can be queried to see if a given type of serialization function
        has been specialized for this type */
    #define CEREAL_MAKE_IS_SPECIALIZED(name, versioned_name, spec_name)                     \
    template <class T, class A>                                                             \
    struct is_specialized_##name : std::integral_constant<bool,                             \
      is_specialized<T, A>::value && detail::is_specialized_##spec_name<T, A>::value>       \
    { CEREAL_MAKE_IS_SPECIALIZED_ASSERT(name, versioned_name, name, spec_name); };          \
    template <class T, class A>                                                             \
    struct is_specialized_##versioned_name : std::integral_constant<bool,                   \
      is_specialized<T, A>::value && detail::is_specialized_##spec_name<T, A>::value>       \
    { CEREAL_MAKE_IS_SPECIALIZED_ASSERT(name, versioned_name, versioned_name, spec_name); }

    CEREAL_MAKE_IS_SPECIALIZED(member_serialize, member_versioned_serialize, member_serialize);
    CEREAL_MAKE_IS_SPECIALIZED(non_member_serialize, non_member_versioned_serialize, non_member_serialize);

    CEREAL_MAKE_IS_SPECIALIZED(member_save, member_versioned_save, member_load_save);
    CEREAL_MAKE_IS_SPECIALIZED(non_member_save, non_member_versioned_save, non_member_load_save);
    CEREAL_MAKE_IS_SPECIALIZED(member_load, member_versioned_load, member_load_save);
    CEREAL_MAKE_IS_SPECIALIZED(non_member_load, non_member_versioned_load, non_member_load_save);

    CEREAL_MAKE_IS_SPECIALIZED(member_save_minimal, member_versioned_save_minimal, member_load_save_minimal);
    CEREAL_MAKE_IS_SPECIALIZED(non_member_save_minimal, non_member_versioned_save_minimal, non_member_load_save_minimal);
    CEREAL_MAKE_IS_SPECIALIZED(member_load_minimal, member_versioned_load_minimal, member_load_save_minimal);
    CEREAL_MAKE_IS_SPECIALIZED(non_member_load_minimal, non_member_versioned_load_minimal, non_member_load_save_minimal);

    #undef CEREAL_MAKE_IS_SPECIALIZED_ASSERT
    #undef CEREAL_MAKE_IS_SPECIALIZED

    // ######################################################################
    // detects if a type has any active minimal output serialization
    template <class T, class OutputArchive>
    struct has_minimal_output_serialization : std::integral_constant<bool,
      is_specialized_member_save_minimal<T, OutputArchive>::value ||
      ((has_member_save_minimal<T, OutputArchive>::value ||
        has_non_member_save_minimal<T, OutputArchive>::value ||
        has_member_versioned_save_minimal<T, OutputArchive>::value ||
        has_non_member_versioned_save_minimal<T, OutputArchive>::value) &&
       !(is_specialized_member_serialize<T, OutputArchive>::value ||
         is_specialized_member_save<T, OutputArchive>::value))> {};

    // ######################################################################
    // detects if a type has any active minimal input serialization
    template <class T, class InputArchive>
    struct has_minimal_input_serialization : std::integral_constant<bool,
      is_specialized_member_load_minimal<T, InputArchive>::value ||
      ((has_member_load_minimal<T, InputArchive>::value ||
        has_non_member_load_minimal<T, InputArchive>::value ||
        has_member_versioned_load_minimal<T, InputArchive>::value ||
        has_non_member_versioned_load_minimal<T, InputArchive>::value) &&
       !(is_specialized_member_serialize<T, InputArchive>::value ||
         is_specialized_member_load<T, InputArchive>::value))> {};

    // ######################################################################
    namespace detail
    {
      //! The number of output serialization functions available
      /*! If specialization is being used, we'll count only those; otherwise we'll count everything */
      template <class T, class OutputArchive>
      struct count_output_serializers : std::integral_constant<int,
        count_specializations<T, OutputArchive>::value ? count_specializations<T, OutputArchive>::value :
        has_member_save<T, OutputArchive>::value +
        has_non_member_save<T, OutputArchive>::value +
        has_member_serialize<T, OutputArchive>::value +
        has_non_member_serialize<T, OutputArchive>::value +
        has_member_save_minimal<T, OutputArchive>::value +
        has_non_member_save_minimal<T, OutputArchive>::value +
        /*-versioned---------------------------------------------------------*/
        has_member_versioned_save<T, OutputArchive>::value +
        has_non_member_versioned_save<T, OutputArchive>::value +
        has_member_versioned_serialize<T, OutputArchive>::value +
        has_non_member_versioned_serialize<T, OutputArchive>::value +
        has_member_versioned_save_minimal<T, OutputArchive>::value +
        has_non_member_versioned_save_minimal<T, OutputArchive>::value> {};
    }

    template <class T, class OutputArchive>
    struct is_output_serializable : std::integral_constant<bool,
      detail::count_output_serializers<T, OutputArchive>::value == 1> {};

    // ######################################################################
    namespace detail
    {
      //! The number of input serialization functions available
      /*! If specialization is being used, we'll count only those; otherwise we'll count everything */
      template <class T, class InputArchive>
      struct count_input_serializers : std::integral_constant<int,
        count_specializations<T, InputArchive>::value ? count_specializations<T, InputArchive>::value :
        has_member_load<T, InputArchive>::value +
        has_non_member_load<T, InputArchive>::value +
        has_member_serialize<T, InputArchive>::value +
        has_non_member_serialize<T, InputArchive>::value +
        has_member_load_minimal<T, InputArchive>::value +
        has_non_member_load_minimal<T, InputArchive>::value +
        /*-versioned---------------------------------------------------------*/
        has_member_versioned_load<T, InputArchive>::value +
        has_non_member_versioned_load<T, InputArchive>::value +
        has_member_versioned_serialize<T, InputArchive>::value +
        has_non_member_versioned_serialize<T, InputArchive>::value +
        has_member_versioned_load_minimal<T, InputArchive>::value +
        has_non_member_versioned_load_minimal<T, InputArchive>::value> {};
    }

    template <class T, class InputArchive>
    struct is_input_serializable : std::integral_constant<bool,
      detail::count_input_serializers<T, InputArchive>::value == 1> {};

    // ######################################################################
    // Base Class Support
    namespace detail
    {
      struct base_class_id
      {
        template<class T>
          base_class_id(T const * const t) :
          type(typeid(T)),
          ptr(t),
          hash(std::hash<std::type_index>()(typeid(T)) ^ (std::hash<void const *>()(t) << 1))
          { }

          bool operator==(base_class_id const & other) const
          { return (type == other.type) && (ptr == other.ptr); }

          std::type_index type;
          void const * ptr;
          size_t hash;
      };
      struct base_class_id_hash { size_t operator()(base_class_id const & id) const { return id.hash; }  };
    } // namespace detail

    namespace detail
    {
      //! Common base type for base class casting
      struct BaseCastBase {};

      template <class>
      struct get_base_class;

      template <template<typename> class Cast, class Base>
      struct get_base_class<Cast<Base>>
      {
        using type = Base;
      };

      //! Base class cast, behave as the test
      template <class Cast, template<class, class> class Test, class Archive,
                bool IsBaseCast = std::is_base_of<BaseCastBase, Cast>::value>
      struct has_minimal_base_class_serialization_impl : Test<typename get_base_class<Cast>::type, Archive>
      { };

      //! Not a base class cast
      template <class Cast, template<class, class> class Test, class Archive>
      struct has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> : std::false_type
      { };
    }

    //! Checks to see if the base class used in a cast has a minimal serialization
    /*! @tparam Cast Either base_class or virtual_base_class wrapped type
        @tparam Test A has_minimal test (for either input or output)
        @tparam Archive The archive to use with the test */
    template <class Cast, template<class, class> class Test, class Archive>
    struct has_minimal_base_class_serialization : detail::has_minimal_base_class_serialization_impl<Cast, Test, Archive>
    { };


    // ######################################################################
    namespace detail
    {
      struct shared_from_this_wrapper
      {
        template <class U>
        static auto (check)( U const & t ) -> decltype( ::cereal::access::shared_from_this(t), std::true_type() );

        static auto (check)( ... ) -> decltype( std::false_type() );

        template <class U>
        static auto get( U const & t ) -> decltype( t.shared_from_this() );
      };
    }

    //! Determine if T or any base class of T has inherited from std::enable_shared_from_this
    template<class T>
    struct has_shared_from_this : decltype((detail::shared_from_this_wrapper::check)(std::declval<T>()))
    { };

    //! Get the type of the base class of T which inherited from std::enable_shared_from_this
    template <class T>
    struct get_shared_from_this_base
    {
      private:
        using PtrType = decltype(detail::shared_from_this_wrapper::get(std::declval<T>()));
      public:
        //! The type of the base of T that inherited from std::enable_shared_from_this
        using type = typename std::decay<typename PtrType::element_type>::type;
    };

    // ######################################################################
    //! Extracts the true type from something possibly wrapped in a cereal NoConvert
    /*! Internally cereal uses some wrapper classes to test the validity of non-member
        minimal load and save functions.  This can interfere with user type traits on
        templated load and save minimal functions.  To get to the correct underlying type,
        users should use strip_minimal when performing any enable_if type type trait checks.

        See the enum serialization in types/common.hpp for an example of using this */
    template <class T, bool IsCerealMinimalTrait = std::is_base_of<detail::NoConvertBase, T>::value>
    struct strip_minimal
    {
      using type = T;
    };

    //! Specialization for types wrapped in a NoConvert
    template <class T>
    struct strip_minimal<T, true>
    {
      using type = typename T::type;
    };

    // ######################################################################
    //! Determines whether the class T can be default constructed by cereal::access
    template <class T>
    struct is_default_constructible
    {
      #ifdef CEREAL_OLDER_GCC
      template <class TT, class SFINAE = void>
      struct test : no {};
      template <class TT>
      struct test<TT, typename detail::Void< decltype( cereal::access::construct<TT>() ) >::type> : yes {};
      static const bool value = test<T>();
      #else // NOT CEREAL_OLDER_GCC =========================================
      template <class TT>
      static auto test(int) -> decltype( cereal::access::construct<TT>(), yes());
      template <class>
      static no test(...);
      static const bool value = std::is_same<decltype(test<T>(0)), yes>::value;
      #endif // NOT CEREAL_OLDER_GCC
    };

    // ######################################################################
    namespace detail
    {
      //! Removes all qualifiers and minimal wrappers from an archive
      template <class A>
      using decay_archive = typename std::decay<typename strip_minimal<A>::type>::type;
    }

    //! Checks if the provided archive type is equal to some cereal archive type
    /*! This automatically does things such as std::decay and removing any other wrappers that may be
        on the Archive template parameter.

        Example use:
        @code{cpp}
        // example use to disable a serialization function
        template <class Archive, EnableIf<cereal::traits::is_same_archive<Archive, cereal::BinaryOutputArchive>::value> = sfinae>
        void save( Archive & ar, MyType const & mt );
        @endcode */
    template <class ArchiveT, class CerealArchiveT>
    struct is_same_archive : std::integral_constant<bool,
      std::is_same<detail::decay_archive<ArchiveT>, CerealArchiveT>::value>
    { };

    // ######################################################################
    //! A macro to use to restrict which types of archives your function will work for.
    /*! This requires you to have a template class parameter named Archive and replaces the void return
        type for your function.

        INTYPE refers to the input archive type you wish to restrict on.
        OUTTYPE refers to the output archive type you wish to restrict on.

        For example, if we want to limit a serialize to only work with binary serialization:

        @code{.cpp}
        template <class Archive>
        CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
        serialize( Archive & ar, MyCoolType & m )
        {
          ar & m;
        }
        @endcode

        If you need to do more restrictions in your enable_if, you will need to do this by hand.
     */
    #define CEREAL_ARCHIVE_RESTRICT(INTYPE, OUTTYPE) \
    typename std::enable_if<cereal::traits::is_same_archive<Archive, INTYPE>::value || cereal::traits::is_same_archive<Archive, OUTTYPE>::value, void>::type

    //! Type traits only struct used to mark an archive as human readable (text based)
    /*! Archives that wish to identify as text based/human readable should inherit from
        this struct */
    struct TextArchive {};

    //! Checks if an archive is a text archive (human readable)
    template <class A>
    struct is_text_archive : std::integral_constant<bool,
      std::is_base_of<TextArchive, detail::decay_archive<A>>::value>
    { };
  } // namespace traits

  // ######################################################################
  namespace detail
  {
    template <class T, class A,
              bool Member = traits::has_member_load_and_construct<T, A>::value,
              bool MemberVersioned = traits::has_member_versioned_load_and_construct<T, A>::value,
              bool NonMember = traits::has_non_member_load_and_construct<T, A>::value,
              bool NonMemberVersioned = traits::has_non_member_versioned_load_and_construct<T, A>::value>
    struct Construct
    {
      static_assert( cereal::traits::detail::delay_static_assert<T>::value,
        "cereal found more than one compatible load_and_construct function for the provided type and archive combination. \n\n "
        "Types must either have a member load_and_construct function or a non-member specialization of LoadAndConstruct (you may not mix these). \n "
        "In addition, you may not mix versioned with non-versioned load_and_construct functions. \n\n " );
      static T * load_andor_construct( A & /*ar*/, construct<T> & /*construct*/ )
      { return nullptr; }
    };

    // no load and construct case
    template <class T, class A>
    struct Construct<T, A, false, false, false, false>
    {
      static_assert( ::cereal::traits::is_default_constructible<T>::value,
                     "Trying to serialize a an object with no default constructor. \n\n "
                     "Types must either be default constructible or define either a member or non member Construct function. \n "
                     "Construct functions generally have the signature: \n\n "
                     "template <class Archive> \n "
                     "static void load_and_construct(Archive & ar, cereal::construct<T> & construct) \n "
                     "{ \n "
                     "  var a; \n "
                     "  ar( a ) \n "
                     "  construct( a ); \n "
                     "} \n\n" );
      static T * load_andor_construct()
      { return ::cereal::access::construct<T>(); }
    };

    // member non-versioned
    template <class T, class A>
    struct Construct<T, A, true, false, false, false>
    {
      static void load_andor_construct( A & ar, construct<T> & construct )
      {
        access::load_and_construct<T>( ar, construct );
      }
    };

    // member versioned
    template <class T, class A>
    struct Construct<T, A, false, true, false, false>
    {
      static void load_andor_construct( A & ar, construct<T> & construct )
      {
        const auto version = ar.template loadClassVersion<T>();
        access::load_and_construct<T>( ar, construct, version );
      }
    };

    // non-member non-versioned
    template <class T, class A>
    struct Construct<T, A, false, false, true, false>
    {
      static void load_andor_construct( A & ar, construct<T> & construct )
      {
        LoadAndConstruct<T>::load_and_construct( ar, construct );
      }
    };

    // non-member versioned
    template <class T, class A>
    struct Construct<T, A, false, false, false, true>
    {
      static void load_andor_construct( A & ar, construct<T> & construct )
      {
        const auto version = ar.template loadClassVersion<T>();
        LoadAndConstruct<T>::load_and_construct( ar, construct, version );
      }
    };
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_TRAITS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/util.hpp
================================================
/*! \file util.hpp
    \brief Internal misc utilities
    \ingroup Internal */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_DETAILS_UTIL_HPP_
#define CEREAL_DETAILS_UTIL_HPP_

#include <typeinfo>
#include <string>

#ifdef _MSC_VER
namespace cereal
{
  namespace util
  {
    //! Demangles the type encoded in a string
    /*! @internal */
    inline std::string demangle( std::string const & name )
    { return name; }

    //! Gets the demangled name of a type
    /*! @internal */
    template <class T> inline
    std::string demangledName()
    { return typeid( T ).name(); }
  } // namespace util
} // namespace cereal
#else // clang or gcc
#include <cxxabi.h>
#include <cstdlib>
namespace cereal
{
  namespace util
  {
    //! Demangles the type encoded in a string
    /*! @internal */
    inline std::string demangle(std::string mangledName)
    {
      int status = 0;
      char *demangledName = nullptr;
      std::size_t len;

      demangledName = abi::__cxa_demangle(mangledName.c_str(), 0, &len, &status);

      std::string retName(demangledName);
      free(demangledName);

      return retName;
    }

    //! Gets the demangled name of a type
    /*! @internal */
    template<class T> inline
    std::string demangledName()
    { return demangle(typeid(T).name()); }
  }
} // namespace cereal
#endif // clang or gcc branch of _MSC_VER
#endif // CEREAL_DETAILS_UTIL_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/base64.hpp
================================================
/*
   Copyright (C) 2004-2008 René Nyffenegger

   This source code is provided 'as-is', without any express or implied
   warranty. In no event will the author be held liable for any damages
   arising from the use of this software.

   Permission is granted to anyone to use this software for any purpose,
   including commercial applications, and to alter it and redistribute it
   freely, subject to the following restrictions:

   1. The origin of this source code must not be misrepresented; you must not
      claim that you wrote the original source code. If you use this source code
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original source code.

   3. This notice may not be removed or altered from any source distribution.

   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
*/

#ifndef CEREAL_EXTERNAL_BASE64_HPP_
#define CEREAL_EXTERNAL_BASE64_HPP_

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif

#include <string>

namespace cereal
{
  namespace base64
  {
    static const std::string chars =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
      "abcdefghijklmnopqrstuvwxyz"
      "0123456789+/";

    static inline bool is_base64(unsigned char c) {
      return (isalnum(c) || (c == '+') || (c == '/'));
    }

    inline std::string encode(unsigned char const* bytes_to_encode, size_t in_len) {
      std::string ret;
      int i = 0;
      int j = 0;
      unsigned char char_array_3[3];
      unsigned char char_array_4[4];

      while (in_len--) {
        char_array_3[i++] = *(bytes_to_encode++);
        if (i == 3) {
          char_array_4[0] = static_cast<unsigned char>((char_array_3[0] & 0xfc) >> 2);
          char_array_4[1] = static_cast<unsigned char>( ( ( char_array_3[0] & 0x03 ) << 4 ) + ( ( char_array_3[1] & 0xf0 ) >> 4 ) );
          char_array_4[2] = static_cast<unsigned char>( ( ( char_array_3[1] & 0x0f ) << 2 ) + ( ( char_array_3[2] & 0xc0 ) >> 6 ) );
          char_array_4[3] = static_cast<unsigned char>( char_array_3[2] & 0x3f );

          for(i = 0; (i <4) ; i++)
            ret += chars[char_array_4[i]];
          i = 0;
        }
      }

      if (i)
      {
        for(j = i; j < 3; j++)
          char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; (j < i + 1); j++)
          ret += chars[char_array_4[j]];

        while((i++ < 3))
          ret += '=';
      }

      return ret;
    }

    inline std::string decode(std::string const& encoded_string) {
      size_t in_len = encoded_string.size();
      size_t i = 0;
      size_t j = 0;
      int in_ = 0;
      unsigned char char_array_4[4], char_array_3[3];
      std::string ret;

      while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
        char_array_4[i++] = encoded_string[in_]; in_++;
        if (i ==4) {
          for (i = 0; i <4; i++)
            char_array_4[i] = static_cast<unsigned char>(chars.find( char_array_4[i] ));

          char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
          char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
          char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

          for (i = 0; (i < 3); i++)
            ret += char_array_3[i];
          i = 0;
        }
      }

      if (i) {
        for (j = i; j <4; j++)
          char_array_4[j] = 0;

        for (j = 0; j <4; j++)
          char_array_4[j] = static_cast<unsigned char>(chars.find( char_array_4[j] ));

        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
      }

      return ret;
    }
  } // namespace base64
} // namespace cereal
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
#endif // CEREAL_EXTERNAL_BASE64_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/allocators.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ALLOCATORS_H_
#define CEREAL_RAPIDJSON_ALLOCATORS_H_

#include "rapidjson.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// Allocator

/*! \class rapidjson::Allocator
    \brief Concept for allocating, resizing and freeing memory block.
    
    Note that Malloc() and Realloc() are non-static but Free() is static.
    
    So if an allocator need to support Free(), it needs to put its pointer in 
    the header of memory block.

\code
concept Allocator {
    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().

    // Allocate a memory block.
    // \param size of the memory block in bytes.
    // \returns pointer to the memory block.
    void* Malloc(size_t size);

    // Resize a memory block.
    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
    // \param newSize the new size in bytes.
    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);

    // Free a memory block.
    // \param pointer to the memory block. Null pointer is permitted.
    static void Free(void *ptr);
};
\endcode
*/


/*! \def CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief User-defined kDefaultChunkCapacity definition.

    User can define this as any \c size that is a power of 2.
*/

#ifndef CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
#define CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
#endif


///////////////////////////////////////////////////////////////////////////////
// CrtAllocator

//! C-runtime library allocator.
/*! This class is just wrapper for standard C library memory routines.
    \note implements Allocator concept
*/
class CrtAllocator {
public:
    static const bool kNeedFree = true;
    void* Malloc(size_t size) { 
        if (size) //  behavior of malloc(0) is implementation defined.
            return std::malloc(size);
        else
            return NULL; // standardize to returning NULL.
    }
    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
        (void)originalSize;
        if (newSize == 0) {
            std::free(originalPtr);
            return NULL;
        }
        return std::realloc(originalPtr, newSize);
    }
    static void Free(void *ptr) { std::free(ptr); }
};

///////////////////////////////////////////////////////////////////////////////
// MemoryPoolAllocator

//! Default memory allocator used by the parser and DOM.
/*! This allocator allocate memory blocks from pre-allocated memory chunks. 

    It does not free memory blocks. And Realloc() only allocate new memory.

    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.

    User may also supply a buffer as the first chunk.

    If the user-buffer is full then additional chunks are allocated by BaseAllocator.

    The user-buffer is not deallocated by this allocator.

    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
    \note implements Allocator concept
*/
template <typename BaseAllocator = CrtAllocator>
class MemoryPoolAllocator {
public:
    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)

    //! Constructor with chunkSize.
    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
        \param baseAllocator The allocator for allocating memory chunks.
    */
    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
    }

    //! Constructor with user-supplied buffer.
    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.

        The user buffer will not be deallocated when this allocator is destructed.

        \param buffer User supplied buffer.
        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
        \param baseAllocator The allocator for allocating memory chunks.
    */
    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
        CEREAL_RAPIDJSON_ASSERT(buffer != 0);
        CEREAL_RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
        chunkHead_->capacity = size - sizeof(ChunkHeader);
        chunkHead_->size = 0;
        chunkHead_->next = 0;
    }

    //! Destructor.
    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
    */
    ~MemoryPoolAllocator() {
        Clear();
        CEREAL_RAPIDJSON_DELETE(ownBaseAllocator_);
    }

    //! Deallocates all memory chunks, excluding the user-supplied buffer.
    void Clear() {
        while (chunkHead_ && chunkHead_ != userBuffer_) {
            ChunkHeader* next = chunkHead_->next;
            baseAllocator_->Free(chunkHead_);
            chunkHead_ = next;
        }
        if (chunkHead_ && chunkHead_ == userBuffer_)
            chunkHead_->size = 0; // Clear user buffer
    }

    //! Computes the total capacity of allocated memory chunks.
    /*! \return total capacity in bytes.
    */
    size_t Capacity() const {
        size_t capacity = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            capacity += c->capacity;
        return capacity;
    }

    //! Computes the memory blocks allocated.
    /*! \return total used bytes.
    */
    size_t Size() const {
        size_t size = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            size += c->size;
        return size;
    }

    //! Allocates a memory block. (concept Allocator)
    void* Malloc(size_t size) {
        if (!size)
            return NULL;

        size = CEREAL_RAPIDJSON_ALIGN(size);
        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
                return NULL;

        void *buffer = reinterpret_cast<char *>(chunkHead_) + CEREAL_RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
        chunkHead_->size += size;
        return buffer;
    }

    //! Resizes a memory block (concept Allocator)
    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
        if (originalPtr == 0)
            return Malloc(newSize);

        if (newSize == 0)
            return NULL;

        originalSize = CEREAL_RAPIDJSON_ALIGN(originalSize);
        newSize = CEREAL_RAPIDJSON_ALIGN(newSize);

        // Do not shrink if new size is smaller than original
        if (originalSize >= newSize)
            return originalPtr;

        // Simply expand it if it is the last allocation and there is sufficient space
        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + CEREAL_RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
            size_t increment = static_cast<size_t>(newSize - originalSize);
            if (chunkHead_->size + increment <= chunkHead_->capacity) {
                chunkHead_->size += increment;
                return originalPtr;
            }
        }

        // Realloc process: allocate and copy memory, do not free original buffer.
        if (void* newBuffer = Malloc(newSize)) {
            if (originalSize)
                std::memcpy(newBuffer, originalPtr, originalSize);
            return newBuffer;
        }
        else
            return NULL;
    }

    //! Frees a memory block (concept Allocator)
    static void Free(void *ptr) { (void)ptr; } // Do nothing

private:
    //! Copy constructor is not permitted.
    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
    //! Copy assignment operator is not permitted.
    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;

    //! Creates a new chunk.
    /*! \param capacity Capacity of the chunk in bytes.
        \return true if success.
    */
    bool AddChunk(size_t capacity) {
        if (!baseAllocator_)
            ownBaseAllocator_ = baseAllocator_ = CEREAL_RAPIDJSON_NEW(BaseAllocator)();
        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(CEREAL_RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
            chunk->capacity = capacity;
            chunk->size = 0;
            chunk->next = chunkHead_;
            chunkHead_ =  chunk;
            return true;
        }
        else
            return false;
    }

    static const int kDefaultChunkCapacity = CEREAL_RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.

    //! Chunk header for perpending to each chunk.
    /*! Chunks are stored as a singly linked list.
    */
    struct ChunkHeader {
        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
        size_t size;        //!< Current size of allocated memory in bytes.
        ChunkHeader *next;  //!< Next chunk in the linked list.
    };

    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
    void *userBuffer_;          //!< User supplied buffer.
    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
    BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.
};

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_ENCODINGS_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/cursorstreamwrapper.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_
#define CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_

#include "stream.h"

#if defined(__GNUC__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#if defined(_MSC_VER) && _MSC_VER <= 1800
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4702)  // unreachable code
CEREAL_RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN


//! Cursor stream wrapper for counting line and column number if error exists.
/*!
    \tparam InputStream     Any stream that implements Stream Concept
*/
template <typename InputStream, typename Encoding = UTF8<> >
class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding> {
public:
    typedef typename Encoding::Ch Ch;

    CursorStreamWrapper(InputStream& is):
        GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}

    // counting line and column number
    Ch Take() {
        Ch ch = this->is_.Take();
        if(ch == '\n') {
            line_ ++;
            col_ = 0;
        } else {
            col_ ++;
        }
        return ch;
    }

    //! Get the error line number, if error exists.
    size_t GetLine() const { return line_; }
    //! Get the error column number, if error exists.
    size_t GetColumn() const { return col_; }

private:
    size_t line_;   //!< Current Line
    size_t col_;    //!< Current Column
};

#if defined(_MSC_VER) && _MSC_VER <= 1800
CEREAL_RAPIDJSON_DIAG_POP
#endif

#if defined(__GNUC__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_CURSORSTREAMWRAPPER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/document.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_DOCUMENT_H_
#define CEREAL_RAPIDJSON_DOCUMENT_H_

/*! \file document.h */

#include "reader.h"
#include "internal/meta.h"
#include "internal/strfunc.h"
#include "memorystream.h"
#include "encodedstream.h"
#include <new>      // placement new
#include <limits>

CEREAL_RAPIDJSON_DIAG_PUSH
#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from kXxxFlags to 'uint16_t', possible loss of data
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif // __GNUC__

#ifndef CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS
#include <iterator> // std::random_access_iterator_tag
#endif

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
#include <utility> // std::move
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

// Forward declaration.
template <typename Encoding, typename Allocator>
class GenericValue;

template <typename Encoding, typename Allocator, typename StackAllocator>
class GenericDocument;

//! Name-value pair in a JSON object value.
/*!
    This class was internal to GenericValue. It used to be a inner struct.
    But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
    https://code.google.com/p/rapidjson/issues/detail?id=64
*/
template <typename Encoding, typename Allocator>
struct GenericMember {
    GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
    GenericValue<Encoding, Allocator> value;    //!< value of member.

    // swap() for std::sort() and other potential use in STL.
    friend inline void swap(GenericMember& a, GenericMember& b) CEREAL_RAPIDJSON_NOEXCEPT {
        a.name.Swap(b.name);
        a.value.Swap(b.value);
    }
};

///////////////////////////////////////////////////////////////////////////////
// GenericMemberIterator

#ifndef CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

//! (Constant) member iterator for a JSON object value
/*!
    \tparam Const Is this a constant iterator?
    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
    \tparam Allocator   Allocator type for allocating memory of object, array and string.

    This class implements a Random Access Iterator for GenericMember elements
    of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements].

    \note This iterator implementation is mainly intended to avoid implicit
        conversions from iterator values to \c NULL,
        e.g. from GenericValue::FindMember.

    \note Define \c CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a
        pointer-based implementation, if your platform doesn't provide
        the C++ <iterator> header.

    \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
 */
template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator {

    friend class GenericValue<Encoding,Allocator>;
    template <bool, typename, typename> friend class GenericMemberIterator;

    typedef GenericMember<Encoding,Allocator> PlainType;
    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;

public:
    //! Iterator type itself
    typedef GenericMemberIterator Iterator;
    //! Constant iterator type
    typedef GenericMemberIterator<true,Encoding,Allocator>  ConstIterator;
    //! Non-constant iterator type
    typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;

    /** \name std::iterator_traits support */
    //@{
    typedef ValueType      value_type;
    typedef ValueType *    pointer;
    typedef ValueType &    reference;
    typedef std::ptrdiff_t difference_type;
    typedef std::random_access_iterator_tag iterator_category;
    //@}

    //! Pointer to (const) GenericMember
    typedef pointer         Pointer;
    //! Reference to (const) GenericMember
    typedef reference       Reference;
    //! Signed integer type (e.g. \c ptrdiff_t)
    typedef difference_type DifferenceType;

    //! Default constructor (singular value)
    /*! Creates an iterator pointing to no element.
        \note All operations, except for comparisons, are undefined on such values.
     */
    GenericMemberIterator() : ptr_() {}

    //! Iterator conversions to more const
    /*!
        \param it (Non-const) iterator to copy from

        Allows the creation of an iterator from another GenericMemberIterator
        that is "less const".  Especially, creating a non-constant iterator
        from a constant iterator are disabled:
        \li const -> non-const (not ok)
        \li const -> const (ok)
        \li non-const -> const (ok)
        \li non-const -> non-const (ok)

        \note If the \c Const template parameter is already \c false, this
            constructor effectively defines a regular copy-constructor.
            Otherwise, the copy constructor is implicitly defined.
    */
    GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
    Iterator& operator=(const NonConstIterator & it) { ptr_ = it.ptr_; return *this; }

    //! @name stepping
    //@{
    Iterator& operator++(){ ++ptr_; return *this; }
    Iterator& operator--(){ --ptr_; return *this; }
    Iterator  operator++(int){ Iterator old(*this); ++ptr_; return old; }
    Iterator  operator--(int){ Iterator old(*this); --ptr_; return old; }
    //@}

    //! @name increment/decrement
    //@{
    Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); }
    Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); }

    Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; }
    Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; }
    //@}

    //! @name relations
    //@{
    bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
    bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
    bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
    bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
    bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
    bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }
    //@}

    //! @name dereference
    //@{
    Reference operator*() const { return *ptr_; }
    Pointer   operator->() const { return ptr_; }
    Reference operator[](DifferenceType n) const { return ptr_[n]; }
    //@}

    //! Distance
    DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; }

private:
    //! Internal constructor from plain pointer
    explicit GenericMemberIterator(Pointer p) : ptr_(p) {}

    Pointer ptr_; //!< raw pointer
};

#else // CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

// class-based member iterator implementation disabled, use plain pointers

template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator;

//! non-const GenericMemberIterator
template <typename Encoding, typename Allocator>
class GenericMemberIterator<false,Encoding,Allocator> {
    //! use plain pointer as iterator type
    typedef GenericMember<Encoding,Allocator>* Iterator;
};
//! const GenericMemberIterator
template <typename Encoding, typename Allocator>
class GenericMemberIterator<true,Encoding,Allocator> {
    //! use plain const pointer as iterator type
    typedef const GenericMember<Encoding,Allocator>* Iterator;
};

#endif // CEREAL_RAPIDJSON_NOMEMBERITERATORCLASS

///////////////////////////////////////////////////////////////////////////////
// GenericStringRef

//! Reference to a constant string (not taking a copy)
/*!
    \tparam CharType character type of the string

    This helper class is used to automatically infer constant string
    references for string literals, especially from \c const \b (!)
    character arrays.

    The main use is for creating JSON string values without copying the
    source string via an \ref Allocator.  This requires that the referenced
    string pointers have a sufficient lifetime, which exceeds the lifetime
    of the associated GenericValue.

    \b Example
    \code
    Value v("foo");   // ok, no need to copy & calculate length
    const char foo[] = "foo";
    v.SetString(foo); // ok

    const char* bar = foo;
    // Value x(bar); // not ok, can't rely on bar's lifetime
    Value x(StringRef(bar)); // lifetime explicitly guaranteed by user
    Value y(StringRef(bar, 3));  // ok, explicitly pass length
    \endcode

    \see StringRef, GenericValue::SetString
*/
template<typename CharType>
struct GenericStringRef {
    typedef CharType Ch; //!< character type of the string

    //! Create string reference from \c const character array
#ifndef __clang__ // -Wdocumentation
    /*!
        This constructor implicitly creates a constant string reference from
        a \c const character array.  It has better performance than
        \ref StringRef(const CharType*) by inferring the string \ref length
        from the array length, and also supports strings containing null
        characters.

        \tparam N length of the string, automatically inferred

        \param str Constant character array, lifetime assumed to be longer
            than the use of the string in e.g. a GenericValue

        \post \ref s == str

        \note Constant complexity.
        \note There is a hidden, private overload to disallow references to
            non-const character arrays to be created via this constructor.
            By this, e.g. function-scope arrays used to be filled via
            \c snprintf are excluded from consideration.
            In such cases, the referenced string should be \b copied to the
            GenericValue instead.
     */
#endif
    template<SizeType N>
    GenericStringRef(const CharType (&str)[N]) CEREAL_RAPIDJSON_NOEXCEPT
        : s(str), length(N-1) {}

    //! Explicitly create string reference from \c const character pointer
#ifndef __clang__ // -Wdocumentation
    /*!
        This constructor can be used to \b explicitly  create a reference to
        a constant string pointer.

        \see StringRef(const CharType*)

        \param str Constant character pointer, lifetime assumed to be longer
            than the use of the string in e.g. a GenericValue

        \post \ref s == str

        \note There is a hidden, private overload to disallow references to
            non-const character arrays to be created via this constructor.
            By this, e.g. function-scope arrays used to be filled via
            \c snprintf are excluded from consideration.
            In such cases, the referenced string should be \b copied to the
            GenericValue instead.
     */
#endif
    explicit GenericStringRef(const CharType* str)
        : s(str), length(NotNullStrLen(str)) {}

    //! Create constant string reference from pointer and length
#ifndef __clang__ // -Wdocumentation
    /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
        \param len length of the string, excluding the trailing NULL terminator

        \post \ref s == str && \ref length == len
        \note Constant complexity.
     */
#endif
    GenericStringRef(const CharType* str, SizeType len)
        : s(CEREAL_RAPIDJSON_LIKELY(str) ? str : emptyString), length(len) { CEREAL_RAPIDJSON_ASSERT(str != 0 || len == 0u); }

    GenericStringRef(const GenericStringRef& rhs) : s(rhs.s), length(rhs.length) {}

    //! implicit conversion to plain CharType pointer
    operator const Ch *() const { return s; }

    const Ch* const s; //!< plain CharType pointer
    const SizeType length; //!< length of the string (excluding the trailing NULL terminator)

private:
    SizeType NotNullStrLen(const CharType* str) {
        CEREAL_RAPIDJSON_ASSERT(str != 0);
        return internal::StrLen(str);
    }

    /// Empty string - used when passing in a NULL pointer
    static const Ch emptyString[];

    //! Disallow construction from non-const array
    template<SizeType N>
    GenericStringRef(CharType (&str)[N]) /* = delete */;
    //! Copy assignment operator not permitted - immutable type
    GenericStringRef& operator=(const GenericStringRef& rhs) /* = delete */;
};

template<typename CharType>
const CharType GenericStringRef<CharType>::emptyString[] = { CharType() };

//! Mark a character pointer as constant string
/*! Mark a plain character pointer as a "string literal".  This function
    can be used to avoid copying a character string to be referenced as a
    value in a JSON GenericValue object, if the string's lifetime is known
    to be valid long enough.
    \tparam CharType Character type of the string
    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
    \return GenericStringRef string reference object
    \relatesalso GenericStringRef

    \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember
*/
template<typename CharType>
inline GenericStringRef<CharType> StringRef(const CharType* str) {
    return GenericStringRef<CharType>(str);
}

//! Mark a character pointer as constant string
/*! Mark a plain character pointer as a "string literal".  This function
    can be used to avoid copying a character string to be referenced as a
    value in a JSON GenericValue object, if the string's lifetime is known
    to be valid long enough.

    This version has better performance with supplied length, and also
    supports string containing null characters.

    \tparam CharType character type of the string
    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
    \param length The length of source string.
    \return GenericStringRef string reference object
    \relatesalso GenericStringRef
*/
template<typename CharType>
inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
    return GenericStringRef<CharType>(str, SizeType(length));
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
//! Mark a string object as constant string
/*! Mark a string object (e.g. \c std::string) as a "string literal".
    This function can be used to avoid copying a string to be referenced as a
    value in a JSON GenericValue object, if the string's lifetime is known
    to be valid long enough.

    \tparam CharType character type of the string
    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
    \return GenericStringRef string reference object
    \relatesalso GenericStringRef
    \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
*/
template<typename CharType>
inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {
    return GenericStringRef<CharType>(str.data(), SizeType(str.size()));
}
#endif

///////////////////////////////////////////////////////////////////////////////
// GenericValue type traits
namespace internal {

template <typename T, typename Encoding = void, typename Allocator = void>
struct IsGenericValueImpl : FalseType {};

// select candidates according to nested encoding and allocator types
template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>
    : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};

// helper to match arbitrary GenericValue instantiations, including derived classes
template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};

} // namespace internal

///////////////////////////////////////////////////////////////////////////////
// TypeHelper

namespace internal {

template <typename ValueType, typename T>
struct TypeHelper {};

template<typename ValueType>
struct TypeHelper<ValueType, bool> {
    static bool Is(const ValueType& v) { return v.IsBool(); }
    static bool Get(const ValueType& v) { return v.GetBool(); }
    static ValueType& Set(ValueType& v, bool data) { return v.SetBool(data); }
    static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, int> {
    static bool Is(const ValueType& v) { return v.IsInt(); }
    static int Get(const ValueType& v) { return v.GetInt(); }
    static ValueType& Set(ValueType& v, int data) { return v.SetInt(data); }
    static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, unsigned> {
    static bool Is(const ValueType& v) { return v.IsUint(); }
    static unsigned Get(const ValueType& v) { return v.GetUint(); }
    static ValueType& Set(ValueType& v, unsigned data) { return v.SetUint(data); }
    static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};

#ifdef _MSC_VER
CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(long) == sizeof(int));
template<typename ValueType>
struct TypeHelper<ValueType, long> {
    static bool Is(const ValueType& v) { return v.IsInt(); }
    static long Get(const ValueType& v) { return v.GetInt(); }
    static ValueType& Set(ValueType& v, long data) { return v.SetInt(data); }
    static ValueType& Set(ValueType& v, long data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
};

CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(unsigned long) == sizeof(unsigned));
template<typename ValueType>
struct TypeHelper<ValueType, unsigned long> {
    static bool Is(const ValueType& v) { return v.IsUint(); }
    static unsigned long Get(const ValueType& v) { return v.GetUint(); }
    static ValueType& Set(ValueType& v, unsigned long data) { return v.SetUint(data); }
    static ValueType& Set(ValueType& v, unsigned long data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};
#endif

template<typename ValueType>
struct TypeHelper<ValueType, int64_t> {
    static bool Is(const ValueType& v) { return v.IsInt64(); }
    static int64_t Get(const ValueType& v) { return v.GetInt64(); }
    static ValueType& Set(ValueType& v, int64_t data) { return v.SetInt64(data); }
    static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, uint64_t> {
    static bool Is(const ValueType& v) { return v.IsUint64(); }
    static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
    static ValueType& Set(ValueType& v, uint64_t data) { return v.SetUint64(data); }
    static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, double> {
    static bool Is(const ValueType& v) { return v.IsDouble(); }
    static double Get(const ValueType& v) { return v.GetDouble(); }
    static ValueType& Set(ValueType& v, double data) { return v.SetDouble(data); }
    static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, float> {
    static bool Is(const ValueType& v) { return v.IsFloat(); }
    static float Get(const ValueType& v) { return v.GetFloat(); }
    static ValueType& Set(ValueType& v, float data) { return v.SetFloat(data); }
    static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
};

template<typename ValueType>
struct TypeHelper<ValueType, const typename ValueType::Ch*> {
    typedef const typename ValueType::Ch* StringType;
    static bool Is(const ValueType& v) { return v.IsString(); }
    static StringType Get(const ValueType& v) { return v.GetString(); }
    static ValueType& Set(ValueType& v, const StringType data) { return v.SetString(typename ValueType::StringRefType(data)); }
    static ValueType& Set(ValueType& v, const StringType data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
};

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template<typename ValueType>
struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
    typedef std::basic_string<typename ValueType::Ch> StringType;
    static bool Is(const ValueType& v) { return v.IsString(); }
    static StringType Get(const ValueType& v) { return StringType(v.GetString(), v.GetStringLength()); }
    static ValueType& Set(ValueType& v, const StringType& data, typename ValueType::AllocatorType& a) { return v.SetString(data, a); }
};
#endif

template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Array> {
    typedef typename ValueType::Array ArrayType;
    static bool Is(const ValueType& v) { return v.IsArray(); }
    static ArrayType Get(ValueType& v) { return v.GetArray(); }
    static ValueType& Set(ValueType& v, ArrayType data) { return v = data; }
    static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
};

template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstArray> {
    typedef typename ValueType::ConstArray ArrayType;
    static bool Is(const ValueType& v) { return v.IsArray(); }
    static ArrayType Get(const ValueType& v) { return v.GetArray(); }
};

template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Object> {
    typedef typename ValueType::Object ObjectType;
    static bool Is(const ValueType& v) { return v.IsObject(); }
    static ObjectType Get(ValueType& v) { return v.GetObject(); }
    static ValueType& Set(ValueType& v, ObjectType data) { return v = data; }
    static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { return v = data; }
};

template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstObject> {
    typedef typename ValueType::ConstObject ObjectType;
    static bool Is(const ValueType& v) { return v.IsObject(); }
    static ObjectType Get(const ValueType& v) { return v.GetObject(); }
};

} // namespace internal

// Forward declarations
template <bool, typename> class GenericArray;
template <bool, typename> class GenericObject;

///////////////////////////////////////////////////////////////////////////////
// GenericValue

//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
/*!
    A JSON value can be one of 7 types. This class is a variant type supporting
    these types.

    Use the Value if UTF8 and default allocator

    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
    \tparam Allocator   Allocator type for allocating memory of object, array and string.
*/
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
class GenericValue {
public:
    //! Name-value pair in an object.
    typedef GenericMember<Encoding, Allocator> Member;
    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.
    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.
    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.
    typedef GenericStringRef<Ch> StringRefType;     //!< Reference to a constant string
    typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator;  //!< Member iterator for iterating in object.
    typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator;  //!< Constant member iterator for iterating in object.
    typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.
    typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.
    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of itself.
    typedef GenericArray<false, ValueType> Array;
    typedef GenericArray<true, ValueType> ConstArray;
    typedef GenericObject<false, ValueType> Object;
    typedef GenericObject<true, ValueType> ConstObject;

    //!@name Constructors and destructor.
    //@{

    //! Default constructor creates a null value.
    GenericValue() CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Move constructor in C++11
    GenericValue(GenericValue&& rhs) CEREAL_RAPIDJSON_NOEXCEPT : data_(rhs.data_) {
        rhs.data_.f.flags = kNullFlag; // give up contents
    }
#endif

private:
    //! Copy constructor is not permitted.
    GenericValue(const GenericValue& rhs);

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Moving from a GenericDocument is not permitted.
    template <typename StackAllocator>
    GenericValue(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);

    //! Move assignment from a GenericDocument is not permitted.
    template <typename StackAllocator>
    GenericValue& operator=(GenericDocument<Encoding,Allocator,StackAllocator>&& rhs);
#endif

public:

    //! Constructor with JSON value type.
    /*! This creates a Value of specified type with default content.
        \param type Type of the value.
        \note Default content for number is zero.
    */
    explicit GenericValue(Type type) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
        static const uint16_t defaultFlags[] = {
            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
            kNumberAnyFlag
        };
        CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(type >= kNullType && type <= kNumberType);
        data_.f.flags = defaultFlags[type];

        // Use ShortString to store empty string.
        if (type == kStringType)
            data_.ss.SetLength(0);
    }

    //! Explicit copy constructor (with allocator)
    /*! Creates a copy of a Value by using the given Allocator
        \tparam SourceAllocator allocator of \c rhs
        \param rhs Value to copy from (read-only)
        \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().
        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
        \see CopyFrom()
    */
    template <typename SourceAllocator>
    GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
        switch (rhs.GetType()) {
        case kObjectType: {
                SizeType count = rhs.data_.o.size;
                Member* lm = reinterpret_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
                const typename GenericValue<Encoding,SourceAllocator>::Member* rm = rhs.GetMembersPointer();
                for (SizeType i = 0; i < count; i++) {
                    new (&lm[i].name) GenericValue(rm[i].name, allocator, copyConstStrings);
                    new (&lm[i].value) GenericValue(rm[i].value, allocator, copyConstStrings);
                }
                data_.f.flags = kObjectFlag;
                data_.o.size = data_.o.capacity = count;
                SetMembersPointer(lm);
            }
            break;
        case kArrayType: {
                SizeType count = rhs.data_.a.size;
                GenericValue* le = reinterpret_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
                const GenericValue<Encoding,SourceAllocator>* re = rhs.GetElementsPointer();
                for (SizeType i = 0; i < count; i++)
                    new (&le[i]) GenericValue(re[i], allocator, copyConstStrings);
                data_.f.flags = kArrayFlag;
                data_.a.size = data_.a.capacity = count;
                SetElementsPointer(le);
            }
            break;
        case kStringType:
            if (rhs.data_.f.flags == kConstStringFlag && !copyConstStrings) {
                data_.f.flags = rhs.data_.f.flags;
                data_  = *reinterpret_cast<const Data*>(&rhs.data_);
            }
            else
                SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
            break;
        default:
            data_.f.flags = rhs.data_.f.flags;
            data_  = *reinterpret_cast<const Data*>(&rhs.data_);
            break;
        }
    }

    //! Constructor for boolean value.
    /*! \param b Boolean value
        \note This constructor is limited to \em real boolean values and rejects
            implicitly converted types like arbitrary pointers.  Use an explicit cast
            to \c bool, if you want to construct a boolean JSON value in such cases.
     */
#ifndef CEREAL_RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
    template <typename T>
    explicit GenericValue(T b, CEREAL_RAPIDJSON_ENABLEIF((internal::IsSame<bool, T>))) CEREAL_RAPIDJSON_NOEXCEPT  // See #472
#else
    explicit GenericValue(bool b) CEREAL_RAPIDJSON_NOEXCEPT
#endif
        : data_() {
            // safe-guard against failing SFINAE
            CEREAL_RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
            data_.f.flags = b ? kTrueFlag : kFalseFlag;
    }

    //! Constructor for int value.
    explicit GenericValue(int i) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
        data_.n.i64 = i;
        data_.f.flags = (i >= 0) ? (kNumberIntFlag | kUintFlag | kUint64Flag) : kNumberIntFlag;
    }

    //! Constructor for unsigned value.
    explicit GenericValue(unsigned u) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
        data_.n.u64 = u;
        data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
    }

    //! Constructor for int64_t value.
    explicit GenericValue(int64_t i64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
        data_.n.i64 = i64;
        data_.f.flags = kNumberInt64Flag;
        if (i64 >= 0) {
            data_.f.flags |= kNumberUint64Flag;
            if (!(static_cast<uint64_t>(i64) & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
                data_.f.flags |= kUintFlag;
            if (!(static_cast<uint64_t>(i64) & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
                data_.f.flags |= kIntFlag;
        }
        else if (i64 >= static_cast<int64_t>(CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

    //! Constructor for uint64_t value.
    explicit GenericValue(uint64_t u64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
        data_.n.u64 = u64;
        data_.f.flags = kNumberUint64Flag;
        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
            data_.f.flags |= kInt64Flag;
        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
            data_.f.flags |= kUintFlag;
        if (!(u64 & CEREAL_RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
            data_.f.flags |= kIntFlag;
    }

    //! Constructor for double value.
    explicit GenericValue(double d) CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.n.d = d; data_.f.flags = kNumberDoubleFlag; }

    //! Constructor for float value.
    explicit GenericValue(float f) CEREAL_RAPIDJSON_NOEXCEPT : data_() { data_.n.d = static_cast<double>(f); data_.f.flags = kNumberDoubleFlag; }

    //! Constructor for constant string (i.e. do not make a copy of string)
    GenericValue(const Ch* s, SizeType length) CEREAL_RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }

    //! Constructor for constant string (i.e. do not make a copy of string)
    explicit GenericValue(StringRefType s) CEREAL_RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(s); }

    //! Constructor for copy-string (i.e. do make a copy of string)
    GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_() { SetStringRaw(StringRef(s, length), allocator); }

    //! Constructor for copy-string (i.e. do make a copy of string)
    GenericValue(const Ch*s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Constructor for copy-string from a string object (i.e. do make a copy of string)
    /*! \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
     */
    GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); }
#endif

    //! Constructor for Array.
    /*!
        \param a An array obtained by \c GetArray().
        \note \c Array is always pass-by-value.
        \note the source array is moved into this value and the sourec array becomes empty.
    */
    GenericValue(Array a) CEREAL_RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
        a.value_.data_ = Data();
        a.value_.data_.f.flags = kArrayFlag;
    }

    //! Constructor for Object.
    /*!
        \param o An object obtained by \c GetObject().
        \note \c Object is always pass-by-value.
        \note the source object is moved into this value and the sourec object becomes empty.
    */
    GenericValue(Object o) CEREAL_RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
        o.value_.data_ = Data();
        o.value_.data_.f.flags = kObjectFlag;
    }

    //! Destructor.
    /*! Need to destruct elements of array, members of object, or copy-string.
    */
    ~GenericValue() {
        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
            switch(data_.f.flags) {
            case kArrayFlag:
                {
                    GenericValue* e = GetElementsPointer();
                    for (GenericValue* v = e; v != e + data_.a.size; ++v)
                        v->~GenericValue();
                    Allocator::Free(e);
                }
                break;

            case kObjectFlag:
                for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
                    m->~Member();
                Allocator::Free(GetMembersPointer());
                break;

            case kCopyStringFlag:
                Allocator::Free(const_cast<Ch*>(GetStringPointer()));
                break;

            default:
                break;  // Do nothing for other types.
            }
        }
    }

    //@}

    //!@name Assignment operators
    //@{

    //! Assignment with move semantics.
    /*! \param rhs Source of the assignment. It will become a null value after assignment.
    */
    GenericValue& operator=(GenericValue& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
        if (CEREAL_RAPIDJSON_LIKELY(this != &rhs)) {
            this->~GenericValue();
            RawAssign(rhs);
        }
        return *this;
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Move assignment in C++11
    GenericValue& operator=(GenericValue&& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
        return *this = rhs.Move();
    }
#endif

    //! Assignment of constant string reference (no copy)
    /*! \param str Constant string reference to be assigned
        \note This overload is needed to avoid clashes with the generic primitive type assignment overload below.
        \see GenericStringRef, operator=(T)
    */
    GenericValue& operator=(StringRefType str) CEREAL_RAPIDJSON_NOEXCEPT {
        GenericValue s(str);
        return *this = s;
    }

    //! Assignment with primitive types.
    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
        \param value The value to be assigned.

        \note The source type \c T explicitly disallows all pointer types,
            especially (\c const) \ref Ch*.  This helps avoiding implicitly
            referencing character strings with insufficient lifetime, use
            \ref SetString(const Ch*, Allocator&) (for copying) or
            \ref StringRef() (to explicitly mark the pointer as constant) instead.
            All other pointer types would implicitly convert to \c bool,
            use \ref SetBool() instead.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))
    operator=(T value) {
        GenericValue v(value);
        return *this = v;
    }

    //! Deep-copy assignment from Value
    /*! Assigns a \b copy of the Value to the current Value object
        \tparam SourceAllocator Allocator type of \c rhs
        \param rhs Value to copy from (read-only)
        \param allocator Allocator to use for copying
        \param copyConstStrings Force copying of constant strings (e.g. referencing an in-situ buffer)
     */
    template <typename SourceAllocator>
    GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator, bool copyConstStrings = false) {
        CEREAL_RAPIDJSON_ASSERT(static_cast<void*>(this) != static_cast<void const*>(&rhs));
        this->~GenericValue();
        new (this) GenericValue(rhs, allocator, copyConstStrings);
        return *this;
    }

    //! Exchange the contents of this value with those of other.
    /*!
        \param other Another value.
        \note Constant complexity.
    */
    GenericValue& Swap(GenericValue& other) CEREAL_RAPIDJSON_NOEXCEPT {
        GenericValue temp;
        temp.RawAssign(*this);
        RawAssign(other);
        other.RawAssign(temp);
        return *this;
    }

    //! free-standing swap function helper
    /*!
        Helper function to enable support for common swap implementation pattern based on \c std::swap:
        \code
        void swap(MyClass& a, MyClass& b) {
            using std::swap;
            swap(a.value, b.value);
            // ...
        }
        \endcode
        \see Swap()
     */
    friend inline void swap(GenericValue& a, GenericValue& b) CEREAL_RAPIDJSON_NOEXCEPT { a.Swap(b); }

    //! Prepare Value for move semantics
    /*! \return *this */
    GenericValue& Move() CEREAL_RAPIDJSON_NOEXCEPT { return *this; }
    //@}

    //!@name Equal-to and not-equal-to operators
    //@{
    //! Equal-to operator
    /*!
        \note If an object contains duplicated named member, comparing equality with any object is always \c false.
        \note Complexity is quadratic in Object's member number and linear for the rest (number of all values in the subtree and total lengths of all strings).
    */
    template <typename SourceAllocator>
    bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
        typedef GenericValue<Encoding, SourceAllocator> RhsType;
        if (GetType() != rhs.GetType())
            return false;

        switch (GetType()) {
        case kObjectType: // Warning: O(n^2) inner-loop
            if (data_.o.size != rhs.data_.o.size)
                return false;
            for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
                typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
                if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
                    return false;
            }
            return true;

        case kArrayType:
            if (data_.a.size != rhs.data_.a.size)
                return false;
            for (SizeType i = 0; i < data_.a.size; i++)
                if ((*this)[i] != rhs[i])
                    return false;
            return true;

        case kStringType:
            return StringEqual(rhs);

        case kNumberType:
            if (IsDouble() || rhs.IsDouble()) {
                double a = GetDouble();     // May convert from integer to double.
                double b = rhs.GetDouble(); // Ditto
                return a >= b && a <= b;    // Prevent -Wfloat-equal
            }
            else
                return data_.n.u64 == rhs.data_.n.u64;

        default:
            return true;
        }
    }

    //! Equal-to operator with const C-string pointer
    bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Equal-to operator with string object
    /*! \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
     */
    bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); }
#endif

    //! Equal-to operator with primitive types
    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false
    */
    template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); }

    //! Not-equal-to operator
    /*! \return !(*this == rhs)
     */
    template <typename SourceAllocator>
    bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); }

    //! Not-equal-to operator with const C-string pointer
    bool operator!=(const Ch* rhs) const { return !(*this == rhs); }

    //! Not-equal-to operator with arbitrary types
    /*! \return !(*this == rhs)
     */
    template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); }

    //! Equal-to operator with arbitrary types (symmetric version)
    /*! \return (rhs == lhs)
     */
    template <typename T> friend CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; }

    //! Not-Equal-to operator with arbitrary types (symmetric version)
    /*! \return !(rhs == lhs)
     */
    template <typename T> friend CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); }
    //@}

    //!@name Type
    //@{

    Type GetType()  const { return static_cast<Type>(data_.f.flags & kTypeMask); }
    bool IsNull()   const { return data_.f.flags == kNullFlag; }
    bool IsFalse()  const { return data_.f.flags == kFalseFlag; }
    bool IsTrue()   const { return data_.f.flags == kTrueFlag; }
    bool IsBool()   const { return (data_.f.flags & kBoolFlag) != 0; }
    bool IsObject() const { return data_.f.flags == kObjectFlag; }
    bool IsArray()  const { return data_.f.flags == kArrayFlag; }
    bool IsNumber() const { return (data_.f.flags & kNumberFlag) != 0; }
    bool IsInt()    const { return (data_.f.flags & kIntFlag) != 0; }
    bool IsUint()   const { return (data_.f.flags & kUintFlag) != 0; }
    bool IsInt64()  const { return (data_.f.flags & kInt64Flag) != 0; }
    bool IsUint64() const { return (data_.f.flags & kUint64Flag) != 0; }
    bool IsDouble() const { return (data_.f.flags & kDoubleFlag) != 0; }
    bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }

    // Checks whether a number can be losslessly converted to a double.
    bool IsLosslessDouble() const {
        if (!IsNumber()) return false;
        if (IsUint64()) {
            uint64_t u = GetUint64();
            volatile double d = static_cast<double>(u);
            return (d >= 0.0)
                && (d < static_cast<double>((std::numeric_limits<uint64_t>::max)()))
                && (u == static_cast<uint64_t>(d));
        }
        if (IsInt64()) {
            int64_t i = GetInt64();
            volatile double d = static_cast<double>(i);
            return (d >= static_cast<double>((std::numeric_limits<int64_t>::min)()))
                && (d < static_cast<double>((std::numeric_limits<int64_t>::max)()))
                && (i == static_cast<int64_t>(d));
        }
        return true; // double, int, uint are always lossless
    }

    // Checks whether a number is a float (possible lossy).
    bool IsFloat() const  {
        if ((data_.f.flags & kDoubleFlag) == 0)
            return false;
        double d = GetDouble();
        return d >= -3.4028234e38 && d <= 3.4028234e38;
    }
    // Checks whether a number can be losslessly converted to a float.
    bool IsLosslessFloat() const {
        if (!IsNumber()) return false;
        double a = GetDouble();
        if (a < static_cast<double>(-(std::numeric_limits<float>::max)())
                || a > static_cast<double>((std::numeric_limits<float>::max)()))
            return false;
        double b = static_cast<double>(static_cast<float>(a));
        return a >= b && a <= b;    // Prevent -Wfloat-equal
    }

    //@}

    //!@name Null
    //@{

    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }

    //@}

    //!@name Bool
    //@{

    bool GetBool() const { CEREAL_RAPIDJSON_ASSERT(IsBool()); return data_.f.flags == kTrueFlag; }
    //!< Set boolean value
    /*! \post IsBool() == true */
    GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }

    //@}

    //!@name Object
    //@{

    //! Set this value as an empty object.
    /*! \post IsObject() == true */
    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }

    //! Get the number of members in the object.
    SizeType MemberCount() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }

    //! Get the capacity of object.
    SizeType MemberCapacity() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.capacity; }

    //! Check whether the object is empty.
    bool ObjectEmpty() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }

    //! Get a value from an object associated with the name.
    /*! \pre IsObject() == true
        \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType))
        \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.
        Since 0.2, if the name is not correct, it will assert.
        If user is unsure whether a member exists, user should use HasMember() first.
        A better approach is to use FindMember().
        \note Linear time complexity.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
        GenericValue n(StringRef(name));
        return (*this)[n];
    }
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }

    //! Get a value from an object associated with the name.
    /*! \pre IsObject() == true
        \tparam SourceAllocator Allocator of the \c name value

        \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen().
        And it can also handle strings with embedded null characters.

        \note Linear time complexity.
    */
    template <typename SourceAllocator>
    GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator member = FindMember(name);
        if (member != MemberEnd())
            return member->value;
        else {
            CEREAL_RAPIDJSON_ASSERT(false);    // see above note

            // This will generate -Wexit-time-destructors in clang
            // static GenericValue NullValue;
            // return NullValue;

            // Use static buffer and placement-new to prevent destruction
            static char buffer[sizeof(GenericValue)];
            return *new (buffer) GenericValue();
        }
    }
    template <typename SourceAllocator>
    const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Get a value from an object associated with name (string object).
    GenericValue& operator[](const std::basic_string<Ch>& name) { return (*this)[GenericValue(StringRef(name))]; }
    const GenericValue& operator[](const std::basic_string<Ch>& name) const { return (*this)[GenericValue(StringRef(name))]; }
#endif

    //! Const member iterator
    /*! \pre IsObject() == true */
    ConstMemberIterator MemberBegin() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer()); }
    //! Const \em past-the-end member iterator
    /*! \pre IsObject() == true */
    ConstMemberIterator MemberEnd() const   { CEREAL_RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(GetMembersPointer() + data_.o.size); }
    //! Member iterator
    /*! \pre IsObject() == true */
    MemberIterator MemberBegin()            { CEREAL_RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer()); }
    //! \em Past-the-end member iterator
    /*! \pre IsObject() == true */
    MemberIterator MemberEnd()              { CEREAL_RAPIDJSON_ASSERT(IsObject()); return MemberIterator(GetMembersPointer() + data_.o.size); }

    //! Request the object to have enough capacity to store members.
    /*! \param newCapacity  The capacity that the object at least need to have.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \note Linear time complexity.
    */
    GenericValue& MemberReserve(SizeType newCapacity, Allocator &allocator) {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        if (newCapacity > data_.o.capacity) {
            SetMembersPointer(reinterpret_cast<Member*>(allocator.Realloc(GetMembersPointer(), data_.o.capacity * sizeof(Member), newCapacity * sizeof(Member))));
            data_.o.capacity = newCapacity;
        }
        return *this;
    }

    //! Check whether a member exists in the object.
    /*!
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Whether a member with that name exists.
        \note It is better to use FindMember() directly if you need the obtain the value as well.
        \note Linear time complexity.
    */
    bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Check whether a member exists in the object with string object.
    /*!
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Whether a member with that name exists.
        \note It is better to use FindMember() directly if you need the obtain the value as well.
        \note Linear time complexity.
    */
    bool HasMember(const std::basic_string<Ch>& name) const { return FindMember(name) != MemberEnd(); }
#endif

    //! Check whether a member exists in the object with GenericValue name.
    /*!
        This version is faster because it does not need a StrLen(). It can also handle string with null character.
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Whether a member with that name exists.
        \note It is better to use FindMember() directly if you need the obtain the value as well.
        \note Linear time complexity.
    */
    template <typename SourceAllocator>
    bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); }

    //! Find member by name.
    /*!
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Iterator to member, if it exists.
            Otherwise returns \ref MemberEnd().

        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
            the requested member doesn't exist. For consistency with e.g.
            \c std::map, this has been changed to MemberEnd() now.
        \note Linear time complexity.
    */
    MemberIterator FindMember(const Ch* name) {
        GenericValue n(StringRef(name));
        return FindMember(n);
    }

    ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }

    //! Find member by name.
    /*!
        This version is faster because it does not need a StrLen(). It can also handle string with null character.
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Iterator to member, if it exists.
            Otherwise returns \ref MemberEnd().

        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
            the requested member doesn't exist. For consistency with e.g.
            \c std::map, this has been changed to MemberEnd() now.
        \note Linear time complexity.
    */
    template <typename SourceAllocator>
    MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        CEREAL_RAPIDJSON_ASSERT(name.IsString());
        MemberIterator member = MemberBegin();
        for ( ; member != MemberEnd(); ++member)
            if (name.StringEqual(member->name))
                break;
        return member;
    }
    template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Find member by string object name.
    /*!
        \param name Member name to be searched.
        \pre IsObject() == true
        \return Iterator to member, if it exists.
            Otherwise returns \ref MemberEnd().
    */
    MemberIterator FindMember(const std::basic_string<Ch>& name) { return FindMember(GenericValue(StringRef(name))); }
    ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const { return FindMember(GenericValue(StringRef(name))); }
#endif

    //! Add a member (name-value pair) to the object.
    /*! \param name A string value as name of member.
        \param value Value of any type.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \note The ownership of \c name and \c value will be transferred to this object on success.
        \pre  IsObject() && name.IsString()
        \post name.IsNull() && value.IsNull()
        \note Amortized Constant time complexity.
    */
    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        CEREAL_RAPIDJSON_ASSERT(name.IsString());

        ObjectData& o = data_.o;
        if (o.size >= o.capacity)
            MemberReserve(o.capacity == 0 ? kDefaultObjectCapacity : (o.capacity + (o.capacity + 1) / 2), allocator);
        Member* members = GetMembersPointer();
        members[o.size].name.RawAssign(name);
        members[o.size].value.RawAssign(value);
        o.size++;
        return *this;
    }

    //! Add a constant string value as member (name-value pair) to the object.
    /*! \param name A string value as name of member.
        \param value constant string reference as value of member.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \pre  IsObject()
        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
        \note Amortized Constant time complexity.
    */
    GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {
        GenericValue v(value);
        return AddMember(name, v, allocator);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Add a string object as member (name-value pair) to the object.
    /*! \param name A string value as name of member.
        \param value constant string reference as value of member.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \pre  IsObject()
        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
        \note Amortized Constant time complexity.
    */
    GenericValue& AddMember(GenericValue& name, std::basic_string<Ch>& value, Allocator& allocator) {
        GenericValue v(value, allocator);
        return AddMember(name, v, allocator);
    }
#endif

    //! Add any primitive value as member (name-value pair) to the object.
    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
        \param name A string value as name of member.
        \param value Value of primitive type \c T as value of member
        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \pre  IsObject()

        \note The source type \c T explicitly disallows all pointer types,
            especially (\c const) \ref Ch*.  This helps avoiding implicitly
            referencing character strings with insufficient lifetime, use
            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
            AddMember(StringRefType, StringRefType, Allocator&).
            All other pointer types would implicitly convert to \c bool,
            use an explicit cast instead, if needed.
        \note Amortized Constant time complexity.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
    AddMember(GenericValue& name, T value, Allocator& allocator) {
        GenericValue v(value);
        return AddMember(name, v, allocator);
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) {
        return AddMember(name, value, allocator);
    }
    GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) {
        return AddMember(name, value, allocator);
    }
    GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) {
        return AddMember(name, value, allocator);
    }
    GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) {
        GenericValue n(name);
        return AddMember(n, value, allocator);
    }
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS


    //! Add a member (name-value pair) to the object.
    /*! \param name A constant string reference as name of member.
        \param value Value of any type.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \note The ownership of \c value will be transferred to this object on success.
        \pre  IsObject()
        \post value.IsNull()
        \note Amortized Constant time complexity.
    */
    GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) {
        GenericValue n(name);
        return AddMember(n, value, allocator);
    }

    //! Add a constant string value as member (name-value pair) to the object.
    /*! \param name A constant string reference as name of member.
        \param value constant string reference as value of member.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \pre  IsObject()
        \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below.
        \note Amortized Constant time complexity.
    */
    GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
        GenericValue v(value);
        return AddMember(name, v, allocator);
    }

    //! Add any primitive value as member (name-value pair) to the object.
    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
        \param name A constant string reference as name of member.
        \param value Value of primitive type \c T as value of member
        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \pre  IsObject()

        \note The source type \c T explicitly disallows all pointer types,
            especially (\c const) \ref Ch*.  This helps avoiding implicitly
            referencing character strings with insufficient lifetime, use
            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
            AddMember(StringRefType, StringRefType, Allocator&).
            All other pointer types would implicitly convert to \c bool,
            use an explicit cast instead, if needed.
        \note Amortized Constant time complexity.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
    AddMember(StringRefType name, T value, Allocator& allocator) {
        GenericValue n(name);
        return AddMember(n, value, allocator);
    }

    //! Remove all members in the object.
    /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged.
        \note Linear time complexity.
    */
    void RemoveAllMembers() {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
            m->~Member();
        data_.o.size = 0;
    }

    //! Remove a member in object by its name.
    /*! \param name Name of member to be removed.
        \return Whether the member existed.
        \note This function may reorder the object members. Use \ref
            EraseMember(ConstMemberIterator) if you need to preserve the
            relative order of the remaining members.
        \note Linear time complexity.
    */
    bool RemoveMember(const Ch* name) {
        GenericValue n(StringRef(name));
        return RemoveMember(n);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool RemoveMember(const std::basic_string<Ch>& name) { return RemoveMember(GenericValue(StringRef(name))); }
#endif

    template <typename SourceAllocator>
    bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator m = FindMember(name);
        if (m != MemberEnd()) {
            RemoveMember(m);
            return true;
        }
        else
            return false;
    }

    //! Remove a member in object by iterator.
    /*! \param m member iterator (obtained by FindMember() or MemberBegin()).
        \return the new iterator after removal.
        \note This function may reorder the object members. Use \ref
            EraseMember(ConstMemberIterator) if you need to preserve the
            relative order of the remaining members.
        \note Constant time complexity.
    */
    MemberIterator RemoveMember(MemberIterator m) {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        CEREAL_RAPIDJSON_ASSERT(data_.o.size > 0);
        CEREAL_RAPIDJSON_ASSERT(GetMembersPointer() != 0);
        CEREAL_RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());

        MemberIterator last(GetMembersPointer() + (data_.o.size - 1));
        if (data_.o.size > 1 && m != last)
            *m = *last; // Move the last one to this place
        else
            m->~Member(); // Only one left, just destroy
        --data_.o.size;
        return m;
    }

    //! Remove a member from an object by iterator.
    /*! \param pos iterator to the member to remove
        \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()
        \return Iterator following the removed element.
            If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned.
        \note This function preserves the relative order of the remaining object
            members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator).
        \note Linear time complexity.
    */
    MemberIterator EraseMember(ConstMemberIterator pos) {
        return EraseMember(pos, pos +1);
    }

    //! Remove members in the range [first, last) from an object.
    /*! \param first iterator to the first member to remove
        \param last  iterator following the last member to remove
        \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd()
        \return Iterator following the last removed element.
        \note This function preserves the relative order of the remaining object
            members.
        \note Linear time complexity.
    */
    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {
        CEREAL_RAPIDJSON_ASSERT(IsObject());
        CEREAL_RAPIDJSON_ASSERT(data_.o.size > 0);
        CEREAL_RAPIDJSON_ASSERT(GetMembersPointer() != 0);
        CEREAL_RAPIDJSON_ASSERT(first >= MemberBegin());
        CEREAL_RAPIDJSON_ASSERT(first <= last);
        CEREAL_RAPIDJSON_ASSERT(last <= MemberEnd());

        MemberIterator pos = MemberBegin() + (first - MemberBegin());
        for (MemberIterator itr = pos; itr != last; ++itr)
            itr->~Member();
        std::memmove(static_cast<void*>(&*pos), &*last, static_cast<size_t>(MemberEnd() - last) * sizeof(Member));
        data_.o.size -= static_cast<SizeType>(last - first);
        return pos;
    }

    //! Erase a member in object by its name.
    /*! \param name Name of member to be removed.
        \return Whether the member existed.
        \note Linear time complexity.
    */
    bool EraseMember(const Ch* name) {
        GenericValue n(StringRef(name));
        return EraseMember(n);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool EraseMember(const std::basic_string<Ch>& name) { return EraseMember(GenericValue(StringRef(name))); }
#endif

    template <typename SourceAllocator>
    bool EraseMember(const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator m = FindMember(name);
        if (m != MemberEnd()) {
            EraseMember(m);
            return true;
        }
        else
            return false;
    }

    Object GetObject() { CEREAL_RAPIDJSON_ASSERT(IsObject()); return Object(*this); }
    ConstObject GetObject() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return ConstObject(*this); }

    //@}

    //!@name Array
    //@{

    //! Set this value as an empty array.
    /*! \post IsArray == true */
    GenericValue& SetArray() { this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }

    //! Get the number of elements in array.
    SizeType Size() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }

    //! Get the capacity of array.
    SizeType Capacity() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }

    //! Check whether the array is empty.
    bool Empty() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }

    //! Remove all elements in the array.
    /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged.
        \note Linear time complexity.
    */
    void Clear() {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        GenericValue* e = GetElementsPointer();
        for (GenericValue* v = e; v != e + data_.a.size; ++v)
            v->~GenericValue();
        data_.a.size = 0;
    }

    //! Get an element from array by index.
    /*! \pre IsArray() == true
        \param index Zero-based index of element.
        \see operator[](T*)
    */
    GenericValue& operator[](SizeType index) {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        CEREAL_RAPIDJSON_ASSERT(index < data_.a.size);
        return GetElementsPointer()[index];
    }
    const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }

    //! Element iterator
    /*! \pre IsArray() == true */
    ValueIterator Begin() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer(); }
    //! \em Past-the-end element iterator
    /*! \pre IsArray() == true */
    ValueIterator End() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return GetElementsPointer() + data_.a.size; }
    //! Constant element iterator
    /*! \pre IsArray() == true */
    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
    //! Constant \em past-the-end element iterator
    /*! \pre IsArray() == true */
    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }

    //! Request the array to have enough capacity to store elements.
    /*! \param newCapacity  The capacity that the array at least need to have.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \note Linear time complexity.
    */
    GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        if (newCapacity > data_.a.capacity) {
            SetElementsPointer(reinterpret_cast<GenericValue*>(allocator.Realloc(GetElementsPointer(), data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue))));
            data_.a.capacity = newCapacity;
        }
        return *this;
    }

    //! Append a GenericValue at the end of the array.
    /*! \param value        Value to be appended.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \pre IsArray() == true
        \post value.IsNull() == true
        \return The value itself for fluent API.
        \note The ownership of \c value will be transferred to this array on success.
        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
        \note Amortized constant time complexity.
    */
    GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        if (data_.a.size >= data_.a.capacity)
            Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
        GetElementsPointer()[data_.a.size++].RawAssign(value);
        return *this;
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericValue& PushBack(GenericValue&& value, Allocator& allocator) {
        return PushBack(value, allocator);
    }
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS

    //! Append a constant string reference at the end of the array.
    /*! \param value        Constant string reference to be appended.
        \param allocator    Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator().
        \pre IsArray() == true
        \return The value itself for fluent API.
        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
        \note Amortized constant time complexity.
        \see GenericStringRef
    */
    GenericValue& PushBack(StringRefType value, Allocator& allocator) {
        return (*this).template PushBack<StringRefType>(value, allocator);
    }

    //! Append a primitive value at the end of the array.
    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
        \param value Value of primitive type T to be appended.
        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
        \pre IsArray() == true
        \return The value itself for fluent API.
        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.

        \note The source type \c T explicitly disallows all pointer types,
            especially (\c const) \ref Ch*.  This helps avoiding implicitly
            referencing character strings with insufficient lifetime, use
            \ref PushBack(GenericValue&, Allocator&) or \ref
            PushBack(StringRefType, Allocator&).
            All other pointer types would implicitly convert to \c bool,
            use an explicit cast instead, if needed.
        \note Amortized constant time complexity.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
    PushBack(T value, Allocator& allocator) {
        GenericValue v(value);
        return PushBack(v, allocator);
    }

    //! Remove the last element in the array.
    /*!
        \note Constant time complexity.
    */
    GenericValue& PopBack() {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        CEREAL_RAPIDJSON_ASSERT(!Empty());
        GetElementsPointer()[--data_.a.size].~GenericValue();
        return *this;
    }

    //! Remove an element of array by iterator.
    /*!
        \param pos iterator to the element to remove
        \pre IsArray() == true && \ref Begin() <= \c pos < \ref End()
        \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned.
        \note Linear time complexity.
    */
    ValueIterator Erase(ConstValueIterator pos) {
        return Erase(pos, pos + 1);
    }

    //! Remove elements in the range [first, last) of the array.
    /*!
        \param first iterator to the first element to remove
        \param last  iterator following the last element to remove
        \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End()
        \return Iterator following the last removed element.
        \note Linear time complexity.
    */
    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
        CEREAL_RAPIDJSON_ASSERT(IsArray());
        CEREAL_RAPIDJSON_ASSERT(data_.a.size > 0);
        CEREAL_RAPIDJSON_ASSERT(GetElementsPointer() != 0);
        CEREAL_RAPIDJSON_ASSERT(first >= Begin());
        CEREAL_RAPIDJSON_ASSERT(first <= last);
        CEREAL_RAPIDJSON_ASSERT(last <= End());
        ValueIterator pos = Begin() + (first - Begin());
        for (ValueIterator itr = pos; itr != last; ++itr)
            itr->~GenericValue();
        std::memmove(static_cast<void*>(pos), last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
        data_.a.size -= static_cast<SizeType>(last - first);
        return pos;
    }

    Array GetArray() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return Array(*this); }
    ConstArray GetArray() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return ConstArray(*this); }

    //@}

    //!@name Number
    //@{

    int GetInt() const          { CEREAL_RAPIDJSON_ASSERT(data_.f.flags & kIntFlag);   return data_.n.i.i;   }
    unsigned GetUint() const    { CEREAL_RAPIDJSON_ASSERT(data_.f.flags & kUintFlag);  return data_.n.u.u;   }
    int64_t GetInt64() const    { CEREAL_RAPIDJSON_ASSERT(data_.f.flags & kInt64Flag); return data_.n.i64; }
    uint64_t GetUint64() const  { CEREAL_RAPIDJSON_ASSERT(data_.f.flags & kUint64Flag); return data_.n.u64; }

    //! Get the value as double type.
    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessDouble() to check whether the converison is lossless.
    */
    double GetDouble() const {
        CEREAL_RAPIDJSON_ASSERT(IsNumber());
        if ((data_.f.flags & kDoubleFlag) != 0)                return data_.n.d;   // exact type, no conversion.
        if ((data_.f.flags & kIntFlag) != 0)                   return data_.n.i.i; // int -> double
        if ((data_.f.flags & kUintFlag) != 0)                  return data_.n.u.u; // unsigned -> double
        if ((data_.f.flags & kInt64Flag) != 0)                 return static_cast<double>(data_.n.i64); // int64_t -> double (may lose precision)
        CEREAL_RAPIDJSON_ASSERT((data_.f.flags & kUint64Flag) != 0);  return static_cast<double>(data_.n.u64); // uint64_t -> double (may lose precision)
    }

    //! Get the value as float type.
    /*! \note If the value is 64-bit integer type, it may lose precision. Use \c IsLosslessFloat() to check whether the converison is lossless.
    */
    float GetFloat() const {
        return static_cast<float>(GetDouble());
    }

    GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }
    GenericValue& SetUint(unsigned u)       { this->~GenericValue(); new (this) GenericValue(u);    return *this; }
    GenericValue& SetInt64(int64_t i64)     { this->~GenericValue(); new (this) GenericValue(i64);  return *this; }
    GenericValue& SetUint64(uint64_t u64)   { this->~GenericValue(); new (this) GenericValue(u64);  return *this; }
    GenericValue& SetDouble(double d)       { this->~GenericValue(); new (this) GenericValue(d);    return *this; }
    GenericValue& SetFloat(float f)         { this->~GenericValue(); new (this) GenericValue(static_cast<double>(f)); return *this; }

    //@}

    //!@name String
    //@{

    const Ch* GetString() const { CEREAL_RAPIDJSON_ASSERT(IsString()); return (data_.f.flags & kInlineStrFlag) ? data_.ss.str : GetStringPointer(); }

    //! Get the length of string.
    /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength().
    */
    SizeType GetStringLength() const { CEREAL_RAPIDJSON_ASSERT(IsString()); return ((data_.f.flags & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }

    //! Set this value as a string without copying source string.
    /*! This version has better performance with supplied length, and also support string containing null character.
        \param s source string pointer.
        \param length The length of source string, excluding the trailing null terminator.
        \return The value itself for fluent API.
        \post IsString() == true && GetString() == s && GetStringLength() == length
        \see SetString(StringRefType)
    */
    GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); }

    //! Set this value as a string without copying source string.
    /*! \param s source string reference
        \return The value itself for fluent API.
        \post IsString() == true && GetString() == s && GetStringLength() == s.length
    */
    GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; }

    //! Set this value as a string by copying from source string.
    /*! This version has better performance with supplied length, and also support string containing null character.
        \param s source string.
        \param length The length of source string, excluding the trailing null terminator.
        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
    */
    GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { return SetString(StringRef(s, length), allocator); }

    //! Set this value as a string by copying from source string.
    /*! \param s source string.
        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
    */
    GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(StringRef(s), allocator); }

    //! Set this value as a string by copying from source string.
    /*! \param s source string reference
        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \post IsString() == true && GetString() != s.s && strcmp(GetString(),s) == 0 && GetStringLength() == length
    */
    GenericValue& SetString(StringRefType s, Allocator& allocator) { this->~GenericValue(); SetStringRaw(s, allocator); return *this; }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Set this value as a string by copying from source string.
    /*! \param s source string.
        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
        \return The value itself for fluent API.
        \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()
        \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
    */
    GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(StringRef(s), allocator); }
#endif

    //@}

    //!@name Array
    //@{

    //! Templated version for checking whether this value is type T.
    /*!
        \tparam T Either \c bool, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c float, \c const \c char*, \c std::basic_string<Ch>
    */
    template <typename T>
    bool Is() const { return internal::TypeHelper<ValueType, T>::Is(*this); }

    template <typename T>
    T Get() const { return internal::TypeHelper<ValueType, T>::Get(*this); }

    template <typename T>
    T Get() { return internal::TypeHelper<ValueType, T>::Get(*this); }

    template<typename T>
    ValueType& Set(const T& data) { return internal::TypeHelper<ValueType, T>::Set(*this, data); }

    template<typename T>
    ValueType& Set(const T& data, AllocatorType& allocator) { return internal::TypeHelper<ValueType, T>::Set(*this, data, allocator); }

    //@}

    //! Generate events of this value to a Handler.
    /*! This function adopts the GoF visitor pattern.
        Typical usage is to output this JSON value as JSON text via Writer, which is a Handler.
        It can also be used to deep clone this value via GenericDocument, which is also a Handler.
        \tparam Handler type of handler.
        \param handler An object implementing concept Handler.
    */
    template <typename Handler>
    bool Accept(Handler& handler) const {
        switch(GetType()) {
        case kNullType:     return handler.Null();
        case kFalseType:    return handler.Bool(false);
        case kTrueType:     return handler.Bool(true);

        case kObjectType:
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.StartObject()))
                return false;
            for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
                CEREAL_RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
                if (CEREAL_RAPIDJSON_UNLIKELY(!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.data_.f.flags & kCopyFlag) != 0)))
                    return false;
                if (CEREAL_RAPIDJSON_UNLIKELY(!m->value.Accept(handler)))
                    return false;
            }
            return handler.EndObject(data_.o.size);

        case kArrayType:
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.StartArray()))
                return false;
            for (const GenericValue* v = Begin(); v != End(); ++v)
                if (CEREAL_RAPIDJSON_UNLIKELY(!v->Accept(handler)))
                    return false;
            return handler.EndArray(data_.a.size);

        case kStringType:
            return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);

        default:
            CEREAL_RAPIDJSON_ASSERT(GetType() == kNumberType);
            if (IsDouble())         return handler.Double(data_.n.d);
            else if (IsInt())       return handler.Int(data_.n.i.i);
            else if (IsUint())      return handler.Uint(data_.n.u.u);
            else if (IsInt64())     return handler.Int64(data_.n.i64);
            else                    return handler.Uint64(data_.n.u64);
        }
    }

private:
    template <typename, typename> friend class GenericValue;
    template <typename, typename, typename> friend class GenericDocument;

    enum {
        kBoolFlag       = 0x0008,
        kNumberFlag     = 0x0010,
        kIntFlag        = 0x0020,
        kUintFlag       = 0x0040,
        kInt64Flag      = 0x0080,
        kUint64Flag     = 0x0100,
        kDoubleFlag     = 0x0200,
        kStringFlag     = 0x0400,
        kCopyFlag       = 0x0800,
        kInlineStrFlag  = 0x1000,

        // Initial flags of different types.
        kNullFlag = kNullType,
        kTrueFlag = kTrueType | kBoolFlag,
        kFalseFlag = kFalseType | kBoolFlag,
        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
        kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
        kConstStringFlag = kStringType | kStringFlag,
        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
        kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
        kObjectFlag = kObjectType,
        kArrayFlag = kArrayType,

        kTypeMask = 0x07
    };

    static const SizeType kDefaultArrayCapacity = 16;
    static const SizeType kDefaultObjectCapacity = 16;

    struct Flag {
#if CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION
        char payload[sizeof(SizeType) * 2 + 6];     // 2 x SizeType + lower 48-bit pointer
#elif CEREAL_RAPIDJSON_64BIT
        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 6]; // 6 padding bytes
#else
        char payload[sizeof(SizeType) * 2 + sizeof(void*) + 2]; // 2 padding bytes
#endif
        uint16_t flags;
    };

    struct String {
        SizeType length;
        SizeType hashcode;  //!< reserved
        const Ch* str;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

    // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars
    // (excluding the terminating zero) and store a value to determine the length of the contained
    // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string
    // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as
    // the string terminator as well. For getting the string length back from that value just use
    // "MaxSize - str[LenPos]".
    // This allows to store 13-chars strings in 32-bit mode, 21-chars strings in 64-bit mode,
    // 13-chars strings for CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION=1 inline (for `UTF8`-encoded strings).
    struct ShortString {
        enum { MaxChars = sizeof(static_cast<Flag*>(0)->payload) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
        Ch str[MaxChars];

        inline static bool Usable(SizeType len) { return                       (MaxSize >= len); }
        inline void     SetLength(SizeType len) { str[LenPos] = static_cast<Ch>(MaxSize -  len); }
        inline SizeType GetLength() const       { return  static_cast<SizeType>(MaxSize -  str[LenPos]); }
    };  // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

    // By using proper binary layout, retrieval of different integer types do not need conversions.
    union Number {
#if CEREAL_RAPIDJSON_ENDIAN == CEREAL_RAPIDJSON_LITTLEENDIAN
        struct I {
            int i;
            char padding[4];
        }i;
        struct U {
            unsigned u;
            char padding2[4];
        }u;
#else
        struct I {
            char padding[4];
            int i;
        }i;
        struct U {
            char padding2[4];
            unsigned u;
        }u;
#endif
        int64_t i64;
        uint64_t u64;
        double d;
    };  // 8 bytes

    struct ObjectData {
        SizeType size;
        SizeType capacity;
        Member* members;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

    struct ArrayData {
        SizeType size;
        SizeType capacity;
        GenericValue* elements;
    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode

    union Data {
        String s;
        ShortString ss;
        Number n;
        ObjectData o;
        ArrayData a;
        Flag f;
    };  // 16 bytes in 32-bit mode, 24 bytes in 64-bit mode, 16 bytes in 64-bit with CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION

    CEREAL_RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return CEREAL_RAPIDJSON_GETPOINTER(Ch, data_.s.str); }
    CEREAL_RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) { return CEREAL_RAPIDJSON_SETPOINTER(Ch, data_.s.str, str); }
    CEREAL_RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { return CEREAL_RAPIDJSON_GETPOINTER(GenericValue, data_.a.elements); }
    CEREAL_RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericValue* elements) { return CEREAL_RAPIDJSON_SETPOINTER(GenericValue, data_.a.elements, elements); }
    CEREAL_RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return CEREAL_RAPIDJSON_GETPOINTER(Member, data_.o.members); }
    CEREAL_RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) { return CEREAL_RAPIDJSON_SETPOINTER(Member, data_.o.members, members); }

    // Initialize this value as array with initial data, without calling destructor.
    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
        data_.f.flags = kArrayFlag;
        if (count) {
            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
            SetElementsPointer(e);
            std::memcpy(static_cast<void*>(e), values, count * sizeof(GenericValue));
        }
        else
            SetElementsPointer(0);
        data_.a.size = data_.a.capacity = count;
    }

    //! Initialize this value as object with initial data, without calling destructor.
    void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
        data_.f.flags = kObjectFlag;
        if (count) {
            Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
            SetMembersPointer(m);
            std::memcpy(static_cast<void*>(m), members, count * sizeof(Member));
        }
        else
            SetMembersPointer(0);
        data_.o.size = data_.o.capacity = count;
    }

    //! Initialize this value as constant string, without calling destructor.
    void SetStringRaw(StringRefType s) CEREAL_RAPIDJSON_NOEXCEPT {
        data_.f.flags = kConstStringFlag;
        SetStringPointer(s);
        data_.s.length = s.length;
    }

    //! Initialize this value as copy string with initial data, without calling destructor.
    void SetStringRaw(StringRefType s, Allocator& allocator) {
        Ch* str = 0;
        if (ShortString::Usable(s.length)) {
            data_.f.flags = kShortStringFlag;
            data_.ss.SetLength(s.length);
            str = data_.ss.str;
        } else {
            data_.f.flags = kCopyStringFlag;
            data_.s.length = s.length;
            str = static_cast<Ch *>(allocator.Malloc((s.length + 1) * sizeof(Ch)));
            SetStringPointer(str);
        }
        std::memcpy(str, s, s.length * sizeof(Ch));
        str[s.length] = '\0';
    }

    //! Assignment without calling destructor
    void RawAssign(GenericValue& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
        data_ = rhs.data_;
        // data_.f.flags = rhs.data_.f.flags;
        rhs.data_.f.flags = kNullFlag;
    }

    template <typename SourceAllocator>
    bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
        CEREAL_RAPIDJSON_ASSERT(IsString());
        CEREAL_RAPIDJSON_ASSERT(rhs.IsString());

        const SizeType len1 = GetStringLength();
        const SizeType len2 = rhs.GetStringLength();
        if(len1 != len2) { return false; }

        const Ch* const str1 = GetString();
        const Ch* const str2 = rhs.GetString();
        if(str1 == str2) { return true; } // fast path for constant string

        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
    }

    Data data_;
};

//! GenericValue with UTF8 encoding
typedef GenericValue<UTF8<> > Value;

///////////////////////////////////////////////////////////////////////////////
// GenericDocument

//! A document for parsing JSON text as DOM.
/*!
    \note implements Handler concept
    \tparam Encoding Encoding for both parsing and string storage.
    \tparam Allocator Allocator for allocating memory for the DOM
    \tparam StackAllocator Allocator for allocating memory for stack during parsing.
    \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor.  To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue.
*/
template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator>
class GenericDocument : public GenericValue<Encoding, Allocator> {
public:
    typedef typename Encoding::Ch Ch;                       //!< Character type derived from Encoding.
    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of the document.
    typedef Allocator AllocatorType;                        //!< Allocator type from template parameter.

    //! Constructor
    /*! Creates an empty document of specified type.
        \param type             Mandatory type of object to create.
        \param allocator        Optional allocator for allocating memory.
        \param stackCapacity    Optional initial capacity of stack in bytes.
        \param stackAllocator   Optional allocator for allocating memory for stack.
    */
    explicit GenericDocument(Type type, Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
        GenericValue<Encoding, Allocator>(type),  allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
    {
        if (!allocator_)
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
    }

    //! Constructor
    /*! Creates an empty document which type is Null.
        \param allocator        Optional allocator for allocating memory.
        \param stackCapacity    Optional initial capacity of stack in bytes.
        \param stackAllocator   Optional allocator for allocating memory for stack.
    */
    GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
        allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
    {
        if (!allocator_)
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Move constructor in C++11
    GenericDocument(GenericDocument&& rhs) CEREAL_RAPIDJSON_NOEXCEPT
        : ValueType(std::forward<ValueType>(rhs)), // explicit cast to avoid prohibited move from Document
          allocator_(rhs.allocator_),
          ownAllocator_(rhs.ownAllocator_),
          stack_(std::move(rhs.stack_)),
          parseResult_(rhs.parseResult_)
    {
        rhs.allocator_ = 0;
        rhs.ownAllocator_ = 0;
        rhs.parseResult_ = ParseResult();
    }
#endif

    ~GenericDocument() {
        Destroy();
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Move assignment in C++11
    GenericDocument& operator=(GenericDocument&& rhs) CEREAL_RAPIDJSON_NOEXCEPT
    {
        // The cast to ValueType is necessary here, because otherwise it would
        // attempt to call GenericValue's templated assignment operator.
        ValueType::operator=(std::forward<ValueType>(rhs));

        // Calling the destructor here would prematurely call stack_'s destructor
        Destroy();

        allocator_ = rhs.allocator_;
        ownAllocator_ = rhs.ownAllocator_;
        stack_ = std::move(rhs.stack_);
        parseResult_ = rhs.parseResult_;

        rhs.allocator_ = 0;
        rhs.ownAllocator_ = 0;
        rhs.parseResult_ = ParseResult();

        return *this;
    }
#endif

    //! Exchange the contents of this document with those of another.
    /*!
        \param rhs Another document.
        \note Constant complexity.
        \see GenericValue::Swap
    */
    GenericDocument& Swap(GenericDocument& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
        ValueType::Swap(rhs);
        stack_.Swap(rhs.stack_);
        internal::Swap(allocator_, rhs.allocator_);
        internal::Swap(ownAllocator_, rhs.ownAllocator_);
        internal::Swap(parseResult_, rhs.parseResult_);
        return *this;
    }

    // Allow Swap with ValueType.
    // Refer to Effective C++ 3rd Edition/Item 33: Avoid hiding inherited names.
    using ValueType::Swap;

    //! free-standing swap function helper
    /*!
        Helper function to enable support for common swap implementation pattern based on \c std::swap:
        \code
        void swap(MyClass& a, MyClass& b) {
            using std::swap;
            swap(a.doc, b.doc);
            // ...
        }
        \endcode
        \see Swap()
     */
    friend inline void swap(GenericDocument& a, GenericDocument& b) CEREAL_RAPIDJSON_NOEXCEPT { a.Swap(b); }

    //! Populate this document by a generator which produces SAX events.
    /*! \tparam Generator A functor with <tt>bool f(Handler)</tt> prototype.
        \param g Generator functor which sends SAX events to the parameter.
        \return The document itself for fluent API.
    */
    template <typename Generator>
    GenericDocument& Populate(Generator& g) {
        ClearStackOnExit scope(*this);
        if (g(*this)) {
            CEREAL_RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
        }
        return *this;
    }

    //!@name Parse from stream
    //!@{

    //! Parse JSON text from an input stream (with Encoding conversion)
    /*! \tparam parseFlags Combination of \ref ParseFlag.
        \tparam SourceEncoding Encoding of input stream
        \tparam InputStream Type of input stream, implementing Stream concept
        \param is Input stream to be parsed.
        \return The document itself for fluent API.
    */
    template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
    GenericDocument& ParseStream(InputStream& is) {
        GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
            stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
        ClearStackOnExit scope(*this);
        parseResult_ = reader.template Parse<parseFlags>(is, *this);
        if (parseResult_) {
            CEREAL_RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
            ValueType::operator=(*stack_.template Pop<ValueType>(1));// Move value from stack to document
        }
        return *this;
    }

    //! Parse JSON text from an input stream
    /*! \tparam parseFlags Combination of \ref ParseFlag.
        \tparam InputStream Type of input stream, implementing Stream concept
        \param is Input stream to be parsed.
        \return The document itself for fluent API.
    */
    template <unsigned parseFlags, typename InputStream>
    GenericDocument& ParseStream(InputStream& is) {
        return ParseStream<parseFlags, Encoding, InputStream>(is);
    }

    //! Parse JSON text from an input stream (with \ref kParseDefaultFlags)
    /*! \tparam InputStream Type of input stream, implementing Stream concept
        \param is Input stream to be parsed.
        \return The document itself for fluent API.
    */
    template <typename InputStream>
    GenericDocument& ParseStream(InputStream& is) {
        return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
    }
    //!@}

    //!@name Parse in-place from mutable string
    //!@{

    //! Parse JSON text from a mutable string
    /*! \tparam parseFlags Combination of \ref ParseFlag.
        \param str Mutable zero-terminated string to be parsed.
        \return The document itself for fluent API.
    */
    template <unsigned parseFlags>
    GenericDocument& ParseInsitu(Ch* str) {
        GenericInsituStringStream<Encoding> s(str);
        return ParseStream<parseFlags | kParseInsituFlag>(s);
    }

    //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags)
    /*! \param str Mutable zero-terminated string to be parsed.
        \return The document itself for fluent API.
    */
    GenericDocument& ParseInsitu(Ch* str) {
        return ParseInsitu<kParseDefaultFlags>(str);
    }
    //!@}

    //!@name Parse from read-only string
    //!@{

    //! Parse JSON text from a read-only string (with Encoding conversion)
    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
        \tparam SourceEncoding Transcoding from input Encoding
        \param str Read-only zero-terminated string to be parsed.
    */
    template <unsigned parseFlags, typename SourceEncoding>
    GenericDocument& Parse(const typename SourceEncoding::Ch* str) {
        CEREAL_RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
        GenericStringStream<SourceEncoding> s(str);
        return ParseStream<parseFlags, SourceEncoding>(s);
    }

    //! Parse JSON text from a read-only string
    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
        \param str Read-only zero-terminated string to be parsed.
    */
    template <unsigned parseFlags>
    GenericDocument& Parse(const Ch* str) {
        return Parse<parseFlags, Encoding>(str);
    }

    //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags)
    /*! \param str Read-only zero-terminated string to be parsed.
    */
    GenericDocument& Parse(const Ch* str) {
        return Parse<kParseDefaultFlags>(str);
    }

    template <unsigned parseFlags, typename SourceEncoding>
    GenericDocument& Parse(const typename SourceEncoding::Ch* str, size_t length) {
        CEREAL_RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
        MemoryStream ms(reinterpret_cast<const char*>(str), length * sizeof(typename SourceEncoding::Ch));
        EncodedInputStream<SourceEncoding, MemoryStream> is(ms);
        ParseStream<parseFlags, SourceEncoding>(is);
        return *this;
    }

    template <unsigned parseFlags>
    GenericDocument& Parse(const Ch* str, size_t length) {
        return Parse<parseFlags, Encoding>(str, length);
    }

    GenericDocument& Parse(const Ch* str, size_t length) {
        return Parse<kParseDefaultFlags>(str, length);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    template <unsigned parseFlags, typename SourceEncoding>
    GenericDocument& Parse(const std::basic_string<typename SourceEncoding::Ch>& str) {
        // c_str() is constant complexity according to standard. Should be faster than Parse(const char*, size_t)
        return Parse<parseFlags, SourceEncoding>(str.c_str());
    }

    template <unsigned parseFlags>
    GenericDocument& Parse(const std::basic_string<Ch>& str) {
        return Parse<parseFlags, Encoding>(str.c_str());
    }

    GenericDocument& Parse(const std::basic_string<Ch>& str) {
        return Parse<kParseDefaultFlags>(str);
    }
#endif // CEREAL_RAPIDJSON_HAS_STDSTRING

    //!@}

    //!@name Handling parse errors
    //!@{

    //! Whether a parse error has occurred in the last parsing.
    bool HasParseError() const { return parseResult_.IsError(); }

    //! Get the \ref ParseErrorCode of last parsing.
    ParseErrorCode GetParseError() const { return parseResult_.Code(); }

    //! Get the position of last parsing error in input, 0 otherwise.
    size_t GetErrorOffset() const { return parseResult_.Offset(); }

    //! Implicit conversion to get the last parse result
#ifndef __clang // -Wdocumentation
    /*! \return \ref ParseResult of the last parse operation

        \code
          Document doc;
          ParseResult ok = doc.Parse(json);
          if (!ok)
            printf( "JSON parse error: %s (%u)\n", GetParseError_En(ok.Code()), ok.Offset());
        \endcode
     */
#endif
    operator ParseResult() const { return parseResult_; }
    //!@}

    //! Get the allocator of this document.
    Allocator& GetAllocator() {
        CEREAL_RAPIDJSON_ASSERT(allocator_);
        return *allocator_;
    }

    //! Get the capacity of stack in bytes.
    size_t GetStackCapacity() const { return stack_.GetCapacity(); }

private:
    // clear stack on any exit from ParseStream, e.g. due to exception
    struct ClearStackOnExit {
        explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
        ~ClearStackOnExit() { d_.ClearStack(); }
    private:
        ClearStackOnExit(const ClearStackOnExit&);
        ClearStackOnExit& operator=(const ClearStackOnExit&);
        GenericDocument& d_;
    };

    // callers of the following private Handler functions
    // template <typename,typename,typename> friend class GenericReader; // for parsing
    template <typename, typename> friend class GenericValue; // for deep copying

public:
    // Implementation of Handler
    bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
    bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
    bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
    bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
    bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
    bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
    bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }

    bool RawNumber(const Ch* str, SizeType length, bool copy) {
        if (copy)
            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
        else
            new (stack_.template Push<ValueType>()) ValueType(str, length);
        return true;
    }

    bool String(const Ch* str, SizeType length, bool copy) {
        if (copy)
            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
        else
            new (stack_.template Push<ValueType>()) ValueType(str, length);
        return true;
    }

    bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }

    bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }

    bool EndObject(SizeType memberCount) {
        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
        stack_.template Top<ValueType>()->SetObjectRaw(members, memberCount, GetAllocator());
        return true;
    }

    bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }

    bool EndArray(SizeType elementCount) {
        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
        return true;
    }

private:
    //! Prohibit copying
    GenericDocument(const GenericDocument&);
    //! Prohibit assignment
    GenericDocument& operator=(const GenericDocument&);

    void ClearStack() {
        if (Allocator::kNeedFree)
            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
                (stack_.template Pop<ValueType>(1))->~ValueType();
        else
            stack_.Clear();
        stack_.ShrinkToFit();
    }

    void Destroy() {
        CEREAL_RAPIDJSON_DELETE(ownAllocator_);
    }

    static const size_t kDefaultStackCapacity = 1024;
    Allocator* allocator_;
    Allocator* ownAllocator_;
    internal::Stack<StackAllocator> stack_;
    ParseResult parseResult_;
};

//! GenericDocument with UTF8 encoding
typedef GenericDocument<UTF8<> > Document;

//! Helper class for accessing Value of array type.
/*!
    Instance of this helper class is obtained by \c GenericValue::GetArray().
    In addition to all APIs for array type, it provides range-based for loop if \c CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
*/
template <bool Const, typename ValueT>
class GenericArray {
public:
    typedef GenericArray<true, ValueT> ConstArray;
    typedef GenericArray<false, ValueT> Array;
    typedef ValueT PlainType;
    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
    typedef ValueType* ValueIterator;  // This may be const or non-const iterator
    typedef const ValueT* ConstValueIterator;
    typedef typename ValueType::AllocatorType AllocatorType;
    typedef typename ValueType::StringRefType StringRefType;

    template <typename, typename>
    friend class GenericValue;

    GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
    GenericArray& operator=(const GenericArray& rhs) { value_ = rhs.value_; return *this; }
    ~GenericArray() {}

    SizeType Size() const { return value_.Size(); }
    SizeType Capacity() const { return value_.Capacity(); }
    bool Empty() const { return value_.Empty(); }
    void Clear() const { value_.Clear(); }
    ValueType& operator[](SizeType index) const {  return value_[index]; }
    ValueIterator Begin() const { return value_.Begin(); }
    ValueIterator End() const { return value_.End(); }
    GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) const { value_.Reserve(newCapacity, allocator); return *this; }
    GenericArray PushBack(ValueType& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericArray PushBack(StringRefType value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
    template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (const GenericArray&)) PushBack(T value, AllocatorType& allocator) const { value_.PushBack(value, allocator); return *this; }
    GenericArray PopBack() const { value_.PopBack(); return *this; }
    ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(pos); }
    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) const { return value_.Erase(first, last); }

#if CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR
    ValueIterator begin() const { return value_.Begin(); }
    ValueIterator end() const { return value_.End(); }
#endif

private:
    GenericArray();
    GenericArray(ValueType& value) : value_(value) {}
    ValueType& value_;
};

//! Helper class for accessing Value of object type.
/*!
    Instance of this helper class is obtained by \c GenericValue::GetObject().
    In addition to all APIs for array type, it provides range-based for loop if \c CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR=1.
*/
template <bool Const, typename ValueT>
class GenericObject {
public:
    typedef GenericObject<true, ValueT> ConstObject;
    typedef GenericObject<false, ValueT> Object;
    typedef ValueT PlainType;
    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
    typedef GenericMemberIterator<Const, typename ValueT::EncodingType, typename ValueT::AllocatorType> MemberIterator;  // This may be const or non-const iterator
    typedef GenericMemberIterator<true, typename ValueT::EncodingType, typename ValueT::AllocatorType> ConstMemberIterator;
    typedef typename ValueType::AllocatorType AllocatorType;
    typedef typename ValueType::StringRefType StringRefType;
    typedef typename ValueType::EncodingType EncodingType;
    typedef typename ValueType::Ch Ch;

    template <typename, typename>
    friend class GenericValue;

    GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
    GenericObject& operator=(const GenericObject& rhs) { value_ = rhs.value_; return *this; }
    ~GenericObject() {}

    SizeType MemberCount() const { return value_.MemberCount(); }
    SizeType MemberCapacity() const { return value_.MemberCapacity(); }
    bool ObjectEmpty() const { return value_.ObjectEmpty(); }
    template <typename T> ValueType& operator[](T* name) const { return value_[name]; }
    template <typename SourceAllocator> ValueType& operator[](const GenericValue<EncodingType, SourceAllocator>& name) const { return value_[name]; }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    ValueType& operator[](const std::basic_string<Ch>& name) const { return value_[name]; }
#endif
    MemberIterator MemberBegin() const { return value_.MemberBegin(); }
    MemberIterator MemberEnd() const { return value_.MemberEnd(); }
    GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocator) const { value_.MemberReserve(newCapacity, allocator); return *this; }
    bool HasMember(const Ch* name) const { return value_.HasMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool HasMember(const std::basic_string<Ch>& name) const { return value_.HasMember(name); }
#endif
    template <typename SourceAllocator> bool HasMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.HasMember(name); }
    MemberIterator FindMember(const Ch* name) const { return value_.FindMember(name); }
    template <typename SourceAllocator> MemberIterator FindMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.FindMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    MemberIterator FindMember(const std::basic_string<Ch>& name) const { return value_.FindMember(name); }
#endif
    GenericObject AddMember(ValueType& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    GenericObject AddMember(ValueType& name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#endif
    template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&)) AddMember(ValueType& name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    GenericObject AddMember(StringRefType name, ValueType&& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericObject AddMember(StringRefType name, ValueType& value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    GenericObject AddMember(StringRefType name, StringRefType value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    template <typename T> CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericObject)) AddMember(StringRefType name, T value, AllocatorType& allocator) const { value_.AddMember(name, value, allocator); return *this; }
    void RemoveAllMembers() { value_.RemoveAllMembers(); }
    bool RemoveMember(const Ch* name) const { return value_.RemoveMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool RemoveMember(const std::basic_string<Ch>& name) const { return value_.RemoveMember(name); }
#endif
    template <typename SourceAllocator> bool RemoveMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.RemoveMember(name); }
    MemberIterator RemoveMember(MemberIterator m) const { return value_.RemoveMember(m); }
    MemberIterator EraseMember(ConstMemberIterator pos) const { return value_.EraseMember(pos); }
    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) const { return value_.EraseMember(first, last); }
    bool EraseMember(const Ch* name) const { return value_.EraseMember(name); }
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool EraseMember(const std::basic_string<Ch>& name) const { return EraseMember(ValueType(StringRef(name))); }
#endif
    template <typename SourceAllocator> bool EraseMember(const GenericValue<EncodingType, SourceAllocator>& name) const { return value_.EraseMember(name); }

#if CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR
    MemberIterator begin() const { return value_.MemberBegin(); }
    MemberIterator end() const { return value_.MemberEnd(); }
#endif

private:
    GenericObject();
    GenericObject(ValueType& value) : value_(value) {}
    ValueType& value_;
};

CEREAL_RAPIDJSON_NAMESPACE_END
CEREAL_RAPIDJSON_DIAG_POP

#endif // CEREAL_RAPIDJSON_DOCUMENT_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/encodedstream.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ENCODEDSTREAM_H_
#define CEREAL_RAPIDJSON_ENCODEDSTREAM_H_

#include "stream.h"
#include "memorystream.h"

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Input byte stream wrapper with a statically bound encoding.
/*!
    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
*/
template <typename Encoding, typename InputByteStream>
class EncodedInputStream {
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
    typedef typename Encoding::Ch Ch;

    EncodedInputStream(InputByteStream& is) : is_(is) { 
        current_ = Encoding::TakeBOM(is_);
    }

    Ch Peek() const { return current_; }
    Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
    size_t Tell() const { return is_.Tell(); }

    // Not implemented
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    EncodedInputStream(const EncodedInputStream&);
    EncodedInputStream& operator=(const EncodedInputStream&);

    InputByteStream& is_;
    Ch current_;
};

//! Specialized for UTF8 MemoryStream.
template <>
class EncodedInputStream<UTF8<>, MemoryStream> {
public:
    typedef UTF8<>::Ch Ch;

    EncodedInputStream(MemoryStream& is) : is_(is) {
        if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
        if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
        if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
    }
    Ch Peek() const { return is_.Peek(); }
    Ch Take() { return is_.Take(); }
    size_t Tell() const { return is_.Tell(); }

    // Not implemented
    void Put(Ch) {}
    void Flush() {} 
    Ch* PutBegin() { return 0; }
    size_t PutEnd(Ch*) { return 0; }

    MemoryStream& is_;

private:
    EncodedInputStream(const EncodedInputStream&);
    EncodedInputStream& operator=(const EncodedInputStream&);
};

//! Output byte stream wrapper with statically bound encoding.
/*!
    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
*/
template <typename Encoding, typename OutputByteStream>
class EncodedOutputStream {
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
    typedef typename Encoding::Ch Ch;

    EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { 
        if (putBOM)
            Encoding::PutBOM(os_);
    }

    void Put(Ch c) { Encoding::Put(os_, c);  }
    void Flush() { os_.Flush(); }

    // Not implemented
    Ch Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
    Ch Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
    size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false);  return 0; }
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    EncodedOutputStream(const EncodedOutputStream&);
    EncodedOutputStream& operator=(const EncodedOutputStream&);

    OutputByteStream& os_;
};

#define CEREAL_RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x

//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
    \tparam CharType Type of character for reading.
    \tparam InputByteStream type of input byte stream to be wrapped.
*/
template <typename CharType, typename InputByteStream>
class AutoUTFInputStream {
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
    typedef CharType Ch;

    //! Constructor.
    /*!
        \param is input stream to be wrapped.
        \param type UTF encoding type if it is not detected from the stream.
    */
    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
        CEREAL_RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
        DetectType();
        static const TakeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Take) };
        takeFunc_ = f[type_];
        current_ = takeFunc_(*is_);
    }

    UTFType GetType() const { return type_; }
    bool HasBOM() const { return hasBOM_; }

    Ch Peek() const { return current_; }
    Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
    size_t Tell() const { return is_->Tell(); }

    // Not implemented
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    AutoUTFInputStream(const AutoUTFInputStream&);
    AutoUTFInputStream& operator=(const AutoUTFInputStream&);

    // Detect encoding type with BOM or RFC 4627
    void DetectType() {
        // BOM (Byte Order Mark):
        // 00 00 FE FF  UTF-32BE
        // FF FE 00 00  UTF-32LE
        // FE FF        UTF-16BE
        // FF FE        UTF-16LE
        // EF BB BF     UTF-8

        const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
        if (!c)
            return;

        unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
        hasBOM_ = false;
        if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
        else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
        else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
        else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
        else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }

        // RFC 4627: Section 3
        // "Since the first two characters of a JSON text will always be ASCII
        // characters [RFC0020], it is possible to determine whether an octet
        // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
        // at the pattern of nulls in the first four octets."
        // 00 00 00 xx  UTF-32BE
        // 00 xx 00 xx  UTF-16BE
        // xx 00 00 00  UTF-32LE
        // xx 00 xx 00  UTF-16LE
        // xx xx xx xx  UTF-8

        if (!hasBOM_) {
            int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
            switch (pattern) {
            case 0x08: type_ = kUTF32BE; break;
            case 0x0A: type_ = kUTF16BE; break;
            case 0x01: type_ = kUTF32LE; break;
            case 0x05: type_ = kUTF16LE; break;
            case 0x0F: type_ = kUTF8;    break;
            default: break; // Use type defined by user.
            }
        }

        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
        if (type_ == kUTF16LE || type_ == kUTF16BE) CEREAL_RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
        if (type_ == kUTF32LE || type_ == kUTF32BE) CEREAL_RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
    }

    typedef Ch (*TakeFunc)(InputByteStream& is);
    InputByteStream* is_;
    UTFType type_;
    Ch current_;
    TakeFunc takeFunc_;
    bool hasBOM_;
};

//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
    \tparam CharType Type of character for writing.
    \tparam OutputByteStream type of output byte stream to be wrapped.
*/
template <typename CharType, typename OutputByteStream>
class AutoUTFOutputStream {
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
    typedef CharType Ch;

    //! Constructor.
    /*!
        \param os output stream to be wrapped.
        \param type UTF encoding type.
        \param putBOM Whether to write BOM at the beginning of the stream.
    */
    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
        CEREAL_RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);

        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
        if (type_ == kUTF16LE || type_ == kUTF16BE) CEREAL_RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
        if (type_ == kUTF32LE || type_ == kUTF32BE) CEREAL_RAPIDJSON_ASSERT(sizeof(Ch) >= 4);

        static const PutFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Put) };
        putFunc_ = f[type_];

        if (putBOM)
            PutBOM();
    }

    UTFType GetType() const { return type_; }

    void Put(Ch c) { putFunc_(*os_, c); }
    void Flush() { os_->Flush(); } 

    // Not implemented
    Ch Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
    Ch Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
    size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    AutoUTFOutputStream(const AutoUTFOutputStream&);
    AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);

    void PutBOM() { 
        typedef void (*PutBOMFunc)(OutputByteStream&);
        static const PutBOMFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
        f[type_](*os_);
    }

    typedef void (*PutFunc)(OutputByteStream&, Ch);

    OutputByteStream* os_;
    UTFType type_;
    PutFunc putFunc_;
};

#undef CEREAL_RAPIDJSON_ENCODINGS_FUNC

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_FILESTREAM_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/encodings.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ENCODINGS_H_
#define CEREAL_RAPIDJSON_ENCODINGS_H_

#include "rapidjson.h"

#if defined(_MSC_VER) && !defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
CEREAL_RAPIDJSON_DIAG_OFF(4702)  // unreachable code
#elif defined(__GNUC__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
CEREAL_RAPIDJSON_DIAG_OFF(overflow)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// Encoding

/*! \class rapidjson::Encoding
    \brief Concept for encoding of Unicode characters.

\code
concept Encoding {
    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.

    enum { supportUnicode = 1 }; // or 0 if not supporting unicode

    //! \brief Encode a Unicode codepoint to an output stream.
    //! \param os Output stream.
    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
    template<typename OutputStream>
    static void Encode(OutputStream& os, unsigned codepoint);

    //! \brief Decode a Unicode codepoint from an input stream.
    //! \param is Input stream.
    //! \param codepoint Output of the unicode codepoint.
    //! \return true if a valid codepoint can be decoded from the stream.
    template <typename InputStream>
    static bool Decode(InputStream& is, unsigned* codepoint);

    //! \brief Validate one Unicode codepoint from an encoded stream.
    //! \param is Input stream to obtain codepoint.
    //! \param os Output for copying one codepoint.
    //! \return true if it is valid.
    //! \note This function just validating and copying the codepoint without actually decode it.
    template <typename InputStream, typename OutputStream>
    static bool Validate(InputStream& is, OutputStream& os);

    // The following functions are deal with byte streams.

    //! Take a character from input byte stream, skip BOM if exist.
    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is);

    //! Take a character from input byte stream.
    template <typename InputByteStream>
    static Ch Take(InputByteStream& is);

    //! Put BOM to output byte stream.
    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os);

    //! Put a character to output byte stream.
    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, Ch c);
};
\endcode
*/

///////////////////////////////////////////////////////////////////////////////
// UTF8

//! UTF-8 encoding.
/*! http://en.wikipedia.org/wiki/UTF-8
    http://tools.ietf.org/html/rfc3629
    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
    \note implements Encoding concept
*/
template<typename CharType = char>
struct UTF8 {
    typedef CharType Ch;

    enum { supportUnicode = 1 };

    template<typename OutputStream>
    static void Encode(OutputStream& os, unsigned codepoint) {
        if (codepoint <= 0x7F) 
            os.Put(static_cast<Ch>(codepoint & 0xFF));
        else if (codepoint <= 0x7FF) {
            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
        }
        else if (codepoint <= 0xFFFF) {
            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
        }
    }

    template<typename OutputStream>
    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
        if (codepoint <= 0x7F) 
            PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
        else if (codepoint <= 0x7FF) {
            PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
        }
        else if (codepoint <= 0xFFFF) {
            PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
        }
    }

    template <typename InputStream>
    static bool Decode(InputStream& is, unsigned* codepoint) {
#define CEREAL_RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
#define CEREAL_RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
#define CEREAL_RAPIDJSON_TAIL() CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x70)
        typename InputStream::Ch c = is.Take();
        if (!(c & 0x80)) {
            *codepoint = static_cast<unsigned char>(c);
            return true;
        }

        unsigned char type = GetRange(static_cast<unsigned char>(c));
        if (type >= 32) {
            *codepoint = 0;
        } else {
            *codepoint = (0xFFu >> type) & static_cast<unsigned char>(c);
        }
        bool result = true;
        switch (type) {
        case 2: CEREAL_RAPIDJSON_TAIL(); return result;
        case 3: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 4: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x50); CEREAL_RAPIDJSON_TAIL(); return result;
        case 5: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x10); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 6: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 10: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x20); CEREAL_RAPIDJSON_TAIL(); return result;
        case 11: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x60); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        default: return false;
        }
#undef CEREAL_RAPIDJSON_COPY
#undef CEREAL_RAPIDJSON_TRANS
#undef CEREAL_RAPIDJSON_TAIL
    }

    template <typename InputStream, typename OutputStream>
    static bool Validate(InputStream& is, OutputStream& os) {
#define CEREAL_RAPIDJSON_COPY() os.Put(c = is.Take())
#define CEREAL_RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
#define CEREAL_RAPIDJSON_TAIL() CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x70)
        Ch c;
        CEREAL_RAPIDJSON_COPY();
        if (!(c & 0x80))
            return true;

        bool result = true;
        switch (GetRange(static_cast<unsigned char>(c))) {
        case 2: CEREAL_RAPIDJSON_TAIL(); return result;
        case 3: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 4: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x50); CEREAL_RAPIDJSON_TAIL(); return result;
        case 5: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x10); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 6: CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        case 10: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x20); CEREAL_RAPIDJSON_TAIL(); return result;
        case 11: CEREAL_RAPIDJSON_COPY(); CEREAL_RAPIDJSON_TRANS(0x60); CEREAL_RAPIDJSON_TAIL(); CEREAL_RAPIDJSON_TAIL(); return result;
        default: return false;
        }
#undef CEREAL_RAPIDJSON_COPY
#undef CEREAL_RAPIDJSON_TRANS
#undef CEREAL_RAPIDJSON_TAIL
    }

    static unsigned char GetRange(unsigned char c) {
        // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
        // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
        static const unsigned char type[] = {
            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,0,0,0,0,
            0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
            0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
            10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
        };
        return type[c];
    }

    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        typename InputByteStream::Ch c = Take(is);
        if (static_cast<unsigned char>(c) != 0xEFu) return c;
        c = is.Take();
        if (static_cast<unsigned char>(c) != 0xBBu) return c;
        c = is.Take();
        if (static_cast<unsigned char>(c) != 0xBFu) return c;
        c = is.Take();
        return c;
    }

    template <typename InputByteStream>
    static Ch Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        return static_cast<Ch>(is.Take());
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, Ch c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(c));
    }
};

///////////////////////////////////////////////////////////////////////////////
// UTF16

//! UTF-16 encoding.
/*! http://en.wikipedia.org/wiki/UTF-16
    http://tools.ietf.org/html/rfc2781
    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
    \note implements Encoding concept

    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
    For streaming, use UTF16LE and UTF16BE, which handle endianness.
*/
template<typename CharType = wchar_t>
struct UTF16 {
    typedef CharType Ch;
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);

    enum { supportUnicode = 1 };

    template<typename OutputStream>
    static void Encode(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
        if (codepoint <= 0xFFFF) {
            CEREAL_RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
            os.Put(static_cast<typename OutputStream::Ch>(codepoint));
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            unsigned v = codepoint - 0x10000;
            os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
            os.Put(static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
        }
    }


    template<typename OutputStream>
    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
        if (codepoint <= 0xFFFF) {
            CEREAL_RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
            PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            unsigned v = codepoint - 0x10000;
            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
        }
    }

    template <typename InputStream>
    static bool Decode(InputStream& is, unsigned* codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
        typename InputStream::Ch c = is.Take();
        if (c < 0xD800 || c > 0xDFFF) {
            *codepoint = static_cast<unsigned>(c);
            return true;
        }
        else if (c <= 0xDBFF) {
            *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
            c = is.Take();
            *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
            *codepoint += 0x10000;
            return c >= 0xDC00 && c <= 0xDFFF;
        }
        return false;
    }

    template <typename InputStream, typename OutputStream>
    static bool Validate(InputStream& is, OutputStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
        typename InputStream::Ch c;
        os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
        if (c < 0xD800 || c > 0xDFFF)
            return true;
        else if (c <= 0xDBFF) {
            os.Put(c = is.Take());
            return c >= 0xDC00 && c <= 0xDFFF;
        }
        return false;
    }
};

//! UTF-16 little endian encoding.
template<typename CharType = wchar_t>
struct UTF16LE : UTF16<CharType> {
    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        CharType c = Take(is);
        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
    }

    template <typename InputByteStream>
    static CharType Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        unsigned c = static_cast<uint8_t>(is.Take());
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
        return static_cast<CharType>(c);
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, CharType c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
    }
};

//! UTF-16 big endian encoding.
template<typename CharType = wchar_t>
struct UTF16BE : UTF16<CharType> {
    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        CharType c = Take(is);
        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
    }

    template <typename InputByteStream>
    static CharType Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
        return static_cast<CharType>(c);
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, CharType c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
    }
};

///////////////////////////////////////////////////////////////////////////////
// UTF32

//! UTF-32 encoding. 
/*! http://en.wikipedia.org/wiki/UTF-32
    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
    \note implements Encoding concept

    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
    For streaming, use UTF32LE and UTF32BE, which handle endianness.
*/
template<typename CharType = unsigned>
struct UTF32 {
    typedef CharType Ch;
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);

    enum { supportUnicode = 1 };

    template<typename OutputStream>
    static void Encode(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
        CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
        os.Put(codepoint);
    }

    template<typename OutputStream>
    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
        CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
        PutUnsafe(os, codepoint);
    }

    template <typename InputStream>
    static bool Decode(InputStream& is, unsigned* codepoint) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
        Ch c = is.Take();
        *codepoint = c;
        return c <= 0x10FFFF;
    }

    template <typename InputStream, typename OutputStream>
    static bool Validate(InputStream& is, OutputStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
        Ch c;
        os.Put(c = is.Take());
        return c <= 0x10FFFF;
    }
};

//! UTF-32 little endian enocoding.
template<typename CharType = unsigned>
struct UTF32LE : UTF32<CharType> {
    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        CharType c = Take(is);
        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
    }

    template <typename InputByteStream>
    static CharType Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        unsigned c = static_cast<uint8_t>(is.Take());
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
        return static_cast<CharType>(c);
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, CharType c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
    }
};

//! UTF-32 big endian encoding.
template<typename CharType = unsigned>
struct UTF32BE : UTF32<CharType> {
    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        CharType c = Take(is);
        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c; 
    }

    template <typename InputByteStream>
    static CharType Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
        return static_cast<CharType>(c);
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, CharType c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
    }
};

///////////////////////////////////////////////////////////////////////////////
// ASCII

//! ASCII encoding.
/*! http://en.wikipedia.org/wiki/ASCII
    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
    \note implements Encoding concept
*/
template<typename CharType = char>
struct ASCII {
    typedef CharType Ch;

    enum { supportUnicode = 0 };

    template<typename OutputStream>
    static void Encode(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x7F);
        os.Put(static_cast<Ch>(codepoint & 0xFF));
    }

    template<typename OutputStream>
    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
        CEREAL_RAPIDJSON_ASSERT(codepoint <= 0x7F);
        PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
    }

    template <typename InputStream>
    static bool Decode(InputStream& is, unsigned* codepoint) {
        uint8_t c = static_cast<uint8_t>(is.Take());
        *codepoint = c;
        return c <= 0X7F;
    }

    template <typename InputStream, typename OutputStream>
    static bool Validate(InputStream& is, OutputStream& os) {
        uint8_t c = static_cast<uint8_t>(is.Take());
        os.Put(static_cast<typename OutputStream::Ch>(c));
        return c <= 0x7F;
    }

    template <typename InputByteStream>
    static CharType TakeBOM(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        uint8_t c = static_cast<uint8_t>(Take(is));
        return static_cast<Ch>(c);
    }

    template <typename InputByteStream>
    static Ch Take(InputByteStream& is) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
        return static_cast<Ch>(is.Take());
    }

    template <typename OutputByteStream>
    static void PutBOM(OutputByteStream& os) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        (void)os;
    }

    template <typename OutputByteStream>
    static void Put(OutputByteStream& os, Ch c) {
        CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
        os.Put(static_cast<typename OutputByteStream::Ch>(c));
    }
};

///////////////////////////////////////////////////////////////////////////////
// AutoUTF

//! Runtime-specified UTF encoding type of a stream.
enum UTFType {
    kUTF8 = 0,      //!< UTF-8.
    kUTF16LE = 1,   //!< UTF-16 little endian.
    kUTF16BE = 2,   //!< UTF-16 big endian.
    kUTF32LE = 3,   //!< UTF-32 little endian.
    kUTF32BE = 4    //!< UTF-32 big endian.
};

//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
*/
template<typename CharType>
struct AutoUTF {
    typedef CharType Ch;

    enum { supportUnicode = 1 };

#define CEREAL_RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x

    template<typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE void Encode(OutputStream& os, unsigned codepoint) {
        typedef void (*EncodeFunc)(OutputStream&, unsigned);
        static const EncodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Encode) };
        (*f[os.GetType()])(os, codepoint);
    }

    template<typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
        typedef void (*EncodeFunc)(OutputStream&, unsigned);
        static const EncodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
        (*f[os.GetType()])(os, codepoint);
    }

    template <typename InputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Decode(InputStream& is, unsigned* codepoint) {
        typedef bool (*DecodeFunc)(InputStream&, unsigned*);
        static const DecodeFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Decode) };
        return (*f[is.GetType()])(is, codepoint);
    }

    template <typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
        typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
        static const ValidateFunc f[] = { CEREAL_RAPIDJSON_ENCODINGS_FUNC(Validate) };
        return (*f[is.GetType()])(is, os);
    }

#undef CEREAL_RAPIDJSON_ENCODINGS_FUNC
};

///////////////////////////////////////////////////////////////////////////////
// Transcoder

//! Encoding conversion.
template<typename SourceEncoding, typename TargetEncoding>
struct Transcoder {
    //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
        unsigned codepoint;
        if (!SourceEncoding::Decode(is, &codepoint))
            return false;
        TargetEncoding::Encode(os, codepoint);
        return true;
    }

    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
        unsigned codepoint;
        if (!SourceEncoding::Decode(is, &codepoint))
            return false;
        TargetEncoding::EncodeUnsafe(os, codepoint);
        return true;
    }

    //! Validate one Unicode codepoint from an encoded stream.
    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
        return Transcode(is, os);   // Since source/target encoding is different, must transcode.
    }
};

// Forward declaration.
template<typename Stream>
inline void PutUnsafe(Stream& stream, typename Stream::Ch c);

//! Specialization of Transcoder with same source and target encoding.
template<typename Encoding>
struct Transcoder<Encoding, Encoding> {
    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Transcode(InputStream& is, OutputStream& os) {
        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
        return true;
    }
    
    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
        PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
        return true;
    }
    
    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE bool Validate(InputStream& is, OutputStream& os) {
        return Encoding::Validate(is, os);  // source/target encoding are the same
    }
};

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_ENCODINGS_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/error/en.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ERROR_EN_H_
#define CEREAL_RAPIDJSON_ERROR_EN_H_

#include "error.h"

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
CEREAL_RAPIDJSON_DIAG_OFF(covered-switch-default)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Maps error code of parsing into error message.
/*!
    \ingroup CEREAL_RAPIDJSON_ERRORS
    \param parseErrorCode Error code obtained in parsing.
    \return the error message.
    \note User can make a copy of this function for localization.
        Using switch-case is safer for future modification of error codes.
*/
inline const CEREAL_RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
    switch (parseErrorCode) {
        case kParseErrorNone:                           return CEREAL_RAPIDJSON_ERROR_STRING("No error.");

        case kParseErrorDocumentEmpty:                  return CEREAL_RAPIDJSON_ERROR_STRING("The document is empty.");
        case kParseErrorDocumentRootNotSingular:        return CEREAL_RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
    
        case kParseErrorValueInvalid:                   return CEREAL_RAPIDJSON_ERROR_STRING("Invalid value.");
    
        case kParseErrorObjectMissName:                 return CEREAL_RAPIDJSON_ERROR_STRING("Missing a name for object member.");
        case kParseErrorObjectMissColon:                return CEREAL_RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
        case kParseErrorObjectMissCommaOrCurlyBracket:  return CEREAL_RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
    
        case kParseErrorArrayMissCommaOrSquareBracket:  return CEREAL_RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");

        case kParseErrorStringUnicodeEscapeInvalidHex:  return CEREAL_RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
        case kParseErrorStringUnicodeSurrogateInvalid:  return CEREAL_RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
        case kParseErrorStringEscapeInvalid:            return CEREAL_RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
        case kParseErrorStringMissQuotationMark:        return CEREAL_RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
        case kParseErrorStringInvalidEncoding:          return CEREAL_RAPIDJSON_ERROR_STRING("Invalid encoding in string.");

        case kParseErrorNumberTooBig:                   return CEREAL_RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
        case kParseErrorNumberMissFraction:             return CEREAL_RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
        case kParseErrorNumberMissExponent:             return CEREAL_RAPIDJSON_ERROR_STRING("Miss exponent in number.");

        case kParseErrorTermination:                    return CEREAL_RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
        case kParseErrorUnspecificSyntaxError:          return CEREAL_RAPIDJSON_ERROR_STRING("Unspecific syntax error.");

        default:                                        return CEREAL_RAPIDJSON_ERROR_STRING("Unknown error.");
    }
}

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_ERROR_EN_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/error/error.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ERROR_ERROR_H_
#define CEREAL_RAPIDJSON_ERROR_ERROR_H_

#include "../rapidjson.h"

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#endif

/*! \file error.h */

/*! \defgroup CEREAL_RAPIDJSON_ERRORS RapidJSON error handling */

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_ERROR_CHARTYPE

//! Character type of error messages.
/*! \ingroup CEREAL_RAPIDJSON_ERRORS
    The default character type is \c char.
    On Windows, user can define this macro as \c TCHAR for supporting both
    unicode/non-unicode settings.
*/
#ifndef CEREAL_RAPIDJSON_ERROR_CHARTYPE
#define CEREAL_RAPIDJSON_ERROR_CHARTYPE char
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_ERROR_STRING

//! Macro for converting string literial to \ref CEREAL_RAPIDJSON_ERROR_CHARTYPE[].
/*! \ingroup CEREAL_RAPIDJSON_ERRORS
    By default this conversion macro does nothing.
    On Windows, user can define this macro as \c _T(x) for supporting both
    unicode/non-unicode settings.
*/
#ifndef CEREAL_RAPIDJSON_ERROR_STRING
#define CEREAL_RAPIDJSON_ERROR_STRING(x) x
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// ParseErrorCode

//! Error code of parsing.
/*! \ingroup CEREAL_RAPIDJSON_ERRORS
    \see GenericReader::Parse, GenericReader::GetParseErrorCode
*/
enum ParseErrorCode {
    kParseErrorNone = 0,                        //!< No error.

    kParseErrorDocumentEmpty,                   //!< The document is empty.
    kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.

    kParseErrorValueInvalid,                    //!< Invalid value.

    kParseErrorObjectMissName,                  //!< Missing a name for object member.
    kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
    kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.

    kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.

    kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
    kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
    kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
    kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
    kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.

    kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
    kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
    kParseErrorNumberMissExponent,              //!< Miss exponent in number.

    kParseErrorTermination,                     //!< Parsing was terminated.
    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
};

//! Result of parsing (wraps ParseErrorCode)
/*!
    \ingroup CEREAL_RAPIDJSON_ERRORS
    \code
        Document doc;
        ParseResult ok = doc.Parse("[42]");
        if (!ok) {
            fprintf(stderr, "JSON parse error: %s (%u)",
                    GetParseError_En(ok.Code()), ok.Offset());
            exit(EXIT_FAILURE);
        }
    \endcode
    \see GenericReader::Parse, GenericDocument::Parse
*/
struct ParseResult {
    //!! Unspecified boolean type
    typedef bool (ParseResult::*BooleanType)() const;
public:
    //! Default constructor, no error.
    ParseResult() : code_(kParseErrorNone), offset_(0) {}
    //! Constructor to set an error.
    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}

    //! Get the error code.
    ParseErrorCode Code() const { return code_; }
    //! Get the error offset, if \ref IsError(), 0 otherwise.
    size_t Offset() const { return offset_; }

    //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError().
    operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; }
    //! Whether the result is an error.
    bool IsError() const { return code_ != kParseErrorNone; }

    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
    bool operator==(ParseErrorCode code) const { return code_ == code; }
    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }

    bool operator!=(const ParseResult& that) const { return !(*this == that); }
    bool operator!=(ParseErrorCode code) const { return !(*this == code); }
    friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; }

    //! Reset error code.
    void Clear() { Set(kParseErrorNone); }
    //! Update error code and offset.
    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }

private:
    ParseErrorCode code_;
    size_t offset_;
};

//! Function pointer type of GetParseError().
/*! \ingroup CEREAL_RAPIDJSON_ERRORS

    This is the prototype for \c GetParseError_X(), where \c X is a locale.
    User can dynamically change locale in runtime, e.g.:
\code
    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
    const CEREAL_RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
\endcode
*/
typedef const CEREAL_RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_ERROR_ERROR_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/filereadstream.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_FILEREADSTREAM_H_
#define CEREAL_RAPIDJSON_FILEREADSTREAM_H_

#include "stream.h"
#include <cstdio>

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
CEREAL_RAPIDJSON_DIAG_OFF(missing-noreturn)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! File byte stream for input using fread().
/*!
    \note implements Stream concept
*/
class FileReadStream {
public:
    typedef char Ch;    //!< Character type (byte).

    //! Constructor.
    /*!
        \param fp File pointer opened for read.
        \param buffer user-supplied buffer.
        \param bufferSize size of buffer in bytes. Must >=4 bytes.
    */
    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
        CEREAL_RAPIDJSON_ASSERT(fp_ != 0);
        CEREAL_RAPIDJSON_ASSERT(bufferSize >= 4);
        Read();
    }

    Ch Peek() const { return *current_; }
    Ch Take() { Ch c = *current_; Read(); return c; }
    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }

    // Not implemented
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

    // For encoding detection only.
    const Ch* Peek4() const {
        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
    }

private:
    void Read() {
        if (current_ < bufferLast_)
            ++current_;
        else if (!eof_) {
            count_ += readCount_;
            readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
            bufferLast_ = buffer_ + readCount_ - 1;
            current_ = buffer_;

            if (readCount_ < bufferSize_) {
                buffer_[readCount_] = '\0';
                ++bufferLast_;
                eof_ = true;
            }
        }
    }

    std::FILE* fp_;
    Ch *buffer_;
    size_t bufferSize_;
    Ch *bufferLast_;
    Ch *current_;
    size_t readCount_;
    size_t count_;  //!< Number of characters read
    bool eof_;
};

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_FILESTREAM_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/filewritestream.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_FILEWRITESTREAM_H_
#define CEREAL_RAPIDJSON_FILEWRITESTREAM_H_

#include "stream.h"
#include <cstdio>

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Wrapper of C file stream for output using fwrite().
/*!
    \note implements Stream concept
*/
class FileWriteStream {
public:
    typedef char Ch;    //!< Character type. Only support char.

    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
        CEREAL_RAPIDJSON_ASSERT(fp_ != 0);
    }

    void Put(char c) { 
        if (current_ >= bufferEnd_)
            Flush();

        *current_++ = c;
    }

    void PutN(char c, size_t n) {
        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
        while (n > avail) {
            std::memset(current_, c, avail);
            current_ += avail;
            Flush();
            n -= avail;
            avail = static_cast<size_t>(bufferEnd_ - current_);
        }

        if (n > 0) {
            std::memset(current_, c, n);
            current_ += n;
        }
    }

    void Flush() {
        if (current_ != buffer_) {
            size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
            if (result < static_cast<size_t>(current_ - buffer_)) {
                // failure deliberately ignored at this time
                // added to avoid warn_unused_result build errors
            }
            current_ = buffer_;
        }
    }

    // Not implemented
    char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    char Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    char* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    // Prohibit copy constructor & assignment operator.
    FileWriteStream(const FileWriteStream&);
    FileWriteStream& operator=(const FileWriteStream&);

    std::FILE* fp_;
    char *buffer_;
    char *bufferEnd_;
    char *current_;
};

//! Implement specialized version of PutN() with memset() for better performance.
template<>
inline void PutN(FileWriteStream& stream, char c, size_t n) {
    stream.PutN(c, n);
}

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_FILESTREAM_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/fwd.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_FWD_H_
#define CEREAL_RAPIDJSON_FWD_H_

#include "rapidjson.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

// encodings.h

template<typename CharType> struct UTF8;
template<typename CharType> struct UTF16;
template<typename CharType> struct UTF16BE;
template<typename CharType> struct UTF16LE;
template<typename CharType> struct UTF32;
template<typename CharType> struct UTF32BE;
template<typename CharType> struct UTF32LE;
template<typename CharType> struct ASCII;
template<typename CharType> struct AutoUTF;

template<typename SourceEncoding, typename TargetEncoding>
struct Transcoder;

// allocators.h

class CrtAllocator;

template <typename BaseAllocator>
class MemoryPoolAllocator;

// stream.h

template <typename Encoding>
struct GenericStringStream;

typedef GenericStringStream<UTF8<char> > StringStream;

template <typename Encoding>
struct GenericInsituStringStream;

typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;

// stringbuffer.h

template <typename Encoding, typename Allocator>
class GenericStringBuffer;

typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;

// filereadstream.h

class FileReadStream;

// filewritestream.h

class FileWriteStream;

// memorybuffer.h

template <typename Allocator>
struct GenericMemoryBuffer;

typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;

// memorystream.h

struct MemoryStream;

// reader.h

template<typename Encoding, typename Derived>
struct BaseReaderHandler;

template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
class GenericReader;

typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;

// writer.h

template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
class Writer;

// prettywriter.h

template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
class PrettyWriter;

// document.h

template <typename Encoding, typename Allocator> 
struct GenericMember;

template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator;

template<typename CharType>
struct GenericStringRef;

template <typename Encoding, typename Allocator> 
class GenericValue;

typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;

template <typename Encoding, typename Allocator, typename StackAllocator>
class GenericDocument;

typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;

// pointer.h

template <typename ValueType, typename Allocator>
class GenericPointer;

typedef GenericPointer<Value, CrtAllocator> Pointer;

// schema.h

template <typename SchemaDocumentType>
class IGenericRemoteSchemaDocumentProvider;

template <typename ValueT, typename Allocator>
class GenericSchemaDocument;

typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;

template <
    typename SchemaDocumentType,
    typename OutputHandler,
    typename StateAllocator>
class GenericSchemaValidator;

typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_RAPIDJSONFWD_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/biginteger.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_BIGINTEGER_H_
#define CEREAL_RAPIDJSON_BIGINTEGER_H_

#include "../rapidjson.h"

#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64)
#include <intrin.h> // for _umul128
#pragma intrinsic(_umul128)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

class BigInteger {
public:
    typedef uint64_t Type;

    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
    }

    explicit BigInteger(uint64_t u) : count_(1) {
        digits_[0] = u;
    }

    BigInteger(const char* decimals, size_t length) : count_(1) {
        CEREAL_RAPIDJSON_ASSERT(length > 0);
        digits_[0] = 0;
        size_t i = 0;
        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
        while (length >= kMaxDigitPerIteration) {
            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
            length -= kMaxDigitPerIteration;
            i += kMaxDigitPerIteration;
        }

        if (length > 0)
            AppendDecimal64(decimals + i, decimals + i + length);
    }
    
    BigInteger& operator=(const BigInteger &rhs)
    {
        if (this != &rhs) {
            count_ = rhs.count_;
            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
        }
        return *this;
    }
    
    BigInteger& operator=(uint64_t u) {
        digits_[0] = u;            
        count_ = 1;
        return *this;
    }

    BigInteger& operator+=(uint64_t u) {
        Type backup = digits_[0];
        digits_[0] += u;
        for (size_t i = 0; i < count_ - 1; i++) {
            if (digits_[i] >= backup)
                return *this; // no carry
            backup = digits_[i + 1];
            digits_[i + 1] += 1;
        }

        // Last carry
        if (digits_[count_ - 1] < backup)
            PushBack(1);

        return *this;
    }

    BigInteger& operator*=(uint64_t u) {
        if (u == 0) return *this = 0;
        if (u == 1) return *this;
        if (*this == 1) return *this = u;

        uint64_t k = 0;
        for (size_t i = 0; i < count_; i++) {
            uint64_t hi;
            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
            k = hi;
        }
        
        if (k > 0)
            PushBack(k);

        return *this;
    }

    BigInteger& operator*=(uint32_t u) {
        if (u == 0) return *this = 0;
        if (u == 1) return *this;
        if (*this == 1) return *this = u;

        uint64_t k = 0;
        for (size_t i = 0; i < count_; i++) {
            const uint64_t c = digits_[i] >> 32;
            const uint64_t d = digits_[i] & 0xFFFFFFFF;
            const uint64_t uc = u * c;
            const uint64_t ud = u * d;
            const uint64_t p0 = ud + k;
            const uint64_t p1 = uc + (p0 >> 32);
            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
            k = p1 >> 32;
        }
        
        if (k > 0)
            PushBack(k);

        return *this;
    }

    BigInteger& operator<<=(size_t shift) {
        if (IsZero() || shift == 0) return *this;

        size_t offset = shift / kTypeBit;
        size_t interShift = shift % kTypeBit;
        CEREAL_RAPIDJSON_ASSERT(count_ + offset <= kCapacity);

        if (interShift == 0) {
            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
            count_ += offset;
        }
        else {
            digits_[count_] = 0;
            for (size_t i = count_; i > 0; i--)
                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
            digits_[offset] = digits_[0] << interShift;
            count_ += offset;
            if (digits_[count_])
                count_++;
        }

        std::memset(digits_, 0, offset * sizeof(Type));

        return *this;
    }

    bool operator==(const BigInteger& rhs) const {
        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
    }

    bool operator==(const Type rhs) const {
        return count_ == 1 && digits_[0] == rhs;
    }

    BigInteger& MultiplyPow5(unsigned exp) {
        static const uint32_t kPow5[12] = {
            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 * 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 * 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
        };
        if (exp == 0) return *this;
        for (; exp >= 27; exp -= 27) *this *= CEREAL_RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
        if (exp > 0)                 *this *= kPow5[exp - 1];
        return *this;
    }

    // Compute absolute difference of this and rhs.
    // Assume this != rhs
    bool Difference(const BigInteger& rhs, BigInteger* out) const {
        int cmp = Compare(rhs);
        CEREAL_RAPIDJSON_ASSERT(cmp != 0);
        const BigInteger *a, *b;  // Makes a > b
        bool ret;
        if (cmp < 0) { a = &rhs; b = this; ret = true; }
        else         { a = this; b = &rhs; ret = false; }

        Type borrow = 0;
        for (size_t i = 0; i < a->count_; i++) {
            Type d = a->digits_[i] - borrow;
            if (i < b->count_)
                d -= b->digits_[i];
            borrow = (d > a->digits_[i]) ? 1 : 0;
            out->digits_[i] = d;
            if (d != 0)
                out->count_ = i + 1;
        }

        return ret;
    }

    int Compare(const BigInteger& rhs) const {
        if (count_ != rhs.count_)
            return count_ < rhs.count_ ? -1 : 1;

        for (size_t i = count_; i-- > 0;)
            if (digits_[i] != rhs.digits_[i])
                return digits_[i] < rhs.digits_[i] ? -1 : 1;

        return 0;
    }

    size_t GetCount() const { return count_; }
    Type GetDigit(size_t index) const { CEREAL_RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }

private:
    void AppendDecimal64(const char* begin, const char* end) {
        uint64_t u = ParseUint64(begin, end);
        if (IsZero())
            *this = u;
        else {
            unsigned exp = static_cast<unsigned>(end - begin);
            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
        }
    }

    void PushBack(Type digit) {
        CEREAL_RAPIDJSON_ASSERT(count_ < kCapacity);
        digits_[count_++] = digit;
    }

    static uint64_t ParseUint64(const char* begin, const char* end) {
        uint64_t r = 0;
        for (const char* p = begin; p != end; ++p) {
            CEREAL_RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
            r = r * 10u + static_cast<unsigned>(*p - '0');
        }
        return r;
    }

    // Assume a * b + k < 2^128
    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
#if defined(_MSC_VER) && defined(_M_AMD64)
        uint64_t low = _umul128(a, b, outHigh) + k;
        if (low < k)
            (*outHigh)++;
        return low;
#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
        __extension__ typedef unsigned __int128 uint128;
        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
        p += k;
        *outHigh = static_cast<uint64_t>(p >> 64);
        return static_cast<uint64_t>(p);
#else
        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
        x1 += (x0 >> 32); // can't give carry
        x1 += x2;
        if (x1 < x2)
            x3 += (static_cast<uint64_t>(1) << 32);
        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
        uint64_t hi = x3 + (x1 >> 32);

        lo += k;
        if (lo < k)
            hi++;
        *outHigh = hi;
        return lo;
#endif
    }

    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
    static const size_t kCapacity = kBitCount / sizeof(Type);
    static const size_t kTypeBit = sizeof(Type) * 8;

    Type digits_[kCapacity];
    size_t count_;
};

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_BIGINTEGER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/diyfp.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
// integers." ACM Sigplan Notices 45.6 (2010): 233-243.

#ifndef CEREAL_RAPIDJSON_DIYFP_H_
#define CEREAL_RAPIDJSON_DIYFP_H_

#include "../rapidjson.h"
#include <limits>

#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
#include <intrin.h>
#pragma intrinsic(_BitScanReverse64)
#pragma intrinsic(_umul128)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#endif

struct DiyFp {
    DiyFp() : f(), e() {}

    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}

    explicit DiyFp(double d) {
        union {
            double d;
            uint64_t u64;
        } u = { d };

        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
        uint64_t significand = (u.u64 & kDpSignificandMask);
        if (biased_e != 0) {
            f = significand + kDpHiddenBit;
            e = biased_e - kDpExponentBias;
        }
        else {
            f = significand;
            e = kDpMinExponent + 1;
        }
    }

    DiyFp operator-(const DiyFp& rhs) const {
        return DiyFp(f - rhs.f, e);
    }

    DiyFp operator*(const DiyFp& rhs) const {
#if defined(_MSC_VER) && defined(_M_AMD64)
        uint64_t h;
        uint64_t l = _umul128(f, rhs.f, &h);
        if (l & (uint64_t(1) << 63)) // rounding
            h++;
        return DiyFp(h, e + rhs.e + 64);
#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
        __extension__ typedef unsigned __int128 uint128;
        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
        uint64_t h = static_cast<uint64_t>(p >> 64);
        uint64_t l = static_cast<uint64_t>(p);
        if (l & (uint64_t(1) << 63)) // rounding
            h++;
        return DiyFp(h, e + rhs.e + 64);
#else
        const uint64_t M32 = 0xFFFFFFFF;
        const uint64_t a = f >> 32;
        const uint64_t b = f & M32;
        const uint64_t c = rhs.f >> 32;
        const uint64_t d = rhs.f & M32;
        const uint64_t ac = a * c;
        const uint64_t bc = b * c;
        const uint64_t ad = a * d;
        const uint64_t bd = b * d;
        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
        tmp += 1U << 31;  /// mult_round
        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
#endif
    }

    DiyFp Normalize() const {
        CEREAL_RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
#if defined(_MSC_VER) && defined(_M_AMD64)
        unsigned long index;
        _BitScanReverse64(&index, f);
        return DiyFp(f << (63 - index), e - (63 - index));
#elif defined(__GNUC__) && __GNUC__ >= 4
        int s = __builtin_clzll(f);
        return DiyFp(f << s, e - s);
#else
        DiyFp res = *this;
        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
            res.f <<= 1;
            res.e--;
        }
        return res;
#endif
    }

    DiyFp NormalizeBoundary() const {
        DiyFp res = *this;
        while (!(res.f & (kDpHiddenBit << 1))) {
            res.f <<= 1;
            res.e--;
        }
        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
        return res;
    }

    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
        mi.f <<= mi.e - pl.e;
        mi.e = pl.e;
        *plus = pl;
        *minus = mi;
    }

    double ToDouble() const {
        union {
            double d;
            uint64_t u64;
        }u;
        CEREAL_RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
        if (e < kDpDenormalExponent) {
            // Underflow.
            return 0.0;
        }
        if (e >= kDpMaxExponent) {
            // Overflow.
            return std::numeric_limits<double>::infinity();
        }
        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
            static_cast<uint64_t>(e + kDpExponentBias);
        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
        return u.d;
    }

    static const int kDiySignificandSize = 64;
    static const int kDpSignificandSize = 52;
    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
    static const int kDpMinExponent = -kDpExponentBias;
    static const int kDpDenormalExponent = -kDpExponentBias + 1;
    static const uint64_t kDpExponentMask = CEREAL_RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
    static const uint64_t kDpSignificandMask = CEREAL_RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
    static const uint64_t kDpHiddenBit = CEREAL_RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);

    uint64_t f;
    int e;
};

inline DiyFp GetCachedPowerByIndex(size_t index) {
    // 10^-348, 10^-340, ..., 10^340
    static const uint64_t kCachedPowers_F[] = {
        CEREAL_RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), CEREAL_RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
        CEREAL_RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), CEREAL_RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
        CEREAL_RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), CEREAL_RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
        CEREAL_RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), CEREAL_RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
        CEREAL_RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), CEREAL_RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
        CEREAL_RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), CEREAL_RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
        CEREAL_RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), CEREAL_RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
        CEREAL_RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), CEREAL_RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
        CEREAL_RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), CEREAL_RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
        CEREAL_RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), CEREAL_RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
        CEREAL_RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), CEREAL_RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
        CEREAL_RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), CEREAL_RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
        CEREAL_RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), CEREAL_RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
        CEREAL_RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), CEREAL_RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
        CEREAL_RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), CEREAL_RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
        CEREAL_RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), CEREAL_RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
        CEREAL_RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), CEREAL_RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
        CEREAL_RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), CEREAL_RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
        CEREAL_RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), CEREAL_RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
        CEREAL_RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), CEREAL_RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
        CEREAL_RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), CEREAL_RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
        CEREAL_RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), CEREAL_RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
        CEREAL_RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), CEREAL_RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
        CEREAL_RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), CEREAL_RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
        CEREAL_RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), CEREAL_RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
        CEREAL_RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), CEREAL_RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
        CEREAL_RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), CEREAL_RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
        CEREAL_RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), CEREAL_RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
        CEREAL_RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), CEREAL_RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
        CEREAL_RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), CEREAL_RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
        CEREAL_RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), CEREAL_RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
        CEREAL_RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), CEREAL_RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
        CEREAL_RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), CEREAL_RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
        CEREAL_RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), CEREAL_RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
        CEREAL_RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), CEREAL_RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
        CEREAL_RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), CEREAL_RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
        CEREAL_RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), CEREAL_RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
        CEREAL_RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), CEREAL_RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
        CEREAL_RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), CEREAL_RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
        CEREAL_RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), CEREAL_RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
        CEREAL_RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), CEREAL_RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
        CEREAL_RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), CEREAL_RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
        CEREAL_RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), CEREAL_RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
        CEREAL_RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
    };
    static const int16_t kCachedPowers_E[] = {
        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
        907,   933,   960,   986,  1013,  1039,  1066
    };
    CEREAL_RAPIDJSON_ASSERT(index < 87);
    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
}

inline DiyFp GetCachedPower(int e, int* K) {

    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
    int k = static_cast<int>(dk);
    if (dk - k > 0.0)
        k++;

    unsigned index = static_cast<unsigned>((k >> 3) + 1);
    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table

    return GetCachedPowerByIndex(index);
}

inline DiyFp GetCachedPower10(int exp, int *outExp) {
    CEREAL_RAPIDJSON_ASSERT(exp >= -348);
    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
    *outExp = -348 + static_cast<int>(index) * 8;
    return GetCachedPowerByIndex(index);
}

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#endif

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_DIYFP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/dtoa.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
// integers." ACM Sigplan Notices 45.6 (2010): 233-243.

#ifndef CEREAL_RAPIDJSON_DTOA_
#define CEREAL_RAPIDJSON_DTOA_

#include "itoa.h" // GetDigitsLut()
#include "diyfp.h"
#include "ieee754.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
CEREAL_RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
#endif

inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
    while (rest < wp_w && delta - rest >= ten_kappa &&
           (rest + ten_kappa < wp_w ||  /// closer
            wp_w - rest > rest + ten_kappa - wp_w)) {
        buffer[len - 1]--;
        rest += ten_kappa;
    }
}

inline int CountDecimalDigit32(uint32_t n) {
    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
    if (n < 10) return 1;
    if (n < 100) return 2;
    if (n < 1000) return 3;
    if (n < 10000) return 4;
    if (n < 100000) return 5;
    if (n < 1000000) return 6;
    if (n < 10000000) return 7;
    if (n < 100000000) return 8;
    // Will not reach 10 digits in DigitGen()
    //if (n < 1000000000) return 9;
    //return 10;
    return 9;
}

inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
    const DiyFp wp_w = Mp - W;
    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
    uint64_t p2 = Mp.f & (one.f - 1);
    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
    *len = 0;

    while (kappa > 0) {
        uint32_t d = 0;
        switch (kappa) {
            case  9: d = p1 /  100000000; p1 %=  100000000; break;
            case  8: d = p1 /   10000000; p1 %=   10000000; break;
            case  7: d = p1 /    1000000; p1 %=    1000000; break;
            case  6: d = p1 /     100000; p1 %=     100000; break;
            case  5: d = p1 /      10000; p1 %=      10000; break;
            case  4: d = p1 /       1000; p1 %=       1000; break;
            case  3: d = p1 /        100; p1 %=        100; break;
            case  2: d = p1 /         10; p1 %=         10; break;
            case  1: d = p1;              p1 =           0; break;
            default:;
        }
        if (d || *len)
            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
        kappa--;
        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
        if (tmp <= delta) {
            *K += kappa;
            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
            return;
        }
    }

    // kappa = 0
    for (;;) {
        p2 *= 10;
        delta *= 10;
        char d = static_cast<char>(p2 >> -one.e);
        if (d || *len)
            buffer[(*len)++] = static_cast<char>('0' + d);
        p2 &= one.f - 1;
        kappa--;
        if (p2 < delta) {
            *K += kappa;
            int index = -kappa;
            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0));
            return;
        }
    }
}

inline void Grisu2(double value, char* buffer, int* length, int* K) {
    const DiyFp v(value);
    DiyFp w_m, w_p;
    v.NormalizedBoundaries(&w_m, &w_p);

    const DiyFp c_mk = GetCachedPower(w_p.e, K);
    const DiyFp W = v.Normalize() * c_mk;
    DiyFp Wp = w_p * c_mk;
    DiyFp Wm = w_m * c_mk;
    Wm.f++;
    Wp.f--;
    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
}

inline char* WriteExponent(int K, char* buffer) {
    if (K < 0) {
        *buffer++ = '-';
        K = -K;
    }

    if (K >= 100) {
        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
        K %= 100;
        const char* d = GetDigitsLut() + K * 2;
        *buffer++ = d[0];
        *buffer++ = d[1];
    }
    else if (K >= 10) {
        const char* d = GetDigitsLut() + K * 2;
        *buffer++ = d[0];
        *buffer++ = d[1];
    }
    else
        *buffer++ = static_cast<char>('0' + static_cast<char>(K));

    return buffer;
}

inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) {
    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk

    if (0 <= k && kk <= 21) {
        // 1234e7 -> 12340000000
        for (int i = length; i < kk; i++)
            buffer[i] = '0';
        buffer[kk] = '.';
        buffer[kk + 1] = '0';
        return &buffer[kk + 2];
    }
    else if (0 < kk && kk <= 21) {
        // 1234e-2 -> 12.34
        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
        buffer[kk] = '.';
        if (0 > k + maxDecimalPlaces) {
            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
            // Remove extra trailing zeros (at least one) after truncation.
            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
                if (buffer[i] != '0')
                    return &buffer[i + 1];
            return &buffer[kk + 2]; // Reserve one zero
        }
        else
            return &buffer[length + 1];
    }
    else if (-6 < kk && kk <= 0) {
        // 1234e-6 -> 0.001234
        const int offset = 2 - kk;
        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
        buffer[0] = '0';
        buffer[1] = '.';
        for (int i = 2; i < offset; i++)
            buffer[i] = '0';
        if (length - kk > maxDecimalPlaces) {
            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
            // Remove extra trailing zeros (at least one) after truncation.
            for (int i = maxDecimalPlaces + 1; i > 2; i--)
                if (buffer[i] != '0')
                    return &buffer[i + 1];
            return &buffer[3]; // Reserve one zero
        }
        else
            return &buffer[length + offset];
    }
    else if (kk < -maxDecimalPlaces) {
        // Truncate to zero
        buffer[0] = '0';
        buffer[1] = '.';
        buffer[2] = '0';
        return &buffer[3];
    }
    else if (length == 1) {
        // 1e30
        buffer[1] = 'e';
        return WriteExponent(kk - 1, &buffer[2]);
    }
    else {
        // 1234e30 -> 1.234e33
        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
        buffer[1] = '.';
        buffer[length + 1] = 'e';
        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
    }
}

inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
    CEREAL_RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
    Double d(value);
    if (d.IsZero()) {
        if (d.Sign())
            *buffer++ = '-';     // -0.0, Issue #289
        buffer[0] = '0';
        buffer[1] = '.';
        buffer[2] = '0';
        return &buffer[3];
    }
    else {
        if (value < 0) {
            *buffer++ = '-';
            value = -value;
        }
        int length, K;
        Grisu2(value, buffer, &length, &K);
        return Prettify(buffer, length, K, maxDecimalPlaces);
    }
}

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_DTOA_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/ieee754.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_IEEE754_
#define CEREAL_RAPIDJSON_IEEE754_

#include "../rapidjson.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

class Double {
public:
    Double() {}
    Double(double d) : d_(d) {}
    Double(uint64_t u) : u_(u) {}

    double Value() const { return d_; }
    uint64_t Uint64Value() const { return u_; }

    double NextPositiveDouble() const {
        CEREAL_RAPIDJSON_ASSERT(!Sign());
        return Double(u_ + 1).Value();
    }

    bool Sign() const { return (u_ & kSignMask) != 0; }
    uint64_t Significand() const { return u_ & kSignificandMask; }
    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }

    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
    bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }

    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }

    static int EffectiveSignificandSize(int order) {
        if (order >= -1021)
            return 53;
        else if (order <= -1074)
            return 0;
        else
            return order + 1074;
    }

private:
    static const int kSignificandSize = 52;
    static const int kExponentBias = 0x3FF;
    static const int kDenormalExponent = 1 - kExponentBias;
    static const uint64_t kSignMask = CEREAL_RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
    static const uint64_t kExponentMask = CEREAL_RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
    static const uint64_t kSignificandMask = CEREAL_RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
    static const uint64_t kHiddenBit = CEREAL_RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);

    union {
        double d_;
        uint64_t u_;
    };
};

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_IEEE754_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/itoa.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ITOA_
#define CEREAL_RAPIDJSON_ITOA_

#include "../rapidjson.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

inline const char* GetDigitsLut() {
    static const char cDigitsLut[200] = {
        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
    };
    return cDigitsLut;
}

inline char* u32toa(uint32_t value, char* buffer) {
    CEREAL_RAPIDJSON_ASSERT(buffer != 0);

    const char* cDigitsLut = GetDigitsLut();

    if (value < 10000) {
        const uint32_t d1 = (value / 100) << 1;
        const uint32_t d2 = (value % 100) << 1;

        if (value >= 1000)
            *buffer++ = cDigitsLut[d1];
        if (value >= 100)
            *buffer++ = cDigitsLut[d1 + 1];
        if (value >= 10)
            *buffer++ = cDigitsLut[d2];
        *buffer++ = cDigitsLut[d2 + 1];
    }
    else if (value < 100000000) {
        // value = bbbbcccc
        const uint32_t b = value / 10000;
        const uint32_t c = value % 10000;

        const uint32_t d1 = (b / 100) << 1;
        const uint32_t d2 = (b % 100) << 1;

        const uint32_t d3 = (c / 100) << 1;
        const uint32_t d4 = (c % 100) << 1;

        if (value >= 10000000)
            *buffer++ = cDigitsLut[d1];
        if (value >= 1000000)
            *buffer++ = cDigitsLut[d1 + 1];
        if (value >= 100000)
            *buffer++ = cDigitsLut[d2];
        *buffer++ = cDigitsLut[d2 + 1];

        *buffer++ = cDigitsLut[d3];
        *buffer++ = cDigitsLut[d3 + 1];
        *buffer++ = cDigitsLut[d4];
        *buffer++ = cDigitsLut[d4 + 1];
    }
    else {
        // value = aabbbbcccc in decimal

        const uint32_t a = value / 100000000; // 1 to 42
        value %= 100000000;

        if (a >= 10) {
            const unsigned i = a << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
        }
        else
            *buffer++ = static_cast<char>('0' + static_cast<char>(a));

        const uint32_t b = value / 10000; // 0 to 9999
        const uint32_t c = value % 10000; // 0 to 9999

        const uint32_t d1 = (b / 100) << 1;
        const uint32_t d2 = (b % 100) << 1;

        const uint32_t d3 = (c / 100) << 1;
        const uint32_t d4 = (c % 100) << 1;

        *buffer++ = cDigitsLut[d1];
        *buffer++ = cDigitsLut[d1 + 1];
        *buffer++ = cDigitsLut[d2];
        *buffer++ = cDigitsLut[d2 + 1];
        *buffer++ = cDigitsLut[d3];
        *buffer++ = cDigitsLut[d3 + 1];
        *buffer++ = cDigitsLut[d4];
        *buffer++ = cDigitsLut[d4 + 1];
    }
    return buffer;
}

inline char* i32toa(int32_t value, char* buffer) {
    CEREAL_RAPIDJSON_ASSERT(buffer != 0);
    uint32_t u = static_cast<uint32_t>(value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;
    }

    return u32toa(u, buffer);
}

inline char* u64toa(uint64_t value, char* buffer) {
    CEREAL_RAPIDJSON_ASSERT(buffer != 0);
    const char* cDigitsLut = GetDigitsLut();
    const uint64_t  kTen8 = 100000000;
    const uint64_t  kTen9 = kTen8 * 10;
    const uint64_t kTen10 = kTen8 * 100;
    const uint64_t kTen11 = kTen8 * 1000;
    const uint64_t kTen12 = kTen8 * 10000;
    const uint64_t kTen13 = kTen8 * 100000;
    const uint64_t kTen14 = kTen8 * 1000000;
    const uint64_t kTen15 = kTen8 * 10000000;
    const uint64_t kTen16 = kTen8 * kTen8;

    if (value < kTen8) {
        uint32_t v = static_cast<uint32_t>(value);
        if (v < 10000) {
            const uint32_t d1 = (v / 100) << 1;
            const uint32_t d2 = (v % 100) << 1;

            if (v >= 1000)
                *buffer++ = cDigitsLut[d1];
            if (v >= 100)
                *buffer++ = cDigitsLut[d1 + 1];
            if (v >= 10)
                *buffer++ = cDigitsLut[d2];
            *buffer++ = cDigitsLut[d2 + 1];
        }
        else {
            // value = bbbbcccc
            const uint32_t b = v / 10000;
            const uint32_t c = v % 10000;

            const uint32_t d1 = (b / 100) << 1;
            const uint32_t d2 = (b % 100) << 1;

            const uint32_t d3 = (c / 100) << 1;
            const uint32_t d4 = (c % 100) << 1;

            if (value >= 10000000)
                *buffer++ = cDigitsLut[d1];
            if (value >= 1000000)
                *buffer++ = cDigitsLut[d1 + 1];
            if (value >= 100000)
                *buffer++ = cDigitsLut[d2];
            *buffer++ = cDigitsLut[d2 + 1];

            *buffer++ = cDigitsLut[d3];
            *buffer++ = cDigitsLut[d3 + 1];
            *buffer++ = cDigitsLut[d4];
            *buffer++ = cDigitsLut[d4 + 1];
        }
    }
    else if (value < kTen16) {
        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);

        const uint32_t b0 = v0 / 10000;
        const uint32_t c0 = v0 % 10000;

        const uint32_t d1 = (b0 / 100) << 1;
        const uint32_t d2 = (b0 % 100) << 1;

        const uint32_t d3 = (c0 / 100) << 1;
        const uint32_t d4 = (c0 % 100) << 1;

        const uint32_t b1 = v1 / 10000;
        const uint32_t c1 = v1 % 10000;

        const uint32_t d5 = (b1 / 100) << 1;
        const uint32_t d6 = (b1 % 100) << 1;

        const uint32_t d7 = (c1 / 100) << 1;
        const uint32_t d8 = (c1 % 100) << 1;

        if (value >= kTen15)
            *buffer++ = cDigitsLut[d1];
        if (value >= kTen14)
            *buffer++ = cDigitsLut[d1 + 1];
        if (value >= kTen13)
            *buffer++ = cDigitsLut[d2];
        if (value >= kTen12)
            *buffer++ = cDigitsLut[d2 + 1];
        if (value >= kTen11)
            *buffer++ = cDigitsLut[d3];
        if (value >= kTen10)
            *buffer++ = cDigitsLut[d3 + 1];
        if (value >= kTen9)
            *buffer++ = cDigitsLut[d4];

        *buffer++ = cDigitsLut[d4 + 1];
        *buffer++ = cDigitsLut[d5];
        *buffer++ = cDigitsLut[d5 + 1];
        *buffer++ = cDigitsLut[d6];
        *buffer++ = cDigitsLut[d6 + 1];
        *buffer++ = cDigitsLut[d7];
        *buffer++ = cDigitsLut[d7 + 1];
        *buffer++ = cDigitsLut[d8];
        *buffer++ = cDigitsLut[d8 + 1];
    }
    else {
        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
        value %= kTen16;

        if (a < 10)
            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
        else if (a < 100) {
            const uint32_t i = a << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
        }
        else if (a < 1000) {
            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));

            const uint32_t i = (a % 100) << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
        }
        else {
            const uint32_t i = (a / 100) << 1;
            const uint32_t j = (a % 100) << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
            *buffer++ = cDigitsLut[j];
            *buffer++ = cDigitsLut[j + 1];
        }

        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);

        const uint32_t b0 = v0 / 10000;
        const uint32_t c0 = v0 % 10000;

        const uint32_t d1 = (b0 / 100) << 1;
        const uint32_t d2 = (b0 % 100) << 1;

        const uint32_t d3 = (c0 / 100) << 1;
        const uint32_t d4 = (c0 % 100) << 1;

        const uint32_t b1 = v1 / 10000;
        const uint32_t c1 = v1 % 10000;

        const uint32_t d5 = (b1 / 100) << 1;
        const uint32_t d6 = (b1 % 100) << 1;

        const uint32_t d7 = (c1 / 100) << 1;
        const uint32_t d8 = (c1 % 100) << 1;

        *buffer++ = cDigitsLut[d1];
        *buffer++ = cDigitsLut[d1 + 1];
        *buffer++ = cDigitsLut[d2];
        *buffer++ = cDigitsLut[d2 + 1];
        *buffer++ = cDigitsLut[d3];
        *buffer++ = cDigitsLut[d3 + 1];
        *buffer++ = cDigitsLut[d4];
        *buffer++ = cDigitsLut[d4 + 1];
        *buffer++ = cDigitsLut[d5];
        *buffer++ = cDigitsLut[d5 + 1];
        *buffer++ = cDigitsLut[d6];
        *buffer++ = cDigitsLut[d6 + 1];
        *buffer++ = cDigitsLut[d7];
        *buffer++ = cDigitsLut[d7 + 1];
        *buffer++ = cDigitsLut[d8];
        *buffer++ = cDigitsLut[d8 + 1];
    }

    return buffer;
}

inline char* i64toa(int64_t value, char* buffer) {
    CEREAL_RAPIDJSON_ASSERT(buffer != 0);
    uint64_t u = static_cast<uint64_t>(value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;
    }

    return u64toa(u, buffer);
}

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_ITOA_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/meta.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_INTERNAL_META_H_
#define CEREAL_RAPIDJSON_INTERNAL_META_H_

#include "../rapidjson.h"

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#if defined(_MSC_VER) && !defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(6334)
#endif

#if CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS
#include <type_traits>
#endif

//@cond CEREAL_RAPIDJSON_INTERNAL
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
template <typename T> struct Void { typedef void Type; };

///////////////////////////////////////////////////////////////////////////////
// BoolType, TrueType, FalseType
//
template <bool Cond> struct BoolType {
    static const bool Value = Cond;
    typedef BoolType Type;
};
typedef BoolType<true> TrueType;
typedef BoolType<false> FalseType;


///////////////////////////////////////////////////////////////////////////////
// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
//

template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};

template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
template <> struct AndExprCond<true, true> : TrueType {};
template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
template <> struct OrExprCond<false, false> : FalseType {};

template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};


///////////////////////////////////////////////////////////////////////////////
// AddConst, MaybeAddConst, RemoveConst
template <typename T> struct AddConst { typedef const T Type; };
template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
template <typename T> struct RemoveConst { typedef T Type; };
template <typename T> struct RemoveConst<const T> { typedef T Type; };


///////////////////////////////////////////////////////////////////////////////
// IsSame, IsConst, IsMoreConst, IsPointer
//
template <typename T, typename U> struct IsSame : FalseType {};
template <typename T> struct IsSame<T, T> : TrueType {};

template <typename T> struct IsConst : FalseType {};
template <typename T> struct IsConst<const T> : TrueType {};

template <typename CT, typename T>
struct IsMoreConst
    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};

template <typename T> struct IsPointer : FalseType {};
template <typename T> struct IsPointer<T*> : TrueType {};

///////////////////////////////////////////////////////////////////////////////
// IsBaseOf
//
#if CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS

template <typename B, typename D> struct IsBaseOf
    : BoolType< ::std::is_base_of<B,D>::value> {};

#else // simplified version adopted from Boost

template<typename B, typename D> struct IsBaseOfImpl {
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
    CEREAL_RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);

    typedef char (&Yes)[1];
    typedef char (&No) [2];

    template <typename T>
    static Yes Check(const D*, T);
    static No  Check(const B*, int);

    struct Host {
        operator const B*() const;
        operator const D*();
    };

    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
};

template <typename B, typename D> struct IsBaseOf
    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};

#endif // CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS


//////////////////////////////////////////////////////////////////////////
// EnableIf / DisableIf
//
template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
template <typename T> struct EnableIfCond<false, T> { /* empty */ };

template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
template <typename T> struct DisableIfCond<true, T> { /* empty */ };

template <typename Condition, typename T = void>
struct EnableIf : EnableIfCond<Condition::Value, T> {};

template <typename Condition, typename T = void>
struct DisableIf : DisableIfCond<Condition::Value, T> {};

// SFINAE helpers
struct SfinaeTag {};
template <typename T> struct RemoveSfinaeTag;
template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };

#define CEREAL_RAPIDJSON_REMOVEFPTR_(type) \
    typename ::CEREAL_RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
        < ::CEREAL_RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type

#define CEREAL_RAPIDJSON_ENABLEIF(cond) \
    typename ::CEREAL_RAPIDJSON_NAMESPACE::internal::EnableIf \
        <CEREAL_RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL

#define CEREAL_RAPIDJSON_DISABLEIF(cond) \
    typename ::CEREAL_RAPIDJSON_NAMESPACE::internal::DisableIf \
        <CEREAL_RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL

#define CEREAL_RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
    typename ::CEREAL_RAPIDJSON_NAMESPACE::internal::EnableIf \
        <CEREAL_RAPIDJSON_REMOVEFPTR_(cond), \
         CEREAL_RAPIDJSON_REMOVEFPTR_(returntype)>::Type

#define CEREAL_RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
    typename ::CEREAL_RAPIDJSON_NAMESPACE::internal::DisableIf \
        <CEREAL_RAPIDJSON_REMOVEFPTR_(cond), \
         CEREAL_RAPIDJSON_REMOVEFPTR_(returntype)>::Type

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END
//@endcond

#if defined(_MSC_VER) && !defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_INTERNAL_META_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/pow10.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_POW10_
#define CEREAL_RAPIDJSON_POW10_

#include "../rapidjson.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

//! Computes integer powers of 10 in double (10.0^n).
/*! This function uses lookup table for fast and accurate results.
    \param n non-negative exponent. Must <= 308.
    \return 10.0^n
*/
inline double Pow10(int n) {
    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
        1e+0,  
        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
    };
    CEREAL_RAPIDJSON_ASSERT(n >= 0 && n <= 308);
    return e[n];
}

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_POW10_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/regex.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_INTERNAL_REGEX_H_
#define CEREAL_RAPIDJSON_INTERNAL_REGEX_H_

#include "../allocators.h"
#include "../stream.h"
#include "stack.h"

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
CEREAL_RAPIDJSON_DIAG_OFF(implicit-fallthrough)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#if __GNUC__ >= 7
CEREAL_RAPIDJSON_DIAG_OFF(implicit-fallthrough)
#endif
#endif

#ifndef CEREAL_RAPIDJSON_REGEX_VERBOSE
#define CEREAL_RAPIDJSON_REGEX_VERBOSE 0
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

///////////////////////////////////////////////////////////////////////////////
// DecodedStream

template <typename SourceStream, typename Encoding>
class DecodedStream {
public:
    DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
    unsigned Peek() { return codepoint_; }
    unsigned Take() {
        unsigned c = codepoint_;
        if (c) // No further decoding when '\0'
            Decode();
        return c;
    }

private:
    void Decode() {
        if (!Encoding::Decode(ss_, &codepoint_))
            codepoint_ = 0;
    }

    SourceStream& ss_;
    unsigned codepoint_;
};

///////////////////////////////////////////////////////////////////////////////
// GenericRegex

static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
static const SizeType kRegexInvalidRange = ~SizeType(0);

template <typename Encoding, typename Allocator>
class GenericRegexSearch;

//! Regular expression engine with subset of ECMAscript grammar.
/*!
    Supported regular expression syntax:
    - \c ab     Concatenation
    - \c a|b    Alternation
    - \c a?     Zero or one
    - \c a*     Zero or more
    - \c a+     One or more
    - \c a{3}   Exactly 3 times
    - \c a{3,}  At least 3 times
    - \c a{3,5} 3 to 5 times
    - \c (ab)   Grouping
    - \c ^a     At the beginning
    - \c a$     At the end
    - \c .      Any character
    - \c [abc]  Character classes
    - \c [a-c]  Character class range
    - \c [a-z0-9_] Character class combination
    - \c [^abc] Negated character classes
    - \c [^a-c] Negated character class range
    - \c [\b]   Backspace (U+0008)
    - \c \\| \\\\ ...  Escape characters
    - \c \\f Form feed (U+000C)
    - \c \\n Line feed (U+000A)
    - \c \\r Carriage return (U+000D)
    - \c \\t Tab (U+0009)
    - \c \\v Vertical tab (U+000B)

    \note This is a Thompson NFA engine, implemented with reference to 
        Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", 
        https://swtch.com/~rsc/regexp/regexp1.html 
*/
template <typename Encoding, typename Allocator = CrtAllocator>
class GenericRegex {
public:
    typedef Encoding EncodingType;
    typedef typename Encoding::Ch Ch;
    template <typename, typename> friend class GenericRegexSearch;

    GenericRegex(const Ch* source, Allocator* allocator = 0) : 
        ownAllocator_(allocator ? 0 : CEREAL_RAPIDJSON_NEW(Allocator)()), allocator_(allocator ? allocator : ownAllocator_), 
        states_(allocator_, 256), ranges_(allocator_, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
        anchorBegin_(), anchorEnd_()
    {
        GenericStringStream<Encoding> ss(source);
        DecodedStream<GenericStringStream<Encoding>, Encoding> ds(ss);
        Parse(ds);
    }

    ~GenericRegex()
    {
        CEREAL_RAPIDJSON_DELETE(ownAllocator_);
    }

    bool IsValid() const {
        return root_ != kRegexInvalidState;
    }

private:
    enum Operator {
        kZeroOrOne,
        kZeroOrMore,
        kOneOrMore,
        kConcatenation,
        kAlternation,
        kLeftParenthesis
    };

    static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
    static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
    static const unsigned kRangeNegationFlag = 0x80000000;

    struct Range {
        unsigned start; // 
        unsigned end;
        SizeType next;
    };

    struct State {
        SizeType out;     //!< Equals to kInvalid for matching state
        SizeType out1;    //!< Equals to non-kInvalid for split
        SizeType rangeStart;
        unsigned codepoint;
    };

    struct Frag {
        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
        SizeType start;
        SizeType out; //!< link-list of all output states
        SizeType minIndex;
    };

    State& GetState(SizeType index) {
        CEREAL_RAPIDJSON_ASSERT(index < stateCount_);
        return states_.template Bottom<State>()[index];
    }

    const State& GetState(SizeType index) const {
        CEREAL_RAPIDJSON_ASSERT(index < stateCount_);
        return states_.template Bottom<State>()[index];
    }

    Range& GetRange(SizeType index) {
        CEREAL_RAPIDJSON_ASSERT(index < rangeCount_);
        return ranges_.template Bottom<Range>()[index];
    }

    const Range& GetRange(SizeType index) const {
        CEREAL_RAPIDJSON_ASSERT(index < rangeCount_);
        return ranges_.template Bottom<Range>()[index];
    }

    template <typename InputStream>
    void Parse(DecodedStream<InputStream, Encoding>& ds) {
        Stack<Allocator> operandStack(allocator_, 256);    // Frag
        Stack<Allocator> operatorStack(allocator_, 256);   // Operator
        Stack<Allocator> atomCountStack(allocator_, 256);  // unsigned (Atom per parenthesis)

        *atomCountStack.template Push<unsigned>() = 0;

        unsigned codepoint;
        while (ds.Peek() != 0) {
            switch (codepoint = ds.Take()) {
                case '^':
                    anchorBegin_ = true;
                    break;

                case '$':
                    anchorEnd_ = true;
                    break;

                case '|':
                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
                            return;
                    *operatorStack.template Push<Operator>() = kAlternation;
                    *atomCountStack.template Top<unsigned>() = 0;
                    break;

                case '(':
                    *operatorStack.template Push<Operator>() = kLeftParenthesis;
                    *atomCountStack.template Push<unsigned>() = 0;
                    break;

                case ')':
                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
                            return;
                    if (operatorStack.Empty())
                        return;
                    operatorStack.template Pop<Operator>(1);
                    atomCountStack.template Pop<unsigned>(1);
                    ImplicitConcatenation(atomCountStack, operatorStack);
                    break;

                case '?':
                    if (!Eval(operandStack, kZeroOrOne))
                        return;
                    break;

                case '*':
                    if (!Eval(operandStack, kZeroOrMore))
                        return;
                    break;

                case '+':
                    if (!Eval(operandStack, kOneOrMore))
                        return;
                    break;

                case '{':
                    {
                        unsigned n, m;
                        if (!ParseUnsigned(ds, &n))
                            return;

                        if (ds.Peek() == ',') {
                            ds.Take();
                            if (ds.Peek() == '}')
                                m = kInfinityQuantifier;
                            else if (!ParseUnsigned(ds, &m) || m < n)
                                return;
                        }
                        else
                            m = n;

                        if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
                            return;
                        ds.Take();
                    }
                    break;

                case '.':
                    PushOperand(operandStack, kAnyCharacterClass);
                    ImplicitConcatenation(atomCountStack, operatorStack);
                    break;

                case '[':
                    {
                        SizeType range;
                        if (!ParseRange(ds, &range))
                            return;
                        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
                        GetState(s).rangeStart = range;
                        *operandStack.template Push<Frag>() = Frag(s, s, s);
                    }
                    ImplicitConcatenation(atomCountStack, operatorStack);
                    break;

                case '\\': // Escape character
                    if (!CharacterEscape(ds, &codepoint))
                        return; // Unsupported escape character
                    // fall through to default

                default: // Pattern character
                    PushOperand(operandStack, codepoint);
                    ImplicitConcatenation(atomCountStack, operatorStack);
            }
        }

        while (!operatorStack.Empty())
            if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
                return;

        // Link the operand to matching state.
        if (operandStack.GetSize() == sizeof(Frag)) {
            Frag* e = operandStack.template Pop<Frag>(1);
            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
            root_ = e->start;

#if CEREAL_RAPIDJSON_REGEX_VERBOSE
            printf("root: %d\n", root_);
            for (SizeType i = 0; i < stateCount_ ; i++) {
                State& s = GetState(i);
                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
            }
            printf("\n");
#endif
        }
    }

    SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
        State* s = states_.template Push<State>();
        s->out = out;
        s->out1 = out1;
        s->codepoint = codepoint;
        s->rangeStart = kRegexInvalidRange;
        return stateCount_++;
    }

    void PushOperand(Stack<Allocator>& operandStack, unsigned codepoint) {
        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
        *operandStack.template Push<Frag>() = Frag(s, s, s);
    }

    void ImplicitConcatenation(Stack<Allocator>& atomCountStack, Stack<Allocator>& operatorStack) {
        if (*atomCountStack.template Top<unsigned>())
            *operatorStack.template Push<Operator>() = kConcatenation;
        (*atomCountStack.template Top<unsigned>())++;
    }

    SizeType Append(SizeType l1, SizeType l2) {
        SizeType old = l1;
        while (GetState(l1).out != kRegexInvalidState)
            l1 = GetState(l1).out;
        GetState(l1).out = l2;
        return old;
    }

    void Patch(SizeType l, SizeType s) {
        for (SizeType next; l != kRegexInvalidState; l = next) {
            next = GetState(l).out;
            GetState(l).out = s;
        }
    }

    bool Eval(Stack<Allocator>& operandStack, Operator op) {
        switch (op) {
            case kConcatenation:
                CEREAL_RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
                {
                    Frag e2 = *operandStack.template Pop<Frag>(1);
                    Frag e1 = *operandStack.template Pop<Frag>(1);
                    Patch(e1.out, e2.start);
                    *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
                }
                return true;

            case kAlternation:
                if (operandStack.GetSize() >= sizeof(Frag) * 2) {
                    Frag e2 = *operandStack.template Pop<Frag>(1);
                    Frag e1 = *operandStack.template Pop<Frag>(1);
                    SizeType s = NewState(e1.start, e2.start, 0);
                    *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
                    return true;
                }
                return false;

            case kZeroOrOne:
                if (operandStack.GetSize() >= sizeof(Frag)) {
                    Frag e = *operandStack.template Pop<Frag>(1);
                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
                    *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
                    return true;
                }
                return false;

            case kZeroOrMore:
                if (operandStack.GetSize() >= sizeof(Frag)) {
                    Frag e = *operandStack.template Pop<Frag>(1);
                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
                    Patch(e.out, s);
                    *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
                    return true;
                }
                return false;

            case kOneOrMore:
                if (operandStack.GetSize() >= sizeof(Frag)) {
                    Frag e = *operandStack.template Pop<Frag>(1);
                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
                    Patch(e.out, s);
                    *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
                    return true;
                }
                return false;

            default: 
                // syntax error (e.g. unclosed kLeftParenthesis)
                return false;
        }
    }

    bool EvalQuantifier(Stack<Allocator>& operandStack, unsigned n, unsigned m) {
        CEREAL_RAPIDJSON_ASSERT(n <= m);
        CEREAL_RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));

        if (n == 0) {
            if (m == 0)                             // a{0} not support
                return false;
            else if (m == kInfinityQuantifier)
                Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
            else {
                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
                for (unsigned i = 0; i < m - 1; i++)
                    CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
                for (unsigned i = 0; i < m - 1; i++)
                    Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
            }
            return true;
        }

        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
            CloneTopOperand(operandStack);

        if (m == kInfinityQuantifier)
            Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
        else if (m > n) {
            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
            for (unsigned i = n; i < m - 1; i++)
                CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
            for (unsigned i = n; i < m; i++)
                Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
        }

        for (unsigned i = 0; i < n - 1; i++)
            Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?

        return true;
    }

    static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; }

    void CloneTopOperand(Stack<Allocator>& operandStack) {
        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
        State* s = states_.template Push<State>(count);
        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
        for (SizeType j = 0; j < count; j++) {
            if (s[j].out != kRegexInvalidState)
                s[j].out += count;
            if (s[j].out1 != kRegexInvalidState)
                s[j].out1 += count;
        }
        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
        stateCount_ += count;
    }

    template <typename InputStream>
    bool ParseUnsigned(DecodedStream<InputStream, Encoding>& ds, unsigned* u) {
        unsigned r = 0;
        if (ds.Peek() < '0' || ds.Peek() > '9')
            return false;
        while (ds.Peek() >= '0' && ds.Peek() <= '9') {
            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
                return false; // overflow
            r = r * 10 + (ds.Take() - '0');
        }
        *u = r;
        return true;
    }

    template <typename InputStream>
    bool ParseRange(DecodedStream<InputStream, Encoding>& ds, SizeType* range) {
        bool isBegin = true;
        bool negate = false;
        int step = 0;
        SizeType start = kRegexInvalidRange;
        SizeType current = kRegexInvalidRange;
        unsigned codepoint;
        while ((codepoint = ds.Take()) != 0) {
            if (isBegin) {
                isBegin = false;
                if (codepoint == '^') {
                    negate = true;
                    continue;
                }
            }

            switch (codepoint) {
            case ']':
                if (start == kRegexInvalidRange)
                    return false;   // Error: nothing inside []
                if (step == 2) { // Add trailing '-'
                    SizeType r = NewRange('-');
                    CEREAL_RAPIDJSON_ASSERT(current != kRegexInvalidRange);
                    GetRange(current).next = r;
                }
                if (negate)
                    GetRange(start).start |= kRangeNegationFlag;
                *range = start;
                return true;

            case '\\':
                if (ds.Peek() == 'b') {
                    ds.Take();
                    codepoint = 0x0008; // Escape backspace character
                }
                else if (!CharacterEscape(ds, &codepoint))
                    return false;
                // fall through to default

            default:
                switch (step) {
                case 1:
                    if (codepoint == '-') {
                        step++;
                        break;
                    }
                    // fall through to step 0 for other characters

                case 0:
                    {
                        SizeType r = NewRange(codepoint);
                        if (current != kRegexInvalidRange)
                            GetRange(current).next = r;
                        if (start == kRegexInvalidRange)
                            start = r;
                        current = r;
                    }
                    step = 1;
                    break;

                default:
                    CEREAL_RAPIDJSON_ASSERT(step == 2);
                    GetRange(current).end = codepoint;
                    step = 0;
                }
            }
        }
        return false;
    }
    
    SizeType NewRange(unsigned codepoint) {
        Range* r = ranges_.template Push<Range>();
        r->start = r->end = codepoint;
        r->next = kRegexInvalidRange;
        return rangeCount_++;
    }

    template <typename InputStream>
    bool CharacterEscape(DecodedStream<InputStream, Encoding>& ds, unsigned* escapedCodepoint) {
        unsigned codepoint;
        switch (codepoint = ds.Take()) {
            case '^':
            case '$':
            case '|':
            case '(':
            case ')':
            case '?':
            case '*':
            case '+':
            case '.':
            case '[':
            case ']':
            case '{':
            case '}':
            case '\\':
                *escapedCodepoint = codepoint; return true;
            case 'f': *escapedCodepoint = 0x000C; return true;
            case 'n': *escapedCodepoint = 0x000A; return true;
            case 'r': *escapedCodepoint = 0x000D; return true;
            case 't': *escapedCodepoint = 0x0009; return true;
            case 'v': *escapedCodepoint = 0x000B; return true;
            default:
                return false; // Unsupported escape character
        }
    }

    Allocator* ownAllocator_;
    Allocator* allocator_;
    Stack<Allocator> states_;
    Stack<Allocator> ranges_;
    SizeType root_;
    SizeType stateCount_;
    SizeType rangeCount_;

    static const unsigned kInfinityQuantifier = ~0u;

    // For SearchWithAnchoring()
    bool anchorBegin_;
    bool anchorEnd_;
};

template <typename RegexType, typename Allocator = CrtAllocator>
class GenericRegexSearch {
public:
    typedef typename RegexType::EncodingType Encoding;
    typedef typename Encoding::Ch Ch;

    GenericRegexSearch(const RegexType& regex, Allocator* allocator = 0) : 
        regex_(regex), allocator_(allocator), ownAllocator_(0),
        state0_(allocator, 0), state1_(allocator, 0), stateSet_()
    {
        CEREAL_RAPIDJSON_ASSERT(regex_.IsValid());
        if (!allocator_)
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
        stateSet_ = static_cast<unsigned*>(allocator_->Malloc(GetStateSetSize()));
        state0_.template Reserve<SizeType>(regex_.stateCount_);
        state1_.template Reserve<SizeType>(regex_.stateCount_);
    }

    ~GenericRegexSearch() {
        Allocator::Free(stateSet_);
        CEREAL_RAPIDJSON_DELETE(ownAllocator_);
    }

    template <typename InputStream>
    bool Match(InputStream& is) {
        return SearchWithAnchoring(is, true, true);
    }

    bool Match(const Ch* s) {
        GenericStringStream<Encoding> is(s);
        return Match(is);
    }

    template <typename InputStream>
    bool Search(InputStream& is) {
        return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
    }

    bool Search(const Ch* s) {
        GenericStringStream<Encoding> is(s);
        return Search(is);
    }

private:
    typedef typename RegexType::State State;
    typedef typename RegexType::Range Range;

    template <typename InputStream>
    bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) {
        DecodedStream<InputStream, Encoding> ds(is);

        state0_.Clear();
        Stack<Allocator> *current = &state0_, *next = &state1_;
        const size_t stateSetSize = GetStateSetSize();
        std::memset(stateSet_, 0, stateSetSize);

        bool matched = AddState(*current, regex_.root_);
        unsigned codepoint;
        while (!current->Empty() && (codepoint = ds.Take()) != 0) {
            std::memset(stateSet_, 0, stateSetSize);
            next->Clear();
            matched = false;
            for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
                const State& sr = regex_.GetState(*s);
                if (sr.codepoint == codepoint ||
                    sr.codepoint == RegexType::kAnyCharacterClass || 
                    (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
                {
                    matched = AddState(*next, sr.out) || matched;
                    if (!anchorEnd && matched)
                        return true;
                }
                if (!anchorBegin)
                    AddState(*next, regex_.root_);
            }
            internal::Swap(current, next);
        }

        return matched;
    }

    size_t GetStateSetSize() const {
        return (regex_.stateCount_ + 31) / 32 * 4;
    }

    // Return whether the added states is a match state
    bool AddState(Stack<Allocator>& l, SizeType index) {
        CEREAL_RAPIDJSON_ASSERT(index != kRegexInvalidState);

        const State& s = regex_.GetState(index);
        if (s.out1 != kRegexInvalidState) { // Split
            bool matched = AddState(l, s.out);
            return AddState(l, s.out1) || matched;
        }
        else if (!(stateSet_[index >> 5] & (1u << (index & 31)))) {
            stateSet_[index >> 5] |= (1u << (index & 31));
            *l.template PushUnsafe<SizeType>() = index;
        }
        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
    }

    bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
        bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
        while (rangeIndex != kRegexInvalidRange) {
            const Range& r = regex_.GetRange(rangeIndex);
            if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
                return yes;
            rangeIndex = r.next;
        }
        return !yes;
    }

    const RegexType& regex_;
    Allocator* allocator_;
    Allocator* ownAllocator_;
    Stack<Allocator> state0_;
    Stack<Allocator> state1_;
    uint32_t* stateSet_;
};

typedef GenericRegex<UTF8<> > Regex;
typedef GenericRegexSearch<Regex> RegexSearch;

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_INTERNAL_REGEX_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/stack.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_INTERNAL_STACK_H_
#define CEREAL_RAPIDJSON_INTERNAL_STACK_H_

#include "../allocators.h"
#include "swap.h"
#include <cstddef>

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

///////////////////////////////////////////////////////////////////////////////
// Stack

//! A type-unsafe stack for storing different types of data.
/*! \tparam Allocator Allocator for allocating stack memory.
*/
template <typename Allocator>
class Stack {
public:
    // Optimization note: Do not allocate memory for stack_ in constructor.
    // Do it lazily when first Push() -> Expand() -> Resize().
    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    Stack(Stack&& rhs)
        : allocator_(rhs.allocator_),
          ownAllocator_(rhs.ownAllocator_),
          stack_(rhs.stack_),
          stackTop_(rhs.stackTop_),
          stackEnd_(rhs.stackEnd_),
          initialCapacity_(rhs.initialCapacity_)
    {
        rhs.allocator_ = 0;
        rhs.ownAllocator_ = 0;
        rhs.stack_ = 0;
        rhs.stackTop_ = 0;
        rhs.stackEnd_ = 0;
        rhs.initialCapacity_ = 0;
    }
#endif

    ~Stack() {
        Destroy();
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    Stack& operator=(Stack&& rhs) {
        if (&rhs != this)
        {
            Destroy();

            allocator_ = rhs.allocator_;
            ownAllocator_ = rhs.ownAllocator_;
            stack_ = rhs.stack_;
            stackTop_ = rhs.stackTop_;
            stackEnd_ = rhs.stackEnd_;
            initialCapacity_ = rhs.initialCapacity_;

            rhs.allocator_ = 0;
            rhs.ownAllocator_ = 0;
            rhs.stack_ = 0;
            rhs.stackTop_ = 0;
            rhs.stackEnd_ = 0;
            rhs.initialCapacity_ = 0;
        }
        return *this;
    }
#endif

    void Swap(Stack& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
        internal::Swap(allocator_, rhs.allocator_);
        internal::Swap(ownAllocator_, rhs.ownAllocator_);
        internal::Swap(stack_, rhs.stack_);
        internal::Swap(stackTop_, rhs.stackTop_);
        internal::Swap(stackEnd_, rhs.stackEnd_);
        internal::Swap(initialCapacity_, rhs.initialCapacity_);
    }

    void Clear() { stackTop_ = stack_; }

    void ShrinkToFit() { 
        if (Empty()) {
            // If the stack is empty, completely deallocate the memory.
            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
            stack_ = 0;
            stackTop_ = 0;
            stackEnd_ = 0;
        }
        else
            Resize(GetSize());
    }

    // Optimization note: try to minimize the size of this function for force inline.
    // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
    template<typename T>
    CEREAL_RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
         // Expand the stack if needed
        if (CEREAL_RAPIDJSON_UNLIKELY(static_cast<std::ptrdiff_t>(sizeof(T) * count) > (stackEnd_ - stackTop_)))
            Expand<T>(count);
    }

    template<typename T>
    CEREAL_RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
        Reserve<T>(count);
        return PushUnsafe<T>(count);
    }

    template<typename T>
    CEREAL_RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
        CEREAL_RAPIDJSON_ASSERT(stackTop_);
        CEREAL_RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_));
        T* ret = reinterpret_cast<T*>(stackTop_);
        stackTop_ += sizeof(T) * count;
        return ret;
    }

    template<typename T>
    T* Pop(size_t count) {
        CEREAL_RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
        stackTop_ -= count * sizeof(T);
        return reinterpret_cast<T*>(stackTop_);
    }

    template<typename T>
    T* Top() { 
        CEREAL_RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
    }

    template<typename T>
    const T* Top() const {
        CEREAL_RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
    }

    template<typename T>
    T* End() { return reinterpret_cast<T*>(stackTop_); }

    template<typename T>
    const T* End() const { return reinterpret_cast<T*>(stackTop_); }

    template<typename T>
    T* Bottom() { return reinterpret_cast<T*>(stack_); }

    template<typename T>
    const T* Bottom() const { return reinterpret_cast<T*>(stack_); }

    bool HasAllocator() const {
        return allocator_ != 0;
    }

    Allocator& GetAllocator() {
        CEREAL_RAPIDJSON_ASSERT(allocator_);
        return *allocator_;
    }

    bool Empty() const { return stackTop_ == stack_; }
    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }

private:
    template<typename T>
    void Expand(size_t count) {
        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
        size_t newCapacity;
        if (stack_ == 0) {
            if (!allocator_)
                ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();
            newCapacity = initialCapacity_;
        } else {
            newCapacity = GetCapacity();
            newCapacity += (newCapacity + 1) / 2;
        }
        size_t newSize = GetSize() + sizeof(T) * count;
        if (newCapacity < newSize)
            newCapacity = newSize;

        Resize(newCapacity);
    }

    void Resize(size_t newCapacity) {
        const size_t size = GetSize();  // Backup the current size
        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
        stackTop_ = stack_ + size;
        stackEnd_ = stack_ + newCapacity;
    }

    void Destroy() {
        Allocator::Free(stack_);
        CEREAL_RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
    }

    // Prohibit copy constructor & assignment operator.
    Stack(const Stack&);
    Stack& operator=(const Stack&);

    Allocator* allocator_;
    Allocator* ownAllocator_;
    char *stack_;
    char *stackTop_;
    char *stackEnd_;
    size_t initialCapacity_;
};

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_STACK_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/strfunc.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_
#define CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_

#include "../stream.h"
#include <cwchar>

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

//! Custom strlen() which works on different character types.
/*! \tparam Ch Character type (e.g. char, wchar_t, short)
    \param s Null-terminated input string.
    \return Number of characters in the string. 
    \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
*/
template <typename Ch>
inline SizeType StrLen(const Ch* s) {
    CEREAL_RAPIDJSON_ASSERT(s != 0);
    const Ch* p = s;
    while (*p) ++p;
    return SizeType(p - s);
}

template <>
inline SizeType StrLen(const char* s) {
    return SizeType(std::strlen(s));
}

template <>
inline SizeType StrLen(const wchar_t* s) {
    return SizeType(std::wcslen(s));
}

//! Returns number of code points in a encoded string.
template<typename Encoding>
bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
    CEREAL_RAPIDJSON_ASSERT(s != 0);
    CEREAL_RAPIDJSON_ASSERT(outCount != 0);
    GenericStringStream<Encoding> is(s);
    const typename Encoding::Ch* end = s + length;
    SizeType count = 0;
    while (is.src_ < end) {
        unsigned codepoint;
        if (!Encoding::Decode(is, &codepoint))
            return false;
        count++;
    }
    *outCount = count;
    return true;
}

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_INTERNAL_STRFUNC_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/strtod.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_STRTOD_
#define CEREAL_RAPIDJSON_STRTOD_

#include "ieee754.h"
#include "biginteger.h"
#include "diyfp.h"
#include "pow10.h"
#include <climits>
#include <limits>

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

inline double FastPath(double significand, int exp) {
    if (exp < -308)
        return 0.0;
    else if (exp >= 0)
        return significand * internal::Pow10(exp);
    else
        return significand / internal::Pow10(-exp);
}

inline double StrtodNormalPrecision(double d, int p) {
    if (p < -308) {
        // Prevent expSum < -308, making Pow10(p) = 0
        d = FastPath(d, -308);
        d = FastPath(d, p + 308);
    }
    else
        d = FastPath(d, p);
    return d;
}

template <typename T>
inline T Min3(T a, T b, T c) {
    T m = a;
    if (m > b) m = b;
    if (m > c) m = c;
    return m;
}

inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
    const Double db(b);
    const uint64_t bInt = db.IntegerSignificand();
    const int bExp = db.IntegerExponent();
    const int hExp = bExp - 1;

    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;

    // Adjust for decimal exponent
    if (dExp >= 0) {
        dS_Exp2 += dExp;
        dS_Exp5 += dExp;
    }
    else {
        bS_Exp2 -= dExp;
        bS_Exp5 -= dExp;
        hS_Exp2 -= dExp;
        hS_Exp5 -= dExp;
    }

    // Adjust for binary exponent
    if (bExp >= 0)
        bS_Exp2 += bExp;
    else {
        dS_Exp2 -= bExp;
        hS_Exp2 -= bExp;
    }

    // Adjust for half ulp exponent
    if (hExp >= 0)
        hS_Exp2 += hExp;
    else {
        dS_Exp2 -= hExp;
        bS_Exp2 -= hExp;
    }

    // Remove common power of two factor from all three scaled values
    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
    dS_Exp2 -= common_Exp2;
    bS_Exp2 -= common_Exp2;
    hS_Exp2 -= common_Exp2;

    BigInteger dS = d;
    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);

    BigInteger bS(bInt);
    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);

    BigInteger hS(1);
    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);

    BigInteger delta(0);
    dS.Difference(bS, &delta);

    return delta.Compare(hS);
}

inline bool StrtodFast(double d, int p, double* result) {
    // Use fast path for string-to-double conversion if possible
    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
    if (p > 22  && p < 22 + 16) {
        // Fast Path Cases In Disguise
        d *= internal::Pow10(p - 22);
        p = 22;
    }

    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
        *result = FastPath(d, p);
        return true;
    }
    else
        return false;
}

// Compute an approximation and see if it is within 1/2 ULP
inline bool StrtodDiyFp(const char* decimals, int dLen, int dExp, double* result) {
    uint64_t significand = 0;
    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
    for (; i < dLen; i++) {
        if (significand  >  CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
            (significand == CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
            break;
        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
    }
    
    if (i < dLen && decimals[i] >= '5') // Rounding
        significand++;

    int remaining = dLen - i;
    const int kUlpShift = 3;
    const int kUlp = 1 << kUlpShift;
    int64_t error = (remaining == 0) ? 0 : kUlp / 2;

    DiyFp v(significand, 0);
    v = v.Normalize();
    error <<= -v.e;

    dExp += remaining;

    int actualExp;
    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
    if (actualExp != dExp) {
        static const DiyFp kPow10[] = {
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
            DiyFp(CEREAL_RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
        };
        int adjustment = dExp - actualExp;
        CEREAL_RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
        v = v * kPow10[adjustment - 1];
        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
            error += kUlp / 2;
    }

    v = v * cachedPower;

    error += kUlp + (error == 0 ? 0 : 1);

    const int oldExp = v.e;
    v = v.Normalize();
    error <<= oldExp - v.e;

    const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
    int precisionSize = 64 - effectiveSignificandSize;
    if (precisionSize + kUlpShift >= 64) {
        int scaleExp = (precisionSize + kUlpShift) - 63;
        v.f >>= scaleExp;
        v.e += scaleExp; 
        error = (error >> scaleExp) + 1 + kUlp;
        precisionSize -= scaleExp;
    }

    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
        rounded.f++;
        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
            rounded.f >>= 1;
            rounded.e++;
        }
    }

    *result = rounded.ToDouble();

    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
}

inline double StrtodBigInteger(double approx, const char* decimals, int dLen, int dExp) {
    CEREAL_RAPIDJSON_ASSERT(dLen >= 0);
    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
    Double a(approx);
    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
    if (cmp < 0)
        return a.Value();  // within half ULP
    else if (cmp == 0) {
        // Round towards even
        if (a.Significand() & 1)
            return a.NextPositiveDouble();
        else
            return a.Value();
    }
    else // adjustment
        return a.NextPositiveDouble();
}

inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
    CEREAL_RAPIDJSON_ASSERT(d >= 0.0);
    CEREAL_RAPIDJSON_ASSERT(length >= 1);

    double result = 0.0;
    if (StrtodFast(d, p, &result))
        return result;

    CEREAL_RAPIDJSON_ASSERT(length <= INT_MAX);
    int dLen = static_cast<int>(length);

    CEREAL_RAPIDJSON_ASSERT(length >= decimalPosition);
    CEREAL_RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
    int dExpAdjust = static_cast<int>(length - decimalPosition);

    CEREAL_RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
    int dExp = exp - dExpAdjust;

    // Make sure length+dExp does not overflow
    CEREAL_RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);

    // Trim leading zeros
    while (dLen > 0 && *decimals == '0') {
        dLen--;
        decimals++;
    }

    // Trim trailing zeros
    while (dLen > 0 && decimals[dLen - 1] == '0') {
        dLen--;
        dExp++;
    }

    if (dLen == 0) { // Buffer only contains zeros.
        return 0.0;
    }

    // Trim right-most digits
    const int kMaxDecimalDigit = 767 + 1;
    if (dLen > kMaxDecimalDigit) {
        dExp += dLen - kMaxDecimalDigit;
        dLen = kMaxDecimalDigit;
    }

    // If too small, underflow to zero.
    // Any x <= 10^-324 is interpreted as zero.
    if (dLen + dExp <= -324)
        return 0.0;

    // If too large, overflow to infinity.
    // Any x >= 10^309 is interpreted as +infinity.
    if (dLen + dExp > 309)
        return std::numeric_limits<double>::infinity();

    if (StrtodDiyFp(decimals, dLen, dExp, &result))
        return result;

    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
    return StrtodBigInteger(result, decimals, dLen, dExp);
}

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_STRTOD_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/swap.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_INTERNAL_SWAP_H_
#define CEREAL_RAPIDJSON_INTERNAL_SWAP_H_

#include "../rapidjson.h"

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN
namespace internal {

//! Custom swap() to avoid dependency on C++ <algorithm> header
/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
    \note This has the same semantics as std::swap().
*/
template <typename T>
inline void Swap(T& a, T& b) CEREAL_RAPIDJSON_NOEXCEPT {
    T tmp = a;
        a = b;
        b = tmp;
}

} // namespace internal
CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_INTERNAL_SWAP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/istreamwrapper.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_
#define CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_

#include "stream.h"
#include <iosfwd>
#include <ios>

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
/*!
    The classes can be wrapped including but not limited to:

    - \c std::istringstream
    - \c std::stringstream
    - \c std::wistringstream
    - \c std::wstringstream
    - \c std::ifstream
    - \c std::fstream
    - \c std::wifstream
    - \c std::wfstream

    \tparam StreamType Class derived from \c std::basic_istream.
*/
   
template <typename StreamType>
class BasicIStreamWrapper {
public:
    typedef typename StreamType::char_type Ch;

    //! Constructor.
    /*!
        \param stream stream opened for read.
    */
    BasicIStreamWrapper(StreamType &stream) : stream_(stream), buffer_(peekBuffer_), bufferSize_(4), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
        Read();
    }

    //! Constructor.
    /*!
        \param stream stream opened for read.
        \param buffer user-supplied buffer.
        \param bufferSize size of buffer in bytes. Must >=4 bytes.
    */
    BasicIStreamWrapper(StreamType &stream, char* buffer, size_t bufferSize) : stream_(stream), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
        CEREAL_RAPIDJSON_ASSERT(bufferSize >= 4);
        Read();
    }

    Ch Peek() const { return *current_; }
    Ch Take() { Ch c = *current_; Read(); return c; }
    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }

    // Not implemented
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); } 
    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

    // For encoding detection only.
    const Ch* Peek4() const {
        return (current_ + 4 - !eof_ <= bufferLast_) ? current_ : 0;
    }

private:
    BasicIStreamWrapper();
    BasicIStreamWrapper(const BasicIStreamWrapper&);
    BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);

    void Read() {
        if (current_ < bufferLast_)
            ++current_;
        else if (!eof_) {
            count_ += readCount_;
            readCount_ = bufferSize_;
            bufferLast_ = buffer_ + readCount_ - 1;
            current_ = buffer_;

            if (!stream_.read(buffer_, static_cast<std::streamsize>(bufferSize_))) {
                readCount_ = static_cast<size_t>(stream_.gcount());
                *(bufferLast_ = buffer_ + readCount_) = '\0';
                eof_ = true;
            }
        }
    }

    StreamType &stream_;
    Ch peekBuffer_[4], *buffer_;
    size_t bufferSize_;
    Ch *bufferLast_;
    Ch *current_;
    size_t readCount_;
    size_t count_;  //!< Number of characters read
    bool eof_;
};

typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;

#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_ISTREAMWRAPPER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/memorybuffer.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_MEMORYBUFFER_H_
#define CEREAL_RAPIDJSON_MEMORYBUFFER_H_

#include "stream.h"
#include "internal/stack.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Represents an in-memory output byte stream.
/*!
    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.

    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.

    Differences between MemoryBuffer and StringBuffer:
    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.

    \tparam Allocator type for allocating memory buffer.
    \note implements Stream concept
*/
template <typename Allocator = CrtAllocator>
struct GenericMemoryBuffer {
    typedef char Ch; // byte

    GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}

    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
    void Flush() {}

    void Clear() { stack_.Clear(); }
    void ShrinkToFit() { stack_.ShrinkToFit(); }
    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
    void Pop(size_t count) { stack_.template Pop<Ch>(count); }

    const Ch* GetBuffer() const {
        return stack_.template Bottom<Ch>();
    }

    size_t GetSize() const { return stack_.GetSize(); }

    static const size_t kDefaultCapacity = 256;
    mutable internal::Stack<Allocator> stack_;
};

typedef GenericMemoryBuffer<> MemoryBuffer;

//! Implement specialized version of PutN() with memset() for better performance.
template<>
inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
    std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
}

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_MEMORYBUFFER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/memorystream.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_MEMORYSTREAM_H_
#define CEREAL_RAPIDJSON_MEMORYSTREAM_H_

#include "stream.h"

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
CEREAL_RAPIDJSON_DIAG_OFF(missing-noreturn)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Represents an in-memory input byte stream.
/*!
    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.

    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.

    Differences between MemoryStream and StringStream:
    1. StringStream has encoding but MemoryStream is a byte stream.
    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
    \note implements Stream concept
*/
struct MemoryStream {
    typedef char Ch; // byte

    MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}

    Ch Peek() const { return CEREAL_RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; }
    Ch Take() { return CEREAL_RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; }
    size_t Tell() const { return static_cast<size_t>(src_ - begin_); }

    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

    // For encoding detection only.
    const Ch* Peek4() const {
        return Tell() + 4 <= size_ ? src_ : 0;
    }

    const Ch* src_;     //!< Current read position.
    const Ch* begin_;   //!< Original head of the string.
    const Ch* end_;     //!< End of stream.
    size_t size_;       //!< Size of the stream.
};

CEREAL_RAPIDJSON_NAMESPACE_END

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_MEMORYBUFFER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/msinttypes/inttypes.h
================================================
// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
// 
//  Copyright (c) 2006-2013 Alexander Chemeris
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//   1. Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
// 
//   2. Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
// 
//   3. Neither the name of the product nor the names of its contributors may
//      be used to endorse or promote products derived from this software
//      without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
///////////////////////////////////////////////////////////////////////////////

// The above software in this distribution may have been modified by 
// THL A29 Limited ("Tencent Modifications"). 
// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.

#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]

#ifndef _MSC_INTTYPES_H_ // [
#define _MSC_INTTYPES_H_

#if _MSC_VER > 1000
#pragma once
#endif

#include "stdint.h"

// miloyip: VC supports inttypes.h since VC2013
#if _MSC_VER >= 1800
#include <inttypes.h>
#else

// 7.8 Format conversion of integer types

typedef struct {
   intmax_t quot;
   intmax_t rem;
} imaxdiv_t;

// 7.8.1 Macros for format specifiers

#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198

// The fprintf macros for signed integers are:
#define PRId8       "d"
#define PRIi8       "i"
#define PRIdLEAST8  "d"
#define PRIiLEAST8  "i"
#define PRIdFAST8   "d"
#define PRIiFAST8   "i"

#define PRId16       "hd"
#define PRIi16       "hi"
#define PRIdLEAST16  "hd"
#define PRIiLEAST16  "hi"
#define PRIdFAST16   "hd"
#define PRIiFAST16   "hi"

#define PRId32       "I32d"
#define PRIi32       "I32i"
#define PRIdLEAST32  "I32d"
#define PRIiLEAST32  "I32i"
#define PRIdFAST32   "I32d"
#define PRIiFAST32   "I32i"

#define PRId64       "I64d"
#define PRIi64       "I64i"
#define PRIdLEAST64  "I64d"
#define PRIiLEAST64  "I64i"
#define PRIdFAST64   "I64d"
#define PRIiFAST64   "I64i"

#define PRIdMAX     "I64d"
#define PRIiMAX     "I64i"

#define PRIdPTR     "Id"
#define PRIiPTR     "Ii"

// The fprintf macros for unsigned integers are:
#define PRIo8       "o"
#define PRIu8       "u"
#define PRIx8       "x"
#define PRIX8       "X"
#define PRIoLEAST8  "o"
#define PRIuLEAST8  "u"
#define PRIxLEAST8  "x"
#define PRIXLEAST8  "X"
#define PRIoFAST8   "o"
#define PRIuFAST8   "u"
#define PRIxFAST8   "x"
#define PRIXFAST8   "X"

#define PRIo16       "ho"
#define PRIu16       "hu"
#define PRIx16       "hx"
#define PRIX16       "hX"
#define PRIoLEAST16  "ho"
#define PRIuLEAST16  "hu"
#define PRIxLEAST16  "hx"
#define PRIXLEAST16  "hX"
#define PRIoFAST16   "ho"
#define PRIuFAST16   "hu"
#define PRIxFAST16   "hx"
#define PRIXFAST16   "hX"

#define PRIo32       "I32o"
#define PRIu32       "I32u"
#define PRIx32       "I32x"
#define PRIX32       "I32X"
#define PRIoLEAST32  "I32o"
#define PRIuLEAST32  "I32u"
#define PRIxLEAST32  "I32x"
#define PRIXLEAST32  "I32X"
#define PRIoFAST32   "I32o"
#define PRIuFAST32   "I32u"
#define PRIxFAST32   "I32x"
#define PRIXFAST32   "I32X"

#define PRIo64       "I64o"
#define PRIu64       "I64u"
#define PRIx64       "I64x"
#define PRIX64       "I64X"
#define PRIoLEAST64  "I64o"
#define PRIuLEAST64  "I64u"
#define PRIxLEAST64  "I64x"
#define PRIXLEAST64  "I64X"
#define PRIoFAST64   "I64o"
#define PRIuFAST64   "I64u"
#define PRIxFAST64   "I64x"
#define PRIXFAST64   "I64X"

#define PRIoMAX     "I64o"
#define PRIuMAX     "I64u"
#define PRIxMAX     "I64x"
#define PRIXMAX     "I64X"

#define PRIoPTR     "Io"
#define PRIuPTR     "Iu"
#define PRIxPTR     "Ix"
#define PRIXPTR     "IX"

// The fscanf macros for signed integers are:
#define SCNd8       "d"
#define SCNi8       "i"
#define SCNdLEAST8  "d"
#define SCNiLEAST8  "i"
#define SCNdFAST8   "d"
#define SCNiFAST8   "i"

#define SCNd16       "hd"
#define SCNi16       "hi"
#define SCNdLEAST16  "hd"
#define SCNiLEAST16  "hi"
#define SCNdFAST16   "hd"
#define SCNiFAST16   "hi"

#define SCNd32       "ld"
#define SCNi32       "li"
#define SCNdLEAST32  "ld"
#define SCNiLEAST32  "li"
#define SCNdFAST32   "ld"
#define SCNiFAST32   "li"

#define SCNd64       "I64d"
#define SCNi64       "I64i"
#define SCNdLEAST64  "I64d"
#define SCNiLEAST64  "I64i"
#define SCNdFAST64   "I64d"
#define SCNiFAST64   "I64i"

#define SCNdMAX     "I64d"
#define SCNiMAX     "I64i"

#ifdef _WIN64 // [
#  define SCNdPTR     "I64d"
#  define SCNiPTR     "I64i"
#else  // _WIN64 ][
#  define SCNdPTR     "ld"
#  define SCNiPTR     "li"
#endif  // _WIN64 ]

// The fscanf macros for unsigned integers are:
#define SCNo8       "o"
#define SCNu8       "u"
#define SCNx8       "x"
#define SCNX8       "X"
#define SCNoLEAST8  "o"
#define SCNuLEAST8  "u"
#define SCNxLEAST8  "x"
#define SCNXLEAST8  "X"
#define SCNoFAST8   "o"
#define SCNuFAST8   "u"
#define SCNxFAST8   "x"
#define SCNXFAST8   "X"

#define SCNo16       "ho"
#define SCNu16       "hu"
#define SCNx16       "hx"
#define SCNX16       "hX"
#define SCNoLEAST16  "ho"
#define SCNuLEAST16  "hu"
#define SCNxLEAST16  "hx"
#define SCNXLEAST16  "hX"
#define SCNoFAST16   "ho"
#define SCNuFAST16   "hu"
#define SCNxFAST16   "hx"
#define SCNXFAST16   "hX"

#define SCNo32       "lo"
#define SCNu32       "lu"
#define SCNx32       "lx"
#define SCNX32       "lX"
#define SCNoLEAST32  "lo"
#define SCNuLEAST32  "lu"
#define SCNxLEAST32  "lx"
#define SCNXLEAST32  "lX"
#define SCNoFAST32   "lo"
#define SCNuFAST32   "lu"
#define SCNxFAST32   "lx"
#define SCNXFAST32   "lX"

#define SCNo64       "I64o"
#define SCNu64       "I64u"
#define SCNx64       "I64x"
#define SCNX64       "I64X"
#define SCNoLEAST64  "I64o"
#define SCNuLEAST64  "I64u"
#define SCNxLEAST64  "I64x"
#define SCNXLEAST64  "I64X"
#define SCNoFAST64   "I64o"
#define SCNuFAST64   "I64u"
#define SCNxFAST64   "I64x"
#define SCNXFAST64   "I64X"

#define SCNoMAX     "I64o"
#define SCNuMAX     "I64u"
#define SCNxMAX     "I64x"
#define SCNXMAX     "I64X"

#ifdef _WIN64 // [
#  define SCNoPTR     "I64o"
#  define SCNuPTR     "I64u"
#  define SCNxPTR     "I64x"
#  define SCNXPTR     "I64X"
#else  // _WIN64 ][
#  define SCNoPTR     "lo"
#  define SCNuPTR     "lu"
#  define SCNxPTR     "lx"
#  define SCNXPTR     "lX"
#endif  // _WIN64 ]

#endif // __STDC_FORMAT_MACROS ]

// 7.8.2 Functions for greatest-width integer types

// 7.8.2.1 The imaxabs function
#define imaxabs _abs64

// 7.8.2.2 The imaxdiv function

// This is modified version of div() function from Microsoft's div.c found
// in %MSVC.NET%\crt\src\div.c
#ifdef STATIC_IMAXDIV // [
static
#else // STATIC_IMAXDIV ][
_inline
#endif // STATIC_IMAXDIV ]
imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
{
   imaxdiv_t result;

   result.quot = numer / denom;
   result.rem = numer % denom;

   if (numer < 0 && result.rem > 0) {
      // did division wrong; must fix up
      ++result.quot;
      result.rem -= denom;
   }

   return result;
}

// 7.8.2.3 The strtoimax and strtoumax functions
#define strtoimax _strtoi64
#define strtoumax _strtoui64

// 7.8.2.4 The wcstoimax and wcstoumax functions
#define wcstoimax _wcstoi64
#define wcstoumax _wcstoui64

#endif // _MSC_VER >= 1800

#endif // _MSC_INTTYPES_H_ ]


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/msinttypes/stdint.h
================================================
// ISO C9x  compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
// 
//  Copyright (c) 2006-2013 Alexander Chemeris
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//   1. Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
// 
//   2. Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
// 
//   3. Neither the name of the product nor the names of its contributors may
//      be used to endorse or promote products derived from this software
//      without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
///////////////////////////////////////////////////////////////////////////////

// The above software in this distribution may have been modified by 
// THL A29 Limited ("Tencent Modifications"). 
// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.

#ifndef _MSC_VER // [
#error "Use this header only with Microsoft Visual C++ compilers!"
#endif // _MSC_VER ]

#ifndef _MSC_STDINT_H_ // [
#define _MSC_STDINT_H_

#if _MSC_VER > 1000
#pragma once
#endif

// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
#if _MSC_VER >= 1600 // [
#include <stdint.h>

#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260

#undef INT8_C
#undef INT16_C
#undef INT32_C
#undef INT64_C
#undef UINT8_C
#undef UINT16_C
#undef UINT32_C
#undef UINT64_C

// 7.18.4.1 Macros for minimum-width integer constants

#define INT8_C(val)  val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64

#define UINT8_C(val)  val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64

// 7.18.4.2 Macros for greatest-width integer constants
// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
// Check out Issue 9 for the details.
#ifndef INTMAX_C //   [
#  define INTMAX_C   INT64_C
#endif // INTMAX_C    ]
#ifndef UINTMAX_C //  [
#  define UINTMAX_C  UINT64_C
#endif // UINTMAX_C   ]

#endif // __STDC_CONSTANT_MACROS ]

#else // ] _MSC_VER >= 1700 [

#include <limits.h>

// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
// or compiler would give many errors like this:
//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
#if defined(__cplusplus) && !defined(_M_ARM)
extern "C" {
#endif
#  include <wchar.h>
#if defined(__cplusplus) && !defined(_M_ARM)
}
#endif

// Define _W64 macros to mark types changing their size, like intptr_t.
#ifndef _W64
#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
#     define _W64 __w64
#  else
#     define _W64
#  endif
#endif


// 7.18.1 Integer types

// 7.18.1.1 Exact-width integer types

// Visual Studio 6 and Embedded Visual C++ 4 doesn't
// realize that, e.g. char has the same size as __int8
// so we give up on __intX for them.
#if (_MSC_VER < 1300)
   typedef signed char       int8_t;
   typedef signed short      int16_t;
   typedef signed int        int32_t;
   typedef unsigned char     uint8_t;
   typedef unsigned short    uint16_t;
   typedef unsigned int      uint32_t;
#else
   typedef signed __int8     int8_t;
   typedef signed __int16    int16_t;
   typedef signed __int32    int32_t;
   typedef unsigned __int8   uint8_t;
   typedef unsigned __int16  uint16_t;
   typedef unsigned __int32  uint32_t;
#endif
typedef signed __int64       int64_t;
typedef unsigned __int64     uint64_t;


// 7.18.1.2 Minimum-width integer types
typedef int8_t    int_least8_t;
typedef int16_t   int_least16_t;
typedef int32_t   int_least32_t;
typedef int64_t   int_least64_t;
typedef uint8_t   uint_least8_t;
typedef uint16_t  uint_least16_t;
typedef uint32_t  uint_least32_t;
typedef uint64_t  uint_least64_t;

// 7.18.1.3 Fastest minimum-width integer types
typedef int8_t    int_fast8_t;
typedef int16_t   int_fast16_t;
typedef int32_t   int_fast32_t;
typedef int64_t   int_fast64_t;
typedef uint8_t   uint_fast8_t;
typedef uint16_t  uint_fast16_t;
typedef uint32_t  uint_fast32_t;
typedef uint64_t  uint_fast64_t;

// 7.18.1.4 Integer types capable of holding object pointers
#ifdef _WIN64 // [
   typedef signed __int64    intptr_t;
   typedef unsigned __int64  uintptr_t;
#else // _WIN64 ][
   typedef _W64 signed int   intptr_t;
   typedef _W64 unsigned int uintptr_t;
#endif // _WIN64 ]

// 7.18.1.5 Greatest-width integer types
typedef int64_t   intmax_t;
typedef uint64_t  uintmax_t;


// 7.18.2 Limits of specified-width integer types

#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259

// 7.18.2.1 Limits of exact-width integer types
#define INT8_MIN     ((int8_t)_I8_MIN)
#define INT8_MAX     _I8_MAX
#define INT16_MIN    ((int16_t)_I16_MIN)
#define INT16_MAX    _I16_MAX
#define INT32_MIN    ((int32_t)_I32_MIN)
#define INT32_MAX    _I32_MAX
#define INT64_MIN    ((int64_t)_I64_MIN)
#define INT64_MAX    _I64_MAX
#define UINT8_MAX    _UI8_MAX
#define UINT16_MAX   _UI16_MAX
#define UINT32_MAX   _UI32_MAX
#define UINT64_MAX   _UI64_MAX

// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN    INT8_MIN
#define INT_LEAST8_MAX    INT8_MAX
#define INT_LEAST16_MIN   INT16_MIN
#define INT_LEAST16_MAX   INT16_MAX
#define INT_LEAST32_MIN   INT32_MIN
#define INT_LEAST32_MAX   INT32_MAX
#define INT_LEAST64_MIN   INT64_MIN
#define INT_LEAST64_MAX   INT64_MAX
#define UINT_LEAST8_MAX   UINT8_MAX
#define UINT_LEAST16_MAX  UINT16_MAX
#define UINT_LEAST32_MAX  UINT32_MAX
#define UINT_LEAST64_MAX  UINT64_MAX

// 7.18.2.3 Limits of fastest minimum-width integer types
#define INT_FAST8_MIN    INT8_MIN
#define INT_FAST8_MAX    INT8_MAX
#define INT_FAST16_MIN   INT16_MIN
#define INT_FAST16_MAX   INT16_MAX
#define INT_FAST32_MIN   INT32_MIN
#define INT_FAST32_MAX   INT32_MAX
#define INT_FAST64_MIN   INT64_MIN
#define INT_FAST64_MAX   INT64_MAX
#define UINT_FAST8_MAX   UINT8_MAX
#define UINT_FAST16_MAX  UINT16_MAX
#define UINT_FAST32_MAX  UINT32_MAX
#define UINT_FAST64_MAX  UINT64_MAX

// 7.18.2.4 Limits of integer types capable of holding object pointers
#ifdef _WIN64 // [
#  define INTPTR_MIN   INT64_MIN
#  define INTPTR_MAX   INT64_MAX
#  define UINTPTR_MAX  UINT64_MAX
#else // _WIN64 ][
#  define INTPTR_MIN   INT32_MIN
#  define INTPTR_MAX   INT32_MAX
#  define UINTPTR_MAX  UINT32_MAX
#endif // _WIN64 ]

// 7.18.2.5 Limits of greatest-width integer types
#define INTMAX_MIN   INT64_MIN
#define INTMAX_MAX   INT64_MAX
#define UINTMAX_MAX  UINT64_MAX

// 7.18.3 Limits of other integer types

#ifdef _WIN64 // [
#  define PTRDIFF_MIN  _I64_MIN
#  define PTRDIFF_MAX  _I64_MAX
#else  // _WIN64 ][
#  define PTRDIFF_MIN  _I32_MIN
#  define PTRDIFF_MAX  _I32_MAX
#endif  // _WIN64 ]

#define SIG_ATOMIC_MIN  INT_MIN
#define SIG_ATOMIC_MAX  INT_MAX

#ifndef SIZE_MAX // [
#  ifdef _WIN64 // [
#     define SIZE_MAX  _UI64_MAX
#  else // _WIN64 ][
#     define SIZE_MAX  _UI32_MAX
#  endif // _WIN64 ]
#endif // SIZE_MAX ]

// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
#ifndef WCHAR_MIN // [
#  define WCHAR_MIN  0
#endif  // WCHAR_MIN ]
#ifndef WCHAR_MAX // [
#  define WCHAR_MAX  _UI16_MAX
#endif  // WCHAR_MAX ]

#define WINT_MIN  0
#define WINT_MAX  _UI16_MAX

#endif // __STDC_LIMIT_MACROS ]


// 7.18.4 Limits of other integer types

#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260

// 7.18.4.1 Macros for minimum-width integer constants

#define INT8_C(val)  val##i8
#define INT16_C(val) val##i16
#define INT32_C(val) val##i32
#define INT64_C(val) val##i64

#define UINT8_C(val)  val##ui8
#define UINT16_C(val) val##ui16
#define UINT32_C(val) val##ui32
#define UINT64_C(val) val##ui64

// 7.18.4.2 Macros for greatest-width integer constants
// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
// Check out Issue 9 for the details.
#ifndef INTMAX_C //   [
#  define INTMAX_C   INT64_C
#endif // INTMAX_C    ]
#ifndef UINTMAX_C //  [
#  define UINTMAX_C  UINT64_C
#endif // UINTMAX_C   ]

#endif // __STDC_CONSTANT_MACROS ]

#endif // _MSC_VER >= 1600 ]

#endif // _MSC_STDINT_H_ ]


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/ostreamwrapper.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_
#define CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_

#include "stream.h"
#include <iosfwd>

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
/*!
    The classes can be wrapped including but not limited to:

    - \c std::ostringstream
    - \c std::stringstream
    - \c std::wpstringstream
    - \c std::wstringstream
    - \c std::ifstream
    - \c std::fstream
    - \c std::wofstream
    - \c std::wfstream

    \tparam StreamType Class derived from \c std::basic_ostream.
*/
   
template <typename StreamType>
class BasicOStreamWrapper {
public:
    typedef typename StreamType::char_type Ch;
    BasicOStreamWrapper(StreamType& stream) : stream_(stream) {}

    void Put(Ch c) {
        stream_.put(c);
    }

    void Flush() {
        stream_.flush();
    }

    // Not implemented
    char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    char Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    char* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

private:
    BasicOStreamWrapper(const BasicOStreamWrapper&);
    BasicOStreamWrapper& operator=(const BasicOStreamWrapper&);

    StreamType& stream_;
};

typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_POP
#endif

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_OSTREAMWRAPPER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/pointer.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_POINTER_H_
#define CEREAL_RAPIDJSON_POINTER_H_

#include "document.h"
#include "internal/itoa.h"

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token

//! Error code of parsing.
/*! \ingroup CEREAL_RAPIDJSON_ERRORS
    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
*/
enum PointerParseErrorCode {
    kPointerParseErrorNone = 0,                     //!< The parse is successful

    kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
    kPointerParseErrorInvalidEscape,                //!< Invalid escape
    kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
    kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
};

///////////////////////////////////////////////////////////////////////////////
// GenericPointer

//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
/*!
    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" 
    (https://tools.ietf.org/html/rfc6901).

    A JSON pointer is for identifying a specific value in a JSON document
    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
    can access multiple-level depth of DOM tree with single API call.

    After it parses a string representation (e.g. "/foo/0" or URI fragment 
    representation (e.g. "#/foo/0") into its internal representation (tokens),
    it can be used to resolve a specific value in multiple documents, or sub-tree 
    of documents.

    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
    Apart from assignment, a Pointer cannot be modified after construction.

    Although Pointer is very convenient, please aware that constructing Pointer
    involves parsing and dynamic memory allocation. A special constructor with user-
    supplied tokens eliminates these.

    GenericPointer depends on GenericDocument and GenericValue.
    
    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
    \tparam Allocator The allocator type for allocating memory for internal representation.
    
    \note GenericPointer uses same encoding of ValueType.
    However, Allocator of GenericPointer is independent of Allocator of Value.
*/
template <typename ValueType, typename Allocator = CrtAllocator>
class GenericPointer {
public:
    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
    typedef typename ValueType::Ch Ch;                      //!< Character type from Value

    //! A token is the basic units of internal representation.
    /*!
        A JSON pointer string representation "/foo/123" is parsed to two tokens: 
        "foo" and 123. 123 will be represented in both numeric form and string form.
        They are resolved according to the actual value type (object or array).

        For token that are not numbers, or the numeric value is out of bound
        (greater than limits of SizeType), they are only treated as string form
        (i.e. the token's index will be equal to kPointerInvalidIndex).

        This struct is public so that user can create a Pointer without parsing and 
        allocation, using a special constructor.
    */
    struct Token {
        const Ch* name;             //!< Name of the token. It has null character at the end but it can contain null character.
        SizeType length;            //!< Length of the name.
        SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
    };

    //!@name Constructors and destructor.
    //@{

    //! Default constructor.
    GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}

    //! Constructor that parses a string or URI fragment representation.
    /*!
        \param source A null-terminated, string or URI fragment representation of JSON pointer.
        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
    */
    explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        Parse(source, internal::StrLen(source));
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Constructor that parses a string or URI fragment representation.
    /*!
        \param source A string or URI fragment representation of JSON pointer.
        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
        \note Requires the definition of the preprocessor symbol \ref CEREAL_RAPIDJSON_HAS_STDSTRING.
    */
    explicit GenericPointer(const std::basic_string<Ch>& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        Parse(source.c_str(), source.size());
    }
#endif

    //! Constructor that parses a string or URI fragment representation, with length of the source string.
    /*!
        \param source A string or URI fragment representation of JSON pointer.
        \param length Length of source.
        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
        \note Slightly faster than the overload without length.
    */
    GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        Parse(source, length);
    }

    //! Constructor with user-supplied tokens.
    /*!
        This constructor let user supplies const array of tokens.
        This prevents the parsing process and eliminates allocation.
        This is preferred for memory constrained environments.

        \param tokens An constant array of tokens representing the JSON pointer.
        \param tokenCount Number of tokens.

        \b Example
        \code
        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
        #define INDEX(i) { #i, sizeof(#i) - 1, i }

        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
        // Equivalent to static const Pointer p("/foo/123");

        #undef NAME
        #undef INDEX
        \endcode
    */
    GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}

    //! Copy constructor.
    GenericPointer(const GenericPointer& rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        *this = rhs;
    }

    //! Copy constructor.
    GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        *this = rhs;
    }

    //! Destructor.
    ~GenericPointer() {
        if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
            Allocator::Free(tokens_);
        CEREAL_RAPIDJSON_DELETE(ownAllocator_);
    }

    //! Assignment operator.
    GenericPointer& operator=(const GenericPointer& rhs) {
        if (this != &rhs) {
            // Do not delete ownAllcator
            if (nameBuffer_)
                Allocator::Free(tokens_);

            tokenCount_ = rhs.tokenCount_;
            parseErrorOffset_ = rhs.parseErrorOffset_;
            parseErrorCode_ = rhs.parseErrorCode_;

            if (rhs.nameBuffer_)
                CopyFromRaw(rhs); // Normally parsed tokens.
            else {
                tokens_ = rhs.tokens_; // User supplied const tokens.
                nameBuffer_ = 0;
            }
        }
        return *this;
    }

    //! Swap the content of this pointer with an other.
    /*!
        \param other The pointer to swap with.
        \note Constant complexity.
    */
    GenericPointer& Swap(GenericPointer& other) CEREAL_RAPIDJSON_NOEXCEPT {
        internal::Swap(allocator_, other.allocator_);
        internal::Swap(ownAllocator_, other.ownAllocator_);
        internal::Swap(nameBuffer_, other.nameBuffer_);
        internal::Swap(tokens_, other.tokens_);
        internal::Swap(tokenCount_, other.tokenCount_);
        internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
        internal::Swap(parseErrorCode_, other.parseErrorCode_);
        return *this;
    }

    //! free-standing swap function helper
    /*!
        Helper function to enable support for common swap implementation pattern based on \c std::swap:
        \code
        void swap(MyClass& a, MyClass& b) {
            using std::swap;
            swap(a.pointer, b.pointer);
            // ...
        }
        \endcode
        \see Swap()
     */
    friend inline void swap(GenericPointer& a, GenericPointer& b) CEREAL_RAPIDJSON_NOEXCEPT { a.Swap(b); }

    //@}

    //!@name Append token
    //@{

    //! Append a token and return a new Pointer
    /*!
        \param token Token to be appended.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    GenericPointer Append(const Token& token, Allocator* allocator = 0) const {
        GenericPointer r;
        r.allocator_ = allocator;
        Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
        std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
        r.tokens_[tokenCount_].name = p;
        r.tokens_[tokenCount_].length = token.length;
        r.tokens_[tokenCount_].index = token.index;
        return r;
    }

    //! Append a name token with length, and return a new Pointer
    /*!
        \param name Name to be appended.
        \param length Length of name.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const {
        Token token = { name, length, kPointerInvalidIndex };
        return Append(token, allocator);
    }

    //! Append a name token without length, and return a new Pointer
    /*!
        \param name Name (const Ch*) to be appended.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
    Append(T* name, Allocator* allocator = 0) const {
        return Append(name, internal::StrLen(name), allocator);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Append a name token, and return a new Pointer
    /*!
        \param name Name to be appended.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    GenericPointer Append(const std::basic_string<Ch>& name, Allocator* allocator = 0) const {
        return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
    }
#endif

    //! Append a index token, and return a new Pointer
    /*!
        \param index Index to be appended.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    GenericPointer Append(SizeType index, Allocator* allocator = 0) const {
        char buffer[21];
        char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
        SizeType length = static_cast<SizeType>(end - buffer);
        buffer[length] = '\0';

        if (sizeof(Ch) == 1) {
            Token token = { reinterpret_cast<Ch*>(buffer), length, index };
            return Append(token, allocator);
        }
        else {
            Ch name[21];
            for (size_t i = 0; i <= length; i++)
                name[i] = static_cast<Ch>(buffer[i]);
            Token token = { name, length, index };
            return Append(token, allocator);
        }
    }

    //! Append a token by value, and return a new Pointer
    /*!
        \param token token to be appended.
        \param allocator Allocator for the newly return Pointer.
        \return A new Pointer with appended token.
    */
    GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const {
        if (token.IsString())
            return Append(token.GetString(), token.GetStringLength(), allocator);
        else {
            CEREAL_RAPIDJSON_ASSERT(token.IsUint64());
            CEREAL_RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
            return Append(static_cast<SizeType>(token.GetUint64()), allocator);
        }
    }

    //!@name Handling Parse Error
    //@{

    //! Check whether this is a valid pointer.
    bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; }

    //! Get the parsing error offset in code unit.
    size_t GetParseErrorOffset() const { return parseErrorOffset_; }

    //! Get the parsing error code.
    PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; }

    //@}

    //! Get the allocator of this pointer.
    Allocator& GetAllocator() { return *allocator_; }

    //!@name Tokens
    //@{

    //! Get the token array (const version only).
    const Token* GetTokens() const { return tokens_; }

    //! Get the number of tokens.
    size_t GetTokenCount() const { return tokenCount_; }

    //@}

    //!@name Equality/inequality operators
    //@{

    //! Equality operator.
    /*!
        \note When any pointers are invalid, always returns false.
    */
    bool operator==(const GenericPointer& rhs) const {
        if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
            return false;

        for (size_t i = 0; i < tokenCount_; i++) {
            if (tokens_[i].index != rhs.tokens_[i].index ||
                tokens_[i].length != rhs.tokens_[i].length || 
                (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
            {
                return false;
            }
        }

        return true;
    }

    //! Inequality operator.
    /*!
        \note When any pointers are invalid, always returns true.
    */
    bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }

    //! Less than operator.
    /*!
        \note Invalid pointers are always greater than valid ones.
    */
    bool operator<(const GenericPointer& rhs) const {
        if (!IsValid())
            return false;
        if (!rhs.IsValid())
            return true;

        if (tokenCount_ != rhs.tokenCount_)
            return tokenCount_ < rhs.tokenCount_;

        for (size_t i = 0; i < tokenCount_; i++) {
            if (tokens_[i].index != rhs.tokens_[i].index)
                return tokens_[i].index < rhs.tokens_[i].index;

            if (tokens_[i].length != rhs.tokens_[i].length)
                return tokens_[i].length < rhs.tokens_[i].length;

            if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
                return cmp < 0;
        }

        return false;
    }

    //@}

    //!@name Stringify
    //@{

    //! Stringify the pointer into string representation.
    /*!
        \tparam OutputStream Type of output stream.
        \param os The output stream.
    */
    template<typename OutputStream>
    bool Stringify(OutputStream& os) const {
        return Stringify<false, OutputStream>(os);
    }

    //! Stringify the pointer into URI fragment representation.
    /*!
        \tparam OutputStream Type of output stream.
        \param os The output stream.
    */
    template<typename OutputStream>
    bool StringifyUriFragment(OutputStream& os) const {
        return Stringify<true, OutputStream>(os);
    }

    //@}

    //!@name Create value
    //@{

    //! Create a value in a subtree.
    /*!
        If the value is not exist, it creates all parent values and a JSON Null value.
        So it always succeed and return the newly created or existing value.

        Remind that it may change types of parents according to tokens, so it 
        potentially removes previously stored values. For example, if a document 
        was an array, and "/foo" is used to create a value, then the document 
        will be changed to an object, and all existing array elements are lost.

        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
        \return The resolved newly created (a JSON Null value), or already exists value.
    */
    ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const {
        CEREAL_RAPIDJSON_ASSERT(IsValid());
        ValueType* v = &root;
        bool exist = true;
        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            if (v->IsArray() && t->name[0] == '-' && t->length == 1) {
                v->PushBack(ValueType().Move(), allocator);
                v = &((*v)[v->Size() - 1]);
                exist = false;
            }
            else {
                if (t->index == kPointerInvalidIndex) { // must be object name
                    if (!v->IsObject())
                        v->SetObject(); // Change to Object
                }
                else { // object name or array index
                    if (!v->IsArray() && !v->IsObject())
                        v->SetArray(); // Change to Array
                }

                if (v->IsArray()) {
                    if (t->index >= v->Size()) {
                        v->Reserve(t->index + 1, allocator);
                        while (t->index >= v->Size())
                            v->PushBack(ValueType().Move(), allocator);
                        exist = false;
                    }
                    v = &((*v)[t->index]);
                }
                else {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd()) {
                        v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
                        v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
                        exist = false;
                    }
                    else
                        v = &m->value;
                }
            }
        }

        if (alreadyExist)
            *alreadyExist = exist;

        return *v;
    }

    //! Creates a value in a document.
    /*!
        \param document A document to be resolved.
        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
        \return The resolved newly created, or already exists value.
    */
    template <typename stackAllocator>
    ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, bool* alreadyExist = 0) const {
        return Create(document, document.GetAllocator(), alreadyExist);
    }

    //@}

    //!@name Query value
    //@{

    //! Query a value in a subtree.
    /*!
        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token.
        \return Pointer to the value if it can be resolved. Otherwise null.

        \note
        There are only 3 situations when a value cannot be resolved:
        1. A value in the path is not an array nor object.
        2. An object value does not contain the token.
        3. A token is out of range of an array value.

        Use unresolvedTokenIndex to retrieve the token index.
    */
    ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const {
        CEREAL_RAPIDJSON_ASSERT(IsValid());
        ValueType* v = &root;
        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            switch (v->GetType()) {
            case kObjectType:
                {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd())
                        break;
                    v = &m->value;
                }
                continue;
            case kArrayType:
                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
                    break;
                v = &((*v)[t->index]);
                continue;
            default:
                break;
            }

            // Error: unresolved token
            if (unresolvedTokenIndex)
                *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
            return 0;
        }
        return v;
    }

    //! Query a const value in a const subtree.
    /*!
        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \return Pointer to the value if it can be resolved. Otherwise null.
    */
    const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { 
        return Get(const_cast<ValueType&>(root), unresolvedTokenIndex);
    }

    //@}

    //!@name Query a value with default
    //@{

    //! Query a value in a subtree with default value.
    /*!
        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
        So that this function always succeed.

        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \param defaultValue Default value to be cloned if the value was not exists.
        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
        \see Create()
    */
    ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
    }

    //! Query a value in a subtree with default null-terminated string.
    ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.SetString(defaultValue, allocator);
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Query a value in a subtree with default std::basic_string.
    ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.SetString(defaultValue, allocator);
    }
#endif

    //! Query a value in a subtree with default primitive value.
    /*!
        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const {
        return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
    }

    //! Query a value in a document with default value.
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }

    //! Query a value in a document with default null-terminated string.
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
    
#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Query a value in a document with default std::basic_string.
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
#endif

    //! Query a value in a document with default primitive value.
    /*!
        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
    */
    template <typename T, typename stackAllocator>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }

    //@}

    //!@name Set a value
    //@{

    //! Set a value in a subtree, with move semantics.
    /*!
        It creates all parents if they are not exist or types are different to the tokens.
        So this function always succeeds but potentially remove existing values.

        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \param value Value to be set.
        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
        \see Create()
    */
    ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = value;
    }

    //! Set a value in a subtree, with copy semantics.
    ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator).CopyFrom(value, allocator);
    }

    //! Set a null-terminated string in a subtree.
    ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value, allocator).Move();
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Set a std::basic_string in a subtree.
    ValueType& Set(ValueType& root, const std::basic_string<Ch>& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value, allocator).Move();
    }
#endif

    //! Set a primitive value in a subtree.
    /*!
        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
    */
    template <typename T>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value).Move();
    }

    //! Set a value in a document, with move semantics.
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
        return Create(document) = value;
    }

    //! Set a value in a document, with copy semantics.
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& value) const {
        return Create(document).CopyFrom(value, document.GetAllocator());
    }

    //! Set a null-terminated string in a document.
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* value) const {
        return Create(document) = ValueType(value, document.GetAllocator()).Move();
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    //! Sets a std::basic_string in a document.
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& value) const {
        return Create(document) = ValueType(value, document.GetAllocator()).Move();
    }
#endif

    //! Set a primitive value in a document.
    /*!
    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
    */
    template <typename T, typename stackAllocator>
    CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
        Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T value) const {
            return Create(document) = value;
    }

    //@}

    //!@name Swap a value
    //@{

    //! Swap a value with a value in a subtree.
    /*!
        It creates all parents if they are not exist or types are different to the tokens.
        So this function always succeeds but potentially remove existing values.

        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \param value Value to be swapped.
        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
        \see Create()
    */
    ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator).Swap(value);
    }

    //! Swap a value with a value in a document.
    template <typename stackAllocator>
    ValueType& Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
        return Create(document).Swap(value);
    }

    //@}

    //! Erase a value in a subtree.
    /*!
        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
        \return Whether the resolved value is found and erased.

        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
    */
    bool Erase(ValueType& root) const {
        CEREAL_RAPIDJSON_ASSERT(IsValid());
        if (tokenCount_ == 0) // Cannot erase the root
            return false;

        ValueType* v = &root;
        const Token* last = tokens_ + (tokenCount_ - 1);
        for (const Token *t = tokens_; t != last; ++t) {
            switch (v->GetType()) {
            case kObjectType:
                {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd())
                        return false;
                    v = &m->value;
                }
                break;
            case kArrayType:
                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
                    return false;
                v = &((*v)[t->index]);
                break;
            default:
                return false;
            }
        }

        switch (v->GetType()) {
        case kObjectType:
            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
        case kArrayType:
            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
                return false;
            v->Erase(v->Begin() + last->index);
            return true;
        default:
            return false;
        }
    }

private:
    //! Clone the content from rhs to this.
    /*!
        \param rhs Source pointer.
        \param extraToken Extra tokens to be allocated.
        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
        \return Start of non-occupied name buffer, for storing extra names.
    */
    Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
        if (!allocator_) // allocator is independently owned.
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();

        size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
        for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
            nameBufferSize += t->length;

        tokenCount_ = rhs.tokenCount_ + extraToken;
        tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
        nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
        if (rhs.tokenCount_ > 0) {
            std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
        }
        if (nameBufferSize > 0) {
            std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
        }

        // Adjust pointers to name buffer
        std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
        for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
            t->name += diff;

        return nameBuffer_ + nameBufferSize;
    }

    //! Check whether a character should be percent-encoded.
    /*!
        According to RFC 3986 2.3 Unreserved Characters.
        \param c The character (code unit) to be tested.
    */
    bool NeedPercentEncode(Ch c) const {
        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
    }

    //! Parse a JSON String or its URI fragment representation into tokens.
#ifndef __clang__ // -Wdocumentation
    /*!
        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
        \param length Length of the source string.
        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
    */
#endif
    void Parse(const Ch* source, size_t length) {
        CEREAL_RAPIDJSON_ASSERT(source != NULL);
        CEREAL_RAPIDJSON_ASSERT(nameBuffer_ == 0);
        CEREAL_RAPIDJSON_ASSERT(tokens_ == 0);

        // Create own allocator if user did not supply.
        if (!allocator_)
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();

        // Count number of '/' as tokenCount
        tokenCount_ = 0;
        for (const Ch* s = source; s != source + length; s++) 
            if (*s == '/')
                tokenCount_++;

        Token* token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
        Ch* name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
        size_t i = 0;

        // Detect if it is a URI fragment
        bool uriFragment = false;
        if (source[i] == '#') {
            uriFragment = true;
            i++;
        }

        if (i != length && source[i] != '/') {
            parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
            goto error;
        }

        while (i < length) {
            CEREAL_RAPIDJSON_ASSERT(source[i] == '/');
            i++; // consumes '/'

            token->name = name;
            bool isNumber = true;

            while (i < length && source[i] != '/') {
                Ch c = source[i];
                if (uriFragment) {
                    // Decoding percent-encoding for URI fragment
                    if (c == '%') {
                        PercentDecodeStream is(&source[i], source + length);
                        GenericInsituStringStream<EncodingType> os(name);
                        Ch* begin = os.PutBegin();
                        if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid()) {
                            parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
                            goto error;
                        }
                        size_t len = os.PutEnd(begin);
                        i += is.Tell() - 1;
                        if (len == 1)
                            c = *name;
                        else {
                            name += len;
                            isNumber = false;
                            i++;
                            continue;
                        }
                    }
                    else if (NeedPercentEncode(c)) {
                        parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
                        goto error;
                    }
                }

                i++;
                
                // Escaping "~0" -> '~', "~1" -> '/'
                if (c == '~') {
                    if (i < length) {
                        c = source[i];
                        if (c == '0')       c = '~';
                        else if (c == '1')  c = '/';
                        else {
                            parseErrorCode_ = kPointerParseErrorInvalidEscape;
                            goto error;
                        }
                        i++;
                    }
                    else {
                        parseErrorCode_ = kPointerParseErrorInvalidEscape;
                        goto error;
                    }
                }

                // First check for index: all of characters are digit
                if (c < '0' || c > '9')
                    isNumber = false;

                *name++ = c;
            }
            token->length = static_cast<SizeType>(name - token->name);
            if (token->length == 0)
                isNumber = false;
            *name++ = '\0'; // Null terminator

            // Second check for index: more than one digit cannot have leading zero
            if (isNumber && token->length > 1 && token->name[0] == '0')
                isNumber = false;

            // String to SizeType conversion
            SizeType n = 0;
            if (isNumber) {
                for (size_t j = 0; j < token->length; j++) {
                    SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
                    if (m < n) {   // overflow detection
                        isNumber = false;
                        break;
                    }
                    n = m;
                }
            }

            token->index = isNumber ? n : kPointerInvalidIndex;
            token++;
        }

        CEREAL_RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
        parseErrorCode_ = kPointerParseErrorNone;
        return;

    error:
        Allocator::Free(tokens_);
        nameBuffer_ = 0;
        tokens_ = 0;
        tokenCount_ = 0;
        parseErrorOffset_ = i;
        return;
    }

    //! Stringify to string or URI fragment representation.
    /*!
        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
        \tparam OutputStream type of output stream.
        \param os The output stream.
    */
    template<bool uriFragment, typename OutputStream>
    bool Stringify(OutputStream& os) const {
        CEREAL_RAPIDJSON_ASSERT(IsValid());

        if (uriFragment)
            os.Put('#');

        for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            os.Put('/');
            for (size_t j = 0; j < t->length; j++) {
                Ch c = t->name[j];
                if (c == '~') {
                    os.Put('~');
                    os.Put('0');
                }
                else if (c == '/') {
                    os.Put('~');
                    os.Put('1');
                }
                else if (uriFragment && NeedPercentEncode(c)) { 
                    // Transcode to UTF8 sequence
                    GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
                    PercentEncodeStream<OutputStream> target(os);
                    if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
                        return false;
                    j += source.Tell() - 1;
                }
                else
                    os.Put(c);
            }
        }
        return true;
    }

    //! A helper stream for decoding a percent-encoded sequence into code unit.
    /*!
        This stream decodes %XY triplet into code unit (0-255).
        If it encounters invalid characters, it sets output code unit as 0 and 
        mark invalid, and to be checked by IsValid().
    */
    class PercentDecodeStream {
    public:
        typedef typename ValueType::Ch Ch;

        //! Constructor
        /*!
            \param source Start of the stream
            \param end Past-the-end of the stream.
        */
        PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {}

        Ch Take() {
            if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet
                valid_ = false;
                return 0;
            }
            src_++;
            Ch c = 0;
            for (int j = 0; j < 2; j++) {
                c = static_cast<Ch>(c << 4);
                Ch h = *src_;
                if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
                else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
                else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
                else {
                    valid_ = false;
                    return 0;
                }
                src_++;
            }
            return c;
        }

        size_t Tell() const { return static_cast<size_t>(src_ - head_); }
        bool IsValid() const { return valid_; }

    private:
        const Ch* src_;     //!< Current read position.
        const Ch* head_;    //!< Original head of the string.
        const Ch* end_;     //!< Past-the-end position.
        bool valid_;        //!< Whether the parsing is valid.
    };

    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
    template <typename OutputStream>
    class PercentEncodeStream {
    public:
        PercentEncodeStream(OutputStream& os) : os_(os) {}
        void Put(char c) { // UTF-8 must be byte
            unsigned char u = static_cast<unsigned char>(c);
            static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
            os_.Put('%');
            os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
            os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
        }
    private:
        OutputStream& os_;
    };

    Allocator* allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
    Allocator* ownAllocator_;               //!< Allocator owned by this Pointer.
    Ch* nameBuffer_;                        //!< A buffer containing all names in tokens.
    Token* tokens_;                         //!< A list of tokens.
    size_t tokenCount_;                     //!< Number of tokens in tokens_.
    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
};

//! GenericPointer for Value (UTF-8, default allocator).
typedef GenericPointer<Value> Pointer;

//!@name Helper functions for GenericPointer
//@{

//////////////////////////////////////////////////////////////////////////////

template <typename T>
typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::AllocatorType& a) {
    return pointer.Create(root, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
}

// No allocator parameter

template <typename DocumentType>
typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer) {
    return pointer.Create(document);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
}

//////////////////////////////////////////////////////////////////////////////

template <typename T>
typename T::ValueType* GetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
    return pointer.Get(root, unresolvedTokenIndex);
}

template <typename T>
const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
    return pointer.Get(root, unresolvedTokenIndex);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
}

template <typename T, typename CharType, size_t N>
const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
}

//////////////////////////////////////////////////////////////////////////////

template <typename T>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
    return pointer.GetWithDefault(root, defaultValue, a);
}

template <typename T>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
    return pointer.GetWithDefault(root, defaultValue, a);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename T>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
    return pointer.GetWithDefault(root, defaultValue, a);
}
#endif

template <typename T, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 defaultValue, typename T::AllocatorType& a) {
    return pointer.GetWithDefault(root, defaultValue, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename T, typename CharType, size_t N>
typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
}
#endif

template <typename T, typename CharType, size_t N, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
}

// No allocator parameter

template <typename DocumentType>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& defaultValue) {
    return pointer.GetWithDefault(document, defaultValue);
}

template <typename DocumentType>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* defaultValue) {
    return pointer.GetWithDefault(document, defaultValue);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename DocumentType>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& defaultValue) {
    return pointer.GetWithDefault(document, defaultValue);
}
#endif

template <typename DocumentType, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 defaultValue) {
    return pointer.GetWithDefault(document, defaultValue);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& defaultValue) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
}
#endif

template <typename DocumentType, typename CharType, size_t N, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
}

//////////////////////////////////////////////////////////////////////////////

template <typename T>
typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
    return pointer.Set(root, value, a);
}

template <typename T>
typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) {
    return pointer.Set(root, value, a);
}

template <typename T>
typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* value, typename T::AllocatorType& a) {
    return pointer.Set(root, value, a);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename T>
typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
    return pointer.Set(root, value, a);
}
#endif

template <typename T, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 value, typename T::AllocatorType& a) {
    return pointer.Set(root, value, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename T, typename CharType, size_t N>
typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
}
#endif

template <typename T, typename CharType, size_t N, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
}

// No allocator parameter

template <typename DocumentType>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
    return pointer.Set(document, value);
}

template <typename DocumentType>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& value) {
    return pointer.Set(document, value);
}

template <typename DocumentType>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* value) {
    return pointer.Set(document, value);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename DocumentType>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& value) {
    return pointer.Set(document, value);
}
#endif

template <typename DocumentType, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 value) {
    return pointer.Set(document, value);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
}

#if CEREAL_RAPIDJSON_HAS_STDSTRING
template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
}
#endif

template <typename DocumentType, typename CharType, size_t N, typename T2>
CEREAL_RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
}

//////////////////////////////////////////////////////////////////////////////

template <typename T>
typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
    return pointer.Swap(root, value, a);
}

template <typename T, typename CharType, size_t N>
typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
}

template <typename DocumentType>
typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
    return pointer.Swap(document, value);
}

template <typename DocumentType, typename CharType, size_t N>
typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
    return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
}

//////////////////////////////////////////////////////////////////////////////

template <typename T>
bool EraseValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
    return pointer.Erase(root);
}

template <typename T, typename CharType, size_t N>
bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
    return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
}

//@}

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_POINTER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/prettywriter.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_PRETTYWRITER_H_
#define CEREAL_RAPIDJSON_PRETTYWRITER_H_

#include "writer.h"

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Combination of PrettyWriter format flags.
/*! \see PrettyWriter::SetFormatOptions
 */
enum PrettyFormatOptions {
    kFormatDefault = 0,         //!< Default pretty formatting.
    kFormatSingleLineArray = 1  //!< Format arrays on a single line.
};

//! Writer with indentation and spacing.
/*!
    \tparam OutputStream Type of output os.
    \tparam SourceEncoding Encoding of source string.
    \tparam TargetEncoding Encoding of output stream.
    \tparam StackAllocator Type of allocator for allocating memory of stack.
*/
template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
public:
    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
    typedef typename Base::Ch Ch;

    //! Constructor
    /*! \param os Output stream.
        \param allocator User supplied allocator. If it is null, it will create a private one.
        \param levelDepth Initial capacity of stack.
    */
    explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}


    explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    PrettyWriter(PrettyWriter&& rhs) :
        Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
#endif

    //! Set custom indentation.
    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
        \param indentCharCount  Number of indent characters for each indentation level.
        \note The default indentation is 4 spaces.
    */
    PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
        CEREAL_RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
        indentChar_ = indentChar;
        indentCharCount_ = indentCharCount;
        return *this;
    }

    //! Set pretty writer formatting options.
    /*! \param options Formatting options.
    */
    PrettyWriter& SetFormatOptions(PrettyFormatOptions options) {
        formatOptions_ = options;
        return *this;
    }

    /*! @name Implementation of Handler
        \see Handler
    */
    //@{

    bool Null()                 { PrettyPrefix(kNullType);   return Base::EndValue(Base::WriteNull()); }
    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }
    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }
    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }
    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }
    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64));  }
    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }

    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
        CEREAL_RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        PrettyPrefix(kNumberType);
        return Base::EndValue(Base::WriteString(str, length));
    }

    bool String(const Ch* str, SizeType length, bool copy = false) {
        CEREAL_RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        PrettyPrefix(kStringType);
        return Base::EndValue(Base::WriteString(str, length));
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool String(const std::basic_string<Ch>& str) {
        return String(str.data(), SizeType(str.size()));
    }
#endif

    bool StartObject() {
        PrettyPrefix(kObjectType);
        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
        return Base::WriteStartObject();
    }

    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool Key(const std::basic_string<Ch>& str) {
        return Key(str.data(), SizeType(str.size()));
    }
#endif
	
    bool EndObject(SizeType memberCount = 0) {
        (void)memberCount;
        CEREAL_RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
        CEREAL_RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
        CEREAL_RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
       
        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

        if (!empty) {
            Base::os_->Put('\n');
            WriteIndent();
        }
        bool ret = Base::EndValue(Base::WriteEndObject());
        (void)ret;
        CEREAL_RAPIDJSON_ASSERT(ret == true);
        if (Base::level_stack_.Empty()) // end of json text
            Base::Flush();
        return true;
    }

    bool StartArray() {
        PrettyPrefix(kArrayType);
        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
        return Base::WriteStartArray();
    }

    bool EndArray(SizeType memberCount = 0) {
        (void)memberCount;
        CEREAL_RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
        CEREAL_RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
            Base::os_->Put('\n');
            WriteIndent();
        }
        bool ret = Base::EndValue(Base::WriteEndArray());
        (void)ret;
        CEREAL_RAPIDJSON_ASSERT(ret == true);
        if (Base::level_stack_.Empty()) // end of json text
            Base::Flush();
        return true;
    }

    //@}

    /*! @name Convenience extensions */
    //@{

    //! Simpler but slower overload.
    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }

    //@}

    //! Write a raw JSON value.
    /*!
        For user to write a stringified JSON as a value.

        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
        \param length Length of the json.
        \param type Type of the root of json.
        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
    */
    bool RawValue(const Ch* json, size_t length, Type type) {
        CEREAL_RAPIDJSON_ASSERT(json != 0);
        PrettyPrefix(type);
        return Base::EndValue(Base::WriteRawValue(json, length));
    }

protected:
    void PrettyPrefix(Type type) {
        (void)type;
        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();

            if (level->inArray) {
                if (level->valueCount > 0) {
                    Base::os_->Put(','); // add comma if it is not the first element in array
                    if (formatOptions_ & kFormatSingleLineArray)
                        Base::os_->Put(' ');
                }

                if (!(formatOptions_ & kFormatSingleLineArray)) {
                    Base::os_->Put('\n');
                    WriteIndent();
                }
            }
            else {  // in object
                if (level->valueCount > 0) {
                    if (level->valueCount % 2 == 0) {
                        Base::os_->Put(',');
                        Base::os_->Put('\n');
                    }
                    else {
                        Base::os_->Put(':');
                        Base::os_->Put(' ');
                    }
                }
                else
                    Base::os_->Put('\n');

                if (level->valueCount % 2 == 0)
                    WriteIndent();
            }
            if (!level->inArray && level->valueCount % 2 == 0)
                CEREAL_RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
            level->valueCount++;
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
            Base::hasRoot_ = true;
        }
    }

    void WriteIndent()  {
        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
        PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
    }

    Ch indentChar_;
    unsigned indentCharCount_;
    PrettyFormatOptions formatOptions_;

private:
    // Prohibit copy constructor & assignment operator.
    PrettyWriter(const PrettyWriter&);
    PrettyWriter& operator=(const PrettyWriter&);
};

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_CEREAL_RAPIDJSON_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/rapidjson.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_CEREAL_RAPIDJSON_H_
#define CEREAL_RAPIDJSON_CEREAL_RAPIDJSON_H_

/*!\file rapidjson.h
    \brief common definitions and configuration
    
    \see CEREAL_RAPIDJSON_CONFIG
 */

/*! \defgroup CEREAL_RAPIDJSON_CONFIG RapidJSON configuration
    \brief Configuration macros for library features

    Some RapidJSON features are configurable to adapt the library to a wide
    variety of platforms, environments and usage scenarios.  Most of the
    features can be configured in terms of overridden or predefined
    preprocessor macros at compile-time.

    Some additional customization is available in the \ref CEREAL_RAPIDJSON_ERRORS APIs.

    \note These macros should be given on the compiler command-line
          (where applicable)  to avoid inconsistent values when compiling
          different translation units of a single application.
 */

#include <cstdlib>  // malloc(), realloc(), free(), size_t
#include <cstring>  // memset(), memcpy(), memmove(), memcmp()

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_VERSION_STRING
//
// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
//

//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
// token stringification
#define CEREAL_RAPIDJSON_STRINGIFY(x) CEREAL_RAPIDJSON_DO_STRINGIFY(x)
#define CEREAL_RAPIDJSON_DO_STRINGIFY(x) #x

// token concatenation
#define CEREAL_RAPIDJSON_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN(X, Y)
#define CEREAL_RAPIDJSON_DO_JOIN(X, Y) CEREAL_RAPIDJSON_DO_JOIN2(X, Y)
#define CEREAL_RAPIDJSON_DO_JOIN2(X, Y) X##Y
//!@endcond

/*! \def CEREAL_RAPIDJSON_MAJOR_VERSION
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Major version of RapidJSON in integer.
*/
/*! \def CEREAL_RAPIDJSON_MINOR_VERSION
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Minor version of RapidJSON in integer.
*/
/*! \def CEREAL_RAPIDJSON_PATCH_VERSION
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Patch version of RapidJSON in integer.
*/
/*! \def CEREAL_RAPIDJSON_VERSION_STRING
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
*/
#define CEREAL_RAPIDJSON_MAJOR_VERSION 1
#define CEREAL_RAPIDJSON_MINOR_VERSION 1
#define CEREAL_RAPIDJSON_PATCH_VERSION 0
#define CEREAL_RAPIDJSON_VERSION_STRING \
    CEREAL_RAPIDJSON_STRINGIFY(CEREAL_RAPIDJSON_MAJOR_VERSION.CEREAL_RAPIDJSON_MINOR_VERSION.CEREAL_RAPIDJSON_PATCH_VERSION)

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_NAMESPACE_(BEGIN|END)
/*! \def CEREAL_RAPIDJSON_NAMESPACE
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief   provide custom rapidjson namespace

    In order to avoid symbol clashes and/or "One Definition Rule" errors
    between multiple inclusions of (different versions of) RapidJSON in
    a single binary, users can customize the name of the main RapidJSON
    namespace.

    In case of a single nesting level, defining \c CEREAL_RAPIDJSON_NAMESPACE
    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
    levels are needed, both \ref CEREAL_RAPIDJSON_NAMESPACE_BEGIN and \ref
    CEREAL_RAPIDJSON_NAMESPACE_END need to be defined as well:

    \code
    // in some .cpp file
    #define CEREAL_RAPIDJSON_NAMESPACE my::rapidjson
    #define CEREAL_RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
    #define CEREAL_RAPIDJSON_NAMESPACE_END   } }
    #include "rapidjson/..."
    \endcode

    \see rapidjson
 */
/*! \def CEREAL_RAPIDJSON_NAMESPACE_BEGIN
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief   provide custom rapidjson namespace (opening expression)
    \see CEREAL_RAPIDJSON_NAMESPACE
*/
/*! \def CEREAL_RAPIDJSON_NAMESPACE_END
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief   provide custom rapidjson namespace (closing expression)
    \see CEREAL_RAPIDJSON_NAMESPACE
*/
#ifndef CEREAL_RAPIDJSON_NAMESPACE
#define CEREAL_RAPIDJSON_NAMESPACE rapidjson
#endif
#ifndef CEREAL_RAPIDJSON_NAMESPACE_BEGIN
#define CEREAL_RAPIDJSON_NAMESPACE_BEGIN namespace CEREAL_RAPIDJSON_NAMESPACE {
#endif
#ifndef CEREAL_RAPIDJSON_NAMESPACE_END
#define CEREAL_RAPIDJSON_NAMESPACE_END }
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_HAS_STDSTRING

#ifndef CEREAL_RAPIDJSON_HAS_STDSTRING
#ifdef CEREAL_RAPIDJSON_DOXYGEN_RUNNING
#define CEREAL_RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
#else
#define CEREAL_RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
#endif
/*! \def CEREAL_RAPIDJSON_HAS_STDSTRING
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Enable RapidJSON support for \c std::string

    By defining this preprocessor symbol to \c 1, several convenience functions for using
    \ref rapidjson::GenericValue with \c std::string are enabled, especially
    for construction and comparison.

    \hideinitializer
*/
#endif // !defined(CEREAL_RAPIDJSON_HAS_STDSTRING)

#if CEREAL_RAPIDJSON_HAS_STDSTRING
#include <string>
#endif // CEREAL_RAPIDJSON_HAS_STDSTRING

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_NO_INT64DEFINE

/*! \def CEREAL_RAPIDJSON_NO_INT64DEFINE
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Use external 64-bit integer types.

    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
    to be available at global scope.

    If users have their own definition, define CEREAL_RAPIDJSON_NO_INT64DEFINE to
    prevent RapidJSON from defining its own types.
*/
#ifndef CEREAL_RAPIDJSON_NO_INT64DEFINE
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#if defined(_MSC_VER) && (_MSC_VER < 1800)	// Visual Studio 2013
#include "msinttypes/stdint.h"
#include "msinttypes/inttypes.h"
#else
// Other compilers should have this.
#include <stdint.h>
#include <inttypes.h>
#endif
//!@endcond
#ifdef CEREAL_RAPIDJSON_DOXYGEN_RUNNING
#define CEREAL_RAPIDJSON_NO_INT64DEFINE
#endif
#endif // CEREAL_RAPIDJSON_NO_INT64TYPEDEF

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_FORCEINLINE

#ifndef CEREAL_RAPIDJSON_FORCEINLINE
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#if defined(_MSC_VER) && defined(NDEBUG)
#define CEREAL_RAPIDJSON_FORCEINLINE __forceinline
#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
#define CEREAL_RAPIDJSON_FORCEINLINE __attribute__((always_inline))
#else
#define CEREAL_RAPIDJSON_FORCEINLINE
#endif
//!@endcond
#endif // CEREAL_RAPIDJSON_FORCEINLINE

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_ENDIAN
#define CEREAL_RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
#define CEREAL_RAPIDJSON_BIGENDIAN     1   //!< Big endian machine

//! Endianness of the machine.
/*!
    \def CEREAL_RAPIDJSON_ENDIAN
    \ingroup CEREAL_RAPIDJSON_CONFIG

    GCC 4.6 provided macro for detecting endianness of the target machine. But other
    compilers may not have this. User can define CEREAL_RAPIDJSON_ENDIAN to either
    \ref CEREAL_RAPIDJSON_LITTLEENDIAN or \ref CEREAL_RAPIDJSON_BIGENDIAN.

    Default detection implemented with reference to
    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
*/
#ifndef CEREAL_RAPIDJSON_ENDIAN
// Detect with GCC 4.6's macro
#  ifdef __BYTE_ORDER__
#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#      define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#      define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
#    else
#      error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
#    endif // __BYTE_ORDER__
// Detect with GLIBC's endian.h
#  elif defined(__GLIBC__)
#    include <endian.h>
#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
#      define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
#    elif (__BYTE_ORDER == __BIG_ENDIAN)
#      define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
#    else
#      error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.
#   endif // __GLIBC__
// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
#    define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
#    define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
// Detect with architecture macros
#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
#    define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_BIGENDIAN
#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
#    define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
#  elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
#    define CEREAL_RAPIDJSON_ENDIAN CEREAL_RAPIDJSON_LITTLEENDIAN
#  elif defined(CEREAL_RAPIDJSON_DOXYGEN_RUNNING)
#    define CEREAL_RAPIDJSON_ENDIAN
#  else
#    error Unknown machine endianness detected. User needs to define CEREAL_RAPIDJSON_ENDIAN.   
#  endif
#endif // CEREAL_RAPIDJSON_ENDIAN

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_64BIT

//! Whether using 64-bit architecture
#ifndef CEREAL_RAPIDJSON_64BIT
#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
#define CEREAL_RAPIDJSON_64BIT 1
#else
#define CEREAL_RAPIDJSON_64BIT 0
#endif
#endif // CEREAL_RAPIDJSON_64BIT

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_ALIGN

//! Data alignment of the machine.
/*! \ingroup CEREAL_RAPIDJSON_CONFIG
    \param x pointer to align

    Some machines require strict data alignment. The default is 8 bytes.
    User can customize by defining the CEREAL_RAPIDJSON_ALIGN function macro.
*/
#ifndef CEREAL_RAPIDJSON_ALIGN
#define CEREAL_RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_UINT64_C2

//! Construct a 64-bit literal by a pair of 32-bit integer.
/*!
    64-bit literal with or without ULL suffix is prone to compiler warnings.
    UINT64_C() is C macro which cause compilation problems.
    Use this macro to define 64-bit constants by a pair of 32-bit integer.
*/
#ifndef CEREAL_RAPIDJSON_UINT64_C2
#define CEREAL_RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION

//! Use only lower 48-bit address for some pointers.
/*!
    \ingroup CEREAL_RAPIDJSON_CONFIG

    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
    The higher 16-bit can be used for storing other data.
    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
*/
#ifndef CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION
#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
#define CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
#else
#define CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
#endif
#endif // CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION

#if CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
#if CEREAL_RAPIDJSON_64BIT != 1
#error CEREAL_RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when CEREAL_RAPIDJSON_64BIT=1
#endif
#define CEREAL_RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(CEREAL_RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
#define CEREAL_RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(CEREAL_RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
#else
#define CEREAL_RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
#define CEREAL_RAPIDJSON_GETPOINTER(type, p) (p)
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_SSE2/CEREAL_RAPIDJSON_SSE42/CEREAL_RAPIDJSON_NEON/CEREAL_RAPIDJSON_SIMD

/*! \def CEREAL_RAPIDJSON_SIMD
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief Enable SSE2/SSE4.2/Neon optimization.

    RapidJSON supports optimized implementations for some parsing operations
    based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
    or ARM compatible processors.

    To enable these optimizations, three different symbols can be defined;
    \code
    // Enable SSE2 optimization.
    #define CEREAL_RAPIDJSON_SSE2

    // Enable SSE4.2 optimization.
    #define CEREAL_RAPIDJSON_SSE42
    \endcode

    // Enable ARM Neon optimization.
    #define CEREAL_RAPIDJSON_NEON
    \endcode

    \c CEREAL_RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.

    If any of these symbols is defined, RapidJSON defines the macro
    \c CEREAL_RAPIDJSON_SIMD to indicate the availability of the optimized code.
*/
#if defined(CEREAL_RAPIDJSON_SSE2) || defined(CEREAL_RAPIDJSON_SSE42) \
    || defined(CEREAL_RAPIDJSON_NEON) || defined(CEREAL_RAPIDJSON_DOXYGEN_RUNNING)
#define CEREAL_RAPIDJSON_SIMD
#endif

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE

#ifndef CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE
/*! \def CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief User-provided \c SizeType definition.

    In order to avoid using 32-bit size types for indexing strings and arrays,
    define this preprocessor symbol and provide the type rapidjson::SizeType
    before including RapidJSON:
    \code
    #define CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE
    namespace rapidjson { typedef ::std::size_t SizeType; }
    #include "rapidjson/..."
    \endcode

    \see rapidjson::SizeType
*/
#ifdef CEREAL_RAPIDJSON_DOXYGEN_RUNNING
#define CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE
#endif
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
//! Size type (for string lengths, array sizes, etc.)
/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
    instead of using \c size_t. Users may override the SizeType by defining
    \ref CEREAL_RAPIDJSON_NO_SIZETYPEDEFINE.
*/
typedef unsigned SizeType;
CEREAL_RAPIDJSON_NAMESPACE_END
#endif

// always import std::size_t to rapidjson namespace
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
using std::size_t;
CEREAL_RAPIDJSON_NAMESPACE_END

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_ASSERT

//! Assertion.
/*! \ingroup CEREAL_RAPIDJSON_CONFIG
    By default, rapidjson uses C \c assert() for internal assertions.
    User can override it by defining CEREAL_RAPIDJSON_ASSERT(x) macro.

    \note Parsing errors are handled and can be customized by the
          \ref CEREAL_RAPIDJSON_ERRORS APIs.
*/
#ifndef CEREAL_RAPIDJSON_ASSERT
#include <cassert>
#define CEREAL_RAPIDJSON_ASSERT(x) assert(x)
#endif // CEREAL_RAPIDJSON_ASSERT

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_STATIC_ASSERT

// Prefer C++11 static_assert, if available
#ifndef CEREAL_RAPIDJSON_STATIC_ASSERT
#if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
#define CEREAL_RAPIDJSON_STATIC_ASSERT(x) \
   static_assert(x, CEREAL_RAPIDJSON_STRINGIFY(x))
#endif // C++11
#endif // CEREAL_RAPIDJSON_STATIC_ASSERT

// Adopt C++03 implementation from boost
#ifndef CEREAL_RAPIDJSON_STATIC_ASSERT
#ifndef __clang__
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#endif
CEREAL_RAPIDJSON_NAMESPACE_BEGIN
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
template <size_t x> struct StaticAssertTest {};
CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__GNUC__) || defined(__clang__)
#define CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#else
#define CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
#endif
#ifndef __clang__
//!@endcond
#endif

/*! \def CEREAL_RAPIDJSON_STATIC_ASSERT
    \brief (Internal) macro to check for conditions at compile-time
    \param x compile-time condition
    \hideinitializer
 */
#define CEREAL_RAPIDJSON_STATIC_ASSERT(x) \
    typedef ::CEREAL_RAPIDJSON_NAMESPACE::StaticAssertTest< \
      sizeof(::CEREAL_RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
    CEREAL_RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) CEREAL_RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
#endif // CEREAL_RAPIDJSON_STATIC_ASSERT

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_LIKELY, CEREAL_RAPIDJSON_UNLIKELY

//! Compiler branching hint for expression with high probability to be true.
/*!
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \param x Boolean expression likely to be true.
*/
#ifndef CEREAL_RAPIDJSON_LIKELY
#if defined(__GNUC__) || defined(__clang__)
#define CEREAL_RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
#else
#define CEREAL_RAPIDJSON_LIKELY(x) (x)
#endif
#endif

//! Compiler branching hint for expression with low probability to be true.
/*!
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \param x Boolean expression unlikely to be true.
*/
#ifndef CEREAL_RAPIDJSON_UNLIKELY
#if defined(__GNUC__) || defined(__clang__)
#define CEREAL_RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
#else
#define CEREAL_RAPIDJSON_UNLIKELY(x) (x)
#endif
#endif

///////////////////////////////////////////////////////////////////////////////
// Helpers

//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN

#define CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN do {  
#define CEREAL_RAPIDJSON_MULTILINEMACRO_END \
} while((void)0, 0)

// adopted from Boost
#define CEREAL_RAPIDJSON_VERSION_CODE(x,y,z) \
  (((x)*100000) + ((y)*100) + (z))

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_DIAG_PUSH/POP, CEREAL_RAPIDJSON_DIAG_OFF

#if defined(__GNUC__)
#define CEREAL_RAPIDJSON_GNUC \
    CEREAL_RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
#endif

#if defined(__clang__) || (defined(CEREAL_RAPIDJSON_GNUC) && CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,2,0))

#define CEREAL_RAPIDJSON_PRAGMA(x) _Pragma(CEREAL_RAPIDJSON_STRINGIFY(x))
#define CEREAL_RAPIDJSON_DIAG_PRAGMA(x) CEREAL_RAPIDJSON_PRAGMA(GCC diagnostic x)
#define CEREAL_RAPIDJSON_DIAG_OFF(x) \
    CEREAL_RAPIDJSON_DIAG_PRAGMA(ignored CEREAL_RAPIDJSON_STRINGIFY(CEREAL_RAPIDJSON_JOIN(-W,x)))

// push/pop support in Clang and GCC>=4.6
#if defined(__clang__) || (defined(CEREAL_RAPIDJSON_GNUC) && CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0))
#define CEREAL_RAPIDJSON_DIAG_PUSH CEREAL_RAPIDJSON_DIAG_PRAGMA(push)
#define CEREAL_RAPIDJSON_DIAG_POP  CEREAL_RAPIDJSON_DIAG_PRAGMA(pop)
#else // GCC >= 4.2, < 4.6
#define CEREAL_RAPIDJSON_DIAG_PUSH /* ignored */
#define CEREAL_RAPIDJSON_DIAG_POP /* ignored */
#endif

#elif defined(_MSC_VER)

// pragma (MSVC specific)
#define CEREAL_RAPIDJSON_PRAGMA(x) __pragma(x)
#define CEREAL_RAPIDJSON_DIAG_PRAGMA(x) CEREAL_RAPIDJSON_PRAGMA(warning(x))

#define CEREAL_RAPIDJSON_DIAG_OFF(x) CEREAL_RAPIDJSON_DIAG_PRAGMA(disable: x)
#define CEREAL_RAPIDJSON_DIAG_PUSH CEREAL_RAPIDJSON_DIAG_PRAGMA(push)
#define CEREAL_RAPIDJSON_DIAG_POP  CEREAL_RAPIDJSON_DIAG_PRAGMA(pop)

#else

#define CEREAL_RAPIDJSON_DIAG_OFF(x) /* ignored */
#define CEREAL_RAPIDJSON_DIAG_PUSH   /* ignored */
#define CEREAL_RAPIDJSON_DIAG_POP    /* ignored */

#endif // CEREAL_RAPIDJSON_DIAG_*

///////////////////////////////////////////////////////////////////////////////
// C++11 features

#ifndef CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
#if defined(__clang__)
#if __has_feature(cxx_rvalue_references) && \
    (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
#endif
#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
      (defined(_MSC_VER) && _MSC_VER >= 1600) || \
      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))

#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
#endif
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS

#ifndef CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
#if defined(__clang__)
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
    (defined(_MSC_VER) && _MSC_VER >= 1900) || \
    (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT 0
#endif
#endif
#if CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
#define CEREAL_RAPIDJSON_NOEXCEPT noexcept
#else
#define CEREAL_RAPIDJSON_NOEXCEPT /* noexcept */
#endif // CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT

// no automatic detection, yet
#ifndef CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS
#if (defined(_MSC_VER) && _MSC_VER >= 1700)
#define CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_TYPETRAITS 0
#endif
#endif

#ifndef CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR
#if defined(__clang__)
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
#elif (defined(CEREAL_RAPIDJSON_GNUC) && (CEREAL_RAPIDJSON_GNUC >= CEREAL_RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
      (defined(_MSC_VER) && _MSC_VER >= 1700) || \
      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR 1
#else
#define CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR 0
#endif
#endif // CEREAL_RAPIDJSON_HAS_CXX11_RANGE_FOR

//!@endcond

//! Assertion (in non-throwing contexts).
 /*! \ingroup CEREAL_RAPIDJSON_CONFIG
    Some functions provide a \c noexcept guarantee, if the compiler supports it.
    In these cases, the \ref CEREAL_RAPIDJSON_ASSERT macro cannot be overridden to
    throw an exception.  This macro adds a separate customization point for
    such cases.

    Defaults to C \c assert() (as \ref CEREAL_RAPIDJSON_ASSERT), if \c noexcept is
    supported, and to \ref CEREAL_RAPIDJSON_ASSERT otherwise.
 */

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_NOEXCEPT_ASSERT

#ifndef CEREAL_RAPIDJSON_NOEXCEPT_ASSERT
#ifdef CEREAL_RAPIDJSON_ASSERT_THROWS
#if CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x)
#else
#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x) CEREAL_RAPIDJSON_ASSERT(x)
#endif // CEREAL_RAPIDJSON_HAS_CXX11_NOEXCEPT
#else
#define CEREAL_RAPIDJSON_NOEXCEPT_ASSERT(x) CEREAL_RAPIDJSON_ASSERT(x)
#endif // CEREAL_RAPIDJSON_ASSERT_THROWS
#endif // CEREAL_RAPIDJSON_NOEXCEPT_ASSERT

///////////////////////////////////////////////////////////////////////////////
// new/delete

#ifndef CEREAL_RAPIDJSON_NEW
///! customization point for global \c new
#define CEREAL_RAPIDJSON_NEW(TypeName) new TypeName
#endif
#ifndef CEREAL_RAPIDJSON_DELETE
///! customization point for global \c delete
#define CEREAL_RAPIDJSON_DELETE(x) delete x
#endif

///////////////////////////////////////////////////////////////////////////////
// Type

/*! \namespace rapidjson
    \brief main RapidJSON namespace
    \see CEREAL_RAPIDJSON_NAMESPACE
*/
CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Type of JSON value
enum Type {
    kNullType = 0,      //!< null
    kFalseType = 1,     //!< false
    kTrueType = 2,      //!< true
    kObjectType = 3,    //!< object
    kArrayType = 4,     //!< array 
    kStringType = 5,    //!< string
    kNumberType = 6     //!< number
};

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_CEREAL_RAPIDJSON_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/reader.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_READER_H_
#define CEREAL_RAPIDJSON_READER_H_

/*! \file reader.h */

#include "allocators.h"
#include "stream.h"
#include "encodedstream.h"
#include "internal/meta.h"
#include "internal/stack.h"
#include "internal/strtod.h"
#include <limits>

#if defined(CEREAL_RAPIDJSON_SIMD) && defined(_MSC_VER)
#include <intrin.h>
#pragma intrinsic(_BitScanForward)
#endif
#ifdef CEREAL_RAPIDJSON_SSE42
#include <nmmintrin.h>
#elif defined(CEREAL_RAPIDJSON_SSE2)
#include <emmintrin.h>
#elif defined(CEREAL_RAPIDJSON_NEON)
#include <arm_neon.h>
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(old-style-cast)
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(switch-enum)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
CEREAL_RAPIDJSON_DIAG_OFF(4702)  // unreachable code
#endif

#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#define CEREAL_RAPIDJSON_NOTHING /* deliberately empty */
#ifndef CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN
#define CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
    CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN \
    if (CEREAL_RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
    CEREAL_RAPIDJSON_MULTILINEMACRO_END
#endif
#define CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
    CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(CEREAL_RAPIDJSON_NOTHING)
//!@endcond

/*! \def CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN
    \ingroup CEREAL_RAPIDJSON_ERRORS
    \brief Macro to indicate a parse error.
    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
    \param offset  position of the error in JSON input (\c size_t)

    This macros can be used as a customization point for the internal
    error handling mechanism of RapidJSON.

    A common usage model is to throw an exception instead of requiring the
    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
    return value:

    \code
    #define CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
       throw ParseException(parseErrorCode, #parseErrorCode, offset)

    #include <stdexcept>               // std::runtime_error
    #include "rapidjson/error/error.h" // rapidjson::ParseResult

    struct ParseException : std::runtime_error, rapidjson::ParseResult {
      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
        : std::runtime_error(msg), ParseResult(code, offset) {}
    };

    #include "rapidjson/reader.h"
    \endcode

    \see CEREAL_RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
 */
#ifndef CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN
#define CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
    CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN \
    CEREAL_RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
    SetParseError(parseErrorCode, offset); \
    CEREAL_RAPIDJSON_MULTILINEMACRO_END
#endif

/*! \def CEREAL_RAPIDJSON_PARSE_ERROR
    \ingroup CEREAL_RAPIDJSON_ERRORS
    \brief (Internal) macro to indicate and handle a parse error.
    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
    \param offset  position of the error in JSON input (\c size_t)

    Invokes CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.

    \see CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN
    \hideinitializer
 */
#ifndef CEREAL_RAPIDJSON_PARSE_ERROR
#define CEREAL_RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
    CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN \
    CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
    CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
    CEREAL_RAPIDJSON_MULTILINEMACRO_END
#endif

#include "error/error.h" // ParseErrorCode, ParseResult

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// ParseFlag

/*! \def CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief User-defined kParseDefaultFlags definition.

    User can define this as any \c ParseFlag combinations.
*/
#ifndef CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
#endif

//! Combination of parseFlags
/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
 */
enum ParseFlag {
    kParseNoFlags = 0,              //!< No flags are set.
    kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
    kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
    kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
    kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
    kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
    kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.
    kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
    kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
    kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
    kParseDefaultFlags = CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining CEREAL_RAPIDJSON_PARSE_DEFAULT_FLAGS
};

///////////////////////////////////////////////////////////////////////////////
// Handler

/*! \class rapidjson::Handler
    \brief Concept for receiving events from GenericReader upon parsing.
    The functions return true if no error occurs. If they return false,
    the event publisher should terminate the process.
\code
concept Handler {
    typename Ch;

    bool Null();
    bool Bool(bool b);
    bool Int(int i);
    bool Uint(unsigned i);
    bool Int64(int64_t i);
    bool Uint64(uint64_t i);
    bool Double(double d);
    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
    bool RawNumber(const Ch* str, SizeType length, bool copy);
    bool String(const Ch* str, SizeType length, bool copy);
    bool StartObject();
    bool Key(const Ch* str, SizeType length, bool copy);
    bool EndObject(SizeType memberCount);
    bool StartArray();
    bool EndArray(SizeType elementCount);
};
\endcode
*/
///////////////////////////////////////////////////////////////////////////////
// BaseReaderHandler

//! Default implementation of Handler.
/*! This can be used as base class of any reader handler.
    \note implements Handler concept
*/
template<typename Encoding = UTF8<>, typename Derived = void>
struct BaseReaderHandler {
    typedef typename Encoding::Ch Ch;

    typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;

    bool Default() { return true; }
    bool Null() { return static_cast<Override&>(*this).Default(); }
    bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
    bool Int(int) { return static_cast<Override&>(*this).Default(); }
    bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
    bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
    bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
    bool Double(double) { return static_cast<Override&>(*this).Default(); }
    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
    bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
    bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
    bool StartObject() { return static_cast<Override&>(*this).Default(); }
    bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
    bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
    bool StartArray() { return static_cast<Override&>(*this).Default(); }
    bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
};

///////////////////////////////////////////////////////////////////////////////
// StreamLocalCopy

namespace internal {

template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
class StreamLocalCopy;

//! Do copy optimization.
template<typename Stream>
class StreamLocalCopy<Stream, 1> {
public:
    StreamLocalCopy(Stream& original) : s(original), original_(original) {}
    ~StreamLocalCopy() { original_ = s; }

    Stream s;

private:
    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;

    Stream& original_;
};

//! Keep reference.
template<typename Stream>
class StreamLocalCopy<Stream, 0> {
public:
    StreamLocalCopy(Stream& original) : s(original) {}

    Stream& s;

private:
    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
};

} // namespace internal

///////////////////////////////////////////////////////////////////////////////
// SkipWhitespace

//! Skip the JSON white spaces in a stream.
/*! \param is A input stream for skipping white spaces.
    \note This function has SSE2/SSE4.2 specialization.
*/
template<typename InputStream>
void SkipWhitespace(InputStream& is) {
    internal::StreamLocalCopy<InputStream> copy(is);
    InputStream& s(copy.s);

    typename InputStream::Ch c;
    while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
        s.Take();
}

inline const char* SkipWhitespace(const char* p, const char* end) {
    while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
        ++p;
    return p;
}

#ifdef CEREAL_RAPIDJSON_SSE42
//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
inline const char *SkipWhitespace_SIMD(const char* p) {
    // Fast return for single non-whitespace
    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
        ++p;
    else
        return p;

    // 16-byte align to the next boundary
    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
    while (p != nextAligned)
        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
            ++p;
        else
            return p;

    // The rest of string using SIMD
    static const char whitespace[16] = " \n\r\t";
    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));

    for (;; p += 16) {
        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
        const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
        if (r != 16)    // some of characters is non-whitespace
            return p + r;
    }
}

inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
    // Fast return for single non-whitespace
    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
        ++p;
    else
        return p;

    // The middle of string using SIMD
    static const char whitespace[16] = " \n\r\t";
    const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));

    for (; p <= end - 16; p += 16) {
        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
        const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
        if (r != 16)    // some of characters is non-whitespace
            return p + r;
    }

    return SkipWhitespace(p, end);
}

#elif defined(CEREAL_RAPIDJSON_SSE2)

//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
inline const char *SkipWhitespace_SIMD(const char* p) {
    // Fast return for single non-whitespace
    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
        ++p;
    else
        return p;

    // 16-byte align to the next boundary
    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
    while (p != nextAligned)
        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
            ++p;
        else
            return p;

    // The rest of string
    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
    #undef C16

    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));

    for (;; p += 16) {
        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
        __m128i x = _mm_cmpeq_epi8(s, w0);
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
        if (r != 0) {   // some of characters may be non-whitespace
#ifdef _MSC_VER         // Find the index of first non-whitespace
            unsigned long offset;
            _BitScanForward(&offset, r);
            return p + offset;
#else
            return p + __builtin_ffs(r) - 1;
#endif
        }
    }
}

inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
    // Fast return for single non-whitespace
    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
        ++p;
    else
        return p;

    // The rest of string
    #define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
    static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
    #undef C16

    const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
    const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
    const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
    const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));

    for (; p <= end - 16; p += 16) {
        const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
        __m128i x = _mm_cmpeq_epi8(s, w0);
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
        unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
        if (r != 0) {   // some of characters may be non-whitespace
#ifdef _MSC_VER         // Find the index of first non-whitespace
            unsigned long offset;
            _BitScanForward(&offset, r);
            return p + offset;
#else
            return p + __builtin_ffs(r) - 1;
#endif
        }
    }

    return SkipWhitespace(p, end);
}

#elif defined(CEREAL_RAPIDJSON_NEON)

//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
inline const char *SkipWhitespace_SIMD(const char* p) {
    // Fast return for single non-whitespace
    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
        ++p;
    else
        return p;

    // 16-byte align to the next boundary
    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
    while (p != nextAligned)
        if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
            ++p;
        else
            return p;

    const uint8x16_t w0 = vmovq_n_u8(' ');
    const uint8x16_t w1 = vmovq_n_u8('\n');
    const uint8x16_t w2 = vmovq_n_u8('\r');
    const uint8x16_t w3 = vmovq_n_u8('\t');

    for (;; p += 16) {
        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
        uint8x16_t x = vceqq_u8(s, w0);
        x = vorrq_u8(x, vceqq_u8(s, w1));
        x = vorrq_u8(x, vceqq_u8(s, w2));
        x = vorrq_u8(x, vceqq_u8(s, w3));

        x = vmvnq_u8(x);                       // Negate
        x = vrev64q_u8(x);                     // Rev in 64
        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

        if (low == 0) {
            if (high != 0) {
                int lz =__builtin_clzll(high);;
                return p + 8 + (lz >> 3);
            }
        } else {
            int lz = __builtin_clzll(low);;
            return p + (lz >> 3);
        }
    }
}

inline const char *SkipWhitespace_SIMD(const char* p, const char* end) {
    // Fast return for single non-whitespace
    if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
        ++p;
    else
        return p;

    const uint8x16_t w0 = vmovq_n_u8(' ');
    const uint8x16_t w1 = vmovq_n_u8('\n');
    const uint8x16_t w2 = vmovq_n_u8('\r');
    const uint8x16_t w3 = vmovq_n_u8('\t');

    for (; p <= end - 16; p += 16) {
        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
        uint8x16_t x = vceqq_u8(s, w0);
        x = vorrq_u8(x, vceqq_u8(s, w1));
        x = vorrq_u8(x, vceqq_u8(s, w2));
        x = vorrq_u8(x, vceqq_u8(s, w3));

        x = vmvnq_u8(x);                       // Negate
        x = vrev64q_u8(x);                     // Rev in 64
        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

        if (low == 0) {
            if (high != 0) {
                int lz = __builtin_clzll(high);
                return p + 8 + (lz >> 3);
            }
        } else {
            int lz = __builtin_clzll(low);
            return p + (lz >> 3);
        }
    }

    return SkipWhitespace(p, end);
}

#endif // CEREAL_RAPIDJSON_NEON

#ifdef CEREAL_RAPIDJSON_SIMD
//! Template function specialization for InsituStringStream
template<> inline void SkipWhitespace(InsituStringStream& is) {
    is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
}

//! Template function specialization for StringStream
template<> inline void SkipWhitespace(StringStream& is) {
    is.src_ = SkipWhitespace_SIMD(is.src_);
}

template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
    is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
}
#endif // CEREAL_RAPIDJSON_SIMD

///////////////////////////////////////////////////////////////////////////////
// GenericReader

//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
/*! GenericReader parses JSON text from a stream, and send events synchronously to an
    object implementing Handler concept.

    It needs to allocate a stack for storing a single decoded string during
    non-destructive parsing.

    For in-situ parsing, the decoded string is directly written to the source
    text string, no temporary buffer is required.

    A GenericReader object can be reused for parsing multiple JSON text.

    \tparam SourceEncoding Encoding of the input stream.
    \tparam TargetEncoding Encoding of the parse output.
    \tparam StackAllocator Allocator type for stack.
*/
template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
class GenericReader {
public:
    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type

    //! Constructor.
    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
    */
    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
        stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}

    //! Parse JSON text.
    /*! \tparam parseFlags Combination of \ref ParseFlag.
        \tparam InputStream Type of input stream, implementing Stream concept.
        \tparam Handler Type of handler, implementing Handler concept.
        \param is Input stream to be parsed.
        \param handler The handler to receive events.
        \return Whether the parsing is successful.
    */
    template <unsigned parseFlags, typename InputStream, typename Handler>
    ParseResult Parse(InputStream& is, Handler& handler) {
        if (parseFlags & kParseIterativeFlag)
            return IterativeParse<parseFlags>(is, handler);

        parseResult_.Clear();

        ClearStackOnExit scope(*this);

        SkipWhitespaceAndComments<parseFlags>(is);
        CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

        if (CEREAL_RAPIDJSON_UNLIKELY(is.Peek() == '\0')) {
            CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
        }
        else {
            ParseValue<parseFlags>(is, handler);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

            if (!(parseFlags & kParseStopWhenDoneFlag)) {
                SkipWhitespaceAndComments<parseFlags>(is);
                CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);

                if (CEREAL_RAPIDJSON_UNLIKELY(is.Peek() != '\0')) {
                    CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
                    CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
                }
            }
        }

        return parseResult_;
    }

    //! Parse JSON text (with \ref kParseDefaultFlags)
    /*! \tparam InputStream Type of input stream, implementing Stream concept
        \tparam Handler Type of handler, implementing Handler concept.
        \param is Input stream to be parsed.
        \param handler The handler to receive events.
        \return Whether the parsing is successful.
    */
    template <typename InputStream, typename Handler>
    ParseResult Parse(InputStream& is, Handler& handler) {
        return Parse<kParseDefaultFlags>(is, handler);
    }

    //! Initialize JSON text token-by-token parsing
    /*!
     */
    void IterativeParseInit() {
        parseResult_.Clear();
        state_ = IterativeParsingStartState;
    }

    //! Parse one token from JSON text
    /*! \tparam InputStream Type of input stream, implementing Stream concept
        \tparam Handler Type of handler, implementing Handler concept.
        \param is Input stream to be parsed.
        \param handler The handler to receive events.
        \return Whether the parsing is successful.
     */
    template <unsigned parseFlags, typename InputStream, typename Handler>
    bool IterativeParseNext(InputStream& is, Handler& handler) {
        while (CEREAL_RAPIDJSON_LIKELY(is.Peek() != '\0')) {
            SkipWhitespaceAndComments<parseFlags>(is);

            Token t = Tokenize(is.Peek());
            IterativeParsingState n = Predict(state_, t);
            IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);

            // If we've finished or hit an error...
            if (CEREAL_RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d))) {
                // Report errors.
                if (d == IterativeParsingErrorState) {
                    HandleError(state_, is);
                    return false;
                }

                // Transition to the finish state.
                CEREAL_RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
                state_ = d;

                // If StopWhenDone is not set...
                if (!(parseFlags & kParseStopWhenDoneFlag)) {
                    // ... and extra non-whitespace data is found...
                    SkipWhitespaceAndComments<parseFlags>(is);
                    if (is.Peek() != '\0') {
                        // ... this is considered an error.
                        HandleError(state_, is);
                        return false;
                    }
                }

                // Success! We are done!
                return true;
            }

            // Transition to the new state.
            state_ = d;

            // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
            if (!IsIterativeParsingDelimiterState(n))
                return true;
        }

        // We reached the end of file.
        stack_.Clear();

        if (state_ != IterativeParsingFinishState) {
            HandleError(state_, is);
            return false;
        }

        return true;
    }

    //! Check if token-by-token parsing JSON text is complete
    /*! \return Whether the JSON has been fully decoded.
     */
    CEREAL_RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const {
        return IsIterativeParsingCompleteState(state_);
    }

    //! Whether a parse error has occurred in the last parsing.
    bool HasParseError() const { return parseResult_.IsError(); }

    //! Get the \ref ParseErrorCode of last parsing.
    ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }

    //! Get the position of last parsing error in input, 0 otherwise.
    size_t GetErrorOffset() const { return parseResult_.Offset(); }

protected:
    void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }

private:
    // Prohibit copy constructor & assignment operator.
    GenericReader(const GenericReader&);
    GenericReader& operator=(const GenericReader&);

    void ClearStack() { stack_.Clear(); }

    // clear stack on any exit from ParseStream, e.g. due to exception
    struct ClearStackOnExit {
        explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
        ~ClearStackOnExit() { r_.ClearStack(); }
    private:
        GenericReader& r_;
        ClearStackOnExit(const ClearStackOnExit&);
        ClearStackOnExit& operator=(const ClearStackOnExit&);
    };

    template<unsigned parseFlags, typename InputStream>
    void SkipWhitespaceAndComments(InputStream& is) {
        SkipWhitespace(is);

        if (parseFlags & kParseCommentsFlag) {
            while (CEREAL_RAPIDJSON_UNLIKELY(Consume(is, '/'))) {
                if (Consume(is, '*')) {
                    while (true) {
                        if (CEREAL_RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
                            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
                        else if (Consume(is, '*')) {
                            if (Consume(is, '/'))
                                break;
                        }
                        else
                            is.Take();
                    }
                }
                else if (CEREAL_RAPIDJSON_LIKELY(Consume(is, '/')))
                    while (is.Peek() != '\0' && is.Take() != '\n') {}
                else
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());

                SkipWhitespace(is);
            }
        }
    }

    // Parse object: { string : value, ... }
    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseObject(InputStream& is, Handler& handler) {
        CEREAL_RAPIDJSON_ASSERT(is.Peek() == '{');
        is.Take();  // Skip '{'

        if (CEREAL_RAPIDJSON_UNLIKELY(!handler.StartObject()))
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

        SkipWhitespaceAndComments<parseFlags>(is);
        CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

        if (Consume(is, '}')) {
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
            return;
        }

        for (SizeType memberCount = 0;;) {
            if (CEREAL_RAPIDJSON_UNLIKELY(is.Peek() != '"'))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());

            ParseString<parseFlags>(is, handler, true);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            SkipWhitespaceAndComments<parseFlags>(is);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            if (CEREAL_RAPIDJSON_UNLIKELY(!Consume(is, ':')))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());

            SkipWhitespaceAndComments<parseFlags>(is);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            ParseValue<parseFlags>(is, handler);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            SkipWhitespaceAndComments<parseFlags>(is);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            ++memberCount;

            switch (is.Peek()) {
                case ',':
                    is.Take();
                    SkipWhitespaceAndComments<parseFlags>(is);
                    CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
                    break;
                case '}':
                    is.Take();
                    if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
                        CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
                    return;
                default:
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); break; // This useless break is only for making warning and coverage happy
            }

            if (parseFlags & kParseTrailingCommasFlag) {
                if (is.Peek() == '}') {
                    if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
                        CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
                    is.Take();
                    return;
                }
            }
        }
    }

    // Parse array: [ value, ... ]
    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseArray(InputStream& is, Handler& handler) {
        CEREAL_RAPIDJSON_ASSERT(is.Peek() == '[');
        is.Take();  // Skip '['

        if (CEREAL_RAPIDJSON_UNLIKELY(!handler.StartArray()))
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());

        SkipWhitespaceAndComments<parseFlags>(is);
        CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

        if (Consume(is, ']')) {
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
            return;
        }

        for (SizeType elementCount = 0;;) {
            ParseValue<parseFlags>(is, handler);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            ++elementCount;
            SkipWhitespaceAndComments<parseFlags>(is);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;

            if (Consume(is, ',')) {
                SkipWhitespaceAndComments<parseFlags>(is);
                CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
            }
            else if (Consume(is, ']')) {
                if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
                return;
            }
            else
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());

            if (parseFlags & kParseTrailingCommasFlag) {
                if (is.Peek() == ']') {
                    if (CEREAL_RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
                        CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
                    is.Take();
                    return;
                }
            }
        }
    }

    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseNull(InputStream& is, Handler& handler) {
        CEREAL_RAPIDJSON_ASSERT(is.Peek() == 'n');
        is.Take();

        if (CEREAL_RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l'))) {
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.Null()))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseTrue(InputStream& is, Handler& handler) {
        CEREAL_RAPIDJSON_ASSERT(is.Peek() == 't');
        is.Take();

        if (CEREAL_RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.Bool(true)))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseFalse(InputStream& is, Handler& handler) {
        CEREAL_RAPIDJSON_ASSERT(is.Peek() == 'f');
        is.Take();

        if (CEREAL_RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e'))) {
            if (CEREAL_RAPIDJSON_UNLIKELY(!handler.Bool(false)))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
        }
        else
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
    }

    template<typename InputStream>
    CEREAL_RAPIDJSON_FORCEINLINE static bool Consume(InputStream& is, typename InputStream::Ch expect) {
        if (CEREAL_RAPIDJSON_LIKELY(is.Peek() == expect)) {
            is.Take();
            return true;
        }
        else
            return false;
    }

    // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
    template<typename InputStream>
    unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
        unsigned codepoint = 0;
        for (int i = 0; i < 4; i++) {
            Ch c = is.Peek();
            codepoint <<= 4;
            codepoint += static_cast<unsigned>(c);
            if (c >= '0' && c <= '9')
                codepoint -= '0';
            else if (c >= 'A' && c <= 'F')
                codepoint -= 'A' - 10;
            else if (c >= 'a' && c <= 'f')
                codepoint -= 'a' - 10;
            else {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
                CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
            }
            is.Take();
        }
        return codepoint;
    }

    template <typename CharType>
    class StackStream {
    public:
        typedef CharType Ch;

        StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
        CEREAL_RAPIDJSON_FORCEINLINE void Put(Ch c) {
            *stack_.template Push<Ch>() = c;
            ++length_;
        }

        CEREAL_RAPIDJSON_FORCEINLINE void* Push(SizeType count) {
            length_ += count;
            return stack_.template Push<Ch>(count);
        }

        size_t Length() const { return length_; }

        Ch* Pop() {
            return stack_.template Pop<Ch>(length_);
        }

    private:
        StackStream(const StackStream&);
        StackStream& operator=(const StackStream&);

        internal::Stack<StackAllocator>& stack_;
        SizeType length_;
    };

    // Parse string and generate String event. Different code paths for kParseInsituFlag.
    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
        internal::StreamLocalCopy<InputStream> copy(is);
        InputStream& s(copy.s);

        CEREAL_RAPIDJSON_ASSERT(s.Peek() == '\"');
        s.Take();  // Skip '\"'

        bool success = false;
        if (parseFlags & kParseInsituFlag) {
            typename InputStream::Ch *head = s.PutBegin();
            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
            size_t length = s.PutEnd(head) - 1;
            CEREAL_RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
            const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
        }
        else {
            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
            const typename TargetEncoding::Ch* const str = stackStream.Pop();
            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
        }
        if (CEREAL_RAPIDJSON_UNLIKELY(!success))
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
    }

    // Parse string to an output is
    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
    CEREAL_RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        static const char escape[256] = {
            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
        };
#undef Z16
//!@endcond

        for (;;) {
            // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
            if (!(parseFlags & kParseValidateEncodingFlag))
                ScanCopyUnescapedString(is, os);

            Ch c = is.Peek();
            if (CEREAL_RAPIDJSON_UNLIKELY(c == '\\')) {    // Escape
                size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
                is.Take();
                Ch e = is.Peek();
                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && CEREAL_RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)])) {
                    is.Take();
                    os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
                }
                else if (CEREAL_RAPIDJSON_LIKELY(e == 'u')) {    // Unicode
                    is.Take();
                    unsigned codepoint = ParseHex4(is, escapeOffset);
                    CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
                    if (CEREAL_RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF)) {
                        // Handle UTF-16 surrogate pair
                        if (CEREAL_RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
                            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
                        unsigned codepoint2 = ParseHex4(is, escapeOffset);
                        CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
                        if (CEREAL_RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
                            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
                        codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
                    }
                    TEncoding::Encode(os, codepoint);
                }
                else
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
            }
            else if (CEREAL_RAPIDJSON_UNLIKELY(c == '"')) {    // Closing double quote
                is.Take();
                os.Put('\0');   // null-terminate the string
                return;
            }
            else if (CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20)) { // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
                if (c == '\0')
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
                else
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
            }
            else {
                size_t offset = is.Tell();
                if (CEREAL_RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
                    CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
            }
        }
    }

    template<typename InputStream, typename OutputStream>
    static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream&, OutputStream&) {
            // Do nothing for generic version
    }

#if defined(CEREAL_RAPIDJSON_SSE2) || defined(CEREAL_RAPIDJSON_SSE42)
    // StringStream -> StackStream<char>
    static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
        const char* p = is.src_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        while (p != nextAligned)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = p;
                return;
            }
            else
                os.Put(*p++);

        // The rest of string using SIMD
        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
        static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));

        for (;; p += 16) {
            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
            if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
                SizeType length;
    #ifdef _MSC_VER         // Find the index of first escaped
                unsigned long offset;
                _BitScanForward(&offset, r);
                length = offset;
    #else
                length = static_cast<SizeType>(__builtin_ffs(r) - 1);
    #endif
                if (length != 0) {
                    char* q = reinterpret_cast<char*>(os.Push(length));
                    for (size_t i = 0; i < length; i++)
                        q[i] = p[i];

                    p += length;
                }
                break;
            }
            _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
        }

        is.src_ = p;
    }

    // InsituStringStream -> InsituStringStream
    static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
        CEREAL_RAPIDJSON_ASSERT(&is == &os);
        (void)os;

        if (is.src_ == is.dst_) {
            SkipUnescapedString(is);
            return;
        }

        char* p = is.src_;
        char *q = is.dst_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        while (p != nextAligned)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = p;
                is.dst_ = q;
                return;
            }
            else
                *q++ = *p++;

        // The rest of string using SIMD
        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
        static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));

        for (;; p += 16, q += 16) {
            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
            if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
                size_t length;
#ifdef _MSC_VER         // Find the index of first escaped
                unsigned long offset;
                _BitScanForward(&offset, r);
                length = offset;
#else
                length = static_cast<size_t>(__builtin_ffs(r) - 1);
#endif
                for (const char* pend = p + length; p != pend; )
                    *q++ = *p++;
                break;
            }
            _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
        }

        is.src_ = p;
        is.dst_ = q;
    }

    // When read/write pointers are the same for insitu stream, just skip unescaped characters
    static CEREAL_RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
        CEREAL_RAPIDJSON_ASSERT(is.src_ == is.dst_);
        char* p = is.src_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        for (; p != nextAligned; p++)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = is.dst_ = p;
                return;
            }

        // The rest of string using SIMD
        static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
        static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
        static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
        const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
        const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
        const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));

        for (;; p += 16) {
            const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
            const __m128i t1 = _mm_cmpeq_epi8(s, dq);
            const __m128i t2 = _mm_cmpeq_epi8(s, bs);
            const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
            const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
            unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
            if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
                size_t length;
#ifdef _MSC_VER         // Find the index of first escaped
                unsigned long offset;
                _BitScanForward(&offset, r);
                length = offset;
#else
                length = static_cast<size_t>(__builtin_ffs(r) - 1);
#endif
                p += length;
                break;
            }
        }

        is.src_ = is.dst_ = p;
    }
#elif defined(CEREAL_RAPIDJSON_NEON)
    // StringStream -> StackStream<char>
    static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream& is, StackStream<char>& os) {
        const char* p = is.src_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        while (p != nextAligned)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = p;
                return;
            }
            else
                os.Put(*p++);

        // The rest of string using SIMD
        const uint8x16_t s0 = vmovq_n_u8('"');
        const uint8x16_t s1 = vmovq_n_u8('\\');
        const uint8x16_t s2 = vmovq_n_u8('\b');
        const uint8x16_t s3 = vmovq_n_u8(32);

        for (;; p += 16) {
            const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
            uint8x16_t x = vceqq_u8(s, s0);
            x = vorrq_u8(x, vceqq_u8(s, s1));
            x = vorrq_u8(x, vceqq_u8(s, s2));
            x = vorrq_u8(x, vcltq_u8(s, s3));

            x = vrev64q_u8(x);                     // Rev in 64
            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

            SizeType length = 0;
            bool escaped = false;
            if (low == 0) {
                if (high != 0) {
                    unsigned lz = (unsigned)__builtin_clzll(high);;
                    length = 8 + (lz >> 3);
                    escaped = true;
                }
            } else {
                unsigned lz = (unsigned)__builtin_clzll(low);;
                length = lz >> 3;
                escaped = true;
            }
            if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
                if (length != 0) {
                    char* q = reinterpret_cast<char*>(os.Push(length));
                    for (size_t i = 0; i < length; i++)
                        q[i] = p[i];

                    p += length;
                }
                break;
            }
            vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
        }

        is.src_ = p;
    }

    // InsituStringStream -> InsituStringStream
    static CEREAL_RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream& is, InsituStringStream& os) {
        CEREAL_RAPIDJSON_ASSERT(&is == &os);
        (void)os;

        if (is.src_ == is.dst_) {
            SkipUnescapedString(is);
            return;
        }

        char* p = is.src_;
        char *q = is.dst_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        while (p != nextAligned)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = p;
                is.dst_ = q;
                return;
            }
            else
                *q++ = *p++;

        // The rest of string using SIMD
        const uint8x16_t s0 = vmovq_n_u8('"');
        const uint8x16_t s1 = vmovq_n_u8('\\');
        const uint8x16_t s2 = vmovq_n_u8('\b');
        const uint8x16_t s3 = vmovq_n_u8(32);

        for (;; p += 16, q += 16) {
            const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
            uint8x16_t x = vceqq_u8(s, s0);
            x = vorrq_u8(x, vceqq_u8(s, s1));
            x = vorrq_u8(x, vceqq_u8(s, s2));
            x = vorrq_u8(x, vcltq_u8(s, s3));

            x = vrev64q_u8(x);                     // Rev in 64
            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

            SizeType length = 0;
            bool escaped = false;
            if (low == 0) {
                if (high != 0) {
                    unsigned lz = (unsigned)__builtin_clzll(high);
                    length = 8 + (lz >> 3);
                    escaped = true;
                }
            } else {
                unsigned lz = (unsigned)__builtin_clzll(low);
                length = lz >> 3;
                escaped = true;
            }
            if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
                for (const char* pend = p + length; p != pend; ) {
                    *q++ = *p++;
                }
                break;
            }
            vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
        }

        is.src_ = p;
        is.dst_ = q;
    }

    // When read/write pointers are the same for insitu stream, just skip unescaped characters
    static CEREAL_RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream& is) {
        CEREAL_RAPIDJSON_ASSERT(is.src_ == is.dst_);
        char* p = is.src_;

        // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
        const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
        for (; p != nextAligned; p++)
            if (CEREAL_RAPIDJSON_UNLIKELY(*p == '\"') || CEREAL_RAPIDJSON_UNLIKELY(*p == '\\') || CEREAL_RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20)) {
                is.src_ = is.dst_ = p;
                return;
            }

        // The rest of string using SIMD
        const uint8x16_t s0 = vmovq_n_u8('"');
        const uint8x16_t s1 = vmovq_n_u8('\\');
        const uint8x16_t s2 = vmovq_n_u8('\b');
        const uint8x16_t s3 = vmovq_n_u8(32);

        for (;; p += 16) {
            const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
            uint8x16_t x = vceqq_u8(s, s0);
            x = vorrq_u8(x, vceqq_u8(s, s1));
            x = vorrq_u8(x, vceqq_u8(s, s2));
            x = vorrq_u8(x, vcltq_u8(s, s3));

            x = vrev64q_u8(x);                     // Rev in 64
            uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
            uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

            if (low == 0) {
                if (high != 0) {
                    int lz = __builtin_clzll(high);
                    p += 8 + (lz >> 3);
                    break;
                }
            } else {
                int lz = __builtin_clzll(low);
                p += lz >> 3;
                break;
            }
        }

        is.src_ = is.dst_ = p;
    }
#endif // CEREAL_RAPIDJSON_NEON

    template<typename InputStream, bool backup, bool pushOnTake>
    class NumberStream;

    template<typename InputStream>
    class NumberStream<InputStream, false, false> {
    public:
        typedef typename InputStream::Ch Ch;

        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }

        CEREAL_RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
        CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
        CEREAL_RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
		  CEREAL_RAPIDJSON_FORCEINLINE void Push(char) {}

        size_t Tell() { return is.Tell(); }
        size_t Length() { return 0; }
        const char* Pop() { return 0; }

    protected:
        NumberStream& operator=(const NumberStream&);

        InputStream& is;
    };

    template<typename InputStream>
    class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false> {
        typedef NumberStream<InputStream, false, false> Base;
    public:
        NumberStream(GenericReader& reader, InputStream& s) : Base(reader, s), stackStream(reader.stack_) {}

        CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() {
            stackStream.Put(static_cast<char>(Base::is.Peek()));
            return Base::is.Take();
        }

        CEREAL_RAPIDJSON_FORCEINLINE void Push(char c) {
            stackStream.Put(c);
        }

        size_t Length() { return stackStream.Length(); }

        const char* Pop() {
            stackStream.Put('\0');
            return stackStream.Pop();
        }

    private:
        StackStream<char> stackStream;
    };

    template<typename InputStream>
    class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false> {
        typedef NumberStream<InputStream, true, false> Base;
    public:
        NumberStream(GenericReader& reader, InputStream& is) : Base(reader, is) {}

        CEREAL_RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
    };

    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseNumber(InputStream& is, Handler& handler) {
        internal::StreamLocalCopy<InputStream> copy(is);
        NumberStream<InputStream,
            ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
                ((parseFlags & kParseInsituFlag) == 0) :
                ((parseFlags & kParseFullPrecisionFlag) != 0),
            (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
                (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);

        size_t startOffset = s.Tell();
        double d = 0.0;
        bool useNanOrInf = false;

        // Parse minus
        bool minus = Consume(s, '-');

        // Parse int: zero / ( digit1-9 *DIGIT )
        unsigned i = 0;
        uint64_t i64 = 0;
        bool use64bit = false;
        int significandDigit = 0;
        if (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() == '0')) {
            i = 0;
            s.TakePush();
        }
        else if (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9')) {
            i = static_cast<unsigned>(s.TakePush() - '0');

            if (minus)
                while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (CEREAL_RAPIDJSON_UNLIKELY(i >= 214748364)) { // 2^31 = 2147483648
                        if (CEREAL_RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8')) {
                            i64 = i;
                            use64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
            else
                while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (CEREAL_RAPIDJSON_UNLIKELY(i >= 429496729)) { // 2^32 - 1 = 4294967295
                        if (CEREAL_RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5')) {
                            i64 = i;
                            use64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
        }
        // Parse NaN or Infinity here
        else if ((parseFlags & kParseNanAndInfFlag) && CEREAL_RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N'))) {
            if (Consume(s, 'N')) {
                if (Consume(s, 'a') && Consume(s, 'N')) {
                    d = std::numeric_limits<double>::quiet_NaN();
                    useNanOrInf = true;
                }
            }
            else if (CEREAL_RAPIDJSON_LIKELY(Consume(s, 'I'))) {
                if (Consume(s, 'n') && Consume(s, 'f')) {
                    d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
                    useNanOrInf = true;

                    if (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
                                                                && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y')))) {
                        CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
                    }
                }
            }

            if (CEREAL_RAPIDJSON_UNLIKELY(!useNanOrInf)) {
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
            }
        }
        else
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());

        // Parse 64bit int
        bool useDouble = false;
        if (use64bit) {
            if (minus)
                while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                     if (CEREAL_RAPIDJSON_UNLIKELY(i64 >= CEREAL_RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
                        if (CEREAL_RAPIDJSON_LIKELY(i64 != CEREAL_RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8')) {
                            d = static_cast<double>(i64);
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
            else
                while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (CEREAL_RAPIDJSON_UNLIKELY(i64 >= CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
                        if (CEREAL_RAPIDJSON_LIKELY(i64 != CEREAL_RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5')) {
                            d = static_cast<double>(i64);
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                    significandDigit++;
                }
        }

        // Force double for big integer
        if (useDouble) {
            while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                d = d * 10 + (s.TakePush() - '0');
            }
        }

        // Parse frac = decimal-point 1*DIGIT
        int expFrac = 0;
        size_t decimalPosition;
        if (Consume(s, '.')) {
            decimalPosition = s.Length();

            if (CEREAL_RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());

            if (!useDouble) {
#if CEREAL_RAPIDJSON_64BIT
                // Use i64 to store significand in 64-bit architecture
                if (!use64bit)
                    i64 = i;

                while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                    if (i64 > CEREAL_RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
                        break;
                    else {
                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
                        --expFrac;
                        if (i64 != 0)
                            significandDigit++;
                    }
                }

                d = static_cast<double>(i64);
#else
                // Use double to store significand in 32-bit architecture
                d = static_cast<double>(use64bit ? i64 : i);
#endif
                useDouble = true;
            }

            while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                if (significandDigit < 17) {
                    d = d * 10.0 + (s.TakePush() - '0');
                    --expFrac;
                    if (CEREAL_RAPIDJSON_LIKELY(d > 0.0))
                        significandDigit++;
                }
                else
                    s.TakePush();
            }
        }
        else
            decimalPosition = s.Length(); // decimal position at the end of integer.

        // Parse exp = e [ minus / plus ] 1*DIGIT
        int exp = 0;
        if (Consume(s, 'e') || Consume(s, 'E')) {
            if (!useDouble) {
                d = static_cast<double>(use64bit ? i64 : i);
                useDouble = true;
            }

            bool expMinus = false;
            if (Consume(s, '+'))
                ;
            else if (Consume(s, '-'))
                expMinus = true;

            if (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                exp = static_cast<int>(s.Take() - '0');
                if (expMinus) {
                    // (exp + expFrac) must not underflow int => we're detecting when -exp gets
                    // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
                    // underflow territory):
                    //
                    //        -(exp * 10 + 9) + expFrac >= INT_MIN
                    //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
                    CEREAL_RAPIDJSON_ASSERT(expFrac <= 0);
                    int maxExp = (expFrac + 2147483639) / 10;

                    while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
                        if (CEREAL_RAPIDJSON_UNLIKELY(exp > maxExp)) {
                            while (CEREAL_RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
                                s.Take();
                        }
                    }
                }
                else {  // positive exp
                    int maxExp = 308 - expFrac;
                    while (CEREAL_RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9')) {
                        exp = exp * 10 + static_cast<int>(s.Take() - '0');
                        if (CEREAL_RAPIDJSON_UNLIKELY(exp > maxExp))
                            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
                    }
                }
            }
            else
                CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());

            if (expMinus)
                exp = -exp;
        }

        // Finish parsing, call event according to the type of number.
        bool cont = true;

        if (parseFlags & kParseNumbersAsStringsFlag) {
            if (parseFlags & kParseInsituFlag) {
                s.Pop();  // Pop stack no matter if it will be used or not.
                typename InputStream::Ch* head = is.PutBegin();
                const size_t length = s.Tell() - startOffset;
                CEREAL_RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
                // unable to insert the \0 character here, it will erase the comma after this number
                const typename TargetEncoding::Ch* const str = reinterpret_cast<typename TargetEncoding::Ch*>(head);
                cont = handler.RawNumber(str, SizeType(length), false);
            }
            else {
                SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
                StringStream srcStream(s.Pop());
                StackStream<typename TargetEncoding::Ch> dstStream(stack_);
                while (numCharsToCopy--) {
                    Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
                }
                dstStream.Put('\0');
                const typename TargetEncoding::Ch* str = dstStream.Pop();
                const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
                cont = handler.RawNumber(str, SizeType(length), true);
            }
        }
        else {
           size_t length = s.Length();
           const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.

           if (useDouble) {
               int p = exp + expFrac;
               if (parseFlags & kParseFullPrecisionFlag)
                   d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
               else
                   d = internal::StrtodNormalPrecision(d, p);

               // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
               if (d > (std::numeric_limits<double>::max)()) {
                   // Overflow
                   // TODO: internal::StrtodX should report overflow (or underflow)
                   CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
               }

               cont = handler.Double(minus ? -d : d);
           }
           else if (useNanOrInf) {
               cont = handler.Double(d);
           }
           else {
               if (use64bit) {
                   if (minus)
                       cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
                   else
                       cont = handler.Uint64(i64);
               }
               else {
                   if (minus)
                       cont = handler.Int(static_cast<int32_t>(~i + 1));
                   else
                       cont = handler.Uint(i);
               }
           }
        }
        if (CEREAL_RAPIDJSON_UNLIKELY(!cont))
            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
    }

    // Parse any JSON value
    template<unsigned parseFlags, typename InputStream, typename Handler>
    void ParseValue(InputStream& is, Handler& handler) {
        switch (is.Peek()) {
            case 'n': ParseNull  <parseFlags>(is, handler); break;
            case 't': ParseTrue  <parseFlags>(is, handler); break;
            case 'f': ParseFalse <parseFlags>(is, handler); break;
            case '"': ParseString<parseFlags>(is, handler); break;
            case '{': ParseObject<parseFlags>(is, handler); break;
            case '[': ParseArray <parseFlags>(is, handler); break;
            default :
                      ParseNumber<parseFlags>(is, handler);
                      break;

        }
    }

    // Iterative Parsing

    // States
    enum IterativeParsingState {
        IterativeParsingFinishState = 0, // sink states at top
        IterativeParsingErrorState,      // sink states at top
        IterativeParsingStartState,

        // Object states
        IterativeParsingObjectInitialState,
        IterativeParsingMemberKeyState,
        IterativeParsingMemberValueState,
        IterativeParsingObjectFinishState,

        // Array states
        IterativeParsingArrayInitialState,
        IterativeParsingElementState,
        IterativeParsingArrayFinishState,

        // Single value state
        IterativeParsingValueState,

        // Delimiter states (at bottom)
        IterativeParsingElementDelimiterState,
        IterativeParsingMemberDelimiterState,
        IterativeParsingKeyValueDelimiterState,

        cIterativeParsingStateCount
    };

    // Tokens
    enum Token {
        LeftBracketToken = 0,
        RightBracketToken,

        LeftCurlyBracketToken,
        RightCurlyBracketToken,

        CommaToken,
        ColonToken,

        StringToken,
        FalseToken,
        TrueToken,
        NullToken,
        NumberToken,

        kTokenCount
    };

    CEREAL_RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {

//!@cond CEREAL_RAPIDJSON_HIDDEN_FROM_DOXYGEN
#define N NumberToken
#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
        // Maps from ASCII to Token
        static const unsigned char tokenMap[256] = {
            N16, // 00~0F
            N16, // 10~1F
            N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
            N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
            N16, // 40~4F
            N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
            N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
            N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
            N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
        };
#undef N
#undef N16
//!@endcond

        if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
            return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
        else
            return NumberToken;
    }

    CEREAL_RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const {
        // current state x one lookahead token -> new state
        static const char G[cIterativeParsingStateCount][kTokenCount] = {
            // Finish(sink state)
            {
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState
            },
            // Error(sink state)
            {
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState
            },
            // Start
            {
                IterativeParsingArrayInitialState,  // Left bracket
                IterativeParsingErrorState,         // Right bracket
                IterativeParsingObjectInitialState, // Left curly bracket
                IterativeParsingErrorState,         // Right curly bracket
                IterativeParsingErrorState,         // Comma
                IterativeParsingErrorState,         // Colon
                IterativeParsingValueState,         // String
                IterativeParsingValueState,         // False
                IterativeParsingValueState,         // True
                IterativeParsingValueState,         // Null
                IterativeParsingValueState          // Number
            },
            // ObjectInitial
            {
                IterativeParsingErrorState,         // Left bracket
                IterativeParsingErrorState,         // Right bracket
                IterativeParsingErrorState,         // Left curly bracket
                IterativeParsingObjectFinishState,  // Right curly bracket
                IterativeParsingErrorState,         // Comma
                IterativeParsingErrorState,         // Colon
                IterativeParsingMemberKeyState,     // String
                IterativeParsingErrorState,         // False
                IterativeParsingErrorState,         // True
                IterativeParsingErrorState,         // Null
                IterativeParsingErrorState          // Number
            },
            // MemberKey
            {
                IterativeParsingErrorState,             // Left bracket
                IterativeParsingErrorState,             // Right bracket
                IterativeParsingErrorState,             // Left curly bracket
                IterativeParsingErrorState,             // Right curly bracket
                IterativeParsingErrorState,             // Comma
                IterativeParsingKeyValueDelimiterState, // Colon
                IterativeParsingErrorState,             // String
                IterativeParsingErrorState,             // False
                IterativeParsingErrorState,             // True
                IterativeParsingErrorState,             // Null
                IterativeParsingErrorState              // Number
            },
            // MemberValue
            {
                IterativeParsingErrorState,             // Left bracket
                IterativeParsingErrorState,             // Right bracket
                IterativeParsingErrorState,             // Left curly bracket
                IterativeParsingObjectFinishState,      // Right curly bracket
                IterativeParsingMemberDelimiterState,   // Comma
                IterativeParsingErrorState,             // Colon
                IterativeParsingErrorState,             // String
                IterativeParsingErrorState,             // False
                IterativeParsingErrorState,             // True
                IterativeParsingErrorState,             // Null
                IterativeParsingErrorState              // Number
            },
            // ObjectFinish(sink state)
            {
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState
            },
            // ArrayInitial
            {
                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
                IterativeParsingArrayFinishState,       // Right bracket
                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
                IterativeParsingErrorState,             // Right curly bracket
                IterativeParsingErrorState,             // Comma
                IterativeParsingErrorState,             // Colon
                IterativeParsingElementState,           // String
                IterativeParsingElementState,           // False
                IterativeParsingElementState,           // True
                IterativeParsingElementState,           // Null
                IterativeParsingElementState            // Number
            },
            // Element
            {
                IterativeParsingErrorState,             // Left bracket
                IterativeParsingArrayFinishState,       // Right bracket
                IterativeParsingErrorState,             // Left curly bracket
                IterativeParsingErrorState,             // Right curly bracket
                IterativeParsingElementDelimiterState,  // Comma
                IterativeParsingErrorState,             // Colon
                IterativeParsingErrorState,             // String
                IterativeParsingErrorState,             // False
                IterativeParsingErrorState,             // True
                IterativeParsingErrorState,             // Null
                IterativeParsingErrorState              // Number
            },
            // ArrayFinish(sink state)
            {
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState
            },
            // Single Value (sink state)
            {
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
                IterativeParsingErrorState
            },
            // ElementDelimiter
            {
                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
                IterativeParsingArrayFinishState,       // Right bracket
                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
                IterativeParsingErrorState,             // Right curly bracket
                IterativeParsingErrorState,             // Comma
                IterativeParsingErrorState,             // Colon
                IterativeParsingElementState,           // String
                IterativeParsingElementState,           // False
                IterativeParsingElementState,           // True
                IterativeParsingElementState,           // Null
                IterativeParsingElementState            // Number
            },
            // MemberDelimiter
            {
                IterativeParsingErrorState,         // Left bracket
                IterativeParsingErrorState,         // Right bracket
                IterativeParsingErrorState,         // Left curly bracket
                IterativeParsingObjectFinishState,  // Right curly bracket
                IterativeParsingErrorState,         // Comma
                IterativeParsingErrorState,         // Colon
                IterativeParsingMemberKeyState,     // String
                IterativeParsingErrorState,         // False
                IterativeParsingErrorState,         // True
                IterativeParsingErrorState,         // Null
                IterativeParsingErrorState          // Number
            },
            // KeyValueDelimiter
            {
                IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
                IterativeParsingErrorState,             // Right bracket
                IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
                IterativeParsingErrorState,             // Right curly bracket
                IterativeParsingErrorState,             // Comma
                IterativeParsingErrorState,             // Colon
                IterativeParsingMemberValueState,       // String
                IterativeParsingMemberValueState,       // False
                IterativeParsingMemberValueState,       // True
                IterativeParsingMemberValueState,       // Null
                IterativeParsingMemberValueState        // Number
            },
        }; // End of G

        return static_cast<IterativeParsingState>(G[state][token]);
    }

    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
    // May return a new state on state pop.
    template <unsigned parseFlags, typename InputStream, typename Handler>
    CEREAL_RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
        (void)token;

        switch (dst) {
        case IterativeParsingErrorState:
            return dst;

        case IterativeParsingObjectInitialState:
        case IterativeParsingArrayInitialState:
        {
            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
            IterativeParsingState n = src;
            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
                n = IterativeParsingElementState;
            else if (src == IterativeParsingKeyValueDelimiterState)
                n = IterativeParsingMemberValueState;
            // Push current state.
            *stack_.template Push<SizeType>(1) = n;
            // Initialize and push the member/element count.
            *stack_.template Push<SizeType>(1) = 0;
            // Call handler
            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
            // On handler short circuits the parsing.
            if (!hr) {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
                return IterativeParsingErrorState;
            }
            else {
                is.Take();
                return dst;
            }
        }

        case IterativeParsingMemberKeyState:
            ParseString<parseFlags>(is, handler, true);
            if (HasParseError())
                return IterativeParsingErrorState;
            else
                return dst;

        case IterativeParsingKeyValueDelimiterState:
            CEREAL_RAPIDJSON_ASSERT(token == ColonToken);
            is.Take();
            return dst;

        case IterativeParsingMemberValueState:
            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
            ParseValue<parseFlags>(is, handler);
            if (HasParseError()) {
                return IterativeParsingErrorState;
            }
            return dst;

        case IterativeParsingElementState:
            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
            ParseValue<parseFlags>(is, handler);
            if (HasParseError()) {
                return IterativeParsingErrorState;
            }
            return dst;

        case IterativeParsingMemberDelimiterState:
        case IterativeParsingElementDelimiterState:
            is.Take();
            // Update member/element count.
            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
            return dst;

        case IterativeParsingObjectFinishState:
        {
            // Transit from delimiter is only allowed when trailing commas are enabled
            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState) {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
                return IterativeParsingErrorState;
            }
            // Get member count.
            SizeType c = *stack_.template Pop<SizeType>(1);
            // If the object is not empty, count the last member.
            if (src == IterativeParsingMemberValueState)
                ++c;
            // Restore the state.
            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
            // Transit to Finish state if this is the topmost scope.
            if (n == IterativeParsingStartState)
                n = IterativeParsingFinishState;
            // Call handler
            bool hr = handler.EndObject(c);
            // On handler short circuits the parsing.
            if (!hr) {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
                return IterativeParsingErrorState;
            }
            else {
                is.Take();
                return n;
            }
        }

        case IterativeParsingArrayFinishState:
        {
            // Transit from delimiter is only allowed when trailing commas are enabled
            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState) {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
                return IterativeParsingErrorState;
            }
            // Get element count.
            SizeType c = *stack_.template Pop<SizeType>(1);
            // If the array is not empty, count the last element.
            if (src == IterativeParsingElementState)
                ++c;
            // Restore the state.
            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
            // Transit to Finish state if this is the topmost scope.
            if (n == IterativeParsingStartState)
                n = IterativeParsingFinishState;
            // Call handler
            bool hr = handler.EndArray(c);
            // On handler short circuits the parsing.
            if (!hr) {
                CEREAL_RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
                return IterativeParsingErrorState;
            }
            else {
                is.Take();
                return n;
            }
        }

        default:
            // This branch is for IterativeParsingValueState actually.
            // Use `default:` rather than
            // `case IterativeParsingValueState:` is for code coverage.

            // The IterativeParsingStartState is not enumerated in this switch-case.
            // It is impossible for that case. And it can be caught by following assertion.

            // The IterativeParsingFinishState is not enumerated in this switch-case either.
            // It is a "derivative" state which cannot triggered from Predict() directly.
            // Therefore it cannot happen here. And it can be caught by following assertion.
            CEREAL_RAPIDJSON_ASSERT(dst == IterativeParsingValueState);

            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
            ParseValue<parseFlags>(is, handler);
            if (HasParseError()) {
                return IterativeParsingErrorState;
            }
            return IterativeParsingFinishState;
        }
    }

    template <typename InputStream>
    void HandleError(IterativeParsingState src, InputStream& is) {
        if (HasParseError()) {
            // Error flag has been set.
            return;
        }

        switch (src) {
        case IterativeParsingStartState:            CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell()); return;
        case IterativeParsingFinishState:           CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell()); return;
        case IterativeParsingObjectInitialState:
        case IterativeParsingMemberDelimiterState:  CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell()); return;
        case IterativeParsingMemberKeyState:        CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell()); return;
        case IterativeParsingMemberValueState:      CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell()); return;
        case IterativeParsingKeyValueDelimiterState:
        case IterativeParsingArrayInitialState:
        case IterativeParsingElementDelimiterState: CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell()); return;
        default: CEREAL_RAPIDJSON_ASSERT(src == IterativeParsingElementState); CEREAL_RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell()); return;
        }
    }

    CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const {
        return s >= IterativeParsingElementDelimiterState;
    }

    CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const {
        return s <= IterativeParsingErrorState;
    }

    template <unsigned parseFlags, typename InputStream, typename Handler>
    ParseResult IterativeParse(InputStream& is, Handler& handler) {
        parseResult_.Clear();
        ClearStackOnExit scope(*this);
        IterativeParsingState state = IterativeParsingStartState;

        SkipWhitespaceAndComments<parseFlags>(is);
        CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
        while (is.Peek() != '\0') {
            Token t = Tokenize(is.Peek());
            IterativeParsingState n = Predict(state, t);
            IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);

            if (d == IterativeParsingErrorState) {
                HandleError(state, is);
                break;
            }

            state = d;

            // Do not further consume streams if a root JSON has been parsed.
            if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
                break;

            SkipWhitespaceAndComments<parseFlags>(is);
            CEREAL_RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
        }

        // Handle the end of file.
        if (state != IterativeParsingFinishState)
            HandleError(state, is);

        return parseResult_;
    }

    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
    ParseResult parseResult_;
    IterativeParsingState state_;
}; // class GenericReader

//! Reader with UTF8 encoding and default allocator.
typedef GenericReader<UTF8<>, UTF8<> > Reader;

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__) || defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_POP
#endif


#ifdef __GNUC__
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_READER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/schema.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available->
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License-> You may obtain a copy of the License at
//
// http://opensource->org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied-> See the License for the 
// specific language governing permissions and limitations under the License->

#ifndef CEREAL_RAPIDJSON_SCHEMA_H_
#define CEREAL_RAPIDJSON_SCHEMA_H_

#include "document.h"
#include "pointer.h"
#include "stringbuffer.h"
#include <cmath> // abs, floor

#if !defined(CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
#define CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
#else
#define CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
#endif

#if !CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
#define CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX 1
#else
#define CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX 0
#endif

#if CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX
#include "internal/regex.h"
#elif CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
#include <regex>
#endif

#if CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX || CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
#define CEREAL_RAPIDJSON_SCHEMA_HAS_REGEX 1
#else
#define CEREAL_RAPIDJSON_SCHEMA_HAS_REGEX 0
#endif

#ifndef CEREAL_RAPIDJSON_SCHEMA_VERBOSE
#define CEREAL_RAPIDJSON_SCHEMA_VERBOSE 0
#endif

#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
#include "stringbuffer.h"
#endif

CEREAL_RAPIDJSON_DIAG_PUSH

#if defined(__GNUC__)
CEREAL_RAPIDJSON_DIAG_OFF(effc++)
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_OFF(weak-vtables)
CEREAL_RAPIDJSON_DIAG_OFF(exit-time-destructors)
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
CEREAL_RAPIDJSON_DIAG_OFF(variadic-macros)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// Verbose Utilities

#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE

namespace internal {

inline void PrintInvalidKeyword(const char* keyword) {
    printf("Fail keyword: %s\n", keyword);
}

inline void PrintInvalidKeyword(const wchar_t* keyword) {
    wprintf(L"Fail keyword: %ls\n", keyword);
}

inline void PrintInvalidDocument(const char* document) {
    printf("Fail document: %s\n\n", document);
}

inline void PrintInvalidDocument(const wchar_t* document) {
    wprintf(L"Fail document: %ls\n\n", document);
}

inline void PrintValidatorPointers(unsigned depth, const char* s, const char* d) {
    printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d);
}

inline void PrintValidatorPointers(unsigned depth, const wchar_t* s, const wchar_t* d) {
    wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d);
}

} // namespace internal

#endif // CEREAL_RAPIDJSON_SCHEMA_VERBOSE

///////////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN

#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
#define CEREAL_RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
#else
#define CEREAL_RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
#endif

#define CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN\
    context.invalidKeyword = keyword.GetString();\
    CEREAL_RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
    return false;\
CEREAL_RAPIDJSON_MULTILINEMACRO_END

///////////////////////////////////////////////////////////////////////////////
// Forward declarations

template <typename ValueType, typename Allocator>
class GenericSchemaDocument;

namespace internal {

template <typename SchemaDocumentType>
class Schema;

///////////////////////////////////////////////////////////////////////////////
// ISchemaValidator

class ISchemaValidator {
public:
    virtual ~ISchemaValidator() {}
    virtual bool IsValid() const = 0;
};

///////////////////////////////////////////////////////////////////////////////
// ISchemaStateFactory

template <typename SchemaType>
class ISchemaStateFactory {
public:
    virtual ~ISchemaStateFactory() {}
    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType&) = 0;
    virtual void DestroySchemaValidator(ISchemaValidator* validator) = 0;
    virtual void* CreateHasher() = 0;
    virtual uint64_t GetHashCode(void* hasher) = 0;
    virtual void DestroryHasher(void* hasher) = 0;
    virtual void* MallocState(size_t size) = 0;
    virtual void FreeState(void* p) = 0;
};

///////////////////////////////////////////////////////////////////////////////
// IValidationErrorHandler

template <typename SchemaType>
class IValidationErrorHandler {
public:
    typedef typename SchemaType::Ch Ch;
    typedef typename SchemaType::SValue SValue;

    virtual ~IValidationErrorHandler() {}

    virtual void NotMultipleOf(int64_t actual, const SValue& expected) = 0;
    virtual void NotMultipleOf(uint64_t actual, const SValue& expected) = 0;
    virtual void NotMultipleOf(double actual, const SValue& expected) = 0;
    virtual void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) = 0;
    virtual void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
    virtual void AboveMaximum(double actual, const SValue& expected, bool exclusive) = 0;
    virtual void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) = 0;
    virtual void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) = 0;
    virtual void BelowMinimum(double actual, const SValue& expected, bool exclusive) = 0;

    virtual void TooLong(const Ch* str, SizeType length, SizeType expected) = 0;
    virtual void TooShort(const Ch* str, SizeType length, SizeType expected) = 0;
    virtual void DoesNotMatch(const Ch* str, SizeType length) = 0;

    virtual void DisallowedItem(SizeType index) = 0;
    virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
    virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
    virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;

    virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
    virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
    virtual void StartMissingProperties() = 0;
    virtual void AddMissingProperty(const SValue& name) = 0;
    virtual bool EndMissingProperties() = 0;
    virtual void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) = 0;
    virtual void DisallowedProperty(const Ch* name, SizeType length) = 0;

    virtual void StartDependencyErrors() = 0;
    virtual void StartMissingDependentProperties() = 0;
    virtual void AddMissingDependentProperty(const SValue& targetName) = 0;
    virtual void EndMissingDependentProperties(const SValue& sourceName) = 0;
    virtual void AddDependencySchemaError(const SValue& souceName, ISchemaValidator* subvalidator) = 0;
    virtual bool EndDependencyErrors() = 0;

    virtual void DisallowedValue() = 0;
    virtual void StartDisallowedType() = 0;
    virtual void AddExpectedType(const typename SchemaType::ValueType& expectedType) = 0;
    virtual void EndDisallowedType(const typename SchemaType::ValueType& actualType) = 0;
    virtual void NotAllOf(ISchemaValidator** subvalidators, SizeType count) = 0;
    virtual void NoneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
    virtual void NotOneOf(ISchemaValidator** subvalidators, SizeType count) = 0;
    virtual void Disallowed() = 0;
};


///////////////////////////////////////////////////////////////////////////////
// Hasher

// For comparison of compound value
template<typename Encoding, typename Allocator>
class Hasher {
public:
    typedef typename Encoding::Ch Ch;

    Hasher(Allocator* allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}

    bool Null() { return WriteType(kNullType); }
    bool Bool(bool b) { return WriteType(b ? kTrueType : kFalseType); }
    bool Int(int i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
    bool Uint(unsigned u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
    bool Int64(int64_t i) { Number n; n.u.i = i; n.d = static_cast<double>(i); return WriteNumber(n); }
    bool Uint64(uint64_t u) { Number n; n.u.u = u; n.d = static_cast<double>(u); return WriteNumber(n); }
    bool Double(double d) { 
        Number n; 
        if (d < 0) n.u.i = static_cast<int64_t>(d);
        else       n.u.u = static_cast<uint64_t>(d); 
        n.d = d;
        return WriteNumber(n);
    }

    bool RawNumber(const Ch* str, SizeType len, bool) {
        WriteBuffer(kNumberType, str, len * sizeof(Ch));
        return true;
    }

    bool String(const Ch* str, SizeType len, bool) {
        WriteBuffer(kStringType, str, len * sizeof(Ch));
        return true;
    }

    bool StartObject() { return true; }
    bool Key(const Ch* str, SizeType len, bool copy) { return String(str, len, copy); }
    bool EndObject(SizeType memberCount) { 
        uint64_t h = Hash(0, kObjectType);
        uint64_t* kv = stack_.template Pop<uint64_t>(memberCount * 2);
        for (SizeType i = 0; i < memberCount; i++)
            h ^= Hash(kv[i * 2], kv[i * 2 + 1]);  // Use xor to achieve member order insensitive
        *stack_.template Push<uint64_t>() = h;
        return true;
    }
    
    bool StartArray() { return true; }
    bool EndArray(SizeType elementCount) { 
        uint64_t h = Hash(0, kArrayType);
        uint64_t* e = stack_.template Pop<uint64_t>(elementCount);
        for (SizeType i = 0; i < elementCount; i++)
            h = Hash(h, e[i]); // Use hash to achieve element order sensitive
        *stack_.template Push<uint64_t>() = h;
        return true;
    }

    bool IsValid() const { return stack_.GetSize() == sizeof(uint64_t); }

    uint64_t GetHashCode() const {
        CEREAL_RAPIDJSON_ASSERT(IsValid());
        return *stack_.template Top<uint64_t>();
    }

private:
    static const size_t kDefaultSize = 256;
    struct Number {
        union U {
            uint64_t u;
            int64_t i;
        }u;
        double d;
    };

    bool WriteType(Type type) { return WriteBuffer(type, 0, 0); }
    
    bool WriteNumber(const Number& n) { return WriteBuffer(kNumberType, &n, sizeof(n)); }
    
    bool WriteBuffer(Type type, const void* data, size_t len) {
        // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/
        uint64_t h = Hash(CEREAL_RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type);
        const unsigned char* d = static_cast<const unsigned char*>(data);
        for (size_t i = 0; i < len; i++)
            h = Hash(h, d[i]);
        *stack_.template Push<uint64_t>() = h;
        return true;
    }

    static uint64_t Hash(uint64_t h, uint64_t d) {
        static const uint64_t kPrime = CEREAL_RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3);
        h ^= d;
        h *= kPrime;
        return h;
    }

    Stack<Allocator> stack_;
};

///////////////////////////////////////////////////////////////////////////////
// SchemaValidationContext

template <typename SchemaDocumentType>
struct SchemaValidationContext {
    typedef Schema<SchemaDocumentType> SchemaType;
    typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
    typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
    typedef typename SchemaType::ValueType ValueType;
    typedef typename ValueType::Ch Ch;

    enum PatternValidatorType {
        kPatternValidatorOnly,
        kPatternValidatorWithProperty,
        kPatternValidatorWithAdditionalProperty
    };

    SchemaValidationContext(SchemaValidatorFactoryType& f, ErrorHandlerType& eh, const SchemaType* s) :
        factory(f),
        error_handler(eh),
        schema(s),
        valueSchema(),
        invalidKeyword(),
        hasher(),
        arrayElementHashCodes(),
        validators(),
        validatorCount(),
        patternPropertiesValidators(),
        patternPropertiesValidatorCount(),
        patternPropertiesSchemas(),
        patternPropertiesSchemaCount(),
        valuePatternValidatorType(kPatternValidatorOnly),
        propertyExist(),
        inArray(false),
        valueUniqueness(false),
        arrayUniqueness(false)
    {
    }

    ~SchemaValidationContext() {
        if (hasher)
            factory.DestroryHasher(hasher);
        if (validators) {
            for (SizeType i = 0; i < validatorCount; i++)
                factory.DestroySchemaValidator(validators[i]);
            factory.FreeState(validators);
        }
        if (patternPropertiesValidators) {
            for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
                factory.DestroySchemaValidator(patternPropertiesValidators[i]);
            factory.FreeState(patternPropertiesValidators);
        }
        if (patternPropertiesSchemas)
            factory.FreeState(patternPropertiesSchemas);
        if (propertyExist)
            factory.FreeState(propertyExist);
    }

    SchemaValidatorFactoryType& factory;
    ErrorHandlerType& error_handler;
    const SchemaType* schema;
    const SchemaType* valueSchema;
    const Ch* invalidKeyword;
    void* hasher; // Only validator access
    void* arrayElementHashCodes; // Only validator access this
    ISchemaValidator** validators;
    SizeType validatorCount;
    ISchemaValidator** patternPropertiesValidators;
    SizeType patternPropertiesValidatorCount;
    const SchemaType** patternPropertiesSchemas;
    SizeType patternPropertiesSchemaCount;
    PatternValidatorType valuePatternValidatorType;
    PatternValidatorType objectPatternValidatorType;
    SizeType arrayElementIndex;
    bool* propertyExist;
    bool inArray;
    bool valueUniqueness;
    bool arrayUniqueness;
};

///////////////////////////////////////////////////////////////////////////////
// Schema

template <typename SchemaDocumentType>
class Schema {
public:
    typedef typename SchemaDocumentType::ValueType ValueType;
    typedef typename SchemaDocumentType::AllocatorType AllocatorType;
    typedef typename SchemaDocumentType::PointerType PointerType;
    typedef typename ValueType::EncodingType EncodingType;
    typedef typename EncodingType::Ch Ch;
    typedef SchemaValidationContext<SchemaDocumentType> Context;
    typedef Schema<SchemaDocumentType> SchemaType;
    typedef GenericValue<EncodingType, AllocatorType> SValue;
    typedef IValidationErrorHandler<Schema> ErrorHandler;
    friend class GenericSchemaDocument<ValueType, AllocatorType>;

    Schema(SchemaDocumentType* schemaDocument, const PointerType& p, const ValueType& value, const ValueType& document, AllocatorType* allocator) :
        allocator_(allocator),
        uri_(schemaDocument->GetURI(), *allocator),
        pointer_(p, allocator),
        typeless_(schemaDocument->GetTypeless()),
        enum_(),
        enumCount_(),
        not_(),
        type_((1 << kTotalSchemaType) - 1), // typeless
        validatorCount_(),
        notValidatorIndex_(),
        properties_(),
        additionalPropertiesSchema_(),
        patternProperties_(),
        patternPropertyCount_(),
        propertyCount_(),
        minProperties_(),
        maxProperties_(SizeType(~0)),
        additionalProperties_(true),
        hasDependencies_(),
        hasRequired_(),
        hasSchemaDependencies_(),
        additionalItemsSchema_(),
        itemsList_(),
        itemsTuple_(),
        itemsTupleCount_(),
        minItems_(),
        maxItems_(SizeType(~0)),
        additionalItems_(true),
        uniqueItems_(false),
        pattern_(),
        minLength_(0),
        maxLength_(~SizeType(0)),
        exclusiveMinimum_(false),
        exclusiveMaximum_(false),
        defaultValueLength_(0)
    {
        typedef typename SchemaDocumentType::ValueType ValueType;
        typedef typename ValueType::ConstValueIterator ConstValueIterator;
        typedef typename ValueType::ConstMemberIterator ConstMemberIterator;

        if (!value.IsObject())
            return;

        if (const ValueType* v = GetMember(value, GetTypeString())) {
            type_ = 0;
            if (v->IsString())
                AddType(*v);
            else if (v->IsArray())
                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
                    AddType(*itr);
        }

        if (const ValueType* v = GetMember(value, GetEnumString()))
            if (v->IsArray() && v->Size() > 0) {
                enum_ = static_cast<uint64_t*>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr) {
                    typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
                    char buffer[256u + 24];
                    MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
                    EnumHasherType h(&hasherAllocator, 256);
                    itr->Accept(h);
                    enum_[enumCount_++] = h.GetHashCode();
                }
            }

        if (schemaDocument) {
            AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
            AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
            AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
        }

        if (const ValueType* v = GetMember(value, GetNotString())) {
            schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
            notValidatorIndex_ = validatorCount_;
            validatorCount_++;
        }

        // Object

        const ValueType* properties = GetMember(value, GetPropertiesString());
        const ValueType* required = GetMember(value, GetRequiredString());
        const ValueType* dependencies = GetMember(value, GetDependenciesString());
        {
            // Gather properties from properties/required/dependencies
            SValue allProperties(kArrayType);

            if (properties && properties->IsObject())
                for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
                    AddUniqueElement(allProperties, itr->name);
            
            if (required && required->IsArray())
                for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
                    if (itr->IsString())
                        AddUniqueElement(allProperties, *itr);

            if (dependencies && dependencies->IsObject())
                for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
                    AddUniqueElement(allProperties, itr->name);
                    if (itr->value.IsArray())
                        for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
                            if (i->IsString())
                                AddUniqueElement(allProperties, *i);
                }

            if (allProperties.Size() > 0) {
                propertyCount_ = allProperties.Size();
                properties_ = static_cast<Property*>(allocator_->Malloc(sizeof(Property) * propertyCount_));
                for (SizeType i = 0; i < propertyCount_; i++) {
                    new (&properties_[i]) Property();
                    properties_[i].name = allProperties[i];
                    properties_[i].schema = typeless_;
                }
            }
        }

        if (properties && properties->IsObject()) {
            PointerType q = p.Append(GetPropertiesString(), allocator_);
            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr) {
                SizeType index;
                if (FindPropertyIndex(itr->name, &index))
                    schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
            }
        }

        if (const ValueType* v = GetMember(value, GetPatternPropertiesString())) {
            PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
            patternProperties_ = static_cast<PatternProperty*>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
            patternPropertyCount_ = 0;

            for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr) {
                new (&patternProperties_[patternPropertyCount_]) PatternProperty();
                patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
                schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
                patternPropertyCount_++;
            }
        }

        if (required && required->IsArray())
            for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
                if (itr->IsString()) {
                    SizeType index;
                    if (FindPropertyIndex(*itr, &index)) {
                        properties_[index].required = true;
                        hasRequired_ = true;
                    }
                }

        if (dependencies && dependencies->IsObject()) {
            PointerType q = p.Append(GetDependenciesString(), allocator_);
            hasDependencies_ = true;
            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr) {
                SizeType sourceIndex;
                if (FindPropertyIndex(itr->name, &sourceIndex)) {
                    if (itr->value.IsArray()) {
                        properties_[sourceIndex].dependencies = static_cast<bool*>(allocator_->Malloc(sizeof(bool) * propertyCount_));
                        std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
                        for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr) {
                            SizeType targetIndex;
                            if (FindPropertyIndex(*targetItr, &targetIndex))
                                properties_[sourceIndex].dependencies[targetIndex] = true;
                        }
                    }
                    else if (itr->value.IsObject()) {
                        hasSchemaDependencies_ = true;
                        schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
                        properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
                        validatorCount_++;
                    }
                }
            }
        }

        if (const ValueType* v = GetMember(value, GetAdditionalPropertiesString())) {
            if (v->IsBool())
                additionalProperties_ = v->GetBool();
            else if (v->IsObject())
                schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
        }

        AssignIfExist(minProperties_, value, GetMinPropertiesString());
        AssignIfExist(maxProperties_, value, GetMaxPropertiesString());

        // Array
        if (const ValueType* v = GetMember(value, GetItemsString())) {
            PointerType q = p.Append(GetItemsString(), allocator_);
            if (v->IsObject()) // List validation
                schemaDocument->CreateSchema(&itemsList_, q, *v, document);
            else if (v->IsArray()) { // Tuple validation
                itemsTuple_ = static_cast<const Schema**>(allocator_->Malloc(sizeof(const Schema*) * v->Size()));
                SizeType index = 0;
                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
                    schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
            }
        }

        AssignIfExist(minItems_, value, GetMinItemsString());
        AssignIfExist(maxItems_, value, GetMaxItemsString());

        if (const ValueType* v = GetMember(value, GetAdditionalItemsString())) {
            if (v->IsBool())
                additionalItems_ = v->GetBool();
            else if (v->IsObject())
                schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
        }

        AssignIfExist(uniqueItems_, value, GetUniqueItemsString());

        // String
        AssignIfExist(minLength_, value, GetMinLengthString());
        AssignIfExist(maxLength_, value, GetMaxLengthString());

        if (const ValueType* v = GetMember(value, GetPatternString()))
            pattern_ = CreatePattern(*v);

        // Number
        if (const ValueType* v = GetMember(value, GetMinimumString()))
            if (v->IsNumber())
                minimum_.CopyFrom(*v, *allocator_);

        if (const ValueType* v = GetMember(value, GetMaximumString()))
            if (v->IsNumber())
                maximum_.CopyFrom(*v, *allocator_);

        AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
        AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());

        if (const ValueType* v = GetMember(value, GetMultipleOfString()))
            if (v->IsNumber() && v->GetDouble() > 0.0)
                multipleOf_.CopyFrom(*v, *allocator_);

        // Default
        if (const ValueType* v = GetMember(value, GetDefaultValueString()))
            if (v->IsString())
                defaultValueLength_ = v->GetStringLength();

    }

    ~Schema() {
        AllocatorType::Free(enum_);
        if (properties_) {
            for (SizeType i = 0; i < propertyCount_; i++)
                properties_[i].~Property();
            AllocatorType::Free(properties_);
        }
        if (patternProperties_) {
            for (SizeType i = 0; i < patternPropertyCount_; i++)
                patternProperties_[i].~PatternProperty();
            AllocatorType::Free(patternProperties_);
        }
        AllocatorType::Free(itemsTuple_);
#if CEREAL_RAPIDJSON_SCHEMA_HAS_REGEX
        if (pattern_) {
            pattern_->~RegexType();
            AllocatorType::Free(pattern_);
        }
#endif
    }

    const SValue& GetURI() const {
        return uri_;
    }

    const PointerType& GetPointer() const {
        return pointer_;
    }

    bool BeginValue(Context& context) const {
        if (context.inArray) {
            if (uniqueItems_)
                context.valueUniqueness = true;

            if (itemsList_)
                context.valueSchema = itemsList_;
            else if (itemsTuple_) {
                if (context.arrayElementIndex < itemsTupleCount_)
                    context.valueSchema = itemsTuple_[context.arrayElementIndex];
                else if (additionalItemsSchema_)
                    context.valueSchema = additionalItemsSchema_;
                else if (additionalItems_)
                    context.valueSchema = typeless_;
                else {
                    context.error_handler.DisallowedItem(context.arrayElementIndex);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
                }
            }
            else
                context.valueSchema = typeless_;

            context.arrayElementIndex++;
        }
        return true;
    }

    CEREAL_RAPIDJSON_FORCEINLINE bool EndValue(Context& context) const {
        if (context.patternPropertiesValidatorCount > 0) {
            bool otherValid = false;
            SizeType count = context.patternPropertiesValidatorCount;
            if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
                otherValid = context.patternPropertiesValidators[--count]->IsValid();

            bool patternValid = true;
            for (SizeType i = 0; i < count; i++)
                if (!context.patternPropertiesValidators[i]->IsValid()) {
                    patternValid = false;
                    break;
                }

            if (context.objectPatternValidatorType == Context::kPatternValidatorOnly) {
                if (!patternValid) {
                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
                }
            }
            else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty) {
                if (!patternValid || !otherValid) {
                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
                }
            }
            else if (!patternValid && !otherValid) { // kPatternValidatorWithAdditionalProperty)
                context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
            }
        }

        if (enum_) {
            const uint64_t h = context.factory.GetHashCode(context.hasher);
            for (SizeType i = 0; i < enumCount_; i++)
                if (enum_[i] == h)
                    goto foundEnum;
            context.error_handler.DisallowedValue();
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
            foundEnum:;
        }

        if (allOf_.schemas)
            for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
                if (!context.validators[i]->IsValid()) {
                    context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
                }
        
        if (anyOf_.schemas) {
            for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
                if (context.validators[i]->IsValid())
                    goto foundAny;
            context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
            foundAny:;
        }

        if (oneOf_.schemas) {
            bool oneValid = false;
            for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
                if (context.validators[i]->IsValid()) {
                    if (oneValid) {
                        context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
                        CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
                    } else
                        oneValid = true;
                }
            if (!oneValid) {
                context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
            }
        }

        if (not_ && context.validators[notValidatorIndex_]->IsValid()) {
            context.error_handler.Disallowed();
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
        }

        return true;
    }

    bool Null(Context& context) const {
        if (!(type_ & (1 << kNullSchemaType))) {
            DisallowedType(context, GetNullString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }
        return CreateParallelValidator(context);
    }
    
    bool Bool(Context& context, bool) const {
        if (!(type_ & (1 << kBooleanSchemaType))) {
            DisallowedType(context, GetBooleanString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }
        return CreateParallelValidator(context);
    }

    bool Int(Context& context, int i) const {
        if (!CheckInt(context, i))
            return false;
        return CreateParallelValidator(context);
    }

    bool Uint(Context& context, unsigned u) const {
        if (!CheckUint(context, u))
            return false;
        return CreateParallelValidator(context);
    }

    bool Int64(Context& context, int64_t i) const {
        if (!CheckInt(context, i))
            return false;
        return CreateParallelValidator(context);
    }

    bool Uint64(Context& context, uint64_t u) const {
        if (!CheckUint(context, u))
            return false;
        return CreateParallelValidator(context);
    }

    bool Double(Context& context, double d) const {
        if (!(type_ & (1 << kNumberSchemaType))) {
            DisallowedType(context, GetNumberString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
            return false;

        if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
            return false;
        
        if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
            return false;
        
        return CreateParallelValidator(context);
    }
    
    bool String(Context& context, const Ch* str, SizeType length, bool) const {
        if (!(type_ & (1 << kStringSchemaType))) {
            DisallowedType(context, GetStringString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        if (minLength_ != 0 || maxLength_ != SizeType(~0)) {
            SizeType count;
            if (internal::CountStringCodePoint<EncodingType>(str, length, &count)) {
                if (count < minLength_) {
                    context.error_handler.TooShort(str, length, minLength_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
                }
                if (count > maxLength_) {
                    context.error_handler.TooLong(str, length, maxLength_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
                }
            }
        }

        if (pattern_ && !IsPatternMatch(pattern_, str, length)) {
            context.error_handler.DoesNotMatch(str, length);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
        }

        return CreateParallelValidator(context);
    }

    bool StartObject(Context& context) const {
        if (!(type_ & (1 << kObjectSchemaType))) {
            DisallowedType(context, GetObjectString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        if (hasDependencies_ || hasRequired_) {
            context.propertyExist = static_cast<bool*>(context.factory.MallocState(sizeof(bool) * propertyCount_));
            std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
        }

        if (patternProperties_) { // pre-allocate schema array
            SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
            context.patternPropertiesSchemas = static_cast<const SchemaType**>(context.factory.MallocState(sizeof(const SchemaType*) * count));
            context.patternPropertiesSchemaCount = 0;
            std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType*) * count);
        }

        return CreateParallelValidator(context);
    }
    
    bool Key(Context& context, const Ch* str, SizeType len, bool) const {
        if (patternProperties_) {
            context.patternPropertiesSchemaCount = 0;
            for (SizeType i = 0; i < patternPropertyCount_; i++)
                if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len)) {
                    context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
                    context.valueSchema = typeless_;
                }
        }

        SizeType index;
        if (FindPropertyIndex(ValueType(str, len).Move(), &index)) {
            if (context.patternPropertiesSchemaCount > 0) {
                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
                context.valueSchema = typeless_;
                context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
            }
            else
                context.valueSchema = properties_[index].schema;

            if (context.propertyExist)
                context.propertyExist[index] = true;

            return true;
        }

        if (additionalPropertiesSchema_) {
            if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0) {
                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
                context.valueSchema = typeless_;
                context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
            }
            else
                context.valueSchema = additionalPropertiesSchema_;
            return true;
        }
        else if (additionalProperties_) {
            context.valueSchema = typeless_;
            return true;
        }

        if (context.patternPropertiesSchemaCount == 0) { // patternProperties are not additional properties
            context.error_handler.DisallowedProperty(str, len);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
        }

        return true;
    }

    bool EndObject(Context& context, SizeType memberCount) const {
        if (hasRequired_) {
            context.error_handler.StartMissingProperties();
            for (SizeType index = 0; index < propertyCount_; index++)
                if (properties_[index].required && !context.propertyExist[index])
                    if (properties_[index].schema->defaultValueLength_ == 0 )
                        context.error_handler.AddMissingProperty(properties_[index].name);
            if (context.error_handler.EndMissingProperties())
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
        }

        if (memberCount < minProperties_) {
            context.error_handler.TooFewProperties(memberCount, minProperties_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
        }

        if (memberCount > maxProperties_) {
            context.error_handler.TooManyProperties(memberCount, maxProperties_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
        }

        if (hasDependencies_) {
            context.error_handler.StartDependencyErrors();
            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++) {
                const Property& source = properties_[sourceIndex];
                if (context.propertyExist[sourceIndex]) {
                    if (source.dependencies) {
                        context.error_handler.StartMissingDependentProperties();
                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
                            if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
                                context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
                        context.error_handler.EndMissingDependentProperties(source.name);
                    }
                    else if (source.dependenciesSchema) {
                        ISchemaValidator* dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
                        if (!dependenciesValidator->IsValid())
                            context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
                    }
                }
            }
            if (context.error_handler.EndDependencyErrors())
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
        }

        return true;
    }

    bool StartArray(Context& context) const {
        if (!(type_ & (1 << kArraySchemaType))) {
            DisallowedType(context, GetArrayString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        context.arrayElementIndex = 0;
        context.inArray = true;

        return CreateParallelValidator(context);
    }

    bool EndArray(Context& context, SizeType elementCount) const {
        context.inArray = false;
        
        if (elementCount < minItems_) {
            context.error_handler.TooFewItems(elementCount, minItems_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
        }
        
        if (elementCount > maxItems_) {
            context.error_handler.TooManyItems(elementCount, maxItems_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
        }

        return true;
    }

    // Generate functions for string literal according to Ch
#define CEREAL_RAPIDJSON_STRING_(name, ...) \
    static const ValueType& Get##name##String() {\
        static const Ch s[] = { __VA_ARGS__, '\0' };\
        static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
        return v;\
    }

    CEREAL_RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l')
    CEREAL_RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
    CEREAL_RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
    CEREAL_RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
    CEREAL_RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
    CEREAL_RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
    CEREAL_RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
    CEREAL_RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
    CEREAL_RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
    CEREAL_RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
    CEREAL_RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
    CEREAL_RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
    CEREAL_RAPIDJSON_STRING_(Not, 'n', 'o', 't')
    CEREAL_RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
    CEREAL_RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
    CEREAL_RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
    CEREAL_RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
    CEREAL_RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
    CEREAL_RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
    CEREAL_RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
    CEREAL_RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
    CEREAL_RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
    CEREAL_RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
    CEREAL_RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
    CEREAL_RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
    CEREAL_RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
    CEREAL_RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
    CEREAL_RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
    CEREAL_RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')

#undef CEREAL_RAPIDJSON_STRING_

private:
    enum SchemaValueType {
        kNullSchemaType,
        kBooleanSchemaType,
        kObjectSchemaType,
        kArraySchemaType,
        kStringSchemaType,
        kNumberSchemaType,
        kIntegerSchemaType,
        kTotalSchemaType
    };

#if CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX
        typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
#elif CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
        typedef std::basic_regex<Ch> RegexType;
#else
        typedef char RegexType;
#endif

    struct SchemaArray {
        SchemaArray() : schemas(), count() {}
        ~SchemaArray() { AllocatorType::Free(schemas); }
        const SchemaType** schemas;
        SizeType begin; // begin index of context.validators
        SizeType count;
    };

    template <typename V1, typename V2>
    void AddUniqueElement(V1& a, const V2& v) {
        for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
            if (*itr == v)
                return;
        V1 c(v, *allocator_);
        a.PushBack(c, *allocator_);
    }

    static const ValueType* GetMember(const ValueType& value, const ValueType& name) {
        typename ValueType::ConstMemberIterator itr = value.FindMember(name);
        return itr != value.MemberEnd() ? &(itr->value) : 0;
    }

    static void AssignIfExist(bool& out, const ValueType& value, const ValueType& name) {
        if (const ValueType* v = GetMember(value, name))
            if (v->IsBool())
                out = v->GetBool();
    }

    static void AssignIfExist(SizeType& out, const ValueType& value, const ValueType& name) {
        if (const ValueType* v = GetMember(value, name))
            if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
                out = static_cast<SizeType>(v->GetUint64());
    }

    void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument, const PointerType& p, const ValueType& value, const ValueType& name, const ValueType& document) {
        if (const ValueType* v = GetMember(value, name)) {
            if (v->IsArray() && v->Size() > 0) {
                PointerType q = p.Append(name, allocator_);
                out.count = v->Size();
                out.schemas = static_cast<const Schema**>(allocator_->Malloc(out.count * sizeof(const Schema*)));
                memset(out.schemas, 0, sizeof(Schema*)* out.count);
                for (SizeType i = 0; i < out.count; i++)
                    schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
                out.begin = validatorCount_;
                validatorCount_ += out.count;
            }
        }
    }

#if CEREAL_RAPIDJSON_SCHEMA_USE_INTERNALREGEX
    template <typename ValueType>
    RegexType* CreatePattern(const ValueType& value) {
        if (value.IsString()) {
            RegexType* r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
            if (!r->IsValid()) {
                r->~RegexType();
                AllocatorType::Free(r);
                r = 0;
            }
            return r;
        }
        return 0;
    }

    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType) {
        GenericRegexSearch<RegexType> rs(*pattern);
        return rs.Search(str);
    }
#elif CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX
    template <typename ValueType>
    RegexType* CreatePattern(const ValueType& value) {
        if (value.IsString()) {
            RegexType *r = static_cast<RegexType*>(allocator_->Malloc(sizeof(RegexType)));
            try {
                return new (r) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
            }
            catch (const std::regex_error&) {
                AllocatorType::Free(r);
            }
        }
        return 0;
    }

    static bool IsPatternMatch(const RegexType* pattern, const Ch *str, SizeType length) {
        std::match_results<const Ch*> r;
        return std::regex_search(str, str + length, r, *pattern);
    }
#else
    template <typename ValueType>
    RegexType* CreatePattern(const ValueType&) { return 0; }

    static bool IsPatternMatch(const RegexType*, const Ch *, SizeType) { return true; }
#endif // CEREAL_RAPIDJSON_SCHEMA_USE_STDREGEX

    void AddType(const ValueType& type) {
        if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
        else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
        else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
        else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
        else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
        else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
        else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
    }

    bool CreateParallelValidator(Context& context) const {
        if (enum_ || context.arrayUniqueness)
            context.hasher = context.factory.CreateHasher();

        if (validatorCount_) {
            CEREAL_RAPIDJSON_ASSERT(context.validators == 0);
            context.validators = static_cast<ISchemaValidator**>(context.factory.MallocState(sizeof(ISchemaValidator*) * validatorCount_));
            context.validatorCount = validatorCount_;

            if (allOf_.schemas)
                CreateSchemaValidators(context, allOf_);

            if (anyOf_.schemas)
                CreateSchemaValidators(context, anyOf_);
            
            if (oneOf_.schemas)
                CreateSchemaValidators(context, oneOf_);
            
            if (not_)
                context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
            
            if (hasSchemaDependencies_) {
                for (SizeType i = 0; i < propertyCount_; i++)
                    if (properties_[i].dependenciesSchema)
                        context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
            }
        }

        return true;
    }

    void CreateSchemaValidators(Context& context, const SchemaArray& schemas) const {
        for (SizeType i = 0; i < schemas.count; i++)
            context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
    }

    // O(n)
    bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const {
        SizeType len = name.GetStringLength();
        const Ch* str = name.GetString();
        for (SizeType index = 0; index < propertyCount_; index++)
            if (properties_[index].name.GetStringLength() == len && 
                (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
            {
                *outIndex = index;
                return true;
            }
        return false;
    }

    bool CheckInt(Context& context, int64_t i) const {
        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
            DisallowedType(context, GetIntegerString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        if (!minimum_.IsNull()) {
            if (minimum_.IsInt64()) {
                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64()) {
                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
                }
            }
            else if (minimum_.IsUint64()) {
                context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
            }
            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
                return false;
        }

        if (!maximum_.IsNull()) {
            if (maximum_.IsInt64()) {
                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64()) {
                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
                }
            }
            else if (maximum_.IsUint64()) { }
                /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
                return false;
        }

        if (!multipleOf_.IsNull()) {
            if (multipleOf_.IsUint64()) {
                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0) {
                    context.error_handler.NotMultipleOf(i, multipleOf_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
                }
            }
            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
                return false;
        }

        return true;
    }

    bool CheckUint(Context& context, uint64_t i) const {
        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType)))) {
            DisallowedType(context, GetIntegerString());
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
        }

        if (!minimum_.IsNull()) {
            if (minimum_.IsUint64()) {
                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64()) {
                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
                }
            }
            else if (minimum_.IsInt64())
                /* do nothing */; // i >= 0 > minimum.Getint64()
            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
                return false;
        }

        if (!maximum_.IsNull()) {
            if (maximum_.IsUint64()) {
                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64()) {
                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
                }
            }
            else if (maximum_.IsInt64()) {
                context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
                CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
            }
            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
                return false;
        }

        if (!multipleOf_.IsNull()) {
            if (multipleOf_.IsUint64()) {
                if (i % multipleOf_.GetUint64() != 0) {
                    context.error_handler.NotMultipleOf(i, multipleOf_);
                    CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
                }
            }
            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
                return false;
        }

        return true;
    }

    bool CheckDoubleMinimum(Context& context, double d) const {
        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble()) {
            context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
        }
        return true;
    }

    bool CheckDoubleMaximum(Context& context, double d) const {
        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble()) {
            context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
        }
        return true;
    }

    bool CheckDoubleMultipleOf(Context& context, double d) const {
        double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
        double q = std::floor(a / b);
        double r = a - q * b;
        if (r > 0.0) {
            context.error_handler.NotMultipleOf(d, multipleOf_);
            CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
        }
        return true;
    }

    void DisallowedType(Context& context, const ValueType& actualType) const {
        ErrorHandler& eh = context.error_handler;
        eh.StartDisallowedType();

        if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
        if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
        if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
        if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
        if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());

        if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
        else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());

        eh.EndDisallowedType(actualType);
    }

    struct Property {
        Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
        ~Property() { AllocatorType::Free(dependencies); }
        SValue name;
        const SchemaType* schema;
        const SchemaType* dependenciesSchema;
        SizeType dependenciesValidatorIndex;
        bool* dependencies;
        bool required;
    };

    struct PatternProperty {
        PatternProperty() : schema(), pattern() {}
        ~PatternProperty() { 
            if (pattern) {
                pattern->~RegexType();
                AllocatorType::Free(pattern);
            }
        }
        const SchemaType* schema;
        RegexType* pattern;
    };

    AllocatorType* allocator_;
    SValue uri_;
    PointerType pointer_;
    const SchemaType* typeless_;
    uint64_t* enum_;
    SizeType enumCount_;
    SchemaArray allOf_;
    SchemaArray anyOf_;
    SchemaArray oneOf_;
    const SchemaType* not_;
    unsigned type_; // bitmask of kSchemaType
    SizeType validatorCount_;
    SizeType notValidatorIndex_;

    Property* properties_;
    const SchemaType* additionalPropertiesSchema_;
    PatternProperty* patternProperties_;
    SizeType patternPropertyCount_;
    SizeType propertyCount_;
    SizeType minProperties_;
    SizeType maxProperties_;
    bool additionalProperties_;
    bool hasDependencies_;
    bool hasRequired_;
    bool hasSchemaDependencies_;

    const SchemaType* additionalItemsSchema_;
    const SchemaType* itemsList_;
    const SchemaType** itemsTuple_;
    SizeType itemsTupleCount_;
    SizeType minItems_;
    SizeType maxItems_;
    bool additionalItems_;
    bool uniqueItems_;

    RegexType* pattern_;
    SizeType minLength_;
    SizeType maxLength_;

    SValue minimum_;
    SValue maximum_;
    SValue multipleOf_;
    bool exclusiveMinimum_;
    bool exclusiveMaximum_;
    
    SizeType defaultValueLength_;
};

template<typename Stack, typename Ch>
struct TokenHelper {
    CEREAL_RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
        *documentStack.template Push<Ch>() = '/';
        char buffer[21];
        size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
        for (size_t i = 0; i < length; i++)
            *documentStack.template Push<Ch>() = static_cast<Ch>(buffer[i]);
    }
};

// Partial specialized version for char to prevent buffer copying.
template <typename Stack>
struct TokenHelper<Stack, char> {
    CEREAL_RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack& documentStack, SizeType index) {
        if (sizeof(SizeType) == 4) {
            char *buffer = documentStack.template Push<char>(1 + 10); // '/' + uint
            *buffer++ = '/';
            const char* end = internal::u32toa(index, buffer);
             documentStack.template Pop<char>(static_cast<size_t>(10 - (end - buffer)));
        }
        else {
            char *buffer = documentStack.template Push<char>(1 + 20); // '/' + uint64
            *buffer++ = '/';
            const char* end = internal::u64toa(index, buffer);
            documentStack.template Pop<char>(static_cast<size_t>(20 - (end - buffer)));
        }
    }
};

} // namespace internal

///////////////////////////////////////////////////////////////////////////////
// IGenericRemoteSchemaDocumentProvider

template <typename SchemaDocumentType>
class IGenericRemoteSchemaDocumentProvider {
public:
    typedef typename SchemaDocumentType::Ch Ch;

    virtual ~IGenericRemoteSchemaDocumentProvider() {}
    virtual const SchemaDocumentType* GetRemoteDocument(const Ch* uri, SizeType length) = 0;
};

///////////////////////////////////////////////////////////////////////////////
// GenericSchemaDocument

//! JSON schema document.
/*!
    A JSON schema document is a compiled version of a JSON schema.
    It is basically a tree of internal::Schema.

    \note This is an immutable class (i.e. its instance cannot be modified after construction).
    \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding.
    \tparam Allocator Allocator type for allocating memory of this document.
*/
template <typename ValueT, typename Allocator = CrtAllocator>
class GenericSchemaDocument {
public:
    typedef ValueT ValueType;
    typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType;
    typedef Allocator AllocatorType;
    typedef typename ValueType::EncodingType EncodingType;
    typedef typename EncodingType::Ch Ch;
    typedef internal::Schema<GenericSchemaDocument> SchemaType;
    typedef GenericPointer<ValueType, Allocator> PointerType;
    typedef GenericValue<EncodingType, Allocator> URIType;
    friend class internal::Schema<GenericSchemaDocument>;
    template <typename, typename, typename>
    friend class GenericSchemaValidator;

    //! Constructor.
    /*!
        Compile a JSON document into schema document.

        \param document A JSON document as source.
        \param uri The base URI of this schema document for purposes of violation reporting.
        \param uriLength Length of \c name, in code points.
        \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
        \param allocator An optional allocator instance for allocating memory. Can be null.
    */
    explicit GenericSchemaDocument(const ValueType& document, const Ch* uri = 0, SizeType uriLength = 0,
        IRemoteSchemaDocumentProviderType* remoteProvider = 0, Allocator* allocator = 0) :
        remoteProvider_(remoteProvider),
        allocator_(allocator),
        ownAllocator_(),
        root_(),
        typeless_(),
        schemaMap_(allocator, kInitialSchemaMapSize),
        schemaRef_(allocator, kInitialSchemaRefSize)
    {
        if (!allocator_)
            ownAllocator_ = allocator_ = CEREAL_RAPIDJSON_NEW(Allocator)();

        Ch noUri[1] = {0};
        uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);

        typeless_ = static_cast<SchemaType*>(allocator_->Malloc(sizeof(SchemaType)));
        new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);

        // Generate root schema, it will call CreateSchema() to create sub-schemas,
        // And call AddRefSchema() if there are $ref.
        CreateSchemaRecursive(&root_, PointerType(), document, document);

        // Resolve $ref
        while (!schemaRef_.Empty()) {
            SchemaRefEntry* refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
            if (const SchemaType* s = GetSchema(refEntry->target)) {
                if (refEntry->schema)
                    *refEntry->schema = s;

                // Create entry in map if not exist
                if (!GetSchema(refEntry->source)) {
                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType*>(s), false, allocator_);
                }
            }
            else if (refEntry->schema)
                *refEntry->schema = typeless_;

            refEntry->~SchemaRefEntry();
        }

        CEREAL_RAPIDJSON_ASSERT(root_ != 0);

        schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
    }

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    //! Move constructor in C++11
    GenericSchemaDocument(GenericSchemaDocument&& rhs) CEREAL_RAPIDJSON_NOEXCEPT :
        remoteProvider_(rhs.remoteProvider_),
        allocator_(rhs.allocator_),
        ownAllocator_(rhs.ownAllocator_),
        root_(rhs.root_),
        typeless_(rhs.typeless_),
        schemaMap_(std::move(rhs.schemaMap_)),
        schemaRef_(std::move(rhs.schemaRef_)),
        uri_(std::move(rhs.uri_))
    {
        rhs.remoteProvider_ = 0;
        rhs.allocator_ = 0;
        rhs.ownAllocator_ = 0;
        rhs.typeless_ = 0;
    }
#endif

    //! Destructor
    ~GenericSchemaDocument() {
        while (!schemaMap_.Empty())
            schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();

        if (typeless_) {
            typeless_->~SchemaType();
            Allocator::Free(typeless_);
        }

        CEREAL_RAPIDJSON_DELETE(ownAllocator_);
    }

    const URIType& GetURI() const { return uri_; }

    //! Get the root schema.
    const SchemaType& GetRoot() const { return *root_; }

private:
    //! Prohibit copying
    GenericSchemaDocument(const GenericSchemaDocument&);
    //! Prohibit assignment
    GenericSchemaDocument& operator=(const GenericSchemaDocument&);

    struct SchemaRefEntry {
        SchemaRefEntry(const PointerType& s, const PointerType& t, const SchemaType** outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {}
        PointerType source;
        PointerType target;
        const SchemaType** schema;
    };

    struct SchemaEntry {
        SchemaEntry(const PointerType& p, SchemaType* s, bool o, Allocator* allocator) : pointer(p, allocator), schema(s), owned(o) {}
        ~SchemaEntry() {
            if (owned) {
                schema->~SchemaType();
                Allocator::Free(schema);
            }
        }
        PointerType pointer;
        SchemaType* schema;
        bool owned;
    };

    void CreateSchemaRecursive(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
        if (schema)
            *schema = typeless_;

        if (v.GetType() == kObjectType) {
            const SchemaType* s = GetSchema(pointer);
            if (!s)
                CreateSchema(schema, pointer, v, document);

            for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
                CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
        }
        else if (v.GetType() == kArrayType)
            for (SizeType i = 0; i < v.Size(); i++)
                CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
    }

    void CreateSchema(const SchemaType** schema, const PointerType& pointer, const ValueType& v, const ValueType& document) {
        CEREAL_RAPIDJSON_ASSERT(pointer.IsValid());
        if (v.IsObject()) {
            if (!HandleRefSchema(pointer, schema, v, document)) {
                SchemaType* s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
                new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
                if (schema)
                    *schema = s;
            }
        }
    }

    bool HandleRefSchema(const PointerType& source, const SchemaType** schema, const ValueType& v, const ValueType& document) {
        static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
        static const ValueType kRefValue(kRefString, 4);

        typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
        if (itr == v.MemberEnd())
            return false;

        if (itr->value.IsString()) {
            SizeType len = itr->value.GetStringLength();
            if (len > 0) {
                const Ch* s = itr->value.GetString();
                SizeType i = 0;
                while (i < len && s[i] != '#') // Find the first #
                    i++;

                if (i > 0) { // Remote reference, resolve immediately
                    if (remoteProvider_) {
                        if (const GenericSchemaDocument* remoteDocument = remoteProvider_->GetRemoteDocument(s, i)) {
                            PointerType pointer(&s[i], len - i, allocator_);
                            if (pointer.IsValid()) {
                                if (const SchemaType* sc = remoteDocument->GetSchema(pointer)) {
                                    if (schema)
                                        *schema = sc;
                                    new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType*>(sc), false, allocator_);
                                    return true;
                                }
                            }
                        }
                    }
                }
                else if (s[i] == '#') { // Local reference, defer resolution
                    PointerType pointer(&s[i], len - i, allocator_);
                    if (pointer.IsValid()) {
                        if (const ValueType* nv = pointer.Get(document))
                            if (HandleRefSchema(source, schema, *nv, document))
                                return true;

                        new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
                        return true;
                    }
                }
            }
        }
        return false;
    }

    const SchemaType* GetSchema(const PointerType& pointer) const {
        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
            if (pointer == target->pointer)
                return target->schema;
        return 0;
    }

    PointerType GetPointer(const SchemaType* schema) const {
        for (const SchemaEntry* target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
            if (schema == target->schema)
                return target->pointer;
        return PointerType();
    }

    const SchemaType* GetTypeless() const { return typeless_; }

    static const size_t kInitialSchemaMapSize = 64;
    static const size_t kInitialSchemaRefSize = 64;

    IRemoteSchemaDocumentProviderType* remoteProvider_;
    Allocator *allocator_;
    Allocator *ownAllocator_;
    const SchemaType* root_;                //!< Root schema.
    SchemaType* typeless_;
    internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
    internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
    URIType uri_;
};

//! GenericSchemaDocument using Value type.
typedef GenericSchemaDocument<Value> SchemaDocument;
//! IGenericRemoteSchemaDocumentProvider using SchemaDocument.
typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;

///////////////////////////////////////////////////////////////////////////////
// GenericSchemaValidator

//! JSON Schema Validator.
/*!
    A SAX style JSON schema validator.
    It uses a \c GenericSchemaDocument to validate SAX events.
    It delegates the incoming SAX events to an output handler.
    The default output handler does nothing.
    It can be reused multiple times by calling \c Reset().

    \tparam SchemaDocumentType Type of schema document.
    \tparam OutputHandler Type of output handler. Default handler does nothing.
    \tparam StateAllocator Allocator for storing the internal validation states.
*/
template <
    typename SchemaDocumentType,
    typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
    typename StateAllocator = CrtAllocator>
class GenericSchemaValidator :
    public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>, 
    public internal::ISchemaValidator,
    public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType>
{
public:
    typedef typename SchemaDocumentType::SchemaType SchemaType;
    typedef typename SchemaDocumentType::PointerType PointerType;
    typedef typename SchemaType::EncodingType EncodingType;
    typedef typename SchemaType::SValue SValue;
    typedef typename EncodingType::Ch Ch;
    typedef GenericStringRef<Ch> StringRefType;
    typedef GenericValue<EncodingType, StateAllocator> ValueType;

    //! Constructor without output handler.
    /*!
        \param schemaDocument The schema document to conform to.
        \param allocator Optional allocator for storing internal validation states.
        \param schemaStackCapacity Optional initial capacity of schema path stack.
        \param documentStackCapacity Optional initial capacity of document path stack.
    */
    GenericSchemaValidator(
        const SchemaDocumentType& schemaDocument,
        StateAllocator* allocator = 0, 
        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
        :
        schemaDocument_(&schemaDocument),
        root_(schemaDocument.GetRoot()),
        stateAllocator_(allocator),
        ownStateAllocator_(0),
        schemaStack_(allocator, schemaStackCapacity),
        documentStack_(allocator, documentStackCapacity),
        outputHandler_(0),
        error_(kObjectType),
        currentError_(),
        missingDependents_(),
        valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        , depth_(0)
#endif
    {
    }

    //! Constructor with output handler.
    /*!
        \param schemaDocument The schema document to conform to.
        \param allocator Optional allocator for storing internal validation states.
        \param schemaStackCapacity Optional initial capacity of schema path stack.
        \param documentStackCapacity Optional initial capacity of document path stack.
    */
    GenericSchemaValidator(
        const SchemaDocumentType& schemaDocument,
        OutputHandler& outputHandler,
        StateAllocator* allocator = 0, 
        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
        :
        schemaDocument_(&schemaDocument),
        root_(schemaDocument.GetRoot()),
        stateAllocator_(allocator),
        ownStateAllocator_(0),
        schemaStack_(allocator, schemaStackCapacity),
        documentStack_(allocator, documentStackCapacity),
        outputHandler_(&outputHandler),
        error_(kObjectType),
        currentError_(),
        missingDependents_(),
        valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        , depth_(0)
#endif
    {
    }

    //! Destructor.
    ~GenericSchemaValidator() {
        Reset();
        CEREAL_RAPIDJSON_DELETE(ownStateAllocator_);
    }

    //! Reset the internal states.
    void Reset() {
        while (!schemaStack_.Empty())
            PopSchema();
        documentStack_.Clear();
        error_.SetObject();
        currentError_.SetNull();
        missingDependents_.SetNull();
        valid_ = true;
    }

    //! Checks whether the current state is valid.
    // Implementation of ISchemaValidator
    virtual bool IsValid() const { return valid_; }

    //! Gets the error object.
    ValueType& GetError() { return error_; }
    const ValueType& GetError() const { return error_; }

    //! Gets the JSON pointer pointed to the invalid schema.
    PointerType GetInvalidSchemaPointer() const {
        return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
    }

    //! Gets the keyword of invalid schema.
    const Ch* GetInvalidSchemaKeyword() const {
        return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
    }

    //! Gets the JSON pointer pointed to the invalid value.
    PointerType GetInvalidDocumentPointer() const {
        if (documentStack_.Empty()) {
            return PointerType();
        }
        else {
            return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
        }
    }

    void NotMultipleOf(int64_t actual, const SValue& expected) {
        AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
    }
    void NotMultipleOf(uint64_t actual, const SValue& expected) {
        AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
    }
    void NotMultipleOf(double actual, const SValue& expected) {
        AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
    }
    void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
    }
    void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
    }
    void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
    }
    void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
    }
    void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
    }
    void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
        AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
            exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
    }

    void TooLong(const Ch* str, SizeType length, SizeType expected) {
        AddNumberError(SchemaType::GetMaxLengthString(),
            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
    }
    void TooShort(const Ch* str, SizeType length, SizeType expected) {
        AddNumberError(SchemaType::GetMinLengthString(),
            ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
    }
    void DoesNotMatch(const Ch* str, SizeType length) {
        currentError_.SetObject();
        currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
        AddCurrentError(SchemaType::GetPatternString());
    }

    void DisallowedItem(SizeType index) {
        currentError_.SetObject();
        currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
        AddCurrentError(SchemaType::GetAdditionalItemsString(), true);
    }
    void TooFewItems(SizeType actualCount, SizeType expectedCount) {
        AddNumberError(SchemaType::GetMinItemsString(),
            ValueType(actualCount).Move(), SValue(expectedCount).Move());
    }
    void TooManyItems(SizeType actualCount, SizeType expectedCount) {
        AddNumberError(SchemaType::GetMaxItemsString(),
            ValueType(actualCount).Move(), SValue(expectedCount).Move());
    }
    void DuplicateItems(SizeType index1, SizeType index2) {
        ValueType duplicates(kArrayType);
        duplicates.PushBack(index1, GetStateAllocator());
        duplicates.PushBack(index2, GetStateAllocator());
        currentError_.SetObject();
        currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
        AddCurrentError(SchemaType::GetUniqueItemsString(), true);
    }

    void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
        AddNumberError(SchemaType::GetMaxPropertiesString(),
            ValueType(actualCount).Move(), SValue(expectedCount).Move());
    }
    void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
        AddNumberError(SchemaType::GetMinPropertiesString(),
            ValueType(actualCount).Move(), SValue(expectedCount).Move());
    }
    void StartMissingProperties() {
        currentError_.SetArray();
    }
    void AddMissingProperty(const SValue& name) {
        currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
    }
    bool EndMissingProperties() {
        if (currentError_.Empty())
            return false;
        ValueType error(kObjectType);
        error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
        currentError_ = error;
        AddCurrentError(SchemaType::GetRequiredString());
        return true;
    }
    void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
        for (SizeType i = 0; i < count; ++i)
            MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
    }
    void DisallowedProperty(const Ch* name, SizeType length) {
        currentError_.SetObject();
        currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
        AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true);
    }

    void StartDependencyErrors() {
        currentError_.SetObject();
    }
    void StartMissingDependentProperties() {
        missingDependents_.SetArray();
    }
    void AddMissingDependentProperty(const SValue& targetName) {
        missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
    }
    void EndMissingDependentProperties(const SValue& sourceName) {
        if (!missingDependents_.Empty())
            currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
                missingDependents_, GetStateAllocator());
    }
    void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator* subvalidator) {
        currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
            static_cast<GenericSchemaValidator*>(subvalidator)->GetError(), GetStateAllocator());
    }
    bool EndDependencyErrors() {
        if (currentError_.ObjectEmpty())
            return false;
        ValueType error(kObjectType);
        error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
        currentError_ = error;
        AddCurrentError(SchemaType::GetDependenciesString());
        return true;
    }

    void DisallowedValue() {
        currentError_.SetObject();
        AddCurrentError(SchemaType::GetEnumString());
    }
    void StartDisallowedType() {
        currentError_.SetArray();
    }
    void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
        currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
    }
    void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
        ValueType error(kObjectType);
        error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
        error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
        currentError_ = error;
        AddCurrentError(SchemaType::GetTypeString());
    }
    void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
        for (SizeType i = 0; i < count; ++i) {
            MergeError(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError());
        }
    }
    void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
        AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count);
    }
    void NotOneOf(ISchemaValidator** subvalidators, SizeType count) {
        AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count);
    }
    void Disallowed() {
        currentError_.SetObject();
        AddCurrentError(SchemaType::GetNotString());
    }

#define CEREAL_RAPIDJSON_STRING_(name, ...) \
    static const StringRefType& Get##name##String() {\
        static const Ch s[] = { __VA_ARGS__, '\0' };\
        static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
        return v;\
    }

    CEREAL_RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
    CEREAL_RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
    CEREAL_RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
    CEREAL_RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
    CEREAL_RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
    CEREAL_RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
    CEREAL_RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
    CEREAL_RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')

#undef CEREAL_RAPIDJSON_STRING_

#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
CEREAL_RAPIDJSON_MULTILINEMACRO_BEGIN\
    *documentStack_.template Push<Ch>() = '\0';\
    documentStack_.template Pop<Ch>(1);\
    internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
CEREAL_RAPIDJSON_MULTILINEMACRO_END
#else
#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
#endif

#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
    if (!valid_) return false; \
    if (!BeginValue() || !CurrentSchema().method arg1) {\
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
        return valid_ = false;\
    }

#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
    for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
        if (context->hasher)\
            static_cast<HasherType*>(context->hasher)->method arg2;\
        if (context->validators)\
            for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
                static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
        if (context->patternPropertiesValidators)\
            for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
                static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
    }

#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
    return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)

#define CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
    CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
    CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
    CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)

    bool Null()             { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()), ( )); }
    bool Bool(bool b)       { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b)); }
    bool Int(int i)         { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i)); }
    bool Uint(unsigned u)   { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u)); }
    bool Int64(int64_t i)   { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64,  (CurrentContext(), i), (i)); }
    bool Uint64(uint64_t u) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u)); }
    bool Double(double d)   { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d)); }
    bool RawNumber(const Ch* str, SizeType length, bool copy)
                                    { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }
    bool String(const Ch* str, SizeType length, bool copy)
                                    { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy)); }

    bool StartObject() {
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
        return valid_ = !outputHandler_ || outputHandler_->StartObject();
    }
    
    bool Key(const Ch* str, SizeType len, bool copy) {
        if (!valid_) return false;
        AppendToken(str, len);
        if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
        return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
    }
    
    bool EndObject(SizeType memberCount) { 
        if (!valid_) return false;
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
        if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false;
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
    }

    bool StartArray() {
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
        return valid_ = !outputHandler_ || outputHandler_->StartArray();
    }
    
    bool EndArray(SizeType elementCount) {
        if (!valid_) return false;
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
        if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false;
        CEREAL_RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
    }

#undef CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
#undef CEREAL_RAPIDJSON_SCHEMA_HANDLE_BEGIN_
#undef CEREAL_RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
#undef CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_

    // Implementation of ISchemaStateFactory<SchemaType>
    virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
        return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        depth_ + 1,
#endif
        &GetStateAllocator());
    }

    virtual void DestroySchemaValidator(ISchemaValidator* validator) {
        GenericSchemaValidator* v = static_cast<GenericSchemaValidator*>(validator);
        v->~GenericSchemaValidator();
        StateAllocator::Free(v);
    }

    virtual void* CreateHasher() {
        return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator());
    }

    virtual uint64_t GetHashCode(void* hasher) {
        return static_cast<HasherType*>(hasher)->GetHashCode();
    }

    virtual void DestroryHasher(void* hasher) {
        HasherType* h = static_cast<HasherType*>(hasher);
        h->~HasherType();
        StateAllocator::Free(h);
    }

    virtual void* MallocState(size_t size) {
        return GetStateAllocator().Malloc(size);
    }

    virtual void FreeState(void* p) {
        StateAllocator::Free(p);
    }

private:
    typedef typename SchemaType::Context Context;
    typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
    typedef internal::Hasher<EncodingType, StateAllocator> HasherType;

    GenericSchemaValidator( 
        const SchemaDocumentType& schemaDocument,
        const SchemaType& root,
        const char* basePath, size_t basePathSize,
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        unsigned depth,
#endif
        StateAllocator* allocator = 0,
        size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
        size_t documentStackCapacity = kDefaultDocumentStackCapacity)
        :
        schemaDocument_(&schemaDocument),
        root_(root),
        stateAllocator_(allocator),
        ownStateAllocator_(0),
        schemaStack_(allocator, schemaStackCapacity),
        documentStack_(allocator, documentStackCapacity),
        outputHandler_(0),
        error_(kObjectType),
        currentError_(),
        missingDependents_(),
        valid_(true)
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        , depth_(depth)
#endif
    {
        if (basePath && basePathSize)
            memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
    }

    StateAllocator& GetStateAllocator() {
        if (!stateAllocator_)
            stateAllocator_ = ownStateAllocator_ = CEREAL_RAPIDJSON_NEW(StateAllocator)();
        return *stateAllocator_;
    }

    bool BeginValue() {
        if (schemaStack_.Empty())
            PushSchema(root_);
        else {
            if (CurrentContext().inArray)
                internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);

            if (!CurrentSchema().BeginValue(CurrentContext()))
                return false;

            SizeType count = CurrentContext().patternPropertiesSchemaCount;
            const SchemaType** sa = CurrentContext().patternPropertiesSchemas;
            typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
            bool valueUniqueness = CurrentContext().valueUniqueness;
            CEREAL_RAPIDJSON_ASSERT(CurrentContext().valueSchema);
            PushSchema(*CurrentContext().valueSchema);

            if (count > 0) {
                CurrentContext().objectPatternValidatorType = patternValidatorType;
                ISchemaValidator**& va = CurrentContext().patternPropertiesValidators;
                SizeType& validatorCount = CurrentContext().patternPropertiesValidatorCount;
                va = static_cast<ISchemaValidator**>(MallocState(sizeof(ISchemaValidator*) * count));
                for (SizeType i = 0; i < count; i++)
                    va[validatorCount++] = CreateSchemaValidator(*sa[i]);
            }

            CurrentContext().arrayUniqueness = valueUniqueness;
        }
        return true;
    }

    bool EndValue() {
        if (!CurrentSchema().EndValue(CurrentContext()))
            return false;

#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
        GenericStringBuffer<EncodingType> sb;
        schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);

        *documentStack_.template Push<Ch>() = '\0';
        documentStack_.template Pop<Ch>(1);
        internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
#endif

        uint64_t h = CurrentContext().arrayUniqueness ? static_cast<HasherType*>(CurrentContext().hasher)->GetHashCode() : 0;
        
        PopSchema();

        if (!schemaStack_.Empty()) {
            Context& context = CurrentContext();
            if (context.valueUniqueness) {
                HashCodeArray* a = static_cast<HashCodeArray*>(context.arrayElementHashCodes);
                if (!a)
                    CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
                for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
                    if (itr->GetUint64() == h) {
                        DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
                        CEREAL_RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
                    }
                a->PushBack(h, GetStateAllocator());
            }
        }

        // Remove the last token of document pointer
        while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/')
            ;

        return true;
    }

    void AppendToken(const Ch* str, SizeType len) {
        documentStack_.template Reserve<Ch>(1 + len * 2); // worst case all characters are escaped as two characters
        *documentStack_.template PushUnsafe<Ch>() = '/';
        for (SizeType i = 0; i < len; i++) {
            if (str[i] == '~') {
                *documentStack_.template PushUnsafe<Ch>() = '~';
                *documentStack_.template PushUnsafe<Ch>() = '0';
            }
            else if (str[i] == '/') {
                *documentStack_.template PushUnsafe<Ch>() = '~';
                *documentStack_.template PushUnsafe<Ch>() = '1';
            }
            else
                *documentStack_.template PushUnsafe<Ch>() = str[i];
        }
    }

    CEREAL_RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) { new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema); }
    
    CEREAL_RAPIDJSON_FORCEINLINE void PopSchema() {
        Context* c = schemaStack_.template Pop<Context>(1);
        if (HashCodeArray* a = static_cast<HashCodeArray*>(c->arrayElementHashCodes)) {
            a->~HashCodeArray();
            StateAllocator::Free(a);
        }
        c->~Context();
    }

    void AddErrorLocation(ValueType& result, bool parent) {
        GenericStringBuffer<EncodingType> sb;
        PointerType instancePointer = GetInvalidDocumentPointer();
        ((parent && instancePointer.GetTokenCount() > 0)
            ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
            : instancePointer).StringifyUriFragment(sb);
        ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
            GetStateAllocator());
        result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
        sb.Clear();
        memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()),
            CurrentSchema().GetURI().GetString(),
            CurrentSchema().GetURI().GetStringLength() * sizeof(Ch));
        GetInvalidSchemaPointer().StringifyUriFragment(sb);
        ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
            GetStateAllocator());
        result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
    }

    void AddError(ValueType& keyword, ValueType& error) {
        typename ValueType::MemberIterator member = error_.FindMember(keyword);
        if (member == error_.MemberEnd())
            error_.AddMember(keyword, error, GetStateAllocator());
        else {
            if (member->value.IsObject()) {
                ValueType errors(kArrayType);
                errors.PushBack(member->value, GetStateAllocator());
                member->value = errors;
            }
            member->value.PushBack(error, GetStateAllocator());
        }
    }

    void AddCurrentError(const typename SchemaType::ValueType& keyword, bool parent = false) {
        AddErrorLocation(currentError_, parent);
        AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_);
    }

    void MergeError(ValueType& other) {
        for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it) {
            AddError(it->name, it->value);
        }
    }

    void AddNumberError(const typename SchemaType::ValueType& keyword, ValueType& actual, const SValue& expected,
        const typename SchemaType::ValueType& (*exclusive)() = 0) {
        currentError_.SetObject();
        currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
        currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
        if (exclusive)
            currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
        AddCurrentError(keyword);
    }

    void AddErrorArray(const typename SchemaType::ValueType& keyword,
        ISchemaValidator** subvalidators, SizeType count) {
        ValueType errors(kArrayType);
        for (SizeType i = 0; i < count; ++i)
            errors.PushBack(static_cast<GenericSchemaValidator*>(subvalidators[i])->GetError(), GetStateAllocator());
        currentError_.SetObject();
        currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
        AddCurrentError(keyword);
    }

    const SchemaType& CurrentSchema() const { return *schemaStack_.template Top<Context>()->schema; }
    Context& CurrentContext() { return *schemaStack_.template Top<Context>(); }
    const Context& CurrentContext() const { return *schemaStack_.template Top<Context>(); }

    static const size_t kDefaultSchemaStackCapacity = 1024;
    static const size_t kDefaultDocumentStackCapacity = 256;
    const SchemaDocumentType* schemaDocument_;
    const SchemaType& root_;
    StateAllocator* stateAllocator_;
    StateAllocator* ownStateAllocator_;
    internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
    internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
    OutputHandler* outputHandler_;
    ValueType error_;
    ValueType currentError_;
    ValueType missingDependents_;
    bool valid_;
#if CEREAL_RAPIDJSON_SCHEMA_VERBOSE
    unsigned depth_;
#endif
};

typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;

///////////////////////////////////////////////////////////////////////////////
// SchemaValidatingReader

//! A helper class for parsing with validation.
/*!
    This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate().

    \tparam parseFlags Combination of \ref ParseFlag.
    \tparam InputStream Type of input stream, implementing Stream concept.
    \tparam SourceEncoding Encoding of the input stream.
    \tparam SchemaDocumentType Type of schema document.
    \tparam StackAllocator Allocator type for stack.
*/
template <
    unsigned parseFlags,
    typename InputStream,
    typename SourceEncoding,
    typename SchemaDocumentType = SchemaDocument,
    typename StackAllocator = CrtAllocator>
class SchemaValidatingReader {
public:
    typedef typename SchemaDocumentType::PointerType PointerType;
    typedef typename InputStream::Ch Ch;
    typedef GenericValue<SourceEncoding, StackAllocator> ValueType;

    //! Constructor
    /*!
        \param is Input stream.
        \param sd Schema document.
    */
    SchemaValidatingReader(InputStream& is, const SchemaDocumentType& sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {}

    template <typename Handler>
    bool operator()(Handler& handler) {
        GenericReader<SourceEncoding, typename SchemaDocumentType::EncodingType, StackAllocator> reader;
        GenericSchemaValidator<SchemaDocumentType, Handler> validator(sd_, handler);
        parseResult_ = reader.template Parse<parseFlags>(is_, validator);

        isValid_ = validator.IsValid();
        if (isValid_) {
            invalidSchemaPointer_ = PointerType();
            invalidSchemaKeyword_ = 0;
            invalidDocumentPointer_ = PointerType();
            error_.SetObject();
        }
        else {
            invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
            invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
            invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
            error_.CopyFrom(validator.GetError(), allocator_);
        }

        return parseResult_;
    }

    const ParseResult& GetParseResult() const { return parseResult_; }
    bool IsValid() const { return isValid_; }
    const PointerType& GetInvalidSchemaPointer() const { return invalidSchemaPointer_; }
    const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
    const PointerType& GetInvalidDocumentPointer() const { return invalidDocumentPointer_; }
    const ValueType& GetError() const { return error_; }

private:
    InputStream& is_;
    const SchemaDocumentType& sd_;

    ParseResult parseResult_;
    PointerType invalidSchemaPointer_;
    const Ch* invalidSchemaKeyword_;
    PointerType invalidDocumentPointer_;
    StackAllocator allocator_;
    ValueType error_;
    bool isValid_;
};

CEREAL_RAPIDJSON_NAMESPACE_END
CEREAL_RAPIDJSON_DIAG_POP

#endif // CEREAL_RAPIDJSON_SCHEMA_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/stream.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#include "rapidjson.h"

#ifndef CEREAL_RAPIDJSON_STREAM_H_
#define CEREAL_RAPIDJSON_STREAM_H_

#include "encodings.h"

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
//  Stream

/*! \class rapidjson::Stream
    \brief Concept for reading and writing characters.

    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().

    For write-only stream, only need to implement Put() and Flush().

\code
concept Stream {
    typename Ch;    //!< Character type of the stream.

    //! Read the current character from stream without moving the read cursor.
    Ch Peek() const;

    //! Read the current character from stream and moving the read cursor to next character.
    Ch Take();

    //! Get the current read cursor.
    //! \return Number of characters read from start.
    size_t Tell();

    //! Begin writing operation at the current read pointer.
    //! \return The begin writer pointer.
    Ch* PutBegin();

    //! Write a character.
    void Put(Ch c);

    //! Flush the buffer.
    void Flush();

    //! End the writing operation.
    //! \param begin The begin write pointer returned by PutBegin().
    //! \return Number of characters written.
    size_t PutEnd(Ch* begin);
}
\endcode
*/

//! Provides additional information for stream.
/*!
    By using traits pattern, this type provides a default configuration for stream.
    For custom stream, this type can be specialized for other configuration.
    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
*/
template<typename Stream>
struct StreamTraits {
    //! Whether to make local copy of stream for optimization during parsing.
    /*!
        By default, for safety, streams do not use local copy optimization.
        Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
    */
    enum { copyOptimization = 0 };
};

//! Reserve n characters for writing to a stream.
template<typename Stream>
inline void PutReserve(Stream& stream, size_t count) {
    (void)stream;
    (void)count;
}

//! Write character to a stream, presuming buffer is reserved.
template<typename Stream>
inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
    stream.Put(c);
}

//! Put N copies of a character to a stream.
template<typename Stream, typename Ch>
inline void PutN(Stream& stream, Ch c, size_t n) {
    PutReserve(stream, n);
    for (size_t i = 0; i < n; i++)
        PutUnsafe(stream, c);
}

///////////////////////////////////////////////////////////////////////////////
// GenericStreamWrapper

//! A Stream Wrapper
/*! \tThis string stream is a wrapper for any stream by just forwarding any
    \treceived message to the origin stream.
    \note implements Stream concept
*/

#if defined(_MSC_VER) && _MSC_VER <= 1800
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4702)  // unreachable code
CEREAL_RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
#endif

template <typename InputStream, typename Encoding = UTF8<> >
class GenericStreamWrapper {
public:
    typedef typename Encoding::Ch Ch;
    GenericStreamWrapper(InputStream& is): is_(is) {}

    Ch Peek() const { return is_.Peek(); }
    Ch Take() { return is_.Take(); }
    size_t Tell() { return is_.Tell(); }
    Ch* PutBegin() { return is_.PutBegin(); }
    void Put(Ch ch) { is_.Put(ch); }
    void Flush() { is_.Flush(); }
    size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }

    // wrapper for MemoryStream
    const Ch* Peek4() const { return is_.Peek4(); }

    // wrapper for AutoUTFInputStream
    UTFType GetType() const { return is_.GetType(); }
    bool HasBOM() const { return is_.HasBOM(); }

protected:
    InputStream& is_;
};

#if defined(_MSC_VER) && _MSC_VER <= 1800
CEREAL_RAPIDJSON_DIAG_POP
#endif

///////////////////////////////////////////////////////////////////////////////
// StringStream

//! Read-only string stream.
/*! \note implements Stream concept
*/
template <typename Encoding>
struct GenericStringStream {
    typedef typename Encoding::Ch Ch;

    GenericStringStream(const Ch *src) : src_(src), head_(src) {}

    Ch Peek() const { return *src_; }
    Ch Take() { return *src_++; }
    size_t Tell() const { return static_cast<size_t>(src_ - head_); }

    Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
    void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
    void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
    size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }

    const Ch* src_;     //!< Current read position.
    const Ch* head_;    //!< Original head of the string.
};

template <typename Encoding>
struct StreamTraits<GenericStringStream<Encoding> > {
    enum { copyOptimization = 1 };
};

//! String stream with UTF8 encoding.
typedef GenericStringStream<UTF8<> > StringStream;

///////////////////////////////////////////////////////////////////////////////
// InsituStringStream

//! A read-write string stream.
/*! This string stream is particularly designed for in-situ parsing.
    \note implements Stream concept
*/
template <typename Encoding>
struct GenericInsituStringStream {
    typedef typename Encoding::Ch Ch;

    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}

    // Read
    Ch Peek() { return *src_; }
    Ch Take() { return *src_++; }
    size_t Tell() { return static_cast<size_t>(src_ - head_); }

    // Write
    void Put(Ch c) { CEREAL_RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }

    Ch* PutBegin() { return dst_ = src_; }
    size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
    void Flush() {}

    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
    void Pop(size_t count) { dst_ -= count; }

    Ch* src_;
    Ch* dst_;
    Ch* head_;
};

template <typename Encoding>
struct StreamTraits<GenericInsituStringStream<Encoding> > {
    enum { copyOptimization = 1 };
};

//! Insitu string stream with UTF8 encoding.
typedef GenericInsituStringStream<UTF8<> > InsituStringStream;

CEREAL_RAPIDJSON_NAMESPACE_END

#endif // CEREAL_RAPIDJSON_STREAM_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/stringbuffer.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_STRINGBUFFER_H_
#define CEREAL_RAPIDJSON_STRINGBUFFER_H_

#include "stream.h"
#include "internal/stack.h"

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
#include <utility> // std::move
#endif

#include "internal/stack.h"

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

//! Represents an in-memory output stream.
/*!
    \tparam Encoding Encoding of the stream.
    \tparam Allocator type for allocating memory buffer.
    \note implements Stream concept
*/
template <typename Encoding, typename Allocator = CrtAllocator>
class GenericStringBuffer {
public:
    typedef typename Encoding::Ch Ch;

    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
        if (&rhs != this)
            stack_ = std::move(rhs.stack_);
        return *this;
    }
#endif

    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
    void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
    void Flush() {}

    void Clear() { stack_.Clear(); }
    void ShrinkToFit() {
        // Push and pop a null terminator. This is safe.
        *stack_.template Push<Ch>() = '\0';
        stack_.ShrinkToFit();
        stack_.template Pop<Ch>(1);
    }

    void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
    Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe<Ch>(count); }
    void Pop(size_t count) { stack_.template Pop<Ch>(count); }

    const Ch* GetString() const {
        // Push and pop a null terminator. This is safe.
        *stack_.template Push<Ch>() = '\0';
        stack_.template Pop<Ch>(1);

        return stack_.template Bottom<Ch>();
    }

    //! Get the size of string in bytes in the string buffer.
    size_t GetSize() const { return stack_.GetSize(); }

    //! Get the length of string in Ch in the string buffer.
    size_t GetLength() const { return stack_.GetSize() / sizeof(Ch); }

    static const size_t kDefaultCapacity = 256;
    mutable internal::Stack<Allocator> stack_;

private:
    // Prohibit copy constructor & assignment operator.
    GenericStringBuffer(const GenericStringBuffer&);
    GenericStringBuffer& operator=(const GenericStringBuffer&);
};

//! String buffer with UTF8 encoding
typedef GenericStringBuffer<UTF8<> > StringBuffer;

template<typename Encoding, typename Allocator>
inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
    stream.Reserve(count);
}

template<typename Encoding, typename Allocator>
inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
    stream.PutUnsafe(c);
}

//! Implement specialized version of PutN() with memset() for better performance.
template<>
inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
}

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_STRINGBUFFER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/writer.h
================================================
// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed 
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
// specific language governing permissions and limitations under the License.

#ifndef CEREAL_RAPIDJSON_WRITER_H_
#define CEREAL_RAPIDJSON_WRITER_H_

#include "stream.h"
#include "internal/meta.h"
#include "internal/stack.h"
#include "internal/strfunc.h"
#include "internal/dtoa.h"
#include "internal/itoa.h"
#include "stringbuffer.h"
#include <new>      // placement new

#if defined(CEREAL_RAPIDJSON_SIMD) && defined(_MSC_VER)
#include <intrin.h>
#pragma intrinsic(_BitScanForward)
#endif
#ifdef CEREAL_RAPIDJSON_SSE42
#include <nmmintrin.h>
#elif defined(CEREAL_RAPIDJSON_SSE2)
#include <emmintrin.h>
#elif defined(CEREAL_RAPIDJSON_NEON)
#include <arm_neon.h>
#endif

#ifdef __clang__
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(padded)
CEREAL_RAPIDJSON_DIAG_OFF(unreachable-code)
CEREAL_RAPIDJSON_DIAG_OFF(c++98-compat)
#elif defined(_MSC_VER)
CEREAL_RAPIDJSON_DIAG_PUSH
CEREAL_RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
#endif

CEREAL_RAPIDJSON_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////////
// WriteFlag

/*! \def CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS 
    \ingroup CEREAL_RAPIDJSON_CONFIG
    \brief User-defined kWriteDefaultFlags definition.

    User can define this as any \c WriteFlag combinations.
*/
#ifndef CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS
#define CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
#endif

//! Combination of writeFlags
enum WriteFlag {
    kWriteNoFlags = 0,              //!< No flags are set.
    kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
    kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
    kWriteDefaultFlags = CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS
};

//! JSON writer
/*! Writer implements the concept Handler.
    It generates JSON text by events to an output os.

    User may programmatically calls the functions of a writer to generate JSON text.

    On the other side, a writer can also be passed to objects that generates events, 

    for example Reader::Parse() and Document::Accept().

    \tparam OutputStream Type of output stream.
    \tparam SourceEncoding Encoding of source string.
    \tparam TargetEncoding Encoding of output stream.
    \tparam StackAllocator Type of allocator for allocating memory of stack.
    \note implements Handler concept
*/
template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
class Writer {
public:
    typedef typename SourceEncoding::Ch Ch;

    static const int kDefaultMaxDecimalPlaces = 324;

    //! Constructor
    /*! \param os Output stream.
        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
        \param levelDepth Initial capacity of stack.
    */
    explicit
    Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 
        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}

    explicit
    Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
        os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}

#if CEREAL_RAPIDJSON_HAS_CXX11_RVALUE_REFS
    Writer(Writer&& rhs) :
        os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_) {
        rhs.os_ = 0;
    }
#endif

    //! Reset the writer with a new stream.
    /*!
        This function reset the writer with a new stream and default settings,
        in order to make a Writer object reusable for output multiple JSONs.

        \param os New output stream.
        \code
        Writer<OutputStream> writer(os1);
        writer.StartObject();
        // ...
        writer.EndObject();

        writer.Reset(os2);
        writer.StartObject();
        // ...
        writer.EndObject();
        \endcode
    */
    void Reset(OutputStream& os) {
        os_ = &os;
        hasRoot_ = false;
        level_stack_.Clear();
    }

    //! Checks whether the output is a complete JSON.
    /*!
        A complete JSON has a complete root object or array.
    */
    bool IsComplete() const {
        return hasRoot_ && level_stack_.Empty();
    }

    int GetMaxDecimalPlaces() const {
        return maxDecimalPlaces_;
    }

    //! Sets the maximum number of decimal places for double output.
    /*!
        This setting truncates the output with specified number of decimal places.

        For example, 

        \code
        writer.SetMaxDecimalPlaces(3);
        writer.StartArray();
        writer.Double(0.12345);                 // "0.123"
        writer.Double(0.0001);                  // "0.0"
        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
        writer.EndArray();
        \endcode

        The default setting does not truncate any decimal places. You can restore to this setting by calling
        \code
        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
        \endcode
    */
    void SetMaxDecimalPlaces(int maxDecimalPlaces) {
        maxDecimalPlaces_ = maxDecimalPlaces;
    }

    /*!@name Implementation of Handler
        \see Handler
    */
    //@{

    bool Null()                 { Prefix(kNullType);   return EndValue(WriteNull()); }
    bool Bool(bool b)           { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); }
    bool Int(int i)             { Prefix(kNumberType); return EndValue(WriteInt(i)); }
    bool Uint(unsigned u)       { Prefix(kNumberType); return EndValue(WriteUint(u)); }
    bool Int64(int64_t i64)     { Prefix(kNumberType); return EndValue(WriteInt64(i64)); }
    bool Uint64(uint64_t u64)   { Prefix(kNumberType); return EndValue(WriteUint64(u64)); }

    //! Writes the given \c double value to the stream
    /*!
        \param d The value to be written.
        \return Whether it is succeed.
    */
    bool Double(double d)       { Prefix(kNumberType); return EndValue(WriteDouble(d)); }

    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
        CEREAL_RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        Prefix(kNumberType);
        return EndValue(WriteString(str, length));
    }

    bool String(const Ch* str, SizeType length, bool copy = false) {
        CEREAL_RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        Prefix(kStringType);
        return EndValue(WriteString(str, length));
    }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool String(const std::basic_string<Ch>& str) {
        return String(str.data(), SizeType(str.size()));
    }
#endif

    bool StartObject() {
        Prefix(kObjectType);
        new (level_stack_.template Push<Level>()) Level(false);
        return WriteStartObject();
    }

    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }

#if CEREAL_RAPIDJSON_HAS_STDSTRING
    bool Key(const std::basic_string<Ch>& str)
    {
      return Key(str.data(), SizeType(str.size()));
    }
#endif
	
    bool EndObject(SizeType memberCount = 0) {
        (void)memberCount;
        CEREAL_RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
        CEREAL_RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
        CEREAL_RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
        level_stack_.template Pop<Level>(1);
        return EndValue(WriteEndObject());
    }

    bool StartArray() {
        Prefix(kArrayType);
        new (level_stack_.template Push<Level>()) Level(true);
        return WriteStartArray();
    }

    bool EndArray(SizeType elementCount = 0) {
        (void)elementCount;
        CEREAL_RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
        CEREAL_RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
        level_stack_.template Pop<Level>(1);
        return EndValue(WriteEndArray());
    }
    //@}

    /*! @name Convenience extensions */
    //@{

    //! Simpler but slower overload.
    bool String(const Ch* const& str) { return String(str, internal::StrLen(str)); }
    bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
    
    //@}

    //! Write a raw JSON value.
    /*!
        For user to write a stringified JSON as a value.

        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
        \param length Length of the json.
        \param type Type of the root of json.
    */
    bool RawValue(const Ch* json, size_t length, Type type) {
        CEREAL_RAPIDJSON_ASSERT(json != 0);
        Prefix(type);
        return EndValue(WriteRawValue(json, length));
    }

    //! Flush the output stream.
    /*!
        Allows the user to flush the output stream immediately.
     */
    void Flush() {
        os_->Flush();
    }

protected:
    //! Information for each nested level
    struct Level {
        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
        size_t valueCount;  //!< number of values in this level
        bool inArray;       //!< true if in array, otherwise in object
    };

    static const size_t kDefaultLevelDepth = 32;

    bool WriteNull()  {
        PutReserve(*os_, 4);
        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
    }

    bool WriteBool(bool b)  {
        if (b) {
            PutReserve(*os_, 4);
            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
        }
        else {
            PutReserve(*os_, 5);
            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
        }
        return true;
    }

    bool WriteInt(int i) {
        char buffer[11];
        const char* end = internal::i32toa(i, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

    bool WriteUint(unsigned u) {
        char buffer[10];
        const char* end = internal::u32toa(u, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

    bool WriteInt64(int64_t i64) {
        char buffer[21];
        const char* end = internal::i64toa(i64, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

    bool WriteUint64(uint64_t u64) {
        char buffer[20];
        char* end = internal::u64toa(u64, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

    bool WriteDouble(double d) {
        if (internal::Double(d).IsNanOrInf()) {
            if (!(writeFlags & kWriteNanAndInfFlag))
                return false;
            if (internal::Double(d).IsNan()) {
                PutReserve(*os_, 3);
                PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
                return true;
            }
            if (internal::Double(d).Sign()) {
                PutReserve(*os_, 9);
                PutUnsafe(*os_, '-');
            }
            else
                PutReserve(*os_, 8);
            PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
            PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
            return true;
        }

        char buffer[25];
        char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

    bool WriteString(const Ch* str, SizeType length)  {
        static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        static const char escape[256] = {
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
            Z16, Z16,                                                                       // 30~4F
              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
#undef Z16
        };

        if (TargetEncoding::supportUnicode)
            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
        else
            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."

        PutUnsafe(*os_, '\"');
        GenericStringStream<SourceEncoding> is(str);
        while (ScanWriteUnescapedString(is, length)) {
            const Ch c = is.Peek();
            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
                // Unicode escaping
                unsigned codepoint;
                if (CEREAL_RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
                    return false;
                PutUnsafe(*os_, '\\');
                PutUnsafe(*os_, 'u');
                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
                }
                else {
                    CEREAL_RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
                    // Surrogate pair
                    unsigned s = codepoint - 0x010000;
                    unsigned lead = (s >> 10) + 0xD800;
                    unsigned trail = (s & 0x3FF) + 0xDC00;
                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
                    PutUnsafe(*os_, '\\');
                    PutUnsafe(*os_, 'u');
                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
                }
            }
            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && CEREAL_RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
                is.Take();
                PutUnsafe(*os_, '\\');
                PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
                if (escape[static_cast<unsigned char>(c)] == 'u') {
                    PutUnsafe(*os_, '0');
                    PutUnsafe(*os_, '0');
                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
                }
            }
            else if (CEREAL_RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
                return false;
        }
        PutUnsafe(*os_, '\"');
        return true;
    }

    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
        return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
    }

    bool WriteStartObject() { os_->Put('{'); return true; }
    bool WriteEndObject()   { os_->Put('}'); return true; }
    bool WriteStartArray()  { os_->Put('['); return true; }
    bool WriteEndArray()    { os_->Put(']'); return true; }

    bool WriteRawValue(const Ch* json, size_t length) {
        PutReserve(*os_, length);
        GenericStringStream<SourceEncoding> is(json);
        while (CEREAL_RAPIDJSON_LIKELY(is.Tell() < length)) {
            CEREAL_RAPIDJSON_ASSERT(is.Peek() != '\0');
            if (CEREAL_RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
                return false;
        }
        return true;
    }

    void Prefix(Type type) {
        (void)type;
        if (CEREAL_RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
            Level* level = level_stack_.template Top<Level>();
            if (level->valueCount > 0) {
                if (level->inArray) 
                    os_->Put(','); // add comma if it is not the first element in array
                else  // in object
                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
            }
            if (!level->inArray && level->valueCount % 2 == 0)
                CEREAL_RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
            level->valueCount++;
        }
        else {
            CEREAL_RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
            hasRoot_ = true;
        }
    }

    // Flush the value if it is the top level one.
    bool EndValue(bool ret) {
        if (CEREAL_RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
            Flush();
        return ret;
    }

    OutputStream* os_;
    internal::Stack<StackAllocator> level_stack_;
    int maxDecimalPlaces_;
    bool hasRoot_;

private:
    // Prohibit copy constructor & assignment operator.
    Writer(const Writer&);
    Writer& operator=(const Writer&);
};

// Full specialization for StringStream to prevent memory copying

template<>
inline bool Writer<StringBuffer>::WriteInt(int i) {
    char *buffer = os_->Push(11);
    const char* end = internal::i32toa(i, buffer);
    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
    return true;
}

template<>
inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
    char *buffer = os_->Push(10);
    const char* end = internal::u32toa(u, buffer);
    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
    return true;
}

template<>
inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
    char *buffer = os_->Push(21);
    const char* end = internal::i64toa(i64, buffer);
    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
    return true;
}

template<>
inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
    char *buffer = os_->Push(20);
    const char* end = internal::u64toa(u, buffer);
    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
    return true;
}

template<>
inline bool Writer<StringBuffer>::WriteDouble(double d) {
    if (internal::Double(d).IsNanOrInf()) {
        // Note: This code path can only be reached if (CEREAL_RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
            return false;
        if (internal::Double(d).IsNan()) {
            PutReserve(*os_, 3);
            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
            return true;
        }
        if (internal::Double(d).Sign()) {
            PutReserve(*os_, 9);
            PutUnsafe(*os_, '-');
        }
        else
            PutReserve(*os_, 8);
        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
        return true;
    }
    
    char *buffer = os_->Push(25);
    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
    return true;
}

#if defined(CEREAL_RAPIDJSON_SSE2) || defined(CEREAL_RAPIDJSON_SSE42)
template<>
inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
    if (length < 16)
        return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);

    if (!CEREAL_RAPIDJSON_LIKELY(is.Tell() < length))
        return false;

    const char* p = is.src_;
    const char* end = is.head_ + length;
    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
    if (nextAligned > end)
        return true;

    while (p != nextAligned)
        if (*p < 0x20 || *p == '\"' || *p == '\\') {
            is.src_ = p;
            return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
        }
        else
            os_->PutUnsafe(*p++);

    // The rest of string using SIMD
    static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
    static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
    static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
    const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
    const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
    const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));

    for (; p != endAligned; p += 16) {
        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
        const __m128i t1 = _mm_cmpeq_epi8(s, dq);
        const __m128i t2 = _mm_cmpeq_epi8(s, bs);
        const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
        const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
        unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
        if (CEREAL_RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
            SizeType len;
#ifdef _MSC_VER         // Find the index of first escaped
            unsigned long offset;
            _BitScanForward(&offset, r);
            len = offset;
#else
            len = static_cast<SizeType>(__builtin_ffs(r) - 1);
#endif
            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
            for (size_t i = 0; i < len; i++)
                q[i] = p[i];

            p += len;
            break;
        }
        _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
    }

    is.src_ = p;
    return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
}
#elif defined(CEREAL_RAPIDJSON_NEON)
template<>
inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
    if (length < 16)
        return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);

    if (!CEREAL_RAPIDJSON_LIKELY(is.Tell() < length))
        return false;

    const char* p = is.src_;
    const char* end = is.head_ + length;
    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
    if (nextAligned > end)
        return true;

    while (p != nextAligned)
        if (*p < 0x20 || *p == '\"' || *p == '\\') {
            is.src_ = p;
            return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
        }
        else
            os_->PutUnsafe(*p++);

    // The rest of string using SIMD
    const uint8x16_t s0 = vmovq_n_u8('"');
    const uint8x16_t s1 = vmovq_n_u8('\\');
    const uint8x16_t s2 = vmovq_n_u8('\b');
    const uint8x16_t s3 = vmovq_n_u8(32);

    for (; p != endAligned; p += 16) {
        const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
        uint8x16_t x = vceqq_u8(s, s0);
        x = vorrq_u8(x, vceqq_u8(s, s1));
        x = vorrq_u8(x, vceqq_u8(s, s2));
        x = vorrq_u8(x, vcltq_u8(s, s3));

        x = vrev64q_u8(x);                     // Rev in 64
        uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
        uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract

        SizeType len = 0;
        bool escaped = false;
        if (low == 0) {
            if (high != 0) {
                unsigned lz = (unsigned)__builtin_clzll(high);
                len = 8 + (lz >> 3);
                escaped = true;
            }
        } else {
            unsigned lz = (unsigned)__builtin_clzll(low);
            len = lz >> 3;
            escaped = true;
        }
        if (CEREAL_RAPIDJSON_UNLIKELY(escaped)) {   // some of characters is escaped
            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
            for (size_t i = 0; i < len; i++)
                q[i] = p[i];

            p += len;
            break;
        }
        vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
    }

    is.src_ = p;
    return CEREAL_RAPIDJSON_LIKELY(is.Tell() < length);
}
#endif // CEREAL_RAPIDJSON_NEON

CEREAL_RAPIDJSON_NAMESPACE_END

#if defined(_MSC_VER) || defined(__clang__)
CEREAL_RAPIDJSON_DIAG_POP
#endif

#endif // CEREAL_RAPIDJSON_CEREAL_RAPIDJSON_H_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/license.txt
================================================
Use of this software is granted under one of the following two licenses,
to be chosen freely by the user.

1. Boost Software License - Version 1.0 - August 17th, 2003
===============================================================================

Copyright (c) 2006, 2007 Marcin Kalicinski

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

2. The MIT License
===============================================================================

Copyright (c) 2006, 2007 Marcin Kalicinski

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.


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/manual.html
================================================
<html><head><style type="text/css">

          body
          {
          font-family: sans-serif;
          font-size: 90%;
          margin: 8pt 8pt 8pt 8pt;
          text-align: justify;
          background-color: White;
          }

          h1 { font-weight: bold; text-align: left;  }
          h2 { font: 140% sans-serif; font-weight: bold; text-align: left;  }
          h3 { font: 120% sans-serif; font-weight: bold; text-align: left;  }
          h4 { font: bold 100% sans-serif; font-weight: bold; text-align: left;  }
          h5 { font: italic 100% sans-serif; font-weight: bold; text-align: left;  }
          h6 { font: small-caps 100% sans-serif; font-weight: bold; text-align: left;  }

          code
          {
          font-family: &quot;Courier New&quot;, Courier, mono;
          }

          pre
          {
          border-top: gray 0.5pt solid;
          border-right: gray 0.5pt solid;
          border-left: gray 0.5pt solid;
          border-bottom: gray 0.5pt solid;
          padding-top: 2pt;
          padding-right: 2pt;
          padding-left: 2pt;
          padding-bottom: 2pt;
          display: block;
          font-family: &quot;courier new&quot;, courier, mono;
          background-color: #eeeeee;
          }

          a
          {
          color: #000080;
          text-decoration: none;
          }

          a:hover
          {
          text-decoration: underline;
          }

          .reference-header
          {
          border-top: gray 0.5pt solid;
          border-right: gray 0.5pt solid;
          border-left: gray 0.5pt solid;
          border-bottom: gray 0.5pt solid;
          padding-top: 2pt;
          padding-right: 2pt;
          padding-left: 2pt;
          padding-bottom: 2pt;
          background-color: #dedede;
          }

          .parameter-name
          {
          font-style: italic;
          }

          .indented
          {
          margin-left: 0.5cm;
          }

          a.toc1
          {
          margin-left: 0.0cm;
          }

          a.toc2
          {
          margin-left: 0.75cm;
          }

          a.toc3
          {
          margin-left: 1.5cm;
          }

        </style></head><body><h1>RAPIDXML Manual</h1><h3>Version 1.13</h3><detaileddescription xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><para><i>Copyright (C) 2006, 2009 Marcin Kalicinski</i><br/><i>See accompanying file <a href="license.txt">license.txt</a> for license information.</i><hr/><h2 level="2">Table of Contents</h2></para><para><toc><toc-contents><a href="#namespacerapidxml_1what_is_rapidxml" class="toc1">1. What is RapidXml?</a><br/><a href="#namespacerapidxml_1dependencies_and_compatibility" class="toc2">1.1 Dependencies And Compatibility</a><br/><a href="#namespacerapidxml_1character_types_and_encodings" class="toc2">1.2 Character Types And Encodings</a><br/><a href="#namespacerapidxml_1error_handling" class="toc2">1.3 Error Handling</a><br/><a href="#namespacerapidxml_1memory_allocation" class="toc2">1.4 Memory Allocation</a><br/><a href="#namespacerapidxml_1w3c_compliance" class="toc2">1.5 W3C Compliance</a><br/><a href="#namespacerapidxml_1api_design" class="toc2">1.6 API Design</a><br/><a href="#namespacerapidxml_1reliability" class="toc2">1.7 Reliability</a><br/><a href="#namespacerapidxml_1acknowledgements" class="toc2">1.8 Acknowledgements</a><br/><a href="#namespacerapidxml_1two_minute_tutorial" class="toc1">2. Two Minute Tutorial</a><br/><a href="#namespacerapidxml_1parsing" class="toc2">2.1 Parsing</a><br/><a href="#namespacerapidxml_1accessing_dom_tree" class="toc2">2.2 Accessing The DOM Tree</a><br/><a href="#namespacerapidxml_1modifying_dom_tree" class="toc2">2.3 Modifying The DOM Tree</a><br/><a href="#namespacerapidxml_1printing" class="toc2">2.4 Printing XML</a><br/><a href="#namespacerapidxml_1differences" class="toc1">3. Differences From Regular XML Parsers</a><br/><a href="#namespacerapidxml_1lifetime_of_source_text" class="toc2">3.1 Lifetime Of Source Text</a><br/><a href="#namespacerapidxml_1ownership_of_strings" class="toc2">3.2 Ownership Of Strings</a><br/><a href="#namespacerapidxml_1destructive_non_destructive" class="toc2">3.3 Destructive Vs Non-Destructive Mode</a><br/><a href="#namespacerapidxml_1performance" class="toc1">4. Performance</a><br/><a href="#namespacerapidxml_1performance_charts" class="toc2">4.1 Comparison With Other Parsers</a><br/><a href="#namespacerapidxml_1reference" class="toc1">5. Reference</a><br/></toc-contents></toc><br/></para><sect1><h2 id="namespacerapidxml_1what_is_rapidxml">1. What is RapidXml?</h2><para><a href="http://rapidxml.sourceforge.net">RapidXml</a> is an attempt to create the fastest XML DOM parser possible, while retaining useability, portability and reasonable W3C compatibility. It is an in-situ parser written in C++, with parsing speed approaching that of <code>strlen()</code> function executed on the same data. <br/><br/>
 Entire parser is contained in a single header file, so no building or linking is neccesary. To use it you just need to copy <code>rapidxml.hpp</code> file to a convenient place (such as your project directory), and include it where needed. You may also want to use printing functions contained in header <code>rapidxml_print.hpp</code>.</para><sect2><h3 id="namespacerapidxml_1dependencies_and_compatibility">1.1 Dependencies And Compatibility</h3><para>RapidXml has <i>no dependencies</i> other than a very small subset of standard C++ library (<code>&lt;cassert&gt;</code>, <code>&lt;cstdlib&gt;</code>, <code>&lt;new&gt;</code> and <code>&lt;exception&gt;</code>, unless exceptions are disabled). It should compile on any reasonably conformant compiler, and was tested on Visual C++ 2003, Visual C++ 2005, Visual C++ 2008, gcc 3, gcc 4, and Comeau 4.3.3. Care was taken that no warnings are produced on these compilers, even with highest warning levels enabled.</para></sect2><sect2><h3 id="namespacerapidxml_1character_types_and_encodings">1.2 Character Types And Encodings</h3><para>RapidXml is character type agnostic, and can work both with narrow and wide characters. Current version does not fully support UTF-16 or UTF-32, so use of wide characters is somewhat incapacitated. However, it should succesfully parse <code>wchar_t</code> strings containing UTF-16 or UTF-32 if endianness of the data matches that of the machine. UTF-8 is fully supported, including all numeric character references, which are expanded into appropriate UTF-8 byte sequences (unless you enable parse_no_utf8 flag). <br/><br/>
 Note that RapidXml performs no decoding - strings returned by name() and value() functions will contain text encoded using the same encoding as source file. Rapidxml understands and expands the following character references: <code>&amp;apos; &amp;amp; &amp;quot; &amp;lt; &amp;gt; &amp;#...;</code> Other character references are not expanded.</para></sect2><sect2><h3 id="namespacerapidxml_1error_handling">1.3 Error Handling</h3><para>By default, RapidXml uses C++ exceptions to report errors. If this behaviour is undesirable, RAPIDXML_NO_EXCEPTIONS can be defined to suppress exception code. See <a href="#classrapidxml_1_1parse__error" kindref="compound">parse_error</a> class and <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">parse_error_handler()</a> function for more information.</para></sect2><sect2><h3 id="namespacerapidxml_1memory_allocation">1.4 Memory Allocation</h3><para>RapidXml uses a special memory pool object to allocate nodes and attributes, because direct allocation using <code>new</code> operator would be far too slow. Underlying memory allocations performed by the pool can be customized by use of <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a" kindref="member">memory_pool::set_allocator()</a> function. See class <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> for more information.</para></sect2><sect2><h3 id="namespacerapidxml_1w3c_compliance">1.5 W3C Compliance</h3><para>RapidXml is not a W3C compliant parser, primarily because it ignores DOCTYPE declarations. There is a number of other, minor incompatibilities as well. Still, it can successfully parse and produce complete trees of all valid XML files in W3C conformance suite (over 1000 files specially designed to find flaws in XML processors). In destructive mode it performs whitespace normalization and character entity substitution for a small set of built-in entities.</para></sect2><sect2><h3 id="namespacerapidxml_1api_design">1.6 API Design</h3><para>RapidXml API is minimalistic, to reduce code size as much as possible, and facilitate use in embedded environments. Additional convenience functions are provided in separate headers: <code>rapidxml_utils.hpp</code> and <code><a href="#rapidxml__print_8hpp" kindref="compound">rapidxml_print.hpp</a></code>. Contents of these headers is not an essential part of the library, and is currently not documented (otherwise than with comments in code).</para></sect2><sect2><h3 id="namespacerapidxml_1reliability">1.7 Reliability</h3><para>RapidXml is very robust and comes with a large harness of unit tests. Special care has been taken to ensure stability of the parser no matter what source text is thrown at it. One of the unit tests produces 100,000 randomly corrupted variants of XML document, which (when uncorrupted) contains all constructs recognized by RapidXml. RapidXml passes this test when it correctly recognizes that errors have been introduced, and does not crash or loop indefinitely. <br/><br/>
 Another unit test puts RapidXml head-to-head with another, well estabilished XML parser, and verifies that their outputs match across a wide variety of small and large documents. <br/><br/>
 Yet another test feeds RapidXml with over 1000 test files from W3C compliance suite, and verifies that correct results are obtained. There are also additional tests that verify each API function separately, and test that various parsing modes work as expected.</para></sect2><sect2><h3 id="namespacerapidxml_1acknowledgements">1.8 Acknowledgements</h3><para>I would like to thank Arseny Kapoulkine for his work on <a href="http://code.google.com/p/pugixml">pugixml</a>, which was an inspiration for this project. Additional thanks go to Kristen Wegner for creating <a href="http://www.codeproject.com/soap/pugxml.asp">pugxml</a>, from which pugixml was derived. Janusz Wohlfeil kindly ran RapidXml speed tests on hardware that I did not have access to, allowing me to expand performance comparison table.</para></sect2></sect1><sect1><h2 id="namespacerapidxml_1two_minute_tutorial">2. Two Minute Tutorial</h2><sect2><h3 id="namespacerapidxml_1parsing">2.1 Parsing</h3><para>The following code causes RapidXml to parse a zero-terminated string named <code>text</code>: <pre>using namespace rapidxml;
xml_document&lt;&gt; doc;    // character type defaults to char
doc.parse&lt;0&gt;(text);    // 0 means default parse flags
</pre><code>doc</code> object is now a root of DOM tree containing representation of the parsed XML. Because all RapidXml interface is contained inside namespace <code>rapidxml</code>, users must either bring contents of this namespace into scope, or fully qualify all the names. Class <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> represents a root of the DOM hierarchy. By means of public inheritance, it is also an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and a <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>. Template parameter of <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function is used to specify parsing flags, with which you can fine-tune behaviour of the parser. Note that flags must be a compile-time constant.</para></sect2><sect2><h3 id="namespacerapidxml_1accessing_dom_tree">2.2 Accessing The DOM Tree</h3><para>To access the DOM tree, use methods of <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and <a href="#classrapidxml_1_1xml__attribute" kindref="compound">xml_attribute</a> classes: <pre>cout &lt;&lt; &quot;Name of my first node is: &quot; &lt;&lt; doc.first_node()-&gt;name() &lt;&lt; &quot;\n&quot;;
xml_node&lt;&gt; *node = doc.first_node(&quot;foobar&quot;);
cout &lt;&lt; &quot;Node foobar has value &quot; &lt;&lt; node-&gt;value() &lt;&lt; &quot;\n&quot;;
for (xml_attribute&lt;&gt; *attr = node-&gt;first_attribute();
     attr; attr = attr-&gt;next_attribute())
{
    cout &lt;&lt; &quot;Node foobar has attribute &quot; &lt;&lt; attr-&gt;name() &lt;&lt; &quot; &quot;;
    cout &lt;&lt; &quot;with value &quot; &lt;&lt; attr-&gt;value() &lt;&lt; &quot;\n&quot;;
}
</pre></para></sect2><sect2><h3 id="namespacerapidxml_1modifying_dom_tree">2.3 Modifying The DOM Tree</h3><para>DOM tree produced by the parser is fully modifiable. Nodes and attributes can be added/removed, and their contents changed. The below example creates a HTML document, whose sole contents is a link to google.com website: <pre>xml_document&lt;&gt; doc;
xml_node&lt;&gt; *node = doc.allocate_node(node_element, &quot;a&quot;, &quot;Google&quot;);
doc.append_node(node);
xml_attribute&lt;&gt; *attr = doc.allocate_attribute(&quot;href&quot;, &quot;google.com&quot;);
node-&gt;append_attribute(attr);
</pre> One quirk is that nodes and attributes <i>do not own</i> the text of their names and values. This is because normally they only store pointers to the source text. So, when assigning a new name or value to the node, care must be taken to ensure proper lifetime of the string. The easiest way to achieve it is to allocate the string from the <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> memory pool. In the above example this is not necessary, because we are only assigning character constants. But the code below uses <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">memory_pool::allocate_string()</a> function to allocate node name (which will have the same lifetime as the document), and assigns it to a new node: <pre>xml_document&lt;&gt; doc;
char *node_name = doc.allocate_string(name);        // Allocate string and copy name into it
xml_node&lt;&gt; *node = doc.allocate_node(node_element, node_name);  // Set node name to node_name
</pre> Check <a href="#namespacerapidxml_1reference" kindref="member">Reference</a>  section for description of the entire interface.</para></sect2><sect2><h3 id="namespacerapidxml_1printing">2.4 Printing XML</h3><para>You can print <code><a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a></code> and <code><a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a></code> objects into an XML string. Use <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function or operator &lt;&lt;, which are defined in <code><a href="#rapidxml__print_8hpp" kindref="compound">rapidxml_print.hpp</a></code> header. <pre>using namespace rapidxml;
xml_document&lt;&gt; doc;    // character type defaults to char
// ... some code to fill the document

// Print to stream using operator &lt;&lt;
std::cout &lt;&lt; doc;   

// Print to stream using print function, specifying printing flags
print(std::cout, doc, 0);   // 0 means default printing flags

// Print to string using output iterator
std::string s;
print(std::back_inserter(s), doc, 0);

// Print to memory buffer using output iterator
char buffer[4096];                      // You are responsible for making the buffer large enough!
char *end = print(buffer, doc, 0);      // end contains pointer to character after last printed character
*end = 0;                               // Add string terminator after XML
</pre></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1differences">3. Differences From Regular XML Parsers</h2><para>RapidXml is an <i>in-situ parser</i>, which allows it to achieve very high parsing speed. In-situ means that parser does not make copies of strings. Instead, it places pointers to the <i>source text</i> in the DOM hierarchy.</para><sect2><h3 id="namespacerapidxml_1lifetime_of_source_text">3.1 Lifetime Of Source Text</h3><para>In-situ parsing requires that source text lives at least as long as the document object. If source text is destroyed, names and values of nodes in DOM tree will become destroyed as well. Additionally, whitespace processing, character entity translation, and zero-termination of strings require that source text be modified during parsing (but see non-destructive mode). This makes the text useless for further processing once it was parsed by RapidXml. <br/><br/>
 In many cases however, these are not serious issues.</para></sect2><sect2><h3 id="namespacerapidxml_1ownership_of_strings">3.2 Ownership Of Strings</h3><para>Nodes and attributes produced by RapidXml do not own their name and value strings. They merely hold the pointers to them. This means you have to be careful when setting these values manually, by using <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e" kindref="member">xml_base::name(const Ch *)</a> or <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c" kindref="member">xml_base::value(const Ch *)</a> functions. Care must be taken to ensure that lifetime of the string passed is at least as long as lifetime of the node/attribute. The easiest way to achieve it is to allocate the string from <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> owned by the document. Use <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">memory_pool::allocate_string()</a> function for this purpose.</para></sect2><sect2><h3 id="namespacerapidxml_1destructive_non_destructive">3.3 Destructive Vs Non-Destructive Mode</h3><para>By default, the parser modifies source text during the parsing process. This is required to achieve character entity translation, whitespace normalization, and zero-termination of strings. <br/><br/>
 In some cases this behaviour may be undesirable, for example if source text resides in read only memory, or is mapped to memory directly from file. By using appropriate parser flags (parse_non_destructive), source text modifications can be disabled. However, because RapidXml does in-situ parsing, it obviously has the following side-effects:<ul><li><para>no whitespace normalization is done</para></li><li><para>no entity reference translation is done</para></li><li><para>names and values are not zero-terminated, you must use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">xml_base::name_size()</a> and <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">xml_base::value_size()</a> functions to tell where they end</para></li></ul></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1performance">4. Performance</h2><para>RapidXml achieves its speed through use of several techniques:<ul><li><para>In-situ parsing. When building DOM tree, RapidXml does not make copies of string data, such as node names and values. Instead, it stores pointers to interior of the source text.</para></li><li><para>Use of template metaprogramming techniques. This allows it to move much of the work to compile time. Through magic of the templates, C++ compiler generates a separate copy of parsing code for any combination of parser flags you use. In each copy, all possible decisions are made at compile time and all unused code is omitted.</para></li><li><para>Extensive use of lookup tables for parsing.</para></li><li><para>Hand-tuned C++ with profiling done on several most popular CPUs.</para></li></ul></para><para>This results in a very small and fast code: a parser which is custom tailored to exact needs with each invocation.</para><sect2><h3 id="namespacerapidxml_1performance_charts">4.1 Comparison With Other Parsers</h3><para>The table below compares speed of RapidXml to some other parsers, and to <code>strlen()</code> function executed on the same data. On a modern CPU (as of 2007), you can expect parsing throughput to be close to 1 GB/s. As a rule of thumb, parsing speed is about 50-100x faster than Xerces DOM, 30-60x faster than TinyXml, 3-12x faster than pugxml, and about 5% - 30% faster than pugixml, the fastest XML parser I know of.</para><para><ul><li><para>The test file is a real-world, 50kB large, moderately dense XML file. </para></li><li><para>All timing is done by using RDTSC instruction present in Pentium-compatible CPUs. </para></li><li><para>No profile-guided optimizations are used. </para></li><li><para>All parsers are running in their fastest modes. </para></li><li><para>The results are given in CPU cycles per character, so frequency of CPUs is irrelevant. </para></li><li><para>The results are minimum values from a large number of runs, to minimize effects of operating system activity, task switching, interrupt handling etc. </para></li><li><para>A single parse of the test file takes about 1/10th of a millisecond, so with large number of runs there is a good chance of hitting at least one no-interrupt streak, and obtaining undisturbed results. </para></li></ul><table rows="9" cols="7" border="1" cellpadding="3pt"><tr><th thead="yes"><para><center>Platform</center></para></th><th thead="yes"><para><center>Compiler</center></para></th><th thead="yes"><para>strlen() </para></th><th thead="yes"><para>RapidXml </para></th><th thead="yes"><para>pugixml 0.3 </para></th><th thead="yes"><para>pugxml </para></th><th thead="yes"><para>TinyXml  </para></th></tr><tr><td thead="no"><para><center>Pentium 4</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>2.5</center></para></td><td thead="no"><para><center>5.4</center></para></td><td thead="no"><para><center>7.0</center></para></td><td thead="no"><para><center>61.7</center></para></td><td thead="no"><para><center>298.8</center></para></td></tr><tr><td thead="no"><para><center>Pentium 4</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.8</center></para></td><td thead="no"><para><center>6.1</center></para></td><td thead="no"><para><center>9.5</center></para></td><td thead="no"><para><center>67.0</center></para></td><td thead="no"><para><center>413.2</center></para></td></tr><tr><td thead="no"><para><center>Core 2</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>1.0</center></para></td><td thead="no"><para><center>4.5</center></para></td><td thead="no"><para><center>5.0</center></para></td><td thead="no"><para><center>24.6</center></para></td><td thead="no"><para><center>154.8</center></para></td></tr><tr><td thead="no"><para><center>Core 2</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.6</center></para></td><td thead="no"><para><center>4.6</center></para></td><td thead="no"><para><center>5.4</center></para></td><td thead="no"><para><center>28.3</center></para></td><td thead="no"><para><center>229.3</center></para></td></tr><tr><td thead="no"><para><center>Athlon XP</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>3.1</center></para></td><td thead="no"><para><center>7.7</center></para></td><td thead="no"><para><center>8.0</center></para></td><td thead="no"><para><center>25.5</center></para></td><td thead="no"><para><center>182.6</center></para></td></tr><tr><td thead="no"><para><center>Athlon XP</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.9</center></para></td><td thead="no"><para><center>8.2</center></para></td><td thead="no"><para><center>9.2</center></para></td><td thead="no"><para><center>33.7</center></para></td><td thead="no"><para><center>265.2</center></para></td></tr><tr><td thead="no"><para><center>Pentium 3</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>2.0</center></para></td><td thead="no"><para><center>6.3</center></para></td><td thead="no"><para><center>7.0</center></para></td><td thead="no"><para><center>30.9</center></para></td><td thead="no"><para><center>211.9</center></para></td></tr><tr><td thead="no"><para><center>Pentium 3</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>1.0</center></para></td><td thead="no"><para><center>6.7</center></para></td><td thead="no"><para><center>8.9</center></para></td><td thead="no"><para><center>35.3</center></para></td><td thead="no"><para><center>316.0</center></para></td></tr></table><i>(*) All results are in CPU cycles per character of source text</i></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1reference">5. Reference</h2><para>This section lists all classes, functions, constants etc. and describes them in detail. </para></sect1></detaileddescription><dl><dt>class
								  template
							   <a href="#classrapidxml_1_1memory__pool">rapidxml::memory_pool</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1memory__pool_f8fb3c8f1a564f8045c40bcd07a89866_1f8fb3c8f1a564f8045c40bcd07a89866">memory_pool()</a></dt><dt class="indented">
				destructor
			 <a href="#classrapidxml_1_1memory__pool_6f8c7990d9ec1ed2acf6558b238570eb_16f8c7990d9ec1ed2acf6558b238570eb">~memory_pool()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41">allocate_node(node_type type, const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457">allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859">allocate_string(const Ch *source=0, std::size_t size=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_95c49fcb056e9103ec906a59e3e01d76_195c49fcb056e9103ec906a59e3e01d76">clone_node(const xml_node&lt; Ch &gt; *source, xml_node&lt; Ch &gt; *result=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">clear()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a">set_allocator(alloc_func *af, free_func *ff)</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><p/><dt>class <a href="#classrapidxml_1_1parse__error">rapidxml::parse_error</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1parse__error_4dd8d1bdbd9221df4dcb90cafaee3332_14dd8d1bdbd9221df4dcb90cafaee3332">parse_error(const char *what, void *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba">what() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca">where() const </a></dt><dt class="indented"/><dt class="indented"/><p/><dt>class
								  template
							   <a href="#classrapidxml_1_1xml__attribute">rapidxml::xml_attribute</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1xml__attribute_d5464aadf08269a886b730993525db34_1d5464aadf08269a886b730993525db34">xml_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">document() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_5c4a98d2b75f9b41b12c110108fd55ab_15c4a98d2b75f9b41b12c110108fd55ab">previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_1b8a814d0d3a7165396b08433eee8a91_11b8a814d0d3a7165396b08433eee8a91">next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>class
								  template
							   <a href="#classrapidxml_1_1xml__base">rapidxml::xml_base</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1xml__base_23630d2c130a9e0e3f3afa7584a9b218_123630d2c130a9e0e3f3afa7584a9b218">xml_base()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707">name() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c">name_size() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f">value() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db">value_size() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c">name(const Ch *name, std::size_t size)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e">name(const Ch *name)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb">value(const Ch *value, std::size_t size)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c">value(const Ch *value)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e">parent() const </a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>class
								  template
							   <a href="#classrapidxml_1_1xml__document">rapidxml::xml_document</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1xml__document_6ce266cc52d549c42abe3a3d5e8af9ba_16ce266cc52d549c42abe3a3d5e8af9ba">xml_document()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c">parse(Ch *text)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__document_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">clear()</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><p/><p/><p/><p/><p/><p/><p/><p/><dt>class
								  template
							   <a href="#classrapidxml_1_1xml__node">rapidxml::xml_node</a></dt><dt class="indented">
				constructor
			 <a href="#classrapidxml_1_1xml__node_34c55af3504549a475e5b9dfcaa6adf5_134c55af3504549a475e5b9dfcaa6adf5">xml_node(node_type type)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0">type() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">document() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a">first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_fcb6e2209b591a36d2dadba20d2bc7cc_1fcb6e2209b591a36d2dadba20d2bc7cc">last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_ac2f6886c0107e9d5f156e9542546df6_1ac2f6886c0107e9d5f156e9542546df6">previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_b3ead2cefecc03a813836203e3f6f38f_1b3ead2cefecc03a813836203e3f6f38f">next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83">first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_16953d66751b5b949ee4ee2d9c0bc63a_116953d66751b5b949ee4ee2d9c0bc63a">last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_a78759bfa429fa2ab6bc5fe617cfa3cf_1a78759bfa429fa2ab6bc5fe617cfa3cf">type(node_type type)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_0c39df6617e709eb2fba11300dea63f2_10c39df6617e709eb2fba11300dea63f2">prepend_node(xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_86de2e22276826089b7baed2599f8dee_186de2e22276826089b7baed2599f8dee">append_node(xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_780972a57fc447250ab47cc8f421b65e_1780972a57fc447250ab47cc8f421b65e">insert_node(xml_node&lt; Ch &gt; *where, xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_9a31d861e1bddc710839c551a5d2b3a4_19a31d861e1bddc710839c551a5d2b3a4">remove_first_node()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_87addf2bc127ee31aa4b5295d3c9b530_187addf2bc127ee31aa4b5295d3c9b530">remove_last_node()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_9316463a2201631e7e2062b17729f9cd_19316463a2201631e7e2062b17729f9cd">remove_node(xml_node&lt; Ch &gt; *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_0218147d13e41d5fa60ced4e7a7e9726_10218147d13e41d5fa60ced4e7a7e9726">remove_all_nodes()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_f6dffa513da74cc0be71a7ba84f8265e_1f6dffa513da74cc0be71a7ba84f8265e">prepend_attribute(xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_8fbd4f5ef7169d493da9f8d87ac04b77_18fbd4f5ef7169d493da9f8d87ac04b77">append_attribute(xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_070d5888b0557fe06a5b24961de1b988_1070d5888b0557fe06a5b24961de1b988">insert_attribute(xml_attribute&lt; Ch &gt; *where, xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_4eea4a7f6cb484ca9944f7eafe6e1843_14eea4a7f6cb484ca9944f7eafe6e1843">remove_first_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_37d87c4d5d89fa0cf05b72ee8d4cba3b_137d87c4d5d89fa0cf05b72ee8d4cba3b">remove_last_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_c75154db2e768c0e5b541fc8cd0775ab_1c75154db2e768c0e5b541fc8cd0775ab">remove_attribute(xml_attribute&lt; Ch &gt; *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_59e6ad4cfd5e8096c052e71d79561eda_159e6ad4cfd5e8096c052e71d79561eda">remove_all_attributes()</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>namespace <a href="#namespacerapidxml">rapidxml</a></dt><dt class="indented">enum <a href="#namespacerapidxml_6a276b85e2da28c5f9c3dbce61c55682_16a276b85e2da28c5f9c3dbce61c55682">node_type</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented">function <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1">parse_error_handler(const char *what, void *where)</a></dt><dt class="indented">function <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1">print(OutIt out, const xml_node&lt; Ch &gt; &amp;node, int flags=0)</a></dt><dt class="indented">function <a href="#namespacerapidxml_13bc37d6d1047acb0efdbc1689221a5e_113bc37d6d1047acb0efdbc1689221a5e">print(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node, int flags=0)</a></dt><dt class="indented">function <a href="#namespacerapidxml_5619b38000d967fb223b2b0a8c17463a_15619b38000d967fb223b2b0a8c17463a">operator&lt;&lt;(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node)</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9">parse_no_data_nodes</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e">parse_no_element_values</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c">parse_no_string_terminators</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_7223b7815c4fb8b42e6e4e77e1ea6b97_17223b7815c4fb8b42e6e4e77e1ea6b97">parse_no_entity_translation</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9">parse_no_utf8</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_52e2c934ad9c845a5f4cc49570470556_152e2c934ad9c845a5f4cc49570470556">parse_declaration_node</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_0f7479dacbc868456d07897a8c072784_10f7479dacbc868456d07897a8c072784">parse_comment_nodes</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_8e187746ba1ca04f107951ad32df962e_18e187746ba1ca04f107951ad32df962e">parse_doctype_node</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_1c20b2b2b75711cd76423e119c49f830_11c20b2b2b75711cd76423e119c49f830">parse_pi_nodes</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_a5daff9d61c7d4eaf98e4d42efe628ee_1a5daff9d61c7d4eaf98e4d42efe628ee">parse_validate_closing_tags</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9">parse_trim_whitespace</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_88f95d4e275ba01408fefde83078651b_188f95d4e275ba01408fefde83078651b">parse_normalize_whitespace</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_45751cf2f38fd6915f35b3122b46d5b6_145751cf2f38fd6915f35b3122b46d5b6">parse_default</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943">parse_non_destructive</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_398c5476e76102f8bd76c10bb0abbe10_1398c5476e76102f8bd76c10bb0abbe10">parse_fastest</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_b4f2515265facb42291570307924bd57_1b4f2515265facb42291570307924bd57">parse_full</a></dt><dt class="indented">
				constant
			 <a href="#namespacerapidxml_b08b8d4293c203b69ed6c5ae77ac1907_1b08b8d4293c203b69ed6c5ae77ac1907">print_no_indenting</a></dt><p/><p/><p/><p/></dl><hr/><h3 class="reference-header" id="classrapidxml_1_1memory__pool">class
									  template
								   rapidxml::memory_pool</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
								  Base class for
								  <a href="#classrapidxml_1_1xml__document">xml_document</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation. In most cases, you will not need to use this class directly. However, if you need to create nodes manually or modify names/values of nodes, you are encouraged to use <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of relevant <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> to allocate the memory. Not only is this faster than allocating them by using <code>new</code> operator, but also their lifetime will be tied to the lifetime of document, possibly simplyfing memory management. <br/><br/>
 Call <a href="#classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41" kindref="member">allocate_node()</a> or <a href="#classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457" kindref="member">allocate_attribute()</a> functions to obtain new nodes or attributes from the pool. You can also call <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">allocate_string()</a> function to allocate strings. Such strings can then be used as names or values of nodes without worrying about their lifetime. Note that there is no <code>free()</code> function -- all allocations are freed at once when <a href="#classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204" kindref="member">clear()</a> function is called, or when the pool is destroyed. <br/><br/>
 It is also possible to create a standalone <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>, and use it to allocate nodes, whose lifetime will not be tied to any document. <br/><br/>
 Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory. Until static memory is exhausted, no dynamic memory allocations are done. When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each, by using global <code>new[]</code> and <code>delete[]</code> operators. This behaviour can be changed by setting custom allocation routines. Use <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a" kindref="member">set_allocator()</a> function to set them. <br/><br/>
 Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes. This value defaults to the size of pointer on target architecture. <br/><br/>
 To obtain absolutely top performance from the parser, it is important that all nodes are allocated from a single, contiguous block of memory. Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably. If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code> to obtain best wasted memory to performance compromise. To do it, define their values before <a href="#rapidxml_8hpp" kindref="compound">rapidxml.hpp</a> file is included. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type of created nodes. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_f8fb3c8f1a564f8045c40bcd07a89866_1f8fb3c8f1a564f8045c40bcd07a89866">
				constructor
			 memory_pool::memory_pool</h3><h4>Synopsis</h4><code class="synopsis">memory_pool();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs empty pool with default allocator functions. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_6f8c7990d9ec1ed2acf6558b238570eb_16f8c7990d9ec1ed2acf6558b238570eb">
				destructor
			 memory_pool::~memory_pool</h3><h4>Synopsis</h4><code class="synopsis">~memory_pool();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Destroys pool and frees all the memory. This causes memory occupied by nodes allocated by the pool to be freed. Nodes allocated from the pool are no longer valid. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41">function memory_pool::allocate_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* allocate_node(node_type type, const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Allocates a new node from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to create. </dd></dl><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name to assign to the node, or 0 to assign no name. </dd></dl><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Value to assign to the node, or 0 to assign no value. </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name to assign, or 0 to automatically calculate size from name string. </dd></dl><dl><dt class="parameter-name">value_size</dt><dd class="parameter-def">Size of value to assign, or 0 to automatically calculate size from value string. </dd></dl><h4>Returns</h4>Pointer to allocated node. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457">function memory_pool::allocate_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Allocates a new attribute from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name to assign to the attribute, or 0 to assign no name. </dd></dl><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Value to assign to the attribute, or 0 to assign no value. </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name to assign, or 0 to automatically calculate size from name string. </dd></dl><dl><dt class="parameter-name">value_size</dt><dd class="parameter-def">Size of value to assign, or 0 to automatically calculate size from value string. </dd></dl><h4>Returns</h4>Pointer to allocated attribute. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859">function memory_pool::allocate_string</h3><h4>Synopsis</h4><code class="synopsis">Ch* allocate_string(const Ch *source=0, std::size_t size=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Allocates a char array of given size from the pool, and optionally copies a given string to it. If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">source</dt><dd class="parameter-def">String to initialize the allocated memory with, or 0 to not initialize it. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated. </dd></dl><h4>Returns</h4>Pointer to allocated char array. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_95c49fcb056e9103ec906a59e3e01d76_195c49fcb056e9103ec906a59e3e01d76">function memory_pool::clone_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* clone_node(const xml_node&lt; Ch &gt; *source, xml_node&lt; Ch &gt; *result=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clones an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and its hierarchy of child nodes and attributes. Nodes and attributes are allocated from this memory pool. Names and values are not cloned, they are shared between the clone and the source. Result node can be optionally specified as a second parameter, in which case its contents will be replaced with cloned source node. This is useful when you want to clone entire document. </para><h4>Parameters</h4><dl><dt class="parameter-name">source</dt><dd class="parameter-def">Node to clone. </dd></dl><dl><dt class="parameter-name">result</dt><dd class="parameter-def">Node to put results in, or 0 to automatically allocate result node </dd></dl><h4>Returns</h4>Pointer to cloned node. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">function memory_pool::clear</h3><h4>Synopsis</h4><code class="synopsis">void clear();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clears the pool. This causes memory occupied by nodes allocated by the pool to be freed. Any nodes or strings allocated from the pool will no longer be valid. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a">function memory_pool::set_allocator</h3><h4>Synopsis</h4><code class="synopsis">void set_allocator(alloc_func *af, free_func *ff);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets or resets the user-defined memory allocation functions for the pool. This can only be called when no memory is allocated from the pool yet, otherwise results are undefined. Allocation function must not return invalid pointer on failure. It should either throw, stop the program, or use <code>longjmp()</code> function to pass control to other place of program. If it returns invalid pointer, results are undefined. <br/><br/>
 User defined allocation functions must have the following forms: <br/><code><br/>
void *allocate(std::size_t size); <br/>
void free(void *pointer); </code><br/></para><h4>Parameters</h4><dl><dt class="parameter-name">af</dt><dd class="parameter-def">Allocation function, or 0 to restore default function </dd></dl><dl><dt class="parameter-name">ff</dt><dd class="parameter-def">Free function, or 0 to restore default function </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error">class rapidxml::parse_error</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse error exception. This exception is thrown by the parser when an error occurs. Use <a href="#classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba" kindref="member">what()</a> function to get human-readable error message. Use <a href="#classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca" kindref="member">where()</a> function to get a pointer to position within source text where error was detected. <br/><br/>
 If throwing exceptions by the parser is undesirable, it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before <a href="#rapidxml_8hpp" kindref="compound">rapidxml.hpp</a> is included. This will cause the parser to call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function instead of throwing an exception. This function must be defined by the user. <br/><br/>
 This class derives from <code>std::exception</code> class. </para><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_4dd8d1bdbd9221df4dcb90cafaee3332_14dd8d1bdbd9221df4dcb90cafaee3332">
				constructor
			 parse_error::parse_error</h3><h4>Synopsis</h4><code class="synopsis">parse_error(const char *what, void *where);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs parse error. </para><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba">function parse_error::what</h3><h4>Synopsis</h4><code class="synopsis">virtual const char* what() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets human readable description of error. </para><h4>Returns</h4>Pointer to null terminated description of the error. <p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca">function parse_error::where</h3><h4>Synopsis</h4><code class="synopsis">Ch* where() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets pointer to character data where error happened. Ch should be the same as char type of <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> that produced the error. </para><h4>Returns</h4>Pointer to location within the parsed string where error occured. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute">class
									  template
								   rapidxml::xml_attribute</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
								  Inherits from
								  <a href="#classrapidxml_1_1xml__base">xml_base</a> <br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Class representing attribute node of XML document. Each attribute has name and value strings, which are available through <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a> and <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a> functions (inherited from <a href="#classrapidxml_1_1xml__base" kindref="compound">xml_base</a>). Note that after parse, both name and value of attribute will point to interior of source text used for parsing. Thus, this text must persist in memory for the lifetime of attribute. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_d5464aadf08269a886b730993525db34_1d5464aadf08269a886b730993525db34">
				constructor
			 xml_attribute::xml_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs an empty attribute with the specified type. Consider using <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of appropriate <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> if allocating attributes manually. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">function xml_attribute::document</h3><h4>Synopsis</h4><code class="synopsis">xml_document&lt;Ch&gt;* document() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets document of which attribute is a child. </para><h4>Returns</h4>Pointer to document that contains this attribute, or 0 if there is no parent document. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_5c4a98d2b75f9b41b12c110108fd55ab_15c4a98d2b75f9b41b12c110108fd55ab">function xml_attribute::previous_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets previous attribute, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_1b8a814d0d3a7165396b08433eee8a91_11b8a814d0d3a7165396b08433eee8a91">function xml_attribute::next_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets next attribute, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base">class
									  template
								   rapidxml::xml_base</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
								  Base class for
								  <a href="#classrapidxml_1_1xml__attribute">xml_attribute</a> <a href="#classrapidxml_1_1xml__node">xml_node</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Base class for <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and <a href="#classrapidxml_1_1xml__attribute" kindref="compound">xml_attribute</a> implementing common functions: <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a>, <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">name_size()</a>, <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a>, <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">value_size()</a> and <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_23630d2c130a9e0e3f3afa7584a9b218_123630d2c130a9e0e3f3afa7584a9b218">
				constructor
			 xml_base::xml_base</h3><h4>Synopsis</h4><code class="synopsis">xml_base();
									  </code><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">Ch* name() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets name of the node. Interpretation of name depends on type of node. Note that name will not be zero-terminated if <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c" kindref="member">rapidxml::parse_no_string_terminators</a> option was selected during parse. <br/><br/>
 Use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">name_size()</a> function to determine length of the name. </para><h4>Returns</h4>Name of node, or empty string if node has no name. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c">function xml_base::name_size</h3><h4>Synopsis</h4><code class="synopsis">std::size_t name_size() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets size of node name, not including terminator character. This function works correctly irrespective of whether name is or is not zero terminated. </para><h4>Returns</h4>Size of node name, in characters. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">Ch* value() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets value of node. Interpretation of value depends on type of node. Note that value will not be zero-terminated if <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c" kindref="member">rapidxml::parse_no_string_terminators</a> option was selected during parse. <br/><br/>
 Use <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">value_size()</a> function to determine length of the value. </para><h4>Returns</h4>Value of node, or empty string if node has no value. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db">function xml_base::value_size</h3><h4>Synopsis</h4><code class="synopsis">std::size_t value_size() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets size of node value, not including terminator character. This function works correctly irrespective of whether value is or is not zero terminated. </para><h4>Returns</h4>Size of node value, in characters. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">void name(const Ch *name, std::size_t size);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets name of node to a non zero-terminated string. See <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a> . <br/><br/>
 Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of the document to allocate the string - on destruction of the document the string will be automatically freed. <br/><br/>
 Size of name must be specified separately, because name does not have to be zero terminated. Use <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e" kindref="member">name(const Ch *)</a> function to have the length automatically calculated (string must be zero terminated). </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of node to set. Does not have to be zero terminated. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">Size of name, in characters. This does not include zero terminator, if one is present. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">void name(const Ch *name);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets name of node to a zero-terminated string. See also <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a>  and <a href="#classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c" kindref="member">xml_node::name(const Ch *, std::size_t)</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of node to set. Must be zero terminated. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">void value(const Ch *value, std::size_t size);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets value of node to a non zero-terminated string. See <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a> . <br/><br/>
 Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of the document to allocate the string - on destruction of the document the string will be automatically freed. <br/><br/>
 Size of value must be specified separately, because it does not have to be zero terminated. Use <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c" kindref="member">value(const Ch *)</a> function to have the length automatically calculated (string must be zero terminated). <br/><br/>
 If an element has a child node of type node_data, it will take precedence over element value when printing. If you want to manipulate data of elements using values, use parser flag <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9" kindref="member">rapidxml::parse_no_data_nodes</a> to prevent creation of data nodes by the parser. </para><h4>Parameters</h4><dl><dt class="parameter-name">value</dt><dd class="parameter-def">value of node to set. Does not have to be zero terminated. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">Size of value, in characters. This does not include zero terminator, if one is present. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">void value(const Ch *value);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets value of node to a zero-terminated string. See also <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a>  and <a href="#classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb" kindref="member">xml_node::value(const Ch *, std::size_t)</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Vame of node to set. Must be zero terminated. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e">function xml_base::parent</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* parent() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets node parent. </para><h4>Returns</h4>Pointer to parent node, or 0 if there is no parent. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__document">class
									  template
								   rapidxml::xml_document</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
								  Inherits from
								  <a href="#classrapidxml_1_1xml__node">xml_node</a> <a href="#classrapidxml_1_1memory__pool">memory_pool</a> <br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">This class represents root of the DOM hierarchy. It is also an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and a <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> through public inheritance. Use <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">parse()</a> function to build a DOM tree from a zero-terminated XML text string. <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">parse()</a> function allocates memory for nodes and attributes by using functions of <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a>, which are inherited from <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>. To access root node of the document, use the document itself, as if it was an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_6ce266cc52d549c42abe3a3d5e8af9ba_16ce266cc52d549c42abe3a3d5e8af9ba">
				constructor
			 xml_document::xml_document</h3><h4>Synopsis</h4><code class="synopsis">xml_document();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs empty XML document. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c">function xml_document::parse</h3><h4>Synopsis</h4><code class="synopsis">void parse(Ch *text);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parses zero-terminated XML string according to given flags. Passed string will be modified by the parser, unless <a href="#namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943" kindref="member">rapidxml::parse_non_destructive</a> flag is used. The string must persist for the lifetime of the document. In case of error, <a href="#classrapidxml_1_1parse__error" kindref="compound">rapidxml::parse_error</a> exception will be thrown. <br/><br/>
 If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning. Make sure that data is zero-terminated. <br/><br/>
 Document can be parsed into multiple times. Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool. </para><h4>Parameters</h4><dl><dt class="parameter-name">text</dt><dd class="parameter-def">XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">function xml_document::clear</h3><h4>Synopsis</h4><code class="synopsis">void clear();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clears the document by deleting all nodes and clearing the memory pool. All nodes owned by document pool are destroyed. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node">class
									  template
								   rapidxml::xml_node</h3>

							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
								  Inherits from
								  <a href="#classrapidxml_1_1xml__base">xml_base</a> <br/>
								  Base class for
								  <a href="#classrapidxml_1_1xml__document">xml_document</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Class representing a node of XML document. Each node may have associated name and value strings, which are available through <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a> and <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a> functions. Interpretation of name and value depends on type of the node. Type of node can be determined by using <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0" kindref="member">type()</a> function. <br/><br/>
 Note that after parse, both name and value of node, if any, will point interior of source text used for parsing. Thus, this text must persist in the memory for the lifetime of node. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_34c55af3504549a475e5b9dfcaa6adf5_134c55af3504549a475e5b9dfcaa6adf5">
				constructor
			 xml_node::xml_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node(node_type type);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs an empty node with the specified type. Consider using <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of appropriate document to allocate nodes manually. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to construct. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0">function xml_node::type</h3><h4>Synopsis</h4><code class="synopsis">node_type type() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets type of node. </para><h4>Returns</h4>Type of node. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">function xml_node::document</h3><h4>Synopsis</h4><code class="synopsis">xml_document&lt;Ch&gt;* document() const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets document of which node is a child. </para><h4>Returns</h4>Pointer to document that contains this node, or 0 if there is no parent document. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a">function xml_node::first_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets first child node, optionally matching node name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of child to find, or 0 to return first child regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found child, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_fcb6e2209b591a36d2dadba20d2bc7cc_1fcb6e2209b591a36d2dadba20d2bc7cc">function xml_node::last_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets last child node, optionally matching node name. Behaviour is undefined if node has no children. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of child to find, or 0 to return last child regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found child, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_ac2f6886c0107e9d5f156e9542546df6_1ac2f6886c0107e9d5f156e9542546df6">function xml_node::previous_sibling</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets previous sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a> to test if node has a parent. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found sibling, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_b3ead2cefecc03a813836203e3f6f38f_1b3ead2cefecc03a813836203e3f6f38f">function xml_node::next_sibling</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets next sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a> to test if node has a parent. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found sibling, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83">function xml_node::first_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets first attribute of node, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_16953d66751b5b949ee4ee2d9c0bc63a_116953d66751b5b949ee4ee2d9c0bc63a">function xml_node::last_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets last attribute of node, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_a78759bfa429fa2ab6bc5fe617cfa3cf_1a78759bfa429fa2ab6bc5fe617cfa3cf">function xml_node::type</h3><h4>Synopsis</h4><code class="synopsis">void type(node_type type);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets type of node. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to set. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_0c39df6617e709eb2fba11300dea63f2_10c39df6617e709eb2fba11300dea63f2">function xml_node::prepend_node</h3><h4>Synopsis</h4><code class="synopsis">void prepend_node(xml_node&lt; Ch &gt; *child);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prepends a new child node. The prepended child becomes the first child, and all existing children are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to prepend. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_86de2e22276826089b7baed2599f8dee_186de2e22276826089b7baed2599f8dee">function xml_node::append_node</h3><h4>Synopsis</h4><code class="synopsis">void append_node(xml_node&lt; Ch &gt; *child);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Appends a new child node. The appended child becomes the last child. </para><h4>Parameters</h4><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to append. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_780972a57fc447250ab47cc8f421b65e_1780972a57fc447250ab47cc8f421b65e">function xml_node::insert_node</h3><h4>Synopsis</h4><code class="synopsis">void insert_node(xml_node&lt; Ch &gt; *where, xml_node&lt; Ch &gt; *child);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Inserts a new child node at specified place inside the node. All children after and including the specified node are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Place where to insert the child, or 0 to insert at the back. </dd></dl><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to insert. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_9a31d861e1bddc710839c551a5d2b3a4_19a31d861e1bddc710839c551a5d2b3a4">function xml_node::remove_first_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_first_node();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes first child node. If node has no children, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_87addf2bc127ee31aa4b5295d3c9b530_187addf2bc127ee31aa4b5295d3c9b530">function xml_node::remove_last_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_last_node();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes last child of the node. If node has no children, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_9316463a2201631e7e2062b17729f9cd_19316463a2201631e7e2062b17729f9cd">function xml_node::remove_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_node(xml_node&lt; Ch &gt; *where);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes specified child from the node. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_0218147d13e41d5fa60ced4e7a7e9726_10218147d13e41d5fa60ced4e7a7e9726">function xml_node::remove_all_nodes</h3><h4>Synopsis</h4><code class="synopsis">void remove_all_nodes();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes all child nodes (but not attributes). </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_f6dffa513da74cc0be71a7ba84f8265e_1f6dffa513da74cc0be71a7ba84f8265e">function xml_node::prepend_attribute</h3><h4>Synopsis</h4><code class="synopsis">void prepend_attribute(xml_attribute&lt; Ch &gt; *attribute);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prepends a new attribute to the node. </para><h4>Parameters</h4><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to prepend. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_8fbd4f5ef7169d493da9f8d87ac04b77_18fbd4f5ef7169d493da9f8d87ac04b77">function xml_node::append_attribute</h3><h4>Synopsis</h4><code class="synopsis">void append_attribute(xml_attribute&lt; Ch &gt; *attribute);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Appends a new attribute to the node. </para><h4>Parameters</h4><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to append. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_070d5888b0557fe06a5b24961de1b988_1070d5888b0557fe06a5b24961de1b988">function xml_node::insert_attribute</h3><h4>Synopsis</h4><code class="synopsis">void insert_attribute(xml_attribute&lt; Ch &gt; *where, xml_attribute&lt; Ch &gt; *attribute);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Inserts a new attribute at specified place inside the node. All attributes after and including the specified attribute are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Place where to insert the attribute, or 0 to insert at the back. </dd></dl><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to insert. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_4eea4a7f6cb484ca9944f7eafe6e1843_14eea4a7f6cb484ca9944f7eafe6e1843">function xml_node::remove_first_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_first_attribute();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes first attribute of the node. If node has no attributes, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83" kindref="member">first_attribute()</a> to test if node has attributes. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_37d87c4d5d89fa0cf05b72ee8d4cba3b_137d87c4d5d89fa0cf05b72ee8d4cba3b">function xml_node::remove_last_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_last_attribute();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes last attribute of the node. If node has no attributes, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83" kindref="member">first_attribute()</a> to test if node has attributes. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_c75154db2e768c0e5b541fc8cd0775ab_1c75154db2e768c0e5b541fc8cd0775ab">function xml_node::remove_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_attribute(xml_attribute&lt; Ch &gt; *where);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes specified attribute from node. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Pointer to attribute to be removed. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_59e6ad4cfd5e8096c052e71d79561eda_159e6ad4cfd5e8096c052e71d79561eda">function xml_node::remove_all_attributes</h3><h4>Synopsis</h4><code class="synopsis">void remove_all_attributes();
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes all attributes of node. </para><p/><h3 class="reference-header" id="namespacerapidxml_6a276b85e2da28c5f9c3dbce61c55682_16a276b85e2da28c5f9c3dbce61c55682">enum node_type</h3><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Enumeration listing all node types produced by the parser. Use <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0" kindref="member">xml_node::type()</a> function to query node type. </para><h4>Values</h4><dl><dt class="parameter-name">node_document</dt><dd class="parameter-def">A document node. Name and value are empty. </dd></dl><dl><dt class="parameter-name">node_element</dt><dd class="parameter-def">An element node. Name contains element name. Value contains text of first data node. </dd></dl><dl><dt class="parameter-name">node_data</dt><dd class="parameter-def">A data node. Name is empty. Value contains data text. </dd></dl><dl><dt class="parameter-name">node_cdata</dt><dd class="parameter-def">A CDATA node. Name is empty. Value contains data text. </dd></dl><dl><dt class="parameter-name">node_comment</dt><dd class="parameter-def">A comment node. Name is empty. Value contains comment text. </dd></dl><dl><dt class="parameter-name">node_declaration</dt><dd class="parameter-def">A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes. </dd></dl><dl><dt class="parameter-name">node_doctype</dt><dd class="parameter-def">A DOCTYPE node. Name is empty. Value contains DOCTYPE text. </dd></dl><dl><dt class="parameter-name">node_pi</dt><dd class="parameter-def">A PI node. Name contains target. Value contains instructions. </dd></dl><p/><h3 class="reference-header" id="namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1">function parse_error_handler</h3><h4>Synopsis</h4><code class="synopsis">void rapidxml::parse_error_handler(const char *what, void *where);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function is called to notify user about the error. It must be defined by the user. <br/><br/>
 This function cannot return. If it does, the results are undefined. <br/><br/>
 A very simple definition might look like that: <preformatted>
        void rapidxml::parse_error_handler(const char *what, void *where)
        {
            std::cout &lt;&lt; &quot;Parse error: &quot; &lt;&lt; what &lt;&lt; &quot;\n&quot;;
            std::abort();
        }
        </preformatted></para><h4>Parameters</h4><dl><dt class="parameter-name">what</dt><dd class="parameter-def">Human readable description of the error. </dd></dl><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Pointer to character data where error was detected. </dd></dl><p/><h3 class="reference-header" id="namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1">function print</h3><h4>Synopsis</h4><code class="synopsis">OutIt rapidxml::print(OutIt out, const xml_node&lt; Ch &gt; &amp;node, int flags=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints XML to given output iterator. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output iterator to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. Pass xml_document to print entire document. </dd></dl><dl><dt class="parameter-name">flags</dt><dd class="parameter-def">Flags controlling how XML is printed. </dd></dl><h4>Returns</h4>Output iterator pointing to position immediately after last character of printed text. <p/><h3 class="reference-header" id="namespacerapidxml_13bc37d6d1047acb0efdbc1689221a5e_113bc37d6d1047acb0efdbc1689221a5e">function print</h3><h4>Synopsis</h4><code class="synopsis">std::basic_ostream&lt;Ch&gt;&amp; rapidxml::print(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node, int flags=0);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints XML to given output stream. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output stream to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. Pass xml_document to print entire document. </dd></dl><dl><dt class="parameter-name">flags</dt><dd class="parameter-def">Flags controlling how XML is printed. </dd></dl><h4>Returns</h4>Output stream. <p/><h3 class="reference-header" id="namespacerapidxml_5619b38000d967fb223b2b0a8c17463a_15619b38000d967fb223b2b0a8c17463a">function operator&lt;&lt;</h3><h4>Synopsis</h4><code class="synopsis">std::basic_ostream&lt;Ch&gt;&amp; rapidxml::operator&lt;&lt;(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node);
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints formatted XML to given output stream. Uses default printing flags. Use <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function to customize printing process. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output stream to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. </dd></dl><h4>Returns</h4>Output stream. <p/><h3 class="reference-header" id="namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9">
				constant
			 parse_no_data_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_data_nodes
											  = 0x1;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not create data nodes. Text of first data node will still be placed in value of parent element, unless <a href="#namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e" kindref="member">rapidxml::parse_no_element_values</a> flag is also specified. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e">
				constant
			 parse_no_element_values</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_element_values
											  = 0x2;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not use text of first data node as a value of parent element. Can be combined with other flags by use of | operator. Note that child data nodes of element node take precendence over its value when printing. That is, if element has one or more child data nodes <i>and</i> a value, the value will be ignored. Use <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9" kindref="member">rapidxml::parse_no_data_nodes</a> flag to prevent creation of data nodes if you want to manipulate data using values of elements. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c">
				constant
			 parse_no_string_terminators</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_string_terminators
											  = 0x4;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not place zero terminators after strings in the source text. By default zero terminators are placed, modifying source text. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_7223b7815c4fb8b42e6e4e77e1ea6b97_17223b7815c4fb8b42e6e4e77e1ea6b97">
				constant
			 parse_no_entity_translation</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_entity_translation
											  = 0x8;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not translate entities in the source text. By default entities are translated, modifying source text. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9">
				constant
			 parse_no_utf8</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_utf8
											  = 0x10;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters. By default, UTF-8 handling is enabled. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_52e2c934ad9c845a5f4cc49570470556_152e2c934ad9c845a5f4cc49570470556">
				constant
			 parse_declaration_node</h3><h4>Synopsis</h4><code class="synopsis">const int parse_declaration_node
											  = 0x20;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create XML declaration node. By default, declaration node is not created. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_0f7479dacbc868456d07897a8c072784_10f7479dacbc868456d07897a8c072784">
				constant
			 parse_comment_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_comment_nodes
											  = 0x40;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create comments nodes. By default, comment nodes are not created. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_8e187746ba1ca04f107951ad32df962e_18e187746ba1ca04f107951ad32df962e">
				constant
			 parse_doctype_node</h3><h4>Synopsis</h4><code class="synopsis">const int parse_doctype_node
											  = 0x80;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create DOCTYPE node. By default, doctype node is not created. Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_1c20b2b2b75711cd76423e119c49f830_11c20b2b2b75711cd76423e119c49f830">
				constant
			 parse_pi_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_pi_nodes
											  = 0x100;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create PI nodes. By default, PI nodes are not created. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_a5daff9d61c7d4eaf98e4d42efe628ee_1a5daff9d61c7d4eaf98e4d42efe628ee">
				constant
			 parse_validate_closing_tags</h3><h4>Synopsis</h4><code class="synopsis">const int parse_validate_closing_tags
											  = 0x200;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to validate closing tag names. If not set, name inside closing tag is irrelevant to the parser. By default, closing tags are not validated. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9">
				constant
			 parse_trim_whitespace</h3><h4>Synopsis</h4><code class="synopsis">const int parse_trim_whitespace
											  = 0x400;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes. By default, whitespace is not trimmed. This flag does not cause the parser to modify source text. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_88f95d4e275ba01408fefde83078651b_188f95d4e275ba01408fefde83078651b">
				constant
			 parse_normalize_whitespace</h3><h4>Synopsis</h4><code class="synopsis">const int parse_normalize_whitespace
											  = 0x800;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character. Trimming of leading and trailing whitespace of data is controlled by <a href="#namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9" kindref="member">rapidxml::parse_trim_whitespace</a> flag. By default, whitespace is not normalized. If this flag is specified, source text will be modified. Can be combined with other flags by use of | operator. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_45751cf2f38fd6915f35b3122b46d5b6_145751cf2f38fd6915f35b3122b46d5b6">
				constant
			 parse_default</h3><h4>Synopsis</h4><code class="synopsis">const int parse_default
											  = 0;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flags which represent default behaviour of the parser. This is always equal to 0, so that all other flags can be simply ored together. Normally there is no need to inconveniently disable flags by anding with their negated (~) values. This also means that meaning of each flag is a <i>negation</i> of the default setting. For example, if flag name is <a href="#namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9" kindref="member">rapidxml::parse_no_utf8</a>, it means that utf-8 is <i>enabled</i> by default, and using the flag will disable it. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943">
				constant
			 parse_non_destructive</h3><h4>Synopsis</h4><code class="synopsis">const int parse_non_destructive
											  = parse_no_string_terminators | parse_no_entity_translation;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags that forbids any modifications of the source text. This also results in faster parsing. However, note that the following will occur: <ul><li><para>names and values of nodes will not be zero terminated, you have to use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">xml_base::name_size()</a> and <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">xml_base::value_size()</a> functions to determine where name and value ends </para></li><li><para>entities will not be translated </para></li><li><para>whitespace will not be normalized </para></li></ul>
See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_398c5476e76102f8bd76c10bb0abbe10_1398c5476e76102f8bd76c10bb0abbe10">
				constant
			 parse_fastest</h3><h4>Synopsis</h4><code class="synopsis">const int parse_fastest
											  = parse_non_destructive | parse_no_data_nodes;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags resulting in fastest possible parsing, without sacrificing important data. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_b4f2515265facb42291570307924bd57_1b4f2515265facb42291570307924bd57">
				constant
			 parse_full</h3><h4>Synopsis</h4><code class="synopsis">const int parse_full
											  = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags resulting in largest amount of data being extracted. This usually results in slowest parsing. <br/><br/>
 See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_b08b8d4293c203b69ed6c5ae77ac1907_1b08b8d4293c203b69ed6c5ae77ac1907">
				constant
			 print_no_indenting</h3><h4>Synopsis</h4><code class="synopsis">const int print_no_indenting
											  = 0x1;
									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Printer flag instructing the printer to suppress indenting of XML. See <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function. </para><p/></body></html>

================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/rapidxml.hpp
================================================
#ifndef CEREAL_RAPIDXML_HPP_INCLUDED
#define CEREAL_RAPIDXML_HPP_INCLUDED

// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $

// If standard library is disabled, user must provide implementations of required functions and typedefs
#if !defined(CEREAL_RAPIDXML_NO_STDLIB)
    #include <cstdlib>      // For std::size_t
    #include <cassert>      // For assert
    #include <new>          // For placement new
#endif

// On MSVC, disable "conditional expression is constant" warning (level 4).
// This warning is almost impossible to avoid with certain types of templated code
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable:4127)   // Conditional expression is constant
    #pragma warning(disable:4100)   // unreferenced formal parameter
#endif

///////////////////////////////////////////////////////////////////////////
// CEREAL_RAPIDXML_PARSE_ERROR

#if defined(CEREAL_RAPIDXML_NO_EXCEPTIONS)

#define CEREAL_RAPIDXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }

namespace cereal {
namespace rapidxml
{
    //! When exceptions are disabled by defining CEREAL_RAPIDXML_NO_EXCEPTIONS,
    //! this function is called to notify user about the error.
    //! It must be defined by the user.
    //! <br><br>
    //! This function cannot return. If it does, the results are undefined.
    //! <br><br>
    //! A very simple definition might look like that:
    //! <pre>
    //! void %rapidxml::%parse_error_handler(const char *what, void *where)
    //! {
    //!     std::cout << "Parse error: " << what << "\n";
    //!     std::abort();
    //! }
    //! </pre>
    //! \param what Human readable description of the error.
    //! \param where Pointer to character data where error was detected.
    void parse_error_handler(const char *what, void *where);
}
} // end namespace cereal

#else

#include <exception>    // For std::exception

#define CEREAL_RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)

namespace cereal {
namespace rapidxml
{

    //! Parse error exception.
    //! This exception is thrown by the parser when an error occurs.
    //! Use what() function to get human-readable error message.
    //! Use where() function to get a pointer to position within source text where error was detected.
    //! <br><br>
    //! If throwing exceptions by the parser is undesirable,
    //! it can be disabled by defining CEREAL_RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
    //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
    //! This function must be defined by the user.
    //! <br><br>
    //! This class derives from <code>std::exception</code> class.
    class parse_error: public std::exception
    {

    public:

        //! Constructs parse error
        parse_error(const char *what_, void *where_)
            : m_what(what_)
            , m_where(where_)
        {
        }

        //! Gets human readable description of error.
        //! \return Pointer to null terminated description of the error.
        virtual const char *what() const CEREAL_NOEXCEPT override
        {
            return m_what;
        }

        //! Gets pointer to character data where error happened.
        //! Ch should be the same as char type of xml_document that produced the error.
        //! \return Pointer to location within the parsed string where error occured.
        template<class Ch>
        Ch *where() const
        {
            return reinterpret_cast<Ch *>(m_where);
        }

    private:

        const char *m_what;
        void *m_where;

    };
}
} // end namespace cereal

#endif

///////////////////////////////////////////////////////////////////////////
// Pool sizes

#ifndef CEREAL_RAPIDXML_STATIC_POOL_SIZE
    // Size of static memory block of memory_pool.
    // Define CEREAL_RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
    // No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
    #define CEREAL_RAPIDXML_STATIC_POOL_SIZE (64 * 1024)
#endif

#ifndef CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE
    // Size of dynamic memory block of memory_pool.
    // Define CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
    // After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.
    #define CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024)
#endif

#ifndef CEREAL_RAPIDXML_ALIGNMENT
    // Memory allocation alignment.
    // Define CEREAL_RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to override the default value, which is the size of pointer.
    // All memory allocations for nodes, attributes and strings will be aligned to this value.
    // This must be a power of 2 and at least 1, otherwise memory_pool will not work.
    #define CEREAL_RAPIDXML_ALIGNMENT sizeof(void *)
#endif

namespace cereal {
namespace rapidxml
{
    // Forward declarations
    template<class Ch> class xml_node;
    template<class Ch> class xml_attribute;
    template<class Ch> class xml_document;

    //! Enumeration listing all node types produced by the parser.
    //! Use xml_node::type() function to query node type.
    enum node_type
    {
        node_document,      //!< A document node. Name and value are empty.
        node_element,       //!< An element node. Name contains element name. Value contains text of first data node.
        node_data,          //!< A data node. Name is empty. Value contains data text.
        node_cdata,         //!< A CDATA node. Name is empty. Value contains data text.
        node_comment,       //!< A comment node. Name is empty. Value contains comment text.
        node_declaration,   //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
        node_doctype,       //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
        node_pi             //!< A PI node. Name contains target. Value contains instructions.
    };

    ///////////////////////////////////////////////////////////////////////
    // Parsing flags

    //! Parse flag instructing the parser to not create data nodes.
    //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_no_data_nodes = 0x1;

    //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
    //! Can be combined with other flags by use of | operator.
    //! Note that child data nodes of element node take precendence over its value when printing.
    //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
    //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_no_element_values = 0x2;

    //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
    //! By default zero terminators are placed, modifying source text.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_no_string_terminators = 0x4;

    //! Parse flag instructing the parser to not translate entities in the source text.
    //! By default entities are translated, modifying source text.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_no_entity_translation = 0x8;

    //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
    //! By default, UTF-8 handling is enabled.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_no_utf8 = 0x10;

    //! Parse flag instructing the parser to create XML declaration node.
    //! By default, declaration node is not created.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_declaration_node = 0x20;

    //! Parse flag instructing the parser to create comments nodes.
    //! By default, comment nodes are not created.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_comment_nodes = 0x40;

    //! Parse flag instructing the parser to create DOCTYPE node.
    //! By default, doctype node is not created.
    //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_doctype_node = 0x80;

    //! Parse flag instructing the parser to create PI nodes.
    //! By default, PI nodes are not created.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_pi_nodes = 0x100;

    //! Parse flag instructing the parser to validate closing tag names.
    //! If not set, name inside closing tag is irrelevant to the parser.
    //! By default, closing tags are not validated.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_validate_closing_tags = 0x200;

    //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
    //! By default, whitespace is not trimmed.
    //! This flag does not cause the parser to modify source text.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_trim_whitespace = 0x400;

    //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
    //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
    //! By default, whitespace is not normalized.
    //! If this flag is specified, source text will be modified.
    //! Can be combined with other flags by use of | operator.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_normalize_whitespace = 0x800;

    // Compound flags

    //! Parse flags which represent default behaviour of the parser.
    //! This is always equal to 0, so that all other flags can be simply ored together.
    //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
    //! This also means that meaning of each flag is a <i>negation</i> of the default setting.
    //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
    //! and using the flag will disable it.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_default = 0;

    //! A combination of parse flags that forbids any modifications of the source text.
    //! This also results in faster parsing. However, note that the following will occur:
    //! <ul>
    //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
    //! <li>entities will not be translated</li>
    //! <li>whitespace will not be normalized</li>
    //! </ul>
    //! See xml_document::parse() function.
    const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;

    //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_fastest = parse_non_destructive | parse_no_data_nodes;

    //! A combination of parse flags resulting in largest amount of data being extracted.
    //! This usually results in slowest parsing.
    //! <br><br>
    //! See xml_document::parse() function.
    const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;

    ///////////////////////////////////////////////////////////////////////
    // Internals

    //! \cond internal
    namespace internal
    {

        // Struct that contains lookup tables for the parser
        // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).
        template<int Dummy>
        struct lookup_tables
        {
            static const unsigned char lookup_whitespace[256];              // Whitespace table
            static const unsigned char lookup_node_name[256];               // Node name table
            static const unsigned char lookup_text[256];                    // Text table
            static const unsigned char lookup_text_pure_no_ws[256];         // Text table
            static const unsigned char lookup_text_pure_with_ws[256];       // Text table
            static const unsigned char lookup_attribute_name[256];          // Attribute name table
            static const unsigned char lookup_attribute_data_1[256];        // Attribute data table with single quote
            static const unsigned char lookup_attribute_data_1_pure[256];   // Attribute data table with single quote
            static const unsigned char lookup_attribute_data_2[256];        // Attribute data table with double quotes
            static const unsigned char lookup_attribute_data_2_pure[256];   // Attribute data table with double quotes
            static const unsigned char lookup_digits[256];                  // Digits
            static const unsigned char lookup_upcase[256];                  // To uppercase conversion table for ASCII characters
        };

        // Find length of the string
        template<class Ch>
        inline std::size_t measure(const Ch *p)
        {
            const Ch *tmp = p;
            while (*tmp)
                ++tmp;
            return static_cast<std::size_t>(tmp - p);
        }

        // Compare strings for equality
        template<class Ch>
        inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)
        {
            if (size1 != size2)
                return false;
            if (case_sensitive)
            {
                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
                    if (*p1 != *p2)
                        return false;
            }
            else
            {
                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
                    if (lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p1)] != lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p2)])
                        return false;
            }
            return true;
        }

        template<class Ch>
        inline bool preserve_space(xml_node<Ch>* node)
        {
            const Ch preserve_value[] = { Ch('p'), Ch('r'), Ch('e'), Ch('s'), Ch('e'), Ch('r'), Ch('v'), Ch('e') };
            const xml_attribute<Ch>* space = node->first_attribute("xml:space");
            return space && internal::compare(space->value(), space->value_size(), preserve_value, sizeof(preserve_value) / sizeof(Ch), true);
        }
    }
    //! \endcond

    ///////////////////////////////////////////////////////////////////////
    // Memory pool

    //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
    //! In most cases, you will not need to use this class directly.
    //! However, if you need to create nodes manually or modify names/values of nodes,
    //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.
    //! Not only is this faster than allocating them by using <code>new</code> operator,
    //! but also their lifetime will be tied to the lifetime of document,
    //! possibly simplyfing memory management.
    //! <br><br>
    //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.
    //! You can also call allocate_string() function to allocate strings.
    //! Such strings can then be used as names or values of nodes without worrying about their lifetime.
    //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,
    //! or when the pool is destroyed.
    //! <br><br>
    //! It is also possible to create a standalone memory_pool, and use it
    //! to allocate nodes, whose lifetime will not be tied to any document.
    //! <br><br>
    //! Pool maintains <code>CEREAL_RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.
    //! Until static memory is exhausted, no dynamic memory allocations are done.
    //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
    //! by using global <code>new[]</code> and <code>delete[]</code> operators.
    //! This behaviour can be changed by setting custom allocation routines.
    //! Use set_allocator() function to set them.
    //! <br><br>
    //! Allocations for nodes, attributes and strings are aligned at <code>CEREAL_RAPIDXML_ALIGNMENT</code> bytes.
    //! This value defaults to the size of pointer on target architecture.
    //! <br><br>
    //! To obtain absolutely top performance from the parser,
    //! it is important that all nodes are allocated from a single, contiguous block of memory.
    //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
    //! If required, you can tweak <code>CEREAL_RAPIDXML_STATIC_POOL_SIZE</code>, <code>CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>CEREAL_RAPIDXML_ALIGNMENT</code>
    //! to obtain best wasted memory to performance compromise.
    //! To do it, define their values before rapidxml.hpp file is included.
    //! \tparam Ch Character type of created nodes.
    template<class Ch = char>
    class memory_pool
    {

    public:

        //! \cond internal
        typedef void *(alloc_func)(std::size_t);       // Type of user-defined function used to allocate memory
        typedef void (free_func)(void *);              // Type of user-defined function used to free memory
        //! \endcond

        //! Constructs empty pool with default allocator functions.
        memory_pool()
            : m_alloc_func(0)
            , m_free_func(0)
        {
            init();
        }

        //! Destroys pool and frees all the memory.
        //! This causes memory occupied by nodes allocated by the pool to be freed.
        //! Nodes allocated from the pool are no longer valid.
        ~memory_pool()
        {
            clear();
        }

        //! Allocates a new node from the pool, and optionally assigns name and value to it.
        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
        //! If exceptions are disabled by defining CEREAL_RAPIDXML_NO_EXCEPTIONS, this function
        //! will call rapidxml::parse_error_handler() function.
        //! \param type Type of node to create.
        //! \param name Name to assign to the node, or 0 to assign no name.
        //! \param value Value to assign to the node, or 0 to assign no value.
        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
        //! \return Pointer to allocated node. This pointer will never be NULL.
        xml_node<Ch> *allocate_node(node_type type,
                                    const Ch *name = 0, const Ch *value = 0,
                                    std::size_t name_size = 0, std::size_t value_size = 0)
        {
            void *memory = allocate_aligned(sizeof(xml_node<Ch>));
            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
            if (name)
            {
                if (name_size > 0)
                    node->name(name, name_size);
                else
                    node->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    node->value(value, value_size);
                else
                    node->value(value);
            }
            return node;
        }

        //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
        //! If exceptions are disabled by defining CEREAL_RAPIDXML_NO_EXCEPTIONS, this function
        //! will call rapidxml::parse_error_handler() function.
        //! \param name Name to assign to the attribute, or 0 to assign no name.
        //! \param value Value to assign to the attribute, or 0 to assign no value.
        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
        //! \return Pointer to allocated attribute. This pointer will never be NULL.
        xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0,
                                              std::size_t name_size = 0, std::size_t value_size = 0)
        {
            void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
            if (name)
            {
                if (name_size > 0)
                    attribute->name(name, name_size);
                else
                    attribute->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    attribute->value(value, value_size);
                else
                    attribute->value(value);
            }
            return attribute;
        }

        //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
        //! If exceptions are disabled by defining CEREAL_RAPIDXML_NO_EXCEPTIONS, this function
        //! will call rapidxml::parse_error_handler() function.
        //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
        //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
        //! \return Pointer to allocated char array. This pointer will never be NULL.
        Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)
        {
            assert(source || size);     // Either source or size (or both) must be specified
            if (size == 0)
                size = internal::measure(source) + 1;
            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
            if (source)
                for (std::size_t i = 0; i < size; ++i)
                    result[i] = source[i];
            return result;
        }

        //! Clones an xml_node and its hierarchy of child nodes and attributes.
        //! Nodes and attributes are allocated from this memory pool.
        //! Names and values are not cloned, they are shared between the clone and the source.
        //! Result node can be optionally specified as a second parameter,
        //! in which case its contents will be replaced with cloned source node.
        //! This is useful when you want to clone entire document.
        //! \param source Node to clone.
        //! \param result Node to put results in, or 0 to automatically allocate result node
        //! \return Pointer to cloned node. This pointer will never be NULL.
        xml_node<Ch> *clone_node(const xml_node<Ch> *source, xml_node<Ch> *result = 0)
        {
            // Prepare result node
            if (result)
            {
                result->remove_all_attributes();
                result->remove_all_nodes();
                result->type(source->type());
            }
            else
                result = allocate_node(source->type());

            // Clone name and value
            result->name(source->name(), source->name_size());
            result->value(source->value(), source->value_size());

            // Clone child nodes and attributes
            for (xml_node<Ch> *child = source->first_node(); child; child = child->next_sibling())
                result->append_node(clone_node(child));
            for (xml_attribute<Ch> *attr = source->first_attribute(); attr; attr = attr->next_attribute())
                result->append_attribute(allocate_attribute(attr->name(), attr->value(), attr->name_size(), attr->value_size()));

            return result;
        }

        //! Clears the pool.
        //! This causes memory occupied by nodes allocated by the pool to be freed.
        //! Any nodes or strings allocated from the pool will no longer be valid.
        void clear()
        {
            while (m_begin != m_static_memory)
            {
                char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;
                if (m_free_func)
                    m_free_func(m_begin);
                else
                    delete[] m_begin;
                m_begin = previous_begin;
            }
            init();
        }

        //! Sets or resets the user-defined memory allocation functions for the pool.
        //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
        //! Allocation function must not return invalid pointer on failure. It should either throw,
        //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.
        //! If it returns invalid pointer, results are undefined.
        //! <br><br>
        //! User defined allocation functions must have the following forms:
        //! <br><code>
        //! <br>void *allocate(std::size_t size);
        //! <br>void free(void *pointer);
        //! </code><br>
        //! \param af Allocation function, or 0 to restore default function
        //! \param ff Free function, or 0 to restore default function
        void set_allocator(alloc_func *af, free_func *ff)
        {
            assert(m_begin == m_static_memory && m_ptr == align(m_begin));    // Verify that no memory is allocated yet
            m_alloc_func = af;
            m_free_func = ff;
        }

    private:

        struct header
        {
            char *previous_begin;
        };

        void init()
        {
            m_begin = m_static_memory;
            m_ptr = align(m_begin);
            m_end = m_static_memory + sizeof(m_static_memory);
        }

        char *align(char *ptr)
        {
            std::size_t alignment = ((CEREAL_RAPIDXML_ALIGNMENT - (std::size_t(ptr) & (CEREAL_RAPIDXML_ALIGNMENT - 1))) & (CEREAL_RAPIDXML_ALIGNMENT - 1));
            return ptr + alignment;
        }

        char *allocate_raw(std::size_t size)
        {
            // Allocate
            void *memory;
            if (m_alloc_func)   // Allocate memory using either user-specified allocation function or global operator new[]
            {
                memory = m_alloc_func(size);
                assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
            }
            else
            {
                memory = new char[size];
#ifdef CEREAL_RAPIDXML_NO_EXCEPTIONS
                if (!memory)            // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
                    CEREAL_RAPIDXML_PARSE_ERROR("out of memory", 0);
#endif
            }
            return static_cast<char *>(memory);
        }

        void *allocate_aligned(std::size_t size)
        {
            // Calculate aligned pointer
            char *result = align(m_ptr);

            // If not enough memory left in current pool, allocate a new pool
            if (result + size > m_end)
            {
                // Calculate required pool size (may be bigger than CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE)
                std::size_t pool_size = CEREAL_RAPIDXML_DYNAMIC_POOL_SIZE;
                if (pool_size < size)
                    pool_size = size;

                // Allocate
                std::size_t alloc_size = sizeof(header) + (2 * CEREAL_RAPIDXML_ALIGNMENT - 2) + pool_size;     // 2 alignments required in worst case: one for header, one for actual allocation
                char *raw_memory = allocate_raw(alloc_size);

                // Setup new pool in allocated memory
                char *pool = align(raw_memory);
                header *new_header = reinterpret_cast<header *>(pool);
                new_header->previous_begin = m_begin;
                m_begin = raw_memory;
                m_ptr = pool + sizeof(header);
                m_end = raw_memory + alloc_size;

                // Calculate aligned pointer again using new pool
                result = align(m_ptr);
            }

            // Update pool and return aligned pointer
            m_ptr = result + size;
            return result;
        }

        char *m_begin;                                      // Start of raw memory making up current pool
        char *m_ptr;                                        // First free byte in current pool
        char *m_end;                                        // One past last available byte in current pool
        char m_static_memory[CEREAL_RAPIDXML_STATIC_POOL_SIZE];    // Static raw memory
        alloc_func *m_alloc_func;                           // Allocator function, or 0 if default is to be used
        free_func *m_free_func;                             // Free function, or 0 if default is to be used
    };

    ///////////////////////////////////////////////////////////////////////////
    // XML base

    //! Base class for xml_node and xml_attribute implementing common functions:
    //! name(), name_size(), value(), value_size() and parent().
    //! \tparam Ch Character type to use
    template<class Ch = char>
    class xml_base
    {

    public:

        ///////////////////////////////////////////////////////////////////////////
        // Construction & destruction

        // Construct a base with empty name, value and parent
        xml_base()
            : m_name(0)
            , m_value(0)
            , m_parent(0)
        {
        }

        ///////////////////////////////////////////////////////////////////////////
        // Node data access

        //! Gets name of the node.
        //! Interpretation of name depends on type of node.
        //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
        //! <br><br>
        //! Use name_size() function to determine length of the name.
        //! \return Name of node, or empty string if node has no name.
        Ch *name() const
        {
            return m_name ? m_name : nullstr();
        }

        //! Gets size of node name, not including terminator character.
        //! This function works correctly irrespective of whether name is or is not zero terminated.
        //! \return Size of node name, in characters.
        std::size_t name_size() const
        {
            return m_name ? m_name_size : 0;
        }

        //! Gets value of node.
        //! Interpretation of value depends on type of node.
        //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
        //! <br><br>
        //! Use value_size() function to determine length of the value.
        //! \return Value of node, or empty string if node has no value.
        Ch *value() const
        {
            return m_value ? m_value : nullstr();
        }

        //! Gets size of node value, not including terminator character.
        //! This function works correctly irrespective of whether value is or is not zero terminated.
        //! \return Size of node value, in characters.
        std::size_t value_size() const
        {
            return m_value ? m_value_size : 0;
        }

        ///////////////////////////////////////////////////////////////////////////
        // Node modification

        //! Sets name of node to a non zero-terminated string.
        //! See \ref ownership_of_strings.
        //! <br><br>
        //! Note that node does not own its name or value, it only stores a pointer to it.
        //! It will not delete or otherwise free the pointer on destruction.
        //! It is reponsibility of the user to properly manage lifetime of the string.
        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
        //! on destruction of the document the string will be automatically freed.
        //! <br><br>
        //! Size of name must be specified separately, because name does not have to be zero terminated.
        //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
        //! \param name_ Name of node to set. Does not have to be zero terminated.
        //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
        void name(const Ch *name_, std::size_t size)
        {
            m_name = const_cast<Ch *>(name_);
            m_name_size = size;
        }

        //! Sets name of node to a zero-terminated string.
        //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
        //! \param name_ Name of node to set. Must be zero terminated.
        void name(const Ch *name_)
        {
            this->name(name_, internal::measure(name_));
        }

        //! Sets value of node to a non zero-terminated string.
        //! See \ref ownership_of_strings.
        //! <br><br>
        //! Note that node does not own its name or value, it only stores a pointer to it.
        //! It will not delete or otherwise free the pointer on destruction.
        //! It is reponsibility of the user to properly manage lifetime of the string.
        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
        //! on destruction of the document the string will be automatically freed.
        //! <br><br>
        //! Size of value must be specified separately, because it does not have to be zero terminated.
        //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
        //! <br><br>
        //! If an element has a child node of type node_data, it will take precedence over element value when printing.
        //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
        //! \param value_ value of node to set. Does not have to be zero terminated.
        //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
        void value(const Ch *value_, std::size_t size)
        {
            m_value = const_cast<Ch *>(value_);
            m_value_size = size;
        }

        //! Sets value of node to a zero-terminated string.
        //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
        //! \param value_ Vame of node to set. Must be zero terminated.
        void value(const Ch *value_)
        {
            this->value(value_, internal::measure(value_));
        }

        ///////////////////////////////////////////////////////////////////////////
        // Related nodes access

        //! Gets node parent.
        //! \return Pointer to parent node, or 0 if there is no parent.
        xml_node<Ch> *parent() const
        {
            return m_parent;
        }

    protected:

        // Return empty string
        static Ch *nullstr()
        {
            static Ch zero = Ch('\0');
            return &zero;
        }

        Ch *m_name;                         // Name of node, or 0 if no name
        Ch *m_value;                        // Value of node, or 0 if no value
        std::size_t m_name_size;            // Length of node name, or undefined of no name
        std::size_t m_value_size;           // Length of node value, or undefined if no value
        xml_node<Ch> *m_parent;             // Pointer to parent node, or 0 if none

    };

    //! Class representing attribute node of XML document.
    //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
    //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
    //! Thus, this text must persist in memory for the lifetime of attribute.
    //! \tparam Ch Character type to use.
    template<class Ch = char>
    class xml_attribute: public xml_base<Ch>
    {

        friend class xml_node<Ch>;

    public:

        ///////////////////////////////////////////////////////////////////////////
        // Construction & destruction

        //! Constructs an empty attribute with the specified type.
        //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
        xml_attribute()
        {
        }

        ///////////////////////////////////////////////////////////////////////////
        // Related nodes access

        //! Gets document of which attribute is a child.
        //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
        xml_document<Ch> *document() const
        {
            if (xml_node<Ch> *node = this->parent())
            {
                while (node->parent())
                    node = node->parent();
                return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
            }
            else
                return 0;
        }

        //! Gets previous attribute, optionally matching attribute name.
        //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found attribute, or 0 if not found.
        xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return this->m_parent ? m_prev_attribute : 0;
        }

        //! Gets next attribute, optionally matching attribute name.
        //! \param name_ Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found attribute, or 0 if not found.
        xml_attribute<Ch> *next_attribute(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
        {
            if (name_)
            {
                if (name_size_ == 0)
                    name_size_ = internal::measure(name_);
                for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name_, name_size_, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return this->m_parent ? m_next_attribute : 0;
        }

    private:

        xml_attribute<Ch> *m_prev_attribute;        // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
        xml_attribute<Ch> *m_next_attribute;        // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero

    };

    ///////////////////////////////////////////////////////////////////////////
    // XML node

    //! Class representing a node of XML document.
    //! Each node may have associated name and value strings, which are available through name() and value() functions.
    //! Interpretation of name and value depends on type of the node.
    //! Type of node can be determined by using type() function.
    //! <br><br>
    //! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing.
    //! Thus, this text must persist in the memory for the lifetime of node.
    //! \tparam Ch Character type to use.
    template<class Ch = char>
    class xml_node: public xml_base<Ch>
    {

    public:

        ///////////////////////////////////////////////////////////////////////////
        // Construction & destruction

        //! Constructs an empty node with the specified type.
        //! Consider using memory_pool of appropriate document to allocate nodes manually.
        //! \param type_ Type of node to construct.
        xml_node(node_type type_)
            : m_type(type_)
            , m_first_node(0)
            , m_first_attribute(0)
        {
        }

        ///////////////////////////////////////////////////////////////////////////
        // Node data access

        //! Gets type of node.
        //! \return Type of node.
        node_type type() const
        {
            return m_type;
        }

        ///////////////////////////////////////////////////////////////////////////
        // Related nodes access

        //! Gets document of which node is a child.
        //! \return Pointer to document that contains this node, or 0 if there is no parent document.
        xml_document<Ch> *document() const
        {
            xml_node<Ch> *node = const_cast<xml_node<Ch> *>(this);
            while (node->parent())
                node = node->parent();
            return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
        }

        //! Gets first child node, optionally matching node name.
        //! \param name_ Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found child, or 0 if not found.
        xml_node<Ch> *first_node(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
        {
            if (name_)
            {
                if (name_size_ == 0)
                    name_size_ = internal::measure(name_);
                for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
                    if (internal::compare(child->name(), child->name_size(), name_, name_size_, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_first_node;
        }

        //! Gets last child node, optionally matching node name.
        //! Behaviour is undefined if node has no children.
        //! Use first_node() to test if node has children.
        //! \param name Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found child, or 0 if not found.
        xml_node<Ch> *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            assert(m_first_node);  // Cannot query for last child if node has no children
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_last_node;
        }

        //! Gets previous sibling node, optionally matching node name.
        //! Behaviour is undefined if node has no parent.
        //! Use parent() to test if node has a parent.
        //! \param name Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found sibling, or 0 if not found.
        xml_node<Ch> *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_prev_sibling;
        }

        //! Gets next sibling node, optionally matching node name.
        //! Behaviour is undefined if node has no parent.
        //! Use parent() to test if node has a parent.
        //! \param name_ Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found sibling, or 0 if not found.
        xml_node<Ch> *next_sibling(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name_)
            {
                if (name_size_ == 0)
                    name_size_ = internal::measure(name_);
                for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name_, name_size_, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_next_sibling;
        }

        //! Gets first attribute of node, optionally matching attribute name.
        //! \param name_ Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size_ Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found attribute, or 0 if not found.
        xml_attribute<Ch> *first_attribute(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const
        {
            if (name_)
            {
                if (name_size_ == 0)
                    name_size_ = internal::measure(name_);
                for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name_, name_size_, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return m_first_attribute;
        }

        //! Gets last attribute of node, optionally matching attribute name.
        //! \param name Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
        //! \return Pointer to found attribute, or 0 if not found.
        xml_attribute<Ch> *last_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return m_first_attribute ? m_last_attribute : 0;
        }

        ///////////////////////////////////////////////////////////////////////////
        // Node modification

        //! Sets type of node.
        //! \param type_ Type of node to set.
        void type(node_type type_)
        {
            m_type = type_;
        }

        ///////////////////////////////////////////////////////////////////////////
        // Node manipulation

        //! Prepends a new child node.
        //! The prepended child becomes the first child, and all existing children are moved one position back.
        //! \param child Node to prepend.
        void prepend_node(xml_node<Ch> *child)
        {
            assert(child && !child->parent() && child->type() != node_document);
            if (first_node())
            {
                child->m_next_sibling = m_first_node;
                m_first_node->m_prev_sibling = child;
            }
            else
            {
                child->m_next_sibling = 0;
                m_last_node = child;
            }
            m_first_node = child;
            child->m_parent = this;
            child->m_prev_sibling = 0;
        }

        //! Appends a new child node.
        //! The appended child becomes the last child.
        //! \param child Node to append.
        void append_node(xml_node<Ch> *child)
        {
            assert(child && !child->parent() && child->type() != node_document);
            if (first_node())
            {
                child->m_prev_sibling = m_last_node;
                m_last_node->m_next_sibling = child;
            }
            else
            {
                child->m_prev_sibling = 0;
                m_first_node = child;
            }
            m_last_node = child;
            child->m_parent = this;
            child->m_next_sibling = 0;
        }

        //! Inserts a new child node at specified place inside the node.
        //! All children after and including the specified node are moved one position back.
        //! \param where Place where to insert the child, or 0 to insert at the back.
        //! \param child Node to insert.
        void insert_node(xml_node<Ch> *where, xml_node<Ch> *child)
        {
            assert(!where || where->parent() == this);
            assert(child && !child->parent() && child->type() != node_document);
            if (where == m_first_node)
                prepend_node(child);
            else if (where == 0)
                append_node(child);
            else
            {
                child->m_prev_sibling = where->m_prev_sibling;
                child->m_next_sibling = where;
                where->m_prev_sibling->m_next_sibling = child;
                where->m_prev_sibling = child;
                child->m_parent = this;
            }
        }

        //! Removes first child node.
        //! If node has no children, behaviour is undefined.
        //! Use first_node() to test if node has children.
        void remove_first_node()
        {
            assert(first_node());
            xml_node<Ch> *child = m_first_node;
            m_first_node = child->m_next_sibling;
            if (child->m_next_sibling)
                child->m_next_sibling->m_prev_sibling = 0;
            else
                m_last_node = 0;
            child->m_parent = 0;
        }

        //! Removes last child of the node.
        //! If node has no children, behaviour is undefined.
        //! Use first_node() to test if node has children.
        void remove_last_node()
        {
            assert(first_node());
            xml_node<Ch> *child = m_last_node;
            if (child->m_prev_sibling)
            {
                m_last_node = child->m_prev_sibling;
                child->m_prev_sibling->m_next_sibling = 0;
            }
            else
                m_first_node = 0;
            child->m_parent = 0;
        }

        //! Removes specified child from the node
        // \param where Pointer to child to be removed.
        void remove_node(xml_node<Ch> *where)
        {
            assert(where && where->parent() == this);
            assert(first_node());
            if (where == m_first_node)
                remove_first_node();
            else if (where == m_last_node)
                remove_last_node();
            else
            {
                where->m_prev_sibling->m_next_sibling = where->m_next_sibling;
                where->m_next_sibling->m_prev_sibling = where->m_prev_sibling;
                where->m_parent = 0;
            }
        }

        //! Removes all child nodes (but not attributes).
        void remove_all_nodes()
        {
            for (xml_node<Ch> *node = first_node(); node; node = node->m_next_sibling)
                node->m_parent = 0;
            m_first_node = 0;
        }

        //! Prepends a new attribute to the node.
        //! \param attribute Attribute to prepend.
        void prepend_attribute(xml_attribute<Ch> *attribute)
        {
            assert(attribute && !attribute->parent());
            if (first_attribute())
            {
                attribute->m_next_attribute = m_first_attribute;
                m_first_attribute->m_prev_attribute = attribute;
            }
            else
            {
                attribute->m_next_attribute = 0;
                m_last_attribute = attribute;
            }
            m_first_attribute = attribute;
            attribute->m_parent = this;
            attribute->m_prev_attribute = 0;
        }

        //! Appends a new attribute to the node.
        //! \param attribute Attribute to append.
        void append_attribute(xml_attribute<Ch> *attribute)
        {
            assert(attribute && !attribute->parent());
            if (first_attribute())
            {
                attribute->m_prev_attribute = m_last_attribute;
                m_last_attribute->m_next_attribute = attribute;
            }
            else
            {
                attribute->m_prev_attribute = 0;
                m_first_attribute = attribute;
            }
            m_last_attribute = attribute;
            attribute->m_parent = this;
            attribute->m_next_attribute = 0;
        }

        //! Inserts a new attribute at specified place inside the node.
        //! All attributes after and including the specified attribute are moved one position back.
        //! \param where Place where to insert the attribute, or 0 to insert at the back.
        //! \param attribute Attribute to insert.
        void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> *attribute)
        {
            assert(!where || where->parent() == this);
            assert(attribute && !attribute->parent());
            if (where == m_first_attribute)
                prepend_attribute(attribute);
            else if (where == 0)
                append_attribute(attribute);
            else
            {
                attribute->m_prev_attribute = where->m_prev_attribute;
                attribute->m_next_attribute = where;
                where->m_prev_attribute->m_next_attribute = attribute;
                where->m_prev_attribute = attribute;
                attribute->m_parent = this;
            }
        }

        //! Removes first attribute of the node.
        //! If node has no attributes, behaviour is undefined.
        //! Use first_attribute() to test if node has attributes.
        void remove_first_attribute()
        {
            assert(first_attribute());
            xml_attribute<Ch> *attribute = m_first_attribute;
            if (attribute->m_next_attribute)
            {
                attribute->m_next_attribute->m_prev_attribute = 0;
            }
            else
                m_last_attribute = 0;
            attribute->m_parent = 0;
            m_first_attribute = attribute->m_next_attribute;
        }

        //! Removes last attribute of the node.
        //! If node has no attributes, behaviour is undefined.
        //! Use first_attribute() to test if node has attributes.
        void remove_last_attribute()
        {
            assert(first_attribute());
            xml_attribute<Ch> *attribute = m_last_attribute;
            if (attribute->m_prev_attribute)
            {
                attribute->m_prev_attribute->m_next_attribute = 0;
                m_last_attribute = attribute->m_prev_attribute;
            }
            else
                m_first_attribute = 0;
            attribute->m_parent = 0;
        }

        //! Removes specified attribute from node.
        //! \param where Pointer to attribute to be removed.
        void remove_attribute(xml_attribute<Ch> *where)
        {
            assert(first_attribute() && where->parent() == this);
            if (where == m_first_attribute)
                remove_first_attribute();
            else if (where == m_last_attribute)
                remove_last_attribute();
            else
            {
                where->m_prev_attribute->m_next_attribute = where->m_next_attribute;
                where->m_next_attribute->m_prev_attribute = where->m_prev_attribute;
                where->m_parent = 0;
            }
        }

        //! Removes all attributes of node.
        void remove_all_attributes()
        {
            for (xml_attribute<Ch> *attribute = first_attribute(); attribute; attribute = attribute->m_next_attribute)
                attribute->m_parent = 0;
            m_first_attribute = 0;
        }

    private:

        ///////////////////////////////////////////////////////////////////////////
        // Restrictions

        // No copying
        xml_node(const xml_node &);
        void operator =(const xml_node &);

        ///////////////////////////////////////////////////////////////////////////
        // Data members

        // Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
        // This is required for maximum performance, as it allows the parser to omit initialization of
        // unneded/redundant values.
        //
        // The rules are as follows:
        // 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
        // 2. last_node and last_attribute are valid only if node has at least one child/attribute respectively, otherwise they contain garbage
        // 3. prev_sibling and next_sibling are valid only if node has a parent, otherwise they contain garbage

        node_type m_type;                       // Type of node; always valid
        xml_node<Ch> *m_first_node;             // Pointer to first child node, or 0 if none; always valid
        xml_node<Ch> *m_last_node;              // Pointer to last child node, or 0 if none; this value is only valid if m_first_node is non-zero
        xml_attribute<Ch> *m_first_attribute;   // Pointer to first attribute of node, or 0 if none; always valid
        xml_attribute<Ch> *m_last_attribute;    // Pointer to last attribute of node, or 0 if none; this value is only valid if m_first_attribute is non-zero
        xml_node<Ch> *m_prev_sibling;           // Pointer to previous sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
        xml_node<Ch> *m_next_sibling;           // Pointer to next sibling of node, or 0 if none; this value is only valid if m_parent is non-zero

    };

    ///////////////////////////////////////////////////////////////////////////
    // XML document

    //! This class represents root of the DOM hierarchy.
    //! It is also an xml_node and a memory_pool through public inheritance.
    //! Use parse() function to build a DOM tree from a zero-terminated XML text string.
    //! parse() function allocates memory for nodes and attributes by using functions of xml_document,
    //! which are inherited from memory_pool.
    //! To access root node of the document, use the document itself, as if it was an xml_node.
    //! \tparam Ch Character type to use.
    template<class Ch = char>
    class xml_document: public xml_node<Ch>, public memory_pool<Ch>
    {

    public:

        //! Constructs empty XML document
        xml_document()
            : xml_node<Ch>(node_document)
        {
        }

        //! Parses zero-terminated XML string according to given flags.
        //! Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used.
        //! The string must persist for the lifetime of the document.
        //! In case of error, rapidxml::parse_error exception will be thrown.
        //! <br><br>
        //! If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning.
        //! Make sure that data is zero-terminated.
        //! <br><br>
        //! Document can be parsed into multiple times.
        //! Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.
        //! \param text XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.
        template<int Flags>
        void parse(Ch *text)
        {
            assert(text);

            // Remove current contents
            this->remove_all_nodes();
            this->remove_all_attributes();

            // Parse BOM, if any
            parse_bom<Flags>(text);

            // Parse children
            while (1)
            {
                // Skip whitespace before node
                skip<whitespace_pred, Flags>(text);
                if (*text == 0)
                    break;

                // Parse and append new child
                if (*text == Ch('<'))
                {
                    ++text;     // Skip '<'
                    if (xml_node<Ch> *node = parse_node<Flags>(text))
                        this->append_node(node);
                }
                else
                    CEREAL_RAPIDXML_PARSE_ERROR("expected <", text);
            }

        }

        //! Clears the document by deleting all nodes and clearing the memory pool.
        //! All nodes owned by document pool are destroyed.
        void clear()
        {
            this->remove_all_nodes();
            this->remove_all_attributes();
            memory_pool<Ch>::clear();
        }

    private:

        ///////////////////////////////////////////////////////////////////////
        // Internal character utility functions

        // Detect whitespace character
        struct whitespace_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_whitespace[static_cast<unsigned char>(ch)];
            }
        };

        // Detect node name character
        struct node_name_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_node_name[static_cast<unsigned char>(ch)];
            }
        };

        // Detect attribute name character
        struct attribute_name_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_attribute_name[static_cast<unsigned char>(ch)];
            }
        };

        // Detect text character (PCDATA)
        struct text_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_text[static_cast<unsigned char>(ch)];
            }
        };

        // Detect text character (PCDATA) that does not require processing
        struct text_pure_no_ws_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_text_pure_no_ws[static_cast<unsigned char>(ch)];
            }
        };

        // Detect text character (PCDATA) that does not require processing
        struct text_pure_with_ws_pred
        {
            static unsigned char test(Ch ch)
            {
                return internal::lookup_tables<0>::lookup_text_pure_with_ws[static_cast<unsigned char>(ch)];
            }
        };

        // Detect attribute value character
        template<Ch Quote>
        struct attribute_value_pred
        {
            static unsigned char test(Ch ch)
            {
                if (Quote == Ch('\''))
                    return internal::lookup_tables<0>::lookup_attribute_data_1[static_cast<unsigned char>(ch)];
                if (Quote == Ch('\"'))
                    return internal::lookup_tables<0>::lookup_attribute_data_2[static_cast<unsigned char>(ch)];
                return 0;       // Should never be executed, to avoid warnings on Comeau
            }
        };

        // Detect attribute value character
        template<Ch Quote>
        struct attribute_value_pure_pred
        {
            static unsigned char test(Ch ch)
            {
                if (Quote == Ch('\''))
                    return internal::lookup_tables<0>::lookup_attribute_data_1_pure[static_cast<unsigned char>(ch)];
                if (Quote == Ch('\"'))
                    return internal::lookup_tables<0>::lookup_attribute_data_2_pure[static_cast<unsigned char>(ch)];
                return 0;       // Should never be executed, to avoid warnings on Comeau
            }
        };

        // Insert coded character, using UTF8 or 8-bit ASCII
        template<int Flags>
        static void insert_coded_character(Ch *&text, unsigned long code)
        {
            if (Flags & parse_no_utf8)
            {
                // Insert 8-bit ASCII character
                // Todo: possibly verify that code is less than 256 and use replacement char otherwise?
                text[0] = static_cast<Ch>(code);
                text += 1;
            }
            else
            {
                // Insert UTF8 sequence
                if (code < 0x80)    // 1 byte sequence
                {
	                text[0] = static_cast<Ch>(code);
                    text += 1;
                }
                else if (code < 0x800)  // 2 byte sequence
                {
	                text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[0] = static_cast<Ch>(code | 0xC0);
                    text += 2;
                }
	            else if (code < 0x10000)    // 3 byte sequence
                {
	                text[2] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[0] = static_cast<Ch>(code | 0xE0);
                    text += 3;
                }
	            else if (code < 0x110000)   // 4 byte sequence
                {
	                text[3] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[2] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[1] = static_cast<Ch>((code | 0x80) & 0xBF); code >>= 6;
	                text[0] = static_cast<Ch>(code | 0xF0);
                    text += 4;
                }
                else    // Invalid, only codes up to 0x10FFFF are allowed in Unicode
                {
                    CEREAL_RAPIDXML_PARSE_ERROR("invalid numeric character entity", text);
                }
            }
        }

        // Skip characters until predicate evaluates to true
        template<class StopPred, int Flags>
        static void skip(Ch *&text)
        {
            Ch *tmp = text;
            while (StopPred::test(*tmp))
                ++tmp;
            text = tmp;
        }

        // Skip characters until predicate evaluates to true while doing the following:
        // - replacing XML character entity references with proper characters (&apos; &amp; &quot; &lt; &gt; &#...;)
        // - condensing whitespace sequences to single space character
        template<class StopPred, class StopPredPure, int Flags>
        static Ch *skip_and_expand_character_refs(Ch *&text, bool preserve_space)
        {
            // If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
            if (Flags & parse_no_entity_translation &&
                !(Flags & parse_normalize_whitespace) &&
                !(Flags & parse_trim_whitespace))
            {
                skip<StopPred, Flags>(text);
                return text;
            }

            // Use simple skip until first modification is detected
            skip<StopPredPure, Flags>(text);

            // Use translation skip
            Ch *src = text;
            Ch *dest = src;
            while (StopPred::test(*src))
            {
                // If entity translation is enabled
                if (!(Flags & parse_no_entity_translation))
                {
                    // Test if replacement is needed
                    if (src[0] == Ch('&'))
                    {
                        switch (src[1])
                        {

                        // &amp; &apos;
                        case Ch('a'):
                            if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';'))
                            {
                                *dest = Ch('&');
                                ++dest;
                                src += 5;
                                continue;
                            }
                            if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';'))
                            {
                                *dest = Ch('\'');
                                ++dest;
                                src += 6;
                                continue;
                            }
                            break;

                        // &quot;
                        case Ch('q'):
                            if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';'))
                            {
                                *dest = Ch('"');
                                ++dest;
                                src += 6;
                                continue;
                            }
                            break;

                        // &gt;
                        case Ch('g'):
                            if (src[2] == Ch('t') && src[3] == Ch(';'))
                            {
                                *dest = Ch('>');
                                ++dest;
                                src += 4;
                                continue;
                            }
                            break;

                        // &lt;
                        case Ch('l'):
                            if (src[2] == Ch('t') && src[3] == Ch(';'))
                            {
                                *dest = Ch('<');
                                ++dest;
                                src += 4;
                                continue;
                            }
                            break;

                        // &#...; - assumes ASCII
                        case Ch('#'):
                            if (src[2] == Ch('x'))
                            {
                                unsigned long code = 0;
                                src += 3;   // Skip &#x
                                while (1)
                                {
                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                    if (digit == 0xFF)
                                        break;
                                    code = code * 16 + digit;
                                    ++src;
                                }
                                insert_coded_character<Flags>(dest, code);    // Put character in output
                            }
                            else
                            {
                                unsigned long code = 0;
                                src += 2;   // Skip &#
                                while (1)
                                {
                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                    if (digit == 0xFF)
                                        break;
                                    code = code * 10 + digit;
                                    ++src;
                                }
                                insert_coded_character<Flags>(dest, code);    // Put character in output
                            }
                            if (*src == Ch(';'))
                                ++src;
                            else
                                CEREAL_RAPIDXML_PARSE_ERROR("expected ;", src);
                            continue;

                        // Something else
                        default:
                            // Ignore, just copy '&' verbatim
                            break;

                        }
                    }
                }

                // If whitespace condensing is enabled
                if ((Flags & parse_normalize_whitespace) && !preserve_space)
                {
                    // Test if condensing is needed
                    if (whitespace_pred::test(*src))
                    {
                        *dest = Ch(' '); ++dest;    // Put single space in dest
                        ++src;                      // Skip first whitespace char
                        // Skip remaining whitespace chars
                        while (whitespace_pred::test(*src))
                            ++src;
                        continue;
                    }
                }

                // No replacement, only copy character
                *dest++ = *src++;

            }

            // Return new end
            text = src;
            return dest;

        }

        ///////////////////////////////////////////////////////////////////////
        // Internal parsing functions

        // Parse BOM, if any
        template<int Flags>
        void parse_bom(Ch *&text)
        {
            // UTF-8?
            if (static_cast<unsigned char>(text[0]) == 0xEF &&
                static_cast<unsigned char>(text[1]) == 0xBB &&
                static_cast<unsigned char>(text[2]) == 0xBF)
            {
                text += 3;      // Skup utf-8 bom
            }
        }

        // Parse XML declaration (<?xml...)
        template<int Flags>
        xml_node<Ch> *parse_xml_declaration(Ch *&text)
        {
            // If parsing of declaration is disabled
            if (!(Flags & parse_declaration_node))
            {
                // Skip until end of declaration
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (!text[0])
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 2;    // Skip '?>'
                return 0;
            }

            // Create declaration
            xml_node<Ch> *declaration = this->allocate_node(node_declaration);

            // Skip whitespace before attributes or ?>
            skip<whitespace_pred, Flags>(text);

            // Parse declaration attributes
            parse_node_attributes<Flags>(text, declaration);

            // Skip ?>
            if (text[0] != Ch('?') || text[1] != Ch('>'))
                CEREAL_RAPIDXML_PARSE_ERROR("expected ?>", text);
            text += 2;

            return declaration;
        }

        // Parse XML comment (<!--...)
        template<int Flags>
        xml_node<Ch> *parse_comment(Ch *&text)
        {
            // If parsing of comments is disabled
            if (!(Flags & parse_comment_nodes))
            {
                // Skip until end of comment
                while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;     // Skip '-->'
                return 0;      // Do not produce comment node
            }

            // Remember value start
            Ch *value_ = text;

            // Skip until end of comment
            while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
            {
                if (!text[0])
                    CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create comment node
            xml_node<Ch> *comment = this->allocate_node(node_comment);
            comment->value(value_, static_cast<std::size_t>(text - value_));

            // Place zero terminator after comment value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');

            text += 3;     // Skip '-->'
            return comment;
        }

        // Parse DOCTYPE
        template<int Flags>
        xml_node<Ch> *parse_doctype(Ch *&text)
        {
            // Remember value start
            Ch *value_ = text;

            // Skip to >
            while (*text != Ch('>'))
            {
                // Determine character type
                switch (*text)
                {

                // If '[' encountered, scan for matching ending ']' using naive algorithm with depth
                // This works for all W3C test files except for 2 most wicked
                case Ch('['):
                {
                    ++text;     // Skip '['
                    int depth = 1;
                    while (depth > 0)
                    {
                        switch (*text)
                        {
                            case Ch('['): ++depth; break;
                            case Ch(']'): --depth; break;
                            case 0: CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                        }
                        ++text;
                    }
                    break;
                }

                // Error on end of text
                case Ch('\0'):
                    CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);

                // Other character, skip it
                default:
                    ++text;

                }
            }

            // If DOCTYPE nodes enabled
            if (Flags & parse_doctype_node)
            {
                // Create a new doctype node
                xml_node<Ch> *doctype = this->allocate_node(node_doctype);
                doctype->value(value_, static_cast<std::size_t>(text - value_));

                // Place zero terminator after value
                if (!(Flags & parse_no_string_terminators))
                    *text = Ch('\0');

                text += 1;      // skip '>'
                return doctype;
            }
            else
            {
                text += 1;      // skip '>'
                return 0;
            }

        }

        // Parse PI
        template<int Flags>
        xml_node<Ch> *parse_pi(Ch *&text)
        {
            // If creation of PI nodes is enabled
            if (Flags & parse_pi_nodes)
            {
                // Create pi node
                xml_node<Ch> *pi = this->allocate_node(node_pi);

                // Extract PI target name
                Ch *name_ = text;
                skip<node_name_pred, Flags>(text);
                if (text == name_)
                    CEREAL_RAPIDXML_PARSE_ERROR("expected PI target", text);
                pi->name(name_, static_cast<std::size_t>(text - name_));

                // Skip whitespace between pi target and pi
                skip<whitespace_pred, Flags>(text);

                // Remember start of pi
                Ch *value_ = text;

                // Skip to '?>'
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (*text == Ch('\0'))
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }

                // Set pi value (verbatim, no entity expansion or whitespace normalization)
                pi->value(value_, static_cast<std::size_t>(text - value_));

                // Place zero terminator after name and value
                if (!(Flags & parse_no_string_terminators))
                {
                    pi->name()[pi->name_size()] = Ch('\0');
                    pi->value()[pi->value_size()] = Ch('\0');
                }

                text += 2;                          // Skip '?>'
                return pi;
            }
            else
            {
                // Skip to '?>'
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (*text == Ch('\0'))
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 2;    // Skip '?>'
                return 0;
            }
        }

        // Parse and append data
        // Return character that ends data.
        // This is necessary because this character might have been overwritten by a terminating 0
        template<int Flags>
        Ch parse_and_append_data(xml_node<Ch> *node, Ch *&text, Ch *contents_start)
        {
            // Backup to contents start if whitespace trimming is disabled
            if (!(Flags & parse_trim_whitespace))
                text = contents_start;

            const bool preserve_space =  internal::preserve_space(node);

            // Skip until end of data
            Ch *value_ = text, *end;
            if ((Flags & parse_normalize_whitespace) && !preserve_space)
                end = skip_and_expand_character_refs<text_pred, text_pure_with_ws_pred, Flags>(text, false);
            else
                end = skip_and_expand_character_refs<text_pred, text_pure_no_ws_pred, Flags>(text, preserve_space);

            // Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
            if ((Flags & parse_trim_whitespace) && !preserve_space)
            {
                if (Flags & parse_normalize_whitespace)
                {
                    // Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
                    if (*(end - 1) == Ch(' '))
                        --end;
                }
                else
                {
                    // Backup until non-whitespace character is found
                    while (whitespace_pred::test(*(end - 1)))
                        --end;
                }
            }

            // If characters are still left between end and value (this test is only necessary if normalization is enabled)
            // Create new data node
            if (!(Flags & parse_no_data_nodes))
            {
                xml_node<Ch> *data = this->allocate_node(node_data);
                data->value(value_, static_cast<std::size_t>(end - value_));
                node->append_node(data);
            }

            // Add data to parent node if no data exists yet
            if (!(Flags & parse_no_element_values))
                if (*node->value() == Ch('\0'))
                    node->value(value_, static_cast<std::size_t>(end - value_));

            // Place zero terminator after value
            if (!(Flags & parse_no_string_terminators))
            {
                Ch ch = *text;
                *end = Ch('\0');
                return ch;      // Return character that ends data; this is required because zero terminator overwritten it
            }

            // Return character that ends data
            return *text;
        }

        // Parse CDATA
        template<int Flags>
        xml_node<Ch> *parse_cdata(Ch *&text)
        {
            // If CDATA is disabled
            if (Flags & parse_no_data_nodes)
            {
                // Skip until end of cdata
                while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;      // Skip ]]>
                return 0;       // Do not produce CDATA node
            }

            // Skip until end of cdata
            Ch *value_ = text;
            while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
            {
                if (!text[0])
                    CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create new cdata node
            xml_node<Ch> *cdata = this->allocate_node(node_cdata);
            cdata->value(value_, static_cast<std::size_t>(text - value_));

            // Place zero terminator after value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');

            text += 3;      // Skip ]]>
            return cdata;
        }

        // Parse element node
        template<int Flags>
        xml_node<Ch> *parse_element(Ch *&text)
        {
            // Create element node
            xml_node<Ch> *element = this->allocate_node(node_element);

            // Extract element name
            Ch *name_ = text;
            skip<node_name_pred, Flags>(text);
            if (text == name_)
                CEREAL_RAPIDXML_PARSE_ERROR("expected element name", text);
            element->name(name_, static_cast<std::size_t>(text - name_));

            // Skip whitespace between element name and attributes or >
            skip<whitespace_pred, Flags>(text);

            // Parse attributes, if any
            parse_node_attributes<Flags>(text, element);

            // Determine ending type
            if (*text == Ch('>'))
            {
                ++text;
                parse_node_contents<Flags>(text, element);
            }
            else if (*text == Ch('/'))
            {
                ++text;
                if (*text != Ch('>'))
                    CEREAL_RAPIDXML_PARSE_ERROR("expected >", text);
                ++text;
            }
            else
                CEREAL_RAPIDXML_PARSE_ERROR("expected >", text);

            // Place zero terminator after name
            if (!(Flags & parse_no_string_terminators))
                element->name()[element->name_size()] = Ch('\0');

            // Return parsed element
            return element;
        }

        // Determine node type, and parse it
        template<int Flags>
        xml_node<Ch> *parse_node(Ch *&text)
        {
            // Parse proper node type
            switch (text[0])
            {

            // <...
            default:
                // Parse and append element node
                return parse_element<Flags>(text);

            // <?...
            case Ch('?'):
                ++text;     // Skip ?
                if ((text[0] == Ch('x') || text[0] == Ch('X')) &&
                    (text[1] == Ch('m') || text[1] == Ch('M')) &&
                    (text[2] == Ch('l') || text[2] == Ch('L')) &&
                    whitespace_pred::test(text[3]))
                {
                    // '<?xml ' - xml declaration
                    text += 4;      // Skip 'xml '
                    return parse_xml_declaration<Flags>(text);
                }
                else
                {
                    // Parse PI
                    return parse_pi<Flags>(text);
                }

            // <!...
            case Ch('!'):

                // Parse proper subset of <! node
                switch (text[1])
                {

                // <!-
                case Ch('-'):
                    if (text[2] == Ch('-'))
                    {
                        // '<!--' - xml comment
                        text += 3;     // Skip '!--'
                        return parse_comment<Flags>(text);
                    }
                    break;

                // <![
                case Ch('['):
                    if (text[2] == Ch('C') && text[3] == Ch('D') && text[4] == Ch('A') &&
                        text[5] == Ch('T') && text[6] == Ch('A') && text[7] == Ch('['))
                    {
                        // '<![CDATA[' - cdata
                        text += 8;     // Skip '![CDATA['
                        return parse_cdata<Flags>(text);
                    }
                    break;

                // <!D
                case Ch('D'):
                    if (text[2] == Ch('O') && text[3] == Ch('C') && text[4] == Ch('T') &&
                        text[5] == Ch('Y') && text[6] == Ch('P') && text[7] == Ch('E') &&
                        whitespace_pred::test(text[8]))
                    {
                        // '<!DOCTYPE ' - doctype
                        text += 9;      // skip '!DOCTYPE '
                        return parse_doctype<Flags>(text);
                    }

                }   // switch

                // Attempt to skip other, unrecognized node types starting with <!
                ++text;     // Skip !
                while (*text != Ch('>'))
                {
                    if (*text == 0)
                        CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                ++text;     // Skip '>'
                return 0;   // No node recognized

            }
        }

        // Parse contents of the node - children, data etc.
        template<int Flags>
        void parse_node_contents(Ch *&text, xml_node<Ch> *node)
        {
            // For all children and text
            while (1)
            {
                // Skip whitespace between > and node contents
                Ch *contents_start = text;      // Store start of node contents before whitespace is skipped
                skip<whitespace_pred, Flags>(text);
                Ch next_char = *text;

            // After data nodes, instead of continuing the loop, control jumps here.
            // This is because zero termination inside parse_and_append_data() function
            // would wreak havoc with the above code.
            // Also, skipping whitespace after data nodes is unnecessary.
            after_data_node:

                // Determine what comes next: node closing, child node, data node, or 0?
                switch (next_char)
                {

                // Node closing or child node
                case Ch('<'):
                    if (text[1] == Ch('/'))
                    {
                        Ch *contents_end = 0;
                        if (internal::preserve_space(node))
                        {
                            contents_end = text;
                        }

                        // Node closing
                        text += 2;      // Skip '</'
                        if (Flags & parse_validate_closing_tags)
                        {
                            // Skip and validate closing tag name
                            Ch *closing_name = text;
                            skip<node_name_pred, Flags>(text);
                            if (!internal::compare(node->name(), node->name_size(), closing_name, static_cast<std::size_t>(text - closing_name), true))
                                CEREAL_RAPIDXML_PARSE_ERROR("invalid closing tag name", text);
                        }
                        else
                        {
                            // No validation, just skip name
                            skip<node_name_pred, Flags>(text);
                        }
                        // Skip remaining whitespace after node name
                        skip<whitespace_pred, Flags>(text);
                        if (*text != Ch('>'))
                            CEREAL_RAPIDXML_PARSE_ERROR("expected >", text);
                        ++text;     // Skip '>'

                        if (contents_end && contents_end != contents_start)
                        {
                            node->value(contents_start, static_cast<std::size_t>(contents_end - contents_start));
                            node->value()[node->value_size()] = Ch('\0');
                        }
                        return;     // Node closed, finished parsing contents
                    }
                    else
                    {
                        // Child node
                        ++text;     // Skip '<'
                        if (xml_node<Ch> *child = parse_node<Flags>(text))
                            node->append_node(child);
                    }
                    break;

                // End of data - error
                case Ch('\0'):
                    CEREAL_RAPIDXML_PARSE_ERROR("unexpected end of data", text);

                // Data node
                default:
                    next_char = parse_and_append_data<Flags>(node, text, contents_start);
                    goto after_data_node;   // Bypass regular processing after data nodes

                }
            }
        }

        // Parse XML attributes of the node
        template<int Flags>
        void parse_node_attributes(Ch *&text, xml_node<Ch> *node)
        {
            // For all attributes
            while (attribute_name_pred::test(*text))
            {
                // Extract attribute name
                Ch *name_ = text;
                ++text;     // Skip first character of attribute name
                skip<attribute_name_pred, Flags>(text);
                if (text == name_)
                    CEREAL_RAPIDXML_PARSE_ERROR("expected attribute name", name_);

                // Create new attribute
                xml_attribute<Ch> *attribute = this->allocate_attribute();
                attribute->name(name_, static_cast<std::size_t>(text - name_));
                node->append_attribute(attribute);

                // Skip whitespace after attribute name
                skip<whitespace_pred, Flags>(text);

                // Skip =
                if (*text != Ch('='))
                    CEREAL_RAPIDXML_PARSE_ERROR("expected =", text);
                ++text;

                // Add terminating zero after name
                if (!(Flags & parse_no_string_terminators))
                    attribute->name()[attribute->name_size()] = 0;

                // Skip whitespace after =
                skip<whitespace_pred, Flags>(text);

                // Skip quote and remember if it was ' or "
                Ch quote = *text;
                if (quote != Ch('\'') && quote != Ch('"'))
                    CEREAL_RAPIDXML_PARSE_ERROR("expected ' or \"", text);
                ++text;

                // Extract attribute value and expand char refs in it
                Ch *value_ = text, *end;
                const int AttFlags = Flags & ~parse_normalize_whitespace;   // No whitespace normalization in attributes
                if (quote == Ch('\''))
                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('\'')>, attribute_value_pure_pred<Ch('\'')>, AttFlags>(text, false);
                else
                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text, false);

                // Set attribute value
                attribute->value(value_, static_cast<std::size_t>(end - value_));

                // Make sure that end quote is present
                if (*text != quote)
                    CEREAL_RAPIDXML_PARSE_ERROR("expected ' or \"", text);
                ++text;     // Skip quote

                // Add terminating zero after value
                if (!(Flags & parse_no_string_terminators))
                    attribute->value()[attribute->value_size()] = 0;

                // Skip whitespace after attribute value
                skip<whitespace_pred, Flags>(text);
            }
        }

    };

    //! \cond internal
    namespace internal
    {

        // Whitespace (space \n \r \t)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_whitespace[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,  0,  // 0
             0,  0,  0,  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,  // 2
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 3
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 4
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 5
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 6
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 7
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 8
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // 9
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // A
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // B
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // C
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // D
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  // E
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0   // F
        };

        // Node name (anything but space \n \r \t / > ? \0)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_node_name[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Text (i.e. PCDATA) (anything but < \0)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_text[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 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,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Text (i.e. PCDATA) that does not require processing when ws normalization is disabled
        // (anything but < \0 &)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_text_pure_no_ws[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
        // (anything but < \0 & space \n \r \t)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_text_pure_with_ws[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             0,  1,  1,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Attribute name (anything but space \n \r \t / < > = ? ! \0)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_attribute_name[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Attribute data with single quote (anything but ' \0)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 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,  0,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Attribute data with single quote that does not require processing (anything but ' \0 &)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1_pure[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             1,  1,  1,  1,  1,  1,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Attribute data with double quote (anything but " \0)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Attribute data with double quote that does not require processing (anything but " \0 &)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2_pure[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
             0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 0
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 1
             1,  1,  0,  1,  1,  1,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 2
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 3
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 4
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 5
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 6
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 7
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 8
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // 9
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // A
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // B
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // C
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // D
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  // E
             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
        };

        // Digits (dec and hex, 255 denotes end of numeric character reference)
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_digits[256] =
        {
          // 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 0
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 1
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 2
             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,255,255,255,255,255,255,  // 3
           255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255,  // 4
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 5
           255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255,  // 6
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 7
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 8
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // 9
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // A
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // B
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // C
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // D
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,  // E
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255   // F
        };

        // Upper case conversion
        template<int Dummy>
        const unsigned char lookup_tables<Dummy>::lookup_upcase[256] =
        {
          // 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  A   B   C   D   E   F
           0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,   // 0
           16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,   // 1
           32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,   // 2
           48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,   // 3
           64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,   // 4
           80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,   // 5
           96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,   // 6
           80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127,  // 7
           128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,  // 8
           144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,  // 9
           160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,  // A
           176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,  // B
           192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,  // C
           208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,  // D
           224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,  // E
           240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255   // F
        };
    }
    //! \endcond

}
} // end namespace cereal

// Undefine internal macros
#undef CEREAL_RAPIDXML_PARSE_ERROR

// On MSVC, restore warnings state
#ifdef _MSC_VER
    #pragma warning(pop)
#endif

#endif


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/rapidxml_iterators.hpp
================================================
#ifndef CEREAL_RAPIDXML_ITERATORS_HPP_INCLUDED
#define CEREAL_RAPIDXML_ITERATORS_HPP_INCLUDED

// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $

#include "rapidxml.hpp"

namespace cereal {
namespace rapidxml
{

    //! Iterator of child nodes of xml_node
    template<class Ch>
    class node_iterator
    {

    public:

        typedef typename xml_node<Ch> value_type;
        typedef typename xml_node<Ch> &reference;
        typedef typename xml_node<Ch> *pointer;
        typedef std::ptrdiff_t difference_type;
        typedef std::bidirectional_iterator_tag iterator_category;

        node_iterator()
            : m_node(0)
        {
        }

        node_iterator(xml_node<Ch> *node)
            : m_node(node->first_node())
        {
        }

        reference operator *() const
        {
            assert(m_node);
            return *m_node;
        }

        pointer operator->() const
        {
            assert(m_node);
            return m_node;
        }

        node_iterator& operator++()
        {
            assert(m_node);
            m_node = m_node->next_sibling();
            return *this;
        }

        node_iterator operator++(int)
        {
            node_iterator tmp = *this;
            ++this;
            return tmp;
        }

        node_iterator& operator--()
        {
            assert(m_node && m_node->previous_sibling());
            m_node = m_node->previous_sibling();
            return *this;
        }

        node_iterator operator--(int)
        {
            node_iterator tmp = *this;
            ++this;
            return tmp;
        }

        bool operator ==(const node_iterator<Ch> &rhs)
        {
            return m_node == rhs.m_node;
        }

        bool operator !=(const node_iterator<Ch> &rhs)
        {
            return m_node != rhs.m_node;
        }

    private:

        xml_node<Ch> *m_node;

    };

    //! Iterator of child attributes of xml_node
    template<class Ch>
    class attribute_iterator
    {

    public:

        typedef typename xml_attribute<Ch> value_type;
        typedef typename xml_attribute<Ch> &reference;
        typedef typename xml_attribute<Ch> *pointer;
        typedef std::ptrdiff_t difference_type;
        typedef std::bidirectional_iterator_tag iterator_category;

        attribute_iterator()
            : m_attribute(0)
        {
        }

        attribute_iterator(xml_node<Ch> *node)
            : m_attribute(node->first_attribute())
        {
        }

        reference operator *() const
        {
            assert(m_attribute);
            return *m_attribute;
        }

        pointer operator->() const
        {
            assert(m_attribute);
            return m_attribute;
        }

        attribute_iterator& operator++()
        {
            assert(m_attribute);
            m_attribute = m_attribute->next_attribute();
            return *this;
        }

        attribute_iterator operator++(int)
        {
            attribute_iterator tmp = *this;
            ++this;
            return tmp;
        }

        attribute_iterator& operator--()
        {
            assert(m_attribute && m_attribute->previous_attribute());
            m_attribute = m_attribute->previous_attribute();
            return *this;
        }

        attribute_iterator operator--(int)
        {
            attribute_iterator tmp = *this;
            ++this;
            return tmp;
        }

        bool operator ==(const attribute_iterator<Ch> &rhs)
        {
            return m_attribute == rhs.m_attribute;
        }

        bool operator !=(const attribute_iterator<Ch> &rhs)
        {
            return m_attribute != rhs.m_attribute;
        }

    private:

        xml_attribute<Ch> *m_attribute;

    };

}
} // namespace cereal

#endif


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/rapidxml_print.hpp
================================================
#ifndef CEREAL_RAPIDXML_PRINT_HPP_INCLUDED
#define CEREAL_RAPIDXML_PRINT_HPP_INCLUDED

// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $

#include "rapidxml.hpp"

// Only include streams if not disabled
#ifndef CEREAL_RAPIDXML_NO_STREAMS
    #include <ostream>
    #include <iterator>
#endif

namespace cereal {
namespace rapidxml
{

    ///////////////////////////////////////////////////////////////////////
    // Printing flags

    const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.

    ///////////////////////////////////////////////////////////////////////
    // Internal

    //! \cond internal
    namespace internal
    {

        ///////////////////////////////////////////////////////////////////////////
        // Internal character operations

        // Copy characters from given range to given output iterator
        template<class OutIt, class Ch>
        inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
        {
            while (begin != end)
                *out++ = *begin++;
            return out;
        }

        // Copy characters from given range to given output iterator and expand
        // characters into references (&lt; &gt; &apos; &quot; &amp;)
        template<class OutIt, class Ch>
        inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)
        {
            while (begin != end)
            {
                if (*begin == noexpand)
                {
                    *out++ = *begin;    // No expansion, copy character
                }
                else
                {
                    switch (*begin)
                    {
                    case Ch('<'):
                        *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
                        break;
                    case Ch('>'):
                        *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
                        break;
                    case Ch('\''):
                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
                        break;
                    case Ch('"'):
                        *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');
                        break;
                    case Ch('&'):
                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';');
                        break;
                    default:
                        *out++ = *begin;    // No expansion, copy character
                    }
                }
                ++begin;    // Step to next character
            }
            return out;
        }

        // Fill given output iterator with repetitions of the same character
        template<class OutIt, class Ch>
        inline OutIt fill_chars(OutIt out, int n, Ch ch)
        {
            for (int i = 0; i < n; ++i)
                *out++ = ch;
            return out;
        }

        // Find character
        template<class Ch, Ch ch>
        inline bool find_char(const Ch *begin, const Ch *end)
        {
            while (begin != end)
                if (*begin++ == ch)
                    return true;
            return false;
        }

        ///////////////////////////////////////////////////////////////////////////
        // Internal printing operations

        // Print node
        template<class OutIt, class Ch>
        inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);

        // Print children of the node
        template<class OutIt, class Ch>
        inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            for (xml_node<Ch> *child = node->first_node(); child; child = child->next_sibling())
                out = print_node(out, child, flags, indent);
            return out;
        }

        // Print attributes of the node
        template<class OutIt, class Ch>
        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int /*flags*/)
        {
            for (xml_attribute<Ch> *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())
            {
                if (attribute->name() && attribute->value())
                {
                    // Print attribute name
                    *out = Ch(' '), ++out;
                    out = copy_chars(attribute->name(), attribute->name() + attribute->name_size(), out);
                    *out = Ch('='), ++out;
                    // Print attribute value using appropriate quote type
                    if (find_char<Ch, Ch('"')>(attribute->value(), attribute->value() + attribute->value_size()))
                    {
                        *out = Ch('\''), ++out;
                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('"'), out);
                        *out = Ch('\''), ++out;
                    }
                    else
                    {
                        *out = Ch('"'), ++out;
                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('\''), out);
                        *out = Ch('"'), ++out;
                    }
                }
            }
            return out;
        }

        // Print data node
        template<class OutIt, class Ch>
        inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_data);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
            return out;
        }

        // Print data node
        template<class OutIt, class Ch>
        inline OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_cdata);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'); ++out;
            *out = Ch('!'); ++out;
            *out = Ch('['); ++out;
            *out = Ch('C'); ++out;
            *out = Ch('D'); ++out;
            *out = Ch('A'); ++out;
            *out = Ch('T'); ++out;
            *out = Ch('A'); ++out;
            *out = Ch('['); ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch(']'); ++out;
            *out = Ch(']'); ++out;
            *out = Ch('>'); ++out;
            return out;
        }

        // Print element node
        template<class OutIt, class Ch>
        inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_element);

            // Print element name and attributes, if any
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            out = copy_chars(node->name(), node->name() + node->name_size(), out);
            out = print_attributes(out, node, flags);

            // If node is childless
            if (node->value_size() == 0 && !node->first_node())
            {
                // Print childless node tag ending
                *out = Ch('/'), ++out;
                *out = Ch('>'), ++out;
            }
            else
            {
                // Print normal node tag ending
                *out = Ch('>'), ++out;

                // Test if node contains a single data node only (and no other nodes)
                xml_node<Ch> *child = node->first_node();
                if (!child)
                {
                    // If node has no children, only print its value without indenting
                    out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
                }
                else if (child->next_sibling() == 0 && child->type() == node_data)
                {
                    // If node has a sole data child, only print its value without indenting
                    out = copy_and_expand_chars(child->value(), child->value() + child->value_size(), Ch(0), out);
                }
                else
                {
                    // Print all children with full indenting
                    if (!(flags & print_no_indenting))
                        *out = Ch('\n'), ++out;
                    out = print_children(out, node, flags, indent + 1);
                    if (!(flags & print_no_indenting))
                        out = fill_chars(out, indent, Ch('\t'));
                }

                // Print node end
                *out = Ch('<'), ++out;
                *out = Ch('/'), ++out;
                out = copy_chars(node->name(), node->name() + node->name_size(), out);
                *out = Ch('>'), ++out;
            }
            return out;
        }

        // Print declaration node
        template<class OutIt, class Ch>
        inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            // Print declaration start
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('?'), ++out;
            *out = Ch('x'), ++out;
            *out = Ch('m'), ++out;
            *out = Ch('l'), ++out;

            // Print attributes
            out = print_attributes(out, node, flags);

            // Print declaration end
            *out = Ch('?'), ++out;
            *out = Ch('>'), ++out;

            return out;
        }

        // Print comment node
        template<class OutIt, class Ch>
        inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_comment);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('!'), ++out;
            *out = Ch('-'), ++out;
            *out = Ch('-'), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('-'), ++out;
            *out = Ch('-'), ++out;
            *out = Ch('>'), ++out;
            return out;
        }

        // Print doctype node
        template<class OutIt, class Ch>
        inline OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_doctype);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('!'), ++out;
            *out = Ch('D'), ++out;
            *out = Ch('O'), ++out;
            *out = Ch('C'), ++out;
            *out = Ch('T'), ++out;
            *out = Ch('Y'), ++out;
            *out = Ch('P'), ++out;
            *out = Ch('E'), ++out;
            *out = Ch(' '), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('>'), ++out;
            return out;
        }

        // Print pi node
        template<class OutIt, class Ch>
        inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_pi);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('?'), ++out;
            out = copy_chars(node->name(), node->name() + node->name_size(), out);
            *out = Ch(' '), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('?'), ++out;
            *out = Ch('>'), ++out;
            return out;
        }

        // Print node
        template<class OutIt, class Ch>
        inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            // Print proper node type
            switch (node->type())
            {

            // Document
            case node_document:
                out = print_children(out, node, flags, indent);
                break;

            // Element
            case node_element:
                out = print_element_node(out, node, flags, indent);
                break;

            // Data
            case node_data:
                out = print_data_node(out, node, flags, indent);
                break;

            // CDATA
            case node_cdata:
                out = print_cdata_node(out, node, flags, indent);
                break;

            // Declaration
            case node_declaration:
                out = print_declaration_node(out, node, flags, indent);
                break;

            // Comment
            case node_comment:
                out = print_comment_node(out, node, flags, indent);
                break;

            // Doctype
            case node_doctype:
                out = print_doctype_node(out, node, flags, indent);
                break;

            // Pi
            case node_pi:
                out = print_pi_node(out, node, flags, indent);
                break;

#ifndef __GNUC__
                // Unknown
            default:
                assert(0);
                break;
#endif
            }

            // If indenting not disabled, add line break after node
            if (!(flags & print_no_indenting))
                *out = Ch('\n'), ++out;

            // Return modified iterator
            return out;
        }

    }
    //! \endcond

    ///////////////////////////////////////////////////////////////////////////
    // Printing

    //! Prints XML to given output iterator.
    //! \param out Output iterator to print to.
    //! \param node Node to be printed. Pass xml_document to print entire document.
    //! \param flags Flags controlling how XML is printed.
    //! \return Output iterator pointing to position immediately after last character of printed text.
    template<class OutIt, class Ch>
    inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
    {
        return internal::print_node(out, &node, flags, 0);
    }

#ifndef CEREAL_RAPIDXML_NO_STREAMS

    //! Prints XML to given output stream.
    //! \param out Output stream to print to.
    //! \param node Node to be printed. Pass xml_document to print entire document.
    //! \param flags Flags controlling how XML is printed.
    //! \return Output stream.
    template<class Ch>
    inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)
    {
        print(std::ostream_iterator<Ch>(out), node, flags);
        return out;
    }

    //! Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.
    //! \param out Output stream to print to.
    //! \param node Node to be printed.
    //! \return Output stream.
    template<class Ch>
    inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)
    {
        return print(out, node);
    }

#endif

}
} // namespace cereal

#endif


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/rapidxml_utils.hpp
================================================
#ifndef CEREAL_RAPIDXML_UTILS_HPP_INCLUDED
#define CEREAL_RAPIDXML_UTILS_HPP_INCLUDED

// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.

#include "rapidxml.hpp"
#include <vector>
#include <string>
#include <fstream>
#include <stdexcept>

namespace cereal {
namespace rapidxml
{

    //! Represents data loaded from a file
    template<class Ch = char>
    class file
    {

    public:

        //! Loads file into the memory. Data will be automatically destroyed by the destructor.
        //! \param filename Filename to load.
        file(const char *filename)
        {
            using namespace std;

            // Open stream
            basic_ifstream<Ch> stream(filename, ios::binary);
            if (!stream)
                throw runtime_error(string("cannot open file ") + filename);
            stream.unsetf(ios::skipws);

            // Determine stream size
            stream.seekg(0, ios::end);
            size_t size = stream.tellg();
            stream.seekg(0);

            // Load data and add terminating 0
            m_data.resize(size + 1);
            stream.read(&m_data.front(), static_cast<streamsize>(size));
            m_data[size] = 0;
        }

        //! Loads file into the memory. Data will be automatically destroyed by the destructor
        //! \param stream Stream to load from
        file(std::basic_istream<Ch> &stream)
        {
            using namespace std;

            // Load data and add terminating 0
            stream.unsetf(ios::skipws);
            m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
            if (stream.fail() || stream.bad())
                throw runtime_error("error reading stream");
            m_data.push_back(0);
        }

        //! Gets file data.
        //! \return Pointer to data of file.
        Ch *data()
        {
            return &m_data.front();
        }

        //! Gets file data.
        //! \return Pointer to data of file.
        const Ch *data() const
        {
            return &m_data.front();
        }

        //! Gets file data size.
        //! \return Size of file data, in characters.
        std::size_t size() const
        {
            return m_data.size();
        }

    private:

        std::vector<Ch> m_data;   // File data

    };

    //! Counts children of node. Time complexity is O(n).
    //! \return Number of children of node
    template<class Ch>
    inline std::size_t count_children(xml_node<Ch> *node)
    {
        xml_node<Ch> *child = node->first_node();
        std::size_t count = 0;
        while (child)
        {
            ++count;
            child = child->next_sibling();
        }
        return count;
    }

    //! Counts attributes of node. Time complexity is O(n).
    //! \return Number of attributes of node
    template<class Ch>
    inline std::size_t count_attributes(xml_node<Ch> *node)
    {
        xml_attribute<Ch> *attr = node->first_attribute();
        std::size_t count = 0;
        while (attr)
        {
            ++count;
            attr = attr->next_attribute();
        }
        return count;
    }

}
} // namespace cereal

#endif


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/macros.hpp
================================================
/*! \file macros.hpp
    \brief Preprocessor macros that can customise the cereal library

    By default, cereal looks for serialization functions with very
    specific names, that is: serialize, load, save, load_minimal,
    or save_minimal.

    This file allows an advanced user to change these names to conform
    to some other style or preference.  This is implemented using
    preprocessor macros.

    As a result of this, in internal cereal code you will see macros
    used for these function names.  In user code, you should name
    the functions like you normally would and not use the macros
    to improve readability.
    \ingroup utility */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CEREAL_MACROS_HPP_
#define CEREAL_MACROS_HPP_

#ifndef CEREAL_THREAD_SAFE
//! Whether cereal should be compiled for a threaded environment
/*! This macro causes cereal to use mutexes to control access to
    global internal state in a thread safe manner.

    Note that even with this enabled you must still ensure that
    archives are accessed by only one thread at a time; it is safe
    to use multiple archives in paralel, but not to access one archive
    from many places simultaneously. */
#define CEREAL_THREAD_SAFE 0
#endif // CEREAL_THREAD_SAFE

#ifndef CEREAL_SIZE_TYPE
//! Determines the data type used for size_type
/*! cereal uses size_type to ensure that the serialized size of
    dynamic containers is compatible across different architectures
    (e.g. 32 vs 64 bit), which may use different underlying types for
    std::size_t.

    More information can be found in cereal/details/helpers.hpp.

    If you choose to modify this type, ensure that you use a fixed
    size type (e.g. uint32_t). */
#define CEREAL_SIZE_TYPE uint64_t
#endif // CEREAL_SIZE_TYPE

// ######################################################################
#ifndef CEREAL_SERIALIZE_FUNCTION_NAME
//! The serialization/deserialization function name to search for.
/*! You can define @c CEREAL_SERIALIZE_FUNCTION_NAME to be different assuming
    you do so before this file is included. */
#define CEREAL_SERIALIZE_FUNCTION_NAME serialize
#endif // CEREAL_SERIALIZE_FUNCTION_NAME

#ifndef CEREAL_LOAD_FUNCTION_NAME
//! The deserialization (load) function name to search for.
/*! You can define @c CEREAL_LOAD_FUNCTION_NAME to be different assuming you do so
    before this file is included. */
#define CEREAL_LOAD_FUNCTION_NAME load
#endif // CEREAL_LOAD_FUNCTION_NAME

#ifndef CEREAL_SAVE_FUNCTION_NAME
//! The serialization (save) function name to search for.
/*! You can define @c CEREAL_SAVE_FUNCTION_NAME to be different assuming you do so
    before this file is included. */
#define CEREAL_SAVE_FUNCTION_NAME save
#endif // CEREAL_SAVE_FUNCTION_NAME

#ifndef CEREAL_LOAD_MINIMAL_FUNCTION_NAME
//! The deserialization (load_minimal) function name to search for.
/*! You can define @c CEREAL_LOAD_MINIMAL_FUNCTION_NAME to be different assuming you do so
    before this file is included. */
#define CEREAL_LOAD_MINIMAL_FUNCTION_NAME load_minimal
#endif // CEREAL_LOAD_MINIMAL_FUNCTION_NAME

#ifndef CEREAL_SAVE_MINIMAL_FUNCTION_NAME
//! The serialization (save_minimal) function name to search for.
/*! You can define @c CEREAL_SAVE_MINIMAL_FUNCTION_NAME to be different assuming you do so
    before this file is included. */
#define CEREAL_SAVE_MINIMAL_FUNCTION_NAME save_minimal
#endif // CEREAL_SAVE_MINIMAL_FUNCTION_NAME

// ######################################################################
//! Defines the CEREAL_NOEXCEPT macro to use instead of noexcept
/*! If a compiler we support does not support noexcept, this macro
    will detect this and define CEREAL_NOEXCEPT as a no-op
    @internal */
#if !defined(CEREAL_HAS_NOEXCEPT)
  #if defined(__clang__)
    #if __has_feature(cxx_noexcept)
      #define CEREAL_HAS_NOEXCEPT
    #endif
  #else // NOT clang
    #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
        defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
      #define CEREAL_HAS_NOEXCEPT
    #endif // end GCC/MSVC check
  #endif // end NOT clang block

  #ifndef CEREAL_NOEXCEPT
    #ifdef CEREAL_HAS_NOEXCEPT
      #define CEREAL_NOEXCEPT noexcept
    #else
      #define CEREAL_NOEXCEPT
    #endif // end CEREAL_HAS_NOEXCEPT
  #endif // end !defined(CEREAL_HAS_NOEXCEPT)
#endif // ifndef CEREAL_NOEXCEPT

// ######################################################################
//! Checks if C++17 is available
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#define CEREAL_HAS_CPP17
#endif

//! Checks if C++14 is available
#if __cplusplus >= 201402L
#define CEREAL_HAS_CPP14
#endif

// ######################################################################
//! Defines the CEREAL_ALIGNOF macro to use instead of alignof
#if defined(_MSC_VER) && _MSC_VER < 1900
#define CEREAL_ALIGNOF __alignof
#else // not MSVC 2013 or older
#define CEREAL_ALIGNOF alignof
#endif // end MSVC check

#endif // CEREAL_MACROS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/specialize.hpp
================================================
/*! \file specialize.hpp
    \brief Serialization disambiguation */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CEREAL_SPECIALIZE_HPP_
#define CEREAL_SPECIALIZE_HPP_

namespace cereal
{
  // Forward declaration of access class that users can become friends with
  class access;

  // ######################################################################
  //! A specifier used in conjunction with cereal::specialize to disambiguate
  //! serialization in special cases
  /*! @relates specialize
      @ingroup Access */
  enum class specialization
  {
    member_serialize,            //!< Force the use of a member serialize function
    member_load_save,            //!< Force the use of a member load/save pair
    member_load_save_minimal,    //!< Force the use of a member minimal load/save pair
    non_member_serialize,        //!< Force the use of a non-member serialize function
    non_member_load_save,        //!< Force the use of a non-member load/save pair
    non_member_load_save_minimal //!< Force the use of a non-member minimal load/save pair
  };

  //! A class used to disambiguate cases where cereal cannot detect a unique way of serializing a class
  /*! cereal attempts to figure out which method of serialization (member vs. non-member serialize
      or load/save pair) at compile time.  If for some reason cereal cannot find a non-ambiguous way
      of serializing a type, it will produce a static assertion complaining about this.

      This can happen because you have both a serialize and load/save pair, or even because a base
      class has a serialize (public or private with friend access) and a derived class does not
      overwrite this due to choosing some other serialization type.

      Specializing this class will tell cereal to explicitly use the serialization type you specify
      and it will not complain about ambiguity in its compile time selection.  However, if cereal detects
      an ambiguity in specializations, it will continue to issue a static assertion.

      @code{.cpp}
      class MyParent
      {
        friend class cereal::access;
        template <class Archive>
        void serialize( Archive & ar ) {}
      };

      // Although serialize is private in MyParent, to cereal::access it will look public,
      // even through MyDerived
      class MyDerived : public MyParent
      {
        public:
          template <class Archive>
          void load( Archive & ar ) {}

          template <class Archive>
          void save( Archive & ar ) {}
      };

      // The load/save pair in MyDerived is ambiguous because serialize in MyParent can
      // be accessed from cereal::access.  This looks the same as making serialize public
      // in MyParent, making it seem as though MyDerived has both a serialize and a load/save pair.
      // cereal will complain about this at compile time unless we disambiguate:

      namespace cereal
      {
        // This struct specialization will tell cereal which is the right way to serialize the ambiguity
        template <class Archive> struct specialize<Archive, MyDerived, cereal::specialization::member_load_save> {};

        // If we only had a disambiguation for a specific archive type, it would look something like this
        template <> struct specialize<cereal::BinaryOutputArchive, MyDerived, cereal::specialization::member_load_save> {};
      }
      @endcode

      You can also choose to use the macros CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES or
      CEREAL_SPECIALIZE_FOR_ARCHIVE if you want to type a little bit less.

      @tparam T The type to specialize the serialization for
      @tparam S The specialization type to use for T
      @ingroup Access */
  template <class Archive, class T, specialization S>
  struct specialize : public std::false_type {};

  //! Convenient macro for performing specialization for all archive types
  /*! This performs specialization for the specific type for all types of archives.
      This macro should be placed at the global namespace.

      @code{cpp}
      struct MyType {};
      CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES( MyType, cereal::specialization::member_load_save );
      @endcode

      @relates specialize
      @ingroup Access */
  #define CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES( Type, Specialization )                                \
  namespace cereal { template <class Archive> struct specialize<Archive, Type, Specialization> {}; }

  //! Convenient macro for performing specialization for a single archive type
  /*! This performs specialization for the specific type for a single type of archive.
      This macro should be placed at the global namespace.

      @code{cpp}
      struct MyType {};
      CEREAL_SPECIALIZE_FOR_ARCHIVE( cereal::XMLInputArchive, MyType, cereal::specialization::member_load_save );
      @endcode

      @relates specialize
      @ingroup Access */
  #define CEREAL_SPECIALIZE_FOR_ARCHIVE( Archive, Type, Specialization )               \
  namespace cereal { template <> struct specialize<Archive, Type, Specialization> {}; }
}

#endif


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/array.hpp
================================================
/*! \file array.hpp
    \brief Support for types found in \<array\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_ARRAY_HPP_
#define CEREAL_TYPES_ARRAY_HPP_

#include "cereal/cereal.hpp"
#include <array>

namespace cereal
{
  //! Saving for std::array primitive types
  //! using binary serialization, if supported
  template <class Archive, class T, size_t N> inline
  typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
  {
    ar( binary_data( array.data(), sizeof(array) ) );
  }

  //! Loading for std::array primitive types
  //! using binary serialization, if supported
  template <class Archive, class T, size_t N> inline
  typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
  {
    ar( binary_data( array.data(), sizeof(array) ) );
  }

  //! Saving for std::array all other types
  template <class Archive, class T, size_t N> inline
  typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
  {
    for( auto const & i : array )
      ar( i );
  }

  //! Loading for std::array all other types
  template <class Archive, class T, size_t N> inline
  typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
  {
    for( auto & i : array )
      ar( i );
  }
} // namespace cereal

#endif // CEREAL_TYPES_ARRAY_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/atomic.hpp
================================================
/*! \file atomic.hpp
    \brief Support for types found in \<atomic\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_ATOMIC_HPP_
#define CEREAL_TYPES_ATOMIC_HPP_

#include <cereal/cereal.hpp>
#include <atomic>

namespace cereal
{
  //! Serializing (save) for std::atomic
  template <class Archive, class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::atomic<T> const & a )
  {
    ar( CEREAL_NVP_("atomic_data", a.load()) );
  }

  //! Serializing (load) for std::atomic
  template <class Archive, class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::atomic<T> & a )
  {
    T tmp;
    ar( CEREAL_NVP_("atomic_data", tmp) );
    a.store( tmp );
  }
} // namespace cereal

#endif // CEREAL_TYPES_ATOMIC_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/base_class.hpp
================================================
/*! \file base_class.hpp
    \brief Support for base classes (virtual and non-virtual)
    \ingroup OtherTypes */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BASE_CLASS_HPP_
#define CEREAL_TYPES_BASE_CLASS_HPP_

#include "cereal/details/traits.hpp"
#include "cereal/details/polymorphic_impl_fwd.hpp"

namespace cereal
{
  namespace base_class_detail
  {
    //! Used to register polymorphic relations and avoid the need to include
    //! polymorphic.hpp when no polymorphism is used
    /*! @internal */
    template <class Base, class Derived, bool IsPolymorphic = std::is_polymorphic<Base>::value>
    struct RegisterPolymorphicBaseClass
    {
      static void bind()
      { }
    };

    //! Polymorphic version
    /*! @internal */
    template <class Base, class Derived>
    struct RegisterPolymorphicBaseClass<Base, Derived, true>
    {
      static void bind()
      { detail::RegisterPolymorphicCaster<Base, Derived>::bind(); }
    };
  }

  //! Casts a derived class to its non-virtual base class in a way that safely supports abstract classes
  /*! This should be used in cases when a derived type needs to serialize its base type. This is better than directly
      using static_cast, as it allows for serialization of pure virtual (abstract) base classes.

      This also automatically registers polymorphic relation between the base and derived class, assuming they
      are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
      see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
      polymorphism (cereal/types/polymorphic.hpp).

      \sa virtual_base_class

      @code{.cpp}
      struct MyBase
      {
        int x;

        virtual void foo() = 0;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( x );
        }
      };

      struct MyDerived : public MyBase //<-- Note non-virtual inheritance
      {
        int y;

        virtual void foo() {};

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( cereal::base_class<MyBase>(this) );
          ar( y );
        }
      };
      @endcode */
  template<class Base>
    struct base_class : private traits::detail::BaseCastBase
    {
      template<class Derived>
        base_class(Derived const * derived) :
          base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
      {
        static_assert( std::is_base_of<Base, Derived>::value, "Can only use base_class on a valid base class" );
        base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
      }

        Base * base_ptr;
    };

  //! Casts a derived class to its virtual base class in a way that allows cereal to track inheritance
  /*! This should be used in cases when a derived type features virtual inheritance from some
      base type.  This allows cereal to track the inheritance and to avoid making duplicate copies
      during serialization.

      It is safe to use virtual_base_class in all circumstances for serializing base classes, even in cases
      where virtual inheritance does not take place, though it may be slightly faster to utilize
      cereal::base_class<> if you do not need to worry about virtual inheritance.

      This also automatically registers polymorphic relation between the base and derived class, assuming they
      are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
      see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
      polymorphism (cereal/types/polymorphic.hpp).

      \sa base_class

      @code{.cpp}
      struct MyBase
      {
        int x;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( x );
        }
      };

      struct MyLeft : virtual MyBase //<-- Note the virtual inheritance
      {
        int y;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( cereal::virtual_base_class<MyBase>( this ) );
          ar( y );
        }
      };

      struct MyRight : virtual MyBase
      {
        int z;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( cereal::virtual_base_clas<MyBase>( this ) );
          ar( z );
        }
      };

      // diamond virtual inheritance; contains one copy of each base class
      struct MyDerived : virtual MyLeft, virtual MyRight
      {
        int a;

        template <class Archive>
        void serialize( Archive & ar )
        {
          ar( cereal::virtual_base_class<MyLeft>( this ) );  // safely serialize data members in MyLeft
          ar( cereal::virtual_base_class<MyRight>( this ) ); // safely serialize data members in MyRight
          ar( a );

          // Because we used virtual_base_class, cereal will ensure that only one instance of MyBase is
          // serialized as we traverse the inheritance heirarchy. This means that there will be one copy
          // each of the variables x, y, z, and a

          // If we had chosen to use static_cast<> instead, cereal would perform no tracking and
          // assume that every base class should be serialized (in this case leading to a duplicate
          // serialization of MyBase due to diamond inheritance
      };
     }
     @endcode */
  template<class Base>
    struct virtual_base_class : private traits::detail::BaseCastBase
    {
      template<class Derived>
        virtual_base_class(Derived const * derived) :
          base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
      {
        static_assert( std::is_base_of<Base, Derived>::value, "Can only use virtual_base_class on a valid base class" );
        base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
      }

        Base * base_ptr;
    };

} // namespace cereal

#endif // CEREAL_TYPES_BASE_CLASS_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/bitset.hpp
================================================
/*! \file bitset.hpp
    \brief Support for types found in \<bitset\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BITSET_HPP_
#define CEREAL_TYPES_BITSET_HPP_

#include "cereal/cereal.hpp"
#include "cereal/types/string.hpp"
#include <bitset>

namespace cereal
{
  namespace bitset_detail
  {
    //! The type the bitset is encoded with
    /*! @internal */
    enum class type : uint8_t
    {
      ulong,
      ullong,
      string,
      bits
    };
  }

  //! Serializing (save) for std::bitset when BinaryData optimization supported
  template <class Archive, size_t N,
            traits::EnableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
            = traits::sfinae> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
  {
    ar( CEREAL_NVP_("type", bitset_detail::type::bits) );

    // Serialize 8 bit chunks
    std::uint8_t chunk = 0;
    std::uint8_t mask = 0x80;

    // Set each chunk using a rotating mask for the current bit
    for( std::size_t i = 0; i < N; ++i )
    {
      if( bits[i] )
        chunk |= mask;

      mask = static_cast<std::uint8_t>(mask >> 1);

      // output current chunk when mask is empty (8 bits)
      if( mask == 0 )
      {
        ar( chunk );
        chunk = 0;
        mask = 0x80;
      }
    }

    // serialize remainder, if it exists
    if( mask != 0x80 )
      ar( chunk );
  }

  //! Serializing (save) for std::bitset when BinaryData is not supported
  template <class Archive, size_t N,
            traits::DisableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
            = traits::sfinae> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
  {
    try
    {
      auto const b = bits.to_ulong();
      ar( CEREAL_NVP_("type", bitset_detail::type::ulong) );
      ar( CEREAL_NVP_("data", b) );
    }
    catch( std::overflow_error const & )
    {
      try
      {
        auto const b = bits.to_ullong();
        ar( CEREAL_NVP_("type", bitset_detail::type::ullong) );
        ar( CEREAL_NVP_("data", b) );
      }
      catch( std::overflow_error const & )
      {
        ar( CEREAL_NVP_("type", bitset_detail::type::string) );
        ar( CEREAL_NVP_("data", bits.to_string()) );
      }
    }
  }

  //! Serializing (load) for std::bitset
  template <class Archive, size_t N> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::bitset<N> & bits )
  {
    bitset_detail::type t;
    ar( CEREAL_NVP_("type", t) );

    switch( t )
    {
      case bitset_detail::type::ulong:
      {
        unsigned long b;
        ar( CEREAL_NVP_("data", b) );
        bits = std::bitset<N>( b );
        break;
      }
      case bitset_detail::type::ullong:
      {
        unsigned long long b;
        ar( CEREAL_NVP_("data", b) );
        bits = std::bitset<N>( b );
        break;
      }
      case bitset_detail::type::string:
      {
        std::string b;
        ar( CEREAL_NVP_("data", b) );
        bits = std::bitset<N>( b );
        break;
      }
      case bitset_detail::type::bits:
      {
        // Normally we would use BinaryData to route this at compile time,
        // but doing this at runtime doesn't break any old serialization
        std::uint8_t chunk = 0;
        std::uint8_t mask  = 0;

        bits.reset();

        // Load one chunk at a time, rotating through the chunk
        // to set bits in the bitset
        for( std::size_t i = 0; i < N; ++i )
        {
          if( mask == 0 )
          {
            ar( chunk );
            mask = 0x80;
          }

          if( chunk & mask )
            bits[i] = 1;

          mask = static_cast<std::uint8_t>(mask >> 1);
        }
        break;
      }
      default:
        throw Exception("Invalid bitset data representation");
    }
  }
} // namespace cereal

#endif // CEREAL_TYPES_BITSET_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/boost_variant.hpp
================================================
/*! \file boost_variant.hpp
    \brief Support for boost::variant
    \ingroup OtherTypes */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BOOST_VARIANT_HPP_
#define CEREAL_TYPES_BOOST_VARIANT_HPP_

//! @internal
#if defined(_MSC_VER) && _MSC_VER < 1911
#define CEREAL_CONSTEXPR_LAMBDA
#else // MSVC 2017 or newer, all other compilers
#define CEREAL_CONSTEXPR_LAMBDA constexpr
#endif

#include "cereal/cereal.hpp"
#include <boost/variant/variant_fwd.hpp>
#include <boost/variant/static_visitor.hpp>

namespace cereal
{
  namespace boost_variant_detail
  {
    //! @internal
    template <class Archive>
    struct variant_save_visitor : boost::static_visitor<>
    {
      variant_save_visitor(Archive & ar_) : ar(ar_) {}

      template<class T>
      void operator()(T const & value) const
      {
        ar( CEREAL_NVP_("data", value) );
      }

      Archive & ar;
    };

    //! @internal
    template <class Archive, class T>
    struct LoadAndConstructLoadWrapper
    {
      using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;

      LoadAndConstructLoadWrapper() :
        construct( reinterpret_cast<T *>( &st ) )
      { }

      ~LoadAndConstructLoadWrapper()
      {
        if (construct.itsValid)
        {
          construct->~T();
        }
      }

      void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
      {
        ::cereal::detail::Construct<T, Archive>::load_andor_construct( ar, construct );
      }

      ST st;
      ::cereal::construct<T> construct;
    };

    //! @internal
    template <class T> struct load_variant_wrapper;

    //! Avoid serializing variant void_ type
    /*! @internal */
    template <>
    struct load_variant_wrapper<boost::detail::variant::void_>
    {
      template <class Variant, class Archive>
      static void load_variant( Archive &, Variant & )
      { }
    };

    //! @internal
    template <class T>
    struct load_variant_wrapper
    {
      // default constructible
      template <class Archive, class Variant>
      static void load_variant_impl( Archive & ar, Variant & variant, std::true_type )
      {
        T value;
        ar( CEREAL_NVP_("data", value) );
        variant = std::move(value);
      }

      // not default constructible
      template<class Variant, class Archive>
      static void load_variant_impl(Archive & ar, Variant & variant, std::false_type )
      {
        LoadAndConstructLoadWrapper<Archive, T> loadWrapper;

        ar( CEREAL_NVP_("data", loadWrapper) );
        variant = std::move(*loadWrapper.construct.ptr());
      }

      //! @internal
      template<class Variant, class Archive>
      static void load_variant(Archive & ar, Variant & variant)
      {
        load_variant_impl( ar, variant, typename std::is_default_constructible<T>::type() );
      }
    };
  } // namespace boost_variant_detail

  //! Saving for boost::variant
  template <class Archive, typename ... VariantTypes> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> const & variant )
  {
    int32_t which = variant.which();
    ar( CEREAL_NVP_("which", which) );
    boost_variant_detail::variant_save_visitor<Archive> visitor(ar);
    variant.apply_visitor(visitor);
  }

  //! Loading for boost::variant
  template <class Archive, typename ... VariantTypes> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> & variant )
  {
    int32_t which;
    ar( CEREAL_NVP_("which", which) );

    using LoadFuncType = void(*)(Archive &, boost::variant<VariantTypes...> &);
    CEREAL_CONSTEXPR_LAMBDA LoadFuncType loadFuncArray[] = {&boost_variant_detail::load_variant_wrapper<VariantTypes>::load_variant...};

    if(which >= int32_t(sizeof(loadFuncArray)/sizeof(loadFuncArray[0])))
      throw Exception("Invalid 'which' selector when deserializing boost::variant");

    loadFuncArray[which](ar, variant);
  }
} // namespace cereal

#undef CEREAL_CONSTEXPR_LAMBDA

#endif // CEREAL_TYPES_BOOST_VARIANT_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/chrono.hpp
================================================
/*! \file chrono.hpp
    \brief Support for types found in \<chrono\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_CHRONO_HPP_
#define CEREAL_TYPES_CHRONO_HPP_

#include <chrono>

namespace cereal
{
  //! Saving std::chrono::duration
  template <class Archive, class R, class P> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> const & dur )
  {
    ar( CEREAL_NVP_("count", dur.count()) );
  }

  //! Loading std::chrono::duration
  template <class Archive, class R, class P> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> & dur )
  {
    R count;
    ar( CEREAL_NVP_("count", count) );

    dur = std::chrono::duration<R, P>{count};
  }

  //! Saving std::chrono::time_point
  template <class Archive, class C, class D> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> const & dur )
  {
    ar( CEREAL_NVP_("time_since_epoch", dur.time_since_epoch()) );
  }

  //! Loading std::chrono::time_point
  template <class Archive, class C, class D> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> & dur )
  {
    D elapsed;
    ar( CEREAL_NVP_("time_since_epoch", elapsed) );

    dur = std::chrono::time_point<C, D>{elapsed};
  }
} // namespace cereal

#endif // CEREAL_TYPES_CHRONO_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/common.hpp
================================================
/*! \file common.hpp
    \brief Support common types - always included automatically
    \ingroup OtherTypes */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_COMMON_HPP_
#define CEREAL_TYPES_COMMON_HPP_

#include "cereal/cereal.hpp"

namespace cereal
{
  namespace common_detail
  {
    //! Serialization for arrays if BinaryData is supported and we are arithmetic
    /*! @internal */
    template <class Archive, class T> inline
    void serializeArray( Archive & ar, T & array, std::true_type /* binary_supported */ )
    {
      ar( binary_data( array, sizeof(array) ) );
    }

    //! Serialization for arrays if BinaryData is not supported or we are not arithmetic
    /*! @internal */
    template <class Archive, class T> inline
    void serializeArray( Archive & ar, T & array, std::false_type /* binary_supported */ )
    {
      for( auto & i : array )
        ar( i );
    }

    namespace
    {
      //! Gets the underlying type of an enum
      /*! @internal */
      template <class T, bool IsEnum>
      struct enum_underlying_type : std::false_type {};

      //! Gets the underlying type of an enum
      /*! Specialization for when we actually have an enum
          @internal */
      template <class T>
      struct enum_underlying_type<T, true> { using type = typename std::underlying_type<T>::type; };
    } // anon namespace

    //! Checks if a type is an enum
    /*! This is needed over simply calling std::is_enum because the type
        traits checking at compile time will attempt to call something like
        load_minimal with a special NoConvertRef struct that wraps up the true type.

        This will strip away any of that and also expose the true underlying type.
        @internal */
    template <class T>
    class is_enum
    {
      private:
        using DecayedT  = typename std::decay<T>::type;
        using StrippedT = typename ::cereal::traits::strip_minimal<DecayedT>::type;

      public:
        static const bool value = std::is_enum<StrippedT>::value;
        using type = StrippedT;
        using base_type = typename enum_underlying_type<StrippedT, value>::type;
    };
  }

  //! Saving for enum types
  template <class Archive, class T> inline
  typename std::enable_if<common_detail::is_enum<T>::value,
                          typename common_detail::is_enum<T>::base_type>::type
  CEREAL_SAVE_MINIMAL_FUNCTION_NAME( Archive const &, T const & t )
  {
    return static_cast<typename common_detail::is_enum<T>::base_type>(t);
  }

  //! Loading for enum types
  template <class Archive, class T> inline
  typename std::enable_if<common_detail::is_enum<T>::value, void>::type
  CEREAL_LOAD_MINIMAL_FUNCTION_NAME( Archive const &, T && t,
                                     typename common_detail::is_enum<T>::base_type const & value )
  {
    t = reinterpret_cast<typename common_detail::is_enum<T>::type const &>( value );
  }

  //! Serialization for raw pointers
  /*! This exists only to throw a static_assert to let users know we don't support raw pointers. */
  template <class Archive, class T> inline
  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, T * & )
  {
    static_assert(cereal::traits::detail::delay_static_assert<T>::value,
      "Cereal does not support serializing raw pointers - please use a smart pointer");
  }

  //! Serialization for C style arrays
  template <class Archive, class T> inline
  typename std::enable_if<std::is_array<T>::value, void>::type
  CEREAL_SERIALIZE_FUNCTION_NAME(Archive & ar, T & array)
  {
    common_detail::serializeArray( ar, array,
        std::integral_constant<bool, traits::is_output_serializable<BinaryData<T>, Archive>::value &&
                                     std::is_arithmetic<typename std::remove_all_extents<T>::type>::value>() );
  }
} // namespace cereal

#endif // CEREAL_TYPES_COMMON_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/complex.hpp
================================================
/*! \file complex.hpp
    \brief Support for types found in \<complex\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_COMPLEX_HPP_
#define CEREAL_TYPES_COMPLEX_HPP_

#include <complex>

namespace cereal
{
  //! Serializing (save) for std::complex
  template <class Archive, class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::complex<T> const & comp )
  {
    ar( CEREAL_NVP_("real", comp.real()),
        CEREAL_NVP_("imag", comp.imag()) );
  }

  //! Serializing (load) for std::complex
  template <class Archive, class T> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::complex<T> & bits )
  {
    T real, imag;
    ar( CEREAL_NVP_("real", real),
        CEREAL_NVP_("imag", imag) );
    bits = {real, imag};
  }
} // namespace cereal

#endif // CEREAL_TYPES_COMPLEX_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/concepts/pair_associative_container.hpp
================================================
/*! \file pair_associative_container.hpp
    \brief Support for the PairAssociativeContainer refinement of the
    AssociativeContainer concept.
    \ingroup TypeConcepts */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
#define CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_

#include "cereal/cereal.hpp"

namespace cereal
{
  //! Saving for std-like pair associative containers
  template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, Map<Args...> const & map )
  {
    ar( make_size_tag( static_cast<size_type>(map.size()) ) );

    for( const auto & i : map )
      ar( make_map_item(i.first, i.second) );
  }

  //! Loading for std-like pair associative containers
  template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, Map<Args...> & map )
  {
    size_type size;
    ar( make_size_tag( size ) );

    map.clear();

    auto hint = map.begin();
    for( size_t i = 0; i < size; ++i )
    {
      typename Map<Args...>::key_type key;
      typename Map<Args...>::mapped_type value;

      ar( make_map_item(key, value) );
      #ifdef CEREAL_OLDER_GCC
      hint = map.insert( hint, std::make_pair(std::move(key), std::move(value)) );
      #else // NOT CEREAL_OLDER_GCC
      hint = map.emplace_hint( hint, std::move( key ), std::move( value ) );
      #endif // NOT CEREAL_OLDER_GCC
    }
  }
} // namespace cereal

#endif // CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/deque.hpp
================================================
/*! \file deque.hpp
    \brief Support for types found in \<deque\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_DEQUE_HPP_
#define CEREAL_TYPES_DEQUE_HPP_

#include "cereal/cereal.hpp"
#include <deque>

namespace cereal
{
  //! Saving for std::deque
  template <class Archive, class T, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::deque<T, A> const & deque )
  {
    ar( make_size_tag( static_cast<size_type>(deque.size()) ) );

    for( auto const & i : deque )
      ar( i );
  }

  //! Loading for std::deque
  template <class Archive, class T, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::deque<T, A> & deque )
  {
    size_type size;
    ar( make_size_tag( size ) );

    deque.resize( static_cast<size_t>( size ) );

    for( auto & i : deque )
      ar( i );
  }
} // namespace cereal

#endif // CEREAL_TYPES_DEQUE_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/forward_list.hpp
================================================
/*! \file forward_list.hpp
    \brief Support for types found in \<forward_list\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_FORWARD_LIST_HPP_
#define CEREAL_TYPES_FORWARD_LIST_HPP_

#include "cereal/cereal.hpp"
#include <forward_list>

namespace cereal
{
  //! Saving for std::forward_list all other types
  template <class Archive, class T, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> const & forward_list )
  {
    // write the size - note that this is slow because we need to traverse
    // the entire list. there are ways we could avoid this but this was chosen
    // since it works in the most general fashion with any archive type
    size_type const size = std::distance( forward_list.begin(), forward_list.end() );

    ar( make_size_tag( size ) );

    // write the list
    for( const auto & i : forward_list )
      ar( i );
  }

  //! Loading for std::forward_list all other types from
  template <class Archive, class T, class A>
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> & forward_list )
  {
    size_type size;
    ar( make_size_tag( size ) );

    forward_list.resize( static_cast<size_t>( size ) );

    for( auto & i : forward_list )
      ar( i );
  }
} // namespace cereal

#endif // CEREAL_TYPES_FORWARD_LIST_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/functional.hpp
================================================
/*! \file functional.hpp
    \brief Support for types found in \<functional\>
    \ingroup STLSupport */
/*
  Copyright (c) 2016, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_FUNCTIONAL_HPP_
#define CEREAL_TYPES_FUNCTIONAL_HPP_

#include <functional>

namespace cereal
{
  //! Saving for std::less
  template <class Archive, class T> inline
  void serialize( Archive &, std::less<T> & )
  { }
} // namespace cereal

#endif // CEREAL_TYPES_FUNCTIONAL_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/list.hpp
================================================
/*! \file list.hpp
    \brief Support for types found in \<list\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_LIST_HPP_
#define CEREAL_TYPES_LIST_HPP_

#include "cereal/cereal.hpp"
#include <list>

namespace cereal
{
  //! Saving for std::list
  template <class Archive, class T, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::list<T, A> const & list )
  {
    ar( make_size_tag( static_cast<size_type>(list.size()) ) );

    for( auto const & i : list )
      ar( i );
  }

  //! Loading for std::list
  template <class Archive, class T, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::list<T, A> & list )
  {
    size_type size;
    ar( make_size_tag( size ) );

    list.resize( static_cast<size_t>( size ) );

    for( auto & i : list )
      ar( i );
  }
} // namespace cereal

#endif // CEREAL_TYPES_LIST_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/map.hpp
================================================
/*! \file map.hpp
    \brief Support for types found in \<map\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_MAP_HPP_
#define CEREAL_TYPES_MAP_HPP_

#include "cereal/types/concepts/pair_associative_container.hpp"
#include <map>

#endif // CEREAL_TYPES_MAP_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/memory.hpp
================================================
/*! \file memory.hpp
    \brief Support for types found in \<memory\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_SHARED_PTR_HPP_
#define CEREAL_TYPES_SHARED_PTR_HPP_

#include "cereal/cereal.hpp"
#include <memory>
#include <cstring>

namespace cereal
{
  namespace memory_detail
  {
    //! A wrapper class to notify cereal that it is ok to serialize the contained pointer
    /*! This mechanism allows us to intercept and properly handle polymorphic pointers
        @internal */
    template<class T>
    struct PtrWrapper
    {
      PtrWrapper(T && p) : ptr(std::forward<T>(p)) {}
      T & ptr;

      PtrWrapper( PtrWrapper const & ) = default;
      PtrWrapper & operator=( PtrWrapper const & ) = delete;
    };

    //! Make a PtrWrapper
    /*! @internal */
    template<class T> inline
    PtrWrapper<T> make_ptr_wrapper(T && t)
    {
      return {std::forward<T>(t)};
    }

    //! A struct that acts as a wrapper around calling load_andor_construct
    /*! The purpose of this is to allow a load_and_construct call to properly enter into the
        'data' NVP of the ptr_wrapper
        @internal */
    template <class Archive, class T>
    struct LoadAndConstructLoadWrapper
    {
      LoadAndConstructLoadWrapper( T * ptr ) :
        construct( ptr )
      { }

      //! Constructor for embedding an early call for restoring shared_from_this
      template <class F>
      LoadAndConstructLoadWrapper( T * ptr, F && sharedFromThisFunc ) :
        construct( ptr, sharedFromThisFunc )
      { }

      inline void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
      {
        ::cereal::detail::Construct<T, Archive>::load_andor_construct( ar, construct );
      }

      ::cereal::construct<T> construct;
    };

    //! A helper struct for saving and restoring the state of types that derive from
    //! std::enable_shared_from_this
    /*! This special struct is necessary because when a user uses load_and_construct,
        the weak_ptr (or whatever implementation defined variant) that allows
        enable_shared_from_this to function correctly will not be initialized properly.

        This internal weak_ptr can also be modified by the shared_ptr that is created
        during the serialization of a polymorphic pointer, where cereal creates a
        wrapper shared_ptr out of a void pointer to the real data.

        In the case of load_and_construct, this happens because it is the allocation
        of shared_ptr that perform this initialization, which we let happen on a buffer
        of memory (aligned_storage).  This buffer is then used for placement new
        later on, effectively overwriting any initialized weak_ptr with a default
        initialized one, eventually leading to issues when the user calls shared_from_this.

        To get around these issues, we will store the memory for the enable_shared_from_this
        portion of the class and replace it after whatever happens to modify it (e.g. the
        user performing construction or the wrapper shared_ptr in saving).

        Note that this goes into undefined behavior territory, but as of the initial writing
        of this, all standard library implementations of std::enable_shared_from_this are
        compatible with this memory manipulation. It is entirely possible that this may someday
        break or may not work with convoluted use cases.

        Example usage:

        @code{.cpp}
        T * myActualPointer;
        {
          EnableSharedStateHelper<T> helper( myActualPointer ); // save the state
          std::shared_ptr<T> myPtr( myActualPointer ); // modifies the internal weak_ptr
          // helper restores state when it goes out of scope
        }
        @endcode

        When possible, this is designed to be used in an RAII fashion - it will save state on
        construction and restore it on destruction. The restore can be done at an earlier time
        (e.g. after construct() is called in load_and_construct) in which case the destructor will
        do nothing. Performing the restore immediately following construct() allows a user to call
        shared_from_this within their load_and_construct function.

        @tparam T Type pointed to by shared_ptr
        @internal */
    template <class T>
    class EnableSharedStateHelper
    {
      // typedefs for parent type and storage type
      using BaseType = typename ::cereal::traits::get_shared_from_this_base<T>::type;
      using ParentType = std::enable_shared_from_this<BaseType>;
      using StorageType = typename std::aligned_storage<sizeof(ParentType), CEREAL_ALIGNOF(ParentType)>::type;

      public:
        //! Saves the state of some type inheriting from enable_shared_from_this
        /*! @param ptr The raw pointer held by the shared_ptr */
        inline EnableSharedStateHelper( T * ptr ) :
          itsPtr( static_cast<ParentType *>( ptr ) ),
          itsState(),
          itsRestored( false )
        {
          std::memcpy( &itsState, itsPtr, sizeof(ParentType) );
        }

        //! Restores the state of the held pointer (can only be done once)
        inline void restore()
        {
          if( !itsRestored )
          {
            // void * cast needed when type has no trivial copy-assignment
            std::memcpy( static_cast<void *>(itsPtr), &itsState, sizeof(ParentType) );
            itsRestored = true;
          }
        }

        //! Restores the state of the held pointer if not done previously
        inline ~EnableSharedStateHelper()
        {
          restore();
        }

      private:
        ParentType * itsPtr;
        StorageType itsState;
        bool itsRestored;
    }; // end EnableSharedStateHelper

    //! Performs loading and construction for a shared pointer that is derived from
    //! std::enable_shared_from_this
    /*! @param ar The archive
        @param ptr Raw pointer held by the shared_ptr
        @internal */
    template <class Archive, class T> inline
    void loadAndConstructSharedPtr( Archive & ar, T * ptr, std::true_type /* has_shared_from_this */ )
    {
      memory_detail::EnableSharedStateHelper<T> state( ptr );
      memory_detail::LoadAndConstructLoadWrapper<Archive, T> loadWrapper( ptr, [&](){ state.restore(); } );

      // let the user perform their initialization, shared state will be restored as soon as construct()
      // is called
      ar( CEREAL_NVP_("data", loadWrapper) );
    }

    //! Performs loading and construction for a shared pointer that is NOT derived from
    //! std::enable_shared_from_this
    /*! This is the typical case, where we simply pass the load wrapper to the
        archive.

        @param ar The archive
        @param ptr Raw pointer held by the shared_ptr
        @internal */
    template <class Archive, class T> inline
    void loadAndConstructSharedPtr( Archive & ar, T * ptr, std::false_type /* has_shared_from_this */ )
    {
      memory_detail::LoadAndConstructLoadWrapper<Archive, T> loadWrapper( ptr );
      ar( CEREAL_NVP_("data", loadWrapper) );
    }
  } // end namespace memory_detail

  //! Saving std::shared_ptr for non polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
  {
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
  }

  //! Loading std::shared_ptr, case when no user load and construct for non polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> & ptr )
  {
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
  }

  //! Saving std::weak_ptr for non polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> const & ptr )
  {
    auto const sptr = ptr.lock();
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
  }

  //! Loading std::weak_ptr for non polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> & ptr )
  {
    std::shared_ptr<T> sptr;
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
    ptr = sptr;
  }

  //! Saving std::unique_ptr for non polymorphic types
  template <class Archive, class T, class D> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
  {
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
  }

  //! Loading std::unique_ptr, case when user provides load_and_construct for non polymorphic types
  template <class Archive, class T, class D> inline
  typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> & ptr )
  {
    ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
  }

  // ######################################################################
  // Pointer wrapper implementations follow below

  //! Saving std::shared_ptr (wrapper implementation)
  /*! @internal */
  template <class Archive, class T> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> const &> const & wrapper )
  {
    auto & ptr = wrapper.ptr;

    uint32_t id = ar.registerSharedPointer( ptr.get() );
    ar( CEREAL_NVP_("id", id) );

    if( id & detail::msb_32bit )
    {
      ar( CEREAL_NVP_("data", *ptr) );
    }
  }

  //! Loading std::shared_ptr, case when user load and construct (wrapper implementation)
  /*! @internal */
  template <class Archive, class T> inline
  typename std::enable_if<traits::has_load_and_construct<T, Archive>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
  {
    uint32_t id;

    ar( CEREAL_NVP_("id", id) );

    if( id & detail::msb_32bit )
    {
      // Storage type for the pointer - since we can't default construct this type,
      // we'll allocate it using std::aligned_storage and use a custom deleter
      using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;

      // Valid flag - set to true once construction finishes
      //  This prevents us from calling the destructor on
      //  uninitialized data.
      auto valid = std::make_shared<bool>( false );

      // Allocate our storage, which we will treat as
      //  uninitialized until initialized with placement new
      using NonConstT = typename std::remove_const<T>::type;
      std::shared_ptr<NonConstT> ptr(reinterpret_cast<NonConstT *>(new ST()),
          [=]( NonConstT * t )
          {
            if( *valid )
              t->~T();

            delete reinterpret_cast<ST *>( t );
          } );

      // Register the pointer
      ar.registerSharedPointer( id, ptr );

      // Perform the actual loading and allocation
      memory_detail::loadAndConstructSharedPtr( ar, ptr.get(), typename ::cereal::traits::has_shared_from_this<NonConstT>::type() );

      // Mark pointer as valid (initialized)
      *valid = true;
      wrapper.ptr = std::move(ptr);
    }
    else
      wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
  }

  //! Loading std::shared_ptr, case when no user load and construct (wrapper implementation)
  /*! @internal */
  template <class Archive, class T> inline
  typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
  {
    uint32_t id;

    ar( CEREAL_NVP_("id", id) );

    if( id & detail::msb_32bit )
    {
      using NonConstT = typename std::remove_const<T>::type;
      std::shared_ptr<NonConstT> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
      ar.registerSharedPointer( id, ptr );
      ar( CEREAL_NVP_("data", *ptr) );
      wrapper.ptr = std::move(ptr);
    }
    else
      wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
  }

  //! Saving std::unique_ptr (wrapper implementation)
  /*! @internal */
  template <class Archive, class T, class D> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> const &> const & wrapper )
  {
    auto & ptr = wrapper.ptr;

    // unique_ptr get one byte of metadata which signifies whether they were a nullptr
    // 0 == nullptr
    // 1 == not null

    if( !ptr )
      ar( CEREAL_NVP_("valid", uint8_t(0)) );
    else
    {
      ar( CEREAL_NVP_("valid", uint8_t(1)) );
      ar( CEREAL_NVP_("data", *ptr) );
    }
  }

  //! Loading std::unique_ptr, case when user provides load_and_construct (wrapper implementation)
  /*! @internal */
  template <class Archive, class T, class D> inline
  typename std::enable_if<traits::has_load_and_construct<T, Archive>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
  {
    uint8_t isValid;
    ar( CEREAL_NVP_("valid", isValid) );

    auto & ptr = wrapper.ptr;

    if( isValid )
    {
      using NonConstT = typename std::remove_const<T>::type;
      // Storage type for the pointer - since we can't default construct this type,
      // we'll allocate it using std::aligned_storage
      using ST = typename std::aligned_storage<sizeof(NonConstT), CEREAL_ALIGNOF(NonConstT)>::type;

      // Allocate storage - note the ST type so that deleter is correct if
      //                    an exception is thrown before we are initialized
      std::unique_ptr<ST> stPtr( new ST() );

      // Use wrapper to enter into "data" nvp of ptr_wrapper
      memory_detail::LoadAndConstructLoadWrapper<Archive, NonConstT> loadWrapper( reinterpret_cast<NonConstT *>( stPtr.get() ) );

      // Initialize storage
      ar( CEREAL_NVP_("data", loadWrapper) );

      // Transfer ownership to correct unique_ptr type
      ptr.reset( reinterpret_cast<T *>( stPtr.release() ) );
    }
    else
      ptr.reset( nullptr );
  }

  //! Loading std::unique_ptr, case when no load_and_construct (wrapper implementation)
  /*! @internal */
  template <class Archive, class T, class D> inline
  typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
  {
    uint8_t isValid;
    ar( CEREAL_NVP_("valid", isValid) );

    if( isValid )
    {
      using NonConstT = typename std::remove_const<T>::type;
      std::unique_ptr<NonConstT, D> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
      ar( CEREAL_NVP_( "data", *ptr ) );
      wrapper.ptr = std::move(ptr);
    }
    else
    {
      wrapper.ptr.reset( nullptr );
    }
  }
} // namespace cereal

// automatically include polymorphic support
#include "cereal/types/polymorphic.hpp"

#endif // CEREAL_TYPES_SHARED_PTR_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/optional.hpp
================================================
/*! \file optional.hpp
    \brief Support for std::optional
    \ingroup STLSupport */
/*
  Copyright (c) 2017, Juan Pedro Bolivar Puente
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STD_OPTIONAL_
#define CEREAL_TYPES_STD_OPTIONAL_

#include "cereal/cereal.hpp"
#include <optional>

namespace cereal {
  //! Saving for std::optional
  template <class Archive, typename T> inline
  void CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const std::optional<T>& optional)
  {
    if(!optional) {
      ar(CEREAL_NVP_("nullopt", true));
    } else {
      ar(CEREAL_NVP_("nullopt", false),
         CEREAL_NVP_("data", *optional));
    }
  }

  //! Loading for std::optional
  template <class Archive, typename T> inline
  void CEREAL_LOAD_FUNCTION_NAME(Archive& ar, std::optional<T>& optional)
  {
    bool nullopt;
    ar(CEREAL_NVP_("nullopt", nullopt));

    if (nullopt) {
      optional = std::nullopt;
    } else {
      T value;
      ar(CEREAL_NVP_("data", value));
      optional = std::move(value);
    }
  }
} // namespace cereal

#endif // CEREAL_TYPES_STD_OPTIONAL_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/polymorphic.hpp
================================================
/*! \file polymorphic.hpp
    \brief Support for pointers to polymorphic base classes
    \ingroup OtherTypes */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_POLYMORPHIC_HPP_
#define CEREAL_TYPES_POLYMORPHIC_HPP_

#include "cereal/cereal.hpp"
#include "cereal/types/memory.hpp"

#include "cereal/details/util.hpp"
#include "cereal/details/helpers.hpp"
#include "cereal/details/traits.hpp"
#include "cereal/details/polymorphic_impl.hpp"

#ifdef _MSC_VER
#define CEREAL_STATIC_CONSTEXPR static
#else
#define CEREAL_STATIC_CONSTEXPR static constexpr
#endif

//! Registers a derived polymorphic type with cereal
/*! Polymorphic types must be registered before smart
    pointers to them can be serialized.  Note that base
    classes do not need to be registered.

    Registering a type lets cereal know how to properly
    serialize it when a smart pointer to a base object is
    used in conjunction with a derived class.

    This assumes that all relevant archives have also
    previously been registered.  Registration for archives
    is usually done in the header file in which they are
    defined.  This means that type registration needs to
    happen after specific archives to be used are included.

    It is recommended that type registration be done in
    the header file in which the type is declared.

    Registration can also be placed in a source file,
    but this may require the use of the
    CEREAL_REGISTER_DYNAMIC_INIT macro (see below).

    Registration may be called repeatedly for the same
    type in different translation units to add support
    for additional archives if they are not initially
    available (included and registered).

    When building serialization support as a DLL on
    Windows, registration must happen in the header file.
    On Linux and Mac things should still work properly
    if placed in a source file, but see the above comments
    on registering in source files.

    Polymorphic support in cereal requires RTTI to be
    enabled */
#define CEREAL_REGISTER_TYPE(...)                                        \
  namespace cereal {                                                     \
  namespace detail {                                                     \
  template <>                                                            \
  struct binding_name<__VA_ARGS__>                                       \
  {                                                                      \
    CEREAL_STATIC_CONSTEXPR char const * name() { return #__VA_ARGS__; } \
  };                                                                     \
  } } /* end namespaces */                                               \
  CEREAL_BIND_TO_ARCHIVES(__VA_ARGS__)

//! Registers a polymorphic type with cereal, giving it a
//! user defined name
/*! In some cases the default name used with
    CEREAL_REGISTER_TYPE (the name of the type) may not be
    suitable.  This macro allows any name to be associated
    with the type.  The name should be unique */
#define CEREAL_REGISTER_TYPE_WITH_NAME(T, Name)                     \
  namespace cereal {                                                \
  namespace detail {                                                \
  template <>                                                       \
  struct binding_name<T>                                            \
  { CEREAL_STATIC_CONSTEXPR char const * name() { return Name; } }; \
  } } /* end namespaces */                                          \
  CEREAL_BIND_TO_ARCHIVES(T)

//! Registers the base-derived relationship for a polymorphic type
/*! When polymorphic serialization occurs, cereal needs to know how to
    properly cast between derived and base types for the polymorphic
    type. Normally this happens automatically whenever cereal::base_class
    or cereal::virtual_base_class are used to serialize a base class. In
    cases where neither of these is ever called but a base class still
    exists, this explicit registration is required.

    The Derived class should be the most derived type that will be serialized,
    and the Base type any possible base that has not been covered under a base
    class serialization that will be used to store a Derived pointer.

    Placement of this is the same as for CEREAL_REGISTER_TYPE. */
#define CEREAL_REGISTER_POLYMORPHIC_RELATION(Base, Derived)                     \
  namespace cereal {                                                            \
  namespace detail {                                                            \
  template <>                                                                   \
  struct PolymorphicRelation<Base, Derived>                                     \
  { static void bind() { RegisterPolymorphicCaster<Base, Derived>::bind(); } }; \
  } } /* end namespaces */

//! Adds a way to force initialization of a translation unit containing
//! calls to CEREAL_REGISTER_TYPE
/*! In C++, dynamic initialization of non-local variables of a translation
    unit may be deferred until "the first odr-use of any function or variable
    defined in the same translation unit as the variable to be initialized."

    Informally, odr-use means that your program takes the address of or binds
    a reference directly to an object, which must have a definition.

    Since polymorphic type support in cereal relies on the dynamic
    initialization of certain global objects happening before
    serialization is performed, it is important to ensure that something
    from files that call CEREAL_REGISTER_TYPE is odr-used before serialization
    occurs, otherwise the registration will never take place.  This may often
    be the case when serialization is built as a shared library external from
    your main program.

    This macro, with any name of your choosing, should be placed into the
    source file that contains calls to CEREAL_REGISTER_TYPE.

    Its counterpart, CEREAL_FORCE_DYNAMIC_INIT, should be placed in its
    associated header file such that it is included in the translation units
    (source files) in which you want the registration to appear.

    @relates CEREAL_FORCE_DYNAMIC_INIT
    */
#define CEREAL_REGISTER_DYNAMIC_INIT(LibName)                \
  namespace cereal {                                         \
  namespace detail {                                         \
    void CEREAL_DLL_EXPORT dynamic_init_dummy_##LibName() {} \
  } } /* end namespaces */

//! Forces dynamic initialization of polymorphic support in a
//! previously registered source file
/*! @sa CEREAL_REGISTER_DYNAMIC_INIT

    See CEREAL_REGISTER_DYNAMIC_INIT for detailed explanation
    of how this macro should be used.  The name used should
    match that for CEREAL_REGISTER_DYNAMIC_INIT. */
#define CEREAL_FORCE_DYNAMIC_INIT(LibName)                 \
  namespace cereal {                                       \
  namespace detail {                                       \
    void CEREAL_DLL_EXPORT dynamic_init_dummy_##LibName(); \
  } /* end detail */                                       \
  } /* end cereal */                                       \
  namespace {                                              \
    struct dynamic_init_##LibName {                        \
      dynamic_init_##LibName() {                           \
        ::cereal::detail::dynamic_init_dummy_##LibName();  \
      }                                                    \
    } dynamic_init_instance_##LibName;                     \
  } /* end anonymous namespace */

namespace cereal
{
  namespace polymorphic_detail
  {
    //! Error message used for unregistered polymorphic types
    /*! @internal */
    #define UNREGISTERED_POLYMORPHIC_EXCEPTION(LoadSave, Name)                                                                                      \
      throw cereal::Exception("Trying to " #LoadSave " an unregistered polymorphic type (" + Name + ").\n"                                          \
                              "Make sure your type is registered with CEREAL_REGISTER_TYPE and that the archive "                                   \
                              "you are using was included (and registered with CEREAL_REGISTER_ARCHIVE) prior to calling CEREAL_REGISTER_TYPE.\n"   \
                              "If your type is already registered and you still see this error, you may need to use CEREAL_REGISTER_DYNAMIC_INIT.");

    //! Get an input binding from the given archive by deserializing the type meta data
    /*! @internal */
    template<class Archive> inline
    typename ::cereal::detail::InputBindingMap<Archive>::Serializers getInputBinding(Archive & ar, std::uint32_t const nameid)
    {
      // If the nameid is zero, we serialized a null pointer
      if(nameid == 0)
      {
        typename ::cereal::detail::InputBindingMap<Archive>::Serializers emptySerializers;
        emptySerializers.shared_ptr = [](void*, std::shared_ptr<void> & ptr, std::type_info const &) { ptr.reset(); };
        emptySerializers.unique_ptr = [](void*, std::unique_ptr<void, ::cereal::detail::EmptyDeleter<void>> & ptr, std::type_info const &) { ptr.reset( nullptr ); };
        return emptySerializers;
      }

      std::string name;
      if(nameid & detail::msb_32bit)
      {
        ar( CEREAL_NVP_("polymorphic_name", name) );
        ar.registerPolymorphicName(nameid, name);
      }
      else
        name = ar.getPolymorphicName(nameid);

      auto const & bindingMap = detail::StaticObject<detail::InputBindingMap<Archive>>::getInstance().map;

      auto binding = bindingMap.find(name);
      if(binding == bindingMap.end())
        UNREGISTERED_POLYMORPHIC_EXCEPTION(load, name)
      return binding->second;
    }

    //! Serialize a shared_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
    /*! This check lets us try and skip doing polymorphic machinery if we can get away with
        using the derived class serialize function

        Note that on MSVC 2013 preview, is_default_constructible<T> returns true for abstract classes with
        default constructors, but on clang/gcc this will return false.  So we also need to check for that here.
        @internal */
    template<class Archive, class T> inline
    typename std::enable_if<(traits::is_default_constructible<T>::value
                             || traits::has_load_and_construct<T, Archive>::value)
                             && !std::is_abstract<T>::value, bool>::type
    serialize_wrapper(Archive & ar, std::shared_ptr<T> & ptr, std::uint32_t const nameid)
    {
      if(nameid & detail::msb2_32bit)
      {
        ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
        return true;
      }
      return false;
    }

    //! Serialize a unique_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
    /*! This check lets us try and skip doing polymorphic machinery if we can get away with
        using the derived class serialize function
        @internal */
    template<class Archive, class T, class D> inline
    typename std::enable_if<(traits::is_default_constructible<T>::value
                             || traits::has_load_and_construct<T, Archive>::value)
                             && !std::is_abstract<T>::value, bool>::type
    serialize_wrapper(Archive & ar, std::unique_ptr<T, D> & ptr, std::uint32_t const nameid)
    {
      if(nameid & detail::msb2_32bit)
      {
        ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
        return true;
      }
      return false;
    }

    //! Serialize a shared_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
    /*! This case is for when we can't actually construct the shared pointer.  Normally this would be caught
        as the pointer itself is serialized, but since this is a polymorphic pointer, if we tried to serialize
        the pointer we'd end up back here recursively.  So we have to catch the error here as well, if
        this was a polymorphic type serialized by its proper pointer type
        @internal */
    template<class Archive, class T> inline
    typename std::enable_if<(!traits::is_default_constructible<T>::value
                             && !traits::has_load_and_construct<T, Archive>::value)
                             || std::is_abstract<T>::value, bool>::type
    serialize_wrapper(Archive &, std::shared_ptr<T> &, std::uint32_t const nameid)
    {
      if(nameid & detail::msb2_32bit)
        throw cereal::Exception("Cannot load a polymorphic type that is not default constructable and does not have a load_and_construct function");
      return false;
    }

    //! Serialize a unique_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
    /*! This case is for when we can't actually construct the unique pointer.  Normally this would be caught
        as the pointer itself is serialized, but since this is a polymorphic pointer, if we tried to serialize
        the pointer we'd end up back here recursively.  So we have to catch the error here as well, if
        this was a polymorphic type serialized by its proper pointer type
        @internal */
    template<class Archive, class T, class D> inline
     typename std::enable_if<(!traits::is_default_constructible<T>::value
                               && !traits::has_load_and_construct<T, Archive>::value)
                               || std::is_abstract<T>::value, bool>::type
    serialize_wrapper(Archive &, std::unique_ptr<T, D> &, std::uint32_t const nameid)
    {
      if(nameid & detail::msb2_32bit)
        throw cereal::Exception("Cannot load a polymorphic type that is not default constructable and does not have a load_and_construct function");
      return false;
    }
  } // polymorphic_detail

  // ######################################################################
  // Pointer serialization for polymorphic types

  //! Saving std::shared_ptr for polymorphic types, abstract
  template <class Archive, class T> inline
  typename std::enable_if<std::is_polymorphic<T>::value && std::is_abstract<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
  {
    if(!ptr)
    {
      // same behavior as nullptr in memory implementation
      ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
      return;
    }

    std::type_info const & ptrinfo = typeid(*ptr.get());
    static std::type_info const & tinfo = typeid(T);
    // ptrinfo can never be equal to T info since we can't have an instance
    // of an abstract object
    //  this implies we need to do the lookup

    auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;

    auto binding = bindingMap.find(std::type_index(ptrinfo));
    if(binding == bindingMap.end())
      UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))

    binding->second.shared_ptr(&ar, ptr.get(), tinfo);
  }

  //! Saving std::shared_ptr for polymorphic types, not abstract
  template <class Archive, class T> inline
  typename std::enable_if<std::is_polymorphic<T>::value && !std::is_abstract<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
  {
    if(!ptr)
    {
      // same behavior as nullptr in memory implementation
      ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
      return;
    }

    std::type_info const & ptrinfo = typeid(*ptr.get());
    static std::type_info const & tinfo = typeid(T);

    if(ptrinfo == tinfo)
    {
      // The 2nd msb signals that the following pointer does not need to be
      // cast with our polymorphic machinery
      ar( CEREAL_NVP_("polymorphic_id", detail::msb2_32bit) );

      ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );

      return;
    }

    auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;

    auto binding = bindingMap.find(std::type_index(ptrinfo));
    if(binding == bindingMap.end())
      UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))

    binding->second.shared_ptr(&ar, ptr.get(), tinfo);
  }

  //! Loading std::shared_ptr for polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> & ptr )
  {
    std::uint32_t nameid;
    ar( CEREAL_NVP_("polymorphic_id", nameid) );

    // Check to see if we can skip all of this polymorphism business
    if(polymorphic_detail::serialize_wrapper(ar, ptr, nameid))
      return;

    auto binding = polymorphic_detail::getInputBinding(ar, nameid);
    std::shared_ptr<void> result;
    binding.shared_ptr(&ar, result, typeid(T));
    ptr = std::static_pointer_cast<T>(result);
  }

  //! Saving std::weak_ptr for polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> const & ptr )
  {
    auto const sptr = ptr.lock();
    ar( CEREAL_NVP_("locked_ptr", sptr) );
  }

  //! Loading std::weak_ptr for polymorphic types
  template <class Archive, class T> inline
  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> & ptr )
  {
    std::shared_ptr<T> sptr;
    ar( CEREAL_NVP_("locked_ptr", sptr) );
    ptr = sptr;
  }

  //! Saving std::unique_ptr for polymorphic types that are abstract
  template <class Archive, class T, class D> inline
  typename std::enable_if<std::is_polymorphic<T>::value && std::is_abstract<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
  {
    if(!ptr)
    {
      // same behavior as nullptr in memory implementation
      ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
      return;
    }

    std::type_info const & ptrinfo = typeid(*ptr.get());
    static std::type_info const & tinfo = typeid(T);
    // ptrinfo can never be equal to T info since we can't have an instance
    // of an abstract object
    //  this implies we need to do the lookup

    auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;

    auto binding = bindingMap.find(std::type_index(ptrinfo));
    if(binding == bindingMap.end())
      UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))

    binding->second.unique_ptr(&ar, ptr.get(), tinfo);
  }

  //! Saving std::unique_ptr for polymorphic types, not abstract
  template <class Archive, class T, class D> inline
  typename std::enable_if<std::is_polymorphic<T>::value && !std::is_abstract<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
  {
    if(!ptr)
    {
      // same behavior as nullptr in memory implementation
      ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
      return;
    }

    std::type_info const & ptrinfo = typeid(*ptr.get());
    static std::type_info const & tinfo = typeid(T);

    if(ptrinfo == tinfo)
    {
      // The 2nd msb signals that the following pointer does not need to be
      // cast with our polymorphic machinery
      ar( CEREAL_NVP_("polymorphic_id", detail::msb2_32bit) );

      ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );

      return;
    }

    auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;

    auto binding = bindingMap.find(std::type_index(ptrinfo));
    if(binding == bindingMap.end())
      UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))

    binding->second.unique_ptr(&ar, ptr.get(), tinfo);
  }

  //! Loading std::unique_ptr, case when user provides load_and_construct for polymorphic types
  template <class Archive, class T, class D> inline
  typename std::enable_if<std::is_polymorphic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> & ptr )
  {
    std::uint32_t nameid;
    ar( CEREAL_NVP_("polymorphic_id", nameid) );

    // Check to see if we can skip all of this polymorphism business
    if(polymorphic_detail::serialize_wrapper(ar, ptr, nameid))
      return;

    auto binding = polymorphic_detail::getInputBinding(ar, nameid);
    std::unique_ptr<void, ::cereal::detail::EmptyDeleter<void>> result;
    binding.unique_ptr(&ar, result, typeid(T));
    ptr.reset(static_cast<T*>(result.release()));
  }

  #undef UNREGISTERED_POLYMORPHIC_EXCEPTION
} // namespace cereal
#endif // CEREAL_TYPES_POLYMORPHIC_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/queue.hpp
================================================
/*! \file queue.hpp
    \brief Support for types found in \<queue\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_QUEUE_HPP_
#define CEREAL_TYPES_QUEUE_HPP_

#include "cereal/details/helpers.hpp"
#include <queue>

// The default container for queue is deque, so let's include that too
#include "cereal/types/deque.hpp"
// The default comparator for queue is less
#include "cereal/types/functional.hpp"

namespace cereal
{
  namespace queue_detail
  {
    //! Allows access to the protected container in queue
    /*! @internal */
    template <class T, class C> inline
    C const & container( std::queue<T, C> const & queue )
    {
      struct H : public std::queue<T, C>
      {
        static C const & get( std::queue<T, C> const & q )
        {
          return q.*(&H::c);
        }
      };

      return H::get( queue );
    }

    //! Allows access to the protected container in priority queue
    /*! @internal */
    template <class T, class C, class Comp> inline
    C const & container( std::priority_queue<T, C, Comp> const & priority_queue )
    {
      struct H : public std::priority_queue<T, C, Comp>
      {
        static C const & get( std::priority_queue<T, C, Comp> const & pq )
        {
          return pq.*(&H::c);
        }
      };

      return H::get( priority_queue );
    }

    //! Allows access to the protected comparator in priority queue
    /*! @internal */
    template <class T, class C, class Comp> inline
    Comp const & comparator( std::priority_queue<T, C, Comp> const & priority_queue )
    {
      struct H : public std::priority_queue<T, C, Comp>
      {
        static Comp const & get( std::priority_queue<T, C, Comp> const & pq )
        {
          return pq.*(&H::comp);
        }
      };

      return H::get( priority_queue );
    }
  }

  //! Saving for std::queue
  template <class Archive, class T, class C> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::queue<T, C> const & queue )
  {
    ar( CEREAL_NVP_("container", queue_detail::container( queue )) );
  }

  //! Loading for std::queue
  template <class Archive, class T, class C> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::queue<T, C> & queue )
  {
    C container;
    ar( CEREAL_NVP_("container", container) );
    queue = std::queue<T, C>( std::move( container ) );
  }

  //! Saving for std::priority_queue
  template <class Archive, class T, class C, class Comp> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> const & priority_queue )
  {
    ar( CEREAL_NVP_("comparator", queue_detail::comparator( priority_queue )) );
    ar( CEREAL_NVP_("container", queue_detail::container( priority_queue )) );
  }

  //! Loading for std::priority_queue
  template <class Archive, class T, class C, class Comp> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> & priority_queue )
  {
    Comp comparator;
    ar( CEREAL_NVP_("comparator", comparator) );

    C container;
    ar( CEREAL_NVP_("container", container) );

    priority_queue = std::priority_queue<T, C, Comp>( comparator, std::move( container ) );
  }
} // namespace cereal

#endif // CEREAL_TYPES_QUEUE_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/set.hpp
================================================
/*! \file set.hpp
    \brief Support for types found in \<set\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_SET_HPP_
#define CEREAL_TYPES_SET_HPP_

#include "cereal/cereal.hpp"
#include <set>

namespace cereal
{
  namespace set_detail
  {
    //! @internal
    template <class Archive, class SetT> inline
    void save( Archive & ar, SetT const & set )
    {
      ar( make_size_tag( static_cast<size_type>(set.size()) ) );

      for( const auto & i : set )
        ar( i );
    }

    //! @internal
    template <class Archive, class SetT> inline
    void load( Archive & ar, SetT & set )
    {
      size_type size;
      ar( make_size_tag( size ) );

      set.clear();

      auto hint = set.begin();
      for( size_type i = 0; i < size; ++i )
      {
        typename SetT::key_type key;

        ar( key );
        #ifdef CEREAL_OLDER_GCC
        hint = set.insert( hint, std::move( key ) );
        #else // NOT CEREAL_OLDER_GCC
        hint = set.emplace_hint( hint, std::move( key ) );
        #endif // NOT CEREAL_OLDER_GCC
      }
    }
  }

  //! Saving for std::set
  template <class Archive, class K, class C, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::set<K, C, A> const & set )
  {
    set_detail::save( ar, set );
  }

  //! Loading for std::set
  template <class Archive, class K, class C, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::set<K, C, A> & set )
  {
    set_detail::load( ar, set );
  }

  //! Saving for std::multiset
  template <class Archive, class K, class C, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> const & multiset )
  {
    set_detail::save( ar, multiset );
  }

  //! Loading for std::multiset
  template <class Archive, class K, class C, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> & multiset )
  {
    set_detail::load( ar, multiset );
  }
} // namespace cereal

#endif // CEREAL_TYPES_SET_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/stack.hpp
================================================
/*! \file stack.hpp
    \brief Support for types found in \<stack\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STACK_HPP_
#define CEREAL_TYPES_STACK_HPP_

#include "cereal/cereal.hpp"
#include <stack>

// The default container for stack is deque, so let's include that too
#include "cereal/types/deque.hpp"

namespace cereal
{
  namespace stack_detail
  {
    //! Allows access to the protected container in stack
    template <class T, class C> inline
    C const & container( std::stack<T, C> const & stack )
    {
      struct H : public std::stack<T, C>
      {
        static C const & get( std::stack<T, C> const & s )
        {
          return s.*(&H::c);
        }
      };

      return H::get( stack );
    }
  }

  //! Saving for std::stack
  template <class Archive, class T, class C> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::stack<T, C> const & stack )
  {
    ar( CEREAL_NVP_("container", stack_detail::container( stack )) );
  }

  //! Loading for std::stack
  template <class Archive, class T, class C> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::stack<T, C> & stack )
  {
    C container;
    ar( CEREAL_NVP_("container", container) );
    stack = std::stack<T, C>( std::move( container ) );
  }
} // namespace cereal

#endif // CEREAL_TYPES_STACK_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/string.hpp
================================================
/*! \file string.hpp
    \brief Support for types found in \<string\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STRING_HPP_
#define CEREAL_TYPES_STRING_HPP_

#include "cereal/cereal.hpp"
#include <string>

namespace cereal
{
  //! Serialization for basic_string types, if binary data is supported
  template<class Archive, class CharT, class Traits, class Alloc> inline
  typename std::enable_if<traits::is_output_serializable<BinaryData<CharT>, Archive>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
  {
    // Save number of chars + the data
    ar( make_size_tag( static_cast<size_type>(str.size()) ) );
    ar( binary_data( str.data(), str.size() * sizeof(CharT) ) );
  }

  //! Serialization for basic_string types, if binary data is supported
  template<class Archive, class CharT, class Traits, class Alloc> inline
  typename std::enable_if<traits::is_input_serializable<BinaryData<CharT>, Archive>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> & str)
  {
    size_type size;
    ar( make_size_tag( size ) );
    str.resize(static_cast<std::size_t>(size));
    ar( binary_data( const_cast<CharT *>( str.data() ), static_cast<std::size_t>(size) * sizeof(CharT) ) );
  }
} // namespace cereal

#endif // CEREAL_TYPES_STRING_HPP_



================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/tuple.hpp
================================================
/*! \file tuple.hpp
    \brief Support for types found in \<tuple\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_TUPLE_HPP_
#define CEREAL_TYPES_TUPLE_HPP_

#include "cereal/cereal.hpp"
#include <tuple>

namespace cereal
{
  namespace tuple_detail
  {
    //! Creates a c string from a sequence of characters
    /*! The c string created will always be prefixed by "tuple_element"
        Based on code from: http://stackoverflow/a/20973438/710791
        @internal */
    template<char...Cs>
    struct char_seq_to_c_str
    {
      static const int size = 14;// Size of array for the word: tuple_element
      typedef const char (&arr_type)[sizeof...(Cs) + size];
      static const char str[sizeof...(Cs) + size];
    };

    // the word tuple_element plus a number
    //! @internal
    template<char...Cs>
    const char char_seq_to_c_str<Cs...>::str[sizeof...(Cs) + size] =
      {'t','u','p','l','e','_','e','l','e','m','e','n','t', Cs..., '\0'};

    //! Converts a number into a sequence of characters
    /*! @tparam Q The quotient of dividing the original number by 10
        @tparam R The remainder of dividing the original number by 10
        @tparam C The sequence built so far
        @internal */
    template <size_t Q, size_t R, char ... C>
    struct to_string_impl
    {
      using type = typename to_string_impl<Q/10, Q%10, static_cast<char>(R+std::size_t{'0'}), C...>::type;
    };

    //! Base case with no quotient
    /*! @internal */
    template <size_t R, char ... C>
    struct to_string_impl<0, R, C...>
    {
      using type = char_seq_to_c_str<static_cast<char>(R+std::size_t{'0'}), C...>;
    };

    //! Generates a c string for a given index of a tuple
    /*! Example use:
        @code{cpp}
        tuple_element_name<3>::c_str();// returns "tuple_element3"
        @endcode
        @internal */
    template<size_t T>
    struct tuple_element_name
    {
      using type = typename to_string_impl<T/10, T%10>::type;
      static const typename type::arr_type c_str(){ return type::str; }
    };

    // unwinds a tuple to save it
    //! @internal
    template <size_t Height>
    struct serialize
    {
      template <class Archive, class ... Types> inline
      static void apply( Archive & ar, std::tuple<Types...> & tuple )
      {
        serialize<Height - 1>::template apply( ar, tuple );
        ar( CEREAL_NVP_(tuple_element_name<Height - 1>::c_str(),
            std::get<Height - 1>( tuple )) );
      }
    };

    // Zero height specialization - nothing to do here
    //! @internal
    template <>
    struct serialize<0>
    {
      template <class Archive, class ... Types> inline
      static void apply( Archive &, std::tuple<Types...> & )
      { }
    };
  }

  //! Serializing for std::tuple
  template <class Archive, class ... Types> inline
  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::tuple<Types...> & tuple )
  {
    tuple_detail::serialize<std::tuple_size<std::tuple<Types...>>::value>::template apply( ar, tuple );
  }
} // namespace cereal

#endif // CEREAL_TYPES_TUPLE_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/unordered_map.hpp
================================================
/*! \file unordered_map.hpp
    \brief Support for types found in \<unordered_map\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UNORDERED_MAP_HPP_
#define CEREAL_TYPES_UNORDERED_MAP_HPP_

#include "cereal/types/concepts/pair_associative_container.hpp"
#include <unordered_map>

#endif // CEREAL_TYPES_UNORDERED_MAP_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/unordered_set.hpp
================================================
/*! \file unordered_set.hpp
    \brief Support for types found in \<unordered_set\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UNORDERED_SET_HPP_
#define CEREAL_TYPES_UNORDERED_SET_HPP_

#include "cereal/cereal.hpp"
#include <unordered_set>

namespace cereal
{
  namespace unordered_set_detail
  {
    //! @internal
    template <class Archive, class SetT> inline
    void save( Archive & ar, SetT const & set )
    {
      ar( make_size_tag( static_cast<size_type>(set.size()) ) );

      for( const auto & i : set )
        ar( i );
    }

    //! @internal
    template <class Archive, class SetT> inline
    void load( Archive & ar, SetT & set )
    {
      size_type size;
      ar( make_size_tag( size ) );

      set.clear();
      set.reserve( static_cast<std::size_t>( size ) );

      for( size_type i = 0; i < size; ++i )
      {
        typename SetT::key_type key;

        ar( key );
        set.emplace( std::move( key ) );
      }
    }
  }

  //! Saving for std::unordered_set
  template <class Archive, class K, class H, class KE, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> const & unordered_set )
  {
    unordered_set_detail::save( ar, unordered_set );
  }

  //! Loading for std::unordered_set
  template <class Archive, class K, class H, class KE, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> & unordered_set )
  {
    unordered_set_detail::load( ar, unordered_set );
  }

  //! Saving for std::unordered_multiset
  template <class Archive, class K, class H, class KE, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> const & unordered_multiset )
  {
    unordered_set_detail::save( ar, unordered_multiset );
  }

  //! Loading for std::unordered_multiset
  template <class Archive, class K, class H, class KE, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> & unordered_multiset )
  {
    unordered_set_detail::load( ar, unordered_multiset );
  }
} // namespace cereal

#endif // CEREAL_TYPES_UNORDERED_SET_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/utility.hpp
================================================
/*! \file utility.hpp
    \brief Support for types found in \<utility\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UTILITY_HPP_
#define CEREAL_TYPES_UTILITY_HPP_

#include "cereal/cereal.hpp"
#include <utility>

namespace cereal
{
  //! Serializing for std::pair
  template <class Archive, class T1, class T2> inline
  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::pair<T1, T2> & pair )
  {
    ar( CEREAL_NVP_("first",  pair.first),
        CEREAL_NVP_("second", pair.second) );
  }
} // namespace cereal

#endif // CEREAL_TYPES_UTILITY_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/valarray.hpp
================================================
/*! \file valarray.hpp
\brief Support for types found in \<valarray\>
\ingroup STLSupport */

/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CEREAL_TYPES_VALARRAY_HPP_
#define CEREAL_TYPES_VALARRAY_HPP_

#include "cereal/cereal.hpp"
#include <valarray>

namespace cereal
{
  //! Saving for std::valarray arithmetic types, using binary serialization, if supported
  template <class Archive, class T> inline
  typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
  {
    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
    ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous
  }

  //! Loading for std::valarray arithmetic types, using binary serialization, if supported
  template <class Archive, class T> inline
  typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
  {
    size_type valarraySize;
    ar( make_size_tag( valarraySize ) );

    valarray.resize( static_cast<std::size_t>( valarraySize ) );
    ar( binary_data( &valarray[0], static_cast<std::size_t>( valarraySize ) * sizeof(T) ) );
  }

  //! Saving for std::valarray all other types
  template <class Archive, class T> inline
  typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
  {
    ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
    for(auto && v : valarray)
      ar(v);
  }

  //! Loading for std::valarray all other types
  template <class Archive, class T> inline
  typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
  {
    size_type valarraySize;
    ar( make_size_tag( valarraySize ) );

    valarray.resize( static_cast<size_t>( valarraySize ) );
    for(auto && v : valarray)
      ar(v);
  }
} // namespace cereal

#endif // CEREAL_TYPES_VALARRAY_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/variant.hpp
================================================
/*! \file variant.hpp
    \brief Support for std::variant
    \ingroup STLSupport */
/*
  Copyright (c) 2014, 2017, Randolph Voorhies, Shane Grant, Juan Pedro
  Bolivar Puente. All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STD_VARIANT_HPP_
#define CEREAL_TYPES_STD_VARIANT_HPP_

#include "cereal/cereal.hpp"
#include <variant>
#include <cstdint>

namespace cereal
{
  namespace variant_detail
  {
    //! @internal
    template <class Archive>
    struct variant_save_visitor
    {
      variant_save_visitor(Archive & ar_) : ar(ar_) {}

      template<class T>
        void operator()(T const & value) const
        {
          ar( CEREAL_NVP_("data", value) );
        }

      Archive & ar;
    };

    //! @internal
    template<int N, class Variant, class ... Args, class Archive>
    typename std::enable_if<N == std::variant_size_v<Variant>, void>::type
    load_variant(Archive & /*ar*/, int /*target*/, Variant & /*variant*/)
    {
      throw ::cereal::Exception("Error traversing variant during load");
    }
    //! @internal
    template<int N, class Variant, class H, class ... T, class Archive>
    typename std::enable_if<N < std::variant_size_v<Variant>, void>::type
    load_variant(Archive & ar, int target, Variant & variant)
    {
      if(N == target)
      {
        H value;
        ar( CEREAL_NVP_("data", value) );
        variant = std::move(value);
      }
      else
        load_variant<N+1, Variant, T...>(ar, target, variant);
    }

  } // namespace variant_detail

  //! Saving for std::variant
  template <class Archive, typename VariantType1, typename... VariantTypes> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::variant<VariantType1, VariantTypes...> const & variant )
  {
    std::int32_t index = static_cast<std::int32_t>(variant.index());
    ar( CEREAL_NVP_("index", index) );
    variant_detail::variant_save_visitor<Archive> visitor(ar);
    std::visit(visitor, variant);
  }

  //! Loading for std::variant
  template <class Archive, typename... VariantTypes> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::variant<VariantTypes...> & variant )
  {
    using variant_t = typename std::variant<VariantTypes...>;

    std::int32_t index;
    ar( CEREAL_NVP_("index", index) );
    if(index >= static_cast<std::int32_t>(std::variant_size_v<variant_t>))
      throw Exception("Invalid 'index' selector when deserializing std::variant");

    variant_detail::load_variant<0, variant_t, VariantTypes...>(ar, index, variant);
  }

  //! Serializing a std::monostate
  template <class Archive>
  void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, std::monostate const & ) {}
} // namespace cereal

#endif // CEREAL_TYPES_STD_VARIANT_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/types/vector.hpp
================================================
/*! \file vector.hpp
    \brief Support for types found in \<vector\>
    \ingroup STLSupport */
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_VECTOR_HPP_
#define CEREAL_TYPES_VECTOR_HPP_

#include "cereal/cereal.hpp"
#include <vector>

namespace cereal
{
  //! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
  template <class Archive, class T, class A> inline
  typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
  {
    ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
    ar( binary_data( vector.data(), vector.size() * sizeof(T) ) );
  }

  //! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
  template <class Archive, class T, class A> inline
  typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
                          && std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
  {
    size_type vectorSize;
    ar( make_size_tag( vectorSize ) );

    vector.resize( static_cast<std::size_t>( vectorSize ) );
    ar( binary_data( vector.data(), static_cast<std::size_t>( vectorSize ) * sizeof(T) ) );
  }

  //! Serialization for non-arithmetic vector types
  template <class Archive, class T, class A> inline
  typename std::enable_if<(!traits::is_output_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
  CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
  {
    ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
    for(auto && v : vector)
      ar( v );
  }

  //! Serialization for non-arithmetic vector types
  template <class Archive, class T, class A> inline
  typename std::enable_if<(!traits::is_input_serializable<BinaryData<T>, Archive>::value
                          || !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
  CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
  {
    size_type size;
    ar( make_size_tag( size ) );

    vector.resize( static_cast<std::size_t>( size ) );
    for(auto && v : vector)
      ar( v );
  }

  //! Serialization for bool vector types
  template <class Archive, class A> inline
  void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<bool, A> const & vector )
  {
    ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
    for(const auto v : vector)
      ar( static_cast<bool>(v) );
  }

  //! Serialization for bool vector types
  template <class Archive, class A> inline
  void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<bool, A> & vector )
  {
    size_type size;
    ar( make_size_tag( size ) );

    vector.resize( static_cast<std::size_t>( size ) );
    for(auto v : vector)
    {
      bool b;
      ar( b );
      v = b;
    }
  }
} // namespace cereal

#endif // CEREAL_TYPES_VECTOR_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/include/cereal/version.hpp
================================================
/*! \file version.hpp
    \brief Macros to detect cereal version

    These macros can assist in determining the version of cereal. Be
    warned that cereal is not guaranteed to be compatible across
    different versions. For more information on releases of cereal,
    see https://github.com/USCiLab/cereal/releases.

    \ingroup utility */
/*
  Copyright (c) 2018, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CEREAL_VERSION_HPP_
#define CEREAL_VERSION_HPP_

//! The major version
#define CEREAL_VERSION_MAJOR 1
//! The minor version
#define CEREAL_VERSION_MINOR 3
//! The patch version
#define CEREAL_VERSION_PATCH 0

//! The full version as a single number
#define CEREAL_VERSION (CEREAL_VERSION_MAJOR * 10000 \
                        + CEREAL_VERSION_MINOR * 100 \
                        + CEREAL_VERSION_PATCH)

#endif // CEREAL_VERSION_HPP_


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/CMakeLists.txt
================================================
add_subdirectory(sandbox_shared_lib)

add_executable(sandbox sandbox.cpp)
add_executable(sandbox_json sandbox_json.cpp)
add_executable(sandbox_rtti sandbox_rtti.cpp)

add_executable(sandbox_vs sandbox_vs.cpp)
target_link_libraries(sandbox_vs sandbox_vs_dll)
include_directories(sandbox_shared_lib)

if((Boost_FOUND) AND NOT SKIP_PERFORMANCE_COMPARISON)
  add_executable(performance performance.cpp)
  if(MSVC)
    set_target_properties(performance PROPERTIES COMPILE_DEFINITIONS "BOOST_SERIALIZATION_DYN_LINK")
  endif()
  target_link_libraries(performance ${Boost_LIBRARIES})
endif()


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/performance.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable : 4244 4267)
#endif

// fix for old versions of boost + deprecated auto_ptr
#define BOOST_NO_AUTO_PTR

#include <sstream>
#include <iostream>
#include <chrono>
#include <random>

#include <boost/format.hpp>

#include <boost/serialization/serialization.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/base_object.hpp>

#include <cereal/archives/binary.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/map.hpp>

//! Runs serialization to save data to an ostringstream
/*! Used to time how long it takes to save data to an ostringstream.
    Everything that happens within the save function will be timed, including
    any set-up necessary to perform the serialization.

    @param data The data to save
    @param saveFunction A function taking in an ostringstream and the data and returning void
    @return The ostringstream and the time it took to save the data */
template <class T>
std::chrono::nanoseconds
saveData( T const & data, std::function<void(std::ostringstream &, T const&)> saveFunction, std::ostringstream & os )
{
  auto start = std::chrono::high_resolution_clock::now();
  saveFunction( os, data );
  return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now() - start );
}

//! Runs serialization to load data to from an istringstream
/*! Used to time how long it takes to load data from an istringstream.
    Everything that happens within the load function will be timed, including
    any set-up necessary to perform the serialization.

    @param dataStream The saved data stream
    @param loadFunction A function taking in an istringstream and a data reference and returning void
    @return The loaded data and the time it took to save the data */
template <class T>
std::pair<T, std::chrono::nanoseconds>
loadData( std::ostringstream const & dataStream, std::function<void(std::istringstream &, T &)> loadFunction )
{
  T data;
  std::istringstream os( dataStream.str() );

  auto start = std::chrono::high_resolution_clock::now();
  loadFunction( os, data );

  return {data, std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now() - start )};
}

struct cerealBinary
{
  //! Saves data to a cereal binary archive
  template <class T>
  static void save( std::ostringstream & os, T const & data )
  {
    cereal::BinaryOutputArchive oar(os);
    oar(data);
  }

  //! Loads data to a cereal binary archive
  template <class T>
  static void load( std::istringstream & is, T & data )
  {
    cereal::BinaryInputArchive iar(is);
    iar(data);
  }
};

struct boostBinary
{
  //! Saves data to a boost binary archive
  template <class T>
  static void save( std::ostringstream & os, T const & data )
  {
    boost::archive::binary_oarchive oar(os);
    oar & data;
  }

  //! Loads data to a boost binary archive
  template <class T>
  static void load( std::istringstream & is, T & data )
  {
    boost::archive::binary_iarchive iar(is);
    iar & data;
  }
};

struct binary
{
  typedef boostBinary  boost;
  typedef cerealBinary cereal;
};

//! Times how long it takes to serialize (load and store) some data
/*! Times how long and the size of the serialization object used to serialize
    some data.  Result is output to standard out.

    @tparam SerializationT The serialization struct that has all save and load functions
    @tparam DataTCereal The type of data to test for cereal
    @tparam DataTBoost The type of data to test for boost
    @param name The name for this test
    @param data The data to serialize for cereal
    @param data The data to serialize for boost
    @param numAverages The number of times to average
    @param validateData Whether data should be validated (input == output) */
template <class SerializationT, class DataTCereal, class DataTBoost>
void test( std::string const & name,
            DataTCereal const & dataC,
            DataTBoost const & dataB,
            size_t numAverages = 100,
            bool validateData = false );

template <class SerializationT, class DataTCereal, class DataTBoost>
void test( std::string const & name,
            DataTCereal const & dataC,
            DataTBoost const & dataB,
            size_t numAverages,
            bool /*validateData*/ )
{
  std::cout << "-----------------------------------" << std::endl;
  std::cout << "Running test: " << name << std::endl;

  std::chrono::nanoseconds totalBoostSave{0};
  std::chrono::nanoseconds totalBoostLoad{0};

  std::chrono::nanoseconds totalCerealSave{0};
  std::chrono::nanoseconds totalCerealLoad{0};

  size_t boostSize = 0;
  size_t cerealSize = 0;

  for(size_t i = 0; i < numAverages; ++i)
  {
    // Boost
    {
      std::ostringstream os;
      auto saveResult = saveData<DataTBoost>( dataB, {SerializationT::boost::template save<DataTBoost>}, os );
      totalBoostSave += saveResult;
      if(!boostSize)
        boostSize = os.tellp();

      auto loadResult = loadData<DataTBoost>( os, {SerializationT::boost::template load<DataTBoost>} );
      totalBoostLoad += loadResult.second;
    }

    // Cereal
    {
      std::ostringstream os;
      auto saveResult = saveData<DataTCereal>( dataC, {SerializationT::cereal::template save<DataTCereal>}, os );
      totalCerealSave += saveResult;
      if(!cerealSize)
        cerealSize = os.tellp();

      auto loadResult = loadData<DataTCereal>( os, {SerializationT::cereal::template load<DataTCereal>} );
      totalCerealLoad += loadResult.second;
    }
  }

  // Averages
  double averageBoostSave = std::chrono::duration_cast<std::chrono::milliseconds>(totalBoostSave).count() / static_cast<double>( numAverages );
  double averageBoostLoad = std::chrono::duration_cast<std::chrono::milliseconds>(totalBoostLoad).count() / static_cast<double>( numAverages );

  double averageCerealSave = std::chrono::duration_cast<std::chrono::milliseconds>(totalCerealSave).count() / static_cast<double>( numAverages );
  double averageCerealLoad = std::chrono::duration_cast<std::chrono::milliseconds>(totalCerealLoad).count() / static_cast<double>( numAverages );

  // Percentages relative to boost
  double cerealSaveP = averageCerealSave / averageBoostSave;
  double cerealLoadP = averageCerealLoad / averageBoostLoad;
  double cerealSizeP = cerealSize / static_cast<double>( boostSize );

  std::cout << "  Boost results:" << std::endl;
  std::cout << boost::format("\tsave | time: %06.4fms (%1.2f) size: %20.8fkb (%1.8f) total: %6.1fms")
    % averageBoostSave % 1.0 % (boostSize / 1024.0) % 1.0 % static_cast<double>( std::chrono::duration_cast<std::chrono::milliseconds>(totalBoostSave).count() );
  std::cout << std::endl;
  std::cout << boost::format("\tload | time: %06.4fms (%1.2f) total: %6.1fms")
    % averageBoostLoad % 1.0 % static_cast<double>( std::chrono::duration_cast<std::chrono::milliseconds>(totalBoostLoad).count() );
  std::cout << std::endl;

  std::cout << "  Cereal results:" << std::endl;
  std::cout << boost::format("\tsave | time: %06.4fms (%1.2f) size: %20.8fkb (%1.8f) total: %6.1fms")
    % averageCerealSave % cerealSaveP % (cerealSize / 1024.0) % cerealSizeP % static_cast<double>( std::chrono::duration_cast<std::chrono::milliseconds>(totalCerealSave).count() );
  std::cout << std::endl;
  std::cout << boost::format("\tload | time: %06.4fms (%1.2f) total: %6.1fms")
    % averageCerealLoad % cerealLoadP % static_cast<double>( std::chrono::duration_cast<std::chrono::milliseconds>(totalCerealLoad).count() );
  std::cout << std::endl;
}

template <class SerializationT, class DataT>
void test( std::string const & name,
            DataT const & data,
            size_t numAverages = 100,
            bool validateData = false )
{
  return test<SerializationT, DataT, DataT>( name, data, data, numAverages, validateData );
}

template<class T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
random_value(std::mt19937 & gen)
{ return std::uniform_real_distribution<T>(-10000.0, 10000.0)(gen); }

template<class T>
typename std::enable_if<std::is_integral<T>::value && sizeof(T) != sizeof(char), T>::type
random_value(std::mt19937 & gen)
{ return std::uniform_int_distribution<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen); }

template<class T>
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(char), T>::type
random_value(std::mt19937 & gen)
{ return static_cast<T>( std::uniform_int_distribution<int64_t>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen) ); }

template<class T>
typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type
random_value(std::mt19937 & gen)
{
  std::string s(std::uniform_int_distribution<int>(3, 30)(gen), ' ');
  for(char & c : s)
    c = std::uniform_int_distribution<char>(' ', '~')(gen);
  return s;
}

template<class C>
std::basic_string<C> random_basic_string(std::mt19937 & gen, size_t maxSize = 30)
{
  std::basic_string<C> s(std::uniform_int_distribution<int>(3, maxSize)(gen), ' ');
  for(C & c : s)
    c = static_cast<C>( std::uniform_int_distribution<int>( '~', '~' )(gen) );
  return s;
  return s;
}

template <size_t N>
std::string random_binary_string(std::mt19937 & gen)
{
  std::string s(N, ' ');
  for(auto & c : s )
    c = std::uniform_int_distribution<char>('0', '1')(gen);
  return s;
}

struct PoDStructCereal
{
  int32_t a;
  int64_t b;
  float c;
  double d;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar(a, b, c, d);
  }
};

struct PoDStructBoost
{
  int32_t a;
  int64_t b;
  float c;
  double d;

  template <class Archive>
  void serialize( Archive & ar, const unsigned int /*version*/ )
  {
    ar & a & b & c & d;
  }
};

struct PoDChildCereal : virtual PoDStructCereal
{
  PoDChildCereal() : v(1024)
  { }

  std::vector<float> v;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( cereal::virtual_base_class<PoDStructCereal>(this), v );
  }
};

struct PoDChildBoost : virtual PoDStructBoost
{
  PoDChildBoost() : v(1024)
  { }

  std::vector<float> v;

  template <class Archive>
  void serialize( Archive & ar, const unsigned int /*version*/ )
  {
    ar & boost::serialization::base_object<PoDStructBoost>(*this);
    ar & v;
  }
};

int main()
{
  std::random_device rd;
  std::mt19937 gen(rd());
  auto rngC = [&](){ return random_value<uint8_t>(gen); };
  auto rngD = [&](){ return random_value<double>(gen); };
  const bool randomize = false;

  //########################################
  auto vectorDoubleTest = [&](size_t s, bool randomize_)
  {
    std::ostringstream name;
    name << "Vector(double) size " << s;

    std::vector<double> data(s);
    if(randomize_)
      for( auto & d : data )
        d = rngD();

    test<binary>( name.str(), data );
  };

  vectorDoubleTest(1, randomize); // 8B
  vectorDoubleTest(16, randomize); // 128B
  vectorDoubleTest(1024, randomize); // 8KB
  vectorDoubleTest(1024*1024, randomize); // 8MB

  //########################################
  auto vectorCharTest = [&](size_t s, bool randomize_)
  {
    std::ostringstream name;
    name << "Vector(uint8_t) size " << s;

    std::vector<uint8_t> data(s);
    if(randomize_)
      for( auto & d : data )
        d = rngC();

    test<binary>( name.str(), data );
  };

  vectorCharTest(1024*1024*64, randomize);

  //########################################
  auto vectorPoDStructTest = [&](size_t s)
  {
    std::ostringstream name;
    name << "Vector(PoDStruct) size " << s;

    std::vector<PoDStructCereal> dataC(s);
    std::vector<PoDStructBoost> dataB(s);
    test<binary>( name.str(), dataC, dataB );
  };

  vectorPoDStructTest(1);
  vectorPoDStructTest(64);
  vectorPoDStructTest(1024);
  vectorPoDStructTest(1024*1024);
  vectorPoDStructTest(1024*1024*2);

  //########################################
  auto vectorPoDChildTest = [&](size_t s)
  {
    std::ostringstream name;
    name << "Vector(PoDChild) size " << s;

    std::vector<PoDChildCereal> dataC(s);
    std::vector<PoDChildBoost> dataB(s);
    test<binary>( name.str(), dataC, dataB );
  };

  vectorPoDChildTest(1024);
  vectorPoDChildTest(1024*32);

  //########################################
  auto stringTest = [&](size_t s)
  {
    std::ostringstream name;
    name << "String size " << s;

    std::string data = random_basic_string<char>(gen, s);
    std::cout << "data.size " << data.size() << std::endl;
    test<binary>( name.str(), data );
  };

  stringTest(200000);
  stringTest(2000000);
  stringTest(20000000);

  //########################################
  auto vectorStringTest = [&](size_t s)
  {
    std::ostringstream name;
    name << "Vector(String) size " << s;

    std::vector<std::string> data(s);
    for(size_t i=0; i<data.size(); ++i)
      data[i] = random_basic_string<char>(gen);

    test<binary>( name.str(), data );
  };

  vectorStringTest(512);
  vectorStringTest(1024);
  vectorStringTest(1024*64);
  vectorStringTest(1024*128);

  //########################################
  auto mapPoDStructTest = [&](size_t s)
  {
    std::ostringstream name;
    name << "Map(PoDStruct) size " <<s;

    std::map<std::string, PoDStructCereal> mC;
    std::map<std::string, PoDStructBoost> mB;
    for(size_t i=0; i<s; ++i)
    {
      mC[std::to_string( i )] = PoDStructCereal();
      mB[std::to_string( i )] = PoDStructBoost();
    }
    test<binary>(name.str(), mC, mB);
  };

  mapPoDStructTest(1024);
  mapPoDStructTest(1024*64);

  return 0;
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <cereal/cereal.hpp>
#include <cereal/archives/binary.hpp>
#include <cereal/archives/portable_binary.hpp>
#include <cereal/archives/xml.hpp>

#include <cereal/types/string.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/types/complex.hpp>
#include <cereal/types/base_class.hpp>
#include <cereal/types/array.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/bitset.hpp>
#include <cereal/types/polymorphic.hpp>

//#include <cxxabi.h>
#include <sstream>
#include <fstream>
#include <cassert>
#include <complex>
#include <iostream>
#include <random>

class Base
{
  private:
    friend class cereal::access;
    template <class Archive>
    void serialize( Archive & ar )
    {
      std::cout << "Base serialize" << std::endl;
      ar( x );
    }

    virtual void foo() = 0;

  public:
    int x;

    virtual ~Base() {}
};

class Derived : public Base
{
  public:
    using Base::x;
    Derived() : Base(), y() {}
    Derived( int d, int b )
    {
      y = d;
      x = b;
    }
    virtual ~Derived() {}

    template <class Archive>
    void save( Archive & ar ) const
    {
      ar( cereal::virtual_base_class<Base>(this) );
      std::cout << "Derived save" << std::endl;
      ar( y );
    }

    template <class Archive>
    void load( Archive & ar )
    {
      ar( cereal::virtual_base_class<Base>(this) );
      std::cout << "Derived load" << std::endl;
      ar( y );
    }

    void foo() {}

    int y;
};

namespace cereal
{
  template <class Archive> struct specialize<Archive, Derived, cereal::specialization::member_load_save> {};
}

CEREAL_REGISTER_TYPE(Derived)

// ###################################
struct Test1
{
  int a;

  private:
    friend class cereal::access;
    template<class Archive>
    void serialize(Archive & ar)
    {
      ar(CEREAL_NVP(a));
    }
};

// ###################################
class Test2
{
  public:
    Test2() {}
    Test2( int x ) : a( x ) {}
    int a;

  private:
    friend class cereal::access;

    template<class Archive>
      void save(Archive & ar) const
      {
        ar(a);
      }

    template<class Archive>
      void load(Archive & ar)
      {
        ar(a);
      }
};

// ###################################
struct Test3
{
  int a;
};

template<class Archive>
void serialize(Archive & ar, Test3 & t)
{
  ar(CEREAL_NVP(t.a));
}

namespace test4
{
  // ###################################
  struct Test4
  {
    int a;
  };

  template<class Archive>
  void save(Archive & ar, Test4 const & t)
  {
    ar(CEREAL_NVP(t.a));
  }

  template<class Archive>
  void load(Archive & ar, Test4 & t)
  {
    ar(CEREAL_NVP(t.a));
  }
}

class Private
{
  public:
    Private() : a('z') {}

  private:
    char a;

    friend class cereal::access;

    template<class Archive>
      void serialize(Archive & ar)
      {
        ar(a);
      }
};

struct Everything
{
  int x;
  int y;
  Test1 t1;
  Test2 t2;
  Test3 t3;
  test4::Test4 t4;
  std::string s;

  template<class Archive>
  void serialize(Archive & ar)
  {
    ar(CEREAL_NVP(x));
    ar(CEREAL_NVP(y));
    ar(CEREAL_NVP(t1));
    ar(CEREAL_NVP(t2));
    ar(CEREAL_NVP(t3));
    ar(CEREAL_NVP(t4));
    ar(CEREAL_NVP(s));
  }

  bool operator==(Everything const & o)
  {
    return
      x == o.x &&
      y == o.y &&
      t1.a == o.t1.a &&
      t2.a == o.t2.a &&
      t3.a == o.t3.a &&
      t4.a == o.t4.a &&
      s == o.s;
  }
};

struct EmptyStruct
{
  template<class Archive>
  void serialize(Archive &)
  {
    std::cout << "Side effects!" << std::endl;
  }
};

struct NonEmptyStruct
{
  int x, y, z;
};

struct NoDefaultCtor
{
private:
  NoDefaultCtor() {};
  int z;
  NoDefaultCtor( int x, bool ) :y(x) {}
public:
  NoDefaultCtor(int x) : y(x)
  { }

  friend class cereal::access;

  int y;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( y );
  }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<NoDefaultCtor> & construct )
  {
    int yy;
    ar( yy );
    construct( yy, true );
    construct->z = 33;
    construct.ptr()->z = 33;
  }
};

//namespace cereal
//{
//  template <>
//  struct LoadAndConstruct<NoDefaultCtor>
//  {
//    template <class Archive>
//    static void load_and_construct( Archive & ar, cereal::construct<NoDefaultCtor> & construct )
//    {
//      int y;
//      ar( y );
//      construct( y );
//    }
//  };
//}

struct unordered_naming
{
  int x;
  int y;
  int z;

  template <class Archive>
  void save( Archive & ar ) const
  {
    ar( CEREAL_NVP(x),
        CEREAL_NVP(z),
        CEREAL_NVP(y) );
  }

  template <class Archive>
  void load( Archive & ar )
  {
    ar( x,
        CEREAL_NVP(y),
        CEREAL_NVP(z) );
  }

  bool operator==( unordered_naming const & other ) const
  {
    return x == other.x && y == other.y && z == other.z;
  }
};

std::ostream& operator<<(std::ostream& os, unordered_naming const & s)
{
  os << "[x: " << s.x << " y: " << s.y << " z: " << s.z << "]";
  return os;
}

template <class IArchive, class OArchive>
void test_unordered_loads()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rngI = [](){ return 1; };
  auto rngF = [](){ return 2.0f; };
  auto rngD = [](){ return 3.2; };

  for(int i=0; i<100; ++i)
  {
    auto const name1 = "1";
    auto const name2 = "2";
    auto const name3 = "3";
    auto const name4 = "4";
    auto const name5 = "5";
    auto const name6 = "6";
    auto const name7 = "7";

    int o_int1 = rngI();
    double o_double2 = rngD();
    std::vector<bool> o_vecbool3 = { true, false, true, false, true };
    int o_int4 = rngI();
    int o_int5 = rngI();
    int o_int6 = rngI();
    std::pair<float, unordered_naming> o_un7;
    o_un7.first = rngF();
    o_un7.second.x = rngI();
    o_un7.second.y = rngI();
    o_un7.second.z = rngI();

    {
      std::ofstream os("test.xml");
      OArchive oar(os);

      oar( cereal::make_nvp( name1, o_int1 ),
           cereal::make_nvp( name2, o_double2 ),
           cereal::make_nvp( name3, o_vecbool3 ),
           cereal::make_nvp( name4, o_int4 ),
           cereal::make_nvp( name5, o_int5 ),
           cereal::make_nvp( name6, o_int6 ),
           cereal::make_nvp( name7, o_un7 ) );
    }

    decltype(o_int1) i_int1;
    decltype(o_double2) i_double2;
    decltype(o_vecbool3) i_vecbool3;
    decltype(o_int4) i_int4;
    decltype(o_int5) i_int5;
    decltype(o_int6) i_int6;
    decltype(o_un7) i_un7;

    std::ifstream is("test.xml");
    {
      IArchive iar(is);

      iar( cereal::make_nvp( name7, o_un7 ),
           cereal::make_nvp( name2, i_double2 ),
           cereal::make_nvp( name4, i_int4 ),
           cereal::make_nvp( name3, i_vecbool3 ),
           cereal::make_nvp( name1, i_int1 ),
           cereal::make_nvp( name5, i_int5 ),
           i_int6,
           i_un7 );
    }
  }
}

class BoostTransitionMS
{
  public:
    BoostTransitionMS() {}
    BoostTransitionMS( int xx ) : x(xx) {}

    int getX(){ return x; }
    void setX( int xx ){ x = xx; }

  private:
    friend class cereal::access;
    int x;

    template <class Archive>
    void serialize( Archive & ar, const std::uint32_t /*version*/ )
    { ar( x ); }
};

class BoostTransitionSplit
{
  public:
    BoostTransitionSplit() {}
    BoostTransitionSplit( int xx ) : x(xx) {}

    int getX(){ return x; }
    void setX( int xx ){ x = xx; }

  private:
    friend class cereal::access;
    int x;

    template <class Archive>
    void save( Archive & ar, const std::uint32_t /*version*/ ) const
    { ar( x ); }

    template <class Archive>
    void load( Archive & ar, const std::uint32_t /*version*/ )
    { ar( x ); }
};

class BoostTransitionNMS
{
  public:
    BoostTransitionNMS() {}
    BoostTransitionNMS( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void serialize( Archive & ar, BoostTransitionNMS & bnms, const std::uint32_t version )
{ ar( bnms.x ); std::cout << "NMS version: " << version << std::endl; }

struct BoostTransitionNMSplit
{
  public:
    BoostTransitionNMSplit() {}
    BoostTransitionNMSplit( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void save( Archive & ar, BoostTransitionNMSplit const & bnsplit, const std::uint32_t version )
{ ar( bnsplit.x ); std::cout << "NMsave version: " << version << std::endl; }

template <class Archive>
void load( Archive & ar, BoostTransitionNMSplit & bnsplit, const std::uint32_t version )
{ ar( bnsplit.x ); std::cout << "NMload version: " << version << std::endl; }

// ######################################################################
int main()
{
  std::cout << std::boolalpha << std::endl;

  Everything e_out;
  e_out.x = 99;
  e_out.y = 100;
  e_out.t1 = {1};
  e_out.t2 = {2};
  e_out.t3 = {3};
  e_out.t4 = {4};
  e_out.s = "Hello, World!";
  std::unique_ptr<NoDefaultCtor> nodefault( new NoDefaultCtor( 3 ) );

  Test2 t2 = {22};

  {
    std::ofstream os("out.txt", std::ios::binary);
    cereal::BinaryOutputArchive archive(os);
    archive(CEREAL_NVP(e_out));
    archive(t2);
    archive(nodefault);
  }

  Everything e_in;

  std::unique_ptr<NoDefaultCtor> nodefaultin( new NoDefaultCtor( 1 ) );

  {
    std::ifstream is("out.txt", std::ios::binary);
    cereal::BinaryInputArchive archive(is);
    archive(CEREAL_NVP(e_in));
    archive(t2);
    archive(nodefaultin);
    std::remove("out.txt");
  }

  assert(e_in == e_out);
  assert(nodefault->y == nodefaultin->y);

  {
    cereal::BinaryOutputArchive archive(std::cout);
    int xxx[] = {-1, 95, 3};
    archive( xxx );

    cereal::XMLOutputArchive archive2(std::cout, cereal::XMLOutputArchive::Options(std::numeric_limits<double>::max_digits10, true, true));
    archive2( xxx );

    std::vector<int> yyy = {1, 2, 3};
    archive2( yyy );

    archive2.saveBinaryValue( xxx, sizeof(int)*3 );
  }

  {
    std::ofstream os("out.xml");
    cereal::XMLOutputArchive oar( os );
    //cereal::XMLOutputArchive oar( std::cout );

    oar( cereal::make_nvp("hello", 5 ) );

    std::string bla("bla");
    oar( bla );

    auto intptr = std::make_shared<int>(99);
    oar( CEREAL_NVP(intptr) );

    std::map<std::string, int> map1 =
    {
      {"one",   1},
      {"two",   2},
      {"three", 3}
    };

    oar( CEREAL_NVP(map1) );

    int x = 3;
    oar( CEREAL_NVP(x) );
    oar( 5 );
    oar( 3.3 );
    oar( 3.2f );
    oar( true );

    std::array<int,5> arr = {{1, 2, 3, 4, 5}};
    oar( arr );

    std::vector<std::string> vec = {"hey",
                                    "there",
                                    "buddy"};

    std::vector<std::vector<std::string>> vec2 = {vec, vec, vec};

    oar( cereal::make_nvp("EVERYTHING", e_out) );
    oar( vec );
    oar( vec2 );

    int xxx[] = {-1, 95, 3};
    oar.saveBinaryValue( xxx, sizeof(int)*3, "xxxbinary" );
    //oar.saveBinaryValue( xxx, sizeof(int)*3 );

    std::unique_ptr<Derived> d1( new Derived(3, 4) );
    std::unique_ptr<Base> d2( new Derived(4, 5) );
    std::shared_ptr<Base> d3( new Derived(5, 6) );
    oar( d1 );
    oar( d2 );
    oar( d3 );
  }

  {
    std::ifstream is("out.xml");
    cereal::XMLInputArchive iar( is );

    int hello;
    iar( cereal::make_nvp("hello", hello) );
    assert( hello == 5 );

    std::string bla;
    iar( bla );
    assert( bla == "bla" );

    std::shared_ptr<int> intptr;
    iar( CEREAL_NVP(intptr) );
    assert( *intptr == 99 );

    std::map<std::string, int> map1;

    iar( CEREAL_NVP(map1) );
    assert( map1["one"]   == 1 );
    assert( map1["two"]   == 2 );
    assert( map1["three"] == 3 );


    int x;
    iar( CEREAL_NVP(x) );
    assert( x == 3 );

    int x5;
    iar( x5 );
    assert( x5 == 5 );

    double x33;
    iar( x33 );
    assert( x33 == 3.3 );

    float x32;
    iar( x32 );
    assert( x32 == 3.2f );

    bool xtrue;
    iar( xtrue );
    assert( xtrue == true );

    std::array<int,5> arr;
    iar( arr );
    for( int i = 0; i < 5; ++i )
      assert( arr[i] == (i+1) );

    Everything e;
    iar( cereal::make_nvp("EVERYTHING", e) );
    assert( e == e_out );

    std::vector<std::string> vec;
    iar( vec );
    assert( vec[0] == "hey" );
    assert( vec[1] == "there" );
    assert( vec[2] == "buddy" );

    std::vector<std::vector<std::string>> vec2;
    iar( vec2 );
    for( auto & v : vec2 )
    {
      assert( v[0] == "hey" );
      assert( v[1] == "there" );
      assert( v[2] == "buddy" );
    }

    int xxx[3];
    iar.loadBinaryValue( xxx, sizeof(int)*3 );
    assert( xxx[0] == -1 );
    assert( xxx[1] == 95 );
    assert( xxx[2] == 3 );

    std::unique_ptr<Derived> d1;
    std::unique_ptr<Base> d2;
    std::shared_ptr<Base> d3;

    iar( d1 );
    assert( d1->x == 4 && d1->y == 3 );
    iar( d2 );
    assert( dynamic_cast<Derived*>(d2.get())->x == 5 && dynamic_cast<Derived*>(d2.get())->y == 4 );
    iar( d3 );
    assert( dynamic_cast<Derived*>(d3.get())->x == 6 && dynamic_cast<Derived*>(d3.get())->y == 5 );
  }

  {
    std::ofstream b("endian.out", std::ios::binary);
    cereal::PortableBinaryOutputArchive oar(b);

    bool bb = true;
    char a = 'a';
    int x = 1234;
    float y = 1.324f;
    double z = 3.1452;
    long double d = 1.123451234512345;
    long long j = 2394873298472343;

    oar( bb, a, x, y, z, d, j );
    std::cout << bb << " " << a << " " << x << " " << y << " " << z << " " << d << " " << j << std::endl;
    // valgrind will complain about uninitialized bytes here - seems to be the padding caused by the long double and
    // long long allocations (this padding just exists on the stack and is never used anywhere)
    // see https://bugs.kde.org/show_bug.cgi?id=197915
  }
  {
    std::ifstream b("endian.out", std::ios::binary);
    cereal::PortableBinaryInputArchive iar(b);

    bool bb;
    char a;
    int x;
    float y;
    double z;
    long double d;
    long long j;

    iar( bb, a, x, y, z, d, j );

    std::cout << bb << " " << a << " " << x << " " << y << " " << z << " " << d << " " << j << std::endl;

    std::remove("endian.out");
  }

  {
    std::ofstream ss("xml_ordering.out");
    cereal::XMLOutputArchive ar(ss);

    double one = 1;
    double two = 2;
    double three = 3;
    std::vector<int> four = {1, 2, 3, 4};

    // Output is ordered 3 2 1 4
    ar( three, CEREAL_NVP(two), one, cereal::make_nvp("five", four) );
  }

  {
    std::ifstream ss("xml_ordering.out");
    cereal::XMLInputArchive ar(ss);

    // Output prodered out of order, try to load in order 1 2 3 4
    double one;
    double two;
    double three;
    std::vector<int> four;

    ar( one ); // cereal can only give warnings if you used an NVP!
    ar( CEREAL_NVP( two ) );
    ar( three );

    try
    {
      ar( CEREAL_NVP( three ) );
    }
    catch( cereal::Exception const & e )
    {
      std::cout << e.what() << std::endl;
      std::cout << "Looked for three but we didn't use an NVP when saving" << std::endl;
    }
    ar( cereal::make_nvp("five", four) );
    ar( cereal::make_nvp("five", four) ); // do it a second time since it shouldn't matter as we provide the name

    std::cout << one << std::endl;
    std::cout << two << std::endl;
    std::cout << three << std::endl;
    for( auto i : four ) std::cout << i << " ";
    std::cout << std::endl;
  }

  {
    // Boost transition layer stuff
    std::ofstream ss("cereal_version.out");
    cereal::XMLOutputArchive ar(ss);

    BoostTransitionMS b(3);
    ar( b, b );

    BoostTransitionSplit c(4);
    ar( c, c );

    BoostTransitionNMS d(5);
    ar( d, d );

    BoostTransitionNMSplit e(32);
    ar( e, e );
  }

  {
    // Boost transition layer stuff
    std::ifstream ss("cereal_version.out");
    cereal::XMLInputArchive ar(ss);

    BoostTransitionMS b;
    ar( b );
    assert( b.getX() == 3 );
    b.setX( 0 );
    ar( b );
    assert( b.getX() == 3 );

    BoostTransitionSplit c;
    ar( c );
    assert( c.getX() == 4 );
    c.setX( 0 );
    ar( c );
    assert( c.getX() == 4 );

    BoostTransitionNMS d;
    ar( d );
    assert( d.x == 5 );
    d.x = 0;
    ar( d );
    assert( d.x == 5 );

    BoostTransitionNMSplit e;
    ar( e );
    assert( e.x == 32 );
    e.x = 0;
    ar( e );
    assert( e.x == 32 );
  }

#ifdef CEREAL_FUTURE_EXPERIMENTAL
  {
    // Any testing
    int x = 32;
    int * xx = &x;
    std::string y("hello");
    cereal::detail::Any a(xx);
    auto b = a;

    std::cout << *((int *)a) << std::endl;
    *((int*)a) = 44;
    std::cout << *((int *)b) << std::endl;
    std::cout << *((int *)a) << std::endl;

    a = cereal::detail::Any(y);
    std::string a_out = a;
    std::cout << a_out << std::endl;
  }
#endif // CEREAL_FUTURE_EXPERIMENTAL

  return 0;
}

CEREAL_CLASS_VERSION(BoostTransitionMS, 1)
CEREAL_CLASS_VERSION(BoostTransitionSplit, 2)
CEREAL_CLASS_VERSION(BoostTransitionNMS, 3)
// keep the other at default version (0)


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_json.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <cereal/cereal.hpp>
#include <cereal/archives/binary.hpp>
#include <cereal/archives/json.hpp>

#include <cereal/types/string.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/types/complex.hpp>
#include <cereal/types/base_class.hpp>
#include <cereal/types/array.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/map.hpp>

#include <sstream>
#include <fstream>
#include <cassert>
#include <complex>
#include <iostream>
#include <iomanip>
#include <string>

// ###################################
struct Test1
{
  int a;

  private:
    friend class cereal::access;
    template<class Archive>
    void serialize(Archive & ar)
    {
      ar(CEREAL_NVP(a));
    }
};

// ###################################
class Test2
{
  public:
    Test2() {}
    Test2( int x ) : a( x ) {}
    int a;

  private:
    friend class cereal::access;

    template<class Archive>
      void save(Archive & ar) const
      {
        ar(a);
      }

    template<class Archive>
      void load(Archive & ar)
      {
        ar(a);
      }
};

// ###################################
struct Test3
{
  int a;
};

template<class Archive>
void serialize(Archive & ar, Test3 & t)
{
  ar(CEREAL_NVP(t.a));
}

namespace test4
{
  // ###################################
  struct Test4
  {
    int a;
  };

  template<class Archive>
  void save(Archive & ar, Test4 const & t)
  {
    ar(CEREAL_NVP(t.a));
  }

  template<class Archive>
  void load(Archive & ar, Test4 & t)
  {
    ar(CEREAL_NVP(t.a));
  }
}

class Private
{
  public:
    Private() : a('z') {}

  private:
    char a;

    friend class cereal::access;

    template<class Archive>
      void serialize(Archive & ar)
      {
        ar(a);
      }
};

struct Everything
{
  int x;
  int y;
  Test1 t1;
  Test2 t2;
  Test3 t3;
  test4::Test4 t4;
  std::string s;

  template<class Archive>
  void serialize(Archive & ar)
  {
    ar(CEREAL_NVP(x));
    ar(CEREAL_NVP(y));
    ar(CEREAL_NVP(t1));
    ar(CEREAL_NVP(t2));
    ar(CEREAL_NVP(t3));
    ar(CEREAL_NVP(t4));
    ar(CEREAL_NVP(s));
  }

  bool operator==(Everything const & o)
  {
    return
      x == o.x &&
      y == o.y &&
      t1.a == o.t1.a &&
      t2.a == o.t2.a &&
      t3.a == o.t3.a &&
      t4.a == o.t4.a &&
      s == o.s;
  }
};


struct SubFixture
{
  SubFixture() : a( 3 ),
    b( 9999 ),
    c( 100.1f ),
    d( 2000.9 ),
    s( "hello, world!" )
  {}

  int a;
  uint64_t b;
  float c;
  double d;
  std::string s;

    template<class Archive>
      void serialize(Archive & ar)
      {
        ar( CEREAL_NVP(a),
            b,
            c,
            CEREAL_NVP(d),
            CEREAL_NVP(s) );
      }
    void change()
    {
      a = 4;
      b = 4;
      c = 4;
      d = 4;
      s = "4";
    }
};

struct Fixture
{
  SubFixture f1, f2, f3;
  int array[4];

  Fixture()
  {
    array[0] = 1;
    array[1] = 2;
    array[2] = 3;
    array[3] = 4;
  }

  template<class Archive>
  void save(Archive & ar) const
  {
    ar( f1,
        CEREAL_NVP(f2),
        f3 );
    ar.saveBinaryValue( array, sizeof(int)*4, "cool array man" );
  }

  template<class Archive>
  void load(Archive & ar)
  {
    ar( f1,
        CEREAL_NVP(f2),
        f3 );
    ar.loadBinaryValue( array, sizeof(int)*4 );
  }

    void change()
    {
      f1.change();
      f2.change();
      f3.change();
    }
};

struct AAA
{
  AAA() : one( 1 ), two( 2 ), three( { {1, 2, 3}, { 4, 5, 6 }, {} } ) {}
  int one, two;

  std::vector<std::vector<int>> three;

  template<class Archive>
    void serialize(Archive & ar)
    {
      ar( CEREAL_NVP(one), CEREAL_NVP(two) );
      //ar( CEREAL_NVP(three) );
    }
};

class Stuff
{
  public:
    Stuff() {}

    void fillData()
    {
      std::vector<std::complex<float>> t1{ {0, -1.0f},
                          { 0, -2.9932f },
                          { 0, -3.5f } };
      std::vector<std::complex<float>> t2{ {1.0f, 0},
                     { 2.2f, 0 },
                     { 3.3f, 0 } };
      data["imaginary"] = t1;
      data["real"] = t2;
    }

  private:
    std::map<std::string, std::vector<std::complex<float>>> data;

    friend class cereal::access;

    template <class Archive>
    void serialize( Archive & ar )
    {
      ar( CEREAL_NVP(data) );
    }
};

struct OOJson
{
  OOJson() = default;
  OOJson( int aa, int bb, bool cc, double dd ) :
    a( aa ), b( bb ), c{ cc, dd }
  {
    d[0] = 0; d[1] = 1; d[2] = 2;
  }

  int a;
  int b;
  std::pair<bool, double> c;
  float d[3];

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( CEREAL_NVP(c) );
    ar( CEREAL_NVP(a) );
    ar( b );
    ar( CEREAL_NVP(d) );
  }
};

// ######################################################################
int main()
{
  std::cout << std::boolalpha << std::endl;

  {
    std::ofstream os("file.json");
    cereal::JSONOutputArchive oar( os );

    //auto f = std::make_shared<Fixture>();
    //auto f2 = f;
    //oar( f );
    //oar( f2 );
    Stuff s; s.fillData();
    oar( cereal::make_nvp("best data ever", s) );
  }

  {
    std::ifstream is("file.json");
    std::string str((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
    std::cout << "---------------------" << std::endl << str << std::endl << "---------------------" << std::endl;
  }

  // playground
  {
    cereal::JSONOutputArchive archive( std::cout );
    bool arr[] = {true, false};
    std::vector<int> vec = {1, 2, 3, 4, 5};
    archive( CEREAL_NVP(vec),
        arr );
    auto f = std::make_shared<Fixture>();
    auto f2 = f;
    archive( f );
    archive( f2 );
  }

  // test out of order
  std::stringstream oos;
  {
    cereal::JSONOutputArchive ar(oos);
    cereal::JSONOutputArchive ar2(std::cout,
        cereal::JSONOutputArchive::Options(2, cereal::JSONOutputArchive::Options::IndentChar::space, 2) );

    ar( cereal::make_nvp( "1", 1 ),
        cereal::make_nvp( "2", 2 ),
        3,
        0, // unused
        cereal::make_nvp( "4", 4 ),
        cereal::make_nvp( "5", 5 ) );

    int x = 33;
    ar.saveBinaryValue( &x, sizeof(int), "bla" );

    ar2( cereal::make_nvp( "1", 1 ),
         cereal::make_nvp( "2", 2 ),
         3,
         0, // unused
         cereal::make_nvp( "4", 4 ),
         cereal::make_nvp( "5", 5 ) );
    ar2.saveBinaryValue( &x, sizeof(int), "bla" );

    OOJson oo( 1, 2, true, 4.2 );
    ar( CEREAL_NVP(oo) );
    ar2( CEREAL_NVP(oo) );

    // boost stuff
    ar & cereal::make_nvp("usingop&", oo ) & 6;
    ar << 5 << 4 << 3;

    ar2 & cereal::make_nvp("usingop&", oo ) & 6;
    ar2 << 5 << 4 << 3;

    long double ld = std::numeric_limits<long double>::max();
    long long ll = std::numeric_limits<long long>::max();
    unsigned long long ull = std::numeric_limits<unsigned long long>::max();

    ar( CEREAL_NVP(ld),
        CEREAL_NVP(ll),
        CEREAL_NVP(ull) );

    ar2( CEREAL_NVP(ld),
         CEREAL_NVP(ll),
         CEREAL_NVP(ull) );
  }

  {
    cereal::JSONInputArchive ar(oos);
    int i1, i2, i3, i4, i5, x;

    ar( i1 );
    ar( cereal::make_nvp( "2", i2 ), i3 );

    ar( cereal::make_nvp( "4", i4 ),
        i5 );

    ar.loadBinaryValue( &x, sizeof(int) );

    OOJson ii;
    ar( cereal::make_nvp("oo", ii) );
    ar( cereal::make_nvp( "2", i2 ) );

    std::cout << i1 << " " << i2 << " " << i3 << " " << i4 << " " << i5 << std::endl;
    std::cout << x << std::endl;
    std::cout << ii.a << " " << ii.b << " " << ii.c.first << " " << ii.c.second << " ";
    for( auto z : ii.d )
      std::cout << z << " ";
    std::cout << std::endl;

    OOJson oo;
    ar >> cereal::make_nvp("usingop&", oo );
    std::cout << oo.a << " " << oo.b << " " << oo.c.first << " " << oo.c.second << " ";
    for( auto z : oo.d )
      std::cout << z << " ";

    int aa, a, b, c;
    ar & aa & a & b & c;
    std::cout << aa << " " << a << " " << b << " " << c << std::endl;

    long double ld;
    long long ll;
    unsigned long long ull;

    ar( CEREAL_NVP(ld),
        CEREAL_NVP(ll),
        CEREAL_NVP(ull) );

    std::cout << (ld  == std::numeric_limits<long double>::max()) << std::endl;
    std::cout << (ll  == std::numeric_limits<long long>::max()) << std::endl;
    std::cout << (ull == std::numeric_limits<unsigned long long>::max()) << std::endl;
  }

  return 0;
}


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_rtti.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <type_traits>
#include <cereal/archives/binary.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/types/polymorphic.hpp>
#include <sstream>
#include <fstream>
#include <iostream>

struct Base
{
  int y;
  virtual void foo() = 0;
  virtual ~Base() {}

  template<class Archive>
    void save(Archive & ar) const
    {
      std::cout << "Saving Base" << std::endl;
      ar( y );
    }

  template<class Archive>
    void load(Archive & ar)
    {
      std::cout << "Loading Base" << std::endl;
      ar( y );
    }
};

struct MyType : public Base
{
  virtual ~MyType() {}

  int x;

  void foo() {}

  template<class Archive>
    void save(Archive & ar) const
    {
      std::cout << "Saving MyType" << std::endl;
      ar( cereal::virtual_base_class<Base>( this ) );
    }

  template<class Archive>
    void load(Archive & ar)
    {
      std::cout << "Loading MyType" << std::endl;
      ar( cereal::base_class<Base>( this ) );
    }
};
CEREAL_REGISTER_TYPE(MyType)

struct YourType : public Base
{
  virtual ~YourType() {}

  YourType(int xx) : x(xx) {}
  YourType() : x(-1) {}
  int x;

  void foo() {}

  template<class Archive>
    void save(Archive & ar) const
    {
      std::cout << "Saving YourType" << std::endl;
      ar( x );
    }

  template<class Archive>
    void load(Archive & ar)
    {
      std::cout << "Loading YourType" << std::endl;
      ar( x );
    }
};

CEREAL_REGISTER_TYPE(YourType)
CEREAL_REGISTER_POLYMORPHIC_RELATION(Base, YourType)

struct OurBase
{
  virtual void foo() {}

  template<class Archive>
    void serialize(Archive &)
    { }
};

struct OurType : public OurBase
{
  OurType() : OurBase(), x() {}
  OurType(int x_) : x(x_) {}
  virtual ~OurType() {}

  void foo() {}

  int x;

  template<class Archive>
    void serialize(Archive & ar)
    {
      ar( x );
    }
};

struct BaseVirtual
{
  int x;
  template <class Archive>
  void serialize( Archive & ar )
  { ar( x ); }
  virtual void foo() = 0;
};

struct DerivedVirtual : public virtual BaseVirtual
{
  virtual ~DerivedVirtual() {}

  int y;
  virtual void foo() {}

  template <class Archive>
  void save( Archive & ar ) const
  {
    ar( cereal::virtual_base_class<BaseVirtual>( this ) );
    ar( y );
  }

  template <class Archive>
  void load( Archive & ar )
  {
    ar( cereal::virtual_base_class<BaseVirtual>( this ) );
    ar( y );
  }
};

struct TestType
{
  int x;
  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x );
  }
};

namespace cereal
{
  template <class Archive> struct specialize<Archive, DerivedVirtual, cereal::specialization::member_load_save> {};
  template <class Archive> struct specialize<Archive, TestType, cereal::specialization::member_serialize> {};
}

struct AAA
{
  virtual void foo() = 0;
};

struct BBB : AAA
{
  virtual ~BBB() {}
  void foo() {}
  template <class Archive>
  void serialize( Archive & ) {}
};

CEREAL_REGISTER_TYPE(BBB)

template <class T> void nop(T&&) {}

int main()
{
  {
    std::ofstream ostream("rtti.txt");
    //cereal::BinaryOutputArchive oarchive(ostream);
    cereal::XMLOutputArchive oarchive(ostream);

    std::shared_ptr<Base> ptr1 = std::make_shared<MyType>();
    std::shared_ptr<Base> ptr2 = std::make_shared<YourType>(33);
    std::unique_ptr<Base> ptr3(new MyType());
    std::weak_ptr<Base>   ptr4 = ptr2;

    std::shared_ptr<OurType> ptr5 = std::make_shared<OurType>(99);

    oarchive(ptr1);
    oarchive(ptr2);
    oarchive(ptr3);
    oarchive(ptr4);
    oarchive(ptr5);

    //std::shared_ptr<AAA> a = std::make_shared<BBB>();
    //oarchive(a);
  }

  {
    std::ifstream istream("rtti.txt");
    //cereal::BinaryInputArchive iarchive(istream);
    cereal::XMLInputArchive iarchive(istream);

    std::shared_ptr<Base> ptr1;
    std::shared_ptr<Base> ptr2;
    std::unique_ptr<Base> ptr3;
    std::weak_ptr<Base>   ptr4;

    std::shared_ptr<OurType> ptr5;

    iarchive(ptr1);
    iarchive(ptr2);
    iarchive(ptr3);
    iarchive(ptr4);
    iarchive(ptr5);
  }
}


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_shared_lib/CMakeLists.txt
================================================
add_library(sandbox_vs_dll SHARED base.cpp derived.cpp)


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_shared_lib/base.cpp
================================================
#ifndef CEREAL_DLL_USE
#define CEREAL_DLL_MAKE
#endif
#include "base.hpp"

template void Base::serialize<cereal::XMLOutputArchive>
    ( cereal::XMLOutputArchive & ar, std::uint32_t const version );
template void Base::serialize<cereal::XMLInputArchive>
    ( cereal::XMLInputArchive & ar, std::uint32_t const version );


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_shared_lib/base.hpp
================================================
#pragma once

#include <memory>
#include <cereal/cereal.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/types/polymorphic.hpp>

#if defined (_WINDLL)
#define DECLSPECIFIER __declspec(dllexport)
#elif defined(MSC_VER)
#define DECLSPECIFIER __declspec(dllimport)
#else
#define DECLSPECIFIER
#endif

int doit();

class VersionTest
{
  public:
    int x;
    template <class Archive>
    void serialize( Archive & ar, const std::uint32_t /* version */ )
    { ar( x ); }
};

class Base
{
  public:
    friend class cereal::access;

    template < class Archive >
    void serialize(Archive &, std::uint32_t const) {}
    virtual ~Base() {}
};

extern template DECLSPECIFIER void Base::serialize<cereal::XMLInputArchive>
( cereal::XMLInputArchive & ar, std::uint32_t const version );

extern template DECLSPECIFIER void Base::serialize<cereal::XMLOutputArchive>
( cereal::XMLOutputArchive & ar, std::uint32_t const version );

CEREAL_CLASS_VERSION(VersionTest, 1)


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_shared_lib/derived.cpp
================================================
#ifndef CEREAL_DLL_USE
#define CEREAL_DLL_MAKE
#endif
#include "derived.hpp"

template void Derived::serialize<cereal::XMLOutputArchive>
    ( cereal::XMLOutputArchive & ar, std::uint32_t const version );

template void Derived::serialize<cereal::XMLInputArchive>
    ( cereal::XMLInputArchive & ar, std::uint32_t const version );


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_shared_lib/derived.hpp
================================================
#pragma once
#include "base.hpp"
class Derived : public Base
{
  public:
    virtual ~Derived() {}

  private:
    friend class cereal::access;
    template <class Archive>
    void serialize(Archive & ar, std::uint32_t const)
    {
      ar(cereal::base_class<Base>(this));
    }
};

extern template DECLSPECIFIER void Derived::serialize<cereal::XMLOutputArchive>
    ( cereal::XMLOutputArchive & ar, std::uint32_t const version );
extern template DECLSPECIFIER void Derived::serialize<cereal::XMLInputArchive>
    ( cereal::XMLInputArchive & ar, std::uint32_t const version );

CEREAL_REGISTER_TYPE(Derived)


================================================
FILE: examples/libraries/cereal-1.3.0/sandbox/sandbox_vs.cpp
================================================
#include <base.hpp>
#include <derived.hpp>

#include <cereal/access.hpp>
#include <cereal/details/traits.hpp>
#include <cereal/details/helpers.hpp>
#include <cereal/types/base_class.hpp>
#include <cereal/cereal.hpp>

#include <cereal/types/array.hpp>
#include <cereal/types/bitset.hpp>
#include <cereal/types/chrono.hpp>
#include <cereal/types/common.hpp>
#include <cereal/types/complex.hpp>
#include <cereal/types/deque.hpp>
#include <cereal/types/forward_list.hpp>
#include <cereal/types/list.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/memory.hpp>

#include <cereal/details/util.hpp>

#include <cereal/details/polymorphic_impl.hpp>
#include <cereal/types/polymorphic.hpp>

#include <cereal/types/queue.hpp>
#include <cereal/types/set.hpp>
#include <cereal/types/stack.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/tuple.hpp>
#include <cereal/types/unordered_map.hpp>
#include <cereal/types/unordered_set.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/vector.hpp>

#include <cereal/archives/binary.hpp>
#include <cereal/archives/portable_binary.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/archives/json.hpp>

#include <iostream>
#include <type_traits>
#include <functional>

//CEREAL_FORCE_LINK_SHARED_LIBRARY(Sandbox)

struct Archive {};
CEREAL_SETUP_ARCHIVE_TRAITS(Archive, Archive)

struct Test
{
  template <class Archive>
  void serialzize( Archive & )
  {
    std::cout << "hey there" << std::endl;
  }

  template <class Archive>
  void save( Archive & ) const
  {
    std::cout << "saved by the bell" << std::endl;
  }

  template <class Archive>
  void load( Archive & )
  {
    std::cout << "locked and loaded" << std::endl;
  }

  template <class Archive>
  static void load_and_construct( Archive &, cereal::construct<Test> & )
  {
  }

  template <class Archive>
  int save_minimal() const
  {
    return 0;
  }

  template <class Archive>
  int save_minimal(const std::uint32_t) const
  {
    return 1;
  }

  template <class Archive>
  void load_minimal( int & )
  { }
};

template <class Archive>
void serialize( Archive &, Test & )
{ }

template <class Archive>
void load( Archive &, Test & )
{ }

template <class Archive>
void save( Archive &, Test const & )
{ }

template <class Archive>
int save_minimal( Test const & )
{ return 0; }

template <class Archive>
int save_minimal( Test const &, const std::uint32_t )
{ return 0; }

namespace cereal
{
  template <>
  struct LoadAndConstruct<Test>
  {
    template <class Archive>
    static void load_and_construct( Archive &, cereal::construct<Test> & construct )
    {
      construct();
    }
  };
}

struct A
{
  virtual void foo() = 0;
  virtual ~A() {}
};

struct B : A
{
  virtual ~B() {}
  void foo() {}

  template <class Archive>
  void serialize( Archive & )
  {
    std::cout << "i'm in your b" << std::endl;
  }
};

struct C
{
  char a;
};

CEREAL_REGISTER_TYPE(B)
CEREAL_REGISTER_POLYMORPHIC_RELATION(A, B)

class MemberMinimal
{
  public:
    MemberMinimal() = default;
    template <class Archive>
    int save_minimal( Archive const & ) const
    {
      return x;
    }

    template <class Archive>
    void load_minimal( Archive const &, int const & str )
    {
      x = str;
    }

  public:
    int x;
};

int main()
{
  typedef Test T;
  std::cout << std::boolalpha;

  // Test Load and Construct internal/external
  std::cout << "\tload_and_construct" << std::endl;
  std::cout << cereal::traits::has_member_load_and_construct<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_load_and_construct<T, Archive>::value << std::endl;

  // serialize
  std::cout << "\tserialize" << std::endl;
  std::cout << cereal::traits::has_member_serialize<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_serialize<T, Archive>::value << std::endl;

  // load
  std::cout << "\tload" << std::endl;
  std::cout << cereal::traits::has_member_load<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_load<T, Archive>::value << std::endl;

  // load minimal
  std::cout << "\tload minimal" << std::endl;
  std::cout << cereal::traits::has_member_load<T, Archive>::value << std::endl;

  // save
  std::cout << "\tsave" << std::endl;
  std::cout << cereal::traits::has_member_save<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_save<T, Archive>::value << std::endl;

  // save_minimal
  std::cout << "\tsave_minimal" << std::endl;
  std::cout << cereal::traits::has_member_save_minimal<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_save_minimal<T, Archive>::value << std::endl;

  // save_minimal_versioned
  std::cout << "\tsave_minimal versioned" << std::endl;
  std::cout << cereal::traits::has_member_versioned_save_minimal<T, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_versioned_save_minimal<T, Archive>::value << std::endl;

  // splittable
  std::cout << "\t splittable" << std::endl;
  std::cout << cereal::traits::has_member_split<T, Archive, Archive>::value << std::endl;
  std::cout << cereal::traits::has_non_member_split<T, Archive, Archive>::value << std::endl;

  // serialiable
  std::cout << "\toutput serializable" << std::endl;
  std::cout << cereal::traits::is_output_serializable<T, Archive>::value << std::endl;

#if !defined(__INTEL_COMPILER)
  //! TODO: This causes icc to crash
  std::cout << cereal::traits::is_input_serializable<T, Archive>::value << std::endl;
#endif

  // specialized
  std::cout << "\tspecialized" << std::endl;
  std::cout << cereal::traits::detail::is_specialized_member_serialize<T, Archive>::value << std::endl;
  std::cout << cereal::traits::detail::is_specialized_member_load_save<T, Archive>::value << std::endl;
  std::cout << cereal::traits::detail::is_specialized_non_member_serialize<T, Archive>::value << std::endl;
  std::cout << cereal::traits::detail::is_specialized_non_member_load_save<T, Archive>::value << std::endl;
  std::cout << cereal::traits::detail::count_specializations<T, Archive>::value << std::endl;
  std::cout << cereal::traits::is_specialized<T, Archive>::value << std::endl;

  // array size
  std::cout << typeid(A).name() << std::endl;
  std::cout << typeid(cereal::traits::has_load_and_construct<int, bool>).name() << std::endl;

  // extra testing
  std::cout << "\textra" << std::endl;
  std::cout << cereal::traits::has_member_save_minimal<MemberMinimal, Archive>::value << std::endl;
  std::cout << cereal::traits::has_member_load_minimal<MemberMinimal, Archive>::value << std::endl;

  // DLL testing
  std::cout << "------DLL TESTING------" << std::endl;
  std::stringstream dllSS1;
  std::stringstream dllSS2;
  {
    cereal::XMLOutputArchive out(dllSS1);
    VersionTest x{1};
    std::shared_ptr<Base> p = std::make_shared<Derived>();
    out(x);
    out( p );

    std::shared_ptr<A> ay = std::make_shared<B>();
    out(ay);
  }

  std::cout << dllSS1.str() << std::endl;

  {
    VersionTest x;
    std::shared_ptr<Base> p;
    std::shared_ptr<A> ay;
    {
      cereal::XMLInputArchive in(dllSS1);
      in(x);
      in( p );
      in( ay );
    }
    {
      cereal::XMLOutputArchive out(dllSS2);
      out( x );
      out( p );
      out( ay );
    }
  }

  std::cout << dllSS2.str() << std::endl;

  return 0;
}


================================================
FILE: examples/libraries/cereal-1.3.0/scripts/add_rapidjson_prefix.sh
================================================
# Applies renaming within all of the rapidjson source files to add a cereal prefix
find ./../include/cereal/external/rapidjson/ -type f -name \*.h -exec sed -i "s/RAPIDJSON_/CEREAL_RAPIDJSON_/g" {} \;
echo "Remember to backport any cereal specific changes not in this version of RapidJSON!"
echo "See https://github.com/USCiLab/cereal/commits/develop/include/cereal/external/rapidjson"


================================================
FILE: examples/libraries/cereal-1.3.0/scripts/appveyor.bat
================================================
@echo off
setlocal enabledelayedexpansion

if not defined APPVEYOR (
    @echo This script is meant to be used with AppVeyor CI. This can be used as reference.
    @echo I sincerely recommend not using it for building/testing cereal locally.
    exit /b 0
)

if not defined BOOST_ROOT (
    set BOOST_ROOT=C:\Libraries\boost
)

if not defined VS_VERSION_MAJOR (
    set VS_VERSION_MAJOR=14
)
if not defined VS_VERSION_YEAR (
    if "%VS_VERSION_MAJOR%" == "12" (
        set VS_VERSION_YEAR=2013
    ) else if "%VS_VERSION_MAJOR%" == "14" (
        set VS_VERSION_YEAR=2015
    ) else if "%VS_VERSION_MAJOR%" == "15" (
        set VS_VERSION_YEAR=2017
    ) else if "%VS_VERSION_MAJOR%" == "16" (
        set VS_VERSION_YEAR=2019
    ) else (
        @echo Cannot use Visual Studio version %VS_VERSION_MAJOR%
        exit /b 1
    )
)
if not defined CMAKE_GENERATOR_PREFIX (
    set CMAKE_GENERATOR_PREFIX=Visual Studio %VS_VERSION_MAJOR% %VS_VERSION_YEAR%
)

@rem CONFIGURATION is (one of the entries) defined in appveyor.yml
if not defined CONFIGURATION (
    set CONFIGURATION=Release
)
@rem PLATFORM is (one of the entries) defined in appveyor.yml
if "%PLATFORM%"=="x64" (
    set BIT_COUNT=64
    set CMAKE_GENERATOR_NAME=%CMAKE_GENERATOR_PREFIX% Win64
) else (
    set BIT_COUNT=32
    set CMAKE_GENERATOR_NAME=%CMAKE_GENERATOR_PREFIX%
)

set BOOST_LIBRARYDIR=%BOOST_ROOT%\lib%BIT_COUNT%-msvc-%VS_VERSION_MAJOR%.0

set START_DIR=%CD%

if not exist build\NUL mkdir build
cd build

if "%~1" == "test" (
    @rem overloading the batch script; Run tests if the first argument is `test` (without quotes).
    @rem   Cereal uses Boost Unit test framework. Rather than modifying the code to load boost test
    @rem dll from its location OR copying the boost dlls to the directory of every test being run,
    @rem we use another option Windows leaves us - modify the PATH.
    for %%i in (ctest.exe) do set CTEST_EXE=%%~$PATH:i
    PATH %BOOST_LIBRARYDIR%
    "!CTEST_EXE!" -C %CONFIGURATION%
    if %errorlevel% neq 0 exit /b %errorlevel%
    goto done
)

if "%PLATFORM%" == "x64" (
    @rem please excuse the hack - CMake is unable to produce multiarch MSVC projects
    cmake -G "%CMAKE_GENERATOR_PREFIX%" -DBOOST_ROOT=%BOOST_ROOT% -DBOOST_LIBRARYDIR=%BOOST_LIBRARYDIR% ..
    cmake --build . --config %CONFIGURATION% --target portability_test32
    del CMakeCache.txt
    rmdir /s /q CMakeFiles
)

cmake -G "%CMAKE_GENERATOR_NAME%" -DBOOST_ROOT=%BOOST_ROOT% -DBOOST_LIBRARYDIR=%BOOST_LIBRARYDIR% ..
@rem left the actual build for later - AppVeyor enables parallel jobs in a much cleaner way than msbuild

:done
@REM go back home
cd %START_DIR%


================================================
FILE: examples/libraries/cereal-1.3.0/scripts/renameincludes.sh
================================================
#!/usr/bin/env bash

destdir="include_renamed"

echo -n "New prefix: "
read newprefix

cp -r include ${destdir}

newprefix=$(echo ${newprefix} | sed -e 's/\//\\\//')

find ${destdir} -name '*.hpp' -exec sed -i "s/#include <cereal/#include <${newprefix}\/cereal/" {} \;


================================================
FILE: examples/libraries/cereal-1.3.0/scripts/updatecoverage.sh
================================================
#!/usr/bin/env bash

# Updates the coverage documentation, and copies it into the appropriate place
# in the gh-pages branch.
#   $1 from CMAKE will contain the root directory of cereal

# this requires lcov 1.10 or newer

set -e

COVERAGE_TESTS=./coverage_*

# run tests
for f in $COVERAGE_TESTS
  do
    echo $f
    $f
  done

# build coverage output
tempdir=`mktemp -d`

lcov --capture --directory $1 --output-file coverage.info --no-external
lcov --remove coverage.info '*/external/*' '*/cereal/details/util.hpp' 'sandbox/*' '*/unittests/*' -o coverage.info
genhtml --demangle-cpp coverage.info --output-directory ${tempdir}

# copy over to gh pages
git checkout gh-pages

rm -rf $1/assets/coverage
mkdir $1/assets/coverage
cp -r ${tempdir}/* $1/assets/coverage/
rm -rf ${tempdir}


================================================
FILE: examples/libraries/cereal-1.3.0/scripts/updatedoc.in
================================================
#!/usr/bin/env bash

# Updates the doxygen documentation, and copies it into the appropriate place
# in the gh-pages branch.

set -e

tempdir=`mktemp -d`
branch=`git rev-parse --abbrev-ref HEAD`

cp -r @PROJECT_BINARY_DIR@/doc/html/ ${tempdir}

git stash
git checkout gh-pages

rm -rf @PROJECT_SOURCE_DIR@/assets/doxygen
mkdir @PROJECT_SOURCE_DIR@/assets/doxygen
cp -r ${tempdir}/html/* @PROJECT_SOURCE_DIR@/assets/doxygen/

rm -rf ${tempdir}

git commit @PROJECT_SOURCE_DIR@/assets/doxygen

git checkout ${branch}
git stash apply


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/CMakeLists.txt
================================================
file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)

# A semi-colon separated list of test sources that should not be automatically built with doctest 
set(SPECIAL_TESTS "portability_test.cpp")

if(CMAKE_VERSION VERSION_LESS 2.8)
  # Portability test uses the `TARGET_FILE_DIR` generator expression which is available from CMake 2.8.
  set(SKIP_PORTABILITY_TEST ON)
endif()

if(NOT SKIP_PORTABILITY_TEST)
  # Build the portability test only if we are on a 64-bit machine (void* is 8 bytes)
  if((${CMAKE_SIZEOF_VOID_P} EQUAL 8))
    if(NOT MSVC)
      add_executable(portability_test32 portability_test.cpp)
      set_target_properties(portability_test32 PROPERTIES COMPILE_FLAGS "-m32")
      set_target_properties(portability_test32 PROPERTIES LINK_FLAGS "-m32")
    endif()

    add_executable(portability_test64 portability_test.cpp)

    add_test(NAME portability_test
            COMMAND ${CMAKE_COMMAND}
              -DPORTABILITY_TEST_DIR=$<TARGET_FILE_DIR:portability_test64>
            -P "${CMAKE_CURRENT_SOURCE_DIR}/run_portability_test.cmake")

  elseif(MSVC)
    add_executable(portability_test32 portability_test.cpp)
  endif()
endif()

# Build all of the non-special tests
foreach(TEST_SOURCE ${TESTS})

  string(REPLACE ".cpp" "" TEST_TARGET "${TEST_SOURCE}")
  set(TEST_TARGET "test_${TEST_TARGET}")

  # Check to see if our target is listed in "SPECIAL_TESTS"
  list(FIND SPECIAL_TESTS "${TEST_SOURCE}" IS_SPECIAL_TEST)

  if(IS_SPECIAL_TEST EQUAL -1)

    add_executable(${TEST_TARGET} ${TEST_SOURCE})
    target_link_libraries(${TEST_TARGET} ${CEREAL_THREAD_LIBS})
    add_test("${TEST_TARGET}" "${TEST_TARGET}")

    # If we are on a 64-bit machine, create an extra 32-bit version of the test if portability testing is enabled
    if((NOT MSVC) AND (${CMAKE_SIZEOF_VOID_P} EQUAL 8) AND (NOT SKIP_PORTABILITY_TEST))
      add_executable(${TEST_TARGET}_32 ${TEST_SOURCE})
      set_target_properties(${TEST_TARGET}_32 PROPERTIES
        COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
      add_test("${TEST_TARGET}_32" "${TEST_TARGET}_32")
    endif()

  endif()

endforeach()

# Add the valgrind target
if(NOT MSVC)
  add_custom_target(valgrind
    COMMAND "${CMAKE_CURRENT_SOURCE_DIR}/run_valgrind.sh")

  # Add the coverage target
  add_custom_target(coverage)
  add_custom_command(TARGET coverage
    COMMAND "${CMAKE_SOURCE_DIR}/scripts/updatecoverage.sh" ${CMAKE_SOURCE_DIR}
    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/coverage")

  # add tests to coverage
  foreach(TEST_SOURCE ${TESTS})
    string(REPLACE ".cpp" "" COVERAGE_TARGET "${TEST_SOURCE}")
    set(COVERAGE_TARGET "coverage_${COVERAGE_TARGET}")

    # Check to see if our target is listed in "SPECIAL_TESTS"
    list(FIND SPECIAL_TESTS "${TEST_SOURCE}" IS_SPECIAL_TEST)

    if(IS_SPECIAL_TEST EQUAL -1)
      add_dependencies(coverage ${COVERAGE_TARGET})

      add_executable(${COVERAGE_TARGET} EXCLUDE_FROM_ALL ${TEST_SOURCE})
      set_target_properties(${COVERAGE_TARGET} PROPERTIES COMPILE_FLAGS "-coverage")
      set_target_properties(${COVERAGE_TARGET} PROPERTIES LINK_FLAGS "-coverage")
      set_target_properties(${COVERAGE_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/coverage")
      target_link_libraries(${COVERAGE_TARGET} ${CEREAL_THREAD_LIBS})
    endif()
  endforeach()
endif(NOT MSVC)

if(CMAKE_CXX_STANDARD GREATER 14)
  add_subdirectory(cpp17)
endif()

if(Boost_FOUND)
  add_subdirectory(boost)
endif()

if(NOT CMAKE_VERSION VERSION_LESS 3.0)
  add_test(test_cmake_config_module ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake-config-module.cmake)
endif()


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/array.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "array.hpp"

TEST_SUITE_BEGIN("array");

TEST_CASE("binary_array")
{
  test_array<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_array")
{
  test_array<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_array")
{
  test_array<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_array")
{
  test_array<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/array.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_ARRAY_H_
#define CEREAL_TEST_ARRAY_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_array()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::array<int, 100> o_podarray;
    for(auto & elem : o_podarray)
      elem = random_value<int>(gen);

    std::array<StructInternalSerialize, 100> o_iserarray;
    for(auto & elem : o_iserarray)
      elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::array<StructInternalSplit, 100> o_isplarray;
    for(auto & elem : o_isplarray)
      elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::array<StructExternalSerialize, 100> o_eserarray;
    for(auto & elem : o_eserarray)
      elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::array<StructExternalSplit, 100> o_esplarray;
    for(auto & elem : o_esplarray)
      elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podarray);
      oar(o_iserarray);
      oar(o_isplarray);
      oar(o_eserarray);
      oar(o_esplarray);
    }

    std::array<int, 100> i_podarray;
    std::array<StructInternalSerialize, 100> i_iserarray;
    std::array<StructInternalSplit, 100>     i_isplarray;
    std::array<StructExternalSerialize, 100> i_eserarray;
    std::array<StructExternalSplit, 100>     i_esplarray;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podarray);
      iar(i_iserarray);
      iar(i_isplarray);
      iar(i_eserarray);
      iar(i_esplarray);
    }

    check_collection( i_podarray, o_podarray );
    check_collection( i_iserarray, o_iserarray );
    check_collection( i_isplarray, o_isplarray );
    check_collection( i_eserarray, o_eserarray );
    check_collection( i_esplarray, o_esplarray );
  }
}

#endif // CEREAL_TEST_ARRAY_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/atomic.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "atomic.hpp"

TEST_SUITE_BEGIN("atomic");

TEST_CASE("binary_atomic")
{
  test_atomic<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_atomic")
{
  test_atomic<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_atomic")
{
  test_atomic<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_atomic")
{
  test_atomic<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/atomic.hpp
================================================

/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "common.hpp"

#define MAKE_TEST_HELPER_FUNCS(t)                             \
bool operator==(t const & l, t const & r)                     \
{ return l.x == r.x; }                                        \
inline std::ostream& operator<<(std::ostream&os, t const & s) \
{                                                             \
    os << "[x: " << s.x << "]";                               \
    return os;                                                \
}

struct TrivialISER
{
  int x;

  template <class Archive>
  void serialize( Archive & ar )
  { ar( x ); }
};

MAKE_TEST_HELPER_FUNCS(TrivialISER)

struct TrivialISPL
{
  int x;

  template <class Archive>
  void load( Archive & ar )
  { ar( x ); }

  template <class Archive>
  void save( Archive & ar ) const
  { ar( x ); }
};

MAKE_TEST_HELPER_FUNCS(TrivialISPL)

struct TrivialESER
{
  int x;
};

template <class Archive>
void serialize( Archive & ar, TrivialESER & t )
{ ar( t.x ); }

MAKE_TEST_HELPER_FUNCS(TrivialESER)

struct TrivialESPL
{
  int x;
};

template <class Archive>
void load( Archive & ar, TrivialESPL & t )
{ ar( t.x ); }

template <class Archive>
void save( Archive & ar, TrivialESPL const & t )
{ ar( t.x ); }

MAKE_TEST_HELPER_FUNCS(TrivialESPL)
#undef MAKE_TEST_HELPER_FUNCS

template <class IArchive, class OArchive>
void test_atomic()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::atomic<bool> o_ab(random_value<uint8_t>(gen) % 2 ? true : false);
    std::atomic<signed char> o_asc(random_value<signed char>(gen));
    std::atomic<unsigned short> o_aus(random_value<unsigned short>(gen));
    std::atomic<int> o_asi(random_value<int>(gen));
    std::atomic<long> o_asl(random_value<long>(gen));
    std::atomic<unsigned long long> o_aull(random_value<unsigned long long>(gen));
    std::atomic<double> o_ad(random_value<double>(gen));
    std::atomic<TrivialISER> o_iser{{random_value<int>(gen)}};
    std::atomic<TrivialISPL> o_ispl{{random_value<int>(gen)}};
    std::atomic<TrivialESER> o_eser{{random_value<int>(gen)}};
    std::atomic<TrivialESPL> o_espl{{random_value<int>(gen)}};

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_ab);
      oar(o_asc);
      oar(o_aus);
      oar(o_asi);
      oar(o_asl);
      oar(o_aull);
      oar(o_ad);
      oar(o_iser);
      oar(o_ispl);
      oar(o_eser);
      oar(o_espl);
    }

    decltype(o_ab) i_ab;
    decltype(o_asc) i_asc;
    decltype(o_aus) i_aus;
    decltype(o_asi) i_asi;
    decltype(o_asl) i_asl;
    decltype(o_aull) i_aull;
    decltype(o_ad) i_ad;
    decltype(o_iser) i_iser;
    decltype(o_ispl) i_ispl;
    decltype(o_eser) i_eser;
    decltype(o_espl) i_espl;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_ab);
      iar(i_asc);
      iar(i_aus);
      iar(i_asi);
      iar(i_asl);
      iar(i_aull);
      iar(i_ad);
      iar(i_iser);
      iar(i_ispl);
      iar(i_eser);
      iar(i_espl);
    }

    CHECK_EQ(o_ab.load(), i_ab.load());
    CHECK_EQ(o_asc.load(), i_asc.load());
    CHECK_EQ(o_aus.load(), i_aus.load());
    CHECK_EQ(o_asi.load(), i_asi.load());
    CHECK_EQ(o_asl.load(), i_asl.load());
    CHECK_EQ(o_aull.load(), i_aull.load());
    CHECK_EQ(o_ad.load(), doctest::Approx(i_ad.load()).epsilon(1e-5L));
    CHECK_EQ(i_iser.load(), o_iser.load());
    CHECK_EQ(i_ispl.load(), o_ispl.load());
    CHECK_EQ(i_eser.load(), o_eser.load());
    CHECK_EQ(i_espl.load(), o_espl.load());
  }
}


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/basic_string.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "basic_string.hpp"

TEST_SUITE_BEGIN("basic_string");

TEST_CASE("binary_string")
{
  test_string_all<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_string")
{
  test_string_all<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_string_basic")
{
  test_string_basic<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_string_basic")
{
  test_string_basic<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

template <class IArchive, class OArchive, class Out, class In = Out>
void test_ws_in_out(Out const & o_value_with_ws)
{
  std::ostringstream os;
  {
    OArchive oar(os);
    oar(o_value_with_ws);
  }

  In i_value_with_ws;

  std::istringstream is(os.str());
  {
    IArchive iar(is);
    iar(i_value_with_ws);
  }

  CHECK(i_value_with_ws == o_value_with_ws);
}

TEST_CASE("xml_string_issue109")
{
  char strings[][20] = {
    "some text",
    "some text ",
    " some text",
    " some text ",
    "  ",
    "    text    ",
    " ]]> ",
    " &gt; > ]]> ",
    " < <]>] &lt; ",
    " &amp; &   "
  };

  for( size_t i=0; i<( sizeof( strings ) / sizeof( strings[0] ) ); ++i )
  {
    std::basic_string<char> o_string = strings[i];

    test_ws_in_out<cereal::XMLInputArchive, cereal::XMLOutputArchive>( o_string );
  }
}

TEST_CASE("xml_char_issue109")
{
  uint8_t chars[] = {
    ' ',
    '\t',
    '\n',
    '\r',
    '&',
    '>',
    '<',
    '\'',
    '"',
    '!',
    '|'
  };

  for( size_t i=0; i<( sizeof( chars ) / sizeof( chars[0] ) ); ++i )
  {
    test_ws_in_out<cereal::XMLInputArchive, cereal::XMLOutputArchive>( chars[i] );
  }

  for( size_t i=0; i<( sizeof( chars ) / sizeof( chars[0] ) ); ++i )
  {
    test_ws_in_out<cereal::XMLInputArchive, cereal::XMLOutputArchive>( int8_t( chars[i] ) );
  }

  for( size_t i=0; i<( sizeof( chars ) / sizeof( chars[0] ) ); ++i )
  {
    test_ws_in_out<cereal::XMLInputArchive, cereal::XMLOutputArchive>( char( chars[i] ) );
  }
}

template <class IArchive, class OArchive, class Out, size_t Nb, class In = Out>
void test_ws_in_out_array(Out const (&o_a_value_with_ws)[Nb])
{
    std::ostringstream os;
    {
        OArchive oar(os);
        for (const auto& o_value_with_ws : o_a_value_with_ws)
        {
            oar(o_value_with_ws);
        }
    }

    In i_a_value_with_ws[Nb];

    std::istringstream is(os.str());
    {
        IArchive iar(is);
        for (In& i_value_with_ws : i_a_value_with_ws)
        {
            iar(i_value_with_ws);
        }
    }

    for (size_t uiIndex = 0; uiIndex < Nb; ++uiIndex)
    {
        CHECK(i_a_value_with_ws[uiIndex] == o_a_value_with_ws[uiIndex]);
    }
}

TEST_CASE("xml_string_issue_consecutive_calls")
{
    std::string strings[] = {
        "some text",
        " some text",
        " some text ",
        "Long text without ws at the end",
        "some text ",
        " some text",
        " some text ",
    };

    test_ws_in_out_array<cereal::XMLInputArchive, cereal::XMLOutputArchive>(strings);
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/basic_string.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_BASIC_STRING_H_
#define CEREAL_TEST_BASIC_STRING_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_string_basic()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(size_t i=0; i<100; ++i)
  {
    std::basic_string<char> o_string  = random_basic_string<char>(gen);
    std::basic_string<char> o_string2 = "";
    std::basic_string<char> o_string3;

    std::ostringstream os;
    {
      OArchive oar(os);
      oar(o_string);
      oar(o_string2);
      oar(o_string3);
    }

    std::basic_string<char> i_string;
    std::basic_string<char> i_string2;
    std::basic_string<char> i_string3;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_string);
      iar(i_string2);
      iar(i_string3);
    }

    CHECK_EQ(i_string, o_string);
    CHECK_EQ(i_string2, o_string2);
    CHECK_EQ(i_string3, o_string3);
  }
}

template <class IArchive, class OArchive> inline
void test_string_all()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(size_t i=0; i<100; ++i)
  {
    std::basic_string<char> o_string        = random_basic_string<char>(gen);
    std::basic_string<wchar_t> o_wstring    = random_basic_string<wchar_t>(gen);
    std::basic_string<char16_t> o_u16string = random_basic_string<char16_t>(gen);
    std::basic_string<char32_t> o_u32string = random_basic_string<char32_t>(gen);

    std::ostringstream os;
    {
      OArchive oar(os);
      oar(o_string);
      oar(o_wstring);
      oar(o_u16string);
      oar(o_u32string);
    }

    std::basic_string<char> i_string;
    std::basic_string<wchar_t> i_wstring;
    std::basic_string<char16_t> i_u16string;
    std::basic_string<char32_t> i_u32string;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_string);
      iar(i_wstring);
      iar(i_u16string);
      iar(i_u32string);
    }

    CHECK_EQ(i_string, o_string);
    check_collection( i_wstring, o_wstring );
    check_collection( i_u16string, o_u16string );
    check_collection( i_u32string, o_u32string );
  }
}

#endif // CEREAL_TEST_BASIC_STRING_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/bitset.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "bitset.hpp"

TEST_SUITE_BEGIN("bitset");

TEST_CASE("binary_bitset")
{
  test_bitset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_bitset")
{
  test_bitset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_bitset")
{
  test_bitset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_bitset")
{
  test_bitset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/bitset.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_BITSET_H_
#define CEREAL_TEST_BITSET_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_bitset()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rng32  = [&](){ return random_binary_string<32>( gen ); };
  auto rng65  = [&](){ return random_binary_string<65>( gen ); };
  auto rng256 = [&](){ return random_binary_string<256>( gen ); };
  auto rng512 = [&](){ return random_binary_string<512>( gen ); };

  for(int ii=0; ii<100; ++ii)
  {
    std::bitset<32> o_bit32( rng32() );
    std::bitset<65> o_bit65( rng65() );
    std::bitset<256> o_bit256( rng256() );
    std::bitset<512> o_bit512( rng512() );
    std::bitset<32>  o_bit32_low( 0 );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_bit32);
      oar(o_bit65);
      oar(o_bit256);
      oar(o_bit512);
      oar(o_bit32_low);
    }

    std::bitset<32>  i_bit32;
    std::bitset<65>  i_bit65;
    std::bitset<256> i_bit256;
    std::bitset<512> i_bit512;
    std::bitset<32>  i_bit32_low( 0xffffffff );

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_bit32);
      iar(i_bit65);
      iar(i_bit256);
      iar(i_bit512);
      iar(i_bit32_low);
    }

    CHECK_EQ( o_bit32, i_bit32 );
    CHECK_EQ( o_bit65, i_bit65 );
    CHECK_EQ( o_bit256, i_bit256 );
    CHECK_EQ( o_bit512, i_bit512 );

    CHECK_EQ( o_bit32_low, i_bit32_low );
  }
}

#endif // CEREAL_TEST_BITSET_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/boost/CMakeLists.txt
================================================
file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)

# Build all of the non-special tests
foreach(TEST_SOURCE ${TESTS})
  message(STATUS ${TEST_SOURCE})

  string(REPLACE ".cpp" "" TEST_TARGET "${TEST_SOURCE}")
  set(TEST_TARGET "test_${TEST_TARGET}")

  add_executable(${TEST_TARGET} ${TEST_SOURCE})
  target_link_libraries(${TEST_TARGET} ${CEREAL_THREAD_LIBS})
  add_test("${TEST_TARGET}" "${TEST_TARGET}")

  # If we are on a 64-bit machine, create an extra 32-bit version of the test if portability testing is enabled
  if((NOT MSVC) AND (${CMAKE_SIZEOF_VOID_P} EQUAL 8) AND (NOT SKIP_PORTABILITY_TEST))
    add_executable(${TEST_TARGET}_32 ${TEST_SOURCE})
    set_target_properties(${TEST_TARGET}_32 PROPERTIES
      COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
    add_test("${TEST_TARGET}_32" "${TEST_TARGET}_32")
  endif()

endforeach()

if(NOT MSVC)
  # add tests to coverage
  foreach(TEST_SOURCE ${TESTS})
    string(REPLACE ".cpp" "" COVERAGE_TARGET "${TEST_SOURCE}")
    set(COVERAGE_TARGET "coverage_${COVERAGE_TARGET}")
    
    add_dependencies(coverage ${COVERAGE_TARGET})

    add_executable(${COVERAGE_TARGET} EXCLUDE_FROM_ALL ${TEST_SOURCE})
    set_target_properties(${COVERAGE_TARGET} PROPERTIES COMPILE_FLAGS "-coverage")
    set_target_properties(${COVERAGE_TARGET} PROPERTIES LINK_FLAGS "-coverage")
    set_target_properties(${COVERAGE_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/coverage")
    target_link_libraries(${COVERAGE_TARGET} ${CEREAL_THREAD_LIBS})
  endforeach()
endif(NOT MSVC)


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/boost/boost_variant.cpp
================================================
/*
  Copyright (c) 2015, Kyle Fleming
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "boost_variant.hpp"

TEST_SUITE_BEGIN("boost_variant");

TEST_CASE("binary_boost_variant")
{
  test_boost_variant<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_boost_variant")
{
  test_boost_variant<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_boost_variant")
{
  test_boost_variant<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_boost_variant")
{
  test_boost_variant<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/boost/boost_variant.hpp
================================================
/*
  Copyright (c) 2015, Kyle Fleming
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_BOOST_VARIANT_H_
#define CEREAL_TEST_BOOST_VARIANT_H_

#include "../common.hpp"
#include <cereal/types/boost_variant.hpp>
#include <boost/variant.hpp>

struct NonDefaultConstructible
{
    NonDefaultConstructible(int i) : index(i)
    {}

    template <class Archive>
    void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
    {
        ar( index );
    }
    int index;
};

namespace cereal
{
template <> struct LoadAndConstruct<NonDefaultConstructible>
{
    template <class Archive>
    static void load_and_construct( Archive & ar, cereal::construct<NonDefaultConstructible> & construct )
    {
        int i;
        ar( i );
        construct( i );
    }
};
} // end namespace cereal

template <class IArchive, class OArchive> inline
void test_boost_variant()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  using VariantType = boost::variant<int, double, std::string, NonDefaultConstructible>;

  VariantType o_bv1 = random_value<int>(gen);
  VariantType o_bv2 = random_value<double>(gen);
  VariantType o_bv3 = random_basic_string<char>(gen);
  VariantType o_bv4 = NonDefaultConstructible(random_value<int>(gen));

  std::ostringstream os;
  {
    OArchive oar(os);

    oar(o_bv1);
    oar(o_bv2);
    oar(o_bv3);
    oar(o_bv4);
  }

  decltype(o_bv1) i_bv1;
  decltype(o_bv2) i_bv2;
  decltype(o_bv3) i_bv3;
  decltype(o_bv4) i_bv4;

  std::istringstream is(os.str());
  {
    IArchive iar(is);

    iar(i_bv1);
    iar(i_bv2);
    iar(i_bv3);
    iar(i_bv4);
  }

  CHECK_EQ( boost::get<int>(i_bv1), boost::get<int>(o_bv1) );
  CHECK_EQ( boost::get<double>(i_bv2), doctest::Approx(boost::get<double>(o_bv2)).epsilon(1e-5) );
  CHECK_EQ( boost::get<std::string>(i_bv3), boost::get<std::string>(o_bv3) );
  CHECK_EQ( boost::get<NonDefaultConstructible>(i_bv4).index, boost::get<NonDefaultConstructible>(o_bv4).index );
}

#endif // CEREAL_TEST_BOOST_VARIANT_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/chrono.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "chrono.hpp"

TEST_SUITE_BEGIN("chrono");

TEST_CASE("binary_chrono")
{
  test_chrono<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_chrono")
{
  test_chrono<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_chrono")
{
  test_chrono<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_chrono")
{
  test_chrono<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/chrono.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_CHRONO_H_
#define CEREAL_TEST_CHRONO_H_

#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_chrono()
{
  for(int ii=0; ii<100; ++ii)
  {
    auto o_timePoint1 = std::chrono::system_clock::now();
    #ifndef CEREAL_OLDER_GCC
    auto o_timePoint2 = std::chrono::steady_clock::now();
    #endif // CEREAL_OLDER_GCC
    auto o_timePoint3 = std::chrono::high_resolution_clock::now();

    auto o_duration1 = std::chrono::system_clock::now() - o_timePoint1;
    #ifndef CEREAL_OLDER_GCC
    auto o_duration2 = std::chrono::steady_clock::now() - o_timePoint2;
    #endif // CEREAL_OLDER_GCC
    auto o_duration3 = std::chrono::high_resolution_clock::now() - o_timePoint3;

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_timePoint1);
      #ifndef CEREAL_OLDER_GCC
      oar(o_timePoint2);
      #endif // CEREAL_OLDER_GCC
      oar(o_timePoint3);
      oar(o_duration1);
      #ifndef CEREAL_OLDER_GCC
      oar(o_duration2);
      #endif // CEREAL_OLDER_GCC
      oar(o_duration3);
    }

    decltype(o_timePoint1) i_timePoint1;
    #ifndef CEREAL_OLDER_GCC
    decltype(o_timePoint2) i_timePoint2;
    #endif // CEREAL_OLDER_GCC
    decltype(o_timePoint3) i_timePoint3;
    decltype(o_duration1) i_duration1;
    #ifndef CEREAL_OLDER_GCC
    decltype(o_duration2) i_duration2;
    #endif // CEREAL_OLDER_GCC
    decltype(o_duration3) i_duration3;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_timePoint1);
      #ifndef CEREAL_OLDER_GCC
      iar(i_timePoint2);
      #endif // CEREAL_OLDER_GCC
      iar(i_timePoint3);
      iar(i_duration1);
      #ifndef CEREAL_OLDER_GCC
      iar(i_duration2);
      #endif // CEREAL_OLDER_GCC
      iar(i_duration3);
    }

    CHECK_EQ( o_timePoint1, i_timePoint1 );
    #ifndef CEREAL_OLDER_GCC
    CHECK_EQ( o_timePoint2, i_timePoint2 );
    #endif // CEREAL_OLDER_GCC
    CHECK_EQ( o_timePoint3, i_timePoint3 );
    CHECK_EQ( o_duration1, i_duration1 );
    #ifndef CEREAL_OLDER_GCC
    CHECK_EQ( o_duration2, i_duration2 );
    #endif // CEREAL_OLDER_GCC
    CHECK_EQ( o_duration3, i_duration3 );
  }
}

#endif // CEREAL_TEST_CHRONO_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cmake-config-module.cmake
================================================
if(CMAKE_VERSION LESS 3.0)
  message(FATAL_ERROR "Cereal can't be installed with CMake < 3.0")
endif()

get_filename_component(BINARY_DIR ${CMAKE_CURRENT_LIST_DIR}/../build ABSOLUTE)
get_filename_component(INSTALL_DIR ${CMAKE_CURRENT_LIST_DIR}/../out ABSOLUTE)

# cmake configure step for cereal
file(MAKE_DIRECTORY ${BINARY_DIR}/cereal)
execute_process(
  COMMAND ${CMAKE_COMMAND}
    -DJUST_INSTALL_CEREAL=1
    -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}
    ${CMAKE_CURRENT_LIST_DIR}/..
  WORKING_DIRECTORY ${BINARY_DIR}/cereal
  RESULT_VARIABLE result
)
if(result)
  message(FATAL_ERROR "Cereal cmake configure-step failed")
endif()

# cmake install cereal
execute_process(
  COMMAND ${CMAKE_COMMAND}
    --build ${BINARY_DIR}/cereal
    --target install
  RESULT_VARIABLE result
)
if(result)
  message(FATAL_ERROR "Cereal cmake install-step failed")
endif()

# create test project sources
file(WRITE ${BINARY_DIR}/test_source/CMakeLists.txt "
  cmake_minimum_required(VERSION ${CMAKE_VERSION})
  project(cereal-test-config-module)
  if(NOT MSVC)
      if(CMAKE_VERSION VERSION_LESS 3.1)
          set(CMAKE_CXX_FLAGS \"-std=c++11 \${CMAKE_CXX_FLAGS}\")
      else()
          set(CMAKE_CXX_STANDARD 11)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)
      endif()
  endif()
  find_package(cereal REQUIRED)
  add_executable(cereal-test-config-module main.cpp)
  target_link_libraries(cereal-test-config-module cereal)
  enable_testing()
  add_test(test-cereal-test-config-module cereal-test-config-module)
")
file(WRITE ${BINARY_DIR}/test_source/main.cpp "
  #include <cereal/archives/binary.hpp>
  #include <sstream>
  #include <cstdlib>
  struct MyData
  {
    int x = 0, y = 0, z = 0;
    void set() { x = 1; y = 2; z = 3; }
    bool is_set() const { return x == 1 && y == 2 && z == 3; }

    // This method lets cereal know which data members to serialize
    template<class Archive>
    void serialize(Archive & archive)
    {
      archive( x, y, z ); // serialize things by passing them to the archive
    }
  };
  int main()
  {
    std::stringstream ss; // any stream can be used

    {
      cereal::BinaryOutputArchive oarchive(ss); // Create an output archive

      MyData m1, m2, m3;
      m1.set();
      m2.set();
      m3.set();
      oarchive(m1, m2, m3); // Write the data to the archive
    }

    {
      cereal::BinaryInputArchive iarchive(ss); // Create an input archive

      MyData m1, m2, m3;
      iarchive(m1, m2, m3); // Read the data from the archive

      return (m1.is_set() && m2.is_set() && m3.is_set())
      ? EXIT_SUCCESS : EXIT_FAILURE;
    }
  }"
)
file(MAKE_DIRECTORY ${BINARY_DIR}/test)
execute_process(
  COMMAND ${CMAKE_COMMAND}
    -DCMAKE_PREFIX_PATH=${INSTALL_DIR}
    ${BINARY_DIR}/test_source
  WORKING_DIRECTORY ${BINARY_DIR}/test
  RESULT_VARIABLE result
)
if(result)
  message(FATAL_ERROR "Test cmake configure-step failed")
endif()

# cmake install cereal
execute_process(
  COMMAND ${CMAKE_COMMAND}
    --build ${BINARY_DIR}/test
  RESULT_VARIABLE result
)
if(result)
  message(FATAL_ERROR "Test cmake build-step failed")
endif()

execute_process(
  COMMAND ${CMAKE_CTEST_COMMAND}
  WORKING_DIRECTORY ${BINARY_DIR}/test
  RESULT_VARIABLE result
)

if(result)
  message(FATAL_ERROR "Test run failed")
endif()


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/common.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_COMMON_H_
#define CEREAL_TEST_COMMON_H_

#include <cereal/types/memory.hpp>
#include <cereal/types/array.hpp>
#include <cereal/types/atomic.hpp>
#include <cereal/types/valarray.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/deque.hpp>
#include <cereal/types/forward_list.hpp>
#include <cereal/types/list.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/queue.hpp>
#include <cereal/types/set.hpp>
#include <cereal/types/stack.hpp>
#include <cereal/types/unordered_map.hpp>
#include <cereal/types/unordered_set.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/tuple.hpp>
#include <cereal/types/bitset.hpp>
#include <cereal/types/complex.hpp>
#include <cereal/types/chrono.hpp>
#include <cereal/types/polymorphic.hpp>

#include <cereal/archives/binary.hpp>
#include <cereal/archives/portable_binary.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/archives/json.hpp>
#include <limits>
#include <random>

#include "doctest.h"

namespace std
{
  // Ostream overload for std::pair
  template<class F, class S> inline
  ::std::ostream & operator<<(::std::ostream & os, ::std::pair<F, S> const & p)
  {
    os << "([" << p.first << "], [" << p.second << "])";
    return os;
  }
}

// Checks that collections have equal size and all elements are the same
template <class T> inline
void check_collection( T const & a, T const & b )
{
  auto aIter = std::begin(a);
  auto aEnd  = std::end(a);
  auto bIter = std::begin(b);
  auto bEnd  = std::end(b);

  CHECK_EQ( std::distance(aIter, aEnd), std::distance(bIter, bEnd) );

  for( ; aIter != aEnd; ++aIter, ++bIter )
    CHECK_EQ( *aIter, *bIter );
}

template <class T> inline
void check_ptr_collection( T const & a, T const & b )
{
  auto aIter = std::begin(a);
  auto aEnd  = std::end(a);
  auto bIter = std::begin(b);
  auto bEnd  = std::end(b);

  CHECK_EQ( std::distance(aIter, aEnd), std::distance(bIter, bEnd) );

  for( ; aIter != aEnd; ++aIter, ++bIter )
    CHECK_EQ( **aIter, **bIter );
}

// Random Number Generation ===============================================
template<class T> inline
typename std::enable_if<std::is_floating_point<T>::value, T>::type
random_value(std::mt19937 & gen)
{ return std::uniform_real_distribution<T>(-10000.0, 10000.0)(gen); }

template<class T> inline
typename std::enable_if<std::is_integral<T>::value && sizeof(T) != sizeof(char), T>::type
random_value(std::mt19937 & gen)
{ return std::uniform_int_distribution<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen); }

template<class T> inline
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(char), T>::type
random_value(std::mt19937 & gen)
{ return static_cast<T>( std::uniform_int_distribution<int64_t>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen) ); }

template<class T> inline
typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type
random_value(std::mt19937 & gen)
{
  std::string s(std::uniform_int_distribution<int>(3, 30)(gen), ' ');
  for(char & c : s)
    c = static_cast<char>( std::uniform_int_distribution<int>( 'A', 'Z' )(gen) );
  return s;
}

size_t random_index( size_t min, size_t max, std::mt19937 & gen )
{
  return std::uniform_int_distribution<size_t>( min, max )(gen);
}

template<class C> inline
std::basic_string<C> random_basic_string(std::mt19937 & gen)
{
  std::basic_string<C> s(std::uniform_int_distribution<int>(3, 30)(gen), ' ');
  for(C & c : s)
    c = static_cast<C>( std::uniform_int_distribution<int>( 'A', 'Z' )(gen) );
  return s;
}

template <size_t N> inline
std::string random_binary_string(std::mt19937 & gen)
{
  std::string s(N, ' ');
  for(auto & c : s )
     c = static_cast<char>( std::uniform_int_distribution<int>( '0', '1' )(gen) );
  return s;
}

// Generic struct useful for testing many serialization functions
struct StructBase
{
  StructBase() {}
  StructBase( int xx, int yy ) : x( xx ), y( yy ) {}
  int x, y;
  bool operator==(StructBase const & other) const
  { return x == other.x && y == other.y; }
  bool operator!=(StructBase const & other) const
  { return x != other.x || y != other.y; }
  bool operator<(StructBase const & other) const
  {
    if (x < other.x) return true;
    else if(other.x < x) return false;
    else return (y < other.y);
  }
};

inline std::ostream& operator<<(std::ostream& os, StructBase const & s)
{
    os << "[x: " << s.x << " y: " << s.y << "]";
    return os;
}

struct StructInternalSerialize : StructBase
{
  StructInternalSerialize() : StructBase{0,0} {}
  StructInternalSerialize(int x_, int y_) : StructBase{x_,y_} {}
  template<class Archive>
    void serialize(Archive & ar)
    {
      ar(x, y);
    }
};

struct StructInternalSplit : StructBase
{
  StructInternalSplit() : StructBase{0,0} {}
  StructInternalSplit(int x_, int y_) : StructBase{x_,y_} {}
  template<class Archive>
    void save(Archive & ar) const
    {
      ar(x, y);
    }

  template<class Archive>
    void load(Archive & ar)
    {
      ar(x, y);
    }
};

struct StructExternalSerialize : StructBase
{
  StructExternalSerialize() : StructBase{0,0} {}
  StructExternalSerialize(int x_, int y_) : StructBase{x_,y_} {}
};

template<class Archive>
void serialize(Archive & ar, StructExternalSerialize & s)
{
  ar(s.x, s.y);
}

struct StructExternalSplit : StructBase
{
  StructExternalSplit() : StructBase{0,0} {}
  StructExternalSplit(int x_, int y_) : StructBase{x_,y_} {}
};

template<class Archive> inline
void save(Archive & ar, StructExternalSplit const & s)
{
  ar(s.x, s.y);
}

template<class Archive> inline
void load(Archive & ar, StructExternalSplit & s)
{
  ar(s.x, s.y);
}

template<class T>
struct StructHash {
  public:
    size_t operator()(const T & s) const
    {
      size_t h1 = std::hash<int>()(s.x);
      size_t h2 = std::hash<int>()(s.y);
      return h1 ^ ( h2 << 1 );
    }
};

#endif // CEREAL_TEST_COMMON_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/complex.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "complex.hpp"

TEST_SUITE_BEGIN("complex");

TEST_CASE("binary_complex")
{
  test_complex<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_complex")
{
  test_complex<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_complex")
{
  test_complex<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_complex")
{
  test_complex<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/complex.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_COMPLEX_H_
#define CEREAL_TEST_COMPLEX_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_complex()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rngF = [&](){ return random_value<float>(gen); };
  auto rngD = [&](){ return random_value<double>(gen); };
  auto rngLD = [&](){ return random_value<long double>(gen); };

  for(int ii=0; ii<100; ++ii)
  {
    std::complex<float> o_float( rngF(), rngF() );
    std::complex<double> o_double( rngD(), rngD() );
    std::complex<long double> o_ldouble( rngLD(), rngLD() );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_float);
      oar(o_double);
      oar(o_ldouble);
    }

    std::complex<float> i_float;
    std::complex<double> i_double;
    std::complex<long double> i_ldouble;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_float);
      iar(i_double);
      iar(i_ldouble);
    }

    CHECK_EQ( o_float, i_float );
    CHECK_EQ( o_double.real(), doctest::Approx(i_double.real()).epsilon(1e-5) );
    CHECK_EQ( o_double.imag(), doctest::Approx(i_double.imag()).epsilon(1e-5) );
    CHECK_EQ( o_ldouble.real(), doctest::Approx(i_ldouble.real()).epsilon(1e-5L) );
    CHECK_EQ( o_ldouble.imag(), doctest::Approx(i_ldouble.imag()).epsilon(1e-5L) );
  }
}

#endif // CEREAL_TEST_COMPLEX_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cpp17/CMakeLists.txt
================================================
file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)

# Build all of the non-special tests
foreach(TEST_SOURCE ${TESTS})
  message(STATUS ${TEST_SOURCE})

  string(REPLACE ".cpp" "" TEST_TARGET "${TEST_SOURCE}")
  set(TEST_TARGET "test_cpp17_${TEST_TARGET}")

  add_executable(${TEST_TARGET} ${TEST_SOURCE})
  target_link_libraries(${TEST_TARGET} ${CEREAL_THREAD_LIBS})
  add_test("${TEST_TARGET}" "${TEST_TARGET}")

  # If we are on a 64-bit machine, create an extra 32-bit version of the test if portability testing is enabled
  if((NOT MSVC) AND (${CMAKE_SIZEOF_VOID_P} EQUAL 8) AND (NOT SKIP_PORTABILITY_TEST))
    add_executable(${TEST_TARGET}_32 ${TEST_SOURCE})
    set_target_properties(${TEST_TARGET}_32 PROPERTIES
      COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
    add_test("${TEST_TARGET}_32" "${TEST_TARGET}_32")
  endif()

endforeach()

if(NOT MSVC)
  # add tests to coverage
  foreach(TEST_SOURCE ${TESTS})
    string(REPLACE ".cpp" "" COVERAGE_TARGET "${TEST_SOURCE}")
    set(COVERAGE_TARGET "coverage_cpp17_${COVERAGE_TARGET}")
    
    add_dependencies(coverage ${COVERAGE_TARGET})

    add_executable(${COVERAGE_TARGET} EXCLUDE_FROM_ALL ${TEST_SOURCE})
    set_target_properties(${COVERAGE_TARGET} PROPERTIES COMPILE_FLAGS "-coverage")
    set_target_properties(${COVERAGE_TARGET} PROPERTIES LINK_FLAGS "-coverage")
    set_target_properties(${COVERAGE_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/coverage")
    target_link_libraries(${COVERAGE_TARGET} ${CEREAL_THREAD_LIBS})
  endforeach()
endif(NOT MSVC)


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cpp17/optional.cpp
================================================
/*
  Copyright (c) 2017, Juan Pedro Bolivar Puente
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "optional.hpp"

#ifdef CEREAL_HAS_CPP17

TEST_SUITE_BEGIN("std_optional");

TEST_CASE("binary_std_optional")
{
  test_std_optional<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_std_optional")
{
  test_std_optional<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_std_optional")
{
  test_std_optional<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_std_optional")
{
  test_std_optional<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();

#endif // CEREAL_HAS_CPP17


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cpp17/optional.hpp
================================================
/*
  Copyright (c) 2017, Juan Pedro Bolivar Puente
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_CPP17_OPTIONAL_H_
#define CEREAL_TEST_CPP17_OPTIONAL_H_
#include "../common.hpp"

#ifdef CEREAL_HAS_CPP17
#include <cereal/types/optional.hpp>

template <class IArchive, class OArchive> inline
void test_std_optional()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  std::optional<int> o_o1 = random_value<int>(gen);
  std::optional<double> o_o2 = random_value<double>(gen);
  std::optional<std::string> o_o3 = random_basic_string<char>(gen);
  std::optional<int> o_o4 = std::nullopt;
  std::optional<double> o_o5 = std::nullopt;
  std::optional<std::string> o_o6 = std::nullopt;
  std::optional<std::optional<long>> o_o7 = std::make_optional<std::optional<long>>( std::make_optional<long>( random_value<long>(gen) ) );

  std::ostringstream os;
  {
    OArchive oar(os);

    oar(o_o1);
    oar(o_o2);
    oar(o_o3);
    oar(o_o4);
    oar(o_o5);
    oar(o_o6);
    oar(o_o7);
  }

  decltype(o_o1) i_o1;
  decltype(o_o2) i_o2;
  decltype(o_o3) i_o3;
  decltype(o_o4) i_o4{1}; // initialize with non-nullopt
  decltype(o_o5) i_o5{1.0};
  decltype(o_o6) i_o6{"1"};
  decltype(o_o7) i_o7;

  std::istringstream is(os.str());
  {
    IArchive iar(is);

    iar(i_o1);
    iar(i_o2);
    iar(i_o3);
    iar(i_o4);
    iar(i_o5);
    iar(i_o6);
    iar(i_o7);
  }

  CHECK_EQ( *i_o1, *o_o1 );
  CHECK_EQ( *i_o2, doctest::Approx(*o_o2).epsilon(1e-5) );
  CHECK_EQ( *i_o3, *o_o3 );
  CHECK_EQ( i_o4.has_value(), o_o4.has_value() );
  CHECK_EQ( i_o5.has_value(), o_o5.has_value() );
  CHECK_EQ( i_o6.has_value(), o_o6.has_value() );
  CHECK_EQ( **i_o7, **o_o7 );
}

#endif // CEREAL_HAS_CPP17
#endif // CEREAL_TEST_CPP17_OPTIONAL_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cpp17/variant.cpp
================================================
/*
  Copyright (c) 2015, Kyle Fleming, Juan Pedro Bolivar Puente
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "variant.hpp"

#ifdef CEREAL_HAS_CPP17

TEST_SUITE_BEGIN("std_variant");

TEST_CASE("binary_std_variant")
{
  test_std_variant<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_std_variant")
{
  test_std_variant<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_std_variant")
{
  test_std_variant<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_std_variant")
{
  test_std_variant<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();

#endif // CEREAL_HAS_CPP17


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/cpp17/variant.hpp
================================================
/*
  Copyright (c) 2015, Kyle Fleming, Juan Pedro Bolivar Puente
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CEREAL_TEST_CPP17_VARIANT_H_
#define CEREAL_TEST_CPP17_VARIANT_H_
#include "../common.hpp"

#ifdef CEREAL_HAS_CPP17

#include <cereal/types/variant.hpp>

template <class IArchive, class OArchive> inline
void test_std_variant()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  std::variant<int, double, std::string> o_bv1 = random_value<int>(gen);
  std::variant<int, double, std::string> o_bv2 = random_value<double>(gen);
  std::variant<int, double, std::string> o_bv3 = random_basic_string<char>(gen);

  std::ostringstream os;
  {
    OArchive oar(os);

    oar(o_bv1);
    oar(o_bv2);
    oar(o_bv3);
  }

  decltype(o_bv1) i_bv1;
  decltype(o_bv2) i_bv2;
  decltype(o_bv3) i_bv3;

  std::istringstream is(os.str());
  {
    IArchive iar(is);

    iar(i_bv1);
    iar(i_bv2);
    iar(i_bv3);
  }

  CHECK_EQ( std::get<int>(i_bv1), std::get<int>(o_bv1) );
  CHECK_EQ( std::get<double>(i_bv2), doctest::Approx(std::get<double>(o_bv2)).epsilon(1e-5) );
  CHECK_EQ( std::get<std::string>(i_bv3), std::get<std::string>(o_bv3) );
}

#endif // CEREAL_HAS_CPP17
#endif // CEREAL_TEST_CPP17_VARIANT_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/defer.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "defer.hpp"

TEST_SUITE_BEGIN("defer");

TEST_CASE("binary_defer")
{
  test_defer<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_defer")
{
  test_defer<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_defer")
{
  test_defer<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_defer")
{
  test_defer<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/defer.hpp
================================================
/*
  Copyright (c) 2017, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_DEFER_H_
#define CEREAL_TEST_DEFER_H_
#include "common.hpp"

struct DeferNode;

struct DeferRelation
{
  std::shared_ptr<DeferNode> node;
  int x;
  std::string y;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( node, x, y );
  }

  bool operator==( DeferRelation const & other ) const;
};

struct DeferNode
{
  DeferNode() = default;
  DeferNode( size_t id_, std::mt19937 & gen ) :
      id(id_),
      w(random_value<long>(gen)),
      iser{random_value<int>(gen), random_value<int>(gen)},
      ispl{random_value<int>(gen), random_value<int>(gen)},
      eser{random_value<int>(gen), random_value<int>(gen)},
      espl{random_value<int>(gen), random_value<int>(gen)},
      relations(),
      z(random_value<char>(gen))
  { }

  size_t id;
  long w;

  StructInternalSerialize iser;
  StructInternalSplit     ispl;
  StructExternalSerialize eser;
  StructExternalSplit     espl;

  std::vector<DeferRelation> relations;

  char z;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( id, w,
        cereal::defer( iser ),
        cereal::defer( ispl ),
        cereal::defer( eser ),
        cereal::defer( espl ),
        cereal::defer( relations ),
        z );
  }

  bool operator==( DeferNode const & other ) const
  {
    bool relationsEqual = true;

    if( relations.size() == other.relations.size() )
      for( size_t i = 0; i < relations.size(); ++i )
        relationsEqual &= relations[i] == other.relations[i];
    else
      relationsEqual = false;

    return id == other.id && w == other.w &&
           iser == other.iser && ispl == other.ispl &&
           eser == other.eser && espl == other.espl &&
           relationsEqual;
  }
};

inline std::ostream& operator<<(std::ostream& os, DeferRelation const & s)
{
  os << "[node(id): " << (s.node ? std::to_string(s.node->id) : "null") << " x: " << s.x << " y: " << s.y << "]";
  return os;
}


bool DeferRelation::operator==( DeferRelation const & other ) const
{
  return x == other.x && y == other.y && node->id == other.node->id;
}


inline std::ostream& operator<<(std::ostream& os, DeferNode const & s)
{
  os << "[id: " << s.id << " w " << s.w << " iser " << s.iser;
  os << " ispl " << s.ispl << " eser " << s.eser << " espl " << s.espl;
  os << " relations (size: " << s.relations.size() << "): ";
  for( auto & r : s.relations )
    os << r;
  os << " z " << s.z << "]";
  return os;
}

template <class IArchive, class OArchive> inline
void test_defer()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    size_t id = 0;
    std::vector<std::shared_ptr<DeferNode>> o_nodes0(1);
    for( auto & node : o_nodes0 )
      node = std::make_shared<DeferNode>(id++, gen);

    std::vector<std::shared_ptr<DeferNode>> o_nodes1(1);
    for( auto & node : o_nodes1 )
      node = std::make_shared<DeferNode>(id++, gen);

    std::shuffle( o_nodes1.begin(), o_nodes1.end(), gen );

    for( auto & node : o_nodes0 )
    {
      node->relations.resize( random_index( 0, 100, gen ) );
      for (auto & r : node->relations)
      {
        r = { o_nodes0[random_index( 0, o_nodes0.size() - 1, gen )],
             random_value<int>( gen ), random_basic_string<char>( gen ) };
      }
    }

    for( auto & node : o_nodes1 )
    {
      node->relations.resize( random_index( 0, 100, gen ) );
      for (auto & r : node->relations)
      {
        r = { o_nodes0[random_index( 0, o_nodes0.size() - 1, gen )],
             random_value<int>( gen ), random_basic_string<char>( gen ) };
      }
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_nodes0 );
      oar( o_nodes1 );
      oar.serializeDeferments();
      // TODO: throw exception if deferments not done when destructor fires
    }

    decltype(o_nodes0) i_nodes0;
    decltype(o_nodes1) i_nodes1;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_nodes0 );
      iar( i_nodes1 );
      iar.serializeDeferments();
    }

    check_ptr_collection(o_nodes0, i_nodes0);
    check_ptr_collection(o_nodes1, i_nodes1);
  }
}

#endif // CEREAL_TEST_DEFER_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/deque.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "deque.hpp"

TEST_SUITE_BEGIN("deque");

TEST_CASE("binary_dequeue")
{
  test_deque<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_dequeue")
{
  test_deque<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_dequeue")
{
  test_deque<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_dequeue")
{
  test_deque<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/deque.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_DEQUE_H_
#define CEREAL_TEST_DEQUE_H_
#include "common.hpp"

template <class IArchive, class OArchive>
void test_deque()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::deque<int> o_poddeque(100);
    for(auto & elem : o_poddeque)
      elem = random_value<int>(gen);

    std::deque<StructInternalSerialize> o_iserdeque(100);
    for(auto & elem : o_iserdeque)
      elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::deque<StructInternalSplit> o_ispldeque(100);
    for(auto & elem : o_ispldeque)
      elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::deque<StructExternalSerialize> o_eserdeque(100);
    for(auto & elem : o_eserdeque)
      elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::deque<StructExternalSplit> o_espldeque(100);
    for(auto & elem : o_espldeque)
      elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_poddeque);
      oar(o_iserdeque);
      oar(o_ispldeque);
      oar(o_eserdeque);
      oar(o_espldeque);
    }

    std::deque<int> i_poddeque;
    std::deque<StructInternalSerialize> i_iserdeque;
    std::deque<StructInternalSplit>     i_ispldeque;
    std::deque<StructExternalSerialize> i_eserdeque;
    std::deque<StructExternalSplit>     i_espldeque;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_poddeque);
      iar(i_iserdeque);
      iar(i_ispldeque);
      iar(i_eserdeque);
      iar(i_espldeque);
    }

    CHECK_EQ(i_poddeque.size(),  o_poddeque.size());
    CHECK_EQ(i_iserdeque.size(), o_iserdeque.size());
    CHECK_EQ(i_ispldeque.size(), o_ispldeque.size());
    CHECK_EQ(i_eserdeque.size(), o_eserdeque.size());
    CHECK_EQ(i_espldeque.size(), o_espldeque.size());

    check_collection(i_poddeque,  o_poddeque );
    check_collection(i_iserdeque, o_iserdeque);
    check_collection(i_ispldeque, o_ispldeque);
    check_collection(i_eserdeque, o_eserdeque);
    check_collection(i_espldeque, o_espldeque);
  }
}

#endif // CEREAL_TEST_DEQUE_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/doctest.h
================================================
// ====================================================================== lgtm [cpp/missing-header-guard]
// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! ==
// ======================================================================
//
// doctest.h - the lightest feature-rich C++ single-header testing framework for unit tests and TDD
//
// Copyright (c) 2016-2019 Viktor Kirilov
//
// Distributed under the MIT Software License
// See accompanying file LICENSE.txt or copy at
// https://opensource.org/licenses/MIT
//
// The documentation can be found at the library's page:
// https://github.com/onqtam/doctest/blob/master/doc/markdown/readme.md
//
// =================================================================================================
// =================================================================================================
// =================================================================================================
//
// The library is heavily influenced by Catch - https://github.com/catchorg/Catch2
// which uses the Boost Software License - Version 1.0
// see here - https://github.com/catchorg/Catch2/blob/master/LICENSE.txt
//
// The concept of subcases (sections in Catch) and expression decomposition are from there.
// Some parts of the code are taken directly:
// - stringification - the detection of "ostream& operator<<(ostream&, const T&)" and StringMaker<>
// - the Approx() helper class for floating point comparison
// - colors in the console
// - breaking into a debugger
// - signal / SEH handling
// - timer
// - XmlWriter class - thanks to Phil Nash for allowing the direct reuse (AKA copy/paste)
//
// The expression decomposing templates are taken from lest - https://github.com/martinmoene/lest
// which uses the Boost Software License - Version 1.0
// see here - https://github.com/martinmoene/lest/blob/master/LICENSE.txt
//
// =================================================================================================
// =================================================================================================
// =================================================================================================

#ifndef DOCTEST_LIBRARY_INCLUDED
#define DOCTEST_LIBRARY_INCLUDED

// =================================================================================================
// == VERSION ======================================================================================
// =================================================================================================

#define DOCTEST_VERSION_MAJOR 2
#define DOCTEST_VERSION_MINOR 3
#define DOCTEST_VERSION_PATCH 5
#define DOCTEST_VERSION_STR "2.3.5"

#define DOCTEST_VERSION                                                                            \
    (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH)

// =================================================================================================
// == COMPILER VERSION =============================================================================
// =================================================================================================

// ideas for the version stuff are taken from here: https://github.com/cxxstuff/cxx_detect

#define DOCTEST_COMPILER(MAJOR, MINOR, PATCH) ((MAJOR)*10000000 + (MINOR)*100000 + (PATCH))

// GCC/Clang and GCC/MSVC are mutually exclusive, but Clang/MSVC are not because of clang-cl...
#if defined(_MSC_VER) && defined(_MSC_FULL_VER)
#if _MSC_VER == _MSC_FULL_VER / 10000
#define DOCTEST_MSVC DOCTEST_COMPILER(_MSC_VER / 100, _MSC_VER % 100, _MSC_FULL_VER % 10000)
#else // MSVC
#define DOCTEST_MSVC                                                                               \
    DOCTEST_COMPILER(_MSC_VER / 100, (_MSC_FULL_VER / 100000) % 100, _MSC_FULL_VER % 100000)
#endif // MSVC
#endif // MSVC
#if defined(__clang__) && defined(__clang_minor__)
#define DOCTEST_CLANG DOCTEST_COMPILER(__clang_major__, __clang_minor__, __clang_patchlevel__)
#elif defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) &&              \
        !defined(__INTEL_COMPILER)
#define DOCTEST_GCC DOCTEST_COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#endif // GCC

#ifndef DOCTEST_MSVC
#define DOCTEST_MSVC 0
#endif // DOCTEST_MSVC
#ifndef DOCTEST_CLANG
#define DOCTEST_CLANG 0
#endif // DOCTEST_CLANG
#ifndef DOCTEST_GCC
#define DOCTEST_GCC 0
#endif // DOCTEST_GCC

// =================================================================================================
// == COMPILER WARNINGS HELPERS ====================================================================
// =================================================================================================

#if DOCTEST_CLANG
#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH _Pragma("clang diagnostic push")
#define DOCTEST_CLANG_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(clang diagnostic ignored w)
#define DOCTEST_CLANG_SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop")
#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)                                                \
    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING(w)
#else // DOCTEST_CLANG
#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
#define DOCTEST_CLANG_SUPPRESS_WARNING(w)
#define DOCTEST_CLANG_SUPPRESS_WARNING_POP
#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)
#endif // DOCTEST_CLANG

#if DOCTEST_GCC
#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH _Pragma("GCC diagnostic push")
#define DOCTEST_GCC_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(GCC diagnostic ignored w)
#define DOCTEST_GCC_SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop")
#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)                                                  \
    DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_GCC_SUPPRESS_WARNING(w)
#else // DOCTEST_GCC
#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH
#define DOCTEST_GCC_SUPPRESS_WARNING(w)
#define DOCTEST_GCC_SUPPRESS_WARNING_POP
#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)
#endif // DOCTEST_GCC

#if DOCTEST_MSVC
#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH __pragma(warning(push))
#define DOCTEST_MSVC_SUPPRESS_WARNING(w) __pragma(warning(disable : w))
#define DOCTEST_MSVC_SUPPRESS_WARNING_POP __pragma(warning(pop))
#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)                                                 \
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH DOCTEST_MSVC_SUPPRESS_WARNING(w)
#else // DOCTEST_MSVC
#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
#define DOCTEST_MSVC_SUPPRESS_WARNING(w)
#define DOCTEST_MSVC_SUPPRESS_WARNING_POP
#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)
#endif // DOCTEST_MSVC

// =================================================================================================
// == COMPILER WARNINGS ============================================================================
// =================================================================================================

DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wnon-virtual-dtor")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wdeprecated")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-local-typedef")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")

DOCTEST_GCC_SUPPRESS_WARNING_PUSH
DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas")
DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas")
DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++")
DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow")
DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing")
DOCTEST_GCC_SUPPRESS_WARNING("-Wctor-dtor-privacy")
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations")
DOCTEST_GCC_SUPPRESS_WARNING("-Wnon-virtual-dtor")
DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-local-typedefs")
DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast")
DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")
DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-promo")

DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
DOCTEST_MSVC_SUPPRESS_WARNING(4616) // invalid compiler warning
DOCTEST_MSVC_SUPPRESS_WARNING(4619) // invalid compiler warning
DOCTEST_MSVC_SUPPRESS_WARNING(4996) // The compiler encountered a deprecated declaration
DOCTEST_MSVC_SUPPRESS_WARNING(4706) // assignment within conditional expression
DOCTEST_MSVC_SUPPRESS_WARNING(4512) // 'class' : assignment operator could not be generated
DOCTEST_MSVC_SUPPRESS_WARNING(4127) // conditional expression is constant
DOCTEST_MSVC_SUPPRESS_WARNING(4820) // padding
DOCTEST_MSVC_SUPPRESS_WARNING(4625) // copy constructor was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(4626) // assignment operator was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(5027) // move assignment operator was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(5026) // move constructor was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(4623) // default constructor was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(4640) // construction of local static object is not thread-safe
// static analysis
DOCTEST_MSVC_SUPPRESS_WARNING(26439) // This kind of function may not throw. Declare it 'noexcept'
DOCTEST_MSVC_SUPPRESS_WARNING(26495) // Always initialize a member variable
DOCTEST_MSVC_SUPPRESS_WARNING(26451) // Arithmetic overflow ...
DOCTEST_MSVC_SUPPRESS_WARNING(26444) // Avoid unnamed objects with custom construction and dtr...

// 4548 - expression before comma has no effect; expected expression with side - effect
// 4265 - class has virtual functions, but destructor is not virtual
// 4986 - exception specification does not match previous declaration
// 4350 - behavior change: 'member1' called instead of 'member2'
// 4668 - 'x' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
// 4365 - conversion from 'int' to 'unsigned long', signed/unsigned mismatch
// 4774 - format string expected in argument 'x' is not a string literal
// 4820 - padding in structs

// only 4 should be disabled globally:
// - 4514 # unreferenced inline function has been removed
// - 4571 # SEH related
// - 4710 # function not inlined
// - 4711 # function 'x' selected for automatic inline expansion

#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN                                 \
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH                                                             \
    DOCTEST_MSVC_SUPPRESS_WARNING(4548)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4265)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4986)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4350)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4668)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4365)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4774)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4820)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4625)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4626)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(5027)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(5026)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(4623)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(5039)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(5045)                                                            \
    DOCTEST_MSVC_SUPPRESS_WARNING(5105)

#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END DOCTEST_MSVC_SUPPRESS_WARNING_POP

// =================================================================================================
// == FEATURE DETECTION ============================================================================
// =================================================================================================

// general compiler feature support table: https://en.cppreference.com/w/cpp/compiler_support
// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx
// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html
// MSVC version table:
// https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
// MSVC++ 14.2 (16) _MSC_VER == 1920 (Visual Studio 2019)
// MSVC++ 14.1 (15) _MSC_VER == 1910 (Visual Studio 2017)
// MSVC++ 14.0      _MSC_VER == 1900 (Visual Studio 2015)
// MSVC++ 12.0      _MSC_VER == 1800 (Visual Studio 2013)
// MSVC++ 11.0      _MSC_VER == 1700 (Visual Studio 2012)
// MSVC++ 10.0      _MSC_VER == 1600 (Visual Studio 2010)
// MSVC++ 9.0       _MSC_VER == 1500 (Visual Studio 2008)
// MSVC++ 8.0       _MSC_VER == 1400 (Visual Studio 2005)

#if DOCTEST_MSVC && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
#define DOCTEST_CONFIG_WINDOWS_SEH
#endif // MSVC
#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH)
#undef DOCTEST_CONFIG_WINDOWS_SEH
#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH

#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) &&             \
        !defined(__EMSCRIPTEN__)
#define DOCTEST_CONFIG_POSIX_SIGNALS
#endif // _WIN32
#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS)
#undef DOCTEST_CONFIG_POSIX_SIGNALS
#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS

#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)
#define DOCTEST_CONFIG_NO_EXCEPTIONS
#endif // no exceptions
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS

#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
#define DOCTEST_CONFIG_NO_EXCEPTIONS
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS

#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS)
#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS

#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT)
#define DOCTEST_CONFIG_IMPLEMENT
#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

#if defined(_WIN32) || defined(__CYGWIN__)
#if DOCTEST_MSVC
#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport)
#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport)
#else // MSVC
#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport))
#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport))
#endif // MSVC
#else  // _WIN32
#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default")))
#define DOCTEST_SYMBOL_IMPORT
#endif // _WIN32

#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
#ifdef DOCTEST_CONFIG_IMPLEMENT
#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT
#else // DOCTEST_CONFIG_IMPLEMENT
#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT
#endif // DOCTEST_CONFIG_IMPLEMENT
#else  // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
#define DOCTEST_INTERFACE
#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL

#define DOCTEST_EMPTY

#if DOCTEST_MSVC
#define DOCTEST_NOINLINE __declspec(noinline)
#define DOCTEST_UNUSED
#define DOCTEST_ALIGNMENT(x)
#define DOCTEST_NORETURN __declspec(noreturn)
#if DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0)
#define DOCTEST_THREAD_LOCAL /* not supported */
#define DOCTEST_NOEXCEPT /* not supported */
#else
#define DOCTEST_THREAD_LOCAL __declspec(thread)
#define DOCTEST_NOEXCEPT noexcept
#endif // MSVC version >= 19
#else // MSVC
#define DOCTEST_NOINLINE __attribute__((noinline))
#define DOCTEST_UNUSED __attribute__((unused))
#define DOCTEST_ALIGNMENT(x) __attribute__((aligned(x)))
#define DOCTEST_NORETURN __attribute__((noreturn))
#if DOCTEST_GCC < DOCTEST_COMPILER(4, 8, 0)
#define DOCTEST_THREAD_LOCAL /* not supported */
#else // GCC >= 4.8.0
#define DOCTEST_THREAD_LOCAL thread_local
#endif // GCC version
#define DOCTEST_NOEXCEPT noexcept
#endif // NOT MSVC


// =================================================================================================
// == FEATURE DETECTION END ========================================================================
// =================================================================================================

// internal macros for string concatenation and anonymous variable name generation
#define DOCTEST_CAT_IMPL(s1, s2) s1##s2
#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2)
#ifdef __COUNTER__ // not standard and may be missing for some compilers
#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__)
#else // __COUNTER__
#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__)
#endif // __COUNTER__

#define DOCTEST_TOSTR(x) #x

#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
#define DOCTEST_REF_WRAP(x) x&
#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
#define DOCTEST_REF_WRAP(x) x
#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE

// not using __APPLE__ because... this is how Catch does it
#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
#define DOCTEST_PLATFORM_MAC
#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
#define DOCTEST_PLATFORM_IPHONE
#elif defined(_WIN32)
#define DOCTEST_PLATFORM_WINDOWS
#else // DOCTEST_PLATFORM
#define DOCTEST_PLATFORM_LINUX
#endif // DOCTEST_PLATFORM

#define DOCTEST_GLOBAL_NO_WARNINGS(var)                                                            \
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wglobal-constructors")                              \
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-variable")                                            \
    static int var DOCTEST_UNUSED // NOLINT(fuchsia-statically-constructed-objects,cert-err58-cpp)
#define DOCTEST_GLOBAL_NO_WARNINGS_END() DOCTEST_CLANG_SUPPRESS_WARNING_POP

#ifndef DOCTEST_BREAK_INTO_DEBUGGER
// should probably take a look at https://github.com/scottt/debugbreak
#ifdef DOCTEST_PLATFORM_MAC
#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :)
#elif DOCTEST_MSVC
#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak()
#elif defined(__MINGW32__)
DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wredundant-decls")
extern "C" __declspec(dllimport) void __stdcall DebugBreak();
DOCTEST_GCC_SUPPRESS_WARNING_POP
#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak()
#else // linux
#define DOCTEST_BREAK_INTO_DEBUGGER() ((void)0)
#endif // linux
#endif // DOCTEST_BREAK_INTO_DEBUGGER

// this is kept here for backwards compatibility since the config option was changed
#ifdef DOCTEST_CONFIG_USE_IOSFWD
#define DOCTEST_CONFIG_USE_STD_HEADERS
#endif // DOCTEST_CONFIG_USE_IOSFWD

#ifdef DOCTEST_CONFIG_USE_STD_HEADERS
#include <iosfwd>
#include <cstddef>
#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183
#include <ostream>
#endif // VS 2019
#else // DOCTEST_CONFIG_USE_STD_HEADERS

#if DOCTEST_CLANG
// to detect if libc++ is being used with clang (the _LIBCPP_VERSION identifier)
#include <ciso646>
#endif // clang

#ifdef _LIBCPP_VERSION
#define DOCTEST_STD_NAMESPACE_BEGIN _LIBCPP_BEGIN_NAMESPACE_STD
#define DOCTEST_STD_NAMESPACE_END _LIBCPP_END_NAMESPACE_STD
#else // _LIBCPP_VERSION
#define DOCTEST_STD_NAMESPACE_BEGIN namespace std {
#define DOCTEST_STD_NAMESPACE_END }
#endif // _LIBCPP_VERSION

// Forward declaring 'X' in namespace std is not permitted by the C++ Standard.
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4643)

DOCTEST_STD_NAMESPACE_BEGIN // NOLINT (cert-dcl58-cpp)
typedef decltype(nullptr) nullptr_t;
template <class charT>
struct char_traits;
template <>
struct char_traits<char>;
template <class charT, class traits>
class basic_ostream;
typedef basic_ostream<char, char_traits<char>> ostream;
template <class... Types>
class tuple;
#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183
template <class _Ty>
class allocator;
template <class _Elem, class _Traits, class _Alloc>
class basic_string;
using string = basic_string<char, char_traits<char>, allocator<char>>;
#endif // VS 2019
DOCTEST_STD_NAMESPACE_END

DOCTEST_MSVC_SUPPRESS_WARNING_POP

#endif // DOCTEST_CONFIG_USE_STD_HEADERS

#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
#include <type_traits>
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

namespace doctest {

DOCTEST_INTERFACE extern bool is_running_in_test;

// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length
// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for:
// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128)
// - if small - capacity left before going on the heap - using the lowest 5 bits
// - if small - 2 bits are left unused - the second and third highest ones
// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator)
//              and the "is small" bit remains "0" ("as well as the capacity left") so its OK
// Idea taken from this lecture about the string implementation of facebook/folly - fbstring
// https://www.youtube.com/watch?v=kPR8h4-qZdk
// TODO:
// - optimizations - like not deleting memory unnecessarily in operator= and etc.
// - resize/reserve/clear
// - substr
// - replace
// - back/front
// - iterator stuff
// - find & friends
// - push_back/pop_back
// - assign/insert/erase
// - relational operators as free functions - taking const char* as one of the params
class DOCTEST_INTERFACE String
{
    static const unsigned len  = 24;      //!OCLINT avoid private static members
    static const unsigned last = len - 1; //!OCLINT avoid private static members

    struct view // len should be more than sizeof(view) - because of the final byte for flags
    {
        char*    ptr;
        unsigned size;
        unsigned capacity;
    };

    union
    {
        char buf[len];
        view data;
    };

    bool isOnStack() const { return (buf[last] & 128) == 0; }
    void setOnHeap();
    void setLast(unsigned in = last);

    void copy(const String& other);

public:
    String();
    ~String();

    // cppcheck-suppress noExplicitConstructor
    String(const char* in);
    String(const char* in, unsigned in_size);

    String(const String& other);
    String& operator=(const String& other);

    String& operator+=(const String& other);
    String  operator+(const String& other) const;

    String(String&& other);
    String& operator=(String&& other);

    char  operator[](unsigned i) const;
    char& operator[](unsigned i);

    // the only functions I'm willing to leave in the interface - available for inlining
    const char* c_str() const { return const_cast<String*>(this)->c_str(); } // NOLINT
    char*       c_str() {
        if(isOnStack())
            return reinterpret_cast<char*>(buf);
        return data.ptr;
    }

    unsigned size() const;
    unsigned capacity() const;

    int compare(const char* other, bool no_case = false) const;
    int compare(const String& other, bool no_case = false) const;
};

DOCTEST_INTERFACE bool operator==(const String& lhs, const String& rhs);
DOCTEST_INTERFACE bool operator!=(const String& lhs, const String& rhs);
DOCTEST_INTERFACE bool operator<(const String& lhs, const String& rhs);
DOCTEST_INTERFACE bool operator>(const String& lhs, const String& rhs);
DOCTEST_INTERFACE bool operator<=(const String& lhs, const String& rhs);
DOCTEST_INTERFACE bool operator>=(const String& lhs, const String& rhs);

DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, const String& in);

namespace Color {
    enum Enum
    {
        None = 0,
        White,
        Red,
        Green,
        Blue,
        Cyan,
        Yellow,
        Grey,

        Bright = 0x10,

        BrightRed   = Bright | Red,
        BrightGreen = Bright | Green,
        LightGrey   = Bright | Grey,
        BrightWhite = Bright | White
    };

    DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, Color::Enum code);
} // namespace Color

namespace assertType {
    enum Enum
    {
        // macro traits

        is_warn    = 1,
        is_check   = 2 * is_warn,
        is_require = 2 * is_check,

        is_normal      = 2 * is_require,
        is_throws      = 2 * is_normal,
        is_throws_as   = 2 * is_throws,
        is_throws_with = 2 * is_throws_as,
        is_nothrow     = 2 * is_throws_with,

        is_false = 2 * is_nothrow,
        is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types

        is_eq = 2 * is_unary,
        is_ne = 2 * is_eq,

        is_lt = 2 * is_ne,
        is_gt = 2 * is_lt,

        is_ge = 2 * is_gt,
        is_le = 2 * is_ge,

        // macro types

        DT_WARN    = is_normal | is_warn,
        DT_CHECK   = is_normal | is_check,
        DT_REQUIRE = is_normal | is_require,

        DT_WARN_FALSE    = is_normal | is_false | is_warn,
        DT_CHECK_FALSE   = is_normal | is_false | is_check,
        DT_REQUIRE_FALSE = is_normal | is_false | is_require,

        DT_WARN_THROWS    = is_throws | is_warn,
        DT_CHECK_THROWS   = is_throws | is_check,
        DT_REQUIRE_THROWS = is_throws | is_require,

        DT_WARN_THROWS_AS    = is_throws_as | is_warn,
        DT_CHECK_THROWS_AS   = is_throws_as | is_check,
        DT_REQUIRE_THROWS_AS = is_throws_as | is_require,

        DT_WARN_THROWS_WITH    = is_throws_with | is_warn,
        DT_CHECK_THROWS_WITH   = is_throws_with | is_check,
        DT_REQUIRE_THROWS_WITH = is_throws_with | is_require,

        DT_WARN_THROWS_WITH_AS    = is_throws_with | is_throws_as | is_warn,
        DT_CHECK_THROWS_WITH_AS   = is_throws_with | is_throws_as | is_check,
        DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require,

        DT_WARN_NOTHROW    = is_nothrow | is_warn,
        DT_CHECK_NOTHROW   = is_nothrow | is_check,
        DT_REQUIRE_NOTHROW = is_nothrow | is_require,

        DT_WARN_EQ    = is_normal | is_eq | is_warn,
        DT_CHECK_EQ   = is_normal | is_eq | is_check,
        DT_REQUIRE_EQ = is_normal | is_eq | is_require,

        DT_WARN_NE    = is_normal | is_ne | is_warn,
        DT_CHECK_NE   = is_normal | is_ne | is_check,
        DT_REQUIRE_NE = is_normal | is_ne | is_require,

        DT_WARN_GT    = is_normal | is_gt | is_warn,
        DT_CHECK_GT   = is_normal | is_gt | is_check,
        DT_REQUIRE_GT = is_normal | is_gt | is_require,

        DT_WARN_LT    = is_normal | is_lt | is_warn,
        DT_CHECK_LT   = is_normal | is_lt | is_check,
        DT_REQUIRE_LT = is_normal | is_lt | is_require,

        DT_WARN_GE    = is_normal | is_ge | is_warn,
        DT_CHECK_GE   = is_normal | is_ge | is_check,
        DT_REQUIRE_GE = is_normal | is_ge | is_require,

        DT_WARN_LE    = is_normal | is_le | is_warn,
        DT_CHECK_LE   = is_normal | is_le | is_check,
        DT_REQUIRE_LE = is_normal | is_le | is_require,

        DT_WARN_UNARY    = is_normal | is_unary | is_warn,
        DT_CHECK_UNARY   = is_normal | is_unary | is_check,
        DT_REQUIRE_UNARY = is_normal | is_unary | is_require,

        DT_WARN_UNARY_FALSE    = is_normal | is_false | is_unary | is_warn,
        DT_CHECK_UNARY_FALSE   = is_normal | is_false | is_unary | is_check,
        DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require,
    };
} // namespace assertType

DOCTEST_INTERFACE const char* assertString(assertType::Enum at);
DOCTEST_INTERFACE const char* failureString(assertType::Enum at);
DOCTEST_INTERFACE const char* skipPathFromFilename(const char* file);

struct DOCTEST_INTERFACE TestCaseData
{
    const char* m_file;       // the file in which the test was registered
    unsigned    m_line;       // the line where the test was registered
    const char* m_name;       // name of the test case
    const char* m_test_suite; // the test suite in which the test was added
    const char* m_description;
    bool        m_skip;
    bool        m_may_fail;
    bool        m_should_fail;
    int         m_expected_failures;
    double      m_timeout;
};

struct DOCTEST_INTERFACE AssertData
{
    // common - for all asserts
    const TestCaseData* m_test_case;
    assertType::Enum    m_at;
    const char*         m_file;
    int                 m_line;
    const char*         m_expr;
    bool                m_failed;

    // exception-related - for all asserts
    bool   m_threw;
    String m_exception;

    // for normal asserts
    String m_decomp;

    // for specific exception-related asserts
    bool        m_threw_as;
    const char* m_exception_type;
    const char* m_exception_string;
};

struct DOCTEST_INTERFACE MessageData
{
    String           m_string;
    const char*      m_file;
    int              m_line;
    assertType::Enum m_severity;
};

struct DOCTEST_INTERFACE SubcaseSignature
{
    const char* m_name;
    const char* m_file;
    int         m_line;

    bool operator<(const SubcaseSignature& other) const;
};

struct DOCTEST_INTERFACE IContextScope
{
    IContextScope();
    virtual ~IContextScope();
    virtual void stringify(std::ostream*) const = 0;
};

struct ContextOptions //!OCLINT too many fields
{
    std::ostream* cout;        // stdout stream - std::cout by default
    std::ostream* cerr;        // stderr stream - std::cerr by default
    String        binary_name; // the test binary name

    // == parameters from the command line
    String   out;       // output filename
    String   order_by;  // how tests should be ordered
    unsigned rand_seed; // the seed for rand ordering

    unsigned first; // the first (matching) test to be executed
    unsigned last;  // the last (matching) test to be executed

    int abort_after;           // stop tests after this many failed assertions
    int subcase_filter_levels; // apply the subcase filters for the first N levels

    bool success;              // include successful assertions in output
    bool case_sensitive;       // if filtering should be case sensitive
    bool exit;                 // if the program should be exited after the tests are ran/whatever
    bool duration;             // print the time duration of each test case
    bool no_throw;             // to skip exceptions-related assertion macros
    bool no_exitcode;          // if the framework should return 0 as the exitcode
    bool no_run;               // to not run the tests at all (can be done with an "*" exclude)
    bool no_version;           // to not print the version of the framework
    bool no_colors;            // if output to the console should be colorized
    bool force_colors;         // forces the use of colors even when a tty cannot be detected
    bool no_breaks;            // to not break into the debugger
    bool no_skip;              // don't skip test cases which are marked to be skipped
    bool gnu_file_line;        // if line numbers should be surrounded with :x: and not (x):
    bool no_path_in_filenames; // if the path to files should be removed from the output
    bool no_line_numbers;      // if source code line numbers should be omitted from the output
    bool no_skipped_summary;   // don't print "skipped" in the summary !!! UNDOCUMENTED !!!

    bool help;             // to print the help
    bool version;          // to print the version
    bool count;            // if only the count of matching tests is to be retrieved
    bool list_test_cases;  // to list all tests matching the filters
    bool list_test_suites; // to list all suites matching the filters
    bool list_reporters;   // lists all registered reporters
};

namespace detail {
#if defined(DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING) || defined(DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS)
    template <bool CONDITION, typename TYPE = void>
    struct enable_if
    {};

    template <typename TYPE>
    struct enable_if<true, TYPE>
    { typedef TYPE type; };
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING) || DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

    // clang-format off
    template<class T> struct remove_reference      { typedef T type; };
    template<class T> struct remove_reference<T&>  { typedef T type; };
    template<class T> struct remove_reference<T&&> { typedef T type; };

    template<class T> struct remove_const          { typedef T type; };
    template<class T> struct remove_const<const T> { typedef T type; };
    // clang-format on

    template <typename T>
    struct deferred_false
    // cppcheck-suppress unusedStructMember
    { static const bool value = false; };

    namespace has_insertion_operator_impl {
        typedef char no;
        typedef char yes[2];

        struct any_t
        {
            template <typename T>
            // cppcheck-suppress noExplicitConstructor
            any_t(const DOCTEST_REF_WRAP(T));
        };

        yes& testStreamable(std::ostream&);
        no   testStreamable(no);

        no operator<<(const std::ostream&, const any_t&);

        template <typename T>
        struct has_insertion_operator
        {
            static std::ostream& s;
            static const DOCTEST_REF_WRAP(T) t;
            static const bool value = sizeof(decltype(testStreamable(s << t))) == sizeof(yes);
        };
    } // namespace has_insertion_operator_impl

    template <typename T>
    struct has_insertion_operator : has_insertion_operator_impl::has_insertion_operator<T>
    {};

    DOCTEST_INTERFACE void my_memcpy(void* dest, const void* src, unsigned num);

    DOCTEST_INTERFACE std::ostream* getTlsOss(); // returns a thread-local ostringstream
    DOCTEST_INTERFACE String getTlsOssResult();

    template <bool C>
    struct StringMakerBase
    {
        template <typename T>
        static String convert(const DOCTEST_REF_WRAP(T)) {
            return "{?}";
        }
    };

    template <>
    struct StringMakerBase<true>
    {
        template <typename T>
        static String convert(const DOCTEST_REF_WRAP(T) in) {
            *getTlsOss() << in;
            return getTlsOssResult();
        }
    };

    DOCTEST_INTERFACE String rawMemoryToString(const void* object, unsigned size);

    template <typename T>
    String rawMemoryToString(const DOCTEST_REF_WRAP(T) object) {
        return rawMemoryToString(&object, sizeof(object));
    }

    template <typename T>
    const char* type_to_string() {
        return "<>";
    }
} // namespace detail

template <typename T>
struct StringMaker : public detail::StringMakerBase<detail::has_insertion_operator<T>::value>
{};

template <typename T>
struct StringMaker<T*>
{
    template <typename U>
    static String convert(U* p) {
        if(p)
            return detail::rawMemoryToString(p);
        return "NULL";
    }
};

template <typename R, typename C>
struct StringMaker<R C::*>
{
    static String convert(R C::*p) {
        if(p)
            return detail::rawMemoryToString(p);
        return "NULL";
    }
};

template <typename T>
String toString(const DOCTEST_REF_WRAP(T) value) {
    return StringMaker<T>::convert(value);
}

#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
DOCTEST_INTERFACE String toString(char* in);
DOCTEST_INTERFACE String toString(const char* in);
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
DOCTEST_INTERFACE String toString(bool in);
DOCTEST_INTERFACE String toString(float in);
DOCTEST_INTERFACE String toString(double in);
DOCTEST_INTERFACE String toString(double long in);

DOCTEST_INTERFACE String toString(char in);
DOCTEST_INTERFACE String toString(char signed in);
DOCTEST_INTERFACE String toString(char unsigned in);
DOCTEST_INTERFACE String toString(int short in);
DOCTEST_INTERFACE String toString(int short unsigned in);
DOCTEST_INTERFACE String toString(int in);
DOCTEST_INTERFACE String toString(int unsigned in);
DOCTEST_INTERFACE String toString(int long in);
DOCTEST_INTERFACE String toString(int long unsigned in);
DOCTEST_INTERFACE String toString(int long long in);
DOCTEST_INTERFACE String toString(int long long unsigned in);
DOCTEST_INTERFACE String toString(std::nullptr_t in);

#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183
DOCTEST_INTERFACE String toString(const std::string& in);
#endif // VS 2019

class DOCTEST_INTERFACE Approx
{
public:
    explicit Approx(double value);

    Approx operator()(double value) const;

#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
    template <typename T>
    explicit Approx(const T& value,
                    typename detail::enable_if<std::is_constructible<double, T>::value>::type* =
                            static_cast<T*>(nullptr)) {
        *this = Approx(static_cast<double>(value));
    }
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

    Approx& epsilon(double newEpsilon);

#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
    template <typename T>
    typename detail::enable_if<std::is_constructible<double, T>::value, Approx&>::type epsilon(
            const T& newEpsilon) {
        m_epsilon = static_cast<double>(newEpsilon);
        return *this;
    }
#endif //  DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

    Approx& scale(double newScale);

#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
    template <typename T>
    typename detail::enable_if<std::is_constructible<double, T>::value, Approx&>::type scale(
            const T& newScale) {
        m_scale = static_cast<double>(newScale);
        return *this;
    }
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

    // clang-format off
    DOCTEST_INTERFACE friend bool operator==(double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator==(const Approx & lhs, double rhs);
    DOCTEST_INTERFACE friend bool operator!=(double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator!=(const Approx & lhs, double rhs);
    DOCTEST_INTERFACE friend bool operator<=(double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator<=(const Approx & lhs, double rhs);
    DOCTEST_INTERFACE friend bool operator>=(double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator>=(const Approx & lhs, double rhs);
    DOCTEST_INTERFACE friend bool operator< (double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator< (const Approx & lhs, double rhs);
    DOCTEST_INTERFACE friend bool operator> (double lhs, const Approx & rhs);
    DOCTEST_INTERFACE friend bool operator> (const Approx & lhs, double rhs);

    DOCTEST_INTERFACE friend String toString(const Approx& in);

#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
#define DOCTEST_APPROX_PREFIX \
    template <typename T> friend typename detail::enable_if<std::is_constructible<double, T>::value, bool>::type

    DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(double(lhs), rhs); }
    DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); }
    DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
    DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); }
    DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value || lhs == rhs; }
    DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) || lhs == rhs; }
    DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value || lhs == rhs; }
    DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) || lhs == rhs; }
    DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value && lhs != rhs; }
    DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) && lhs != rhs; }
    DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value && lhs != rhs; }
    DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) && lhs != rhs; }
#undef DOCTEST_APPROX_PREFIX
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS

    // clang-format on

private:
    double m_epsilon;
    double m_scale;
    double m_value;
};

DOCTEST_INTERFACE String toString(const Approx& in);

DOCTEST_INTERFACE const ContextOptions* getContextOptions();

#if !defined(DOCTEST_CONFIG_DISABLE)

namespace detail {
    // clang-format off
#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    template<class T>               struct decay_array       { typedef T type; };
    template<class T, unsigned N>   struct decay_array<T[N]> { typedef T* type; };
    template<class T>               struct decay_array<T[]>  { typedef T* type; };

    template<class T>   struct not_char_pointer              { enum { value = 1 }; };
    template<>          struct not_char_pointer<char*>       { enum { value = 0 }; };
    template<>          struct not_char_pointer<const char*> { enum { value = 0 }; };

    template<class T> struct can_use_op : public not_char_pointer<typename decay_array<T>::type> {};
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    // clang-format on

    struct DOCTEST_INTERFACE TestFailureException
    {
    };

    DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum at);

#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
    DOCTEST_NORETURN
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
    DOCTEST_INTERFACE void throwException();

    struct DOCTEST_INTERFACE Subcase
    {
        SubcaseSignature m_signature;
        bool             m_entered = false;

        Subcase(const char* name, const char* file, int line);
        ~Subcase();

        operator bool() const;
    };

    template <typename L, typename R>
    String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
                               const DOCTEST_REF_WRAP(R) rhs) {
        return toString(lhs) + op + toString(rhs);
    }

#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro)                              \
    template <typename R>                                                                          \
    DOCTEST_NOINLINE Result operator op(const DOCTEST_REF_WRAP(R) rhs) {                           \
        bool res = op_macro(lhs, rhs);                                                             \
        if(m_at & assertType::is_false)                                                            \
            res = !res;                                                                            \
        if(!res || doctest::getContextOptions()->success)                                          \
            return Result(res, stringifyBinaryExpr(lhs, op_str, rhs));                             \
        return Result(res);                                                                        \
    }

    // more checks could be added - like in Catch:
    // https://github.com/catchorg/Catch2/pull/1480/files
    // https://github.com/catchorg/Catch2/pull/1481/files
#define DOCTEST_FORBIT_EXPRESSION(rt, op)                                                          \
    template <typename R>                                                                          \
    rt& operator op(const R&) {                                                                    \
        static_assert(deferred_false<R>::value,                                                    \
                      "Expression Too Complex Please Rewrite As Binary Comparison!");              \
        return *this;                                                                              \
    }

    struct DOCTEST_INTERFACE Result
    {
        bool   m_passed;
        String m_decomp;

        Result(bool passed, const String& decomposition = String());

        // forbidding some expressions based on this table: http://en.cppreference.com/w/cpp/language/operator_precedence
        DOCTEST_FORBIT_EXPRESSION(Result, &)
        DOCTEST_FORBIT_EXPRESSION(Result, ^)
        DOCTEST_FORBIT_EXPRESSION(Result, |)
        DOCTEST_FORBIT_EXPRESSION(Result, &&)
        DOCTEST_FORBIT_EXPRESSION(Result, ||)
        DOCTEST_FORBIT_EXPRESSION(Result, ==)
        DOCTEST_FORBIT_EXPRESSION(Result, !=)
        DOCTEST_FORBIT_EXPRESSION(Result, <)
        DOCTEST_FORBIT_EXPRESSION(Result, >)
        DOCTEST_FORBIT_EXPRESSION(Result, <=)
        DOCTEST_FORBIT_EXPRESSION(Result, >=)
        DOCTEST_FORBIT_EXPRESSION(Result, =)
        DOCTEST_FORBIT_EXPRESSION(Result, +=)
        DOCTEST_FORBIT_EXPRESSION(Result, -=)
        DOCTEST_FORBIT_EXPRESSION(Result, *=)
        DOCTEST_FORBIT_EXPRESSION(Result, /=)
        DOCTEST_FORBIT_EXPRESSION(Result, %=)
        DOCTEST_FORBIT_EXPRESSION(Result, <<=)
        DOCTEST_FORBIT_EXPRESSION(Result, >>=)
        DOCTEST_FORBIT_EXPRESSION(Result, &=)
        DOCTEST_FORBIT_EXPRESSION(Result, ^=)
        DOCTEST_FORBIT_EXPRESSION(Result, |=)
    };

#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION

    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-compare")
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wdouble-promotion")
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wconversion")
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wfloat-equal")

    DOCTEST_GCC_SUPPRESS_WARNING_PUSH
    DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
    DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-compare")
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wdouble-promotion")
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal")

    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
    // http://stackoverflow.com/questions/39479163 what's the difference between 4018 and 4389
    DOCTEST_MSVC_SUPPRESS_WARNING(4388) // signed/unsigned mismatch
    DOCTEST_MSVC_SUPPRESS_WARNING(4389) // 'operator' : signed/unsigned mismatch
    DOCTEST_MSVC_SUPPRESS_WARNING(4018) // 'expression' : signed/unsigned mismatch
    //DOCTEST_MSVC_SUPPRESS_WARNING(4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation

#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION

    // clang-format off
#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
#define DOCTEST_COMPARISON_RETURN_TYPE bool
#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
#define DOCTEST_COMPARISON_RETURN_TYPE typename enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type
    inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); }
    inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); }
    inline bool lt(const char* lhs, const char* rhs) { return String(lhs) <  String(rhs); }
    inline bool gt(const char* lhs, const char* rhs) { return String(lhs) >  String(rhs); }
    inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); }
    inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); }
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    // clang-format on

#define DOCTEST_RELATIONAL_OP(name, op)                                                            \
    template <typename L, typename R>                                                              \
    DOCTEST_COMPARISON_RETURN_TYPE name(const DOCTEST_REF_WRAP(L) lhs,                             \
                                        const DOCTEST_REF_WRAP(R) rhs) {                           \
        return lhs op rhs;                                                                         \
    }

    DOCTEST_RELATIONAL_OP(eq, ==)
    DOCTEST_RELATIONAL_OP(ne, !=)
    DOCTEST_RELATIONAL_OP(lt, <)
    DOCTEST_RELATIONAL_OP(gt, >)
    DOCTEST_RELATIONAL_OP(le, <=)
    DOCTEST_RELATIONAL_OP(ge, >=)

#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
#define DOCTEST_CMP_EQ(l, r) l == r
#define DOCTEST_CMP_NE(l, r) l != r
#define DOCTEST_CMP_GT(l, r) l > r
#define DOCTEST_CMP_LT(l, r) l < r
#define DOCTEST_CMP_GE(l, r) l >= r
#define DOCTEST_CMP_LE(l, r) l <= r
#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
#define DOCTEST_CMP_EQ(l, r) eq(l, r)
#define DOCTEST_CMP_NE(l, r) ne(l, r)
#define DOCTEST_CMP_GT(l, r) gt(l, r)
#define DOCTEST_CMP_LT(l, r) lt(l, r)
#define DOCTEST_CMP_GE(l, r) ge(l, r)
#define DOCTEST_CMP_LE(l, r) le(l, r)
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING

    template <typename L>
    // cppcheck-suppress copyCtorAndEqOperator
    struct Expression_lhs
    {
        L                lhs;
        assertType::Enum m_at;

        explicit Expression_lhs(L in, assertType::Enum at)
                : lhs(in)
                , m_at(at) {}

        DOCTEST_NOINLINE operator Result() {
            bool res = !!lhs;
            if(m_at & assertType::is_false) //!OCLINT bitwise operator in conditional
                res = !res;

            if(!res || getContextOptions()->success)
                return Result(res, toString(lhs));
            return Result(res);
        }

        // clang-format off
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>,  " >  ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<,  " <  ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional
        // clang-format on

        // forbidding some expressions based on this table: http://en.cppreference.com/w/cpp/language/operator_precedence
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &&)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ||)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, =)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, +=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, -=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, *=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, /=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, %=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^=)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |=)
        // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the
        // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression...
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<)
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>)
    };

#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION

    DOCTEST_CLANG_SUPPRESS_WARNING_POP
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
    DOCTEST_GCC_SUPPRESS_WARNING_POP

#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION

    struct DOCTEST_INTERFACE ExpressionDecomposer
    {
        assertType::Enum m_at;

        ExpressionDecomposer(assertType::Enum at);

        // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table)
        // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now...
        // https://github.com/catchorg/Catch2/issues/870
        // https://github.com/catchorg/Catch2/issues/565
        template <typename L>
        Expression_lhs<const DOCTEST_REF_WRAP(L)> operator<<(const DOCTEST_REF_WRAP(L) operand) {
            return Expression_lhs<const DOCTEST_REF_WRAP(L)>(operand, m_at);
        }
    };

    struct DOCTEST_INTERFACE TestSuite
    {
        const char* m_test_suite;
        const char* m_description;
        bool        m_skip;
        bool        m_may_fail;
        bool        m_should_fail;
        int         m_expected_failures;
        double      m_timeout;

        TestSuite& operator*(const char* in);

        template <typename T>
        TestSuite& operator*(const T& in) {
            in.fill(*this);
            return *this;
        }
    };

    typedef void (*funcType)();

    struct DOCTEST_INTERFACE TestCase : public TestCaseData
    {
        funcType m_test; // a function pointer to the test case

        const char* m_type; // for templated test cases - gets appended to the real name
        int m_template_id; // an ID used to distinguish between the different versions of a templated test case
        String m_full_name; // contains the name (only for templated test cases!) + the template type

        TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
                 const char* type = "", int template_id = -1);

        TestCase(const TestCase& other);

        DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
        TestCase& operator=(const TestCase& other);
        DOCTEST_MSVC_SUPPRESS_WARNING_POP

        TestCase& operator*(const char* in);

        template <typename T>
        TestCase& operator*(const T& in) {
            in.fill(*this);
            return *this;
        }

        bool operator<(const TestCase& other) const;
    };

    // forward declarations of functions used by the macros
    DOCTEST_INTERFACE int  regTest(const TestCase& tc);
    DOCTEST_INTERFACE int  setTestSuite(const TestSuite& ts);
    DOCTEST_INTERFACE bool isDebuggerActive();

    template<typename T>
    int instantiationHelper(const T&) { return 0; }

    namespace binaryAssertComparison {
        enum Enum
        {
            eq = 0,
            ne,
            gt,
            lt,
            ge,
            le
        };
    } // namespace binaryAssertComparison

    // clang-format off
    template <int, class L, class R> struct RelationalComparator     { bool operator()(const DOCTEST_REF_WRAP(L),     const DOCTEST_REF_WRAP(R)    ) const { return false;        } };

#define DOCTEST_BINARY_RELATIONAL_OP(n, op) \
    template <class L, class R> struct RelationalComparator<n, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return op(lhs, rhs); } };
    // clang-format on

    DOCTEST_BINARY_RELATIONAL_OP(0, eq)
    DOCTEST_BINARY_RELATIONAL_OP(1, ne)
    DOCTEST_BINARY_RELATIONAL_OP(2, gt)
    DOCTEST_BINARY_RELATIONAL_OP(3, lt)
    DOCTEST_BINARY_RELATIONAL_OP(4, ge)
    DOCTEST_BINARY_RELATIONAL_OP(5, le)

    struct DOCTEST_INTERFACE ResultBuilder : public AssertData
    {
        ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
                      const char* exception_type = "", const char* exception_string = "");

        void setResult(const Result& res);

        template <int comparison, typename L, typename R>
        DOCTEST_NOINLINE void binary_assert(const DOCTEST_REF_WRAP(L) lhs,
                                            const DOCTEST_REF_WRAP(R) rhs) {
            m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
            if(m_failed || getContextOptions()->success)
                m_decomp = stringifyBinaryExpr(lhs, ", ", rhs);
        }

        template <typename L>
        DOCTEST_NOINLINE void unary_assert(const DOCTEST_REF_WRAP(L) val) {
            m_failed = !val;

            if(m_at & assertType::is_false) //!OCLINT bitwise operator in conditional
                m_failed = !m_failed;

            if(m_failed || getContextOptions()->success)
                m_decomp = toString(val);
        }

        void translateException();

        bool log();
        void react() const;
    };

    namespace assertAction {
        enum Enum
        {
            nothing     = 0,
            dbgbreak    = 1,
            shouldthrow = 2
        };
    } // namespace assertAction

    DOCTEST_INTERFACE void failed_out_of_a_testing_context(const AssertData& ad);

    DOCTEST_INTERFACE void decomp_assert(assertType::Enum at, const char* file, int line,
                                         const char* expr, Result result);

#define DOCTEST_ASSERT_OUT_OF_TESTS(decomp)                                                        \
    do {                                                                                           \
        if(!is_running_in_test) {                                                                  \
            if(failed) {                                                                           \
                ResultBuilder rb(at, file, line, expr);                                            \
                rb.m_failed = failed;                                                              \
                rb.m_decomp = decomp;                                                              \
                failed_out_of_a_testing_context(rb);                                               \
                if(isDebuggerActive() && !getContextOptions()->no_breaks)                          \
                    DOCTEST_BREAK_INTO_DEBUGGER();                                                 \
                if(checkIfShouldThrow(at))                                                         \
                    throwException();                                                              \
            }                                                                                      \
            return;                                                                                \
        }                                                                                          \
    } while(false)

#define DOCTEST_ASSERT_IN_TESTS(decomp)                                                            \
    ResultBuilder rb(at, file, line, expr);                                                        \
    rb.m_failed = failed;                                                                          \
    if(rb.m_failed || getContextOptions()->success)                                                \
        rb.m_decomp = decomp;                                                                      \
    if(rb.log())                                                                                   \
        DOCTEST_BREAK_INTO_DEBUGGER();                                                             \
    if(rb.m_failed && checkIfShouldThrow(at))                                                      \
    throwException()

    template <int comparison, typename L, typename R>
    DOCTEST_NOINLINE void binary_assert(assertType::Enum at, const char* file, int line,
                                        const char* expr, const DOCTEST_REF_WRAP(L) lhs,
                                        const DOCTEST_REF_WRAP(R) rhs) {
        bool failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);

        // ###################################################################################
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
        // ###################################################################################
        DOCTEST_ASSERT_OUT_OF_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
        DOCTEST_ASSERT_IN_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
    }

    template <typename L>
    DOCTEST_NOINLINE void unary_assert(assertType::Enum at, const char* file, int line,
                                       const char* expr, const DOCTEST_REF_WRAP(L) val) {
        bool failed = !val;

        if(at & assertType::is_false) //!OCLINT bitwise operator in conditional
            failed = !failed;

        // ###################################################################################
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
        // ###################################################################################
        DOCTEST_ASSERT_OUT_OF_TESTS(toString(val));
        DOCTEST_ASSERT_IN_TESTS(toString(val));
    }

    struct DOCTEST_INTERFACE IExceptionTranslator
    {
        IExceptionTranslator();
        virtual ~IExceptionTranslator();
        virtual bool translate(String&) const = 0;
    };

    template <typename T>
    class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class
    {
    public:
        explicit ExceptionTranslator(String (*translateFunction)(T))
                : m_translateFunction(translateFunction) {}

        bool translate(String& res) const override {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
            try {
                throw; // lgtm [cpp/rethrow-no-exception]
                // cppcheck-suppress catchExceptionByValue
            } catch(T ex) {                    // NOLINT
                res = m_translateFunction(ex); //!OCLINT parameter reassignment
                return true;
            } catch(...) {} //!OCLINT -  empty catch statement
#endif                      // DOCTEST_CONFIG_NO_EXCEPTIONS
            ((void)res);    // to silence -Wunused-parameter
            return false;
        }

    private:
        String (*m_translateFunction)(T);
    };

    DOCTEST_INTERFACE void registerExceptionTranslatorImpl(const IExceptionTranslator* et);

    template <bool C>
    struct StringStreamBase
    {
        template <typename T>
        static void convert(std::ostream* s, const T& in) {
            *s << toString(in);
        }

        // always treat char* as a string in this context - no matter
        // if DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING is defined
        static void convert(std::ostream* s, const char* in) { *s << String(in); }
    };

    template <>
    struct StringStreamBase<true>
    {
        template <typename T>
        static void convert(std::ostream* s, const T& in) {
            *s << in;
        }
    };

    template <typename T>
    struct StringStream : public StringStreamBase<has_insertion_operator<T>::value>
    {};

    template <typename T>
    void toStream(std::ostream* s, const T& value) {
        StringStream<T>::convert(s, value);
    }

#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    DOCTEST_INTERFACE void toStream(std::ostream* s, char* in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, const char* in);
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    DOCTEST_INTERFACE void toStream(std::ostream* s, bool in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, float in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, double in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, double long in);

    DOCTEST_INTERFACE void toStream(std::ostream* s, char in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, char signed in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, char unsigned in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int short in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int short unsigned in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int unsigned in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int long in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int long unsigned in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int long long in);
    DOCTEST_INTERFACE void toStream(std::ostream* s, int long long unsigned in);

    // ContextScope base class used to allow implementing methods of ContextScope
    // that don't depend on the template parameter in doctest.cpp.
    class DOCTEST_INTERFACE ContextScopeBase : public IContextScope {
    protected:
        ContextScopeBase();

        void destroy();
    };

    template <typename L> class DOCTEST_INTERFACE ContextScope : public ContextScopeBase
    {
        const L &lambda_;

    public:
        explicit ContextScope(const L &lambda) : lambda_(lambda) {}

        ContextScope(ContextScope &&other) : lambda_(other.lambda_) {}

        void stringify(std::ostream* s) const override { lambda_(s); }

        ~ContextScope() override { destroy(); }
    };

    struct DOCTEST_INTERFACE MessageBuilder : public MessageData
    {
        std::ostream* m_stream;

        MessageBuilder(const char* file, int line, assertType::Enum severity);
        MessageBuilder() = delete;
        ~MessageBuilder();

        template <typename T>
        MessageBuilder& operator<<(const T& in) {
            toStream(m_stream, in);
            return *this;
        }

        bool log();
        void react();
    };

    template <typename L>
    ContextScope<L> MakeContextScope(const L &lambda) {
        return ContextScope<L>(lambda);
    }
} // namespace detail

#define DOCTEST_DEFINE_DECORATOR(name, type, def)                                                  \
    struct name                                                                                    \
    {                                                                                              \
        type data;                                                                                 \
        name(type in = def)                                                                        \
                : data(in) {}                                                                      \
        void fill(detail::TestCase& state) const { state.DOCTEST_CAT(m_, name) = data; }           \
        void fill(detail::TestSuite& state) const { state.DOCTEST_CAT(m_, name) = data; }          \
    }

DOCTEST_DEFINE_DECORATOR(test_suite, const char*, "");
DOCTEST_DEFINE_DECORATOR(description, const char*, "");
DOCTEST_DEFINE_DECORATOR(skip, bool, true);
DOCTEST_DEFINE_DECORATOR(timeout, double, 0);
DOCTEST_DEFINE_DECORATOR(may_fail, bool, true);
DOCTEST_DEFINE_DECORATOR(should_fail, bool, true);
DOCTEST_DEFINE_DECORATOR(expected_failures, int, 0);

template <typename T>
int registerExceptionTranslator(String (*translateFunction)(T)) {
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")
    static detail::ExceptionTranslator<T> exceptionTranslator(translateFunction);
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
    detail::registerExceptionTranslatorImpl(&exceptionTranslator);
    return 0;
}

} // namespace doctest

// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro
// introduces an anonymous namespace in which getCurrentTestSuite gets overridden
namespace doctest_detail_test_suite_ns {
DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite();
} // namespace doctest_detail_test_suite_ns

namespace doctest {
#else  // DOCTEST_CONFIG_DISABLE
template <typename T>
int registerExceptionTranslator(String (*)(T)) {
    return 0;
}
#endif // DOCTEST_CONFIG_DISABLE

namespace detail {
    typedef void (*assert_handler)(const AssertData&);
    struct ContextState;
} // namespace detail

class DOCTEST_INTERFACE Context
{
    detail::ContextState* p;

    void parseArgs(int argc, const char* const* argv, bool withDefaults = false);

public:
    explicit Context(int argc = 0, const char* const* argv = nullptr);

    ~Context();

    void applyCommandLine(int argc, const char* const* argv);

    void addFilter(const char* filter, const char* value);
    void clearFilters();
    void setOption(const char* option, int value);
    void setOption(const char* option, const char* value);

    bool shouldExit();

    void setAsDefaultForAssertsOutOfTestCases();

    void setAssertHandler(detail::assert_handler ah);

    int run();
};

namespace TestCaseFailureReason {
    enum Enum
    {
        None                     = 0,
        AssertFailure            = 1,   // an assertion has failed in the test case
        Exception                = 2,   // test case threw an exception
        Crash                    = 4,   // a crash...
        TooManyFailedAsserts     = 8,   // the abort-after option
        Timeout                  = 16,  // see the timeout decorator
        ShouldHaveFailedButDidnt = 32,  // see the should_fail decorator
        ShouldHaveFailedAndDid   = 64,  // see the should_fail decorator
        DidntFailExactlyNumTimes = 128, // see the expected_failures decorator
        FailedExactlyNumTimes    = 256, // see the expected_failures decorator
        CouldHaveFailedAndDid    = 512  // see the may_fail decorator
    };
} // namespace TestCaseFailureReason

struct DOCTEST_INTERFACE CurrentTestCaseStats
{
    int    numAssertsCurrentTest;
    int    numAssertsFailedCurrentTest;
    double seconds;
    int    failure_flags; // use TestCaseFailureReason::Enum
};

struct DOCTEST_INTERFACE TestCaseException
{
    String error_string;
    bool   is_crash;
};

struct DOCTEST_INTERFACE TestRunStats
{
    unsigned numTestCases;
    unsigned numTestCasesPassingFilters;
    unsigned numTestSuitesPassingFilters;
    unsigned numTestCasesFailed;
    int      numAsserts;
    int      numAssertsFailed;
};

struct QueryData
{
    const TestRunStats* run_stats = nullptr;
    String*             data      = nullptr;
    unsigned            num_data  = 0;
};

struct DOCTEST_INTERFACE IReporter
{
    // The constructor has to accept "const ContextOptions&" as a single argument
    // which has most of the options for the run + a pointer to the stdout stream
    // Reporter(const ContextOptions& in)

    // called when a query should be reported (listing test cases, printing the version, etc.)
    virtual void report_query(const QueryData&) = 0;

    // called when the whole test run starts
    virtual void test_run_start() = 0;
    // called when the whole test run ends (caching a pointer to the input doesn't make sense here)
    virtual void test_run_end(const TestRunStats&) = 0;

    // called when a test case is started (safe to cache a pointer to the input)
    virtual void test_case_start(const TestCaseData&) = 0;
    // called when a test case is reentered because of unfinished subcases (safe to cache a pointer to the input)
    virtual void test_case_reenter(const TestCaseData&) = 0;
    // called when a test case has ended
    virtual void test_case_end(const CurrentTestCaseStats&) = 0;

    // called when an exception is thrown from the test case (or it crashes)
    virtual void test_case_exception(const TestCaseException&) = 0;

    // called whenever a subcase is entered (don't cache pointers to the input)
    virtual void subcase_start(const SubcaseSignature&) = 0;
    // called whenever a subcase is exited (don't cache pointers to the input)
    virtual void subcase_end() = 0;

    // called for each assert (don't cache pointers to the input)
    virtual void log_assert(const AssertData&) = 0;
    // called for each message (don't cache pointers to the input)
    virtual void log_message(const MessageData&) = 0;

    // called when a test case is skipped either because it doesn't pass the filters, has a skip decorator
    // or isn't in the execution range (between first and last) (safe to cache a pointer to the input)
    virtual void test_case_skipped(const TestCaseData&) = 0;

    // doctest will not be managing the lifetimes of reporters given to it but this would still be nice to have
    virtual ~IReporter();

    // can obtain all currently active contexts and stringify them if one wishes to do so
    static int                         get_num_active_contexts();
    static const IContextScope* const* get_active_contexts();

    // can iterate through contexts which have been stringified automatically in their destructors when an exception has been thrown
    static int           get_num_stringified_contexts();
    static const String* get_stringified_contexts();
};

namespace detail {
    typedef IReporter* (*reporterCreatorFunc)(const ContextOptions&);

    DOCTEST_INTERFACE void registerReporterImpl(const char* name, int prio, reporterCreatorFunc c, bool isReporter);

    template <typename Reporter>
    IReporter* reporterCreator(const ContextOptions& o) {
        return new Reporter(o);
    }
} // namespace detail

template <typename Reporter>
int registerReporter(const char* name, int priority, bool isReporter) {
    detail::registerReporterImpl(name, priority, detail::reporterCreator<Reporter>, isReporter);
    return 0;
}
} // namespace doctest

// if registering is not disabled
#if !defined(DOCTEST_CONFIG_DISABLE)

// common code in asserts - for convenience
#define DOCTEST_ASSERT_LOG_AND_REACT(b)                                                            \
    if(b.log())                                                                                    \
        DOCTEST_BREAK_INTO_DEBUGGER();                                                             \
    b.react()

#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
#define DOCTEST_WRAP_IN_TRY(x) x;
#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
#define DOCTEST_WRAP_IN_TRY(x)                                                                     \
    try {                                                                                          \
        x;                                                                                         \
    } catch(...) { _DOCTEST_RB.translateException(); }
#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS

#ifdef DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
#define DOCTEST_CAST_TO_VOID(x)                                                                    \
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wuseless-cast")                                       \
    static_cast<void>(x);                                                                          \
    DOCTEST_GCC_SUPPRESS_WARNING_POP
#else // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
#define DOCTEST_CAST_TO_VOID(x) x;
#endif // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS

// registers the test by initializing a dummy var with a function
#define DOCTEST_REGISTER_FUNCTION(global_prefix, f, decorators)                                    \
    global_prefix DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) =              \
            doctest::detail::regTest(                                                              \
                    doctest::detail::TestCase(                                                     \
                            f, __FILE__, __LINE__,                                                 \
                            doctest_detail_test_suite_ns::getCurrentTestSuite()) *                 \
                    decorators);                                                                   \
    DOCTEST_GLOBAL_NO_WARNINGS_END()

#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators)                                     \
    namespace {                                                                                    \
        struct der : public base                                                                   \
        {                                                                                          \
            void f();                                                                              \
        };                                                                                         \
        static void func() {                                                                       \
            der v;                                                                                 \
            v.f();                                                                                 \
        }                                                                                          \
        DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, func, decorators)                                 \
    }                                                                                              \
    inline DOCTEST_NOINLINE void der::f()

#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators)                                        \
    static void f();                                                                               \
    DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, f, decorators)                                        \
    static void f()

#define DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(f, proxy, decorators)                        \
    static doctest::detail::funcType proxy() { return f; }                                         \
    DOCTEST_REGISTER_FUNCTION(inline const, proxy(), decorators)                                   \
    static void f()

// for registering tests
#define DOCTEST_TEST_CASE(decorators)                                                              \
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators)

// for registering tests in classes - requires C++17 for inline variables!
#if __cplusplus >= 201703L || (DOCTEST_MSVC >= DOCTEST_COMPILER(19, 12, 0) && _MSVC_LANG >= 201703L)
#define DOCTEST_TEST_CASE_CLASS(decorators)                                                        \
    DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_),          \
                                                  DOCTEST_ANONYMOUS(_DOCTEST_ANON_PROXY_),         \
                                                  decorators)
#else // DOCTEST_TEST_CASE_CLASS
#define DOCTEST_TEST_CASE_CLASS(...)                                                               \
    TEST_CASES_CAN_BE_REGISTERED_IN_CLASSES_ONLY_IN_CPP17_MODE_OR_WITH_VS_2017_OR_NEWER
#endif // DOCTEST_TEST_CASE_CLASS

// for registering tests with a fixture
#define DOCTEST_TEST_CASE_FIXTURE(c, decorators)                                                   \
    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), c,                          \
                              DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators)

// for converting types to strings without the <typeinfo> header and demangling
#define DOCTEST_TYPE_TO_STRING_IMPL(...)                                                           \
    template <>                                                                                    \
    inline const char* type_to_string<__VA_ARGS__>() {                                             \
        return "<" #__VA_ARGS__ ">";                                                               \
    }
#define DOCTEST_TYPE_TO_STRING(...)                                                                \
    namespace doctest { namespace detail {                                                         \
            DOCTEST_TYPE_TO_STRING_IMPL(__VA_ARGS__)                                               \
        }                                                                                          \
    }                                                                                              \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, iter, func)                                 \
    template <typename T>                                                                          \
    static void func();                                                                            \
    namespace {                                                                                    \
        template <typename Tuple>                                                                  \
        struct iter;                                                                               \
        template <typename Type, typename... Rest>                                                 \
        struct iter<std::tuple<Type, Rest...>>                                                     \
        {                                                                                          \
            iter(const char* file, unsigned line, int index) {                                     \
                doctest::detail::regTest(doctest::detail::TestCase(func<Type>, file, line,         \
                                            doctest_detail_test_suite_ns::getCurrentTestSuite(),   \
                                            doctest::detail::type_to_string<Type>(),               \
                                            int(line) * 1000 + index)                              \
                                         * dec);                                                   \
                iter<std::tuple<Rest...>>(file, line, index + 1);                                  \
            }                                                                                      \
        };                                                                                         \
        template <>                                                                                \
        struct iter<std::tuple<>>                                                                  \
        {                                                                                          \
            iter(const char*, unsigned, int) {}                                                    \
        };                                                                                         \
    }                                                                                              \
    template <typename T>                                                                          \
    static void func()

#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(dec, T, id)                                              \
    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(id, ITERATOR),                      \
                                           DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_))

#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, anon, ...)                                 \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY)) =                                         \
        doctest::detail::instantiationHelper(DOCTEST_CAT(id, ITERATOR)<__VA_ARGS__>(__FILE__, __LINE__, 0));\
    DOCTEST_GLOBAL_NO_WARNINGS_END()

#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...)                                                 \
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), std::tuple<__VA_ARGS__>) \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...)                                                  \
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), __VA_ARGS__) \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, anon, ...)                                         \
    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(anon, ITERATOR), anon);             \
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(anon, anon, std::tuple<__VA_ARGS__>)               \
    template <typename T>                                                                          \
    static void anon()

#define DOCTEST_TEST_CASE_TEMPLATE(dec, T, ...)                                                    \
    DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), __VA_ARGS__)

// for subcases
#define DOCTEST_SUBCASE(name)                                                                      \
    if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUBCASE_) DOCTEST_UNUSED = \
               doctest::detail::Subcase(name, __FILE__, __LINE__))

// for grouping tests in test suites by using code blocks
#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name)                                               \
    namespace ns_name { namespace doctest_detail_test_suite_ns {                                   \
            static DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() {            \
                DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4640)                                      \
                DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")                \
                static doctest::detail::TestSuite data;                                            \
                static bool                       inited = false;                                  \
                DOCTEST_MSVC_SUPPRESS_WARNING_POP                                                  \
                DOCTEST_CLANG_SUPPRESS_WARNING_POP                                                 \
                if(!inited) {                                                                      \
                    data* decorators;                                                              \
                    inited = true;                                                                 \
                }                                                                                  \
                return data;                                                                       \
            }                                                                                      \
        }                                                                                          \
    }                                                                                              \
    namespace ns_name

#define DOCTEST_TEST_SUITE(decorators)                                                             \
    DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUITE_))

// for starting a testsuite block
#define DOCTEST_TEST_SUITE_BEGIN(decorators)                                                       \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) =                            \
            doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators);              \
    DOCTEST_GLOBAL_NO_WARNINGS_END()                                                               \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for ending a testsuite block
#define DOCTEST_TEST_SUITE_END                                                                     \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) =                            \
            doctest::detail::setTestSuite(doctest::detail::TestSuite() * "");                      \
    DOCTEST_GLOBAL_NO_WARNINGS_END()                                                               \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for registering exception translators
#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature)                      \
    inline doctest::String translatorName(signature);                                              \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)) =                     \
            doctest::registerExceptionTranslator(translatorName);                                  \
    DOCTEST_GLOBAL_NO_WARNINGS_END()                                                               \
    doctest::String translatorName(signature)

#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
    DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_),       \
                                               signature)

// for registering reporters
#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)                                        \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_REPORTER_)) =                       \
            doctest::registerReporter<reporter>(name, priority, true);                             \
    DOCTEST_GLOBAL_NO_WARNINGS_END() typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for registering listeners
#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)                                        \
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_REPORTER_)) =                       \
            doctest::registerReporter<reporter>(name, priority, false);                            \
    DOCTEST_GLOBAL_NO_WARNINGS_END() typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for logging
#define DOCTEST_INFO(expression)                                                                   \
    DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_),  \
                      DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), expression)

#define DOCTEST_INFO_IMPL(lambda_name, mb_name, s_name, expression)                                \
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4626)                                                  \
    auto lambda_name = [&](std::ostream* s_name) {                                                 \
        doctest::detail::MessageBuilder mb_name(__FILE__, __LINE__, doctest::assertType::is_warn); \
        mb_name.m_stream = s_name;                                                                 \
        mb_name << expression;                                                                     \
    };                                                                                             \
    DOCTEST_MSVC_SUPPRESS_WARNING_POP                                                              \
    auto DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_) = doctest::detail::MakeContextScope(lambda_name)

#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := " << x)

#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, x)                                               \
    do {                                                                                           \
        doctest::detail::MessageBuilder mb(file, line, doctest::assertType::type);                 \
        mb << x;                                                                                   \
        DOCTEST_ASSERT_LOG_AND_REACT(mb);                                                          \
    } while((void)0, 0)

// clang-format off
#define DOCTEST_ADD_MESSAGE_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x)
#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x)
#define DOCTEST_ADD_FAIL_AT(file, line, x) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), x)
// clang-format on

#define DOCTEST_MESSAGE(x) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, x)
#define DOCTEST_FAIL_CHECK(x) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, x)
#define DOCTEST_FAIL(x) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, x)

#define DOCTEST_TO_LVALUE(...) __VA_ARGS__ // Not removed to keep backwards compatibility.

#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS

#define DOCTEST_ASSERT_IMPLEMENT_2(assert_type, ...)                                               \
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
    doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__,         \
                                               __LINE__, #__VA_ARGS__);                            \
    DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.setResult(                                                     \
            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
            << __VA_ARGS__))                                                                       \
    DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB)                                                      \
    DOCTEST_CLANG_SUPPRESS_WARNING_POP

#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
    do {                                                                                           \
        DOCTEST_ASSERT_IMPLEMENT_2(assert_type, __VA_ARGS__);                                      \
    } while((void)0, 0)

#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS

// necessary for <ASSERT>_MESSAGE
#define DOCTEST_ASSERT_IMPLEMENT_2 DOCTEST_ASSERT_IMPLEMENT_1

#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
    doctest::detail::decomp_assert(                                                                \
            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__,                    \
            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
                    << __VA_ARGS__) DOCTEST_CLANG_SUPPRESS_WARNING_POP

#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS

#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN, __VA_ARGS__)
#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK, __VA_ARGS__)
#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE, __VA_ARGS__)
#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN_FALSE, __VA_ARGS__)
#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK_FALSE, __VA_ARGS__)
#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE_FALSE, __VA_ARGS__)

// clang-format off
#define DOCTEST_WARN_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN, cond); } while((void)0, 0)
#define DOCTEST_CHECK_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK, cond); } while((void)0, 0)
#define DOCTEST_REQUIRE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE, cond); } while((void)0, 0)
#define DOCTEST_WARN_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN_FALSE, cond); } while((void)0, 0)
#define DOCTEST_CHECK_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK_FALSE, cond); } while((void)0, 0)
#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, msg) do { DOCTEST_INFO(msg); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE_FALSE, cond); } while((void)0, 0)
// clang-format on

#define DOCTEST_ASSERT_THROWS_AS(expr, assert_type, message, ...)                                  \
    do {                                                                                           \
        if(!doctest::getContextOptions()->no_throw) {                                              \
            doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
                                                       __LINE__, #expr, #__VA_ARGS__, message);    \
            try {                                                                                  \
                DOCTEST_CAST_TO_VOID(expr)                                                         \
            } catch(const doctest::detail::remove_const<                                           \
                    doctest::detail::remove_reference<__VA_ARGS__>::type>::type&) {                \
                _DOCTEST_RB.translateException();                                                  \
                _DOCTEST_RB.m_threw_as = true;                                                     \
            } catch(...) { _DOCTEST_RB.translateException(); }                                     \
            DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB);                                             \
        }                                                                                          \
    } while((void)0, 0)

#define DOCTEST_ASSERT_THROWS_WITH(expr, assert_type, ...)                                         \
    do {                                                                                           \
        if(!doctest::getContextOptions()->no_throw) {                                              \
            doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \
                                                       __LINE__, #expr, "", __VA_ARGS__);          \
            try {                                                                                  \
                DOCTEST_CAST_TO_VOID(expr)                                                         \
            } catch(...) { _DOCTEST_RB.translateException(); }                                     \
            DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB);                                             \
        }                                                                                          \
    } while((void)0, 0)

#define DOCTEST_ASSERT_NOTHROW(expr, assert_type)                                                  \
    do {                                                                                           \
        doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__,     \
                                                   __LINE__, #expr);                               \
        try {                                                                                      \
            DOCTEST_CAST_TO_VOID(expr)                                                             \
        } catch(...) { _DOCTEST_RB.translateException(); }                                         \
        DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB);                                                 \
    } while((void)0, 0)

// clang-format off
#define DOCTEST_WARN_THROWS(expr) DOCTEST_ASSERT_THROWS_WITH(expr, DT_WARN_THROWS, "")
#define DOCTEST_CHECK_THROWS(expr) DOCTEST_ASSERT_THROWS_WITH(expr, DT_CHECK_THROWS, "")
#define DOCTEST_REQUIRE_THROWS(expr) DOCTEST_ASSERT_THROWS_WITH(expr, DT_REQUIRE_THROWS, "")

#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_AS, "", __VA_ARGS__)
#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_AS, "", __VA_ARGS__)
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_AS, "", __VA_ARGS__)

#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, DT_WARN_THROWS_WITH, __VA_ARGS__)
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, DT_CHECK_THROWS_WITH, __VA_ARGS__)
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, DT_REQUIRE_THROWS_WITH, __VA_ARGS__)

#define DOCTEST_WARN_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_WITH_AS, message, __VA_ARGS__)
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_WITH_AS, message, __VA_ARGS__)
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_WITH_AS, message, __VA_ARGS__)

#define DOCTEST_WARN_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_WARN_NOTHROW)
#define DOCTEST_CHECK_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_CHECK_NOTHROW)
#define DOCTEST_REQUIRE_NOTHROW(expr) DOCTEST_ASSERT_NOTHROW(expr, DT_REQUIRE_NOTHROW)

#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS(expr); } while((void)0, 0)
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS(expr); } while((void)0, 0)
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS(expr); } while((void)0, 0)
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS_AS(expr, ex); } while((void)0, 0)
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS_AS(expr, ex); } while((void)0, 0)
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } while((void)0, 0)
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS_WITH(expr, with); } while((void)0, 0)
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS_WITH(expr, with); } while((void)0, 0)
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS_WITH(expr, with); } while((void)0, 0)
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex); } while((void)0, 0)
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex); } while((void)0, 0)
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex); } while((void)0, 0)
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_WARN_NOTHROW(expr); } while((void)0, 0)
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_CHECK_NOTHROW(expr); } while((void)0, 0)
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) do { DOCTEST_INFO(msg); DOCTEST_REQUIRE_NOTHROW(expr); } while((void)0, 0)
// clang-format on

#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS

#define DOCTEST_BINARY_ASSERT(assert_type, comp, ...)                                              \
    do {                                                                                           \
        doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__,     \
                                                   __LINE__, #__VA_ARGS__);                        \
        DOCTEST_WRAP_IN_TRY(                                                                       \
                _DOCTEST_RB.binary_assert<doctest::detail::binaryAssertComparison::comp>(          \
                        __VA_ARGS__))                                                              \
        DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB);                                                 \
    } while((void)0, 0)

#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
    do {                                                                                           \
        doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__,     \
                                                   __LINE__, #__VA_ARGS__);                        \
        DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.unary_assert(__VA_ARGS__))                                 \
        DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB);                                                 \
    } while((void)0, 0)

#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS

#define DOCTEST_BINARY_ASSERT(assert_type, comparison, ...)                                        \
    doctest::detail::binary_assert<doctest::detail::binaryAssertComparison::comparison>(           \
            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, __VA_ARGS__)

#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
    doctest::detail::unary_assert(doctest::assertType::assert_type, __FILE__, __LINE__,            \
                                  #__VA_ARGS__, __VA_ARGS__)

#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS

#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, eq, __VA_ARGS__)
#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, eq, __VA_ARGS__)
#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, eq, __VA_ARGS__)
#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, ne, __VA_ARGS__)
#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, ne, __VA_ARGS__)
#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, ne, __VA_ARGS__)
#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, gt, __VA_ARGS__)
#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, gt, __VA_ARGS__)
#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, gt, __VA_ARGS__)
#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lt, __VA_ARGS__)
#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lt, __VA_ARGS__)
#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lt, __VA_ARGS__)
#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, ge, __VA_ARGS__)
#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, ge, __VA_ARGS__)
#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, ge, __VA_ARGS__)
#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, le, __VA_ARGS__)
#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, le, __VA_ARGS__)
#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, le, __VA_ARGS__)

#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, __VA_ARGS__)
#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, __VA_ARGS__)
#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, __VA_ARGS__)
#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, __VA_ARGS__)
#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, __VA_ARGS__)
#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, __VA_ARGS__)

#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS

#undef DOCTEST_WARN_THROWS
#undef DOCTEST_CHECK_THROWS
#undef DOCTEST_REQUIRE_THROWS
#undef DOCTEST_WARN_THROWS_AS
#undef DOCTEST_CHECK_THROWS_AS
#undef DOCTEST_REQUIRE_THROWS_AS
#undef DOCTEST_WARN_THROWS_WITH
#undef DOCTEST_CHECK_THROWS_WITH
#undef DOCTEST_REQUIRE_THROWS_WITH
#undef DOCTEST_WARN_THROWS_WITH_AS
#undef DOCTEST_CHECK_THROWS_WITH_AS
#undef DOCTEST_REQUIRE_THROWS_WITH_AS
#undef DOCTEST_WARN_NOTHROW
#undef DOCTEST_CHECK_NOTHROW
#undef DOCTEST_REQUIRE_NOTHROW

#undef DOCTEST_WARN_THROWS_MESSAGE
#undef DOCTEST_CHECK_THROWS_MESSAGE
#undef DOCTEST_REQUIRE_THROWS_MESSAGE
#undef DOCTEST_WARN_THROWS_AS_MESSAGE
#undef DOCTEST_CHECK_THROWS_AS_MESSAGE
#undef DOCTEST_REQUIRE_THROWS_AS_MESSAGE
#undef DOCTEST_WARN_THROWS_WITH_MESSAGE
#undef DOCTEST_CHECK_THROWS_WITH_MESSAGE
#undef DOCTEST_REQUIRE_THROWS_WITH_MESSAGE
#undef DOCTEST_WARN_THROWS_WITH_AS_MESSAGE
#undef DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE
#undef DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE
#undef DOCTEST_WARN_NOTHROW_MESSAGE
#undef DOCTEST_CHECK_NOTHROW_MESSAGE
#undef DOCTEST_REQUIRE_NOTHROW_MESSAGE

#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS

#define DOCTEST_WARN_THROWS(expr) ((void)0)
#define DOCTEST_CHECK_THROWS(expr) ((void)0)
#define DOCTEST_REQUIRE_THROWS(expr) ((void)0)
#define DOCTEST_WARN_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_WARN_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_WARN_NOTHROW(expr) ((void)0)
#define DOCTEST_CHECK_NOTHROW(expr) ((void)0)
#define DOCTEST_REQUIRE_NOTHROW(expr) ((void)0)

#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) ((void)0)

#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS

#undef DOCTEST_REQUIRE
#undef DOCTEST_REQUIRE_FALSE
#undef DOCTEST_REQUIRE_MESSAGE
#undef DOCTEST_REQUIRE_FALSE_MESSAGE
#undef DOCTEST_REQUIRE_EQ
#undef DOCTEST_REQUIRE_NE
#undef DOCTEST_REQUIRE_GT
#undef DOCTEST_REQUIRE_LT
#undef DOCTEST_REQUIRE_GE
#undef DOCTEST_REQUIRE_LE
#undef DOCTEST_REQUIRE_UNARY
#undef DOCTEST_REQUIRE_UNARY_FALSE

#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS

#endif // DOCTEST_CONFIG_NO_EXCEPTIONS

// =================================================================================================
// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING!                      ==
// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY!                            ==
// =================================================================================================
#else // DOCTEST_CONFIG_DISABLE

#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name)                                           \
    namespace {                                                                                    \
        template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                           \
        struct der : public base                                                                   \
        { void f(); };                                                                             \
    }                                                                                              \
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
    inline void der<DOCTEST_UNUSED_TEMPLATE_TYPE>::f()

#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name)                                              \
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
    static inline void f()

// for registering tests
#define DOCTEST_TEST_CASE(name)                                                                    \
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name)

// for registering tests in classes
#define DOCTEST_TEST_CASE_CLASS(name)                                                              \
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name)

// for registering tests with a fixture
#define DOCTEST_TEST_CASE_FIXTURE(x, name)                                                         \
    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), x,                          \
                              DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name)

// for converting types to strings without the <typeinfo> header and demangling
#define DOCTEST_TYPE_TO_STRING(...) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)
#define DOCTEST_TYPE_TO_STRING_IMPL(...)

// for typed tests
#define DOCTEST_TEST_CASE_TEMPLATE(name, type, ...)                                                \
    template <typename type>                                                                       \
    inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)()

#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id)                                          \
    template <typename type>                                                                       \
    inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)()

#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...)                                                 \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...)                                                  \
    typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for subcases
#define DOCTEST_SUBCASE(name)

// for a testsuite block
#define DOCTEST_TEST_SUITE(name) namespace

// for starting a testsuite block
#define DOCTEST_TEST_SUITE_BEGIN(name) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

// for ending a testsuite block
#define DOCTEST_TEST_SUITE_END typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_)

#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
    static inline doctest::String DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)(signature)

#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)
#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)

#define DOCTEST_INFO(x) ((void)0)
#define DOCTEST_CAPTURE(x) ((void)0)
#define DOCTEST_ADD_MESSAGE_AT(file, line, x) ((void)0)
#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, x) ((void)0)
#define DOCTEST_ADD_FAIL_AT(file, line, x) ((void)0)
#define DOCTEST_MESSAGE(x) ((void)0)
#define DOCTEST_FAIL_CHECK(x) ((void)0)
#define DOCTEST_FAIL(x) ((void)0)

#define DOCTEST_WARN(...) ((void)0)
#define DOCTEST_CHECK(...) ((void)0)
#define DOCTEST_REQUIRE(...) ((void)0)
#define DOCTEST_WARN_FALSE(...) ((void)0)
#define DOCTEST_CHECK_FALSE(...) ((void)0)
#define DOCTEST_REQUIRE_FALSE(...) ((void)0)

#define DOCTEST_WARN_MESSAGE(cond, msg) ((void)0)
#define DOCTEST_CHECK_MESSAGE(cond, msg) ((void)0)
#define DOCTEST_REQUIRE_MESSAGE(cond, msg) ((void)0)
#define DOCTEST_WARN_FALSE_MESSAGE(cond, msg) ((void)0)
#define DOCTEST_CHECK_FALSE_MESSAGE(cond, msg) ((void)0)
#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, msg) ((void)0)

#define DOCTEST_WARN_THROWS(expr) ((void)0)
#define DOCTEST_CHECK_THROWS(expr) ((void)0)
#define DOCTEST_REQUIRE_THROWS(expr) ((void)0)
#define DOCTEST_WARN_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) ((void)0)
#define DOCTEST_WARN_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) ((void)0)
#define DOCTEST_WARN_NOTHROW(expr) ((void)0)
#define DOCTEST_CHECK_NOTHROW(expr) ((void)0)
#define DOCTEST_REQUIRE_NOTHROW(expr) ((void)0)

#define DOCTEST_WARN_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, msg) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, msg) ((void)0)
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, msg) ((void)0)
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, msg) ((void)0)
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, msg) ((void)0)

#define DOCTEST_WARN_EQ(...) ((void)0)
#define DOCTEST_CHECK_EQ(...) ((void)0)
#define DOCTEST_REQUIRE_EQ(...) ((void)0)
#define DOCTEST_WARN_NE(...) ((void)0)
#define DOCTEST_CHECK_NE(...) ((void)0)
#define DOCTEST_REQUIRE_NE(...) ((void)0)
#define DOCTEST_WARN_GT(...) ((void)0)
#define DOCTEST_CHECK_GT(...) ((void)0)
#define DOCTEST_REQUIRE_GT(...) ((void)0)
#define DOCTEST_WARN_LT(...) ((void)0)
#define DOCTEST_CHECK_LT(...) ((void)0)
#define DOCTEST_REQUIRE_LT(...) ((void)0)
#define DOCTEST_WARN_GE(...) ((void)0)
#define DOCTEST_CHECK_GE(...) ((void)0)
#define DOCTEST_REQUIRE_GE(...) ((void)0)
#define DOCTEST_WARN_LE(...) ((void)0)
#define DOCTEST_CHECK_LE(...) ((void)0)
#define DOCTEST_REQUIRE_LE(...) ((void)0)

#define DOCTEST_WARN_UNARY(...) ((void)0)
#define DOCTEST_CHECK_UNARY(...) ((void)0)
#define DOCTEST_REQUIRE_UNARY(...) ((void)0)
#define DOCTEST_WARN_UNARY_FALSE(...) ((void)0)
#define DOCTEST_CHECK_UNARY_FALSE(...) ((void)0)
#define DOCTEST_REQUIRE_UNARY_FALSE(...) ((void)0)

#endif // DOCTEST_CONFIG_DISABLE

// clang-format off
// KEPT FOR BACKWARDS COMPATIBILITY - FORWARDING TO THE RIGHT MACROS
#define DOCTEST_FAST_WARN_EQ             DOCTEST_WARN_EQ
#define DOCTEST_FAST_CHECK_EQ            DOCTEST_CHECK_EQ
#define DOCTEST_FAST_REQUIRE_EQ          DOCTEST_REQUIRE_EQ
#define DOCTEST_FAST_WARN_NE             DOCTEST_WARN_NE
#define DOCTEST_FAST_CHECK_NE            DOCTEST_CHECK_NE
#define DOCTEST_FAST_REQUIRE_NE          DOCTEST_REQUIRE_NE
#define DOCTEST_FAST_WARN_GT             DOCTEST_WARN_GT
#define DOCTEST_FAST_CHECK_GT            DOCTEST_CHECK_GT
#define DOCTEST_FAST_REQUIRE_GT          DOCTEST_REQUIRE_GT
#define DOCTEST_FAST_WARN_LT             DOCTEST_WARN_LT
#define DOCTEST_FAST_CHECK_LT            DOCTEST_CHECK_LT
#define DOCTEST_FAST_REQUIRE_LT          DOCTEST_REQUIRE_LT
#define DOCTEST_FAST_WARN_GE             DOCTEST_WARN_GE
#define DOCTEST_FAST_CHECK_GE            DOCTEST_CHECK_GE
#define DOCTEST_FAST_REQUIRE_GE          DOCTEST_REQUIRE_GE
#define DOCTEST_FAST_WARN_LE             DOCTEST_WARN_LE
#define DOCTEST_FAST_CHECK_LE            DOCTEST_CHECK_LE
#define DOCTEST_FAST_REQUIRE_LE          DOCTEST_REQUIRE_LE

#define DOCTEST_FAST_WARN_UNARY          DOCTEST_WARN_UNARY
#define DOCTEST_FAST_CHECK_UNARY         DOCTEST_CHECK_UNARY
#define DOCTEST_FAST_REQUIRE_UNARY       DOCTEST_REQUIRE_UNARY
#define DOCTEST_FAST_WARN_UNARY_FALSE    DOCTEST_WARN_UNARY_FALSE
#define DOCTEST_FAST_CHECK_UNARY_FALSE   DOCTEST_CHECK_UNARY_FALSE
#define DOCTEST_FAST_REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE

#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE DOCTEST_TEST_CASE_TEMPLATE_INVOKE
// clang-format on

// BDD style macros
// clang-format off
#define DOCTEST_SCENARIO(name) DOCTEST_TEST_CASE("  Scenario: " name)
#define DOCTEST_SCENARIO_CLASS(name) DOCTEST_TEST_CASE_CLASS("  Scenario: " name)
#define DOCTEST_SCENARIO_TEMPLATE(name, T, ...)  DOCTEST_TEST_CASE_TEMPLATE("  Scenario: " name, T, __VA_ARGS__)
#define DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE("  Scenario: " name, T, id)

#define DOCTEST_GIVEN(name)     DOCTEST_SUBCASE("   Given: " name)
#define DOCTEST_WHEN(name)      DOCTEST_SUBCASE("    When: " name)
#define DOCTEST_AND_WHEN(name)  DOCTEST_SUBCASE("And when: " name)
#define DOCTEST_THEN(name)      DOCTEST_SUBCASE("    Then: " name)
#define DOCTEST_AND_THEN(name)  DOCTEST_SUBCASE("     And: " name)
// clang-format on

// == SHORT VERSIONS OF THE MACROS
#if !defined(DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES)

#define TEST_CASE DOCTEST_TEST_CASE
#define TEST_CASE_CLASS DOCTEST_TEST_CASE_CLASS
#define TEST_CASE_FIXTURE DOCTEST_TEST_CASE_FIXTURE
#define TYPE_TO_STRING DOCTEST_TYPE_TO_STRING
#define TEST_CASE_TEMPLATE DOCTEST_TEST_CASE_TEMPLATE
#define TEST_CASE_TEMPLATE_DEFINE DOCTEST_TEST_CASE_TEMPLATE_DEFINE
#define TEST_CASE_TEMPLATE_INVOKE DOCTEST_TEST_CASE_TEMPLATE_INVOKE
#define TEST_CASE_TEMPLATE_APPLY DOCTEST_TEST_CASE_TEMPLATE_APPLY
#define SUBCASE DOCTEST_SUBCASE
#define TEST_SUITE DOCTEST_TEST_SUITE
#define TEST_SUITE_BEGIN DOCTEST_TEST_SUITE_BEGIN
#define TEST_SUITE_END DOCTEST_TEST_SUITE_END
#define REGISTER_EXCEPTION_TRANSLATOR DOCTEST_REGISTER_EXCEPTION_TRANSLATOR
#define REGISTER_REPORTER DOCTEST_REGISTER_REPORTER
#define REGISTER_LISTENER DOCTEST_REGISTER_LISTENER
#define INFO DOCTEST_INFO
#define CAPTURE DOCTEST_CAPTURE
#define ADD_MESSAGE_AT DOCTEST_ADD_MESSAGE_AT
#define ADD_FAIL_CHECK_AT DOCTEST_ADD_FAIL_CHECK_AT
#define ADD_FAIL_AT DOCTEST_ADD_FAIL_AT
#define MESSAGE DOCTEST_MESSAGE
#define FAIL_CHECK DOCTEST_FAIL_CHECK
#define FAIL DOCTEST_FAIL
#define TO_LVALUE DOCTEST_TO_LVALUE

#define WARN DOCTEST_WARN
#define WARN_FALSE DOCTEST_WARN_FALSE
#define WARN_THROWS DOCTEST_WARN_THROWS
#define WARN_THROWS_AS DOCTEST_WARN_THROWS_AS
#define WARN_THROWS_WITH DOCTEST_WARN_THROWS_WITH
#define WARN_THROWS_WITH_AS DOCTEST_WARN_THROWS_WITH_AS
#define WARN_NOTHROW DOCTEST_WARN_NOTHROW
#define CHECK DOCTEST_CHECK
#define CHECK_FALSE DOCTEST_CHECK_FALSE
#define CHECK_THROWS DOCTEST_CHECK_THROWS
#define CHECK_THROWS_AS DOCTEST_CHECK_THROWS_AS
#define CHECK_THROWS_WITH DOCTEST_CHECK_THROWS_WITH
#define CHECK_THROWS_WITH_AS DOCTEST_CHECK_THROWS_WITH_AS
#define CHECK_NOTHROW DOCTEST_CHECK_NOTHROW
#define REQUIRE DOCTEST_REQUIRE
#define REQUIRE_FALSE DOCTEST_REQUIRE_FALSE
#define REQUIRE_THROWS DOCTEST_REQUIRE_THROWS
#define REQUIRE_THROWS_AS DOCTEST_REQUIRE_THROWS_AS
#define REQUIRE_THROWS_WITH DOCTEST_REQUIRE_THROWS_WITH
#define REQUIRE_THROWS_WITH_AS DOCTEST_REQUIRE_THROWS_WITH_AS
#define REQUIRE_NOTHROW DOCTEST_REQUIRE_NOTHROW

#define WARN_MESSAGE DOCTEST_WARN_MESSAGE
#define WARN_FALSE_MESSAGE DOCTEST_WARN_FALSE_MESSAGE
#define WARN_THROWS_MESSAGE DOCTEST_WARN_THROWS_MESSAGE
#define WARN_THROWS_AS_MESSAGE DOCTEST_WARN_THROWS_AS_MESSAGE
#define WARN_THROWS_WITH_MESSAGE DOCTEST_WARN_THROWS_WITH_MESSAGE
#define WARN_THROWS_WITH_AS_MESSAGE DOCTEST_WARN_THROWS_WITH_AS_MESSAGE
#define WARN_NOTHROW_MESSAGE DOCTEST_WARN_NOTHROW_MESSAGE
#define CHECK_MESSAGE DOCTEST_CHECK_MESSAGE
#define CHECK_FALSE_MESSAGE DOCTEST_CHECK_FALSE_MESSAGE
#define CHECK_THROWS_MESSAGE DOCTEST_CHECK_THROWS_MESSAGE
#define CHECK_THROWS_AS_MESSAGE DOCTEST_CHECK_THROWS_AS_MESSAGE
#define CHECK_THROWS_WITH_MESSAGE DOCTEST_CHECK_THROWS_WITH_MESSAGE
#define CHECK_THROWS_WITH_AS_MESSAGE DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE
#define CHECK_NOTHROW_MESSAGE DOCTEST_CHECK_NOTHROW_MESSAGE
#define REQUIRE_MESSAGE DOCTEST_REQUIRE_MESSAGE
#define REQUIRE_FALSE_MESSAGE DOCTEST_REQUIRE_FALSE_MESSAGE
#define REQUIRE_THROWS_MESSAGE DOCTEST_REQUIRE_THROWS_MESSAGE
#define REQUIRE_THROWS_AS_MESSAGE DOCTEST_REQUIRE_THROWS_AS_MESSAGE
#define REQUIRE_THROWS_WITH_MESSAGE DOCTEST_REQUIRE_THROWS_WITH_MESSAGE
#define REQUIRE_THROWS_WITH_AS_MESSAGE DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE
#define REQUIRE_NOTHROW_MESSAGE DOCTEST_REQUIRE_NOTHROW_MESSAGE

#define SCENARIO DOCTEST_SCENARIO
#define SCENARIO_CLASS DOCTEST_SCENARIO_CLASS
#define SCENARIO_TEMPLATE DOCTEST_SCENARIO_TEMPLATE
#define SCENARIO_TEMPLATE_DEFINE DOCTEST_SCENARIO_TEMPLATE_DEFINE
#define GIVEN DOCTEST_GIVEN
#define WHEN DOCTEST_WHEN
#define AND_WHEN DOCTEST_AND_WHEN
#define THEN DOCTEST_THEN
#define AND_THEN DOCTEST_AND_THEN

#define WARN_EQ DOCTEST_WARN_EQ
#define CHECK_EQ DOCTEST_CHECK_EQ
#define REQUIRE_EQ DOCTEST_REQUIRE_EQ
#define WARN_NE DOCTEST_WARN_NE
#define CHECK_NE DOCTEST_CHECK_NE
#define REQUIRE_NE DOCTEST_REQUIRE_NE
#define WARN_GT DOCTEST_WARN_GT
#define CHECK_GT DOCTEST_CHECK_GT
#define REQUIRE_GT DOCTEST_REQUIRE_GT
#define WARN_LT DOCTEST_WARN_LT
#define CHECK_LT DOCTEST_CHECK_LT
#define REQUIRE_LT DOCTEST_REQUIRE_LT
#define WARN_GE DOCTEST_WARN_GE
#define CHECK_GE DOCTEST_CHECK_GE
#define REQUIRE_GE DOCTEST_REQUIRE_GE
#define WARN_LE DOCTEST_WARN_LE
#define CHECK_LE DOCTEST_CHECK_LE
#define REQUIRE_LE DOCTEST_REQUIRE_LE
#define WARN_UNARY DOCTEST_WARN_UNARY
#define CHECK_UNARY DOCTEST_CHECK_UNARY
#define REQUIRE_UNARY DOCTEST_REQUIRE_UNARY
#define WARN_UNARY_FALSE DOCTEST_WARN_UNARY_FALSE
#define CHECK_UNARY_FALSE DOCTEST_CHECK_UNARY_FALSE
#define REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE

// KEPT FOR BACKWARDS COMPATIBILITY
#define FAST_WARN_EQ DOCTEST_FAST_WARN_EQ
#define FAST_CHECK_EQ DOCTEST_FAST_CHECK_EQ
#define FAST_REQUIRE_EQ DOCTEST_FAST_REQUIRE_EQ
#define FAST_WARN_NE DOCTEST_FAST_WARN_NE
#define FAST_CHECK_NE DOCTEST_FAST_CHECK_NE
#define FAST_REQUIRE_NE DOCTEST_FAST_REQUIRE_NE
#define FAST_WARN_GT DOCTEST_FAST_WARN_GT
#define FAST_CHECK_GT DOCTEST_FAST_CHECK_GT
#define FAST_REQUIRE_GT DOCTEST_FAST_REQUIRE_GT
#define FAST_WARN_LT DOCTEST_FAST_WARN_LT
#define FAST_CHECK_LT DOCTEST_FAST_CHECK_LT
#define FAST_REQUIRE_LT DOCTEST_FAST_REQUIRE_LT
#define FAST_WARN_GE DOCTEST_FAST_WARN_GE
#define FAST_CHECK_GE DOCTEST_FAST_CHECK_GE
#define FAST_REQUIRE_GE DOCTEST_FAST_REQUIRE_GE
#define FAST_WARN_LE DOCTEST_FAST_WARN_LE
#define FAST_CHECK_LE DOCTEST_FAST_CHECK_LE
#define FAST_REQUIRE_LE DOCTEST_FAST_REQUIRE_LE

#define FAST_WARN_UNARY DOCTEST_FAST_WARN_UNARY
#define FAST_CHECK_UNARY DOCTEST_FAST_CHECK_UNARY
#define FAST_REQUIRE_UNARY DOCTEST_FAST_REQUIRE_UNARY
#define FAST_WARN_UNARY_FALSE DOCTEST_FAST_WARN_UNARY_FALSE
#define FAST_CHECK_UNARY_FALSE DOCTEST_FAST_CHECK_UNARY_FALSE
#define FAST_REQUIRE_UNARY_FALSE DOCTEST_FAST_REQUIRE_UNARY_FALSE

#define TEST_CASE_TEMPLATE_INSTANTIATE DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE

#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES

#if !defined(DOCTEST_CONFIG_DISABLE)

// this is here to clear the 'current test suite' for the current translation unit - at the top
DOCTEST_TEST_SUITE_END();

// add stringification for primitive/fundamental types
namespace doctest { namespace detail {
    DOCTEST_TYPE_TO_STRING_IMPL(bool)
    DOCTEST_TYPE_TO_STRING_IMPL(float)
    DOCTEST_TYPE_TO_STRING_IMPL(double)
    DOCTEST_TYPE_TO_STRING_IMPL(long double)
    DOCTEST_TYPE_TO_STRING_IMPL(char)
    DOCTEST_TYPE_TO_STRING_IMPL(signed char)
    DOCTEST_TYPE_TO_STRING_IMPL(unsigned char)
#if !DOCTEST_MSVC || defined(_NATIVE_WCHAR_T_DEFINED)
    DOCTEST_TYPE_TO_STRING_IMPL(wchar_t)
#endif // not MSVC or wchar_t support enabled
    DOCTEST_TYPE_TO_STRING_IMPL(short int)
    DOCTEST_TYPE_TO_STRING_IMPL(unsigned short int)
    DOCTEST_TYPE_TO_STRING_IMPL(int)
    DOCTEST_TYPE_TO_STRING_IMPL(unsigned int)
    DOCTEST_TYPE_TO_STRING_IMPL(long int)
    DOCTEST_TYPE_TO_STRING_IMPL(unsigned long int)
    DOCTEST_TYPE_TO_STRING_IMPL(long long int)
    DOCTEST_TYPE_TO_STRING_IMPL(unsigned long long int)
}} // namespace doctest::detail

#endif // DOCTEST_CONFIG_DISABLE

DOCTEST_CLANG_SUPPRESS_WARNING_POP
DOCTEST_MSVC_SUPPRESS_WARNING_POP
DOCTEST_GCC_SUPPRESS_WARNING_POP

#endif // DOCTEST_LIBRARY_INCLUDED

#ifndef DOCTEST_SINGLE_HEADER
#define DOCTEST_SINGLE_HEADER
#endif // DOCTEST_SINGLE_HEADER

#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER)

#ifndef DOCTEST_SINGLE_HEADER
#include "doctest_fwd.h"
#endif // DOCTEST_SINGLE_HEADER

DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-macros")

#ifndef DOCTEST_LIBRARY_IMPLEMENTATION
#define DOCTEST_LIBRARY_IMPLEMENTATION

DOCTEST_CLANG_SUPPRESS_WARNING_POP

DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wglobal-constructors")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wshorten-64-to-32")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-variable-declarations")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch-enum")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wcovered-switch-default")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-noreturn")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-local-typedef")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wdisabled-macro-expansion")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-braces")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-field-initializers")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")

DOCTEST_GCC_SUPPRESS_WARNING_PUSH
DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas")
DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas")
DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++")
DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow")
DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing")
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-field-initializers")
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-braces")
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations")
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch")
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-enum")
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-default")
DOCTEST_GCC_SUPPRESS_WARNING("-Wunsafe-loop-optimizations")
DOCTEST_GCC_SUPPRESS_WARNING("-Wold-style-cast")
DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-local-typedefs")
DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast")
DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-function")
DOCTEST_GCC_SUPPRESS_WARNING("-Wmultiple-inheritance")
DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")
DOCTEST_GCC_SUPPRESS_WARNING("-Wsuggest-attribute")

DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
DOCTEST_MSVC_SUPPRESS_WARNING(4616) // invalid compiler warning
DOCTEST_MSVC_SUPPRESS_WARNING(4619) // invalid compiler warning
DOCTEST_MSVC_SUPPRESS_WARNING(4996) // The compiler encountered a deprecated declaration
DOCTEST_MSVC_SUPPRESS_WARNING(4267) // 'var' : conversion from 'x' to 'y', possible loss of data
DOCTEST_MSVC_SUPPRESS_WARNING(4706) // assignment within conditional expression
DOCTEST_MSVC_SUPPRESS_WARNING(4512) // 'class' : assignment operator could not be generated
DOCTEST_MSVC_SUPPRESS_WARNING(4127) // conditional expression is constant
DOCTEST_MSVC_SUPPRESS_WARNING(4530) // C++ exception handler used, but unwind semantics not enabled
DOCTEST_MSVC_SUPPRESS_WARNING(4577) // 'noexcept' used with no exception handling mode specified
DOCTEST_MSVC_SUPPRESS_WARNING(4774) // format string expected in argument is not a string literal
DOCTEST_MSVC_SUPPRESS_WARNING(4365) // conversion from 'int' to 'unsigned', signed/unsigned mismatch
DOCTEST_MSVC_SUPPRESS_WARNING(4820) // padding in structs
DOCTEST_MSVC_SUPPRESS_WARNING(4640) // construction of local static object is not thread-safe
DOCTEST_MSVC_SUPPRESS_WARNING(5039) // pointer to potentially throwing function passed to extern C
DOCTEST_MSVC_SUPPRESS_WARNING(5045) // Spectre mitigation stuff
DOCTEST_MSVC_SUPPRESS_WARNING(4626) // assignment operator was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(5027) // move assignment operator was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(5026) // move constructor was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(4625) // copy constructor was implicitly defined as deleted
DOCTEST_MSVC_SUPPRESS_WARNING(4800) // forcing value to bool 'true' or 'false' (performance warning)
// static analysis
DOCTEST_MSVC_SUPPRESS_WARNING(26439) // This kind of function may not throw. Declare it 'noexcept'
DOCTEST_MSVC_SUPPRESS_WARNING(26495) // Always initialize a member variable
DOCTEST_MSVC_SUPPRESS_WARNING(26451) // Arithmetic overflow ...
DOCTEST_MSVC_SUPPRESS_WARNING(26444) // Avoid unnamed objects with custom construction and dtor...

DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN

// required includes - will go only in one translation unit!
#include <ctime>
#include <cmath>
#include <climits>
// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/onqtam/doctest/pull/37
#ifdef __BORLANDC__
#include <math.h>
#endif // __BORLANDC__
#include <new>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <utility>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <atomic>
#include <mutex>
#include <set>
#include <map>
#include <exception>
#include <stdexcept>
#ifdef DOCTEST_CONFIG_POSIX_SIGNALS
#include <csignal>
#endif // DOCTEST_CONFIG_POSIX_SIGNALS
#include <cfloat>
#include <cctype>
#include <cstdint>

#ifdef DOCTEST_PLATFORM_MAC
#include <sys/types.h>
#include <unistd.h>
#include <sys/sysctl.h>
#endif // DOCTEST_PLATFORM_MAC

#ifdef DOCTEST_PLATFORM_WINDOWS

// defines for a leaner windows.h
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif // WIN32_LEAN_AND_MEAN
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX

// not sure what AfxWin.h is for - here I do what Catch does
#ifdef __AFXDLL
#include <AfxWin.h>
#else
#include <Windows.h>
#endif
#include <io.h>

#else // DOCTEST_PLATFORM_WINDOWS

#include <sys/time.h>
#include <unistd.h>

#endif // DOCTEST_PLATFORM_WINDOWS

DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END

// counts the number of elements in a C array
#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0]))

#ifdef DOCTEST_CONFIG_DISABLE
#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_disabled
#else // DOCTEST_CONFIG_DISABLE
#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_not_disabled
#endif // DOCTEST_CONFIG_DISABLE

#ifndef DOCTEST_CONFIG_OPTIONS_PREFIX
#define DOCTEST_CONFIG_OPTIONS_PREFIX "dt-"
#endif

#ifdef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
#define DOCTEST_OPTIONS_PREFIX_DISPLAY DOCTEST_CONFIG_OPTIONS_PREFIX
#else
#define DOCTEST_OPTIONS_PREFIX_DISPLAY ""
#endif

namespace doctest {

bool is_running_in_test = false;

namespace {
    using namespace detail;
    // case insensitive strcmp
    int stricmp(const char* a, const char* b) {
        for(;; a++, b++) {
            const int d = tolower(*a) - tolower(*b);
            if(d != 0 || !*a)
                return d;
        }
    }

    template <typename T>
    String fpToString(T value, int precision) {
        std::ostringstream oss;
        oss << std::setprecision(precision) << std::fixed << value;
        std::string d = oss.str();
        size_t      i = d.find_last_not_of('0');
        if(i != std::string::npos && i != d.size() - 1) {
            if(d[i] == '.')
                i++;
            d = d.substr(0, i + 1);
        }
        return d.c_str();
    }

    struct Endianness
    {
        enum Arch
        {
            Big,
            Little
        };

        static Arch which() {
            int x = 1;
            // casting any data pointer to char* is allowed
            auto ptr = reinterpret_cast<char*>(&x);
            if(*ptr)
                return Little;
            return Big;
        }
    };
} // namespace

namespace detail {
    void my_memcpy(void* dest, const void* src, unsigned num) { memcpy(dest, src, num); }

    String rawMemoryToString(const void* object, unsigned size) {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>(size), inc = 1;
        if(Endianness::which() == Endianness::Little) {
            i   = end - 1;
            end = inc = -1;
        }

        unsigned const char* bytes = static_cast<unsigned const char*>(object);
        std::ostringstream   oss;
        oss << "0x" << std::setfill('0') << std::hex;
        for(; i != end; i += inc)
            oss << std::setw(2) << static_cast<unsigned>(bytes[i]);
        return oss.str().c_str();
    }

    DOCTEST_THREAD_LOCAL std::ostringstream g_oss; // NOLINT(cert-err58-cpp)

    std::ostream* getTlsOss() {
        g_oss.clear(); // there shouldn't be anything worth clearing in the flags
        g_oss.str(""); // the slow way of resetting a string stream
        //g_oss.seekp(0); // optimal reset - as seen here: https://stackoverflow.com/a/624291/3162383
        return &g_oss;
    }

    String getTlsOssResult() {
        //g_oss << std::ends; // needed - as shown here: https://stackoverflow.com/a/624291/3162383
        return g_oss.str().c_str();
    }

#ifndef DOCTEST_CONFIG_DISABLE

    typedef uint64_t UInt64;

#ifdef DOCTEST_CONFIG_GETCURRENTTICKS
    UInt64 getCurrentTicks() { return DOCTEST_CONFIG_GETCURRENTTICKS(); }
#elif defined(DOCTEST_PLATFORM_WINDOWS)
    UInt64 getCurrentTicks() {
        static UInt64 hz = 0, hzo = 0;
        if(!hz) {
            QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&hz));
            QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&hzo));
        }
        UInt64 t;
        QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&t));
        return ((t - hzo) * 1000000) / hz;
    }
#else  // DOCTEST_PLATFORM_WINDOWS
    UInt64 getCurrentTicks() {
        timeval t;
        gettimeofday(&t, nullptr);
        return static_cast<UInt64>(t.tv_sec) * 1000000 + static_cast<UInt64>(t.tv_usec);
    }
#endif // DOCTEST_PLATFORM_WINDOWS

    struct Timer
    {
        void         start() { m_ticks = getCurrentTicks(); }
        unsigned int getElapsedMicroseconds() const {
            return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
        }
        //unsigned int getElapsedMilliseconds() const {
        //    return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
        //}
        double getElapsedSeconds() const { return getElapsedMicroseconds() / 1000000.0; }

    private:
        UInt64 m_ticks = 0;
    };

    // this holds both parameters from the command line and runtime data for tests
    struct ContextState : ContextOptions, TestRunStats, CurrentTestCaseStats
    {
        std::atomic<int> numAssertsCurrentTest_atomic;
        std::atomic<int> numAssertsFailedCurrentTest_atomic;

        std::vector<std::vector<String>> filters = decltype(filters)(9); // 9 different filters

        std::vector<IReporter*> reporters_currently_used;

        const TestCase* currentTest = nullptr;

        assert_handler ah = nullptr;

        Timer timer;

        std::vector<String> stringifiedContexts; // logging from INFO() due to an exception

        // stuff for subcases
        std::vector<SubcaseSignature>     subcasesStack;
        std::set<decltype(subcasesStack)> subcasesPassed;
        int                               subcasesCurrentMaxLevel;
        bool                              should_reenter;
        std::atomic<bool>                 shouldLogCurrentException;

        void resetRunData() {
            numTestCases                = 0;
            numTestCasesPassingFilters  = 0;
            numTestSuitesPassingFilters = 0;
            numTestCasesFailed          = 0;
            numAsserts                  = 0;
            numAssertsFailed            = 0;
            numAssertsCurrentTest       = 0;
            numAssertsFailedCurrentTest = 0;
        }

        void finalizeTestCaseData() {
            seconds = timer.getElapsedSeconds();

            // update the non-atomic counters
            numAsserts += numAssertsCurrentTest_atomic;
            numAssertsFailed += numAssertsFailedCurrentTest_atomic;
            numAssertsCurrentTest       = numAssertsCurrentTest_atomic;
            numAssertsFailedCurrentTest = numAssertsFailedCurrentTest_atomic;

            if(numAssertsFailedCurrentTest)
                failure_flags |= TestCaseFailureReason::AssertFailure;

            if(Approx(currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 &&
               Approx(seconds).epsilon(DBL_EPSILON) > currentTest->m_timeout)
                failure_flags |= TestCaseFailureReason::Timeout;

            if(currentTest->m_should_fail) {
                if(failure_flags) {
                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedAndDid;
                } else {
                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedButDidnt;
                }
            } else if(failure_flags && currentTest->m_may_fail) {
                failure_flags |= TestCaseFailureReason::CouldHaveFailedAndDid;
            } else if(currentTest->m_expected_failures > 0) {
                if(numAssertsFailedCurrentTest == currentTest->m_expected_failures) {
                    failure_flags |= TestCaseFailureReason::FailedExactlyNumTimes;
                } else {
                    failure_flags |= TestCaseFailureReason::DidntFailExactlyNumTimes;
                }
            }

            bool ok_to_fail = (TestCaseFailureReason::ShouldHaveFailedAndDid & failure_flags) ||
                              (TestCaseFailureReason::CouldHaveFailedAndDid & failure_flags) ||
                              (TestCaseFailureReason::FailedExactlyNumTimes & failure_flags);

            // if any subcase has failed - the whole test case has failed
            if(failure_flags && !ok_to_fail)
                numTestCasesFailed++;
        }
    };

    ContextState* g_cs = nullptr;

    // used to avoid locks for the debug output
    // TODO: figure out if this is indeed necessary/correct - seems like either there still
    // could be a race or that there wouldn't be a race even if using the context directly
    DOCTEST_THREAD_LOCAL bool g_no_colors;

#endif // DOCTEST_CONFIG_DISABLE
} // namespace detail

void String::setOnHeap() { *reinterpret_cast<unsigned char*>(&buf[last]) = 128; }
void String::setLast(unsigned in) { buf[last] = char(in); }

void String::copy(const String& other) {
    if(other.isOnStack()) {
        memcpy(buf, other.buf, len);
    } else {
        setOnHeap();
        data.size     = other.data.size;
        data.capacity = data.size + 1;
        data.ptr      = new char[data.capacity];
        memcpy(data.ptr, other.data.ptr, data.size + 1);
    }
}

String::String() {
    buf[0] = '\0';
    setLast();
}

String::~String() {
    if(!isOnStack())
        delete[] data.ptr;
}

String::String(const char* in)
        : String(in, strlen(in)) {}

String::String(const char* in, unsigned in_size) {
    if(in_size <= last) {
        memcpy(buf, in, in_size + 1);
        setLast(last - in_size);
    } else {
        setOnHeap();
        data.size     = in_size;
        data.capacity = data.size + 1;
        data.ptr      = new char[data.capacity];
        memcpy(data.ptr, in, in_size + 1);
    }
}

String::String(const String& other) { copy(other); }

String& String::operator=(const String& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;

        copy(other);
    }

    return *this;
}

String& String::operator+=(const String& other) {
    const unsigned my_old_size = size();
    const unsigned other_size  = other.size();
    const unsigned total_size  = my_old_size + other_size;
    if(isOnStack()) {
        if(total_size < len) {
            // append to the current stack space
            memcpy(buf + my_old_size, other.c_str(), other_size + 1);
            setLast(last - total_size);
        } else {
            // alloc new chunk
            char* temp = new char[total_size + 1];
            // copy current data to new location before writing in the union
            memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed
            // update data in union
            setOnHeap();
            data.size     = total_size;
            data.capacity = data.size + 1;
            data.ptr      = temp;
            // transfer the rest of the data
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
        }
    } else {
        if(data.capacity > total_size) {
            // append to the current heap block
            data.size = total_size;
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
        } else {
            // resize
            data.capacity *= 2;
            if(data.capacity <= total_size)
                data.capacity = total_size + 1;
            // alloc new chunk
            char* temp = new char[data.capacity];
            // copy current data to new location before releasing it
            memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed
            // release old chunk
            delete[] data.ptr;
            // update the rest of the union members
            data.size = total_size;
            data.ptr  = temp;
            // transfer the rest of the data
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
        }
    }

    return *this;
}

String String::operator+(const String& other) const { return String(*this) += other; }

String::String(String&& other) {
    memcpy(buf, other.buf, len);
    other.buf[0] = '\0';
    other.setLast();
}

String& String::operator=(String&& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;
        memcpy(buf, other.buf, len);
        other.buf[0] = '\0';
        other.setLast();
    }
    return *this;
}

char String::operator[](unsigned i) const {
    return const_cast<String*>(this)->operator[](i); // NOLINT
}

char& String::operator[](unsigned i) {
    if(isOnStack())
        return reinterpret_cast<char*>(buf)[i];
    return data.ptr[i];
}

DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmaybe-uninitialized")
unsigned String::size() const {
    if(isOnStack())
        return last - (unsigned(buf[last]) & 31); // using "last" would work only if "len" is 32
    return data.size;
}
DOCTEST_GCC_SUPPRESS_WARNING_POP

unsigned String::capacity() const {
    if(isOnStack())
        return len;
    return data.capacity;
}

int String::compare(const char* other, bool no_case) const {
    if(no_case)
        return stricmp(c_str(), other);
    return std::strcmp(c_str(), other);
}

int String::compare(const String& other, bool no_case) const {
    return compare(other.c_str(), no_case);
}

// clang-format off
bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; }
bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; }
bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; }
bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; }
// clang-format on

std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); }

namespace {
    void color_to_stream(std::ostream&, Color::Enum) DOCTEST_BRANCH_ON_DISABLED({}, ;)
} // namespace

namespace Color {
    std::ostream& operator<<(std::ostream& s, Color::Enum code) {
        color_to_stream(s, code);
        return s;
    }
} // namespace Color

// clang-format off
const char* assertString(assertType::Enum at) {
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4062) // enum 'x' in switch of enum 'y' is not handled
    switch(at) {  //!OCLINT missing default in switch statements
        case assertType::DT_WARN                    : return "WARN";
        case assertType::DT_CHECK                   : return "CHECK";
        case assertType::DT_REQUIRE                 : return "REQUIRE";

        case assertType::DT_WARN_FALSE              : return "WARN_FALSE";
        case assertType::DT_CHECK_FALSE             : return "CHECK_FALSE";
        case assertType::DT_REQUIRE_FALSE           : return "REQUIRE_FALSE";

        case assertType::DT_WARN_THROWS             : return "WARN_THROWS";
        case assertType::DT_CHECK_THROWS            : return "CHECK_THROWS";
        case assertType::DT_REQUIRE_THROWS          : return "REQUIRE_THROWS";

        case assertType::DT_WARN_THROWS_AS          : return "WARN_THROWS_AS";
        case assertType::DT_CHECK_THROWS_AS         : return "CHECK_THROWS_AS";
        case assertType::DT_REQUIRE_THROWS_AS       : return "REQUIRE_THROWS_AS";

        case assertType::DT_WARN_THROWS_WITH        : return "WARN_THROWS_WITH";
        case assertType::DT_CHECK_THROWS_WITH       : return "CHECK_THROWS_WITH";
        case assertType::DT_REQUIRE_THROWS_WITH     : return "REQUIRE_THROWS_WITH";

        case assertType::DT_WARN_THROWS_WITH_AS     : return "WARN_THROWS_WITH_AS";
        case assertType::DT_CHECK_THROWS_WITH_AS    : return "CHECK_THROWS_WITH_AS";
        case assertType::DT_REQUIRE_THROWS_WITH_AS  : return "REQUIRE_THROWS_WITH_AS";

        case assertType::DT_WARN_NOTHROW            : return "WARN_NOTHROW";
        case assertType::DT_CHECK_NOTHROW           : return "CHECK_NOTHROW";
        case assertType::DT_REQUIRE_NOTHROW         : return "REQUIRE_NOTHROW";

        case assertType::DT_WARN_EQ                 : return "WARN_EQ";
        case assertType::DT_CHECK_EQ                : return "CHECK_EQ";
        case assertType::DT_REQUIRE_EQ              : return "REQUIRE_EQ";
        case assertType::DT_WARN_NE                 : return "WARN_NE";
        case assertType::DT_CHECK_NE                : return "CHECK_NE";
        case assertType::DT_REQUIRE_NE              : return "REQUIRE_NE";
        case assertType::DT_WARN_GT                 : return "WARN_GT";
        case assertType::DT_CHECK_GT                : return "CHECK_GT";
        case assertType::DT_REQUIRE_GT              : return "REQUIRE_GT";
        case assertType::DT_WARN_LT                 : return "WARN_LT";
        case assertType::DT_CHECK_LT                : return "CHECK_LT";
        case assertType::DT_REQUIRE_LT              : return "REQUIRE_LT";
        case assertType::DT_WARN_GE                 : return "WARN_GE";
        case assertType::DT_CHECK_GE                : return "CHECK_GE";
        case assertType::DT_REQUIRE_GE              : return "REQUIRE_GE";
        case assertType::DT_WARN_LE                 : return "WARN_LE";
        case assertType::DT_CHECK_LE                : return "CHECK_LE";
        case assertType::DT_REQUIRE_LE              : return "REQUIRE_LE";

        case assertType::DT_WARN_UNARY              : return "WARN_UNARY";
        case assertType::DT_CHECK_UNARY             : return "CHECK_UNARY";
        case assertType::DT_REQUIRE_UNARY           : return "REQUIRE_UNARY";
        case assertType::DT_WARN_UNARY_FALSE        : return "WARN_UNARY_FALSE";
        case assertType::DT_CHECK_UNARY_FALSE       : return "CHECK_UNARY_FALSE";
        case assertType::DT_REQUIRE_UNARY_FALSE     : return "REQUIRE_UNARY_FALSE";
    }
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
    return "";
}
// clang-format on

const char* failureString(assertType::Enum at) {
    if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
        return "WARNING";
    if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
        return "ERROR";
    if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
        return "FATAL ERROR";
    return "";
}

DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
// depending on the current options this will remove the path of filenames
const char* skipPathFromFilename(const char* file) {
    if(getContextOptions()->no_path_in_filenames) {
        auto back    = std::strrchr(file, '\\');
        auto forward = std::strrchr(file, '/');
        if(back || forward) {
            if(back > forward)
                forward = back;
            return forward + 1;
        }
    }
    return file;
}
DOCTEST_CLANG_SUPPRESS_WARNING_POP
DOCTEST_GCC_SUPPRESS_WARNING_POP

bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
    if(m_line != other.m_line)
        return m_line < other.m_line;
    if(std::strcmp(m_file, other.m_file) != 0)
        return std::strcmp(m_file, other.m_file) < 0;
    return std::strcmp(m_name, other.m_name) < 0;
}

IContextScope::IContextScope()  = default;
IContextScope::~IContextScope() = default;

#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
String toString(char* in) { return toString(static_cast<const char*>(in)); }
String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; }
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
String toString(bool in) { return in ? "true" : "false"; }
String toString(float in) { return fpToString(in, 5) + "f"; }
String toString(double in) { return fpToString(in, 10); }
String toString(double long in) { return fpToString(in, 15); }

#define DOCTEST_TO_STRING_OVERLOAD(type, fmt)                                                      \
    String toString(type in) {                                                                     \
        char buf[64];                                                                              \
        std::sprintf(buf, fmt, in);                                                                \
        return buf;                                                                                \
    }

DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int long, "%ld")
DOCTEST_TO_STRING_OVERLOAD(int long unsigned, "%lu")
DOCTEST_TO_STRING_OVERLOAD(int long long, "%lld")
DOCTEST_TO_STRING_OVERLOAD(int long long unsigned, "%llu")

String toString(std::nullptr_t) { return "NULL"; }

#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183
String toString(const std::string& in) { return in.c_str(); }
#endif // VS 2019

Approx::Approx(double value)
        : m_epsilon(static_cast<double>(std::numeric_limits<float>::epsilon()) * 100)
        , m_scale(1.0)
        , m_value(value) {}

Approx Approx::operator()(double value) const {
    Approx approx(value);
    approx.epsilon(m_epsilon);
    approx.scale(m_scale);
    return approx;
}

Approx& Approx::epsilon(double newEpsilon) {
    m_epsilon = newEpsilon;
    return *this;
}
Approx& Approx::scale(double newScale) {
    m_scale = newScale;
    return *this;
}

bool operator==(double lhs, const Approx& rhs) {
    // Thanks to Richard Harris for his help refining this formula
    return std::fabs(lhs - rhs.m_value) <
           rhs.m_epsilon * (rhs.m_scale + std::max<double>(std::fabs(lhs), std::fabs(rhs.m_value)));
}
bool operator==(const Approx& lhs, double rhs) { return operator==(rhs, lhs); }
bool operator!=(double lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
bool operator!=(const Approx& lhs, double rhs) { return !operator==(rhs, lhs); }
bool operator<=(double lhs, const Approx& rhs) { return lhs < rhs.m_value || lhs == rhs; }
bool operator<=(const Approx& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; }
bool operator>=(double lhs, const Approx& rhs) { return lhs > rhs.m_value || lhs == rhs; }
bool operator>=(const Approx& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; }
bool operator<(double lhs, const Approx& rhs) { return lhs < rhs.m_value && lhs != rhs; }
bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; }
bool operator>(double lhs, const Approx& rhs) { return lhs > rhs.m_value && lhs != rhs; }
bool operator>(const Approx& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; }

String toString(const Approx& in) {
    return String("Approx( ") + doctest::toString(in.m_value) + " )";
}
const ContextOptions* getContextOptions() { return DOCTEST_BRANCH_ON_DISABLED(nullptr, g_cs); }

} // namespace doctest

#ifdef DOCTEST_CONFIG_DISABLE
namespace doctest {
Context::Context(int, const char* const*) {}
Context::~Context() = default;
void Context::applyCommandLine(int, const char* const*) {}
void Context::addFilter(const char*, const char*) {}
void Context::clearFilters() {}
void Context::setOption(const char*, int) {}
void Context::setOption(const char*, const char*) {}
bool Context::shouldExit() { return false; }
void Context::setAsDefaultForAssertsOutOfTestCases() {}
void Context::setAssertHandler(detail::assert_handler) {}
int  Context::run() { return 0; }

IReporter::~IReporter() = default;

int                         IReporter::get_num_active_contexts() { return 0; }
const IContextScope* const* IReporter::get_active_contexts() { return nullptr; }
int                         IReporter::get_num_stringified_contexts() { return 0; }
const String*               IReporter::get_stringified_contexts() { return nullptr; }

int registerReporter(const char*, int, IReporter*) { return 0; }

} // namespace doctest
#else // DOCTEST_CONFIG_DISABLE

#if !defined(DOCTEST_CONFIG_COLORS_NONE)
#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI)
#ifdef DOCTEST_PLATFORM_WINDOWS
#define DOCTEST_CONFIG_COLORS_WINDOWS
#else // linux
#define DOCTEST_CONFIG_COLORS_ANSI
#endif // platform
#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI
#endif // DOCTEST_CONFIG_COLORS_NONE

namespace doctest_detail_test_suite_ns {
// holds the current test suite
doctest::detail::TestSuite& getCurrentTestSuite() {
    static doctest::detail::TestSuite data;
    return data;
}
} // namespace doctest_detail_test_suite_ns

namespace doctest {
namespace {
    // the int (priority) is part of the key for automatic sorting - sadly one can register a
    // reporter with a duplicate name and a different priority but hopefully that won't happen often :|
    typedef std::map<std::pair<int, String>, reporterCreatorFunc> reporterMap;

    reporterMap& getReporters() {
        static reporterMap data;
        return data;
    }
    reporterMap& getListeners() {
        static reporterMap data;
        return data;
    }
} // namespace
namespace detail {
#define DOCTEST_ITERATE_THROUGH_REPORTERS(function, ...)                                           \
    for(auto& curr_rep : g_cs->reporters_currently_used)                                           \
    curr_rep->function(__VA_ARGS__)

    bool checkIfShouldThrow(assertType::Enum at) {
        if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
            return true;

        if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
           && getContextOptions()->abort_after > 0 &&
           (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
                   getContextOptions()->abort_after)
            return true;

        return false;
    }

#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
    DOCTEST_NORETURN void throwException() {
        g_cs->shouldLogCurrentException = false;
        throw TestFailureException();
    } // NOLINT(cert-err60-cpp)
#else // DOCTEST_CONFIG_NO_EXCEPTIONS
    void throwException() {}
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
} // namespace detail

namespace {
    using namespace detail;
    // matching of a string against a wildcard mask (case sensitivity configurable) taken from
    // https://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing
    int wildcmp(const char* str, const char* wild, bool caseSensitive) {
        const char* cp = nullptr;
        const char* mp = nullptr;

        while((*str) && (*wild != '*')) {
            if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) &&
               (*wild != '?')) {
                return 0;
            }
            wild++;
            str++;
        }

        while(*str) {
            if(*wild == '*') {
                if(!*++wild) {
                    return 1;
                }
                mp = wild;
                cp = str + 1;
            } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) ||
                      (*wild == '?')) {
                wild++;
                str++;
            } else {
                wild = mp;   //!OCLINT parameter reassignment
                str  = cp++; //!OCLINT parameter reassignment
            }
        }

        while(*wild == '*') {
            wild++;
        }
        return !*wild;
    }

    //// C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html
    //unsigned hashStr(unsigned const char* str) {
    //    unsigned long hash = 5381;
    //    char          c;
    //    while((c = *str++))
    //        hash = ((hash << 5) + hash) + c; // hash * 33 + c
    //    return hash;
    //}

    // checks if the name matches any of the filters (and can be configured what to do when empty)
    bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
                    bool caseSensitive) {
        if(filters.empty() && matchEmpty)
            return true;
        for(auto& curr : filters)
            if(wildcmp(name, curr.c_str(), caseSensitive))
                return true;
        return false;
    }
} // namespace
namespace detail {

    Subcase::Subcase(const char* name, const char* file, int line)
            : m_signature({name, file, line}) {
        ContextState* s = g_cs;

        // check subcase filters
        if(s->subcasesStack.size() < size_t(s->subcase_filter_levels)) {
            if(!matchesAny(m_signature.m_name, s->filters[6], true, s->case_sensitive))
                return;
            if(matchesAny(m_signature.m_name, s->filters[7], false, s->case_sensitive))
                return;
        }

        // if a Subcase on the same level has already been entered
        if(s->subcasesStack.size() < size_t(s->subcasesCurrentMaxLevel)) {
            s->should_reenter = true;
            return;
        }

        // push the current signature to the stack so we can check if the
        // current stack + the current new subcase have been traversed
        s->subcasesStack.push_back(m_signature);
        if(s->subcasesPassed.count(s->subcasesStack) != 0) {
            // pop - revert to previous stack since we've already passed this
            s->subcasesStack.pop_back();
            return;
        }

        s->subcasesCurrentMaxLevel = s->subcasesStack.size();
        m_entered = true;

        DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
    }

    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
    Subcase::~Subcase() {
        if(m_entered) {
            // only mark the subcase stack as passed if no subcases have been skipped
            if(g_cs->should_reenter == false)
                g_cs->subcasesPassed.insert(g_cs->subcasesStack);
            g_cs->subcasesStack.pop_back();

            if(std::uncaught_exception() && g_cs->shouldLogCurrentException) {
                DOCTEST_ITERATE_THROUGH_REPORTERS(
                        test_case_exception, {"exception thrown in subcase - will translate later "
                                              "when the whole test case has been exited (cannot "
                                              "translate while there is an active exception)",
                                              false});
                g_cs->shouldLogCurrentException = false;
            }
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
        }
    }
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
    DOCTEST_GCC_SUPPRESS_WARNING_POP
    DOCTEST_MSVC_SUPPRESS_WARNING_POP

    Subcase::operator bool() const { return m_entered; }

    Result::Result(bool passed, const String& decomposition)
            : m_passed(passed)
            , m_decomp(decomposition) {}

    ExpressionDecomposer::ExpressionDecomposer(assertType::Enum at)
            : m_at(at) {}

    TestSuite& TestSuite::operator*(const char* in) {
        m_test_suite = in;
        // clear state
        m_description       = nullptr;
        m_skip              = false;
        m_may_fail          = false;
        m_should_fail       = false;
        m_expected_failures = 0;
        m_timeout           = 0;
        return *this;
    }

    TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
                       const char* type, int template_id) {
        m_file              = file;
        m_line              = line;
        m_name              = nullptr; // will be later overridden in operator*
        m_test_suite        = test_suite.m_test_suite;
        m_description       = test_suite.m_description;
        m_skip              = test_suite.m_skip;
        m_may_fail          = test_suite.m_may_fail;
        m_should_fail       = test_suite.m_should_fail;
        m_expected_failures = test_suite.m_expected_failures;
        m_timeout           = test_suite.m_timeout;

        m_test        = test;
        m_type        = type;
        m_template_id = template_id;
    }

    TestCase::TestCase(const TestCase& other)
            : TestCaseData() {
        *this = other;
    }

    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
    DOCTEST_MSVC_SUPPRESS_WARNING(26437)           // Do not slice
    TestCase& TestCase::operator=(const TestCase& other) {
        static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other);

        m_test        = other.m_test;
        m_type        = other.m_type;
        m_template_id = other.m_template_id;
        m_full_name   = other.m_full_name;

        if(m_template_id != -1)
            m_name = m_full_name.c_str();
        return *this;
    }
    DOCTEST_MSVC_SUPPRESS_WARNING_POP

    TestCase& TestCase::operator*(const char* in) {
        m_name = in;
        // make a new name with an appended type for templated test case
        if(m_template_id != -1) {
            m_full_name = String(m_name) + m_type;
            // redirect the name to point to the newly constructed full name
            m_name = m_full_name.c_str();
        }
        return *this;
    }

    bool TestCase::operator<(const TestCase& other) const {
        if(m_line != other.m_line)
            return m_line < other.m_line;
        const int file_cmp = std::strcmp(m_file, other.m_file);
        if(file_cmp != 0)
            return file_cmp < 0;
        return m_template_id < other.m_template_id;
    }
} // namespace detail
namespace {
    using namespace detail;
    // for sorting tests by file/line
    bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
#if DOCTEST_MSVC
        // this is needed because MSVC gives different case for drive letters
        // for __FILE__ when evaluated in a header and a source file
        const int res = stricmp(lhs->m_file, rhs->m_file);
#else  // MSVC
        const int res = std::strcmp(lhs->m_file, rhs->m_file);
#endif // MSVC
        if(res != 0)
            return res < 0;
        if(lhs->m_line != rhs->m_line)
            return lhs->m_line < rhs->m_line;
        return lhs->m_template_id < rhs->m_template_id;
    }

    // for sorting tests by suite/file/line
    bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
        if(res != 0)
            return res < 0;
        return fileOrderComparator(lhs, rhs);
    }

    // for sorting tests by name/suite/file/line
    bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_name, rhs->m_name);
        if(res != 0)
            return res < 0;
        return suiteOrderComparator(lhs, rhs);
    }

    // all the registered tests
    std::set<TestCase>& getRegisteredTests() {
        static std::set<TestCase> data;
        return data;
    }

#ifdef DOCTEST_CONFIG_COLORS_WINDOWS
    HANDLE g_stdoutHandle;
    WORD   g_origFgAttrs;
    WORD   g_origBgAttrs;
    bool   g_attrsInitted = false;

    int colors_init() {
        if(!g_attrsInitted) {
            g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
            g_attrsInitted = true;
            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
            GetConsoleScreenBufferInfo(g_stdoutHandle, &csbiInfo);
            g_origFgAttrs = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED |
                                                     BACKGROUND_BLUE | BACKGROUND_INTENSITY);
            g_origBgAttrs = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED |
                                                     FOREGROUND_BLUE | FOREGROUND_INTENSITY);
        }
        return 0;
    }

    int dumy_init_console_colors = colors_init();
#endif // DOCTEST_CONFIG_COLORS_WINDOWS

    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
    void color_to_stream(std::ostream& s, Color::Enum code) {
        ((void)s);    // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS
        ((void)code); // for DOCTEST_CONFIG_COLORS_NONE
#ifdef DOCTEST_CONFIG_COLORS_ANSI
        if(g_no_colors ||
           (isatty(STDOUT_FILENO) == false && getContextOptions()->force_colors == false))
            return;

        auto col = "";
        // clang-format off
            switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement
                case Color::Red:         col = "[0;31m"; break;
                case Color::Green:       col = "[0;32m"; break;
                case Color::Blue:        col = "[0;34m"; break;
                case Color::Cyan:        col = "[0;36m"; break;
                case Color::Yellow:      col = "[0;33m"; break;
                case Color::Grey:        col = "[1;30m"; break;
                case Color::LightGrey:   col = "[0;37m"; break;
                case Color::BrightRed:   col = "[1;31m"; break;
                case Color::BrightGreen: col = "[1;32m"; break;
                case Color::BrightWhite: col = "[1;37m"; break;
                case Color::Bright: // invalid
                case Color::None:
                case Color::White:
                default:                 col = "[0m";
            }
        // clang-format on
        s << "\033" << col;
#endif // DOCTEST_CONFIG_COLORS_ANSI

#ifdef DOCTEST_CONFIG_COLORS_WINDOWS
        if(g_no_colors ||
           (isatty(fileno(stdout)) == false && getContextOptions()->force_colors == false))
            return;

#define DOCTEST_SET_ATTR(x) SetConsoleTextAttribute(g_stdoutHandle, x | g_origBgAttrs)

        // clang-format off
        switch (code) {
            case Color::White:       DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
            case Color::Red:         DOCTEST_SET_ATTR(FOREGROUND_RED);                                      break;
            case Color::Green:       DOCTEST_SET_ATTR(FOREGROUND_GREEN);                                    break;
            case Color::Blue:        DOCTEST_SET_ATTR(FOREGROUND_BLUE);                                     break;
            case Color::Cyan:        DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN);                  break;
            case Color::Yellow:      DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN);                   break;
            case Color::Grey:        DOCTEST_SET_ATTR(0);                                                   break;
            case Color::LightGrey:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY);                                break;
            case Color::BrightRed:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED);               break;
            case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN);             break;
            case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
            case Color::None:
            case Color::Bright: // invalid
            default:                 DOCTEST_SET_ATTR(g_origFgAttrs);
        }
            // clang-format on
#endif // DOCTEST_CONFIG_COLORS_WINDOWS
    }
    DOCTEST_CLANG_SUPPRESS_WARNING_POP

    std::vector<const IExceptionTranslator*>& getExceptionTranslators() {
        static std::vector<const IExceptionTranslator*> data;
        return data;
    }

    String translateActiveException() {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
        String res;
        auto&  translators = getExceptionTranslators();
        for(auto& curr : translators)
            if(curr->translate(res))
                return res;
        // clang-format off
        DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
        try {
            throw;
        } catch(std::exception& ex) {
            return ex.what();
        } catch(std::string& msg) {
            return msg.c_str();
        } catch(const char* msg) {
            return msg;
        } catch(...) {
            return "unknown exception";
        }
        DOCTEST_GCC_SUPPRESS_WARNING_POP
// clang-format on
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
        return "";
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
    }
} // namespace

namespace detail {
    // used by the macros for registering tests
    int regTest(const TestCase& tc) {
        getRegisteredTests().insert(tc);
        return 0;
    }

    // sets the current test suite
    int setTestSuite(const TestSuite& ts) {
        doctest_detail_test_suite_ns::getCurrentTestSuite() = ts;
        return 0;
    }

#ifdef DOCTEST_IS_DEBUGGER_ACTIVE
    bool isDebuggerActive() { return DOCTEST_IS_DEBUGGER_ACTIVE(); }
#else // DOCTEST_IS_DEBUGGER_ACTIVE
#ifdef DOCTEST_PLATFORM_MAC
    // The following function is taken directly from the following technical note:
    // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
    // Returns true if the current process is being debugged (either
    // running under the debugger or has a debugger attached post facto).
    bool isDebuggerActive() {
        int        mib[4];
        kinfo_proc info;
        size_t     size;
        // Initialize the flags so that, if sysctl fails for some bizarre
        // reason, we get a predictable result.
        info.kp_proc.p_flag = 0;
        // Initialize mib, which tells sysctl the info we want, in this case
        // we're looking for information about a specific process ID.
        mib[0] = CTL_KERN;
        mib[1] = KERN_PROC;
        mib[2] = KERN_PROC_PID;
        mib[3] = getpid();
        // Call sysctl.
        size = sizeof(info);
        if(sysctl(mib, DOCTEST_COUNTOF(mib), &info, &size, 0, 0) != 0) {
            std::cerr << "\nCall to sysctl failed - unable to determine if debugger is active **\n";
            return false;
        }
        // We're being debugged if the P_TRACED flag is set.
        return ((info.kp_proc.p_flag & P_TRACED) != 0);
    }
#elif DOCTEST_MSVC || defined(__MINGW32__)
    bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; }
#else
    bool isDebuggerActive() { return false; }
#endif // Platform
#endif // DOCTEST_IS_DEBUGGER_ACTIVE

    void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
        if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
           getExceptionTranslators().end())
            getExceptionTranslators().push_back(et);
    }

#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    void toStream(std::ostream* s, char* in) { *s << in; }
    void toStream(std::ostream* s, const char* in) { *s << in; }
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
    void toStream(std::ostream* s, bool in) { *s << std::boolalpha << in << std::noboolalpha; }
    void toStream(std::ostream* s, float in) { *s << in; }
    void toStream(std::ostream* s, double in) { *s << in; }
    void toStream(std::ostream* s, double long in) { *s << in; }

    void toStream(std::ostream* s, char in) { *s << in; }
    void toStream(std::ostream* s, char signed in) { *s << in; }
    void toStream(std::ostream* s, char unsigned in) { *s << in; }
    void toStream(std::ostream* s, int short in) { *s << in; }
    void toStream(std::ostream* s, int short unsigned in) { *s << in; }
    void toStream(std::ostream* s, int in) { *s << in; }
    void toStream(std::ostream* s, int unsigned in) { *s << in; }
    void toStream(std::ostream* s, int long in) { *s << in; }
    void toStream(std::ostream* s, int long unsigned in) { *s << in; }
    void toStream(std::ostream* s, int long long in) { *s << in; }
    void toStream(std::ostream* s, int long long unsigned in) { *s << in; }

    DOCTEST_THREAD_LOCAL std::vector<IContextScope*> g_infoContexts; // for logging with INFO()

    ContextScopeBase::ContextScopeBase() {
        g_infoContexts.push_back(this);
    }

    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
    // destroy cannot be inlined into the destructor because that would mean calling stringify after
    // ContextScope has been destroyed (base class destructors run after derived class destructors).
    // Instead, ContextScope calls this method directly from its destructor.
    void ContextScopeBase::destroy() {
        if(std::uncaught_exception()) {
            std::ostringstream s;
            this->stringify(&s);
            g_cs->stringifiedContexts.push_back(s.str().c_str());
        }
        g_infoContexts.pop_back();
    }
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
    DOCTEST_GCC_SUPPRESS_WARNING_POP
    DOCTEST_MSVC_SUPPRESS_WARNING_POP

} // namespace detail
namespace {
    using namespace detail;

    std::ostream& file_line_to_stream(std::ostream& s, const char* file, int line,
                                      const char* tail = "") {
        const auto opt = getContextOptions();
        s << Color::LightGrey << skipPathFromFilename(file) << (opt->gnu_file_line ? ":" : "(")
          << (opt->no_line_numbers ? 0 : line) // 0 or the real num depending on the option
          << (opt->gnu_file_line ? ":" : "):") << tail;
        return s;
    }

#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
    struct FatalConditionHandler
    {
        void reset() {}
    };
#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH

    void reportFatal(const std::string&);

#ifdef DOCTEST_PLATFORM_WINDOWS

    struct SignalDefs
    {
        DWORD id;
        const char* name;
    };
    // There is no 1-1 mapping between signals and windows exceptions.
    // Windows can easily distinguish between SO and SigSegV,
    // but SigInt, SigTerm, etc are handled differently.
    SignalDefs signalDefs[] = {
            {EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal"},
            {EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow"},
            {EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal"},
            {EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error"},
    };

    struct FatalConditionHandler
    {
        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
            for(size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
                    reportFatal(signalDefs[i].name);
                }
            }
            // If its not an exception we care about, pass it along.
            // This stops us from eating debugger breaks etc.
            return EXCEPTION_CONTINUE_SEARCH;
        }

        FatalConditionHandler() {
            isSet = true;
            // 32k seems enough for doctest to handle stack overflow,
            // but the value was found experimentally, so there is no strong guarantee
            guaranteeSize = 32 * 1024;
            exceptionHandlerHandle = nullptr;
            // Register as first handler in current chain
            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
            // Pass in guarantee size to be filled
            SetThreadStackGuarantee(&guaranteeSize);
        }

        static void reset() {
            if(isSet) {
                // Unregister handler and restore the old guarantee
                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
                SetThreadStackGuarantee(&guaranteeSize);
                exceptionHandlerHandle = nullptr;
                isSet = false;
            }
        }

        ~FatalConditionHandler() { reset(); }

    private:
        static bool isSet;
        static ULONG guaranteeSize;
        static PVOID exceptionHandlerHandle;
    };

    bool FatalConditionHandler::isSet = false;
    ULONG FatalConditionHandler::guaranteeSize = 0;
    PVOID FatalConditionHandler::exceptionHandlerHandle = nullptr;

#else // DOCTEST_PLATFORM_WINDOWS

    struct SignalDefs
    {
        int         id;
        const char* name;
    };
    SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"},
                               {SIGILL, "SIGILL - Illegal instruction signal"},
                               {SIGFPE, "SIGFPE - Floating point error signal"},
                               {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
                               {SIGTERM, "SIGTERM - Termination request signal"},
                               {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};

    struct FatalConditionHandler
    {
        static bool             isSet;
        static struct sigaction oldSigActions[DOCTEST_COUNTOF(signalDefs)];
        static stack_t          oldSigStack;
        static char             altStackMem[4 * SIGSTKSZ];

        static void handleSignal(int sig) {
            const char* name = "<unknown signal>";
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                SignalDefs& def = signalDefs[i];
                if(sig == def.id) {
                    name = def.name;
                    break;
                }
            }
            reset();
            reportFatal(name);
            raise(sig);
        }

        FatalConditionHandler() {
            isSet = true;
            stack_t sigStack;
            sigStack.ss_sp    = altStackMem;
            sigStack.ss_size  = sizeof(altStackMem);
            sigStack.ss_flags = 0;
            sigaltstack(&sigStack, &oldSigStack);
            struct sigaction sa = {};
            sa.sa_handler       = handleSignal; // NOLINT
            sa.sa_flags         = SA_ONSTACK;
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
            }
        }

        ~FatalConditionHandler() { reset(); }
        static void reset() {
            if(isSet) {
                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
                for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                    sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
                }
                // Return the old stack
                sigaltstack(&oldSigStack, nullptr);
                isSet = false;
            }
        }
    };

    bool             FatalConditionHandler::isSet                                      = false;
    struct sigaction FatalConditionHandler::oldSigActions[DOCTEST_COUNTOF(signalDefs)] = {};
    stack_t          FatalConditionHandler::oldSigStack                                = {};
    char             FatalConditionHandler::altStackMem[]                              = {};

#endif // DOCTEST_PLATFORM_WINDOWS
#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH

} // namespace

namespace {
    using namespace detail;

#ifdef DOCTEST_PLATFORM_WINDOWS
#define DOCTEST_OUTPUT_DEBUG_STRING(text) ::OutputDebugStringA(text)
#else
    // TODO: integration with XCode and other IDEs
#define DOCTEST_OUTPUT_DEBUG_STRING(text) // NOLINT(clang-diagnostic-unused-macros)
#endif // Platform

    void addAssert(assertType::Enum at) {
        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
            g_cs->numAssertsCurrentTest_atomic++;
    }

    void addFailedAssert(assertType::Enum at) {
        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
            g_cs->numAssertsFailedCurrentTest_atomic++;
    }

#if defined(DOCTEST_CONFIG_POSIX_SIGNALS) || defined(DOCTEST_CONFIG_WINDOWS_SEH)
    void reportFatal(const std::string& message) {
        g_cs->failure_flags |= TestCaseFailureReason::Crash;

        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, {message.c_str(), true});

        while(g_cs->subcasesStack.size()) {
            g_cs->subcasesStack.pop_back();
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
        }

        g_cs->finalizeTestCaseData();

        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);

        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
    }
#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
} // namespace
namespace detail {

    ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
                                 const char* exception_type, const char* exception_string) {
        m_test_case        = g_cs->currentTest;
        m_at               = at;
        m_file             = file;
        m_line             = line;
        m_expr             = expr;
        m_failed           = true;
        m_threw            = false;
        m_threw_as         = false;
        m_exception_type   = exception_type;
        m_exception_string = exception_string;
#if DOCTEST_MSVC
        if(m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
            ++m_expr;
#endif // MSVC
    }

    void ResultBuilder::setResult(const Result& res) {
        m_decomp = res.m_decomp;
        m_failed = !res.m_passed;
    }

    void ResultBuilder::translateException() {
        m_threw     = true;
        m_exception = translateActiveException();
    }

    bool ResultBuilder::log() {
        if(m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
            m_failed = !m_threw;
        } else if((m_at & assertType::is_throws_as) && (m_at & assertType::is_throws_with)) { //!OCLINT
            m_failed = !m_threw_as || (m_exception != m_exception_string);
        } else if(m_at & assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
            m_failed = !m_threw_as;
        } else if(m_at & assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
            m_failed = m_exception != m_exception_string;
        } else if(m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
            m_failed = m_threw;
        }

        if(m_exception.size())
            m_exception = String("\"") + m_exception + "\"";

        if(is_running_in_test) {
            addAssert(m_at);
            DOCTEST_ITERATE_THROUGH_REPORTERS(log_assert, *this);

            if(m_failed)
                addFailedAssert(m_at);
        } else if(m_failed) {
            failed_out_of_a_testing_context(*this);
        }

        return m_failed && isDebuggerActive() &&
               !getContextOptions()->no_breaks; // break into debugger
    }

    void ResultBuilder::react() const {
        if(m_failed && checkIfShouldThrow(m_at))
            throwException();
    }

    void failed_out_of_a_testing_context(const AssertData& ad) {
        if(g_cs->ah)
            g_cs->ah(ad);
        else
            std::abort();
    }

    void decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
                       Result result) {
        bool failed = !result.m_passed;

        // ###################################################################################
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
        // ###################################################################################
        DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
        DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
    }

    MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
        m_stream   = getTlsOss();
        m_file     = file;
        m_line     = line;
        m_severity = severity;
    }

    IExceptionTranslator::IExceptionTranslator()  = default;
    IExceptionTranslator::~IExceptionTranslator() = default;

    bool MessageBuilder::log() {
        m_string = getTlsOssResult();
        DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);

        const bool isWarn = m_severity & assertType::is_warn;

        // warn is just a message in this context so we don't treat it as an assert
        if(!isWarn) {
            addAssert(m_severity);
            addFailedAssert(m_severity);
        }

        return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn; // break
    }

    void MessageBuilder::react() {
        if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional
            throwException();
    }

    MessageBuilder::~MessageBuilder() = default;
} // namespace detail
namespace {
    using namespace detail;

    template <typename Ex>
    DOCTEST_NORETURN void throw_exception(Ex const& e) {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
        throw e;
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
        std::cerr << "doctest will terminate because it needed to throw an exception.\n"
                  << "The message was: " << e.what() << '\n';
        std::terminate();
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
    }

#define DOCTEST_INTERNAL_ERROR(msg)                                                                \
    throw_exception(std::logic_error(                                                              \
            __FILE__ ":" DOCTEST_TOSTR(__LINE__) ": Internal doctest error: " msg))

    // clang-format off

// =================================================================================================
// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
// =================================================================================================

    class XmlEncode {
    public:
        enum ForWhat { ForTextNodes, ForAttributes };

        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );

        void encodeTo( std::ostream& os ) const;

        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );

    private:
        std::string m_str;
        ForWhat m_forWhat;
    };

    class XmlWriter {
    public:

        class ScopedElement {
        public:
            ScopedElement( XmlWriter* writer );

            ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT;
            ScopedElement& operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT;

            ~ScopedElement();

            ScopedElement& writeText( std::string const& text, bool indent = true );

            template<typename T>
            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
                m_writer->writeAttribute( name, attribute );
                return *this;
            }

        private:
            mutable XmlWriter* m_writer = nullptr;
        };

        XmlWriter( std::ostream& os = std::cout );
        ~XmlWriter();

        XmlWriter( XmlWriter const& ) = delete;
        XmlWriter& operator=( XmlWriter const& ) = delete;

        XmlWriter& startElement( std::string const& name );

        ScopedElement scopedElement( std::string const& name );

        XmlWriter& endElement();

        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );

        XmlWriter& writeAttribute( std::string const& name, const char* attribute );

        XmlWriter& writeAttribute( std::string const& name, bool attribute );

        template<typename T>
        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
        std::stringstream rss;
            rss << attribute;
            return writeAttribute( name, rss.str() );
        }

        XmlWriter& writeText( std::string const& text, bool indent = true );

        //XmlWriter& writeComment( std::string const& text );

        //void writeStylesheetRef( std::string const& url );

        //XmlWriter& writeBlankLine();

        void ensureTagClosed();

    private:

        void writeDeclaration();

        void newlineIfNecessary();

        bool m_tagIsOpen = false;
        bool m_needsNewline = false;
        std::vector<std::string> m_tags;
        std::string m_indent;
        std::ostream& m_os;
    };

// =================================================================================================
// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
// =================================================================================================

using uchar = unsigned char;

namespace {

    size_t trailingBytes(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return 2;
        }
        if ((c & 0xF0) == 0xE0) {
            return 3;
        }
        if ((c & 0xF8) == 0xF0) {
            return 4;
        }
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

    uint32_t headerValue(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return c & 0x1F;
        }
        if ((c & 0xF0) == 0xE0) {
            return c & 0x0F;
        }
        if ((c & 0xF8) == 0xF0) {
            return c & 0x07;
        }
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

    void hexEscapeChar(std::ostream& os, unsigned char c) {
        std::ios_base::fmtflags f(os.flags());
        os << "\\x"
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        os.flags(f);
    }

} // anonymous namespace

    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
    :   m_str( str ),
        m_forWhat( forWhat )
    {}

    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)

        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
            uchar c = m_str[idx];
            switch (c) {
            case '<':   os << "&lt;"; break;
            case '&':   os << "&amp;"; break;

            case '>':
                // See: http://www.w3.org/TR/xml/#syntax
                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
                    os << "&gt;";
                else
                    os << c;
                break;

            case '\"':
                if (m_forWhat == ForAttributes)
                    os << "&quot;";
                else
                    os << c;
                break;

            default:
                // Check for control characters and invalid utf-8

                // Escape control characters in standard ascii
                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
                    hexEscapeChar(os, c);
                    break;
                }

                // Plain ASCII: Write it to stream
                if (c < 0x7F) {
                    os << c;
                    break;
                }

                // UTF-8 territory
                // Check if the encoding is valid and if it is not, hex escape bytes.
                // Important: We do not check the exact decoded values for validity, only the encoding format
                // First check that this bytes is a valid lead byte:
                // This means that it is not encoded as 1111 1XXX
                // Or as 10XX XXXX
                if (c <  0xC0 ||
                    c >= 0xF8) {
                    hexEscapeChar(os, c);
                    break;
                }

                auto encBytes = trailingBytes(c);
                // Are there enough bytes left to avoid accessing out-of-bounds memory?
                if (idx + encBytes - 1 >= m_str.size()) {
                    hexEscapeChar(os, c);
                    break;
                }
                // The header is valid, check data
                // The next encBytes bytes must together be a valid utf-8
                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
                bool valid = true;
                uint32_t value = headerValue(c);
                for (std::size_t n = 1; n < encBytes; ++n) {
                    uchar nc = m_str[idx + n];
                    valid &= ((nc & 0xC0) == 0x80);
                    value = (value << 6) | (nc & 0x3F);
                }

                if (
                    // Wrong bit pattern of following bytes
                    (!valid) ||
                    // Overlong encodings
                    (value < 0x80) ||
                    (                 value < 0x800   && encBytes > 2) || // removed "0x80 <= value &&" because redundant
                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
                    // Encoded value out of range
                    (value >= 0x110000)
                    ) {
                    hexEscapeChar(os, c);
                    break;
                }

                // If we got here, this is in fact a valid(ish) utf-8 sequence
                for (std::size_t n = 0; n < encBytes; ++n) {
                    os << m_str[idx + n];
                }
                idx += encBytes - 1;
                break;
            }
        }
    }

    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
        xmlEncode.encodeTo( os );
        return os;
    }

    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
    :   m_writer( writer )
    {}

    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT
    :   m_writer( other.m_writer ){
        other.m_writer = nullptr;
    }
    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT {
        if ( m_writer ) {
            m_writer->endElement();
        }
        m_writer = other.m_writer;
        other.m_writer = nullptr;
        return *this;
    }


    XmlWriter::ScopedElement::~ScopedElement() {
        if( m_writer )
            m_writer->endElement();
    }

    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
        m_writer->writeText( text, indent );
        return *this;
    }

    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
    {
        writeDeclaration();
    }

    XmlWriter::~XmlWriter() {
        while( !m_tags.empty() )
            endElement();
    }

    XmlWriter& XmlWriter::startElement( std::string const& name ) {
        ensureTagClosed();
        newlineIfNecessary();
        m_os << m_indent << '<' << name;
        m_tags.push_back( name );
        m_indent += "  ";
        m_tagIsOpen = true;
        return *this;
    }

    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
        ScopedElement scoped( this );
        startElement( name );
        return scoped;
    }

    XmlWriter& XmlWriter::endElement() {
        newlineIfNecessary();
        m_indent = m_indent.substr( 0, m_indent.size()-2 );
        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        }
        else {
            m_os << m_indent << "</" << m_tags.back() << ">";
        }
        m_os << std::endl;
        m_tags.pop_back();
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
        if( !name.empty() && !attribute.empty() )
            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) {
        if( !name.empty() && attribute && attribute[0] != '\0' )
            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
        return *this;
    }

    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
        return *this;
    }

    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
        if( !text.empty() ){
            bool tagWasOpen = m_tagIsOpen;
            ensureTagClosed();
            if( tagWasOpen && indent )
                m_os << m_indent;
            m_os << XmlEncode( text );
            m_needsNewline = true;
        }
        return *this;
    }

    //XmlWriter& XmlWriter::writeComment( std::string const& text ) {
    //    ensureTagClosed();
    //    m_os << m_indent << "<!--" << text << "-->";
    //    m_needsNewline = true;
    //    return *this;
    //}

    //void XmlWriter::writeStylesheetRef( std::string const& url ) {
    //    m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
    //}

    //XmlWriter& XmlWriter::writeBlankLine() {
    //    ensureTagClosed();
    //    m_os << '\n';
    //    return *this;
    //}

    void XmlWriter::ensureTagClosed() {
        if( m_tagIsOpen ) {
            m_os << ">" << std::endl;
            m_tagIsOpen = false;
        }
    }

    void XmlWriter::writeDeclaration() {
        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
    }

    void XmlWriter::newlineIfNecessary() {
        if( m_needsNewline ) {
            m_os << std::endl;
            m_needsNewline = false;
        }
    }

// =================================================================================================
// End of copy-pasted code from Catch
// =================================================================================================

    // clang-format on

    struct XmlReporter : public IReporter
    {
        XmlWriter  xml;
        std::mutex mutex;

        // caching pointers/references to objects of these types - safe to do
        const ContextOptions& opt;
        const TestCaseData*   tc = nullptr;

        XmlReporter(const ContextOptions& co)
                : xml(*co.cout)
                , opt(co) {}

        void log_contexts() {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto              contexts = get_active_contexts();
                std::stringstream ss;
                for(int i = 0; i < num_contexts; ++i) {
                    contexts[i]->stringify(&ss);
                    xml.scopedElement("Info").writeText(ss.str());
                    ss.str("");
                }
            }
        }

        unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }

        void test_case_start_impl(const TestCaseData& in) {
            bool open_ts_tag = false;
            if(tc != nullptr) { // we have already opened a test suite
                if(strcmp(tc->m_test_suite, in.m_test_suite) != 0) {
                    xml.endElement();
                    open_ts_tag = true;
                }
            }
            else {
                open_ts_tag = true; // first test case ==> first test suite
            }

            if(open_ts_tag) {
                xml.startElement("TestSuite");
                xml.writeAttribute("name", in.m_test_suite);
            }

            tc = &in;
            xml.startElement("TestCase")
                    .writeAttribute("name", in.m_name)
                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
                    .writeAttribute("line", line(in.m_line))
                    .writeAttribute("description", in.m_description);

            if(Approx(in.m_timeout) != 0)
                xml.writeAttribute("timeout", in.m_timeout);
            if(in.m_may_fail)
                xml.writeAttribute("may_fail", true);
            if(in.m_should_fail)
                xml.writeAttribute("should_fail", true);
        }

        // =========================================================================================
        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
        // =========================================================================================

        void report_query(const QueryData& in) override {
            test_run_start();
            if(opt.list_reporters) {
                for(auto& curr : getListeners())
                    xml.scopedElement("Listener")
                            .writeAttribute("priority", curr.first.first)
                            .writeAttribute("name", curr.first.second);
                for(auto& curr : getReporters())
                    xml.scopedElement("Reporter")
                            .writeAttribute("priority", curr.first.first)
                            .writeAttribute("name", curr.first.second);
            } else if(opt.count || opt.list_test_cases) {
                for(unsigned i = 0; i < in.num_data; ++i)
                    xml.scopedElement("TestCase").writeAttribute("name", in.data[i]);
                xml.scopedElement("OverallResultsTestCases")
                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
            } else if(opt.list_test_suites) {
                for(unsigned i = 0; i < in.num_data; ++i)
                    xml.scopedElement("TestSuite").writeAttribute("name", in.data[i]);
                xml.scopedElement("OverallResultsTestCases")
                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
                xml.scopedElement("OverallResultsTestSuites")
                        .writeAttribute("unskipped", in.run_stats->numTestSuitesPassingFilters);
            }
            xml.endElement();
        }

        void test_run_start() override {
            // remove .exe extension - mainly to have the same output on UNIX and Windows
            std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
#ifdef DOCTEST_PLATFORM_WINDOWS
            if(binary_name.rfind(".exe") != std::string::npos)
                binary_name = binary_name.substr(0, binary_name.length() - 4);
#endif // DOCTEST_PLATFORM_WINDOWS

            xml.startElement("doctest").writeAttribute("binary", binary_name);
            if(opt.no_version == false)
                xml.writeAttribute("version", DOCTEST_VERSION_STR);

            // only the consequential ones (TODO: filters)
            xml.scopedElement("Options")
                    .writeAttribute("order_by", opt.order_by.c_str())
                    .writeAttribute("rand_seed", opt.rand_seed)
                    .writeAttribute("first", opt.first)
                    .writeAttribute("last", opt.last)
                    .writeAttribute("abort_after", opt.abort_after)
                    .writeAttribute("subcase_filter_levels", opt.subcase_filter_levels)
                    .writeAttribute("case_sensitive", opt.case_sensitive)
                    .writeAttribute("no_throw", opt.no_throw)
                    .writeAttribute("no_skip", opt.no_skip);
        }

        void test_run_end(const TestRunStats& p) override {
            if(tc) // the TestSuite tag - only if there has been at least 1 test case
                xml.endElement();

            xml.scopedElement("OverallResultsAsserts")
                    .writeAttribute("successes", p.numAsserts - p.numAssertsFailed)
                    .writeAttribute("failures", p.numAssertsFailed);

            xml.startElement("OverallResultsTestCases")
                    .writeAttribute("successes",
                                    p.numTestCasesPassingFilters - p.numTestCasesFailed)
                    .writeAttribute("failures", p.numTestCasesFailed);
            if(opt.no_skipped_summary == false)
                xml.writeAttribute("skipped", p.numTestCases - p.numTestCasesPassingFilters);
            xml.endElement();

            xml.endElement();
        }

        void test_case_start(const TestCaseData& in) override {
            test_case_start_impl(in);
            xml.ensureTagClosed();
        }

        void test_case_reenter(const TestCaseData&) override {}

        void test_case_end(const CurrentTestCaseStats& st) override {
            xml.startElement("OverallResultsAsserts")
                    .writeAttribute("successes",
                                    st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
                    .writeAttribute("failures", st.numAssertsFailedCurrentTest);
            if(opt.duration)
                xml.writeAttribute("duration", st.seconds);
            if(tc->m_expected_failures)
                xml.writeAttribute("expected_failures", tc->m_expected_failures);
            xml.endElement();

            xml.endElement();
        }

        void test_case_exception(const TestCaseException& e) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.scopedElement("Exception")
                    .writeAttribute("crash", e.is_crash)
                    .writeText(e.error_string.c_str());
        }

        void subcase_start(const SubcaseSignature& in) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.startElement("SubCase")
                    .writeAttribute("name", in.m_name)
                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
                    .writeAttribute("line", line(in.m_line));
            xml.ensureTagClosed();
        }

        void subcase_end() override { xml.endElement(); }

        void log_assert(const AssertData& rb) override {
            if(!rb.m_failed && !opt.success)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            xml.startElement("Expression")
                    .writeAttribute("success", !rb.m_failed)
                    .writeAttribute("type", assertString(rb.m_at))
                    .writeAttribute("filename", skipPathFromFilename(rb.m_file))
                    .writeAttribute("line", line(rb.m_line));

            xml.scopedElement("Original").writeText(rb.m_expr);

            if(rb.m_threw)
                xml.scopedElement("Exception").writeText(rb.m_exception.c_str());

            if(rb.m_at & assertType::is_throws_as)
                xml.scopedElement("ExpectedException").writeText(rb.m_exception_type);
            if(rb.m_at & assertType::is_throws_with)
                xml.scopedElement("ExpectedExceptionString").writeText(rb.m_exception_string);
            if((rb.m_at & assertType::is_normal) && !rb.m_threw)
                xml.scopedElement("Expanded").writeText(rb.m_decomp.c_str());

            log_contexts();

            xml.endElement();
        }

        void log_message(const MessageData& mb) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.startElement("Message")
                    .writeAttribute("type", failureString(mb.m_severity))
                    .writeAttribute("filename", skipPathFromFilename(mb.m_file))
                    .writeAttribute("line", line(mb.m_line));

            xml.scopedElement("Text").writeText(mb.m_string.c_str());

            log_contexts();

            xml.endElement();
        }

        void test_case_skipped(const TestCaseData& in) override {
            if(opt.no_skipped_summary == false) {
                test_case_start_impl(in);
                xml.writeAttribute("skipped", "true");
                xml.endElement();
            }
        }
    };

    DOCTEST_REGISTER_REPORTER("xml", 0, XmlReporter);

    struct Whitespace
    {
        int nrSpaces;
        explicit Whitespace(int nr)
                : nrSpaces(nr) {}
    };

    std::ostream& operator<<(std::ostream& out, const Whitespace& ws) {
        if(ws.nrSpaces != 0)
            out << std::setw(ws.nrSpaces) << ' ';
        return out;
    }

    struct ConsoleReporter : public IReporter
    {
        std::ostream&                 s;
        bool                          hasLoggedCurrentTestStart;
        std::vector<SubcaseSignature> subcasesStack;
        std::mutex                    mutex;

        // caching pointers/references to objects of these types - safe to do
        const ContextOptions& opt;
        const TestCaseData*   tc;

        ConsoleReporter(const ContextOptions& co)
                : s(*co.cout)
                , opt(co) {}

        ConsoleReporter(const ContextOptions& co, std::ostream& ostr)
                : s(ostr)
                , opt(co) {}

        // =========================================================================================
        // WHAT FOLLOWS ARE HELPERS USED BY THE OVERRIDES OF THE VIRTUAL METHODS OF THE INTERFACE
        // =========================================================================================

        void separator_to_stream() {
            s << Color::Yellow
              << "==============================================================================="
                 "\n";
        }

        const char* getSuccessOrFailString(bool success, assertType::Enum at,
                                           const char* success_str) {
            if(success)
                return success_str;
            return failureString(at);
        }

        Color::Enum getSuccessOrFailColor(bool success, assertType::Enum at) {
            return success ? Color::BrightGreen :
                             (at & assertType::is_warn) ? Color::Yellow : Color::Red;
        }

        void successOrFailColoredStringToStream(bool success, assertType::Enum at,
                                                const char* success_str = "SUCCESS") {
            s << getSuccessOrFailColor(success, at)
              << getSuccessOrFailString(success, at, success_str) << ": ";
        }

        void log_contexts() {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto contexts = get_active_contexts();

                s << Color::None << "  logged: ";
                for(int i = 0; i < num_contexts; ++i) {
                    s << (i == 0 ? "" : "          ");
                    contexts[i]->stringify(&s);
                    s << "\n";
                }
            }

            s << "\n";
        }

        void logTestStart() {
            if(hasLoggedCurrentTestStart)
                return;

            separator_to_stream();
            file_line_to_stream(s, tc->m_file, tc->m_line, "\n");
            if(tc->m_description)
                s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description << "\n";
            if(tc->m_test_suite && tc->m_test_suite[0] != '\0')
                s << Color::Yellow << "TEST SUITE: " << Color::None << tc->m_test_suite << "\n";
            if(strncmp(tc->m_name, "  Scenario:", 11) != 0)
                s << Color::None << "TEST CASE:  ";
            s << Color::None << tc->m_name << "\n";

            for(auto& curr : subcasesStack)
                if(curr.m_name[0] != '\0')
                    s << "  " << curr.m_name << "\n";

            s << "\n";

            hasLoggedCurrentTestStart = true;
        }

        void printVersion() {
            if(opt.no_version == false)
                s << Color::Cyan << "[doctest] " << Color::None << "doctest version is \""
                  << DOCTEST_VERSION_STR << "\"\n";
        }

        void printIntro() {
            printVersion();
            s << Color::Cyan << "[doctest] " << Color::None
              << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n";
        }

        void printHelp() {
            int sizePrefixDisplay = static_cast<int>(strlen(DOCTEST_OPTIONS_PREFIX_DISPLAY));
            printVersion();
            // clang-format off
            s << Color::Cyan << "[doctest]\n" << Color::None;
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n";
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "filter  values: \"str1,str2,str3\" (comma separated strings)\n";
            s << Color::Cyan << "[doctest]\n" << Color::None;
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "filters use wildcards for matching strings\n";
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "something passes a filter if any of the strings in a filter matches\n";
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
            s << Color::Cyan << "[doctest]\n" << Color::None;
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"" DOCTEST_CONFIG_OPTIONS_PREFIX "\" PREFIX!!!\n";
#endif
            s << Color::Cyan << "[doctest]\n" << Color::None;
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "Query flags - the program quits after them. Available:\n\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "?,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "help, -" DOCTEST_OPTIONS_PREFIX_DISPLAY "h                      "
              << Whitespace(sizePrefixDisplay*0) <<  "prints this message\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "v,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "version                       "
              << Whitespace(sizePrefixDisplay*1) << "prints the version\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "c,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "count                         "
              << Whitespace(sizePrefixDisplay*1) << "prints the number of matching tests\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ltc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-cases               "
              << Whitespace(sizePrefixDisplay*1) << "lists all matching tests by name\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-suites              "
              << Whitespace(sizePrefixDisplay*1) << "lists all matching test suites\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-reporters                "
              << Whitespace(sizePrefixDisplay*1) << "lists all registered reporters\n\n";
            // ================================================================================== << 79
            s << Color::Cyan << "[doctest] " << Color::None;
            s << "The available <int>/<string> options/filters are:\n\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case=<filters>           "
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their name\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case-exclude=<filters>   "
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their name\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sf,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file=<filters>         "
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their file\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sfe, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file-exclude=<filters> "
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their file\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ts,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite=<filters>          "
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their test suite\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tse, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite-exclude=<filters>  "
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their test suite\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase=<filters>             "
              << Whitespace(sizePrefixDisplay*1) << "filters     subcases by their name\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-exclude=<filters>     "
              << Whitespace(sizePrefixDisplay*1) << "filters OUT subcases by their name\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "r,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "reporters=<filters>           "
              << Whitespace(sizePrefixDisplay*1) << "reporters to use (console is default)\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "o,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "out=<string>                  "
              << Whitespace(sizePrefixDisplay*1) << "output filename\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ob,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "order-by=<string>             "
              << Whitespace(sizePrefixDisplay*1) << "how the tests should be ordered\n";
            s << Whitespace(sizePrefixDisplay*3) << "                                       <string> - by [file/suite/name/rand]\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "rs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "rand-seed=<int>               "
              << Whitespace(sizePrefixDisplay*1) << "seed for random ordering\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "f,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "first=<int>                   "
              << Whitespace(sizePrefixDisplay*1) << "the first test passing the filters to\n";
            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "l,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "last=<int>                    "
              << Whitespace(sizePrefixDisplay*1) << "the last test passing the filters to\n";
            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "aa,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "abort-after=<int>             "
              << Whitespace(sizePrefixDisplay*1) << "stop after <int> failed assertions\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "scfl,--" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-filter-levels=<int>   "
              << Whitespace(sizePrefixDisplay*1) << "apply filters for the first <int> levels\n";
            s << Color::Cyan << "\n[doctest] " << Color::None;
            s << "Bool options - can be used like flags and true is assumed. Available:\n\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "s,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "success=<bool>                "
              << Whitespace(sizePrefixDisplay*1) << "include successful assertions in output\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "cs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "case-sensitive=<bool>         "
              << Whitespace(sizePrefixDisplay*1) << "filters being treated as case sensitive\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "e,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "exit=<bool>                   "
              << Whitespace(sizePrefixDisplay*1) << "exits after the tests finish\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "d,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "duration=<bool>               "
              << Whitespace(sizePrefixDisplay*1) << "prints the time duration of each test\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nt,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-throw=<bool>               "
              << Whitespace(sizePrefixDisplay*1) << "skips exceptions-related assert checks\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ne,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-exitcode=<bool>            "
              << Whitespace(sizePrefixDisplay*1) << "returns (or exits) always with success\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-run=<bool>                 "
              << Whitespace(sizePrefixDisplay*1) << "skips all runtime doctest operations\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nv,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-version=<bool>             "
              << Whitespace(sizePrefixDisplay*1) << "omit the framework version in the output\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-colors=<bool>              "
              << Whitespace(sizePrefixDisplay*1) << "disables colors in output\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "fc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "force-colors=<bool>           "
              << Whitespace(sizePrefixDisplay*1) << "use colors even when not in a tty\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nb,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-breaks=<bool>              "
              << Whitespace(sizePrefixDisplay*1) << "disables breakpoints in debuggers\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ns,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-skip=<bool>                "
              << Whitespace(sizePrefixDisplay*1) << "don't skip test cases marked as skip\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "gfl, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "gnu-file-line=<bool>          "
              << Whitespace(sizePrefixDisplay*1) << ":n: vs (n): for line numbers in output\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "npf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-path-filenames=<bool>      "
              << Whitespace(sizePrefixDisplay*1) << "only filenames and no paths in output\n";
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nln, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-line-numbers=<bool>        "
              << Whitespace(sizePrefixDisplay*1) << "0 instead of real line numbers in output\n";
            // ================================================================================== << 79
            // clang-format on

            s << Color::Cyan << "\n[doctest] " << Color::None;
            s << "for more information visit the project documentation\n\n";
        }

        void printRegisteredReporters() {
            printVersion();
            auto printReporters = [this] (const reporterMap& reporters, const char* type) {
                if(reporters.size()) {
                    s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n";
                    for(auto& curr : reporters)
                        s << "priority: " << std::setw(5) << curr.first.first
                          << " name: " << curr.first.second << "\n";
                }
            };
            printReporters(getListeners(), "listeners");
            printReporters(getReporters(), "reporters");
        }

        void list_query_results() {
            separator_to_stream();
            if(opt.count || opt.list_test_cases) {
                s << Color::Cyan << "[doctest] " << Color::None
                  << "unskipped test cases passing the current filters: "
                  << g_cs->numTestCasesPassingFilters << "\n";
            } else if(opt.list_test_suites) {
                s << Color::Cyan << "[doctest] " << Color::None
                  << "unskipped test cases passing the current filters: "
                  << g_cs->numTestCasesPassingFilters << "\n";
                s << Color::Cyan << "[doctest] " << Color::None
                  << "test suites with unskipped test cases passing the current filters: "
                  << g_cs->numTestSuitesPassingFilters << "\n";
            }
        }

        // =========================================================================================
        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
        // =========================================================================================

        void report_query(const QueryData& in) override {
            if(opt.version) {
                printVersion();
            } else if(opt.help) {
                printHelp();
            } else if(opt.list_reporters) {
                printRegisteredReporters();
            } else if(opt.count || opt.list_test_cases) {
                if(opt.list_test_cases) {
                    s << Color::Cyan << "[doctest] " << Color::None
                      << "listing all test case names\n";
                    separator_to_stream();
                }

                for(unsigned i = 0; i < in.num_data; ++i)
                    s << Color::None << in.data[i] << "\n";

                separator_to_stream();

                s << Color::Cyan << "[doctest] " << Color::None
                  << "unskipped test cases passing the current filters: "
                  << g_cs->numTestCasesPassingFilters << "\n";

            } else if(opt.list_test_suites) {
                s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n";
                separator_to_stream();

                for(unsigned i = 0; i < in.num_data; ++i)
                    s << Color::None << in.data[i] << "\n";

                separator_to_stream();

                s << Color::Cyan << "[doctest] " << Color::None
                  << "unskipped test cases passing the current filters: "
                  << g_cs->numTestCasesPassingFilters << "\n";
                s << Color::Cyan << "[doctest] " << Color::None
                  << "test suites with unskipped test cases passing the current filters: "
                  << g_cs->numTestSuitesPassingFilters << "\n";
            }
        }

        void test_run_start() override { printIntro(); }

        void test_run_end(const TestRunStats& p) override {
            separator_to_stream();

            const bool anythingFailed = p.numTestCasesFailed > 0 || p.numAssertsFailed > 0;
            s << Color::Cyan << "[doctest] " << Color::None << "test cases: " << std::setw(6)
              << p.numTestCasesPassingFilters << " | "
              << ((p.numTestCasesPassingFilters == 0 || anythingFailed) ? Color::None :
                                                                          Color::Green)
              << std::setw(6) << p.numTestCasesPassingFilters - p.numTestCasesFailed << " passed"
              << Color::None << " | " << (p.numTestCasesFailed > 0 ? Color::Red : Color::None)
              << std::setw(6) << p.numTestCasesFailed << " failed" << Color::None << " | ";
            if(opt.no_skipped_summary == false) {
                const int numSkipped = p.numTestCases - p.numTestCasesPassingFilters;
                s << (numSkipped == 0 ? Color::None : Color::Yellow) << std::setw(6) << numSkipped
                  << " skipped" << Color::None;
            }
            s << "\n";
            s << Color::Cyan << "[doctest] " << Color::None << "assertions: " << std::setw(6)
              << p.numAsserts << " | "
              << ((p.numAsserts == 0 || anythingFailed) ? Color::None : Color::Green)
              << std::setw(6) << (p.numAsserts - p.numAssertsFailed) << " passed" << Color::None
              << " | " << (p.numAssertsFailed > 0 ? Color::Red : Color::None) << std::setw(6)
              << p.numAssertsFailed << " failed" << Color::None << " |\n";
            s << Color::Cyan << "[doctest] " << Color::None
              << "Status: " << (p.numTestCasesFailed > 0 ? Color::Red : Color::Green)
              << ((p.numTestCasesFailed > 0) ? "FAILURE!" : "SUCCESS!") << Color::None << std::endl;
        }

        void test_case_start(const TestCaseData& in) override {
            hasLoggedCurrentTestStart = false;
            tc                        = &in;
        }

        void test_case_reenter(const TestCaseData&) override {}

        void test_case_end(const CurrentTestCaseStats& st) override {
            // log the preamble of the test case only if there is something
            // else to print - something other than that an assert has failed
            if(opt.duration ||
               (st.failure_flags && st.failure_flags != TestCaseFailureReason::AssertFailure))
                logTestStart();

            if(opt.duration)
                s << Color::None << std::setprecision(6) << std::fixed << st.seconds
                  << " s: " << tc->m_name << "\n";

            if(st.failure_flags & TestCaseFailureReason::Timeout)
                s << Color::Red << "Test case exceeded time limit of " << std::setprecision(6)
                  << std::fixed << tc->m_timeout << "!\n";

            if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedButDidnt) {
                s << Color::Red << "Should have failed but didn't! Marking it as failed!\n";
            } else if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedAndDid) {
                s << Color::Yellow << "Failed as expected so marking it as not failed\n";
            } else if(st.failure_flags & TestCaseFailureReason::CouldHaveFailedAndDid) {
                s << Color::Yellow << "Allowed to fail so marking it as not failed\n";
            } else if(st.failure_flags & TestCaseFailureReason::DidntFailExactlyNumTimes) {
                s << Color::Red << "Didn't fail exactly " << tc->m_expected_failures
                  << " times so marking it as failed!\n";
            } else if(st.failure_flags & TestCaseFailureReason::FailedExactlyNumTimes) {
                s << Color::Yellow << "Failed exactly " << tc->m_expected_failures
                  << " times as expected so marking it as not failed!\n";
            }
            if(st.failure_flags & TestCaseFailureReason::TooManyFailedAsserts) {
                s << Color::Red << "Aborting - too many failed asserts!\n";
            }
            s << Color::None; // lgtm [cpp/useless-expression]
        }

        void test_case_exception(const TestCaseException& e) override {
            logTestStart();

            file_line_to_stream(s, tc->m_file, tc->m_line, " ");
            successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require :
                                                                   assertType::is_check);
            s << Color::Red << (e.is_crash ? "test case CRASHED: " : "test case THREW exception: ")
              << Color::Cyan << e.error_string << "\n";

            int num_stringified_contexts = get_num_stringified_contexts();
            if(num_stringified_contexts) {
                auto stringified_contexts = get_stringified_contexts();
                s << Color::None << "  logged: ";
                for(int i = num_stringified_contexts; i > 0; --i) {
                    s << (i == num_stringified_contexts ? "" : "          ")
                      << stringified_contexts[i - 1] << "\n";
                }
            }
            s << "\n" << Color::None;
        }

        void subcase_start(const SubcaseSignature& subc) override {
            std::lock_guard<std::mutex> lock(mutex);
            subcasesStack.push_back(subc);
            hasLoggedCurrentTestStart = false;
        }

        void subcase_end() override {
            std::lock_guard<std::mutex> lock(mutex);
            subcasesStack.pop_back();
            hasLoggedCurrentTestStart = false;
        }

        void log_assert(const AssertData& rb) override {
            if(!rb.m_failed && !opt.success)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(s, rb.m_file, rb.m_line, " ");
            successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);
            if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) ==
               0) //!OCLINT bitwise operator in conditional
                s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) "
                  << Color::None;

            if(rb.m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
                s << (rb.m_threw ? "threw as expected!" : "did NOT throw at all!") << "\n";
            } else if((rb.m_at & assertType::is_throws_as) &&
                      (rb.m_at & assertType::is_throws_with)) { //!OCLINT
                s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
                  << rb.m_exception_string << "\", " << rb.m_exception_type << " ) " << Color::None;
                if(rb.m_threw) {
                    if(!rb.m_failed) {
                        s << "threw as expected!\n";
                    } else {
                        s << "threw a DIFFERENT exception! (contents: " << rb.m_exception << ")\n";
                    }
                } else {
                    s << "did NOT throw at all!\n";
                }
            } else if(rb.m_at &
                      assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
                s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", "
                  << rb.m_exception_type << " ) " << Color::None
                  << (rb.m_threw ? (rb.m_threw_as ? "threw as expected!" :
                                                    "threw a DIFFERENT exception: ") :
                                   "did NOT throw at all!")
                  << Color::Cyan << rb.m_exception << "\n";
            } else if(rb.m_at &
                      assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
                s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
                  << rb.m_exception_string << "\" ) " << Color::None
                  << (rb.m_threw ? (!rb.m_failed ? "threw as expected!" :
                                                   "threw a DIFFERENT exception: ") :
                                   "did NOT throw at all!")
                  << Color::Cyan << rb.m_exception << "\n";
            } else if(rb.m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
                s << (rb.m_threw ? "THREW exception: " : "didn't throw!") << Color::Cyan
                  << rb.m_exception << "\n";
            } else {
                s << (rb.m_threw ? "THREW exception: " :
                                   (!rb.m_failed ? "is correct!\n" : "is NOT correct!\n"));
                if(rb.m_threw)
                    s << rb.m_exception << "\n";
                else
                    s << "  values: " << assertString(rb.m_at) << "( " << rb.m_decomp << " )\n";
            }

            log_contexts();
        }

        void log_message(const MessageData& mb) override {
            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(s, mb.m_file, mb.m_line, " ");
            s << getSuccessOrFailColor(false, mb.m_severity)
              << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
                                        "MESSAGE") << ": ";
            s << Color::None << mb.m_string << "\n";
            log_contexts();
        }

        void test_case_skipped(const TestCaseData&) override {}
    };

    DOCTEST_REGISTER_REPORTER("console", 0, ConsoleReporter);

#ifdef DOCTEST_PLATFORM_WINDOWS
    struct DebugOutputWindowReporter : public ConsoleReporter
    {
        DOCTEST_THREAD_LOCAL static std::ostringstream oss;

        DebugOutputWindowReporter(const ContextOptions& co)
                : ConsoleReporter(co, oss) {}

#define DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(func, type, arg)                                    \
    void func(type arg) override {                                                                 \
        bool with_col = g_no_colors;                                                               \
        g_no_colors   = false;                                                                     \
        ConsoleReporter::func(arg);                                                                \
        DOCTEST_OUTPUT_DEBUG_STRING(oss.str().c_str());                                            \
        oss.str("");                                                                               \
        g_no_colors = with_col;                                                                    \
    }

        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_start, DOCTEST_EMPTY, DOCTEST_EMPTY)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_end, const TestRunStats&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_start, const TestCaseData&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_reenter, const TestCaseData&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_end, const CurrentTestCaseStats&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_exception, const TestCaseException&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_start, const SubcaseSignature&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_end, DOCTEST_EMPTY, DOCTEST_EMPTY)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_assert, const AssertData&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_message, const MessageData&, in)
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_skipped, const TestCaseData&, in)
    };

    DOCTEST_THREAD_LOCAL std::ostringstream DebugOutputWindowReporter::oss;
#endif // DOCTEST_PLATFORM_WINDOWS

    // the implementation of parseOption()
    bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
        // going from the end to the beginning and stopping on the first occurrence from the end
        for(int i = argc; i > 0; --i) {
            auto index = i - 1;
            auto temp = std::strstr(argv[index], pattern);
            if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
                // eliminate matches in which the chars before the option are not '-'
                bool noBadCharsFound = true;
                auto curr            = argv[index];
                while(curr != temp) {
                    if(*curr++ != '-') {
                        noBadCharsFound = false;
                        break;
                    }
                }
                if(noBadCharsFound && argv[index][0] == '-') {
                    if(value) {
                        // parsing the value of an option
                        temp += strlen(pattern);
                        const unsigned len = strlen(temp);
                        if(len) {
                            *value = temp;
                            return true;
                        }
                    } else {
                        // just a flag - no value
                        return true;
                    }
                }
            }
        }
        return false;
    }

    // parses an option and returns the string after the '=' character
    bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
                     const String& defaultVal = String()) {
        if(value)
            *value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        // offset (normally 3 for "dt-") to skip prefix
        if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
            return true;
#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        return parseOptionImpl(argc, argv, pattern, value);
    }

    // locates a flag on the command line
    bool parseFlag(int argc, const char* const* argv, const char* pattern) {
        return parseOption(argc, argv, pattern);
    }

    // parses a comma separated list of words after a pattern in one of the arguments in argv
    bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern,
                           std::vector<String>& res) {
        String filtersString;
        if(parseOption(argc, argv, pattern, &filtersString)) {
            // tokenize with "," as a separator
            // cppcheck-suppress strtokCalled
            DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
            auto pch = std::strtok(filtersString.c_str(), ","); // modifies the string
            while(pch != nullptr) {
                if(strlen(pch))
                    res.push_back(pch);
                // uses the strtok() internal state to go to the next token
                // cppcheck-suppress strtokCalled
                pch = std::strtok(nullptr, ",");
            }
            DOCTEST_CLANG_SUPPRESS_WARNING_POP
            return true;
        }
        return false;
    }

    enum optionType
    {
        option_bool,
        option_int
    };

    // parses an int/bool option from the command line
    bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
                        int& res) {
        String parsedValue;
        if(!parseOption(argc, argv, pattern, &parsedValue))
            return false;

        if(type == 0) {
            // boolean
            const char positive[][5] = {"1", "true", "on", "yes"};  // 5 - strlen("true") + 1
            const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1

            // if the value matches any of the positive/negative possibilities
            for(unsigned i = 0; i < 4; i++) {
                if(parsedValue.compare(positive[i], true) == 0) {
                    res = 1; //!OCLINT parameter reassignment
                    return true;
                }
                if(parsedValue.compare(negative[i], true) == 0) {
                    res = 0; //!OCLINT parameter reassignment
                    return true;
                }
            }
        } else {
            // integer
            // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
            int theInt = std::atoi(parsedValue.c_str()); // NOLINT
            if(theInt != 0) {
                res = theInt; //!OCLINT parameter reassignment
                return true;
            }
        }
        return false;
    }
} // namespace

Context::Context(int argc, const char* const* argv)
        : p(new detail::ContextState) {
    parseArgs(argc, argv, true);
    if(argc)
        p->binary_name = argv[0];
}

Context::~Context() {
    if(g_cs == p)
        g_cs = nullptr;
    delete p;
}

void Context::applyCommandLine(int argc, const char* const* argv) {
    parseArgs(argc, argv);
    if(argc)
        p->binary_name = argv[0];
}

// parses args
void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) {
    using namespace detail;

    // clang-format off
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=",        p->filters[0]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=",                 p->filters[0]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=",                p->filters[1]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=",         p->filters[2]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=",                 p->filters[2]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=",                p->filters[3]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=",          p->filters[4]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=",                 p->filters[4]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=",  p->filters[5]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=",                p->filters[5]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=",            p->filters[6]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=",                 p->filters[6]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=",    p->filters[7]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=",                p->filters[7]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=",          p->filters[8]);
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=",                  p->filters[8]);
    // clang-format on

    int    intRes = 0;
    String strRes;

#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default)                                   \
    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) ||  \
       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes))   \
        p->var = !!intRes;                                                                         \
    else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) ||                           \
            parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname))                            \
        p->var = true;                                                                             \
    else if(withDefaults)                                                                          \
    p->var = default

#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default)                                        \
    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) ||   \
       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes))    \
        p->var = intRes;                                                                           \
    else if(withDefaults)                                                                          \
    p->var = default

#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default)                                        \
    if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) ||        \
       parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) ||       \
       withDefaults)                                                                               \
    p->var = strRes

    // clang-format off
    DOCTEST_PARSE_STR_OPTION("out", "o", out, "");
    DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file");
    DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0);

    DOCTEST_PARSE_INT_OPTION("first", "f", first, 0);
    DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX);

    DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0);
    DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX);

    DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC));
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false);
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false);
    // clang-format on

    if(withDefaults) {
        p->help             = false;
        p->version          = false;
        p->count            = false;
        p->list_test_cases  = false;
        p->list_test_suites = false;
        p->list_reporters   = false;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) {
        p->help = true;
        p->exit = true;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) {
        p->version = true;
        p->exit    = true;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) {
        p->count = true;
        p->exit  = true;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) {
        p->list_test_cases = true;
        p->exit            = true;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) {
        p->list_test_suites = true;
        p->exit             = true;
    }
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") ||
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) {
        p->list_reporters = true;
        p->exit           = true;
    }
}

// allows the user to add procedurally to the filters from the command line
void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); }

// allows the user to clear all filters from the command line
void Context::clearFilters() {
    for(auto& curr : p->filters)
        curr.clear();
}

// allows the user to override procedurally the int/bool options from the command line
void Context::setOption(const char* option, int value) {
    setOption(option, toString(value).c_str());
}

// allows the user to override procedurally the string options from the command line
void Context::setOption(const char* option, const char* value) {
    auto argv   = String("-") + option + "=" + value;
    auto lvalue = argv.c_str();
    parseArgs(1, &lvalue);
}

// users should query this in their main() and exit the program if true
bool Context::shouldExit() { return p->exit; }

void Context::setAsDefaultForAssertsOutOfTestCases() { g_cs = p; }

void Context::setAssertHandler(detail::assert_handler ah) { p->ah = ah; }

// the main function that does all the filtering and test running
int Context::run() {
    using namespace detail;

    // save the old context state in case such was setup - for using asserts out of a testing context
    auto old_cs = g_cs;
    // this is the current contest
    g_cs               = p;
    is_running_in_test = true;

    g_no_colors = p->no_colors;
    p->resetRunData();

    // stdout by default
    p->cout = &std::cout;
    p->cerr = &std::cerr;

    // or to a file if specified
    std::fstream fstr;
    if(p->out.size()) {
        fstr.open(p->out.c_str(), std::fstream::out);
        p->cout = &fstr;
    }

    auto cleanup_and_return = [&]() {
        if(fstr.is_open())
            fstr.close();

        // restore context
        g_cs               = old_cs;
        is_running_in_test = false;

        // we have to free the reporters which were allocated when the run started
        for(auto& curr : p->reporters_currently_used)
            delete curr;
        p->reporters_currently_used.clear();

        if(p->numTestCasesFailed && !p->no_exitcode)
            return EXIT_FAILURE;
        return EXIT_SUCCESS;
    };

    // setup default reporter if none is given through the command line
    if(p->filters[8].empty())
        p->filters[8].push_back("console");

    // check to see if any of the registered reporters has been selected
    for(auto& curr : getReporters()) {
        if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive))
            p->reporters_currently_used.push_back(curr.second(*g_cs));
    }

    // TODO: check if there is nothing in reporters_currently_used

    // prepend all listeners
    for(auto& curr : getListeners())
        p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs));

#ifdef DOCTEST_PLATFORM_WINDOWS
    if(isDebuggerActive())
        p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs));
#endif // DOCTEST_PLATFORM_WINDOWS

    // handle version, help and no_run
    if(p->no_run || p->version || p->help || p->list_reporters) {
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData());

        return cleanup_and_return();
    }

    std::vector<const TestCase*> testArray;
    for(auto& curr : getRegisteredTests())
        testArray.push_back(&curr);
    p->numTestCases = testArray.size();

    // sort the collected records
    if(!testArray.empty()) {
        if(p->order_by.compare("file", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), fileOrderComparator);
        } else if(p->order_by.compare("suite", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), suiteOrderComparator);
        } else if(p->order_by.compare("name", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), nameOrderComparator);
        } else if(p->order_by.compare("rand", true) == 0) {
            std::srand(p->rand_seed);

            // random_shuffle implementation
            const auto first = &testArray[0];
            for(size_t i = testArray.size() - 1; i > 0; --i) {
                int idxToSwap = std::rand() % (i + 1); // NOLINT

                const auto temp = first[i];

                first[i]         = first[idxToSwap];
                first[idxToSwap] = temp;
            }
        }
    }

    std::set<String> testSuitesPassingFilt;

    bool                query_mode = p->count || p->list_test_cases || p->list_test_suites;
    std::vector<String> queryResults;

    if(!query_mode)
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY);

    // invoke the registered functions if they match the filter criteria (or just count them)
    for(auto& curr : testArray) {
        const auto& tc = *curr;

        bool skip_me = false;
        if(tc.m_skip && !p->no_skip)
            skip_me = true;

        if(!matchesAny(tc.m_file, p->filters[0], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_file, p->filters[1], false, p->case_sensitive))
            skip_me = true;
        if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive))
            skip_me = true;
        if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive))
            skip_me = true;

        if(!skip_me)
            p->numTestCasesPassingFilters++;

        // skip the test if it is not in the execution range
        if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) ||
           (p->first > p->numTestCasesPassingFilters))
            skip_me = true;

        if(skip_me) {
            if(!query_mode)
                DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc);
            continue;
        }

        // do not execute the test if we are to only count the number of filter passing tests
        if(p->count)
            continue;

        // print the name of the test and don't execute it
        if(p->list_test_cases) {
            queryResults.push_back(tc.m_name);
            continue;
        }

        // print the name of the test suite if not done already and don't execute it
        if(p->list_test_suites) {
            if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') {
                queryResults.push_back(tc.m_test_suite);
                testSuitesPassingFilt.insert(tc.m_test_suite);
                p->numTestSuitesPassingFilters++;
            }
            continue;
        }

        // execute the test if it passes all the filtering
        {
            p->currentTest = &tc;

            p->failure_flags = TestCaseFailureReason::None;
            p->seconds       = 0;

            // reset atomic counters
            p->numAssertsFailedCurrentTest_atomic = 0;
            p->numAssertsCurrentTest_atomic       = 0;

            p->subcasesPassed.clear();

            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc);

            p->timer.start();

            bool run_test = true;

            do {
                // reset some of the fields for subcases (except for the set of fully passed ones)
                p->should_reenter          = false;
                p->subcasesCurrentMaxLevel = 0;
                p->subcasesStack.clear();

                p->shouldLogCurrentException = true;

                // reset stuff for logging with INFO()
                p->stringifiedContexts.clear();

#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
                try {
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
                    FatalConditionHandler fatalConditionHandler; // Handle signals
                    // execute the test
                    tc.m_test();
                    fatalConditionHandler.reset();
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
                } catch(const TestFailureException&) {
                    p->failure_flags |= TestCaseFailureReason::AssertFailure;
                } catch(...) {
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception,
                                                      {translateActiveException(), false});
                    p->failure_flags |= TestCaseFailureReason::Exception;
                }
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS

                // exit this loop if enough assertions have failed - even if there are more subcases
                if(p->abort_after > 0 &&
                   p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) {
                    run_test = false;
                    p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts;
                }

                if(p->should_reenter && run_test)
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc);
                if(!p->should_reenter)
                    run_test = false;
            } while(run_test);

            p->finalizeTestCaseData();

            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);

            p->currentTest = nullptr;

            // stop executing tests if enough assertions have failed
            if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after)
                break;
        }
    }

    if(!query_mode) {
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
    } else {
        QueryData qdata;
        qdata.run_stats = g_cs;
        qdata.data      = queryResults.data();
        qdata.num_data  = unsigned(queryResults.size());
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata);
    }

    // see these issues on the reasoning for this:
    // - https://github.com/onqtam/doctest/issues/143#issuecomment-414418903
    // - https://github.com/onqtam/doctest/issues/126
    auto DOCTEST_FIX_FOR_MACOS_LIBCPP_IOSFWD_STRING_LINK_ERRORS = []() DOCTEST_NOINLINE
        { std::cout << std::string(); };
    DOCTEST_FIX_FOR_MACOS_LIBCPP_IOSFWD_STRING_LINK_ERRORS();

    return cleanup_and_return();
}

IReporter::~IReporter() = default;

int IReporter::get_num_active_contexts() { return detail::g_infoContexts.size(); }
const IContextScope* const* IReporter::get_active_contexts() {
    return get_num_active_contexts() ? &detail::g_infoContexts[0] : nullptr;
}

int IReporter::get_num_stringified_contexts() { return detail::g_cs->stringifiedContexts.size(); }
const String* IReporter::get_stringified_contexts() {
    return get_num_stringified_contexts() ? &detail::g_cs->stringifiedContexts[0] : nullptr;
}

namespace detail {
    void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
        if(isReporter)
            getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
        else
            getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
    }
} // namespace detail

} // namespace doctest

#endif // DOCTEST_CONFIG_DISABLE

#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) // 'function' : must be 'attribute' - see issue #182
int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); }
DOCTEST_MSVC_SUPPRESS_WARNING_POP
#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

DOCTEST_CLANG_SUPPRESS_WARNING_POP
DOCTEST_MSVC_SUPPRESS_WARNING_POP
DOCTEST_GCC_SUPPRESS_WARNING_POP

#endif // DOCTEST_LIBRARY_IMPLEMENTATION
#endif // DOCTEST_CONFIG_IMPLEMENT



================================================
FILE: examples/libraries/cereal-1.3.0/unittests/forward_list.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "forward_list.hpp"

TEST_SUITE_BEGIN("forward_list");

TEST_CASE("binary_forward_list")
{
  test_forward_list<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_forward_list")
{
  test_forward_list<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_forward_list")
{
  test_forward_list<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_forward_list")
{
  test_forward_list<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/forward_list.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_FORWARD_LIST_H_
#define CEREAL_TEST_FORWARD_LIST_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_forward_list()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::forward_list<int> o_podforward_list(100);
    for(auto & elem : o_podforward_list)
      elem = random_value<int>(gen);

    std::forward_list<StructInternalSerialize> o_iserforward_list(100);
    for(auto & elem : o_iserforward_list)
      elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::forward_list<StructInternalSplit> o_isplforward_list(100);
    for(auto & elem : o_isplforward_list)
      elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::forward_list<StructExternalSerialize> o_eserforward_list(100);
    for(auto & elem : o_eserforward_list)
      elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::forward_list<StructExternalSplit> o_esplforward_list(100);
    for(auto & elem : o_esplforward_list)
      elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podforward_list);
      oar(o_iserforward_list);
      oar(o_isplforward_list);
      oar(o_eserforward_list);
      oar(o_esplforward_list);
    }

    std::forward_list<int> i_podforward_list;
    std::forward_list<StructInternalSerialize> i_iserforward_list;
    std::forward_list<StructInternalSplit>     i_isplforward_list;
    std::forward_list<StructExternalSerialize> i_eserforward_list;
    std::forward_list<StructExternalSplit>     i_esplforward_list;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podforward_list);
      iar(i_iserforward_list);
      iar(i_isplforward_list);
      iar(i_eserforward_list);
      iar(i_esplforward_list);
    }

    check_collection(i_podforward_list,  o_podforward_list );
    check_collection(i_iserforward_list, o_iserforward_list);
    check_collection(i_isplforward_list, o_isplforward_list);
    check_collection(i_eserforward_list, o_eserforward_list);
    check_collection(i_esplforward_list, o_esplforward_list);
  }
}

#endif // CEREAL_TEST_FORWARD_LIST_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/list.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "list.hpp"

TEST_SUITE_BEGIN("list");

TEST_CASE("binary_list")
{
  test_list<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_list")
{
  test_list<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_list")
{
  test_list<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_list")
{
  test_list<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/list.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_LIST_H_
#define CEREAL_TEST_LIST_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_list()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::list<int> o_podlist(100);
    for(auto & elem : o_podlist)
      elem = random_value<int>(gen);

    std::list<StructInternalSerialize> o_iserlist(100);
    for(auto & elem : o_iserlist)
      elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::list<StructInternalSplit> o_ispllist(100);
    for(auto & elem : o_ispllist)
      elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::list<StructExternalSerialize> o_eserlist(100);
    for(auto & elem : o_eserlist)
      elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::list<StructExternalSplit> o_espllist(100);
    for(auto & elem : o_espllist)
      elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podlist);
      oar(o_iserlist);
      oar(o_ispllist);
      oar(o_eserlist);
      oar(o_espllist);
    }

    std::list<int> i_podlist;
    std::list<StructInternalSerialize> i_iserlist;
    std::list<StructInternalSplit>     i_ispllist;
    std::list<StructExternalSerialize> i_eserlist;
    std::list<StructExternalSplit>     i_espllist;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podlist);
      iar(i_iserlist);
      iar(i_ispllist);
      iar(i_eserlist);
      iar(i_espllist);
    }

    check_collection(i_podlist,  o_podlist);
    check_collection(i_iserlist, o_iserlist);
    check_collection(i_ispllist, o_ispllist);
    check_collection(i_eserlist, o_eserlist);
    check_collection(i_espllist, o_espllist);
  }
}

#endif // CEREAL_TEST_LIST_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/load_construct.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "load_construct.hpp"

TEST_SUITE_BEGIN("load_construct");

TEST_CASE("binary_memory_load_construct")
{
  test_memory_load_construct<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_memory_load_construct")
{
  test_memory_load_construct<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_memory_load_construct")
{
  test_memory_load_construct<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_memory_load_construct")
{
  test_memory_load_construct<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/load_construct.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_LOAD_CONSTRUCT_H_
#define CEREAL_TEST_LOAD_CONSTRUCT_H_
#include "common.hpp"

struct OneLA
{
  OneLA( int xx ) : x( xx ) {}

  int x;

  template <class Archive>
  void serialize( Archive & ar )
  { ar( x ); }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<OneLA> & construct )
  {
    int xx;
    ar( xx );
    construct( xx );
  }

  bool operator==( OneLA const & other ) const
  { return x == other.x; }
};

std::ostream& operator<<(std::ostream& os, OneLA const & s)
{
  os << "[" << s.x << "]";
  return os;
}

struct OneLAVersioned
{
  OneLAVersioned( int xx ) : x( xx ), v() {}
  OneLAVersioned( int xx, int vv ) : x( xx ), v( vv ) {}

  int x;
  std::uint32_t v;

  template <class Archive>
  void serialize( Archive & ar, const std::uint32_t version )
  { ar( x ); v = version; }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<OneLAVersioned> & construct, const std::uint32_t version )
  {
    int xx;
    ar( xx );
    construct( xx, version );
  }

  bool operator==( OneLAVersioned const & other ) const
  { return x == other.x; }
};

std::ostream& operator<<(std::ostream& os, OneLAVersioned const & s)
{
  os << "[" << s.x << "]";
  return os;
}

CEREAL_CLASS_VERSION( OneLAVersioned, 13 )

struct TwoLA
{
  TwoLA( int xx ) : x( xx ) {}

  int x;

  template <class Archive>
  void serialize( Archive & ar )
  { ar( x ); }

  bool operator==( TwoLA const & other ) const
  { return x == other.x; }
};

std::ostream& operator<<(std::ostream& os, TwoLA const & s)
{
  os << "[" << s.x << "]";
  return os;
}

namespace cereal
{
  template <>
  struct LoadAndConstruct<TwoLA>
  {
    template <class Archive>
    static void load_and_construct( Archive & ar, cereal::construct<TwoLA> & construct )
    {
      int xx;
      ar( xx );
      construct( xx );
    }
  };
}

struct TwoLAVersioned
{
  TwoLAVersioned( int xx ) : x( xx ), v() {}
  TwoLAVersioned( int xx, int vv ) : x( xx ), v( vv ) {}

  int x;
  std::uint32_t v;

  template <class Archive>
  void serialize( Archive & ar, const std::uint32_t version )
  { ar( x ); v = version; }

  bool operator==( TwoLAVersioned const & other ) const
  { return x == other.x; }
};

std::ostream& operator<<(std::ostream& os, TwoLAVersioned const & s)
{
  os << "[" << s.x << "]";
  return os;
}

namespace cereal
{
  template <>
  struct LoadAndConstruct<TwoLAVersioned>
  {
    template <class Archive>
    static void load_and_construct( Archive & ar, cereal::construct<TwoLAVersioned> & construct, const std::uint32_t version )
    {
      int xx;
      ar( xx );
      construct( xx, version );
    }
  };
}

CEREAL_CLASS_VERSION( TwoLAVersioned, 1 )

struct ThreeLA : std::enable_shared_from_this<ThreeLA>
{
  ThreeLA( int xx ) : x( xx ) {}

  int x;

  template <class Archive>
  void serialize( Archive & ar )
  { ar( x ); }

  bool operator==( ThreeLA const & other ) const
  { return x == other.x; }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<ThreeLA> & construct )
  {
    int xx;
    ar( xx );
    construct( xx );
  }
};

std::ostream& operator<<(std::ostream& os, ThreeLA const & s)
{
  os << "[" << s.x << "]";
  return os;
}

template <class IArchive, class OArchive>
void test_memory_load_construct()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    auto o_shared1 = std::make_shared<OneLA>( random_value<int>(gen) );
    auto o_shared2 = std::make_shared<TwoLA>( random_value<int>(gen) );
    std::unique_ptr<OneLA> o_unique1( new OneLA( random_value<int>(gen) ) );
    std::unique_ptr<TwoLA> o_unique2( new TwoLA( random_value<int>(gen) ) );
    auto o_shared3 = std::make_shared<ThreeLA>( random_value<int>(gen) );
    auto o_shared1v = std::make_shared<OneLAVersioned>( random_value<int>(gen) );
    auto o_shared2v = std::make_shared<TwoLAVersioned>( random_value<int>(gen) );

    auto o_constShared1 = std::make_shared<const OneLA>( random_value<int>(gen) ); // issue 417
    auto o_constShared2 = std::make_shared<const TwoLA>( random_value<int>(gen) );
    std::unique_ptr<const OneLA> o_constUnique1( new OneLA( random_value<int>(gen) ) );
    std::unique_ptr<const TwoLA> o_constUnique2( new TwoLA( random_value<int>(gen) ) );
    auto o_constShared3 = std::make_shared<const ThreeLA>( random_value<int>(gen) );
    auto o_constShared1v = std::make_shared<const OneLAVersioned>( random_value<int>(gen) );
    auto o_constShared2v = std::make_shared<const TwoLAVersioned>( random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_shared1 );
      oar( o_shared2 );
      oar( o_unique1 );
      oar( o_unique2 );
      oar( o_shared3 );
      oar( o_shared1v );
      oar( o_shared2v );
      oar( o_constShared1 );
      oar( o_constShared2 );
      oar( o_constUnique1 );
      oar( o_constUnique2 );
      oar( o_constShared3 );
      oar( o_constShared1v );
      oar( o_constShared2v );
    }

    o_shared3->shared_from_this(); // tests github issue #68
    o_constShared3->shared_from_this();

    decltype(o_shared1) i_shared1;
    decltype(o_shared2) i_shared2;
    decltype(o_unique1) i_unique1;
    decltype(o_unique2) i_unique2;
    decltype(o_shared3) i_shared3;
    decltype(o_shared1v) i_shared1v;
    decltype(o_shared2v) i_shared2v;
    decltype(o_constShared1) i_constShared1;
    decltype(o_constShared2) i_constShared2;
    decltype(o_constUnique1) i_constUnique1;
    decltype(o_constUnique2) i_constUnique2;
    decltype(o_constShared3) i_constShared3;
    decltype(o_constShared1v) i_constShared1v;
    decltype(o_constShared2v) i_constShared2v;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_shared1 );
      iar( i_shared2 );
      iar( i_unique1 );
      iar( i_unique2 );
      iar( i_shared3 );
      iar( i_shared1v );
      iar( i_shared2v );
      iar( i_constShared1 );
      iar( i_constShared2 );
      iar( i_constUnique1 );
      iar( i_constUnique2 );
      iar( i_constShared3 );
      iar( i_constShared1v );
      iar( i_constShared2v );
    }

    CHECK_EQ( *o_shared1, *i_shared1 );
    CHECK_EQ( *o_shared2, *i_shared2 );
    CHECK_EQ( *o_unique1, *i_unique1 );
    CHECK_EQ( *o_unique2, *i_unique2 );
    CHECK_EQ( *o_shared3, *i_shared3 );
    CHECK_EQ( *o_shared1v, *i_shared1v );
    CHECK_EQ(i_shared1v->v, 13u);
    CHECK_EQ( *o_shared2v, *i_shared2v );
    CHECK_EQ(i_shared2v->v, 1u);

    auto i_shared3_2 = i_shared3->shared_from_this();
    CHECK_EQ( *o_shared3, *i_shared3_2 );

    CHECK_EQ( *o_constShared1, *i_constShared1 );
    CHECK_EQ( *o_constShared2, *i_constShared2 );
    CHECK_EQ( *o_constUnique1, *i_constUnique1 );
    CHECK_EQ( *o_constUnique2, *i_constUnique2 );
    CHECK_EQ( *o_constShared3, *i_constShared3 );
    CHECK_EQ( *o_constShared1v, *i_constShared1v );
    CHECK_EQ(i_constShared1v->v, 13u);
    CHECK_EQ( *o_constShared2v, *i_constShared2v );
    CHECK_EQ(i_constShared2v->v, 1u);

    auto i_constShared3_2 = i_constShared3->shared_from_this();
    CHECK_EQ( *o_constShared3, *i_constShared3_2 );
  }
}

#endif // CEREAL_TEST_LOAD_CONSTRUCT_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/map.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "map.hpp"

TEST_SUITE_BEGIN("map");

TEST_CASE("binary_map")
{
  test_map<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_map")
{
  test_map<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_map")
{
  test_map<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_map")
{
  test_map<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_CASE("binary_map_memory")
{
  test_map_memory<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_map_memory")
{
  test_map_memory<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_map_memory")
{
  test_map_memory<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_map_memory")
{
  test_map_memory<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/map.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_MAP_H_
#define CEREAL_TEST_MAP_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_map()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::map<size_t, std::vector<StructInternalSerialize>> o_vectormap;
    for(int j=0; j<10; ++j)
    {
      size_t id = random_value<size_t>(gen);
      for(int k=0; k<100; ++k)
        o_vectormap[id].emplace_back(random_value<int>(gen), random_value<int>(gen));
    }

    std::map<std::string, int> o_podmap;
    for(int j=0; j<100; ++j)
      o_podmap.insert({random_value<std::string>(gen), random_value<int>(gen)});

    std::map<int, StructInternalSerialize> o_isermap;
    for(int j=0; j<100; ++j)
      o_isermap.insert({random_value<int>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::map<int, StructInternalSplit> o_isplmap;
    for(int j=0; j<100; ++j)
      o_isplmap.insert({random_value<int>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::map<uint32_t, StructExternalSerialize> o_esermap;
    for(int j=0; j<100; ++j)
      o_esermap.insert({random_value<uint32_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::map<int8_t, StructExternalSplit> o_esplmap;
    for(int j=0; j<100; ++j)
      o_esplmap.insert({random_value<char>(gen),  { random_value<int>(gen), random_value<int>(gen) }});

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_vectormap);
      oar(o_podmap);
      oar(o_isermap);
      oar(o_isplmap);
      oar(o_esermap);
      oar(o_esplmap);
    }

    std::map<size_t, std::vector<StructInternalSerialize>> i_vectormap;
    std::map<std::string, int> i_podmap;
    std::map<int, StructInternalSerialize>   i_isermap;
    std::map<int, StructInternalSplit>        i_isplmap;
    std::map<uint32_t, StructExternalSerialize> i_esermap;
    std::map<int8_t, StructExternalSplit>       i_esplmap;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_vectormap);
      iar(i_podmap);
      iar(i_isermap);
      iar(i_isplmap);
      iar(i_esermap);
      iar(i_esplmap);
    }

    CHECK_EQ(i_vectormap.size(), o_vectormap.size());
    auto o_v_it = o_vectormap.begin();
    auto i_v_it = i_vectormap.begin();
    for(;o_v_it != o_vectormap.end(); ++o_v_it, ++i_v_it)
    {
      CHECK_EQ(i_v_it->second.size(), o_v_it->second.size());
      check_collection(i_v_it->second, o_v_it->second);
    }

    check_collection(i_podmap,  o_podmap);
    check_collection(i_isermap, o_isermap);
    check_collection(i_isplmap, o_isplmap);
    check_collection(i_esermap, o_esermap);
    check_collection(i_esplmap, o_esplmap);
  }
}

template <class IArchive, class OArchive> inline
void test_map_memory()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::map<int, std::unique_ptr<int>> o_uniqueptrMap;
    std::map<int, std::shared_ptr<int>> o_sharedptrMap;

    for(int j=0; j<100; ++j)
    {
      #ifdef CEREAL_OLDER_GCC
      o_uniqueptrMap.insert( std::make_pair(random_value<int>(gen), std::unique_ptr<int>( new int( random_value<int>(gen) ) )) );
      o_sharedptrMap.insert( std::make_pair(random_value<int>(gen), std::make_shared<int>( random_value<int>(gen) )) );
      #else // NOT CEREAL_OLDER_GCC
      o_uniqueptrMap.emplace( random_value<int>(gen), std::unique_ptr<int>( new int( random_value<int>(gen) ) ) );
      o_sharedptrMap.emplace( random_value<int>(gen), std::make_shared<int>( random_value<int>(gen) ) );
      #endif // NOT CEREAL_OLDER_GCC
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_uniqueptrMap );
      oar( o_sharedptrMap );
    }

    decltype( o_uniqueptrMap ) i_uniqueptrMap;
    decltype( o_sharedptrMap ) i_sharedptrMap;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_uniqueptrMap );
      iar( i_sharedptrMap );
    }

    CHECK_EQ(o_sharedptrMap.size(), i_sharedptrMap.size());
    CHECK_EQ(o_uniqueptrMap.size(), i_uniqueptrMap.size());

    auto o_v_it = o_uniqueptrMap.begin();
    auto i_v_it = i_uniqueptrMap.begin();
    for(;o_v_it != o_uniqueptrMap.end(); ++o_v_it, ++i_v_it)
    {
      CHECK_EQ(i_v_it->first, o_v_it->first);
      CHECK_EQ(*i_v_it->second, *o_v_it->second);
    }
  }
}

#endif // CEREAL_TEST_MAP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/memory.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "memory.hpp"

TEST_SUITE_BEGIN("memory");

TEST_CASE("binary_memory")
{
  test_memory<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_memory")
{
  test_memory<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_memory")
{
  test_memory<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_memory")
{
  test_memory<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_CASE("binary_default_construction")
{
  test_default_construction<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_default_construction")
{
  test_default_construction<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_default_construction")
{
  test_default_construction<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_default_construction")
{
  test_default_construction<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/memory.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_MEMORY_H_
#define CEREAL_TEST_MEMORY_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_memory()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::shared_ptr<int> o_xptr1 = std::make_shared<int>(random_value<int>(gen));
    std::shared_ptr<int> o_xptr2 = o_xptr1;
    std::shared_ptr<const int> o_xptr3 = o_xptr1;
    std::shared_ptr<int> o_yptr1 = std::make_shared<int>(random_value<int>(gen));
    std::shared_ptr<int> o_yptr2 = o_yptr1;
    std::shared_ptr<int> o_nullptr1;
    std::shared_ptr<int> o_nullptr2;

    std::unique_ptr<int> o_zptr1(new int(random_value<int>(gen)));
    std::unique_ptr<const int> o_zptr2(new int(random_value<int>(gen)));
    std::unique_ptr<int> o_nullptr3;

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_xptr1, o_xptr2, o_xptr3 );
      oar( o_yptr1, o_yptr2 );
      oar( o_nullptr1, o_nullptr2 );

      oar( o_zptr1, o_zptr2 );
      oar( o_nullptr3 );
    }

    std::shared_ptr<int> i_xptr1;
    std::shared_ptr<int> i_xptr2;
    std::shared_ptr<const int> i_xptr3;
    std::shared_ptr<int> i_yptr1;
    std::shared_ptr<int> i_yptr2;
    std::shared_ptr<int> i_nullptr1;
    std::shared_ptr<int> i_nullptr2;

    std::unique_ptr<int> i_zptr1;
    std::unique_ptr<const int> i_zptr2;
    std::unique_ptr<int> i_nullptr3;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_xptr1, i_xptr2, i_xptr3 );
      iar( i_yptr1, i_yptr2 );
      iar( i_nullptr1, i_nullptr2 );

      iar( i_zptr1, i_zptr2 );
      iar( i_nullptr3 );
    }

    CHECK_EQ(o_xptr1.get(), o_xptr2.get());
    CHECK_EQ(o_xptr1.get(), o_xptr3.get());
    CHECK_EQ(i_xptr1.get(), i_xptr2.get());
    CHECK_EQ(i_xptr1.get(), i_xptr3.get());
    CHECK_EQ(*i_xptr1,      *i_xptr2);
    CHECK_EQ(*i_xptr1,      *i_xptr3);

    CHECK_EQ(o_yptr1.get(), o_yptr2.get());
    CHECK_EQ(i_yptr1.get(), i_yptr2.get());
    CHECK_EQ(*i_yptr1,      *i_yptr2);
    CHECK_UNARY_FALSE(i_nullptr1);
    CHECK_UNARY_FALSE(i_nullptr2);

    CHECK_EQ(*i_xptr1, *o_xptr1);
    CHECK_EQ(*i_xptr2, *o_xptr2);
    CHECK_EQ(*i_xptr3, *o_xptr3);

    CHECK_EQ(*i_zptr1, *o_zptr1);
    CHECK_EQ(*i_zptr2, *o_zptr2);
    CHECK_UNARY_FALSE(i_nullptr3);
  }
}

class TestClass
{
  public:
    TestClass(int v) : x(v) { }
    int x;

  private:
    friend class cereal::access;
    TestClass() = default;

    template<class Archive>
      void serialize(Archive & ar) { ar(x); }
};

template <class IArchive, class OArchive> inline
void test_default_construction()
{
  auto o_ptr = std::make_shared<TestClass>(1);
  auto o_ptr2 = std::make_shared<const TestClass>(1);
  std::shared_ptr<TestClass> i_ptr;
  std::shared_ptr<const TestClass> i_ptr2;

  std::ostringstream os;
  {
    OArchive oar(os);
    oar(o_ptr);
    oar(o_ptr2);
  }
  {
    std::istringstream is(os.str());
    IArchive iar(is);
    iar(i_ptr);
    iar(i_ptr2);
  }
  CHECK_EQ(o_ptr->x, i_ptr->x);
  CHECK_EQ(o_ptr2->x, i_ptr2->x);
}

#endif // CEREAL_TEST_LOAD_CONSTRUCT_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/memory_cycles.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "memory_cycles.hpp"

TEST_SUITE_BEGIN("memory_cycles");

TEST_CASE("binary_memory_cycles")
{
  test_memory_cycles<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_memory_cycles")
{
  test_memory_cycles<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_memory_cycles")
{
  test_memory_cycles<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_memory_cycles")
{
  test_memory_cycles<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/memory_cycles.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_MEMORY_CYCLES_H_
#define CEREAL_TEST_MEMORY_CYCLES_H_
#include "common.hpp"

struct MemoryCycle
{
  MemoryCycle() = default;

  MemoryCycle( int v ) :
    value( v )
  { }

  int value;
  std::weak_ptr<MemoryCycle> ptr;

  bool operator==( MemoryCycle const & other ) const
  {
    return value == other.value && ptr.lock() == other.ptr.lock();
  }

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( value, ptr );
  }
};

std::ostream& operator<<(std::ostream& os, MemoryCycle const & s)
{
  os << "[value: " << s.value << " ptr: " << s.ptr.lock() << "]";
  return os;
}

class MemoryCycleLoadAndConstruct
{
  public:
    MemoryCycleLoadAndConstruct( int v ) :
      value( v )
    { }

    MemoryCycleLoadAndConstruct( int v,
        std::weak_ptr<MemoryCycleLoadAndConstruct> p ) :
      value( v ),
      ptr( p )
    { }

    bool operator==( MemoryCycleLoadAndConstruct const & other ) const
    {
      return value == other.value && ptr.lock() == other.ptr.lock();
    }

    template <class Archive>
    void serialize( Archive & ar )
    {
      ar( value, ptr );
    }

    template <class Archive>
    static void load_and_construct( Archive & ar, cereal::construct<MemoryCycleLoadAndConstruct> & construct )
    {
      int val;
      std::weak_ptr<MemoryCycleLoadAndConstruct> p;

      ar( val, p );
      construct( val, p );
    }

    int value;
    std::weak_ptr<MemoryCycleLoadAndConstruct> ptr;
};

std::ostream& operator<<(std::ostream& os, MemoryCycleLoadAndConstruct const & s)
{
  os << "[value: " << s.value << " ptr: " << s.ptr.lock() << "]";
  return os;
}

template <class IArchive, class OArchive> inline
void test_memory_cycles()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    auto o_ptr1 = std::make_shared<MemoryCycle>( random_value<int>(gen) );
    o_ptr1->ptr = o_ptr1;
    auto o_ptr2 = std::make_shared<MemoryCycleLoadAndConstruct>( random_value<int>(gen) );
    o_ptr2->ptr = o_ptr2;

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_ptr1 );
      oar( o_ptr2 );
    }

    decltype(o_ptr1) i_ptr1;
    decltype(o_ptr2) i_ptr2;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_ptr1 );
      iar( i_ptr2 );
    }

    CHECK_EQ( o_ptr1->value, i_ptr1->value );
    CHECK_EQ( i_ptr1.get(), i_ptr1->ptr.lock().get() );
    CHECK_EQ( o_ptr2->value, i_ptr2->value );
    CHECK_EQ( i_ptr2.get(), i_ptr2->ptr.lock().get() );
  }
}
#endif // CEREAL_TEST_MEMORY_CYCLES_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/multimap.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "multimap.hpp"

TEST_SUITE_BEGIN("multimap");

TEST_CASE("binary_multimap")
{
  test_multimap<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_multimap")
{
  test_multimap<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_multimap")
{
  test_multimap<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_multimap")
{
  test_multimap<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/multimap.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_MULTIMAP_H_
#define CEREAL_TEST_MULTIMAP_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_multimap()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::multimap<std::string, int> o_podmultimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<std::string>(gen);
      o_podmultimap.insert({key, random_value<int>(gen)});
      o_podmultimap.insert({key, random_value<int>(gen)});
    }

    std::multimap<uint8_t, StructInternalSerialize> o_isermultimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<uint8_t>(gen);
      o_isermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_isermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::multimap<int16_t, StructInternalSplit> o_isplmultimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<int16_t>(gen);
      o_isplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_isplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::multimap<uint32_t, StructExternalSerialize> o_esermultimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<uint32_t>(gen);
      o_esermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_esermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::multimap<int8_t, StructExternalSplit> o_esplmultimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<char>(gen);
      o_esplmultimap.insert({key,  { random_value<int>(gen), random_value<int>(gen) }});
      o_esplmultimap.insert({key,  { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podmultimap);
      oar(o_isermultimap);
      oar(o_isplmultimap);
      oar(o_esermultimap);
      oar(o_esplmultimap);
    }

    std::multimap<std::string, int> i_podmultimap;
    std::multimap<uint8_t, StructInternalSerialize>   i_isermultimap;
    std::multimap<int16_t, StructInternalSplit>        i_isplmultimap;
    std::multimap<uint32_t, StructExternalSerialize> i_esermultimap;
    std::multimap<int8_t, StructExternalSplit>       i_esplmultimap;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podmultimap);
      iar(i_isermultimap);
      iar(i_isplmultimap);
      iar(i_esermultimap);
      iar(i_esplmultimap);
    }

#define MULTIMAP_CHECK(InMap, OutMap) \
    for( auto & pair : OutMap ) \
    { \
      auto const count = InMap.count( pair.first ); \
      CHECK_EQ( count, OutMap.count( pair.first ) ); \
      auto find = InMap.find( pair.first ); \
      bool found = false; \
      for( size_t i = 0; i < count; ++i, ++find ) \
        found |= find->second == pair.second; \
      CHECK_UNARY( found ); \
    }

    MULTIMAP_CHECK( i_podmultimap, o_podmultimap );
    MULTIMAP_CHECK( i_isermultimap, o_isermultimap );
    MULTIMAP_CHECK( i_isplmultimap, o_isplmultimap );
    MULTIMAP_CHECK( i_esermultimap, o_esermultimap );
    MULTIMAP_CHECK( i_esplmultimap, o_esplmultimap );

#undef MULTIMAP_CHECK
  }
}

#endif // CEREAL_TEST_MULTIMAP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/multiset.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "multiset.hpp"

TEST_SUITE_BEGIN("multiset");

TEST_CASE("binary_multiset")
{
  test_multiset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_multiset")
{
  test_multiset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_multiset")
{
  test_multiset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_multiset")
{
  test_multiset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/multiset.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_MULTISET_H_
#define CEREAL_TEST_MULTISET_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_multiset()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::multiset<int> o_podmultiset;
    for(int j=0; j<100; ++j)
    {
      int value = random_value<int>(gen);
      o_podmultiset.insert(value);
      o_podmultiset.insert(value);
    }

    std::multiset<StructInternalSerialize> o_isermultiset;
    for(int j=0; j<100; ++j)
    {
      StructInternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
      o_isermultiset.insert(value);
      o_isermultiset.insert(value);
    }

    std::multiset<StructInternalSplit> o_isplmultiset;
    for(int j=0; j<100; ++j)
    {
      StructInternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
      o_isplmultiset.insert(value);
      o_isplmultiset.insert(value);
    }

    std::multiset<StructExternalSerialize> o_esermultiset;
    for(int j=0; j<100; ++j)
    {
      StructExternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
      o_esermultiset.insert(value);
      o_esermultiset.insert(value);
    }

    std::multiset<StructExternalSplit> o_esplmultiset;
    for(int j=0; j<100; ++j)
    {
      StructExternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
      o_esplmultiset.insert(value);
      o_esplmultiset.insert(value);
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podmultiset);
      oar(o_isermultiset);
      oar(o_isplmultiset);
      oar(o_esermultiset);
      oar(o_esplmultiset);
    }

    std::multiset<int> i_podmultiset;
    std::multiset<StructInternalSerialize> i_isermultiset;
    std::multiset<StructInternalSplit>     i_isplmultiset;
    std::multiset<StructExternalSerialize> i_esermultiset;
    std::multiset<StructExternalSplit>     i_esplmultiset;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podmultiset);
      iar(i_isermultiset);
      iar(i_isplmultiset);
      iar(i_esermultiset);
      iar(i_esplmultiset);
    }

    for(auto const & p : i_podmultiset)
    {
      CHECK_EQ(o_podmultiset.count(p), i_podmultiset.count(p));
    }

    for(auto const & p : i_isermultiset)
    {
      CHECK_EQ(o_isermultiset.count(p), i_isermultiset.count(p));
    }

    for(auto const & p : i_isplmultiset)
    {
      CHECK_EQ(o_isplmultiset.count(p), i_isplmultiset.count(p));
    }

    for(auto const & p : i_esermultiset)
    {
      CHECK_EQ(o_esermultiset.count(p), i_esermultiset.count(p));
    }

    for(auto const & p : i_esplmultiset)
    {
      CHECK_EQ(o_esplmultiset.count(p), i_esplmultiset.count(p));
    }
  }
}

#endif // CEREAL_TEST_MULTISET_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/pair.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "pair.hpp"

TEST_SUITE_BEGIN("pair");

TEST_CASE("binary_pair")
{
  test_pair<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_pair")
{
  test_pair<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_pair")
{
  test_pair<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}
TEST_CASE("json_pair")
{
  test_pair<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/pair.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_PAIR_H_
#define CEREAL_TEST_PAIR_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_pair()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rng = [&](){ return random_value<int>(gen); };

  for(int ii=0; ii<100; ++ii)
  {
    std::pair<int, int> o_podpair = {rng(), rng()};
    std::pair<StructInternalSerialize, StructInternalSerialize> o_iserpair = {{rng(), rng()}, {rng(), rng()}};
    std::pair<StructInternalSplit, StructInternalSplit> o_isplpair = {{rng(), rng()}, {rng(), rng()}};
    std::pair<StructExternalSerialize, StructExternalSerialize> o_eserpair = {{rng(), rng()}, {rng(), rng()}};
    std::pair<StructExternalSplit, StructExternalSplit> o_esplpair = {{rng(), rng()}, {rng(), rng()}};

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podpair);
      oar(o_iserpair);
      oar(o_isplpair);
      oar(o_eserpair);
      oar(o_esplpair);
    }

    std::pair<int, int> i_podpair;
    std::pair<StructInternalSerialize, StructInternalSerialize> i_iserpair;
    std::pair<StructInternalSplit, StructInternalSplit> i_isplpair;
    std::pair<StructExternalSerialize, StructExternalSerialize> i_eserpair;
    std::pair<StructExternalSplit, StructExternalSplit> i_esplpair;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podpair);
      iar(i_iserpair);
      iar(i_isplpair);
      iar(i_eserpair);
      iar(i_esplpair);
    }

    CHECK_EQ( i_podpair.first, o_podpair.first );
    CHECK_EQ( i_podpair.second, o_podpair.second );

    CHECK_EQ( i_iserpair.first, o_iserpair.first );
    CHECK_EQ( i_iserpair.second, o_iserpair.second );

    CHECK_EQ( i_isplpair.first, o_isplpair.first );
    CHECK_EQ( i_isplpair.second, o_isplpair.second );

    CHECK_EQ( i_eserpair.first, o_eserpair.first );
    CHECK_EQ( i_eserpair.second, o_eserpair.second );

    CHECK_EQ( i_esplpair.first, o_esplpair.first );
    CHECK_EQ( i_esplpair.second, o_esplpair.second );
  }
}

#endif // CEREAL_TEST_PAIR_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/pod.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "pod.hpp"

TEST_SUITE_BEGIN("pod");

TEST_CASE("binary_pod")
{
  test_pod<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_pod")
{
  test_pod<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_pod")
{
  test_pod<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_pod")
{
  test_pod<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/pod.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_POD_H_
#define CEREAL_TEST_POD_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_pod()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(size_t i=0; i<100; ++i)
  {
    bool          const o_bool   = random_value<uint8_t>(gen) % 2 ? true : false;
    char          const o_char   = random_value<char>(gen);
    unsigned char const o_uchar  = random_value<unsigned char>(gen);
    uint8_t       const o_uint8  = random_value<uint8_t>(gen);
    int8_t        const o_int8   = random_value<int8_t>(gen);
    uint16_t      const o_uint16 = random_value<uint16_t>(gen);
    int16_t       const o_int16  = random_value<int16_t>(gen);
    uint32_t      const o_uint32 = random_value<uint32_t>(gen);
    int32_t       const o_int32  = random_value<int32_t>(gen);
    uint64_t      const o_uint64 = random_value<uint64_t>(gen);
    int64_t       const o_int64  = random_value<int64_t>(gen);
    float         const o_float  = random_value<float>(gen);
    double        const o_double = random_value<double>(gen);

    long double const o_long_double = random_value<long double>(gen);
    long const o_long = random_value<long>(gen);
    unsigned long const o_ulong = random_value<unsigned long>(gen);
    long long const o_long_long = random_value<long long>(gen);
    unsigned long long const o_ulong_long = random_value<unsigned long long>(gen);

    std::ostringstream os;
    {
      OArchive oar(os);
      oar(o_bool);
      oar(o_char);
      oar(o_uchar);
      oar(o_uint8);
      oar(o_int8);
      oar(o_uint16);
      oar(o_int16);
      oar(o_uint32);
      oar(o_int32);
      oar(o_uint64);
      oar(o_int64);
      oar(o_float);
      oar(o_double);
      oar(o_long_double);
      oar(o_long);
      oar(o_ulong);
      oar(o_long_long);
      oar(o_ulong_long);
    }

    bool          i_bool                       = false;
    char          i_char                       = 0;
    unsigned char i_uchar                      = 0;
    uint8_t       i_uint8                      = 0;
    int8_t        i_int8                       = 0;
    uint16_t      i_uint16                     = 0;
    int16_t       i_int16                      = 0;
    uint32_t      i_uint32                     = 0;
    int32_t       i_int32                      = 0;
    uint64_t      i_uint64                     = 0;
    int64_t       i_int64                      = 0;
    float         i_float                      = 0;
    double        i_double                     = 0;

    long double i_long_double       = 0;
    long i_long                     = 0;
    unsigned long i_ulong           = 0;
    long long i_long_long           = 0;
    unsigned long long i_ulong_long = 0;

    std::istringstream is(os.str());
    {
      IArchive iar(is);
      iar(i_bool);
      iar(i_char);
      iar(i_uchar);
      iar(i_uint8);
      iar(i_int8);
      iar(i_uint16);
      iar(i_int16);
      iar(i_uint32);
      iar(i_int32);
      iar(i_uint64);
      iar(i_int64);
      iar(i_float);
      iar(i_double);
      iar(i_long_double);
      iar(i_long);
      iar(i_ulong);
      iar(i_long_long);
      iar(i_ulong_long);
    }

    CHECK_EQ(i_bool   , o_bool);
    CHECK_EQ(i_char   , o_char);
    CHECK_EQ(i_uchar  , o_uchar);
    CHECK_EQ(i_uint8  , o_uint8);
    CHECK_EQ(i_int8   , o_int8);
    CHECK_EQ(i_uint16 , o_uint16);
    CHECK_EQ(i_int16  , o_int16);
    CHECK_EQ(i_uint32 , o_uint32);
    CHECK_EQ(i_int32  , o_int32);
    CHECK_EQ(i_uint64 , o_uint64);
    CHECK_EQ(i_int64  , o_int64);
    CHECK_EQ(i_float  , doctest::Approx(o_float).epsilon(1e-5F));
    CHECK_EQ(i_double , doctest::Approx(o_double).epsilon(1e-5));

    CHECK_EQ(i_long_double, doctest::Approx(o_long_double).epsilon(1e-5L));
    CHECK_EQ(i_long,        o_long);
    CHECK_EQ(i_ulong,       o_ulong);
    CHECK_EQ(i_long_long,   o_long_long);
    CHECK_EQ(i_ulong_long,  o_ulong_long);
  }
}

#endif // CEREAL_TEST_POD_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/polymorphic.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "polymorphic.hpp"

TEST_SUITE_BEGIN("polymorphic");

TEST_CASE("binary_polymorphic")
{
  test_polymorphic<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_polymorphic")
{
  test_polymorphic<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_polymorphic")
{
  test_polymorphic<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_polymorphic")
{
  test_polymorphic<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

#if CEREAL_THREAD_SAFE
TEST_CASE("binary_polymorphic_threading")
{
  test_polymorphic_threading<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_polymorphic_threading")
{
  test_polymorphic_threading<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_polymorphic_threading")
{
  test_polymorphic_threading<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_polymorphic_threading")
{
  test_polymorphic_threading<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}
#endif // CEREAL_THREAD_SAFE

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/polymorphic.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_POLYMORPHIC_H_
#define CEREAL_TEST_POLYMORPHIC_H_
#include "common.hpp"

#if CEREAL_THREAD_SAFE
#include <future>
#endif

struct PolyBaseA
{
  virtual void foo() = 0;
  virtual ~PolyBaseA() {}
};

struct PolyBaseAA : PolyBaseA
{
  PolyBaseAA() {}
  PolyBaseAA( long ww ) : w(ww) {}
  virtual ~PolyBaseAA() {}
  long w;

  void foo() {}

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( w );
  }

  bool operator==( PolyBaseAA const & other ) const
  {
    return w == other.w;
  }
};

CEREAL_REGISTER_POLYMORPHIC_RELATION(PolyBaseA, PolyBaseAA)

struct PolyBaseB : virtual PolyBaseAA
{
  PolyBaseB() {}
  PolyBaseB( int xx, long ww ) : PolyBaseAA(ww), x(xx) {}
  virtual ~PolyBaseB() {}
  int x;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( cereal::virtual_base_class<PolyBaseAA>( this ) );
    ar( x );
  }

  bool operator==( PolyBaseB const & other ) const
  {
    return PolyBaseAA::operator==( other ) &&
           x == other.x;
  }
};

struct PolyBaseC : virtual PolyBaseAA
{
  PolyBaseC() {}
  PolyBaseC( double yy, long ww ) : PolyBaseAA(ww), y(yy) {}
  virtual ~PolyBaseC() {}
  double y;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( cereal::virtual_base_class<PolyBaseAA>( this ) );
    ar( y );
  }

  bool operator==( PolyBaseC const & other ) const
  {
    return PolyBaseAA::operator==( other ) &&
           std::abs(y - other.y) < 1e-5;
  }
};

struct PolyDerivedD : PolyBaseB, PolyBaseC
{
  PolyDerivedD() {}
  PolyDerivedD( std::string const & zz, double yy, int xx, long ww ) :
    PolyBaseAA( ww ), PolyBaseB( xx, ww ), PolyBaseC( yy, ww ), z(zz) {}
  virtual ~PolyDerivedD() {}
  std::string z;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( cereal::base_class<PolyBaseB>( this ) );
    ar( cereal::base_class<PolyBaseC>( this ) );
    ar( z );
  }

  bool operator==( PolyDerivedD const & other ) const
  {
    return PolyBaseB::operator==( other ) &&
           PolyBaseC::operator==( other ) &&
           z == other.z;
  }
};

CEREAL_REGISTER_TYPE(PolyDerivedD)

struct PolyBase
{
  PolyBase() {}
  PolyBase( int xx, float yy ) : x(xx), y(yy) {}
  virtual ~PolyBase() {}
  int x;
  float y;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x, y );
  }

  virtual void foo() = 0;

  bool operator==( PolyBase const & other ) const
  {
    return x == other.x && std::abs(y - other.y) < 1e-5;
  }
};

struct PolyDerived : PolyBase
{
  PolyDerived() {}
  PolyDerived( int xx, float yy, bool aa, double bb ) :
    PolyBase( xx, yy ), a(aa), b(bb) {}
  virtual ~PolyDerived() {}

  bool a;
  double b;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( cereal::base_class<PolyBase>( this ),
        a, b );
  }

  bool operator==( PolyDerived const & other ) const
  {
    return PolyBase::operator==( other ) && a == other.a && std::abs(b - other.b) < 1e-5;
  }

  void foo() {}
};

CEREAL_REGISTER_TYPE(PolyDerived)

struct PolyLA : std::enable_shared_from_this<PolyLA>
{
  PolyLA() {}
  virtual ~PolyLA() {}
  virtual void foo() = 0;
};

struct PolyDerivedLA : public PolyLA
{
  PolyDerivedLA( int xx ) : x( xx ) { }
  virtual ~PolyDerivedLA() {}

  int x;
  std::vector<std::shared_ptr<PolyLA>> vec;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x );
    ar( vec );
  }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<PolyDerivedLA> & construct )
  {
    int xx;
    ar( xx );
    construct( xx );
    ar( construct->vec );
  }

  void foo() {}

  bool operator==( PolyDerivedLA const & other ) const
  {
    if( x != other.x )
      return false;
    if( vec.size() != other.vec.size() )
      return false;
    for( size_t i = 0; i < vec.size(); ++i )
      if( !(*std::dynamic_pointer_cast<PolyDerivedLA>(vec[i]) == *std::dynamic_pointer_cast<PolyDerivedLA>(other.vec[i])) )
        return false;

    return true;
  }
};

CEREAL_REGISTER_TYPE(PolyDerivedLA)
CEREAL_REGISTER_POLYMORPHIC_RELATION(PolyLA, PolyDerivedLA)

std::ostream& operator<<(std::ostream& os, PolyDerivedLA const & s)
{
    os << "[x: " << s.x << "] ";
    for( auto const & v : s.vec )
      os << " child: " << (*std::dynamic_pointer_cast<PolyDerivedLA>(v));
    return os;
}

std::ostream& operator<<(std::ostream& os, PolyDerived const & s)
{
    os << "[x: " << s.x << " y: " << s.y << " a: " << s.a << " b: " << s.b << "]";
    return os;
}

std::ostream& operator<<(std::ostream& os, PolyDerivedD const & s)
{
    os << "[w: " << s.w << " x: " << s.x << " y: " << s.y << " z: " << s.z << "]";
    return os;
}

template <class IArchive, class OArchive> inline
void test_polymorphic()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  #if CEREAL_THREAD_SAFE
  static std::mutex testMutex;
  #endif

  auto rngB = [&](){ return random_value<int>( gen ) % 2 == 0; };
  auto rngI = [&](){ return random_value<int>( gen ); };
  auto rngL = [&](){ return random_value<long>( gen ); };
  auto rngF = [&](){ return random_value<float>( gen ); };
  auto rngD = [&](){ return random_value<double>( gen ); };

  for(int ii=0; ii<100; ++ii)
  {
    std::shared_ptr<PolyBase> o_shared = std::make_shared<PolyDerived>( rngI(), rngF(), rngB(), rngD() );
    std::shared_ptr<const PolyBase> o_sharedC = std::make_shared<const PolyDerived>( rngI(), rngF(), rngB(), rngD() );

    std::weak_ptr<PolyBase>   o_weak = o_shared;
    std::weak_ptr<const PolyBase>   o_weakC = o_sharedC;

    std::unique_ptr<PolyBase> o_unique( new PolyDerived( rngI(), rngF(), rngB(), rngD() ) );
    std::unique_ptr<const PolyBase> o_uniqueC( new PolyDerived( rngI(), rngF(), rngB(), rngD() ) );

    std::shared_ptr<PolyBaseA> o_sharedA = std::make_shared<PolyDerivedD>( random_basic_string<char>(gen),
                                                                           rngD(), rngI(), rngL() );

    std::weak_ptr<PolyBaseA>   o_weakA = o_sharedA;
    std::unique_ptr<PolyBaseA> o_uniqueA( new PolyDerivedD( random_basic_string<char>(gen),
                                                            rngD(), rngI(), rngL() ) );

    auto pda = std::make_shared<PolyDerivedLA>( rngI() );
    pda->vec.emplace_back( std::make_shared<PolyDerivedLA>( rngI() ) );
    std::shared_ptr<PolyLA>   o_sharedLA = pda;

    auto pdaC = std::make_shared<const PolyDerivedLA>( rngI() );
    pda->vec.emplace_back( std::make_shared<PolyDerivedLA>( rngI() ) );
    std::shared_ptr<const PolyLA>   o_sharedLAC = pdaC;

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_shared, o_sharedC );
      oar( o_weak, o_weakC );
      oar( o_unique, o_uniqueC );

      oar( o_sharedLA );
      oar( o_sharedLAC );

      oar( o_sharedA, o_weakA, o_uniqueA );
    }

    decltype(o_shared) i_shared;
    decltype(o_sharedC) i_sharedC;

    decltype(o_weak) i_weak;
    decltype(o_weakC) i_weakC;

    decltype(o_unique) i_unique;
    decltype(o_uniqueC) i_uniqueC;

    decltype(o_sharedLA) i_sharedLA;
    decltype(o_sharedLAC) i_sharedLAC;

    decltype(o_sharedA) i_sharedA;
    decltype(o_weakA) i_weakA;
    decltype(o_uniqueA) i_uniqueA;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_shared, i_sharedC );
      iar( i_weak, i_weakC );
      iar( i_unique, i_uniqueC );

      iar( i_sharedLA );
      iar( i_sharedLAC );

      iar( i_sharedA, i_weakA, i_uniqueA );
    }

    auto i_locked = i_weak.lock();
    auto o_locked = o_weak.lock();

    auto i_lockedC = i_weakC.lock();
    auto o_lockedC = o_weakC.lock();

    auto i_sharedLA2 = i_sharedLA->shared_from_this();
    auto i_sharedLA2C = i_sharedLAC->shared_from_this();

    auto i_lockedA = i_weakA.lock();
    auto o_lockedA = o_weakA.lock();

    #if CEREAL_THREAD_SAFE
    std::lock_guard<std::mutex> lock( testMutex );
    #endif

    CHECK_EQ(i_shared.get(), i_locked.get());
    CHECK_EQ(*dynamic_cast<PolyDerived*>(i_shared.get()), *dynamic_cast<PolyDerived*>(o_shared.get()));
    CHECK_EQ(*dynamic_cast<PolyDerived*>(i_shared.get()), *dynamic_cast<PolyDerived*>(i_locked.get()));
    CHECK_EQ(*dynamic_cast<PolyDerived*>(i_locked.get()), *dynamic_cast<PolyDerived*>(o_locked.get()));
    CHECK_EQ(*dynamic_cast<PolyDerived*>(i_unique.get()), *dynamic_cast<PolyDerived*>(o_unique.get()));

    CHECK_EQ(i_sharedC.get(), i_lockedC.get());
    CHECK_EQ(*dynamic_cast<const PolyDerived*>(i_sharedC.get()), *dynamic_cast<const PolyDerived*>(o_sharedC.get()));
    CHECK_EQ(*dynamic_cast<const PolyDerived*>(i_sharedC.get()), *dynamic_cast<const PolyDerived*>(i_lockedC.get()));
    CHECK_EQ(*dynamic_cast<const PolyDerived*>(i_lockedC.get()), *dynamic_cast<const PolyDerived*>(o_lockedC.get()));
    CHECK_EQ(*dynamic_cast<const PolyDerived*>(i_uniqueC.get()), *dynamic_cast<const PolyDerived*>(o_uniqueC.get()));

    CHECK_EQ(*dynamic_cast<PolyDerivedLA*>(i_sharedLA.get()), *dynamic_cast<PolyDerivedLA*>(o_sharedLA.get()));
    CHECK_EQ(*dynamic_cast<PolyDerivedLA*>(i_sharedLA2.get()), *dynamic_cast<PolyDerivedLA*>(o_sharedLA.get()));

    CHECK_EQ(*dynamic_cast<const PolyDerivedLA*>(i_sharedLAC.get()), *dynamic_cast<const PolyDerivedLA*>(o_sharedLAC.get()));
    CHECK_EQ(*dynamic_cast<const PolyDerivedLA*>(i_sharedLA2C.get()), *dynamic_cast<const PolyDerivedLA*>(o_sharedLAC.get()));

    CHECK_EQ(i_sharedA.get(), i_lockedA.get());
    CHECK_EQ(*dynamic_cast<PolyDerivedD*>(i_sharedA.get()), *dynamic_cast<PolyDerivedD*>(o_sharedA.get()));
    CHECK_EQ(*dynamic_cast<PolyDerivedD*>(i_sharedA.get()), *dynamic_cast<PolyDerivedD*>(i_lockedA.get()));
    CHECK_EQ(*dynamic_cast<PolyDerivedD*>(i_lockedA.get()), *dynamic_cast<PolyDerivedD*>(o_lockedA.get()));
    CHECK_EQ(*dynamic_cast<PolyDerivedD*>(i_uniqueA.get()), *dynamic_cast<PolyDerivedD*>(o_uniqueA.get()));
  }
}

#if CEREAL_THREAD_SAFE
template <class IArchive, class OArchive> inline
void test_polymorphic_threading()
{
  std::vector<std::future<bool>> pool;
  for( size_t i = 0; i < 100; ++i )
    pool.emplace_back( std::async( std::launch::async,
                                   [](){ test_polymorphic<IArchive, OArchive>(); return true; } ) );

  for( auto & future : pool )
    future.wait();

  for( auto & future : pool )
    CHECK_UNARY( future.get() );
}
#endif // CEREAL_THREAD_SAFE

struct Object
{
  Object() = default;
  Object( int xx ) : x(xx) {}

  virtual ~Object() {}
  virtual void func() {}

  int x;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x );
  }
};

#define CEREAL_TEST_CREATE_DERIVED_CLASS(Base, Derived) \
struct Derived : public Base                            \
{                                                       \
  Derived() = default;                                  \
  Derived( int yy ) : Base( yy ), Derived##y( yy ) {}   \
  virtual ~Derived() {}                                 \
                                                        \
  virtual void func() override {}                       \
                                                        \
  int Derived##y;                                       \
  template <class Archive>                              \
  void serialize( Archive & ar )                        \
  {                                                     \
    ar( cereal::base_class<Base>( this ), Derived##y ); \
  }                                                     \
};                                                      \
CEREAL_REGISTER_TYPE(Derived)

//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived0)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived0,Derived1)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived1,Derived2)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived2,Derived3)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived3,Derived4)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived5)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived5,Derived6)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived6,Derived7)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived7,Derived8)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived8,Derived9)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived10)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived10,Derived11)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived11,Derived12)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived12,Derived13)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived13,Derived14)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived15)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived15,Derived16)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived16,Derived17)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived17,Derived18)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived18,Derived19)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived20)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived20,Derived21)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived21,Derived22)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived22,Derived23)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived23,Derived24)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived25)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived25,Derived26)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived26,Derived27)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived27,Derived28)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived28,Derived29)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived30)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived30,Derived31)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived31,Derived32)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived32,Derived33)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived33,Derived34)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived35)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived35,Derived36)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived36,Derived37)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived37,Derived38)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived38,Derived39)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived40)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived40,Derived41)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived41,Derived42)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived42,Derived43)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived43,Derived44)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived45)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived45,Derived46)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived46,Derived47)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived47,Derived48)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived48,Derived49)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived50)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived50,Derived51)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived51,Derived52)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived52,Derived53)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived53,Derived54)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived55)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived55,Derived56)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived56,Derived57)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived57,Derived58)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived58,Derived59)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived60)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived60,Derived61)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived61,Derived62)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived62,Derived63)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived63,Derived64)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived65)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived65,Derived66)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived66,Derived67)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived67,Derived68)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived68,Derived69)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived70)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived70,Derived71)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived71,Derived72)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived72,Derived73)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived73,Derived74)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived75)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived75,Derived76)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived76,Derived77)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived77,Derived78)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived78,Derived79)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived80)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived80,Derived81)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived81,Derived82)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived82,Derived83)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived83,Derived84)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived85)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived85,Derived86)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived86,Derived87)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived87,Derived88)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived88,Derived89)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived90)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived90,Derived91)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived91,Derived92)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived92,Derived93)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived93,Derived94)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived95)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived95,Derived96)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived96,Derived97)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived97,Derived98)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived98,Derived99)

//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived0)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived0,Derived1)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived1,Derived2)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived2,Derived3)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived0,Derived4)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived4,Derived5)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived5,Derived6)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived0,Derived7)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived7,Derived8)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived8,Derived9)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived10)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived10,Derived11)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived11,Derived12)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived12,Derived13)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived10,Derived14)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived14,Derived15)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived15,Derived16)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived10,Derived17)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived17,Derived18)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived18,Derived19)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived20)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived20,Derived21)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived21,Derived22)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived22,Derived23)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived20,Derived24)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived24,Derived25)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived25,Derived26)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived20,Derived27)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived27,Derived28)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived28,Derived29)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived30)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived30,Derived31)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived31,Derived32)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived32,Derived33)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived30,Derived34)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived34,Derived35)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived35,Derived36)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived30,Derived37)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived37,Derived38)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived38,Derived39)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived40)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived40,Derived41)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived41,Derived42)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived42,Derived43)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived40,Derived44)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived44,Derived45)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived45,Derived46)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived40,Derived47)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived47,Derived48)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived48,Derived49)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived50)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived50,Derived51)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived51,Derived52)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived52,Derived53)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived50,Derived54)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived54,Derived55)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived55,Derived56)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived50,Derived57)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived57,Derived58)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived58,Derived59)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived60)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived60,Derived61)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived61,Derived62)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived62,Derived63)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived60,Derived64)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived64,Derived65)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived65,Derived66)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived60,Derived67)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived67,Derived68)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived68,Derived69)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived70)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived70,Derived71)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived71,Derived72)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived72,Derived73)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived70,Derived74)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived74,Derived75)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived75,Derived76)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived70,Derived77)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived77,Derived78)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived78,Derived79)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived80)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived80,Derived81)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived81,Derived82)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived82,Derived83)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived80,Derived84)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived84,Derived85)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived85,Derived86)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived80,Derived87)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived87,Derived88)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived88,Derived89)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Object,Derived90)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived90,Derived91)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived91,Derived92)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived92,Derived93)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived90,Derived94)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived94,Derived95)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived95,Derived96)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived90,Derived97)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived97,Derived98)
//CEREAL_TEST_CREATE_DERIVED_CLASS(Derived98,Derived99)


#endif // CEREAL_TEST_POLYMORPHIC_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/portability_test.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <cereal/archives/portable_binary.hpp>

#include <cereal/types/memory.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/vector.hpp>

#include <fstream>
#include <iostream>

struct Data : std::enable_shared_from_this<Data>
{
  int32_t x;
  int64_t y;

  Data( int32_t xx, int64_t yy ) : x(xx), y(yy) {}

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x, y );
  }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<Data> & construct )
  {
    int32_t xx;
    int64_t yy;
    ar( xx, yy );
    construct( xx, yy );
  }

  bool operator==( Data const & other ) const
  {
    if( x != other.x )
    {
      std::cerr << "x=" << x << ", other.x=" << other.x << std::endl;
      return false;
    }
    if( y != other.y )
    {
      std::cerr << "y=" << y << ", other.y=" << other.y << std::endl;
      return false;
    }

    return true;
  }
};

struct Data2
{
  int32_t x;
  int64_t y;

  Data2() = default;
  Data2( int32_t xx, int64_t yy ) : x(xx), y(yy) {}

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( x, y );
  }

  bool operator==( Data2 const & other ) const
  {
    if( x != other.x )
    {
      std::cerr << "x=" << x << ", other.x=" << other.x << std::endl;
      return false;
    }
    if( y != other.y )
    {
      std::cerr << "y=" << y << ", other.y=" << other.y << std::endl;
      return false;
    }

    return true;
  }
};

const uint32_t AnotherCount = 32;

struct Another
{
  Another() = default;

  Another( bool )
  {
    for( uint32_t i = 0; i < AnotherCount; ++i )
      data[i] = Data2( i, i+1 );
  }

  std::map<std::uint32_t, Data2> data;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( data );
  }

  bool operator==( Another const & other ) const
  {
    auto iter  = data.begin();
    auto oiter = other.data.begin();
    for( ; iter != data.end(); ++iter, ++oiter )
    {
      if( !(iter->second == oiter->second) )
      {
        std::cerr << "Data mismatch at i=" << iter->first << std::endl;
        return false;
      }
    }

    return true;
  }
};

int main( int, char ** argv )
{
  std::vector<Another> vec_o;
  for( int i = 0; i < 5; ++i )
    vec_o.emplace_back( true );

  auto data_o = std::make_shared<Data>( 33, 64 );
  int32_t int_o = 7;

  std::cerr << "Portability test: " << argv[2] << "bit" << std::endl;

  if( std::string(argv[1]) == "load" )
  {
    std::ifstream is("portable.cereal", std::ios::binary);
    cereal::PortableBinaryInputArchive ar( is );

    std::vector<Another> vec_i;
    std::shared_ptr<Data> data_i;
    int32_t int_i;

    ar( int_i );

    if( int_i != int_o )
    {
      std::cerr << "in " << int_i << ", out: " << int_o << std::endl;
      return -1;
    }

    ar( vec_i );
    ar( data_i );

    if( vec_i != vec_o )
    {
      std::cerr << "Input vector did not equal output vector" << std::endl;
      return -1;
    }

    if( !(*data_i == *data_o) )
    {
      std::cerr << "Data did not match" << std::endl;
      return -1;
    }
  }
  else if( std::string(argv[1]) == "save" )
  {
    std::ofstream os("portable.cereal", std::ios::binary);
    cereal::PortableBinaryOutputArchive ar( os );

    ar( int_o );
    ar( vec_o );
    ar( data_o );
  }
  else // clean
  {
    std::remove( "portable.cereal" );
  }

  return 0;
}


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/portable_binary_archive.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "portable_binary_archive.hpp"

TEST_SUITE_BEGIN("portable_binary_archive");

#ifdef _MSC_VER
TEST_CASE("util")
{
  CHECK_EQ( cereal::util::demangledName<mynamespace::MyCustomClass>(), "struct mynamespace::MyCustomClass" );
}
#else
TEST_CASE("util")
{
  CHECK_EQ( cereal::util::demangledName<mynamespace::MyCustomClass>(), "mynamespace::MyCustomClass" );
}
#endif

TEST_CASE("portable_binary_archive_endian_conversions")
{
  // (last parameter is whether we load as little endian)
  test_endian_serialization<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>(
      cereal::PortableBinaryInputArchive::Options::BigEndian(), cereal::PortableBinaryOutputArchive::Options::BigEndian(), false );
  test_endian_serialization<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>(
      cereal::PortableBinaryInputArchive::Options::LittleEndian(), cereal::PortableBinaryOutputArchive::Options::BigEndian(), true );
  test_endian_serialization<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>(
      cereal::PortableBinaryInputArchive::Options::BigEndian(), cereal::PortableBinaryOutputArchive::Options::LittleEndian(), false );
  test_endian_serialization<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>(
      cereal::PortableBinaryInputArchive::Options::LittleEndian(), cereal::PortableBinaryOutputArchive::Options::LittleEndian(), true );
}

// Tests the default behavior to swap bytes to current machine's endianness
TEST_CASE("portable_binary_archive_default_behavior")
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(size_t i=0; i<100; ++i)
  {
    bool     o_bool   = random_value<uint8_t>(gen) % 2 ? true : false;
    uint8_t  o_uint8  = random_value<uint8_t>(gen);
    int8_t   o_int8   = random_value<int8_t>(gen);
    uint16_t o_uint16 = random_value<uint16_t>(gen);
    int16_t  o_int16  = random_value<int16_t>(gen);
    uint32_t o_uint32 = random_value<uint32_t>(gen);
    int32_t  o_int32  = random_value<int32_t>(gen);
    uint64_t o_uint64 = random_value<uint64_t>(gen);
    int64_t  o_int64  = random_value<int64_t>(gen);
    float    o_float  = random_value<float>(gen);
    double   o_double = random_value<double>(gen);

    // swap the bytes on all of the data
    CEREAL_TEST_SWAP_OUTPUT

    std::ostringstream os;
    {
      cereal::BinaryOutputArchive oar(os);
      // manually insert incorrect endian encoding
      oar(!cereal::portable_binary_detail::is_little_endian());

      oar(o_bool);
      oar(o_uint8);
      oar(o_int8);
      oar(o_uint16);
      oar(o_int16);
      oar(o_uint32);
      oar(o_int32);
      oar(o_uint64);
      oar(o_int64);
      oar(o_float);
      oar(o_double);
    }

    // swap back to original values
    CEREAL_TEST_SWAP_OUTPUT

    bool     i_bool   = false;
    uint8_t  i_uint8  = 0;
    int8_t   i_int8   = 0;
    uint16_t i_uint16 = 0;
    int16_t  i_int16  = 0;
    uint32_t i_uint32 = 0;
    int32_t  i_int32  = 0;
    uint64_t i_uint64 = 0;
    int64_t  i_int64  = 0;
    float    i_float  = 0;
    double   i_double = 0;

    std::istringstream is(os.str());
    {
      cereal::PortableBinaryInputArchive iar(is);
      iar(i_bool);
      iar(i_uint8);
      iar(i_int8);
      iar(i_uint16);
      iar(i_int16);
      iar(i_uint32);
      iar(i_int32);
      iar(i_uint64);
      iar(i_int64);
      iar(i_float);
      iar(i_double);
    }

    CEREAL_TEST_CHECK_EQUAL
  }
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/portable_binary_archive.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#define CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#include "common.hpp"

#include <cmath>

namespace mynamespace { struct MyCustomClass {}; }

template <class T>
inline void swapBytes( T & t )
{
  cereal::portable_binary_detail::swap_bytes<sizeof(T)>( reinterpret_cast<std::uint8_t*>(&t) );
}

// swaps all output data
#define CEREAL_TEST_SWAP_OUTPUT \
    swapBytes(o_bool);          \
    swapBytes(o_uint8);         \
    swapBytes(o_int8);          \
    swapBytes(o_uint16);        \
    swapBytes(o_int16);         \
    swapBytes(o_uint32);        \
    swapBytes(o_int32);         \
    swapBytes(o_uint64);        \
    swapBytes(o_int64);         \
    swapBytes(o_float);         \
    swapBytes(o_double);

#define CEREAL_TEST_CHECK_EQUAL                 \
    CHECK_EQ(i_bool   , o_bool);                \
    CHECK_EQ(i_uint8  , o_uint8);               \
    CHECK_EQ(i_int8   , o_int8);                \
    CHECK_EQ(i_uint16 , o_uint16);              \
    CHECK_EQ(i_int16  , o_int16);               \
    CHECK_EQ(i_uint32 , o_uint32);              \
    CHECK_EQ(i_int32  , o_int32);               \
    CHECK_EQ(i_uint64 , o_uint64);              \
    CHECK_EQ(i_int64  , o_int64);               \
    if( !std::isnan(i_float) && !std::isnan(o_float) ) CHECK_EQ(i_float , doctest::Approx(o_float).epsilon(1e-5F)); \
    if( !std::isnan(i_double) && !std::isnan(o_double) ) CHECK_EQ(i_double, doctest::Approx(o_double).epsilon(1e-5));

// Last parameter exists to keep everything hidden in options
template <class IArchive, class OArchive> inline
void test_endian_serialization( typename IArchive::Options const & iOptions, typename OArchive::Options const & oOptions, const std::uint8_t inputLittleEndian )
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(size_t i=0; i<100; ++i)
  {
    bool     o_bool   = random_value<uint8_t>(gen) % 2 ? true : false;
    uint8_t  o_uint8  = random_value<uint8_t>(gen);
    int8_t   o_int8   = random_value<int8_t>(gen);
    uint16_t o_uint16 = random_value<uint16_t>(gen);
    int16_t  o_int16  = random_value<int16_t>(gen);
    uint32_t o_uint32 = random_value<uint32_t>(gen);
    int32_t  o_int32  = random_value<int32_t>(gen);
    uint64_t o_uint64 = random_value<uint64_t>(gen);
    int64_t  o_int64  = random_value<int64_t>(gen);
    float    o_float  = random_value<float>(gen);
    double   o_double = random_value<double>(gen);

    std::vector<int32_t> o_vector(100);
    for(auto & elem : o_vector)
      elem = random_value<uint32_t>(gen);

    std::ostringstream os;
    {
      OArchive oar(os, oOptions);
      oar(o_bool);
      oar(o_uint8);
      oar(o_int8);
      oar(o_uint16);
      oar(o_int16);
      oar(o_uint32);
      oar(o_int32);
      oar(o_uint64);
      oar(o_int64);
      oar(o_float);
      oar(o_double);
      // We can't test vector directly here since we are artificially interfering with the endianness,
      // which can result in the size being incorrect
      oar(cereal::binary_data( o_vector.data(), static_cast<std::size_t>( o_vector.size() * sizeof(int32_t) ) ));
    }

    bool     i_bool   = false;
    uint8_t  i_uint8  = 0;
    int8_t   i_int8   = 0;
    uint16_t i_uint16 = 0;
    int16_t  i_int16  = 0;
    uint32_t i_uint32 = 0;
    int32_t  i_int32  = 0;
    uint64_t i_uint64 = 0;
    int64_t  i_int64  = 0;
    float    i_float  = 0;
    double   i_double = 0;
    std::vector<int32_t> i_vector(100);

    std::istringstream is(os.str());
    {
      IArchive iar(is, iOptions);
      iar(i_bool);
      iar(i_uint8);
      iar(i_int8);
      iar(i_uint16);
      iar(i_int16);
      iar(i_uint32);
      iar(i_int32);
      iar(i_uint64);
      iar(i_int64);
      iar(i_float);
      iar(i_double);
      iar(cereal::binary_data( i_vector.data(), static_cast<std::size_t>( i_vector.size() * sizeof(int32_t) ) ));
    }

    // Convert to big endian if we expect to read big and didn't start big
    if( cereal::portable_binary_detail::is_little_endian() ^ inputLittleEndian ) // Convert to little endian if
    {
      CEREAL_TEST_SWAP_OUTPUT
      for( auto & val : o_vector )
        swapBytes(val);
    }

    CEREAL_TEST_CHECK_EQUAL

    check_collection(i_vector, o_vector);
  }
}

#endif // CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/priority_queue.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "priority_queue.hpp"

TEST_SUITE_BEGIN("priority_queue");

TEST_CASE("binary_priority_queue")
{
  test_priority_queue<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_priority_queue")
{
  test_priority_queue<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_priority_queue")
{
  test_priority_queue<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_priority_queue")
{
  test_priority_queue<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/priority_queue.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_PRIORITY_QUEUE_H_
#define CEREAL_TEST_PRIORITY_QUEUE_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_priority_queue()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::priority_queue<int> o_podpriority_queue;
    for(int j=0; j<100; ++j)
      o_podpriority_queue.push(random_value<int>(gen));

    std::priority_queue<StructInternalSerialize> o_iserpriority_queue;
    for(int j=0; j<100; ++j)
      o_iserpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::priority_queue<StructInternalSplit> o_isplpriority_queue;
    for(int j=0; j<100; ++j)
      o_isplpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::priority_queue<StructExternalSerialize> o_eserpriority_queue;
    for(int j=0; j<100; ++j)
      o_eserpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::priority_queue<StructExternalSplit> o_esplpriority_queue;
    for(int j=0; j<100; ++j)
      o_esplpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podpriority_queue);
      oar(o_iserpriority_queue);
      oar(o_isplpriority_queue);
      oar(o_eserpriority_queue);
      oar(o_esplpriority_queue);
    }

    std::priority_queue<int> i_podpriority_queue;
    std::priority_queue<StructInternalSerialize> i_iserpriority_queue;
    std::priority_queue<StructInternalSplit>     i_isplpriority_queue;
    std::priority_queue<StructExternalSerialize> i_eserpriority_queue;
    std::priority_queue<StructExternalSplit>     i_esplpriority_queue;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podpriority_queue);
      iar(i_iserpriority_queue);
      iar(i_isplpriority_queue);
      iar(i_eserpriority_queue);
      iar(i_esplpriority_queue);
    }

    auto & i_podpriority_queue_c  = cereal::queue_detail::container(i_podpriority_queue);
    auto & i_iserpriority_queue_c = cereal::queue_detail::container(i_iserpriority_queue);
    auto & i_isplpriority_queue_c = cereal::queue_detail::container(i_isplpriority_queue);
    auto & i_eserpriority_queue_c = cereal::queue_detail::container(i_eserpriority_queue);
    auto & i_esplpriority_queue_c = cereal::queue_detail::container(i_esplpriority_queue);

    auto & o_podpriority_queue_c  = cereal::queue_detail::container(o_podpriority_queue);
    auto & o_iserpriority_queue_c = cereal::queue_detail::container(o_iserpriority_queue);
    auto & o_isplpriority_queue_c = cereal::queue_detail::container(o_isplpriority_queue);
    auto & o_eserpriority_queue_c = cereal::queue_detail::container(o_eserpriority_queue);
    auto & o_esplpriority_queue_c = cereal::queue_detail::container(o_esplpriority_queue);

    check_collection(i_podpriority_queue_c,  o_podpriority_queue_c);
    check_collection(i_iserpriority_queue_c, o_iserpriority_queue_c);
    check_collection(i_isplpriority_queue_c, o_isplpriority_queue_c);
    check_collection(i_eserpriority_queue_c, o_eserpriority_queue_c);
    check_collection(i_esplpriority_queue_c, o_esplpriority_queue_c);
  }
}

#endif // CEREAL_TEST_PRIORITY_QUEUE_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/queue.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "queue.hpp"

TEST_SUITE_BEGIN("queue");

TEST_CASE("binary_queue")
{
  test_queue<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_queue")
{
  test_queue<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_queue")
{
  test_queue<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_queue")
{
  test_queue<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/queue.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_QUEUE_H_
#define CEREAL_TEST_QUEUE_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_queue()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::queue<int> o_podqueue;
    for(int j=0; j<100; ++j)
      o_podqueue.push(random_value<int>(gen));

    std::queue<StructInternalSerialize> o_iserqueue;
    for(int j=0; j<100; ++j)
      o_iserqueue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::queue<StructInternalSplit> o_isplqueue;
    for(int j=0; j<100; ++j)
      o_isplqueue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::queue<StructExternalSerialize> o_eserqueue;
    for(int j=0; j<100; ++j)
      o_eserqueue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::queue<StructExternalSplit> o_esplqueue;
    for(int j=0; j<100; ++j)
      o_esplqueue.push({ random_value<int>(gen), random_value<int>(gen) });

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podqueue);
      oar(o_iserqueue);
      oar(o_isplqueue);
      oar(o_eserqueue);
      oar(o_esplqueue);
    }

    std::queue<int> i_podqueue;
    std::queue<StructInternalSerialize> i_iserqueue;
    std::queue<StructInternalSplit>     i_isplqueue;
    std::queue<StructExternalSerialize> i_eserqueue;
    std::queue<StructExternalSplit>     i_esplqueue;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podqueue);
      iar(i_iserqueue);
      iar(i_isplqueue);
      iar(i_eserqueue);
      iar(i_esplqueue);
    }

    auto & i_podqueue_c  = cereal::queue_detail::container(i_podqueue);
    auto & i_iserqueue_c = cereal::queue_detail::container(i_iserqueue);
    auto & i_isplqueue_c = cereal::queue_detail::container(i_isplqueue);
    auto & i_eserqueue_c = cereal::queue_detail::container(i_eserqueue);
    auto & i_esplqueue_c = cereal::queue_detail::container(i_esplqueue);

    auto & o_podqueue_c  = cereal::queue_detail::container(o_podqueue);
    auto & o_iserqueue_c = cereal::queue_detail::container(o_iserqueue);
    auto & o_isplqueue_c = cereal::queue_detail::container(o_isplqueue);
    auto & o_eserqueue_c = cereal::queue_detail::container(o_eserqueue);
    auto & o_esplqueue_c = cereal::queue_detail::container(o_esplqueue);

    check_collection(i_podqueue_c,  o_podqueue_c);
    check_collection(i_iserqueue_c, o_iserqueue_c);
    check_collection(i_isplqueue_c, o_isplqueue_c);
    check_collection(i_eserqueue_c, o_eserqueue_c);
    check_collection(i_esplqueue_c, o_esplqueue_c);
  }
}

#endif // CEREAL_TEST_QUEUE_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/run_portability_test.cmake
================================================
macro(EXEC_CMD_CHECK)
  message("running ${ARGN}")
  execute_process(COMMAND ${ARGN} RESULT_VARIABLE CMD_RESULT)
  if(CMD_RESULT)
    message(FATAL_ERROR "Error running ${ARGN}")
  endif()
endmacro()

set(PORTABILITY_TEST_32 "${PORTABILITY_TEST_DIR}/portability_test32")
set(PORTABILITY_TEST_64 "${PORTABILITY_TEST_DIR}/portability_test64")

exec_cmd_check(${PORTABILITY_TEST_64} save 64)
exec_cmd_check(${PORTABILITY_TEST_32} load 32)
exec_cmd_check(${PORTABILITY_TEST_32} save 32)
exec_cmd_check(${PORTABILITY_TEST_64} load 64)
exec_cmd_check(${PORTABILITY_TEST_64} remove 64)


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/run_valgrind.sh
================================================
#!/usr/bin/env bash

set -e

TESTS=./test_*

for f in $TESTS
  do
    valgrind --tool=memcheck --leak-check=full $f
  done


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/set.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "set.hpp"

TEST_SUITE_BEGIN("set");

TEST_CASE("binary_set")
{
  test_set<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_set")
{
  test_set<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_set")
{
  test_set<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_set")
{
  test_set<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/set.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_SET_H_
#define CEREAL_TEST_SET_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_set()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::set<int> o_podset;
    for(int j=0; j<100; ++j)
      o_podset.insert(random_value<int>(gen));

    std::set<StructInternalSerialize> o_iserset;
    for(int j=0; j<100; ++j)
      o_iserset.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::set<StructInternalSplit> o_isplset;
    for(int j=0; j<100; ++j)
      o_isplset.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::set<StructExternalSerialize> o_eserset;
    for(int j=0; j<100; ++j)
      o_eserset.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::set<StructExternalSplit> o_esplset;
    for(int j=0; j<100; ++j)
      o_esplset.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podset);
      oar(o_iserset);
      oar(o_isplset);
      oar(o_eserset);
      oar(o_esplset);
    }

    std::set<int> i_podset;
    std::set<StructInternalSerialize>   i_iserset;
    std::set<StructInternalSplit>        i_isplset;
    std::set<StructExternalSerialize> i_eserset;
    std::set<StructExternalSplit>       i_esplset;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podset);
      iar(i_iserset);
      iar(i_isplset);
      iar(i_eserset);
      iar(i_esplset);
    }

    check_collection(i_podset,  o_podset);
    check_collection(i_iserset, o_iserset);
    check_collection(i_isplset, o_isplset);
    check_collection(i_eserset, o_eserset);
    check_collection(i_esplset, o_esplset);
  }
}

#endif // CEREAL_TEST_SET_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/stack.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "stack.hpp"

TEST_SUITE_BEGIN("stack");

TEST_CASE("binary_stack")
{
  test_stack<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_stack")
{
  test_stack<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_stack")
{
  test_stack<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_stack")
{
  test_stack<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/stack.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_STACK_H_
#define CEREAL_TEST_STACK_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_stack()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::stack<int> o_podstack;
    for(int j=0; j<100; ++j)
      o_podstack.push(random_value<int>(gen));

    std::stack<StructInternalSerialize> o_iserstack;
    for(int j=0; j<100; ++j)
      o_iserstack.push({ random_value<int>(gen), random_value<int>(gen) });

    std::stack<StructInternalSplit> o_isplstack;
    for(int j=0; j<100; ++j)
      o_isplstack.push({ random_value<int>(gen), random_value<int>(gen) });

    std::stack<StructExternalSerialize> o_eserstack;
    for(int j=0; j<100; ++j)
      o_eserstack.push({ random_value<int>(gen), random_value<int>(gen) });

    std::stack<StructExternalSplit> o_esplstack;
    for(int j=0; j<100; ++j)
      o_esplstack.push({ random_value<int>(gen), random_value<int>(gen) });

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podstack);
      oar(o_iserstack);
      oar(o_isplstack);
      oar(o_eserstack);
      oar(o_esplstack);
    }

    std::stack<int> i_podstack;
    std::stack<StructInternalSerialize> i_iserstack;
    std::stack<StructInternalSplit>     i_isplstack;
    std::stack<StructExternalSerialize> i_eserstack;
    std::stack<StructExternalSplit>     i_esplstack;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podstack);
      iar(i_iserstack);
      iar(i_isplstack);
      iar(i_eserstack);
      iar(i_esplstack);
    }

    auto & i_podstack_c  = cereal::stack_detail::container(i_podstack);
    auto & i_iserstack_c = cereal::stack_detail::container(i_iserstack);
    auto & i_isplstack_c = cereal::stack_detail::container(i_isplstack);
    auto & i_eserstack_c = cereal::stack_detail::container(i_eserstack);
    auto & i_esplstack_c = cereal::stack_detail::container(i_esplstack);

    auto & o_podstack_c  = cereal::stack_detail::container(o_podstack);
    auto & o_iserstack_c = cereal::stack_detail::container(o_iserstack);
    auto & o_isplstack_c = cereal::stack_detail::container(o_isplstack);
    auto & o_eserstack_c = cereal::stack_detail::container(o_eserstack);
    auto & o_esplstack_c = cereal::stack_detail::container(o_esplstack);

    check_collection(i_podstack_c,  o_podstack_c );
    check_collection(i_iserstack_c, o_iserstack_c);
    check_collection(i_isplstack_c, o_isplstack_c);
    check_collection(i_eserstack_c, o_eserstack_c);
    check_collection(i_esplstack_c, o_esplstack_c);
  }
}

#endif // CEREAL_TEST_STACK_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "structs.hpp"

TEST_SUITE_BEGIN("structs");

TEST_CASE("binary_structs")
{
  test_structs<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_structs")
{
  test_structs<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_structs")
{
  test_structs<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_structs")
{
  test_structs<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_STRUCTS_H_
#define CEREAL_TEST_STRUCTS_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_structs()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    StructInternalSerialize o_iser = { random_value<int>(gen), random_value<int>(gen) };
    StructInternalSplit     o_ispl = { random_value<int>(gen), random_value<int>(gen) };
    StructExternalSerialize o_eser = { random_value<int>(gen), random_value<int>(gen) };
    StructExternalSplit     o_espl = { random_value<int>(gen), random_value<int>(gen) };

    std::ostringstream os;
    {
      OArchive oar(os);
      oar( o_iser, o_ispl, o_eser, o_espl);
    }

    StructInternalSerialize i_iser;
    StructInternalSplit     i_ispl;
    StructExternalSerialize i_eser;
    StructExternalSplit     i_espl;

    std::istringstream is(os.str());
    {
      IArchive iar(is);
      iar( i_iser, i_ispl, i_eser, i_espl);
    }

    CHECK_EQ(i_iser, o_iser);
    CHECK_EQ(i_ispl, o_ispl);
    CHECK_EQ(i_eser, o_eser);
    CHECK_EQ(i_espl, o_espl);
  }
}

#endif // CEREAL_TEST_STRUCTS_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs_minimal.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "structs_minimal.hpp"

TEST_SUITE_BEGIN("structs_minimal");

TEST_CASE("binary_structs_minimal")
{
  test_structs_minimal<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_structs_minimal")
{
  test_structs_minimal<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_structs_minimal")
{
  test_structs_minimal<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_structs_minimal")
{
  test_structs_minimal<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs_minimal.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_STRUCTS_MINIMAL_H_
#define CEREAL_TEST_STRUCTS_MINIMAL_H_
#include "common.hpp"

class MemberMinimal
{
  public:
    MemberMinimal() = default;
    MemberMinimal( std::string const & str ) : x( str ) {}

  protected:
    friend class cereal::access;

    template <class Archive>
    std::string save_minimal( Archive const & ) const
    {
      return x;
    }

    template <class Archive>
    void load_minimal( Archive const &, std::string const & str )
    {
      x = str;
    }

  public:
    std::string x;
};

class MemberMinimalVersioned
{
  public:
    MemberMinimalVersioned() = default;
    MemberMinimalVersioned( double d ) : x( d ) {}

  protected:
    friend class cereal::access;

    template <class Archive>
    double save_minimal( Archive const &, const std::uint32_t ) const
    {
      return x;
    }

    template <class Archive>
    void load_minimal( Archive const &, double const & d, const std::uint32_t )
    {
      x = d;
    }

  public:
    double x;
};

struct NonMemberMinimal
{
  NonMemberMinimal() = default;
  NonMemberMinimal( std::uint32_t xx ) : x(xx) {}
  std::uint32_t x;
};

template <class Archive> inline
std::uint32_t save_minimal( Archive const &, NonMemberMinimal const & nmm )
{
  return nmm.x;
}

template <class Archive> inline
void load_minimal( Archive const &, NonMemberMinimal & nmm, std::uint32_t const & data )
{
  nmm.x = data;
}

struct NonMemberMinimalVersioned
{
  NonMemberMinimalVersioned() = default;
  NonMemberMinimalVersioned( bool xx ) : x(xx) {}
  bool x;
};

template <class Archive> inline
bool save_minimal( Archive const &, NonMemberMinimalVersioned const & nmm, std::uint32_t const )
{
  return nmm.x;
}

template <class Archive> inline
void load_minimal( Archive const &, NonMemberMinimalVersioned & nmm, bool const & data, std::uint32_t const )
{
  nmm.x = data;
}

struct TestStruct
{
  TestStruct() = default;
  TestStruct( std::string const & s, double d, std::uint32_t u, bool b ) :
    mm(s), mmv(d), nmm(u), nmmv(b) {}

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( mm, mmv );
    ar( nmm, nmmv );
  }

  MemberMinimal mm;
  MemberMinimalVersioned mmv;
  NonMemberMinimal nmm;
  NonMemberMinimalVersioned nmmv;
};

struct Issue79Struct
{
  Issue79Struct() = default;
  Issue79Struct( std::int32_t xx ) : x(xx) {}
  std::int32_t x;
};

template <class Archive, cereal::traits::DisableIf<std::is_same<Archive, cereal::BinaryOutputArchive>::value ||
                                                   std::is_same<Archive, cereal::PortableBinaryOutputArchive>::value> = cereal::traits::sfinae>
inline std::string save_minimal( Archive const &, Issue79Struct const & val )
{
  return std::to_string( val.x );
}

template <class Archive, cereal::traits::DisableIf<std::is_same<Archive, cereal::BinaryInputArchive>::value ||
                                                   std::is_same<Archive, cereal::PortableBinaryInputArchive>::value> = cereal::traits::sfinae>
inline void load_minimal( Archive const &, Issue79Struct & val, std::string const & str )
{
  val.x = std::stoi( str );
}

template <class Archive, cereal::traits::EnableIf<std::is_same<Archive, cereal::BinaryOutputArchive>::value ||
                                                  std::is_same<Archive, cereal::PortableBinaryOutputArchive>::value> = cereal::traits::sfinae>
inline std::int32_t save_minimal( Archive const &, Issue79Struct const & val )
{
  return val.x;
}

template <class Archive, cereal::traits::EnableIf<std::is_same<Archive, cereal::BinaryInputArchive>::value ||
                                                  std::is_same<Archive, cereal::PortableBinaryInputArchive>::value> = cereal::traits::sfinae>
inline void load_minimal( Archive const &, Issue79Struct & val, std::int32_t const & xx )
{
  val.x = xx;
}

struct Issue79StructInternal
{
  Issue79StructInternal() = default;
  Issue79StructInternal( std::int32_t xx ) : x(xx) {}
  std::int32_t x;

  template <class Archive, cereal::traits::DisableIf<std::is_same<Archive, cereal::BinaryOutputArchive>::value ||
                                                     std::is_same<Archive, cereal::PortableBinaryOutputArchive>::value> = cereal::traits::sfinae>
  inline std::string save_minimal( Archive const & ) const
  {
    return std::to_string( x );
  }

  template <class Archive, cereal::traits::DisableIf<std::is_same<Archive, cereal::BinaryInputArchive>::value ||
                                                     std::is_same<Archive, cereal::PortableBinaryInputArchive>::value> = cereal::traits::sfinae>
  inline void load_minimal( Archive const &, std::string const & str )
  {
    x = std::stoi( str );
  }

  template <class Archive, cereal::traits::EnableIf<std::is_same<Archive, cereal::BinaryOutputArchive>::value ||
                                                    std::is_same<Archive, cereal::PortableBinaryOutputArchive>::value> = cereal::traits::sfinae>
  inline std::int32_t save_minimal( Archive const & ) const
  {
    return x;
  }

  template <class Archive, cereal::traits::EnableIf<std::is_same<Archive, cereal::BinaryInputArchive>::value ||
                                                    std::is_same<Archive, cereal::PortableBinaryInputArchive>::value> = cereal::traits::sfinae>
  inline void load_minimal( Archive const &, std::int32_t const & xx )
  {
    x = xx;
  }
};

template <class IArchive, class OArchive> inline
void test_structs_minimal()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    TestStruct o_struct = { random_basic_string<char>(gen), random_value<double>(gen),
                            random_value<std::uint32_t>(gen), random_value<uint8_t>(gen) % 2 ? true : false };

    Issue79Struct o_struct2 = { random_value<std::int32_t>(gen) };
    Issue79StructInternal o_struct3 = { random_value<std::int32_t>(gen) };

    std::ostringstream os;
    {
      OArchive oar(os);
      oar( o_struct );
      oar( o_struct2 );
      oar( o_struct3 );
    }

    decltype(o_struct) i_struct;
    decltype(o_struct2) i_struct2;
    decltype(o_struct3) i_struct3;

    std::istringstream is(os.str());
    {
      IArchive iar(is);
      iar( i_struct );
      iar( i_struct2 );
      iar( i_struct3 );
    }

    CHECK_EQ(o_struct.mm.x, i_struct.mm.x);
    CHECK_EQ(o_struct.mmv.x, doctest::Approx(i_struct.mmv.x).epsilon(1e-5));

    CHECK_EQ(o_struct.nmm.x, i_struct.nmm.x);
    CHECK_EQ(o_struct.nmmv.x, i_struct.nmmv.x);

    CHECK_EQ(o_struct2.x, i_struct2.x);

    CHECK_EQ(o_struct3.x, i_struct3.x);
  }
}

#endif // CEREAL_TEST_STRUCTS_MINIMAL_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs_specialized.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "structs_specialized.hpp"

TEST_SUITE_BEGIN("structs_specialized");

TEST_CASE("binary_structs_specialized")
{
  test_structs_specialized<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_structs_specialized")
{
  test_structs_specialized<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_structs_specialized")
{
  test_structs_specialized<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_structs_specialized")
{
  test_structs_specialized<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/structs_specialized.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_STRUCTS_MINIMAL_H_
#define CEREAL_TEST_STRUCTS_MINIMAL_H_
#include "common.hpp"

struct BogusBase
{
  template <class Archive>
  void serialize( Archive & ) {}

  template <class Archive>
  void save( Archive & ) const {}

  template <class Archive>
  void load( Archive & ) {}

  template <class Archive>
  int save_minimal( Archive const & ) const { return 0; }

  template <class Archive>
  void load_minimal( Archive const &, int const & ) {}
};

struct BogusBaseVersioned
{
  template <class Archive>
  void serialize( Archive &, const std::uint32_t ) {}

  template <class Archive>
  void save( Archive &, const std::uint32_t ) const {}

  template <class Archive>
  void load( Archive &, const std::uint32_t ) {}

  template <class Archive>
  int save_minimal( Archive const &, const std::uint32_t ) const { return 0; }

  template <class Archive>
  void load_minimal( Archive const &, int const &, const std::uint32_t ) {}
};

struct BogusBasePolymorphic
{
  template <class Archive>
  void serialize( Archive & ) {}

  virtual void doesNothing() {}

  virtual ~BogusBasePolymorphic() {}
};

class SpecializedMSerialize : public BogusBase
{
  public:
    SpecializedMSerialize() = default;
    SpecializedMSerialize( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    void serialize( Archive & ar )
    {
      ar( x );
    }
};

class SpecializedMSerializeVersioned : public BogusBaseVersioned
{
  public:
    SpecializedMSerializeVersioned() = default;
    SpecializedMSerializeVersioned( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    void serialize( Archive & ar, const std::uint32_t )
    {
      ar( x );
    }
};

class SpecializedMSplit : public BogusBase
{
  public:
    SpecializedMSplit() = default;
    SpecializedMSplit( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    void save( Archive & ar ) const
    {
      ar( x );
    }

    template <class Archive>
    void load( Archive & ar )
    {
      ar( x );
    }
};

class SpecializedMSplitVersioned : public BogusBaseVersioned
{
  public:
    SpecializedMSplitVersioned() = default;
    SpecializedMSplitVersioned( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    void save( Archive & ar, const std::uint32_t ) const
    {
      ar( x );
    }

    template <class Archive>
    void load( Archive & ar, const std::uint32_t )
    {
      ar( x );
    }
};

class SpecializedMSplitPolymorphic : public BogusBasePolymorphic
{
  public:
    SpecializedMSplitPolymorphic() = default;
    SpecializedMSplitPolymorphic( int xx ) : x(xx) {}

    virtual ~SpecializedMSplitPolymorphic() {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    void save( Archive & ar ) const
    {
      ar( x );
    }

    template <class Archive>
    void load( Archive & ar )
    {
      ar( x );
    }
};

class SpecializedMSplitMinimal : public BogusBase
{
  public:
    SpecializedMSplitMinimal() = default;
    SpecializedMSplitMinimal( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    int save_minimal( Archive const & ) const
    {
      return x;
    }

    template <class Archive>
    void load_minimal( Archive const &, int const & value )
    {
      x = value;
    }
};

class SpecializedMSplitVersionedMinimal : public BogusBaseVersioned
{
  public:
    SpecializedMSplitVersionedMinimal() = default;
    SpecializedMSplitVersionedMinimal( int xx ) : x(xx) {}

    int x;

  private:
    friend class cereal::access;
    template <class Archive>
    int save_minimal( Archive const &, const std::uint32_t ) const
    {
      return x;
    }

    template <class Archive>
    void load_minimal( Archive const &, int const & value, const std::uint32_t )
    {
      x = value;
    }
};

class SpecializedNMSerialize : public BogusBase
{
  public:
    SpecializedNMSerialize() = default;
    SpecializedNMSerialize( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void serialize( Archive & ar, SpecializedNMSerialize & s )
{
  ar( s.x );
}

class SpecializedNMSerializeVersioned : public BogusBaseVersioned
{
  public:
    SpecializedNMSerializeVersioned() = default;
    SpecializedNMSerializeVersioned( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void serialize( Archive & ar, SpecializedNMSerializeVersioned & s )
{
  ar( s.x );
}

class SpecializedNMSplit : public BogusBase
{
  public:
    SpecializedNMSplit() = default;
    SpecializedNMSplit( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void load( Archive & ar, SpecializedNMSplit & s )
{
  ar( s.x );
}

template <class Archive>
void save( Archive & ar, SpecializedNMSplit const & s )
{
  ar( s.x );
}

class SpecializedNMSplitVersioned : public BogusBaseVersioned
{
  public:
    SpecializedNMSplitVersioned() = default;
    SpecializedNMSplitVersioned( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void load( Archive & ar, SpecializedNMSplitVersioned & s, const std::uint32_t )
{
  ar( s.x );
}

template <class Archive>
void save( Archive & ar, SpecializedNMSplitVersioned const & s, const std::uint32_t )
{
  ar( s.x );
}

class SpecializedNMSplitMinimal : public BogusBase
{
  public:
    SpecializedNMSplitMinimal() = default;
    SpecializedNMSplitMinimal( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void load_minimal( Archive const &, SpecializedNMSplitMinimal & s, int const & value )
{
  s.x = value;
}

template <class Archive>
int save_minimal( Archive const &, SpecializedNMSplitMinimal const & s )
{
  return s.x;
}

class SpecializedNMSplitVersionedMinimal : public BogusBaseVersioned
{
  public:
    SpecializedNMSplitVersionedMinimal() = default;
    SpecializedNMSplitVersionedMinimal( int xx ) : x(xx) {}

    int x;
};

template <class Archive>
void load_minimal( Archive const &, SpecializedNMSplitVersionedMinimal & s, int const & value, const std::uint32_t )
{
  s.x = value;
}

template <class Archive>
int save_minimal( Archive const &, SpecializedNMSplitVersionedMinimal const & s, const std::uint32_t )
{
  return s.x;
}

namespace cereal
{
  template <class Archive> struct specialize<Archive, SpecializedMSerialize, cereal::specialization::member_serialize> {};
  template <class Archive> struct specialize<Archive, SpecializedMSerializeVersioned, cereal::specialization::member_serialize> {};

  template <class Archive> struct specialize<Archive, SpecializedMSplit, cereal::specialization::member_load_save> {};
  template <class Archive> struct specialize<Archive, SpecializedMSplitVersioned, cereal::specialization::member_load_save> {};
  template <class Archive> struct specialize<Archive, SpecializedMSplitPolymorphic, cereal::specialization::member_load_save> {};

  template <class Archive> struct specialize<Archive, SpecializedMSplitMinimal, cereal::specialization::member_load_save_minimal> {};
  template <class Archive> struct specialize<Archive, SpecializedMSplitVersionedMinimal, cereal::specialization::member_load_save_minimal> {};

  template <class Archive> struct specialize<Archive, SpecializedNMSerialize, cereal::specialization::non_member_serialize> {};
  template <class Archive> struct specialize<Archive, SpecializedNMSerializeVersioned, cereal::specialization::non_member_serialize> {};

  template <class Archive> struct specialize<Archive, SpecializedNMSplit, cereal::specialization::non_member_load_save> {};
  template <class Archive> struct specialize<Archive, SpecializedNMSplitVersioned, cereal::specialization::non_member_load_save> {};

  template <class Archive> struct specialize<Archive, SpecializedNMSplitMinimal,
           cereal::specialization::non_member_load_save_minimal> {};
  template <class Archive> struct specialize<Archive, SpecializedNMSplitVersionedMinimal,
           cereal::specialization::non_member_load_save_minimal> {};
}

CEREAL_REGISTER_TYPE(SpecializedMSplitPolymorphic)
CEREAL_REGISTER_POLYMORPHIC_RELATION(BogusBasePolymorphic, SpecializedMSplitPolymorphic)

template <class IArchive, class OArchive> inline
void test_structs_specialized()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    SpecializedMSerialize               o_iser          = { random_value<int>(gen) };
    SpecializedMSerializeVersioned      o_iserv         = { random_value<int>(gen) };

    SpecializedMSplit                   o_ispl          = { random_value<int>(gen) };
    SpecializedMSplitVersioned          o_isplv         = { random_value<int>(gen) };

    // added re: issue #180
    std::shared_ptr<BogusBasePolymorphic> o_shared_ispl = std::make_shared<SpecializedMSplitPolymorphic>( random_value<int>(gen) );

    SpecializedMSplitMinimal            o_isplm         = { random_value<int>(gen) };
    SpecializedMSplitVersionedMinimal   o_isplvm        = { random_value<int>(gen) };

    SpecializedNMSerialize              o_eser          = { random_value<int>(gen) };
    SpecializedNMSerializeVersioned     o_eserv         = { random_value<int>(gen) };

    SpecializedNMSplit                  o_espl          = { random_value<int>(gen) };
    SpecializedNMSplitVersioned         o_esplv         = { random_value<int>(gen) };

    SpecializedNMSplitMinimal           o_esplm         = { random_value<int>(gen) };
    SpecializedNMSplitVersionedMinimal  o_esplvm        = { random_value<int>(gen) };


    std::ostringstream os;
    {
      OArchive oar(os);

      oar( o_iser, o_iserv,
           o_ispl, o_isplv, o_shared_ispl,
           o_isplm, o_isplvm,
           o_eser, o_eserv,
           o_espl, o_esplv,
           o_esplm, o_esplvm );
    }

    decltype(o_iser) i_iser;
    decltype(o_iserv) i_iserv;

    decltype(o_ispl) i_ispl;
    decltype(o_isplv) i_isplv;

    decltype(o_shared_ispl) i_shared_ispl;

    decltype(o_isplm) i_isplm;
    decltype(o_isplvm) i_isplvm;

    decltype(o_eser) i_eser;
    decltype(o_eserv) i_eserv;

    decltype(o_espl) i_espl;
    decltype(o_esplv) i_esplv;

    decltype(o_esplm) i_esplm;
    decltype(o_esplvm) i_esplvm;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( i_iser, i_iserv,
           i_ispl, i_isplv, i_shared_ispl,
           i_isplm, i_isplvm,
           i_eser, i_eserv,
           i_espl, i_esplv,
           i_esplm, i_esplvm );
    }

    CHECK_EQ(i_iser.x, o_iser.x);
    CHECK_EQ(i_iserv.x, o_iserv.x);

    CHECK_EQ(i_ispl.x, o_ispl.x);
    CHECK_EQ(i_isplv.x, o_isplv.x);

    CHECK_EQ(dynamic_cast<SpecializedMSplitPolymorphic*>(i_shared_ispl.get())->x, dynamic_cast<SpecializedMSplitPolymorphic*>(o_shared_ispl.get())->x);

    CHECK_EQ(i_isplm.x, o_isplm.x);
    CHECK_EQ(i_isplvm.x, o_isplvm.x);

    CHECK_EQ(i_eser.x, o_eser.x);
    CHECK_EQ(i_eserv.x, o_eserv.x);

    CHECK_EQ(i_espl.x, o_espl.x);
    CHECK_EQ(i_esplv.x, o_esplv.x);

    CHECK_EQ(i_esplm.x, o_esplm.x);
    CHECK_EQ(i_esplvm.x, o_esplvm.x);
  }
}

#endif // CEREAL_TEST_STRUCTS_SPECIALIZED_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/tuple.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "tuple.hpp"

TEST_SUITE_BEGIN("tuple");

TEST_CASE("binary_tuple")
{
  test_tuple<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_tuple")
{
  test_tuple<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_tuple")
{
  test_tuple<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_tuple")
{
  test_tuple<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/tuple.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_TUPLE_H_
#define CEREAL_TEST_TUPLE_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_tuple()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rng = [&](){ return random_value<int>(gen); };

  for(int ii=0; ii<100; ++ii)
  {
    auto o_podtuple = std::make_tuple( rng(), rng(), rng(), rng() );
    auto o_podtuple11 = std::make_tuple( rng(), rng(), rng(), rng(), rng(), rng(),
                                         rng(), rng(), rng(), rng(), rng() );
    auto o_isertuple = std::make_tuple( StructInternalSerialize( rng(), rng() ),
        StructInternalSerialize( rng(), rng() ),
        StructInternalSerialize( rng(), rng() ),
        StructInternalSerialize( rng(), rng() ) );
    auto o_ispltuple = std::make_tuple( StructInternalSplit( rng(), rng() ),
        StructInternalSplit( rng(), rng() ),
        StructInternalSplit( rng(), rng() ),
        StructInternalSplit( rng(), rng() ) );
    auto o_esertuple = std::make_tuple( StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ) );
    auto o_espltuple = std::make_tuple( StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ),
        StructExternalSerialize( rng(), rng() ) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podtuple);
      oar(o_podtuple11);
      oar(o_isertuple);
      oar(o_ispltuple);
      oar(o_esertuple);
      oar(o_espltuple);
    }

    decltype( o_podtuple   ) i_podtuple;
    decltype( o_podtuple11 ) i_podtuple11;
    decltype( o_isertuple  ) i_isertuple;
    decltype( o_ispltuple  ) i_ispltuple;
    decltype( o_esertuple  ) i_esertuple;
    decltype( o_espltuple  ) i_espltuple;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podtuple);
      iar(i_podtuple11);
      iar(i_isertuple);
      iar(i_ispltuple);
      iar(i_esertuple);
      iar(i_espltuple);
    }

    CHECK_EQ( i_podtuple,   o_podtuple);
    CHECK_EQ( i_podtuple11, o_podtuple11);
    CHECK_EQ( i_isertuple,  o_isertuple);
    CHECK_EQ( i_ispltuple,  o_ispltuple);
    CHECK_EQ( i_esertuple,  o_esertuple);
    CHECK_EQ( i_espltuple,  o_espltuple);
  }
}

#endif // CEREAL_TEST_TUPLE_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_loads.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "unordered_loads.hpp"

TEST_SUITE_BEGIN("unordered_loads");

TEST_CASE("xml_unordered_loads")
{
  test_unordered_loads<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_unordered_loads")
{
  test_unordered_loads<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_loads.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_UNORDERED_LOADS_H_
#define CEREAL_TEST_UNORDERED_LOADS_H_
#include "common.hpp"

struct unordered_naming
{
  int x;
  int xx;
  int y;
  int z;

  template <class Archive>
  void save( Archive & ar ) const
  {
    ar( CEREAL_NVP(x),
        CEREAL_NVP(z),
        CEREAL_NVP(y),
        CEREAL_NVP(xx) );
  }

  template <class Archive>
  void load( Archive & ar )
  {
    ar( x,
        CEREAL_NVP(y),
        CEREAL_NVP(z),
        CEREAL_NVP(xx) );
  }

  bool operator==( unordered_naming const & other ) const
  {
    return x == other.x && xx == other.xx && y == other.y && z == other.z;
  }
};

std::ostream& operator<<(std::ostream& os, unordered_naming const & s)
{
  os << "[x: " << s.x << " xx: " << s.xx << " y: " << s.y << " z: " << s.z << "]";
  return os;
}

template <class IArchive, class OArchive> inline
void test_unordered_loads()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rngB = [&](){ return random_value<int>( gen ) % 2 == 0; };
  auto rngI = [&](){ return random_value<int>( gen ); };
  auto rngF = [&](){ return random_value<float>( gen ); };
  auto rngD = [&](){ return random_value<double>( gen ); };
  auto rngS = [&](){ return random_basic_string<char>( gen ); };

  for(int ii=0; ii<100; ++ii)
  {
    auto const name1 = rngS();
    auto const name2 = rngS();
    auto const name3 = rngS();
    auto const name4 = rngS();
    auto const name5 = rngS();
    auto const name6 = rngS();
    auto const name7 = rngS();

    int o_int1 = rngI();
    double o_double2 = rngD();
    std::vector<bool> o_vecbool3 = { rngB(), rngB(), rngB(), rngB(), rngB() };
    int o_int4 = rngI();
    int o_int5 = rngI();
    int o_int6 = rngI();
    std::pair<float, unordered_naming> o_un7;
    o_un7.first = rngF();
    o_un7.second.x = rngI();
    o_un7.second.xx = rngI();
    o_un7.second.y = rngI();
    o_un7.second.z = rngI();

    std::ostringstream os;
    {
      OArchive oar(os);

      oar( cereal::make_nvp( name1, o_int1 ),
           cereal::make_nvp( name2, o_double2 ),
           cereal::make_nvp( name3, o_vecbool3 ),
           cereal::make_nvp( name4, o_int4 ),
           cereal::make_nvp( name5, o_int5 ),
           cereal::make_nvp( name6, o_int6 ),
           cereal::make_nvp( name7, o_un7 ) );
    }

    decltype(o_int1) i_int1;
    decltype(o_double2) i_double2;
    decltype(o_vecbool3) i_vecbool3;
    decltype(o_int4) i_int4;
    decltype(o_int5) i_int5;
    decltype(o_int6) i_int6;
    decltype(o_un7) i_un7;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar( cereal::make_nvp( name7, i_un7 ),
           cereal::make_nvp( name2, i_double2 ),
           cereal::make_nvp( name4, i_int4 ),
           cereal::make_nvp( name3, i_vecbool3 ),
           cereal::make_nvp( name1, i_int1 ),
           cereal::make_nvp( name5, i_int5 ),
           i_int6 );
    }

    CHECK_EQ(o_int1, i_int1);
    CHECK_EQ(o_double2, doctest::Approx(o_double2).epsilon(1e-5));
    CHECK_EQ(o_vecbool3.size(), i_vecbool3.size());
    check_collection(i_vecbool3, o_vecbool3);
    CHECK_EQ(o_int4, i_int4);
    CHECK_EQ(o_int5, i_int5);
    CHECK_EQ(o_int6, i_int6);
    CHECK_EQ(o_un7.first, i_un7.first);
    CHECK_EQ(o_un7.second, i_un7.second);
  }
}

#endif // CEREAL_TEST_UNORDERED_LOADS_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_map.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "unordered_map.hpp"

TEST_SUITE_BEGIN("unordered_map");

TEST_CASE("binary_unordered_map")
{
  test_unordered_map<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_unordered_map")
{
  test_unordered_map<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_unordered_map")
{
  test_unordered_map<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_unordered_map")
{
  test_unordered_map<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_map.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_UNORDERED_MAP_H_
#define CEREAL_TEST_UNORDERED_MAP_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_unordered_map()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::unordered_map<std::string, int> o_podunordered_map;
    for(int j=0; j<100; ++j)
      o_podunordered_map.insert({random_value<std::string>(gen), random_value<int>(gen)});

    std::unordered_map<uint16_t, StructInternalSerialize> o_iserunordered_map;
    for(int j=0; j<100; ++j)
      o_iserunordered_map.insert({random_value<uint16_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::unordered_map<uint16_t, StructInternalSplit> o_isplunordered_map;
    for(int j=0; j<100; ++j)
      o_isplunordered_map.insert({random_value<uint16_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::unordered_map<uint32_t, StructExternalSerialize> o_eserunordered_map;
    for(int j=0; j<100; ++j)
      o_eserunordered_map.insert({random_value<uint32_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});

    std::unordered_map<int8_t, StructExternalSplit> o_esplunordered_map;
    for(int j=0; j<100; ++j)
      o_esplunordered_map.insert({random_value<char>(gen),  { random_value<int>(gen), random_value<int>(gen) }});

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podunordered_map);
      oar(o_iserunordered_map);
      oar(o_isplunordered_map);
      oar(o_eserunordered_map);
      oar(o_esplunordered_map);
    }

    std::unordered_map<std::string, int> i_podunordered_map;
    std::unordered_map<uint16_t, StructInternalSerialize>   i_iserunordered_map;
    std::unordered_map<uint16_t, StructInternalSplit>        i_isplunordered_map;
    std::unordered_map<uint32_t, StructExternalSerialize> i_eserunordered_map;
    std::unordered_map<int8_t, StructExternalSplit>       i_esplunordered_map;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podunordered_map);
      iar(i_iserunordered_map);
      iar(i_isplunordered_map);
      iar(i_eserunordered_map);
      iar(i_esplunordered_map);
    }

    for(auto const & p : i_podunordered_map)
    {
      auto v = o_podunordered_map.find(p.first);
      CHECK_NE(v, o_podunordered_map.end());
      CHECK_EQ(p.second, v->second);
    }

    for(auto const & p : i_iserunordered_map)
    {
      auto v = o_iserunordered_map.find(p.first);
      CHECK_NE(v, o_iserunordered_map.end());
      CHECK_EQ(p.second, v->second);
    }

    for(auto const & p : i_isplunordered_map)
    {
      auto v = o_isplunordered_map.find(p.first);
      CHECK_NE(v, o_isplunordered_map.end());
      CHECK_EQ(p.second, v->second);
    }

    for(auto const & p : i_eserunordered_map)
    {
      auto v = o_eserunordered_map.find(p.first);
      CHECK_NE(v, o_eserunordered_map.end());
      CHECK_EQ(p.second, v->second);
    }

    for(auto const & p : i_esplunordered_map)
    {
      auto v = o_esplunordered_map.find(p.first);
      CHECK_NE(v, o_esplunordered_map.end());
      CHECK_EQ(p.second, v->second);
    }
  }
}

#endif // CEREAL_TEST_UNORDERED_MAP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_multimap.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "unordered_multimap.hpp"

TEST_SUITE_BEGIN("unordered_multimap");

TEST_CASE("binary_unordered_multimap")
{
  test_unordered_multimap<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_unordered_multimap")
{
  test_unordered_multimap<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_unordered_multimap")
{
  test_unordered_multimap<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_unordered_multimap")
{
  test_unordered_multimap<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_multimap.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_UNORDERED_MULTIMAP_H_
#define CEREAL_TEST_UNORDERED_MULTIMAP_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_unordered_multimap()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::unordered_multimap<std::string, int> o_podunordered_multimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<std::string>(gen);
      o_podunordered_multimap.insert({key, random_value<int>(gen)});
      o_podunordered_multimap.insert({key, random_value<int>(gen)});
    }

    std::unordered_multimap<int, StructInternalSerialize> o_iserunordered_multimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<int>(gen);
      o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::unordered_multimap<int, StructInternalSplit> o_isplunordered_multimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<int>(gen);
      o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::unordered_multimap<uint32_t, StructExternalSerialize> o_eserunordered_multimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<uint32_t>(gen);
      o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
      o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::unordered_multimap<int8_t, StructExternalSplit> o_esplunordered_multimap;
    for(int j=0; j<100; ++j)
    {
      auto key = random_value<char>(gen);
      o_esplunordered_multimap.insert({key,  { random_value<int>(gen), random_value<int>(gen) }});
      o_esplunordered_multimap.insert({key,  { random_value<int>(gen), random_value<int>(gen) }});
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podunordered_multimap);
      oar(o_iserunordered_multimap);
      oar(o_isplunordered_multimap);
      oar(o_eserunordered_multimap);
      oar(o_esplunordered_multimap);
    }

    std::unordered_multimap<std::string, int> i_podunordered_multimap;
    std::unordered_multimap<int, StructInternalSerialize>   i_iserunordered_multimap;
    std::unordered_multimap<int, StructInternalSplit>        i_isplunordered_multimap;
    std::unordered_multimap<uint32_t, StructExternalSerialize> i_eserunordered_multimap;
    std::unordered_multimap<int8_t, StructExternalSplit>       i_esplunordered_multimap;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podunordered_multimap);
      iar(i_iserunordered_multimap);
      iar(i_isplunordered_multimap);
      iar(i_eserunordered_multimap);
      iar(i_esplunordered_multimap);
    }

    CHECK_EQ(i_podunordered_multimap.size(),  o_podunordered_multimap.size());
    CHECK_EQ(i_iserunordered_multimap.size(), o_iserunordered_multimap.size());
    CHECK_EQ(i_isplunordered_multimap.size(), o_isplunordered_multimap.size());
    CHECK_EQ(i_eserunordered_multimap.size(), o_eserunordered_multimap.size());
    CHECK_EQ(i_esplunordered_multimap.size(), o_esplunordered_multimap.size());

    for(auto const & p : i_podunordered_multimap)
    {
      size_t const bucket = o_podunordered_multimap.bucket(p.first);
      auto bucket_begin   = o_podunordered_multimap.begin(bucket);
      auto bucket_end     = o_podunordered_multimap.end(bucket);
      CHECK_NE(std::find(bucket_begin, bucket_end, p), bucket_end);
    }

    for(auto const & p : i_iserunordered_multimap)
    {
      size_t const bucket = o_iserunordered_multimap.bucket(p.first);
      auto bucket_begin   = o_iserunordered_multimap.begin(bucket);
      auto bucket_end     = o_iserunordered_multimap.end(bucket);
      CHECK_NE(std::find(bucket_begin, bucket_end, p), bucket_end);
    }

    for(auto const & p : i_isplunordered_multimap)
    {
      size_t const bucket = o_isplunordered_multimap.bucket(p.first);
      auto bucket_begin   = o_isplunordered_multimap.begin(bucket);
      auto bucket_end     = o_isplunordered_multimap.end(bucket);
      CHECK_NE(std::find(bucket_begin, bucket_end, p), bucket_end);
    }

    for(auto const & p : i_eserunordered_multimap)
    {
      size_t const bucket = o_eserunordered_multimap.bucket(p.first);
      auto bucket_begin   = o_eserunordered_multimap.begin(bucket);
      auto bucket_end     = o_eserunordered_multimap.end(bucket);
      CHECK_NE(std::find(bucket_begin, bucket_end, p), bucket_end);
    }

    for(auto const & p : i_esplunordered_multimap)
    {
      size_t const bucket = o_esplunordered_multimap.bucket(p.first);
      auto bucket_begin   = o_esplunordered_multimap.begin(bucket);
      auto bucket_end     = o_esplunordered_multimap.end(bucket);
      CHECK_NE(std::find(bucket_begin, bucket_end, p), bucket_end);
    }
  }
}

#endif // CEREAL_TEST_UNORDERED_MULTIMAP_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_multiset.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "unordered_multiset.hpp"

TEST_SUITE_BEGIN("unordered_multiset");

TEST_CASE("binary_unordered_multiset")
{
  test_unordered_multiset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_unordered_multiset")
{
  test_unordered_multiset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_unordered_multiset")
{
  test_unordered_multiset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_unordered_multiset")
{
  test_unordered_multiset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_multiset.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_UNORDERED_MULTISET_H_
#define CEREAL_TEST_UNORDERED_MULTISET_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_unordered_multiset()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::unordered_multiset<int> o_podunordered_multiset;
    for(int j=0; j<100; ++j)
    {
      int value = random_value<int>(gen);
      o_podunordered_multiset.insert(value);
      o_podunordered_multiset.insert(value);
    }

    std::unordered_multiset<StructInternalSerialize, StructHash<StructInternalSerialize>> o_iserunordered_multiset;
    for(int j=0; j<100; ++j)
    {
      StructInternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
      o_iserunordered_multiset.insert(value);
      o_iserunordered_multiset.insert(value);
    }

    std::unordered_multiset<StructInternalSplit, StructHash<StructInternalSplit>> o_isplunordered_multiset;
    for(int j=0; j<100; ++j)
    {
      StructInternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
      o_isplunordered_multiset.insert(value);
      o_isplunordered_multiset.insert(value);
    }

    std::unordered_multiset<StructExternalSerialize, StructHash<StructExternalSerialize>> o_eserunordered_multiset;
    for(int j=0; j<100; ++j)
    {
      StructExternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
      o_eserunordered_multiset.insert(value);
      o_eserunordered_multiset.insert(value);
    }

    std::unordered_multiset<StructExternalSplit, StructHash<StructExternalSplit>> o_esplunordered_multiset;
    for(int j=0; j<100; ++j)
    {
      StructExternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
      o_esplunordered_multiset.insert(value);
      o_esplunordered_multiset.insert(value);
    }

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podunordered_multiset);
      oar(o_iserunordered_multiset);
      oar(o_isplunordered_multiset);
      oar(o_eserunordered_multiset);
      oar(o_esplunordered_multiset);
    }

    std::unordered_multiset<int> i_podunordered_multiset;
    std::unordered_multiset<StructInternalSerialize, StructHash<StructInternalSerialize>> i_iserunordered_multiset;
    std::unordered_multiset<StructInternalSplit, StructHash<StructInternalSplit>>         i_isplunordered_multiset;
    std::unordered_multiset<StructExternalSerialize, StructHash<StructExternalSerialize>> i_eserunordered_multiset;
    std::unordered_multiset<StructExternalSplit, StructHash<StructExternalSplit>>         i_esplunordered_multiset;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podunordered_multiset);
      iar(i_iserunordered_multiset);
      iar(i_isplunordered_multiset);
      iar(i_eserunordered_multiset);
      iar(i_esplunordered_multiset);
    }

    for(auto const & p : i_podunordered_multiset)
    {
      CHECK_EQ(o_podunordered_multiset.count(p), i_podunordered_multiset.count(p));
    }

    for(auto const & p : i_iserunordered_multiset)
    {
      CHECK_EQ(o_iserunordered_multiset.count(p), i_iserunordered_multiset.count(p));
    }

    for(auto const & p : i_isplunordered_multiset)
    {
      CHECK_EQ(o_isplunordered_multiset.count(p), i_isplunordered_multiset.count(p));
    }

    for(auto const & p : i_eserunordered_multiset)
    {
      CHECK_EQ(o_eserunordered_multiset.count(p), i_eserunordered_multiset.count(p));
    }

    for(auto const & p : i_esplunordered_multiset)
    {
      CHECK_EQ(o_esplunordered_multiset.count(p), i_esplunordered_multiset.count(p));
    }
  }
}

#endif // CEREAL_TEST_UNORDERED_MULTISET_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_set.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "unordered_set.hpp"

TEST_SUITE_BEGIN("unordered_set");

TEST_CASE("binary_unordered_set")
{
  test_unordered_set<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_unordered_set")
{
  test_unordered_set<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_unordered_set")
{
  test_unordered_set<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_unordered_set")
{
  test_unordered_set<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/unordered_set.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_UNORDERED_SET_H_
#define CEREAL_TEST_UNORDERED_SET_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_unordered_set()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::unordered_set<int> o_podunordered_set;
    for(int j=0; j<100; ++j)
      o_podunordered_set.insert(random_value<int>(gen));

    std::unordered_set<StructInternalSerialize, StructHash<StructInternalSerialize>> o_iserunordered_set;
    for(int j=0; j<100; ++j)
      o_iserunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::unordered_set<StructInternalSplit, StructHash<StructInternalSplit>> o_isplunordered_set;
    for(int j=0; j<100; ++j)
      o_isplunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::unordered_set<StructExternalSerialize, StructHash<StructExternalSerialize>> o_eserunordered_set;
    for(int j=0; j<100; ++j)
      o_eserunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::unordered_set<StructExternalSplit, StructHash<StructExternalSplit>> o_esplunordered_set;
    for(int j=0; j<100; ++j)
      o_esplunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podunordered_set);
      oar(o_iserunordered_set);
      oar(o_isplunordered_set);
      oar(o_eserunordered_set);
      oar(o_esplunordered_set);
    }

    std::unordered_set<int> i_podunordered_set;
    std::unordered_set<StructInternalSerialize, StructHash<StructInternalSerialize>>   i_iserunordered_set;
    std::unordered_set<StructInternalSplit, StructHash<StructInternalSplit>>           i_isplunordered_set;
    std::unordered_set<StructExternalSerialize, StructHash<StructExternalSerialize>>   i_eserunordered_set;
    std::unordered_set<StructExternalSplit, StructHash<StructExternalSplit>>           i_esplunordered_set;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podunordered_set);
      iar(i_iserunordered_set);
      iar(i_isplunordered_set);
      iar(i_eserunordered_set);
      iar(i_esplunordered_set);
    }

    for(auto const & p : i_podunordered_set)
    {
      CHECK_EQ(o_podunordered_set.count(p), 1lu);
    }

    for(auto const & p : i_iserunordered_set)
    {
      CHECK_EQ(o_iserunordered_set.count(p), 1lu);
    }

    for(auto const & p : i_isplunordered_set)
    {
      CHECK_EQ(o_isplunordered_set.count(p), 1lu);
    }

    for(auto const & p : i_eserunordered_set)
    {
      CHECK_EQ(o_eserunordered_set.count(p), 1lu);
    }

    for(auto const & p : i_esplunordered_set)
    {
      CHECK_EQ(o_esplunordered_set.count(p), 1lu);
    }
  }
}

#endif // CEREAL_TEST_UNORDERED_SET_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/user_data_adapters.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "user_data_adapters.hpp"

TEST_SUITE_BEGIN("user_data_adapters");

TEST_CASE("binary_user_data_adapters")
{
  test_user_data_adapters<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_user_data_adapters")
{
  test_user_data_adapters<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_user_data_adapters")
{
  test_user_data_adapters<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_user_data_adapters")
{
  test_user_data_adapters<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/user_data_adapters.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_USER_DATA_ADAPTERS_H_
#define CEREAL_TEST_USER_DATA_ADAPTERS_H_

#include "common.hpp"
#define CEREAL_FUTURE_EXPERIMENTAL
#include <cereal/archives/adapters.hpp>

struct SomeStruct {};

struct UserData
{
  UserData( SomeStruct * pp, SomeStruct & r ) :
    p(pp), ref(r) {}

  SomeStruct * p;
  std::reference_wrapper<SomeStruct> ref;
};

struct UserStruct
{
  UserStruct( std::int32_t i,
              SomeStruct * pointer,
              SomeStruct & reference ) :
    i32( i ),
    p( pointer ),
    ref( reference )
  { }

  UserStruct & operator=( UserStruct const & ) = delete;

  std::int32_t i32;
  SomeStruct const * p;
  SomeStruct & ref;

  template <class Archive>
  void serialize( Archive & ar )
  {
    ar( i32 );
  }

  template <class Archive>
  static void load_and_construct( Archive & ar, cereal::construct<UserStruct> & construct )
  {
    std::int32_t ii;
    ar( ii );
    auto & data = cereal::get_user_data<UserData>( ar );
    construct( ii, data.p, data.ref.get() );
  }
};

template <class IArchive, class OArchive> inline
void test_user_data_adapters()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  auto rng = [&](){ return random_value<int>(gen); };

  for(int ii=0; ii<100; ++ii)
  {
    SomeStruct ss;
    std::unique_ptr<UserStruct> o_ptr( new UserStruct( rng(), &ss, ss ) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_ptr);
    }

    decltype( o_ptr  ) i_ptr;

    std::istringstream is(os.str());
    {
      UserData ud(&ss, ss);
      cereal::UserDataAdapter<UserData, IArchive> iar(ud, is);

      iar(i_ptr);
    }

    CHECK_EQ( i_ptr->p, o_ptr->p );
    CHECK_EQ( std::addressof(i_ptr->ref), std::addressof(o_ptr->ref) );
    CHECK_EQ( i_ptr->i32, o_ptr->i32 );

    std::istringstream bad_is(os.str());
    {
      IArchive iar(bad_is);

      CHECK_THROWS_AS( iar(i_ptr), ::cereal::Exception );
    }
  }
}

#endif // CEREAL_TEST_USER_DATA_ADAPTERS_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/valarray.cpp
================================================
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "valarray.hpp"

TEST_SUITE_BEGIN("valarray");

TEST_CASE("binary_valarray")
{
  test_valarray<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_valarray")
{
  test_valarray<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_valarray")
{
  test_valarray<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_valarray")
{
  test_valarray<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/valarray.hpp
================================================
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_VALARRAY_H_
#define CEREAL_TEST_VALARRAY_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_valarray()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for (int ii = 0; ii<100; ++ii)
  {
    std::valarray<int> o_podvalarray(100);
    for (auto & elem : o_podvalarray)
      elem = random_value<int>(gen);

    std::valarray<StructInternalSerialize> o_iservalarray(100);
    for (auto & elem : o_iservalarray)
      elem = StructInternalSerialize(random_value<int>(gen), random_value<int>(gen));

    std::valarray<StructInternalSplit> o_isplvalarray(100);
    for (auto & elem : o_isplvalarray)
      elem = StructInternalSplit(random_value<int>(gen), random_value<int>(gen));

    std::valarray<StructExternalSerialize> o_eservalarray(100);
    for (auto & elem : o_eservalarray)
      elem = StructExternalSerialize(random_value<int>(gen), random_value<int>(gen));

    std::valarray<StructExternalSplit> o_esplvalarray(100);
    for (auto & elem : o_esplvalarray)
      elem = StructExternalSplit(random_value<int>(gen), random_value<int>(gen));

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podvalarray);
      oar(o_iservalarray);
      oar(o_isplvalarray);
      oar(o_eservalarray);
      oar(o_esplvalarray);
    }

    std::valarray<int> i_podvalarray;
    std::valarray<StructInternalSerialize> i_iservalarray;
    std::valarray<StructInternalSplit>     i_isplvalarray;
    std::valarray<StructExternalSerialize> i_eservalarray;
    std::valarray<StructExternalSplit>     i_esplvalarray;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podvalarray);
      iar(i_iservalarray);
      iar(i_isplvalarray);
      iar(i_eservalarray);
      iar(i_esplvalarray);
    }

    CHECK_EQ(i_podvalarray.size(), o_podvalarray.size());
    CHECK_EQ(i_iservalarray.size(), o_iservalarray.size());
    CHECK_EQ(i_isplvalarray.size(), o_isplvalarray.size());
    CHECK_EQ(i_eservalarray.size(), o_eservalarray.size());
    CHECK_EQ(i_esplvalarray.size(), o_esplvalarray.size());

    check_collection(i_podvalarray , o_podvalarray );
    check_collection(i_iservalarray, o_iservalarray);
    check_collection(i_isplvalarray, o_isplvalarray);
    check_collection(i_eservalarray, o_eservalarray);
    check_collection(i_esplvalarray, o_esplvalarray);
  }
}

#endif // CEREAL_TEST_VALARRAY_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/vector.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "vector.hpp"

TEST_SUITE_BEGIN("vector");

TEST_CASE("binary_vector")
{
  test_vector<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_vector")
{
  test_vector<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_vector")
{
  test_vector<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_vector")
{
  test_vector<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/vector.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_VECTOR_H_
#define CEREAL_TEST_VECTOR_H_
#include "common.hpp"

template <class IArchive, class OArchive> inline
void test_vector()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  for(int ii=0; ii<100; ++ii)
  {
    std::vector<int> o_podvector(100);
    for(auto & elem : o_podvector)
      elem = random_value<int>(gen);

    std::vector<bool> o_boolvector; o_boolvector.resize(100);
    for( size_t i = 0; i < 100; ++i )
      o_boolvector[i] = (random_value<int>(gen) % 2) == 0;

    std::vector<StructInternalSerialize> o_iservector(100);
    for(auto & elem : o_iservector)
      elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::vector<StructInternalSplit> o_isplvector(100);
    for(auto & elem : o_isplvector)
      elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::vector<StructExternalSerialize> o_eservector(100);
    for(auto & elem : o_eservector)
      elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );

    std::vector<StructExternalSplit> o_esplvector(100);
    for(auto & elem : o_esplvector)
      elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );

    std::ostringstream os;
    {
      OArchive oar(os);

      oar(o_podvector);
      oar(o_boolvector);
      oar(o_iservector);
      oar(o_isplvector);
      oar(o_eservector);
      oar(o_esplvector);
    }

    std::vector<int> i_podvector;
    std::vector<bool> i_boolvector;
    std::vector<StructInternalSerialize> i_iservector;
    std::vector<StructInternalSplit>     i_isplvector;
    std::vector<StructExternalSerialize> i_eservector;
    std::vector<StructExternalSplit>     i_esplvector;

    std::istringstream is(os.str());
    {
      IArchive iar(is);

      iar(i_podvector);
      iar(i_boolvector);
      iar(i_iservector);
      iar(i_isplvector);
      iar(i_eservector);
      iar(i_esplvector);
    }

    CHECK_EQ(i_podvector.size(),  o_podvector.size());
    CHECK_EQ(i_boolvector.size(),  o_boolvector.size());
    CHECK_EQ(i_iservector.size(), o_iservector.size());
    CHECK_EQ(i_isplvector.size(), o_isplvector.size());
    CHECK_EQ(i_eservector.size(), o_eservector.size());
    CHECK_EQ(i_esplvector.size(), o_esplvector.size());

    check_collection(i_podvector,  o_podvector );
    check_collection(i_boolvector, o_boolvector);
    check_collection(i_iservector, o_iservector);
    check_collection(i_isplvector, o_isplvector);
    check_collection(i_eservector, o_eservector);
    check_collection(i_esplvector, o_esplvector);
  }
}

#endif // CEREAL_TEST_VECTOR_H_


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/versioning.cpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "versioning.hpp"

TEST_SUITE_BEGIN("versioning");

TEST_CASE("binary_versioning")
{
  test_versioning<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_versioning")
{
  test_versioning<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_versioning")
{
  test_versioning<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_versioning")
{
  test_versioning<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}

#if CEREAL_THREAD_SAFE
TEST_CASE("binary_versioning_threading")
{
  test_versioning_threading<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
}

TEST_CASE("portable_binary_versioning_threading")
{
  test_versioning_threading<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
}

TEST_CASE("xml_versioning_threading")
{
  test_versioning_threading<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
}

TEST_CASE("json_versioning_threading")
{
  test_versioning_threading<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
}
#endif // CEREAL_THREAD_SAFE

TEST_SUITE_END();


================================================
FILE: examples/libraries/cereal-1.3.0/unittests/versioning.hpp
================================================
/*
  Copyright (c) 2014, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TEST_VERSIONING_H_
#define CEREAL_TEST_VERSIONING_H_
#include "common.hpp"

#if CEREAL_THREAD_SAFE
#include <future>
#endif

namespace Nested
{
  struct NestedClass
  {
    int x;

    template <class Archive>
    void serialize( Archive & ar )
    { ar( x ); }
  };
}

CEREAL_CLASS_VERSION( Nested::NestedClass, 1 )

class VersionStructMS
{
  public:
    bool x;
    std::uint32_t v;

  private:
    friend class cereal::access;
    template <class Archive>
    void serialize( Archive & ar, std::uint32_t const version )
    {
      ar( x );
      v = version;
    }
};

struct VersionStructMSP
{
  uint8_t x;
  std::uint32_t v;
  template <class Archive>
  void save( Archive & ar, std::uint32_t const /*version*/ ) const
  {
    ar( x );
  }

  template <class Archive>
  void load( Archive & ar, std::uint32_t const version )
  {
    ar( x );
    v = version;
  }
};

struct VersionStructNMS
{
  std::int32_t x;
  std::uint32_t v;
};

template <class Archive>
void serialize( Archive & ar, VersionStructNMS & vnms, const std::uint32_t version )
{
  ar( vnms.x );
  vnms.v = version;
}

struct VersionStructNMSP
{
  double x;
  std::uint32_t v;
};

template <class Archive>
void save( Archive & ar, VersionStructNMSP const & vnms, const std::uint32_t /*version*/ )
{
  ar( vnms.x );
}

template <class Archive>
void load( Archive & ar, VersionStructNMSP & vnms, const std::uint32_t version )
{
  ar( vnms.x );
  vnms.v = version;
}

CEREAL_CLASS_VERSION( VersionStructMSP, 33 )
CEREAL_CLASS_VERSION( VersionStructNMS, 66 )
CEREAL_CLASS_VERSION( VersionStructNMSP, 99 )

template <class IArchive, class OArchive> inline
void test_versioning()
{
  std::random_device rd;
  std::mt19937 gen(rd());

  #if CEREAL_THREAD_SAFE
  #include <future>
  static std::mutex testMutex;
  #endif

  for(size_t i=0; i<100; ++i)
  {
    VersionStructMS o_MS      = {random_value<uint8_t>(gen) % 2 ? true : false, 1};
    VersionStructMSP o_MSP    = {random_value<uint8_t>(gen), 1};
    VersionStructNMS o_NMS    = {random_value<int32_t>(gen), 1};
    VersionStructNMSP o_NMSP  = {random_value<double>(gen), 1};
    VersionStructMS o_MS2     = {random_value<uint8_t>(gen) % 2 ? true : false, 1};
    VersionStructMSP o_MSP2   = {random_value<uint8_t>(gen), 1};
    VersionStructNMS o_NMS2   = {random_value<int32_t>(gen), 1};
    VersionStructNMSP o_NMSP2 = {random_value<double>(gen), 1};

    std::ostringstream os;
    {
      OArchive oar(os);
      oar( o_MS );
      oar( o_MSP );
      oar( o_NMS );
      oar( o_NMSP );
      oar( o_MS2 );
      oar( o_MSP2 );
      oar( o_NMS2 );
      oar( o_NMSP2 );
    }

    decltype(o_MS) i_MS;
    decltype(o_MSP) i_MSP;
    decltype(o_NMS) i_NMS;
    decltype(o_NMSP) i_NMSP;
    decltype(o_MS2) i_MS2;
    decltype(o_MSP2) i_MSP2;
    decltype(o_NMS2) i_NMS2;
    decltype(o_NMSP2) i_NMSP2;

    std::istringstream is(os.str());
    {
      IArchive iar(is);
      iar( i_MS );
      iar( i_MSP );
      iar( i_NMS );
      iar( i_NMSP );
      iar( i_MS2 );
      iar( i_MSP2 );
      iar( i_NMS2 );
      iar( i_NMSP2 );
    }

    #if CEREAL_THREAD_SAFE
    std::lock_guard<std::mutex> lock( testMutex );
    #endif

    CHECK_EQ(o_MS.x, i_MS.x);
    CHECK_EQ(i_MS.v, 0u);
    CHECK_EQ(o_MSP.x, i_MSP.x);
    CHECK_EQ(i_MSP.v, 33u);
    CHECK_EQ(o_NMS.x, i_NMS.x);
    CHECK_EQ(i_NMS.v, 66u);
    CHECK_EQ(o_NMSP.x, doctest::Approx(i_NMSP.x).epsilon(1e-5));
    CHECK_EQ(i_NMSP.v, 99u);

    CHECK_EQ(o_MS2.x, i_MS2.x);
    CHECK_EQ(i_MS2.v, 0u);
    CHECK_EQ(o_MSP2.x, i_MSP2.x);
    CHECK_EQ(i_MSP2.v, 33u);
    CHECK_EQ(o_NMS2.x, i_NMS2.x);
    CHECK_EQ(i_NMS2.v, 66u);
    CHECK_EQ(o_NMSP2.x, doctest::Approx(i_NMSP2.x).epsilon(1e-5));
    CHECK_EQ(i_NMSP2.v, 99u);
    }
}

#if CEREAL_THREAD_SAFE
template <class IArchive, class OArchive> inline
void test_versioning_threading()
{
  std::vector<std::future<bool>> pool;
  for( size_t i = 0; i < 100; ++i )
    pool.emplace_back( std::async( std::launch::async,
                                   [](){ test_versioning<IArchive, OArchive>(); return true; } ) );

  for( auto & future : pool )
    future.wait();

  for( auto & future : pool )
    CHECK_UNARY( future.get() );
}
#endif // CEREAL_THREAD_SAFE

#endif // CEREAL_TEST_VERSIONING_H_


================================================
FILE: examples/libraries/fmt/.clang-format
================================================
# Run manually to reformat a file:
# clang-format -i --style=file <file>
Language: Cpp
BasedOnStyle: Google
IndentPPDirectives: AfterHash
IndentCaseLabels: false
AlwaysBreakTemplateDeclarations: false
DerivePointerAlignment: false


================================================
FILE: examples/libraries/fmt/.github/pull_request_template.md
================================================
<!--
Please read the contribution guidelines before submitting a pull request:
https://github.com/fmtlib/fmt/blob/master/CONTRIBUTING.md.
By submitting this pull request, you agree that your contributions are licensed
under the {fmt} license, and agree to future changes to the licensing.
-->


================================================
FILE: examples/libraries/fmt/.github/workflows/doc.yml
================================================
name: doc

on: [push, pull_request]

jobs:
  build:
    # Use Ubuntu 20.04 because doxygen 1.8.13 from Ubuntu 18.04 is broken.
    runs-on: ubuntu-20.04

    steps:
    - uses: actions/checkout@v2

    - name: Create Build Environment
      run: |
        sudo apt update
        sudo apt install doxygen python3-virtualenv
        sudo npm install -g less clean-css
        cmake -E make_directory ${{runner.workspace}}/build

    - name: Build
      working-directory: ${{runner.workspace}}/build
      env:
        KEY: ${{secrets.KEY}}
      run: $GITHUB_WORKSPACE/support/build-docs.py


================================================
FILE: examples/libraries/fmt/.github/workflows/linux.yml
================================================
name: linux

on: [push, pull_request]

jobs:
  build:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        cxx: [g++-4.8, g++-10, clang++-9]
        build_type: [Debug, Release]
        std: [11]
        os: [ubuntu-18.04]
        include:
          - cxx: g++-4.8
            install: sudo apt install g++-4.8
            os: ubuntu-18.04
          - cxx: g++-8
            build_type: Debug
            std: 14
            install: sudo apt install g++-8
            os: ubuntu-18.04
          - cxx: g++-10
            build_type: Debug
            std: 17
            os: ubuntu-18.04
          - cxx: g++-10
            build_type: Debug
            std: 20
            os: ubuntu-20.04
          - cxx: clang++-9
            build_type: Debug
            fuzz: -DFMT_FUZZ=ON -DFMT_FUZZ_LINKMAIN=ON
            std: 17
            os: ubuntu-18.04
          - cxx: clang++-11
            build_type: Debug
            std: 20
            os: ubuntu-20.04
          - cxx: clang++-11
            build_type: Debug
            std: 20
            cxxflags: -stdlib=libc++
            os: ubuntu-20.04
            install: sudo apt install libc++-11-dev libc++abi-11-dev
          - shared: -DBUILD_SHARED_LIBS=ON

    steps:
    - uses: actions/checkout@v2

    - name: Create Build Environment
      run: |
        ${{matrix.install}}
        sudo apt install locales-all
        cmake -E make_directory ${{runner.workspace}}/build

    - name: Configure
      working-directory: ${{runner.workspace}}/build
      env:
        CXX: ${{matrix.cxx}}
        CXXFLAGS: ${{matrix.cxxflags}}
      run: |
        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.fuzz}} ${{matrix.shared}} \
              -DCMAKE_CXX_STANDARD=${{matrix.std}} -DFMT_DOC=OFF \
              -DCMAKE_CXX_VISIBILITY_PRESET=hidden -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON \
              -DFMT_PEDANTIC=ON -DFMT_WERROR=ON $GITHUB_WORKSPACE

    - name: Build
      working-directory: ${{runner.workspace}}/build
      run: |
        threads=`nproc`
        cmake --build . --config ${{matrix.build_type}} --parallel $threads

    - name: Test
      working-directory: ${{runner.workspace}}/build
      run: ctest -C ${{matrix.build_type}}
      env:
        CTEST_OUTPUT_ON_FAILURE: True


================================================
FILE: examples/libraries/fmt/.github/workflows/macos.yml
================================================
name: macos

on: [push, pull_request]

jobs:
  build:
    runs-on: macos-10.15
    strategy:
      matrix:
        build_type: [Debug, Release]
        include:
          - shared: -DBUILD_SHARED_LIBS=ON

    steps:
    - uses: actions/checkout@v2

    - name: Create Build Environment
      run: cmake -E make_directory ${{runner.workspace}}/build

    - name: Configure
      working-directory: ${{runner.workspace}}/build
      run: |
        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.shared}} \
              -DCMAKE_CXX_VISIBILITY_PRESET=hidden -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON \
              -DFMT_DOC=OFF -DFMT_PEDANTIC=ON -DFMT_WERROR=ON $GITHUB_WORKSPACE

    - name: Build
      working-directory: ${{runner.workspace}}/build
      run: |
        threads=`sysctl -n hw.logicalcpu`
        cmake --build . --config ${{matrix.build_type}} --parallel $threads

    - name: Test
      working-directory: ${{runner.workspace}}/build
      run: ctest -C ${{matrix.build_type}}
      env:
        CTEST_OUTPUT_ON_FAILURE: True


================================================
FILE: examples/libraries/fmt/.github/workflows/windows.yml
================================================
name: windows

on: [push, pull_request]

jobs:
  build:
    runs-on: ${{matrix.os}}
    strategy:
      matrix:
        # windows-2016 and windows-2019 have MSVC 2017 and 2019 installed
        # respectively: https://github.com/actions/virtual-environments.
        os: [windows-2016, windows-2019]
        platform: [Win32, x64]
        build_type: [Debug, Release]
        standard: [11, 17, 20]
        include:
          - os: windows-2016
            platform: Win32
            build_type: Debug
            shared: -DBUILD_SHARED_LIBS=ON
        exclude:
          - os: windows-2016
            platform: Win32
          - os: windows-2016
            standard: 17
          - os: windows-2016
            standard: 20
          - os: windows-2019
            standard: 11
          - os: windows-2019
            standard: 20
            platform: Win32

    steps:
    - uses: actions/checkout@v2

    - name: Create Build Environment
      run: cmake -E make_directory ${{runner.workspace}}/build

    - name: Configure
      # Use a bash shell for $GITHUB_WORKSPACE.
      shell: bash
      working-directory: ${{runner.workspace}}/build
      run: |
        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.shared}} \
              -A ${{matrix.platform}} \
              -DCMAKE_CXX_STANDARD=${{matrix.standard}} \
              $GITHUB_WORKSPACE

    - name: Build
      working-directory: ${{runner.workspace}}/build
      run: |
        $threads = (Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors
        cmake --build . --config ${{matrix.build_type}} --parallel $threads

    - name: Test
      working-directory: ${{runner.workspace}}/build
      run: ctest -C ${{matrix.build_type}} -V
      env:
        CTEST_OUTPUT_ON_FAILURE: True


================================================
FILE: examples/libraries/fmt/.gitignore
================================================
.vscode/
.vs/

*.iml
.idea/
.externalNativeBuild/
.gradle/
gradle/
gradlew*
local.properties
build/
support/.cxx

bin/
/_CPack_Packages
/CMakeScripts
/doc/doxyxml
/doc/html
/doc/node_modules
virtualenv
/Testing
/install_manifest.txt
*~
*.a
*.so*
*.xcodeproj
*.zip
cmake_install.cmake
CPack*.cmake
fmt-*.cmake
CTestTestfile.cmake
CMakeCache.txt
CMakeFiles
FMT.build
Makefile
run-msbuild.bat
fmt.pc


================================================
FILE: examples/libraries/fmt/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1...3.18)

# Fallback for using newer policies on CMake <3.12.
if(${CMAKE_VERSION} VERSION_LESS 3.12)
  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
endif()

# Determine if fmt is built as a subproject (using add_subdirectory)
# or if it is the master project.
if (NOT DEFINED FMT_MASTER_PROJECT)
  set(FMT_MASTER_PROJECT OFF)
  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
    set(FMT_MASTER_PROJECT ON)
    message(STATUS "CMake version: ${CMAKE_VERSION}")
  endif ()
endif ()

# Joins arguments and places the results in ${result_var}.
function(join result_var)
  set(result "")
  foreach (arg ${ARGN})
    set(result "${result}${arg}")
  endforeach ()
  set(${result_var} "${result}" PARENT_SCOPE)
endfunction()

function(enable_module target)
  if (MSVC)
    set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
    target_compile_options(${target}
      PRIVATE /interface /ifcOutput ${BMI}
      INTERFACE /reference fmt=${BMI})
  endif ()
  set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
  set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
endfunction()

include(CMakeParseArguments)

# Sets a cache variable with a docstring joined from multiple arguments:
#   set(<variable> <value>... CACHE <type> <docstring>...)
# This allows splitting a long docstring for readability.
function(set_verbose)
  # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
  # list instead.
  list(GET ARGN 0 var)
  list(REMOVE_AT ARGN 0)
  list(GET ARGN 0 val)
  list(REMOVE_AT ARGN 0)
  list(REMOVE_AT ARGN 0)
  list(GET ARGN 0 type)
  list(REMOVE_AT ARGN 0)
  join(doc ${ARGN})
  set(${var} ${val} CACHE ${type} ${doc})
endfunction()

# Set the default CMAKE_BUILD_TYPE to Release.
# This should be done before the project command since the latter can set
# CMAKE_BUILD_TYPE itself (it does so for nmake).
if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
              "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
              "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
endif ()

project(FMT CXX)
include(GNUInstallDirs)
set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
            "Installation directory for include files, a relative path that "
            "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")

option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
       OFF)

# Options that control generation of various targets.
option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
option(FMT_INSTALL "Generate the install target." ${FMT_MASTER_PROJECT})
option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
option(FMT_FUZZ "Generate the fuzz target." OFF)
option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
option(FMT_MODULE "Build a module instead of a traditional library." OFF)

set(FMT_CAN_MODULE OFF)
if (CMAKE_CXX_STANDARD GREATER 17 AND
    # msvc 16.10-pre4
    MSVC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.29.30035)
  set(FMT_CAN_MODULE ON)
endif ()
if (NOT FMT_CAN_MODULE)
  set(FMT_MODULE OFF)
  message(STATUS "Module support is disabled.")
endif ()
if (FMT_TEST AND FMT_MODULE)
  # The tests require {fmt} to be compiled as traditional library
  message(STATUS "Testing is incompatible with build mode 'module'.")
endif ()

# Get version from core.h
file(READ include/fmt/core.h core_h)
if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
endif ()
# Use math to skip leading zeros if any.
math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
                 ${CPACK_PACKAGE_VERSION_PATCH})
message(STATUS "Version: ${FMT_VERSION}")

message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
endif ()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")

include(cxx14)
include(CheckCXXCompilerFlag)
include(JoinPaths)

list(FIND CMAKE_CXX_COMPILE_FEATURES "cxx_variadic_templates" index)
if (${index} GREATER -1)
  # Use cxx_variadic_templates instead of more appropriate cxx_std_11 for
  # compatibility with older CMake versions.
  set(FMT_REQUIRED_FEATURES cxx_variadic_templates)
endif ()
message(STATUS "Required features: ${FMT_REQUIRED_FEATURES}")

if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
  set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
              "Preset for the export of private symbols")
  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
               hidden default)
endif ()

if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
              "Whether to add a compile flag to hide symbols of inline functions")
endif ()

if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
      -Wold-style-cast -Wundef
      -Wredundant-decls -Wwrite-strings -Wpointer-arith
      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
      -Wcast-align
      -Wctor-dtor-privacy -Wdisabled-optimization
      -Winvalid-pch -Woverloaded-virtual
      -Wconversion -Wswitch-enum -Wundef
      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
         -Wno-dangling-else -Wno-unused-local-typedefs)
  endif ()
  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
  endif ()
  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
          -Wnull-dereference -Wduplicated-cond)
  endif ()
  set(WERROR_FLAG -Werror)
endif ()

if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
      -Wdeprecated -Wweak-vtables -Wshadow
      -Wno-gnu-zero-variadic-macro-arguments)
  check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
  if (HAS_NULLPTR_WARNING)
    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
        -Wzero-as-null-pointer-constant)
  endif ()
  set(WERROR_FLAG -Werror)
endif ()

if (MSVC)
  set(PEDANTIC_COMPILE_FLAGS /W3)
  set(WERROR_FLAG /WX)
endif ()

if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
  # If Microsoft SDK is installed create script run-msbuild.bat that
  # calls SetEnv.cmd to set up build environment and runs msbuild.
  # It is useful when building Visual Studio projects with the SDK
  # toolchain rather than Visual Studio.
  include(FindSetEnv)
  if (WINSDK_SETENV)
    set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
  endif ()
  # Set FrameworkPathOverride to get rid of MSB3644 warnings.
  join(netfxpath
       "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
       ".NETFramework\\v4.0")
  file(WRITE run-msbuild.bat "
    ${MSBUILD_SETUP}
    ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
endif ()

set(strtod_l_headers stdlib.h)
if (APPLE)
  set(strtod_l_headers ${strtod_l_headers} xlocale.h)
endif ()

include(CheckSymbolExists)
if (WIN32)
  check_symbol_exists(_strtod_l "${strtod_l_headers}" HAVE_STRTOD_L)
else ()
  check_symbol_exists(strtod_l "${strtod_l_headers}" HAVE_STRTOD_L)
endif ()

function(add_headers VAR)
  set(headers ${${VAR}})
  foreach (header ${ARGN})
    set(headers ${headers} include/fmt/${header})
  endforeach()
  set(${VAR} ${headers} PARENT_SCOPE)
endfunction()

# Define the fmt library, its includes and the needed defines.
add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
                        format-inl.h locale.h os.h ostream.h printf.h ranges.h
                        xchar.h)
if (FMT_MODULE)
  set(FMT_SOURCES src/fmt.cc)
elseif (FMT_OS)
  set(FMT_SOURCES src/format.cc src/os.cc)
else()
  set(FMT_SOURCES src/format.cc)
endif ()

add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS} README.rst ChangeLog.rst)
add_library(fmt::fmt ALIAS fmt)

if (HAVE_STRTOD_L)
  target_compile_definitions(fmt PUBLIC FMT_LOCALE)
endif ()

if (MINGW)
  check_cxx_compiler_flag("Wa,-mbig-obj" FMT_HAS_MBIG_OBJ)
  if (${FMT_HAS_MBIG_OBJ})
    target_compile_options(fmt PUBLIC "-Wa,-mbig-obj")
  endif()
endif ()

if (FMT_WERROR)
  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
endif ()
if (FMT_PEDANTIC)
  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
endif ()
if (FMT_MODULE)
  enable_module(fmt)
endif ()

target_compile_features(fmt INTERFACE ${FMT_REQUIRED_FEATURES})

target_include_directories(fmt PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")

set_target_properties(fmt PROPERTIES
  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
  DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}")

# Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
# property because it's not set by default.
set(FMT_LIB_NAME fmt)
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
  set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
endif ()

if (BUILD_SHARED_LIBS)
  if (UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS" AND
      NOT EMSCRIPTEN)
    # Fix rpmlint warning:
    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
    target_link_libraries(fmt -Wl,--as-needed)
  endif ()
  target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
endif ()
if (FMT_SAFE_DURATION_CAST)
  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
endif()

add_library(fmt-header-only INTERFACE)
add_library(fmt::fmt-header-only ALIAS fmt-header-only)

target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
target_compile_features(fmt-header-only INTERFACE ${FMT_REQUIRED_FEATURES})

target_include_directories(fmt-header-only INTERFACE
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

# Install targets.
if (FMT_INSTALL)
  include(CMakePackageConfigHelpers)
  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
              "Installation directory for cmake files, a relative path that "
              "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
              "path.")
  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
  set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
  set(targets_export_name fmt-targets)

  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
              "Installation directory for libraries, a relative path that "
              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")

  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE PATH
              "Installation directory for pkgconfig (.pc) files, a relative "
              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
              "absolute path.")

  # Generate the version, config and target files into the build directory.
  write_basic_package_version_file(
    ${version_config}
    VERSION ${FMT_VERSION}
    COMPATIBILITY AnyNewerVersion)

  join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
  join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")

  configure_file(
    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
    "${pkgconfig}"
    @ONLY)
  configure_package_config_file(
    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
    ${project_config}
    INSTALL_DESTINATION ${FMT_CMAKE_DIR})

  set(INSTALL_TARGETS fmt fmt-header-only)

  # Install the library and headers.
  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
          LIBRARY DESTINATION ${FMT_LIB_DIR}
          ARCHIVE DESTINATION ${FMT_LIB_DIR}
          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

  # Use a namespace because CMake provides better diagnostics for namespaced
  # imported targets.
  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)

  # Install version, config and target files.
  install(
    FILES ${project_config} ${version_config}
    DESTINATION ${FMT_CMAKE_DIR})
  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
          NAMESPACE fmt::)

  install(FILES $<TARGET_PDB_FILE:${INSTALL_TARGETS}>
          DESTINATION ${FMT_LIB_DIR} OPTIONAL)
  install(FILES ${FMT_HEADERS} DESTINATION "${FMT_INC_DIR}/fmt")
  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
endif ()

if (FMT_DOC)
  add_subdirectory(doc)
endif ()

if (FMT_TEST)
  enable_testing()
  add_subdirectory(test)
endif ()

# Control fuzzing independent of the unit tests.
if (FMT_FUZZ)
  add_subdirectory(test/fuzzing)

  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
  # mode and make fuzzing practically possible. It is similar to
  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
  # avoid interfering with fuzzing of projects that use {fmt}.
  # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
  target_compile_definitions(fmt PUBLIC FMT_FUZZ)
endif ()

set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
  # Get the list of ignored files from .gitignore.
  file (STRINGS ${gitignore} lines)
  list(REMOVE_ITEM lines /doc/html)
  foreach (line ${lines})
    string(REPLACE "." "[.]" line "${line}")
    string(REPLACE "*" ".*" line "${line}")
    set(ignored_files ${ignored_files} "${line}$" "${line}/")
  endforeach ()
  set(ignored_files ${ignored_files}
    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)

  set(CPACK_SOURCE_GENERATOR ZIP)
  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
  set(CPACK_PACKAGE_NAME fmt)
  set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.rst)
  include(CPack)
endif ()


================================================
FILE: examples/libraries/fmt/CONTRIBUTING.md
================================================
Contributing to {fmt}
=====================

By submitting a pull request or a patch, you represent that you have the right
to license your contribution to the {fmt} project owners and the community,
agree that your contributions are licensed under the {fmt} license, and agree
to future changes to the licensing.

All C++ code must adhere to [Google C++ Style Guide](
https://google.github.io/styleguide/cppguide.html) with the following
exceptions:

* Exceptions are permitted
* snake_case should be used instead of UpperCamelCase for function and type
  names

All documentation must adhere to the [Google Developer Documentation Style
Guide](https://developers.google.com/style).

Thanks for contributing!


================================================
FILE: examples/libraries/fmt/ChangeLog.rst
================================================
8.0.1 - 2021-07-02
------------------

* Fixed the version number in the inline namespace
  (`#2374 <https://github.com/fmtlib/fmt/issues/2374>`_).

* Added a missing presentation type check for ``std::string``
  (`#2402 <https://github.com/fmtlib/fmt/issues/2402>`_).

* Fixed a linkage error when mixing code built with clang and gcc
  (`#2377 <https://github.com/fmtlib/fmt/issues/2377>`_).

* Fixed documentation issues
  (`#2396 <https://github.com/fmtlib/fmt/pull/2396>`_,
  `#2403 <https://github.com/fmtlib/fmt/issues/2403>`_,
  `#2406 <https://github.com/fmtlib/fmt/issues/2406>`_).
  Thanks `@mkurdej (Marek Kurdej) <https://github.com/mkurdej>`_.

* Removed dead code in FP formatter (
  `#2398 <https://github.com/fmtlib/fmt/pull/2398>`_).
  Thanks `@javierhonduco (Javier Honduvilla Coto)
  <https://github.com/javierhonduco>`_.

* Fixed various warnings and compilation issues
  (`#2351 <https://github.com/fmtlib/fmt/issues/2351>`_,
  `#2359 <https://github.com/fmtlib/fmt/issues/2359>`_,
  `#2365 <https://github.com/fmtlib/fmt/pull/2365>`_,
  `#2368 <https://github.com/fmtlib/fmt/issues/2368>`_,
  `#2370 <https://github.com/fmtlib/fmt/pull/2370>`_,
  `#2376 <https://github.com/fmtlib/fmt/pull/2376>`_,
  `#2381 <https://github.com/fmtlib/fmt/pull/2381>`_,
  `#2382 <https://github.com/fmtlib/fmt/pull/2382>`_,
  `#2386 <https://github.com/fmtlib/fmt/issues/2386>`_,
  `#2389 <https://github.com/fmtlib/fmt/pull/2389>`_,
  `#2395 <https://github.com/fmtlib/fmt/pull/2395>`_,
  `#2397 <https://github.com/fmtlib/fmt/pull/2397>`_,
  `#2400 <https://github.com/fmtlib/fmt/issues/2400>`_
  `#2401 <https://github.com/fmtlib/fmt/issues/2401>`_,
  `#2407 <https://github.com/fmtlib/fmt/pull/2407>`_).
  Thanks `@zx2c4 (Jason A. Donenfeld) <https://github.com/zx2c4>`_,
  `@AidanSun05 (Aidan Sun) <https://github.com/AidanSun05>`_,
  `@mattiasljungstrom (Mattias Ljungström)
  <https://github.com/mattiasljungstrom>`_,
  `@joemmett (Jonathan Emmett) <https://github.com/joemmett>`_,
  `@erengy (Eren Okka) <https://github.com/erengy>`_,
  `@patlkli (Patrick Geltinger) <https://github.com/patlkli>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.

8.0.0 - 2021-06-21
------------------

* Enabled compile-time format string check by default.
  For example (`godbolt <https://godbolt.org/z/sMxcohGjz>`__):

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{:d}", "I am not a number");
     }

  gives a compile-time error on compilers with C++20 ``consteval`` support
  (gcc 10+, clang 11+) because ``d`` is not a valid format specifier for a
  string.

  To pass a runtime string wrap it in ``fmt::runtime``:

  .. code:: c++

     fmt::print(fmt::runtime("{:d}"), "I am not a number");

* Added compile-time formatting
  (`#2019 <https://github.com/fmtlib/fmt/pull/2019>`_,
  `#2044 <https://github.com/fmtlib/fmt/pull/2044>`_,
  `#2056 <https://github.com/fmtlib/fmt/pull/2056>`_,
  `#2072 <https://github.com/fmtlib/fmt/pull/2072>`_,
  `#2075 <https://github.com/fmtlib/fmt/pull/2075>`_,
  `#2078 <https://github.com/fmtlib/fmt/issues/2078>`_,
  `#2129 <https://github.com/fmtlib/fmt/pull/2129>`_,
  `#2326 <https://github.com/fmtlib/fmt/pull/2326>`_).
  For example (`godbolt <https://godbolt.org/z/Mxx9d89jM>`__):

  .. code:: c++

     #include <fmt/compile.h>

     consteval auto compile_time_itoa(int value) -> std::array<char, 10> {
       auto result = std::array<char, 10>();
       fmt::format_to(result.data(), FMT_COMPILE("{}"), value);
       return result;
     }

     constexpr auto answer = compile_time_itoa(42);

  Most of the formatting functionality is available at compile time with a
  notable exception of floating-point numbers and pointers.
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Optimized handling of format specifiers during format string compilation.
  For example, hexadecimal formatting (``"{:x}"``) is now 3-7x faster than
  before when using ``format_to`` with format string compilation and a
  stack-allocated buffer (`#1944 <https://github.com/fmtlib/fmt/issues/1944>`_).

  Before (7.1.3)::

    ----------------------------------------------------------------------------
    Benchmark                                  Time             CPU   Iterations
    ----------------------------------------------------------------------------
    FMTCompileOld/0                         15.5 ns         15.5 ns     43302898
    FMTCompileOld/42                        16.6 ns         16.6 ns     43278267
    FMTCompileOld/273123                    18.7 ns         18.6 ns     37035861
    FMTCompileOld/9223372036854775807       19.4 ns         19.4 ns     35243000
    ----------------------------------------------------------------------------

  After (8.x)::

    ----------------------------------------------------------------------------
    Benchmark                                  Time             CPU   Iterations
    ----------------------------------------------------------------------------
    FMTCompileNew/0                         1.99 ns         1.99 ns    360523686
    FMTCompileNew/42                        2.33 ns         2.33 ns    279865664
    FMTCompileNew/273123                    3.72 ns         3.71 ns    190230315
    FMTCompileNew/9223372036854775807       5.28 ns         5.26 ns    130711631
    ----------------------------------------------------------------------------

  It is even faster than ``std::to_chars`` from libc++ compiled with clang on
  macOS::

    ----------------------------------------------------------------------------
    Benchmark                                  Time             CPU   Iterations
    ----------------------------------------------------------------------------
    ToChars/0                               4.42 ns         4.41 ns    160196630
    ToChars/42                              5.00 ns         4.98 ns    140735201
    ToChars/273123                          7.26 ns         7.24 ns     95784130
    ToChars/9223372036854775807             8.77 ns         8.75 ns     75872534
    ----------------------------------------------------------------------------

  In other cases, especially involving ``std::string`` construction, the
  speed up is usually lower because handling format specifiers takes a smaller
  fraction of the total time.

* Added the ``_cf`` user-defined literal to represent a compiled format string.
  It can be used instead of the ``FMT_COMPILE`` macro
  (`#2043 <https://github.com/fmtlib/fmt/pull/2043>`_,
  `#2242 <https://github.com/fmtlib/fmt/pull/2242>`_):

  .. code:: c++

     #include <fmt/compile.h>

     using namespace fmt::literals;
     auto s = fmt::format(FMT_COMPILE("{}"), 42); // 🙁 not modern
     auto s = fmt::format("{}"_cf, 42);           // 🙂 modern as hell

  It requires compiler support for class types in non-type template parameters
  (a C++20 feature) which is available in GCC 9.3+.
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Format string compilation now requires ``format`` functions of ``formatter``
  specializations for user-defined types to be ``const``:

  .. code:: c++

     template <> struct fmt::formatter<my_type>: formatter<string_view> {
       template <typename FormatContext>
       auto format(my_type obj, FormatContext& ctx) const {  // Note const here.
         // ...
       }
     };

* Added UDL-based named argument support to format string compilation
  (`#2243 <https://github.com/fmtlib/fmt/pull/2243>`_,
  `#2281 <https://github.com/fmtlib/fmt/pull/2281>`_). For example:

  .. code:: c++

     #include <fmt/compile.h>

     using namespace fmt::literals;
     auto s = fmt::format(FMT_COMPILE("{answer}"), "answer"_a = 42);

  Here the argument named "answer" is resolved at compile time with no
  runtime overhead.
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Added format string compilation support to ``fmt::print``
  (`#2280 <https://github.com/fmtlib/fmt/issues/2280>`_,
  `#2304 <https://github.com/fmtlib/fmt/pull/2304>`_).
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Added initial support for compiling {fmt} as a C++20 module
  (`#2235 <https://github.com/fmtlib/fmt/pull/2235>`_,
  `#2240 <https://github.com/fmtlib/fmt/pull/2240>`_,
  `#2260 <https://github.com/fmtlib/fmt/pull/2260>`_,
  `#2282 <https://github.com/fmtlib/fmt/pull/2282>`_,
  `#2283 <https://github.com/fmtlib/fmt/pull/2283>`_,
  `#2288 <https://github.com/fmtlib/fmt/pull/2288>`_,
  `#2298 <https://github.com/fmtlib/fmt/pull/2298>`_,
  `#2306 <https://github.com/fmtlib/fmt/pull/2306>`_,
  `#2307 <https://github.com/fmtlib/fmt/pull/2307>`_,
  `#2309 <https://github.com/fmtlib/fmt/pull/2309>`_,
  `#2318 <https://github.com/fmtlib/fmt/pull/2318>`_,
  `#2324 <https://github.com/fmtlib/fmt/pull/2324>`_,
  `#2332 <https://github.com/fmtlib/fmt/pull/2332>`_,
  `#2340 <https://github.com/fmtlib/fmt/pull/2340>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Made symbols private by default reducing shared library size
  (`#2301 <https://github.com/fmtlib/fmt/pull/2301>`_). For example there was
  a ~15% reported reduction on one platform.
  Thanks `@sergiud (Sergiu Deitsch) <https://github.com/sergiud>`_.

* Optimized includes making the result of preprocessing ``fmt/format.h``
  ~20% smaller with libstdc++/C++20 and slightly improving build times
  (`#1998 <https://github.com/fmtlib/fmt/issues/1998>`_).

* Added support of ranges with non-const ``begin`` / ``end``
  (`#1953 <https://github.com/fmtlib/fmt/pull/1953>`_).
  Thanks `@kitegi (sarah) <https://github.com/kitegi>`_.

* Added support of ``std::byte`` and other formattable types to ``fmt::join``
  (`#1981 <https://github.com/fmtlib/fmt/issues/1981>`_,
  `#2040 <https://github.com/fmtlib/fmt/issues/2040>`_,
  `#2050 <https://github.com/fmtlib/fmt/pull/2050>`_,
  `#2262 <https://github.com/fmtlib/fmt/issues/2262>`_). For example:

  .. code:: c++

     #include <fmt/format.h>
     #include <cstddef>
     #include <vector>

     int main() {
       auto bytes = std::vector{std::byte(4), std::byte(2)};
       fmt::print("{}", fmt::join(bytes, ""));
     }

  prints "42".

  Thanks `@kamibo (Camille Bordignon) <https://github.com/kamibo>`_.

* Implemented the default format for ``std::chrono::system_clock``
  (`#2319 <https://github.com/fmtlib/fmt/issues/2319>`_,
  `#2345 <https://github.com/fmtlib/fmt/pull/2345>`_). For example:

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       fmt::print("{}", std::chrono::system_clock::now());
     }

  prints "2021-06-18 15:22:00" (the output depends on the current date and
  time). Thanks `@sunmy2019 <https://github.com/sunmy2019>`_.

* Made more chrono specifiers locale independent by default. Use the ``'L'``
  specifier to get localized formatting. For example:

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       std::locale::global(std::locale("ru_RU.UTF-8"));
       auto monday = std::chrono::weekday(1);
       fmt::print("{}\n", monday);   // prints "Mon"
       fmt::print("{:L}\n", monday); // prints "пн"
     }

* Improved locale handling in chrono formatting
  (`#2337 <https://github.com/fmtlib/fmt/issues/2337>`_,
  `#2349 <https://github.com/fmtlib/fmt/pull/2349>`_,
  `#2350 <https://github.com/fmtlib/fmt/pull/2350>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.

* Deprecated ``fmt/locale.h`` moving the formatting functions that take a
  locale to ``fmt/format.h`` (``char``) and ``fmt/xchar`` (other overloads).
  This doesn't introduce a dependency on ``<locale>`` so there is virtually no
  compile time effect.

* Made parameter order in ``vformat_to`` consistent with ``format_to``
  (`#2327 <https://github.com/fmtlib/fmt/issues/2327>`_).

* Added support for time points with arbitrary durations
  (`#2208 <https://github.com/fmtlib/fmt/issues/2208>`_). For example:

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       using tp = std::chrono::time_point<
         std::chrono::system_clock, std::chrono::seconds>;
       fmt::print("{:%S}", tp(std::chrono::seconds(42)));
     }

  prints "42".

* Formatting floating-point numbers no longer produces trailing zeros by default
  for consistency with ``std::format``. For example:

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{0:.3}", 1.1);
     }

  prints "1.1". Use the ``'#'`` specifier to keep trailing zeros.

* Dropped a limit on the number of elements in a range and replaced ``{}`` with
  ``[]`` as range delimiters for consistency with Python's ``str.format``.

* The ``'L'`` specifier for locale-specific numeric formatting can now be
  combined with presentation specifiers as in ``std::format``. For example:

  .. code:: c++

     #include <fmt/core.h>
     #include <locale>

     int main() {
       std::locale::global(std::locale("fr_FR.UTF-8"));
       fmt::print("{0:.2Lf}", 0.42);
     }

  prints "0,42". The deprecated ``'n'`` specifier has been removed.

* Made the ``0`` specifier ignored for infinity and NaN
  (`#2305 <https://github.com/fmtlib/fmt/issues/2305>`_,
  `#2310 <https://github.com/fmtlib/fmt/pull/2310>`_).
  Thanks `@Liedtke (Matthias Liedtke) <https://github.com/Liedtke>`_.

* Made the hexfloat formatting use the right alignment by default
  (`#2308 <https://github.com/fmtlib/fmt/issues/2308>`_,
  `#2317 <https://github.com/fmtlib/fmt/pull/2317>`_).
  Thanks `@Liedtke (Matthias Liedtke) <https://github.com/Liedtke>`_.

* Removed the deprecated numeric alignment (``'='``). Use the ``'0'`` specifier
  instead.

* Removed the deprecated ``fmt/posix.h`` header that has been replaced with
  ``fmt/os.h``.

* Removed the deprecated ``format_to_n_context``, ``format_to_n_args`` and
  ``make_format_to_n_args``. They have been replaced with ``format_context``,
  ``format_args` and ``make_format_args`` respectively.

* Moved ``wchar_t``-specific functions and types to ``fmt/xchar.h``.
  You can define ``FMT_DEPRECATED_INCLUDE_XCHAR`` to automatically include
  ``fmt/xchar.h`` from ``fmt/format.h`` but this will be disabled in the next
  major release.

* Fixed handling of the ``'+'`` specifier in localized formatting
  (`#2133 <https://github.com/fmtlib/fmt/issues/2133>`_).

* Added support for the ``'s'`` format specifier that gives textual
  representation of ``bool``
  (`#2094 <https://github.com/fmtlib/fmt/issues/2094>`_,
  `#2109 <https://github.com/fmtlib/fmt/pull/2109>`_). For example:

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{:s}", true);
     }

  prints "true".
  Thanks `@powercoderlol (Ivan Polyakov) <https://github.com/powercoderlol>`_.

* Made ``fmt::ptr`` work with function pointers
  (`#2131 <https://github.com/fmtlib/fmt/pull/2131>`_). For example:

  .. code:: c++

     #include <fmt/format.h>

     int main() {
       fmt::print("My main: {}\n", fmt::ptr(main));
     }

  Thanks `@mikecrowe (Mike Crowe) <https://github.com/mikecrowe>`_.

* Fixed ``fmt::formatted_size`` with format string compilation
  (`#2141 <https://github.com/fmtlib/fmt/pull/2141>`_,
  `#2161 <https://github.com/fmtlib/fmt/pull/2161>`_).
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Fixed handling of empty format strings during format string compilation
  (`#2042 <https://github.com/fmtlib/fmt/issues/2042>`_):

  .. code:: c++

     auto s = fmt::format(FMT_COMPILE(""));

  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Fixed handling of enums in ``fmt::to_string``
  (`#2036 <https://github.com/fmtlib/fmt/issues/2036>`_).

* Improved width computation
  (`#2033 <https://github.com/fmtlib/fmt/issues/2033>`_,
  `#2091 <https://github.com/fmtlib/fmt/issues/2091>`_). For example:

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{:-<10}{}\n", "你好", "世界");
       fmt::print("{:-<10}{}\n", "hello", "world");
     }

  prints

  .. image:: https://user-images.githubusercontent.com/576385/
             119840373-cea3ca80-beb9-11eb-91e0-54266c48e181.png

  on a modern terminal.

* The experimental fast output stream (``fmt::ostream``) is now truncated by
  default for consistency with ``fopen``
  (`#2018 <https://github.com/fmtlib/fmt/issues/2018>`_). For example:

  .. code:: c++

     #include <fmt/os.h>

     int main() {
       fmt::ostream out1 = fmt::output_file("guide");
       out1.print("Zaphod");
       out1.close();
       fmt::ostream out2 = fmt::output_file("guide");
       out2.print("Ford");
     }

  writes "Ford" to the file "guide". To preserve the old file content if any
  pass ``fmt::file::WRONLY | fmt::file::CREATE`` flags to ``fmt::output_file``.

* Fixed moving of ``fmt::ostream`` that holds buffered data
  (`#2197 <https://github.com/fmtlib/fmt/issues/2197>`_,
  `#2198 <https://github.com/fmtlib/fmt/pull/2198>`_).
  Thanks `@vtta <https://github.com/vtta>`_.

* Replaced the ``fmt::system_error`` exception with a function of the same
  name that constructs ``std::system_error``
  (`#2266 <https://github.com/fmtlib/fmt/issues/2266>`_).

* Replaced the ``fmt::windows_error`` exception with a function of the same
  name that constructs ``std::system_error`` with the category returned by
  ``fmt::system_category()``
  (`#2274 <https://github.com/fmtlib/fmt/issues/2274>`_,
  `#2275 <https://github.com/fmtlib/fmt/pull/2275>`_).
  The latter is similar to ``std::sytem_category`` but correctly handles UTF-8.
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.

* Replaced ``fmt::error_code`` with ``std::error_code`` and made it formattable
  (`#2269 <https://github.com/fmtlib/fmt/issues/2269>`_,
  `#2270 <https://github.com/fmtlib/fmt/pull/2270>`_,
  `#2273 <https://github.com/fmtlib/fmt/pull/2273>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 
* Added speech synthesis support
  (`#2206 <https://github.com/fmtlib/fmt/pull/2206>`_).

* Made ``format_to`` work with a memory buffer that has a custom allocator
  (`#2300 <https://github.com/fmtlib/fmt/pull/2300>`_).
  Thanks `@voxmea <https://github.com/voxmea>`_.

* Added ``Allocator::max_size`` support to ``basic_memory_buffer``.
  (`#1960 <https://github.com/fmtlib/fmt/pull/1960>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.

* Added wide string support to ``fmt::join``
  (`#2236 <https://github.com/fmtlib/fmt/pull/2236>`_).
  Thanks `@crbrz <https://github.com/crbrz>`_.

* Made iterators passed to ``formatter`` specializations via a format context
  satisfy C++20 ``std::output_iterator`` requirements
  (`#2156 <https://github.com/fmtlib/fmt/issues/2156>`_,
  `#2158 <https://github.com/fmtlib/fmt/pull/2158>`_,
  `#2195 <https://github.com/fmtlib/fmt/issues/2195>`_,
  `#2204 <https://github.com/fmtlib/fmt/pull/2204>`_).
  Thanks `@randomnetcat (Jason Cobb) <https://github.com/randomnetcat>`_.

* Optimized the ``printf`` implementation
  (`#1982 <https://github.com/fmtlib/fmt/pull/1982>`_,
  `#1984 <https://github.com/fmtlib/fmt/pull/1984>`_,
  `#2016 <https://github.com/fmtlib/fmt/pull/2016>`_,
  `#2164 <https://github.com/fmtlib/fmt/pull/2164>`_).
  Thanks `@rimathia <https://github.com/rimathia>`_ and
  `@moiwi <https://github.com/moiwi>`_.

* Improved detection of ``constexpr`` ``char_traits``
  (`#2246 <https://github.com/fmtlib/fmt/pull/2246>`_,
  `#2257 <https://github.com/fmtlib/fmt/pull/2257>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.

* Fixed writing to ``stdout`` when it is redirected to ``NUL`` on Windows
  (`#2080 <https://github.com/fmtlib/fmt/issues/2080>`_).

* Fixed exception propagation from iterators
  (`#2097 <https://github.com/fmtlib/fmt/issues/2097>`_).
  
* Improved ``strftime`` error handling 
  (`#2238 <https://github.com/fmtlib/fmt/issues/2238>`_,
  `#2244 <https://github.com/fmtlib/fmt/pull/2244>`_).
  Thanks `@yumeyao <https://github.com/yumeyao>`_.

* Stopped using deprecated GCC UDL template extension.

* Added ``fmt/args.h`` to the install target
  (`#2096 <https://github.com/fmtlib/fmt/issues/2096>`_).

* Error messages are now passed to assert when exceptions are disabled
  (`#2145 <https://github.com/fmtlib/fmt/pull/2145>`_).
  Thanks `@NobodyXu (Jiahao XU) <https://github.com/NobodyXu>`_.

* Added the ``FMT_MASTER_PROJECT`` CMake option to control build and install
  targets when {fmt} is included via ``add_subdirectory``
  (`#2098 <https://github.com/fmtlib/fmt/issues/2098>`_,
  `#2100 <https://github.com/fmtlib/fmt/pull/2100>`_).
  Thanks `@randomizedthinking <https://github.com/randomizedthinking>`_.

* Improved build configuration
  (`#2026 <https://github.com/fmtlib/fmt/pull/2026>`_,
  `#2122 <https://github.com/fmtlib/fmt/pull/2122>`_).
  Thanks `@luncliff (Park DongHa) <https://github.com/luncliff>`_ and
  `@ibaned (Dan Ibanez) <https://github.com/ibaned>`_.

* Fixed various warnings and compilation issues
  (`#1947 <https://github.com/fmtlib/fmt/issues/1947>`_,
  `#1959 <https://github.com/fmtlib/fmt/pull/1959>`_,
  `#1963 <https://github.com/fmtlib/fmt/pull/1963>`_,
  `#1965 <https://github.com/fmtlib/fmt/pull/1965>`_,
  `#1966 <https://github.com/fmtlib/fmt/issues/1966>`_,
  `#1974 <https://github.com/fmtlib/fmt/pull/1974>`_,
  `#1975 <https://github.com/fmtlib/fmt/pull/1975>`_,
  `#1990 <https://github.com/fmtlib/fmt/pull/1990>`_,
  `#2000 <https://github.com/fmtlib/fmt/issues/2000>`_,
  `#2001 <https://github.com/fmtlib/fmt/pull/2001>`_,
  `#2002 <https://github.com/fmtlib/fmt/issues/2002>`_,
  `#2004 <https://github.com/fmtlib/fmt/issues/2004>`_,
  `#2006 <https://github.com/fmtlib/fmt/pull/2006>`_,
  `#2009 <https://github.com/fmtlib/fmt/pull/2009>`_,
  `#2010 <https://github.com/fmtlib/fmt/pull/2010>`_,
  `#2038 <https://github.com/fmtlib/fmt/issues/2038>`_,
  `#2039 <https://github.com/fmtlib/fmt/issues/2039>`_,
  `#2047 <https://github.com/fmtlib/fmt/issues/2047>`_,
  `#2053 <https://github.com/fmtlib/fmt/pull/2053>`_,
  `#2059 <https://github.com/fmtlib/fmt/issues/2059>`_,
  `#2065 <https://github.com/fmtlib/fmt/pull/2065>`_,
  `#2067 <https://github.com/fmtlib/fmt/pull/2067>`_,
  `#2068 <https://github.com/fmtlib/fmt/pull/2068>`_,
  `#2073 <https://github.com/fmtlib/fmt/pull/2073>`_,
  `#2103 <https://github.com/fmtlib/fmt/issues/2103>`_
  `#2105 <https://github.com/fmtlib/fmt/issues/2105>`_
  `#2106 <https://github.com/fmtlib/fmt/pull/2106>`_,
  `#2107 <https://github.com/fmtlib/fmt/pull/2107>`_,
  `#2116 <https://github.com/fmtlib/fmt/issues/2116>`_
  `#2117 <https://github.com/fmtlib/fmt/pull/2117>`_,
  `#2118 <https://github.com/fmtlib/fmt/issues/2118>`_
  `#2119 <https://github.com/fmtlib/fmt/pull/2119>`_,
  `#2127 <https://github.com/fmtlib/fmt/issues/2127>`_,
  `#2128 <https://github.com/fmtlib/fmt/pull/2128>`_,
  `#2140 <https://github.com/fmtlib/fmt/issues/2140>`_,
  `#2142 <https://github.com/fmtlib/fmt/issues/2142>`_,
  `#2143 <https://github.com/fmtlib/fmt/pull/2143>`_,
  `#2144 <https://github.com/fmtlib/fmt/pull/2144>`_,
  `#2147 <https://github.com/fmtlib/fmt/issues/2147>`_,
  `#2148 <https://github.com/fmtlib/fmt/issues/2148>`_,
  `#2149 <https://github.com/fmtlib/fmt/issues/2149>`_,
  `#2152 <https://github.com/fmtlib/fmt/pull/2152>`_,
  `#2160 <https://github.com/fmtlib/fmt/pull/2160>`_,
  `#2170 <https://github.com/fmtlib/fmt/issues/2170>`_,
  `#2175 <https://github.com/fmtlib/fmt/issues/2175>`_,
  `#2176 <https://github.com/fmtlib/fmt/issues/2176>`_,
  `#2177 <https://github.com/fmtlib/fmt/pull/2177>`_,
  `#2178 <https://github.com/fmtlib/fmt/issues/2178>`_,
  `#2179 <https://github.com/fmtlib/fmt/pull/2179>`_,
  `#2180 <https://github.com/fmtlib/fmt/issues/2180>`_,
  `#2181 <https://github.com/fmtlib/fmt/issues/2181>`_,
  `#2183 <https://github.com/fmtlib/fmt/pull/2183>`_,
  `#2184 <https://github.com/fmtlib/fmt/issues/2184>`_,
  `#2185 <https://github.com/fmtlib/fmt/issues/2185>`_,
  `#2186 <https://github.com/fmtlib/fmt/pull/2186>`_,
  `#2187 <https://github.com/fmtlib/fmt/pull/2187>`_,
  `#2190 <https://github.com/fmtlib/fmt/pull/2190>`_,
  `#2192 <https://github.com/fmtlib/fmt/pull/2192>`_,
  `#2194 <https://github.com/fmtlib/fmt/pull/2194>`_,
  `#2205 <https://github.com/fmtlib/fmt/pull/2205>`_,
  `#2210 <https://github.com/fmtlib/fmt/issues/2210>`_,
  `#2211 <https://github.com/fmtlib/fmt/pull/2211>`_,
  `#2215 <https://github.com/fmtlib/fmt/pull/2215>`_,
  `#2216 <https://github.com/fmtlib/fmt/pull/2216>`_,
  `#2218 <https://github.com/fmtlib/fmt/pull/2218>`_,
  `#2220 <https://github.com/fmtlib/fmt/pull/2220>`_,
  `#2228 <https://github.com/fmtlib/fmt/issues/2228>`_,
  `#2229 <https://github.com/fmtlib/fmt/pull/2229>`_,
  `#2230 <https://github.com/fmtlib/fmt/pull/2230>`_,
  `#2233 <https://github.com/fmtlib/fmt/issues/2233>`_,
  `#2239 <https://github.com/fmtlib/fmt/pull/2239>`_,
  `#2248 <https://github.com/fmtlib/fmt/issues/2248>`_,
  `#2252 <https://github.com/fmtlib/fmt/issues/2252>`_,
  `#2253 <https://github.com/fmtlib/fmt/pull/2253>`_,
  `#2255 <https://github.com/fmtlib/fmt/pull/2255>`_,
  `#2261 <https://github.com/fmtlib/fmt/issues/2261>`_,
  `#2278 <https://github.com/fmtlib/fmt/issues/2278>`_,
  `#2284 <https://github.com/fmtlib/fmt/issues/2284>`_,
  `#2287 <https://github.com/fmtlib/fmt/pull/2287>`_,
  `#2289 <https://github.com/fmtlib/fmt/pull/2289>`_,
  `#2290 <https://github.com/fmtlib/fmt/pull/2290>`_,
  `#2293 <https://github.com/fmtlib/fmt/pull/2293>`_,
  `#2295 <https://github.com/fmtlib/fmt/issues/2295>`_,
  `#2296 <https://github.com/fmtlib/fmt/pull/2296>`_,
  `#2297 <https://github.com/fmtlib/fmt/pull/2297>`_,
  `#2311 <https://github.com/fmtlib/fmt/issues/2311>`_,
  `#2313 <https://github.com/fmtlib/fmt/pull/2313>`_,
  `#2315 <https://github.com/fmtlib/fmt/pull/2315>`_,
  `#2320 <https://github.com/fmtlib/fmt/issues/2320>`_,
  `#2321 <https://github.com/fmtlib/fmt/pull/2321>`_,
  `#2323 <https://github.com/fmtlib/fmt/pull/2323>`_,
  `#2328 <https://github.com/fmtlib/fmt/issues/2328>`_,
  `#2329 <https://github.com/fmtlib/fmt/pull/2329>`_,
  `#2333 <https://github.com/fmtlib/fmt/pull/2333>`_,
  `#2338 <https://github.com/fmtlib/fmt/pull/2338>`_,
  `#2341 <https://github.com/fmtlib/fmt/pull/2341>`_).
  Thanks `@darklukee <https://github.com/darklukee>`_,
  `@fagg (Ashton Fagg) <https://github.com/fagg>`_,
  `@killerbot242 (Lieven de Cock) <https://github.com/killerbot242>`_,
  `@jgopel (Jonathan Gopel) <https://github.com/jgopel>`_,
  `@yeswalrus (Walter Gray) <https://github.com/yeswalrus>`_,
  `@Finkman <https://github.com/Finkman>`_,
  `@HazardyKnusperkeks (Björn Schäpers) <https://github.com/HazardyKnusperkeks>`_,
  `@dkavolis (Daumantas Kavolis) <https://github.com/dkavolis>`_
  `@concatime (Issam Maghni) <https://github.com/concatime>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@summivox (Yin Zhong) <https://github.com/summivox>`_,
  `@yNeo <https://github.com/yNeo>`_,
  `@Apache-HB (Elliot) <https://github.com/Apache-HB>`_,
  `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_,
  `@toojays (John Steele Scott) <https://github.com/toojays>`_,
  `@Brainy0207 <https://github.com/Brainy0207>`_,
  `@vadz (VZ) <https://github.com/vadz>`_,
  `@imsherlock (Ryan Sherlock) <https://github.com/imsherlock>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@white238 (Chris White) <https://github.com/white238>`_,
  `@yafshar (Yaser Afshar) <https://github.com/yafshar>`_,
  `@BillyDonahue (Billy Donahue) <https://github.com/BillyDonahue>`_,
  `@jstaahl <https://github.com/jstaahl>`_,
  `@denchat <https://github.com/denchat>`_,
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_,
  `@ilyakurdyukov (Ilya Kurdyukov) <https://github.com/ilyakurdyukov>`_,
  `@ilmai <https://github.com/ilmai>`_,
  `@JessyDL (Jessy De Lannoit) <https://github.com/JessyDL>`_,
  `@sergiud (Sergiu Deitsch) <https://github.com/sergiud>`_,
  `@mwinterb <https://github.com/mwinterb>`_,
  `@sven-herrmann <https://github.com/sven-herrmann>`_,
  `@jmelas (John Melas) <https://github.com/jmelas>`_,
  `@twoixter (Jose Miguel Pérez) <https://github.com/twoixter>`_,
  `@crbrz <https://github.com/crbrz>`_,
  `@upsj (Tobias Ribizel) <https://github.com/upsj>`_.

* Improved documentation
  (`#1986 <https://github.com/fmtlib/fmt/issues/1986>`_,
  `#2051 <https://github.com/fmtlib/fmt/pull/2051>`_,
  `#2057 <https://github.com/fmtlib/fmt/issues/2057>`_,
  `#2081 <https://github.com/fmtlib/fmt/pull/2081>`_,
  `#2084 <https://github.com/fmtlib/fmt/issues/2084>`_,
  `#2312 <https://github.com/fmtlib/fmt/pull/2312>`_).
  Thanks `@imba-tjd (谭九鼎) <https://github.com/imba-tjd>`_,
  `@0x416c69 (AlιAѕѕaѕѕιN) <https://github.com/0x416c69>`_,
  `@mordante <https://github.com/mordante>`_.

* Continuous integration and test improvements
  (`#1969 <https://github.com/fmtlib/fmt/issues/1969>`_,
  `#1991 <https://github.com/fmtlib/fmt/pull/1991>`_,
  `#2020 <https://github.com/fmtlib/fmt/pull/2020>`_,
  `#2110 <https://github.com/fmtlib/fmt/pull/2110>`_,
  `#2114 <https://github.com/fmtlib/fmt/pull/2114>`_,
  `#2196 <https://github.com/fmtlib/fmt/issues/2196>`_,
  `#2217 <https://github.com/fmtlib/fmt/pull/2217>`_,
  `#2247 <https://github.com/fmtlib/fmt/pull/2247>`_,
  `#2256 <https://github.com/fmtlib/fmt/pull/2256>`_,
  `#2336 <https://github.com/fmtlib/fmt/pull/2336>`_,
  `#2346 <https://github.com/fmtlib/fmt/pull/2346>`_).
  Thanks `@jgopel (Jonathan Gopel) <https://github.com/jgopel>`_,
  `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_ and
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.
  
7.1.3 - 2020-11-24
------------------

* Fixed handling of buffer boundaries in ``format_to_n``
  (`#1996 <https://github.com/fmtlib/fmt/issues/1996>`_,
  `#2029 <https://github.com/fmtlib/fmt/issues/2029>`_).

* Fixed linkage errors when linking with a shared library
  (`#2011 <https://github.com/fmtlib/fmt/issues/2011>`_).

* Reintroduced ostream support to range formatters
  (`#2014 <https://github.com/fmtlib/fmt/issues/2014>`_).

* Worked around an issue with mixing std versions in gcc
  (`#2017 <https://github.com/fmtlib/fmt/issues/2017>`_).

7.1.2 - 2020-11-04
------------------

* Fixed floating point formatting with large precision
  (`#1976 <https://github.com/fmtlib/fmt/issues/1976>`_).

7.1.1 - 2020-11-01
------------------

* Fixed ABI compatibility with 7.0.x
  (`#1961 <https://github.com/fmtlib/fmt/issues/1961>`_).

* Added the ``FMT_ARM_ABI_COMPATIBILITY`` macro to work around ABI
  incompatibility between GCC and Clang on ARM
  (`#1919 <https://github.com/fmtlib/fmt/issues/1919>`_).

* Worked around a SFINAE bug in GCC 8
  (`#1957 <https://github.com/fmtlib/fmt/issues/1957>`_).

* Fixed linkage errors when building with GCC's LTO
  (`#1955 <https://github.com/fmtlib/fmt/issues/1955>`_).

* Fixed a compilation error when building without ``__builtin_clz`` or equivalent
  (`#1968 <https://github.com/fmtlib/fmt/pull/1968>`_).
  Thanks `@tohammer (Tobias Hammer) <https://github.com/tohammer>`_.

* Fixed a sign conversion warning
  (`#1964 <https://github.com/fmtlib/fmt/pull/1964>`_).
  Thanks `@OptoCloud <https://github.com/OptoCloud>`_.

7.1.0 - 2020-10-25
------------------

* Switched from `Grisu3
  <https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf>`_
  to `Dragonbox <https://github.com/jk-jeon/dragonbox>`_ for the default
  floating-point formatting which gives the shortest decimal representation
  with round-trip guarantee and correct rounding
  (`#1882 <https://github.com/fmtlib/fmt/pull/1882>`_,
  `#1887 <https://github.com/fmtlib/fmt/pull/1887>`_,
  `#1894 <https://github.com/fmtlib/fmt/pull/1894>`_). This makes {fmt} up to
  20-30x faster than common implementations of ``std::ostringstream`` and
  ``sprintf`` on `dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_
  and faster than double-conversion and Ryū:

  .. image:: https://user-images.githubusercontent.com/576385/
             95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png

  It is possible to get even better performance at the cost of larger binary
  size by compiling with the ``FMT_USE_FULL_CACHE_DRAGONBOX`` macro set to 1.

  Thanks `@jk-jeon (Junekey Jeon) <https://github.com/jk-jeon>`_.

* Added an experimental unsynchronized file output API which, together with
  `format string compilation <https://fmt.dev/latest/api.html#compile-api>`_,
  can give `5-9 times speed up compared to fprintf
  <https://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html>`_
  on common platforms (`godbolt <https://godbolt.org/z/nsTcG8>`__):

  .. code:: c++

     #include <fmt/os.h>

     int main() {
       auto f = fmt::output_file("guide");
       f.print("The answer is {}.", 42);
     }

* Added a formatter for ``std::chrono::time_point<system_clock>``
  (`#1819 <https://github.com/fmtlib/fmt/issues/1819>`_,
  `#1837 <https://github.com/fmtlib/fmt/pull/1837>`_). For example
  (`godbolt <https://godbolt.org/z/c4M6fh>`__):

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       auto now = std::chrono::system_clock::now();
       fmt::print("The time is {:%H:%M:%S}.\n", now);
     }

  Thanks `@adamburgess (Adam Burgess) <https://github.com/adamburgess>`_.

* Added support for ranges with non-const ``begin``/``end`` to ``fmt::join``
  (`#1784 <https://github.com/fmtlib/fmt/issues/1784>`_,
  `#1786 <https://github.com/fmtlib/fmt/pull/1786>`_). For example
  (`godbolt <https://godbolt.org/z/jP63Tv>`__):

  .. code:: c++

     #include <fmt/ranges.h>
     #include <range/v3/view/filter.hpp>

     int main() {
       using std::literals::string_literals::operator""s;
       auto strs = std::array{"a"s, "bb"s, "ccc"s};
       auto range = strs | ranges::views::filter(
         [] (const std::string &x) { return x.size() != 2; }
       );
       fmt::print("{}\n", fmt::join(range, ""));
     }

  prints "accc".

  Thanks `@tonyelewis (Tony E Lewis) <https://github.com/tonyelewis>`_.

* Added a ``memory_buffer::append`` overload that takes a range
  (`#1806 <https://github.com/fmtlib/fmt/pull/1806>`_).
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.

* Improved handling of single code units in ``FMT_COMPILE``. For example:

  .. code:: c++

     #include <fmt/compile.h>

     char* f(char* buf) {
       return fmt::format_to(buf, FMT_COMPILE("x{}"), 42);
     }

  compiles to just (`godbolt <https://godbolt.org/z/5vncz3>`__):

  .. code:: asm

     _Z1fPc:
       movb $120, (%rdi)
       xorl %edx, %edx
       cmpl $42, _ZN3fmt2v76detail10basic_dataIvE23zero_or_powers_of_10_32E+8(%rip)
       movl $3, %eax
       seta %dl
       subl %edx, %eax
       movzwl _ZN3fmt2v76detail10basic_dataIvE6digitsE+84(%rip), %edx
       cltq
       addq %rdi, %rax
       movw %dx, -2(%rax)
       ret

  Here a single ``mov`` instruction writes ``'x'`` (``$120``) to the output
  buffer.

* Added dynamic width support to format string compilation
  (`#1809 <https://github.com/fmtlib/fmt/issues/1809>`_).

* Improved error reporting for unformattable types: now you'll get the type name
  directly in the error message instead of the note:

  .. code:: c++

     #include <fmt/core.h>

     struct how_about_no {};

     int main() {
       fmt::print("{}", how_about_no());
     }

  Error (`godbolt <https://godbolt.org/z/GoxM4e>`__):

  ``fmt/core.h:1438:3: error: static_assert failed due to requirement
  'fmt::v7::formattable<how_about_no>()' "Cannot format an argument.
  To make type T formattable provide a formatter<T> specialization:
  https://fmt.dev/latest/api.html#udt"
  ...``

* Added the `make_args_checked <https://fmt.dev/7.1.0/api.html#argument-lists>`_
  function template that allows you to write formatting functions with
  compile-time format string checks and avoid binary code bloat
  (`godbolt <https://godbolt.org/z/PEf9qr>`__):

  .. code:: c++

     void vlog(const char* file, int line, fmt::string_view format,
               fmt::format_args args) {
       fmt::print("{}: {}: ", file, line);
       fmt::vprint(format, args);
     }

     template <typename S, typename... Args>
     void log(const char* file, int line, const S& format, Args&&... args) {
       vlog(file, line, format,
           fmt::make_args_checked<Args...>(format, args...));
     }

     #define MY_LOG(format, ...) \
       log(__FILE__, __LINE__, FMT_STRING(format), __VA_ARGS__)

     MY_LOG("invalid squishiness: {}", 42);

* Replaced ``snprintf`` fallback with a faster internal IEEE 754 ``float`` and
  ``double`` formatter for arbitrary precision. For example
  (`godbolt <https://godbolt.org/z/dPhWvj>`__):

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{:.500}\n", 4.9406564584124654E-324);
     }

  prints

  ``4.9406564584124654417656879286822137236505980261432476442558568250067550727020875186529983636163599237979656469544571773092665671035593979639877479601078187812630071319031140452784581716784898210368871863605699873072305000638740915356498438731247339727316961514003171538539807412623856559117102665855668676818703956031062493194527159149245532930545654440112748012970999954193198940908041656332452475714786901472678015935523861155013480352649347201937902681071074917033322268447533357208324319360923829e-324``.

* Made ``format_to_n`` and ``formatted_size`` part of the `core API
  <https://fmt.dev/latest/api.html#core-api>`__
  (`godbolt <https://godbolt.org/z/sPjY1K>`__):

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       char buffer[10];
       auto result = fmt::format_to_n(buffer, sizeof(buffer), "{}", 42);
     }

* Added ``fmt::format_to_n`` overload with format string compilation
  (`#1764 <https://github.com/fmtlib/fmt/issues/1764>`_,
  `#1767 <https://github.com/fmtlib/fmt/pull/1767>`_,
  `#1869 <https://github.com/fmtlib/fmt/pull/1869>`_). For example
  (`godbolt <https://godbolt.org/z/93h86q>`__):

  .. code:: c++

     #include <fmt/compile.h>

     int main() {
       char buffer[8];
       fmt::format_to_n(buffer, sizeof(buffer), FMT_COMPILE("{}"), 42);
     }

  Thanks `@Kurkin (Dmitry Kurkin) <https://github.com/Kurkin>`_,
  `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Added ``fmt::format_to`` overload that take ``text_style``
  (`#1593 <https://github.com/fmtlib/fmt/issues/1593>`_,
  `#1842 <https://github.com/fmtlib/fmt/issues/1842>`_,
  `#1843 <https://github.com/fmtlib/fmt/pull/1843>`_). For example
  (`godbolt <https://godbolt.org/z/91153r>`__):

  .. code:: c++

     #include <fmt/color.h>

     int main() {
       std::string out;
       fmt::format_to(std::back_inserter(out),
                      fmt::emphasis::bold | fg(fmt::color::red),
                      "The answer is {}.", 42);
     }

  Thanks `@Naios (Denis Blank) <https://github.com/Naios>`_.

* Made the ``'#'`` specifier emit trailing zeros in addition to the decimal
  point (`#1797 <https://github.com/fmtlib/fmt/issues/1797>`_). For example
  (`godbolt <https://godbolt.org/z/bhdcW9>`__):

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("{:#.2g}", 0.5);
     }

  prints ``0.50``.

* Changed the default floating point format to not include ``.0`` for
  consistency with ``std::format`` and ``std::to_chars``
  (`#1893 <https://github.com/fmtlib/fmt/issues/1893>`_,
  `#1943 <https://github.com/fmtlib/fmt/issues/1943>`_). It is possible to get
  the decimal point and trailing zero with the ``#`` specifier.

* Fixed an issue with floating-point formatting that could result in addition of
  a non-significant trailing zero in rare cases e.g. ``1.00e-34`` instead of
  ``1.0e-34`` (`#1873 <https://github.com/fmtlib/fmt/issues/1873>`_,
  `#1917 <https://github.com/fmtlib/fmt/issues/1917>`_).

* Made ``fmt::to_string`` fallback on ``ostream`` insertion operator if
  the ``formatter`` specialization is not provided
  (`#1815 <https://github.com/fmtlib/fmt/issues/1815>`_,
  `#1829 <https://github.com/fmtlib/fmt/pull/1829>`_).
  Thanks `@alexezeder (Alexey Ochapov) <https://github.com/alexezeder>`_.

* Added support for the append mode to the experimental file API and
  improved ``fcntl.h`` detection.
  (`#1847 <https://github.com/fmtlib/fmt/pull/1847>`_,
  `#1848 <https://github.com/fmtlib/fmt/pull/1848>`_).
  Thanks `@t-wiser <https://github.com/t-wiser>`_.

* Fixed handling of types that have both an implicit conversion operator and
  an overloaded ``ostream`` insertion operator
  (`#1766 <https://github.com/fmtlib/fmt/issues/1766>`_).

* Fixed a slicing issue in an internal iterator type
  (`#1822 <https://github.com/fmtlib/fmt/pull/1822>`_).
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.

* Fixed an issue in locale-specific integer formatting
  (`#1927 <https://github.com/fmtlib/fmt/issues/1927>`_).

* Fixed handling of exotic code unit types
  (`#1870 <https://github.com/fmtlib/fmt/issues/1870>`_,
  `#1932 <https://github.com/fmtlib/fmt/issues/1932>`_).

* Improved ``FMT_ALWAYS_INLINE``
  (`#1878 <https://github.com/fmtlib/fmt/pull/1878>`_).
  Thanks `@jk-jeon (Junekey Jeon) <https://github.com/jk-jeon>`_.

* Removed dependency on ``windows.h``
  (`#1900 <https://github.com/fmtlib/fmt/pull/1900>`_).
  Thanks `@bernd5 (Bernd Baumanns) <https://github.com/bernd5>`_.

* Optimized counting of decimal digits on MSVC
  (`#1890 <https://github.com/fmtlib/fmt/pull/1890>`_).
  Thanks `@mwinterb <https://github.com/mwinterb>`_.

* Improved documentation
  (`#1772 <https://github.com/fmtlib/fmt/issues/1772>`_,
  `#1775 <https://github.com/fmtlib/fmt/pull/1775>`_,
  `#1792 <https://github.com/fmtlib/fmt/pull/1792>`_,
  `#1838 <https://github.com/fmtlib/fmt/pull/1838>`_,
  `#1888 <https://github.com/fmtlib/fmt/pull/1888>`_,
  `#1918 <https://github.com/fmtlib/fmt/pull/1918>`_,
  `#1939 <https://github.com/fmtlib/fmt/pull/1939>`_).
  Thanks `@leolchat (Léonard Gérard) <https://github.com/leolchat>`_,
  `@pepsiman (Malcolm Parsons) <https://github.com/pepsiman>`_,
  `@Klaim (Joël Lamotte) <https://github.com/Klaim>`_,
  `@ravijanjam (Ravi J) <https://github.com/ravijanjam>`_,
  `@francesco-st <https://github.com/francesco-st>`_,
  `@udnaan (Adnan) <https://github.com/udnaan>`_.

* Added the ``FMT_REDUCE_INT_INSTANTIATIONS`` CMake option that reduces the
  binary code size at the cost of some integer formatting performance. This can
  be useful for extremely memory-constrained embedded systems
  (`#1778 <https://github.com/fmtlib/fmt/issues/1778>`_,
  `#1781 <https://github.com/fmtlib/fmt/pull/1781>`_).
  Thanks `@kammce (Khalil Estell) <https://github.com/kammce>`_.

* Added the ``FMT_USE_INLINE_NAMESPACES`` macro to control usage of inline
  namespaces (`#1945 <https://github.com/fmtlib/fmt/pull/1945>`_).
  Thanks `@darklukee <https://github.com/darklukee>`_.

* Improved build configuration
  (`#1760 <https://github.com/fmtlib/fmt/pull/1760>`_,
  `#1770 <https://github.com/fmtlib/fmt/pull/1770>`_,
  `#1779 <https://github.com/fmtlib/fmt/issues/1779>`_,
  `#1783 <https://github.com/fmtlib/fmt/pull/1783>`_,
  `#1823 <https://github.com/fmtlib/fmt/pull/1823>`_).
  Thanks `@dvetutnev (Dmitriy Vetutnev) <https://github.com/dvetutnev>`_,
  `@xvitaly (Vitaly Zaitsev) <https://github.com/xvitaly>`_,
  `@tambry (Raul Tambre) <https://github.com/tambry>`_,
  `@medithe <https://github.com/medithe>`_,
  `@martinwuehrer (Martin Wührer) <https://github.com/martinwuehrer>`_.

* Fixed various warnings and compilation issues
  (`#1790 <https://github.com/fmtlib/fmt/pull/1790>`_,
  `#1802 <https://github.com/fmtlib/fmt/pull/1802>`_,
  `#1808 <https://github.com/fmtlib/fmt/pull/1808>`_,
  `#1810 <https://github.com/fmtlib/fmt/issues/1810>`_,
  `#1811 <https://github.com/fmtlib/fmt/issues/1811>`_,
  `#1812 <https://github.com/fmtlib/fmt/pull/1812>`_,
  `#1814 <https://github.com/fmtlib/fmt/pull/1814>`_,
  `#1816 <https://github.com/fmtlib/fmt/pull/1816>`_,
  `#1817 <https://github.com/fmtlib/fmt/pull/1817>`_,
  `#1818 <https://github.com/fmtlib/fmt/pull/1818>`_,
  `#1825 <https://github.com/fmtlib/fmt/issues/1825>`_,
  `#1836 <https://github.com/fmtlib/fmt/pull/1836>`_,
  `#1855 <https://github.com/fmtlib/fmt/pull/1855>`_,
  `#1856 <https://github.com/fmtlib/fmt/pull/1856>`_,
  `#1860 <https://github.com/fmtlib/fmt/pull/1860>`_,
  `#1877 <https://github.com/fmtlib/fmt/pull/1877>`_,
  `#1879 <https://github.com/fmtlib/fmt/pull/1879>`_,
  `#1880 <https://github.com/fmtlib/fmt/pull/1880>`_,
  `#1896 <https://github.com/fmtlib/fmt/issues/1896>`_,
  `#1897 <https://github.com/fmtlib/fmt/pull/1897>`_,
  `#1898 <https://github.com/fmtlib/fmt/pull/1898>`_,
  `#1904 <https://github.com/fmtlib/fmt/issues/1904>`_,
  `#1908 <https://github.com/fmtlib/fmt/pull/1908>`_,
  `#1911 <https://github.com/fmtlib/fmt/issues/1911>`_,
  `#1912 <https://github.com/fmtlib/fmt/issues/1912>`_,
  `#1928 <https://github.com/fmtlib/fmt/issues/1928>`_,
  `#1929 <https://github.com/fmtlib/fmt/pull/1929>`_,
  `#1935 <https://github.com/fmtlib/fmt/issues/1935>`_
  `#1937 <https://github.com/fmtlib/fmt/pull/1937>`_,
  `#1942 <https://github.com/fmtlib/fmt/pull/1942>`_,
  `#1949 <https://github.com/fmtlib/fmt/issues/1949>`_).
  Thanks `@TheQwertiest <https://github.com/TheQwertiest>`_,
  `@medithe <https://github.com/medithe>`_,
  `@martinwuehrer (Martin Wührer) <https://github.com/martinwuehrer>`_,
  `@n16h7hunt3r <https://github.com/n16h7hunt3r>`_,
  `@Othereum (Seokjin Lee) <https://github.com/Othereum>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@AlexanderLanin (Alexander Lanin) <https://github.com/AlexanderLanin>`_,
  `@gcerretani (Giovanni Cerretani) <https://github.com/gcerretani>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@noizefloor (Jan Schwers) <https://github.com/noizefloor>`_,
  `@akohlmey (Axel Kohlmeyer) <https://github.com/akohlmey>`_,
  `@jk-jeon (Junekey Jeon) <https://github.com/jk-jeon>`_,
  `@rimathia <https://github.com/rimathia>`_,
  `@rglarix (Riccardo Ghetta (larix)) <https://github.com/rglarix>`_,
  `@moiwi <https://github.com/moiwi>`_,
  `@heckad (Kazantcev Andrey) <https://github.com/heckad>`_,
  `@MarcDirven <https://github.com/MarcDirven>`_.
  `@BartSiwek (Bart Siwek) <https://github.com/BartSiwek>`_,
  `@darklukee <https://github.com/darklukee>`_.

7.0.3 - 2020-08-06
------------------

* Worked around broken ``numeric_limits`` for 128-bit integers
  (`#1787 <https://github.com/fmtlib/fmt/issues/1787>`_).

* Added error reporting on missing named arguments
  (`#1796 <https://github.com/fmtlib/fmt/issues/1796>`_).

* Stopped using 128-bit integers with clang-cl
  (`#1800 <https://github.com/fmtlib/fmt/pull/1800>`_).
  Thanks `@Kingcom <https://github.com/Kingcom>`_.

* Fixed issues in locale-specific integer formatting
  (`#1782 <https://github.com/fmtlib/fmt/issues/1782>`_,
  `#1801 <https://github.com/fmtlib/fmt/issues/1801>`_).

7.0.2 - 2020-07-29
------------------

* Worked around broken ``numeric_limits`` for 128-bit integers
  (`#1725 <https://github.com/fmtlib/fmt/issues/1725>`_).

* Fixed compatibility with CMake 3.4
  (`#1779 <https://github.com/fmtlib/fmt/issues/1779>`_).

* Fixed handling of digit separators in locale-specific formatting
  (`#1782 <https://github.com/fmtlib/fmt/issues/1782>`_).

7.0.1 - 2020-07-07
------------------

* Updated the inline version namespace name.

* Worked around a gcc bug in mangling of alias templates
  (`#1753 <https://github.com/fmtlib/fmt/issues/1753>`_).

* Fixed a linkage error on Windows
  (`#1757 <https://github.com/fmtlib/fmt/issues/1757>`_).
  Thanks `@Kurkin (Dmitry Kurkin) <https://github.com/Kurkin>`_.

* Fixed minor issues with the documentation.

7.0.0 - 2020-07-05
------------------

* Reduced the library size. For example, on macOS a stripped test binary
  statically linked with {fmt} `shrank from ~368k to less than 100k
  <http://www.zverovich.net/2020/05/21/reducing-library-size.html>`_.

* Added a simpler and more efficient `format string compilation API
  <https://fmt.dev/7.0.0/api.html#compile-api>`_:

  .. code:: c++

     #include <fmt/compile.h>

     // Converts 42 into std::string using the most efficient method and no
     // runtime format string processing.
     std::string s = fmt::format(FMT_COMPILE("{}"), 42);

  The old ``fmt::compile`` API is now deprecated.

* Optimized integer formatting: ``format_to`` with format string compilation
  and a stack-allocated buffer is now `faster than to_chars on both
  libc++ and libstdc++
  <http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_.

* Optimized handling of small format strings. For example,

  .. code:: c++

      fmt::format("Result: {}: ({},{},{},{})", str1, str2, str3, str4, str5)

  is now ~40% faster (`#1685 <https://github.com/fmtlib/fmt/issues/1685>`_).

* Applied extern templates to improve compile times when using the core API
  and ``fmt/format.h`` (`#1452 <https://github.com/fmtlib/fmt/issues/1452>`_).
  For example, on macOS with clang the compile time of a test translation unit
  dropped from 2.3s to 0.3s with ``-O2`` and from 0.6s to 0.3s with the default
  settings (``-O0``).

  Before (``-O2``)::

    % time c++ -c test.cc -I include -std=c++17 -O2
    c++ -c test.cc -I include -std=c++17 -O2  2.22s user 0.08s system 99% cpu 2.311 total

  After (``-O2``)::

    % time c++ -c test.cc -I include -std=c++17 -O2
    c++ -c test.cc -I include -std=c++17 -O2  0.26s user 0.04s system 98% cpu 0.303 total

  Before (default)::

    % time c++ -c test.cc -I include -std=c++17
    c++ -c test.cc -I include -std=c++17  0.53s user 0.06s system 98% cpu 0.601 total

  After (default)::

    % time c++ -c test.cc -I include -std=c++17
    c++ -c test.cc -I include -std=c++17  0.24s user 0.06s system 98% cpu 0.301 total

  It is still recommended to use ``fmt/core.h`` instead of ``fmt/format.h`` but
  the compile time difference is now smaller. Thanks
  `@alex3d <https://github.com/alex3d>`_ for the suggestion.

* Named arguments are now stored on stack (no dynamic memory allocations) and
  the compiled code is more compact and efficient. For example

  .. code:: c++

     #include <fmt/core.h>

     int main() {
       fmt::print("The answer is {answer}\n", fmt::arg("answer", 42));
     }

  compiles to just (`godbolt <https://godbolt.org/z/NcfEp_>`__)

  .. code:: asm

      .LC0:
              .string "answer"
      .LC1:
              .string "The answer is {answer}\n"
      main:
              sub     rsp, 56
              mov     edi, OFFSET FLAT:.LC1
              mov     esi, 23
              movabs  rdx, 4611686018427387905
              lea     rax, [rsp+32]
              lea     rcx, [rsp+16]
              mov     QWORD PTR [rsp+8], 1
              mov     QWORD PTR [rsp], rax
              mov     DWORD PTR [rsp+16], 42
              mov     QWORD PTR [rsp+32], OFFSET FLAT:.LC0
              mov     DWORD PTR [rsp+40], 0
              call    fmt::v6::vprint(fmt::v6::basic_string_view<char>,
                                      fmt::v6::format_args)
              xor     eax, eax
              add     rsp, 56
              ret

          .L.str.1:
                  .asciz  "answer"

* Implemented compile-time checks for dynamic width and precision
  (`#1614 <https://github.com/fmtlib/fmt/issues/1614>`_):

  .. code:: c++

     #include <fmt/format.h>

     int main() {
       fmt::print(FMT_STRING("{0:{1}}"), 42);
     }

  now gives a compilation error because argument 1 doesn't exist::

    In file included from test.cc:1:
    include/fmt/format.h:2726:27: error: constexpr variable 'invalid_format' must be
    initialized by a constant expression
      FMT_CONSTEXPR_DECL bool invalid_format =
                              ^
    ...
    include/fmt/core.h:569:26: note: in call to
    '&checker(s, {}).context_->on_error(&"argument not found"[0])'
        if (id >= num_args_) on_error("argument not found");
                            ^

* Added sentinel support to ``fmt::join``
  (`#1689 <https://github.com/fmtlib/fmt/pull/1689>`_)

  .. code:: c++

    struct zstring_sentinel {};
    bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
    bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }

    struct zstring {
      const char* p;
      const char* begin() const { return p; }
      zstring_sentinel end() const { return {}; }
    };

    auto s = fmt::format("{}", fmt::join(zstring{"hello"}, "_"));
    // s == "h_e_l_l_o"

  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.

* Added support for named arguments, ``clear`` and ``reserve`` to
  ``dynamic_format_arg_store``
  (`#1655 <https://github.com/fmtlib/fmt/issues/1655>`_,
  `#1663 <https://github.com/fmtlib/fmt/pull/1663>`_,
  `#1674 <https://github.com/fmtlib/fmt/pull/1674>`_,
  `#1677 <https://github.com/fmtlib/fmt/pull/1677>`_).
  Thanks `@vsolontsov-ll (Vladimir Solontsov)
  <https://github.com/vsolontsov-ll>`_.

* Added support for the ``'c'`` format specifier to integral types for
  compatibility with ``std::format``
  (`#1652 <https://github.com/fmtlib/fmt/issues/1652>`_).

* Replaced the ``'n'`` format specifier with ``'L'`` for compatibility with
  ``std::format`` (`#1624 <https://github.com/fmtlib/fmt/issues/1624>`_).
  The ``'n'`` specifier can be enabled via the ``FMT_DEPRECATED_N_SPECIFIER``
  macro.

* The ``'='`` format specifier is now disabled by default for compatibility with
  ``std::format``. It can be enabled via the ``FMT_DEPRECATED_NUMERIC_ALIGN``
  macro.

* Removed the following deprecated APIs:

  * ``FMT_STRING_ALIAS`` and ``fmt`` macros - replaced by ``FMT_STRING``
  * ``fmt::basic_string_view::char_type`` - replaced by
    ``fmt::basic_string_view::value_type``
  * ``convert_to_int``
  * ``format_arg_store::types``
  * ``*parse_context`` - replaced by ``*format_parse_context``
  * ``FMT_DEPRECATED_INCLUDE_OS``
  * ``FMT_DEPRECATED_PERCENT`` - incompatible with ``std::format``
  * ``*writer`` - replaced by compiled format API

* Renamed the ``internal`` namespace to ``detail``
  (`#1538 <https://github.com/fmtlib/fmt/issues/1538>`_). The former is still
  provided as an alias if the ``FMT_USE_INTERNAL`` macro is defined.

* Improved compatibility between ``fmt::printf`` with the standard specs
  (`#1595 <https://github.com/fmtlib/fmt/issues/1595>`_,
  `#1682 <https://github.com/fmtlib/fmt/pull/1682>`_,
  `#1683 <https://github.com/fmtlib/fmt/pull/1683>`_,
  `#1687 <https://github.com/fmtlib/fmt/pull/1687>`_,
  `#1699 <https://github.com/fmtlib/fmt/pull/1699>`_).
  Thanks `@rimathia <https://github.com/rimathia>`_.

* Fixed handling of ``operator<<`` overloads that use ``copyfmt``
  (`#1666 <https://github.com/fmtlib/fmt/issues/1666>`_).

* Added the ``FMT_OS`` CMake option to control inclusion of OS-specific APIs
  in the fmt target. This can be useful for embedded platforms
  (`#1654 <https://github.com/fmtlib/fmt/issues/1654>`_,
  `#1656 <https://github.com/fmtlib/fmt/pull/1656>`_).
  Thanks `@kwesolowski (Krzysztof Wesolowski)
  <https://github.com/kwesolowski>`_.

* Replaced ``FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION`` with the ``FMT_FUZZ``
  macro to prevent interferring with fuzzing of projects using {fmt}
  (`#1650 <https://github.com/fmtlib/fmt/pull/1650>`_).
  Thanks `@asraa (Asra Ali) <https://github.com/asraa>`_.

* Fixed compatibility with emscripten
  (`#1636 <https://github.com/fmtlib/fmt/issues/1636>`_,
  `#1637 <https://github.com/fmtlib/fmt/pull/1637>`_).
  Thanks `@ArthurSonzogni (Arthur Sonzogni)
  <https://github.com/ArthurSonzogni>`_.

* Improved documentation
  (`#704 <https://github.com/fmtlib/fmt/issues/704>`_,
  `#1643 <https://github.com/fmtlib/fmt/pull/1643>`_,
  `#1660 <https://github.com/fmtlib/fmt/pull/1660>`_,
  `#1681 <https://github.com/fmtlib/fmt/pull/1681>`_,
  `#1691 <https://github.com/fmtlib/fmt/pull/1691>`_,
  `#1706 <https://github.com/fmtlib/fmt/pull/1706>`_,
  `#1714 <https://github.com/fmtlib/fmt/pull/1714>`_,
  `#1721 <https://github.com/fmtlib/fmt/pull/1721>`_,
  `#1739 <https://github.com/fmtlib/fmt/pull/1739>`_,
  `#1740 <https://github.com/fmtlib/fmt/pull/1740>`_,
  `#1741 <https://github.com/fmtlib/fmt/pull/1741>`_,
  `#1751 <https://github.com/fmtlib/fmt/pull/1751>`_).
  Thanks `@senior7515 (Alexander Gallego) <https://github.com/senior7515>`_,
  `@lsr0 (Lindsay Roberts) <https://github.com/lsr0>`_,
  `@puetzk (Kevin Puetz) <https://github.com/puetzk>`_,
  `@fpelliccioni (Fernando Pelliccioni) <https://github.com/fpelliccioni>`_,
  Alexey Kuzmenko, `@jelly (jelle van der Waa) <https://github.com/jelly>`_,
  `@claremacrae (Clare Macrae) <https://github.com/claremacrae>`_,
  `@jiapengwen (文佳鹏) <https://github.com/jiapengwen>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@alexey-milovidov <https://github.com/alexey-milovidov>`_.

* Implemented various build configuration fixes and improvements
  (`#1603 <https://github.com/fmtlib/fmt/pull/1603>`_,
  `#1657 <https://github.com/fmtlib/fmt/pull/1657>`_,
  `#1702 <https://github.com/fmtlib/fmt/pull/1702>`_,
  `#1728 <https://github.com/fmtlib/fmt/pull/1728>`_).
  Thanks `@scramsby (Scott Ramsby) <https://github.com/scramsby>`_,
  `@jtojnar (Jan Tojnar) <https://github.com/jtojnar>`_,
  `@orivej (Orivej Desh) <https://github.com/orivej>`_,
  `@flagarde <https://github.com/flagarde>`_.

* Fixed various warnings and compilation issues
  (`#1616 <https://github.com/fmtlib/fmt/pull/1616>`_,
  `#1620 <https://github.com/fmtlib/fmt/issues/1620>`_,
  `#1622 <https://github.com/fmtlib/fmt/issues/1622>`_,
  `#1625 <https://github.com/fmtlib/fmt/issues/1625>`_,
  `#1627 <https://github.com/fmtlib/fmt/pull/1627>`_,
  `#1628 <https://github.com/fmtlib/fmt/issues/1628>`_,
  `#1629 <https://github.com/fmtlib/fmt/pull/1629>`_,
  `#1631 <https://github.com/fmtlib/fmt/issues/1631>`_,
  `#1633 <https://github.com/fmtlib/fmt/pull/1633>`_,
  `#1649 <https://github.com/fmtlib/fmt/pull/1649>`_,
  `#1658 <https://github.com/fmtlib/fmt/issues/1658>`_,
  `#1661 <https://github.com/fmtlib/fmt/pull/1661>`_,
  `#1667 <https://github.com/fmtlib/fmt/pull/1667>`_,
  `#1668 <https://github.com/fmtlib/fmt/issues/1668>`_,
  `#1669 <https://github.com/fmtlib/fmt/pull/1669>`_,
  `#1692 <https://github.com/fmtlib/fmt/issues/1692>`_,
  `#1696 <https://github.com/fmtlib/fmt/pull/1696>`_,
  `#1697 <https://github.com/fmtlib/fmt/pull/1697>`_,
  `#1707 <https://github.com/fmtlib/fmt/issues/1707>`_,
  `#1712 <https://github.com/fmtlib/fmt/pull/1712>`_,
  `#1716 <https://github.com/fmtlib/fmt/pull/1716>`_,
  `#1722 <https://github.com/fmtlib/fmt/pull/1722>`_,
  `#1724 <https://github.com/fmtlib/fmt/issues/1724>`_,
  `#1729 <https://github.com/fmtlib/fmt/pull/1729>`_,
  `#1738 <https://github.com/fmtlib/fmt/pull/1738>`_,
  `#1742 <https://github.com/fmtlib/fmt/issues/1742>`_,
  `#1743 <https://github.com/fmtlib/fmt/issues/1743>`_,
  `#1744 <https://github.com/fmtlib/fmt/pull/1744>`_,
  `#1747 <https://github.com/fmtlib/fmt/issues/1747>`_,
  `#1750 <https://github.com/fmtlib/fmt/pull/1750>`_).
  Thanks `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@gabime (Gabi Melman) <https://github.com/gabime>`_,
  `@johnor (Johan) <https://github.com/johnor>`_,
  `@Kurkin (Dmitry Kurkin) <https://github.com/Kurkin>`_,
  `@invexed (James Beach) <https://github.com/invexed>`_,
  `@peterbell10 <https://github.com/peterbell10>`_,
  `@daixtrose (Markus Werle) <https://github.com/daixtrose>`_,
  `@petrutlucian94 (Lucian Petrut) <https://github.com/petrutlucian94>`_,
  `@Neargye (Daniil Goncharov) <https://github.com/Neargye>`_,
  `@ambitslix (Attila M. Szilagyi) <https://github.com/ambitslix>`_,
  `@gabime (Gabi Melman) <https://github.com/gabime>`_,
  `@erthink (Leonid Yuriev) <https://github.com/erthink>`_,
  `@tohammer (Tobias Hammer) <https://github.com/tohammer>`_,
  `@0x8000-0000 (Florin Iucha) <https://github.com/0x8000-0000>`_.

6.2.1 - 2020-05-09
------------------

* Fixed ostream support in ``sprintf``
  (`#1631 <https://github.com/fmtlib/fmt/issues/1631>`_).

* Fixed type detection when using implicit conversion to ``string_view`` and
  ostream ``operator<<`` inconsistently
  (`#1662 <https://github.com/fmtlib/fmt/issues/1662>`_).

6.2.0 - 2020-04-05
------------------

* Improved error reporting when trying to format an object of a non-formattable
  type:

  .. code:: c++

     fmt::format("{}", S());

  now gives::

    include/fmt/core.h:1015:5: error: static_assert failed due to requirement
    'formattable' "Cannot format argument. To make type T formattable provide a
    formatter<T> specialization:
    https://fmt.dev/latest/api.html#formatting-user-defined-types"
        static_assert(
        ^
    ...
    note: in instantiation of function template specialization
    'fmt::v6::format<char [3], S, char>' requested here
      fmt::format("{}", S());
           ^

  if ``S`` is not formattable.

* Reduced the library size by ~10%.

* Always print decimal point if ``#`` is specified
  (`#1476 <https://github.com/fmtlib/fmt/issues/1476>`_,
  `#1498 <https://github.com/fmtlib/fmt/issues/1498>`_):

  .. code:: c++

     fmt::print("{:#.0f}", 42.0);

  now prints ``42.``

* Implemented the ``'L'`` specifier for locale-specific numeric formatting to
  improve compatibility with ``std::format``. The ``'n'`` specifier is now
  deprecated and will be removed in the next major release.

* Moved OS-specific APIs such as ``windows_error`` from ``fmt/format.h`` to
  ``fmt/os.h``. You can define ``FMT_DEPRECATED_INCLUDE_OS`` to automatically
  include ``fmt/os.h`` from ``fmt/format.h`` for compatibility but this will be
  disabled in the next major release.

* Added precision overflow detection in floating-point formatting.

* Implemented detection of invalid use of ``fmt::arg``.

* Used ``type_identity`` to block unnecessary template argument deduction.
  Thanks Tim Song.

* Improved UTF-8 handling
  (`#1109 <https://github.com/fmtlib/fmt/issues/1109>`_):

  .. code:: c++

     fmt::print("┌{0:─^{2}}┐\n"
                "│{1: ^{2}}│\n"
                "└{0:─^{2}}┘\n", "", "Привет, мир!", 20);

  now prints::

     ┌────────────────────┐
     │    Привет, мир!    │
     └────────────────────┘

  on systems that support Unicode.

* Added experimental dynamic argument storage
  (`#1170 <https://github.com/fmtlib/fmt/issues/1170>`_,
  `#1584 <https://github.com/fmtlib/fmt/pull/1584>`_):

  .. code:: c++

     fmt::dynamic_format_arg_store<fmt::format_context> store;
     store.push_back("answer");
     store.push_back(42);
     fmt::vprint("The {} is {}.\n", store);
  
  prints::

     The answer is 42.

  Thanks `@vsolontsov-ll (Vladimir Solontsov)
  <https://github.com/vsolontsov-ll>`_.

* Made ``fmt::join`` accept ``initializer_list``
  (`#1591 <https://github.com/fmtlib/fmt/pull/1591>`_).
  Thanks `@Rapotkinnik (Nikolay Rapotkin) <https://github.com/Rapotkinnik>`_.

* Fixed handling of empty tuples
  (`#1588 <https://github.com/fmtlib/fmt/issues/1588>`_).

* Fixed handling of output iterators in ``format_to_n``
  (`#1506 <https://github.com/fmtlib/fmt/issues/1506>`_).

* Fixed formatting of ``std::chrono::duration`` types to wide output
  (`#1533 <https://github.com/fmtlib/fmt/pull/1533>`_).
  Thanks `@zeffy (pilao) <https://github.com/zeffy>`_.

* Added const ``begin`` and ``end`` overload to buffers
  (`#1553 <https://github.com/fmtlib/fmt/pull/1553>`_).
  Thanks `@dominicpoeschko <https://github.com/dominicpoeschko>`_.

* Added the ability to disable floating-point formatting via ``FMT_USE_FLOAT``,
  ``FMT_USE_DOUBLE`` and ``FMT_USE_LONG_DOUBLE`` macros for extremely
  memory-constrained embedded system
  (`#1590 <https://github.com/fmtlib/fmt/pull/1590>`_).
  Thanks `@albaguirre (Alberto Aguirre) <https://github.com/albaguirre>`_.

* Made ``FMT_STRING`` work with ``constexpr`` ``string_view``
  (`#1589 <https://github.com/fmtlib/fmt/pull/1589>`_).
  Thanks `@scramsby (Scott Ramsby) <https://github.com/scramsby>`_.

* Implemented a minor optimization in the format string parser
  (`#1560 <https://github.com/fmtlib/fmt/pull/1560>`_).
  Thanks `@IkarusDeveloper <https://github.com/IkarusDeveloper>`_.

* Improved attribute detection
  (`#1469 <https://github.com/fmtlib/fmt/pull/1469>`_,
  `#1475 <https://github.com/fmtlib/fmt/pull/1475>`_,
  `#1576 <https://github.com/fmtlib/fmt/pull/1576>`_).
  Thanks `@federico-busato (Federico) <https://github.com/federico-busato>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@refnum <https://github.com/refnum>`_.

* Improved documentation
  (`#1481 <https://github.com/fmtlib/fmt/pull/1481>`_,
  `#1523 <https://github.com/fmtlib/fmt/pull/1523>`_).
  Thanks `@JackBoosY (Jack·Boos·Yu) <https://github.com/JackBoosY>`_,
  `@imba-tjd (谭九鼎) <https://github.com/imba-tjd>`_.

* Fixed symbol visibility on Linux when compiling with ``-fvisibility=hidden``
  (`#1535 <https://github.com/fmtlib/fmt/pull/1535>`_).
  Thanks `@milianw (Milian Wolff) <https://github.com/milianw>`_.

* Implemented various build configuration fixes and improvements
  (`#1264 <https://github.com/fmtlib/fmt/issues/1264>`_,
  `#1460 <https://github.com/fmtlib/fmt/issues/1460>`_,
  `#1534 <https://github.com/fmtlib/fmt/pull/1534>`_,
  `#1536 <https://github.com/fmtlib/fmt/issues/1536>`_,
  `#1545 <https://github.com/fmtlib/fmt/issues/1545>`_,
  `#1546 <https://github.com/fmtlib/fmt/pull/1546>`_,
  `#1566 <https://github.com/fmtlib/fmt/issues/1566>`_,
  `#1582 <https://github.com/fmtlib/fmt/pull/1582>`_,
  `#1597 <https://github.com/fmtlib/fmt/issues/1597>`_,
  `#1598 <https://github.com/fmtlib/fmt/pull/1598>`_).
  Thanks `@ambitslix (Attila M. Szilagyi) <https://github.com/ambitslix>`_,
  `@jwillikers (Jordan Williams) <https://github.com/jwillikers>`_,
  `@stac47 (Laurent Stacul) <https://github.com/stac47>`_.

* Fixed various warnings and compilation issues
  (`#1433 <https://github.com/fmtlib/fmt/pull/1433>`_,
  `#1461 <https://github.com/fmtlib/fmt/issues/1461>`_,
  `#1470 <https://github.com/fmtlib/fmt/pull/1470>`_,
  `#1480 <https://github.com/fmtlib/fmt/pull/1480>`_,
  `#1485 <https://github.com/fmtlib/fmt/pull/1485>`_,
  `#1492 <https://github.com/fmtlib/fmt/pull/1492>`_,
  `#1493 <https://github.com/fmtlib/fmt/issues/1493>`_,
  `#1504 <https://github.com/fmtlib/fmt/issues/1504>`_,
  `#1505 <https://github.com/fmtlib/fmt/pull/1505>`_,
  `#1512 <https://github.com/fmtlib/fmt/pull/1512>`_,
  `#1515 <https://github.com/fmtlib/fmt/issues/1515>`_,
  `#1516 <https://github.com/fmtlib/fmt/pull/1516>`_,
  `#1518 <https://github.com/fmtlib/fmt/pull/1518>`_,
  `#1519 <https://github.com/fmtlib/fmt/pull/1519>`_,
  `#1520 <https://github.com/fmtlib/fmt/pull/1520>`_,
  `#1521 <https://github.com/fmtlib/fmt/pull/1521>`_,
  `#1522 <https://github.com/fmtlib/fmt/pull/1522>`_,
  `#1524 <https://github.com/fmtlib/fmt/issues/1524>`_,
  `#1530 <https://github.com/fmtlib/fmt/pull/1530>`_,
  `#1531 <https://github.com/fmtlib/fmt/issues/1531>`_,
  `#1532 <https://github.com/fmtlib/fmt/pull/1532>`_,
  `#1539 <https://github.com/fmtlib/fmt/issues/1539>`_,
  `#1547 <https://github.com/fmtlib/fmt/issues/1547>`_,
  `#1548 <https://github.com/fmtlib/fmt/issues/1548>`_,
  `#1554 <https://github.com/fmtlib/fmt/pull/1554>`_,
  `#1567 <https://github.com/fmtlib/fmt/issues/1567>`_,
  `#1568 <https://github.com/fmtlib/fmt/pull/1568>`_,
  `#1569 <https://github.com/fmtlib/fmt/pull/1569>`_,
  `#1571 <https://github.com/fmtlib/fmt/pull/1571>`_,
  `#1573 <https://github.com/fmtlib/fmt/pull/1573>`_,
  `#1575 <https://github.com/fmtlib/fmt/pull/1575>`_,
  `#1581 <https://github.com/fmtlib/fmt/pull/1581>`_,
  `#1583 <https://github.com/fmtlib/fmt/issues/1583>`_,
  `#1586 <https://github.com/fmtlib/fmt/issues/1586>`_,
  `#1587 <https://github.com/fmtlib/fmt/issues/1587>`_,
  `#1594 <https://github.com/fmtlib/fmt/issues/1594>`_,
  `#1596 <https://github.com/fmtlib/fmt/pull/1596>`_,
  `#1604 <https://github.com/fmtlib/fmt/issues/1604>`_,
  `#1606 <https://github.com/fmtlib/fmt/pull/1606>`_,
  `#1607 <https://github.com/fmtlib/fmt/issues/1607>`_,
  `#1609 <https://github.com/fmtlib/fmt/issues/1609>`_).
  Thanks `@marti4d (Chris Martin) <https://github.com/marti4d>`_,
  `@iPherian <https://github.com/iPherian>`_,
  `@parkertomatoes <https://github.com/parkertomatoes>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_,
  `@torsten48 <https://github.com/torsten48>`_,
  `@tohammer (Tobias Hammer) <https://github.com/tohammer>`_,
  `@lefticus (Jason Turner) <https://github.com/lefticus>`_,
  `@ryusakki (Haise) <https://github.com/ryusakki>`_,
  `@adnsv (Alex Denisov) <https://github.com/adnsv>`_,
  `@fghzxm <https://github.com/fghzxm>`_,
  `@refnum <https://github.com/refnum>`_,
  `@pramodk (Pramod Kumbhar) <https://github.com/pramodk>`_,
  `@Spirrwell <https://github.com/Spirrwell>`_,
  `@scramsby (Scott Ramsby) <https://github.com/scramsby>`_.

6.1.2 - 2019-12-11
------------------

* Fixed ABI compatibility with ``libfmt.so.6.0.0``
  (`#1471 <https://github.com/fmtlib/fmt/issues/1471>`_).

* Fixed handling types convertible to ``std::string_view``
  (`#1451 <https://github.com/fmtlib/fmt/pull/1451>`_).
  Thanks `@denizevrenci (Deniz Evrenci) <https://github.com/denizevrenci>`_.

* Made CUDA test an opt-in enabled via the ``FMT_CUDA_TEST`` CMake option.

* Fixed sign conversion warnings
  (`#1440 <https://github.com/fmtlib/fmt/pull/1440>`_).
  Thanks `@0x8000-0000 (Florin Iucha) <https://github.com/0x8000-0000>`_.

6.1.1 - 2019-12-04
------------------

* Fixed shared library build on Windows
  (`#1443 <https://github.com/fmtlib/fmt/pull/1443>`_,
  `#1445 <https://github.com/fmtlib/fmt/issues/1445>`_,
  `#1446 <https://github.com/fmtlib/fmt/pull/1446>`_,
  `#1450 <https://github.com/fmtlib/fmt/issues/1450>`_).
  Thanks `@egorpugin (Egor Pugin) <https://github.com/egorpugin>`_,
  `@bbolli (Beat Bolli) <https://github.com/bbolli>`_.

* Added a missing decimal point in exponent notation with trailing zeros.

* Removed deprecated ``format_arg_store::TYPES``.

6.1.0 - 2019-12-01
------------------

* {fmt} now formats IEEE 754 ``float`` and ``double`` using the shortest decimal
  representation with correct rounding by default:

  .. code:: c++

     #include <cmath>
     #include <fmt/core.h>

     int main() {
       fmt::print("{}", M_PI);
     }

  prints ``3.141592653589793``.

* Made the fast binary to decimal floating-point formatter the default,
  simplified it and improved performance. {fmt} is now 15 times faster than
  libc++'s ``std::ostringstream``, 11 times faster than ``printf`` and 10%
  faster than double-conversion on `dtoa-benchmark
  <https://github.com/fmtlib/dtoa-benchmark>`_:

  ==================  =========  =======
  Function            Time (ns)  Speedup
  ==================  =========  =======
  ostringstream        1,346.30    1.00x
  ostrstream           1,195.74    1.13x
  sprintf                995.08    1.35x
  doubleconv              99.10   13.59x
  fmt                     88.34   15.24x
  ==================  =========  =======

  .. image:: https://user-images.githubusercontent.com/576385/
             69767160-cdaca400-112f-11ea-9fc5-347c9f83caad.png

* {fmt} no longer converts ``float`` arguments to ``double``. In particular this
  improves the default (shortest) representation of floats and makes
  ``fmt::format`` consistent with ``std::format`` specs
  (`#1336 <https://github.com/fmtlib/fmt/issues/1336>`_,
  `#1353 <https://github.com/fmtlib/fmt/issues/1353>`_,
  `#1360 <https://github.com/fmtlib/fmt/pull/1360>`_,
  `#1361 <https://github.com/fmtlib/fmt/pull/1361>`_):

  .. code:: c++

     fmt::print("{}", 0.1f);

  prints ``0.1`` instead of ``0.10000000149011612``.

  Thanks `@orivej (Orivej Desh) <https://github.com/orivej>`_.

* Made floating-point formatting output consistent with ``printf``/iostreams
  (`#1376 <https://github.com/fmtlib/fmt/issues/1376>`_,
  `#1417 <https://github.com/fmtlib/fmt/issues/1417>`_).

* Added support for 128-bit integers
  (`#1287 <https://github.com/fmtlib/fmt/pull/1287>`_):

  .. code:: c++

     fmt::print("{}", std::numeric_limits<__int128_t>::max());

  prints ``170141183460469231731687303715884105727``.

  Thanks `@denizevrenci (Deniz Evrenci) <https://github.com/denizevrenci>`_.

* The overload of ``print`` that takes ``text_style`` is now atomic, i.e. the
  output from different threads doesn't interleave
  (`#1351 <https://github.com/fmtlib/fmt/pull/1351>`_).
  Thanks `@tankiJong (Tanki Zhang) <https://github.com/tankiJong>`_.

* Made compile time in the header-only mode ~20% faster by reducing the number
  of template instantiations. ``wchar_t`` overload of ``vprint`` was moved from
  ``fmt/core.h`` to ``fmt/format.h``.

* Added an overload of ``fmt::join`` that works with tuples
  (`#1322 <https://github.com/fmtlib/fmt/issues/1322>`_,
  `#1330 <https://github.com/fmtlib/fmt/pull/1330>`_):

  .. code:: c++

     #include <tuple>
     #include <fmt/ranges.h>

     int main() {
       std::tuple<char, int, float> t{'a', 1, 2.0f};
       fmt::print("{}", t);
     }

  prints ``('a', 1, 2.0)``.

  Thanks `@jeremyong (Jeremy Ong) <https://github.com/jeremyong>`_.

* Changed formatting of octal zero with prefix from "00" to "0":

  .. code:: c++

     fmt::print("{:#o}", 0);

  prints ``0``.

* The locale is now passed to ostream insertion (``<<``) operators
  (`#1406 <https://github.com/fmtlib/fmt/pull/1406>`_):

  .. code:: c++

     #include <fmt/locale.h>
     #include <fmt/ostream.h>

     struct S {
       double value;
     };

     std::ostream& operator<<(std::ostream& os, S s) {
       return os << s.value;
     }

     int main() {
       auto s = fmt::format(std::locale("fr_FR.UTF-8"), "{}", S{0.42});
       // s == "0,42"
     }

  Thanks `@dlaugt (Daniel Laügt) <https://github.com/dlaugt>`_.

* Locale-specific number formatting now uses grouping
  (`#1393 <https://github.com/fmtlib/fmt/issues/1393>`_
  `#1394 <https://github.com/fmtlib/fmt/pull/1394>`_).
  Thanks `@skrdaniel <https://github.com/skrdaniel>`_.

* Fixed handling of types with deleted implicit rvalue conversion to
  ``const char**`` (`#1421 <https://github.com/fmtlib/fmt/issues/1421>`_):

  .. code:: c++

     struct mystring {
       operator const char*() const&;
       operator const char*() &;
       operator const char*() const&& = delete;
       operator const char*() && = delete;
     };
     mystring str;
     fmt::print("{}", str); // now compiles

* Enums are now mapped to correct underlying types instead of ``int``
  (`#1286 <https://github.com/fmtlib/fmt/pull/1286>`_).
  Thanks `@agmt (Egor Seredin) <https://github.com/agmt>`_.

* Enum classes are no longer implicitly converted to ``int``
  (`#1424 <https://github.com/fmtlib/fmt/issues/1424>`_).

* Added ``basic_format_parse_context`` for consistency with C++20
  ``std::format`` and deprecated ``basic_parse_context``.

* Fixed handling of UTF-8 in precision
  (`#1389 <https://github.com/fmtlib/fmt/issues/1389>`_,
  `#1390 <https://github.com/fmtlib/fmt/pull/1390>`_).
  Thanks `@tajtiattila (Attila Tajti) <https://github.com/tajtiattila>`_.

* {fmt} can now be installed on Linux, macOS and Windows with
  `Conda <https://docs.conda.io/en/latest/>`__ using its
  `conda-forge <https://conda-forge.org>`__
  `package <https://github.com/conda-forge/fmt-feedstock>`__
  (`#1410 <https://github.com/fmtlib/fmt/pull/1410>`_)::

    conda install -c conda-forge fmt

  Thanks `@tdegeus (Tom de Geus) <https://github.com/tdegeus>`_.

* Added a CUDA test (`#1285 <https://github.com/fmtlib/fmt/pull/1285>`_,
  `#1317 <https://github.com/fmtlib/fmt/pull/1317>`_).
  Thanks `@luncliff (Park DongHa) <https://github.com/luncliff>`_ and
  `@risa2000 <https://github.com/risa2000>`_.

* Improved documentation (`#1276 <https://github.com/fmtlib/fmt/pull/1276>`_,
  `#1291 <https://github.com/fmtlib/fmt/issues/1291>`_,
  `#1296 <https://github.com/fmtlib/fmt/issues/1296>`_,
  `#1315 <https://github.com/fmtlib/fmt/pull/1315>`_,
  `#1332 <https://github.com/fmtlib/fmt/pull/1332>`_,
  `#1337 <https://github.com/fmtlib/fmt/pull/1337>`_,
  `#1395 <https://github.com/fmtlib/fmt/issues/1395>`_
  `#1418 <https://github.com/fmtlib/fmt/pull/1418>`_).
  Thanks
  `@waywardmonkeys (Bruce Mitchener) <https://github.com/waywardmonkeys>`_,
  `@pauldreik (Paul Dreik) <https://github.com/pauldreik>`_,
  `@jackoalan (Jack Andersen) <https://github.com/jackoalan>`_.

* Various code improvements
  (`#1358 <https://github.com/fmtlib/fmt/pull/1358>`_,
  `#1407 <https://github.com/fmtlib/fmt/pull/1407>`_).
  Thanks `@orivej (Orivej Desh) <https://github.com/orivej>`_,
  `@dpacbach (David P. Sicilia) <https://github.com/dpacbach>`_,

* Fixed compile-time format string checks for user-defined types
  (`#1292 <https://github.com/fmtlib/fmt/issues/1292>`_).

* Worked around a false positive in ``unsigned-integer-overflow`` sanitizer
  (`#1377 <https://github.com/fmtlib/fmt/issues/1377>`_).

* Fixed various warnings and compilation issues
  (`#1273 <https://github.com/fmtlib/fmt/issues/1273>`_,
  `#1278 <https://github.com/fmtlib/fmt/pull/1278>`_,
  `#1280 <https://github.com/fmtlib/fmt/pull/1280>`_,
  `#1281 <https://github.com/fmtlib/fmt/issues/1281>`_,
  `#1288 <https://github.com/fmtlib/fmt/issues/1288>`_,
  `#1290 <https://github.com/fmtlib/fmt/pull/1290>`_,
  `#1301 <https://github.com/fmtlib/fmt/pull/1301>`_,
  `#1305 <https://github.com/fmtlib/fmt/issues/1305>`_,
  `#1306 <https://github.com/fmtlib/fmt/issues/1306>`_,
  `#1309 <https://github.com/fmtlib/fmt/issues/1309>`_,
  `#1312 <https://github.com/fmtlib/fmt/pull/1312>`_,
  `#1313 <https://github.com/fmtlib/fmt/issues/1313>`_,
  `#1316 <https://github.com/fmtlib/fmt/issues/1316>`_,
  `#1319 <https://github.com/fmtlib/fmt/issues/1319>`_,
  `#1320 <https://github.com/fmtlib/fmt/pull/1320>`_,
  `#1326 <https://github.com/fmtlib/fmt/pull/1326>`_,
  `#1328 <https://github.com/fmtlib/fmt/pull/1328>`_,
  `#1344 <https://github.com/fmtlib/fmt/issues/1344>`_,
  `#1345 <https://github.com/fmtlib/fmt/pull/1345>`_,
  `#1347 <https://github.com/fmtlib/fmt/pull/1347>`_,
  `#1349 <https://github.com/fmtlib/fmt/pull/1349>`_,
  `#1354 <https://github.com/fmtlib/fmt/issues/1354>`_,
  `#1362 <https://github.com/fmtlib/fmt/issues/1362>`_,
  `#1366 <https://github.com/fmtlib/fmt/issues/1366>`_,
  `#1364 <https://github.com/fmtlib/fmt/pull/1364>`_,
  `#1370 <https://github.com/fmtlib/fmt/pull/1370>`_,
  `#1371 <https://github.com/fmtlib/fmt/pull/1371>`_,
  `#1385 <https://github.com/fmtlib/fmt/issues/1385>`_,
  `#1388 <https://github.com/fmtlib/fmt/issues/1388>`_,
  `#1397 <https://github.com/fmtlib/fmt/pull/1397>`_,
  `#1414 <https://github.com/fmtlib/fmt/pull/1414>`_,
  `#1416 <https://github.com/fmtlib/fmt/pull/1416>`_,
  `#1422 <https://github.com/fmtlib/fmt/issues/1422>`_
  `#1427 <https://github.com/fmtlib/fmt/pull/1427>`_,
  `#1431 <https://github.com/fmtlib/fmt/issues/1431>`_,
  `#1433 <https://github.com/fmtlib/fmt/pull/1433>`_).
  Thanks `@hhb <https://github.com/hhb>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@gabime (Gabi Melman) <https://github.com/gabime>`_,
  `@neheb (Rosen Penev) <https://github.com/neheb>`_,
  `@vedranmiletic (Vedran Miletić) <https://github.com/vedranmiletic>`_,
  `@dkavolis (Daumantas Kavolis) <https://github.com/dkavolis>`_,
  `@mwinterb <https://github.com/mwinterb>`_,
  `@orivej (Orivej Desh) <https://github.com/orivej>`_,
  `@denizevrenci (Deniz Evrenci) <https://github.com/denizevrenci>`_
  `@leonklingele <https://github.com/leonklingele>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@kent-tri <https://github.com/kent-tri>`_,
  `@0x8000-0000 (Florin Iucha) <https://github.com/0x8000-0000>`_,
  `@marti4d (Chris Martin) <https://github.com/marti4d>`_.

6.0.0 - 2019-08-26
------------------

* Switched to the `MIT license
  <https://github.com/fmtlib/fmt/blob/5a4b24613ba16cc689977c3b5bd8274a3ba1dd1f/LICENSE.rst>`_
  with an optional exception that allows distributing binary code without
  attribution.

* Floating-point formatting is now locale-independent by default:

  .. code:: c++

     #include <locale>
     #include <fmt/core.h>

     int main() {
       std::locale::global(std::locale("ru_RU.UTF-8"));
       fmt::print("value = {}", 4.2);
     }

  prints "value = 4.2" regardless of the locale.

  For locale-specific formatting use the ``n`` specifier:

  .. code:: c++

     std::locale::global(std::locale("ru_RU.UTF-8"));
     fmt::print("value = {:n}", 4.2);

  prints "value = 4,2".

* Added an experimental Grisu floating-point formatting algorithm
  implementation (disabled by default). To enable it compile with the
  ``FMT_USE_GRISU`` macro defined to 1:

  .. code:: c++

     #define FMT_USE_GRISU 1
     #include <fmt/format.h>

     auto s = fmt::format("{}", 4.2); // formats 4.2 using Grisu

  With Grisu enabled, {fmt} is 13x faster than ``std::ostringstream`` (libc++)
  and 10x faster than ``sprintf`` on `dtoa-benchmark
  <https://github.com/fmtlib/dtoa-benchmark>`_ (`full results
  <https://fmt.dev/unknown_mac64_clang10.0.html>`_):

  .. image:: https://user-images.githubusercontent.com/576385/
             54883977-9fe8c000-4e28-11e9-8bde-272d122e7c52.jpg

* Separated formatting and parsing contexts for consistency with
  `C++20 std::format <http://eel.is/c++draft/format>`_, removing the
  undocumented ``basic_format_context::parse_context()`` function.

* Added `oss-fuzz <https://github.com/google/oss-fuzz>`_ support
  (`#1199 <https://github.com/fmtlib/fmt/pull/1199>`_).
  Thanks `@pauldreik (Paul Dreik) <https://github.com/pauldreik>`_.

* ``formatter`` specializations now always take precedence over ``operator<<``
  (`#952 <https://github.com/fmtlib/fmt/issues/952>`_):

  .. code:: c++

     #include <iostream>
     #include <fmt/ostream.h>

     struct S {};

     std::ostream& operator<<(std::ostream& os, S) {
       return os << 1;
     }

     template <>
     struct fmt::formatter<S> : fmt::formatter<int> {
       auto format(S, format_context& ctx) {
         return formatter<int>::format(2, ctx);
       }
     };

     int main() {
       std::cout << S() << "\n"; // prints 1 using operator<<
       fmt::print("{}\n", S());  // prints 2 using formatter
     }

* Introduced the experimental ``fmt::compile`` function that does format string
  compilation (`#618 <https://github.com/fmtlib/fmt/issues/618>`_,
  `#1169 <https://github.com/fmtlib/fmt/issues/1169>`_,
  `#1171 <https://github.com/fmtlib/fmt/pull/1171>`_):

  .. code:: c++

     #include <fmt/compile.h>

     auto f = fmt::compile<int>("{}");
     std::string s = fmt::format(f, 42); // can be called multiple times to
                                         // format different values
     // s == "42"

  It moves the cost of parsing a format string outside of the format function
  which can be beneficial when identically formatting many objects of the same
  types. Thanks `@stryku (Mateusz Janek) <https://github.com/stryku>`_.

* Added experimental ``%`` format specifier that formats floating-point values
  as percentages (`#1060 <https://github.com/fmtlib/fmt/pull/1060>`_,
  `#1069 <https://github.com/fmtlib/fmt/pull/1069>`_,
  `#1071 <https://github.com/fmtlib/fmt/pull/1071>`_):

  .. code:: c++

     auto s = fmt::format("{:.1%}", 0.42); // s == "42.0%"

  Thanks `@gawain-bolton (Gawain Bolton) <https://github.com/gawain-bolton>`_.

* Implemented precision for floating-point durations
  (`#1004 <https://github.com/fmtlib/fmt/issues/1004>`_,
  `#1012 <https://github.com/fmtlib/fmt/pull/1012>`_):

  .. code:: c++

     auto s = fmt::format("{:.1}", std::chrono::duration<double>(1.234));
     // s == 1.2s

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Implemented ``chrono`` format specifiers ``%Q`` and ``%q`` that give the value
  and the unit respectively (`#1019 <https://github.com/fmtlib/fmt/pull/1019>`_):

  .. code:: c++

     auto value = fmt::format("{:%Q}", 42s); // value == "42"
     auto unit  = fmt::format("{:%q}", 42s); // unit == "s"

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Fixed handling of dynamic width in chrono formatter:

  .. code:: c++

     auto s = fmt::format("{0:{1}%H:%M:%S}", std::chrono::seconds(12345), 12);
     //                        ^ width argument index                     ^ width
     // s == "03:25:45    "

  Thanks Howard Hinnant.

* Removed deprecated ``fmt/time.h``. Use ``fmt/chrono.h`` instead.

* Added ``fmt::format`` and ``fmt::vformat`` overloads that take ``text_style``
  (`#993 <https://github.com/fmtlib/fmt/issues/993>`_,
  `#994 <https://github.com/fmtlib/fmt/pull/994>`_):

  .. code:: c++

     #include <fmt/color.h>

     std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
                                       "The answer is {}.", 42);

  Thanks `@Naios (Denis Blank) <https://github.com/Naios>`_.

* Removed the deprecated color API (``print_colored``). Use the new API, namely
  ``print`` overloads that take ``text_style`` instead.

* Made ``std::unique_ptr`` and ``std::shared_ptr`` formattable as pointers via
  ``fmt::ptr`` (`#1121 <https://github.com/fmtlib/fmt/pull/1121>`_):

  .. code:: c++

     std::unique_ptr<int> p = ...;
     fmt::print("{}", fmt::ptr(p)); // prints p as a pointer

  Thanks `@sighingnow (Tao He) <https://github.com/sighingnow>`_.

* Made ``print`` and ``vprint`` report I/O errors
  (`#1098 <https://github.com/fmtlib/fmt/issues/1098>`_,
  `#1099 <https://github.com/fmtlib/fmt/pull/1099>`_).
  Thanks `@BillyDonahue (Billy Donahue) <https://github.com/BillyDonahue>`_.

* Marked deprecated APIs with the ``[[deprecated]]`` attribute and removed
  internal uses of deprecated APIs
  (`#1022 <https://github.com/fmtlib/fmt/pull/1022>`_).
  Thanks `@eliaskosunen (Elias Kosunen) <https://github.com/eliaskosunen>`_.

* Modernized the codebase using more C++11 features and removing workarounds.
  Most importantly, ``buffer_context`` is now an alias template, so
  use ``buffer_context<T>`` instead of ``buffer_context<T>::type``.
  These features require GCC 4.8 or later.

* ``formatter`` specializations now always take precedence over implicit
  conversions to ``int`` and the undocumented ``convert_to_int`` trait
  is now deprecated.

* Moved the undocumented ``basic_writer``, ``writer``, and ``wwriter`` types
  to the ``internal`` namespace.

* Removed deprecated ``basic_format_context::begin()``. Use ``out()`` instead.

* Disallowed passing the result of ``join`` as an lvalue to prevent misuse.

* Refactored the undocumented structs that represent parsed format specifiers
  to simplify the API and allow multibyte fill.

* Moved SFINAE to template parameters to reduce symbol sizes.

* Switched to ``fputws`` for writing wide strings so that it's no longer
  required to call ``_setmode`` on Windows
  (`#1229 <https://github.com/fmtlib/fmt/issues/1229>`_,
  `#1243 <https://github.com/fmtlib/fmt/pull/1243>`_).
  Thanks `@jackoalan (Jack Andersen) <https://github.com/jackoalan>`_.

* Improved literal-based API
  (`#1254 <https://github.com/fmtlib/fmt/pull/1254>`_).
  Thanks `@sylveon (Charles Milette) <https://github.com/sylveon>`_.

* Added support for exotic platforms without ``uintptr_t`` such as IBM i
  (AS/400) which has 128-bit pointers and only 64-bit integers
  (`#1059 <https://github.com/fmtlib/fmt/issues/1059>`_).

* Added `Sublime Text syntax highlighting config
  <https://github.com/fmtlib/fmt/blob/master/support/C%2B%2B.sublime-syntax>`_
  (`#1037 <https://github.com/fmtlib/fmt/issues/1037>`_).
  Thanks `@Kronuz (Germán Méndez Bravo) <https://github.com/Kronuz>`_.

* Added the ``FMT_ENFORCE_COMPILE_STRING`` macro to enforce the use of
  compile-time format strings
  (`#1231 <https://github.com/fmtlib/fmt/pull/1231>`_).
  Thanks `@jackoalan (Jack Andersen) <https://github.com/jackoalan>`_.

* Stopped setting ``CMAKE_BUILD_TYPE`` if {fmt} is a subproject
  (`#1081 <https://github.com/fmtlib/fmt/issues/1081>`_).

* Various build improvements
  (`#1039 <https://github.com/fmtlib/fmt/pull/1039>`_,
  `#1078 <https://github.com/fmtlib/fmt/pull/1078>`_,
  `#1091 <https://github.com/fmtlib/fmt/pull/1091>`_,
  `#1103 <https://github.com/fmtlib/fmt/pull/1103>`_,
  `#1177 <https://github.com/fmtlib/fmt/pull/1177>`_).
  Thanks `@luncliff (Park DongHa) <https://github.com/luncliff>`_,
  `@jasonszang (Jason Shuo Zang) <https://github.com/jasonszang>`_,
  `@olafhering (Olaf Hering) <https://github.com/olafhering>`_,
  `@Lecetem <https://github.com/Lectem>`_,
  `@pauldreik (Paul Dreik) <https://github.com/pauldreik>`_.

* Improved documentation
  (`#1049 <https://github.com/fmtlib/fmt/issues/1049>`_,
  `#1051 <https://github.com/fmtlib/fmt/pull/1051>`_,
  `#1083 <https://github.com/fmtlib/fmt/pull/1083>`_,
  `#1113 <https://github.com/fmtlib/fmt/pull/1113>`_,
  `#1114 <https://github.com/fmtlib/fmt/pull/1114>`_,
  `#1146 <https://github.com/fmtlib/fmt/issues/1146>`_,
  `#1180 <https://github.com/fmtlib/fmt/issues/1180>`_,
  `#1250 <https://github.com/fmtlib/fmt/pull/1250>`_,
  `#1252 <https://github.com/fmtlib/fmt/pull/1252>`_,
  `#1265 <https://github.com/fmtlib/fmt/pull/1265>`_).
  Thanks `@mikelui (Michael Lui) <https://github.com/mikelui>`_,
  `@foonathan (Jonathan Müller) <https://github.com/foonathan>`_,
  `@BillyDonahue (Billy Donahue) <https://github.com/BillyDonahue>`_,
  `@jwakely (Jonathan Wakely) <https://github.com/jwakely>`_,
  `@kaisbe (Kais Ben Salah) <https://github.com/kaisbe>`_,
  `@sdebionne (Samuel Debionne) <https://github.com/sdebionne>`_.

* Fixed ambiguous formatter specialization in ``fmt/ranges.h``
  (`#1123 <https://github.com/fmtlib/fmt/issues/1123>`_).

* Fixed formatting of a non-empty ``std::filesystem::path`` which is an
  infinitely deep range of its components
  (`#1268 <https://github.com/fmtlib/fmt/issues/1268>`_).

* Fixed handling of general output iterators when formatting characters
  (`#1056 <https://github.com/fmtlib/fmt/issues/1056>`_,
  `#1058 <https://github.com/fmtlib/fmt/pull/1058>`_).
  Thanks `@abolz (Alexander Bolz) <https://github.com/abolz>`_.

* Fixed handling of output iterators in ``formatter`` specialization for
  ranges (`#1064 <https://github.com/fmtlib/fmt/issues/1064>`_).

* Fixed handling of exotic character types
  (`#1188 <https://github.com/fmtlib/fmt/issues/1188>`_).

* Made chrono formatting work with exceptions disabled
  (`#1062 <https://github.com/fmtlib/fmt/issues/1062>`_).

* Fixed DLL visibility issues
  (`#1134 <https://github.com/fmtlib/fmt/pull/1134>`_,
  `#1147 <https://github.com/fmtlib/fmt/pull/1147>`_).
  Thanks `@denchat <https://github.com/denchat>`_.

* Disabled the use of UDL template extension on GCC 9
  (`#1148 <https://github.com/fmtlib/fmt/issues/1148>`_).

* Removed misplaced ``format`` compile-time checks from ``printf``
  (`#1173 <https://github.com/fmtlib/fmt/issues/1173>`_).

* Fixed issues in the experimental floating-point formatter
  (`#1072 <https://github.com/fmtlib/fmt/issues/1072>`_,
  `#1129 <https://github.com/fmtlib/fmt/issues/1129>`_,
  `#1153 <https://github.com/fmtlib/fmt/issues/1153>`_,
  `#1155 <https://github.com/fmtlib/fmt/pull/1155>`_,
  `#1210 <https://github.com/fmtlib/fmt/issues/1210>`_,
  `#1222 <https://github.com/fmtlib/fmt/issues/1222>`_).
  Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.

* Fixed bugs discovered by fuzzing or during fuzzing integration
  (`#1124 <https://github.com/fmtlib/fmt/issues/1124>`_,
  `#1127 <https://github.com/fmtlib/fmt/issues/1127>`_,
  `#1132 <https://github.com/fmtlib/fmt/issues/1132>`_,
  `#1135 <https://github.com/fmtlib/fmt/pull/1135>`_,
  `#1136 <https://github.com/fmtlib/fmt/issues/1136>`_,
  `#1141 <https://github.com/fmtlib/fmt/issues/1141>`_,
  `#1142 <https://github.com/fmtlib/fmt/issues/1142>`_,
  `#1178 <https://github.com/fmtlib/fmt/issues/1178>`_,
  `#1179 <https://github.com/fmtlib/fmt/issues/1179>`_,
  `#1194 <https://github.com/fmtlib/fmt/issues/1194>`_).
  Thanks `@pauldreik (Paul Dreik) <https://github.com/pauldreik>`_.

* Fixed building tests on FreeBSD and Hurd
  (`#1043 <https://github.com/fmtlib/fmt/issues/1043>`_).
  Thanks `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_.

* Fixed various warnings and compilation issues
  (`#998 <https://github.com/fmtlib/fmt/pull/998>`_,
  `#1006 <https://github.com/fmtlib/fmt/pull/1006>`_,
  `#1008 <https://github.com/fmtlib/fmt/issues/1008>`_,
  `#1011 <https://github.com/fmtlib/fmt/issues/1011>`_,
  `#1025 <https://github.com/fmtlib/fmt/issues/1025>`_,
  `#1027 <https://github.com/fmtlib/fmt/pull/1027>`_,
  `#1028 <https://github.com/fmtlib/fmt/pull/1028>`_,
  `#1029 <https://github.com/fmtlib/fmt/pull/1029>`_,
  `#1030 <https://github.com/fmtlib/fmt/pull/1030>`_,
  `#1031 <https://github.com/fmtlib/fmt/pull/1031>`_,
  `#1054 <https://github.com/fmtlib/fmt/pull/1054>`_,
  `#1063 <https://github.com/fmtlib/fmt/issues/1063>`_,
  `#1068 <https://github.com/fmtlib/fmt/pull/1068>`_,
  `#1074 <https://github.com/fmtlib/fmt/pull/1074>`_,
  `#1075 <https://github.com/fmtlib/fmt/pull/1075>`_,
  `#1079 <https://github.com/fmtlib/fmt/pull/1079>`_,
  `#1086 <https://github.com/fmtlib/fmt/pull/1086>`_,
  `#1088 <https://github.com/fmtlib/fmt/issues/1088>`_,
  `#1089 <https://github.com/fmtlib/fmt/pull/1089>`_,
  `#1094 <https://github.com/fmtlib/fmt/pull/1094>`_,
  `#1101 <https://github.com/fmtlib/fmt/issues/1101>`_,
  `#1102 <https://github.com/fmtlib/fmt/pull/1102>`_,
  `#1105 <https://github.com/fmtlib/fmt/issues/1105>`_,
  `#1107 <https://github.com/fmtlib/fmt/pull/1107>`_,
  `#1115 <https://github.com/fmtlib/fmt/issues/1115>`_,
  `#1117 <https://github.com/fmtlib/fmt/issues/1117>`_,
  `#1118 <https://github.com/fmtlib/fmt/issues/1118>`_,
  `#1120 <https://github.com/fmtlib/fmt/issues/1120>`_,
  `#1123 <https://github.com/fmtlib/fmt/issues/1123>`_,
  `#1139 <https://github.com/fmtlib/fmt/pull/1139>`_,
  `#1140 <https://github.com/fmtlib/fmt/issues/1140>`_,
  `#1143 <https://github.com/fmtlib/fmt/issues/1143>`_,
  `#1144 <https://github.com/fmtlib/fmt/pull/1144>`_,
  `#1150 <https://github.com/fmtlib/fmt/pull/1150>`_,
  `#1151 <https://github.com/fmtlib/fmt/pull/1151>`_,
  `#1152 <https://github.com/fmtlib/fmt/issues/1152>`_,
  `#1154 <https://github.com/fmtlib/fmt/issues/1154>`_,
  `#1156 <https://github.com/fmtlib/fmt/issues/1156>`_,
  `#1159 <https://github.com/fmtlib/fmt/pull/1159>`_,
  `#1175 <https://github.com/fmtlib/fmt/issues/1175>`_,
  `#1181 <https://github.com/fmtlib/fmt/issues/1181>`_,
  `#1186 <https://github.com/fmtlib/fmt/issues/1186>`_,
  `#1187 <https://github.com/fmtlib/fmt/pull/1187>`_,
  `#1191 <https://github.com/fmtlib/fmt/pull/1191>`_,
  `#1197 <https://github.com/fmtlib/fmt/issues/1197>`_,
  `#1200 <https://github.com/fmtlib/fmt/issues/1200>`_,
  `#1203 <https://github.com/fmtlib/fmt/issues/1203>`_,
  `#1205 <https://github.com/fmtlib/fmt/issues/1205>`_,
  `#1206 <https://github.com/fmtlib/fmt/pull/1206>`_,
  `#1213 <https://github.com/fmtlib/fmt/issues/1213>`_,
  `#1214 <https://github.com/fmtlib/fmt/issues/1214>`_,
  `#1217 <https://github.com/fmtlib/fmt/pull/1217>`_,
  `#1228 <https://github.com/fmtlib/fmt/issues/1228>`_,
  `#1230 <https://github.com/fmtlib/fmt/pull/1230>`_,
  `#1232 <https://github.com/fmtlib/fmt/issues/1232>`_,
  `#1235 <https://github.com/fmtlib/fmt/pull/1235>`_,
  `#1236 <https://github.com/fmtlib/fmt/pull/1236>`_,
  `#1240 <https://github.com/fmtlib/fmt/issues/1240>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_,
  `@mwinterb <https://github.com/mwinterb>`_,
  `@eliaskosunen (Elias Kosunen) <https://github.com/eliaskosunen>`_,
  `@morinmorin <https://github.com/morinmorin>`_,
  `@ricco19 (Brian Ricciardelli) <https://github.com/ricco19>`_,
  `@waywardmonkeys (Bruce Mitchener) <https://github.com/waywardmonkeys>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@remyabel <https://github.com/remyabel>`_,
  `@pauldreik (Paul Dreik) <https://github.com/pauldreik>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@rcane (Ronny Krüger) <https://github.com/rcane>`_,
  `@mocabe <https://github.com/mocabe>`_,
  `@denchat <https://github.com/denchat>`_,
  `@cjdb (Christopher Di Bella) <https://github.com/cjdb>`_,
  `@HazardyKnusperkeks (Björn Schäpers) <https://github.com/HazardyKnusperkeks>`_,
  `@vedranmiletic (Vedran Miletić) <https://github.com/vedranmiletic>`_,
  `@jackoalan (Jack Andersen) <https://github.com/jackoalan>`_,
  `@DaanDeMeyer (Daan De Meyer) <https://github.com/DaanDeMeyer>`_,
  `@starkmapper (Mark Stapper) <https://github.com/starkmapper>`_.

5.3.0 - 2018-12-28
------------------

* Introduced experimental chrono formatting support:

  .. code:: c++

     #include <fmt/chrono.h>

     int main() {
       using namespace std::literals::chrono_literals;
       fmt::print("Default format: {} {}\n", 42s, 100ms);
       fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
     }

  prints::

     Default format: 42s 100ms
     strftime-like format: 03:15:30

* Added experimental support for emphasis (bold, italic, underline,
  strikethrough), colored output to a file stream, and improved colored
  formatting API
  (`#961 <https://github.com/fmtlib/fmt/pull/961>`_,
  `#967 <https://github.com/fmtlib/fmt/pull/967>`_,
  `#973 <https://github.com/fmtlib/fmt/pull/973>`_):

  .. code:: c++

     #include <fmt/color.h>

     int main() {
       print(fg(fmt::color::crimson) | fmt::emphasis::bold,
             "Hello, {}!\n", "world");
       print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
             fmt::emphasis::underline, "Hello, {}!\n", "мир");
       print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
             "Hello, {}!\n", "世界");
     }

  prints the following on modern terminals with RGB color support:

  .. image:: https://user-images.githubusercontent.com/576385/
             50405788-b66e7500-076e-11e9-9592-7324d1f951d8.png

  Thanks `@Rakete1111 (Nicolas) <https://github.com/Rakete1111>`_.

* Added support for 4-bit terminal colors
  (`#968 <https://github.com/fmtlib/fmt/issues/968>`_,
  `#974 <https://github.com/fmtlib/fmt/pull/974>`_)

  .. code:: c++

     #include <fmt/color.h>

     int main() {
       print(fg(fmt::terminal_color::red), "stop\n");
     }

  Note that these colors vary by terminal:

  .. image:: https://user-images.githubusercontent.com/576385/
             50405925-dbfc7e00-0770-11e9-9b85-333fab0af9ac.png

  Thanks `@Rakete1111 (Nicolas) <https://github.com/Rakete1111>`_.

* Parameterized formatting functions on the type of the format string
  (`#880 <https://github.com/fmtlib/fmt/issues/880>`_,
  `#881 <https://github.com/fmtlib/fmt/pull/881>`_,
  `#883 <https://github.com/fmtlib/fmt/pull/883>`_,
  `#885 <https://github.com/fmtlib/fmt/pull/885>`_,
  `#897 <https://github.com/fmtlib/fmt/pull/897>`_,
  `#920 <https://github.com/fmtlib/fmt/issues/920>`_).
  Any object of type ``S`` that has an overloaded ``to_string_view(const S&)``
  returning ``fmt::string_view`` can be used as a format string:

  .. code:: c++

     namespace my_ns {
     inline string_view to_string_view(const my_string& s) {
       return {s.data(), s.length()};
     }
     }

     std::string message = fmt::format(my_string("The answer is {}."), 42);

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Made ``std::string_view`` work as a format string
  (`#898 <https://github.com/fmtlib/fmt/pull/898>`_):

  .. code:: c++

     auto message = fmt::format(std::string_view("The answer is {}."), 42);

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Added wide string support to compile-time format string checks
  (`#924 <https://github.com/fmtlib/fmt/pull/924>`_):

  .. code:: c++

     print(fmt(L"{:f}"), 42); // compile-time error: invalid type specifier

  Thanks `@XZiar <https://github.com/XZiar>`_.

* Made colored print functions work with wide strings
  (`#867 <https://github.com/fmtlib/fmt/pull/867>`_):

  .. code:: c++

     #include <fmt/color.h>

     int main() {
       print(fg(fmt::color::red), L"{}\n", 42);
     }

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Introduced experimental Unicode support
  (`#628 <https://github.com/fmtlib/fmt/issues/628>`_,
  `#891 <https://github.com/fmtlib/fmt/pull/891>`_):

  .. code:: c++

     using namespace fmt::literals;
     auto s = fmt::format("{:*^5}"_u, "🤡"_u); // s == "**🤡**"_u

* Improved locale support:

  .. code:: c++

     #include <fmt/locale.h>

     struct numpunct : std::numpunct<char> {
      protected:
       char do_thousands_sep() const override { return '~'; }
     };

     std::locale loc;
     auto s = fmt::format(std::locale(loc, new numpunct()), "{:n}", 1234567);
     // s == "1~234~567"

* Constrained formatting functions on proper iterator types
  (`#921 <https://github.com/fmtlib/fmt/pull/921>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Added ``make_printf_args`` and ``make_wprintf_args`` functions
  (`#934 <https://github.com/fmtlib/fmt/pull/934>`_).
  Thanks `@tnovotny <https://github.com/tnovotny>`_.

* Deprecated ``fmt::visit``, ``parse_context``, and ``wparse_context``.
  Use ``fmt::visit_format_arg``, ``format_parse_context``, and
  ``wformat_parse_context`` instead.

* Removed undocumented ``basic_fixed_buffer`` which has been superseded by the
  iterator-based API
  (`#873 <https://github.com/fmtlib/fmt/issues/873>`_,
  `#902 <https://github.com/fmtlib/fmt/pull/902>`_).
  Thanks `@superfunc (hollywood programmer) <https://github.com/superfunc>`_.

* Disallowed repeated leading zeros in an argument ID:

  .. code:: c++

     fmt::print("{000}", 42); // error

* Reintroduced support for gcc 4.4.

* Fixed compilation on platforms with exotic ``double``
  (`#878 <https://github.com/fmtlib/fmt/issues/878>`_).

* Improved documentation
  (`#164 <https://github.com/fmtlib/fmt/issues/164>`_,
  `#877 <https://github.com/fmtlib/fmt/issues/877>`_,
  `#901 <https://github.com/fmtlib/fmt/pull/901>`_,
  `#906 <https://github.com/fmtlib/fmt/pull/906>`_,
  `#979 <https://github.com/fmtlib/fmt/pull/979>`_).
  Thanks `@kookjr (Mathew Cucuzella) <https://github.com/kookjr>`_,
  `@DarkDimius (Dmitry Petrashko) <https://github.com/DarkDimius>`_,
  `@HecticSerenity <https://github.com/HecticSerenity>`_.

* Added pkgconfig support which makes it easier to consume the library from
  meson and other build systems
  (`#916 <https://github.com/fmtlib/fmt/pull/916>`_).
  Thanks `@colemickens (Cole Mickens) <https://github.com/colemickens>`_.

* Various build improvements
  (`#909 <https://github.com/fmtlib/fmt/pull/909>`_,
  `#926 <https://github.com/fmtlib/fmt/pull/926>`_,
  `#937 <https://github.com/fmtlib/fmt/pull/937>`_,
  `#953 <https://github.com/fmtlib/fmt/pull/953>`_,
  `#959 <https://github.com/fmtlib/fmt/pull/959>`_).
  Thanks `@tchaikov (Kefu Chai) <https://github.com/tchaikov>`_,
  `@luncliff (Park DongHa) <https://github.com/luncliff>`_,
  `@AndreasSchoenle (Andreas Schönle) <https://github.com/AndreasSchoenle>`_,
  `@hotwatermorning <https://github.com/hotwatermorning>`_,
  `@Zefz (JohanJansen) <https://github.com/Zefz>`_.

* Improved ``string_view`` construction performance
  (`#914 <https://github.com/fmtlib/fmt/pull/914>`_).
  Thanks `@gabime (Gabi Melman) <https://github.com/gabime>`_.

* Fixed non-matching char types
  (`#895 <https://github.com/fmtlib/fmt/pull/895>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Fixed ``format_to_n`` with ``std::back_insert_iterator``
  (`#913 <https://github.com/fmtlib/fmt/pull/913>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Fixed locale-dependent formatting
  (`#905 <https://github.com/fmtlib/fmt/issues/905>`_).

* Fixed various compiler warnings and errors
  (`#882 <https://github.com/fmtlib/fmt/pull/882>`_,
  `#886 <https://github.com/fmtlib/fmt/pull/886>`_,
  `#933 <https://github.com/fmtlib/fmt/pull/933>`_,
  `#941 <https://github.com/fmtlib/fmt/pull/941>`_,
  `#931 <https://github.com/fmtlib/fmt/issues/931>`_,
  `#943 <https://github.com/fmtlib/fmt/pull/943>`_,
  `#954 <https://github.com/fmtlib/fmt/pull/954>`_,
  `#956 <https://github.com/fmtlib/fmt/pull/956>`_,
  `#962 <https://github.com/fmtlib/fmt/pull/962>`_,
  `#965 <https://github.com/fmtlib/fmt/issues/965>`_,
  `#977 <https://github.com/fmtlib/fmt/issues/977>`_,
  `#983 <https://github.com/fmtlib/fmt/pull/983>`_,
  `#989 <https://github.com/fmtlib/fmt/pull/989>`_).
  Thanks `@Luthaf (Guillaume Fraux) <https://github.com/Luthaf>`_,
  `@stevenhoving (Steven Hoving) <https://github.com/stevenhoving>`_,
  `@christinaa (Kristina Brooks) <https://github.com/christinaa>`_,
  `@lgritz (Larry Gritz) <https://github.com/lgritz>`_,
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_,
  `@0x8000-0000 (Sign Bit) <https://github.com/0x8000-0000>`_,
  `@liuping1997 <https://github.com/liuping1997>`_.

5.2.1 - 2018-09-21
------------------

* Fixed ``visit`` lookup issues on gcc 7 & 8
  (`#870 <https://github.com/fmtlib/fmt/pull/870>`_).
  Thanks `@medithe <https://github.com/medithe>`_.

* Fixed linkage errors on older gcc.

* Prevented ``fmt/range.h`` from specializing ``fmt::basic_string_view``
  (`#865 <https://github.com/fmtlib/fmt/issues/865>`_,
  `#868 <https://github.com/fmtlib/fmt/pull/868>`_).
  Thanks `@hhggit (dual) <https://github.com/hhggit>`_.

* Improved error message when formatting unknown types
  (`#872 <https://github.com/fmtlib/fmt/pull/872>`_).
  Thanks `@foonathan (Jonathan Müller) <https://github.com/foonathan>`_,

* Disabled templated user-defined literals when compiled under nvcc
  (`#875 <https://github.com/fmtlib/fmt/pull/875>`_).
  Thanks `@CandyGumdrop (Candy Gumdrop) <https://github.com/CandyGumdrop>`_,

* Fixed ``format_to`` formatting to ``wmemory_buffer``
  (`#874 <https://github.com/fmtlib/fmt/issues/874>`_).

5.2.0 - 2018-09-13
------------------

* Optimized format string parsing and argument processing which resulted in up
  to 5x speed up on long format strings and significant performance boost on
  various benchmarks. For example, version 5.2 is 2.22x faster than 5.1 on
  decimal integer formatting with ``format_to`` (macOS, clang-902.0.39.2):

  ==================  =======  =======
  Method              Time, s  Speedup
  ==================  =======  =======
  fmt::format 5.1      0.58
  fmt::format 5.2      0.35     1.66x
  fmt::format_to 5.1   0.51
  fmt::format_to 5.2   0.23     2.22x
  sprintf              0.71
  std::to_string       1.01
  std::stringstream    1.73
  ==================  =======  =======

* Changed the ``fmt`` macro from opt-out to opt-in to prevent name collisions.
  To enable it define the ``FMT_STRING_ALIAS`` macro to 1 before including
  ``fmt/format.h``:

  .. code:: c++

     #define FMT_STRING_ALIAS 1
     #include <fmt/format.h>
     std::string answer = format(fmt("{}"), 42);

* Added compile-time format string checks to ``format_to`` overload that takes
  ``fmt::memory_buffer`` (`#783 <https://github.com/fmtlib/fmt/issues/783>`_):

  .. code:: c++

     fmt::memory_buffer buf;
     // Compile-time error: invalid type specifier.
     fmt::format_to(buf, fmt("{:d}"), "foo");

* Moved experimental color support to ``fmt/color.h`` and enabled the
  new API by default. The old API can be enabled by defining the
  ``FMT_DEPRECATED_COLORS`` macro.

* Added formatting support for types explicitly convertible to
  ``fmt::string_view``:

  .. code:: c++

     struct foo {
       explicit operator fmt::string_view() const { return "foo"; }
     };
     auto s = format("{}", foo());

  In particular, this makes formatting function work with
  ``folly::StringPiece``.

* Implemented preliminary support for ``char*_t`` by replacing the ``format``
  function overloads with a single function template parameterized on the string
  type.

* Added support for dynamic argument lists
  (`#814 <https://github.com/fmtlib/fmt/issues/814>`_,
  `#819 <https://github.com/fmtlib/fmt/pull/819>`_).
  Thanks `@MikePopoloski (Michael Popoloski)
  <https://github.com/MikePopoloski>`_.

* Reduced executable size overhead for embedded targets using newlib nano by
  making locale dependency optional
  (`#839 <https://github.com/fmtlib/fmt/pull/839>`_).
  Thanks `@teajay-fr (Thomas Benard) <https://github.com/teajay-fr>`_.

* Keep ``noexcept`` specifier when exceptions are disabled
  (`#801 <https://github.com/fmtlib/fmt/issues/801>`_,
  `#810 <https://github.com/fmtlib/fmt/pull/810>`_).
  Thanks `@qis (Alexej Harm) <https://github.com/qis>`_.

* Fixed formatting of user-defined types providing ``operator<<`` with
  ``format_to_n``
  (`#806 <https://github.com/fmtlib/fmt/pull/806>`_).
  Thanks `@mkurdej (Marek Kurdej) <https://github.com/mkurdej>`_.

* Fixed dynamic linkage of new symbols
  (`#808 <https://github.com/fmtlib/fmt/issues/808>`_).

* Fixed global initialization issue
  (`#807 <https://github.com/fmtlib/fmt/issues/807>`_):

  .. code:: c++

     // This works on compilers with constexpr support.
     static const std::string answer = fmt::format("{}", 42);

* Fixed various compiler warnings and errors
  (`#804 <https://github.com/fmtlib/fmt/pull/804>`_,
  `#809 <https://github.com/fmtlib/fmt/issues/809>`_,
  `#811 <https://github.com/fmtlib/fmt/pull/811>`_,
  `#822 <https://github.com/fmtlib/fmt/issues/822>`_,
  `#827 <https://github.com/fmtlib/fmt/pull/827>`_,
  `#830 <https://github.com/fmtlib/fmt/issues/830>`_,
  `#838 <https://github.com/fmtlib/fmt/pull/838>`_,
  `#843 <https://github.com/fmtlib/fmt/issues/843>`_,
  `#844 <https://github.com/fmtlib/fmt/pull/844>`_,
  `#851 <https://github.com/fmtlib/fmt/issues/851>`_,
  `#852 <https://github.com/fmtlib/fmt/pull/852>`_,
  `#854 <https://github.com/fmtlib/fmt/pull/854>`_).
  Thanks `@henryiii (Henry Schreiner) <https://github.com/henryiii>`_,
  `@medithe <https://github.com/medithe>`_, and
  `@eliasdaler (Elias Daler) <https://github.com/eliasdaler>`_.

5.1.0 - 2018-07-05
------------------

* Added experimental support for RGB color output enabled with
  the ``FMT_EXTENDED_COLORS`` macro:

  .. code:: c++

     #define FMT_EXTENDED_COLORS
     #define FMT_HEADER_ONLY // or compile fmt with FMT_EXTENDED_COLORS defined
     #include <fmt/format.h>

     fmt::print(fmt::color::steel_blue, "Some beautiful text");

  The old API (the ``print_colored`` and ``vprint_colored`` functions and the
  ``color`` enum) is now deprecated.
  (`#762 <https://github.com/fmtlib/fmt/issues/762>`_
  `#767 <https://github.com/fmtlib/fmt/pull/767>`_).
  thanks `@Remotion (Remo) <https://github.com/Remotion>`_.

* Added quotes to strings in ranges and tuples
  (`#766 <https://github.com/fmtlib/fmt/pull/766>`_).
  Thanks `@Remotion (Remo) <https://github.com/Remotion>`_.

* Made ``format_to`` work with ``basic_memory_buffer``
  (`#776 <https://github.com/fmtlib/fmt/issues/776>`_).

* Added ``vformat_to_n`` and ``wchar_t`` overload of ``format_to_n``
  (`#764 <https://github.com/fmtlib/fmt/issues/764>`_,
  `#769 <https://github.com/fmtlib/fmt/issues/769>`_).

* Made ``is_range`` and ``is_tuple_like`` part of public (experimental) API
  to allow specialization for user-defined types
  (`#751 <https://github.com/fmtlib/fmt/issues/751>`_,
  `#759 <https://github.com/fmtlib/fmt/pull/759>`_).
  Thanks `@drrlvn (Dror Levin) <https://github.com/drrlvn>`_.

* Added more compilers to continuous integration and increased ``FMT_PEDANTIC``
  warning levels
  (`#736 <https://github.com/fmtlib/fmt/pull/736>`_).
  Thanks `@eliaskosunen (Elias Kosunen) <https://github.com/eliaskosunen>`_.

* Fixed compilation with MSVC 2013.

* Fixed handling of user-defined types in ``format_to``
  (`#793 <https://github.com/fmtlib/fmt/issues/793>`_).

* Forced linking of inline ``vformat`` functions into the library
  (`#795 <https://github.com/fmtlib/fmt/issues/795>`_).

* Fixed incorrect call to on_align in ``'{:}='``
  (`#750 <https://github.com/fmtlib/fmt/issues/750>`_).

* Fixed floating-point formatting to a non-back_insert_iterator with sign &
  numeric alignment specified
  (`#756 <https://github.com/fmtlib/fmt/issues/756>`_).

* Fixed formatting to an array with ``format_to_n``
  (`#778 <https://github.com/fmtlib/fmt/issues/778>`_).

* Fixed formatting of more than 15 named arguments
  (`#754 <https://github.com/fmtlib/fmt/issues/754>`_).

* Fixed handling of compile-time strings when including ``fmt/ostream.h``.
  (`#768 <https://github.com/fmtlib/fmt/issues/768>`_).

* Fixed various compiler warnings and errors
  (`#742 <https://github.com/fmtlib/fmt/issues/742>`_,
  `#748 <https://github.com/fmtlib/fmt/issues/748>`_,
  `#752 <https://github.com/fmtlib/fmt/issues/752>`_,
  `#770 <https://github.com/fmtlib/fmt/issues/770>`_,
  `#775 <https://github.com/fmtlib/fmt/pull/775>`_,
  `#779 <https://github.com/fmtlib/fmt/issues/779>`_,
  `#780 <https://github.com/fmtlib/fmt/pull/780>`_,
  `#790 <https://github.com/fmtlib/fmt/pull/790>`_,
  `#792 <https://github.com/fmtlib/fmt/pull/792>`_,
  `#800 <https://github.com/fmtlib/fmt/pull/800>`_).
  Thanks `@Remotion (Remo) <https://github.com/Remotion>`_,
  `@gabime (Gabi Melman) <https://github.com/gabime>`_,
  `@foonathan (Jonathan Müller) <https://github.com/foonathan>`_,
  `@Dark-Passenger (Dhruv Paranjape) <https://github.com/Dark-Passenger>`_, and
  `@0x8000-0000 (Sign Bit) <https://github.com/0x8000-0000>`_.

5.0.0 - 2018-05-21
------------------

* Added a requirement for partial C++11 support, most importantly variadic
  templates and type traits, and dropped ``FMT_VARIADIC_*`` emulation macros.
  Variadic templates are available since GCC 4.4, Clang 2.9 and MSVC 18.0 (2013).
  For older compilers use {fmt} `version 4.x
  <https://github.com/fmtlib/fmt/releases/tag/4.1.0>`_ which continues to be
  maintained and works with C++98 compilers.

* Renamed symbols to follow standard C++ naming conventions and proposed a subset
  of the library for standardization in `P0645R2 Text Formatting
  <https://wg21.link/P0645>`_.

* Implemented ``constexpr`` parsing of format strings and `compile-time format
  string checks
  <https://fmt.dev/latest/api.html#compile-time-format-string-checks>`_. For
  example

  .. code:: c++

     #include <fmt/format.h>

     std::string s = format(fmt("{:d}"), "foo");

  gives a compile-time error because ``d`` is an invalid specifier for strings
  (`godbolt <https://godbolt.org/g/rnCy9Q>`__)::

     ...
     <source>:4:19: note: in instantiation of function template specialization 'fmt::v5::format<S, char [4]>' requested here
       std::string s = format(fmt("{:d}"), "foo");
                       ^
     format.h:1337:13: note: non-constexpr function 'on_error' cannot be used in a constant expression
         handler.on_error("invalid type specifier");

  Compile-time checks require relaxed ``constexpr`` (C++14 feature) support. If
  the latter is not available, checks will be performed at runtime.

* Separated format string parsing and formatting in the extension API to enable
  compile-time format string processing. For example

  .. code:: c++

     struct Answer {};

     namespace fmt {
     template <>
     struct formatter<Answer> {
       constexpr auto parse(parse_context& ctx) {
         auto it = ctx.begin();
         spec = *it;
         if (spec != 'd' && spec != 's')
           throw format_error("invalid specifier");
         return ++it;
       }

       template <typename FormatContext>
       auto format(Answer, FormatContext& ctx) {
         return spec == 's' ?
           format_to(ctx.begin(), "{}", "fourty-two") :
           format_to(ctx.begin(), "{}", 42);
       }

       char spec = 0;
     };
     }

     std::string s = format(fmt("{:x}"), Answer());

  gives a compile-time error due to invalid format specifier (`godbolt
  <https://godbolt.org/g/2jQ1Dv>`__)::

     ...
     <source>:12:45: error: expression '<throw-expression>' is not a constant expression
            throw format_error("invalid specifier");

* Added `iterator support
  <https://fmt.dev/latest/api.html#output-iterator-support>`_:

  .. code:: c++

     #include <vector>
     #include <fmt/format.h>

     std::vector<char> out;
     fmt::format_to(std::back_inserter(out), "{}", 42);

* Added the `format_to_n
  <https://fmt.dev/latest/api.html#_CPPv2N3fmt11format_to_nE8OutputItNSt6size_tE11string_viewDpRK4Args>`_
  function that restricts the output to the specified number of characters
  (`#298 <https://github.com/fmtlib/fmt/issues/298>`_):

  .. code:: c++

     char out[4];
     fmt::format_to_n(out, sizeof(out), "{}", 12345);
     // out == "1234" (without terminating '\0')

* Added the `formatted_size
  <https://fmt.dev/latest/api.html#_CPPv2N3fmt14formatted_sizeE11string_viewDpRK4Args>`_
  function for computing the output size:

  .. code:: c++

     #include <fmt/format.h>

     auto size = fmt::formatted_size("{}", 12345); // size == 5

* Improved compile times by reducing dependencies on standard headers and
  providing a lightweight `core API <https://fmt.dev/latest/api.html#core-api>`_:

  .. code:: c++

     #include <fmt/core.h>

     fmt::print("The answer is {}.", 42);

  See `Compile time and code bloat
  <https://github.com/fmtlib/fmt#compile-time-and-code-bloat>`_.

* Added the `make_format_args
  <https://fmt.dev/latest/api.html#_CPPv2N3fmt16make_format_argsEDpRK4Args>`_
  function for capturing formatting arguments:

  .. code:: c++
  
     // Prints formatted error message.
     void vreport_error(const char *format, fmt::format_args args) {
       fmt::print("Error: ");
       fmt::vprint(format, args);
     }
     template <typename... Args>
     void report_error(const char *format, const Args & ... args) {
       vreport_error(format, fmt::make_format_args(args...));
     }

* Added the ``make_printf_args`` function for capturing ``printf`` arguments
  (`#687 <https://github.com/fmtlib/fmt/issues/687>`_,
  `#694 <https://github.com/fmtlib/fmt/pull/694>`_).
  Thanks `@Kronuz (Germán Méndez Bravo) <https://github.com/Kronuz>`_.

* Added prefix ``v`` to non-variadic functions taking ``format_args`` to
  distinguish them from variadic ones:

  .. code:: c++

     std::string vformat(string_view format_str, format_args args);
     
     template <typename... Args>
     std::string format(string_view format_str, const Args & ... args);

* Added experimental support for formatting ranges, containers and tuple-like
  types in ``fmt/ranges.h`` (`#735 <https://github.com/fmtlib/fmt/pull/735>`_):

  .. code:: c++

     #include <fmt/ranges.h>

     std::vector<int> v = {1, 2, 3};
     fmt::print("{}", v); // prints {1, 2, 3}

  Thanks `@Remotion (Remo) <https://github.com/Remotion>`_.

* Implemented ``wchar_t`` date and time formatting
  (`#712 <https://github.com/fmtlib/fmt/pull/712>`_):

  .. code:: c++

     #include <fmt/time.h>

     std::time_t t = std::time(nullptr);
     auto s = fmt::format(L"The date is {:%Y-%m-%d}.", *std::localtime(&t));

  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Provided more wide string overloads
  (`#724 <https://github.com/fmtlib/fmt/pull/724>`_).
  Thanks `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.

* Switched from a custom null-terminated string view class to ``string_view``
  in the format API and provided ``fmt::string_view`` which implements a subset
  of ``std::string_view`` API for pre-C++17 systems.

* Added support for ``std::experimental::string_view``
  (`#607 <https://github.com/fmtlib/fmt/pull/607>`_):

  .. code:: c++

     #include <fmt/core.h>
     #include <experimental/string_view>

     fmt::print("{}", std::experimental::string_view("foo"));

  Thanks `@virgiliofornazin (Virgilio Alexandre Fornazin)
  <https://github.com/virgiliofornazin>`__.

* Allowed mixing named and automatic arguments:

  .. code:: c++

     fmt::format("{} {two}", 1, fmt::arg("two", 2));

* Removed the write API in favor of the `format API
  <https://fmt.dev/latest/api.html#format-api>`_ with compile-time handling of
  format strings.

* Disallowed formatting of multibyte strings into a wide character target
  (`#606 <https://github.com/fmtlib/fmt/pull/606>`_).

* Improved documentation
  (`#515 <https://github.com/fmtlib/fmt/pull/515>`_,
  `#614 <https://github.com/fmtlib/fmt/issues/614>`_,
  `#617 <https://github.com/fmtlib/fmt/pull/617>`_,
  `#661 <https://github.com/fmtlib/fmt/pull/661>`_,
  `#680 <https://github.com/fmtlib/fmt/pull/680>`_).
  Thanks `@ibell (Ian Bell) <https://github.com/ibell>`_,
  `@mihaitodor (Mihai Todor) <https://github.com/mihaitodor>`_, and
  `@johnthagen <https://github.com/johnthagen>`_.

* Implemented more efficient handling of large number of format arguments.

* Introduced an inline namespace for symbol versioning.

* Added debug postfix ``d`` to the ``fmt`` library name
  (`#636 <https://github.com/fmtlib/fmt/issues/636>`_).

* Removed unnecessary ``fmt/`` prefix in includes
  (`#397 <https://github.com/fmtlib/fmt/pull/397>`_).
  Thanks `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_.

* Moved ``fmt/*.h`` to ``include/fmt/*.h`` to prevent irrelevant files and
  directories appearing on the include search paths when fmt is used as a
  subproject and moved source files to the ``src`` directory.

* Added qmake project file ``support/fmt.pro``
  (`#641 <https://github.com/fmtlib/fmt/pull/641>`_).
  Thanks `@cowo78 (Giuseppe Corbelli) <https://github.com/cowo78>`_.

* Added Gradle build file ``support/build.gradle``
  (`#649 <https://github.com/fmtlib/fmt/pull/649>`_).
  Thanks `@luncliff (Park DongHa) <https://github.com/luncliff>`_.

* Removed ``FMT_CPPFORMAT`` CMake option.

* Fixed a name conflict with the macro ``CHAR_WIDTH`` in glibc
  (`#616 <https://github.com/fmtlib/fmt/pull/616>`_).
  Thanks `@aroig (Abdó Roig-Maranges) <https://github.com/aroig>`_.

* Fixed handling of nested braces in ``fmt::join``
  (`#638 <https://github.com/fmtlib/fmt/issues/638>`_).

* Added ``SOURCELINK_SUFFIX`` for compatibility with Sphinx 1.5
  (`#497 <https://github.com/fmtlib/fmt/pull/497>`_).
  Thanks `@ginggs (Graham Inggs) <https://github.com/ginggs>`_.

* Added a missing ``inline`` in the header-only mode
  (`#626 <https://github.com/fmtlib/fmt/pull/626>`_).
  Thanks `@aroig (Abdó Roig-Maranges) <https://github.com/aroig>`_.

* Fixed various compiler warnings
  (`#640 <https://github.com/fmtlib/fmt/pull/640>`_,
  `#656 <https://github.com/fmtlib/fmt/pull/656>`_,
  `#679 <https://github.com/fmtlib/fmt/pull/679>`_,
  `#681 <https://github.com/fmtlib/fmt/pull/681>`_,
  `#705 <https://github.com/fmtlib/fmt/pull/705>`__,
  `#715 <https://github.com/fmtlib/fmt/issues/715>`_,
  `#717 <https://github.com/fmtlib/fmt/pull/717>`_,
  `#720 <https://github.com/fmtlib/fmt/pull/720>`_,
  `#723 <https://github.com/fmtlib/fmt/pull/723>`_,
  `#726 <https://github.com/fmtlib/fmt/pull/726>`_,
  `#730 <https://github.com/fmtlib/fmt/pull/730>`_,
  `#739 <https://github.com/fmtlib/fmt/pull/739>`_).
  Thanks `@peterbell10 <https://github.com/peterbell10>`_,
  `@LarsGullik <https://github.com/LarsGullik>`_,
  `@foonathan (Jonathan Müller) <https://github.com/foonathan>`_,
  `@eliaskosunen (Elias Kosunen) <https://github.com/eliaskosunen>`_,
  `@christianparpart (Christian Parpart) <https://github.com/christianparpart>`_,
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_,
  and `@mwinterb <https://github.com/mwinterb>`_.

* Worked around an MSVC bug and fixed several warnings
  (`#653 <https://github.com/fmtlib/fmt/pull/653>`_).
  Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.

* Worked around GCC bug 67371
  (`#682 <https://github.com/fmtlib/fmt/issues/682>`_).

* Fixed compilation with ``-fno-exceptions``
  (`#655 <https://github.com/fmtlib/fmt/pull/655>`_).
  Thanks `@chenxiaolong (Andrew Gunnerson) <https://github.com/chenxiaolong>`_.

* Made ``constexpr remove_prefix`` gcc version check tighter
  (`#648 <https://github.com/fmtlib/fmt/issues/648>`_).

* Renamed internal type enum constants to prevent collision with poorly written
  C libraries (`#644 <https://github.com/fmtlib/fmt/issues/644>`_).

* Added detection of ``wostream operator<<``
  (`#650 <https://github.com/fmtlib/fmt/issues/650>`_).

* Fixed compilation on OpenBSD
  (`#660 <https://github.com/fmtlib/fmt/pull/660>`_).
  Thanks `@hubslave <https://github.com/hubslave>`_.

* Fixed compilation on FreeBSD 12
  (`#732 <https://github.com/fmtlib/fmt/pull/732>`_).
  Thanks `@dankm <https://github.com/dankm>`_.

* Fixed compilation when there is a mismatch between ``-std`` options between
  the library and user code
  (`#664 <https://github.com/fmtlib/fmt/issues/664>`_).

* Fixed compilation with GCC 7 and ``-std=c++11``
  (`#734 <https://github.com/fmtlib/fmt/issues/734>`_).

* Improved generated binary code on GCC 7 and older
  (`#668 <https://github.com/fmtlib/fmt/issues/668>`_).

* Fixed handling of numeric alignment with no width 
  (`#675 <https://github.com/fmtlib/fmt/issues/675>`_).

* Fixed handling of empty strings in UTF8/16 converters
  (`#676 <https://github.com/fmtlib/fmt/pull/676>`_).
  Thanks `@vgalka-sl (Vasili Galka) <https://github.com/vgalka-sl>`_.

* Fixed formatting of an empty ``string_view``
  (`#689 <https://github.com/fmtlib/fmt/issues/689>`_).

* Fixed detection of ``string_view`` on libc++ 
  (`#686 <https://github.com/fmtlib/fmt/issues/686>`_).

* Fixed DLL issues (`#696 <https://github.com/fmtlib/fmt/pull/696>`_).
  Thanks `@sebkoenig <https://github.com/sebkoenig>`_.

* Fixed compile checks for mixing narrow and wide strings
  (`#690 <https://github.com/fmtlib/fmt/issues/690>`_).

* Disabled unsafe implicit conversion to ``std::string``
  (`#729 <https://github.com/fmtlib/fmt/issues/729>`_).

* Fixed handling of reused format specs (as in ``fmt::join``) for pointers
  (`#725 <https://github.com/fmtlib/fmt/pull/725>`_).
  Thanks `@mwinterb <https://github.com/mwinterb>`_.

* Fixed installation of ``fmt/ranges.h``
  (`#738 <https://github.com/fmtlib/fmt/pull/738>`_).
  Thanks `@sv1990 <https://github.com/sv1990>`_.

4.1.0 - 2017-12-20
------------------

* Added ``fmt::to_wstring()`` in addition to ``fmt::to_string()``
  (`#559 <https://github.com/fmtlib/fmt/pull/559>`_).
  Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.

* Added support for C++17 ``std::string_view``
  (`#571 <https://github.com/fmtlib/fmt/pull/571>`_ and
  `#578 <https://github.com/fmtlib/fmt/pull/578>`_).
  Thanks `@thelostt (Mário Feroldi) <https://github.com/thelostt>`_ and
  `@mwinterb <https://github.com/mwinterb>`_.

* Enabled stream exceptions to catch errors
  (`#581 <https://github.com/fmtlib/fmt/issues/581>`_).
  Thanks `@crusader-mike <https://github.com/crusader-mike>`_.

* Allowed formatting of class hierarchies with ``fmt::format_arg()``
  (`#547 <https://github.com/fmtlib/fmt/pull/547>`_).
  Thanks `@rollbear (Björn Fahller) <https://github.com/rollbear>`_.

* Removed limitations on character types
  (`#563 <https://github.com/fmtlib/fmt/pull/563>`_).
  Thanks `@Yelnats321 (Elnar Dakeshov) <https://github.com/Yelnats321>`_.

* Conditionally enabled use of ``std::allocator_traits``
  (`#583 <https://github.com/fmtlib/fmt/pull/583>`_).
  Thanks `@mwinterb <https://github.com/mwinterb>`_.

* Added support for ``const`` variadic member function emulation with
  ``FMT_VARIADIC_CONST`` (`#591 <https://github.com/fmtlib/fmt/pull/591>`_).
  Thanks `@ludekvodicka (Ludek Vodicka) <https://github.com/ludekvodicka>`_.

* Various bugfixes: bad overflow check, unsupported implicit type conversion
  when determining formatting function, test segfaults
  (`#551 <https://github.com/fmtlib/fmt/issues/551>`_), ill-formed macros
  (`#542 <https://github.com/fmtlib/fmt/pull/542>`_) and ambiguous overloads
  (`#580 <https://github.com/fmtlib/fmt/issues/580>`_).
  Thanks `@xylosper (Byoung-young Lee) <https://github.com/xylosper>`_.

* Prevented warnings on MSVC (`#605 <https://github.com/fmtlib/fmt/pull/605>`_,
  `#602 <https://github.com/fmtlib/fmt/pull/602>`_, and
  `#545 <https://github.com/fmtlib/fmt/pull/545>`_),
  clang (`#582 <https://github.com/fmtlib/fmt/pull/582>`_),
  GCC (`#573 <https://github.com/fmtlib/fmt/issues/573>`_),
  various conversion warnings (`#609 <https://github.com/fmtlib/fmt/pull/609>`_,
  `#567 <https://github.com/fmtlib/fmt/pull/567>`_,
  `#553 <https://github.com/fmtlib/fmt/pull/553>`_ and
  `#553 <https://github.com/fmtlib/fmt/pull/553>`_), and added ``override`` and
  ``[[noreturn]]`` (`#549 <https://github.com/fmtlib/fmt/pull/549>`_ and
  `#555 <https://github.com/fmtlib/fmt/issues/555>`_).
  Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_,
  `@virgiliofornazin (Virgilio Alexandre Fornazin)
  <https://gihtub.com/virgiliofornazin>`_,
  `@alexanderbock (Alexander Bock) <https://github.com/alexanderbock>`_,
  `@yumetodo <https://github.com/yumetodo>`_,
  `@VaderY (Császár Mátyás) <https://github.com/VaderY>`_,
  `@jpcima (JP Cimalando) <https://github.com/jpcima>`_,
  `@thelostt (Mário Feroldi) <https://github.com/thelostt>`_, and
  `@Manu343726 (Manu Sánchez) <https://github.com/Manu343726>`_.

* Improved CMake: Used ``GNUInstallDirs`` to set installation location
  (`#610 <https://github.com/fmtlib/fmt/pull/610>`_) and fixed warnings
  (`#536 <https://github.com/fmtlib/fmt/pull/536>`_ and
  `#556 <https://github.com/fmtlib/fmt/pull/556>`_).
  Thanks `@mikecrowe (Mike Crowe) <https://github.com/mikecrowe>`_,
  `@evgen231 <https://github.com/evgen231>`_ and
  `@henryiii (Henry Schreiner) <https://github.com/henryiii>`_.

4.0.0 - 2017-06-27
------------------

* Removed old compatibility headers ``cppformat/*.h`` and CMake options
  (`#527 <https://github.com/fmtlib/fmt/pull/527>`_).
  Thanks `@maddinat0r (Alex Martin) <https://github.com/maddinat0r>`_.

* Added ``string.h`` containing ``fmt::to_string()`` as alternative to
  ``std::to_string()`` as well as other string writer functionality
  (`#326 <https://github.com/fmtlib/fmt/issues/326>`_ and
  `#441 <https://github.com/fmtlib/fmt/pull/441>`_):

  .. code:: c++

    #include "fmt/string.h"
  
    std::string answer = fmt::to_string(42);

  Thanks to `@glebov-andrey (Andrey Glebov)
  <https://github.com/glebov-andrey>`_.

* Moved ``fmt::printf()`` to new ``printf.h`` header and allowed ``%s`` as
  generic specifier (`#453 <https://github.com/fmtlib/fmt/pull/453>`_),
  made ``%.f`` more conformant to regular ``printf()``
  (`#490 <https://github.com/fmtlib/fmt/pull/490>`_), added custom writer
  support (`#476 <https://github.com/fmtlib/fmt/issues/476>`_) and implemented
  missing custom argument formatting
  (`#339 <https://github.com/fmtlib/fmt/pull/339>`_ and
  `#340 <https://github.com/fmtlib/fmt/pull/340>`_):

  .. code:: c++

    #include "fmt/printf.h"
 
    // %s format specifier can be used with any argument type.
    fmt::printf("%s", 42);

  Thanks `@mojoBrendan <https://github.com/mojoBrendan>`_,
  `@manylegged (Arthur Danskin) <https://github.com/manylegged>`_ and
  `@spacemoose (Glen Stark) <https://github.com/spacemoose>`_.
  See also `#360 <https://github.com/fmtlib/fmt/issues/360>`_,
  `#335 <https://github.com/fmtlib/fmt/issues/335>`_ and
  `#331 <https://github.com/fmtlib/fmt/issues/331>`_.

* Added ``container.h`` containing a ``BasicContainerWriter``
  to write to containers like ``std::vector``
  (`#450 <https://github.com/fmtlib/fmt/pull/450>`_).
  Thanks `@polyvertex (Jean-Charles Lefebvre) <https://github.com/polyvertex>`_.

* Added ``fmt::join()`` function that takes a range and formats
  its elements separated by a given string
  (`#466 <https://github.com/fmtlib/fmt/pull/466>`_):

  .. code:: c++

    #include "fmt/format.h"
 
    std::vector<double> v = {1.2, 3.4, 5.6};
    // Prints "(+01.20, +03.40, +05.60)".
    fmt::print("({:+06.2f})", fmt::join(v.begin(), v.end(), ", "));

  Thanks `@olivier80 <https://github.com/olivier80>`_.

* Added support for custom formatting specifications to simplify customization
  of built-in formatting (`#444 <https://github.com/fmtlib/fmt/pull/444>`_).
  Thanks `@polyvertex (Jean-Charles Lefebvre) <https://github.com/polyvertex>`_.
  See also `#439 <https://github.com/fmtlib/fmt/issues/439>`_.

* Added ``fmt::format_system_error()`` for error code formatting
  (`#323 <https://github.com/fmtlib/fmt/issues/323>`_ and
  `#526 <https://github.com/fmtlib/fmt/pull/526>`_).
  Thanks `@maddinat0r (Alex Martin) <https://github.com/maddinat0r>`_.

* Added thread-safe ``fmt::localtime()`` and ``fmt::gmtime()``
  as replacement   for the standard version to ``time.h``
  (`#396 <https://github.com/fmtlib/fmt/pull/396>`_).
  Thanks `@codicodi <https://github.com/codicodi>`_.

* Internal improvements to ``NamedArg`` and ``ArgLists``
  (`#389 <https://github.com/fmtlib/fmt/pull/389>`_ and
  `#390 <https://github.com/fmtlib/fmt/pull/390>`_).
  Thanks `@chronoxor <https://github.com/chronoxor>`_.

* Fixed crash due to bug in ``FormatBuf``
  (`#493 <https://github.com/fmtlib/fmt/pull/493>`_).
  Thanks `@effzeh <https://github.com/effzeh>`_. See also
  `#480 <https://github.com/fmtlib/fmt/issues/480>`_ and
  `#491 <https://github.com/fmtlib/fmt/issues/491>`_.

* Fixed handling of wide strings in ``fmt::StringWriter``.

* Improved compiler error messages
  (`#357 <https://github.com/fmtlib/fmt/issues/357>`_).

* Fixed various warnings and issues with various compilers
  (`#494 <https://github.com/fmtlib/fmt/pull/494>`_,
  `#499 <https://github.com/fmtlib/fmt/pull/499>`_,
  `#483 <https://github.com/fmtlib/fmt/pull/483>`_,
  `#485 <https://github.com/fmtlib/fmt/pull/485>`_,
  `#482 <https://github.com/fmtlib/fmt/pull/482>`_,
  `#475 <https://github.com/fmtlib/fmt/pull/475>`_,
  `#473 <https://github.com/fmtlib/fmt/pull/473>`_ and
  `#414 <https://github.com/fmtlib/fmt/pull/414>`_).
  Thanks `@chronoxor <https://github.com/chronoxor>`_,
  `@zhaohuaxishi <https://github.com/zhaohuaxishi>`_,
  `@pkestene (Pierre Kestener) <https://github.com/pkestene>`_,
  `@dschmidt (Dominik Schmidt) <https://github.com/dschmidt>`_ and
  `@0x414c (Alexey Gorishny) <https://github.com/0x414c>`_ .

* Improved CMake: targets are now namespaced
  (`#511 <https://github.com/fmtlib/fmt/pull/511>`_ and
  `#513 <https://github.com/fmtlib/fmt/pull/513>`_), supported header-only
  ``printf.h`` (`#354 <https://github.com/fmtlib/fmt/pull/354>`_), fixed issue
  with minimal supported library subset
  (`#418 <https://github.com/fmtlib/fmt/issues/418>`_,
  `#419 <https://github.com/fmtlib/fmt/pull/419>`_ and
  `#420 <https://github.com/fmtlib/fmt/pull/420>`_).
  Thanks `@bjoernthiel (Bjoern Thiel) <https://github.com/bjoernthiel>`_,
  `@niosHD (Mario Werner) <https://github.com/niosHD>`_,
  `@LogicalKnight (Sean LK) <https://github.com/LogicalKnight>`_ and
  `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.

* Improved documentation. Thanks to
  `@pwm1234 (Phil) <https://github.com/pwm1234>`_ for
  `#393 <https://github.com/fmtlib/fmt/pull/393>`_.

3.0.2 - 2017-06-14
------------------

* Added ``FMT_VERSION`` macro
  (`#411 <https://github.com/fmtlib/fmt/issues/411>`_).

* Used ``FMT_NULL`` instead of literal ``0``
  (`#409 <https://github.com/fmtlib/fmt/pull/409>`_).
  Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.

* Added extern templates for ``format_float``
  (`#413 <https://github.com/fmtlib/fmt/issues/413>`_).

* Fixed implicit conversion issue
  (`#507 <https://github.com/fmtlib/fmt/issues/507>`_).

* Fixed signbit detection (`#423 <https://github.com/fmtlib/fmt/issues/423>`_).

* Fixed naming collision (`#425 <https://github.com/fmtlib/fmt/issues/425>`_).

* Fixed missing intrinsic for C++/CLI
  (`#457 <https://github.com/fmtlib/fmt/pull/457>`_).
  Thanks `@calumr (Calum Robinson) <https://github.com/calumr>`_

* Fixed Android detection (`#458 <https://github.com/fmtlib/fmt/pull/458>`_).
  Thanks `@Gachapen (Magnus Bjerke Vik) <https://github.com/Gachapen>`_.

* Use lean ``windows.h`` if not in header-only mode
  (`#503 <https://github.com/fmtlib/fmt/pull/503>`_).
  Thanks `@Quentin01 (Quentin Buathier) <https://github.com/Quentin01>`_.

* Fixed issue with CMake exporting C++11 flag
  (`#445 <https://github.com/fmtlib/fmt/pull/455>`_).
  Thanks `@EricWF (Eric) <https://github.com/EricWF>`_.

* Fixed issue with nvcc and MSVC compiler bug and MinGW
  (`#505 <https://github.com/fmtlib/fmt/issues/505>`_).

* Fixed DLL issues (`#469 <https://github.com/fmtlib/fmt/pull/469>`_ and
  `#502 <https://github.com/fmtlib/fmt/pull/502>`_).
  Thanks `@richardeakin (Richard Eakin) <https://github.com/richardeakin>`_ and
  `@AndreasSchoenle (Andreas Schönle) <https://github.com/AndreasSchoenle>`_.

* Fixed test compilation under FreeBSD
  (`#433 <https://github.com/fmtlib/fmt/issues/433>`_).

* Fixed various warnings (`#403 <https://github.com/fmtlib/fmt/pull/403>`_,
  `#410 <https://github.com/fmtlib/fmt/pull/410>`_ and
  `#510 <https://github.com/fmtlib/fmt/pull/510>`_).
  Thanks `@Lecetem <https://github.com/Lectem>`_,
  `@chenhayat (Chen Hayat) <https://github.com/chenhayat>`_ and
  `@trozen <https://github.com/trozen>`_.

* Worked around a broken ``__builtin_clz`` in clang with MS codegen
  (`#519 <https://github.com/fmtlib/fmt/issues/519>`_).

* Removed redundant include
  (`#479 <https://github.com/fmtlib/fmt/issues/479>`_).

* Fixed documentation issues.

3.0.1 - 2016-11-01
------------------
* Fixed handling of thousands separator
  (`#353 <https://github.com/fmtlib/fmt/issues/353>`_).

* Fixed handling of ``unsigned char`` strings
  (`#373 <https://github.com/fmtlib/fmt/issues/373>`_).

* Corrected buffer growth when formatting time
  (`#367 <https://github.com/fmtlib/fmt/issues/367>`_).

* Removed warnings under MSVC and clang
  (`#318 <https://github.com/fmtlib/fmt/issues/318>`_,
  `#250 <https://github.com/fmtlib/fmt/issues/250>`_, also merged
  `#385 <https://github.com/fmtlib/fmt/pull/385>`_ and
  `#361 <https://github.com/fmtlib/fmt/pull/361>`_).
  Thanks `@jcelerier (Jean-Michaël Celerier) <https://github.com/jcelerier>`_
  and `@nmoehrle (Nils Moehrle) <https://github.com/nmoehrle>`_.

* Fixed compilation issues under Android
  (`#327 <https://github.com/fmtlib/fmt/pull/327>`_,
  `#345 <https://github.com/fmtlib/fmt/issues/345>`_ and
  `#381 <https://github.com/fmtlib/fmt/pull/381>`_),
  FreeBSD (`#358 <https://github.com/fmtlib/fmt/pull/358>`_),
  Cygwin (`#388 <https://github.com/fmtlib/fmt/issues/388>`_),
  MinGW (`#355 <https://github.com/fmtlib/fmt/issues/355>`_) as well as other
  issues (`#350 <https://github.com/fmtlib/fmt/issues/350>`_,
  `#366 <https://github.com/fmtlib/fmt/issues/355>`_,
  `#348 <https://github.com/fmtlib/fmt/pull/348>`_,
  `#402 <https://github.com/fmtlib/fmt/pull/402>`_,
  `#405 <https://github.com/fmtlib/fmt/pull/405>`_).
  Thanks to `@dpantele (Dmitry) <https://github.com/dpantele>`_,
  `@hghwng (Hugh Wang) <https://github.com/hghwng>`_,
  `@arvedarved (Tilman Keskinöz) <https://github.com/arvedarved>`_,
  `@LogicalKnight (Sean) <https://github.com/LogicalKnight>`_ and
  `@JanHellwig (Jan Hellwig) <https://github.com/janhellwig>`_.

* Fixed some documentation issues and extended specification
  (`#320 <https://github.com/fmtlib/fmt/issues/320>`_,
  `#333 <https://github.com/fmtlib/fmt/pull/333>`_,
  `#347 <https://github.com/fmtlib/fmt/issues/347>`_,
  `#362 <https://github.com/fmtlib/fmt/pull/362>`_).
  Thanks to `@smellman (Taro Matsuzawa aka. btm)
  <https://github.com/smellman>`_.

3.0.0 - 2016-05-07
------------------

* The project has been renamed from C++ Format (cppformat) to fmt for
  consistency with the used namespace and macro prefix
  (`#307 <https://github.com/fmtlib/fmt/issues/307>`_).
  Library headers are now located in the ``fmt`` directory:

  .. code:: c++

    #include "fmt/format.h"

  Including ``format.h`` from the ``cppformat`` directory is deprecated
  but works via a proxy header which will be removed in the next major version.
  
  The documentation is now available at https://fmt.dev.

* Added support for `strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like
  `date and time formatting <https://fmt.dev/3.0.0/api.html#date-and-time-formatting>`_
  (`#283 <https://github.com/fmtlib/fmt/issues/283>`_):

  .. code:: c++

    #include "fmt/time.h"

    std::time_t t = std::time(nullptr);
    // Prints "The date is 2016-04-29." (with the current date)
    fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));

* ``std::ostream`` support including formatting of user-defined types that provide
  overloaded ``operator<<`` has been moved to ``fmt/ostream.h``:

  .. code:: c++

    #include "fmt/ostream.h"

    class Date {
      int year_, month_, day_;
    public:
      Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}

      friend std::ostream &operator<<(std::ostream &os, const Date &d) {
        return os << d.year_ << '-' << d.month_ << '-' << d.day_;
      }
    };

    std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
    // s == "The date is 2012-12-9"

* Added support for `custom argument formatters
  <https://fmt.dev/3.0.0/api.html#argument-formatters>`_
  (`#235 <https://github.com/fmtlib/fmt/issues/235>`_).

* Added support for locale-specific integer formatting with the ``n`` specifier
  (`#305 <https://github.com/fmtlib/fmt/issues/305>`_):

  .. code:: c++

    std::setlocale(LC_ALL, "en_US.utf8");
    fmt::print("cppformat: {:n}\n", 1234567); // prints 1,234,567

* Sign is now preserved when formatting an integer with an incorrect ``printf``
  format specifier (`#265 <https://github.com/fmtlib/fmt/issues/265>`_):

  .. code:: c++

    fmt::printf("%lld", -42); // prints -42

  Note that it would be an undefined behavior in ``std::printf``.

* Length modifiers such as ``ll`` are now optional in printf formatting
  functions and the correct type is determined automatically
  (`#255 <https://github.com/fmtlib/fmt/issues/255>`_):

  .. code:: c++

    fmt::printf("%d", std::numeric_limits<long long>::max());

  Note that it would be an undefined behavior in ``std::printf``.

* Added initial support for custom formatters
  (`#231 <https://github.com/fmtlib/fmt/issues/231>`_).

* Fixed detection of user-defined literal support on Intel C++ compiler
  (`#311 <https://github.com/fmtlib/fmt/issues/311>`_,
  `#312 <https://github.com/fmtlib/fmt/pull/312>`_).
  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_ and
  `@speth (Ray Speth) <https://github.com/speth>`_.

* Reduced compile time
  (`#243 <https://github.com/fmtlib/fmt/pull/243>`_,
  `#249 <https://github.com/fmtlib/fmt/pull/249>`_,
  `#317 <https://github.com/fmtlib/fmt/issues/317>`_):

  .. image:: https://cloud.githubusercontent.com/assets/4831417/11614060/
             b9e826d2-9c36-11e5-8666-d4131bf503ef.png

  .. image:: https://cloud.githubusercontent.com/assets/4831417/11614080/
             6ac903cc-9c37-11e5-8165-26df6efae364.png

  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_.

* Compile test fixes (`#313 <https://github.com/fmtlib/fmt/pull/313>`_).
  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_.

* Documentation fixes (`#239 <https://github.com/fmtlib/fmt/pull/239>`_,
  `#248 <https://github.com/fmtlib/fmt/issues/248>`_,
  `#252 <https://github.com/fmtlib/fmt/issues/252>`_,
  `#258 <https://github.com/fmtlib/fmt/pull/258>`_,
  `#260 <https://github.com/fmtlib/fmt/issues/260>`_,
  `#301 <https://github.com/fmtlib/fmt/issues/301>`_,
  `#309 <https://github.com/fmtlib/fmt/pull/309>`_).
  Thanks to `@ReadmeCritic <https://github.com/ReadmeCritic>`_
  `@Gachapen (Magnus Bjerke Vik) <https://github.com/Gachapen>`_ and
  `@jwilk (Jakub Wilk) <https://github.com/jwilk>`_.

* Fixed compiler and sanitizer warnings
  (`#244 <https://github.com/fmtlib/fmt/issues/244>`_,
  `#256 <https://github.com/fmtlib/fmt/pull/256>`_,
  `#259 <https://github.com/fmtlib/fmt/pull/259>`_,
  `#263 <https://github.com/fmtlib/fmt/issues/263>`_,
  `#274 <https://github.com/fmtlib/fmt/issues/274>`_,
  `#277 <https://github.com/fmtlib/fmt/pull/277>`_,
  `#286 <https://github.com/fmtlib/fmt/pull/286>`_,
  `#291 <https://github.com/fmtlib/fmt/issues/291>`_,
  `#296 <https://github.com/fmtlib/fmt/issues/296>`_,
  `#308 <https://github.com/fmtlib/fmt/issues/308>`_)
  Thanks to `@mwinterb <https://github.com/mwinterb>`_,
  `@pweiskircher (Patrik Weiskircher) <https://github.com/pweiskircher>`_,
  `@Naios <https://github.com/Naios>`_.

* Improved compatibility with Windows Store apps
  (`#280 <https://github.com/fmtlib/fmt/issues/280>`_,
  `#285 <https://github.com/fmtlib/fmt/pull/285>`_)
  Thanks to `@mwinterb <https://github.com/mwinterb>`_.

* Added tests of compatibility with older C++ standards
  (`#273 <https://github.com/fmtlib/fmt/pull/273>`_).
  Thanks to `@niosHD <https://github.com/niosHD>`_.

* Fixed Android build (`#271 <https://github.com/fmtlib/fmt/pull/271>`_).
  Thanks to `@newnon <https://github.com/newnon>`_.

* Changed ``ArgMap`` to be backed by a vector instead of a map.
  (`#261 <https://github.com/fmtlib/fmt/issues/261>`_,
  `#262 <https://github.com/fmtlib/fmt/pull/262>`_).
  Thanks to `@mwinterb <https://github.com/mwinterb>`_.

* Added ``fprintf`` overload that writes to a ``std::ostream``
  (`#251 <https://github.com/fmtlib/fmt/pull/251>`_).
  Thanks to `nickhutchinson (Nicholas Hutchinson) <https://github.com/nickhutchinson>`_.

* Export symbols when building a Windows DLL
  (`#245 <https://github.com/fmtlib/fmt/pull/245>`_).
  Thanks to `macdems (Maciek Dems) <https://github.com/macdems>`_.

* Fixed compilation on Cygwin (`#304 <https://github.com/fmtlib/fmt/issues/304>`_).

* Implemented a workaround for a bug in Apple LLVM version 4.2 of clang
  (`#276 <https://github.com/fmtlib/fmt/issues/276>`_).

* Implemented a workaround for Google Test bug
  `#705 <https://github.com/google/googletest/issues/705>`_ on gcc 6
  (`#268 <https://github.com/fmtlib/fmt/issues/268>`_).
  Thanks to `octoploid <https://github.com/octoploid>`_.

* Removed Biicode support because the latter has been discontinued.

2.1.1 - 2016-04-11
------------------

* The install location for generated CMake files is now configurable via
  the ``FMT_CMAKE_DIR`` CMake variable
  (`#299 <https://github.com/fmtlib/fmt/pull/299>`_).
  Thanks to `@niosHD <https://github.com/niosHD>`_.

* Documentation fixes (`#252 <https://github.com/fmtlib/fmt/issues/252>`_).

2.1.0 - 2016-03-21
------------------

* Project layout and build system improvements
  (`#267 <https://github.com/fmtlib/fmt/pull/267>`_):

  * The code have been moved to the ``cppformat`` directory.
    Including ``format.h`` from the top-level directory is deprecated
    but works via a proxy header which will be removed in the next
    major version.

  * C++ Format CMake targets now have proper interface definitions.

  * Installed version of the library now supports the header-only
    configuration.

  * Targets ``doc``, ``install``, and ``test`` are now disabled if C++ Format
    is included as a CMake subproject. They can be enabled by setting
    ``FMT_DOC``, ``FMT_INSTALL``, and ``FMT_TEST`` in the parent project.

  Thanks to `@niosHD <https://github.com/niosHD>`_.

2.0.1 - 2016-03-13
------------------

* Improved CMake find and package support
  (`#264 <https://github.com/fmtlib/fmt/issues/264>`_).
  Thanks to `@niosHD <https://github.com/niosHD>`_.

* Fix compile error with Android NDK and mingw32
  (`#241 <https://github.com/fmtlib/fmt/issues/241>`_).
  Thanks to `@Gachapen (Magnus Bjerke Vik) <https://github.com/Gachapen>`_.

* Documentation fixes
  (`#248 <https://github.com/fmtlib/fmt/issues/248>`_,
  `#260 <https://github.com/fmtlib/fmt/issues/260>`_).

2.0.0 - 2015-12-01
------------------

General
~~~~~~~

* [Breaking] Named arguments
  (`#169 <https://github.com/fmtlib/fmt/pull/169>`_,
  `#173 <https://github.com/fmtlib/fmt/pull/173>`_,
  `#174 <https://github.com/fmtlib/fmt/pull/174>`_):

  .. code:: c++

    fmt::print("The answer is {answer}.", fmt::arg("answer", 42));

  Thanks to `@jamboree <https://github.com/jamboree>`_.

* [Experimental] User-defined literals for format and named arguments
  (`#204 <https://github.com/fmtlib/fmt/pull/204>`_,
  `#206 <https://github.com/fmtlib/fmt/pull/206>`_,
  `#207 <https://github.com/fmtlib/fmt/pull/207>`_):

  .. code:: c++

    using namespace fmt::literals;
    fmt::print("The answer is {answer}.", "answer"_a=42);

  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_.

* [Breaking] Formatting of more than 16 arguments is now supported when using
  variadic templates
  (`#141 <https://github.com/fmtlib/fmt/issues/141>`_).
  Thanks to `@Shauren <https://github.com/Shauren>`_.

* Runtime width specification
  (`#168 <https://github.com/fmtlib/fmt/pull/168>`_):

  .. code:: c++

    fmt::format("{0:{1}}", 42, 5); // gives "   42"

  Thanks to `@jamboree <https://github.com/jamboree>`_.

* [Breaking] Enums are now formatted with an overloaded ``std::ostream`` insertion
  operator (``operator<<``) if available
  (`#232 <https://github.com/fmtlib/fmt/issues/232>`_).

* [Breaking] Changed default ``bool`` format to textual, "true" or "false"
  (`#170 <https://github.com/fmtlib/fmt/issues/170>`_):

  .. code:: c++
  
    fmt::print("{}", true); // prints "true"

  To print ``bool`` as a number use numeric format specifier such as ``d``:

  .. code:: c++

    fmt::print("{:d}", true); // prints "1"

* ``fmt::printf`` and ``fmt::sprintf`` now support formatting of ``bool`` with the
  ``%s`` specifier giving textual output, "true" or "false"
  (`#223 <https://github.com/fmtlib/fmt/pull/223>`_):

  .. code:: c++

    fmt::printf("%s", true); // prints "true"

  Thanks to `@LarsGullik <https://github.com/LarsGullik>`_.

* [Breaking] ``signed char`` and ``unsigned char`` are now formatted as integers by default
  (`#217 <https://github.com/fmtlib/fmt/pull/217>`_).

* [Breaking] Pointers to C strings can now be formatted with the ``p`` specifier
  (`#223 <https://github.com/fmtlib/fmt/pull/223>`_):

  .. code:: c++

    fmt::print("{:p}", "test"); // prints pointer value

  Thanks to `@LarsGullik <https://github.com/LarsGullik>`_.

* [Breaking] ``fmt::printf`` and ``fmt::sprintf`` now print null pointers as ``(nil)``
  and null strings as ``(null)`` for consistency with glibc
  (`#226 <https://github.com/fmtlib/fmt/pull/226>`_).
  Thanks to `@LarsGullik <https://github.com/LarsGullik>`_.

* [Breaking] ``fmt::(s)printf`` now supports formatting of objects of user-defined types
  that provide an overloaded ``std::ostream`` insertion operator (``operator<<``)
  (`#201 <https://github.com/fmtlib/fmt/issues/201>`_):

  .. code:: c++

    fmt::printf("The date is %s", Date(2012, 12, 9));

* [Breaking] The ``Buffer`` template is now part of the public API and can be used
  to implement custom memory buffers
  (`#140 <https://github.com/fmtlib/fmt/issues/140>`_).
  Thanks to `@polyvertex (Jean-Charles Lefebvre) <https://github.com/polyvertex>`_.

* [Breaking] Improved compatibility between ``BasicStringRef`` and
  `std::experimental::basic_string_view
  <http://en.cppreference.com/w/cpp/experimental/basic_string_view>`_
  (`#100 <https://github.com/fmtlib/fmt/issues/100>`_,
  `#159 <https://github.com/fmtlib/fmt/issues/159>`_,
  `#183 <https://github.com/fmtlib/fmt/issues/183>`_):

  - Comparison operators now compare string content, not pointers
  - ``BasicStringRef::c_str`` replaced by ``BasicStringRef::data``
  - ``BasicStringRef`` is no longer assumed to be null-terminated

  References to null-terminated strings are now represented by a new class,
  ``BasicCStringRef``.

* Dependency on pthreads introduced by Google Test is now optional
  (`#185 <https://github.com/fmtlib/fmt/issues/185>`_).

* New CMake options ``FMT_DOC``, ``FMT_INSTALL`` and ``FMT_TEST`` to control
  generation of ``doc``, ``install`` and ``test`` targets respectively, on by default
  (`#197 <https://github.com/fmtlib/fmt/issues/197>`_,
  `#198 <https://github.com/fmtlib/fmt/issues/198>`_,
  `#200 <https://github.com/fmtlib/fmt/issues/200>`_).
  Thanks to `@maddinat0r (Alex Martin) <https://github.com/maddinat0r>`_.

* ``noexcept`` is now used when compiling with MSVC2015
  (`#215 <https://github.com/fmtlib/fmt/pull/215>`_).
  Thanks to `@dmkrepo (Dmitriy) <https://github.com/dmkrepo>`_.

* Added an option to disable use of ``windows.h`` when ``FMT_USE_WINDOWS_H``
  is defined as 0 before including ``format.h``
  (`#171 <https://github.com/fmtlib/fmt/issues/171>`_).
  Thanks to `@alfps (Alf P. Steinbach) <https://github.com/alfps>`_.

* [Breaking] ``windows.h`` is now included with ``NOMINMAX`` unless
  ``FMT_WIN_MINMAX`` is defined. This is done to prevent breaking code using
  ``std::min`` and ``std::max`` and only affects the header-only configuration
  (`#152 <https://github.com/fmtlib/fmt/issues/152>`_,
  `#153 <https://github.com/fmtlib/fmt/pull/153>`_,
  `#154 <https://github.com/fmtlib/fmt/pull/154>`_).
  Thanks to `@DevO2012 <https://github.com/DevO2012>`_.

* Improved support for custom character types
  (`#171 <https://github.com/fmtlib/fmt/issues/171>`_).
  Thanks to `@alfps (Alf P. Steinbach) <https://github.com/alfps>`_.

* Added an option to disable use of IOStreams when ``FMT_USE_IOSTREAMS``
  is defined as 0 before including ``format.h``
  (`#205 <https://github.com/fmtlib/fmt/issues/205>`_,
  `#208 <https://github.com/fmtlib/fmt/pull/208>`_).
  Thanks to `@JodiTheTigger <https://github.com/JodiTheTigger>`_.

* Improved detection of ``isnan``, ``isinf`` and ``signbit``.

Optimization
~~~~~~~~~~~~

* Made formatting of user-defined types more efficient with a custom stream buffer
  (`#92 <https://github.com/fmtlib/fmt/issues/92>`_,
  `#230 <https://github.com/fmtlib/fmt/pull/230>`_).
  Thanks to `@NotImplemented <https://github.com/NotImplemented>`_.

* Further improved performance of ``fmt::Writer`` on integer formatting
  and fixed a minor regression. Now it is ~7% faster than ``karma::generate``
  on Karma's benchmark
  (`#186 <https://github.com/fmtlib/fmt/issues/186>`_).

* [Breaking] Reduced `compiled code size
  <https://github.com/fmtlib/fmt#compile-time-and-code-bloat>`_
  (`#143 <https://github.com/fmtlib/fmt/issues/143>`_,
  `#149 <https://github.com/fmtlib/fmt/pull/149>`_).

Distribution
~~~~~~~~~~~~

* [Breaking] Headers are now installed in
  ``${CMAKE_INSTALL_PREFIX}/include/cppformat``
  (`#178 <https://github.com/fmtlib/fmt/issues/178>`_).
  Thanks to `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_.

* [Breaking] Changed the library name from ``format`` to ``cppformat``
  for consistency with the project name and to avoid potential conflicts
  (`#178 <https://github.com/fmtlib/fmt/issues/178>`_).
  Thanks to `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_.

* C++ Format is now available in `Debian <https://www.debian.org/>`_ GNU/Linux
  (`stretch <https://packages.debian.org/source/stretch/cppformat>`_,
  `sid <https://packages.debian.org/source/sid/cppformat>`_) and 
  derived distributions such as
  `Ubuntu <https://launchpad.net/ubuntu/+source/cppformat>`_ 15.10 and later
  (`#155 <https://github.com/fmtlib/fmt/issues/155>`_)::

    $ sudo apt-get install libcppformat1-dev

  Thanks to `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_.

* `Packages for Fedora and RHEL <https://admin.fedoraproject.org/pkgdb/package/cppformat/>`_
  are now available. Thanks to Dave Johansen.
  
* C++ Format can now be installed via `Homebrew <http://brew.sh/>`_ on OS X
  (`#157 <https://github.com/fmtlib/fmt/issues/157>`_)::

    $ brew install cppformat

  Thanks to `@ortho <https://github.com/ortho>`_, Anatoliy Bulukin.

Documentation
~~~~~~~~~~~~~

* Migrated from ReadTheDocs to GitHub Pages for better responsiveness
  and reliability
  (`#128 <https://github.com/fmtlib/fmt/issues/128>`_).
  New documentation address is http://cppformat.github.io/.


* Added `Building the documentation
  <https://fmt.dev/2.0.0/usage.html#building-the-documentation>`_
  section to the documentation.

* Documentation build script is now compatible with Python 3 and newer pip versions.
  (`#189 <https://github.com/fmtlib/fmt/pull/189>`_,
  `#209 <https://github.com/fmtlib/fmt/issues/209>`_).
  Thanks to `@JodiTheTigger <https://github.com/JodiTheTigger>`_ and
  `@xentec <https://github.com/xentec>`_.
  
* Documentation fixes and improvements
  (`#36 <https://github.com/fmtlib/fmt/issues/36>`_,
  `#75 <https://github.com/fmtlib/fmt/issues/75>`_,
  `#125 <https://github.com/fmtlib/fmt/issues/125>`_,
  `#160 <https://github.com/fmtlib/fmt/pull/160>`_,
  `#161 <https://github.com/fmtlib/fmt/pull/161>`_,
  `#162 <https://github.com/fmtlib/fmt/issues/162>`_,
  `#165 <https://github.com/fmtlib/fmt/issues/165>`_,
  `#210 <https://github.com/fmtlib/fmt/issues/210>`_).
  Thanks to `@syohex (Syohei YOSHIDA) <https://github.com/syohex>`_ and
  bug reporters.

* Fixed out-of-tree documentation build
  (`#177 <https://github.com/fmtlib/fmt/issues/177>`_).
  Thanks to `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_.

Fixes
~~~~~

* Fixed ``initializer_list`` detection
  (`#136 <https://github.com/fmtlib/fmt/issues/136>`_).
  Thanks to `@Gachapen (Magnus Bjerke Vik) <https://github.com/Gachapen>`_.

* [Breaking] Fixed formatting of enums with numeric format specifiers in
  ``fmt::(s)printf`` 
  (`#131 <https://github.com/fmtlib/fmt/issues/131>`_,
  `#139 <https://github.com/fmtlib/fmt/issues/139>`_):

  .. code:: c++

    enum { ANSWER = 42 };
    fmt::printf("%d", ANSWER);

  Thanks to `@Naios <https://github.com/Naios>`_.

* Improved compatibility with old versions of MinGW
  (`#129 <https://github.com/fmtlib/fmt/issues/129>`_,
  `#130 <https://github.com/fmtlib/fmt/pull/130>`_,
  `#132 <https://github.com/fmtlib/fmt/issues/132>`_).
  Thanks to `@cstamford (Christopher Stamford) <https://github.com/cstamford>`_.

* Fixed a compile error on MSVC with disabled exceptions
  (`#144 <https://github.com/fmtlib/fmt/issues/144>`_).

* Added a workaround for broken implementation of variadic templates in MSVC2012
  (`#148 <https://github.com/fmtlib/fmt/issues/148>`_).

* Placed the anonymous namespace within ``fmt`` namespace for the header-only
  configuration
  (`#171 <https://github.com/fmtlib/fmt/issues/171>`_).
  Thanks to `@alfps (Alf P. Steinbach) <https://github.com/alfps>`_.

* Fixed issues reported by Coverity Scan
  (`#187 <https://github.com/fmtlib/fmt/issues/187>`_,
  `#192 <https://github.com/fmtlib/fmt/issues/192>`_).

* Implemented a workaround for a name lookup bug in MSVC2010
  (`#188 <https://github.com/fmtlib/fmt/issues/188>`_).

* Fixed compiler warnings
  (`#95 <https://github.com/fmtlib/fmt/issues/95>`_,
  `#96 <https://github.com/fmtlib/fmt/issues/96>`_,
  `#114 <https://github.com/fmtlib/fmt/pull/114>`_,
  `#135 <https://github.com/fmtlib/fmt/issues/135>`_,
  `#142 <https://github.com/fmtlib/fmt/issues/142>`_,
  `#145 <https://github.com/fmtlib/fmt/issues/145>`_,
  `#146 <https://github.com/fmtlib/fmt/issues/146>`_,
  `#158 <https://github.com/fmtlib/fmt/issues/158>`_,
  `#163 <https://github.com/fmtlib/fmt/issues/163>`_,
  `#175 <https://github.com/fmtlib/fmt/issues/175>`_,
  `#190 <https://github.com/fmtlib/fmt/issues/190>`_,
  `#191 <https://github.com/fmtlib/fmt/pull/191>`_,
  `#194 <https://github.com/fmtlib/fmt/issues/194>`_,
  `#196 <https://github.com/fmtlib/fmt/pull/196>`_,
  `#216 <https://github.com/fmtlib/fmt/issues/216>`_,
  `#218 <https://github.com/fmtlib/fmt/pull/218>`_,
  `#220 <https://github.com/fmtlib/fmt/pull/220>`_,
  `#229 <https://github.com/fmtlib/fmt/pull/229>`_,
  `#233 <https://github.com/fmtlib/fmt/issues/233>`_,
  `#234 <https://github.com/fmtlib/fmt/issues/234>`_,
  `#236 <https://github.com/fmtlib/fmt/pull/236>`_,
  `#281 <https://github.com/fmtlib/fmt/issues/281>`_,
  `#289 <https://github.com/fmtlib/fmt/issues/289>`_).
  Thanks to `@seanmiddleditch (Sean Middleditch) <https://github.com/seanmiddleditch>`_,
  `@dixlorenz (Dix Lorenz) <https://github.com/dixlorenz>`_,
  `@CarterLi (李通洲) <https://github.com/CarterLi>`_,
  `@Naios <https://github.com/Naios>`_,
  `@fmatthew5876 (Matthew Fioravante) <https://github.com/fmatthew5876>`_,
  `@LevskiWeng (Levski Weng) <https://github.com/LevskiWeng>`_,
  `@rpopescu <https://github.com/rpopescu>`_,
  `@gabime (Gabi Melman) <https://github.com/gabime>`_,
  `@cubicool (Jeremy Moles) <https://github.com/cubicool>`_,
  `@jkflying (Julian Kent) <https://github.com/jkflying>`_,
  `@LogicalKnight (Sean L) <https://github.com/LogicalKnight>`_,
  `@inguin (Ingo van Lil) <https://github.com/inguin>`_ and
  `@Jopie64 (Johan) <https://github.com/Jopie64>`_.

* Fixed portability issues (mostly causing test failures) on ARM, ppc64, ppc64le,
  s390x and SunOS 5.11 i386
  (`#138 <https://github.com/fmtlib/fmt/issues/138>`_,
  `#179 <https://github.com/fmtlib/fmt/issues/179>`_,
  `#180 <https://github.com/fmtlib/fmt/issues/180>`_,
  `#202 <https://github.com/fmtlib/fmt/issues/202>`_,
  `#225 <https://github.com/fmtlib/fmt/issues/225>`_,
  `Red Hat Bugzilla Bug 1260297 <https://bugzilla.redhat.com/show_bug.cgi?id=1260297>`_).
  Thanks to `@Naios <https://github.com/Naios>`_,
  `@jackyf (Eugene V. Lyubimkin) <https://github.com/jackyf>`_ and Dave Johansen.

* Fixed a name conflict with macro ``free`` defined in
  ``crtdbg.h`` when ``_CRTDBG_MAP_ALLOC`` is set
  (`#211 <https://github.com/fmtlib/fmt/issues/211>`_).

* Fixed shared library build on OS X
  (`#212 <https://github.com/fmtlib/fmt/pull/212>`_).
  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_.

* Fixed an overload conflict on MSVC when ``/Zc:wchar_t-`` option is specified
  (`#214 <https://github.com/fmtlib/fmt/pull/214>`_).
  Thanks to `@slavanap (Vyacheslav Napadovsky) <https://github.com/slavanap>`_.

* Improved compatibility with MSVC 2008
  (`#236 <https://github.com/fmtlib/fmt/pull/236>`_).
  Thanks to `@Jopie64 (Johan) <https://github.com/Jopie64>`_.

* Improved compatibility with bcc32
  (`#227 <https://github.com/fmtlib/fmt/issues/227>`_).

* Fixed ``static_assert`` detection on Clang
  (`#228 <https://github.com/fmtlib/fmt/pull/228>`_).
  Thanks to `@dean0x7d (Dean Moldovan) <https://github.com/dean0x7d>`_.

1.1.0 - 2015-03-06
------------------

* Added ``BasicArrayWriter``, a class template that provides operations for
  formatting and writing data into a fixed-size array
  (`#105 <https://github.com/fmtlib/fmt/issues/105>`_ and
  `#122 <https://github.com/fmtlib/fmt/issues/122>`_):

  .. code:: c++
  
    char buffer[100];
    fmt::ArrayWriter w(buffer);
    w.write("The answer is {}", 42);

* Added `0 A.D. <http://play0ad.com/>`_ and `PenUltima Online (POL)
  <http://www.polserver.com/>`_ to the list of notable projects using C++ Format.

* C++ Format now uses MSVC intrinsics for better formatting performance
  (`#115 <https://github.com/fmtlib/fmt/pull/115>`_,
  `#116 <https://github.com/fmtlib/fmt/pull/116>`_,
  `#118 <https://github.com/fmtlib/fmt/pull/118>`_ and
  `#121 <https://github.com/fmtlib/fmt/pull/121>`_).
  Previously these optimizations where only used on GCC and Clang.
  Thanks to `@CarterLi <https://github.com/CarterLi>`_ and
  `@objectx <https://github.com/objectx>`_.

* CMake install target (`#119 <https://github.com/fmtlib/fmt/pull/119>`_).
  Thanks to `@TrentHouliston <https://github.com/TrentHouliston>`_.

  You can now install C++ Format with ``make install`` command.

* Improved `Biicode <http://www.biicode.com/>`_ support
  (`#98 <https://github.com/fmtlib/fmt/pull/98>`_ and
  `#104 <https://github.com/fmtlib/fmt/pull/104>`_). Thanks to
  `@MariadeAnton <https://github.com/MariadeAnton>`_ and
  `@franramirez688 <https://github.com/franramirez688>`_.

* Improved support for building with `Android NDK
  <https://developer.android.com/tools/sdk/ndk/index.html>`_
  (`#107 <https://github.com/fmtlib/fmt/pull/107>`_).
  Thanks to `@newnon <https://github.com/newnon>`_.
  
  The `android-ndk-example <https://github.com/fmtlib/android-ndk-example>`_
  repository provides and example of using C++ Format with Android NDK:

  .. image:: https://raw.githubusercontent.com/fmtlib/android-ndk-example/
            master/screenshot.png

* Improved documentation of ``SystemError`` and ``WindowsError``
  (`#54 <https://github.com/fmtlib/fmt/issues/54>`_).

* Various code improvements
  (`#110 <https://github.com/fmtlib/fmt/pull/110>`_,
  `#111 <https://github.com/fmtlib/fmt/pull/111>`_
  `#112 <https://github.com/fmtlib/fmt/pull/112>`_).
  Thanks to `@CarterLi <https://github.com/CarterLi>`_.

* Improved compile-time errors when formatting wide into narrow strings
  (`#117 <https://github.com/fmtlib/fmt/issues/117>`_).

* Fixed ``BasicWriter::write`` without formatting arguments when C++11 support
  is disabled (`#109 <https://github.com/fmtlib/fmt/issues/109>`_).

* Fixed header-only build on OS X with GCC 4.9
  (`#124 <https://github.com/fmtlib/fmt/issues/124>`_).

* Fixed packaging issues (`#94 <https://github.com/fmtlib/fmt/issues/94>`_).

* Added `changelog <https://github.com/fmtlib/fmt/blob/master/ChangeLog.rst>`_
  (`#103 <https://github.com/fmtlib/fmt/issues/103>`_).

1.0.0 - 2015-02-05
------------------

* Add support for a header-only configuration when ``FMT_HEADER_ONLY`` is
  defined before including ``format.h``:

  .. code:: c++

    #define FMT_HEADER_ONLY
    #include "format.h"

* Compute string length in the constructor of ``BasicStringRef``
  instead of the ``size`` method
  (`#79 <https://github.com/fmtlib/fmt/issues/79>`_).
  This eliminates size computation for string literals on reasonable optimizing
  compilers.

* Fix formatting of types with overloaded ``operator <<`` for ``std::wostream``
  (`#86 <https://github.com/fmtlib/fmt/issues/86>`_):

  .. code:: c++

    fmt::format(L"The date is {0}", Date(2012, 12, 9));

* Fix linkage of tests on Arch Linux
  (`#89 <https://github.com/fmtlib/fmt/issues/89>`_).

* Allow precision specifier for non-float arguments
  (`#90 <https://github.com/fmtlib/fmt/issues/90>`_):

  .. code:: c++

    fmt::print("{:.3}\n", "Carpet"); // prints "Car"

* Fix build on Android NDK
  (`#93 <https://github.com/fmtlib/fmt/issues/93>`_)

* Improvements to documentation build procedure.

* Remove ``FMT_SHARED`` CMake variable in favor of standard `BUILD_SHARED_LIBS
  <http://www.cmake.org/cmake/help/v3.0/variable/BUILD_SHARED_LIBS.html>`_.

* Fix error handling in ``fmt::fprintf``.

* Fix a number of warnings.

0.12.0 - 2014-10-25
-------------------

* [Breaking] Improved separation between formatting and buffer management.
  ``Writer`` is now a base class that cannot be instantiated directly.
  The new ``MemoryWriter`` class implements the default buffer management
  with small allocations done on stack. So ``fmt::Writer`` should be replaced
  with ``fmt::MemoryWriter`` in variable declarations.

  Old code:

  .. code:: c++

    fmt::Writer w;

  New code: 

  .. code:: c++

    fmt::MemoryWriter w;

  If you pass ``fmt::Writer`` by reference, you can continue to do so:

  .. code:: c++

      void f(fmt::Writer &w);

  This doesn't affect the formatting API.

* Support for custom memory allocators
  (`#69 <https://github.com/fmtlib/fmt/issues/69>`_)

* Formatting functions now accept `signed char` and `unsigned char` strings as
  arguments (`#73 <https://github.com/fmtlib/fmt/issues/73>`_):

  .. code:: c++

    auto s = format("GLSL version: {}", glGetString(GL_VERSION));

* Reduced code bloat. According to the new `benchmark results
  <https://github.com/fmtlib/fmt#compile-time-and-code-bloat>`_,
  cppformat is close to ``printf`` and by the order of magnitude better than
  Boost Format in terms of compiled code size.

* Improved appearance of the documentation on mobile by using the `Sphinx
  Bootstrap theme <http://ryan-roemer.github.io/sphinx-bootstrap-theme/>`_:

  .. |old| image:: https://cloud.githubusercontent.com/assets/576385/4792130/
                   cd256436-5de3-11e4-9a62-c077d0c2b003.png

  .. |new| image:: https://cloud.githubusercontent.com/assets/576385/4792131/
                   cd29896c-5de3-11e4-8f59-cac952942bf0.png
  
  +-------+-------+
  |  Old  |  New  |
  +-------+-------+
  | |old| | |new| |
  +-------+-------+

0.11.0 - 2014-08-21
-------------------

* Safe printf implementation with a POSIX extension for positional arguments:

  .. code:: c++

    fmt::printf("Elapsed time: %.2f seconds", 1.23);
    fmt::printf("%1$s, %3$d %2$s", weekday, month, day);

* Arguments of ``char`` type can now be formatted as integers
  (Issue `#55 <https://github.com/fmtlib/fmt/issues/55>`_):

  .. code:: c++

    fmt::format("0x{0:02X}", 'a');

* Deprecated parts of the API removed.

* The library is now built and tested on MinGW with Appveyor in addition to
  existing test platforms Linux/GCC, OS X/Clang, Windows/MSVC.

0.10.0 - 2014-07-01
-------------------

**Improved API**

* All formatting methods are now implemented as variadic functions instead
  of using ``operator<<`` for feeding arbitrary arguments into a temporary
  formatter object. This works both with C++11 where variadic templates are
  used and with older standards where variadic functions are emulated by
  providing lightweight wrapper functions defined with the ``FMT_VARIADIC``
  macro. You can use this macro for defining your own portable variadic
  functions:

  .. code:: c++

    void report_error(const char *format, const fmt::ArgList &args) {
      fmt::print("Error: {}");
      fmt::print(format, args);
    }
    FMT_VARIADIC(void, report_error, const char *)

    report_error("file not found: {}", path);

  Apart from a more natural syntax, this also improves performance as there
  is no need to construct temporary formatter objects and control arguments'
  lifetimes. Because the wrapper functions are very lightweight, this doesn't
  cause code bloat even in pre-C++11 mode.

* Simplified common case of formatting an ``std::string``. Now it requires a
  single function call:

  .. code:: c++

    std::string s = format("The answer is {}.", 42);

  Previously it required 2 function calls:

  .. code:: c++

    std::string s = str(Format("The answer is {}.") << 42);

  Instead of unsafe ``c_str`` function, ``fmt::Writer`` should be used directly
  to bypass creation of ``std::string``:

  .. code:: c++

    fmt::Writer w;
    w.write("The answer is {}.", 42);
    w.c_str();  // returns a C string

  This doesn't do dynamic memory allocation for small strings and is less error
  prone as the lifetime of the string is the same as for ``std::string::c_str``
  which is well understood (hopefully).

* Improved consistency in naming functions that are a part of the public API.
  Now all public functions are lowercase following the standard library
  conventions. Previously it was a combination of lowercase and
  CapitalizedWords.
  Issue `#50 <https://github.com/fmtlib/fmt/issues/50>`_.

* Old functions are marked as deprecated and will be removed in the next
  release.

**Other Changes**

* Experimental support for printf format specifications (work in progress):

  .. code:: c++

    fmt::printf("The answer is %d.", 42);
    std::string s = fmt::sprintf("Look, a %s!", "string");

* Support for hexadecimal floating point format specifiers ``a`` and ``A``:

  .. code:: c++

    print("{:a}", -42.0); // Prints -0x1.5p+5
    print("{:A}", -42.0); // Prints -0X1.5P+5

* CMake option ``FMT_SHARED`` that specifies whether to build format as a
  shared library (off by default).

0.9.0 - 2014-05-13
------------------

* More efficient implementation of variadic formatting functions.

* ``Writer::Format`` now has a variadic overload:

  .. code:: c++

    Writer out;
    out.Format("Look, I'm {}!", "variadic");

* For efficiency and consistency with other overloads, variadic overload of
  the ``Format`` function now returns ``Writer`` instead of ``std::string``.
  Use the ``str`` function to convert it to ``std::string``:

  .. code:: c++

    std::string s = str(Format("Look, I'm {}!", "variadic"));

* Replaced formatter actions with output sinks: ``NoAction`` -> ``NullSink``,
  ``Write`` -> ``FileSink``, ``ColorWriter`` -> ``ANSITerminalSink``.
  This improves naming consistency and shouldn't affect client code unless
  these classes are used directly which should be rarely needed.

* Added ``ThrowSystemError`` function that formats a message and throws
  ``SystemError`` containing the formatted message and system-specific error
  description. For example, the following code

  .. code:: c++

    FILE *f = fopen(filename, "r");
    if (!f)
      ThrowSystemError(errno, "Failed to open file '{}'") << filename;

  will throw ``SystemError`` exception with description
  "Failed to open file '<filename>': No such file or directory" if file
  doesn't exist.

* Support for AppVeyor continuous integration platform.

* ``Format`` now throws ``SystemError`` in case of I/O errors.

* Improve test infrastructure. Print functions are now tested by redirecting
  the output to a pipe.

0.8.0 - 2014-04-14
------------------

* Initial release


================================================
FILE: examples/libraries/fmt/LICENSE.rst
================================================
Copyright (c) 2012 - present, Victor Zverovich

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.

--- Optional exception to the license ---

As an exception, if, as a result of your compiling your source code, portions
of this Software are embedded into a machine-executable object form of such
source code, you may redistribute such embedded portions in such object form
without including the above copyright and permission notices.


================================================
FILE: examples/libraries/fmt/README.rst
================================================
{fmt}
=====

.. image:: https://github.com/fmtlib/fmt/workflows/linux/badge.svg
   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Alinux

.. image:: https://github.com/fmtlib/fmt/workflows/macos/badge.svg
   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Amacos

.. image:: https://github.com/fmtlib/fmt/workflows/windows/badge.svg
   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows

.. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v
   :target: https://ci.appveyor.com/project/vitaut/fmt

.. image:: https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg
   :alt: fmt is continuously fuzzed at oss-fuzz
   :target: https://bugs.chromium.org/p/oss-fuzz/issues/list?\
            colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\
            Summary&q=proj%3Dfmt&can=1

.. image:: https://img.shields.io/badge/stackoverflow-fmt-blue.svg
   :alt: Ask questions at StackOverflow with the tag fmt
   :target: https://stackoverflow.com/questions/tagged/fmt

**{fmt}** is an open-source formatting library providing a fast and safe
alternative to C stdio and C++ iostreams.

If you like this project, please consider donating to the BYSOL
Foundation that helps victims of political repressions in Belarus:
https://bysol.org/en/bs/general/.

`Documentation <https://fmt.dev>`__

Q&A: ask questions on `StackOverflow with the tag fmt
<https://stackoverflow.com/questions/tagged/fmt>`_.

Try {fmt} in `Compiler Explorer <https://godbolt.org/z/Eq5763>`_.

Features
--------

* Simple `format API <https://fmt.dev/latest/api.html>`_ with positional arguments
  for localization
* Implementation of `C++20 std::format
  <https://en.cppreference.com/w/cpp/utility/format>`__
* `Format string syntax <https://fmt.dev/latest/syntax.html>`_ similar to Python's
  `format <https://docs.python.org/3/library/stdtypes.html#str.format>`_
* Fast IEEE 754 floating-point formatter with correct rounding, shortness and
  round-trip guarantees
* Safe `printf implementation
  <https://fmt.dev/latest/api.html#printf-formatting>`_ including the POSIX
  extension for positional arguments
* Extensibility: `support for user-defined types
  <https://fmt.dev/latest/api.html#formatting-user-defined-types>`_
* High performance: faster than common standard library implementations of
  ``(s)printf``, iostreams, ``to_string`` and ``to_chars``, see `Speed tests`_
  and `Converting a hundred million integers to strings per second
  <http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_
* Small code size both in terms of source code with the minimum configuration
  consisting of just three files, ``core.h``, ``format.h`` and ``format-inl.h``,
  and compiled code; see `Compile time and code bloat`_
* Reliability: the library has an extensive set of `tests
  <https://github.com/fmtlib/fmt/tree/master/test>`_ and is `continuously fuzzed
  <https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20
  Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1>`_
* Safety: the library is fully type safe, errors in format strings can be
  reported at compile time, automatic memory management prevents buffer overflow
  errors
* Ease of use: small self-contained code base, no external dependencies,
  permissive MIT `license
  <https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_
* `Portability <https://fmt.dev/latest/index.html#portability>`_ with
  consistent output across platforms and support for older compilers
* Clean warning-free codebase even on high warning levels such as
  ``-Wall -Wextra -pedantic``
* Locale-independence by default
* Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro

See the `documentation <https://fmt.dev>`_ for more details.

Examples
--------

**Print to stdout** (`run <https://godbolt.org/z/Tevcjh>`_)

.. code:: c++

    #include <fmt/core.h>
    
    int main() {
      fmt::print("Hello, world!\n");
    }

**Format a string** (`run <https://godbolt.org/z/oK8h33>`_)

.. code:: c++

    std::string s = fmt::format("The answer is {}.", 42);
    // s == "The answer is 42."

**Format a string using positional arguments** (`run <https://godbolt.org/z/Yn7Txe>`_)

.. code:: c++

    std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy");
    // s == "I'd rather be happy than right."

**Print chrono durations** (`run <https://godbolt.org/z/K8s4Mc>`_)

.. code:: c++

    #include <fmt/chrono.h>

    int main() {
      using namespace std::literals::chrono_literals;
      fmt::print("Default format: {} {}\n", 42s, 100ms);
      fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
    }

Output::

    Default format: 42s 100ms
    strftime-like format: 03:15:30

**Print a container** (`run <https://godbolt.org/z/MjsY7c>`_)

.. code:: c++

    #include <vector>
    #include <fmt/ranges.h>

    int main() {
      std::vector<int> v = {1, 2, 3};
      fmt::print("{}\n", v);
    }

Output::

    [1, 2, 3]

**Check a format string at compile time**

.. code:: c++

    std::string s = fmt::format("{:d}", "I am not a number");

This gives a compile-time error in C++20 because ``d`` is an invalid format
specifier for a string.

**Write a file from a single thread**

.. code:: c++

    #include <fmt/os.h>

    int main() {
      auto out = fmt::output_file("guide.txt");
      out.print("Don't {}", "Panic");
    }

This can be `5 to 9 times faster than fprintf
<http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html>`_.

**Print with colors and text styles**

.. code:: c++

    #include <fmt/color.h>

    int main() {
      fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold,
                 "Hello, {}!\n", "world");
      fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
                 fmt::emphasis::underline, "Hello, {}!\n", "мир");
      fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
                 "Hello, {}!\n", "世界");
    }

Output on a modern terminal:

.. image:: https://user-images.githubusercontent.com/
           576385/88485597-d312f600-cf2b-11ea-9cbe-61f535a86e28.png

Benchmarks
----------

Speed tests
~~~~~~~~~~~

================= ============= ===========
Library           Method        Run Time, s
================= ============= ===========
libc              printf          1.04
libc++            std::ostream    3.05
{fmt} 6.1.1       fmt::print      0.75
Boost Format 1.67 boost::format   7.24
Folly Format      folly::format   2.23
================= ============= ===========

{fmt} is the fastest of the benchmarked methods, ~35% faster than ``printf``.

The above results were generated by building ``tinyformat_test.cpp`` on macOS
10.14.6 with ``clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT``, and taking the
best of three runs. In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"``
or equivalent is filled 2,000,000 times with output sent to ``/dev/null``; for
further details refer to the `source
<https://github.com/fmtlib/format-benchmark/blob/master/tinyformat_test.cpp>`_.

{fmt} is up to 20-30x faster than ``std::ostringstream`` and ``sprintf`` on
floating-point formatting (`dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_)
and faster than `double-conversion <https://github.com/google/double-conversion>`_ and
`ryu <https://github.com/ulfjack/ryu>`_:

.. image:: https://user-images.githubusercontent.com/576385/
           95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png
   :target: https://fmt.dev/unknown_mac64_clang12.0.html

Compile time and code bloat
~~~~~~~~~~~~~~~~~~~~~~~~~~~

The script `bloat-test.py
<https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py>`_
from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_
tests compile time and code bloat for nontrivial projects.
It generates 100 translation units and uses ``printf()`` or its alternative
five times in each to simulate a medium sized project.  The resulting
executable size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42),
macOS Sierra, best of three) is shown in the following tables.

**Optimized build (-O3)**

============= =============== ==================== ==================
Method        Compile Time, s Executable size, KiB Stripped size, KiB
============= =============== ==================== ==================
printf                    2.6                   29                 26
printf+string            16.4                   29                 26
iostreams                31.1                   59                 55
{fmt}                    19.0                   37                 34
Boost Format             91.9                  226                203
Folly Format            115.7                  101                 88
============= =============== ==================== ==================

As you can see, {fmt} has 60% less overhead in terms of resulting binary code
size compared to iostreams and comes pretty close to ``printf``. Boost Format
and Folly Format have the largest overheads.

``printf+string`` is the same as ``printf`` but with extra ``<string>``
include to measure the overhead of the latter.

**Non-optimized build**

============= =============== ==================== ==================
Method        Compile Time, s Executable size, KiB Stripped size, KiB
============= =============== ==================== ==================
printf                    2.2                   33                 30
printf+string            16.0                   33                 30
iostreams                28.3                   56                 52
{fmt}                    18.2                   59                 50
Boost Format             54.1                  365                303
Folly Format             79.9                  445                430
============= =============== ==================== ==================

``libc``, ``lib(std)c++`` and ``libfmt`` are all linked as shared libraries to
compare formatting function overhead only. Boost Format is a
header-only library so it doesn't provide any linkage options.

Running the tests
~~~~~~~~~~~~~~~~~

Please refer to `Building the library`__ for the instructions on how to build
the library and run the unit tests.

__ https://fmt.dev/latest/usage.html#building-the-library

Benchmarks reside in a separate repository,
`format-benchmarks <https://github.com/fmtlib/format-benchmark>`_,
so to run the benchmarks you first need to clone this repository and
generate Makefiles with CMake::

    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
    $ cd format-benchmark
    $ cmake .

Then you can run the speed test::

    $ make speed-test

or the bloat test::

    $ make bloat-test
    
Migrating code
--------------

`clang-tidy-fmt <https://github.com/mikecrowe/clang-tidy-fmt>`_ provides clang
tidy checks for converting occurrences of ``printf`` and ``fprintf`` to
``fmt::print``.

Projects using this library
---------------------------

* `0 A.D. <https://play0ad.com/>`_: a free, open-source, cross-platform
  real-time strategy game

* `2GIS <https://2gis.ru/>`_: free business listings with a city map

* `AMPL/MP <https://github.com/ampl/mp>`_:
  an open-source library for mathematical programming

* `Aseprite <https://github.com/aseprite/aseprite>`_:
  animated sprite editor & pixel art tool 

* `AvioBook <https://www.aviobook.aero/en>`_: a comprehensive aircraft
  operations suite
  
* `Blizzard Battle.net <https://battle.net/>`_: an online gaming platform
  
* `Celestia <https://celestia.space/>`_: real-time 3D visualization of space

* `Ceph <https://ceph.com/>`_: a scalable distributed storage system

* `ccache <https://ccache.dev/>`_: a compiler cache

* `ClickHouse <https://github.com/ClickHouse/ClickHouse>`_: analytical database
  management system

* `CUAUV <https://cuauv.org/>`_: Cornell University's autonomous underwater
  vehicle

* `Drake <https://drake.mit.edu/>`_: a planning, control, and analysis toolbox
  for nonlinear dynamical systems (MIT)

* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus
  (Lyft)

* `FiveM <https://fivem.net/>`_: a modification framework for GTA V

* `fmtlog <https://github.com/MengRao/fmtlog>`_: a performant fmtlib-style
  logging library with latency in nanoseconds

* `Folly <https://github.com/facebook/folly>`_: Facebook open-source library

* `Grand Mountain Adventure
  <https://store.steampowered.com/app/1247360/Grand_Mountain_Adventure/>`_:
  A beautiful open-world ski & snowboarding game

* `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_:
  Player vs Player Gaming Network with tweaks

* `KBEngine <https://github.com/kbengine/kbengine>`_: an open-source MMOG server
  engine

* `Keypirinha <https://keypirinha.com/>`_: a semantic launcher for Windows

* `Kodi <https://kodi.tv/>`_ (formerly xbmc): home theater software

* `Knuth <https://kth.cash/>`_: high-performance Bitcoin full-node

* `Microsoft Verona <https://github.com/microsoft/verona>`_:
  research programming language for concurrent ownership

* `MongoDB <https://mongodb.com/>`_: distributed document database

* `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: a small tool to
  generate randomized datasets

* `OpenSpace <https://openspaceproject.com/>`_: an open-source
  astrovisualization framework

* `PenUltima Online (POL) <https://www.polserver.com/>`_:
  an MMO server, compatible with most Ultima Online clients

* `PyTorch <https://github.com/pytorch/pytorch>`_: an open-source machine
  learning library

* `quasardb <https://www.quasardb.net/>`_: a distributed, high-performance,
  associative database
  
* `Quill <https://github.com/odygrd/quill>`_: asynchronous low-latency logging library

* `QKW <https://github.com/ravijanjam/qkw>`_: generalizing aliasing to simplify
  navigation, and executing complex multi-line terminal command sequences

* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: a Redis cluster
  proxy

* `redpanda <https://vectorized.io/redpanda>`_: a 10x faster Kafka® replacement
  for mission critical systems written in C++

* `rpclib <http://rpclib.net/>`_: a modern C++ msgpack-RPC server and client
  library

* `Salesforce Analytics Cloud
  <https://www.salesforce.com/analytics-cloud/overview/>`_:
  business intelligence software

* `Scylla <https://www.scylladb.com/>`_: a Cassandra-compatible NoSQL data store
  that can handle 1 million transactions per second on a single server

* `Seastar <http://www.seastar-project.org/>`_: an advanced, open-source C++
  framework for high-performance server applications on modern hardware

* `spdlog <https://github.com/gabime/spdlog>`_: super fast C++ logging library

* `Stellar <https://www.stellar.org/>`_: financial platform

* `Touch Surgery <https://www.touchsurgery.com/>`_: surgery simulator

* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: open-source
  MMORPG framework

* `Windows Terminal <https://github.com/microsoft/terminal>`_: the new Windows
  terminal

`More... <https://github.com/search?q=fmtlib&type=Code>`_

If you are aware of other projects using this library, please let me know
by `email <mailto:victor.zverovich@gmail.com>`_ or by submitting an
`issue <https://github.com/fmtlib/fmt/issues>`_.

Motivation
----------

So why yet another formatting library?

There are plenty of methods for doing this task, from standard ones like
the printf family of function and iostreams to Boost Format and FastFormat
libraries. The reason for creating a new library is that every existing
solution that I found either had serious issues or didn't provide
all the features I needed.

printf
~~~~~~

The good thing about ``printf`` is that it is pretty fast and readily available
being a part of the C standard library. The main drawback is that it
doesn't support user-defined types. ``printf`` also has safety issues although
they are somewhat mitigated with `__attribute__ ((format (printf, ...))
<https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ in GCC.
There is a POSIX extension that adds positional arguments required for
`i18n <https://en.wikipedia.org/wiki/Internationalization_and_localization>`_
to ``printf`` but it is not a part of C99 and may not be available on some
platforms.

iostreams
~~~~~~~~~

The main issue with iostreams is best illustrated with an example:

.. code:: c++

    std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n";

which is a lot of typing compared to printf:

.. code:: c++

    printf("%.2f\n", 1.23456);

Matthew Wilson, the author of FastFormat, called this "chevron hell". iostreams
don't support positional arguments by design.

The good part is that iostreams support user-defined types and are safe although
error handling is awkward.

Boost Format
~~~~~~~~~~~~

This is a very powerful library which supports both ``printf``-like format
strings and positional arguments. Its main drawback is performance. According to
various, benchmarks it is much slower than other methods considered here. Boost
Format also has excessive build times and severe code bloat issues (see
`Benchmarks`_).

FastFormat
~~~~~~~~~~

This is an interesting library which is fast, safe and has positional arguments.
However, it has significant limitations, citing its author:

    Three features that have no hope of being accommodated within the
    current design are:

    * Leading zeros (or any other non-space padding)
    * Octal/hexadecimal encoding
    * Runtime width/alignment specification

It is also quite big and has a heavy dependency, STLSoft, which might be too
restrictive for using it in some projects.

Boost Spirit.Karma
~~~~~~~~~~~~~~~~~~

This is not really a formatting library but I decided to include it here for
completeness. As iostreams, it suffers from the problem of mixing verbatim text
with arguments. The library is pretty fast, but slower on integer formatting
than ``fmt::format_to`` with format string compilation on Karma's own benchmark,
see `Converting a hundred million integers to strings per second
<http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_.

License
-------

{fmt} is distributed under the MIT `license
<https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_.

Documentation License
---------------------

The `Format String Syntax <https://fmt.dev/latest/syntax.html>`_
section in the documentation is based on the one from Python `string module
documentation <https://docs.python.org/3/library/string.html#module-string>`_.
For this reason the documentation is distributed under the Python Software
Foundation license available in `doc/python-license.txt
<https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_.
It only applies if you distribute the documentation of {fmt}.

Maintainers
-----------

The {fmt} library is maintained by Victor Zverovich (`vitaut
<https://github.com/vitaut>`_) and Jonathan Müller (`foonathan
<https://github.com/foonathan>`_) with contributions from many other people.
See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and
`Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names.
Let us know if your contribution is not listed or mentioned incorrectly and
we'll make it right.


================================================
FILE: examples/libraries/fmt/doc/CMakeLists.txt
================================================
find_program(DOXYGEN doxygen)
if (NOT DOXYGEN)
  message(STATUS "Target 'doc' disabled (requires doxygen)")
  return ()
endif ()

find_package(PythonInterp QUIET REQUIRED)

add_custom_target(doc
  COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/build.py
                               ${FMT_VERSION}
  SOURCES api.rst syntax.rst usage.rst build.py conf.py _templates/layout.html)

include(GNUInstallDirs)
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/fmt OPTIONAL
        PATTERN ".doctrees" EXCLUDE)


================================================
FILE: examples/libraries/fmt/doc/_static/breathe.css
================================================

/* -- breathe specific styles ----------------------------------------------- */

/* So enum value descriptions are displayed inline to the item */
.breatheenumvalues li tt + p {
  display: inline;
}

/* So parameter descriptions are displayed inline to the item */
.breatheparameterlist li tt + p {
  display: inline;
}

.container .breathe-sectiondef {
  width: inherit;
}

.github-btn {
  border: 0;
  overflow: hidden;
}

.jumbotron {
  background-size: 100% 4px;
  background-repeat: repeat-y;
  color: white;
  text-align: center;
}


================================================
FILE: examples/libraries/fmt/doc/_templates/layout.html
================================================
{% extends "!layout.html" %}

{% block extrahead %}
<meta name="description" content="Small, safe and fast formatting library">
<meta name="keywords" content="C++, formatting, printf, string, library">
<meta name="author" content="Victor Zverovich">
<link rel="stylesheet" href="_static/fmt.css">
{# Google Analytics #}
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-20116650-4"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'UA-20116650-4');
</script>
{% endblock %}

{%- macro searchform(classes, button) %}
<form class="{{classes}}" role="search" action="{{ pathto('search') }}"
      method="get">
  <div class="form-group">
    <input type="text" name="q" class="form-control"
           {{ 'placeholder="Search"' if not button }} >
  </div>
  <input type="hidden" name="check_keywords" value="yes" />
  <input type="hidden" name="area" value="default" />
  {% if button %}
    <input type="submit" class="btn btn-default" value="search">
  {% endif %}
</form>
{%- endmacro %}

{% block header %}
<nav class="navbar navbar-inverse">
  <div class="tb-container">
    <div class="row">
      <div class="navbar-content">
        {# Brand and toggle get grouped for better mobile display #}
        <div class="navbar-header">
          <button type="button" class="navbar-toggle collapsed"
                  data-toggle="collapse" data-target=".navbar-collapse">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="index.html">{fmt}</a>
        </div>

        {# Collect the nav links, forms, and other content for toggling #}
        <div class="collapse navbar-collapse">
          <ul class="nav navbar-nav">
            <li class="dropdown">
              <a href="#" class="dropdown-toggle" data-toggle="dropdown"
                 role="button" aria-expanded="false">{{ version }}
                <span class="caret"></span></a>
              <ul class="dropdown-menu" role="menu">
                {% for v in versions.split(',') %}
                <li><a href="https://fmt.dev/{{v}}">{{v}}</a></li>
                {% endfor %}
              </ul>
            </li>
            {% for name in ['Contents', 'Usage', 'API', 'Syntax'] %}
              {% if pagename == name.lower() %}
              <li class="active"><a href="{{name.lower()}}.html">{{name}}
                <span class="sr-only">(current)</span></a></li>
              {%else%}
              <li><a href="{{name.lower()}}.html">{{name}}</a></li>
              {%endif%}
            {% endfor %}
          </ul>
          {% if pagename != 'search' %}
            {{ searchform('navbar-form navbar-right', False) }}
          {%endif%}
        </div> {# /.navbar-collapse #}
      </div> {# /.col-md-offset-2 #}
    </div> {# /.row #}
  </div> {# /.tb-container #}
</nav>
{% if pagename == "index" %}
{% set download_url = 'https://github.com/fmtlib/fmt/releases/download' %}
<div class="jumbotron">
  <div class="tb-container">
    <h1>{fmt}</h1>
    <p class="lead">A modern formatting library</p>
    <div class="btn-group" role="group">
      {% set name = 'fmt' if version.split('.')[0]|int >= 3 else 'cppformat' %}
      <a class="btn btn-success"
         href="{{download_url}}/{{version}}/{{name}}-{{version}}.zip">
           <span class="glyphicon glyphicon-download"></span> Download
      </a>
      <button type="button" class="btn btn-success dropdown-toggle"
        data-toggle="dropdown"><span class="caret"></span></button>
      <ul class="dropdown-menu">
      {% for v in versions.split(',') %}
      {% set name = 'fmt' if v.split('.')[0]|int >= 3 else 'cppformat' %}
        <li><a href="{{download_url}}/{{v}}/{{name}}-{{v}}.zip">Version {{v}}
          </a></li>
      {% endfor %}
      </ul>
    </div>
  </div>
</div>
{% endif %}
{% endblock %}

{# Disable relbars. #}
{% block relbar1 %}
{% endblock %}
{% block relbar2 %}
{% endblock %}

{% block content %}
<div class="tb-container">
  <div class="row">
    {# Sidebar is currently disabled.
    <div class="bs-sidebar">
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
          {%- block sidebarlogo %}
          {%- if logo %}
            <p class="logo"><a href="{{ pathto(master_doc) }}">
              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}"
                   alt="Logo"/>
            </a></p>
          {%- endif %}
          {%- endblock %}
          {%- for sidebartemplate in sidebars %}
          {%- include sidebartemplate %}
          {%- endfor %}
        </div>
      </div>
    </div>
    #}

    <div class="content">
      {% block body %} {% endblock %}
    </div>
  </div>
</div>
{% endblock %}

{% block footer %}
{{ super() }}
{# Placed at the end of the document so the pages load faster. #}
<script src="_static/bootstrap.min.js"></script>
{% endblock %}


================================================
FILE: examples/libraries/fmt/doc/_templates/search.html
================================================
{#
    basic/search.html
    ~~~~~~~~~~~~~~~~~

    Template for the search page.

    :copyright: Copyright 2007-2015 by the Sphinx team, see AUTHORS.
    :license: BSD, see LICENSE for details.
#}
{%- extends "layout.html" %}
{% set title = _('Search') %}
{% set script_files = script_files + ['_static/searchtools.js'] %}
{% block extrahead %}
  <script type="text/javascript">
    jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
  </script>
  {# this is used when loading the search index using $.ajax fails,
     such as on Chrome for documents on localhost #}
  <script type="text/javascript" id="searchindexloader"></script>
  {{ super() }}
{% endblock %}
{% block body %}
  <h1 id="search-documentation">{{ _('Search') }}</h1>
  <div id="fallback" class="admonition warning">
  <script type="text/javascript">$('#fallback').hide();</script>
  <p>
    {% trans %}Please activate JavaScript to enable the search
    functionality.{% endtrans %}
  </p>
  </div>
  <p>
    {% trans %}From here you can search these documents. Enter your search
    words into the box below and click "search". Note that the search
    function will automatically search for all of the words. Pages
    containing fewer words won't appear in the result list.{% endtrans %}
  </p>
  {{ searchform('form-inline', True) }}
  {% if search_performed %}
    <h2>{{ _('Search Results') }}</h2>
    {% if not search_results %}
      <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
    {% endif %}
  {% endif %}
  <div id="search-results">
  {% if search_results %}
    <ul>
    {% for href, caption, context in search_results %}
      <li><a href="{{ pathto(item.href) }}">{{ caption }}</a>
        <div class="context">{{ context|e }}</div>
      </li>
    {% endfor %}
    </ul>
  {% endif %}
  </div>
{% endblock %}


================================================
FILE: examples/libraries/fmt/doc/api.rst
================================================
.. _string-formatting-api:

*************
API Reference
*************

The {fmt} library API consists of the following parts:

* :ref:`fmt/core.h <core-api>`: the core API providing main formatting functions
  for ``char``/UTF-8 with compile-time checks and minimal dependencies
* :ref:`fmt/format.h <format-api>`: the full format API providing additional
  formatting functions and locale support
* :ref:`fmt/ranges.h <ranges-api>`: formatting of ranges and tuples
* :ref:`fmt/chrono.h <chrono-api>`: date and time formatting
* :ref:`fmt/compile.h <compile-api>`: format string compilation
* :ref:`fmt/color.h <color-api>`: terminal color and text style
* :ref:`fmt/os.h <os-api>`: system APIs
* :ref:`fmt/ostream.h <ostream-api>`: ``std::ostream`` support
* :ref:`fmt/printf.h <printf-api>`: ``printf`` formatting
* :ref:`fmt/xchar.h <xchar-api>`: optional ``wchar_t`` support 

All functions and types provided by the library reside in namespace ``fmt`` and
macros have prefix ``FMT_``.

.. _core-api:

Core API
========

``fmt/core.h`` defines the core API which provides main formatting functions for
``char``/UTF-8 with compile-time checks. It has minimal include dependencies for
better compile times. This header is only beneficial when using {fmt} as a
library and not in the header-only mode.

The following functions use :ref:`format string syntax <syntax>`
similar to that of Python's `str.format
<https://docs.python.org/3/library/stdtypes.html#str.format>`_.
They take *fmt* and *args* as arguments.

*fmt* is a format string that contains literal text and replacement
fields surrounded by braces ``{}``. The fields are replaced with formatted
arguments in the resulting string. A function taking *fmt* doesn't
participate in an overload resolution if the latter is not a string.

*args* is an argument list representing objects to be formatted.

.. _format:

.. doxygenfunction:: format(format_string<T...> fmt, T&&... args) -> std::string
.. doxygenfunction:: vformat(string_view fmt, format_args args) -> std::string

.. doxygenfunction:: format_to(OutputIt out, format_string<T...> fmt, T&&... args) -> OutputIt
.. doxygenfunction:: format_to_n(OutputIt out, size_t n, format_string<T...> fmt, const T&... args) -> format_to_n_result<OutputIt>
.. doxygenfunction:: formatted_size(format_string<T...> fmt, T&&... args) -> size_t

.. doxygenstruct:: fmt::format_to_n_result
   :members:

.. _print:

.. doxygenfunction:: fmt::print(format_string<T...> fmt, T&&... args)
.. doxygenfunction:: vprint(string_view fmt, format_args args)

.. doxygenfunction:: print(std::FILE *f, format_string<T...> fmt, T&&... args)
.. doxygenfunction:: vprint(std::FILE *f, string_view fmt, format_args args)

Compile-time Format String Checks
---------------------------------

Compile-time checks are enabled when using ``FMT_STRING``. They support built-in
and string types as well as user-defined types with ``constexpr`` ``parse``
functions in their ``formatter`` specializations.

.. doxygendefine:: FMT_STRING

To force the use of compile-time checks, define the preprocessor variable
``FMT_ENFORCE_COMPILE_STRING``. When set, functions accepting ``FMT_STRING``
will fail to compile with regular strings. Runtime-checked
formatting is still possible using ``fmt::vformat``, ``fmt::vprint``, etc.

Named Arguments
---------------

.. doxygenfunction:: fmt::arg(const S&, const T&)

Named arguments are not supported in compile-time checks at the moment.

Argument Lists
--------------

You can create your own formatting function with compile-time checks and small
binary footprint, for example (https://godbolt.org/z/oba4Mc):

.. code:: c++

    #include <fmt/format.h>

    void vlog(const char* file, int line, fmt::string_view format,
              fmt::format_args args) {
      fmt::print("{}: {}: ", file, line);
      fmt::vprint(format, args);
    }

    template <typename S, typename... Args>
    void log(const char* file, int line, const S& format, Args&&... args) {
      vlog(file, line, format,
          fmt::make_args_checked<Args...>(format, args...));
    }

    #define MY_LOG(format, ...) \
      log(__FILE__, __LINE__, FMT_STRING(format), __VA_ARGS__)

    MY_LOG("invalid squishiness: {}", 42);

Note that ``vlog`` is not parameterized on argument types which improves compile
times and reduces binary code size compared to a fully parameterized version.

.. doxygenfunction:: fmt::make_args_checked(const S&, const remove_reference_t<Args>&...)

.. doxygenfunction:: fmt::make_format_args(const Args&...)

.. doxygenclass:: fmt::format_arg_store
   :members:

.. doxygenclass:: fmt::dynamic_format_arg_store
   :members:

.. doxygenclass:: fmt::basic_format_args
   :members:

.. doxygentypedef:: fmt::format_args

.. doxygenclass:: fmt::basic_format_arg
   :members:

.. doxygenclass:: fmt::basic_format_context
   :members:

.. doxygentypedef:: fmt::format_context

Compatibility
-------------

.. doxygenclass:: fmt::basic_string_view
   :members:

.. doxygentypedef:: fmt::string_view

Locale
------

All formatting is locale-independent by default. Use the ``'L'`` format
specifier to insert the appropriate number separator characters from the
locale::

  #include <fmt/core.h>
  #include <locale>

  std::locale::global(std::locale("en_US.UTF-8"));
  auto s = fmt::format("{:L}", 1000000);  // s == "1,000,000"

.. _format-api:

Format API
==========

``fmt/format.h`` defines the full format API providing additional formatting
functions and locale support.

.. _udt:

Formatting User-defined Types
-----------------------------

To make a user-defined type formattable, specialize the ``formatter<T>`` struct
template and implement ``parse`` and ``format`` methods::

  #include <fmt/format.h>

  struct point { double x, y; };

  template <> struct fmt::formatter<point> {
    // Presentation format: 'f' - fixed, 'e' - exponential.
    char presentation = 'f';

    // Parses format specifications of the form ['f' | 'e'].
    constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
      // [ctx.begin(), ctx.end()) is a character range that contains a part of
      // the format string starting from the format specifications to be parsed,
      // e.g. in
      //
      //   fmt::format("{:f} - point of interest", point{1, 2});
      //
      // the range will contain "f} - point of interest". The formatter should
      // parse specifiers until '}' or the end of the range. In this example
      // the formatter should parse the 'f' specifier and return an iterator
      // pointing to '}'.

      // Parse the presentation format and store it in the formatter:
      auto it = ctx.begin(), end = ctx.end();
      if (it != end && (*it == 'f' || *it == 'e')) presentation = *it++;

      // Check if reached the end of the range:
      if (it != end && *it != '}')
        throw format_error("invalid format");

      // Return an iterator past the end of the parsed range:
      return it;
    }

    // Formats the point p using the parsed format specification (presentation)
    // stored in this formatter.
    template <typename FormatContext>
    auto format(const point& p, FormatContext& ctx) -> decltype(ctx.out()) {
      // ctx.out() is an output iterator to write to.
      return format_to(
          ctx.out(),
          presentation == 'f' ? "({:.1f}, {:.1f})" : "({:.1e}, {:.1e})",
          p.x, p.y);
    }
  };

Then you can pass objects of type ``point`` to any formatting function::

  point p = {1, 2};
  std::string s = fmt::format("{:f}", p);
  // s == "(1.0, 2.0)"

You can also reuse existing formatters via inheritance or composition, for
example::

  enum class color {red, green, blue};

  template <> struct fmt::formatter<color>: formatter<string_view> {
    // parse is inherited from formatter<string_view>.
    template <typename FormatContext>
    auto format(color c, FormatContext& ctx) {
      string_view name = "unknown";
      switch (c) {
      case color::red:   name = "red"; break;
      case color::green: name = "green"; break;
      case color::blue:  name = "blue"; break;
      }
      return formatter<string_view>::format(name, ctx);
    }
  };

Since ``parse`` is inherited from ``formatter<string_view>`` it will recognize
all string format specifications, for example

.. code-block:: c++

   fmt::format("{:>10}", color::blue)

will return ``"      blue"``.

You can also write a formatter for a hierarchy of classes::

  #include <type_traits>
  #include <fmt/format.h>

  struct A {
    virtual ~A() {}
    virtual std::string name() const { return "A"; }
  };

  struct B : A {
    virtual std::string name() const { return "B"; }
  };

  template <typename T>
  struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> :
      fmt::formatter<std::string> {
    template <typename FormatCtx>
    auto format(const A& a, FormatCtx& ctx) {
      return fmt::formatter<std::string>::format(a.name(), ctx);
    }
  };

  int main() {
    B b;
    A& a = b;
    fmt::print("{}", a); // prints "B"
  }

If a type provides both a ``formatter`` specialization and an implicit
conversion to a formattable type, the specialization takes precedence over the
conversion.

.. doxygenclass:: fmt::basic_format_parse_context
   :members:

Literal-based API
-----------------

The following user-defined literals are defined in ``fmt/format.h``.

.. doxygenfunction:: operator""_format(const char *s, size_t n) -> detail::udl_formatter<char> 

.. doxygenfunction:: operator""_a(const char *s, size_t) -> detail::udl_arg<char>

Utilities
---------

.. doxygenfunction:: fmt::ptr(T p) -> const void*
.. doxygenfunction:: fmt::ptr(const std::unique_ptr<T> &p) -> const void*
.. doxygenfunction:: fmt::ptr(const std::shared_ptr<T> &p) -> const void*

.. doxygenfunction:: fmt::to_string(const T &value) -> std::string

.. doxygenfunction:: fmt::to_string_view(const Char *s) -> basic_string_view<Char>

.. doxygenfunction:: fmt::join(Range &&range, string_view sep) -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>>

.. doxygenfunction:: fmt::join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel>

.. doxygenclass:: fmt::detail::buffer
   :members:

.. doxygenclass:: fmt::basic_memory_buffer
   :protected-members:
   :members:

System Errors
-------------

{fmt} does not use ``errno`` to communicate errors to the user, but it may call
system functions which set ``errno``. Users should not make any assumptions
about the value of ``errno`` being preserved by library functions.

.. doxygenfunction:: fmt::system_error

.. doxygenfunction:: fmt::format_system_error

Custom Allocators
-----------------

The {fmt} library supports custom dynamic memory allocators.
A custom allocator class can be specified as a template argument to
:class:`fmt::basic_memory_buffer`::

    using custom_memory_buffer = 
      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;

It is also possible to write a formatting function that uses a custom
allocator::

    using custom_string =
      std::basic_string<char, std::char_traits<char>, custom_allocator>;

    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
                          fmt::format_args args) {
      custom_memory_buffer buf(alloc);
      fmt::vformat_to(buf, format_str, args);
      return custom_string(buf.data(), buf.size(), alloc);
    }

    template <typename ...Args>
    inline custom_string format(custom_allocator alloc,
                                fmt::string_view format_str,
                                const Args& ... args) {
      return vformat(alloc, format_str, fmt::make_format_args(args...));
    }

The allocator will be used for the output container only. Formatting functions
normally don't do any allocations for built-in and string types except for
non-default floating-point formatting that occasionally falls back on
``sprintf``.

.. _ranges-api:

Ranges and Tuple Formatting
===========================

The library also supports convenient formatting of ranges and tuples::

  #include <fmt/ranges.h>

  std::tuple<char, int, float> t{'a', 1, 2.0f};
  // Prints "('a', 1, 2.0)"
  fmt::print("{}", t);


NOTE: currently, the overload of ``fmt::join`` for iterables exists in the main
``format.h`` header, but expect this to change in the future.

Using ``fmt::join``, you can separate tuple elements with a custom separator::

  #include <fmt/ranges.h>

  std::tuple<int, char> t = {1, 'a'};
  // Prints "1, a"
  fmt::print("{}", fmt::join(t, ", "));

.. _chrono-api:

Date and Time Formatting
========================

``fmt/chrono.h`` provides formatters for

* `std::chrono::duration <https://en.cppreference.com/w/cpp/chrono/duration>`_
* `std::chrono::time_point
  <https://en.cppreference.com/w/cpp/chrono/time_point>`_
* `std::tm <https://en.cppreference.com/w/cpp/chrono/c/tm>`_

The format syntax is described in :ref:`chrono-specs`.

**Example**::

  #include <fmt/chrono.h>

  int main() {
    std::time_t t = std::time(nullptr);

    // Prints "The date is 2020-11-07." (with the current date):
    fmt::print("The date is {:%Y-%m-%d}.", fmt::localtime(t));

    using namespace std::literals::chrono_literals;

    // Prints "Default format: 42s 100ms":
    fmt::print("Default format: {} {}\n", 42s, 100ms);

    // Prints "strftime-like format: 03:15:30":
    fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
  }

.. doxygenfunction:: localtime(std::time_t time)

.. doxygenfunction:: gmtime(std::time_t time)

.. _compile-api:

Format string compilation
=========================

``fmt/compile.h`` provides format string compilation support when using
``FMT_COMPILE``. Format strings are parsed, checked and converted into efficient
formatting code at compile-time. This supports arguments of built-in and string
types as well as user-defined types with ``constexpr`` ``parse`` functions in
their ``formatter`` specializations. Format string compilation can generate more
binary code compared to the default API and is only recommended in places where
formatting is a performance bottleneck.

.. doxygendefine:: FMT_COMPILE

.. _color-api:

Terminal color and text style
=============================

``fmt/color.h`` provides support for terminal color and text style output.

.. doxygenfunction:: print(const text_style &ts, const S &format_str, const Args&... args)

.. doxygenfunction:: fg(detail::color_type)

.. doxygenfunction:: bg(detail::color_type)

.. _os-api:

System APIs
===========

.. doxygenclass:: fmt::ostream
   :members:

.. doxygenfunction:: fmt::windows_error
   :members:

.. _ostream-api:

``std::ostream`` Support
========================

``fmt/ostream.h`` provides ``std::ostream`` support including formatting of
user-defined types that have an overloaded insertion operator (``operator<<``)::

  #include <fmt/ostream.h>

  class date {
    int year_, month_, day_;
  public:
    date(int year, int month, int day): year_(year), month_(month), day_(day) {}

    friend std::ostream& operator<<(std::ostream& os, const date& d) {
      return os << d.year_ << '-' << d.month_ << '-' << d.day_;
    }
  };

  std::string s = fmt::format("The date is {}", date(2012, 12, 9));
  // s == "The date is 2012-12-9"

{fmt} only supports insertion operators that are defined in the same namespaces
as the types they format and can be found with the argument-dependent lookup.

.. doxygenfunction:: print(std::basic_ostream<Char> &os, const S &format_str, Args&&... args)

.. _printf-api:

``printf`` Formatting
=====================

The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
The following functions use `printf format string syntax
<https://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
the POSIX extension for positional arguments. Unlike their standard
counterparts, the ``fmt`` functions are type-safe and throw an exception if an
argument type doesn't match its format specification.

.. doxygenfunction:: printf(const S &format_str, const T&... args)

.. doxygenfunction:: fprintf(std::FILE *f, const S &fmt, const T&... args) -> int

.. doxygenfunction:: sprintf(const S&, const T&...)

.. _xchar-api:

``wchar_t`` Support
===================

The optional header ``fmt/wchar_t.h`` provides support for ``wchar_t`` and
exotic character types.

.. doxygenstruct:: fmt::is_char

.. doxygentypedef:: fmt::wstring_view

.. doxygentypedef:: fmt::wformat_context

.. doxygenfunction:: fmt::to_wstring(const T &value)

Compatibility with C++20 ``std::format``
========================================

{fmt} implements nearly all of the `C++20 formatting library
<https://en.cppreference.com/w/cpp/utility/format>`_ with the following
differences:

* Names are defined in the ``fmt`` namespace instead of ``std`` to avoid
  collisions with standard library implementations.
* Width calculation doesn't use grapheme clusterization. The latter has been
  implemented in a separate branch but hasn't been integrated yet.
* Most C++20 chrono types are not supported yet.


================================================
FILE: examples/libraries/fmt/doc/basic-bootstrap/README
================================================
Sphinx basic theme with Bootstrap support. Modifications are kept to
a minimum to simplify integration in case of changes to Sphinx theming.


================================================
FILE: examples/libraries/fmt/doc/basic-bootstrap/layout.html
================================================
{#
    basic/layout.html
    ~~~~~~~~~~~~~~~~~

    Master layout template for Sphinx themes.

    :copyright: Copyright 2007-2015 by the Sphinx team, see AUTHORS.
    :license: BSD, see LICENSE for details.
#}
{%- block doctype -%}
<!DOCTYPE html>
{%- endblock %}
{%- set reldelim1 = reldelim1 is not defined and ' &raquo;' or reldelim1 %}
{%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
{%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
                         (sidebars != []) %}
{%- set url_root = pathto('', 1) %}
{# XXX necessary? #}
{%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
{%- if not embedded and docstitle %}
  {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
{%- else %}
  {%- set titlesuffix = "" %}
{%- endif %}

{%- macro relbar() %}
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>{{ _('Navigation') }}</h3>
      <ul>
        {%- for rellink in rellinks %}
        <li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
          <a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
             {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
          {%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
        {%- endfor %}
        {%- block rootrellink %}
        <li class="nav-item nav-item-0"><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
        {%- endblock %}
        {%- for parent in parents %}
          <li class="nav-item nav-item-{{ loop.index }}"><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
        {%- endfor %}
        {%- block relbaritems %} {% endblock %}
      </ul>
    </div>
{%- endmacro %}

{%- macro sidebar() %}
      {%- if render_sidebar %}
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
          {%- block sidebarlogo %}
          {%- if logo %}
            <p class="logo"><a href="{{ pathto(master_doc) }}">
              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
            </a></p>
          {%- endif %}
          {%- endblock %}
          {%- if sidebars != None %}
            {#- new style sidebar: explicitly include/exclude templates #}
            {%- for sidebartemplate in sidebars %}
            {%- include sidebartemplate %}
            {%- endfor %}
          {%- else %}
            {#- old style sidebars: using blocks -- should be deprecated #}
            {%- block sidebartoc %}
            {%- include "localtoc.html" %}
            {%- endblock %}
            {%- block sidebarrel %}
            {%- include "relations.html" %}
            {%- endblock %}
            {%- block sidebarsourcelink %}
            {%- include "sourcelink.html" %}
            {%- endblock %}
            {%- if customsidebar %}
            {%- include customsidebar %}
            {%- endif %}
            {%- block sidebarsearch %}
            {%- include "searchbox.html" %}
            {%- endblock %}
          {%- endif %}
        </div>
      </div>
      {%- endif %}
{%- endmacro %}

{%- macro script() %}
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '{{ url_root }}',
        VERSION:     '{{ release|e }}',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
        HAS_SOURCE:  {{ has_source|lower }},
        SOURCELINK_SUFFIX:  '{{ sourcelink_suffix }}'
      };
    </script>
    {%- for scriptfile in script_files %}
    <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
    {%- endfor %}
{%- endmacro %}

{%- macro css() %}
    <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
    <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
    {%- for cssfile in css_files %}
    <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
    {%- endfor %}
{%- endmacro %}

<html lang="en">
  <head>
    <meta charset="{{ encoding }}">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    {# The above 3 meta tags *must* come first in the head; any other head content
       must come *after* these tags. #}
    {{ metatags }}
    {%- block htmltitle %}
    <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
    {%- endblock %}
    {{ css() }}
    {%- if not embedded %}
    {{ script() }}
    {%- if use_opensearch %}
    <link rel="search" type="application/opensearchdescription+xml"
          title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
          href="{{ pathto('_static/opensearch.xml', 1) }}"/>
    {%- endif %}
    {%- if favicon %}
    <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
    {%- endif %}
    {%- endif %}
{%- block linktags %}
    {%- if hasdoc('about') %}
    <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
    {%- endif %}
    {%- if hasdoc('genindex') %}
    <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
    {%- endif %}
    {%- if hasdoc('search') %}
    <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
    {%- endif %}
    {%- if hasdoc('copyright') %}
    <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
    {%- endif %}
    {%- if parents %}
    <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}" />
    {%- endif %}
    {%- if next %}
    <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
    {%- endif %}
    {%- if prev %}
    <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
    {%- endif %}
{%- endblock %}
{%- block extrahead %} {% endblock %}
  </head>
  <body role="document">
{%- block header %}{% endblock %}

{%- block relbar1 %}{{ relbar() }}{% endblock %}

{%- block content %}
  {%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}

    <div class="document">
  {%- block document %}
      <div class="documentwrapper">
      {%- if render_sidebar %}
        <div class="bodywrapper">
      {%- endif %}
          <div class="body" role="main">
            {% block body %} {% endblock %}
          </div>
      {%- if render_sidebar %}
        </div>
      {%- endif %}
      </div>
  {%- endblock %}

  {%- block sidebar2 %}{{ sidebar() }}{% endblock %}
      <div class="clearer"></div>
    </div>
{%- endblock %}

{%- block relbar2 %}{{ relbar() }}{% endblock %}

{%- block footer %}
    <div class="footer" role="contentinfo">
    {%- if show_copyright %}
      {%- if hasdoc('copyright') %}
        {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
      {%- else %}
        {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
      {%- endif %}
    {%- endif %}
    {%- if last_updated %}
      {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
    {%- endif %}
    {%- if show_sphinx %}
      {% trans sphinx_version=sphinx_version|e %}Created using <a href="http://sphinx-doc.org/">Sphinx</a> {{ sphinx_version }}.{% endtrans %}
    {%- endif %}
    </div>
{%- endblock %}
  </body>
</html>


================================================
FILE: examples/libraries/fmt/doc/basic-bootstrap/theme.conf
================================================
[theme]
inherit = basic


================================================
FILE: examples/libraries/fmt/doc/bootstrap/alerts.less
================================================
//
// Alerts
// --------------------------------------------------


// Base styles
// -------------------------

.alert {
  padding: @alert-padding;
  margin-bottom: @line-height-computed;
  border: 1px solid transparent;
  border-radius: @alert-border-radius;

  // Headings for larger alerts
  h4 {
    margin-top: 0;
    // Specified for the h4 to prevent conflicts of changing @headings-color
    color: inherit;
  }

  // Provide class for links that match alerts
  .alert-link {
    font-weight: @alert-link-font-weight;
  }

  // Improve alignment and spacing of inner content
  > p,
  > ul {
    margin-bottom: 0;
  }

  > p + p {
    margin-top: 5px;
  }
}

// Dismissible alerts
//
// Expand the right padding and account for the close button's positioning.

.alert-dismissable, // The misspelled .alert-dismissable was deprecated in 3.2.0.
.alert-dismissible {
  padding-right: (@alert-padding + 20);

  // Adjust close link position
  .close {
    position: relative;
    top: -2px;
    right: -21px;
    color: inherit;
  }
}

// Alternate styles
//
// Generate contextual modifier classes for colorizing the alert.

.alert-success {
  .alert-variant(@alert-success-bg; @alert-success-border; @alert-success-text);
}

.alert-info {
  .alert-variant(@alert-info-bg; @alert-info-border; @alert-info-text);
}

.alert-warning {
  .alert-variant(@alert-warning-bg; @alert-warning-border; @alert-warning-text);
}

.alert-danger {
  .alert-variant(@alert-danger-bg; @alert-danger-border; @alert-danger-text);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/badges.less
================================================
//
// Badges
// --------------------------------------------------


// Base class
.badge {
  display: inline-block;
  min-width: 10px;
  padding: 3px 7px;
  font-size: @font-size-small;
  font-weight: @badge-font-weight;
  color: @badge-color;
  line-height: @badge-line-height;
  vertical-align: baseline;
  white-space: nowrap;
  text-align: center;
  background-color: @badge-bg;
  border-radius: @badge-border-radius;

  // Empty badges collapse automatically (not available in IE8)
  &:empty {
    display: none;
  }

  // Quick fix for badges in buttons
  .btn & {
    position: relative;
    top: -1px;
  }

  .btn-xs &,
  .btn-group-xs > .btn & {
    top: 0;
    padding: 1px 5px;
  }

  // Hover state, but only for links
  a& {
    &:hover,
    &:focus {
      color: @badge-link-hover-color;
      text-decoration: none;
      cursor: pointer;
    }
  }

  // Account for badges in navs
  .list-group-item.active > &,
  .nav-pills > .active > a > & {
    color: @badge-active-color;
    background-color: @badge-active-bg;
  }

  .list-group-item > & {
    float: right;
  }

  .list-group-item > & + & {
    margin-right: 5px;
  }

  .nav-pills > li > a > & {
    margin-left: 3px;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/bootstrap.less
================================================
// Core variables and mixins
@import "variables.less";
@import "mixins.less";

// Reset and dependencies
@import "normalize.less";
@import "print.less";
@import "glyphicons.less";

// Core CSS
@import "scaffolding.less";
@import "type.less";
@import "code.less";
@import "grid.less";
@import "tables.less";
@import "forms.less";
@import "buttons.less";

// Components
@import "component-animations.less";
@import "dropdowns.less";
@import "button-groups.less";
@import "input-groups.less";
@import "navs.less";
@import "navbar.less";
@import "breadcrumbs.less";
@import "pagination.less";
@import "pager.less";
@import "labels.less";
@import "badges.less";
@import "jumbotron.less";
@import "thumbnails.less";
@import "alerts.less";
@import "progress-bars.less";
@import "media.less";
@import "list-group.less";
@import "panels.less";
@import "responsive-embed.less";
@import "wells.less";
@import "close.less";

// Components w/ JavaScript
@import "modals.less";
@import "tooltip.less";
@import "popovers.less";
@import "carousel.less";

// Utility classes
@import "utilities.less";
@import "responsive-utilities.less";


================================================
FILE: examples/libraries/fmt/doc/bootstrap/breadcrumbs.less
================================================
//
// Breadcrumbs
// --------------------------------------------------


.breadcrumb {
  padding: @breadcrumb-padding-vertical @breadcrumb-padding-horizontal;
  margin-bottom: @line-height-computed;
  list-style: none;
  background-color: @breadcrumb-bg;
  border-radius: @border-radius-base;

  > li {
    display: inline-block;

    + li:before {
      content: "@{breadcrumb-separator}\00a0"; // Unicode space added since inline-block means non-collapsing white-space
      padding: 0 5px;
      color: @breadcrumb-color;
    }
  }

  > .active {
    color: @breadcrumb-active-color;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/button-groups.less
================================================
//
// Button groups
// --------------------------------------------------

// Make the div behave like a button
.btn-group,
.btn-group-vertical {
  position: relative;
  display: inline-block;
  vertical-align: middle; // match .btn alignment given font-size hack above
  > .btn {
    position: relative;
    float: left;
    // Bring the "active" button to the front
    &:hover,
    &:focus,
    &:active,
    &.active {
      z-index: 2;
    }
  }
}

// Prevent double borders when buttons are next to each other
.btn-group {
  .btn + .btn,
  .btn + .btn-group,
  .btn-group + .btn,
  .btn-group + .btn-group {
    margin-left: -1px;
  }
}

// Optional: Group multiple button groups together for a toolbar
.btn-toolbar {
  margin-left: -5px; // Offset the first child's margin
  &:extend(.clearfix all);

  .btn-group,
  .input-group {
    float: left;
  }
  > .btn,
  > .btn-group,
  > .input-group {
    margin-left: 5px;
  }
}

.btn-group > .btn:not(:first-child):not(:last-child):not(.dropdown-toggle) {
  border-radius: 0;
}

// Set corners individual because sometimes a single button can be in a .btn-group and we need :first-child and :last-child to both match
.btn-group > .btn:first-child {
  margin-left: 0;
  &:not(:last-child):not(.dropdown-toggle) {
    .border-right-radius(0);
  }
}
// Need .dropdown-toggle since :last-child doesn't apply given a .dropdown-menu immediately after it
.btn-group > .btn:last-child:not(:first-child),
.btn-group > .dropdown-toggle:not(:first-child) {
  .border-left-radius(0);
}

// Custom edits for including btn-groups within btn-groups (useful for including dropdown buttons within a btn-group)
.btn-group > .btn-group {
  float: left;
}
.btn-group > .btn-group:not(:first-child):not(:last-child) > .btn {
  border-radius: 0;
}
.btn-group > .btn-group:first-child:not(:last-child) {
  > .btn:last-child,
  > .dropdown-toggle {
    .border-right-radius(0);
  }
}
.btn-group > .btn-group:last-child:not(:first-child) > .btn:first-child {
  .border-left-radius(0);
}

// On active and open, don't show outline
.btn-group .dropdown-toggle:active,
.btn-group.open .dropdown-toggle {
  outline: 0;
}


// Sizing
//
// Remix the default button sizing classes into new ones for easier manipulation.

.btn-group-xs > .btn { &:extend(.btn-xs); }
.btn-group-sm > .btn { &:extend(.btn-sm); }
.btn-group-lg > .btn { &:extend(.btn-lg); }


// Split button dropdowns
// ----------------------

// Give the line between buttons some depth
.btn-group > .btn + .dropdown-toggle {
  padding-left: 8px;
  padding-right: 8px;
}
.btn-group > .btn-lg + .dropdown-toggle {
  padding-left: 12px;
  padding-right: 12px;
}

// The clickable button for toggling the menu
// Remove the gradient and set the same inset shadow as the :active state
.btn-group.open .dropdown-toggle {
  .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));

  // Show no shadow for `.btn-link` since it has no other button styles.
  &.btn-link {
    .box-shadow(none);
  }
}


// Reposition the caret
.btn .caret {
  margin-left: 0;
}
// Carets in other button sizes
.btn-lg .caret {
  border-width: @caret-width-large @caret-width-large 0;
  border-bottom-width: 0;
}
// Upside down carets for .dropup
.dropup .btn-lg .caret {
  border-width: 0 @caret-width-large @caret-width-large;
}


// Vertical button groups
// ----------------------

.btn-group-vertical {
  > .btn,
  > .btn-group,
  > .btn-group > .btn {
    display: block;
    float: none;
    width: 100%;
    max-width: 100%;
  }

  // Clear floats so dropdown menus can be properly placed
  > .btn-group {
    &:extend(.clearfix all);
    > .btn {
      float: none;
    }
  }

  > .btn + .btn,
  > .btn + .btn-group,
  > .btn-group + .btn,
  > .btn-group + .btn-group {
    margin-top: -1px;
    margin-left: 0;
  }
}

.btn-group-vertical > .btn {
  &:not(:first-child):not(:last-child) {
    border-radius: 0;
  }
  &:first-child:not(:last-child) {
    border-top-right-radius: @border-radius-base;
    .border-bottom-radius(0);
  }
  &:last-child:not(:first-child) {
    border-bottom-left-radius: @border-radius-base;
    .border-top-radius(0);
  }
}
.btn-group-vertical > .btn-group:not(:first-child):not(:last-child) > .btn {
  border-radius: 0;
}
.btn-group-vertical > .btn-group:first-child:not(:last-child) {
  > .btn:last-child,
  > .dropdown-toggle {
    .border-bottom-radius(0);
  }
}
.btn-group-vertical > .btn-group:last-child:not(:first-child) > .btn:first-child {
  .border-top-radius(0);
}


// Justified button groups
// ----------------------

.btn-group-justified {
  display: table;
  width: 100%;
  table-layout: fixed;
  border-collapse: separate;
  > .btn,
  > .btn-group {
    float: none;
    display: table-cell;
    width: 1%;
  }
  > .btn-group .btn {
    width: 100%;
  }

  > .btn-group .dropdown-menu {
    left: auto;
  }
}


// Checkbox and radio options
//
// In order to support the browser's form validation feedback, powered by the
// `required` attribute, we have to "hide" the inputs via `clip`. We cannot use
// `display: none;` or `visibility: hidden;` as that also hides the popover.
// Simply visually hiding the inputs via `opacity` would leave them clickable in
// certain cases which is prevented by using `clip` and `pointer-events`.
// This way, we ensure a DOM element is visible to position the popover from.
//
// See https://github.com/twbs/bootstrap/pull/12794 and
// https://github.com/twbs/bootstrap/pull/14559 for more information.

[data-toggle="buttons"] {
  > .btn,
  > .btn-group > .btn {
    input[type="radio"],
    input[type="checkbox"] {
      position: absolute;
      clip: rect(0,0,0,0);
      pointer-events: none;
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/buttons.less
================================================
//
// Buttons
// --------------------------------------------------


// Base styles
// --------------------------------------------------

.btn {
  display: inline-block;
  margin-bottom: 0; // For input.btn
  font-weight: @btn-font-weight;
  text-align: center;
  vertical-align: middle;
  touch-action: manipulation;
  cursor: pointer;
  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
  border: 1px solid transparent;
  white-space: nowrap;
  .button-size(@padding-base-vertical; @padding-base-horizontal; @font-size-base; @line-height-base; @border-radius-base);
  .user-select(none);

  &,
  &:active,
  &.active {
    &:focus,
    &.focus {
      .tab-focus();
    }
  }

  &:hover,
  &:focus,
  &.focus {
    color: @btn-default-color;
    text-decoration: none;
  }

  &:active,
  &.active {
    outline: 0;
    background-image: none;
    .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));
  }

  &.disabled,
  &[disabled],
  fieldset[disabled] & {
    cursor: @cursor-disabled;
    pointer-events: none; // Future-proof disabling of clicks
    .opacity(.65);
    .box-shadow(none);
  }
}


// Alternate buttons
// --------------------------------------------------

.btn-default {
  .button-variant(@btn-default-color; @btn-default-bg; @btn-default-border);
}
.btn-primary {
  .button-variant(@btn-primary-color; @btn-primary-bg; @btn-primary-border);
}
// Success appears as green
.btn-success {
  .button-variant(@btn-success-color; @btn-success-bg; @btn-success-border);
}
// Info appears as blue-green
.btn-info {
  .button-variant(@btn-info-color; @btn-info-bg; @btn-info-border);
}
// Warning appears as orange
.btn-warning {
  .button-variant(@btn-warning-color; @btn-warning-bg; @btn-warning-border);
}
// Danger and error appear as red
.btn-danger {
  .button-variant(@btn-danger-color; @btn-danger-bg; @btn-danger-border);
}


// Link buttons
// -------------------------

// Make a button look and behave like a link
.btn-link {
  color: @link-color;
  font-weight: normal;
  border-radius: 0;

  &,
  &:active,
  &.active,
  &[disabled],
  fieldset[disabled] & {
    background-color: transparent;
    .box-shadow(none);
  }
  &,
  &:hover,
  &:focus,
  &:active {
    border-color: transparent;
  }
  &:hover,
  &:focus {
    color: @link-hover-color;
    text-decoration: @link-hover-decoration;
    background-color: transparent;
  }
  &[disabled],
  fieldset[disabled] & {
    &:hover,
    &:focus {
      color: @btn-link-disabled-color;
      text-decoration: none;
    }
  }
}


// Button Sizes
// --------------------------------------------------

.btn-lg {
  // line-height: ensure even-numbered height of button next to large input
  .button-size(@padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @border-radius-large);
}
.btn-sm {
  // line-height: ensure proper height of button next to small input
  .button-size(@padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @border-radius-small);
}
.btn-xs {
  .button-size(@padding-xs-vertical; @padding-xs-horizontal; @font-size-small; @line-height-small; @border-radius-small);
}


// Block button
// --------------------------------------------------

.btn-block {
  display: block;
  width: 100%;
}

// Vertically space out multiple block buttons
.btn-block + .btn-block {
  margin-top: 5px;
}

// Specificity overrides
input[type="submit"],
input[type="reset"],
input[type="button"] {
  &.btn-block {
    width: 100%;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/carousel.less
================================================
//
// Carousel
// --------------------------------------------------


// Wrapper for the slide container and indicators
.carousel {
  position: relative;
}

.carousel-inner {
  position: relative;
  overflow: hidden;
  width: 100%;

  > .item {
    display: none;
    position: relative;
    .transition(.6s ease-in-out left);

    // Account for jankitude on images
    > img,
    > a > img {
      &:extend(.img-responsive);
      line-height: 1;
    }

    // WebKit CSS3 transforms for supported devices
    @media all and (transform-3d), (-webkit-transform-3d) {
      .transition-transform(~'0.6s ease-in-out');
      .backface-visibility(~'hidden');
      .perspective(1000);

      &.next,
      &.active.right {
        .translate3d(100%, 0, 0);
        left: 0;
      }
      &.prev,
      &.active.left {
        .translate3d(-100%, 0, 0);
        left: 0;
      }
      &.next.left,
      &.prev.right,
      &.active {
        .translate3d(0, 0, 0);
        left: 0;
      }
    }
  }

  > .active,
  > .next,
  > .prev {
    display: block;
  }

  > .active {
    left: 0;
  }

  > .next,
  > .prev {
    position: absolute;
    top: 0;
    width: 100%;
  }

  > .next {
    left: 100%;
  }
  > .prev {
    left: -100%;
  }
  > .next.left,
  > .prev.right {
    left: 0;
  }

  > .active.left {
    left: -100%;
  }
  > .active.right {
    left: 100%;
  }

}

// Left/right controls for nav
// ---------------------------

.carousel-control {
  position: absolute;
  top: 0;
  left: 0;
  bottom: 0;
  width: @carousel-control-width;
  .opacity(@carousel-control-opacity);
  font-size: @carousel-control-font-size;
  color: @carousel-control-color;
  text-align: center;
  text-shadow: @carousel-text-shadow;
  // We can't have this transition here because WebKit cancels the carousel
  // animation if you trip this while in the middle of another animation.

  // Set gradients for backgrounds
  &.left {
    #gradient > .horizontal(@start-color: rgba(0,0,0,.5); @end-color: rgba(0,0,0,.0001));
  }
  &.right {
    left: auto;
    right: 0;
    #gradient > .horizontal(@start-color: rgba(0,0,0,.0001); @end-color: rgba(0,0,0,.5));
  }

  // Hover/focus state
  &:hover,
  &:focus {
    outline: 0;
    color: @carousel-control-color;
    text-decoration: none;
    .opacity(.9);
  }

  // Toggles
  .icon-prev,
  .icon-next,
  .glyphicon-chevron-left,
  .glyphicon-chevron-right {
    position: absolute;
    top: 50%;
    z-index: 5;
    display: inline-block;
  }
  .icon-prev,
  .glyphicon-chevron-left {
    left: 50%;
    margin-left: -10px;
  }
  .icon-next,
  .glyphicon-chevron-right {
    right: 50%;
    margin-right: -10px;
  }
  .icon-prev,
  .icon-next {
    width:  20px;
    height: 20px;
    margin-top: -10px;
    line-height: 1;
    font-family: serif;
  }


  .icon-prev {
    &:before {
      content: '\2039';// SINGLE LEFT-POINTING ANGLE QUOTATION MARK (U+2039)
    }
  }
  .icon-next {
    &:before {
      content: '\203a';// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (U+203A)
    }
  }
}

// Optional indicator pips
//
// Add an unordered list with the following class and add a list item for each
// slide your carousel holds.

.carousel-indicators {
  position: absolute;
  bottom: 10px;
  left: 50%;
  z-index: 15;
  width: 60%;
  margin-left: -30%;
  padding-left: 0;
  list-style: none;
  text-align: center;

  li {
    display: inline-block;
    width:  10px;
    height: 10px;
    margin: 1px;
    text-indent: -999px;
    border: 1px solid @carousel-indicator-border-color;
    border-radius: 10px;
    cursor: pointer;

    // IE8-9 hack for event handling
    //
    // Internet Explorer 8-9 does not support clicks on elements without a set
    // `background-color`. We cannot use `filter` since that's not viewed as a
    // background color by the browser. Thus, a hack is needed.
    // See https://developer.mozilla.org/en-US/docs/Web/Events/click#Internet_Explorer
    //
    // For IE8, we set solid black as it doesn't support `rgba()`. For IE9, we
    // set alpha transparency for the best results possible.
    background-color: #000 \9; // IE8
    background-color: rgba(0,0,0,0); // IE9
  }
  .active {
    margin: 0;
    width:  12px;
    height: 12px;
    background-color: @carousel-indicator-active-bg;
  }
}

// Optional captions
// -----------------------------
// Hidden by default for smaller viewports
.carousel-caption {
  position: absolute;
  left: 15%;
  right: 15%;
  bottom: 20px;
  z-index: 10;
  padding-top: 20px;
  padding-bottom: 20px;
  color: @carousel-caption-color;
  text-align: center;
  text-shadow: @carousel-text-shadow;
  & .btn {
    text-shadow: none; // No shadow for button elements in carousel-caption
  }
}


// Scale up controls for tablets and up
@media screen and (min-width: @screen-sm-min) {

  // Scale up the controls a smidge
  .carousel-control {
    .glyphicon-chevron-left,
    .glyphicon-chevron-right,
    .icon-prev,
    .icon-next {
      width: 30px;
      height: 30px;
      margin-top: -15px;
      font-size: 30px;
    }
    .glyphicon-chevron-left,
    .icon-prev {
      margin-left: -15px;
    }
    .glyphicon-chevron-right,
    .icon-next {
      margin-right: -15px;
    }
  }

  // Show and left align the captions
  .carousel-caption {
    left: 20%;
    right: 20%;
    padding-bottom: 30px;
  }

  // Move up the indicators
  .carousel-indicators {
    bottom: 20px;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/close.less
================================================
//
// Close icons
// --------------------------------------------------


.close {
  float: right;
  font-size: (@font-size-base * 1.5);
  font-weight: @close-font-weight;
  line-height: 1;
  color: @close-color;
  text-shadow: @close-text-shadow;
  .opacity(.2);

  &:hover,
  &:focus {
    color: @close-color;
    text-decoration: none;
    cursor: pointer;
    .opacity(.5);
  }

  // Additional properties for button version
  // iOS requires the button element instead of an anchor tag.
  // If you want the anchor version, it requires `href="#"`.
  // See https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile
  button& {
    padding: 0;
    cursor: pointer;
    background: transparent;
    border: 0;
    -webkit-appearance: none;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/code.less
================================================
//
// Code (inline and block)
// --------------------------------------------------


// Inline and block code styles
code,
kbd,
pre,
samp {
  font-family: @font-family-monospace;
}

// Inline code
code {
  padding: 2px 4px;
  font-size: 90%;
  color: @code-color;
  background-color: @code-bg;
  border-radius: @border-radius-base;
}

// User input typically entered via keyboard
kbd {
  padding: 2px 4px;
  font-size: 90%;
  color: @kbd-color;
  background-color: @kbd-bg;
  border-radius: @border-radius-small;
  box-shadow: inset 0 -1px 0 rgba(0,0,0,.25);

  kbd {
    padding: 0;
    font-size: 100%;
    font-weight: bold;
    box-shadow: none;
  }
}

// Blocks of code
pre {
  display: block;
  padding: ((@line-height-computed - 1) / 2);
  margin: 0 0 (@line-height-computed / 2);
  font-size: (@font-size-base - 1); // 14px to 13px
  line-height: @line-height-base;
  word-break: break-all;
  word-wrap: break-word;
  color: @pre-color;
  background-color: @pre-bg;
  border: 1px solid @pre-border-color;
  border-radius: @border-radius-base;

  // Account for some code outputs that place code tags in pre tags
  code {
    padding: 0;
    font-size: inherit;
    color: inherit;
    white-space: pre-wrap;
    background-color: transparent;
    border-radius: 0;
  }
}

// Enable scrollable blocks of code
.pre-scrollable {
  max-height: @pre-scrollable-max-height;
  overflow-y: scroll;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/component-animations.less
================================================
//
// Component animations
// --------------------------------------------------

// Heads up!
//
// We don't use the `.opacity()` mixin here since it causes a bug with text
// fields in IE7-8. Source: https://github.com/twbs/bootstrap/pull/3552.

.fade {
  opacity: 0;
  .transition(opacity .15s linear);
  &.in {
    opacity: 1;
  }
}

.collapse {
  display: none;

  &.in      { display: block; }
  tr&.in    { display: table-row; }
  tbody&.in { display: table-row-group; }
}

.collapsing {
  position: relative;
  height: 0;
  overflow: hidden;
  .transition-property(~"height, visibility");
  .transition-duration(.35s);
  .transition-timing-function(ease);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/dropdowns.less
================================================
//
// Dropdown menus
// --------------------------------------------------


// Dropdown arrow/caret
.caret {
  display: inline-block;
  width: 0;
  height: 0;
  margin-left: 2px;
  vertical-align: middle;
  border-top:   @caret-width-base dashed;
  border-right: @caret-width-base solid transparent;
  border-left:  @caret-width-base solid transparent;
}

// The dropdown wrapper (div)
.dropup,
.dropdown {
  position: relative;
}

// Prevent the focus on the dropdown toggle when closing dropdowns
.dropdown-toggle:focus {
  outline: 0;
}

// The dropdown menu (ul)
.dropdown-menu {
  position: absolute;
  top: 100%;
  left: 0;
  z-index: @zindex-dropdown;
  display: none; // none by default, but block on "open" of the menu
  float: left;
  min-width: 160px;
  padding: 5px 0;
  margin: 2px 0 0; // override default ul
  list-style: none;
  font-size: @font-size-base;
  text-align: left; // Ensures proper alignment if parent has it changed (e.g., modal footer)
  background-color: @dropdown-bg;
  border: 1px solid @dropdown-fallback-border; // IE8 fallback
  border: 1px solid @dropdown-border;
  border-radius: @border-radius-base;
  .box-shadow(0 6px 12px rgba(0,0,0,.175));
  background-clip: padding-box;

  // Aligns the dropdown menu to right
  //
  // Deprecated as of 3.1.0 in favor of `.dropdown-menu-[dir]`
  &.pull-right {
    right: 0;
    left: auto;
  }

  // Dividers (basically an hr) within the dropdown
  .divider {
    .nav-divider(@dropdown-divider-bg);
  }

  // Links within the dropdown menu
  > li > a {
    display: block;
    padding: 3px 20px;
    clear: both;
    font-weight: normal;
    line-height: @line-height-base;
    color: @dropdown-link-color;
    white-space: nowrap; // prevent links from randomly breaking onto new lines
  }
}

// Hover/Focus state
.dropdown-menu > li > a {
  &:hover,
  &:focus {
    text-decoration: none;
    color: @dropdown-link-hover-color;
    background-color: @dropdown-link-hover-bg;
  }
}

// Active state
.dropdown-menu > .active > a {
  &,
  &:hover,
  &:focus {
    color: @dropdown-link-active-color;
    text-decoration: none;
    outline: 0;
    background-color: @dropdown-link-active-bg;
  }
}

// Disabled state
//
// Gray out text and ensure the hover/focus state remains gray

.dropdown-menu > .disabled > a {
  &,
  &:hover,
  &:focus {
    color: @dropdown-link-disabled-color;
  }

  // Nuke hover/focus effects
  &:hover,
  &:focus {
    text-decoration: none;
    background-color: transparent;
    background-image: none; // Remove CSS gradient
    .reset-filter();
    cursor: @cursor-disabled;
  }
}

// Open state for the dropdown
.open {
  // Show the menu
  > .dropdown-menu {
    display: block;
  }

  // Remove the outline when :focus is triggered
  > a {
    outline: 0;
  }
}

// Menu positioning
//
// Add extra class to `.dropdown-menu` to flip the alignment of the dropdown
// menu with the parent.
.dropdown-menu-right {
  left: auto; // Reset the default from `.dropdown-menu`
  right: 0;
}
// With v3, we enabled auto-flipping if you have a dropdown within a right
// aligned nav component. To enable the undoing of that, we provide an override
// to restore the default dropdown menu alignment.
//
// This is only for left-aligning a dropdown menu within a `.navbar-right` or
// `.pull-right` nav component.
.dropdown-menu-left {
  left: 0;
  right: auto;
}

// Dropdown section headers
.dropdown-header {
  display: block;
  padding: 3px 20px;
  font-size: @font-size-small;
  line-height: @line-height-base;
  color: @dropdown-header-color;
  white-space: nowrap; // as with > li > a
}

// Backdrop to catch body clicks on mobile, etc.
.dropdown-backdrop {
  position: fixed;
  left: 0;
  right: 0;
  bottom: 0;
  top: 0;
  z-index: (@zindex-dropdown - 10);
}

// Right aligned dropdowns
.pull-right > .dropdown-menu {
  right: 0;
  left: auto;
}

// Allow for dropdowns to go bottom up (aka, dropup-menu)
//
// Just add .dropup after the standard .dropdown class and you're set, bro.
// TODO: abstract this so that the navbar fixed styles are not placed here?

.dropup,
.navbar-fixed-bottom .dropdown {
  // Reverse the caret
  .caret {
    border-top: 0;
    border-bottom: @caret-width-base solid;
    content: "";
  }
  // Different positioning for bottom up menu
  .dropdown-menu {
    top: auto;
    bottom: 100%;
    margin-bottom: 2px;
  }
}


// Component alignment
//
// Reiterate per navbar.less and the modified component alignment there.

@media (min-width: @grid-float-breakpoint) {
  .navbar-right {
    .dropdown-menu {
      .dropdown-menu-right();
    }
    // Necessary for overrides of the default right aligned menu.
    // Will remove come v4 in all likelihood.
    .dropdown-menu-left {
      .dropdown-menu-left();
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/forms.less
================================================
//
// Forms
// --------------------------------------------------


// Normalize non-controls
//
// Restyle and baseline non-control form elements.

fieldset {
  padding: 0;
  margin: 0;
  border: 0;
  // Chrome and Firefox set a `min-width: min-content;` on fieldsets,
  // so we reset that to ensure it behaves more like a standard block element.
  // See https://github.com/twbs/bootstrap/issues/12359.
  min-width: 0;
}

legend {
  display: block;
  width: 100%;
  padding: 0;
  margin-bottom: @line-height-computed;
  font-size: (@font-size-base * 1.5);
  line-height: inherit;
  color: @legend-color;
  border: 0;
  border-bottom: 1px solid @legend-border-color;
}

label {
  display: inline-block;
  max-width: 100%; // Force IE8 to wrap long content (see https://github.com/twbs/bootstrap/issues/13141)
  margin-bottom: 5px;
  font-weight: bold;
}


// Normalize form controls
//
// While most of our form styles require extra classes, some basic normalization
// is required to ensure optimum display with or without those classes to better
// address browser inconsistencies.

// Override content-box in Normalize (* isn't specific enough)
input[type="search"] {
  .box-sizing(border-box);
}

// Position radios and checkboxes better
input[type="radio"],
input[type="checkbox"] {
  margin: 4px 0 0;
  margin-top: 1px \9; // IE8-9
  line-height: normal;
}

// Set the height of file controls to match text inputs
input[type="file"] {
  display: block;
}

// Make range inputs behave like textual form controls
input[type="range"] {
  display: block;
  width: 100%;
}

// Make multiple select elements height not fixed
select[multiple],
select[size] {
  height: auto;
}

// Focus for file, radio, and checkbox
input[type="file"]:focus,
input[type="radio"]:focus,
input[type="checkbox"]:focus {
  .tab-focus();
}

// Adjust output element
output {
  display: block;
  padding-top: (@padding-base-vertical + 1);
  font-size: @font-size-base;
  line-height: @line-height-base;
  color: @input-color;
}


// Common form controls
//
// Shared size and type resets for form controls. Apply `.form-control` to any
// of the following form controls:
//
// select
// textarea
// input[type="text"]
// input[type="password"]
// input[type="datetime"]
// input[type="datetime-local"]
// input[type="date"]
// input[type="month"]
// input[type="time"]
// input[type="week"]
// input[type="number"]
// input[type="email"]
// input[type="url"]
// input[type="search"]
// input[type="tel"]
// input[type="color"]

.form-control {
  display: block;
  width: 100%;
  height: @input-height-base; // Make inputs at least the height of their button counterpart (base line-height + padding + border)
  padding: @padding-base-vertical @padding-base-horizontal;
  font-size: @font-size-base;
  line-height: @line-height-base;
  color: @input-color;
  background-color: @input-bg;
  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
  border: 1px solid @input-border;
  border-radius: @input-border-radius; // Note: This has no effect on <select>s in some browsers, due to the limited stylability of <select>s in CSS.
  .box-shadow(inset 0 1px 1px rgba(0,0,0,.075));
  .transition(~"border-color ease-in-out .15s, box-shadow ease-in-out .15s");

  // Customize the `:focus` state to imitate native WebKit styles.
  .form-control-focus();

  // Placeholder
  .placeholder();

  // Disabled and read-only inputs
  //
  // HTML5 says that controls under a fieldset > legend:first-child won't be
  // disabled if the fieldset is disabled. Due to implementation difficulty, we
  // don't honor that edge case; we style them as disabled anyway.
  &[disabled],
  &[readonly],
  fieldset[disabled] & {
    background-color: @input-bg-disabled;
    opacity: 1; // iOS fix for unreadable disabled content; see https://github.com/twbs/bootstrap/issues/11655
  }

  &[disabled],
  fieldset[disabled] & {
    cursor: @cursor-disabled;
  }

  // Reset height for `textarea`s
  textarea& {
    height: auto;
  }
}


// Search inputs in iOS
//
// This overrides the extra rounded corners on search inputs in iOS so that our
// `.form-control` class can properly style them. Note that this cannot simply
// be added to `.form-control` as it's not specific enough. For details, see
// https://github.com/twbs/bootstrap/issues/11586.

input[type="search"] {
  -webkit-appearance: none;
}


// Special styles for iOS temporal inputs
//
// In Mobile Safari, setting `display: block` on temporal inputs causes the
// text within the input to become vertically misaligned. As a workaround, we
// set a pixel line-height that matches the given height of the input, but only
// for Safari. See https://bugs.webkit.org/show_bug.cgi?id=139848

@media screen and (-webkit-min-device-pixel-ratio: 0) {
  input[type="date"],
  input[type="time"],
  input[type="datetime-local"],
  input[type="month"] {
    line-height: @input-height-base;

    &.input-sm,
    .input-group-sm & {
      line-height: @input-height-small;
    }

    &.input-lg,
    .input-group-lg & {
      line-height: @input-height-large;
    }
  }
}


// Form groups
//
// Designed to help with the organization and spacing of vertical forms. For
// horizontal forms, use the predefined grid classes.

.form-group {
  margin-bottom: @form-group-margin-bottom;
}


// Checkboxes and radios
//
// Indent the labels to position radios/checkboxes as hanging controls.

.radio,
.checkbox {
  position: relative;
  display: block;
  margin-top: 10px;
  margin-bottom: 10px;

  label {
    min-height: @line-height-computed; // Ensure the input doesn't jump when there is no text
    padding-left: 20px;
    margin-bottom: 0;
    font-weight: normal;
    cursor: pointer;
  }
}
.radio input[type="radio"],
.radio-inline input[type="radio"],
.checkbox input[type="checkbox"],
.checkbox-inline input[type="checkbox"] {
  position: absolute;
  margin-left: -20px;
  margin-top: 4px \9;
}

.radio + .radio,
.checkbox + .checkbox {
  margin-top: -5px; // Move up sibling radios or checkboxes for tighter spacing
}

// Radios and checkboxes on same line
.radio-inline,
.checkbox-inline {
  position: relative;
  display: inline-block;
  padding-left: 20px;
  margin-bottom: 0;
  vertical-align: middle;
  font-weight: normal;
  cursor: pointer;
}
.radio-inline + .radio-inline,
.checkbox-inline + .checkbox-inline {
  margin-top: 0;
  margin-left: 10px; // space out consecutive inline controls
}

// Apply same disabled cursor tweak as for inputs
// Some special care is needed because <label>s don't inherit their parent's `cursor`.
//
// Note: Neither radios nor checkboxes can be readonly.
input[type="radio"],
input[type="checkbox"] {
  &[disabled],
  &.disabled,
  fieldset[disabled] & {
    cursor: @cursor-disabled;
  }
}
// These classes are used directly on <label>s
.radio-inline,
.checkbox-inline {
  &.disabled,
  fieldset[disabled] & {
    cursor: @cursor-disabled;
  }
}
// These classes are used on elements with <label> descendants
.radio,
.checkbox {
  &.disabled,
  fieldset[disabled] & {
    label {
      cursor: @cursor-disabled;
    }
  }
}


// Static form control text
//
// Apply class to a `p` element to make any string of text align with labels in
// a horizontal form layout.

.form-control-static {
  // Size it appropriately next to real form controls
  padding-top: (@padding-base-vertical + 1);
  padding-bottom: (@padding-base-vertical + 1);
  // Remove default margin from `p`
  margin-bottom: 0;
  min-height: (@line-height-computed + @font-size-base);

  &.input-lg,
  &.input-sm {
    padding-left: 0;
    padding-right: 0;
  }
}


// Form control sizing
//
// Build on `.form-control` with modifier classes to decrease or increase the
// height and font-size of form controls.
//
// The `.form-group-* form-control` variations are sadly duplicated to avoid the
// issue documented in https://github.com/twbs/bootstrap/issues/15074.

.input-sm {
  .input-size(@input-height-small; @padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @input-border-radius-small);
}
.form-group-sm {
  .form-control {
    .input-size(@input-height-small; @padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @input-border-radius-small);
  }
  .form-control-static {
    height: @input-height-small;
    padding: @padding-small-vertical @padding-small-horizontal;
    font-size: @font-size-small;
    line-height: @line-height-small;
    min-height: (@line-height-computed + @font-size-small);
  }
}

.input-lg {
  .input-size(@input-height-large; @padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @input-border-radius-large);
}
.form-group-lg {
  .form-control {
    .input-size(@input-height-large; @padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @input-border-radius-large);
  }
  .form-control-static {
    height: @input-height-large;
    padding: @padding-large-vertical @padding-large-horizontal;
    font-size: @font-size-large;
    line-height: @line-height-large;
    min-height: (@line-height-computed + @font-size-large);
  }
}


// Form control feedback states
//
// Apply contextual and semantic states to individual form controls.

.has-feedback {
  // Enable absolute positioning
  position: relative;

  // Ensure icons don't overlap text
  .form-control {
    padding-right: (@input-height-base * 1.25);
  }
}
// Feedback icon (requires .glyphicon classes)
.form-control-feedback {
  position: absolute;
  top: 0;
  right: 0;
  z-index: 2; // Ensure icon is above input groups
  display: block;
  width: @input-height-base;
  height: @input-height-base;
  line-height: @input-height-base;
  text-align: center;
  pointer-events: none;
}
.input-lg + .form-control-feedback {
  width: @input-height-large;
  height: @input-height-large;
  line-height: @input-height-large;
}
.input-sm + .form-control-feedback {
  width: @input-height-small;
  height: @input-height-small;
  line-height: @input-height-small;
}

// Feedback states
.has-success {
  .form-control-validation(@state-success-text; @state-success-text; @state-success-bg);
}
.has-warning {
  .form-control-validation(@state-warning-text; @state-warning-text; @state-warning-bg);
}
.has-error {
  .form-control-validation(@state-danger-text; @state-danger-text; @state-danger-bg);
}

// Reposition feedback icon if input has visible label above
.has-feedback label {

  & ~ .form-control-feedback {
     top: (@line-height-computed + 5); // Height of the `label` and its margin
  }
  &.sr-only ~ .form-control-feedback {
     top: 0;
  }
}


// Help text
//
// Apply to any element you wish to create light text for placement immediately
// below a form control. Use for general help, formatting, or instructional text.

.help-block {
  display: block; // account for any element using help-block
  margin-top: 5px;
  margin-bottom: 10px;
  color: lighten(@text-color, 25%); // lighten the text some for contrast
}


// Inline forms
//
// Make forms appear inline(-block) by adding the `.form-inline` class. Inline
// forms begin stacked on extra small (mobile) devices and then go inline when
// viewports reach <768px.
//
// Requires wrapping inputs and labels with `.form-group` for proper display of
// default HTML form controls and our custom form controls (e.g., input groups).
//
// Heads up! This is mixin-ed into `.navbar-form` in navbars.less.

.form-inline {

  // Kick in the inline
  @media (min-width: @screen-sm-min) {
    // Inline-block all the things for "inline"
    .form-group {
      display: inline-block;
      margin-bottom: 0;
      vertical-align: middle;
    }

    // In navbar-form, allow folks to *not* use `.form-group`
    .form-control {
      display: inline-block;
      width: auto; // Prevent labels from stacking above inputs in `.form-group`
      vertical-align: middle;
    }

    // Make static controls behave like regular ones
    .form-control-static {
      display: inline-block;
    }

    .input-group {
      display: inline-table;
      vertical-align: middle;

      .input-group-addon,
      .input-group-btn,
      .form-control {
        width: auto;
      }
    }

    // Input groups need that 100% width though
    .input-group > .form-control {
      width: 100%;
    }

    .control-label {
      margin-bottom: 0;
      vertical-align: middle;
    }

    // Remove default margin on radios/checkboxes that were used for stacking, and
    // then undo the floating of radios and checkboxes to match.
    .radio,
    .checkbox {
      display: inline-block;
      margin-top: 0;
      margin-bottom: 0;
      vertical-align: middle;

      label {
        padding-left: 0;
      }
    }
    .radio input[type="radio"],
    .checkbox input[type="checkbox"] {
      position: relative;
      margin-left: 0;
    }

    // Re-override the feedback icon.
    .has-feedback .form-control-feedback {
      top: 0;
    }
  }
}


// Horizontal forms
//
// Horizontal forms are built on grid classes and allow you to create forms with
// labels on the left and inputs on the right.

.form-horizontal {

  // Consistent vertical alignment of radios and checkboxes
  //
  // Labels also get some reset styles, but that is scoped to a media query below.
  .radio,
  .checkbox,
  .radio-inline,
  .checkbox-inline {
    margin-top: 0;
    margin-bottom: 0;
    padding-top: (@padding-base-vertical + 1); // Default padding plus a border
  }
  // Account for padding we're adding to ensure the alignment and of help text
  // and other content below items
  .radio,
  .checkbox {
    min-height: (@line-height-computed + (@padding-base-vertical + 1));
  }

  // Make form groups behave like rows
  .form-group {
    .make-row();
  }

  // Reset spacing and right align labels, but scope to media queries so that
  // labels on narrow viewports stack the same as a default form example.
  @media (min-width: @screen-sm-min) {
    .control-label {
      text-align: right;
      margin-bottom: 0;
      padding-top: (@padding-base-vertical + 1); // Default padding plus a border
    }
  }

  // Validation states
  //
  // Reposition the icon because it's now within a grid column and columns have
  // `position: relative;` on them. Also accounts for the grid gutter padding.
  .has-feedback .form-control-feedback {
    right: (@grid-gutter-width / 2);
  }

  // Form group sizes
  //
  // Quick utility class for applying `.input-lg` and `.input-sm` styles to the
  // inputs and labels within a `.form-group`.
  .form-group-lg {
    @media (min-width: @screen-sm-min) {
      .control-label {
        padding-top: ((@padding-large-vertical * @line-height-large) + 1);
      }
    }
  }
  .form-group-sm {
    @media (min-width: @screen-sm-min) {
      .control-label {
        padding-top: (@padding-small-vertical + 1);
      }
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/glyphicons.less
================================================
//
// Glyphicons for Bootstrap
//
// Since icons are fonts, they can be placed anywhere text is placed and are
// thus automatically sized to match the surrounding child. To use, create an
// inline element with the appropriate classes, like so:
//
// <a href="#"><span class="glyphicon glyphicon-star"></span> Star</a>

// Import the fonts
@font-face {
  font-family: 'Glyphicons Halflings';
  src: url('@{icon-font-path}@{icon-font-name}.eot');
  src: url('@{icon-font-path}@{icon-font-name}.eot?#iefix') format('embedded-opentype'),
       url('@{icon-font-path}@{icon-font-name}.woff2') format('woff2'),
       url('@{icon-font-path}@{icon-font-name}.woff') format('woff'),
       url('@{icon-font-path}@{icon-font-name}.ttf') format('truetype'),
       url('@{icon-font-path}@{icon-font-name}.svg#@{icon-font-svg-id}') format('svg');
}

// Catchall baseclass
.glyphicon {
  position: relative;
  top: 1px;
  display: inline-block;
  font-family: 'Glyphicons Halflings';
  font-style: normal;
  font-weight: normal;
  line-height: 1;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}

// Individual icons
.glyphicon-asterisk               { &:before { content: "\2a"; } }
.glyphicon-plus                   { &:before { content: "\2b"; } }
.glyphicon-euro,
.glyphicon-eur                    { &:before { content: "\20ac"; } }
.glyphicon-minus                  { &:before { content: "\2212"; } }
.glyphicon-cloud                  { &:before { content: "\2601"; } }
.glyphicon-envelope               { &:before { content: "\2709"; } }
.glyphicon-pencil                 { &:before { content: "\270f"; } }
.glyphicon-glass                  { &:before { content: "\e001"; } }
.glyphicon-music                  { &:before { content: "\e002"; } }
.glyphicon-search                 { &:before { content: "\e003"; } }
.glyphicon-heart                  { &:before { content: "\e005"; } }
.glyphicon-star                   { &:before { content: "\e006"; } }
.glyphicon-star-empty             { &:before { content: "\e007"; } }
.glyphicon-user                   { &:before { content: "\e008"; } }
.glyphicon-film                   { &:before { content: "\e009"; } }
.glyphicon-th-large               { &:before { content: "\e010"; } }
.glyphicon-th                     { &:before { content: "\e011"; } }
.glyphicon-th-list                { &:before { content: "\e012"; } }
.glyphicon-ok                     { &:before { content: "\e013"; } }
.glyphicon-remove                 { &:before { content: "\e014"; } }
.glyphicon-zoom-in                { &:before { content: "\e015"; } }
.glyphicon-zoom-out               { &:before { content: "\e016"; } }
.glyphicon-off                    { &:before { content: "\e017"; } }
.glyphicon-signal                 { &:before { content: "\e018"; } }
.glyphicon-cog                    { &:before { content: "\e019"; } }
.glyphicon-trash                  { &:before { content: "\e020"; } }
.glyphicon-home                   { &:before { content: "\e021"; } }
.glyphicon-file                   { &:before { content: "\e022"; } }
.glyphicon-time                   { &:before { content: "\e023"; } }
.glyphicon-road                   { &:before { content: "\e024"; } }
.glyphicon-download-alt           { &:before { content: "\e025"; } }
.glyphicon-download               { &:before { content: "\e026"; } }
.glyphicon-upload                 { &:before { content: "\e027"; } }
.glyphicon-inbox                  { &:before { content: "\e028"; } }
.glyphicon-play-circle            { &:before { content: "\e029"; } }
.glyphicon-repeat                 { &:before { content: "\e030"; } }
.glyphicon-refresh                { &:before { content: "\e031"; } }
.glyphicon-list-alt               { &:before { content: "\e032"; } }
.glyphicon-lock                   { &:before { content: "\e033"; } }
.glyphicon-flag                   { &:before { content: "\e034"; } }
.glyphicon-headphones             { &:before { content: "\e035"; } }
.glyphicon-volume-off             { &:before { content: "\e036"; } }
.glyphicon-volume-down            { &:before { content: "\e037"; } }
.glyphicon-volume-up              { &:before { content: "\e038"; } }
.glyphicon-qrcode                 { &:before { content: "\e039"; } }
.glyphicon-barcode                { &:before { content: "\e040"; } }
.glyphicon-tag                    { &:before { content: "\e041"; } }
.glyphicon-tags                   { &:before { content: "\e042"; } }
.glyphicon-book                   { &:before { content: "\e043"; } }
.glyphicon-bookmark               { &:before { content: "\e044"; } }
.glyphicon-print                  { &:before { content: "\e045"; } }
.glyphicon-camera                 { &:before { content: "\e046"; } }
.glyphicon-font                   { &:before { content: "\e047"; } }
.glyphicon-bold                   { &:before { content: "\e048"; } }
.glyphicon-italic                 { &:before { content: "\e049"; } }
.glyphicon-text-height            { &:before { content: "\e050"; } }
.glyphicon-text-width             { &:before { content: "\e051"; } }
.glyphicon-align-left             { &:before { content: "\e052"; } }
.glyphicon-align-center           { &:before { content: "\e053"; } }
.glyphicon-align-right            { &:before { content: "\e054"; } }
.glyphicon-align-justify          { &:before { content: "\e055"; } }
.glyphicon-list                   { &:before { content: "\e056"; } }
.glyphicon-indent-left            { &:before { content: "\e057"; } }
.glyphicon-indent-right           { &:before { content: "\e058"; } }
.glyphicon-facetime-video         { &:before { content: "\e059"; } }
.glyphicon-picture                { &:before { content: "\e060"; } }
.glyphicon-map-marker             { &:before { content: "\e062"; } }
.glyphicon-adjust                 { &:before { content: "\e063"; } }
.glyphicon-tint                   { &:before { content: "\e064"; } }
.glyphicon-edit                   { &:before { content: "\e065"; } }
.glyphicon-share                  { &:before { content: "\e066"; } }
.glyphicon-check                  { &:before { content: "\e067"; } }
.glyphicon-move                   { &:before { content: "\e068"; } }
.glyphicon-step-backward          { &:before { content: "\e069"; } }
.glyphicon-fast-backward          { &:before { content: "\e070"; } }
.glyphicon-backward               { &:before { content: "\e071"; } }
.glyphicon-play                   { &:before { content: "\e072"; } }
.glyphicon-pause                  { &:before { content: "\e073"; } }
.glyphicon-stop                   { &:before { content: "\e074"; } }
.glyphicon-forward                { &:before { content: "\e075"; } }
.glyphicon-fast-forward           { &:before { content: "\e076"; } }
.glyphicon-step-forward           { &:before { content: "\e077"; } }
.glyphicon-eject                  { &:before { content: "\e078"; } }
.glyphicon-chevron-left           { &:before { content: "\e079"; } }
.glyphicon-chevron-right          { &:before { content: "\e080"; } }
.glyphicon-plus-sign              { &:before { content: "\e081"; } }
.glyphicon-minus-sign             { &:before { content: "\e082"; } }
.glyphicon-remove-sign            { &:before { content: "\e083"; } }
.glyphicon-ok-sign                { &:before { content: "\e084"; } }
.glyphicon-question-sign          { &:before { content: "\e085"; } }
.glyphicon-info-sign              { &:before { content: "\e086"; } }
.glyphicon-screenshot             { &:before { content: "\e087"; } }
.glyphicon-remove-circle          { &:before { content: "\e088"; } }
.glyphicon-ok-circle              { &:before { content: "\e089"; } }
.glyphicon-ban-circle             { &:before { content: "\e090"; } }
.glyphicon-arrow-left             { &:before { content: "\e091"; } }
.glyphicon-arrow-right            { &:before { content: "\e092"; } }
.glyphicon-arrow-up               { &:before { content: "\e093"; } }
.glyphicon-arrow-down             { &:before { content: "\e094"; } }
.glyphicon-share-alt              { &:before { content: "\e095"; } }
.glyphicon-resize-full            { &:before { content: "\e096"; } }
.glyphicon-resize-small           { &:before { content: "\e097"; } }
.glyphicon-exclamation-sign       { &:before { content: "\e101"; } }
.glyphicon-gift                   { &:before { content: "\e102"; } }
.glyphicon-leaf                   { &:before { content: "\e103"; } }
.glyphicon-fire                   { &:before { content: "\e104"; } }
.glyphicon-eye-open               { &:before { content: "\e105"; } }
.glyphicon-eye-close              { &:before { content: "\e106"; } }
.glyphicon-warning-sign           { &:before { content: "\e107"; } }
.glyphicon-plane                  { &:before { content: "\e108"; } }
.glyphicon-calendar               { &:before { content: "\e109"; } }
.glyphicon-random                 { &:before { content: "\e110"; } }
.glyphicon-comment                { &:before { content: "\e111"; } }
.glyphicon-magnet                 { &:before { content: "\e112"; } }
.glyphicon-chevron-up             { &:before { content: "\e113"; } }
.glyphicon-chevron-down           { &:before { content: "\e114"; } }
.glyphicon-retweet                { &:before { content: "\e115"; } }
.glyphicon-shopping-cart          { &:before { content: "\e116"; } }
.glyphicon-folder-close           { &:before { content: "\e117"; } }
.glyphicon-folder-open            { &:before { content: "\e118"; } }
.glyphicon-resize-vertical        { &:before { content: "\e119"; } }
.glyphicon-resize-horizontal      { &:before { content: "\e120"; } }
.glyphicon-hdd                    { &:before { content: "\e121"; } }
.glyphicon-bullhorn               { &:before { content: "\e122"; } }
.glyphicon-bell                   { &:before { content: "\e123"; } }
.glyphicon-certificate            { &:before { content: "\e124"; } }
.glyphicon-thumbs-up              { &:before { content: "\e125"; } }
.glyphicon-thumbs-down            { &:before { content: "\e126"; } }
.glyphicon-hand-right             { &:before { content: "\e127"; } }
.glyphicon-hand-left              { &:before { content: "\e128"; } }
.glyphicon-hand-up                { &:before { content: "\e129"; } }
.glyphicon-hand-down              { &:before { content: "\e130"; } }
.glyphicon-circle-arrow-right     { &:before { content: "\e131"; } }
.glyphicon-circle-arrow-left      { &:before { content: "\e132"; } }
.glyphicon-circle-arrow-up        { &:before { content: "\e133"; } }
.glyphicon-circle-arrow-down      { &:before { content: "\e134"; } }
.glyphicon-globe                  { &:before { content: "\e135"; } }
.glyphicon-wrench                 { &:before { content: "\e136"; } }
.glyphicon-tasks                  { &:before { content: "\e137"; } }
.glyphicon-filter                 { &:before { content: "\e138"; } }
.glyphicon-briefcase              { &:before { content: "\e139"; } }
.glyphicon-fullscreen             { &:before { content: "\e140"; } }
.glyphicon-dashboard              { &:before { content: "\e141"; } }
.glyphicon-paperclip              { &:before { content: "\e142"; } }
.glyphicon-heart-empty            { &:before { content: "\e143"; } }
.glyphicon-link                   { &:before { content: "\e144"; } }
.glyphicon-phone                  { &:before { content: "\e145"; } }
.glyphicon-pushpin                { &:before { content: "\e146"; } }
.glyphicon-usd                    { &:before { content: "\e148"; } }
.glyphicon-gbp                    { &:before { content: "\e149"; } }
.glyphicon-sort                   { &:before { content: "\e150"; } }
.glyphicon-sort-by-alphabet       { &:before { content: "\e151"; } }
.glyphicon-sort-by-alphabet-alt   { &:before { content: "\e152"; } }
.glyphicon-sort-by-order          { &:before { content: "\e153"; } }
.glyphicon-sort-by-order-alt      { &:before { content: "\e154"; } }
.glyphicon-sort-by-attributes     { &:before { content: "\e155"; } }
.glyphicon-sort-by-attributes-alt { &:before { content: "\e156"; } }
.glyphicon-unchecked              { &:before { content: "\e157"; } }
.glyphicon-expand                 { &:before { content: "\e158"; } }
.glyphicon-collapse-down          { &:before { content: "\e159"; } }
.glyphicon-collapse-up            { &:before { content: "\e160"; } }
.glyphicon-log-in                 { &:before { content: "\e161"; } }
.glyphicon-flash                  { &:before { content: "\e162"; } }
.glyphicon-log-out                { &:before { content: "\e163"; } }
.glyphicon-new-window             { &:before { content: "\e164"; } }
.glyphicon-record                 { &:before { content: "\e165"; } }
.glyphicon-save                   { &:before { content: "\e166"; } }
.glyphicon-open                   { &:before { content: "\e167"; } }
.glyphicon-saved                  { &:before { content: "\e168"; } }
.glyphicon-import                 { &:before { content: "\e169"; } }
.glyphicon-export                 { &:before { content: "\e170"; } }
.glyphicon-send                   { &:before { content: "\e171"; } }
.glyphicon-floppy-disk            { &:before { content: "\e172"; } }
.glyphicon-floppy-saved           { &:before { content: "\e173"; } }
.glyphicon-floppy-remove          { &:before { content: "\e174"; } }
.glyphicon-floppy-save            { &:before { content: "\e175"; } }
.glyphicon-floppy-open            { &:before { content: "\e176"; } }
.glyphicon-credit-card            { &:before { content: "\e177"; } }
.glyphicon-transfer               { &:before { content: "\e178"; } }
.glyphicon-cutlery                { &:before { content: "\e179"; } }
.glyphicon-header                 { &:before { content: "\e180"; } }
.glyphicon-compressed             { &:before { content: "\e181"; } }
.glyphicon-earphone               { &:before { content: "\e182"; } }
.glyphicon-phone-alt              { &:before { content: "\e183"; } }
.glyphicon-tower                  { &:before { content: "\e184"; } }
.glyphicon-stats                  { &:before { content: "\e185"; } }
.glyphicon-sd-video               { &:before { content: "\e186"; } }
.glyphicon-hd-video               { &:before { content: "\e187"; } }
.glyphicon-subtitles              { &:before { content: "\e188"; } }
.glyphicon-sound-stereo           { &:before { content: "\e189"; } }
.glyphicon-sound-dolby            { &:before { content: "\e190"; } }
.glyphicon-sound-5-1              { &:before { content: "\e191"; } }
.glyphicon-sound-6-1              { &:before { content: "\e192"; } }
.glyphicon-sound-7-1              { &:before { content: "\e193"; } }
.glyphicon-copyright-mark         { &:before { content: "\e194"; } }
.glyphicon-registration-mark      { &:before { content: "\e195"; } }
.glyphicon-cloud-download         { &:before { content: "\e197"; } }
.glyphicon-cloud-upload           { &:before { content: "\e198"; } }
.glyphicon-tree-conifer           { &:before { content: "\e199"; } }
.glyphicon-tree-deciduous         { &:before { content: "\e200"; } }
.glyphicon-cd                     { &:before { content: "\e201"; } }
.glyphicon-save-file              { &:before { content: "\e202"; } }
.glyphicon-open-file              { &:before { content: "\e203"; } }
.glyphicon-level-up               { &:before { content: "\e204"; } }
.glyphicon-copy                   { &:before { content: "\e205"; } }
.glyphicon-paste                  { &:before { content: "\e206"; } }
// The following 2 Glyphicons are omitted for the time being because
// they currently use Unicode codepoints that are outside the
// Basic Multilingual Plane (BMP). Older buggy versions of WebKit can't handle
// non-BMP codepoints in CSS string escapes, and thus can't display these two icons.
// Notably, the bug affects some older versions of the Android Browser.
// More info: https://github.com/twbs/bootstrap/issues/10106
// .glyphicon-door                   { &:before { content: "\1f6aa"; } }
// .glyphicon-key                    { &:before { content: "\1f511"; } }
.glyphicon-alert                  { &:before { content: "\e209"; } }
.glyphicon-equalizer              { &:before { content: "\e210"; } }
.glyphicon-king                   { &:before { content: "\e211"; } }
.glyphicon-queen                  { &:before { content: "\e212"; } }
.glyphicon-pawn                   { &:before { content: "\e213"; } }
.glyphicon-bishop                 { &:before { content: "\e214"; } }
.glyphicon-knight                 { &:before { content: "\e215"; } }
.glyphicon-baby-formula           { &:before { content: "\e216"; } }
.glyphicon-tent                   { &:before { content: "\26fa"; } }
.glyphicon-blackboard             { &:before { content: "\e218"; } }
.glyphicon-bed                    { &:before { content: "\e219"; } }
.glyphicon-apple                  { &:before { content: "\f8ff"; } }
.glyphicon-erase                  { &:before { content: "\e221"; } }
.glyphicon-hourglass              { &:before { content: "\231b"; } }
.glyphicon-lamp                   { &:before { content: "\e223"; } }
.glyphicon-duplicate              { &:before { content: "\e224"; } }
.glyphicon-piggy-bank             { &:before { content: "\e225"; } }
.glyphicon-scissors               { &:before { content: "\e226"; } }
.glyphicon-bitcoin                { &:before { content: "\e227"; } }
.glyphicon-btc                    { &:before { content: "\e227"; } }
.glyphicon-xbt                    { &:before { content: "\e227"; } }
.glyphicon-yen                    { &:before { content: "\00a5"; } }
.glyphicon-jpy                    { &:before { content: "\00a5"; } }
.glyphicon-ruble                  { &:before { content: "\20bd"; } }
.glyphicon-rub                    { &:before { content: "\20bd"; } }
.glyphicon-scale                  { &:before { content: "\e230"; } }
.glyphicon-ice-lolly              { &:before { content: "\e231"; } }
.glyphicon-ice-lolly-tasted       { &:before { content: "\e232"; } }
.glyphicon-education              { &:before { content: "\e233"; } }
.glyphicon-option-horizontal      { &:before { content: "\e234"; } }
.glyphicon-option-vertical        { &:before { content: "\e235"; } }
.glyphicon-menu-hamburger         { &:before { content: "\e236"; } }
.glyphicon-modal-window           { &:before { content: "\e237"; } }
.glyphicon-oil                    { &:before { content: "\e238"; } }
.glyphicon-grain                  { &:before { content: "\e239"; } }
.glyphicon-sunglasses             { &:before { content: "\e240"; } }
.glyphicon-text-size              { &:before { content: "\e241"; } }
.glyphicon-text-color             { &:before { content: "\e242"; } }
.glyphicon-text-background        { &:before { content: "\e243"; } }
.glyphicon-object-align-top       { &:before { content: "\e244"; } }
.glyphicon-object-align-bottom    { &:before { content: "\e245"; } }
.glyphicon-object-align-horizontal{ &:before { content: "\e246"; } }
.glyphicon-object-align-left      { &:before { content: "\e247"; } }
.glyphicon-object-align-vertical  { &:before { content: "\e248"; } }
.glyphicon-object-align-right     { &:before { content: "\e249"; } }
.glyphicon-triangle-right         { &:before { content: "\e250"; } }
.glyphicon-triangle-left          { &:before { content: "\e251"; } }
.glyphicon-triangle-bottom        { &:before { content: "\e252"; } }
.glyphicon-triangle-top           { &:before { content: "\e253"; } }
.glyphicon-console                { &:before { content: "\e254"; } }
.glyphicon-superscript            { &:before { content: "\e255"; } }
.glyphicon-subscript              { &:before { content: "\e256"; } }
.glyphicon-menu-left              { &:before { content: "\e257"; } }
.glyphicon-menu-right             { &:before { content: "\e258"; } }
.glyphicon-menu-down              { &:before { content: "\e259"; } }
.glyphicon-menu-up                { &:before { content: "\e260"; } }


================================================
FILE: examples/libraries/fmt/doc/bootstrap/grid.less
================================================
//
// Grid system
// --------------------------------------------------


// Container widths
//
// Set the container width, and override it for fixed navbars in media queries.

.tb-container {
  .container-fixed();

  @media (min-width: @screen-sm-min) {
    width: @container-sm;
  }
  @media (min-width: @screen-md-min) {
    width: @container-md;
  }
  @media (min-width: @screen-lg-min) {
    width: @container-lg;
  }
}


// Fluid container
//
// Utilizes the mixin meant for fixed width containers, but without any defined
// width for fluid, full width layouts.

.container-fluid {
  .container-fixed();
}


// Row
//
// Rows contain and clear the floats of your columns.

.row {
  .make-row();
}


// Columns
//
// Common styles for small and large grid columns

.make-grid-columns();


// Extra small grid
//
// Columns, offsets, pushes, and pulls for extra small devices like
// smartphones.

.make-grid(xs);


// Small grid
//
// Columns, offsets, pushes, and pulls for the small device range, from phones
// to tablets.

@media (min-width: @screen-sm-min) {
  .make-grid(sm);
}


// Medium grid
//
// Columns, offsets, pushes, and pulls for the desktop device range.

@media (min-width: @screen-md-min) {
  .make-grid(md);
}


// Large grid
//
// Columns, offsets, pushes, and pulls for the large desktop device range.

@media (min-width: @screen-lg-min) {
  .make-grid(lg);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/input-groups.less
================================================
//
// Input groups
// --------------------------------------------------

// Base styles
// -------------------------
.input-group {
  position: relative; // For dropdowns
  display: table;
  border-collapse: separate; // prevent input groups from inheriting border styles from table cells when placed within a table

  // Undo padding and float of grid classes
  &[class*="col-"] {
    float: none;
    padding-left: 0;
    padding-right: 0;
  }

  .form-control {
    // Ensure that the input is always above the *appended* addon button for
    // proper border colors.
    position: relative;
    z-index: 2;

    // IE9 fubars the placeholder attribute in text inputs and the arrows on
    // select elements in input groups. To fix it, we float the input. Details:
    // https://github.com/twbs/bootstrap/issues/11561#issuecomment-28936855
    float: left;

    width: 100%;
    margin-bottom: 0;
  }
}

// Sizing options
//
// Remix the default form control sizing classes into new ones for easier
// manipulation.

.input-group-lg > .form-control,
.input-group-lg > .input-group-addon,
.input-group-lg > .input-group-btn > .btn {
  .input-lg();
}
.input-group-sm > .form-control,
.input-group-sm > .input-group-addon,
.input-group-sm > .input-group-btn > .btn {
  .input-sm();
}


// Display as table-cell
// -------------------------
.input-group-addon,
.input-group-btn,
.input-group .form-control {
  display: table-cell;

  &:not(:first-child):not(:last-child) {
    border-radius: 0;
  }
}
// Addon and addon wrapper for buttons
.input-group-addon,
.input-group-btn {
  width: 1%;
  white-space: nowrap;
  vertical-align: middle; // Match the inputs
}

// Text input groups
// -------------------------
.input-group-addon {
  padding: @padding-base-vertical @padding-base-horizontal;
  font-size: @font-size-base;
  font-weight: normal;
  line-height: 1;
  color: @input-color;
  text-align: center;
  background-color: @input-group-addon-bg;
  border: 1px solid @input-group-addon-border-color;
  border-radius: @border-radius-base;

  // Sizing
  &.input-sm {
    padding: @padding-small-vertical @padding-small-horizontal;
    font-size: @font-size-small;
    border-radius: @border-radius-small;
  }
  &.input-lg {
    padding: @padding-large-vertical @padding-large-horizontal;
    font-size: @font-size-large;
    border-radius: @border-radius-large;
  }

  // Nuke default margins from checkboxes and radios to vertically center within.
  input[type="radio"],
  input[type="checkbox"] {
    margin-top: 0;
  }
}

// Reset rounded corners
.input-group .form-control:first-child,
.input-group-addon:first-child,
.input-group-btn:first-child > .btn,
.input-group-btn:first-child > .btn-group > .btn,
.input-group-btn:first-child > .dropdown-toggle,
.input-group-btn:last-child > .btn:not(:last-child):not(.dropdown-toggle),
.input-group-btn:last-child > .btn-group:not(:last-child) > .btn {
  .border-right-radius(0);
}
.input-group-addon:first-child {
  border-right: 0;
}
.input-group .form-control:last-child,
.input-group-addon:last-child,
.input-group-btn:last-child > .btn,
.input-group-btn:last-child > .btn-group > .btn,
.input-group-btn:last-child > .dropdown-toggle,
.input-group-btn:first-child > .btn:not(:first-child),
.input-group-btn:first-child > .btn-group:not(:first-child) > .btn {
  .border-left-radius(0);
}
.input-group-addon:last-child {
  border-left: 0;
}

// Button input groups
// -------------------------
.input-group-btn {
  position: relative;
  // Jankily prevent input button groups from wrapping with `white-space` and
  // `font-size` in combination with `inline-block` on buttons.
  font-size: 0;
  white-space: nowrap;

  // Negative margin for spacing, position for bringing hovered/focused/actived
  // element above the siblings.
  > .btn {
    position: relative;
    + .btn {
      margin-left: -1px;
    }
    // Bring the "active" button to the front
    &:hover,
    &:focus,
    &:active {
      z-index: 2;
    }
  }

  // Negative margin to only have a 1px border between the two
  &:first-child {
    > .btn,
    > .btn-group {
      margin-right: -1px;
    }
  }
  &:last-child {
    > .btn,
    > .btn-group {
      margin-left: -1px;
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/jumbotron.less
================================================
//
// Jumbotron
// --------------------------------------------------


.jumbotron {
  padding: @jumbotron-padding (@jumbotron-padding / 2);
  margin-bottom: @jumbotron-padding;
  color: @jumbotron-color;
  background-color: @jumbotron-bg;

  h1,
  .h1 {
    color: @jumbotron-heading-color;
  }

  p {
    margin-bottom: (@jumbotron-padding / 2);
    font-size: @jumbotron-font-size;
    font-weight: 200;
  }

  > hr {
    border-top-color: darken(@jumbotron-bg, 10%);
  }

  .tb-container &,
  .container-fluid & {
    border-radius: @border-radius-large; // Only round corners at higher resolutions if contained in a container
  }

  .tb-container {
    max-width: 100%;
  }

  @media screen and (min-width: @screen-sm-min) {
    padding: (@jumbotron-padding * 1.6) 0;

    .tb-container &,
    .container-fluid & {
      padding-left:  (@jumbotron-padding * 2);
      padding-right: (@jumbotron-padding * 2);
    }

    h1,
    .h1 {
      font-size: (@font-size-base * 4.5);
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/labels.less
================================================
//
// Labels
// --------------------------------------------------

.label {
  display: inline;
  padding: .2em .6em .3em;
  font-size: 75%;
  font-weight: bold;
  line-height: 1;
  color: @label-color;
  text-align: center;
  white-space: nowrap;
  vertical-align: baseline;
  border-radius: .25em;

  // Add hover effects, but only for links
  a& {
    &:hover,
    &:focus {
      color: @label-link-hover-color;
      text-decoration: none;
      cursor: pointer;
    }
  }

  // Empty labels collapse automatically (not available in IE8)
  &:empty {
    display: none;
  }

  // Quick fix for labels in buttons
  .btn & {
    position: relative;
    top: -1px;
  }
}

// Colors
// Contextual variations (linked labels get darker on :hover)

.label-default {
  .label-variant(@label-default-bg);
}

.label-primary {
  .label-variant(@label-primary-bg);
}

.label-success {
  .label-variant(@label-success-bg);
}

.label-info {
  .label-variant(@label-info-bg);
}

.label-warning {
  .label-variant(@label-warning-bg);
}

.label-danger {
  .label-variant(@label-danger-bg);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/list-group.less
================================================
//
// List groups
// --------------------------------------------------


// Base class
//
// Easily usable on <ul>, <ol>, or <div>.

.list-group {
  // No need to set list-style: none; since .list-group-item is block level
  margin-bottom: 20px;
  padding-left: 0; // reset padding because ul and ol
}


// Individual list items
//
// Use on `li`s or `div`s within the `.list-group` parent.

.list-group-item {
  position: relative;
  display: block;
  padding: 10px 15px;
  // Place the border on the list items and negative margin up for better styling
  margin-bottom: -1px;
  background-color: @list-group-bg;
  border: 1px solid @list-group-border;

  // Round the first and last items
  &:first-child {
    .border-top-radius(@list-group-border-radius);
  }
  &:last-child {
    margin-bottom: 0;
    .border-bottom-radius(@list-group-border-radius);
  }
}


// Linked list items
//
// Use anchor elements instead of `li`s or `div`s to create linked list items.
// Includes an extra `.active` modifier class for showing selected items.

a.list-group-item {
  color: @list-group-link-color;

  .list-group-item-heading {
    color: @list-group-link-heading-color;
  }

  // Hover state
  &:hover,
  &:focus {
    text-decoration: none;
    color: @list-group-link-hover-color;
    background-color: @list-group-hover-bg;
  }
}

.list-group-item {
  // Disabled state
  &.disabled,
  &.disabled:hover,
  &.disabled:focus {
    background-color: @list-group-disabled-bg;
    color: @list-group-disabled-color;
    cursor: @cursor-disabled;

    // Force color to inherit for custom content
    .list-group-item-heading {
      color: inherit;
    }
    .list-group-item-text {
      color: @list-group-disabled-text-color;
    }
  }

  // Active class on item itself, not parent
  &.active,
  &.active:hover,
  &.active:focus {
    z-index: 2; // Place active items above their siblings for proper border styling
    color: @list-group-active-color;
    background-color: @list-group-active-bg;
    border-color: @list-group-active-border;

    // Force color to inherit for custom content
    .list-group-item-heading,
    .list-group-item-heading > small,
    .list-group-item-heading > .small {
      color: inherit;
    }
    .list-group-item-text {
      color: @list-group-active-text-color;
    }
  }
}


// Contextual variants
//
// Add modifier classes to change text and background color on individual items.
// Organizationally, this must come after the `:hover` states.

.list-group-item-variant(success; @state-success-bg; @state-success-text);
.list-group-item-variant(info; @state-info-bg; @state-info-text);
.list-group-item-variant(warning; @state-warning-bg; @state-warning-text);
.list-group-item-variant(danger; @state-danger-bg; @state-danger-text);


// Custom content options
//
// Extra classes for creating well-formatted content within `.list-group-item`s.

.list-group-item-heading {
  margin-top: 0;
  margin-bottom: 5px;
}
.list-group-item-text {
  margin-bottom: 0;
  line-height: 1.3;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/media.less
================================================
.media {
  // Proper spacing between instances of .media
  margin-top: 15px;

  &:first-child {
    margin-top: 0;
  }
}

.media,
.media-body {
  zoom: 1;
  overflow: hidden;
}

.media-body {
  width: 10000px;
}

.media-object {
  display: block;
}

.media-right,
.media > .pull-right {
  padding-left: 10px;
}

.media-left,
.media > .pull-left {
  padding-right: 10px;
}

.media-left,
.media-right,
.media-body {
  display: table-cell;
  vertical-align: top;
}

.media-middle {
  vertical-align: middle;
}

.media-bottom {
  vertical-align: bottom;
}

// Reset margins on headings for tighter default spacing
.media-heading {
  margin-top: 0;
  margin-bottom: 5px;
}

// Media list variation
//
// Undo default ul/ol styles
.media-list {
  padding-left: 0;
  list-style: none;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/alerts.less
================================================
// Alerts

.alert-variant(@background; @border; @text-color) {
  background-color: @background;
  border-color: @border;
  color: @text-color;

  hr {
    border-top-color: darken(@border, 5%);
  }
  .alert-link {
    color: darken(@text-color, 10%);
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/background-variant.less
================================================
// Contextual backgrounds

.bg-variant(@color) {
  background-color: @color;
  a&:hover {
    background-color: darken(@color, 10%);
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/border-radius.less
================================================
// Single side border-radius

.border-top-radius(@radius) {
  border-top-right-radius: @radius;
   border-top-left-radius: @radius;
}
.border-right-radius(@radius) {
  border-bottom-right-radius: @radius;
     border-top-right-radius: @radius;
}
.border-bottom-radius(@radius) {
  border-bottom-right-radius: @radius;
   border-bottom-left-radius: @radius;
}
.border-left-radius(@radius) {
  border-bottom-left-radius: @radius;
     border-top-left-radius: @radius;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/buttons.less
================================================
// Button variants
//
// Easily pump out default styles, as well as :hover, :focus, :active,
// and disabled options for all buttons

.button-variant(@color; @background; @border) {
  color: @color;
  background-color: @background;
  border-color: @border;

  &:hover,
  &:focus,
  &.focus,
  &:active,
  &.active,
  .open > .dropdown-toggle& {
    color: @color;
    background-color: darken(@background, 10%);
        border-color: darken(@border, 12%);
  }
  &:active,
  &.active,
  .open > .dropdown-toggle& {
    background-image: none;
  }
  &.disabled,
  &[disabled],
  fieldset[disabled] & {
    &,
    &:hover,
    &:focus,
    &.focus,
    &:active,
    &.active {
      background-color: @background;
          border-color: @border;
    }
  }

  .badge {
    color: @background;
    background-color: @color;
  }
}

// Button sizes
.button-size(@padding-vertical; @padding-horizontal; @font-size; @line-height; @border-radius) {
  padding: @padding-vertical @padding-horizontal;
  font-size: @font-size;
  line-height: @line-height;
  border-radius: @border-radius;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/center-block.less
================================================
// Center-align a block level element

.center-block() {
  display: block;
  margin-left: auto;
  margin-right: auto;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/clearfix.less
================================================
// Clearfix
//
// For modern browsers
// 1. The space content is one way to avoid an Opera bug when the
//    contenteditable attribute is included anywhere else in the document.
//    Otherwise it causes space to appear at the top and bottom of elements
//    that are clearfixed.
// 2. The use of `table` rather than `block` is only necessary if using
//    `:before` to contain the top-margins of child elements.
//
// Source: http://nicolasgallagher.com/micro-clearfix-hack/

.clearfix() {
  &:before,
  &:after {
    content: " "; // 1
    display: table; // 2
  }
  &:after {
    clear: both;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/forms.less
================================================
// Form validation states
//
// Used in forms.less to generate the form validation CSS for warnings, errors,
// and successes.

.form-control-validation(@text-color: #555; @border-color: #ccc; @background-color: #f5f5f5) {
  // Color the label and help text
  .help-block,
  .control-label,
  .radio,
  .checkbox,
  .radio-inline,
  .checkbox-inline,
  &.radio label,
  &.checkbox label,
  &.radio-inline label,
  &.checkbox-inline label  {
    color: @text-color;
  }
  // Set the border and box shadow on specific inputs to match
  .form-control {
    border-color: @border-color;
    .box-shadow(inset 0 1px 1px rgba(0,0,0,.075)); // Redeclare so transitions work
    &:focus {
      border-color: darken(@border-color, 10%);
      @shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 6px lighten(@border-color, 20%);
      .box-shadow(@shadow);
    }
  }
  // Set validation states also for addons
  .input-group-addon {
    color: @text-color;
    border-color: @border-color;
    background-color: @background-color;
  }
  // Optional feedback icon
  .form-control-feedback {
    color: @text-color;
  }
}


// Form control focus state
//
// Generate a customized focus state and for any input with the specified color,
// which defaults to the `@input-border-focus` variable.
//
// We highly encourage you to not customize the default value, but instead use
// this to tweak colors on an as-needed basis. This aesthetic change is based on
// WebKit's default styles, but applicable to a wider range of browsers. Its
// usability and accessibility should be taken into account with any change.
//
// Example usage: change the default blue border and shadow to white for better
// contrast against a dark gray background.
.form-control-focus(@color: @input-border-focus) {
  @color-rgba: rgba(red(@color), green(@color), blue(@color), .6);
  &:focus {
    border-color: @color;
    outline: 0;
    .box-shadow(~"inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px @{color-rgba}");
  }
}

// Form control sizing
//
// Relative text size, padding, and border-radii changes for form controls. For
// horizontal sizing, wrap controls in the predefined grid classes. `<select>`
// element gets special love because it's special, and that's a fact!
.input-size(@input-height; @padding-vertical; @padding-horizontal; @font-size; @line-height; @border-radius) {
  height: @input-height;
  padding: @padding-vertical @padding-horizontal;
  font-size: @font-size;
  line-height: @line-height;
  border-radius: @border-radius;

  select& {
    height: @input-height;
    line-height: @input-height;
  }

  textarea&,
  select[multiple]& {
    height: auto;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/gradients.less
================================================
// Gradients

#gradient {

  // Horizontal gradient, from left to right
  //
  // Creates two color stops, start and end, by specifying a color and position for each color stop.
  // Color stops are not available in IE9 and below.
  .horizontal(@start-color: #555; @end-color: #333; @start-percent: 0%; @end-percent: 100%) {
    background-image: -webkit-linear-gradient(left, @start-color @start-percent, @end-color @end-percent); // Safari 5.1-6, Chrome 10+
    background-image: -o-linear-gradient(left, @start-color @start-percent, @end-color @end-percent); // Opera 12
    background-image: linear-gradient(to right, @start-color @start-percent, @end-color @end-percent); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
    background-repeat: repeat-x;
    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=1)",argb(@start-color),argb(@end-color))); // IE9 and down
  }

  // Vertical gradient, from top to bottom
  //
  // Creates two color stops, start and end, by specifying a color and position for each color stop.
  // Color stops are not available in IE9 and below.
  .vertical(@start-color: #555; @end-color: #333; @start-percent: 0%; @end-percent: 100%) {
    background-image: -webkit-linear-gradient(top, @start-color @start-percent, @end-color @end-percent);  // Safari 5.1-6, Chrome 10+
    background-image: -o-linear-gradient(top, @start-color @start-percent, @end-color @end-percent);  // Opera 12
    background-image: linear-gradient(to bottom, @start-color @start-percent, @end-color @end-percent); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
    background-repeat: repeat-x;
    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",argb(@start-color),argb(@end-color))); // IE9 and down
  }

  .directional(@start-color: #555; @end-color: #333; @deg: 45deg) {
    background-repeat: repeat-x;
    background-image: -webkit-linear-gradient(@deg, @start-color, @end-color); // Safari 5.1-6, Chrome 10+
    background-image: -o-linear-gradient(@deg, @start-color, @end-color); // Opera 12
    background-image: linear-gradient(@deg, @start-color, @end-color); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
  }
  .horizontal-three-colors(@start-color: #00b3ee; @mid-color: #7a43b6; @color-stop: 50%; @end-color: #c3325f) {
    background-image: -webkit-linear-gradient(left, @start-color, @mid-color @color-stop, @end-color);
    background-image: -o-linear-gradient(left, @start-color, @mid-color @color-stop, @end-color);
    background-image: linear-gradient(to right, @start-color, @mid-color @color-stop, @end-color);
    background-repeat: no-repeat;
    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=1)",argb(@start-color),argb(@end-color))); // IE9 and down, gets no color-stop at all for proper fallback
  }
  .vertical-three-colors(@start-color: #00b3ee; @mid-color: #7a43b6; @color-stop: 50%; @end-color: #c3325f) {
    background-image: -webkit-linear-gradient(@start-color, @mid-color @color-stop, @end-color);
    background-image: -o-linear-gradient(@start-color, @mid-color @color-stop, @end-color);
    background-image: linear-gradient(@start-color, @mid-color @color-stop, @end-color);
    background-repeat: no-repeat;
    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",argb(@start-color),argb(@end-color))); // IE9 and down, gets no color-stop at all for proper fallback
  }
  .radial(@inner-color: #555; @outer-color: #333) {
    background-image: -webkit-radial-gradient(circle, @inner-color, @outer-color);
    background-image: radial-gradient(circle, @inner-color, @outer-color);
    background-repeat: no-repeat;
  }
  .striped(@color: rgba(255,255,255,.15); @angle: 45deg) {
    background-image: -webkit-linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
    background-image: -o-linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
    background-image: linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/grid-framework.less
================================================
// Framework grid generation
//
// Used only by Bootstrap to generate the correct number of grid classes given
// any value of `@grid-columns`.

.make-grid-columns() {
  // Common styles for all sizes of grid columns, widths 1-12
  .col(@index) { // initial
    @item: ~".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}";
    .col((@index + 1), @item);
  }
  .col(@index, @list) when (@index =< @grid-columns) { // general; "=<" isn't a typo
    @item: ~".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}";
    .col((@index + 1), ~"@{list}, @{item}");
  }
  .col(@index, @list) when (@index > @grid-columns) { // terminal
    @{list} {
      position: relative;
      // Prevent columns from collapsing when empty
      min-height: 1px;
      // Inner gutter via padding
      padding-left:  (@grid-gutter-width / 2);
      padding-right: (@grid-gutter-width / 2);
    }
  }
  .col(1); // kickstart it
}

.float-grid-columns(@class) {
  .col(@index) { // initial
    @item: ~".col-@{class}-@{index}";
    .col((@index + 1), @item);
  }
  .col(@index, @list) when (@index =< @grid-columns) { // general
    @item: ~".col-@{class}-@{index}";
    .col((@index + 1), ~"@{list}, @{item}");
  }
  .col(@index, @list) when (@index > @grid-columns) { // terminal
    @{list} {
      float: left;
    }
  }
  .col(1); // kickstart it
}

.calc-grid-column(@index, @class, @type) when (@type = width) and (@index > 0) {
  .col-@{class}-@{index} {
    width: percentage((@index / @grid-columns));
  }
}
.calc-grid-column(@index, @class, @type) when (@type = push) and (@index > 0) {
  .col-@{class}-push-@{index} {
    left: percentage((@index / @grid-columns));
  }
}
.calc-grid-column(@index, @class, @type) when (@type = push) and (@index = 0) {
  .col-@{class}-push-0 {
    left: auto;
  }
}
.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index > 0) {
  .col-@{class}-pull-@{index} {
    right: percentage((@index / @grid-columns));
  }
}
.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index = 0) {
  .col-@{class}-pull-0 {
    right: auto;
  }
}
.calc-grid-column(@index, @class, @type) when (@type = offset) {
  .col-@{class}-offset-@{index} {
    margin-left: percentage((@index / @grid-columns));
  }
}

// Basic looping in LESS
.loop-grid-columns(@index, @class, @type) when (@index >= 0) {
  .calc-grid-column(@index, @class, @type);
  // next iteration
  .loop-grid-columns((@index - 1), @class, @type);
}

// Create grid for specific class
.make-grid(@class) {
  .float-grid-columns(@class);
  .loop-grid-columns(@grid-columns, @class, width);
  .loop-grid-columns(@grid-columns, @class, pull);
  .loop-grid-columns(@grid-columns, @class, push);
  .loop-grid-columns(@grid-columns, @class, offset);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/grid.less
================================================
// Grid system
//
// Generate semantic grid columns with these mixins.

// Centered container element
.container-fixed(@gutter: @grid-gutter-width) {
  margin-right: auto;
  margin-left: auto;
  padding-left:  (@gutter / 2);
  padding-right: (@gutter / 2);
  &:extend(.clearfix all);
}

// Creates a wrapper for a series of columns
.make-row(@gutter: @grid-gutter-width) {
  margin-left:  (@gutter / -2);
  margin-right: (@gutter / -2);
  &:extend(.clearfix all);
}

// Generate the extra small columns
.make-xs-column(@columns; @gutter: @grid-gutter-width) {
  position: relative;
  float: left;
  width: percentage((@columns / @grid-columns));
  min-height: 1px;
  padding-left:  (@gutter / 2);
  padding-right: (@gutter / 2);
}
.make-xs-column-offset(@columns) {
  margin-left: percentage((@columns / @grid-columns));
}
.make-xs-column-push(@columns) {
  left: percentage((@columns / @grid-columns));
}
.make-xs-column-pull(@columns) {
  right: percentage((@columns / @grid-columns));
}

// Generate the small columns
.make-sm-column(@columns; @gutter: @grid-gutter-width) {
  position: relative;
  min-height: 1px;
  padding-left:  (@gutter / 2);
  padding-right: (@gutter / 2);

  @media (min-width: @screen-sm-min) {
    float: left;
    width: percentage((@columns / @grid-columns));
  }
}
.make-sm-column-offset(@columns) {
  @media (min-width: @screen-sm-min) {
    margin-left: percentage((@columns / @grid-columns));
  }
}
.make-sm-column-push(@columns) {
  @media (min-width: @screen-sm-min) {
    left: percentage((@columns / @grid-columns));
  }
}
.make-sm-column-pull(@columns) {
  @media (min-width: @screen-sm-min) {
    right: percentage((@columns / @grid-columns));
  }
}

// Generate the medium columns
.make-md-column(@columns; @gutter: @grid-gutter-width) {
  position: relative;
  min-height: 1px;
  padding-left:  (@gutter / 2);
  padding-right: (@gutter / 2);

  @media (min-width: @screen-md-min) {
    float: left;
    width: percentage((@columns / @grid-columns));
  }
}
.make-md-column-offset(@columns) {
  @media (min-width: @screen-md-min) {
    margin-left: percentage((@columns / @grid-columns));
  }
}
.make-md-column-push(@columns) {
  @media (min-width: @screen-md-min) {
    left: percentage((@columns / @grid-columns));
  }
}
.make-md-column-pull(@columns) {
  @media (min-width: @screen-md-min) {
    right: percentage((@columns / @grid-columns));
  }
}

// Generate the large columns
.make-lg-column(@columns; @gutter: @grid-gutter-width) {
  position: relative;
  min-height: 1px;
  padding-left:  (@gutter / 2);
  padding-right: (@gutter / 2);

  @media (min-width: @screen-lg-min) {
    float: left;
    width: percentage((@columns / @grid-columns));
  }
}
.make-lg-column-offset(@columns) {
  @media (min-width: @screen-lg-min) {
    margin-left: percentage((@columns / @grid-columns));
  }
}
.make-lg-column-push(@columns) {
  @media (min-width: @screen-lg-min) {
    left: percentage((@columns / @grid-columns));
  }
}
.make-lg-column-pull(@columns) {
  @media (min-width: @screen-lg-min) {
    right: percentage((@columns / @grid-columns));
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/hide-text.less
================================================
// CSS image replacement
//
// Heads up! v3 launched with with only `.hide-text()`, but per our pattern for
// mixins being reused as classes with the same name, this doesn't hold up. As
// of v3.0.1 we have added `.text-hide()` and deprecated `.hide-text()`.
//
// Source: https://github.com/h5bp/html5-boilerplate/commit/aa0396eae757

// Deprecated as of v3.0.1 (will be removed in v4)
.hide-text() {
  font: ~"0/0" a;
  color: transparent;
  text-shadow: none;
  background-color: transparent;
  border: 0;
}

// New mixin to use as of v3.0.1
.text-hide() {
  .hide-text();
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/image.less
================================================
// Image Mixins
// - Responsive image
// - Retina image


// Responsive image
//
// Keep images from scaling beyond the width of their parents.
.img-responsive(@display: block) {
  display: @display;
  max-width: 100%; // Part 1: Set a maximum relative to the parent
  height: auto; // Part 2: Scale the height according to the width, otherwise you get stretching
}


// Retina image
//
// Short retina mixin for setting background-image and -size. Note that the
// spelling of `min--moz-device-pixel-ratio` is intentional.
.img-retina(@file-1x; @file-2x; @width-1x; @height-1x) {
  background-image: url("@{file-1x}");

  @media
  only screen and (-webkit-min-device-pixel-ratio: 2),
  only screen and (   min--moz-device-pixel-ratio: 2),
  only screen and (     -o-min-device-pixel-ratio: 2/1),
  only screen and (        min-device-pixel-ratio: 2),
  only screen and (                min-resolution: 192dpi),
  only screen and (                min-resolution: 2dppx) {
    background-image: url("@{file-2x}");
    background-size: @width-1x @height-1x;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/labels.less
================================================
// Labels

.label-variant(@color) {
  background-color: @color;

  &[href] {
    &:hover,
    &:focus {
      background-color: darken(@color, 10%);
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/list-group.less
================================================
// List Groups

.list-group-item-variant(@state; @background; @color) {
  .list-group-item-@{state} {
    color: @color;
    background-color: @background;

    a& {
      color: @color;

      .list-group-item-heading {
        color: inherit;
      }

      &:hover,
      &:focus {
        color: @color;
        background-color: darken(@background, 5%);
      }
      &.active,
      &.active:hover,
      &.active:focus {
        color: #fff;
        background-color: @color;
        border-color: @color;
      }
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/nav-divider.less
================================================
// Horizontal dividers
//
// Dividers (basically an hr) within dropdowns and nav lists

.nav-divider(@color: #e5e5e5) {
  height: 1px;
  margin: ((@line-height-computed / 2) - 1) 0;
  overflow: hidden;
  background-color: @color;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/nav-vertical-align.less
================================================
// Navbar vertical align
//
// Vertically center elements in the navbar.
// Example: an element has a height of 30px, so write out `.navbar-vertical-align(30px);` to calculate the appropriate top margin.

.navbar-vertical-align(@element-height) {
  margin-top: ((@navbar-height - @element-height) / 2);
  margin-bottom: ((@navbar-height - @element-height) / 2);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/opacity.less
================================================
// Opacity

.opacity(@opacity) {
  opacity: @opacity;
  // IE8 filter
  @opacity-ie: (@opacity * 100);
  filter: ~"alpha(opacity=@{opacity-ie})";
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/pagination.less
================================================
// Pagination

.pagination-size(@padding-vertical; @padding-horizontal; @font-size; @border-radius) {
  > li {
    > a,
    > span {
      padding: @padding-vertical @padding-horizontal;
      font-size: @font-size;
    }
    &:first-child {
      > a,
      > span {
        .border-left-radius(@border-radius);
      }
    }
    &:last-child {
      > a,
      > span {
        .border-right-radius(@border-radius);
      }
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/panels.less
================================================
// Panels

.panel-variant(@border; @heading-text-color; @heading-bg-color; @heading-border) {
  border-color: @border;

  & > .panel-heading {
    color: @heading-text-color;
    background-color: @heading-bg-color;
    border-color: @heading-border;

    + .panel-collapse > .panel-body {
      border-top-color: @border;
    }
    .badge {
      color: @heading-bg-color;
      background-color: @heading-text-color;
    }
  }
  & > .panel-footer {
    + .panel-collapse > .panel-body {
      border-bottom-color: @border;
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/progress-bar.less
================================================
// Progress bars

.progress-bar-variant(@color) {
  background-color: @color;

  // Deprecated parent class requirement as of v3.2.0
  .progress-striped & {
    #gradient > .striped();
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/reset-filter.less
================================================
// Reset filters for IE
//
// When you need to remove a gradient background, do not forget to use this to reset
// the IE filter for IE9 and below.

.reset-filter() {
  filter: e(%("progid:DXImageTransform.Microsoft.gradient(enabled = false)"));
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/resize.less
================================================
// Resize anything

.resizable(@direction) {
  resize: @direction; // Options: horizontal, vertical, both
  overflow: auto; // Per CSS3 UI, `resize` only applies when `overflow` isn't `visible`
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/responsive-visibility.less
================================================
// Responsive utilities

//
// More easily include all the states for responsive-utilities.less.
.responsive-visibility() {
  display: block !important;
  table&  { display: table; }
  tr&     { display: table-row !important; }
  th&,
  td&     { display: table-cell !important; }
}

.responsive-invisibility() {
  display: none !important;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/size.less
================================================
// Sizing shortcuts

.size(@width; @height) {
  width: @width;
  height: @height;
}

.square(@size) {
  .size(@size; @size);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/tab-focus.less
================================================
// WebKit-style focus

.tab-focus() {
  // Default
  outline: thin dotted;
  // WebKit
  outline: 5px auto -webkit-focus-ring-color;
  outline-offset: -2px;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/table-row.less
================================================
// Tables

.table-row-variant(@state; @background) {
  // Exact selectors below required to override `.table-striped` and prevent
  // inheritance to nested tables.
  .table > thead > tr,
  .table > tbody > tr,
  .table > tfoot > tr {
    > td.@{state},
    > th.@{state},
    &.@{state} > td,
    &.@{state} > th {
      background-color: @background;
    }
  }

  // Hover states for `.table-hover`
  // Note: this is not available for cells or rows within `thead` or `tfoot`.
  .table-hover > tbody > tr {
    > td.@{state}:hover,
    > th.@{state}:hover,
    &.@{state}:hover > td,
    &:hover > .@{state},
    &.@{state}:hover > th {
      background-color: darken(@background, 5%);
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/text-emphasis.less
================================================
// Typography

.text-emphasis-variant(@color) {
  color: @color;
  a&:hover {
    color: darken(@color, 10%);
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/text-overflow.less
================================================
// Text overflow
// Requires inline-block or block for proper styling

.text-overflow() {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins/vendor-prefixes.less
================================================
// Vendor Prefixes
//
// All vendor mixins are deprecated as of v3.2.0 due to the introduction of
// Autoprefixer in our Gruntfile. They will be removed in v4.

// - Animations
// - Backface visibility
// - Box shadow
// - Box sizing
// - Content columns
// - Hyphens
// - Placeholder text
// - Transformations
// - Transitions
// - User Select


// Animations
.animation(@animation) {
  -webkit-animation: @animation;
       -o-animation: @animation;
          animation: @animation;
}
.animation-name(@name) {
  -webkit-animation-name: @name;
          animation-name: @name;
}
.animation-duration(@duration) {
  -webkit-animation-duration: @duration;
          animation-duration: @duration;
}
.animation-timing-function(@timing-function) {
  -webkit-animation-timing-function: @timing-function;
          animation-timing-function: @timing-function;
}
.animation-delay(@delay) {
  -webkit-animation-delay: @delay;
          animation-delay: @delay;
}
.animation-iteration-count(@iteration-count) {
  -webkit-animation-iteration-count: @iteration-count;
          animation-iteration-count: @iteration-count;
}
.animation-direction(@direction) {
  -webkit-animation-direction: @direction;
          animation-direction: @direction;
}
.animation-fill-mode(@fill-mode) {
  -webkit-animation-fill-mode: @fill-mode;
          animation-fill-mode: @fill-mode;
}

// Backface visibility
// Prevent browsers from flickering when using CSS 3D transforms.
// Default value is `visible`, but can be changed to `hidden`

.backface-visibility(@visibility){
  -webkit-backface-visibility: @visibility;
     -moz-backface-visibility: @visibility;
          backface-visibility: @visibility;
}

// Drop shadows
//
// Note: Deprecated `.box-shadow()` as of v3.1.0 since all of Bootstrap's
// supported browsers that have box shadow capabilities now support it.

.box-shadow(@shadow) {
  -webkit-box-shadow: @shadow; // iOS <4.3 & Android <4.1
          box-shadow: @shadow;
}

// Box sizing
.box-sizing(@boxmodel) {
  -webkit-box-sizing: @boxmodel;
     -moz-box-sizing: @boxmodel;
          box-sizing: @boxmodel;
}

// CSS3 Content Columns
.content-columns(@column-count; @column-gap: @grid-gutter-width) {
  -webkit-column-count: @column-count;
     -moz-column-count: @column-count;
          column-count: @column-count;
  -webkit-column-gap: @column-gap;
     -moz-column-gap: @column-gap;
          column-gap: @column-gap;
}

// Optional hyphenation
.hyphens(@mode: auto) {
  word-wrap: break-word;
  -webkit-hyphens: @mode;
     -moz-hyphens: @mode;
      -ms-hyphens: @mode; // IE10+
       -o-hyphens: @mode;
          hyphens: @mode;
}

// Placeholder text
.placeholder(@color: @input-color-placeholder) {
  // Firefox
  &::-moz-placeholder {
    color: @color;
    opacity: 1; // Override Firefox's unusual default opacity; see https://github.com/twbs/bootstrap/pull/11526
  }
  &:-ms-input-placeholder { color: @color; } // Internet Explorer 10+
  &::-webkit-input-placeholder  { color: @color; } // Safari and Chrome
}

// Transformations
.scale(@ratio) {
  -webkit-transform: scale(@ratio);
      -ms-transform: scale(@ratio); // IE9 only
       -o-transform: scale(@ratio);
          transform: scale(@ratio);
}
.scale(@ratioX; @ratioY) {
  -webkit-transform: scale(@ratioX, @ratioY);
      -ms-transform: scale(@ratioX, @ratioY); // IE9 only
       -o-transform: scale(@ratioX, @ratioY);
          transform: scale(@ratioX, @ratioY);
}
.scaleX(@ratio) {
  -webkit-transform: scaleX(@ratio);
      -ms-transform: scaleX(@ratio); // IE9 only
       -o-transform: scaleX(@ratio);
          transform: scaleX(@ratio);
}
.scaleY(@ratio) {
  -webkit-transform: scaleY(@ratio);
      -ms-transform: scaleY(@ratio); // IE9 only
       -o-transform: scaleY(@ratio);
          transform: scaleY(@ratio);
}
.skew(@x; @y) {
  -webkit-transform: skewX(@x) skewY(@y);
      -ms-transform: skewX(@x) skewY(@y); // See https://github.com/twbs/bootstrap/issues/4885; IE9+
       -o-transform: skewX(@x) skewY(@y);
          transform: skewX(@x) skewY(@y);
}
.translate(@x; @y) {
  -webkit-transform: translate(@x, @y);
      -ms-transform: translate(@x, @y); // IE9 only
       -o-transform: translate(@x, @y);
          transform: translate(@x, @y);
}
.translate3d(@x; @y; @z) {
  -webkit-transform: translate3d(@x, @y, @z);
          transform: translate3d(@x, @y, @z);
}
.rotate(@degrees) {
  -webkit-transform: rotate(@degrees);
      -ms-transform: rotate(@degrees); // IE9 only
       -o-transform: rotate(@degrees);
          transform: rotate(@degrees);
}
.rotateX(@degrees) {
  -webkit-transform: rotateX(@degrees);
      -ms-transform: rotateX(@degrees); // IE9 only
       -o-transform: rotateX(@degrees);
          transform: rotateX(@degrees);
}
.rotateY(@degrees) {
  -webkit-transform: rotateY(@degrees);
      -ms-transform: rotateY(@degrees); // IE9 only
       -o-transform: rotateY(@degrees);
          transform: rotateY(@degrees);
}
.perspective(@perspective) {
  -webkit-perspective: @perspective;
     -moz-perspective: @perspective;
          perspective: @perspective;
}
.perspective-origin(@perspective) {
  -webkit-perspective-origin: @perspective;
     -moz-perspective-origin: @perspective;
          perspective-origin: @perspective;
}
.transform-origin(@origin) {
  -webkit-transform-origin: @origin;
     -moz-transform-origin: @origin;
      -ms-transform-origin: @origin; // IE9 only
          transform-origin: @origin;
}


// Transitions

.transition(@transition) {
  -webkit-transition: @transition;
       -o-transition: @transition;
          transition: @transition;
}
.transition-property(@transition-property) {
  -webkit-transition-property: @transition-property;
          transition-property: @transition-property;
}
.transition-delay(@transition-delay) {
  -webkit-transition-delay: @transition-delay;
          transition-delay: @transition-delay;
}
.transition-duration(@transition-duration) {
  -webkit-transition-duration: @transition-duration;
          transition-duration: @transition-duration;
}
.transition-timing-function(@timing-function) {
  -webkit-transition-timing-function: @timing-function;
          transition-timing-function: @timing-function;
}
.transition-transform(@transition) {
  -webkit-transition: -webkit-transform @transition;
     -moz-transition: -moz-transform @transition;
       -o-transition: -o-transform @transition;
          transition: transform @transition;
}


// User select
// For selecting text on the page

.user-select(@select) {
  -webkit-user-select: @select;
     -moz-user-select: @select;
      -ms-user-select: @select; // IE10+
          user-select: @select;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/mixins.less
================================================
// Mixins
// --------------------------------------------------

// Utilities
@import "mixins/hide-text.less";
@import "mixins/opacity.less";
@import "mixins/image.less";
@import "mixins/labels.less";
@import "mixins/reset-filter.less";
@import "mixins/resize.less";
@import "mixins/responsive-visibility.less";
@import "mixins/size.less";
@import "mixins/tab-focus.less";
@import "mixins/text-emphasis.less";
@import "mixins/text-overflow.less";
@import "mixins/vendor-prefixes.less";

// Components
@import "mixins/alerts.less";
@import "mixins/buttons.less";
@import "mixins/panels.less";
@import "mixins/pagination.less";
@import "mixins/list-group.less";
@import "mixins/nav-divider.less";
@import "mixins/forms.less";
@import "mixins/progress-bar.less";
@import "mixins/table-row.less";

// Skins
@import "mixins/background-variant.less";
@import "mixins/border-radius.less";
@import "mixins/gradients.less";

// Layout
@import "mixins/clearfix.less";
@import "mixins/center-block.less";
@import "mixins/nav-vertical-align.less";
@import "mixins/grid-framework.less";
@import "mixins/grid.less";


================================================
FILE: examples/libraries/fmt/doc/bootstrap/modals.less
================================================
//
// Modals
// --------------------------------------------------

// .modal-open      - body class for killing the scroll
// .modal           - container to scroll within
// .modal-dialog    - positioning shell for the actual modal
// .modal-content   - actual modal w/ bg and corners and shit

// Kill the scroll on the body
.modal-open {
  overflow: hidden;
}

// Container that the modal scrolls within
.modal {
  display: none;
  overflow: hidden;
  position: fixed;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  z-index: @zindex-modal;
  -webkit-overflow-scrolling: touch;

  // Prevent Chrome on Windows from adding a focus outline. For details, see
  // https://github.com/twbs/bootstrap/pull/10951.
  outline: 0;

  // When fading in the modal, animate it to slide down
  &.fade .modal-dialog {
    .translate(0, -25%);
    .transition-transform(~"0.3s ease-out");
  }
  &.in .modal-dialog { .translate(0, 0) }
}
.modal-open .modal {
  overflow-x: hidden;
  overflow-y: auto;
}

// Shell div to position the modal with bottom padding
.modal-dialog {
  position: relative;
  width: auto;
  margin: 10px;
}

// Actual modal
.modal-content {
  position: relative;
  background-color: @modal-content-bg;
  border: 1px solid @modal-content-fallback-border-color; //old browsers fallback (ie8 etc)
  border: 1px solid @modal-content-border-color;
  border-radius: @border-radius-large;
  .box-shadow(0 3px 9px rgba(0,0,0,.5));
  background-clip: padding-box;
  // Remove focus outline from opened modal
  outline: 0;
}

// Modal background
.modal-backdrop {
  position: fixed;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  z-index: @zindex-modal-background;
  background-color: @modal-backdrop-bg;
  // Fade for backdrop
  &.fade { .opacity(0); }
  &.in { .opacity(@modal-backdrop-opacity); }
}

// Modal header
// Top section of the modal w/ title and dismiss
.modal-header {
  padding: @modal-title-padding;
  border-bottom: 1px solid @modal-header-border-color;
  min-height: (@modal-title-padding + @modal-title-line-height);
}
// Close icon
.modal-header .close {
  margin-top: -2px;
}

// Title text within header
.modal-title {
  margin: 0;
  line-height: @modal-title-line-height;
}

// Modal body
// Where all modal content resides (sibling of .modal-header and .modal-footer)
.modal-body {
  position: relative;
  padding: @modal-inner-padding;
}

// Footer (for actions)
.modal-footer {
  padding: @modal-inner-padding;
  text-align: right; // right align buttons
  border-top: 1px solid @modal-footer-border-color;
  &:extend(.clearfix all); // clear it in case folks use .pull-* classes on buttons

  // Properly space out buttons
  .btn + .btn {
    margin-left: 5px;
    margin-bottom: 0; // account for input[type="submit"] which gets the bottom margin like all other inputs
  }
  // but override that for button groups
  .btn-group .btn + .btn {
    margin-left: -1px;
  }
  // and override it for block buttons as well
  .btn-block + .btn-block {
    margin-left: 0;
  }
}

// Measure scrollbar width for padding body during modal show/hide
.modal-scrollbar-measure {
  position: absolute;
  top: -9999px;
  width: 50px;
  height: 50px;
  overflow: scroll;
}

// Scale up the modal
@media (min-width: @screen-sm-min) {
  // Automatically set modal's width for larger viewports
  .modal-dialog {
    width: @modal-md;
    margin: 30px auto;
  }
  .modal-content {
    .box-shadow(0 5px 15px rgba(0,0,0,.5));
  }

  // Modal sizes
  .modal-sm { width: @modal-sm; }
}

@media (min-width: @screen-md-min) {
  .modal-lg { width: @modal-lg; }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/navbar.less
================================================
//
// Navbars
// --------------------------------------------------


// Wrapper and base class
//
// Provide a static navbar from which we expand to create full-width, fixed, and
// other navbar variations.

.navbar {
  position: relative;
  min-height: @navbar-height; // Ensure a navbar always shows (e.g., without a .navbar-brand in collapsed mode)
  margin-bottom: @navbar-margin-bottom;
  border: 1px solid transparent;

  // Prevent floats from breaking the navbar
  &:extend(.clearfix all);

  @media (min-width: @grid-float-breakpoint) {
    border-radius: @navbar-border-radius;
  }
}


// Navbar heading
//
// Groups `.navbar-brand` and `.navbar-toggle` into a single component for easy
// styling of responsive aspects.

.navbar-header {
  &:extend(.clearfix all);

  @media (min-width: @grid-float-breakpoint) {
    float: left;
  }
}


// Navbar collapse (body)
//
// Group your navbar content into this for easy collapsing and expanding across
// various device sizes. By default, this content is collapsed when <768px, but
// will expand past that for a horizontal display.
//
// To start (on mobile devices) the navbar links, forms, and buttons are stacked
// vertically and include a `max-height` to overflow in case you have too much
// content for the user's viewport.

.navbar-collapse {
  overflow-x: visible;
  padding-right: @navbar-padding-horizontal;
  padding-left:  @navbar-padding-horizontal;
  border-top: 1px solid transparent;
  box-shadow: inset 0 1px 0 rgba(255,255,255,.1);
  &:extend(.clearfix all);
  -webkit-overflow-scrolling: touch;

  &.in {
    overflow-y: auto;
  }

  @media (min-width: @grid-float-breakpoint) {
    width: auto;
    border-top: 0;
    box-shadow: none;

    &.collapse {
      display: block !important;
      height: auto !important;
      padding-bottom: 0; // Override default setting
      overflow: visible !important;
    }

    &.in {
      overflow-y: visible;
    }

    // Undo the collapse side padding for navbars with containers to ensure
    // alignment of right-aligned contents.
    .navbar-fixed-top &,
    .navbar-static-top &,
    .navbar-fixed-bottom & {
      padding-left: 0;
      padding-right: 0;
    }
  }
}

.navbar-fixed-top,
.navbar-fixed-bottom {
  .navbar-collapse {
    max-height: @navbar-collapse-max-height;

    @media (max-device-width: @screen-xs-min) and (orientation: landscape) {
      max-height: 200px;
    }
  }
}


// Both navbar header and collapse
//
// When a container is present, change the behavior of the header and collapse.

.tb-container,
.container-fluid {
  > .navbar-header,
  > .navbar-collapse {
    margin-right: -@navbar-padding-horizontal;
    margin-left:  -@navbar-padding-horizontal;

    @media (min-width: @grid-float-breakpoint) {
      margin-right: 0;
      margin-left:  0;
    }
  }
}


//
// Navbar alignment options
//
// Display the navbar across the entirety of the page or fixed it to the top or
// bottom of the page.

// Static top (unfixed, but 100% wide) navbar
.navbar-static-top {
  z-index: @zindex-navbar;
  border-width: 0 0 1px;

  @media (min-width: @grid-float-breakpoint) {
    border-radius: 0;
  }
}

// Fix the top/bottom navbars when screen real estate supports it
.navbar-fixed-top,
.navbar-fixed-bottom {
  position: fixed;
  right: 0;
  left: 0;
  z-index: @zindex-navbar-fixed;

  // Undo the rounded corners
  @media (min-width: @grid-float-breakpoint) {
    border-radius: 0;
  }
}
.navbar-fixed-top {
  top: 0;
  border-width: 0 0 1px;
}
.navbar-fixed-bottom {
  bottom: 0;
  margin-bottom: 0; // override .navbar defaults
  border-width: 1px 0 0;
}


// Brand/project name

.navbar-brand {
  float: left;
  padding: @navbar-padding-vertical @navbar-padding-horizontal;
  font-size: @font-size-large;
  line-height: @line-height-computed;
  height: @navbar-height;

  &:hover,
  &:focus {
    text-decoration: none;
  }

  > img {
    display: block;
  }

  @media (min-width: @grid-float-breakpoint) {
    .navbar > .tb-container &,
    .navbar > .container-fluid & {
      margin-left: -@navbar-padding-horizontal;
    }
  }
}


// Navbar toggle
//
// Custom button for toggling the `.navbar-collapse`, powered by the collapse
// JavaScript plugin.

.navbar-toggle {
  position: relative;
  float: right;
  margin-right: @navbar-padding-horizontal;
  padding: 9px 10px;
  .navbar-vertical-align(34px);
  background-color: transparent;
  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
  border: 1px solid transparent;
  border-radius: @border-radius-base;

  // We remove the `outline` here, but later compensate by attaching `:hover`
  // styles to `:focus`.
  &:focus {
    outline: 0;
  }

  // Bars
  .icon-bar {
    display: block;
    width: 22px;
    height: 2px;
    border-radius: 1px;
  }
  .icon-bar + .icon-bar {
    margin-top: 4px;
  }

  @media (min-width: @grid-float-breakpoint) {
    display: none;
  }
}


// Navbar nav links
//
// Builds on top of the `.nav` components with its own modifier class to make
// the nav the full height of the horizontal nav (above 768px).

.navbar-nav {
  margin: (@navbar-padding-vertical / 2) -@navbar-padding-horizontal;

  > li > a {
    padding-top:    10px;
    padding-bottom: 10px;
    line-height: @line-height-computed;
  }

  @media (max-width: @grid-float-breakpoint-max) {
    // Dropdowns get custom display when collapsed
    .open .dropdown-menu {
      position: static;
      float: none;
      width: auto;
      margin-top: 0;
      background-color: transparent;
      border: 0;
      box-shadow: none;
      > li > a,
      .dropdown-header {
        padding: 5px 15px 5px 25px;
      }
      > li > a {
        line-height: @line-height-computed;
        &:hover,
        &:focus {
          background-image: none;
        }
      }
    }
  }

  // Uncollapse the nav
  @media (min-width: @grid-float-breakpoint) {
    float: left;
    margin: 0;

    > li {
      float: left;
      > a {
        padding-top:    @navbar-padding-vertical;
        padding-bottom: @navbar-padding-vertical;
      }
    }
  }
}


// Navbar form
//
// Extension of the `.form-inline` with some extra flavor for optimum display in
// our navbars.

.navbar-form {
  margin-left: -@navbar-padding-horizontal;
  margin-right: -@navbar-padding-horizontal;
  padding: 10px @navbar-padding-horizontal;
  border-top: 1px solid transparent;
  border-bottom: 1px solid transparent;
  @shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
  .box-shadow(@shadow);

  // Mixin behavior for optimum display
  .form-inline();

  .form-group {
    @media (max-width: @grid-float-breakpoint-max) {
      margin-bottom: 5px;

      &:last-child {
        margin-bottom: 0;
      }
    }
  }

  // Vertically center in expanded, horizontal navbar
  .navbar-vertical-align(@input-height-base);

  // Undo 100% width for pull classes
  @media (min-width: @grid-float-breakpoint) {
    width: auto;
    border: 0;
    margin-left: 0;
    margin-right: 0;
    padding-top: 0;
    padding-bottom: 0;
    .box-shadow(none);
  }
}


// Dropdown menus

// Menu position and menu carets
.navbar-nav > li > .dropdown-menu {
  margin-top: 0;
  .border-top-radius(0);
}
// Menu position and menu caret support for dropups via extra dropup class
.navbar-fixed-bottom .navbar-nav > li > .dropdown-menu {
  margin-bottom: 0;
  .border-top-radius(@navbar-border-radius);
  .border-bottom-radius(0);
}


// Buttons in navbars
//
// Vertically center a button within a navbar (when *not* in a form).

.navbar-btn {
  .navbar-vertical-align(@input-height-base);

  &.btn-sm {
    .navbar-vertical-align(@input-height-small);
  }
  &.btn-xs {
    .navbar-vertical-align(22);
  }
}


// Text in navbars
//
// Add a class to make any element properly align itself vertically within the navbars.

.navbar-text {
  .navbar-vertical-align(@line-height-computed);

  @media (min-width: @grid-float-breakpoint) {
    float: left;
    margin-left: @navbar-padding-horizontal;
    margin-right: @navbar-padding-horizontal;
  }
}


// Component alignment
//
// Repurpose the pull utilities as their own navbar utilities to avoid specificity
// issues with parents and chaining. Only do this when the navbar is uncollapsed
// though so that navbar contents properly stack and align in mobile.
//
// Declared after the navbar components to ensure more specificity on the margins.

@media (min-width: @grid-float-breakpoint) {
  .navbar-left  { .pull-left(); }
  .navbar-right {
    .pull-right();
    margin-right: -@navbar-padding-horizontal;

    ~ .navbar-right {
      margin-right: 0;
    }
  }
}


// Alternate navbars
// --------------------------------------------------

// Default navbar
.navbar-default {
  background-color: @navbar-default-bg;
  border-color: @navbar-default-border;

  .navbar-brand {
    color: @navbar-default-brand-color;
    &:hover,
    &:focus {
      color: @navbar-default-brand-hover-color;
      background-color: @navbar-default-brand-hover-bg;
    }
  }

  .navbar-text {
    color: @navbar-default-color;
  }

  .navbar-nav {
    > li > a {
      color: @navbar-default-link-color;

      &:hover,
      &:focus {
        color: @navbar-default-link-hover-color;
        background-color: @navbar-default-link-hover-bg;
      }
    }
    > .active > a {
      &,
      &:hover,
      &:focus {
        color: @navbar-default-link-active-color;
        background-color: @navbar-default-link-active-bg;
      }
    }
    > .disabled > a {
      &,
      &:hover,
      &:focus {
        color: @navbar-default-link-disabled-color;
        background-color: @navbar-default-link-disabled-bg;
      }
    }
  }

  .navbar-toggle {
    border-color: @navbar-default-toggle-border-color;
    &:hover,
    &:focus {
      background-color: @navbar-default-toggle-hover-bg;
    }
    .icon-bar {
      background-color: @navbar-default-toggle-icon-bar-bg;
    }
  }

  .navbar-collapse,
  .navbar-form {
    border-color: @navbar-default-border;
  }

  // Dropdown menu items
  .navbar-nav {
    // Remove background color from open dropdown
    > .open > a {
      &,
      &:hover,
      &:focus {
        background-color: @navbar-default-link-active-bg;
        color: @navbar-default-link-active-color;
      }
    }

    @media (max-width: @grid-float-breakpoint-max) {
      // Dropdowns get custom display when collapsed
      .open .dropdown-menu {
        > li > a {
          color: @navbar-default-link-color;
          &:hover,
          &:focus {
            color: @navbar-default-link-hover-color;
            background-color: @navbar-default-link-hover-bg;
          }
        }
        > .active > a {
          &,
          &:hover,
          &:focus {
            color: @navbar-default-link-active-color;
            background-color: @navbar-default-link-active-bg;
          }
        }
        > .disabled > a {
          &,
          &:hover,
          &:focus {
            color: @navbar-default-link-disabled-color;
            background-color: @navbar-default-link-disabled-bg;
          }
        }
      }
    }
  }


  // Links in navbars
  //
  // Add a class to ensure links outside the navbar nav are colored correctly.

  .navbar-link {
    color: @navbar-default-link-color;
    &:hover {
      color: @navbar-default-link-hover-color;
    }
  }

  .btn-link {
    color: @navbar-default-link-color;
    &:hover,
    &:focus {
      color: @navbar-default-link-hover-color;
    }
    &[disabled],
    fieldset[disabled] & {
      &:hover,
      &:focus {
        color: @navbar-default-link-disabled-color;
      }
    }
  }
}

// Inverse navbar

.navbar-inverse {
  background-color: @navbar-inverse-bg;
  border-color: @navbar-inverse-border;

  .navbar-brand {
    color: @navbar-inverse-brand-color;
    &:hover,
    &:focus {
      color: @navbar-inverse-brand-hover-color;
      background-color: @navbar-inverse-brand-hover-bg;
    }
  }

  .navbar-text {
    color: @navbar-inverse-color;
  }

  .navbar-nav {
    > li > a {
      color: @navbar-inverse-link-color;

      &:hover,
      &:focus {
        color: @navbar-inverse-link-hover-color;
        background-color: @navbar-inverse-link-hover-bg;
      }
    }
    > .active > a {
      &,
      &:hover,
      &:focus {
        color: @navbar-inverse-link-active-color;
        background-color: @navbar-inverse-link-active-bg;
      }
    }
    > .disabled > a {
      &,
      &:hover,
      &:focus {
        color: @navbar-inverse-link-disabled-color;
        background-color: @navbar-inverse-link-disabled-bg;
      }
    }
  }

  // Darken the responsive nav toggle
  .navbar-toggle {
    border-color: @navbar-inverse-toggle-border-color;
    &:hover,
    &:focus {
      background-color: @navbar-inverse-toggle-hover-bg;
    }
    .icon-bar {
      background-color: @navbar-inverse-toggle-icon-bar-bg;
    }
  }

  .navbar-collapse,
  .navbar-form {
    border-color: darken(@navbar-inverse-bg, 7%);
  }

  // Dropdowns
  .navbar-nav {
    > .open > a {
      &,
      &:hover,
      &:focus {
        background-color: @navbar-inverse-link-active-bg;
        color: @navbar-inverse-link-active-color;
      }
    }

    @media (max-width: @grid-float-breakpoint-max) {
      // Dropdowns get custom display
      .open .dropdown-menu {
        > .dropdown-header {
          border-color: @navbar-inverse-border;
        }
        .divider {
          background-color: @navbar-inverse-border;
        }
        > li > a {
          color: @navbar-inverse-link-color;
          &:hover,
          &:focus {
            color: @navbar-inverse-link-hover-color;
            background-color: @navbar-inverse-link-hover-bg;
          }
        }
        > .active > a {
          &,
          &:hover,
          &:focus {
            color: @navbar-inverse-link-active-color;
            background-color: @navbar-inverse-link-active-bg;
          }
        }
        > .disabled > a {
          &,
          &:hover,
          &:focus {
            color: @navbar-inverse-link-disabled-color;
            background-color: @navbar-inverse-link-disabled-bg;
          }
        }
      }
    }
  }

  .navbar-link {
    color: @navbar-inverse-link-color;
    &:hover {
      color: @navbar-inverse-link-hover-color;
    }
  }

  .btn-link {
    color: @navbar-inverse-link-color;
    &:hover,
    &:focus {
      color: @navbar-inverse-link-hover-color;
    }
    &[disabled],
    fieldset[disabled] & {
      &:hover,
      &:focus {
        color: @navbar-inverse-link-disabled-color;
      }
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/navs.less
================================================
//
// Navs
// --------------------------------------------------


// Base class
// --------------------------------------------------

.nav {
  margin-bottom: 0;
  padding-left: 0; // Override default ul/ol
  list-style: none;
  &:extend(.clearfix all);

  > li {
    position: relative;
    display: block;

    > a {
      position: relative;
      display: block;
      padding: @nav-link-padding;
      &:hover,
      &:focus {
        text-decoration: none;
        background-color: @nav-link-hover-bg;
      }
    }

    // Disabled state sets text to gray and nukes hover/tab effects
    &.disabled > a {
      color: @nav-disabled-link-color;

      &:hover,
      &:focus {
        color: @nav-disabled-link-hover-color;
        text-decoration: none;
        background-color: transparent;
        cursor: @cursor-disabled;
      }
    }
  }

  // Open dropdowns
  .open > a {
    &,
    &:hover,
    &:focus {
      background-color: @nav-link-hover-bg;
      border-color: @link-color;
    }
  }

  // Nav dividers (deprecated with v3.0.1)
  //
  // This should have been removed in v3 with the dropping of `.nav-list`, but
  // we missed it. We don't currently support this anywhere, but in the interest
  // of maintaining backward compatibility in case you use it, it's deprecated.
  .nav-divider {
    .nav-divider();
  }

  // Prevent IE8 from misplacing imgs
  //
  // See https://github.com/h5bp/html5-boilerplate/issues/984#issuecomment-3985989
  > li > a > img {
    max-width: none;
  }
}


// Tabs
// -------------------------

// Give the tabs something to sit on
.nav-tabs {
  border-bottom: 1px solid @nav-tabs-border-color;
  > li {
    float: left;
    // Make the list-items overlay the bottom border
    margin-bottom: -1px;

    // Actual tabs (as links)
    > a {
      margin-right: 2px;
      line-height: @line-height-base;
      border: 1px solid transparent;
      border-radius: @border-radius-base @border-radius-base 0 0;
      &:hover {
        border-color: @nav-tabs-link-hover-border-color @nav-tabs-link-hover-border-color @nav-tabs-border-color;
      }
    }

    // Active state, and its :hover to override normal :hover
    &.active > a {
      &,
      &:hover,
      &:focus {
        color: @nav-tabs-active-link-hover-color;
        background-color: @nav-tabs-active-link-hover-bg;
        border: 1px solid @nav-tabs-active-link-hover-border-color;
        border-bottom-color: transparent;
        cursor: default;
      }
    }
  }
  // pulling this in mainly for less shorthand
  &.nav-justified {
    .nav-justified();
    .nav-tabs-justified();
  }
}


// Pills
// -------------------------
.nav-pills {
  > li {
    float: left;

    // Links rendered as pills
    > a {
      border-radius: @nav-pills-border-radius;
    }
    + li {
      margin-left: 2px;
    }

    // Active state
    &.active > a {
      &,
      &:hover,
      &:focus {
        color: @nav-pills-active-link-hover-color;
        background-color: @nav-pills-active-link-hover-bg;
      }
    }
  }
}


// Stacked pills
.nav-stacked {
  > li {
    float: none;
    + li {
      margin-top: 2px;
      margin-left: 0; // no need for this gap between nav items
    }
  }
}


// Nav variations
// --------------------------------------------------

// Justified nav links
// -------------------------

.nav-justified {
  width: 100%;

  > li {
    float: none;
    > a {
      text-align: center;
      margin-bottom: 5px;
    }
  }

  > .dropdown .dropdown-menu {
    top: auto;
    left: auto;
  }

  @media (min-width: @screen-sm-min) {
    > li {
      display: table-cell;
      width: 1%;
      > a {
        margin-bottom: 0;
      }
    }
  }
}

// Move borders to anchors instead of bottom of list
//
// Mixin for adding on top the shared `.nav-justified` styles for our tabs
.nav-tabs-justified {
  border-bottom: 0;

  > li > a {
    // Override margin from .nav-tabs
    margin-right: 0;
    border-radius: @border-radius-base;
  }

  > .active > a,
  > .active > a:hover,
  > .active > a:focus {
    border: 1px solid @nav-tabs-justified-link-border-color;
  }

  @media (min-width: @screen-sm-min) {
    > li > a {
      border-bottom: 1px solid @nav-tabs-justified-link-border-color;
      border-radius: @border-radius-base @border-radius-base 0 0;
    }
    > .active > a,
    > .active > a:hover,
    > .active > a:focus {
      border-bottom-color: @nav-tabs-justified-active-link-border-color;
    }
  }
}


// Tabbable tabs
// -------------------------

// Hide tabbable panes to start, show them when `.active`
.tab-content {
  > .tab-pane {
    display: none;
  }
  > .active {
    display: block;
  }
}


// Dropdowns
// -------------------------

// Specific dropdowns
.nav-tabs .dropdown-menu {
  // make dropdown border overlap tab border
  margin-top: -1px;
  // Remove the top rounded corners here since there is a hard edge above the menu
  .border-top-radius(0);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/normalize.less
================================================
/*! normalize.css v3.0.2 | MIT License | git.io/normalize */

//
// 1. Set default font family to sans-serif.
// 2. Prevent iOS text size adjust after orientation change, without disabling
//    user zoom.
//

html {
  font-family: sans-serif; // 1
  -ms-text-size-adjust: 100%; // 2
  -webkit-text-size-adjust: 100%; // 2
}

//
// Remove default margin.
//

body {
  margin: 0;
}

// HTML5 display definitions
// ==========================================================================

//
// Correct `block` display not defined for any HTML5 element in IE 8/9.
// Correct `block` display not defined for `details` or `summary` in IE 10/11
// and Firefox.
// Correct `block` display not defined for `main` in IE 11.
//

article,
aside,
details,
figcaption,
figure,
footer,
header,
hgroup,
main,
menu,
nav,
section,
summary {
  display: block;
}

//
// 1. Correct `inline-block` display not defined in IE 8/9.
// 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
//

audio,
canvas,
progress,
video {
  display: inline-block; // 1
  vertical-align: baseline; // 2
}

//
// Prevent modern browsers from displaying `audio` without controls.
// Remove excess height in iOS 5 devices.
//

audio:not([controls]) {
  display: none;
  height: 0;
}

//
// Address `[hidden]` styling not present in IE 8/9/10.
// Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
//

[hidden],
template {
  display: none;
}

// Links
// ==========================================================================

//
// Remove the gray background color from active links in IE 10.
//

a {
  background-color: transparent;
}

//
// Improve readability when focused and also mouse hovered in all browsers.
//

a:active,
a:hover {
  outline: 0;
}

// Text-level semantics
// ==========================================================================

//
// Address styling not present in IE 8/9/10/11, Safari, and Chrome.
//

abbr[title] {
  border-bottom: 1px dotted;
}

//
// Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
//

b,
strong {
  font-weight: bold;
}

//
// Address styling not present in Safari and Chrome.
//

dfn {
  font-style: italic;
}

//
// Address variable `h1` font-size and margin within `section` and `article`
// contexts in Firefox 4+, Safari, and Chrome.
//

h1 {
  font-size: 2em;
  margin: 0.67em 0;
}

//
// Address styling not present in IE 8/9.
//

mark {
  background: #ff0;
  color: #000;
}

//
// Address inconsistent and variable font size in all browsers.
//

small {
  font-size: 80%;
}

//
// Prevent `sub` and `sup` affecting `line-height` in all browsers.
//

sub,
sup {
  font-size: 75%;
  line-height: 0;
  position: relative;
  vertical-align: baseline;
}

sup {
  top: -0.5em;
}

sub {
  bottom: -0.25em;
}

// Embedded content
// ==========================================================================

//
// Remove border when inside `a` element in IE 8/9/10.
//

img {
  border: 0;
}

//
// Correct overflow not hidden in IE 9/10/11.
//

svg:not(:root) {
  overflow: hidden;
}

// Grouping content
// ==========================================================================

//
// Address margin not present in IE 8/9 and Safari.
//

figure {
  margin: 1em 40px;
}

//
// Address differences between Firefox and other browsers.
//

hr {
  -moz-box-sizing: content-box;
  box-sizing: content-box;
  height: 0;
}

//
// Contain overflow in all browsers.
//

pre {
  overflow: auto;
}

//
// Address odd `em`-unit font size rendering in all browsers.
//

code,
kbd,
pre,
samp {
  font-family: monospace, monospace;
  font-size: 1em;
}

// Forms
// ==========================================================================

//
// Known limitation: by default, Chrome and Safari on OS X allow very limited
// styling of `select`, unless a `border` property is set.
//

//
// 1. Correct color not being inherited.
//    Known issue: affects color of disabled elements.
// 2. Correct font properties not being inherited.
// 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
//

button,
input,
optgroup,
select,
textarea {
  color: inherit; // 1
  font: inherit; // 2
  margin: 0; // 3
}

//
// Address `overflow` set to `hidden` in IE 8/9/10/11.
//

button {
  overflow: visible;
}

//
// Address inconsistent `text-transform` inheritance for `button` and `select`.
// All other form control elements do not inherit `text-transform` values.
// Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
// Correct `select` style inheritance in Firefox.
//

button,
select {
  text-transform: none;
}

//
// 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
//    and `video` controls.
// 2. Correct inability to style clickable `input` types in iOS.
// 3. Improve usability and consistency of cursor style between image-type
//    `input` and others.
//

button,
html input[type="button"], // 1
input[type="reset"],
input[type="submit"] {
  -webkit-appearance: button; // 2
  cursor: pointer; // 3
}

//
// Re-set default cursor for disabled elements.
//

button[disabled],
html input[disabled] {
  cursor: default;
}

//
// Remove inner padding and border in Firefox 4+.
//

button::-moz-focus-inner,
input::-moz-focus-inner {
  border: 0;
  padding: 0;
}

//
// Address Firefox 4+ setting `line-height` on `input` using `!important` in
// the UA stylesheet.
//

input {
  line-height: normal;
}

//
// It's recommended that you don't attempt to style these elements.
// Firefox's implementation doesn't respect box-sizing, padding, or width.
//
// 1. Address box sizing set to `content-box` in IE 8/9/10.
// 2. Remove excess padding in IE 8/9/10.
//

input[type="checkbox"],
input[type="radio"] {
  box-sizing: border-box; // 1
  padding: 0; // 2
}

//
// Fix the cursor style for Chrome's increment/decrement buttons. For certain
// `font-size` values of the `input`, it causes the cursor style of the
// decrement button to change from `default` to `text`.
//

input[type="number"]::-webkit-inner-spin-button,
input[type="number"]::-webkit-outer-spin-button {
  height: auto;
}

//
// 1. Address `appearance` set to `searchfield` in Safari and Chrome.
// 2. Address `box-sizing` set to `border-box` in Safari and Chrome
//    (include `-moz` to future-proof).
//

input[type="search"] {
  -webkit-appearance: textfield; // 1
  -moz-box-sizing: content-box;
  -webkit-box-sizing: content-box; // 2
  box-sizing: content-box;
}

//
// Remove inner padding and search cancel button in Safari and Chrome on OS X.
// Safari (but not Chrome) clips the cancel button when the search input has
// padding (and `textfield` appearance).
//

input[type="search"]::-webkit-search-cancel-button,
input[type="search"]::-webkit-search-decoration {
  -webkit-appearance: none;
}

//
// Define consistent border, margin, and padding.
//

fieldset {
  border: 1px solid #c0c0c0;
  margin: 0 2px;
  padding: 0.35em 0.625em 0.75em;
}

//
// 1. Correct `color` not being inherited in IE 8/9/10/11.
// 2. Remove padding so people aren't caught out if they zero out fieldsets.
//

legend {
  border: 0; // 1
  padding: 0; // 2
}

//
// Remove default vertical scrollbar in IE 8/9/10/11.
//

textarea {
  overflow: auto;
}

//
// Don't inherit the `font-weight` (applied by a rule above).
// NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
//

optgroup {
  font-weight: bold;
}

// Tables
// ==========================================================================

//
// Remove most spacing between table cells.
//

table {
  border-collapse: collapse;
  border-spacing: 0;
}

td,
th {
  padding: 0;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/pager.less
================================================
//
// Pager pagination
// --------------------------------------------------


.pager {
  padding-left: 0;
  margin: @line-height-computed 0;
  list-style: none;
  text-align: center;
  &:extend(.clearfix all);
  li {
    display: inline;
    > a,
    > span {
      display: inline-block;
      padding: 5px 14px;
      background-color: @pager-bg;
      border: 1px solid @pager-border;
      border-radius: @pager-border-radius;
    }

    > a:hover,
    > a:focus {
      text-decoration: none;
      background-color: @pager-hover-bg;
    }
  }

  .next {
    > a,
    > span {
      float: right;
    }
  }

  .previous {
    > a,
    > span {
      float: left;
    }
  }

  .disabled {
    > a,
    > a:hover,
    > a:focus,
    > span {
      color: @pager-disabled-color;
      background-color: @pager-bg;
      cursor: @cursor-disabled;
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/pagination.less
================================================
//
// Pagination (multiple pages)
// --------------------------------------------------
.pagination {
  display: inline-block;
  padding-left: 0;
  margin: @line-height-computed 0;
  border-radius: @border-radius-base;

  > li {
    display: inline; // Remove list-style and block-level defaults
    > a,
    > span {
      position: relative;
      float: left; // Collapse white-space
      padding: @padding-base-vertical @padding-base-horizontal;
      line-height: @line-height-base;
      text-decoration: none;
      color: @pagination-color;
      background-color: @pagination-bg;
      border: 1px solid @pagination-border;
      margin-left: -1px;
    }
    &:first-child {
      > a,
      > span {
        margin-left: 0;
        .border-left-radius(@border-radius-base);
      }
    }
    &:last-child {
      > a,
      > span {
        .border-right-radius(@border-radius-base);
      }
    }
  }

  > li > a,
  > li > span {
    &:hover,
    &:focus {
      color: @pagination-hover-color;
      background-color: @pagination-hover-bg;
      border-color: @pagination-hover-border;
    }
  }

  > .active > a,
  > .active > span {
    &,
    &:hover,
    &:focus {
      z-index: 2;
      color: @pagination-active-color;
      background-color: @pagination-active-bg;
      border-color: @pagination-active-border;
      cursor: default;
    }
  }

  > .disabled {
    > span,
    > span:hover,
    > span:focus,
    > a,
    > a:hover,
    > a:focus {
      color: @pagination-disabled-color;
      background-color: @pagination-disabled-bg;
      border-color: @pagination-disabled-border;
      cursor: @cursor-disabled;
    }
  }
}

// Sizing
// --------------------------------------------------

// Large
.pagination-lg {
  .pagination-size(@padding-large-vertical; @padding-large-horizontal; @font-size-large; @border-radius-large);
}

// Small
.pagination-sm {
  .pagination-size(@padding-small-vertical; @padding-small-horizontal; @font-size-small; @border-radius-small);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/panels.less
================================================
//
// Panels
// --------------------------------------------------


// Base class
.panel {
  margin-bottom: @line-height-computed;
  background-color: @panel-bg;
  border: 1px solid transparent;
  border-radius: @panel-border-radius;
  .box-shadow(0 1px 1px rgba(0,0,0,.05));
}

// Panel contents
.panel-body {
  padding: @panel-body-padding;
  &:extend(.clearfix all);
}

// Optional heading
.panel-heading {
  padding: @panel-heading-padding;
  border-bottom: 1px solid transparent;
  .border-top-radius((@panel-border-radius - 1));

  > .dropdown .dropdown-toggle {
    color: inherit;
  }
}

// Within heading, strip any `h*` tag of its default margins for spacing.
.panel-title {
  margin-top: 0;
  margin-bottom: 0;
  font-size: ceil((@font-size-base * 1.125));
  color: inherit;

  > a,
  > small,
  > .small,
  > small > a,
  > .small > a {
    color: inherit;
  }
}

// Optional footer (stays gray in every modifier class)
.panel-footer {
  padding: @panel-footer-padding;
  background-color: @panel-footer-bg;
  border-top: 1px solid @panel-inner-border;
  .border-bottom-radius((@panel-border-radius - 1));
}


// List groups in panels
//
// By default, space out list group content from panel headings to account for
// any kind of custom content between the two.

.panel {
  > .list-group,
  > .panel-collapse > .list-group {
    margin-bottom: 0;

    .list-group-item {
      border-width: 1px 0;
      border-radius: 0;
    }

    // Add border top radius for first one
    &:first-child {
      .list-group-item:first-child {
        border-top: 0;
        .border-top-radius((@panel-border-radius - 1));
      }
    }
    // Add border bottom radius for last one
    &:last-child {
      .list-group-item:last-child {
        border-bottom: 0;
        .border-bottom-radius((@panel-border-radius - 1));
      }
    }
  }
}
// Collapse space between when there's no additional content.
.panel-heading + .list-group {
  .list-group-item:first-child {
    border-top-width: 0;
  }
}
.list-group + .panel-footer {
  border-top-width: 0;
}

// Tables in panels
//
// Place a non-bordered `.table` within a panel (not within a `.panel-body`) and
// watch it go full width.

.panel {
  > .table,
  > .table-responsive > .table,
  > .panel-collapse > .table {
    margin-bottom: 0;

    caption {
      padding-left: @panel-body-padding;
      padding-right: @panel-body-padding;
    }
  }
  // Add border top radius for first one
  > .table:first-child,
  > .table-responsive:first-child > .table:first-child {
    .border-top-radius((@panel-border-radius - 1));

    > thead:first-child,
    > tbody:first-child {
      > tr:first-child {
        border-top-left-radius: (@panel-border-radius - 1);
        border-top-right-radius: (@panel-border-radius - 1);

        td:first-child,
        th:first-child {
          border-top-left-radius: (@panel-border-radius - 1);
        }
        td:last-child,
        th:last-child {
          border-top-right-radius: (@panel-border-radius - 1);
        }
      }
    }
  }
  // Add border bottom radius for last one
  > .table:last-child,
  > .table-responsive:last-child > .table:last-child {
    .border-bottom-radius((@panel-border-radius - 1));

    > tbody:last-child,
    > tfoot:last-child {
      > tr:last-child {
        border-bottom-left-radius: (@panel-border-radius - 1);
        border-bottom-right-radius: (@panel-border-radius - 1);

        td:first-child,
        th:first-child {
          border-bottom-left-radius: (@panel-border-radius - 1);
        }
        td:last-child,
        th:last-child {
          border-bottom-right-radius: (@panel-border-radius - 1);
        }
      }
    }
  }
  > .panel-body + .table,
  > .panel-body + .table-responsive,
  > .table + .panel-body,
  > .table-responsive + .panel-body {
    border-top: 1px solid @table-border-color;
  }
  > .table > tbody:first-child > tr:first-child th,
  > .table > tbody:first-child > tr:first-child td {
    border-top: 0;
  }
  > .table-bordered,
  > .table-responsive > .table-bordered {
    border: 0;
    > thead,
    > tbody,
    > tfoot {
      > tr {
        > th:first-child,
        > td:first-child {
          border-left: 0;
        }
        > th:last-child,
        > td:last-child {
          border-right: 0;
        }
      }
    }
    > thead,
    > tbody {
      > tr:first-child {
        > td,
        > th {
          border-bottom: 0;
        }
      }
    }
    > tbody,
    > tfoot {
      > tr:last-child {
        > td,
        > th {
          border-bottom: 0;
        }
      }
    }
  }
  > .table-responsive {
    border: 0;
    margin-bottom: 0;
  }
}


// Collapsable panels (aka, accordion)
//
// Wrap a series of panels in `.panel-group` to turn them into an accordion with
// the help of our collapse JavaScript plugin.

.panel-group {
  margin-bottom: @line-height-computed;

  // Tighten up margin so it's only between panels
  .panel {
    margin-bottom: 0;
    border-radius: @panel-border-radius;

    + .panel {
      margin-top: 5px;
    }
  }

  .panel-heading {
    border-bottom: 0;

    + .panel-collapse > .panel-body,
    + .panel-collapse > .list-group {
      border-top: 1px solid @panel-inner-border;
    }
  }

  .panel-footer {
    border-top: 0;
    + .panel-collapse .panel-body {
      border-bottom: 1px solid @panel-inner-border;
    }
  }
}


// Contextual variations
.panel-default {
  .panel-variant(@panel-default-border; @panel-default-text; @panel-default-heading-bg; @panel-default-border);
}
.panel-primary {
  .panel-variant(@panel-primary-border; @panel-primary-text; @panel-primary-heading-bg; @panel-primary-border);
}
.panel-success {
  .panel-variant(@panel-success-border; @panel-success-text; @panel-success-heading-bg; @panel-success-border);
}
.panel-info {
  .panel-variant(@panel-info-border; @panel-info-text; @panel-info-heading-bg; @panel-info-border);
}
.panel-warning {
  .panel-variant(@panel-warning-border; @panel-warning-text; @panel-warning-heading-bg; @panel-warning-border);
}
.panel-danger {
  .panel-variant(@panel-danger-border; @panel-danger-text; @panel-danger-heading-bg; @panel-danger-border);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/popovers.less
================================================
//
// Popovers
// --------------------------------------------------


.popover {
  position: absolute;
  top: 0;
  left: 0;
  z-index: @zindex-popover;
  display: none;
  max-width: @popover-max-width;
  padding: 1px;
  // Reset font and text properties given new insertion method
  font-family: @font-family-base;
  font-size: @font-size-base;
  font-weight: normal;
  line-height: @line-height-base;
  text-align: left;
  background-color: @popover-bg;
  background-clip: padding-box;
  border: 1px solid @popover-fallback-border-color;
  border: 1px solid @popover-border-color;
  border-radius: @border-radius-large;
  .box-shadow(0 5px 10px rgba(0,0,0,.2));

  // Overrides for proper insertion
  white-space: normal;

  // Offset the popover to account for the popover arrow
  &.top     { margin-top: -@popover-arrow-width; }
  &.right   { margin-left: @popover-arrow-width; }
  &.bottom  { margin-top: @popover-arrow-width; }
  &.left    { margin-left: -@popover-arrow-width; }
}

.popover-title {
  margin: 0; // reset heading margin
  padding: 8px 14px;
  font-size: @font-size-base;
  background-color: @popover-title-bg;
  border-bottom: 1px solid darken(@popover-title-bg, 5%);
  border-radius: (@border-radius-large - 1) (@border-radius-large - 1) 0 0;
}

.popover-content {
  padding: 9px 14px;
}

// Arrows
//
// .arrow is outer, .arrow:after is inner

.popover > .arrow {
  &,
  &:after {
    position: absolute;
    display: block;
    width: 0;
    height: 0;
    border-color: transparent;
    border-style: solid;
  }
}
.popover > .arrow {
  border-width: @popover-arrow-outer-width;
}
.popover > .arrow:after {
  border-width: @popover-arrow-width;
  content: "";
}

.popover {
  &.top > .arrow {
    left: 50%;
    margin-left: -@popover-arrow-outer-width;
    border-bottom-width: 0;
    border-top-color: @popover-arrow-outer-fallback-color; // IE8 fallback
    border-top-color: @popover-arrow-outer-color;
    bottom: -@popover-arrow-outer-width;
    &:after {
      content: " ";
      bottom: 1px;
      margin-left: -@popover-arrow-width;
      border-bottom-width: 0;
      border-top-color: @popover-arrow-color;
    }
  }
  &.right > .arrow {
    top: 50%;
    left: -@popover-arrow-outer-width;
    margin-top: -@popover-arrow-outer-width;
    border-left-width: 0;
    border-right-color: @popover-arrow-outer-fallback-color; // IE8 fallback
    border-right-color: @popover-arrow-outer-color;
    &:after {
      content: " ";
      left: 1px;
      bottom: -@popover-arrow-width;
      border-left-width: 0;
      border-right-color: @popover-arrow-color;
    }
  }
  &.bottom > .arrow {
    left: 50%;
    margin-left: -@popover-arrow-outer-width;
    border-top-width: 0;
    border-bottom-color: @popover-arrow-outer-fallback-color; // IE8 fallback
    border-bottom-color: @popover-arrow-outer-color;
    top: -@popover-arrow-outer-width;
    &:after {
      content: " ";
      top: 1px;
      margin-left: -@popover-arrow-width;
      border-top-width: 0;
      border-bottom-color: @popover-arrow-color;
    }
  }

  &.left > .arrow {
    top: 50%;
    right: -@popover-arrow-outer-width;
    margin-top: -@popover-arrow-outer-width;
    border-right-width: 0;
    border-left-color: @popover-arrow-outer-fallback-color; // IE8 fallback
    border-left-color: @popover-arrow-outer-color;
    &:after {
      content: " ";
      right: 1px;
      border-right-width: 0;
      border-left-color: @popover-arrow-color;
      bottom: -@popover-arrow-width;
    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/print.less
================================================
/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */

// ==========================================================================
// Print styles.
// Inlined to avoid the additional HTTP request: h5bp.com/r
// ==========================================================================

@media print {
    *,
    *:before,
    *:after {
        background: transparent !important;
        color: #000 !important; // Black prints faster: h5bp.com/s
        box-shadow: none !important;
        text-shadow: none !important;
    }

    a,
    a:visited {
        text-decoration: underline;
    }

    a[href]:after {
        content: " (" attr(href) ")";
    }

    abbr[title]:after {
        content: " (" attr(title) ")";
    }

    // Don't show links that are fragment identifiers,
    // or use the `javascript:` pseudo protocol
    a[href^="#"]:after,
    a[href^="javascript:"]:after {
        content: "";
    }

    pre,
    blockquote {
        border: 1px solid #999;
        page-break-inside: avoid;
    }

    thead {
        display: table-header-group; // h5bp.com/t
    }

    tr,
    img {
        page-break-inside: avoid;
    }

    img {
        max-width: 100% !important;
    }

    p,
    h2,
    h3 {
        orphans: 3;
        widows: 3;
    }

    h2,
    h3 {
        page-break-after: avoid;
    }

    // Bootstrap specific changes start
    //
    // Chrome (OSX) fix for https://github.com/twbs/bootstrap/issues/11245
    // Once fixed, we can just straight up remove this.
    select {
        background: #fff !important;
    }

    // Bootstrap components
    .navbar {
        display: none;
    }
    .btn,
    .dropup > .btn {
        > .caret {
            border-top-color: #000 !important;
        }
    }
    .label {
        border: 1px solid #000;
    }

    .table {
        border-collapse: collapse !important;

        td,
        th {
            background-color: #fff !important;
        }
    }
    .table-bordered {
        th,
        td {
            border: 1px solid #ddd !important;
        }
    }

    // Bootstrap specific changes end
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/progress-bars.less
================================================
//
// Progress bars
// --------------------------------------------------


// Bar animations
// -------------------------

// WebKit
@-webkit-keyframes progress-bar-stripes {
  from  { background-position: 40px 0; }
  to    { background-position: 0 0; }
}

// Spec and IE10+
@keyframes progress-bar-stripes {
  from  { background-position: 40px 0; }
  to    { background-position: 0 0; }
}


// Bar itself
// -------------------------

// Outer container
.progress {
  overflow: hidden;
  height: @line-height-computed;
  margin-bottom: @line-height-computed;
  background-color: @progress-bg;
  border-radius: @progress-border-radius;
  .box-shadow(inset 0 1px 2px rgba(0,0,0,.1));
}

// Bar of progress
.progress-bar {
  float: left;
  width: 0%;
  height: 100%;
  font-size: @font-size-small;
  line-height: @line-height-computed;
  color: @progress-bar-color;
  text-align: center;
  background-color: @progress-bar-bg;
  .box-shadow(inset 0 -1px 0 rgba(0,0,0,.15));
  .transition(width .6s ease);
}

// Striped bars
//
// `.progress-striped .progress-bar` is deprecated as of v3.2.0 in favor of the
// `.progress-bar-striped` class, which you just add to an existing
// `.progress-bar`.
.progress-striped .progress-bar,
.progress-bar-striped {
  #gradient > .striped();
  background-size: 40px 40px;
}

// Call animation for the active one
//
// `.progress.active .progress-bar` is deprecated as of v3.2.0 in favor of the
// `.progress-bar.active` approach.
.progress.active .progress-bar,
.progress-bar.active {
  .animation(progress-bar-stripes 2s linear infinite);
}


// Variations
// -------------------------

.progress-bar-success {
  .progress-bar-variant(@progress-bar-success-bg);
}

.progress-bar-info {
  .progress-bar-variant(@progress-bar-info-bg);
}

.progress-bar-warning {
  .progress-bar-variant(@progress-bar-warning-bg);
}

.progress-bar-danger {
  .progress-bar-variant(@progress-bar-danger-bg);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/responsive-embed.less
================================================
// Embeds responsive
//
// Credit: Nicolas Gallagher and SUIT CSS.

.embed-responsive {
  position: relative;
  display: block;
  height: 0;
  padding: 0;
  overflow: hidden;

  .embed-responsive-item,
  iframe,
  embed,
  object,
  video {
    position: absolute;
    top: 0;
    left: 0;
    bottom: 0;
    height: 100%;
    width: 100%;
    border: 0;
  }
}

// Modifier class for 16:9 aspect ratio
.embed-responsive-16by9 {
  padding-bottom: 56.25%;
}

// Modifier class for 4:3 aspect ratio
.embed-responsive-4by3 {
  padding-bottom: 75%;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/responsive-utilities.less
================================================
//
// Responsive: Utility classes
// --------------------------------------------------


// IE10 in Windows (Phone) 8
//
// Support for responsive views via media queries is kind of borked in IE10, for
// Surface/desktop in split view and for Windows Phone 8. This particular fix
// must be accompanied by a snippet of JavaScript to sniff the user agent and
// apply some conditional CSS to *only* the Surface/desktop Windows 8. Look at
// our Getting Started page for more information on this bug.
//
// For more information, see the following:
//
// Issue: https://github.com/twbs/bootstrap/issues/10497
// Docs: http://getbootstrap.com/getting-started/#support-ie10-width
// Source: http://timkadlec.com/2013/01/windows-phone-8-and-device-width/
// Source: http://timkadlec.com/2012/10/ie10-snap-mode-and-responsive-design/

@-ms-viewport {
  width: device-width;
}


// Visibility utilities
// Note: Deprecated .visible-xs, .visible-sm, .visible-md, and .visible-lg as of v3.2.0
.visible-xs,
.visible-sm,
.visible-md,
.visible-lg {
  .responsive-invisibility();
}

.visible-xs-block,
.visible-xs-inline,
.visible-xs-inline-block,
.visible-sm-block,
.visible-sm-inline,
.visible-sm-inline-block,
.visible-md-block,
.visible-md-inline,
.visible-md-inline-block,
.visible-lg-block,
.visible-lg-inline,
.visible-lg-inline-block {
  display: none !important;
}

.visible-xs {
  @media (max-width: @screen-xs-max) {
    .responsive-visibility();
  }
}
.visible-xs-block {
  @media (max-width: @screen-xs-max) {
    display: block !important;
  }
}
.visible-xs-inline {
  @media (max-width: @screen-xs-max) {
    display: inline !important;
  }
}
.visible-xs-inline-block {
  @media (max-width: @screen-xs-max) {
    display: inline-block !important;
  }
}

.visible-sm {
  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
    .responsive-visibility();
  }
}
.visible-sm-block {
  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
    display: block !important;
  }
}
.visible-sm-inline {
  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
    display: inline !important;
  }
}
.visible-sm-inline-block {
  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
    display: inline-block !important;
  }
}

.visible-md {
  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
    .responsive-visibility();
  }
}
.visible-md-block {
  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
    display: block !important;
  }
}
.visible-md-inline {
  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
    display: inline !important;
  }
}
.visible-md-inline-block {
  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
    display: inline-block !important;
  }
}

.visible-lg {
  @media (min-width: @screen-lg-min) {
    .responsive-visibility();
  }
}
.visible-lg-block {
  @media (min-width: @screen-lg-min) {
    display: block !important;
  }
}
.visible-lg-inline {
  @media (min-width: @screen-lg-min) {
    display: inline !important;
  }
}
.visible-lg-inline-block {
  @media (min-width: @screen-lg-min) {
    display: inline-block !important;
  }
}

.hidden-xs {
  @media (max-width: @screen-xs-max) {
    .responsive-invisibility();
  }
}
.hidden-sm {
  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
    .responsive-invisibility();
  }
}
.hidden-md {
  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
    .responsive-invisibility();
  }
}
.hidden-lg {
  @media (min-width: @screen-lg-min) {
    .responsive-invisibility();
  }
}


// Print utilities
//
// Media queries are placed on the inside to be mixin-friendly.

// Note: Deprecated .visible-print as of v3.2.0
.visible-print {
  .responsive-invisibility();

  @media print {
    .responsive-visibility();
  }
}
.visible-print-block {
  display: none !important;

  @media print {
    display: block !important;
  }
}
.visible-print-inline {
  display: none !important;

  @media print {
    display: inline !important;
  }
}
.visible-print-inline-block {
  display: none !important;

  @media print {
    display: inline-block !important;
  }
}

.hidden-print {
  @media print {
    .responsive-invisibility();
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/scaffolding.less
================================================
//
// Scaffolding
// --------------------------------------------------


// Reset the box-sizing
//
// Heads up! This reset may cause conflicts with some third-party widgets.
// For recommendations on resolving such conflicts, see
// http://getbootstrap.com/getting-started/#third-box-sizing
* {
  .box-sizing(border-box);
}
*:before,
*:after {
  .box-sizing(border-box);
}


// Body reset

html {
  font-size: 10px;
  -webkit-tap-highlight-color: rgba(0,0,0,0);
}

body {
  font-family: @font-family-base;
  font-size: @font-size-base;
  line-height: @line-height-base;
  color: @text-color;
  background-color: @body-bg;
}

// Reset fonts for relevant elements
input,
button,
select,
textarea {
  font-family: inherit;
  font-size: inherit;
  line-height: inherit;
}


// Links

a {
  color: @link-color;
  text-decoration: none;

  &:hover,
  &:focus {
    color: @link-hover-color;
    text-decoration: @link-hover-decoration;
  }

  &:focus {
    .tab-focus();
  }
}


// Figures
//
// We reset this here because previously Normalize had no `figure` margins. This
// ensures we don't break anyone's use of the element.

figure {
  margin: 0;
}


// Images

img {
  vertical-align: middle;
}

// Responsive images (ensure images don't scale beyond their parents)
.img-responsive {
  .img-responsive();
}

// Rounded corners
.img-rounded {
  border-radius: @border-radius-large;
}

// Image thumbnails
//
// Heads up! This is mixin-ed into thumbnails.less for `.thumbnail`.
.img-thumbnail {
  padding: @thumbnail-padding;
  line-height: @line-height-base;
  background-color: @thumbnail-bg;
  border: 1px solid @thumbnail-border;
  border-radius: @thumbnail-border-radius;
  .transition(all .2s ease-in-out);

  // Keep them at most 100% wide
  .img-responsive(inline-block);
}

// Perfect circle
.img-circle {
  border-radius: 50%; // set radius in percents
}


// Horizontal rules

hr {
  margin-top:    @line-height-computed;
  margin-bottom: @line-height-computed;
  border: 0;
  border-top: 1px solid @hr-border;
}


// Only display content to screen readers
//
// See: http://a11yproject.com/posts/how-to-hide-content/

.sr-only {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  clip: rect(0,0,0,0);
  border: 0;
}

// Use in conjunction with .sr-only to only display content when it's focused.
// Useful for "Skip to main content" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1
// Credit: HTML5 Boilerplate

.sr-only-focusable {
  &:active,
  &:focus {
    position: static;
    width: auto;
    height: auto;
    margin: 0;
    overflow: visible;
    clip: auto;
  }
}


// iOS "clickable elements" fix for role="button"
//
// Fixes "clickability" issue (and more generally, the firing of events such as focus as well)
// for traditionally non-focusable elements with role="button"
// see https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile
// Upstream patch for normalize.css submitted: https://github.com/necolas/normalize.css/pull/379 - remove this fix once that is merged

[role="button"] {
  cursor: pointer;
}

================================================
FILE: examples/libraries/fmt/doc/bootstrap/tables.less
================================================
//
// Tables
// --------------------------------------------------


table {
  background-color: @table-bg;
}
caption {
  padding-top: @table-cell-padding;
  padding-bottom: @table-cell-padding;
  color: @text-muted;
  text-align: left;
}
th {
  text-align: left;
}


// Baseline styles

.table {
  width: 100%;
  max-width: 100%;
  margin-bottom: @line-height-computed;
  // Cells
  > thead,
  > tbody,
  > tfoot {
    > tr {
      > th,
      > td {
        padding: @table-cell-padding;
        line-height: @line-height-base;
        vertical-align: top;
        border-top: 1px solid @table-border-color;
      }
    }
  }
  // Bottom align for column headings
  > thead > tr > th {
    vertical-align: bottom;
    border-bottom: 2px solid @table-border-color;
  }
  // Remove top border from thead by default
  > caption + thead,
  > colgroup + thead,
  > thead:first-child {
    > tr:first-child {
      > th,
      > td {
        border-top: 0;
      }
    }
  }
  // Account for multiple tbody instances
  > tbody + tbody {
    border-top: 2px solid @table-border-color;
  }

  // Nesting
  .table {
    background-color: @body-bg;
  }
}


// Condensed table w/ half padding

.table-condensed {
  > thead,
  > tbody,
  > tfoot {
    > tr {
      > th,
      > td {
        padding: @table-condensed-cell-padding;
      }
    }
  }
}


// Bordered version
//
// Add borders all around the table and between all the columns.

.table-bordered {
  border: 1px solid @table-border-color;
  > thead,
  > tbody,
  > tfoot {
    > tr {
      > th,
      > td {
        border: 1px solid @table-border-color;
      }
    }
  }
  > thead > tr {
    > th,
    > td {
      border-bottom-width: 2px;
    }
  }
}


// Zebra-striping
//
// Default zebra-stripe styles (alternating gray and transparent backgrounds)

.table-striped {
  > tbody > tr:nth-of-type(odd) {
    background-color: @table-bg-accent;
  }
}


// Hover effect
//
// Placed here since it has to come after the potential zebra striping

.table-hover {
  > tbody > tr:hover {
    background-color: @table-bg-hover;
  }
}


// Table cell sizing
//
// Reset default table behavior

table col[class*="col-"] {
  position: static; // Prevent border hiding in Firefox and IE9-11 (see https://github.com/twbs/bootstrap/issues/11623)
  float: none;
  display: table-column;
}
table {
  td,
  th {
    &[class*="col-"] {
      position: static; // Prevent border hiding in Firefox and IE9-11 (see https://github.com/twbs/bootstrap/issues/11623)
      float: none;
      display: table-cell;
    }
  }
}


// Table backgrounds
//
// Exact selectors below required to override `.table-striped` and prevent
// inheritance to nested tables.

// Generate the contextual variants
.table-row-variant(active; @table-bg-active);
.table-row-variant(success; @state-success-bg);
.table-row-variant(info; @state-info-bg);
.table-row-variant(warning; @state-warning-bg);
.table-row-variant(danger; @state-danger-bg);


// Responsive tables
//
// Wrap your tables in `.table-responsive` and we'll make them mobile friendly
// by enabling horizontal scrolling. Only applies <768px. Everything above that
// will display normally.

.table-responsive {
  overflow-x: auto;
  min-height: 0.01%; // Workaround for IE9 bug (see https://github.com/twbs/bootstrap/issues/14837)

  @media screen and (max-width: @screen-xs-max) {
    width: 100%;
    margin-bottom: (@line-height-computed * 0.75);
    overflow-y: hidden;
    -ms-overflow-style: -ms-autohiding-scrollbar;
    border: 1px solid @table-border-color;

    // Tighten up spacing
    > .table {
      margin-bottom: 0;

      // Ensure the content doesn't wrap
      > thead,
      > tbody,
      > tfoot {
        > tr {
          > th,
          > td {
            white-space: nowrap;
          }
        }
      }
    }

    // Special overrides for the bordered tables
    > .table-bordered {
      border: 0;

      // Nuke the appropriate borders so that the parent can handle them
      > thead,
      > tbody,
      > tfoot {
        > tr {
          > th:first-child,
          > td:first-child {
            border-left: 0;
          }
          > th:last-child,
          > td:last-child {
            border-right: 0;
          }
        }
      }

      // Only nuke the last row's bottom-border in `tbody` and `tfoot` since
      // chances are there will be only one `tr` in a `thead` and that would
      // remove the border altogether.
      > tbody,
      > tfoot {
        > tr:last-child {
          > th,
          > td {
            border-bottom: 0;
          }
        }
      }

    }
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/theme.less
================================================

//
// Load core variables and mixins
// --------------------------------------------------

@import "variables.less";
@import "mixins.less";


//
// Buttons
// --------------------------------------------------

// Common styles
.btn-default,
.btn-primary,
.btn-success,
.btn-info,
.btn-warning,
.btn-danger {
  text-shadow: 0 -1px 0 rgba(0,0,0,.2);
  @shadow: inset 0 1px 0 rgba(255,255,255,.15), 0 1px 1px rgba(0,0,0,.075);
  .box-shadow(@shadow);

  // Reset the shadow
  &:active,
  &.active {
    .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));
  }

  .badge {
    text-shadow: none;
  }
}

// Mixin for generating new styles
.btn-styles(@btn-color: #555) {
  #gradient > .vertical(@start-color: @btn-color; @end-color: darken(@btn-color, 12%));
  .reset-filter(); // Disable gradients for IE9 because filter bleeds through rounded corners; see https://github.com/twbs/bootstrap/issues/10620
  background-repeat: repeat-x;
  border-color: darken(@btn-color, 14%);

  &:hover,
  &:focus  {
    background-color: darken(@btn-color, 12%);
    background-position: 0 -15px;
  }

  &:active,
  &.active {
    background-color: darken(@btn-color, 12%);
    border-color: darken(@btn-color, 14%);
  }

  &.disabled,
  &:disabled,
  &[disabled] {
    background-color: darken(@btn-color, 12%);
    background-image: none;
  }
}

// Common styles
.btn {
  // Remove the gradient for the pressed/active state
  &:active,
  &.active {
    background-image: none;
  }
}

// Apply the mixin to the buttons
.btn-default { .btn-styles(@btn-default-bg); text-shadow: 0 1px 0 #fff; border-color: #ccc; }
.btn-primary { .btn-styles(@btn-primary-bg); }
.btn-success { .btn-styles(@btn-success-bg); }
.btn-info    { .btn-styles(@btn-info-bg); }
.btn-warning { .btn-styles(@btn-warning-bg); }
.btn-danger  { .btn-styles(@btn-danger-bg); }


//
// Images
// --------------------------------------------------

.thumbnail,
.img-thumbnail {
  .box-shadow(0 1px 2px rgba(0,0,0,.075));
}


//
// Dropdowns
// --------------------------------------------------

.dropdown-menu > li > a:hover,
.dropdown-menu > li > a:focus {
  #gradient > .vertical(@start-color: @dropdown-link-hover-bg; @end-color: darken(@dropdown-link-hover-bg, 5%));
  background-color: darken(@dropdown-link-hover-bg, 5%);
}
.dropdown-menu > .active > a,
.dropdown-menu > .active > a:hover,
.dropdown-menu > .active > a:focus {
  #gradient > .vertical(@start-color: @dropdown-link-active-bg; @end-color: darken(@dropdown-link-active-bg, 5%));
  background-color: darken(@dropdown-link-active-bg, 5%);
}


//
// Navbar
// --------------------------------------------------

// Default navbar
.navbar-default {
  #gradient > .vertical(@start-color: lighten(@navbar-default-bg, 10%); @end-color: @navbar-default-bg);
  .reset-filter(); // Remove gradient in IE<10 to fix bug where dropdowns don't get triggered
  border-radius: @navbar-border-radius;
  @shadow: inset 0 1px 0 rgba(255,255,255,.15), 0 1px 5px rgba(0,0,0,.075);
  .box-shadow(@shadow);

  .navbar-nav > .open > a,
  .navbar-nav > .active > a {
    #gradient > .vertical(@start-color: darken(@navbar-default-link-active-bg, 5%); @end-color: darken(@navbar-default-link-active-bg, 2%));
    .box-shadow(inset 0 3px 9px rgba(0,0,0,.075));
  }
}
.navbar-brand,
.navbar-nav > li > a {
  text-shadow: 0 1px 0 rgba(255,255,255,.25);
}

// Inverted navbar
.navbar-inverse {
  #gradient > .vertical(@start-color: lighten(@navbar-inverse-bg, 10%); @end-color: @navbar-inverse-bg);
  .reset-filter(); // Remove gradient in IE<10 to fix bug where dropdowns don't get triggered; see https://github.com/twbs/bootstrap/issues/10257

  .navbar-nav > .open > a,
  .navbar-nav > .active > a {
    #gradient > .vertical(@start-color: @navbar-inverse-link-active-bg; @end-color: lighten(@navbar-inverse-link-active-bg, 2.5%));
    .box-shadow(inset 0 3px 9px rgba(0,0,0,.25));
  }

  .navbar-brand,
  .navbar-nav > li > a {
    text-shadow: 0 -1px 0 rgba(0,0,0,.25);
  }
}

// Undo rounded corners in static and fixed navbars
.navbar-static-top,
.navbar-fixed-top,
.navbar-fixed-bottom {
  border-radius: 0;
}

// Fix active state of dropdown items in collapsed mode
@media (max-width: @grid-float-breakpoint-max) {
  .navbar .navbar-nav .open .dropdown-menu > .active > a {
    &,
    &:hover,
    &:focus {
      color: #fff;
      #gradient > .vertical(@start-color: @dropdown-link-active-bg; @end-color: darken(@dropdown-link-active-bg, 5%));
    }
  }
}


//
// Alerts
// --------------------------------------------------

// Common styles
.alert {
  text-shadow: 0 1px 0 rgba(255,255,255,.2);
  @shadow: inset 0 1px 0 rgba(255,255,255,.25), 0 1px 2px rgba(0,0,0,.05);
  .box-shadow(@shadow);
}

// Mixin for generating new styles
.alert-styles(@color) {
  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 7.5%));
  border-color: darken(@color, 15%);
}

// Apply the mixin to the alerts
.alert-success    { .alert-styles(@alert-success-bg); }
.alert-info       { .alert-styles(@alert-info-bg); }
.alert-warning    { .alert-styles(@alert-warning-bg); }
.alert-danger     { .alert-styles(@alert-danger-bg); }


//
// Progress bars
// --------------------------------------------------

// Give the progress background some depth
.progress {
  #gradient > .vertical(@start-color: darken(@progress-bg, 4%); @end-color: @progress-bg)
}

// Mixin for generating new styles
.progress-bar-styles(@color) {
  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 10%));
}

// Apply the mixin to the progress bars
.progress-bar            { .progress-bar-styles(@progress-bar-bg); }
.progress-bar-success    { .progress-bar-styles(@progress-bar-success-bg); }
.progress-bar-info       { .progress-bar-styles(@progress-bar-info-bg); }
.progress-bar-warning    { .progress-bar-styles(@progress-bar-warning-bg); }
.progress-bar-danger     { .progress-bar-styles(@progress-bar-danger-bg); }

// Reset the striped class because our mixins don't do multiple gradients and
// the above custom styles override the new `.progress-bar-striped` in v3.2.0.
.progress-bar-striped {
  #gradient > .striped();
}


//
// List groups
// --------------------------------------------------

.list-group {
  border-radius: @border-radius-base;
  .box-shadow(0 1px 2px rgba(0,0,0,.075));
}
.list-group-item.active,
.list-group-item.active:hover,
.list-group-item.active:focus {
  text-shadow: 0 -1px 0 darken(@list-group-active-bg, 10%);
  #gradient > .vertical(@start-color: @list-group-active-bg; @end-color: darken(@list-group-active-bg, 7.5%));
  border-color: darken(@list-group-active-border, 7.5%);

  .badge {
    text-shadow: none;
  }
}


//
// Panels
// --------------------------------------------------

// Common styles
.panel {
  .box-shadow(0 1px 2px rgba(0,0,0,.05));
}

// Mixin for generating new styles
.panel-heading-styles(@color) {
  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 5%));
}

// Apply the mixin to the panel headings only
.panel-default > .panel-heading   { .panel-heading-styles(@panel-default-heading-bg); }
.panel-primary > .panel-heading   { .panel-heading-styles(@panel-primary-heading-bg); }
.panel-success > .panel-heading   { .panel-heading-styles(@panel-success-heading-bg); }
.panel-info > .panel-heading      { .panel-heading-styles(@panel-info-heading-bg); }
.panel-warning > .panel-heading   { .panel-heading-styles(@panel-warning-heading-bg); }
.panel-danger > .panel-heading    { .panel-heading-styles(@panel-danger-heading-bg); }


//
// Wells
// --------------------------------------------------

.well {
  #gradient > .vertical(@start-color: darken(@well-bg, 5%); @end-color: @well-bg);
  border-color: darken(@well-bg, 10%);
  @shadow: inset 0 1px 3px rgba(0,0,0,.05), 0 1px 0 rgba(255,255,255,.1);
  .box-shadow(@shadow);
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/thumbnails.less
================================================
//
// Thumbnails
// --------------------------------------------------


// Mixin and adjust the regular image class
.thumbnail {
  display: block;
  padding: @thumbnail-padding;
  margin-bottom: @line-height-computed;
  line-height: @line-height-base;
  background-color: @thumbnail-bg;
  border: 1px solid @thumbnail-border;
  border-radius: @thumbnail-border-radius;
  .transition(border .2s ease-in-out);

  > img,
  a > img {
    &:extend(.img-responsive);
    margin-left: auto;
    margin-right: auto;
  }

  // Add a hover state for linked versions only
  a&:hover,
  a&:focus,
  a&.active {
    border-color: @link-color;
  }

  // Image captions
  .caption {
    padding: @thumbnail-caption-padding;
    color: @thumbnail-caption-color;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/tooltip.less
================================================
//
// Tooltips
// --------------------------------------------------


// Base class
.tooltip {
  position: absolute;
  z-index: @zindex-tooltip;
  display: block;
  // Reset font and text properties given new insertion method
  font-family: @font-family-base;
  font-size: @font-size-small;
  font-weight: normal;
  line-height: 1.4;
  .opacity(0);

  &.in     { .opacity(@tooltip-opacity); }
  &.top    { margin-top:  -3px; padding: @tooltip-arrow-width 0; }
  &.right  { margin-left:  3px; padding: 0 @tooltip-arrow-width; }
  &.bottom { margin-top:   3px; padding: @tooltip-arrow-width 0; }
  &.left   { margin-left: -3px; padding: 0 @tooltip-arrow-width; }
}

// Wrapper for the tooltip content
.tooltip-inner {
  max-width: @tooltip-max-width;
  padding: 3px 8px;
  color: @tooltip-color;
  text-align: center;
  text-decoration: none;
  background-color: @tooltip-bg;
  border-radius: @border-radius-base;
}

// Arrows
.tooltip-arrow {
  position: absolute;
  width: 0;
  height: 0;
  border-color: transparent;
  border-style: solid;
}
// Note: Deprecated .top-left, .top-right, .bottom-left, and .bottom-right as of v3.3.1
.tooltip {
  &.top .tooltip-arrow {
    bottom: 0;
    left: 50%;
    margin-left: -@tooltip-arrow-width;
    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
    border-top-color: @tooltip-arrow-color;
  }
  &.top-left .tooltip-arrow {
    bottom: 0;
    right: @tooltip-arrow-width;
    margin-bottom: -@tooltip-arrow-width;
    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
    border-top-color: @tooltip-arrow-color;
  }
  &.top-right .tooltip-arrow {
    bottom: 0;
    left: @tooltip-arrow-width;
    margin-bottom: -@tooltip-arrow-width;
    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
    border-top-color: @tooltip-arrow-color;
  }
  &.right .tooltip-arrow {
    top: 50%;
    left: 0;
    margin-top: -@tooltip-arrow-width;
    border-width: @tooltip-arrow-width @tooltip-arrow-width @tooltip-arrow-width 0;
    border-right-color: @tooltip-arrow-color;
  }
  &.left .tooltip-arrow {
    top: 50%;
    right: 0;
    margin-top: -@tooltip-arrow-width;
    border-width: @tooltip-arrow-width 0 @tooltip-arrow-width @tooltip-arrow-width;
    border-left-color: @tooltip-arrow-color;
  }
  &.bottom .tooltip-arrow {
    top: 0;
    left: 50%;
    margin-left: -@tooltip-arrow-width;
    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
    border-bottom-color: @tooltip-arrow-color;
  }
  &.bottom-left .tooltip-arrow {
    top: 0;
    right: @tooltip-arrow-width;
    margin-top: -@tooltip-arrow-width;
    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
    border-bottom-color: @tooltip-arrow-color;
  }
  &.bottom-right .tooltip-arrow {
    top: 0;
    left: @tooltip-arrow-width;
    margin-top: -@tooltip-arrow-width;
    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
    border-bottom-color: @tooltip-arrow-color;
  }
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/type.less
================================================
//
// Typography
// --------------------------------------------------


// Headings
// -------------------------

h1, h2, h3, h4, h5, h6,
.h1, .h2, .h3, .h4, .h5, .h6 {
  font-family: @headings-font-family;
  font-weight: @headings-font-weight;
  line-height: @headings-line-height;
  color: @headings-color;

  small,
  .small {
    font-weight: normal;
    line-height: 1;
    color: @headings-small-color;
  }
}

h1, .h1,
h2, .h2,
h3, .h3 {
  margin-top: @line-height-computed;
  margin-bottom: (@line-height-computed / 2);

  small,
  .small {
    font-size: 65%;
  }
}
h4, .h4,
h5, .h5,
h6, .h6 {
  margin-top: (@line-height-computed / 2);
  margin-bottom: (@line-height-computed / 2);

  small,
  .small {
    font-size: 75%;
  }
}

h1, .h1 { font-size: @font-size-h1; }
h2, .h2 { font-size: @font-size-h2; }
h3, .h3 { font-size: @font-size-h3; }
h4, .h4 { font-size: @font-size-h4; }
h5, .h5 { font-size: @font-size-h5; }
h6, .h6 { font-size: @font-size-h6; }


// Body text
// -------------------------

p {
  margin: 0 0 (@line-height-computed / 2);
}

.lead {
  margin-bottom: @line-height-computed;
  font-size: floor((@font-size-base * 1.15));
  font-weight: 300;
  line-height: 1.4;

  @media (min-width: @screen-sm-min) {
    font-size: (@font-size-base * 1.5);
  }
}


// Emphasis & misc
// -------------------------

// Ex: (12px small font / 14px base font) * 100% = about 85%
small,
.small {
  font-size: floor((100% * @font-size-small / @font-size-base));
}

mark,
.mark {
  background-color: @state-warning-bg;
  padding: .2em;
}

// Alignment
.text-left           { text-align: left; }
.text-right          { text-align: right; }
.text-center         { text-align: center; }
.text-justify        { text-align: justify; }
.text-nowrap         { white-space: nowrap; }

// Transformation
.text-lowercase      { text-transform: lowercase; }
.text-uppercase      { text-transform: uppercase; }
.text-capitalize     { text-transform: capitalize; }

// Contextual colors
.text-muted {
  color: @text-muted;
}
.text-primary {
  .text-emphasis-variant(@brand-primary);
}
.text-success {
  .text-emphasis-variant(@state-success-text);
}
.text-info {
  .text-emphasis-variant(@state-info-text);
}
.text-warning {
  .text-emphasis-variant(@state-warning-text);
}
.text-danger {
  .text-emphasis-variant(@state-danger-text);
}

// Contextual backgrounds
// For now we'll leave these alongside the text classes until v4 when we can
// safely shift things around (per SemVer rules).
.bg-primary {
  // Given the contrast here, this is the only class to have its color inverted
  // automatically.
  color: #fff;
  .bg-variant(@brand-primary);
}
.bg-success {
  .bg-variant(@state-success-bg);
}
.bg-info {
  .bg-variant(@state-info-bg);
}
.bg-warning {
  .bg-variant(@state-warning-bg);
}
.bg-danger {
  .bg-variant(@state-danger-bg);
}


// Page header
// -------------------------

.page-header {
  padding-bottom: ((@line-height-computed / 2) - 1);
  margin: (@line-height-computed * 2) 0 @line-height-computed;
  border-bottom: 1px solid @page-header-border-color;
}


// Lists
// -------------------------

// Unordered and Ordered lists
ul,
ol {
  margin-top: 0;
  margin-bottom: (@line-height-computed / 2);
  ul,
  ol {
    margin-bottom: 0;
  }
}

// List options

// Unstyled keeps list items block level, just removes default browser padding and list-style
.list-unstyled {
  padding-left: 0;
  list-style: none;
}

// Inline turns list items into inline-block
.list-inline {
  .list-unstyled();
  margin-left: -5px;

  > li {
    display: inline-block;
    padding-left: 5px;
    padding-right: 5px;
  }
}

// Description Lists
dl {
  margin-top: 0; // Remove browser default
  margin-bottom: @line-height-computed;
}
dt,
dd {
  line-height: @line-height-base;
}
dt {
  font-weight: bold;
}
dd {
  margin-left: 0; // Undo browser default
}

// Horizontal description lists
//
// Defaults to being stacked without any of the below styles applied, until the
// grid breakpoint is reached (default of ~768px).

.dl-horizontal {
  dd {
    &:extend(.clearfix all); // Clear the floated `dt` if an empty `dd` is present
  }

  @media (min-width: @grid-float-breakpoint) {
    dt {
      float: left;
      width: (@dl-horizontal-offset - 20);
      clear: left;
      text-align: right;
      .text-overflow();
    }
    dd {
      margin-left: @dl-horizontal-offset;
    }
  }
}


// Misc
// -------------------------

// Abbreviations and acronyms
abbr[title],
// Add data-* attribute to help out our tooltip plugin, per https://github.com/twbs/bootstrap/issues/5257
abbr[data-original-title] {
  cursor: help;
  border-bottom: 1px dotted @abbr-border-color;
}
.initialism {
  font-size: 90%;
  .text-uppercase();
}

// Blockquotes
blockquote {
  padding: (@line-height-computed / 2) @line-height-computed;
  margin: 0 0 @line-height-computed;
  font-size: @blockquote-font-size;
  border-left: 5px solid @blockquote-border-color;

  p,
  ul,
  ol {
    &:last-child {
      margin-bottom: 0;
    }
  }

  // Note: Deprecated small and .small as of v3.1.0
  // Context: https://github.com/twbs/bootstrap/issues/11660
  footer,
  small,
  .small {
    display: block;
    font-size: 80%; // back to default font-size
    line-height: @line-height-base;
    color: @blockquote-small-color;

    &:before {
      content: '\2014 \00A0'; // em dash, nbsp
    }
  }
}

// Opposite alignment of blockquote
//
// Heads up: `blockquote.pull-right` has been deprecated as of v3.1.0.
.blockquote-reverse,
blockquote.pull-right {
  padding-right: 15px;
  padding-left: 0;
  border-right: 5px solid @blockquote-border-color;
  border-left: 0;
  text-align: right;

  // Account for citation
  footer,
  small,
  .small {
    &:before { content: ''; }
    &:after {
      content: '\00A0 \2014'; // nbsp, em dash
    }
  }
}

// Addresses
address {
  margin-bottom: @line-height-computed;
  font-style: normal;
  line-height: @line-height-base;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/utilities.less
================================================
//
// Utility classes
// --------------------------------------------------


// Floats
// -------------------------

.clearfix {
  .clearfix();
}
.center-block {
  .center-block();
}
.pull-right {
  float: right !important;
}
.pull-left {
  float: left !important;
}


// Toggling content
// -------------------------

// Note: Deprecated .hide in favor of .hidden or .sr-only (as appropriate) in v3.0.1
.hide {
  display: none !important;
}
.show {
  display: block !important;
}
.invisible {
  visibility: hidden;
}
.text-hide {
  .text-hide();
}


// Hide from screenreaders and browsers
//
// Credit: HTML5 Boilerplate

.hidden {
  display: none !important;
}


// For Affix plugin
// -------------------------

.affix {
  position: fixed;
}


================================================
FILE: examples/libraries/fmt/doc/bootstrap/variables.less
================================================
//
// Variables
// --------------------------------------------------


//== Colors
//
//## Gray and brand colors for use across Bootstrap.

@gray-base:              #000;
@gray-darker:            lighten(@gray-base, 13.5%); // #222
@gray-dark:              lighten(@gray-base, 20%);   // #333
@gray:                   lighten(@gray-base, 33.5%); // #555
@gray-light:             lighten(@gray-base, 46.7%); // #777
@gray-lighter:           lighten(@gray-base, 93.5%); // #eee

@brand-primary:         darken(#428bca, 6.5%); // #337ab7
@brand-success:         #5cb85c;
@brand-info:            #5bc0de;
@brand-warning:         #f0ad4e;
@brand-danger:          #d9534f;


//== Scaffolding
//
//## Settings for some of the most global styles.

//** Background color for `<body>`.
@body-bg:               #fff;
//** Global text color on `<body>`.
@text-color:            @gray-dark;

//** Global textual link color.
@link-color:            @brand-primary;
//** Link hover color set via `darken()` function.
@link-hover-color:      darken(@link-color, 15%);
//** Link hover decoration.
@link-hover-decoration: underline;


//== Typography
//
//## Font, line-height, and color for body text, headings, and more.

@font-family-sans-serif:  "Helvetica Neue", Helvetica, Arial, sans-serif;
@font-family-serif:       Georgia, "Times New Roman", Times, serif;
//** Default monospace fonts for `<code>`, `<kbd>`, and `<pre>`.
@font-family-monospace:   Menlo, Monaco, Consolas, "Courier New", monospace;
@font-family-base:        @font-family-sans-serif;

@font-size-base:          14px;
@font-size-large:         ceil((@font-size-base * 1.25)); // ~18px
@font-size-small:         ceil((@font-size-base * 0.85)); // ~12px

@font-size-h1:            floor((@font-size-base * 2.6)); // ~36px
@font-size-h2:            floor((@font-size-base * 2.15)); // ~30px
@font-size-h3:            ceil((@font-size-base * 1.7)); // ~24px
@font-size-h4:            ceil((@font-size-base * 1.25)); // ~18px
@font-size-h5:            @font-size-base;
@font-size-h6:            ceil((@font-size-base * 0.85)); // ~12px

//** Unit-less `line-height` for use in components like buttons.
@line-height-base:        1.428571429; // 20/14
//** Computed "line-height" (`font-size` * `line-height`) for use with `margin`, `padding`, etc.
@line-height-computed:    floor((@font-size-base * @line-height-base)); // ~20px

//** By default, this inherits from the `<body>`.
@headings-font-family:    inherit;
@headings-font-weight:    500;
@headings-line-height:    1.1;
@headings-color:          inherit;


//== Iconography
//
//## Specify custom location and filename of the included Glyphicons icon font. Useful for those including Bootstrap via Bower.

//** Load fonts from this directory.
@icon-font-path:          "../fonts/";
//** File name for all font files.
@icon-font-name:          "glyphicons-halflings-regular";
//** Element ID within SVG icon file.
@icon-font-svg-id:        "glyphicons_halflingsregular";


//== Components
//
//## Define common padding and border radius sizes and more. Values based on 14px text and 1.428 line-height (~20px to start).

@padding-base-vertical:     6px;
@padding-base-horizontal:   12px;

@padding-large-vertical:    10px;
@padding-large-horizontal:  16px;

@padding-small-vertical:    5px;
@padding-small-horizontal:  10px;

@padding-xs-vertical:       1px;
@padding-xs-horizontal:     5px;

@line-height-large:         1.3333333; // extra decimals for Win 8.1 Chrome
@line-height-small:         1.5;

@border-radius-base:        4px;
@border-radius-large:       6px;
@border-radius-small:       3px;

//** Global color for active items (e.g., navs or dropdowns).
@component-active-color:    #fff;
//** Global background color for active items (e.g., navs or dropdowns).
@component-active-bg:       @brand-primary;

//** Width of the `border` for generating carets that indicator dropdowns.
@caret-width-base:          4px;
//** Carets increase slightly in size for larger components.
@caret-width-large:         5px;


//== Tables
//
//## Customizes the `.table` component with basic values, each used across all table variations.

//** Padding for `<th>`s and `<td>`s.
@table-cell-padding:            8px;
//** Padding for cells in `.table-condensed`.
@table-condensed-cell-padding:  5px;

//** Default background color used for all tables.
@table-bg:                      transparent;
//** Background color used for `.table-striped`.
@table-bg-accent:               #f9f9f9;
//** Background color used for `.table-hover`.
@table-bg-hover:                #f5f5f5;
@table-bg-active:               @table-bg-hover;

//** Border color for table and cell borders.
@table-border-color:            #ddd;


//== Buttons
//
//## For each of Bootstrap's buttons, define text, background and border color.

@btn-font-weight:                normal;

@btn-default-color:              #333;
@btn-default-bg:                 #fff;
@btn-default-border:             #ccc;

@btn-primary-color:              #fff;
@btn-primary-bg:                 @brand-primary;
@btn-primary-border:             darken(@btn-primary-bg, 5%);

@btn-success-color:              #fff;
@btn-success-bg:                 @brand-success;
@btn-success-border:             darken(@btn-success-bg, 5%);

@btn-info-color:                 #fff;
@btn-info-bg:                    @brand-info;
@btn-info-border:                darken(@btn-info-bg, 5%);

@btn-warning-color:              #fff;
@btn-warning-bg:                 @brand-warning;
@btn-warning-border:             darken(@btn-warning-bg, 5%);

@btn-danger-color:               #fff;
@btn-danger-bg:                  @brand-danger;
@btn-danger-border:              darken(@btn-danger-bg, 5%);

@btn-link-disabled-color:        @gray-light;


//== Forms
//
//##

//** `<input>` background color
@input-bg:                       #fff;
//** `<input disabled>` background color
@input-bg-disabled:              @gray-lighter;

//** Text color for `<input>`s
@input-color:                    @gray;
//** `<input>` border color
@input-border:                   #ccc;

// TODO: Rename `@input-border-radius` to `@input-border-radius-base` in v4
//** Default `.form-control` border radius
// This has no effect on `<select>`s in some browsers, due to the limited stylability of `<select>`s in CSS.
@input-border-radius:            @border-radius-base;
//** Large `.form-control` border radius
@input-border-radius-large:      @border-radius-large;
//** Small `.form-control` border radius
@input-border-radius-small:      @border-radius-small;

//** Border color for inputs on focus
@input-border-focus:             #66afe9;

//** Placeholder text color
@input-color-placeholder:        #999;

//** Default `.form-control` height
@input-height-base:              (@line-height-computed + (@padding-base-vertical * 2) + 2);
//** Large `.form-control` height
@input-height-large:             (ceil(@font-size-large * @line-height-large) + (@padding-large-vertical * 2) + 2);
//** Small `.form-control` height
@input-height-small:             (floor(@font-size-small * @line-height-small) + (@padding-small-vertical * 2) + 2);

//** `.form-group` margin
@form-group-margin-bottom:       15px;

@legend-color:                   @gray-dark;
@legend-border-color:            #e5e5e5;

//** Background color for textual input addons
@input-group-addon-bg:           @gray-lighter;
//** Border color for textual input addons
@input-group-addon-border-color: @input-border;

//** Disabled cursor for form controls and buttons.
@cursor-disabled:                not-allowed;


//== Dropdowns
//
//## Dropdown menu container and contents.

//** Background for the dropdown menu.
@dropdown-bg:                    #fff;
//** Dropdown menu `border-color`.
@dropdown-border:                rgba(0,0,0,.15);
//** Dropdown menu `border-color` **for IE8**.
@dropdown-fallback-border:       #ccc;
//** Divider color for between dropdown items.
@dropdown-divider-bg:            #e5e5e5;

//** Dropdown link text color.
@dropdown-link-color:            @gray-dark;
//** Hover color for dropdown links.
@dropdown-link-hover-color:      darken(@gray-dark, 5%);
//** Hover background for dropdown links.
@dropdown-link-hover-bg:         #f5f5f5;

//** Active dropdown menu item text color.
@dropdown-link-active-color:     @component-active-color;
//** Active dropdown menu item background color.
@dropdown-link-active-bg:        @component-active-bg;

//** Disabled dropdown menu item background color.
@dropdown-link-disabled-color:   @gray-light;

//** Text color for headers within dropdown menus.
@dropdown-header-color:          @gray-light;

//** Deprecated `@dropdown-caret-color` as of v3.1.0
@dropdown-caret-color:           #000;


//-- Z-index master list
//
// Warning: Avoid customizing these values. They're used for a bird's eye view
// of components dependent on the z-axis and are designed to all work together.
//
// Note: These variables are not generated into the Customizer.

@zindex-navbar:            1000;
@zindex-dropdown:          1000;
@zindex-popover:           1060;
@zindex-tooltip:           1070;
@zindex-navbar-fixed:      1030;
@zindex-modal-background:  1040;
@zindex-modal:             1050;


//== Media queries breakpoints
//
//## Define the breakpoints at which your layout will change, adapting to different screen sizes.

// Extra small screen / phone
//** Deprecated `@screen-xs` as of v3.0.1
@screen-xs:                  480px;
//** Deprecated `@screen-xs-min` as of v3.2.0
@screen-xs-min:              @screen-xs;
//** Deprecated `@screen-phone` as of v3.0.1
@screen-phone:               @screen-xs-min;

// Small screen / tablet
//** Deprecated `@screen-sm` as of v3.0.1
@screen-sm:                  768px;
@screen-sm-min:              @screen-sm;
//** Deprecated `@screen-tablet` as of v3.0.1
@screen-tablet:              @screen-sm-min;

// Medium screen / desktop
//** Deprecated `@screen-md` as of v3.0.1
@screen-md:                  992px;
@screen-md-min:              @screen-md;
//** Deprecated `@screen-desktop` as of v3.0.1
@screen-desktop:             @screen-md-min;

// Large screen / wide desktop
//** Deprecated `@screen-lg` as of v3.0.1
@screen-lg:                  1200px;
@screen-lg-min:              @screen-lg;
//** Deprecated `@screen-lg-desktop` as of v3.0.1
@screen-lg-desktop:          @screen-lg-min;

// So media queries don't overlap when required, provide a maximum
@screen-xs-max:              (@screen-sm-min - 1);
@screen-sm-max:              (@screen-md-min - 1);
@screen-md-max:              (@screen-lg-min - 1);


//== Grid system
//
//## Define your custom responsive grid.

//** Number of columns in the grid.
@grid-columns:              12;
//** Padding between columns. Gets divided in half for the left and right.
@grid-gutter-width:         30px;
// Navbar collapse
//** Point at which the navbar becomes uncollapsed.
@grid-float-breakpoint:     @screen-sm-min;
//** Point at which the navbar begins collapsing.
@grid-float-breakpoint-max: (@grid-float-breakpoint - 1);


//== Container sizes
//
//## Define the maximum width of `.container` for different screen sizes.

// Small screen / tablet
@container-tablet:             (720px + @grid-gutter-width);
//** For `@screen-sm-min` and up.
@container-sm:                 @container-tablet;

// Medium screen / desktop
@container-desktop:            (940px + @grid-gutter-width);
//** For `@screen-md-min` and up.
@container-md:                 @container-desktop;

// Large screen / wide desktop
@container-large-desktop:      (1140px + @grid-gutter-width);
//** For `@screen-lg-min` and up.
@container-lg:                 @container-large-desktop;


//== Navbar
//
//##

// Basics of a navbar
@navbar-height:                    50px;
@navbar-margin-bottom:             @line-height-computed;
@navbar-border-radius:             @border-radius-base;
@navbar-padding-horizontal:        floor((@grid-gutter-width / 2));
@navbar-padding-vertical:          ((@navbar-height - @line-height-computed) / 2);
@navbar-collapse-max-height:       340px;

@navbar-default-color:             #777;
@navbar-default-bg:                #f8f8f8;
@navbar-default-border:            darken(@navbar-default-bg, 6.5%);

// Navbar links
@navbar-default-link-color:                #777;
@navbar-default-link-hover-color:          #333;
@navbar-default-link-hover-bg:             transparent;
@navbar-default-link-active-color:         #555;
@navbar-default-link-active-bg:            darken(@navbar-default-bg, 6.5%);
@navbar-default-link-disabled-color:       #ccc;
@navbar-default-link-disabled-bg:          transparent;

// Navbar brand label
@navbar-default-brand-color:               @navbar-default-link-color;
@navbar-default-brand-hover-color:         darken(@navbar-default-brand-color, 10%);
@navbar-default-brand-hover-bg:            transparent;

// Navbar toggle
@navbar-default-toggle-hover-bg:           #ddd;
@navbar-default-toggle-icon-bar-bg:        #888;
@navbar-default-toggle-border-color:       #ddd;


// Inverted navbar
// Reset inverted navbar basics
@navbar-inverse-color:                      lighten(@gray-light, 15%);
@navbar-inverse-bg:                         #222;
@navbar-inverse-border:                     darken(@navbar-inverse-bg, 10%);

// Inverted navbar links
@navbar-inverse-link-color:                 lighten(@gray-light, 15%);
@navbar-inverse-link-hover-color:           #fff;
@navbar-inverse-link-hover-bg:              transparent;
@navbar-inverse-link-active-color:          @navbar-inverse-link-hover-color;
@navbar-inverse-link-active-bg:             darken(@navbar-inverse-bg, 10%);
@navbar-inverse-link-disabled-color:        #444;
@navbar-inverse-link-disabled-bg:           transparent;

// Inverted navbar brand label
@navbar-inverse-brand-color:                @navbar-inverse-link-color;
@navbar-inverse-brand-hover-color:          #fff;
@navbar-inverse-brand-hover-bg:             transparent;

// Inverted navbar toggle
@navbar-inverse-toggle-hover-bg:            #333;
@navbar-inverse-toggle-icon-bar-bg:         #fff;
@navbar-inverse-toggle-border-color:        #333;


//== Navs
//
//##

//=== Shared nav styles
@nav-link-padding:                          10px 15px;
@nav-link-hover-bg:                         @gray-lighter;

@nav-disabled-link-color:                   @gray-light;
@nav-disabled-link-hover-color:             @gray-light;

//== Tabs
@nav-tabs-border-color:                     #ddd;

@nav-tabs-link-hover-border-color:          @gray-lighter;

@nav-tabs-active-link-hover-bg:             @body-bg;
@nav-tabs-active-link-hover-color:          @gray;
@nav-tabs-active-link-hover-border-color:   #ddd;

@nav-tabs-justified-link-border-color:            #ddd;
@nav-tabs-justified-active-link-border-color:     @body-bg;

//== Pills
@nav-pills-border-radius:                   @border-radius-base;
@nav-pills-active-link-hover-bg:            @component-active-bg;
@nav-pills-active-link-hover-color:         @component-active-color;


//== Pagination
//
//##

@pagination-color:                     @link-color;
@pagination-bg:                        #fff;
@pagination-border:                    #ddd;

@pagination-hover-color:               @link-hover-color;
@pagination-hover-bg:                  @gray-lighter;
@pagination-hover-border:              #ddd;

@pagination-active-color:              #fff;
@pagination-active-bg:                 @brand-primary;
@pagination-active-border:             @brand-primary;

@pagination-disabled-color:            @gray-light;
@pagination-disabled-bg:               #fff;
@pagination-disabled-border:           #ddd;


//== Pager
//
//##

@pager-bg:                             @pagination-bg;
@pager-border:                         @pagination-border;
@pager-border-radius:                  15px;

@pager-hover-bg:                       @pagination-hover-bg;

@pager-active-bg:                      @pagination-active-bg;
@pager-active-color:                   @pagination-active-color;

@pager-disabled-color:                 @pagination-disabled-color;


//== Jumbotron
//
//##

@jumbotron-padding:              30px;
@jumbotron-color:                inherit;
@jumbotron-bg:                   @gray-lighter;
@jumbotron-heading-color:        inherit;
@jumbotron-font-size:            ceil((@font-size-base * 1.5));


//== Form states and alerts
//
//## Define colors for form feedback states and, by default, alerts.

@state-success-text:             #3c763d;
@state-success-bg:               #dff0d8;
@state-success-border:           darken(spin(@state-success-bg, -10), 5%);

@state-info-text:                #31708f;
@state-info-bg:                  #d9edf7;
@state-info-border:              darken(spin(@state-info-bg, -10), 7%);

@state-warning-text:             #8a6d3b;
@state-warning-bg:               #fcf8e3;
@state-warning-border:           darken(spin(@state-warning-bg, -10), 5%);

@state-danger-text:              #a94442;
@state-danger-bg:                #f2dede;
@state-danger-border:            darken(spin(@state-danger-bg, -10), 5%);


//== Tooltips
//
//##

//** Tooltip max width
@tooltip-max-width:           200px;
//** Tooltip text color
@tooltip-color:               #fff;
//** Tooltip background color
@tooltip-bg:                  #000;
@tooltip-opacity:             .9;

//** Tooltip arrow width
@tooltip-arrow-width:         5px;
//** Tooltip arrow color
@tooltip-arrow-color:         @tooltip-bg;


//== Popovers
//
//##

//** Popover body background color
@popover-bg:                          #fff;
//** Popover maximum width
@popover-max-width:                   276px;
//** Popover border color
@popover-border-color:                rgba(0,0,0,.2);
//** Popover fallback border color
@popover-fallback-border-color:       #ccc;

//** Popover title background color
@popover-title-bg:                    darken(@popover-bg, 3%);

//** Popover arrow width
@popover-arrow-width:                 10px;
//** Popover arrow color
@popover-arrow-color:                 @popover-bg;

//** Popover outer arrow width
@popover-arrow-outer-width:           (@popover-arrow-width + 1);
//** Popover outer arrow color
@popover-arrow-outer-color:           fadein(@popover-border-color, 5%);
//** Popover outer arrow fallback color
@popover-arrow-outer-fallback-color:  darken(@popover-fallback-border-color, 20%);


//== Labels
//
//##

//** Default label background color
@label-default-bg:            @gray-light;
//** Primary label background color
@label-primary-bg:            @brand-primary;
//** Success label background color
@label-success-bg:            @brand-success;
//** Info label background color
@label-info-bg:               @brand-info;
//** Warning label background color
@label-warning-bg:            @brand-warning;
//** Danger label background color
@label-danger-bg:             @brand-danger;

//** Default label text color
@label-color:                 #fff;
//** Default text color of a linked label
@label-link-hover-color:      #fff;


//== Modals
//
//##

//** Padding applied to the modal body
@modal-inner-padding:         15px;

//** Padding applied to the modal title
@modal-title-padding:         15px;
//** Modal title line-height
@modal-title-line-height:     @line-height-base;

//** Background color of modal content area
@modal-content-bg:                             #fff;
//** Modal content border color
@modal-content-border-color:                   rgba(0,0,0,.2);
//** Modal content border color **for IE8**
@modal-content-fallback-border-color:          #999;

//** Modal backdrop background color
@modal-backdrop-bg:           #000;
//** Modal backdrop opacity
@modal-backdrop-opacity:      .5;
//** Modal header border color
@modal-header-border-color:   #e5e5e5;
//** Modal footer border color
@modal-footer-border-color:   @modal-header-border-color;

@modal-lg:                    900px;
@modal-md:                    600px;
@modal-sm:                    300px;


//== Alerts
//
//## Define alert colors, border radius, and padding.

@alert-padding:               15px;
@alert-border-radius:         @border-radius-base;
@alert-link-font-weight:      bold;

@alert-success-bg:            @state-success-bg;
@alert-success-text:          @state-success-text;
@alert-success-border:        @state-success-border;

@alert-info-bg:               @state-info-bg;
@alert-info-text:             @state-info-text;
@alert-info-border:           @state-info-border;

@alert-warning-bg:            @state-warning-bg;
@alert-warning-text:          @state-warning-text;
@alert-warning-border:        @state-warning-border;

@alert-danger-bg:             @state-danger-bg;
@alert-danger-text:           @state-danger-text;
@alert-danger-border:         @state-danger-border;


//== Progress bars
//
//##

//** Background color of the whole progress component
@progress-bg:                 #f5f5f5;
//** Progress bar text color
@progress-bar-color:          #fff;
//** Variable for setting rounded corners on progress bar.
@progress-border-radius:      @border-radius-base;

//** Default progress bar color
@progress-bar-bg:             @brand-primary;
//** Success progress bar color
@progress-bar-success-bg:     @brand-success;
//** Warning progress bar color
@progress-bar-warning-bg:     @brand-warning;
//** Danger progress bar color
@progress-bar-danger-bg:      @brand-danger;
//** Info progress bar color
@progress-bar-info-bg:        @brand-info;


//== List group
//
//##

//** Background color on `.list-group-item`
@list-group-bg:                 #fff;
//** `.list-group-item` border color
@list-group-border:             #ddd;
//** List group border radius
@list-group-border-radius:      @border-radius-base;

//** Background color of single list items on hover
@list-group-hover-bg:           #f5f5f5;
//** Text color of active list items
@list-group-active-color:       @component-active-color;
//** Background color of active list items
@list-group-active-bg:          @component-active-bg;
//** Border color of active list elements
@list-group-active-border:      @list-group-active-bg;
//** Text color for content within active list items
@list-group-active-text-color:  lighten(@list-group-active-bg, 40%);

//** Text color of disabled list items
@list-group-disabled-color:      @gray-light;
//** Background color of disabled list items
@list-group-disabled-bg:         @gray-lighter;
//** Text color for content within disabled list items
@list-group-disabled-text-color: @list-group-disabled-color;

@list-group-link-color:         #555;
@list-group-link-hover-color:   @list-group-link-color;
@list-group-link-heading-color: #333;


//== Panels
//
//##

@panel-bg:                    #fff;
@panel-body-padding:          15px;
@panel-heading-padding:       10px 15px;
@panel-footer-padding:        @panel-heading-padding;
@panel-border-radius:         @border-radius-base;

//** Border color for elements within panels
@panel-inner-border:          #ddd;
@panel-footer-bg:             #f5f5f5;

@panel-default-text:          @gray-dark;
@panel-default-border:        #ddd;
@panel-default-heading-bg:    #f5f5f5;

@panel-primary-text:          #fff;
@panel-primary-border:        @brand-primary;
@panel-primary-heading-bg:    @brand-primary;

@panel-success-text:          @state-success-text;
@panel-success-border:        @state-success-border;
@panel-success-heading-bg:    @state-success-bg;

@panel-info-text:             @state-info-text;
@panel-info-border:           @state-info-border;
@panel-info-heading-bg:       @state-info-bg;

@panel-warning-text:          @state-warning-text;
@panel-warning-border:        @state-warning-border;
@panel-warning-heading-bg:    @state-warning-bg;

@panel-danger-text:           @state-danger-text;
@panel-danger-border:         @state-danger-border;
@panel-danger-heading-bg:     @state-danger-bg;


//== Thumbnails
//
//##

//** Padding around the thumbnail image
@thumbnail-padding:           4px;
//** Thumbnail background color
@thumbnail-bg:                @body-bg;
//** Thumbnail border color
@thumbnail-border:            #ddd;
//** Thumbnail border radius
@thumbnail-border-radius:     @border-radius-base;

//** Custom text color for thumbnail captions
@thumbnail-caption-color:     @text-color;
//** Padding around the thumbnail caption
@thumbnail-caption-padding:   9px;


//== Wells
//
//##

@well-bg:                     #f5f5f5;
@well-border:                 darken(@well-bg, 7%);


//== Badges
//
//##

@badge-color:                 #fff;
//** Linked badge text color on hover
@badge-link-hover-color:      #fff;
@badge-bg:                    @gray-light;

//** Badge text color in active nav link
@badge-active-color:          @link-color;
//** Badge background color in active nav link
@badge-active-bg:             #fff;

@badge-font-weight:           bold;
@badge-line-height:           1;
@badge-border-radius:         10px;


//== Breadcrumbs
//
//##

@breadcrumb-padding-vertical:   8px;
@breadcrumb-padding-horizontal: 15px;
//** Breadcrumb background color
@breadcrumb-bg:                 #f5f5f5;
//** Breadcrumb text color
@breadcrumb-color:              #ccc;
//** Text color of current page in the breadcrumb
@breadcrumb-active-color:       @gray-light;
//** Textual separator for between breadcrumb elements
@breadcrumb-separator:          "/";


//== Carousel
//
//##

@carousel-text-shadow:                        0 1px 2px rgba(0,0,0,.6);

@carousel-control-color:                      #fff;
@carousel-control-width:                      15%;
@carousel-control-opacity:                    .5;
@carousel-control-font-size:                  20px;

@carousel-indicator-active-bg:                #fff;
@carousel-indicator-border-color:             #fff;

@carousel-caption-color:                      #fff;


//== Close
//
//##

@close-font-weight:           bold;
@close-color:                 #000;
@close-text-shadow:           0 1px 0 #fff;


//== Code
//
//##

@code-color:                  #c7254e;
@code-bg:                     #f9f2f4;

@kbd-color:                   #fff;
@kbd-bg:                      #333;

@pre-bg:                      #f5f5f5;
@pre-color:                   @gray-dark;
@pre-border-color:            #ccc;
@pre-scrollable-max-height:   340px;


//== Type
//
//##

//** Horizontal offset for forms and lists.
@component-offset-horizontal: 180px;
//** Text muted color
@text-muted:                  @gray-light;
//** Abbreviations and acronyms border color
@abbr-border-color:           @gray-light;
//** Headings small color
@headings-small-color:        @gray-light;
//** Blockquote small color
@blockquote-small-color:      @gray-light;
//** Blockquote font size
@blockquote-font-size:        (@font-size-base * 1.25);
//** Blockquote border color
@blockquote-border-color:     @gray-lighter;
//** Page header border color
@page-header-border-color:    @gray-lighter;
//** Width of horizontal description list titles
@dl-horizontal-offset:        @component-offset-horizontal;
//** Horizontal line color.
@hr-border:                   @gray-lighter;


================================================
FILE: examples/libraries/fmt/doc/bootstrap/wells.less
================================================
//
// Wells
// --------------------------------------------------


// Base class
.well {
  min-height: 20px;
  padding: 19px;
  margin-bottom: 20px;
  background-color: @well-bg;
  border: 1px solid @well-border;
  border-radius: @border-radius-base;
  .box-shadow(inset 0 1px 1px rgba(0,0,0,.05));
  blockquote {
    border-color: #ddd;
    border-color: rgba(0,0,0,.15);
  }
}

// Sizes
.well-lg {
  padding: 24px;
  border-radius: @border-radius-large;
}
.well-sm {
  padding: 9px;
  border-radius: @border-radius-small;
}


================================================
FILE: examples/libraries/fmt/doc/build.py
================================================
#!/usr/bin/env python3
# Build the documentation.

import errno, os, re, sys
from subprocess import check_call, CalledProcessError, Popen, PIPE, STDOUT

versions = ['1.0.0', '1.1.0', '2.0.0', '3.0.2', '4.0.0', '4.1.0', '5.0.0', '5.1.0', '5.2.0', '5.2.1', '5.3.0', '6.0.0', '6.1.0', '6.1.1', '6.1.2', '6.2.0', '6.2.1', '7.0.0', '7.0.1', '7.0.2', '7.0.3', '7.1.0', '7.1.1', '7.1.2', '7.1.3', '8.0.0', '8.0.1']

class Pip:
  def __init__(self, venv_dir):
    self.path = os.path.join(venv_dir, 'bin', 'pip')

  def install(self, package, commit=None):
    "Install package using pip."
    if commit:
      package = 'git+https://github.com/{0}.git@{1}'.format(package, commit)
    print('Installing {0}'.format(package))
    check_call([self.path, 'install', package])

def create_build_env(venv_dir='virtualenv'):
  # Create virtualenv.
  if not os.path.exists(venv_dir):
    check_call(['python3', '-m', 'venv', venv_dir])
  # Install Sphinx and Breathe. Require the exact version of Sphinx which is
  # compatible with Breathe.
  pip = Pip(venv_dir)
  pip.install('wheel')
  pip.install('six')
  pip.install('sphinx-doc/sphinx', 'v3.3.0')
  pip.install('michaeljones/breathe', 'v4.25.0')

def build_docs(version='dev', **kwargs):
  doc_dir = kwargs.get('doc_dir', os.path.dirname(os.path.realpath(__file__)))
  work_dir = kwargs.get('work_dir', '.')
  include_dir = kwargs.get(
      'include_dir', os.path.join(os.path.dirname(doc_dir), 'include', 'fmt'))
  # Build docs.
  cmd = ['doxygen', '-']
  p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
  doxyxml_dir = os.path.join(work_dir, 'doxyxml')
  out, _ = p.communicate(input=r'''
      PROJECT_NAME      = fmt
      GENERATE_LATEX    = NO
      GENERATE_MAN      = NO
      GENERATE_RTF      = NO
      CASE_SENSE_NAMES  = NO
      INPUT             = {0}/chrono.h {0}/color.h {0}/core.h {0}/compile.h \
                          {0}/format.h {0}/os.h {0}/ostream.h {0}/printf.h \
                          {0}/xchar.h
      QUIET             = YES
      JAVADOC_AUTOBRIEF = YES
      AUTOLINK_SUPPORT  = NO
      GENERATE_HTML     = NO
      GENERATE_XML      = YES
      XML_OUTPUT        = {1}
      ALIASES           = "rst=\verbatim embed:rst"
      ALIASES          += "endrst=\endverbatim"
      MACRO_EXPANSION   = YES
      PREDEFINED        = _WIN32=1 \
                          __linux__=1 \
                          FMT_USE_VARIADIC_TEMPLATES=1 \
                          FMT_USE_RVALUE_REFERENCES=1 \
                          FMT_USE_USER_DEFINED_LITERALS=1 \
                          FMT_USE_ALIAS_TEMPLATES=1 \
                          FMT_API= \
                          "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
                          "FMT_END_NAMESPACE=}}" \
                          "FMT_STRING_ALIAS=1" \
                          "FMT_VARIADIC(...)=" \
                          "FMT_VARIADIC_W(...)=" \
                          "FMT_DOC=1"
      EXCLUDE_SYMBOLS   = fmt::formatter fmt::printf_formatter fmt::arg_join \
                          fmt::basic_format_arg::handle
    '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
  out = out.decode('utf-8')
  internal_symbols = [
    'fmt::detail::.*',
    'basic_data<>',
    'fmt::type_identity',
    'fmt::dynamic_formatter'
  ]
  noisy_warnings = [
    'warning: (Compound|Member .* of class) (' + '|'.join(internal_symbols) + \
      ') is not documented.',
    'warning: Internal inconsistency: .* does not belong to any container!'
  ]
  for w in noisy_warnings:
      out = re.sub('.*' + w + '\n', '', out)
  print(out)
  if p.returncode != 0:
    raise CalledProcessError(p.returncode, cmd)

  html_dir = os.path.join(work_dir, 'html')
  main_versions = reversed(versions[-3:])
  check_call([os.path.join(work_dir, 'virtualenv', 'bin', 'sphinx-build'),
              '-Dbreathe_projects.format=' + os.path.abspath(doxyxml_dir),
              '-Dversion=' + version, '-Drelease=' + version,
              '-Aversion=' + version, '-Aversions=' + ','.join(main_versions),
              '-b', 'html', doc_dir, html_dir])
  try:
    check_call(['lessc', '--verbose', '--clean-css',
                '--include-path=' + os.path.join(doc_dir, 'bootstrap'),
                os.path.join(doc_dir, 'fmt.less'),
                os.path.join(html_dir, '_static', 'fmt.css')])
  except OSError as e:
    if e.errno != errno.ENOENT:
      raise
    print('lessc not found; make sure that Less (http://lesscss.org/) ' +
          'is installed')
    sys.exit(1)
  return html_dir

if __name__ == '__main__':
  create_build_env()
  build_docs(sys.argv[1])


================================================
FILE: examples/libraries/fmt/doc/conf.py
================================================
# -*- coding: utf-8 -*-
#
# format documentation build configuration file, created by
# sphinx-quickstart on Tue Dec 18 06:46:16 2012.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

import sys, os, re, subprocess

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))

# -- General configuration -----------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.2'

if os.environ.get('READTHEDOCS', None) == 'True':
  subprocess.call('doxygen')

# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.ifconfig', 'breathe']

breathe_default_project = "format"
breathe_domain_by_extension = {"h" : "cpp"}

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The encoding of source files.
#source_encoding = 'utf-8-sig'

# The master toctree document.
#master_doc = 'contents'

# General information about the project.
project = u'fmt'
copyright = u'2012-present, Victor Zverovich'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.

# Version and release are passed from CMake.
#version = None

# The full version, including alpha/beta/rc tags.
#release = version

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None

# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['virtualenv']

# The reST default role (used for this markup: `text`) to use for all documents.
default_role = 'cpp:any'

# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True

# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True

# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

highlight_language = 'c++'

primary_domain = 'cpp'

# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []


# -- Options for HTML output ---------------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
html_theme = 'basic-bootstrap'

# Theme options are theme-specific and customize the look and feel of a theme
# further.  For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}

# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = ['.']

# The name for this set of Sphinx documents.  If None, it defaults to
# "<project> v<release> documentation".
#html_title = None

# A shorter title for the navigation bar.  Default is the same as html_title.
#html_short_title = None

# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None

# The name of an image file (within the static path) to use as favicon of the
# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']

# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'

# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True

# Custom sidebar templates, maps document names to template names.
html_sidebars = {
  '**': ['localtoc.html', 'relations.html', 'sourcelink.html', 'searchbox.html']
}

# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}

# If false, no module index is generated.
#html_domain_indices = True

# If false, no index is generated.
#html_use_index = True

# If true, the index is split into individual pages for each letter.
#html_split_index = False

# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True

# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True

# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True

# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it.  The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''

# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None

# Output file base name for HTML help builder.
htmlhelp_basename = 'formatdoc'


# -- Options for LaTeX output --------------------------------------------------

latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',

# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',

# Additional stuff for the LaTeX preamble.
#'preamble': '',
}

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
  ('index', 'format.tex', u'fmt documentation',
   u'Victor Zverovich', 'manual'),
]

# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None

# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False

# If true, show page references after internal links.
#latex_show_pagerefs = False

# If true, show URL addresses after external links.
#latex_show_urls = False

# Documents to append as an appendix to all manuals.
#latex_appendices = []

# If false, no module index is generated.
#latex_domain_indices = True


# -- Options for manual page output --------------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('index', 'fmt', u'fmt documentation', [u'Victor Zverovich'], 1)
]

# If true, show URL addresses after external links.
#man_show_urls = False


# -- Options for Texinfo output ------------------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
  ('index', 'fmt', u'fmt documentation',
   u'Victor Zverovich', 'fmt', 'One line description of project.',
   'Miscellaneous'),
]

# Documents to append as an appendix to all manuals.
#texinfo_appendices = []

# If false, no module index is generated.
#texinfo_domain_indices = True

# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'


================================================
FILE: examples/libraries/fmt/doc/contents.rst
================================================
########
Contents
########

.. toctree::
   :maxdepth: 2

   usage
   api
   syntax


================================================
FILE: examples/libraries/fmt/doc/fmt.less
================================================
@import 'bootstrap.less';

@header-bg: #094d75;
@icon-font-path: "fonts/";

html {
  overflow-y: scroll;
}

.navbar {
  border-radius: 0;
  margin-bottom: 0;
  background-color: darken(@header-bg, 10%);
}

.jumbotron {
  #gradient > .vertical(@header-bg; darken(@header-bg, 2%); 50%; 50%);
  background-size: 100% 4px;
  background-color: @header-bg;
  background-repeat: repeat-y;
  color: white;
  text-align: center;
}

div.sphinxsidebar {
  margin-left: 0;
}

// Keep content not too wide for better readability.
.navbar-content, .content {
  .make-md-column-offset(1);
  .make-md-column(10);
  .make-lg-column-offset(2);
  .make-lg-column(8);
}

.footer {
  padding-top: 20px;
  padding-bottom: 20px;
  border-top: 1px solid @gray-lighter;
  text-align: center;
}

// Indent descriptions of classes, functions and macros.
.class dd, .function dd, .macro dd {
  margin-left: 20px;
}

// Remove Bootstrap padding for Sphinx containers.
.breathe-sectiondef.container {
  padding: 0;
}

// Remove Bootstrap padding for Sphinx code elements in API signatures.
.descclassname, .descname {
  padding: 0;
}

// Override center alignment in tables.
td {
  text-align: left;
}

p.rubric {
  margin-top: 10px;
}

.github-btn {
  border: 0;
  overflow: hidden;
}


================================================
FILE: examples/libraries/fmt/doc/index.rst
================================================
Overview
========

**{fmt}** is an open-source formatting library providing a fast and safe
alternative to C stdio and C++ iostreams.

.. raw:: html

   <div class="panel panel-default">
     <div class="panel-heading">What users say:</div>
     <div class="panel-body">
       Thanks for creating this library. It’s been a hole in C++ for
       a long time. I’ve used both <code>boost::format</code> and
       <code>loki::SPrintf</code>, and neither felt like the right answer.
       This does.
     </div>
   </div>

.. _format-api-intro:

Format API
----------

The format API is similar in spirit to the C ``printf`` family of function but
is safer, simpler and several times `faster
<https://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_
than common standard library implementations.
The `format string syntax <syntax.html>`_ is similar to the one used by
`str.format <https://docs.python.org/3/library/stdtypes.html#str.format>`_ in
Python:

.. code:: c++

  std::string s = fmt::format("The answer is {}.", 42);
  
The ``fmt::format`` function returns a string "The answer is 42.". You can use
``fmt::memory_buffer`` to avoid constructing ``std::string``:

.. code:: c++

  auto out = fmt::memory_buffer();
  format_to(std::back_inserter(out),
            "For a moment, {} happened.", "nothing");
  auto data = out.data(); // pointer to the formatted data
  auto size = out.size(); // size of the formatted data

The ``fmt::print`` function performs formatting and writes the result to a stream:

.. code:: c++

  fmt::print(stderr, "System error code = {}\n", errno);

If you omit the file argument the function will print to ``stdout``:

.. code:: c++

  fmt::print("Don't {}\n", "panic");

The format API also supports positional arguments useful for localization:

.. code:: c++

  fmt::print("I'd rather be {1} than {0}.", "right", "happy");

You can pass named arguments with ``fmt::arg``:

.. code:: c++

  fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
             fmt::arg("name", "World"), fmt::arg("number", 42));

If your compiler supports C++11 user-defined literals, the suffix ``_a`` offers 
an alternative, slightly terser syntax for named arguments:

.. code:: c++

  using namespace fmt::literals;
  fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
             "name"_a="World", "number"_a=42);

.. _safety:

Safety
------

The library is fully type safe, automatic memory management prevents buffer
overflow, errors in format strings are reported using exceptions or at compile
time. For example, the code

.. code:: c++

  fmt::format("The answer is {:d}", "forty-two");

throws the ``format_error`` exception because the argument ``"forty-two"`` is a
string while the format code ``d`` only applies to integers.

The code

.. code:: c++

  format(FMT_STRING("The answer is {:d}"), "forty-two");

reports a compile-time error on compilers that support relaxed ``constexpr``.
See `here <api.html#c.fmt>`_ for details.

The following code

.. code:: c++

  fmt::format("Cyrillic letter {}", L'\x42e');
  
produces a compile-time error because wide character ``L'\x42e'`` cannot be
formatted into a narrow string. For comparison, writing a wide character to
``std::ostream`` results in its numeric value being written to the stream
(i.e. 1070 instead of letter 'ю' which is represented by ``L'\x42e'`` if we
use Unicode) which is rarely desirable.

Compact Binary Code
-------------------

The library produces compact per-call compiled code. For example
(`godbolt <https://godbolt.org/g/TZU4KF>`_),

.. code:: c++

   #include <fmt/core.h>

   int main() {
     fmt::print("The answer is {}.", 42);
   }

compiles to just

.. code:: asm

   main: # @main
     sub rsp, 24
     mov qword ptr [rsp], 42
     mov rcx, rsp
     mov edi, offset .L.str
     mov esi, 17
     mov edx, 1
     call fmt::v7::vprint(fmt::v7::basic_string_view<char>, fmt::v7::format_args)
     xor eax, eax
     add rsp, 24
     ret
   .L.str:
     .asciz "The answer is {}."

.. _portability:

Portability
-----------

The library is highly portable and relies only on a small set of C++11 features:

* variadic templates
* type traits
* rvalue references
* decltype
* trailing return types
* deleted functions
* alias templates

These are available in GCC 4.8, Clang 3.4, MSVC 19.0 (2015) and more recent
compiler version. For older compilers use {fmt} `version 4.x
<https://github.com/fmtlib/fmt/releases/tag/4.1.0>`_ which is maintained and
only requires C++98.

The output of all formatting functions is consistent across platforms.
For example,

.. code::

  fmt::print("{}", std::numeric_limits<double>::infinity());

always prints ``inf`` while the output of ``printf`` is platform-dependent.

.. _ease-of-use:

Ease of Use
-----------

{fmt} has a small self-contained code base with the core library consisting of
just three header files and no external dependencies.
A permissive MIT `license <https://github.com/fmtlib/fmt#license>`_ allows
using the library both in open-source and commercial projects.

`Learn more... <contents.html>`_

.. raw:: html

  <a class="btn btn-success" href="https://github.com/fmtlib/fmt">GitHub Repository</a>

  <div class="section footer">
    <iframe src="https://ghbtns.com/github-btn.html?user=fmtlib&amp;repo=fmt&amp;type=watch&amp;count=true"
            class="github-btn" width="100" height="20"></iframe>
  </div>


================================================
FILE: examples/libraries/fmt/doc/python-license.txt
================================================
A. HISTORY OF THE SOFTWARE
==========================

Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC.  Guido remains Python's
principal author, although it includes many contributions from others.

In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.

In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com).  In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property.  Zope Corporation is a sponsoring member of
the PSF.

All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition).  Historically, most, but not all, Python
releases have also been GPL-compatible; the table below summarizes
the various releases.

    Release         Derived     Year        Owner       GPL-
                    from                                compatible? (1)

    0.9.0 thru 1.2              1991-1995   CWI         yes
    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
    1.6             1.5.2       2000        CNRI        no
    2.0             1.6         2000        BeOpen.com  no
    1.6.1           1.6         2001        CNRI        yes (2)
    2.1             2.0+1.6.1   2001        PSF         no
    2.0.1           2.0+1.6.1   2001        PSF         yes
    2.1.1           2.1+2.0.1   2001        PSF         yes
    2.2             2.1.1       2001        PSF         yes
    2.1.2           2.1.1       2002        PSF         yes
    2.1.3           2.1.2       2002        PSF         yes
    2.2.1           2.2         2002        PSF         yes
    2.2.2           2.2.1       2002        PSF         yes
    2.2.3           2.2.2       2003        PSF         yes
    2.3             2.2.2       2002-2003   PSF         yes
    2.3.1           2.3         2002-2003   PSF         yes
    2.3.2           2.3.1       2002-2003   PSF         yes
    2.3.3           2.3.2       2002-2003   PSF         yes
    2.3.4           2.3.3       2004        PSF         yes
    2.3.5           2.3.4       2005        PSF         yes
    2.4             2.3         2004        PSF         yes
    2.4.1           2.4         2005        PSF         yes
    2.4.2           2.4.1       2005        PSF         yes
    2.4.3           2.4.2       2006        PSF         yes
    2.4.4           2.4.3       2006        PSF         yes
    2.5             2.4         2006        PSF         yes
    2.5.1           2.5         2007        PSF         yes
    2.5.2           2.5.1       2008        PSF         yes
    2.5.3           2.5.2       2008        PSF         yes
    2.6             2.5         2008        PSF         yes
    2.6.1           2.6         2008        PSF         yes
    2.6.2           2.6.1       2009        PSF         yes
    2.6.3           2.6.2       2009        PSF         yes
    2.6.4           2.6.3       2009        PSF         yes
    2.6.5           2.6.4       2010        PSF         yes
    3.0             2.6         2008        PSF         yes
    3.0.1           3.0         2009        PSF         yes
    3.1             3.0.1       2009        PSF         yes
    3.1.1           3.1         2009        PSF         yes
    3.1.2           3.1.1       2010        PSF         yes
    3.1.3           3.1.2       2010        PSF         yes
    3.1.4           3.1.3       2011        PSF         yes
    3.2             3.1         2011        PSF         yes
    3.2.1           3.2         2011        PSF         yes
    3.2.2           3.2.1       2011        PSF         yes
    3.2.3           3.2.2       2012        PSF         yes
    3.3.0           3.2         2012        PSF         yes

Footnotes:

(1) GPL-compatible doesn't mean that we're distributing Python under
    the GPL.  All Python licenses, unlike the GPL, let you distribute
    a modified version without making your changes open source.  The
    GPL-compatible licenses make it possible to combine Python with
    other software that is released under the GPL; the others don't.

(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
    because its license has a choice of law clause.  According to
    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
    is "not incompatible" with the GPL.

Thanks to the many outside volunteers who have worked under Guido's
direction to make these releases possible.


B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
===============================================================

PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
--------------------------------------------

1. This LICENSE AGREEMENT is between the Python Software Foundation
("PSF"), and the Individual or Organization ("Licensee") accessing and
otherwise using this software ("Python") in source or binary form and
its associated documentation.

2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011, 2012 Python Software Foundation; All Rights Reserved" are retained in Python
alone or in any derivative version prepared by Licensee.

3. In the event Licensee prepares a derivative work that is based on
or incorporates Python or any part thereof, and wants to make
the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of
the changes made to Python.

4. PSF is making Python available to Licensee on an "AS IS"
basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.

5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.

7. Nothing in this License Agreement shall be deemed to create any
relationship of agency, partnership, or joint venture between PSF and
Licensee.  This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote
products or services of Licensee, or any third party.

8. By copying, installing or otherwise using Python, Licensee
agrees to be bound by the terms and conditions of this License
Agreement.


BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
-------------------------------------------

BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1

1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
Individual or Organization ("Licensee") accessing and otherwise using
this software in source or binary form and its associated
documentation ("the Software").

2. Subject to the terms and conditions of this BeOpen Python License
Agreement, BeOpen hereby grants Licensee a non-exclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform
and/or display publicly, prepare derivative works, distribute, and
otherwise use the Software alone or in any derivative version,
provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an "AS IS"
basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.

6. This License Agreement shall be governed by and interpreted in all
respects by the law of the State of California, excluding conflict of
law provisions.  Nothing in this License Agreement shall be deemed to
create any relationship of agency, partnership, or joint venture
between BeOpen and Licensee.  This License Agreement does not grant
permission to use BeOpen trademarks or trade names in a trademark
sense to endorse or promote products or services of Licensee, or any
third party.  As an exception, the "BeOpen Python" logos available at
http://www.pythonlabs.com/logos.html may be used according to the
permissions granted on that web page.

7. By copying, installing or otherwise using the software, Licensee
agrees to be bound by the terms and conditions of this License
Agreement.


CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
---------------------------------------

1. This LICENSE AGREEMENT is between the Corporation for National
Research Initiatives, having an office at 1895 Preston White Drive,
Reston, VA 20191 ("CNRI"), and the Individual or Organization
("Licensee") accessing and otherwise using Python 1.6.1 software in
source or binary form and its associated documentation.

2. Subject to the terms and conditions of this License Agreement, CNRI
hereby grants Licensee a nonexclusive, royalty-free, world-wide
license to reproduce, analyze, test, perform and/or display publicly,
prepare derivative works, distribute, and otherwise use Python 1.6.1
alone or in any derivative version, provided, however, that CNRI's
License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
1995-2001 Corporation for National Research Initiatives; All Rights
Reserved" are retained in Python 1.6.1 alone or in any derivative
version prepared by Licensee.  Alternately, in lieu of CNRI's License
Agreement, Licensee may substitute the following text (omitting the
quotes): "Python 1.6.1 is made available subject to the terms and
conditions in CNRI's License Agreement.  This Agreement together with
Python 1.6.1 may be located on the Internet using the following
unique, persistent identifier (known as a handle): 1895.22/1013.  This
Agreement may also be obtained from a proxy server on the Internet
using the following URL: http://hdl.handle.net/1895.22/1013".

3. In the event Licensee prepares a derivative work that is based on
or incorporates Python 1.6.1 or any part thereof, and wants to make
the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of
the changes made to Python 1.6.1.

4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.

5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.

7. This License Agreement shall be governed by the federal
intellectual property law of the United States, including without
limitation the federal copyright law, and, to the extent such
U.S. federal law does not apply, by the law of the Commonwealth of
Virginia, excluding Virginia's conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based
on Python 1.6.1 that incorporate non-separable material that was
previously distributed under the GNU General Public License (GPL), the
law of the Commonwealth of Virginia shall govern this License
Agreement only as to issues arising under or with respect to
Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between CNRI and Licensee.  This
License Agreement does not grant permission to use CNRI trademarks or
trade name in a trademark sense to endorse or promote products or
services of Licensee, or any third party.

8. By clicking on the "ACCEPT" button where indicated, or by copying,
installing or otherwise using Python 1.6.1, Licensee agrees to be
bound by the terms and conditions of this License Agreement.

        ACCEPT


CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
--------------------------------------------------

Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
The Netherlands.  All rights reserved.

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


================================================
FILE: examples/libraries/fmt/doc/syntax.rst
================================================
.. _syntax:

********************
Format String Syntax
********************

Formatting functions such as :ref:`fmt::format() <format>` and
:ref:`fmt::print() <print>` use the same format string syntax described in this
section.

Format strings contain "replacement fields" surrounded by curly braces ``{}``.
Anything that is not contained in braces is considered literal text, which is
copied unchanged to the output.  If you need to include a brace character in the
literal text, it can be escaped by doubling: ``{{`` and ``}}``.

The grammar for a replacement field is as follows:

.. productionlist:: sf
   replacement_field: "{" [`arg_id`] [":" (`format_spec` | `chrono_format_spec`)] "}"
   arg_id: `integer` | `identifier`
   integer: `digit`+
   digit: "0"..."9"
   identifier: `id_start` `id_continue`*
   id_start: "a"..."z" | "A"..."Z" | "_"
   id_continue: `id_start` | `digit`

In less formal terms, the replacement field can start with an *arg_id*
that specifies the argument whose value is to be formatted and inserted into
the output instead of the replacement field.
The *arg_id* is optionally followed by a *format_spec*, which is preceded by a
colon ``':'``.  These specify a non-default format for the replacement value.

See also the :ref:`formatspec` section.

If the numerical arg_ids in a format string are 0, 1, 2, ... in sequence,
they can all be omitted (not just some) and the numbers 0, 1, 2, ... will be
automatically inserted in that order.

Named arguments can be referred to by their names or indices.

Some simple format string examples::

   "First, thou shalt count to {0}" // References the first argument
   "Bring me a {}"                  // Implicitly references the first argument
   "From {} to {}"                  // Same as "From {0} to {1}"

The *format_spec* field contains a specification of how the value should be
presented, including such details as field width, alignment, padding, decimal
precision and so on.  Each value type can define its own "formatting
mini-language" or interpretation of the *format_spec*.

Most built-in types support a common formatting mini-language, which is
described in the next section.

A *format_spec* field can also include nested replacement fields in certain
positions within it. These nested replacement fields can contain only an
argument id; format specifications are not allowed. This allows the formatting
of a value to be dynamically specified.

See the :ref:`formatexamples` section for some examples.

.. _formatspec:

Format Specification Mini-Language
==================================

"Format specifications" are used within replacement fields contained within a
format string to define how individual values are presented (see
:ref:`syntax`).  Each formattable type may define how the format
specification is to be interpreted.

Most built-in types implement the following options for format specifications,
although some of the formatting options are only supported by the numeric types.

The general form of a *standard format specifier* is:

.. productionlist:: sf
   format_spec: [[`fill`]`align`][`sign`]["#"]["0"][`width`]["." `precision`]["L"][`type`]
   fill: <a character other than '{' or '}'>
   align: "<" | ">" | "^"
   sign: "+" | "-" | " "
   width: `integer` | "{" [`arg_id`] "}"
   precision: `integer` | "{" [`arg_id`] "}"
   type: "a" | "A" | "b" | "B" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" |
       : "o" | "p" | "s" | "x" | "X"

The *fill* character can be any Unicode code point other than ``'{'`` or
``'}'``. The presence of a fill character is signaled by the character following
it, which must be one of the alignment options. If the second character of
*format_spec* is not a valid alignment option, then it is assumed that both the
fill character and the alignment option are absent.

The meaning of the various alignment options is as follows:

+---------+----------------------------------------------------------+
| Option  | Meaning                                                  |
+=========+==========================================================+
| ``'<'`` | Forces the field to be left-aligned within the available |
|         | space (this is the default for most objects).            |
+---------+----------------------------------------------------------+
| ``'>'`` | Forces the field to be right-aligned within the          |
|         | available space (this is the default for numbers).       |
+---------+----------------------------------------------------------+
| ``'^'`` | Forces the field to be centered within the available     |
|         | space.                                                   |
+---------+----------------------------------------------------------+

Note that unless a minimum field width is defined, the field width will always
be the same size as the data to fill it, so that the alignment option has no
meaning in this case.

The *sign* option is only valid for number types, and can be one of the
following:

+---------+----------------------------------------------------------+
| Option  | Meaning                                                  |
+=========+==========================================================+
| ``'+'`` | indicates that a sign should be used for both            |
|         | positive as well as negative numbers.                    |
+---------+----------------------------------------------------------+
| ``'-'`` | indicates that a sign should be used only for negative   |
|         | numbers (this is the default behavior).                  |
+---------+----------------------------------------------------------+
| space   | indicates that a leading space should be used on         |
|         | positive numbers, and a minus sign on negative numbers.  |
+---------+----------------------------------------------------------+

The ``'#'`` option causes the "alternate form" to be used for the
conversion.  The alternate form is defined differently for different
types.  This option is only valid for integer and floating-point types.
For integers, when binary, octal, or hexadecimal output is used, this
option adds the prefix respective ``"0b"`` (``"0B"``), ``"0"``, or
``"0x"`` (``"0X"``) to the output value.  Whether the prefix is
lower-case or upper-case is determined by the case of the type
specifier, for example, the prefix ``"0x"`` is used for the type ``'x'``
and ``"0X"`` is used for ``'X'``.  For floating-point numbers the
alternate form causes the result of the conversion to always contain a
decimal-point character, even if no digits follow it. Normally, a
decimal-point character appears in the result of these conversions
only if a digit follows it. In addition, for ``'g'`` and ``'G'``
conversions, trailing zeros are not removed from the result.

.. ifconfig:: False

   The ``','`` option signals the use of a comma for a thousands separator.
   For a locale aware separator, use the ``'L'`` integer presentation type
   instead.

*width* is a decimal integer defining the minimum field width.  If not
specified, then the field width will be determined by the content.

Preceding the *width* field by a zero (``'0'``) character enables sign-aware
zero-padding for numeric types. It forces the padding to be placed after the
sign or base (if any) but before the digits. This is used for printing fields in
the form '+000000120'. This option is only valid for numeric types and it has no
effect on formatting of infinity and NaN.

The *precision* is a decimal number indicating how many digits should be
displayed after the decimal point for a floating-point value formatted with
``'f'`` and ``'F'``, or before and after the decimal point for a floating-point
value formatted with ``'g'`` or ``'G'``.  For non-number types the field
indicates the maximum field size - in other words, how many characters will be
used from the field content. The *precision* is not allowed for integer,
character, Boolean, and pointer values.

The ``'L'`` option uses the current locale setting to insert the appropriate
number separator characters. This option is only valid for numeric types.

Finally, the *type* determines how the data should be presented.

The available string presentation types are:

+---------+----------------------------------------------------------+
| Type    | Meaning                                                  |
+=========+==========================================================+
| ``'s'`` | String format. This is the default type for strings and  |
|         | may be omitted.                                          |
+---------+----------------------------------------------------------+
| none    | The same as ``'s'``.                                     |
+---------+----------------------------------------------------------+

The available character presentation types are:

+---------+----------------------------------------------------------+
| Type    | Meaning                                                  |
+=========+==========================================================+
| ``'c'`` | Character format. This is the default type for           |
|         | characters and may be omitted.                           |
+---------+----------------------------------------------------------+
| none    | The same as ``'c'``.                                     |
+---------+----------------------------------------------------------+

The available integer presentation types are:

+---------+----------------------------------------------------------+
| Type    | Meaning                                                  |
+=========+==========================================================+
| ``'b'`` | Binary format. Outputs the number in base 2. Using the   |
|         | ``'#'`` option with this type adds the prefix ``"0b"``   |
|         | to the output value.                                     |
+---------+----------------------------------------------------------+
| ``'B'`` | Binary format. Outputs the number in base 2. Using the   |
|         | ``'#'`` option with this type adds the prefix ``"0B"``   |
|         | to the output value.                                     |
+---------+----------------------------------------------------------+
| ``'c'`` | Character format. Outputs the number as a character.     |
+---------+----------------------------------------------------------+
| ``'d'`` | Decimal integer. Outputs the number in base 10.          |
+---------+----------------------------------------------------------+
| ``'o'`` | Octal format. Outputs the number in base 8.              |
+---------+----------------------------------------------------------+
| ``'x'`` | Hex format. Outputs the number in base 16, using         |
|         | lower-case letters for the digits above 9. Using the     |
|         | ``'#'`` option with this type adds the prefix ``"0x"``   |
|         | to the output value.                                     |
+---------+----------------------------------------------------------+
| ``'X'`` | Hex format. Outputs the number in base 16, using         |
|         | upper-case letters for the digits above 9. Using the     |
|         | ``'#'`` option with this type adds the prefix ``"0X"``   |
|         | to the output value.                                     |
+---------+----------------------------------------------------------+
| none    | The same as ``'d'``.                                     |
+---------+----------------------------------------------------------+

Integer presentation types can also be used with character and Boolean values.
Boolean values are formatted using textual representation, either ``true`` or
``false``, if the presentation type is not specified.

The available presentation types for floating-point values are:

+---------+----------------------------------------------------------+
| Type    | Meaning                                                  |
+=========+==========================================================+
| ``'a'`` | Hexadecimal floating point format. Prints the number in  |
|         | base 16 with prefix ``"0x"`` and lower-case letters for  |
|         | digits above 9. Uses ``'p'`` to indicate the exponent.   |
+---------+----------------------------------------------------------+
| ``'A'`` | Same as ``'a'`` except it uses upper-case letters for    |
|         | the prefix, digits above 9 and to indicate the exponent. |
+---------+----------------------------------------------------------+
| ``'e'`` | Exponent notation. Prints the number in scientific       |
|         | notation using the letter 'e' to indicate the exponent.  |
+---------+----------------------------------------------------------+
| ``'E'`` | Exponent notation. Same as ``'e'`` except it uses an     |
|         | upper-case ``'E'`` as the separator character.           |
+---------+----------------------------------------------------------+
| ``'f'`` | Fixed point. Displays the number as a fixed-point        |
|         | number.                                                  |
+---------+----------------------------------------------------------+
| ``'F'`` | Fixed point. Same as ``'f'``, but converts ``nan`` to    |
|         | ``NAN`` and ``inf`` to ``INF``.                          |
+---------+----------------------------------------------------------+
| ``'g'`` | General format.  For a given precision ``p >= 1``,       |
|         | this rounds the number to ``p`` significant digits and   |
|         | then formats the result in either fixed-point format     |
|         | or in scientific notation, depending on its magnitude.   |
|         |                                                          |
|         | A precision of ``0`` is treated as equivalent to a       |
|         | precision of ``1``.                                      |
+---------+----------------------------------------------------------+
| ``'G'`` | General format. Same as ``'g'`` except switches to       |
|         | ``'E'`` if the number gets too large. The                |
|         | representations of infinity and NaN are uppercased, too. |
+---------+----------------------------------------------------------+
| none    | Similar to ``'g'``, except that the default precision is |
|         | as high as needed to represent the particular value.     |
+---------+----------------------------------------------------------+

.. ifconfig:: False

   +---------+----------------------------------------------------------+
   |         | The precise rules are as follows: suppose that the       |
   |         | result formatted with presentation type ``'e'`` and      |
   |         | precision ``p-1`` would have exponent ``exp``.  Then     |
   |         | if ``-4 <= exp < p``, the number is formatted            |
   |         | with presentation type ``'f'`` and precision             |
   |         | ``p-1-exp``.  Otherwise, the number is formatted         |
   |         | with presentation type ``'e'`` and precision ``p-1``.    |
   |         | In both cases insignificant trailing zeros are removed   |
   |         | from the significand, and the decimal point is also      |
   |         | removed if there are no remaining digits following it.   |
   |         |                                                          |
   |         | Positive and negative infinity, positive and negative    |
   |         | zero, and nans, are formatted as ``inf``, ``-inf``,      |
   |         | ``0``, ``-0`` and ``nan`` respectively, regardless of    |
   |         | the precision.                                           |
   |         |                                                          |
   +---------+----------------------------------------------------------+

The available presentation types for pointers are:

+---------+----------------------------------------------------------+
| Type    | Meaning                                                  |
+=========+==========================================================+
| ``'p'`` | Pointer format. This is the default type for             |
|         | pointers and may be omitted.                             |
+---------+----------------------------------------------------------+
| none    | The same as ``'p'``.                                     |
+---------+----------------------------------------------------------+

.. _chrono-specs:

Chrono Format Specifications
============================

Format specifications for chrono types have the following syntax:

.. productionlist:: sf
   chrono_format_spec: [[`fill`]`align`][`width`]["." `precision`][`chrono_specs`]
   chrono_specs: [`chrono_specs`] `conversion_spec` | `chrono_specs` `literal_char`
   conversion_spec: "%" [`modifier`] `chrono_type`
   literal_char: <a character other than '{', '}' or '%'>
   modifier: "E" | "O"
   chrono_type: "a" | "A" | "b" | "B" | "c" | "C" | "d" | "D" | "e" | "F" |
              : "g" | "G" | "h" | "H" | "I" | "j" | "m" | "M" | "n" | "p" |
              : "q" | "Q" | "r" | "R" | "S" | "t" | "T" | "u" | "U" | "V" |
              : "w" | "W" | "x" | "X" | "y" | "Y" | "z" | "Z" | "%"

Literal chars are copied unchanged to the output. Precision is valid only for
``std::chrono::duration`` types with a floating-point representation type.

The available presentation types (*chrono_type*) for chrono durations and time
points are:

+---------+--------------------------------------------------------------------+
| Type    | Meaning                                                            |
+=========+====================================================================+
| ``'H'`` | The hour (24-hour clock) as a decimal number. If the result is a   |
|         | single digit, it is prefixed with 0. The modified command ``%OH``  |
|         | produces the locale's alternative representation.                  |
+---------+--------------------------------------------------------------------+
| ``'M'`` | The minute as a decimal number. If the result is a single digit,   |
|         | it is prefixed with 0. The modified command ``%OM`` produces the   |
|         | locale's alternative representation.                               |
+---------+--------------------------------------------------------------------+
| ``'S'`` | Seconds as a decimal number. If the number of seconds is less than |
|         | 10, the result is prefixed with 0. If the precision of the input   |
|         | cannot be exactly represented with seconds, then the format is a   |
|         | decimal floating-point number with a fixed format and a precision  |
|         | matching that of the precision of the input (or to a microseconds  |
|         | precision if the conversion to floating-point decimal seconds      |
|         | cannot be made within 18 fractional digits). The character for the |
|         | decimal point is localized according to the locale. The modified   |
|         | command ``%OS`` produces the locale's alternative representation.  |
+---------+--------------------------------------------------------------------+

Specifiers that have a calendaric component such as `'d'` (the day of month)
are valid only for ``std::tm`` and not durations or time points.

``std::tm`` uses the system's `strftime
<https://en.cppreference.com/w/cpp/chrono/c/strftime>`_ so refer to its
documentation for details on supported conversion specifiers. 

.. _formatexamples:

Format Examples
===============

This section contains examples of the format syntax and comparison with
the printf formatting.

In most of the cases the syntax is similar to the printf formatting, with the
addition of the ``{}`` and with ``:`` used instead of ``%``.
For example, ``"%03.2f"`` can be translated to ``"{:03.2f}"``.

The new format syntax also supports new and different options, shown in the
following examples.

Accessing arguments by position::

   fmt::format("{0}, {1}, {2}", 'a', 'b', 'c');
   // Result: "a, b, c"
   fmt::format("{}, {}, {}", 'a', 'b', 'c');
   // Result: "a, b, c"
   fmt::format("{2}, {1}, {0}", 'a', 'b', 'c');
   // Result: "c, b, a"
   fmt::format("{0}{1}{0}", "abra", "cad");  // arguments' indices can be repeated
   // Result: "abracadabra"

Aligning the text and specifying a width::

   fmt::format("{:<30}", "left aligned");
   // Result: "left aligned                  "
   fmt::format("{:>30}", "right aligned");
   // Result: "                 right aligned"
   fmt::format("{:^30}", "centered");
   // Result: "           centered           "
   fmt::format("{:*^30}", "centered");  // use '*' as a fill char
   // Result: "***********centered***********"

Dynamic width::

   fmt::format("{:<{}}", "left aligned", 30);
   // Result: "left aligned                  "

Dynamic precision::

   fmt::format("{:.{}f}", 3.14, 1);
   // Result: "3.1"

Replacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign::

   fmt::format("{:+f}; {:+f}", 3.14, -3.14);  // show it always
   // Result: "+3.140000; -3.140000"
   fmt::format("{: f}; {: f}", 3.14, -3.14);  // show a space for positive numbers
   // Result: " 3.140000; -3.140000"
   fmt::format("{:-f}; {:-f}", 3.14, -3.14);  // show only the minus -- same as '{:f}; {:f}'
   // Result: "3.140000; -3.140000"

Replacing ``%x`` and ``%o`` and converting the value to different bases::

   fmt::format("int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
   // Result: "int: 42;  hex: 2a;  oct: 52; bin: 101010"
   // with 0x or 0 or 0b as prefix:
   fmt::format("int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}", 42);
   // Result: "int: 42;  hex: 0x2a;  oct: 052;  bin: 0b101010"

Padded hex byte with prefix and always prints both hex characters::

   fmt::format("{:#04x}", 0);
   // Result: "0x00"

Box drawing using Unicode fill::

   fmt::print(
     "┌{0:─^{2}}┐\n"
     "│{1: ^{2}}│\n"
     "└{0:─^{2}}┘\n", "", "Hello, world!", 20);

prints::

   ┌────────────────────┐
   │   Hello, world!    │
   └────────────────────┘

Using type-specific formatting::

   #include <fmt/chrono.h>

   auto t = tm();
   t.tm_year = 2010 - 1900;
   t.tm_mon = 7;
   t.tm_mday = 4;
   t.tm_hour = 12;
   t.tm_min = 15;
   t.tm_sec = 58;
   fmt::print("{:%Y-%m-%d %H:%M:%S}", t);
   // Prints: 2010-08-04 12:15:58

Using the comma as a thousands separator::

   #include <fmt/locale.h>

   auto s = fmt::format(std::locale("en_US.UTF-8"), "{:L}", 1234567890);
   // s == "1,234,567,890"

.. ifconfig:: False

   Nesting arguments and more complex examples::

      >>> for align, text in zip('<^>', ['left', 'center', 'right']):
      ...     '{0:{fill}{align}16}") << text, fill=align, align=align)
      ...
      'left<<<<<<<<<<<<'
      '^^^^^center^^^^^'
      '>>>>>>>>>>>right'
      >>>
      >>> octets = [192, 168, 0, 1]
      Format("{:02X}{:02X}{:02X}{:02X}") << *octets)
      'C0A80001'
      >>> int(_, 16)
      3232235521
      >>>
      >>> width = 5
      >>> for num in range(5,12):
      ...     for base in 'dXob':
      ...         print('{0:{width}{base}}") << num, base=base, width=width), end=' ')
      ...     print()
      ...
          5     5     5   101
          6     6     6   110
          7     7     7   111
          8     8    10  1000
          9     9    11  1001
         10     A    12  1010
         11     B    13  1011


================================================
FILE: examples/libraries/fmt/doc/usage.rst
================================================
*****
Usage
*****

To use the {fmt} library, add :file:`fmt/core.h`, :file:`fmt/format.h`,
:file:`fmt/format-inl.h`, :file:`src/format.cc` and optionally other headers
from a `release archive <https://github.com/fmtlib/fmt/releases/latest>`_ or
the `Git repository <https://github.com/fmtlib/fmt>`_ to your project.
Alternatively, you can :ref:`build the library with CMake <building>`.

.. _building:

Building the Library
====================

The included `CMake build script`__ can be used to build the fmt
library on a wide range of platforms. CMake is freely available for
download from https://www.cmake.org/download/.

__ https://github.com/fmtlib/fmt/blob/master/CMakeLists.txt

CMake works by generating native makefiles or project files that can
be used in the compiler environment of your choice. The typical
workflow starts with::

  mkdir build          # Create a directory to hold the build output.
  cd build
  cmake ..  # Generate native build scripts.

where :file:`{<path/to/fmt>}` is a path to the ``fmt`` repository.

If you are on a \*nix system, you should now see a Makefile in the
current directory. Now you can build the library by running :command:`make`.

Once the library has been built you can invoke :command:`make test` to run
the tests.

You can control generation of the make ``test`` target with the ``FMT_TEST``
CMake option. This can be useful if you include fmt as a subdirectory in
your project but don't want to add fmt's tests to your ``test`` target.

If you use Windows and have Visual Studio installed, a :file:`FMT.sln`
file and several :file:`.vcproj` files will be created. You can then build them
using Visual Studio or msbuild.

On Mac OS X with Xcode installed, an :file:`.xcodeproj` file will be generated.

To build a `shared library`__ set the ``BUILD_SHARED_LIBS`` CMake variable to
``TRUE``::

  cmake -DBUILD_SHARED_LIBS=TRUE ...

__ https://en.wikipedia.org/wiki/Library_%28computing%29#Shared_libraries


To build a `static library` with position independent code (required if the main
consumer of the fmt library is a shared library i.e. a Python extension) set the
``CMAKE_POSITION_INDEPENDENT_CODE`` CMake variable to ``TRUE``::

  cmake -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE ...


Installing the Library
======================

After building the library you can install it on a Unix-like system by running
:command:`sudo make install`.

Usage with CMake
================

You can add the ``fmt`` library directory into your project and include it in
your ``CMakeLists.txt`` file::

   add_subdirectory(fmt)

or

::

   add_subdirectory(fmt EXCLUDE_FROM_ALL)

to exclude it from ``make``, ``make all``, or ``cmake --build .``.

You can detect and use an installed version of {fmt} as follows::

   find_package(fmt)
   target_link_libraries(<your-target> fmt::fmt)

Setting up your target to use a header-only version of ``fmt`` is equally easy::

   target_link_libraries(<your-target> PRIVATE fmt::fmt-header-only)

Usage with build2
=================

You can use `build2 <https://build2.org>`_, a dependency manager and a
build-system combined, to use ``fmt``.

Currently this package is available in these package repositories:

- **https://cppget.org/fmt/** for released and published versions.
- `The git repository with the sources of the build2 package of fmt <https://github.com/build2-packaging/fmt.git>`_
  for unreleased or custom revisions of ``fmt``.

**Usage:**

- ``build2`` package name: ``fmt``
- Library target name : ``lib{fmt}``

For example, to make your ``build2`` project depend on ``fmt``:

- Add one of the repositories to your configurations, or in your
  ``repositories.manifest``, if not already there::

    :
    role: prerequisite
    location: https://pkg.cppget.org/1/stable

- Add this package as a dependency to your ``./manifest`` file
  (example for ``v7.0.x``)::

    depends: fmt ~7.0.0

- Import the target and use it as a prerequisite to your own target
  using `fmt` in the appropriate ``buildfile``::

    import fmt = fmt%lib{fmt}
    lib{mylib} : cxx{**} ... $fmt

Then build your project as usual with `b` or `bdep update`.

For ``build2`` newcomers or to get more details and use cases, you can read the
``build2``
`toolchain introduction <https://build2.org/build2-toolchain/doc/build2-toolchain-intro.xhtml>`_.

Building the Documentation
==========================

To build the documentation you need the following software installed on your
system:

* `Python <https://www.python.org/>`_ with pip and virtualenv
* `Doxygen <http://www.stack.nl/~dimitri/doxygen/>`_
* `Less <http://lesscss.org/>`_ with ``less-plugin-clean-css``.
  Ubuntu doesn't package the ``clean-css`` plugin so you should use ``npm``
  instead of ``apt`` to install both ``less`` and the plugin::

    sudo npm install -g less less-plugin-clean-css.

First generate makefiles or project files using CMake as described in
the previous section. Then compile the ``doc`` target/project, for example::

  make doc

This will generate the HTML documentation in ``doc/html``.

Conda
=====

fmt can be installed on Linux, macOS and Windows with
`Conda <https://docs.conda.io/en/latest/>`__, using its
`conda-forge <https://conda-forge.org>`__
`package <https://github.com/conda-forge/fmt-feedstock>`__, as follows::

  conda install -c conda-forge fmt

Vcpkg
=====

You can download and install fmt using the `vcpkg
<https://github.com/Microsoft/vcpkg>`__ dependency manager::

  git clone https://github.com/Microsoft/vcpkg.git
  cd vcpkg
  ./bootstrap-vcpkg.sh
  ./vcpkg integrate install
  ./vcpkg install fmt

The fmt port in vcpkg is kept up to date by Microsoft team members and community
contributors. If the version is out of date, please `create an issue or pull
request <https://github.com/Microsoft/vcpkg>`__ on the vcpkg repository.

LHelper
=======

You can download and install fmt using
`lhelper <https://github.com/franko/lhelper>`__ dependency manager::

  lhelper activate <some-environment>
  lhelper install fmt

All the recipes for lhelper are kept in the
`lhelper's recipe <https://github.com/franko/lhelper-recipes>`__ repository.

Android NDK
===========

fmt provides `Android.mk file`__ that can be used to build the library
with `Android NDK <https://developer.android.com/tools/sdk/ndk/index.html>`_.
For an example of using fmt with Android NDK, see the
`android-ndk-example <https://github.com/fmtlib/android-ndk-example>`_
repository.

__ https://github.com/fmtlib/fmt/blob/master/support/Android.mk

Homebrew
========

fmt can be installed on OS X using `Homebrew <https://brew.sh/>`_::

  brew install fmt


================================================
FILE: examples/libraries/fmt/include/fmt/args.h
================================================
// Formatting library for C++ - dynamic format arguments
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_ARGS_H_
#define FMT_ARGS_H_

#include <functional>  // std::reference_wrapper
#include <memory>      // std::unique_ptr
#include <vector>

#include "core.h"

FMT_BEGIN_NAMESPACE

namespace detail {

template <typename T> struct is_reference_wrapper : std::false_type {};
template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};

template <typename T> const T& unwrap(const T& v) { return v; }
template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
  return static_cast<const T&>(v);
}

class dynamic_arg_list {
  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
  // templates it doesn't complain about inability to deduce single translation
  // unit for placing vtable. So storage_node_base is made a fake template.
  template <typename = void> struct node {
    virtual ~node() = default;
    std::unique_ptr<node<>> next;
  };

  template <typename T> struct typed_node : node<> {
    T value;

    template <typename Arg>
    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}

    template <typename Char>
    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
        : value(arg.data(), arg.size()) {}
  };

  std::unique_ptr<node<>> head_;

 public:
  template <typename T, typename Arg> const T& push(const Arg& arg) {
    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
    auto& value = new_node->value;
    new_node->next = std::move(head_);
    head_ = std::move(new_node);
    return value;
  }
};
}  // namespace detail

/**
  \rst
  A dynamic version of `fmt::format_arg_store`.
  It's equipped with a storage to potentially temporary objects which lifetimes
  could be shorter than the format arguments object.

  It can be implicitly converted into `~fmt::basic_format_args` for passing
  into type-erased formatting functions such as `~fmt::vformat`.
  \endrst
 */
template <typename Context>
class dynamic_format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
    // Workaround a GCC template argument substitution bug.
    : public basic_format_args<Context>
#endif
{
 private:
  using char_type = typename Context::char_type;

  template <typename T> struct need_copy {
    static constexpr detail::type mapped_type =
        detail::mapped_type_constant<T, Context>::value;

    enum {
      value = !(detail::is_reference_wrapper<T>::value ||
                std::is_same<T, basic_string_view<char_type>>::value ||
                std::is_same<T, detail::std_string_view<char_type>>::value ||
                (mapped_type != detail::type::cstring_type &&
                 mapped_type != detail::type::string_type &&
                 mapped_type != detail::type::custom_type))
    };
  };

  template <typename T>
  using stored_type = conditional_t<detail::is_string<T>::value &&
                                        !has_formatter<T, Context>::value &&
                                        !detail::is_reference_wrapper<T>::value,
                                    std::basic_string<char_type>, T>;

  // Storage of basic_format_arg must be contiguous.
  std::vector<basic_format_arg<Context>> data_;
  std::vector<detail::named_arg_info<char_type>> named_info_;

  // Storage of arguments not fitting into basic_format_arg must grow
  // without relocation because items in data_ refer to it.
  detail::dynamic_arg_list dynamic_args_;

  friend class basic_format_args<Context>;

  unsigned long long get_types() const {
    return detail::is_unpacked_bit | data_.size() |
           (named_info_.empty()
                ? 0ULL
                : static_cast<unsigned long long>(detail::has_named_args_bit));
  }

  const basic_format_arg<Context>* data() const {
    return named_info_.empty() ? data_.data() : data_.data() + 1;
  }

  template <typename T> void emplace_arg(const T& arg) {
    data_.emplace_back(detail::make_arg<Context>(arg));
  }

  template <typename T>
  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
    if (named_info_.empty()) {
      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
      data_.insert(data_.begin(), {zero_ptr, 0});
    }
    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
      data->pop_back();
    };
    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
        guard{&data_, pop_one};
    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
    guard.release();
  }

 public:
  /**
    \rst
    Adds an argument into the dynamic store for later passing to a formatting
    function.

    Note that custom types and string types (but not string views) are copied
    into the store dynamically allocating memory if necessary.

    **Example**::

      fmt::dynamic_format_arg_store<fmt::format_context> store;
      store.push_back(42);
      store.push_back("abc");
      store.push_back(1.5f);
      std::string result = fmt::vformat("{} and {} and {}", store);
    \endrst
  */
  template <typename T> void push_back(const T& arg) {
    if (detail::const_check(need_copy<T>::value))
      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
    else
      emplace_arg(detail::unwrap(arg));
  }

  /**
    \rst
    Adds a reference to the argument into the dynamic store for later passing to
    a formatting function.

    **Example**::

      fmt::dynamic_format_arg_store<fmt::format_context> store;
      char band[] = "Rolling Stones";
      store.push_back(std::cref(band));
      band[9] = 'c'; // Changing str affects the output.
      std::string result = fmt::vformat("{}", store);
      // result == "Rolling Scones"
    \endrst
  */
  template <typename T> void push_back(std::reference_wrapper<T> arg) {
    static_assert(
        need_copy<T>::value,
        "objects of built-in types and string views are always copied");
    emplace_arg(arg.get());
  }

  /**
    Adds named argument into the dynamic store for later passing to a formatting
    function. ``std::reference_wrapper`` is supported to avoid copying of the
    argument. The name is always copied into the store.
  */
  template <typename T>
  void push_back(const detail::named_arg<char_type, T>& arg) {
    const char_type* arg_name =
        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
    if (detail::const_check(need_copy<T>::value)) {
      emplace_arg(
          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
    } else {
      emplace_arg(fmt::arg(arg_name, arg.value));
    }
  }

  /** Erase all elements from the store */
  void clear() {
    data_.clear();
    named_info_.clear();
    dynamic_args_ = detail::dynamic_arg_list();
  }

  /**
    \rst
    Reserves space to store at least *new_cap* arguments including
    *new_cap_named* named arguments.
    \endrst
  */
  void reserve(size_t new_cap, size_t new_cap_named) {
    FMT_ASSERT(new_cap >= new_cap_named,
               "Set of arguments includes set of named arguments");
    data_.reserve(new_cap);
    named_info_.reserve(new_cap_named);
  }
};

FMT_END_NAMESPACE

#endif  // FMT_ARGS_H_


================================================
FILE: examples/libraries/fmt/include/fmt/chrono.h
================================================
// Formatting library for C++ - chrono support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_CHRONO_H_
#define FMT_CHRONO_H_

#include <algorithm>
#include <chrono>
#include <ctime>
#include <locale>
#include <sstream>

#include "format.h"

FMT_BEGIN_NAMESPACE

// Enable safe chrono durations, unless explicitly disabled.
#ifndef FMT_SAFE_DURATION_CAST
#  define FMT_SAFE_DURATION_CAST 1
#endif
#if FMT_SAFE_DURATION_CAST

// For conversion between std::chrono::durations without undefined
// behaviour or erroneous results.
// This is a stripped down version of duration_cast, for inclusion in fmt.
// See https://github.com/pauldreik/safe_duration_cast
//
// Copyright Paul Dreik 2019
namespace safe_duration_cast {

template <typename To, typename From,
          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                        std::numeric_limits<From>::is_signed ==
                            std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
  ec = 0;
  using F = std::numeric_limits<From>;
  using T = std::numeric_limits<To>;
  static_assert(F::is_integer, "From must be integral");
  static_assert(T::is_integer, "To must be integral");

  // A and B are both signed, or both unsigned.
  if (F::digits <= T::digits) {
    // From fits in To without any problem.
  } else {
    // From does not always fit in To, resort to a dynamic check.
    if (from < (T::min)() || from > (T::max)()) {
      // outside range.
      ec = 1;
      return {};
    }
  }
  return static_cast<To>(from);
}

/**
 * converts From to To, without loss. If the dynamic value of from
 * can't be converted to To without loss, ec is set.
 */
template <typename To, typename From,
          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
                        std::numeric_limits<From>::is_signed !=
                            std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
  ec = 0;
  using F = std::numeric_limits<From>;
  using T = std::numeric_limits<To>;
  static_assert(F::is_integer, "From must be integral");
  static_assert(T::is_integer, "To must be integral");

  if (detail::const_check(F::is_signed && !T::is_signed)) {
    // From may be negative, not allowed!
    if (fmt::detail::is_negative(from)) {
      ec = 1;
      return {};
    }
    // From is positive. Can it always fit in To?
    if (F::digits > T::digits &&
        from > static_cast<From>(detail::max_value<To>())) {
      ec = 1;
      return {};
    }
  }

  if (!F::is_signed && T::is_signed && F::digits >= T::digits &&
      from > static_cast<From>(detail::max_value<To>())) {
    ec = 1;
    return {};
  }
  return static_cast<To>(from);  // Lossless conversion.
}

template <typename To, typename From,
          FMT_ENABLE_IF(std::is_same<From, To>::value)>
FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
  ec = 0;
  return from;
}  // function

// clang-format off
/**
 * converts From to To if possible, otherwise ec is set.
 *
 * input                            |    output
 * ---------------------------------|---------------
 * NaN                              | NaN
 * Inf                              | Inf
 * normal, fits in output           | converted (possibly lossy)
 * normal, does not fit in output   | ec is set
 * subnormal                        | best effort
 * -Inf                             | -Inf
 */
// clang-format on
template <typename To, typename From,
          FMT_ENABLE_IF(!std::is_same<From, To>::value)>
FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
  ec = 0;
  using T = std::numeric_limits<To>;
  static_assert(std::is_floating_point<From>::value, "From must be floating");
  static_assert(std::is_floating_point<To>::value, "To must be floating");

  // catch the only happy case
  if (std::isfinite(from)) {
    if (from >= T::lowest() && from <= (T::max)()) {
      return static_cast<To>(from);
    }
    // not within range.
    ec = 1;
    return {};
  }

  // nan and inf will be preserved
  return static_cast<To>(from);
}  // function

template <typename To, typename From,
          FMT_ENABLE_IF(std::is_same<From, To>::value)>
FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
  ec = 0;
  static_assert(std::is_floating_point<From>::value, "From must be floating");
  return from;
}

/**
 * safe duration cast between integral durations
 */
template <typename To, typename FromRep, typename FromPeriod,
          FMT_ENABLE_IF(std::is_integral<FromRep>::value),
          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                      int& ec) {
  using From = std::chrono::duration<FromRep, FromPeriod>;
  ec = 0;
  // the basic idea is that we need to convert from count() in the from type
  // to count() in the To type, by multiplying it with this:
  struct Factor
      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");
  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num
  // /Factor::den and convert it to To::rep, all this without
  // overflow/underflow. let's start by finding a suitable type that can hold
  // both To, From and Factor::num
  using IntermediateRep =
      typename std::common_type<typename From::rep, typename To::rep,
                                decltype(Factor::num)>::type;

  // safe conversion to IntermediateRep
  IntermediateRep count =
      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
  if (ec) return {};
  // multiply with Factor::num without overflow or underflow
  if (detail::const_check(Factor::num != 1)) {
    const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;
    if (count > max1) {
      ec = 1;
      return {};
    }
    const auto min1 =
        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
    if (count < min1) {
      ec = 1;
      return {};
    }
    count *= Factor::num;
  }

  if (detail::const_check(Factor::den != 1)) count /= Factor::den;
  auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);
  return ec ? To() : To(tocount);
}

/**
 * safe duration_cast between floating point durations
 */
template <typename To, typename FromRep, typename FromPeriod,
          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
                      int& ec) {
  using From = std::chrono::duration<FromRep, FromPeriod>;
  ec = 0;
  if (std::isnan(from.count())) {
    // nan in, gives nan out. easy.
    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
  }
  // maybe we should also check if from is denormal, and decide what to do about
  // it.

  // +-inf should be preserved.
  if (std::isinf(from.count())) {
    return To{from.count()};
  }

  // the basic idea is that we need to convert from count() in the from type
  // to count() in the To type, by multiplying it with this:
  struct Factor
      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");
  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num
  // /Factor::den and convert it to To::rep, all this without
  // overflow/underflow. let's start by finding a suitable type that can hold
  // both To, From and Factor::num
  using IntermediateRep =
      typename std::common_type<typename From::rep, typename To::rep,
                                decltype(Factor::num)>::type;

  // force conversion of From::rep -> IntermediateRep to be safe,
  // even if it will never happen be narrowing in this context.
  IntermediateRep count =
      safe_float_conversion<IntermediateRep>(from.count(), ec);
  if (ec) {
    return {};
  }

  // multiply with Factor::num without overflow or underflow
  if (Factor::num != 1) {
    constexpr auto max1 = detail::max_value<IntermediateRep>() /
                          static_cast<IntermediateRep>(Factor::num);
    if (count > max1) {
      ec = 1;
      return {};
    }
    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
                          static_cast<IntermediateRep>(Factor::num);
    if (count < min1) {
      ec = 1;
      return {};
    }
    count *= static_cast<IntermediateRep>(Factor::num);
  }

  // this can't go wrong, right? den>0 is checked earlier.
  if (Factor::den != 1) {
    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
    count /= static_cast<common_t>(Factor::den);
  }

  // convert to the to type, safely
  using ToRep = typename To::rep;

  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
  if (ec) {
    return {};
  }
  return To{tocount};
}
}  // namespace safe_duration_cast
#endif

// Prevents expansion of a preceding token as a function-style macro.
// Usage: f FMT_NOMACRO()
#define FMT_NOMACRO

namespace detail {
template <typename T = void> struct null {};
inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
inline null<> localtime_s(...) { return null<>(); }
inline null<> gmtime_r(...) { return null<>(); }
inline null<> gmtime_s(...) { return null<>(); }

inline auto do_write(const std::tm& time, const std::locale& loc, char format,
                     char modifier) -> std::string {
  auto&& os = std::ostringstream();
  os.imbue(loc);
  using iterator = std::ostreambuf_iterator<char>;
  const auto& facet = std::use_facet<std::time_put<char, iterator>>(loc);
  auto end = facet.put(os, os, ' ', &time, format, modifier);
  if (end.failed()) FMT_THROW(format_error("failed to format time"));
  auto str = os.str();
  if (!detail::is_utf8() || loc == std::locale::classic()) return str;
    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
    // gcc-4.
#if FMT_MSC_VER != 0 || \
    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
  // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
  // and newer.
  using code_unit = wchar_t;
#else
  using code_unit = char32_t;
#endif
  auto& f = std::use_facet<std::codecvt<code_unit, char, std::mbstate_t>>(loc);
  auto mb = std::mbstate_t();
  const char* from_next = nullptr;
  code_unit* to_next = nullptr;
  constexpr size_t buf_size = 32;
  code_unit buf[buf_size] = {};
  auto result = f.in(mb, str.data(), str.data() + str.size(), from_next, buf,
                     buf + buf_size, to_next);
  if (result != std::codecvt_base::ok)
    FMT_THROW(format_error("failed to format time"));
  str.clear();
  for (code_unit* p = buf; p != to_next; ++p) {
    uint32_t c = static_cast<uint32_t>(*p);
    if (sizeof(code_unit) == 2 && c >= 0xd800 && c <= 0xdfff) {
      // surrogate pair
      ++p;
      if (p == to_next || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
        FMT_THROW(format_error("failed to format time"));
      }
      c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
    }
    if (c < 0x80) {
      str.push_back(static_cast<char>(c));
    } else if (c < 0x800) {
      str.push_back(static_cast<char>(0xc0 | (c >> 6)));
      str.push_back(static_cast<char>(0x80 | (c & 0x3f)));
    } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {
      str.push_back(static_cast<char>(0xe0 | (c >> 12)));
      str.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
      str.push_back(static_cast<char>(0x80 | (c & 0x3f)));
    } else if (c >= 0x10000 && c <= 0x10ffff) {
      str.push_back(static_cast<char>(0xf0 | (c >> 18)));
      str.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
      str.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
      str.push_back(static_cast<char>(0x80 | (c & 0x3f)));
    } else {
      FMT_THROW(format_error("failed to format time"));
    }
  }
  return str;
}

template <typename OutputIt>
auto write(OutputIt out, const std::tm& time, const std::locale& loc,
           char format, char modifier = 0) -> OutputIt {
  auto str = do_write(time, loc, format, modifier);
  return std::copy(str.begin(), str.end(), out);
}
}  // namespace detail

FMT_MODULE_EXPORT_BEGIN

/**
  Converts given time since epoch as ``std::time_t`` value into calendar time,
  expressed in local time. Unlike ``std::localtime``, this function is
  thread-safe on most platforms.
 */
inline std::tm localtime(std::time_t time) {
  struct dispatcher {
    std::time_t time_;
    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    bool run() {
      using namespace fmt::detail;
      return handle(localtime_r(&time_, &tm_));
    }

    bool handle(std::tm* tm) { return tm != nullptr; }

    bool handle(detail::null<>) {
      using namespace fmt::detail;
      return fallback(localtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

#if !FMT_MSC_VER
    bool fallback(detail::null<>) {
      using namespace fmt::detail;
      std::tm* tm = std::localtime(&time_);
      if (tm) tm_ = *tm;
      return tm != nullptr;
    }
#endif
  };
  dispatcher lt(time);
  // Too big time values may be unsupported.
  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
  return lt.tm_;
}

inline std::tm localtime(
    std::chrono::time_point<std::chrono::system_clock> time_point) {
  return localtime(std::chrono::system_clock::to_time_t(time_point));
}

/**
  Converts given time since epoch as ``std::time_t`` value into calendar time,
  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
  function is thread-safe on most platforms.
 */
inline std::tm gmtime(std::time_t time) {
  struct dispatcher {
    std::time_t time_;
    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    bool run() {
      using namespace fmt::detail;
      return handle(gmtime_r(&time_, &tm_));
    }

    bool handle(std::tm* tm) { return tm != nullptr; }

    bool handle(detail::null<>) {
      using namespace fmt::detail;
      return fallback(gmtime_s(&tm_, &time_));
    }

    bool fallback(int res) { return res == 0; }

#if !FMT_MSC_VER
    bool fallback(detail::null<>) {
      std::tm* tm = std::gmtime(&time_);
      if (tm) tm_ = *tm;
      return tm != nullptr;
    }
#endif
  };
  dispatcher gt(time);
  // Too big time values may be unsupported.
  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
  return gt.tm_;
}

inline std::tm gmtime(
    std::chrono::time_point<std::chrono::system_clock> time_point) {
  return gmtime(std::chrono::system_clock::to_time_t(time_point));
}

FMT_BEGIN_DETAIL_NAMESPACE

inline size_t strftime(char* str, size_t count, const char* format,
                       const std::tm* time) {
  // Assign to a pointer to suppress GCCs -Wformat-nonliteral
  // First assign the nullptr to suppress -Wsuggest-attribute=format
  std::size_t (*strftime)(char*, std::size_t, const char*, const std::tm*) =
      nullptr;
  strftime = std::strftime;
  return strftime(str, count, format, time);
}

inline size_t strftime(wchar_t* str, size_t count, const wchar_t* format,
                       const std::tm* time) {
  // See above
  std::size_t (*wcsftime)(wchar_t*, std::size_t, const wchar_t*,
                          const std::tm*) = nullptr;
  wcsftime = std::wcsftime;
  return wcsftime(str, count, format, time);
}

FMT_END_DETAIL_NAMESPACE

template <typename Char, typename Duration>
struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
                 Char> : formatter<std::tm, Char> {
  FMT_CONSTEXPR formatter() {
    this->specs = {default_specs, sizeof(default_specs) / sizeof(Char)};
  }

  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    if (it != ctx.end() && *it == ':') ++it;
    auto end = it;
    while (end != ctx.end() && *end != '}') ++end;
    if (end != it) this->specs = {it, detail::to_unsigned(end - it)};
    return end;
  }

  template <typename FormatContext>
  auto format(std::chrono::time_point<std::chrono::system_clock> val,
              FormatContext& ctx) -> decltype(ctx.out()) {
    std::tm time = localtime(val);
    return formatter<std::tm, Char>::format(time, ctx);
  }

  static constexpr Char default_specs[] = {'%', 'Y', '-', '%', 'm', '-',
                                           '%', 'd', ' ', '%', 'H', ':',
                                           '%', 'M', ':', '%', 'S'};
};

template <typename Char, typename Duration>
constexpr Char
    formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
              Char>::default_specs[];

template <typename Char> struct formatter<std::tm, Char> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    if (it != ctx.end() && *it == ':') ++it;
    auto end = it;
    while (end != ctx.end() && *end != '}') ++end;
    specs = {it, detail::to_unsigned(end - it)};
    return end;
  }

  template <typename FormatContext>
  auto format(const std::tm& tm, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    basic_memory_buffer<Char> tm_format;
    tm_format.append(specs.begin(), specs.end());
    // By appending an extra space we can distinguish an empty result that
    // indicates insufficient buffer size from a guaranteed non-empty result
    // https://github.com/fmtlib/fmt/issues/2238
    tm_format.push_back(' ');
    tm_format.push_back('\0');
    basic_memory_buffer<Char> buf;
    size_t start = buf.size();
    for (;;) {
      size_t size = buf.capacity() - start;
      size_t count = detail::strftime(&buf[start], size, &tm_format[0], &tm);
      if (count != 0) {
        buf.resize(start + count);
        break;
      }
      const size_t MIN_GROWTH = 10;
      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
    }
    // Remove the extra space.
    return std::copy(buf.begin(), buf.end() - 1, ctx.out());
  }

  basic_string_view<Char> specs;
};

FMT_BEGIN_DETAIL_NAMESPACE

template <typename Period> FMT_CONSTEXPR inline const char* get_units() {
  if (std::is_same<Period, std::atto>::value) return "as";
  if (std::is_same<Period, std::femto>::value) return "fs";
  if (std::is_same<Period, std::pico>::value) return "ps";
  if (std::is_same<Period, std::nano>::value) return "ns";
  if (std::is_same<Period, std::micro>::value) return "µs";
  if (std::is_same<Period, std::milli>::value) return "ms";
  if (std::is_same<Period, std::centi>::value) return "cs";
  if (std::is_same<Period, std::deci>::value) return "ds";
  if (std::is_same<Period, std::ratio<1>>::value) return "s";
  if (std::is_same<Period, std::deca>::value) return "das";
  if (std::is_same<Period, std::hecto>::value) return "hs";
  if (std::is_same<Period, std::kilo>::value) return "ks";
  if (std::is_same<Period, std::mega>::value) return "Ms";
  if (std::is_same<Period, std::giga>::value) return "Gs";
  if (std::is_same<Period, std::tera>::value) return "Ts";
  if (std::is_same<Period, std::peta>::value) return "Ps";
  if (std::is_same<Period, std::exa>::value) return "Es";
  if (std::is_same<Period, std::ratio<60>>::value) return "m";
  if (std::is_same<Period, std::ratio<3600>>::value) return "h";
  return nullptr;
}

enum class numeric_system {
  standard,
  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
  alternative
};

// Parses a put_time-like format string and invokes handler actions.
template <typename Char, typename Handler>
FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
                                              const Char* end,
                                              Handler&& handler) {
  auto ptr = begin;
  while (ptr != end) {
    auto c = *ptr;
    if (c == '}') break;
    if (c != '%') {
      ++ptr;
      continue;
    }
    if (begin != ptr) handler.on_text(begin, ptr);
    ++ptr;  // consume '%'
    if (ptr == end) FMT_THROW(format_error("invalid format"));
    c = *ptr++;
    switch (c) {
    case '%':
      handler.on_text(ptr - 1, ptr);
      break;
    case 'n': {
      const Char newline[] = {'\n'};
      handler.on_text(newline, newline + 1);
      break;
    }
    case 't': {
      const Char tab[] = {'\t'};
      handler.on_text(tab, tab + 1);
      break;
    }
    // Day of the week:
    case 'a':
      handler.on_abbr_weekday();
      break;
    case 'A':
      handler.on_full_weekday();
      break;
    case 'w':
      handler.on_dec0_weekday(numeric_system::standard);
      break;
    case 'u':
      handler.on_dec1_weekday(numeric_system::standard);
      break;
    // Month:
    case 'b':
      handler.on_abbr_month();
      break;
    case 'B':
      handler.on_full_month();
      break;
    // Hour, minute, second:
    case 'H':
      handler.on_24_hour(numeric_system::standard);
      break;
    case 'I':
      handler.on_12_hour(numeric_system::standard);
      break;
    case 'M':
      handler.on_minute(numeric_system::standard);
      break;
    case 'S':
      handler.on_second(numeric_system::standard);
      break;
    // Other:
    case 'c':
      handler.on_datetime(numeric_system::standard);
      break;
    case 'x':
      handler.on_loc_date(numeric_system::standard);
      break;
    case 'X':
      handler.on_loc_time(numeric_system::standard);
      break;
    case 'D':
      handler.on_us_date();
      break;
    case 'F':
      handler.on_iso_date();
      break;
    case 'r':
      handler.on_12_hour_time();
      break;
    case 'R':
      handler.on_24_hour_time();
      break;
    case 'T':
      handler.on_iso_time();
      break;
    case 'p':
      handler.on_am_pm();
      break;
    case 'Q':
      handler.on_duration_value();
      break;
    case 'q':
      handler.on_duration_unit();
      break;
    case 'z':
      handler.on_utc_offset();
      break;
    case 'Z':
      handler.on_tz_name();
      break;
    // Alternative representation:
    case 'E': {
      if (ptr == end) FMT_THROW(format_error("invalid format"));
      c = *ptr++;
      switch (c) {
      case 'c':
        handler.on_datetime(numeric_system::alternative);
        break;
      case 'x':
        handler.on_loc_date(numeric_system::alternative);
        break;
      case 'X':
        handler.on_loc_time(numeric_system::alternative);
        break;
      default:
        FMT_THROW(format_error("invalid format"));
      }
      break;
    }
    case 'O':
      if (ptr == end) FMT_THROW(format_error("invalid format"));
      c = *ptr++;
      switch (c) {
      case 'w':
        handler.on_dec0_weekday(numeric_system::alternative);
        break;
      case 'u':
        handler.on_dec1_weekday(numeric_system::alternative);
        break;
      case 'H':
        handler.on_24_hour(numeric_system::alternative);
        break;
      case 'I':
        handler.on_12_hour(numeric_system::alternative);
        break;
      case 'M':
        handler.on_minute(numeric_system::alternative);
        break;
      case 'S':
        handler.on_second(numeric_system::alternative);
        break;
      default:
        FMT_THROW(format_error("invalid format"));
      }
      break;
    default:
      FMT_THROW(format_error("invalid format"));
    }
    begin = ptr;
  }
  if (begin != ptr) handler.on_text(begin, ptr);
  return ptr;
}

template <typename Derived> struct null_chrono_spec_handler {
  FMT_CONSTEXPR void unsupported() {
    static_cast<Derived*>(this)->unsupported();
  }
  FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); }
  FMT_CONSTEXPR void on_full_weekday() { unsupported(); }
  FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_abbr_month() { unsupported(); }
  FMT_CONSTEXPR void on_full_month() { unsupported(); }
  FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }
  FMT_CONSTEXPR void on_us_date() { unsupported(); }
  FMT_CONSTEXPR void on_iso_date() { unsupported(); }
  FMT_CONSTEXPR void on_12_hour_time() { unsupported(); }
  FMT_CONSTEXPR void on_24_hour_time() { unsupported(); }
  FMT_CONSTEXPR void on_iso_time() { unsupported(); }
  FMT_CONSTEXPR void on_am_pm() { unsupported(); }
  FMT_CONSTEXPR void on_duration_value() { unsupported(); }
  FMT_CONSTEXPR void on_duration_unit() { unsupported(); }
  FMT_CONSTEXPR void on_utc_offset() { unsupported(); }
  FMT_CONSTEXPR void on_tz_name() { unsupported(); }
};

struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
  FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); }

  template <typename Char>
  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
  FMT_CONSTEXPR void on_24_hour(numeric_system) {}
  FMT_CONSTEXPR void on_12_hour(numeric_system) {}
  FMT_CONSTEXPR void on_minute(numeric_system) {}
  FMT_CONSTEXPR void on_second(numeric_system) {}
  FMT_CONSTEXPR void on_12_hour_time() {}
  FMT_CONSTEXPR void on_24_hour_time() {}
  FMT_CONSTEXPR void on_iso_time() {}
  FMT_CONSTEXPR void on_am_pm() {}
  FMT_CONSTEXPR void on_duration_value() {}
  FMT_CONSTEXPR void on_duration_unit() {}
};

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline bool isnan(T) {
  return false;
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
inline bool isnan(T value) {
  return std::isnan(value);
}

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline bool isfinite(T) {
  return true;
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
inline bool isfinite(T value) {
  return std::isfinite(value);
}

// Converts value to int and checks that it's in the range [0, upper).
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline int to_nonnegative_int(T value, int upper) {
  FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper),
             "invalid value");
  (void)upper;
  return static_cast<int>(value);
}
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
inline int to_nonnegative_int(T value, int upper) {
  FMT_ASSERT(
      std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
      "invalid value");
  (void)upper;
  return static_cast<int>(value);
}

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline T mod(T x, int y) {
  return x % static_cast<T>(y);
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
inline T mod(T x, int y) {
  return std::fmod(x, static_cast<T>(y));
}

// If T is an integral type, maps T to its unsigned counterpart, otherwise
// leaves it unchanged (unlike std::make_unsigned).
template <typename T, bool INTEGRAL = std::is_integral<T>::value>
struct make_unsigned_or_unchanged {
  using type = T;
};

template <typename T> struct make_unsigned_or_unchanged<T, true> {
  using type = typename std::make_unsigned<T>::type;
};

#if FMT_SAFE_DURATION_CAST
// throwing version of safe_duration_cast
template <typename To, typename FromRep, typename FromPeriod>
To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
  int ec;
  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
  if (ec) FMT_THROW(format_error("cannot format duration"));
  return to;
}
#endif

template <typename Rep, typename Period,
          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
inline std::chrono::duration<Rep, std::milli> get_milliseconds(
    std::chrono::duration<Rep, Period> d) {
  // this may overflow and/or the result may not fit in the
  // target type.
#if FMT_SAFE_DURATION_CAST
  using CommonSecondsType =
      typename std::common_type<decltype(d), std::chrono::seconds>::type;
  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
  const auto d_as_whole_seconds =
      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
  // this conversion should be nonproblematic
  const auto diff = d_as_common - d_as_whole_seconds;
  const auto ms =
      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
  return ms;
#else
  auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
  return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
#endif
}

template <typename Rep, typename Period,
          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
inline std::chrono::duration<Rep, std::milli> get_milliseconds(
    std::chrono::duration<Rep, Period> d) {
  using common_type = typename std::common_type<Rep, std::intmax_t>::type;
  auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
                    static_cast<common_type>(Period::den) * 1000,
                1000);
  return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
}

template <typename Char, typename Rep, typename OutputIt,
          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
OutputIt format_duration_value(OutputIt out, Rep val, int) {
  return write<Char>(out, val);
}

template <typename Char, typename Rep, typename OutputIt,
          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
  auto specs = basic_format_specs<Char>();
  specs.precision = precision;
  specs.type = precision > 0 ? 'f' : 'g';
  return write<Char>(out, val, specs);
}

template <typename Char, typename OutputIt>
OutputIt copy_unit(string_view unit, OutputIt out, Char) {
  return std::copy(unit.begin(), unit.end(), out);
}

template <typename OutputIt>
OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) {
  // This works when wchar_t is UTF-32 because units only contain characters
  // that have the same representation in UTF-16 and UTF-32.
  utf8_to_utf16 u(unit);
  return std::copy(u.c_str(), u.c_str() + u.size(), out);
}

template <typename Char, typename Period, typename OutputIt>
OutputIt format_duration_unit(OutputIt out) {
  if (const char* unit = get_units<Period>())
    return copy_unit(string_view(unit), out, Char());
  *out++ = '[';
  out = write<Char>(out, Period::num);
  if (const_check(Period::den != 1)) {
    *out++ = '/';
    out = write<Char>(out, Period::den);
  }
  *out++ = ']';
  *out++ = 's';
  return out;
}

template <typename FormatContext, typename OutputIt, typename Rep,
          typename Period>
struct chrono_formatter {
  FormatContext& context;
  OutputIt out;
  int precision;
  bool localized = false;
  // rep is unsigned to avoid overflow.
  using rep =
      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
  rep val;
  using seconds = std::chrono::duration<rep>;
  seconds s;
  using milliseconds = std::chrono::duration<rep, std::milli>;
  bool negative;

  using char_type = typename FormatContext::char_type;

  explicit chrono_formatter(FormatContext& ctx, OutputIt o,
                            std::chrono::duration<Rep, Period> d)
      : context(ctx),
        out(o),
        val(static_cast<rep>(d.count())),
        negative(false) {
    if (d.count() < 0) {
      val = 0 - val;
      negative = true;
    }

    // this may overflow and/or the result may not fit in the
    // target type.
#if FMT_SAFE_DURATION_CAST
    // might need checked conversion (rep!=Rep)
    auto tmpval = std::chrono::duration<rep, Period>(val);
    s = fmt_safe_duration_cast<seconds>(tmpval);
#else
    s = std::chrono::duration_cast<seconds>(
        std::chrono::duration<rep, Period>(val));
#endif
  }

  // returns true if nan or inf, writes to out.
  bool handle_nan_inf() {
    if (isfinite(val)) {
      return false;
    }
    if (isnan(val)) {
      write_nan();
      return true;
    }
    // must be +-inf
    if (val > 0) {
      write_pinf();
    } else {
      write_ninf();
    }
    return true;
  }

  Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }

  Rep hour12() const {
    Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
    return hour <= 0 ? 12 : hour;
  }

  Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
  Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }

  std::tm time() const {
    auto time = std::tm();
    time.tm_hour = to_nonnegative_int(hour(), 24);
    time.tm_min = to_nonnegative_int(minute(), 60);
    time.tm_sec = to_nonnegative_int(second(), 60);
    return time;
  }

  void write_sign() {
    if (negative) {
      *out++ = '-';
      negative = false;
    }
  }

  void write(Rep value, int width) {
    write_sign();
    if (isnan(value)) return write_nan();
    uint32_or_64_or_128_t<int> n =
        to_unsigned(to_nonnegative_int(value, max_value<int>()));
    int num_digits = detail::count_digits(n);
    if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
    out = format_decimal<char_type>(out, n, num_digits).end;
  }

  void write_nan() { std::copy_n("nan", 3, out); }
  void write_pinf() { std::copy_n("inf", 3, out); }
  void write_ninf() { std::copy_n("-inf", 4, out); }

  void format_localized(const tm& time, char format, char modifier = 0) {
    if (isnan(val)) return write_nan();
    const auto& loc = localized ? context.locale().template get<std::locale>()
                                : std::locale::classic();
    out = detail::write(out, time, loc, format, modifier);
  }

  void on_text(const char_type* begin, const char_type* end) {
    std::copy(begin, end, out);
  }

  // These are not implemented because durations don't have date information.
  void on_abbr_weekday() {}
  void on_full_weekday() {}
  void on_dec0_weekday(numeric_system) {}
  void on_dec1_weekday(numeric_system) {}
  void on_abbr_month() {}
  void on_full_month() {}
  void on_datetime(numeric_system) {}
  void on_loc_date(numeric_system) {}
  void on_loc_time(numeric_system) {}
  void on_us_date() {}
  void on_iso_date() {}
  void on_utc_offset() {}
  void on_tz_name() {}

  void on_24_hour(numeric_system ns) {
    if (handle_nan_inf()) return;

    if (ns == numeric_system::standard) return write(hour(), 2);
    auto time = tm();
    time.tm_hour = to_nonnegative_int(hour(), 24);
    format_localized(time, 'H', 'O');
  }

  void on_12_hour(numeric_system ns) {
    if (handle_nan_inf()) return;

    if (ns == numeric_system::standard) return write(hour12(), 2);
    auto time = tm();
    time.tm_hour = to_nonnegative_int(hour12(), 12);
    format_localized(time, 'I', 'O');
  }

  void on_minute(numeric_system ns) {
    if (handle_nan_inf()) return;

    if (ns == numeric_system::standard) return write(minute(), 2);
    auto time = tm();
    time.tm_min = to_nonnegative_int(minute(), 60);
    format_localized(time, 'M', 'O');
  }

  void on_second(numeric_system ns) {
    if (handle_nan_inf()) return;

    if (ns == numeric_system::standard) {
      write(second(), 2);
#if FMT_SAFE_DURATION_CAST
      // convert rep->Rep
      using duration_rep = std::chrono::duration<rep, Period>;
      using duration_Rep = std::chrono::duration<Rep, Period>;
      auto tmpval = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
#else
      auto tmpval = std::chrono::duration<Rep, Period>(val);
#endif
      auto ms = get_milliseconds(tmpval);
      if (ms != std::chrono::milliseconds(0)) {
        *out++ = '.';
        write(ms.count(), 3);
      }
      return;
    }
    auto time = tm();
    time.tm_sec = to_nonnegative_int(second(), 60);
    format_localized(time, 'S', 'O');
  }

  void on_12_hour_time() {
    if (handle_nan_inf()) return;
    format_localized(time(), 'r');
  }

  void on_24_hour_time() {
    if (handle_nan_inf()) {
      *out++ = ':';
      handle_nan_inf();
      return;
    }

    write(hour(), 2);
    *out++ = ':';
    write(minute(), 2);
  }

  void on_iso_time() {
    on_24_hour_time();
    *out++ = ':';
    if (handle_nan_inf()) return;
    write(second(), 2);
  }

  void on_am_pm() {
    if (handle_nan_inf()) return;
    format_localized(time(), 'p');
  }

  void on_duration_value() {
    if (handle_nan_inf()) return;
    write_sign();
    out = format_duration_value<char_type>(out, val, precision);
  }

  void on_duration_unit() {
    out = format_duration_unit<char_type, Period>(out);
  }
};

FMT_END_DETAIL_NAMESPACE

#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
using weekday = std::chrono::weekday;
#else
// A fallback version of weekday.
class weekday {
 private:
  unsigned char value;

 public:
  weekday() = default;
  explicit constexpr weekday(unsigned wd) noexcept
      : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
  constexpr unsigned c_encoding() const noexcept { return value; }
};
#endif

// A rudimentary weekday formatter.
template <> struct formatter<weekday> {
 private:
  bool localized = false;

 public:
  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    auto begin = ctx.begin(), end = ctx.end();
    if (begin != end && *begin == 'L') {
      ++begin;
      localized = true;
    }
    return begin;
  }

  auto format(weekday wd, format_context& ctx) -> decltype(ctx.out()) {
    auto time = std::tm();
    time.tm_wday = static_cast<int>(wd.c_encoding());
    const auto& loc = localized ? ctx.locale().template get<std::locale>()
                                : std::locale::classic();
    return detail::write(ctx.out(), time, loc, 'a');
  }
};

template <typename Rep, typename Period, typename Char>
struct formatter<std::chrono::duration<Rep, Period>, Char> {
 private:
  basic_format_specs<Char> specs;
  int precision = -1;
  using arg_ref_type = detail::arg_ref<Char>;
  arg_ref_type width_ref;
  arg_ref_type precision_ref;
  bool localized = false;
  basic_string_view<Char> format_str;
  using duration = std::chrono::duration<Rep, Period>;

  struct spec_handler {
    formatter& f;
    basic_format_parse_context<Char>& context;
    basic_string_view<Char> format_str;

    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
      context.check_arg_id(arg_id);
      return arg_ref_type(arg_id);
    }

    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id) {
      context.check_arg_id(arg_id);
      return arg_ref_type(arg_id);
    }

    FMT_CONSTEXPR arg_ref_type make_arg_ref(detail::auto_id) {
      return arg_ref_type(context.next_arg_id());
    }

    void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
    FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
      f.specs.fill = fill;
    }
    FMT_CONSTEXPR void on_align(align_t align) { f.specs.align = align; }
    FMT_CONSTEXPR void on_width(int width) { f.specs.width = width; }
    FMT_CONSTEXPR void on_precision(int _precision) {
      f.precision = _precision;
    }
    FMT_CONSTEXPR void end_precision() {}

    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
      f.width_ref = make_arg_ref(arg_id);
    }

    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
      f.precision_ref = make_arg_ref(arg_id);
    }
  };

  using iterator = typename basic_format_parse_context<Char>::iterator;
  struct parse_range {
    iterator begin;
    iterator end;
  };

  FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context<Char>& ctx) {
    auto begin = ctx.begin(), end = ctx.end();
    if (begin == end || *begin == '}') return {begin, begin};
    spec_handler handler{*this, ctx, format_str};
    begin = detail::parse_align(begin, end, handler);
    if (begin == end) return {begin, begin};
    begin = detail::parse_width(begin, end, handler);
    if (begin == end) return {begin, begin};
    if (*begin == '.') {
      if (std::is_floating_point<Rep>::value)
        begin = detail::parse_precision(begin, end, handler);
      else
        handler.on_error("precision not allowed for this argument type");
    }
    if (begin != end && *begin == 'L') {
      ++begin;
      localized = true;
    }
    end = parse_chrono_format(begin, end, detail::chrono_format_checker());
    return {begin, end};
  }

 public:
  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
      -> decltype(ctx.begin()) {
    auto range = do_parse(ctx);
    format_str = basic_string_view<Char>(
        &*range.begin, detail::to_unsigned(range.end - range.begin));
    return range.end;
  }

  template <typename FormatContext>
  auto format(const duration& d, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto specs_copy = specs;
    auto precision_copy = precision;
    auto begin = format_str.begin(), end = format_str.end();
    // As a possible future optimization, we could avoid extra copying if width
    // is not specified.
    basic_memory_buffer<Char> buf;
    auto out = std::back_inserter(buf);
    detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width,
                                                       width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(precision_copy,
                                                           precision_ref, ctx);
    if (begin == end || *begin == '}') {
      out = detail::format_duration_value<Char>(out, d.count(), precision_copy);
      detail::format_duration_unit<Char, Period>(out);
    } else {
      detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
          ctx, out, d);
      f.precision = precision_copy;
      f.localized = localized;
      detail::parse_chrono_format(begin, end, f);
    }
    return detail::write(
        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy);
  }
};

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_CHRONO_H_


================================================
FILE: examples/libraries/fmt/include/fmt/color.h
================================================
// Formatting library for C++ - color support
//
// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_COLOR_H_
#define FMT_COLOR_H_

#include "format.h"

// __declspec(deprecated) is broken in some MSVC versions.
#if FMT_MSC_VER
#  define FMT_DEPRECATED_NONMSVC
#else
#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
#endif

FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN

enum class color : uint32_t {
  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
  antique_white = 0xFAEBD7,            // rgb(250,235,215)
  aqua = 0x00FFFF,                     // rgb(0,255,255)
  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
  azure = 0xF0FFFF,                    // rgb(240,255,255)
  beige = 0xF5F5DC,                    // rgb(245,245,220)
  bisque = 0xFFE4C4,                   // rgb(255,228,196)
  black = 0x000000,                    // rgb(0,0,0)
  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
  blue = 0x0000FF,                     // rgb(0,0,255)
  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
  brown = 0xA52A2A,                    // rgb(165,42,42)
  burly_wood = 0xDEB887,               // rgb(222,184,135)
  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
  chartreuse = 0x7FFF00,               // rgb(127,255,0)
  chocolate = 0xD2691E,                // rgb(210,105,30)
  coral = 0xFF7F50,                    // rgb(255,127,80)
  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
  crimson = 0xDC143C,                  // rgb(220,20,60)
  cyan = 0x00FFFF,                     // rgb(0,255,255)
  dark_blue = 0x00008B,                // rgb(0,0,139)
  dark_cyan = 0x008B8B,                // rgb(0,139,139)
  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
  dark_green = 0x006400,               // rgb(0,100,0)
  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
  dark_magenta = 0x8B008B,             // rgb(139,0,139)
  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
  dark_orange = 0xFF8C00,              // rgb(255,140,0)
  dark_orchid = 0x9932CC,              // rgb(153,50,204)
  dark_red = 0x8B0000,                 // rgb(139,0,0)
  dark_salmon = 0xE9967A,              // rgb(233,150,122)
  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
  dark_violet = 0x9400D3,              // rgb(148,0,211)
  deep_pink = 0xFF1493,                // rgb(255,20,147)
  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
  dim_gray = 0x696969,                 // rgb(105,105,105)
  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
  fire_brick = 0xB22222,               // rgb(178,34,34)
  floral_white = 0xFFFAF0,             // rgb(255,250,240)
  forest_green = 0x228B22,             // rgb(34,139,34)
  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
  gold = 0xFFD700,                     // rgb(255,215,0)
  golden_rod = 0xDAA520,               // rgb(218,165,32)
  gray = 0x808080,                     // rgb(128,128,128)
  green = 0x008000,                    // rgb(0,128,0)
  green_yellow = 0xADFF2F,             // rgb(173,255,47)
  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
  indian_red = 0xCD5C5C,               // rgb(205,92,92)
  indigo = 0x4B0082,                   // rgb(75,0,130)
  ivory = 0xFFFFF0,                    // rgb(255,255,240)
  khaki = 0xF0E68C,                    // rgb(240,230,140)
  lavender = 0xE6E6FA,                 // rgb(230,230,250)
  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
  lawn_green = 0x7CFC00,               // rgb(124,252,0)
  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
  light_blue = 0xADD8E6,               // rgb(173,216,230)
  light_coral = 0xF08080,              // rgb(240,128,128)
  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
  light_gray = 0xD3D3D3,               // rgb(211,211,211)
  light_green = 0x90EE90,              // rgb(144,238,144)
  light_pink = 0xFFB6C1,               // rgb(255,182,193)
  light_salmon = 0xFFA07A,             // rgb(255,160,122)
  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
  light_slate_gray = 0x778899,         // rgb(119,136,153)
  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
  lime = 0x00FF00,                     // rgb(0,255,0)
  lime_green = 0x32CD32,               // rgb(50,205,50)
  linen = 0xFAF0E6,                    // rgb(250,240,230)
  magenta = 0xFF00FF,                  // rgb(255,0,255)
  maroon = 0x800000,                   // rgb(128,0,0)
  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
  medium_blue = 0x0000CD,              // rgb(0,0,205)
  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
  medium_purple = 0x9370DB,            // rgb(147,112,219)
  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
  medium_violet_red = 0xC71585,        // rgb(199,21,133)
  midnight_blue = 0x191970,            // rgb(25,25,112)
  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
  navy = 0x000080,                     // rgb(0,0,128)
  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
  olive = 0x808000,                    // rgb(128,128,0)
  olive_drab = 0x6B8E23,               // rgb(107,142,35)
  orange = 0xFFA500,                   // rgb(255,165,0)
  orange_red = 0xFF4500,               // rgb(255,69,0)
  orchid = 0xDA70D6,                   // rgb(218,112,214)
  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
  pale_green = 0x98FB98,               // rgb(152,251,152)
  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
  peru = 0xCD853F,                     // rgb(205,133,63)
  pink = 0xFFC0CB,                     // rgb(255,192,203)
  plum = 0xDDA0DD,                     // rgb(221,160,221)
  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
  purple = 0x800080,                   // rgb(128,0,128)
  rebecca_purple = 0x663399,           // rgb(102,51,153)
  red = 0xFF0000,                      // rgb(255,0,0)
  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
  royal_blue = 0x4169E1,               // rgb(65,105,225)
  saddle_brown = 0x8B4513,             // rgb(139,69,19)
  salmon = 0xFA8072,                   // rgb(250,128,114)
  sandy_brown = 0xF4A460,              // rgb(244,164,96)
  sea_green = 0x2E8B57,                // rgb(46,139,87)
  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
  sienna = 0xA0522D,                   // rgb(160,82,45)
  silver = 0xC0C0C0,                   // rgb(192,192,192)
  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
  slate_gray = 0x708090,               // rgb(112,128,144)
  snow = 0xFFFAFA,                     // rgb(255,250,250)
  spring_green = 0x00FF7F,             // rgb(0,255,127)
  steel_blue = 0x4682B4,               // rgb(70,130,180)
  tan = 0xD2B48C,                      // rgb(210,180,140)
  teal = 0x008080,                     // rgb(0,128,128)
  thistle = 0xD8BFD8,                  // rgb(216,191,216)
  tomato = 0xFF6347,                   // rgb(255,99,71)
  turquoise = 0x40E0D0,                // rgb(64,224,208)
  violet = 0xEE82EE,                   // rgb(238,130,238)
  wheat = 0xF5DEB3,                    // rgb(245,222,179)
  white = 0xFFFFFF,                    // rgb(255,255,255)
  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
  yellow = 0xFFFF00,                   // rgb(255,255,0)
  yellow_green = 0x9ACD32              // rgb(154,205,50)
};                                     // enum class color

enum class terminal_color : uint8_t {
  black = 30,
  red,
  green,
  yellow,
  blue,
  magenta,
  cyan,
  white,
  bright_black = 90,
  bright_red,
  bright_green,
  bright_yellow,
  bright_blue,
  bright_magenta,
  bright_cyan,
  bright_white
};

enum class emphasis : uint8_t {
  bold = 1,
  faint = 1 << 1,
  italic = 1 << 2,
  underline = 1 << 3,
  blink = 1 << 4,
  reverse = 1 << 5,
  conceal = 1 << 6,
  strikethrough = 1 << 7,
};

// rgb is a struct for red, green and blue colors.
// Using the name "rgb" makes some editors show the color in a tooltip.
struct rgb {
  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
  FMT_CONSTEXPR rgb(uint32_t hex)
      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
  FMT_CONSTEXPR rgb(color hex)
      : r((uint32_t(hex) >> 16) & 0xFF),
        g((uint32_t(hex) >> 8) & 0xFF),
        b(uint32_t(hex) & 0xFF) {}
  uint8_t r;
  uint8_t g;
  uint8_t b;
};

FMT_BEGIN_DETAIL_NAMESPACE

// color is a struct of either a rgb color or a terminal color.
struct color_type {
  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
                                                           value{} {
    value.rgb_color = static_cast<uint32_t>(rgb_color);
  }
  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
  }
  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
                                                                     value{} {
    value.term_color = static_cast<uint8_t>(term_color);
  }
  bool is_rgb;
  union color_union {
    uint8_t term_color;
    uint32_t rgb_color;
  } value;
};

FMT_END_DETAIL_NAMESPACE

/** A text style consisting of foreground and background colors and emphasis. */
class text_style {
 public:
  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
      : set_foreground_color(),
        set_background_color(),
        ems(em) {}

  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
    if (!set_foreground_color) {
      set_foreground_color = rhs.set_foreground_color;
      foreground_color = rhs.foreground_color;
    } else if (rhs.set_foreground_color) {
      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
        FMT_THROW(format_error("can't OR a terminal color"));
      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
    }

    if (!set_background_color) {
      set_background_color = rhs.set_background_color;
      background_color = rhs.background_color;
    } else if (rhs.set_background_color) {
      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
        FMT_THROW(format_error("can't OR a terminal color"));
      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
    }

    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
                                static_cast<uint8_t>(rhs.ems));
    return *this;
  }

  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
                                            const text_style& rhs) {
    return lhs |= rhs;
  }

  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
      const text_style& rhs) {
    return and_assign(rhs);
  }

  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
  operator&(text_style lhs, const text_style& rhs) {
    return lhs.and_assign(rhs);
  }

  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
    return set_foreground_color;
  }
  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
    return set_background_color;
  }
  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
    return static_cast<uint8_t>(ems) != 0;
  }
  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
    return foreground_color;
  }
  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
    FMT_ASSERT(has_background(), "no background specified for this style");
    return background_color;
  }
  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
    return ems;
  }

 private:
  FMT_CONSTEXPR text_style(bool is_foreground,
                           detail::color_type text_color) FMT_NOEXCEPT
      : set_foreground_color(),
        set_background_color(),
        ems() {
    if (is_foreground) {
      foreground_color = text_color;
      set_foreground_color = true;
    } else {
      background_color = text_color;
      set_background_color = true;
    }
  }

  // DEPRECATED!
  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
    if (!set_foreground_color) {
      set_foreground_color = rhs.set_foreground_color;
      foreground_color = rhs.foreground_color;
    } else if (rhs.set_foreground_color) {
      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
        FMT_THROW(format_error("can't AND a terminal color"));
      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
    }

    if (!set_background_color) {
      set_background_color = rhs.set_background_color;
      background_color = rhs.background_color;
    } else if (rhs.set_background_color) {
      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
        FMT_THROW(format_error("can't AND a terminal color"));
      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
    }

    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
                                static_cast<uint8_t>(rhs.ems));
    return *this;
  }

  friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
      FMT_NOEXCEPT;

  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
      FMT_NOEXCEPT;

  detail::color_type foreground_color;
  detail::color_type background_color;
  bool set_foreground_color;
  bool set_background_color;
  emphasis ems;
};

/** Creates a text style from the foreground (text) color. */
FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
  return text_style(true, foreground);
}

/** Creates a text style from the background color. */
FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
  return text_style(false, background);
}

FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
                                          emphasis rhs) FMT_NOEXCEPT {
  return text_style(lhs) | rhs;
}

FMT_BEGIN_DETAIL_NAMESPACE

template <typename Char> struct ansi_color_escape {
  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
                                  const char* esc) FMT_NOEXCEPT {
    // If we have a terminal color, we need to output another escape code
    // sequence.
    if (!text_color.is_rgb) {
      bool is_background = esc == string_view("\x1b[48;2;");
      uint32_t value = text_color.value.term_color;
      // Background ASCII codes are the same as the foreground ones but with
      // 10 more.
      if (is_background) value += 10u;

      size_t index = 0;
      buffer[index++] = static_cast<Char>('\x1b');
      buffer[index++] = static_cast<Char>('[');

      if (value >= 100u) {
        buffer[index++] = static_cast<Char>('1');
        value %= 100u;
      }
      buffer[index++] = static_cast<Char>('0' + value / 10u);
      buffer[index++] = static_cast<Char>('0' + value % 10u);

      buffer[index++] = static_cast<Char>('m');
      buffer[index++] = static_cast<Char>('\0');
      return;
    }

    for (int i = 0; i < 7; i++) {
      buffer[i] = static_cast<Char>(esc[i]);
    }
    rgb color(text_color.value.rgb_color);
    to_esc(color.r, buffer + 7, ';');
    to_esc(color.g, buffer + 11, ';');
    to_esc(color.b, buffer + 15, 'm');
    buffer[19] = static_cast<Char>(0);
  }
  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
    uint8_t em_codes[num_emphases] = {};
    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;

    size_t index = 0;
    for (size_t i = 0; i < num_emphases; ++i) {
      if (!em_codes[i]) continue;
      buffer[index++] = static_cast<Char>('\x1b');
      buffer[index++] = static_cast<Char>('[');
      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
      buffer[index++] = static_cast<Char>('m');
    }
    buffer[index++] = static_cast<Char>(0);
  }
  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }

  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
    return buffer + std::char_traits<Char>::length(buffer);
  }

 private:
  static constexpr size_t num_emphases = 8;
  Char buffer[7u + 3u * num_emphases + 1u];

  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
                                   char delimiter) FMT_NOEXCEPT {
    out[0] = static_cast<Char>('0' + c / 100);
    out[1] = static_cast<Char>('0' + c / 10 % 10);
    out[2] = static_cast<Char>('0' + c % 10);
    out[3] = static_cast<Char>(delimiter);
  }
  static FMT_CONSTEXPR bool has_emphasis(emphasis em,
                                         emphasis mask) FMT_NOEXCEPT {
    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
  }
};

template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
    detail::color_type foreground) FMT_NOEXCEPT {
  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
}

template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
    detail::color_type background) FMT_NOEXCEPT {
  return ansi_color_escape<Char>(background, "\x1b[48;2;");
}

template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
  return ansi_color_escape<Char>(em);
}

template <typename Char>
inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
  std::fputs(chars, stream);
}

template <>
inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
  std::fputws(chars, stream);
}

template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
  fputs("\x1b[0m", stream);
}

template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
  fputs(L"\x1b[0m", stream);
}

template <typename Char>
inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
  auto reset_color = string_view("\x1b[0m");
  buffer.append(reset_color.begin(), reset_color.end());
}

template <typename Char>
void vformat_to(buffer<Char>& buf, const text_style& ts,
                basic_string_view<Char> format_str,
                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  bool has_style = false;
  if (ts.has_emphasis()) {
    has_style = true;
    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
    buf.append(emphasis.begin(), emphasis.end());
  }
  if (ts.has_foreground()) {
    has_style = true;
    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
    buf.append(foreground.begin(), foreground.end());
  }
  if (ts.has_background()) {
    has_style = true;
    auto background = detail::make_background_color<Char>(ts.get_background());
    buf.append(background.begin(), background.end());
  }
  detail::vformat_to(buf, format_str, args, {});
  if (has_style) detail::reset_color<Char>(buf);
}

FMT_END_DETAIL_NAMESPACE

template <typename S, typename Char = char_t<S>>
void vprint(std::FILE* f, const text_style& ts, const S& format,
            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buf;
  detail::vformat_to(buf, ts, to_string_view(format), args);
  buf.push_back(Char(0));
  detail::fputs(buf.data(), f);
}

/**
  \rst
  Formats a string and prints it to the specified file stream using ANSI
  escape sequences to specify text formatting.

  **Example**::

    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
               "Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_string<S>::value)>
void print(std::FILE* f, const text_style& ts, const S& format_str,
           const Args&... args) {
  vprint(f, ts, format_str,
         fmt::make_args_checked<Args...>(format_str, args...));
}

/**
  \rst
  Formats a string and prints it to stdout using ANSI escape sequences to
  specify text formatting.

  **Example**::

    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
               "Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_string<S>::value)>
void print(const text_style& ts, const S& format_str, const Args&... args) {
  return print(stdout, ts, format_str, args...);
}

template <typename S, typename Char = char_t<S>>
inline std::basic_string<Char> vformat(
    const text_style& ts, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buf;
  detail::vformat_to(buf, ts, to_string_view(format_str), args);
  return fmt::to_string(buf);
}

/**
  \rst
  Formats arguments and returns the result as a string using ANSI
  escape sequences to specify text formatting.

  **Example**::

    #include <fmt/color.h>
    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
                                      "The answer is {}", 42);
  \endrst
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
                                      const Args&... args) {
  return fmt::vformat(ts, to_string_view(format_str),
                      fmt::make_args_checked<Args...>(format_str, args...));
}

/**
  Formats a string with the given text_style and writes the output to ``out``.
 */
template <typename OutputIt, typename Char,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
OutputIt vformat_to(
    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  auto&& buf = detail::get_buffer<Char>(out);
  detail::vformat_to(buf, ts, format_str, args);
  return detail::get_iterator(buf);
}

/**
  \rst
  Formats arguments with the given text_style, writes the result to the output
  iterator ``out`` and returns the iterator past the end of the output range.

  **Example**::

    std::vector<char> out;
    fmt::format_to(std::back_inserter(out),
                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
  \endrst
*/
template <typename OutputIt, typename S, typename... Args,
          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
              detail::is_string<S>::value>
inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
                      Args&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
  return vformat_to(out, ts, to_string_view(format_str),
                    fmt::make_args_checked<Args...>(format_str, args...));
}

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_COLOR_H_


================================================
FILE: examples/libraries/fmt/include/fmt/compile.h
================================================
// Formatting library for C++ - experimental format string compilation
//
// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_COMPILE_H_
#define FMT_COMPILE_H_

#include "format.h"

FMT_BEGIN_NAMESPACE
namespace detail {

// An output iterator that counts the number of objects written to it and
// discards them.
class counting_iterator {
 private:
  size_t count_;

 public:
  using iterator_category = std::output_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.

  struct value_type {
    template <typename T> void operator=(const T&) {}
  };

  counting_iterator() : count_(0) {}

  size_t count() const { return count_; }

  counting_iterator& operator++() {
    ++count_;
    return *this;
  }
  counting_iterator operator++(int) {
    auto it = *this;
    ++*this;
    return it;
  }

  friend counting_iterator operator+(counting_iterator it, difference_type n) {
    it.count_ += static_cast<size_t>(n);
    return it;
  }

  value_type operator*() const { return {}; }
};

template <typename Char, typename InputIt>
inline counting_iterator copy_str(InputIt begin, InputIt end,
                                  counting_iterator it) {
  return it + (end - begin);
}

template <typename OutputIt> class truncating_iterator_base {
 protected:
  OutputIt out_;
  size_t limit_;
  size_t count_ = 0;

  truncating_iterator_base() : out_(), limit_(0) {}

  truncating_iterator_base(OutputIt out, size_t limit)
      : out_(out), limit_(limit) {}

 public:
  using iterator_category = std::output_iterator_tag;
  using value_type = typename std::iterator_traits<OutputIt>::value_type;
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
  using _Unchecked_type =
      truncating_iterator_base;  // Mark iterator as checked.

  OutputIt base() const { return out_; }
  size_t count() const { return count_; }
};

// An output iterator that truncates the output and counts the number of objects
// written to it.
template <typename OutputIt,
          typename Enable = typename std::is_void<
              typename std::iterator_traits<OutputIt>::value_type>::type>
class truncating_iterator;

template <typename OutputIt>
class truncating_iterator<OutputIt, std::false_type>
    : public truncating_iterator_base<OutputIt> {
  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;

 public:
  using value_type = typename truncating_iterator_base<OutputIt>::value_type;

  truncating_iterator() = default;

  truncating_iterator(OutputIt out, size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}

  truncating_iterator& operator++() {
    if (this->count_++ < this->limit_) ++this->out_;
    return *this;
  }

  truncating_iterator operator++(int) {
    auto it = *this;
    ++*this;
    return it;
  }

  value_type& operator*() const {
    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
  }
};

template <typename OutputIt>
class truncating_iterator<OutputIt, std::true_type>
    : public truncating_iterator_base<OutputIt> {
 public:
  truncating_iterator() = default;

  truncating_iterator(OutputIt out, size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}

  template <typename T> truncating_iterator& operator=(T val) {
    if (this->count_++ < this->limit_) *this->out_++ = val;
    return *this;
  }

  truncating_iterator& operator++() { return *this; }
  truncating_iterator& operator++(int) { return *this; }
  truncating_iterator& operator*() { return *this; }
};

// A compile-time string which is compiled into fast formatting code.
class compiled_string {};

template <typename S>
struct is_compiled_string : std::is_base_of<compiled_string, S> {};

/**
  \rst
  Converts a string literal *s* into a format string that will be parsed at
  compile time and converted into efficient formatting code. Requires C++17
  ``constexpr if`` compiler support.

  **Example**::

    // Converts 42 into std::string using the most efficient method and no
    // runtime format string processing.
    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
  \endrst
 */
#ifdef __cpp_if_constexpr
#  define FMT_COMPILE(s) \
    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
#else
#  define FMT_COMPILE(s) FMT_STRING(s)
#endif

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
template <typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
struct udl_compiled_string : compiled_string {
  using char_type = Char;
  constexpr operator basic_string_view<char_type>() const {
    return {Str.data, N - 1};
  }
};
#endif

template <typename T, typename... Tail>
const T& first(const T& value, const Tail&...) {
  return value;
}

#ifdef __cpp_if_constexpr
template <typename... Args> struct type_list {};

// Returns a reference to the argument at index N from [first, rest...].
template <int N, typename T, typename... Args>
constexpr const auto& get([[maybe_unused]] const T& first,
                          [[maybe_unused]] const Args&... rest) {
  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
  if constexpr (N == 0)
    return first;
  else
    return get<N - 1>(rest...);
}

template <typename Char, typename... Args>
constexpr int get_arg_index_by_name(basic_string_view<Char> name,
                                    type_list<Args...>) {
  return get_arg_index_by_name<Args...>(name);
}

template <int N, typename> struct get_type_impl;

template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
};

template <int N, typename T>
using get_type = typename get_type_impl<N, T>::type;

template <typename T> struct is_compiled_format : std::false_type {};

template <typename Char> struct text {
  basic_string_view<Char> data;
  using char_type = Char;

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&...) const {
    return write<Char>(out, data);
  }
};

template <typename Char>
struct is_compiled_format<text<Char>> : std::true_type {};

template <typename Char>
constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
                               size_t size) {
  return {{&s[pos], size}};
}

template <typename Char> struct code_unit {
  Char value;
  using char_type = Char;

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&...) const {
    return write<Char>(out, value);
  }
};

// This ensures that the argument type is convertible to `const T&`.
template <typename T, int N, typename... Args>
constexpr const T& get_arg_checked(const Args&... args) {
  const auto& arg = get<N>(args...);
  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
    return arg.value;
  } else {
    return arg;
  }
}

template <typename Char>
struct is_compiled_format<code_unit<Char>> : std::true_type {};

// A replacement field that refers to argument N.
template <typename Char, typename T, int N> struct field {
  using char_type = Char;

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
    return write<Char>(out, get_arg_checked<T, N>(args...));
  }
};

template <typename Char, typename T, int N>
struct is_compiled_format<field<Char, T, N>> : std::true_type {};

// A replacement field that refers to argument with name.
template <typename Char> struct runtime_named_field {
  using char_type = Char;
  basic_string_view<Char> name;

  template <typename OutputIt, typename T>
  constexpr static bool try_format_argument(
      OutputIt& out,
      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
      if (arg_name == arg.name) {
        out = write<Char>(out, arg.value);
        return true;
      }
    }
    return false;
  }

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
    bool found = (try_format_argument(out, name, args) || ...);
    if (!found) {
      throw format_error("argument with specified name is not found");
    }
    return out;
  }
};

template <typename Char>
struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};

// A replacement field that refers to argument N and has format specifiers.
template <typename Char, typename T, int N> struct spec_field {
  using char_type = Char;
  formatter<T, Char> fmt;

  template <typename OutputIt, typename... Args>
  constexpr FMT_INLINE OutputIt format(OutputIt out,
                                       const Args&... args) const {
    const auto& vargs =
        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
    basic_format_context<OutputIt, Char> ctx(out, vargs);
    return fmt.format(get_arg_checked<T, N>(args...), ctx);
  }
};

template <typename Char, typename T, int N>
struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};

template <typename L, typename R> struct concat {
  L lhs;
  R rhs;
  using char_type = typename L::char_type;

  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
    out = lhs.format(out, args...);
    return rhs.format(out, args...);
  }
};

template <typename L, typename R>
struct is_compiled_format<concat<L, R>> : std::true_type {};

template <typename L, typename R>
constexpr concat<L, R> make_concat(L lhs, R rhs) {
  return {lhs, rhs};
}

struct unknown_format {};

template <typename Char>
constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
  for (size_t size = str.size(); pos != size; ++pos) {
    if (str[pos] == '{' || str[pos] == '}') break;
  }
  return pos;
}

template <typename Args, size_t POS, int ID, typename S>
constexpr auto compile_format_string(S format_str);

template <typename Args, size_t POS, int ID, typename T, typename S>
constexpr auto parse_tail(T head, S format_str) {
  if constexpr (POS !=
                basic_string_view<typename S::char_type>(format_str).size()) {
    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
                               unknown_format>())
      return tail;
    else
      return make_concat(head, tail);
  } else {
    return head;
  }
}

template <typename T, typename Char> struct parse_specs_result {
  formatter<T, Char> fmt;
  size_t end;
  int next_arg_id;
};

constexpr int manual_indexing_id = -1;

template <typename T, typename Char>
constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                  size_t pos, int next_arg_id) {
  str.remove_prefix(pos);
  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
  auto f = formatter<T, Char>();
  auto end = f.parse(ctx);
  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
}

template <typename Char> struct arg_id_handler {
  arg_ref<Char> arg_id;

  constexpr int operator()() {
    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
    return 0;
  }
  constexpr int operator()(int id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }
  constexpr int operator()(basic_string_view<Char> id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }

  constexpr void on_error(const char* message) { throw format_error(message); }
};

template <typename Char> struct parse_arg_id_result {
  arg_ref<Char> arg_id;
  const Char* arg_id_end;
};

template <int ID, typename Char>
constexpr auto parse_arg_id(const Char* begin, const Char* end) {
  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
  auto arg_id_end = parse_arg_id(begin, end, handler);
  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
}

template <typename T, typename Enable = void> struct field_type {
  using type = remove_cvref_t<T>;
};

template <typename T>
struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
  using type = remove_cvref_t<decltype(T::value)>;
};

template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
          typename S>
constexpr auto parse_replacement_field_then_tail(S format_str) {
  using char_type = typename S::char_type;
  constexpr auto str = basic_string_view<char_type>(format_str);
  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
  if constexpr (c == '}') {
    return parse_tail<Args, END_POS + 1, NEXT_ID>(
        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
        format_str);
  } else if constexpr (c == ':') {
    constexpr auto result = parse_specs<typename field_type<T>::type>(
        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
    return parse_tail<Args, result.end, result.next_arg_id>(
        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
            result.fmt},
        format_str);
  }
}

// Compiles a non-empty format string and returns the compiled representation
// or unknown_format() on unrecognized input.
template <typename Args, size_t POS, int ID, typename S>
constexpr auto compile_format_string(S format_str) {
  using char_type = typename S::char_type;
  constexpr auto str = basic_string_view<char_type>(format_str);
  if constexpr (str[POS] == '{') {
    if constexpr (POS + 1 == str.size())
      throw format_error("unmatched '{' in format string");
    if constexpr (str[POS + 1] == '{') {
      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
      static_assert(ID != manual_indexing_id,
                    "cannot switch from manual to automatic argument indexing");
      constexpr auto next_id =
          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
                                               POS + 1, ID, next_id>(
          format_str);
    } else {
      constexpr auto arg_id_result =
          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
      constexpr char_type c =
          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
      static_assert(c == '}' || c == ':', "missing '}' in format string");
      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
        static_assert(
            ID == manual_indexing_id || ID == 0,
            "cannot switch from automatic to manual argument indexing");
        constexpr auto arg_index = arg_id_result.arg_id.val.index;
        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                 Args, arg_id_end_pos,
                                                 arg_index, manual_indexing_id>(
            format_str);
      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
        constexpr auto arg_index =
            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
        if constexpr (arg_index != invalid_arg_index) {
          constexpr auto next_id =
              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
          return parse_replacement_field_then_tail<
              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
              arg_index, next_id>(format_str);
        } else {
          if constexpr (c == '}') {
            return parse_tail<Args, arg_id_end_pos + 1, ID>(
                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
                format_str);
          } else if constexpr (c == ':') {
            return unknown_format();  // no type info for specs parsing
          }
        }
      }
    }
  } else if constexpr (str[POS] == '}') {
    if constexpr (POS + 1 == str.size())
      throw format_error("unmatched '}' in format string");
    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
  } else {
    constexpr auto end = parse_text(str, POS + 1);
    if constexpr (end - POS > 1) {
      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
                                       format_str);
    } else {
      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
                                       format_str);
    }
  }
}

template <typename... Args, typename S,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
constexpr auto compile(S format_str) {
  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
  if constexpr (str.size() == 0) {
    return detail::make_text(str, 0, 0);
  } else {
    constexpr auto result =
        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
            format_str);
    return result;
  }
}
#endif  // __cpp_if_constexpr
}  // namespace detail

FMT_MODULE_EXPORT_BEGIN

#ifdef __cpp_if_constexpr

template <typename CompiledFormat, typename... Args,
          typename Char = typename CompiledFormat::char_type,
          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
                                          const Args&... args) {
  auto s = std::basic_string<Char>();
  cf.format(std::back_inserter(s), args...);
  return s;
}

template <typename OutputIt, typename CompiledFormat, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
                                        const Args&... args) {
  return cf.format(out, args...);
}

template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
                                                           Args&&... args) {
  if constexpr (std::is_same<typename S::char_type, char>::value) {
    constexpr auto str = basic_string_view<typename S::char_type>(S());
    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
      const auto& first = detail::first(args...);
      if constexpr (detail::is_named_arg<
                        remove_cvref_t<decltype(first)>>::value) {
        return fmt::to_string(first.value);
      } else {
        return fmt::to_string(first);
      }
    }
  }
  constexpr auto compiled = detail::compile<Args...>(S());
  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                             detail::unknown_format>()) {
    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
                  std::forward<Args>(args)...);
  } else {
    return format(compiled, std::forward<Args>(args)...);
  }
}

template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
  constexpr auto compiled = detail::compile<Args...>(S());
  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                             detail::unknown_format>()) {
    return format_to(out,
                     static_cast<basic_string_view<typename S::char_type>>(S()),
                     std::forward<Args>(args)...);
  } else {
    return format_to(out, compiled, std::forward<Args>(args)...);
  }
}
#endif

template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
                                         const S& format_str, Args&&... args) {
  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
                      std::forward<Args>(args)...);
  return {it.base(), it.count()};
}

template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
size_t formatted_size(const S& format_str, const Args&... args) {
  return format_to(detail::counting_iterator(), format_str, args...).count();
}

template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
void print(std::FILE* f, const S& format_str, const Args&... args) {
  memory_buffer buffer;
  format_to(std::back_inserter(buffer), format_str, args...);
  detail::print(f, {buffer.data(), buffer.size()});
}

template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
void print(const S& format_str, const Args&... args) {
  print(stdout, format_str, args...);
}

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
inline namespace literals {
template <detail_exported::fixed_string Str>
constexpr detail::udl_compiled_string<
    remove_cvref_t<decltype(Str.data[0])>,
    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
operator""_cf() {
  return {};
}
}  // namespace literals
#endif

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_COMPILE_H_


================================================
FILE: examples/libraries/fmt/include/fmt/core.h
================================================
// Formatting library for C++ - the core API for char/UTF-8
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_CORE_H_
#define FMT_CORE_H_

#include <cstdio>  // std::FILE
#include <cstring>
#include <iterator>
#include <limits>
#include <string>
#include <type_traits>

// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 80001

#ifdef __clang__
#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
#else
#  define FMT_CLANG_VERSION 0
#endif

#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#  define FMT_GCC_PRAGMA(arg) _Pragma(arg)
#else
#  define FMT_GCC_VERSION 0
#  define FMT_GCC_PRAGMA(arg)
#endif

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#else
#  define FMT_HAS_GXX_CXX11 0
#endif

#if defined(__INTEL_COMPILER)
#  define FMT_ICC_VERSION __INTEL_COMPILER
#else
#  define FMT_ICC_VERSION 0
#endif

#ifdef __NVCC__
#  define FMT_NVCC __NVCC__
#else
#  define FMT_NVCC 0
#endif

#ifdef _MSC_VER
#  define FMT_MSC_VER _MSC_VER
#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
#else
#  define FMT_MSC_VER 0
#  define FMT_MSC_WARNING(...)
#endif

#ifdef __has_feature
#  define FMT_HAS_FEATURE(x) __has_feature(x)
#else
#  define FMT_HAS_FEATURE(x) 0
#endif

#if defined(__has_include) &&                             \
    (!defined(__INTELLISENSE__) || FMT_MSC_VER > 1900) && \
    (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1600)
#  define FMT_HAS_INCLUDE(x) __has_include(x)
#else
#  define FMT_HAS_INCLUDE(x) 0
#endif

#ifdef __has_cpp_attribute
#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif

#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
  (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
  (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

// Check if relaxed C++14 constexpr is supported.
// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
#ifndef FMT_USE_CONSTEXPR
#  define FMT_USE_CONSTEXPR                                           \
    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
        !FMT_NVCC && !FMT_ICC_VERSION
#endif
#if FMT_USE_CONSTEXPR
#  define FMT_CONSTEXPR constexpr
#  define FMT_CONSTEXPR_DECL constexpr
#else
#  define FMT_CONSTEXPR
#  define FMT_CONSTEXPR_DECL
#endif

// Check if constexpr std::char_traits<>::compare,length is supported.
#if defined(__GLIBCXX__)
#  if __cplusplus >= 201703L && defined(_GLIBCXX_RELEASE) && \
      _GLIBCXX_RELEASE >= 7  // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
#  endif
#elif defined(_LIBCPP_VERSION) && __cplusplus >= 201703L && \
    _LIBCPP_VERSION >= 4000
#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
#elif FMT_MSC_VER >= 1914 && _MSVC_LANG >= 201703L
#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
#endif
#ifndef FMT_CONSTEXPR_CHAR_TRAITS
#  define FMT_CONSTEXPR_CHAR_TRAITS
#endif

#ifndef FMT_OVERRIDE
#  if FMT_HAS_FEATURE(cxx_override_control) || \
      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
#    define FMT_OVERRIDE override
#  else
#    define FMT_OVERRIDE
#  endif
#endif

// Check if exceptions are disabled.
#ifndef FMT_EXCEPTIONS
#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
      FMT_MSC_VER && !_HAS_EXCEPTIONS
#    define FMT_EXCEPTIONS 0
#  else
#    define FMT_EXCEPTIONS 1
#  endif
#endif

// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
#  define FMT_USE_NOEXCEPT 0
#endif

#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
#  define FMT_DETECTED_NOEXCEPT noexcept
#  define FMT_HAS_CXX11_NOEXCEPT 1
#else
#  define FMT_DETECTED_NOEXCEPT throw()
#  define FMT_HAS_CXX11_NOEXCEPT 0
#endif

#ifndef FMT_NOEXCEPT
#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
#  else
#    define FMT_NOEXCEPT
#  endif
#endif

// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
// warnings.
#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
    !FMT_NVCC
#  define FMT_NORETURN [[noreturn]]
#else
#  define FMT_NORETURN
#endif

#ifndef FMT_MAYBE_UNUSED
#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
#    define FMT_MAYBE_UNUSED [[maybe_unused]]
#  else
#    define FMT_MAYBE_UNUSED
#  endif
#endif

#if __cplusplus == 201103L || __cplusplus == 201402L
#  if defined(__INTEL_COMPILER) || defined(__PGI)
#    define FMT_FALLTHROUGH
#  elif defined(__clang__)
#    define FMT_FALLTHROUGH [[clang::fallthrough]]
#  elif FMT_GCC_VERSION >= 700 && \
      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
#    define FMT_FALLTHROUGH [[gnu::fallthrough]]
#  else
#    define FMT_FALLTHROUGH
#  endif
#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#  define FMT_FALLTHROUGH [[fallthrough]]
#else
#  define FMT_FALLTHROUGH
#endif

#ifndef FMT_USE_FLOAT
#  define FMT_USE_FLOAT 1
#endif
#ifndef FMT_USE_DOUBLE
#  define FMT_USE_DOUBLE 1
#endif
#ifndef FMT_USE_LONG_DOUBLE
#  define FMT_USE_LONG_DOUBLE 1
#endif

#ifndef FMT_INLINE
#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
#    define FMT_INLINE inline __attribute__((always_inline))
#  else
#    define FMT_INLINE inline
#  endif
#endif

#ifndef FMT_USE_INLINE_NAMESPACES
#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
      (FMT_MSC_VER >= 1900 && (!defined(_MANAGED) || !_MANAGED))
#    define FMT_USE_INLINE_NAMESPACES 1
#  else
#    define FMT_USE_INLINE_NAMESPACES 0
#  endif
#endif

#ifndef FMT_BEGIN_NAMESPACE
#  if FMT_USE_INLINE_NAMESPACES
#    define FMT_INLINE_NAMESPACE inline namespace
#    define FMT_END_NAMESPACE \
      }                       \
      }
#  else
#    define FMT_INLINE_NAMESPACE namespace
#    define FMT_END_NAMESPACE \
      }                       \
      using namespace v8;     \
      }
#  endif
#  define FMT_BEGIN_NAMESPACE \
    namespace fmt {           \
    FMT_INLINE_NAMESPACE v8 {
#endif

#ifndef FMT_MODULE_EXPORT
#  define FMT_MODULE_EXPORT
#  define FMT_MODULE_EXPORT_BEGIN
#  define FMT_MODULE_EXPORT_END
#  define FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
#  define FMT_END_DETAIL_NAMESPACE }
#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
#  define FMT_CLASS_API FMT_MSC_WARNING(suppress : 4275)
#  ifdef FMT_EXPORT
#    define FMT_API __declspec(dllexport)
#  elif defined(FMT_SHARED)
#    define FMT_API __declspec(dllimport)
#  endif
#else
#  define FMT_CLASS_API
#  if defined(FMT_EXPORT) || defined(FMT_SHARED)
#    if defined(__GNUC__) || defined(__clang__)
#      define FMT_API __attribute__((visibility("default")))
#    endif
#  endif
#endif
#ifndef FMT_API
#  define FMT_API
#endif

#if FMT_GCC_VERSION
#  define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
#else
#  define FMT_GCC_VISIBILITY_HIDDEN
#endif

// libc++ supports string_view in pre-c++17.
#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
#  include <string_view>
#  define FMT_USE_STRING_VIEW
#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
#  include <experimental/string_view>
#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
#endif

#ifndef FMT_UNICODE
#  define FMT_UNICODE !FMT_MSC_VER
#endif

#ifndef FMT_CONSTEVAL
#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \
       __cplusplus > 201703L) ||                                 \
      (defined(__cpp_consteval) &&                               \
       !FMT_MSC_VER)  // consteval is broken in MSVC.
#    define FMT_CONSTEVAL consteval
#    define FMT_HAS_CONSTEVAL
#  else
#    define FMT_CONSTEVAL
#  endif
#endif

#ifndef FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
#  if defined(__cpp_nontype_template_args) &&                \
      ((FMT_GCC_VERSION >= 903 && __cplusplus >= 201709L) || \
       __cpp_nontype_template_args >= 201911L)
#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 1
#  else
#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 0
#  endif
#endif

// Enable minimal optimizations for more compact code in debug mode.
FMT_GCC_PRAGMA("GCC push_options")
#ifndef __OPTIMIZE__
FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
#endif

FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN

// Implementations of enable_if_t and other metafunctions for older systems.
template <bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template <bool B, typename T, typename F>
using conditional_t = typename std::conditional<B, T, F>::type;
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
template <typename T> struct type_identity { using type = T; };
template <typename T> using type_identity_t = typename type_identity<T>::type;

struct monostate {
  constexpr monostate() {}
};

// Suppress "unused variable" warnings with the method described in
// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
// (void)var does not work on many Intel compilers.
template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}

// An enable_if helper to be used in template parameters which results in much
// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#ifdef FMT_DOC
#  define FMT_ENABLE_IF(...)
#else
#  define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
#endif

FMT_BEGIN_DETAIL_NAMESPACE

constexpr FMT_INLINE auto is_constant_evaluated() FMT_NOEXCEPT -> bool {
#ifdef __cpp_lib_is_constant_evaluated
  return std::is_constant_evaluated();
#else
  return false;
#endif
}

// A function to suppress "conditional expression is constant" warnings.
template <typename T> constexpr auto const_check(T value) -> T { return value; }

FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
                                      const char* message);

#ifndef FMT_ASSERT
#  ifdef NDEBUG
// FMT_ASSERT is not empty to avoid -Werror=empty-body.
#    define FMT_ASSERT(condition, message) \
      ::fmt::ignore_unused((condition), (message))
#  else
#    define FMT_ASSERT(condition, message)                                    \
      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
           ? (void)0                                                          \
           : ::fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
#  endif
#endif

#if defined(FMT_USE_STRING_VIEW)
template <typename Char> using std_string_view = std::basic_string_view<Char>;
#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
template <typename Char>
using std_string_view = std::experimental::basic_string_view<Char>;
#else
template <typename T> struct std_string_view {};
#endif

#ifdef FMT_USE_INT128
// Do nothing.
#elif defined(__SIZEOF_INT128__) && !FMT_NVCC && \
    !(FMT_CLANG_VERSION && FMT_MSC_VER)
#  define FMT_USE_INT128 1
using int128_t = __int128_t;
using uint128_t = __uint128_t;
template <typename T> inline auto convert_for_visit(T value) -> T {
  return value;
}
#else
#  define FMT_USE_INT128 0
#endif
#if !FMT_USE_INT128
enum class int128_t {};
enum class uint128_t {};
// Reduce template instantiations.
template <typename T> inline auto convert_for_visit(T) -> monostate {
  return {};
}
#endif

// Casts a nonnegative integer to unsigned.
template <typename Int>
FMT_CONSTEXPR auto to_unsigned(Int value) ->
    typename std::make_unsigned<Int>::type {
  FMT_ASSERT(value >= 0, "negative value");
  return static_cast<typename std::make_unsigned<Int>::type>(value);
}

FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5";

constexpr auto is_utf8() -> bool {
  // Avoid buggy sign extensions in MSVC's constant evaluation mode.
  // https://developercommunity.visualstudio.com/t/C-difference-in-behavior-for-unsigned/1233612
  using uchar = unsigned char;
  return FMT_UNICODE || (sizeof(micro) == 3 && uchar(micro[0]) == 0xC2 &&
                         uchar(micro[1]) == 0xB5);
}
FMT_END_DETAIL_NAMESPACE

/**
  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
  subset of the API. ``fmt::basic_string_view`` is used for format strings even
  if ``std::string_view`` is available to prevent issues when a library is
  compiled with a different ``-std`` option than the client code (which is not
  recommended).
 */
template <typename Char> class basic_string_view {
 private:
  const Char* data_;
  size_t size_;

 public:
  using value_type = Char;
  using iterator = const Char*;

  constexpr basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}

  /** Constructs a string reference object from a C string and a size. */
  constexpr basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
      : data_(s),
        size_(count) {}

  /**
    \rst
    Constructs a string reference object from a C string computing
    the size with ``std::char_traits<Char>::length``.
    \endrst
   */
  FMT_CONSTEXPR_CHAR_TRAITS
  FMT_INLINE
  basic_string_view(const Char* s) : data_(s) {
    if (detail::const_check(std::is_same<Char, char>::value &&
                            !detail::is_constant_evaluated()))
      size_ = std::strlen(reinterpret_cast<const char*>(s));
    else
      size_ = std::char_traits<Char>::length(s);
  }

  /** Constructs a string reference from a ``std::basic_string`` object. */
  template <typename Traits, typename Alloc>
  FMT_CONSTEXPR basic_string_view(
      const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
      : data_(s.data()),
        size_(s.size()) {}

  template <typename S, FMT_ENABLE_IF(std::is_same<
                                      S, detail::std_string_view<Char>>::value)>
  FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
                                                      size_(s.size()) {}

  /** Returns a pointer to the string data. */
  constexpr auto data() const -> const Char* { return data_; }

  /** Returns the string size. */
  constexpr auto size() const -> size_t { return size_; }

  constexpr auto begin() const -> iterator { return data_; }
  constexpr auto end() const -> iterator { return data_ + size_; }

  constexpr auto operator[](size_t pos) const -> const Char& {
    return data_[pos];
  }

  FMT_CONSTEXPR void remove_prefix(size_t n) {
    data_ += n;
    size_ -= n;
  }

  // Lexicographically compare this string reference to other.
  FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
    size_t str_size = size_ < other.size_ ? size_ : other.size_;
    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
    if (result == 0)
      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
    return result;
  }

  FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs,
                                                   basic_string_view rhs)
      -> bool {
    return lhs.compare(rhs) == 0;
  }
  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) != 0;
  }
  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) < 0;
  }
  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) <= 0;
  }
  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) > 0;
  }
  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) >= 0;
  }
};

using string_view = basic_string_view<char>;

/** Specifies if ``T`` is a character type. Can be specialized by users. */
template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};

// Returns a string view of `s`.
template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
  return s;
}
template <typename Char, typename Traits, typename Alloc>
inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
    -> basic_string_view<Char> {
  return s;
}
template <typename Char>
constexpr auto to_string_view(basic_string_view<Char> s)
    -> basic_string_view<Char> {
  return s;
}
template <typename Char,
          FMT_ENABLE_IF(!std::is_empty<detail::std_string_view<Char>>::value)>
inline auto to_string_view(detail::std_string_view<Char> s)
    -> basic_string_view<Char> {
  return s;
}

// A base class for compile-time strings. It is defined in the fmt namespace to
// make formatting functions visible via ADL, e.g. format(FMT_STRING("{}"), 42).
struct compile_string {};

template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};

template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
constexpr auto to_string_view(const S& s)
    -> basic_string_view<typename S::char_type> {
  return basic_string_view<typename S::char_type>(s);
}

FMT_BEGIN_DETAIL_NAMESPACE

void to_string_view(...);
using fmt::v8::to_string_view;

// Specifies whether S is a string type convertible to fmt::basic_string_view.
// It should be a constexpr function but MSVC 2017 fails to compile it in
// enable_if and MSVC 2015 fails to compile it as an alias template.
template <typename S>
struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
};

template <typename S, typename = void> struct char_t_impl {};
template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
  using result = decltype(to_string_view(std::declval<S>()));
  using type = typename result::value_type;
};

// Reports a compile-time error if S is not a valid format string.
template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
FMT_INLINE void check_format_string(const S&) {
#ifdef FMT_ENFORCE_COMPILE_STRING
  static_assert(is_compile_string<S>::value,
                "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
                "FMT_STRING.");
#endif
}
template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
void check_format_string(S);

struct error_handler {
  constexpr error_handler() = default;
  constexpr error_handler(const error_handler&) = default;

  // This function is intentionally not constexpr to give a compile-time error.
  FMT_NORETURN FMT_API void on_error(const char* message);
};
FMT_END_DETAIL_NAMESPACE

/** String's character type. */
template <typename S> using char_t = typename detail::char_t_impl<S>::type;

/**
  \rst
  Parsing context consisting of a format string range being parsed and an
  argument counter for automatic indexing.
  You can use the ``format_parse_context`` type alias for ``char`` instead.
  \endrst
 */
template <typename Char, typename ErrorHandler = detail::error_handler>
class basic_format_parse_context : private ErrorHandler {
 private:
  basic_string_view<Char> format_str_;
  int next_arg_id_;

 public:
  using char_type = Char;
  using iterator = typename basic_string_view<Char>::iterator;

  explicit constexpr basic_format_parse_context(
      basic_string_view<Char> format_str, ErrorHandler eh = {},
      int next_arg_id = 0)
      : ErrorHandler(eh), format_str_(format_str), next_arg_id_(next_arg_id) {}

  /**
    Returns an iterator to the beginning of the format string range being
    parsed.
   */
  constexpr auto begin() const FMT_NOEXCEPT -> iterator {
    return format_str_.begin();
  }

  /**
    Returns an iterator past the end of the format string range being parsed.
   */
  constexpr auto end() const FMT_NOEXCEPT -> iterator {
    return format_str_.end();
  }

  /** Advances the begin iterator to ``it``. */
  FMT_CONSTEXPR void advance_to(iterator it) {
    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
  }

  /**
    Reports an error if using the manual argument indexing; otherwise returns
    the next argument index and switches to the automatic indexing.
   */
  FMT_CONSTEXPR auto next_arg_id() -> int {
    // Don't check if the argument id is valid to avoid overhead and because it
    // will be checked during formatting anyway.
    if (next_arg_id_ >= 0) return next_arg_id_++;
    on_error("cannot switch from manual to automatic argument indexing");
    return 0;
  }

  /**
    Reports an error if using the automatic argument indexing; otherwise
    switches to the manual indexing.
   */
  FMT_CONSTEXPR void check_arg_id(int) {
    if (next_arg_id_ > 0)
      on_error("cannot switch from automatic to manual argument indexing");
    else
      next_arg_id_ = -1;
  }

  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}

  FMT_CONSTEXPR void on_error(const char* message) {
    ErrorHandler::on_error(message);
  }

  constexpr auto error_handler() const -> ErrorHandler { return *this; }
};

using format_parse_context = basic_format_parse_context<char>;

template <typename Context> class basic_format_arg;
template <typename Context> class basic_format_args;
template <typename Context> class dynamic_format_arg_store;

// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
  // A deleted default constructor indicates a disabled formatter.
  formatter() = delete;
};

// Specifies if T has an enabled formatter specialization. A type can be
// formattable even if it doesn't have a formatter e.g. via a conversion.
template <typename T, typename Context>
using has_formatter =
    std::is_constructible<typename Context::template formatter_type<T>>;

// Checks whether T is a container with contiguous storage.
template <typename T> struct is_contiguous : std::false_type {};
template <typename Char>
struct is_contiguous<std::basic_string<Char>> : std::true_type {};

class appender;

FMT_BEGIN_DETAIL_NAMESPACE

// Extracts a reference to the container from back_insert_iterator.
template <typename Container>
inline auto get_container(std::back_insert_iterator<Container> it)
    -> Container& {
  using bi_iterator = std::back_insert_iterator<Container>;
  struct accessor : bi_iterator {
    accessor(bi_iterator iter) : bi_iterator(iter) {}
    using bi_iterator::container;
  };
  return *accessor(it).container;
}

template <typename Char, typename InputIt, typename OutputIt>
FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
    -> OutputIt {
  while (begin != end) *out++ = static_cast<Char>(*begin++);
  return out;
}

template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
FMT_CONSTEXPR auto copy_str(const Char* begin, const Char* end, Char* out)
    -> Char* {
  if (is_constant_evaluated())
    return copy_str<Char, const Char*, Char*>(begin, end, out);
  auto size = to_unsigned(end - begin);
  memcpy(out, begin, size);
  return out + size;
}

/**
  \rst
  A contiguous memory buffer with an optional growing ability. It is an internal
  class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`.
  \endrst
 */
template <typename T> class buffer {
 private:
  T* ptr_;
  size_t size_;
  size_t capacity_;

 protected:
  // Don't initialize ptr_ since it is not accessed to save a few cycles.
  FMT_MSC_WARNING(suppress : 26495)
  buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}

  buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) FMT_NOEXCEPT
      : ptr_(p),
        size_(sz),
        capacity_(cap) {}

  ~buffer() = default;
  buffer(buffer&&) = default;

  /** Sets the buffer data and capacity. */
  void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT {
    ptr_ = buf_data;
    capacity_ = buf_capacity;
  }

  /** Increases the buffer capacity to hold at least *capacity* elements. */
  virtual void grow(size_t capacity) = 0;

 public:
  using value_type = T;
  using const_reference = const T&;

  buffer(const buffer&) = delete;
  void operator=(const buffer&) = delete;

  auto begin() FMT_NOEXCEPT -> T* { return ptr_; }
  auto end() FMT_NOEXCEPT -> T* { return ptr_ + size_; }

  auto begin() const FMT_NOEXCEPT -> const T* { return ptr_; }
  auto end() const FMT_NOEXCEPT -> const T* { return ptr_ + size_; }

  /** Returns the size of this buffer. */
  auto size() const FMT_NOEXCEPT -> size_t { return size_; }

  /** Returns the capacity of this buffer. */
  auto capacity() const FMT_NOEXCEPT -> size_t { return capacity_; }

  /** Returns a pointer to the buffer data. */
  auto data() FMT_NOEXCEPT -> T* { return ptr_; }

  /** Returns a pointer to the buffer data. */
  auto data() const FMT_NOEXCEPT -> const T* { return ptr_; }

  /** Clears this buffer. */
  void clear() { size_ = 0; }

  // Tries resizing the buffer to contain *count* elements. If T is a POD type
  // the new elements may not be initialized.
  void try_resize(size_t count) {
    try_reserve(count);
    size_ = count <= capacity_ ? count : capacity_;
  }

  // Tries increasing the buffer capacity to *new_capacity*. It can increase the
  // capacity by a smaller amount than requested but guarantees there is space
  // for at least one additional element either by increasing the capacity or by
  // flushing the buffer if it is full.
  void try_reserve(size_t new_capacity) {
    if (new_capacity > capacity_) grow(new_capacity);
  }

  void push_back(const T& value) {
    try_reserve(size_ + 1);
    ptr_[size_++] = value;
  }

  /** Appends data to the end of the buffer. */
  template <typename U> void append(const U* begin, const U* end);

  template <typename I> auto operator[](I index) -> T& { return ptr_[index]; }
  template <typename I> auto operator[](I index) const -> const T& {
    return ptr_[index];
  }
};

struct buffer_traits {
  explicit buffer_traits(size_t) {}
  auto count() const -> size_t { return 0; }
  auto limit(size_t size) -> size_t { return size; }
};

class fixed_buffer_traits {
 private:
  size_t count_ = 0;
  size_t limit_;

 public:
  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
  auto count() const -> size_t { return count_; }
  auto limit(size_t size) -> size_t {
    size_t n = limit_ > count_ ? limit_ - count_ : 0;
    count_ += size;
    return size < n ? size : n;
  }
};

// A buffer that writes to an output iterator when flushed.
template <typename OutputIt, typename T, typename Traits = buffer_traits>
class iterator_buffer final : public Traits, public buffer<T> {
 private:
  OutputIt out_;
  enum { buffer_size = 256 };
  T data_[buffer_size];

 protected:
  void grow(size_t) final FMT_OVERRIDE {
    if (this->size() == buffer_size) flush();
  }

  void flush() {
    auto size = this->size();
    this->clear();
    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
  }

 public:
  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
  iterator_buffer(iterator_buffer&& other)
      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
  ~iterator_buffer() { flush(); }

  auto out() -> OutputIt {
    flush();
    return out_;
  }
  auto count() const -> size_t { return Traits::count() + this->size(); }
};

template <typename T> class iterator_buffer<T*, T> final : public buffer<T> {
 protected:
  void grow(size_t) final FMT_OVERRIDE {}

 public:
  explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}

  auto out() -> T* { return &*this->end(); }
};

// A buffer that writes to a container with the contiguous storage.
template <typename Container>
class iterator_buffer<std::back_insert_iterator<Container>,
                      enable_if_t<is_contiguous<Container>::value,
                                  typename Container::value_type>>
    final : public buffer<typename Container::value_type> {
 private:
  Container& container_;

 protected:
  void grow(size_t capacity) final FMT_OVERRIDE {
    container_.resize(capacity);
    this->set(&container_[0], capacity);
  }

 public:
  explicit iterator_buffer(Container& c)
      : buffer<typename Container::value_type>(c.size()), container_(c) {}
  explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
      : iterator_buffer(get_container(out)) {}
  auto out() -> std::back_insert_iterator<Container> {
    return std::back_inserter(container_);
  }
};

// A buffer that counts the number of code units written discarding the output.
template <typename T = char> class counting_buffer final : public buffer<T> {
 private:
  enum { buffer_size = 256 };
  T data_[buffer_size];
  size_t count_ = 0;

 protected:
  void grow(size_t) final FMT_OVERRIDE {
    if (this->size() != buffer_size) return;
    count_ += this->size();
    this->clear();
  }

 public:
  counting_buffer() : buffer<T>(data_, 0, buffer_size) {}

  auto count() -> size_t { return count_ + this->size(); }
};

template <typename T>
using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
                                      std::back_insert_iterator<buffer<T>>>;

// Maps an output iterator to a buffer.
template <typename T, typename OutputIt>
auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
  return iterator_buffer<OutputIt, T>(out);
}

template <typename Buffer>
auto get_iterator(Buffer& buf) -> decltype(buf.out()) {
  return buf.out();
}
template <typename T> auto get_iterator(buffer<T>& buf) -> buffer_appender<T> {
  return buffer_appender<T>(buf);
}

template <typename T, typename Char = char, typename Enable = void>
struct fallback_formatter {
  fallback_formatter() = delete;
};

// Specifies if T has an enabled fallback_formatter specialization.
template <typename T, typename Char>
using has_fallback_formatter =
    std::is_constructible<fallback_formatter<T, Char>>;

struct view {};

template <typename Char, typename T> struct named_arg : view {
  const Char* name;
  const T& value;
  named_arg(const Char* n, const T& v) : name(n), value(v) {}
};

template <typename Char> struct named_arg_info {
  const Char* name;
  int id;
};

template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
struct arg_data {
  // args_[0].named_args points to named_args_ to avoid bloating format_args.
  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
  T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
  named_arg_info<Char> named_args_[NUM_NAMED_ARGS];

  template <typename... U>
  arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
  arg_data(const arg_data& other) = delete;
  auto args() const -> const T* { return args_ + 1; }
  auto named_args() -> named_arg_info<Char>* { return named_args_; }
};

template <typename T, typename Char, size_t NUM_ARGS>
struct arg_data<T, Char, NUM_ARGS, 0> {
  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
  T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];

  template <typename... U>
  FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {}
  FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; }
  FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t {
    return nullptr;
  }
};

template <typename Char>
inline void init_named_args(named_arg_info<Char>*, int, int) {}

template <typename T> struct is_named_arg : std::false_type {};
template <typename T> struct is_statically_named_arg : std::false_type {};

template <typename T, typename Char>
struct is_named_arg<named_arg<Char, T>> : std::true_type {};

template <typename Char, typename T, typename... Tail,
          FMT_ENABLE_IF(!is_named_arg<T>::value)>
void init_named_args(named_arg_info<Char>* named_args, int arg_count,
                     int named_arg_count, const T&, const Tail&... args) {
  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
}

template <typename Char, typename T, typename... Tail,
          FMT_ENABLE_IF(is_named_arg<T>::value)>
void init_named_args(named_arg_info<Char>* named_args, int arg_count,
                     int named_arg_count, const T& arg, const Tail&... args) {
  named_args[named_arg_count++] = {arg.name, arg_count};
  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
}

template <typename... Args>
FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int,
                                              const Args&...) {}

template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
  return (B1 ? 1 : 0) + count<B2, Tail...>();
}

template <typename... Args> constexpr auto count_named_args() -> size_t {
  return count<is_named_arg<Args>::value...>();
}

enum class type {
  none_type,
  // Integer types should go first,
  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  int128_type,
  uint128_type,
  bool_type,
  char_type,
  last_integer_type = char_type,
  // followed by floating-point types.
  float_type,
  double_type,
  long_double_type,
  last_numeric_type = long_double_type,
  cstring_type,
  string_type,
  pointer_type,
  custom_type
};

// Maps core type T to the corresponding type enum constant.
template <typename T, typename Char>
struct type_constant : std::integral_constant<type, type::custom_type> {};

#define FMT_TYPE_CONSTANT(Type, constant) \
  template <typename Char>                \
  struct type_constant<Type, Char>        \
      : std::integral_constant<type, type::constant> {}

FMT_TYPE_CONSTANT(int, int_type);
FMT_TYPE_CONSTANT(unsigned, uint_type);
FMT_TYPE_CONSTANT(long long, long_long_type);
FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
FMT_TYPE_CONSTANT(int128_t, int128_type);
FMT_TYPE_CONSTANT(uint128_t, uint128_type);
FMT_TYPE_CONSTANT(bool, bool_type);
FMT_TYPE_CONSTANT(Char, char_type);
FMT_TYPE_CONSTANT(float, float_type);
FMT_TYPE_CONSTANT(double, double_type);
FMT_TYPE_CONSTANT(long double, long_double_type);
FMT_TYPE_CONSTANT(const Char*, cstring_type);
FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
FMT_TYPE_CONSTANT(const void*, pointer_type);

constexpr bool is_integral_type(type t) {
  return t > type::none_type && t <= type::last_integer_type;
}

constexpr bool is_arithmetic_type(type t) {
  return t > type::none_type && t <= type::last_numeric_type;
}

template <typename Char> struct string_value {
  const Char* data;
  size_t size;
};

template <typename Char> struct named_arg_value {
  const named_arg_info<Char>* data;
  size_t size;
};

template <typename Context> struct custom_value {
  using parse_context = typename Context::parse_context_type;
  const void* value;
  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
};

// A formatting argument value.
template <typename Context> class value {
 public:
  using char_type = typename Context::char_type;

  union {
    monostate no_value;
    int int_value;
    unsigned uint_value;
    long long long_long_value;
    unsigned long long ulong_long_value;
    int128_t int128_value;
    uint128_t uint128_value;
    bool bool_value;
    char_type char_value;
    float float_value;
    double double_value;
    long double long_double_value;
    const void* pointer;
    string_value<char_type> string;
    custom_value<Context> custom;
    named_arg_value<char_type> named_args;
  };

  constexpr FMT_INLINE value() : no_value() {}
  constexpr FMT_INLINE value(int val) : int_value(val) {}
  constexpr FMT_INLINE value(unsigned val) : uint_value(val) {}
  constexpr FMT_INLINE value(long long val) : long_long_value(val) {}
  constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
  FMT_INLINE value(int128_t val) : int128_value(val) {}
  FMT_INLINE value(uint128_t val) : uint128_value(val) {}
  FMT_INLINE value(float val) : float_value(val) {}
  FMT_INLINE value(double val) : double_value(val) {}
  FMT_INLINE value(long double val) : long_double_value(val) {}
  constexpr FMT_INLINE value(bool val) : bool_value(val) {}
  constexpr FMT_INLINE value(char_type val) : char_value(val) {}
  FMT_CONSTEXPR FMT_INLINE value(const char_type* val) {
    string.data = val;
    if (is_constant_evaluated()) string.size = {};
  }
  FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val) {
    string.data = val.data();
    string.size = val.size();
  }
  FMT_INLINE value(const void* val) : pointer(val) {}
  FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
      : named_args{args, size} {}

  template <typename T> FMT_CONSTEXPR FMT_INLINE value(const T& val) {
    custom.value = &val;
    // Get the formatter type through the context to allow different contexts
    // have different extension points, e.g. `formatter<T>` for `format` and
    // `printf_formatter<T>` for `printf`.
    custom.format = format_custom_arg<
        T, conditional_t<has_formatter<T, Context>::value,
                         typename Context::template formatter_type<T>,
                         fallback_formatter<T, char_type>>>;
  }

 private:
  // Formats an argument of a custom type, such as a user-defined class.
  template <typename T, typename Formatter>
  static void format_custom_arg(const void* arg,
                                typename Context::parse_context_type& parse_ctx,
                                Context& ctx) {
    Formatter f;
    parse_ctx.advance_to(f.parse(parse_ctx));
    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
  }
};

template <typename Context, typename T>
FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context>;

// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
enum { long_short = sizeof(long) == sizeof(int) };
using long_type = conditional_t<long_short, int, long long>;
using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;

struct unformattable {};

// Maps formatting arguments to core types.
template <typename Context> struct arg_mapper {
  using char_type = typename Context::char_type;

  FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val)
      -> unsigned long long {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(int128_t val) -> int128_t { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(uint128_t val) -> uint128_t { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; }

  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type {
    static_assert(
        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
        "mixing character types is disallowed");
    return val;
  }

  FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double {
    return val;
  }

  FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* {
    return val;
  }
  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
      -> basic_string_view<char_type> {
    static_assert(std::is_same<char_type, char_t<T>>::value,
                  "mixing character types is disallowed");
    return to_string_view(val);
  }
  template <typename T,
            FMT_ENABLE_IF(
                std::is_constructible<basic_string_view<char_type>, T>::value &&
                !is_string<T>::value && !has_formatter<T, Context>::value &&
                !has_fallback_formatter<T, char_type>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
      -> basic_string_view<char_type> {
    return basic_string_view<char_type>(val);
  }
  template <
      typename T,
      FMT_ENABLE_IF(
          std::is_constructible<std_string_view<char_type>, T>::value &&
          !std::is_constructible<basic_string_view<char_type>, T>::value &&
          !is_string<T>::value && !has_formatter<T, Context>::value &&
          !has_fallback_formatter<T, char_type>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
      -> basic_string_view<char_type> {
    return std_string_view<char_type>(val);
  }
  FMT_CONSTEXPR FMT_INLINE auto map(const signed char* val) -> const char* {
    static_assert(std::is_same<char_type, char>::value, "invalid string type");
    return reinterpret_cast<const char*>(val);
  }
  FMT_CONSTEXPR FMT_INLINE auto map(const unsigned char* val) -> const char* {
    static_assert(std::is_same<char_type, char>::value, "invalid string type");
    return reinterpret_cast<const char*>(val);
  }
  FMT_CONSTEXPR FMT_INLINE auto map(signed char* val) -> const char* {
    const auto* const_val = val;
    return map(const_val);
  }
  FMT_CONSTEXPR FMT_INLINE auto map(unsigned char* val) -> const char* {
    const auto* const_val = val;
    return map(const_val);
  }

  FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; }
  FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* {
    return val;
  }
  FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* {
    return val;
  }

  // We use SFINAE instead of a const T* parameter to avoid conflicting with
  // the C array overload.
  template <typename T>
  FMT_CONSTEXPR auto map(T) -> enable_if_t<std::is_pointer<T>::value, int> {
    // Formatting of arbitrary pointers is disallowed. If you want to output
    // a pointer cast it to "void *" or "const void *". In particular, this
    // forbids formatting of "[const] volatile char *" which is printed as bool
    // by iostreams.
    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
    return 0;
  }

  template <typename T, std::size_t N>
  FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] {
    return values;
  }

  template <typename T,
            FMT_ENABLE_IF(std::is_enum<T>::value &&
                          !has_formatter<T, Context>::value &&
                          !has_fallback_formatter<T, char_type>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
      -> decltype(std::declval<arg_mapper>().map(
          static_cast<typename std::underlying_type<T>::type>(val))) {
    return map(static_cast<typename std::underlying_type<T>::type>(val));
  }
  template <typename T,
            FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
                          (has_formatter<T, Context>::value ||
                           has_fallback_formatter<T, char_type>::value))>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> const T& {
    return val;
  }

  template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
  FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
      -> decltype(std::declval<arg_mapper>().map(named_arg.value)) {
    return map(named_arg.value);
  }

  auto map(...) -> unformattable { return {}; }
};

// A type constant after applying arg_mapper<Context>.
template <typename T, typename Context>
using mapped_type_constant =
    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
                  typename Context::char_type>;

enum { packed_arg_bits = 4 };
// Maximum number of arguments with packed types.
enum { max_packed_args = 62 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
enum : unsigned long long { has_named_args_bit = 1ULL << 62 };

FMT_END_DETAIL_NAMESPACE

// An output iterator that appends to a buffer.
// It is used to reduce symbol sizes for the common case.
class appender : public std::back_insert_iterator<detail::buffer<char>> {
  using base = std::back_insert_iterator<detail::buffer<char>>;

  template <typename T>
  friend auto get_buffer(appender out) -> detail::buffer<char>& {
    return detail::get_container(out);
  }

 public:
  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
  appender(base it) : base(it) {}
  using _Unchecked_type = appender;  // Mark iterator as checked.

  auto operator++() -> appender& {
    base::operator++();
    return *this;
  }

  auto operator++(int) -> appender {
    auto tmp = *this;
    ++*this;
    return tmp;
  }
};

// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in basic_memory_buffer.
template <typename Context> class basic_format_arg {
 private:
  detail::value<Context> value_;
  detail::type type_;

  template <typename ContextType, typename T>
  friend FMT_CONSTEXPR auto detail::make_arg(const T& value)
      -> basic_format_arg<ContextType>;

  template <typename Visitor, typename Ctx>
  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
                                             const basic_format_arg<Ctx>& arg)
      -> decltype(vis(0));

  friend class basic_format_args<Context>;
  friend class dynamic_format_arg_store<Context>;

  using char_type = typename Context::char_type;

  template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
  friend struct detail::arg_data;

  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
      : value_(args, size) {}

 public:
  class handle {
   public:
    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}

    void format(typename Context::parse_context_type& parse_ctx,
                Context& ctx) const {
      custom_.format(custom_.value, parse_ctx, ctx);
    }

   private:
    detail::custom_value<Context> custom_;
  };

  constexpr basic_format_arg() : type_(detail::type::none_type) {}

  constexpr explicit operator bool() const FMT_NOEXCEPT {
    return type_ != detail::type::none_type;
  }

  auto type() const -> detail::type { return type_; }

  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
  auto is_arithmetic() const -> bool {
    return detail::is_arithmetic_type(type_);
  }
};

/**
  \rst
  Visits an argument dispatching to the appropriate visit method based on
  the argument type. For example, if the argument type is ``double`` then
  ``vis(value)`` will be called with the value of type ``double``.
  \endrst
 */
template <typename Visitor, typename Context>
FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
  switch (arg.type_) {
  case detail::type::none_type:
    break;
  case detail::type::int_type:
    return vis(arg.value_.int_value);
  case detail::type::uint_type:
    return vis(arg.value_.uint_value);
  case detail::type::long_long_type:
    return vis(arg.value_.long_long_value);
  case detail::type::ulong_long_type:
    return vis(arg.value_.ulong_long_value);
  case detail::type::int128_type:
    return vis(detail::convert_for_visit(arg.value_.int128_value));
  case detail::type::uint128_type:
    return vis(detail::convert_for_visit(arg.value_.uint128_value));
  case detail::type::bool_type:
    return vis(arg.value_.bool_value);
  case detail::type::char_type:
    return vis(arg.value_.char_value);
  case detail::type::float_type:
    return vis(arg.value_.float_value);
  case detail::type::double_type:
    return vis(arg.value_.double_value);
  case detail::type::long_double_type:
    return vis(arg.value_.long_double_value);
  case detail::type::cstring_type:
    return vis(arg.value_.string.data);
  case detail::type::string_type:
    using sv = basic_string_view<typename Context::char_type>;
    return vis(sv(arg.value_.string.data, arg.value_.string.size));
  case detail::type::pointer_type:
    return vis(arg.value_.pointer);
  case detail::type::custom_type:
    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
  }
  return vis(monostate());
}

FMT_BEGIN_DETAIL_NAMESPACE

template <typename Char, typename InputIt>
auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
  get_container(out).append(begin, end);
  return out;
}

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
template <typename... Ts> struct void_t_impl { using type = void; };
template <typename... Ts>
using void_t = typename detail::void_t_impl<Ts...>::type;
#else
template <typename...> using void_t = void;
#endif

template <typename It, typename T, typename Enable = void>
struct is_output_iterator : std::false_type {};

template <typename It, typename T>
struct is_output_iterator<
    It, T,
    void_t<typename std::iterator_traits<It>::iterator_category,
           decltype(*std::declval<It>() = std::declval<T>())>>
    : std::true_type {};

template <typename OutputIt>
struct is_back_insert_iterator : std::false_type {};
template <typename Container>
struct is_back_insert_iterator<std::back_insert_iterator<Container>>
    : std::true_type {};

template <typename OutputIt>
struct is_contiguous_back_insert_iterator : std::false_type {};
template <typename Container>
struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
    : is_contiguous<Container> {};
template <>
struct is_contiguous_back_insert_iterator<appender> : std::true_type {};

// A type-erased reference to an std::locale to avoid heavy <locale> include.
class locale_ref {
 private:
  const void* locale_;  // A type-erased pointer to std::locale.

 public:
  constexpr locale_ref() : locale_(nullptr) {}
  template <typename Locale> explicit locale_ref(const Locale& loc);

  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }

  template <typename Locale> auto get() const -> Locale;
};

template <typename> constexpr auto encode_types() -> unsigned long long {
  return 0;
}

template <typename Context, typename Arg, typename... Args>
constexpr auto encode_types() -> unsigned long long {
  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
         (encode_types<Context, Args...>() << packed_arg_bits);
}

template <typename Context, typename T>
FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context> {
  basic_format_arg<Context> arg;
  arg.type_ = mapped_type_constant<T, Context>::value;
  arg.value_ = arg_mapper<Context>().map(value);
  return arg;
}

// The type template parameter is there to avoid an ODR violation when using
// a fallback formatter in one translation unit and an implicit conversion in
// another (not recommended).
template <bool IS_PACKED, typename Context, type, typename T,
          FMT_ENABLE_IF(IS_PACKED)>
FMT_CONSTEXPR FMT_INLINE auto make_arg(const T& val) -> value<Context> {
  const auto& arg = arg_mapper<Context>().map(val);
  static_assert(
      !std::is_same<decltype(arg), const unformattable&>::value,
      "Cannot format an argument. To make type T formattable provide a "
      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
  return {arg};
}

template <bool IS_PACKED, typename Context, type, typename T,
          FMT_ENABLE_IF(!IS_PACKED)>
inline auto make_arg(const T& value) -> basic_format_arg<Context> {
  return make_arg<Context>(value);
}
FMT_END_DETAIL_NAMESPACE

// Formatting context.
template <typename OutputIt, typename Char> class basic_format_context {
 public:
  /** The character type for the output. */
  using char_type = Char;

 private:
  OutputIt out_;
  basic_format_args<basic_format_context> args_;
  detail::locale_ref loc_;

 public:
  using iterator = OutputIt;
  using format_arg = basic_format_arg<basic_format_context>;
  using parse_context_type = basic_format_parse_context<Char>;
  template <typename T> using formatter_type = formatter<T, char_type>;

  basic_format_context(basic_format_context&&) = default;
  basic_format_context(const basic_format_context&) = delete;
  void operator=(const basic_format_context&) = delete;
  /**
   Constructs a ``basic_format_context`` object. References to the arguments are
   stored in the object so make sure they have appropriate lifetimes.
   */
  constexpr basic_format_context(
      OutputIt out, basic_format_args<basic_format_context> ctx_args,
      detail::locale_ref loc = detail::locale_ref())
      : out_(out), args_(ctx_args), loc_(loc) {}

  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
  FMT_CONSTEXPR auto arg(basic_string_view<char_type> name) -> format_arg {
    return args_.get(name);
  }
  FMT_CONSTEXPR auto arg_id(basic_string_view<char_type> name) -> int {
    return args_.get_id(name);
  }
  auto args() const -> const basic_format_args<basic_format_context>& {
    return args_;
  }

  FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
  void on_error(const char* message) { error_handler().on_error(message); }

  // Returns an iterator to the beginning of the output range.
  FMT_CONSTEXPR auto out() -> iterator { return out_; }

  // Advances the begin iterator to ``it``.
  void advance_to(iterator it) {
    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
  }

  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
};

template <typename Char>
using buffer_context =
    basic_format_context<detail::buffer_appender<Char>, Char>;
using format_context = buffer_context<char>;

// Workaround an alias issue: https://stackoverflow.com/q/62767544/471164.
#define FMT_BUFFER_CONTEXT(Char) \
  basic_format_context<detail::buffer_appender<Char>, Char>

template <typename T, typename Char = char>
using is_formattable = bool_constant<
    !std::is_same<decltype(detail::arg_mapper<buffer_context<Char>>().map(
                      std::declval<T>())),
                  detail::unformattable>::value &&
    !detail::has_fallback_formatter<T, Char>::value>;

/**
  \rst
  An array of references to arguments. It can be implicitly converted into
  `~fmt::basic_format_args` for passing into type-erased formatting functions
  such as `~fmt::vformat`.
  \endrst
 */
template <typename Context, typename... Args>
class format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
    // Workaround a GCC template argument substitution bug.
    : public basic_format_args<Context>
#endif
{
 private:
  static const size_t num_args = sizeof...(Args);
  static const size_t num_named_args = detail::count_named_args<Args...>();
  static const bool is_packed = num_args <= detail::max_packed_args;

  using value_type = conditional_t<is_packed, detail::value<Context>,
                                   basic_format_arg<Context>>;

  detail::arg_data<value_type, typename Context::char_type, num_args,
                   num_named_args>
      data_;

  friend class basic_format_args<Context>;

  static constexpr unsigned long long desc =
      (is_packed ? detail::encode_types<Context, Args...>()
                 : detail::is_unpacked_bit | num_args) |
      (num_named_args != 0
           ? static_cast<unsigned long long>(detail::has_named_args_bit)
           : 0);

 public:
  FMT_CONSTEXPR FMT_INLINE format_arg_store(const Args&... args)
      :
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
        basic_format_args<Context>(*this),
#endif
        data_{detail::make_arg<
            is_packed, Context,
            detail::mapped_type_constant<Args, Context>::value>(args)...} {
    detail::init_named_args(data_.named_args(), 0, 0, args...);
  }
};

/**
  \rst
  Constructs a `~fmt::format_arg_store` object that contains references to
  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
  can be omitted in which case it defaults to `~fmt::context`.
  See `~fmt::arg` for lifetime considerations.
  \endrst
 */
template <typename Context = format_context, typename... Args>
constexpr auto make_format_args(const Args&... args)
    -> format_arg_store<Context, Args...> {
  return {args...};
}

/**
  \rst
  Returns a named argument to be used in a formatting function.
  It should only be used in a call to a formatting function or
  `dynamic_format_arg_store::push_back`.

  **Example**::

    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
  \endrst
 */
template <typename Char, typename T>
inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
  return {name, arg};
}

/**
  \rst
  A view of a collection of formatting arguments. To avoid lifetime issues it
  should only be used as a parameter type in type-erased functions such as
  ``vformat``::

    void vlog(string_view format_str, format_args args);  // OK
    format_args args = make_format_args(42);  // Error: dangling reference
  \endrst
 */
template <typename Context> class basic_format_args {
 public:
  using size_type = int;
  using format_arg = basic_format_arg<Context>;

 private:
  // A descriptor that contains information about formatting arguments.
  // If the number of arguments is less or equal to max_packed_args then
  // argument types are passed in the descriptor. This reduces binary code size
  // per formatting function call.
  unsigned long long desc_;
  union {
    // If is_packed() returns true then argument values are stored in values_;
    // otherwise they are stored in args_. This is done to improve cache
    // locality and reduce compiled code size since storing larger objects
    // may require more code (at least on x86-64) even if the same amount of
    // data is actually copied to stack. It saves ~10% on the bloat test.
    const detail::value<Context>* values_;
    const format_arg* args_;
  };

  constexpr auto is_packed() const -> bool {
    return (desc_ & detail::is_unpacked_bit) == 0;
  }
  auto has_named_args() const -> bool {
    return (desc_ & detail::has_named_args_bit) != 0;
  }

  FMT_CONSTEXPR auto type(int index) const -> detail::type {
    int shift = index * detail::packed_arg_bits;
    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
    return static_cast<detail::type>((desc_ >> shift) & mask);
  }

  constexpr FMT_INLINE basic_format_args(unsigned long long desc,
                                         const detail::value<Context>* values)
      : desc_(desc), values_(values) {}
  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
      : desc_(desc), args_(args) {}

 public:
  constexpr basic_format_args() : desc_(0), args_(nullptr) {}

  /**
   \rst
   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
   \endrst
   */
  template <typename... Args>
  constexpr FMT_INLINE basic_format_args(
      const format_arg_store<Context, Args...>& store)
      : basic_format_args(format_arg_store<Context, Args...>::desc,
                          store.data_.args()) {}

  /**
   \rst
   Constructs a `basic_format_args` object from
   `~fmt::dynamic_format_arg_store`.
   \endrst
   */
  constexpr FMT_INLINE basic_format_args(
      const dynamic_format_arg_store<Context>& store)
      : basic_format_args(store.get_types(), store.data()) {}

  /**
   \rst
   Constructs a `basic_format_args` object from a dynamic set of arguments.
   \endrst
   */
  constexpr basic_format_args(const format_arg* args, int count)
      : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
                          args) {}

  /** Returns the argument with the specified id. */
  FMT_CONSTEXPR auto get(int id) const -> format_arg {
    format_arg arg;
    if (!is_packed()) {
      if (id < max_size()) arg = args_[id];
      return arg;
    }
    if (id >= detail::max_packed_args) return arg;
    arg.type_ = type(id);
    if (arg.type_ == detail::type::none_type) return arg;
    arg.value_ = values_[id];
    return arg;
  }

  template <typename Char>
  auto get(basic_string_view<Char> name) const -> format_arg {
    int id = get_id(name);
    return id >= 0 ? get(id) : format_arg();
  }

  template <typename Char>
  auto get_id(basic_string_view<Char> name) const -> int {
    if (!has_named_args()) return -1;
    const auto& named_args =
        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
    for (size_t i = 0; i < named_args.size; ++i) {
      if (named_args.data[i].name == name) return named_args.data[i].id;
    }
    return -1;
  }

  auto max_size() const -> int {
    unsigned long long max_packed = detail::max_packed_args;
    return static_cast<int>(is_packed() ? max_packed
                                        : desc_ & ~detail::is_unpacked_bit);
  }
};

/** An alias to ``basic_format_args<format_context>``. */
// A separate type would result in shorter symbols but break ABI compatibility
// between clang and gcc on ARM (#1919).
using format_args = basic_format_args<format_context>;

// We cannot use enum classes as bit fields because of a gcc bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
namespace align {
enum type { none, left, right, center, numeric };
}
using align_t = align::type;
namespace sign {
enum type { none, minus, plus, space };
}
using sign_t = sign::type;

FMT_BEGIN_DETAIL_NAMESPACE

void throw_format_error(const char* message);

// Workaround an array initialization issue in gcc 4.8.
template <typename Char> struct fill_t {
 private:
  enum { max_size = 4 };
  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
  unsigned char size_ = 1;

 public:
  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
    auto size = s.size();
    if (size > max_size) return throw_format_error("invalid fill");
    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
    size_ = static_cast<unsigned char>(size);
  }

  constexpr auto size() const -> size_t { return size_; }
  constexpr auto data() const -> const Char* { return data_; }

  FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; }
  FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& {
    return data_[index];
  }
};
FMT_END_DETAIL_NAMESPACE

// Format specifiers for built-in and string types.
template <typename Char> struct basic_format_specs {
  int width;
  int precision;
  char type;
  align_t align : 4;
  sign_t sign : 3;
  bool alt : 1;  // Alternate form ('#').
  bool localized : 1;
  detail::fill_t<Char> fill;

  constexpr basic_format_specs()
      : width(0),
        precision(-1),
        type(0),
        align(align::none),
        sign(sign::none),
        alt(false),
        localized(false) {}
};

using format_specs = basic_format_specs<char>;

FMT_BEGIN_DETAIL_NAMESPACE

enum class arg_id_kind { none, index, name };

// An argument reference.
template <typename Char> struct arg_ref {
  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}

  FMT_CONSTEXPR explicit arg_ref(int index)
      : kind(arg_id_kind::index), val(index) {}
  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
      : kind(arg_id_kind::name), val(name) {}

  FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& {
    kind = arg_id_kind::index;
    val.index = idx;
    return *this;
  }

  arg_id_kind kind;
  union value {
    FMT_CONSTEXPR value(int id = 0) : index{id} {}
    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}

    int index;
    basic_string_view<Char> name;
  } val;
};

// Format specifiers with width and precision resolved at formatting rather
// than parsing time to allow re-using the same parsed specifiers with
// different sets of arguments (precompilation of format strings).
template <typename Char>
struct dynamic_format_specs : basic_format_specs<Char> {
  arg_ref<Char> width_ref;
  arg_ref<Char> precision_ref;
};

struct auto_id {};

// A format specifier handler that sets fields in basic_format_specs.
template <typename Char> class specs_setter {
 protected:
  basic_format_specs<Char>& specs_;

 public:
  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
      : specs_(specs) {}

  FMT_CONSTEXPR specs_setter(const specs_setter& other)
      : specs_(other.specs_) {}

  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
  FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
    specs_.fill = fill;
  }
  FMT_CONSTEXPR void on_sign(sign_t s) { specs_.sign = s; }
  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
  FMT_CONSTEXPR void on_localized() { specs_.localized = true; }

  FMT_CONSTEXPR void on_zero() {
    if (specs_.align == align::none) specs_.align = align::numeric;
    specs_.fill[0] = Char('0');
  }

  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
  FMT_CONSTEXPR void on_precision(int precision) {
    specs_.precision = precision;
  }
  FMT_CONSTEXPR void end_precision() {}

  FMT_CONSTEXPR void on_type(Char type) {
    specs_.type = static_cast<char>(type);
  }
};

// Format spec handler that saves references to arguments representing dynamic
// width and precision to be resolved at formatting time.
template <typename ParseContext>
class dynamic_specs_handler
    : public specs_setter<typename ParseContext::char_type> {
 public:
  using char_type = typename ParseContext::char_type;

  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
                                      ParseContext& ctx)
      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}

  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
      : specs_setter<char_type>(other),
        specs_(other.specs_),
        context_(other.context_) {}

  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
    specs_.width_ref = make_arg_ref(arg_id);
  }

  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
    specs_.precision_ref = make_arg_ref(arg_id);
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    context_.on_error(message);
  }

 private:
  dynamic_format_specs<char_type>& specs_;
  ParseContext& context_;

  using arg_ref_type = arg_ref<char_type>;

  FMT_CONSTEXPR auto make_arg_ref(int arg_id) -> arg_ref_type {
    context_.check_arg_id(arg_id);
    return arg_ref_type(arg_id);
  }

  FMT_CONSTEXPR auto make_arg_ref(auto_id) -> arg_ref_type {
    return arg_ref_type(context_.next_arg_id());
  }

  FMT_CONSTEXPR auto make_arg_ref(basic_string_view<char_type> arg_id)
      -> arg_ref_type {
    context_.check_arg_id(arg_id);
    basic_string_view<char_type> format_str(
        context_.begin(), to_unsigned(context_.end() - context_.begin()));
    return arg_ref_type(arg_id);
  }
};

template <typename Char> constexpr bool is_ascii_letter(Char c) {
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}

// Converts a character to ASCII. Returns a number > 127 on conversion failure.
template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
constexpr auto to_ascii(Char value) -> Char {
  return value;
}
template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
constexpr auto to_ascii(Char value) ->
    typename std::underlying_type<Char>::type {
  return value;
}

template <typename Char>
FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
  if (const_check(sizeof(Char) != 1)) return 1;
  constexpr char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                              0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 3, 3, 4, 0};
  int len = lengths[static_cast<unsigned char>(*begin) >> 3];

  // Compute the pointer to the next character early so that the next
  // iteration can start working on the next character. Neither Clang
  // nor GCC figure out this reordering on their own.
  return len + !len;
}

// Return the result via the out param to workaround gcc bug 77539.
template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
  for (out = first; out != last; ++out) {
    if (*out == value) return true;
  }
  return false;
}

template <>
inline auto find<false, char>(const char* first, const char* last, char value,
                              const char*& out) -> bool {
  out = static_cast<const char*>(
      std::memchr(first, value, to_unsigned(last - first)));
  return out != nullptr;
}

// Parses the range [begin, end) as an unsigned integer. This function assumes
// that the range is non-empty and the first character is a digit.
template <typename Char>
FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
                                         int error_value) noexcept -> int {
  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
  unsigned value = 0, prev = 0;
  auto p = begin;
  do {
    prev = value;
    value = value * 10 + unsigned(*p - '0');
    ++p;
  } while (p != end && '0' <= *p && *p <= '9');
  auto num_digits = p - begin;
  begin = p;
  if (num_digits <= std::numeric_limits<int>::digits10)
    return static_cast<int>(value);
  // Check for overflow.
  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
                 prev * 10ull + unsigned(p[-1] - '0') <= max
             ? static_cast<int>(value)
             : error_value;
}

// Parses fill and alignment.
template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
                               Handler&& handler) -> const Char* {
  FMT_ASSERT(begin != end, "");
  auto align = align::none;
  auto p = begin + code_point_length(begin);
  if (p >= end) p = begin;
  for (;;) {
    switch (to_ascii(*p)) {
    case '<':
      align = align::left;
      break;
    case '>':
      align = align::right;
      break;
    case '^':
      align = align::center;
      break;
    default:
      break;
    }
    if (align != align::none) {
      if (p != begin) {
        auto c = *begin;
        if (c == '{')
          return handler.on_error("invalid fill character '{'"), begin;
        handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
        begin = p + 1;
      } else
        ++begin;
      handler.on_align(align);
      break;
    } else if (p == begin) {
      break;
    }
    p = begin;
  }
  return begin;
}

template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}

template <typename Char, typename IDHandler>
FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
                                   IDHandler&& handler) -> const Char* {
  FMT_ASSERT(begin != end, "");
  Char c = *begin;
  if (c >= '0' && c <= '9') {
    int index = 0;
    if (c != '0')
      index =
          parse_nonnegative_int(begin, end, (std::numeric_limits<int>::max)());
    else
      ++begin;
    if (begin == end || (*begin != '}' && *begin != ':'))
      handler.on_error("invalid format string");
    else
      handler(index);
    return begin;
  }
  if (!is_name_start(c)) {
    handler.on_error("invalid format string");
    return begin;
  }
  auto it = begin;
  do {
    ++it;
  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
  return it;
}

template <typename Char, typename IDHandler>
FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end,
                                           IDHandler&& handler) -> const Char* {
  Char c = *begin;
  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
  handler();
  return begin;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
                               Handler&& handler) -> const Char* {
  using detail::auto_id;
  struct width_adapter {
    Handler& handler;

    FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
      handler.on_dynamic_width(id);
    }
    FMT_CONSTEXPR void on_error(const char* message) {
      if (message) handler.on_error(message);
    }
  };

  FMT_ASSERT(begin != end, "");
  if ('0' <= *begin && *begin <= '9') {
    int width = parse_nonnegative_int(begin, end, -1);
    if (width != -1)
      handler.on_width(width);
    else
      handler.on_error("number is too big");
  } else if (*begin == '{') {
    ++begin;
    if (begin != end) begin = parse_arg_id(begin, end, width_adapter{handler});
    if (begin == end || *begin != '}')
      return handler.on_error("invalid format string"), begin;
    ++begin;
  }
  return begin;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
                                   Handler&& handler) -> const Char* {
  using detail::auto_id;
  struct precision_adapter {
    Handler& handler;

    FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
      handler.on_dynamic_precision(id);
    }
    FMT_CONSTEXPR void on_error(const char* message) {
      if (message) handler.on_error(message);
    }
  };

  ++begin;
  auto c = begin != end ? *begin : Char();
  if ('0' <= c && c <= '9') {
    auto precision = parse_nonnegative_int(begin, end, -1);
    if (precision != -1)
      handler.on_precision(precision);
    else
      handler.on_error("number is too big");
  } else if (c == '{') {
    ++begin;
    if (begin != end)
      begin = parse_arg_id(begin, end, precision_adapter{handler});
    if (begin == end || *begin++ != '}')
      return handler.on_error("invalid format string"), begin;
  } else {
    return handler.on_error("missing precision specifier"), begin;
  }
  handler.end_precision();
  return begin;
}

// Parses standard format specifiers and sends notifications about parsed
// components to handler.
template <typename Char, typename SpecHandler>
FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(const Char* begin,
                                                 const Char* end,
                                                 SpecHandler&& handler)
    -> const Char* {
  if (begin + 1 < end && begin[1] == '}' && is_ascii_letter(*begin) &&
      *begin != 'L') {
    handler.on_type(*begin++);
    return begin;
  }

  if (begin == end) return begin;

  begin = parse_align(begin, end, handler);
  if (begin == end) return begin;

  // Parse sign.
  switch (to_ascii(*begin)) {
  case '+':
    handler.on_sign(sign::plus);
    ++begin;
    break;
  case '-':
    handler.on_sign(sign::minus);
    ++begin;
    break;
  case ' ':
    handler.on_sign(sign::space);
    ++begin;
    break;
  default:
    break;
  }
  if (begin == end) return begin;

  if (*begin == '#') {
    handler.on_hash();
    if (++begin == end) return begin;
  }

  // Parse zero flag.
  if (*begin == '0') {
    handler.on_zero();
    if (++begin == end) return begin;
  }

  begin = parse_width(begin, end, handler);
  if (begin == end) return begin;

  // Parse precision.
  if (*begin == '.') {
    begin = parse_precision(begin, end, handler);
    if (begin == end) return begin;
  }

  if (*begin == 'L') {
    handler.on_localized();
    ++begin;
  }

  // Parse type.
  if (begin != end && *begin != '}') handler.on_type(*begin++);
  return begin;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
                                           Handler&& handler) -> const Char* {
  struct id_adapter {
    Handler& handler;
    int arg_id;

    FMT_CONSTEXPR void operator()() { arg_id = handler.on_arg_id(); }
    FMT_CONSTEXPR void operator()(int id) { arg_id = handler.on_arg_id(id); }
    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
      arg_id = handler.on_arg_id(id);
    }
    FMT_CONSTEXPR void on_error(const char* message) {
      if (message) handler.on_error(message);
    }
  };

  ++begin;
  if (begin == end) return handler.on_error("invalid format string"), end;
  if (*begin == '}') {
    handler.on_replacement_field(handler.on_arg_id(), begin);
  } else if (*begin == '{') {
    handler.on_text(begin, begin + 1);
  } else {
    auto adapter = id_adapter{handler, 0};
    begin = parse_arg_id(begin, end, adapter);
    Char c = begin != end ? *begin : Char();
    if (c == '}') {
      handler.on_replacement_field(adapter.arg_id, begin);
    } else if (c == ':') {
      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
      if (begin == end || *begin != '}')
        return handler.on_error("unknown format specifier"), end;
    } else {
      return handler.on_error("missing '}' in format string"), end;
    }
  }
  return begin + 1;
}

template <bool IS_CONSTEXPR, typename Char, typename Handler>
FMT_CONSTEXPR FMT_INLINE void parse_format_string(
    basic_string_view<Char> format_str, Handler&& handler) {
  // this is most likely a name-lookup defect in msvc's modules implementation
  using detail::find;

  auto begin = format_str.data();
  auto end = begin + format_str.size();
  if (end - begin < 32) {
    // Use a simple loop instead of memchr for small strings.
    const Char* p = begin;
    while (p != end) {
      auto c = *p++;
      if (c == '{') {
        handler.on_text(begin, p - 1);
        begin = p = parse_replacement_field(p - 1, end, handler);
      } else if (c == '}') {
        if (p == end || *p != '}')
          return handler.on_error("unmatched '}' in format string");
        handler.on_text(begin, p);
        begin = ++p;
      }
    }
    handler.on_text(begin, end);
    return;
  }
  struct writer {
    FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
      if (pbegin == pend) return;
      for (;;) {
        const Char* p = nullptr;
        if (!find<IS_CONSTEXPR>(pbegin, pend, Char('}'), p))
          return handler_.on_text(pbegin, pend);
        ++p;
        if (p == pend || *p != '}')
          return handler_.on_error("unmatched '}' in format string");
        handler_.on_text(pbegin, p);
        pbegin = p + 1;
      }
    }
    Handler& handler_;
  } write{handler};
  while (begin != end) {
    // Doing two passes with memchr (one for '{' and another for '}') is up to
    // 2.5x faster than the naive one-pass implementation on big format strings.
    const Char* p = begin;
    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
      return write(begin, end);
    write(begin, p);
    begin = parse_replacement_field(p, end, handler);
  }
}

template <typename T, typename ParseContext>
FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
    -> decltype(ctx.begin()) {
  using char_type = typename ParseContext::char_type;
  using context = buffer_context<char_type>;
  using mapped_type = conditional_t<
      mapped_type_constant<T, context>::value != type::custom_type,
      decltype(arg_mapper<context>().map(std::declval<const T&>())), T>;
  auto f = conditional_t<has_formatter<mapped_type, context>::value,
                         formatter<mapped_type, char_type>,
                         fallback_formatter<T, char_type>>();
  return f.parse(ctx);
}

// A parse context with extra argument id checks. It is only used at compile
// time because adding checks at runtime would introduce substantial overhead
// and would be redundant since argument ids are checked when arguments are
// retrieved anyway.
template <typename Char, typename ErrorHandler = error_handler>
class compile_parse_context
    : public basic_format_parse_context<Char, ErrorHandler> {
 private:
  int num_args_;
  using base = basic_format_parse_context<Char, ErrorHandler>;

 public:
  explicit FMT_CONSTEXPR compile_parse_context(
      basic_string_view<Char> format_str,
      int num_args = (std::numeric_limits<int>::max)(), ErrorHandler eh = {})
      : base(format_str, eh), num_args_(num_args) {}

  FMT_CONSTEXPR auto next_arg_id() -> int {
    int id = base::next_arg_id();
    if (id >= num_args_) this->on_error("argument not found");
    return id;
  }

  FMT_CONSTEXPR void check_arg_id(int id) {
    base::check_arg_id(id);
    if (id >= num_args_) this->on_error("argument not found");
  }
  using base::check_arg_id;
};

template <typename ErrorHandler>
FMT_CONSTEXPR void check_int_type_spec(char spec, ErrorHandler&& eh) {
  switch (spec) {
  case 0:
  case 'd':
  case 'x':
  case 'X':
  case 'b':
  case 'B':
  case 'o':
  case 'c':
    break;
  default:
    eh.on_error("invalid type specifier");
    break;
  }
}

// Checks char specs and returns true if the type spec is char (and not int).
template <typename Char, typename ErrorHandler = error_handler>
FMT_CONSTEXPR auto check_char_specs(const basic_format_specs<Char>& specs,
                                    ErrorHandler&& eh = {}) -> bool {
  if (specs.type && specs.type != 'c') {
    check_int_type_spec(specs.type, eh);
    return false;
  }
  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
    eh.on_error("invalid format specifier for char");
  return true;
}

// A floating-point presentation format.
enum class float_format : unsigned char {
  general,  // General: exponent notation or fixed point based on magnitude.
  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
  hex
};

struct float_specs {
  int precision;
  float_format format : 8;
  sign_t sign : 8;
  bool upper : 1;
  bool locale : 1;
  bool binary32 : 1;
  bool use_grisu : 1;
  bool showpoint : 1;
};

template <typename ErrorHandler = error_handler, typename Char>
FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
                                         ErrorHandler&& eh = {})
    -> float_specs {
  auto result = float_specs();
  result.showpoint = specs.alt;
  result.locale = specs.localized;
  switch (specs.type) {
  case 0:
    result.format = float_format::general;
    break;
  case 'G':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'g':
    result.format = float_format::general;
    break;
  case 'E':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'e':
    result.format = float_format::exp;
    result.showpoint |= specs.precision != 0;
    break;
  case 'F':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'f':
    result.format = float_format::fixed;
    result.showpoint |= specs.precision != 0;
    break;
  case 'A':
    result.upper = true;
    FMT_FALLTHROUGH;
  case 'a':
    result.format = float_format::hex;
    break;
  default:
    eh.on_error("invalid type specifier");
    break;
  }
  return result;
}

template <typename Char, typename ErrorHandler = error_handler>
FMT_CONSTEXPR auto check_cstring_type_spec(Char spec, ErrorHandler&& eh = {})
    -> bool {
  if (spec == 0 || spec == 's') return true;
  if (spec != 'p') eh.on_error("invalid type specifier");
  return false;
}

template <typename Char, typename ErrorHandler = error_handler>
FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh = {}) {
  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
}

template <typename Char, typename ErrorHandler>
FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
}

// A parse_format_specs handler that checks if specifiers are consistent with
// the argument type.
template <typename Handler> class specs_checker : public Handler {
 private:
  detail::type arg_type_;

  FMT_CONSTEXPR void require_numeric_argument() {
    if (!is_arithmetic_type(arg_type_))
      this->on_error("format specifier requires numeric argument");
  }

 public:
  FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type)
      : Handler(handler), arg_type_(arg_type) {}

  FMT_CONSTEXPR void on_align(align_t align) {
    if (align == align::numeric) require_numeric_argument();
    Handler::on_align(align);
  }

  FMT_CONSTEXPR void on_sign(sign_t s) {
    require_numeric_argument();
    if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
      this->on_error("format specifier requires signed argument");
    }
    Handler::on_sign(s);
  }

  FMT_CONSTEXPR void on_hash() {
    require_numeric_argument();
    Handler::on_hash();
  }

  FMT_CONSTEXPR void on_localized() {
    require_numeric_argument();
    Handler::on_localized();
  }

  FMT_CONSTEXPR void on_zero() {
    require_numeric_argument();
    Handler::on_zero();
  }

  FMT_CONSTEXPR void end_precision() {
    if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
      this->on_error("precision not allowed for this argument type");
  }
};

constexpr int invalid_arg_index = -1;

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
template <int N, typename T, typename... Args, typename Char>
constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
  if constexpr (detail::is_statically_named_arg<T>()) {
    if (name == T::name) return N;
  }
  if constexpr (sizeof...(Args) > 0) {
    return get_arg_index_by_name<N + 1, Args...>(name);
  } else {
    (void)name;  // Workaround an MSVC bug about "unused" parameter.
    return invalid_arg_index;
  }
}
#endif

template <typename... Args, typename Char>
FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
  if constexpr (sizeof...(Args) > 0) {
    return get_arg_index_by_name<0, Args...>(name);
  } else {
    (void)name;
    return invalid_arg_index;
  }
#else
  (void)name;
  return invalid_arg_index;
#endif
}

template <typename Char, typename ErrorHandler, typename... Args>
class format_string_checker {
 private:
  using parse_context_type = compile_parse_context<Char, ErrorHandler>;
  enum { num_args = sizeof...(Args) };

  // Format specifier parsing function.
  using parse_func = const Char* (*)(parse_context_type&);

  parse_context_type context_;
  parse_func parse_funcs_[num_args > 0 ? num_args : 1];

 public:
  explicit FMT_CONSTEXPR format_string_checker(
      basic_string_view<Char> format_str, ErrorHandler eh)
      : context_(format_str, num_args, eh),
        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}

  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}

  FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
    return context_.check_arg_id(id), id;
  }
  FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
    auto index = get_arg_index_by_name<Args...>(id);
    if (index == invalid_arg_index) on_error("named argument is not found");
    return context_.check_arg_id(index), index;
#else
    (void)id;
    on_error("compile-time checks for named arguments require C++20 support");
    return 0;
#endif
  }

  FMT_CONSTEXPR void on_replacement_field(int, const Char*) {}

  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
      -> const Char* {
    context_.advance_to(context_.begin() + (begin - &*context_.begin()));
    // id >= 0 check is a workaround for gcc 10 bug (#2065).
    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
  }

  FMT_CONSTEXPR void on_error(const char* message) {
    context_.on_error(message);
  }
};

template <typename... Args, typename S,
          enable_if_t<(is_compile_string<S>::value), int>>
void check_format_string(S format_str) {
  FMT_CONSTEXPR auto s = to_string_view(format_str);
  using checker = format_string_checker<typename S::char_type, error_handler,
                                        remove_cvref_t<Args>...>;
  FMT_CONSTEXPR bool invalid_format =
      (parse_format_string<true>(s, checker(s, {})), true);
  ignore_unused(invalid_format);
}

template <typename Char>
void vformat_to(
    buffer<Char>& buf, basic_string_view<Char> fmt,
    basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args,
    locale_ref loc = {});

FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
#ifndef _WIN32
inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
#endif
FMT_END_DETAIL_NAMESPACE

// A formatter specialization for the core types corresponding to detail::type
// constants.
template <typename T, typename Char>
struct formatter<T, Char,
                 enable_if_t<detail::type_constant<T, Char>::value !=
                             detail::type::custom_type>> {
 private:
  detail::dynamic_format_specs<Char> specs_;

 public:
  // Parses format specifiers stopping either at the end of the range or at the
  // terminating '}'.
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto begin = ctx.begin(), end = ctx.end();
    if (begin == end) return begin;
    using handler_type = detail::dynamic_specs_handler<ParseContext>;
    auto type = detail::type_constant<T, Char>::value;
    auto checker =
        detail::specs_checker<handler_type>(handler_type(specs_, ctx), type);
    auto it = detail::parse_format_specs(begin, end, checker);
    auto eh = ctx.error_handler();
    switch (type) {
    case detail::type::none_type:
      FMT_ASSERT(false, "invalid argument type");
      break;
    case detail::type::bool_type:
      if (!specs_.type || specs_.type == 's') break;
      FMT_FALLTHROUGH;
    case detail::type::int_type:
    case detail::type::uint_type:
    case detail::type::long_long_type:
    case detail::type::ulong_long_type:
    case detail::type::int128_type:
    case detail::type::uint128_type:
      detail::check_int_type_spec(specs_.type, eh);
      break;
    case detail::type::char_type:
      detail::check_char_specs(specs_, eh);
      break;
    case detail::type::float_type:
      if (detail::const_check(FMT_USE_FLOAT))
        detail::parse_float_type_spec(specs_, eh);
      else
        FMT_ASSERT(false, "float support disabled");
      break;
    case detail::type::double_type:
      if (detail::const_check(FMT_USE_DOUBLE))
        detail::parse_float_type_spec(specs_, eh);
      else
        FMT_ASSERT(false, "double support disabled");
      break;
    case detail::type::long_double_type:
      if (detail::const_check(FMT_USE_LONG_DOUBLE))
        detail::parse_float_type_spec(specs_, eh);
      else
        FMT_ASSERT(false, "long double support disabled");
      break;
    case detail::type::cstring_type:
      detail::check_cstring_type_spec(specs_.type, eh);
      break;
    case detail::type::string_type:
      detail::check_string_type_spec(specs_.type, eh);
      break;
    case detail::type::pointer_type:
      detail::check_pointer_type_spec(specs_.type, eh);
      break;
    case detail::type::custom_type:
      // Custom format specifiers are checked in parse functions of
      // formatter specializations.
      break;
    }
    return it;
  }

  template <typename FormatContext>
  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
      -> decltype(ctx.out());
};

template <typename Char> struct basic_runtime { basic_string_view<Char> str; };

template <typename Char, typename... Args> class basic_format_string {
 private:
  basic_string_view<Char> str_;

 public:
  template <typename S,
            FMT_ENABLE_IF(
                std::is_convertible<const S&, basic_string_view<Char>>::value)>
  FMT_CONSTEVAL basic_format_string(const S& s) : str_(s) {
    static_assert(
        detail::count<
            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
             std::is_reference<Args>::value)...>() == 0,
        "passing views as lvalues is disallowed");
#ifdef FMT_HAS_CONSTEVAL
    if constexpr (detail::count_named_args<Args...>() == 0) {
      using checker = detail::format_string_checker<Char, detail::error_handler,
                                                    remove_cvref_t<Args>...>;
      detail::parse_format_string<true>(str_, checker(s, {}));
    }
#else
    detail::check_format_string<Args...>(s);
#endif
  }
  basic_format_string(basic_runtime<Char> r) : str_(r.str) {}

  FMT_INLINE operator basic_string_view<Char>() const { return str_; }
};

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
// Workaround broken conversion on older gcc.
template <typename... Args> using format_string = string_view;
template <typename S> auto runtime(const S& s) -> basic_string_view<char_t<S>> {
  return s;
}
#else
template <typename... Args>
using format_string = basic_format_string<char, type_identity_t<Args>...>;
// Creates a runtime format string.
template <typename S> auto runtime(const S& s) -> basic_runtime<char_t<S>> {
  return {{s}};
}
#endif

FMT_API auto vformat(string_view fmt, format_args args) -> std::string;

/**
  \rst
  Formats ``args`` according to specifications in ``fmt`` and returns the result
  as a string.

  **Example**::

    #include <fmt/core.h>
    std::string message = fmt::format("The answer is {}", 42);
  \endrst
*/
template <typename... T>
FMT_INLINE auto format(format_string<T...> fmt, T&&... args) -> std::string {
  return vformat(fmt, fmt::make_format_args(args...));
}

/** Formats a string and writes the output to ``out``. */
template <typename OutputIt,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
  using detail::get_buffer;
  auto&& buf = get_buffer<char>(out);
  detail::vformat_to(buf, string_view(fmt), args, {});
  return detail::get_iterator(buf);
}

/**
 \rst
 Formats ``args`` according to specifications in ``fmt``, writes the result to
 the output iterator ``out`` and returns the iterator past the end of the output
 range.

 **Example**::

   auto out = std::vector<char>();
   fmt::format_to(std::back_inserter(out), "{}", 42);
 \endrst
 */
template <typename OutputIt, typename... T,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
    -> OutputIt {
  return vformat_to(out, fmt, fmt::make_format_args(args...));
}

template <typename OutputIt> struct format_to_n_result {
  /** Iterator past the end of the output range. */
  OutputIt out;
  /** Total (not truncated) output size. */
  size_t size;
};

template <typename OutputIt, typename... T,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
    -> format_to_n_result<OutputIt> {
  using buffer =
      detail::iterator_buffer<OutputIt, char, detail::fixed_buffer_traits>;
  auto buf = buffer(out, n);
  detail::vformat_to(buf, fmt, args, {});
  return {buf.out(), buf.count()};
}

/**
  \rst
  Formats ``args`` according to specifications in ``fmt``, writes up to ``n``
  characters of the result to the output iterator ``out`` and returns the total
  (not truncated) output size and the iterator past the end of the output range.
  \endrst
 */
template <typename OutputIt, typename... T,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
                            const T&... args) -> format_to_n_result<OutputIt> {
  return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
}

/** Returns the number of chars in the output of ``format(fmt, args...)``. */
template <typename... T>
FMT_INLINE auto formatted_size(format_string<T...> fmt, T&&... args) -> size_t {
  auto buf = detail::counting_buffer<>();
  detail::vformat_to(buf, string_view(fmt), fmt::make_format_args(args...), {});
  return buf.count();
}

FMT_API void vprint(string_view fmt, format_args args);
FMT_API void vprint(std::FILE* f, string_view fmt, format_args args);

/**
  \rst
  Formats ``args`` according to specifications in ``fmt`` and writes the output
  to ``stdout``.

  **Example**::

    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
  \endrst
 */
template <typename... T>
FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
  const auto& vargs = fmt::make_format_args(args...);
  return detail::is_utf8() ? vprint(fmt, vargs)
                           : detail::vprint_mojibake(stdout, fmt, vargs);
}

/**
  \rst
  Formats ``args`` according to specifications in ``fmt`` and writes the
  output to the file ``f``.

  **Example**::

    fmt::print(stderr, "Don't {}!", "panic");
  \endrst
 */
template <typename... T>
FMT_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
  const auto& vargs = fmt::make_format_args(args...);
  return detail::is_utf8() ? vprint(f, fmt, vargs)
                           : detail::vprint_mojibake(f, fmt, vargs);
}

FMT_MODULE_EXPORT_END
FMT_GCC_PRAGMA("GCC pop_options")
FMT_END_NAMESPACE

#ifdef FMT_HEADER_ONLY
#  include "format.h"
#endif
#endif  // FMT_CORE_H_


================================================
FILE: examples/libraries/fmt/include/fmt/format-inl.h
================================================
// Formatting library for C++ - implementation
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_

#include <algorithm>
#include <cctype>
#include <cerrno>  // errno
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstring>  // std::memmove
#include <cwchar>
#include <exception>

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
#  include <locale>
#endif

#ifdef _WIN32
#  include <io.h>  // _isatty
#endif

#include "format.h"

FMT_BEGIN_NAMESPACE
namespace detail {

FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
  // Use unchecked std::fprintf to avoid triggering another assertion when
  // writing to stderr fails
  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
  // code pass.
  std::terminate();
}

#ifndef _MSC_VER
#  define FMT_SNPRINTF snprintf
#else  // _MSC_VER
inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
  va_end(args);
  return result;
}
#  define FMT_SNPRINTF fmt_snprintf
#endif  // _MSC_VER

FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
                                string_view message) FMT_NOEXCEPT {
  // Report error code making sure that the output fits into
  // inline_buffer_size to avoid dynamic memory allocation and potential
  // bad_alloc.
  out.try_resize(0);
  static const char SEP[] = ": ";
  static const char ERROR_STR[] = "error ";
  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
  if (detail::is_negative(error_code)) {
    abs_value = 0 - abs_value;
    ++error_code_size;
  }
  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
  auto it = buffer_appender<char>(out);
  if (message.size() <= inline_buffer_size - error_code_size)
    format_to(it, FMT_STRING("{}{}"), message, SEP);
  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
  FMT_ASSERT(out.size() <= inline_buffer_size, "");
}

FMT_FUNC void report_error(format_func func, int error_code,
                           const char* message) FMT_NOEXCEPT {
  memory_buffer full_message;
  func(full_message, error_code, message);
  // Don't use fwrite_fully because the latter may throw.
  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
    std::fputc('\n', stderr);
}

// A wrapper around fwrite that throws on error.
inline void fwrite_fully(const void* ptr, size_t size, size_t count,
                         FILE* stream) {
  size_t written = std::fwrite(ptr, size, count, stream);
  if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
}

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template <typename Locale>
locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
  static_assert(std::is_same<Locale, std::locale>::value, "");
}

template <typename Locale> Locale locale_ref::get() const {
  static_assert(std::is_same<Locale, std::locale>::value, "");
  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
}

template <typename Char>
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
  auto grouping = facet.grouping();
  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
  return {std::move(grouping), thousands_sep};
}
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
      .decimal_point();
}
#else
template <typename Char>
FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
}
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
  return '.';
}
#endif
}  // namespace detail

#if !FMT_MSC_VER
FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
#endif

FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
                                         format_args args) {
  auto ec = std::error_code(error_code, std::generic_category());
  return std::system_error(ec, vformat(format_str, args));
}

namespace detail {

template <> FMT_FUNC int count_digits<4>(detail::fallback_uintptr n) {
  // fallback_uintptr is always stored in little endian.
  int i = static_cast<int>(sizeof(void*)) - 1;
  while (i > 0 && n.value[i] == 0) --i;
  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
}

#if __cplusplus < 201703L
template <typename T> constexpr const char basic_data<T>::digits[][2];
template <typename T> constexpr const char basic_data<T>::hex_digits[];
template <typename T> constexpr const char basic_data<T>::signs[];
template <typename T> constexpr const unsigned basic_data<T>::prefixes[];
template <typename T> constexpr const char basic_data<T>::left_padding_shifts[];
template <typename T>
constexpr const char basic_data<T>::right_padding_shifts[];
#endif

template <typename T> struct bits {
  static FMT_CONSTEXPR_DECL const int value =
      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
};

class fp;
template <int SHIFT = 0> fp normalize(fp value);

// Lower (upper) boundary is a value half way between a floating-point value
// and its predecessor (successor). Boundaries have the same exponent as the
// value so only significands are stored.
struct boundaries {
  uint64_t lower;
  uint64_t upper;
};

// A handmade floating-point number f * pow(2, e).
class fp {
 private:
  using significand_type = uint64_t;

  template <typename Float>
  using is_supported_float = bool_constant<sizeof(Float) == sizeof(uint64_t) ||
                                           sizeof(Float) == sizeof(uint32_t)>;

 public:
  significand_type f;
  int e;

  // All sizes are in bits.
  // Subtract 1 to account for an implicit most significant bit in the
  // normalized form.
  static FMT_CONSTEXPR_DECL const int double_significand_size =
      std::numeric_limits<double>::digits - 1;
  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
      1ULL << double_significand_size;
  static FMT_CONSTEXPR_DECL const int significand_size =
      bits<significand_type>::value;

  fp() : f(0), e(0) {}
  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}

  // Constructs fp from an IEEE754 double. It is a template to prevent compile
  // errors on platforms where double is not IEEE754.
  template <typename Double> explicit fp(Double d) { assign(d); }

  // Assigns d to this and return true iff predecessor is closer than successor.
  template <typename Float, FMT_ENABLE_IF(is_supported_float<Float>::value)>
  bool assign(Float d) {
    // Assume float is in the format [sign][exponent][significand].
    using limits = std::numeric_limits<Float>;
    const int float_significand_size = limits::digits - 1;
    const int exponent_size =
        bits<Float>::value - float_significand_size - 1;  // -1 for sign
    const uint64_t float_implicit_bit = 1ULL << float_significand_size;
    const uint64_t significand_mask = float_implicit_bit - 1;
    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
    constexpr bool is_double = sizeof(Float) == sizeof(uint64_t);
    auto u = bit_cast<conditional_t<is_double, uint64_t, uint32_t>>(d);
    f = u & significand_mask;
    int biased_e =
        static_cast<int>((u & exponent_mask) >> float_significand_size);
    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
    // the smallest normalized number (biased_e > 1).
    bool is_predecessor_closer = f == 0 && biased_e > 1;
    if (biased_e != 0)
      f += float_implicit_bit;
    else
      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
    e = biased_e - exponent_bias - float_significand_size;
    return is_predecessor_closer;
  }

  template <typename Float, FMT_ENABLE_IF(!is_supported_float<Float>::value)>
  bool assign(Float) {
    *this = fp();
    return false;
  }
};

// Normalizes the value converted from double and multiplied by (1 << SHIFT).
template <int SHIFT> fp normalize(fp value) {
  // Handle subnormals.
  const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
  while ((value.f & shifted_implicit_bit) == 0) {
    value.f <<= 1;
    --value.e;
  }
  // Subtract 1 to account for hidden bit.
  const auto offset =
      fp::significand_size - fp::double_significand_size - SHIFT - 1;
  value.f <<= offset;
  value.e -= offset;
  return value;
}

inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }

// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
#if FMT_USE_INT128
  auto product = static_cast<__uint128_t>(lhs) * rhs;
  auto f = static_cast<uint64_t>(product >> 64);
  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
#else
  // Multiply 32-bit parts of significands.
  uint64_t mask = (1ULL << 32) - 1;
  uint64_t a = lhs >> 32, b = lhs & mask;
  uint64_t c = rhs >> 32, d = rhs & mask;
  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
  // Compute mid 64-bit of result and round.
  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
#endif
}

inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }

// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
  // These are generated by support/compute-powers.py.
  static constexpr const uint64_t pow10_significands[] = {
      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
      0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
      0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
      0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
      0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
      0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
      0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
      0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
      0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
      0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
      0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
      0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
      0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
      0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
      0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
      0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
      0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
      0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
      0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
      0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
      0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
      0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
  };

  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
  // to significands above.
  static constexpr const int16_t pow10_exponents[] = {
      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
      -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
      -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
      -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
      -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
      242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
      534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
      827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};

  const int shift = 32;
  const auto significand = static_cast<int64_t>(data::log10_2_significand);
  int index = static_cast<int>(
      ((min_exponent + fp::significand_size - 1) * (significand >> shift) +
       ((int64_t(1) << shift) - 1))  // ceil
      >> 32                          // arithmetic shift
  );
  // Decimal exponent of the first (smallest) cached power of 10.
  const int first_dec_exp = -348;
  // Difference between 2 consecutive decimal exponents in cached powers of 10.
  const int dec_exp_step = 8;
  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
  pow10_exponent = first_dec_exp + index * dec_exp_step;
  return {pow10_significands[index], pow10_exponents[index]};
}

// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
// is not available.
struct accumulator {
  uint64_t lower;
  uint64_t upper;

  accumulator() : lower(0), upper(0) {}
  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }

  void operator+=(uint64_t n) {
    lower += n;
    if (lower < n) ++upper;
  }
  void operator>>=(int shift) {
    FMT_ASSERT(shift == 32, "");
    (void)shift;
    lower = (upper << 32) | (lower >> 32);
    upper >>= 32;
  }
};

class bigint {
 private:
  // A bigint is stored as an array of bigits (big digits), with bigit at index
  // 0 being the least significant one.
  using bigit = uint32_t;
  using double_bigit = uint64_t;
  enum { bigits_capacity = 32 };
  basic_memory_buffer<bigit, bigits_capacity> bigits_;
  int exp_;

  bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
  bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }

  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;

  friend struct formatter<bigint>;

  void subtract_bigits(int index, bigit other, bigit& borrow) {
    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
    (*this)[index] = static_cast<bigit>(result);
    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
  }

  void remove_leading_zeros() {
    int num_bigits = static_cast<int>(bigits_.size()) - 1;
    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
    bigits_.resize(to_unsigned(num_bigits + 1));
  }

  // Computes *this -= other assuming aligned bigints and *this >= other.
  void subtract_aligned(const bigint& other) {
    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
    FMT_ASSERT(compare(*this, other) >= 0, "");
    bigit borrow = 0;
    int i = other.exp_ - exp_;
    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
      subtract_bigits(i, other.bigits_[j], borrow);
    while (borrow > 0) subtract_bigits(i, 0, borrow);
    remove_leading_zeros();
  }

  void multiply(uint32_t value) {
    const double_bigit wide_value = value;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      double_bigit result = bigits_[i] * wide_value + carry;
      bigits_[i] = static_cast<bigit>(result);
      carry = static_cast<bigit>(result >> bigit_bits);
    }
    if (carry != 0) bigits_.push_back(carry);
  }

  void multiply(uint64_t value) {
    const bigit mask = ~bigit(0);
    const double_bigit lower = value & mask;
    const double_bigit upper = value >> bigit_bits;
    double_bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      double_bigit result = bigits_[i] * lower + (carry & mask);
      carry =
          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
      bigits_[i] = static_cast<bigit>(result);
    }
    while (carry != 0) {
      bigits_.push_back(carry & mask);
      carry >>= bigit_bits;
    }
  }

 public:
  bigint() : exp_(0) {}
  explicit bigint(uint64_t n) { assign(n); }
  ~bigint() { FMT_ASSERT(bigits_.capacity() <= bigits_capacity, ""); }

  bigint(const bigint&) = delete;
  void operator=(const bigint&) = delete;

  void assign(const bigint& other) {
    auto size = other.bigits_.size();
    bigits_.resize(size);
    auto data = other.bigits_.data();
    std::copy(data, data + size, make_checked(bigits_.data(), size));
    exp_ = other.exp_;
  }

  void assign(uint64_t n) {
    size_t num_bigits = 0;
    do {
      bigits_[num_bigits++] = n & ~bigit(0);
      n >>= bigit_bits;
    } while (n != 0);
    bigits_.resize(num_bigits);
    exp_ = 0;
  }

  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }

  FMT_NOINLINE bigint& operator<<=(int shift) {
    FMT_ASSERT(shift >= 0, "");
    exp_ += shift / bigit_bits;
    shift %= bigit_bits;
    if (shift == 0) return *this;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      bigit c = bigits_[i] >> (bigit_bits - shift);
      bigits_[i] = (bigits_[i] << shift) + carry;
      carry = c;
    }
    if (carry != 0) bigits_.push_back(carry);
    return *this;
  }

  template <typename Int> bigint& operator*=(Int value) {
    FMT_ASSERT(value > 0, "");
    multiply(uint32_or_64_or_128_t<Int>(value));
    return *this;
  }

  friend int compare(const bigint& lhs, const bigint& rhs) {
    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
    if (num_lhs_bigits != num_rhs_bigits)
      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
    int i = static_cast<int>(lhs.bigits_.size()) - 1;
    int j = static_cast<int>(rhs.bigits_.size()) - 1;
    int end = i - j;
    if (end < 0) end = 0;
    for (; i >= end; --i, --j) {
      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
    }
    if (i != j) return i > j ? 1 : -1;
    return 0;
  }

  // Returns compare(lhs1 + lhs2, rhs).
  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
                         const bigint& rhs) {
    int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
    int num_rhs_bigits = rhs.num_bigits();
    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
    if (max_lhs_bigits > num_rhs_bigits) return 1;
    auto get_bigit = [](const bigint& n, int i) -> bigit {
      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
    };
    double_bigit borrow = 0;
    int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
      double_bigit sum =
          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
      bigit rhs_bigit = get_bigit(rhs, i);
      if (sum > rhs_bigit + borrow) return 1;
      borrow = rhs_bigit + borrow - sum;
      if (borrow > 1) return -1;
      borrow <<= bigit_bits;
    }
    return borrow != 0 ? -1 : 0;
  }

  // Assigns pow(10, exp) to this bigint.
  void assign_pow10(int exp) {
    FMT_ASSERT(exp >= 0, "");
    if (exp == 0) return assign(1);
    // Find the top bit.
    int bitmask = 1;
    while (exp >= bitmask) bitmask <<= 1;
    bitmask >>= 1;
    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
    // repeated squaring and multiplication.
    assign(5);
    bitmask >>= 1;
    while (bitmask != 0) {
      square();
      if ((exp & bitmask) != 0) *this *= 5;
      bitmask >>= 1;
    }
    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
  }

  void square() {
    int num_bigits = static_cast<int>(bigits_.size());
    int num_result_bigits = 2 * num_bigits;
    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
    bigits_.resize(to_unsigned(num_result_bigits));
    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
    auto sum = accumulator_t();
    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
      // Compute bigit at position bigit_index of the result by adding
      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
        // Most terms are multiplied twice which can be optimized in the future.
        sum += static_cast<double_bigit>(n[i]) * n[j];
      }
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= bits<bigit>::value;  // Compute the carry.
    }
    // Do the same for the top half.
    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
         ++bigit_index) {
      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
        sum += static_cast<double_bigit>(n[i++]) * n[j--];
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= bits<bigit>::value;
    }
    remove_leading_zeros();
    exp_ *= 2;
  }

  // If this bigint has a bigger exponent than other, adds trailing zero to make
  // exponents equal. This simplifies some operations such as subtraction.
  void align(const bigint& other) {
    int exp_difference = exp_ - other.exp_;
    if (exp_difference <= 0) return;
    int num_bigits = static_cast<int>(bigits_.size());
    bigits_.resize(to_unsigned(num_bigits + exp_difference));
    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
      bigits_[j] = bigits_[i];
    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
    exp_ -= exp_difference;
  }

  // Divides this bignum by divisor, assigning the remainder to this and
  // returning the quotient.
  int divmod_assign(const bigint& divisor) {
    FMT_ASSERT(this != &divisor, "");
    if (compare(*this, divisor) < 0) return 0;
    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
    align(divisor);
    int quotient = 0;
    do {
      subtract_aligned(divisor);
      ++quotient;
    } while (compare(*this, divisor) >= 0);
    return quotient;
  }
};

enum class round_direction { unknown, up, down };

// Given the divisor (normally a power of 10), the remainder = v % divisor for
// some number v and the error, returns whether v should be rounded up, down, or
// whether the rounding direction can't be determined due to error.
// error should be less than divisor / 2.
inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
                                           uint64_t error) {
  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
  // Round down if (remainder + error) * 2 <= divisor.
  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
    return round_direction::down;
  // Round up if (remainder - error) * 2 >= divisor.
  if (remainder >= error &&
      remainder - error >= divisor - (remainder - error)) {
    return round_direction::up;
  }
  return round_direction::unknown;
}

namespace digits {
enum result {
  more,  // Generate more digits.
  done,  // Done generating digits.
  error  // Digit generation cancelled due to an error.
};
}

inline uint64_t power_of_10_64(int exp) {
  static constexpr const uint64_t data[] = {1, FMT_POWERS_OF_10(1),
                                            FMT_POWERS_OF_10(1000000000ULL),
                                            10000000000000000000ULL};
  return data[exp];
}

// Generates output using the Grisu digit-gen algorithm.
// error: the size of the region (lower, upper) outside of which numbers
// definitely do not round to value (Delta in Grisu3).
template <typename Handler>
FMT_INLINE digits::result grisu_gen_digits(fp value, uint64_t error, int& exp,
                                           Handler& handler) {
  const fp one(1ULL << -value.e, value.e);
  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
  // zero because it contains a product of two 64-bit numbers with MSB set (due
  // to normalization) - 1, shifted right by at most 60 bits.
  auto integral = static_cast<uint32_t>(value.f >> -one.e);
  FMT_ASSERT(integral != 0, "");
  FMT_ASSERT(integral == value.f >> -one.e, "");
  // The fractional part of scaled value (p2 in Grisu) c = value % one.
  uint64_t fractional = value.f & (one.f - 1);
  exp = count_digits(integral);  // kappa in Grisu.
  // Divide by 10 to prevent overflow.
  auto result = handler.on_start(power_of_10_64(exp - 1) << -one.e,
                                 value.f / 10, error * 10, exp);
  if (result != digits::more) return result;
  // Generate digits for the integral part. This can produce up to 10 digits.
  do {
    uint32_t digit = 0;
    auto divmod_integral = [&](uint32_t divisor) {
      digit = integral / divisor;
      integral %= divisor;
    };
    // This optimization by Milo Yip reduces the number of integer divisions by
    // one per iteration.
    switch (exp) {
    case 10:
      divmod_integral(1000000000);
      break;
    case 9:
      divmod_integral(100000000);
      break;
    case 8:
      divmod_integral(10000000);
      break;
    case 7:
      divmod_integral(1000000);
      break;
    case 6:
      divmod_integral(100000);
      break;
    case 5:
      divmod_integral(10000);
      break;
    case 4:
      divmod_integral(1000);
      break;
    case 3:
      divmod_integral(100);
      break;
    case 2:
      divmod_integral(10);
      break;
    case 1:
      digit = integral;
      integral = 0;
      break;
    default:
      FMT_ASSERT(false, "invalid number of digits");
    }
    --exp;
    auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
    result = handler.on_digit(static_cast<char>('0' + digit),
                              power_of_10_64(exp) << -one.e, remainder, error,
                              exp, true);
    if (result != digits::more) return result;
  } while (exp > 0);
  // Generate digits for the fractional part.
  for (;;) {
    fractional *= 10;
    error *= 10;
    char digit = static_cast<char>('0' + (fractional >> -one.e));
    fractional &= one.f - 1;
    --exp;
    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
    if (result != digits::more) return result;
  }
}

// The fixed precision digit handler.
struct fixed_handler {
  char* buf;
  int size;
  int precision;
  int exp10;
  bool fixed;

  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
                          int& exp) {
    // Non-fixed formats require at least one digit and no precision adjustment.
    if (!fixed) return digits::more;
    // Adjust fixed precision by exponent because it is relative to decimal
    // point.
    precision += exp + exp10;
    // Check if precision is satisfied just by leading zeros, e.g.
    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
    if (precision > 0) return digits::more;
    if (precision < 0) return digits::done;
    auto dir = get_round_direction(divisor, remainder, error);
    if (dir == round_direction::unknown) return digits::error;
    buf[size++] = dir == round_direction::up ? '1' : '0';
    return digits::done;
  }

  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
                          uint64_t error, int, bool integral) {
    FMT_ASSERT(remainder < divisor, "");
    buf[size++] = digit;
    if (!integral && error >= remainder) return digits::error;
    if (size < precision) return digits::more;
    if (!integral) {
      // Check if error * 2 < divisor with overflow prevention.
      // The check is not needed for the integral part because error = 1
      // and divisor > (1 << 32) there.
      if (error >= divisor || error >= divisor - error) return digits::error;
    } else {
      FMT_ASSERT(error == 1 && divisor > 2, "");
    }
    auto dir = get_round_direction(divisor, remainder, error);
    if (dir != round_direction::up)
      return dir == round_direction::down ? digits::done : digits::error;
    ++buf[size - 1];
    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
      buf[i] = '0';
      ++buf[i - 1];
    }
    if (buf[0] > '9') {
      buf[0] = '1';
      if (fixed)
        buf[size++] = '0';
      else
        ++exp10;
    }
    return digits::done;
  }
};

// A 128-bit integer type used internally,
struct uint128_wrapper {
  uint128_wrapper() = default;

#if FMT_USE_INT128
  uint128_t internal_;

  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
      : internal_{static_cast<uint128_t>(low) |
                  (static_cast<uint128_t>(high) << 64)} {}

  constexpr uint128_wrapper(uint128_t u) : internal_{u} {}

  constexpr uint64_t high() const FMT_NOEXCEPT {
    return uint64_t(internal_ >> 64);
  }
  constexpr uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); }

  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
    internal_ += n;
    return *this;
  }
#else
  uint64_t high_;
  uint64_t low_;

  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
      : high_{high},
        low_{low} {}

  constexpr uint64_t high() const FMT_NOEXCEPT { return high_; }
  constexpr uint64_t low() const FMT_NOEXCEPT { return low_; }

  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
#  if defined(_MSC_VER) && defined(_M_X64)
    unsigned char carry = _addcarry_u64(0, low_, n, &low_);
    _addcarry_u64(carry, high_, 0, &high_);
    return *this;
#  else
    uint64_t sum = low_ + n;
    high_ += (sum < low_ ? 1 : 0);
    low_ = sum;
    return *this;
#  endif
  }
#endif
};

// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
namespace dragonbox {
// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT {
#if FMT_USE_INT128
  return static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
#elif defined(_MSC_VER) && defined(_M_X64)
  uint128_wrapper result;
  result.low_ = _umul128(x, y, &result.high_);
  return result;
#else
  const uint64_t mask = (uint64_t(1) << 32) - uint64_t(1);

  uint64_t a = x >> 32;
  uint64_t b = x & mask;
  uint64_t c = y >> 32;
  uint64_t d = y & mask;

  uint64_t ac = a * c;
  uint64_t bc = b * c;
  uint64_t ad = a * d;
  uint64_t bd = b * d;

  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);

  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
          (intermediate << 32) + (bd & mask)};
#endif
}

// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT {
#if FMT_USE_INT128
  auto p = static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
  return static_cast<uint64_t>(p >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
  return __umulh(x, y);
#else
  return umul128(x, y).high();
#endif
}

// Computes upper 64 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
  uint128_wrapper g0 = umul128(x, y.high());
  g0 += umul128_upper64(x, y.low());
  return g0.high();
}

// Computes upper 32 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
inline uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT {
  return static_cast<uint32_t>(umul128_upper64(x, y));
}

// Computes middle 64 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
  uint64_t g01 = x * y.high();
  uint64_t g10 = umul128_upper64(x, y.low());
  return g01 + g10;
}

// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
inline uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT {
  return x * y;
}

// Computes floor(log10(pow(2, e))) for e in [-1700, 1700] using the method from
// https://fmt.dev/papers/Grisu-Exact.pdf#page=5, section 3.4.
inline int floor_log10_pow2(int e) FMT_NOEXCEPT {
  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
  const int shift = 22;
  return (e * static_cast<int>(data::log10_2_significand >> (64 - shift))) >>
         shift;
}

// Various fast log computations.
inline int floor_log2_pow10(int e) FMT_NOEXCEPT {
  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  const uint64_t log2_10_integer_part = 3;
  const uint64_t log2_10_fractional_digits = 0x5269e12f346e2bf9;
  const int shift_amount = 19;
  return (e * static_cast<int>(
                  (log2_10_integer_part << shift_amount) |
                  (log2_10_fractional_digits >> (64 - shift_amount)))) >>
         shift_amount;
}
inline int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT {
  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
  const uint64_t log10_4_over_3_fractional_digits = 0x1ffbfc2bbc780375;
  const int shift_amount = 22;
  return (e * static_cast<int>(data::log10_2_significand >>
                               (64 - shift_amount)) -
          static_cast<int>(log10_4_over_3_fractional_digits >>
                           (64 - shift_amount))) >>
         shift_amount;
}

// Returns true iff x is divisible by pow(2, exp).
inline bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT {
  FMT_ASSERT(exp >= 1, "");
  FMT_ASSERT(x != 0, "");
#ifdef FMT_BUILTIN_CTZ
  return FMT_BUILTIN_CTZ(x) >= exp;
#else
  return exp < num_bits<uint32_t>() && x == ((x >> exp) << exp);
#endif
}
inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT {
  FMT_ASSERT(exp >= 1, "");
  FMT_ASSERT(x != 0, "");
#ifdef FMT_BUILTIN_CTZLL
  return FMT_BUILTIN_CTZLL(x) >= exp;
#else
  return exp < num_bits<uint64_t>() && x == ((x >> exp) << exp);
#endif
}

// Table entry type for divisibility test.
template <typename T> struct divtest_table_entry {
  T mod_inv;
  T max_quotient;
};

// Returns true iff x is divisible by pow(5, exp).
inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT {
  FMT_ASSERT(exp <= 10, "too large exponent");
  static constexpr const divtest_table_entry<uint32_t> divtest_table[] = {
      {0x00000001, 0xffffffff}, {0xcccccccd, 0x33333333},
      {0xc28f5c29, 0x0a3d70a3}, {0x26e978d5, 0x020c49ba},
      {0x3afb7e91, 0x0068db8b}, {0x0bcbe61d, 0x0014f8b5},
      {0x68c26139, 0x000431bd}, {0xae8d46a5, 0x0000d6bf},
      {0x22e90e21, 0x00002af3}, {0x3a2e9c6d, 0x00000897},
      {0x3ed61f49, 0x000001b7}};
  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
}
inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT {
  FMT_ASSERT(exp <= 23, "too large exponent");
  static constexpr const divtest_table_entry<uint64_t> divtest_table[] = {
      {0x0000000000000001, 0xffffffffffffffff},
      {0xcccccccccccccccd, 0x3333333333333333},
      {0x8f5c28f5c28f5c29, 0x0a3d70a3d70a3d70},
      {0x1cac083126e978d5, 0x020c49ba5e353f7c},
      {0xd288ce703afb7e91, 0x0068db8bac710cb2},
      {0x5d4e8fb00bcbe61d, 0x0014f8b588e368f0},
      {0x790fb65668c26139, 0x000431bde82d7b63},
      {0xe5032477ae8d46a5, 0x0000d6bf94d5e57a},
      {0xc767074b22e90e21, 0x00002af31dc46118},
      {0x8e47ce423a2e9c6d, 0x0000089705f4136b},
      {0x4fa7f60d3ed61f49, 0x000001b7cdfd9d7b},
      {0x0fee64690c913975, 0x00000057f5ff85e5},
      {0x3662e0e1cf503eb1, 0x000000119799812d},
      {0xa47a2cf9f6433fbd, 0x0000000384b84d09},
      {0x54186f653140a659, 0x00000000b424dc35},
      {0x7738164770402145, 0x0000000024075f3d},
      {0xe4a4d1417cd9a041, 0x000000000734aca5},
      {0xc75429d9e5c5200d, 0x000000000170ef54},
      {0xc1773b91fac10669, 0x000000000049c977},
      {0x26b172506559ce15, 0x00000000000ec1e4},
      {0xd489e3a9addec2d1, 0x000000000002f394},
      {0x90e860bb892c8d5d, 0x000000000000971d},
      {0x502e79bf1b6f4f79, 0x0000000000001e39},
      {0xdcd618596be30fe5, 0x000000000000060b}};
  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
}

// Replaces n by floor(n / pow(5, N)) returning true if and only if n is
// divisible by pow(5, N).
// Precondition: n <= 2 * pow(5, N + 1).
template <int N>
bool check_divisibility_and_divide_by_pow5(uint32_t& n) FMT_NOEXCEPT {
  static constexpr struct {
    uint32_t magic_number;
    int bits_for_comparison;
    uint32_t threshold;
    int shift_amount;
  } infos[] = {{0xcccd, 16, 0x3333, 18}, {0xa429, 8, 0x0a, 20}};
  constexpr auto info = infos[N - 1];
  n *= info.magic_number;
  const uint32_t comparison_mask = (1u << info.bits_for_comparison) - 1;
  bool result = (n & comparison_mask) <= info.threshold;
  n >>= info.shift_amount;
  return result;
}

// Computes floor(n / pow(10, N)) for small n and N.
// Precondition: n <= pow(10, N + 1).
template <int N> uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT {
  static constexpr struct {
    uint32_t magic_number;
    int shift_amount;
    uint32_t divisor_times_10;
  } infos[] = {{0xcccd, 19, 100}, {0xa3d8, 22, 1000}};
  constexpr auto info = infos[N - 1];
  FMT_ASSERT(n <= info.divisor_times_10, "n is too large");
  return n * info.magic_number >> info.shift_amount;
}

// Computes floor(n / 10^(kappa + 1)) (float)
inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT {
  return n / float_info<float>::big_divisor;
}
// Computes floor(n / 10^(kappa + 1)) (double)
inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) FMT_NOEXCEPT {
  return umul128_upper64(n, 0x83126e978d4fdf3c) >> 9;
}

// Various subroutines using pow10 cache
template <class T> struct cache_accessor;

template <> struct cache_accessor<float> {
  using carrier_uint = float_info<float>::carrier_uint;
  using cache_entry_type = uint64_t;

  static uint64_t get_cached_power(int k) FMT_NOEXCEPT {
    FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
               "k is out of range");
    constexpr const uint64_t pow10_significands[] = {
        0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
        0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
        0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
        0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
        0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
        0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
        0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
        0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
        0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
        0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
        0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
        0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
        0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
        0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
        0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
        0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
        0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
        0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
        0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
        0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940984,
        0xa18f07d736b90be5, 0xc9f2c9cd04674ede, 0xfc6f7c4045812296,
        0x9dc5ada82b70b59d, 0xc5371912364ce305, 0xf684df56c3e01bc6,
        0x9a130b963a6c115c, 0xc097ce7bc90715b3, 0xf0bdc21abb48db20,
        0x96769950b50d88f4, 0xbc143fa4e250eb31, 0xeb194f8e1ae525fd,
        0x92efd1b8d0cf37be, 0xb7abc627050305ad, 0xe596b7b0c643c719,
        0x8f7e32ce7bea5c6f, 0xb35dbf821ae4f38b, 0xe0352f62a19e306e};
    return pow10_significands[k - float_info<float>::min_k];
  }

  static carrier_uint compute_mul(carrier_uint u,
                                  const cache_entry_type& cache) FMT_NOEXCEPT {
    return umul96_upper32(u, cache);
  }

  static uint32_t compute_delta(const cache_entry_type& cache,
                                int beta_minus_1) FMT_NOEXCEPT {
    return static_cast<uint32_t>(cache >> (64 - 1 - beta_minus_1));
  }

  static bool compute_mul_parity(carrier_uint two_f,
                                 const cache_entry_type& cache,
                                 int beta_minus_1) FMT_NOEXCEPT {
    FMT_ASSERT(beta_minus_1 >= 1, "");
    FMT_ASSERT(beta_minus_1 < 64, "");

    return ((umul96_lower64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
  }

  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return static_cast<carrier_uint>(
        (cache - (cache >> (float_info<float>::significand_bits + 2))) >>
        (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
  }

  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return static_cast<carrier_uint>(
        (cache + (cache >> (float_info<float>::significand_bits + 1))) >>
        (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
  }

  static carrier_uint compute_round_up_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return (static_cast<carrier_uint>(
                cache >>
                (64 - float_info<float>::significand_bits - 2 - beta_minus_1)) +
            1) /
           2;
  }
};

template <> struct cache_accessor<double> {
  using carrier_uint = float_info<double>::carrier_uint;
  using cache_entry_type = uint128_wrapper;

  static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT {
    FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
               "k is out of range");

    static constexpr const uint128_wrapper pow10_significands[] = {
#if FMT_USE_FULL_CACHE_DRAGONBOX
      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
      {0x9faacf3df73609b1, 0x77b191618c54e9ad},
      {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
      {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
      {0x9becce62836ac577, 0x4ee367f9430aec33},
      {0xc2e801fb244576d5, 0x229c41f793cda740},
      {0xf3a20279ed56d48a, 0x6b43527578c11110},
      {0x9845418c345644d6, 0x830a13896b78aaaa},
      {0xbe5691ef416bd60c, 0x23cc986bc656d554},
      {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
      {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
      {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
      {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
      {0x91376c36d99995be, 0x23100809b9c21fa2},
      {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
      {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
      {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
      {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
      {0xdd95317f31c7fa1d, 0x40405643d711d584},
      {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
      {0xad1c8eab5ee43b66, 0xda3243650005eed0},
      {0xd863b256369d4a40, 0x90bed43e40076a83},
      {0x873e4f75e2224e68, 0x5a7744a6e804a292},
      {0xa90de3535aaae202, 0x711515d0a205cb37},
      {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
      {0x8412d9991ed58091, 0xe858790afe9486c3},
      {0xa5178fff668ae0b6, 0x626e974dbe39a873},
      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
      {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
      {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
      {0xc987434744ac874e, 0xa327ffb266b56221},
      {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
      {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
      {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
      {0xf6019da07f549b2b, 0x7e2a53a146606a49},
      {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
      {0xc0314325637a1939, 0xfa911155fefb5309},
      {0xf03d93eebc589f88, 0x793555ab7eba27cb},
      {0x96267c7535b763b5, 0x4bc1558b2f3458df},
      {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
      {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
      {0x92a1958a7675175f, 0x0bfacd89ec191eca},
      {0xb749faed14125d36, 0xcef980ec671f667c},
      {0xe51c79a85916f484, 0x82b7e12780e7401b},
      {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
      {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
      {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
      {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
      {0xaecc49914078536d, 0x58fae9f773886e19},
      {0xda7f5bf590966848, 0xaf39a475506a899f},
      {0x888f99797a5e012d, 0x6d8406c952429604},
      {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
      {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
      {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
      {0xd0601d8efc57b08b, 0xf13b94daf124da27},
      {0x823c12795db6ce57, 0x76c53d08d6b70859},
      {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
      {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
      {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
      {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
      {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
      {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
      {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
      {0xc21094364dfb5636, 0x985915fc12f542e5},
      {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
      {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
      {0xbd8430bd08277231, 0x50c6ff782a838354},
      {0xece53cec4a314ebd, 0xa4f8bf5635246429},
      {0x940f4613ae5ed136, 0x871b7795e136be9a},
      {0xb913179899f68584, 0x28e2557b59846e40},
      {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
      {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
      {0xb4bca50b065abe63, 0x0fed077a756b53aa},
      {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
      {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
      {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
      {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
      {0x89e42caaf9491b60, 0xf41686c49db57245},
      {0xac5d37d5b79b6239, 0x311c2875c522ced6},
      {0xd77485cb25823ac7, 0x7d633293366b828c},
      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
      {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
      {0xd267caa862a12d66, 0xd072df63c324fd7c},
      {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
      {0xa46116538d0deb78, 0x52d9be85f074e609},
      {0xcd795be870516656, 0x67902e276c921f8c},
      {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
      {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
      {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
      {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
      {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
      {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
      {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
      {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
      {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
      {0xef340a98172aace4, 0x86fb897116c87c35},
      {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
      {0xbae0a846d2195712, 0x8974836059cca10a},
      {0xe998d258869facd7, 0x2bd1a438703fc94c},
      {0x91ff83775423cc06, 0x7b6306a34627ddd0},
      {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
      {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
      {0x8e938662882af53e, 0x547eb47b7282ee9d},
      {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
      {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
      {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
      {0xae0b158b4738705e, 0x9624ab50b148d446},
      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
      {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
      {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
      {0xd47487cc8470652b, 0x7647c32000696720},
      {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
      {0xa5fb0a17c777cf09, 0xf468107100525891},
      {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
      {0x81ac1fe293d599bf, 0xc6f14cd848405531},
      {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
      {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
      {0xfd442e4688bd304a, 0x908f4a166d1da664},
      {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
      {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
      {0xf7549530e188c128, 0xd12bee59e68ef47d},
      {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
      {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
      {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
      {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
      {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
      {0xebdf661791d60f56, 0x111b495b3464ad22},
      {0x936b9fcebb25c995, 0xcab10dd900beec35},
      {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
      {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
      {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
      {0xb3f4e093db73a093, 0x59ed216765690f57},
      {0xe0f218b8d25088b8, 0x306869c13ec3532d},
      {0x8c974f7383725573, 0x1e414218c73a13fc},
      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
      {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
      {0x894bc396ce5da772, 0x6b8bba8c328eb784},
      {0xab9eb47c81f5114f, 0x066ea92f3f326565},
      {0xd686619ba27255a2, 0xc80a537b0efefebe},
      {0x8613fd0145877585, 0xbd06742ce95f5f37},
      {0xa798fc4196e952e7, 0x2c48113823b73705},
      {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
      {0x82ef85133de648c4, 0x9a984d73dbe722fc},
      {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
      {0xcc963fee10b7d1b3, 0x318df905079926a9},
      {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
      {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
      {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
      {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
      {0x9c1661a651213e2d, 0x06bea10ca65c084f},
      {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
      {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
      {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
      {0xbe89523386091465, 0xf6bbb397f1135824},
      {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
      {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
      {0xba121a4650e4ddeb, 0x92f34d62616ce414},
      {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
      {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
      {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
      {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
      {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
      {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
      {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
      {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
      {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
      {0x87625f056c7c4a8b, 0x11471cd764ad4973},
      {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
      {0xd389b47879823479, 0x4aff1d108d4ec2c4},
      {0x843610cb4bf160cb, 0xcedf722a585139bb},
      {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
      {0xce947a3da6a9273e, 0x733d226229feea33},
      {0x811ccc668829b887, 0x0806357d5a3f5260},
      {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
      {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
      {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
      {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
      {0xc5029163f384a931, 0x0a9e795e65d4df12},
      {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
      {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
      {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
      {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
      {0x964e858c91ba2655, 0x3a6a07f8d510f870},
      {0xbbe226efb628afea, 0x890489f70a55368c},
      {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
      {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
      {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
      {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
      {0xb32df8e9f3546564, 0x47939822dc96abfa},
      {0xdff9772470297ebd, 0x59787e2b93bc56f8},
      {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
      {0xaefae51477a06b03, 0xede622920b6b23f2},
      {0xdab99e59958885c4, 0xe95fab368e45ecee},
      {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
      {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
      {0xd59944a37c0752a2, 0x4be76d3346f04960},
      {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
      {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
      {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
      {0x825ecc24c873782f, 0x8ed400668c0c28c9},
      {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
      {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
      {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
      {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
      {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
      {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
      {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
      {0xc24452da229b021b, 0xfbe85badce996169},
      {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
      {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
      {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
      {0xed246723473e3813, 0x290123e9aab23b69},
      {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
      {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
      {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
      {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
      {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
      {0x8d590723948a535f, 0x579c487e5a38ad0f},
      {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
      {0xdcdb1b2798182244, 0xf8e431456cf88e66},
      {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
      {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
      {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
      {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
      {0xa87fea27a539e9a5, 0x3f2398d747b36225},
      {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
      {0x83a3eeeef9153e89, 0x1953cf68300424ad},
      {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
      {0xcdb02555653131b6, 0x3792f412cb06794e},
      {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
      {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
      {0xc8de047564d20a8b, 0xf245825a5a445276},
      {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
      {0x9ced737bb6c4183d, 0x55464dd69685606c},
      {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
      {0xf53304714d9265df, 0xd53dd99f4b3066a9},
      {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
      {0xbf8fdb78849a5f96, 0xde98520472bdd034},
      {0xef73d256a5c0f77c, 0x963e66858f6d4441},
      {0x95a8637627989aad, 0xdde7001379a44aa9},
      {0xbb127c53b17ec159, 0x5560c018580d5d53},
      {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
      {0x9226712162ab070d, 0xcab3961304ca70e9},
      {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
      {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
      {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
      {0xb267ed1940f1c61c, 0x55f038b237591ed4},
      {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
      {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
      {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
      {0xd9c7dced53c72255, 0x96e7bd358c904a22},
      {0x881cea14545c7575, 0x7e50d64177da2e55},
      {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
      {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
      {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
      {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
      {0xcfb11ead453994ba, 0x67de18eda5814af3},
      {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
      {0xa2425ff75e14fc31, 0xa1258379a94d028e},
      {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
      {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
      {0x9e74d1b791e07e48, 0x775ea264cf55347e},
      {0xc612062576589dda, 0x95364afe032a819e},
      {0xf79687aed3eec551, 0x3a83ddbd83f52205},
      {0x9abe14cd44753b52, 0xc4926a9672793543},
      {0xc16d9a0095928a27, 0x75b7053c0f178294},
      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
      {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
      {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
      {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
      {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
      {0xb877aa3236a4b449, 0x09befeb9fad487c3},
      {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
      {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
      {0xb424dc35095cd80f, 0x538484c19ef38c95},
      {0xe12e13424bb40e13, 0x2865a5f206b06fba},
      {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
      {0xafebff0bcb24aafe, 0xf78f69a51539d749},
      {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
      {0x89705f4136b4a597, 0x31680a88f8953031},
      {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
      {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
      {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
      {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
      {0xd1b71758e219652b, 0xd3c36113404ea4a9},
      {0x83126e978d4fdf3b, 0x645a1cac083126ea},
      {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
      {0xcccccccccccccccc, 0xcccccccccccccccd},
      {0x8000000000000000, 0x0000000000000000},
      {0xa000000000000000, 0x0000000000000000},
      {0xc800000000000000, 0x0000000000000000},
      {0xfa00000000000000, 0x0000000000000000},
      {0x9c40000000000000, 0x0000000000000000},
      {0xc350000000000000, 0x0000000000000000},
      {0xf424000000000000, 0x0000000000000000},
      {0x9896800000000000, 0x0000000000000000},
      {0xbebc200000000000, 0x0000000000000000},
      {0xee6b280000000000, 0x0000000000000000},
      {0x9502f90000000000, 0x0000000000000000},
      {0xba43b74000000000, 0x0000000000000000},
      {0xe8d4a51000000000, 0x0000000000000000},
      {0x9184e72a00000000, 0x0000000000000000},
      {0xb5e620f480000000, 0x0000000000000000},
      {0xe35fa931a0000000, 0x0000000000000000},
      {0x8e1bc9bf04000000, 0x0000000000000000},
      {0xb1a2bc2ec5000000, 0x0000000000000000},
      {0xde0b6b3a76400000, 0x0000000000000000},
      {0x8ac7230489e80000, 0x0000000000000000},
      {0xad78ebc5ac620000, 0x0000000000000000},
      {0xd8d726b7177a8000, 0x0000000000000000},
      {0x878678326eac9000, 0x0000000000000000},
      {0xa968163f0a57b400, 0x0000000000000000},
      {0xd3c21bcecceda100, 0x0000000000000000},
      {0x84595161401484a0, 0x0000000000000000},
      {0xa56fa5b99019a5c8, 0x0000000000000000},
      {0xcecb8f27f4200f3a, 0x0000000000000000},
      {0x813f3978f8940984, 0x4000000000000000},
      {0xa18f07d736b90be5, 0x5000000000000000},
      {0xc9f2c9cd04674ede, 0xa400000000000000},
      {0xfc6f7c4045812296, 0x4d00000000000000},
      {0x9dc5ada82b70b59d, 0xf020000000000000},
      {0xc5371912364ce305, 0x6c28000000000000},
      {0xf684df56c3e01bc6, 0xc732000000000000},
      {0x9a130b963a6c115c, 0x3c7f400000000000},
      {0xc097ce7bc90715b3, 0x4b9f100000000000},
      {0xf0bdc21abb48db20, 0x1e86d40000000000},
      {0x96769950b50d88f4, 0x1314448000000000},
      {0xbc143fa4e250eb31, 0x17d955a000000000},
      {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
      {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
      {0xb7abc627050305ad, 0xf14a3d9e40000000},
      {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
      {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
      {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
      {0xe0352f62a19e306e, 0xd50b2037ad200000},
      {0x8c213d9da502de45, 0x4526f422cc340000},
      {0xaf298d050e4395d6, 0x9670b12b7f410000},
      {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
      {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
      {0xab0e93b6efee0053, 0x8eea0d047a457a00},
      {0xd5d238a4abe98068, 0x72a4904598d6d880},
      {0x85a36366eb71f041, 0x47a6da2b7f864750},
      {0xa70c3c40a64e6c51, 0x999090b65f67d924},
      {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
      {0x82818f1281ed449f, 0xbff8f10e7a8921a4},
      {0xa321f2d7226895c7, 0xaff72d52192b6a0d},
      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490},
      {0xfee50b7025c36a08, 0x02f236d04753d5b4},
      {0x9f4f2726179a2245, 0x01d762422c946590},
      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5},
      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2},
      {0x9b934c3b330c8577, 0x63cc55f49f88eb2f},
      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb},
      {0xf316271c7fc3908a, 0x8bef464e3945ef7a},
      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ac},
      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317},
      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd},
      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a},
      {0xb975d6b6ee39e436, 0xb3e2fd538e122b44},
      {0xe7d34c64a9c85d44, 0x60dbbca87196b616},
      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd},
      {0xb51d13aea4a488dd, 0x6babab6398bdbe41},
      {0xe264589a4dcdab14, 0xc696963c7eed2dd1},
      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2},
      {0xb0de65388cc8ada8, 0x3b25a55f43294bcb},
      {0xdd15fe86affad912, 0x49ef0eb713f39ebe},
      {0x8a2dbf142dfcc7ab, 0x6e3569326c784337},
      {0xacb92ed9397bf996, 0x49c2c37f07965404},
      {0xd7e77a8f87daf7fb, 0xdc33745ec97be906},
      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3},
      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0c},
      {0xd2d80db02aabd62b, 0xf50a3fa490c30190},
      {0x83c7088e1aab65db, 0x792667c6da79e0fa},
      {0xa4b8cab1a1563f52, 0x577001b891185938},
      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
      {0x80b05e5ac60b6178, 0x544f8158315b05b4},
      {0xa0dc75f1778e39d6, 0x696361ae3db1c721},
      {0xc913936dd571c84c, 0x03bc3a19cd1e38e9},
      {0xfb5878494ace3a5f, 0x04ab48a04065c723},
      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c76},
      {0xc45d1df942711d9a, 0x3ba5d0bd324f8394},
      {0xf5746577930d6500, 0xca8f44ec7ee36479},
      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb},
      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e},
      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e},
      {0x95d04aee3b80ece5, 0xbba1f1d158724a12},
      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc97},
      {0xea1575143cf97226, 0xf52d09d71a3293bd},
      {0x924d692ca61be758, 0x593c2626705f9c56},
      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c},
      {0xe498f455c38b997a, 0x0b6dfb9c0f956447},
      {0x8edf98b59a373fec, 0x4724bd4189bd5eac},
      {0xb2977ee300c50fe7, 0x58edec91ec2cb657},
      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed},
      {0x8b865b215899f46c, 0xbd79e0d20082ee74},
      {0xae67f1e9aec07187, 0xecd8590680a3aa11},
      {0xda01ee641a708de9, 0xe80e6f4820cc9495},
      {0x884134fe908658b2, 0x3109058d147fdcdd},
      {0xaa51823e34a7eede, 0xbd4b46f0599fd415},
      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a},
      {0x850fadc09923329e, 0x03e2cf6bc604ddb0},
      {0xa6539930bf6bff45, 0x84db8346b786151c},
      {0xcfe87f7cef46ff16, 0xe612641865679a63},
      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e},
      {0xa26da3999aef7749, 0xe3be5e330f38f09d},
      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc5},
      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6},
      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa},
      {0xc646d63501a1511d, 0xb281e1fd541501b8},
      {0xf7d88bc24209a565, 0x1f225a7ca91a4226},
      {0x9ae757596946075f, 0x3375788de9b06958},
      {0xc1a12d2fc3978937, 0x0052d6b1641c83ae},
      {0xf209787bb47d6b84, 0xc0678c5dbd23a49a},
      {0x9745eb4d50ce6332, 0xf840b7ba963646e0},
      {0xbd176620a501fbff, 0xb650e5a93bc3d898},
      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe},
      {0x93ba47c980e98cdf, 0xc66f336c36b10137},
      {0xb8a8d9bbe123f017, 0xb80b0047445d4184},
      {0xe6d3102ad96cec1d, 0xa60dc059157491e5},
      {0x9043ea1ac7e41392, 0x87c89837ad68db2f},
      {0xb454e4a179dd1877, 0x29babe4598c311fb},
      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a},
      {0x8ce2529e2734bb1d, 0x1899e4a65f58660c},
      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f},
      {0xdc21a1171d42645d, 0x76707543f4fa1f73},
      {0x899504ae72497eba, 0x6a06494a791c53a8},
      {0xabfa45da0edbde69, 0x0487db9d17636892},
      {0xd6f8d7509292d603, 0x45a9d2845d3c42b6},
      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
      {0xa7f26836f282b732, 0x8e6cac7768d7141e},
      {0xd1ef0244af2364ff, 0x3207d795430cd926},
      {0x8335616aed761f1f, 0x7f44e6bd49e807b8},
      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6},
      {0xcd036837130890a1, 0x36dba887c37a8c0f},
      {0x802221226be55a64, 0xc2494954da2c9789},
      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c},
      {0xc83553c5c8965d3d, 0x6f92829494e5acc7},
      {0xfa42a8b73abbf48c, 0xcb772339ba1f17f9},
      {0x9c69a97284b578d7, 0xff2a760414536efb},
      {0xc38413cf25e2d70d, 0xfef5138519684aba},
      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d69},
      {0x98bf2f79d5993802, 0xef2f773ffbd97a61},
      {0xbeeefb584aff8603, 0xaafb550ffacfd8fa},
      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38},
      {0x952ab45cfa97a0b2, 0xdd945a747bf26183},
      {0xba756174393d88df, 0x94f971119aeef9e4},
      {0xe912b9d1478ceb17, 0x7a37cd5601aab85d},
      {0x91abb422ccb812ee, 0xac62e055c10ab33a},
      {0xb616a12b7fe617aa, 0x577b986b314d6009},
      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80b},
      {0x8e41ade9fbebc27d, 0x14588f13be847307},
      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc8},
      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb},
      {0x8aec23d680043bee, 0x25de7bb9480d5854},
      {0xada72ccc20054ae9, 0xaf561aa79a10ae6a},
      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
      {0x87aa9aff79042286, 0x90fb44d2f05d0842},
      {0xa99541bf57452b28, 0x353a1607ac744a53},
      {0xd3fa922f2d1675f2, 0x42889b8997915ce8},
      {0x847c9b5d7c2e09b7, 0x69956135febada11},
      {0xa59bc234db398c25, 0x43fab9837e699095},
      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bb},
      {0x8161afb94b44f57d, 0x1d1be0eebac278f5},
      {0xa1ba1ba79e1632dc, 0x6462d92a69731732},
      {0xca28a291859bbf93, 0x7d7b8f7503cfdcfe},
      {0xfcb2cb35e702af78, 0x5cda735244c3d43e},
      {0x9defbf01b061adab, 0x3a0888136afa64a7},
      {0xc56baec21c7a1916, 0x088aaa1845b8fdd0},
      {0xf6c69a72a3989f5b, 0x8aad549e57273d45},
      {0x9a3c2087a63f6399, 0x36ac54e2f678864b},
      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd},
      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5},
      {0x969eb7c47859e743, 0x9f644ae5a4b1b325},
      {0xbc4665b596706114, 0x873d5d9f0dde1fee},
      {0xeb57ff22fc0c7959, 0xa90cb506d155a7ea},
      {0x9316ff75dd87cbd8, 0x09a7f12442d588f2},
      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb2f},
      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fa},
      {0x8fa475791a569d10, 0xf96e017d694487bc},
      {0xb38d92d760ec4455, 0x37c981dcc395a9ac},
      {0xe070f78d3927556a, 0x85bbe253f47b1417},
      {0x8c469ab843b89562, 0x93956d7478ccec8e},
      {0xaf58416654a6babb, 0x387ac8d1970027b2},
      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319e},
      {0x88fcf317f22241e2, 0x441fece3bdf81f03},
      {0xab3c2fddeeaad25a, 0xd527e81cad7626c3},
      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b074},
      {0x85c7056562757456, 0xf6872d5667844e49},
      {0xa738c6bebb12d16c, 0xb428f8ac016561db},
      {0xd106f86e69d785c7, 0xe13336d701beba52},
      {0x82a45b450226b39c, 0xecc0024661173473},
      {0xa34d721642b06084, 0x27f002d7f95d0190},
      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f4},
      {0xff290242c83396ce, 0x7e67047175a15271},
      {0x9f79a169bd203e41, 0x0f0062c6e984d386},
      {0xc75809c42c684dd1, 0x52c07b78a3e60868},
      {0xf92e0c3537826145, 0xa7709a56ccdf8a82},
      {0x9bbcc7a142b17ccb, 0x88a66076400bb691},
      {0xc2abf989935ddbfe, 0x6acff893d00ea435},
      {0xf356f7ebf83552fe, 0x0583f6b8c4124d43},
      {0x98165af37b2153de, 0xc3727a337a8b704a},
      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c},
      {0xeda2ee1c7064130c, 0x1162def06f79df73},
      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8},
      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173692},
      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437},
      {0x910ab1d4db9914a0, 0x1d9c9892400a22a2},
      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4b},
      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61d},
      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
      {0xb10d8e1456105dad, 0x7425a83e872c5f47},
      {0xdd50f1996b947518, 0xd12f124e28f77719},
      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f},
      {0xace73cbfdc0bfb7b, 0x636cc64d1001550b},
      {0xd8210befd30efa5a, 0x3c47f7e05401aa4e},
      {0x8714a775e3e95c78, 0x65acfaec34810a71},
      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0d},
      {0xd31045a8341ca07c, 0x1ede48111209a050},
      {0x83ea2b892091e44d, 0x934aed0aab460432},
      {0xa4e4b66b68b65d60, 0xf81da84d5617853f},
      {0xce1de40642e3f4b9, 0x36251260ab9d668e},
      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019},
      {0xa1075a24e4421730, 0xb24cf65b8612f81f},
      {0xc94930ae1d529cfc, 0xdee033f26797b627},
      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b1},
      {0x9d412e0806e88aa5, 0x8e1f289560ee864e},
      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2},
      {0xf5b5d7ec8acb58a2, 0xae10af696774b1db},
      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29},
      {0xbff610b0cc6edd3f, 0x17fd090a58d32af3},
      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b0},
      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98e},
      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1},
      {0xea53df5fd18d5513, 0x84c86189216dc5ed},
      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4},
      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a1},
      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400e},
      {0xb2c71d5bca9023f8, 0x743e20e9ef511012},
      {0xdf78e4b2bd342cf6, 0x914da9246b255416},
      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e},
      {0xae9672aba3d0c320, 0xa184ac2473b529b1},
      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e},
      {0x8865899617fb1871, 0x7e2fa67c7a658892},
      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab7},
      {0xd51ea6fa85785631, 0x552a74227f3ea565},
      {0x8533285c936b35de, 0xd53a88958f87275f},
      {0xa67ff273b8460356, 0x8a892abaf368f137},
      {0xd01fef10a657842c, 0x2d2b7569b0432d85},
      {0x8213f56a67f6b29b, 0x9c3b29620e29fc73},
      {0xa298f2c501f45f42, 0x8349f3ba91b47b8f},
      {0xcb3f2f7642717713, 0x241c70a936219a73},
      {0xfe0efb53d30dd4d7, 0xed238cd383aa0110},
      {0x9ec95d1463e8a506, 0xf4363804324a40aa},
      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d5},
      {0xf81aa16fdc1b81da, 0xdd94b7868e94050a},
      {0x9b10a4e5e9913128, 0xca7cf2b4191c8326},
      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0},
      {0xf24a01a73cf2dccf, 0xbc633b39673c8cec},
      {0x976e41088617ca01, 0xd5be0503e085d813},
      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18},
      {0xec9c459d51852ba2, 0xddf8e7d60ed1219e},
      {0x93e1ab8252f33b45, 0xcabb90e5c942b503},
      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
      {0xe7109bfba19c0c9d, 0x0cc512670a783ad4},
      {0x906a617d450187e2, 0x27fb2b80668b24c5},
      {0xb484f9dc9641e9da, 0xb1f9f660802dedf6},
      {0xe1a63853bbd26451, 0x5e7873f8a0396973},
      {0x8d07e33455637eb2, 0xdb0b487b6423e1e8},
      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62},
      {0xdc5c5301c56b75f7, 0x7641a140cc7810fb},
      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d},
      {0xac2820d9623bf429, 0x546345fa9fbdcd44},
      {0xd732290fbacaf133, 0xa97c177947ad4095},
      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485d},
      {0xa81f301449ee8c70, 0x5c68f256bfff5a74},
      {0xd226fc195c6a2f8c, 0x73832eec6fff3111},
      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eab},
      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e55},
      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb},
      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b3},
      {0xa0555e361951c366, 0xd7e105bcc332621f},
      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7},
      {0xfa856334878fc150, 0xb14f98f6f0feb951},
      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3},
      {0xc3b8358109e84f07, 0x0a862f80ec4700c8},
      {0xf4a642e14c6262c8, 0xcd27bb612758c0fa},
      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789c},
      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c3},
      {0xeeea5d5004981478, 0x1858ccfce06cac74},
      {0x95527a5202df0ccb, 0x0f37801e0c43ebc8},
      {0xbaa718e68396cffd, 0xd30560258f54e6ba},
      {0xe950df20247c83fd, 0x47c6b82ef32a2069},
      {0x91d28b7416cdd27e, 0x4cdc331d57fa5441},
      {0xb6472e511c81471d, 0xe0133fe4adf8e952},
      {0xe3d8f9e563a198e5, 0x58180fddd97723a6},
      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648},
      {0xb201833b35d63f73, 0x2cd2cc6551e513da},
      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d1},
      {0x8b112e86420f6191, 0xfb04afaf27faf782},
      {0xadd57a27d29339f6, 0x79c5db9af1f9b563},
      {0xd94ad8b1c7380874, 0x18375281ae7822bc},
      {0x87cec76f1c830548, 0x8f2293910d0b15b5},
      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb22},
      {0xd433179d9c8cb841, 0x5fa60692a46151eb},
      {0x849feec281d7f328, 0xdbc7c41ba6bcd333},
      {0xa5c7ea73224deff3, 0x12b9b522906c0800},
      {0xcf39e50feae16bef, 0xd768226b34870a00},
      {0x81842f29f2cce375, 0xe6a1158300d46640},
      {0xa1e53af46f801c53, 0x60495ae3c1097fd0},
      {0xca5e89b18b602368, 0x385bb19cb14bdfc4},
      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b5},
      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d1},
      {0xc5a05277621be293, 0xc7098b7305241885},
      { 0xf70867153aa2db38,
        0xb8cbee4fc66d1ea7 }
#else
      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
      {0x95a8637627989aad, 0xdde7001379a44aa9},
      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
      {0xc350000000000000, 0x0000000000000000},
      {0x9dc5ada82b70b59d, 0xf020000000000000},
      {0xfee50b7025c36a08, 0x02f236d04753d5b4},
      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
      {0xa6539930bf6bff45, 0x84db8346b786151c},
      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
      {0xaf58416654a6babb, 0x387ac8d1970027b2},
      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
      { 0x95527a5202df0ccb,
        0x0f37801e0c43ebc8 }
#endif
    };

#if FMT_USE_FULL_CACHE_DRAGONBOX
    return pow10_significands[k - float_info<double>::min_k];
#else
    static constexpr const uint64_t powers_of_5_64[] = {
        0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
        0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
        0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
        0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
        0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
        0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
        0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
        0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
        0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};

    static constexpr const uint32_t pow10_recovery_errors[] = {
        0x50001400, 0x54044100, 0x54014555, 0x55954415, 0x54115555, 0x00000001,
        0x50000000, 0x00104000, 0x54010004, 0x05004001, 0x55555544, 0x41545555,
        0x54040551, 0x15445545, 0x51555514, 0x10000015, 0x00101100, 0x01100015,
        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04450514, 0x45414110,
        0x55555145, 0x50544050, 0x15040155, 0x11054140, 0x50111514, 0x11451454,
        0x00400541, 0x00000000, 0x55555450, 0x10056551, 0x10054011, 0x55551014,
        0x69514555, 0x05151109, 0x00155555};

    static const int compression_ratio = 27;

    // Compute base index.
    int cache_index = (k - float_info<double>::min_k) / compression_ratio;
    int kb = cache_index * compression_ratio + float_info<double>::min_k;
    int offset = k - kb;

    // Get base cache.
    uint128_wrapper base_cache = pow10_significands[cache_index];
    if (offset == 0) return base_cache;

    // Compute the required amount of bit-shift.
    int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
    FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");

    // Try to recover the real cache.
    uint64_t pow5 = powers_of_5_64[offset];
    uint128_wrapper recovered_cache = umul128(base_cache.high(), pow5);
    uint128_wrapper middle_low =
        umul128(base_cache.low() - (kb < 0 ? 1u : 0u), pow5);

    recovered_cache += middle_low.high();

    uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
    uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);

    recovered_cache =
        uint128_wrapper{(recovered_cache.low() >> alpha) | high_to_middle,
                        ((middle_low.low() >> alpha) | middle_to_low)};

    if (kb < 0) recovered_cache += 1;

    // Get error.
    int error_idx = (k - float_info<double>::min_k) / 16;
    uint32_t error = (pow10_recovery_errors[error_idx] >>
                      ((k - float_info<double>::min_k) % 16) * 2) &
                     0x3;

    // Add the error back.
    FMT_ASSERT(recovered_cache.low() + error >= recovered_cache.low(), "");
    return {recovered_cache.high(), recovered_cache.low() + error};
#endif
  }

  static carrier_uint compute_mul(carrier_uint u,
                                  const cache_entry_type& cache) FMT_NOEXCEPT {
    return umul192_upper64(u, cache);
  }

  static uint32_t compute_delta(cache_entry_type const& cache,
                                int beta_minus_1) FMT_NOEXCEPT {
    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta_minus_1));
  }

  static bool compute_mul_parity(carrier_uint two_f,
                                 const cache_entry_type& cache,
                                 int beta_minus_1) FMT_NOEXCEPT {
    FMT_ASSERT(beta_minus_1 >= 1, "");
    FMT_ASSERT(beta_minus_1 < 64, "");

    return ((umul192_middle64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
  }

  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return (cache.high() -
            (cache.high() >> (float_info<double>::significand_bits + 2))) >>
           (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
  }

  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return (cache.high() +
            (cache.high() >> (float_info<double>::significand_bits + 1))) >>
           (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
  }

  static carrier_uint compute_round_up_for_shorter_interval_case(
      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
    return ((cache.high() >>
             (64 - float_info<double>::significand_bits - 2 - beta_minus_1)) +
            1) /
           2;
  }
};

// Various integer checks
template <class T>
bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT {
  return exponent >=
             float_info<
                 T>::case_shorter_interval_left_endpoint_lower_threshold &&
         exponent <=
             float_info<T>::case_shorter_interval_left_endpoint_upper_threshold;
}
template <class T>
bool is_endpoint_integer(typename float_info<T>::carrier_uint two_f,
                         int exponent, int minus_k) FMT_NOEXCEPT {
  if (exponent < float_info<T>::case_fc_pm_half_lower_threshold) return false;
  // For k >= 0.
  if (exponent <= float_info<T>::case_fc_pm_half_upper_threshold) return true;
  // For k < 0.
  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
  return divisible_by_power_of_5(two_f, minus_k);
}

template <class T>
bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
                       int minus_k) FMT_NOEXCEPT {
  // Exponent for 5 is negative.
  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
  if (exponent > float_info<T>::case_fc_upper_threshold)
    return divisible_by_power_of_5(two_f, minus_k);
  // Both exponents are nonnegative.
  if (exponent >= float_info<T>::case_fc_lower_threshold) return true;
  // Exponent for 2 is negative.
  return divisible_by_power_of_2(two_f, minus_k - exponent + 1);
}

// Remove trailing zeros from n and return the number of zeros removed (float)
FMT_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT {
#ifdef FMT_BUILTIN_CTZ
  int t = FMT_BUILTIN_CTZ(n);
#else
  int t = ctz(n);
#endif
  if (t > float_info<float>::max_trailing_zeros)
    t = float_info<float>::max_trailing_zeros;

  const uint32_t mod_inv1 = 0xcccccccd;
  const uint32_t max_quotient1 = 0x33333333;
  const uint32_t mod_inv2 = 0xc28f5c29;
  const uint32_t max_quotient2 = 0x0a3d70a3;

  int s = 0;
  for (; s < t - 1; s += 2) {
    if (n * mod_inv2 > max_quotient2) break;
    n *= mod_inv2;
  }
  if (s < t && n * mod_inv1 <= max_quotient1) {
    n *= mod_inv1;
    ++s;
  }
  n >>= s;
  return s;
}

// Removes trailing zeros and returns the number of zeros removed (double)
FMT_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT {
#ifdef FMT_BUILTIN_CTZLL
  int t = FMT_BUILTIN_CTZLL(n);
#else
  int t = ctzll(n);
#endif
  if (t > float_info<double>::max_trailing_zeros)
    t = float_info<double>::max_trailing_zeros;
  // Divide by 10^8 and reduce to 32-bits
  // Since ret_value.significand <= (2^64 - 1) / 1000 < 10^17,
  // both of the quotient and the r should fit in 32-bits

  const uint32_t mod_inv1 = 0xcccccccd;
  const uint32_t max_quotient1 = 0x33333333;
  const uint64_t mod_inv8 = 0xc767074b22e90e21;
  const uint64_t max_quotient8 = 0x00002af31dc46118;

  // If the number is divisible by 1'0000'0000, work with the quotient
  if (t >= 8) {
    auto quotient_candidate = n * mod_inv8;

    if (quotient_candidate <= max_quotient8) {
      auto quotient = static_cast<uint32_t>(quotient_candidate >> 8);

      int s = 8;
      for (; s < t; ++s) {
        if (quotient * mod_inv1 > max_quotient1) break;
        quotient *= mod_inv1;
      }
      quotient >>= (s - 8);
      n = quotient;
      return s;
    }
  }

  // Otherwise, work with the remainder
  auto quotient = static_cast<uint32_t>(n / 100000000);
  auto remainder = static_cast<uint32_t>(n - 100000000 * quotient);

  if (t == 0 || remainder * mod_inv1 > max_quotient1) {
    return 0;
  }
  remainder *= mod_inv1;

  if (t == 1 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 1) + quotient * 10000000ull;
    return 1;
  }
  remainder *= mod_inv1;

  if (t == 2 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 2) + quotient * 1000000ull;
    return 2;
  }
  remainder *= mod_inv1;

  if (t == 3 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 3) + quotient * 100000ull;
    return 3;
  }
  remainder *= mod_inv1;

  if (t == 4 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 4) + quotient * 10000ull;
    return 4;
  }
  remainder *= mod_inv1;

  if (t == 5 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 5) + quotient * 1000ull;
    return 5;
  }
  remainder *= mod_inv1;

  if (t == 6 || remainder * mod_inv1 > max_quotient1) {
    n = (remainder >> 6) + quotient * 100ull;
    return 6;
  }
  remainder *= mod_inv1;

  n = (remainder >> 7) + quotient * 10ull;
  return 7;
}

// The main algorithm for shorter interval case
template <class T>
FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) FMT_NOEXCEPT {
  decimal_fp<T> ret_value;
  // Compute k and beta
  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
  const int beta_minus_1 = exponent + floor_log2_pow10(-minus_k);

  // Compute xi and zi
  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);

  auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(
      cache, beta_minus_1);
  auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
      cache, beta_minus_1);

  // If the left endpoint is not an integer, increase it
  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;

  // Try bigger divisor
  ret_value.significand = zi / 10;

  // If succeed, remove trailing zeros if necessary and return
  if (ret_value.significand * 10 >= xi) {
    ret_value.exponent = minus_k + 1;
    ret_value.exponent += remove_trailing_zeros(ret_value.significand);
    return ret_value;
  }

  // Otherwise, compute the round-up of y
  ret_value.significand =
      cache_accessor<T>::compute_round_up_for_shorter_interval_case(
          cache, beta_minus_1);
  ret_value.exponent = minus_k;

  // When tie occurs, choose one of them according to the rule
  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
      exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
    ret_value.significand = ret_value.significand % 2 == 0
                                ? ret_value.significand
                                : ret_value.significand - 1;
  } else if (ret_value.significand < xi) {
    ++ret_value.significand;
  }
  return ret_value;
}

template <typename T> decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
  // Step 1: integer promotion & Schubfach multiplier calculation.

  using carrier_uint = typename float_info<T>::carrier_uint;
  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
  auto br = bit_cast<carrier_uint>(x);

  // Extract significand bits and exponent bits.
  const carrier_uint significand_mask =
      (static_cast<carrier_uint>(1) << float_info<T>::significand_bits) - 1;
  carrier_uint significand = (br & significand_mask);
  int exponent = static_cast<int>((br & exponent_mask<T>()) >>
                                  float_info<T>::significand_bits);

  if (exponent != 0) {  // Check if normal.
    exponent += float_info<T>::exponent_bias - float_info<T>::significand_bits;

    // Shorter interval case; proceed like Schubfach.
    if (significand == 0) return shorter_interval_case<T>(exponent);

    significand |=
        (static_cast<carrier_uint>(1) << float_info<T>::significand_bits);
  } else {
    // Subnormal case; the interval is always regular.
    if (significand == 0) return {0, 0};
    exponent = float_info<T>::min_exponent - float_info<T>::significand_bits;
  }

  const bool include_left_endpoint = (significand % 2 == 0);
  const bool include_right_endpoint = include_left_endpoint;

  // Compute k and beta.
  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
  const int beta_minus_1 = exponent + floor_log2_pow10(-minus_k);

  // Compute zi and deltai
  // 10^kappa <= deltai < 10^(kappa + 1)
  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta_minus_1);
  const carrier_uint two_fc = significand << 1;
  const carrier_uint two_fr = two_fc | 1;
  const carrier_uint zi =
      cache_accessor<T>::compute_mul(two_fr << beta_minus_1, cache);

  // Step 2: Try larger divisor; remove trailing zeros if necessary

  // Using an upper bound on zi, we might be able to optimize the division
  // better than the compiler; we are computing zi / big_divisor here
  decimal_fp<T> ret_value;
  ret_value.significand = divide_by_10_to_kappa_plus_1(zi);
  uint32_t r = static_cast<uint32_t>(zi - float_info<T>::big_divisor *
                                              ret_value.significand);

  if (r > deltai) {
    goto small_divisor_case_label;
  } else if (r < deltai) {
    // Exclude the right endpoint if necessary
    if (r == 0 && !include_right_endpoint &&
        is_endpoint_integer<T>(two_fr, exponent, minus_k)) {
      --ret_value.significand;
      r = float_info<T>::big_divisor;
      goto small_divisor_case_label;
    }
  } else {
    // r == deltai; compare fractional parts
    // Check conditions in the order different from the paper
    // to take advantage of short-circuiting
    const carrier_uint two_fl = two_fc - 1;
    if ((!include_left_endpoint ||
         !is_endpoint_integer<T>(two_fl, exponent, minus_k)) &&
        !cache_accessor<T>::compute_mul_parity(two_fl, cache, beta_minus_1)) {
      goto small_divisor_case_label;
    }
  }
  ret_value.exponent = minus_k + float_info<T>::kappa + 1;

  // We may need to remove trailing zeros
  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
  return ret_value;

  // Step 3: Find the significand with the smaller divisor

small_divisor_case_label:
  ret_value.significand *= 10;
  ret_value.exponent = minus_k + float_info<T>::kappa;

  const uint32_t mask = (1u << float_info<T>::kappa) - 1;
  auto dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);

  // Is dist divisible by 2^kappa?
  if ((dist & mask) == 0) {
    const bool approx_y_parity =
        ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
    dist >>= float_info<T>::kappa;

    // Is dist divisible by 5^kappa?
    if (check_divisibility_and_divide_by_pow5<float_info<T>::kappa>(dist)) {
      ret_value.significand += dist;

      // Check z^(f) >= epsilon^(f)
      // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
      // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f)
      // Since there are only 2 possibilities, we only need to care about the
      // parity. Also, zi and r should have the same parity since the divisor
      // is an even number
      if (cache_accessor<T>::compute_mul_parity(two_fc, cache, beta_minus_1) !=
          approx_y_parity) {
        --ret_value.significand;
      } else {
        // If z^(f) >= epsilon^(f), we might have a tie
        // when z^(f) == epsilon^(f), or equivalently, when y is an integer
        if (is_center_integer<T>(two_fc, exponent, minus_k)) {
          ret_value.significand = ret_value.significand % 2 == 0
                                      ? ret_value.significand
                                      : ret_value.significand - 1;
        }
      }
    }
    // Is dist not divisible by 5^kappa?
    else {
      ret_value.significand += dist;
    }
  }
  // Is dist not divisible by 2^kappa?
  else {
    // Since we know dist is small, we might be able to optimize the division
    // better than the compiler; we are computing dist / small_divisor here
    ret_value.significand +=
        small_division_by_pow10<float_info<T>::kappa>(dist);
  }
  return ret_value;
}
}  // namespace dragonbox

// Formats value using a variation of the Fixed-Precision Positive
// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
// https://fmt.dev/papers/p372-steele.pdf.
template <typename Double>
void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
                     int& exp10) {
  bigint numerator;    // 2 * R in (FPP)^2.
  bigint denominator;  // 2 * S in (FPP)^2.
  // lower and upper are differences between value and corresponding boundaries.
  bigint lower;             // (M^- in (FPP)^2).
  bigint upper_store;       // upper's value if different from lower.
  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
  fp value;
  // Shift numerator and denominator by an extra bit or two (if lower boundary
  // is closer) to make lower and upper integers. This eliminates multiplication
  // by 2 during later computations.
  const bool is_predecessor_closer =
      binary32 ? value.assign(static_cast<float>(d)) : value.assign(d);
  int shift = is_predecessor_closer ? 2 : 1;
  uint64_t significand = value.f << shift;
  if (value.e >= 0) {
    numerator.assign(significand);
    numerator <<= value.e;
    lower.assign(1);
    lower <<= value.e;
    if (shift != 1) {
      upper_store.assign(1);
      upper_store <<= value.e + 1;
      upper = &upper_store;
    }
    denominator.assign_pow10(exp10);
    denominator <<= shift;
  } else if (exp10 < 0) {
    numerator.assign_pow10(-exp10);
    lower.assign(numerator);
    if (shift != 1) {
      upper_store.assign(numerator);
      upper_store <<= 1;
      upper = &upper_store;
    }
    numerator *= significand;
    denominator.assign(1);
    denominator <<= shift - value.e;
  } else {
    numerator.assign(significand);
    denominator.assign_pow10(exp10);
    denominator <<= shift - value.e;
    lower.assign(1);
    if (shift != 1) {
      upper_store.assign(1ULL << 1);
      upper = &upper_store;
    }
  }
  // Invariant: value == (numerator / denominator) * pow(10, exp10).
  if (num_digits < 0) {
    // Generate the shortest representation.
    if (!upper) upper = &lower;
    bool even = (value.f & 1) == 0;
    num_digits = 0;
    char* data = buf.data();
    for (;;) {
      int digit = numerator.divmod_assign(denominator);
      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
      // numerator + upper >[=] pow10:
      bool high = add_compare(numerator, *upper, denominator) + even > 0;
      data[num_digits++] = static_cast<char>('0' + digit);
      if (low || high) {
        if (!low) {
          ++data[num_digits - 1];
        } else if (high) {
          int result = add_compare(numerator, numerator, denominator);
          // Round half to even.
          if (result > 0 || (result == 0 && (digit % 2) != 0))
            ++data[num_digits - 1];
        }
        buf.try_resize(to_unsigned(num_digits));
        exp10 -= num_digits - 1;
        return;
      }
      numerator *= 10;
      lower *= 10;
      if (upper != &lower) *upper *= 10;
    }
  }
  // Generate the given number of digits.
  exp10 -= num_digits - 1;
  if (num_digits == 0) {
    buf.try_resize(1);
    denominator *= 10;
    buf[0] = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
    return;
  }
  buf.try_resize(to_unsigned(num_digits));
  for (int i = 0; i < num_digits - 1; ++i) {
    int digit = numerator.divmod_assign(denominator);
    buf[i] = static_cast<char>('0' + digit);
    numerator *= 10;
  }
  int digit = numerator.divmod_assign(denominator);
  auto result = add_compare(numerator, numerator, denominator);
  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
    if (digit == 9) {
      const auto overflow = '0' + 10;
      buf[num_digits - 1] = overflow;
      // Propagate the carry.
      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
        buf[i] = '0';
        ++buf[i - 1];
      }
      if (buf[0] == overflow) {
        buf[0] = '1';
        ++exp10;
      }
      return;
    }
    ++digit;
  }
  buf[num_digits - 1] = static_cast<char>('0' + digit);
}

template <typename T>
int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
  static_assert(!std::is_same<T, float>::value, "");
  FMT_ASSERT(value >= 0, "value is negative");

  const bool fixed = specs.format == float_format::fixed;
  if (value <= 0) {  // <= instead of == to silence a warning.
    if (precision <= 0 || !fixed) {
      buf.push_back('0');
      return 0;
    }
    buf.try_resize(to_unsigned(precision));
    std::uninitialized_fill_n(buf.data(), precision, '0');
    return -precision;
  }

  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);

  if (precision < 0) {
    // Use Dragonbox for the shortest format.
    if (specs.binary32) {
      auto dec = dragonbox::to_decimal(static_cast<float>(value));
      write<char>(buffer_appender<char>(buf), dec.significand);
      return dec.exponent;
    }
    auto dec = dragonbox::to_decimal(static_cast<double>(value));
    write<char>(buffer_appender<char>(buf), dec.significand);
    return dec.exponent;
  }

  // Use Grisu + Dragon4 for the given precision:
  // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
  int exp = 0;
  const int min_exp = -60;  // alpha in Grisu.
  int cached_exp10 = 0;     // K in Grisu.
  fp normalized = normalize(fp(value));
  const auto cached_pow = get_cached_power(
      min_exp - (normalized.e + fp::significand_size), cached_exp10);
  normalized = normalized * cached_pow;
  // Limit precision to the maximum possible number of significant digits in an
  // IEEE754 double because we don't need to generate zeros.
  const int max_double_digits = 767;
  if (precision > max_double_digits) precision = max_double_digits;
  fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
  if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error) {
    exp += handler.size - cached_exp10 - 1;
    fallback_format(value, handler.precision, specs.binary32, buf, exp);
  } else {
    exp += handler.exp10;
    buf.try_resize(to_unsigned(handler.size));
  }
  if (!fixed && !specs.showpoint) {
    // Remove trailing zeros.
    auto num_digits = buf.size();
    while (num_digits > 0 && buf[num_digits - 1] == '0') {
      --num_digits;
      ++exp;
    }
    buf.try_resize(num_digits);
  }
  return exp;
}  // namespace detail

template <typename T>
int snprintf_float(T value, int precision, float_specs specs,
                   buffer<char>& buf) {
  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
  static_assert(!std::is_same<T, float>::value, "");

  // Subtract 1 to account for the difference in precision since we use %e for
  // both general and exponent format.
  if (specs.format == float_format::general ||
      specs.format == float_format::exp)
    precision = (precision >= 0 ? precision : 6) - 1;

  // Build the format string.
  enum { max_format_size = 7 };  // The longest format is "%#.*Le".
  char format[max_format_size];
  char* format_ptr = format;
  *format_ptr++ = '%';
  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
  if (precision >= 0) {
    *format_ptr++ = '.';
    *format_ptr++ = '*';
  }
  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
  *format_ptr++ = specs.format != float_format::hex
                      ? (specs.format == float_format::fixed ? 'f' : 'e')
                      : (specs.upper ? 'A' : 'a');
  *format_ptr = '\0';

  // Format using snprintf.
  auto offset = buf.size();
  for (;;) {
    auto begin = buf.data() + offset;
    auto capacity = buf.capacity() - offset;
#ifdef FMT_FUZZ
    if (precision > 100000)
      throw std::runtime_error(
          "fuzz mode - avoid large allocation inside snprintf");
#endif
    // Suppress the warning about a nonliteral format string.
    // Cannot use auto because of a bug in MinGW (#1532).
    int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
    int result = precision >= 0
                     ? snprintf_ptr(begin, capacity, format, precision, value)
                     : snprintf_ptr(begin, capacity, format, value);
    if (result < 0) {
      // The buffer will grow exponentially.
      buf.try_reserve(buf.capacity() + 1);
      continue;
    }
    auto size = to_unsigned(result);
    // Size equal to capacity means that the last character was truncated.
    if (size >= capacity) {
      buf.try_reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
      continue;
    }
    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
    if (specs.format == float_format::fixed) {
      if (precision == 0) {
        buf.try_resize(size);
        return 0;
      }
      // Find and remove the decimal point.
      auto end = begin + size, p = end;
      do {
        --p;
      } while (is_digit(*p));
      int fraction_size = static_cast<int>(end - p - 1);
      std::memmove(p, p + 1, to_unsigned(fraction_size));
      buf.try_resize(size - 1);
      return -fraction_size;
    }
    if (specs.format == float_format::hex) {
      buf.try_resize(size + offset);
      return 0;
    }
    // Find and parse the exponent.
    auto end = begin + size, exp_pos = end;
    do {
      --exp_pos;
    } while (*exp_pos != 'e');
    char sign = exp_pos[1];
    FMT_ASSERT(sign == '+' || sign == '-', "");
    int exp = 0;
    auto p = exp_pos + 2;  // Skip 'e' and sign.
    do {
      FMT_ASSERT(is_digit(*p), "");
      exp = exp * 10 + (*p++ - '0');
    } while (p != end);
    if (sign == '-') exp = -exp;
    int fraction_size = 0;
    if (exp_pos != begin + 1) {
      // Remove trailing zeros.
      auto fraction_end = exp_pos - 1;
      while (*fraction_end == '0') --fraction_end;
      // Move the fractional part left to get rid of the decimal point.
      fraction_size = static_cast<int>(fraction_end - begin - 1);
      std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
    }
    buf.try_resize(to_unsigned(fraction_size) + offset + 1);
    return exp - fraction_size;
  }
}
}  // namespace detail

template <> struct formatter<detail::bigint> {
  FMT_CONSTEXPR format_parse_context::iterator parse(
      format_parse_context& ctx) {
    return ctx.begin();
  }

  format_context::iterator format(const detail::bigint& n,
                                  format_context& ctx) {
    auto out = ctx.out();
    bool first = true;
    for (auto i = n.bigits_.size(); i > 0; --i) {
      auto value = n.bigits_[i - 1u];
      if (first) {
        out = format_to(out, FMT_STRING("{:x}"), value);
        first = false;
        continue;
      }
      out = format_to(out, FMT_STRING("{:08x}"), value);
    }
    if (n.exp_ > 0)
      out = format_to(out, FMT_STRING("p{}"),
                      n.exp_ * detail::bigint::bigit_bits);
    return out;
  }
};

FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
  for_each_codepoint(s, [this](uint32_t cp, int error) {
    if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
    if (cp <= 0xFFFF) {
      buffer_.push_back(static_cast<wchar_t>(cp));
    } else {
      cp -= 0x10000;
      buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
      buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
    }
  });
  buffer_.push_back(0);
}

FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
                                  const char* message) FMT_NOEXCEPT {
  FMT_TRY {
    auto ec = std::error_code(error_code, std::generic_category());
    write(std::back_inserter(out), std::system_error(ec, message).what());
    return;
  }
  FMT_CATCH(...) {}
  format_error_code(out, error_code, message);
}

FMT_FUNC void detail::error_handler::on_error(const char* message) {
  FMT_THROW(format_error(message));
}

FMT_FUNC void report_system_error(int error_code,
                                  const char* message) FMT_NOEXCEPT {
  report_error(format_system_error, error_code, message);
}

FMT_FUNC std::string vformat(string_view fmt, format_args args) {
  // Don't optimize the "{}" case to keep the binary size small and because it
  // can be better optimized in fmt::format anyway.
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, fmt, args);
  return to_string(buffer);
}

#ifdef _WIN32
namespace detail {
using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
    void*, const void*, dword, dword*, void*);
}  // namespace detail
#endif

namespace detail {
FMT_FUNC void print(std::FILE* f, string_view text) {
#ifdef _WIN32
  auto fd = _fileno(f);
  if (_isatty(fd)) {
    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
    auto written = detail::dword();
    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
                              u16.c_str(), static_cast<uint32_t>(u16.size()),
                              &written, nullptr)) {
      return;
    }
    // Fallback to fwrite on failure. It can happen if the output has been
    // redirected to NUL.
  }
#endif
  detail::fwrite_fully(text.data(), 1, text.size(), f);
}
}  // namespace detail

FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
  memory_buffer buffer;
  detail::vformat_to(buffer, format_str, args);
  detail::print(f, {buffer.data(), buffer.size()});
}

#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
                                      format_args args) {
  memory_buffer buffer;
  detail::vformat_to(buffer, format_str,
                     basic_format_args<buffer_context<char>>(args));
  fwrite_fully(buffer.data(), 1, buffer.size(), f);
}
#endif

FMT_FUNC void vprint(string_view format_str, format_args args) {
  vprint(stdout, format_str, args);
}

FMT_END_NAMESPACE

#endif  // FMT_FORMAT_INL_H_


================================================
FILE: examples/libraries/fmt/include/fmt/format.h
================================================
/*
 Formatting library for C++

 Copyright (c) 2012 - present, Victor Zverovich

 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.

 --- Optional exception to the license ---

 As an exception, if, as a result of your compiling your source code, portions
 of this Software are embedded into a machine-executable object form of such
 source code, you may redistribute such embedded portions in such object form
 without including the above copyright and permission notices.
 */

#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_

#include <cmath>         // std::signbit
#include <cstdint>       // uint32_t
#include <limits>        // std::numeric_limits
#include <memory>        // std::uninitialized_copy
#include <stdexcept>     // std::runtime_error
#include <system_error>  // std::system_error
#include <utility>       // std::swap

#include "core.h"

#ifdef __INTEL_COMPILER
#  define FMT_ICC_VERSION __INTEL_COMPILER
#elif defined(__ICL)
#  define FMT_ICC_VERSION __ICL
#else
#  define FMT_ICC_VERSION 0
#endif

#ifdef __NVCC__
#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
#else
#  define FMT_CUDA_VERSION 0
#endif

#ifdef __has_builtin
#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
#  define FMT_HAS_BUILTIN(x) 0
#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_NOINLINE __attribute__((noinline))
#else
#  define FMT_NOINLINE
#endif

#if FMT_MSC_VER
#  define FMT_MSC_DEFAULT = default
#else
#  define FMT_MSC_DEFAULT
#endif

#ifndef FMT_THROW
#  if FMT_EXCEPTIONS
#    if FMT_MSC_VER || FMT_NVCC
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Exception> inline void do_throw(const Exception& x) {
  // Silence unreachable code warnings in MSVC and NVCC because these
  // are nearly impossible to fix in a generic code.
  volatile bool b = true;
  if (b) throw x;
}
}  // namespace detail
FMT_END_NAMESPACE
#      define FMT_THROW(x) detail::do_throw(x)
#    else
#      define FMT_THROW(x) throw x
#    endif
#  else
#    define FMT_THROW(x)               \
      do {                             \
        FMT_ASSERT(false, (x).what()); \
      } while (false)
#  endif
#endif

#if FMT_EXCEPTIONS
#  define FMT_TRY try
#  define FMT_CATCH(x) catch (x)
#else
#  define FMT_TRY if (true)
#  define FMT_CATCH(x) if (false)
#endif

#ifndef FMT_DEPRECATED
#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
#    define FMT_DEPRECATED [[deprecated]]
#  else
#    if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
#      define FMT_DEPRECATED __attribute__((deprecated))
#    elif FMT_MSC_VER
#      define FMT_DEPRECATED __declspec(deprecated)
#    else
#      define FMT_DEPRECATED /* deprecated */
#    endif
#  endif
#endif

// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC
#  define FMT_DEPRECATED_ALIAS
#else
#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
#endif

#ifndef FMT_USE_USER_DEFINED_LITERALS
// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
       FMT_MSC_VER >= 1900) &&                                         \
      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
#    define FMT_USE_USER_DEFINED_LITERALS 1
#  else
#    define FMT_USE_USER_DEFINED_LITERALS 0
#  endif
#endif

// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
// integer formatter template instantiations to just one by only using the
// largest integer type. This results in a reduction in binary size but will
// cause a decrease in integer formatting performance.
#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)
#  define FMT_REDUCE_INT_INSTANTIATIONS 0
#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
#endif
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
#endif
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctz))
#  define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
#endif
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctzll))
#  define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
#endif

#if FMT_MSC_VER
#  include <intrin.h>  // _BitScanReverse[64], _BitScanForward[64], _umul128
#endif

// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
// MSVC intrinsics if the clz and clzll builtins are not available.
#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(FMT_BUILTIN_CTZLL)
FMT_BEGIN_NAMESPACE
namespace detail {
// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
#  if !defined(__clang__)
#    pragma managed(push, off)
#    pragma intrinsic(_BitScanForward)
#    pragma intrinsic(_BitScanReverse)
#    if defined(_WIN64)
#      pragma intrinsic(_BitScanForward64)
#      pragma intrinsic(_BitScanReverse64)
#    endif
#  endif

inline auto clz(uint32_t x) -> int {
  unsigned long r = 0;
  _BitScanReverse(&r, x);
  FMT_ASSERT(x != 0, "");
  // Static analysis complains about using uninitialized data
  // "r", but the only way that can happen is if "x" is 0,
  // which the callers guarantee to not happen.
  FMT_MSC_WARNING(suppress : 6102)
  return 31 ^ static_cast<int>(r);
}
#  define FMT_BUILTIN_CLZ(n) detail::clz(n)

inline auto clzll(uint64_t x) -> int {
  unsigned long r = 0;
#  ifdef _WIN64
  _BitScanReverse64(&r, x);
#  else
  // Scan the high 32 bits.
  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 ^ (r + 32);
  // Scan the low 32 bits.
  _BitScanReverse(&r, static_cast<uint32_t>(x));
#  endif
  FMT_ASSERT(x != 0, "");
  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
  return 63 ^ static_cast<int>(r);
}
#  define FMT_BUILTIN_CLZLL(n) detail::clzll(n)

inline auto ctz(uint32_t x) -> int {
  unsigned long r = 0;
  _BitScanForward(&r, x);
  FMT_ASSERT(x != 0, "");
  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
  return static_cast<int>(r);
}
#  define FMT_BUILTIN_CTZ(n) detail::ctz(n)

inline auto ctzll(uint64_t x) -> int {
  unsigned long r = 0;
  FMT_ASSERT(x != 0, "");
  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
#  ifdef _WIN64
  _BitScanForward64(&r, x);
#  else
  // Scan the low 32 bits.
  if (_BitScanForward(&r, static_cast<uint32_t>(x))) return static_cast<int>(r);
  // Scan the high 32 bits.
  _BitScanForward(&r, static_cast<uint32_t>(x >> 32));
  r += 32;
#  endif
  return static_cast<int>(r);
}
#  define FMT_BUILTIN_CTZLL(n) detail::ctzll(n)
#  if !defined(__clang__)
#    pragma managed(pop)
#  endif
}  // namespace detail
FMT_END_NAMESPACE
#endif

FMT_BEGIN_NAMESPACE
namespace detail {

#if __cplusplus >= 202002L || \
    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
#  define FMT_CONSTEXPR20 constexpr
#else
#  define FMT_CONSTEXPR20
#endif

// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
// undefined behavior (e.g. due to type aliasing).
// Example: uint64_t d = bit_cast<uint64_t>(2.718);
template <typename Dest, typename Source>
inline auto bit_cast(const Source& source) -> Dest {
  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
  Dest dest;
  std::memcpy(&dest, &source, sizeof(dest));
  return dest;
}

inline auto is_big_endian() -> bool {
  const auto u = 1u;
  struct bytes {
    char data[sizeof(u)];
  };
  return bit_cast<bytes>(u).data[0] == 0;
}

// A fallback implementation of uintptr_t for systems that lack it.
struct fallback_uintptr {
  unsigned char value[sizeof(void*)];

  fallback_uintptr() = default;
  explicit fallback_uintptr(const void* p) {
    *this = bit_cast<fallback_uintptr>(p);
    if (is_big_endian()) {
      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
        std::swap(value[i], value[j]);
    }
  }
};
#ifdef UINTPTR_MAX
using uintptr_t = ::uintptr_t;
inline auto to_uintptr(const void* p) -> uintptr_t {
  return bit_cast<uintptr_t>(p);
}
#else
using uintptr_t = fallback_uintptr;
inline auto to_uintptr(const void* p) -> fallback_uintptr {
  return fallback_uintptr(p);
}
#endif

// Returns the largest possible value for type T. Same as
// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
template <typename T> constexpr auto max_value() -> T {
  return (std::numeric_limits<T>::max)();
}
template <typename T> constexpr auto num_bits() -> int {
  return std::numeric_limits<T>::digits;
}
// std::numeric_limits<T>::digits may return 0 for 128-bit ints.
template <> constexpr auto num_bits<int128_t>() -> int { return 128; }
template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
template <> constexpr auto num_bits<fallback_uintptr>() -> int {
  return static_cast<int>(sizeof(void*) *
                          std::numeric_limits<unsigned char>::digits);
}

FMT_INLINE void assume(bool condition) {
  (void)condition;
#if FMT_HAS_BUILTIN(__builtin_assume)
  __builtin_assume(condition);
#endif
}

// An approximation of iterator_t for pre-C++20 systems.
template <typename T>
using iterator_t = decltype(std::begin(std::declval<T&>()));
template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));

// A workaround for std::string not having mutable data() until C++17.
template <typename Char>
inline auto get_data(std::basic_string<Char>& s) -> Char* {
  return &s[0];
}
template <typename Container>
inline auto get_data(Container& c) -> typename Container::value_type* {
  return c.data();
}

#if defined(_SECURE_SCL) && _SECURE_SCL
// Make a checked iterator to avoid MSVC warnings.
template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
template <typename T> auto make_checked(T* p, size_t size) -> checked_ptr<T> {
  return {p, size};
}
#else
template <typename T> using checked_ptr = T*;
template <typename T> inline auto make_checked(T* p, size_t) -> T* { return p; }
#endif

// Attempts to reserve space for n extra characters in the output range.
// Returns a pointer to the reserved range or a reference to it.
template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
__attribute__((no_sanitize("undefined")))
#endif
inline auto
reserve(std::back_insert_iterator<Container> it, size_t n)
    -> checked_ptr<typename Container::value_type> {
  Container& c = get_container(it);
  size_t size = c.size();
  c.resize(size + n);
  return make_checked(get_data(c) + size, n);
}

template <typename T>
inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
  buffer<T>& buf = get_container(it);
  buf.try_reserve(buf.size() + n);
  return it;
}

template <typename Iterator>
constexpr auto reserve(Iterator& it, size_t) -> Iterator& {
  return it;
}

template <typename OutputIt>
using reserve_iterator =
    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;

template <typename T, typename OutputIt>
constexpr auto to_pointer(OutputIt, size_t) -> T* {
  return nullptr;
}
template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
  buffer<T>& buf = get_container(it);
  auto size = buf.size();
  if (buf.capacity() < size + n) return nullptr;
  buf.try_resize(size + n);
  return buf.data() + size;
}

template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
inline auto base_iterator(std::back_insert_iterator<Container>& it,
                          checked_ptr<typename Container::value_type>)
    -> std::back_insert_iterator<Container> {
  return it;
}

template <typename Iterator>
constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
  return it;
}

// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n
// instead (#1998).
template <typename OutputIt, typename Size, typename T>
FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
    -> OutputIt {
  for (Size i = 0; i < count; ++i) *out++ = value;
  return out;
}
template <typename T, typename Size>
FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {
  if (is_constant_evaluated()) {
    return fill_n<T*, Size, T>(out, count, value);
  }
  std::memset(out, value, to_unsigned(count));
  return out + count;
}

#ifdef __cpp_char8_t
using char8_type = char8_t;
#else
enum char8_type : unsigned char {};
#endif

template <typename OutChar, typename InputIt, typename OutputIt>
FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,
                                                  OutputIt out) -> OutputIt {
  return copy_str<OutChar>(begin, end, out);
}

// A public domain branchless UTF-8 decoder by Christopher Wellons:
// https://github.com/skeeto/branchless-utf8
/* Decode the next character, c, from s, reporting errors in e.
 *
 * Since this is a branchless decoder, four bytes will be read from the
 * buffer regardless of the actual length of the next character. This
 * means the buffer _must_ have at least three bytes of zero padding
 * following the end of the data stream.
 *
 * Errors are reported in e, which will be non-zero if the parsed
 * character was somehow invalid: invalid byte sequence, non-canonical
 * encoding, or a surrogate half.
 *
 * The function returns a pointer to the next character. When an error
 * occurs, this pointer will be a guess that depends on the particular
 * error, but it will always advance at least one byte.
 */
FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)
    -> const char* {
  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
  constexpr const int shiftc[] = {0, 18, 12, 6, 0};
  constexpr const int shifte[] = {0, 6, 4, 2, 0};

  int len = code_point_length(s);
  const char* next = s + len;

  // Assume a four-byte character and load four bytes. Unused bits are
  // shifted out.
  *c = uint32_t(s[0] & masks[len]) << 18;
  *c |= uint32_t(s[1] & 0x3f) << 12;
  *c |= uint32_t(s[2] & 0x3f) << 6;
  *c |= uint32_t(s[3] & 0x3f) << 0;
  *c >>= shiftc[len];

  // Accumulate the various error conditions.
  using uchar = unsigned char;
  *e = (*c < mins[len]) << 6;       // non-canonical encoding
  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
  *e |= (*c > 0x10FFFF) << 8;       // out of range?
  *e |= (uchar(s[1]) & 0xc0) >> 2;
  *e |= (uchar(s[2]) & 0xc0) >> 4;
  *e |= uchar(s[3]) >> 6;
  *e ^= 0x2a;  // top two bits of each tail byte correct?
  *e >>= shifte[len];

  return next;
}

template <typename F>
FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
  auto decode = [f](const char* p) {
    auto cp = uint32_t();
    auto error = 0;
    p = utf8_decode(p, &cp, &error);
    f(cp, error);
    return p;
  };
  auto p = s.data();
  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.
  if (s.size() >= block_size) {
    for (auto end = p + s.size() - block_size + 1; p < end;) p = decode(p);
  }
  if (auto num_chars_left = s.data() + s.size() - p) {
    char buf[2 * block_size - 1] = {};
    copy_str<char>(p, p + num_chars_left, buf);
    p = buf;
    do {
      p = decode(p);
    } while (p - buf < num_chars_left);
  }
}

template <typename Char>
inline auto compute_width(basic_string_view<Char> s) -> size_t {
  return s.size();
}

// Computes approximate display width of a UTF-8 string.
FMT_CONSTEXPR inline size_t compute_width(string_view s) {
  size_t num_code_points = 0;
  // It is not a lambda for compatibility with C++14.
  struct count_code_points {
    size_t* count;
    FMT_CONSTEXPR void operator()(uint32_t cp, int error) const {
      *count += detail::to_unsigned(
          1 +
          (error == 0 && cp >= 0x1100 &&
           (cp <= 0x115f ||  // Hangul Jamo init. consonants
            cp == 0x2329 ||  // LEFT-POINTING ANGLE BRACKET
            cp == 0x232a ||  // RIGHT-POINTING ANGLE BRACKET
            // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
            (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
            (cp >= 0xac00 && cp <= 0xd7a3) ||    // Hangul Syllables
            (cp >= 0xf900 && cp <= 0xfaff) ||    // CJK Compatibility Ideographs
            (cp >= 0xfe10 && cp <= 0xfe19) ||    // Vertical Forms
            (cp >= 0xfe30 && cp <= 0xfe6f) ||    // CJK Compatibility Forms
            (cp >= 0xff00 && cp <= 0xff60) ||    // Fullwidth Forms
            (cp >= 0xffe0 && cp <= 0xffe6) ||    // Fullwidth Forms
            (cp >= 0x20000 && cp <= 0x2fffd) ||  // CJK
            (cp >= 0x30000 && cp <= 0x3fffd) ||
            // Miscellaneous Symbols and Pictographs + Emoticons:
            (cp >= 0x1f300 && cp <= 0x1f64f) ||
            // Supplemental Symbols and Pictographs:
            (cp >= 0x1f900 && cp <= 0x1f9ff))));
    }
  };
  for_each_codepoint(s, count_code_points{&num_code_points});
  return num_code_points;
}

inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
  return compute_width(basic_string_view<char>(
      reinterpret_cast<const char*>(s.data()), s.size()));
}

template <typename Char>
inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
  size_t size = s.size();
  return n < size ? n : size;
}

// Calculates the index of the nth code point in a UTF-8 string.
inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
    -> size_t {
  const char8_type* data = s.data();
  size_t num_code_points = 0;
  for (size_t i = 0, size = s.size(); i != size; ++i) {
    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
  }
  return s.size();
}

template <typename T>
using is_fast_float = bool_constant<std::numeric_limits<T>::is_iec559 &&
                                    sizeof(T) <= sizeof(double)>;

#ifndef FMT_USE_FULL_CACHE_DRAGONBOX
#  define FMT_USE_FULL_CACHE_DRAGONBOX 0
#endif

template <typename T>
template <typename U>
void buffer<T>::append(const U* begin, const U* end) {
  while (begin != end) {
    auto count = to_unsigned(end - begin);
    try_reserve(size_ + count);
    auto free_cap = capacity_ - size_;
    if (free_cap < count) count = free_cap;
    std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
    size_ += count;
    begin += count;
  }
}

template <typename T, typename Enable = void>
struct is_locale : std::false_type {};
template <typename T>
struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};
}  // namespace detail

FMT_MODULE_EXPORT_BEGIN

// The number of characters to store in the basic_memory_buffer object itself
// to avoid dynamic memory allocation.
enum { inline_buffer_size = 500 };

/**
  \rst
  A dynamically growing memory buffer for trivially copyable/constructible types
  with the first ``SIZE`` elements stored in the object itself.

  You can use the ``memory_buffer`` type alias for ``char`` instead.

  **Example**::

     fmt::memory_buffer out;
     format_to(out, "The answer is {}.", 42);

  This will append the following output to the ``out`` object:

  .. code-block:: none

     The answer is 42.

  The output can be converted to an ``std::string`` with ``to_string(out)``.
  \endrst
 */
template <typename T, size_t SIZE = inline_buffer_size,
          typename Allocator = std::allocator<T>>
class basic_memory_buffer final : public detail::buffer<T> {
 private:
  T store_[SIZE];

  // Don't inherit from Allocator avoid generating type_info for it.
  Allocator alloc_;

  // Deallocate memory allocated by the buffer.
  void deallocate() {
    T* data = this->data();
    if (data != store_) alloc_.deallocate(data, this->capacity());
  }

 protected:
  void grow(size_t size) final FMT_OVERRIDE;

 public:
  using value_type = T;
  using const_reference = const T&;

  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
      : alloc_(alloc) {
    this->set(store_, SIZE);
  }
  ~basic_memory_buffer() { deallocate(); }

 private:
  // Move data from other to this buffer.
  void move(basic_memory_buffer& other) {
    alloc_ = std::move(other.alloc_);
    T* data = other.data();
    size_t size = other.size(), capacity = other.capacity();
    if (data == other.store_) {
      this->set(store_, capacity);
      std::uninitialized_copy(other.store_, other.store_ + size,
                              detail::make_checked(store_, capacity));
    } else {
      this->set(data, capacity);
      // Set pointer to the inline array so that delete is not called
      // when deallocating.
      other.set(other.store_, 0);
    }
    this->resize(size);
  }

 public:
  /**
    \rst
    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
    of the other object to it.
    \endrst
   */
  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }

  /**
    \rst
    Moves the content of the other ``basic_memory_buffer`` object to this one.
    \endrst
   */
  auto operator=(basic_memory_buffer&& other) FMT_NOEXCEPT
      -> basic_memory_buffer& {
    FMT_ASSERT(this != &other, "");
    deallocate();
    move(other);
    return *this;
  }

  // Returns a copy of the allocator associated with this buffer.
  auto get_allocator() const -> Allocator { return alloc_; }

  /**
    Resizes the buffer to contain *count* elements. If T is a POD type new
    elements may not be initialized.
   */
  void resize(size_t count) { this->try_resize(count); }

  /** Increases the buffer capacity to *new_capacity*. */
  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }

  // Directly append data into the buffer
  using detail::buffer<T>::append;
  template <typename ContiguousRange>
  void append(const ContiguousRange& range) {
    append(range.data(), range.data() + range.size());
  }
};

template <typename T, size_t SIZE, typename Allocator>
void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
#ifdef FMT_FUZZ
  if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
  const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
  size_t old_capacity = this->capacity();
  size_t new_capacity = old_capacity + old_capacity / 2;
  if (size > new_capacity)
    new_capacity = size;
  else if (new_capacity > max_size)
    new_capacity = size > max_size ? size : max_size;
  T* old_data = this->data();
  T* new_data =
      std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
  // The following code doesn't throw, so the raw pointer above doesn't leak.
  std::uninitialized_copy(old_data, old_data + this->size(),
                          detail::make_checked(new_data, new_capacity));
  this->set(new_data, new_capacity);
  // deallocate must not throw according to the standard, but even if it does,
  // the buffer already uses the new storage and will deallocate it in
  // destructor.
  if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
}

using memory_buffer = basic_memory_buffer<char>;

template <typename T, size_t SIZE, typename Allocator>
struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
};

namespace detail {
FMT_API void print(std::FILE*, string_view);
}

/** A formatting error such as invalid format string. */
FMT_CLASS_API
class FMT_API format_error : public std::runtime_error {
 public:
  explicit format_error(const char* message) : std::runtime_error(message) {}
  explicit format_error(const std::string& message)
      : std::runtime_error(message) {}
  format_error(const format_error&) = default;
  format_error& operator=(const format_error&) = default;
  format_error(format_error&&) = default;
  format_error& operator=(format_error&&) = default;
  ~format_error() FMT_NOEXCEPT FMT_OVERRIDE FMT_MSC_DEFAULT;
};

/**
  \rst
  Constructs a `~fmt::format_arg_store` object that contains references
  to arguments and can be implicitly converted to `~fmt::format_args`.
  If ``fmt`` is a compile-time string then `make_args_checked` checks
  its validity at compile time.
  \endrst
 */
template <typename... Args, typename S, typename Char = char_t<S>>
FMT_INLINE auto make_args_checked(const S& fmt,
                                  const remove_reference_t<Args>&... args)
    -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...> {
  static_assert(
      detail::count<(
              std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
              std::is_reference<Args>::value)...>() == 0,
      "passing views as lvalues is disallowed");
  detail::check_format_string<Args...>(fmt);
  return {args...};
}

// compile-time support
namespace detail_exported {
#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
template <typename Char, size_t N> struct fixed_string {
  constexpr fixed_string(const Char (&str)[N]) {
    detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),
                                               str + N, data);
  }
  Char data[N]{};
};
#endif

// Converts a compile-time string to basic_string_view.
template <typename Char, size_t N>
constexpr auto compile_string_to_view(const Char (&s)[N])
    -> basic_string_view<Char> {
  // Remove trailing NUL character if needed. Won't be present if this is used
  // with a raw character array (i.e. not defined as a string).
  return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
}
template <typename Char>
constexpr auto compile_string_to_view(detail::std_string_view<Char> s)
    -> basic_string_view<Char> {
  return {s.data(), s.size()};
}
}  // namespace detail_exported

FMT_BEGIN_DETAIL_NAMESPACE

inline void throw_format_error(const char* message) {
  FMT_THROW(format_error(message));
}

template <typename T> struct is_integral : std::is_integral<T> {};
template <> struct is_integral<int128_t> : std::true_type {};
template <> struct is_integral<uint128_t> : std::true_type {};

template <typename T>
using is_signed =
    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
                                     std::is_same<T, int128_t>::value>;

// Returns true if value is negative, false otherwise.
// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
template <typename T, FMT_ENABLE_IF(is_signed<T>::value)>
FMT_CONSTEXPR auto is_negative(T value) -> bool {
  return value < 0;
}
template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
FMT_CONSTEXPR auto is_negative(T) -> bool {
  return false;
}

template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
FMT_CONSTEXPR auto is_supported_floating_point(T) -> uint16_t {
  return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
         (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
         (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
}

// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
// represent all values of an integral type T.
template <typename T>
using uint32_or_64_or_128_t =
    conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,
                  uint32_t,
                  conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
template <typename T>
using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;

#define FMT_POWERS_OF_10(factor)                                             \
  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
      (factor)*1000000000

// Static data is placed in this class template for the header-only config.
template <typename T = void> struct basic_data {
  // log10(2) = 0x0.4d104d427de7fbcc...
  static const uint64_t log10_2_significand = 0x4d104d427de7fbcc;

  // GCC generates slightly better code for pairs than chars.
  FMT_API static constexpr const char digits[100][2] = {
      {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'},
      {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'}, {'1', '0'}, {'1', '1'},
      {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'},
      {'1', '8'}, {'1', '9'}, {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'},
      {'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
      {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'},
      {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'}, {'4', '0'}, {'4', '1'},
      {'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'},
      {'4', '8'}, {'4', '9'}, {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'},
      {'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
      {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'},
      {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'}, {'7', '0'}, {'7', '1'},
      {'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'},
      {'7', '8'}, {'7', '9'}, {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'},
      {'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
      {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'},
      {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}};

  FMT_API static constexpr const char hex_digits[] = "0123456789abcdef";
  FMT_API static constexpr const char signs[4] = {0, '-', '+', ' '};
  FMT_API static constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
                                                         0x1000000u | ' '};
  FMT_API static constexpr const char left_padding_shifts[5] = {31, 31, 0, 1,
                                                                0};
  FMT_API static constexpr const char right_padding_shifts[5] = {0, 31, 0, 1,
                                                                 0};
};

#ifdef FMT_SHARED
// Required for -flto, -fivisibility=hidden and -shared to work
extern template struct basic_data<void>;
#endif

// This is a struct rather than an alias to avoid shadowing warnings in gcc.
struct data : basic_data<> {};

template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
  int count = 1;
  for (;;) {
    // Integer division is slow so do it for a group of four digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000u;
    count += 4;
  }
}
#if FMT_USE_INT128
FMT_CONSTEXPR inline auto count_digits(uint128_t n) -> int {
  return count_digits_fallback(n);
}
#endif

// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
#ifdef FMT_BUILTIN_CLZLL
  if (!is_constant_evaluated()) {
    // https://github.com/fmtlib/format-benchmark/blob/master/digits10
    // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
    constexpr uint16_t bsr2log10[] = {
        1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
        6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
        10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
        15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
    auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
    constexpr const uint64_t zero_or_powers_of_10[] = {
        0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
        10000000000000000000ULL};
    return t - (n < zero_or_powers_of_10[t]);
  }
#endif
  return count_digits_fallback(n);
}

// Counts the number of digits in n. BITS = log2(radix).
template <int BITS, typename UInt>
FMT_CONSTEXPR auto count_digits(UInt n) -> int {
#ifdef FMT_BUILTIN_CLZ
  if (num_bits<UInt>() == 32)
    return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
#endif
  int num_digits = 0;
  do {
    ++num_digits;
  } while ((n >>= BITS) != 0);
  return num_digits;
}

template <> auto count_digits<4>(detail::fallback_uintptr n) -> int;

// It is a separate function rather than a part of count_digits to workaround
// the lack of static constexpr in constexpr functions.
FMT_INLINE uint64_t count_digits_inc(int n) {
  // An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
  // This increments the upper 32 bits (log10(T) - 1) when >= T is added.
#define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
  static constexpr uint64_t table[] = {
      FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
      FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
      FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
      FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
      FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
      FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
      FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
      FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
      FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
      FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
      FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
  };
  return table[n];
}

// Optional version of count_digits for better performance on 32-bit platforms.
FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
#ifdef FMT_BUILTIN_CLZ
  if (!is_constant_evaluated()) {
    auto inc = count_digits_inc(FMT_BUILTIN_CLZ(n | 1) ^ 31);
    return static_cast<int>((n + inc) >> 32);
  }
#endif
  return count_digits_fallback(n);
}

template <typename Int> constexpr auto digits10() FMT_NOEXCEPT -> int {
  return std::numeric_limits<Int>::digits10;
}
template <> constexpr auto digits10<int128_t>() FMT_NOEXCEPT -> int {
  return 38;
}
template <> constexpr auto digits10<uint128_t>() FMT_NOEXCEPT -> int {
  return 38;
}

template <typename Char> struct thousands_sep_result {
  std::string grouping;
  Char thousands_sep;
};

template <typename Char>
FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
template <typename Char>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> {
  auto result = thousands_sep_impl<char>(loc);
  return {result.grouping, Char(result.thousands_sep)};
}
template <>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> {
  return thousands_sep_impl<wchar_t>(loc);
}

template <typename Char>
FMT_API auto decimal_point_impl(locale_ref loc) -> Char;
template <typename Char> inline auto decimal_point(locale_ref loc) -> Char {
  return Char(decimal_point_impl<char>(loc));
}
template <> inline auto decimal_point(locale_ref loc) -> wchar_t {
  return decimal_point_impl<wchar_t>(loc);
}

// Compares two characters for equality.
template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
  return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
}
inline auto equal2(const char* lhs, const char* rhs) -> bool {
  return memcmp(lhs, rhs, 2) == 0;
}

// Copies two characters from src to dst.
template <typename Char> void copy2(Char* dst, const char* src) {
  *dst++ = static_cast<Char>(*src++);
  *dst = static_cast<Char>(*src);
}
FMT_INLINE void copy2(char* dst, const char* src) { memcpy(dst, src, 2); }

template <typename Iterator> struct format_decimal_result {
  Iterator begin;
  Iterator end;
};

// Formats a decimal unsigned integer value writing into out pointing to a
// buffer of specified size. The caller must ensure that the buffer is large
// enough.
template <typename Char, typename UInt>
FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
    -> format_decimal_result<Char*> {
  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
  out += size;
  Char* end = out;
  if (is_constant_evaluated()) {
    while (value >= 10) {
      *--out = static_cast<Char>('0' + value % 10);
      value /= 10;
    }
    *--out = static_cast<Char>('0' + value);
    return {out, end};
  }
  while (value >= 100) {
    // Integer division is slow so do it for a group of two digits instead
    // of for every digit. The idea comes from the talk by Alexandrescu
    // "Three Optimization Tips for C++". See speed-test for a comparison.
    out -= 2;
    copy2(out, data::digits[value % 100]);
    value /= 100;
  }
  if (value < 10) {
    *--out = static_cast<Char>('0' + value);
    return {out, end};
  }
  out -= 2;
  copy2(out, data::digits[value]);
  return {out, end};
}

template <typename Char, typename UInt, typename Iterator,
          FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
inline auto format_decimal(Iterator out, UInt value, int size)
    -> format_decimal_result<Iterator> {
  // Buffer is large enough to hold all digits (digits10 + 1).
  Char buffer[digits10<UInt>() + 1];
  auto end = format_decimal(buffer, value, size).end;
  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
}

template <unsigned BASE_BITS, typename Char, typename UInt>
FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
                               bool upper = false) -> Char* {
  buffer += num_digits;
  Char* end = buffer;
  do {
    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
    unsigned digit = (value & ((1 << BASE_BITS) - 1));
    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
                                                : digits[digit]);
  } while ((value >>= BASE_BITS) != 0);
  return end;
}

template <unsigned BASE_BITS, typename Char>
auto format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
                 bool = false) -> Char* {
  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
  int start = (num_digits + char_digits - 1) / char_digits - 1;
  if (int start_digits = num_digits % char_digits) {
    unsigned value = n.value[start--];
    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
  }
  for (; start >= 0; --start) {
    unsigned value = n.value[start];
    buffer += char_digits;
    auto p = buffer;
    for (int i = 0; i < char_digits; ++i) {
      unsigned digit = (value & ((1 << BASE_BITS) - 1));
      *--p = static_cast<Char>(data::hex_digits[digit]);
      value >>= BASE_BITS;
    }
  }
  return buffer;
}

template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
    -> It {
  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
    format_uint<BASE_BITS>(ptr, value, num_digits, upper);
    return out;
  }
  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
  char buffer[num_bits<UInt>() / BASE_BITS + 1];
  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
}

// A converter from UTF-8 to UTF-16.
class utf8_to_utf16 {
 private:
  basic_memory_buffer<wchar_t> buffer_;

 public:
  FMT_API explicit utf8_to_utf16(string_view s);
  operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; }
  auto size() const -> size_t { return buffer_.size() - 1; }
  auto c_str() const -> const wchar_t* { return &buffer_[0]; }
  auto str() const -> std::wstring { return {&buffer_[0], size()}; }
};

namespace dragonbox {

// Type-specific information that Dragonbox uses.
template <class T> struct float_info;

template <> struct float_info<float> {
  using carrier_uint = uint32_t;
  static const int significand_bits = 23;
  static const int exponent_bits = 8;
  static const int min_exponent = -126;
  static const int max_exponent = 127;
  static const int exponent_bias = -127;
  static const int decimal_digits = 9;
  static const int kappa = 1;
  static const int big_divisor = 100;
  static const int small_divisor = 10;
  static const int min_k = -31;
  static const int max_k = 46;
  static const int cache_bits = 64;
  static const int divisibility_check_by_5_threshold = 39;
  static const int case_fc_pm_half_lower_threshold = -1;
  static const int case_fc_pm_half_upper_threshold = 6;
  static const int case_fc_lower_threshold = -2;
  static const int case_fc_upper_threshold = 6;
  static const int case_shorter_interval_left_endpoint_lower_threshold = 2;
  static const int case_shorter_interval_left_endpoint_upper_threshold = 3;
  static const int shorter_interval_tie_lower_threshold = -35;
  static const int shorter_interval_tie_upper_threshold = -35;
  static const int max_trailing_zeros = 7;
};

template <> struct float_info<double> {
  using carrier_uint = uint64_t;
  static const int significand_bits = 52;
  static const int exponent_bits = 11;
  static const int min_exponent = -1022;
  static const int max_exponent = 1023;
  static const int exponent_bias = -1023;
  static const int decimal_digits = 17;
  static const int kappa = 2;
  static const int big_divisor = 1000;
  static const int small_divisor = 100;
  static const int min_k = -292;
  static const int max_k = 326;
  static const int cache_bits = 128;
  static const int divisibility_check_by_5_threshold = 86;
  static const int case_fc_pm_half_lower_threshold = -2;
  static const int case_fc_pm_half_upper_threshold = 9;
  static const int case_fc_lower_threshold = -4;
  static const int case_fc_upper_threshold = 9;
  static const int case_shorter_interval_left_endpoint_lower_threshold = 2;
  static const int case_shorter_interval_left_endpoint_upper_threshold = 3;
  static const int shorter_interval_tie_lower_threshold = -77;
  static const int shorter_interval_tie_upper_threshold = -77;
  static const int max_trailing_zeros = 16;
};

template <typename T> struct decimal_fp {
  using significand_type = typename float_info<T>::carrier_uint;
  significand_type significand;
  int exponent;
};

template <typename T>
FMT_API auto to_decimal(T x) FMT_NOEXCEPT -> decimal_fp<T>;
}  // namespace dragonbox

template <typename T>
constexpr auto exponent_mask() ->
    typename dragonbox::float_info<T>::carrier_uint {
  using uint = typename dragonbox::float_info<T>::carrier_uint;
  return ((uint(1) << dragonbox::float_info<T>::exponent_bits) - 1)
         << dragonbox::float_info<T>::significand_bits;
}

// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
template <typename Char, typename It>
auto write_exponent(int exp, It it) -> It {
  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
  if (exp < 0) {
    *it++ = static_cast<Char>('-');
    exp = -exp;
  } else {
    *it++ = static_cast<Char>('+');
  }
  if (exp >= 100) {
    const char* top = data::digits[exp / 100];
    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
    *it++ = static_cast<Char>(top[1]);
    exp %= 100;
  }
  const char* d = data::digits[exp];
  *it++ = static_cast<Char>(d[0]);
  *it++ = static_cast<Char>(d[1]);
  return it;
}

template <typename T>
auto format_float(T value, int precision, float_specs specs, buffer<char>& buf)
    -> int;

// Formats a floating-point number with snprintf.
template <typename T>
auto snprintf_float(T value, int precision, float_specs specs,
                    buffer<char>& buf) -> int;

template <typename T> auto promote_float(T value) -> T { return value; }
inline auto promote_float(float value) -> double {
  return static_cast<double>(value);
}

template <typename OutputIt, typename Char>
FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
                                     const fill_t<Char>& fill) -> OutputIt {
  auto fill_size = fill.size();
  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
  auto data = fill.data();
  for (size_t i = 0; i < n; ++i)
    it = copy_str<Char>(data, data + fill_size, it);
  return it;
}

// Writes the output of f, padded according to format specifications in specs.
// size: output size in code units.
// width: output display width in (terminal) column positions.
template <align::type align = align::left, typename OutputIt, typename Char,
          typename F>
FMT_CONSTEXPR auto write_padded(OutputIt out,
                                const basic_format_specs<Char>& specs,
                                size_t size, size_t width, F&& f) -> OutputIt {
  static_assert(align == align::left || align == align::right, "");
  unsigned spec_width = to_unsigned(specs.width);
  size_t padding = spec_width > width ? spec_width - width : 0;
  auto* shifts = align == align::left ? data::left_padding_shifts
                                      : data::right_padding_shifts;
  size_t left_padding = padding >> shifts[specs.align];
  size_t right_padding = padding - left_padding;
  auto it = reserve(out, size + padding * specs.fill.size());
  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
  it = f(it);
  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
  return base_iterator(out, it);
}

template <align::type align = align::left, typename OutputIt, typename Char,
          typename F>
constexpr auto write_padded(OutputIt out, const basic_format_specs<Char>& specs,
                            size_t size, F&& f) -> OutputIt {
  return write_padded<align>(out, specs, size, size, f);
}

template <align::type align = align::left, typename Char, typename OutputIt>
FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
                               const basic_format_specs<Char>& specs)
    -> OutputIt {
  return write_padded<align>(
      out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
        const char* data = bytes.data();
        return copy_str<Char>(data, data + bytes.size(), it);
      });
}

template <typename Char, typename OutputIt, typename UIntPtr>
auto write_ptr(OutputIt out, UIntPtr value,
               const basic_format_specs<Char>* specs) -> OutputIt {
  int num_digits = count_digits<4>(value);
  auto size = to_unsigned(num_digits) + size_t(2);
  auto write = [=](reserve_iterator<OutputIt> it) {
    *it++ = static_cast<Char>('0');
    *it++ = static_cast<Char>('x');
    return format_uint<4, Char>(it, value, num_digits);
  };
  return specs ? write_padded<align::right>(out, *specs, size, write)
               : base_iterator(out, write(reserve(out, size)));
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write_char(OutputIt out, Char value,
                              const basic_format_specs<Char>& specs)
    -> OutputIt {
  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
    *it++ = value;
    return it;
  });
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, Char value,
                         const basic_format_specs<Char>& specs,
                         locale_ref loc = {}) -> OutputIt {
  return check_char_specs(specs)
             ? write_char(out, value, specs)
             : write(out, static_cast<int>(value), specs, loc);
}

// Data for write_int that doesn't depend on output iterator type. It is used to
// avoid template code bloat.
template <typename Char> struct write_int_data {
  size_t size;
  size_t padding;

  FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix,
                               const basic_format_specs<Char>& specs)
      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
    if (specs.align == align::numeric) {
      auto width = to_unsigned(specs.width);
      if (width > size) {
        padding = width - size;
        size = width;
      }
    } else if (specs.precision > num_digits) {
      size = (prefix >> 24) + to_unsigned(specs.precision);
      padding = to_unsigned(specs.precision - num_digits);
    }
  }
};

// Writes an integer in the format
//   <left-padding><prefix><numeric-padding><digits><right-padding>
// where <digits> are written by write_digits(it).
// prefix contains chars in three lower bytes and the size in the fourth byte.
template <typename OutputIt, typename Char, typename W>
FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits,
                                        unsigned prefix,
                                        const basic_format_specs<Char>& specs,
                                        W write_digits) -> OutputIt {
  // Slightly faster check for specs.width == 0 && specs.precision == -1.
  if ((specs.width | (specs.precision + 1)) == 0) {
    auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
    if (prefix != 0) {
      for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
        *it++ = static_cast<Char>(p & 0xff);
    }
    return base_iterator(out, write_digits(it));
  }
  auto data = write_int_data<Char>(num_digits, prefix, specs);
  return write_padded<align::right>(
      out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
          *it++ = static_cast<Char>(p & 0xff);
        it = detail::fill_n(it, data.padding, static_cast<Char>('0'));
        return write_digits(it);
      });
}

template <typename Char> class digit_grouping {
 private:
  thousands_sep_result<Char> sep_;
  std::string::const_iterator group_;
  int pos_;

 public:
  explicit digit_grouping(locale_ref loc) {
    if (loc) {
      sep_ = thousands_sep<Char>(loc);
      reset();
    } else {
      sep_.thousands_sep = Char();
    }
  }

  void reset() {
    group_ = sep_.grouping.begin();
    pos_ = 0;
  }

  // Returns the next digit group separator position.
  int next() {
    if (!sep_.thousands_sep) return max_value<int>();
    if (group_ == sep_.grouping.end()) return pos_ += sep_.grouping.back();
    if (*group_ <= 0 || *group_ == max_value<char>()) return max_value<int>();
    pos_ += *group_++;
    return pos_;
  }

  int count_separators(int num_digits) {
    int count = 0;
    while (num_digits > next()) ++count;
    reset();
    return count;
  }

  Char separator() const { return sep_.thousands_sep; }
};

template <typename OutputIt, typename UInt, typename Char>
auto write_int_localized(OutputIt& out, UInt value, unsigned prefix,
                         const basic_format_specs<Char>& specs, locale_ref loc)
    -> bool {
  static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
  int num_digits = count_digits(value);
  char digits[40];
  format_decimal(digits, value, num_digits);

  auto grouping = digit_grouping<Char>(loc);
  unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits +
                              grouping.count_separators(num_digits));
  auto buffer = basic_memory_buffer<Char>();
  buffer.resize(size);
  int separator_pos = grouping.next();
  auto p = buffer.data() + size;
  for (int i = 0; i < num_digits; ++i) {
    if (i == separator_pos) {
      *--p = grouping.separator();
      separator_pos = grouping.next();
    }
    *--p = static_cast<Char>(digits[num_digits - i - 1]);
  }
  if (prefix != 0) *--p = static_cast<Char>(prefix);
  out = write_padded<align::right>(out, specs, size, size,
                                   [=](reserve_iterator<OutputIt> it) {
                                     return copy_str<Char>(p, p + size, it);
                                   });
  return true;
}

FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
  prefix |= prefix != 0 ? value << 8 : value;
  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
}

template <typename UInt> struct write_int_arg {
  UInt abs_value;
  unsigned prefix;
};

template <typename T>
FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign)
    -> write_int_arg<uint32_or_64_or_128_t<T>> {
  auto prefix = 0u;
  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
  if (is_negative(value)) {
    prefix = 0x01000000 | '-';
    abs_value = 0 - abs_value;
  } else {
    prefix = data::prefixes[sign];
  }
  return {abs_value, prefix};
}

template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
                                        const basic_format_specs<Char>& specs,
                                        locale_ref loc) -> OutputIt {
  static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
  auto abs_value = arg.abs_value;
  auto prefix = arg.prefix;
  auto utype = static_cast<unsigned>(specs.type);
  switch (specs.type) {
  case 0:
  case 'd': {
    if (specs.localized &&
        write_int_localized(out, static_cast<uint64_or_128_t<T>>(abs_value),
                            prefix, specs, loc)) {
      return out;
    }
    auto num_digits = count_digits(abs_value);
    return write_int(
        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
          return format_decimal<Char>(it, abs_value, num_digits).end;
        });
  }
  case 'x':
  case 'X': {
    if (specs.alt) prefix_append(prefix, (utype << 8) | '0');
    bool upper = specs.type != 'x';
    int num_digits = count_digits<4>(abs_value);
    return write_int(
        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
          return format_uint<4, Char>(it, abs_value, num_digits, upper);
        });
  }
  case 'b':
  case 'B': {
    if (specs.alt) prefix_append(prefix, (utype << 8) | '0');
    int num_digits = count_digits<1>(abs_value);
    return write_int(out, num_digits, prefix, specs,
                     [=](reserve_iterator<OutputIt> it) {
                       return format_uint<1, Char>(it, abs_value, num_digits);
                     });
  }
  case 'o': {
    int num_digits = count_digits<3>(abs_value);
    if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
      // Octal prefix '0' is counted as a digit, so only add it if precision
      // is not greater than the number of digits.
      prefix_append(prefix, '0');
    }
    return write_int(out, num_digits, prefix, specs,
                     [=](reserve_iterator<OutputIt> it) {
                       return format_uint<3, Char>(it, abs_value, num_digits);
                     });
  }
  case 'c':
    return write_char(out, static_cast<Char>(abs_value), specs);
  default:
    FMT_THROW(format_error("invalid type specifier"));
  }
  return out;
}
template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(is_integral<T>::value &&
                        !std::is_same<T, bool>::value &&
                        std::is_same<OutputIt, buffer_appender<Char>>::value)>
FMT_CONSTEXPR auto write(OutputIt out, T value,
                         const basic_format_specs<Char>& specs, locale_ref loc)
    -> OutputIt {
  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
}
// An inlined version of write used in format string compilation.
template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(is_integral<T>::value &&
                        !std::is_same<T, bool>::value &&
                        !std::is_same<OutputIt, buffer_appender<Char>>::value)>
FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
                                    const basic_format_specs<Char>& specs,
                                    locale_ref loc) -> OutputIt {
  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
                         const basic_format_specs<Char>& specs) -> OutputIt {
  auto data = s.data();
  auto size = s.size();
  if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
    size = code_point_index(s, to_unsigned(specs.precision));
  auto width =
      specs.width != 0 ? compute_width(basic_string_view<Char>(data, size)) : 0;
  return write_padded(out, specs, size, width,
                      [=](reserve_iterator<OutputIt> it) {
                        return copy_str<Char>(data, data + size, it);
                      });
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out,
                         basic_string_view<type_identity_t<Char>> s,
                         const basic_format_specs<Char>& specs, locale_ref)
    -> OutputIt {
  check_string_type_spec(specs.type);
  return write(out, s, specs);
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
                         const basic_format_specs<Char>& specs, locale_ref)
    -> OutputIt {
  return check_cstring_type_spec(specs.type)
             ? write(out, basic_string_view<Char>(s), specs, {})
             : write_ptr<Char>(out, to_uintptr(s), &specs);
}

template <typename Char, typename OutputIt>
auto write_nonfinite(OutputIt out, bool isinf, basic_format_specs<Char> specs,
                     const float_specs& fspecs) -> OutputIt {
  auto str =
      isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
  constexpr size_t str_size = 3;
  auto sign = fspecs.sign;
  auto size = str_size + (sign ? 1 : 0);
  // Replace '0'-padding with space for non-finite values.
  const bool is_zero_fill =
      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
    return copy_str<Char>(str, str + str_size, it);
  });
}

// A decimal floating-point number significand * pow(10, exp).
struct big_decimal_fp {
  const char* significand;
  int significand_size;
  int exponent;
};

inline auto get_significand_size(const big_decimal_fp& fp) -> int {
  return fp.significand_size;
}
template <typename T>
inline auto get_significand_size(const dragonbox::decimal_fp<T>& fp) -> int {
  return count_digits(fp.significand);
}

template <typename Char, typename OutputIt>
inline auto write_significand(OutputIt out, const char* significand,
                              int significand_size) -> OutputIt {
  return copy_str<Char>(significand, significand + significand_size, out);
}
template <typename Char, typename OutputIt, typename UInt>
inline auto write_significand(OutputIt out, UInt significand,
                              int significand_size) -> OutputIt {
  return format_decimal<Char>(out, significand, significand_size).end;
}

template <typename Char, typename UInt,
          FMT_ENABLE_IF(std::is_integral<UInt>::value)>
inline auto write_significand(Char* out, UInt significand, int significand_size,
                              int integral_size, Char decimal_point) -> Char* {
  if (!decimal_point)
    return format_decimal(out, significand, significand_size).end;
  auto end = format_decimal(out + 1, significand, significand_size).end;
  if (integral_size == 1) {
    out[0] = out[1];
  } else {
    std::uninitialized_copy_n(out + 1, integral_size,
                              make_checked(out, to_unsigned(integral_size)));
  }
  out[integral_size] = decimal_point;
  return end;
}

template <typename OutputIt, typename UInt, typename Char,
          FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
inline auto write_significand(OutputIt out, UInt significand,
                              int significand_size, int integral_size,
                              Char decimal_point) -> OutputIt {
  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
  Char buffer[digits10<UInt>() + 2];
  auto end = write_significand(buffer, significand, significand_size,
                               integral_size, decimal_point);
  return detail::copy_str_noinline<Char>(buffer, end, out);
}

template <typename OutputIt, typename Char>
inline auto write_significand(OutputIt out, const char* significand,
                              int significand_size, int integral_size,
                              Char decimal_point) -> OutputIt {
  out = detail::copy_str_noinline<Char>(significand,
                                        significand + integral_size, out);
  if (!decimal_point) return out;
  *out++ = decimal_point;
  return detail::copy_str_noinline<Char>(significand + integral_size,
                                         significand + significand_size, out);
}

template <typename OutputIt, typename DecimalFP, typename Char>
auto write_float(OutputIt out, const DecimalFP& fp,
                 const basic_format_specs<Char>& specs, float_specs fspecs,
                 locale_ref loc) -> OutputIt {
  auto significand = fp.significand;
  int significand_size = get_significand_size(fp);
  static const Char zero = static_cast<Char>('0');
  auto sign = fspecs.sign;
  size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
  using iterator = reserve_iterator<OutputIt>;

  Char decimal_point =
      fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');

  int output_exp = fp.exponent + significand_size - 1;
  auto use_exp_format = [=]() {
    if (fspecs.format == float_format::exp) return true;
    if (fspecs.format != float_format::general) return false;
    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
    const int exp_lower = -4, exp_upper = 16;
    return output_exp < exp_lower ||
           output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
  };
  if (use_exp_format()) {
    int num_zeros = 0;
    if (fspecs.showpoint) {
      num_zeros = fspecs.precision - significand_size;
      if (num_zeros < 0) num_zeros = 0;
      size += to_unsigned(num_zeros);
    } else if (significand_size == 1) {
      decimal_point = Char();
    }
    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
    int exp_digits = 2;
    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;

    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
    char exp_char = fspecs.upper ? 'E' : 'e';
    auto write = [=](iterator it) {
      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
      // Insert a decimal point after the first digit and add an exponent.
      it = write_significand(it, significand, significand_size, 1,
                             decimal_point);
      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
      *it++ = static_cast<Char>(exp_char);
      return write_exponent<Char>(output_exp, it);
    };
    return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
                           : base_iterator(out, write(reserve(out, size)));
  }

  int exp = fp.exponent + significand_size;
  if (fp.exponent >= 0) {
    // 1234e5 -> 123400000[.0+]
    size += to_unsigned(fp.exponent);
    int num_zeros = fspecs.precision - exp;
#ifdef FMT_FUZZ
    if (num_zeros > 5000)
      throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
    if (fspecs.showpoint) {
      if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
      if (num_zeros > 0) size += to_unsigned(num_zeros) + 1;
    }
    return write_padded<align::right>(out, specs, size, [&](iterator it) {
      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
      it = write_significand<Char>(it, significand, significand_size);
      it = detail::fill_n(it, fp.exponent, zero);
      if (!fspecs.showpoint) return it;
      *it++ = decimal_point;
      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
    });
  } else if (exp > 0) {
    // 1234e-2 -> 12.34[0+]
    int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
    size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
    return write_padded<align::right>(out, specs, size, [&](iterator it) {
      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
      it = write_significand(it, significand, significand_size, exp,
                             decimal_point);
      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
    });
  }
  // 1234e-6 -> 0.001234
  int num_zeros = -exp;
  if (significand_size == 0 && fspecs.precision >= 0 &&
      fspecs.precision < num_zeros) {
    num_zeros = fspecs.precision;
  }
  bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
  return write_padded<align::right>(out, specs, size, [&](iterator it) {
    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
    *it++ = zero;
    if (!pointy) return it;
    *it++ = decimal_point;
    it = detail::fill_n(it, num_zeros, zero);
    return write_significand<Char>(it, significand, significand_size);
  });
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(std::is_floating_point<T>::value)>
auto write(OutputIt out, T value, basic_format_specs<Char> specs,
           locale_ref loc = {}) -> OutputIt {
  if (const_check(!is_supported_floating_point(value))) return out;
  float_specs fspecs = parse_float_type_spec(specs);
  fspecs.sign = specs.sign;
  if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
    fspecs.sign = sign::minus;
    value = -value;
  } else if (fspecs.sign == sign::minus) {
    fspecs.sign = sign::none;
  }

  if (!std::isfinite(value))
    return write_nonfinite(out, std::isinf(value), specs, fspecs);

  if (specs.align == align::numeric && fspecs.sign) {
    auto it = reserve(out, 1);
    *it++ = static_cast<Char>(data::signs[fspecs.sign]);
    out = base_iterator(out, it);
    fspecs.sign = sign::none;
    if (specs.width != 0) --specs.width;
  }

  memory_buffer buffer;
  if (fspecs.format == float_format::hex) {
    if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
    snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
                                     specs);
  }
  int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
  if (fspecs.format == float_format::exp) {
    if (precision == max_value<int>())
      FMT_THROW(format_error("number is too big"));
    else
      ++precision;
  }
  if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
  fspecs.use_grisu = is_fast_float<T>();
  int exp = format_float(promote_float(value), precision, fspecs, buffer);
  fspecs.precision = precision;
  auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
  return write_float(out, fp, specs, fspecs, loc);
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(is_fast_float<T>::value)>
auto write(OutputIt out, T value) -> OutputIt {
  if (const_check(!is_supported_floating_point(value))) return out;

  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
  using uint = typename dragonbox::float_info<floaty>::carrier_uint;
  auto bits = bit_cast<uint>(value);

  auto fspecs = float_specs();
  auto sign_bit = bits & (uint(1) << (num_bits<uint>() - 1));
  if (sign_bit != 0) {
    fspecs.sign = sign::minus;
    value = -value;
  }

  static const auto specs = basic_format_specs<Char>();
  uint mask = exponent_mask<floaty>();
  if ((bits & mask) == mask)
    return write_nonfinite(out, std::isinf(value), specs, fspecs);

  auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
  return write_float(out, dec, specs, fspecs, {});
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(std::is_floating_point<T>::value &&
                        !is_fast_float<T>::value)>
inline auto write(OutputIt out, T value) -> OutputIt {
  return write(out, value, basic_format_specs<Char>());
}

template <typename Char, typename OutputIt>
auto write(OutputIt out, monostate, basic_format_specs<Char> = {},
           locale_ref = {}) -> OutputIt {
  FMT_ASSERT(false, "");
  return out;
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
    -> OutputIt {
  auto it = reserve(out, value.size());
  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
  return base_iterator(out, it);
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(is_string<T>::value)>
constexpr auto write(OutputIt out, const T& value) -> OutputIt {
  return write<Char>(out, to_string_view(value));
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(is_integral<T>::value &&
                        !std::is_same<T, bool>::value &&
                        !std::is_same<T, Char>::value)>
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
  bool negative = is_negative(value);
  // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
  if (negative) abs_value = ~abs_value + 1;
  int num_digits = count_digits(abs_value);
  auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
  auto it = reserve(out, size);
  if (auto ptr = to_pointer<Char>(it, size)) {
    if (negative) *ptr++ = static_cast<Char>('-');
    format_decimal<Char>(ptr, abs_value, num_digits);
    return out;
  }
  if (negative) *it++ = static_cast<Char>('-');
  it = format_decimal<Char>(it, abs_value, num_digits).end;
  return base_iterator(out, it);
}

// FMT_ENABLE_IF() condition separated to workaround MSVC bug
template <
    typename Char, typename OutputIt, typename T,
    bool check =
        std::is_enum<T>::value && !std::is_same<T, Char>::value &&
        mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value !=
            type::custom_type,
    FMT_ENABLE_IF(check)>
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
  return write<Char>(
      out, static_cast<typename std::underlying_type<T>::type>(value));
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(std::is_same<T, bool>::value)>
FMT_CONSTEXPR auto write(OutputIt out, T value,
                         const basic_format_specs<Char>& specs = {},
                         locale_ref = {}) -> OutputIt {
  return specs.type && specs.type != 's'
             ? write(out, value ? 1 : 0, specs, {})
             : write_bytes(out, value ? "true" : "false", specs);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
  auto it = reserve(out, 1);
  *it++ = value;
  return base_iterator(out, it);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value)
    -> OutputIt {
  if (!value) {
    FMT_THROW(format_error("string pointer is null"));
  } else {
    auto length = std::char_traits<Char>::length(value);
    out = write(out, basic_string_view<Char>(value, length));
  }
  return out;
}

template <typename Char, typename OutputIt, typename T,
          FMT_ENABLE_IF(std::is_same<T, void>::value)>
auto write(OutputIt out, const T* value,
           const basic_format_specs<Char>& specs = {}, locale_ref = {})
    -> OutputIt {
  check_pointer_type_spec(specs.type, error_handler());
  return write_ptr<Char>(out, to_uintptr(value), &specs);
}

template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR auto write(OutputIt out, const T& value) ->
    typename std::enable_if<
        mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value ==
            type::custom_type,
        OutputIt>::type {
  using context_type = basic_format_context<OutputIt, Char>;
  using formatter_type =
      conditional_t<has_formatter<T, context_type>::value,
                    typename context_type::template formatter_type<T>,
                    fallback_formatter<T, Char>>;
  context_type ctx(out, {}, {});
  return formatter_type().format(value, ctx);
}

// An argument visitor that formats the argument and writes it via the output
// iterator. It's a class and not a generic lambda for compatibility with C++11.
template <typename Char> struct default_arg_formatter {
  using iterator = buffer_appender<Char>;
  using context = buffer_context<Char>;

  iterator out;
  basic_format_args<context> args;
  locale_ref loc;

  template <typename T> auto operator()(T value) -> iterator {
    return write<Char>(out, value);
  }
  auto operator()(typename basic_format_arg<context>::handle h) -> iterator {
    basic_format_parse_context<Char> parse_ctx({});
    context format_ctx(out, args, loc);
    h.format(parse_ctx, format_ctx);
    return format_ctx.out();
  }
};

template <typename Char> struct arg_formatter {
  using iterator = buffer_appender<Char>;
  using context = buffer_context<Char>;

  iterator out;
  const basic_format_specs<Char>& specs;
  locale_ref locale;

  template <typename T>
  FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator {
    return detail::write(out, value, specs, locale);
  }
  auto operator()(typename basic_format_arg<context>::handle) -> iterator {
    // User-defined types are handled separately because they require access
    // to the parse context.
    return out;
  }
};

template <typename Char> struct custom_formatter {
  basic_format_parse_context<Char>& parse_ctx;
  buffer_context<Char>& ctx;

  void operator()(
      typename basic_format_arg<buffer_context<Char>>::handle h) const {
    h.format(parse_ctx, ctx);
  }
  template <typename T> void operator()(T) const {}
};

template <typename T>
using is_integer =
    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
                  !std::is_same<T, char>::value &&
                  !std::is_same<T, wchar_t>::value>;

template <typename ErrorHandler> class width_checker {
 public:
  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}

  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
    if (is_negative(value)) handler_.on_error("negative width");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
    handler_.on_error("width is not integer");
    return 0;
  }

 private:
  ErrorHandler& handler_;
};

template <typename ErrorHandler> class precision_checker {
 public:
  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}

  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
    if (is_negative(value)) handler_.on_error("negative precision");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
    handler_.on_error("precision is not integer");
    return 0;
  }

 private:
  ErrorHandler& handler_;
};

template <template <typename> class Handler, typename FormatArg,
          typename ErrorHandler>
FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
  return static_cast<int>(value);
}

template <typename Context, typename ID>
FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) ->
    typename Context::format_arg {
  auto arg = ctx.arg(id);
  if (!arg) ctx.on_error("argument not found");
  return arg;
}

// The standard format specifier handler with checking.
template <typename Char> class specs_handler : public specs_setter<Char> {
 private:
  basic_format_parse_context<Char>& parse_context_;
  buffer_context<Char>& context_;

  // This is only needed for compatibility with gcc 4.4.
  using format_arg = basic_format_arg<buffer_context<Char>>;

  FMT_CONSTEXPR auto get_arg(auto_id) -> format_arg {
    return detail::get_arg(context_, parse_context_.next_arg_id());
  }

  FMT_CONSTEXPR auto get_arg(int arg_id) -> format_arg {
    parse_context_.check_arg_id(arg_id);
    return detail::get_arg(context_, arg_id);
  }

  FMT_CONSTEXPR auto get_arg(basic_string_view<Char> arg_id) -> format_arg {
    parse_context_.check_arg_id(arg_id);
    return detail::get_arg(context_, arg_id);
  }

 public:
  FMT_CONSTEXPR specs_handler(basic_format_specs<Char>& specs,
                              basic_format_parse_context<Char>& parse_ctx,
                              buffer_context<Char>& ctx)
      : specs_setter<Char>(specs), parse_context_(parse_ctx), context_(ctx) {}

  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
    this->specs_.width = get_dynamic_spec<width_checker>(
        get_arg(arg_id), context_.error_handler());
  }

  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
    this->specs_.precision = get_dynamic_spec<precision_checker>(
        get_arg(arg_id), context_.error_handler());
  }

  void on_error(const char* message) { context_.on_error(message); }
};

template <template <typename> class Handler, typename Context>
FMT_CONSTEXPR void handle_dynamic_spec(int& value,
                                       arg_ref<typename Context::char_type> ref,
                                       Context& ctx) {
  switch (ref.kind) {
  case arg_id_kind::none:
    break;
  case arg_id_kind::index:
    value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
                                              ctx.error_handler());
    break;
  case arg_id_kind::name:
    value = detail::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
                                              ctx.error_handler());
    break;
  }
}

#define FMT_STRING_IMPL(s, base, explicit)                                 \
  [] {                                                                     \
    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
    /* Use a macro-like name to avoid shadowing warnings. */               \
    struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base {           \
      using char_type = fmt::remove_cvref_t<decltype(s[0])>;               \
      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                              \
      operator fmt::basic_string_view<char_type>() const {                 \
        return fmt::detail_exported::compile_string_to_view<char_type>(s); \
      }                                                                    \
    };                                                                     \
    return FMT_COMPILE_STRING();                                           \
  }()

/**
  \rst
  Constructs a compile-time format string from a string literal *s*.

  **Example**::

    // A compile-time error because 'd' is an invalid specifier for strings.
    std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
  \endrst
 */
#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::compile_string, )

#if FMT_USE_USER_DEFINED_LITERALS
template <typename Char> struct udl_formatter {
  basic_string_view<Char> str;

  template <typename... T>
  auto operator()(T&&... args) const -> std::basic_string<Char> {
    return vformat(str, fmt::make_args_checked<T...>(str, args...));
  }
};

#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
template <typename T, typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
struct statically_named_arg : view {
  static constexpr auto name = Str.data;

  const T& value;
  statically_named_arg(const T& v) : value(v) {}
};

template <typename T, typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
struct is_named_arg<statically_named_arg<T, Char, N, Str>> : std::true_type {};

template <typename T, typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
struct is_statically_named_arg<statically_named_arg<T, Char, N, Str>>
    : std::true_type {};

template <typename Char, size_t N,
          fmt::detail_exported::fixed_string<Char, N> Str>
struct udl_arg {
  template <typename T> auto operator=(T&& value) const {
    return statically_named_arg<T, Char, N, Str>(std::forward<T>(value));
  }
};
#  else
template <typename Char> struct udl_arg {
  const Char* str;

  template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> {
    return {str, std::forward<T>(value)};
  }
};
#  endif
#endif  // FMT_USE_USER_DEFINED_LITERALS

template <typename Locale, typename Char>
auto vformat(const Locale& loc, basic_string_view<Char> format_str,
             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  basic_memory_buffer<Char> buffer;
  detail::vformat_to(buffer, format_str, args, detail::locale_ref(loc));
  return {buffer.data(), buffer.size()};
}

using format_func = void (*)(detail::buffer<char>&, int, const char*);

FMT_API void format_error_code(buffer<char>& out, int error_code,
                               string_view message) FMT_NOEXCEPT;

FMT_API void report_error(format_func func, int error_code,
                          const char* message) FMT_NOEXCEPT;
FMT_END_DETAIL_NAMESPACE

FMT_API auto vsystem_error(int error_code, string_view format_str,
                           format_args args) -> std::system_error;

/**
 \rst
 Constructs :class:`std::system_error` with a message formatted with
 ``fmt::format(fmt, args...)``.
  *error_code* is a system error code as given by ``errno``.

 **Example**::

   // This throws std::system_error with the description
   //   cannot open file 'madeup': No such file or directory
   // or similar (system message may vary).
   const char* filename = "madeup";
   std::FILE* file = std::fopen(filename, "r");
   if (!file)
     throw fmt::system_error(errno, "cannot open file '{}'", filename);
 \endrst
*/
template <typename... T>
auto system_error(int error_code, format_string<T...> fmt, T&&... args)
    -> std::system_error {
  return vsystem_error(error_code, fmt, fmt::make_format_args(args...));
}

/**
  \rst
  Formats an error message for an error returned by an operating system or a
  language runtime, for example a file opening error, and writes it to *out*.
  The format is the same as the one used by ``std::system_error(ec, message)``
  where ``ec`` is ``std::error_code(error_code, std::generic_category()})``.
  It is implementation-defined but normally looks like:

  .. parsed-literal::
     *<message>*: *<system-message>*

  where *<message>* is the passed message and *<system-message>* is the system
  message corresponding to the error code.
  *error_code* is a system error code as given by ``errno``.
  \endrst
 */
FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
                                 const char* message) FMT_NOEXCEPT;

// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code,
                                 const char* message) FMT_NOEXCEPT;

/** Fast integer formatter. */
class format_int {
 private:
  // Buffer should be large enough to hold all digits (digits10 + 1),
  // a sign and a null character.
  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
  mutable char buffer_[buffer_size];
  char* str_;

  template <typename UInt> auto format_unsigned(UInt value) -> char* {
    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
    return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
  }

  template <typename Int> auto format_signed(Int value) -> char* {
    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
    bool negative = value < 0;
    if (negative) abs_value = 0 - abs_value;
    auto begin = format_unsigned(abs_value);
    if (negative) *--begin = '-';
    return begin;
  }

 public:
  explicit format_int(int value) : str_(format_signed(value)) {}
  explicit format_int(long value) : str_(format_signed(value)) {}
  explicit format_int(long long value) : str_(format_signed(value)) {}
  explicit format_int(unsigned value) : str_(format_unsigned(value)) {}
  explicit format_int(unsigned long value) : str_(format_unsigned(value)) {}
  explicit format_int(unsigned long long value)
      : str_(format_unsigned(value)) {}

  /** Returns the number of characters written to the output buffer. */
  auto size() const -> size_t {
    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
  }

  /**
    Returns a pointer to the output buffer content. No terminating null
    character is appended.
   */
  auto data() const -> const char* { return str_; }

  /**
    Returns a pointer to the output buffer content with terminating null
    character appended.
   */
  auto c_str() const -> const char* {
    buffer_[buffer_size - 1] = '\0';
    return str_;
  }

  /**
    \rst
    Returns the content of the output buffer as an ``std::string``.
    \endrst
   */
  auto str() const -> std::string { return std::string(str_, size()); }
};

template <typename T, typename Char>
template <typename FormatContext>
FMT_CONSTEXPR FMT_INLINE auto
formatter<T, Char,
          enable_if_t<detail::type_constant<T, Char>::value !=
                      detail::type::custom_type>>::format(const T& val,
                                                          FormatContext& ctx)
    const -> decltype(ctx.out()) {
  if (specs_.width_ref.kind != detail::arg_id_kind::none ||
      specs_.precision_ref.kind != detail::arg_id_kind::none) {
    auto specs = specs_;
    detail::handle_dynamic_spec<detail::width_checker>(specs.width,
                                                       specs.width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs.precision, specs.precision_ref, ctx);
    return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
  }
  return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
}

#define FMT_FORMAT_AS(Type, Base)                                        \
  template <typename Char>                                               \
  struct formatter<Type, Char> : formatter<Base, Char> {                 \
    template <typename FormatContext>                                    \
    auto format(Type const& val, FormatContext& ctx) const               \
        -> decltype(ctx.out()) {                                         \
      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
    }                                                                    \
  }

FMT_FORMAT_AS(signed char, int);
FMT_FORMAT_AS(unsigned char, unsigned);
FMT_FORMAT_AS(short, int);
FMT_FORMAT_AS(unsigned short, unsigned);
FMT_FORMAT_AS(long, long long);
FMT_FORMAT_AS(unsigned long, unsigned long long);
FMT_FORMAT_AS(Char*, const Char*);
FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
FMT_FORMAT_AS(std::nullptr_t, const void*);
FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);

template <typename Char>
struct formatter<void*, Char> : formatter<const void*, Char> {
  template <typename FormatContext>
  auto format(void* val, FormatContext& ctx) const -> decltype(ctx.out()) {
    return formatter<const void*, Char>::format(val, ctx);
  }
};

template <typename Char, size_t N>
struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
  template <typename FormatContext>
  FMT_CONSTEXPR auto format(const Char* val, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
  }
};

// A formatter for types known only at run time such as variant alternatives.
//
// Usage:
//   using variant = std::variant<int, std::string>;
//   template <>
//   struct formatter<variant>: dynamic_formatter<> {
//     auto format(const variant& v, format_context& ctx) {
//       return visit([&](const auto& val) {
//           return dynamic_formatter<>::format(val, ctx);
//       }, v);
//     }
//   };
template <typename Char = char> class dynamic_formatter {
 private:
  detail::dynamic_format_specs<Char> specs_;
  const Char* format_str_;

  struct null_handler : detail::error_handler {
    void on_align(align_t) {}
    void on_sign(sign_t) {}
    void on_hash() {}
  };

  template <typename Context> void handle_specs(Context& ctx) {
    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
                                                       specs_.width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
  }

 public:
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    format_str_ = ctx.begin();
    // Checks are deferred to formatting time when the argument type is known.
    detail::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
    return detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
  }

  template <typename T, typename FormatContext>
  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
    handle_specs(ctx);
    detail::specs_checker<null_handler> checker(
        null_handler(), detail::mapped_type_constant<T, FormatContext>::value);
    checker.on_align(specs_.align);
    if (specs_.sign != sign::none) checker.on_sign(specs_.sign);
    if (specs_.alt) checker.on_hash();
    if (specs_.precision >= 0) checker.end_precision();
    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
  }
};

/**
  \rst
  Converts ``p`` to ``const void*`` for pointer formatting.

  **Example**::

    auto s = fmt::format("{}", fmt::ptr(p));
  \endrst
 */
template <typename T> auto ptr(T p) -> const void* {
  static_assert(std::is_pointer<T>::value, "");
  return detail::bit_cast<const void*>(p);
}
template <typename T> auto ptr(const std::unique_ptr<T>& p) -> const void* {
  return p.get();
}
template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
  return p.get();
}

class bytes {
 private:
  string_view data_;
  friend struct formatter<bytes>;

 public:
  explicit bytes(string_view data) : data_(data) {}
};

template <> struct formatter<bytes> {
 private:
  detail::dynamic_format_specs<char> specs_;

 public:
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    using handler_type = detail::dynamic_specs_handler<ParseContext>;
    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                detail::type::string_type);
    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
    detail::check_string_type_spec(specs_.type, ctx.error_handler());
    return it;
  }

  template <typename FormatContext>
  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
                                                       specs_.width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    return detail::write_bytes(ctx.out(), b.data_, specs_);
  }
};

template <typename It, typename Sentinel, typename Char = char>
struct join_view : detail::view {
  It begin;
  Sentinel end;
  basic_string_view<Char> sep;

  join_view(It b, Sentinel e, basic_string_view<Char> s)
      : begin(b), end(e), sep(s) {}
};

template <typename It, typename Sentinel, typename Char>
using arg_join FMT_DEPRECATED_ALIAS = join_view<It, Sentinel, Char>;

template <typename It, typename Sentinel, typename Char>
struct formatter<join_view<It, Sentinel, Char>, Char> {
 private:
  using value_type = typename std::iterator_traits<It>::value_type;
  using context = buffer_context<Char>;
  using mapper = detail::arg_mapper<context>;

  template <typename T, FMT_ENABLE_IF(has_formatter<T, context>::value)>
  static auto map(const T& value) -> const T& {
    return value;
  }
  template <typename T, FMT_ENABLE_IF(!has_formatter<T, context>::value)>
  static auto map(const T& value) -> decltype(mapper().map(value)) {
    return mapper().map(value);
  }

  using formatter_type =
      conditional_t<is_formattable<value_type, Char>::value,
                    formatter<remove_cvref_t<decltype(map(
                                  std::declval<const value_type&>()))>,
                              Char>,
                    detail::fallback_formatter<value_type, Char>>;

  formatter_type value_formatter_;

 public:
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return value_formatter_.parse(ctx);
  }

  template <typename FormatContext>
  auto format(const join_view<It, Sentinel, Char>& value, FormatContext& ctx)
      -> decltype(ctx.out()) {
    auto it = value.begin;
    auto out = ctx.out();
    if (it != value.end) {
      out = value_formatter_.format(map(*it++), ctx);
      while (it != value.end) {
        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
        ctx.advance_to(out);
        out = value_formatter_.format(map(*it++), ctx);
      }
    }
    return out;
  }
};

/**
  Returns an object that formats the iterator range `[begin, end)` with
  elements separated by `sep`.
 */
template <typename It, typename Sentinel>
auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
  return {begin, end, sep};
}

/**
  \rst
  Returns an object that formats `range` with elements separated by `sep`.

  **Example**::

    std::vector<int> v = {1, 2, 3};
    fmt::print("{}", fmt::join(v, ", "));
    // Output: "1, 2, 3"

  ``fmt::join`` applies passed format specifiers to the range elements::

    fmt::print("{:02}", fmt::join(v, ", "));
    // Output: "01, 02, 03"
  \endrst
 */
template <typename Range>
auto join(Range&& range, string_view sep)
    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
  return join(std::begin(range), std::end(range), sep);
}

/**
  \rst
  Converts *value* to ``std::string`` using the default format for type *T*.

  **Example**::

    #include <fmt/format.h>

    std::string answer = fmt::to_string(42);
  \endrst
 */
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
inline auto to_string(const T& value) -> std::string {
  auto result = std::string();
  detail::write<char>(std::back_inserter(result), value);
  return result;
}

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline auto to_string(T value) -> std::string {
  // The buffer should be large enough to store the number including the sign
  // or "false" for bool.
  constexpr int max_size = detail::digits10<T>() + 2;
  char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
  char* begin = buffer;
  return std::string(begin, detail::write<char>(begin, value));
}

template <typename Char, size_t SIZE>
auto to_string(const basic_memory_buffer<Char, SIZE>& buf)
    -> std::basic_string<Char> {
  auto size = buf.size();
  detail::assume(size < std::basic_string<Char>().max_size());
  return std::basic_string<Char>(buf.data(), size);
}

FMT_BEGIN_DETAIL_NAMESPACE

template <typename Char>
void vformat_to(
    buffer<Char>& buf, basic_string_view<Char> fmt,
    basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args,
    locale_ref loc) {
  // workaround for msvc bug regarding name-lookup in module
  // link names into function scope
  using detail::arg_formatter;
  using detail::buffer_appender;
  using detail::custom_formatter;
  using detail::default_arg_formatter;
  using detail::get_arg;
  using detail::locale_ref;
  using detail::parse_format_specs;
  using detail::specs_checker;
  using detail::specs_handler;
  using detail::to_unsigned;
  using detail::type;
  using detail::write;
  auto out = buffer_appender<Char>(buf);
  if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
    auto arg = args.get(0);
    if (!arg) error_handler().on_error("argument not found");
    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
    return;
  }

  struct format_handler : error_handler {
    basic_format_parse_context<Char> parse_context;
    buffer_context<Char> context;

    format_handler(buffer_appender<Char> out, basic_string_view<Char> str,
                   basic_format_args<buffer_context<Char>> args, locale_ref loc)
        : parse_context(str), context(out, args, loc) {}

    void on_text(const Char* begin, const Char* end) {
      auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
      context.advance_to(write<Char>(context.out(), text));
    }

    FMT_CONSTEXPR auto on_arg_id() -> int {
      return parse_context.next_arg_id();
    }
    FMT_CONSTEXPR auto on_arg_id(int id) -> int {
      return parse_context.check_arg_id(id), id;
    }
    FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
      int arg_id = context.arg_id(id);
      if (arg_id < 0) on_error("argument not found");
      return arg_id;
    }

    FMT_INLINE void on_replacement_field(int id, const Char*) {
      auto arg = get_arg(context, id);
      context.advance_to(visit_format_arg(
          default_arg_formatter<Char>{context.out(), context.args(),
                                      context.locale()},
          arg));
    }

    auto on_format_specs(int id, const Char* begin, const Char* end)
        -> const Char* {
      auto arg = get_arg(context, id);
      if (arg.type() == type::custom_type) {
        parse_context.advance_to(parse_context.begin() +
                                 (begin - &*parse_context.begin()));
        visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
        return parse_context.begin();
      }
      auto specs = basic_format_specs<Char>();
      specs_checker<specs_handler<Char>> handler(
          specs_handler<Char>(specs, parse_context, context), arg.type());
      begin = parse_format_specs(begin, end, handler);
      if (begin == end || *begin != '}')
        on_error("missing '}' in format string");
      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
      context.advance_to(visit_format_arg(f, arg));
      return begin;
    }
  };
  detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
}

#ifndef FMT_HEADER_ONLY
extern template FMT_API auto thousands_sep_impl<char>(locale_ref)
    -> thousands_sep_result<char>;
extern template FMT_API auto thousands_sep_impl<wchar_t>(locale_ref)
    -> thousands_sep_result<wchar_t>;
extern template FMT_API auto decimal_point_impl(locale_ref) -> char;
extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
extern template auto format_float<double>(double value, int precision,
                                          float_specs specs, buffer<char>& buf)
    -> int;
extern template auto format_float<long double>(long double value, int precision,
                                               float_specs specs,
                                               buffer<char>& buf) -> int;
void snprintf_float(float, int, float_specs, buffer<char>&) = delete;
extern template auto snprintf_float<double>(double value, int precision,
                                            float_specs specs,
                                            buffer<char>& buf) -> int;
extern template auto snprintf_float<long double>(long double value,
                                                 int precision,
                                                 float_specs specs,
                                                 buffer<char>& buf) -> int;
#endif  // FMT_HEADER_ONLY

FMT_END_DETAIL_NAMESPACE

#if FMT_USE_USER_DEFINED_LITERALS
inline namespace literals {
/**
  \rst
  User-defined literal equivalent of :func:`fmt::arg`.

  **Example**::

    using namespace fmt::literals;
    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
  \endrst
 */
#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
template <detail_exported::fixed_string Str>
constexpr auto operator""_a()
    -> detail::udl_arg<remove_cvref_t<decltype(Str.data[0])>,
                       sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str> {
  return {};
}
#  else
constexpr auto operator"" _a(const char* s, size_t) -> detail::udl_arg<char> {
  return {s};
}
#  endif

/**
  \rst
  User-defined literal equivalent of :func:`fmt::format`.

  **Example**::

    using namespace fmt::literals;
    std::string message = "The answer is {}"_format(42);
  \endrst
 */
constexpr auto operator"" _format(const char* s, size_t n)
    -> detail::udl_formatter<char> {
  return {{s, n}};
}
}  // namespace literals
#endif  // FMT_USE_USER_DEFINED_LITERALS

template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
inline auto vformat(const Locale& loc, string_view fmt, format_args args)
    -> std::string {
  return detail::vformat(loc, fmt, args);
}

template <typename Locale, typename... T,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
inline auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
    -> std::string {
  return vformat(loc, string_view(fmt), fmt::make_format_args(args...));
}

template <typename... T, size_t SIZE, typename Allocator>
FMT_DEPRECATED auto format_to(basic_memory_buffer<char, SIZE, Allocator>& buf,
                              format_string<T...> fmt, T&&... args)
    -> appender {
  detail::vformat_to(buf, string_view(fmt), fmt::make_format_args(args...));
  return appender(buf);
}

template <typename OutputIt, typename Locale,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
                            detail::is_locale<Locale>::value)>
auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
                format_args args) -> OutputIt {
  using detail::get_buffer;
  auto&& buf = get_buffer<char>(out);
  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
  return detail::get_iterator(buf);
}

template <typename OutputIt, typename Locale, typename... T,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
                            detail::is_locale<Locale>::value)>
FMT_INLINE auto format_to(OutputIt out, const Locale& loc,
                          format_string<T...> fmt, T&&... args) -> OutputIt {
  return vformat_to(out, loc, fmt, fmt::make_format_args(args...));
}

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#ifdef FMT_DEPRECATED_INCLUDE_XCHAR
#  include "xchar.h"
#endif

#ifdef FMT_HEADER_ONLY
#  define FMT_FUNC inline
#  include "format-inl.h"
#else
#  define FMT_FUNC
#endif

#endif  // FMT_FORMAT_H_


================================================
FILE: examples/libraries/fmt/include/fmt/locale.h
================================================
#include "xchar.h"
#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead


================================================
FILE: examples/libraries/fmt/include/fmt/os.h
================================================
// Formatting library for C++ - optional OS-specific functionality
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_OS_H_
#define FMT_OS_H_

#include <cerrno>
#include <clocale>  // locale_t
#include <cstddef>
#include <cstdio>
#include <cstdlib>       // strtod_l
#include <system_error>  // std::system_error

#if defined __APPLE__ || defined(__FreeBSD__)
#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
#endif

#include "format.h"

// UWP doesn't provide _pipe.
#if FMT_HAS_INCLUDE("winapifamily.h")
#  include <winapifamily.h>
#endif
#if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
     defined(__linux__)) &&                              \
    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
#  include <fcntl.h>  // for O_RDONLY
#  define FMT_USE_FCNTL 1
#else
#  define FMT_USE_FCNTL 0
#endif

#ifndef FMT_POSIX
#  if defined(_WIN32) && !defined(__MINGW32__)
// Fix warnings about deprecated symbols.
#    define FMT_POSIX(call) _##call
#  else
#    define FMT_POSIX(call) call
#  endif
#endif

// Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM
#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else
#  define FMT_SYSTEM(call) ::call
#  ifdef _WIN32
// Fix warnings about deprecated symbols.
#    define FMT_POSIX_CALL(call) ::_##call
#  else
#    define FMT_POSIX_CALL(call) ::call
#  endif
#endif

// Retries the expression while it evaluates to error_result and errno
// equals to EINTR.
#ifndef _WIN32
#  define FMT_RETRY_VAL(result, expression, error_result) \
    do {                                                  \
      (result) = (expression);                            \
    } while ((result) == (error_result) && errno == EINTR)
#else
#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
#endif

#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)

FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN

/**
  \rst
  A reference to a null-terminated string. It can be constructed from a C
  string or ``std::string``.

  You can use one of the following type aliases for common character types:

  +---------------+-----------------------------+
  | Type          | Definition                  |
  +===============+=============================+
  | cstring_view  | basic_cstring_view<char>    |
  +---------------+-----------------------------+
  | wcstring_view | basic_cstring_view<wchar_t> |
  +---------------+-----------------------------+

  This class is most useful as a parameter type to allow passing
  different types of strings to a function, for example::

    template <typename... Args>
    std::string format(cstring_view format_str, const Args & ... args);

    format("{}", 42);
    format(std::string("{}"), 42);
  \endrst
 */
template <typename Char> class basic_cstring_view {
 private:
  const Char* data_;

 public:
  /** Constructs a string reference object from a C string. */
  basic_cstring_view(const Char* s) : data_(s) {}

  /**
    \rst
    Constructs a string reference from an ``std::string`` object.
    \endrst
   */
  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}

  /** Returns the pointer to a C string. */
  const Char* c_str() const { return data_; }
};

using cstring_view = basic_cstring_view<char>;
using wcstring_view = basic_cstring_view<wchar_t>;

template <typename Char> struct formatter<std::error_code, Char> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto out = ctx.out();
    out = detail::write_bytes(out, ec.category().name(),
                              basic_format_specs<Char>());
    out = detail::write<Char>(out, Char(':'));
    out = detail::write<Char>(out, ec.value());
    return out;
  }
};

#ifdef _WIN32
FMT_API const std::error_category& system_category() FMT_NOEXCEPT;

FMT_BEGIN_DETAIL_NAMESPACE
// A converter from UTF-16 to UTF-8.
// It is only provided for Windows since other systems support UTF-8 natively.
class utf16_to_utf8 {
 private:
  memory_buffer buffer_;

 public:
  utf16_to_utf8() {}
  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
  operator string_view() const { return string_view(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const char* c_str() const { return &buffer_[0]; }
  std::string str() const { return std::string(&buffer_[0], size()); }

  // Performs conversion returning a system error code instead of
  // throwing exception on conversion error. This method may still throw
  // in case of memory allocation error.
  FMT_API int convert(basic_string_view<wchar_t> s);
};

FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                  const char* message) FMT_NOEXCEPT;
FMT_END_DETAIL_NAMESPACE

FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                         format_args args);

/**
 \rst
 Constructs a :class:`std::system_error` object with the description
 of the form

 .. parsed-literal::
   *<message>*: *<system-message>*

 where *<message>* is the formatted message and *<system-message>* is the
 system message corresponding to the error code.
 *error_code* is a Windows error code as given by ``GetLastError``.
 If *error_code* is not a valid error code such as -1, the system message
 will look like "error -1".

 **Example**::

   // This throws a system_error with the description
   //   cannot open file 'madeup': The system cannot find the file specified.
   // or similar (system message may vary).
   const char *filename = "madeup";
   LPOFSTRUCT of = LPOFSTRUCT();
   HFILE file = OpenFile(filename, &of, OF_READ);
   if (file == HFILE_ERROR) {
     throw fmt::windows_error(GetLastError(),
                              "cannot open file '{}'", filename);
   }
 \endrst
*/
template <typename... Args>
std::system_error windows_error(int error_code, string_view message,
                                const Args&... args) {
  return vwindows_error(error_code, message, fmt::make_format_args(args...));
}

// Reports a Windows error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_windows_error(int error_code,
                                  const char* message) FMT_NOEXCEPT;
#else
inline const std::error_category& system_category() FMT_NOEXCEPT {
  return std::system_category();
}
#endif  // _WIN32

// std::system is not available on some platforms such as iOS (#2248).
#ifdef __OSX__
template <typename S, typename... Args, typename Char = char_t<S>>
void say(const S& format_str, Args&&... args) {
  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
}
#endif

// A buffered file.
class buffered_file {
 private:
  FILE* file_;

  friend class file;

  explicit buffered_file(FILE* f) : file_(f) {}

 public:
  buffered_file(const buffered_file&) = delete;
  void operator=(const buffered_file&) = delete;

  // Constructs a buffered_file object which doesn't represent any file.
  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}

  // Destroys the object closing the file it represents if any.
  FMT_API ~buffered_file() FMT_NOEXCEPT;

 public:
  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
    other.file_ = nullptr;
  }

  buffered_file& operator=(buffered_file&& other) {
    close();
    file_ = other.file_;
    other.file_ = nullptr;
    return *this;
  }

  // Opens a file.
  FMT_API buffered_file(cstring_view filename, cstring_view mode);

  // Closes the file.
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
  FILE* get() const FMT_NOEXCEPT { return file_; }

  // We place parentheses around fileno to workaround a bug in some versions
  // of MinGW that define fileno as a macro.
  FMT_API int(fileno)() const;

  void vprint(string_view format_str, format_args args) {
    fmt::vprint(file_, format_str, args);
  }

  template <typename... Args>
  inline void print(string_view format_str, const Args&... args) {
    vprint(format_str, fmt::make_format_args(args...));
  }
};

#if FMT_USE_FCNTL
// A file. Closed file is represented by a file object with descriptor -1.
// Methods that are not declared with FMT_NOEXCEPT may throw
// fmt::system_error in case of failure. Note that some errors such as
// closing the file multiple times will cause a crash on Windows rather
// than an exception. You can get standard behavior by overriding the
// invalid parameter handler with _set_invalid_parameter_handler.
class file {
 private:
  int fd_;  // File descriptor.

  // Constructs a file object with a given descriptor.
  explicit file(int fd) : fd_(fd) {}

 public:
  // Possible values for the oflag argument to the constructor.
  enum {
    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
    RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
    CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
  };

  // Constructs a file object which doesn't represent any file.
  file() FMT_NOEXCEPT : fd_(-1) {}

  // Opens a file and constructs a file object representing this file.
  FMT_API file(cstring_view path, int oflag);

 public:
  file(const file&) = delete;
  void operator=(const file&) = delete;

  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }

  // Move assignment is not noexcept because close may throw.
  file& operator=(file&& other) {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
    return *this;
  }

  // Destroys the object closing the file it represents if any.
  FMT_API ~file() FMT_NOEXCEPT;

  // Returns the file descriptor.
  int descriptor() const FMT_NOEXCEPT { return fd_; }

  // Closes the file.
  FMT_API void close();

  // Returns the file size. The size has signed type for consistency with
  // stat::st_size.
  FMT_API long long size() const;

  // Attempts to read count bytes from the file into the specified buffer.
  FMT_API size_t read(void* buffer, size_t count);

  // Attempts to write count bytes from the specified buffer to the file.
  FMT_API size_t write(const void* buffer, size_t count);

  // Duplicates a file descriptor with the dup function and returns
  // the duplicate as a file object.
  FMT_API static file dup(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd);

  // Makes fd be the copy of this file descriptor, closing fd first if
  // necessary.
  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;

  // Creates a pipe setting up read_end and write_end file objects for reading
  // and writing respectively.
  FMT_API static void pipe(file& read_end, file& write_end);

  // Creates a buffered_file object associated with this file and detaches
  // this file object from the file.
  FMT_API buffered_file fdopen(const char* mode);
};

// Returns the memory page size.
long getpagesize();

FMT_BEGIN_DETAIL_NAMESPACE

struct buffer_size {
  buffer_size() = default;
  size_t value = 0;
  buffer_size operator=(size_t val) const {
    auto bs = buffer_size();
    bs.value = val;
    return bs;
  }
};

struct ostream_params {
  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;

  ostream_params() {}

  template <typename... T>
  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
    oflag = new_oflag;
  }

  template <typename... T>
  ostream_params(T... params, detail::buffer_size bs)
      : ostream_params(params...) {
    this->buffer_size = bs.value;
  }
};

FMT_END_DETAIL_NAMESPACE

constexpr detail::buffer_size buffer_size;

/** A fast output stream which is not thread-safe. */
class FMT_API ostream final : private detail::buffer<char> {
 private:
  file file_;

  void flush() {
    if (size() == 0) return;
    file_.write(data(), size());
    clear();
  }

  void grow(size_t) override;

  ostream(cstring_view path, const detail::ostream_params& params)
      : file_(path, params.oflag) {
    set(new char[params.buffer_size], params.buffer_size);
  }

 public:
  ostream(ostream&& other)
      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
        file_(std::move(other.file_)) {
    other.clear();
    other.set(nullptr, 0);
  }
  ~ostream() {
    flush();
    delete[] data();
  }

  template <typename... T>
  friend ostream output_file(cstring_view path, T... params);

  void close() {
    flush();
    file_.close();
  }

  /**
    Formats ``args`` according to specifications in ``fmt`` and writes the
    output to the file.
   */
  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
    vformat_to(detail::buffer_appender<char>(*this), fmt,
               fmt::make_format_args(args...));
  }
};

/**
  \rst
  Opens a file for writing. Supported parameters passed in *params*:

  * ``<integer>``: Flags passed to `open
    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
    (``file::WRONLY | file::CREATE`` by default)
  * ``buffer_size=<integer>``: Output buffer size

  **Example**::

    auto out = fmt::output_file("guide.txt");
    out.print("Don't {}", "Panic");
  \endrst
 */
template <typename... T>
inline ostream output_file(cstring_view path, T... params) {
  return {path, detail::ostream_params(params...)};
}
#endif  // FMT_USE_FCNTL

#ifdef FMT_LOCALE
// A "C" numeric locale.
class locale {
 private:
#  ifdef _WIN32
  using locale_t = _locale_t;

  static void freelocale(locale_t loc) { _free_locale(loc); }

  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
    return _strtod_l(nptr, endptr, loc);
  }
#  endif

  locale_t locale_;

 public:
  using type = locale_t;
  locale(const locale&) = delete;
  void operator=(const locale&) = delete;

  locale() {
#  ifndef _WIN32
    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
#  else
    locale_ = _create_locale(LC_NUMERIC, "C");
#  endif
    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
  }
  ~locale() { freelocale(locale_); }

  type get() const { return locale_; }

  // Converts string to floating-point number and advances str past the end
  // of the parsed input.
  double strtod(const char*& str) const {
    char* end = nullptr;
    double result = strtod_l(str, &end, locale_);
    str = end;
    return result;
  }
};
using Locale FMT_DEPRECATED_ALIAS = locale;
#endif  // FMT_LOCALE
FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_OS_H_


================================================
FILE: examples/libraries/fmt/include/fmt/ostream.h
================================================
// Formatting library for C++ - std::ostream support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_

#include <ostream>

#include "format.h"

FMT_BEGIN_NAMESPACE

template <typename Char> class basic_printf_parse_context;
template <typename OutputIt, typename Char> class basic_printf_context;

namespace detail {

template <class Char> class formatbuf : public std::basic_streambuf<Char> {
 private:
  using int_type = typename std::basic_streambuf<Char>::int_type;
  using traits_type = typename std::basic_streambuf<Char>::traits_type;

  buffer<Char>& buffer_;

 public:
  formatbuf(buffer<Char>& buf) : buffer_(buf) {}

 protected:
  // The put-area is actually always empty. This makes the implementation
  // simpler and has the advantage that the streambuf and the buffer are always
  // in sync and sputc never writes into uninitialized memory. The obvious
  // disadvantage is that each call to sputc always results in a (virtual) call
  // to overflow. There is no disadvantage here for sputn since this always
  // results in a call to xsputn.

  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
    if (!traits_type::eq_int_type(ch, traits_type::eof()))
      buffer_.push_back(static_cast<Char>(ch));
    return ch;
  }

  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
    buffer_.append(s, s + count);
    return count;
  }
};

struct converter {
  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> converter(T);
};

template <typename Char> struct test_stream : std::basic_ostream<Char> {
 private:
  void_t<> operator<<(converter);
};

// Hide insertion operators for built-in types.
template <typename Char, typename Traits>
void_t<> operator<<(std::basic_ostream<Char, Traits>&, Char);
template <typename Char, typename Traits>
void_t<> operator<<(std::basic_ostream<Char, Traits>&, char);
template <typename Traits>
void_t<> operator<<(std::basic_ostream<char, Traits>&, char);
template <typename Traits>
void_t<> operator<<(std::basic_ostream<char, Traits>&, signed char);
template <typename Traits>
void_t<> operator<<(std::basic_ostream<char, Traits>&, unsigned char);

// Checks if T has a user-defined operator<< (e.g. not a member of
// std::ostream).
template <typename T, typename Char> class is_streamable {
 private:
  template <typename U>
  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
                                              << std::declval<U>()),
                                     void_t<>>::value>
  test(int);

  template <typename> static std::false_type test(...);

  using result = decltype(test<T>(0));

 public:
  is_streamable() = default;

  static const bool value = result::value;
};

// Write the content of buf to os.
template <typename Char>
void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  const Char* buf_data = buf.data();
  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
  unsigned_streamsize size = buf.size();
  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
  do {
    unsigned_streamsize n = size <= max_size ? size : max_size;
    os.write(buf_data, static_cast<std::streamsize>(n));
    buf_data += n;
    size -= n;
  } while (size != 0);
}

template <typename Char, typename T>
void format_value(buffer<Char>& buf, const T& value,
                  locale_ref loc = locale_ref()) {
  formatbuf<Char> format_buf(buf);
  std::basic_ostream<Char> output(&format_buf);
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
  if (loc) output.imbue(loc.get<std::locale>());
#endif
  output << value;
  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
  buf.try_resize(buf.size());
}

// Formats an object of type T that has an overloaded ostream operator<<.
template <typename T, typename Char>
struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
    : private formatter<basic_string_view<Char>, Char> {
  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
      -> decltype(ctx.begin()) {
    return formatter<basic_string_view<Char>, Char>::parse(ctx);
  }
  template <typename ParseCtx,
            FMT_ENABLE_IF(std::is_same<
                          ParseCtx, basic_printf_parse_context<Char>>::value)>
  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename OutputIt>
  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
      -> OutputIt {
    basic_memory_buffer<Char> buffer;
    format_value(buffer, value, ctx.locale());
    basic_string_view<Char> str(buffer.data(), buffer.size());
    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
  }
  template <typename OutputIt>
  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
      -> OutputIt {
    basic_memory_buffer<Char> buffer;
    format_value(buffer, value, ctx.locale());
    return std::copy(buffer.begin(), buffer.end(), ctx.out());
  }
};
}  // namespace detail

FMT_MODULE_EXPORT
template <typename Char>
void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  basic_memory_buffer<Char> buffer;
  detail::vformat_to(buffer, format_str, args);
  detail::write_buffer(os, buffer);
}

/**
  \rst
  Prints formatted data to the stream *os*.

  **Example**::

    fmt::print(cerr, "Don't {}!", "panic");
  \endrst
 */
FMT_MODULE_EXPORT
template <typename S, typename... Args,
          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
  vprint(os, to_string_view(format_str),
         fmt::make_args_checked<Args...>(format_str, args...));
}
FMT_END_NAMESPACE

#endif  // FMT_OSTREAM_H_


================================================
FILE: examples/libraries/fmt/include/fmt/printf.h
================================================
// Formatting library for C++ - legacy printf implementation
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_PRINTF_H_
#define FMT_PRINTF_H_

#include <algorithm>  // std::max
#include <limits>     // std::numeric_limits
#include <ostream>

#include "format.h"

FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN

template <typename T> struct printf_formatter { printf_formatter() = delete; };

template <typename Char>
class basic_printf_parse_context : public basic_format_parse_context<Char> {
  using basic_format_parse_context<Char>::basic_format_parse_context;
};

template <typename OutputIt, typename Char> class basic_printf_context {
 private:
  OutputIt out_;
  basic_format_args<basic_printf_context> args_;

 public:
  using char_type = Char;
  using format_arg = basic_format_arg<basic_printf_context>;
  using parse_context_type = basic_printf_parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;

  /**
    \rst
    Constructs a ``printf_context`` object. References to the arguments are
    stored in the context object so make sure they have appropriate lifetimes.
    \endrst
   */
  basic_printf_context(OutputIt out,
                       basic_format_args<basic_printf_context> args)
      : out_(out), args_(args) {}

  OutputIt out() { return out_; }
  void advance_to(OutputIt it) { out_ = it; }

  detail::locale_ref locale() { return {}; }

  format_arg arg(int id) const { return args_.get(id); }

  FMT_CONSTEXPR void on_error(const char* message) {
    detail::error_handler().on_error(message);
  }
};

FMT_BEGIN_DETAIL_NAMESPACE

// Checks if a value fits in int - used to avoid warnings about comparing
// signed and unsigned integers.
template <bool IsSigned> struct int_checker {
  template <typename T> static bool fits_in_int(T value) {
    unsigned max = max_value<int>();
    return value <= max;
  }
  static bool fits_in_int(bool) { return true; }
};

template <> struct int_checker<true> {
  template <typename T> static bool fits_in_int(T value) {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
  static bool fits_in_int(int) { return true; }
};

class printf_precision_handler {
 public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  int operator()(T value) {
    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
      FMT_THROW(format_error("number is too big"));
    return (std::max)(static_cast<int>(value), 0);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  int operator()(T) {
    FMT_THROW(format_error("precision is not integer"));
    return 0;
  }
};

// An argument visitor that returns true iff arg is a zero integer.
class is_zero_int {
 public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  bool operator()(T value) {
    return value == 0;
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  bool operator()(T) {
    return false;
  }
};

template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};

template <> struct make_unsigned_or_bool<bool> { using type = bool; };

template <typename T, typename Context> class arg_converter {
 private:
  using char_type = typename Context::char_type;

  basic_format_arg<Context>& arg_;
  char_type type_;

 public:
  arg_converter(basic_format_arg<Context>& arg, char_type type)
      : arg_(arg), type_(type) {}

  void operator()(bool value) {
    if (type_ != 's') operator()<bool>(value);
  }

  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
  void operator()(U value) {
    bool is_signed = type_ == 'd' || type_ == 'i';
    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
    if (const_check(sizeof(target_type) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
      if (is_signed) {
        arg_ = detail::make_arg<Context>(
            static_cast<int>(static_cast<target_type>(value)));
      } else {
        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
        arg_ = detail::make_arg<Context>(
            static_cast<unsigned>(static_cast<unsigned_type>(value)));
      }
    } else {
      if (is_signed) {
        // glibc's printf doesn't sign extend arguments of smaller types:
        //   std::printf("%lld", -42);  // prints "4294967254"
        // but we don't have to do the same because it's a UB.
        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
      } else {
        arg_ = detail::make_arg<Context>(
            static_cast<typename make_unsigned_or_bool<U>::type>(value));
      }
    }
  }

  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
  void operator()(U) {}  // No conversion needed for non-integral types.
};

// Converts an integer argument to T for printf, if T is an integral type.
// If T is void, the argument is converted to corresponding signed or unsigned
// type depending on the type specifier: 'd' and 'i' - signed, other -
// unsigned).
template <typename T, typename Context, typename Char>
void convert_arg(basic_format_arg<Context>& arg, Char type) {
  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
}

// Converts an integer argument to char for printf.
template <typename Context> class char_converter {
 private:
  basic_format_arg<Context>& arg_;

 public:
  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  void operator()(T value) {
    arg_ = detail::make_arg<Context>(
        static_cast<typename Context::char_type>(value));
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  void operator()(T) {}  // No conversion needed for non-integral types.
};

// An argument visitor that return a pointer to a C string if argument is a
// string or null otherwise.
template <typename Char> struct get_cstring {
  template <typename T> const Char* operator()(T) { return nullptr; }
  const Char* operator()(const Char* s) { return s; }
};

// Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative.
template <typename Char> class printf_width_handler {
 private:
  using format_specs = basic_format_specs<Char>;

  format_specs& specs_;

 public:
  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  unsigned operator()(T value) {
    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
    if (detail::is_negative(value)) {
      specs_.align = align::left;
      width = 0 - width;
    }
    unsigned int_max = max_value<int>();
    if (width > int_max) FMT_THROW(format_error("number is too big"));
    return static_cast<unsigned>(width);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
  unsigned operator()(T) {
    FMT_THROW(format_error("width is not integer"));
    return 0;
  }
};

// The ``printf`` argument formatter.
template <typename OutputIt, typename Char>
class printf_arg_formatter : public arg_formatter<Char> {
 private:
  using base = arg_formatter<Char>;
  using context_type = basic_printf_context<OutputIt, Char>;
  using format_specs = basic_format_specs<Char>;

  context_type& context_;

  OutputIt write_null_pointer(bool is_string = false) {
    auto s = this->specs;
    s.type = 0;
    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
  }

 public:
  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
      : base{iter, s, locale_ref()}, context_(ctx) {}

  OutputIt operator()(monostate value) { return base::operator()(value); }

  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
  OutputIt operator()(T value) {
    // MSVC2013 fails to compile separate overloads for bool and Char so use
    // std::is_same instead.
    if (std::is_same<T, Char>::value) {
      format_specs fmt_specs = this->specs;
      if (fmt_specs.type && fmt_specs.type != 'c')
        return (*this)(static_cast<int>(value));
      fmt_specs.sign = sign::none;
      fmt_specs.alt = false;
      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
      // align::numeric needs to be overwritten here since the '0' flag is
      // ignored for non-numeric types
      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
        fmt_specs.align = align::right;
      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
    }
    return base::operator()(value);
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
  OutputIt operator()(T value) {
    return base::operator()(value);
  }

  /** Formats a null-terminated C string. */
  OutputIt operator()(const char* value) {
    if (value) return base::operator()(value);
    return write_null_pointer(this->specs.type != 'p');
  }

  /** Formats a null-terminated wide C string. */
  OutputIt operator()(const wchar_t* value) {
    if (value) return base::operator()(value);
    return write_null_pointer(this->specs.type != 'p');
  }

  OutputIt operator()(basic_string_view<Char> value) {
    return base::operator()(value);
  }

  /** Formats a pointer. */
  OutputIt operator()(const void* value) {
    return value ? base::operator()(value) : write_null_pointer();
  }

  /** Formats an argument of a custom (user-defined) type. */
  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
    auto parse_ctx =
        basic_printf_parse_context<Char>(basic_string_view<Char>());
    handle.format(parse_ctx, context_);
    return this->out;
  }
};

template <typename Char>
void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
                 const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
    case '-':
      specs.align = align::left;
      break;
    case '+':
      specs.sign = sign::plus;
      break;
    case '0':
      specs.fill[0] = '0';
      break;
    case ' ':
      if (specs.sign != sign::plus) {
        specs.sign = sign::space;
      }
      break;
    case '#':
      specs.alt = true;
      break;
    default:
      return;
    }
  }
}

template <typename Char, typename GetArg>
int parse_header(const Char*& it, const Char* end,
                 basic_format_specs<Char>& specs, GetArg get_arg) {
  int arg_index = -1;
  Char c = *it;
  if (c >= '0' && c <= '9') {
    // Parse an argument index (if followed by '$') or a width possibly
    // preceded with '0' flag(s).
    int value = parse_nonnegative_int(it, end, -1);
    if (it != end && *it == '$') {  // value is an argument index
      ++it;
      arg_index = value != -1 ? value : max_value<int>();
    } else {
      if (c == '0') specs.fill[0] = '0';
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
        if (value == -1) FMT_THROW(format_error("number is too big"));
        specs.width = value;
        return arg_index;
      }
    }
  }
  parse_flags(specs, it, end);
  // Parse width.
  if (it != end) {
    if (*it >= '0' && *it <= '9') {
      specs.width = parse_nonnegative_int(it, end, -1);
      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
    } else if (*it == '*') {
      ++it;
      specs.width = static_cast<int>(visit_format_arg(
          detail::printf_width_handler<Char>(specs), get_arg(-1)));
    }
  }
  return arg_index;
}

template <typename Char, typename Context>
void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
             basic_format_args<Context> args) {
  using OutputIt = buffer_appender<Char>;
  auto out = OutputIt(buf);
  auto context = basic_printf_context<OutputIt, Char>(out, args);
  auto parse_ctx = basic_printf_parse_context<Char>(format);

  // Returns the argument with specified index or, if arg_index is -1, the next
  // argument.
  auto get_arg = [&](int arg_index) {
    if (arg_index < 0)
      arg_index = parse_ctx.next_arg_id();
    else
      parse_ctx.check_arg_id(--arg_index);
    return detail::get_arg(context, arg_index);
  };

  const Char* start = parse_ctx.begin();
  const Char* end = parse_ctx.end();
  auto it = start;
  while (it != end) {
    if (!detail::find<false, Char>(it, end, '%', it)) {
      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
      break;
    }
    Char c = *it++;
    if (it != end && *it == c) {
      out = detail::write(
          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
      start = ++it;
      continue;
    }
    out = detail::write(out, basic_string_view<Char>(
                                 start, detail::to_unsigned(it - 1 - start)));

    basic_format_specs<Char> specs;
    specs.align = align::right;

    // Parse argument index, flags and width.
    int arg_index = parse_header(it, end, specs, get_arg);
    if (arg_index == 0) parse_ctx.on_error("argument not found");

    // Parse precision.
    if (it != end && *it == '.') {
      ++it;
      c = it != end ? *it : 0;
      if ('0' <= c && c <= '9') {
        specs.precision = parse_nonnegative_int(it, end, 0);
      } else if (c == '*') {
        ++it;
        specs.precision = static_cast<int>(
            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
      } else {
        specs.precision = 0;
      }
    }

    auto arg = get_arg(arg_index);
    // For d, i, o, u, x, and X conversion specifiers, if a precision is
    // specified, the '0' flag is ignored
    if (specs.precision >= 0 && arg.is_integral())
      specs.fill[0] =
          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
      auto str_end = str + specs.precision;
      auto nul = std::find(str, str_end, Char());
      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
          basic_string_view<Char>(
              str, detail::to_unsigned(nul != str_end ? nul - str
                                                      : specs.precision)));
    }
    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
      specs.alt = false;
    if (specs.fill[0] == '0') {
      if (arg.is_arithmetic() && specs.align != align::left)
        specs.align = align::numeric;
      else
        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
                              // flag is also present.
    }

    // Parse length and convert the argument to the required type.
    c = it != end ? *it++ : 0;
    Char t = it != end ? *it : 0;
    using detail::convert_arg;
    switch (c) {
    case 'h':
      if (t == 'h') {
        ++it;
        t = it != end ? *it : 0;
        convert_arg<signed char>(arg, t);
      } else {
        convert_arg<short>(arg, t);
      }
      break;
    case 'l':
      if (t == 'l') {
        ++it;
        t = it != end ? *it : 0;
        convert_arg<long long>(arg, t);
      } else {
        convert_arg<long>(arg, t);
      }
      break;
    case 'j':
      convert_arg<intmax_t>(arg, t);
      break;
    case 'z':
      convert_arg<size_t>(arg, t);
      break;
    case 't':
      convert_arg<std::ptrdiff_t>(arg, t);
      break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
    default:
      --it;
      convert_arg<void>(arg, c);
    }

    // Parse type.
    if (it == end) FMT_THROW(format_error("invalid format string"));
    specs.type = static_cast<char>(*it++);
    if (arg.is_integral()) {
      // Normalize type.
      switch (specs.type) {
      case 'i':
      case 'u':
        specs.type = 'd';
        break;
      case 'c':
        visit_format_arg(
            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
            arg);
        break;
      }
    }

    start = it;

    // Format argument.
    out = visit_format_arg(
        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
  }
  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
}
FMT_END_DETAIL_NAMESPACE

template <typename Char>
using basic_printf_context_t =
    basic_printf_context<detail::buffer_appender<Char>, Char>;

using printf_context = basic_printf_context_t<char>;
using wprintf_context = basic_printf_context_t<wchar_t>;

using printf_args = basic_format_args<printf_context>;
using wprintf_args = basic_format_args<wprintf_context>;

/**
  \rst
  Constructs an `~fmt::format_arg_store` object that contains references to
  arguments and can be implicitly converted to `~fmt::printf_args`.
  \endrst
 */
template <typename... T>
inline auto make_printf_args(const T&... args)
    -> format_arg_store<printf_context, T...> {
  return {args...};
}

/**
  \rst
  Constructs an `~fmt::format_arg_store` object that contains references to
  arguments and can be implicitly converted to `~fmt::wprintf_args`.
  \endrst
 */
template <typename... T>
inline auto make_wprintf_args(const T&... args)
    -> format_arg_store<wprintf_context, T...> {
  return {args...};
}

template <typename S, typename Char = char_t<S>>
inline auto vsprintf(
    const S& fmt,
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  basic_memory_buffer<Char> buffer;
  vprintf(buffer, to_string_view(fmt), args);
  return to_string(buffer);
}

/**
  \rst
  Formats arguments and returns the result as a string.

  **Example**::

    std::string message = fmt::sprintf("The answer is %d", 42);
  \endrst
*/
template <typename S, typename... T,
          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  using context = basic_printf_context_t<Char>;
  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
}

template <typename S, typename Char = char_t<S>>
inline auto vfprintf(
    std::FILE* f, const S& fmt,
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
  basic_memory_buffer<Char> buffer;
  vprintf(buffer, to_string_view(fmt), args);
  size_t size = buffer.size();
  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
             ? -1
             : static_cast<int>(size);
}

/**
  \rst
  Prints formatted data to the file *f*.

  **Example**::

    fmt::fprintf(stderr, "Don't %s!", "panic");
  \endrst
 */
template <typename S, typename... T, typename Char = char_t<S>>
inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  using context = basic_printf_context_t<Char>;
  return vfprintf(f, to_string_view(fmt),
                  fmt::make_format_args<context>(args...));
}

template <typename S, typename Char = char_t<S>>
inline auto vprintf(
    const S& fmt,
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
  return vfprintf(stdout, to_string_view(fmt), args);
}

/**
  \rst
  Prints formatted data to ``stdout``.

  **Example**::

    fmt::printf("Elapsed time: %.2f seconds", 1.23);
  \endrst
 */
template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
inline auto printf(const S& fmt, const T&... args) -> int {
  return vprintf(
      to_string_view(fmt),
      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
}

template <typename S, typename Char = char_t<S>>
FMT_DEPRECATED auto vfprintf(
    std::basic_ostream<Char>& os, const S& fmt,
    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
    -> int {
  basic_memory_buffer<Char> buffer;
  vprintf(buffer, to_string_view(fmt), args);
  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
  return static_cast<int>(buffer.size());
}
template <typename S, typename... T, typename Char = char_t<S>>
FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
                            const T&... args) -> int {
  return vfprintf(os, to_string_view(fmt),
                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
}

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_PRINTF_H_


================================================
FILE: examples/libraries/fmt/include/fmt/ranges.h
================================================
// Formatting library for C++ - experimental range support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
//
// Copyright (c) 2018 - present, Remotion (Igor Schulz)
// All Rights Reserved
// {fmt} support for ranges, containers and types tuple interface.

#ifndef FMT_RANGES_H_
#define FMT_RANGES_H_

#include <initializer_list>
#include <type_traits>

#include "format.h"

FMT_BEGIN_NAMESPACE

template <typename Char, typename Enable = void> struct formatting_range {
#ifdef FMT_DEPRECATED_BRACED_RANGES
  Char prefix = '{';
  Char postfix = '}';
#else
  Char prefix = '[';
  Char postfix = ']';
#endif

  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
};

template <typename Char, typename Enable = void> struct formatting_tuple {
  Char prefix = '(';
  Char postfix = ')';

  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
};

namespace detail {

template <typename RangeT, typename OutputIterator>
OutputIterator copy(const RangeT& range, OutputIterator out) {
  for (auto it = range.begin(), end = range.end(); it != end; ++it)
    *out++ = *it;
  return out;
}

template <typename OutputIterator>
OutputIterator copy(const char* str, OutputIterator out) {
  while (*str) *out++ = *str++;
  return out;
}

template <typename OutputIterator>
OutputIterator copy(char ch, OutputIterator out) {
  *out++ = ch;
  return out;
}

template <typename OutputIterator>
OutputIterator copy(wchar_t ch, OutputIterator out) {
  *out++ = ch;
  return out;
}

/// Return true value if T has std::string interface, like std::string_view.
template <typename T> class is_std_string_like {
  template <typename U>
  static auto check(U* p)
      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
  template <typename> static void check(...);

 public:
  static FMT_CONSTEXPR_DECL const bool value =
      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
};

template <typename Char>
struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};

template <typename... Ts> struct conditional_helper {};

template <typename T, typename _ = void> struct is_range_ : std::false_type {};

#if !FMT_MSC_VER || FMT_MSC_VER > 1800

#  define FMT_DECLTYPE_RETURN(val)  \
    ->decltype(val) { return val; } \
    static_assert(                  \
        true, "")  // This makes it so that a semicolon is required after the
                   // macro, which helps clang-format handle the formatting.

// C array overload
template <typename T, std::size_t N>
auto range_begin(const T (&arr)[N]) -> const T* {
  return arr;
}
template <typename T, std::size_t N>
auto range_end(const T (&arr)[N]) -> const T* {
  return arr + N;
}

template <typename T, typename Enable = void>
struct has_member_fn_begin_end_t : std::false_type {};

template <typename T>
struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
                                           decltype(std::declval<T>().end())>>
    : std::true_type {};

// Member function overload
template <typename T>
auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
template <typename T>
auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());

// ADL overload. Only participates in overload resolution if member functions
// are not found.
template <typename T>
auto range_begin(T&& rng)
    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
                   decltype(begin(static_cast<T&&>(rng)))> {
  return begin(static_cast<T&&>(rng));
}
template <typename T>
auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
                                       decltype(end(static_cast<T&&>(rng)))> {
  return end(static_cast<T&&>(rng));
}

template <typename T, typename Enable = void>
struct has_const_begin_end : std::false_type {};
template <typename T, typename Enable = void>
struct has_mutable_begin_end : std::false_type {};

template <typename T>
struct has_const_begin_end<
    T, void_t<decltype(detail::range_begin(
                  std::declval<const remove_cvref_t<T>&>())),
              decltype(detail::range_begin(
                  std::declval<const remove_cvref_t<T>&>()))>>
    : std::true_type {};

template <typename T>
struct has_mutable_begin_end<
    T, void_t<decltype(detail::range_begin(std::declval<T>())),
              decltype(detail::range_begin(std::declval<T>())),
              enable_if_t<std::is_copy_constructible<T>::value>>>
    : std::true_type {};

template <typename T>
struct is_range_<T, void>
    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
                                    has_mutable_begin_end<T>::value)> {};

template <typename T, typename Enable = void> struct range_to_view;
template <typename T>
struct range_to_view<T, enable_if_t<has_const_begin_end<T>::value>> {
  struct view_t {
    const T* m_range_ptr;

    auto begin() const FMT_DECLTYPE_RETURN(detail::range_begin(*m_range_ptr));
    auto end() const FMT_DECLTYPE_RETURN(detail::range_end(*m_range_ptr));
  };
  static auto view(const T& range) -> view_t { return {&range}; }
};

template <typename T>
struct range_to_view<T, enable_if_t<!has_const_begin_end<T>::value &&
                                    has_mutable_begin_end<T>::value>> {
  struct view_t {
    T m_range_copy;

    auto begin() FMT_DECLTYPE_RETURN(detail::range_begin(m_range_copy));
    auto end() FMT_DECLTYPE_RETURN(detail::range_end(m_range_copy));
  };
  static auto view(const T& range) -> view_t { return {range}; }
};
#  undef FMT_DECLTYPE_RETURN
#endif

/// tuple_size and tuple_element check.
template <typename T> class is_tuple_like_ {
  template <typename U>
  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
  template <typename> static void check(...);

 public:
  static FMT_CONSTEXPR_DECL const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value;
};

// Check for integer_sequence
#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
template <typename T, T... N>
using integer_sequence = std::integer_sequence<T, N...>;
template <size_t... N> using index_sequence = std::index_sequence<N...>;
template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
#else
template <typename T, T... N> struct integer_sequence {
  using value_type = T;

  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
};

template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;

template <typename T, size_t N, T... Ns>
struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
template <typename T, T... Ns>
struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};

template <size_t N>
using make_index_sequence = make_integer_sequence<size_t, N>;
#endif

template <class Tuple, class F, size_t... Is>
void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
  using std::get;
  // using free function get<I>(T) now.
  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
  (void)_;  // blocks warnings
}

template <class T>
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
    T const&) {
  return {};
}

template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
  const auto indexes = get_indexes(tup);
  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
}

template <typename Range>
using value_type =
    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;

template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
  *out++ = ',';
  *out++ = ' ';
  return out;
}

template <
    typename Char, typename OutputIt, typename Arg,
    FMT_ENABLE_IF(is_std_string_like<typename std::decay<Arg>::type>::value)>
OutputIt write_range_entry(OutputIt out, const Arg& v) {
  *out++ = '"';
  out = write<Char>(out, v);
  *out++ = '"';
  return out;
}

template <typename Char, typename OutputIt, typename Arg,
          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
OutputIt write_range_entry(OutputIt out, const Arg v) {
  *out++ = '\'';
  *out++ = v;
  *out++ = '\'';
  return out;
}

template <
    typename Char, typename OutputIt, typename Arg,
    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
                  !std::is_same<Arg, Char>::value)>
OutputIt write_range_entry(OutputIt out, const Arg& v) {
  return write<Char>(out, v);
}

}  // namespace detail

template <typename T> struct is_tuple_like {
  static FMT_CONSTEXPR_DECL const bool value =
      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
};

template <typename TupleT, typename Char>
struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
 private:
  // C++11 generic lambda for format()
  template <typename FormatContext> struct format_each {
    template <typename T> void operator()(const T& v) {
      if (i > 0) out = detail::write_delimiter(out);
      out = detail::write_range_entry<Char>(out, v);
      ++i;
    }
    formatting_tuple<Char>& formatting;
    size_t& i;
    typename std::add_lvalue_reference<
        decltype(std::declval<FormatContext>().out())>::type out;
  };

 public:
  formatting_tuple<Char> formatting;

  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return formatting.parse(ctx);
  }

  template <typename FormatContext = format_context>
  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
    auto out = ctx.out();
    size_t i = 0;

    detail::copy(formatting.prefix, out);
    detail::for_each(values, format_each<FormatContext>{formatting, i, out});
    detail::copy(formatting.postfix, out);

    return ctx.out();
  }
};

template <typename T, typename Char> struct is_range {
  static FMT_CONSTEXPR_DECL const bool value =
      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
      !std::is_convertible<T, std::basic_string<Char>>::value &&
      !std::is_constructible<detail::std_string_view<Char>, T>::value;
};

template <typename T, typename Char>
struct formatter<
    T, Char,
    enable_if_t<
        fmt::is_range<T, Char>::value
// Workaround a bug in MSVC 2017 and earlier.
#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
        && (has_formatter<detail::value_type<T>, format_context>::value ||
            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
#endif
        >> {
  formatting_range<Char> formatting;

  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return formatting.parse(ctx);
  }

  template <typename FormatContext>
  typename FormatContext::iterator format(const T& values, FormatContext& ctx) {
    auto out = detail::copy(formatting.prefix, ctx.out());
    size_t i = 0;
    auto view = detail::range_to_view<T>::view(values);
    auto it = view.begin();
    auto end = view.end();
    for (; it != end; ++it) {
      if (i > 0) out = detail::write_delimiter(out);
      out = detail::write_range_entry<Char>(out, *it);
      ++i;
    }
    return detail::copy(formatting.postfix, out);
  }
};

template <typename Char, typename... T> struct tuple_join_view : detail::view {
  const std::tuple<T...>& tuple;
  basic_string_view<Char> sep;

  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
      : tuple(t), sep{s} {}
};

template <typename Char, typename... T>
using tuple_arg_join = tuple_join_view<Char, T...>;

template <typename Char, typename... T>
struct formatter<tuple_join_view<Char, T...>, Char> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx) ->
      typename FormatContext::iterator {
    return format(value, ctx, detail::make_index_sequence<sizeof...(T)>{});
  }

 private:
  template <typename FormatContext, size_t... N>
  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
              detail::index_sequence<N...>) ->
      typename FormatContext::iterator {
    using std::get;
    return format_args(value, ctx, get<N>(value.tuple)...);
  }

  template <typename FormatContext>
  auto format_args(const tuple_join_view<Char, T...>&, FormatContext& ctx) ->
      typename FormatContext::iterator {
    // NOTE: for compilers that support C++17, this empty function instantiation
    // can be replaced with a constexpr branch in the variadic overload.
    return ctx.out();
  }

  template <typename FormatContext, typename Arg, typename... Args>
  auto format_args(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
                   const Arg& arg, const Args&... args) ->
      typename FormatContext::iterator {
    using base = formatter<typename std::decay<Arg>::type, Char>;
    auto out = base().format(arg, ctx);
    if (sizeof...(Args) > 0) {
      out = std::copy(value.sep.begin(), value.sep.end(), out);
      ctx.advance_to(out);
      return format_args(value, ctx, args...);
    }
    return out;
  }
};

FMT_MODULE_EXPORT_BEGIN

/**
  \rst
  Returns an object that formats `tuple` with elements separated by `sep`.

  **Example**::

    std::tuple<int, char> t = {1, 'a'};
    fmt::print("{}", fmt::join(t, ", "));
    // Output: "1, a"
  \endrst
 */
template <typename... T>
FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
    -> tuple_join_view<char, T...> {
  return {tuple, sep};
}

template <typename... T>
FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
                        basic_string_view<wchar_t> sep)
    -> tuple_join_view<wchar_t, T...> {
  return {tuple, sep};
}

/**
  \rst
  Returns an object that formats `initializer_list` with elements separated by
  `sep`.

  **Example**::

    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
    // Output: "1, 2, 3"
  \endrst
 */
template <typename T>
auto join(std::initializer_list<T> list, string_view sep)
    -> join_view<const T*, const T*> {
  return join(std::begin(list), std::end(list), sep);
}

FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_RANGES_H_


================================================
FILE: examples/libraries/fmt/include/fmt/xchar.h
================================================
// Formatting library for C++ - optional wchar_t and exotic character support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_WCHAR_H_
#define FMT_WCHAR_H_

#include <cwchar>
#include <tuple>

#include "format.h"

FMT_BEGIN_NAMESPACE
namespace detail {
template <typename T>
using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
}

FMT_MODULE_EXPORT_BEGIN

using wstring_view = basic_string_view<wchar_t>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;
using wformat_context = buffer_context<wchar_t>;
using wformat_args = basic_format_args<wformat_context>;
using wmemory_buffer = basic_memory_buffer<wchar_t>;

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
// Workaround broken conversion on older gcc.
template <typename... Args> using wformat_string = wstring_view;
#else
template <typename... Args>
using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
#endif

template <> struct is_char<wchar_t> : std::true_type {};
template <> struct is_char<detail::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {};

template <typename... Args>
constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
    const Args&... args) {
  return {args...};
}

inline namespace literals {
constexpr auto operator"" _format(const wchar_t* s, size_t n)
    -> detail::udl_formatter<wchar_t> {
  return {{s, n}};
}

#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
  return {s};
}
#endif
}  // namespace literals

template <typename It, typename Sentinel>
auto join(It begin, Sentinel end, wstring_view sep)
    -> join_view<It, Sentinel, wchar_t> {
  return {begin, end, sep};
}

template <typename Range>
auto join(Range&& range, wstring_view sep)
    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
                 wchar_t> {
  return join(std::begin(range), std::end(range), sep);
}

template <typename T>
auto join(std::initializer_list<T> list, wstring_view sep)
    -> join_view<const T*, const T*, wchar_t> {
  return join(std::begin(list), std::end(list), sep);
}

template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto vformat(basic_string_view<Char> format_str,
             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  basic_memory_buffer<Char> buffer;
  detail::vformat_to(buffer, format_str, args);
  return to_string(buffer);
}

// Pass char_t as a default template parameter instead of using
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... Args, typename Char = char_t<S>,
          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
  return vformat(to_string_view(format_str), vargs);
}

template <typename Locale, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
inline auto vformat(
    const Locale& loc, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  return detail::vformat(loc, to_string_view(format_str), args);
}

template <typename Locale, typename S, typename... Args,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                            detail::is_exotic_char<Char>::value)>
inline auto format(const Locale& loc, const S& format_str, Args&&... args)
    -> std::basic_string<Char> {
  return detail::vformat(loc, to_string_view(format_str),
                         fmt::make_args_checked<Args...>(format_str, args...));
}

template <typename OutputIt, typename S, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
auto vformat_to(OutputIt out, const S& format_str,
                basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
  detail::vformat_to(buf, to_string_view(format_str), args);
  return detail::get_iterator(buf);
}

template <typename OutputIt, typename S, typename... Args,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
  return vformat_to(out, to_string_view(fmt), vargs);
}

template <typename S, typename... Args, typename Char, size_t SIZE,
          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
                              const S& format_str, Args&&... args) ->
    typename buffer_context<Char>::iterator {
  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
  return detail::buffer_appender<Char>(buf);
}

template <typename Locale, typename S, typename OutputIt, typename... Args,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_locale<Locale>::value&&
                                detail::is_exotic_char<Char>::value)>
inline auto vformat_to(
    OutputIt out, const Locale& loc, const S& format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
  return detail::get_iterator(buf);
}

template <
    typename OutputIt, typename Locale, typename S, typename... Args,
    typename Char = char_t<S>,
    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                      Args&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
  return vformat_to(out, loc, to_string_view(format_str), vargs);
}

template <typename OutputIt, typename Char, typename... Args,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
inline auto vformat_to_n(
    OutputIt out, size_t n, basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> format_to_n_result<OutputIt> {
  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
                                                                           n);
  detail::vformat_to(buf, format_str, args);
  return {buf.out(), buf.count()};
}

template <typename OutputIt, typename S, typename... Args,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
                        const Args&... args) -> format_to_n_result<OutputIt> {
  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
  return vformat_to_n(out, n, to_string_view(fmt), vargs);
}

template <typename S, typename... Args, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
  detail::counting_buffer<Char> buf;
  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
  detail::vformat_to(buf, to_string_view(fmt), vargs);
  return buf.count();
}

inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
  wmemory_buffer buffer;
  detail::vformat_to(buffer, fmt, args);
  buffer.push_back(L'\0');
  if (std::fputws(buffer.data(), f) == -1)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}

inline void vprint(wstring_view fmt, wformat_args args) {
  vprint(stdout, fmt, args);
}

template <typename... T>
void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
  return vprint(f, wstring_view(fmt), make_wformat_args(args...));
}

template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
  return vprint(wstring_view(fmt), make_wformat_args(args...));
}

/**
  Converts *value* to ``std::wstring`` using the default format for type *T*.
 */
template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
  return format(FMT_STRING(L"{}"), value);
}
FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE

#endif  // FMT_WCHAR_H_


================================================
FILE: examples/libraries/fmt/src/fmt.cc
================================================
module;
#ifndef __cpp_modules
#  error Module not supported.
#endif

// put all implementation-provided headers into the global module fragment
// to prevent attachment to this module
#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
#  define _CRT_SECURE_NO_WARNINGS
#endif
#if !defined(WIN32_LEAN_AND_MEAN) && defined(_WIN32)
#  define WIN32_LEAN_AND_MEAN
#endif

#include <algorithm>
#include <cctype>
#include <cerrno>
#include <chrono>
#include <climits>
#include <clocale>
#include <cmath>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cwchar>
#include <exception>
#include <functional>
#include <iterator>
#include <limits>
#include <locale>
#include <memory>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <utility>
#include <vector>

#if _MSC_VER
#  include <intrin.h>
#endif
#if defined __APPLE__ || defined(__FreeBSD__)
#  include <xlocale.h>
#endif
#if __has_include(<winapifamily.h>)
#  include <winapifamily.h>
#endif
#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
     defined(__linux__)) &&                            \
    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
#  include <fcntl.h>
#  include <sys/stat.h>
#  include <sys/types.h>
#  ifndef _WIN32
#    include <unistd.h>
#  else
#    include <io.h>
#  endif
#endif
#ifdef _WIN32
#  include <windows.h>
#endif

export module fmt;

#define FMT_MODULE_EXPORT export
#define FMT_MODULE_EXPORT_BEGIN export {
#define FMT_MODULE_EXPORT_END }
#define FMT_BEGIN_DETAIL_NAMESPACE \
  }                                \
  namespace detail {
#define FMT_END_DETAIL_NAMESPACE \
  }                              \
  export {

// all library-provided declarations and definitions
// must be in the module purview to be exported
#include "fmt/args.h"
#include "fmt/chrono.h"
#include "fmt/color.h"
#include "fmt/compile.h"
#include "fmt/format.h"
#include "fmt/os.h"
#include "fmt/printf.h"
#include "fmt/xchar.h"

// gcc doesn't yet implement private module fragments
#if !FMT_GCC_VERSION
module : private;
#endif

#include "format.cc"
#include "os.cc"


================================================
FILE: examples/libraries/fmt/src/format.cc
================================================
// Formatting library for C++
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/format-inl.h"

FMT_BEGIN_NAMESPACE
namespace detail {

template <typename T>
int format_float(char* buf, std::size_t size, const char* format, int precision,
                 T value) {
#ifdef FMT_FUZZ
  if (precision > 100000)
    throw std::runtime_error(
        "fuzz mode - avoid large allocation inside snprintf");
#endif
  // Suppress the warning about nonliteral format string.
  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
  return precision < 0 ? snprintf_ptr(buf, size, format, value)
                       : snprintf_ptr(buf, size, format, precision, value);
}

template FMT_API dragonbox::decimal_fp<float> dragonbox::to_decimal(float x)
    FMT_NOEXCEPT;
template FMT_API dragonbox::decimal_fp<double> dragonbox::to_decimal(double x)
    FMT_NOEXCEPT;
}  // namespace detail

// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
int (*instantiate_format_float)(double, int, detail::float_specs,
                                detail::buffer<char>&) = detail::format_float;

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template FMT_API detail::locale_ref::locale_ref(const std::locale& loc);
template FMT_API std::locale detail::locale_ref::get<std::locale>() const;
#endif

// Explicit instantiations for char.

template FMT_API auto detail::thousands_sep_impl(locale_ref)
    -> thousands_sep_result<char>;
template FMT_API char detail::decimal_point_impl(locale_ref);

template FMT_API void detail::buffer<char>::append(const char*, const char*);

// DEPRECATED!
// There is no correspondent extern template in format.h because of
// incompatibility between clang and gcc (#2377).
template FMT_API void detail::vformat_to(
    detail::buffer<char>&, string_view,
    basic_format_args<FMT_BUFFER_CONTEXT(char)>, detail::locale_ref);

template FMT_API int detail::snprintf_float(double, int, detail::float_specs,
                                            detail::buffer<char>&);
template FMT_API int detail::snprintf_float(long double, int,
                                            detail::float_specs,
                                            detail::buffer<char>&);
template FMT_API int detail::format_float(double, int, detail::float_specs,
                                          detail::buffer<char>&);
template FMT_API int detail::format_float(long double, int, detail::float_specs,
                                          detail::buffer<char>&);

// Explicit instantiations for wchar_t.

template FMT_API auto detail::thousands_sep_impl(locale_ref)
    -> thousands_sep_result<wchar_t>;
template FMT_API wchar_t detail::decimal_point_impl(locale_ref);

template FMT_API void detail::buffer<wchar_t>::append(const wchar_t*,
                                                      const wchar_t*);

template struct detail::basic_data<void>;

FMT_END_NAMESPACE


================================================
FILE: examples/libraries/fmt/src/os.cc
================================================
// Formatting library for C++ - optional OS-specific functionality
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

// Disable bogus MSVC warnings.
#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
#  define _CRT_SECURE_NO_WARNINGS
#endif

#include "fmt/os.h"

#include <climits>

#if FMT_USE_FCNTL
#  include <sys/stat.h>
#  include <sys/types.h>

#  ifndef _WIN32
#    include <unistd.h>
#  else
#    ifndef WIN32_LEAN_AND_MEAN
#      define WIN32_LEAN_AND_MEAN
#    endif
#    include <io.h>

#    define O_CREAT _O_CREAT
#    define O_TRUNC _O_TRUNC

#    ifndef S_IRUSR
#      define S_IRUSR _S_IREAD
#    endif

#    ifndef S_IWUSR
#      define S_IWUSR _S_IWRITE
#    endif

#    ifdef __MINGW32__
#      define _SH_DENYNO 0x40
#    endif
#  endif  // _WIN32
#endif    // FMT_USE_FCNTL

#ifdef _WIN32
#  include <windows.h>
#endif

#ifdef fileno
#  undef fileno
#endif

namespace {
#ifdef _WIN32
// Return type of read and write functions.
using rwresult = int;

// On Windows the count argument to read and write is unsigned, so convert
// it from size_t preventing integer overflow.
inline unsigned convert_rwcount(std::size_t count) {
  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
}
#elif FMT_USE_FCNTL
// Return type of read and write functions.
using rwresult = ssize_t;

inline std::size_t convert_rwcount(std::size_t count) { return count; }
#endif
}  // namespace

FMT_BEGIN_NAMESPACE

#ifdef _WIN32
detail::utf16_to_utf8::utf16_to_utf8(basic_string_view<wchar_t> s) {
  if (int error_code = convert(s)) {
    FMT_THROW(windows_error(error_code,
                            "cannot convert string from UTF-16 to UTF-8"));
  }
}

int detail::utf16_to_utf8::convert(basic_string_view<wchar_t> s) {
  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
  int s_size = static_cast<int>(s.size());
  if (s_size == 0) {
    // WideCharToMultiByte does not support zero length, handle separately.
    buffer_.resize(1);
    buffer_[0] = 0;
    return 0;
  }

  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
                                   nullptr, nullptr);
  if (length == 0) return GetLastError();
  buffer_.resize(length + 1);
  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
                               length, nullptr, nullptr);
  if (length == 0) return GetLastError();
  buffer_[length] = 0;
  return 0;
}

namespace detail {

class system_message {
  system_message(const system_message&) = delete;
  void operator=(const system_message&) = delete;

  unsigned long result_;
  wchar_t* message_;

  static bool is_whitespace(wchar_t c) FMT_NOEXCEPT {
    return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
  }

 public:
  explicit system_message(unsigned long error_code)
      : result_(0), message_(nullptr) {
    result_ = FormatMessageW(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
        nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
    if (result_ != 0) {
      while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
        --result_;
      }
    }
  }
  ~system_message() { LocalFree(message_); }
  explicit operator bool() const FMT_NOEXCEPT { return result_ != 0; }
  operator basic_string_view<wchar_t>() const FMT_NOEXCEPT {
    return basic_string_view<wchar_t>(message_, result_);
  }
};

class utf8_system_category final : public std::error_category {
 public:
  const char* name() const FMT_NOEXCEPT override { return "system"; }
  std::string message(int error_code) const override {
    system_message msg(error_code);
    if (msg) {
      utf16_to_utf8 utf8_message;
      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
        return utf8_message.str();
      }
    }
    return "unknown error";
  }
};

}  // namespace detail

FMT_API const std::error_category& system_category() FMT_NOEXCEPT {
  static const detail::utf8_system_category category;
  return category;
}

std::system_error vwindows_error(int err_code, string_view format_str,
                                 format_args args) {
  auto ec = std::error_code(err_code, system_category());
  return std::system_error(ec, vformat(format_str, args));
}

void detail::format_windows_error(detail::buffer<char>& out, int error_code,
                                  const char* message) FMT_NOEXCEPT {
  FMT_TRY {
    system_message msg(error_code);
    if (msg) {
      utf16_to_utf8 utf8_message;
      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
        format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
        return;
      }
    }
  }
  FMT_CATCH(...) {}
  format_error_code(out, error_code, message);
}

void report_windows_error(int error_code, const char* message) FMT_NOEXCEPT {
  report_error(detail::format_windows_error, error_code, message);
}
#endif  // _WIN32

buffered_file::~buffered_file() FMT_NOEXCEPT {
  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
    report_system_error(errno, "cannot close file");
}

buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
                nullptr);
  if (!file_)
    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
}

void buffered_file::close() {
  if (!file_) return;
  int result = FMT_SYSTEM(fclose(file_));
  file_ = nullptr;
  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
}

// A macro used to prevent expansion of fileno on broken versions of MinGW.
#define FMT_ARGS

int buffered_file::fileno() const {
  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
  if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
  return fd;
}

#if FMT_USE_FCNTL
file::file(cstring_view path, int oflag) {
  int mode = S_IRUSR | S_IWUSR;
#  if defined(_WIN32) && !defined(__MINGW32__)
  fd_ = -1;
  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
#  else
  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
#  endif
  if (fd_ == -1)
    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
}

file::~file() FMT_NOEXCEPT {
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
    report_system_error(errno, "cannot close file");
}

void file::close() {
  if (fd_ == -1) return;
  // Don't retry close in case of EINTR!
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  int result = FMT_POSIX_CALL(close(fd_));
  fd_ = -1;
  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
}

long long file::size() const {
#  ifdef _WIN32
  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
  // is less than 0x0500 as is the case with some default MinGW builds.
  // Both functions support large file sizes.
  DWORD size_upper = 0;
  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
  if (size_lower == INVALID_FILE_SIZE) {
    DWORD error = GetLastError();
    if (error != NO_ERROR)
      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
  }
  unsigned long long long_size = size_upper;
  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
#  else
  using Stat = struct stat;
  Stat file_stat = Stat();
  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
    FMT_THROW(system_error(errno, "cannot get file attributes"));
  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
                "return type of file::size is not large enough");
  return file_stat.st_size;
#  endif
}

std::size_t file::read(void* buffer, std::size_t count) {
  rwresult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
  if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
  return detail::to_unsigned(result);
}

std::size_t file::write(const void* buffer, std::size_t count) {
  rwresult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
  if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
  return detail::to_unsigned(result);
}

file file::dup(int fd) {
  // Don't retry as dup doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
  int new_fd = FMT_POSIX_CALL(dup(fd));
  if (new_fd == -1)
    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
  return file(new_fd);
}

void file::dup2(int fd) {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1) {
    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}",
                           fd_, fd));
  }
}

void file::dup2(int fd, std::error_code& ec) FMT_NOEXCEPT {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1) ec = std::error_code(errno, std::generic_category());
}

void file::pipe(file& read_end, file& write_end) {
  // Close the descriptors first to make sure that assignments don't throw
  // and there are no leaks.
  read_end.close();
  write_end.close();
  int fds[2] = {};
#  ifdef _WIN32
  // Make the default pipe capacity same as on Linux 2.6.11+.
  enum { DEFAULT_CAPACITY = 65536 };
  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
#  else
  // Don't retry as the pipe function doesn't return EINTR.
  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
  int result = FMT_POSIX_CALL(pipe(fds));
#  endif
  if (result != 0) FMT_THROW(system_error(errno, "cannot create pipe"));
  // The following assignments don't throw because read_fd and write_fd
  // are closed.
  read_end = file(fds[0]);
  write_end = file(fds[1]);
}

buffered_file file::fdopen(const char* mode) {
// Don't retry as fdopen doesn't return EINTR.
#  if defined(__MINGW32__) && defined(_POSIX_)
  FILE* f = ::fdopen(fd_, mode);
#  else
  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
#  endif
  if (!f)
    FMT_THROW(
        system_error(errno, "cannot associate stream with file descriptor"));
  buffered_file bf(f);
  fd_ = -1;
  return bf;
}

long getpagesize() {
#  ifdef _WIN32
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return si.dwPageSize;
#  else
  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
  if (size < 0) FMT_THROW(system_error(errno, "cannot get memory page size"));
  return size;
#  endif
}

FMT_API void ostream::grow(size_t) {
  if (this->size() == this->capacity()) flush();
}
#endif  // FMT_USE_FCNTL
FMT_END_NAMESPACE


================================================
FILE: examples/libraries/fmt/support/Android.mk
================================================
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE := fmt_static
LOCAL_MODULE_FILENAME := libfmt

LOCAL_SRC_FILES := ../src/format.cc

LOCAL_C_INCLUDES := $(LOCAL_PATH)
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)

LOCAL_CFLAGS += -std=c++11 -fexceptions

include $(BUILD_STATIC_LIBRARY)



================================================
FILE: examples/libraries/fmt/support/AndroidManifest.xml
================================================
<manifest package="net.fmtlib" />


================================================
FILE: examples/libraries/fmt/support/C++.sublime-syntax
================================================
%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: C++ (fmt)
comment: I don't think anyone uses .hp. .cp tends to be paired with .h. (I could be wrong. :) -- chris
file_extensions:
  - cpp
  - cc
  - cp
  - cxx
  - c++
  - C
  - h
  - hh
  - hpp
  - hxx
  - h++
  - inl
  - ipp
first_line_match: '-\*- C\+\+ -\*-'
scope: source.c++
variables:
  identifier: \b[[:alpha:]_][[:alnum:]_]*\b # upper and lowercase
  macro_identifier: \b[[:upper:]_][[:upper:][:digit:]_]{2,}\b # only uppercase, at least 3 chars
  path_lookahead: '(?:::\s*)?(?:{{identifier}}\s*::\s*)*(?:template\s+)?{{identifier}}'
  operator_method_name: '\boperator\s*(?:[-+*/%^&|~!=<>]|[-+*/%^&|=!<>]=|<<=?|>>=?|&&|\|\||\+\+|--|,|->\*?|\(\)|\[\]|""\s*{{identifier}})'
  casts: 'const_cast|dynamic_cast|reinterpret_cast|static_cast'
  operator_keywords: 'and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq|noexcept'
  control_keywords: 'break|case|catch|continue|default|do|else|for|goto|if|_Pragma|return|switch|throw|try|while'
  memory_operators: 'new|delete'
  basic_types: 'asm|__asm__|auto|bool|_Bool|char|_Complex|double|float|_Imaginary|int|long|short|signed|unsigned|void'
  before_tag: 'struct|union|enum\s+class|enum\s+struct|enum|class'
  declspec: '__declspec\(\s*\w+(?:\([^)]+\))?\s*\)'
  storage_classes: 'static|export|extern|friend|explicit|virtual|register|thread_local'
  type_qualifier: 'const|constexpr|mutable|typename|volatile'
  compiler_directive: 'inline|restrict|__restrict__|__restrict'
  visibility_modifiers: 'private|protected|public'
  other_keywords: 'typedef|nullptr|{{visibility_modifiers}}|static_assert|sizeof|using|typeid|alignof|alignas|namespace|template'
  modifiers: '{{storage_classes}}|{{type_qualifier}}|{{compiler_directive}}'
  non_angle_brackets: '(?=<<|<=)'

  regular: '[^(){}&;*^%=<>-]*'
  paren_open: (?:\(
  paren_close: '\))?'
  generic_open: (?:<
  generic_close: '>)?'
  balance_parentheses: '{{regular}}{{paren_open}}{{regular}}{{paren_close}}{{regular}}'
  generic_lookahead: <{{regular}}{{generic_open}}{{regular}}{{generic_open}}{{regular}}{{generic_close}}\s*{{generic_close}}{{balance_parentheses}}>

  data_structures_forward_decl_lookahead: '(\s+{{macro_identifier}})*\s*(:\s*({{path_lookahead}}|{{visibility_modifiers}}|,|\s|<[^;]*>)+)?;'
  non_func_keywords: 'if|for|switch|while|decltype|sizeof|__declspec|__attribute__|typeid|alignof|alignas|static_assert'

  format_spec: |-
    (?x:
      (?:.? [<>=^])?     # fill align
      [ +-]?             # sign
      \#?                # alternate form
      # technically, octal and hexadecimal integers are also supported as 'width', but rarely used
      \d*                # width
      ,?                 # thousands separator
      (?:\.\d+)?         # precision
      [bcdeEfFgGnosxX%]? # type
    )

contexts:
  main:
    - include: preprocessor-global
    - include: global

  #############################################################################
  # Reusable contexts
  #
  # The follow contexts are currently constructed to be reused in the
  # Objetive-C++ syntax. They are specifically constructed to not push into
  # sub-contexts, which ensures that Objective-C++ code isn't accidentally
  # lexed as plain C++.
  #
  # The "unique-*" contexts are additions that C++ makes over C, and thus can
  # be directly reused in Objective-C++ along with contexts from Objective-C
  # and C.
  #############################################################################

  unique-late-expressions:
    # This is highlighted after all of the other control keywords
    # to allow operator overloading to be lexed properly
    - match: \boperator\b
      scope: keyword.control.c++

  unique-modifiers:
    - match: \b({{modifiers}})\b
      scope: storage.modifier.c++

  unique-variables:
    - match: \bthis\b
      scope: variable.language.c++
    # common C++ instance var naming idiom -- fMemberName
    - match: '\b(f|m)[[:upper:]]\w*\b'
      scope: variable.other.readwrite.member.c++
    # common C++ instance var naming idiom -- m_member_name
    - match: '\bm_[[:alnum:]_]+\b'
      scope: variable.other.readwrite.member.c++

  unique-constants:
    - match: \bnullptr\b
      scope: constant.language.c++

  unique-keywords:
    - match: \busing\b
      scope: keyword.control.c++
    - match: \bbreak\b
      scope: keyword.control.flow.break.c++
    - match: \bcontinue\b
      scope: keyword.control.flow.continue.c++
    - match: \bgoto\b
      scope: keyword.control.flow.goto.c++
    - match: \breturn\b
      scope: keyword.control.flow.return.c++
    - match: \bthrow\b
      scope: keyword.control.flow.throw.c++
    - match: \b({{control_keywords}})\b
      scope: keyword.control.c++
    - match: '\bdelete\b(\s*\[\])?|\bnew\b(?!])'
      scope: keyword.control.c++
    - match: \b({{operator_keywords}})\b
      scope: keyword.operator.word.c++

  unique-types:
    - match: \b(char16_t|char32_t|wchar_t|nullptr_t)\b
      scope: storage.type.c++
    - match: \bclass\b
      scope: storage.type.c++

  unique-strings:
    - match: '((?:L|u8|u|U)?R)("([^\(\)\\ ]{0,16})\()'
      captures:
        1: storage.type.string.c++
        2: punctuation.definition.string.begin.c++
      push:
        - meta_scope: string.quoted.double.c++
        - match: '\)\3"'
          scope: punctuation.definition.string.end.c++
          pop: true
        - match: '\{\{|\}\}'
          scope: constant.character.escape.c++
        - include: formatting-syntax

  unique-numbers:
    - match: |-
        (?x)
        (?:
        # floats
          (?:
          (?:\b\d(?:[\d']*\d)?\.\d(?:[\d']*\d)?|\B\.\d(?:[\d']*\d)?)(?:[Ee][+-]?\d(?:[\d']*\d)?)?(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b
          |
          (?:\b\d(?:[\d']*\d)?\.)(?:\B|(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))\b|(?:[Ee][+-]?\d(?:[\d']*\d)?)(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b)
          |
          \b\d(?:[\d']*\d)?(?:[Ee][+-]?\d(?:[\d']*\d)?)(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b
          )
        |
        # ints
          \b(?:
          (?:
          # dec
          [1-9](?:[\d']*\d)?
          |
          # oct
          0(?:[0-7']*[0-7])?
          |
          # hex
          0[Xx][\da-fA-F](?:[\da-fA-F']*[\da-fA-F])?
          |
          # bin
          0[Bb][01](?:[01']*[01])?
          )
          # int suffixes
          (?:(?:l{1,2}|L{1,2})[uU]?|[uU](?:l{0,2}|L{0,2})|(?:i[fl]?|h|min|[mun]?s|_\w*))?)\b
        )
        (?!\.) # Number must not be followed by a decimal point
      scope: constant.numeric.c++

  identifiers:
    - match: '{{identifier}}\s*(::)\s*'
      captures:
        1: punctuation.accessor.c++
    - match: '(?:(::)\s*)?{{identifier}}'
      captures:
        1: punctuation.accessor.c++

  function-specifiers:
    - match: \b(const|final|noexcept|override)\b
      scope: storage.modifier.c++

  #############################################################################
  # The following are C++-specific contexts that should not be reused. This is
  # because they push into subcontexts and use variables that are C++-specific.
  #############################################################################

  ## Common context layout

  global:
    - match: '(?=\btemplate\b)'
      push:
        - include: template
        - match: (?=\S)
          set: global-modifier
    - include: namespace
    - include: keywords-angle-brackets
    - match: '(?={{path_lookahead}}\s*<)'
      push: global-modifier
    # Take care of comments just before a function definition.
    - match: /\*
      scope: punctuation.definition.comment.c
      push:
        - - match: \s*(?=\w)
            set: global-modifier
          - match: ""
            pop: true
        - - meta_scope: comment.block.c
          - match: \*/
            scope: punctuation.definition.comment.c
            pop: true
    - include: early-expressions
    - match: ^\s*\b(extern)(?=\s+"C(\+\+)?")
      scope: storage.modifier.c++
      push:
        - include: comments
        - include: strings
        - match: '\{'
          scope: punctuation.section.block.begin.c++
          set:
            - meta_scope: meta.extern-c.c++
            - match: '^\s*(#\s*ifdef)\s*__cplusplus\s*'
              scope: meta.preprocessor.c++
              captures:
                1: keyword.control.import.c++
              set:
                - match: '\}'
                  scope: punctuation.section.block.end.c++
                  pop: true
                - include: preprocessor-global
                - include: global
            - match: '\}'
              scope: punctuation.section.block.end.c++
              pop: true
            - include: preprocessor-global
            - include: global
        - match: (?=\S)
          set: global-modifier
    - match: ^\s*(?=\w)
      push: global-modifier
    - include: late-expressions

  statements:
    - include: preprocessor-statements
    - include: scope:source.c#label
    - include: expressions

  expressions:
    - include: early-expressions
    - include: late-expressions

  early-expressions:
    - include: early-expressions-before-generic-type
    - include: generic-type
    - include: early-expressions-after-generic-type

  early-expressions-before-generic-type:
    - include: preprocessor-expressions
    - include: comments
    - include: case-default
    - include: typedef
    - include: keywords-angle-brackets
    - include: keywords-parens
    - include: keywords
    - include: numbers
    # Prevent a '<' from getting scoped as the start of another template
    # parameter list, if in reality a less-than-or-equals sign is meant.
    - match: <=
      scope: keyword.operator.comparison.c

  early-expressions-after-generic-type:
    - include: members-arrow
    - include: operators
    - include: members-dot
    - include: strings
    - include: parens
    - include: brackets
    - include: block
    - include: variables
    - include: constants
    - match: ','
      scope: punctuation.separator.c++
    - match: '\)|\}'
      scope: invalid.illegal.stray-bracket-end.c++

  expressions-minus-generic-type:
    - include: early-expressions-before-generic-type
    - include: angle-brackets
    - include: early-expressions-after-generic-type
    - include: late-expressions

  expressions-minus-generic-type-function-call:
    - include: early-expressions-before-generic-type
    - include: angle-brackets
    - include: early-expressions-after-generic-type
    - include: late-expressions-before-function-call
    - include: identifiers
    - match: ';'
      scope: punctuation.terminator.c++

  late-expressions:
    - include: late-expressions-before-function-call
    - include: function-call
    - include: identifiers
    - match: ';'
      scope: punctuation.terminator.c++

  late-expressions-before-function-call:
    - include: unique-late-expressions
    - include: modifiers-parens
    - include: modifiers
    - include: types

  expressions-minus-function-call:
    - include: early-expressions
    - include: late-expressions-before-function-call
    - include: identifiers
    - match: ';'
      scope: punctuation.terminator.c++

  comments:
    - include: scope:source.c#comments

  operators:
    - include: scope:source.c#operators

  modifiers:
    - include: unique-modifiers
    - include: scope:source.c#modifiers

  variables:
    - include: unique-variables
    - include: scope:source.c#variables

  constants:
    - include: unique-constants
    - include: scope:source.c#constants

  keywords:
    - include: unique-keywords
    - include: scope:source.c#keywords

  types:
    - include: unique-types
    - include: types-parens
    - include: scope:source.c#types

  strings:
    - include: unique-strings
    - match: '(L|u8|u|U)?(")'
      captures:
        1: storage.type.string.c++
        2: punctuation.definition.string.begin.c++
      push:
        - meta_scope: string.quoted.double.c++
        - match: '"'
          scope: punctuation.definition.string.end.c++
          pop: true
        - include: scope:source.c#string_escaped_char
        - match: |-
            (?x)%
              (\d+\$)?                                      # field (argument #)
              [#0\- +']*                                    # flags
              [,;:_]?                                       # separator character (AltiVec)
              ((-?\d+)|\*(-?\d+\$)?)?                       # minimum field width
              (\.((-?\d+)|\*(-?\d+\$)?)?)?                  # precision
              (hh|h|ll|l|j|t|z|q|L|vh|vl|v|hv|hl)?          # length modifier
              (\[[^\]]+\]|[am]s|[diouxXDOUeEfFgGaACcSspn%]) # conversion type
          scope: constant.other.placeholder.c++
        - match: '\{\{|\}\}'
          scope: constant.character.escape.c++
        - include: formatting-syntax
    - include: scope:source.c#strings

  formatting-syntax:
    # https://docs.python.org/3.6/library/string.html#formatstrings
    - match: |- # simple form
        (?x)
        (\{)
          (?: [\w.\[\]]+)?             # field_name
          (   ! [ars])?                # conversion
          (   : (?:{{format_spec}}|    # format_spec OR
                   [^}%]*%.[^}]*)      # any format-like string
          )?
        (\})
      scope: constant.other.placeholder.c++
      captures:
        1: punctuation.definition.placeholder.begin.c++
        2: storage.modifier.c++onversion.c++
        3: constant.other.format-spec.c++
        4: punctuation.definition.placeholder.end.c++
    - match: \{(?=[^\}"']+\{[^"']*\}) # complex (nested) form
      scope: punctuation.definition.placeholder.begin.c++
      push:
        - meta_scope: constant.other.placeholder.c++
        - match: \}
          scope: punctuation.definition.placeholder.end.c++
          pop: true
        - match: '[\w.\[\]]+'
        - match: '![ars]'
          scope: storage.modifier.conversion.c++
        - match: ':'
          push:
            - meta_scope: meta.format-spec.c++ constant.other.format-spec.c++
            - match: (?=\})
              pop: true
            - include: formatting-syntax

  numbers:
    - include: unique-numbers
    - include: scope:source.c#numbers

  ## C++-specific contexts

  case-default:
    - match: '\b(default|case)\b'
      scope: keyword.control.c++
      push:
        - match: (?=[);,])
          pop: true
        - match: ':'
          scope: punctuation.separator.c++
          pop: true
        - include: expressions

  modifiers-parens:
    - match: '\b(alignas)\b\s*(\()'
      captures:
        1: storage.modifier.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - include: expressions
    - match: \b(__attribute__)\s*(\(\()
      captures:
        1: storage.modifier.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push :
        - meta_scope: meta.attribute.c++
        - meta_content_scope: meta.group.c++
        - include: parens
        - include: strings
        - match: \)\)
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
    - match: \b(__declspec)(\()
      captures:
        1: storage.modifier.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - match: '\b(align|allocate|code_seg|deprecated|property|uuid)\b\s*(\()'
          captures:
            1: storage.modifier.c++
            2: meta.group.c++ punctuation.section.group.begin.c++
          push:
            - meta_content_scope: meta.group.c++
            - match: '\)'
              scope: meta.group.c++ punctuation.section.group.end.c++
              pop: true
            - include: numbers
            - include: strings
            - match: \b(get|put)\b
              scope: variable.parameter.c++
            - match: ','
              scope: punctuation.separator.c++
            - match: '='
              scope: keyword.operator.assignment.c++
        - match: '\b(appdomain|deprecated|dllimport|dllexport|jintrinsic|naked|noalias|noinline|noreturn|nothrow|novtable|process|restrict|safebuffers|selectany|thread)\b'
          scope: constant.other.c++

  types-parens:
    - match: '\b(decltype)\b\s*(\()'
      captures:
        1: storage.type.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - include: expressions

  keywords-angle-brackets:
    - match: \b({{casts}})\b\s*
      scope: keyword.operator.word.cast.c++
      push:
        - match: '>'
          scope: punctuation.section.generic.end.c++
          pop: true
        - match: '<'
          scope: punctuation.section.generic.begin.c++
          push:
            - match: '(?=>)'
              pop: true
            - include: expressions-minus-generic-type-function-call

  keywords-parens:
    - match: '\b(alignof|typeid|static_assert|sizeof)\b\s*(\()'
      captures:
        1: keyword.operator.word.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - include: expressions

  namespace:
    - match: '\b(using)\s+(namespace)\s+(?={{path_lookahead}})'
      captures:
        1: keyword.control.c++
        2: keyword.control.c++
      push:
        - include: identifiers
        - match: ''
          pop: true
    - match: '\b(namespace)\s+(?=({{path_lookahead}})?(?!\s*[;,]))'
      scope: meta.namespace.c++
      captures:
        1: keyword.control.c++
      push:
        - meta_content_scope: meta.namespace.c++ entity.name.namespace.c++
        - include: identifiers
        - match: ''
          set:
            - meta_scope: meta.namespace.c++
            - include: comments
            - match: '='
              scope: keyword.operator.alias.c++
            - match: '(?=;)'
              pop: true
            - match: '\}'
              scope: meta.block.c++ punctuation.section.block.end.c++
              pop: true
            - match: '\{'
              scope: punctuation.section.block.begin.c++
              push:
                - meta_scope: meta.block.c++
                - match: '(?=\})'
                  pop: true
                - include: preprocessor-global
                - include: global
            - include: expressions

  template-common:
    # Exit the template scope if we hit some basic invalid characters. This
    # helps when a user is in the middle of typing their template types and
    # prevents re-highlighting the whole file until the next > is found.
    - match: (?=[{};])
      pop: true
    - include: expressions

  template:
    - match: \btemplate\b
      scope: storage.type.template.c++
      push:
        - meta_scope: meta.template.c++
        # Explicitly include comments here at the top, in order to NOT match the
        # \S lookahead in the case of comments.
        - include: comments
        - match: <
          scope: punctuation.section.generic.begin.c++
          set:
            - meta_content_scope: meta.template.c++
            - match: '>'
              scope: meta.template.c++ punctuation.section.generic.end.c++
              pop: true
            - match: \.{3}
              scope: keyword.operator.variadic.c++
            - match: \b(typename|{{before_tag}})\b
              scope: storage.type.c++
            - include: template # include template here for nested templates
            - include: template-common
        - match: (?=\S)
          set:
            - meta_content_scope: meta.template.c++
            - match: \b({{before_tag}})\b
              scope: storage.type.c++
            - include: template-common

  generic-type:
    - match: '(?=(?!template){{path_lookahead}}\s*{{generic_lookahead}}\s*\()'
      push:
        - meta_scope: meta.function-call.c++
        - match: \btemplate\b
          scope: storage.type.template.c++
        - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
          captures:
            1: punctuation.accessor.double-colon.c++
            2: punctuation.accessor.double-colon.c++
        - match: (?:(::)\s*)?({{identifier}})\s*(<)
          captures:
            1: punctuation.accessor.double-colon.c++
            2: variable.function.c++
            3: punctuation.section.generic.begin.c++
          push:
            - match: '>'
              scope: punctuation.section.generic.end.c++
              pop: true
            - include: expressions-minus-generic-type-function-call
        - match: (?:(::)\s*)?({{identifier}})\s*(\()
          captures:
            1: punctuation.accessor.double-colon.c++
            2: variable.function.c++
            3: punctuation.section.group.begin.c++
          set:
            - meta_scope: meta.function-call.c++
            - meta_content_scope: meta.group.c++
            - match: '\)'
              scope: meta.group.c++ punctuation.section.group.end.c++
              pop: true
            - include: expressions
        - include: angle-brackets
        - match: '\('
          scope: meta.group.c++ punctuation.section.group.begin.c++
          set:
            - meta_scope: meta.function-call.c++
            - meta_content_scope: meta.group.c++
            - match: '\)'
              scope: meta.group.c++ punctuation.section.group.end.c++
              pop: true
            - include: expressions
    - match: '(?=(?!template){{path_lookahead}}\s*{{generic_lookahead}})'
      push:
        - include: identifiers
        - match: '<'
          scope: punctuation.section.generic.begin.c++
          set:
            - match: '>'
              scope: punctuation.section.generic.end.c++
              pop: true
            - include: expressions-minus-generic-type-function-call

  angle-brackets:
    - match: '<(?!<)'
      scope: punctuation.section.generic.begin.c++
      push:
        - match: '>'
          scope: punctuation.section.generic.end.c++
          pop: true
        - include: expressions-minus-generic-type-function-call

  block:
    - match: '\{'
      scope: punctuation.section.block.begin.c++
      push:
        - meta_scope: meta.block.c++
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - match: '\}'
          scope: punctuation.section.block.end.c++
          pop: true
        - include: statements

  function-call:
    - match: (?={{path_lookahead}}\s*\()
      push:
        - meta_scope: meta.function-call.c++
        - include: scope:source.c#c99
        - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
          scope: variable.function.c++
          captures:
            1: punctuation.accessor.c++
            2: punctuation.accessor.c++
        - match: '(?:(::)\s*)?{{identifier}}'
          scope: variable.function.c++
          captures:
            1: punctuation.accessor.c++
        - match: '\('
          scope: meta.group.c++ punctuation.section.group.begin.c++
          set:
            - meta_content_scope: meta.function-call.c++ meta.group.c++
            - match: '\)'
              scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
              pop: true
            - include: expressions

  members-inside-function-call:
    - meta_content_scope: meta.method-call.c++ meta.group.c++
    - match: \)
      scope: meta.method-call.c++ meta.group.c++ punctuation.section.group.end.c++
      pop: true
    - include: expressions

  members-after-accessor-junction:
    # After we've seen an accessor (dot or arrow), this context decides what
    # kind of entity we're accessing.
    - include: comments
    - match: \btemplate\b
      scope: meta.method-call.c++ storage.type.template.c++
      # Guaranteed to be a template member function call after we match this
      set:
        - meta_content_scope: meta.method-call.c++
        - include: comments
        - match: '{{identifier}}'
          scope: variable.function.member.c++
          set:
            - meta_content_scope: meta.method-call.c++
            - match: \(
              scope: meta.group.c++ punctuation.section.group.begin.c++
              set: members-inside-function-call
            - include: comments
            - include: angle-brackets
            - match: (?=\S) # safety pop
              pop: true
        - match: (?=\S) # safety pop
          pop: true
    # Operator overloading
    - match: '({{operator_method_name}})\s*(\()'
      captures:
        0: meta.method-call.c++
        1: variable.function.member.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      set: members-inside-function-call
    # Non-templated member function call
    - match: (~?{{identifier}})\s*(\()
      captures:
        0: meta.method-call.c++
        1: variable.function.member.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      set: members-inside-function-call
    # Templated member function call
    - match: (~?{{identifier}})\s*(?={{generic_lookahead}})
      captures:
        1: variable.function.member.c++
      set:
        - meta_scope: meta.method-call.c++
        - match: <
          scope: punctuation.section.generic.begin.c++
          set:
            - meta_content_scope: meta.method-call.c++
            - match: '>'
              scope: punctuation.section.generic.end.c++
              set:
                - meta_content_scope: meta.method-call.c++
                - include: comments
                - match: \(
                  scope: punctuation.section.group.begin.c++
                  set: members-inside-function-call
                - match: (?=\S) # safety pop
                  pop: true
            - include: expressions
    # Explicit base-class access
    - match: ({{identifier}})\s*(::)
      captures:
        1: variable.other.base-class.c++
        2: punctuation.accessor.double-colon.c++
      set: members-after-accessor-junction # reset
    # Just a regular member variable
    - match: '{{identifier}}'
      scope: variable.other.readwrite.member.c++
      pop: true

  members-dot:
    - include: scope:source.c#access-illegal
    # No lookahead required because members-dot goes after operators in the
    # early-expressions-after-generic-type context. This means triple dots
    # (i.e. "..." or "variadic") is attempted first.
    - match: \.
      scope: punctuation.accessor.dot.c++
      push: members-after-accessor-junction

  members-arrow:
    # This needs to be before operators in the
    # early-expressions-after-generic-type context because otherwise the "->"
    # from the C language will match.
    - match: ->
      scope: punctuation.accessor.arrow.c++
      push: members-after-accessor-junction

  typedef:
    - match: \btypedef\b
      scope: storage.type.c++
      push:
        - match: ({{identifier}})?\s*(?=;)
          captures:
            1: entity.name.type.typedef.c++
          pop: true
        - match: \b(struct)\s+({{identifier}})\b
          captures:
            1: storage.type.c++
        - include: expressions-minus-generic-type

  parens:
    - match: \(
      scope: punctuation.section.group.begin.c++
      push:
        - meta_scope: meta.group.c++
        - match: \)
          scope: punctuation.section.group.end.c++
          pop: true
        - include: expressions

  brackets:
    - match: \[
      scope: punctuation.section.brackets.begin.c++
      push:
        - meta_scope: meta.brackets.c++
        - match: \]
          scope: punctuation.section.brackets.end.c++
          pop: true
        - include: expressions

  function-trailing-return-type:
    - match: '{{non_angle_brackets}}'
      pop: true
    - include: angle-brackets
    - include: types
    - include: modifiers-parens
    - include: modifiers
    - include: identifiers
    - match: \*|&
      scope: keyword.operator.c++
    - include: function-trailing-return-type-parens
    - match: '(?=\S)'
      pop: true

  function-trailing-return-type-parens:
    - match: \(
      scope: punctuation.section.group.begin.c++
      push:
        - meta_scope: meta.group.c++
        - match: \)
          scope: punctuation.section.group.end.c++
          pop: true
        - include: function-trailing-return-type

  ## Detection of function and data structure definitions at the global level

  global-modifier:
    - include: comments
    - include: modifiers-parens
    - include: modifiers
    # Constructors and destructors don't have a type
    - match: '(?={{path_lookahead}}\s*::\s*{{identifier}}\s*(\(|$))'
      set:
        - meta_content_scope: meta.function.c++ entity.name.function.constructor.c++
        - include: identifiers
        - match: '(?=[^\w\s])'
          set: function-definition-params
    - match: '(?={{path_lookahead}}\s*::\s*~{{identifier}}\s*(\(|$))'
      set:
        - meta_content_scope: meta.function.c++ entity.name.function.destructor.c++
        - include: identifiers
        - match: '~{{identifier}}'
        - match: '(?=[^\w\s])'
          set: function-definition-params
    # If we see a path ending in :: before a newline, we don't know if it is
    # a constructor or destructor, or a long return type, so we are just going
    # to treat it like a regular function. Most likely it is a constructor,
    # since it doesn't seem most developers would create such a long typename.
    - match: '(?={{path_lookahead}}\s*::\s*$)'
      set:
        - meta_content_scope: meta.function.c++ entity.name.function.c++
        - include: identifiers
        - match: '~{{identifier}}'
        - match: '(?=[^\w\s])'
          set: function-definition-params
    - include: unique-strings
    - match: '(?=\S)'
      set: global-type

  global-type:
    - include: comments
    - match: \*|&
      scope: keyword.operator.c++
    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}}|operator)\b)'
      pop: true
    - match: '(?=\s)'
      set: global-maybe-function
    # If a class/struct/enum followed by a name that is not a macro or declspec
    # then this is likely a return type of a function. This is uncommon.
    - match: |-
        (?x:
          ({{before_tag}})
          \s+
          (?=
            (?![[:upper:][:digit:]_]+\b|__declspec|{{before_tag}})
            {{path_lookahead}}
            (\s+{{identifier}}\s*\(|\s*[*&])
          )
        )
      captures:
        1: storage.type.c++
      set:
        - include: identifiers
        - match: ''
          set: global-maybe-function
    # The previous match handles return types of struct/enum/etc from a func,
    # there this one exits the context to allow matching an actual struct/class
    - match: '(?=\b({{before_tag}})\b)'
      set: data-structures
    - match: '(?=\b({{casts}})\b\s*<)'
      pop: true
    - match: '{{non_angle_brackets}}'
      pop: true
    - include: angle-brackets
    - include: types
    # Allow a macro call
    - match: '({{identifier}})\s*(\()(?=[^\)]+\))'
      captures:
        1: variable.function.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_scope: meta.function-call.c++
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - include: expressions
    - match: '(?={{path_lookahead}}\s*\()'
      set:
        - include: function-call
        - match: ''
          pop: true
    - include: variables
    - include: constants
    - include: identifiers
    - match: (?=\W)
      pop: true

  global-maybe-function:
    - include: comments
    # Consume pointer info, macros and any type info that was offset by macros
    - match: \*|&
      scope: keyword.operator.c++
    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}})\b)'
      pop: true
    - match: '\b({{type_qualifier}})\b'
      scope: storage.modifier.c++
    - match: '{{non_angle_brackets}}'
      pop: true
    - include: angle-brackets
    - include: types
    - include: modifiers-parens
    - include: modifiers
    # All uppercase identifier just before a newline is most likely a macro
    - match: '[[:upper:][:digit:]_]+\s*$'
    # Operator overloading
    - match: '(?=({{path_lookahead}}\s*(?:{{generic_lookahead}})?::\s*)?{{operator_method_name}}\s*(\(|$))'
      set:
        - meta_content_scope: meta.function.c++ entity.name.function.c++
        - include: identifiers
        - match: '(?=\s*(\(|$))'
          set: function-definition-params
    # Identifier that is not the function name - likely a macro or type
    - match: '(?={{path_lookahead}}([ \t]+|[*&])(?!\s*(<|::|\(|$)))'
      push:
        - include: identifiers
        - match: ''
          pop: true
    # Real function definition
    - match: '(?={{path_lookahead}}({{generic_lookahead}}({{path_lookahead}})?)\s*(\(|$))'
      set: [function-definition-params, global-function-identifier-generic]
    - match: '(?={{path_lookahead}}\s*(\(|$))'
      set: [function-definition-params, global-function-identifier]
    - match: '(?={{path_lookahead}}\s*::\s*$)'
      set: [function-definition-params, global-function-identifier]
    - match: '(?=\S)'
      pop: true

  global-function-identifier-generic:
    - include: angle-brackets
    - match: '::'
      scope: punctuation.accessor.c++
    - match: '(?={{identifier}}<.*>\s*\()'
      push:
        - meta_content_scope: entity.name.function.c++
        - include: identifiers
        - match: '(?=<)'
          pop: true
    - match: '(?={{identifier}}\s*\()'
      push:
        - meta_content_scope: entity.name.function.c++
        - include: identifiers
        - match: ''
          pop: true
    - match: '(?=\()'
      pop: true

  global-function-identifier:
    - meta_content_scope: entity.name.function.c++
    - include: identifiers
    - match: '(?=\S)'
      pop: true

  function-definition-params:
    - meta_content_scope: meta.function.c++
    - include: comments
    - match: '(?=\()'
      set:
        - match: \(
          scope: meta.function.parameters.c++ meta.group.c++ punctuation.section.group.begin.c++
          set:
            - meta_content_scope: meta.function.parameters.c++ meta.group.c++
            - match : \)
              scope: punctuation.section.group.end.c++
              set: function-definition-continue
            - match: '\bvoid\b'
              scope: storage.type.c++
            - match: '{{identifier}}(?=\s*(\[|,|\)|=))'
              scope: variable.parameter.c++
            - match: '='
              scope: keyword.operator.assignment.c++
              push:
                - match: '(?=,|\))'
                  pop: true
                - include: expressions-minus-generic-type
                - include: scope:source.c#preprocessor-line-continuation
            - include: expressions-minus-generic-type
            - include: scope:source.c#preprocessor-line-continuation
    - match: (?=\S)
      pop: true

  function-definition-continue:
    - meta_content_scope: meta.function.c++
    - include: comments
    - match: '(?=;)'
      pop: true
    - match: '->'
      scope: punctuation.separator.c++
      set: function-definition-trailing-return
    - include: function-specifiers
    - match: '='
      scope: keyword.operator.assignment.c++
    - match: '&'
      scope: keyword.operator.c++
    - match: \b0\b
      scope: constant.numeric.c++
    - match: \b(default|delete)\b
      scope: storage.modifier.c++
    - match: '(?=\{)'
      set: function-definition-body
    - match: '(?=\S)'
      pop: true

  function-definition-trailing-return:
    - include: comments
    - match: '(?=;)'
      pop: true
    - match: '(?=\{)'
      set: function-definition-body
    - include: function-specifiers
    - include: function-trailing-return-type

  function-definition-body:
    - meta_content_scope: meta.function.c++ meta.block.c++
    - match: '\{'
      scope: punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.function.c++ meta.block.c++
        - match: '\}'
          scope: meta.function.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - match: '(?=({{before_tag}})([^(;]+$|.*\{))'
          push: data-structures
        - include: statements

  ## Data structures including classes, structs, unions and enums

  data-structures:
    - match: '\bclass\b'
      scope: storage.type.c++
      set: data-structures-class-definition
    # Detect variable type definitions using struct/enum/union followed by a tag
    - match: '\b({{before_tag}})(?=\s+{{path_lookahead}}\s+{{path_lookahead}}\s*[=;\[])'
      scope: storage.type.c++
    - match: '\bstruct\b'
      scope: storage.type.c++
      set: data-structures-struct-definition
    - match: '\benum(\s+(class|struct))?\b'
      scope: storage.type.c++
      set: data-structures-enum-definition
    - match: '\bunion\b'
      scope: storage.type.c++
      set: data-structures-union-definition
    - match: '(?=\S)'
      pop: true

  preprocessor-workaround-eat-macro-before-identifier:
    # Handle macros so they aren't matched as the class name
    - match: ({{macro_identifier}})(?=\s+~?{{identifier}})
      captures:
        1: meta.assumed-macro.c

  data-structures-class-definition:
    - meta_scope: meta.class.c++
    - include: data-structures-definition-common-begin
    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
      scope: entity.name.class.forward-decl.c++
      set: data-structures-class-definition-after-identifier
    - match: '{{identifier}}'
      scope: entity.name.class.c++
      set: data-structures-class-definition-after-identifier
    - match: '(?=[:{])'
      set: data-structures-class-definition-after-identifier
    - match: '(?=;)'
      pop: true

  data-structures-class-definition-after-identifier:
    - meta_content_scope: meta.class.c++
    - include: data-structures-definition-common-begin
    # No matching of identifiers since they should all be macros at this point
    - include: data-structures-definition-common-end
    - match: '\{'
      scope: meta.block.c++ punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.class.c++ meta.block.c++
        - match: '\}'
          scope: meta.class.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - include: data-structures-body

  data-structures-struct-definition:
    - meta_scope: meta.struct.c++
    - include: data-structures-definition-common-begin
    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
      scope: entity.name.struct.forward-decl.c++
      set: data-structures-struct-definition-after-identifier
    - match: '{{identifier}}'
      scope: entity.name.struct.c++
      set: data-structures-struct-definition-after-identifier
    - match: '(?=[:{])'
      set: data-structures-struct-definition-after-identifier
    - match: '(?=;)'
      pop: true

  data-structures-struct-definition-after-identifier:
    - meta_content_scope: meta.struct.c++
    - include: data-structures-definition-common-begin
    # No matching of identifiers since they should all be macros at this point
    - include: data-structures-definition-common-end
    - match: '\{'
      scope: meta.block.c++ punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.struct.c++ meta.block.c++
        - match: '\}'
          scope: meta.struct.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - include: data-structures-body

  data-structures-enum-definition:
    - meta_scope: meta.enum.c++
    - include: data-structures-definition-common-begin
    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
      scope: entity.name.enum.forward-decl.c++
      set: data-structures-enum-definition-after-identifier
    - match: '{{identifier}}'
      scope: entity.name.enum.c++
      set: data-structures-enum-definition-after-identifier
    - match: '(?=[:{])'
      set: data-structures-enum-definition-after-identifier
    - match: '(?=;)'
      pop: true

  data-structures-enum-definition-after-identifier:
    - meta_content_scope: meta.enum.c++
    - include: data-structures-definition-common-begin
    # No matching of identifiers since they should all be macros at this point
    - include: data-structures-definition-common-end
    - match: '\{'
      scope: meta.block.c++ punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.enum.c++ meta.block.c++
        # Enums don't support methods so we have a simplified body
        - match: '\}'
          scope: meta.enum.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - include: statements

  data-structures-union-definition:
    - meta_scope: meta.union.c++
    - include: data-structures-definition-common-begin
    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
      scope: entity.name.union.forward-decl.c++
      set: data-structures-union-definition-after-identifier
    - match: '{{identifier}}'
      scope: entity.name.union.c++
      set: data-structures-union-definition-after-identifier
    - match: '(?=[{])'
      set: data-structures-union-definition-after-identifier
    - match: '(?=;)'
      pop: true

  data-structures-union-definition-after-identifier:
    - meta_content_scope: meta.union.c++
    - include: data-structures-definition-common-begin
    # No matching of identifiers since they should all be macros at this point
    # Unions don't support base classes
    - include: angle-brackets
    - match: '\{'
      scope: meta.block.c++ punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.union.c++ meta.block.c++
        - match: '\}'
          scope: meta.union.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - include: data-structures-body
    - match: '(?=;)'
      pop: true

  data-structures-definition-common-begin:
    - include: comments
    - match: '(?=\b(?:{{before_tag}}|{{control_keywords}})\b)'
      pop: true
    - include: preprocessor-other
    - include: modifiers-parens
    - include: modifiers
    - include: preprocessor-workaround-eat-macro-before-identifier

  data-structures-definition-common-end:
    - include: angle-brackets
    - match: \bfinal\b
      scope: storage.modifier.c++
    - match: ':'
      scope: punctuation.separator.c++
      push:
        - include: comments
        - include: preprocessor-other
        - include: modifiers-parens
        - include: modifiers
        - match: '\b(virtual|{{visibility_modifiers}})\b'
          scope: storage.modifier.c++
        - match: (?={{path_lookahead}})
          push:
            - meta_scope: entity.other.inherited-class.c++
            - include: identifiers
            - match: ''
              pop: true
        - include: angle-brackets
        - match: ','
          scope: punctuation.separator.c++
        - match: (?=\{|;)
          pop: true
    - match: '(?=;)'
      pop: true

  data-structures-body:
    - include: preprocessor-data-structures
    - match: '(?=\btemplate\b)'
      push:
        - include: template
        - match: (?=\S)
          set: data-structures-modifier
    - include: typedef
    - match: \b({{visibility_modifiers}})\s*(:)(?!:)
      captures:
        1: storage.modifier.c++
        2: punctuation.section.class.c++
    - match: '^\s*(?=(?:~?\w+|::))'
      push: data-structures-modifier
    - include: expressions-minus-generic-type

  data-structures-modifier:
    - match: '\bfriend\b'
      scope: storage.modifier.c++
      push:
        - match: (?=;)
          pop: true
        - match: '\{'
          scope: punctuation.section.block.begin.c++
          set:
            - meta_scope: meta.block.c++
            - match: '\}'
              scope: punctuation.section.block.end.c++
              pop: true
            - include: statements
        - match: '\b({{before_tag}})\b'
          scope: storage.type.c++
        - include: expressions-minus-function-call
    - include: comments
    - include: modifiers-parens
    - include: modifiers
    - match: '\bstatic_assert(?=\s*\()'
      scope: meta.static-assert.c++ keyword.operator.word.c++
      push:
        - match: '\('
          scope: meta.group.c++ punctuation.section.group.begin.c++
          set:
            - meta_content_scope: meta.function-call.c++ meta.group.c++
            - match: '\)'
              scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
              pop: true
            - include: expressions
    # Destructor
    - match: '(?:{{identifier}}\s*(::)\s*)?~{{identifier}}(?=\s*(\(|$))'
      scope: meta.method.destructor.c++ entity.name.function.destructor.c++
      captures:
        1: punctuation.accessor.c++
      set: method-definition-params
    # It's a macro, not a constructor if there is no type in the first param
    - match: '({{identifier}})\s*(\()(?=\s*(?!void){{identifier}}\s*[),])'
      captures:
        1: variable.function.c++
        2: meta.group.c++ punctuation.section.group.begin.c++
      push:
        - meta_scope: meta.function-call.c++
        - meta_content_scope: meta.group.c++
        - match: '\)'
          scope: meta.group.c++ punctuation.section.group.end.c++
          pop: true
        - include: expressions
    # Constructor
    - include: preprocessor-workaround-eat-macro-before-identifier
    - match: '((?!{{before_tag}}|template){{identifier}})(?=\s*\()'
      scope: meta.method.constructor.c++ entity.name.function.constructor.c++
      set: method-definition-params
    # Long form constructor
    - match: '({{identifier}}\s*(::)\s*{{identifier}})(?=\s*\()'
      captures:
        1: meta.method.constructor.c++ entity.name.function.constructor.c++
        2: punctuation.accessor.c++
      push: method-definition-params
    - match: '(?=\S)'
      set: data-structures-type

  data-structures-type:
    - include: comments
    - match: \*|&
      scope: keyword.operator.c++
      # Cast methods
    - match: '(operator)\s+({{identifier}})(?=\s*(\(|$))'
      captures:
        1: keyword.control.c++
        2: meta.method.c++ entity.name.function.c++
      set: method-definition-params
    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}}|operator)\b)'
      pop: true
    - match: '(?=\s)'
      set: data-structures-maybe-method
    # If a class/struct/enum followed by a name that is not a macro or declspec
    # then this is likely a return type of a function. This is uncommon.
    - match: |-
        (?x:
          ({{before_tag}})
          \s+
          (?=
            (?![[:upper:][:digit:]_]+\b|__declspec|{{before_tag}})
            {{path_lookahead}}
            (\s+{{identifier}}\s*\(|\s*[*&])
          )
        )
      captures:
        1: storage.type.c++
      set:
        - include: identifiers
        - match: ''
          set: data-structures-maybe-method
    # The previous match handles return types of struct/enum/etc from a func,
    # there this one exits the context to allow matching an actual struct/class
    - match: '(?=\b({{before_tag}})\b)'
      set: data-structures
    - match: '(?=\b({{casts}})\b\s*<)'
      pop: true
    - match: '{{non_angle_brackets}}'
      pop: true
    - include: angle-brackets
    - include: types
    - include: variables
    - include: constants
    - include: identifiers
    - match: (?=[&*])
      set: data-structures-maybe-method
    - match: (?=\W)
      pop: true

  data-structures-maybe-method:
    - include: comments
    # Consume pointer info, macros and any type info that was offset by macros
    - match: \*|&
      scope: keyword.operator.c++
    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}})\b)'
      pop: true
    - match: '\b({{type_qualifier}})\b'
      scope: storage.modifier.c++
    - match: '{{non_angle_brackets}}'
      pop: true
    - include: angle-brackets
    - include: types
    - include: modifiers-parens
    - include: modifiers
    # Operator overloading
    - match: '{{operator_method_name}}(?=\s*(\(|$))'
      scope: meta.method.c++ entity.name.function.c++
      set: method-definition-params
    # Identifier that is not the function name - likely a macro or type
    - match: '(?={{path_lookahead}}([ \t]+|[*&])(?!\s*(<|::|\()))'
      push:
        - include: identifiers
        - match: ''
          pop: true
    # Real function definition
    - match: '(?={{path_lookahead}}({{generic_lookahead}})\s*(\())'
      set: [method-definition-params, data-structures-function-identifier-generic]
    - match: '(?={{path_lookahead}}\s*(\())'
      set: [method-definition-params, data-structures-function-identifier]
    - match: '(?={{path_lookahead}}\s*::\s*$)'
      set: [method-definition-params, data-structures-function-identifier]
    - match: '(?=\S)'
      pop: true

  data-structures-function-identifier-generic:
    - include: angle-brackets
    - match: '(?={{identifier}})'
      push:
        - meta_content_scope: entity.name.function.c++
        - include: identifiers
        - match: '(?=<)'
          pop: true
    - match: '(?=\()'
      pop: true

  data-structures-function-identifier:
    - meta_content_scope: entity.name.function.c++
    - include: identifiers
    - match: '(?=\S)'
      pop: true

  method-definition-params:
    - meta_content_scope: meta.method.c++
    - include: comments
    - match: '(?=\()'
      set:
        - match: \(
          scope: meta.method.parameters.c++ meta.group.c++ punctuation.section.group.begin.c++
          set:
            - meta_content_scope: meta.method.parameters.c++ meta.group.c++
            - match : \)
              scope: punctuation.section.group.end.c++
              set: method-definition-continue
            - match: '\bvoid\b'
              scope: storage.type.c++
            - match: '{{identifier}}(?=\s*(\[|,|\)|=))'
              scope: variable.parameter.c++
            - match: '='
              scope: keyword.operator.assignment.c++
              push:
                - match: '(?=,|\))'
                  pop: true
                - include: expressions-minus-generic-type
            - include: expressions-minus-generic-type
    - match: '(?=\S)'
      pop: true

  method-definition-continue:
    - meta_content_scope: meta.method.c++
    - include: comments
    - match: '(?=;)'
      pop: true
    - match: '->'
      scope: punctuation.separator.c++
      set: method-definition-trailing-return
    - include: function-specifiers
    - match: '='
      scope: keyword.operator.assignment.c++
    - match: '&'
      scope: keyword.operator.c++
    - match: \b0\b
      scope: constant.numeric.c++
    - match: \b(default|delete)\b
      scope: storage.modifier.c++
    - match: '(?=:)'
      set:
        - match: ':'
          scope: punctuation.separator.initializer-list.c++
          set:
            - meta_scope: meta.method.constructor.initializer-list.c++
            - match: '{{identifier}}'
              scope: variable.other.readwrite.member.c++
              push:
                - match: \(
                  scope: meta.group.c++ punctuation.section.group.begin.c++
                  set:
                    - meta_content_scope: meta.group.c++
                    - match: \)
                      scope: meta.group.c++ punctuation.section.group.end.c++
                      pop: true
                    - include: expressions
                - match: \{
                  scope: meta.group.c++ punctuation.section.group.begin.c++
                  set:
                    - meta_content_scope: meta.group.c++
                    - match: \}
                      scope: meta.group.c++ punctuation.section.group.end.c++
                      pop: true
                    - include: expressions
                - include: comments
            - match: (?=\{|;)
              set: method-definition-continue
            - include: expressions
    - match: '(?=\{)'
      set: method-definition-body
    - match: '(?=\S)'
      pop: true

  method-definition-trailing-return:
    - include: comments
    - match: '(?=;)'
      pop: true
    - match: '(?=\{)'
      set: method-definition-body
    - include: function-specifiers
    - include: function-trailing-return-type

  method-definition-body:
    - meta_content_scope: meta.method.c++ meta.block.c++
    - match: '\{'
      scope: punctuation.section.block.begin.c++
      set:
        - meta_content_scope: meta.method.c++ meta.block.c++
        - match: '\}'
          scope: meta.method.c++ meta.block.c++ punctuation.section.block.end.c++
          pop: true
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - match: '(?=({{before_tag}})([^(;]+$|.*\{))'
          push: data-structures
        - include: statements

  ## Preprocessor for data-structures

  preprocessor-data-structures:
    - include: preprocessor-rule-enabled-data-structures
    - include: preprocessor-rule-disabled-data-structures
    - include: preprocessor-practical-workarounds

  preprocessor-rule-disabled-data-structures:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: negated-block
            - include: data-structures-body
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.c++
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled

  preprocessor-rule-enabled-data-structures:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.c++
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: negated-block
            - include: data-structures-body

  ## Preprocessor for global

  preprocessor-global:
    - include: preprocessor-rule-enabled-global
    - include: preprocessor-rule-disabled-global
    - include: preprocessor-rule-other-global

  preprocessor-statements:
    - include: preprocessor-rule-enabled-statements
    - include: preprocessor-rule-disabled-statements
    - include: preprocessor-rule-other-statements

  preprocessor-expressions:
    - include: scope:source.c#incomplete-inc
    - include: preprocessor-macro-define
    - include: scope:source.c#pragma-mark
    - include: preprocessor-other

  preprocessor-rule-disabled-global:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: preprocessor-global
            - include: negated-block
            - include: global
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.c++
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled

  preprocessor-rule-enabled-global:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.c++
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: preprocessor-global
            - include: negated-block
            - include: global

  preprocessor-rule-other-global:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: keyword.control.import.c++
      push:
        - meta_scope: meta.preprocessor.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.c++
        # Enter a new scope where all elif/else branches have their
        # contexts popped by a subsequent elif/else/endif. This ensures that
        # preprocessor branches don't push multiple meta.block scopes on
        # the stack, thus messing up the "global" context's detection of
        # functions.
        - match: $\n
          set: preprocessor-if-branch-global

  # These gymnastics here ensure that we are properly handling scope even
  # when the preprocessor is used to create different scope beginnings, such
  # as a different if/while condition
  preprocessor-if-branch-global:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      pop: true
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-global
    - match: \{
      scope: punctuation.section.block.begin.c++
      set: preprocessor-block-if-branch-global
    - include: preprocessor-global
    - include: negated-block
    - include: global

  preprocessor-block-if-branch-global:
    - meta_scope: meta.block.c++
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-block-finish-global
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-global
    - match: \}
      scope: punctuation.section.block.end.c++
      set: preprocessor-if-branch-global
    - include: statements

  preprocessor-block-finish-global:
    - meta_scope: meta.block.c++
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-block-finish-if-branch-global
    - match: \}
      scope: punctuation.section.block.end.c++
      pop: true
    - include: statements

  preprocessor-block-finish-if-branch-global:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: keyword.control.import.c++
      pop: true
    - match: \}
      scope: punctuation.section.block.end.c++
      set: preprocessor-if-branch-global
    - include: statements

  preprocessor-elif-else-branch-global:
    - match: (?=^\s*#\s*(endif)\b)
      pop: true
    - include: preprocessor-global
    - include: negated-block
    - include: global

  ## Preprocessor for statements

  preprocessor-rule-disabled-statements:
    - match: ^\s*((#if)\s+(0))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: negated-block
            - include: statements
        - match: ""
          push:
            - meta_scope: comment.block.preprocessor.if-branch.c++
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled

  preprocessor-rule-enabled-statements:
    - match: ^\s*((#if)\s+(0*1))\b
      captures:
        1: meta.preprocessor.c++
        2: keyword.control.import.c++
        3: constant.numeric.preprocessor.c++
      push:
        - match: ^\s*(#\s*endif)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.c++
          pop: true
        - match: ^\s*(#\s*else)\b
          captures:
            1: meta.preprocessor.c++ keyword.control.import.else.c++
          push:
            - meta_content_scope: comment.block.preprocessor.else-branch.c++
            - match: (?=^\s*#\s*endif\b)
              pop: true
            - include: scope:source.c#preprocessor-disabled
        - match: ""
          push:
            - match: (?=^\s*#\s*(else|endif)\b)
              pop: true
            - include: negated-block
            - include: statements

  preprocessor-rule-other-statements:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: keyword.control.import.c++
      push:
        - meta_scope: meta.preprocessor.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.c++
        # Enter a new scope where all elif/else branches have their
        # contexts popped by a subsequent elif/else/endif. This ensures that
        # preprocessor branches don't push multiple meta.block scopes on
        # the stack, thus messing up the "global" context's detection of
        # functions.
        - match: $\n
          set: preprocessor-if-branch-statements

  # These gymnastics here ensure that we are properly handling scope even
  # when the preprocessor is used to create different scope beginnings, such
  # as a different if/while condition
  preprocessor-if-branch-statements:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      pop: true
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-statements
    - match: \{
      scope: punctuation.section.block.begin.c++
      set: preprocessor-block-if-branch-statements
    - match: (?=(?!{{non_func_keywords}}){{path_lookahead}}\s*\()
      set: preprocessor-if-branch-function-call
    - include: negated-block
    - include: statements

  preprocessor-if-branch-function-call:
    - meta_content_scope: meta.function-call.c++
    - include: scope:source.c#c99
    - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
      scope: variable.function.c++
      captures:
        1: punctuation.accessor.c++
        2: punctuation.accessor.c++
    - match: '(?:(::)\s*)?{{identifier}}'
      scope: variable.function.c++
      captures:
        1: punctuation.accessor.c++
    - match: '\('
      scope: meta.group.c++ punctuation.section.group.begin.c++
      set: preprocessor-if-branch-function-call-arguments

  preprocessor-if-branch-function-call-arguments:
    - meta_content_scope: meta.function-call.c++ meta.group.c++
    - match : \)
      scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
      set: preprocessor-if-branch-statements
    - match: ^\s*(#\s*(?:elif|else))\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-if-branch-statements
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-if-branch-function-call-arguments-finish
    - include: expressions

  preprocessor-if-branch-function-call-arguments-finish:
    - meta_content_scope: meta.function-call.c++ meta.group.c++
    - match: \)
      scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
      pop: true
    - include: expressions

  preprocessor-block-if-branch-statements:
    - meta_scope: meta.block.c++
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-block-finish-statements
    - match: (?=^\s*#\s*(elif|else)\b)
      push: preprocessor-elif-else-branch-statements
    - match: \}
      scope: punctuation.section.block.end.c++
      set: preprocessor-if-branch-statements
    - include: statements

  preprocessor-block-finish-statements:
    - meta_scope: meta.block.c++
    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
      set: preprocessor-block-finish-if-branch-statements
    - match: \}
      scope: punctuation.section.block.end.c++
      pop: true
    - include: statements

  preprocessor-block-finish-if-branch-statements:
    - match: ^\s*(#\s*endif)\b
      captures:
        1: keyword.control.import.c++
      pop: true
    - match: \}
      scope: meta.block.c++ punctuation.section.block.end.c++
      set: preprocessor-if-branch-statements
    - include: statements

  preprocessor-elif-else-branch-statements:
    - match: (?=^\s*#\s*endif\b)
      pop: true
    - include: negated-block
    - include: statements

  ## Preprocessor other

  negated-block:
    - match: '\}'
      scope: punctuation.section.block.end.c++
      push:
        - match: '\{'
          scope: punctuation.section.block.begin.c++
          pop: true
        - match: (?=^\s*#\s*(elif|else|endif)\b)
          pop: true
        - include: statements

  preprocessor-macro-define:
    - match: ^\s*(\#\s*define)\b
      captures:
        1: meta.preprocessor.macro.c++ keyword.control.import.define.c++
      push:
        - meta_content_scope: meta.preprocessor.macro.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-line-ending
        - include: scope:source.c#preprocessor-comments
        - match: '({{identifier}})(?=\()'
          scope: entity.name.function.preprocessor.c++
          set:
            - match: '\('
              scope: punctuation.section.group.begin.c++
              set: preprocessor-macro-params
        - match: '{{identifier}}'
          scope: entity.name.constant.preprocessor.c++
          set: preprocessor-macro-definition

  preprocessor-macro-params:
    - meta_scope: meta.preprocessor.macro.parameters.c++ meta.group.c++
    - match: '{{identifier}}'
      scope: variable.parameter.c++
    - match: \)
      scope: punctuation.section.group.end.c++
      set: preprocessor-macro-definition
    - match: ','
      scope: punctuation.separator.c++
      push:
        - match: '{{identifier}}'
          scope: variable.parameter.c++
          pop: true
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-comments
        - match: '\.\.\.'
          scope: keyword.operator.variadic.c++
        - match: '(?=\))'
          pop: true
        - match: (/\*).*(\*/)
          scope: comment.block.c++
          captures:
            1: punctuation.definition.comment.c++
            2: punctuation.definition.comment.c++
        - match: '\S+'
          scope: invalid.illegal.unexpected-character.c++
    - include: scope:source.c#preprocessor-line-continuation
    - include: scope:source.c#preprocessor-comments
    - match: '\.\.\.'
      scope: keyword.operator.variadic.c++
    - match: (/\*).*(\*/)
      scope: comment.block.c++
      captures:
        1: punctuation.definition.comment.c++
        2: punctuation.definition.comment.c++
    - match: $\n
      scope: invalid.illegal.unexpected-end-of-line.c++

  preprocessor-macro-definition:
    - meta_content_scope: meta.preprocessor.macro.c++
    - include: scope:source.c#preprocessor-line-continuation
    - include: scope:source.c#preprocessor-line-ending
    - include: scope:source.c#preprocessor-comments
    # Don't define blocks in define statements
    - match: '\{'
      scope: punctuation.section.block.begin.c++
    - match: '\}'
      scope: punctuation.section.block.end.c++
    - include: expressions

  preprocessor-practical-workarounds:
    - include: preprocessor-convention-ignore-uppercase-ident-lines
    - include: scope:source.c#preprocessor-convention-ignore-uppercase-calls-without-semicolon

  preprocessor-convention-ignore-uppercase-ident-lines:
    - match: ^(\s*{{macro_identifier}})+\s*$
      scope: meta.assumed-macro.c++
      push:
        # It's possible that we are dealing with a function return type on its own line, and the
        # name of the function is on the subsequent line.
        - match: '(?={{path_lookahead}}({{generic_lookahead}}({{path_lookahead}})?)\s*\()'
          set: [function-definition-params, global-function-identifier-generic]
        - match: '(?={{path_lookahead}}\s*\()'
          set: [function-definition-params, global-function-identifier]
        - match: ^
          pop: true

  preprocessor-other:
    - match: ^\s*(#\s*(?:if|ifdef|ifndef|elif|else|line|pragma|undef))\b
      captures:
        1: keyword.control.import.c++
      push:
        - meta_scope: meta.preprocessor.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-line-ending
        - include: scope:source.c#preprocessor-comments
        - match: \bdefined\b
          scope: keyword.control.c++
    - match: ^\s*(#\s*endif)\b
      captures:
        1: meta.preprocessor.c++ keyword.control.import.c++
    - match: ^\s*(#\s*(?:error|warning))\b
      captures:
        1: keyword.control.import.error.c++
      push:
        - meta_scope: meta.preprocessor.diagnostic.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-line-ending
        - include: scope:source.c#preprocessor-comments
        - include: strings
        - match: '\S+'
          scope: string.unquoted.c++
    - match: ^\s*(#\s*(?:include|include_next|import))\b
      captures:
        1: keyword.control.import.include.c++
      push:
        - meta_scope: meta.preprocessor.include.c++
        - include: scope:source.c#preprocessor-line-continuation
        - include: scope:source.c#preprocessor-line-ending
        - include: scope:source.c#preprocessor-comments
        - match: '"'
          scope: punctuation.definition.string.begin.c++
          push:
            - meta_scope: string.quoted.double.include.c++
            - match: '"'
              scope: punctuation.definition.string.end.c++
              pop: true
        - match: <
          scope: punctuation.definition.string.begin.c++
          push:
            - meta_scope: string.quoted.other.lt-gt.include.c++
            - match: '>'
              scope: punctuation.definition.string.end.c++
              pop: true
    - include: preprocessor-practical-workarounds


================================================
FILE: examples/libraries/fmt/support/README
================================================
This directory contains build support files such as

* CMake modules
* Build scripts


================================================
FILE: examples/libraries/fmt/support/Vagrantfile
================================================
# -*- mode: ruby -*-
# vi: set ft=ruby :

# A vagrant config for testing against gcc-4.8.
Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/xenial64"
  config.disksize.size = '15GB'

  config.vm.provider "virtualbox" do |vb|
    vb.memory = "4096"
  end

  config.vm.provision "shell", inline: <<-SHELL
    apt-get update
    apt-get install -y g++ make wget git
    wget -q https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4-Linux-x86_64.tar.gz
    tar xzf cmake-3.14.4-Linux-x86_64.tar.gz
    ln -s `pwd`/cmake-3.14.4-Linux-x86_64/bin/cmake /usr/local/bin
  SHELL
end


================================================
FILE: examples/libraries/fmt/support/appveyor-build.py
================================================
#!/usr/bin/env python
# Build the project on AppVeyor.

import os
from subprocess import check_call

build = os.environ['BUILD']
config = os.environ['CONFIGURATION']
platform = os.environ['PLATFORM']
path = os.environ['PATH']
image = os.environ['APPVEYOR_BUILD_WORKER_IMAGE']
jobid = os.environ['APPVEYOR_JOB_ID']
cmake_command = ['cmake', '-DFMT_PEDANTIC=ON', '-DCMAKE_BUILD_TYPE=' + config, '..']
if build == 'mingw':
    cmake_command.append('-GMinGW Makefiles')
    build_command = ['mingw32-make', '-j4']
    test_command = ['mingw32-make', 'test']
    # Remove the path to Git bin directory from $PATH because it breaks
    # MinGW config.
    path = path.replace(r'C:\Program Files (x86)\Git\bin', '')
    os.environ['PATH'] = r'C:\MinGW\bin;' + path
else:
    # Add MSBuild 14.0 to PATH as described in
    # http://help.appveyor.com/discussions/problems/2229-v140-not-found-on-vs2105rc.
    os.environ['PATH'] = r'C:\Program Files (x86)\MSBuild\15.0\Bin;' + path
    if image == 'Visual Studio 2019':
        generator = 'Visual Studio 16 2019'
        if platform == 'x64':
            cmake_command.extend(['-A', 'x64'])
    else:
        if image == 'Visual Studio 2015':
            generator = 'Visual Studio 14 2015'
        elif image == 'Visual Studio 2017':
            generator = 'Visual Studio 15 2017'
        if platform == 'x64':
            generator += ' Win64'
    cmake_command.append('-G' + generator)
    build_command = ['cmake', '--build', '.', '--config', config, '--', '/m:4']
    test_command = ['ctest', '-C', config]

check_call(cmake_command)
check_call(build_command)
check_call(test_command)


================================================
FILE: examples/libraries/fmt/support/appveyor.yml
================================================
configuration:
  - Debug
  - Release

clone_depth: 1

image:
  - Visual Studio 2015

platform:
  - x64

environment:
  CTEST_OUTPUT_ON_FAILURE: 1
  MSVC_DEFAULT_OPTIONS: ON
  BUILD: msvc

before_build:
 - mkdir build
 - cd build

build_script:
  - python ../support/appveyor-build.py

on_failure:
  - appveyor PushArtifact Testing/Temporary/LastTest.log
  - appveyor AddTest test

# Uncomment this to debug AppVeyor failures.
#on_finish:
#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))


================================================
FILE: examples/libraries/fmt/support/build-docs.py
================================================
#!/usr/bin/env python
# Build the documentation in CI.

from __future__ import print_function
import errno, os, shutil, subprocess, sys, urllib
from subprocess import call, check_call, Popen, PIPE, STDOUT

def rmtree_if_exists(dir):
    try:
        shutil.rmtree(dir)
    except OSError as e:
        if e.errno == errno.ENOENT:
            pass

# Build the docs.
fmt_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
sys.path.insert(0, os.path.join(fmt_dir, 'doc'))
import build
build.create_build_env()
html_dir = build.build_docs()

repo = 'fmtlib.github.io'
branch = os.environ['GITHUB_REF']
is_ci = 'CI' in os.environ
if is_ci and branch != 'refs/heads/master':
    print('Branch: ' + branch)
    exit(0) # Ignore non-master branches
if is_ci and 'KEY' not in os.environ:
    # Don't update the repo if building in CI from an account that doesn't have
    # push access.
    print('Skipping update of ' + repo)
    exit(0)

# Clone the fmtlib.github.io repo.
rmtree_if_exists(repo)
git_url = 'https://github.com/' if is_ci else 'git@github.com:'
check_call(['git', 'clone', git_url + 'fmtlib/{}.git'.format(repo)])

# Copy docs to the repo.
target_dir = os.path.join(repo, 'dev')
rmtree_if_exists(target_dir)
shutil.copytree(html_dir, target_dir, ignore=shutil.ignore_patterns('.*'))
if is_ci:
    check_call(['git', 'config', '--global', 'user.name', 'fmtbot'])
    check_call(['git', 'config', '--global', 'user.email', 'viz@fmt.dev'])

# Push docs to GitHub pages.
check_call(['git', 'add', '--all'], cwd=repo)
if call(['git', 'diff-index', '--quiet', 'HEAD'], cwd=repo):
    check_call(['git', 'commit', '-m', 'Update documentation'], cwd=repo)
    cmd = 'git push'
    if is_ci:
        cmd += ' https://$KEY@github.com/fmtlib/fmtlib.github.io.git master'
    p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd=repo)
    # Print the output without the key.
    print(p.communicate()[0].decode('utf-8').replace(os.environ['KEY'], '$KEY'))
    if p.returncode != 0:
        raise subprocess.CalledProcessError(p.returncode, cmd)


================================================
FILE: examples/libraries/fmt/support/build.gradle
================================================
import java.nio.file.Paths

// General gradle arguments for root project
buildscript {    
    repositories {
        google()
        jcenter()
    }
    dependencies {
        //
        // https://developer.android.com/studio/releases/gradle-plugin#updating-gradle
        //
        // Notice that 4.0.0 here is the version of [Android Gradle Plugin]
        // Accroding to URL above you will need Gradle 6.1 or higher
        //
        classpath "com.android.tools.build:gradle:4.1.1"
    }
}
repositories {
    google()
    jcenter()
}

// Project's root where CMakeLists.txt exists: rootDir/support/.cxx -> rootDir
def rootDir = Paths.get(project.buildDir.getParent()).getParent()
println("rootDir: ${rootDir}")

// Output: Shared library (.so) for Android 
apply plugin: "com.android.library"
android {
    compileSdkVersion 25    // Android 7.0

    // Target ABI
    //  - This option controls target platform of module
    //  - The platform might be limited by compiler's support
    //    some can work with Clang(default), but some can work only with GCC...
    //    if bad, both toolchains might not support it
    splits {
        abi {
            enable true
            // Specify platforms for Application
            reset()
            include  "arm64-v8a", "armeabi-v7a", "x86_64"
        }
    }
    ndkVersion "21.3.6528147" // ANDROID_NDK_HOME is deprecated. Be explicit

    defaultConfig {
        minSdkVersion 21    // Android 5.0+
        targetSdkVersion 25 // Follow Compile SDK
        versionCode 34      // Follow release count
        versionName "7.1.2" // Follow Official version
        
        externalNativeBuild {
            cmake {
                arguments "-DANDROID_STL=c++_shared"    // Specify Android STL
                arguments "-DBUILD_SHARED_LIBS=true"    // Build shared object
                arguments "-DFMT_TEST=false"            // Skip test
                arguments "-DFMT_DOC=false"             // Skip document
                cppFlags  "-std=c++17"
                targets   "fmt"
            }
        }
        println(externalNativeBuild.cmake.cppFlags)
        println(externalNativeBuild.cmake.arguments)
    }

    // External Native build
    //  - Use existing CMakeList.txt
    //  - Give path to CMake. This gradle file should be 
    //    neighbor of the top level cmake
    externalNativeBuild {
        cmake {
            version "3.10.0+"
            path "${rootDir}/CMakeLists.txt"
            // buildStagingDirectory "./build"  // Custom path for cmake output
        }
    }
    
    sourceSets{
        // Android Manifest for Gradle
        main {
            manifest.srcFile "AndroidManifest.xml"
        }
    }

    // https://developer.android.com/studio/build/native-dependencies#build_system_configuration
    buildFeatures {
        prefab true
        prefabPublishing true
    }
    prefab {
        fmt {
            headers "${rootDir}/include"
        }
    }
}

assemble.doLast
{
    // Instead of `ninja install`, Gradle will deploy the files.
    // We are doing this since FMT is dependent to the ANDROID_STL after build
    copy {
        from "build/intermediates/cmake"
        into "${rootDir}/libs"
    }
    // Copy debug binaries
    copy {
        from "${rootDir}/libs/debug/obj"
        into "${rootDir}/libs/debug"
    }
    // Copy Release binaries
    copy {
        from "${rootDir}/libs/release/obj"
        into "${rootDir}/libs/release"
    }
    // Remove empty directory
    delete "${rootDir}/libs/debug/obj"
    delete "${rootDir}/libs/release/obj"

    // Copy AAR files. Notice that the aar is named after the folder of this script.
    copy {
        from "build/outputs/aar/support-release.aar"
        into "${rootDir}/libs"
        rename "support-release.aar", "fmt-release.aar"
    }
    copy {
        from "build/outputs/aar/support-debug.aar"
        into "${rootDir}/libs"
        rename "support-debug.aar", "fmt-debug.aar"
    }
}


================================================
FILE: examples/libraries/fmt/support/cmake/FindSetEnv.cmake
================================================
# A CMake script to find SetEnv.cmd.

find_program(WINSDK_SETENV NAMES SetEnv.cmd
  PATHS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin")
if (WINSDK_SETENV AND PRINT_PATH)
  execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${WINSDK_SETENV}")
endif ()


================================================
FILE: examples/libraries/fmt/support/cmake/JoinPaths.cmake
================================================
# This module provides function for joining paths
# known from from most languages
#
# Original license:
# SPDX-License-Identifier: (MIT OR CC0-1.0)
# Explicit permission given to distribute this module under
# the terms of the project as described in /LICENSE.rst.
# Copyright 2020 Jan Tojnar
# https://github.com/jtojnar/cmake-snips
#
# Modelled after Python’s os.path.join
# https://docs.python.org/3.7/library/os.path.html#os.path.join
# Windows not supported
function(join_paths joined_path first_path_segment)
    set(temp_path "${first_path_segment}")
    foreach(current_segment IN LISTS ARGN)
        if(NOT ("${current_segment}" STREQUAL ""))
            if(IS_ABSOLUTE "${current_segment}")
                set(temp_path "${current_segment}")
            else()
                set(temp_path "${temp_path}/${current_segment}")
            endif()
        endif()
    endforeach()
    set(${joined_path} "${temp_path}" PARENT_SCOPE)
endfunction()


================================================
FILE: examples/libraries/fmt/support/cmake/cxx14.cmake
================================================
# C++14 feature support detection

include(CheckCXXSourceCompiles)
include(CheckCXXCompilerFlag)

if (NOT CMAKE_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 11)
endif()
message(STATUS "CXX_STANDARD: ${CMAKE_CXX_STANDARD}")

if (CMAKE_CXX_STANDARD EQUAL 20)
  check_cxx_compiler_flag(-std=c++20 has_std_20_flag)
  check_cxx_compiler_flag(-std=c++2a has_std_2a_flag)

  if (has_std_20_flag)
    set(CXX_STANDARD_FLAG -std=c++20)
  elseif (has_std_2a_flag)
    set(CXX_STANDARD_FLAG -std=c++2a)
  endif ()
elseif (CMAKE_CXX_STANDARD EQUAL 17)
  check_cxx_compiler_flag(-std=c++17 has_std_17_flag)
  check_cxx_compiler_flag(-std=c++1z has_std_1z_flag)

  if (has_std_17_flag)
    set(CXX_STANDARD_FLAG -std=c++17)
  elseif (has_std_1z_flag)
    set(CXX_STANDARD_FLAG -std=c++1z)
  endif ()
elseif (CMAKE_CXX_STANDARD EQUAL 14)
  check_cxx_compiler_flag(-std=c++14 has_std_14_flag)
  check_cxx_compiler_flag(-std=c++1y has_std_1y_flag)

  if (has_std_14_flag)
    set(CXX_STANDARD_FLAG -std=c++14)
  elseif (has_std_1y_flag)
    set(CXX_STANDARD_FLAG -std=c++1y)
  endif ()
elseif (CMAKE_CXX_STANDARD EQUAL 11)
  check_cxx_compiler_flag(-std=c++11 has_std_11_flag)
  check_cxx_compiler_flag(-std=c++0x has_std_0x_flag)

  if (has_std_11_flag)
    set(CXX_STANDARD_FLAG -std=c++11)
  elseif (has_std_0x_flag)
    set(CXX_STANDARD_FLAG -std=c++0x)
  endif ()
endif ()

set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG})

# Check if user-defined literals are available
check_cxx_source_compiles("
  void operator\"\" _udl(long double);
  int main() {}"
  SUPPORTS_USER_DEFINED_LITERALS)
if (NOT SUPPORTS_USER_DEFINED_LITERALS)
  set (SUPPORTS_USER_DEFINED_LITERALS OFF)
endif ()

# Check if <variant> is available
set(CMAKE_REQUIRED_FLAGS -std=c++1z)
check_cxx_source_compiles("
  #include <variant>
  int main() {}"
  FMT_HAS_VARIANT)
if (NOT FMT_HAS_VARIANT)
  set (FMT_HAS_VARIANT OFF)
endif ()

set(CMAKE_REQUIRED_FLAGS )


================================================
FILE: examples/libraries/fmt/support/cmake/fmt-config.cmake.in
================================================
@PACKAGE_INIT@

include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
check_required_components(fmt)


================================================
FILE: examples/libraries/fmt/support/cmake/fmt.pc.in
================================================
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=@CMAKE_INSTALL_PREFIX@
libdir=@libdir_for_pc_file@
includedir=@includedir_for_pc_file@

Name: fmt
Description: A modern formatting library
Version: @FMT_VERSION@
Libs: -L${libdir} -l@FMT_LIB_NAME@
Cflags: -I${includedir}



================================================
FILE: examples/libraries/fmt/support/compute-powers.py
================================================
#!/usr/bin/env python
# Compute 10 ** exp with exp in the range [min_exponent, max_exponent] and print
# normalized (with most-significant bit equal to 1) significands in hexadecimal.

from __future__ import print_function

min_exponent = -348
max_exponent = 340
step = 8
significand_size = 64
exp_offset = 2000

class fp:
    pass

powers = []
for i, exp in enumerate(range(min_exponent, max_exponent + 1, step)):
    result = fp()
    n = 10 ** exp if exp >= 0 else 2 ** exp_offset / 10 ** -exp
    k = significand_size + 1
    # Convert to binary and round.
    binary = '{:b}'.format(n)
    result.f = (int('{:0<{}}'.format(binary[:k], k), 2) + 1) / 2
    result.e = len(binary) - (exp_offset if exp < 0 else 0) - significand_size
    powers.append(result)
    # Sanity check.
    exp_offset10 = 400
    actual = result.f * 10 ** exp_offset10
    if result.e > 0:
        actual *= 2 ** result.e
    else:
        for j in range(-result.e):
            actual /= 2
    expected = 10 ** (exp_offset10 + exp)
    precision = len('{}'.format(expected)) - len('{}'.format(actual - expected))
    if precision < 19:
        print('low precision:', precision)
        exit(1)

print('Significands:', end='')
for i, fp in enumerate(powers):
    if i % 3 == 0:
        print(end='\n ')
    print(' {:0<#16x}'.format(fp.f, ), end=',')

print('\n\nExponents:', end='')
for i, fp in enumerate(powers):
    if i % 11 == 0:
        print(end='\n ')
    print(' {:5}'.format(fp.e), end=',')

print('\n\nMax exponent difference:',
      max([x.e - powers[i - 1].e for i, x in enumerate(powers)][1:]))


================================================
FILE: examples/libraries/fmt/support/docopt.py
================================================
"""Pythonic command-line interface parser that will make you smile.

 * http://docopt.org
 * Repository and issue-tracker: https://github.com/docopt/docopt
 * Licensed under terms of MIT license (see LICENSE-MIT)
 * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com

"""
import sys
import re


__all__ = ['docopt']
__version__ = '0.6.1'


class DocoptLanguageError(Exception):

    """Error in construction of usage-message by developer."""


class DocoptExit(SystemExit):

    """Exit in case user invoked program with incorrect arguments."""

    usage = ''

    def __init__(self, message=''):
        SystemExit.__init__(self, (message + '\n' + self.usage).strip())


class Pattern(object):

    def __eq__(self, other):
        return repr(self) == repr(other)

    def __hash__(self):
        return hash(repr(self))

    def fix(self):
        self.fix_identities()
        self.fix_repeating_arguments()
        return self

    def fix_identities(self, uniq=None):
        """Make pattern-tree tips point to same object if they are equal."""
        if not hasattr(self, 'children'):
            return self
        uniq = list(set(self.flat())) if uniq is None else uniq
        for i, child in enumerate(self.children):
            if not hasattr(child, 'children'):
                assert child in uniq
                self.children[i] = uniq[uniq.index(child)]
            else:
                child.fix_identities(uniq)

    def fix_repeating_arguments(self):
        """Fix elements that should accumulate/increment values."""
        either = [list(child.children) for child in transform(self).children]
        for case in either:
            for e in [child for child in case if case.count(child) > 1]:
                if type(e) is Argument or type(e) is Option and e.argcount:
                    if e.value is None:
                        e.value = []
                    elif type(e.value) is not list:
                        e.value = e.value.split()
                if type(e) is Command or type(e) is Option and e.argcount == 0:
                    e.value = 0
        return self


def transform(pattern):
    """Expand pattern into an (almost) equivalent one, but with single Either.

    Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
    Quirks: [-a] => (-a), (-a...) => (-a -a)

    """
    result = []
    groups = [[pattern]]
    while groups:
        children = groups.pop(0)
        parents = [Required, Optional, OptionsShortcut, Either, OneOrMore]
        if any(t in map(type, children) for t in parents):
            child = [c for c in children if type(c) in parents][0]
            children.remove(child)
            if type(child) is Either:
                for c in child.children:
                    groups.append([c] + children)
            elif type(child) is OneOrMore:
                groups.append(child.children * 2 + children)
            else:
                groups.append(child.children + children)
        else:
            result.append(children)
    return Either(*[Required(*e) for e in result])


class LeafPattern(Pattern):

    """Leaf/terminal node of a pattern tree."""

    def __init__(self, name, value=None):
        self.name, self.value = name, value

    def __repr__(self):
        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value)

    def flat(self, *types):
        return [self] if not types or type(self) in types else []

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        pos, match = self.single_match(left)
        if match is None:
            return False, left, collected
        left_ = left[:pos] + left[pos + 1:]
        same_name = [a for a in collected if a.name == self.name]
        if type(self.value) in (int, list):
            if type(self.value) is int:
                increment = 1
            else:
                increment = ([match.value] if type(match.value) is str
                             else match.value)
            if not same_name:
                match.value = increment
                return True, left_, collected + [match]
            same_name[0].value += increment
            return True, left_, collected
        return True, left_, collected + [match]


class BranchPattern(Pattern):

    """Branch/inner node of a pattern tree."""

    def __init__(self, *children):
        self.children = list(children)

    def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__,
                           ', '.join(repr(a) for a in self.children))

    def flat(self, *types):
        if type(self) in types:
            return [self]
        return sum([child.flat(*types) for child in self.children], [])


class Argument(LeafPattern):

    def single_match(self, left):
        for n, pattern in enumerate(left):
            if type(pattern) is Argument:
                return n, Argument(self.name, pattern.value)
        return None, None

    @classmethod
    def parse(class_, source):
        name = re.findall('(<\S*?>)', source)[0]
        value = re.findall('\[default: (.*)\]', source, flags=re.I)
        return class_(name, value[0] if value else None)


class Command(Argument):

    def __init__(self, name, value=False):
        self.name, self.value = name, value

    def single_match(self, left):
        for n, pattern in enumerate(left):
            if type(pattern) is Argument:
                if pattern.value == self.name:
                    return n, Command(self.name, True)
                else:
                    break
        return None, None


class Option(LeafPattern):

    def __init__(self, short=None, long=None, argcount=0, value=False):
        assert argcount in (0, 1)
        self.short, self.long, self.argcount = short, long, argcount
        self.value = None if value is False and argcount else value

    @classmethod
    def parse(class_, option_description):
        short, long, argcount, value = None, None, 0, False
        options, _, description = option_description.strip().partition('  ')
        options = options.replace(',', ' ').replace('=', ' ')
        for s in options.split():
            if s.startswith('--'):
                long = s
            elif s.startswith('-'):
                short = s
            else:
                argcount = 1
        if argcount:
            matched = re.findall('\[default: (.*)\]', description, flags=re.I)
            value = matched[0] if matched else None
        return class_(short, long, argcount, value)

    def single_match(self, left):
        for n, pattern in enumerate(left):
            if self.name == pattern.name:
                return n, pattern
        return None, None

    @property
    def name(self):
        return self.long or self.short

    def __repr__(self):
        return 'Option(%r, %r, %r, %r)' % (self.short, self.long,
                                           self.argcount, self.value)


class Required(BranchPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        l = left
        c = collected
        for pattern in self.children:
            matched, l, c = pattern.match(l, c)
            if not matched:
                return False, left, collected
        return True, l, c


class Optional(BranchPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        for pattern in self.children:
            m, left, collected = pattern.match(left, collected)
        return True, left, collected


class OptionsShortcut(Optional):

    """Marker/placeholder for [options] shortcut."""


class OneOrMore(BranchPattern):

    def match(self, left, collected=None):
        assert len(self.children) == 1
        collected = [] if collected is None else collected
        l = left
        c = collected
        l_ = None
        matched = True
        times = 0
        while matched:
            # could it be that something didn't match but changed l or c?
            matched, l, c = self.children[0].match(l, c)
            times += 1 if matched else 0
            if l_ == l:
                break
            l_ = l
        if times >= 1:
            return True, l, c
        return False, left, collected


class Either(BranchPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        outcomes = []
        for pattern in self.children:
            matched, _, _ = outcome = pattern.match(left, collected)
            if matched:
                outcomes.append(outcome)
        if outcomes:
            return min(outcomes, key=lambda outcome: len(outcome[1]))
        return False, left, collected


class Tokens(list):

    def __init__(self, source, error=DocoptExit):
        self += source.split() if hasattr(source, 'split') else source
        self.error = error

    @staticmethod
    def from_pattern(source):
        source = re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source)
        source = [s for s in re.split('\s+|(\S*<.*?>)', source) if s]
        return Tokens(source, error=DocoptLanguageError)

    def move(self):
        return self.pop(0) if len(self) else None

    def current(self):
        return self[0] if len(self) else None


def parse_long(tokens, options):
    """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;"""
    long, eq, value = tokens.move().partition('=')
    assert long.startswith('--')
    value = None if eq == value == '' else value
    similar = [o for o in options if o.long == long]
    if tokens.error is DocoptExit and similar == []:  # if no exact match
        similar = [o for o in options if o.long and o.long.startswith(long)]
    if len(similar) > 1:  # might be simply specified ambiguously 2+ times?
        raise tokens.error('%s is not a unique prefix: %s?' %
                           (long, ', '.join(o.long for o in similar)))
    elif len(similar) < 1:
        argcount = 1 if eq == '=' else 0
        o = Option(None, long, argcount)
        options.append(o)
        if tokens.error is DocoptExit:
            o = Option(None, long, argcount, value if argcount else True)
    else:
        o = Option(similar[0].short, similar[0].long,
                   similar[0].argcount, similar[0].value)
        if o.argcount == 0:
            if value is not None:
                raise tokens.error('%s must not have an argument' % o.long)
        else:
            if value is None:
                if tokens.current() in [None, '--']:
                    raise tokens.error('%s requires argument' % o.long)
                value = tokens.move()
        if tokens.error is DocoptExit:
            o.value = value if value is not None else True
    return [o]


def parse_shorts(tokens, options):
    """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;"""
    token = tokens.move()
    assert token.startswith('-') and not token.startswith('--')
    left = token.lstrip('-')
    parsed = []
    while left != '':
        short, left = '-' + left[0], left[1:]
        similar = [o for o in options if o.short == short]
        if len(similar) > 1:
            raise tokens.error('%s is specified ambiguously %d times' %
                               (short, len(similar)))
        elif len(similar) < 1:
            o = Option(short, None, 0)
            options.append(o)
            if tokens.error is DocoptExit:
                o = Option(short, None, 0, True)
        else:  # why copying is necessary here?
            o = Option(short, similar[0].long,
                       similar[0].argcount, similar[0].value)
            value = None
            if o.argcount != 0:
                if left == '':
                    if tokens.current() in [None, '--']:
                        raise tokens.error('%s requires argument' % short)
                    value = tokens.move()
                else:
                    value = left
                    left = ''
            if tokens.error is DocoptExit:
                o.value = value if value is not None else True
        parsed.append(o)
    return parsed


def parse_pattern(source, options):
    tokens = Tokens.from_pattern(source)
    result = parse_expr(tokens, options)
    if tokens.current() is not None:
        raise tokens.error('unexpected ending: %r' % ' '.join(tokens))
    return Required(*result)


def parse_expr(tokens, options):
    """expr ::= seq ( '|' seq )* ;"""
    seq = parse_seq(tokens, options)
    if tokens.current() != '|':
        return seq
    result = [Required(*seq)] if len(seq) > 1 else seq
    while tokens.current() == '|':
        tokens.move()
        seq = parse_seq(tokens, options)
        result += [Required(*seq)] if len(seq) > 1 else seq
    return [Either(*result)] if len(result) > 1 else result


def parse_seq(tokens, options):
    """seq ::= ( atom [ '...' ] )* ;"""
    result = []
    while tokens.current() not in [None, ']', ')', '|']:
        atom = parse_atom(tokens, options)
        if tokens.current() == '...':
            atom = [OneOrMore(*atom)]
            tokens.move()
        result += atom
    return result


def parse_atom(tokens, options):
    """atom ::= '(' expr ')' | '[' expr ']' | 'options'
             | long | shorts | argument | command ;
    """
    token = tokens.current()
    result = []
    if token in '([':
        tokens.move()
        matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token]
        result = pattern(*parse_expr(tokens, options))
        if tokens.move() != matching:
            raise tokens.error("unmatched '%s'" % token)
        return [result]
    elif token == 'options':
        tokens.move()
        return [OptionsShortcut()]
    elif token.startswith('--') and token != '--':
        return parse_long(tokens, options)
    elif token.startswith('-') and token not in ('-', '--'):
        return parse_shorts(tokens, options)
    elif token.startswith('<') and token.endswith('>') or token.isupper():
        return [Argument(tokens.move())]
    else:
        return [Command(tokens.move())]


def parse_argv(tokens, options, options_first=False):
    """Parse command-line argument vector.

    If options_first:
        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
    else:
        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;

    """
    parsed = []
    while tokens.current() is not None:
        if tokens.current() == '--':
            return parsed + [Argument(None, v) for v in tokens]
        elif tokens.current().startswith('--'):
            parsed += parse_long(tokens, options)
        elif tokens.current().startswith('-') and tokens.current() != '-':
            parsed += parse_shorts(tokens, options)
        elif options_first:
            return parsed + [Argument(None, v) for v in tokens]
        else:
            parsed.append(Argument(None, tokens.move()))
    return parsed


def parse_defaults(doc):
    defaults = []
    for s in parse_section('options:', doc):
        # FIXME corner case "bla: options: --foo"
        _, _, s = s.partition(':')  # get rid of "options:"
        split = re.split('\n[ \t]*(-\S+?)', '\n' + s)[1:]
        split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
        options = [Option.parse(s) for s in split if s.startswith('-')]
        defaults += options
    return defaults


def parse_section(name, source):
    pattern = re.compile('^([^\n]*' + name + '[^\n]*\n?(?:[ \t].*?(?:\n|$))*)',
                         re.IGNORECASE | re.MULTILINE)
    return [s.strip() for s in pattern.findall(source)]


def formal_usage(section):
    _, _, section = section.partition(':')  # drop "usage:"
    pu = section.split()
    return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )'


def extras(help, version, options, doc):
    if help and any((o.name in ('-h', '--help')) and o.value for o in options):
        print(doc.strip("\n"))
        sys.exit()
    if version and any(o.name == '--version' and o.value for o in options):
        print(version)
        sys.exit()


class Dict(dict):
    def __repr__(self):
        return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items()))


def docopt(doc, argv=None, help=True, version=None, options_first=False):
    """Parse `argv` based on command-line interface described in `doc`.

    `docopt` creates your command-line interface based on its
    description that you pass as `doc`. Such description can contain
    --options, <positional-argument>, commands, which could be
    [optional], (required), (mutually | exclusive) or repeated...

    Parameters
    ----------
    doc : str
        Description of your command-line interface.
    argv : list of str, optional
        Argument vector to be parsed. sys.argv[1:] is used if not
        provided.
    help : bool (default: True)
        Set to False to disable automatic help on -h or --help
        options.
    version : any object
        If passed, the object will be printed if --version is in
        `argv`.
    options_first : bool (default: False)
        Set to True to require options precede positional arguments,
        i.e. to forbid options and positional arguments intermix.

    Returns
    -------
    args : dict
        A dictionary, where keys are names of command-line elements
        such as e.g. "--verbose" and "<path>", and values are the
        parsed values of those elements.

    Example
    -------
    >>> from docopt import docopt
    >>> doc = '''
    ... Usage:
    ...     my_program tcp <host> <port> [--timeout=<seconds>]
    ...     my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
    ...     my_program (-h | --help | --version)
    ...
    ... Options:
    ...     -h, --help  Show this screen and exit.
    ...     --baud=<n>  Baudrate [default: 9600]
    ... '''
    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
    >>> docopt(doc, argv)
    {'--baud': '9600',
     '--help': False,
     '--timeout': '30',
     '--version': False,
     '<host>': '127.0.0.1',
     '<port>': '80',
     'serial': False,
     'tcp': True}

    See also
    --------
    * For video introduction see http://docopt.org
    * Full documentation is available in README.rst as well as online
      at https://github.com/docopt/docopt#readme

    """
    argv = sys.argv[1:] if argv is None else argv

    usage_sections = parse_section('usage:', doc)
    if len(usage_sections) == 0:
        raise DocoptLanguageError('"usage:" (case-insensitive) not found.')
    if len(usage_sections) > 1:
        raise DocoptLanguageError('More than one "usage:" (case-insensitive).')
    DocoptExit.usage = usage_sections[0]

    options = parse_defaults(doc)
    pattern = parse_pattern(formal_usage(DocoptExit.usage), options)
    # [default] syntax for argument is disabled
    #for a in pattern.flat(Argument):
    #    same_name = [d for d in arguments if d.name == a.name]
    #    if same_name:
    #        a.value = same_name[0].value
    argv = parse_argv(Tokens(argv), list(options), options_first)
    pattern_options = set(pattern.flat(Option))
    for options_shortcut in pattern.flat(OptionsShortcut):
        doc_options = parse_defaults(doc)
        options_shortcut.children = list(set(doc_options) - pattern_options)
        #if any_options:
        #    options_shortcut.children += [Option(o.short, o.long, o.argcount)
        #                    for o in argv if type(o) is Option]
    extras(help, version, argv, doc)
    matched, left, collected = pattern.fix().match(argv)
    if matched and left == []:  # better error message if left?
        return Dict((a.name, a.value) for a in (pattern.flat() + collected))
    raise DocoptExit()


================================================
FILE: examples/libraries/fmt/support/manage.py
================================================
#!/usr/bin/env python3

"""Manage site and releases.

Usage:
  manage.py release [<branch>]
  manage.py site

For the release command $FMT_TOKEN should contain a GitHub personal access token
obtained from https://github.com/settings/tokens.
"""

from __future__ import print_function
import datetime, docopt, errno, fileinput, json, os
import re, requests, shutil, sys, tempfile
from contextlib import contextmanager
from distutils.version import LooseVersion
from subprocess import check_call


class Git:
    def __init__(self, dir):
        self.dir = dir

    def call(self, method, args, **kwargs):
        return check_call(['git', method] + list(args), **kwargs)

    def add(self, *args):
        return self.call('add', args, cwd=self.dir)

    def checkout(self, *args):
        return self.call('checkout', args, cwd=self.dir)

    def clean(self, *args):
        return self.call('clean', args, cwd=self.dir)

    def clone(self, *args):
        return self.call('clone', list(args) + [self.dir])

    def commit(self, *args):
        return self.call('commit', args, cwd=self.dir)

    def pull(self, *args):
        return self.call('pull', args, cwd=self.dir)

    def push(self, *args):
        return self.call('push', args, cwd=self.dir)

    def reset(self, *args):
        return self.call('reset', args, cwd=self.dir)

    def update(self, *args):
        clone = not os.path.exists(self.dir)
        if clone:
            self.clone(*args)
        return clone


def clean_checkout(repo, branch):
    repo.clean('-f', '-d')
    repo.reset('--hard')
    repo.checkout(branch)


class Runner:
    def __init__(self, cwd):
        self.cwd = cwd

    def __call__(self, *args, **kwargs):
        kwargs['cwd'] = kwargs.get('cwd', self.cwd)
        check_call(args, **kwargs)


def create_build_env():
    """Create a build environment."""
    class Env:
        pass
    env = Env()

    # Import the documentation build module.
    env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.insert(0, os.path.join(env.fmt_dir, 'doc'))
    import build

    env.build_dir = 'build'
    env.versions = build.versions

    # Virtualenv and repos are cached to speed up builds.
    build.create_build_env(os.path.join(env.build_dir, 'virtualenv'))

    env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
    return env


@contextmanager
def rewrite(filename):
    class Buffer:
        pass
    buffer = Buffer()
    if not os.path.exists(filename):
        buffer.data = ''
        yield buffer
        return
    with open(filename) as f:
        buffer.data = f.read()
    yield buffer
    with open(filename, 'w') as f:
        f.write(buffer.data)


fmt_repo_url = 'git@github.com:fmtlib/fmt'


def update_site(env):
    env.fmt_repo.update(fmt_repo_url)

    doc_repo = Git(os.path.join(env.build_dir, 'fmtlib.github.io'))
    doc_repo.update('git@github.com:fmtlib/fmtlib.github.io')

    for version in env.versions:
        clean_checkout(env.fmt_repo, version)
        target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
        # Remove the old theme.
        for entry in os.listdir(target_doc_dir):
            path = os.path.join(target_doc_dir, entry)
            if os.path.isdir(path):
                shutil.rmtree(path)
        # Copy the new theme.
        for entry in ['_static', '_templates', 'basic-bootstrap', 'bootstrap',
                      'conf.py', 'fmt.less']:
            src = os.path.join(env.fmt_dir, 'doc', entry)
            dst = os.path.join(target_doc_dir, entry)
            copy = shutil.copytree if os.path.isdir(src) else shutil.copyfile
            copy(src, dst)
        # Rename index to contents.
        contents = os.path.join(target_doc_dir, 'contents.rst')
        if not os.path.exists(contents):
            os.rename(os.path.join(target_doc_dir, 'index.rst'), contents)
        # Fix issues in reference.rst/api.rst.
        for filename in ['reference.rst', 'api.rst', 'index.rst']:
            pattern = re.compile('doxygenfunction.. (bin|oct|hexu|hex)$', re.M)
            with rewrite(os.path.join(target_doc_dir, filename)) as b:
                b.data = b.data.replace('std::ostream &', 'std::ostream&')
                b.data = re.sub(pattern, r'doxygenfunction:: \1(int)', b.data)
                b.data = b.data.replace('std::FILE*', 'std::FILE *')
                b.data = b.data.replace('unsigned int', 'unsigned')
                #b.data = b.data.replace('operator""_', 'operator"" _')
                b.data = b.data.replace(
                    'format_to_n(OutputIt, size_t, string_view, Args&&',
                    'format_to_n(OutputIt, size_t, const S&, const Args&')
                b.data = b.data.replace(
                    'format_to_n(OutputIt, std::size_t, string_view, Args&&',
                    'format_to_n(OutputIt, std::size_t, const S&, const Args&')
                if version == ('3.0.2'):
                    b.data = b.data.replace(
                        'fprintf(std::ostream&', 'fprintf(std::ostream &')
                if version == ('5.3.0'):
                    b.data = b.data.replace(
                        'format_to(OutputIt, const S&, const Args&...)',
                        'format_to(OutputIt, const S &, const Args &...)')
                if version.startswith('5.') or version.startswith('6.'):
                    b.data = b.data.replace(', size_t', ', std::size_t')
                if version.startswith('7.'):
                    b.data = b.data.replace(', std::size_t', ', size_t')
                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
                if version.startswith('7.1.'):
                    b.data = b.data.replace(', std::size_t', ', size_t')
                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
                    b.data = b.data.replace(
                        'fmt::format_to(OutputIt, const S&, Args&&...)',
                        'fmt::format_to(OutputIt, const S&, Args&&...) -> ' +
                        'typename std::enable_if<enable, OutputIt>::type')
                b.data = b.data.replace('aa long', 'a long')
                b.data = b.data.replace('serveral', 'several')
                if version.startswith('6.2.'):
                    b.data = b.data.replace(
                        'vformat(const S&, basic_format_args<' +
                        'buffer_context<Char>>)',
                        'vformat(const S&, basic_format_args<' +
                        'buffer_context<type_identity_t<Char>>>)')
        # Fix a broken link in index.rst.
        index = os.path.join(target_doc_dir, 'index.rst')
        with rewrite(index) as b:
            b.data = b.data.replace(
                'doc/latest/index.html#format-string-syntax', 'syntax.html')
        # Build the docs.
        html_dir = os.path.join(env.build_dir, 'html')
        if os.path.exists(html_dir):
            shutil.rmtree(html_dir)
        include_dir = env.fmt_repo.dir
        if LooseVersion(version) >= LooseVersion('5.0.0'):
            include_dir = os.path.join(include_dir, 'include', 'fmt')
        elif LooseVersion(version) >= LooseVersion('3.0.0'):
            include_dir = os.path.join(include_dir, 'fmt')
        import build
        build.build_docs(version, doc_dir=target_doc_dir,
                         include_dir=include_dir, work_dir=env.build_dir)
        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
        # Create symlinks for older versions.
        for link, target in {'index': 'contents', 'api': 'reference'}.items():
            link = os.path.join(html_dir, link) + '.html'
            target += '.html'
            if os.path.exists(os.path.join(html_dir, target)) and \
               not os.path.exists(link):
                os.symlink(target, link)
        # Copy docs to the website.
        version_doc_dir = os.path.join(doc_repo.dir, version)
        try:
            shutil.rmtree(version_doc_dir)
        except OSError as e:
            if e.errno != errno.ENOENT:
                raise
        shutil.move(html_dir, version_doc_dir)


def release(args):
    env = create_build_env()
    fmt_repo = env.fmt_repo

    branch = args.get('<branch>')
    if branch is None:
        branch = 'master'
    if not fmt_repo.update('-b', branch, fmt_repo_url):
        clean_checkout(fmt_repo, branch)

    # Convert changelog from RST to GitHub-flavored Markdown and get the
    # version.
    changelog = 'ChangeLog.rst'
    changelog_path = os.path.join(fmt_repo.dir, changelog)
    import rst2md
    changes, version = rst2md.convert(changelog_path)
    cmakelists = 'CMakeLists.txt'
    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
                                inplace=True):
        prefix = 'set(FMT_VERSION '
        if line.startswith(prefix):
            line = prefix + version + ')\n'
        sys.stdout.write(line)

    # Update the version in the changelog.
    title_len = 0
    for line in fileinput.input(changelog_path, inplace=True):
        if line.decode('utf-8').startswith(version + ' - TBD'):
            line = version + ' - ' + datetime.date.today().isoformat()
            title_len = len(line)
            line += '\n'
        elif title_len:
            line = '-' * title_len + '\n'
            title_len = 0
        sys.stdout.write(line)

    # Add the version to the build script.
    script = os.path.join('doc', 'build.py')
    script_path = os.path.join(fmt_repo.dir, script)
    for line in fileinput.input(script_path, inplace=True):
      m = re.match(r'( *versions = )\[(.+)\]', line)
      if m:
        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
      sys.stdout.write(line)

    fmt_repo.checkout('-B', 'release')
    fmt_repo.add(changelog, cmakelists, script)
    fmt_repo.commit('-m', 'Update version')

    # Build the docs and package.
    run = Runner(fmt_repo.dir)
    run('cmake', '.')
    run('make', 'doc', 'package_source')
    update_site(env)

    # Create a release on GitHub.
    fmt_repo.push('origin', 'release')
    params = {'access_token': os.getenv('FMT_TOKEN')}
    r = requests.post('https://api.github.com/repos/fmtlib/fmt/releases',
                      params=params,
                      data=json.dumps({'tag_name': version,
                                       'target_commitish': 'release',
                                       'body': changes, 'draft': True}))
    if r.status_code != 201:
        raise Exception('Failed to create a release ' + str(r))
    id = r.json()['id']
    uploads_url = 'https://uploads.github.com/repos/fmtlib/fmt/releases'
    package = 'fmt-{}.zip'.format(version)
    r = requests.post(
        '{}/{}/assets?name={}'.format(uploads_url, id, package),
        headers={'Content-Type': 'application/zip'},
        params=params, data=open('build/fmt/' + package, 'rb'))
    if r.status_code != 201:
        raise Exception('Failed to upload an asset ' + str(r))


if __name__ == '__main__':
    args = docopt.docopt(__doc__)
    if args.get('release'):
        release(args)
    elif args.get('site'):
        update_site(create_build_env())


================================================
FILE: examples/libraries/fmt/support/rst2md.py
================================================
#!/usr/bin/env python
# reStructuredText (RST) to GitHub-flavored Markdown converter

import re, sys
from docutils import core, nodes, writers


def is_github_ref(node):
    return re.match('https://github.com/.*/(issues|pull)/.*', node['refuri'])


class Translator(nodes.NodeVisitor):
    def __init__(self, document):
        nodes.NodeVisitor.__init__(self, document)
        self.output = ''
        self.indent = 0
        self.preserve_newlines = False

    def write(self, text):
        self.output += text.replace('\n', '\n' + ' ' * self.indent)

    def visit_document(self, node):
        pass

    def depart_document(self, node):
        pass

    def visit_section(self, node):
        pass

    def depart_section(self, node):
        # Skip all sections except the first one.
        raise nodes.StopTraversal

    def visit_title(self, node):
        self.version = re.match(r'(\d+\.\d+\.\d+).*', node.children[0]).group(1)
        raise nodes.SkipChildren

    def visit_title_reference(self, node):
        raise Exception(node)

    def depart_title(self, node):
        pass

    def visit_Text(self, node):
        if not self.preserve_newlines:
            node = node.replace('\n', ' ')
        self.write(node)

    def depart_Text(self, node):
        pass

    def visit_bullet_list(self, node):
        pass

    def depart_bullet_list(self, node):
        pass

    def visit_list_item(self, node):
        self.write('* ')
        self.indent += 2

    def depart_list_item(self, node):
        self.indent -= 2
        self.write('\n\n')

    def visit_paragraph(self, node):
        self.write('\n\n')

    def depart_paragraph(self, node):
        pass

    def visit_reference(self, node):
        if not is_github_ref(node):
            self.write('[')

    def depart_reference(self, node):
        if not is_github_ref(node):
            self.write('](' + node['refuri'] + ')')

    def visit_target(self, node):
        pass

    def depart_target(self, node):
        pass

    def visit_literal(self, node):
        self.write('`')

    def depart_literal(self, node):
        self.write('`')

    def visit_literal_block(self, node):
        self.write('\n\n```')
        if 'c++' in node['classes']:
            self.write('c++')
        self.write('\n')
        self.preserve_newlines = True

    def depart_literal_block(self, node):
        self.write('\n```\n')
        self.preserve_newlines = False

    def visit_inline(self, node):
        pass

    def depart_inline(self, node):
        pass

    def visit_image(self, node):
        self.write('![](' + node['uri'] + ')')

    def depart_image(self, node):
        pass

    def write_row(self, row, widths):
        for i, entry in enumerate(row):
            text = entry[0][0] if len(entry) > 0 else ''
            if i != 0:
                self.write('|')
            self.write('{:{}}'.format(text, widths[i]))
        self.write('\n')

    def visit_table(self, node):
        table = node.children[0]
        colspecs = table[:-2]
        thead = table[-2]
        tbody = table[-1]
        widths = [int(cs['colwidth']) for cs in colspecs]
        sep = '|'.join(['-' * w for w in widths]) + '\n'
        self.write('\n\n')
        self.write_row(thead[0], widths)
        self.write(sep)
        for row in tbody:
            self.write_row(row, widths)
        raise nodes.SkipChildren

    def depart_table(self, node):
        pass

class MDWriter(writers.Writer):
    """GitHub-flavored markdown writer"""

    supported = ('md',)
    """Formats this writer supports."""

    def translate(self):
        translator = Translator(self.document)
        self.document.walkabout(translator)
        self.output = (translator.output, translator.version)


def convert(rst_path):
    """Converts RST file to Markdown."""
    return core.publish_file(source_path=rst_path, writer=MDWriter())


if __name__ == '__main__':
    convert(sys.argv[1])


================================================
FILE: examples/libraries/fmt/support/rtd/conf.py
================================================
# Sphinx configuration for readthedocs.

import os, sys

master_doc = 'index'
html_theme = 'theme'
html_theme_path = ["."]


================================================
FILE: examples/libraries/fmt/support/rtd/index.rst
================================================
If you are not redirected automatically, follow the
`link to the fmt documentation <https://fmt.dev/latest/>`_.


================================================
FILE: examples/libraries/fmt/support/rtd/theme/layout.html
================================================
{% extends "basic/layout.html" %}

{% block extrahead %}
<meta charset="UTF-8">
<meta http-equiv="refresh" content="1;url=https://fmt.dev/latest/">
<script type="text/javascript">
    window.location.href = "https://fmt.dev/latest/"
</script>
<title>Page Redirection</title>
{% endblock %}

{% block document %}
If you are not redirected automatically, follow the <a href='https://fmt.dev/latest/'>link to the fmt documentation</a>.
{% endblock %}

{% block footer %}
{% endblock %}


================================================
FILE: examples/libraries/fmt/support/rtd/theme/theme.conf
================================================
[theme]
inherit = basic


================================================
FILE: examples/libraries/fmt/test/CMakeLists.txt
================================================
add_subdirectory(gtest)

set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
add_library(test-main STATIC ${TEST_MAIN_SRC})
target_include_directories(test-main PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
target_link_libraries(test-main gtest)

include(CheckCXXCompilerFlag)

# Workaround GTest bug https://github.com/google/googletest/issues/705.
check_cxx_compiler_flag(
  -fno-delete-null-pointer-checks HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
if (HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
  target_compile_options(test-main PUBLIC -fno-delete-null-pointer-checks)
endif ()

# Use less strict pedantic flags for the tests because GMock doesn't compile
# cleanly with -pedantic and -std=c++98.
if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
    #set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -Wno-long-long -Wno-variadic-macros)
endif ()

function(add_fmt_executable name)
  add_executable(${name} ${ARGN})
  if (MINGW)
    target_link_libraries(${name} -static-libgcc -static-libstdc++)
  endif ()
endfunction()

# Adds a test.
# Usage: add_fmt_test(name srcs...)
function(add_fmt_test name)
  cmake_parse_arguments(ADD_FMT_TEST "HEADER_ONLY;MODULE" "" "" ${ARGN})

  set(sources ${name}.cc ${ADD_FMT_TEST_UNPARSED_ARGUMENTS})
  if (ADD_FMT_TEST_HEADER_ONLY)
    set(sources ${sources} ${TEST_MAIN_SRC} ../src/os.cc)
    set(libs gtest fmt-header-only)
    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-weak-vtables)
    endif ()
  elseif (ADD_FMT_TEST_MODULE)
    set(libs gtest test-module)
    set_source_files_properties(${name}.cc PROPERTIES OBJECT_DEPENDS test-module)
  else ()
    set(libs test-main fmt)
  endif ()
  add_fmt_executable(${name} ${sources})
  target_link_libraries(${name} ${libs})

  # Define if certain C++ features can be used.
  if (FMT_PEDANTIC)
    target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
  endif ()
  if (FMT_WERROR)
    target_compile_options(${name} PRIVATE ${WERROR_FLAG})
  endif ()
  add_test(NAME ${name} COMMAND ${name})
endfunction()

add_fmt_test(args-test)
add_fmt_test(assert-test)
add_fmt_test(chrono-test)
add_fmt_test(color-test)
add_fmt_test(core-test)
add_fmt_test(gtest-extra-test)
add_fmt_test(format-test mock-allocator.h)
if (MSVC)
  target_compile_options(format-test PRIVATE /bigobj)
endif ()
if (NOT (MSVC AND BUILD_SHARED_LIBS))
  add_fmt_test(format-impl-test HEADER_ONLY header-only-test.cc)
endif ()
add_fmt_test(ostream-test)
add_fmt_test(compile-test)
add_fmt_test(printf-test)
add_fmt_test(ranges-test)
add_fmt_test(scan-test)
add_fmt_test(unicode-test HEADER_ONLY)
if (MSVC)
  target_compile_options(unicode-test PRIVATE /utf-8)
endif ()
add_fmt_test(xchar-test)
add_fmt_test(enforce-checks-test)
target_compile_definitions(enforce-checks-test PRIVATE
                           -DFMT_ENFORCE_COMPILE_STRING)

if (FMT_CAN_MODULE)
  # The tests need {fmt} to be compiled as traditional library
  # because of visibility of implementation details.
  # If module support is present the module tests require a
  # test-only module to be built from {fmt}
  add_library(test-module OBJECT ${CMAKE_SOURCE_DIR}/src/fmt.cc)
  target_compile_features(test-module PUBLIC ${FMT_REQUIRED_FEATURES})
  target_include_directories(test-module PUBLIC
    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
  enable_module(test-module)

  add_fmt_test(module-test MODULE test-main.cc)
  if (MSVC)
    target_compile_options(test-module PRIVATE /utf-8 /Zc:__cplusplus
                           /Zc:externConstexpr /Zc:inline)
    target_compile_options(module-test PRIVATE /utf-8 /Zc:__cplusplus
                           /Zc:externConstexpr /Zc:inline)
  endif ()
endif ()

if (NOT DEFINED MSVC_STATIC_RUNTIME AND MSVC)
  foreach (flag_var
			 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
			 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
	if (${flag_var} MATCHES "^(/|-)(MT|MTd)")
	  set(MSVC_STATIC_RUNTIME ON)
	  break()
	endif()
  endforeach()
endif()

if (NOT MSVC_STATIC_RUNTIME)
  add_fmt_executable(posix-mock-test
    posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
  target_include_directories(
    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
  target_link_libraries(posix-mock-test gtest)
  if (FMT_PEDANTIC)
    target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
  endif ()
  if (HAVE_STRTOD_L)
    target_compile_definitions(posix-mock-test PRIVATE FMT_LOCALE)
  endif ()
  add_test(NAME posix-mock-test COMMAND posix-mock-test)
  add_fmt_test(os-test)
endif ()

message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}")

if (FMT_PEDANTIC AND CXX_STANDARD LESS 20)
  # MSVC fails to compile GMock when C++17 is enabled.
  if (FMT_HAS_VARIANT AND NOT MSVC)
    add_fmt_test(std-format-test)
    set_property(TARGET std-format-test PROPERTY CXX_STANDARD 17)
  endif ()

  # Test that the library can be compiled with exceptions disabled.
  # -fno-exception is broken in icc: https://github.com/fmtlib/fmt/issues/822.
  if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
    check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
  endif ()
  if (HAVE_FNO_EXCEPTIONS_FLAG)
    add_library(noexception-test ../src/format.cc)
    target_include_directories(
      noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
    target_compile_options(noexception-test PRIVATE -fno-exceptions)
    if (FMT_PEDANTIC)
      target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
    endif ()
  endif ()

  # Test that the library compiles without locale.
  add_library(nolocale-test ../src/format.cc)
  target_include_directories(
    nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
  target_compile_definitions(
    nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)

  add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}"
    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")
endif ()

# These tests are disabled on Windows because they take too long.
if (FMT_PEDANTIC AND NOT WIN32)
  # Test if the targets are found from the build directory.
  add_test(find-package-test ${CMAKE_CTEST_COMMAND}
    -C ${CMAKE_BUILD_TYPE}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
    "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DFMT_DIR=${PROJECT_BINARY_DIR}"
    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")

  # Test if the targets are found when add_subdirectory is used.
  add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
    -C ${CMAKE_BUILD_TYPE}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
endif ()

# This test are disabled on Windows because it is only *NIX issue.
if (FMT_PEDANTIC AND NOT WIN32)
  add_test(static-export-test ${CMAKE_CTEST_COMMAND}
    -C ${CMAKE_BUILD_TYPE}
    --build-and-test
    "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test"
    "${CMAKE_CURRENT_BINARY_DIR}/static-export-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
endif ()

# Activate optional CUDA tests if CUDA is found. For version selection see
# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
if (FMT_CUDA_TEST)
  if (${CMAKE_VERSION} VERSION_LESS 3.15)
    find_package(CUDA 9.0)
  else ()
    include(CheckLanguage)
    check_language(CUDA)
    if (CMAKE_CUDA_COMPILER)
      enable_language(CUDA OPTIONAL)
      set(CUDA_FOUND TRUE)
    endif ()
  endif ()

  if (CUDA_FOUND)
    add_subdirectory(cuda-test)
    add_test(NAME cuda-test COMMAND fmt-in-cuda-test)
  endif ()
endif ()


================================================
FILE: examples/libraries/fmt/test/add-subdirectory-test/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1...3.18)

project(fmt-test CXX)

add_subdirectory(../.. fmt)

add_executable(library-test main.cc)
target_include_directories(library-test PUBLIC SYSTEM .)
target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
target_link_libraries(library-test fmt::fmt)

if (TARGET fmt::fmt-header-only)
  add_executable(header-only-test main.cc)
  target_include_directories(header-only-test PUBLIC SYSTEM .)
  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
  target_link_libraries(header-only-test fmt::fmt-header-only)
endif ()


================================================
FILE: examples/libraries/fmt/test/add-subdirectory-test/main.cc
================================================
#include "fmt/core.h"

int main(int argc, char** argv) {
  for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]);
}


================================================
FILE: examples/libraries/fmt/test/args-test.cc
================================================
// Formatting library for C++ - dynamic argument store tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/args.h"

#include "gtest/gtest.h"

TEST(args_test, basic) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  store.push_back(42);
  store.push_back("abc1");
  store.push_back(1.5f);
  EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store));
}

TEST(args_test, strings_and_refs) {
  // Unfortunately the tests are compiled with old ABI so strings use COW.
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  char str[] = "1234567890";
  store.push_back(str);
  store.push_back(std::cref(str));
  store.push_back(fmt::string_view{str});
  str[0] = 'X';

  auto result = fmt::vformat("{} and {} and {}", store);
  EXPECT_EQ("1234567890 and X234567890 and X234567890", result);
}

struct custom_type {
  int i = 0;
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<custom_type> {
  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const custom_type& p, FormatContext& ctx) -> decltype(ctx.out()) {
    return format_to(ctx.out(), "cust={}", p.i);
  }
};
FMT_END_NAMESPACE

TEST(args_test, custom_format) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  auto c = custom_type();
  store.push_back(c);
  ++c.i;
  store.push_back(c);
  ++c.i;
  store.push_back(std::cref(c));
  ++c.i;
  auto result = fmt::vformat("{} and {} and {}", store);
  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
}

struct to_stringable {
  friend fmt::string_view to_string_view(to_stringable) { return {}; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<to_stringable> {
  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  auto format(to_stringable, format_context& ctx) -> decltype(ctx.out()) {
    return ctx.out();
  }
};
FMT_END_NAMESPACE

TEST(args_test, to_string_and_formatter) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  auto s = to_stringable();
  store.push_back(s);
  store.push_back(std::cref(s));
  fmt::vformat("", store);
}

TEST(args_test, named_int) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  store.push_back(fmt::arg("a1", 42));
  EXPECT_EQ("42", fmt::vformat("{a1}", store));
}

TEST(args_test, named_strings) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  char str[] = "1234567890";
  store.push_back(fmt::arg("a1", str));
  store.push_back(fmt::arg("a2", std::cref(str)));
  str[0] = 'X';
  EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store));
}

TEST(args_test, named_arg_by_ref) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  char band[] = "Rolling Stones";
  store.push_back(fmt::arg("band", std::cref(band)));
  band[9] = 'c';  // Changing band affects the output.
  EXPECT_EQ(fmt::vformat("{band}", store), "Rolling Scones");
}

TEST(args_test, named_custom_format) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  auto c = custom_type();
  store.push_back(fmt::arg("c1", c));
  ++c.i;
  store.push_back(fmt::arg("c2", c));
  ++c.i;
  store.push_back(fmt::arg("c_ref", std::cref(c)));
  ++c.i;
  auto result = fmt::vformat("{c1} and {c2} and {c_ref}", store);
  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
}

TEST(args_test, clear) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  store.push_back(42);

  auto result = fmt::vformat("{}", store);
  EXPECT_EQ("42", result);

  store.push_back(43);
  result = fmt::vformat("{} and {}", store);
  EXPECT_EQ("42 and 43", result);

  store.clear();
  store.push_back(44);
  result = fmt::vformat("{}", store);
  EXPECT_EQ("44", result);
}

TEST(args_test, reserve) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  store.reserve(2, 1);
  store.push_back(1.5f);
  store.push_back(fmt::arg("a1", 42));
  auto result = fmt::vformat("{a1} and {}", store);
  EXPECT_EQ("42 and 1.5", result);
}

struct copy_throwable {
  copy_throwable() {}
  copy_throwable(const copy_throwable&) { throw "deal with it"; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<copy_throwable> {
  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  auto format(copy_throwable, format_context& ctx) -> decltype(ctx.out()) {
    return ctx.out();
  }
};
FMT_END_NAMESPACE

TEST(args_test, throw_on_copy) {
  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
  store.push_back(std::string("foo"));
  try {
    store.push_back(copy_throwable());
  } catch (...) {
  }
  EXPECT_EQ(fmt::vformat("{}", store), "foo");
}


================================================
FILE: examples/libraries/fmt/test/assert-test.cc
================================================
// Formatting library for C++ - FMT_ASSERT test
//
// It is a separate test to minimize the number of EXPECT_DEBUG_DEATH checks
// which are slow on some platforms. In other tests FMT_ASSERT is made to throw
// an exception which is much faster and easier to check.
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/core.h"
#include "gtest/gtest.h"

TEST(assert_test, fail) {
#if GTEST_HAS_DEATH_TEST
  EXPECT_DEBUG_DEATH(FMT_ASSERT(false, "don't panic!"), "don't panic!");
#else
  fmt::print("warning: death tests are not supported\n");
#endif
}

TEST(assert_test, dangling_else) {
  bool test_condition = false;
  bool executed_else = false;
  if (test_condition)
    FMT_ASSERT(true, "");
  else
    executed_else = true;
  EXPECT_TRUE(executed_else);
}


================================================
FILE: examples/libraries/fmt/test/chrono-test.cc
================================================
// Formatting library for C++ - time formatting tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/chrono.h"

#include "gtest-extra.h"  // EXPECT_THROW_MSG
#include "util.h"         // get_locale

using fmt::runtime;

using testing::Contains;

auto make_tm() -> std::tm {
  auto time = std::tm();
  time.tm_mday = 1;
  return time;
}

auto make_hour(int h) -> std::tm {
  auto time = make_tm();
  time.tm_hour = h;
  return time;
}

auto make_minute(int m) -> std::tm {
  auto time = make_tm();
  time.tm_min = m;
  return time;
}

auto make_second(int s) -> std::tm {
  auto time = make_tm();
  time.tm_sec = s;
  return time;
}

TEST(chrono_test, format_tm) {
  auto tm = std::tm();
  tm.tm_year = 116;
  tm.tm_mon = 3;
  tm.tm_mday = 25;
  tm.tm_hour = 11;
  tm.tm_min = 22;
  tm.tm_sec = 33;
  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
            "The date is 2016-04-25 11:22:33.");
}

TEST(chrono_test, grow_buffer) {
  auto s = std::string("{:");
  for (int i = 0; i < 30; ++i) s += "%c";
  s += "}\n";
  auto t = std::time(nullptr);
  fmt::format(fmt::runtime(s), *std::localtime(&t));
}

TEST(chrono_test, format_to_empty_container) {
  auto time = std::tm();
  time.tm_sec = 42;
  auto s = std::string();
  fmt::format_to(std::back_inserter(s), "{:%S}", time);
  EXPECT_EQ(s, "42");
}

TEST(chrono_test, empty_result) { EXPECT_EQ(fmt::format("{}", std::tm()), ""); }

auto equal(const std::tm& lhs, const std::tm& rhs) -> bool {
  return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
         lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
         lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
         lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
         lhs.tm_isdst == rhs.tm_isdst;
}

TEST(chrono_test, localtime) {
  auto t = std::time(nullptr);
  auto tm = *std::localtime(&t);
  EXPECT_TRUE(equal(tm, fmt::localtime(t)));
}

TEST(chrono_test, gmtime) {
  auto t = std::time(nullptr);
  auto tm = *std::gmtime(&t);
  EXPECT_TRUE(equal(tm, fmt::gmtime(t)));
}

template <typename TimePoint> auto strftime(TimePoint tp) -> std::string {
  auto t = std::chrono::system_clock::to_time_t(tp);
  auto tm = *std::localtime(&t);
  char output[256] = {};
  std::strftime(output, sizeof(output), "%Y-%m-%d %H:%M:%S", &tm);
  return output;
}

TEST(chrono_test, time_point) {
  auto t1 = std::chrono::system_clock::now();
  EXPECT_EQ(strftime(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
  EXPECT_EQ(strftime(t1), fmt::format("{}", t1));
  using time_point =
      std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
  auto t2 = time_point(std::chrono::seconds(42));
  EXPECT_EQ(strftime(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
}

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR

TEST(chrono_test, format_default) {
  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
  EXPECT_EQ("42as",
            fmt::format("{}", std::chrono::duration<int, std::atto>(42)));
  EXPECT_EQ("42fs",
            fmt::format("{}", std::chrono::duration<int, std::femto>(42)));
  EXPECT_EQ("42ps",
            fmt::format("{}", std::chrono::duration<int, std::pico>(42)));
  EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42)));
  EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42)));
  EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42)));
  EXPECT_EQ("42cs",
            fmt::format("{}", std::chrono::duration<int, std::centi>(42)));
  EXPECT_EQ("42ds",
            fmt::format("{}", std::chrono::duration<int, std::deci>(42)));
  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
  EXPECT_EQ("42das",
            fmt::format("{}", std::chrono::duration<int, std::deca>(42)));
  EXPECT_EQ("42hs",
            fmt::format("{}", std::chrono::duration<int, std::hecto>(42)));
  EXPECT_EQ("42ks",
            fmt::format("{}", std::chrono::duration<int, std::kilo>(42)));
  EXPECT_EQ("42Ms",
            fmt::format("{}", std::chrono::duration<int, std::mega>(42)));
  EXPECT_EQ("42Gs",
            fmt::format("{}", std::chrono::duration<int, std::giga>(42)));
  EXPECT_EQ("42Ts",
            fmt::format("{}", std::chrono::duration<int, std::tera>(42)));
  EXPECT_EQ("42Ps",
            fmt::format("{}", std::chrono::duration<int, std::peta>(42)));
  EXPECT_EQ("42Es",
            fmt::format("{}", std::chrono::duration<int, std::exa>(42)));
  EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42)));
  EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42)));
  EXPECT_EQ(
      "42[15]s",
      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)));
  EXPECT_EQ(
      "42[15/4]s",
      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)));
}

TEST(chrono_test, align) {
  auto s = std::chrono::seconds(42);
  EXPECT_EQ("42s  ", fmt::format("{:5}", s));
  EXPECT_EQ("42s  ", fmt::format("{:{}}", s, 5));
  EXPECT_EQ("  42s", fmt::format("{:>5}", s));
  EXPECT_EQ("**42s**", fmt::format("{:*^7}", s));
  EXPECT_EQ("03:25:45    ",
            fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)));
  EXPECT_EQ("    03:25:45",
            fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)));
  EXPECT_EQ("~~03:25:45~~",
            fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)));
  EXPECT_EQ("03:25:45    ",
            fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12));
}

TEST(chrono_test, format_specs) {
  EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0)));
  EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0)));
  EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0)));
  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0)));
  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60)));
  EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42)));
  EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234)));
  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0)));
  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60)));
  EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42)));
  EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61)));
  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0)));
  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24)));
  EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14)));
  EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61)));
  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0)));
  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12)));
  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24)));
  EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4)));
  EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14)));
  EXPECT_EQ("03:25:45",
            fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)));
  EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345)));
  EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345)));
  EXPECT_EQ("12345", fmt::format("{:%Q}", std::chrono::seconds(12345)));
  EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(12345)));
}

TEST(chrono_test, invalid_specs) {
  auto sec = std::chrono::seconds(0);
  EXPECT_THROW_MSG(fmt::format(runtime("{:%a}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%A}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%c}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%x}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%Ex}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%X}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%EX}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%D}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%F}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%Ec}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%w}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%u}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%b}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%B}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%z}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%Z}"), sec), fmt::format_error,
                   "no date");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%Eq}"), sec), fmt::format_error,
                   "invalid format");
  EXPECT_THROW_MSG(fmt::format(runtime("{:%Oq}"), sec), fmt::format_error,
                   "invalid format");
}

auto format_tm(const std::tm& time, fmt::string_view spec,
               const std::locale& loc) -> std::string {
  auto& facet = std::use_facet<std::time_put<char>>(loc);
  std::ostringstream os;
  os.imbue(loc);
  facet.put(os, os, ' ', &time, spec.begin(), spec.end());
  return os.str();
}

TEST(chrono_test, locale) {
  auto loc = get_locale("ja_JP.utf8");
  if (loc == std::locale::classic()) return;
#  define EXPECT_TIME(spec, time, duration)                     \
    {                                                           \
      auto jp_loc = std::locale("ja_JP.utf8");                  \
      EXPECT_EQ(format_tm(time, spec, jp_loc),                  \
                fmt::format(jp_loc, "{:L" spec "}", duration)); \
    }
  EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
  EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
  EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
  EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
  auto time = make_tm();
  time.tm_hour = 3;
  time.tm_min = 25;
  time.tm_sec = 45;
  auto sec = std::chrono::seconds(12345);
  EXPECT_TIME("%r", time, sec);
  EXPECT_TIME("%p", time, sec);
}

using dms = std::chrono::duration<double, std::milli>;

TEST(chrono_test, format_default_fp) {
  typedef std::chrono::duration<float> fs;
  EXPECT_EQ("1.234s", fmt::format("{}", fs(1.234)));
  typedef std::chrono::duration<float, std::milli> fms;
  EXPECT_EQ("1.234ms", fmt::format("{}", fms(1.234)));
  typedef std::chrono::duration<double> ds;
  EXPECT_EQ("1.234s", fmt::format("{}", ds(1.234)));
  EXPECT_EQ("1.234ms", fmt::format("{}", dms(1.234)));
}

TEST(chrono_test, format_precision) {
  EXPECT_THROW_MSG(fmt::format(runtime("{:.2}"), std::chrono::seconds(42)),
                   fmt::format_error,
                   "precision not allowed for this argument type");
  EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
  EXPECT_EQ("1.23ms", fmt::format("{:.{}}", dms(1.234), 2));
}

TEST(chrono_test, format_full_specs) {
  EXPECT_EQ("1.2ms ", fmt::format("{:6.1}", dms(1.234)));
  EXPECT_EQ("  1.23ms", fmt::format("{:>8.{}}", dms(1.234), 2));
  EXPECT_EQ(" 1.2ms ", fmt::format("{:^{}.{}}", dms(1.234), 7, 1));
  EXPECT_EQ(" 1.23ms ", fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8));
  EXPECT_EQ("=1.234ms=", fmt::format("{:=^{}.{}}", dms(1.234), 9, 3));
  EXPECT_EQ("*1.2340ms*", fmt::format("{:*^10.4}", dms(1.234)));
}

TEST(chrono_test, format_simple_q) {
  typedef std::chrono::duration<float> fs;
  EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", fs(1.234)));
  typedef std::chrono::duration<float, std::milli> fms;
  EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", fms(1.234)));
  typedef std::chrono::duration<double> ds;
  EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", ds(1.234)));
  EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", dms(1.234)));
}

TEST(chrono_test, format_precision_q) {
  EXPECT_THROW_MSG(fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)),
                   fmt::format_error,
                   "precision not allowed for this argument type");
  EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234)));
  EXPECT_EQ("1.23 ms", fmt::format("{:.{}%Q %q}", dms(1.234), 2));
}

TEST(chrono_test, format_full_specs_q) {
  EXPECT_EQ("1.2 ms ", fmt::format("{:7.1%Q %q}", dms(1.234)));
  EXPECT_EQ(" 1.23 ms", fmt::format("{:>8.{}%Q %q}", dms(1.234), 2));
  EXPECT_EQ(" 1.2 ms ", fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1));
  EXPECT_EQ(" 1.23 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9));
  EXPECT_EQ("=1.234 ms=", fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3));
  EXPECT_EQ("*1.2340 ms*", fmt::format("{:*^11.4%Q %q}", dms(1.234)));
}

TEST(chrono_test, invalid_width_id) {
  EXPECT_THROW(fmt::format(runtime("{:{o}"), std::chrono::seconds(0)),
               fmt::format_error);
}

TEST(chrono_test, invalid_colons) {
  EXPECT_THROW(fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)),
               fmt::format_error);
}

TEST(chrono_test, negative_durations) {
  EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345)));
  EXPECT_EQ("-03:25:45",
            fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)));
  EXPECT_EQ("-00:01",
            fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)));
  EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(-12345)));
  EXPECT_EQ("-00.127",
            fmt::format("{:%S}",
                        std::chrono::duration<signed char, std::milli>{-127}));
  auto min = std::numeric_limits<int>::min();
  EXPECT_EQ(fmt::format("{}", min),
            fmt::format("{:%Q}", std::chrono::duration<int>(min)));
}

TEST(chrono_test, special_durations) {
  EXPECT_EQ(
      "40.",
      fmt::format("{:%S}", std::chrono::duration<double>(1e20)).substr(0, 3));
  auto nan = std::numeric_limits<double>::quiet_NaN();
  EXPECT_EQ(
      "nan nan nan nan nan:nan nan",
      fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)));
  fmt::format("{:%S}",
              std::chrono::duration<float, std::atto>(1.79400457e+31f));
  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
            "1Es");
  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
            "1as");
  EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
            "03:33");
  EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
            "03:33:20");
}

TEST(chrono_test, unsigned_duration) {
  EXPECT_EQ("42s", fmt::format("{}", std::chrono::duration<unsigned>(42)));
}

TEST(chrono_test, weekday) {
  auto loc = get_locale("ru_RU.UTF-8");
  std::locale::global(loc);
  auto mon = fmt::weekday(1);
  EXPECT_EQ(fmt::format("{}", mon), "Mon");
  if (loc != std::locale::classic()) {
    EXPECT_THAT((std::vector<std::string>{"пн", "Пн", "пнд", "Пнд"}),
                Contains(fmt::format(loc, "{:L}", mon)));
  }
}

#endif  // FMT_STATIC_THOUSANDS_SEPARATOR


================================================
FILE: examples/libraries/fmt/test/color-test.cc
================================================
// Formatting library for C++ - color tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/color.h"

#include <iterator>  // std::back_inserter

#include "gtest-extra.h"  // EXPECT_WRITE

TEST(color_test, format) {
  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
            "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"),
            "\x1b[38;2;000;000;255mblue\x1b[0m");
  EXPECT_EQ(
      fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
      "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"), "\x1b[1mbold\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::faint, "faint"), "\x1b[2mfaint\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"),
            "\x1b[3mitalic\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"),
            "\x1b[4munderline\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::blink, "blink"), "\x1b[5mblink\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::reverse, "reverse"),
            "\x1b[7mreverse\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::conceal, "conceal"),
            "\x1b[8mconceal\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"),
            "\x1b[9mstrikethrough\x1b[0m");
  EXPECT_EQ(
      fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
      "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"),
            "\x1b[1mbold error\x1b[0m");
  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"),
            "\x1b[38;2;000;000;255mblue log\x1b[0m");
  EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi");
  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"),
            "\x1b[31mtred\x1b[0m");
  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"),
            "\x1b[46mtcyan\x1b[0m");
  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"),
            "\x1b[92mtbgreen\x1b[0m");
  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
            "\x1b[105mtbmagenta\x1b[0m");
  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "{}", "foo"),
            "\x1b[31mfoo\x1b[0m");
}

TEST(color_test, format_to) {
  auto out = std::string();
  fmt::format_to(std::back_inserter(out), fg(fmt::rgb(255, 20, 30)),
                 "rgb(255,20,30){}{}{}", 1, 2, 3);
  EXPECT_EQ(fmt::to_string(out),
            "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m");
}

TEST(color_test, print) {
  EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
               "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
}


================================================
FILE: examples/libraries/fmt/test/compile-error-test/CMakeLists.txt
================================================
# Test if compile errors are produced where necessary.

cmake_minimum_required(VERSION 3.1...3.18)

include(CheckCXXSourceCompiles)
include(CheckCXXCompilerFlag)

set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../../include)
set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG} ${PEDANTIC_COMPILE_FLAGS})

function (generate_source result fragment)
  set(${result} "
  #define FMT_HEADER_ONLY 1
  #include \"fmt/format.h\"
  int main() {
    ${fragment}
  }
  " PARENT_SCOPE)
endfunction ()

function (expect_compile code)
  generate_source(source "${code}")
  check_cxx_source_compiles("${source}" compiles)
  if (NOT compiles)
    set(error_msg "Compile error for: ${code}")
  endif ()
  # Unset the CMake cache variable compiles. Otherwise the compile test will
  # just use cached information next time it runs.
  unset(compiles CACHE)
  if (error_msg)
    message(FATAL_ERROR ${error_msg})
  endif ()
endfunction ()

function (expect_compile_error code)
  generate_source(source "${code}")
  check_cxx_source_compiles("${source}" compiles)
  if (compiles)
    set(error_msg "No compile error for: ${code}")
  endif ()
  # Unset the CMake cache variable compiles. Otherwise the compile test will
  # just use cached information next time it runs.
  unset(compiles CACHE)
  if (error_msg)
    message(FATAL_ERROR ${error_msg})
  endif ()
endfunction ()

# check if the source file skeleton compiles
expect_compile("")

# Formatting a wide character with a narrow format string is forbidden.
expect_compile_error("fmt::format(\"{}\", L'a');")

# Formatting a wide string with a narrow format string is forbidden.
expect_compile_error("fmt::format(\"{}\", L\"foo\");")

# Formatting a narrow string with a wide format string is forbidden because
# mixing UTF-8 with UTF-16/32 can result in an invalid output.
expect_compile_error("fmt::format(L\"{}\", \"foo\");")

# Formatting a wide string with a narrow format string is forbidden.
expect_compile_error("
  struct S {
    operator std::string() const { return std::string(); }
  };
  fmt::format(\"{}\", S());
")

# Make sure that compiler features detected in the header
# match the features detected in CMake.
if (SUPPORTS_USER_DEFINED_LITERALS)
  set(supports_udl 1)
else ()
  set(supports_udl 0)
endif ()
expect_compile("#if FMT_USE_USER_DEFINED_LITERALS != ${supports_udl}
                # error
                #endif")


================================================
FILE: examples/libraries/fmt/test/compile-test.cc
================================================
// Formatting library for C++ - formatting library tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/compile.h"

#include <type_traits>

#include "fmt/chrono.h"
#include "gmock/gmock.h"
#include "gtest-extra.h"

TEST(iterator_test, counting_iterator) {
  auto it = fmt::detail::counting_iterator();
  auto prev = it++;
  EXPECT_EQ(prev.count(), 0);
  EXPECT_EQ(it.count(), 1);
  EXPECT_EQ((it + 41).count(), 42);
}

TEST(iterator_test, truncating_iterator) {
  char* p = nullptr;
  auto it = fmt::detail::truncating_iterator<char*>(p, 3);
  auto prev = it++;
  EXPECT_EQ(prev.base(), p);
  EXPECT_EQ(it.base(), p + 1);
}

TEST(iterator_test, truncating_iterator_default_construct) {
  auto it = fmt::detail::truncating_iterator<char*>();
  EXPECT_EQ(nullptr, it.base());
  EXPECT_EQ(std::size_t{0}, it.count());
}

#ifdef __cpp_lib_ranges
TEST(iterator_test, truncating_iterator_is_output_iterator) {
  static_assert(
      std::output_iterator<fmt::detail::truncating_iterator<char*>, char>);
}
#endif

TEST(iterator_test, truncating_back_inserter) {
  auto buffer = std::string();
  auto bi = std::back_inserter(buffer);
  auto it = fmt::detail::truncating_iterator<decltype(bi)>(bi, 2);
  *it++ = '4';
  *it++ = '2';
  *it++ = '1';
  EXPECT_EQ(buffer.size(), 2);
  EXPECT_EQ(buffer, "42");
}

TEST(compile_test, compile_fallback) {
  // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
  // not available.
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
}

#ifdef __cpp_if_constexpr
struct test_formattable {};

FMT_BEGIN_NAMESPACE
template <> struct formatter<test_formattable> : formatter<const char*> {
  char word_spec = 'f';
  constexpr auto parse(format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end || *it == '}') return it;
    if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++;
    if (it != end && *it != '}') throw format_error("invalid format");
    return it;
  }
  template <typename FormatContext>
  constexpr auto format(test_formattable, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
                                          ctx);
  }
};
FMT_END_NAMESPACE

TEST(compile_test, format_default) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
  EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
  EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
  EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
  auto t = std::chrono::system_clock::now();
  EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
#  ifdef __cpp_lib_byte
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
#  endif
}

TEST(compile_test, format_wide_string) {
  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
}

TEST(compile_test, format_specs) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
  EXPECT_EQ("1.2 ms ",
            fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
                        std::chrono::duration<double, std::milli>(1.234)));
}

TEST(compile_test, dynamic_format_specs) {
  EXPECT_EQ("foo  ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
  EXPECT_EQ("  3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
  EXPECT_EQ(
      "=1.234ms=",
      fmt::format(FMT_COMPILE("{:=^{}.{}}"),
                  std::chrono::duration<double, std::milli>(1.234), 9, 3));
}

TEST(compile_test, manual_ordering) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
  EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
  EXPECT_EQ("  41   43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
  EXPECT_EQ("42 1.2 ms ",
            fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
                        std::chrono::duration<double, std::milli>(1.234)));
  EXPECT_EQ(
      "true 42 42 foo 0x1234 foo",
      fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
                  "foo", reinterpret_cast<void*>(0x1234), test_formattable()));
  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
}

TEST(compile_test, named) {
  auto runtime_named_field_compiled =
      fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
  static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
                               fmt::detail::runtime_named_field<char>>);

  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
                                 fmt::arg("arg", 43)));

  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
                        fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));

  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
                        fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
  EXPECT_EQ(" bar foo ",
            fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
                        fmt::arg("bar", "foo")));

  EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
               fmt::format_error);

#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
  using namespace fmt::literals;
  auto statically_named_field_compiled =
      fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
  static_assert(std::is_same_v<decltype(statically_named_field_compiled),
                               fmt::detail::field<char, int, 0>>);

  EXPECT_EQ("41 43",
            fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
  EXPECT_EQ("41 43",
            fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
#  endif
}

TEST(compile_test, format_to) {
  char buf[8];
  auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
  *end = '\0';
  EXPECT_STREQ("42", buf);
  end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
  *end = '\0';
  EXPECT_STREQ("2a", buf);
}

TEST(compile_test, format_to_n) {
  constexpr auto buffer_size = 8;
  char buffer[buffer_size];
  auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
  *res.out = '\0';
  EXPECT_STREQ("42", buffer);
  res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
  *res.out = '\0';
  EXPECT_STREQ("2a", buffer);
}

TEST(compile_test, formatted_size) {
  EXPECT_EQ(2, fmt::formatted_size(FMT_COMPILE("{0}"), 42));
  EXPECT_EQ(5, fmt::formatted_size(FMT_COMPILE("{0:<4.2f}"), 42.0));
}

TEST(compile_test, text_and_arg) {
  EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
  EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
}

TEST(compile_test, unknown_format_fallback) {
  EXPECT_EQ(" 42 ",
            fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));

  std::vector<char> v;
  fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
                 fmt::arg("name", 42));
  EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));

  char buffer[4];
  auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
                                 fmt::arg("name", 42));
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ(buffer + 4, result.out);
  EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
}

TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }

struct to_stringable {
  friend fmt::string_view to_string_view(to_stringable) { return {}; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<to_stringable> {
  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
    return ctx.out();
  }
};
FMT_END_NAMESPACE

TEST(compile_test, to_string_and_formatter) {
  fmt::format(FMT_COMPILE("{}"), to_stringable());
}

TEST(compile_test, print) {
  EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
               "Don't panic!");
  EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
               "Don't panic!");
}
#endif

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
TEST(compile_test, compile_format_string_literal) {
  using namespace fmt::literals;
  EXPECT_EQ("", fmt::format(""_cf));
  EXPECT_EQ("42", fmt::format("{}"_cf, 42));
  EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
}
#endif

#if __cplusplus >= 202002L || \
    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
template <size_t max_string_length, typename Char = char> struct test_string {
  template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
    return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
  }
  Char buffer[max_string_length]{};
};

template <size_t max_string_length, typename Char = char, typename... Args>
consteval auto test_format(auto format, const Args&... args) {
  test_string<max_string_length, Char> string{};
  fmt::format_to(string.buffer, format, args...);
  return string;
}

TEST(compile_time_formatting_test, bool) {
  EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
  EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
  EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
  EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
}

TEST(compile_time_formatting_test, integer) {
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
  EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
  EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
  EXPECT_EQ("42 42",
            test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));

  EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
  EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));

  EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));

  EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
  EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
  EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
  EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
  EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
  EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));

  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42));
  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));

  EXPECT_EQ("42  ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
  EXPECT_EQ("  42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
  EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
  EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42));
}

TEST(compile_time_formatting_test, char) {
  EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));

  EXPECT_EQ("c  ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
  EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
}

TEST(compile_time_formatting_test, string) {
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
  EXPECT_EQ("The answer is 42",
            test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));

  EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc"));
  EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡"));
}

TEST(compile_time_formatting_test, combination) {
  EXPECT_EQ("420, true, answer",
            test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));

  EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
}

TEST(compile_time_formatting_test, custom_type) {
  EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
  EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
}

TEST(compile_time_formatting_test, multibyte_fill) {
  EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
}
#endif


================================================
FILE: examples/libraries/fmt/test/core-test.cc
================================================
// Formatting library for C++ - core tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

// clang-format off
#include "test-assert.h"
// clang-format on

#include "fmt/core.h"

#include <algorithm>    // std::copy_n
#include <climits>      // INT_MAX
#include <cstring>      // std::strlen
#include <functional>   // std::equal_to
#include <iterator>     // std::back_insert_iterator
#include <limits>       // std::numeric_limits
#include <string>       // std::string
#include <type_traits>  // std::is_same

#include "gmock/gmock.h"

using fmt::string_view;
using fmt::detail::buffer;

using testing::_;
using testing::Invoke;
using testing::Return;

#ifdef FMT_FORMAT_H_
#  error core-test includes format.h
#endif

TEST(string_view_test, value_type) {
  static_assert(std::is_same<string_view::value_type, char>::value, "");
}

TEST(string_view_test, ctor) {
  EXPECT_STREQ("abc", fmt::string_view("abc").data());
  EXPECT_EQ(3u, fmt::string_view("abc").size());

  EXPECT_STREQ("defg", fmt::string_view(std::string("defg")).data());
  EXPECT_EQ(4u, fmt::string_view(std::string("defg")).size());
}

TEST(string_view_test, length) {
  // Test that string_view::size() returns string length, not buffer size.
  char str[100] = "some string";
  EXPECT_EQ(std::strlen(str), string_view(str).size());
  EXPECT_LT(std::strlen(str), sizeof(str));
}

// Check string_view's comparison operator.
template <template <typename> class Op> void check_op() {
  const char* inputs[] = {"foo", "fop", "fo"};
  size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
  for (size_t i = 0; i < num_inputs; ++i) {
    for (size_t j = 0; j < num_inputs; ++j) {
      string_view lhs(inputs[i]), rhs(inputs[j]);
      EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
    }
  }
}

TEST(string_view_test, compare) {
  EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
  EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
  EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
  EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
  EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
  check_op<std::equal_to>();
  check_op<std::not_equal_to>();
  check_op<std::less>();
  check_op<std::less_equal>();
  check_op<std::greater>();
  check_op<std::greater_equal>();
}

namespace test_ns {
template <typename Char> class test_string {
 private:
  std::basic_string<Char> s_;

 public:
  test_string(const Char* s) : s_(s) {}
  const Char* data() const { return s_.data(); }
  size_t length() const { return s_.size(); }
  operator const Char*() const { return s_.c_str(); }
};

template <typename Char>
fmt::basic_string_view<Char> to_string_view(const test_string<Char>& s) {
  return {s.data(), s.length()};
}
}  // namespace test_ns

TEST(core_test, is_output_iterator) {
  EXPECT_TRUE((fmt::detail::is_output_iterator<char*, char>::value));
  EXPECT_FALSE((fmt::detail::is_output_iterator<const char*, char>::value));
  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string, char>::value));
  EXPECT_TRUE(
      (fmt::detail::is_output_iterator<std::back_insert_iterator<std::string>,
                                       char>::value));
  EXPECT_TRUE(
      (fmt::detail::is_output_iterator<std::string::iterator, char>::value));
  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string::const_iterator,
                                                char>::value));
}

TEST(core_test, buffer_appender) {
  // back_insert_iterator is not default-constructible before C++20, so
  // buffer_appender can only be default-constructible when back_insert_iterator
  // is.
  static_assert(
      std::is_default_constructible<
          std::back_insert_iterator<fmt::detail::buffer<char>>>::value ==
          std::is_default_constructible<
              fmt::detail::buffer_appender<char>>::value,
      "");

#ifdef __cpp_lib_ranges
  static_assert(std::output_iterator<fmt::detail::buffer_appender<char>, char>);
#endif
}

#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
TEST(buffer_test, noncopyable) {
  EXPECT_FALSE(std::is_copy_constructible<buffer<char>>::value);
#  if !FMT_MSC_VER
  // std::is_copy_assignable is broken in MSVC2013.
  EXPECT_FALSE(std::is_copy_assignable<buffer<char>>::value);
#  endif
}

TEST(buffer_test, nonmoveable) {
  EXPECT_FALSE(std::is_move_constructible<buffer<char>>::value);
#  if !FMT_MSC_VER
  // std::is_move_assignable is broken in MSVC2013.
  EXPECT_FALSE(std::is_move_assignable<buffer<char>>::value);
#  endif
}
#endif

TEST(buffer_test, indestructible) {
  static_assert(!std::is_destructible<fmt::detail::buffer<int>>(),
                "buffer's destructor is protected");
}

template <typename T> struct mock_buffer final : buffer<T> {
  MOCK_METHOD1(do_grow, size_t(size_t capacity));

  void grow(size_t capacity) { this->set(this->data(), do_grow(capacity)); }

  mock_buffer(T* data = nullptr, size_t buf_capacity = 0) {
    this->set(data, buf_capacity);
    ON_CALL(*this, do_grow(_)).WillByDefault(Invoke([](size_t capacity) {
      return capacity;
    }));
  }
};

TEST(buffer_test, ctor) {
  {
    mock_buffer<int> buffer;
    EXPECT_EQ(nullptr, buffer.data());
    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
  }
  {
    int dummy;
    mock_buffer<int> buffer(&dummy);
    EXPECT_EQ(&dummy, &buffer[0]);
    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
  }
  {
    int dummy;
    size_t capacity = std::numeric_limits<size_t>::max();
    mock_buffer<int> buffer(&dummy, capacity);
    EXPECT_EQ(&dummy, &buffer[0]);
    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
    EXPECT_EQ(capacity, buffer.capacity());
  }
}

TEST(buffer_test, access) {
  char data[10];
  mock_buffer<char> buffer(data, sizeof(data));
  buffer[0] = 11;
  EXPECT_EQ(11, buffer[0]);
  buffer[3] = 42;
  EXPECT_EQ(42, *(&buffer[0] + 3));
  const fmt::detail::buffer<char>& const_buffer = buffer;
  EXPECT_EQ(42, const_buffer[3]);
}

TEST(buffer_test, try_resize) {
  char data[123];
  mock_buffer<char> buffer(data, sizeof(data));
  buffer[10] = 42;
  EXPECT_EQ(42, buffer[10]);
  buffer.try_resize(20);
  EXPECT_EQ(20u, buffer.size());
  EXPECT_EQ(123u, buffer.capacity());
  EXPECT_EQ(42, buffer[10]);
  buffer.try_resize(5);
  EXPECT_EQ(5u, buffer.size());
  EXPECT_EQ(123u, buffer.capacity());
  EXPECT_EQ(42, buffer[10]);
  // Check if try_resize calls grow.
  EXPECT_CALL(buffer, do_grow(124));
  buffer.try_resize(124);
  EXPECT_CALL(buffer, do_grow(200));
  buffer.try_resize(200);
}

TEST(buffer_test, try_resize_partial) {
  char data[10];
  mock_buffer<char> buffer(data, sizeof(data));
  EXPECT_CALL(buffer, do_grow(20)).WillOnce(Return(15));
  buffer.try_resize(20);
  EXPECT_EQ(buffer.capacity(), 15);
  EXPECT_EQ(buffer.size(), 15);
}

TEST(buffer_test, clear) {
  mock_buffer<char> buffer;
  EXPECT_CALL(buffer, do_grow(20));
  buffer.try_resize(20);
  buffer.try_resize(0);
  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
  EXPECT_EQ(20u, buffer.capacity());
}

TEST(buffer_test, append) {
  char data[15];
  mock_buffer<char> buffer(data, 10);
  auto test = "test";
  buffer.append(test, test + 5);
  EXPECT_STREQ(test, &buffer[0]);
  EXPECT_EQ(5u, buffer.size());
  buffer.try_resize(10);
  EXPECT_CALL(buffer, do_grow(12));
  buffer.append(test, test + 2);
  EXPECT_EQ('t', buffer[10]);
  EXPECT_EQ('e', buffer[11]);
  EXPECT_EQ(12u, buffer.size());
}

TEST(buffer_test, append_partial) {
  char data[10];
  mock_buffer<char> buffer(data, sizeof(data));
  testing::InSequence seq;
  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Return(10));
  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Invoke([&buffer](size_t) {
    EXPECT_EQ(fmt::string_view(buffer.data(), buffer.size()), "0123456789");
    buffer.clear();
    return 10;
  }));
  auto test = "0123456789abcde";
  buffer.append(test, test + 15);
}

TEST(buffer_test, append_allocates_enough_storage) {
  char data[19];
  mock_buffer<char> buffer(data, 10);
  auto test = "abcdefgh";
  buffer.try_resize(10);
  EXPECT_CALL(buffer, do_grow(19));
  buffer.append(test, test + 9);
}

struct custom_context {
  using char_type = char;
  using parse_context_type = fmt::format_parse_context;

  bool called = false;

  template <typename T> struct formatter_type {
    auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin()) {
      return ctx.begin();
    }

    const char* format(const T&, custom_context& ctx) {
      ctx.called = true;
      return nullptr;
    }
  };

  void advance_to(const char*) {}
};

struct test_struct {};

FMT_BEGIN_NAMESPACE
template <typename Char> struct formatter<test_struct, Char> {
  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  auto format(test_struct, format_context& ctx) -> decltype(ctx.out()) {
    auto test = string_view("test");
    return std::copy_n(test.data(), test.size(), ctx.out());
  }
};
FMT_END_NAMESPACE

TEST(arg_test, format_args) {
  auto args = fmt::format_args();
  EXPECT_FALSE(args.get(1));
}

TEST(arg_test, make_value_with_custom_context) {
  auto t = test_struct();
  fmt::detail::value<custom_context> arg(
      fmt::detail::arg_mapper<custom_context>().map(t));
  auto ctx = custom_context();
  auto parse_ctx = fmt::format_parse_context("");
  arg.custom.format(&t, parse_ctx, ctx);
  EXPECT_TRUE(ctx.called);
}

// Use a unique result type to make sure that there are no undesirable
// conversions.
struct test_result {};

template <typename T> struct mock_visitor {
  template <typename U> struct result { using type = test_result; };

  mock_visitor() {
    ON_CALL(*this, visit(_)).WillByDefault(Return(test_result()));
  }

  MOCK_METHOD1_T(visit, test_result(T value));
  MOCK_METHOD0_T(unexpected, void());

  test_result operator()(T value) { return visit(value); }

  template <typename U> test_result operator()(U) {
    unexpected();
    return test_result();
  }
};

template <typename T> struct visit_type { using type = T; };

#define VISIT_TYPE(type_, visit_type_) \
  template <> struct visit_type<type_> { using type = visit_type_; }

VISIT_TYPE(signed char, int);
VISIT_TYPE(unsigned char, unsigned);
VISIT_TYPE(short, int);
VISIT_TYPE(unsigned short, unsigned);

#if LONG_MAX == INT_MAX
VISIT_TYPE(long, int);
VISIT_TYPE(unsigned long, unsigned);
#else
VISIT_TYPE(long, long long);
VISIT_TYPE(unsigned long, unsigned long long);
#endif

#define CHECK_ARG(Char, expected, value)                                  \
  {                                                                       \
    testing::StrictMock<mock_visitor<decltype(expected)>> visitor;        \
    EXPECT_CALL(visitor, visit(expected));                                \
    using iterator = std::back_insert_iterator<buffer<Char>>;             \
    fmt::visit_format_arg(                                                \
        visitor,                                                          \
        fmt::detail::make_arg<fmt::basic_format_context<iterator, Char>>( \
            value));                                                      \
  }

#define CHECK_ARG_SIMPLE(value)                             \
  {                                                         \
    using value_type = decltype(value);                     \
    typename visit_type<value_type>::type expected = value; \
    CHECK_ARG(char, expected, value)                        \
    CHECK_ARG(wchar_t, expected, value)                     \
  }

template <typename T> class numeric_arg_test : public testing::Test {};

using types =
    testing::Types<bool, signed char, unsigned char, short, unsigned short, int,
                   unsigned, long, unsigned long, long long, unsigned long long,
                   float, double, long double>;
TYPED_TEST_SUITE(numeric_arg_test, types);

template <typename T, fmt::enable_if_t<std::is_integral<T>::value, int> = 0>
T test_value() {
  return static_cast<T>(42);
}

template <typename T,
          fmt::enable_if_t<std::is_floating_point<T>::value, int> = 0>
T test_value() {
  return static_cast<T>(4.2);
}

TYPED_TEST(numeric_arg_test, make_and_visit) {
  CHECK_ARG_SIMPLE(test_value<TypeParam>());
  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::min());
  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::max());
}

namespace fmt {
template <> struct is_char<wchar_t> : std::true_type {};
}  // namespace fmt

TEST(arg_test, char_arg) {
  CHECK_ARG(char, 'a', 'a');
  CHECK_ARG(wchar_t, L'a', 'a');
  CHECK_ARG(wchar_t, L'a', L'a');
}

TEST(arg_test, string_arg) {
  char str_data[] = "test";
  char* str = str_data;
  const char* cstr = str;
  CHECK_ARG(char, cstr, str);

  auto sv = fmt::string_view(str);
  CHECK_ARG(char, sv, std::string(str));
}

TEST(arg_test, wstring_arg) {
  wchar_t str_data[] = L"test";
  wchar_t* str = str_data;
  const wchar_t* cstr = str;

  auto sv = fmt::basic_string_view<wchar_t>(str);
  CHECK_ARG(wchar_t, cstr, str);
  CHECK_ARG(wchar_t, cstr, cstr);
  CHECK_ARG(wchar_t, sv, std::wstring(str));
  CHECK_ARG(wchar_t, sv, fmt::basic_string_view<wchar_t>(str));
}

TEST(arg_test, pointer_arg) {
  void* p = nullptr;
  const void* cp = nullptr;
  CHECK_ARG(char, cp, p);
  CHECK_ARG(wchar_t, cp, p);
  CHECK_ARG_SIMPLE(cp);
}

struct check_custom {
  test_result operator()(
      fmt::basic_format_arg<fmt::format_context>::handle h) const {
    struct test_buffer final : fmt::detail::buffer<char> {
      char data[10];
      test_buffer() : fmt::detail::buffer<char>(data, 0, 10) {}
      void grow(size_t) {}
    } buffer;
    auto parse_ctx = fmt::format_parse_context("");
    auto ctx = fmt::format_context(fmt::detail::buffer_appender<char>(buffer),
                                   fmt::format_args());
    h.format(parse_ctx, ctx);
    EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
    return test_result();
  }
};

TEST(arg_test, custom_arg) {
  auto test = test_struct();
  using visitor =
      mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>;
  testing::StrictMock<visitor> v;
  EXPECT_CALL(v, visit(_)).WillOnce(Invoke(check_custom()));
  fmt::visit_format_arg(v, fmt::detail::make_arg<fmt::format_context>(test));
}

TEST(arg_test, visit_invalid_arg) {
  testing::StrictMock<mock_visitor<fmt::monostate>> visitor;
  EXPECT_CALL(visitor, visit(_));
  auto arg = fmt::basic_format_arg<fmt::format_context>();
  fmt::visit_format_arg(visitor, arg);
}

#if FMT_USE_CONSTEXPR

enum class arg_id_result { none, empty, index, name, error };
struct test_arg_id_handler {
  arg_id_result res = arg_id_result::none;
  int index = 0;
  string_view name;

  constexpr void operator()() { res = arg_id_result::empty; }

  constexpr void operator()(int i) {
    res = arg_id_result::index;
    index = i;
  }

  constexpr void operator()(string_view n) {
    res = arg_id_result::name;
    name = n;
  }

  constexpr void on_error(const char*) { res = arg_id_result::error; }
};

template <size_t N>
constexpr test_arg_id_handler parse_arg_id(const char (&s)[N]) {
  test_arg_id_handler h;
  fmt::detail::parse_arg_id(s, s + N, h);
  return h;
}

TEST(format_test, constexpr_parse_arg_id) {
  static_assert(parse_arg_id(":").res == arg_id_result::empty, "");
  static_assert(parse_arg_id("}").res == arg_id_result::empty, "");
  static_assert(parse_arg_id("42:").res == arg_id_result::index, "");
  static_assert(parse_arg_id("42:").index == 42, "");
  static_assert(parse_arg_id("foo:").res == arg_id_result::name, "");
  static_assert(parse_arg_id("foo:").name.size() == 3, "");
  static_assert(parse_arg_id("!").res == arg_id_result::error, "");
}

struct test_format_specs_handler {
  enum result { none, hash, zero, loc, error };
  result res = none;

  fmt::align_t alignment = fmt::align::none;
  fmt::sign_t sign = fmt::sign::none;
  char fill = 0;
  int width = 0;
  fmt::detail::arg_ref<char> width_ref;
  int precision = 0;
  fmt::detail::arg_ref<char> precision_ref;
  char type = 0;

  // Workaround for MSVC2017 bug that results in "expression did not evaluate
  // to a constant" with compiler-generated copy ctor.
  constexpr test_format_specs_handler() {}
  constexpr test_format_specs_handler(const test_format_specs_handler& other) =
      default;

  constexpr void on_align(fmt::align_t a) { alignment = a; }
  constexpr void on_fill(fmt::string_view f) { fill = f[0]; }
  constexpr void on_sign(fmt::sign_t s) { sign = s; }
  constexpr void on_hash() { res = hash; }
  constexpr void on_zero() { res = zero; }
  constexpr void on_localized() { res = loc; }

  constexpr void on_width(int w) { width = w; }
  constexpr void on_dynamic_width(fmt::detail::auto_id) {}
  constexpr void on_dynamic_width(int index) { width_ref = index; }
  constexpr void on_dynamic_width(string_view) {}

  constexpr void on_precision(int p) { precision = p; }
  constexpr void on_dynamic_precision(fmt::detail::auto_id) {}
  constexpr void on_dynamic_precision(int index) { precision_ref = index; }
  constexpr void on_dynamic_precision(string_view) {}

  constexpr void end_precision() {}
  constexpr void on_type(char t) { type = t; }
  constexpr void on_error(const char*) { res = error; }
};

template <size_t N>
constexpr test_format_specs_handler parse_test_specs(const char (&s)[N]) {
  auto h = test_format_specs_handler();
  fmt::detail::parse_format_specs(s, s + N, h);
  return h;
}

TEST(core_test, constexpr_parse_format_specs) {
  using handler = test_format_specs_handler;
  static_assert(parse_test_specs("<").alignment == fmt::align::left, "");
  static_assert(parse_test_specs("*^").fill == '*', "");
  static_assert(parse_test_specs("+").sign == fmt::sign::plus, "");
  static_assert(parse_test_specs("-").sign == fmt::sign::minus, "");
  static_assert(parse_test_specs(" ").sign == fmt::sign::space, "");
  static_assert(parse_test_specs("#").res == handler::hash, "");
  static_assert(parse_test_specs("0").res == handler::zero, "");
  static_assert(parse_test_specs("L").res == handler::loc, "");
  static_assert(parse_test_specs("42").width == 42, "");
  static_assert(parse_test_specs("{42}").width_ref.val.index == 42, "");
  static_assert(parse_test_specs(".42").precision == 42, "");
  static_assert(parse_test_specs(".{42}").precision_ref.val.index == 42, "");
  static_assert(parse_test_specs("d").type == 'd', "");
  static_assert(parse_test_specs("{<").res == handler::error, "");
}

struct test_parse_context {
  using char_type = char;

  constexpr int next_arg_id() { return 11; }
  template <typename Id> FMT_CONSTEXPR void check_arg_id(Id) {}

  constexpr const char* begin() { return nullptr; }
  constexpr const char* end() { return nullptr; }

  void on_error(const char*) {}
};

template <size_t N>
constexpr fmt::detail::dynamic_format_specs<char> parse_dynamic_specs(
    const char (&s)[N]) {
  auto specs = fmt::detail::dynamic_format_specs<char>();
  auto ctx = test_parse_context();
  auto h = fmt::detail::dynamic_specs_handler<test_parse_context>(specs, ctx);
  parse_format_specs(s, s + N, h);
  return specs;
}

TEST(format_test, constexpr_dynamic_specs_handler) {
  static_assert(parse_dynamic_specs("<").align == fmt::align::left, "");
  static_assert(parse_dynamic_specs("*^").fill[0] == '*', "");
  static_assert(parse_dynamic_specs("+").sign == fmt::sign::plus, "");
  static_assert(parse_dynamic_specs("-").sign == fmt::sign::minus, "");
  static_assert(parse_dynamic_specs(" ").sign == fmt::sign::space, "");
  static_assert(parse_dynamic_specs("#").alt, "");
  static_assert(parse_dynamic_specs("0").align == fmt::align::numeric, "");
  static_assert(parse_dynamic_specs("42").width == 42, "");
  static_assert(parse_dynamic_specs("{}").width_ref.val.index == 11, "");
  static_assert(parse_dynamic_specs("{42}").width_ref.val.index == 42, "");
  static_assert(parse_dynamic_specs(".42").precision == 42, "");
  static_assert(parse_dynamic_specs(".{}").precision_ref.val.index == 11, "");
  static_assert(parse_dynamic_specs(".{42}").precision_ref.val.index == 42, "");
  static_assert(parse_dynamic_specs("d").type == 'd', "");
}

template <size_t N>
constexpr test_format_specs_handler check_specs(const char (&s)[N]) {
  fmt::detail::specs_checker<test_format_specs_handler> checker(
      test_format_specs_handler(), fmt::detail::type::double_type);
  parse_format_specs(s, s + N, checker);
  return checker;
}

TEST(format_test, constexpr_specs_checker) {
  using handler = test_format_specs_handler;
  static_assert(check_specs("<").alignment == fmt::align::left, "");
  static_assert(check_specs("*^").fill == '*', "");
  static_assert(check_specs("+").sign == fmt::sign::plus, "");
  static_assert(check_specs("-").sign == fmt::sign::minus, "");
  static_assert(check_specs(" ").sign == fmt::sign::space, "");
  static_assert(check_specs("#").res == handler::hash, "");
  static_assert(check_specs("0").res == handler::zero, "");
  static_assert(check_specs("42").width == 42, "");
  static_assert(check_specs("{42}").width_ref.val.index == 42, "");
  static_assert(check_specs(".42").precision == 42, "");
  static_assert(check_specs(".{42}").precision_ref.val.index == 42, "");
  static_assert(check_specs("d").type == 'd', "");
  static_assert(check_specs("{<").res == handler::error, "");
}

struct test_format_string_handler {
  constexpr void on_text(const char*, const char*) {}

  constexpr int on_arg_id() { return 0; }

  template <typename T> constexpr int on_arg_id(T) { return 0; }

  constexpr void on_replacement_field(int, const char*) {}

  constexpr const char* on_format_specs(int, const char* begin, const char*) {
    return begin;
  }

  constexpr void on_error(const char*) { error = true; }

  bool error = false;
};

template <size_t N> constexpr bool parse_string(const char (&s)[N]) {
  auto h = test_format_string_handler();
  fmt::detail::parse_format_string<true>(fmt::string_view(s, N - 1), h);
  return !h.error;
}

TEST(format_test, constexpr_parse_format_string) {
  static_assert(parse_string("foo"), "");
  static_assert(!parse_string("}"), "");
  static_assert(parse_string("{}"), "");
  static_assert(parse_string("{42}"), "");
  static_assert(parse_string("{foo}"), "");
  static_assert(parse_string("{:}"), "");
}
#endif  // FMT_USE_CONSTEXPR

struct enabled_formatter {};
struct disabled_formatter {};
struct disabled_formatter_convertible {
  operator int() const { return 42; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<enabled_formatter> {
  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  auto format(enabled_formatter, format_context& ctx) -> decltype(ctx.out()) {
    return ctx.out();
  }
};
FMT_END_NAMESPACE

TEST(core_test, has_formatter) {
  using fmt::has_formatter;
  using context = fmt::format_context;
  static_assert(has_formatter<enabled_formatter, context>::value, "");
  static_assert(!has_formatter<disabled_formatter, context>::value, "");
  static_assert(!has_formatter<disabled_formatter_convertible, context>::value,
                "");
}

TEST(core_test, is_formattable) {
  static_assert(fmt::is_formattable<enabled_formatter>::value, "");
  static_assert(!fmt::is_formattable<disabled_formatter>::value, "");
  static_assert(fmt::is_formattable<disabled_formatter_convertible>::value, "");
}

TEST(core_test, format) { EXPECT_EQ(fmt::format("{}", 42), "42"); }

TEST(core_test, format_to) {
  std::string s;
  fmt::format_to(std::back_inserter(s), "{}", 42);
  EXPECT_EQ(s, "42");
}

struct convertible_to_int {
  operator int() const { return 42; }
};

struct convertible_to_c_string {
  operator const char*() const { return "foo"; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<convertible_to_int> {
  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  auto format(convertible_to_int, format_context& ctx) -> decltype(ctx.out()) {
    return std::copy_n("foo", 3, ctx.out());
  }
};

template <> struct formatter<convertible_to_c_string> {
  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  auto format(convertible_to_c_string, format_context& ctx)
      -> decltype(ctx.out()) {
    return std::copy_n("bar", 3, ctx.out());
  }
};
FMT_END_NAMESPACE

TEST(core_test, formatter_overrides_implicit_conversion) {
  EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
  EXPECT_EQ(fmt::format("{}", convertible_to_c_string()), "bar");
}

// Test that check is not found by ADL.
template <typename T> void check(T);
TEST(core_test, adl_check) {
  EXPECT_EQ(fmt::format("{}", test_struct()), "test");
}

TEST(core_test, to_string_view_foreign_strings) {
  using namespace test_ns;
  EXPECT_EQ(to_string_view(test_string<char>("42")), "42");
  fmt::detail::type type =
      fmt::detail::mapped_type_constant<test_string<char>,
                                        fmt::format_context>::value;
  EXPECT_EQ(type, fmt::detail::type::string_type);
}

struct implicitly_convertible_to_string {
  operator std::string() const { return "foo"; }
};

struct implicitly_convertible_to_string_view {
  operator fmt::string_view() const { return "foo"; }
};

TEST(core_test, format_implicitly_convertible_to_string_view) {
  EXPECT_EQ("foo", fmt::format("{}", implicitly_convertible_to_string_view()));
}

// std::is_constructible is broken in MSVC until version 2015.
#if !FMT_MSC_VER || FMT_MSC_VER >= 1900
struct explicitly_convertible_to_string_view {
  explicit operator fmt::string_view() const { return "foo"; }
};

TEST(core_test, format_explicitly_convertible_to_string_view) {
  EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_view()));
}

#  ifdef FMT_USE_STRING_VIEW
struct explicitly_convertible_to_std_string_view {
  explicit operator std::string_view() const { return "foo"; }
};

TEST(core_test, format_explicitly_convertible_to_std_string_view) {
  EXPECT_EQ("foo",
            fmt::format("{}", explicitly_convertible_to_std_string_view()));
}
#  endif
#endif

struct convertible_to_long_long {
  operator long long() const { return 1LL << 32; }
};

TEST(format_test, format_convertible_to_long_long) {
  EXPECT_EQ("100000000", fmt::format("{:x}", convertible_to_long_long()));
}

struct disabled_rvalue_conversion {
  operator const char*() const& { return "foo"; }
  operator const char*() & { return "foo"; }
  operator const char*() const&& = delete;
  operator const char*() && = delete;
};

TEST(core_test, disabled_rvalue_conversion) {
  EXPECT_EQ("foo", fmt::format("{}", disabled_rvalue_conversion()));
}

namespace adl_test {
template <typename... T> void make_format_args(const T&...) = delete;

struct string : std::string {};
}  // namespace adl_test

// Test that formatting functions compile when make_format_args is found by ADL.
TEST(core_test, adl) {
  // Only check compilation and don't run the code to avoid polluting the output
  // and since the output is tested elsewhere.
  if (fmt::detail::const_check(true)) return;
  auto s = adl_test::string();
  char buf[10];
  fmt::format("{}", s);
  fmt::format_to(buf, "{}", s);
  fmt::format_to_n(buf, 10, "{}", s);
  fmt::formatted_size("{}", s);
  fmt::print("{}", s);
  fmt::print(stdout, "{}", s);
}


================================================
FILE: examples/libraries/fmt/test/cuda-test/CMakeLists.txt
================================================
# We can find some usecases which follow the guide of CMake which uses
# `enable_language(CUDA)` instead of `find_package(CUDA)` and let the CMake
# built-in functions use NVCC.

# See: https://cmake.org/cmake/help/latest/module/FindCUDA.html#replacement
#
# However, this requires CMake version 3.10 or higher and we can't be sure most
# of the CUDA projects are using those.
#
# This test relies on `find_package(CUDA)` in the parent CMake config.

# These can be updated when NVCC becomes ready for C++ 17 features
# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
set(CMAKE_CUDA_STANDARD 14)
set(CMAKE_CUDA_STANDARD_REQUIRED 14)

# In this test, we assume that the user is going to compile CUDA source code
# with some libraries (fmt in this case).
#
# In addition to that, this test invokes both the C++ host compiler and NVCC
# by providing another (non-CUDA) C++ source code.
if (${CMAKE_VERSION} VERSION_LESS 3.15)
  # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html
  list(APPEND CUDA_NVCC_FLAGS "-std=c++14")
  if (MSVC)
    # This is the solution of pytorch:
    # https://github.com/pytorch/pytorch/pull/7118
    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/std:c++14")
    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/Zc:__cplusplus")
    # for the reason of this -Xcompiler options, see below.
  endif ()
  cuda_add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
  if (MSVC)
    # This part is for (non-CUDA) C++ code. MSVC can define incorrect
    # `__cplusplus` macro. Fix for the issue is to use additional compiler flag. 
    #
    # See Also:
    # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
    # https://github.com/Microsoft/vscode-cpptools/issues/2595
    target_compile_options(fmt-in-cuda-test PRIVATE /Zc:__cplusplus /permissive-)
  endif ()
else()
  # now using a "new" way of handling CUDA
  add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
  set_target_properties(fmt-in-cuda-test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
  if (MSVC)
    # with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but will
    # not set __cplusplus correctly anyway, while nvcc will ignore it.
    # If specified for nvcc on the command line as '-std=c++14' nvcc will emit this
    # message instead:
    # nvcc warning : The -std=c++14 flag is not supported with the configured host
    #                compiler. Flag will be ignored.
    set_property(SOURCE cuda-cpp14.cu APPEND PROPERTY
      COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
    set_property(SOURCE cpp14.cc APPEND PROPERTY
      COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
  endif()
endif()

get_target_property(IN_USE_CUDA_STANDARD fmt-in-cuda-test CUDA_STANDARD)
message(STATUS "cuda_standard:          ${IN_USE_CUDA_STANDARD}")

get_target_property(IN_USE_CUDA_STANDARD_REQUIRED
    fmt-in-cuda-test CUDA_STANDARD_REQUIRED)
message(STATUS "cuda_standard_required: ${IN_USE_CUDA_STANDARD_REQUIRED}")

# We don't use PUBLIC or other keyword for reasons explained in the
# CUDA_LINK_LIBRARIES_KEYWORD section in
# https://cmake.org/cmake/help/latest/module/FindCUDA.html
target_link_libraries(fmt-in-cuda-test fmt::fmt)



================================================
FILE: examples/libraries/fmt/test/cuda-test/cpp14.cc
================================================
#include <fmt/core.h>

// The purpose of this part is to ensure NVCC's host compiler also supports
// the standard version. See 'cuda-cpp14.cu'.
//
// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
static_assert(__cplusplus >= 201402L, "expect C++ 2014 for host compiler");

auto make_message_cpp() -> std::string {
  return fmt::format("host compiler \t: __cplusplus == {}", __cplusplus);
}


================================================
FILE: examples/libraries/fmt/test/cuda-test/cuda-cpp14.cu
================================================
//  Direct NVCC command line example:
//
//  nvcc ./cuda-cpp14.cu -x cu -I"../include" -l"fmtd" -L"../build/Debug" \
//       -std=c++14 -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus

// Ensure that we are using the latest C++ standard for NVCC
// The version is C++14
//
// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#c-cplusplus-language-support
// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
static_assert(__cplusplus >= 201402L, "expect C++ 2014 for nvcc");

#include <fmt/core.h>

#include <cuda.h>
#include <iostream>

extern auto make_message_cpp() -> std::string;
extern auto make_message_cuda() -> std::string;

int main() {
  std::cout << make_message_cuda() << std::endl;
  std::cout << make_message_cpp() << std::endl;
}

auto make_message_cuda() -> std::string {
  return fmt::format("nvcc compiler \t: __cplusplus == {}", __cplusplus);
}


================================================
FILE: examples/libraries/fmt/test/enforce-checks-test.cc
================================================
// Formatting library for C++ - formatting library tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <iterator>
#include <vector>

#include "fmt/chrono.h"
#include "fmt/color.h"
#include "fmt/format.h"
#include "fmt/ostream.h"
#include "fmt/ranges.h"
#include "fmt/xchar.h"

// Exercise the API to verify that everything we expect to can compile.
void test_format_api() {
  fmt::format(FMT_STRING("{}"), 42);
  fmt::format(FMT_STRING(L"{}"), 42);
  fmt::format(FMT_STRING("noop"));

  fmt::to_string(42);
  fmt::to_wstring(42);

  std::vector<char> out;
  fmt::format_to(std::back_inserter(out), FMT_STRING("{}"), 42);

  char buffer[4];
  fmt::format_to_n(buffer, 3, FMT_STRING("{}"), 12345);

  wchar_t wbuffer[4];
  fmt::format_to_n(wbuffer, 3, FMT_STRING(L"{}"), 12345);
}

void test_chrono() {
  fmt::format(FMT_STRING("{}"), std::chrono::seconds(42));
  fmt::format(FMT_STRING(L"{}"), std::chrono::seconds(42));
}

void test_text_style() {
  fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)");
  fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)");

  fmt::text_style ts = fg(fmt::rgb(255, 20, 30));
  std::string out;
  fmt::format_to(std::back_inserter(out), ts,
                 FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3);
}

void test_range() {
  std::vector<char> hello = {'h', 'e', 'l', 'l', 'o'};
  fmt::format(FMT_STRING("{}"), hello);
}

int main() {
  test_format_api();
  test_chrono();
  test_text_style();
  test_range();
}


================================================
FILE: examples/libraries/fmt/test/find-package-test/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1...3.18)

project(fmt-test)

find_package(FMT REQUIRED)

add_executable(library-test main.cc)
target_link_libraries(library-test fmt::fmt)
target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
target_include_directories(library-test PUBLIC SYSTEM .)

if (TARGET fmt::fmt-header-only)
  add_executable(header-only-test main.cc)
  target_link_libraries(header-only-test fmt::fmt-header-only)
  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
  target_include_directories(header-only-test PUBLIC SYSTEM .)
endif ()


================================================
FILE: examples/libraries/fmt/test/find-package-test/main.cc
================================================
#include "fmt/format.h"

int main(int argc, char** argv) {
  for(int i = 0; i < argc; ++i)
    fmt::print("{}: {}\n", i, argv[i]);
}


================================================
FILE: examples/libraries/fmt/test/format
================================================
// Formatting library for C++ - the standard API implementation
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_FORMAT_
#define FMT_FORMAT_

#include <algorithm>
#include <cassert>
#include <variant>
#include "fmt/format.h"

// This implementation verifies the correctness of the standard API proposed in
// P0645 Text Formatting and is optimized for copy-pasting from the paper, not
// for efficiency or readability. An efficient implementation should not use
// std::variant and should store packed argument type tags separately from
// values in basic_format_args for small number of arguments.

namespace std {
template<class T>
constexpr bool Integral = is_integral_v<T>;

template <class O>
  using iter_difference_t = ptrdiff_t;
}

// https://fmt.dev/Text%20Formatting.html#format.syn
namespace std {
  // [format.error], class format_error
  class format_error;

  // [format.formatter], formatter
  template<class charT> class basic_format_parse_context;
  using format_parse_context = basic_format_parse_context<char>;
  using wformat_parse_context = basic_format_parse_context<wchar_t>;
  
  template<class Out, class charT> class basic_format_context;
  using format_context = basic_format_context<
    /* unspecified */ fmt::detail::buffer_appender<char>, char>;
  using wformat_context = basic_format_context<
    /* unspecified */ fmt::detail::buffer_appender<wchar_t>, wchar_t>;

  template<class T, class charT = char> struct formatter {
    formatter() = delete;
  };
  
  // [format.arguments], arguments
  template<class Context> class basic_format_arg;

  template<class Visitor, class Context>
    /* see below */ auto visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);

  template<class Context, class... Args> struct format_arg_store; // exposition only

  template<class Context> class basic_format_args;
  using format_args = basic_format_args<format_context>;
  using wformat_args = basic_format_args<wformat_context>;

  template<class Out, class charT>
    using format_args_t = basic_format_args<basic_format_context<Out, charT>>;

  template<class Context = format_context, class... Args>
    format_arg_store<Context, Args...>
      make_format_args(const Args&... args);
  template<class... Args>
    format_arg_store<wformat_context, Args...>
      make_wformat_args(const Args&... args);

  // [format.functions], formatting functions
  template<class... Args>
    string format(string_view fmt, const Args&... args);
  template<class... Args>
    wstring format(wstring_view fmt, const Args&... args);

  string vformat(string_view fmt, format_args args);
  wstring vformat(wstring_view fmt, wformat_args args);

  template<class Out, class... Args>
    Out format_to(Out out, string_view fmt, const Args&... args);
  template<class Out, class... Args>
    Out format_to(Out out, wstring_view fmt, const Args&... args);

  template<class Out>
    Out vformat_to(Out out, string_view fmt, format_args_t<fmt::type_identity_t<Out>, char> args);
  template<class Out>
    Out vformat_to(Out out, wstring_view fmt, format_args_t<fmt::type_identity_t<Out>, wchar_t> args);

  template<class Out>
    struct format_to_n_result {
      Out out;
      iter_difference_t<Out> size;
    };
  
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        string_view fmt, const Args&... args);
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        wstring_view fmt, const Args&... args);

  template<class... Args>
    size_t formatted_size(string_view fmt, const Args&... args);
  template<class... Args>
    size_t formatted_size(wstring_view fmt, const Args&... args);
}

// https://fmt.dev/Text%20Formatting.html#format.error
namespace std {
  class format_error : public runtime_error {
  public:
    explicit format_error(const string& what_arg) : runtime_error(what_arg) {}
    explicit format_error(const char* what_arg) : runtime_error(what_arg) {}
  };
}

namespace std {
namespace detail {
struct error_handler {
  // This function is intentionally not constexpr to give a compile-time error.
  void on_error(const char* message) {
    throw std::format_error(message);
  }
};
}
}

// https://fmt.dev/Text%20Formatting.html#format.parse_context
namespace std {
  template<class charT>
  class basic_format_parse_context {
  public:
    using char_type = charT;
    using const_iterator = typename basic_string_view<charT>::const_iterator;
    using iterator = const_iterator;

  private:
    iterator begin_;                              // exposition only
    iterator end_;                                // exposition only
    enum indexing { unknown, manual, automatic }; // exposition only
    indexing indexing_;                           // exposition only
    size_t next_arg_id_;                          // exposition only
    size_t num_args_;                             // exposition only

  public:
    explicit constexpr basic_format_parse_context(basic_string_view<charT> fmt,
                                                  size_t num_args = 0) noexcept;
    basic_format_parse_context(const basic_format_parse_context&) = delete;
    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;

    constexpr const_iterator begin() const noexcept;
    constexpr const_iterator end() const noexcept;
    constexpr void advance_to(const_iterator it);

    constexpr size_t next_arg_id();
    constexpr void check_arg_id(size_t id);

    // Implementation detail:
    constexpr void check_arg_id(fmt::string_view) {}
    detail::error_handler error_handler() const { return {}; }
    void on_error(const char* msg) { error_handler().on_error(msg); }
  };
}

namespace std {
template<class charT>
/* explicit */ constexpr basic_format_parse_context<charT>::
                   basic_format_parse_context(basic_string_view<charT> fmt,
                                              size_t num_args) noexcept
: begin_(fmt.begin()), end_(fmt.end()), indexing_(unknown), next_arg_id_(0), num_args_(num_args) {}

template<class charT>
constexpr typename basic_format_parse_context<charT>::const_iterator basic_format_parse_context<charT>::begin() const noexcept { return begin_; }

template<class charT>
constexpr typename basic_format_parse_context<charT>::const_iterator basic_format_parse_context<charT>::end() const noexcept { return end_; }

template<class charT>
constexpr void basic_format_parse_context<charT>::advance_to(typename basic_format_parse_context<charT>::iterator it) { begin_ = it; }

template<class charT>
constexpr size_t basic_format_parse_context<charT>::next_arg_id() {
  if (indexing_ == manual)
    throw format_error("manual to automatic indexing");
  if (indexing_ == unknown)
    indexing_ = automatic;
  return next_arg_id_++;
}

template<class charT>
constexpr void basic_format_parse_context<charT>::check_arg_id(size_t id) {
  // clang doesn't support __builtin_is_constant_evaluated yet
  //if (!(!__builtin_is_constant_evaluated() || id < num_args_))
  //  throw format_error(invalid index is out of range");
  if (indexing_ == automatic)
    throw format_error("automatic to manual indexing");
  if (indexing_ == unknown)
    indexing_ = manual;
}
}

// https://fmt.dev/Text%20Formatting.html#format.context
namespace std {
  template<class Out, class charT>
  class basic_format_context {
    basic_format_args<basic_format_context> args_; // exposition only
    Out out_;                                      // exposition only

  public:
    using iterator = Out;
    using char_type = charT;
    template<class T> using formatter_type = formatter<T, charT>;

    basic_format_arg<basic_format_context> arg(size_t id) const;

    iterator out();
    void advance_to(iterator it);

    // Implementation details:
    using format_arg = basic_format_arg<basic_format_context>;
    basic_format_context(Out out, basic_format_args<basic_format_context> args, fmt::detail::locale_ref)
    : args_(args), out_(out) {}
    detail::error_handler error_handler() const { return {}; }
    basic_format_arg<basic_format_context> arg(fmt::basic_string_view<charT>) const {
      return {}; // unused: named arguments are not supported yet
    }
    void on_error(const char* msg) { error_handler().on_error(msg); }
  };
}

namespace std {
template<class O, class charT>
basic_format_arg<basic_format_context<O, charT>> basic_format_context<O, charT>::arg(size_t id) const { return args_.get(id); }

template<class O, class charT>
typename basic_format_context<O, charT>::iterator basic_format_context<O, charT>::out() { return out_; }

template<class O, class charT>
void basic_format_context<O, charT>::advance_to(typename basic_format_context<O, charT>::iterator it) { out_ = it; }
}

namespace std {
namespace detail {
template <typename T>
constexpr bool is_standard_integer_v =
    std::is_same_v<T, signed char> ||
    std::is_same_v<T, short int> ||
    std::is_same_v<T, int> ||
    std::is_same_v<T, long int> ||
    std::is_same_v<T, long long int>;

template <typename T>
constexpr bool is_standard_unsigned_integer_v =
    std::is_same_v<T, unsigned char> ||
    std::is_same_v<T, unsigned short int> ||
    std::is_same_v<T, unsigned int> ||
    std::is_same_v<T, unsigned long int> ||
    std::is_same_v<T, unsigned long long int>;

template <typename T, typename Char> struct formatter;
}
}

// https://fmt.dev/Text%20Formatting.html#format.arg
namespace std {
  template<class Context>
  class basic_format_arg {
  public:
    class handle;

  private:
    using char_type = typename Context::char_type;                       // exposition only

    variant<monostate, bool, char_type,
            int, unsigned int, long long int, unsigned long long int,
            double, long double,
            const char_type*, basic_string_view<char_type>,
            const void*, handle> value;                                  // exposition only

    template<typename T,
      typename = enable_if_t<
        std::is_same_v<T, bool> ||
        std::is_same_v<T, char_type> ||
        (std::is_same_v<T, char> && std::is_same_v<char_type, wchar_t>) ||
        detail::is_standard_integer_v<T> ||
        detail::is_standard_unsigned_integer_v<T> ||
        sizeof(typename Context::template formatter_type<T>().format(declval<const T&>(), declval<Context&>())) != 0
    >> explicit basic_format_arg(const T& v) noexcept; // exposition only
    explicit basic_format_arg(float n) noexcept;                         // exposition only
    explicit basic_format_arg(double n) noexcept;                        // exposition only
    explicit basic_format_arg(long double n) noexcept;                   // exposition only
    explicit basic_format_arg(const char_type* s);                       // exposition only

    template<class traits>
      explicit basic_format_arg(
        basic_string_view<char_type, traits> s) noexcept;                // exposition only

    template<class traits, class Allocator>
      explicit basic_format_arg(
        const basic_string<char_type, traits, Allocator>& s) noexcept;   // exposition only

    explicit basic_format_arg(nullptr_t) noexcept;                       // exposition only

    template<class T, typename = enable_if_t<is_void_v<T>>>
      explicit basic_format_arg(const T* p) noexcept;                    // exposition only

    // Fails due to a bug in clang
    //template<class Visitor, class Ctx>
    //  friend auto visit_format_arg(Visitor&& vis,
    //                                    basic_format_arg<Ctx> arg);           // exposition only

    friend auto get_value(basic_format_arg arg) {
      return arg.value;
    }

    template <typename T, typename Char> friend struct detail::formatter;

    template<class Ctx, class... Args>
      friend format_arg_store<Ctx, Args...>
        make_format_args(const Args&... args);                           // exposition only

  public:
    basic_format_arg() noexcept;

    explicit operator bool() const noexcept;
  };
}

namespace std {
template<class Context>
basic_format_arg<Context>::basic_format_arg() noexcept {}

template<class Context>
template<class T, typename> /* explicit */ basic_format_arg<Context>::basic_format_arg(const T& v) noexcept {
  if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, char_type>)
    value = v;
  else if constexpr (std::is_same_v<T, char> && std::is_same_v<char_type, wchar_t>)
    value = static_cast<wchar_t>(v);
  else if constexpr (detail::is_standard_integer_v<T> && sizeof(T) <= sizeof(int))
    value = static_cast<int>(v);
  else if constexpr (detail::is_standard_unsigned_integer_v<T> && sizeof(T) <= sizeof(unsigned))
    value = static_cast<unsigned>(v);
  else if constexpr (detail::is_standard_integer_v<T>)
    value = static_cast<long long int>(v);
  else if constexpr (detail::is_standard_unsigned_integer_v<T>)
    value = static_cast<unsigned long long int>(v);
  else if constexpr (sizeof(typename Context::template formatter_type<T>().format(declval<const T&>(), declval<Context&>())) != 0)
    value = handle(v);
}

template<class Context>
/* explicit */ basic_format_arg<Context>::basic_format_arg(float n) noexcept
  : value(static_cast<double>(n)) {}

template<class Context>
/* explicit */ basic_format_arg<Context>::basic_format_arg(double n) noexcept
  : value(n) {}

template<class Context>
/* explicit */ basic_format_arg<Context>::basic_format_arg(long double n) noexcept
  : value(n) {}

template<class Context>
/* explicit */ basic_format_arg<Context>::basic_format_arg(const typename basic_format_arg<Context>::char_type* s)
  : value(s) {
  assert(s != nullptr);
}

template<class Context>
template<class traits>
/* explicit */ basic_format_arg<Context>::basic_format_arg(basic_string_view<char_type, traits> s) noexcept
  : value(s) {}

template<class Context>
template<class traits, class Allocator>
/* explicit */ basic_format_arg<Context>::basic_format_arg(
    const basic_string<char_type, traits, Allocator>& s) noexcept
  : value(basic_string_view<char_type>(s.data(), s.size())) {}


template<class Context>
/* explicit */ basic_format_arg<Context>::basic_format_arg(nullptr_t) noexcept
  : value(static_cast<const void*>(nullptr)) {}

template<class Context>
template<class T, typename> /* explicit */ basic_format_arg<Context>::basic_format_arg(const T* p) noexcept
  : value(p) {}

template<class Context>
/* explicit */ basic_format_arg<Context>::operator bool() const noexcept {
    return !holds_alternative<monostate>(value);
}
}

namespace std {
  template<class Context>
  class basic_format_arg<Context>::handle {
    const void* ptr_;                                         // exposition only
    void (*format_)(basic_format_parse_context<char_type>&,
                    Context&, const void*);                   // exposition only

    template<class T> explicit handle(const T& val) noexcept; // exposition only

    friend class basic_format_arg<Context>;                   // exposition only

  public:
    void format(basic_format_parse_context<char_type>&, Context& ctx) const;
  };
}

namespace std {
template<class Context>
template<class T> /* explicit */ basic_format_arg<Context>::handle::handle(const T& val) noexcept
  : ptr_(&val), format_([](basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx, const void* ptr) {
    typename Context::template formatter_type<T> f;
    parse_ctx.advance_to(f.parse(parse_ctx));
    format_ctx.advance_to(f.format(*static_cast<const T*>(ptr), format_ctx));
  }) {}

template<class Context>
void basic_format_arg<Context>::handle::format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx) const {
  format_(parse_ctx, format_ctx, ptr_);
}

// https://fmt.dev/Text%20Formatting.html#format.visit
template<class Visitor, class Context>
  auto visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg) {
    return visit(vis, get_value(arg));
  }
}

// https://fmt.dev/Text%20Formatting.html#format.store
namespace std {
  template<class Context, class... Args>
  struct format_arg_store { // exposition only
    array<basic_format_arg<Context>, sizeof...(Args)> args;
  };
}

// https://fmt.dev/Text%20Formatting.html#format.basic_args
namespace std {
  template<class Context>
  class basic_format_args {
    size_t size_;                           // exposition only
    const basic_format_arg<Context>* data_; // exposition only

  public:
    basic_format_args() noexcept;

    template<class... Args>
      basic_format_args(const format_arg_store<Context, Args...>& store) noexcept;

    basic_format_arg<Context> get(size_t i) const noexcept;
  };
}

namespace std {

template<class Context>
basic_format_args<Context>::basic_format_args() noexcept : size_(0) {}

template<class Context>
template<class... Args>
  basic_format_args<Context>::basic_format_args(const format_arg_store<Context, Args...>& store) noexcept
  : size_(sizeof...(Args)), data_(store.args.data()) {}

template<class Context>
basic_format_arg<Context> basic_format_args<Context>::get(size_t i) const noexcept {
  return i < size_ ? data_[i] : basic_format_arg<Context>();
}
}

namespace std {
// https://fmt.dev/Text%20Formatting.html#format.make_args
template<class Context /*= format_context*/, class... Args>
  format_arg_store<Context, Args...> make_format_args(const Args&... args) {
    return {basic_format_arg<Context>(args)...};
  }

// https://fmt.dev/Text%20Formatting.html#format.make_wargs
template<class... Args>
  format_arg_store<wformat_context, Args...> make_wformat_args(const Args&... args) {
    return make_format_args<wformat_context>(args...);
  }
}

namespace std {
namespace detail {

template <typename OutputIt, typename Char>
class arg_formatter
    : public fmt::detail::arg_formatter_base<OutputIt, Char, error_handler> {
 private:
  using char_type = Char;
  using base = fmt::detail::arg_formatter_base<OutputIt, Char, error_handler>;
  using format_context = std::basic_format_context<OutputIt, Char>;
  using parse_context = basic_format_parse_context<Char>;

  parse_context* parse_ctx_;
  format_context& ctx_;

 public:
  using iterator = OutputIt;
  using format_specs = typename base::format_specs;

  /**
    \rst
    Constructs an argument formatter object.
    *ctx* is a reference to the formatting context,
    *spec* contains format specifier information for standard argument types.
    \endrst
   */
  arg_formatter(format_context& ctx, parse_context* parse_ctx = nullptr, fmt::format_specs* spec = nullptr)
      : base(ctx.out(), spec, {}), parse_ctx_(parse_ctx), ctx_(ctx) {}

  using base::operator();

  /** Formats an argument of a user-defined type. */
  iterator operator()(typename std::basic_format_arg<format_context>::handle handle) {
    handle.format(*parse_ctx_, ctx_);
    return this->out();
  }

  iterator operator()(monostate) {
    throw format_error("");
  }
};

template <typename Context>
inline fmt::detail::type get_type(basic_format_arg<Context> arg) {
  return visit_format_arg([&] (auto val) {
    using char_type = typename Context::char_type;
    using T = decltype(val);
    if (std::is_same_v<T, monostate>)
      return fmt::detail::type::none_type;
    if (std::is_same_v<T, bool>)
      return fmt::detail::type::bool_type;
    if (std::is_same_v<T, char_type>)
      return fmt::detail::type::char_type;
    if (std::is_same_v<T, int>)
      return fmt::detail::type::int_type;
    if (std::is_same_v<T, unsigned int>)
      return fmt::detail::type::uint_type;
    if (std::is_same_v<T, long long int>)
      return fmt::detail::type::long_long_type;
    if (std::is_same_v<T, unsigned long long int>)
      return fmt::detail::type::ulong_long_type;
    if (std::is_same_v<T, double>)
      return fmt::detail::type::double_type;
    if (std::is_same_v<T, long double>)
      return fmt::detail::type::long_double_type;
    if (std::is_same_v<T, const char_type*>)
      return fmt::detail::type::cstring_type;
    if (std::is_same_v<T, basic_string_view<char_type>>)
      return fmt::detail::type::string_type;
    if (std::is_same_v<T, const void*>)
      return fmt::detail::type::pointer_type;
    assert(get_value(arg).index() == 12);
    return fmt::detail::type::custom_type;
  }, arg);
}

template <typename Context>
class custom_formatter {
 private:
  using parse_context = basic_format_parse_context<typename Context::char_type>;
  parse_context& parse_ctx_;
  Context& format_ctx_;

 public:
  custom_formatter(parse_context& parse_ctx, Context& ctx) : parse_ctx_(parse_ctx), format_ctx_(ctx) {}

  bool operator()(typename basic_format_arg<Context>::handle h) const {
    h.format(parse_ctx_, format_ctx_);
    return true;
  }

  template <typename T> bool operator()(T) const { return false; }
};

template <typename ArgFormatter, typename Char, typename Context>
struct format_handler : detail::error_handler {
  using iterator = typename ArgFormatter::iterator;

  format_handler(iterator out, basic_string_view<Char> str,
                 basic_format_args<Context> format_args,
                 fmt::detail::locale_ref loc)
      : parse_ctx(str), context(out, format_args, loc) {}

  void on_text(const Char* begin, const Char* end) {
    auto size = fmt::detail::to_unsigned(end - begin);
    auto out = context.out();
    auto&& it = fmt::detail::reserve(out, size);
    it = std::copy_n(begin, size, it);
    context.advance_to(out);
  }

  int on_arg_id() { return parse_ctx.next_arg_id(); }
  int on_arg_id(unsigned id) { return parse_ctx.check_arg_id(id), id; }
  int on_arg_id(fmt::basic_string_view<Char>) { return 0; }

  void on_replacement_field(int id, const Char* p) {
    auto arg = context.arg(id);
    parse_ctx.advance_to(parse_ctx.begin() + (p  - &*parse_ctx.begin()));
    custom_formatter<Context> f(parse_ctx, context);
    if (!visit_format_arg(f, arg))
      context.advance_to(visit_format_arg(ArgFormatter(context, &parse_ctx), arg));
  }

  const Char* on_format_specs(int id, const Char* begin, const Char* end) {
    auto arg = context.arg(id);
    parse_ctx.advance_to(parse_ctx.begin() + (begin - &*parse_ctx.begin()));
    custom_formatter<Context> f(parse_ctx, context);
    if (visit_format_arg(f, arg)) return &*parse_ctx.begin();
    fmt::basic_format_specs<Char> specs;
    using fmt::detail::specs_handler;
    using parse_context = basic_format_parse_context<Char>;
    fmt::detail::specs_checker<specs_handler<parse_context, Context>> handler(
        specs_handler<parse_context, Context>(specs, parse_ctx, context), get_type(arg));
    begin = parse_format_specs(begin, end, handler);
    if (begin == end || *begin != '}') on_error("missing '}' in format string");
    parse_ctx.advance_to(parse_ctx.begin() + (begin - &*parse_ctx.begin()));
    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_ctx, &specs), arg));
    return begin;
  }

  basic_format_parse_context<Char> parse_ctx;
  Context context;
};

template <typename T, typename Char>
struct formatter {
  // Parses format specifiers stopping either at the end of the range or at the
  // terminating '}'.
  template <typename ParseContext>
  FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
    namespace detail = fmt::detail;
    typedef detail::dynamic_specs_handler<ParseContext> handler_type;
    auto type = detail::mapped_type_constant<T, fmt::buffer_context<Char>>::value;
    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                  type);
    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
    auto type_spec = specs_.type;
    auto eh = ctx.error_handler();
    switch (type) {
    case detail::type::none_type:
      FMT_ASSERT(false, "invalid argument type");
      break;
    case detail::type::int_type:
    case detail::type::uint_type:
    case detail::type::long_long_type:
    case detail::type::ulong_long_type:
    case detail::type::bool_type:
      handle_int_type_spec(type_spec,
                           detail::int_type_checker<decltype(eh)>(eh));
      break;
    case detail::type::char_type:
      handle_char_specs(
          &specs_, detail::char_specs_checker<decltype(eh)>(type_spec, eh));
      break;
    case detail::type::double_type:
    case detail::type::long_double_type:
      detail::parse_float_type_spec(specs_, eh);
      break;
    case detail::type::cstring_type:
      detail::handle_cstring_type_spec(
          type_spec, detail::cstring_type_checker<decltype(eh)>(eh));
      break;
    case detail::type::string_type:
      detail::check_string_type_spec(type_spec, eh);
      break;
    case detail::type::pointer_type:
      detail::check_pointer_type_spec(type_spec, eh);
      break;
    case detail::type::custom_type:
      // Custom format specifiers should be checked in parse functions of
      // formatter specializations.
      break;
    }
    return it;
  }

  template <typename FormatContext>
  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
    fmt::detail::handle_dynamic_spec<fmt::detail::width_checker>(
        specs_.width, specs_.width_ref, ctx);
    fmt::detail::handle_dynamic_spec<fmt::detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    using af = arg_formatter<typename FormatContext::iterator,
                             typename FormatContext::char_type>;
    return visit_format_arg(af(ctx, nullptr, &specs_),
                            basic_format_arg<FormatContext>(val));
  }

 private:
  fmt::detail::dynamic_format_specs<Char> specs_;
};
}  // namespace detail

// https://fmt.dev/Text%20Formatting.html#format.functions
template<class... Args>
  string format(string_view fmt, const Args&... args) {
    return vformat(fmt, make_format_args(args...));
  }

template<class... Args>
  wstring format(wstring_view fmt, const Args&... args) {
    return vformat(fmt, make_wformat_args(args...));
  }

string vformat(string_view fmt, format_args args) {
  fmt::memory_buffer mbuf;
  fmt::detail::buffer<char>& buf = mbuf;
  using af = detail::arg_formatter<fmt::format_context::iterator, char>;
  detail::format_handler<af, char, format_context>
    h(fmt::detail::buffer_appender<char>(buf), fmt, args, {});
  fmt::detail::parse_format_string<false>(fmt::to_string_view(fmt), h);
  return to_string(mbuf);
}

wstring vformat(wstring_view fmt, wformat_args args);

template<class Out, class... Args>
  Out format_to(Out out, string_view fmt, const Args&... args) {
    using context = basic_format_context<Out, decltype(fmt)::value_type>;
    return vformat_to(out, fmt, make_format_args<context>(args...));
  }

template<class Out, class... Args>
  Out format_to(Out out, wstring_view fmt, const Args&... args) {
    using context = basic_format_context<Out, decltype(fmt)::value_type>;
    return vformat_to(out, fmt, make_format_args<context>(args...));
  }

template<class Out>
  Out vformat_to(Out out, string_view fmt, format_args_t<fmt::type_identity_t<Out>, char> args) {
    using af = detail::arg_formatter<Out, char>;
    detail::format_handler<af, char, basic_format_context<Out, char>>
      h(out, fmt, args, {});
    fmt::detail::parse_format_string<false>(fmt::to_string_view(fmt), h);
    return h.context.out();
  }

template<class Out>
  Out vformat_to(Out out, wstring_view fmt, format_args_t<fmt::type_identity_t<Out>, wchar_t> args);

template<class Out, class... Args>
  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                      string_view fmt, const Args&... args);
template<class Out, class... Args>
  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                      wstring_view fmt, const Args&... args);

template<class... Args>
  size_t formatted_size(string_view fmt, const Args&... args);
template<class... Args>
  size_t formatted_size(wstring_view fmt, const Args&... args);

#define charT char

template<> struct formatter<charT, charT> : detail::formatter<charT, charT> {};

template<> struct formatter<char, wchar_t>;

template<> struct formatter<charT*, charT> : detail::formatter<const charT*, charT> {};

template<> struct formatter<const charT*, charT> : detail::formatter<const charT*, charT> {};

template<size_t N> struct formatter<const charT[N], charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template<class traits, class Allocator>
  struct formatter<basic_string<charT, traits, Allocator>, charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template<class traits>
  struct formatter<basic_string_view<charT, traits>, charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template <> struct formatter<nullptr_t, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<void*, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<const void*, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<bool, charT> : detail::formatter<bool, charT> {};

template <> struct formatter<signed char, charT> : detail::formatter<int, charT> {};
template <> struct formatter<short, charT> : detail::formatter<int, charT> {};
template <> struct formatter<int, charT> : detail::formatter<int, charT> {};
template <> struct formatter<long, charT>
      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), int, long long>, charT> {};
template <> struct formatter<long long, charT> : detail::formatter<long long, charT> {};
template <> struct formatter<unsigned char, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned short, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned int, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned long, charT>
      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), unsigned, unsigned long long>, charT> {};
template <> struct formatter<unsigned long long, charT> : detail::formatter<unsigned long long, charT> {};

template <> struct formatter<float, charT> : detail::formatter<double, charT> {};
template <> struct formatter<double, charT> : detail::formatter<double, charT> {};
template <> struct formatter<long double, charT> : detail::formatter<long double, charT> {};

#undef charT

#define charT wchar_t

template<> struct formatter<charT, charT> : detail::formatter<charT, charT> {};

template<> struct formatter<char, wchar_t> : detail::formatter<charT, charT> {};

template<> struct formatter<charT*, charT> : detail::formatter<const charT*, charT> {};

template<> struct formatter<const charT*, charT> : detail::formatter<const charT*, charT> {};

template<size_t N> struct formatter<const charT[N], charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template<class traits, class Allocator>
  struct formatter<std::basic_string<charT, traits, Allocator>, charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template<class traits>
  struct formatter<std::basic_string_view<charT, traits>, charT>
      : detail::formatter<std::basic_string_view<charT>, charT> {};

template <> struct formatter<nullptr_t, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<void*, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<const void*, charT> : detail::formatter<const void*, charT> {};
template <> struct formatter<bool, charT> : detail::formatter<bool, charT> {};

template <> struct formatter<signed char, charT> : detail::formatter<int, charT> {};
template <> struct formatter<short, charT> : detail::formatter<int, charT> {};
template <> struct formatter<int, charT> : detail::formatter<int, charT> {};
template <> struct formatter<long, charT>
      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), int, long long>, charT> {};
template <> struct formatter<long long, charT> : detail::formatter<long long, charT> {};
template <> struct formatter<unsigned char, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned short, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned int, charT> : detail::formatter<unsigned int, charT> {};
template <> struct formatter<unsigned long, charT>
      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), unsigned, unsigned long long>, charT> {};
template <> struct formatter<unsigned long long, charT> : detail::formatter<unsigned long long, charT> {};

template <> struct formatter<float, charT> : detail::formatter<double, charT> {};
template <> struct formatter<double, charT> : detail::formatter<double, charT> {};
template <> struct formatter<long double, charT> : detail::formatter<long double, charT> {};

#undef charT

  template<> struct formatter<const wchar_t, char> {
    formatter() = delete;
  };
}

#endif  // FMT_FORMAT_


================================================
FILE: examples/libraries/fmt/test/format-impl-test.cc
================================================
// Formatting library for C++ - formatting library implementation tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <algorithm>
#include <cstring>

// clang-format off
#include "test-assert.h"
// clang-format on

#include "fmt/format.h"
#include "gmock/gmock.h"
#include "util.h"

using fmt::detail::bigint;
using fmt::detail::fp;
using fmt::detail::max_value;

static_assert(!std::is_copy_constructible<bigint>::value, "");
static_assert(!std::is_copy_assignable<bigint>::value, "");

TEST(bigint_test, construct) {
  EXPECT_EQ("", fmt::format("{}", bigint()));
  EXPECT_EQ("42", fmt::format("{}", bigint(0x42)));
  EXPECT_EQ("123456789abcedf0", fmt::format("{}", bigint(0x123456789abcedf0)));
}

TEST(bigint_test, compare) {
  bigint n1(42);
  bigint n2(42);
  EXPECT_EQ(compare(n1, n2), 0);
  n2 <<= 32;
  EXPECT_LT(compare(n1, n2), 0);
  bigint n3(43);
  EXPECT_LT(compare(n1, n3), 0);
  EXPECT_GT(compare(n3, n1), 0);
  bigint n4(42 * 0x100000001);
  EXPECT_LT(compare(n2, n4), 0);
  EXPECT_GT(compare(n4, n2), 0);
}

TEST(bigint_test, add_compare) {
  EXPECT_LT(
      add_compare(bigint(0xffffffff), bigint(0xffffffff), bigint(1) <<= 64), 0);
  EXPECT_LT(add_compare(bigint(1) <<= 32, bigint(1), bigint(1) <<= 96), 0);
  EXPECT_GT(add_compare(bigint(1) <<= 32, bigint(0), bigint(0xffffffff)), 0);
  EXPECT_GT(add_compare(bigint(0), bigint(1) <<= 32, bigint(0xffffffff)), 0);
  EXPECT_GT(add_compare(bigint(42), bigint(1), bigint(42)), 0);
  EXPECT_GT(add_compare(bigint(0xffffffff), bigint(1), bigint(0xffffffff)), 0);
  EXPECT_LT(add_compare(bigint(10), bigint(10), bigint(22)), 0);
  EXPECT_LT(add_compare(bigint(0x100000010), bigint(0x100000010),
                        bigint(0x300000010)),
            0);
  EXPECT_GT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
                        bigint(0x300000000)),
            0);
  EXPECT_EQ(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
                        bigint(0x300000001)),
            0);
  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
                        bigint(0x300000002)),
            0);
  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
                        bigint(0x300000003)),
            0);
}

TEST(bigint_test, shift_left) {
  bigint n(0x42);
  n <<= 0;
  EXPECT_EQ("42", fmt::format("{}", n));
  n <<= 1;
  EXPECT_EQ("84", fmt::format("{}", n));
  n <<= 25;
  EXPECT_EQ("108000000", fmt::format("{}", n));
}

TEST(bigint_test, multiply) {
  bigint n(0x42);
  EXPECT_THROW(n *= 0, assertion_failure);
  n *= 1;
  EXPECT_EQ("42", fmt::format("{}", n));
  n *= 2;
  EXPECT_EQ("84", fmt::format("{}", n));
  n *= 0x12345678;
  EXPECT_EQ("962fc95e0", fmt::format("{}", n));
  bigint bigmax(max_value<uint32_t>());
  bigmax *= max_value<uint32_t>();
  EXPECT_EQ("fffffffe00000001", fmt::format("{}", bigmax));
  bigmax.assign(max_value<uint64_t>());
  bigmax *= max_value<uint64_t>();
  EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", bigmax));
}

TEST(bigint_test, accumulator) {
  fmt::detail::accumulator acc;
  EXPECT_EQ(acc.lower, 0);
  EXPECT_EQ(acc.upper, 0);
  acc.upper = 12;
  acc.lower = 34;
  EXPECT_EQ(static_cast<uint32_t>(acc), 34);
  acc += 56;
  EXPECT_EQ(acc.lower, 90);
  acc += max_value<uint64_t>();
  EXPECT_EQ(acc.upper, 13);
  EXPECT_EQ(acc.lower, 89);
  acc >>= 32;
  EXPECT_EQ(acc.upper, 0);
  EXPECT_EQ(acc.lower, 13 * 0x100000000);
}

TEST(bigint_test, square) {
  bigint n0(0);
  n0.square();
  EXPECT_EQ("0", fmt::format("{}", n0));
  bigint n1(0x100);
  n1.square();
  EXPECT_EQ("10000", fmt::format("{}", n1));
  bigint n2(0xfffffffff);
  n2.square();
  EXPECT_EQ("ffffffffe000000001", fmt::format("{}", n2));
  bigint n3(max_value<uint64_t>());
  n3.square();
  EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", n3));
  bigint n4;
  n4.assign_pow10(10);
  EXPECT_EQ("2540be400", fmt::format("{}", n4));
}

TEST(bigint_test, divmod_assign_zero_divisor) {
  bigint zero(0);
  EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure);
  EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure);
}

TEST(bigint_test, divmod_assign_self) {
  bigint n(100);
  EXPECT_THROW(n.divmod_assign(n), assertion_failure);
}

TEST(bigint_test, divmod_assign_unaligned) {
  // (42 << 340) / pow(10, 100):
  bigint n1(42);
  n1 <<= 340;
  bigint n2;
  n2.assign_pow10(100);
  int result = n1.divmod_assign(n2);
  EXPECT_EQ(result, 9406);
  EXPECT_EQ("10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96",
            fmt::format("{}", n1));
}

TEST(bigint_test, divmod_assign) {
  // 100 / 10:
  bigint n1(100);
  int result = n1.divmod_assign(bigint(10));
  EXPECT_EQ(result, 10);
  EXPECT_EQ("0", fmt::format("{}", n1));
  // pow(10, 100) / (42 << 320):
  n1.assign_pow10(100);
  result = n1.divmod_assign(bigint(42) <<= 320);
  EXPECT_EQ(result, 111);
  EXPECT_EQ("13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96",
            fmt::format("{}", n1));
  // 42 / 100:
  bigint n2(42);
  n1.assign_pow10(2);
  result = n2.divmod_assign(n1);
  EXPECT_EQ(result, 0);
  EXPECT_EQ("2a", fmt::format("{}", n2));
}

template <bool is_iec559> void run_double_tests() {
  fmt::print("warning: double is not IEC559, skipping FP tests\n");
}

template <> void run_double_tests<true>() {
  // Construct from double.
  EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52));
}

TEST(fp_test, double_tests) {
  run_double_tests<std::numeric_limits<double>::is_iec559>();
}

TEST(fp_test, normalize) {
  const auto v = fp(0xbeef, 42);
  auto normalized = normalize(v);
  EXPECT_EQ(0xbeef000000000000, normalized.f);
  EXPECT_EQ(-6, normalized.e);
}

TEST(fp_test, multiply) {
  auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
  EXPECT_EQ(v.f, 123u * 56u);
  EXPECT_EQ(v.e, 4 + 7 + 64);
  v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
  EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
  EXPECT_EQ(v.e, 4 + 8 + 64);
}

TEST(fp_test, get_cached_power) {
  using limits = std::numeric_limits<double>;
  for (auto exp = limits::min_exponent; exp <= limits::max_exponent; ++exp) {
    int dec_exp = 0;
    auto fp = fmt::detail::get_cached_power(exp, dec_exp);
    bigint exact, cache(fp.f);
    if (dec_exp >= 0) {
      exact.assign_pow10(dec_exp);
      if (fp.e <= 0)
        exact <<= -fp.e;
      else
        cache <<= fp.e;
      exact.align(cache);
      cache.align(exact);
      auto exact_str = fmt::format("{}", exact);
      auto cache_str = fmt::format("{}", cache);
      EXPECT_EQ(exact_str.size(), cache_str.size());
      EXPECT_EQ(exact_str.substr(0, 15), cache_str.substr(0, 15));
      int diff = cache_str[15] - exact_str[15];
      if (diff == 1)
        EXPECT_GT(exact_str[16], '8');
      else
        EXPECT_EQ(diff, 0);
    } else {
      cache.assign_pow10(-dec_exp);
      cache *= fp.f + 1;  // Inexact check.
      exact.assign(1);
      exact <<= -fp.e;
      exact.align(cache);
      auto exact_str = fmt::format("{}", exact);
      auto cache_str = fmt::format("{}", cache);
      EXPECT_EQ(exact_str.size(), cache_str.size());
      EXPECT_EQ(exact_str.substr(0, 16), cache_str.substr(0, 16));
    }
  }
}

TEST(fp_test, dragonbox_max_k) {
  using fmt::detail::dragonbox::floor_log10_pow2;
  using float_info = fmt::detail::dragonbox::float_info<float>;
  EXPECT_EQ(fmt::detail::const_check(float_info::max_k),
            float_info::kappa - floor_log10_pow2(float_info::min_exponent -
                                                 float_info::significand_bits));
  using double_info = fmt::detail::dragonbox::float_info<double>;
  EXPECT_EQ(
      fmt::detail::const_check(double_info::max_k),
      double_info::kappa - floor_log10_pow2(double_info::min_exponent -
                                            double_info::significand_bits));
}

TEST(fp_test, get_round_direction) {
  using fmt::detail::get_round_direction;
  using fmt::detail::round_direction;
  EXPECT_EQ(round_direction::down, get_round_direction(100, 50, 0));
  EXPECT_EQ(round_direction::up, get_round_direction(100, 51, 0));
  EXPECT_EQ(round_direction::down, get_round_direction(100, 40, 10));
  EXPECT_EQ(round_direction::up, get_round_direction(100, 60, 10));
  for (size_t i = 41; i < 60; ++i)
    EXPECT_EQ(round_direction::unknown, get_round_direction(100, i, 10));
  uint64_t max = max_value<uint64_t>();
  EXPECT_THROW(get_round_direction(100, 100, 0), assertion_failure);
  EXPECT_THROW(get_round_direction(100, 0, 100), assertion_failure);
  EXPECT_THROW(get_round_direction(100, 0, 50), assertion_failure);
  // Check that remainder + error doesn't overflow.
  EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 2));
  // Check that 2 * (remainder + error) doesn't overflow.
  EXPECT_EQ(round_direction::unknown,
            get_round_direction(max, max / 2 + 1, max / 2));
  // Check that remainder - error doesn't overflow.
  EXPECT_EQ(round_direction::unknown, get_round_direction(100, 40, 41));
  // Check that 2 * (remainder - error) doesn't overflow.
  EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 1));
}

TEST(fp_test, fixed_handler) {
  struct handler : fmt::detail::fixed_handler {
    char buffer[10];
    handler(int prec = 0) : fmt::detail::fixed_handler() {
      buf = buffer;
      precision = prec;
    }
  };
  int exp = 0;
  handler().on_digit('0', 100, 99, 0, exp, false);
  EXPECT_THROW(handler().on_digit('0', 100, 100, 0, exp, false),
               assertion_failure);
  namespace digits = fmt::detail::digits;
  EXPECT_EQ(handler(1).on_digit('0', 100, 10, 10, exp, false), digits::error);
  // Check that divisor - error doesn't overflow.
  EXPECT_EQ(handler(1).on_digit('0', 100, 10, 101, exp, false), digits::error);
  // Check that 2 * error doesn't overflow.
  uint64_t max = max_value<uint64_t>();
  EXPECT_EQ(handler(1).on_digit('0', max, 10, max - 1, exp, false),
            digits::error);
}

TEST(fp_test, grisu_format_compiles_with_on_ieee_double) {
  fmt::memory_buffer buf;
  format_float(0.42, -1, fmt::detail::float_specs(), buf);
}

TEST(format_impl_test, format_error_code) {
  std::string msg = "error 42", sep = ": ";
  {
    fmt::memory_buffer buffer;
    format_to(fmt::appender(buffer), "garbage");
    fmt::detail::format_error_code(buffer, 42, "test");
    EXPECT_EQ("test: " + msg, to_string(buffer));
  }
  {
    fmt::memory_buffer buffer;
    auto prefix =
        std::string(fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
    fmt::detail::format_error_code(buffer, 42, prefix);
    EXPECT_EQ(msg, to_string(buffer));
  }
  int codes[] = {42, -1};
  for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
    // Test maximum buffer size.
    msg = fmt::format("error {}", codes[i]);
    fmt::memory_buffer buffer;
    auto prefix =
        std::string(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
    fmt::detail::format_error_code(buffer, codes[i], prefix);
    EXPECT_EQ(prefix + sep + msg, to_string(buffer));
    size_t size = fmt::inline_buffer_size;
    EXPECT_EQ(size, buffer.size());
    buffer.resize(0);
    // Test with a message that doesn't fit into the buffer.
    prefix += 'x';
    fmt::detail::format_error_code(buffer, codes[i], prefix);
    EXPECT_EQ(msg, to_string(buffer));
  }
}

TEST(format_impl_test, compute_width) {
  EXPECT_EQ(4,
            fmt::detail::compute_width(
                fmt::basic_string_view<fmt::detail::char8_type>(
                    reinterpret_cast<const fmt::detail::char8_type*>("ёжик"))));
}

// Tests fmt::detail::count_digits for integer type Int.
template <typename Int> void test_count_digits() {
  for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::detail::count_digits(i));
  for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) {
    n *= 10;
    EXPECT_EQ(i, fmt::detail::count_digits(n - 1));
    EXPECT_EQ(i + 1, fmt::detail::count_digits(n));
  }
}

TEST(format_impl_test, count_digits) {
  test_count_digits<uint32_t>();
  test_count_digits<uint64_t>();
}

TEST(format_impl_test, write_fallback_uintptr) {
  std::string s;
  fmt::detail::write_ptr<char>(
      std::back_inserter(s),
      fmt::detail::fallback_uintptr(reinterpret_cast<void*>(0xface)), nullptr);
  EXPECT_EQ(s, "0xface");
}

#ifdef _WIN32
#  include <windows.h>
#endif

#ifdef _WIN32
TEST(format_impl_test, write_console_signature) {
  decltype(WriteConsoleW)* p = fmt::detail::WriteConsoleW;
  (void)p;
}
#endif


================================================
FILE: examples/libraries/fmt/test/format-test.cc
================================================
// Formatting library for C++ - formatting library tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

// Check if fmt/format.h compiles with windows.h included before it.
#ifdef _WIN32
#  include <windows.h>
#endif
// clang-format off
#include "fmt/format.h"
// clang-format on

#include <stdint.h>  // uint32_t

#include <climits>      // INT_MAX
#include <cmath>        // std::signbit
#include <cstring>      // std::strlen
#include <iterator>     // std::back_inserter
#include <list>         // std::list
#include <memory>       // std::unique_ptr
#include <type_traits>  // std::is_default_constructible

#include "gtest-extra.h"
#include "mock-allocator.h"
#include "util.h"

using fmt::basic_memory_buffer;
using fmt::format_error;
using fmt::memory_buffer;
using fmt::runtime;
using fmt::string_view;
using fmt::detail::max_value;

using testing::Return;
using testing::StrictMock;

enum { buffer_size = 256 };

struct uint32_pair {
  uint32_t u[2];
};

TEST(util_test, bit_cast) {
  auto s = fmt::detail::bit_cast<uint32_pair>(uint64_t{42});
  EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), 42ull);
  s = fmt::detail::bit_cast<uint32_pair>(~uint64_t{0});
  EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), ~0ull);
}

// Increment a number in a string.
void increment(char* s) {
  for (int i = static_cast<int>(std::strlen(s)) - 1; i >= 0; --i) {
    if (s[i] != '9') {
      ++s[i];
      break;
    }
    s[i] = '0';
  }
}

TEST(util_test, increment) {
  char s[10] = "123";
  increment(s);
  EXPECT_STREQ("124", s);
  s[2] = '8';
  increment(s);
  EXPECT_STREQ("129", s);
  increment(s);
  EXPECT_STREQ("130", s);
  s[1] = s[2] = '9';
  increment(s);
  EXPECT_STREQ("200", s);
}

TEST(util_test, parse_nonnegative_int) {
  auto s = fmt::string_view("10000000000");
  auto begin = s.begin(), end = s.end();
  EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);
  s = "2147483649";
  begin = s.begin();
  end = s.end();
  EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);
}

TEST(util_test, utf8_to_utf16) {
  auto u = fmt::detail::utf8_to_utf16("лошадка");
  EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
  EXPECT_EQ(7, u.size());
  // U+10437 { DESERET SMALL LETTER YEE }
  EXPECT_EQ(L"\xD801\xDC37", fmt::detail::utf8_to_utf16("𐐷").str());
  EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16("\xc3\x28"), std::runtime_error,
                   "invalid utf8");
  EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16(fmt::string_view("л", 1)),
                   std::runtime_error, "invalid utf8");
  EXPECT_EQ(L"123456", fmt::detail::utf8_to_utf16("123456").str());
}

TEST(util_test, utf8_to_utf16_empty_string) {
  auto s = std::string();
  auto u = fmt::detail::utf8_to_utf16(s.c_str());
  EXPECT_EQ(L"", u.str());
  EXPECT_EQ(s.size(), u.size());
}

TEST(util_test, allocator_ref) {
  using test_allocator_ref = allocator_ref<mock_allocator<int>>;
  auto check_forwarding = [](mock_allocator<int>& alloc,
                             test_allocator_ref& ref) {
    int mem;
    // Check if value_type is properly defined.
    allocator_ref<mock_allocator<int>>::value_type* ptr = &mem;
    // Check forwarding.
    EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
    ref.allocate(42);
    EXPECT_CALL(alloc, deallocate(ptr, 42));
    ref.deallocate(ptr, 42);
  };

  StrictMock<mock_allocator<int>> alloc;
  auto ref = test_allocator_ref(&alloc);
  // Check if allocator_ref forwards to the underlying allocator.
  check_forwarding(alloc, ref);
  test_allocator_ref ref2(ref);
  check_forwarding(alloc, ref2);
  test_allocator_ref ref3;
  EXPECT_EQ(nullptr, ref3.get());
  ref3 = ref;
  check_forwarding(alloc, ref3);
}

TEST(util_test, format_system_error) {
  fmt::memory_buffer message;
  fmt::format_system_error(message, EDOM, "test");
  auto ec = std::error_code(EDOM, std::generic_category());
  EXPECT_EQ(to_string(message), std::system_error(ec, "test").what());
  message = fmt::memory_buffer();

  // Check if std::allocator throws on allocating max size_t / 2 chars.
  size_t max_size = max_value<size_t>() / 2;
  bool throws_on_alloc = false;
  try {
    auto alloc = std::allocator<char>();
    alloc.deallocate(alloc.allocate(max_size), max_size);
  } catch (const std::bad_alloc&) {
    throws_on_alloc = true;
  }
  if (!throws_on_alloc) {
    fmt::print("warning: std::allocator allocates {} chars", max_size);
    return;
  }
}

TEST(util_test, system_error) {
  auto test_error = fmt::system_error(EDOM, "test");
  auto ec = std::error_code(EDOM, std::generic_category());
  EXPECT_STREQ(test_error.what(), std::system_error(ec, "test").what());
  EXPECT_EQ(test_error.code(), ec);

  auto error = std::system_error(std::error_code());
  try {
    throw fmt::system_error(EDOM, "test {}", "error");
  } catch (const std::system_error& e) {
    error = e;
  }
  fmt::memory_buffer message;
  fmt::format_system_error(message, EDOM, "test error");
  EXPECT_EQ(error.what(), to_string(message));
  EXPECT_EQ(error.code(), std::error_code(EDOM, std::generic_category()));
}

TEST(util_test, report_system_error) {
  fmt::memory_buffer out;
  fmt::format_system_error(out, EDOM, "test error");
  out.push_back('\n');
  EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
               to_string(out));
}

TEST(memory_buffer_test, ctor) {
  basic_memory_buffer<char, 123> buffer;
  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
  EXPECT_EQ(123u, buffer.capacity());
}

using std_allocator = allocator_ref<std::allocator<char>>;

TEST(memory_buffer_test, move_ctor_inline_buffer) {
  auto check_move_buffer =
      [](const char* str, basic_memory_buffer<char, 5, std_allocator>& buffer) {
        std::allocator<char>* alloc = buffer.get_allocator().get();
        basic_memory_buffer<char, 5, std_allocator> buffer2(std::move(buffer));
        // Move shouldn't destroy the inline content of the first buffer.
        EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
        EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
        EXPECT_EQ(5u, buffer2.capacity());
        // Move should transfer allocator.
        EXPECT_EQ(nullptr, buffer.get_allocator().get());
        EXPECT_EQ(alloc, buffer2.get_allocator().get());
      };

  auto alloc = std::allocator<char>();
  basic_memory_buffer<char, 5, std_allocator> buffer((std_allocator(&alloc)));
  const char test[] = "test";
  buffer.append(string_view(test, 4));
  check_move_buffer("test", buffer);
  // Adding one more character fills the inline buffer, but doesn't cause
  // dynamic allocation.
  buffer.push_back('a');
  check_move_buffer("testa", buffer);
}

TEST(memory_buffer_test, move_ctor_dynamic_buffer) {
  auto alloc = std::allocator<char>();
  basic_memory_buffer<char, 4, std_allocator> buffer((std_allocator(&alloc)));
  const char test[] = "test";
  buffer.append(test, test + 4);
  const char* inline_buffer_ptr = &buffer[0];
  // Adding one more character causes the content to move from the inline to
  // a dynamically allocated buffer.
  buffer.push_back('a');
  basic_memory_buffer<char, 4, std_allocator> buffer2(std::move(buffer));
  // Move should rip the guts of the first buffer.
  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
  EXPECT_EQ("testa", std::string(&buffer2[0], buffer2.size()));
  EXPECT_GT(buffer2.capacity(), 4u);
}

void check_move_assign_buffer(const char* str,
                              basic_memory_buffer<char, 5>& buffer) {
  basic_memory_buffer<char, 5> buffer2;
  buffer2 = std::move(buffer);
  // Move shouldn't destroy the inline content of the first buffer.
  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
  EXPECT_EQ(5u, buffer2.capacity());
}

TEST(memory_buffer_test, move_assignment) {
  basic_memory_buffer<char, 5> buffer;
  const char test[] = "test";
  buffer.append(test, test + 4);
  check_move_assign_buffer("test", buffer);
  // Adding one more character fills the inline buffer, but doesn't cause
  // dynamic allocation.
  buffer.push_back('a');
  check_move_assign_buffer("testa", buffer);
  const char* inline_buffer_ptr = &buffer[0];
  // Adding one more character causes the content to move from the inline to
  // a dynamically allocated buffer.
  buffer.push_back('b');
  basic_memory_buffer<char, 5> buffer2;
  buffer2 = std::move(buffer);
  // Move should rip the guts of the first buffer.
  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
  EXPECT_GT(buffer2.capacity(), 5u);
}

TEST(memory_buffer_test, grow) {
  typedef allocator_ref<mock_allocator<int>> Allocator;
  mock_allocator<int> alloc;
  basic_memory_buffer<int, 10, Allocator> buffer((Allocator(&alloc)));
  buffer.resize(7);
  using fmt::detail::to_unsigned;
  for (int i = 0; i < 7; ++i) buffer[to_unsigned(i)] = i * i;
  EXPECT_EQ(10u, buffer.capacity());
  int mem[20];
  mem[7] = 0xdead;
  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
  buffer.try_reserve(20);
  EXPECT_EQ(20u, buffer.capacity());
  // Check if size elements have been copied
  for (int i = 0; i < 7; ++i) EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
  // and no more than that.
  EXPECT_EQ(0xdead, buffer[7]);
  EXPECT_CALL(alloc, deallocate(mem, 20));
}

TEST(memory_buffer_test, allocator) {
  using test_allocator = allocator_ref<mock_allocator<char>>;
  basic_memory_buffer<char, 10, test_allocator> buffer;
  EXPECT_EQ(nullptr, buffer.get_allocator().get());
  StrictMock<mock_allocator<char>> alloc;
  char mem;
  {
    basic_memory_buffer<char, 10, test_allocator> buffer2(
        (test_allocator(&alloc)));
    EXPECT_EQ(&alloc, buffer2.get_allocator().get());
    size_t size = 2 * fmt::inline_buffer_size;
    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
    buffer2.reserve(size);
    EXPECT_CALL(alloc, deallocate(&mem, size));
  }
}

TEST(memory_buffer_test, exception_in_deallocate) {
  using test_allocator = allocator_ref<mock_allocator<char>>;
  StrictMock<mock_allocator<char>> alloc;
  basic_memory_buffer<char, 10, test_allocator> buffer(
      (test_allocator(&alloc)));
  size_t size = 2 * fmt::inline_buffer_size;
  auto mem = std::vector<char>(size);
  {
    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
    buffer.resize(size);
    std::fill(&buffer[0], &buffer[0] + size, 'x');
  }
  auto mem2 = std::vector<char>(2 * size);
  {
    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
    auto e = std::exception();
    EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
    EXPECT_THROW(buffer.reserve(2 * size), std::exception);
    EXPECT_EQ(&mem2[0], &buffer[0]);
    // Check that the data has been copied.
    for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]);
  }
  EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
}

template <typename Allocator, size_t MaxSize>
class max_size_allocator : public Allocator {
 public:
  using typename Allocator::value_type;
  size_t max_size() const FMT_NOEXCEPT { return MaxSize; }
  value_type* allocate(size_t n) {
    if (n > max_size()) {
      throw std::length_error("size > max_size");
    }
    return std::allocator_traits<Allocator>::allocate(
        *static_cast<Allocator*>(this), n);
  }
  void deallocate(value_type* p, size_t n) {
    std::allocator_traits<Allocator>::deallocate(*static_cast<Allocator*>(this),
                                                 p, n);
  }
};

TEST(memory_buffer_test, max_size_allocator) {
  // 160 = 128 + 32
  using test_allocator = max_size_allocator<std::allocator<char>, 160>;
  basic_memory_buffer<char, 10, test_allocator> buffer;
  buffer.resize(128);
  // new_capacity = 128 + 128/2 = 192 > 160
  buffer.resize(160);  // Shouldn't throw.
}

TEST(memory_buffer_test, max_size_allocator_overflow) {
  using test_allocator = max_size_allocator<std::allocator<char>, 160>;
  basic_memory_buffer<char, 10, test_allocator> buffer;
  EXPECT_THROW(buffer.resize(161), std::exception);
}

TEST(format_test, escape) {
  EXPECT_EQ("{", fmt::format("{{"));
  EXPECT_EQ("before {", fmt::format("before {{"));
  EXPECT_EQ("{ after", fmt::format("{{ after"));
  EXPECT_EQ("before { after", fmt::format("before {{ after"));

  EXPECT_EQ("}", fmt::format("}}"));
  EXPECT_EQ("before }", fmt::format("before }}"));
  EXPECT_EQ("} after", fmt::format("}} after"));
  EXPECT_EQ("before } after", fmt::format("before }} after"));

  EXPECT_EQ("{}", fmt::format("{{}}"));
  EXPECT_EQ("{42}", fmt::format("{{{0}}}", 42));
}

TEST(format_test, unmatched_braces) {
  EXPECT_THROW_MSG(fmt::format(runtime("{")), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("}")), format_error,
                   "unmatched '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0{}")), format_error,
                   "invalid format string");
}

TEST(format_test, no_args) { EXPECT_EQ("test", fmt::format("test")); }

TEST(format_test, args_in_different_positions) {
  EXPECT_EQ("42", fmt::format("{0}", 42));
  EXPECT_EQ("before 42", fmt::format("before {0}", 42));
  EXPECT_EQ("42 after", fmt::format("{0} after", 42));
  EXPECT_EQ("before 42 after", fmt::format("before {0} after", 42));
  EXPECT_EQ("answer = 42", fmt::format("{0} = {1}", "answer", 42));
  EXPECT_EQ("42 is the answer", fmt::format("{1} is the {0}", "answer", 42));
  EXPECT_EQ("abracadabra", fmt::format("{0}{1}{0}", "abra", "cad"));
}

TEST(format_test, arg_errors) {
  EXPECT_THROW_MSG(fmt::format(runtime("{")), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{?}")), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0")), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0}")), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(fmt::format(runtime("{00}"), 42), format_error,
                   "invalid format string");

  char format_str[buffer_size];
  safe_sprintf(format_str, "{%u", INT_MAX);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str)), format_error,
                   "invalid format string");
  safe_sprintf(format_str, "{%u}", INT_MAX);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str)), format_error,
                   "argument not found");

  safe_sprintf(format_str, "{%u", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str)), format_error,
                   "invalid format string");
  safe_sprintf(format_str, "{%u}", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str)), format_error,
                   "argument not found");
}

template <int N> struct test_format {
  template <typename... T>
  static std::string format(fmt::string_view fmt, const T&... args) {
    return test_format<N - 1>::format(fmt, N - 1, args...);
  }
};

template <> struct test_format<0> {
  template <typename... T>
  static std::string format(fmt::string_view fmt, const T&... args) {
    return fmt::format(runtime(fmt), args...);
  }
};

TEST(format_test, many_args) {
  EXPECT_EQ("19", test_format<20>::format("{19}"));
  EXPECT_THROW_MSG(test_format<20>::format("{20}"), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(test_format<21>::format("{21}"), format_error,
                   "argument not found");
  using fmt::detail::max_packed_args;
  std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
  EXPECT_THROW_MSG(test_format<max_packed_args>::format(format_str),
                   format_error, "argument not found");
}

TEST(format_test, named_arg) {
  EXPECT_EQ("1/a/A", fmt::format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
                                 fmt::arg("A_", "A"), fmt::arg("_1", 1)));
  EXPECT_EQ(" -42", fmt::format("{0:{width}}", -42, fmt::arg("width", 4)));
  EXPECT_EQ("st",
            fmt::format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
  EXPECT_EQ("1 2", fmt::format("{} {two}", 1, fmt::arg("two", 2)));
  EXPECT_EQ("42",
            fmt::format("{c}", fmt::arg("a", 0), fmt::arg("b", 0),
                        fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0),
                        fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),
                        fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0),
                        fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0),
                        fmt::arg("o", 0), fmt::arg("p", 0)));
  EXPECT_THROW_MSG(fmt::format(runtime("{a}")), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(fmt::format(runtime("{a}"), 42), format_error,
                   "argument not found");
}

TEST(format_test, auto_arg_index) {
  EXPECT_EQ("abc", fmt::format("{}{}{}", 'a', 'b', 'c'));
  EXPECT_THROW_MSG(fmt::format(runtime("{0}{}"), 'a', 'b'), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{}{0}"), 'a', 'b'), format_error,
                   "cannot switch from automatic to manual argument indexing");
  EXPECT_EQ("1.2", fmt::format("{:.{}}", 1.2345, 2));
  EXPECT_THROW_MSG(fmt::format(runtime("{0}:.{}"), 1.2345, 2), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{:.{0}}"), 1.2345, 2), format_error,
                   "cannot switch from automatic to manual argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{}")), format_error,
                   "argument not found");
}

TEST(format_test, empty_specs) { EXPECT_EQ("42", fmt::format("{0:}", 42)); }

TEST(format_test, left_align) {
  EXPECT_EQ("42  ", fmt::format("{0:<4}", 42));
  EXPECT_EQ("42  ", fmt::format("{0:<4o}", 042));
  EXPECT_EQ("42  ", fmt::format("{0:<4x}", 0x42));
  EXPECT_EQ("-42  ", fmt::format("{0:<5}", -42));
  EXPECT_EQ("42   ", fmt::format("{0:<5}", 42u));
  EXPECT_EQ("-42  ", fmt::format("{0:<5}", -42l));
  EXPECT_EQ("42   ", fmt::format("{0:<5}", 42ul));
  EXPECT_EQ("-42  ", fmt::format("{0:<5}", -42ll));
  EXPECT_EQ("42   ", fmt::format("{0:<5}", 42ull));
  EXPECT_EQ("-42  ", fmt::format("{0:<5}", -42.0));
  EXPECT_EQ("-42  ", fmt::format("{0:<5}", -42.0l));
  EXPECT_EQ("c    ", fmt::format("{0:<5}", 'c'));
  EXPECT_EQ("abc  ", fmt::format("{0:<5}", "abc"));
  EXPECT_EQ("0xface  ", fmt::format("{0:<8}", reinterpret_cast<void*>(0xface)));
}

TEST(format_test, right_align) {
  EXPECT_EQ("  42", fmt::format("{0:>4}", 42));
  EXPECT_EQ("  42", fmt::format("{0:>4o}", 042));
  EXPECT_EQ("  42", fmt::format("{0:>4x}", 0x42));
  EXPECT_EQ("  -42", fmt::format("{0:>5}", -42));
  EXPECT_EQ("   42", fmt::format("{0:>5}", 42u));
  EXPECT_EQ("  -42", fmt::format("{0:>5}", -42l));
  EXPECT_EQ("   42", fmt::format("{0:>5}", 42ul));
  EXPECT_EQ("  -42", fmt::format("{0:>5}", -42ll));
  EXPECT_EQ("   42", fmt::format("{0:>5}", 42ull));
  EXPECT_EQ("  -42", fmt::format("{0:>5}", -42.0));
  EXPECT_EQ("  -42", fmt::format("{0:>5}", -42.0l));
  EXPECT_EQ("    c", fmt::format("{0:>5}", 'c'));
  EXPECT_EQ("  abc", fmt::format("{0:>5}", "abc"));
  EXPECT_EQ("  0xface", fmt::format("{0:>8}", reinterpret_cast<void*>(0xface)));
}

TEST(format_test, center_align) {
  EXPECT_EQ(" 42  ", fmt::format("{0:^5}", 42));
  EXPECT_EQ(" 42  ", fmt::format("{0:^5o}", 042));
  EXPECT_EQ(" 42  ", fmt::format("{0:^5x}", 0x42));
  EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42));
  EXPECT_EQ(" 42  ", fmt::format("{0:^5}", 42u));
  EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42l));
  EXPECT_EQ(" 42  ", fmt::format("{0:^5}", 42ul));
  EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42ll));
  EXPECT_EQ(" 42  ", fmt::format("{0:^5}", 42ull));
  EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42.0));
  EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42.0l));
  EXPECT_EQ("  c  ", fmt::format("{0:^5}", 'c'));
  EXPECT_EQ(" abc  ", fmt::format("{0:^6}", "abc"));
  EXPECT_EQ(" 0xface ", fmt::format("{0:^8}", reinterpret_cast<void*>(0xface)));
}

TEST(format_test, fill) {
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{<5}"), 'c'), format_error,
                   "invalid fill character '{'");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{<5}}"), 'c'), format_error,
                   "invalid fill character '{'");
  EXPECT_EQ("**42", fmt::format("{0:*>4}", 42));
  EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42));
  EXPECT_EQ("***42", fmt::format("{0:*>5}", 42u));
  EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42l));
  EXPECT_EQ("***42", fmt::format("{0:*>5}", 42ul));
  EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42ll));
  EXPECT_EQ("***42", fmt::format("{0:*>5}", 42ull));
  EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42.0));
  EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42.0l));
  EXPECT_EQ("c****", fmt::format("{0:*<5}", 'c'));
  EXPECT_EQ("abc**", fmt::format("{0:*<5}", "abc"));
  EXPECT_EQ("**0xface",
            fmt::format("{0:*>8}", reinterpret_cast<void*>(0xface)));
  EXPECT_EQ("foo=", fmt::format("{:}=", "foo"));
  EXPECT_EQ(std::string("\0\0\0*", 4),
            fmt::format(string_view("{:\0>4}", 6), '*'));
  EXPECT_EQ("жж42", fmt::format("{0:ж>4}", 42));
  EXPECT_THROW_MSG(fmt::format(runtime("{:\x80\x80\x80\x80\x80>}"), 0),
                   format_error, "missing '}' in format string");
}

TEST(format_test, plus_sign) {
  EXPECT_EQ("+42", fmt::format("{0:+}", 42));
  EXPECT_EQ("-42", fmt::format("{0:+}", -42));
  EXPECT_EQ("+42", fmt::format("{0:+}", 42));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), 42u), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("+42", fmt::format("{0:+}", 42l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), 42ul), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("+42", fmt::format("{0:+}", 42ll));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), 42ull), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("+42", fmt::format("{0:+}", 42.0));
  EXPECT_EQ("+42", fmt::format("{0:+}", 42.0l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+"), 'c'), format_error,
                   "missing '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), 'c'), format_error,
                   "invalid format specifier for char");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), "abc"), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), reinterpret_cast<void*>(0x42)),
                   format_error, "format specifier requires numeric argument");
}

TEST(format_test, minus_sign) {
  EXPECT_EQ("42", fmt::format("{0:-}", 42));
  EXPECT_EQ("-42", fmt::format("{0:-}", -42));
  EXPECT_EQ("42", fmt::format("{0:-}", 42));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), 42u), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("42", fmt::format("{0:-}", 42l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), 42ul), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("42", fmt::format("{0:-}", 42ll));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), 42ull), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ("42", fmt::format("{0:-}", 42.0));
  EXPECT_EQ("42", fmt::format("{0:-}", 42.0l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-"), 'c'), format_error,
                   "missing '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), 'c'), format_error,
                   "invalid format specifier for char");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), "abc"), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), reinterpret_cast<void*>(0x42)),
                   format_error, "format specifier requires numeric argument");
}

TEST(format_test, space_sign) {
  EXPECT_EQ(" 42", fmt::format("{0: }", 42));
  EXPECT_EQ("-42", fmt::format("{0: }", -42));
  EXPECT_EQ(" 42", fmt::format("{0: }", 42));
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), 42u), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ(" 42", fmt::format("{0: }", 42l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), 42ul), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ(" 42", fmt::format("{0: }", 42ll));
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), 42ull), format_error,
                   "format specifier requires signed argument");
  EXPECT_EQ(" 42", fmt::format("{0: }", 42.0));
  EXPECT_EQ(" 42", fmt::format("{0: }", 42.0l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0: "), 'c'), format_error,
                   "missing '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), 'c'), format_error,
                   "invalid format specifier for char");
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), "abc"), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), reinterpret_cast<void*>(0x42)),
                   format_error, "format specifier requires numeric argument");
}

TEST(format_test, hash_flag) {
  EXPECT_EQ("42", fmt::format("{0:#}", 42));
  EXPECT_EQ("-42", fmt::format("{0:#}", -42));
  EXPECT_EQ("0b101010", fmt::format("{0:#b}", 42));
  EXPECT_EQ("0B101010", fmt::format("{0:#B}", 42));
  EXPECT_EQ("-0b101010", fmt::format("{0:#b}", -42));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42));
  EXPECT_EQ("0X42", fmt::format("{0:#X}", 0x42));
  EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42));
  EXPECT_EQ("0", fmt::format("{0:#o}", 0));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042));
  EXPECT_EQ("-042", fmt::format("{0:#o}", -042));
  EXPECT_EQ("42", fmt::format("{0:#}", 42u));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42u));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042u));

  EXPECT_EQ("-42", fmt::format("{0:#}", -42l));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42l));
  EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42l));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042l));
  EXPECT_EQ("-042", fmt::format("{0:#o}", -042l));
  EXPECT_EQ("42", fmt::format("{0:#}", 42ul));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ul));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042ul));

  EXPECT_EQ("-42", fmt::format("{0:#}", -42ll));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ll));
  EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42ll));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042ll));
  EXPECT_EQ("-042", fmt::format("{0:#o}", -042ll));
  EXPECT_EQ("42", fmt::format("{0:#}", 42ull));
  EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ull));
  EXPECT_EQ("042", fmt::format("{0:#o}", 042ull));

  EXPECT_EQ("-42.0", fmt::format("{0:#}", -42.0));
  EXPECT_EQ("-42.0", fmt::format("{0:#}", -42.0l));
  EXPECT_EQ("4.e+01", fmt::format("{:#.0e}", 42.0));
  EXPECT_EQ("0.", fmt::format("{:#.0f}", 0.01));
  EXPECT_EQ("0.50", fmt::format("{:#.2g}", 0.5));
  EXPECT_EQ("0.", fmt::format("{:#.0f}", 0.5));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:#"), 'c'), format_error,
                   "missing '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:#}"), 'c'), format_error,
                   "invalid format specifier for char");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:#}"), "abc"), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:#}"), reinterpret_cast<void*>(0x42)),
                   format_error, "format specifier requires numeric argument");
}

TEST(format_test, zero_flag) {
  EXPECT_EQ("42", fmt::format("{0:0}", 42));
  EXPECT_EQ("-0042", fmt::format("{0:05}", -42));
  EXPECT_EQ("00042", fmt::format("{0:05}", 42u));
  EXPECT_EQ("-0042", fmt::format("{0:05}", -42l));
  EXPECT_EQ("00042", fmt::format("{0:05}", 42ul));
  EXPECT_EQ("-0042", fmt::format("{0:05}", -42ll));
  EXPECT_EQ("00042", fmt::format("{0:05}", 42ull));
  EXPECT_EQ("-000042", fmt::format("{0:07}", -42.0));
  EXPECT_EQ("-000042", fmt::format("{0:07}", -42.0l));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:0"), 'c'), format_error,
                   "missing '}' in format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:05}"), 'c'), format_error,
                   "invalid format specifier for char");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:05}"), "abc"), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(
      fmt::format(runtime("{0:05}"), reinterpret_cast<void*>(0x42)),
      format_error, "format specifier requires numeric argument");
}

TEST(format_test, width) {
  char format_str[buffer_size];
  safe_sprintf(format_str, "{0:%u", UINT_MAX);
  increment(format_str + 3);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");
  size_t size = std::strlen(format_str);
  format_str[size] = '}';
  format_str[size + 1] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");

  safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");
  safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");
  EXPECT_EQ(" -42", fmt::format("{0:4}", -42));
  EXPECT_EQ("   42", fmt::format("{0:5}", 42u));
  EXPECT_EQ("   -42", fmt::format("{0:6}", -42l));
  EXPECT_EQ("     42", fmt::format("{0:7}", 42ul));
  EXPECT_EQ("   -42", fmt::format("{0:6}", -42ll));
  EXPECT_EQ("     42", fmt::format("{0:7}", 42ull));
  EXPECT_EQ("   -1.23", fmt::format("{0:8}", -1.23));
  EXPECT_EQ("    -1.23", fmt::format("{0:9}", -1.23l));
  EXPECT_EQ("    0xcafe",
            fmt::format("{0:10}", reinterpret_cast<void*>(0xcafe)));
  EXPECT_EQ("x          ", fmt::format("{0:11}", 'x'));
  EXPECT_EQ("str         ", fmt::format("{0:12}", "str"));
  EXPECT_EQ(fmt::format("{:*^6}", "🤡"), "**🤡**");
  EXPECT_EQ(fmt::format("{:*^8}", "你好"), "**你好**");
  EXPECT_EQ(fmt::format("{:#6}", 42.0), "  42.0");
  EXPECT_EQ(fmt::format("{:6c}", static_cast<int>('x')), "x     ");
  EXPECT_EQ(fmt::format("{:>06.0f}", 0.00884311), "000000");
}

TEST(format_test, runtime_width) {
  char format_str[buffer_size];
  safe_sprintf(format_str, "{0:{%u", UINT_MAX);
  increment(format_str + 4);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "invalid format string");
  size_t size = std::strlen(format_str);
  format_str[size] = '}';
  format_str[size + 1] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "argument not found");
  format_str[size + 1] = '}';
  format_str[size + 2] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "argument not found");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:{"), 0), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{}"), 0), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{?}}"), 0), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0), format_error,
                   "argument not found");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:{0:}}"), 0), format_error,
                   "invalid format string");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, -1), format_error,
                   "negative width");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1u)),
                   format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, -1l), format_error,
                   "negative width");
  if (fmt::detail::const_check(sizeof(long) > sizeof(int))) {
    long value = INT_MAX;
    EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, (value + 1)),
                     format_error, "number is too big");
  }
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1ul)),
                   format_error, "number is too big");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, '0'), format_error,
                   "width is not integer");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{1}}"), 0, 0.0), format_error,
                   "width is not integer");

  EXPECT_EQ(" -42", fmt::format("{0:{1}}", -42, 4));
  EXPECT_EQ("   42", fmt::format("{0:{1}}", 42u, 5));
  EXPECT_EQ("   -42", fmt::format("{0:{1}}", -42l, 6));
  EXPECT_EQ("     42", fmt::format("{0:{1}}", 42ul, 7));
  EXPECT_EQ("   -42", fmt::format("{0:{1}}", -42ll, 6));
  EXPECT_EQ("     42", fmt::format("{0:{1}}", 42ull, 7));
  EXPECT_EQ("   -1.23", fmt::format("{0:{1}}", -1.23, 8));
  EXPECT_EQ("    -1.23", fmt::format("{0:{1}}", -1.23l, 9));
  EXPECT_EQ("    0xcafe",
            fmt::format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
  EXPECT_EQ("x          ", fmt::format("{0:{1}}", 'x', 11));
  EXPECT_EQ("str         ", fmt::format("{0:{1}}", "str", 12));
}

TEST(format_test, precision) {
  char format_str[buffer_size];
  safe_sprintf(format_str, "{0:.%u", UINT_MAX);
  increment(format_str + 4);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");
  size_t size = std::strlen(format_str);
  format_str[size] = '}';
  format_str[size + 1] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");

  safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");
  safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "number is too big");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:."), 0), format_error,
                   "missing precision specifier");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.}"), 0), format_error,
                   "missing precision specifier");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2"), 0), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42u), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42u), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42l), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42l), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42ul), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42ul), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42ll), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42ll), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2}"), 42ull), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.2f}"), 42ull), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:3.0}"), 'x'), format_error,
                   "precision not allowed for this argument type");
  EXPECT_EQ("1.2", fmt::format("{0:.2}", 1.2345));
  EXPECT_EQ("1.2", fmt::format("{0:.2}", 1.2345l));
  EXPECT_EQ("1.2e+56", fmt::format("{:.2}", 1.234e56));
  EXPECT_EQ("1.1", fmt::format("{0:.3}", 1.1));
  EXPECT_EQ("1e+00", fmt::format("{:.0e}", 1.0L));
  EXPECT_EQ("  0.0e+00", fmt::format("{:9.1e}", 0.0));
  EXPECT_EQ(
      fmt::format("{:.494}", 4.9406564584124654E-324),
      "4.9406564584124654417656879286822137236505980261432476442558568250067550"
      "727020875186529983636163599237979656469544571773092665671035593979639877"
      "479601078187812630071319031140452784581716784898210368871863605699873072"
      "305000638740915356498438731247339727316961514003171538539807412623856559"
      "117102665855668676818703956031062493194527159149245532930545654440112748"
      "012970999954193198940908041656332452475714786901472678015935523861155013"
      "480352649347201937902681071074917033322268447533357208324319361e-324");

  std::string outputs[] = {
      "-0X1.41FE3FFE71C9E000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000P+127",
      "-0XA.0FF1FFF38E4F0000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000000000000000000000000"
      "000000000000000000000000000000000000000000000000000P+124"};
  EXPECT_THAT(outputs,
              testing::Contains(fmt::format("{:.838A}", -2.14001164E+38)));

  EXPECT_EQ("123.", fmt::format("{:#.0f}", 123.0));
  EXPECT_EQ("1.23", fmt::format("{:.02f}", 1.234));
  EXPECT_EQ("0.001", fmt::format("{:.1g}", 0.001));
  EXPECT_EQ("1019666400", fmt::format("{}", 1019666432.0f));
  EXPECT_EQ("1e+01", fmt::format("{:.0e}", 9.5));
  EXPECT_EQ("1.0e-34", fmt::format("{:.1e}", 1e-34));

  EXPECT_THROW_MSG(
      fmt::format(runtime("{0:.2}"), reinterpret_cast<void*>(0xcafe)),
      format_error, "precision not allowed for this argument type");
  EXPECT_THROW_MSG(
      fmt::format(runtime("{0:.2f}"), reinterpret_cast<void*>(0xcafe)),
      format_error, "precision not allowed for this argument type");
  EXPECT_THROW_MSG(
      fmt::format(runtime("{:.{}e}"), 42.0, fmt::detail::max_value<int>()),
      format_error, "number is too big");

  EXPECT_EQ("st", fmt::format("{0:.2}", "str"));
}

TEST(format_test, runtime_precision) {
  char format_str[buffer_size];
  safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
  increment(format_str + 5);
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "invalid format string");
  size_t size = std::strlen(format_str);
  format_str[size] = '}';
  format_str[size + 1] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "argument not found");
  format_str[size + 1] = '}';
  format_str[size + 2] = 0;
  EXPECT_THROW_MSG(fmt::format(runtime(format_str), 0), format_error,
                   "argument not found");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{"), 0), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{}"), 0), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{?}}"), 0), format_error,
                   "invalid format string");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}"), 0, 0), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0), format_error,
                   "argument not found");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{0:}}"), 0), format_error,
                   "invalid format string");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, -1), format_error,
                   "negative precision");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, (INT_MAX + 1u)),
                   format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, -1l), format_error,
                   "negative precision");
  if (fmt::detail::const_check(sizeof(long) > sizeof(int))) {
    long value = INT_MAX;
    EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, (value + 1)),
                     format_error, "number is too big");
  }
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, (INT_MAX + 1ul)),
                   format_error, "number is too big");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, '0'), format_error,
                   "precision is not integer");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 0, 0.0), format_error,
                   "precision is not integer");

  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42u, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42u, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42l, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42l, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42ul, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42ul, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42ll, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42ll, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}}"), 42ull, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:.{1}f}"), 42ull, 2), format_error,
                   "precision not allowed for this argument type");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:3.{1}}"), 'x', 0), format_error,
                   "precision not allowed for this argument type");
  EXPECT_EQ("1.2", fmt::format("{0:.{1}}", 1.2345, 2));
  EXPECT_EQ("1.2", fmt::format("{1:.{0}}", 2, 1.2345l));

  EXPECT_THROW_MSG(
      fmt::format(runtime("{0:.{1}}"), reinterpret_cast<void*>(0xcafe), 2),
      format_error, "precision not allowed for this argument type");
  EXPECT_THROW_MSG(
      fmt::format(runtime("{0:.{1}f}"), reinterpret_cast<void*>(0xcafe), 2),
      format_error, "precision not allowed for this argument type");

  EXPECT_EQ("st", fmt::format("{0:.{1}}", "str", 2));
}

TEST(format_test, format_bool) {
  EXPECT_EQ("true", fmt::format("{}", true));
  EXPECT_EQ("false", fmt::format("{}", false));
  EXPECT_EQ("1", fmt::format("{:d}", true));
  EXPECT_EQ("true ", fmt::format("{:5}", true));
  EXPECT_EQ("true", fmt::format("{:s}", true));
  EXPECT_EQ("false", fmt::format("{:s}", false));
  EXPECT_EQ("false ", fmt::format("{:6s}", false));
}

TEST(format_test, format_short) {
  short s = 42;
  EXPECT_EQ("42", fmt::format("{0:d}", s));
  unsigned short us = 42;
  EXPECT_EQ("42", fmt::format("{0:d}", us));
}

template <typename T>
void check_unknown_types(const T& value, const char* types, const char*) {
  char format_str[buffer_size];
  const char* special = ".0123456789L}";
  for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
    char c = static_cast<char>(i);
    if (std::strchr(types, c) || std::strchr(special, c) || !c) continue;
    safe_sprintf(format_str, "{0:10%c}", c);
    const char* message = "invalid type specifier";
    EXPECT_THROW_MSG(fmt::format(runtime(format_str), value), format_error,
                     message)
        << format_str << " " << message;
  }
}

TEST(format_test, format_int) {
  EXPECT_THROW_MSG(fmt::format(runtime("{0:v"), 42), format_error,
                   "missing '}' in format string");
  check_unknown_types(42, "bBdoxXnLc", "integer");
  EXPECT_EQ("x", fmt::format("{:c}", static_cast<int>('x')));
}

TEST(format_test, format_bin) {
  EXPECT_EQ("0", fmt::format("{0:b}", 0));
  EXPECT_EQ("101010", fmt::format("{0:b}", 42));
  EXPECT_EQ("101010", fmt::format("{0:b}", 42u));
  EXPECT_EQ("-101010", fmt::format("{0:b}", -42));
  EXPECT_EQ("11000000111001", fmt::format("{0:b}", 12345));
  EXPECT_EQ("10010001101000101011001111000", fmt::format("{0:b}", 0x12345678));
  EXPECT_EQ("10010000101010111100110111101111",
            fmt::format("{0:b}", 0x90ABCDEF));
  EXPECT_EQ("11111111111111111111111111111111",
            fmt::format("{0:b}", max_value<uint32_t>()));
}

#if FMT_USE_INT128
constexpr auto int128_max = static_cast<__int128_t>(
    (static_cast<__uint128_t>(1) << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1);
constexpr auto int128_min = -int128_max - 1;

constexpr auto uint128_max = ~static_cast<__uint128_t>(0);
#endif

TEST(format_test, format_dec) {
  EXPECT_EQ("0", fmt::format("{0}", 0));
  EXPECT_EQ("42", fmt::format("{0}", 42));
  EXPECT_EQ("42", fmt::format("{0:d}", 42));
  EXPECT_EQ("42", fmt::format("{0}", 42u));
  EXPECT_EQ("-42", fmt::format("{0}", -42));
  EXPECT_EQ("12345", fmt::format("{0}", 12345));
  EXPECT_EQ("67890", fmt::format("{0}", 67890));
#if FMT_USE_INT128
  EXPECT_EQ("0", fmt::format("{0}", static_cast<__int128_t>(0)));
  EXPECT_EQ("0", fmt::format("{0}", static_cast<__uint128_t>(0)));
  EXPECT_EQ("9223372036854775808",
            fmt::format("{0}", static_cast<__int128_t>(INT64_MAX) + 1));
  EXPECT_EQ("-9223372036854775809",
            fmt::format("{0}", static_cast<__int128_t>(INT64_MIN) - 1));
  EXPECT_EQ("18446744073709551616",
            fmt::format("{0}", static_cast<__int128_t>(UINT64_MAX) + 1));
  EXPECT_EQ("170141183460469231731687303715884105727",
            fmt::format("{0}", int128_max));
  EXPECT_EQ("-170141183460469231731687303715884105728",
            fmt::format("{0}", int128_min));
  EXPECT_EQ("340282366920938463463374607431768211455",
            fmt::format("{0}", uint128_max));
#endif

  char buffer[buffer_size];
  safe_sprintf(buffer, "%d", INT_MIN);
  EXPECT_EQ(buffer, fmt::format("{0}", INT_MIN));
  safe_sprintf(buffer, "%d", INT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0}", INT_MAX));
  safe_sprintf(buffer, "%u", UINT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0}", UINT_MAX));
  safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
  EXPECT_EQ(buffer, fmt::format("{0}", LONG_MIN));
  safe_sprintf(buffer, "%ld", LONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0}", LONG_MAX));
  safe_sprintf(buffer, "%lu", ULONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0}", ULONG_MAX));
}

TEST(format_test, format_hex) {
  EXPECT_EQ("0", fmt::format("{0:x}", 0));
  EXPECT_EQ("42", fmt::format("{0:x}", 0x42));
  EXPECT_EQ("42", fmt::format("{0:x}", 0x42u));
  EXPECT_EQ("-42", fmt::format("{0:x}", -0x42));
  EXPECT_EQ("12345678", fmt::format("{0:x}", 0x12345678));
  EXPECT_EQ("90abcdef", fmt::format("{0:x}", 0x90abcdef));
  EXPECT_EQ("12345678", fmt::format("{0:X}", 0x12345678));
  EXPECT_EQ("90ABCDEF", fmt::format("{0:X}", 0x90ABCDEF));
#if FMT_USE_INT128
  EXPECT_EQ("0", fmt::format("{0:x}", static_cast<__int128_t>(0)));
  EXPECT_EQ("0", fmt::format("{0:x}", static_cast<__uint128_t>(0)));
  EXPECT_EQ("8000000000000000",
            fmt::format("{0:x}", static_cast<__int128_t>(INT64_MAX) + 1));
  EXPECT_EQ("-8000000000000001",
            fmt::format("{0:x}", static_cast<__int128_t>(INT64_MIN) - 1));
  EXPECT_EQ("10000000000000000",
            fmt::format("{0:x}", static_cast<__int128_t>(UINT64_MAX) + 1));
  EXPECT_EQ("7fffffffffffffffffffffffffffffff",
            fmt::format("{0:x}", int128_max));
  EXPECT_EQ("-80000000000000000000000000000000",
            fmt::format("{0:x}", int128_min));
  EXPECT_EQ("ffffffffffffffffffffffffffffffff",
            fmt::format("{0:x}", uint128_max));
#endif

  char buffer[buffer_size];
  safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
  EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MIN));
  safe_sprintf(buffer, "%x", INT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MAX));
  safe_sprintf(buffer, "%x", UINT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:x}", UINT_MAX));
  safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
  EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MIN));
  safe_sprintf(buffer, "%lx", LONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MAX));
  safe_sprintf(buffer, "%lx", ULONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:x}", ULONG_MAX));
}

TEST(format_test, format_oct) {
  EXPECT_EQ("0", fmt::format("{0:o}", 0));
  EXPECT_EQ("42", fmt::format("{0:o}", 042));
  EXPECT_EQ("42", fmt::format("{0:o}", 042u));
  EXPECT_EQ("-42", fmt::format("{0:o}", -042));
  EXPECT_EQ("12345670", fmt::format("{0:o}", 012345670));
#if FMT_USE_INT128
  EXPECT_EQ("0", fmt::format("{0:o}", static_cast<__int128_t>(0)));
  EXPECT_EQ("0", fmt::format("{0:o}", static_cast<__uint128_t>(0)));
  EXPECT_EQ("1000000000000000000000",
            fmt::format("{0:o}", static_cast<__int128_t>(INT64_MAX) + 1));
  EXPECT_EQ("-1000000000000000000001",
            fmt::format("{0:o}", static_cast<__int128_t>(INT64_MIN) - 1));
  EXPECT_EQ("2000000000000000000000",
            fmt::format("{0:o}", static_cast<__int128_t>(UINT64_MAX) + 1));
  EXPECT_EQ("1777777777777777777777777777777777777777777",
            fmt::format("{0:o}", int128_max));
  EXPECT_EQ("-2000000000000000000000000000000000000000000",
            fmt::format("{0:o}", int128_min));
  EXPECT_EQ("3777777777777777777777777777777777777777777",
            fmt::format("{0:o}", uint128_max));
#endif

  char buffer[buffer_size];
  safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
  EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MIN));
  safe_sprintf(buffer, "%o", INT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MAX));
  safe_sprintf(buffer, "%o", UINT_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:o}", UINT_MAX));
  safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
  EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MIN));
  safe_sprintf(buffer, "%lo", LONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MAX));
  safe_sprintf(buffer, "%lo", ULONG_MAX);
  EXPECT_EQ(buffer, fmt::format("{0:o}", ULONG_MAX));
}

TEST(format_test, format_int_locale) {
  EXPECT_EQ("1234", fmt::format("{:L}", 1234));
}

TEST(format_test, format_float) {
  EXPECT_EQ("0", fmt::format("{}", 0.0f));
  EXPECT_EQ("392.500000", fmt::format("{0:f}", 392.5f));
}

TEST(format_test, format_double) {
  EXPECT_EQ("0", fmt::format("{}", 0.0));
  check_unknown_types(1.2, "eEfFgGaAnL%", "double");
  EXPECT_EQ("0", fmt::format("{:}", 0.0));
  EXPECT_EQ("0.000000", fmt::format("{:f}", 0.0));
  EXPECT_EQ("0", fmt::format("{:g}", 0.0));
  EXPECT_EQ("392.65", fmt::format("{:}", 392.65));
  EXPECT_EQ("392.65", fmt::format("{:g}", 392.65));
  EXPECT_EQ("392.65", fmt::format("{:G}", 392.65));
  EXPECT_EQ("4.9014e+06", fmt::format("{:g}", 4.9014e6));
  EXPECT_EQ("392.650000", fmt::format("{:f}", 392.65));
  EXPECT_EQ("392.650000", fmt::format("{:F}", 392.65));
  EXPECT_EQ("42", fmt::format("{:L}", 42.0));
  EXPECT_EQ("    0x1.0cccccccccccdp+2", fmt::format("{:24a}", 4.2));
  EXPECT_EQ("0x1.0cccccccccccdp+2    ", fmt::format("{:<24a}", 4.2));
  char buffer[buffer_size];
  safe_sprintf(buffer, "%e", 392.65);
  EXPECT_EQ(buffer, fmt::format("{0:e}", 392.65));
  safe_sprintf(buffer, "%E", 392.65);
  EXPECT_EQ(buffer, fmt::format("{0:E}", 392.65));
  EXPECT_EQ("+0000392.6", fmt::format("{0:+010.4g}", 392.65));
  safe_sprintf(buffer, "%a", -42.0);
  EXPECT_EQ(buffer, fmt::format("{:a}", -42.0));
  safe_sprintf(buffer, "%A", -42.0);
  EXPECT_EQ(buffer, fmt::format("{:A}", -42.0));
  EXPECT_EQ("9223372036854775808.000000",
            fmt::format("{:f}", 9223372036854775807.0));
}

TEST(format_test, precision_rounding) {
  EXPECT_EQ("0", fmt::format("{:.0f}", 0.0));
  EXPECT_EQ("0", fmt::format("{:.0f}", 0.01));
  EXPECT_EQ("0", fmt::format("{:.0f}", 0.1));
  EXPECT_EQ("0.000", fmt::format("{:.3f}", 0.00049));
  EXPECT_EQ("0.001", fmt::format("{:.3f}", 0.0005));
  EXPECT_EQ("0.001", fmt::format("{:.3f}", 0.00149));
  EXPECT_EQ("0.002", fmt::format("{:.3f}", 0.0015));
  EXPECT_EQ("1.000", fmt::format("{:.3f}", 0.9999));
  EXPECT_EQ("0.00123", fmt::format("{:.3}", 0.00123));
  EXPECT_EQ("0.1", fmt::format("{:.16g}", 0.1));
  EXPECT_EQ("1", fmt::format("{:.0}", 1.0));
  EXPECT_EQ("225.51575035152063720",
            fmt::format("{:.17f}", 225.51575035152064));
  EXPECT_EQ("-761519619559038.2", fmt::format("{:.1f}", -761519619559038.2));
  EXPECT_EQ("1.9156918820264798e-56",
            fmt::format("{}", 1.9156918820264798e-56));
  EXPECT_EQ("0.0000", fmt::format("{:.4f}", 7.2809479766055470e-15));

  // Trigger a rounding error in Grisu by a specially chosen number.
  EXPECT_EQ("3788512123356.985352", fmt::format("{:f}", 3788512123356.985352));
}

TEST(format_test, prettify_float) {
  EXPECT_EQ("0.0001", fmt::format("{}", 1e-4));
  EXPECT_EQ("1e-05", fmt::format("{}", 1e-5));
  EXPECT_EQ("1000000000000000", fmt::format("{}", 1e15));
  EXPECT_EQ("1e+16", fmt::format("{}", 1e16));
  EXPECT_EQ("9.999e-05", fmt::format("{}", 9.999e-5));
  EXPECT_EQ("10000000000", fmt::format("{}", 1e10));
  EXPECT_EQ("100000000000", fmt::format("{}", 1e11));
  EXPECT_EQ("12340000000", fmt::format("{}", 1234e7));
  EXPECT_EQ("12.34", fmt::format("{}", 1234e-2));
  EXPECT_EQ("0.001234", fmt::format("{}", 1234e-6));
  EXPECT_EQ("0.1", fmt::format("{}", 0.1f));
  EXPECT_EQ("0.10000000149011612", fmt::format("{}", double(0.1f)));
  EXPECT_EQ("1.3563156e-19", fmt::format("{}", 1.35631564e-19f));
}

TEST(format_test, format_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();
  EXPECT_EQ("nan", fmt::format("{}", nan));
  EXPECT_EQ("+nan", fmt::format("{:+}", nan));
  EXPECT_EQ("  +nan", fmt::format("{:+06}", nan));
  EXPECT_EQ("+nan  ", fmt::format("{:<+06}", nan));
  EXPECT_EQ(" +nan ", fmt::format("{:^+06}", nan));
  EXPECT_EQ("  +nan", fmt::format("{:>+06}", nan));
  if (std::signbit(-nan)) {
    EXPECT_EQ("-nan", fmt::format("{}", -nan));
    EXPECT_EQ("  -nan", fmt::format("{:+06}", -nan));
  } else {
    fmt::print("Warning: compiler doesn't handle negative NaN correctly");
  }
  EXPECT_EQ(" nan", fmt::format("{: }", nan));
  EXPECT_EQ("NAN", fmt::format("{:F}", nan));
  EXPECT_EQ("nan    ", fmt::format("{:<7}", nan));
  EXPECT_EQ("  nan  ", fmt::format("{:^7}", nan));
  EXPECT_EQ("    nan", fmt::format("{:>7}", nan));
}

TEST(format_test, format_infinity) {
  double inf = std::numeric_limits<double>::infinity();
  EXPECT_EQ("inf", fmt::format("{}", inf));
  EXPECT_EQ("+inf", fmt::format("{:+}", inf));
  EXPECT_EQ("-inf", fmt::format("{}", -inf));
  EXPECT_EQ("  +inf", fmt::format("{:+06}", inf));
  EXPECT_EQ("  -inf", fmt::format("{:+06}", -inf));
  EXPECT_EQ("+inf  ", fmt::format("{:<+06}", inf));
  EXPECT_EQ(" +inf ", fmt::format("{:^+06}", inf));
  EXPECT_EQ("  +inf", fmt::format("{:>+06}", inf));
  EXPECT_EQ(" inf", fmt::format("{: }", inf));
  EXPECT_EQ("INF", fmt::format("{:F}", inf));
  EXPECT_EQ("inf    ", fmt::format("{:<7}", inf));
  EXPECT_EQ("  inf  ", fmt::format("{:^7}", inf));
  EXPECT_EQ("    inf", fmt::format("{:>7}", inf));
}

TEST(format_test, format_long_double) {
  EXPECT_EQ("0", fmt::format("{0:}", 0.0l));
  EXPECT_EQ("0.000000", fmt::format("{0:f}", 0.0l));
  EXPECT_EQ("392.65", fmt::format("{0:}", 392.65l));
  EXPECT_EQ("392.65", fmt::format("{0:g}", 392.65l));
  EXPECT_EQ("392.65", fmt::format("{0:G}", 392.65l));
  EXPECT_EQ("392.650000", fmt::format("{0:f}", 392.65l));
  EXPECT_EQ("392.650000", fmt::format("{0:F}", 392.65l));
  char buffer[buffer_size];
  safe_sprintf(buffer, "%Le", 392.65l);
  EXPECT_EQ(buffer, fmt::format("{0:e}", 392.65l));
  EXPECT_EQ("+0000392.6", fmt::format("{0:+010.4g}", 392.64l));
  safe_sprintf(buffer, "%La", 3.31l);
  EXPECT_EQ(buffer, fmt::format("{:a}", 3.31l));
}

TEST(format_test, format_char) {
  const char types[] = "cbBdoxX";
  check_unknown_types('a', types, "char");
  EXPECT_EQ("a", fmt::format("{0}", 'a'));
  EXPECT_EQ("z", fmt::format("{0:c}", 'z'));
  int n = 'x';
  for (const char* type = types + 1; *type; ++type) {
    std::string format_str = fmt::format("{{:{}}}", *type);
    EXPECT_EQ(fmt::format(runtime(format_str), n),
              fmt::format(runtime(format_str), 'x'))
        << format_str;
  }
  EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
}

TEST(format_test, format_volatile_char) {
  volatile char c = 'x';
  EXPECT_EQ("x", fmt::format("{}", c));
}

TEST(format_test, format_unsigned_char) {
  EXPECT_EQ("42", fmt::format("{}", static_cast<unsigned char>(42)));
  EXPECT_EQ("42", fmt::format("{}", static_cast<uint8_t>(42)));
}

TEST(format_test, format_cstring) {
  check_unknown_types("test", "sp", "string");
  EXPECT_EQ("test", fmt::format("{0}", "test"));
  EXPECT_EQ("test", fmt::format("{0:s}", "test"));
  char nonconst[] = "nonconst";
  EXPECT_EQ("nonconst", fmt::format("{0}", nonconst));
  EXPECT_THROW_MSG(
      fmt::format(runtime("{0}"), static_cast<const char*>(nullptr)),
      format_error, "string pointer is null");
}

TEST(format_test, format_schar_string) {
  signed char str[] = "test";
  EXPECT_EQ("test", fmt::format("{0:s}", str));
  const signed char* const_str = str;
  EXPECT_EQ("test", fmt::format("{0:s}", const_str));
}

TEST(format_test, format_uchar_string) {
  unsigned char str[] = "test";
  EXPECT_EQ("test", fmt::format("{0:s}", str));
  const unsigned char* const_str = str;
  EXPECT_EQ("test", fmt::format("{0:s}", const_str));
  unsigned char* ptr = str;
  EXPECT_EQ("test", fmt::format("{0:s}", ptr));
}

void function_pointer_test(int, double, std::string) {}

TEST(format_test, format_pointer) {
  check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer");
  EXPECT_EQ("0x0", fmt::format("{0}", static_cast<void*>(nullptr)));
  EXPECT_EQ("0x1234", fmt::format("{0}", reinterpret_cast<void*>(0x1234)));
  EXPECT_EQ("0x1234", fmt::format("{0:p}", reinterpret_cast<void*>(0x1234)));
  EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'),
            fmt::format("{0}", reinterpret_cast<void*>(~uintptr_t())));
  EXPECT_EQ("0x1234",
            fmt::format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
  std::unique_ptr<int> up(new int(1));
  EXPECT_EQ(fmt::format("{}", fmt::ptr(up.get())),
            fmt::format("{}", fmt::ptr(up)));
  std::shared_ptr<int> sp(new int(1));
  EXPECT_EQ(fmt::format("{}", fmt::ptr(sp.get())),
            fmt::format("{}", fmt::ptr(sp)));
  EXPECT_EQ(fmt::format("{}", fmt::detail::bit_cast<const void*>(
                                  &function_pointer_test)),
            fmt::format("{}", fmt::ptr(function_pointer_test)));
  EXPECT_EQ("0x0", fmt::format("{}", nullptr));
}

TEST(format_test, format_string) {
  EXPECT_EQ("test", fmt::format("{0}", std::string("test")));
  EXPECT_THROW(fmt::format(fmt::runtime("{:x}"), std::string("test")),
               fmt::format_error);
}

TEST(format_test, format_string_view) {
  EXPECT_EQ("test", fmt::format("{}", string_view("test")));
  EXPECT_EQ("", fmt::format("{}", string_view()));
}

#ifdef FMT_USE_STRING_VIEW
struct string_viewable {};

FMT_BEGIN_NAMESPACE
template <> struct formatter<string_viewable> : formatter<std::string_view> {
  auto format(string_viewable, format_context& ctx) -> decltype(ctx.out()) {
    return formatter<std::string_view>::format("foo", ctx);
  }
};
FMT_END_NAMESPACE

TEST(format_test, format_std_string_view) {
  EXPECT_EQ("test", fmt::format("{}", std::string_view("test")));
  EXPECT_EQ("foo", fmt::format("{}", string_viewable()));
}

struct explicitly_convertible_to_std_string_view {
  explicit operator std::string_view() const { return "foo"; }
};

template <>
struct fmt::formatter<explicitly_convertible_to_std_string_view>
    : formatter<std::string_view> {
  auto format(explicitly_convertible_to_std_string_view v, format_context& ctx)
      -> decltype(ctx.out()) {
    return format_to(ctx.out(), "'{}'", std::string_view(v));
  }
};

TEST(format_test, format_explicitly_convertible_to_std_string_view) {
  EXPECT_EQ("'foo'",
            fmt::format("{}", explicitly_convertible_to_std_string_view()));
}
#endif

struct converible_to_anything {
  template <typename T> operator T() const { return T(); }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<converible_to_anything> {
  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  auto format(converible_to_anything, format_context& ctx)
      -> decltype(ctx.out()) {
    return format_to(ctx.out(), "foo");
  }
};
FMT_END_NAMESPACE

TEST(format_test, format_convertible_to_anything) {
  EXPECT_EQ("foo", fmt::format("{}", converible_to_anything()));
}

class Answer {};

FMT_BEGIN_NAMESPACE
template <> struct formatter<date> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    if (it != ctx.end() && *it == 'd') ++it;
    return it;
  }

  auto format(const date& d, format_context& ctx) -> decltype(ctx.out()) {
    format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day());
    return ctx.out();
  }
};

template <> struct formatter<Answer> : formatter<int> {
  template <typename FormatContext>
  auto format(Answer, FormatContext& ctx) -> decltype(ctx.out()) {
    return formatter<int>::format(42, ctx);
  }
};
FMT_END_NAMESPACE

TEST(format_test, format_custom) {
  EXPECT_THROW_MSG(fmt::format(runtime("{:s}"), date(2012, 12, 9)),
                   format_error, "unknown format specifier");
  EXPECT_EQ("42", fmt::format("{0}", Answer()));
  EXPECT_EQ("0042", fmt::format("{:04}", Answer()));
}

TEST(format_test, format_to_custom) {
  char buf[10] = {};
  auto end =
      &*fmt::format_to(fmt::detail::make_checked(buf, 10), "{}", Answer());
  EXPECT_EQ(end, buf + 2);
  EXPECT_STREQ(buf, "42");
}

TEST(format_test, format_string_from_speed_test) {
  EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
            fmt::format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%", 1.234, 42,
                        3.13, "str", reinterpret_cast<void*>(1000), 'X'));
}

TEST(format_test, format_examples) {
  std::string message = fmt::format("The answer is {}", 42);
  EXPECT_EQ("The answer is 42", message);

  EXPECT_EQ("42", fmt::format("{}", 42));

  memory_buffer out;
  format_to(std::back_inserter(out), "The answer is {}.", 42);
  EXPECT_EQ("The answer is 42.", to_string(out));

  const char* filename = "nonexistent";
  FILE* ftest = safe_fopen(filename, "r");
  if (ftest) fclose(ftest);
  int error_code = errno;
  EXPECT_TRUE(ftest == nullptr);
  EXPECT_SYSTEM_ERROR(
      {
        FILE* f = safe_fopen(filename, "r");
        if (!f)
          throw fmt::system_error(errno, "Cannot open file '{}'", filename);
        fclose(f);
      },
      error_code, "Cannot open file 'nonexistent'");

  EXPECT_EQ("First, thou shalt count to three",
            fmt::format("First, thou shalt count to {0}", "three"));
  EXPECT_EQ("Bring me a shrubbery", fmt::format("Bring me a {}", "shrubbery"));
  EXPECT_EQ("From 1 to 3", fmt::format("From {} to {}", 1, 3));

  char buffer[buffer_size];
  safe_sprintf(buffer, "%03.2f", -1.2);
  EXPECT_EQ(buffer, fmt::format("{:03.2f}", -1.2));

  EXPECT_EQ("a, b, c", fmt::format("{0}, {1}, {2}", 'a', 'b', 'c'));
  EXPECT_EQ("a, b, c", fmt::format("{}, {}, {}", 'a', 'b', 'c'));
  EXPECT_EQ("c, b, a", fmt::format("{2}, {1}, {0}", 'a', 'b', 'c'));
  EXPECT_EQ("abracadabra", fmt::format("{0}{1}{0}", "abra", "cad"));

  EXPECT_EQ("left aligned                  ",
            fmt::format("{:<30}", "left aligned"));
  EXPECT_EQ("                 right aligned",
            fmt::format("{:>30}", "right aligned"));
  EXPECT_EQ("           centered           ",
            fmt::format("{:^30}", "centered"));
  EXPECT_EQ("***********centered***********",
            fmt::format("{:*^30}", "centered"));

  EXPECT_EQ("+3.140000; -3.140000", fmt::format("{:+f}; {:+f}", 3.14, -3.14));
  EXPECT_EQ(" 3.140000; -3.140000", fmt::format("{: f}; {: f}", 3.14, -3.14));
  EXPECT_EQ("3.140000; -3.140000", fmt::format("{:-f}; {:-f}", 3.14, -3.14));

  EXPECT_EQ("int: 42;  hex: 2a;  oct: 52",
            fmt::format("int: {0:d};  hex: {0:x};  oct: {0:o}", 42));
  EXPECT_EQ("int: 42;  hex: 0x2a;  oct: 052",
            fmt::format("int: {0:d};  hex: {0:#x};  oct: {0:#o}", 42));

  EXPECT_EQ("The answer is 42", fmt::format("The answer is {}", 42));
  EXPECT_THROW_MSG(fmt::format(runtime("The answer is {:d}"), "forty-two"),
                   format_error, "invalid type specifier");

  EXPECT_WRITE(
      stdout, fmt::print("{}", std::numeric_limits<double>::infinity()), "inf");
}

TEST(format_test, print) {
  EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!");
  EXPECT_WRITE(stderr, fmt::print(stderr, "Don't {}!", "panic"),
               "Don't panic!");
}

TEST(format_test, variadic) {
  EXPECT_EQ("abc1", fmt::format("{}c{}", "ab", 1));
}

TEST(format_test, dynamic) {
  using ctx = fmt::format_context;
  auto args = std::vector<fmt::basic_format_arg<ctx>>();
  args.emplace_back(fmt::detail::make_arg<ctx>(42));
  args.emplace_back(fmt::detail::make_arg<ctx>("abc1"));
  args.emplace_back(fmt::detail::make_arg<ctx>(1.5f));

  std::string result = fmt::vformat(
      "{} and {} and {}",
      fmt::format_args(args.data(), static_cast<int>(args.size())));

  EXPECT_EQ("42 and abc1 and 1.5", result);
}

TEST(format_test, bytes) {
  auto s = fmt::format("{:10}", fmt::bytes("ёжик"));
  EXPECT_EQ("ёжик  ", s);
  EXPECT_EQ(10, s.size());
}

enum test_enum { foo, bar };

TEST(format_test, join) {
  using fmt::join;
  int v1[3] = {1, 2, 3};
  auto v2 = std::vector<float>();
  v2.push_back(1.2f);
  v2.push_back(3.4f);
  void* v3[2] = {&v1[0], &v1[1]};

  EXPECT_EQ("(1, 2, 3)", fmt::format("({})", join(v1, v1 + 3, ", ")));
  EXPECT_EQ("(1)", fmt::format("({})", join(v1, v1 + 1, ", ")));
  EXPECT_EQ("()", fmt::format("({})", join(v1, v1, ", ")));
  EXPECT_EQ("(001, 002, 003)", fmt::format("({:03})", join(v1, v1 + 3, ", ")));
  EXPECT_EQ("(+01.20, +03.40)",
            fmt::format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));

  EXPECT_EQ("1, 2, 3", fmt::format("{0:{1}}", join(v1, v1 + 3, ", "), 1));

  EXPECT_EQ(fmt::format("{}, {}", v3[0], v3[1]),
            fmt::format("{}", join(v3, v3 + 2, ", ")));

  EXPECT_EQ("(1, 2, 3)", fmt::format("({})", join(v1, ", ")));
  EXPECT_EQ("(+01.20, +03.40)", fmt::format("({:+06.2f})", join(v2, ", ")));

  auto v4 = std::vector<test_enum>{foo, bar, foo};
  EXPECT_EQ("0 1 0", fmt::format("{}", join(v4, " ")));
}

#ifdef __cpp_lib_byte
TEST(format_test, join_bytes) {
  auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)};
  EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, ", ")));
}
#endif

std::string vformat_message(int id, const char* format, fmt::format_args args) {
  auto buffer = fmt::memory_buffer();
  format_to(fmt::appender(buffer), "[{}] ", id);
  vformat_to(fmt::appender(buffer), format, args);
  return to_string(buffer);
}

template <typename... Args>
std::string format_message(int id, const char* format, const Args&... args) {
  auto va = fmt::make_format_args(args...);
  return vformat_message(id, format, va);
}

TEST(format_test, format_message_example) {
  EXPECT_EQ("[42] something happened",
            format_message(42, "{} happened", "something"));
}

template <typename... Args>
void print_error(const char* file, int line, const char* format,
                 const Args&... args) {
  fmt::print("{}: {}: ", file, line);
  fmt::print(format, args...);
}

TEST(format_test, unpacked_args) {
  EXPECT_EQ("0123456789abcdefg",
            fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", 0, 1, 2, 3, 4, 5,
                        6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f', 'g'));
}

struct string_like {};
fmt::string_view to_string_view(string_like) { return "foo"; }

constexpr char with_null[3] = {'{', '}', '\0'};
constexpr char no_null[2] = {'{', '}'};
static FMT_CONSTEXPR_DECL const char static_with_null[3] = {'{', '}', '\0'};
static FMT_CONSTEXPR_DECL const char static_no_null[2] = {'{', '}'};

TEST(format_test, compile_time_string) {
  EXPECT_EQ("foo", fmt::format(FMT_STRING("foo")));
  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42));
  EXPECT_EQ("foo", fmt::format(FMT_STRING("{}"), string_like()));

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
  using namespace fmt::literals;
  EXPECT_EQ("foobar", fmt::format(FMT_STRING("{foo}{bar}"), "bar"_a = "bar",
                                  "foo"_a = "foo"));
  EXPECT_EQ("", fmt::format(FMT_STRING("")));
  EXPECT_EQ("", fmt::format(FMT_STRING(""), "arg"_a = 42));
#endif

  (void)static_with_null;
  (void)static_no_null;
#ifndef _MSC_VER
  EXPECT_EQ("42", fmt::format(FMT_STRING(static_with_null), 42));
  EXPECT_EQ("42", fmt::format(FMT_STRING(static_no_null), 42));
#endif

  (void)with_null;
  (void)no_null;
#if __cplusplus >= 201703L
  EXPECT_EQ("42", fmt::format(FMT_STRING(with_null), 42));
  EXPECT_EQ("42", fmt::format(FMT_STRING(no_null), 42));
#endif
#if defined(FMT_USE_STRING_VIEW) && __cplusplus >= 201703L
  EXPECT_EQ("42", fmt::format(FMT_STRING(std::string_view("{}")), 42));
#endif
}

TEST(format_test, custom_format_compile_time_string) {
  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), Answer()));
  auto answer = Answer();
  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), answer));
  char buf[10] = {};
  fmt::format_to(buf, FMT_STRING("{}"), answer);
  const Answer const_answer = Answer();
  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), const_answer));
}

#if FMT_USE_USER_DEFINED_LITERALS
// Passing user-defined literals directly to EXPECT_EQ causes problems
// with macro argument stringification (#) on some versions of GCC.
// Workaround: Assing the UDL result to a variable before the macro.

using namespace fmt::literals;

TEST(format_test, format_udl) {
  EXPECT_EQ("{}c{}"_format("ab", 1), fmt::format("{}c{}", "ab", 1));
  EXPECT_EQ("foo"_format(), "foo");
  EXPECT_EQ("{0:10}"_format(42), "        42");
  EXPECT_EQ("{}"_format(date(2015, 10, 21)), "2015-10-21");
}

TEST(format_test, named_arg_udl) {
  auto udl_a = fmt::format("{first}{second}{first}{third}", "first"_a = "abra",
                           "second"_a = "cad", "third"_a = 99);
  EXPECT_EQ(
      fmt::format("{first}{second}{first}{third}", fmt::arg("first", "abra"),
                  fmt::arg("second", "cad"), fmt::arg("third", 99)),
      udl_a);
}
#endif  // FMT_USE_USER_DEFINED_LITERALS

TEST(format_test, enum) { EXPECT_EQ("0", fmt::format("{}", foo)); }

TEST(format_test, formatter_not_specialized) {
  static_assert(!fmt::has_formatter<fmt::formatter<test_enum>,
                                    fmt::format_context>::value,
                "");
}

#if FMT_HAS_FEATURE(cxx_strong_enums)
enum big_enum : unsigned long long { big_enum_value = 5000000000ULL };

TEST(format_test, strong_enum) {
  EXPECT_EQ("5000000000", fmt::format("{}", big_enum_value));
}
#endif

TEST(format_test, non_null_terminated_format_string) {
  EXPECT_EQ("42", fmt::format(string_view("{}foo", 2), 42));
}

struct variant {
  enum { int_type, string_type } type;
  explicit variant(int) : type(int_type) {}
  explicit variant(const char*) : type(string_type) {}
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<variant> : dynamic_formatter<> {
  auto format(variant value, format_context& ctx) -> decltype(ctx.out()) {
    if (value.type == variant::int_type)
      return dynamic_formatter<>::format(42, ctx);
    return dynamic_formatter<>::format("foo", ctx);
  }
};
FMT_END_NAMESPACE

TEST(format_test, dynamic_formatter) {
  auto num = variant(42);
  auto str = variant("foo");
  EXPECT_EQ("42", fmt::format("{:d}", num));
  EXPECT_EQ("foo", fmt::format("{:s}", str));
  EXPECT_EQ(" 42 foo ", fmt::format("{:{}} {:{}}", num, 3, str, 4));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:{}}"), num), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{:{0}}"), num), format_error,
                   "cannot switch from automatic to manual argument indexing");
  EXPECT_THROW_MSG(fmt::format(runtime("{:+}"), str), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{:-}"), str), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{: }"), str), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{:#}"), str), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{:0}"), str), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{:.2}"), num), format_error,
                   "precision not allowed for this argument type");
}

namespace adl_test {
namespace fmt {
namespace detail {
struct foo {};
template <typename, typename OutputIt> void write(OutputIt, foo) = delete;
}  // namespace detail
}  // namespace fmt
}  // namespace adl_test

FMT_BEGIN_NAMESPACE
template <>
struct formatter<adl_test::fmt::detail::foo> : formatter<std::string> {
  template <typename FormatContext>
  auto format(adl_test::fmt::detail::foo, FormatContext& ctx)
      -> decltype(ctx.out()) {
    return formatter<std::string>::format("foo", ctx);
  }
};
FMT_END_NAMESPACE

TEST(format_test, to_string) {
  EXPECT_EQ("42", fmt::to_string(42));
  EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));
  EXPECT_EQ("foo", fmt::to_string(adl_test::fmt::detail::foo()));

  enum test_enum2 : unsigned char { test_value };
  EXPECT_EQ("0", fmt::to_string(test_value));
}

TEST(format_test, output_iterators) {
  std::list<char> out;
  fmt::format_to(std::back_inserter(out), "{}", 42);
  EXPECT_EQ("42", std::string(out.begin(), out.end()));
  std::stringstream s;
  fmt::format_to(std::ostream_iterator<char>(s), "{}", 42);
  EXPECT_EQ("42", s.str());
}

TEST(format_test, formatted_size) {
  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
}

TEST(format_test, format_to_no_args) {
  std::string s;
  fmt::format_to(std::back_inserter(s), "test");
  EXPECT_EQ("test", s);
}

TEST(format_test, format_to) {
  std::string s;
  fmt::format_to(std::back_inserter(s), "part{0}", 1);
  EXPECT_EQ("part1", s);
  fmt::format_to(std::back_inserter(s), "part{0}", 2);
  EXPECT_EQ("part1part2", s);
}

TEST(format_test, format_to_memory_buffer) {
  auto buf = fmt::basic_memory_buffer<char, 100>();
  fmt::format_to(fmt::appender(buf), "{}", "foo");
  EXPECT_EQ("foo", to_string(buf));
}

TEST(format_test, format_to_vector) {
  std::vector<char> v;
  fmt::format_to(std::back_inserter(v), "{}", "foo");
  EXPECT_EQ(string_view(v.data(), v.size()), "foo");
}

struct nongrowing_container {
  using value_type = char;
  void push_back(char) { throw std::runtime_error("can't take it any more"); }
};

TEST(format_test, format_to_propagates_exceptions) {
  auto c = nongrowing_container();
  EXPECT_THROW(fmt::format_to(std::back_inserter(c), "{}", 42),
               std::runtime_error);
}

TEST(format_test, format_to_n) {
  char buffer[4];
  buffer[3] = 'x';
  auto result = fmt::format_to_n(buffer, 3, "{}", 12345);
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ("123x", fmt::string_view(buffer, 4));

  result = fmt::format_to_n(buffer, 3, "{:s}", "foobar");
  EXPECT_EQ(6u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ("foox", fmt::string_view(buffer, 4));

  buffer[0] = 'x';
  buffer[1] = 'x';
  buffer[2] = 'x';
  result = fmt::format_to_n(buffer, 3, "{}", 'A');
  EXPECT_EQ(1u, result.size);
  EXPECT_EQ(buffer + 1, result.out);
  EXPECT_EQ("Axxx", fmt::string_view(buffer, 4));

  result = fmt::format_to_n(buffer, 3, "{}{} ", 'B', 'C');
  EXPECT_EQ(3u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ("BC x", fmt::string_view(buffer, 4));

  result = fmt::format_to_n(buffer, 4, "{}", "ABCDE");
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ("ABCD", fmt::string_view(buffer, 4));

  buffer[3] = 'x';
  result = fmt::format_to_n(buffer, 3, "{}", std::string(1000, '*'));
  EXPECT_EQ(1000u, result.size);
  EXPECT_EQ("***x", fmt::string_view(buffer, 4));
}

struct test_output_iterator {
  char* data;

  using iterator_category = std::output_iterator_tag;
  using value_type = void;
  using difference_type = void;
  using pointer = void;
  using reference = void;

  test_output_iterator& operator++() {
    ++data;
    return *this;
  }
  test_output_iterator operator++(int) {
    auto tmp = *this;
    ++data;
    return tmp;
  }
  char& operator*() { return *data; }
};

TEST(format_test, format_to_n_output_iterator) {
  char buf[10] = {};
  fmt::format_to_n(test_output_iterator{buf}, 10, "{}", 42);
  EXPECT_STREQ(buf, "42");
}

#if FMT_USE_CONSTEXPR
struct test_error_handler {
  const char*& error;

  FMT_CONSTEXPR test_error_handler(const char*& err) : error(err) {}

  FMT_CONSTEXPR test_error_handler(const test_error_handler& other)
      : error(other.error) {}

  FMT_CONSTEXPR void on_error(const char* message) {
    if (!error) error = message;
  }
};

FMT_CONSTEXPR size_t len(const char* s) {
  size_t len = 0;
  while (*s++) ++len;
  return len;
}

FMT_CONSTEXPR bool equal(const char* s1, const char* s2) {
  if (!s1 || !s2) return s1 == s2;
  while (*s1 && *s1 == *s2) {
    ++s1;
    ++s2;
  }
  return *s1 == *s2;
}

template <typename... Args>
FMT_CONSTEXPR bool test_error(const char* fmt, const char* expected_error) {
  const char* actual_error = nullptr;
  auto s = string_view(fmt, len(fmt));
  auto checker =
      fmt::detail::format_string_checker<char, test_error_handler, Args...>(
          s, test_error_handler(actual_error));
  fmt::detail::parse_format_string<true>(s, checker);
  return equal(actual_error, expected_error);
}

#  define EXPECT_ERROR_NOARGS(fmt, error) \
    static_assert(test_error(fmt, error), "")
#  define EXPECT_ERROR(fmt, error, ...) \
    static_assert(test_error<__VA_ARGS__>(fmt, error), "")

TEST(format_test, format_string_errors) {
  EXPECT_ERROR_NOARGS("foo", nullptr);
  EXPECT_ERROR_NOARGS("}", "unmatched '}' in format string");
  EXPECT_ERROR("{0:s", "unknown format specifier", date);
#  if !FMT_MSC_VER || FMT_MSC_VER >= 1916
  // This causes an detail compiler error in MSVC2017.
  EXPECT_ERROR("{:{<}", "invalid fill character '{'", int);
  EXPECT_ERROR("{:10000000000}", "number is too big", int);
  EXPECT_ERROR("{:.10000000000}", "number is too big", int);
  EXPECT_ERROR_NOARGS("{:x}", "argument not found");
  EXPECT_ERROR("{:+}", "format specifier requires numeric argument",
               const char*);
  EXPECT_ERROR("{:-}", "format specifier requires numeric argument",
               const char*);
  EXPECT_ERROR("{:#}", "format specifier requires numeric argument",
               const char*);
  EXPECT_ERROR("{: }", "format specifier requires numeric argument",
               const char*);
  EXPECT_ERROR("{:0}", "format specifier requires numeric argument",
               const char*);
  EXPECT_ERROR("{:+}", "format specifier requires signed argument", unsigned);
  EXPECT_ERROR("{:-}", "format specifier requires signed argument", unsigned);
  EXPECT_ERROR("{: }", "format specifier requires signed argument", unsigned);
  EXPECT_ERROR("{:{}}", "argument not found", int);
  EXPECT_ERROR("{:.{}}", "argument not found", double);
  EXPECT_ERROR("{:.2}", "precision not allowed for this argument type", int);
  EXPECT_ERROR("{:s}", "invalid type specifier", int);
  EXPECT_ERROR("{:s}", "invalid type specifier", char);
  EXPECT_ERROR("{:+}", "invalid format specifier for char", char);
  EXPECT_ERROR("{:s}", "invalid type specifier", double);
  EXPECT_ERROR("{:d}", "invalid type specifier", const char*);
  EXPECT_ERROR("{:d}", "invalid type specifier", std::string);
  EXPECT_ERROR("{:s}", "invalid type specifier", void*);
#  else
  fmt::print("warning: constexpr is broken in this version of MSVC\n");
#  endif
#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
  EXPECT_ERROR("{foo}", "named argument is not found", decltype("bar"_a = 42));
  EXPECT_ERROR("{foo}", "named argument is not found",
               decltype(fmt::arg("foo", 42)));
#  else
  EXPECT_ERROR("{foo}",
               "compile-time checks for named arguments require C++20 support",
               int);
#  endif
  EXPECT_ERROR_NOARGS("{10000000000}", "argument not found");
  EXPECT_ERROR_NOARGS("{0x}", "invalid format string");
  EXPECT_ERROR_NOARGS("{-}", "invalid format string");
  EXPECT_ERROR("{:{0x}}", "invalid format string", int);
  EXPECT_ERROR("{:{-}}", "invalid format string", int);
  EXPECT_ERROR("{:.{0x}}", "invalid format string", int);
  EXPECT_ERROR("{:.{-}}", "invalid format string", int);
  EXPECT_ERROR("{:.x}", "missing precision specifier", int);
  EXPECT_ERROR_NOARGS("{}", "argument not found");
  EXPECT_ERROR("{1}", "argument not found", int);
  EXPECT_ERROR("{1}{}",
               "cannot switch from manual to automatic argument indexing", int,
               int);
  EXPECT_ERROR("{}{1}",
               "cannot switch from automatic to manual argument indexing", int,
               int);
}

TEST(format_test, vformat_to) {
  using context = fmt::format_context;
  fmt::basic_format_arg<context> arg = fmt::detail::make_arg<context>(42);
  auto args = fmt::basic_format_args<context>(&arg, 1);
  auto s = std::string();
  fmt::vformat_to(std::back_inserter(s), "{}", args);
  EXPECT_EQ("42", s);
  s.clear();
  fmt::vformat_to(std::back_inserter(s), FMT_STRING("{}"), args);
  EXPECT_EQ("42", s);
}

#endif  // FMT_USE_CONSTEXPR

TEST(format_test, char_traits_is_not_ambiguous) {
  // Test that we don't inject detail names into the std namespace.
  using namespace std;
  auto c = char_traits<char>::char_type();
  (void)c;
#if __cplusplus >= 201103L
  auto s = std::string();
  auto lval = begin(s);
  (void)lval;
#endif
}

struct check_back_appender {};

FMT_BEGIN_NAMESPACE
template <> struct formatter<check_back_appender> {
  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename Context>
  auto format(check_back_appender, Context& ctx) -> decltype(ctx.out()) {
    auto out = ctx.out();
    static_assert(std::is_same<decltype(++out), decltype(out)&>::value,
                  "needs to satisfy weakly_incrementable");
    *out = 'y';
    return ++out;
  }
};
FMT_END_NAMESPACE

TEST(format_test, back_insert_slicing) {
  EXPECT_EQ(fmt::format("{}", check_back_appender{}), "y");
}

template <typename Char, typename T> bool check_enabled_formatter() {
  static_assert(std::is_default_constructible<fmt::formatter<T, Char>>::value,
                "");
  return true;
}

template <typename Char, typename... T> void check_enabled_formatters() {
  auto dummy = {check_enabled_formatter<Char, T>()...};
  (void)dummy;
}

TEST(format_test, test_formatters_enabled) {
  check_enabled_formatters<char, bool, char, signed char, unsigned char, short,
                           unsigned short, int, unsigned, long, unsigned long,
                           long long, unsigned long long, float, double,
                           long double, void*, const void*, char*, const char*,
                           std::string, std::nullptr_t>();
  check_enabled_formatters<wchar_t, bool, wchar_t, signed char, unsigned char,
                           short, unsigned short, int, unsigned, long,
                           unsigned long, long long, unsigned long long, float,
                           double, long double, void*, const void*, wchar_t*,
                           const wchar_t*, std::wstring, std::nullptr_t>();
}

TEST(format_int_test, data) {
  fmt::format_int format_int(42);
  EXPECT_EQ("42", std::string(format_int.data(), format_int.size()));
}

TEST(format_int_test, format_int) {
  EXPECT_EQ("42", fmt::format_int(42).str());
  EXPECT_EQ(2u, fmt::format_int(42).size());
  EXPECT_EQ("-42", fmt::format_int(-42).str());
  EXPECT_EQ(3u, fmt::format_int(-42).size());
  EXPECT_EQ("42", fmt::format_int(42ul).str());
  EXPECT_EQ("-42", fmt::format_int(-42l).str());
  EXPECT_EQ("42", fmt::format_int(42ull).str());
  EXPECT_EQ("-42", fmt::format_int(-42ll).str());
  std::ostringstream os;
  os << max_value<int64_t>();
  EXPECT_EQ(os.str(), fmt::format_int(max_value<int64_t>()).str());
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/.gitignore
================================================
# ignore artifacts from the build.sh script
build-*/



================================================
FILE: examples/libraries/fmt/test/fuzzing/CMakeLists.txt
================================================
# Copyright (c) 2019, Paul Dreik
# License: see LICENSE.rst in the fmt root directory

# Link in the main function. Useful for reproducing, kcov, gdb, afl, valgrind.
# (Note that libFuzzer can also reproduce, just pass it the files.)
option(FMT_FUZZ_LINKMAIN "Enables the reproduce mode, instead of libFuzzer" On)

# For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
# the fuzz targets, otherwise the CMake configuration step fails.
set(FMT_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")

# Adds a binary for reproducing, i.e. no fuzzing, just enables replaying data
# through the fuzzers.
function(add_fuzzer source)
  get_filename_component(basename ${source} NAME_WE)
  set(name ${basename}-fuzzer)
  add_executable(${name} ${source} fuzzer-common.h)
  if (FMT_FUZZ_LINKMAIN)
    target_sources(${name} PRIVATE main.cc)
  endif ()
  target_link_libraries(${name} PRIVATE fmt)
  if (FMT_FUZZ_LDFLAGS)
    target_link_libraries(${name} PRIVATE ${FMT_FUZZ_LDFLAGS})
  endif ()
  target_compile_features(${name} PRIVATE cxx_generic_lambdas)
endfunction()

foreach (source chrono-duration.cc float.cc named-arg.cc one-arg.cc two-args.cc)
  add_fuzzer(${source})
endforeach ()


================================================
FILE: examples/libraries/fmt/test/fuzzing/README.md
================================================
# Running the fuzzers locally

There is a [helper script](build.sh) to build the fuzzers, which has only been
tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on
Windows (using clang>=8) or on Mac, but the script will probably not work out of
the box.

Something along
```sh
mkdir build
cd build
export CXX=clang++
export CXXFLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
cmake .. -DFMT_SAFE_DURATION_CAST=On -DFMT_FUZZ=On -DFMT_FUZZ_LINKMAIN=Off -DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
cmake --build .
```
should work to build the fuzzers for all platforms which clang supports.

Execute a fuzzer with for instance
```sh
cd build
export UBSAN_OPTIONS=halt_on_error=1
mkdir out_chrono
bin/fuzzer_chrono_duration out_chrono
```


================================================
FILE: examples/libraries/fmt/test/fuzzing/build.sh
================================================
#!/bin/sh
#
# Creates fuzzer builds of various kinds
# - oss-fuzz emulated mode (makes sure a simulated invocation by oss-fuzz works)
# - libFuzzer build (you will need clang)
# - afl build (you will need afl)
#
#
# Copyright (c) 2019 Paul Dreik
#
# For the license information refer to format.h.

set -e
me=$(basename $0)
root=$(readlink -f "$(dirname "$0")/../..")


echo $me: root=$root

here=$(pwd)

CXXFLAGSALL="-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
CMAKEFLAGSALL="$root -GNinja -DCMAKE_BUILD_TYPE=Debug -DFMT_DOC=Off -DFMT_TEST=Off -DFMT_FUZZ=On -DCMAKE_CXX_STANDARD=17"

# For performance analysis of the fuzzers.
builddir=$here/build-fuzzers-perfanalysis
mkdir -p $builddir
cd $builddir
CXX="ccache g++" CXXFLAGS="$CXXFLAGSALL -g" cmake \
$CMAKEFLAGSALL \
-DFMT_FUZZ_LINKMAIN=On \
-DCMAKE_BUILD_TYPE=Release

cmake --build $builddir

# Builds the fuzzers as oss-fuzz does.
builddir=$here/build-fuzzers-ossfuzz
mkdir -p $builddir
cd $builddir
CXX="clang++" \
CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link" cmake \
cmake $CMAKEFLAGSALL \
-DFMT_FUZZ_LINKMAIN=Off \
-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"

cmake --build $builddir


# Builds fuzzers for local fuzzing with libfuzzer with asan+usan.
builddir=$here/build-fuzzers-libfuzzer
mkdir -p $builddir
cd $builddir
CXX="clang++" \
CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link,address,undefined" cmake \
cmake $CMAKEFLAGSALL \
-DFMT_FUZZ_LINKMAIN=Off \
-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"

cmake --build $builddir

# Builds a fast fuzzer for making coverage fast.
builddir=$here/build-fuzzers-fast
mkdir -p $builddir
cd $builddir
CXX="clang++" \
CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link -O3" cmake \
cmake $CMAKEFLAGSALL \
-DFMT_FUZZ_LINKMAIN=Off \
-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" \
 -DCMAKE_BUILD_TYPE=Release

cmake --build $builddir


# Builds fuzzers for local fuzzing with afl.
builddir=$here/build-fuzzers-afl
mkdir -p $builddir
cd $builddir
CXX="afl-g++" \
CXXFLAGS="$CXXFLAGSALL -fsanitize=address,undefined" \
cmake $CMAKEFLAGSALL \
-DFMT_FUZZ_LINKMAIN=On

cmake --build $builddir


echo $me: all good



================================================
FILE: examples/libraries/fmt/test/fuzzing/chrono-duration.cc
================================================
// Copyright (c) 2019, Paul Dreik
// For the license information refer to format.h.

#include <cstdint>
#include <fmt/chrono.h>

#include "fuzzer-common.h"

template <typename Period, typename Rep>
void invoke_inner(fmt::string_view format_str, Rep rep) {
  auto value = std::chrono::duration<Rep, Period>(rep);
  try {
#if FMT_FUZZ_FORMAT_TO_STRING
    std::string message = fmt::format(format_str, value);
#else
    fmt::memory_buffer buf;
    fmt::format_to(buf, format_str, value);
#endif
  } catch (std::exception&) {
  }
}

// Rep is a duration's representation type.
template <typename Rep>
void invoke_outer(const uint8_t* data, size_t size, int period) {
  // Always use a fixed location of the data.
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
  if (size <= fixed_size + 1) return;

  const Rep rep = assign_from_buf<Rep>(data);
  data += fixed_size;
  size -= fixed_size;

  // data is already allocated separately in libFuzzer so reading past the end 
  // will most likely be detected anyway.
  const auto format_str = fmt::string_view(as_chars(data), size);

  // yocto, zepto, zetta and yotta are not handled.
  switch (period) {
  case 1:
    invoke_inner<std::atto>(format_str, rep);
    break;
  case 2:
    invoke_inner<std::femto>(format_str, rep);
    break;
  case 3:
    invoke_inner<std::pico>(format_str, rep);
    break;
  case 4:
    invoke_inner<std::nano>(format_str, rep);
    break;
  case 5:
    invoke_inner<std::micro>(format_str, rep);
    break;
  case 6:
    invoke_inner<std::milli>(format_str, rep);
    break;
  case 7:
    invoke_inner<std::centi>(format_str, rep);
    break;
  case 8:
    invoke_inner<std::deci>(format_str, rep);
    break;
  case 9:
    invoke_inner<std::deca>(format_str, rep);
    break;
  case 10:
    invoke_inner<std::kilo>(format_str, rep);
    break;
  case 11:
    invoke_inner<std::mega>(format_str, rep);
    break;
  case 12:
    invoke_inner<std::giga>(format_str, rep);
    break;
  case 13:
    invoke_inner<std::tera>(format_str, rep);
    break;
  case 14:
    invoke_inner<std::peta>(format_str, rep);
    break;
  case 15:
    invoke_inner<std::exa>(format_str, rep);
    break;
  }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  if (size <= 4)  return 0;

  const auto representation = data[0];
  const auto period = data[1];
  data += 2;
  size -= 2;

  switch (representation) {
  case 1:
    invoke_outer<char>(data, size, period);
    break;
  case 2:
    invoke_outer<signed char>(data, size, period);
    break;
  case 3:
    invoke_outer<unsigned char>(data, size, period);
    break;
  case 4:
    invoke_outer<short>(data, size, period);
    break;
  case 5:
    invoke_outer<unsigned short>(data, size, period);
    break;
  case 6:
    invoke_outer<int>(data, size, period);
    break;
  case 7:
    invoke_outer<unsigned int>(data, size, period);
    break;
  case 8:
    invoke_outer<long>(data, size, period);
    break;
  case 9:
    invoke_outer<unsigned long>(data, size, period);
    break;
  case 10:
    invoke_outer<float>(data, size, period);
    break;
  case 11:
    invoke_outer<double>(data, size, period);
    break;
  case 12:
    invoke_outer<long double>(data, size, period);
    break;
  }
  return 0;
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/float.cc
================================================
// A fuzzer for floating-point formatter.
// For the license information refer to format.h.

#include <cstdint>
#include <cstdlib>
#include <stdexcept>
#include <limits>
#include <fmt/format.h>

#include "fuzzer-common.h"

void check_round_trip(fmt::string_view format_str, double value) {
  auto buffer = fmt::memory_buffer();
  fmt::format_to(buffer, format_str, value);

  if (std::isnan(value)) {
    auto nan = std::signbit(value) ? "-nan" : "nan";
    if (fmt::string_view(buffer.data(), buffer.size()) != nan)
      throw std::runtime_error("round trip failure");
    return;
  }

  buffer.push_back('\0');
  char* ptr = nullptr;
  if (std::strtod(buffer.data(), &ptr) != value)
    throw std::runtime_error("round trip failure");
  if (ptr + 1 != buffer.end())
    throw std::runtime_error("unparsed output");
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  if (size <= sizeof(double) || !std::numeric_limits<double>::is_iec559)
    return 0;
  check_round_trip("{}", assign_from_buf<double>(data));
  // A larger than necessary precision is used to trigger the fallback
  // formatter.
  check_round_trip("{:.50g}", assign_from_buf<double>(data));
  return 0;
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/fuzzer-common.h
================================================
// Copyright (c) 2019, Paul Dreik
// For the license information refer to format.h.

#ifndef FUZZER_COMMON_H
#define FUZZER_COMMON_H

#include <cstdint>      // std::uint8_t
#include <cstring>      // memcpy
#include <vector>

#include <fmt/core.h>

// One can format to either a string, or a buffer. The latter is faster, but
// one may be interested in formatting to a string instead to verify it works
// as intended. To avoid a combinatoric explosion, select this at compile time
// instead of dynamically from the fuzz data.
#define FMT_FUZZ_FORMAT_TO_STRING 0

// If {fmt} is given a buffer that is separately allocated, chances that address
// sanitizer detects out of bound reads is much higher. However, it slows down
// the fuzzing.
#define FMT_FUZZ_SEPARATE_ALLOCATION 1

// The size of the largest possible type in use.
// To let the the fuzzer mutation be efficient at cross pollinating between
// different types, use a fixed size format. The same bit pattern, interpreted
// as another type, is likely interesting.
constexpr auto fixed_size = 16;

// Casts data to a char pointer.
template <typename T> inline const char* as_chars(const T* data) {
  return reinterpret_cast<const char*>(data);
}

// Casts data to a byte pointer.
template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
  return reinterpret_cast<const std::uint8_t*>(data);
}

// Blits bytes from data to form an (assumed trivially constructible) object
// of type Item.
template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {
  auto item = Item();
  std::memcpy(&item, data, sizeof(Item));
  return item;
}

// Reads a boolean value by looking at the first byte from data.
template <> inline bool assign_from_buf<bool>(const std::uint8_t* data) {
  return *data != 0;
}

struct data_to_string {
#if FMT_FUZZ_SEPARATE_ALLOCATION
  std::vector<char> buffer;

  data_to_string(const uint8_t* data, size_t size, bool add_terminator = false)
      : buffer(size + (add_terminator ? 1 : 0)) {
    std::memcpy(buffer.data(), data, size);
  }

  fmt::string_view get() const { return {buffer.data(), buffer.size()}; }
#else
  fmt::string_view sv;

  data_to_string(const uint8_t* data, size_t size, bool = false)
      : str(as_chars(data), size) {}

  fmt::string_view get() const { return sv; }
#endif

  const char* data() const { return get().data(); }
};

#endif  // FUZZER_COMMON_H


================================================
FILE: examples/libraries/fmt/test/fuzzing/main.cc
================================================
#include <cassert>
#include <fstream>
#include <vector>

#include "fuzzer-common.h"

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);

int main(int argc, char** argv) {
  for (int i = 1; i < argc; ++i) {
    std::ifstream in(argv[i]);
    assert(in);
    in.seekg(0, std::ios_base::end);
    const auto size = in.tellg();
    assert(size >= 0);
    in.seekg(0, std::ios_base::beg);
    std::vector<char> buf(static_cast<size_t>(size));
    in.read(buf.data(), size);
    assert(in.gcount() == size);
    LLVMFuzzerTestOneInput(as_bytes(buf.data()), buf.size());
  }
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/named-arg.cc
================================================
// Copyright (c) 2019, Paul Dreik
// For the license information refer to format.h.

#include <cstdint>
#include <type_traits>
#include <vector>
#include <fmt/chrono.h>

#include "fuzzer-common.h"

template <typename T>
void invoke_fmt(const uint8_t* data, size_t size, unsigned arg_name_size) {
  static_assert(sizeof(T) <= fixed_size, "fixed_size too small");
  if (size <= fixed_size) return;
  const T value = assign_from_buf<T>(data);
  data += fixed_size;
  size -= fixed_size;

  if (arg_name_size <= 0 || arg_name_size >= size) return;
  data_to_string arg_name(data, arg_name_size, true);
  data += arg_name_size;
  size -= arg_name_size;

  data_to_string format_str(data, size);
  try {
#if FMT_FUZZ_FORMAT_TO_STRING
    std::string message =
      fmt::format(format_str.get(), fmt::arg(arg_name.data(), value));
#else
    fmt::memory_buffer out;
    fmt::format_to(out, format_str.get(), fmt::arg(arg_name.data(), value));
#endif
  } catch (std::exception&) {
  }
}

// For dynamic dispatching to an explicit instantiation.
template <typename Callback> void invoke(int type, Callback callback) {
  switch (type) {
  case 0:
    callback(bool());
    break;
  case 1:
    callback(char());
    break;
  case 2:
    using sc = signed char;
    callback(sc());
    break;
  case 3:
    using uc = unsigned char;
    callback(uc());
    break;
  case 4:
    callback(short());
    break;
  case 5:
    using us = unsigned short;
    callback(us());
    break;
  case 6:
    callback(int());
    break;
  case 7:
    callback(unsigned());
    break;
  case 8:
    callback(long());
    break;
  case 9:
    using ul = unsigned long;
    callback(ul());
    break;
  case 10:
    callback(float());
    break;
  case 11:
    callback(double());
    break;
  case 12:
    using LD = long double;
    callback(LD());
    break;
  }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  if (size <= 3) return 0;

  // Switch types depending on the first byte of the input.
  const auto type = data[0] & 0x0F;
  const unsigned arg_name_size = (data[0] & 0xF0) >> 4;
  data++;
  size--;

  invoke(type, [=](auto arg) {
    invoke_fmt<decltype(arg)>(data, size, arg_name_size);
  });
  return 0;
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/one-arg.cc
================================================
// Copyright (c) 2019, Paul Dreik
// For the license information refer to format.h.

#include <cstdint>
#include <exception>
#include <fmt/chrono.h>

#include "fuzzer-common.h"

template <typename T, typename Repr>
const T* from_repr(const Repr& r) { return &r; }

template <>
const std::tm* from_repr<std::tm>(const std::time_t& t) {
  return std::localtime(&t);
}

template <typename T, typename Repr = T>
void invoke_fmt(const uint8_t* data, size_t size) {
  static_assert(sizeof(Repr) <= fixed_size, "Nfixed is too small");
  if (size <= fixed_size) return;
  auto repr = assign_from_buf<Repr>(data);
  const T* value = from_repr<T>(repr);
  if (!value) return;
  data += fixed_size;
  size -= fixed_size;
  data_to_string format_str(data, size);
  try {
#if FMT_FUZZ_FORMAT_TO_STRING
    std::string message = fmt::format(format_str.get(), *value);
#else
    fmt::memory_buffer message;
    fmt::format_to(message, format_str.get(), *value);
#endif
  } catch (std::exception&) {
  }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  if (size <= 3) return 0;

  const auto first = data[0];
  data++;
  size--;

  switch (first) {
  case 0:
    invoke_fmt<bool>(data, size);
    break;
  case 1:
    invoke_fmt<char>(data, size);
    break;
  case 2:
    invoke_fmt<unsigned char>(data, size);
    break;
  case 3:
    invoke_fmt<signed char>(data, size);
    break;
  case 4:
    invoke_fmt<short>(data, size);
    break;
  case 5:
    invoke_fmt<unsigned short>(data, size);
    break;
  case 6:
    invoke_fmt<int>(data, size);
    break;
  case 7:
    invoke_fmt<unsigned int>(data, size);
    break;
  case 8:
    invoke_fmt<long>(data, size);
    break;
  case 9:
    invoke_fmt<unsigned long>(data, size);
    break;
  case 10:
    invoke_fmt<float>(data, size);
    break;
  case 11:
    invoke_fmt<double>(data, size);
    break;
  case 12:
    invoke_fmt<long double>(data, size);
    break;
  case 13:
    invoke_fmt<std::tm, std::time_t>(data, size);
    break;
  }
  return 0;
}


================================================
FILE: examples/libraries/fmt/test/fuzzing/two-args.cc
================================================
// Copyright (c) 2019, Paul Dreik
// For the license information refer to format.h.

#include <cstdint>
#include <exception>
#include <string>
#include <fmt/format.h>

#include "fuzzer-common.h"

template <typename Item1, typename Item2>
void invoke_fmt(const uint8_t* data, size_t size) {
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
  if (size <= fixed_size + fixed_size) return;

  const Item1 item1 = assign_from_buf<Item1>(data);
  data += fixed_size;
  size -= fixed_size;

  const Item2 item2 = assign_from_buf<Item2>(data);
  data += fixed_size;
  size -= fixed_size;

  auto format_str = fmt::string_view(as_chars(data), size);
#if FMT_FUZZ_FORMAT_TO_STRING
  std::string message = fmt::format(format_str, item1, item2);
#else
  fmt::memory_buffer message;
  fmt::format_to(message, format_str, item1, item2);
#endif
}

// For dynamic dispatching to an explicit instantiation.
template <typename Callback> void invoke(int index, Callback callback) {
  switch (index) {
  case 0:
    callback(bool());
    break;
  case 1:
    callback(char());
    break;
  case 2:
    using sc = signed char;
    callback(sc());
    break;
  case 3:
    using uc = unsigned char;
    callback(uc());
    break;
  case 4:
    callback(short());
    break;
  case 5:
    using us = unsigned short;
    callback(us());
    break;
  case 6:
    callback(int());
    break;
  case 7:
    callback(unsigned());
    break;
  case 8:
    callback(long());
    break;
  case 9:
    using ul = unsigned long;
    callback(ul());
    break;
  case 10:
    callback(float());
    break;
  case 11:
    callback(double());
    break;
  case 12:
    using LD = long double;
    callback(LD());
    break;
  case 13:
    using ptr = void*;
    callback(ptr());
    break;
  }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  if (size <= 3) return 0;

  // Switch types depending on the first byte of the input.
  const auto type1 = data[0] & 0x0F;
  const auto type2 = (data[0] & 0xF0) >> 4;
  data++;
  size--;
  try {
    invoke(type1, [=](auto param1) {
      invoke(type2, [=](auto param2) {
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
      });
    });
  } catch (std::exception&) {
  }
  return 0;
}


================================================
FILE: examples/libraries/fmt/test/gtest/.clang-format
================================================
# Disable clang-format here
DisableFormat: true
SortIncludes: Never


================================================
FILE: examples/libraries/fmt/test/gtest/CMakeLists.txt
================================================
#------------------------------------------------------------------------------
# Build the google test library

# We compile Google Test ourselves instead of using pre-compiled libraries.
# See the Google Test FAQ "Why is it not recommended to install a
# pre-compiled copy of Google Test (for example, into /usr/local)?"
# at http://code.google.com/p/googletest/wiki/FAQ for more details.
add_library(gtest STATIC
  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
target_compile_definitions(gtest PUBLIC GTEST_HAS_STD_WSTRING=1)
target_include_directories(gtest SYSTEM PUBLIC .)

find_package(Threads)
if (Threads_FOUND)
  target_link_libraries(gtest ${CMAKE_THREAD_LIBS_INIT})
else ()
  target_compile_definitions(gtest PUBLIC GTEST_HAS_PTHREAD=0)
endif ()

if (MSVC)
  # Disable MSVC warnings of _CRT_INSECURE_DEPRECATE functions.
  target_compile_definitions(gtest PRIVATE _CRT_SECURE_NO_WARNINGS)
  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    # Disable MSVC warnings of POSIX functions.
    target_compile_options(gtest PUBLIC -Wno-deprecated-declarations)
  endif ()
endif ()

# Silence MSVC tr1 deprecation warning in gmock.
target_compile_definitions(gtest
  PUBLIC _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING=1)


================================================
FILE: examples/libraries/fmt/test/gtest/gmock/gmock.h
================================================
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This is the main header file a user should include.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_

// This file implements the following syntax:
//
//   ON_CALL(mock_object, Method(...))
//     .With(...) ?
//     .WillByDefault(...);
//
// where With() is optional and WillByDefault() must appear exactly
// once.
//
//   EXPECT_CALL(mock_object, Method(...))
//     .With(...) ?
//     .Times(...) ?
//     .InSequence(...) *
//     .WillOnce(...) *
//     .WillRepeatedly(...) ?
//     .RetiresOnSaturation() ? ;
//
// where all clauses are optional and WillOnce() can be repeated.

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// The ACTION* family of macros can be used in a namespace scope to
// define custom actions easily.  The syntax:
//
//   ACTION(name) { statements; }
//
// will define an action with the given name that executes the
// statements.  The value returned by the statements will be used as
// the return value of the action.  Inside the statements, you can
// refer to the K-th (0-based) argument of the mock function by
// 'argK', and refer to its type by 'argK_type'.  For example:
//
//   ACTION(IncrementArg1) {
//     arg1_type temp = arg1;
//     return ++(*temp);
//   }
//
// allows you to write
//
//   ...WillOnce(IncrementArg1());
//
// You can also refer to the entire argument tuple and its type by
// 'args' and 'args_type', and refer to the mock function type and its
// return type by 'function_type' and 'return_type'.
//
// Note that you don't need to specify the types of the mock function
// arguments.  However rest assured that your code is still type-safe:
// you'll get a compiler error if *arg1 doesn't support the ++
// operator, or if the type of ++(*arg1) isn't compatible with the
// mock function's return type, for example.
//
// Sometimes you'll want to parameterize the action.   For that you can use
// another macro:
//
//   ACTION_P(name, param_name) { statements; }
//
// For example:
//
//   ACTION_P(Add, n) { return arg0 + n; }
//
// will allow you to write:
//
//   ...WillOnce(Add(5));
//
// Note that you don't need to provide the type of the parameter
// either.  If you need to reference the type of a parameter named
// 'foo', you can write 'foo_type'.  For example, in the body of
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
// of 'n'.
//
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
// multi-parameter actions.
//
// For the purpose of typing, you can view
//
//   ACTION_Pk(Foo, p1, ..., pk) { ... }
//
// as shorthand for
//
//   template <typename p1_type, ..., typename pk_type>
//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
//
// In particular, you can provide the template type arguments
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
// although usually you can rely on the compiler to infer the types
// for you automatically.  You can assign the result of expression
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
// pk_type>.  This can be useful when composing actions.
//
// You can also overload actions with different numbers of parameters:
//
//   ACTION_P(Plus, a) { ... }
//   ACTION_P2(Plus, a, b) { ... }
//
// While it's tempting to always use the ACTION* macros when defining
// a new action, you should also consider implementing ActionInterface
// or using MakePolymorphicAction() instead, especially if you need to
// use the action a lot.  While these approaches require more work,
// they give you more control on the types of the mock function
// arguments and the action parameters, which in general leads to
// better compiler error messages that pay off in the long run.  They
// also allow overloading actions based on parameter types (as opposed
// to just based on the number of parameters).
//
// CAVEAT:
//
// ACTION*() can only be used in a namespace scope as templates cannot be
// declared inside of a local class.
// Users can, however, define any local functors (e.g. a lambda) that
// can be used as actions.
//
// MORE INFORMATION:
//
// To learn more about using these macros, please search for 'ACTION' on
// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_

#ifndef _WIN32_WCE
# include <errno.h>
#endif

#include <algorithm>
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file defines some utilities useful for implementing Google
// Mock.  They are subject to change without notice, so please DO NOT
// USE THEM IN USER CODE.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_

#include <stdio.h>
#include <ostream>  // NOLINT
#include <string>
#include <type_traits>
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Low-level types and utilities for porting Google Mock to various
// platforms.  All macros ending with _ and symbols defined in an
// internal namespace are subject to change without notice.  Code
// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
// end with _ are part of Google Mock's public API and can be used by
// code outside Google Mock.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_

#include <assert.h>
#include <stdlib.h>
#include <cstdint>
#include <iostream>

// Most of the utilities needed for porting Google Mock are also
// required for Google Test and are defined in gtest-port.h.
//
// Note to maintainers: to reduce code duplication, prefer adding
// portability utilities to Google Test's gtest-port.h instead of
// here, as Google Mock depends on Google Test.  Only add a utility
// here if it's truly specific to Google Mock.

#include "gtest/gtest.h"
// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_

// For MS Visual C++, check the compiler version. At least VS 2015 is
// required to compile Google Mock.
#if defined(_MSC_VER) && _MSC_VER < 1900
# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
#endif

// Macro for referencing flags.  This is public as we want the user to
// use this syntax to reference Google Mock flags.
#define GMOCK_FLAG(name) FLAGS_gmock_##name

#if !defined(GMOCK_DECLARE_bool_)

// Macros for declaring flags.
# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name)
# define GMOCK_DECLARE_string_(name) \
    extern GTEST_API_ ::std::string GMOCK_FLAG(name)

// Macros for defining flags.
# define GMOCK_DEFINE_bool_(name, default_val, doc) \
    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
# define GMOCK_DEFINE_int32_(name, default_val, doc) \
    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val)
# define GMOCK_DEFINE_string_(name, default_val, doc) \
    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)

#endif  // !defined(GMOCK_DECLARE_bool_)

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_

namespace testing {

template <typename>
class Matcher;

namespace internal {

// Silence MSVC C4100 (unreferenced formal parameter) and
// C4805('==': unsafe mix of type 'const int' and type 'const bool')
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
# pragma warning(disable:4805)
#endif

// Joins a vector of strings as if they are fields of a tuple; returns
// the joined string.
GTEST_API_ std::string JoinAsTuple(const Strings& fields);

// Converts an identifier name to a space-separated list of lower-case
// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
// treated as one word.  For example, both "FooBar123" and
// "foo_bar_123" are converted to "foo bar 123".
GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);

// GetRawPointer(p) returns the raw pointer underlying p when p is a
// smart pointer, or returns p itself when p is already a raw pointer.
// The following default implementation is for the smart pointer case.
template <typename Pointer>
inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
  return p.get();
}
// This overloaded version is for the raw pointer case.
template <typename Element>
inline Element* GetRawPointer(Element* p) { return p; }

// MSVC treats wchar_t as a native type usually, but treats it as the
// same as unsigned short when the compiler option /Zc:wchar_t- is
// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
// is a native type.
#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
// wchar_t is a typedef.
#else
# define GMOCK_WCHAR_T_IS_NATIVE_ 1
#endif

// In what follows, we use the term "kind" to indicate whether a type
// is bool, an integer type (excluding bool), a floating-point type,
// or none of them.  This categorization is useful for determining
// when a matcher argument type can be safely converted to another
// type in the implementation of SafeMatcherCast.
enum TypeKind {
  kBool, kInteger, kFloatingPoint, kOther
};

// KindOf<T>::value is the kind of type T.
template <typename T> struct KindOf {
  enum { value = kOther };  // The default kind.
};

// This macro declares that the kind of 'type' is 'kind'.
#define GMOCK_DECLARE_KIND_(type, kind) \
  template <> struct KindOf<type> { enum { value = kind }; }

GMOCK_DECLARE_KIND_(bool, kBool);

// All standard integer types.
GMOCK_DECLARE_KIND_(char, kInteger);
GMOCK_DECLARE_KIND_(signed char, kInteger);
GMOCK_DECLARE_KIND_(unsigned char, kInteger);
GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
GMOCK_DECLARE_KIND_(int, kInteger);
GMOCK_DECLARE_KIND_(unsigned int, kInteger);
GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT

#if GMOCK_WCHAR_T_IS_NATIVE_
GMOCK_DECLARE_KIND_(wchar_t, kInteger);
#endif

// All standard floating-point types.
GMOCK_DECLARE_KIND_(float, kFloatingPoint);
GMOCK_DECLARE_KIND_(double, kFloatingPoint);
GMOCK_DECLARE_KIND_(long double, kFloatingPoint);

#undef GMOCK_DECLARE_KIND_

// Evaluates to the kind of 'type'.
#define GMOCK_KIND_OF_(type) \
  static_cast< ::testing::internal::TypeKind>( \
      ::testing::internal::KindOf<type>::value)

// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
// is true if and only if arithmetic type From can be losslessly converted to
// arithmetic type To.
//
// It's the user's responsibility to ensure that both From and To are
// raw (i.e. has no CV modifier, is not a pointer, and is not a
// reference) built-in arithmetic types, kFromKind is the kind of
// From, and kToKind is the kind of To; the value is
// implementation-defined when the above pre-condition is violated.
template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
using LosslessArithmeticConvertibleImpl = std::integral_constant<
    bool,
    // clang-format off
      // Converting from bool is always lossless
      (kFromKind == kBool) ? true
      // Converting between any other type kinds will be lossy if the type
      // kinds are not the same.
    : (kFromKind != kToKind) ? false
    : (kFromKind == kInteger &&
       // Converting between integers of different widths is allowed so long
       // as the conversion does not go from signed to unsigned.
      (((sizeof(From) < sizeof(To)) &&
        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
       // Converting between integers of the same width only requires the
       // two types to have the same signedness.
       ((sizeof(From) == sizeof(To)) &&
        (std::is_signed<From>::value == std::is_signed<To>::value)))
       ) ? true
      // Floating point conversions are lossless if and only if `To` is at least
      // as wide as `From`.
    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
    : false
    // clang-format on
    >;

// LosslessArithmeticConvertible<From, To>::value is true if and only if
// arithmetic type From can be losslessly converted to arithmetic type To.
//
// It's the user's responsibility to ensure that both From and To are
// raw (i.e. has no CV modifier, is not a pointer, and is not a
// reference) built-in arithmetic types; the value is
// implementation-defined when the above pre-condition is violated.
template <typename From, typename To>
using LosslessArithmeticConvertible =
    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
                                      GMOCK_KIND_OF_(To), To>;

// This interface knows how to report a Google Mock failure (either
// non-fatal or fatal).
class FailureReporterInterface {
 public:
  // The type of a failure (either non-fatal or fatal).
  enum FailureType {
    kNonfatal, kFatal
  };

  virtual ~FailureReporterInterface() {}

  // Reports a failure that occurred at the given source file location.
  virtual void ReportFailure(FailureType type, const char* file, int line,
                             const std::string& message) = 0;
};

// Returns the failure reporter used by Google Mock.
GTEST_API_ FailureReporterInterface* GetFailureReporter();

// Asserts that condition is true; aborts the process with the given
// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
// as Google Mock might be used to mock the log sink itself.  We
// inline this function to prevent it from showing up in the stack
// trace.
inline void Assert(bool condition, const char* file, int line,
                   const std::string& msg) {
  if (!condition) {
    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
                                        file, line, msg);
  }
}
inline void Assert(bool condition, const char* file, int line) {
  Assert(condition, file, line, "Assertion failed.");
}

// Verifies that condition is true; generates a non-fatal failure if
// condition is false.
inline void Expect(bool condition, const char* file, int line,
                   const std::string& msg) {
  if (!condition) {
    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
                                        file, line, msg);
  }
}
inline void Expect(bool condition, const char* file, int line) {
  Expect(condition, file, line, "Expectation failed.");
}

// Severity level of a log.
enum LogSeverity {
  kInfo = 0,
  kWarning = 1
};

// Valid values for the --gmock_verbose flag.

// All logs (informational and warnings) are printed.
const char kInfoVerbosity[] = "info";
// Only warnings are printed.
const char kWarningVerbosity[] = "warning";
// No logs are printed.
const char kErrorVerbosity[] = "error";

// Returns true if and only if a log with the given severity is visible
// according to the --gmock_verbose flag.
GTEST_API_ bool LogIsVisible(LogSeverity severity);

// Prints the given message to stdout if and only if 'severity' >= the level
// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
// 0, also prints the stack trace excluding the top
// stack_frames_to_skip frames.  In opt mode, any positive
// stack_frames_to_skip is treated as 0, since we don't know which
// function calls will be inlined by the compiler and need to be
// conservative.
GTEST_API_ void Log(LogSeverity severity, const std::string& message,
                    int stack_frames_to_skip);

// A marker class that is used to resolve parameterless expectations to the
// correct overload. This must not be instantiable, to prevent client code from
// accidentally resolving to the overload; for example:
//
//    ON_CALL(mock, Method({}, nullptr))...
//
class WithoutMatchers {
 private:
  WithoutMatchers() {}
  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
};

// Internal use only: access the singleton instance of WithoutMatchers.
GTEST_API_ WithoutMatchers GetWithoutMatchers();

// Disable MSVC warnings for infinite recursion, since in this case the
// the recursion is unreachable.
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4717)
#endif

// Invalid<T>() is usable as an expression of type T, but will terminate
// the program with an assertion failure if actually run.  This is useful
// when a value of type T is needed for compilation, but the statement
// will not really be executed (or we don't care if the statement
// crashes).
template <typename T>
inline T Invalid() {
  Assert(false, "", -1, "Internal error: attempt to return invalid value");
  // This statement is unreachable, and would never terminate even if it
  // could be reached. It is provided only to placate compiler warnings
  // about missing return statements.
  return Invalid<T>();
}

#ifdef _MSC_VER
# pragma warning(pop)
#endif

// Given a raw type (i.e. having no top-level reference or const
// modifier) RawContainer that's either an STL-style container or a
// native array, class StlContainerView<RawContainer> has the
// following members:
//
//   - type is a type that provides an STL-style container view to
//     (i.e. implements the STL container concept for) RawContainer;
//   - const_reference is a type that provides a reference to a const
//     RawContainer;
//   - ConstReference(raw_container) returns a const reference to an STL-style
//     container view to raw_container, which is a RawContainer.
//   - Copy(raw_container) returns an STL-style container view of a
//     copy of raw_container, which is a RawContainer.
//
// This generic version is used when RawContainer itself is already an
// STL-style container.
template <class RawContainer>
class StlContainerView {
 public:
  typedef RawContainer type;
  typedef const type& const_reference;

  static const_reference ConstReference(const RawContainer& container) {
    static_assert(!std::is_const<RawContainer>::value,
                  "RawContainer type must not be const");
    return container;
  }
  static type Copy(const RawContainer& container) { return container; }
};

// This specialization is used when RawContainer is a native array type.
template <typename Element, size_t N>
class StlContainerView<Element[N]> {
 public:
  typedef typename std::remove_const<Element>::type RawElement;
  typedef internal::NativeArray<RawElement> type;
  // NativeArray<T> can represent a native array either by value or by
  // reference (selected by a constructor argument), so 'const type'
  // can be used to reference a const native array.  We cannot
  // 'typedef const type& const_reference' here, as that would mean
  // ConstReference() has to return a reference to a local variable.
  typedef const type const_reference;

  static const_reference ConstReference(const Element (&array)[N]) {
    static_assert(std::is_same<Element, RawElement>::value,
                  "Element type must not be const");
    return type(array, N, RelationToSourceReference());
  }
  static type Copy(const Element (&array)[N]) {
    return type(array, N, RelationToSourceCopy());
  }
};

// This specialization is used when RawContainer is a native array
// represented as a (pointer, size) tuple.
template <typename ElementPointer, typename Size>
class StlContainerView< ::std::tuple<ElementPointer, Size> > {
 public:
  typedef typename std::remove_const<
      typename std::pointer_traits<ElementPointer>::element_type>::type
      RawElement;
  typedef internal::NativeArray<RawElement> type;
  typedef const type const_reference;

  static const_reference ConstReference(
      const ::std::tuple<ElementPointer, Size>& array) {
    return type(std::get<0>(array), std::get<1>(array),
                RelationToSourceReference());
  }
  static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy());
  }
};

// The following specialization prevents the user from instantiating
// StlContainer with a reference type.
template <typename T> class StlContainerView<T&>;

// A type transform to remove constness from the first part of a pair.
// Pairs like that are used as the value_type of associative containers,
// and this transform produces a similar but assignable pair.
template <typename T>
struct RemoveConstFromKey {
  typedef T type;
};

// Partially specialized to remove constness from std::pair<const K, V>.
template <typename K, typename V>
struct RemoveConstFromKey<std::pair<const K, V> > {
  typedef std::pair<K, V> type;
};

// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to
// reduce code size.
GTEST_API_ void IllegalDoDefault(const char* file, int line);

template <typename F, typename Tuple, size_t... Idx>
auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
}

// Apply the function to a tuple of arguments.
template <typename F, typename Tuple>
auto Apply(F&& f, Tuple&& args) -> decltype(
    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
              MakeIndexSequence<std::tuple_size<
                  typename std::remove_reference<Tuple>::type>::value>())) {
  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
                   MakeIndexSequence<std::tuple_size<
                       typename std::remove_reference<Tuple>::type>::value>());
}

// Template struct Function<F>, where F must be a function type, contains
// the following typedefs:
//
//   Result:               the function's return type.
//   Arg<N>:               the type of the N-th argument, where N starts with 0.
//   ArgumentTuple:        the tuple type consisting of all parameters of F.
//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
//                         parameters of F.
//   MakeResultVoid:       the function type obtained by substituting void
//                         for the return type of F.
//   MakeResultIgnoredValue:
//                         the function type obtained by substituting Something
//                         for the return type of F.
template <typename T>
struct Function;

template <typename R, typename... Args>
struct Function<R(Args...)> {
  using Result = R;
  static constexpr size_t ArgumentCount = sizeof...(Args);
  template <size_t I>
  using Arg = ElemFromList<I, Args...>;
  using ArgumentTuple = std::tuple<Args...>;
  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
  using MakeResultVoid = void(Args...);
  using MakeResultIgnoredValue = IgnoredValue(Args...);
};

template <typename R, typename... Args>
constexpr size_t Function<R(Args...)>::ArgumentCount;

#ifdef _MSC_VER
# pragma warning(pop)
#endif

}  // namespace internal
}  // namespace testing

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_

// Expands and concatenates the arguments. Constructed macros reevaluate.
#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)

// Expands and stringifies the only argument.
#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)

// Returns empty. Given a variadic number of arguments.
#define GMOCK_PP_EMPTY(...)

// Returns a comma. Given a variadic number of arguments.
#define GMOCK_PP_COMMA(...) ,

// Returns the only argument.
#define GMOCK_PP_IDENTITY(_1) _1

// Evaluates to the number of arguments after expansion.
//
//   #define PAIR x, y
//
//   GMOCK_PP_NARG() => 1
//   GMOCK_PP_NARG(x) => 1
//   GMOCK_PP_NARG(x, y) => 2
//   GMOCK_PP_NARG(PAIR) => 2
//
// Requires: the number of arguments after expansion is at most 15.
#define GMOCK_PP_NARG(...) \
  GMOCK_PP_INTERNAL_16TH(  \
      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))

// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
// returns 0. Requires no more than 15 unprotected commas.
#define GMOCK_PP_HAS_COMMA(...) \
  GMOCK_PP_INTERNAL_16TH(       \
      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))

// Returns the first argument.
#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))

// Returns the tail. A variadic list of all arguments minus the first. Requires
// at least one argument.
#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__))

// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
  GMOCK_PP_IDENTITY(                        \
      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__))

// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
// evaluates to `0`.
//
// Requires: * the number of arguments after expansion is at most 15.
//           * If the argument is a macro, it must be able to be called with one
//             argument.
//
// Implementation details:
//
// There is one case when it generates a compile error: if the argument is macro
// that cannot be called with one argument.
//
//   #define M(a, b)  // it doesn't matter what it expands to
//
//   // Expected: expands to `0`.
//   // Actual: compile error.
//   GMOCK_PP_IS_EMPTY(M)
//
// There are 4 cases tested:
//
// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0.
// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma.
//   Expected 0
// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
//
// We trigger detection on '0001', i.e. on empty.
#define GMOCK_PP_IS_EMPTY(...)                                               \
  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \
                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \
                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \
                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__()))

// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
#define GMOCK_PP_IF(_Cond, _Then, _Else) \
  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)

// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses.
//
// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c
// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f
//
#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \
  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else))

// Evaluates to the number of arguments after expansion. Identifies 'empty' as
// 0.
//
//   #define PAIR x, y
//
//   GMOCK_PP_NARG0() => 0
//   GMOCK_PP_NARG0(x) => 1
//   GMOCK_PP_NARG0(x, y) => 2
//   GMOCK_PP_NARG0(PAIR) => 2
//
// Requires: * the number of arguments after expansion is at most 15.
//           * If the argument is a macro, it must be able to be called with one
//             argument.
#define GMOCK_PP_NARG0(...) \
  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__))

// Expands to 1 if the first argument starts with something in parentheses,
// otherwise to 0.
#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \
  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))

// Expands to 1 is there is only one argument and it is enclosed in parentheses.
#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \
  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)

// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__

// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
// Requires: * |_Macro| can be called with 3 arguments.
//           * |_Tuple| expansion has no more than 15 elements.
#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
  (0, _Macro, _Data, _Tuple)

// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
// Empty if _K = 0.
// Requires: * |_Macro| can be called with 3 arguments.
//           * |_K| literal between 0 and 15
#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)

// Increments the argument, requires the argument to be between 0 and 15.
#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)

// Returns comma if _i != 0. Requires _i to be between 0 and 15.
#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)

// Internal details follow. Do not use any of these symbols outside of this
// file or we will break your code.
#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \
  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \
                                             _1, _2, _3, _4))
#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else

// Because of MSVC treating a token with a comma in it as a single token when
// passed to another macro, we need to force it to evaluate it as multiple
// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
// define one per possible macro that relies on this behavior. Note "_Args" must
// be parenthesized.
#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
                                        _10, _11, _12, _13, _14, _15, _16,  \
                                        ...)                                \
  _16
#define GMOCK_PP_INTERNAL_16TH(_Args) \
  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
#define GMOCK_PP_INTERNAL_HEAD(_Args) \
  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__
#define GMOCK_PP_INTERNAL_TAIL(_Args) \
  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args)

#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
  0,
#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
#define GMOCK_PP_INTERNAL_INC_0 1
#define GMOCK_PP_INTERNAL_INC_1 2
#define GMOCK_PP_INTERNAL_INC_2 3
#define GMOCK_PP_INTERNAL_INC_3 4
#define GMOCK_PP_INTERNAL_INC_4 5
#define GMOCK_PP_INTERNAL_INC_5 6
#define GMOCK_PP_INTERNAL_INC_6 7
#define GMOCK_PP_INTERNAL_INC_7 8
#define GMOCK_PP_INTERNAL_INC_8 9
#define GMOCK_PP_INTERNAL_INC_9 10
#define GMOCK_PP_INTERNAL_INC_10 11
#define GMOCK_PP_INTERNAL_INC_11 12
#define GMOCK_PP_INTERNAL_INC_12 13
#define GMOCK_PP_INTERNAL_INC_13 14
#define GMOCK_PP_INTERNAL_INC_14 15
#define GMOCK_PP_INTERNAL_INC_15 16
#define GMOCK_PP_INTERNAL_COMMA_IF_0
#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
  _Macro(_i, _Data, _element)
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \
                                    (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_

#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif

namespace testing {

// To implement an action Foo, define:
//   1. a class FooAction that implements the ActionInterface interface, and
//   2. a factory function that creates an Action object from a
//      const FooAction*.
//
// The two-level delegation design follows that of Matcher, providing
// consistency for extension developers.  It also eases ownership
// management as Action objects can now be copied like plain values.

namespace internal {

// BuiltInDefaultValueGetter<T, true>::Get() returns a
// default-constructed T value.  BuiltInDefaultValueGetter<T,
// false>::Get() crashes with an error.
//
// This primary template is used when kDefaultConstructible is true.
template <typename T, bool kDefaultConstructible>
struct BuiltInDefaultValueGetter {
  static T Get() { return T(); }
};
template <typename T>
struct BuiltInDefaultValueGetter<T, false> {
  static T Get() {
    Assert(false, __FILE__, __LINE__,
           "Default action undefined for the function return type.");
    return internal::Invalid<T>();
    // The above statement will never be reached, but is required in
    // order for this function to compile.
  }
};

// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
// for type T, which is NULL when T is a raw pointer type, 0 when T is
// a numeric type, false when T is bool, or "" when T is string or
// std::string.  In addition, in C++11 and above, it turns a
// default-constructed T value if T is default constructible.  For any
// other type T, the built-in default T value is undefined, and the
// function will abort the process.
template <typename T>
class BuiltInDefaultValue {
 public:
  // This function returns true if and only if type T has a built-in default
  // value.
  static bool Exists() {
    return ::std::is_default_constructible<T>::value;
  }

  static T Get() {
    return BuiltInDefaultValueGetter<
        T, ::std::is_default_constructible<T>::value>::Get();
  }
};

// This partial specialization says that we use the same built-in
// default value for T and const T.
template <typename T>
class BuiltInDefaultValue<const T> {
 public:
  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
  static T Get() { return BuiltInDefaultValue<T>::Get(); }
};

// This partial specialization defines the default values for pointer
// types.
template <typename T>
class BuiltInDefaultValue<T*> {
 public:
  static bool Exists() { return true; }
  static T* Get() { return nullptr; }
};

// The following specializations define the default values for
// specific types we care about.
#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
  template <> \
  class BuiltInDefaultValue<type> { \
   public: \
    static bool Exists() { return true; } \
    static type Get() { return value; } \
  }

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');

// There's no need for a default action for signed wchar_t, as that
// type is the same as wchar_t for gcc, and invalid for MSVC.
//
// There's also no need for a default action for unsigned wchar_t, as
// that type is the same as unsigned int for gcc, and invalid for
// MSVC.
#if GMOCK_WCHAR_T_IS_NATIVE_
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
#endif

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);

#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_

// Simple two-arg form of std::disjunction.
template <typename P, typename Q>
using disjunction = typename ::std::conditional<P::value, P, Q>::type;

}  // namespace internal

// When an unexpected function call is encountered, Google Mock will
// let it return a default value if the user has specified one for its
// return type, or if the return type has a built-in default value;
// otherwise Google Mock won't know what value to return and will have
// to abort the process.
//
// The DefaultValue<T> class allows a user to specify the
// default value for a type T that is both copyable and publicly
// destructible (i.e. anything that can be used as a function return
// type).  The usage is:
//
//   // Sets the default value for type T to be foo.
//   DefaultValue<T>::Set(foo);
template <typename T>
class DefaultValue {
 public:
  // Sets the default value for type T; requires T to be
  // copy-constructable and have a public destructor.
  static void Set(T x) {
    delete producer_;
    producer_ = new FixedValueProducer(x);
  }

  // Provides a factory function to be called to generate the default value.
  // This method can be used even if T is only move-constructible, but it is not
  // limited to that case.
  typedef T (*FactoryFunction)();
  static void SetFactory(FactoryFunction factory) {
    delete producer_;
    producer_ = new FactoryValueProducer(factory);
  }

  // Unsets the default value for type T.
  static void Clear() {
    delete producer_;
    producer_ = nullptr;
  }

  // Returns true if and only if the user has set the default value for type T.
  static bool IsSet() { return producer_ != nullptr; }

  // Returns true if T has a default return value set by the user or there
  // exists a built-in default value.
  static bool Exists() {
    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
  }

  // Returns the default value for type T if the user has set one;
  // otherwise returns the built-in default value. Requires that Exists()
  // is true, which ensures that the return value is well-defined.
  static T Get() {
    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
                                : producer_->Produce();
  }

 private:
  class ValueProducer {
   public:
    virtual ~ValueProducer() {}
    virtual T Produce() = 0;
  };

  class FixedValueProducer : public ValueProducer {
   public:
    explicit FixedValueProducer(T value) : value_(value) {}
    T Produce() override { return value_; }

   private:
    const T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
  };

  class FactoryValueProducer : public ValueProducer {
   public:
    explicit FactoryValueProducer(FactoryFunction factory)
        : factory_(factory) {}
    T Produce() override { return factory_(); }

   private:
    const FactoryFunction factory_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
  };

  static ValueProducer* producer_;
};

// This partial specialization allows a user to set default values for
// reference types.
template <typename T>
class DefaultValue<T&> {
 public:
  // Sets the default value for type T&.
  static void Set(T& x) {  // NOLINT
    address_ = &x;
  }

  // Unsets the default value for type T&.
  static void Clear() { address_ = nullptr; }

  // Returns true if and only if the user has set the default value for type T&.
  static bool IsSet() { return address_ != nullptr; }

  // Returns true if T has a default return value set by the user or there
  // exists a built-in default value.
  static bool Exists() {
    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
  }

  // Returns the default value for type T& if the user has set one;
  // otherwise returns the built-in default value if there is one;
  // otherwise aborts the process.
  static T& Get() {
    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
                               : *address_;
  }

 private:
  static T* address_;
};

// This specialization allows DefaultValue<void>::Get() to
// compile.
template <>
class DefaultValue<void> {
 public:
  static bool Exists() { return true; }
  static void Get() {}
};

// Points to the user-set default value for type T.
template <typename T>
typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;

// Points to the user-set default value for type T&.
template <typename T>
T* DefaultValue<T&>::address_ = nullptr;

// Implement this interface to define an action for function type F.
template <typename F>
class ActionInterface {
 public:
  typedef typename internal::Function<F>::Result Result;
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  ActionInterface() {}
  virtual ~ActionInterface() {}

  // Performs the action.  This method is not const, as in general an
  // action can have side effects and be stateful.  For example, a
  // get-the-next-element-from-the-collection action will need to
  // remember the current element.
  virtual Result Perform(const ArgumentTuple& args) = 0;

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
};

// An Action<F> is a copyable and IMMUTABLE (except by assignment)
// object that represents an action to be taken when a mock function
// of type F is called.  The implementation of Action<T> is just a
// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
// You can view an object implementing ActionInterface<F> as a
// concrete action (including its current state), and an Action<F>
// object as a handle to it.
template <typename F>
class Action {
  // Adapter class to allow constructing Action from a legacy ActionInterface.
  // New code should create Actions from functors instead.
  struct ActionAdapter {
    // Adapter must be copyable to satisfy std::function requirements.
    ::std::shared_ptr<ActionInterface<F>> impl_;

    template <typename... Args>
    typename internal::Function<F>::Result operator()(Args&&... args) {
      return impl_->Perform(
          ::std::forward_as_tuple(::std::forward<Args>(args)...));
    }
  };

  template <typename G>
  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;

 public:
  typedef typename internal::Function<F>::Result Result;
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  // Constructs a null Action.  Needed for storing Action objects in
  // STL containers.
  Action() {}

  // Construct an Action from a specified callable.
  // This cannot take std::function directly, because then Action would not be
  // directly constructible from lambda (it would require two conversions).
  template <
      typename G,
      typename = typename std::enable_if<internal::disjunction<
          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
                                                        G>>::value>::type>
  Action(G&& fun) {  // NOLINT
    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
  }

  // Constructs an Action from its implementation.
  explicit Action(ActionInterface<F>* impl)
      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}

  // This constructor allows us to turn an Action<Func> object into an
  // Action<F>, as long as F's arguments can be implicitly converted
  // to Func's and Func's return type can be implicitly converted to F's.
  template <typename Func>
  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}

  // Returns true if and only if this is the DoDefault() action.
  bool IsDoDefault() const { return fun_ == nullptr; }

  // Performs the action.  Note that this method is const even though
  // the corresponding method in ActionInterface is not.  The reason
  // is that a const Action<F> means that it cannot be re-bound to
  // another concrete action, not that the concrete action it binds to
  // cannot change state.  (Think of the difference between a const
  // pointer and a pointer to const.)
  Result Perform(ArgumentTuple args) const {
    if (IsDoDefault()) {
      internal::IllegalDoDefault(__FILE__, __LINE__);
    }
    return internal::Apply(fun_, ::std::move(args));
  }

 private:
  template <typename G>
  friend class Action;

  template <typename G>
  void Init(G&& g, ::std::true_type) {
    fun_ = ::std::forward<G>(g);
  }

  template <typename G>
  void Init(G&& g, ::std::false_type) {
    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
  }

  template <typename FunctionImpl>
  struct IgnoreArgs {
    template <typename... Args>
    Result operator()(const Args&...) const {
      return function_impl();
    }

    FunctionImpl function_impl;
  };

  // fun_ is an empty function if and only if this is the DoDefault() action.
  ::std::function<F> fun_;
};

// The PolymorphicAction class template makes it easy to implement a
// polymorphic action (i.e. an action that can be used in mock
// functions of than one type, e.g. Return()).
//
// To define a polymorphic action, a user first provides a COPYABLE
// implementation class that has a Perform() method template:
//
//   class FooAction {
//    public:
//     template <typename Result, typename ArgumentTuple>
//     Result Perform(const ArgumentTuple& args) const {
//       // Processes the arguments and returns a result, using
//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
//     }
//     ...
//   };
//
// Then the user creates the polymorphic action using
// MakePolymorphicAction(object) where object has type FooAction.  See
// the definition of Return(void) and SetArgumentPointee<N>(value) for
// complete examples.
template <typename Impl>
class PolymorphicAction {
 public:
  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}

  template <typename F>
  operator Action<F>() const {
    return Action<F>(new MonomorphicImpl<F>(impl_));
  }

 private:
  template <typename F>
  class MonomorphicImpl : public ActionInterface<F> {
   public:
    typedef typename internal::Function<F>::Result Result;
    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}

    Result Perform(const ArgumentTuple& args) override {
      return impl_.template Perform<Result>(args);
    }

   private:
    Impl impl_;
  };

  Impl impl_;
};

// Creates an Action from its implementation and returns it.  The
// created Action object owns the implementation.
template <typename F>
Action<F> MakeAction(ActionInterface<F>* impl) {
  return Action<F>(impl);
}

// Creates a polymorphic action from its implementation.  This is
// easier to use than the PolymorphicAction<Impl> constructor as it
// doesn't require you to explicitly write the template argument, e.g.
//
//   MakePolymorphicAction(foo);
// vs
//   PolymorphicAction<TypeOfFoo>(foo);
template <typename Impl>
inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
  return PolymorphicAction<Impl>(impl);
}

namespace internal {

// Helper struct to specialize ReturnAction to execute a move instead of a copy
// on return. Useful for move-only types, but could be used on any type.
template <typename T>
struct ByMoveWrapper {
  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
  T payload;
};

// Implements the polymorphic Return(x) action, which can be used in
// any function that returns the type of x, regardless of the argument
// types.
//
// Note: The value passed into Return must be converted into
// Function<F>::Result when this action is cast to Action<F> rather than
// when that action is performed. This is important in scenarios like
//
// MOCK_METHOD1(Method, T(U));
// ...
// {
//   Foo foo;
//   X x(&foo);
//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
// }
//
// In the example above the variable x holds reference to foo which leaves
// scope and gets destroyed.  If copying X just copies a reference to foo,
// that copy will be left with a hanging reference.  If conversion to T
// makes a copy of foo, the above code is safe. To support that scenario, we
// need to make sure that the type conversion happens inside the EXPECT_CALL
// statement, and conversion of the result of Return to Action<T(U)> is a
// good place for that.
//
// The real life example of the above scenario happens when an invocation
// of gtl::Container() is passed into Return.
//
template <typename R>
class ReturnAction {
 public:
  // Constructs a ReturnAction object from the value to be returned.
  // 'value' is passed by value instead of by const reference in order
  // to allow Return("string literal") to compile.
  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}

  // This template type conversion operator allows Return(x) to be
  // used in ANY function that returns x's type.
  template <typename F>
  operator Action<F>() const {  // NOLINT
    // Assert statement belongs here because this is the best place to verify
    // conditions on F. It produces the clearest error messages
    // in most compilers.
    // Impl really belongs in this scope as a local class but can't
    // because MSVC produces duplicate symbols in different translation units
    // in this case. Until MS fixes that bug we put Impl into the class scope
    // and put the typedef both here (for use in assert statement) and
    // in the Impl class. But both definitions must be the same.
    typedef typename Function<F>::Result Result;
    GTEST_COMPILE_ASSERT_(
        !std::is_reference<Result>::value,
        use_ReturnRef_instead_of_Return_to_return_a_reference);
    static_assert(!std::is_void<Result>::value,
                  "Can't use Return() on an action expected to return `void`.");
    return Action<F>(new Impl<R, F>(value_));
  }

 private:
  // Implements the Return(x) action for a particular function type F.
  template <typename R_, typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    // The implicit cast is necessary when Result has more than one
    // single-argument constructor (e.g. Result is std::vector<int>) and R
    // has a type conversion operator template.  In that case, value_(value)
    // won't compile as the compiler doesn't known which constructor of
    // Result to call.  ImplicitCast_ forces the compiler to convert R to
    // Result without considering explicit constructors, thus resolving the
    // ambiguity. value_ is then initialized using its copy constructor.
    explicit Impl(const std::shared_ptr<R>& value)
        : value_before_cast_(*value),
          value_(ImplicitCast_<Result>(value_before_cast_)) {}

    Result Perform(const ArgumentTuple&) override { return value_; }

   private:
    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
                          Result_cannot_be_a_reference_type);
    // We save the value before casting just in case it is being cast to a
    // wrapper type.
    R value_before_cast_;
    Result value_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
  };

  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
  // move its contents instead.
  template <typename R_, typename F>
  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const std::shared_ptr<R>& wrapper)
        : performed_(false), wrapper_(wrapper) {}

    Result Perform(const ArgumentTuple&) override {
      GTEST_CHECK_(!performed_)
          << "A ByMove() action should only be performed once.";
      performed_ = true;
      return std::move(wrapper_->payload);
    }

   private:
    bool performed_;
    const std::shared_ptr<R> wrapper_;
  };

  const std::shared_ptr<R> value_;
};

// Implements the ReturnNull() action.
class ReturnNullAction {
 public:
  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
  // this is enforced by returning nullptr, and in non-C++11 by asserting a
  // pointer type on compile time.
  template <typename Result, typename ArgumentTuple>
  static Result Perform(const ArgumentTuple&) {
    return nullptr;
  }
};

// Implements the Return() action.
class ReturnVoidAction {
 public:
  // Allows Return() to be used in any void-returning function.
  template <typename Result, typename ArgumentTuple>
  static void Perform(const ArgumentTuple&) {
    static_assert(std::is_void<Result>::value, "Result should be void.");
  }
};

// Implements the polymorphic ReturnRef(x) action, which can be used
// in any function that returns a reference to the type of x,
// regardless of the argument types.
template <typename T>
class ReturnRefAction {
 public:
  // Constructs a ReturnRefAction object from the reference to be returned.
  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT

  // This template type conversion operator allows ReturnRef(x) to be
  // used in ANY function that returns a reference to x's type.
  template <typename F>
  operator Action<F>() const {
    typedef typename Function<F>::Result Result;
    // Asserts that the function return type is a reference.  This
    // catches the user error of using ReturnRef(x) when Return(x)
    // should be used, and generates some helpful error message.
    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
                          use_Return_instead_of_ReturnRef_to_return_a_value);
    return Action<F>(new Impl<F>(ref_));
  }

 private:
  // Implements the ReturnRef(x) action for a particular function type F.
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT

    Result Perform(const ArgumentTuple&) override { return ref_; }

   private:
    T& ref_;
  };

  T& ref_;
};

// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
// used in any function that returns a reference to the type of x,
// regardless of the argument types.
template <typename T>
class ReturnRefOfCopyAction {
 public:
  // Constructs a ReturnRefOfCopyAction object from the reference to
  // be returned.
  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT

  // This template type conversion operator allows ReturnRefOfCopy(x) to be
  // used in ANY function that returns a reference to x's type.
  template <typename F>
  operator Action<F>() const {
    typedef typename Function<F>::Result Result;
    // Asserts that the function return type is a reference.  This
    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
    // should be used, and generates some helpful error message.
    GTEST_COMPILE_ASSERT_(
        std::is_reference<Result>::value,
        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
    return Action<F>(new Impl<F>(value_));
  }

 private:
  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const T& value) : value_(value) {}  // NOLINT

    Result Perform(const ArgumentTuple&) override { return value_; }

   private:
    T value_;
  };

  const T value_;
};

// Implements the polymorphic ReturnRoundRobin(v) action, which can be
// used in any function that returns the element_type of v.
template <typename T>
class ReturnRoundRobinAction {
 public:
  explicit ReturnRoundRobinAction(std::vector<T> values) {
    GTEST_CHECK_(!values.empty())
        << "ReturnRoundRobin requires at least one element.";
    state_->values = std::move(values);
  }

  template <typename... Args>
  T operator()(Args&&...) const {
     return state_->Next();
  }

 private:
  struct State {
    T Next() {
      T ret_val = values[i++];
      if (i == values.size()) i = 0;
      return ret_val;
    }

    std::vector<T> values;
    size_t i = 0;
  };
  std::shared_ptr<State> state_ = std::make_shared<State>();
};

// Implements the polymorphic DoDefault() action.
class DoDefaultAction {
 public:
  // This template type conversion operator allows DoDefault() to be
  // used in any function.
  template <typename F>
  operator Action<F>() const { return Action<F>(); }  // NOLINT
};

// Implements the Assign action to set a given pointer referent to a
// particular value.
template <typename T1, typename T2>
class AssignAction {
 public:
  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}

  template <typename Result, typename ArgumentTuple>
  void Perform(const ArgumentTuple& /* args */) const {
    *ptr_ = value_;
  }

 private:
  T1* const ptr_;
  const T2 value_;
};

#if !GTEST_OS_WINDOWS_MOBILE

// Implements the SetErrnoAndReturn action to simulate return from
// various system calls and libc functions.
template <typename T>
class SetErrnoAndReturnAction {
 public:
  SetErrnoAndReturnAction(int errno_value, T result)
      : errno_(errno_value),
        result_(result) {}
  template <typename Result, typename ArgumentTuple>
  Result Perform(const ArgumentTuple& /* args */) const {
    errno = errno_;
    return result_;
  }

 private:
  const int errno_;
  const T result_;
};

#endif  // !GTEST_OS_WINDOWS_MOBILE

// Implements the SetArgumentPointee<N>(x) action for any function
// whose N-th argument (0-based) is a pointer to x's type.
template <size_t N, typename A, typename = void>
struct SetArgumentPointeeAction {
  A value;

  template <typename... Args>
  void operator()(const Args&... args) const {
    *::std::get<N>(std::tie(args...)) = value;
  }
};

// Implements the Invoke(object_ptr, &Class::Method) action.
template <class Class, typename MethodPtr>
struct InvokeMethodAction {
  Class* const obj_ptr;
  const MethodPtr method_ptr;

  template <typename... Args>
  auto operator()(Args&&... args) const
      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
  }
};

// Implements the InvokeWithoutArgs(f) action.  The template argument
// FunctionImpl is the implementation type of f, which can be either a
// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
// Action<F> as long as f's type is compatible with F.
template <typename FunctionImpl>
struct InvokeWithoutArgsAction {
  FunctionImpl function_impl;

  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
  // compatible with f.
  template <typename... Args>
  auto operator()(const Args&...) -> decltype(function_impl()) {
    return function_impl();
  }
};

// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
template <class Class, typename MethodPtr>
struct InvokeMethodWithoutArgsAction {
  Class* const obj_ptr;
  const MethodPtr method_ptr;

  using ReturnType =
      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());

  template <typename... Args>
  ReturnType operator()(const Args&...) const {
    return (obj_ptr->*method_ptr)();
  }
};

// Implements the IgnoreResult(action) action.
template <typename A>
class IgnoreResultAction {
 public:
  explicit IgnoreResultAction(const A& action) : action_(action) {}

  template <typename F>
  operator Action<F>() const {
    // Assert statement belongs here because this is the best place to verify
    // conditions on F. It produces the clearest error messages
    // in most compilers.
    // Impl really belongs in this scope as a local class but can't
    // because MSVC produces duplicate symbols in different translation units
    // in this case. Until MS fixes that bug we put Impl into the class scope
    // and put the typedef both here (for use in assert statement) and
    // in the Impl class. But both definitions must be the same.
    typedef typename internal::Function<F>::Result Result;

    // Asserts at compile time that F returns void.
    static_assert(std::is_void<Result>::value, "Result type should be void.");

    return Action<F>(new Impl<F>(action_));
  }

 private:
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename internal::Function<F>::Result Result;
    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const A& action) : action_(action) {}

    void Perform(const ArgumentTuple& args) override {
      // Performs the action and ignores its result.
      action_.Perform(args);
    }

   private:
    // Type OriginalFunction is the same as F except that its return
    // type is IgnoredValue.
    typedef typename internal::Function<F>::MakeResultIgnoredValue
        OriginalFunction;

    const Action<OriginalFunction> action_;
  };

  const A action_;
};

template <typename InnerAction, size_t... I>
struct WithArgsAction {
  InnerAction action;

  // The inner action could be anything convertible to Action<X>.
  // We use the conversion operator to detect the signature of the inner Action.
  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
    using TupleType = std::tuple<Args...>;
    Action<R(typename std::tuple_element<I, TupleType>::type...)>
        converted(action);

    return [converted](Args... args) -> R {
      return converted.Perform(std::forward_as_tuple(
        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
    };
  }
};

template <typename... Actions>
struct DoAllAction {
 private:
  template <typename T>
  using NonFinalType =
      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;

  template <typename ActionT, size_t... I>
  std::vector<ActionT> Convert(IndexSequence<I...>) const {
    return {ActionT(std::get<I>(actions))...};
  }

 public:
  std::tuple<Actions...> actions;

  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
    struct Op {
      std::vector<Action<void(NonFinalType<Args>...)>> converted;
      Action<R(Args...)> last;
      R operator()(Args... args) const {
        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
        for (auto& a : converted) {
          a.Perform(tuple_args);
        }
        return last.Perform(std::move(tuple_args));
      }
    };
    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
                  MakeIndexSequence<sizeof...(Actions) - 1>()),
              std::get<sizeof...(Actions) - 1>(actions)};
  }
};

template <typename T, typename... Params>
struct ReturnNewAction {
  T* operator()() const {
    return internal::Apply(
        [](const Params&... unpacked_params) {
          return new T(unpacked_params...);
        },
        params);
  }
  std::tuple<Params...> params;
};

template <size_t k>
struct ReturnArgAction {
  template <typename... Args>
  auto operator()(const Args&... args) const ->
      typename std::tuple_element<k, std::tuple<Args...>>::type {
    return std::get<k>(std::tie(args...));
  }
};

template <size_t k, typename Ptr>
struct SaveArgAction {
  Ptr pointer;

  template <typename... Args>
  void operator()(const Args&... args) const {
    *pointer = std::get<k>(std::tie(args...));
  }
};

template <size_t k, typename Ptr>
struct SaveArgPointeeAction {
  Ptr pointer;

  template <typename... Args>
  void operator()(const Args&... args) const {
    *pointer = *std::get<k>(std::tie(args...));
  }
};

template <size_t k, typename T>
struct SetArgRefereeAction {
  T value;

  template <typename... Args>
  void operator()(Args&&... args) const {
    using argk_type =
        typename ::std::tuple_element<k, std::tuple<Args...>>::type;
    static_assert(std::is_lvalue_reference<argk_type>::value,
                  "Argument must be a reference type.");
    std::get<k>(std::tie(args...)) = value;
  }
};

template <size_t k, typename I1, typename I2>
struct SetArrayArgumentAction {
  I1 first;
  I2 last;

  template <typename... Args>
  void operator()(const Args&... args) const {
    auto value = std::get<k>(std::tie(args...));
    for (auto it = first; it != last; ++it, (void)++value) {
      *value = *it;
    }
  }
};

template <size_t k>
struct DeleteArgAction {
  template <typename... Args>
  void operator()(const Args&... args) const {
    delete std::get<k>(std::tie(args...));
  }
};

template <typename Ptr>
struct ReturnPointeeAction {
  Ptr pointer;
  template <typename... Args>
  auto operator()(const Args&...) const -> decltype(*pointer) {
    return *pointer;
  }
};

#if GTEST_HAS_EXCEPTIONS
template <typename T>
struct ThrowAction {
  T exception;
  // We use a conversion operator to adapt to any return type.
  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
    T copy = exception;
    return [copy](Args...) -> R { throw copy; };
  }
};
#endif  // GTEST_HAS_EXCEPTIONS

}  // namespace internal

// An Unused object can be implicitly constructed from ANY value.
// This is handy when defining actions that ignore some or all of the
// mock function arguments.  For example, given
//
//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
//   MOCK_METHOD3(Bar, double(int index, double x, double y));
//
// instead of
//
//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   double DistanceToOriginWithIndex(int index, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   ...
//   EXPECT_CALL(mock, Foo("abc", _, _))
//       .WillOnce(Invoke(DistanceToOriginWithLabel));
//   EXPECT_CALL(mock, Bar(5, _, _))
//       .WillOnce(Invoke(DistanceToOriginWithIndex));
//
// you could write
//
//   // We can declare any uninteresting argument as Unused.
//   double DistanceToOrigin(Unused, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   ...
//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
typedef internal::IgnoredValue Unused;

// Creates an action that does actions a1, a2, ..., sequentially in
// each invocation. All but the last action will have a readonly view of the
// arguments.
template <typename... Action>
internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
    Action&&... action) {
  return {std::forward_as_tuple(std::forward<Action>(action)...)};
}

// WithArg<k>(an_action) creates an action that passes the k-th
// (0-based) argument of the mock function to an_action and performs
// it.  It adapts an action accepting one argument to one that accepts
// multiple arguments.  For convenience, we also provide
// WithArgs<k>(an_action) (defined below) as a synonym.
template <size_t k, typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
WithArg(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
// the selected arguments of the mock function to an_action and
// performs it.  It serves as an adaptor between actions with
// different argument lists.
template <size_t k, size_t... ks, typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
WithArgs(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

// WithoutArgs(inner_action) can be used in a mock function with a
// non-empty argument list to perform inner_action, which takes no
// argument.  In other words, it adapts an action accepting no
// argument to one that accepts (and ignores) arguments.
template <typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type>
WithoutArgs(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

// Creates an action that returns 'value'.  'value' is passed by value
// instead of const reference - otherwise Return("string literal")
// will trigger a compiler error about using array as initializer.
template <typename R>
internal::ReturnAction<R> Return(R value) {
  return internal::ReturnAction<R>(std::move(value));
}

// Creates an action that returns NULL.
inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
  return MakePolymorphicAction(internal::ReturnNullAction());
}

// Creates an action that returns from a void function.
inline PolymorphicAction<internal::ReturnVoidAction> Return() {
  return MakePolymorphicAction(internal::ReturnVoidAction());
}

// Creates an action that returns the reference to a variable.
template <typename R>
inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
  return internal::ReturnRefAction<R>(x);
}

// Prevent using ReturnRef on reference to temporary.
template <typename R, R* = nullptr>
internal::ReturnRefAction<R> ReturnRef(R&&) = delete;

// Creates an action that returns the reference to a copy of the
// argument.  The copy is created when the action is constructed and
// lives as long as the action.
template <typename R>
inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
  return internal::ReturnRefOfCopyAction<R>(x);
}

// Modifies the parent action (a Return() action) to perform a move of the
// argument instead of a copy.
// Return(ByMove()) actions can only be executed once and will assert this
// invariant.
template <typename R>
internal::ByMoveWrapper<R> ByMove(R x) {
  return internal::ByMoveWrapper<R>(std::move(x));
}

// Creates an action that returns an element of `vals`. Calling this action will
// repeatedly return the next value from `vals` until it reaches the end and
// will restart from the beginning.
template <typename T>
internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
  return internal::ReturnRoundRobinAction<T>(std::move(vals));
}

// Creates an action that returns an element of `vals`. Calling this action will
// repeatedly return the next value from `vals` until it reaches the end and
// will restart from the beginning.
template <typename T>
internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
    std::initializer_list<T> vals) {
  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
}

// Creates an action that does the default action for the give mock function.
inline internal::DoDefaultAction DoDefault() {
  return internal::DoDefaultAction();
}

// Creates an action that sets the variable pointed by the N-th
// (0-based) function argument to 'value'.
template <size_t N, typename T>
internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
  return {std::move(value)};
}

// The following version is DEPRECATED.
template <size_t N, typename T>
internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
  return {std::move(value)};
}

// Creates an action that sets a pointer referent to a given value.
template <typename T1, typename T2>
PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
}

#if !GTEST_OS_WINDOWS_MOBILE

// Creates an action that sets errno and returns the appropriate error.
template <typename T>
PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
SetErrnoAndReturn(int errval, T result) {
  return MakePolymorphicAction(
      internal::SetErrnoAndReturnAction<T>(errval, result));
}

#endif  // !GTEST_OS_WINDOWS_MOBILE

// Various overloads for Invoke().

// Legacy function.
// Actions can now be implicitly constructed from callables. No need to create
// wrapper objects.
// This function exists for backwards compatibility.
template <typename FunctionImpl>
typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
  return std::forward<FunctionImpl>(function_impl);
}

// Creates an action that invokes the given method on the given object
// with the mock function's arguments.
template <class Class, typename MethodPtr>
internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
                                                      MethodPtr method_ptr) {
  return {obj_ptr, method_ptr};
}

// Creates an action that invokes 'function_impl' with no argument.
template <typename FunctionImpl>
internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
InvokeWithoutArgs(FunctionImpl function_impl) {
  return {std::move(function_impl)};
}

// Creates an action that invokes the given method on the given object
// with no argument.
template <class Class, typename MethodPtr>
internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
    Class* obj_ptr, MethodPtr method_ptr) {
  return {obj_ptr, method_ptr};
}

// Creates an action that performs an_action and throws away its
// result.  In other words, it changes the return type of an_action to
// void.  an_action MUST NOT return void, or the code won't compile.
template <typename A>
inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
  return internal::IgnoreResultAction<A>(an_action);
}

// Creates a reference wrapper for the given L-value.  If necessary,
// you can explicitly specify the type of the reference.  For example,
// suppose 'derived' is an object of type Derived, ByRef(derived)
// would wrap a Derived&.  If you want to wrap a const Base& instead,
// where Base is a base class of Derived, just write:
//
//   ByRef<const Base>(derived)
//
// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
// However, it may still be used for consistency with ByMove().
template <typename T>
inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
  return ::std::reference_wrapper<T>(l_value);
}

// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
// instance of type T, constructed on the heap with constructor arguments
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
template <typename T, typename... Params>
internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
    Params&&... params) {
  return {std::forward_as_tuple(std::forward<Params>(params)...)};
}

// Action ReturnArg<k>() returns the k-th argument of the mock function.
template <size_t k>
internal::ReturnArgAction<k> ReturnArg() {
  return {};
}

// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
// mock function to *pointer.
template <size_t k, typename Ptr>
internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
  return {pointer};
}

// Action SaveArgPointee<k>(pointer) saves the value pointed to
// by the k-th (0-based) argument of the mock function to *pointer.
template <size_t k, typename Ptr>
internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
  return {pointer};
}

// Action SetArgReferee<k>(value) assigns 'value' to the variable
// referenced by the k-th (0-based) argument of the mock function.
template <size_t k, typename T>
internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
    T&& value) {
  return {std::forward<T>(value)};
}

// Action SetArrayArgument<k>(first, last) copies the elements in
// source range [first, last) to the array pointed to by the k-th
// (0-based) argument, which can be either a pointer or an
// iterator. The action does not take ownership of the elements in the
// source range.
template <size_t k, typename I1, typename I2>
internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
                                                             I2 last) {
  return {first, last};
}

// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
// function.
template <size_t k>
internal::DeleteArgAction<k> DeleteArg() {
  return {};
}

// This action returns the value pointed to by 'pointer'.
template <typename Ptr>
internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
  return {pointer};
}

// Action Throw(exception) can be used in a mock function of any type
// to throw the given exception.  Any copyable value can be thrown.
#if GTEST_HAS_EXCEPTIONS
template <typename T>
internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
  return {std::forward<T>(exception)};
}
#endif  // GTEST_HAS_EXCEPTIONS

namespace internal {

// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
// defines an action that can be used in a mock function.  Typically,
// these actions only care about a subset of the arguments of the mock
// function.  For example, if such an action only uses the second
// argument, it can be used in any mock function that takes >= 2
// arguments where the type of the second argument is compatible.
//
// Therefore, the action implementation must be prepared to take more
// arguments than it needs.  The ExcessiveArg type is used to
// represent those excessive arguments.  In order to keep the compiler
// error messages tractable, we define it in the testing namespace
// instead of testing::internal.  However, this is an INTERNAL TYPE
// and subject to change without notice, so a user MUST NOT USE THIS
// TYPE DIRECTLY.
struct ExcessiveArg {};

// Builds an implementation of an Action<> for some particular signature, using
// a class defined by an ACTION* macro.
template <typename F, typename Impl> struct ActionImpl;

template <typename Impl>
struct ImplBase {
  struct Holder {
    // Allows each copy of the Action<> to get to the Impl.
    explicit operator const Impl&() const { return *ptr; }
    std::shared_ptr<Impl> ptr;
  };
  using type = typename std::conditional<std::is_constructible<Impl>::value,
                                         Impl, Holder>::type;
};

template <typename R, typename... Args, typename Impl>
struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
  using Base = typename ImplBase<Impl>::type;
  using function_type = R(Args...);
  using args_type = std::tuple<Args...>;

  ActionImpl() = default;  // Only defined if appropriate for Base.
  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }

  R operator()(Args&&... arg) const {
    static constexpr size_t kMaxArgs =
        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
    return Apply(MakeIndexSequence<kMaxArgs>{},
                 MakeIndexSequence<10 - kMaxArgs>{},
                 args_type{std::forward<Args>(arg)...});
  }

  template <std::size_t... arg_id, std::size_t... excess_id>
  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
          const args_type& args) const {
    // Impl need not be specific to the signature of action being implemented;
    // only the implementing function body needs to have all of the specific
    // types instantiated.  Up to 10 of the args that are provided by the
    // args_type get passed, followed by a dummy of unspecified type for the
    // remainder up to 10 explicit args.
    static constexpr ExcessiveArg kExcessArg{};
    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
        /*function_type=*/function_type, /*return_type=*/R,
        /*args_type=*/args_type,
        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
        /*args=*/args, std::get<arg_id>(args)...,
        ((void)excess_id, kExcessArg)...);
  }
};

// Stores a default-constructed Impl as part of the Action<>'s
// std::function<>. The Impl should be trivial to copy.
template <typename F, typename Impl>
::testing::Action<F> MakeAction() {
  return ::testing::Action<F>(ActionImpl<F, Impl>());
}

// Stores just the one given instance of Impl.
template <typename F, typename Impl>
::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
}

#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \
  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)

#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))

#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))

#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
#define GMOCK_ACTION_TYPE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))

#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
  , param##_type gmock_p##i
#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))

#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
  , std::forward<param##_type>(gmock_p##i)
#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))

#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
  , param(::std::forward<param##_type>(gmock_p##i))
#define GMOCK_ACTION_INIT_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))

#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
#define GMOCK_ACTION_FIELD_PARAMS_(params) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)

#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  class full_name {                                                           \
   public:                                                                    \
    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
        : impl_(std::make_shared<gmock_Impl>(                                 \
                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
    full_name(const full_name&) = default;                                    \
    full_name(full_name&&) noexcept = default;                                \
    template <typename F>                                                     \
    operator ::testing::Action<F>() const {                                   \
      return ::testing::internal::MakeAction<F>(impl_);                       \
    }                                                                         \
   private:                                                                   \
    class gmock_Impl {                                                        \
     public:                                                                  \
      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
      template <typename function_type, typename return_type,                 \
                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
    };                                                                        \
    std::shared_ptr<const gmock_Impl> impl_;                                  \
  };                                                                          \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
  }                                                                           \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  template <typename function_type, typename return_type, typename args_type, \
            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const

}  // namespace internal

// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored.
#define ACTION(name)                                                          \
  class name##Action {                                                        \
   public:                                                                    \
   explicit name##Action() noexcept {}                                        \
   name##Action(const name##Action&) noexcept {}                              \
    template <typename F>                                                     \
    operator ::testing::Action<F>() const {                                   \
      return ::testing::internal::MakeAction<F, gmock_Impl>();                \
    }                                                                         \
   private:                                                                   \
    class gmock_Impl {                                                        \
     public:                                                                  \
      template <typename function_type, typename return_type,                 \
                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
    };                                                                        \
  };                                                                          \
  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
  inline name##Action name() { return name##Action(); }                       \
  template <typename function_type, typename return_type, typename args_type, \
            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \
      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const

#define ACTION_P(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))

#define ACTION_P2(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))

#define ACTION_P3(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))

#define ACTION_P4(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))

#define ACTION_P5(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))

#define ACTION_P6(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))

#define ACTION_P7(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))

#define ACTION_P8(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))

#define ACTION_P9(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))

#define ACTION_P10(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))

}  // namespace testing

#ifdef _MSC_VER
# pragma warning(pop)
#endif

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements some commonly used cardinalities.  More
// cardinalities can be defined by the user implementing the
// CardinalityInterface interface if necessary.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_

#include <limits.h>
#include <memory>
#include <ostream>  // NOLINT

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// To implement a cardinality Foo, define:
//   1. a class FooCardinality that implements the
//      CardinalityInterface interface, and
//   2. a factory function that creates a Cardinality object from a
//      const FooCardinality*.
//
// The two-level delegation design follows that of Matcher, providing
// consistency for extension developers.  It also eases ownership
// management as Cardinality objects can now be copied like plain values.

// The implementation of a cardinality.
class CardinalityInterface {
 public:
  virtual ~CardinalityInterface() {}

  // Conservative estimate on the lower/upper bound of the number of
  // calls allowed.
  virtual int ConservativeLowerBound() const { return 0; }
  virtual int ConservativeUpperBound() const { return INT_MAX; }

  // Returns true if and only if call_count calls will satisfy this
  // cardinality.
  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;

  // Returns true if and only if call_count calls will saturate this
  // cardinality.
  virtual bool IsSaturatedByCallCount(int call_count) const = 0;

  // Describes self to an ostream.
  virtual void DescribeTo(::std::ostream* os) const = 0;
};

// A Cardinality is a copyable and IMMUTABLE (except by assignment)
// object that specifies how many times a mock function is expected to
// be called.  The implementation of Cardinality is just a std::shared_ptr
// to const CardinalityInterface. Don't inherit from Cardinality!
class GTEST_API_ Cardinality {
 public:
  // Constructs a null cardinality.  Needed for storing Cardinality
  // objects in STL containers.
  Cardinality() {}

  // Constructs a Cardinality from its implementation.
  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}

  // Conservative estimate on the lower/upper bound of the number of
  // calls allowed.
  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }

  // Returns true if and only if call_count calls will satisfy this
  // cardinality.
  bool IsSatisfiedByCallCount(int call_count) const {
    return impl_->IsSatisfiedByCallCount(call_count);
  }

  // Returns true if and only if call_count calls will saturate this
  // cardinality.
  bool IsSaturatedByCallCount(int call_count) const {
    return impl_->IsSaturatedByCallCount(call_count);
  }

  // Returns true if and only if call_count calls will over-saturate this
  // cardinality, i.e. exceed the maximum number of allowed calls.
  bool IsOverSaturatedByCallCount(int call_count) const {
    return impl_->IsSaturatedByCallCount(call_count) &&
        !impl_->IsSatisfiedByCallCount(call_count);
  }

  // Describes self to an ostream
  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }

  // Describes the given actual call count to an ostream.
  static void DescribeActualCallCountTo(int actual_call_count,
                                        ::std::ostream* os);

 private:
  std::shared_ptr<const CardinalityInterface> impl_;
};

// Creates a cardinality that allows at least n calls.
GTEST_API_ Cardinality AtLeast(int n);

// Creates a cardinality that allows at most n calls.
GTEST_API_ Cardinality AtMost(int n);

// Creates a cardinality that allows any number of calls.
GTEST_API_ Cardinality AnyNumber();

// Creates a cardinality that allows between min and max calls.
GTEST_API_ Cardinality Between(int min, int max);

// Creates a cardinality that allows exactly n calls.
GTEST_API_ Cardinality Exactly(int n);

// Creates a cardinality from its implementation.
inline Cardinality MakeCardinality(const CardinalityInterface* c) {
  return Cardinality(c);
}

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Google Mock - a framework for writing C++ mock classes.
//
// This file implements MOCK_METHOD.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT

#include <type_traits>  // IWYU pragma: keep
#include <utility>      // IWYU pragma: keep

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements the ON_CALL() and EXPECT_CALL() macros.
//
// A user can use the ON_CALL() macro to specify the default action of
// a mock method.  The syntax is:
//
//   ON_CALL(mock_object, Method(argument-matchers))
//       .With(multi-argument-matcher)
//       .WillByDefault(action);
//
//  where the .With() clause is optional.
//
// A user can use the EXPECT_CALL() macro to specify an expectation on
// a mock method.  The syntax is:
//
//   EXPECT_CALL(mock_object, Method(argument-matchers))
//       .With(multi-argument-matchers)
//       .Times(cardinality)
//       .InSequence(sequences)
//       .After(expectations)
//       .WillOnce(action)
//       .WillRepeatedly(action)
//       .RetiresOnSaturation();
//
// where all clauses are optional, and .InSequence()/.After()/
// .WillOnce() can appear any number of times.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_

#include <functional>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// The MATCHER* family of macros can be used in a namespace scope to
// define custom matchers easily.
//
// Basic Usage
// ===========
//
// The syntax
//
//   MATCHER(name, description_string) { statements; }
//
// defines a matcher with the given name that executes the statements,
// which must return a bool to indicate if the match succeeds.  Inside
// the statements, you can refer to the value being matched by 'arg',
// and refer to its type by 'arg_type'.
//
// The description string documents what the matcher does, and is used
// to generate the failure message when the match fails.  Since a
// MATCHER() is usually defined in a header file shared by multiple
// C++ source files, we require the description to be a C-string
// literal to avoid possible side effects.  It can be empty, in which
// case we'll use the sequence of words in the matcher name as the
// description.
//
// For example:
//
//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
//
// allows you to write
//
//   // Expects mock_foo.Bar(n) to be called where n is even.
//   EXPECT_CALL(mock_foo, Bar(IsEven()));
//
// or,
//
//   // Verifies that the value of some_expression is even.
//   EXPECT_THAT(some_expression, IsEven());
//
// If the above assertion fails, it will print something like:
//
//   Value of: some_expression
//   Expected: is even
//     Actual: 7
//
// where the description "is even" is automatically calculated from the
// matcher name IsEven.
//
// Argument Type
// =============
//
// Note that the type of the value being matched (arg_type) is
// determined by the context in which you use the matcher and is
// supplied to you by the compiler, so you don't need to worry about
// declaring it (nor can you).  This allows the matcher to be
// polymorphic.  For example, IsEven() can be used to match any type
// where the value of "(arg % 2) == 0" can be implicitly converted to
// a bool.  In the "Bar(IsEven())" example above, if method Bar()
// takes an int, 'arg_type' will be int; if it takes an unsigned long,
// 'arg_type' will be unsigned long; and so on.
//
// Parameterizing Matchers
// =======================
//
// Sometimes you'll want to parameterize the matcher.  For that you
// can use another macro:
//
//   MATCHER_P(name, param_name, description_string) { statements; }
//
// For example:
//
//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
//
// will allow you to write:
//
//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
//
// which may lead to this message (assuming n is 10):
//
//   Value of: Blah("a")
//   Expected: has absolute value 10
//     Actual: -9
//
// Note that both the matcher description and its parameter are
// printed, making the message human-friendly.
//
// In the matcher definition body, you can write 'foo_type' to
// reference the type of a parameter named 'foo'.  For example, in the
// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
// 'value_type' to refer to the type of 'value'.
//
// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
// support multi-parameter matchers.
//
// Describing Parameterized Matchers
// =================================
//
// The last argument to MATCHER*() is a string-typed expression.  The
// expression can reference all of the matcher's parameters and a
// special bool-typed variable named 'negation'.  When 'negation' is
// false, the expression should evaluate to the matcher's description;
// otherwise it should evaluate to the description of the negation of
// the matcher.  For example,
//
//   using testing::PrintToString;
//
//   MATCHER_P2(InClosedRange, low, hi,
//       std::string(negation ? "is not" : "is") + " in range [" +
//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
//     return low <= arg && arg <= hi;
//   }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
//
// would generate two failures that contain the text:
//
//   Expected: is in range [4, 6]
//   ...
//   Expected: is not in range [2, 4]
//
// If you specify "" as the description, the failure message will
// contain the sequence of words in the matcher name followed by the
// parameter values printed as a tuple.  For example,
//
//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
//   ...
//   EXPECT_THAT(3, InClosedRange(4, 6));
//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
//
// would generate two failures that contain the text:
//
//   Expected: in closed range (4, 6)
//   ...
//   Expected: not (in closed range (2, 4))
//
// Types of Matcher Parameters
// ===========================
//
// For the purpose of typing, you can view
//
//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
//
// as shorthand for
//
//   template <typename p1_type, ..., typename pk_type>
//   FooMatcherPk<p1_type, ..., pk_type>
//   Foo(p1_type p1, ..., pk_type pk) { ... }
//
// When you write Foo(v1, ..., vk), the compiler infers the types of
// the parameters v1, ..., and vk for you.  If you are not happy with
// the result of the type inference, you can specify the types by
// explicitly instantiating the template, as in Foo<long, bool>(5,
// false).  As said earlier, you don't get to (or need to) specify
// 'arg_type' as that's determined by the context in which the matcher
// is used.  You can assign the result of expression Foo(p1, ..., pk)
// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
// can be useful when composing matchers.
//
// While you can instantiate a matcher template with reference types,
// passing the parameters by pointer usually makes your code more
// readable.  If, however, you still want to pass a parameter by
// reference, be aware that in the failure message generated by the
// matcher you will see the value of the referenced object but not its
// address.
//
// Explaining Match Results
// ========================
//
// Sometimes the matcher description alone isn't enough to explain why
// the match has failed or succeeded.  For example, when expecting a
// long string, it can be very helpful to also print the diff between
// the expected string and the actual one.  To achieve that, you can
// optionally stream additional information to a special variable
// named result_listener, whose type is a pointer to class
// MatchResultListener:
//
//   MATCHER_P(EqualsLongString, str, "") {
//     if (arg == str) return true;
//
//     *result_listener << "the difference: "
///                     << DiffStrings(str, arg);
//     return false;
//   }
//
// Overloading Matchers
// ====================
//
// You can overload matchers with different numbers of parameters:
//
//   MATCHER_P(Blah, a, description_string1) { ... }
//   MATCHER_P2(Blah, a, b, description_string2) { ... }
//
// Caveats
// =======
//
// When defining a new matcher, you should also consider implementing
// MatcherInterface or using MakePolymorphicMatcher().  These
// approaches require more work than the MATCHER* macros, but also
// give you more control on the types of the value being matched and
// the matcher parameters, which may leads to better compiler error
// messages when the matcher is used wrong.  They also allow
// overloading matchers based on parameter types (as opposed to just
// based on the number of parameters).
//
// MATCHER*() can only be used in a namespace scope as templates cannot be
// declared inside of a local class.
//
// More Information
// ================
//
// To learn more about using these macros, please search for 'MATCHER'
// on
// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
//
// This file also implements some commonly used argument matchers.  More
// matchers can be defined by the user implementing the
// MatcherInterface<T> interface if necessary.
//
// See googletest/include/gtest/gtest-matchers.h for the definition of class
// Matcher, class MatcherInterface, and others.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_

#include <algorithm>
#include <cmath>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <memory>
#include <ostream>  // NOLINT
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>


// MSVC warning C5046 is new as of VS2017 version 15.8.
#if defined(_MSC_VER) && _MSC_VER >= 1915
#define GMOCK_MAYBE_5046_ 5046
#else
#define GMOCK_MAYBE_5046_
#endif

GTEST_DISABLE_MSC_WARNINGS_PUSH_(
    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
                              clients of class B */
    /* Symbol involving type with internal linkage not defined */)

namespace testing {

// To implement a matcher Foo for type T, define:
//   1. a class FooMatcherImpl that implements the
//      MatcherInterface<T> interface, and
//   2. a factory function that creates a Matcher<T> object from a
//      FooMatcherImpl*.
//
// The two-level delegation design makes it possible to allow a user
// to write "v" instead of "Eq(v)" where a Matcher is expected, which
// is impossible if we pass matchers by pointers.  It also eases
// ownership management as Matcher objects can now be copied like
// plain values.

// A match result listener that stores the explanation in a string.
class StringMatchResultListener : public MatchResultListener {
 public:
  StringMatchResultListener() : MatchResultListener(&ss_) {}

  // Returns the explanation accumulated so far.
  std::string str() const { return ss_.str(); }

  // Clears the explanation accumulated so far.
  void Clear() { ss_.str(""); }

 private:
  ::std::stringstream ss_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
};

// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
// and MUST NOT BE USED IN USER CODE!!!
namespace internal {

// The MatcherCastImpl class template is a helper for implementing
// MatcherCast().  We need this helper in order to partially
// specialize the implementation of MatcherCast() (C++ allows
// class/struct templates to be partially specialized, but not
// function templates.).

// This general version is used when MatcherCast()'s argument is a
// polymorphic matcher (i.e. something that can be converted to a
// Matcher but is not one yet; for example, Eq(value)) or a value (for
// example, "hello").
template <typename T, typename M>
class MatcherCastImpl {
 public:
  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
    // M can be a polymorphic matcher, in which case we want to use
    // its conversion operator to create Matcher<T>.  Or it can be a value
    // that should be passed to the Matcher<T>'s constructor.
    //
    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
    // polymorphic matcher because it'll be ambiguous if T has an implicit
    // constructor from M (this usually happens when T has an implicit
    // constructor from any type).
    //
    // It won't work to unconditionally implicit_cast
    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
    // a user-defined conversion from M to T if one exists (assuming M is
    // a value).
    return CastImpl(polymorphic_matcher_or_value,
                    std::is_convertible<M, Matcher<T>>{},
                    std::is_convertible<M, T>{});
  }

 private:
  template <bool Ignore>
  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
                             std::true_type /* convertible_to_matcher */,
                             std::integral_constant<bool, Ignore>) {
    // M is implicitly convertible to Matcher<T>, which means that either
    // M is a polymorphic matcher or Matcher<T> has an implicit constructor
    // from M.  In both cases using the implicit conversion will produce a
    // matcher.
    //
    // Even if T has an implicit constructor from M, it won't be called because
    // creating Matcher<T> would require a chain of two user-defined conversions
    // (first to create T from M and then to create Matcher<T> from T).
    return polymorphic_matcher_or_value;
  }

  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
  // matcher. It's a value of a type implicitly convertible to T. Use direct
  // initialization to create a matcher.
  static Matcher<T> CastImpl(const M& value,
                             std::false_type /* convertible_to_matcher */,
                             std::true_type /* convertible_to_T */) {
    return Matcher<T>(ImplicitCast_<T>(value));
  }

  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use
  // polymorphic matcher Eq(value) in this case.
  //
  // Note that we first attempt to perform an implicit cast on the value and
  // only fall back to the polymorphic Eq() matcher afterwards because the
  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
  // which might be undefined even when Rhs is implicitly convertible to Lhs
  // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
  //
  // We don't define this method inline as we need the declaration of Eq().
  static Matcher<T> CastImpl(const M& value,
                             std::false_type /* convertible_to_matcher */,
                             std::false_type /* convertible_to_T */);
};

// This more specialized version is used when MatcherCast()'s argument
// is already a Matcher.  This only compiles when type T can be
// statically converted to type U.
template <typename T, typename U>
class MatcherCastImpl<T, Matcher<U> > {
 public:
  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
    return Matcher<T>(new Impl(source_matcher));
  }

 private:
  class Impl : public MatcherInterface<T> {
   public:
    explicit Impl(const Matcher<U>& source_matcher)
        : source_matcher_(source_matcher) {}

    // We delegate the matching logic to the source matcher.
    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
      using FromType = typename std::remove_cv<typename std::remove_pointer<
          typename std::remove_reference<T>::type>::type>::type;
      using ToType = typename std::remove_cv<typename std::remove_pointer<
          typename std::remove_reference<U>::type>::type>::type;
      // Do not allow implicitly converting base*/& to derived*/&.
      static_assert(
          // Do not trigger if only one of them is a pointer. That implies a
          // regular conversion and not a down_cast.
          (std::is_pointer<typename std::remove_reference<T>::type>::value !=
           std::is_pointer<typename std::remove_reference<U>::type>::value) ||
              std::is_same<FromType, ToType>::value ||
              !std::is_base_of<FromType, ToType>::value,
          "Can't implicitly convert from <base> to <derived>");

      // Do the cast to `U` explicitly if necessary.
      // Otherwise, let implicit conversions do the trick.
      using CastType =
          typename std::conditional<std::is_convertible<T&, const U&>::value,
                                    T&, U>::type;

      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
                                             listener);
    }

    void DescribeTo(::std::ostream* os) const override {
      source_matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      source_matcher_.DescribeNegationTo(os);
    }

   private:
    const Matcher<U> source_matcher_;
  };
};

// This even more specialized version is used for efficiently casting
// a matcher to its own type.
template <typename T>
class MatcherCastImpl<T, Matcher<T> > {
 public:
  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
};

// Template specialization for parameterless Matcher.
template <typename Derived>
class MatcherBaseImpl {
 public:
  MatcherBaseImpl() = default;

  template <typename T>
  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit)
    return ::testing::Matcher<T>(new
                                 typename Derived::template gmock_Impl<T>());
  }
};

// Template specialization for Matcher with parameters.
template <template <typename...> class Derived, typename... Ts>
class MatcherBaseImpl<Derived<Ts...>> {
 public:
  // Mark the constructor explicit for single argument T to avoid implicit
  // conversions.
  template <typename E = std::enable_if<sizeof...(Ts) == 1>,
            typename E::type* = nullptr>
  explicit MatcherBaseImpl(Ts... params)
      : params_(std::forward<Ts>(params)...) {}
  template <typename E = std::enable_if<sizeof...(Ts) != 1>,
            typename = typename E::type>
  MatcherBaseImpl(Ts... params)  // NOLINT
      : params_(std::forward<Ts>(params)...) {}

  template <typename F>
  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
  }

 private:
  template <typename F, std::size_t... tuple_ids>
  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
    return ::testing::Matcher<F>(
        new typename Derived<Ts...>::template gmock_Impl<F>(
            std::get<tuple_ids>(params_)...));
  }

  const std::tuple<Ts...> params_;
};

}  // namespace internal

// In order to be safe and clear, casting between different matcher
// types is done explicitly via MatcherCast<T>(m), which takes a
// matcher m and returns a Matcher<T>.  It compiles only when T can be
// statically converted to the argument type of m.
template <typename T, typename M>
inline Matcher<T> MatcherCast(const M& matcher) {
  return internal::MatcherCastImpl<T, M>::Cast(matcher);
}

// This overload handles polymorphic matchers and values only since
// monomorphic matchers are handled by the next one.
template <typename T, typename M>
inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
  return MatcherCast<T>(polymorphic_matcher_or_value);
}

// This overload handles monomorphic matchers.
//
// In general, if type T can be implicitly converted to type U, we can
// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
// contravariant): just keep a copy of the original Matcher<U>, convert the
// argument from type T to U, and then pass it to the underlying Matcher<U>.
// The only exception is when U is a reference and T is not, as the
// underlying Matcher<U> may be interested in the argument's address, which
// is not preserved in the conversion from T to U.
template <typename T, typename U>
inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
  // Enforce that T can be implicitly converted to U.
  static_assert(std::is_convertible<const T&, const U&>::value,
                "T must be implicitly convertible to U");
  // Enforce that we are not converting a non-reference type T to a reference
  // type U.
  GTEST_COMPILE_ASSERT_(
      std::is_reference<T>::value || !std::is_reference<U>::value,
      cannot_convert_non_reference_arg_to_reference);
  // In case both T and U are arithmetic types, enforce that the
  // conversion is not lossy.
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
  GTEST_COMPILE_ASSERT_(
      kTIsOther || kUIsOther ||
      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
      conversion_of_arithmetic_types_must_be_lossless);
  return MatcherCast<T>(matcher);
}

// A<T>() returns a matcher that matches any value of type T.
template <typename T>
Matcher<T> A();

// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
// and MUST NOT BE USED IN USER CODE!!!
namespace internal {

// If the explanation is not empty, prints it to the ostream.
inline void PrintIfNotEmpty(const std::string& explanation,
                            ::std::ostream* os) {
  if (explanation != "" && os != nullptr) {
    *os << ", " << explanation;
  }
}

// Returns true if the given type name is easy to read by a human.
// This is used to decide whether printing the type of a value might
// be helpful.
inline bool IsReadableTypeName(const std::string& type_name) {
  // We consider a type name readable if it's short or doesn't contain
  // a template or function type.
  return (type_name.length() <= 20 ||
          type_name.find_first_of("<(") == std::string::npos);
}

// Matches the value against the given matcher, prints the value and explains
// the match result to the listener. Returns the match result.
// 'listener' must not be NULL.
// Value cannot be passed by const reference, because some matchers take a
// non-const argument.
template <typename Value, typename T>
bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
                          MatchResultListener* listener) {
  if (!listener->IsInterested()) {
    // If the listener is not interested, we do not need to construct the
    // inner explanation.
    return matcher.Matches(value);
  }

  StringMatchResultListener inner_listener;
  const bool match = matcher.MatchAndExplain(value, &inner_listener);

  UniversalPrint(value, listener->stream());
#if GTEST_HAS_RTTI
  const std::string& type_name = GetTypeName<Value>();
  if (IsReadableTypeName(type_name))
    *listener->stream() << " (of type " << type_name << ")";
#endif
  PrintIfNotEmpty(inner_listener.str(), listener->stream());

  return match;
}

// An internal helper class for doing compile-time loop on a tuple's
// fields.
template <size_t N>
class TuplePrefix {
 public:
  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
  // if and only if the first N fields of matcher_tuple matches
  // the first N fields of value_tuple, respectively.
  template <typename MatcherTuple, typename ValueTuple>
  static bool Matches(const MatcherTuple& matcher_tuple,
                      const ValueTuple& value_tuple) {
    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));
  }

  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
  // describes failures in matching the first N fields of matchers
  // against the first N fields of values.  If there is no failure,
  // nothing will be streamed to os.
  template <typename MatcherTuple, typename ValueTuple>
  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
                                     const ValueTuple& values,
                                     ::std::ostream* os) {
    // First, describes failures in the first N - 1 fields.
    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);

    // Then describes the failure (if any) in the (N - 1)-th (0-based)
    // field.
    typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
        std::get<N - 1>(matchers);
    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
    const Value& value = std::get<N - 1>(values);
    StringMatchResultListener listener;
    if (!matcher.MatchAndExplain(value, &listener)) {
      *os << "  Expected arg #" << N - 1 << ": ";
      std::get<N - 1>(matchers).DescribeTo(os);
      *os << "\n           Actual: ";
      // We remove the reference in type Value to prevent the
      // universal printer from printing the address of value, which
      // isn't interesting to the user most of the time.  The
      // matcher's MatchAndExplain() method handles the case when
      // the address is interesting.
      internal::UniversalPrint(value, os);
      PrintIfNotEmpty(listener.str(), os);
      *os << "\n";
    }
  }
};

// The base case.
template <>
class TuplePrefix<0> {
 public:
  template <typename MatcherTuple, typename ValueTuple>
  static bool Matches(const MatcherTuple& /* matcher_tuple */,
                      const ValueTuple& /* value_tuple */) {
    return true;
  }

  template <typename MatcherTuple, typename ValueTuple>
  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
                                     const ValueTuple& /* values */,
                                     ::std::ostream* /* os */) {}
};

// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
// all matchers in matcher_tuple match the corresponding fields in
// value_tuple.  It is a compiler error if matcher_tuple and
// value_tuple have different number of fields or incompatible field
// types.
template <typename MatcherTuple, typename ValueTuple>
bool TupleMatches(const MatcherTuple& matcher_tuple,
                  const ValueTuple& value_tuple) {
  // Makes sure that matcher_tuple and value_tuple have the same
  // number of fields.
  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
                            std::tuple_size<ValueTuple>::value,
                        matcher_and_value_have_different_numbers_of_fields);
  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
                                                                  value_tuple);
}

// Describes failures in matching matchers against values.  If there
// is no failure, nothing will be streamed to os.
template <typename MatcherTuple, typename ValueTuple>
void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
                                const ValueTuple& values,
                                ::std::ostream* os) {
  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
      matchers, values, os);
}

// TransformTupleValues and its helper.
//
// TransformTupleValuesHelper hides the internal machinery that
// TransformTupleValues uses to implement a tuple traversal.
template <typename Tuple, typename Func, typename OutIter>
class TransformTupleValuesHelper {
 private:
  typedef ::std::tuple_size<Tuple> TupleSize;

 public:
  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
  // Returns the final value of 'out' in case the caller needs it.
  static OutIter Run(Func f, const Tuple& t, OutIter out) {
    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
  }

 private:
  template <typename Tup, size_t kRemainingSize>
  struct IterateOverTuple {
    OutIter operator() (Func f, const Tup& t, OutIter out) const {
      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
    }
  };
  template <typename Tup>
  struct IterateOverTuple<Tup, 0> {
    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
      return out;
    }
  };
};

// Successively invokes 'f(element)' on each element of the tuple 't',
// appending each result to the 'out' iterator. Returns the final value
// of 'out'.
template <typename Tuple, typename Func, typename OutIter>
OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
}

// Implements _, a matcher that matches any value of any
// type.  This is a polymorphic matcher, so we need a template type
// conversion operator to make it appearing as a Matcher<T> for any
// type T.
class AnythingMatcher {
 public:
  using is_gtest_matcher = void;

  template <typename T>
  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {
    return true;
  }
  void DescribeTo(std::ostream* os) const { *os << "is anything"; }
  void DescribeNegationTo(::std::ostream* os) const {
    // This is mostly for completeness' sake, as it's not very useful
    // to write Not(A<bool>()).  However we cannot completely rule out
    // such a possibility, and it doesn't hurt to be prepared.
    *os << "never matches";
  }
};

// Implements the polymorphic IsNull() matcher, which matches any raw or smart
// pointer that is NULL.
class IsNullMatcher {
 public:
  template <typename Pointer>
  bool MatchAndExplain(const Pointer& p,
                       MatchResultListener* /* listener */) const {
    return p == nullptr;
  }

  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
  void DescribeNegationTo(::std::ostream* os) const {
    *os << "isn't NULL";
  }
};

// Implements the polymorphic NotNull() matcher, which matches any raw or smart
// pointer that is not NULL.
class NotNullMatcher {
 public:
  template <typename Pointer>
  bool MatchAndExplain(const Pointer& p,
                       MatchResultListener* /* listener */) const {
    return p != nullptr;
  }

  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
  void DescribeNegationTo(::std::ostream* os) const {
    *os << "is NULL";
  }
};

// Ref(variable) matches any argument that is a reference to
// 'variable'.  This matcher is polymorphic as it can match any
// super type of the type of 'variable'.
//
// The RefMatcher template class implements Ref(variable).  It can
// only be instantiated with a reference type.  This prevents a user
// from mistakenly using Ref(x) to match a non-reference function
// argument.  For example, the following will righteously cause a
// compiler error:
//
//   int n;
//   Matcher<int> m1 = Ref(n);   // This won't compile.
//   Matcher<int&> m2 = Ref(n);  // This will compile.
template <typename T>
class RefMatcher;

template <typename T>
class RefMatcher<T&> {
  // Google Mock is a generic framework and thus needs to support
  // mocking any function types, including those that take non-const
  // reference arguments.  Therefore the template parameter T (and
  // Super below) can be instantiated to either a const type or a
  // non-const type.
 public:
  // RefMatcher() takes a T& instead of const T&, as we want the
  // compiler to catch using Ref(const_value) as a matcher for a
  // non-const reference.
  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT

  template <typename Super>
  operator Matcher<Super&>() const {
    // By passing object_ (type T&) to Impl(), which expects a Super&,
    // we make sure that Super is a super type of T.  In particular,
    // this catches using Ref(const_value) as a matcher for a
    // non-const reference, as you cannot implicitly convert a const
    // reference to a non-const reference.
    return MakeMatcher(new Impl<Super>(object_));
  }

 private:
  template <typename Super>
  class Impl : public MatcherInterface<Super&> {
   public:
    explicit Impl(Super& x) : object_(x) {}  // NOLINT

    // MatchAndExplain() takes a Super& (as opposed to const Super&)
    // in order to match the interface MatcherInterface<Super&>.
    bool MatchAndExplain(Super& x,
                         MatchResultListener* listener) const override {
      *listener << "which is located @" << static_cast<const void*>(&x);
      return &x == &object_;
    }

    void DescribeTo(::std::ostream* os) const override {
      *os << "references the variable ";
      UniversalPrinter<Super&>::Print(object_, os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "does not reference the variable ";
      UniversalPrinter<Super&>::Print(object_, os);
    }

   private:
    const Super& object_;
  };

  T& object_;
};

// Polymorphic helper functions for narrow and wide string matchers.
inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
  return String::CaseInsensitiveCStringEquals(lhs, rhs);
}

inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
                                         const wchar_t* rhs) {
  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
}

// String comparison for narrow or wide strings that can have embedded NUL
// characters.
template <typename StringType>
bool CaseInsensitiveStringEquals(const StringType& s1,
                                 const StringType& s2) {
  // Are the heads equal?
  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
    return false;
  }

  // Skip the equal heads.
  const typename StringType::value_type nul = 0;
  const size_t i1 = s1.find(nul), i2 = s2.find(nul);

  // Are we at the end of either s1 or s2?
  if (i1 == StringType::npos || i2 == StringType::npos) {
    return i1 == i2;
  }

  // Are the tails equal?
  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
}

// String matchers.

// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
template <typename StringType>
class StrEqualityMatcher {
 public:
  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
      : string_(std::move(str)),
        expect_eq_(expect_eq),
        case_sensitive_(case_sensitive) {}

#if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    // This should fail to compile if StringView is used with wide
    // strings.
    const StringType& str = std::string(s);
    return MatchAndExplain(str, listener);
  }
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

  // Accepts pointer types, particularly:
  //   const char*
  //   char*
  //   const wchar_t*
  //   wchar_t*
  template <typename CharType>
  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
    if (s == nullptr) {
      return !expect_eq_;
    }
    return MatchAndExplain(StringType(s), listener);
  }

  // Matches anything that can convert to StringType.
  //
  // This is a template, not just a plain function with const StringType&,
  // because StringView has some interfering non-explicit constructors.
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
    const StringType s2(s);
    const bool eq = case_sensitive_ ? s2 == string_ :
        CaseInsensitiveStringEquals(s2, string_);
    return expect_eq_ == eq;
  }

  void DescribeTo(::std::ostream* os) const {
    DescribeToHelper(expect_eq_, os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    DescribeToHelper(!expect_eq_, os);
  }

 private:
  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
    *os << (expect_eq ? "is " : "isn't ");
    *os << "equal to ";
    if (!case_sensitive_) {
      *os << "(ignoring case) ";
    }
    UniversalPrint(string_, os);
  }

  const StringType string_;
  const bool expect_eq_;
  const bool case_sensitive_;
};

// Implements the polymorphic HasSubstr(substring) matcher, which
// can be used as a Matcher<T> as long as T can be converted to a
// string.
template <typename StringType>
class HasSubstrMatcher {
 public:
  explicit HasSubstrMatcher(const StringType& substring)
      : substring_(substring) {}

#if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    // This should fail to compile if StringView is used with wide
    // strings.
    const StringType& str = std::string(s);
    return MatchAndExplain(str, listener);
  }
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

  // Accepts pointer types, particularly:
  //   const char*
  //   char*
  //   const wchar_t*
  //   wchar_t*
  template <typename CharType>
  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
    return s != nullptr && MatchAndExplain(StringType(s), listener);
  }

  // Matches anything that can convert to StringType.
  //
  // This is a template, not just a plain function with const StringType&,
  // because StringView has some interfering non-explicit constructors.
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
    return StringType(s).find(substring_) != StringType::npos;
  }

  // Describes what this matcher matches.
  void DescribeTo(::std::ostream* os) const {
    *os << "has substring ";
    UniversalPrint(substring_, os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "has no substring ";
    UniversalPrint(substring_, os);
  }

 private:
  const StringType substring_;
};

// Implements the polymorphic StartsWith(substring) matcher, which
// can be used as a Matcher<T> as long as T can be converted to a
// string.
template <typename StringType>
class StartsWithMatcher {
 public:
  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
  }

#if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    // This should fail to compile if StringView is used with wide
    // strings.
    const StringType& str = std::string(s);
    return MatchAndExplain(str, listener);
  }
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

  // Accepts pointer types, particularly:
  //   const char*
  //   char*
  //   const wchar_t*
  //   wchar_t*
  template <typename CharType>
  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
    return s != nullptr && MatchAndExplain(StringType(s), listener);
  }

  // Matches anything that can convert to StringType.
  //
  // This is a template, not just a plain function with const StringType&,
  // because StringView has some interfering non-explicit constructors.
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
    const StringType& s2(s);
    return s2.length() >= prefix_.length() &&
        s2.substr(0, prefix_.length()) == prefix_;
  }

  void DescribeTo(::std::ostream* os) const {
    *os << "starts with ";
    UniversalPrint(prefix_, os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "doesn't start with ";
    UniversalPrint(prefix_, os);
  }

 private:
  const StringType prefix_;
};

// Implements the polymorphic EndsWith(substring) matcher, which
// can be used as a Matcher<T> as long as T can be converted to a
// string.
template <typename StringType>
class EndsWithMatcher {
 public:
  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}

#if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    // This should fail to compile if StringView is used with wide
    // strings.
    const StringType& str = std::string(s);
    return MatchAndExplain(str, listener);
  }
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

  // Accepts pointer types, particularly:
  //   const char*
  //   char*
  //   const wchar_t*
  //   wchar_t*
  template <typename CharType>
  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
    return s != nullptr && MatchAndExplain(StringType(s), listener);
  }

  // Matches anything that can convert to StringType.
  //
  // This is a template, not just a plain function with const StringType&,
  // because StringView has some interfering non-explicit constructors.
  template <typename MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
    const StringType& s2(s);
    return s2.length() >= suffix_.length() &&
        s2.substr(s2.length() - suffix_.length()) == suffix_;
  }

  void DescribeTo(::std::ostream* os) const {
    *os << "ends with ";
    UniversalPrint(suffix_, os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "doesn't end with ";
    UniversalPrint(suffix_, os);
  }

 private:
  const StringType suffix_;
};

// Implements a matcher that compares the two fields of a 2-tuple
// using one of the ==, <=, <, etc, operators.  The two fields being
// compared don't have to have the same type.
//
// The matcher defined here is polymorphic (for example, Eq() can be
// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
// etc).  Therefore we use a template type conversion operator in the
// implementation.
template <typename D, typename Op>
class PairMatchBase {
 public:
  template <typename T1, typename T2>
  operator Matcher<::std::tuple<T1, T2>>() const {
    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);
  }
  template <typename T1, typename T2>
  operator Matcher<const ::std::tuple<T1, T2>&>() const {
    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
  }

 private:
  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
    return os << D::Desc();
  }

  template <typename Tuple>
  class Impl : public MatcherInterface<Tuple> {
   public:
    bool MatchAndExplain(Tuple args,
                         MatchResultListener* /* listener */) const override {
      return Op()(::std::get<0>(args), ::std::get<1>(args));
    }
    void DescribeTo(::std::ostream* os) const override {
      *os << "are " << GetDesc;
    }
    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "aren't " << GetDesc;
    }
  };
};

class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
 public:
  static const char* Desc() { return "an equal pair"; }
};
class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
 public:
  static const char* Desc() { return "an unequal pair"; }
};
class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
 public:
  static const char* Desc() { return "a pair where the first < the second"; }
};
class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
 public:
  static const char* Desc() { return "a pair where the first > the second"; }
};
class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
 public:
  static const char* Desc() { return "a pair where the first <= the second"; }
};
class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
 public:
  static const char* Desc() { return "a pair where the first >= the second"; }
};

// Implements the Not(...) matcher for a particular argument type T.
// We do not nest it inside the NotMatcher class template, as that
// will prevent different instantiations of NotMatcher from sharing
// the same NotMatcherImpl<T> class.
template <typename T>
class NotMatcherImpl : public MatcherInterface<const T&> {
 public:
  explicit NotMatcherImpl(const Matcher<T>& matcher)
      : matcher_(matcher) {}

  bool MatchAndExplain(const T& x,
                       MatchResultListener* listener) const override {
    return !matcher_.MatchAndExplain(x, listener);
  }

  void DescribeTo(::std::ostream* os) const override {
    matcher_.DescribeNegationTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    matcher_.DescribeTo(os);
  }

 private:
  const Matcher<T> matcher_;
};

// Implements the Not(m) matcher, which matches a value that doesn't
// match matcher m.
template <typename InnerMatcher>
class NotMatcher {
 public:
  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}

  // This template type conversion operator allows Not(m) to be used
  // to match any type m can match.
  template <typename T>
  operator Matcher<T>() const {
    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
  }

 private:
  InnerMatcher matcher_;
};

// Implements the AllOf(m1, m2) matcher for a particular argument type
// T. We do not nest it inside the BothOfMatcher class template, as
// that will prevent different instantiations of BothOfMatcher from
// sharing the same BothOfMatcherImpl<T> class.
template <typename T>
class AllOfMatcherImpl : public MatcherInterface<const T&> {
 public:
  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
      : matchers_(std::move(matchers)) {}

  void DescribeTo(::std::ostream* os) const override {
    *os << "(";
    for (size_t i = 0; i < matchers_.size(); ++i) {
      if (i != 0) *os << ") and (";
      matchers_[i].DescribeTo(os);
    }
    *os << ")";
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "(";
    for (size_t i = 0; i < matchers_.size(); ++i) {
      if (i != 0) *os << ") or (";
      matchers_[i].DescribeNegationTo(os);
    }
    *os << ")";
  }

  bool MatchAndExplain(const T& x,
                       MatchResultListener* listener) const override {
    // If either matcher1_ or matcher2_ doesn't match x, we only need
    // to explain why one of them fails.
    std::string all_match_result;

    for (size_t i = 0; i < matchers_.size(); ++i) {
      StringMatchResultListener slistener;
      if (matchers_[i].MatchAndExplain(x, &slistener)) {
        if (all_match_result.empty()) {
          all_match_result = slistener.str();
        } else {
          std::string result = slistener.str();
          if (!result.empty()) {
            all_match_result += ", and ";
            all_match_result += result;
          }
        }
      } else {
        *listener << slistener.str();
        return false;
      }
    }

    // Otherwise we need to explain why *both* of them match.
    *listener << all_match_result;
    return true;
  }

 private:
  const std::vector<Matcher<T> > matchers_;
};

// VariadicMatcher is used for the variadic implementation of
// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
// CombiningMatcher<T> is used to recursively combine the provided matchers
// (of type Args...).
template <template <typename T> class CombiningMatcher, typename... Args>
class VariadicMatcher {
 public:
  VariadicMatcher(const Args&... matchers)  // NOLINT
      : matchers_(matchers...) {
    static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");
  }

  VariadicMatcher(const VariadicMatcher&) = default;
  VariadicMatcher& operator=(const VariadicMatcher&) = delete;

  // This template type conversion operator allows an
  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
  template <typename T>
  operator Matcher<T>() const {
    std::vector<Matcher<T> > values;
    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
    return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
  }

 private:
  template <typename T, size_t I>
  void CreateVariadicMatcher(std::vector<Matcher<T> >* values,
                             std::integral_constant<size_t, I>) const {
    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
  }

  template <typename T>
  void CreateVariadicMatcher(
      std::vector<Matcher<T> >*,
      std::integral_constant<size_t, sizeof...(Args)>) const {}

  std::tuple<Args...> matchers_;
};

template <typename... Args>
using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;

// Implements the AnyOf(m1, m2) matcher for a particular argument type
// T.  We do not nest it inside the AnyOfMatcher class template, as
// that will prevent different instantiations of AnyOfMatcher from
// sharing the same EitherOfMatcherImpl<T> class.
template <typename T>
class AnyOfMatcherImpl : public MatcherInterface<const T&> {
 public:
  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
      : matchers_(std::move(matchers)) {}

  void DescribeTo(::std::ostream* os) const override {
    *os << "(";
    for (size_t i = 0; i < matchers_.size(); ++i) {
      if (i != 0) *os << ") or (";
      matchers_[i].DescribeTo(os);
    }
    *os << ")";
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "(";
    for (size_t i = 0; i < matchers_.size(); ++i) {
      if (i != 0) *os << ") and (";
      matchers_[i].DescribeNegationTo(os);
    }
    *os << ")";
  }

  bool MatchAndExplain(const T& x,
                       MatchResultListener* listener) const override {
    std::string no_match_result;

    // If either matcher1_ or matcher2_ matches x, we just need to
    // explain why *one* of them matches.
    for (size_t i = 0; i < matchers_.size(); ++i) {
      StringMatchResultListener slistener;
      if (matchers_[i].MatchAndExplain(x, &slistener)) {
        *listener << slistener.str();
        return true;
      } else {
        if (no_match_result.empty()) {
          no_match_result = slistener.str();
        } else {
          std::string result = slistener.str();
          if (!result.empty()) {
            no_match_result += ", and ";
            no_match_result += result;
          }
        }
      }
    }

    // Otherwise we need to explain why *both* of them fail.
    *listener << no_match_result;
    return false;
  }

 private:
  const std::vector<Matcher<T> > matchers_;
};

// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
template <typename... Args>
using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;

// Wrapper for implementation of Any/AllOfArray().
template <template <class> class MatcherImpl, typename T>
class SomeOfArrayMatcher {
 public:
  // Constructs the matcher from a sequence of element values or
  // element matchers.
  template <typename Iter>
  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}

  template <typename U>
  operator Matcher<U>() const {  // NOLINT
    using RawU = typename std::decay<U>::type;
    std::vector<Matcher<RawU>> matchers;
    for (const auto& matcher : matchers_) {
      matchers.push_back(MatcherCast<RawU>(matcher));
    }
    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
  }

 private:
  const ::std::vector<T> matchers_;
};

template <typename T>
using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;

template <typename T>
using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;

// Used for implementing Truly(pred), which turns a predicate into a
// matcher.
template <typename Predicate>
class TrulyMatcher {
 public:
  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}

  // This method template allows Truly(pred) to be used as a matcher
  // for type T where T is the argument type of predicate 'pred'.  The
  // argument is passed by reference as the predicate may be
  // interested in the address of the argument.
  template <typename T>
  bool MatchAndExplain(T& x,  // NOLINT
                       MatchResultListener* listener) const {
    // Without the if-statement, MSVC sometimes warns about converting
    // a value to bool (warning 4800).
    //
    // We cannot write 'return !!predicate_(x);' as that doesn't work
    // when predicate_(x) returns a class convertible to bool but
    // having no operator!().
    if (predicate_(x))
      return true;
    *listener << "didn't satisfy the given predicate";
    return false;
  }

  void DescribeTo(::std::ostream* os) const {
    *os << "satisfies the given predicate";
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "doesn't satisfy the given predicate";
  }

 private:
  Predicate predicate_;
};

// Used for implementing Matches(matcher), which turns a matcher into
// a predicate.
template <typename M>
class MatcherAsPredicate {
 public:
  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}

  // This template operator() allows Matches(m) to be used as a
  // predicate on type T where m is a matcher on type T.
  //
  // The argument x is passed by reference instead of by value, as
  // some matcher may be interested in its address (e.g. as in
  // Matches(Ref(n))(x)).
  template <typename T>
  bool operator()(const T& x) const {
    // We let matcher_ commit to a particular type here instead of
    // when the MatcherAsPredicate object was constructed.  This
    // allows us to write Matches(m) where m is a polymorphic matcher
    // (e.g. Eq(5)).
    //
    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
    // compile when matcher_ has type Matcher<const T&>; if we write
    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
    // when matcher_ has type Matcher<T>; if we just write
    // matcher_.Matches(x), it won't compile when matcher_ is
    // polymorphic, e.g. Eq(5).
    //
    // MatcherCast<const T&>() is necessary for making the code work
    // in all of the above situations.
    return MatcherCast<const T&>(matcher_).Matches(x);
  }

 private:
  M matcher_;
};

// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
// argument M must be a type that can be converted to a matcher.
template <typename M>
class PredicateFormatterFromMatcher {
 public:
  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}

  // This template () operator allows a PredicateFormatterFromMatcher
  // object to act as a predicate-formatter suitable for using with
  // Google Test's EXPECT_PRED_FORMAT1() macro.
  template <typename T>
  AssertionResult operator()(const char* value_text, const T& x) const {
    // We convert matcher_ to a Matcher<const T&> *now* instead of
    // when the PredicateFormatterFromMatcher object was constructed,
    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
    // know which type to instantiate it to until we actually see the
    // type of x here.
    //
    // We write SafeMatcherCast<const T&>(matcher_) instead of
    // Matcher<const T&>(matcher_), as the latter won't compile when
    // matcher_ has type Matcher<T> (e.g. An<int>()).
    // We don't write MatcherCast<const T&> either, as that allows
    // potentially unsafe downcasting of the matcher argument.
    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);

    // The expected path here is that the matcher should match (i.e. that most
    // tests pass) so optimize for this case.
    if (matcher.Matches(x)) {
      return AssertionSuccess();
    }

    ::std::stringstream ss;
    ss << "Value of: " << value_text << "\n"
       << "Expected: ";
    matcher.DescribeTo(&ss);

    // Rerun the matcher to "PrintAndExplain" the failure.
    StringMatchResultListener listener;
    if (MatchPrintAndExplain(x, matcher, &listener)) {
      ss << "\n  The matcher failed on the initial attempt; but passed when "
            "rerun to generate the explanation.";
    }
    ss << "\n  Actual: " << listener.str();
    return AssertionFailure() << ss.str();
  }

 private:
  const M matcher_;
};

// A helper function for converting a matcher to a predicate-formatter
// without the user needing to explicitly write the type.  This is
// used for implementing ASSERT_THAT() and EXPECT_THAT().
// Implementation detail: 'matcher' is received by-value to force decaying.
template <typename M>
inline PredicateFormatterFromMatcher<M>
MakePredicateFormatterFromMatcher(M matcher) {
  return PredicateFormatterFromMatcher<M>(std::move(matcher));
}

// Implements the polymorphic IsNan() matcher, which matches any floating type
// value that is Nan.
class IsNanMatcher {
 public:
  template <typename FloatType>
  bool MatchAndExplain(const FloatType& f,
                       MatchResultListener* /* listener */) const {
    return (::std::isnan)(f);
  }

  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
  void DescribeNegationTo(::std::ostream* os) const {
    *os << "isn't NaN";
  }
};

// Implements the polymorphic floating point equality matcher, which matches
// two float values using ULP-based approximation or, optionally, a
// user-specified epsilon.  The template is meant to be instantiated with
// FloatType being either float or double.
template <typename FloatType>
class FloatingEqMatcher {
 public:
  // Constructor for FloatingEqMatcher.
  // The matcher's input will be compared with expected.  The matcher treats two
  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
  // equality comparisons between NANs will always return false.  We specify a
  // negative max_abs_error_ term to indicate that ULP-based approximation will
  // be used for comparison.
  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
  }

  // Constructor that supports a user-specified max_abs_error that will be used
  // for comparison instead of ULP-based approximation.  The max absolute
  // should be non-negative.
  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
                    FloatType max_abs_error)
      : expected_(expected),
        nan_eq_nan_(nan_eq_nan),
        max_abs_error_(max_abs_error) {
    GTEST_CHECK_(max_abs_error >= 0)
        << ", where max_abs_error is" << max_abs_error;
  }

  // Implements floating point equality matcher as a Matcher<T>.
  template <typename T>
  class Impl : public MatcherInterface<T> {
   public:
    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
        : expected_(expected),
          nan_eq_nan_(nan_eq_nan),
          max_abs_error_(max_abs_error) {}

    bool MatchAndExplain(T value,
                         MatchResultListener* listener) const override {
      const FloatingPoint<FloatType> actual(value), expected(expected_);

      // Compares NaNs first, if nan_eq_nan_ is true.
      if (actual.is_nan() || expected.is_nan()) {
        if (actual.is_nan() && expected.is_nan()) {
          return nan_eq_nan_;
        }
        // One is nan; the other is not nan.
        return false;
      }
      if (HasMaxAbsError()) {
        // We perform an equality check so that inf will match inf, regardless
        // of error bounds.  If the result of value - expected_ would result in
        // overflow or if either value is inf, the default result is infinity,
        // which should only match if max_abs_error_ is also infinity.
        if (value == expected_) {
          return true;
        }

        const FloatType diff = value - expected_;
        if (::std::fabs(diff) <= max_abs_error_) {
          return true;
        }

        if (listener->IsInterested()) {
          *listener << "which is " << diff << " from " << expected_;
        }
        return false;
      } else {
        return actual.AlmostEquals(expected);
      }
    }

    void DescribeTo(::std::ostream* os) const override {
      // os->precision() returns the previously set precision, which we
      // store to restore the ostream to its original configuration
      // after outputting.
      const ::std::streamsize old_precision = os->precision(
          ::std::numeric_limits<FloatType>::digits10 + 2);
      if (FloatingPoint<FloatType>(expected_).is_nan()) {
        if (nan_eq_nan_) {
          *os << "is NaN";
        } else {
          *os << "never matches";
        }
      } else {
        *os << "is approximately " << expected_;
        if (HasMaxAbsError()) {
          *os << " (absolute error <= " << max_abs_error_ << ")";
        }
      }
      os->precision(old_precision);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      // As before, get original precision.
      const ::std::streamsize old_precision = os->precision(
          ::std::numeric_limits<FloatType>::digits10 + 2);
      if (FloatingPoint<FloatType>(expected_).is_nan()) {
        if (nan_eq_nan_) {
          *os << "isn't NaN";
        } else {
          *os << "is anything";
        }
      } else {
        *os << "isn't approximately " << expected_;
        if (HasMaxAbsError()) {
          *os << " (absolute error > " << max_abs_error_ << ")";
        }
      }
      // Restore original precision.
      os->precision(old_precision);
    }

   private:
    bool HasMaxAbsError() const {
      return max_abs_error_ >= 0;
    }

    const FloatType expected_;
    const bool nan_eq_nan_;
    // max_abs_error will be used for value comparison when >= 0.
    const FloatType max_abs_error_;
  };

  // The following 3 type conversion operators allow FloatEq(expected) and
  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
  operator Matcher<FloatType>() const {
    return MakeMatcher(
        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
  }

  operator Matcher<const FloatType&>() const {
    return MakeMatcher(
        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
  }

  operator Matcher<FloatType&>() const {
    return MakeMatcher(
        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
  }

 private:
  const FloatType expected_;
  const bool nan_eq_nan_;
  // max_abs_error will be used for value comparison when >= 0.
  const FloatType max_abs_error_;
};

// A 2-tuple ("binary") wrapper around FloatingEqMatcher:
// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)
// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)
// against y. The former implements "Eq", the latter "Near". At present, there
// is no version that compares NaNs as equal.
template <typename FloatType>
class FloatingEq2Matcher {
 public:
  FloatingEq2Matcher() { Init(-1, false); }

  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }

  explicit FloatingEq2Matcher(FloatType max_abs_error) {
    Init(max_abs_error, false);
  }

  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {
    Init(max_abs_error, nan_eq_nan);
  }

  template <typename T1, typename T2>
  operator Matcher<::std::tuple<T1, T2>>() const {
    return MakeMatcher(
        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
  }
  template <typename T1, typename T2>
  operator Matcher<const ::std::tuple<T1, T2>&>() const {
    return MakeMatcher(
        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));
  }

 private:
  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
    return os << "an almost-equal pair";
  }

  template <typename Tuple>
  class Impl : public MatcherInterface<Tuple> {
   public:
    Impl(FloatType max_abs_error, bool nan_eq_nan) :
        max_abs_error_(max_abs_error),
        nan_eq_nan_(nan_eq_nan) {}

    bool MatchAndExplain(Tuple args,
                         MatchResultListener* listener) const override {
      if (max_abs_error_ == -1) {
        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
            ::std::get<1>(args), listener);
      } else {
        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
                                        max_abs_error_);
        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
            ::std::get<1>(args), listener);
      }
    }
    void DescribeTo(::std::ostream* os) const override {
      *os << "are " << GetDesc;
    }
    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "aren't " << GetDesc;
    }

   private:
    FloatType max_abs_error_;
    const bool nan_eq_nan_;
  };

  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {
    max_abs_error_ = max_abs_error_val;
    nan_eq_nan_ = nan_eq_nan_val;
  }
  FloatType max_abs_error_;
  bool nan_eq_nan_;
};

// Implements the Pointee(m) matcher for matching a pointer whose
// pointee matches matcher m.  The pointer can be either raw or smart.
template <typename InnerMatcher>
class PointeeMatcher {
 public:
  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}

  // This type conversion operator template allows Pointee(m) to be
  // used as a matcher for any pointer type whose pointee type is
  // compatible with the inner matcher, where type Pointer can be
  // either a raw pointer or a smart pointer.
  //
  // The reason we do this instead of relying on
  // MakePolymorphicMatcher() is that the latter is not flexible
  // enough for implementing the DescribeTo() method of Pointee().
  template <typename Pointer>
  operator Matcher<Pointer>() const {
    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
  }

 private:
  // The monomorphic implementation that works for a particular pointer type.
  template <typename Pointer>
  class Impl : public MatcherInterface<Pointer> {
   public:
    using Pointee =
        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
            Pointer)>::element_type;

    explicit Impl(const InnerMatcher& matcher)
        : matcher_(MatcherCast<const Pointee&>(matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "points to a value that ";
      matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "does not point to a value that ";
      matcher_.DescribeTo(os);
    }

    bool MatchAndExplain(Pointer pointer,
                         MatchResultListener* listener) const override {
      if (GetRawPointer(pointer) == nullptr) return false;

      *listener << "which points to ";
      return MatchPrintAndExplain(*pointer, matcher_, listener);
    }

   private:
    const Matcher<const Pointee&> matcher_;
  };

  const InnerMatcher matcher_;
};

// Implements the Pointer(m) matcher
// Implements the Pointer(m) matcher for matching a pointer that matches matcher
// m.  The pointer can be either raw or smart, and will match `m` against the
// raw pointer.
template <typename InnerMatcher>
class PointerMatcher {
 public:
  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}

  // This type conversion operator template allows Pointer(m) to be
  // used as a matcher for any pointer type whose pointer type is
  // compatible with the inner matcher, where type PointerType can be
  // either a raw pointer or a smart pointer.
  //
  // The reason we do this instead of relying on
  // MakePolymorphicMatcher() is that the latter is not flexible
  // enough for implementing the DescribeTo() method of Pointer().
  template <typename PointerType>
  operator Matcher<PointerType>() const {  // NOLINT
    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
  }

 private:
  // The monomorphic implementation that works for a particular pointer type.
  template <typename PointerType>
  class Impl : public MatcherInterface<PointerType> {
   public:
    using Pointer =
        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
            PointerType)>::element_type*;

    explicit Impl(const InnerMatcher& matcher)
        : matcher_(MatcherCast<Pointer>(matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "is a pointer that ";
      matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "is not a pointer that ";
      matcher_.DescribeTo(os);
    }

    bool MatchAndExplain(PointerType pointer,
                         MatchResultListener* listener) const override {
      *listener << "which is a pointer that ";
      Pointer p = GetRawPointer(pointer);
      return MatchPrintAndExplain(p, matcher_, listener);
    }

   private:
    Matcher<Pointer> matcher_;
  };

  const InnerMatcher matcher_;
};

#if GTEST_HAS_RTTI
// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
// reference that matches inner_matcher when dynamic_cast<T> is applied.
// The result of dynamic_cast<To> is forwarded to the inner matcher.
// If To is a pointer and the cast fails, the inner matcher will receive NULL.
// If To is a reference and the cast fails, this matcher returns false
// immediately.
template <typename To>
class WhenDynamicCastToMatcherBase {
 public:
  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
      : matcher_(matcher) {}

  void DescribeTo(::std::ostream* os) const {
    GetCastTypeDescription(os);
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    GetCastTypeDescription(os);
    matcher_.DescribeNegationTo(os);
  }

 protected:
  const Matcher<To> matcher_;

  static std::string GetToName() {
    return GetTypeName<To>();
  }

 private:
  static void GetCastTypeDescription(::std::ostream* os) {
    *os << "when dynamic_cast to " << GetToName() << ", ";
  }
};

// Primary template.
// To is a pointer. Cast and forward the result.
template <typename To>
class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
 public:
  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
      : WhenDynamicCastToMatcherBase<To>(matcher) {}

  template <typename From>
  bool MatchAndExplain(From from, MatchResultListener* listener) const {
    To to = dynamic_cast<To>(from);
    return MatchPrintAndExplain(to, this->matcher_, listener);
  }
};

// Specialize for references.
// In this case we return false if the dynamic_cast fails.
template <typename To>
class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
 public:
  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
      : WhenDynamicCastToMatcherBase<To&>(matcher) {}

  template <typename From>
  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
    // We don't want an std::bad_cast here, so do the cast with pointers.
    To* to = dynamic_cast<To*>(&from);
    if (to == nullptr) {
      *listener << "which cannot be dynamic_cast to " << this->GetToName();
      return false;
    }
    return MatchPrintAndExplain(*to, this->matcher_, listener);
  }
};
#endif  // GTEST_HAS_RTTI

// Implements the Field() matcher for matching a field (i.e. member
// variable) of an object.
template <typename Class, typename FieldType>
class FieldMatcher {
 public:
  FieldMatcher(FieldType Class::*field,
               const Matcher<const FieldType&>& matcher)
      : field_(field), matcher_(matcher), whose_field_("whose given field ") {}

  FieldMatcher(const std::string& field_name, FieldType Class::*field,
               const Matcher<const FieldType&>& matcher)
      : field_(field),
        matcher_(matcher),
        whose_field_("whose field `" + field_name + "` ") {}

  void DescribeTo(::std::ostream* os) const {
    *os << "is an object " << whose_field_;
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "is an object " << whose_field_;
    matcher_.DescribeNegationTo(os);
  }

  template <typename T>
  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for
    // a compiler bug, and can now be removed.
    return MatchAndExplainImpl(
        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
        value, listener);
  }

 private:
  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
                           const Class& obj,
                           MatchResultListener* listener) const {
    *listener << whose_field_ << "is ";
    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
  }

  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
                           MatchResultListener* listener) const {
    if (p == nullptr) return false;

    *listener << "which points to an object ";
    // Since *p has a field, it must be a class/struct/union type and
    // thus cannot be a pointer.  Therefore we pass false_type() as
    // the first argument.
    return MatchAndExplainImpl(std::false_type(), *p, listener);
  }

  const FieldType Class::*field_;
  const Matcher<const FieldType&> matcher_;

  // Contains either "whose given field " if the name of the field is unknown
  // or "whose field `name_of_field` " if the name is known.
  const std::string whose_field_;
};

// Implements the Property() matcher for matching a property
// (i.e. return value of a getter method) of an object.
//
// Property is a const-qualified member function of Class returning
// PropertyType.
template <typename Class, typename PropertyType, typename Property>
class PropertyMatcher {
 public:
  typedef const PropertyType& RefToConstProperty;

  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)
      : property_(property),
        matcher_(matcher),
        whose_property_("whose given property ") {}

  PropertyMatcher(const std::string& property_name, Property property,
                  const Matcher<RefToConstProperty>& matcher)
      : property_(property),
        matcher_(matcher),
        whose_property_("whose property `" + property_name + "` ") {}

  void DescribeTo(::std::ostream* os) const {
    *os << "is an object " << whose_property_;
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "is an object " << whose_property_;
    matcher_.DescribeNegationTo(os);
  }

  template <typename T>
  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
    return MatchAndExplainImpl(
        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
        value, listener);
  }

 private:
  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
                           const Class& obj,
                           MatchResultListener* listener) const {
    *listener << whose_property_ << "is ";
    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
    // which takes a non-const reference as argument.
    RefToConstProperty result = (obj.*property_)();
    return MatchPrintAndExplain(result, matcher_, listener);
  }

  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
                           MatchResultListener* listener) const {
    if (p == nullptr) return false;

    *listener << "which points to an object ";
    // Since *p has a property method, it must be a class/struct/union
    // type and thus cannot be a pointer.  Therefore we pass
    // false_type() as the first argument.
    return MatchAndExplainImpl(std::false_type(), *p, listener);
  }

  Property property_;
  const Matcher<RefToConstProperty> matcher_;

  // Contains either "whose given property " if the name of the property is
  // unknown or "whose property `name_of_property` " if the name is known.
  const std::string whose_property_;
};

// Type traits specifying various features of different functors for ResultOf.
// The default template specifies features for functor objects.
template <typename Functor>
struct CallableTraits {
  typedef Functor StorageType;

  static void CheckIsValid(Functor /* functor */) {}

  template <typename T>
  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
    return f(arg);
  }
};

// Specialization for function pointers.
template <typename ArgType, typename ResType>
struct CallableTraits<ResType(*)(ArgType)> {
  typedef ResType ResultType;
  typedef ResType(*StorageType)(ArgType);

  static void CheckIsValid(ResType(*f)(ArgType)) {
    GTEST_CHECK_(f != nullptr)
        << "NULL function pointer is passed into ResultOf().";
  }
  template <typename T>
  static ResType Invoke(ResType(*f)(ArgType), T arg) {
    return (*f)(arg);
  }
};

// Implements the ResultOf() matcher for matching a return value of a
// unary function of an object.
template <typename Callable, typename InnerMatcher>
class ResultOfMatcher {
 public:
  ResultOfMatcher(Callable callable, InnerMatcher matcher)
      : callable_(std::move(callable)), matcher_(std::move(matcher)) {
    CallableTraits<Callable>::CheckIsValid(callable_);
  }

  template <typename T>
  operator Matcher<T>() const {
    return Matcher<T>(new Impl<const T&>(callable_, matcher_));
  }

 private:
  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;

  template <typename T>
  class Impl : public MatcherInterface<T> {
    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
        std::declval<CallableStorageType>(), std::declval<T>()));

   public:
    template <typename M>
    Impl(const CallableStorageType& callable, const M& matcher)
        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "is mapped by the given callable to a value that ";
      matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "is mapped by the given callable to a value that ";
      matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
      *listener << "which is mapped by the given callable to ";
      // Cannot pass the return value directly to MatchPrintAndExplain, which
      // takes a non-const reference as argument.
      // Also, specifying template argument explicitly is needed because T could
      // be a non-const reference (e.g. Matcher<Uncopyable&>).
      ResultType result =
          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
      return MatchPrintAndExplain(result, matcher_, listener);
    }

   private:
    // Functors often define operator() as non-const method even though
    // they are actually stateless. But we need to use them even when
    // 'this' is a const pointer. It's the user's responsibility not to
    // use stateful callables with ResultOf(), which doesn't guarantee
    // how many times the callable will be invoked.
    mutable CallableStorageType callable_;
    const Matcher<ResultType> matcher_;
  };  // class Impl

  const CallableStorageType callable_;
  const InnerMatcher matcher_;
};

// Implements a matcher that checks the size of an STL-style container.
template <typename SizeMatcher>
class SizeIsMatcher {
 public:
  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
       : size_matcher_(size_matcher) {
  }

  template <typename Container>
  operator Matcher<Container>() const {
    return Matcher<Container>(new Impl<const Container&>(size_matcher_));
  }

  template <typename Container>
  class Impl : public MatcherInterface<Container> {
   public:
    using SizeType = decltype(std::declval<Container>().size());
    explicit Impl(const SizeMatcher& size_matcher)
        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "size ";
      size_matcher_.DescribeTo(os);
    }
    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "size ";
      size_matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(Container container,
                         MatchResultListener* listener) const override {
      SizeType size = container.size();
      StringMatchResultListener size_listener;
      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
      *listener
          << "whose size " << size << (result ? " matches" : " doesn't match");
      PrintIfNotEmpty(size_listener.str(), listener->stream());
      return result;
    }

   private:
    const Matcher<SizeType> size_matcher_;
  };

 private:
  const SizeMatcher size_matcher_;
};

// Implements a matcher that checks the begin()..end() distance of an STL-style
// container.
template <typename DistanceMatcher>
class BeginEndDistanceIsMatcher {
 public:
  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
      : distance_matcher_(distance_matcher) {}

  template <typename Container>
  operator Matcher<Container>() const {
    return Matcher<Container>(new Impl<const Container&>(distance_matcher_));
  }

  template <typename Container>
  class Impl : public MatcherInterface<Container> {
   public:
    typedef internal::StlContainerView<
        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
    typedef typename std::iterator_traits<
        typename ContainerView::type::const_iterator>::difference_type
        DistanceType;
    explicit Impl(const DistanceMatcher& distance_matcher)
        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "distance between begin() and end() ";
      distance_matcher_.DescribeTo(os);
    }
    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "distance between begin() and end() ";
      distance_matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(Container container,
                         MatchResultListener* listener) const override {
      using std::begin;
      using std::end;
      DistanceType distance = std::distance(begin(container), end(container));
      StringMatchResultListener distance_listener;
      const bool result =
          distance_matcher_.MatchAndExplain(distance, &distance_listener);
      *listener << "whose distance between begin() and end() " << distance
                << (result ? " matches" : " doesn't match");
      PrintIfNotEmpty(distance_listener.str(), listener->stream());
      return result;
    }

   private:
    const Matcher<DistanceType> distance_matcher_;
  };

 private:
  const DistanceMatcher distance_matcher_;
};

// Implements an equality matcher for any STL-style container whose elements
// support ==. This matcher is like Eq(), but its failure explanations provide
// more detailed information that is useful when the container is used as a set.
// The failure message reports elements that are in one of the operands but not
// the other. The failure messages do not report duplicate or out-of-order
// elements in the containers (which don't properly matter to sets, but can
// occur if the containers are vectors or lists, for example).
//
// Uses the container's const_iterator, value_type, operator ==,
// begin(), and end().
template <typename Container>
class ContainerEqMatcher {
 public:
  typedef internal::StlContainerView<Container> View;
  typedef typename View::type StlContainer;
  typedef typename View::const_reference StlContainerReference;

  static_assert(!std::is_const<Container>::value,
                "Container type must not be const");
  static_assert(!std::is_reference<Container>::value,
                "Container type must not be a reference");

  // We make a copy of expected in case the elements in it are modified
  // after this matcher is created.
  explicit ContainerEqMatcher(const Container& expected)
      : expected_(View::Copy(expected)) {}

  void DescribeTo(::std::ostream* os) const {
    *os << "equals ";
    UniversalPrint(expected_, os);
  }
  void DescribeNegationTo(::std::ostream* os) const {
    *os << "does not equal ";
    UniversalPrint(expected_, os);
  }

  template <typename LhsContainer>
  bool MatchAndExplain(const LhsContainer& lhs,
                       MatchResultListener* listener) const {
    typedef internal::StlContainerView<
        typename std::remove_const<LhsContainer>::type>
        LhsView;
    typedef typename LhsView::type LhsStlContainer;
    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
    if (lhs_stl_container == expected_)
      return true;

    ::std::ostream* const os = listener->stream();
    if (os != nullptr) {
      // Something is different. Check for extra values first.
      bool printed_header = false;
      for (typename LhsStlContainer::const_iterator it =
               lhs_stl_container.begin();
           it != lhs_stl_container.end(); ++it) {
        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
            expected_.end()) {
          if (printed_header) {
            *os << ", ";
          } else {
            *os << "which has these unexpected elements: ";
            printed_header = true;
          }
          UniversalPrint(*it, os);
        }
      }

      // Now check for missing values.
      bool printed_header2 = false;
      for (typename StlContainer::const_iterator it = expected_.begin();
           it != expected_.end(); ++it) {
        if (internal::ArrayAwareFind(
                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
            lhs_stl_container.end()) {
          if (printed_header2) {
            *os << ", ";
          } else {
            *os << (printed_header ? ",\nand" : "which")
                << " doesn't have these expected elements: ";
            printed_header2 = true;
          }
          UniversalPrint(*it, os);
        }
      }
    }

    return false;
  }

 private:
  const StlContainer expected_;
};

// A comparator functor that uses the < operator to compare two values.
struct LessComparator {
  template <typename T, typename U>
  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
};

// Implements WhenSortedBy(comparator, container_matcher).
template <typename Comparator, typename ContainerMatcher>
class WhenSortedByMatcher {
 public:
  WhenSortedByMatcher(const Comparator& comparator,
                      const ContainerMatcher& matcher)
      : comparator_(comparator), matcher_(matcher) {}

  template <typename LhsContainer>
  operator Matcher<LhsContainer>() const {
    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
  }

  template <typename LhsContainer>
  class Impl : public MatcherInterface<LhsContainer> {
   public:
    typedef internal::StlContainerView<
         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
    typedef typename LhsView::type LhsStlContainer;
    typedef typename LhsView::const_reference LhsStlContainerReference;
    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
    // so that we can match associative containers.
    typedef typename RemoveConstFromKey<
        typename LhsStlContainer::value_type>::type LhsValue;

    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
        : comparator_(comparator), matcher_(matcher) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "(when sorted) ";
      matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "(when sorted) ";
      matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(LhsContainer lhs,
                         MatchResultListener* listener) const override {
      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
                                               lhs_stl_container.end());
      ::std::sort(
           sorted_container.begin(), sorted_container.end(), comparator_);

      if (!listener->IsInterested()) {
        // If the listener is not interested, we do not need to
        // construct the inner explanation.
        return matcher_.Matches(sorted_container);
      }

      *listener << "which is ";
      UniversalPrint(sorted_container, listener->stream());
      *listener << " when sorted";

      StringMatchResultListener inner_listener;
      const bool match = matcher_.MatchAndExplain(sorted_container,
                                                  &inner_listener);
      PrintIfNotEmpty(inner_listener.str(), listener->stream());
      return match;
    }

   private:
    const Comparator comparator_;
    const Matcher<const ::std::vector<LhsValue>&> matcher_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
  };

 private:
  const Comparator comparator_;
  const ContainerMatcher matcher_;
};

// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
// must be able to be safely cast to Matcher<std::tuple<const T1&, const
// T2&> >, where T1 and T2 are the types of elements in the LHS
// container and the RHS container respectively.
template <typename TupleMatcher, typename RhsContainer>
class PointwiseMatcher {
  GTEST_COMPILE_ASSERT_(
      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
      use_UnorderedPointwise_with_hash_tables);

 public:
  typedef internal::StlContainerView<RhsContainer> RhsView;
  typedef typename RhsView::type RhsStlContainer;
  typedef typename RhsStlContainer::value_type RhsValue;

  static_assert(!std::is_const<RhsContainer>::value,
                "RhsContainer type must not be const");
  static_assert(!std::is_reference<RhsContainer>::value,
                "RhsContainer type must not be a reference");

  // Like ContainerEq, we make a copy of rhs in case the elements in
  // it are modified after this matcher is created.
  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}

  template <typename LhsContainer>
  operator Matcher<LhsContainer>() const {
    GTEST_COMPILE_ASSERT_(
        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
        use_UnorderedPointwise_with_hash_tables);

    return Matcher<LhsContainer>(
        new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
  }

  template <typename LhsContainer>
  class Impl : public MatcherInterface<LhsContainer> {
   public:
    typedef internal::StlContainerView<
         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
    typedef typename LhsView::type LhsStlContainer;
    typedef typename LhsView::const_reference LhsStlContainerReference;
    typedef typename LhsStlContainer::value_type LhsValue;
    // We pass the LHS value and the RHS value to the inner matcher by
    // reference, as they may be expensive to copy.  We must use tuple
    // instead of pair here, as a pair cannot hold references (C++ 98,
    // 20.2.2 [lib.pairs]).
    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;

    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
          rhs_(rhs) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "contains " << rhs_.size()
          << " values, where each value and its corresponding value in ";
      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
      *os << " ";
      mono_tuple_matcher_.DescribeTo(os);
    }
    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "doesn't contain exactly " << rhs_.size()
          << " values, or contains a value x at some index i"
          << " where x and the i-th value of ";
      UniversalPrint(rhs_, os);
      *os << " ";
      mono_tuple_matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(LhsContainer lhs,
                         MatchResultListener* listener) const override {
      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
      const size_t actual_size = lhs_stl_container.size();
      if (actual_size != rhs_.size()) {
        *listener << "which contains " << actual_size << " values";
        return false;
      }

      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
      typename RhsStlContainer::const_iterator right = rhs_.begin();
      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
        if (listener->IsInterested()) {
          StringMatchResultListener inner_listener;
          // Create InnerMatcherArg as a temporarily object to avoid it outlives
          // *left and *right. Dereference or the conversion to `const T&` may
          // return temp objects, e.g for vector<bool>.
          if (!mono_tuple_matcher_.MatchAndExplain(
                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
                                  ImplicitCast_<const RhsValue&>(*right)),
                  &inner_listener)) {
            *listener << "where the value pair (";
            UniversalPrint(*left, listener->stream());
            *listener << ", ";
            UniversalPrint(*right, listener->stream());
            *listener << ") at index #" << i << " don't match";
            PrintIfNotEmpty(inner_listener.str(), listener->stream());
            return false;
          }
        } else {
          if (!mono_tuple_matcher_.Matches(
                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
                                  ImplicitCast_<const RhsValue&>(*right))))
            return false;
        }
      }

      return true;
    }

   private:
    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
    const RhsStlContainer rhs_;
  };

 private:
  const TupleMatcher tuple_matcher_;
  const RhsStlContainer rhs_;
};

// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
template <typename Container>
class QuantifierMatcherImpl : public MatcherInterface<Container> {
 public:
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
  typedef StlContainerView<RawContainer> View;
  typedef typename View::type StlContainer;
  typedef typename View::const_reference StlContainerReference;
  typedef typename StlContainer::value_type Element;

  template <typename InnerMatcher>
  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
      : inner_matcher_(
           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}

  // Checks whether:
  // * All elements in the container match, if all_elements_should_match.
  // * Any element in the container matches, if !all_elements_should_match.
  bool MatchAndExplainImpl(bool all_elements_should_match,
                           Container container,
                           MatchResultListener* listener) const {
    StlContainerReference stl_container = View::ConstReference(container);
    size_t i = 0;
    for (typename StlContainer::const_iterator it = stl_container.begin();
         it != stl_container.end(); ++it, ++i) {
      StringMatchResultListener inner_listener;
      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);

      if (matches != all_elements_should_match) {
        *listener << "whose element #" << i
                  << (matches ? " matches" : " doesn't match");
        PrintIfNotEmpty(inner_listener.str(), listener->stream());
        return !all_elements_should_match;
      }
    }
    return all_elements_should_match;
  }

 protected:
  const Matcher<const Element&> inner_matcher_;
};

// Implements Contains(element_matcher) for the given argument type Container.
// Symmetric to EachMatcherImpl.
template <typename Container>
class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
 public:
  template <typename InnerMatcher>
  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
      : QuantifierMatcherImpl<Container>(inner_matcher) {}

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    *os << "contains at least one element that ";
    this->inner_matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "doesn't contain any element that ";
    this->inner_matcher_.DescribeTo(os);
  }

  bool MatchAndExplain(Container container,
                       MatchResultListener* listener) const override {
    return this->MatchAndExplainImpl(false, container, listener);
  }
};

// Implements Each(element_matcher) for the given argument type Container.
// Symmetric to ContainsMatcherImpl.
template <typename Container>
class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
 public:
  template <typename InnerMatcher>
  explicit EachMatcherImpl(InnerMatcher inner_matcher)
      : QuantifierMatcherImpl<Container>(inner_matcher) {}

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    *os << "only contains elements that ";
    this->inner_matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "contains some element that ";
    this->inner_matcher_.DescribeNegationTo(os);
  }

  bool MatchAndExplain(Container container,
                       MatchResultListener* listener) const override {
    return this->MatchAndExplainImpl(true, container, listener);
  }
};

// Implements polymorphic Contains(element_matcher).
template <typename M>
class ContainsMatcher {
 public:
  explicit ContainsMatcher(M m) : inner_matcher_(m) {}

  template <typename Container>
  operator Matcher<Container>() const {
    return Matcher<Container>(
        new ContainsMatcherImpl<const Container&>(inner_matcher_));
  }

 private:
  const M inner_matcher_;
};

// Implements polymorphic Each(element_matcher).
template <typename M>
class EachMatcher {
 public:
  explicit EachMatcher(M m) : inner_matcher_(m) {}

  template <typename Container>
  operator Matcher<Container>() const {
    return Matcher<Container>(
        new EachMatcherImpl<const Container&>(inner_matcher_));
  }

 private:
  const M inner_matcher_;
};

struct Rank1 {};
struct Rank0 : Rank1 {};

namespace pair_getters {
using std::get;
template <typename T>
auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT
  return get<0>(x);
}
template <typename T>
auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
  return x.first;
}

template <typename T>
auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
  return get<1>(x);
}
template <typename T>
auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
  return x.second;
}
}  // namespace pair_getters

// Implements Key(inner_matcher) for the given argument pair type.
// Key(inner_matcher) matches an std::pair whose 'first' field matches
// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
// std::map that contains at least one element whose key is >= 5.
template <typename PairType>
class KeyMatcherImpl : public MatcherInterface<PairType> {
 public:
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
  typedef typename RawPairType::first_type KeyType;

  template <typename InnerMatcher>
  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
      : inner_matcher_(
          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
  }

  // Returns true if and only if 'key_value.first' (the key) matches the inner
  // matcher.
  bool MatchAndExplain(PairType key_value,
                       MatchResultListener* listener) const override {
    StringMatchResultListener inner_listener;
    const bool match = inner_matcher_.MatchAndExplain(
        pair_getters::First(key_value, Rank0()), &inner_listener);
    const std::string explanation = inner_listener.str();
    if (explanation != "") {
      *listener << "whose first field is a value " << explanation;
    }
    return match;
  }

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    *os << "has a key that ";
    inner_matcher_.DescribeTo(os);
  }

  // Describes what the negation of this matcher does.
  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "doesn't have a key that ";
    inner_matcher_.DescribeTo(os);
  }

 private:
  const Matcher<const KeyType&> inner_matcher_;
};

// Implements polymorphic Key(matcher_for_key).
template <typename M>
class KeyMatcher {
 public:
  explicit KeyMatcher(M m) : matcher_for_key_(m) {}

  template <typename PairType>
  operator Matcher<PairType>() const {
    return Matcher<PairType>(
        new KeyMatcherImpl<const PairType&>(matcher_for_key_));
  }

 private:
  const M matcher_for_key_;
};

// Implements polymorphic Address(matcher_for_address).
template <typename InnerMatcher>
class AddressMatcher {
 public:
  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}

  template <typename Type>
  operator Matcher<Type>() const {  // NOLINT
    return Matcher<Type>(new Impl<const Type&>(matcher_));
  }

 private:
  // The monomorphic implementation that works for a particular object type.
  template <typename Type>
  class Impl : public MatcherInterface<Type> {
   public:
    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;
    explicit Impl(const InnerMatcher& matcher)
        : matcher_(MatcherCast<Address>(matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "has address that ";
      matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "does not have address that ";
      matcher_.DescribeTo(os);
    }

    bool MatchAndExplain(Type object,
                         MatchResultListener* listener) const override {
      *listener << "which has address ";
      Address address = std::addressof(object);
      return MatchPrintAndExplain(address, matcher_, listener);
    }

   private:
    const Matcher<Address> matcher_;
  };
  const InnerMatcher matcher_;
};

// Implements Pair(first_matcher, second_matcher) for the given argument pair
// type with its two matchers. See Pair() function below.
template <typename PairType>
class PairMatcherImpl : public MatcherInterface<PairType> {
 public:
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
  typedef typename RawPairType::first_type FirstType;
  typedef typename RawPairType::second_type SecondType;

  template <typename FirstMatcher, typename SecondMatcher>
  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
      : first_matcher_(
            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
        second_matcher_(
            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
  }

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    *os << "has a first field that ";
    first_matcher_.DescribeTo(os);
    *os << ", and has a second field that ";
    second_matcher_.DescribeTo(os);
  }

  // Describes what the negation of this matcher does.
  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "has a first field that ";
    first_matcher_.DescribeNegationTo(os);
    *os << ", or has a second field that ";
    second_matcher_.DescribeNegationTo(os);
  }

  // Returns true if and only if 'a_pair.first' matches first_matcher and
  // 'a_pair.second' matches second_matcher.
  bool MatchAndExplain(PairType a_pair,
                       MatchResultListener* listener) const override {
    if (!listener->IsInterested()) {
      // If the listener is not interested, we don't need to construct the
      // explanation.
      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
    }
    StringMatchResultListener first_inner_listener;
    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
                                        &first_inner_listener)) {
      *listener << "whose first field does not match";
      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
      return false;
    }
    StringMatchResultListener second_inner_listener;
    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
                                         &second_inner_listener)) {
      *listener << "whose second field does not match";
      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
      return false;
    }
    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
                   listener);
    return true;
  }

 private:
  void ExplainSuccess(const std::string& first_explanation,
                      const std::string& second_explanation,
                      MatchResultListener* listener) const {
    *listener << "whose both fields match";
    if (first_explanation != "") {
      *listener << ", where the first field is a value " << first_explanation;
    }
    if (second_explanation != "") {
      *listener << ", ";
      if (first_explanation != "") {
        *listener << "and ";
      } else {
        *listener << "where ";
      }
      *listener << "the second field is a value " << second_explanation;
    }
  }

  const Matcher<const FirstType&> first_matcher_;
  const Matcher<const SecondType&> second_matcher_;
};

// Implements polymorphic Pair(first_matcher, second_matcher).
template <typename FirstMatcher, typename SecondMatcher>
class PairMatcher {
 public:
  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}

  template <typename PairType>
  operator Matcher<PairType> () const {
    return Matcher<PairType>(
        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
  }

 private:
  const FirstMatcher first_matcher_;
  const SecondMatcher second_matcher_;
};

template <typename T, size_t... I>
auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
    -> decltype(std::tie(get<I>(t)...)) {
  static_assert(std::tuple_size<T>::value == sizeof...(I),
                "Number of arguments doesn't match the number of fields.");
  return std::tie(get<I>(t)...);
}

#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
  const auto& [a] = t;
  return std::tie(a);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
  const auto& [a, b] = t;
  return std::tie(a, b);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
  const auto& [a, b, c] = t;
  return std::tie(a, b, c);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
  const auto& [a, b, c, d] = t;
  return std::tie(a, b, c, d);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
  const auto& [a, b, c, d, e] = t;
  return std::tie(a, b, c, d, e);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
  const auto& [a, b, c, d, e, f] = t;
  return std::tie(a, b, c, d, e, f);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
  const auto& [a, b, c, d, e, f, g] = t;
  return std::tie(a, b, c, d, e, f, g);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
  const auto& [a, b, c, d, e, f, g, h] = t;
  return std::tie(a, b, c, d, e, f, g, h);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
  const auto& [a, b, c, d, e, f, g, h, i] = t;
  return std::tie(a, b, c, d, e, f, g, h, i);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
}
template <typename T>
auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
}
#endif  // defined(__cpp_structured_bindings)

template <size_t I, typename T>
auto UnpackStruct(const T& t)
    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
}

// Helper function to do comma folding in C++11.
// The array ensures left-to-right order of evaluation.
// Usage: VariadicExpand({expr...});
template <typename T, size_t N>
void VariadicExpand(const T (&)[N]) {}

template <typename Struct, typename StructSize>
class FieldsAreMatcherImpl;

template <typename Struct, size_t... I>
class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
    : public MatcherInterface<Struct> {
  using UnpackedType =
      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
  using MatchersType = std::tuple<
      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;

 public:
  template <typename Inner>
  explicit FieldsAreMatcherImpl(const Inner& matchers)
      : matchers_(testing::SafeMatcherCast<
                  const typename std::tuple_element<I, UnpackedType>::type&>(
            std::get<I>(matchers))...) {}

  void DescribeTo(::std::ostream* os) const override {
    const char* separator = "";
    VariadicExpand(
        {(*os << separator << "has field #" << I << " that ",
          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    const char* separator = "";
    VariadicExpand({(*os << separator << "has field #" << I << " that ",
                     std::get<I>(matchers_).DescribeNegationTo(os),
                     separator = ", or ")...});
  }

  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {
    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);
  }

 private:
  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {
    if (!listener->IsInterested()) {
      // If the listener is not interested, we don't need to construct the
      // explanation.
      bool good = true;
      VariadicExpand({good = good && std::get<I>(matchers_).Matches(
                                         std::get<I>(tuple))...});
      return good;
    }

    size_t failed_pos = ~size_t{};

    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));

    VariadicExpand(
        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
                                        std::get<I>(tuple), &inner_listener[I])
             ? failed_pos = I
             : 0 ...});
    if (failed_pos != ~size_t{}) {
      *listener << "whose field #" << failed_pos << " does not match";
      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());
      return false;
    }

    *listener << "whose all elements match";
    const char* separator = ", where";
    for (size_t index = 0; index < sizeof...(I); ++index) {
      const std::string str = inner_listener[index].str();
      if (!str.empty()) {
        *listener << separator << " field #" << index << " is a value " << str;
        separator = ", and";
      }
    }

    return true;
  }

  MatchersType matchers_;
};

template <typename... Inner>
class FieldsAreMatcher {
 public:
  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}

  template <typename Struct>
  operator Matcher<Struct>() const {  // NOLINT
    return Matcher<Struct>(
        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
            matchers_));
  }

 private:
  std::tuple<Inner...> matchers_;
};

// Implements ElementsAre() and ElementsAreArray().
template <typename Container>
class ElementsAreMatcherImpl : public MatcherInterface<Container> {
 public:
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
  typedef internal::StlContainerView<RawContainer> View;
  typedef typename View::type StlContainer;
  typedef typename View::const_reference StlContainerReference;
  typedef typename StlContainer::value_type Element;

  // Constructs the matcher from a sequence of element values or
  // element matchers.
  template <typename InputIter>
  ElementsAreMatcherImpl(InputIter first, InputIter last) {
    while (first != last) {
      matchers_.push_back(MatcherCast<const Element&>(*first++));
    }
  }

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    if (count() == 0) {
      *os << "is empty";
    } else if (count() == 1) {
      *os << "has 1 element that ";
      matchers_[0].DescribeTo(os);
    } else {
      *os << "has " << Elements(count()) << " where\n";
      for (size_t i = 0; i != count(); ++i) {
        *os << "element #" << i << " ";
        matchers_[i].DescribeTo(os);
        if (i + 1 < count()) {
          *os << ",\n";
        }
      }
    }
  }

  // Describes what the negation of this matcher does.
  void DescribeNegationTo(::std::ostream* os) const override {
    if (count() == 0) {
      *os << "isn't empty";
      return;
    }

    *os << "doesn't have " << Elements(count()) << ", or\n";
    for (size_t i = 0; i != count(); ++i) {
      *os << "element #" << i << " ";
      matchers_[i].DescribeNegationTo(os);
      if (i + 1 < count()) {
        *os << ", or\n";
      }
    }
  }

  bool MatchAndExplain(Container container,
                       MatchResultListener* listener) const override {
    // To work with stream-like "containers", we must only walk
    // through the elements in one pass.

    const bool listener_interested = listener->IsInterested();

    // explanations[i] is the explanation of the element at index i.
    ::std::vector<std::string> explanations(count());
    StlContainerReference stl_container = View::ConstReference(container);
    typename StlContainer::const_iterator it = stl_container.begin();
    size_t exam_pos = 0;
    bool mismatch_found = false;  // Have we found a mismatched element yet?

    // Go through the elements and matchers in pairs, until we reach
    // the end of either the elements or the matchers, or until we find a
    // mismatch.
    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
      bool match;  // Does the current element match the current matcher?
      if (listener_interested) {
        StringMatchResultListener s;
        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
        explanations[exam_pos] = s.str();
      } else {
        match = matchers_[exam_pos].Matches(*it);
      }

      if (!match) {
        mismatch_found = true;
        break;
      }
    }
    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.

    // Find how many elements the actual container has.  We avoid
    // calling size() s.t. this code works for stream-like "containers"
    // that don't define size().
    size_t actual_count = exam_pos;
    for (; it != stl_container.end(); ++it) {
      ++actual_count;
    }

    if (actual_count != count()) {
      // The element count doesn't match.  If the container is empty,
      // there's no need to explain anything as Google Mock already
      // prints the empty container.  Otherwise we just need to show
      // how many elements there actually are.
      if (listener_interested && (actual_count != 0)) {
        *listener << "which has " << Elements(actual_count);
      }
      return false;
    }

    if (mismatch_found) {
      // The element count matches, but the exam_pos-th element doesn't match.
      if (listener_interested) {
        *listener << "whose element #" << exam_pos << " doesn't match";
        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
      }
      return false;
    }

    // Every element matches its expectation.  We need to explain why
    // (the obvious ones can be skipped).
    if (listener_interested) {
      bool reason_printed = false;
      for (size_t i = 0; i != count(); ++i) {
        const std::string& s = explanations[i];
        if (!s.empty()) {
          if (reason_printed) {
            *listener << ",\nand ";
          }
          *listener << "whose element #" << i << " matches, " << s;
          reason_printed = true;
        }
      }
    }
    return true;
  }

 private:
  static Message Elements(size_t count) {
    return Message() << count << (count == 1 ? " element" : " elements");
  }

  size_t count() const { return matchers_.size(); }

  ::std::vector<Matcher<const Element&> > matchers_;
};

// Connectivity matrix of (elements X matchers), in element-major order.
// Initially, there are no edges.
// Use NextGraph() to iterate over all possible edge configurations.
// Use Randomize() to generate a random edge configuration.
class GTEST_API_ MatchMatrix {
 public:
  MatchMatrix(size_t num_elements, size_t num_matchers)
      : num_elements_(num_elements),
        num_matchers_(num_matchers),
        matched_(num_elements_* num_matchers_, 0) {
  }

  size_t LhsSize() const { return num_elements_; }
  size_t RhsSize() const { return num_matchers_; }
  bool HasEdge(size_t ilhs, size_t irhs) const {
    return matched_[SpaceIndex(ilhs, irhs)] == 1;
  }
  void SetEdge(size_t ilhs, size_t irhs, bool b) {
    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
  }

  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
  // adds 1 to that number; returns false if incrementing the graph left it
  // empty.
  bool NextGraph();

  void Randomize();

  std::string DebugString() const;

 private:
  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
    return ilhs * num_matchers_ + irhs;
  }

  size_t num_elements_;
  size_t num_matchers_;

  // Each element is a char interpreted as bool. They are stored as a
  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
  // a (ilhs, irhs) matrix coordinate into an offset.
  ::std::vector<char> matched_;
};

typedef ::std::pair<size_t, size_t> ElementMatcherPair;
typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;

// Returns a maximum bipartite matching for the specified graph 'g'.
// The matching is represented as a vector of {element, matcher} pairs.
GTEST_API_ ElementMatcherPairs
FindMaxBipartiteMatching(const MatchMatrix& g);

struct UnorderedMatcherRequire {
  enum Flags {
    Superset = 1 << 0,
    Subset = 1 << 1,
    ExactMatch = Superset | Subset,
  };
};

// Untyped base class for implementing UnorderedElementsAre.  By
// putting logic that's not specific to the element type here, we
// reduce binary bloat and increase compilation speed.
class GTEST_API_ UnorderedElementsAreMatcherImplBase {
 protected:
  explicit UnorderedElementsAreMatcherImplBase(
      UnorderedMatcherRequire::Flags matcher_flags)
      : match_flags_(matcher_flags) {}

  // A vector of matcher describers, one for each element matcher.
  // Does not own the describers (and thus can be used only when the
  // element matchers are alive).
  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;

  // Describes this UnorderedElementsAre matcher.
  void DescribeToImpl(::std::ostream* os) const;

  // Describes the negation of this UnorderedElementsAre matcher.
  void DescribeNegationToImpl(::std::ostream* os) const;

  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,
                         const MatchMatrix& matrix,
                         MatchResultListener* listener) const;

  bool FindPairing(const MatchMatrix& matrix,
                   MatchResultListener* listener) const;

  MatcherDescriberVec& matcher_describers() {
    return matcher_describers_;
  }

  static Message Elements(size_t n) {
    return Message() << n << " element" << (n == 1 ? "" : "s");
  }

  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }

 private:
  UnorderedMatcherRequire::Flags match_flags_;
  MatcherDescriberVec matcher_describers_;
};

// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and
// IsSupersetOf.
template <typename Container>
class UnorderedElementsAreMatcherImpl
    : public MatcherInterface<Container>,
      public UnorderedElementsAreMatcherImplBase {
 public:
  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
  typedef internal::StlContainerView<RawContainer> View;
  typedef typename View::type StlContainer;
  typedef typename View::const_reference StlContainerReference;
  typedef typename StlContainer::const_iterator StlContainerConstIterator;
  typedef typename StlContainer::value_type Element;

  template <typename InputIter>
  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
                                  InputIter first, InputIter last)
      : UnorderedElementsAreMatcherImplBase(matcher_flags) {
    for (; first != last; ++first) {
      matchers_.push_back(MatcherCast<const Element&>(*first));
    }
    for (const auto& m : matchers_) {
      matcher_describers().push_back(m.GetDescriber());
    }
  }

  // Describes what this matcher does.
  void DescribeTo(::std::ostream* os) const override {
    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
  }

  // Describes what the negation of this matcher does.
  void DescribeNegationTo(::std::ostream* os) const override {
    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
  }

  bool MatchAndExplain(Container container,
                       MatchResultListener* listener) const override {
    StlContainerReference stl_container = View::ConstReference(container);
    ::std::vector<std::string> element_printouts;
    MatchMatrix matrix =
        AnalyzeElements(stl_container.begin(), stl_container.end(),
                        &element_printouts, listener);

    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
      return true;
    }

    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      if (matrix.LhsSize() != matrix.RhsSize()) {
        // The element count doesn't match.  If the container is empty,
        // there's no need to explain anything as Google Mock already
        // prints the empty container. Otherwise we just need to show
        // how many elements there actually are.
        if (matrix.LhsSize() != 0 && listener->IsInterested()) {
          *listener << "which has " << Elements(matrix.LhsSize());
        }
        return false;
      }
    }

    return VerifyMatchMatrix(element_printouts, matrix, listener) &&
           FindPairing(matrix, listener);
  }

 private:
  template <typename ElementIter>
  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
                              ::std::vector<std::string>* element_printouts,
                              MatchResultListener* listener) const {
    element_printouts->clear();
    ::std::vector<char> did_match;
    size_t num_elements = 0;
    DummyMatchResultListener dummy;
    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
      if (listener->IsInterested()) {
        element_printouts->push_back(PrintToString(*elem_first));
      }
      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
        did_match.push_back(
            matchers_[irhs].MatchAndExplain(*elem_first, &dummy));
      }
    }

    MatchMatrix matrix(num_elements, matchers_.size());
    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
      }
    }
    return matrix;
  }

  ::std::vector<Matcher<const Element&> > matchers_;
};

// Functor for use in TransformTuple.
// Performs MatcherCast<Target> on an input argument of any type.
template <typename Target>
struct CastAndAppendTransform {
  template <typename Arg>
  Matcher<Target> operator()(const Arg& a) const {
    return MatcherCast<Target>(a);
  }
};

// Implements UnorderedElementsAre.
template <typename MatcherTuple>
class UnorderedElementsAreMatcher {
 public:
  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
      : matchers_(args) {}

  template <typename Container>
  operator Matcher<Container>() const {
    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
    typedef typename internal::StlContainerView<RawContainer>::type View;
    typedef typename View::value_type Element;
    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
    MatcherVec matchers;
    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
                         ::std::back_inserter(matchers));
    return Matcher<Container>(
        new UnorderedElementsAreMatcherImpl<const Container&>(
            UnorderedMatcherRequire::ExactMatch, matchers.begin(),
            matchers.end()));
  }

 private:
  const MatcherTuple matchers_;
};

// Implements ElementsAre.
template <typename MatcherTuple>
class ElementsAreMatcher {
 public:
  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}

  template <typename Container>
  operator Matcher<Container>() const {
    GTEST_COMPILE_ASSERT_(
        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
            ::std::tuple_size<MatcherTuple>::value < 2,
        use_UnorderedElementsAre_with_hash_tables);

    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
    typedef typename internal::StlContainerView<RawContainer>::type View;
    typedef typename View::value_type Element;
    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
    MatcherVec matchers;
    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
                         ::std::back_inserter(matchers));
    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
        matchers.begin(), matchers.end()));
  }

 private:
  const MatcherTuple matchers_;
};

// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().
template <typename T>
class UnorderedElementsAreArrayMatcher {
 public:
  template <typename Iter>
  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,
                                   Iter first, Iter last)
      : match_flags_(match_flags), matchers_(first, last) {}

  template <typename Container>
  operator Matcher<Container>() const {
    return Matcher<Container>(
        new UnorderedElementsAreMatcherImpl<const Container&>(
            match_flags_, matchers_.begin(), matchers_.end()));
  }

 private:
  UnorderedMatcherRequire::Flags match_flags_;
  ::std::vector<T> matchers_;
};

// Implements ElementsAreArray().
template <typename T>
class ElementsAreArrayMatcher {
 public:
  template <typename Iter>
  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}

  template <typename Container>
  operator Matcher<Container>() const {
    GTEST_COMPILE_ASSERT_(
        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
        use_UnorderedElementsAreArray_with_hash_tables);

    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
        matchers_.begin(), matchers_.end()));
  }

 private:
  const ::std::vector<T> matchers_;
};

// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
// second) is a polymorphic matcher that matches a value x if and only if
// tm matches tuple (x, second).  Useful for implementing
// UnorderedPointwise() in terms of UnorderedElementsAreArray().
//
// BoundSecondMatcher is copyable and assignable, as we need to put
// instances of this class in a vector when implementing
// UnorderedPointwise().
template <typename Tuple2Matcher, typename Second>
class BoundSecondMatcher {
 public:
  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
      : tuple2_matcher_(tm), second_value_(second) {}

  BoundSecondMatcher(const BoundSecondMatcher& other) = default;

  template <typename T>
  operator Matcher<T>() const {
    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
  }

  // We have to define this for UnorderedPointwise() to compile in
  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
  // which requires the elements to be assignable in C++98.  The
  // compiler cannot generate the operator= for us, as Tuple2Matcher
  // and Second may not be assignable.
  //
  // However, this should never be called, so the implementation just
  // need to assert.
  void operator=(const BoundSecondMatcher& /*rhs*/) {
    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
  }

 private:
  template <typename T>
  class Impl : public MatcherInterface<T> {
   public:
    typedef ::std::tuple<T, Second> ArgTuple;

    Impl(const Tuple2Matcher& tm, const Second& second)
        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
          second_value_(second) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "and ";
      UniversalPrint(second_value_, os);
      *os << " ";
      mono_tuple2_matcher_.DescribeTo(os);
    }

    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
                                                  listener);
    }

   private:
    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
    const Second second_value_;
  };

  const Tuple2Matcher tuple2_matcher_;
  const Second second_value_;
};

// Given a 2-tuple matcher tm and a value second,
// MatcherBindSecond(tm, second) returns a matcher that matches a
// value x if and only if tm matches tuple (x, second).  Useful for
// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().
template <typename Tuple2Matcher, typename Second>
BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
    const Tuple2Matcher& tm, const Second& second) {
  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
}

// Returns the description for a matcher defined using the MATCHER*()
// macro where the user-supplied description string is "", if
// 'negation' is false; otherwise returns the description of the
// negation of the matcher.  'param_values' contains a list of strings
// that are the print-out of the matcher's parameters.
GTEST_API_ std::string FormatMatcherDescription(bool negation,
                                                const char* matcher_name,
                                                const Strings& param_values);

// Implements a matcher that checks the value of a optional<> type variable.
template <typename ValueMatcher>
class OptionalMatcher {
 public:
  explicit OptionalMatcher(const ValueMatcher& value_matcher)
      : value_matcher_(value_matcher) {}

  template <typename Optional>
  operator Matcher<Optional>() const {
    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
  }

  template <typename Optional>
  class Impl : public MatcherInterface<Optional> {
   public:
    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;
    typedef typename OptionalView::value_type ValueType;
    explicit Impl(const ValueMatcher& value_matcher)
        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}

    void DescribeTo(::std::ostream* os) const override {
      *os << "value ";
      value_matcher_.DescribeTo(os);
    }

    void DescribeNegationTo(::std::ostream* os) const override {
      *os << "value ";
      value_matcher_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(Optional optional,
                         MatchResultListener* listener) const override {
      if (!optional) {
        *listener << "which is not engaged";
        return false;
      }
      const ValueType& value = *optional;
      StringMatchResultListener value_listener;
      const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
      *listener << "whose value " << PrintToString(value)
                << (match ? " matches" : " doesn't match");
      PrintIfNotEmpty(value_listener.str(), listener->stream());
      return match;
    }

   private:
    const Matcher<ValueType> value_matcher_;
  };

 private:
  const ValueMatcher value_matcher_;
};

namespace variant_matcher {
// Overloads to allow VariantMatcher to do proper ADL lookup.
template <typename T>
void holds_alternative() {}
template <typename T>
void get() {}

// Implements a matcher that checks the value of a variant<> type variable.
template <typename T>
class VariantMatcher {
 public:
  explicit VariantMatcher(::testing::Matcher<const T&> matcher)
      : matcher_(std::move(matcher)) {}

  template <typename Variant>
  bool MatchAndExplain(const Variant& value,
                       ::testing::MatchResultListener* listener) const {
    using std::get;
    if (!listener->IsInterested()) {
      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));
    }

    if (!holds_alternative<T>(value)) {
      *listener << "whose value is not of type '" << GetTypeName() << "'";
      return false;
    }

    const T& elem = get<T>(value);
    StringMatchResultListener elem_listener;
    const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
    *listener << "whose value " << PrintToString(elem)
              << (match ? " matches" : " doesn't match");
    PrintIfNotEmpty(elem_listener.str(), listener->stream());
    return match;
  }

  void DescribeTo(std::ostream* os) const {
    *os << "is a variant<> with value of type '" << GetTypeName()
        << "' and the value ";
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "is a variant<> with value of type other than '" << GetTypeName()
        << "' or the value ";
    matcher_.DescribeNegationTo(os);
  }

 private:
  static std::string GetTypeName() {
#if GTEST_HAS_RTTI
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
        return internal::GetTypeName<T>());
#endif
    return "the element type";
  }

  const ::testing::Matcher<const T&> matcher_;
};

}  // namespace variant_matcher

namespace any_cast_matcher {

// Overloads to allow AnyCastMatcher to do proper ADL lookup.
template <typename T>
void any_cast() {}

// Implements a matcher that any_casts the value.
template <typename T>
class AnyCastMatcher {
 public:
  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)
      : matcher_(matcher) {}

  template <typename AnyType>
  bool MatchAndExplain(const AnyType& value,
                       ::testing::MatchResultListener* listener) const {
    if (!listener->IsInterested()) {
      const T* ptr = any_cast<T>(&value);
      return ptr != nullptr && matcher_.Matches(*ptr);
    }

    const T* elem = any_cast<T>(&value);
    if (elem == nullptr) {
      *listener << "whose value is not of type '" << GetTypeName() << "'";
      return false;
    }

    StringMatchResultListener elem_listener;
    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
    *listener << "whose value " << PrintToString(*elem)
              << (match ? " matches" : " doesn't match");
    PrintIfNotEmpty(elem_listener.str(), listener->stream());
    return match;
  }

  void DescribeTo(std::ostream* os) const {
    *os << "is an 'any' type with value of type '" << GetTypeName()
        << "' and the value ";
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "is an 'any' type with value of type other than '" << GetTypeName()
        << "' or the value ";
    matcher_.DescribeNegationTo(os);
  }

 private:
  static std::string GetTypeName() {
#if GTEST_HAS_RTTI
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
        return internal::GetTypeName<T>());
#endif
    return "the element type";
  }

  const ::testing::Matcher<const T&> matcher_;
};

}  // namespace any_cast_matcher

// Implements the Args() matcher.
template <class ArgsTuple, size_t... k>
class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
 public:
  using RawArgsTuple = typename std::decay<ArgsTuple>::type;
  using SelectedArgs =
      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;

  template <typename InnerMatcher>
  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}

  bool MatchAndExplain(ArgsTuple args,
                       MatchResultListener* listener) const override {
    // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
    (void)args;
    const SelectedArgs& selected_args =
        std::forward_as_tuple(std::get<k>(args)...);
    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);

    PrintIndices(listener->stream());
    *listener << "are " << PrintToString(selected_args);

    StringMatchResultListener inner_listener;
    const bool match =
        inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
    PrintIfNotEmpty(inner_listener.str(), listener->stream());
    return match;
  }

  void DescribeTo(::std::ostream* os) const override {
    *os << "are a tuple ";
    PrintIndices(os);
    inner_matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "are a tuple ";
    PrintIndices(os);
    inner_matcher_.DescribeNegationTo(os);
  }

 private:
  // Prints the indices of the selected fields.
  static void PrintIndices(::std::ostream* os) {
    *os << "whose fields (";
    const char* sep = "";
    // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
    (void)sep;
    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
    (void)dummy;
    *os << ") ";
  }

  MonomorphicInnerMatcher inner_matcher_;
};

template <class InnerMatcher, size_t... k>
class ArgsMatcher {
 public:
  explicit ArgsMatcher(InnerMatcher inner_matcher)
      : inner_matcher_(std::move(inner_matcher)) {}

  template <typename ArgsTuple>
  operator Matcher<ArgsTuple>() const {  // NOLINT
    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));
  }

 private:
  InnerMatcher inner_matcher_;
};

}  // namespace internal

// ElementsAreArray(iterator_first, iterator_last)
// ElementsAreArray(pointer, count)
// ElementsAreArray(array)
// ElementsAreArray(container)
// ElementsAreArray({ e1, e2, ..., en })
//
// The ElementsAreArray() functions are like ElementsAre(...), except
// that they are given a homogeneous sequence rather than taking each
// element as a function argument. The sequence can be specified as an
// array, a pointer and count, a vector, an initializer list, or an
// STL iterator range. In each of these cases, the underlying sequence
// can be either a sequence of values or a sequence of matchers.
//
// All forms of ElementsAreArray() make a copy of the input matcher sequence.

template <typename Iter>
inline internal::ElementsAreArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
ElementsAreArray(Iter first, Iter last) {
  typedef typename ::std::iterator_traits<Iter>::value_type T;
  return internal::ElementsAreArrayMatcher<T>(first, last);
}

template <typename T>
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const T* pointer, size_t count) {
  return ElementsAreArray(pointer, pointer + count);
}

template <typename T, size_t N>
inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
    const T (&array)[N]) {
  return ElementsAreArray(array, N);
}

template <typename Container>
inline internal::ElementsAreArrayMatcher<typename Container::value_type>
ElementsAreArray(const Container& container) {
  return ElementsAreArray(container.begin(), container.end());
}

template <typename T>
inline internal::ElementsAreArrayMatcher<T>
ElementsAreArray(::std::initializer_list<T> xs) {
  return ElementsAreArray(xs.begin(), xs.end());
}

// UnorderedElementsAreArray(iterator_first, iterator_last)
// UnorderedElementsAreArray(pointer, count)
// UnorderedElementsAreArray(array)
// UnorderedElementsAreArray(container)
// UnorderedElementsAreArray({ e1, e2, ..., en })
//
// UnorderedElementsAreArray() verifies that a bijective mapping onto a
// collection of matchers exists.
//
// The matchers can be specified as an array, a pointer and count, a container,
// an initializer list, or an STL iterator range. In each of these cases, the
// underlying matchers can be either values or matchers.

template <typename Iter>
inline internal::UnorderedElementsAreArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
UnorderedElementsAreArray(Iter first, Iter last) {
  typedef typename ::std::iterator_traits<Iter>::value_type T;
  return internal::UnorderedElementsAreArrayMatcher<T>(
      internal::UnorderedMatcherRequire::ExactMatch, first, last);
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T>
UnorderedElementsAreArray(const T* pointer, size_t count) {
  return UnorderedElementsAreArray(pointer, pointer + count);
}

template <typename T, size_t N>
inline internal::UnorderedElementsAreArrayMatcher<T>
UnorderedElementsAreArray(const T (&array)[N]) {
  return UnorderedElementsAreArray(array, N);
}

template <typename Container>
inline internal::UnorderedElementsAreArrayMatcher<
    typename Container::value_type>
UnorderedElementsAreArray(const Container& container) {
  return UnorderedElementsAreArray(container.begin(), container.end());
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T>
UnorderedElementsAreArray(::std::initializer_list<T> xs) {
  return UnorderedElementsAreArray(xs.begin(), xs.end());
}

// _ is a matcher that matches anything of any type.
//
// This definition is fine as:
//
//   1. The C++ standard permits using the name _ in a namespace that
//      is not the global namespace or ::std.
//   2. The AnythingMatcher class has no data member or constructor,
//      so it's OK to create global variables of this type.
//   3. c-style has approved of using _ in this case.
const internal::AnythingMatcher _ = {};
// Creates a matcher that matches any value of the given type T.
template <typename T>
inline Matcher<T> A() {
  return _;
}

// Creates a matcher that matches any value of the given type T.
template <typename T>
inline Matcher<T> An() {
  return _;
}

template <typename T, typename M>
Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
    const M& value, std::false_type /* convertible_to_matcher */,
    std::false_type /* convertible_to_T */) {
  return Eq(value);
}

// Creates a polymorphic matcher that matches any NULL pointer.
inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
  return MakePolymorphicMatcher(internal::IsNullMatcher());
}

// Creates a polymorphic matcher that matches any non-NULL pointer.
// This is convenient as Not(NULL) doesn't compile (the compiler
// thinks that that expression is comparing a pointer with an integer).
inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
  return MakePolymorphicMatcher(internal::NotNullMatcher());
}

// Creates a polymorphic matcher that matches any argument that
// references variable x.
template <typename T>
inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
  return internal::RefMatcher<T&>(x);
}

// Creates a polymorphic matcher that matches any NaN floating point.
inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
  return MakePolymorphicMatcher(internal::IsNanMatcher());
}

// Creates a matcher that matches any double argument approximately
// equal to rhs, where two NANs are considered unequal.
inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
  return internal::FloatingEqMatcher<double>(rhs, false);
}

// Creates a matcher that matches any double argument approximately
// equal to rhs, including NaN values when rhs is NaN.
inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
  return internal::FloatingEqMatcher<double>(rhs, true);
}

// Creates a matcher that matches any double argument approximately equal to
// rhs, up to the specified max absolute error bound, where two NANs are
// considered unequal.  The max absolute error bound must be non-negative.
inline internal::FloatingEqMatcher<double> DoubleNear(
    double rhs, double max_abs_error) {
  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
}

// Creates a matcher that matches any double argument approximately equal to
// rhs, up to the specified max absolute error bound, including NaN values when
// rhs is NaN.  The max absolute error bound must be non-negative.
inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
    double rhs, double max_abs_error) {
  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
}

// Creates a matcher that matches any float argument approximately
// equal to rhs, where two NANs are considered unequal.
inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
  return internal::FloatingEqMatcher<float>(rhs, false);
}

// Creates a matcher that matches any float argument approximately
// equal to rhs, including NaN values when rhs is NaN.
inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
  return internal::FloatingEqMatcher<float>(rhs, true);
}

// Creates a matcher that matches any float argument approximately equal to
// rhs, up to the specified max absolute error bound, where two NANs are
// considered unequal.  The max absolute error bound must be non-negative.
inline internal::FloatingEqMatcher<float> FloatNear(
    float rhs, float max_abs_error) {
  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
}

// Creates a matcher that matches any float argument approximately equal to
// rhs, up to the specified max absolute error bound, including NaN values when
// rhs is NaN.  The max absolute error bound must be non-negative.
inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
    float rhs, float max_abs_error) {
  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
}

// Creates a matcher that matches a pointer (raw or smart) that points
// to a value that matches inner_matcher.
template <typename InnerMatcher>
inline internal::PointeeMatcher<InnerMatcher> Pointee(
    const InnerMatcher& inner_matcher) {
  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
}

#if GTEST_HAS_RTTI
// Creates a matcher that matches a pointer or reference that matches
// inner_matcher when dynamic_cast<To> is applied.
// The result of dynamic_cast<To> is forwarded to the inner matcher.
// If To is a pointer and the cast fails, the inner matcher will receive NULL.
// If To is a reference and the cast fails, this matcher returns false
// immediately.
template <typename To>
inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
  return MakePolymorphicMatcher(
      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
}
#endif  // GTEST_HAS_RTTI

// Creates a matcher that matches an object whose given field matches
// 'matcher'.  For example,
//   Field(&Foo::number, Ge(5))
// matches a Foo object x if and only if x.number >= 5.
template <typename Class, typename FieldType, typename FieldMatcher>
inline PolymorphicMatcher<
  internal::FieldMatcher<Class, FieldType> > Field(
    FieldType Class::*field, const FieldMatcher& matcher) {
  return MakePolymorphicMatcher(
      internal::FieldMatcher<Class, FieldType>(
          field, MatcherCast<const FieldType&>(matcher)));
  // The call to MatcherCast() is required for supporting inner
  // matchers of compatible types.  For example, it allows
  //   Field(&Foo::bar, m)
  // to compile where bar is an int32 and m is a matcher for int64.
}

// Same as Field() but also takes the name of the field to provide better error
// messages.
template <typename Class, typename FieldType, typename FieldMatcher>
inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
    const std::string& field_name, FieldType Class::*field,
    const FieldMatcher& matcher) {
  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
      field_name, field, MatcherCast<const FieldType&>(matcher)));
}

// Creates a matcher that matches an object whose given property
// matches 'matcher'.  For example,
//   Property(&Foo::str, StartsWith("hi"))
// matches a Foo object x if and only if x.str() starts with "hi".
template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher<
    Class, PropertyType, PropertyType (Class::*)() const> >
Property(PropertyType (Class::*property)() const,
         const PropertyMatcher& matcher) {
  return MakePolymorphicMatcher(
      internal::PropertyMatcher<Class, PropertyType,
                                PropertyType (Class::*)() const>(
          property, MatcherCast<const PropertyType&>(matcher)));
  // The call to MatcherCast() is required for supporting inner
  // matchers of compatible types.  For example, it allows
  //   Property(&Foo::bar, m)
  // to compile where bar() returns an int32 and m is a matcher for int64.
}

// Same as Property() above, but also takes the name of the property to provide
// better error messages.
template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher<
    Class, PropertyType, PropertyType (Class::*)() const> >
Property(const std::string& property_name,
         PropertyType (Class::*property)() const,
         const PropertyMatcher& matcher) {
  return MakePolymorphicMatcher(
      internal::PropertyMatcher<Class, PropertyType,
                                PropertyType (Class::*)() const>(
          property_name, property, MatcherCast<const PropertyType&>(matcher)));
}

// The same as above but for reference-qualified member functions.
template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher<
    Class, PropertyType, PropertyType (Class::*)() const &> >
Property(PropertyType (Class::*property)() const &,
         const PropertyMatcher& matcher) {
  return MakePolymorphicMatcher(
      internal::PropertyMatcher<Class, PropertyType,
                                PropertyType (Class::*)() const&>(
          property, MatcherCast<const PropertyType&>(matcher)));
}

// Three-argument form for reference-qualified member functions.
template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher<
    Class, PropertyType, PropertyType (Class::*)() const &> >
Property(const std::string& property_name,
         PropertyType (Class::*property)() const &,
         const PropertyMatcher& matcher) {
  return MakePolymorphicMatcher(
      internal::PropertyMatcher<Class, PropertyType,
                                PropertyType (Class::*)() const&>(
          property_name, property, MatcherCast<const PropertyType&>(matcher)));
}

// Creates a matcher that matches an object if and only if the result of
// applying a callable to x matches 'matcher'. For example,
//   ResultOf(f, StartsWith("hi"))
// matches a Foo object x if and only if f(x) starts with "hi".
// `callable` parameter can be a function, function pointer, or a functor. It is
// required to keep no state affecting the results of the calls on it and make
// no assumptions about how many calls will be made. Any state it keeps must be
// protected from the concurrent access.
template <typename Callable, typename InnerMatcher>
internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
    Callable callable, InnerMatcher matcher) {
  return internal::ResultOfMatcher<Callable, InnerMatcher>(
      std::move(callable), std::move(matcher));
}

// String matchers.

// Matches a string equal to str.
template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
    const internal::StringLike<T>& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
}

// Matches a string not equal to str.
template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
    const internal::StringLike<T>& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
}

// Matches a string equal to str, ignoring case.
template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
    const internal::StringLike<T>& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
}

// Matches a string not equal to str, ignoring case.
template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
    const internal::StringLike<T>& str) {
  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
      std::string(str), false, false));
}

// Creates a matcher that matches any string, std::string, or C string
// that contains the given substring.
template <typename T = std::string>
PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
    const internal::StringLike<T>& substring) {
  return MakePolymorphicMatcher(
      internal::HasSubstrMatcher<std::string>(std::string(substring)));
}

// Matches a string that starts with 'prefix' (case-sensitive).
template <typename T = std::string>
PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
    const internal::StringLike<T>& prefix) {
  return MakePolymorphicMatcher(
      internal::StartsWithMatcher<std::string>(std::string(prefix)));
}

// Matches a string that ends with 'suffix' (case-sensitive).
template <typename T = std::string>
PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
    const internal::StringLike<T>& suffix) {
  return MakePolymorphicMatcher(
      internal::EndsWithMatcher<std::string>(std::string(suffix)));
}

#if GTEST_HAS_STD_WSTRING
// Wide string matchers.

// Matches a string equal to str.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq(
    const std::wstring& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::wstring>(str, true, true));
}

// Matches a string not equal to str.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe(
    const std::wstring& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::wstring>(str, false, true));
}

// Matches a string equal to str, ignoring case.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
StrCaseEq(const std::wstring& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::wstring>(str, true, false));
}

// Matches a string not equal to str, ignoring case.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
StrCaseNe(const std::wstring& str) {
  return MakePolymorphicMatcher(
      internal::StrEqualityMatcher<std::wstring>(str, false, false));
}

// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
// that contains the given substring.
inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr(
    const std::wstring& substring) {
  return MakePolymorphicMatcher(
      internal::HasSubstrMatcher<std::wstring>(substring));
}

// Matches a string that starts with 'prefix' (case-sensitive).
inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
StartsWith(const std::wstring& prefix) {
  return MakePolymorphicMatcher(
      internal::StartsWithMatcher<std::wstring>(prefix));
}

// Matches a string that ends with 'suffix' (case-sensitive).
inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
    const std::wstring& suffix) {
  return MakePolymorphicMatcher(
      internal::EndsWithMatcher<std::wstring>(suffix));
}

#endif  // GTEST_HAS_STD_WSTRING

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field == the second field.
inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field >= the second field.
inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field > the second field.
inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field <= the second field.
inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field < the second field.
inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where the
// first field != the second field.
inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }

// Creates a polymorphic matcher that matches a 2-tuple where
// FloatEq(first field) matches the second field.
inline internal::FloatingEq2Matcher<float> FloatEq() {
  return internal::FloatingEq2Matcher<float>();
}

// Creates a polymorphic matcher that matches a 2-tuple where
// DoubleEq(first field) matches the second field.
inline internal::FloatingEq2Matcher<double> DoubleEq() {
  return internal::FloatingEq2Matcher<double>();
}

// Creates a polymorphic matcher that matches a 2-tuple where
// FloatEq(first field) matches the second field with NaN equality.
inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
  return internal::FloatingEq2Matcher<float>(true);
}

// Creates a polymorphic matcher that matches a 2-tuple where
// DoubleEq(first field) matches the second field with NaN equality.
inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
  return internal::FloatingEq2Matcher<double>(true);
}

// Creates a polymorphic matcher that matches a 2-tuple where
// FloatNear(first field, max_abs_error) matches the second field.
inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
  return internal::FloatingEq2Matcher<float>(max_abs_error);
}

// Creates a polymorphic matcher that matches a 2-tuple where
// DoubleNear(first field, max_abs_error) matches the second field.
inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {
  return internal::FloatingEq2Matcher<double>(max_abs_error);
}

// Creates a polymorphic matcher that matches a 2-tuple where
// FloatNear(first field, max_abs_error) matches the second field with NaN
// equality.
inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
    float max_abs_error) {
  return internal::FloatingEq2Matcher<float>(max_abs_error, true);
}

// Creates a polymorphic matcher that matches a 2-tuple where
// DoubleNear(first field, max_abs_error) matches the second field with NaN
// equality.
inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
    double max_abs_error) {
  return internal::FloatingEq2Matcher<double>(max_abs_error, true);
}

// Creates a matcher that matches any value of type T that m doesn't
// match.
template <typename InnerMatcher>
inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
  return internal::NotMatcher<InnerMatcher>(m);
}

// Returns a matcher that matches anything that satisfies the given
// predicate.  The predicate can be any unary function or functor
// whose return type can be implicitly converted to bool.
template <typename Predicate>
inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
Truly(Predicate pred) {
  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
}

// Returns a matcher that matches the container size. The container must
// support both size() and size_type which all STL-like containers provide.
// Note that the parameter 'size' can be a value of type size_type as well as
// matcher. For instance:
//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
template <typename SizeMatcher>
inline internal::SizeIsMatcher<SizeMatcher>
SizeIs(const SizeMatcher& size_matcher) {
  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
}

// Returns a matcher that matches the distance between the container's begin()
// iterator and its end() iterator, i.e. the size of the container. This matcher
// can be used instead of SizeIs with containers such as std::forward_list which
// do not implement size(). The container must provide const_iterator (with
// valid iterator_traits), begin() and end().
template <typename DistanceMatcher>
inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
}

// Returns a matcher that matches an equal container.
// This matcher behaves like Eq(), but in the event of mismatch lists the
// values that are included in one container but not the other. (Duplicate
// values and order differences are not explained.)
template <typename Container>
inline PolymorphicMatcher<internal::ContainerEqMatcher<
    typename std::remove_const<Container>::type>>
ContainerEq(const Container& rhs) {
  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
}

// Returns a matcher that matches a container that, when sorted using
// the given comparator, matches container_matcher.
template <typename Comparator, typename ContainerMatcher>
inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
WhenSortedBy(const Comparator& comparator,
             const ContainerMatcher& container_matcher) {
  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
      comparator, container_matcher);
}

// Returns a matcher that matches a container that, when sorted using
// the < operator, matches container_matcher.
template <typename ContainerMatcher>
inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
WhenSorted(const ContainerMatcher& container_matcher) {
  return
      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
          internal::LessComparator(), container_matcher);
}

// Matches an STL-style container or a native array that contains the
// same number of elements as in rhs, where its i-th element and rhs's
// i-th element (as a pair) satisfy the given pair matcher, for all i.
// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
// T1&, const T2&> >, where T1 and T2 are the types of elements in the
// LHS container and the RHS container respectively.
template <typename TupleMatcher, typename Container>
inline internal::PointwiseMatcher<TupleMatcher,
                                  typename std::remove_const<Container>::type>
Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,
                                                             rhs);
}


// Supports the Pointwise(m, {a, b, c}) syntax.
template <typename TupleMatcher, typename T>
inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
  return Pointwise(tuple_matcher, std::vector<T>(rhs));
}


// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
// container or a native array that contains the same number of
// elements as in rhs, where in some permutation of the container, its
// i-th element and rhs's i-th element (as a pair) satisfy the given
// pair matcher, for all i.  Tuple2Matcher must be able to be safely
// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
// the types of elements in the LHS container and the RHS container
// respectively.
//
// This is like Pointwise(pair_matcher, rhs), except that the element
// order doesn't matter.
template <typename Tuple2Matcher, typename RhsContainer>
inline internal::UnorderedElementsAreArrayMatcher<
    typename internal::BoundSecondMatcher<
        Tuple2Matcher,
        typename internal::StlContainerView<
            typename std::remove_const<RhsContainer>::type>::type::value_type>>
UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
                   const RhsContainer& rhs_container) {
  // RhsView allows the same code to handle RhsContainer being a
  // STL-style container and it being a native C-style array.
  typedef typename internal::StlContainerView<RhsContainer> RhsView;
  typedef typename RhsView::type RhsStlContainer;
  typedef typename RhsStlContainer::value_type Second;
  const RhsStlContainer& rhs_stl_container =
      RhsView::ConstReference(rhs_container);

  // Create a matcher for each element in rhs_container.
  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
       it != rhs_stl_container.end(); ++it) {
    matchers.push_back(
        internal::MatcherBindSecond(tuple2_matcher, *it));
  }

  // Delegate the work to UnorderedElementsAreArray().
  return UnorderedElementsAreArray(matchers);
}


// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
template <typename Tuple2Matcher, typename T>
inline internal::UnorderedElementsAreArrayMatcher<
    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
                   std::initializer_list<T> rhs) {
  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
}


// Matches an STL-style container or a native array that contains at
// least one element matching the given value or matcher.
//
// Examples:
//   ::std::set<int> page_ids;
//   page_ids.insert(3);
//   page_ids.insert(1);
//   EXPECT_THAT(page_ids, Contains(1));
//   EXPECT_THAT(page_ids, Contains(Gt(2)));
//   EXPECT_THAT(page_ids, Not(Contains(4)));
//
//   ::std::map<int, size_t> page_lengths;
//   page_lengths[1] = 100;
//   EXPECT_THAT(page_lengths,
//               Contains(::std::pair<const int, size_t>(1, 100)));
//
//   const char* user_ids[] = { "joe", "mike", "tom" };
//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
template <typename M>
inline internal::ContainsMatcher<M> Contains(M matcher) {
  return internal::ContainsMatcher<M>(matcher);
}

// IsSupersetOf(iterator_first, iterator_last)
// IsSupersetOf(pointer, count)
// IsSupersetOf(array)
// IsSupersetOf(container)
// IsSupersetOf({e1, e2, ..., en})
//
// IsSupersetOf() verifies that a surjective partial mapping onto a collection
// of matchers exists. In other words, a container matches
// IsSupersetOf({e1, ..., en}) if and only if there is a permutation
// {y1, ..., yn} of some of the container's elements where y1 matches e1,
// ..., and yn matches en. Obviously, the size of the container must be >= n
// in order to have a match. Examples:
//
// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and
//   1 matches Ne(0).
// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
//   both Eq(1) and Lt(2). The reason is that different matchers must be used
//   for elements in different slots of the container.
// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches
//   Eq(1) and (the second) 1 matches Lt(2).
// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)
//   Gt(1) and 3 matches (the second) Gt(1).
//
// The matchers can be specified as an array, a pointer and count, a container,
// an initializer list, or an STL iterator range. In each of these cases, the
// underlying matchers can be either values or matchers.

template <typename Iter>
inline internal::UnorderedElementsAreArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
IsSupersetOf(Iter first, Iter last) {
  typedef typename ::std::iterator_traits<Iter>::value_type T;
  return internal::UnorderedElementsAreArrayMatcher<T>(
      internal::UnorderedMatcherRequire::Superset, first, last);
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
    const T* pointer, size_t count) {
  return IsSupersetOf(pointer, pointer + count);
}

template <typename T, size_t N>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
    const T (&array)[N]) {
  return IsSupersetOf(array, N);
}

template <typename Container>
inline internal::UnorderedElementsAreArrayMatcher<
    typename Container::value_type>
IsSupersetOf(const Container& container) {
  return IsSupersetOf(container.begin(), container.end());
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
    ::std::initializer_list<T> xs) {
  return IsSupersetOf(xs.begin(), xs.end());
}

// IsSubsetOf(iterator_first, iterator_last)
// IsSubsetOf(pointer, count)
// IsSubsetOf(array)
// IsSubsetOf(container)
// IsSubsetOf({e1, e2, ..., en})
//
// IsSubsetOf() verifies that an injective mapping onto a collection of matchers
// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and
// only if there is a subset of matchers {m1, ..., mk} which would match the
// container using UnorderedElementsAre.  Obviously, the size of the container
// must be <= n in order to have a match. Examples:
//
// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).
// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1
//   matches Lt(0).
// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
//   match Gt(0). The reason is that different matchers must be used for
//   elements in different slots of the container.
//
// The matchers can be specified as an array, a pointer and count, a container,
// an initializer list, or an STL iterator range. In each of these cases, the
// underlying matchers can be either values or matchers.

template <typename Iter>
inline internal::UnorderedElementsAreArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
IsSubsetOf(Iter first, Iter last) {
  typedef typename ::std::iterator_traits<Iter>::value_type T;
  return internal::UnorderedElementsAreArrayMatcher<T>(
      internal::UnorderedMatcherRequire::Subset, first, last);
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
    const T* pointer, size_t count) {
  return IsSubsetOf(pointer, pointer + count);
}

template <typename T, size_t N>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
    const T (&array)[N]) {
  return IsSubsetOf(array, N);
}

template <typename Container>
inline internal::UnorderedElementsAreArrayMatcher<
    typename Container::value_type>
IsSubsetOf(const Container& container) {
  return IsSubsetOf(container.begin(), container.end());
}

template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
    ::std::initializer_list<T> xs) {
  return IsSubsetOf(xs.begin(), xs.end());
}

// Matches an STL-style container or a native array that contains only
// elements matching the given value or matcher.
//
// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
// the messages are different.
//
// Examples:
//   ::std::set<int> page_ids;
//   // Each(m) matches an empty container, regardless of what m is.
//   EXPECT_THAT(page_ids, Each(Eq(1)));
//   EXPECT_THAT(page_ids, Each(Eq(77)));
//
//   page_ids.insert(3);
//   EXPECT_THAT(page_ids, Each(Gt(0)));
//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
//   page_ids.insert(1);
//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
//
//   ::std::map<int, size_t> page_lengths;
//   page_lengths[1] = 100;
//   page_lengths[2] = 200;
//   page_lengths[3] = 300;
//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
//
//   const char* user_ids[] = { "joe", "mike", "tom" };
//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
template <typename M>
inline internal::EachMatcher<M> Each(M matcher) {
  return internal::EachMatcher<M>(matcher);
}

// Key(inner_matcher) matches an std::pair whose 'first' field matches
// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
// std::map that contains at least one element whose key is >= 5.
template <typename M>
inline internal::KeyMatcher<M> Key(M inner_matcher) {
  return internal::KeyMatcher<M>(inner_matcher);
}

// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
// matches first_matcher and whose 'second' field matches second_matcher.  For
// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
// to match a std::map<int, string> that contains exactly one element whose key
// is >= 5 and whose value equals "foo".
template <typename FirstMatcher, typename SecondMatcher>
inline internal::PairMatcher<FirstMatcher, SecondMatcher>
Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
      first_matcher, second_matcher);
}

namespace no_adl {
// FieldsAre(matchers...) matches piecewise the fields of compatible structs.
// These include those that support `get<I>(obj)`, and when structured bindings
// are enabled any class that supports them.
// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.
template <typename... M>
internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
    M&&... matchers) {
  return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
      std::forward<M>(matchers)...);
}

// Creates a matcher that matches a pointer (raw or smart) that matches
// inner_matcher.
template <typename InnerMatcher>
inline internal::PointerMatcher<InnerMatcher> Pointer(
    const InnerMatcher& inner_matcher) {
  return internal::PointerMatcher<InnerMatcher>(inner_matcher);
}

// Creates a matcher that matches an object that has an address that matches
// inner_matcher.
template <typename InnerMatcher>
inline internal::AddressMatcher<InnerMatcher> Address(
    const InnerMatcher& inner_matcher) {
  return internal::AddressMatcher<InnerMatcher>(inner_matcher);
}
}  // namespace no_adl

// Returns a predicate that is satisfied by anything that matches the
// given matcher.
template <typename M>
inline internal::MatcherAsPredicate<M> Matches(M matcher) {
  return internal::MatcherAsPredicate<M>(matcher);
}

// Returns true if and only if the value matches the matcher.
template <typename T, typename M>
inline bool Value(const T& value, M matcher) {
  return testing::Matches(matcher)(value);
}

// Matches the value against the given matcher and explains the match
// result to listener.
template <typename T, typename M>
inline bool ExplainMatchResult(
    M matcher, const T& value, MatchResultListener* listener) {
  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
}

// Returns a string representation of the given matcher.  Useful for description
// strings of matchers defined using MATCHER_P* macros that accept matchers as
// their arguments.  For example:
//
// MATCHER_P(XAndYThat, matcher,
//           "X that " + DescribeMatcher<int>(matcher, negation) +
//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
//   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
//          ExplainMatchResult(matcher, arg.y(), result_listener);
// }
template <typename T, typename M>
std::string DescribeMatcher(const M& matcher, bool negation = false) {
  ::std::stringstream ss;
  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);
  if (negation) {
    monomorphic_matcher.DescribeNegationTo(&ss);
  } else {
    monomorphic_matcher.DescribeTo(&ss);
  }
  return ss.str();
}

template <typename... Args>
internal::ElementsAreMatcher<
    std::tuple<typename std::decay<const Args&>::type...>>
ElementsAre(const Args&... matchers) {
  return internal::ElementsAreMatcher<
      std::tuple<typename std::decay<const Args&>::type...>>(
      std::make_tuple(matchers...));
}

template <typename... Args>
internal::UnorderedElementsAreMatcher<
    std::tuple<typename std::decay<const Args&>::type...>>
UnorderedElementsAre(const Args&... matchers) {
  return internal::UnorderedElementsAreMatcher<
      std::tuple<typename std::decay<const Args&>::type...>>(
      std::make_tuple(matchers...));
}

// Define variadic matcher versions.
template <typename... Args>
internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
    const Args&... matchers) {
  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(
      matchers...);
}

template <typename... Args>
internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(
    const Args&... matchers) {
  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(
      matchers...);
}

// AnyOfArray(array)
// AnyOfArray(pointer, count)
// AnyOfArray(container)
// AnyOfArray({ e1, e2, ..., en })
// AnyOfArray(iterator_first, iterator_last)
//
// AnyOfArray() verifies whether a given value matches any member of a
// collection of matchers.
//
// AllOfArray(array)
// AllOfArray(pointer, count)
// AllOfArray(container)
// AllOfArray({ e1, e2, ..., en })
// AllOfArray(iterator_first, iterator_last)
//
// AllOfArray() verifies whether a given value matches all members of a
// collection of matchers.
//
// The matchers can be specified as an array, a pointer and count, a container,
// an initializer list, or an STL iterator range. In each of these cases, the
// underlying matchers can be either values or matchers.

template <typename Iter>
inline internal::AnyOfArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
AnyOfArray(Iter first, Iter last) {
  return internal::AnyOfArrayMatcher<
      typename ::std::iterator_traits<Iter>::value_type>(first, last);
}

template <typename Iter>
inline internal::AllOfArrayMatcher<
    typename ::std::iterator_traits<Iter>::value_type>
AllOfArray(Iter first, Iter last) {
  return internal::AllOfArrayMatcher<
      typename ::std::iterator_traits<Iter>::value_type>(first, last);
}

template <typename T>
inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {
  return AnyOfArray(ptr, ptr + count);
}

template <typename T>
inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {
  return AllOfArray(ptr, ptr + count);
}

template <typename T, size_t N>
inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
  return AnyOfArray(array, N);
}

template <typename T, size_t N>
inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
  return AllOfArray(array, N);
}

template <typename Container>
inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(
    const Container& container) {
  return AnyOfArray(container.begin(), container.end());
}

template <typename Container>
inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(
    const Container& container) {
  return AllOfArray(container.begin(), container.end());
}

template <typename T>
inline internal::AnyOfArrayMatcher<T> AnyOfArray(
    ::std::initializer_list<T> xs) {
  return AnyOfArray(xs.begin(), xs.end());
}

template <typename T>
inline internal::AllOfArrayMatcher<T> AllOfArray(
    ::std::initializer_list<T> xs) {
  return AllOfArray(xs.begin(), xs.end());
}

// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
// fields of it matches a_matcher.  C++ doesn't support default
// arguments for function templates, so we have to overload it.
template <size_t... k, typename InnerMatcher>
internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
    InnerMatcher&& matcher) {
  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(
      std::forward<InnerMatcher>(matcher));
}

// AllArgs(m) is a synonym of m.  This is useful in
//
//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
//
// which is easier to read than
//
//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
template <typename InnerMatcher>
inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }

// Returns a matcher that matches the value of an optional<> type variable.
// The matcher implementation only uses '!arg' and requires that the optional<>
// type has a 'value_type' member type and that '*arg' is of type 'value_type'
// and is printable using 'PrintToString'. It is compatible with
// std::optional/std::experimental::optional.
// Note that to compare an optional type variable against nullopt you should
// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the
// optional value contains an optional itself.
template <typename ValueMatcher>
inline internal::OptionalMatcher<ValueMatcher> Optional(
    const ValueMatcher& value_matcher) {
  return internal::OptionalMatcher<ValueMatcher>(value_matcher);
}

// Returns a matcher that matches the value of a absl::any type variable.
template <typename T>
PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
    const Matcher<const T&>& matcher) {
  return MakePolymorphicMatcher(
      internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
}

// Returns a matcher that matches the value of a variant<> type variable.
// The matcher implementation uses ADL to find the holds_alternative and get
// functions.
// It is compatible with std::variant.
template <typename T>
PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith(
    const Matcher<const T&>& matcher) {
  return MakePolymorphicMatcher(
      internal::variant_matcher::VariantMatcher<T>(matcher));
}

#if GTEST_HAS_EXCEPTIONS

// Anything inside the `internal` namespace is internal to the implementation
// and must not be used in user code!
namespace internal {

class WithWhatMatcherImpl {
 public:
  WithWhatMatcherImpl(Matcher<std::string> matcher)
      : matcher_(std::move(matcher)) {}

  void DescribeTo(std::ostream* os) const {
    *os << "contains .what() that ";
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "contains .what() that does not ";
    matcher_.DescribeTo(os);
  }

  template <typename Err>
  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
    *listener << "which contains .what() that ";
    return matcher_.MatchAndExplain(err.what(), listener);
  }

 private:
  const Matcher<std::string> matcher_;
};

inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(
    Matcher<std::string> m) {
  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));
}

template <typename Err>
class ExceptionMatcherImpl {
  class NeverThrown {
   public:
    const char* what() const noexcept {
      return "this exception should never be thrown";
    }
  };

  // If the matchee raises an exception of a wrong type, we'd like to
  // catch it and print its message and type. To do that, we add an additional
  // catch clause:
  //
  //     try { ... }
  //     catch (const Err&) { /* an expected exception */ }
  //     catch (const std::exception&) { /* exception of a wrong type */ }
  //
  // However, if the `Err` itself is `std::exception`, we'd end up with two
  // identical `catch` clauses:
  //
  //     try { ... }
  //     catch (const std::exception&) { /* an expected exception */ }
  //     catch (const std::exception&) { /* exception of a wrong type */ }
  //
  // This can cause a warning or an error in some compilers. To resolve
  // the issue, we use a fake error type whenever `Err` is `std::exception`:
  //
  //     try { ... }
  //     catch (const std::exception&) { /* an expected exception */ }
  //     catch (const NeverThrown&) { /* exception of a wrong type */ }
  using DefaultExceptionType = typename std::conditional<
      std::is_same<typename std::remove_cv<
                       typename std::remove_reference<Err>::type>::type,
                   std::exception>::value,
      const NeverThrown&, const std::exception&>::type;

 public:
  ExceptionMatcherImpl(Matcher<const Err&> matcher)
      : matcher_(std::move(matcher)) {}

  void DescribeTo(std::ostream* os) const {
    *os << "throws an exception which is a " << GetTypeName<Err>();
    *os << " which ";
    matcher_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "throws an exception which is not a " << GetTypeName<Err>();
    *os << " which ";
    matcher_.DescribeNegationTo(os);
  }

  template <typename T>
  bool MatchAndExplain(T&& x, MatchResultListener* listener) const {
    try {
      (void)(std::forward<T>(x)());
    } catch (const Err& err) {
      *listener << "throws an exception which is a " << GetTypeName<Err>();
      *listener << " ";
      return matcher_.MatchAndExplain(err, listener);
    } catch (DefaultExceptionType err) {
#if GTEST_HAS_RTTI
      *listener << "throws an exception of type " << GetTypeName(typeid(err));
      *listener << " ";
#else
      *listener << "throws an std::exception-derived type ";
#endif
      *listener << "with description \"" << err.what() << "\"";
      return false;
    } catch (...) {
      *listener << "throws an exception of an unknown type";
      return false;
    }

    *listener << "does not throw any exception";
    return false;
  }

 private:
  const Matcher<const Err&> matcher_;
};

}  // namespace internal

// Throws()
// Throws(exceptionMatcher)
// ThrowsMessage(messageMatcher)
//
// This matcher accepts a callable and verifies that when invoked, it throws
// an exception with the given type and properties.
//
// Examples:
//
//   EXPECT_THAT(
//       []() { throw std::runtime_error("message"); },
//       Throws<std::runtime_error>());
//
//   EXPECT_THAT(
//       []() { throw std::runtime_error("message"); },
//       ThrowsMessage<std::runtime_error>(HasSubstr("message")));
//
//   EXPECT_THAT(
//       []() { throw std::runtime_error("message"); },
//       Throws<std::runtime_error>(
//           Property(&std::runtime_error::what, HasSubstr("message"))));

template <typename Err>
PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {
  return MakePolymorphicMatcher(
      internal::ExceptionMatcherImpl<Err>(A<const Err&>()));
}

template <typename Err, typename ExceptionMatcher>
PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(
    const ExceptionMatcher& exception_matcher) {
  // Using matcher cast allows users to pass a matcher of a more broad type.
  // For example user may want to pass Matcher<std::exception>
  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.
  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(
      SafeMatcherCast<const Err&>(exception_matcher)));
}

template <typename Err, typename MessageMatcher>
PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
    MessageMatcher&& message_matcher) {
  static_assert(std::is_base_of<std::exception, Err>::value,
                "expected an std::exception-derived type");
  return Throws<Err>(internal::WithWhat(
      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));
}

#endif  // GTEST_HAS_EXCEPTIONS

// These macros allow using matchers to check values in Google Test
// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
// succeed if and only if the value matches the matcher.  If the assertion
// fails, the value and the description of the matcher will be printed.
#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)

// MATCHER* macroses itself are listed below.
#define MATCHER(name, description)                                             \
  class name##Matcher                                                          \
      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
   public:                                                                     \
    template <typename arg_type>                                               \
    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
     public:                                                                   \
      gmock_Impl() {}                                                          \
      bool MatchAndExplain(                                                    \
          const arg_type& arg,                                                 \
          ::testing::MatchResultListener* result_listener) const override;     \
      void DescribeTo(::std::ostream* gmock_os) const override {               \
        *gmock_os << FormatDescription(false);                                 \
      }                                                                        \
      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
        *gmock_os << FormatDescription(true);                                  \
      }                                                                        \
                                                                               \
     private:                                                                  \
      ::std::string FormatDescription(bool negation) const {                   \
        ::std::string gmock_description = (description);                       \
        if (!gmock_description.empty()) {                                      \
          return gmock_description;                                            \
        }                                                                      \
        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
                                                             {});              \
      }                                                                        \
    };                                                                         \
  };                                                                           \
  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \
  template <typename arg_type>                                                 \
  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
      const arg_type& arg,                                                     \
      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
      const

#define MATCHER_P(name, p0, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0))
#define MATCHER_P2(name, p0, p1, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1))
#define MATCHER_P3(name, p0, p1, p2, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2))
#define MATCHER_P4(name, p0, p1, p2, p3, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3))
#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
                         (p0, p1, p2, p3, p4))
#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
                         (p0, p1, p2, p3, p4, p5))
#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
                         (p0, p1, p2, p3, p4, p5, p6))
#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
                         (p0, p1, p2, p3, p4, p5, p6, p7))
#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
                         (p0, p1, p2, p3, p4, p5, p6, p7, p8))
#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))

#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \
  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
  class full_name : public ::testing::internal::MatcherBaseImpl<               \
                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
   public:                                                                     \
    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \
    template <typename arg_type>                                               \
    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
     public:                                                                   \
      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \
          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \
      bool MatchAndExplain(                                                    \
          const arg_type& arg,                                                 \
          ::testing::MatchResultListener* result_listener) const override;     \
      void DescribeTo(::std::ostream* gmock_os) const override {               \
        *gmock_os << FormatDescription(false);                                 \
      }                                                                        \
      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
        *gmock_os << FormatDescription(true);                                  \
      }                                                                        \
      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \
                                                                               \
     private:                                                                  \
      ::std::string FormatDescription(bool negation) const {                   \
        ::std::string gmock_description = (description);                       \
        if (!gmock_description.empty()) {                                      \
          return gmock_description;                                            \
        }                                                                      \
        return ::testing::internal::FormatMatcherDescription(                  \
            negation, #name,                                                   \
            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
      }                                                                        \
    };                                                                         \
  };                                                                           \
  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \
      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \
    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \
        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \
  }                                                                            \
  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
  template <typename arg_type>                                                 \
  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \
      arg_type>::MatchAndExplain(const arg_type& arg,                          \
                                 ::testing::MatchResultListener*               \
                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \
      const

#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
  GMOCK_PP_TAIL(                                     \
      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))
#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \
  , typename arg##_type

#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))
#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \
  , arg##_type

#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \
  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \
      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))
#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \
  , arg##_type gmock_p##i

#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))
#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \
  , arg(::std::forward<arg##_type>(gmock_p##i))

#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)
#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \
  const arg##_type arg;

#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))
#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg

#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
  , gmock_p##i

// To prevent ADL on certain functions we put them on a separate namespace.
using namespace no_adl;  // NOLINT

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046

// Include any custom callback matchers added by the local installation.
// We must include this header at the end to make sure it can use the
// declarations from this file.
// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Injection point for custom user configurations. See README for details
//
// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_

#if GTEST_HAS_EXCEPTIONS
# include <stdexcept>  // NOLINT
#endif

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// An abstract handle of an expectation.
class Expectation;

// A set of expectation handles.
class ExpectationSet;

// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
// and MUST NOT BE USED IN USER CODE!!!
namespace internal {

// Implements a mock function.
template <typename F> class FunctionMocker;

// Base class for expectations.
class ExpectationBase;

// Implements an expectation.
template <typename F> class TypedExpectation;

// Helper class for testing the Expectation class template.
class ExpectationTester;

// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
template <typename MockClass>
class NiceMockImpl;
template <typename MockClass>
class StrictMockImpl;
template <typename MockClass>
class NaggyMockImpl;

// Protects the mock object registry (in class Mock), all function
// mockers, and all expectations.
//
// The reason we don't use more fine-grained protection is: when a
// mock function Foo() is called, it needs to consult its expectations
// to see which one should be picked.  If another thread is allowed to
// call a mock function (either Foo() or a different one) at the same
// time, it could affect the "retired" attributes of Foo()'s
// expectations when InSequence() is used, and thus affect which
// expectation gets picked.  Therefore, we sequence all mock function
// calls to ensure the integrity of the mock objects' states.
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);

// Untyped base class for ActionResultHolder<R>.
class UntypedActionResultHolderBase;

// Abstract base class of FunctionMocker.  This is the
// type-agnostic part of the function mocker interface.  Its pure
// virtual methods are implemented by FunctionMocker.
class GTEST_API_ UntypedFunctionMockerBase {
 public:
  UntypedFunctionMockerBase();
  virtual ~UntypedFunctionMockerBase();

  // Verifies that all expectations on this mock function have been
  // satisfied.  Reports one or more Google Test non-fatal failures
  // and returns false if not.
  bool VerifyAndClearExpectationsLocked()
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);

  // Clears the ON_CALL()s set on this mock function.
  virtual void ClearDefaultActionsLocked()
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;

  // In all of the following Untyped* functions, it's the caller's
  // responsibility to guarantee the correctness of the arguments'
  // types.

  // Performs the default action with the given arguments and returns
  // the action's result.  The call description string will be used in
  // the error message to describe the call in the case the default
  // action fails.
  // L = *
  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
      void* untyped_args, const std::string& call_description) const = 0;

  // Performs the given action with the given arguments and returns
  // the action's result.
  // L = *
  virtual UntypedActionResultHolderBase* UntypedPerformAction(
      const void* untyped_action, void* untyped_args) const = 0;

  // Writes a message that the call is uninteresting (i.e. neither
  // explicitly expected nor explicitly unexpected) to the given
  // ostream.
  virtual void UntypedDescribeUninterestingCall(
      const void* untyped_args,
      ::std::ostream* os) const
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;

  // Returns the expectation that matches the given function arguments
  // (or NULL is there's no match); when a match is found,
  // untyped_action is set to point to the action that should be
  // performed (or NULL if the action is "do default"), and
  // is_excessive is modified to indicate whether the call exceeds the
  // expected number.
  virtual const ExpectationBase* UntypedFindMatchingExpectation(
      const void* untyped_args,
      const void** untyped_action, bool* is_excessive,
      ::std::ostream* what, ::std::ostream* why)
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;

  // Prints the given function arguments to the ostream.
  virtual void UntypedPrintArgs(const void* untyped_args,
                                ::std::ostream* os) const = 0;

  // Sets the mock object this mock method belongs to, and registers
  // this information in the global mock registry.  Will be called
  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
  // method.
  void RegisterOwner(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);

  // Sets the mock object this mock method belongs to, and sets the
  // name of the mock function.  Will be called upon each invocation
  // of this mock function.
  void SetOwnerAndName(const void* mock_obj, const char* name)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);

  // Returns the mock object this mock method belongs to.  Must be
  // called after RegisterOwner() or SetOwnerAndName() has been
  // called.
  const void* MockObject() const
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);

  // Returns the name of this mock method.  Must be called after
  // SetOwnerAndName() has been called.
  const char* Name() const
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);

  // Returns the result of invoking this mock function with the given
  // arguments.  This function can be safely called from multiple
  // threads concurrently.  The caller is responsible for deleting the
  // result.
  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);

 protected:
  typedef std::vector<const void*> UntypedOnCallSpecs;

  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;

  // Returns an Expectation object that references and co-owns exp,
  // which must be an expectation on this mock function.
  Expectation GetHandleOf(ExpectationBase* exp);

  // Address of the mock object this mock method belongs to.  Only
  // valid after this mock method has been called or
  // ON_CALL/EXPECT_CALL has been invoked on it.
  const void* mock_obj_;  // Protected by g_gmock_mutex.

  // Name of the function being mocked.  Only valid after this mock
  // method has been called.
  const char* name_;  // Protected by g_gmock_mutex.

  // All default action specs for this function mocker.
  UntypedOnCallSpecs untyped_on_call_specs_;

  // All expectations for this function mocker.
  //
  // It's undefined behavior to interleave expectations (EXPECT_CALLs
  // or ON_CALLs) and mock function calls.  Also, the order of
  // expectations is important.  Therefore it's a logic race condition
  // to read/write untyped_expectations_ concurrently.  In order for
  // tools like tsan to catch concurrent read/write accesses to
  // untyped_expectations, we deliberately leave accesses to it
  // unprotected.
  UntypedExpectations untyped_expectations_;
};  // class UntypedFunctionMockerBase

// Untyped base class for OnCallSpec<F>.
class UntypedOnCallSpecBase {
 public:
  // The arguments are the location of the ON_CALL() statement.
  UntypedOnCallSpecBase(const char* a_file, int a_line)
      : file_(a_file), line_(a_line), last_clause_(kNone) {}

  // Where in the source file was the default action spec defined?
  const char* file() const { return file_; }
  int line() const { return line_; }

 protected:
  // Gives each clause in the ON_CALL() statement a name.
  enum Clause {
    // Do not change the order of the enum members!  The run-time
    // syntax checking relies on it.
    kNone,
    kWith,
    kWillByDefault
  };

  // Asserts that the ON_CALL() statement has a certain property.
  void AssertSpecProperty(bool property,
                          const std::string& failure_message) const {
    Assert(property, file_, line_, failure_message);
  }

  // Expects that the ON_CALL() statement has a certain property.
  void ExpectSpecProperty(bool property,
                          const std::string& failure_message) const {
    Expect(property, file_, line_, failure_message);
  }

  const char* file_;
  int line_;

  // The last clause in the ON_CALL() statement as seen so far.
  // Initially kNone and changes as the statement is parsed.
  Clause last_clause_;
};  // class UntypedOnCallSpecBase

// This template class implements an ON_CALL spec.
template <typename F>
class OnCallSpec : public UntypedOnCallSpecBase {
 public:
  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;

  // Constructs an OnCallSpec object from the information inside
  // the parenthesis of an ON_CALL() statement.
  OnCallSpec(const char* a_file, int a_line,
             const ArgumentMatcherTuple& matchers)
      : UntypedOnCallSpecBase(a_file, a_line),
        matchers_(matchers),
        // By default, extra_matcher_ should match anything.  However,
        // we cannot initialize it with _ as that causes ambiguity between
        // Matcher's copy and move constructor for some argument types.
        extra_matcher_(A<const ArgumentTuple&>()) {}

  // Implements the .With() clause.
  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
    // Makes sure this is called at most once.
    ExpectSpecProperty(last_clause_ < kWith,
                       ".With() cannot appear "
                       "more than once in an ON_CALL().");
    last_clause_ = kWith;

    extra_matcher_ = m;
    return *this;
  }

  // Implements the .WillByDefault() clause.
  OnCallSpec& WillByDefault(const Action<F>& action) {
    ExpectSpecProperty(last_clause_ < kWillByDefault,
                       ".WillByDefault() must appear "
                       "exactly once in an ON_CALL().");
    last_clause_ = kWillByDefault;

    ExpectSpecProperty(!action.IsDoDefault(),
                       "DoDefault() cannot be used in ON_CALL().");
    action_ = action;
    return *this;
  }

  // Returns true if and only if the given arguments match the matchers.
  bool Matches(const ArgumentTuple& args) const {
    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
  }

  // Returns the action specified by the user.
  const Action<F>& GetAction() const {
    AssertSpecProperty(last_clause_ == kWillByDefault,
                       ".WillByDefault() must appear exactly "
                       "once in an ON_CALL().");
    return action_;
  }

 private:
  // The information in statement
  //
  //   ON_CALL(mock_object, Method(matchers))
  //       .With(multi-argument-matcher)
  //       .WillByDefault(action);
  //
  // is recorded in the data members like this:
  //
  //   source file that contains the statement => file_
  //   line number of the statement            => line_
  //   matchers                                => matchers_
  //   multi-argument-matcher                  => extra_matcher_
  //   action                                  => action_
  ArgumentMatcherTuple matchers_;
  Matcher<const ArgumentTuple&> extra_matcher_;
  Action<F> action_;
};  // class OnCallSpec

// Possible reactions on uninteresting calls.
enum CallReaction {
  kAllow,
  kWarn,
  kFail,
};

}  // namespace internal

// Utilities for manipulating mock objects.
class GTEST_API_ Mock {
 public:
  // The following public methods can be called concurrently.

  // Tells Google Mock to ignore mock_obj when checking for leaked
  // mock objects.
  static void AllowLeak(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Verifies and clears all expectations on the given mock object.
  // If the expectations aren't satisfied, generates one or more
  // Google Test non-fatal failures and returns false.
  static bool VerifyAndClearExpectations(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Verifies all expectations on the given mock object and clears its
  // default actions and expectations.  Returns true if and only if the
  // verification was successful.
  static bool VerifyAndClear(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Returns whether the mock was created as a naggy mock (default)
  static bool IsNaggy(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
  // Returns whether the mock was created as a nice mock
  static bool IsNice(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
  // Returns whether the mock was created as a strict mock
  static bool IsStrict(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

 private:
  friend class internal::UntypedFunctionMockerBase;

  // Needed for a function mocker to register itself (so that we know
  // how to clear a mock object).
  template <typename F>
  friend class internal::FunctionMocker;

  template <typename MockClass>
  friend class internal::NiceMockImpl;
  template <typename MockClass>
  friend class internal::NaggyMockImpl;
  template <typename MockClass>
  friend class internal::StrictMockImpl;

  // Tells Google Mock to allow uninteresting calls on the given mock
  // object.
  static void AllowUninterestingCalls(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Tells Google Mock to warn the user about uninteresting calls on
  // the given mock object.
  static void WarnUninterestingCalls(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Tells Google Mock to fail uninteresting calls on the given mock
  // object.
  static void FailUninterestingCalls(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Tells Google Mock the given mock object is being destroyed and
  // its entry in the call-reaction table should be removed.
  static void UnregisterCallReaction(const void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Returns the reaction Google Mock will have on uninteresting calls
  // made on the given mock object.
  static internal::CallReaction GetReactionOnUninterestingCalls(
      const void* mock_obj)
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Verifies that all expectations on the given mock object have been
  // satisfied.  Reports one or more Google Test non-fatal failures
  // and returns false if not.
  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);

  // Clears all ON_CALL()s set on the given mock object.
  static void ClearDefaultActionsLocked(void* mock_obj)
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);

  // Registers a mock object and a mock method it owns.
  static void Register(
      const void* mock_obj,
      internal::UntypedFunctionMockerBase* mocker)
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Tells Google Mock where in the source code mock_obj is used in an
  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
  // information helps the user identify which object it is.
  static void RegisterUseByOnCallOrExpectCall(
      const void* mock_obj, const char* file, int line)
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

  // Unregisters a mock method; removes the owning mock object from
  // the registry when the last mock method associated with it has
  // been unregistered.  This is called only in the destructor of
  // FunctionMocker.
  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
};  // class Mock

// An abstract handle of an expectation.  Useful in the .After()
// clause of EXPECT_CALL() for setting the (partial) order of
// expectations.  The syntax:
//
//   Expectation e1 = EXPECT_CALL(...)...;
//   EXPECT_CALL(...).After(e1)...;
//
// sets two expectations where the latter can only be matched after
// the former has been satisfied.
//
// Notes:
//   - This class is copyable and has value semantics.
//   - Constness is shallow: a const Expectation object itself cannot
//     be modified, but the mutable methods of the ExpectationBase
//     object it references can be called via expectation_base().

class GTEST_API_ Expectation {
 public:
  // Constructs a null object that doesn't reference any expectation.
  Expectation();
  Expectation(Expectation&&) = default;
  Expectation(const Expectation&) = default;
  Expectation& operator=(Expectation&&) = default;
  Expectation& operator=(const Expectation&) = default;
  ~Expectation();

  // This single-argument ctor must not be explicit, in order to support the
  //   Expectation e = EXPECT_CALL(...);
  // syntax.
  //
  // A TypedExpectation object stores its pre-requisites as
  // Expectation objects, and needs to call the non-const Retire()
  // method on the ExpectationBase objects they reference.  Therefore
  // Expectation must receive a *non-const* reference to the
  // ExpectationBase object.
  Expectation(internal::ExpectationBase& exp);  // NOLINT

  // The compiler-generated copy ctor and operator= work exactly as
  // intended, so we don't need to define our own.

  // Returns true if and only if rhs references the same expectation as this
  // object does.
  bool operator==(const Expectation& rhs) const {
    return expectation_base_ == rhs.expectation_base_;
  }

  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }

 private:
  friend class ExpectationSet;
  friend class Sequence;
  friend class ::testing::internal::ExpectationBase;
  friend class ::testing::internal::UntypedFunctionMockerBase;

  template <typename F>
  friend class ::testing::internal::FunctionMocker;

  template <typename F>
  friend class ::testing::internal::TypedExpectation;

  // This comparator is needed for putting Expectation objects into a set.
  class Less {
   public:
    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
    }
  };

  typedef ::std::set<Expectation, Less> Set;

  Expectation(
      const std::shared_ptr<internal::ExpectationBase>& expectation_base);

  // Returns the expectation this object references.
  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
    return expectation_base_;
  }

  // A shared_ptr that co-owns the expectation this handle references.
  std::shared_ptr<internal::ExpectationBase> expectation_base_;
};

// A set of expectation handles.  Useful in the .After() clause of
// EXPECT_CALL() for setting the (partial) order of expectations.  The
// syntax:
//
//   ExpectationSet es;
//   es += EXPECT_CALL(...)...;
//   es += EXPECT_CALL(...)...;
//   EXPECT_CALL(...).After(es)...;
//
// sets three expectations where the last one can only be matched
// after the first two have both been satisfied.
//
// This class is copyable and has value semantics.
class ExpectationSet {
 public:
  // A bidirectional iterator that can read a const element in the set.
  typedef Expectation::Set::const_iterator const_iterator;

  // An object stored in the set.  This is an alias of Expectation.
  typedef Expectation::Set::value_type value_type;

  // Constructs an empty set.
  ExpectationSet() {}

  // This single-argument ctor must not be explicit, in order to support the
  //   ExpectationSet es = EXPECT_CALL(...);
  // syntax.
  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
    *this += Expectation(exp);
  }

  // This single-argument ctor implements implicit conversion from
  // Expectation and thus must not be explicit.  This allows either an
  // Expectation or an ExpectationSet to be used in .After().
  ExpectationSet(const Expectation& e) {  // NOLINT
    *this += e;
  }

  // The compiler-generator ctor and operator= works exactly as
  // intended, so we don't need to define our own.

  // Returns true if and only if rhs contains the same set of Expectation
  // objects as this does.
  bool operator==(const ExpectationSet& rhs) const {
    return expectations_ == rhs.expectations_;
  }

  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }

  // Implements the syntax
  //   expectation_set += EXPECT_CALL(...);
  ExpectationSet& operator+=(const Expectation& e) {
    expectations_.insert(e);
    return *this;
  }

  int size() const { return static_cast<int>(expectations_.size()); }

  const_iterator begin() const { return expectations_.begin(); }
  const_iterator end() const { return expectations_.end(); }

 private:
  Expectation::Set expectations_;
};


// Sequence objects are used by a user to specify the relative order
// in which the expectations should match.  They are copyable (we rely
// on the compiler-defined copy constructor and assignment operator).
class GTEST_API_ Sequence {
 public:
  // Constructs an empty sequence.
  Sequence() : last_expectation_(new Expectation) {}

  // Adds an expectation to this sequence.  The caller must ensure
  // that no other thread is accessing this Sequence object.
  void AddExpectation(const Expectation& expectation) const;

 private:
  // The last expectation in this sequence.
  std::shared_ptr<Expectation> last_expectation_;
};  // class Sequence

// An object of this type causes all EXPECT_CALL() statements
// encountered in its scope to be put in an anonymous sequence.  The
// work is done in the constructor and destructor.  You should only
// create an InSequence object on the stack.
//
// The sole purpose for this class is to support easy definition of
// sequential expectations, e.g.
//
//   {
//     InSequence dummy;  // The name of the object doesn't matter.
//
//     // The following expectations must match in the order they appear.
//     EXPECT_CALL(a, Bar())...;
//     EXPECT_CALL(a, Baz())...;
//     ...
//     EXPECT_CALL(b, Xyz())...;
//   }
//
// You can create InSequence objects in multiple threads, as long as
// they are used to affect different mock objects.  The idea is that
// each thread can create and set up its own mocks as if it's the only
// thread.  However, for clarity of your tests we recommend you to set
// up mocks in the main thread unless you have a good reason not to do
// so.
class GTEST_API_ InSequence {
 public:
  InSequence();
  ~InSequence();
 private:
  bool sequence_created_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
} GTEST_ATTRIBUTE_UNUSED_;

namespace internal {

// Points to the implicit sequence introduced by a living InSequence
// object (if any) in the current thread or NULL.
GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;

// Base class for implementing expectations.
//
// There are two reasons for having a type-agnostic base class for
// Expectation:
//
//   1. We need to store collections of expectations of different
//   types (e.g. all pre-requisites of a particular expectation, all
//   expectations in a sequence).  Therefore these expectation objects
//   must share a common base class.
//
//   2. We can avoid binary code bloat by moving methods not depending
//   on the template argument of Expectation to the base class.
//
// This class is internal and mustn't be used by user code directly.
class GTEST_API_ ExpectationBase {
 public:
  // source_text is the EXPECT_CALL(...) source that created this Expectation.
  ExpectationBase(const char* file, int line, const std::string& source_text);

  virtual ~ExpectationBase();

  // Where in the source file was the expectation spec defined?
  const char* file() const { return file_; }
  int line() const { return line_; }
  const char* source_text() const { return source_text_.c_str(); }
  // Returns the cardinality specified in the expectation spec.
  const Cardinality& cardinality() const { return cardinality_; }

  // Describes the source file location of this expectation.
  void DescribeLocationTo(::std::ostream* os) const {
    *os << FormatFileLocation(file(), line()) << " ";
  }

  // Describes how many times a function call matching this
  // expectation has occurred.
  void DescribeCallCountTo(::std::ostream* os) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);

  // If this mock method has an extra matcher (i.e. .With(matcher)),
  // describes it to the ostream.
  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;

 protected:
  friend class ::testing::Expectation;
  friend class UntypedFunctionMockerBase;

  enum Clause {
    // Don't change the order of the enum members!
    kNone,
    kWith,
    kTimes,
    kInSequence,
    kAfter,
    kWillOnce,
    kWillRepeatedly,
    kRetiresOnSaturation
  };

  typedef std::vector<const void*> UntypedActions;

  // Returns an Expectation object that references and co-owns this
  // expectation.
  virtual Expectation GetHandle() = 0;

  // Asserts that the EXPECT_CALL() statement has the given property.
  void AssertSpecProperty(bool property,
                          const std::string& failure_message) const {
    Assert(property, file_, line_, failure_message);
  }

  // Expects that the EXPECT_CALL() statement has the given property.
  void ExpectSpecProperty(bool property,
                          const std::string& failure_message) const {
    Expect(property, file_, line_, failure_message);
  }

  // Explicitly specifies the cardinality of this expectation.  Used
  // by the subclasses to implement the .Times() clause.
  void SpecifyCardinality(const Cardinality& cardinality);

  // Returns true if and only if the user specified the cardinality
  // explicitly using a .Times().
  bool cardinality_specified() const { return cardinality_specified_; }

  // Sets the cardinality of this expectation spec.
  void set_cardinality(const Cardinality& a_cardinality) {
    cardinality_ = a_cardinality;
  }

  // The following group of methods should only be called after the
  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
  // the current thread.

  // Retires all pre-requisites of this expectation.
  void RetireAllPreRequisites()
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);

  // Returns true if and only if this expectation is retired.
  bool is_retired() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return retired_;
  }

  // Retires this expectation.
  void Retire()
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    retired_ = true;
  }

  // Returns true if and only if this expectation is satisfied.
  bool IsSatisfied() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return cardinality().IsSatisfiedByCallCount(call_count_);
  }

  // Returns true if and only if this expectation is saturated.
  bool IsSaturated() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return cardinality().IsSaturatedByCallCount(call_count_);
  }

  // Returns true if and only if this expectation is over-saturated.
  bool IsOverSaturated() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return cardinality().IsOverSaturatedByCallCount(call_count_);
  }

  // Returns true if and only if all pre-requisites of this expectation are
  // satisfied.
  bool AllPrerequisitesAreSatisfied() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);

  // Adds unsatisfied pre-requisites of this expectation to 'result'.
  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);

  // Returns the number this expectation has been invoked.
  int call_count() const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return call_count_;
  }

  // Increments the number this expectation has been invoked.
  void IncrementCallCount()
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    call_count_++;
  }

  // Checks the action count (i.e. the number of WillOnce() and
  // WillRepeatedly() clauses) against the cardinality if this hasn't
  // been done before.  Prints a warning if there are too many or too
  // few actions.
  void CheckActionCountIfNotDone() const
      GTEST_LOCK_EXCLUDED_(mutex_);

  friend class ::testing::Sequence;
  friend class ::testing::internal::ExpectationTester;

  template <typename Function>
  friend class TypedExpectation;

  // Implements the .Times() clause.
  void UntypedTimes(const Cardinality& a_cardinality);

  // This group of fields are part of the spec and won't change after
  // an EXPECT_CALL() statement finishes.
  const char* file_;          // The file that contains the expectation.
  int line_;                  // The line number of the expectation.
  const std::string source_text_;  // The EXPECT_CALL(...) source text.
  // True if and only if the cardinality is specified explicitly.
  bool cardinality_specified_;
  Cardinality cardinality_;            // The cardinality of the expectation.
  // The immediate pre-requisites (i.e. expectations that must be
  // satisfied before this expectation can be matched) of this
  // expectation.  We use std::shared_ptr in the set because we want an
  // Expectation object to be co-owned by its FunctionMocker and its
  // successors.  This allows multiple mock objects to be deleted at
  // different times.
  ExpectationSet immediate_prerequisites_;

  // This group of fields are the current state of the expectation,
  // and can change as the mock function is called.
  int call_count_;  // How many times this expectation has been invoked.
  bool retired_;    // True if and only if this expectation has retired.
  UntypedActions untyped_actions_;
  bool extra_matcher_specified_;
  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
  bool retires_on_saturation_;
  Clause last_clause_;
  mutable bool action_count_checked_;  // Under mutex_.
  mutable Mutex mutex_;  // Protects action_count_checked_.
};  // class ExpectationBase

// Impements an expectation for the given function type.
template <typename F>
class TypedExpectation : public ExpectationBase {
 public:
  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
  typedef typename Function<F>::Result Result;

  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
                   const std::string& a_source_text,
                   const ArgumentMatcherTuple& m)
      : ExpectationBase(a_file, a_line, a_source_text),
        owner_(owner),
        matchers_(m),
        // By default, extra_matcher_ should match anything.  However,
        // we cannot initialize it with _ as that causes ambiguity between
        // Matcher's copy and move constructor for some argument types.
        extra_matcher_(A<const ArgumentTuple&>()),
        repeated_action_(DoDefault()) {}

  ~TypedExpectation() override {
    // Check the validity of the action count if it hasn't been done
    // yet (for example, if the expectation was never used).
    CheckActionCountIfNotDone();
    for (UntypedActions::const_iterator it = untyped_actions_.begin();
         it != untyped_actions_.end(); ++it) {
      delete static_cast<const Action<F>*>(*it);
    }
  }

  // Implements the .With() clause.
  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
    if (last_clause_ == kWith) {
      ExpectSpecProperty(false,
                         ".With() cannot appear "
                         "more than once in an EXPECT_CALL().");
    } else {
      ExpectSpecProperty(last_clause_ < kWith,
                         ".With() must be the first "
                         "clause in an EXPECT_CALL().");
    }
    last_clause_ = kWith;

    extra_matcher_ = m;
    extra_matcher_specified_ = true;
    return *this;
  }

  // Implements the .Times() clause.
  TypedExpectation& Times(const Cardinality& a_cardinality) {
    ExpectationBase::UntypedTimes(a_cardinality);
    return *this;
  }

  // Implements the .Times() clause.
  TypedExpectation& Times(int n) {
    return Times(Exactly(n));
  }

  // Implements the .InSequence() clause.
  TypedExpectation& InSequence(const Sequence& s) {
    ExpectSpecProperty(last_clause_ <= kInSequence,
                       ".InSequence() cannot appear after .After(),"
                       " .WillOnce(), .WillRepeatedly(), or "
                       ".RetiresOnSaturation().");
    last_clause_ = kInSequence;

    s.AddExpectation(GetHandle());
    return *this;
  }
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
    return InSequence(s1).InSequence(s2);
  }
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
                               const Sequence& s3) {
    return InSequence(s1, s2).InSequence(s3);
  }
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
                               const Sequence& s3, const Sequence& s4) {
    return InSequence(s1, s2, s3).InSequence(s4);
  }
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
                               const Sequence& s3, const Sequence& s4,
                               const Sequence& s5) {
    return InSequence(s1, s2, s3, s4).InSequence(s5);
  }

  // Implements that .After() clause.
  TypedExpectation& After(const ExpectationSet& s) {
    ExpectSpecProperty(last_clause_ <= kAfter,
                       ".After() cannot appear after .WillOnce(),"
                       " .WillRepeatedly(), or "
                       ".RetiresOnSaturation().");
    last_clause_ = kAfter;

    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
      immediate_prerequisites_ += *it;
    }
    return *this;
  }
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
    return After(s1).After(s2);
  }
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
                          const ExpectationSet& s3) {
    return After(s1, s2).After(s3);
  }
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
                          const ExpectationSet& s3, const ExpectationSet& s4) {
    return After(s1, s2, s3).After(s4);
  }
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
                          const ExpectationSet& s3, const ExpectationSet& s4,
                          const ExpectationSet& s5) {
    return After(s1, s2, s3, s4).After(s5);
  }

  // Implements the .WillOnce() clause.
  TypedExpectation& WillOnce(const Action<F>& action) {
    ExpectSpecProperty(last_clause_ <= kWillOnce,
                       ".WillOnce() cannot appear after "
                       ".WillRepeatedly() or .RetiresOnSaturation().");
    last_clause_ = kWillOnce;

    untyped_actions_.push_back(new Action<F>(action));
    if (!cardinality_specified()) {
      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
    }
    return *this;
  }

  // Implements the .WillRepeatedly() clause.
  TypedExpectation& WillRepeatedly(const Action<F>& action) {
    if (last_clause_ == kWillRepeatedly) {
      ExpectSpecProperty(false,
                         ".WillRepeatedly() cannot appear "
                         "more than once in an EXPECT_CALL().");
    } else {
      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
                         ".WillRepeatedly() cannot appear "
                         "after .RetiresOnSaturation().");
    }
    last_clause_ = kWillRepeatedly;
    repeated_action_specified_ = true;

    repeated_action_ = action;
    if (!cardinality_specified()) {
      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
    }

    // Now that no more action clauses can be specified, we check
    // whether their count makes sense.
    CheckActionCountIfNotDone();
    return *this;
  }

  // Implements the .RetiresOnSaturation() clause.
  TypedExpectation& RetiresOnSaturation() {
    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
                       ".RetiresOnSaturation() cannot appear "
                       "more than once.");
    last_clause_ = kRetiresOnSaturation;
    retires_on_saturation_ = true;

    // Now that no more action clauses can be specified, we check
    // whether their count makes sense.
    CheckActionCountIfNotDone();
    return *this;
  }

  // Returns the matchers for the arguments as specified inside the
  // EXPECT_CALL() macro.
  const ArgumentMatcherTuple& matchers() const {
    return matchers_;
  }

  // Returns the matcher specified by the .With() clause.
  const Matcher<const ArgumentTuple&>& extra_matcher() const {
    return extra_matcher_;
  }

  // Returns the action specified by the .WillRepeatedly() clause.
  const Action<F>& repeated_action() const { return repeated_action_; }

  // If this mock method has an extra matcher (i.e. .With(matcher)),
  // describes it to the ostream.
  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
    if (extra_matcher_specified_) {
      *os << "    Expected args: ";
      extra_matcher_.DescribeTo(os);
      *os << "\n";
    }
  }

 private:
  template <typename Function>
  friend class FunctionMocker;

  // Returns an Expectation object that references and co-owns this
  // expectation.
  Expectation GetHandle() override { return owner_->GetHandleOf(this); }

  // The following methods will be called only after the EXPECT_CALL()
  // statement finishes and when the current thread holds
  // g_gmock_mutex.

  // Returns true if and only if this expectation matches the given arguments.
  bool Matches(const ArgumentTuple& args) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
  }

  // Returns true if and only if this expectation should handle the given
  // arguments.
  bool ShouldHandleArguments(const ArgumentTuple& args) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();

    // In case the action count wasn't checked when the expectation
    // was defined (e.g. if this expectation has no WillRepeatedly()
    // or RetiresOnSaturation() clause), we check it when the
    // expectation is used for the first time.
    CheckActionCountIfNotDone();
    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
  }

  // Describes the result of matching the arguments against this
  // expectation to the given ostream.
  void ExplainMatchResultTo(
      const ArgumentTuple& args,
      ::std::ostream* os) const
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();

    if (is_retired()) {
      *os << "         Expected: the expectation is active\n"
          << "           Actual: it is retired\n";
    } else if (!Matches(args)) {
      if (!TupleMatches(matchers_, args)) {
        ExplainMatchFailureTupleTo(matchers_, args, os);
      }
      StringMatchResultListener listener;
      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
        *os << "    Expected args: ";
        extra_matcher_.DescribeTo(os);
        *os << "\n           Actual: don't match";

        internal::PrintIfNotEmpty(listener.str(), os);
        *os << "\n";
      }
    } else if (!AllPrerequisitesAreSatisfied()) {
      *os << "         Expected: all pre-requisites are satisfied\n"
          << "           Actual: the following immediate pre-requisites "
          << "are not satisfied:\n";
      ExpectationSet unsatisfied_prereqs;
      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
      int i = 0;
      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
           it != unsatisfied_prereqs.end(); ++it) {
        it->expectation_base()->DescribeLocationTo(os);
        *os << "pre-requisite #" << i++ << "\n";
      }
      *os << "                   (end of pre-requisites)\n";
    } else {
      // This line is here just for completeness' sake.  It will never
      // be executed as currently the ExplainMatchResultTo() function
      // is called only when the mock function call does NOT match the
      // expectation.
      *os << "The call matches the expectation.\n";
    }
  }

  // Returns the action that should be taken for the current invocation.
  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
                                    const ArgumentTuple& args) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    const int count = call_count();
    Assert(count >= 1, __FILE__, __LINE__,
           "call_count() is <= 0 when GetCurrentAction() is "
           "called - this should never happen.");

    const int action_count = static_cast<int>(untyped_actions_.size());
    if (action_count > 0 && !repeated_action_specified_ &&
        count > action_count) {
      // If there is at least one WillOnce() and no WillRepeatedly(),
      // we warn the user when the WillOnce() clauses ran out.
      ::std::stringstream ss;
      DescribeLocationTo(&ss);
      ss << "Actions ran out in " << source_text() << "...\n"
         << "Called " << count << " times, but only "
         << action_count << " WillOnce()"
         << (action_count == 1 ? " is" : "s are") << " specified - ";
      mocker->DescribeDefaultActionTo(args, &ss);
      Log(kWarning, ss.str(), 1);
    }

    return count <= action_count
               ? *static_cast<const Action<F>*>(
                     untyped_actions_[static_cast<size_t>(count - 1)])
               : repeated_action();
  }

  // Given the arguments of a mock function call, if the call will
  // over-saturate this expectation, returns the default action;
  // otherwise, returns the next action in this expectation.  Also
  // describes *what* happened to 'what', and explains *why* Google
  // Mock does it to 'why'.  This method is not const as it calls
  // IncrementCallCount().  A return value of NULL means the default
  // action.
  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
                                         const ArgumentTuple& args,
                                         ::std::ostream* what,
                                         ::std::ostream* why)
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    if (IsSaturated()) {
      // We have an excessive call.
      IncrementCallCount();
      *what << "Mock function called more times than expected - ";
      mocker->DescribeDefaultActionTo(args, what);
      DescribeCallCountTo(why);

      return nullptr;
    }

    IncrementCallCount();
    RetireAllPreRequisites();

    if (retires_on_saturation_ && IsSaturated()) {
      Retire();
    }

    // Must be done after IncrementCount()!
    *what << "Mock function call matches " << source_text() <<"...\n";
    return &(GetCurrentAction(mocker, args));
  }

  // All the fields below won't change once the EXPECT_CALL()
  // statement finishes.
  FunctionMocker<F>* const owner_;
  ArgumentMatcherTuple matchers_;
  Matcher<const ArgumentTuple&> extra_matcher_;
  Action<F> repeated_action_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
};  // class TypedExpectation

// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
// specifying the default behavior of, or expectation on, a mock
// function.

// Note: class MockSpec really belongs to the ::testing namespace.
// However if we define it in ::testing, MSVC will complain when
// classes in ::testing::internal declare it as a friend class
// template.  To workaround this compiler bug, we define MockSpec in
// ::testing::internal and import it into ::testing.

// Logs a message including file and line number information.
GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
                                const char* file, int line,
                                const std::string& message);

template <typename F>
class MockSpec {
 public:
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  typedef typename internal::Function<F>::ArgumentMatcherTuple
      ArgumentMatcherTuple;

  // Constructs a MockSpec object, given the function mocker object
  // that the spec is associated with.
  MockSpec(internal::FunctionMocker<F>* function_mocker,
           const ArgumentMatcherTuple& matchers)
      : function_mocker_(function_mocker), matchers_(matchers) {}

  // Adds a new default action spec to the function mocker and returns
  // the newly created spec.
  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
      const char* file, int line, const char* obj, const char* call) {
    LogWithLocation(internal::kInfo, file, line,
                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
  }

  // Adds a new expectation spec to the function mocker and returns
  // the newly created spec.
  internal::TypedExpectation<F>& InternalExpectedAt(
      const char* file, int line, const char* obj, const char* call) {
    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
                                  call + ")");
    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
    return function_mocker_->AddNewExpectation(
        file, line, source_text, matchers_);
  }

  // This operator overload is used to swallow the superfluous parameter list
  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
  // explanation.
  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
    return *this;
  }

 private:
  template <typename Function>
  friend class internal::FunctionMocker;

  // The function mocker that owns this spec.
  internal::FunctionMocker<F>* const function_mocker_;
  // The argument matchers specified in the spec.
  ArgumentMatcherTuple matchers_;
};  // class MockSpec

// Wrapper type for generically holding an ordinary value or lvalue reference.
// If T is not a reference type, it must be copyable or movable.
// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
// T is a move-only value type (which means that it will always be copyable
// if the current platform does not support move semantics).
//
// The primary template defines handling for values, but function header
// comments describe the contract for the whole template (including
// specializations).
template <typename T>
class ReferenceOrValueWrapper {
 public:
  // Constructs a wrapper from the given value/reference.
  explicit ReferenceOrValueWrapper(T value)
      : value_(std::move(value)) {
  }

  // Unwraps and returns the underlying value/reference, exactly as
  // originally passed. The behavior of calling this more than once on
  // the same object is unspecified.
  T Unwrap() { return std::move(value_); }

  // Provides nondestructive access to the underlying value/reference.
  // Always returns a const reference (more precisely,
  // const std::add_lvalue_reference<T>::type). The behavior of calling this
  // after calling Unwrap on the same object is unspecified.
  const T& Peek() const {
    return value_;
  }

 private:
  T value_;
};

// Specialization for lvalue reference types. See primary template
// for documentation.
template <typename T>
class ReferenceOrValueWrapper<T&> {
 public:
  // Workaround for debatable pass-by-reference lint warning (c-library-team
  // policy precludes NOLINT in this context)
  typedef T& reference;
  explicit ReferenceOrValueWrapper(reference ref)
      : value_ptr_(&ref) {}
  T& Unwrap() { return *value_ptr_; }
  const T& Peek() const { return *value_ptr_; }

 private:
  T* value_ptr_;
};

// C++ treats the void type specially.  For example, you cannot define
// a void-typed variable or pass a void value to a function.
// ActionResultHolder<T> holds a value of type T, where T must be a
// copyable type or void (T doesn't need to be default-constructable).
// It hides the syntactic difference between void and other types, and
// is used to unify the code for invoking both void-returning and
// non-void-returning mock functions.

// Untyped base class for ActionResultHolder<T>.
class UntypedActionResultHolderBase {
 public:
  virtual ~UntypedActionResultHolderBase() {}

  // Prints the held value as an action's result to os.
  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
};

// This generic definition is used when T is not void.
template <typename T>
class ActionResultHolder : public UntypedActionResultHolderBase {
 public:
  // Returns the held value. Must not be called more than once.
  T Unwrap() {
    return result_.Unwrap();
  }

  // Prints the held value as an action's result to os.
  void PrintAsActionResult(::std::ostream* os) const override {
    *os << "\n          Returns: ";
    // T may be a reference type, so we don't use UniversalPrint().
    UniversalPrinter<T>::Print(result_.Peek(), os);
  }

  // Performs the given mock function's default action and returns the
  // result in a new-ed ActionResultHolder.
  template <typename F>
  static ActionResultHolder* PerformDefaultAction(
      const FunctionMocker<F>* func_mocker,
      typename Function<F>::ArgumentTuple&& args,
      const std::string& call_description) {
    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
        std::move(args), call_description)));
  }

  // Performs the given action and returns the result in a new-ed
  // ActionResultHolder.
  template <typename F>
  static ActionResultHolder* PerformAction(
      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
    return new ActionResultHolder(
        Wrapper(action.Perform(std::move(args))));
  }

 private:
  typedef ReferenceOrValueWrapper<T> Wrapper;

  explicit ActionResultHolder(Wrapper result)
      : result_(std::move(result)) {
  }

  Wrapper result_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
};

// Specialization for T = void.
template <>
class ActionResultHolder<void> : public UntypedActionResultHolderBase {
 public:
  void Unwrap() { }

  void PrintAsActionResult(::std::ostream* /* os */) const override {}

  // Performs the given mock function's default action and returns ownership
  // of an empty ActionResultHolder*.
  template <typename F>
  static ActionResultHolder* PerformDefaultAction(
      const FunctionMocker<F>* func_mocker,
      typename Function<F>::ArgumentTuple&& args,
      const std::string& call_description) {
    func_mocker->PerformDefaultAction(std::move(args), call_description);
    return new ActionResultHolder;
  }

  // Performs the given action and returns ownership of an empty
  // ActionResultHolder*.
  template <typename F>
  static ActionResultHolder* PerformAction(
      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
    action.Perform(std::move(args));
    return new ActionResultHolder;
  }

 private:
  ActionResultHolder() {}
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
};

template <typename F>
class FunctionMocker;

template <typename R, typename... Args>
class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
  using F = R(Args...);

 public:
  using Result = R;
  using ArgumentTuple = std::tuple<Args...>;
  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;

  FunctionMocker() {}

  // There is no generally useful and implementable semantics of
  // copying a mock object, so copying a mock is usually a user error.
  // Thus we disallow copying function mockers.  If the user really
  // wants to copy a mock object, they should implement their own copy
  // operation, for example:
  //
  //   class MockFoo : public Foo {
  //    public:
  //     // Defines a copy constructor explicitly.
  //     MockFoo(const MockFoo& src) {}
  //     ...
  //   };
  FunctionMocker(const FunctionMocker&) = delete;
  FunctionMocker& operator=(const FunctionMocker&) = delete;

  // The destructor verifies that all expectations on this mock
  // function have been satisfied.  If not, it will report Google Test
  // non-fatal failures for the violations.
  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    MutexLock l(&g_gmock_mutex);
    VerifyAndClearExpectationsLocked();
    Mock::UnregisterLocked(this);
    ClearDefaultActionsLocked();
  }

  // Returns the ON_CALL spec that matches this mock function with the
  // given arguments; returns NULL if no matching ON_CALL is found.
  // L = *
  const OnCallSpec<F>* FindOnCallSpec(
      const ArgumentTuple& args) const {
    for (UntypedOnCallSpecs::const_reverse_iterator it
             = untyped_on_call_specs_.rbegin();
         it != untyped_on_call_specs_.rend(); ++it) {
      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
      if (spec->Matches(args))
        return spec;
    }

    return nullptr;
  }

  // Performs the default action of this mock function on the given
  // arguments and returns the result. Asserts (or throws if
  // exceptions are enabled) with a helpful call descrption if there
  // is no valid return value. This method doesn't depend on the
  // mutable state of this object, and thus can be called concurrently
  // without locking.
  // L = *
  Result PerformDefaultAction(ArgumentTuple&& args,
                              const std::string& call_description) const {
    const OnCallSpec<F>* const spec =
        this->FindOnCallSpec(args);
    if (spec != nullptr) {
      return spec->GetAction().Perform(std::move(args));
    }
    const std::string message =
        call_description +
        "\n    The mock function has no default action "
        "set, and its return type has no default value set.";
#if GTEST_HAS_EXCEPTIONS
    if (!DefaultValue<Result>::Exists()) {
      throw std::runtime_error(message);
    }
#else
    Assert(DefaultValue<Result>::Exists(), "", -1, message);
#endif
    return DefaultValue<Result>::Get();
  }

  // Performs the default action with the given arguments and returns
  // the action's result.  The call description string will be used in
  // the error message to describe the call in the case the default
  // action fails.  The caller is responsible for deleting the result.
  // L = *
  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
      void* untyped_args,  // must point to an ArgumentTuple
      const std::string& call_description) const override {
    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
    return ResultHolder::PerformDefaultAction(this, std::move(*args),
                                              call_description);
  }

  // Performs the given action with the given arguments and returns
  // the action's result.  The caller is responsible for deleting the
  // result.
  // L = *
  UntypedActionResultHolderBase* UntypedPerformAction(
      const void* untyped_action, void* untyped_args) const override {
    // Make a copy of the action before performing it, in case the
    // action deletes the mock object (and thus deletes itself).
    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
    return ResultHolder::PerformAction(action, std::move(*args));
  }

  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
  // clears the ON_CALL()s set on this mock function.
  void ClearDefaultActionsLocked() override
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();

    // Deleting our default actions may trigger other mock objects to be
    // deleted, for example if an action contains a reference counted smart
    // pointer to that mock object, and that is the last reference. So if we
    // delete our actions within the context of the global mutex we may deadlock
    // when this method is called again. Instead, make a copy of the set of
    // actions to delete, clear our set within the mutex, and then delete the
    // actions outside of the mutex.
    UntypedOnCallSpecs specs_to_delete;
    untyped_on_call_specs_.swap(specs_to_delete);

    g_gmock_mutex.Unlock();
    for (UntypedOnCallSpecs::const_iterator it =
             specs_to_delete.begin();
         it != specs_to_delete.end(); ++it) {
      delete static_cast<const OnCallSpec<F>*>(*it);
    }

    // Lock the mutex again, since the caller expects it to be locked when we
    // return.
    g_gmock_mutex.Lock();
  }

  // Returns the result of invoking this mock function with the given
  // arguments.  This function can be safely called from multiple
  // threads concurrently.
  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    ArgumentTuple tuple(std::forward<Args>(args)...);
    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
    return holder->Unwrap();
  }

  MockSpec<F> With(Matcher<Args>... m) {
    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
  }

 protected:
  template <typename Function>
  friend class MockSpec;

  typedef ActionResultHolder<Result> ResultHolder;

  // Adds and returns a default action spec for this mock function.
  OnCallSpec<F>& AddNewOnCallSpec(
      const char* file, int line,
      const ArgumentMatcherTuple& m)
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
    untyped_on_call_specs_.push_back(on_call_spec);
    return *on_call_spec;
  }

  // Adds and returns an expectation spec for this mock function.
  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
                                         const std::string& source_text,
                                         const ArgumentMatcherTuple& m)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
    TypedExpectation<F>* const expectation =
        new TypedExpectation<F>(this, file, line, source_text, m);
    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
    // See the definition of untyped_expectations_ for why access to
    // it is unprotected here.
    untyped_expectations_.push_back(untyped_expectation);

    // Adds this expectation into the implicit sequence if there is one.
    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
    if (implicit_sequence != nullptr) {
      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
    }

    return *expectation;
  }

 private:
  template <typename Func> friend class TypedExpectation;

  // Some utilities needed for implementing UntypedInvokeWith().

  // Describes what default action will be performed for the given
  // arguments.
  // L = *
  void DescribeDefaultActionTo(const ArgumentTuple& args,
                               ::std::ostream* os) const {
    const OnCallSpec<F>* const spec = FindOnCallSpec(args);

    if (spec == nullptr) {
      *os << (std::is_void<Result>::value ? "returning directly.\n"
                                          : "returning default value.\n");
    } else {
      *os << "taking default action specified at:\n"
          << FormatFileLocation(spec->file(), spec->line()) << "\n";
    }
  }

  // Writes a message that the call is uninteresting (i.e. neither
  // explicitly expected nor explicitly unexpected) to the given
  // ostream.
  void UntypedDescribeUninterestingCall(const void* untyped_args,
                                        ::std::ostream* os) const override
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    const ArgumentTuple& args =
        *static_cast<const ArgumentTuple*>(untyped_args);
    *os << "Uninteresting mock function call - ";
    DescribeDefaultActionTo(args, os);
    *os << "    Function call: " << Name();
    UniversalPrint(args, os);
  }

  // Returns the expectation that matches the given function arguments
  // (or NULL is there's no match); when a match is found,
  // untyped_action is set to point to the action that should be
  // performed (or NULL if the action is "do default"), and
  // is_excessive is modified to indicate whether the call exceeds the
  // expected number.
  //
  // Critical section: We must find the matching expectation and the
  // corresponding action that needs to be taken in an ATOMIC
  // transaction.  Otherwise another thread may call this mock
  // method in the middle and mess up the state.
  //
  // However, performing the action has to be left out of the critical
  // section.  The reason is that we have no control on what the
  // action does (it can invoke an arbitrary user function or even a
  // mock function) and excessive locking could cause a dead lock.
  const ExpectationBase* UntypedFindMatchingExpectation(
      const void* untyped_args, const void** untyped_action, bool* is_excessive,
      ::std::ostream* what, ::std::ostream* why) override
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    const ArgumentTuple& args =
        *static_cast<const ArgumentTuple*>(untyped_args);
    MutexLock l(&g_gmock_mutex);
    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
    if (exp == nullptr) {  // A match wasn't found.
      this->FormatUnexpectedCallMessageLocked(args, what, why);
      return nullptr;
    }

    // This line must be done before calling GetActionForArguments(),
    // which will increment the call count for *exp and thus affect
    // its saturation status.
    *is_excessive = exp->IsSaturated();
    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
    if (action != nullptr && action->IsDoDefault())
      action = nullptr;  // Normalize "do default" to NULL.
    *untyped_action = action;
    return exp;
  }

  // Prints the given function arguments to the ostream.
  void UntypedPrintArgs(const void* untyped_args,
                        ::std::ostream* os) const override {
    const ArgumentTuple& args =
        *static_cast<const ArgumentTuple*>(untyped_args);
    UniversalPrint(args, os);
  }

  // Returns the expectation that matches the arguments, or NULL if no
  // expectation matches them.
  TypedExpectation<F>* FindMatchingExpectationLocked(
      const ArgumentTuple& args) const
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    // See the definition of untyped_expectations_ for why access to
    // it is unprotected here.
    for (typename UntypedExpectations::const_reverse_iterator it =
             untyped_expectations_.rbegin();
         it != untyped_expectations_.rend(); ++it) {
      TypedExpectation<F>* const exp =
          static_cast<TypedExpectation<F>*>(it->get());
      if (exp->ShouldHandleArguments(args)) {
        return exp;
      }
    }
    return nullptr;
  }

  // Returns a message that the arguments don't match any expectation.
  void FormatUnexpectedCallMessageLocked(
      const ArgumentTuple& args,
      ::std::ostream* os,
      ::std::ostream* why) const
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    *os << "\nUnexpected mock function call - ";
    DescribeDefaultActionTo(args, os);
    PrintTriedExpectationsLocked(args, why);
  }

  // Prints a list of expectations that have been tried against the
  // current mock function call.
  void PrintTriedExpectationsLocked(
      const ArgumentTuple& args,
      ::std::ostream* why) const
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld();
    const size_t count = untyped_expectations_.size();
    *why << "Google Mock tried the following " << count << " "
         << (count == 1 ? "expectation, but it didn't match" :
             "expectations, but none matched")
         << ":\n";
    for (size_t i = 0; i < count; i++) {
      TypedExpectation<F>* const expectation =
          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
      *why << "\n";
      expectation->DescribeLocationTo(why);
      if (count > 1) {
        *why << "tried expectation #" << i << ": ";
      }
      *why << expectation->source_text() << "...\n";
      expectation->ExplainMatchResultTo(args, why);
      expectation->DescribeCallCountTo(why);
    }
  }
};  // class FunctionMocker

// Reports an uninteresting call (whose description is in msg) in the
// manner specified by 'reaction'.
void ReportUninterestingCall(CallReaction reaction, const std::string& msg);

}  // namespace internal

namespace internal {

template <typename F>
class MockFunction;

template <typename R, typename... Args>
class MockFunction<R(Args...)> {
 public:
  MockFunction(const MockFunction&) = delete;
  MockFunction& operator=(const MockFunction&) = delete;

  std::function<R(Args...)> AsStdFunction() {
    return [this](Args... args) -> R {
      return this->Call(std::forward<Args>(args)...);
    };
  }

  // Implementation detail: the expansion of the MOCK_METHOD macro.
  R Call(Args... args) {
    mock_.SetOwnerAndName(this, "Call");
    return mock_.Invoke(std::forward<Args>(args)...);
  }

  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
    mock_.RegisterOwner(this);
    return mock_.With(std::move(m)...);
  }

  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
    return this->gmock_Call(::testing::A<Args>()...);
  }

 protected:
  MockFunction() = default;
  ~MockFunction() = default;

 private:
  FunctionMocker<R(Args...)> mock_;
};

/*
The SignatureOf<F> struct is a meta-function returning function signature
corresponding to the provided F argument.

It makes use of MockFunction easier by allowing it to accept more F arguments
than just function signatures.

Specializations provided here cover only a signature type itself and
std::function. However, if need be it can be easily extended to cover also other
types (like for example boost::function).
*/

template <typename F>
struct SignatureOf;

template <typename R, typename... Args>
struct SignatureOf<R(Args...)> {
  using type = R(Args...);
};

template <typename F>
struct SignatureOf<std::function<F>> : SignatureOf<F> {};

template <typename F>
using SignatureOfT = typename SignatureOf<F>::type;

}  // namespace internal

// A MockFunction<F> type has one mock method whose type is
// internal::SignatureOfT<F>.  It is useful when you just want your
// test code to emit some messages and have Google Mock verify the
// right messages are sent (and perhaps at the right times).  For
// example, if you are exercising code:
//
//   Foo(1);
//   Foo(2);
//   Foo(3);
//
// and want to verify that Foo(1) and Foo(3) both invoke
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
//
// TEST(FooTest, InvokesBarCorrectly) {
//   MyMock mock;
//   MockFunction<void(string check_point_name)> check;
//   {
//     InSequence s;
//
//     EXPECT_CALL(mock, Bar("a"));
//     EXPECT_CALL(check, Call("1"));
//     EXPECT_CALL(check, Call("2"));
//     EXPECT_CALL(mock, Bar("a"));
//   }
//   Foo(1);
//   check.Call("1");
//   Foo(2);
//   check.Call("2");
//   Foo(3);
// }
//
// The expectation spec says that the first Bar("a") must happen
// before check point "1", the second Bar("a") must happen after check
// point "2", and nothing should happen between the two check
// points. The explicit check points make it easy to tell which
// Bar("a") is called by which call to Foo().
//
// MockFunction<F> can also be used to exercise code that accepts
// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
// AsStdFunction() method to create std::function proxy forwarding to
// original object's Call. Example:
//
// TEST(FooTest, RunsCallbackWithBarArgument) {
//   MockFunction<int(string)> callback;
//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
//   Foo(callback.AsStdFunction());
// }
//
// The internal::SignatureOfT<F> indirection allows to use other types
// than just function signature type. This is typically useful when
// providing a mock for a predefined std::function type. Example:
//
// using FilterPredicate = std::function<bool(string)>;
// void MyFilterAlgorithm(FilterPredicate predicate);
//
// TEST(FooTest, FilterPredicateAlwaysAccepts) {
//   MockFunction<FilterPredicate> predicateMock;
//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
//   MyFilterAlgorithm(predicateMock.AsStdFunction());
// }
template <typename F>
class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
  using Base = internal::MockFunction<internal::SignatureOfT<F>>;

 public:
  using Base::Base;
};

// The style guide prohibits "using" statements in a namespace scope
// inside a header file.  However, the MockSpec class template is
// meant to be defined in the ::testing namespace.  The following line
// is just a trick for working around a bug in MSVC 8.0, which cannot
// handle it if we define MockSpec in ::testing.
using internal::MockSpec;

// Const(x) is a convenient function for obtaining a const reference
// to x.  This is useful for setting expectations on an overloaded
// const mock method, e.g.
//
//   class MockFoo : public FooInterface {
//    public:
//     MOCK_METHOD0(Bar, int());
//     MOCK_CONST_METHOD0(Bar, int&());
//   };
//
//   MockFoo foo;
//   // Expects a call to non-const MockFoo::Bar().
//   EXPECT_CALL(foo, Bar());
//   // Expects a call to const MockFoo::Bar().
//   EXPECT_CALL(Const(foo), Bar());
template <typename T>
inline const T& Const(const T& x) { return x; }

// Constructs an Expectation object that references and co-owns exp.
inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
    : expectation_base_(exp.GetHandle().expectation_base()) {}

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
// required to avoid compile errors when the name of the method used in call is
// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
// tests in internal/gmock-spec-builders_test.cc for more details.
//
// This macro supports statements both with and without parameter matchers. If
// the parameter list is omitted, gMock will accept any parameters, which allows
// tests to be written that don't need to encode the number of method
// parameter. This technique may only be used for non-overloaded methods.
//
//   // These are the same:
//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
//
//   // As are these:
//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
//
//   // Can also specify args if you want, of course:
//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
//
//   // Overloads work as long as you specify parameters:
//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
//
//   // Oops! Which overload did you want?
//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
//
// How this works: The mock class uses two overloads of the gmock_Method
// expectation setter method plus an operator() overload on the MockSpec object.
// In the matcher list form, the macro expands to:
//
//   // This statement:
//   ON_CALL(mock, TwoArgsMethod(_, 45))...
//
//   // ...expands to:
//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
//   |-------------v---------------||------------v-------------|
//       invokes first overload        swallowed by operator()
//
//   // ...which is essentially:
//   mock.gmock_TwoArgsMethod(_, 45)...
//
// Whereas the form without a matcher list:
//
//   // This statement:
//   ON_CALL(mock, TwoArgsMethod)...
//
//   // ...expands to:
//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
//   |-----------------------v--------------------------|
//                 invokes second overload
//
//   // ...which is essentially:
//   mock.gmock_TwoArgsMethod(_, _)...
//
// The WithoutMatchers() argument is used to disambiguate overloads and to
// block the caller from accidentally invoking the second overload directly. The
// second argument is an internal type derived from the method signature. The
// failure to disambiguate two overloads of this method in the ON_CALL statement
// is how we block callers from setting expectations on overloaded methods.
#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
                             nullptr)                                   \
      .Setter(__FILE__, __LINE__, #mock_expr, #call)

#define ON_CALL(obj, call) \
  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)

#define EXPECT_CALL(obj, call) \
  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_

namespace testing {
namespace internal {
template <typename T>
using identity_t = T;

template <typename Pattern>
struct ThisRefAdjuster {
  template <typename T>
  using AdjustT = typename std::conditional<
      std::is_const<typename std::remove_reference<Pattern>::type>::value,
      typename std::conditional<std::is_lvalue_reference<Pattern>::value,
                                const T&, const T&&>::type,
      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
                                T&&>::type>::type;

  template <typename MockType>
  static AdjustT<MockType> Adjust(const MockType& mock) {
    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
  }
};

}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope
// inside a header file.  However, the FunctionMocker class template
// is meant to be defined in the ::testing namespace.  The following
// line is just a trick for working around a bug in MSVC 8.0, which
// cannot handle it if we define FunctionMocker in ::testing.
using internal::FunctionMocker;
}  // namespace testing

#define MOCK_METHOD(...) \
  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \
  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \
  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \
  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \
      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \
  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \
  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \
      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \
      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \
      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \
      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \
      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)

#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
  static_assert(                                                             \
      false,                                                                 \
      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
      "it must also be enclosed in parentheses.")

#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
  static_assert(                                  \
      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")

#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
  static_assert(                                                       \
      std::is_function<__VA_ARGS__>::value,                            \
      "Signature must be a function type, maybe return type contains " \
      "unprotected comma.");                                           \
  static_assert(                                                       \
      ::testing::tuple_size<typename ::testing::internal::Function<    \
              __VA_ARGS__>::ArgumentTuple>::value == _N,               \
      "This method does not take " GMOCK_PP_STRINGIZE(                 \
          _N) " arguments. Parenthesize all types with unprotected commas.")

#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)

#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
                                        _Override, _Final, _NoexceptSpec,      \
                                        _CallType, _RefSpec, _Signature)       \
  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
      _Signature)>::Result                                                     \
  GMOCK_INTERNAL_EXPAND(_CallType)                                             \
      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \
          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \
    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
        .SetOwnerAndName(this, #_MethodName);                                  \
    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
  }                                                                            \
  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
  }                                                                            \
  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
      const ::testing::internal::WithoutMatchers&,                             \
      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
  }                                                                            \
  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
      GMOCK_MOCKER_(_N, _Constness, _MethodName)

#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__

// Five Valid modifiers.
#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))

#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
  GMOCK_PP_HAS_COMMA(                       \
      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))

#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))

#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)

#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
  GMOCK_PP_IF(                                                          \
      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
      _elem, )

#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)

#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )

#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)

#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \
  static_assert(                                                          \
      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \
       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \
       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \
       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \
       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \
       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \
      GMOCK_PP_STRINGIZE(                                                 \
          _elem) " cannot be recognized as a valid specification modifier.");

// Modifiers implementation.
#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)

#define GMOCK_INTERNAL_DETECT_CONST_I_const ,

#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)

#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,

#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)

#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,

#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)

#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,

#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)

#define GMOCK_INTERNAL_DETECT_REF_I_ref ,

#define GMOCK_INTERNAL_UNPACK_ref(x) x

#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \
  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \
              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
  (_elem)

// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows
// maybe they can be simplified somehow.
#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
  GMOCK_INTERNAL_IS_CALLTYPE_I(          \
      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg)

#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \
      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
  GMOCK_PP_IDENTITY _arg

#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype

// Note: The use of `identity_t` here allows _Ret to represent return types that
// would normally need to be specified in a different way. For example, a method
// returning a function pointer must be written as
//
// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
//
// But we only support placing the return type at the beginning. To handle this,
// we wrap all calls in identity_t, so that a declaration will be expanded to
//
// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
//
// This allows us to work around the syntactic oddities of function/method
// types.
#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
                                              GMOCK_PP_REMOVE_PARENS,         \
                                              GMOCK_PP_IDENTITY)(_Ret)>(      \
      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))

#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
  GMOCK_PP_COMMA_IF(_i)                                                \
  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
              GMOCK_PP_IDENTITY)                                       \
  (_elem)

#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
  GMOCK_PP_COMMA_IF(_i)                                        \
  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
  gmock_a##_i

#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
  GMOCK_PP_COMMA_IF(_i)                               \
  ::std::forward<GMOCK_INTERNAL_ARG_O(                \
      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)

#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
  GMOCK_PP_COMMA_IF(_i)                                            \
  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
  gmock_a##_i

#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
  GMOCK_PP_COMMA_IF(_i)                             \
  gmock_a##_i

#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
  GMOCK_PP_COMMA_IF(_i)                                      \
  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()

#define GMOCK_INTERNAL_ARG_O(_i, ...) \
  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type

#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
  const ::testing::Matcher<typename ::testing::internal::Function< \
      __VA_ARGS__>::template Arg<_i>::type>&

#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
#define MOCK_METHOD10(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)

#define MOCK_CONST_METHOD0(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
#define MOCK_CONST_METHOD1(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
#define MOCK_CONST_METHOD2(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
#define MOCK_CONST_METHOD3(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
#define MOCK_CONST_METHOD4(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
#define MOCK_CONST_METHOD5(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
#define MOCK_CONST_METHOD6(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
#define MOCK_CONST_METHOD7(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
#define MOCK_CONST_METHOD8(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
#define MOCK_CONST_METHOD9(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
#define MOCK_CONST_METHOD10(m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)

#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)

#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)

#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)

#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)

#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)

#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)

#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
      (::testing::internal::identity_t<__VA_ARGS__>))

#define GMOCK_MOCKER_(arity, constness, Method) \
  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements some commonly used variadic actions.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_

#include <memory>
#include <utility>


// Include any custom callback actions added by the local installation.
// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_

// Sometimes you want to give an action explicit template parameters
// that cannot be inferred from its value parameters.  ACTION() and
// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
// and can be viewed as an extension to ACTION() and ACTION_P*().
//
// The syntax:
//
//   ACTION_TEMPLATE(ActionName,
//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
//
// defines an action template that takes m explicit template
// parameters and n value parameters.  name_i is the name of the i-th
// template parameter, and kind_i specifies whether it's a typename,
// an integral constant, or a template.  p_i is the name of the i-th
// value parameter.
//
// Example:
//
//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
//   // function to type T and copies it to *output.
//   ACTION_TEMPLATE(DuplicateArg,
//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
//                   AND_1_VALUE_PARAMS(output)) {
//     *output = T(::std::get<k>(args));
//   }
//   ...
//     int n;
//     EXPECT_CALL(mock, Foo(_, _))
//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
//
// To create an instance of an action template, write:
//
//   ActionName<t1, ..., t_m>(v1, ..., v_n)
//
// where the ts are the template arguments and the vs are the value
// arguments.  The value argument types are inferred by the compiler.
// If you want to explicitly specify the value argument types, you can
// provide additional template arguments:
//
//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
//
// where u_i is the desired type of v_i.
//
// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
// number of value parameters, but not on the number of template
// parameters.  Without the restriction, the meaning of the following
// is unclear:
//
//   OverloadedAction<int, bool>(x);
//
// Are we using a single-template-parameter action where 'bool' refers
// to the type of x, or are we using a two-template-parameter action
// where the compiler is asked to infer the type of x?
//
// Implementation notes:
//
// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
// implementing ACTION_TEMPLATE.  The main trick we use is to create
// new macro invocations when expanding a macro.  For example, we have
//
//   #define ACTION_TEMPLATE(name, template_params, value_params)
//       ... GMOCK_INTERNAL_DECL_##template_params ...
//
// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
// to expand to
//
//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
//
// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
// preprocessor will continue to expand it to
//
//       ... typename T ...
//
// This technique conforms to the C++ standard and is portable.  It
// allows us to implement action templates using O(N) code, where N is
// the maximum number of template/value parameters supported.  Without
// using it, we'd have to devote O(N^2) amount of code to implement all
// combinations of m and n.

// Declares the template parameters.
#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
    name1) kind0 name0, kind1 name1
#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2) kind0 name0, kind1 name1, kind2 name2
#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
    kind3 name3
#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
    kind2 name2, kind3 name3, kind4 name4
#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
    kind5 name5, kind6 name6
#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
    kind4 name4, kind5 name5, kind6 name6, kind7 name7
#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
    kind8 name8
#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
    kind6 name6, kind7 name7, kind8 name8, kind9 name9

// Lists the template parameters.
#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
    name1) name0, name1
#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2) name0, name1, name2
#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3) name0, name1, name2, name3
#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
    name4
#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
    name2, name3, name4, name5
#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
    name6) name0, name1, name2, name3, name4, name5, name6
#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
    name6, name7, name8
#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
    name3, name4, name5, name6, name7, name8, name9

// Declares the types of value parameters.
#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
    typename p0##_type, typename p1##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
    typename p0##_type, typename p1##_type, typename p2##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
    typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
    typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type, typename p4##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
    typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type, typename p4##_type, typename p5##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type, typename p4##_type, typename p5##_type, \
    typename p6##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type, typename p4##_type, typename p5##_type, \
    typename p6##_type, typename p7##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
    typename p3##_type, typename p4##_type, typename p5##_type, \
    typename p6##_type, typename p7##_type, typename p8##_type
#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
    typename p2##_type, typename p3##_type, typename p4##_type, \
    typename p5##_type, typename p6##_type, typename p7##_type, \
    typename p8##_type, typename p9##_type

// Initializes the value parameters.
#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
    ()
#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1))
#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
    (p0##_type gmock_p0, p1##_type gmock_p1, \
        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3))
#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4, \
        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
        p5(::std::move(gmock_p5))
#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
        p7(::std::move(gmock_p7))
#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
        p6##_type gmock_p6, p7##_type gmock_p7, \
        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8, p9)\
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
        p9(::std::move(gmock_p9))

// Defines the copy constructor
#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default;
#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default;

// Declares the fields for storing the value parameters.
#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
    p1##_type p1;
#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
    p1##_type p1; p2##_type p2;
#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
    p1##_type p1; p2##_type p2; p3##_type p3;
#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
    p5##_type p5;
#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
    p5##_type p5; p6##_type p6;
#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
    p5##_type p5; p6##_type p6; p7##_type p7;
#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
    p9##_type p9;

// Lists the value parameters.
#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
    p2, p3, p4
#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
    p1, p2, p3, p4, p5
#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6) p0, p1, p2, p3, p4, p5, p6
#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7) p0, p1, p2, p3, p4, p5, p6, p7
#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9

// Lists the value parameter types.
#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
    p1##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
    p1##_type, p2##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
    p0##_type, p1##_type, p2##_type, p3##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
    p6##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
    p5##_type, p6##_type, p7##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
    p5##_type, p6##_type, p7##_type, p8##_type
#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type

// Declares the value parameters.
#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
    p1##_type p1
#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
    p1##_type p1, p2##_type p2
#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
    p1##_type p1, p2##_type p2, p3##_type p3
#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
    p5##_type p5
#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
    p5##_type p5, p6##_type p6
#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
    p5##_type p5, p6##_type p6, p7##_type p7
#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
    p9##_type p9

// The suffix of the class template implementing the action template.
#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7) P8
#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8) P9
#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
    p7, p8, p9) P10

// The name of the class template implementing the action template.
#define GMOCK_ACTION_CLASS_(name, value_params)\
    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)

#define ACTION_TEMPLATE(name, template_params, value_params)                   \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
  class GMOCK_ACTION_CLASS_(name, value_params) {                              \
   public:                                                                     \
    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
        GMOCK_INTERNAL_DECL_##value_params)                                    \
        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
                    = default; ,                                               \
                    : impl_(std::make_shared<gmock_Impl>(                      \
                                GMOCK_INTERNAL_LIST_##value_params)) { })      \
    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
    template <typename F>                                                      \
    operator ::testing::Action<F>() const {                                    \
      return GMOCK_PP_IF(                                                      \
          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
                      (::testing::internal::MakeAction<F>(impl_)));            \
    }                                                                          \
   private:                                                                    \
    class gmock_Impl {                                                         \
     public:                                                                   \
      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \
      template <typename function_type, typename return_type,                  \
                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
      GMOCK_INTERNAL_DEFN_##value_params                                       \
    };                                                                         \
    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
                , std::shared_ptr<const gmock_Impl> impl_;)                    \
  };                                                                           \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
  GMOCK_ACTION_CLASS_(name, value_params)<                                     \
      GMOCK_INTERNAL_LIST_##template_params                                    \
      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
      GMOCK_INTERNAL_LIST_##template_params                                    \
      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
          GMOCK_INTERNAL_DECL_##value_params) {                                \
    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
        GMOCK_INTERNAL_LIST_##template_params                                  \
        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
            GMOCK_INTERNAL_LIST_##value_params);                               \
  }                                                                            \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
  template <typename function_type, typename return_type, typename args_type,  \
            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
      GMOCK_INTERNAL_LIST_##template_params                                    \
      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const

namespace testing {

// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma.  Therefore
// we suppress them here.
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif

namespace internal {

// internal::InvokeArgument - a helper for InvokeArgument action.
// The basic overloads are provided here for generic functors.
// Overloads for other custom-callables are provided in the
// internal/custom/gmock-generated-actions.h header.
template <typename F, typename... Args>
auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
  return f(args...);
}

template <std::size_t index, typename... Params>
struct InvokeArgumentAction {
  template <typename... Args>
  auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
      std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
      std::declval<const Params&>()...)) {
    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{},
                                              std::forward<Args>(args)...);
    return params.Apply([&](const Params&... unpacked_params) {
      auto&& callable = args_tuple.template Get<index>();
      return internal::InvokeArgument(
          std::forward<decltype(callable)>(callable), unpacked_params...);
    });
  }

  internal::FlatTuple<Params...> params;
};

}  // namespace internal

// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
// (0-based) argument, which must be a k-ary callable, of the mock
// function, with arguments a1, a2, ..., a_k.
//
// Notes:
//
//   1. The arguments are passed by value by default.  If you need to
//   pass an argument by reference, wrap it inside std::ref().  For
//   example,
//
//     InvokeArgument<1>(5, string("Hello"), std::ref(foo))
//
//   passes 5 and string("Hello") by value, and passes foo by
//   reference.
//
//   2. If the callable takes an argument by reference but std::ref() is
//   not used, it will receive the reference to a copy of the value,
//   instead of the original value.  For example, when the 0-th
//   argument of the mock function takes a const string&, the action
//
//     InvokeArgument<0>(string("Hello"))
//
//   makes a copy of the temporary string("Hello") object and passes a
//   reference of the copy, instead of the original temporary object,
//   to the callable.  This makes it easy for a user to define an
//   InvokeArgument action from temporary values and have it performed
//   later.
template <std::size_t index, typename... Params>
internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
InvokeArgument(Params&&... params) {
  return {internal::FlatTuple<typename std::decay<Params>::type...>(
      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
}

#ifdef _MSC_VER
# pragma warning(pop)
#endif

}  // namespace testing

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
// Copyright 2013, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements some matchers that depend on gmock-matchers.h.
//
// Note that tests are implemented in gmock-matchers_test.cc rather than
// gmock-more-matchers-test.cc.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_


namespace testing {

// Silence C4100 (unreferenced formal
// parameter) for MSVC
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#if (_MSC_VER == 1900)
// and silence C4800 (C4800: 'int *const ': forcing value
// to bool 'true' or 'false') for MSVC 14
# pragma warning(disable:4800)
  #endif
#endif

// Defines a matcher that matches an empty container. The container must
// support both size() and empty(), which all STL-like containers provide.
MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
  if (arg.empty()) {
    return true;
  }
  *result_listener << "whose size is " << arg.size();
  return false;
}

// Define a matcher that matches a value that evaluates in boolean
// context to true.  Useful for types that define "explicit operator
// bool" operators and so can't be compared for equality with true
// and false.
MATCHER(IsTrue, negation ? "is false" : "is true") {
  return static_cast<bool>(arg);
}

// Define a matcher that matches a value that evaluates in boolean
// context to false.  Useful for types that define "explicit operator
// bool" operators and so can't be compared for equality with true
// and false.
MATCHER(IsFalse, negation ? "is true" : "is false") {
  return !static_cast<bool>(arg);
}

#ifdef _MSC_VER
# pragma warning(pop)
#endif


}  // namespace testing

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Implements class templates NiceMock, NaggyMock, and StrictMock.
//
// Given a mock class MockFoo that is created using Google Mock,
// NiceMock<MockFoo> is a subclass of MockFoo that allows
// uninteresting calls (i.e. calls to mock methods that have no
// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
// that prints a warning when an uninteresting call occurs, and
// StrictMock<MockFoo> is a subclass of MockFoo that treats all
// uninteresting calls as errors.
//
// Currently a mock is naggy by default, so MockFoo and
// NaggyMock<MockFoo> behave like the same.  However, we will soon
// switch the default behavior of mocks to be nice, as that in general
// leads to more maintainable tests.  When that happens, MockFoo will
// stop behaving like NaggyMock<MockFoo> and start behaving like
// NiceMock<MockFoo>.
//
// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
// their respective base class.  Therefore you can write
// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
// has a constructor that accepts (int, const char*), for example.
//
// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
// and StrictMock<MockFoo> only works for mock methods defined using
// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
// If a mock method is defined in a base class of MockFoo, the "nice"
// or "strict" modifier may not affect it, depending on the compiler.
// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
// supported.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_

#include <type_traits>


namespace testing {
template <class MockClass>
class NiceMock;
template <class MockClass>
class NaggyMock;
template <class MockClass>
class StrictMock;

namespace internal {
template <typename T>
std::true_type StrictnessModifierProbe(const NiceMock<T>&);
template <typename T>
std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
template <typename T>
std::true_type StrictnessModifierProbe(const StrictMock<T>&);
std::false_type StrictnessModifierProbe(...);

template <typename T>
constexpr bool HasStrictnessModifier() {
  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
}

// Base classes that register and deregister with testing::Mock to alter the
// default behavior around uninteresting calls. Inheriting from one of these
// classes first and then MockClass ensures the MockClass constructor is run
// after registration, and that the MockClass destructor runs before
// deregistration. This guarantees that MockClass's constructor and destructor
// run with the same level of strictness as its instance methods.

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
    (defined(_MSC_VER) || defined(__clang__))
// We need to mark these classes with this declspec to ensure that
// the empty base class optimization is performed.
#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
#else
#define GTEST_INTERNAL_EMPTY_BASE_CLASS
#endif

template <typename Base>
class NiceMockImpl {
 public:
  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }

  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

template <typename Base>
class NaggyMockImpl {
 public:
  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }

  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

template <typename Base>
class StrictMockImpl {
 public:
  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }

  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
};

}  // namespace internal

template <class MockClass>
class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
    : private internal::NiceMockImpl<MockClass>,
      public MockClass {
 public:
  static_assert(!internal::HasStrictnessModifier<MockClass>(),
                "Can't apply NiceMock to a class hierarchy that already has a "
                "strictness modifier. See "
                "https://google.github.io/googletest/"
                "gmock_cook_book.html#NiceStrictNaggy");
  NiceMock() : MockClass() {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  template <typename TArg1, typename TArg2, typename... An>
  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
                  std::forward<An>(args)...) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
};

template <class MockClass>
class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
    : private internal::NaggyMockImpl<MockClass>,
      public MockClass {
  static_assert(!internal::HasStrictnessModifier<MockClass>(),
                "Can't apply NaggyMock to a class hierarchy that already has a "
                "strictness modifier. See "
                "https://google.github.io/googletest/"
                "gmock_cook_book.html#NiceStrictNaggy");

 public:
  NaggyMock() : MockClass() {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  template <typename TArg1, typename TArg2, typename... An>
  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
                  std::forward<An>(args)...) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
};

template <class MockClass>
class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
    : private internal::StrictMockImpl<MockClass>,
      public MockClass {
 public:
  static_assert(
      !internal::HasStrictnessModifier<MockClass>(),
      "Can't apply StrictMock to a class hierarchy that already has a "
      "strictness modifier. See "
      "https://google.github.io/googletest/"
      "gmock_cook_book.html#NiceStrictNaggy");
  StrictMock() : MockClass() {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  // Ideally, we would inherit base class's constructors through a using
  // declaration, which would preserve their visibility. However, many existing
  // tests rely on the fact that current implementation reexports protected
  // constructors as public. These tests would need to be cleaned up first.

  // Single argument constructor is special-cased so that it can be
  // made explicit.
  template <typename A>
  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

  template <typename TArg1, typename TArg2, typename... An>
  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
                  std::forward<An>(args)...) {
    static_assert(sizeof(*this) == sizeof(MockClass),
                  "The impl subclass shouldn't introduce any padding");
  }

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
};

#undef GTEST_INTERNAL_EMPTY_BASE_CLASS

}  // namespace testing

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_

namespace testing {

// Declares Google Mock flags that we want a user to use programmatically.
GMOCK_DECLARE_bool_(catch_leaked_mocks);
GMOCK_DECLARE_string_(verbose);
GMOCK_DECLARE_int32_(default_mock_behavior);

// Initializes Google Mock.  This must be called before running the
// tests.  In particular, it parses the command line for the flags
// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
// it is removed from argv, and *argc is decremented.
//
// No value is returned.  Instead, the Google Mock flag variables are
// updated.
//
// Since Google Test is needed for Google Mock to work, this function
// also initializes Google Test and parses its flags, if that hasn't
// been done.
GTEST_API_ void InitGoogleMock(int* argc, char** argv);

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);

// This overloaded version can be used on Arduino/embedded platforms where
// there is no argc/argv.
GTEST_API_ void InitGoogleMock();

}  // namespace testing

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_


================================================
FILE: examples/libraries/fmt/test/gtest/gmock-gtest-all.cc
================================================
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Google C++ Testing and Mocking Framework (Google Test)
//
// Sometimes it's desirable to build Google Test by compiling a single file.
// This file serves this purpose.

// This line ensures that gtest.h can be compiled on its own, even
// when it's fused.
#include "gtest/gtest.h"

// The following lines pull in the real gtest *.cc files.
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// The Google C++ Testing and Mocking Framework (Google Test)

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Utilities for testing Google Test itself and code that uses Google Test
// (e.g. frameworks built on top of Google Test).

// GOOGLETEST_CM0004 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_


GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// This helper class can be used to mock out Google Test failure reporting
// so that we can test Google Test or code that builds on Google Test.
//
// An object of this class appends a TestPartResult object to the
// TestPartResultArray object given in the constructor whenever a Google Test
// failure is reported. It can either intercept only failures that are
// generated in the same thread that created this object or it can intercept
// all generated failures. The scope of this mock object can be controlled with
// the second argument to the two arguments constructor.
class GTEST_API_ ScopedFakeTestPartResultReporter
    : public TestPartResultReporterInterface {
 public:
  // The two possible mocking modes of this object.
  enum InterceptMode {
    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
    INTERCEPT_ALL_THREADS           // Intercepts all failures.
  };

  // The c'tor sets this object as the test part result reporter used
  // by Google Test.  The 'result' parameter specifies where to report the
  // results. This reporter will only catch failures generated in the current
  // thread. DEPRECATED
  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);

  // Same as above, but you can choose the interception scope of this object.
  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
                                   TestPartResultArray* result);

  // The d'tor restores the previous test part result reporter.
  ~ScopedFakeTestPartResultReporter() override;

  // Appends the TestPartResult object to the TestPartResultArray
  // received in the constructor.
  //
  // This method is from the TestPartResultReporterInterface
  // interface.
  void ReportTestPartResult(const TestPartResult& result) override;

 private:
  void Init();

  const InterceptMode intercept_mode_;
  TestPartResultReporterInterface* old_reporter_;
  TestPartResultArray* const result_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
};

namespace internal {

// A helper class for implementing EXPECT_FATAL_FAILURE() and
// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
// TestPartResultArray contains exactly one failure that has the given
// type and contains the given substring.  If that's not the case, a
// non-fatal failure will be generated.
class GTEST_API_ SingleFailureChecker {
 public:
  // The constructor remembers the arguments.
  SingleFailureChecker(const TestPartResultArray* results,
                       TestPartResult::Type type, const std::string& substr);
  ~SingleFailureChecker();
 private:
  const TestPartResultArray* const results_;
  const TestPartResult::Type type_;
  const std::string substr_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
};

}  // namespace internal

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// A set of macros for testing Google Test assertions or code that's expected
// to generate Google Test fatal failures.  It verifies that the given
// statement will cause exactly one fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
//   - 'statement' cannot reference local non-static variables or
//     non-static members of the current object.
//   - 'statement' cannot return a value.
//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \
  do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
  do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ALL_THREADS, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

// A macro for testing Google Test assertions or code that's expected to
// generate Google Test non-fatal failures.  It asserts that the given
// statement will cause exactly one non-fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// 'statement' is allowed to reference local variables and members of
// the current object.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  If we do that, the code won't compile when the user gives
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
// expands to code containing an unprotected comma.  The
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
// catches that.
//
// For the same reason, we have to write
//   if (::testing::internal::AlwaysTrue()) { statement; }
// instead of
//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
// to avoid an MSVC warning on unreachable code.
#define EXPECT_NONFATAL_FAILURE(statement, substr) \
  do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
  do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
          &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <wchar.h>
#include <wctype.h>

#include <algorithm>
#include <chrono>  // NOLINT
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <list>
#include <map>
#include <ostream>  // NOLINT
#include <sstream>
#include <vector>

#if GTEST_OS_LINUX

# include <fcntl.h>  // NOLINT
# include <limits.h>  // NOLINT
# include <sched.h>  // NOLINT
// Declares vsnprintf().  This header is not available on Windows.
# include <strings.h>  // NOLINT
# include <sys/mman.h>  // NOLINT
# include <sys/time.h>  // NOLINT
# include <unistd.h>  // NOLINT
# include <string>

#elif GTEST_OS_ZOS
# include <sys/time.h>  // NOLINT

// On z/OS we additionally need strings.h for strcasecmp.
# include <strings.h>  // NOLINT

#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.

# include <windows.h>  // NOLINT
# undef min

#elif GTEST_OS_WINDOWS  // We are on Windows proper.

# include <windows.h>  // NOLINT
# undef min

#ifdef _MSC_VER
# include <crtdbg.h>  // NOLINT
#endif

# include <io.h>  // NOLINT
# include <sys/timeb.h>  // NOLINT
# include <sys/types.h>  // NOLINT
# include <sys/stat.h>  // NOLINT

# if GTEST_OS_WINDOWS_MINGW
#  include <sys/time.h>  // NOLINT
# endif  // GTEST_OS_WINDOWS_MINGW

#else

// cpplint thinks that the header is already included, so we want to
// silence it.
# include <sys/time.h>  // NOLINT
# include <unistd.h>  // NOLINT

#endif  // GTEST_OS_LINUX

#if GTEST_HAS_EXCEPTIONS
# include <stdexcept>
#endif

#if GTEST_CAN_STREAM_RESULTS_
# include <arpa/inet.h>  // NOLINT
# include <netdb.h>  // NOLINT
# include <sys/socket.h>  // NOLINT
# include <sys/types.h>  // NOLINT
#endif

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Utility functions and classes used by the Google C++ testing framework.//
// This file contains purely Google Test's internal implementation.  Please
// DO NOT #INCLUDE IT IN A USER PROGRAM.

#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_

#ifndef _WIN32_WCE
# include <errno.h>
#endif  // !_WIN32_WCE
#include <stddef.h>
#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
#include <string.h>  // For memmove.

#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>


#if GTEST_CAN_STREAM_RESULTS_
# include <arpa/inet.h>  // NOLINT
# include <netdb.h>  // NOLINT
#endif

#if GTEST_OS_WINDOWS
# include <windows.h>  // NOLINT
#endif  // GTEST_OS_WINDOWS


GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// Declares the flags.
//
// We don't want the users to modify this flag in the code, but want
// Google Test's own unit tests to be able to access it. Therefore we
// declare it here as opposed to in gtest.h.
GTEST_DECLARE_bool_(death_test_use_fork);

namespace internal {

// The value of GetTestTypeId() as seen from within the Google Test
// library.  This is solely for testing GetTestTypeId().
GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;

// Names of the flags (needed for parsing Google Test flags).
const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
const char kBreakOnFailureFlag[] = "break_on_failure";
const char kCatchExceptionsFlag[] = "catch_exceptions";
const char kColorFlag[] = "color";
const char kFailFast[] = "fail_fast";
const char kFilterFlag[] = "filter";
const char kListTestsFlag[] = "list_tests";
const char kOutputFlag[] = "output";
const char kBriefFlag[] = "brief";
const char kPrintTimeFlag[] = "print_time";
const char kPrintUTF8Flag[] = "print_utf8";
const char kRandomSeedFlag[] = "random_seed";
const char kRepeatFlag[] = "repeat";
const char kShuffleFlag[] = "shuffle";
const char kStackTraceDepthFlag[] = "stack_trace_depth";
const char kStreamResultToFlag[] = "stream_result_to";
const char kThrowOnFailureFlag[] = "throw_on_failure";
const char kFlagfileFlag[] = "flagfile";

// A valid random seed must be in [1, kMaxRandomSeed].
const int kMaxRandomSeed = 99999;

// g_help_flag is true if and only if the --help flag or an equivalent form
// is specified on the command line.
GTEST_API_ extern bool g_help_flag;

// Returns the current time in milliseconds.
GTEST_API_ TimeInMillis GetTimeInMillis();

// Returns true if and only if Google Test should use colors in the output.
GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);

// Formats the given time in milliseconds as seconds.
GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);

// Converts the given time in milliseconds to a date string in the ISO 8601
// format, without the timezone information.  N.B.: due to the use the
// non-reentrant localtime() function, this function is not thread safe.  Do
// not use it in any code that can be called from multiple threads.
GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);

// Parses a string for an Int32 flag, in the form of "--flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
GTEST_API_ bool ParseInt32Flag(
    const char* str, const char* flag, int32_t* value);

// Returns a random seed in range [1, kMaxRandomSeed] based on the
// given --gtest_random_seed flag value.
inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
  return normalized_seed;
}

// Returns the first valid random seed after 'seed'.  The behavior is
// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
// considered to be 1.
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// This class saves the values of all Google Test flags in its c'tor, and
// restores them in its d'tor.
class GTestFlagSaver {
 public:
  // The c'tor.
  GTestFlagSaver() {
    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
    break_on_failure_ = GTEST_FLAG(break_on_failure);
    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
    color_ = GTEST_FLAG(color);
    death_test_style_ = GTEST_FLAG(death_test_style);
    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
    fail_fast_ = GTEST_FLAG(fail_fast);
    filter_ = GTEST_FLAG(filter);
    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
    list_tests_ = GTEST_FLAG(list_tests);
    output_ = GTEST_FLAG(output);
    brief_ = GTEST_FLAG(brief);
    print_time_ = GTEST_FLAG(print_time);
    print_utf8_ = GTEST_FLAG(print_utf8);
    random_seed_ = GTEST_FLAG(random_seed);
    repeat_ = GTEST_FLAG(repeat);
    shuffle_ = GTEST_FLAG(shuffle);
    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
    stream_result_to_ = GTEST_FLAG(stream_result_to);
    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
  }

  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
  ~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(fail_fast) = fail_fast_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(brief) = brief_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(print_utf8) = print_utf8_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
  }

 private:
  // Fields for saving the original values of flags.
  bool also_run_disabled_tests_;
  bool break_on_failure_;
  bool catch_exceptions_;
  std::string color_;
  std::string death_test_style_;
  bool death_test_use_fork_;
  bool fail_fast_;
  std::string filter_;
  std::string internal_run_death_test_;
  bool list_tests_;
  std::string output_;
  bool brief_;
  bool print_time_;
  bool print_utf8_;
  int32_t random_seed_;
  int32_t repeat_;
  bool shuffle_;
  int32_t stack_trace_depth_;
  std::string stream_result_to_;
  bool throw_on_failure_;
} GTEST_ATTRIBUTE_UNUSED_;

// Converts a Unicode code point to a narrow string in UTF-8 encoding.
// code_point parameter is of type UInt32 because wchar_t may not be
// wide enough to contain a code point.
// If the code_point is not a valid Unicode code point
// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
// to "(Invalid Unicode 0xXXXXXXXX)".
GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);

// Converts a wide string to a narrow string in UTF-8 encoding.
// The wide string is assumed to have the following encoding:
//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
// Parameter str points to a null-terminated wide string.
// Parameter num_chars may additionally limit the number
// of wchar_t characters processed. -1 is used when the entire string
// should be processed.
// If the string contains code points that are not valid Unicode code points
// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
// and contains invalid UTF-16 surrogate pairs, values in those pairs
// will be encoded as individual Unicode characters from Basic Normal Plane.
GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);

// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
// if the variable is present. If a file already exists at this location, this
// function will write over it. If the variable is present, but the file cannot
// be created, prints an error and exits.
void WriteToShardStatusFileIfNeeded();

// Checks whether sharding is enabled by examining the relevant
// environment variable values. If the variables are present,
// but inconsistent (e.g., shard_index >= total_shards), prints
// an error and exits. If in_subprocess_for_death_test, sharding is
// disabled because it must only be applied to the original test
// process. Otherwise, we could filter out death tests we intended to execute.
GTEST_API_ bool ShouldShard(const char* total_shards_str,
                            const char* shard_index_str,
                            bool in_subprocess_for_death_test);

// Parses the environment variable var as a 32-bit integer. If it is unset,
// returns default_val. If it is not a 32-bit integer, prints an error and
// and aborts.
GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);

// Given the total number of shards, the shard index, and the test id,
// returns true if and only if the test should be run on this shard. The test id
// is some arbitrary but unique non-negative integer assigned to each test
// method. Assumes that 0 <= shard_index < total_shards.
GTEST_API_ bool ShouldRunTestOnShard(
    int total_shards, int shard_index, int test_id);

// STL container utilities.

// Returns the number of elements in the given container that satisfy
// the given predicate.
template <class Container, typename Predicate>
inline int CountIf(const Container& c, Predicate predicate) {
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
    if (predicate(*it))
      ++count;
  }
  return count;
}

// Applies a function/functor to each element in the container.
template <class Container, typename Functor>
void ForEach(const Container& c, Functor functor) {
  std::for_each(c.begin(), c.end(), functor);
}

// Returns the i-th element of the vector, or default_value if i is not
// in range [0, v.size()).
template <typename E>
inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
                                                    : v[static_cast<size_t>(i)];
}

// Performs an in-place shuffle of a range of the vector's elements.
// 'begin' and 'end' are element indices as an STL-style range;
// i.e. [begin, end) are shuffled, where 'end' == size() means to
// shuffle to the end of the vector.
template <typename E>
void ShuffleRange(internal::Random* random, int begin, int end,
                  std::vector<E>* v) {
  const int size = static_cast<int>(v->size());
  GTEST_CHECK_(0 <= begin && begin <= size)
      << "Invalid shuffle range start " << begin << ": must be in range [0, "
      << size << "].";
  GTEST_CHECK_(begin <= end && end <= size)
      << "Invalid shuffle range finish " << end << ": must be in range ["
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected =
        begin +
        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
    std::swap((*v)[static_cast<size_t>(selected)],
              (*v)[static_cast<size_t>(last_in_range)]);
  }
}

// Performs an in-place shuffle of the vector's elements.
template <typename E>
inline void Shuffle(internal::Random* random, std::vector<E>* v) {
  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
}

// A function for deleting an object.  Handy for being used as a
// functor.
template <typename T>
static void Delete(T* x) {
  delete x;
}

// A predicate that checks the key of a TestProperty against a known key.
//
// TestPropertyKeyIs is copyable.
class TestPropertyKeyIs {
 public:
  // Constructor.
  //
  // TestPropertyKeyIs has NO default constructor.
  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}

  // Returns true if and only if the test name of test property matches on key_.
  bool operator()(const TestProperty& test_property) const {
    return test_property.key() == key_;
  }

 private:
  std::string key_;
};

// Class UnitTestOptions.
//
// This class contains functions for processing options the user
// specifies when running the tests.  It has only static members.
//
// In most cases, the user can specify an option using either an
// environment variable or a command line flag.  E.g. you can set the
// test filter using either GTEST_FILTER or --gtest_filter.  If both
// the variable and the flag are present, the latter overrides the
// former.
class GTEST_API_ UnitTestOptions {
 public:
  // Functions for processing the gtest_output flag.

  // Returns the output format, or "" for normal printed output.
  static std::string GetOutputFormat();

  // Returns the absolute path of the requested output file, or the
  // default (test_detail.xml in the original working directory) if
  // none was explicitly specified.
  static std::string GetAbsolutePathToOutputFile();

  // Functions for processing the gtest_filter flag.

  // Returns true if and only if the user-specified filter matches the test
  // suite name and the test name.
  static bool FilterMatchesTest(const std::string& test_suite_name,
                                const std::string& test_name);

#if GTEST_OS_WINDOWS
  // Function for supporting the gtest_catch_exception flag.

  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
  // This function is useful as an __except condition.
  static int GTestShouldProcessSEH(DWORD exception_code);
#endif  // GTEST_OS_WINDOWS

  // Returns true if "name" matches the ':' separated list of glob-style
  // filters in "filter".
  static bool MatchesFilter(const std::string& name, const char* filter);
};

// Returns the current application's name, removing directory path if that
// is present.  Used by UnitTestOptions::GetOutputFile.
GTEST_API_ FilePath GetCurrentExecutableName();

// The role interface for getting the OS stack trace as a string.
class OsStackTraceGetterInterface {
 public:
  OsStackTraceGetterInterface() {}
  virtual ~OsStackTraceGetterInterface() {}

  // Returns the current OS stack trace as an std::string.  Parameters:
  //
  //   max_depth  - the maximum number of stack frames to be included
  //                in the trace.
  //   skip_count - the number of top frames to be skipped; doesn't count
  //                against max_depth.
  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;

  // UponLeavingGTest() should be called immediately before Google Test calls
  // user code. It saves some information about the current stack that
  // CurrentStackTrace() will use to find and hide Google Test stack frames.
  virtual void UponLeavingGTest() = 0;

  // This string is inserted in place of stack frames that are part of
  // Google Test's implementation.
  static const char* const kElidedFramesMarker;

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
};

// A working implementation of the OsStackTraceGetterInterface interface.
class OsStackTraceGetter : public OsStackTraceGetterInterface {
 public:
  OsStackTraceGetter() {}

  std::string CurrentStackTrace(int max_depth, int skip_count) override;
  void UponLeavingGTest() override;

 private:
#if GTEST_HAS_ABSL
  Mutex mutex_;  // Protects all internal state.

  // We save the stack frame below the frame that calls user code.
  // We do this because the address of the frame immediately below
  // the user code changes between the call to UponLeavingGTest()
  // and any calls to the stack trace code from within the user code.
  void* caller_frame_ = nullptr;
#endif  // GTEST_HAS_ABSL

  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
};

// Information about a Google Test trace point.
struct TraceInfo {
  const char* file;
  int line;
  std::string message;
};

// This is the default global test part result reporter used in UnitTestImpl.
// This class should only be used by UnitTestImpl.
class DefaultGlobalTestPartResultReporter
  : public TestPartResultReporterInterface {
 public:
  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
  // Implements the TestPartResultReporterInterface. Reports the test part
  // result in the current test.
  void ReportTestPartResult(const TestPartResult& result) override;

 private:
  UnitTestImpl* const unit_test_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
};

// This is the default per thread test part result reporter used in
// UnitTestImpl. This class should only be used by UnitTestImpl.
class DefaultPerThreadTestPartResultReporter
    : public TestPartResultReporterInterface {
 public:
  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
  // Implements the TestPartResultReporterInterface. The implementation just
  // delegates to the current global test part result reporter of *unit_test_.
  void ReportTestPartResult(const TestPartResult& result) override;

 private:
  UnitTestImpl* const unit_test_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
};

// The private implementation of the UnitTest class.  We don't protect
// the methods under a mutex, as this class is not accessible by a
// user and the UnitTest class that delegates work to this class does
// proper locking.
class GTEST_API_ UnitTestImpl {
 public:
  explicit UnitTestImpl(UnitTest* parent);
  virtual ~UnitTestImpl();

  // There are two different ways to register your own TestPartResultReporter.
  // You can register your own repoter to listen either only for test results
  // from the current thread or for results from all threads.
  // By default, each per-thread test result repoter just passes a new
  // TestPartResult to the global test result reporter, which registers the
  // test part result for the currently running test.

  // Returns the global test part result reporter.
  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();

  // Sets the global test part result reporter.
  void SetGlobalTestPartResultReporter(
      TestPartResultReporterInterface* reporter);

  // Returns the test part result reporter for the current thread.
  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();

  // Sets the test part result reporter for the current thread.
  void SetTestPartResultReporterForCurrentThread(
      TestPartResultReporterInterface* reporter);

  // Gets the number of successful test suites.
  int successful_test_suite_count() const;

  // Gets the number of failed test suites.
  int failed_test_suite_count() const;

  // Gets the number of all test suites.
  int total_test_suite_count() const;

  // Gets the number of all test suites that contain at least one test
  // that should run.
  int test_suite_to_run_count() const;

  // Gets the number of successful tests.
  int successful_test_count() const;

  // Gets the number of skipped tests.
  int skipped_test_count() const;

  // Gets the number of failed tests.
  int failed_test_count() const;

  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

  // Gets the number of disabled tests.
  int disabled_test_count() const;

  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

  // Gets the number of all tests.
  int total_test_count() const;

  // Gets the number of tests that should run.
  int test_to_run_count() const;

  // Gets the time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const { return start_timestamp_; }

  // Gets the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const { return elapsed_time_; }

  // Returns true if and only if the unit test passed (i.e. all test suites
  // passed).
  bool Passed() const { return !Failed(); }

  // Returns true if and only if the unit test failed (i.e. some test suite
  // failed or something outside of all tests failed).
  bool Failed() const {
    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
  }

  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  const TestSuite* GetTestSuite(int i) const {
    const int index = GetElementOr(test_suite_indices_, i, -1);
    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
  }

  //  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  TestSuite* GetMutableSuiteCase(int i) {
    const int index = GetElementOr(test_suite_indices_, i, -1);
    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
  }

  // Provides access to the event listener list.
  TestEventListeners* listeners() { return &listeners_; }

  // Returns the TestResult for the test that's currently running, or
  // the TestResult for the ad hoc test if no test is running.
  TestResult* current_test_result();

  // Returns the TestResult for the ad hoc test.
  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }

  // Sets the OS stack trace getter.
  //
  // Does nothing if the input and the current OS stack trace getter
  // are the same; otherwise, deletes the old getter and makes the
  // input the current getter.
  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);

  // Returns the current OS stack trace getter if it is not NULL;
  // otherwise, creates an OsStackTraceGetter, makes it the current
  // getter, and returns it.
  OsStackTraceGetterInterface* os_stack_trace_getter();

  // Returns the current OS stack trace as an std::string.
  //
  // The maximum number of stack frames to be included is specified by
  // the gtest_stack_trace_depth flag.  The skip_count parameter
  // specifies the number of top frames to be skipped, which doesn't
  // count against the number of frames to be included.
  //
  // For example, if Foo() calls Bar(), which in turn calls
  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;

  // Finds and returns a TestSuite with the given name.  If one doesn't
  // exist, creates one and returns it.
  //
  // Arguments:
  //
  //   test_suite_name: name of the test suite
  //   type_param:      the name of the test's type parameter, or NULL if
  //                    this is not a typed or a type-parameterized test.
  //   set_up_tc:       pointer to the function that sets up the test suite
  //   tear_down_tc:    pointer to the function that tears down the test suite
  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
                          internal::SetUpTestSuiteFunc set_up_tc,
                          internal::TearDownTestSuiteFunc tear_down_tc);

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
                        internal::SetUpTestSuiteFunc set_up_tc,
                        internal::TearDownTestSuiteFunc tear_down_tc) {
    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
  }
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Adds a TestInfo to the unit test.
  //
  // Arguments:
  //
  //   set_up_tc:    pointer to the function that sets up the test suite
  //   tear_down_tc: pointer to the function that tears down the test suite
  //   test_info:    the TestInfo object
  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
                   internal::TearDownTestSuiteFunc tear_down_tc,
                   TestInfo* test_info) {
#if GTEST_HAS_DEATH_TEST
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }
#endif  // GTEST_HAS_DEATH_TEST

    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
                 set_up_tc, tear_down_tc)
        ->AddTestInfo(test_info);
  }

  // Returns ParameterizedTestSuiteRegistry object used to keep track of
  // value-parameterized tests and instantiate and register them.
  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
    return parameterized_test_registry_;
  }

  std::set<std::string>* ignored_parameterized_test_suites() {
    return &ignored_parameterized_test_suites_;
  }

  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of
  // type-parameterized tests and instantiations of them.
  internal::TypeParameterizedTestSuiteRegistry&
  type_parameterized_test_registry() {
    return type_parameterized_test_registry_;
  }

  // Sets the TestSuite object for the test that's currently running.
  void set_current_test_suite(TestSuite* a_current_test_suite) {
    current_test_suite_ = a_current_test_suite;
  }

  // Sets the TestInfo object for the test that's currently running.  If
  // current_test_info is NULL, the assertion results will be stored in
  // ad_hoc_test_result_.
  void set_current_test_info(TestInfo* a_current_test_info) {
    current_test_info_ = a_current_test_info;
  }

  // Registers all parameterized tests defined using TEST_P and
  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
  // combination. This method can be called more then once; it has guards
  // protecting from registering the tests more then once.  If
  // value-parameterized tests are disabled, RegisterParameterizedTests is
  // present but does nothing.
  void RegisterParameterizedTests();

  // Runs all tests in this UnitTest object, prints the result, and
  // returns true if all tests are successful.  If any exception is
  // thrown during a test, this test is considered to be failed, but
  // the rest of the tests will still be run.
  bool RunAllTests();

  // Clears the results of all tests, except the ad hoc tests.
  void ClearNonAdHocTestResult() {
    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
  }

  // Clears the results of ad-hoc test assertions.
  void ClearAdHocTestResult() {
    ad_hoc_test_result_.Clear();
  }

  // Adds a TestProperty to the current TestResult object when invoked in a
  // context of a test or a test suite, or to the global property set. If the
  // result already contains a property with the same key, the value will be
  // updated.
  void RecordProperty(const TestProperty& test_property);

  enum ReactionToSharding {
    HONOR_SHARDING_PROTOCOL,
    IGNORE_SHARDING_PROTOCOL
  };

  // Matches the full name of each test against the user-specified
  // filter to decide whether the test should run, then records the
  // result in each TestSuite and TestInfo object.
  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
  // based on sharding variables in the environment.
  // Returns the number of tests that should run.
  int FilterTests(ReactionToSharding shard_tests);

  // Prints the names of the tests matching the user-specified filter flag.
  void ListTestsMatchingFilter();

  const TestSuite* current_test_suite() const { return current_test_suite_; }
  TestInfo* current_test_info() { return current_test_info_; }
  const TestInfo* current_test_info() const { return current_test_info_; }

  // Returns the vector of environments that need to be set-up/torn-down
  // before/after the tests are run.
  std::vector<Environment*>& environments() { return environments_; }

  // Getters for the per-thread Google Test trace stack.
  std::vector<TraceInfo>& gtest_trace_stack() {
    return *(gtest_trace_stack_.pointer());
  }
  const std::vector<TraceInfo>& gtest_trace_stack() const {
    return gtest_trace_stack_.get();
  }

#if GTEST_HAS_DEATH_TEST
  void InitDeathTestSubprocessControlInfo() {
    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  }
  // Returns a pointer to the parsed --gtest_internal_run_death_test
  // flag, or NULL if that flag was not specified.
  // This information is useful only in a death test child process.
  // Must not be called before a call to InitGoogleTest.
  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
    return internal_run_death_test_flag_.get();
  }

  // Returns a pointer to the current death test factory.
  internal::DeathTestFactory* death_test_factory() {
    return death_test_factory_.get();
  }

  void SuppressTestEventsIfInSubprocess();

  friend class ReplaceDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST

  // Initializes the event listener performing XML output as specified by
  // UnitTestOptions. Must not be called before InitGoogleTest.
  void ConfigureXmlOutput();

#if GTEST_CAN_STREAM_RESULTS_
  // Initializes the event listener for streaming test results to a socket.
  // Must not be called before InitGoogleTest.
  void ConfigureStreamingOutput();
#endif

  // Performs initialization dependent upon flag values obtained in
  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
  // this function is also called from RunAllTests.  Since this function can be
  // called more than once, it has to be idempotent.
  void PostFlagParsingInit();

  // Gets the random seed used at the start of the current test iteration.
  int random_seed() const { return random_seed_; }

  // Gets the random number generator.
  internal::Random* random() { return &random_; }

  // Shuffles all test suites, and the tests within each test suite,
  // making sure that death tests are still run first.
  void ShuffleTests();

  // Restores the test suites and tests to their order before the first shuffle.
  void UnshuffleTests();

  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
  // UnitTest::Run() starts.
  bool catch_exceptions() const { return catch_exceptions_; }

 private:
  friend class ::testing::UnitTest;

  // Used by UnitTest::Run() to capture the state of
  // GTEST_FLAG(catch_exceptions) at the moment it starts.
  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }

  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

  // The working directory when the first TEST() or TEST_F() was
  // executed.
  internal::FilePath original_working_dir_;

  // The default test part result reporters.
  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
  DefaultPerThreadTestPartResultReporter
      default_per_thread_test_part_result_reporter_;

  // Points to (but doesn't own) the global test part result reporter.
  TestPartResultReporterInterface* global_test_part_result_repoter_;

  // Protects read and write access to global_test_part_result_reporter_.
  internal::Mutex global_test_part_result_reporter_mutex_;

  // Points to (but doesn't own) the per-thread test part result reporter.
  internal::ThreadLocal<TestPartResultReporterInterface*>
      per_thread_test_part_result_reporter_;

  // The vector of environments that need to be set-up/torn-down
  // before/after the tests are run.
  std::vector<Environment*> environments_;

  // The vector of TestSuites in their original order.  It owns the
  // elements in the vector.
  std::vector<TestSuite*> test_suites_;

  // Provides a level of indirection for the test suite list to allow
  // easy shuffling and restoring the test suite order.  The i-th
  // element of this vector is the index of the i-th test suite in the
  // shuffled order.
  std::vector<int> test_suite_indices_;

  // ParameterizedTestRegistry object used to register value-parameterized
  // tests.
  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
  internal::TypeParameterizedTestSuiteRegistry
      type_parameterized_test_registry_;

  // The set holding the name of parameterized
  // test suites that may go uninstantiated.
  std::set<std::string> ignored_parameterized_test_suites_;

  // Indicates whether RegisterParameterizedTests() has been called already.
  bool parameterized_tests_registered_;

  // Index of the last death test suite registered.  Initially -1.
  int last_death_test_suite_;

  // This points to the TestSuite for the currently running test.  It
  // changes as Google Test goes through one test suite after another.
  // When no test is running, this is set to NULL and Google Test
  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
  TestSuite* current_test_suite_;

  // This points to the TestInfo for the currently running test.  It
  // changes as Google Test goes through one test after another.  When
  // no test is running, this is set to NULL and Google Test stores
  // assertion results in ad_hoc_test_result_.  Initially NULL.
  TestInfo* current_test_info_;

  // Normally, a user only writes assertions inside a TEST or TEST_F,
  // or inside a function called by a TEST or TEST_F.  Since Google
  // Test keeps track of which test is current running, it can
  // associate such an assertion with the test it belongs to.
  //
  // If an assertion is encountered when no TEST or TEST_F is running,
  // Google Test attributes the assertion result to an imaginary "ad hoc"
  // test, and records the result in ad_hoc_test_result_.
  TestResult ad_hoc_test_result_;

  // The list of event listeners that can be used to track events inside
  // Google Test.
  TestEventListeners listeners_;

  // The OS stack trace getter.  Will be deleted when the UnitTest
  // object is destructed.  By default, an OsStackTraceGetter is used,
  // but the user can set this field to use a custom getter if that is
  // desired.
  OsStackTraceGetterInterface* os_stack_trace_getter_;

  // True if and only if PostFlagParsingInit() has been called.
  bool post_flag_parse_init_performed_;

  // The random number seed used at the beginning of the test run.
  int random_seed_;

  // Our random number generator.
  internal::Random random_;

  // The time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp_;

  // How long the test took to run, in milliseconds.
  TimeInMillis elapsed_time_;

#if GTEST_HAS_DEATH_TEST
  // The decomposed components of the gtest_internal_run_death_test flag,
  // parsed when RUN_ALL_TESTS is called.
  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
#endif  // GTEST_HAS_DEATH_TEST

  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;

  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
  // starts.
  bool catch_exceptions_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
};  // class UnitTestImpl

// Convenience function for accessing the global UnitTest
// implementation object.
inline UnitTestImpl* GetUnitTestImpl() {
  return UnitTest::GetInstance()->impl();
}

#if GTEST_USES_SIMPLE_RE

// Internal helper functions for implementing the simple regular
// expression matcher.
GTEST_API_ bool IsInSet(char ch, const char* str);
GTEST_API_ bool IsAsciiDigit(char ch);
GTEST_API_ bool IsAsciiPunct(char ch);
GTEST_API_ bool IsRepeat(char ch);
GTEST_API_ bool IsAsciiWhiteSpace(char ch);
GTEST_API_ bool IsAsciiWordChar(char ch);
GTEST_API_ bool IsValidEscape(char ch);
GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
GTEST_API_ bool ValidateRegex(const char* regex);
GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
GTEST_API_ bool MatchRepetitionAndRegexAtHead(
    bool escaped, char ch, char repeat, const char* regex, const char* str);
GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);

#endif  // GTEST_USES_SIMPLE_RE

// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);

#if GTEST_HAS_DEATH_TEST

// Returns the message describing the last system error, regardless of the
// platform.
GTEST_API_ std::string GetLastErrnoDescription();

// Attempts to parse a string into a positive integer pointed to by the
// number parameter.  Returns true if that is possible.
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
// it here.
template <typename Integer>
bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
  // Fail fast if the given string does not begin with a digit;
  // this bypasses strtoXXX's "optional leading whitespace and plus
  // or minus sign" semantics, which are undesirable here.
  if (str.empty() || !IsDigit(str[0])) {
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.
  using BiggestConvertible = unsigned long long;  // NOLINT

  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
  const bool parse_success = *end == '\0' && errno == 0;

  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));

  const Integer result = static_cast<Integer>(parsed);
  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
    *number = result;
    return true;
  }
  return false;
}
#endif  // GTEST_HAS_DEATH_TEST

// TestResult contains some private methods that should be hidden from
// Google Test user but are required for testing. This class allow our tests
// to access them.
//
// This class is supplied only for the purpose of testing Google Test's own
// constructs. Do not use it in user tests, either directly or indirectly.
class TestResultAccessor {
 public:
  static void RecordProperty(TestResult* test_result,
                             const std::string& xml_element,
                             const TestProperty& property) {
    test_result->RecordProperty(xml_element, property);
  }

  static void ClearTestPartResults(TestResult* test_result) {
    test_result->ClearTestPartResults();
  }

  static const std::vector<testing::TestPartResult>& test_part_results(
      const TestResult& test_result) {
    return test_result.test_part_results();
  }
};

#if GTEST_CAN_STREAM_RESULTS_

// Streams test results to the given port on the given host machine.
class StreamingListener : public EmptyTestEventListener {
 public:
  // Abstract base class for writing strings to a socket.
  class AbstractSocketWriter {
   public:
    virtual ~AbstractSocketWriter() {}

    // Sends a string to the socket.
    virtual void Send(const std::string& message) = 0;

    // Closes the socket.
    virtual void CloseConnection() {}

    // Sends a string and a newline to the socket.
    void SendLn(const std::string& message) { Send(message + "\n"); }
  };

  // Concrete class for actually writing strings to a socket.
  class SocketWriter : public AbstractSocketWriter {
   public:
    SocketWriter(const std::string& host, const std::string& port)
        : sockfd_(-1), host_name_(host), port_num_(port) {
      MakeConnection();
    }

    ~SocketWriter() override {
      if (sockfd_ != -1)
        CloseConnection();
    }

    // Sends a string to the socket.
    void Send(const std::string& message) override {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

      const auto len = static_cast<size_t>(message.length());
      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

   private:
    // Creates a client socket and connects to the server.
    void MakeConnection();

    // Closes the socket.
    void CloseConnection() override {
      GTEST_CHECK_(sockfd_ != -1)
          << "CloseConnection() can be called only when there is a connection.";

      close(sockfd_);
      sockfd_ = -1;
    }

    int sockfd_;  // socket file descriptor
    const std::string host_name_;
    const std::string port_num_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
  };  // class SocketWriter

  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
  static std::string UrlEncode(const char* str);

  StreamingListener(const std::string& host, const std::string& port)
      : socket_writer_(new SocketWriter(host, port)) {
    Start();
  }

  explicit StreamingListener(AbstractSocketWriter* socket_writer)
      : socket_writer_(socket_writer) { Start(); }

  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
    SendLn("event=TestProgramStart");
  }

  void OnTestProgramEnd(const UnitTest& unit_test) override {
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

    // Notify the streaming server to stop.
    socket_writer_->CloseConnection();
  }

  void OnTestIterationStart(const UnitTest& /* unit_test */,
                            int iteration) override {
    SendLn("event=TestIterationStart&iteration=" +
           StreamableToString(iteration));
  }

  void OnTestIterationEnd(const UnitTest& unit_test,
                          int /* iteration */) override {
    SendLn("event=TestIterationEnd&passed=" +
           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
           StreamableToString(unit_test.elapsed_time()) + "ms");
  }

  // Note that "event=TestCaseStart" is a wire format and has to remain
  // "case" for compatibility
  void OnTestCaseStart(const TestCase& test_case) override {
    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
  }

  // Note that "event=TestCaseEnd" is a wire format and has to remain
  // "case" for compatibility
  void OnTestCaseEnd(const TestCase& test_case) override {
    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
           "ms");
  }

  void OnTestStart(const TestInfo& test_info) override {
    SendLn(std::string("event=TestStart&name=") + test_info.name());
  }

  void OnTestEnd(const TestInfo& test_info) override {
    SendLn("event=TestEnd&passed=" +
           FormatBool((test_info.result())->Passed()) +
           "&elapsed_time=" +
           StreamableToString((test_info.result())->elapsed_time()) + "ms");
  }

  void OnTestPartResult(const TestPartResult& test_part_result) override {
    const char* file_name = test_part_result.file_name();
    if (file_name == nullptr) file_name = "";
    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
           "&line=" + StreamableToString(test_part_result.line_number()) +
           "&message=" + UrlEncode(test_part_result.message()));
  }

 private:
  // Sends the given message and a newline to the socket.
  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }

  // Called at the start of streaming to notify the receiver what
  // protocol we are using.
  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }

  std::string FormatBool(bool value) { return value ? "1" : "0"; }

  const std::unique_ptr<AbstractSocketWriter> socket_writer_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
};  // class StreamingListener

#endif  // GTEST_CAN_STREAM_RESULTS_

}  // namespace internal
}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_

#if GTEST_OS_WINDOWS
# define vsnprintf _vsnprintf
#endif  // GTEST_OS_WINDOWS

#if GTEST_OS_MAC
#ifndef GTEST_OS_IOS
#include <crt_externs.h>
#endif
#endif

#if GTEST_HAS_ABSL
#include "absl/debugging/failure_signal_handler.h"
#include "absl/debugging/stacktrace.h"
#include "absl/debugging/symbolize.h"
#include "absl/strings/str_cat.h"
#endif  // GTEST_HAS_ABSL

namespace testing {

using internal::CountIf;
using internal::ForEach;
using internal::GetElementOr;
using internal::Shuffle;

// Constants.

// A test whose test suite name or test name matches this filter is
// disabled and not run.
static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";

// A test suite whose name matches this filter is considered a death
// test suite and will be run before test suites whose name doesn't
// match this filter.
static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";

// A test filter that matches everything.
static const char kUniversalFilter[] = "*";

// The default output format.
static const char kDefaultOutputFormat[] = "xml";
// The default output file.
static const char kDefaultOutputFile[] = "test_detail";

// The environment variable name for the test shard index.
static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
// The environment variable name for the total number of test shards.
static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
// The environment variable name for the test shard status file.
static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";

namespace internal {

// The text used in failure messages to indicate the start of the
// stack trace.
const char kStackTraceMarker[] = "\nStack trace:\n";

// g_help_flag is true if and only if the --help flag or an equivalent form
// is specified on the command line.
bool g_help_flag = false;

// Utilty function to Open File for Writing
static FILE* OpenFileForWriting(const std::string& output_file) {
  FILE* fileout = nullptr;
  FilePath output_file_path(output_file);
  FilePath output_dir(output_file_path.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    fileout = posix::FOpen(output_file.c_str(), "w");
  }
  if (fileout == nullptr) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
  }
  return fileout;
}

}  // namespace internal

// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
// environment variable.
static const char* GetDefaultFilter() {
  const char* const testbridge_test_only =
      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  if (testbridge_test_only != nullptr) {
    return testbridge_test_only;
  }
  return kUniversalFilter;
}

// Bazel passes in the argument to '--test_runner_fail_fast' via the
// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
static bool GetDefaultFailFast() {
  const char* const testbridge_test_runner_fail_fast =
      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
  if (testbridge_test_runner_fail_fast != nullptr) {
    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
  }
  return false;
}

GTEST_DEFINE_bool_(
    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
    "True if and only if a test failure should stop further test execution.");

GTEST_DEFINE_bool_(
    also_run_disabled_tests,
    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
    "Run disabled tests too, in addition to the tests normally being run.");

GTEST_DEFINE_bool_(
    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
    "True if and only if a failed assertion should be a debugger "
    "break-point.");

GTEST_DEFINE_bool_(catch_exceptions,
                   internal::BoolFromGTestEnv("catch_exceptions", true),
                   "True if and only if " GTEST_NAME_
                   " should catch exceptions and treat them as test failures.");

GTEST_DEFINE_string_(
    color,
    internal::StringFromGTestEnv("color", "auto"),
    "Whether to use colors in the output.  Valid values: yes, no, "
    "and auto.  'auto' means to use colors if the output is "
    "being sent to a terminal and the TERM environment variable "
    "is set to a terminal type that supports colors.");

GTEST_DEFINE_string_(
    filter,
    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
    "A colon-separated list of glob (not regex) patterns "
    "for filtering the tests to run, optionally followed by a "
    "'-' and a : separated list of negative patterns (tests to "
    "exclude).  A test is run if it matches one of the positive "
    "patterns and does not match any of the negative patterns.");

GTEST_DEFINE_bool_(
    install_failure_signal_handler,
    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
    "If true and supported on the current platform, " GTEST_NAME_ " should "
    "install a signal handler that dumps debugging information when fatal "
    "signals are raised.");

GTEST_DEFINE_bool_(list_tests, false,
                   "List all tests without running them.");

// The net priority order after flag processing is thus:
//   --gtest_output command line flag
//   GTEST_OUTPUT environment variable
//   XML_OUTPUT_FILE environment variable
//   ''
GTEST_DEFINE_string_(
    output,
    internal::StringFromGTestEnv("output",
      internal::OutputFlagAlsoCheckEnvVar().c_str()),
    "A format (defaults to \"xml\" but can be specified to be \"json\"), "
    "optionally followed by a colon and an output file name or directory. "
    "A directory is indicated by a trailing pathname separator. "
    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
    "If a directory is specified, output files will be created "
    "within that directory, with file-names based on the test "
    "executable's name and, if necessary, made unique by adding "
    "digits.");

GTEST_DEFINE_bool_(
    brief, internal::BoolFromGTestEnv("brief", false),
    "True if only test failures should be displayed in text output.");

GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
                   "True if and only if " GTEST_NAME_
                   " should display elapsed time in text output.");

GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
                   "True if and only if " GTEST_NAME_
                   " prints UTF8 characters as text.");

GTEST_DEFINE_int32_(
    random_seed,
    internal::Int32FromGTestEnv("random_seed", 0),
    "Random number seed to use when shuffling test orders.  Must be in range "
    "[1, 99999], or 0 to use a seed based on the current time.");

GTEST_DEFINE_int32_(
    repeat,
    internal::Int32FromGTestEnv("repeat", 1),
    "How many times to repeat each test.  Specify a negative number "
    "for repeating forever.  Useful for shaking out flaky tests.");

GTEST_DEFINE_bool_(show_internal_stack_frames, false,
                   "True if and only if " GTEST_NAME_
                   " should include internal stack frames when "
                   "printing test failure stack traces.");

GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
                   "True if and only if " GTEST_NAME_
                   " should randomize tests' order on every run.");

GTEST_DEFINE_int32_(
    stack_trace_depth,
    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
    "The maximum number of stack frames to print when an "
    "assertion fails.  The valid range is 0 through 100, inclusive.");

GTEST_DEFINE_string_(
    stream_result_to,
    internal::StringFromGTestEnv("stream_result_to", ""),
    "This flag specifies the host name and the port number on which to stream "
    "test results. Example: \"localhost:555\". The flag is effective only on "
    "Linux.");

GTEST_DEFINE_bool_(
    throw_on_failure,
    internal::BoolFromGTestEnv("throw_on_failure", false),
    "When this flag is specified, a failed assertion will throw an exception "
    "if exceptions are enabled or exit the program with a non-zero code "
    "otherwise. For use with an external test framework.");

#if GTEST_USE_OWN_FLAGFILE_FLAG_
GTEST_DEFINE_string_(
    flagfile,
    internal::StringFromGTestEnv("flagfile", ""),
    "This flag specifies the flagfile to read command-line flags from.");
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_

namespace internal {

// Generates a random number from [0, range), using a Linear
// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
// than kMaxRange.
uint32_t Random::Generate(uint32_t range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)
      << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// GTestIsInitialized() returns true if and only if the user has initialized
// Google Test.  Useful for catching the user mistake of not initializing
// Google Test before calling RUN_ALL_TESTS().
static bool GTestIsInitialized() { return GetArgvs().size() > 0; }

// Iterates over a vector of TestSuites, keeping a running sum of the
// results of calling a given int-returning method on each.
// Returns the sum.
static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
                                int (TestSuite::*method)() const) {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

// Returns true if and only if the test suite passed.
static bool TestSuitePassed(const TestSuite* test_suite) {
  return test_suite->should_run() && test_suite->Passed();
}

// Returns true if and only if the test suite failed.
static bool TestSuiteFailed(const TestSuite* test_suite) {
  return test_suite->should_run() && test_suite->Failed();
}

// Returns true if and only if test_suite contains at least one test that
// should run.
static bool ShouldRunTestSuite(const TestSuite* test_suite) {
  return test_suite->should_run();
}

// AssertHelper constructor.
AssertHelper::AssertHelper(TestPartResult::Type type,
                           const char* file,
                           int line,
                           const char* message)
    : data_(new AssertHelperData(type, file, line, message)) {
}

AssertHelper::~AssertHelper() {
  delete data_;
}

// Message assignment, for assertion streaming support.
void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->
    AddTestPartResult(data_->type, data_->file, data_->line,
                      AppendUserMessage(data_->message, message),
                      UnitTest::GetInstance()->impl()
                      ->CurrentOsStackTraceExceptTop(1)
                      // Skips the stack frame for this function itself.
                      );  // NOLINT
}

namespace {

// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
// to creates test cases for it, a syntetic test case is
// inserted to report ether an error or a log message.
//
// This configuration bit will likely be removed at some point.
constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;

// A test that fails at a given file/line location with a given message.
class FailureTest : public Test {
 public:
  explicit FailureTest(const CodeLocation& loc, std::string error_message,
                       bool as_error)
      : loc_(loc),
        error_message_(std::move(error_message)),
        as_error_(as_error) {}

  void TestBody() override {
    if (as_error_) {
      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
                   loc_.line, "") = Message() << error_message_;
    } else {
      std::cout << error_message_ << std::endl;
    }
  }

 private:
  const CodeLocation loc_;
  const std::string error_message_;
  const bool as_error_;
};


}  // namespace

std::set<std::string>* GetIgnoredParameterizedTestSuites() {
  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
}

// Add a given test_suit to the list of them allow to go un-instantiated.
MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
  GetIgnoredParameterizedTestSuites()->insert(test_suite);
}

// If this parameterized test suite has no instantiations (and that
// has not been marked as okay), emit a test case reporting that.
void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
                             bool has_test_p) {
  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  if (ignored.find(name) != ignored.end()) return;

  const char kMissingInstantiation[] =  //
      " is defined via TEST_P, but never instantiated. None of the test cases "
      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
      "ones provided expand to nothing."
      "\n\n"
      "Ideally, TEST_P definitions should only ever be included as part of "
      "binaries that intend to use them. (As opposed to, for example, being "
      "placed in a library that may be linked in to get other utilities.)";

  const char kMissingTestCase[] =  //
      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
      "defined via TEST_P . No test cases will run."
      "\n\n"
      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
      "code that always depend on code that provides TEST_P. Failing to do "
      "so is often an indication of dead code, e.g. the last TEST_P was "
      "removed but the rest got left behind.";

  std::string message =
      "Parameterized test suite " + name +
      (has_test_p ? kMissingInstantiation : kMissingTestCase) +
      "\n\n"
      "To suppress this error for this test suite, insert the following line "
      "(in a non-header) in the namespace it is defined in:"
      "\n\n"
      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";

  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
  RegisterTest(  //
      "GoogleTestVerification", full_name.c_str(),
      nullptr,  // No type parameter.
      nullptr,  // No value parameter.
      location.file.c_str(), location.line, [message, location] {
        return new FailureTest(location, message,
                               kErrorOnUninstantiatedParameterizedTest);
      });
}

void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
                                        CodeLocation code_location) {
  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
      test_suite_name, code_location);
}

void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
  GetUnitTestImpl()
      ->type_parameterized_test_registry()
      .RegisterInstantiation(case_name);
}

void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
    const char* test_suite_name, CodeLocation code_location) {
  suites_.emplace(std::string(test_suite_name),
                 TypeParameterizedTestSuiteInfo(code_location));
}

void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
        const char* test_suite_name) {
  auto it = suites_.find(std::string(test_suite_name));
  if (it != suites_.end()) {
    it->second.instantiated = true;
  } else {
    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
                      << test_suite_name << "'";
  }
}

void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  for (const auto& testcase : suites_) {
    if (testcase.second.instantiated) continue;
    if (ignored.find(testcase.first) != ignored.end()) continue;

    std::string message =
        "Type parameterized test suite " + testcase.first +
        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
        "\n\n"
        "Ideally, TYPED_TEST_P definitions should only ever be included as "
        "part of binaries that intend to use them. (As opposed to, for "
        "example, being placed in a library that may be linked in to get other "
        "utilities.)"
        "\n\n"
        "To suppress this error for this test suite, insert the following line "
        "(in a non-header) in the namespace it is defined in:"
        "\n\n"
        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
        testcase.first + ");";

    std::string full_name =
        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
    RegisterTest(  //
        "GoogleTestVerification", full_name.c_str(),
        nullptr,  // No type parameter.
        nullptr,  // No value parameter.
        testcase.second.code_location.file.c_str(),
        testcase.second.code_location.line, [message, testcase] {
          return new FailureTest(testcase.second.code_location, message,
                                 kErrorOnUninstantiatedTypeParameterizedTest);
        });
  }
}

// A copy of all command line arguments.  Set by InitGoogleTest().
static ::std::vector<std::string> g_argvs;

::std::vector<std::string> GetArgvs() {
#if defined(GTEST_CUSTOM_GET_ARGVS_)
  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  // ::string. This code converts it to the appropriate type.
  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  return ::std::vector<std::string>(custom.begin(), custom.end());
#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  return g_argvs;
#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
}

// Returns the current application's name, removing directory path if that
// is present.
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS || GTEST_OS_OS2
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Functions for processing the gtest_output flag.

// Returns the output format, or "" for normal printed output.
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == nullptr)
             ? std::string(gtest_output_flag)
             : std::string(gtest_output_flag,
                           static_cast<size_t>(colon - gtest_output_flag));
}

// Returns the name of the requested output file, or the default if none
// was explicitly specified.
std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();

  std::string format = GetOutputFormat();
  if (format.empty())
    format = std::string(kDefaultOutputFormat);

  const char* const colon = strchr(gtest_output_flag, ':');
  if (colon == nullptr)
    return internal::FilePath::MakeFileName(
        internal::FilePath(
            UnitTest::GetInstance()->original_working_dir()),
        internal::FilePath(kDefaultOutputFile), 0,
        format.c_str()).string();

  internal::FilePath output_name(colon + 1);
  if (!output_name.IsAbsolutePath())
    output_name = internal::FilePath::ConcatPaths(
        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
        internal::FilePath(colon + 1));

  if (!output_name.IsDirectory())
    return output_name.string();

  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
      output_name, internal::GetCurrentExecutableName(),
      GetOutputFormat().c_str()));
  return result.string();
}

// Returns true if and only if the wildcard pattern matches the string. Each
// pattern consists of regular characters, single-character wildcards (?), and
// multi-character wildcards (*).
//
// This function implements a linear-time string globbing algorithm based on
// https://research.swtch.com/glob.
static bool PatternMatchesString(const std::string& name_str,
                                 const char* pattern, const char* pattern_end) {
  const char* name = name_str.c_str();
  const char* const name_begin = name;
  const char* const name_end = name + name_str.size();

  const char* pattern_next = pattern;
  const char* name_next = name;

  while (pattern < pattern_end || name < name_end) {
    if (pattern < pattern_end) {
      switch (*pattern) {
        default:  // Match an ordinary character.
          if (name < name_end && *name == *pattern) {
            ++pattern;
            ++name;
            continue;
          }
          break;
        case '?':  // Match any single character.
          if (name < name_end) {
            ++pattern;
            ++name;
            continue;
          }
          break;
        case '*':
          // Match zero or more characters. Start by skipping over the wildcard
          // and matching zero characters from name. If that fails, restart and
          // match one more character than the last attempt.
          pattern_next = pattern;
          name_next = name + 1;
          ++pattern;
          continue;
      }
    }
    // Failed to match a character. Restart if possible.
    if (name_begin < name_next && name_next <= name_end) {
      pattern = pattern_next;
      name = name_next;
      continue;
    }
    return false;
  }
  return true;
}

bool UnitTestOptions::MatchesFilter(const std::string& name_str,
                                    const char* filter) {
  // The filter is a list of patterns separated by colons (:).
  const char* pattern = filter;
  while (true) {
    // Find the bounds of this pattern.
    const char* const next_sep = strchr(pattern, ':');
    const char* const pattern_end =
        next_sep != nullptr ? next_sep : pattern + strlen(pattern);

    // Check if this pattern matches name_str.
    if (PatternMatchesString(name_str, pattern, pattern_end)) {
      return true;
    }

    // Give up on this pattern. However, if we found a pattern separator (:),
    // advance to the next pattern (skipping over the separator) and restart.
    if (next_sep == nullptr) {
      return false;
    }
    pattern = next_sep + 1;
  }
  return true;
}

// Returns true if and only if the user-specified filter matches the test
// suite name and the test name.
bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
                                        const std::string& test_name) {
  const std::string& full_name = test_suite_name + "." + test_name.c_str();

  // Split --gtest_filter at '-', if there is one, to separate into
  // positive filter and negative filter portions
  const char* const p = GTEST_FLAG(filter).c_str();
  const char* const dash = strchr(p, '-');
  std::string positive;
  std::string negative;
  if (dash == nullptr) {
    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
    negative = "";
  } else {
    positive = std::string(p, dash);   // Everything up to the dash
    negative = std::string(dash + 1);  // Everything after the dash
    if (positive.empty()) {
      // Treat '-test1' as the same as '*-test1'
      positive = kUniversalFilter;
    }
  }

  // A filter is a colon-separated list of patterns.  It matches a
  // test if any pattern in it matches the test.
  return (MatchesFilter(full_name, positive.c_str()) &&
          !MatchesFilter(full_name, negative.c_str()));
}

#if GTEST_HAS_SEH
// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
// This function is useful as an __except condition.
int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
  // Google Test should handle a SEH exception if:
  //   1. the user wants it to, AND
  //   2. this is not a breakpoint exception, AND
  //   3. this is not a C++ exception (VC++ implements them via SEH,
  //      apparently).
  //
  // SEH exception code for C++ exceptions.
  // (see http://support.microsoft.com/kb/185294 for more information).
  const DWORD kCxxExceptionCode = 0xe06d7363;

  bool should_handle = true;

  if (!GTEST_FLAG(catch_exceptions))
    should_handle = false;
  else if (exception_code == EXCEPTION_BREAKPOINT)
    should_handle = false;
  else if (exception_code == kCxxExceptionCode)
    should_handle = false;

  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
}
#endif  // GTEST_HAS_SEH

}  // namespace internal

// The c'tor sets this object as the test part result reporter used by
// Google Test.  The 'result' parameter specifies where to report the
// results. Intercepts only failures from the current thread.
ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
    TestPartResultArray* result)
    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
      result_(result) {
  Init();
}

// The c'tor sets this object as the test part result reporter used by
// Google Test.  The 'result' parameter specifies where to report the
// results.
ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
    InterceptMode intercept_mode, TestPartResultArray* result)
    : intercept_mode_(intercept_mode),
      result_(result) {
  Init();
}

void ScopedFakeTestPartResultReporter::Init() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    old_reporter_ = impl->GetGlobalTestPartResultReporter();
    impl->SetGlobalTestPartResultReporter(this);
  } else {
    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
    impl->SetTestPartResultReporterForCurrentThread(this);
  }
}

// The d'tor restores the test part result reporter used by Google Test
// before.
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    impl->SetGlobalTestPartResultReporter(old_reporter_);
  } else {
    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
  }
}

// Increments the test part result count and remembers the result.
// This method is from the TestPartResultReporterInterface interface.
void ScopedFakeTestPartResultReporter::ReportTestPartResult(
    const TestPartResult& result) {
  result_->Append(result);
}

namespace internal {

// Returns the type ID of ::testing::Test.  We should always call this
// instead of GetTypeId< ::testing::Test>() to get the type ID of
// testing::Test.  This is to work around a suspected linker bug when
// using Google Test as a framework on Mac OS X.  The bug causes
// GetTypeId< ::testing::Test>() to return different values depending
// on whether the call is from the Google Test framework itself or
// from user test code.  GetTestTypeId() is guaranteed to always
// return the same value, as it always calls GetTypeId<>() from the
// gtest.cc, which is within the Google Test framework.
TypeId GetTestTypeId() {
  return GetTypeId<Test>();
}

// The value of GetTestTypeId() as seen from within the Google Test
// library.  This is solely for testing GetTestTypeId().
extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();

// This predicate-formatter checks that 'results' contains a test part
// failure of the given type and that the failure message contains the
// given substring.
static AssertionResult HasOneFailure(const char* /* results_expr */,
                                     const char* /* type_expr */,
                                     const char* /* substr_expr */,
                                     const TestPartResultArray& results,
                                     TestPartResult::Type type,
                                     const std::string& substr) {
  const std::string expected(type == TestPartResult::kFatalFailure ?
                        "1 fatal failure" :
                        "1 non-fatal failure");
  Message msg;
  if (results.size() != 1) {
    msg << "Expected: " << expected << "\n"
        << "  Actual: " << results.size() << " failures";
    for (int i = 0; i < results.size(); i++) {
      msg << "\n" << results.GetTestPartResult(i);
    }
    return AssertionFailure() << msg;
  }

  const TestPartResult& r = results.GetTestPartResult(0);
  if (r.type() != type) {
    return AssertionFailure() << "Expected: " << expected << "\n"
                              << "  Actual:\n"
                              << r;
  }

  if (strstr(r.message(), substr.c_str()) == nullptr) {
    return AssertionFailure() << "Expected: " << expected << " containing \""
                              << substr << "\"\n"
                              << "  Actual:\n"
                              << r;
  }

  return AssertionSuccess();
}

// The constructor of SingleFailureChecker remembers where to look up
// test part results, what type of failure we expect, and what
// substring the failure message should contain.
SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
                                           TestPartResult::Type type,
                                           const std::string& substr)
    : results_(results), type_(type), substr_(substr) {}

// The destructor of SingleFailureChecker verifies that the given
// TestPartResultArray contains exactly one failure that has the given
// type and contains the given substring.  If that's not the case, a
// non-fatal failure will be generated.
SingleFailureChecker::~SingleFailureChecker() {
  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
}

DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
    UnitTestImpl* unit_test) : unit_test_(unit_test) {}

void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
    const TestPartResult& result) {
  unit_test_->current_test_result()->AddTestPartResult(result);
  unit_test_->listeners()->repeater()->OnTestPartResult(result);
}

DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
    UnitTestImpl* unit_test) : unit_test_(unit_test) {}

void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
    const TestPartResult& result) {
  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
}

// Returns the global test part result reporter.
TestPartResultReporterInterface*
UnitTestImpl::GetGlobalTestPartResultReporter() {
  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
  return global_test_part_result_repoter_;
}

// Sets the global test part result reporter.
void UnitTestImpl::SetGlobalTestPartResultReporter(
    TestPartResultReporterInterface* reporter) {
  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
  global_test_part_result_repoter_ = reporter;
}

// Returns the test part result reporter for the current thread.
TestPartResultReporterInterface*
UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
  return per_thread_test_part_result_reporter_.get();
}

// Sets the test part result reporter for the current thread.
void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
    TestPartResultReporterInterface* reporter) {
  per_thread_test_part_result_reporter_.set(reporter);
}

// Gets the number of successful test suites.
int UnitTestImpl::successful_test_suite_count() const {
  return CountIf(test_suites_, TestSuitePassed);
}

// Gets the number of failed test suites.
int UnitTestImpl::failed_test_suite_count() const {
  return CountIf(test_suites_, TestSuiteFailed);
}

// Gets the number of all test suites.
int UnitTestImpl::total_test_suite_count() const {
  return static_cast<int>(test_suites_.size());
}

// Gets the number of all test suites that contain at least one test
// that should run.
int UnitTestImpl::test_suite_to_run_count() const {
  return CountIf(test_suites_, ShouldRunTestSuite);
}

// Gets the number of successful tests.
int UnitTestImpl::successful_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
}

// Gets the number of skipped tests.
int UnitTestImpl::skipped_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
}

// Gets the number of failed tests.
int UnitTestImpl::failed_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
}

// Gets the number of disabled tests that will be reported in the XML report.
int UnitTestImpl::reportable_disabled_test_count() const {
  return SumOverTestSuiteList(test_suites_,
                              &TestSuite::reportable_disabled_test_count);
}

// Gets the number of disabled tests.
int UnitTestImpl::disabled_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
}

// Gets the number of tests to be printed in the XML report.
int UnitTestImpl::reportable_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
}

// Gets the number of all tests.
int UnitTestImpl::total_test_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
}

// Gets the number of tests that should run.
int UnitTestImpl::test_to_run_count() const {
  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
}

// Returns the current OS stack trace as an std::string.
//
// The maximum number of stack frames to be included is specified by
// the gtest_stack_trace_depth flag.  The skip_count parameter
// specifies the number of top frames to be skipped, which doesn't
// count against the number of frames to be included.
//
// For example, if Foo() calls Bar(), which in turn calls
// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
      skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
      );  // NOLINT
}

// A helper class for measuring elapsed times.
class Timer {
 public:
  Timer() : start_(std::chrono::steady_clock::now()) {}

  // Return time elapsed in milliseconds since the timer was created.
  TimeInMillis Elapsed() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now() - start_)
        .count();
  }

 private:
  std::chrono::steady_clock::time_point start_;
};

// Returns a timestamp as milliseconds since the epoch. Note this time may jump
// around subject to adjustments by the system, to measure elapsed time use
// Timer instead.
TimeInMillis GetTimeInMillis() {
  return std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::system_clock::now() -
             std::chrono::system_clock::from_time_t(0))
      .count();
}

// Utilities

// class String.

#if GTEST_OS_WINDOWS_MOBILE
// Creates a UTF-16 wide string from the given ANSI string, allocating
// memory using new. The caller is responsible for deleting the return
// value using delete[]. Returns the wide string, or NULL if the
// input is NULL.
LPCWSTR String::AnsiToUtf16(const char* ansi) {
  if (!ansi) return nullptr;
  const int length = strlen(ansi);
  const int unicode_length =
      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
  WCHAR* unicode = new WCHAR[unicode_length + 1];
  MultiByteToWideChar(CP_ACP, 0, ansi, length,
                      unicode, unicode_length);
  unicode[unicode_length] = 0;
  return unicode;
}

// Creates an ANSI string from the given wide string, allocating
// memory using new. The caller is responsible for deleting the return
// value using delete[]. Returns the ANSI string, or NULL if the
// input is NULL.
const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
  if (!utf16_str) return nullptr;
  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
                                              0, nullptr, nullptr);
  char* ansi = new char[ansi_length + 1];
  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
                      nullptr);
  ansi[ansi_length] = 0;
  return ansi;
}

#endif  // GTEST_OS_WINDOWS_MOBILE

// Compares two C strings.  Returns true if and only if they have the same
// content.
//
// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
// C string is considered different to any non-NULL C string,
// including the empty string.
bool String::CStringEquals(const char * lhs, const char * rhs) {
  if (lhs == nullptr) return rhs == nullptr;

  if (rhs == nullptr) return false;

  return strcmp(lhs, rhs) == 0;
}

#if GTEST_HAS_STD_WSTRING

// Converts an array of wide chars to a narrow string using the UTF-8
// encoding, and streams the result to the given Message object.
static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
                                     Message* msg) {
  for (size_t i = 0; i != length; ) {  // NOLINT
    if (wstr[i] != L'\0') {
      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
      while (i != length && wstr[i] != L'\0')
        i++;
    } else {
      *msg << '\0';
      i++;
    }
  }
}

#endif  // GTEST_HAS_STD_WSTRING

void SplitString(const ::std::string& str, char delimiter,
                 ::std::vector< ::std::string>* dest) {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

}  // namespace internal

// Constructs an empty Message.
// We allocate the stringstream separately because otherwise each use of
// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
// stack frame leading to huge stack frames in some cases; gcc does not reuse
// the stack space.
Message::Message() : ss_(new ::std::stringstream) {
  // By default, we want there to be enough precision when printing
  // a double to a Message.
  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
}

// These two overloads allow streaming a wide C string to a Message
// using the UTF-8 encoding.
Message& Message::operator <<(const wchar_t* wide_c_str) {
  return *this << internal::String::ShowWideCString(wide_c_str);
}
Message& Message::operator <<(wchar_t* wide_c_str) {
  return *this << internal::String::ShowWideCString(wide_c_str);
}

#if GTEST_HAS_STD_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& Message::operator <<(const ::std::wstring& wstr) {
  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
  return *this;
}
#endif  // GTEST_HAS_STD_WSTRING

// Gets the text streamed to this object so far as an std::string.
// Each '\0' character in the buffer is replaced with "\\0".
std::string Message::GetString() const {
  return internal::StringStreamToString(ss_.get());
}

// AssertionResult constructors.
// Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult::AssertionResult(const AssertionResult& other)
    : success_(other.success_),
      message_(other.message_.get() != nullptr
                   ? new ::std::string(*other.message_)
                   : static_cast< ::std::string*>(nullptr)) {}

// Swaps two AssertionResults.
void AssertionResult::swap(AssertionResult& other) {
  using std::swap;
  swap(success_, other.success_);
  swap(message_, other.message_);
}

// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
  if (message_.get() != nullptr) negation << *message_;
  return negation;
}

// Makes a successful assertion result.
AssertionResult AssertionSuccess() {
  return AssertionResult(true);
}

// Makes a failed assertion result.
AssertionResult AssertionFailure() {
  return AssertionResult(false);
}

// Makes a failed assertion result with the given failure message.
// Deprecated; use AssertionFailure() << message.
AssertionResult AssertionFailure(const Message& message) {
  return AssertionFailure() << message;
}

namespace internal {

namespace edit_distance {
std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
                                            const std::vector<size_t>& right) {
  std::vector<std::vector<double> > costs(
      left.size() + 1, std::vector<double>(right.size() + 1));
  std::vector<std::vector<EditType> > best_move(
      left.size() + 1, std::vector<EditType>(right.size() + 1));

  // Populate for empty right.
  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
    costs[l_i][0] = static_cast<double>(l_i);
    best_move[l_i][0] = kRemove;
  }
  // Populate for empty left.
  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
    costs[0][r_i] = static_cast<double>(r_i);
    best_move[0][r_i] = kAdd;
  }

  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
      if (left[l_i] == right[r_i]) {
        // Found a match. Consume it.
        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
        best_move[l_i + 1][r_i + 1] = kMatch;
        continue;
      }

      const double add = costs[l_i + 1][r_i];
      const double remove = costs[l_i][r_i + 1];
      const double replace = costs[l_i][r_i];
      if (add < remove && add < replace) {
        costs[l_i + 1][r_i + 1] = add + 1;
        best_move[l_i + 1][r_i + 1] = kAdd;
      } else if (remove < add && remove < replace) {
        costs[l_i + 1][r_i + 1] = remove + 1;
        best_move[l_i + 1][r_i + 1] = kRemove;
      } else {
        // We make replace a little more expensive than add/remove to lower
        // their priority.
        costs[l_i + 1][r_i + 1] = replace + 1.00001;
        best_move[l_i + 1][r_i + 1] = kReplace;
      }
    }
  }

  // Reconstruct the best path. We do it in reverse order.
  std::vector<EditType> best_path;
  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
    EditType move = best_move[l_i][r_i];
    best_path.push_back(move);
    l_i -= move != kAdd;
    r_i -= move != kRemove;
  }
  std::reverse(best_path.begin(), best_path.end());
  return best_path;
}

namespace {

// Helper class to convert string into ids with deduplication.
class InternalStrings {
 public:
  size_t GetId(const std::string& str) {
    IdMap::iterator it = ids_.find(str);
    if (it != ids_.end()) return it->second;
    size_t id = ids_.size();
    return ids_[str] = id;
  }

 private:
  typedef std::map<std::string, size_t> IdMap;
  IdMap ids_;
};

}  // namespace

std::vector<EditType> CalculateOptimalEdits(
    const std::vector<std::string>& left,
    const std::vector<std::string>& right) {
  std::vector<size_t> left_ids, right_ids;
  {
    InternalStrings intern_table;
    for (size_t i = 0; i < left.size(); ++i) {
      left_ids.push_back(intern_table.GetId(left[i]));
    }
    for (size_t i = 0; i < right.size(); ++i) {
      right_ids.push_back(intern_table.GetId(right[i]));
    }
  }
  return CalculateOptimalEdits(left_ids, right_ids);
}

namespace {

// Helper class that holds the state for one hunk and prints it out to the
// stream.
// It reorders adds/removes when possible to group all removes before all
// adds. It also adds the hunk header before printint into the stream.
class Hunk {
 public:
  Hunk(size_t left_start, size_t right_start)
      : left_start_(left_start),
        right_start_(right_start),
        adds_(),
        removes_(),
        common_() {}

  void PushLine(char edit, const char* line) {
    switch (edit) {
      case ' ':
        ++common_;
        FlushEdits();
        hunk_.push_back(std::make_pair(' ', line));
        break;
      case '-':
        ++removes_;
        hunk_removes_.push_back(std::make_pair('-', line));
        break;
      case '+':
        ++adds_;
        hunk_adds_.push_back(std::make_pair('+', line));
        break;
    }
  }

  void PrintTo(std::ostream* os) {
    PrintHeader(os);
    FlushEdits();
    for (std::list<std::pair<char, const char*> >::const_iterator it =
             hunk_.begin();
         it != hunk_.end(); ++it) {
      *os << it->first << it->second << "\n";
    }
  }

  bool has_edits() const { return adds_ || removes_; }

 private:
  void FlushEdits() {
    hunk_.splice(hunk_.end(), hunk_removes_);
    hunk_.splice(hunk_.end(), hunk_adds_);
  }

  // Print a unified diff header for one hunk.
  // The format is
  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
  // where the left/right parts are omitted if unnecessary.
  void PrintHeader(std::ostream* ss) const {
    *ss << "@@ ";
    if (removes_) {
      *ss << "-" << left_start_ << "," << (removes_ + common_);
    }
    if (removes_ && adds_) {
      *ss << " ";
    }
    if (adds_) {
      *ss << "+" << right_start_ << "," << (adds_ + common_);
    }
    *ss << " @@\n";
  }

  size_t left_start_, right_start_;
  size_t adds_, removes_, common_;
  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
};

}  // namespace

// Create a list of diff hunks in Unified diff format.
// Each hunk has a header generated by PrintHeader above plus a body with
// lines prefixed with ' ' for no change, '-' for deletion and '+' for
// addition.
// 'context' represents the desired unchanged prefix/suffix around the diff.
// If two hunks are close enough that their contexts overlap, then they are
// joined into one hunk.
std::string CreateUnifiedDiff(const std::vector<std::string>& left,
                              const std::vector<std::string>& right,
                              size_t context) {
  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);

  size_t l_i = 0, r_i = 0, edit_i = 0;
  std::stringstream ss;
  while (edit_i < edits.size()) {
    // Find first edit.
    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
      ++l_i;
      ++r_i;
      ++edit_i;
    }

    // Find the first line to include in the hunk.
    const size_t prefix_context = std::min(l_i, context);
    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
    for (size_t i = prefix_context; i > 0; --i) {
      hunk.PushLine(' ', left[l_i - i].c_str());
    }

    // Iterate the edits until we found enough suffix for the hunk or the input
    // is over.
    size_t n_suffix = 0;
    for (; edit_i < edits.size(); ++edit_i) {
      if (n_suffix >= context) {
        // Continue only if the next hunk is very close.
        auto it = edits.begin() + static_cast<int>(edit_i);
        while (it != edits.end() && *it == kMatch) ++it;
        if (it == edits.end() ||
            static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
          // There is no next edit or it is too far away.
          break;
        }
      }

      EditType edit = edits[edit_i];
      // Reset count when a non match is found.
      n_suffix = edit == kMatch ? n_suffix + 1 : 0;

      if (edit == kMatch || edit == kRemove || edit == kReplace) {
        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
      }
      if (edit == kAdd || edit == kReplace) {
        hunk.PushLine('+', right[r_i].c_str());
      }

      // Advance indices, depending on edit type.
      l_i += edit != kAdd;
      r_i += edit != kRemove;
    }

    if (!hunk.has_edits()) {
      // We are done. We don't want this hunk.
      break;
    }

    hunk.PrintTo(&ss);
  }
  return ss.str();
}

}  // namespace edit_distance

namespace {

// The string representation of the values received in EqFailure() are already
// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
// characters the same.
std::vector<std::string> SplitEscapedString(const std::string& str) {
  std::vector<std::string> lines;
  size_t start = 0, end = str.size();
  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
    ++start;
    --end;
  }
  bool escaped = false;
  for (size_t i = start; i + 1 < end; ++i) {
    if (escaped) {
      escaped = false;
      if (str[i] == 'n') {
        lines.push_back(str.substr(start, i - start - 1));
        start = i + 1;
      }
    } else {
      escaped = str[i] == '\\';
    }
  }
  lines.push_back(str.substr(start, end - start));
  return lines;
}

}  // namespace

// Constructs and returns the message for an equality assertion
// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
//
// The first four parameters are the expressions used in the assertion
// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
// where foo is 5 and bar is 6, we have:
//
//   lhs_expression: "foo"
//   rhs_expression: "bar"
//   lhs_value:      "5"
//   rhs_value:      "6"
//
// The ignoring_case parameter is true if and only if the assertion is a
// *_STRCASEEQ*.  When it's true, the string "Ignoring case" will
// be inserted into the message.
AssertionResult EqFailure(const char* lhs_expression,
                          const char* rhs_expression,
                          const std::string& lhs_value,
                          const std::string& rhs_value,
                          bool ignoring_case) {
  Message msg;
  msg << "Expected equality of these values:";
  msg << "\n  " << lhs_expression;
  if (lhs_value != lhs_expression) {
    msg << "\n    Which is: " << lhs_value;
  }
  msg << "\n  " << rhs_expression;
  if (rhs_value != rhs_expression) {
    msg << "\n    Which is: " << rhs_value;
  }

  if (ignoring_case) {
    msg << "\nIgnoring case";
  }

  if (!lhs_value.empty() && !rhs_value.empty()) {
    const std::vector<std::string> lhs_lines =
        SplitEscapedString(lhs_value);
    const std::vector<std::string> rhs_lines =
        SplitEscapedString(rhs_value);
    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
      msg << "\nWith diff:\n"
          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
    }
  }

  return AssertionFailure() << msg;
}

// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result,
    const char* expression_text,
    const char* actual_predicate_value,
    const char* expected_predicate_value) {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

// Helper function for implementing ASSERT_NEAR.
AssertionResult DoubleNearPredFormat(const char* expr1,
                                     const char* expr2,
                                     const char* abs_error_expr,
                                     double val1,
                                     double val2,
                                     double abs_error) {
  const double diff = fabs(val1 - val2);
  if (diff <= abs_error) return AssertionSuccess();

  // Find the value which is closest to zero.
  const double min_abs = std::min(fabs(val1), fabs(val2));
  // Find the distance to the next double from that value.
  const double epsilon =
      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
  // Detect the case where abs_error is so small that EXPECT_NEAR is
  // effectively the same as EXPECT_EQUAL, and give an informative error
  // message so that the situation can be more easily understood without
  // requiring exotic floating-point knowledge.
  // Don't do an epsilon check if abs_error is zero because that implies
  // that an equality check was actually intended.
  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
      abs_error < epsilon) {
    return AssertionFailure()
           << "The difference between " << expr1 << " and " << expr2 << " is "
           << diff << ", where\n"
           << expr1 << " evaluates to " << val1 << ",\n"
           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
           << abs_error_expr << " evaluates to " << abs_error
           << " which is smaller than the minimum distance between doubles for "
              "numbers of this magnitude which is "
           << epsilon
           << ", thus making this EXPECT_NEAR check equivalent to "
              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
  }
  return AssertionFailure()
      << "The difference between " << expr1 << " and " << expr2
      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
      << expr1 << " evaluates to " << val1 << ",\n"
      << expr2 << " evaluates to " << val2 << ", and\n"
      << abs_error_expr << " evaluates to " << abs_error << ".";
}


// Helper template for implementing FloatLE() and DoubleLE().
template <typename RawType>
AssertionResult FloatingPointLE(const char* expr1,
                                const char* expr2,
                                RawType val1,
                                RawType val2) {
  // Returns success if val1 is less than val2,
  if (val1 < val2) {
    return AssertionSuccess();
  }

  // or if val1 is almost equal to val2.
  const FloatingPoint<RawType> lhs(val1), rhs(val2);
  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  // Note that the above two checks will both fail if either val1 or
  // val2 is NaN, as the IEEE floating-point standard requires that
  // any predicate involving a NaN must return false.

  ::std::stringstream val1_ss;
  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val1;

  ::std::stringstream val2_ss;
  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val2;

  return AssertionFailure()
      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
      << StringStreamToString(&val2_ss);
}

}  // namespace internal

// Asserts that val1 is less than, or almost equal to, val2.  Fails
// otherwise.  In particular, it fails if either val1 or val2 is NaN.
AssertionResult FloatLE(const char* expr1, const char* expr2,
                        float val1, float val2) {
  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
}

// Asserts that val1 is less than, or almost equal to, val2.  Fails
// otherwise.  In particular, it fails if either val1 or val2 is NaN.
AssertionResult DoubleLE(const char* expr1, const char* expr2,
                         double val1, double val2) {
  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
}

namespace internal {

// The helper function for {ASSERT|EXPECT}_STREQ.
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression,
                               const char* lhs,
                               const char* rhs) {
  if (String::CStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
                                   const char* rhs_expression,
                                   const char* lhs,
                                   const char* rhs) {
  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   true);
}

// The helper function for {ASSERT|EXPECT}_STRNE.
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression,
                               const char* s1,
                               const char* s2) {
  if (!String::CStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                              << s2_expression << "), actual: \""
                              << s1 << "\" vs \"" << s2 << "\"";
  }
}

// The helper function for {ASSERT|EXPECT}_STRCASENE.
AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                   const char* s2_expression,
                                   const char* s1,
                                   const char* s2) {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

}  // namespace internal

namespace {

// Helper functions for implementing IsSubString() and IsNotSubstring().

// This group of overloaded functions return true if and only if needle
// is a substring of haystack.  NULL is considered a substring of
// itself only.

bool IsSubstringPred(const char* needle, const char* haystack) {
  if (needle == nullptr || haystack == nullptr) return needle == haystack;

  return strstr(haystack, needle) != nullptr;
}

bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
  if (needle == nullptr || haystack == nullptr) return needle == haystack;

  return wcsstr(haystack, needle) != nullptr;
}

// StringType here can be either ::std::string or ::std::wstring.
template <typename StringType>
bool IsSubstringPred(const StringType& needle,
                     const StringType& haystack) {
  return haystack.find(needle) != StringType::npos;
}

// This function implements either IsSubstring() or IsNotSubstring(),
// depending on the value of the expected_to_be_substring parameter.
// StringType here can be const char*, const wchar_t*, ::std::string,
// or ::std::wstring.
template <typename StringType>
AssertionResult IsSubstringImpl(
    bool expected_to_be_substring,
    const char* needle_expr, const char* haystack_expr,
    const StringType& needle, const StringType& haystack) {
  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
    return AssertionSuccess();

  const bool is_wide_string = sizeof(needle[0]) > 1;
  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
  return AssertionFailure()
      << "Value of: " << needle_expr << "\n"
      << "  Actual: " << begin_string_quote << needle << "\"\n"
      << "Expected: " << (expected_to_be_substring ? "" : "not ")
      << "a substring of " << haystack_expr << "\n"
      << "Which is: " << begin_string_quote << haystack << "\"";
}

}  // namespace

// IsSubstring() and IsNotSubstring() check whether needle is a
// substring of haystack (NULL is considered a substring of itself
// only), and return an appropriate error message when they fail.

AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack) {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack) {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack) {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack) {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack) {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack) {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

#if GTEST_HAS_STD_WSTRING
AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack) {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack) {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}
#endif  // GTEST_HAS_STD_WSTRING

namespace internal {

#if GTEST_OS_WINDOWS

namespace {

// Helper function for IsHRESULT{SuccessFailure} predicates
AssertionResult HRESULTFailureHelper(const char* expr,
                                     const char* expected,
                                     long hr) {  // NOLINT
# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE

  // Windows CE doesn't support FormatMessage.
  const char error_text[] = "";

# else

  // Looks up the human-readable system message for the HRESULT code
  // and since we're not passing any params to FormatMessage, we don't
  // want inserts expanded.
  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
                       FORMAT_MESSAGE_IGNORE_INSERTS;
  const DWORD kBufSize = 4096;
  // Gets the system's human readable message string for this HRESULT.
  char error_text[kBufSize] = { '\0' };
  DWORD message_length = ::FormatMessageA(kFlags,
                                          0,   // no source, we're asking system
                                          static_cast<DWORD>(hr),  // the error
                                          0,   // no line width restrictions
                                          error_text,  // output buffer
                                          kBufSize,    // buf size
                                          nullptr);  // no arguments for inserts
  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
  for (; message_length && IsSpace(error_text[message_length - 1]);
          --message_length) {
    error_text[message_length - 1] = '\0';
  }

# endif  // GTEST_OS_WINDOWS_MOBILE

  const std::string error_hex("0x" + String::FormatHexInt(hr));
  return ::testing::AssertionFailure()
      << "Expected: " << expr << " " << expected << ".\n"
      << "  Actual: " << error_hex << " " << error_text << "\n";
}

}  // namespace

AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
  if (SUCCEEDED(hr)) {
    return AssertionSuccess();
  }
  return HRESULTFailureHelper(expr, "succeeds", hr);
}

AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
  if (FAILED(hr)) {
    return AssertionSuccess();
  }
  return HRESULTFailureHelper(expr, "fails", hr);
}

#endif  // GTEST_OS_WINDOWS

// Utility functions for encoding Unicode text (wide strings) in
// UTF-8.

// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
// like this:
//
// Code-point length   Encoding
//   0 -  7 bits       0xxxxxxx
//   8 - 11 bits       110xxxxx 10xxxxxx
//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

// The maximum code-point a one-byte UTF-8 sequence can represent.
constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1;

// The maximum code-point a two-byte UTF-8 sequence can represent.
constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;

// The maximum code-point a three-byte UTF-8 sequence can represent.
constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;

// The maximum code-point a four-byte UTF-8 sequence can represent.
constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;

// Chops off the n lowest bits from a bit pattern.  Returns the n
// lowest bits.  As a side effect, the original bit pattern will be
// shifted to the right by n bits.
inline uint32_t ChopLowBits(uint32_t* bits, int n) {
  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
  *bits >>= n;
  return low_bits;
}

// Converts a Unicode code point to a narrow string in UTF-8 encoding.
// code_point parameter is of type uint32_t because wchar_t may not be
// wide enough to contain a code point.
// If the code_point is not a valid Unicode code point
// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
// to "(Invalid Unicode 0xXXXXXXXX)".
std::string CodePointToUtf8(uint32_t code_point) {
  if (code_point > kMaxCodePoint4) {
    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
  }

  char str[5];  // Big enough for the largest valid code point.
  if (code_point <= kMaxCodePoint1) {
    str[1] = '\0';
    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
  } else if (code_point <= kMaxCodePoint2) {
    str[2] = '\0';
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
  } else if (code_point <= kMaxCodePoint3) {
    str[3] = '\0';
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
  } else {  // code_point <= kMaxCodePoint4
    str[4] = '\0';
    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
  }
  return str;
}

// The following two functions only make sense if the system
// uses UTF-16 for wide string encoding. All supported systems
// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.

// Determines if the arguments constitute UTF-16 surrogate pair
// and thus should be combined into a single Unicode code point
// using CreateCodePointFromUtf16SurrogatePair.
inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
  return sizeof(wchar_t) == 2 &&
      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
}

// Creates a Unicode code point from UTF16 surrogate pair.
inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
                                                      wchar_t second) {
  const auto first_u = static_cast<uint32_t>(first);
  const auto second_u = static_cast<uint32_t>(second);
  const uint32_t mask = (1 << 10) - 1;
  return (sizeof(wchar_t) == 2)
             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
             :
             // This function should not be called when the condition is
             // false, but we provide a sensible default in case it is.
             first_u;
}

// Converts a wide string to a narrow string in UTF-8 encoding.
// The wide string is assumed to have the following encoding:
//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
// Parameter str points to a null-terminated wide string.
// Parameter num_chars may additionally limit the number
// of wchar_t characters processed. -1 is used when the entire string
// should be processed.
// If the string contains code points that are not valid Unicode code points
// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
// and contains invalid UTF-16 surrogate pairs, values in those pairs
// will be encoded as individual Unicode characters from Basic Normal Plane.
std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    uint32_t unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<uint32_t>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

// Converts a wide C string to an std::string using the UTF-8 encoding.
// NULL will be converted to "(null)".
std::string String::ShowWideCString(const wchar_t * wide_c_str) {
  if (wide_c_str == nullptr) return "(null)";

  return internal::WideStringToUtf8(wide_c_str, -1);
}

// Compares two wide C strings.  Returns true if and only if they have the
// same content.
//
// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
// C string is considered different to any non-NULL C string,
// including the empty string.
bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
  if (lhs == nullptr) return rhs == nullptr;

  if (rhs == nullptr) return false;

  return wcscmp(lhs, rhs) == 0;
}

// Helper function for *_STREQ on wide strings.
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression,
                               const wchar_t* lhs,
                               const wchar_t* rhs) {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

// Helper function for *_STRNE on wide strings.
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression,
                               const wchar_t* s1,
                               const wchar_t* s2) {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }

  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

// Compares two C strings, ignoring case.  Returns true if and only if they have
// the same content.
//
// Unlike strcasecmp(), this function can handle NULL argument(s).  A
// NULL C string is considered different to any non-NULL C string,
// including the empty string.
bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
  if (lhs == nullptr) return rhs == nullptr;
  if (rhs == nullptr) return false;
  return posix::StrCaseCmp(lhs, rhs) == 0;
}

// Compares two wide C strings, ignoring case.  Returns true if and only if they
// have the same content.
//
// Unlike wcscasecmp(), this function can handle NULL argument(s).
// A NULL C string is considered different to any non-NULL wide C string,
// including the empty string.
// NB: The implementations on different platforms slightly differ.
// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
// environment variable. On GNU platform this method uses wcscasecmp
// which compares according to LC_CTYPE category of the current locale.
// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
// current locale.
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                              const wchar_t* rhs) {
  if (lhs == nullptr) return rhs == nullptr;

  if (rhs == nullptr) return false;

#if GTEST_OS_WINDOWS
  return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
  return wcscasecmp(lhs, rhs) == 0;
#else
  // Android, Mac OS X and Cygwin don't define wcscasecmp.
  // Other unknown OSes may not define it either.
  wint_t left, right;
  do {
    left = towlower(static_cast<wint_t>(*lhs++));
    right = towlower(static_cast<wint_t>(*rhs++));
  } while (left && left == right);
  return left == right;
#endif  // OS selector
}

// Returns true if and only if str ends with the given suffix, ignoring case.
// Any string is considered to end with an empty suffix.
bool String::EndsWithCaseInsensitive(
    const std::string& str, const std::string& suffix) {
  const size_t str_len = str.length();
  const size_t suffix_len = suffix.length();
  return (str_len >= suffix_len) &&
         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
                                      suffix.c_str());
}

// Formats an int value as "%02d".
std::string String::FormatIntWidth2(int value) {
  return FormatIntWidthN(value, 2);
}

// Formats an int value to given width with leading zeros.
std::string String::FormatIntWidthN(int value, int width) {
  std::stringstream ss;
  ss << std::setfill('0') << std::setw(width) << value;
  return ss.str();
}

// Formats an int value as "%X".
std::string String::FormatHexUInt32(uint32_t value) {
  std::stringstream ss;
  ss << std::hex << std::uppercase << value;
  return ss.str();
}

// Formats an int value as "%X".
std::string String::FormatHexInt(int value) {
  return FormatHexUInt32(static_cast<uint32_t>(value));
}

// Formats a byte as "%02X".
std::string String::FormatByte(unsigned char value) {
  std::stringstream ss;
  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
     << static_cast<unsigned int>(value);
  return ss.str();
}

// Converts the buffer in a stringstream to an std::string, converting NUL
// bytes to "\\0" along the way.
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(static_cast<size_t>(2 * (end - start)));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Appends the user-supplied message to the Google-Test-generated message.
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }
  if (gtest_msg.empty()) {
    return user_msg_string;
  }
  return gtest_msg + "\n" + user_msg_string;
}

}  // namespace internal

// class TestResult

// Creates an empty TestResult.
TestResult::TestResult()
    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}

// D'tor.
TestResult::~TestResult() {
}

// Returns the i-th test part result among all the results. i can
// range from 0 to total_part_count() - 1. If i is not in that range,
// aborts the program.
const TestPartResult& TestResult::GetTestPartResult(int i) const {
  if (i < 0 || i >= total_part_count())
    internal::posix::Abort();
  return test_part_results_.at(static_cast<size_t>(i));
}

// Returns the i-th test property. i can range from 0 to
// test_property_count() - 1. If i is not in that range, aborts the
// program.
const TestProperty& TestResult::GetTestProperty(int i) const {
  if (i < 0 || i >= test_property_count())
    internal::posix::Abort();
  return test_properties_.at(static_cast<size_t>(i));
}

// Clears the test part results.
void TestResult::ClearTestPartResults() {
  test_part_results_.clear();
}

// Adds a test part result to the list.
void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
  test_part_results_.push_back(test_part_result);
}

// Adds a test property to the list. If a property with the same key as the
// supplied property is already represented, the value of this test_property
// replaces the old value for that key.
void TestResult::RecordProperty(const std::string& xml_element,
                                const TestProperty& test_property) {
  if (!ValidateTestProperty(xml_element, test_property)) {
    return;
  }
  internal::MutexLock lock(&test_properties_mutex_);
  const std::vector<TestProperty>::iterator property_with_matching_key =
      std::find_if(test_properties_.begin(), test_properties_.end(),
                   internal::TestPropertyKeyIs(test_property.key()));
  if (property_with_matching_key == test_properties_.end()) {
    test_properties_.push_back(test_property);
    return;
  }
  property_with_matching_key->SetValue(test_property.value());
}

// The list of reserved attributes used in the <testsuites> element of XML
// output.
static const char* const kReservedTestSuitesAttributes[] = {
  "disabled",
  "errors",
  "failures",
  "name",
  "random_seed",
  "tests",
  "time",
  "timestamp"
};

// The list of reserved attributes used in the <testsuite> element of XML
// output.
static const char* const kReservedTestSuiteAttributes[] = {
    "disabled", "errors", "failures",  "name",
    "tests",    "time",   "timestamp", "skipped"};

// The list of reserved attributes used in the <testcase> element of XML output.
static const char* const kReservedTestCaseAttributes[] = {
    "classname",   "name", "status", "time",  "type_param",
    "value_param", "file", "line"};

// Use a slightly different set for allowed output to ensure existing tests can
// still RecordProperty("result") or "RecordProperty(timestamp")
static const char* const kReservedOutputTestCaseAttributes[] = {
    "classname",   "name", "status", "time",   "type_param",
    "value_param", "file", "line",   "result", "timestamp"};

template <size_t kSize>
std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
  return std::vector<std::string>(array, array + kSize);
}

static std::vector<std::string> GetReservedAttributesForElement(
    const std::string& xml_element) {
  if (xml_element == "testsuites") {
    return ArrayAsVector(kReservedTestSuitesAttributes);
  } else if (xml_element == "testsuite") {
    return ArrayAsVector(kReservedTestSuiteAttributes);
  } else if (xml_element == "testcase") {
    return ArrayAsVector(kReservedTestCaseAttributes);
  } else {
    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  }
  // This code is unreachable but some compilers may not realizes that.
  return std::vector<std::string>();
}

// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
static std::vector<std::string> GetReservedOutputAttributesForElement(
    const std::string& xml_element) {
  if (xml_element == "testsuites") {
    return ArrayAsVector(kReservedTestSuitesAttributes);
  } else if (xml_element == "testsuite") {
    return ArrayAsVector(kReservedTestSuiteAttributes);
  } else if (xml_element == "testcase") {
    return ArrayAsVector(kReservedOutputTestCaseAttributes);
  } else {
    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  }
  // This code is unreachable but some compilers may not realizes that.
  return std::vector<std::string>();
}

static std::string FormatWordList(const std::vector<std::string>& words) {
  Message word_list;
  for (size_t i = 0; i < words.size(); ++i) {
    if (i > 0 && words.size() > 2) {
      word_list << ", ";
    }
    if (i == words.size() - 1) {
      word_list << "and ";
    }
    word_list << "'" << words[i] << "'";
  }
  return word_list.GetString();
}

static bool ValidateTestPropertyName(
    const std::string& property_name,
    const std::vector<std::string>& reserved_names) {
  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
          reserved_names.end()) {
    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
                  << " (" << FormatWordList(reserved_names)
                  << " are reserved by " << GTEST_NAME_ << ")";
    return false;
  }
  return true;
}

// Adds a failure if the key is a reserved attribute of the element named
// xml_element.  Returns true if the property is valid.
bool TestResult::ValidateTestProperty(const std::string& xml_element,
                                      const TestProperty& test_property) {
  return ValidateTestPropertyName(test_property.key(),
                                  GetReservedAttributesForElement(xml_element));
}

// Clears the object.
void TestResult::Clear() {
  test_part_results_.clear();
  test_properties_.clear();
  death_test_count_ = 0;
  elapsed_time_ = 0;
}

// Returns true off the test part was skipped.
static bool TestPartSkipped(const TestPartResult& result) {
  return result.skipped();
}

// Returns true if and only if the test was skipped.
bool TestResult::Skipped() const {
  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
}

// Returns true if and only if the test failed.
bool TestResult::Failed() const {
  for (int i = 0; i < total_part_count(); ++i) {
    if (GetTestPartResult(i).failed())
      return true;
  }
  return false;
}

// Returns true if and only if the test part fatally failed.
static bool TestPartFatallyFailed(const TestPartResult& result) {
  return result.fatally_failed();
}

// Returns true if and only if the test fatally failed.
bool TestResult::HasFatalFailure() const {
  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
}

// Returns true if and only if the test part non-fatally failed.
static bool TestPartNonfatallyFailed(const TestPartResult& result) {
  return result.nonfatally_failed();
}

// Returns true if and only if the test has a non-fatal failure.
bool TestResult::HasNonfatalFailure() const {
  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
}

// Gets the number of all test parts.  This is the sum of the number
// of successful test parts and the number of failed test parts.
int TestResult::total_part_count() const {
  return static_cast<int>(test_part_results_.size());
}

// Returns the number of the test properties.
int TestResult::test_property_count() const {
  return static_cast<int>(test_properties_.size());
}

// class Test

// Creates a Test object.

// The c'tor saves the states of all flags.
Test::Test()
    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
}

// The d'tor restores the states of all flags.  The actual work is
// done by the d'tor of the gtest_flag_saver_ field, and thus not
// visible here.
Test::~Test() {
}

// Sets up the test fixture.
//
// A sub-class may override this.
void Test::SetUp() {
}

// Tears down the test fixture.
//
// A sub-class may override this.
void Test::TearDown() {
}

// Allows user supplied key value pairs to be recorded for later output.
void Test::RecordProperty(const std::string& key, const std::string& value) {
  UnitTest::GetInstance()->RecordProperty(key, value);
}

// Allows user supplied key value pairs to be recorded for later output.
void Test::RecordProperty(const std::string& key, int value) {
  Message value_message;
  value_message << value;
  RecordProperty(key, value_message.GetString().c_str());
}

namespace internal {

void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message) {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      nullptr,  // No info about the source file where the exception occurred.
      -1,       // We have no info on which line caused the exception.
      message,
      "");  // No stack trace, either.
}

}  // namespace internal

// Google Test requires all tests in the same test suite to use the same test
// fixture class.  This function checks if the current test has the
// same fixture class as the first test in the current test suite.  If
// yes, it returns true; otherwise it generates a Google Test failure and
// returns false.
bool Test::HasSameFixtureClass() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  const TestSuite* const test_suite = impl->current_test_suite();

  // Info about the first test in the current test suite.
  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
  const char* const first_test_name = first_test_info->name();

  // Info about the current test.
  const TestInfo* const this_test_info = impl->current_test_info();
  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
  const char* const this_test_name = this_test_info->name();

  if (this_fixture_id != first_fixture_id) {
    // Is the first test defined using TEST?
    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
    // Is this test defined using TEST?
    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();

    if (first_is_TEST || this_is_TEST) {
      // Both TEST and TEST_F appear in same test suite, which is incorrect.
      // Tell the user how to fix this.

      // Gets the name of the TEST and the name of the TEST_F.  Note
      // that first_is_TEST and this_is_TEST cannot both be true, as
      // the fixture IDs are different for the two tests.
      const char* const TEST_name =
          first_is_TEST ? first_test_name : this_test_name;
      const char* const TEST_F_name =
          first_is_TEST ? this_test_name : first_test_name;

      ADD_FAILURE()
          << "All tests in the same test suite must use the same test fixture\n"
          << "class, so mixing TEST_F and TEST in the same test suite is\n"
          << "illegal.  In test suite " << this_test_info->test_suite_name()
          << ",\n"
          << "test " << TEST_F_name << " is defined using TEST_F but\n"
          << "test " << TEST_name << " is defined using TEST.  You probably\n"
          << "want to change the TEST to TEST_F or move it to another test\n"
          << "case.";
    } else {
      // Two fixture classes with the same name appear in two different
      // namespaces, which is not allowed. Tell the user how to fix this.
      ADD_FAILURE()
          << "All tests in the same test suite must use the same test fixture\n"
          << "class.  However, in test suite "
          << this_test_info->test_suite_name() << ",\n"
          << "you defined test " << first_test_name << " and test "
          << this_test_name << "\n"
          << "using two different test fixture classes.  This can happen if\n"
          << "the two classes are from different namespaces or translation\n"
          << "units and have the same name.  You should probably rename one\n"
          << "of the classes to put the tests into different test suites.";
    }
    return false;
  }

  return true;
}

#if GTEST_HAS_SEH

// Adds an "exception thrown" fatal failure to the current test.  This
// function returns its result via an output parameter pointer because VC++
// prohibits creation of objects with destructors on stack in functions
// using __try (see error C2712).
static std::string* FormatSehExceptionMessage(DWORD exception_code,
                                              const char* location) {
  Message message;
  message << "SEH exception with code 0x" << std::setbase(16) <<
    exception_code << std::setbase(10) << " thrown in " << location << ".";

  return new std::string(message.GetString());
}

#endif  // GTEST_HAS_SEH

namespace internal {

#if GTEST_HAS_EXCEPTIONS

// Adds an "exception thrown" fatal failure to the current test.
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != nullptr) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result);

GoogleTestFailureException::GoogleTestFailureException(
    const TestPartResult& failure)
    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}

#endif  // GTEST_HAS_EXCEPTIONS

// We put these helper functions in the internal namespace as IBM's xlC
// compiler rejects the code if they were declared static.

// Runs the given method and handles SEH exceptions it throws, when
// SEH is supported; returns the 0-value for type Result in case of an
// SEH exception.  (Microsoft compilers cannot handle SEH and C++
// exceptions in the same function.  Therefore, we provide a separate
// wrapper function for handling SEH exceptions.)
template <class T, typename Result>
Result HandleSehExceptionsInMethodIfSupported(
    T* object, Result (T::*method)(), const char* location) {
#if GTEST_HAS_SEH
  __try {
    return (object->*method)();
  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
      GetExceptionCode())) {
    // We create the exception message on the heap because VC++ prohibits
    // creation of objects with destructors on stack in functions using __try
    // (see error C2712).
    std::string* exception_message = FormatSehExceptionMessage(
        GetExceptionCode(), location);
    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                             *exception_message);
    delete exception_message;
    return static_cast<Result>(0);
  }
#else
  (void)location;
  return (object->*method)();
#endif  // GTEST_HAS_SEH
}

// Runs the given method and catches and reports C++ and/or SEH-style
// exceptions, if they are supported; returns the 0-value for type
// Result in case of an SEH exception.
template <class T, typename Result>
Result HandleExceptionsInMethodIfSupported(
    T* object, Result (T::*method)(), const char* location) {
  // NOTE: The user code can affect the way in which Google Test handles
  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
  // after the exception is caught and either report or re-throw the
  // exception based on the flag's value:
  //
  // try {
  //   // Perform the test method.
  // } catch (...) {
  //   if (GTEST_FLAG(catch_exceptions))
  //     // Report the exception as failure.
  //   else
  //     throw;  // Re-throws the original exception.
  // }
  //
  // However, the purpose of this flag is to allow the program to drop into
  // the debugger when the exception is thrown. On most platforms, once the
  // control enters the catch block, the exception origin information is
  // lost and the debugger will stop the program at the point of the
  // re-throw in this function -- instead of at the point of the original
  // throw statement in the code under test.  For this reason, we perform
  // the check early, sacrificing the ability to affect Google Test's
  // exception handling in the method where the exception is thrown.
  if (internal::GetUnitTestImpl()->catch_exceptions()) {
#if GTEST_HAS_EXCEPTIONS
    try {
      return HandleSehExceptionsInMethodIfSupported(object, method, location);
    } catch (const AssertionException&) {  // NOLINT
      // This failure was reported already.
    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
      // This exception type can only be thrown by a failed Google
      // Test assertion with the intention of letting another testing
      // framework catch it.  Therefore we just re-throw it.
      throw;
    } catch (const std::exception& e) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(e.what(), location));
    } catch (...) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(nullptr, location));
    }
    return static_cast<Result>(0);
#else
    return HandleSehExceptionsInMethodIfSupported(object, method, location);
#endif  // GTEST_HAS_EXCEPTIONS
  } else {
    return (object->*method)();
  }
}

}  // namespace internal

// Runs the test and updates the test result.
void Test::Run() {
  if (!HasSameFixtureClass()) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
  // We will run the test only if SetUp() was successful and didn't call
  // GTEST_SKIP().
  if (!HasFatalFailure() && !IsSkipped()) {
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        this, &Test::TestBody, "the test body");
  }

  // However, we want to clean up as much as possible.  Hence we will
  // always call TearDown(), even if SetUp() or the test body has
  // failed.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &Test::TearDown, "TearDown()");
}

// Returns true if and only if the current test has a fatal failure.
bool Test::HasFatalFailure() {
  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
}

// Returns true if and only if the current test has a non-fatal failure.
bool Test::HasNonfatalFailure() {
  return internal::GetUnitTestImpl()->current_test_result()->
      HasNonfatalFailure();
}

// Returns true if and only if the current test was skipped.
bool Test::IsSkipped() {
  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
}

// class TestInfo

// Constructs a TestInfo object. It assumes ownership of the test factory
// object.
TestInfo::TestInfo(const std::string& a_test_suite_name,
                   const std::string& a_name, const char* a_type_param,
                   const char* a_value_param,
                   internal::CodeLocation a_code_location,
                   internal::TypeId fixture_class_id,
                   internal::TestFactoryBase* factory)
    : test_suite_name_(a_test_suite_name),
      name_(a_name),
      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
      location_(a_code_location),
      fixture_class_id_(fixture_class_id),
      should_run_(false),
      is_disabled_(false),
      matches_filter_(false),
      is_in_another_shard_(false),
      factory_(factory),
      result_() {}

// Destructs a TestInfo object.
TestInfo::~TestInfo() { delete factory_; }

namespace internal {

// Creates a new TestInfo object and registers it with Google Test;
// returns the created object.
//
// Arguments:
//
//   test_suite_name:  name of the test suite
//   name:             name of the test
//   type_param:       the name of the test's type parameter, or NULL if
//                     this is not a typed or a type-parameterized test.
//   value_param:      text representation of the test's value parameter,
//                     or NULL if this is not a value-parameterized test.
//   code_location:    code location where the test is defined
//   fixture_class_id: ID of the test fixture class
//   set_up_tc:        pointer to the function that sets up the test suite
//   tear_down_tc:     pointer to the function that tears down the test suite
//   factory:          pointer to the factory that creates a test object.
//                     The newly created TestInfo instance will assume
//                     ownership of the factory object.
TestInfo* MakeAndRegisterTestInfo(
    const char* test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_suite_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

void ReportInvalidTestSuiteType(const char* test_suite_name,
                                CodeLocation code_location) {
  Message errors;
  errors
      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
      << "All tests in the same test suite must use the same test fixture\n"
      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test suites.";

  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
                                          code_location.line)
                    << " " << errors.GetString();
}
}  // namespace internal

namespace {

// A predicate that checks the test name of a TestInfo against a known
// value.
//
// This is used for implementation of the TestSuite class only.  We put
// it in the anonymous namespace to prevent polluting the outer
// namespace.
//
// TestNameIs is copyable.
class TestNameIs {
 public:
  // Constructor.
  //
  // TestNameIs has NO default constructor.
  explicit TestNameIs(const char* name)
      : name_(name) {}

  // Returns true if and only if the test name of test_info matches name_.
  bool operator()(const TestInfo * test_info) const {
    return test_info && test_info->name() == name_;
  }

 private:
  std::string name_;
};

}  // namespace

namespace internal {

// This method expands all parameterized tests registered with macros TEST_P
// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
// This will be done just once during the program runtime.
void UnitTestImpl::RegisterParameterizedTests() {
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    type_parameterized_test_registry_.CheckForInstantiations();
    parameterized_tests_registered_ = true;
  }
}

}  // namespace internal

// Creates the test object, runs it, records its result, and then
// deletes it.
void TestInfo::Run() {
  if (!should_run_) return;

  // Tells UnitTest where to store test result.
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  result_.set_start_timestamp(internal::GetTimeInMillis());
  internal::Timer timer;

  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
      factory_, &internal::TestFactoryBase::CreateTest,
      "the test fixture's constructor");

  // Runs the test if the constructor didn't generate a fatal failure or invoke
  // GTEST_SKIP().
  // Note that the object will not be null
  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

  if (test != nullptr) {
    // Deletes the test object.
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        test, &Test::DeleteSelf_, "the test fixture's destructor");
  }

  result_.set_elapsed_time(timer.Elapsed());

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);

  // Tells UnitTest to stop associating assertion results to this
  // test.
  impl->set_current_test_info(nullptr);
}

// Skip and records a skipped test result for this object.
void TestInfo::Skip() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  const TestPartResult test_part_result =
      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
      test_part_result);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);
  impl->set_current_test_info(nullptr);
}

// class TestSuite

// Gets the number of successful tests in this test suite.
int TestSuite::successful_test_count() const {
  return CountIf(test_info_list_, TestPassed);
}

// Gets the number of successful tests in this test suite.
int TestSuite::skipped_test_count() const {
  return CountIf(test_info_list_, TestSkipped);
}

// Gets the number of failed tests in this test suite.
int TestSuite::failed_test_count() const {
  return CountIf(test_info_list_, TestFailed);
}

// Gets the number of disabled tests that will be reported in the XML report.
int TestSuite::reportable_disabled_test_count() const {
  return CountIf(test_info_list_, TestReportableDisabled);
}

// Gets the number of disabled tests in this test suite.
int TestSuite::disabled_test_count() const {
  return CountIf(test_info_list_, TestDisabled);
}

// Gets the number of tests to be printed in the XML report.
int TestSuite::reportable_test_count() const {
  return CountIf(test_info_list_, TestReportable);
}

// Get the number of tests in this test suite that should run.
int TestSuite::test_to_run_count() const {
  return CountIf(test_info_list_, ShouldRunTest);
}

// Gets the number of all tests.
int TestSuite::total_test_count() const {
  return static_cast<int>(test_info_list_.size());
}

// Creates a TestSuite with the given name.
//
// Arguments:
//
//   a_name:       name of the test suite
//   a_type_param: the name of the test suite's type parameter, or NULL if
//                 this is not a typed or a type-parameterized test suite.
//   set_up_tc:    pointer to the function that sets up the test suite
//   tear_down_tc: pointer to the function that tears down the test suite
TestSuite::TestSuite(const char* a_name, const char* a_type_param,
                     internal::SetUpTestSuiteFunc set_up_tc,
                     internal::TearDownTestSuiteFunc tear_down_tc)
    : name_(a_name),
      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
      set_up_tc_(set_up_tc),
      tear_down_tc_(tear_down_tc),
      should_run_(false),
      start_timestamp_(0),
      elapsed_time_(0) {}

// Destructor of TestSuite.
TestSuite::~TestSuite() {
  // Deletes every Test in the collection.
  ForEach(test_info_list_, internal::Delete<TestInfo>);
}

// Returns the i-th test among all the tests. i can range from 0 to
// total_test_count() - 1. If i is not in that range, returns NULL.
const TestInfo* TestSuite::GetTestInfo(int i) const {
  const int index = GetElementOr(test_indices_, i, -1);
  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
}

// Returns the i-th test among all the tests. i can range from 0 to
// total_test_count() - 1. If i is not in that range, returns NULL.
TestInfo* TestSuite::GetMutableTestInfo(int i) {
  const int index = GetElementOr(test_indices_, i, -1);
  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
}

// Adds a test to this test suite.  Will delete the test upon
// destruction of the TestSuite object.
void TestSuite::AddTestInfo(TestInfo* test_info) {
  test_info_list_.push_back(test_info);
  test_indices_.push_back(static_cast<int>(test_indices_.size()));
}

// Runs every test in this TestSuite.
void TestSuite::Run() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_suite(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Call both legacy and the new API
  repeater->OnTestSuiteStart(*this);
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseStart(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");

  start_timestamp_ = internal::GetTimeInMillis();
  internal::Timer timer;
  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Run();
    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
      for (int j = i + 1; j < total_test_count(); j++) {
        GetMutableTestInfo(j)->Skip();
      }
      break;
    }
  }
  elapsed_time_ = timer.Elapsed();

  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");

  // Call both legacy and the new API
  repeater->OnTestSuiteEnd(*this);
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseEnd(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  impl->set_current_test_suite(nullptr);
}

// Skips all tests under this TestSuite.
void TestSuite::Skip() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_suite(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Call both legacy and the new API
  repeater->OnTestSuiteStart(*this);
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseStart(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Skip();
  }

  // Call both legacy and the new API
  repeater->OnTestSuiteEnd(*this);
  // Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseEnd(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  impl->set_current_test_suite(nullptr);
}

// Clears the results of all tests in this test suite.
void TestSuite::ClearResult() {
  ad_hoc_test_result_.Clear();
  ForEach(test_info_list_, TestInfo::ClearTestResult);
}

// Shuffles the tests in this test suite.
void TestSuite::ShuffleTests(internal::Random* random) {
  Shuffle(random, &test_indices_);
}

// Restores the test order to before the first shuffle.
void TestSuite::UnshuffleTests() {
  for (size_t i = 0; i < test_indices_.size(); i++) {
    test_indices_[i] = static_cast<int>(i);
  }
}

// Formats a countable noun.  Depending on its quantity, either the
// singular form or the plural form is used. e.g.
//
// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
// FormatCountableNoun(5, "book", "books") returns "5 books".
static std::string FormatCountableNoun(int count,
                                       const char * singular_form,
                                       const char * plural_form) {
  return internal::StreamableToString(count) + " " +
      (count == 1 ? singular_form : plural_form);
}

// Formats the count of tests.
static std::string FormatTestCount(int test_count) {
  return FormatCountableNoun(test_count, "test", "tests");
}

// Formats the count of test suites.
static std::string FormatTestSuiteCount(int test_suite_count) {
  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
}

// Converts a TestPartResult::Type enum to human-friendly string
// representation.  Both kNonFatalFailure and kFatalFailure are translated
// to "Failure", as the user usually doesn't care about the difference
// between the two when viewing the test result.
static const char * TestPartResultTypeToString(TestPartResult::Type type) {
  switch (type) {
    case TestPartResult::kSkip:
      return "Skipped\n";
    case TestPartResult::kSuccess:
      return "Success";

    case TestPartResult::kNonFatalFailure:
    case TestPartResult::kFatalFailure:
#ifdef _MSC_VER
      return "error: ";
#else
      return "Failure\n";
#endif
    default:
      return "Unknown result type";
  }
}

namespace internal {
namespace {
enum class GTestColor { kDefault, kRed, kGreen, kYellow };
}  // namespace

// Prints a TestPartResult to an std::string.
static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result) {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

// Prints a TestPartResult.
static void PrintTestPartResult(const TestPartResult& test_part_result) {
  const std::string& result =
      PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

// class PrettyUnitTestResultPrinter
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW

// Returns the character attribute for the given color.
static WORD GetColorAttribute(GTestColor color) {
  switch (color) {
    case GTestColor::kRed:
      return FOREGROUND_RED;
    case GTestColor::kGreen:
      return FOREGROUND_GREEN;
    case GTestColor::kYellow:
      return FOREGROUND_RED | FOREGROUND_GREEN;
    default:           return 0;
  }
}

static int GetBitOffset(WORD color_mask) {
  if (color_mask == 0) return 0;

  int bitOffset = 0;
  while ((color_mask & 1) == 0) {
    color_mask >>= 1;
    ++bitOffset;
  }
  return bitOffset;
}

static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
  // Let's reuse the BG
  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
                                      BACKGROUND_RED | BACKGROUND_INTENSITY;
  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
                                      FOREGROUND_RED | FOREGROUND_INTENSITY;
  const WORD existing_bg = old_color_attrs & background_mask;

  WORD new_color =
      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
  static const int bg_bitOffset = GetBitOffset(background_mask);
  static const int fg_bitOffset = GetBitOffset(foreground_mask);

  if (((new_color & background_mask) >> bg_bitOffset) ==
      ((new_color & foreground_mask) >> fg_bitOffset)) {
    new_color ^= FOREGROUND_INTENSITY;  // invert intensity
  }
  return new_color;
}

#else

// Returns the ANSI color code for the given color. GTestColor::kDefault is
// an invalid input.
static const char* GetAnsiColorCode(GTestColor color) {
  switch (color) {
    case GTestColor::kRed:
      return "1";
    case GTestColor::kGreen:
      return "2";
    case GTestColor::kYellow:
      return "3";
    default:
      return nullptr;
  }
}

#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE

// Returns true if and only if Google Test should use colors in the output.
bool ShouldUseColor(bool stdout_is_tty) {
  const char* const gtest_color = GTEST_FLAG(color).c_str();

  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
    // On Windows the TERM variable is usually not set, but the
    // console there does support colors.
    return stdout_is_tty;
#else
    // On non-Windows platforms, we rely on the TERM variable.
    const char* const term = posix::GetEnv("TERM");
    const bool term_supports_color =
        String::CStringEquals(term, "xterm") ||
        String::CStringEquals(term, "xterm-color") ||
        String::CStringEquals(term, "xterm-256color") ||
        String::CStringEquals(term, "screen") ||
        String::CStringEquals(term, "screen-256color") ||
        String::CStringEquals(term, "tmux") ||
        String::CStringEquals(term, "tmux-256color") ||
        String::CStringEquals(term, "rxvt-unicode") ||
        String::CStringEquals(term, "rxvt-unicode-256color") ||
        String::CStringEquals(term, "linux") ||
        String::CStringEquals(term, "cygwin");
    return stdout_is_tty && term_supports_color;
#endif  // GTEST_OS_WINDOWS
  }

  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
      String::CStringEquals(gtest_color, "1");
  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
  // value is neither one of these nor "auto", we treat it as "no" to
  // be conservative.
}

// Helpers for printing colored strings to stdout. Note that on Windows, we
// cannot simply emit special characters and have the terminal change colors.
// This routine must actually emit the characters rather than return a string
// that would be colored when printed, as can be done on Linux.

GTEST_ATTRIBUTE_PRINTF_(2, 3)
static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);

#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
  const bool use_color = AlwaysFalse();
#else
  static const bool in_color_mode =
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS

  if (!use_color) {
    vprintf(fmt, args);
    va_end(args);
    return;
  }

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
  const WORD old_color_attrs = buffer_info.wAttributes;
  const WORD new_color = GetNewColor(color, old_color_attrs);

  // We need to flush the stream buffers into the console before each
  // SetConsoleTextAttribute call lest it affect the text that is already
  // printed but has not yet reached the console.
  fflush(stdout);
  SetConsoleTextAttribute(stdout_handle, new_color);

  vprintf(fmt, args);

  fflush(stdout);
  // Restores the text color.
  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
  printf("\033[0;3%sm", GetAnsiColorCode(color));
  vprintf(fmt, args);
  printf("\033[m");  // Resets the terminal to default.
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  va_end(args);
}

// Text printed in Google Test's text output and --gtest_list_tests
// output to label the type parameter and value parameter for a test.
static const char kTypeParamLabel[] = "TypeParam";
static const char kValueParamLabel[] = "GetParam()";

static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
  const char* const type_param = test_info.type_param();
  const char* const value_param = test_info.value_param();

  if (type_param != nullptr || value_param != nullptr) {
    printf(", where ");
    if (type_param != nullptr) {
      printf("%s = %s", kTypeParamLabel, type_param);
      if (value_param != nullptr) printf(" and ");
    }
    if (value_param != nullptr) {
      printf("%s = %s", kValueParamLabel, value_param);
    }
  }
}

// This class implements the TestEventListener interface.
//
// Class PrettyUnitTestResultPrinter is copyable.
class PrettyUnitTestResultPrinter : public TestEventListener {
 public:
  PrettyUnitTestResultPrinter() {}
  static void PrintTestName(const char* test_suite, const char* test) {
    printf("%s.%s", test_suite, test);
  }

  // The following methods override what's in the TestEventListener class.
  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseStart(const TestCase& test_case) override;
#else
  void OnTestSuiteStart(const TestSuite& test_suite) override;
#endif  // OnTestCaseStart

  void OnTestStart(const TestInfo& test_info) override;

  void OnTestPartResult(const TestPartResult& result) override;
  void OnTestEnd(const TestInfo& test_info) override;
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseEnd(const TestCase& test_case) override;
#else
  void OnTestSuiteEnd(const TestSuite& test_suite) override;
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}

 private:
  static void PrintFailedTests(const UnitTest& unit_test);
  static void PrintFailedTestSuites(const UnitTest& unit_test);
  static void PrintSkippedTests(const UnitTest& unit_test);
};

  // Fired before each iteration of tests starts.
void PrettyUnitTestResultPrinter::OnTestIterationStart(
    const UnitTest& unit_test, int iteration) {
  if (GTEST_FLAG(repeat) != 1)
    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);

  const char* const filter = GTEST_FLAG(filter).c_str();

  // Prints the filter if it's not *.  This reminds the user that some
  // tests may be skipped.
  if (!String::CStringEquals(filter, kUniversalFilter)) {
    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
                  filter);
  }

  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
                  static_cast<int>(shard_index) + 1,
                  internal::posix::GetEnv(kTestTotalShards));
  }

  if (GTEST_FLAG(shuffle)) {
    ColoredPrintf(GTestColor::kYellow,
                  "Note: Randomizing tests' orders with a seed of %d .\n",
                  unit_test.random_seed());
  }

  ColoredPrintf(GTestColor::kGreen, "[==========] ");
  printf("Running %s from %s.\n",
         FormatTestCount(unit_test.test_to_run_count()).c_str(),
         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
  fflush(stdout);
}

void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
    const UnitTest& /*unit_test*/) {
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("Global test environment set-up.\n");
  fflush(stdout);
}

#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("%s from %s", counts.c_str(), test_case.name());
  if (test_case.type_param() == nullptr) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
  }
  fflush(stdout);
}
#else
void PrettyUnitTestResultPrinter::OnTestSuiteStart(
    const TestSuite& test_suite) {
  const std::string counts =
      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("%s from %s", counts.c_str(), test_suite.name());
  if (test_suite.type_param() == nullptr) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
  }
  fflush(stdout);
}
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
  PrintTestName(test_info.test_suite_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Called after an assertion failure.
void PrettyUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  switch (result.type()) {
    // If the test part succeeded, we don't need to do anything.
    case TestPartResult::kSuccess:
      return;
    default:
      // Print failure message from the assertion
      // (e.g. expected this and got that).
      PrintTestPartResult(result);
      fflush(stdout);
  }
}

void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Passed()) {
    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
  } else if (test_info.result()->Skipped()) {
    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
  } else {
    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
  }
  PrintTestName(test_info.test_suite_name(), test_info.name());
  if (test_info.result()->Failed())
    PrintFullTestCommentIfPresent(test_info);

  if (GTEST_FLAG(print_time)) {
    printf(" (%s ms)\n", internal::StreamableToString(
           test_info.result()->elapsed_time()).c_str());
  } else {
    printf("\n");
  }
  fflush(stdout);
}

#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
  if (!GTEST_FLAG(print_time)) return;

  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
         internal::StreamableToString(test_case.elapsed_time()).c_str());
  fflush(stdout);
}
#else
void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
  if (!GTEST_FLAG(print_time)) return;

  const std::string counts =
      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
         internal::StreamableToString(test_suite.elapsed_time()).c_str());
  fflush(stdout);
}
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
    const UnitTest& /*unit_test*/) {
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("Global test environment tear-down\n");
  fflush(stdout);
}

// Internal helper for printing the list of failed tests.
void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
  const int failed_test_count = unit_test.failed_test_count();
  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
  printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());

  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
      continue;
    }
    for (int j = 0; j < test_suite.total_test_count(); ++j) {
      const TestInfo& test_info = *test_suite.GetTestInfo(j);
      if (!test_info.should_run() || !test_info.result()->Failed()) {
        continue;
      }
      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
      printf("%s.%s", test_suite.name(), test_info.name());
      PrintFullTestCommentIfPresent(test_info);
      printf("\n");
    }
  }
  printf("\n%2d FAILED %s\n", failed_test_count,
         failed_test_count == 1 ? "TEST" : "TESTS");
}

// Internal helper for printing the list of test suite failures not covered by
// PrintFailedTests.
void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
    const UnitTest& unit_test) {
  int suite_failure_count = 0;
  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
    if (!test_suite.should_run()) {
      continue;
    }
    if (test_suite.ad_hoc_test_result().Failed()) {
      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
      ++suite_failure_count;
    }
  }
  if (suite_failure_count > 0) {
    printf("\n%2d FAILED TEST %s\n", suite_failure_count,
           suite_failure_count == 1 ? "SUITE" : "SUITES");
  }
}

// Internal helper for printing the list of skipped tests.
void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
  const int skipped_test_count = unit_test.skipped_test_count();
  if (skipped_test_count == 0) {
    return;
  }

  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
      continue;
    }
    for (int j = 0; j < test_suite.total_test_count(); ++j) {
      const TestInfo& test_info = *test_suite.GetTestInfo(j);
      if (!test_info.should_run() || !test_info.result()->Skipped()) {
        continue;
      }
      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
      printf("%s.%s", test_suite.name(), test_info.name());
      printf("\n");
    }
  }
}

void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                     int /*iteration*/) {
  ColoredPrintf(GTestColor::kGreen, "[==========] ");
  printf("%s from %s ran.",
         FormatTestCount(unit_test.test_to_run_count()).c_str(),
         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
  if (GTEST_FLAG(print_time)) {
    printf(" (%s ms total)",
           internal::StreamableToString(unit_test.elapsed_time()).c_str());
  }
  printf("\n");
  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());

  const int skipped_test_count = unit_test.skipped_test_count();
  if (skipped_test_count > 0) {
    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
    PrintSkippedTests(unit_test);
  }

  if (!unit_test.Passed()) {
    PrintFailedTests(unit_test);
    PrintFailedTestSuites(unit_test);
  }

  int num_disabled = unit_test.reportable_disabled_test_count();
  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
    if (unit_test.Passed()) {
      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
    }
    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
  }
  // Ensure that Google Test output is printed before, e.g., heapchecker output.
  fflush(stdout);
}

// End PrettyUnitTestResultPrinter

// This class implements the TestEventListener interface.
//
// Class BriefUnitTestResultPrinter is copyable.
class BriefUnitTestResultPrinter : public TestEventListener {
 public:
  BriefUnitTestResultPrinter() {}
  static void PrintTestName(const char* test_suite, const char* test) {
    printf("%s.%s", test_suite, test);
  }

  // The following methods override what's in the TestEventListener class.
  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationStart(const UnitTest& /*unit_test*/,
                            int /*iteration*/) override {}
  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
#else
  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
#endif  // OnTestCaseStart

  void OnTestStart(const TestInfo& /*test_info*/) override {}

  void OnTestPartResult(const TestPartResult& result) override;
  void OnTestEnd(const TestInfo& test_info) override;
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
#else
  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
};

// Called after an assertion failure.
void BriefUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  switch (result.type()) {
    // If the test part succeeded, we don't need to do anything.
    case TestPartResult::kSuccess:
      return;
    default:
      // Print failure message from the assertion
      // (e.g. expected this and got that).
      PrintTestPartResult(result);
      fflush(stdout);
  }
}

void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Failed()) {
    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
    PrintTestName(test_info.test_suite_name(), test_info.name());
    PrintFullTestCommentIfPresent(test_info);

    if (GTEST_FLAG(print_time)) {
      printf(" (%s ms)\n",
             internal::StreamableToString(test_info.result()->elapsed_time())
                 .c_str());
    } else {
      printf("\n");
    }
    fflush(stdout);
  }
}

void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                    int /*iteration*/) {
  ColoredPrintf(GTestColor::kGreen, "[==========] ");
  printf("%s from %s ran.",
         FormatTestCount(unit_test.test_to_run_count()).c_str(),
         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
  if (GTEST_FLAG(print_time)) {
    printf(" (%s ms total)",
           internal::StreamableToString(unit_test.elapsed_time()).c_str());
  }
  printf("\n");
  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());

  const int skipped_test_count = unit_test.skipped_test_count();
  if (skipped_test_count > 0) {
    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
    printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
  }

  int num_disabled = unit_test.reportable_disabled_test_count();
  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
    if (unit_test.Passed()) {
      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
    }
    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
  }
  // Ensure that Google Test output is printed before, e.g., heapchecker output.
  fflush(stdout);
}

// End BriefUnitTestResultPrinter

// class TestEventRepeater
//
// This class forwards events to other event listeners.
class TestEventRepeater : public TestEventListener {
 public:
  TestEventRepeater() : forwarding_enabled_(true) {}
  ~TestEventRepeater() override;
  void Append(TestEventListener *listener);
  TestEventListener* Release(TestEventListener* listener);

  // Controls whether events will be forwarded to listeners_. Set to false
  // in death test child processes.
  bool forwarding_enabled() const { return forwarding_enabled_; }
  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }

  void OnTestProgramStart(const UnitTest& unit_test) override;
  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
  void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseStart(const TestSuite& parameter) override;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestSuiteStart(const TestSuite& parameter) override;
  void OnTestStart(const TestInfo& test_info) override;
  void OnTestPartResult(const TestPartResult& result) override;
  void OnTestEnd(const TestInfo& test_info) override;
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseEnd(const TestCase& parameter) override;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestSuiteEnd(const TestSuite& parameter) override;
  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
  void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
  void OnTestProgramEnd(const UnitTest& unit_test) override;

 private:
  // Controls whether events will be forwarded to listeners_. Set to false
  // in death test child processes.
  bool forwarding_enabled_;
  // The list of listeners that receive events.
  std::vector<TestEventListener*> listeners_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
};

TestEventRepeater::~TestEventRepeater() {
  ForEach(listeners_, Delete<TestEventListener>);
}

void TestEventRepeater::Append(TestEventListener *listener) {
  listeners_.push_back(listener);
}

TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
  for (size_t i = 0; i < listeners_.size(); ++i) {
    if (listeners_[i] == listener) {
      listeners_.erase(listeners_.begin() + static_cast<int>(i));
      return listener;
    }
  }

  return nullptr;
}

// Since most methods are very similar, use macros to reduce boilerplate.
// This defines a member that forwards the call to all listeners.
#define GTEST_REPEATER_METHOD_(Name, Type) \
void TestEventRepeater::Name(const Type& parameter) { \
  if (forwarding_enabled_) { \
    for (size_t i = 0; i < listeners_.size(); i++) { \
      listeners_[i]->Name(parameter); \
    } \
  } \
}
// This defines a member that forwards the call to all listeners in reverse
// order.
#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \
  void TestEventRepeater::Name(const Type& parameter) { \
    if (forwarding_enabled_) {                          \
      for (size_t i = listeners_.size(); i != 0; i--) { \
        listeners_[i - 1]->Name(parameter);             \
      }                                                 \
    }                                                   \
  }

GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)

#undef GTEST_REPEATER_METHOD_
#undef GTEST_REVERSE_REPEATER_METHOD_

void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
                                             int iteration) {
  if (forwarding_enabled_) {
    for (size_t i = 0; i < listeners_.size(); i++) {
      listeners_[i]->OnTestIterationStart(unit_test, iteration);
    }
  }
}

void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
                                           int iteration) {
  if (forwarding_enabled_) {
    for (size_t i = listeners_.size(); i > 0; i--) {
      listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
    }
  }
}

// End TestEventRepeater

// This class generates an XML output file.
class XmlUnitTestResultPrinter : public EmptyTestEventListener {
 public:
  explicit XmlUnitTestResultPrinter(const char* output_file);

  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);

  // Prints an XML summary of all unit tests.
  static void PrintXmlTestsList(std::ostream* stream,
                                const std::vector<TestSuite*>& test_suites);

 private:
  // Is c a whitespace character that is normalized to a space character
  // when it appears in an XML attribute value?
  static bool IsNormalizableWhitespace(char c) {
    return c == 0x9 || c == 0xA || c == 0xD;
  }

  // May c appear in a well-formed XML document?
  static bool IsValidXmlCharacter(char c) {
    return IsNormalizableWhitespace(c) || c >= 0x20;
  }

  // Returns an XML-escaped copy of the input string str.  If
  // is_attribute is true, the text is meant to appear as an attribute
  // value, and normalizable whitespace is preserved by replacing it
  // with character references.
  static std::string EscapeXml(const std::string& str, bool is_attribute);

  // Returns the given string with all characters invalid in XML removed.
  static std::string RemoveInvalidXmlCharacters(const std::string& str);

  // Convenience wrapper around EscapeXml when str is an attribute value.
  static std::string EscapeXmlAttribute(const std::string& str) {
    return EscapeXml(str, true);
  }

  // Convenience wrapper around EscapeXml when str is not an attribute value.
  static std::string EscapeXmlText(const char* str) {
    return EscapeXml(str, false);
  }

  // Verifies that the given attribute belongs to the given element and
  // streams the attribute as XML.
  static void OutputXmlAttribute(std::ostream* stream,
                                 const std::string& element_name,
                                 const std::string& name,
                                 const std::string& value);

  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);

  // Streams a test suite XML stanza containing the given test result.
  //
  // Requires: result.Failed()
  static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
                                              const TestResult& result);

  // Streams an XML representation of a TestResult object.
  static void OutputXmlTestResult(::std::ostream* stream,
                                  const TestResult& result);

  // Streams an XML representation of a TestInfo object.
  static void OutputXmlTestInfo(::std::ostream* stream,
                                const char* test_suite_name,
                                const TestInfo& test_info);

  // Prints an XML representation of a TestSuite object
  static void PrintXmlTestSuite(::std::ostream* stream,
                                const TestSuite& test_suite);

  // Prints an XML summary of unit_test to output stream out.
  static void PrintXmlUnitTest(::std::ostream* stream,
                               const UnitTest& unit_test);

  // Produces a string representing the test properties in a result as space
  // delimited XML attributes based on the property key="value" pairs.
  // When the std::string is not empty, it includes a space at the beginning,
  // to delimit this attribute from prior attributes.
  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);

  // Streams an XML representation of the test properties of a TestResult
  // object.
  static void OutputXmlTestProperties(std::ostream* stream,
                                      const TestResult& result);

  // The output file.
  const std::string output_file_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
};

// Creates a new XmlUnitTestResultPrinter.
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
    : output_file_(output_file) {
  if (output_file_.empty()) {
    GTEST_LOG_(FATAL) << "XML output file may not be null";
  }
}

// Called after the unit test ends.
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlUnitTest(&stream, unit_test);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
    const std::vector<TestSuite*>& test_suites) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlTestsList(&stream, test_suites);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Returns an XML-escaped copy of the input string str.  If is_attribute
// is true, the text is meant to appear as an attribute value, and
// normalizable whitespace is preserved by replacing it with character
// references.
//
// Invalid XML characters in str, if any, are stripped from the output.
// It is expected that most, if not all, of the text processed by this
// module will consist of ordinary English text.
// If this module is ever modified to produce version 1.1 XML output,
// most invalid characters can be retained using character references.
std::string XmlUnitTestResultPrinter::EscapeXml(
    const std::string& str, bool is_attribute) {
  Message m;

  for (size_t i = 0; i < str.size(); ++i) {
    const char ch = str[i];
    switch (ch) {
      case '<':
        m << "&lt;";
        break;
      case '>':
        m << "&gt;";
        break;
      case '&':
        m << "&amp;";
        break;
      case '\'':
        if (is_attribute)
          m << "&apos;";
        else
          m << '\'';
        break;
      case '"':
        if (is_attribute)
          m << "&quot;";
        else
          m << '"';
        break;
      default:
        if (IsValidXmlCharacter(ch)) {
          if (is_attribute && IsNormalizableWhitespace(ch))
            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
              << ";";
          else
            m << ch;
        }
        break;
    }
  }

  return m.GetString();
}

// Returns the given string with all characters invalid in XML removed.
// Currently invalid characters are dropped from the string. An
// alternative is to replace them with certain characters such as . or ?.
std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
    const std::string& str) {
  std::string output;
  output.reserve(str.size());
  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    if (IsValidXmlCharacter(*it))
      output.push_back(*it);

  return output;
}

// The following routines generate an XML representation of a UnitTest
// object.
// GOOGLETEST_CM0009 DO NOT DELETE
//
// This is how Google Test concepts map to the DTD:
//
// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object
//     <testcase name="test-name">     <-- corresponds to a TestInfo object
//       <failure message="...">...</failure>
//       <failure message="...">...</failure>
//       <failure message="...">...</failure>
//                                     <-- individual assertion failures
//     </testcase>
//   </testsuite>
// </testsuites>

// Formats the given time in milliseconds as seconds.
std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
  ::std::stringstream ss;
  ss << (static_cast<double>(ms) * 1e-3);
  return ss.str();
}

static bool PortableLocaltime(time_t seconds, struct tm* out) {
#if defined(_MSC_VER)
  return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
  // Windows' localtime(), which has a thread-local tm buffer.
  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
  if (tm_ptr == nullptr) return false;
  *out = *tm_ptr;
  return true;
#elif defined(__STDC_LIB_EXT1__)
  // Uses localtime_s when available as localtime_r is only available from
  // C23 standard.
  return localtime_s(&seconds, out) != nullptr;
#else
  return localtime_r(&seconds, out) != nullptr;
#endif
}

// Converts the given epoch time in milliseconds to a date string in the ISO
// 8601 format, without the timezone information.
std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
  struct tm time_struct;
  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
    return "";
  // YYYY-MM-DDThh:mm:ss.sss
  return StreamableToString(time_struct.tm_year + 1900) + "-" +
      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
      String::FormatIntWidth2(time_struct.tm_min) + ":" +
      String::FormatIntWidth2(time_struct.tm_sec) + "." +
      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
}

// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                     const char* data) {
  const char* segment = data;
  *stream << "<![CDATA[";
  for (;;) {
    const char* const next_segment = strstr(segment, "]]>");
    if (next_segment != nullptr) {
      stream->write(
          segment, static_cast<std::streamsize>(next_segment - segment));
      *stream << "]]>]]&gt;<![CDATA[";
      segment = next_segment + strlen("]]>");
    } else {
      *stream << segment;
      break;
    }
  }
  *stream << "]]>";
}

void XmlUnitTestResultPrinter::OutputXmlAttribute(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value) {
  const std::vector<std::string>& allowed_names =
      GetReservedOutputAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Attribute " << name << " is not allowed for element <" << element_name
      << ">.";

  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
}

// Streams a test suite XML stanza containing the given test result.
void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
    ::std::ostream* stream, const TestResult& result) {
  // Output the boilerplate for a minimal test suite with one test.
  *stream << "  <testsuite";
  OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
  OutputXmlAttribute(stream, "testsuite", "tests", "1");
  OutputXmlAttribute(stream, "testsuite", "failures", "1");
  OutputXmlAttribute(stream, "testsuite", "disabled", "0");
  OutputXmlAttribute(stream, "testsuite", "skipped", "0");
  OutputXmlAttribute(stream, "testsuite", "errors", "0");
  OutputXmlAttribute(stream, "testsuite", "time",
                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
  OutputXmlAttribute(
      stream, "testsuite", "timestamp",
      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
  *stream << ">";

  // Output the boilerplate for a minimal test case with a single test.
  *stream << "    <testcase";
  OutputXmlAttribute(stream, "testcase", "name", "");
  OutputXmlAttribute(stream, "testcase", "status", "run");
  OutputXmlAttribute(stream, "testcase", "result", "completed");
  OutputXmlAttribute(stream, "testcase", "classname", "");
  OutputXmlAttribute(stream, "testcase", "time",
                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
  OutputXmlAttribute(
      stream, "testcase", "timestamp",
      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));

  // Output the actual test result.
  OutputXmlTestResult(stream, result);

  // Complete the test suite.
  *stream << "  </testsuite>\n";
}

// Prints an XML representation of a TestInfo object.
void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
                                                 const char* test_suite_name,
                                                 const TestInfo& test_info) {
  const TestResult& result = *test_info.result();
  const std::string kTestsuite = "testcase";

  if (test_info.is_in_another_shard()) {
    return;
  }

  *stream << "    <testcase";
  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());

  if (test_info.value_param() != nullptr) {
    OutputXmlAttribute(stream, kTestsuite, "value_param",
                       test_info.value_param());
  }
  if (test_info.type_param() != nullptr) {
    OutputXmlAttribute(stream, kTestsuite, "type_param",
                       test_info.type_param());
  }
  if (GTEST_FLAG(list_tests)) {
    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
    OutputXmlAttribute(stream, kTestsuite, "line",
                       StreamableToString(test_info.line()));
    *stream << " />\n";
    return;
  }

  OutputXmlAttribute(stream, kTestsuite, "status",
                     test_info.should_run() ? "run" : "notrun");
  OutputXmlAttribute(stream, kTestsuite, "result",
                     test_info.should_run()
                         ? (result.Skipped() ? "skipped" : "completed")
                         : "suppressed");
  OutputXmlAttribute(stream, kTestsuite, "time",
                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
  OutputXmlAttribute(
      stream, kTestsuite, "timestamp",
      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);

  OutputXmlTestResult(stream, result);
}

void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
                                                   const TestResult& result) {
  int failures = 0;
  int skips = 0;
  for (int i = 0; i < result.total_part_count(); ++i) {
    const TestPartResult& part = result.GetTestPartResult(i);
    if (part.failed()) {
      if (++failures == 1 && skips == 0) {
        *stream << ">\n";
      }
      const std::string location =
          internal::FormatCompilerIndependentFileLocation(part.file_name(),
                                                          part.line_number());
      const std::string summary = location + "\n" + part.summary();
      *stream << "      <failure message=\""
              << EscapeXmlAttribute(summary)
              << "\" type=\"\">";
      const std::string detail = location + "\n" + part.message();
      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
      *stream << "</failure>\n";
    } else if (part.skipped()) {
      if (++skips == 1 && failures == 0) {
        *stream << ">\n";
      }
      const std::string location =
          internal::FormatCompilerIndependentFileLocation(part.file_name(),
                                                          part.line_number());
      const std::string summary = location + "\n" + part.summary();
      *stream << "      <skipped message=\""
              << EscapeXmlAttribute(summary.c_str()) << "\">";
      const std::string detail = location + "\n" + part.message();
      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
      *stream << "</skipped>\n";
    }
  }

  if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
    *stream << " />\n";
  } else {
    if (failures == 0 && skips == 0) {
      *stream << ">\n";
    }
    OutputXmlTestProperties(stream, result);
    *stream << "    </testcase>\n";
  }
}

// Prints an XML representation of a TestSuite object
void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
                                                 const TestSuite& test_suite) {
  const std::string kTestsuite = "testsuite";
  *stream << "  <" << kTestsuite;
  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
  OutputXmlAttribute(stream, kTestsuite, "tests",
                     StreamableToString(test_suite.reportable_test_count()));
  if (!GTEST_FLAG(list_tests)) {
    OutputXmlAttribute(stream, kTestsuite, "failures",
                       StreamableToString(test_suite.failed_test_count()));
    OutputXmlAttribute(
        stream, kTestsuite, "disabled",
        StreamableToString(test_suite.reportable_disabled_test_count()));
    OutputXmlAttribute(stream, kTestsuite, "skipped",
                       StreamableToString(test_suite.skipped_test_count()));

    OutputXmlAttribute(stream, kTestsuite, "errors", "0");

    OutputXmlAttribute(stream, kTestsuite, "time",
                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
    OutputXmlAttribute(
        stream, kTestsuite, "timestamp",
        FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
  }
  *stream << ">\n";
  for (int i = 0; i < test_suite.total_test_count(); ++i) {
    if (test_suite.GetTestInfo(i)->is_reportable())
      OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
  }
  *stream << "  </" << kTestsuite << ">\n";
}

// Prints an XML summary of unit_test to output stream out.
void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
                                                const UnitTest& unit_test) {
  const std::string kTestsuites = "testsuites";

  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  *stream << "<" << kTestsuites;

  OutputXmlAttribute(stream, kTestsuites, "tests",
                     StreamableToString(unit_test.reportable_test_count()));
  OutputXmlAttribute(stream, kTestsuites, "failures",
                     StreamableToString(unit_test.failed_test_count()));
  OutputXmlAttribute(
      stream, kTestsuites, "disabled",
      StreamableToString(unit_test.reportable_disabled_test_count()));
  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
  OutputXmlAttribute(stream, kTestsuites, "time",
                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
  OutputXmlAttribute(
      stream, kTestsuites, "timestamp",
      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));

  if (GTEST_FLAG(shuffle)) {
    OutputXmlAttribute(stream, kTestsuites, "random_seed",
                       StreamableToString(unit_test.random_seed()));
  }
  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());

  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
  *stream << ">\n";

  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
      PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
  }

  // If there was a test failure outside of one of the test suites (like in a
  // test environment) include that in the output.
  if (unit_test.ad_hoc_test_result().Failed()) {
    OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
  }

  *stream << "</" << kTestsuites << ">\n";
}

void XmlUnitTestResultPrinter::PrintXmlTestsList(
    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
  const std::string kTestsuites = "testsuites";

  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  *stream << "<" << kTestsuites;

  int total_tests = 0;
  for (auto test_suite : test_suites) {
    total_tests += test_suite->total_test_count();
  }
  OutputXmlAttribute(stream, kTestsuites, "tests",
                     StreamableToString(total_tests));
  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
  *stream << ">\n";

  for (auto test_suite : test_suites) {
    PrintXmlTestSuite(stream, *test_suite);
  }
  *stream << "</" << kTestsuites << ">\n";
}

// Produces a string representing the test properties in a result as space
// delimited XML attributes based on the property key="value" pairs.
std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    const TestResult& result) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << " " << property.key() << "="
        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
  }
  return attributes.GetString();
}

void XmlUnitTestResultPrinter::OutputXmlTestProperties(
    std::ostream* stream, const TestResult& result) {
  const std::string kProperties = "properties";
  const std::string kProperty = "property";

  if (result.test_property_count() <= 0) {
    return;
  }

  *stream << "<" << kProperties << ">\n";
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    *stream << "<" << kProperty;
    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
    *stream << "/>\n";
  }
  *stream << "</" << kProperties << ">\n";
}

// End XmlUnitTestResultPrinter

// This class generates an JSON output file.
class JsonUnitTestResultPrinter : public EmptyTestEventListener {
 public:
  explicit JsonUnitTestResultPrinter(const char* output_file);

  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;

  // Prints an JSON summary of all unit tests.
  static void PrintJsonTestList(::std::ostream* stream,
                                const std::vector<TestSuite*>& test_suites);

 private:
  // Returns an JSON-escaped copy of the input string str.
  static std::string EscapeJson(const std::string& str);

  //// Verifies that the given attribute belongs to the given element and
  //// streams the attribute as JSON.
  static void OutputJsonKey(std::ostream* stream,
                            const std::string& element_name,
                            const std::string& name,
                            const std::string& value,
                            const std::string& indent,
                            bool comma = true);
  static void OutputJsonKey(std::ostream* stream,
                            const std::string& element_name,
                            const std::string& name,
                            int value,
                            const std::string& indent,
                            bool comma = true);

  // Streams a test suite JSON stanza containing the given test result.
  //
  // Requires: result.Failed()
  static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
                                               const TestResult& result);

  // Streams a JSON representation of a TestResult object.
  static void OutputJsonTestResult(::std::ostream* stream,
                                   const TestResult& result);

  // Streams a JSON representation of a TestInfo object.
  static void OutputJsonTestInfo(::std::ostream* stream,
                                 const char* test_suite_name,
                                 const TestInfo& test_info);

  // Prints a JSON representation of a TestSuite object
  static void PrintJsonTestSuite(::std::ostream* stream,
                                 const TestSuite& test_suite);

  // Prints a JSON summary of unit_test to output stream out.
  static void PrintJsonUnitTest(::std::ostream* stream,
                                const UnitTest& unit_test);

  // Produces a string representing the test properties in a result as
  // a JSON dictionary.
  static std::string TestPropertiesAsJson(const TestResult& result,
                                          const std::string& indent);

  // The output file.
  const std::string output_file_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
};

// Creates a new JsonUnitTestResultPrinter.
JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
    : output_file_(output_file) {
  if (output_file_.empty()) {
    GTEST_LOG_(FATAL) << "JSON output file may not be null";
  }
}

void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* jsonout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintJsonUnitTest(&stream, unit_test);
  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
  fclose(jsonout);
}

// Returns an JSON-escaped copy of the input string str.
std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
  Message m;

  for (size_t i = 0; i < str.size(); ++i) {
    const char ch = str[i];
    switch (ch) {
      case '\\':
      case '"':
      case '/':
        m << '\\' << ch;
        break;
      case '\b':
        m << "\\b";
        break;
      case '\t':
        m << "\\t";
        break;
      case '\n':
        m << "\\n";
        break;
      case '\f':
        m << "\\f";
        break;
      case '\r':
        m << "\\r";
        break;
      default:
        if (ch < ' ') {
          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
        } else {
          m << ch;
        }
        break;
    }
  }

  return m.GetString();
}

// The following routines generate an JSON representation of a UnitTest
// object.

// Formats the given time in milliseconds as seconds.
static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
  ::std::stringstream ss;
  ss << (static_cast<double>(ms) * 1e-3) << "s";
  return ss.str();
}

// Converts the given epoch time in milliseconds to a date string in the
// RFC3339 format, without the timezone information.
static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
  struct tm time_struct;
  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
    return "";
  // YYYY-MM-DDThh:mm:ss
  return StreamableToString(time_struct.tm_year + 1900) + "-" +
      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
      String::FormatIntWidth2(time_struct.tm_min) + ":" +
      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
}

static inline std::string Indent(size_t width) {
  return std::string(width, ' ');
}

void JsonUnitTestResultPrinter::OutputJsonKey(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value,
    const std::string& indent,
    bool comma) {
  const std::vector<std::string>& allowed_names =
      GetReservedOutputAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Key \"" << name << "\" is not allowed for value \"" << element_name
      << "\".";

  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
  if (comma)
    *stream << ",\n";
}

void JsonUnitTestResultPrinter::OutputJsonKey(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    int value,
    const std::string& indent,
    bool comma) {
  const std::vector<std::string>& allowed_names =
      GetReservedOutputAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Key \"" << name << "\" is not allowed for value \"" << element_name
      << "\".";

  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
  if (comma)
    *stream << ",\n";
}

// Streams a test suite JSON stanza containing the given test result.
void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
    ::std::ostream* stream, const TestResult& result) {
  // Output the boilerplate for a new test suite.
  *stream << Indent(4) << "{\n";
  OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
  OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
  if (!GTEST_FLAG(list_tests)) {
    OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
    OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
    OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
    OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
    OutputJsonKey(stream, "testsuite", "time",
                  FormatTimeInMillisAsDuration(result.elapsed_time()),
                  Indent(6));
    OutputJsonKey(stream, "testsuite", "timestamp",
                  FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
                  Indent(6));
  }
  *stream << Indent(6) << "\"testsuite\": [\n";

  // Output the boilerplate for a new test case.
  *stream << Indent(8) << "{\n";
  OutputJsonKey(stream, "testcase", "name", "", Indent(10));
  OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
  OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
  OutputJsonKey(stream, "testcase", "timestamp",
                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
                Indent(10));
  OutputJsonKey(stream, "testcase", "time",
                FormatTimeInMillisAsDuration(result.elapsed_time()),
                Indent(10));
  OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
  *stream << TestPropertiesAsJson(result, Indent(10));

  // Output the actual test result.
  OutputJsonTestResult(stream, result);

  // Finish the test suite.
  *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
}

// Prints a JSON representation of a TestInfo object.
void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
                                                   const char* test_suite_name,
                                                   const TestInfo& test_info) {
  const TestResult& result = *test_info.result();
  const std::string kTestsuite = "testcase";
  const std::string kIndent = Indent(10);

  *stream << Indent(8) << "{\n";
  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);

  if (test_info.value_param() != nullptr) {
    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
                  kIndent);
  }
  if (test_info.type_param() != nullptr) {
    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
                  kIndent);
  }
  if (GTEST_FLAG(list_tests)) {
    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
    *stream << "\n" << Indent(8) << "}";
    return;
  }

  OutputJsonKey(stream, kTestsuite, "status",
                test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
  OutputJsonKey(stream, kTestsuite, "result",
                test_info.should_run()
                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
                    : "SUPPRESSED",
                kIndent);
  OutputJsonKey(stream, kTestsuite, "timestamp",
                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
                kIndent);
  OutputJsonKey(stream, kTestsuite, "time",
                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
                false);
  *stream << TestPropertiesAsJson(result, kIndent);

  OutputJsonTestResult(stream, result);
}

void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
                                                     const TestResult& result) {
  const std::string kIndent = Indent(10);

  int failures = 0;
  for (int i = 0; i < result.total_part_count(); ++i) {
    const TestPartResult& part = result.GetTestPartResult(i);
    if (part.failed()) {
      *stream << ",\n";
      if (++failures == 1) {
        *stream << kIndent << "\"" << "failures" << "\": [\n";
      }
      const std::string location =
          internal::FormatCompilerIndependentFileLocation(part.file_name(),
                                                          part.line_number());
      const std::string message = EscapeJson(location + "\n" + part.message());
      *stream << kIndent << "  {\n"
              << kIndent << "    \"failure\": \"" << message << "\",\n"
              << kIndent << "    \"type\": \"\"\n"
              << kIndent << "  }";
    }
  }

  if (failures > 0)
    *stream << "\n" << kIndent << "]";
  *stream << "\n" << Indent(8) << "}";
}

// Prints an JSON representation of a TestSuite object
void JsonUnitTestResultPrinter::PrintJsonTestSuite(
    std::ostream* stream, const TestSuite& test_suite) {
  const std::string kTestsuite = "testsuite";
  const std::string kIndent = Indent(6);

  *stream << Indent(4) << "{\n";
  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
                kIndent);
  if (!GTEST_FLAG(list_tests)) {
    OutputJsonKey(stream, kTestsuite, "failures",
                  test_suite.failed_test_count(), kIndent);
    OutputJsonKey(stream, kTestsuite, "disabled",
                  test_suite.reportable_disabled_test_count(), kIndent);
    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
    OutputJsonKey(
        stream, kTestsuite, "timestamp",
        FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
        kIndent);
    OutputJsonKey(stream, kTestsuite, "time",
                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
                  kIndent, false);
    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
            << ",\n";
  }

  *stream << kIndent << "\"" << kTestsuite << "\": [\n";

  bool comma = false;
  for (int i = 0; i < test_suite.total_test_count(); ++i) {
    if (test_suite.GetTestInfo(i)->is_reportable()) {
      if (comma) {
        *stream << ",\n";
      } else {
        comma = true;
      }
      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
    }
  }
  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
}

// Prints a JSON summary of unit_test to output stream out.
void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
                                                  const UnitTest& unit_test) {
  const std::string kTestsuites = "testsuites";
  const std::string kIndent = Indent(2);
  *stream << "{\n";

  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
                kIndent);
  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
                kIndent);
  OutputJsonKey(stream, kTestsuites, "disabled",
                unit_test.reportable_disabled_test_count(), kIndent);
  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
  if (GTEST_FLAG(shuffle)) {
    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
                  kIndent);
  }
  OutputJsonKey(stream, kTestsuites, "timestamp",
                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
                kIndent);
  OutputJsonKey(stream, kTestsuites, "time",
                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
                false);

  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
          << ",\n";

  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
  *stream << kIndent << "\"" << kTestsuites << "\": [\n";

  bool comma = false;
  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
      if (comma) {
        *stream << ",\n";
      } else {
        comma = true;
      }
      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
    }
  }

  // If there was a test failure outside of one of the test suites (like in a
  // test environment) include that in the output.
  if (unit_test.ad_hoc_test_result().Failed()) {
    OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
  }

  *stream << "\n" << kIndent << "]\n" << "}\n";
}

void JsonUnitTestResultPrinter::PrintJsonTestList(
    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
  const std::string kTestsuites = "testsuites";
  const std::string kIndent = Indent(2);
  *stream << "{\n";
  int total_tests = 0;
  for (auto test_suite : test_suites) {
    total_tests += test_suite->total_test_count();
  }
  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);

  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
  *stream << kIndent << "\"" << kTestsuites << "\": [\n";

  for (size_t i = 0; i < test_suites.size(); ++i) {
    if (i != 0) {
      *stream << ",\n";
    }
    PrintJsonTestSuite(stream, *test_suites[i]);
  }

  *stream << "\n"
          << kIndent << "]\n"
          << "}\n";
}
// Produces a string representing the test properties in a result as
// a JSON dictionary.
std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
    const TestResult& result, const std::string& indent) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << ",\n" << indent << "\"" << property.key() << "\": "
               << "\"" << EscapeJson(property.value()) << "\"";
  }
  return attributes.GetString();
}

// End JsonUnitTestResultPrinter

#if GTEST_CAN_STREAM_RESULTS_

// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
// replaces them by "%xx" where xx is their hexadecimal value. For
// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
// in both time and space -- important as the input str may contain an
// arbitrarily long test failure message and stack trace.
std::string StreamingListener::UrlEncode(const char* str) {
  std::string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
        break;
      default:
        result.push_back(ch);
        break;
    }
  }
  return result;
}

void StreamingListener::SocketWriter::MakeConnection() {
  GTEST_CHECK_(sockfd_ == -1)
      << "MakeConnection() can't be called when there is already a connection.";

  addrinfo hints;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
  hints.ai_socktype = SOCK_STREAM;
  addrinfo* servinfo = nullptr;

  // Use the getaddrinfo() to get a linked list of IP addresses for
  // the given host name.
  const int error_num = getaddrinfo(
      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
  if (error_num != 0) {
    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
                        << gai_strerror(error_num);
  }

  // Loop through all the results and connect to the first we can.
  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
       cur_addr = cur_addr->ai_next) {
    sockfd_ = socket(
        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
    if (sockfd_ != -1) {
      // Connect the client socket to the server socket.
      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
        close(sockfd_);
        sockfd_ = -1;
      }
    }
  }

  freeaddrinfo(servinfo);  // all done with this structure

  if (sockfd_ == -1) {
    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
                        << host_name_ << ":" << port_num_;
  }
}

// End of class Streaming Listener
#endif  // GTEST_CAN_STREAM_RESULTS__

// class OsStackTraceGetter

const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
    "... " GTEST_NAME_ " internal frames ...";

std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
    GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
  std::string result;

  if (max_depth <= 0) {
    return result;
  }

  max_depth = std::min(max_depth, kMaxStackTraceDepth);

  std::vector<void*> raw_stack(max_depth);
  // Skips the frames requested by the caller, plus this function.
  const int raw_stack_size =
      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);

  void* caller_frame = nullptr;
  {
    MutexLock lock(&mutex_);
    caller_frame = caller_frame_;
  }

  for (int i = 0; i < raw_stack_size; ++i) {
    if (raw_stack[i] == caller_frame &&
        !GTEST_FLAG(show_internal_stack_frames)) {
      // Add a marker to the trace and stop adding frames.
      absl::StrAppend(&result, kElidedFramesMarker, "\n");
      break;
    }

    char tmp[1024];
    const char* symbol = "(unknown)";
    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
      symbol = tmp;
    }

    char line[1024];
    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol);
    result += line;
  }

  return result;

#else  // !GTEST_HAS_ABSL
  static_cast<void>(max_depth);
  static_cast<void>(skip_count);
  return "";
#endif  // GTEST_HAS_ABSL
}

void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
  void* caller_frame = nullptr;
  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
    caller_frame = nullptr;
  }

  MutexLock lock(&mutex_);
  caller_frame_ = caller_frame;
#endif  // GTEST_HAS_ABSL
}

// A helper class that creates the premature-exit file in its
// constructor and deletes the file in its destructor.
class ScopedPrematureExitFile {
 public:
  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath ?
                                 premature_exit_filepath : "") {
    // If a path to the premature-exit file is specified...
    if (!premature_exit_filepath_.empty()) {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

  ~ScopedPrematureExitFile() {
#if !defined GTEST_OS_ESP8266
    if (!premature_exit_filepath_.empty()) {
      int retval = remove(premature_exit_filepath_.c_str());
      if (retval) {
        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
                          << premature_exit_filepath_ << "\" with error "
                          << retval;
      }
    }
#endif
  }

 private:
  const std::string premature_exit_filepath_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
};

}  // namespace internal

// class TestEventListeners

TestEventListeners::TestEventListeners()
    : repeater_(new internal::TestEventRepeater()),
      default_result_printer_(nullptr),
      default_xml_generator_(nullptr) {}

TestEventListeners::~TestEventListeners() { delete repeater_; }

// Returns the standard listener responsible for the default console
// output.  Can be removed from the listeners list to shut down default
// console output.  Note that removing this object from the listener list
// with Release transfers its ownership to the user.
void TestEventListeners::Append(TestEventListener* listener) {
  repeater_->Append(listener);
}

// Removes the given event listener from the list and returns it.  It then
// becomes the caller's responsibility to delete the listener. Returns
// NULL if the listener is not found in the list.
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = nullptr;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = nullptr;
  return repeater_->Release(listener);
}

// Returns repeater that broadcasts the TestEventListener events to all
// subscribers.
TestEventListener* TestEventListeners::repeater() { return repeater_; }

// Sets the default_result_printer attribute to the provided listener.
// The listener is also added to the listener list and previous
// default_result_printer is removed from it and deleted. The listener can
// also be NULL in which case it will not be added to the list. Does
// nothing if the previous and the current listener objects are the same.
void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
  if (default_result_printer_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_result_printer_);
    default_result_printer_ = listener;
    if (listener != nullptr) Append(listener);
  }
}

// Sets the default_xml_generator attribute to the provided listener.  The
// listener is also added to the listener list and previous
// default_xml_generator is removed from it and deleted. The listener can
// also be NULL in which case it will not be added to the list. Does
// nothing if the previous and the current listener objects are the same.
void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
  if (default_xml_generator_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_xml_generator_);
    default_xml_generator_ = listener;
    if (listener != nullptr) Append(listener);
  }
}

// Controls whether events will be forwarded by the repeater to the
// listeners in the list.
bool TestEventListeners::EventForwardingEnabled() const {
  return repeater_->forwarding_enabled();
}

void TestEventListeners::SuppressEventForwarding() {
  repeater_->set_forwarding_enabled(false);
}

// class UnitTest

// Gets the singleton UnitTest object.  The first time this method is
// called, a UnitTest object is constructed and returned.  Consecutive
// calls will return the same object.
//
// We don't protect this under mutex_ as a user is not supposed to
// call this before main() starts, from which point on the return
// value will never change.
UnitTest* UnitTest::GetInstance() {
  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

#if defined(__BORLANDC__)
  static UnitTest* const instance = new UnitTest;
  return instance;
#else
  static UnitTest instance;
  return &instance;
#endif  // defined(__BORLANDC__)
}

// Gets the number of successful test suites.
int UnitTest::successful_test_suite_count() const {
  return impl()->successful_test_suite_count();
}

// Gets the number of failed test suites.
int UnitTest::failed_test_suite_count() const {
  return impl()->failed_test_suite_count();
}

// Gets the number of all test suites.
int UnitTest::total_test_suite_count() const {
  return impl()->total_test_suite_count();
}

// Gets the number of all test suites that contain at least one test
// that should run.
int UnitTest::test_suite_to_run_count() const {
  return impl()->test_suite_to_run_count();
}

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
int UnitTest::successful_test_case_count() const {
  return impl()->successful_test_suite_count();
}
int UnitTest::failed_test_case_count() const {
  return impl()->failed_test_suite_count();
}
int UnitTest::total_test_case_count() const {
  return impl()->total_test_suite_count();
}
int UnitTest::test_case_to_run_count() const {
  return impl()->test_suite_to_run_count();
}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

// Gets the number of successful tests.
int UnitTest::successful_test_count() const {
  return impl()->successful_test_count();
}

// Gets the number of skipped tests.
int UnitTest::skipped_test_count() const {
  return impl()->skipped_test_count();
}

// Gets the number of failed tests.
int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }

// Gets the number of disabled tests that will be reported in the XML report.
int UnitTest::reportable_disabled_test_count() const {
  return impl()->reportable_disabled_test_count();
}

// Gets the number of disabled tests.
int UnitTest::disabled_test_count() const {
  return impl()->disabled_test_count();
}

// Gets the number of tests to be printed in the XML report.
int UnitTest::reportable_test_count() const {
  return impl()->reportable_test_count();
}

// Gets the number of all tests.
int UnitTest::total_test_count() const { return impl()->total_test_count(); }

// Gets the number of tests that should run.
int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }

// Gets the time of the test program start, in ms from the start of the
// UNIX epoch.
internal::TimeInMillis UnitTest::start_timestamp() const {
    return impl()->start_timestamp();
}

// Gets the elapsed time, in milliseconds.
internal::TimeInMillis UnitTest::elapsed_time() const {
  return impl()->elapsed_time();
}

// Returns true if and only if the unit test passed (i.e. all test suites
// passed).
bool UnitTest::Passed() const { return impl()->Passed(); }

// Returns true if and only if the unit test failed (i.e. some test suite
// failed or something outside of all tests failed).
bool UnitTest::Failed() const { return impl()->Failed(); }

// Gets the i-th test suite among all the test suites. i can range from 0 to
// total_test_suite_count() - 1. If i is not in that range, returns NULL.
const TestSuite* UnitTest::GetTestSuite(int i) const {
  return impl()->GetTestSuite(i);
}

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
const TestCase* UnitTest::GetTestCase(int i) const {
  return impl()->GetTestCase(i);
}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

// Returns the TestResult containing information on test failures and
// properties logged outside of individual test suites.
const TestResult& UnitTest::ad_hoc_test_result() const {
  return *impl()->ad_hoc_test_result();
}

// Gets the i-th test suite among all the test suites. i can range from 0 to
// total_test_suite_count() - 1. If i is not in that range, returns NULL.
TestSuite* UnitTest::GetMutableTestSuite(int i) {
  return impl()->GetMutableSuiteCase(i);
}

// Returns the list of event listeners that can be used to track events
// inside Google Test.
TestEventListeners& UnitTest::listeners() {
  return *impl()->listeners();
}

// Registers and returns a global test environment.  When a test
// program is run, all global test environments will be set-up in the
// order they were registered.  After all tests in the program have
// finished, all global test environments will be torn-down in the
// *reverse* order they were registered.
//
// The UnitTest object takes ownership of the given environment.
//
// We don't protect this under mutex_, as we only support calling it
// from the main thread.
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == nullptr) {
    return nullptr;
  }

  impl_->environments().push_back(env);
  return env;
}

// Adds a TestPartResult to the current TestResult object.  All Google Test
// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
// this to report their results.  The user code should use the
// assertion macros instead of calling this directly.
void UnitTest::AddTestPartResult(
    TestPartResult::Type result_type,
    const char* file_name,
    int line_number,
    const std::string& message,
    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
  Message msg;
  msg << message;

  internal::MutexLock lock(&mutex_);
  if (impl_->gtest_trace_stack().size() > 0) {
    msg << "\n" << GTEST_NAME_ << " trace:";

    for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
          << " " << trace.message;
    }
  }

  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
    msg << internal::kStackTraceMarker << os_stack_trace;
  }

  const TestPartResult result = TestPartResult(
      result_type, file_name, line_number, msg.GetString().c_str());
  impl_->GetTestPartResultReporterForCurrentThread()->
      ReportTestPartResult(result);

  if (result_type != TestPartResult::kSuccess &&
      result_type != TestPartResult::kSkip) {
    // gtest_break_on_failure takes precedence over
    // gtest_throw_on_failure.  This allows a user to set the latter
    // in the code (perhaps in order to use Google Test assertions
    // with another testing framework) and specify the former on the
    // command line for debugging.
    if (GTEST_FLAG(break_on_failure)) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
      // Using DebugBreak on Windows allows gtest to still break into a debugger
      // when a failure happens and both the --gtest_break_on_failure and
      // the --gtest_catch_exceptions flags are specified.
      DebugBreak();
#elif (!defined(__native_client__)) &&            \
    ((defined(__clang__) || defined(__GNUC__)) && \
     (defined(__x86_64__) || defined(__i386__)))
      // with clang/gcc we can achieve the same effect on x86 by invoking int3
      asm("int3");
#else
      // Dereference nullptr through a volatile pointer to prevent the compiler
      // from removing. We use this rather than abort() or __builtin_trap() for
      // portability: some debuggers don't correctly trap abort().
      *static_cast<volatile int*>(nullptr) = 1;
#endif  // GTEST_OS_WINDOWS
    } else if (GTEST_FLAG(throw_on_failure)) {
#if GTEST_HAS_EXCEPTIONS
      throw internal::GoogleTestFailureException(result);
#else
      // We cannot call abort() as it generates a pop-up in debug mode
      // that cannot be suppressed in VC 7.1 or below.
      exit(1);
#endif
    }
  }
}

// Adds a TestProperty to the current TestResult object when invoked from
// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
// from SetUpTestSuite or TearDownTestSuite, or to the global property set
// when invoked elsewhere.  If the result already contains a property with
// the same key, the value will be updated.
void UnitTest::RecordProperty(const std::string& key,
                              const std::string& value) {
  impl_->RecordProperty(TestProperty(key, value));
}

// Runs all tests in this UnitTest object and prints the result.
// Returns 0 if successful, or 1 otherwise.
//
// We don't protect this under mutex_, as we only support calling it
// from the main thread.
int UnitTest::Run() {
  const bool in_death_test_child_process =
      internal::GTEST_FLAG(internal_run_death_test).length() > 0;

  // Google Test implements this protocol for catching that a test
  // program exits before returning control to Google Test:
  //
  //   1. Upon start, Google Test creates a file whose absolute path
  //      is specified by the environment variable
  //      TEST_PREMATURE_EXIT_FILE.
  //   2. When Google Test has finished its work, it deletes the file.
  //
  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
  // running a Google-Test-based test program and check the existence
  // of the file at the end of the test execution to see if it has
  // exited prematurely.

  // If we are in the child process of a death test, don't
  // create/delete the premature exit file, as doing so is unnecessary
  // and will confuse the parent process.  Otherwise, create/delete
  // the file upon entering/leaving this function.  If the program
  // somehow exits before this function has a chance to return, the
  // premature-exit file will be left undeleted, causing a test runner
  // that understands the premature-exit-file protocol to report the
  // test as having failed.
  const internal::ScopedPrematureExitFile premature_exit_file(
      in_death_test_child_process
          ? nullptr
          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));

  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
  // used for the duration of the program.
  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));

#if GTEST_OS_WINDOWS
  // Either the user wants Google Test to catch exceptions thrown by the
  // tests or this is executing in the context of death test child
  // process. In either case the user does not want to see pop-up dialogs
  // about crashes - they are expected.
  if (impl()->catch_exceptions() || in_death_test_child_process) {
# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
    // SetErrorMode doesn't exist on CE.
    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
# endif  // !GTEST_OS_WINDOWS_MOBILE

# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
    // Death test children can be terminated with _abort().  On Windows,
    // _abort() can show a dialog with a warning message.  This forces the
    // abort message to go to stderr instead.
    _set_error_mode(_OUT_TO_STDERR);
# endif

# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
    // In the debug version, Visual Studio pops up a separate dialog
    // offering a choice to debug the aborted program. We need to suppress
    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
    // executed. Google Test will notify the user of any unexpected
    // failure via stderr.
    if (!GTEST_FLAG(break_on_failure))
      _set_abort_behavior(
          0x0,                                    // Clear the following flags:
          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.

    // In debug mode, the Windows CRT can crash with an assertion over invalid
    // input (e.g. passing an invalid file descriptor).  The default handling
    // for these assertions is to pop up a dialog and wait for user input.
    // Instead ask the CRT to dump such assertions to stderr non-interactively.
    if (!IsDebuggerPresent()) {
      (void)_CrtSetReportMode(_CRT_ASSERT,
                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
    }
# endif
  }
#endif  // GTEST_OS_WINDOWS

  return internal::HandleExceptionsInMethodIfSupported(
      impl(),
      &internal::UnitTestImpl::RunAllTests,
      "auxiliary test code (environments or event listeners)") ? 0 : 1;
}

// Returns the working directory when the first TEST() or TEST_F() was
// executed.
const char* UnitTest::original_working_dir() const {
  return impl_->original_working_dir_.c_str();
}

// Returns the TestSuite object for the test that's currently running,
// or NULL if no test is running.
const TestSuite* UnitTest::current_test_suite() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
  internal::MutexLock lock(&mutex_);
  return impl_->current_test_suite();
}

// Legacy API is still available but deprecated
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
const TestCase* UnitTest::current_test_case() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
  internal::MutexLock lock(&mutex_);
  return impl_->current_test_suite();
}
#endif

// Returns the TestInfo object for the test that's currently running,
// or NULL if no test is running.
const TestInfo* UnitTest::current_test_info() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
  internal::MutexLock lock(&mutex_);
  return impl_->current_test_info();
}

// Returns the random seed used at the start of the current test run.
int UnitTest::random_seed() const { return impl_->random_seed(); }

// Returns ParameterizedTestSuiteRegistry object used to keep track of
// value-parameterized tests and instantiate and register them.
internal::ParameterizedTestSuiteRegistry&
UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
  return impl_->parameterized_test_registry();
}

// Creates an empty UnitTest.
UnitTest::UnitTest() {
  impl_ = new internal::UnitTestImpl(this);
}

// Destructor of UnitTest.
UnitTest::~UnitTest() {
  delete impl_;
}

// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
// Google Test trace stack.
void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
    GTEST_LOCK_EXCLUDED_(mutex_) {
  internal::MutexLock lock(&mutex_);
  impl_->gtest_trace_stack().push_back(trace);
}

// Pops a trace from the per-thread Google Test trace stack.
void UnitTest::PopGTestTrace()
    GTEST_LOCK_EXCLUDED_(mutex_) {
  internal::MutexLock lock(&mutex_);
  impl_->gtest_trace_stack().pop_back();
}

namespace internal {

UnitTestImpl::UnitTestImpl(UnitTest* parent)
    : parent_(parent),
      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
          default_global_test_part_result_reporter_(this),
      default_per_thread_test_part_result_reporter_(this),
      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
          &default_global_test_part_result_reporter_),
      per_thread_test_part_result_reporter_(
          &default_per_thread_test_part_result_reporter_),
      parameterized_test_registry_(),
      parameterized_tests_registered_(false),
      last_death_test_suite_(-1),
      current_test_suite_(nullptr),
      current_test_info_(nullptr),
      ad_hoc_test_result_(),
      os_stack_trace_getter_(nullptr),
      post_flag_parse_init_performed_(false),
      random_seed_(0),  // Will be overridden by the flag before first use.
      random_(0),       // Will be reseeded before first use.
      start_timestamp_(0),
      elapsed_time_(0),
#if GTEST_HAS_DEATH_TEST
      death_test_factory_(new DefaultDeathTestFactory),
#endif
      // Will be overridden by the flag before first use.
      catch_exceptions_(false) {
  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
}

UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestSuite.
  ForEach(test_suites_, internal::Delete<TestSuite>);

  // Deletes every Environment.
  ForEach(environments_, internal::Delete<Environment>);

  delete os_stack_trace_getter_;
}

// Adds a TestProperty to the current TestResult object when invoked in a
// context of a test, to current test suite's ad_hoc_test_result when invoke
// from SetUpTestSuite/TearDownTestSuite, or to the global property set
// otherwise.  If the result already contains a property with the same key,
// the value will be updated.
void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
  std::string xml_element;
  TestResult* test_result;  // TestResult appropriate for property recording.

  if (current_test_info_ != nullptr) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_suite_ != nullptr) {
    xml_element = "testsuite";
    test_result = &(current_test_suite_->ad_hoc_test_result_);
  } else {
    xml_element = "testsuites";
    test_result = &ad_hoc_test_result_;
  }
  test_result->RecordProperty(xml_element, test_property);
}

#if GTEST_HAS_DEATH_TEST
// Disables event forwarding if the control is currently in a death test
// subprocess. Must not be called before InitGoogleTest.
void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
  if (internal_run_death_test_flag_.get() != nullptr)
    listeners()->SuppressEventForwarding();
}
#endif  // GTEST_HAS_DEATH_TEST

// Initializes event listeners performing XML output as specified by
// UnitTestOptions. Must not be called before InitGoogleTest.
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                        << output_format << "\" ignored.";
  }
}

#if GTEST_CAN_STREAM_RESULTS_
// Initializes event listeners for streaming test results in string form.
// Must not be called before InitGoogleTest.
void UnitTestImpl::ConfigureStreamingOutput() {
  const std::string& target = GTEST_FLAG(stream_result_to);
  if (!target.empty()) {
    const size_t pos = target.find(':');
    if (pos != std::string::npos) {
      listeners()->Append(new StreamingListener(target.substr(0, pos),
                                                target.substr(pos+1)));
    } else {
      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
                          << "\" ignored.";
    }
  }
}
#endif  // GTEST_CAN_STREAM_RESULTS_

// Performs initialization dependent upon flag values obtained in
// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
// this function is also called from RunAllTests.  Since this function can be
// called more than once, it has to be idempotent.
void UnitTestImpl::PostFlagParsingInit() {
  // Ensures that this function does not execute more than once.
  if (!post_flag_parse_init_performed_) {
    post_flag_parse_init_performed_ = true;

#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
    // Register to send notifications about key process state changes.
    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)

#if GTEST_HAS_DEATH_TEST
    InitDeathTestSubprocessControlInfo();
    SuppressTestEventsIfInSubprocess();
#endif  // GTEST_HAS_DEATH_TEST

    // Registers parameterized tests. This makes parameterized tests
    // available to the UnitTest reflection API without running
    // RUN_ALL_TESTS.
    RegisterParameterizedTests();

    // Configures listeners for XML output. This makes it possible for users
    // to shut down the default XML output before invoking RUN_ALL_TESTS.
    ConfigureXmlOutput();

    if (GTEST_FLAG(brief)) {
      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
    }

#if GTEST_CAN_STREAM_RESULTS_
    // Configures listeners for streaming test results to the specified server.
    ConfigureStreamingOutput();
#endif  // GTEST_CAN_STREAM_RESULTS_

#if GTEST_HAS_ABSL
    if (GTEST_FLAG(install_failure_signal_handler)) {
      absl::FailureSignalHandlerOptions options;
      absl::InstallFailureSignalHandler(options);
    }
#endif  // GTEST_HAS_ABSL
  }
}

// A predicate that checks the name of a TestSuite against a known
// value.
//
// This is used for implementation of the UnitTest class only.  We put
// it in the anonymous namespace to prevent polluting the outer
// namespace.
//
// TestSuiteNameIs is copyable.
class TestSuiteNameIs {
 public:
  // Constructor.
  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}

  // Returns true if and only if the name of test_suite matches name_.
  bool operator()(const TestSuite* test_suite) const {
    return test_suite != nullptr &&
           strcmp(test_suite->name(), name_.c_str()) == 0;
  }

 private:
  std::string name_;
};

// Finds and returns a TestSuite with the given name.  If one doesn't
// exist, creates one and returns it.  It's the CALLER'S
// RESPONSIBILITY to ensure that this function is only called WHEN THE
// TESTS ARE NOT SHUFFLED.
//
// Arguments:
//
//   test_suite_name: name of the test suite
//   type_param:      the name of the test suite's type parameter, or NULL if
//                    this is not a typed or a type-parameterized test suite.
//   set_up_tc:       pointer to the function that sets up the test suite
//   tear_down_tc:    pointer to the function that tears down the test suite
TestSuite* UnitTestImpl::GetTestSuite(
    const char* test_suite_name, const char* type_param,
    internal::SetUpTestSuiteFunc set_up_tc,
    internal::TearDownTestSuiteFunc tear_down_tc) {
  // Can we find a TestSuite with the given name?
  const auto test_suite =
      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
                   TestSuiteNameIs(test_suite_name));

  if (test_suite != test_suites_.rend()) return *test_suite;

  // No.  Let's create one.
  auto* const new_test_suite =
      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);

  // Is this a death test suite?
  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
                                               kDeathTestSuiteFilter)) {
    // Yes.  Inserts the test suite after the last death test suite
    // defined so far.  This only works when the test suites haven't
    // been shuffled.  Otherwise we may end up running a death test
    // after a non-death test.
    ++last_death_test_suite_;
    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
                        new_test_suite);
  } else {
    // No.  Appends to the end of the list.
    test_suites_.push_back(new_test_suite);
  }

  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
  return new_test_suite;
}

// Helpers for setting up / tearing down the given environment.  They
// are for use in the ForEach() function.
static void SetUpEnvironment(Environment* env) { env->SetUp(); }
static void TearDownEnvironment(Environment* env) { env->TearDown(); }

// Runs all tests in this UnitTest object, prints the result, and
// returns true if all tests are successful.  If any exception is
// thrown during a test, the test is considered to be failed, but the
// rest of the tests will still be run.
//
// When parameterized tests are enabled, it expands and registers
// parameterized tests first in RegisterParameterizedTests().
// All other functions called from RunAllTests() may safely assume that
// parameterized tests are ready to be counted and run.
bool UnitTestImpl::RunAllTests() {
  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
  // called.
  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();

  // Do not run any test if the --help flag was specified.
  if (g_help_flag)
    return true;

  // Repeats the call to the post-flag parsing initialization in case the
  // user didn't call InitGoogleTest.
  PostFlagParsingInit();

  // Even if sharding is not on, test runners may want to use the
  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
  // protocol.
  internal::WriteToShardStatusFileIfNeeded();

  // True if and only if we are in a subprocess for running a thread-safe-style
  // death test.
  bool in_subprocess_for_death_test = false;

#if GTEST_HAS_DEATH_TEST
  in_subprocess_for_death_test =
      (internal_run_death_test_flag_.get() != nullptr);
# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
  if (in_subprocess_for_death_test) {
    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
  }
# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
#endif  // GTEST_HAS_DEATH_TEST

  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
                                        in_subprocess_for_death_test);

  // Compares the full test names with the filter to decide which
  // tests to run.
  const bool has_tests_to_run = FilterTests(should_shard
                                              ? HONOR_SHARDING_PROTOCOL
                                              : IGNORE_SHARDING_PROTOCOL) > 0;

  // Lists the tests and exits if the --gtest_list_tests flag was specified.
  if (GTEST_FLAG(list_tests)) {
    // This must be called *after* FilterTests() has been called.
    ListTestsMatchingFilter();
    return true;
  }

  random_seed_ = GTEST_FLAG(shuffle) ?
      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;

  // True if and only if at least one test has failed.
  bool failed = false;

  TestEventListener* repeater = listeners()->repeater();

  start_timestamp_ = GetTimeInMillis();
  repeater->OnTestProgramStart(*parent_);

  // How many times to repeat the tests?  We don't want to repeat them
  // when we are inside the subprocess of a death test.
  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
  // Repeats forever if the repeat count is negative.
  const bool gtest_repeat_forever = repeat < 0;
  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
    // We want to preserve failures generated by ad-hoc test
    // assertions executed before RUN_ALL_TESTS().
    ClearNonAdHocTestResult();

    Timer timer;

    // Shuffles test suites and tests if requested.
    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
      random()->Reseed(static_cast<uint32_t>(random_seed_));
      // This should be done before calling OnTestIterationStart(),
      // such that a test event listener can see the actual test order
      // in the event.
      ShuffleTests();
    }

    // Tells the unit test event listeners that the tests are about to start.
    repeater->OnTestIterationStart(*parent_, i);

    // Runs each test suite if there is at least one test to run.
    if (has_tests_to_run) {
      // Sets up all environments beforehand.
      repeater->OnEnvironmentsSetUpStart(*parent_);
      ForEach(environments_, SetUpEnvironment);
      repeater->OnEnvironmentsSetUpEnd(*parent_);

      // Runs the tests only if there was no fatal failure or skip triggered
      // during global set-up.
      if (Test::IsSkipped()) {
        // Emit diagnostics when global set-up calls skip, as it will not be
        // emitted by default.
        TestResult& test_result =
            *internal::GetUnitTestImpl()->current_test_result();
        for (int j = 0; j < test_result.total_part_count(); ++j) {
          const TestPartResult& test_part_result =
              test_result.GetTestPartResult(j);
          if (test_part_result.type() == TestPartResult::kSkip) {
            const std::string& result = test_part_result.message();
            printf("%s\n", result.c_str());
          }
        }
        fflush(stdout);
      } else if (!Test::HasFatalFailure()) {
        for (int test_index = 0; test_index < total_test_suite_count();
             test_index++) {
          GetMutableSuiteCase(test_index)->Run();
          if (GTEST_FLAG(fail_fast) &&
              GetMutableSuiteCase(test_index)->Failed()) {
            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
              GetMutableSuiteCase(j)->Skip();
            }
            break;
          }
        }
      } else if (Test::HasFatalFailure()) {
        // If there was a fatal failure during the global setup then we know we
        // aren't going to run any tests. Explicitly mark all of the tests as
        // skipped to make this obvious in the output.
        for (int test_index = 0; test_index < total_test_suite_count();
             test_index++) {
          GetMutableSuiteCase(test_index)->Skip();
        }
      }

      // Tears down all environments in reverse order afterwards.
      repeater->OnEnvironmentsTearDownStart(*parent_);
      std::for_each(environments_.rbegin(), environments_.rend(),
                    TearDownEnvironment);
      repeater->OnEnvironmentsTearDownEnd(*parent_);
    }

    elapsed_time_ = timer.Elapsed();

    // Tells the unit test event listener that the tests have just finished.
    repeater->OnTestIterationEnd(*parent_, i);

    // Gets the result and clears it.
    if (!Passed()) {
      failed = true;
    }

    // Restores the original test order after the iteration.  This
    // allows the user to quickly repro a failure that happens in the
    // N-th iteration without repeating the first (N - 1) iterations.
    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
    // case the user somehow changes the value of the flag somewhere
    // (it's always safe to unshuffle the tests).
    UnshuffleTests();

    if (GTEST_FLAG(shuffle)) {
      // Picks a new random seed for each iteration.
      random_seed_ = GetNextRandomSeed(random_seed_);
    }
  }

  repeater->OnTestProgramEnd(*parent_);

  if (!gtest_is_initialized_before_run_all_tests) {
    ColoredPrintf(
        GTestColor::kRed,
        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
        " will start to enforce the valid usage. "
        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
#if GTEST_FOR_GOOGLE_
    ColoredPrintf(GTestColor::kRed,
                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
#endif  // GTEST_FOR_GOOGLE_
  }

  return !failed;
}

// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
// if the variable is present. If a file already exists at this location, this
// function will write over it. If the variable is present, but the file cannot
// be created, prints an error and exits.
void WriteToShardStatusFileIfNeeded() {
  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
  if (test_shard_file != nullptr) {
    FILE* const file = posix::FOpen(test_shard_file, "w");
    if (file == nullptr) {
      ColoredPrintf(GTestColor::kRed,
                    "Could not write to the test shard status file \"%s\" "
                    "specified by the %s environment variable.\n",
                    test_shard_file, kTestShardStatusFile);
      fflush(stdout);
      exit(EXIT_FAILURE);
    }
    fclose(file);
  }
}

// Checks whether sharding is enabled by examining the relevant
// environment variable values. If the variables are present,
// but inconsistent (i.e., shard_index >= total_shards), prints
// an error and exits. If in_subprocess_for_death_test, sharding is
// disabled because it must only be applied to the original test
// process. Otherwise, we could filter out death tests we intended to execute.
bool ShouldShard(const char* total_shards_env,
                 const char* shard_index_env,
                 bool in_subprocess_for_death_test) {
  if (in_subprocess_for_death_test) {
    return false;
  }

  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);

  if (total_shards == -1 && shard_index == -1) {
    return false;
  } else if (total_shards == -1 && shard_index != -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestShardIndex << " = " << shard_index
      << ", but have left " << kTestTotalShards << " unset.\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (total_shards != -1 && shard_index == -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestTotalShards << " = " << total_shards
      << ", but have left " << kTestShardIndex << " unset.\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (shard_index < 0 || shard_index >= total_shards) {
    const Message msg = Message()
      << "Invalid environment variables: we require 0 <= "
      << kTestShardIndex << " < " << kTestTotalShards
      << ", but you have " << kTestShardIndex << "=" << shard_index
      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  }

  return total_shards > 1;
}

// Parses the environment variable var as an Int32. If it is unset,
// returns default_val. If it is not an Int32, prints an error
// and aborts.
int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
  const char* str_val = posix::GetEnv(var);
  if (str_val == nullptr) {
    return default_val;
  }

  int32_t result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

// Given the total number of shards, the shard index, and the test id,
// returns true if and only if the test should be run on this shard. The test id
// is some arbitrary but unique non-negative integer assigned to each test
// method. Assumes that 0 <= shard_index < total_shards.
bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
  return (test_id % total_shards) == shard_index;
}

// Compares the name of each test with the user-specified filter to
// decide whether the test should be run, then records the result in
// each TestSuite and TestInfo object.
// If shard_tests == true, further filters tests based on sharding
// variables in the environment - see
// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
// . Returns the number of tests that should run.
int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;

  // num_runnable_tests are the number of tests that will
  // run across all shards (i.e., match filter and are not disabled).
  // num_selected_tests are the number of tests to be run on
  // this shard.
  int num_runnable_tests = 0;
  int num_selected_tests = 0;
  for (auto* test_suite : test_suites_) {
    const std::string& test_suite_name = test_suite->name();
    test_suite->set_should_run(false);

    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
      TestInfo* const test_info = test_suite->test_info_list()[j];
      const std::string test_name(test_info->name());
      // A test is disabled if test suite name or test name matches
      // kDisableTestFilter.
      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
                                   test_suite_name, kDisableTestFilter) ||
                               internal::UnitTestOptions::MatchesFilter(
                                   test_name, kDisableTestFilter);
      test_info->is_disabled_ = is_disabled;

      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
          test_suite_name, test_name);
      test_info->matches_filter_ = matches_filter;

      const bool is_runnable =
          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
          matches_filter;

      const bool is_in_another_shard =
          shard_tests != IGNORE_SHARDING_PROTOCOL &&
          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
      test_info->is_in_another_shard_ = is_in_another_shard;
      const bool is_selected = is_runnable && !is_in_another_shard;

      num_runnable_tests += is_runnable;
      num_selected_tests += is_selected;

      test_info->should_run_ = is_selected;
      test_suite->set_should_run(test_suite->should_run() || is_selected);
    }
  }
  return num_selected_tests;
}

// Prints the given C-string on a single line by replacing all '\n'
// characters with string "\\n".  If the output takes more than
// max_length characters, only prints the first max_length characters
// and "...".
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != nullptr) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Prints the names of the tests matching the user-specified filter flag.
void UnitTestImpl::ListTestsMatchingFilter() {
  // Print at most this many characters for each type/value parameter.
  const int kMaxParamLength = 250;

  for (auto* test_suite : test_suites_) {
    bool printed_test_suite_name = false;

    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
      const TestInfo* const test_info = test_suite->test_info_list()[j];
      if (test_info->matches_filter_) {
        if (!printed_test_suite_name) {
          printed_test_suite_name = true;
          printf("%s.", test_suite->name());
          if (test_suite->type_param() != nullptr) {
            printf("  # %s = ", kTypeParamLabel);
            // We print the type parameter on a single line to make
            // the output easy to parse by a program.
            PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
          }
          printf("\n");
        }
        printf("  %s", test_info->name());
        if (test_info->value_param() != nullptr) {
          printf("  # %s = ", kValueParamLabel);
          // We print the value parameter on a single line to make the
          // output easy to parse by a program.
          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
        }
        printf("\n");
      }
    }
  }
  fflush(stdout);
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml" || output_format == "json") {
    FILE* fileout = OpenFileForWriting(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
    std::stringstream stream;
    if (output_format == "xml") {
      XmlUnitTestResultPrinter(
          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
          .PrintXmlTestsList(&stream, test_suites_);
    } else if (output_format == "json") {
      JsonUnitTestResultPrinter(
          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
          .PrintJsonTestList(&stream, test_suites_);
    }
    fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
    fclose(fileout);
  }
}

// Sets the OS stack trace getter.
//
// Does nothing if the input and the current OS stack trace getter are
// the same; otherwise, deletes the old getter and makes the input the
// current getter.
void UnitTestImpl::set_os_stack_trace_getter(
    OsStackTraceGetterInterface* getter) {
  if (os_stack_trace_getter_ != getter) {
    delete os_stack_trace_getter_;
    os_stack_trace_getter_ = getter;
  }
}

// Returns the current OS stack trace getter if it is not NULL;
// otherwise, creates an OsStackTraceGetter, makes it the current
// getter, and returns it.
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Returns the most specific TestResult currently running.
TestResult* UnitTestImpl::current_test_result() {
  if (current_test_info_ != nullptr) {
    return &current_test_info_->result_;
  }
  if (current_test_suite_ != nullptr) {
    return &current_test_suite_->ad_hoc_test_result_;
  }
  return &ad_hoc_test_result_;
}

// Shuffles all test suites, and the tests within each test suite,
// making sure that death tests are still run first.
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test suites.
  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);

  // Shuffles the non-death test suites.
  ShuffleRange(random(), last_death_test_suite_ + 1,
               static_cast<int>(test_suites_.size()), &test_suite_indices_);

  // Shuffles the tests inside each test suite.
  for (auto& test_suite : test_suites_) {
    test_suite->ShuffleTests(random());
  }
}

// Restores the test suites and tests to their order before the first shuffle.
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_suites_.size(); i++) {
    // Unshuffles the tests in each test suite.
    test_suites_[i]->UnshuffleTests();
    // Resets the index of each test suite.
    test_suite_indices_[i] = static_cast<int>(i);
  }
}

// Returns the current OS stack trace as an std::string.
//
// The maximum number of stack frames to be included is specified by
// the gtest_stack_trace_depth flag.  The skip_count parameter
// specifies the number of top frames to be skipped, which doesn't
// count against the number of frames to be included.
//
// For example, if Foo() calls Bar(), which in turn calls
// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
                                            int skip_count) {
  // We pass skip_count + 1 to skip this wrapper function in addition
  // to what the user really wants to skip.
  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
}

// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
// suppress unreachable code warnings.
namespace {
class ClassUniqueToAlwaysTrue {};
}

bool IsTrue(bool condition) { return condition; }

bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
  // This condition is always false so AlwaysTrue() never actually throws,
  // but it makes the compiler think that it may throw.
  if (IsTrue(false))
    throw ClassUniqueToAlwaysTrue();
#endif  // GTEST_HAS_EXCEPTIONS
  return true;
}

// If *pstr starts with the given prefix, modifies *pstr to be right
// past the prefix and returns true; otherwise leaves *pstr unchanged
// and returns false.  None of pstr, *pstr, and prefix can be NULL.
bool SkipPrefix(const char* prefix, const char** pstr) {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

// Parses a string as a command line flag.  The string should have
// the format "--flag=value".  When def_optional is true, the "=value"
// part can be omitted.
//
// Returns the value of the flag, or NULL if the parsing failed.
static const char* ParseFlagValue(const char* str, const char* flag,
                                  bool def_optional) {
  // str and flag must not be NULL.
  if (str == nullptr || flag == nullptr) return nullptr;

  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return nullptr;

  // Returns the string after "=".
  return flag_end + 1;
}

// Parses a string for a bool flag, in the form of either
// "--flag=value" or "--flag".
//
// In the former case, the value is taken as true as long as it does
// not start with '0', 'f', or 'F'.
//
// In the latter case, the value is taken as true.
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

// Parses a string for an int32_t flag, in the form of "--flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag,
                    value_str, value);
}

// Parses a string for a string flag, in the form of "--flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
template <typename String>
static bool ParseStringFlag(const char* str, const char* flag, String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

// Determines whether a string has a prefix that Google Test uses for its
// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
// If Google Test detects that a command line flag has its prefix but is not
// recognized, it will print its help message. Flags starting with
// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
// internal flags and do not trigger the help message.
static bool HasGoogleTestFlagPrefix(const char* str) {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

// Prints a string containing code-encoded text.  The following escape
// sequences can be used in the string to control the text color:
//
//   @@    prints a single '@' character.
//   @R    changes the color to red.
//   @G    changes the color to green.
//   @Y    changes the color to yellow.
//   @D    changes to the default terminal text color.
//
static void PrintColorEncoded(const char* str) {
  GTestColor color = GTestColor::kDefault;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == nullptr) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = GTestColor::kDefault;
    } else if (ch == 'R') {
      color = GTestColor::kRed;
    } else if (ch == 'G') {
      color = GTestColor::kGreen;
    } else if (ch == 'Y') {
      color = GTestColor::kYellow;
    } else {
      --str;
    }
  }
}

static const char kColorEncodedHelpMessage[] =
    "This program contains tests written using " GTEST_NAME_
    ". You can use the\n"
    "following command line flags to control its behavior:\n"
    "\n"
    "Test Selection:\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "list_tests@D\n"
    "      List the names of all tests instead of running them. The name of\n"
    "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "filter=@YPOSITIVE_PATTERNS"
    "[@G-@YNEGATIVE_PATTERNS]@D\n"
    "      Run only the tests whose name matches one of the positive patterns "
    "but\n"
    "      none of the negative patterns. '?' matches any single character; "
    "'*'\n"
    "      matches any substring; ':' separates two patterns.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "also_run_disabled_tests@D\n"
    "      Run all disabled tests too.\n"
    "\n"
    "Test Execution:\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "repeat=@Y[COUNT]@D\n"
    "      Run the tests repeatedly; use a negative count to repeat forever.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "shuffle@D\n"
    "      Randomize tests' orders on every iteration.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "random_seed=@Y[NUMBER]@D\n"
    "      Random number seed to use for shuffling test orders (between 1 and\n"
    "      99999, or 0 to use a seed based on the current time).\n"
    "\n"
    "Test Output:\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
    "      Enable/disable colored output. The default is @Gauto@D.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "brief=1@D\n"
    "      Only print test failures.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "print_time=0@D\n"
    "      Don't print the elapsed time of each test.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
    "@Y|@G:@YFILE_PATH]@D\n"
    "      Generate a JSON or XML report in the given directory or with the "
    "given\n"
    "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
# if GTEST_CAN_STREAM_RESULTS_
    "  @G--" GTEST_FLAG_PREFIX_
    "stream_result_to=@YHOST@G:@YPORT@D\n"
    "      Stream test results to the given server.\n"
# endif  // GTEST_CAN_STREAM_RESULTS_
    "\n"
    "Assertion Behavior:\n"
# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
    "  @G--" GTEST_FLAG_PREFIX_
    "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
    "      Set the default death test style.\n"
# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
    "  @G--" GTEST_FLAG_PREFIX_
    "break_on_failure@D\n"
    "      Turn assertion failures into debugger break-points.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "throw_on_failure@D\n"
    "      Turn assertion failures into C++ exceptions for use by an external\n"
    "      test framework.\n"
    "  @G--" GTEST_FLAG_PREFIX_
    "catch_exceptions=0@D\n"
    "      Do not report exceptions as test failures. Instead, allow them\n"
    "      to crash the program or throw a pop-up (on Windows).\n"
    "\n"
    "Except for @G--" GTEST_FLAG_PREFIX_
    "list_tests@D, you can alternatively set "
    "the corresponding\n"
    "environment variable of a flag (all letters in upper-case). For example, "
    "to\n"
    "disable colored text output, you can either specify "
    "@G--" GTEST_FLAG_PREFIX_
    "color=no@D or set\n"
    "the @G" GTEST_FLAG_PREFIX_UPPER_
    "COLOR@D environment variable to @Gno@D.\n"
    "\n"
    "For more information, please read the " GTEST_NAME_
    " documentation at\n"
    "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
    "\n"
    "(not one in your own code or tests), please report it to\n"
    "@G<" GTEST_DEV_EMAIL_ ">@D.\n";

static bool ParseGoogleTestFlag(const char* const arg) {
  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
                       &GTEST_FLAG(also_run_disabled_tests)) ||
         ParseBoolFlag(arg, kBreakOnFailureFlag,
                       &GTEST_FLAG(break_on_failure)) ||
         ParseBoolFlag(arg, kCatchExceptionsFlag,
                       &GTEST_FLAG(catch_exceptions)) ||
         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
         ParseStringFlag(arg, kDeathTestStyleFlag,
                         &GTEST_FLAG(death_test_style)) ||
         ParseBoolFlag(arg, kDeathTestUseFork,
                       &GTEST_FLAG(death_test_use_fork)) ||
         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
         ParseStringFlag(arg, kInternalRunDeathTestFlag,
                         &GTEST_FLAG(internal_run_death_test)) ||
         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
         ParseInt32Flag(arg, kStackTraceDepthFlag,
                        &GTEST_FLAG(stack_trace_depth)) ||
         ParseStringFlag(arg, kStreamResultToFlag,
                         &GTEST_FLAG(stream_result_to)) ||
         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
}

#if GTEST_USE_OWN_FLAGFILE_FLAG_
static void LoadFlagsFromFile(const std::string& path) {
  FILE* flagfile = posix::FOpen(path.c_str(), "r");
  if (!flagfile) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
                      << "\"";
  }
  std::string contents(ReadEntireFile(flagfile));
  posix::FClose(flagfile);
  std::vector<std::string> lines;
  SplitString(contents, '\n', &lines);
  for (size_t i = 0; i < lines.size(); ++i) {
    if (lines[i].empty())
      continue;
    if (!ParseGoogleTestFlag(lines[i].c_str()))
      g_help_flag = true;
  }
}
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_

// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.  The type parameter CharType can be
// instantiated to either char or wchar_t.
template <typename CharType>
void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
  for (int i = 1; i < *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();

    using internal::ParseBoolFlag;
    using internal::ParseInt32Flag;
    using internal::ParseStringFlag;

    bool remove_flag = false;
    if (ParseGoogleTestFlag(arg)) {
      remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
      LoadFlagsFromFile(GTEST_FLAG(flagfile));
      remove_flag = true;
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (arg_string == "--help" || arg_string == "-h" ||
               arg_string == "-?" || arg_string == "/?" ||
               HasGoogleTestFlagPrefix(arg)) {
      // Both help flag and unrecognized Google Test flags (excluding
      // internal ones) trigger help display.
      g_help_flag = true;
    }

    if (remove_flag) {
      // Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }

      // Decrements the argument count.
      (*argc)--;

      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }

  if (g_help_flag) {
    // We print the help here instead of in RUN_ALL_TESTS(), as the
    // latter may not be called at all if the user is using Google
    // Test with another testing framework.
    PrintColorEncoded(kColorEncodedHelpMessage);
  }
}

// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.
void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);

  // Fix the value of *_NSGetArgc() on macOS, but if and only if
  // *_NSGetArgv() == argv
  // Only applicable to char** version of argv
#if GTEST_OS_MAC
#ifndef GTEST_OS_IOS
  if (*_NSGetArgv() == argv) {
    *_NSGetArgc() = *argc;
  }
#endif
#endif
}
void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

// The internal implementation of InitGoogleTest().
//
// The type parameter CharType can be instantiated to either char or
// wchar_t.
template <typename CharType>
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

#if GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());
#endif  // GTEST_HAS_ABSL

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

}  // namespace internal

// Initializes Google Test.  This must be called before calling
// RUN_ALL_TESTS().  In particular, it parses a command line for the
// flags that Google Test recognizes.  Whenever a Google Test flag is
// seen, it is removed from argv, and *argc is decremented.
//
// No value is returned.  Instead, the Google Test flag variables are
// updated.
//
// Calling the function for the second time has no user-visible effect.
void InitGoogleTest(int* argc, char** argv) {
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
void InitGoogleTest(int* argc, wchar_t** argv) {
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

// This overloaded version can be used on Arduino/embedded platforms where
// there is no argc/argv.
void InitGoogleTest() {
  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
  int argc = 1;
  const auto arg0 = "dummy";
  char* argv0 = const_cast<char*>(arg0);
  char** argv = &argv0;

#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(&argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS_MOBILE
  return "\\temp\\";
#elif GTEST_OS_WINDOWS
  const char* temp_dir = internal::posix::GetEnv("TEMP");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "\\temp\\";
  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
    return temp_dir;
  } else {
    return std::string(temp_dir) + "\\";
  }
#elif GTEST_OS_LINUX_ANDROID
  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "/data/local/tmp/";
  } else {
    return temp_dir;
  }
#elif GTEST_OS_LINUX
  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "/tmp/";
  } else {
    return temp_dir;
  }
#else
  return "/tmp/";
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Class ScopedTrace

// Pushes the given source file location and message onto a per-thread
// trace stack maintained by Google Test.
void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
  internal::TraceInfo trace;
  trace.file = file;
  trace.line = line;
  trace.message.swap(message);

  UnitTest::GetInstance()->PushGTestTrace(trace);
}

// Pops the info pushed by the c'tor.
ScopedTrace::~ScopedTrace()
    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
  UnitTest::GetInstance()->PopGTestTrace();
}

}  // namespace testing
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// This file implements death tests.


#include <functional>
#include <utility>


#if GTEST_HAS_DEATH_TEST

# if GTEST_OS_MAC
#  include <crt_externs.h>
# endif  // GTEST_OS_MAC

# include <errno.h>
# include <fcntl.h>
# include <limits.h>

# if GTEST_OS_LINUX
#  include <signal.h>
# endif  // GTEST_OS_LINUX

# include <stdarg.h>

# if GTEST_OS_WINDOWS
#  include <windows.h>
# else
#  include <sys/mman.h>
#  include <sys/wait.h>
# endif  // GTEST_OS_WINDOWS

# if GTEST_OS_QNX
#  include <spawn.h>
# endif  // GTEST_OS_QNX

# if GTEST_OS_FUCHSIA
#  include <lib/fdio/fd.h>
#  include <lib/fdio/io.h>
#  include <lib/fdio/spawn.h>
#  include <lib/zx/channel.h>
#  include <lib/zx/port.h>
#  include <lib/zx/process.h>
#  include <lib/zx/socket.h>
#  include <zircon/processargs.h>
#  include <zircon/syscalls.h>
#  include <zircon/syscalls/policy.h>
#  include <zircon/syscalls/port.h>
# endif  // GTEST_OS_FUCHSIA

#endif  // GTEST_HAS_DEATH_TEST


namespace testing {

// Constants.

// The default death test style.
//
// This is defined in internal/gtest-port.h as "fast", but can be overridden by
// a definition in internal/custom/gtest-port.h. The recommended value, which is
// used internally at Google, is "threadsafe".
static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;

GTEST_DEFINE_string_(
    death_test_style,
    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
    "Indicates how to run a death test in a forked child process: "
    "\"threadsafe\" (child process re-executes the test binary "
    "from the beginning, running only the specific death test) or "
    "\"fast\" (child process runs the death test immediately "
    "after forking).");

GTEST_DEFINE_bool_(
    death_test_use_fork,
    internal::BoolFromGTestEnv("death_test_use_fork", false),
    "Instructs to use fork()/_exit() instead of clone() in death tests. "
    "Ignored and always uses fork() on POSIX systems where clone() is not "
    "implemented. Useful when running under valgrind or similar tools if "
    "those do not support clone(). Valgrind 3.3.1 will just fail if "
    "it sees an unsupported combination of clone() flags. "
    "It is not recommended to use this flag w/o valgrind though it will "
    "work in 99% of the cases. Once valgrind is fixed, this flag will "
    "most likely be removed.");

namespace internal {
GTEST_DEFINE_string_(
    internal_run_death_test, "",
    "Indicates the file, line number, temporal index of "
    "the single death test to run, and a file descriptor to "
    "which a success code may be sent, all separated by "
    "the '|' characters.  This flag is specified if and only if the "
    "current process is a sub-process launched for running a thread-safe "
    "death test.  FOR INTERNAL USE ONLY.");
}  // namespace internal

#if GTEST_HAS_DEATH_TEST

namespace internal {

// Valid only for fast death tests. Indicates the code is running in the
// child process of a fast style death test.
# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
static bool g_in_fast_death_test_child = false;
# endif

// Returns a Boolean value indicating whether the caller is currently
// executing in the context of the death test child process.  Tools such as
// Valgrind heap checkers may need this to modify their behavior in death
// tests.  IMPORTANT: This is an internal utility.  Using it may break the
// implementation of death tests.  User code MUST NOT use it.
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
  // of the death_test_style flag.
  return !GTEST_FLAG(internal_run_death_test).empty();

# else

  if (GTEST_FLAG(death_test_style) == "threadsafe")
    return !GTEST_FLAG(internal_run_death_test).empty();
  else
    return g_in_fast_death_test_child;
#endif
}

}  // namespace internal

// ExitedWithCode constructor.
ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
}

// ExitedWithCode function-call operator.
bool ExitedWithCode::operator()(int exit_status) const {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  return exit_status == exit_code_;

# else

  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;

# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
}

# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
// KilledBySignal constructor.
KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
}

// KilledBySignal function-call operator.
bool KilledBySignal::operator()(int exit_status) const {
#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  {
    bool result;
    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
      return result;
    }
  }
#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
}
# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA

namespace internal {

// Utilities needed for death tests.

// Generates a textual description of a given exit code, in the format
// specified by wait(2).
static std::string ExitSummary(int exit_code) {
  Message m;

# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  m << "Exited with exit status " << exit_code;

# else

  if (WIFEXITED(exit_code)) {
    m << "Exited with exit status " << WEXITSTATUS(exit_code);
  } else if (WIFSIGNALED(exit_code)) {
    m << "Terminated by signal " << WTERMSIG(exit_code);
  }
#  ifdef WCOREDUMP
  if (WCOREDUMP(exit_code)) {
    m << " (core dumped)";
  }
#  endif
# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  return m.GetString();
}

// Returns true if exit_status describes a process that was terminated
// by a signal, or exited normally with a nonzero exit code.
bool ExitedUnsuccessfully(int exit_status) {
  return !ExitedWithCode(0)(exit_status);
}

# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
// Generates a textual failure message when a death test finds more than
// one thread running, or cannot determine the number of threads, prior
// to executing the given statement.  It is the responsibility of the
// caller not to pass a thread_count of 1.
static std::string DeathTestThreadWarning(size_t thread_count) {
  Message msg;
  msg << "Death tests use fork(), which is unsafe particularly"
      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
  if (thread_count == 0) {
    msg << "couldn't detect the number of threads.";
  } else {
    msg << "detected " << thread_count << " threads.";
  }
  msg << " See "
         "https://github.com/google/googletest/blob/master/docs/"
         "advanced.md#death-tests-and-threads"
      << " for more explanation and suggested solutions, especially if"
      << " this is the last message you see before your test times out.";
  return msg.GetString();
}
# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA

// Flag characters for reporting a death test that did not die.
static const char kDeathTestLived = 'L';
static const char kDeathTestReturned = 'R';
static const char kDeathTestThrew = 'T';
static const char kDeathTestInternalError = 'I';

#if GTEST_OS_FUCHSIA

// File descriptor used for the pipe in the child process.
static const int kFuchsiaReadPipeFd = 3;

#endif

// An enumeration describing all of the possible ways that a death test can
// conclude.  DIED means that the process died while executing the test
// code; LIVED means that process lived beyond the end of the test code;
// RETURNED means that the test statement attempted to execute a return
// statement, which is not allowed; THREW means that the test statement
// returned control by throwing an exception.  IN_PROGRESS means the test
// has not yet concluded.
enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };

// Routine for aborting the program which is safe to call from an
// exec-style death test child process, in which case the error
// message is propagated back to the parent process.  Otherwise, the
// message is simply printed to stderr.  In either case, the program
// then exits with status 1.
static void DeathTestAbort(const std::string& message) {
  // On a POSIX system, this function may be called from a threadsafe-style
  // death test child process, which operates on a very small stack.  Use
  // the heap for any additional non-minuscule memory requirements.
  const InternalRunDeathTestFlag* const flag =
      GetUnitTestImpl()->internal_run_death_test_flag();
  if (flag != nullptr) {
    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
    fputc(kDeathTestInternalError, parent);
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
    _exit(1);
  } else {
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
    posix::Abort();
  }
}

// A replacement for CHECK that calls DeathTestAbort if the assertion
// fails.
# define GTEST_DEATH_TEST_CHECK_(expression) \
  do { \
    if (!::testing::internal::IsTrue(expression)) { \
      DeathTestAbort( \
          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
          + ::testing::internal::StreamableToString(__LINE__) + ": " \
          + #expression); \
    } \
  } while (::testing::internal::AlwaysFalse())

// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
// evaluating any system call that fulfills two conditions: it must return
// -1 on failure, and set errno to EINTR when it is interrupted and
// should be tried again.  The macro expands to a loop that repeatedly
// evaluates the expression as long as it evaluates to -1 and sets
// errno to EINTR.  If the expression evaluates to -1 but errno is
// something other than EINTR, DeathTestAbort is called.
# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
  do { \
    int gtest_retval; \
    do { \
      gtest_retval = (expression); \
    } while (gtest_retval == -1 && errno == EINTR); \
    if (gtest_retval == -1) { \
      DeathTestAbort( \
          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
          + ::testing::internal::StreamableToString(__LINE__) + ": " \
          + #expression + " != -1"); \
    } \
  } while (::testing::internal::AlwaysFalse())

// Returns the message describing the last system error in errno.
std::string GetLastErrnoDescription() {
    return errno == 0 ? "" : posix::StrError(errno);
}

// This is called from a death test parent process to read a failure
// message from the death test child process and log it with the FATAL
// severity. On Windows, the message is read from a pipe handle. On other
// platforms, it is read from a file descriptor.
static void FailFromInternalError(int fd) {
  Message error;
  char buffer[256];
  int num_read;

  do {
    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
      buffer[num_read] = '\0';
      error << buffer;
    }
  } while (num_read == -1 && errno == EINTR);

  if (num_read == 0) {
    GTEST_LOG_(FATAL) << error.GetString();
  } else {
    const int last_error = errno;
    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
                      << GetLastErrnoDescription() << " [" << last_error << "]";
  }
}

// Death test constructor.  Increments the running death test count
// for the current test.
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == nullptr) {
    DeathTestAbort("Cannot run a death test outside of a TEST or "
                   "TEST_F construct");
  }
}

// Creates and returns a death test by dispatching to the current
// death test factory.
bool DeathTest::Create(const char* statement,
                       Matcher<const std::string&> matcher, const char* file,
                       int line, DeathTest** test) {
  return GetUnitTestImpl()->death_test_factory()->Create(
      statement, std::move(matcher), file, line, test);
}

const char* DeathTest::LastMessage() {
  return last_death_test_message_.c_str();
}

void DeathTest::set_last_death_test_message(const std::string& message) {
  last_death_test_message_ = message;
}

std::string DeathTest::last_death_test_message_;

// Provides cross platform implementation for some death functionality.
class DeathTestImpl : public DeathTest {
 protected:
  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
      : statement_(a_statement),
        matcher_(std::move(matcher)),
        spawned_(false),
        status_(-1),
        outcome_(IN_PROGRESS),
        read_fd_(-1),
        write_fd_(-1) {}

  // read_fd_ is expected to be closed and cleared by a derived class.
  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }

  void Abort(AbortReason reason) override;
  bool Passed(bool status_ok) override;

  const char* statement() const { return statement_; }
  bool spawned() const { return spawned_; }
  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
  int status() const { return status_; }
  void set_status(int a_status) { status_ = a_status; }
  DeathTestOutcome outcome() const { return outcome_; }
  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
  int read_fd() const { return read_fd_; }
  void set_read_fd(int fd) { read_fd_ = fd; }
  int write_fd() const { return write_fd_; }
  void set_write_fd(int fd) { write_fd_ = fd; }

  // Called in the parent process only. Reads the result code of the death
  // test child process via a pipe, interprets it to set the outcome_
  // member, and closes read_fd_.  Outputs diagnostics and terminates in
  // case of unexpected codes.
  void ReadAndInterpretStatusByte();

  // Returns stderr output from the child process.
  virtual std::string GetErrorLogs();

 private:
  // The textual content of the code this object is testing.  This class
  // doesn't own this string and should not attempt to delete it.
  const char* const statement_;
  // A matcher that's expected to match the stderr output by the child process.
  Matcher<const std::string&> matcher_;
  // True if the death test child process has been successfully spawned.
  bool spawned_;
  // The exit status of the child process.
  int status_;
  // How the death test concluded.
  DeathTestOutcome outcome_;
  // Descriptor to the read end of the pipe to the child process.  It is
  // always -1 in the child process.  The child keeps its write end of the
  // pipe in write_fd_.
  int read_fd_;
  // Descriptor to the child's write end of the pipe to the parent process.
  // It is always -1 in the parent process.  The parent keeps its end of the
  // pipe in read_fd_.
  int write_fd_;
};

// Called in the parent process only. Reads the result code of the death
// test child process via a pipe, interprets it to set the outcome_
// member, and closes read_fd_.  Outputs diagnostics and terminates in
// case of unexpected codes.
void DeathTestImpl::ReadAndInterpretStatusByte() {
  char flag;
  int bytes_read;

  // The read() here blocks until data is available (signifying the
  // failure of the death test) or until the pipe is closed (signifying
  // its success), so it's okay to call this in the parent before
  // the child process has exited.
  do {
    bytes_read = posix::Read(read_fd(), &flag, 1);
  } while (bytes_read == -1 && errno == EINTR);

  if (bytes_read == 0) {
    set_outcome(DIED);
  } else if (bytes_read == 1) {
    switch (flag) {
      case kDeathTestReturned:
        set_outcome(RETURNED);
        break;
      case kDeathTestThrew:
        set_outcome(THREW);
        break;
      case kDeathTestLived:
        set_outcome(LIVED);
        break;
      case kDeathTestInternalError:
        FailFromInternalError(read_fd());  // Does not return.
        break;
      default:
        GTEST_LOG_(FATAL) << "Death test child process reported "
                          << "unexpected status byte ("
                          << static_cast<unsigned int>(flag) << ")";
    }
  } else {
    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
                      << GetLastErrnoDescription();
  }
  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
  set_read_fd(-1);
}

std::string DeathTestImpl::GetErrorLogs() {
  return GetCapturedStderr();
}

// Signals that the death test code which should have exited, didn't.
// Should be called only in a death test child process.
// Writes a status byte to the child's status file descriptor, then
// calls _exit(1).
void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
  // to the pipe, then exit.
  const char status_ch =
      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;

  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
  // run after calling _exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
}

// Returns an indented copy of stderr output for a death test.
// This makes distinguishing death test output lines from regular log lines
// much easier.
static ::std::string FormatDeathTestOutput(const ::std::string& output) {
  ::std::string ret;
  for (size_t at = 0; ; ) {
    const size_t line_end = output.find('\n', at);
    ret += "[  DEATH   ] ";
    if (line_end == ::std::string::npos) {
      ret += output.substr(at);
      break;
    }
    ret += output.substr(at, line_end + 1 - at);
    at = line_end + 1;
  }
  return ret;
}

// Assesses the success or failure of a death test, using both private
// members which have previously been set, and one argument:
//
// Private data members:
//   outcome:  An enumeration describing how the death test
//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
//             fails in the latter three cases.
//   status:   The exit status of the child process. On *nix, it is in the
//             in the format specified by wait(2). On Windows, this is the
//             value supplied to the ExitProcess() API or a numeric code
//             of the exception that terminated the program.
//   matcher_: A matcher that's expected to match the stderr output by the child
//             process.
//
// Argument:
//   status_ok: true if exit_status is acceptable in the context of
//              this particular death test, which fails if it is false
//
// Returns true if and only if all of the above conditions are met.  Otherwise,
// the first failing condition, in the order given above, is the one that is
// reported. Also sets the last death test message string.
bool DeathTestImpl::Passed(bool status_ok) {
  if (!spawned())
    return false;

  const std::string error_message = GetErrorLogs();

  bool success = false;
  Message buffer;

  buffer << "Death test: " << statement() << "\n";
  switch (outcome()) {
    case LIVED:
      buffer << "    Result: failed to die.\n"
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
      break;
    case THREW:
      buffer << "    Result: threw an exception.\n"
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
      break;
    case RETURNED:
      buffer << "    Result: illegal return in test statement.\n"
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
      break;
    case DIED:
      if (status_ok) {
        if (matcher_.Matches(error_message)) {
          success = true;
        } else {
          std::ostringstream stream;
          matcher_.DescribeTo(&stream);
          buffer << "    Result: died but not with expected error.\n"
                 << "  Expected: " << stream.str() << "\n"
                 << "Actual msg:\n"
                 << FormatDeathTestOutput(error_message);
        }
      } else {
        buffer << "    Result: died but not with expected exit code:\n"
               << "            " << ExitSummary(status()) << "\n"
               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
      }
      break;
    case IN_PROGRESS:
    default:
      GTEST_LOG_(FATAL)
          << "DeathTest::Passed somehow called before conclusion of test";
  }

  DeathTest::set_last_death_test_message(buffer.GetString());
  return success;
}

# if GTEST_OS_WINDOWS
// WindowsDeathTest implements death tests on Windows. Due to the
// specifics of starting new processes on Windows, death tests there are
// always threadsafe, and Google Test considers the
// --gtest_death_test_style=fast setting to be equivalent to
// --gtest_death_test_style=threadsafe there.
//
// A few implementation notes:  Like the Linux version, the Windows
// implementation uses pipes for child-to-parent communication. But due to
// the specifics of pipes on Windows, some extra steps are required:
//
// 1. The parent creates a communication pipe and stores handles to both
//    ends of it.
// 2. The parent starts the child and provides it with the information
//    necessary to acquire the handle to the write end of the pipe.
// 3. The child acquires the write end of the pipe and signals the parent
//    using a Windows event.
// 4. Now the parent can release the write end of the pipe on its side. If
//    this is done before step 3, the object's reference count goes down to
//    0 and it is destroyed, preventing the child from acquiring it. The
//    parent now has to release it, or read operations on the read end of
//    the pipe will not return when the child terminates.
// 5. The parent reads child's output through the pipe (outcome code and
//    any possible error messages) from the pipe, and its stderr and then
//    determines whether to fail the test.
//
// Note: to distinguish Win32 API calls from the local method and function
// calls, the former are explicitly resolved in the global namespace.
//
class WindowsDeathTest : public DeathTestImpl {
 public:
  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
                   const char* file, int line)
      : DeathTestImpl(a_statement, std::move(matcher)),
        file_(file),
        line_(line) {}

  // All of these virtual functions are inherited from DeathTest.
  virtual int Wait();
  virtual TestRole AssumeRole();

 private:
  // The name of the file in which the death test is located.
  const char* const file_;
  // The line number on which the death test is located.
  const int line_;
  // Handle to the write end of the pipe to the child process.
  AutoHandle write_handle_;
  // Child process handle.
  AutoHandle child_handle_;
  // Event the child process uses to signal the parent that it has
  // acquired the handle to the write end of the pipe. After seeing this
  // event the parent can release its own handles to make sure its
  // ReadFile() calls return when the child terminates.
  AutoHandle event_handle_;
};

// Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists.  As a side effect, sets the
// outcome data member.
int WindowsDeathTest::Wait() {
  if (!spawned())
    return 0;

  // Wait until the child either signals that it has acquired the write end
  // of the pipe or it dies.
  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
  switch (::WaitForMultipleObjects(2,
                                   wait_handles,
                                   FALSE,  // Waits for any of the handles.
                                   INFINITE)) {
    case WAIT_OBJECT_0:
    case WAIT_OBJECT_0 + 1:
      break;
    default:
      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
  }

  // The child has acquired the write end of the pipe or exited.
  // We release the handle on our side and continue.
  write_handle_.Reset();
  event_handle_.Reset();

  ReadAndInterpretStatusByte();

  // Waits for the child process to exit if it haven't already. This
  // returns immediately if the child has already exited, regardless of
  // whether previous calls to WaitForMultipleObjects synchronized on this
  // handle or not.
  GTEST_DEATH_TEST_CHECK_(
      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
                                             INFINITE));
  DWORD status_code;
  GTEST_DEATH_TEST_CHECK_(
      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
  child_handle_.Reset();
  set_status(static_cast<int>(status_code));
  return status();
}

// The AssumeRole process for a Windows death test.  It creates a child
// process with the same executable as the current process to run the
// death test.  The child process is given the --gtest_filter and
// --gtest_internal_run_death_test flags such that it knows to run the
// current death test only.
DeathTest::TestRole WindowsDeathTest::AssumeRole() {
  const UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const TestInfo* const info = impl->current_test_info();
  const int death_test_index = info->result()->death_test_count();

  if (flag != nullptr) {
    // ParseInternalRunDeathTestFlag() has performed all the necessary
    // processing.
    set_write_fd(flag->write_fd());
    return EXECUTE_TEST;
  }

  // WindowsDeathTest uses an anonymous pipe to communicate results of
  // a death test.
  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
                                                 nullptr, TRUE};
  HANDLE read_handle, write_handle;
  GTEST_DEATH_TEST_CHECK_(
      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
                   0)  // Default buffer size.
      != FALSE);
  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
                                O_RDONLY));
  write_handle_.Reset(write_handle);
  event_handle_.Reset(::CreateEvent(
      &handles_are_inheritable,
      TRUE,       // The event will automatically reset to non-signaled state.
      FALSE,      // The initial state is non-signalled.
      nullptr));  // The even is unnamed.
  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
                                  kFilterFlag + "=" + info->test_suite_name() +
                                  "." + info->name();
  const std::string internal_flag =
      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
      "=" + file_ + "|" + StreamableToString(line_) + "|" +
      StreamableToString(death_test_index) + "|" +
      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
      // size_t has the same width as pointers on both 32-bit and 64-bit
      // Windows platforms.
      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));

  char executable_path[_MAX_PATH + 1];  // NOLINT
  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
                                                                executable_path,
                                                                _MAX_PATH));

  std::string command_line =
      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
      internal_flag + "\"";

  DeathTest::set_last_death_test_message("");

  CaptureStderr();
  // Flush the log buffers since the log streams are shared with the child.
  FlushInfoLog();

  // The child process will share the standard handles with the parent.
  STARTUPINFOA startup_info;
  memset(&startup_info, 0, sizeof(STARTUPINFO));
  startup_info.dwFlags = STARTF_USESTDHANDLES;
  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);

  PROCESS_INFORMATION process_info;
  GTEST_DEATH_TEST_CHECK_(
      ::CreateProcessA(
          executable_path, const_cast<char*>(command_line.c_str()),
          nullptr,  // Retuned process handle is not inheritable.
          nullptr,  // Retuned thread handle is not inheritable.
          TRUE,  // Child inherits all inheritable handles (for write_handle_).
          0x0,   // Default creation flags.
          nullptr,  // Inherit the parent's environment.
          UnitTest::GetInstance()->original_working_dir(), &startup_info,
          &process_info) != FALSE);
  child_handle_.Reset(process_info.hProcess);
  ::CloseHandle(process_info.hThread);
  set_spawned(true);
  return OVERSEE_TEST;
}

# elif GTEST_OS_FUCHSIA

class FuchsiaDeathTest : public DeathTestImpl {
 public:
  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
                   const char* file, int line)
      : DeathTestImpl(a_statement, std::move(matcher)),
        file_(file),
        line_(line) {}

  // All of these virtual functions are inherited from DeathTest.
  int Wait() override;
  TestRole AssumeRole() override;
  std::string GetErrorLogs() override;

 private:
  // The name of the file in which the death test is located.
  const char* const file_;
  // The line number on which the death test is located.
  const int line_;
  // The stderr data captured by the child process.
  std::string captured_stderr_;

  zx::process child_process_;
  zx::channel exception_channel_;
  zx::socket stderr_socket_;
};

// Utility class for accumulating command-line arguments.
class Arguments {
 public:
  Arguments() { args_.push_back(nullptr); }

  ~Arguments() {
    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
         ++i) {
      free(*i);
    }
  }
  void AddArgument(const char* argument) {
    args_.insert(args_.end() - 1, posix::StrDup(argument));
  }

  template <typename Str>
  void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }
  char* const* Argv() {
    return &args_[0];
  }

  int size() {
    return static_cast<int>(args_.size()) - 1;
  }

 private:
  std::vector<char*> args_;
};

// Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists.  As a side effect, sets the
// outcome data member.
int FuchsiaDeathTest::Wait() {
  const int kProcessKey = 0;
  const int kSocketKey = 1;
  const int kExceptionKey = 2;

  if (!spawned())
    return 0;

  // Create a port to wait for socket/task/exception events.
  zx_status_t status_zx;
  zx::port port;
  status_zx = zx::port::create(0, &port);
  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

  // Register to wait for the child process to terminate.
  status_zx = child_process_.wait_async(
      port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

  // Register to wait for the socket to be readable or closed.
  status_zx = stderr_socket_.wait_async(
      port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

  // Register to wait for an exception.
  status_zx = exception_channel_.wait_async(
      port, kExceptionKey, ZX_CHANNEL_READABLE, 0);
  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

  bool process_terminated = false;
  bool socket_closed = false;
  do {
    zx_port_packet_t packet = {};
    status_zx = port.wait(zx::time::infinite(), &packet);
    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

    if (packet.key == kExceptionKey) {
      // Process encountered an exception. Kill it directly rather than
      // letting other handlers process the event. We will get a kProcessKey
      // event when the process actually terminates.
      status_zx = child_process_.kill();
      GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
    } else if (packet.key == kProcessKey) {
      // Process terminated.
      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
      GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
      process_terminated = true;
    } else if (packet.key == kSocketKey) {
      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
      if (packet.signal.observed & ZX_SOCKET_READABLE) {
        // Read data from the socket.
        constexpr size_t kBufferSize = 1024;
        do {
          size_t old_length = captured_stderr_.length();
          size_t bytes_read = 0;
          captured_stderr_.resize(old_length + kBufferSize);
          status_zx = stderr_socket_.read(
              0, &captured_stderr_.front() + old_length, kBufferSize,
              &bytes_read);
          captured_stderr_.resize(old_length + bytes_read);
        } while (status_zx == ZX_OK);
        if (status_zx == ZX_ERR_PEER_CLOSED) {
          socket_closed = true;
        } else {
          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
          status_zx = stderr_socket_.wait_async(
              port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
        }
      } else {
        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED);
        socket_closed = true;
      }
    }
  } while (!process_terminated && !socket_closed);

  ReadAndInterpretStatusByte();

  zx_info_process_v2_t buffer;
  status_zx = child_process_.get_info(
      ZX_INFO_PROCESS_V2, &buffer, sizeof(buffer), nullptr, nullptr);
  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);

  GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED);
  set_status(static_cast<int>(buffer.return_code));
  return status();
}

// The AssumeRole process for a Fuchsia death test.  It creates a child
// process with the same executable as the current process to run the
// death test.  The child process is given the --gtest_filter and
// --gtest_internal_run_death_test flags such that it knows to run the
// current death test only.
DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
  const UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const TestInfo* const info = impl->current_test_info();
  const int death_test_index = info->result()->death_test_count();

  if (flag != nullptr) {
    // ParseInternalRunDeathTestFlag() has performed all the necessary
    // processing.
    set_write_fd(kFuchsiaReadPipeFd);
    return EXECUTE_TEST;
  }

  // Flush the log buffers since the log streams are shared with the child.
  FlushInfoLog();

  // Build the child process command line.
  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
                                  kFilterFlag + "=" + info->test_suite_name() +
                                  "." + info->name();
  const std::string internal_flag =
      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
      + file_ + "|"
      + StreamableToString(line_) + "|"
      + StreamableToString(death_test_index);
  Arguments args;
  args.AddArguments(GetInjectableArgvs());
  args.AddArgument(filter_flag.c_str());
  args.AddArgument(internal_flag.c_str());

  // Build the pipe for communication with the child.
  zx_status_t status;
  zx_handle_t child_pipe_handle;
  int child_pipe_fd;
  status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
  set_read_fd(child_pipe_fd);

  // Set the pipe handle for the child.
  fdio_spawn_action_t spawn_actions[2] = {};
  fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
  add_handle_action->h.handle = child_pipe_handle;

  // Create a socket pair will be used to receive the child process' stderr.
  zx::socket stderr_producer_socket;
  status =
      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
  GTEST_DEATH_TEST_CHECK_(status >= 0);
  int stderr_producer_fd = -1;
  status =
      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd);
  GTEST_DEATH_TEST_CHECK_(status >= 0);

  // Make the stderr socket nonblocking.
  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);

  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
  add_stderr_action->fd.local_fd = stderr_producer_fd;
  add_stderr_action->fd.target_fd = STDERR_FILENO;

  // Create a child job.
  zx_handle_t child_job = ZX_HANDLE_INVALID;
  status = zx_job_create(zx_job_default(), 0, & child_job);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
  zx_policy_basic_t policy;
  policy.condition = ZX_POL_NEW_ANY;
  policy.policy = ZX_POL_ACTION_ALLOW;
  status = zx_job_set_policy(
      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);

  // Create an exception channel attached to the |child_job|, to allow
  // us to suppress the system default exception handler from firing.
  status =
      zx_task_create_exception_channel(
          child_job, 0, exception_channel_.reset_and_get_address());
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);

  // Spawn the child process.
  status = fdio_spawn_etc(
      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);

  set_spawned(true);
  return OVERSEE_TEST;
}

std::string FuchsiaDeathTest::GetErrorLogs() {
  return captured_stderr_;
}

#else  // We are neither on Windows, nor on Fuchsia.

// ForkingDeathTest provides implementations for most of the abstract
// methods of the DeathTest interface.  Only the AssumeRole method is
// left undefined.
class ForkingDeathTest : public DeathTestImpl {
 public:
  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher);

  // All of these virtual functions are inherited from DeathTest.
  int Wait() override;

 protected:
  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }

 private:
  // PID of child process during death test; 0 in the child process itself.
  pid_t child_pid_;
};

// Constructs a ForkingDeathTest.
ForkingDeathTest::ForkingDeathTest(const char* a_statement,
                                   Matcher<const std::string&> matcher)
    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}

// Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists.  As a side effect, sets the
// outcome data member.
int ForkingDeathTest::Wait() {
  if (!spawned())
    return 0;

  ReadAndInterpretStatusByte();

  int status_value;
  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
  set_status(status_value);
  return status_value;
}

// A concrete death test class that forks, then immediately runs the test
// in the child process.
class NoExecDeathTest : public ForkingDeathTest {
 public:
  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
      : ForkingDeathTest(a_statement, std::move(matcher)) {}
  TestRole AssumeRole() override;
};

// The AssumeRole process for a fork-and-run death test.  It implements a
// straightforward fork, with a simple pipe to transmit the status byte.
DeathTest::TestRole NoExecDeathTest::AssumeRole() {
  const size_t thread_count = GetThreadCount();
  if (thread_count != 1) {
    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
  }

  int pipe_fd[2];
  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);

  DeathTest::set_last_death_test_message("");
  CaptureStderr();
  // When we fork the process below, the log file buffers are copied, but the
  // file descriptors are shared.  We flush all log files here so that closing
  // the file descriptors in the child process doesn't throw off the
  // synchronization between descriptors and buffers in the parent process.
  // This is as close to the fork as possible to avoid a race condition in case
  // there are multiple threads running before the death test, and another
  // thread writes to the log file.
  FlushInfoLog();

  const pid_t child_pid = fork();
  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
  set_child_pid(child_pid);
  if (child_pid == 0) {
    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
    set_write_fd(pipe_fd[1]);
    // Redirects all logging to stderr in the child process to prevent
    // concurrent writes to the log files.  We capture stderr in the parent
    // process and append the child process' output to a log.
    LogToStderr();
    // Event forwarding to the listeners of event listener API mush be shut
    // down in death test subprocesses.
    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
    g_in_fast_death_test_child = true;
    return EXECUTE_TEST;
  } else {
    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
    set_read_fd(pipe_fd[0]);
    set_spawned(true);
    return OVERSEE_TEST;
  }
}

// A concrete death test class that forks and re-executes the main
// program from the beginning, with command-line flags set that cause
// only this specific death test to be run.
class ExecDeathTest : public ForkingDeathTest {
 public:
  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
                const char* file, int line)
      : ForkingDeathTest(a_statement, std::move(matcher)),
        file_(file),
        line_(line) {}
  TestRole AssumeRole() override;

 private:
  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
    ::std::vector<std::string> args = GetInjectableArgvs();
#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
    ::std::vector<std::string> extra_args =
        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
    args.insert(args.end(), extra_args.begin(), extra_args.end());
#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
    return args;
  }
  // The name of the file in which the death test is located.
  const char* const file_;
  // The line number on which the death test is located.
  const int line_;
};

// Utility class for accumulating command-line arguments.
class Arguments {
 public:
  Arguments() { args_.push_back(nullptr); }

  ~Arguments() {
    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
         ++i) {
      free(*i);
    }
  }
  void AddArgument(const char* argument) {
    args_.insert(args_.end() - 1, posix::StrDup(argument));
  }

  template <typename Str>
  void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }
  char* const* Argv() {
    return &args_[0];
  }

 private:
  std::vector<char*> args_;
};

// A struct that encompasses the arguments to the child process of a
// threadsafe-style death test process.
struct ExecDeathTestArgs {
  char* const* argv;  // Command-line arguments for the child's call to exec
  int close_fd;       // File descriptor to close; the read end of a pipe
};

#  if GTEST_OS_QNX
extern "C" char** environ;
#  else  // GTEST_OS_QNX
// The main function for a threadsafe-style death test child process.
// This function is called in a clone()-ed process and thus must avoid
// any potentially unsafe operations like malloc or libc functions.
static int ExecDeathTestChildMain(void* child_arg) {
  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));

  // We need to execute the test program in the same environment where
  // it was originally invoked.  Therefore we change to the original
  // working directory first.
  const char* const original_dir =
      UnitTest::GetInstance()->original_working_dir();
  // We can safely call chdir() as it's a direct system call.
  if (chdir(original_dir) != 0) {
    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
                   GetLastErrnoDescription());
    return EXIT_FAILURE;
  }

  // We can safely call execv() as it's almost a direct system call. We
  // cannot use execvp() as it's a libc function and thus potentially
  // unsafe.  Since execv() doesn't search the PATH, the user must
  // invoke the test program via a valid path that contains at least
  // one path separator.
  execv(args->argv[0], args->argv);
  DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
                 original_dir + " failed: " +
                 GetLastErrnoDescription());
  return EXIT_FAILURE;
}
#  endif  // GTEST_OS_QNX

#  if GTEST_HAS_CLONE
// Two utility routines that together determine the direction the stack
// grows.
// This could be accomplished more elegantly by a single recursive
// function, but we want to guard against the unlikely possibility of
// a smart compiler optimizing the recursion away.
//
// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
// StackLowerThanAddress into StackGrowsDown, which then doesn't give
// correct answer.
static void StackLowerThanAddress(const void* ptr,
                                  bool* result) GTEST_NO_INLINE_;
// Make sure sanitizers do not tamper with the stack here.
// Ideally, we want to use `__builtin_frame_address` instead of a local variable
// address with sanitizer disabled, but it does not work when the
// compiler optimizes the stack frame out, which happens on PowerPC targets.
// HWAddressSanitizer add a random tag to the MSB of the local variable address,
// making comparison result unpredictable.
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
static void StackLowerThanAddress(const void* ptr, bool* result) {
  int dummy = 0;
  *result = std::less<const void*>()(&dummy, ptr);
}

// Make sure AddressSanitizer does not tamper with the stack here.
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
static bool StackGrowsDown() {
  int dummy = 0;
  bool result;
  StackLowerThanAddress(&dummy, &result);
  return result;
}
#  endif  // GTEST_HAS_CLONE

// Spawns a child process with the same executable as the current process in
// a thread-safe manner and instructs it to run the death test.  The
// implementation uses fork(2) + exec.  On systems where clone(2) is
// available, it is used instead, being slightly more thread-safe.  On QNX,
// fork supports only single-threaded environments, so this function uses
// spawn(2) there instead.  The function dies with an error message if
// anything goes wrong.
static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
  ExecDeathTestArgs args = { argv, close_fd };
  pid_t child_pid = -1;

#  if GTEST_OS_QNX
  // Obtains the current directory and sets it to be closed in the child
  // process.
  const int cwd_fd = open(".", O_RDONLY);
  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
  // We need to execute the test program in the same environment where
  // it was originally invoked.  Therefore we change to the original
  // working directory first.
  const char* const original_dir =
      UnitTest::GetInstance()->original_working_dir();
  // We can safely call chdir() as it's a direct system call.
  if (chdir(original_dir) != 0) {
    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
                   GetLastErrnoDescription());
    return EXIT_FAILURE;
  }

  int fd_flags;
  // Set close_fd to be closed after spawn.
  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
                                        fd_flags | FD_CLOEXEC));
  struct inheritance inherit = {0};
  // spawn is a system call.
  child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
  // Restores the current working directory.
  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));

#  else   // GTEST_OS_QNX
#   if GTEST_OS_LINUX
  // When a SIGPROF signal is received while fork() or clone() are executing,
  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
  // it after the call to fork()/clone() is complete.
  struct sigaction saved_sigprof_action;
  struct sigaction ignore_sigprof_action;
  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
  sigemptyset(&ignore_sigprof_action.sa_mask);
  ignore_sigprof_action.sa_handler = SIG_IGN;
  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
#   endif  // GTEST_OS_LINUX

#   if GTEST_HAS_CLONE
  const bool use_fork = GTEST_FLAG(death_test_use_fork);

  if (!use_fork) {
    static const bool stack_grows_down = StackGrowsDown();
    const auto stack_size = static_cast<size_t>(getpagesize() * 2);
    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
                             MAP_ANON | MAP_PRIVATE, -1, 0);
    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);

    // Maximum stack alignment in bytes:  For a downward-growing stack, this
    // amount is subtracted from size of the stack space to get an address
    // that is within the stack space and is aligned on all systems we care
    // about.  As far as I know there is no ABI with stack alignment greater
    // than 64.  We assume stack and stack_size already have alignment of
    // kMaxStackAlignment.
    const size_t kMaxStackAlignment = 64;
    void* const stack_top =
        static_cast<char*>(stack) +
            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
    GTEST_DEATH_TEST_CHECK_(
        static_cast<size_t>(stack_size) > kMaxStackAlignment &&
        reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);

    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);

    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
  }
#   else
  const bool use_fork = true;
#   endif  // GTEST_HAS_CLONE

  if (use_fork && (child_pid = fork()) == 0) {
      ExecDeathTestChildMain(&args);
      _exit(0);
  }
#  endif  // GTEST_OS_QNX
#  if GTEST_OS_LINUX
  GTEST_DEATH_TEST_CHECK_SYSCALL_(
      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
#  endif  // GTEST_OS_LINUX

  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
  return child_pid;
}

// The AssumeRole process for a fork-and-exec death test.  It re-executes the
// main program from the beginning, setting the --gtest_filter
// and --gtest_internal_run_death_test flags to cause only the current
// death test to be re-run.
DeathTest::TestRole ExecDeathTest::AssumeRole() {
  const UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const TestInfo* const info = impl->current_test_info();
  const int death_test_index = info->result()->death_test_count();

  if (flag != nullptr) {
    set_write_fd(flag->write_fd());
    return EXECUTE_TEST;
  }

  int pipe_fd[2];
  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
  // Clear the close-on-exec flag on the write end of the pipe, lest
  // it be closed when the child process does an exec:
  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);

  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
                                  kFilterFlag + "=" + info->test_suite_name() +
                                  "." + info->name();
  const std::string internal_flag =
      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
      + file_ + "|" + StreamableToString(line_) + "|"
      + StreamableToString(death_test_index) + "|"
      + StreamableToString(pipe_fd[1]);
  Arguments args;
  args.AddArguments(GetArgvsForDeathTestChildProcess());
  args.AddArgument(filter_flag.c_str());
  args.AddArgument(internal_flag.c_str());

  DeathTest::set_last_death_test_message("");

  CaptureStderr();
  // See the comment in NoExecDeathTest::AssumeRole for why the next line
  // is necessary.
  FlushInfoLog();

  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
  set_child_pid(child_pid);
  set_read_fd(pipe_fd[0]);
  set_spawned(true);
  return OVERSEE_TEST;
}

# endif  // !GTEST_OS_WINDOWS

// Creates a concrete DeathTest-derived class that depends on the
// --gtest_death_test_style flag, and sets the pointer pointed to
// by the "test" argument to its address.  If the test should be
// skipped, sets that pointer to NULL.  Returns true, unless the
// flag is set to an invalid value.
bool DefaultDeathTestFactory::Create(const char* statement,
                                     Matcher<const std::string&> matcher,
                                     const char* file, int line,
                                     DeathTest** test) {
  UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const int death_test_index = impl->current_test_info()
      ->increment_death_test_count();

  if (flag != nullptr) {
    if (death_test_index > flag->index()) {
      DeathTest::set_last_death_test_message(
          "Death test count (" + StreamableToString(death_test_index)
          + ") somehow exceeded expected maximum ("
          + StreamableToString(flag->index()) + ")");
      return false;
    }

    if (!(flag->file() == file && flag->line() == line &&
          flag->index() == death_test_index)) {
      *test = nullptr;
      return true;
    }
  }

# if GTEST_OS_WINDOWS

  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
      GTEST_FLAG(death_test_style) == "fast") {
    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
  }

# elif GTEST_OS_FUCHSIA

  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
      GTEST_FLAG(death_test_style) == "fast") {
    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
  }

# else

  if (GTEST_FLAG(death_test_style) == "threadsafe") {
    *test = new ExecDeathTest(statement, std::move(matcher), file, line);
  } else if (GTEST_FLAG(death_test_style) == "fast") {
    *test = new NoExecDeathTest(statement, std::move(matcher));
  }

# endif  // GTEST_OS_WINDOWS

  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
    DeathTest::set_last_death_test_message(
        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
        + "\" encountered");
    return false;
  }

  return true;
}

# if GTEST_OS_WINDOWS
// Recreates the pipe and event handles from the provided parameters,
// signals the event, and returns a file descriptor wrapped around the pipe
// handle. This function is called in the child process only.
static int GetStatusFileDescriptor(unsigned int parent_process_id,
                            size_t write_handle_as_size_t,
                            size_t event_handle_as_size_t) {
  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
                                                   FALSE,  // Non-inheritable.
                                                   parent_process_id));
  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
    DeathTestAbort("Unable to open parent process " +
                   StreamableToString(parent_process_id));
  }

  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));

  const HANDLE write_handle =
      reinterpret_cast<HANDLE>(write_handle_as_size_t);
  HANDLE dup_write_handle;

  // The newly initialized handle is accessible only in the parent
  // process. To obtain one accessible within the child, we need to use
  // DuplicateHandle.
  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
                         ::GetCurrentProcess(), &dup_write_handle,
                         0x0,    // Requested privileges ignored since
                                 // DUPLICATE_SAME_ACCESS is used.
                         FALSE,  // Request non-inheritable handler.
                         DUPLICATE_SAME_ACCESS)) {
    DeathTestAbort("Unable to duplicate the pipe handle " +
                   StreamableToString(write_handle_as_size_t) +
                   " from the parent process " +
                   StreamableToString(parent_process_id));
  }

  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
  HANDLE dup_event_handle;

  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
                         ::GetCurrentProcess(), &dup_event_handle,
                         0x0,
                         FALSE,
                         DUPLICATE_SAME_ACCESS)) {
    DeathTestAbort("Unable to duplicate the event handle " +
                   StreamableToString(event_handle_as_size_t) +
                   " from the parent process " +
                   StreamableToString(parent_process_id));
  }

  const int write_fd =
      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
  if (write_fd == -1) {
    DeathTestAbort("Unable to convert pipe handle " +
                   StreamableToString(write_handle_as_size_t) +
                   " to a file descriptor");
  }

  // Signals the parent that the write end of the pipe has been acquired
  // so the parent can release its own write end.
  ::SetEvent(dup_event_handle);

  return write_fd;
}
# endif  // GTEST_OS_WINDOWS

// Returns a newly created InternalRunDeathTestFlag object with fields
// initialized from the GTEST_FLAG(internal_run_death_test) flag if
// the flag is specified; otherwise returns NULL.
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;

  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
  // can use it here.
  int line = -1;
  int index = -1;
  ::std::vector< ::std::string> fields;
  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
  int write_fd = -1;

# if GTEST_OS_WINDOWS

  unsigned int parent_process_id = 0;
  size_t write_handle_as_size_t = 0;
  size_t event_handle_as_size_t = 0;

  if (fields.size() != 6
      || !ParseNaturalNumber(fields[1], &line)
      || !ParseNaturalNumber(fields[2], &index)
      || !ParseNaturalNumber(fields[3], &parent_process_id)
      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
                   GTEST_FLAG(internal_run_death_test));
  }
  write_fd = GetStatusFileDescriptor(parent_process_id,
                                     write_handle_as_size_t,
                                     event_handle_as_size_t);

# elif GTEST_OS_FUCHSIA

  if (fields.size() != 3
      || !ParseNaturalNumber(fields[1], &line)
      || !ParseNaturalNumber(fields[2], &index)) {
    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
        + GTEST_FLAG(internal_run_death_test));
  }

# else

  if (fields.size() != 4
      || !ParseNaturalNumber(fields[1], &line)
      || !ParseNaturalNumber(fields[2], &index)
      || !ParseNaturalNumber(fields[3], &write_fd)) {
    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
        + GTEST_FLAG(internal_run_death_test));
  }

# endif  // GTEST_OS_WINDOWS

  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
}

}  // namespace internal

#endif  // GTEST_HAS_DEATH_TEST

}  // namespace testing
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#include <stdlib.h>

#if GTEST_OS_WINDOWS_MOBILE
# include <windows.h>
#elif GTEST_OS_WINDOWS
# include <direct.h>
# include <io.h>
#else
# include <limits.h>
# include <climits>  // Some Linux distributions define PATH_MAX here.
#endif  // GTEST_OS_WINDOWS_MOBILE


#if GTEST_OS_WINDOWS
# define GTEST_PATH_MAX_ _MAX_PATH
#elif defined(PATH_MAX)
# define GTEST_PATH_MAX_ PATH_MAX
#elif defined(_XOPEN_PATH_MAX)
# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
#else
# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
#endif  // GTEST_OS_WINDOWS

namespace testing {
namespace internal {

#if GTEST_OS_WINDOWS
// On Windows, '\\' is the standard path separator, but many tools and the
// Windows API also accept '/' as an alternate path separator. Unless otherwise
// noted, a file path can contain either kind of path separators, or a mixture
// of them.
const char kPathSeparator = '\\';
const char kAlternatePathSeparator = '/';
const char kAlternatePathSeparatorString[] = "/";
# if GTEST_OS_WINDOWS_MOBILE
// Windows CE doesn't have a current directory. You should not use
// the current directory in tests on Windows CE, but this at least
// provides a reasonable fallback.
const char kCurrentDirectoryString[] = "\\";
// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
const DWORD kInvalidFileAttributes = 0xffffffff;
# else
const char kCurrentDirectoryString[] = ".\\";
# endif  // GTEST_OS_WINDOWS_MOBILE
#else
const char kPathSeparator = '/';
const char kCurrentDirectoryString[] = "./";
#endif  // GTEST_OS_WINDOWS

// Returns whether the given character is a valid path separator.
static bool IsPathSeparator(char c) {
#if GTEST_HAS_ALT_PATH_SEP_
  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
#else
  return c == kPathSeparator;
#endif
}

// Returns the current working directory, or "" if unsuccessful.
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
    GTEST_OS_XTENSA
  // These platforms do not have a current directory, so we just return
  // something reasonable.
  return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
#else
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  char* result = getcwd(cwd, sizeof(cwd));
# if GTEST_OS_NACL
  // getcwd will likely fail in NaCl due to the sandbox, so return something
  // reasonable. The user may have provided a shim implementation for getcwd,
  // however, so fallback only when failure is detected.
  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
# endif  // GTEST_OS_NACL
  return FilePath(result == nullptr ? "" : cwd);
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Returns a copy of the FilePath with the case-insensitive extension removed.
// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
// FilePath("dir/file"). If a case-insensitive extension is not
// found, returns a copy of the original FilePath.
FilePath FilePath::RemoveExtension(const char* extension) const {
  const std::string dot_extension = std::string(".") + extension;
  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
    return FilePath(pathname_.substr(
        0, pathname_.length() - dot_extension.length()));
  }
  return *this;
}

// Returns a pointer to the last occurrence of a valid path separator in
// the FilePath. On Windows, for example, both '/' and '\' are valid path
// separators. Returns NULL if no path separator was found.
const char* FilePath::FindLastPathSeparator() const {
  const char* const last_sep = strrchr(c_str(), kPathSeparator);
#if GTEST_HAS_ALT_PATH_SEP_
  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
  // Comparing two pointers of which only one is NULL is undefined.
  if (last_alt_sep != nullptr &&
      (last_sep == nullptr || last_alt_sep > last_sep)) {
    return last_alt_sep;
  }
#endif
  return last_sep;
}

// Returns a copy of the FilePath with the directory part removed.
// Example: FilePath("path/to/file").RemoveDirectoryName() returns
// FilePath("file"). If there is no directory part ("just_a_file"), it returns
// the FilePath unmodified. If there is no file part ("just_a_dir/") it
// returns an empty FilePath ("").
// On Windows platform, '\' is the path separator, otherwise it is '/'.
FilePath FilePath::RemoveDirectoryName() const {
  const char* const last_sep = FindLastPathSeparator();
  return last_sep ? FilePath(last_sep + 1) : *this;
}

// RemoveFileName returns the directory path with the filename removed.
// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
// On Windows platform, '\' is the path separator, otherwise it is '/'.
FilePath FilePath::RemoveFileName() const {
  const char* const last_sep = FindLastPathSeparator();
  std::string dir;
  if (last_sep) {
    dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
  } else {
    dir = kCurrentDirectoryString;
  }
  return FilePath(dir);
}

// Helper functions for naming files in a directory for xml output.

// Given directory = "dir", base_name = "test", number = 0,
// extension = "xml", returns "dir/test.xml". If number is greater
// than zero (e.g., 12), returns "dir/test_12.xml".
// On Windows platform, uses \ as the separator rather than /.
FilePath FilePath::MakeFileName(const FilePath& directory,
                                const FilePath& base_name,
                                int number,
                                const char* extension) {
  std::string file;
  if (number == 0) {
    file = base_name.string() + "." + extension;
  } else {
    file = base_name.string() + "_" + StreamableToString(number)
        + "." + extension;
  }
  return ConcatPaths(directory, FilePath(file));
}

// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
// On Windows, uses \ as the separator rather than /.
FilePath FilePath::ConcatPaths(const FilePath& directory,
                               const FilePath& relative_path) {
  if (directory.IsEmpty())
    return relative_path;
  const FilePath dir(directory.RemoveTrailingPathSeparator());
  return FilePath(dir.string() + kPathSeparator + relative_path.string());
}

// Returns true if pathname describes something findable in the file-system,
// either a file, directory, or whatever.
bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE
  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
  const DWORD attributes = GetFileAttributes(unicode);
  delete [] unicode;
  return attributes != kInvalidFileAttributes;
#else
  posix::StatStruct file_stat;
  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Returns true if pathname describes a directory in the file-system
// that exists.
bool FilePath::DirectoryExists() const {
  bool result = false;
#if GTEST_OS_WINDOWS
  // Don't strip off trailing separator if path is a root directory on
  // Windows (like "C:\\").
  const FilePath& path(IsRootDirectory() ? *this :
                                           RemoveTrailingPathSeparator());
#else
  const FilePath& path(*this);
#endif

#if GTEST_OS_WINDOWS_MOBILE
  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
  const DWORD attributes = GetFileAttributes(unicode);
  delete [] unicode;
  if ((attributes != kInvalidFileAttributes) &&
      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
    result = true;
  }
#else
  posix::StatStruct file_stat;
  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
      posix::IsDir(file_stat);
#endif  // GTEST_OS_WINDOWS_MOBILE

  return result;
}

// Returns true if pathname describes a root directory. (Windows has one
// root directory per disk drive.)
bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
  return pathname_.length() == 3 && IsAbsolutePath();
#else
  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
#endif
}

// Returns true if pathname describes an absolute path.
bool FilePath::IsAbsolutePath() const {
  const char* const name = pathname_.c_str();
#if GTEST_OS_WINDOWS
  return pathname_.length() >= 3 &&
     ((name[0] >= 'a' && name[0] <= 'z') ||
      (name[0] >= 'A' && name[0] <= 'Z')) &&
     name[1] == ':' &&
     IsPathSeparator(name[2]);
#else
  return IsPathSeparator(name[0]);
#endif
}

// Returns a pathname for a file that does not currently exist. The pathname
// will be directory/base_name.extension or
// directory/base_name_<number>.extension if directory/base_name.extension
// already exists. The number will be incremented until a pathname is found
// that does not already exist.
// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
// There could be a race condition if two or more processes are calling this
// function at the same time -- they could both pick the same filename.
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
                                          const FilePath& base_name,
                                          const char* extension) {
  FilePath full_pathname;
  int number = 0;
  do {
    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
  } while (full_pathname.FileOrDirectoryExists());
  return full_pathname;
}

// Returns true if FilePath ends with a path separator, which indicates that
// it is intended to represent a directory. Returns false otherwise.
// This does NOT check that a directory (or file) actually exists.
bool FilePath::IsDirectory() const {
  return !pathname_.empty() &&
         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
}

// Create directories so that path exists. Returns true if successful or if
// the directories already exist; returns false if unable to create directories
// for any reason.
bool FilePath::CreateDirectoriesRecursively() const {
  if (!this->IsDirectory()) {
    return false;
  }

  if (pathname_.length() == 0 || this->DirectoryExists()) {
    return true;
  }

  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
}

// Create the directory so that path exists. Returns true if successful or
// if the directory already exists; returns false if unable to create the
// directory for any reason, including if the parent directory does not
// exist. Not named "CreateDirectory" because that's a macro on Windows.
bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
  FilePath removed_sep(this->RemoveTrailingPathSeparator());
  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
  delete [] unicode;
#elif GTEST_OS_WINDOWS
  int result = _mkdir(pathname_.c_str());
#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
  // do nothing
  int result = 0;
#else
  int result = mkdir(pathname_.c_str(), 0777);
#endif  // GTEST_OS_WINDOWS_MOBILE

  if (result == -1) {
    return this->DirectoryExists();  // An error is OK if the directory exists.
  }
  return true;  // No error.
}

// If input name has a trailing separator character, remove it and return the
// name, otherwise return the name string unmodified.
// On Windows platform, uses \ as the separator, other platforms use /.
FilePath FilePath::RemoveTrailingPathSeparator() const {
  return IsDirectory()
      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
      : *this;
}

// Removes any redundant separators that might be in the pathname.
// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
// redundancies that might be in a pathname involving "." or "..".
void FilePath::Normalize() {
  auto out = pathname_.begin();

  for (const char character : pathname_) {
    if (!IsPathSeparator(character)) {
      *(out++) = character;
    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
      *(out++) = kPathSeparator;
    } else {
      continue;
    }
  }

  pathname_.erase(out, pathname_.end());
}

}  // namespace internal
}  // namespace testing
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The Google C++ Testing and Mocking Framework (Google Test)
//
// This file implements just enough of the matcher interface to allow
// EXPECT_DEATH and friends to accept a matcher argument.


#include <string>

namespace testing {

// Constructs a matcher that matches a const std::string& whose value is
// equal to s.
Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }

// Constructs a matcher that matches a const std::string& whose value is
// equal to s.
Matcher<const std::string&>::Matcher(const char* s) {
  *this = Eq(std::string(s));
}

// Constructs a matcher that matches a std::string whose value is equal to
// s.
Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }

// Constructs a matcher that matches a std::string whose value is equal to
// s.
Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }

#if GTEST_INTERNAL_HAS_STRING_VIEW
// Constructs a matcher that matches a const StringView& whose value is
// equal to s.
Matcher<const internal::StringView&>::Matcher(const std::string& s) {
  *this = Eq(s);
}

// Constructs a matcher that matches a const StringView& whose value is
// equal to s.
Matcher<const internal::StringView&>::Matcher(const char* s) {
  *this = Eq(std::string(s));
}

// Constructs a matcher that matches a const StringView& whose value is
// equal to s.
Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
  *this = Eq(std::string(s));
}

// Constructs a matcher that matches a StringView whose value is equal to
// s.
Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); }

// Constructs a matcher that matches a StringView whose value is equal to
// s.
Matcher<internal::StringView>::Matcher(const char* s) {
  *this = Eq(std::string(s));
}

// Constructs a matcher that matches a StringView whose value is equal to
// s.
Matcher<internal::StringView>::Matcher(internal::StringView s) {
  *this = Eq(std::string(s));
}
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

}  // namespace testing
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.



#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstdint>
#include <fstream>
#include <memory>

#if GTEST_OS_WINDOWS
# include <windows.h>
# include <io.h>
# include <sys/stat.h>
# include <map>  // Used in ThreadLocal.
# ifdef _MSC_VER
#  include <crtdbg.h>
# endif  // _MSC_VER
#else
# include <unistd.h>
#endif  // GTEST_OS_WINDOWS

#if GTEST_OS_MAC
# include <mach/mach_init.h>
# include <mach/task.h>
# include <mach/vm_map.h>
#endif  // GTEST_OS_MAC

#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
# include <sys/sysctl.h>
# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
#  include <sys/user.h>
# endif
#endif

#if GTEST_OS_QNX
# include <devctl.h>
# include <fcntl.h>
# include <sys/procfs.h>
#endif  // GTEST_OS_QNX

#if GTEST_OS_AIX
# include <procinfo.h>
# include <sys/types.h>
#endif  // GTEST_OS_AIX

#if GTEST_OS_FUCHSIA
# include <zircon/process.h>
# include <zircon/syscalls.h>
#endif  // GTEST_OS_FUCHSIA


namespace testing {
namespace internal {

#if defined(_MSC_VER) || defined(__BORLANDC__)
// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
const int kStdOutFileno = 1;
const int kStdErrFileno = 2;
#else
const int kStdOutFileno = STDOUT_FILENO;
const int kStdErrFileno = STDERR_FILENO;
#endif  // _MSC_VER

#if GTEST_OS_LINUX

namespace {
template <typename T>
T ReadProcFileField(const std::string& filename, int field) {
  std::string dummy;
  std::ifstream file(filename.c_str());
  while (field-- > 0) {
    file >> dummy;
  }
  T output = 0;
  file >> output;
  return output;
}
}  // namespace

// Returns the number of active threads, or 0 when there is an error.
size_t GetThreadCount() {
  const std::string filename =
      (Message() << "/proc/" << getpid() << "/stat").GetString();
  return ReadProcFileField<size_t>(filename, 19);
}

#elif GTEST_OS_MAC

size_t GetThreadCount() {
  const task_t task = mach_task_self();
  mach_msg_type_number_t thread_count;
  thread_act_array_t thread_list;
  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
  if (status == KERN_SUCCESS) {
    // task_threads allocates resources in thread_list and we need to free them
    // to avoid leaks.
    vm_deallocate(task,
                  reinterpret_cast<vm_address_t>(thread_list),
                  sizeof(thread_t) * thread_count);
    return static_cast<size_t>(thread_count);
  } else {
    return 0;
  }
}

#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
      GTEST_OS_NETBSD

#if GTEST_OS_NETBSD
#undef KERN_PROC
#define KERN_PROC KERN_PROC2
#define kinfo_proc kinfo_proc2
#endif

#if GTEST_OS_DRAGONFLY
#define KP_NLWP(kp) (kp.kp_nthreads)
#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
#define KP_NLWP(kp) (kp.ki_numthreads)
#elif GTEST_OS_NETBSD
#define KP_NLWP(kp) (kp.p_nlwps)
#endif

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount() {
  int mib[] = {
    CTL_KERN,
    KERN_PROC,
    KERN_PROC_PID,
    getpid(),
#if GTEST_OS_NETBSD
    sizeof(struct kinfo_proc),
    1,
#endif
  };
  u_int miblen = sizeof(mib) / sizeof(mib[0]);
  struct kinfo_proc info;
  size_t size = sizeof(info);
  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
    return 0;
  }
  return static_cast<size_t>(KP_NLWP(info));
}
#elif GTEST_OS_OPENBSD

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount() {
  int mib[] = {
    CTL_KERN,
    KERN_PROC,
    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
    getpid(),
    sizeof(struct kinfo_proc),
    0,
  };
  u_int miblen = sizeof(mib) / sizeof(mib[0]);

  // get number of structs
  size_t size;
  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
    return 0;
  }

  mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4]));

  // populate array of structs
  struct kinfo_proc info[mib[5]];
  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
    return 0;
  }

  // exclude empty members
  size_t nthreads = 0;
  for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) {
    if (info[i].p_tid != -1)
      nthreads++;
  }
  return nthreads;
}

#elif GTEST_OS_QNX

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
size_t GetThreadCount() {
  const int fd = open("/proc/self/as", O_RDONLY);
  if (fd < 0) {
    return 0;
  }
  procfs_info process_info;
  const int status =
      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr);
  close(fd);
  if (status == EOK) {
    return static_cast<size_t>(process_info.num_threads);
  } else {
    return 0;
  }
}

#elif GTEST_OS_AIX

size_t GetThreadCount() {
  struct procentry64 entry;
  pid_t pid = getpid();
  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
  if (status == 1) {
    return entry.pi_thcount;
  } else {
    return 0;
  }
}

#elif GTEST_OS_FUCHSIA

size_t GetThreadCount() {
  int dummy_buffer;
  size_t avail;
  zx_status_t status = zx_object_get_info(
      zx_process_self(),
      ZX_INFO_PROCESS_THREADS,
      &dummy_buffer,
      0,
      nullptr,
      &avail);
  if (status == ZX_OK) {
    return avail;
  } else {
    return 0;
  }
}

#else

size_t GetThreadCount() {
  // There's no portable way to detect the number of threads, so we just
  // return 0 to indicate that we cannot detect it.
  return 0;
}

#endif  // GTEST_OS_LINUX

#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS

void SleepMilliseconds(int n) {
  ::Sleep(static_cast<DWORD>(n));
}

AutoHandle::AutoHandle()
    : handle_(INVALID_HANDLE_VALUE) {}

AutoHandle::AutoHandle(Handle handle)
    : handle_(handle) {}

AutoHandle::~AutoHandle() {
  Reset();
}

AutoHandle::Handle AutoHandle::Get() const {
  return handle_;
}

void AutoHandle::Reset() {
  Reset(INVALID_HANDLE_VALUE);
}

void AutoHandle::Reset(HANDLE handle) {
  // Resetting with the same handle we already own is invalid.
  if (handle_ != handle) {
    if (IsCloseable()) {
      ::CloseHandle(handle_);
    }
    handle_ = handle;
  } else {
    GTEST_CHECK_(!IsCloseable())
        << "Resetting a valid handle to itself is likely a programmer error "
            "and thus not allowed.";
  }
}

bool AutoHandle::IsCloseable() const {
  // Different Windows APIs may use either of these values to represent an
  // invalid handle.
  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
}

Notification::Notification()
    : event_(::CreateEvent(nullptr,     // Default security attributes.
                           TRUE,        // Do not reset automatically.
                           FALSE,       // Initially unset.
                           nullptr)) {  // Anonymous event.
  GTEST_CHECK_(event_.Get() != nullptr);
}

void Notification::Notify() {
  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
}

void Notification::WaitForNotification() {
  GTEST_CHECK_(
      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
}

Mutex::Mutex()
    : owner_thread_id_(0),
      type_(kDynamic),
      critical_section_init_phase_(0),
      critical_section_(new CRITICAL_SECTION) {
  ::InitializeCriticalSection(critical_section_);
}

Mutex::~Mutex() {
  // Static mutexes are leaked intentionally. It is not thread-safe to try
  // to clean them up.
  if (type_ == kDynamic) {
    ::DeleteCriticalSection(critical_section_);
    delete critical_section_;
    critical_section_ = nullptr;
  }
}

void Mutex::Lock() {
  ThreadSafeLazyInit();
  ::EnterCriticalSection(critical_section_);
  owner_thread_id_ = ::GetCurrentThreadId();
}

void Mutex::Unlock() {
  ThreadSafeLazyInit();
  // We don't protect writing to owner_thread_id_ here, as it's the
  // caller's responsibility to ensure that the current thread holds the
  // mutex when this is called.
  owner_thread_id_ = 0;
  ::LeaveCriticalSection(critical_section_);
}

// Does nothing if the current thread holds the mutex. Otherwise, crashes
// with high probability.
void Mutex::AssertHeld() {
  ThreadSafeLazyInit();
  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
      << "The current thread is not holding the mutex @" << this;
}

namespace {

#ifdef _MSC_VER
// Use the RAII idiom to flag mem allocs that are intentionally never
// deallocated. The motivation is to silence the false positive mem leaks
// that are reported by the debug version of MS's CRT which can only detect
// if an alloc is missing a matching deallocation.
// Example:
//    MemoryIsNotDeallocated memory_is_not_deallocated;
//    critical_section_ = new CRITICAL_SECTION;
//
class MemoryIsNotDeallocated
{
 public:
  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
    // doesn't report mem leak if there's no matching deallocation.
    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
  }

  ~MemoryIsNotDeallocated() {
    // Restore the original _CRTDBG_ALLOC_MEM_DF flag
    _CrtSetDbgFlag(old_crtdbg_flag_);
  }

 private:
  int old_crtdbg_flag_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
};
#endif  // _MSC_VER

}  // namespace

// Initializes owner_thread_id_ and critical_section_ in static mutexes.
void Mutex::ThreadSafeLazyInit() {
  // Dynamic mutexes are initialized in the constructor.
  if (type_ == kStatic) {
    switch (
        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
      case 0:
        // If critical_section_init_phase_ was 0 before the exchange, we
        // are the first to test it and need to perform the initialization.
        owner_thread_id_ = 0;
        {
          // Use RAII to flag that following mem alloc is never deallocated.
#ifdef _MSC_VER
          MemoryIsNotDeallocated memory_is_not_deallocated;
#endif  // _MSC_VER
          critical_section_ = new CRITICAL_SECTION;
        }
        ::InitializeCriticalSection(critical_section_);
        // Updates the critical_section_init_phase_ to 2 to signal
        // initialization complete.
        GTEST_CHECK_(::InterlockedCompareExchange(
                          &critical_section_init_phase_, 2L, 1L) ==
                      1L);
        break;
      case 1:
        // Somebody else is already initializing the mutex; spin until they
        // are done.
        while (::InterlockedCompareExchange(&critical_section_init_phase_,
                                            2L,
                                            2L) != 2L) {
          // Possibly yields the rest of the thread's time slice to other
          // threads.
          ::Sleep(0);
        }
        break;

      case 2:
        break;  // The mutex is already initialized and ready for use.

      default:
        GTEST_CHECK_(false)
            << "Unexpected value of critical_section_init_phase_ "
            << "while initializing a static mutex.";
    }
  }
}

namespace {

class ThreadWithParamSupport : public ThreadWithParamBase {
 public:
  static HANDLE CreateThread(Runnable* runnable,
                             Notification* thread_can_start) {
    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
    DWORD thread_id;
    HANDLE thread_handle = ::CreateThread(
        nullptr,  // Default security.
        0,        // Default stack size.
        &ThreadWithParamSupport::ThreadMain,
        param,        // Parameter to ThreadMainStatic
        0x0,          // Default creation flags.
        &thread_id);  // Need a valid pointer for the call to work under Win98.
    GTEST_CHECK_(thread_handle != nullptr)
        << "CreateThread failed with error " << ::GetLastError() << ".";
    if (thread_handle == nullptr) {
      delete param;
    }
    return thread_handle;
  }

 private:
  struct ThreadMainParam {
    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
        : runnable_(runnable),
          thread_can_start_(thread_can_start) {
    }
    std::unique_ptr<Runnable> runnable_;
    // Does not own.
    Notification* thread_can_start_;
  };

  static DWORD WINAPI ThreadMain(void* ptr) {
    // Transfers ownership.
    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
    if (param->thread_can_start_ != nullptr)
      param->thread_can_start_->WaitForNotification();
    param->runnable_->Run();
    return 0;
  }

  // Prohibit instantiation.
  ThreadWithParamSupport();

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
};

}  // namespace

ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
                                         Notification* thread_can_start)
      : thread_(ThreadWithParamSupport::CreateThread(runnable,
                                                     thread_can_start)) {
}

ThreadWithParamBase::~ThreadWithParamBase() {
  Join();
}

void ThreadWithParamBase::Join() {
  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
      << "Failed to join the thread with error " << ::GetLastError() << ".";
}

// Maps a thread to a set of ThreadIdToThreadLocals that have values
// instantiated on that thread and notifies them when the thread exits.  A
// ThreadLocal instance is expected to persist until all threads it has
// values on have terminated.
class ThreadLocalRegistryImpl {
 public:
  // Registers thread_local_instance as having value on the current thread.
  // Returns a value that can be used to identify the thread from other threads.
  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
      const ThreadLocalBase* thread_local_instance) {
#ifdef _MSC_VER
    MemoryIsNotDeallocated memory_is_not_deallocated;
#endif  // _MSC_VER
    DWORD current_thread = ::GetCurrentThreadId();
    MutexLock lock(&mutex_);
    ThreadIdToThreadLocals* const thread_to_thread_locals =
        GetThreadLocalsMapLocked();
    ThreadIdToThreadLocals::iterator thread_local_pos =
        thread_to_thread_locals->find(current_thread);
    if (thread_local_pos == thread_to_thread_locals->end()) {
      thread_local_pos = thread_to_thread_locals->insert(
          std::make_pair(current_thread, ThreadLocalValues())).first;
      StartWatcherThreadFor(current_thread);
    }
    ThreadLocalValues& thread_local_values = thread_local_pos->second;
    ThreadLocalValues::iterator value_pos =
        thread_local_values.find(thread_local_instance);
    if (value_pos == thread_local_values.end()) {
      value_pos =
          thread_local_values
              .insert(std::make_pair(
                  thread_local_instance,
                  std::shared_ptr<ThreadLocalValueHolderBase>(
                      thread_local_instance->NewValueForCurrentThread())))
              .first;
    }
    return value_pos->second.get();
  }

  static void OnThreadLocalDestroyed(
      const ThreadLocalBase* thread_local_instance) {
    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
    // Clean up the ThreadLocalValues data structure while holding the lock, but
    // defer the destruction of the ThreadLocalValueHolderBases.
    {
      MutexLock lock(&mutex_);
      ThreadIdToThreadLocals* const thread_to_thread_locals =
          GetThreadLocalsMapLocked();
      for (ThreadIdToThreadLocals::iterator it =
          thread_to_thread_locals->begin();
          it != thread_to_thread_locals->end();
          ++it) {
        ThreadLocalValues& thread_local_values = it->second;
        ThreadLocalValues::iterator value_pos =
            thread_local_values.find(thread_local_instance);
        if (value_pos != thread_local_values.end()) {
          value_holders.push_back(value_pos->second);
          thread_local_values.erase(value_pos);
          // This 'if' can only be successful at most once, so theoretically we
          // could break out of the loop here, but we don't bother doing so.
        }
      }
    }
    // Outside the lock, let the destructor for 'value_holders' deallocate the
    // ThreadLocalValueHolderBases.
  }

  static void OnThreadExit(DWORD thread_id) {
    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
    // Clean up the ThreadIdToThreadLocals data structure while holding the
    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
    {
      MutexLock lock(&mutex_);
      ThreadIdToThreadLocals* const thread_to_thread_locals =
          GetThreadLocalsMapLocked();
      ThreadIdToThreadLocals::iterator thread_local_pos =
          thread_to_thread_locals->find(thread_id);
      if (thread_local_pos != thread_to_thread_locals->end()) {
        ThreadLocalValues& thread_local_values = thread_local_pos->second;
        for (ThreadLocalValues::iterator value_pos =
            thread_local_values.begin();
            value_pos != thread_local_values.end();
            ++value_pos) {
          value_holders.push_back(value_pos->second);
        }
        thread_to_thread_locals->erase(thread_local_pos);
      }
    }
    // Outside the lock, let the destructor for 'value_holders' deallocate the
    // ThreadLocalValueHolderBases.
  }

 private:
  // In a particular thread, maps a ThreadLocal object to its value.
  typedef std::map<const ThreadLocalBase*,
                   std::shared_ptr<ThreadLocalValueHolderBase> >
      ThreadLocalValues;
  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
  // thread's ID.
  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;

  // Holds the thread id and thread handle that we pass from
  // StartWatcherThreadFor to WatcherThreadFunc.
  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;

  static void StartWatcherThreadFor(DWORD thread_id) {
    // The returned handle will be kept in thread_map and closed by
    // watcher_thread in WatcherThreadFunc.
    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
                                 FALSE,
                                 thread_id);
    GTEST_CHECK_(thread != nullptr);
    // We need to pass a valid thread ID pointer into CreateThread for it
    // to work correctly under Win98.
    DWORD watcher_thread_id;
    HANDLE watcher_thread = ::CreateThread(
        nullptr,  // Default security.
        0,        // Default stack size
        &ThreadLocalRegistryImpl::WatcherThreadFunc,
        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
        CREATE_SUSPENDED, &watcher_thread_id);
    GTEST_CHECK_(watcher_thread != nullptr);
    // Give the watcher thread the same priority as ours to avoid being
    // blocked by it.
    ::SetThreadPriority(watcher_thread,
                        ::GetThreadPriority(::GetCurrentThread()));
    ::ResumeThread(watcher_thread);
    ::CloseHandle(watcher_thread);
  }

  // Monitors exit from a given thread and notifies those
  // ThreadIdToThreadLocals about thread termination.
  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
    const ThreadIdAndHandle* tah =
        reinterpret_cast<const ThreadIdAndHandle*>(param);
    GTEST_CHECK_(
        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
    OnThreadExit(tah->first);
    ::CloseHandle(tah->second);
    delete tah;
    return 0;
  }

  // Returns map of thread local instances.
  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
    mutex_.AssertHeld();
#ifdef _MSC_VER
    MemoryIsNotDeallocated memory_is_not_deallocated;
#endif  // _MSC_VER
    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
    return map;
  }

  // Protects access to GetThreadLocalsMapLocked() and its return value.
  static Mutex mutex_;
  // Protects access to GetThreadMapLocked() and its return value.
  static Mutex thread_map_mutex_;
};

Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);

ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
      const ThreadLocalBase* thread_local_instance) {
  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
      thread_local_instance);
}

void ThreadLocalRegistry::OnThreadLocalDestroyed(
      const ThreadLocalBase* thread_local_instance) {
  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
}

#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS

#if GTEST_USES_POSIX_RE

// Implements RE.  Currently only needed for death tests.

RE::~RE() {
  if (is_valid_) {
    // regfree'ing an invalid regex might crash because the content
    // of the regex is undefined. Since the regex's are essentially
    // the same, one cannot be valid (or invalid) without the other
    // being so too.
    regfree(&partial_regex_);
    regfree(&full_regex_);
  }
  free(const_cast<char*>(pattern_));
}

// Returns true if and only if regular expression re matches the entire str.
bool RE::FullMatch(const char* str, const RE& re) {
  if (!re.is_valid_) return false;

  regmatch_t match;
  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
}

// Returns true if and only if regular expression re matches a substring of
// str (including str itself).
bool RE::PartialMatch(const char* str, const RE& re) {
  if (!re.is_valid_) return false;

  regmatch_t match;
  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
}

// Initializes an RE from its string representation.
void RE::Init(const char* regex) {
  pattern_ = posix::StrDup(regex);

  // Reserves enough bytes to hold the regular expression used for a
  // full match.
  const size_t full_regex_len = strlen(regex) + 10;
  char* const full_pattern = new char[full_regex_len];

  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
  // We want to call regcomp(&partial_regex_, ...) even if the
  // previous expression returns false.  Otherwise partial_regex_ may
  // not be properly initialized can may cause trouble when it's
  // freed.
  //
  // Some implementation of POSIX regex (e.g. on at least some
  // versions of Cygwin) doesn't accept the empty string as a valid
  // regex.  We change it to an equivalent form "()" to be safe.
  if (is_valid_) {
    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
  }
  EXPECT_TRUE(is_valid_)
      << "Regular expression \"" << regex
      << "\" is not a valid POSIX Extended regular expression.";

  delete[] full_pattern;
}

#elif GTEST_USES_SIMPLE_RE

// Returns true if and only if ch appears anywhere in str (excluding the
// terminating '\0' character).
bool IsInSet(char ch, const char* str) {
  return ch != '\0' && strchr(str, ch) != nullptr;
}

// Returns true if and only if ch belongs to the given classification.
// Unlike similar functions in <ctype.h>, these aren't affected by the
// current locale.
bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
bool IsAsciiPunct(char ch) {
  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
}
bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
bool IsAsciiWordChar(char ch) {
  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
      ('0' <= ch && ch <= '9') || ch == '_';
}

// Returns true if and only if "\\c" is a supported escape sequence.
bool IsValidEscape(char c) {
  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
}

// Returns true if and only if the given atom (specified by escaped and
// pattern) matches ch.  The result is undefined if the atom is invalid.
bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
  if (escaped) {  // "\\p" where p is pattern_char.
    switch (pattern_char) {
      case 'd': return IsAsciiDigit(ch);
      case 'D': return !IsAsciiDigit(ch);
      case 'f': return ch == '\f';
      case 'n': return ch == '\n';
      case 'r': return ch == '\r';
      case 's': return IsAsciiWhiteSpace(ch);
      case 'S': return !IsAsciiWhiteSpace(ch);
      case 't': return ch == '\t';
      case 'v': return ch == '\v';
      case 'w': return IsAsciiWordChar(ch);
      case 'W': return !IsAsciiWordChar(ch);
    }
    return IsAsciiPunct(pattern_char) && pattern_char == ch;
  }

  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
}

// Helper function used by ValidateRegex() to format error messages.
static std::string FormatRegexSyntaxError(const char* regex, int index) {
  return (Message() << "Syntax error at index " << index
          << " in simple regular expression \"" << regex << "\": ").GetString();
}

// Generates non-fatal failures and returns false if regex is invalid;
// otherwise returns true.
bool ValidateRegex(const char* regex) {
  if (regex == nullptr) {
    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
    return false;
  }

  bool is_valid = true;

  // True if and only if ?, *, or + can follow the previous atom.
  bool prev_repeatable = false;
  for (int i = 0; regex[i]; i++) {
    if (regex[i] == '\\') {  // An escape sequence
      i++;
      if (regex[i] == '\0') {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
                      << "'\\' cannot appear at the end.";
        return false;
      }

      if (!IsValidEscape(regex[i])) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
                      << "invalid escape sequence \"\\" << regex[i] << "\".";
        is_valid = false;
      }
      prev_repeatable = true;
    } else {  // Not an escape sequence.
      const char ch = regex[i];

      if (ch == '^' && i > 0) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'^' can only appear at the beginning.";
        is_valid = false;
      } else if (ch == '$' && regex[i + 1] != '\0') {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'$' can only appear at the end.";
        is_valid = false;
      } else if (IsInSet(ch, "()[]{}|")) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'" << ch << "' is unsupported.";
        is_valid = false;
      } else if (IsRepeat(ch) && !prev_repeatable) {
        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
                      << "'" << ch << "' can only follow a repeatable token.";
        is_valid = false;
      }

      prev_repeatable = !IsInSet(ch, "^$?*+");
    }
  }

  return is_valid;
}

// Matches a repeated regex atom followed by a valid simple regular
// expression.  The regex atom is defined as c if escaped is false,
// or \c otherwise.  repeat is the repetition meta character (?, *,
// or +).  The behavior is undefined if str contains too many
// characters to be indexable by size_t, in which case the test will
// probably time out anyway.  We are fine with this limitation as
// std::string has it too.
bool MatchRepetitionAndRegexAtHead(
    bool escaped, char c, char repeat, const char* regex,
    const char* str) {
  const size_t min_count = (repeat == '+') ? 1 : 0;
  const size_t max_count = (repeat == '?') ? 1 :
      static_cast<size_t>(-1) - 1;
  // We cannot call numeric_limits::max() as it conflicts with the
  // max() macro on Windows.

  for (size_t i = 0; i <= max_count; ++i) {
    // We know that the atom matches each of the first i characters in str.
    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
      // We have enough matches at the head, and the tail matches too.
      // Since we only care about *whether* the pattern matches str
      // (as opposed to *how* it matches), there is no need to find a
      // greedy match.
      return true;
    }
    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
      return false;
  }
  return false;
}

// Returns true if and only if regex matches a prefix of str. regex must
// be a valid simple regular expression and not start with "^", or the
// result is undefined.
bool MatchRegexAtHead(const char* regex, const char* str) {
  if (*regex == '\0')  // An empty regex matches a prefix of anything.
    return true;

  // "$" only matches the end of a string.  Note that regex being
  // valid guarantees that there's nothing after "$" in it.
  if (*regex == '$')
    return *str == '\0';

  // Is the first thing in regex an escape sequence?
  const bool escaped = *regex == '\\';
  if (escaped)
    ++regex;
  if (IsRepeat(regex[1])) {
    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
    // here's an indirect recursion.  It terminates as the regex gets
    // shorter in each recursion.
    return MatchRepetitionAndRegexAtHead(
        escaped, regex[0], regex[1], regex + 2, str);
  } else {
    // regex isn't empty, isn't "$", and doesn't start with a
    // repetition.  We match the first atom of regex with the first
    // character of str and recurse.
    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
        MatchRegexAtHead(regex + 1, str + 1);
  }
}

// Returns true if and only if regex matches any substring of str.  regex must
// be a valid simple regular expression, or the result is undefined.
//
// The algorithm is recursive, but the recursion depth doesn't exceed
// the regex length, so we won't need to worry about running out of
// stack space normally.  In rare cases the time complexity can be
// exponential with respect to the regex length + the string length,
// but usually it's must faster (often close to linear).
bool MatchRegexAnywhere(const char* regex, const char* str) {
  if (regex == nullptr || str == nullptr) return false;

  if (*regex == '^')
    return MatchRegexAtHead(regex + 1, str);

  // A successful match can be anywhere in str.
  do {
    if (MatchRegexAtHead(regex, str))
      return true;
  } while (*str++ != '\0');
  return false;
}

// Implements the RE class.

RE::~RE() {
  free(const_cast<char*>(pattern_));
  free(const_cast<char*>(full_pattern_));
}

// Returns true if and only if regular expression re matches the entire str.
bool RE::FullMatch(const char* str, const RE& re) {
  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
}

// Returns true if and only if regular expression re matches a substring of
// str (including str itself).
bool RE::PartialMatch(const char* str, const RE& re) {
  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
}

// Initializes an RE from its string representation.
void RE::Init(const char* regex) {
  pattern_ = full_pattern_ = nullptr;
  if (regex != nullptr) {
    pattern_ = posix::StrDup(regex);
  }

  is_valid_ = ValidateRegex(regex);
  if (!is_valid_) {
    // No need to calculate the full pattern when the regex is invalid.
    return;
  }

  const size_t len = strlen(regex);
  // Reserves enough bytes to hold the regular expression used for a
  // full match: we need space to prepend a '^', append a '$', and
  // terminate the string with '\0'.
  char* buffer = static_cast<char*>(malloc(len + 3));
  full_pattern_ = buffer;

  if (*regex != '^')
    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.

  // We don't use snprintf or strncpy, as they trigger a warning when
  // compiled with VC++ 8.0.
  memcpy(buffer, regex, len);
  buffer += len;

  if (len == 0 || regex[len - 1] != '$')
    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.

  *buffer = '\0';
}

#endif  // GTEST_USES_POSIX_RE

const char kUnknownFile[] = "unknown file";

// Formats a source file path and a line number as they would appear
// in an error message from the compiler used to compile this code.
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const std::string file_name(file == nullptr ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

// Formats a file location for compiler-independent XML output.
// Although this function is not platform dependent, we put it next to
// FormatFileLocation in order to contrast the two functions.
// Note that FormatCompilerIndependentFileLocation() does NOT append colon
// to the file location it produces, unlike FormatFileLocation().
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
    const char* file, int line) {
  const std::string file_name(file == nullptr ? kUnknownFile : file);

  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
    : severity_(severity) {
  const char* const marker =
      severity == GTEST_INFO ?    "[  INFO ]" :
      severity == GTEST_WARNING ? "[WARNING]" :
      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
  GetStream() << ::std::endl << marker << " "
              << FormatFileLocation(file, line).c_str() << ": ";
}

// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
GTestLog::~GTestLog() {
  GetStream() << ::std::endl;
  if (severity_ == GTEST_FATAL) {
    fflush(stderr);
    posix::Abort();
  }
}

// Disable Microsoft deprecation warnings for POSIX functions called from
// this class (creat, dup, dup2, and close)
GTEST_DISABLE_MSC_DEPRECATED_PUSH_()

#if GTEST_HAS_STREAM_REDIRECTION

// Object that captures an output stream (stdout/stderr).
class CapturedStream {
 public:
  // The ctor redirects the stream to a temporary file.
  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
# if GTEST_OS_WINDOWS
    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT

    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
    const UINT success = ::GetTempFileNameA(temp_dir_path,
                                            "gtest_redir",
                                            0,  // Generate unique file name.
                                            temp_file_path);
    GTEST_CHECK_(success != 0)
        << "Unable to create a temporary file in " << temp_dir_path;
    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
                                    << temp_file_path;
    filename_ = temp_file_path;
# else
    // There's no guarantee that a test has write access to the current
    // directory, so we create the temporary file in the /tmp directory
    // instead. We use /tmp on most systems, and /sdcard on Android.
    // That's because Android doesn't have /tmp.
#  if GTEST_OS_LINUX_ANDROID
    // Note: Android applications are expected to call the framework's
    // Context.getExternalStorageDirectory() method through JNI to get
    // the location of the world-writable SD Card directory. However,
    // this requires a Context handle, which cannot be retrieved
    // globally from native code. Doing so also precludes running the
    // code as part of a regular standalone executable, which doesn't
    // run in a Dalvik process (e.g. when running it through 'adb shell').
    //
    // The location /data/local/tmp is directly accessible from native code.
    // '/sdcard' and other variants cannot be relied on, as they are not
    // guaranteed to be mounted, or may have a delay in mounting.
    char name_template[] = "/data/local/tmp/gtest_captured_stream.XXXXXX";
#  else
    char name_template[] = "/tmp/captured_stream.XXXXXX";
#  endif  // GTEST_OS_LINUX_ANDROID
    const int captured_fd = mkstemp(name_template);
    if (captured_fd == -1) {
      GTEST_LOG_(WARNING)
          << "Failed to create tmp file " << name_template
          << " for test; does the test have access to the /tmp directory?";
    }
    filename_ = name_template;
# endif  // GTEST_OS_WINDOWS
    fflush(nullptr);
    dup2(captured_fd, fd_);
    close(captured_fd);
  }

  ~CapturedStream() {
    remove(filename_.c_str());
  }

  std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(nullptr);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    if (file == nullptr) {
      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
                        << " for capturing stream.";
    }
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

 private:
  const int fd_;  // A stream to capture.
  int uncaptured_fd_;
  // Name of the temporary file holding the stderr output.
  ::std::string filename_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
};

GTEST_DISABLE_MSC_DEPRECATED_POP_()

static CapturedStream* g_captured_stderr = nullptr;
static CapturedStream* g_captured_stdout = nullptr;

// Starts capturing an output stream (stdout/stderr).
static void CaptureStream(int fd, const char* stream_name,
                          CapturedStream** stream) {
  if (*stream != nullptr) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Stops capturing the output stream and returns the captured string.
static std::string GetCapturedStream(CapturedStream** captured_stream) {
  const std::string content = (*captured_stream)->GetCapturedString();

  delete *captured_stream;
  *captured_stream = nullptr;

  return content;
}

// Starts capturing stdout.
void CaptureStdout() {
  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
}

// Starts capturing stderr.
void CaptureStderr() {
  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
}

// Stops capturing stdout and returns the captured string.
std::string GetCapturedStdout() {
  return GetCapturedStream(&g_captured_stdout);
}

// Stops capturing stderr and returns the captured string.
std::string GetCapturedStderr() {
  return GetCapturedStream(&g_captured_stderr);
}

#endif  // GTEST_HAS_STREAM_REDIRECTION





size_t GetFileSize(FILE* file) {
  fseek(file, 0, SEEK_END);
  return static_cast<size_t>(ftell(file));
}

std::string ReadEntireFile(FILE* file) {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far

  fseek(file, 0, SEEK_SET);

  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);

  const std::string content(buffer, bytes_read);
  delete[] buffer;

  return content;
}

#if GTEST_HAS_DEATH_TEST
static const std::vector<std::string>* g_injected_test_argvs =
    nullptr;  // Owned.

std::vector<std::string> GetInjectableArgvs() {
  if (g_injected_test_argvs != nullptr) {
    return *g_injected_test_argvs;
  }
  return GetArgvs();
}

void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs;
  g_injected_test_argvs = new_argvs;
}

void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
  SetInjectableArgvs(
      new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
}

void ClearInjectableArgvs() {
  delete g_injected_test_argvs;
  g_injected_test_argvs = nullptr;
}
#endif  // GTEST_HAS_DEATH_TEST

#if GTEST_OS_WINDOWS_MOBILE
namespace posix {
void Abort() {
  DebugBreak();
  TerminateProcess(GetCurrentProcess(), 1);
}
}  // namespace posix
#endif  // GTEST_OS_WINDOWS_MOBILE

// Returns the name of the environment variable corresponding to the
// given flag.  For example, FlagToEnvVar("foo") will return
// "GTEST_FOO" in the open-source version.
static std::string FlagToEnvVar(const char* flag) {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

// Parses 'str' for a 32-bit signed integer.  If successful, writes
// the result to *value and returns true; otherwise leaves *value
// unchanged and returns false.
bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
  // Parses the environment variable as a decimal integer.
  char* end = nullptr;
  const long long_value = strtol(str, &end, 10);  // NOLINT

  // Has strtol() consumed all characters in the string?
  if (*end != '\0') {
    // No - an invalid character was encountered.
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value \"" << str << "\".\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  // Is the parsed value in the range of an int32_t?
  const auto result = static_cast<int32_t>(long_value);
  if (long_value == LONG_MAX || long_value == LONG_MIN ||
      // The parsed value overflows as a long.  (strtol() returns
      // LONG_MAX or LONG_MIN when the input overflows.)
      result != long_value
      // The parsed value overflows as an int32_t.
      ) {
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  *value = result;
  return true;
}

// Reads and returns the Boolean environment variable corresponding to
// the given flag; if it's not set, returns default_value.
//
// The value is considered true if and only if it's not "0".
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == nullptr ? default_value
                                 : strcmp(string_value, "0") != 0;
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
}

// Reads and returns a 32-bit integer stored in the environment
// variable corresponding to the given flag; if it isn't set or
// doesn't represent a valid 32-bit integer, returns default_value.
int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == nullptr) {
    // The environment variable is not set.
    return default_value;
  }

  int32_t result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
}

// As a special case for the 'output' flag, if GTEST_OUTPUT is not
// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
// system.  The value of XML_OUTPUT_FILE is a filename without the
// "xml:" prefix of GTEST_OUTPUT.
// Note that this is meant to be called at the call site so it does
// not check that the flag is 'output'
// In essence this checks an env variable called XML_OUTPUT_FILE
// and if it is set we prepend "xml:" to its value, if it not set we return ""
std::string OutputFlagAlsoCheckEnvVar(){
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (nullptr != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

// Reads and returns the string environment variable corresponding to
// the given flag; if it's not set, returns default_value.
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const value = posix::GetEnv(env_var.c_str());
  return value == nullptr ? default_value : value;
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
}

}  // namespace internal
}  // namespace testing
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Test - The Google C++ Testing and Mocking Framework
//
// This file implements a universal value printer that can print a
// value of any type T:
//
//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
//
// It uses the << operator when possible, and prints the bytes in the
// object otherwise.  A user can override its behavior for a class
// type Foo by defining either operator<<(::std::ostream&, const Foo&)
// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
// defines Foo.


#include <stdio.h>

#include <cctype>
#include <cstdint>
#include <cwchar>
#include <ostream>  // NOLINT
#include <string>
#include <type_traits>


namespace testing {

namespace {

using ::std::ostream;

// Prints a segment of bytes in the given object.
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
                                size_t count, ostream* os) {
  char text[5] = "";
  for (size_t i = 0; i != count; i++) {
    const size_t j = start + i;
    if (i != 0) {
      // Organizes the bytes into groups of 2 for easy parsing by
      // human.
      if ((j % 2) == 0)
        *os << ' ';
      else
        *os << '-';
    }
    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
    *os << text;
  }
}

// Prints the bytes in the given value to the given ostream.
void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
                              ostream* os) {
  // Tells the user how big the object is.
  *os << count << "-byte object <";

  const size_t kThreshold = 132;
  const size_t kChunkSize = 64;
  // If the object size is bigger than kThreshold, we'll have to omit
  // some details by printing only the first and the last kChunkSize
  // bytes.
  if (count < kThreshold) {
    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
  } else {
    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
    *os << " ... ";
    // Rounds up to 2-byte boundary.
    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
  }
  *os << ">";
}

// Helpers for widening a character to char32_t. Since the standard does not
// specify if char / wchar_t is signed or unsigned, it is important to first
// convert it to the unsigned type of the same width before widening it to
// char32_t.
template <typename CharType>
char32_t ToChar32(CharType in) {
  return static_cast<char32_t>(
      static_cast<typename std::make_unsigned<CharType>::type>(in));
}

}  // namespace

namespace internal {

// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
// given object.  The delegation simplifies the implementation, which
// uses the << operator and thus is easier done outside of the
// ::testing::internal namespace, which contains a << operator that
// sometimes conflicts with the one in STL.
void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
                          ostream* os) {
  PrintBytesInObjectToImpl(obj_bytes, count, os);
}

// Depending on the value of a char (or wchar_t), we print it in one
// of three formats:
//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
//   - as a hexadecimal escape sequence (e.g. '\x7F'), or
//   - as a special escape sequence (e.g. '\r', '\n').
enum CharFormat {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

// Returns true if c is a printable ASCII character.  We test the
// value of c directly instead of calling isprint(), which is buggy on
// Windows Mobile.
inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; }

// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a
// character literal without the quotes, escaping it when necessary; returns how
// c was formatted.
template <typename Char>
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  const char32_t u_c = ToChar32(c);
  switch (u_c) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(u_c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c);
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Prints a char32_t c as if it's part of a string literal, escaping it when
// necessary; returns how c was formatted.
static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo(c, os);
  }
}

static const char* GetCharWidthPrefix(char) {
  return "";
}

static const char* GetCharWidthPrefix(signed char) {
  return "";
}

static const char* GetCharWidthPrefix(unsigned char) {
  return "";
}

#ifdef __cpp_char8_t
static const char* GetCharWidthPrefix(char8_t) {
  return "u8";
}
#endif

static const char* GetCharWidthPrefix(char16_t) {
  return "u";
}

static const char* GetCharWidthPrefix(char32_t) {
  return "U";
}

static const char* GetCharWidthPrefix(wchar_t) {
  return "L";
}

// Prints a char c as if it's part of a string literal, escaping it when
// necessary; returns how c was formatted.
static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
  return PrintAsStringLiteralTo(ToChar32(c), os);
}

#ifdef __cpp_char8_t
static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
  return PrintAsStringLiteralTo(ToChar32(c), os);
}
#endif

static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) {
  return PrintAsStringLiteralTo(ToChar32(c), os);
}

static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
  return PrintAsStringLiteralTo(ToChar32(c), os);
}

// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t)
// and its code. '\0' is printed as "'\\0'", other unprintable characters are
// also properly escaped using the standard C++ escape sequence.
template <typename Char>
void PrintCharAndCodeTo(Char c, ostream* os) {
  // First, print c as a literal in the most readable form we can find.
  *os << GetCharWidthPrefix(c) << "'";
  const CharFormat format = PrintAsCharLiteralTo(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexadecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
  }
  *os << ")";
}

void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }

// Prints a wchar_t as a symbol if it is printable or as its internal
// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); }

// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well.
void PrintTo(char32_t c, ::std::ostream* os) {
  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
      << static_cast<uint32_t>(c);
}

// Prints the given array of characters to the ostream.  CharType must be either
// char, char8_t, char16_t, char32_t, or wchar_t.
// The array starts at begin, the length is len, it may include '\0' characters
// and may not be NUL-terminated.
template <typename CharType>
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
static CharFormat PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const quote_prefix = GetCharWidthPrefix(*begin);
  *os << quote_prefix << "\"";
  bool is_previous_hex = false;
  CharFormat print_format = kAsIs;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << quote_prefix << "\"";
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
    // Remember if any characters required hex escaping.
    if (is_previous_hex) {
      print_format = kHexEscape;
    }
  }
  *os << "\"";
  return print_format;
}

// Prints a (const) char/wchar_t array of 'len' elements, starting at address
// 'begin'.  CharType must be either char or wchar_t.
template <typename CharType>
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
static void UniversalPrintCharArray(
    const CharType* begin, size_t len, ostream* os) {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

  // If, however, the last element in the array is not '\0', e.g.
  //    const char kFoo[] = { 'f', 'o', 'o' };
  // we must print the entire array.  We also print a message to indicate
  // that the array is not NUL-terminated.
  PrintCharsAsStringTo(begin, len, os);
  *os << " (no terminating NUL)";
}

// Prints a (const) char array of 'len' elements, starting at address 'begin'.
void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
  UniversalPrintCharArray(begin, len, os);
}

#ifdef __cpp_char8_t
// Prints a (const) char8_t array of 'len' elements, starting at address
// 'begin'.
void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) {
  UniversalPrintCharArray(begin, len, os);
}
#endif

// Prints a (const) char16_t array of 'len' elements, starting at address
// 'begin'.
void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) {
  UniversalPrintCharArray(begin, len, os);
}

// Prints a (const) char32_t array of 'len' elements, starting at address
// 'begin'.
void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) {
  UniversalPrintCharArray(begin, len, os);
}

// Prints a (const) wchar_t array of 'len' elements, starting at address
// 'begin'.
void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
  UniversalPrintCharArray(begin, len, os);
}

namespace {

// Prints a null-terminated C-style string to the ostream.
template <typename Char>
void PrintCStringTo(const Char* s, ostream* os) {
  if (s == nullptr) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
  }
}

}  // anonymous namespace

void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }

#ifdef __cpp_char8_t
void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
#endif

void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }

void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }

// MSVC compiler can be configured to define whar_t as a typedef
// of unsigned short. Defining an overload for const wchar_t* in that case
// would cause pointers to unsigned shorts be printed as wide strings,
// possibly accessing more memory than intended and causing invalid
// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
// wchar_t is implemented as a native type.
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
// Prints the given wide C string to the ostream.
void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
#endif  // wchar_t is native

namespace {

bool ContainsUnprintableControlCodes(const char* str, size_t length) {
  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);

  for (size_t i = 0; i < length; i++) {
    unsigned char ch = *s++;
    if (std::iscntrl(ch)) {
        switch (ch) {
        case '\t':
        case '\n':
        case '\r':
          break;
        default:
          return true;
        }
      }
  }
  return false;
}

bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }

bool IsValidUTF8(const char* str, size_t length) {
  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);

  for (size_t i = 0; i < length;) {
    unsigned char lead = s[i++];

    if (lead <= 0x7f) {
      continue;  // single-byte character (ASCII) 0..7F
    }
    if (lead < 0xc2) {
      return false;  // trail byte or non-shortest form
    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
      ++i;  // 2-byte character
    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
               IsUTF8TrailByte(s[i]) &&
               IsUTF8TrailByte(s[i + 1]) &&
               // check for non-shortest form and surrogate
               (lead != 0xe0 || s[i] >= 0xa0) &&
               (lead != 0xed || s[i] < 0xa0)) {
      i += 2;  // 3-byte character
    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
               IsUTF8TrailByte(s[i]) &&
               IsUTF8TrailByte(s[i + 1]) &&
               IsUTF8TrailByte(s[i + 2]) &&
               // check for non-shortest form
               (lead != 0xf0 || s[i] >= 0x90) &&
               (lead != 0xf4 || s[i] < 0x90)) {
      i += 3;  // 4-byte character
    } else {
      return false;
    }
  }
  return true;
}

void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
  if (!ContainsUnprintableControlCodes(str, length) &&
      IsValidUTF8(str, length)) {
    *os << "\n    As Text: \"" << str << "\"";
  }
}

}  // anonymous namespace

void PrintStringTo(const ::std::string& s, ostream* os) {
  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
    if (GTEST_FLAG(print_utf8)) {
      ConditionalPrintAsText(s.data(), s.size(), os);
    }
  }
}

#ifdef __cpp_char8_t
void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}
#endif

void PrintU16StringTo(const ::std::u16string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}

void PrintU32StringTo(const ::std::u32string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}

#if GTEST_HAS_STD_WSTRING
void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}
#endif  // GTEST_HAS_STD_WSTRING

}  // namespace internal

}  // namespace testing
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// The Google C++ Testing and Mocking Framework (Google Test)



namespace testing {

using internal::GetUnitTestImpl;

// Gets the summary of the failure message by omitting the stack trace
// in it.
std::string TestPartResult::ExtractSummary(const char* message) {
  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
  return stack_trace == nullptr ? message : std::string(message, stack_trace);
}

// Prints a TestPartResult object.
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os << internal::FormatFileLocation(result.file_name(),
                                            result.line_number())
            << " "
            << (result.type() == TestPartResult::kSuccess
                    ? "Success"
                    : result.type() == TestPartResult::kSkip
                          ? "Skipped"
                          : result.type() == TestPartResult::kFatalFailure
                                ? "Fatal failure"
                                : "Non-fatal failure")
            << ":\n"
            << result.message() << std::endl;
}

// Appends a TestPartResult to the array.
void TestPartResultArray::Append(const TestPartResult& result) {
  array_.push_back(result);
}

// Returns the TestPartResult at the given index (0-based).
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[static_cast<size_t>(index)];
}

// Returns the number of TestPartResult objects in the array.
int TestPartResultArray::size() const {
  return static_cast<int>(array_.size());
}

namespace internal {

HasNewFatalFailureHelper::HasNewFatalFailureHelper()
    : has_new_fatal_failure_(false),
      original_reporter_(GetUnitTestImpl()->
                         GetTestPartResultReporterForCurrentThread()) {
  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
}

HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
      original_reporter_);
}

void HasNewFatalFailureHelper::ReportTestPartResult(
    const TestPartResult& result) {
  if (result.fatally_failed())
    has_new_fatal_failure_ = true;
  original_reporter_->ReportTestPartResult(result);
}

}  // namespace internal

}  // namespace testing
// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.




namespace testing {
namespace internal {

// Skips to the first non-space char in str. Returns an empty string if str
// contains only whitespace characters.
static const char* SkipSpaces(const char* str) {
  while (IsSpace(*str))
    str++;
  return str;
}

static std::vector<std::string> SplitIntoTestNames(const char* src) {
  std::vector<std::string> name_vec;
  src = SkipSpaces(src);
  for (; src != nullptr; src = SkipComma(src)) {
    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
  }
  return name_vec;
}

// Verifies that registered_tests match the test names in
// registered_tests_; returns registered_tests if successful, or
// aborts the program otherwise.
const char* TypedTestSuitePState::VerifyRegisteredTestNames(
    const char* test_suite_name, const char* file, int line,
    const char* registered_tests) {
  RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));

  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
  registered_ = true;

  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);

  Message errors;

  std::set<std::string> tests;
  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
       name_it != name_vec.end(); ++name_it) {
    const std::string& name = *name_it;
    if (tests.count(name) != 0) {
      errors << "Test " << name << " is listed more than once.\n";
      continue;
    }

    if (registered_tests_.count(name) != 0) {
      tests.insert(name);
    } else {
      errors << "No test named " << name
             << " can be found in this test suite.\n";
    }
  }

  for (RegisteredTestIter it = registered_tests_.begin();
       it != registered_tests_.end();
       ++it) {
    if (tests.count(it->first) == 0) {
      errors << "You forgot to list test " << it->first << ".\n";
    }
  }

  const std::string& errors_str = errors.GetString();
  if (errors_str != "") {
    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
            errors_str.c_str());
    fflush(stderr);
    posix::Abort();
  }

  return registered_tests;
}

}  // namespace internal
}  // namespace testing
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Google C++ Mocking Framework (Google Mock)
//
// This file #includes all Google Mock implementation .cc files.  The
// purpose is to allow a user to build Google Mock by compiling this
// file alone.

// This line ensures that gmock.h can be compiled on its own, even
// when it's fused.
#include "gmock/gmock.h"

// The following lines pull in the real gmock *.cc files.
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements cardinalities.


#include <limits.h>
#include <ostream>  // NOLINT
#include <sstream>
#include <string>

namespace testing {

namespace {

// Implements the Between(m, n) cardinality.
class BetweenCardinalityImpl : public CardinalityInterface {
 public:
  BetweenCardinalityImpl(int min, int max)
      : min_(min >= 0 ? min : 0),
        max_(max >= min_ ? max : min_) {
    std::stringstream ss;
    if (min < 0) {
      ss << "The invocation lower bound must be >= 0, "
         << "but is actually " << min << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (max < 0) {
      ss << "The invocation upper bound must be >= 0, "
         << "but is actually " << max << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (min > max) {
      ss << "The invocation upper bound (" << max
         << ") must be >= the invocation lower bound (" << min
         << ").";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    }
  }

  // Conservative estimate on the lower/upper bound of the number of
  // calls allowed.
  int ConservativeLowerBound() const override { return min_; }
  int ConservativeUpperBound() const override { return max_; }

  bool IsSatisfiedByCallCount(int call_count) const override {
    return min_ <= call_count && call_count <= max_;
  }

  bool IsSaturatedByCallCount(int call_count) const override {
    return call_count >= max_;
  }

  void DescribeTo(::std::ostream* os) const override;

 private:
  const int min_;
  const int max_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
};

// Formats "n times" in a human-friendly way.
inline std::string FormatTimes(int n) {
  if (n == 1) {
    return "once";
  } else if (n == 2) {
    return "twice";
  } else {
    std::stringstream ss;
    ss << n << " times";
    return ss.str();
  }
}

// Describes the Between(m, n) cardinality in human-friendly text.
void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
  if (min_ == 0) {
    if (max_ == 0) {
      *os << "never called";
    } else if (max_ == INT_MAX) {
      *os << "called any number of times";
    } else {
      *os << "called at most " << FormatTimes(max_);
    }
  } else if (min_ == max_) {
    *os << "called " << FormatTimes(min_);
  } else if (max_ == INT_MAX) {
    *os << "called at least " << FormatTimes(min_);
  } else {
    // 0 < min_ < max_ < INT_MAX
    *os << "called between " << min_ << " and " << max_ << " times";
  }
}

}  // Unnamed namespace

// Describes the given call count to an ostream.
void Cardinality::DescribeActualCallCountTo(int actual_call_count,
                                            ::std::ostream* os) {
  if (actual_call_count > 0) {
    *os << "called " << FormatTimes(actual_call_count);
  } else {
    *os << "never called";
  }
}

// Creates a cardinality that allows at least n calls.
GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }

// Creates a cardinality that allows at most n calls.
GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }

// Creates a cardinality that allows any number of calls.
GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }

// Creates a cardinality that allows between min and max calls.
GTEST_API_ Cardinality Between(int min, int max) {
  return Cardinality(new BetweenCardinalityImpl(min, max));
}

// Creates a cardinality that allows exactly n calls.
GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }

}  // namespace testing
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file defines some utilities useful for implementing Google
// Mock.  They are subject to change without notice, so please DO NOT
// USE THEM IN USER CODE.


#include <ctype.h>
#include <ostream>  // NOLINT
#include <string>

namespace testing {
namespace internal {

// Joins a vector of strings as if they are fields of a tuple; returns
// the joined string.
GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
  switch (fields.size()) {
    case 0:
      return "";
    case 1:
      return fields[0];
    default:
      std::string result = "(" + fields[0];
      for (size_t i = 1; i < fields.size(); i++) {
        result += ", ";
        result += fields[i];
      }
      result += ")";
      return result;
  }
}

// Converts an identifier name to a space-separated list of lower-case
// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
// treated as one word.  For example, both "FooBar123" and
// "foo_bar_123" are converted to "foo bar 123".
GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
  std::string result;
  char prev_char = '\0';
  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
    // We don't care about the current locale as the input is
    // guaranteed to be a valid C++ identifier name.
    const bool starts_new_word = IsUpper(*p) ||
        (!IsAlpha(prev_char) && IsLower(*p)) ||
        (!IsDigit(prev_char) && IsDigit(*p));

    if (IsAlNum(*p)) {
      if (starts_new_word && result != "")
        result += ' ';
      result += ToLower(*p);
    }
  }
  return result;
}

// This class reports Google Mock failures as Google Test failures.  A
// user can define another class in a similar fashion if they intend to
// use Google Mock with a testing framework other than Google Test.
class GoogleTestFailureReporter : public FailureReporterInterface {
 public:
  void ReportFailure(FailureType type, const char* file, int line,
                     const std::string& message) override {
    AssertHelper(type == kFatal ?
                 TestPartResult::kFatalFailure :
                 TestPartResult::kNonFatalFailure,
                 file,
                 line,
                 message.c_str()) = Message();
    if (type == kFatal) {
      posix::Abort();
    }
  }
};

// Returns the global failure reporter.  Will create a
// GoogleTestFailureReporter and return it the first time called.
GTEST_API_ FailureReporterInterface* GetFailureReporter() {
  // Points to the global failure reporter used by Google Mock.  gcc
  // guarantees that the following use of failure_reporter is
  // thread-safe.  We may need to add additional synchronization to
  // protect failure_reporter if we port Google Mock to other
  // compilers.
  static FailureReporterInterface* const failure_reporter =
      new GoogleTestFailureReporter();
  return failure_reporter;
}

// Protects global resources (stdout in particular) used by Log().
static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);

// Returns true if and only if a log with the given severity is visible
// according to the --gmock_verbose flag.
GTEST_API_ bool LogIsVisible(LogSeverity severity) {
  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
    // Always show the log if --gmock_verbose=info.
    return true;
  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
    // Always hide it if --gmock_verbose=error.
    return false;
  } else {
    // If --gmock_verbose is neither "info" nor "error", we treat it
    // as "warning" (its default value).
    return severity == kWarning;
  }
}

// Prints the given message to stdout if and only if 'severity' >= the level
// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
// 0, also prints the stack trace excluding the top
// stack_frames_to_skip frames.  In opt mode, any positive
// stack_frames_to_skip is treated as 0, since we don't know which
// function calls will be inlined by the compiler and need to be
// conservative.
GTEST_API_ void Log(LogSeverity severity, const std::string& message,
                    int stack_frames_to_skip) {
  if (!LogIsVisible(severity))
    return;

  // Ensures that logs from different threads don't interleave.
  MutexLock l(&g_log_mutex);

  if (severity == kWarning) {
    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
    std::cout << "\nGMOCK WARNING:";
  }
  // Pre-pends a new-line to message if it doesn't start with one.
  if (message.empty() || message[0] != '\n') {
    std::cout << "\n";
  }
  std::cout << message;
  if (stack_frames_to_skip >= 0) {
#ifdef NDEBUG
    // In opt mode, we have to be conservative and skip no stack frame.
    const int actual_to_skip = 0;
#else
    // In dbg mode, we can do what the caller tell us to do (plus one
    // for skipping this function's stack frame).
    const int actual_to_skip = stack_frames_to_skip + 1;
#endif  // NDEBUG

    // Appends a new-line to message if it doesn't end with one.
    if (!message.empty() && *message.rbegin() != '\n') {
      std::cout << "\n";
    }
    std::cout << "Stack trace:\n"
         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
             ::testing::UnitTest::GetInstance(), actual_to_skip);
  }
  std::cout << ::std::flush;
}

GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }

GTEST_API_ void IllegalDoDefault(const char* file, int line) {
  internal::Assert(
      false, file, line,
      "You are using DoDefault() inside a composite action like "
      "DoAll() or WithArgs().  This is not supported for technical "
      "reasons.  Please instead spell out the default action, or "
      "assign the default action to an Action variable and use "
      "the variable in various places.");
}

}  // namespace internal
}  // namespace testing
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements Matcher<const string&>, Matcher<string>, and
// utilities for defining matchers.


#include <string.h>
#include <iostream>
#include <sstream>
#include <string>

namespace testing {
namespace internal {

// Returns the description for a matcher defined using the MATCHER*()
// macro where the user-supplied description string is "", if
// 'negation' is false; otherwise returns the description of the
// negation of the matcher.  'param_values' contains a list of strings
// that are the print-out of the matcher's parameters.
GTEST_API_ std::string FormatMatcherDescription(bool negation,
                                                const char* matcher_name,
                                                const Strings& param_values) {
  std::string result = ConvertIdentifierNameToWords(matcher_name);
  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
  return negation ? "not (" + result + ")" : result;
}

// FindMaxBipartiteMatching and its helper class.
//
// Uses the well-known Ford-Fulkerson max flow method to find a maximum
// bipartite matching. Flow is considered to be from left to right.
// There is an implicit source node that is connected to all of the left
// nodes, and an implicit sink node that is connected to all of the
// right nodes. All edges have unit capacity.
//
// Neither the flow graph nor the residual flow graph are represented
// explicitly. Instead, they are implied by the information in 'graph' and
// a vector<int> called 'left_' whose elements are initialized to the
// value kUnused. This represents the initial state of the algorithm,
// where the flow graph is empty, and the residual flow graph has the
// following edges:
//   - An edge from source to each left_ node
//   - An edge from each right_ node to sink
//   - An edge from each left_ node to each right_ node, if the
//     corresponding edge exists in 'graph'.
//
// When the TryAugment() method adds a flow, it sets left_[l] = r for some
// nodes l and r. This induces the following changes:
//   - The edges (source, l), (l, r), and (r, sink) are added to the
//     flow graph.
//   - The same three edges are removed from the residual flow graph.
//   - The reverse edges (l, source), (r, l), and (sink, r) are added
//     to the residual flow graph, which is a directional graph
//     representing unused flow capacity.
//
// When the method augments a flow (moving left_[l] from some r1 to some
// other r2), this can be thought of as "undoing" the above steps with
// respect to r1 and "redoing" them with respect to r2.
//
// It bears repeating that the flow graph and residual flow graph are
// never represented explicitly, but can be derived by looking at the
// information in 'graph' and in left_.
//
// As an optimization, there is a second vector<int> called right_ which
// does not provide any new information. Instead, it enables more
// efficient queries about edges entering or leaving the right-side nodes
// of the flow or residual flow graphs. The following invariants are
// maintained:
//
// left[l] == kUnused or right[left[l]] == l
// right[r] == kUnused or left[right[r]] == r
//
// . [ source ]                                        .
// .   |||                                             .
// .   |||                                             .
// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
// .   ||                   |                    |     .
// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
// .   |                                        ||     .
// .   \----> left[2]=2  ------> right[2]=2  --\||     .
// .                                           |||     .
// .         elements           matchers       vvv     .
// .                                         [ sink ]  .
//
// See Also:
//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
//   [2] "Ford-Fulkerson algorithm", Wikipedia,
//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
class MaxBipartiteMatchState {
 public:
  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
      : graph_(&graph),
        left_(graph_->LhsSize(), kUnused),
        right_(graph_->RhsSize(), kUnused) {}

  // Returns the edges of a maximal match, each in the form {left, right}.
  ElementMatcherPairs Compute() {
    // 'seen' is used for path finding { 0: unseen, 1: seen }.
    ::std::vector<char> seen;
    // Searches the residual flow graph for a path from each left node to
    // the sink in the residual flow graph, and if one is found, add flow
    // to the graph. It's okay to search through the left nodes once. The
    // edge from the implicit source node to each previously-visited left
    // node will have flow if that left node has any path to the sink
    // whatsoever. Subsequent augmentations can only add flow to the
    // network, and cannot take away that previous flow unit from the source.
    // Since the source-to-left edge can only carry one flow unit (or,
    // each element can be matched to only one matcher), there is no need
    // to visit the left nodes more than once looking for augmented paths.
    // The flow is known to be possible or impossible by looking at the
    // node once.
    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
      // Reset the path-marking vector and try to find a path from
      // source to sink starting at the left_[ilhs] node.
      GTEST_CHECK_(left_[ilhs] == kUnused)
          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
      seen.assign(graph_->RhsSize(), 0);
      TryAugment(ilhs, &seen);
    }
    ElementMatcherPairs result;
    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
      size_t irhs = left_[ilhs];
      if (irhs == kUnused) continue;
      result.push_back(ElementMatcherPair(ilhs, irhs));
    }
    return result;
  }

 private:
  static const size_t kUnused = static_cast<size_t>(-1);

  // Perform a depth-first search from left node ilhs to the sink.  If a
  // path is found, flow is added to the network by linking the left and
  // right vector elements corresponding each segment of the path.
  // Returns true if a path to sink was found, which means that a unit of
  // flow was added to the network. The 'seen' vector elements correspond
  // to right nodes and are marked to eliminate cycles from the search.
  //
  // Left nodes will only be explored at most once because they
  // are accessible from at most one right node in the residual flow
  // graph.
  //
  // Note that left_[ilhs] is the only element of left_ that TryAugment will
  // potentially transition from kUnused to another value. Any other
  // left_ element holding kUnused before TryAugment will be holding it
  // when TryAugment returns.
  //
  bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
      if ((*seen)[irhs]) continue;
      if (!graph_->HasEdge(ilhs, irhs)) continue;
      // There's an available edge from ilhs to irhs.
      (*seen)[irhs] = 1;
      // Next a search is performed to determine whether
      // this edge is a dead end or leads to the sink.
      //
      // right_[irhs] == kUnused means that there is residual flow from
      // right node irhs to the sink, so we can use that to finish this
      // flow path and return success.
      //
      // Otherwise there is residual flow to some ilhs. We push flow
      // along that path and call ourselves recursively to see if this
      // ultimately leads to sink.
      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
        // Add flow from left_[ilhs] to right_[irhs].
        left_[ilhs] = irhs;
        right_[irhs] = ilhs;
        return true;
      }
    }
    return false;
  }

  const MatchMatrix* graph_;  // not owned
  // Each element of the left_ vector represents a left hand side node
  // (i.e. an element) and each element of right_ is a right hand side
  // node (i.e. a matcher). The values in the left_ vector indicate
  // outflow from that node to a node on the right_ side. The values
  // in the right_ indicate inflow, and specify which left_ node is
  // feeding that right_ node, if any. For example, left_[3] == 1 means
  // there's a flow from element #3 to matcher #1. Such a flow would also
  // be redundantly represented in the right_ vector as right_[1] == 3.
  // Elements of left_ and right_ are either kUnused or mutually
  // referent. Mutually referent means that left_[right_[i]] = i and
  // right_[left_[i]] = i.
  ::std::vector<size_t> left_;
  ::std::vector<size_t> right_;
};

const size_t MaxBipartiteMatchState::kUnused;

GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) {
  return MaxBipartiteMatchState(g).Compute();
}

static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
                                     ::std::ostream* stream) {
  typedef ElementMatcherPairs::const_iterator Iter;
  ::std::ostream& os = *stream;
  os << "{";
  const char* sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
    os << sep << "\n  ("
       << "element #" << it->first << ", "
       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
}

bool MatchMatrix::NextGraph() {
  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
      char& b = matched_[SpaceIndex(ilhs, irhs)];
      if (!b) {
        b = 1;
        return true;
      }
      b = 0;
    }
  }
  return false;
}

void MatchMatrix::Randomize() {
  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
      char& b = matched_[SpaceIndex(ilhs, irhs)];
      b = static_cast<char>(rand() & 1);  // NOLINT
    }
  }
}

std::string MatchMatrix::DebugString() const {
  ::std::stringstream ss;
  const char* sep = "";
  for (size_t i = 0; i < LhsSize(); ++i) {
    ss << sep;
    for (size_t j = 0; j < RhsSize(); ++j) {
      ss << HasEdge(i, j);
    }
    sep = ";";
  }
  return ss.str();
}

void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
    ::std::ostream* os) const {
  switch (match_flags()) {
    case UnorderedMatcherRequire::ExactMatch:
      if (matcher_describers_.empty()) {
        *os << "is empty";
        return;
      }
      if (matcher_describers_.size() == 1) {
        *os << "has " << Elements(1) << " and that element ";
        matcher_describers_[0]->DescribeTo(os);
        return;
      }
      *os << "has " << Elements(matcher_describers_.size())
          << " and there exists some permutation of elements such that:\n";
      break;
    case UnorderedMatcherRequire::Superset:
      *os << "a surjection from elements to requirements exists such that:\n";
      break;
    case UnorderedMatcherRequire::Subset:
      *os << "an injection from elements to requirements exists such that:\n";
      break;
  }

  const char* sep = "";
  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
    *os << sep;
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      *os << " - element #" << i << " ";
    } else {
      *os << " - an element ";
    }
    matcher_describers_[i]->DescribeTo(os);
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      sep = ", and\n";
    } else {
      sep = "\n";
    }
  }
}

void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
    ::std::ostream* os) const {
  switch (match_flags()) {
    case UnorderedMatcherRequire::ExactMatch:
      if (matcher_describers_.empty()) {
        *os << "isn't empty";
        return;
      }
      if (matcher_describers_.size() == 1) {
        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
            << " that ";
        matcher_describers_[0]->DescribeNegationTo(os);
        return;
      }
      *os << "doesn't have " << Elements(matcher_describers_.size())
          << ", or there exists no permutation of elements such that:\n";
      break;
    case UnorderedMatcherRequire::Superset:
      *os << "no surjection from elements to requirements exists such that:\n";
      break;
    case UnorderedMatcherRequire::Subset:
      *os << "no injection from elements to requirements exists such that:\n";
      break;
  }
  const char* sep = "";
  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
    *os << sep;
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      *os << " - element #" << i << " ";
    } else {
      *os << " - an element ";
    }
    matcher_describers_[i]->DescribeTo(os);
    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
      sep = ", and\n";
    } else {
      sep = "\n";
    }
  }
}

// Checks that all matchers match at least one element, and that all
// elements match at least one matcher. This enables faster matching
// and better error reporting.
// Returns false, writing an explanation to 'listener', if and only
// if the success criteria are not met.
bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
    const ::std::vector<std::string>& element_printouts,
    const MatchMatrix& matrix, MatchResultListener* listener) const {
  bool result = true;
  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);

  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
      char matched = matrix.HasEdge(ilhs, irhs);
      element_matched[ilhs] |= matched;
      matcher_matched[irhs] |= matched;
    }
  }

  if (match_flags() & UnorderedMatcherRequire::Superset) {
    const char* sep =
        "where the following matchers don't match any elements:\n";
    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
      if (matcher_matched[mi]) continue;
      result = false;
      if (listener->IsInterested()) {
        *listener << sep << "matcher #" << mi << ": ";
        matcher_describers_[mi]->DescribeTo(listener->stream());
        sep = ",\n";
      }
    }
  }

  if (match_flags() & UnorderedMatcherRequire::Subset) {
    const char* sep =
        "where the following elements don't match any matchers:\n";
    const char* outer_sep = "";
    if (!result) {
      outer_sep = "\nand ";
    }
    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
      if (element_matched[ei]) continue;
      result = false;
      if (listener->IsInterested()) {
        *listener << outer_sep << sep << "element #" << ei << ": "
                  << element_printouts[ei];
        sep = ",\n";
        outer_sep = "";
      }
    }
  }
  return result;
}

bool UnorderedElementsAreMatcherImplBase::FindPairing(
    const MatchMatrix& matrix, MatchResultListener* listener) const {
  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);

  size_t max_flow = matches.size();
  if ((match_flags() & UnorderedMatcherRequire::Superset) &&
      max_flow < matrix.RhsSize()) {
    if (listener->IsInterested()) {
      *listener << "where no permutation of the elements can satisfy all "
                   "matchers, and the closest match is "
                << max_flow << " of " << matrix.RhsSize()
                << " matchers with the pairings:\n";
      LogElementMatcherPairVec(matches, listener->stream());
    }
    return false;
  }
  if ((match_flags() & UnorderedMatcherRequire::Subset) &&
      max_flow < matrix.LhsSize()) {
    if (listener->IsInterested()) {
      *listener
          << "where not all elements can be matched, and the closest match is "
          << max_flow << " of " << matrix.RhsSize()
          << " matchers with the pairings:\n";
      LogElementMatcherPairVec(matches, listener->stream());
    }
    return false;
  }

  if (matches.size() > 1) {
    if (listener->IsInterested()) {
      const char* sep = "where:\n";
      for (size_t mi = 0; mi < matches.size(); ++mi) {
        *listener << sep << " - element #" << matches[mi].first
                  << " is matched by matcher #" << matches[mi].second;
        sep = ",\n";
      }
    }
  }
  return true;
}

}  // namespace internal
}  // namespace testing
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Mock - a framework for writing C++ mock classes.
//
// This file implements the spec builder syntax (ON_CALL and
// EXPECT_CALL).


#include <stdlib.h>

#include <iostream>  // NOLINT
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>


#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
# include <unistd.h>  // NOLINT
#endif

// Silence C4800 (C4800: 'int *const ': forcing value
// to bool 'true' or 'false') for MSVC 15
#ifdef _MSC_VER
#if _MSC_VER == 1900
#  pragma warning(push)
#  pragma warning(disable:4800)
#endif
#endif

namespace testing {
namespace internal {

// Protects the mock object registry (in class Mock), all function
// mockers, and all expectations.
GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);

// Logs a message including file and line number information.
GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
                                const char* file, int line,
                                const std::string& message) {
  ::std::ostringstream s;
  s << internal::FormatFileLocation(file, line) << " " << message
    << ::std::endl;
  Log(severity, s.str(), 0);
}

// Constructs an ExpectationBase object.
ExpectationBase::ExpectationBase(const char* a_file, int a_line,
                                 const std::string& a_source_text)
    : file_(a_file),
      line_(a_line),
      source_text_(a_source_text),
      cardinality_specified_(false),
      cardinality_(Exactly(1)),
      call_count_(0),
      retired_(false),
      extra_matcher_specified_(false),
      repeated_action_specified_(false),
      retires_on_saturation_(false),
      last_clause_(kNone),
      action_count_checked_(false) {}

// Destructs an ExpectationBase object.
ExpectationBase::~ExpectationBase() {}

// Explicitly specifies the cardinality of this expectation.  Used by
// the subclasses to implement the .Times() clause.
void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
  cardinality_specified_ = true;
  cardinality_ = a_cardinality;
}

// Retires all pre-requisites of this expectation.
void ExpectationBase::RetireAllPreRequisites()
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
  if (is_retired()) {
    // We can take this short-cut as we never retire an expectation
    // until we have retired all its pre-requisites.
    return;
  }

  ::std::vector<ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      ExpectationBase* next = it->expectation_base().get();
      if (!next->is_retired()) {
        next->Retire();
        expectations.push_back(next);
      }
    }
  }
}

// Returns true if and only if all pre-requisites of this expectation
// have been satisfied.
bool ExpectationBase::AllPrerequisitesAreSatisfied() const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
  g_gmock_mutex.AssertHeld();
  ::std::vector<const ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    const ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      const ExpectationBase* next = it->expectation_base().get();
      if (!next->IsSatisfied()) return false;
      expectations.push_back(next);
    }
  }
  return true;
}

// Adds unsatisfied pre-requisites of this expectation to 'result'.
void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
  g_gmock_mutex.AssertHeld();
  ::std::vector<const ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    const ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      const ExpectationBase* next = it->expectation_base().get();

      if (next->IsSatisfied()) {
        // If *it is satisfied and has a call count of 0, some of its
        // pre-requisites may not be satisfied yet.
        if (next->call_count_ == 0) {
          expectations.push_back(next);
        }
      } else {
        // Now that we know next is unsatisfied, we are not so interested
        // in whether its pre-requisites are satisfied.  Therefore we
        // don't iterate into it here.
        *result += *it;
      }
    }
  }
}

// Describes how many times a function call matching this
// expectation has occurred.
void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
  g_gmock_mutex.AssertHeld();

  // Describes how many times the function is expected to be called.
  *os << "         Expected: to be ";
  cardinality().DescribeTo(os);
  *os << "\n           Actual: ";
  Cardinality::DescribeActualCallCountTo(call_count(), os);

  // Describes the state of the expectation (e.g. is it satisfied?
  // is it active?).
  *os << " - " << (IsOverSaturated() ? "over-saturated" :
                   IsSaturated() ? "saturated" :
                   IsSatisfied() ? "satisfied" : "unsatisfied")
      << " and "
      << (is_retired() ? "retired" : "active");
}

// Checks the action count (i.e. the number of WillOnce() and
// WillRepeatedly() clauses) against the cardinality if this hasn't
// been done before.  Prints a warning if there are too many or too
// few actions.
void ExpectationBase::CheckActionCountIfNotDone() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
  bool should_check = false;
  {
    MutexLock l(&mutex_);
    if (!action_count_checked_) {
      action_count_checked_ = true;
      should_check = true;
    }
  }

  if (should_check) {
    if (!cardinality_specified_) {
      // The cardinality was inferred - no need to check the action
      // count against it.
      return;
    }

    // The cardinality was explicitly specified.
    const int action_count = static_cast<int>(untyped_actions_.size());
    const int upper_bound = cardinality().ConservativeUpperBound();
    const int lower_bound = cardinality().ConservativeLowerBound();
    bool too_many;  // True if there are too many actions, or false
    // if there are too few.
    if (action_count > upper_bound ||
        (action_count == upper_bound && repeated_action_specified_)) {
      too_many = true;
    } else if (0 < action_count && action_count < lower_bound &&
               !repeated_action_specified_) {
      too_many = false;
    } else {
      return;
    }

    ::std::stringstream ss;
    DescribeLocationTo(&ss);
    ss << "Too " << (too_many ? "many" : "few")
       << " actions specified in " << source_text() << "...\n"
       << "Expected to be ";
    cardinality().DescribeTo(&ss);
    ss << ", but has " << (too_many ? "" : "only ")
       << action_count << " WillOnce()"
       << (action_count == 1 ? "" : "s");
    if (repeated_action_specified_) {
      ss << " and a WillRepeatedly()";
    }
    ss << ".";
    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
  }
}

// Implements the .Times() clause.
void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
  if (last_clause_ == kTimes) {
    ExpectSpecProperty(false,
                       ".Times() cannot appear "
                       "more than once in an EXPECT_CALL().");
  } else {
    ExpectSpecProperty(last_clause_ < kTimes,
                       ".Times() cannot appear after "
                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
                       "or .RetiresOnSaturation().");
  }
  last_clause_ = kTimes;

  SpecifyCardinality(a_cardinality);
}

// Points to the implicit sequence introduced by a living InSequence
// object (if any) in the current thread or NULL.
GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;

// Reports an uninteresting call (whose description is in msg) in the
// manner specified by 'reaction'.
void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
  // Include a stack trace only if --gmock_verbose=info is specified.
  const int stack_frames_to_skip =
      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
  switch (reaction) {
    case kAllow:
      Log(kInfo, msg, stack_frames_to_skip);
      break;
    case kWarn:
      Log(kWarning,
          msg +
              "\nNOTE: You can safely ignore the above warning unless this "
              "call should not happen.  Do not suppress it by blindly adding "
              "an EXPECT_CALL() if you don't mean to enforce the call.  "
              "See "
              "https://github.com/google/googletest/blob/master/docs/"
              "gmock_cook_book.md#"
              "knowing-when-to-expect for details.\n",
          stack_frames_to_skip);
      break;
    default:  // FAIL
      Expect(false, nullptr, -1, msg);
  }
}

UntypedFunctionMockerBase::UntypedFunctionMockerBase()
    : mock_obj_(nullptr), name_("") {}

UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}

// Sets the mock object this mock method belongs to, and registers
// this information in the global mock registry.  Will be called
// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
// method.
void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  {
    MutexLock l(&g_gmock_mutex);
    mock_obj_ = mock_obj;
  }
  Mock::Register(mock_obj, this);
}

// Sets the mock object this mock method belongs to, and sets the name
// of the mock function.  Will be called upon each invocation of this
// mock function.
void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
                                                const char* name)
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  // We protect name_ under g_gmock_mutex in case this mock function
  // is called from two threads concurrently.
  MutexLock l(&g_gmock_mutex);
  mock_obj_ = mock_obj;
  name_ = name;
}

// Returns the name of the function being mocked.  Must be called
// after RegisterOwner() or SetOwnerAndName() has been called.
const void* UntypedFunctionMockerBase::MockObject() const
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  const void* mock_obj;
  {
    // We protect mock_obj_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
    MutexLock l(&g_gmock_mutex);
    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
           "MockObject() must not be called before RegisterOwner() or "
           "SetOwnerAndName() has been called.");
    mock_obj = mock_obj_;
  }
  return mock_obj;
}

// Returns the name of this mock method.  Must be called after
// SetOwnerAndName() has been called.
const char* UntypedFunctionMockerBase::Name() const
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  const char* name;
  {
    // We protect name_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
    MutexLock l(&g_gmock_mutex);
    Assert(name_ != nullptr, __FILE__, __LINE__,
           "Name() must not be called before SetOwnerAndName() has "
           "been called.");
    name = name_;
  }
  return name;
}

// Calculates the result of invoking this mock function with the given
// arguments, prints it, and returns it.  The caller is responsible
// for deleting the result.
UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  // See the definition of untyped_expectations_ for why access to it
  // is unprotected here.
  if (untyped_expectations_.size() == 0) {
    // No expectation is set on this mock method - we have an
    // uninteresting call.

    // We must get Google Mock's reaction on uninteresting calls
    // made on this mock object BEFORE performing the action,
    // because the action may DELETE the mock object and make the
    // following expression meaningless.
    const CallReaction reaction =
        Mock::GetReactionOnUninterestingCalls(MockObject());

    // True if and only if we need to print this call's arguments and return
    // value.  This definition must be kept in sync with
    // the behavior of ReportUninterestingCall().
    const bool need_to_report_uninteresting_call =
        // If the user allows this uninteresting call, we print it
        // only when they want informational messages.
        reaction == kAllow ? LogIsVisible(kInfo) :
                           // If the user wants this to be a warning, we print
                           // it only when they want to see warnings.
            reaction == kWarn
                ? LogIsVisible(kWarning)
                :
                // Otherwise, the user wants this to be an error, and we
                // should always print detailed information in the error.
                true;

    if (!need_to_report_uninteresting_call) {
      // Perform the action without printing the call information.
      return this->UntypedPerformDefaultAction(
          untyped_args, "Function call: " + std::string(Name()));
    }

    // Warns about the uninteresting call.
    ::std::stringstream ss;
    this->UntypedDescribeUninterestingCall(untyped_args, &ss);

    // Calculates the function result.
    UntypedActionResultHolderBase* const result =
        this->UntypedPerformDefaultAction(untyped_args, ss.str());

    // Prints the function result.
    if (result != nullptr) result->PrintAsActionResult(&ss);

    ReportUninterestingCall(reaction, ss.str());
    return result;
  }

  bool is_excessive = false;
  ::std::stringstream ss;
  ::std::stringstream why;
  ::std::stringstream loc;
  const void* untyped_action = nullptr;

  // The UntypedFindMatchingExpectation() function acquires and
  // releases g_gmock_mutex.

  const ExpectationBase* const untyped_expectation =
      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
                                           &is_excessive, &ss, &why);
  const bool found = untyped_expectation != nullptr;

  // True if and only if we need to print the call's arguments
  // and return value.
  // This definition must be kept in sync with the uses of Expect()
  // and Log() in this function.
  const bool need_to_report_call =
      !found || is_excessive || LogIsVisible(kInfo);
  if (!need_to_report_call) {
    // Perform the action without printing the call information.
    return untyped_action == nullptr
               ? this->UntypedPerformDefaultAction(untyped_args, "")
               : this->UntypedPerformAction(untyped_action, untyped_args);
  }

  ss << "    Function call: " << Name();
  this->UntypedPrintArgs(untyped_args, &ss);

  // In case the action deletes a piece of the expectation, we
  // generate the message beforehand.
  if (found && !is_excessive) {
    untyped_expectation->DescribeLocationTo(&loc);
  }

  UntypedActionResultHolderBase* result = nullptr;

  auto perform_action = [&] {
    return untyped_action == nullptr
               ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
               : this->UntypedPerformAction(untyped_action, untyped_args);
  };
  auto handle_failures = [&] {
    ss << "\n" << why.str();

    if (!found) {
      // No expectation matches this call - reports a failure.
      Expect(false, nullptr, -1, ss.str());
    } else if (is_excessive) {
      // We had an upper-bound violation and the failure message is in ss.
      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
             ss.str());
    } else {
      // We had an expected call and the matching expectation is
      // described in ss.
      Log(kInfo, loc.str() + ss.str(), 2);
    }
  };
#if GTEST_HAS_EXCEPTIONS
  try {
    result = perform_action();
  } catch (...) {
    handle_failures();
    throw;
  }
#else
  result = perform_action();
#endif

  if (result != nullptr) result->PrintAsActionResult(&ss);
  handle_failures();
  return result;
}

// Returns an Expectation object that references and co-owns exp,
// which must be an expectation on this mock function.
Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
  // See the definition of untyped_expectations_ for why access to it
  // is unprotected here.
  for (UntypedExpectations::const_iterator it =
           untyped_expectations_.begin();
       it != untyped_expectations_.end(); ++it) {
    if (it->get() == exp) {
      return Expectation(*it);
    }
  }

  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
  return Expectation();
  // The above statement is just to make the code compile, and will
  // never be executed.
}

// Verifies that all expectations on this mock function have been
// satisfied.  Reports one or more Google Test non-fatal failures
// and returns false if not.
bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
  g_gmock_mutex.AssertHeld();
  bool expectations_met = true;
  for (UntypedExpectations::const_iterator it =
           untyped_expectations_.begin();
       it != untyped_expectations_.end(); ++it) {
    ExpectationBase* const untyped_expectation = it->get();
    if (untyped_expectation->IsOverSaturated()) {
      // There was an upper-bound violation.  Since the error was
      // already reported when it occurred, there is no need to do
      // anything here.
      expectations_met = false;
    } else if (!untyped_expectation->IsSatisfied()) {
      expectations_met = false;
      ::std::stringstream ss;
      ss  << "Actual function call count doesn't match "
          << untyped_expectation->source_text() << "...\n";
      // No need to show the source file location of the expectation
      // in the description, as the Expect() call that follows already
      // takes care of it.
      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
      untyped_expectation->DescribeCallCountTo(&ss);
      Expect(false, untyped_expectation->file(),
             untyped_expectation->line(), ss.str());
    }
  }

  // Deleting our expectations may trigger other mock objects to be deleted, for
  // example if an action contains a reference counted smart pointer to that
  // mock object, and that is the last reference. So if we delete our
  // expectations within the context of the global mutex we may deadlock when
  // this method is called again. Instead, make a copy of the set of
  // expectations to delete, clear our set within the mutex, and then clear the
  // copied set outside of it.
  UntypedExpectations expectations_to_delete;
  untyped_expectations_.swap(expectations_to_delete);

  g_gmock_mutex.Unlock();
  expectations_to_delete.clear();
  g_gmock_mutex.Lock();

  return expectations_met;
}

CallReaction intToCallReaction(int mock_behavior) {
  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
    return static_cast<internal::CallReaction>(mock_behavior);
  }
  return kWarn;
}

}  // namespace internal

// Class Mock.

namespace {

typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;

// The current state of a mock object.  Such information is needed for
// detecting leaked mock objects and explicitly verifying a mock's
// expectations.
struct MockObjectState {
  MockObjectState()
      : first_used_file(nullptr), first_used_line(-1), leakable(false) {}

  // Where in the source file an ON_CALL or EXPECT_CALL is first
  // invoked on this mock object.
  const char* first_used_file;
  int first_used_line;
  ::std::string first_used_test_suite;
  ::std::string first_used_test;
  bool leakable;  // true if and only if it's OK to leak the object.
  FunctionMockers function_mockers;  // All registered methods of the object.
};

// A global registry holding the state of all mock objects that are
// alive.  A mock object is added to this registry the first time
// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
// is removed from the registry in the mock object's destructor.
class MockObjectRegistry {
 public:
  // Maps a mock object (identified by its address) to its state.
  typedef std::map<const void*, MockObjectState> StateMap;

  // This destructor will be called when a program exits, after all
  // tests in it have been run.  By then, there should be no mock
  // object alive.  Therefore we report any living object as test
  // failure, unless the user explicitly asked us to ignore it.
  ~MockObjectRegistry() {
    if (!GMOCK_FLAG(catch_leaked_mocks))
      return;

    int leaked_count = 0;
    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
         ++it) {
      if (it->second.leakable)  // The user said it's fine to leak this object.
        continue;

      // FIXME: Print the type of the leaked object.
      // This can help the user identify the leaked object.
      std::cout << "\n";
      const MockObjectState& state = it->second;
      std::cout << internal::FormatFileLocation(state.first_used_file,
                                                state.first_used_line);
      std::cout << " ERROR: this mock object";
      if (state.first_used_test != "") {
        std::cout << " (used in test " << state.first_used_test_suite << "."
                  << state.first_used_test << ")";
      }
      std::cout << " should be deleted but never is. Its address is @"
           << it->first << ".";
      leaked_count++;
    }
    if (leaked_count > 0) {
      std::cout << "\nERROR: " << leaked_count << " leaked mock "
                << (leaked_count == 1 ? "object" : "objects")
                << " found at program exit. Expectations on a mock object are "
                   "verified when the object is destructed. Leaking a mock "
                   "means that its expectations aren't verified, which is "
                   "usually a test bug. If you really intend to leak a mock, "
                   "you can suppress this error using "
                   "testing::Mock::AllowLeak(mock_object), or you may use a "
                   "fake or stub instead of a mock.\n";
      std::cout.flush();
      ::std::cerr.flush();
      // RUN_ALL_TESTS() has already returned when this destructor is
      // called.  Therefore we cannot use the normal Google Test
      // failure reporting mechanism.
      _exit(1);  // We cannot call exit() as it is not reentrant and
                 // may already have been called.
    }
  }

  StateMap& states() { return states_; }

 private:
  StateMap states_;
};

// Protected by g_gmock_mutex.
MockObjectRegistry g_mock_object_registry;

// Maps a mock object to the reaction Google Mock should have when an
// uninteresting method is called.  Protected by g_gmock_mutex.
std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;

// Sets the reaction Google Mock should have when an uninteresting
// method of the given mock object is called.
void SetReactionOnUninterestingCalls(const void* mock_obj,
                                     internal::CallReaction reaction)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  g_uninteresting_call_reaction[mock_obj] = reaction;
}

}  // namespace

// Tells Google Mock to allow uninteresting calls on the given mock
// object.
void Mock::AllowUninterestingCalls(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
}

// Tells Google Mock to warn the user about uninteresting calls on the
// given mock object.
void Mock::WarnUninterestingCalls(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
}

// Tells Google Mock to fail uninteresting calls on the given mock
// object.
void Mock::FailUninterestingCalls(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
}

// Tells Google Mock the given mock object is being destroyed and its
// entry in the call-reaction table should be removed.
void Mock::UnregisterCallReaction(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  g_uninteresting_call_reaction.erase(mock_obj);
}

// Returns the reaction Google Mock will have on uninteresting calls
// made on the given mock object.
internal::CallReaction Mock::GetReactionOnUninterestingCalls(
    const void* mock_obj)
        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
      g_uninteresting_call_reaction[mock_obj];
}

// Tells Google Mock to ignore mock_obj when checking for leaked mock
// objects.
void Mock::AllowLeak(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  g_mock_object_registry.states()[mock_obj].leakable = true;
}

// Verifies and clears all expectations on the given mock object.  If
// the expectations aren't satisfied, generates one or more Google
// Test non-fatal failures and returns false.
bool Mock::VerifyAndClearExpectations(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  return VerifyAndClearExpectationsLocked(mock_obj);
}

// Verifies all expectations on the given mock object and clears its
// default actions and expectations.  Returns true if and only if the
// verification was successful.
bool Mock::VerifyAndClear(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  ClearDefaultActionsLocked(mock_obj);
  return VerifyAndClearExpectationsLocked(mock_obj);
}

// Verifies and clears all expectations on the given mock object.  If
// the expectations aren't satisfied, generates one or more Google
// Test non-fatal failures and returns false.
bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
  internal::g_gmock_mutex.AssertHeld();
  if (g_mock_object_registry.states().count(mock_obj) == 0) {
    // No EXPECT_CALL() was set on the given mock object.
    return true;
  }

  // Verifies and clears the expectations on each mock method in the
  // given mock object.
  bool expectations_met = true;
  FunctionMockers& mockers =
      g_mock_object_registry.states()[mock_obj].function_mockers;
  for (FunctionMockers::const_iterator it = mockers.begin();
       it != mockers.end(); ++it) {
    if (!(*it)->VerifyAndClearExpectationsLocked()) {
      expectations_met = false;
    }
  }

  // We don't clear the content of mockers, as they may still be
  // needed by ClearDefaultActionsLocked().
  return expectations_met;
}

bool Mock::IsNaggy(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn;
}
bool Mock::IsNice(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow;
}
bool Mock::IsStrict(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail;
}

// Registers a mock object and a mock method it owns.
void Mock::Register(const void* mock_obj,
                    internal::UntypedFunctionMockerBase* mocker)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
}

// Tells Google Mock where in the source code mock_obj is used in an
// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
// information helps the user identify which object it is.
void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
                                           const char* file, int line)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
  internal::MutexLock l(&internal::g_gmock_mutex);
  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
  if (state.first_used_file == nullptr) {
    state.first_used_file = file;
    state.first_used_line = line;
    const TestInfo* const test_info =
        UnitTest::GetInstance()->current_test_info();
    if (test_info != nullptr) {
      state.first_used_test_suite = test_info->test_suite_name();
      state.first_used_test = test_info->name();
    }
  }
}

// Unregisters a mock method; removes the owning mock object from the
// registry when the last mock method associated with it has been
// unregistered.  This is called only in the destructor of
// FunctionMockerBase.
void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
  internal::g_gmock_mutex.AssertHeld();
  for (MockObjectRegistry::StateMap::iterator it =
           g_mock_object_registry.states().begin();
       it != g_mock_object_registry.states().end(); ++it) {
    FunctionMockers& mockers = it->second.function_mockers;
    if (mockers.erase(mocker) > 0) {
      // mocker was in mockers and has been just removed.
      if (mockers.empty()) {
        g_mock_object_registry.states().erase(it);
      }
      return;
    }
  }
}

// Clears all ON_CALL()s set on the given mock object.
void Mock::ClearDefaultActionsLocked(void* mock_obj)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
  internal::g_gmock_mutex.AssertHeld();

  if (g_mock_object_registry.states().count(mock_obj) == 0) {
    // No ON_CALL() was set on the given mock object.
    return;
  }

  // Clears the default actions for each mock method in the given mock
  // object.
  FunctionMockers& mockers =
      g_mock_object_registry.states()[mock_obj].function_mockers;
  for (FunctionMockers::const_iterator it = mockers.begin();
       it != mockers.end(); ++it) {
    (*it)->ClearDefaultActionsLocked();
  }

  // We don't clear the content of mockers, as they may still be
  // needed by VerifyAndClearExpectationsLocked().
}

Expectation::Expectation() {}

Expectation::Expectation(
    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
    : expectation_base_(an_expectation_base) {}

Expectation::~Expectation() {}

// Adds an expectation to a sequence.
void Sequence::AddExpectation(const Expectation& expectation) const {
  if (*last_expectation_ != expectation) {
    if (last_expectation_->expectation_base() != nullptr) {
      expectation.expectation_base()->immediate_prerequisites_
          += *last_expectation_;
    }
    *last_expectation_ = expectation;
  }
}

// Creates the implicit sequence if there isn't one.
InSequence::InSequence() {
  if (internal::g_gmock_implicit_sequence.get() == nullptr) {
    internal::g_gmock_implicit_sequence.set(new Sequence);
    sequence_created_ = true;
  } else {
    sequence_created_ = false;
  }
}

// Deletes the implicit sequence if it was created by the constructor
// of this object.
InSequence::~InSequence() {
  if (sequence_created_) {
    delete internal::g_gmock_implicit_sequence.get();
    internal::g_gmock_implicit_sequence.set(nullptr);
  }
}

}  // namespace testing

#ifdef _MSC_VER
#if _MSC_VER == 1900
#  pragma warning(pop)
#endif
#endif
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.



namespace testing {

GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
                   "true if and only if Google Mock should report leaked "
                   "mock objects as failures.");

GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
                     "Controls how verbose Google Mock's output is."
                     "  Valid values:\n"
                     "  info    - prints all messages.\n"
                     "  warning - prints warnings and errors.\n"
                     "  error   - prints errors only.");

GMOCK_DEFINE_int32_(default_mock_behavior, 1,
                    "Controls the default behavior of mocks."
                    "  Valid values:\n"
                    "  0 - by default, mocks act as NiceMocks.\n"
                    "  1 - by default, mocks act as NaggyMocks.\n"
                    "  2 - by default, mocks act as StrictMocks.");

namespace internal {

// Parses a string as a command line flag.  The string should have the
// format "--gmock_flag=value".  When def_optional is true, the
// "=value" part can be omitted.
//
// Returns the value of the flag, or NULL if the parsing failed.
static const char* ParseGoogleMockFlagValue(const char* str,
                                            const char* flag,
                                            bool def_optional) {
  // str and flag must not be NULL.
  if (str == nullptr || flag == nullptr) return nullptr;

  // The flag must start with "--gmock_".
  const std::string flag_str = std::string("--gmock_") + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return nullptr;

  // Returns the string after "=".
  return flag_end + 1;
}

// Parses a string for a Google Mock bool flag, in the form of
// "--gmock_flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
                                    bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

// Parses a string for a Google Mock string flag, in the form of
// "--gmock_flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
template <typename String>
static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
                                      String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
                                   int32_t* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag,
                    value_str, value);
}

// The internal implementation of InitGoogleMock().
//
// The type parameter CharType can be instantiated to either char or
// wchar_t.
template <typename CharType>
void InitGoogleMockImpl(int* argc, CharType** argv) {
  // Makes sure Google Test is initialized.  InitGoogleTest() is
  // idempotent, so it's fine if the user has already called it.
  InitGoogleTest(argc, argv);
  if (*argc <= 0) return;

  for (int i = 1; i != *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();

    // Do we see a Google Mock flag?
    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
                                &GMOCK_FLAG(catch_leaked_mocks)) ||
        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
                               &GMOCK_FLAG(default_mock_behavior))) {
      // Yes.  Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }

      // Decrements the argument count.
      (*argc)--;

      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }
}

}  // namespace internal

// Initializes Google Mock.  This must be called before running the
// tests.  In particular, it parses a command line for the flags that
// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
// removed from argv, and *argc is decremented.
//
// No value is returned.  Instead, the Google Mock flag variables are
// updated.
//
// Since Google Test is needed for Google Mock to work, this function
// also initializes Google Test and parses its flags, if that hasn't
// been done.
GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
  internal::InitGoogleMockImpl(argc, argv);
}

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
  internal::InitGoogleMockImpl(argc, argv);
}

// This overloaded version can be used on Arduino/embedded platforms where
// there is no argc/argv.
GTEST_API_ void InitGoogleMock() {
  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
  int argc = 1;
  const auto arg0 = "dummy";
  char* argv0 = const_cast<char*>(arg0);
  char** argv = &argv0;

  internal::InitGoogleMockImpl(&argc, argv);
}

}  // namespace testing


================================================
FILE: examples/libraries/fmt/test/gtest/gtest/gtest-spi.h
================================================
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Utilities for testing Google Test itself and code that uses Google Test
// (e.g. frameworks built on top of Google Test).

// GOOGLETEST_CM0004 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

#include "gtest/gtest.h"

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// This helper class can be used to mock out Google Test failure reporting
// so that we can test Google Test or code that builds on Google Test.
//
// An object of this class appends a TestPartResult object to the
// TestPartResultArray object given in the constructor whenever a Google Test
// failure is reported. It can either intercept only failures that are
// generated in the same thread that created this object or it can intercept
// all generated failures. The scope of this mock object can be controlled with
// the second argument to the two arguments constructor.
class GTEST_API_ ScopedFakeTestPartResultReporter
    : public TestPartResultReporterInterface {
 public:
  // The two possible mocking modes of this object.
  enum InterceptMode {
    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
    INTERCEPT_ALL_THREADS           // Intercepts all failures.
  };

  // The c'tor sets this object as the test part result reporter used
  // by Google Test.  The 'result' parameter specifies where to report the
  // results. This reporter will only catch failures generated in the current
  // thread. DEPRECATED
  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);

  // Same as above, but you can choose the interception scope of this object.
  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
                                   TestPartResultArray* result);

  // The d'tor restores the previous test part result reporter.
  ~ScopedFakeTestPartResultReporter() override;

  // Appends the TestPartResult object to the TestPartResultArray
  // received in the constructor.
  //
  // This method is from the TestPartResultReporterInterface
  // interface.
  void ReportTestPartResult(const TestPartResult& result) override;

 private:
  void Init();

  const InterceptMode intercept_mode_;
  TestPartResultReporterInterface* old_reporter_;
  TestPartResultArray* const result_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
};

namespace internal {

// A helper class for implementing EXPECT_FATAL_FAILURE() and
// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
// TestPartResultArray contains exactly one failure that has the given
// type and contains the given substring.  If that's not the case, a
// non-fatal failure will be generated.
class GTEST_API_ SingleFailureChecker {
 public:
  // The constructor remembers the arguments.
  SingleFailureChecker(const TestPartResultArray* results,
                       TestPartResult::Type type, const std::string& substr);
  ~SingleFailureChecker();
 private:
  const TestPartResultArray* const results_;
  const TestPartResult::Type type_;
  const std::string substr_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
};

}  // namespace internal

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// A set of macros for testing Google Test assertions or code that's expected
// to generate Google Test fatal failures.  It verifies that the given
// statement will cause exactly one fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
//   - 'statement' cannot reference local non-static variables or
//     non-static members of the current object.
//   - 'statement' cannot return a value.
//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \
  do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
  do { \
    class GTestExpectFatalFailureHelper {\
     public:\
      static void Execute() { statement; }\
    };\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ALL_THREADS, &gtest_failures);\
      GTestExpectFatalFailureHelper::Execute();\
    }\
  } while (::testing::internal::AlwaysFalse())

// A macro for testing Google Test assertions or code that's expected to
// generate Google Test non-fatal failures.  It asserts that the given
// statement will cause exactly one non-fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// 'statement' is allowed to reference local variables and members of
// the current object.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
//   - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  If we do that, the code won't compile when the user gives
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
// expands to code containing an unprotected comma.  The
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
// catches that.
//
// For the same reason, we have to write
//   if (::testing::internal::AlwaysTrue()) { statement; }
// instead of
//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
// to avoid an MSVC warning on unreachable code.
#define EXPECT_NONFATAL_FAILURE(statement, substr) \
  do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
  do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
        (substr));\
    {\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
          &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
    }\
  } while (::testing::internal::AlwaysFalse())

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_


================================================
FILE: examples/libraries/fmt/test/gtest/gtest/gtest.h
================================================
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file defines the public API for Google Test.  It should be
// included by any test program that uses Google Test.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
// program!
//
// Acknowledgment: Google Test borrowed the idea of automatic test
// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
// easyUnit framework.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_

#include <cstddef>
#include <limits>
#include <memory>
#include <ostream>
#include <type_traits>
#include <vector>

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file declares functions and macros used internally by
// Google Test.  They are subject to change without notice.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Low-level types and utilities for porting Google Test to various
// platforms.  All macros ending with _ and symbols defined in an
// internal namespace are subject to change without notice.  Code
// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
// end with _ are part of Google Test's public API and can be used by
// code outside Google Test.
//
// This file is fundamental to Google Test.  All other Google Test source
// files are expected to #include this.  Therefore, it cannot #include
// any other Google Test header.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

// Environment-describing macros
// -----------------------------
//
// Google Test can be used in many different environments.  Macros in
// this section tell Google Test what kind of environment it is being
// used in, such that Google Test can provide environment-specific
// features and implementations.
//
// Google Test tries to automatically detect the properties of its
// environment, so users usually don't need to worry about these
// macros.  However, the automatic detection is not perfect.
// Sometimes it's necessary for a user to define some of the following
// macros in the build script to override Google Test's decisions.
//
// If the user doesn't define a macro in the list, Google Test will
// provide a default definition.  After this header is #included, all
// macros in this list will be defined to either 1 or 0.
//
// Notes to maintainers:
//   - Each macro here is a user-tweakable knob; do not grow the list
//     lightly.
//   - Use #if to key off these macros.  Don't use #ifdef or "#if
//     defined(...)", which will not work as these macros are ALWAYS
//     defined.
//
//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
//                              is/isn't available.
//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
//                              are enabled.
//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
//                              expressions are/aren't available.
//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
//                              is/isn't available.
//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
//                              enabled.
//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
//                              std::wstring does/doesn't work (Google Test can
//                              be used where std::wstring is unavailable).
//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
//                              compiler supports Microsoft's "Structured
//                              Exception Handling".
//   GTEST_HAS_STREAM_REDIRECTION
//                            - Define it to 1/0 to indicate whether the
//                              platform supports I/O stream redirection using
//                              dup() and dup2().
//   GTEST_LINKED_AS_SHARED_LIBRARY
//                            - Define to 1 when compiling tests that use
//                              Google Test as a shared library (known as
//                              DLL on Windows).
//   GTEST_CREATE_SHARED_LIBRARY
//                            - Define to 1 when compiling Google Test itself
//                              as a shared library.
//   GTEST_DEFAULT_DEATH_TEST_STYLE
//                            - The default value of --gtest_death_test_style.
//                              The legacy default has been "fast" in the open
//                              source version since 2008. The recommended value
//                              is "threadsafe", and can be set in
//                              custom/gtest-port.h.

// Platform-indicating macros
// --------------------------
//
// Macros indicating the platform on which Google Test is being used
// (a macro is defined to 1 if compiled on the given platform;
// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
// defines these macros automatically.  Code outside Google Test MUST
// NOT define them.
//
//   GTEST_OS_AIX      - IBM AIX
//   GTEST_OS_CYGWIN   - Cygwin
//   GTEST_OS_DRAGONFLY - DragonFlyBSD
//   GTEST_OS_FREEBSD  - FreeBSD
//   GTEST_OS_FUCHSIA  - Fuchsia
//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
//   GTEST_OS_HAIKU    - Haiku
//   GTEST_OS_HPUX     - HP-UX
//   GTEST_OS_LINUX    - Linux
//     GTEST_OS_LINUX_ANDROID - Google Android
//   GTEST_OS_MAC      - Mac OS X
//     GTEST_OS_IOS    - iOS
//   GTEST_OS_NACL     - Google Native Client (NaCl)
//   GTEST_OS_NETBSD   - NetBSD
//   GTEST_OS_OPENBSD  - OpenBSD
//   GTEST_OS_OS2      - OS/2
//   GTEST_OS_QNX      - QNX
//   GTEST_OS_SOLARIS  - Sun Solaris
//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
//     GTEST_OS_WINDOWS_MINGW    - MinGW
//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
//   GTEST_OS_ZOS      - z/OS
//
// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
// most stable support.  Since core members of the Google Test project
// don't have access to other platforms, support for them may be less
// stable.  If you notice any problems on your platform, please notify
// googletestframework@googlegroups.com (patches for fixing them are
// even more welcome!).
//
// It is possible that none of the GTEST_OS_* macros are defined.

// Feature-indicating macros
// -------------------------
//
// Macros indicating which Google Test features are available (a macro
// is defined to 1 if the corresponding feature is supported;
// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
// defines these macros automatically.  Code outside Google Test MUST
// NOT define them.
//
// These macros are public so that portable tests can be written.
// Such tests typically surround code using a feature with an #if
// which controls that code.  For example:
//
// #if GTEST_HAS_DEATH_TEST
//   EXPECT_DEATH(DoSomethingDeadly());
// #endif
//
//   GTEST_HAS_DEATH_TEST   - death tests
//   GTEST_HAS_TYPED_TEST   - typed tests
//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
//   GOOGLETEST_CM0007 DO NOT DELETE
//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
//                            GTEST_HAS_POSIX_RE (see above) which users can
//                            define themselves.
//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
//                            the above RE\b(s) are mutually exclusive.

// Misc public macros
// ------------------
//
//   GTEST_FLAG(flag_name)  - references the variable corresponding to
//                            the given Google Test flag.

// Internal utilities
// ------------------
//
// The following macros and utilities are for Google Test's INTERNAL
// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
//
// Macros for basic C++ coding:
//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
//                              variable don't have to be used.
//   GTEST_DISALLOW_ASSIGN_   - disables copy operator=.
//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=.
//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
//                                        suppressed (constant conditional).
//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
//                                        is suppressed.
//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
//                            UniversalPrinter<absl::any> specializations.
//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
//   or
//                                 UniversalPrinter<absl::optional>
//                                 specializations.
//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
//                                    Matcher<absl::string_view>
//                                    specializations.
//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
//                                UniversalPrinter<absl::variant>
//                                specializations.
//
// Synchronization:
//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
//                            - synchronization primitives.
//
// Regular expressions:
//   RE             - a simple regular expression class using the POSIX
//                    Extended Regular Expression syntax on UNIX-like platforms
//                    GOOGLETEST_CM0008 DO NOT DELETE
//                    or a reduced regular exception syntax on other
//                    platforms, including Windows.
// Logging:
//   GTEST_LOG_()   - logs messages at the specified severity level.
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.
//
// Stdout and stderr capturing:
//   CaptureStdout()     - starts capturing stdout.
//   GetCapturedStdout() - stops capturing stdout and returns the captured
//                         string.
//   CaptureStderr()     - starts capturing stderr.
//   GetCapturedStderr() - stops capturing stderr and returns the captured
//                         string.
//
// Integer types:
//   TypeWithSize   - maps an integer to a int type.
//   TimeInMillis   - integers of known sizes.
//   BiggestInt     - the biggest signed integer type.
//
// Command-line utilities:
//   GTEST_DECLARE_*()  - declares a flag.
//   GTEST_DEFINE_*()   - defines a flag.
//   GetInjectableArgvs() - returns the command line as a vector of strings.
//
// Environment variable utilities:
//   GetEnv()             - gets the value of an environment variable.
//   BoolFromGTestEnv()   - parses a bool environment variable.
//   Int32FromGTestEnv()  - parses an int32_t environment variable.
//   StringFromGTestEnv() - parses a string environment variable.
//
// Deprecation warnings:
//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
//                                        deprecated; calling a marked function
//                                        should generate a compiler warning

#include <ctype.h>   // for isspace, etc
#include <stddef.h>  // for ptrdiff_t
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <cerrno>
#include <cstdint>
#include <limits>
#include <type_traits>

#ifndef _WIN32_WCE
# include <sys/types.h>
# include <sys/stat.h>
#endif  // !_WIN32_WCE

#if defined __APPLE__
# include <AvailabilityMacros.h>
# include <TargetConditionals.h>
#endif

#include <iostream>  // NOLINT
#include <locale>
#include <memory>
#include <string>  // NOLINT
#include <tuple>
#include <vector>  // NOLINT

// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file defines the GTEST_OS_* macro.
// It is separate from gtest-port.h so that custom/gtest-port.h can include it.

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

// Determines the platform on which Google Test is compiled.
#ifdef __CYGWIN__
# define GTEST_OS_CYGWIN 1
# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
#  define GTEST_OS_WINDOWS_MINGW 1
#  define GTEST_OS_WINDOWS 1
#elif defined _WIN32
# define GTEST_OS_WINDOWS 1
# ifdef _WIN32_WCE
#  define GTEST_OS_WINDOWS_MOBILE 1
# elif defined(WINAPI_FAMILY)
#  include <winapifamily.h>
#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#   define GTEST_OS_WINDOWS_DESKTOP 1
#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
#   define GTEST_OS_WINDOWS_PHONE 1
#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#   define GTEST_OS_WINDOWS_RT 1
#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
#   define GTEST_OS_WINDOWS_PHONE 1
#   define GTEST_OS_WINDOWS_TV_TITLE 1
#  else
    // WINAPI_FAMILY defined but no known partition matched.
    // Default to desktop.
#   define GTEST_OS_WINDOWS_DESKTOP 1
#  endif
# else
#  define GTEST_OS_WINDOWS_DESKTOP 1
# endif  // _WIN32_WCE
#elif defined __OS2__
# define GTEST_OS_OS2 1
#elif defined __APPLE__
# define GTEST_OS_MAC 1
# include <TargetConditionals.h>
# if TARGET_OS_IPHONE
#  define GTEST_OS_IOS 1
# endif
#elif defined __DragonFly__
# define GTEST_OS_DRAGONFLY 1
#elif defined __FreeBSD__
# define GTEST_OS_FREEBSD 1
#elif defined __Fuchsia__
# define GTEST_OS_FUCHSIA 1
#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
# define GTEST_OS_GNU_KFREEBSD 1
#elif defined __linux__
# define GTEST_OS_LINUX 1
# if defined __ANDROID__
#  define GTEST_OS_LINUX_ANDROID 1
# endif
#elif defined __MVS__
# define GTEST_OS_ZOS 1
#elif defined(__sun) && defined(__SVR4)
# define GTEST_OS_SOLARIS 1
#elif defined(_AIX)
# define GTEST_OS_AIX 1
#elif defined(__hpux)
# define GTEST_OS_HPUX 1
#elif defined __native_client__
# define GTEST_OS_NACL 1
#elif defined __NetBSD__
# define GTEST_OS_NETBSD 1
#elif defined __OpenBSD__
# define GTEST_OS_OPENBSD 1
#elif defined __QNX__
# define GTEST_OS_QNX 1
#elif defined(__HAIKU__)
#define GTEST_OS_HAIKU 1
#elif defined ESP8266
#define GTEST_OS_ESP8266 1
#elif defined ESP32
#define GTEST_OS_ESP32 1
#elif defined(__XTENSA__)
#define GTEST_OS_XTENSA 1
#endif  // __CYGWIN__

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

#if !defined(GTEST_DEV_EMAIL_)
# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
# define GTEST_FLAG_PREFIX_ "gtest_"
# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
# define GTEST_NAME_ "Google Test"
# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
#endif  // !defined(GTEST_DEV_EMAIL_)

#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)

// Determines the version of gcc that is used to compile this.
#ifdef __GNUC__
// 40302 means version 4.3.2.
# define GTEST_GCC_VER_ \
    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
#endif  // __GNUC__

// Macros for disabling Microsoft Visual C++ warnings.
//
//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
//   /* code that triggers warnings C4800 and C4385 */
//   GTEST_DISABLE_MSC_WARNINGS_POP_()
#if defined(_MSC_VER)
# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
    __pragma(warning(push))                        \
    __pragma(warning(disable: warnings))
# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
    __pragma(warning(pop))
#else
// Not all compilers are MSVC
# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
# define GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif

// Clang on Windows does not understand MSVC's pragma warning.
// We need clang-specific way to disable function deprecation warning.
#ifdef __clang__
# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
    _Pragma("clang diagnostic push")                                  \
    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
    _Pragma("clang diagnostic pop")
#else
# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
    GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif

// Brings in definitions for functions used in the testing::internal::posix
// namespace (read, write, close, chdir, isatty, stat). We do not currently
// use them on Windows Mobile.
#if GTEST_OS_WINDOWS
# if !GTEST_OS_WINDOWS_MOBILE
#  include <direct.h>
#  include <io.h>
# endif
// In order to avoid having to include <windows.h>, use forward declaration
#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
// separate (equivalent) structs, instead of using typedef
typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#else
// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
// This assumption is verified by
// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#endif
#elif GTEST_OS_XTENSA
#include <unistd.h>
// Xtensa toolchains define strcasecmp in the string.h header instead of
// strings.h. string.h is already included.
#else
// This assumes that non-Windows OSes provide unistd.h. For OSes where this
// is not the case, we need to include headers that provide the functions
// mentioned above.
# include <unistd.h>
# include <strings.h>
#endif  // GTEST_OS_WINDOWS

#if GTEST_OS_LINUX_ANDROID
// Used to define __ANDROID_API__ matching the target NDK API level.
#  include <android/api-level.h>  // NOLINT
#endif

// Defines this to true if and only if Google Test can use POSIX regular
// expressions.
#ifndef GTEST_HAS_POSIX_RE
# if GTEST_OS_LINUX_ANDROID
// On Android, <regex.h> is only available starting with Gingerbread.
#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
# else
#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
# endif
#endif

#if GTEST_USES_PCRE
// The appropriate headers have already been included.

#elif GTEST_HAS_POSIX_RE

// On some platforms, <regex.h> needs someone to define size_t, and
// won't compile otherwise.  We can #include it here as we already
// included <stdlib.h>, which is guaranteed to define size_t through
// <stddef.h>.
# include <regex.h>  // NOLINT

# define GTEST_USES_POSIX_RE 1

#elif GTEST_OS_WINDOWS

// <regex.h> is not available on Windows.  Use our own simple regex
// implementation instead.
# define GTEST_USES_SIMPLE_RE 1

#else

// <regex.h> may not be available on this platform.  Use our own
// simple regex implementation instead.
# define GTEST_USES_SIMPLE_RE 1

#endif  // GTEST_USES_PCRE

#ifndef GTEST_HAS_EXCEPTIONS
// The user didn't tell us whether exceptions are enabled, so we need
// to figure it out.
# if defined(_MSC_VER) && defined(_CPPUNWIND)
// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__BORLANDC__)
// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
// macro to enable exceptions, so we'll do the same.
// Assumes that exceptions are enabled by default.
#  ifndef _HAS_EXCEPTIONS
#   define _HAS_EXCEPTIONS 1
#  endif  // _HAS_EXCEPTIONS
#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
# elif defined(__clang__)
// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
// there can be cleanups for ObjC exceptions which also need cleanups, even if
// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which
// checks for C++ exceptions starting at clang r206352, but which checked for
// cleanups prior to that. To reliably check for C++ exception availability with
// clang, check for
// __EXCEPTIONS && __has_feature(cxx_exceptions).
#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
# elif defined(__GNUC__) && __EXCEPTIONS
// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__SUNPRO_CC)
// Sun Pro CC supports exceptions.  However, there is no compile-time way of
// detecting whether they are enabled or not.  Therefore, we assume that
// they are enabled unless the user tells us otherwise.
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__IBMCPP__) && __EXCEPTIONS
// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
#  define GTEST_HAS_EXCEPTIONS 1
# elif defined(__HP_aCC)
// Exception handling is in effect by default in HP aCC compiler. It has to
// be turned of by +noeh compiler option if desired.
#  define GTEST_HAS_EXCEPTIONS 1
# else
// For other compilers, we assume exceptions are disabled to be
// conservative.
#  define GTEST_HAS_EXCEPTIONS 0
# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
#endif  // GTEST_HAS_EXCEPTIONS

#ifndef GTEST_HAS_STD_WSTRING
// The user didn't tell us whether ::std::wstring is available, so we need
// to figure it out.
// Cygwin 1.7 and below doesn't support ::std::wstring.
// Solaris' libc++ doesn't support it either.  Android has
// no support for it at least as recent as Froyo (2.2).
#define GTEST_HAS_STD_WSTRING                                         \
  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))

#endif  // GTEST_HAS_STD_WSTRING

// Determines whether RTTI is available.
#ifndef GTEST_HAS_RTTI
// The user didn't tell us whether RTTI is enabled, so we need to
// figure it out.

# ifdef _MSC_VER

#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
#   define GTEST_HAS_RTTI 1
#  else
#   define GTEST_HAS_RTTI 0
#  endif

// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
// enabled.
# elif defined(__GNUC__)

#  ifdef __GXX_RTTI
// When building against STLport with the Android NDK and with
// -frtti -fno-exceptions, the build fails at link time with undefined
// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
// so disable RTTI when detected.
#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
       !defined(__EXCEPTIONS)
#    define GTEST_HAS_RTTI 0
#   else
#    define GTEST_HAS_RTTI 1
#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
#  else
#   define GTEST_HAS_RTTI 0
#  endif  // __GXX_RTTI

// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
// first version with C++ support.
# elif defined(__clang__)

#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)

// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
// both the typeid and dynamic_cast features are present.
# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)

#  ifdef __RTTI_ALL__
#   define GTEST_HAS_RTTI 1
#  else
#   define GTEST_HAS_RTTI 0
#  endif

# else

// For all other compilers, we assume RTTI is enabled.
#  define GTEST_HAS_RTTI 1

# endif  // _MSC_VER

#endif  // GTEST_HAS_RTTI

// It's this header's responsibility to #include <typeinfo> when RTTI
// is enabled.
#if GTEST_HAS_RTTI
# include <typeinfo>
#endif

// Determines whether Google Test can use the pthreads library.
#ifndef GTEST_HAS_PTHREAD
// The user didn't tell us explicitly, so we make reasonable assumptions about
// which platforms have pthreads support.
//
// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
// to your compiler flags.
#define GTEST_HAS_PTHREAD                                                      \
  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
   GTEST_OS_HAIKU)
#endif  // GTEST_HAS_PTHREAD

#if GTEST_HAS_PTHREAD
// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
// true.
# include <pthread.h>  // NOLINT

// For timespec and nanosleep, used below.
# include <time.h>  // NOLINT
#endif

// Determines whether clone(2) is supported.
// Usually it will only be available on Linux, excluding
// Linux on the Itanium architecture.
// Also see http://linux.die.net/man/2/clone.
#ifndef GTEST_HAS_CLONE
// The user didn't tell us, so we need to figure it out.

# if GTEST_OS_LINUX && !defined(__ia64__)
#  if GTEST_OS_LINUX_ANDROID
// On Android, clone() became available at different API levels for each 32-bit
// architecture.
#    if defined(__LP64__) || \
        (defined(__arm__) && __ANDROID_API__ >= 9) || \
        (defined(__mips__) && __ANDROID_API__ >= 12) || \
        (defined(__i386__) && __ANDROID_API__ >= 17)
#     define GTEST_HAS_CLONE 1
#    else
#     define GTEST_HAS_CLONE 0
#    endif
#  else
#   define GTEST_HAS_CLONE 1
#  endif
# else
#  define GTEST_HAS_CLONE 0
# endif  // GTEST_OS_LINUX && !defined(__ia64__)

#endif  // GTEST_HAS_CLONE

// Determines whether to support stream redirection. This is used to test
// output correctness and to implement death tests.
#ifndef GTEST_HAS_STREAM_REDIRECTION
// By default, we assume that stream redirection is supported on all
// platforms except known mobile ones.
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
#  define GTEST_HAS_STREAM_REDIRECTION 0
# else
#  define GTEST_HAS_STREAM_REDIRECTION 1
# endif  // !GTEST_OS_WINDOWS_MOBILE
#endif  // GTEST_HAS_STREAM_REDIRECTION

// Determines whether to support death tests.
// pops up a dialog window that cannot be suppressed programmatically.
#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
# define GTEST_HAS_DEATH_TEST 1
#endif

// Determines whether to support type-driven tests.

// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
// Sun Pro CC, IBM Visual Age, and HP aCC support.
#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
    defined(__IBMCPP__) || defined(__HP_aCC)
# define GTEST_HAS_TYPED_TEST 1
# define GTEST_HAS_TYPED_TEST_P 1
#endif

// Determines whether the system compiler uses UTF-16 for encoding wide strings.
#define GTEST_WIDE_STRING_USES_UTF16_ \
  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)

// Determines whether test results can be streamed to a socket.
#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
# define GTEST_CAN_STREAM_RESULTS_ 1
#endif

// Defines some utility macros.

// The GNU compiler emits a warning if nested "if" statements are followed by
// an "else" statement and braces are not used to explicitly disambiguate the
// "else" binding.  This leads to problems with code like:
//
//   if (gate)
//     ASSERT_*(condition) << "Some message";
//
// The "switch (0) case 0:" idiom is used to suppress this.
#ifdef __INTEL_COMPILER
# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
#else
# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
#endif

// Use this annotation at the end of a struct/class definition to
// prevent the compiler from optimizing away instances that are never
// used.  This is useful when all interesting logic happens inside the
// c'tor and / or d'tor.  Example:
//
//   struct Foo {
//     Foo() { ... }
//   } GTEST_ATTRIBUTE_UNUSED_;
//
// Also use it after a variable or parameter declaration to tell the
// compiler the variable/parameter does not have to be used.
#if defined(__GNUC__) && !defined(COMPILER_ICC)
# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
#elif defined(__clang__)
# if __has_attribute(unused)
#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
# endif
#endif
#ifndef GTEST_ATTRIBUTE_UNUSED_
# define GTEST_ATTRIBUTE_UNUSED_
#endif

// Use this annotation before a function that takes a printf format string.
#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
# if defined(__MINGW_PRINTF_FORMAT)
// MinGW has two different printf implementations. Ensure the format macro
// matches the selected implementation. See
// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
                                 first_to_check)))
# else
#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
       __attribute__((__format__(__printf__, string_index, first_to_check)))
# endif
#else
# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
#endif


// A macro to disallow copy operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_ASSIGN_(type) \
  type& operator=(type const &) = delete

// A macro to disallow copy constructor and operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
  type(type const&) = delete;                 \
  type& operator=(type const&) = delete

// A macro to disallow move operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
  type& operator=(type &&) noexcept = delete

// A macro to disallow move constructor and operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
  type(type&&) noexcept = delete;             \
  type& operator=(type&&) noexcept = delete

// Tell the compiler to warn about unused return values for functions declared
// with this macro.  The macro should be used on function declarations
// following the argument list:
//
//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
#if defined(__GNUC__) && !defined(COMPILER_ICC)
# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
#else
# define GTEST_MUST_USE_RESULT_
#endif  // __GNUC__ && !COMPILER_ICC

// MS C++ compiler emits warning when a conditional expression is compile time
// constant. In some contexts this warning is false positive and needs to be
// suppressed. Use the following two macros in such cases:
//
// GTEST_INTENTIONAL_CONST_COND_PUSH_()
// while (true) {
// GTEST_INTENTIONAL_CONST_COND_POP_()
// }
# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
# define GTEST_INTENTIONAL_CONST_COND_POP_() \
    GTEST_DISABLE_MSC_WARNINGS_POP_()

// Determine whether the compiler supports Microsoft's Structured Exception
// Handling.  This is supported by several Windows compilers but generally
// does not exist on any other system.
#ifndef GTEST_HAS_SEH
// The user didn't tell us, so we need to figure it out.

# if defined(_MSC_VER) || defined(__BORLANDC__)
// These two compilers are known to support SEH.
#  define GTEST_HAS_SEH 1
# else
// Assume no SEH.
#  define GTEST_HAS_SEH 0
# endif

#endif  // GTEST_HAS_SEH

#ifndef GTEST_IS_THREADSAFE

#define GTEST_IS_THREADSAFE                                                 \
  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
   GTEST_HAS_PTHREAD)

#endif  // GTEST_IS_THREADSAFE

// GTEST_API_ qualifies all symbols that must be exported. The definitions below
// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
// gtest/internal/custom/gtest-port.h
#ifndef GTEST_API_

#ifdef _MSC_VER
# if GTEST_LINKED_AS_SHARED_LIBRARY
#  define GTEST_API_ __declspec(dllimport)
# elif GTEST_CREATE_SHARED_LIBRARY
#  define GTEST_API_ __declspec(dllexport)
# endif
#elif __GNUC__ >= 4 || defined(__clang__)
# define GTEST_API_ __attribute__((visibility ("default")))
#endif  // _MSC_VER

#endif  // GTEST_API_

#ifndef GTEST_API_
# define GTEST_API_
#endif  // GTEST_API_

#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE

#ifdef __GNUC__
// Ask the compiler to never inline a given function.
# define GTEST_NO_INLINE_ __attribute__((noinline))
#else
# define GTEST_NO_INLINE_
#endif

// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
#if !defined(GTEST_HAS_CXXABI_H_)
# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
#  define GTEST_HAS_CXXABI_H_ 1
# else
#  define GTEST_HAS_CXXABI_H_ 0
# endif
#endif

// A function level attribute to disable checking for use of uninitialized
// memory when built with MemorySanitizer.
#if defined(__clang__)
# if __has_feature(memory_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
       __attribute__((no_sanitize_memory))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
# endif  // __has_feature(memory_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
#endif  // __clang__

// A function level attribute to disable AddressSanitizer instrumentation.
#if defined(__clang__)
# if __has_feature(address_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
       __attribute__((no_sanitize_address))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
# endif  // __has_feature(address_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
#endif  // __clang__

// A function level attribute to disable HWAddressSanitizer instrumentation.
#if defined(__clang__)
# if __has_feature(hwaddress_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
       __attribute__((no_sanitize("hwaddress")))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
# endif  // __has_feature(hwaddress_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
#endif  // __clang__

// A function level attribute to disable ThreadSanitizer instrumentation.
#if defined(__clang__)
# if __has_feature(thread_sanitizer)
#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
       __attribute__((no_sanitize_thread))
# else
#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
# endif  // __has_feature(thread_sanitizer)
#else
# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
#endif  // __clang__

namespace testing {

class Message;

// Legacy imports for backwards compatibility.
// New code should use std:: names directly.
using std::get;
using std::make_tuple;
using std::tuple;
using std::tuple_element;
using std::tuple_size;

namespace internal {

// A secret type that Google Test users don't know about.  It has no
// definition on purpose.  Therefore it's impossible to create a
// Secret object, which is what we want.
class Secret;

// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
// time expression is true (in new code, use static_assert instead). For
// example, you could use it to verify the size of a static array:
//
//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
//                         names_incorrect_size);
//
// The second argument to the macro must be a valid C++ identifier. If the
// expression is false, compiler will issue an error containing this identifier.
#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)

// A helper for suppressing warnings on constant condition.  It just
// returns 'condition'.
GTEST_API_ bool IsTrue(bool condition);

// Defines RE.

#if GTEST_USES_PCRE
// if used, PCRE is injected by custom/gtest-port.h
#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE

// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
// Regular Expression syntax.
class GTEST_API_ RE {
 public:
  // A copy constructor is required by the Standard to initialize object
  // references from r-values.
  RE(const RE& other) { Init(other.pattern()); }

  // Constructs an RE from a string.
  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT

  RE(const char* regex) { Init(regex); }  // NOLINT
  ~RE();

  // Returns the string representation of the regex.
  const char* pattern() const { return pattern_; }

  // FullMatch(str, re) returns true if and only if regular expression re
  // matches the entire str.
  // PartialMatch(str, re) returns true if and only if regular expression re
  // matches a substring of str (including str itself).
  static bool FullMatch(const ::std::string& str, const RE& re) {
    return FullMatch(str.c_str(), re);
  }
  static bool PartialMatch(const ::std::string& str, const RE& re) {
    return PartialMatch(str.c_str(), re);
  }

  static bool FullMatch(const char* str, const RE& re);
  static bool PartialMatch(const char* str, const RE& re);

 private:
  void Init(const char* regex);
  const char* pattern_;
  bool is_valid_;

# if GTEST_USES_POSIX_RE

  regex_t full_regex_;     // For FullMatch().
  regex_t partial_regex_;  // For PartialMatch().

# else  // GTEST_USES_SIMPLE_RE

  const char* full_pattern_;  // For FullMatch();

# endif
};

#endif  // GTEST_USES_PCRE

// Formats a source file path and a line number as they would appear
// in an error message from the compiler used to compile this code.
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);

// Formats a file location for compiler-independent XML output.
// Although this function is not platform dependent, we put it next to
// FormatFileLocation in order to contrast the two functions.
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
                                                               int line);

// Defines logging utilities:
//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
//                          message itself is streamed into the macro.
//   LogToStderr()  - directs all log messages to stderr.
//   FlushInfoLog() - flushes informational log messages.

enum GTestLogSeverity {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

// Formats log entry severity, provides a stream object for streaming the
// log message, and terminates the message with a newline when going out of
// scope.
class GTEST_API_ GTestLog {
 public:
  GTestLog(GTestLogSeverity severity, const char* file, int line);

  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
  ~GTestLog();

  ::std::ostream& GetStream() { return ::std::cerr; }

 private:
  const GTestLogSeverity severity_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
};

#if !defined(GTEST_LOG_)

# define GTEST_LOG_(severity) \
    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()

inline void LogToStderr() {}
inline void FlushInfoLog() { fflush(nullptr); }

#endif  // !defined(GTEST_LOG_)

#if !defined(GTEST_CHECK_)
// INTERNAL IMPLEMENTATION - DO NOT USE.
//
// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
// is not satisfied.
//  Synopsys:
//    GTEST_CHECK_(boolean_condition);
//     or
//    GTEST_CHECK_(boolean_condition) << "Additional message";
//
//    This checks the condition and if the condition is not satisfied
//    it prints message about the condition violation, including the
//    condition itself, plus additional message streamed into it, if any,
//    and then it aborts the program. It aborts the program irrespective of
//    whether it is built in the debug mode or not.
# define GTEST_CHECK_(condition) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::IsTrue(condition)) \
      ; \
    else \
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
#endif  // !defined(GTEST_CHECK_)

// An all-mode assert to verify that the given POSIX-style function
// call returns 0 (indicating success).  Known limitation: this
// doesn't expand to a balanced 'if' statement, so enclose the macro
// in {} if you need to use it as the only statement in an 'if'
// branch.
#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
  if (const int gtest_error = (posix_call)) \
    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
                      << gtest_error

// Transforms "T" into "const T&" according to standard reference collapsing
// rules (this is only needed as a backport for C++98 compilers that do not
// support reference collapsing). Specifically, it transforms:
//
//   char         ==> const char&
//   const char   ==> const char&
//   char&        ==> char&
//   const char&  ==> const char&
//
// Note that the non-const reference will not have "const" added. This is
// standard, and necessary so that "T" can always bind to "const T&".
template <typename T>
struct ConstRef { typedef const T& type; };
template <typename T>
struct ConstRef<T&> { typedef T& type; };

// The argument T must depend on some template parameters.
#define GTEST_REFERENCE_TO_CONST_(T) \
  typename ::testing::internal::ConstRef<T>::type

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Use ImplicitCast_ as a safe version of static_cast for upcasting in
// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
// const Foo*).  When you use ImplicitCast_, the compiler checks that
// the cast is safe.  Such explicit ImplicitCast_s are necessary in
// surprisingly many situations where C++ demands an exact type match
// instead of an argument type convertable to a target type.
//
// The syntax for using ImplicitCast_ is the same as for static_cast:
//
//   ImplicitCast_<ToType>(expr)
//
// ImplicitCast_ would have been part of the C++ standard library,
// but the proposal was submitted too late.  It will probably make
// its way into the language in the future.
//
// This relatively ugly name is intentional. It prevents clashes with
// similar functions users may have (e.g., implicit_cast). The internal
// namespace alone is not enough because the function can be found by ADL.
template<typename To>
inline To ImplicitCast_(To x) { return x; }

// When you upcast (that is, cast a pointer from type Foo to type
// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
// always succeed.  When you downcast (that is, cast a pointer from
// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
// how do you know the pointer is really of type SubclassOfFoo?  It
// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
// when you downcast, you should use this macro.  In debug mode, we
// use dynamic_cast<> to double-check the downcast is legal (we die
// if it's not).  In normal mode, we do the efficient static_cast<>
// instead.  Thus, it's important to test in debug mode to make sure
// the cast is legal!
//    This is the only place in the code we should use dynamic_cast<>.
// In particular, you SHOULDN'T be using dynamic_cast<> in order to
// do RTTI (eg code like this:
//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
// You should design the code some other way not to need this.
//
// This relatively ugly name is intentional. It prevents clashes with
// similar functions users may have (e.g., down_cast). The internal
// namespace alone is not enough because the function can be found by ADL.
template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
inline To DownCast_(From* f) {  // so we only accept pointers
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
  if (false) {
  GTEST_INTENTIONAL_CONST_COND_POP_()
  const To to = nullptr;
  ::testing::internal::ImplicitCast_<From*>(to);
  }

#if GTEST_HAS_RTTI
  // RTTI: debug mode only!
  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
#endif
  return static_cast<To>(f);
}

// Downcasts the pointer of type Base to Derived.
// Derived must be a subclass of Base. The parameter MUST
// point to a class of type Derived, not any subclass of it.
// When RTTI is available, the function performs a runtime
// check to enforce this.
template <class Derived, class Base>
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

#if GTEST_HAS_STREAM_REDIRECTION

// Defines the stderr capturer:
//   CaptureStdout     - starts capturing stdout.
//   GetCapturedStdout - stops capturing stdout and returns the captured string.
//   CaptureStderr     - starts capturing stderr.
//   GetCapturedStderr - stops capturing stderr and returns the captured string.
//
GTEST_API_ void CaptureStdout();
GTEST_API_ std::string GetCapturedStdout();
GTEST_API_ void CaptureStderr();
GTEST_API_ std::string GetCapturedStderr();

#endif  // GTEST_HAS_STREAM_REDIRECTION
// Returns the size (in bytes) of a file.
GTEST_API_ size_t GetFileSize(FILE* file);

// Reads the entire content of a file as a string.
GTEST_API_ std::string ReadEntireFile(FILE* file);

// All command line arguments.
GTEST_API_ std::vector<std::string> GetArgvs();

#if GTEST_HAS_DEATH_TEST

std::vector<std::string> GetInjectableArgvs();
// Deprecated: pass the args vector by value instead.
void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
void ClearInjectableArgvs();

#endif  // GTEST_HAS_DEATH_TEST

// Defines synchronization primitives.
#if GTEST_IS_THREADSAFE
# if GTEST_HAS_PTHREAD
// Sleeps for (roughly) n milliseconds.  This function is only for testing
// Google Test's own constructs.  Don't use it in user tests, either
// directly or indirectly.
inline void SleepMilliseconds(int n) {
  const timespec time = {
    0,                  // 0 seconds.
    n * 1000L * 1000L,  // And n ms.
  };
  nanosleep(&time, nullptr);
}
# endif  // GTEST_HAS_PTHREAD

# if GTEST_HAS_NOTIFICATION_
// Notification has already been imported into the namespace.
// Nothing to do here.

# elif GTEST_HAS_PTHREAD
// Allows a controller thread to pause execution of newly created
// threads until notified.  Instances of this class must be created
// and destroyed in the controller thread.
//
// This class is only for testing Google Test's own constructs. Do not
// use it in user tests, either directly or indirectly.
class Notification {
 public:
  Notification() : notified_(false) {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  }
  ~Notification() {
    pthread_mutex_destroy(&mutex_);
  }

  // Notifies all threads created with this notification to start. Must
  // be called from the controller thread.
  void Notify() {
    pthread_mutex_lock(&mutex_);
    notified_ = true;
    pthread_mutex_unlock(&mutex_);
  }

  // Blocks until the controller thread notifies. Must be called from a test
  // thread.
  void WaitForNotification() {
    for (;;) {
      pthread_mutex_lock(&mutex_);
      const bool notified = notified_;
      pthread_mutex_unlock(&mutex_);
      if (notified)
        break;
      SleepMilliseconds(10);
    }
  }

 private:
  pthread_mutex_t mutex_;
  bool notified_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
};

# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT

GTEST_API_ void SleepMilliseconds(int n);

// Provides leak-safe Windows kernel handle ownership.
// Used in death tests and in threading support.
class GTEST_API_ AutoHandle {
 public:
  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
  // avoid including <windows.h> in this header file. Including <windows.h> is
  // undesirable because it defines a lot of symbols and macros that tend to
  // conflict with client code. This assumption is verified by
  // WindowsTypesTest.HANDLEIsVoidStar.
  typedef void* Handle;
  AutoHandle();
  explicit AutoHandle(Handle handle);

  ~AutoHandle();

  Handle Get() const;
  void Reset();
  void Reset(Handle handle);

 private:
  // Returns true if and only if the handle is a valid handle object that can be
  // closed.
  bool IsCloseable() const;

  Handle handle_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
};

// Allows a controller thread to pause execution of newly created
// threads until notified.  Instances of this class must be created
// and destroyed in the controller thread.
//
// This class is only for testing Google Test's own constructs. Do not
// use it in user tests, either directly or indirectly.
class GTEST_API_ Notification {
 public:
  Notification();
  void Notify();
  void WaitForNotification();

 private:
  AutoHandle event_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
};
# endif  // GTEST_HAS_NOTIFICATION_

// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
// defined, but we don't want to use MinGW's pthreads implementation, which
// has conformance problems with some versions of the POSIX standard.
# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW

// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
// Consequently, it cannot select a correct instantiation of ThreadWithParam
// in order to call its Run(). Introducing ThreadWithParamBase as a
// non-templated base class for ThreadWithParam allows us to bypass this
// problem.
class ThreadWithParamBase {
 public:
  virtual ~ThreadWithParamBase() {}
  virtual void Run() = 0;
};

// pthread_create() accepts a pointer to a function type with the C linkage.
// According to the Standard (7.5/1), function types with different linkages
// are different even if they are otherwise identical.  Some compilers (for
// example, SunStudio) treat them as different types.  Since class methods
// cannot be defined with C-linkage we need to define a free C-function to
// pass into pthread_create().
extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
  static_cast<ThreadWithParamBase*>(thread)->Run();
  return nullptr;
}

// Helper class for testing Google Test's multi-threading constructs.
// To use it, write:
//
//   void ThreadFunc(int param) { /* Do things with param */ }
//   Notification thread_can_start;
//   ...
//   // The thread_can_start parameter is optional; you can supply NULL.
//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
//   thread_can_start.Notify();
//
// These classes are only for testing Google Test's own constructs. Do
// not use them in user tests, either directly or indirectly.
template <typename T>
class ThreadWithParam : public ThreadWithParamBase {
 public:
  typedef void UserThreadFunc(T);

  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
      : func_(func),
        param_(param),
        thread_can_start_(thread_can_start),
        finished_(false) {
    ThreadWithParamBase* const base = this;
    // The thread can be created only after all fields except thread_
    // have been initialized.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
  }
  ~ThreadWithParam() override { Join(); }

  void Join() {
    if (!finished_) {
      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
      finished_ = true;
    }
  }

  void Run() override {
    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
    func_(param_);
  }

 private:
  UserThreadFunc* const func_;  // User-supplied thread function.
  const T param_;  // User-supplied parameter to the thread function.
  // When non-NULL, used to block execution until the controller thread
  // notifies.
  Notification* const thread_can_start_;
  bool finished_;  // true if and only if we know that the thread function has
                   // finished.
  pthread_t thread_;  // The native thread object.

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
};
# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_

# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
// Mutex and ThreadLocal have already been imported into the namespace.
// Nothing to do here.

# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT

// Mutex implements mutex on Windows platforms.  It is used in conjunction
// with class MutexLock:
//
//   Mutex mutex;
//   ...
//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
//                            // end of the current scope.
//
// A static Mutex *must* be defined or declared using one of the following
// macros:
//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
//
// (A non-static Mutex is defined/declared in the usual way).
class GTEST_API_ Mutex {
 public:
  enum MutexType { kStatic = 0, kDynamic = 1 };
  // We rely on kStaticMutex being 0 as it is to what the linker initializes
  // type_ in static mutexes.  critical_section_ will be initialized lazily
  // in ThreadSafeLazyInit().
  enum StaticConstructorSelector { kStaticMutex = 0 };

  // This constructor intentionally does nothing.  It relies on type_ being
  // statically initialized to 0 (effectively setting it to kStatic) and on
  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
  explicit Mutex(StaticConstructorSelector /*dummy*/) {}

  Mutex();
  ~Mutex();

  void Lock();

  void Unlock();

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
  void AssertHeld();

 private:
  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
  void ThreadSafeLazyInit();

  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
  // we assume that 0 is an invalid value for thread IDs.
  unsigned int owner_thread_id_;

  // For static mutexes, we rely on these members being initialized to zeros
  // by the linker.
  MutexType type_;
  long critical_section_init_phase_;  // NOLINT
  GTEST_CRITICAL_SECTION* critical_section_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
    extern ::testing::internal::Mutex mutex

# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)

// We cannot name this class MutexLock because the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex* mutex)
      : mutex_(mutex) { mutex_->Lock(); }

  ~GTestMutexLock() { mutex_->Unlock(); }

 private:
  Mutex* const mutex_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
};

typedef GTestMutexLock MutexLock;

// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
// without knowing its type.
class ThreadLocalValueHolderBase {
 public:
  virtual ~ThreadLocalValueHolderBase() {}
};

// Provides a way for a thread to send notifications to a ThreadLocal
// regardless of its parameter type.
class ThreadLocalBase {
 public:
  // Creates a new ValueHolder<T> object holding a default value passed to
  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
  // responsibility not to call this when the ThreadLocal<T> instance already
  // has a value on the current thread.
  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;

 protected:
  ThreadLocalBase() {}
  virtual ~ThreadLocalBase() {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
};

// Maps a thread to a set of ThreadLocals that have values instantiated on that
// thread and notifies them when the thread exits.  A ThreadLocal instance is
// expected to persist until all threads it has values on have terminated.
class GTEST_API_ ThreadLocalRegistry {
 public:
  // Registers thread_local_instance as having value on the current thread.
  // Returns a value that can be used to identify the thread from other threads.
  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
      const ThreadLocalBase* thread_local_instance);

  // Invoked when a ThreadLocal instance is destroyed.
  static void OnThreadLocalDestroyed(
      const ThreadLocalBase* thread_local_instance);
};

class GTEST_API_ ThreadWithParamBase {
 public:
  void Join();

 protected:
  class Runnable {
   public:
    virtual ~Runnable() {}
    virtual void Run() = 0;
  };

  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
  virtual ~ThreadWithParamBase();

 private:
  AutoHandle thread_;
};

// Helper class for testing Google Test's multi-threading constructs.
template <typename T>
class ThreadWithParam : public ThreadWithParamBase {
 public:
  typedef void UserThreadFunc(T);

  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
  }
  virtual ~ThreadWithParam() {}

 private:
  class RunnableImpl : public Runnable {
   public:
    RunnableImpl(UserThreadFunc* func, T param)
        : func_(func),
          param_(param) {
    }
    virtual ~RunnableImpl() {}
    virtual void Run() {
      func_(param_);
    }

   private:
    UserThreadFunc* const func_;
    const T param_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
  };

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
};

// Implements thread-local storage on Windows systems.
//
//   // Thread 1
//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
//
//   // Thread 2
//   tl.set(150);  // Changes the value for thread 2 only.
//   EXPECT_EQ(150, tl.get());
//
//   // Thread 1
//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
//   tl.set(200);
//   EXPECT_EQ(200, tl.get());
//
// The template type argument T must have a public copy constructor.
// In addition, the default ThreadLocal constructor requires T to have
// a public default constructor.
//
// The users of a TheadLocal instance have to make sure that all but one
// threads (including the main one) using that instance have exited before
// destroying it. Otherwise, the per-thread objects managed for them by the
// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
//
// Google Test only uses global ThreadLocal objects.  That means they
// will die after main() has returned.  Therefore, no per-thread
// object managed by Google Test will be leaked as long as all threads
// using Google Test have exited when main() returns.
template <typename T>
class ThreadLocal : public ThreadLocalBase {
 public:
  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
  explicit ThreadLocal(const T& value)
      : default_factory_(new InstanceValueHolderFactory(value)) {}

  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }

  T* pointer() { return GetOrCreateValue(); }
  const T* pointer() const { return GetOrCreateValue(); }
  const T& get() const { return *pointer(); }
  void set(const T& value) { *pointer() = value; }

 private:
  // Holds a value of T.  Can be deleted via its base class without the caller
  // knowing the type of T.
  class ValueHolder : public ThreadLocalValueHolderBase {
   public:
    ValueHolder() : value_() {}
    explicit ValueHolder(const T& value) : value_(value) {}

    T* pointer() { return &value_; }

   private:
    T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
  };


  T* GetOrCreateValue() const {
    return static_cast<ValueHolder*>(
        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
  }

  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
    return default_factory_->MakeNewHolder();
  }

  class ValueHolderFactory {
   public:
    ValueHolderFactory() {}
    virtual ~ValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const = 0;

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
  };

  class DefaultValueHolderFactory : public ValueHolderFactory {
   public:
    DefaultValueHolderFactory() {}
    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
  };

  class InstanceValueHolderFactory : public ValueHolderFactory {
   public:
    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
    ValueHolder* MakeNewHolder() const override {
      return new ValueHolder(value_);
    }

   private:
    const T value_;  // The value for each thread.

    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
  };

  std::unique_ptr<ValueHolderFactory> default_factory_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

# elif GTEST_HAS_PTHREAD

// MutexBase and Mutex implement mutex on pthreads-based platforms.
class MutexBase {
 public:
  // Acquires this mutex.
  void Lock() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
    owner_ = pthread_self();
    has_owner_ = true;
  }

  // Releases this mutex.
  void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
    // mutex when this is called.
    has_owner_ = false;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
  void AssertHeld() const {
    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
        << "The current thread is not holding the mutex @" << this;
  }

  // A static mutex may be used before main() is entered.  It may even
  // be used before the dynamic initialization stage.  Therefore we
  // must be able to initialize a static mutex object at link time.
  // This means MutexBase has to be a POD and its member variables
  // have to be public.
 public:
  pthread_mutex_t mutex_;  // The underlying pthread mutex.
  // has_owner_ indicates whether the owner_ field below contains a valid thread
  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
  // accesses to the owner_ field should be protected by a check of this field.
  // An alternative might be to memset() owner_ to all zeros, but there's no
  // guarantee that a zero'd pthread_t is necessarily invalid or even different
  // from pthread_self().
  bool has_owner_;
  pthread_t owner_;  // The thread holding the mutex.
};

// Forward-declares a static mutex.
#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
     extern ::testing::internal::MutexBase mutex

// Defines and statically (i.e. at link time) initializes a static mutex.
// The initialization list here does not explicitly initialize each field,
// instead relying on default initialization for the unspecified fields. In
// particular, the owner_ field (a pthread_t) is not explicitly initialized.
// This allows initialization to work whether pthread_t is a scalar or struct.
// The flag -Wmissing-field-initializers must not be specified for this to work.
#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}

// The Mutex class can only be used for mutexes created at runtime. It
// shares its API with MutexBase otherwise.
class Mutex : public MutexBase {
 public:
  Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
    has_owner_ = false;
  }
  ~Mutex() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
  }

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
};

// We cannot name this class MutexLock because the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(MutexBase* mutex)
      : mutex_(mutex) { mutex_->Lock(); }

  ~GTestMutexLock() { mutex_->Unlock(); }

 private:
  MutexBase* const mutex_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
};

typedef GTestMutexLock MutexLock;

// Helpers for ThreadLocal.

// pthread_key_create() requires DeleteThreadLocalValue() to have
// C-linkage.  Therefore it cannot be templatized to access
// ThreadLocal<T>.  Hence the need for class
// ThreadLocalValueHolderBase.
class ThreadLocalValueHolderBase {
 public:
  virtual ~ThreadLocalValueHolderBase() {}
};

// Called by pthread to delete thread-local data stored by
// pthread_setspecific().
extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
}

// Implements thread-local storage on pthreads-based systems.
template <typename T>
class GTEST_API_ ThreadLocal {
 public:
  ThreadLocal()
      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
  explicit ThreadLocal(const T& value)
      : key_(CreateKey()),
        default_factory_(new InstanceValueHolderFactory(value)) {}

  ~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

  T* pointer() { return GetOrCreateValue(); }
  const T* pointer() const { return GetOrCreateValue(); }
  const T& get() const { return *pointer(); }
  void set(const T& value) { *pointer() = value; }

 private:
  // Holds a value of type T.
  class ValueHolder : public ThreadLocalValueHolderBase {
   public:
    ValueHolder() : value_() {}
    explicit ValueHolder(const T& value) : value_(value) {}

    T* pointer() { return &value_; }

   private:
    T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
  };

  static pthread_key_t CreateKey() {
    pthread_key_t key;
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
    return key;
  }

  T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != nullptr) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

  class ValueHolderFactory {
   public:
    ValueHolderFactory() {}
    virtual ~ValueHolderFactory() {}
    virtual ValueHolder* MakeNewHolder() const = 0;

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
  };

  class DefaultValueHolderFactory : public ValueHolderFactory {
   public:
    DefaultValueHolderFactory() {}
    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
  };

  class InstanceValueHolderFactory : public ValueHolderFactory {
   public:
    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
    ValueHolder* MakeNewHolder() const override {
      return new ValueHolder(value_);
    }

   private:
    const T value_;  // The value for each thread.

    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
  };

  // A key pthreads uses for looking up per-thread values.
  const pthread_key_t key_;
  std::unique_ptr<ValueHolderFactory> default_factory_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
};

# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_

#else  // GTEST_IS_THREADSAFE

// A dummy implementation of synchronization primitives (mutex, lock,
// and thread-local variable).  Necessary for compiling Google Test where
// mutex is not supported - using Google Test in multiple threads is not
// supported on such platforms.

class Mutex {
 public:
  Mutex() {}
  void Lock() {}
  void Unlock() {}
  void AssertHeld() const {}
};

# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
  extern ::testing::internal::Mutex mutex

# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex

// We cannot name this class MutexLock because the ctor declaration would
// conflict with a macro named MutexLock, which is defined on some
// platforms. That macro is used as a defensive measure to prevent against
// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
// "MutexLock l(&mu)".  Hence the typedef trick below.
class GTestMutexLock {
 public:
  explicit GTestMutexLock(Mutex*) {}  // NOLINT
};

typedef GTestMutexLock MutexLock;

template <typename T>
class GTEST_API_ ThreadLocal {
 public:
  ThreadLocal() : value_() {}
  explicit ThreadLocal(const T& value) : value_(value) {}
  T* pointer() { return &value_; }
  const T* pointer() const { return &value_; }
  const T& get() const { return value_; }
  void set(const T& value) { value_ = value; }
 private:
  T value_;
};

#endif  // GTEST_IS_THREADSAFE

// Returns the number of threads running in the process, or 0 to indicate that
// we cannot detect it.
GTEST_API_ size_t GetThreadCount();

#if GTEST_OS_WINDOWS
# define GTEST_PATH_SEP_ "\\"
# define GTEST_HAS_ALT_PATH_SEP_ 1
#else
# define GTEST_PATH_SEP_ "/"
# define GTEST_HAS_ALT_PATH_SEP_ 0
#endif  // GTEST_OS_WINDOWS

// Utilities for char.

// isspace(int ch) and friends accept an unsigned char or EOF.  char
// may be signed, depending on the compiler (or compiler flags).
// Therefore we need to cast a char to unsigned char before calling
// isspace(), etc.

inline bool IsAlpha(char ch) {
  return isalpha(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsAlNum(char ch) {
  return isalnum(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsDigit(char ch) {
  return isdigit(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsLower(char ch) {
  return islower(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsSpace(char ch) {
  return isspace(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsUpper(char ch) {
  return isupper(static_cast<unsigned char>(ch)) != 0;
}
inline bool IsXDigit(char ch) {
  return isxdigit(static_cast<unsigned char>(ch)) != 0;
}
#ifdef __cpp_char8_t
inline bool IsXDigit(char8_t ch) {
  return isxdigit(static_cast<unsigned char>(ch)) != 0;
}
#endif
inline bool IsXDigit(char16_t ch) {
  const unsigned char low_byte = static_cast<unsigned char>(ch);
  return ch == low_byte && isxdigit(low_byte) != 0;
}
inline bool IsXDigit(char32_t ch) {
  const unsigned char low_byte = static_cast<unsigned char>(ch);
  return ch == low_byte && isxdigit(low_byte) != 0;
}
inline bool IsXDigit(wchar_t ch) {
  const unsigned char low_byte = static_cast<unsigned char>(ch);
  return ch == low_byte && isxdigit(low_byte) != 0;
}

inline char ToLower(char ch) {
  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
}
inline char ToUpper(char ch) {
  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
}

inline std::string StripTrailingSpaces(std::string str) {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

// The testing::internal::posix namespace holds wrappers for common
// POSIX functions.  These wrappers hide the differences between
// Windows/MSVC and POSIX systems.  Since some compilers define these
// standard functions as macros, the wrapper cannot have the same name
// as the wrapped function.

namespace posix {

// Functions with a different name on Windows.

#if GTEST_OS_WINDOWS

typedef struct _stat StatStruct;

# ifdef __BORLANDC__
inline int DoIsATTY(int fd) { return isatty(fd); }
inline int StrCaseCmp(const char* s1, const char* s2) {
  return stricmp(s1, s2);
}
inline char* StrDup(const char* src) { return strdup(src); }
# else  // !__BORLANDC__
#  if GTEST_OS_WINDOWS_MOBILE
inline int DoIsATTY(int /* fd */) { return 0; }
#  else
inline int DoIsATTY(int fd) { return _isatty(fd); }
#  endif  // GTEST_OS_WINDOWS_MOBILE
inline int StrCaseCmp(const char* s1, const char* s2) {
  return _stricmp(s1, s2);
}
inline char* StrDup(const char* src) { return _strdup(src); }
# endif  // __BORLANDC__

# if GTEST_OS_WINDOWS_MOBILE
inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
// time and thus not defined there.
# else
inline int FileNo(FILE* file) { return _fileno(file); }
inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) {
  return (_S_IFDIR & st.st_mode) != 0;
}
# endif  // GTEST_OS_WINDOWS_MOBILE

#elif GTEST_OS_ESP8266
typedef struct stat StatStruct;

inline int FileNo(FILE* file) { return fileno(file); }
inline int DoIsATTY(int fd) { return isatty(fd); }
inline int Stat(const char* path, StatStruct* buf) {
  // stat function not implemented on ESP8266
  return 0;
}
inline int StrCaseCmp(const char* s1, const char* s2) {
  return strcasecmp(s1, s2);
}
inline char* StrDup(const char* src) { return strdup(src); }
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }

#else

typedef struct stat StatStruct;

inline int FileNo(FILE* file) { return fileno(file); }
inline int DoIsATTY(int fd) { return isatty(fd); }
inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
inline int StrCaseCmp(const char* s1, const char* s2) {
  return strcasecmp(s1, s2);
}
inline char* StrDup(const char* src) { return strdup(src); }
inline int RmDir(const char* dir) { return rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }

#endif  // GTEST_OS_WINDOWS

inline int IsATTY(int fd) {
  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
  // to a file on Linux), which is unexpected, so save the previous value, and
  // restore it after the call.
  int savedErrno = errno;
  int isAttyValue = DoIsATTY(fd);
  errno = savedErrno;

  return isAttyValue;
}

// Functions deprecated by MSVC 8.0.

GTEST_DISABLE_MSC_DEPRECATED_PUSH_()

// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
// StrError() aren't needed on Windows CE at this time and thus not
// defined there.

#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
inline int ChDir(const char* dir) { return chdir(dir); }
#endif
inline FILE* FOpen(const char* path, const char* mode) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
  std::wstring_convert<wchar_codecvt> converter;
  std::wstring wide_path = converter.from_bytes(path);
  std::wstring wide_mode = converter.from_bytes(mode);
  return _wfopen(wide_path.c_str(), wide_mode.c_str());
#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
  return fopen(path, mode);
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
}
#if !GTEST_OS_WINDOWS_MOBILE
inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
  return freopen(path, mode, stream);
}
inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
#endif
inline int FClose(FILE* fp) { return fclose(fp); }
#if !GTEST_OS_WINDOWS_MOBILE
inline int Read(int fd, void* buf, unsigned int count) {
  return static_cast<int>(read(fd, buf, count));
}
inline int Write(int fd, const void* buf, unsigned int count) {
  return static_cast<int>(write(fd, buf, count));
}
inline int Close(int fd) { return close(fd); }
inline const char* StrError(int errnum) { return strerror(errnum); }
#endif
inline const char* GetEnv(const char* name) {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
  // We are on an embedded platform, which has no environment variables.
  static_cast<void>(name);  // To prevent 'unused argument' warning.
  return nullptr;
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
  // Environment variables which we programmatically clear will be set to the
  // empty string rather than unset (NULL).  Handle that case.
  const char* const env = getenv(name);
  return (env != nullptr && env[0] != '\0') ? env : nullptr;
#else
  return getenv(name);
#endif
}

GTEST_DISABLE_MSC_DEPRECATED_POP_()

#if GTEST_OS_WINDOWS_MOBILE
// Windows CE has no C library. The abort() function is used in
// several places in Google Test. This implementation provides a reasonable
// imitation of standard behaviour.
[[noreturn]] void Abort();
#else
[[noreturn]] inline void Abort() { abort(); }
#endif  // GTEST_OS_WINDOWS_MOBILE

}  // namespace posix

// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
// function in order to achieve that.  We use macro definition here because
// snprintf is a variadic function.
#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
// MSVC 2005 and above support variadic macros.
# define GTEST_SNPRINTF_(buffer, size, format, ...) \
     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
#elif defined(_MSC_VER)
// Windows CE does not define _snprintf_s
# define GTEST_SNPRINTF_ _snprintf
#else
# define GTEST_SNPRINTF_ snprintf
#endif

// The biggest signed integer type the compiler supports.
//
// long long is guaranteed to be at least 64-bits in C++11.
using BiggestInt = long long;  // NOLINT

// The maximum number a BiggestInt can represent.
constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();

// This template class serves as a compile-time function from size to
// type.  It maps a size in bytes to a primitive type with that
// size. e.g.
//
//   TypeWithSize<4>::UInt
//
// is typedef-ed to be unsigned int (unsigned integer made up of 4
// bytes).
//
// Such functionality should belong to STL, but I cannot find it
// there.
//
// Google Test uses this class in the implementation of floating-point
// comparison.
//
// For now it only handles UInt (unsigned int) as that's all Google Test
// needs.  Other types can be easily added in the future if need
// arises.
template <size_t size>
class TypeWithSize {
 public:
  // This prevents the user from using TypeWithSize<N> with incorrect
  // values of N.
  using UInt = void;
};

// The specialization for size 4.
template <>
class TypeWithSize<4> {
 public:
  using Int = std::int32_t;
  using UInt = std::uint32_t;
};

// The specialization for size 8.
template <>
class TypeWithSize<8> {
 public:
  using Int = std::int64_t;
  using UInt = std::uint64_t;
};

// Integer types of known sizes.
using TimeInMillis = int64_t;  // Represents time in milliseconds.

// Utilities for command line flags and environment variables.

// Macro for referencing flags.
#if !defined(GTEST_FLAG)
# define GTEST_FLAG(name) FLAGS_gtest_##name
#endif  // !defined(GTEST_FLAG)

#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)

#if !defined(GTEST_DECLARE_bool_)
# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver

// Macros for declaring flags.
# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
# define GTEST_DECLARE_int32_(name) \
    GTEST_API_ extern std::int32_t GTEST_FLAG(name)
# define GTEST_DECLARE_string_(name) \
    GTEST_API_ extern ::std::string GTEST_FLAG(name)

// Macros for defining flags.
# define GTEST_DEFINE_bool_(name, default_val, doc) \
    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
# define GTEST_DEFINE_int32_(name, default_val, doc) \
    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
# define GTEST_DEFINE_string_(name, default_val, doc) \
    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)

#endif  // !defined(GTEST_DECLARE_bool_)

// Thread annotations
#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
# define GTEST_LOCK_EXCLUDED_(locks)
#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)

// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
// to *value and returns true; otherwise leaves *value unchanged and returns
// false.
GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,
                           int32_t* value);

// Parses a bool/int32_t/string from the environment variable
// corresponding to the given Google Test flag.
bool BoolFromGTestEnv(const char* flag, bool default_val);
GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);
std::string OutputFlagAlsoCheckEnvVar();
const char* StringFromGTestEnv(const char* flag, const char* default_val);

}  // namespace internal
}  // namespace testing

#if !defined(GTEST_INTERNAL_DEPRECATED)

// Internal Macro to mark an API deprecated, for googletest usage only
// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
// a deprecated entity will trigger a warning when compiled with
// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
// For msvc /W3 option will need to be used
// Note that for 'other' compilers this macro evaluates to nothing to prevent
// compilations errors.
#if defined(_MSC_VER)
#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
#elif defined(__GNUC__)
#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
#else
#define GTEST_INTERNAL_DEPRECATED(message)
#endif

#endif  // !defined(GTEST_INTERNAL_DEPRECATED)

#if GTEST_HAS_ABSL
// Always use absl::any for UniversalPrinter<> specializations if googletest
// is built with absl support.
#define GTEST_INTERNAL_HAS_ANY 1
#include "absl/types/any.h"
namespace testing {
namespace internal {
using Any = ::absl::any;
}  // namespace internal
}  // namespace testing
#else
#ifdef __has_include
#if __has_include(<any>) && __cplusplus >= 201703L
// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
// specializations.
#define GTEST_INTERNAL_HAS_ANY 1
#include <any>
namespace testing {
namespace internal {
using Any = ::std::any;
}  // namespace internal
}  // namespace testing
// The case where absl is configured NOT to alias std::any is not
// supported.
#endif  // __has_include(<any>) && __cplusplus >= 201703L
#endif  // __has_include
#endif  // GTEST_HAS_ABSL

#if GTEST_HAS_ABSL
// Always use absl::optional for UniversalPrinter<> specializations if
// googletest is built with absl support.
#define GTEST_INTERNAL_HAS_OPTIONAL 1
#include "absl/types/optional.h"
namespace testing {
namespace internal {
template <typename T>
using Optional = ::absl::optional<T>;
}  // namespace internal
}  // namespace testing
#else
#ifdef __has_include
#if __has_include(<optional>) && __cplusplus >= 201703L
// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
// specializations.
#define GTEST_INTERNAL_HAS_OPTIONAL 1
#include <optional>
namespace testing {
namespace internal {
template <typename T>
using Optional = ::std::optional<T>;
}  // namespace internal
}  // namespace testing
// The case where absl is configured NOT to alias std::optional is not
// supported.
#endif  // __has_include(<optional>) && __cplusplus >= 201703L
#endif  // __has_include
#endif  // GTEST_HAS_ABSL

#if GTEST_HAS_ABSL
// Always use absl::string_view for Matcher<> specializations if googletest
// is built with absl support.
# define GTEST_INTERNAL_HAS_STRING_VIEW 1
#include "absl/strings/string_view.h"
namespace testing {
namespace internal {
using StringView = ::absl::string_view;
}  // namespace internal
}  // namespace testing
#else
# ifdef __has_include
#   if __has_include(<string_view>) && __cplusplus >= 201703L
// Otherwise for C++17 and higher use std::string_view for Matcher<>
// specializations.
#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
#include <string_view>
namespace testing {
namespace internal {
using StringView = ::std::string_view;
}  // namespace internal
}  // namespace testing
// The case where absl is configured NOT to alias std::string_view is not
// supported.
#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
# endif  // __has_include
#endif  // GTEST_HAS_ABSL

#if GTEST_HAS_ABSL
// Always use absl::variant for UniversalPrinter<> specializations if googletest
// is built with absl support.
#define GTEST_INTERNAL_HAS_VARIANT 1
#include "absl/types/variant.h"
namespace testing {
namespace internal {
template <typename... T>
using Variant = ::absl::variant<T...>;
}  // namespace internal
}  // namespace testing
#else
#ifdef __has_include
#if __has_include(<variant>) && __cplusplus >= 201703L
// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
// specializations.
#define GTEST_INTERNAL_HAS_VARIANT 1
#include <variant>
namespace testing {
namespace internal {
template <typename... T>
using Variant = ::std::variant<T...>;
}  // namespace internal
}  // namespace testing
// The case where absl is configured NOT to alias std::variant is not supported.
#endif  // __has_include(<variant>) && __cplusplus >= 201703L
#endif  // __has_include
#endif  // GTEST_HAS_ABSL

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

#if GTEST_OS_LINUX
# include <stdlib.h>
# include <sys/types.h>
# include <sys/wait.h>
# include <unistd.h>
#endif  // GTEST_OS_LINUX

#if GTEST_HAS_EXCEPTIONS
# include <stdexcept>
#endif

#include <ctype.h>
#include <float.h>
#include <string.h>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <set>
#include <string>
#include <type_traits>
#include <vector>

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file defines the Message class.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
// program!

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#include <limits>
#include <memory>
#include <sstream>


GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

// Ensures that there is at least one operator<< in the global namespace.
// See Message& operator<<(...) below for why.
void operator<<(const testing::internal::Secret&, int);

namespace testing {

// The Message class works like an ostream repeater.
//
// Typical usage:
//
//   1. You stream a bunch of values to a Message object.
//      It will remember the text in a stringstream.
//   2. Then you stream the Message object to an ostream.
//      This causes the text in the Message to be streamed
//      to the ostream.
//
// For example;
//
//   testing::Message foo;
//   foo << 1 << " != " << 2;
//   std::cout << foo;
//
// will print "1 != 2".
//
// Message is not intended to be inherited from.  In particular, its
// destructor is not virtual.
//
// Note that stringstream behaves differently in gcc and in MSVC.  You
// can stream a NULL char pointer to it in the former, but not in the
// latter (it causes an access violation if you do).  The Message
// class hides this difference by treating a NULL char pointer as
// "(null)".
class GTEST_API_ Message {
 private:
  // The type of basic IO manipulators (endl, ends, and flush) for
  // narrow streams.
  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);

 public:
  // Constructs an empty Message.
  Message();

  // Copy constructor.
  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
    *ss_ << msg.GetString();
  }

  // Constructs a Message from a C-string.
  explicit Message(const char* str) : ss_(new ::std::stringstream) {
    *ss_ << str;
  }

  // Streams a non-pointer value to this object.
  template <typename T>
  inline Message& operator <<(const T& val) {
    // Some libraries overload << for STL containers.  These
    // overloads are defined in the global namespace instead of ::std.
    //
    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
    // overloads are visible in either the std namespace or the global
    // namespace, but not other namespaces, including the testing
    // namespace which Google Test's Message class is in.
    //
    // To allow STL containers (and other types that has a << operator
    // defined in the global namespace) to be used in Google Test
    // assertions, testing::Message must access the custom << operator
    // from the global namespace.  With this using declaration,
    // overloads of << defined in the global namespace and those
    // visible via Koenig lookup are both exposed in this function.
    using ::operator <<;
    *ss_ << val;
    return *this;
  }

  // Streams a pointer value to this object.
  //
  // This function is an overload of the previous one.  When you
  // stream a pointer to a Message, this definition will be used as it
  // is more specialized.  (The C++ Standard, section
  // [temp.func.order].)  If you stream a non-pointer, then the
  // previous definition will be used.
  //
  // The reason for this overload is that streaming a NULL pointer to
  // ostream is undefined behavior.  Depending on the compiler, you
  // may get "0", "(nil)", "(null)", or an access violation.  To
  // ensure consistent result across compilers, we always treat NULL
  // as "(null)".
  template <typename T>
  inline Message& operator <<(T* const& pointer) {  // NOLINT
    if (pointer == nullptr) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

  // Since the basic IO manipulators are overloaded for both narrow
  // and wide streams, we have to provide this specialized definition
  // of operator <<, even though its body is the same as the
  // templatized version above.  Without this definition, streaming
  // endl or other basic IO manipulators to Message will confuse the
  // compiler.
  Message& operator <<(BasicNarrowIoManip val) {
    *ss_ << val;
    return *this;
  }

  // Instead of 1/0, we want to see true/false for bool values.
  Message& operator <<(bool b) {
    return *this << (b ? "true" : "false");
  }

  // These two overloads allow streaming a wide C string to a Message
  // using the UTF-8 encoding.
  Message& operator <<(const wchar_t* wide_c_str);
  Message& operator <<(wchar_t* wide_c_str);

#if GTEST_HAS_STD_WSTRING
  // Converts the given wide string to a narrow string using the UTF-8
  // encoding, and streams the result to this Message object.
  Message& operator <<(const ::std::wstring& wstr);
#endif  // GTEST_HAS_STD_WSTRING

  // Gets the text streamed to this object so far as an std::string.
  // Each '\0' character in the buffer is replaced with "\\0".
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
  std::string GetString() const;

 private:
  // We'll hold the text streamed to this object here.
  const std::unique_ptr< ::std::stringstream> ss_;

  // We declare (but don't implement) this to prevent the compiler
  // from implementing the assignment operator.
  void operator=(const Message&);
};

// Streams a Message to an ostream.
inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
  return os << sb.GetString();
}

namespace internal {

// Converts a streamable value to an std::string.  A NULL pointer is
// converted to "(null)".  When the input value is a ::string,
// ::std::string, ::wstring, or ::std::wstring object, each NUL
// character in it is replaced with "\\0".
template <typename T>
std::string StreamableToString(const T& streamable) {
  return (Message() << streamable).GetString();
}

}  // namespace internal
}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Google Test filepath utilities
//
// This header file declares classes and functions used internally by
// Google Test.  They are subject to change without notice.
//
// This file is #included in gtest/internal/gtest-internal.h.
// Do not include this header file separately!

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file declares the String class and functions used internally by
// Google Test.  They are subject to change without notice. They should not used
// by code external to Google Test.
//
// This header file is #included by gtest-internal.h.
// It should not be #included by other files.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_

#ifdef __BORLANDC__
// string.h is not guaranteed to provide strcpy on C++ Builder.
# include <mem.h>
#endif

#include <string.h>
#include <cstdint>
#include <string>


namespace testing {
namespace internal {

// String - an abstract class holding static string utilities.
class GTEST_API_ String {
 public:
  // Static utility methods

  // Clones a 0-terminated C string, allocating memory using new.  The
  // caller is responsible for deleting the return value using
  // delete[].  Returns the cloned string, or NULL if the input is
  // NULL.
  //
  // This is different from strdup() in string.h, which allocates
  // memory using malloc().
  static const char* CloneCString(const char* c_str);

#if GTEST_OS_WINDOWS_MOBILE
  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
  // able to pass strings to Win32 APIs on CE we need to convert them
  // to 'Unicode', UTF-16.

  // Creates a UTF-16 wide string from the given ANSI string, allocating
  // memory using new. The caller is responsible for deleting the return
  // value using delete[]. Returns the wide string, or NULL if the
  // input is NULL.
  //
  // The wide string is created using the ANSI codepage (CP_ACP) to
  // match the behaviour of the ANSI versions of Win32 calls and the
  // C runtime.
  static LPCWSTR AnsiToUtf16(const char* c_str);

  // Creates an ANSI string from the given wide string, allocating
  // memory using new. The caller is responsible for deleting the return
  // value using delete[]. Returns the ANSI string, or NULL if the
  // input is NULL.
  //
  // The returned string is created using the ANSI codepage (CP_ACP) to
  // match the behaviour of the ANSI versions of Win32 calls and the
  // C runtime.
  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
#endif

  // Compares two C strings.  Returns true if and only if they have the same
  // content.
  //
  // Unlike strcmp(), this function can handle NULL argument(s).  A
  // NULL C string is considered different to any non-NULL C string,
  // including the empty string.
  static bool CStringEquals(const char* lhs, const char* rhs);

  // Converts a wide C string to a String using the UTF-8 encoding.
  // NULL will be converted to "(null)".  If an error occurred during
  // the conversion, "(failed to convert from wide string)" is
  // returned.
  static std::string ShowWideCString(const wchar_t* wide_c_str);

  // Compares two wide C strings.  Returns true if and only if they have the
  // same content.
  //
  // Unlike wcscmp(), this function can handle NULL argument(s).  A
  // NULL C string is considered different to any non-NULL C string,
  // including the empty string.
  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);

  // Compares two C strings, ignoring case.  Returns true if and only if
  // they have the same content.
  //
  // Unlike strcasecmp(), this function can handle NULL argument(s).
  // A NULL C string is considered different to any non-NULL C string,
  // including the empty string.
  static bool CaseInsensitiveCStringEquals(const char* lhs,
                                           const char* rhs);

  // Compares two wide C strings, ignoring case.  Returns true if and only if
  // they have the same content.
  //
  // Unlike wcscasecmp(), this function can handle NULL argument(s).
  // A NULL C string is considered different to any non-NULL wide C string,
  // including the empty string.
  // NB: The implementations on different platforms slightly differ.
  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
  // environment variable. On GNU platform this method uses wcscasecmp
  // which compares according to LC_CTYPE category of the current locale.
  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
  // current locale.
  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                               const wchar_t* rhs);

  // Returns true if and only if the given string ends with the given suffix,
  // ignoring case. Any string is considered to end with an empty suffix.
  static bool EndsWithCaseInsensitive(
      const std::string& str, const std::string& suffix);

  // Formats an int value as "%02d".
  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2

  // Formats an int value to given width with leading zeros.
  static std::string FormatIntWidthN(int value, int width);

  // Formats an int value as "%X".
  static std::string FormatHexInt(int value);

  // Formats an int value as "%X".
  static std::string FormatHexUInt32(uint32_t value);

  // Formats a byte as "%02X".
  static std::string FormatByte(unsigned char value);

 private:
  String();  // Not meant to be instantiated.
};  // class String

// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
// character in the buffer is replaced with "\\0".
GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);

}  // namespace internal
}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {
namespace internal {

// FilePath - a class for file and directory pathname manipulation which
// handles platform-specific conventions (like the pathname separator).
// Used for helper functions for naming files in a directory for xml output.
// Except for Set methods, all methods are const or static, which provides an
// "immutable value object" -- useful for peace of mind.
// A FilePath with a value ending in a path separator ("like/this/") represents
// a directory, otherwise it is assumed to represent a file. In either case,
// it may or may not represent an actual file or directory in the file system.
// Names are NOT checked for syntax correctness -- no checking for illegal
// characters, malformed paths, etc.

class GTEST_API_ FilePath {
 public:
  FilePath() : pathname_("") { }
  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }

  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
    Normalize();
  }

  FilePath& operator=(const FilePath& rhs) {
    Set(rhs);
    return *this;
  }

  void Set(const FilePath& rhs) {
    pathname_ = rhs.pathname_;
  }

  const std::string& string() const { return pathname_; }
  const char* c_str() const { return pathname_.c_str(); }

  // Returns the current working directory, or "" if unsuccessful.
  static FilePath GetCurrentDir();

  // Given directory = "dir", base_name = "test", number = 0,
  // extension = "xml", returns "dir/test.xml". If number is greater
  // than zero (e.g., 12), returns "dir/test_12.xml".
  // On Windows platform, uses \ as the separator rather than /.
  static FilePath MakeFileName(const FilePath& directory,
                               const FilePath& base_name,
                               int number,
                               const char* extension);

  // Given directory = "dir", relative_path = "test.xml",
  // returns "dir/test.xml".
  // On Windows, uses \ as the separator rather than /.
  static FilePath ConcatPaths(const FilePath& directory,
                              const FilePath& relative_path);

  // Returns a pathname for a file that does not currently exist. The pathname
  // will be directory/base_name.extension or
  // directory/base_name_<number>.extension if directory/base_name.extension
  // already exists. The number will be incremented until a pathname is found
  // that does not already exist.
  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
  // There could be a race condition if two or more processes are calling this
  // function at the same time -- they could both pick the same filename.
  static FilePath GenerateUniqueFileName(const FilePath& directory,
                                         const FilePath& base_name,
                                         const char* extension);

  // Returns true if and only if the path is "".
  bool IsEmpty() const { return pathname_.empty(); }

  // If input name has a trailing separator character, removes it and returns
  // the name, otherwise return the name string unmodified.
  // On Windows platform, uses \ as the separator, other platforms use /.
  FilePath RemoveTrailingPathSeparator() const;

  // Returns a copy of the FilePath with the directory part removed.
  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
  // returns an empty FilePath ("").
  // On Windows platform, '\' is the path separator, otherwise it is '/'.
  FilePath RemoveDirectoryName() const;

  // RemoveFileName returns the directory path with the filename removed.
  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
  // On Windows platform, '\' is the path separator, otherwise it is '/'.
  FilePath RemoveFileName() const;

  // Returns a copy of the FilePath with the case-insensitive extension removed.
  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
  // FilePath("dir/file"). If a case-insensitive extension is not
  // found, returns a copy of the original FilePath.
  FilePath RemoveExtension(const char* extension) const;

  // Creates directories so that path exists. Returns true if successful or if
  // the directories already exist; returns false if unable to create
  // directories for any reason. Will also return false if the FilePath does
  // not represent a directory (that is, it doesn't end with a path separator).
  bool CreateDirectoriesRecursively() const;

  // Create the directory so that path exists. Returns true if successful or
  // if the directory already exists; returns false if unable to create the
  // directory for any reason, including if the parent directory does not
  // exist. Not named "CreateDirectory" because that's a macro on Windows.
  bool CreateFolder() const;

  // Returns true if FilePath describes something in the file-system,
  // either a file, directory, or whatever, and that something exists.
  bool FileOrDirectoryExists() const;

  // Returns true if pathname describes a directory in the file-system
  // that exists.
  bool DirectoryExists() const;

  // Returns true if FilePath ends with a path separator, which indicates that
  // it is intended to represent a directory. Returns false otherwise.
  // This does NOT check that a directory (or file) actually exists.
  bool IsDirectory() const;

  // Returns true if pathname describes a root directory. (Windows has one
  // root directory per disk drive.)
  bool IsRootDirectory() const;

  // Returns true if pathname describes an absolute path.
  bool IsAbsolutePath() const;

 private:
  // Replaces multiple consecutive separators with a single separator.
  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
  // redundancies that might be in a pathname involving "." or "..".
  //
  // A pathname with multiple consecutive separators may occur either through
  // user error or as a result of some scripts or APIs that generate a pathname
  // with a trailing separator. On other platforms the same API or script
  // may NOT generate a pathname with a trailing "/". Then elsewhere that
  // pathname may have another "/" and pathname components added to it,
  // without checking for the separator already being there.
  // The script language and operating system may allow paths like "foo//bar"
  // but some of the functions in FilePath will not handle that correctly. In
  // particular, RemoveTrailingPathSeparator() only removes one separator, and
  // it is called in CreateDirectoriesRecursively() assuming that it will change
  // a pathname from directory syntax (trailing separator) to filename syntax.
  //
  // On Windows this method also replaces the alternate path separator '/' with
  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
  // "bar\\foo".

  void Normalize();

  // Returns a pointer to the last occurrence of a valid path separator in
  // the FilePath. On Windows, for example, both '/' and '\' are valid path
  // separators. Returns NULL if no path separator was found.
  const char* FindLastPathSeparator() const;

  std::string pathname_;
};  // class FilePath

}  // namespace internal
}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Type utilities needed for implementing typed and type-parameterized
// tests.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_


// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
// libstdc++ (which is where cxxabi.h comes from).
# if GTEST_HAS_CXXABI_H_
#  include <cxxabi.h>
# elif defined(__HP_aCC)
#  include <acxx_demangle.h>
# endif  // GTEST_HASH_CXXABI_H_

namespace testing {
namespace internal {

// Canonicalizes a given name with respect to the Standard C++ Library.
// This handles removing the inline namespace within `std` that is
// used by various standard libraries (e.g., `std::__1`).  Names outside
// of namespace std are returned unmodified.
inline std::string CanonicalizeForStdLibVersioning(std::string s) {
  static const char prefix[] = "std::__";
  if (s.compare(0, strlen(prefix), prefix) == 0) {
    std::string::size_type end = s.find("::", strlen(prefix));
    if (end != s.npos) {
      // Erase everything between the initial `std` and the second `::`.
      s.erase(strlen("std"), end - strlen("std"));
    }
  }
  return s;
}

#if GTEST_HAS_RTTI
// GetTypeName(const std::type_info&) returns a human-readable name of type T.
inline std::string GetTypeName(const std::type_info& type) {
  const char* const name = type.name();
#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
  int status = 0;
  // gcc's implementation of typeid(T).name() mangles the type name,
  // so we have to demangle it.
#if GTEST_HAS_CXXABI_H_
  using abi::__cxa_demangle;
#endif  // GTEST_HAS_CXXABI_H_
  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
  const std::string name_str(status == 0 ? readable_name : name);
  free(readable_name);
  return CanonicalizeForStdLibVersioning(name_str);
#else
  return name;
#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
}
#endif  // GTEST_HAS_RTTI

// GetTypeName<T>() returns a human-readable name of type T if and only if
// RTTI is enabled, otherwise it returns a dummy type name.
// NB: This function is also used in Google Mock, so don't move it inside of
// the typed-test-only section below.
template <typename T>
std::string GetTypeName() {
#if GTEST_HAS_RTTI
  return GetTypeName(typeid(T));
#else
  return "<type>";
#endif  // GTEST_HAS_RTTI
}

// A unique type indicating an empty node
struct None {};

# define GTEST_TEMPLATE_ template <typename T> class

// The template "selector" struct TemplateSel<Tmpl> is used to
// represent Tmpl, which must be a class template with one type
// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
// as the type Tmpl<T>.  This allows us to actually instantiate the
// template "selected" by TemplateSel<Tmpl>.
//
// This trick is necessary for simulating typedef for class templates,
// which C++ doesn't support directly.
template <GTEST_TEMPLATE_ Tmpl>
struct TemplateSel {
  template <typename T>
  struct Bind {
    typedef Tmpl<T> type;
  };
};

# define GTEST_BIND_(TmplSel, T) \
  TmplSel::template Bind<T>::type

template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
struct Templates {
  using Head = TemplateSel<Head_>;
  using Tail = Templates<Tail_...>;
};

template <GTEST_TEMPLATE_ Head_>
struct Templates<Head_> {
  using Head = TemplateSel<Head_>;
  using Tail = None;
};

// Tuple-like type lists
template <typename Head_, typename... Tail_>
struct Types {
  using Head = Head_;
  using Tail = Types<Tail_...>;
};

template <typename Head_>
struct Types<Head_> {
  using Head = Head_;
  using Tail = None;
};

// Helper metafunctions to tell apart a single type from types
// generated by ::testing::Types
template <typename... Ts>
struct ProxyTypeList {
  using type = Types<Ts...>;
};

template <typename>
struct is_proxy_type_list : std::false_type {};

template <typename... Ts>
struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {};

// Generator which conditionally creates type lists.
// It recognizes if a requested type list should be created
// and prevents creating a new type list nested within another one.
template <typename T>
struct GenerateTypeList {
 private:
  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T,
                                          ProxyTypeList<T>>::type;

 public:
  using type = typename proxy::type;
};

}  // namespace internal

template <typename... Ts>
using Types = internal::ProxyTypeList<Ts...>;

}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

// Due to C++ preprocessor weirdness, we need double indirection to
// concatenate two tokens when one of them is __LINE__.  Writing
//
//   foo ## __LINE__
//
// will result in the token foo__LINE__, instead of foo followed by
// the current line number.  For more details, see
// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar

// Stringifies its argument.
// Work around a bug in visual studio which doesn't accept code like this:
//
//   #define GTEST_STRINGIFY_(name) #name
//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ...
//   MACRO(, x, y)
//
// Complaining about the argument to GTEST_STRINGIFY_ being empty.
// This is allowed by the spec.
#define GTEST_STRINGIFY_HELPER_(name, ...) #name
#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )

namespace proto2 {
class MessageLite;
}

namespace testing {

// Forward declarations.

class AssertionResult;                 // Result of an assertion.
class Message;                         // Represents a failure message.
class Test;                            // Represents a test.
class TestInfo;                        // Information about a test.
class TestPartResult;                  // Result of a test part.
class UnitTest;                        // A collection of test suites.

template <typename T>
::std::string PrintToString(const T& value);

namespace internal {

struct TraceInfo;                      // Information about a trace point.
class TestInfoImpl;                    // Opaque implementation of TestInfo
class UnitTestImpl;                    // Opaque implementation of UnitTest

// The text used in failure messages to indicate the start of the
// stack trace.
GTEST_API_ extern const char kStackTraceMarker[];

// An IgnoredValue object can be implicitly constructed from ANY value.
class IgnoredValue {
  struct Sink {};
 public:
  // This constructor template allows any value to be implicitly
  // converted to IgnoredValue.  The object has no data member and
  // doesn't try to remember anything about the argument.  We
  // deliberately omit the 'explicit' keyword in order to allow the
  // conversion to be implicit.
  // Disable the conversion if T already has a magical conversion operator.
  // Otherwise we get ambiguity.
  template <typename T,
            typename std::enable_if<!std::is_convertible<T, Sink>::value,
                                    int>::type = 0>
  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
};

// Appends the user-supplied message to the Google-Test-generated message.
GTEST_API_ std::string AppendUserMessage(
    const std::string& gtest_msg, const Message& user_msg);

#if GTEST_HAS_EXCEPTIONS

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
/* an exported class was derived from a class that was not exported */)

// This exception is thrown by (and only by) a failed Google Test
// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
// are enabled).  We derive it from std::runtime_error, which is for
// errors presumably detectable only at run time.  Since
// std::runtime_error inherits from std::exception, many testing
// frameworks know how to extract and print the message inside it.
class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
 public:
  explicit GoogleTestFailureException(const TestPartResult& failure);
};

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275

#endif  // GTEST_HAS_EXCEPTIONS

namespace edit_distance {
// Returns the optimal edits to go from 'left' to 'right'.
// All edits cost the same, with replace having lower priority than
// add/remove.
// Simple implementation of the Wagner-Fischer algorithm.
// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
enum EditType { kMatch, kAdd, kRemove, kReplace };
GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
    const std::vector<size_t>& left, const std::vector<size_t>& right);

// Same as above, but the input is represented as strings.
GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
    const std::vector<std::string>& left,
    const std::vector<std::string>& right);

// Create a diff of the input strings in Unified diff format.
GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
                                         const std::vector<std::string>& right,
                                         size_t context = 2);

}  // namespace edit_distance

// Calculate the diff between 'left' and 'right' and return it in unified diff
// format.
// If not null, stores in 'total_line_count' the total number of lines found
// in left + right.
GTEST_API_ std::string DiffStrings(const std::string& left,
                                   const std::string& right,
                                   size_t* total_line_count);

// Constructs and returns the message for an equality assertion
// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
//
// The first four parameters are the expressions used in the assertion
// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
// where foo is 5 and bar is 6, we have:
//
//   expected_expression: "foo"
//   actual_expression:   "bar"
//   expected_value:      "5"
//   actual_value:        "6"
//
// The ignoring_case parameter is true if and only if the assertion is a
// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
// be inserted into the message.
GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
                                     const char* actual_expression,
                                     const std::string& expected_value,
                                     const std::string& actual_value,
                                     bool ignoring_case);

// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
GTEST_API_ std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result,
    const char* expression_text,
    const char* actual_predicate_value,
    const char* expected_predicate_value);

// This template class represents an IEEE floating-point number
// (either single-precision or double-precision, depending on the
// template parameters).
//
// The purpose of this class is to do more sophisticated number
// comparison.  (Due to round-off error, etc, it's very unlikely that
// two floating-points will be equal exactly.  Hence a naive
// comparison by the == operation often doesn't work.)
//
// Format of IEEE floating-point:
//
//   The most-significant bit being the leftmost, an IEEE
//   floating-point looks like
//
//     sign_bit exponent_bits fraction_bits
//
//   Here, sign_bit is a single bit that designates the sign of the
//   number.
//
//   For float, there are 8 exponent bits and 23 fraction bits.
//
//   For double, there are 11 exponent bits and 52 fraction bits.
//
//   More details can be found at
//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
//
// Template parameter:
//
//   RawType: the raw floating-point type (either float or double)
template <typename RawType>
class FloatingPoint {
 public:
  // Defines the unsigned integer type that has the same size as the
  // floating point number.
  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;

  // Constants.

  // # of bits in a number.
  static const size_t kBitCount = 8*sizeof(RawType);

  // # of fraction bits in a number.
  static const size_t kFractionBitCount =
    std::numeric_limits<RawType>::digits - 1;

  // # of exponent bits in a number.
  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;

  // The mask for the sign bit.
  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);

  // The mask for the fraction bits.
  static const Bits kFractionBitMask =
    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);

  // The mask for the exponent bits.
  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);

  // How many ULP's (Units in the Last Place) we want to tolerate when
  // comparing two numbers.  The larger the value, the more error we
  // allow.  A 0 value means that two numbers must be exactly the same
  // to be considered equal.
  //
  // The maximum error of a single floating-point operation is 0.5
  // units in the last place.  On Intel CPU's, all floating-point
  // calculations are done with 80-bit precision, while double has 64
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
  static const uint32_t kMaxUlps = 4;

  // Constructs a FloatingPoint from a raw floating-point number.
  //
  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
  // around may change its bits, although the new value is guaranteed
  // to be also a NAN.  Therefore, don't expect this constructor to
  // preserve the bits in x when x is a NAN.
  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }

  // Static methods

  // Reinterprets a bit pattern as a floating-point number.
  //
  // This function is needed to test the AlmostEquals() method.
  static RawType ReinterpretBits(const Bits bits) {
    FloatingPoint fp(0);
    fp.u_.bits_ = bits;
    return fp.u_.value_;
  }

  // Returns the floating-point number that represent positive infinity.
  static RawType Infinity() {
    return ReinterpretBits(kExponentBitMask);
  }

  // Returns the maximum representable finite floating-point number.
  static RawType Max();

  // Non-static methods

  // Returns the bits that represents this number.
  const Bits &bits() const { return u_.bits_; }

  // Returns the exponent bits of this number.
  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }

  // Returns the fraction bits of this number.
  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }

  // Returns the sign bit of this number.
  Bits sign_bit() const { return kSignBitMask & u_.bits_; }

  // Returns true if and only if this is NAN (not a number).
  bool is_nan() const {
    // It's a NAN if the exponent bits are all ones and the fraction
    // bits are not entirely zeros.
    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
  }

  // Returns true if and only if this number is at most kMaxUlps ULP's away
  // from rhs.  In particular, this function:
  //
  //   - returns false if either number is (or both are) NAN.
  //   - treats really large numbers as almost equal to infinity.
  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
  bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

 private:
  // The data type used to store the actual floating-point number.
  union FloatingPointUnion {
    RawType value_;  // The raw floating-point number.
    Bits bits_;      // The bits that represent the number.
  };

  // Converts an integer from the sign-and-magnitude representation to
  // the biased representation.  More precisely, let N be 2 to the
  // power of (kBitCount - 1), an integer x is represented by the
  // unsigned number x + N.
  //
  // For instance,
  //
  //   -N + 1 (the most negative number representable using
  //          sign-and-magnitude) is represented by 1;
  //   0      is represented by N; and
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
  // Read http://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
    } else {
      // sam represents a positive number.
      return kSignBitMask | sam;
    }
  }

  // Given two numbers in the sign-and-magnitude representation,
  // returns the distance between them as an unsigned number.
  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
                                                     const Bits &sam2) {
    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  }

  FloatingPointUnion u_;
};

// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
// macro defined by <windows.h>.
template <>
inline float FloatingPoint<float>::Max() { return FLT_MAX; }
template <>
inline double FloatingPoint<double>::Max() { return DBL_MAX; }

// Typedefs the instances of the FloatingPoint template class that we
// care to use.
typedef FloatingPoint<float> Float;
typedef FloatingPoint<double> Double;

// In order to catch the mistake of putting tests that use different
// test fixture classes in the same test suite, we need to assign
// unique IDs to fixture classes and compare them.  The TypeId type is
// used to hold such IDs.  The user should treat TypeId as an opaque
// type: the only operation allowed on TypeId values is to compare
// them for equality using the == operator.
typedef const void* TypeId;

template <typename T>
class TypeIdHelper {
 public:
  // dummy_ must not have a const type.  Otherwise an overly eager
  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
  static bool dummy_;
};

template <typename T>
bool TypeIdHelper<T>::dummy_ = false;

// GetTypeId<T>() returns the ID of type T.  Different values will be
// returned for different types.  Calling the function twice with the
// same type argument is guaranteed to return the same ID.
template <typename T>
TypeId GetTypeId() {
  // The compiler is required to allocate a different
  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  // the template.  Therefore, the address of dummy_ is guaranteed to
  // be unique.
  return &(TypeIdHelper<T>::dummy_);
}

// Returns the type ID of ::testing::Test.  Always call this instead
// of GetTypeId< ::testing::Test>() to get the type ID of
// ::testing::Test, as the latter may give the wrong result due to a
// suspected linker bug when compiling Google Test as a Mac OS X
// framework.
GTEST_API_ TypeId GetTestTypeId();

// Defines the abstract factory interface that creates instances
// of a Test object.
class TestFactoryBase {
 public:
  virtual ~TestFactoryBase() {}

  // Creates a test instance to run. The instance is both created and destroyed
  // within TestInfoImpl::Run()
  virtual Test* CreateTest() = 0;

 protected:
  TestFactoryBase() {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
};

// This class provides implementation of TeastFactoryBase interface.
// It is used in TEST and TEST_F macros.
template <class TestClass>
class TestFactoryImpl : public TestFactoryBase {
 public:
  Test* CreateTest() override { return new TestClass; }
};

#if GTEST_OS_WINDOWS

// Predicate-formatters for implementing the HRESULT checking macros
// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
// We pass a long instead of HRESULT to avoid causing an
// include dependency for the HRESULT type.
GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
                                            long hr);  // NOLINT
GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
                                            long hr);  // NOLINT

#endif  // GTEST_OS_WINDOWS

// Types of SetUpTestSuite() and TearDownTestSuite() functions.
using SetUpTestSuiteFunc = void (*)();
using TearDownTestSuiteFunc = void (*)();

struct CodeLocation {
  CodeLocation(const std::string& a_file, int a_line)
      : file(a_file), line(a_line) {}

  std::string file;
  int line;
};

//  Helper to identify which setup function for TestCase / TestSuite to call.
//  Only one function is allowed, either TestCase or TestSute but not both.

// Utility functions to help SuiteApiResolver
using SetUpTearDownSuiteFuncType = void (*)();

inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
  return a == def ? nullptr : a;
}

template <typename T>
//  Note that SuiteApiResolver inherits from T because
//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
//  SuiteApiResolver can access them.
struct SuiteApiResolver : T {
  // testing::Test is only forward declared at this point. So we make it a
  // dependend class for the compiler to be OK with it.
  using Test =
      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;

  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
                                                        int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
           "make sure there is only one present at "
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
    (void)(filename);
    (void)(line_num);
    return &T::SetUpTestSuite;
#endif
  }

  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
                                                           int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
           " please make sure there is only one present at"
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
    (void)(filename);
    (void)(line_num);
    return &T::TearDownTestSuite;
#endif
  }
};

// Creates a new TestInfo object and registers it with Google Test;
// returns the created object.
//
// Arguments:
//
//   test_suite_name:  name of the test suite
//   name:             name of the test
//   type_param:       the name of the test's type parameter, or NULL if
//                     this is not a typed or a type-parameterized test.
//   value_param:      text representation of the test's value parameter,
//                     or NULL if this is not a type-parameterized test.
//   code_location:    code location where the test is defined
//   fixture_class_id: ID of the test fixture class
//   set_up_tc:        pointer to the function that sets up the test suite
//   tear_down_tc:     pointer to the function that tears down the test suite
//   factory:          pointer to the factory that creates a test object.
//                     The newly created TestInfo instance will assume
//                     ownership of the factory object.
GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
    const char* test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);

// If *pstr starts with the given prefix, modifies *pstr to be right
// past the prefix and returns true; otherwise leaves *pstr unchanged
// and returns false.  None of pstr, *pstr, and prefix can be NULL.
GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

// State of the definition of a type-parameterized test suite.
class GTEST_API_ TypedTestSuitePState {
 public:
  TypedTestSuitePState() : registered_(false) {}

  // Adds the given test name to defined_test_names_ and return true
  // if the test suite hasn't been registered; otherwise aborts the
  // program.
  bool AddTestName(const char* file, int line, const char* case_name,
                   const char* test_name) {
    if (registered_) {
      fprintf(stderr,
              "%s Test %s must be defined before "
              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
              FormatFileLocation(file, line).c_str(), test_name, case_name);
      fflush(stderr);
      posix::Abort();
    }
    registered_tests_.insert(
        ::std::make_pair(test_name, CodeLocation(file, line)));
    return true;
  }

  bool TestExists(const std::string& test_name) const {
    return registered_tests_.count(test_name) > 0;
  }

  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
    GTEST_CHECK_(it != registered_tests_.end());
    return it->second;
  }

  // Verifies that registered_tests match the test names in
  // defined_test_names_; returns registered_tests if successful, or
  // aborts the program otherwise.
  const char* VerifyRegisteredTestNames(const char* test_suite_name,
                                        const char* file, int line,
                                        const char* registered_tests);

 private:
  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;

  bool registered_;
  RegisteredTestsMap registered_tests_;
};

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
using TypedTestCasePState = TypedTestSuitePState;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// Skips to the first non-space char after the first comma in 'str';
// returns NULL if no comma is found in 'str'.
inline const char* SkipComma(const char* str) {
  const char* comma = strchr(str, ',');
  if (comma == nullptr) {
    return nullptr;
  }
  while (IsSpace(*(++comma))) {}
  return comma;
}

// Returns the prefix of 'str' before the first comma in it; returns
// the entire string if it contains no comma.
inline std::string GetPrefixUntilComma(const char* str) {
  const char* comma = strchr(str, ',');
  return comma == nullptr ? str : std::string(str, comma);
}

// Splits a given string on a given delimiter, populating a given
// vector with the fields.
void SplitString(const ::std::string& str, char delimiter,
                 ::std::vector< ::std::string>* dest);

// The default argument to the template below for the case when the user does
// not provide a name generator.
struct DefaultNameGenerator {
  template <typename T>
  static std::string GetName(int i) {
    return StreamableToString(i);
  }
};

template <typename Provided = DefaultNameGenerator>
struct NameGeneratorSelector {
  typedef Provided type;
};

template <typename NameGenerator>
void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}

template <typename NameGenerator, typename Types>
void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
                                          i + 1);
}

template <typename NameGenerator, typename Types>
std::vector<std::string> GenerateNames() {
  std::vector<std::string> result;
  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
  return result;
}

// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
// registers a list of type-parameterized tests with Google Test.  The
// return value is insignificant - we just need to return something
// such that we can call this function in a namespace scope.
//
// Implementation note: The GTEST_TEMPLATE_ macro declares a template
// template parameter.  It's defined in gtest-type-util.h.
template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
class TypeParameterizedTest {
 public:
  // 'index' is the index of the test in the type list 'Types'
  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
  // Types).  Valid values for 'index' are [0, N - 1] where N is the
  // length of Types.
  static bool Register(const char* prefix, const CodeLocation& code_location,
                       const char* case_name, const char* test_names, int index,
                       const std::vector<std::string>& type_names =
                           GenerateNames<DefaultNameGenerator, Types>()) {
    typedef typename Types::Head Type;
    typedef Fixture<Type> FixtureClass;
    typedef typename GTEST_BIND_(TestSel, Type) TestClass;

    // First, registers the first type-parameterized test in the type
    // list.
    MakeAndRegisterTestInfo(
        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
         "/" + type_names[static_cast<size_t>(index)])
            .c_str(),
        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
        GetTypeName<Type>().c_str(),
        nullptr,  // No value parameter.
        code_location, GetTypeId<FixtureClass>(),
        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
            code_location.file.c_str(), code_location.line),
        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
            code_location.file.c_str(), code_location.line),
        new TestFactoryImpl<TestClass>);

    // Next, recurses (at compile time) with the tail of the type list.
    return TypeParameterizedTest<Fixture, TestSel,
                                 typename Types::Tail>::Register(prefix,
                                                                 code_location,
                                                                 case_name,
                                                                 test_names,
                                                                 index + 1,
                                                                 type_names);
  }
};

// The base case for the compile time recursion.
template <GTEST_TEMPLATE_ Fixture, class TestSel>
class TypeParameterizedTest<Fixture, TestSel, internal::None> {
 public:
  static bool Register(const char* /*prefix*/, const CodeLocation&,
                       const char* /*case_name*/, const char* /*test_names*/,
                       int /*index*/,
                       const std::vector<std::string>& =
                           std::vector<std::string>() /*type_names*/) {
    return true;
  }
};

GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
                                                   CodeLocation code_location);
GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
    const char* case_name);

// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
// registers *all combinations* of 'Tests' and 'Types' with Google
// Test.  The return value is insignificant - we just need to return
// something such that we can call this function in a namespace scope.
template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
class TypeParameterizedTestSuite {
 public:
  static bool Register(const char* prefix, CodeLocation code_location,
                       const TypedTestSuitePState* state, const char* case_name,
                       const char* test_names,
                       const std::vector<std::string>& type_names =
                           GenerateNames<DefaultNameGenerator, Types>()) {
    RegisterTypeParameterizedTestSuiteInstantiation(case_name);
    std::string test_name = StripTrailingSpaces(
        GetPrefixUntilComma(test_names));
    if (!state->TestExists(test_name)) {
      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
              case_name, test_name.c_str(),
              FormatFileLocation(code_location.file.c_str(),
                                 code_location.line).c_str());
      fflush(stderr);
      posix::Abort();
    }
    const CodeLocation& test_location = state->GetCodeLocation(test_name);

    typedef typename Tests::Head Head;

    // First, register the first test in 'Test' for each type in 'Types'.
    TypeParameterizedTest<Fixture, Head, Types>::Register(
        prefix, test_location, case_name, test_names, 0, type_names);

    // Next, recurses (at compile time) with the tail of the test list.
    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
                                      Types>::Register(prefix, code_location,
                                                       state, case_name,
                                                       SkipComma(test_names),
                                                       type_names);
  }
};

// The base case for the compile time recursion.
template <GTEST_TEMPLATE_ Fixture, typename Types>
class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
 public:
  static bool Register(const char* /*prefix*/, const CodeLocation&,
                       const TypedTestSuitePState* /*state*/,
                       const char* /*case_name*/, const char* /*test_names*/,
                       const std::vector<std::string>& =
                           std::vector<std::string>() /*type_names*/) {
    return true;
  }
};

// Returns the current OS stack trace as an std::string.
//
// The maximum number of stack frames to be included is specified by
// the gtest_stack_trace_depth flag.  The skip_count parameter
// specifies the number of top frames to be skipped, which doesn't
// count against the number of frames to be included.
//
// For example, if Foo() calls Bar(), which in turn calls
// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
    UnitTest* unit_test, int skip_count);

// Helpers for suppressing warnings on unreachable code or constant
// condition.

// Always returns true.
GTEST_API_ bool AlwaysTrue();

// Always returns false.
inline bool AlwaysFalse() { return !AlwaysTrue(); }

// Helper for suppressing false warning from Clang on a const char*
// variable declared in a conditional expression always being NULL in
// the else branch.
struct GTEST_API_ ConstCharPtr {
  ConstCharPtr(const char* str) : value(str) {}
  operator bool() const { return true; }
  const char* value;
};

// Helper for declaring std::string within 'if' statement
// in pre C++17 build environment.
struct TrueWithString {
  TrueWithString() = default;
  explicit TrueWithString(const char* str) : value(str) {}
  explicit TrueWithString(const std::string& str) : value(str) {}
  explicit operator bool() const { return true; }
  std::string value;
};

// A simple Linear Congruential Generator for generating random
// numbers with a uniform distribution.  Unlike rand() and srand(), it
// doesn't use global state (and therefore can't interfere with user
// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
// but it's good enough for our purposes.
class GTEST_API_ Random {
 public:
  static const uint32_t kMaxRange = 1u << 31;

  explicit Random(uint32_t seed) : state_(seed) {}

  void Reseed(uint32_t seed) { state_ = seed; }

  // Generates a random number from [0, range).  Crashes if 'range' is
  // 0 or greater than kMaxRange.
  uint32_t Generate(uint32_t range);

 private:
  uint32_t state_;
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
};

// Turns const U&, U&, const U, and U all into U.
#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
  typename std::remove_const<typename std::remove_reference<T>::type>::type

// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant
// that's true if and only if T has methods DebugString() and ShortDebugString()
// that return std::string.
template <typename T>
class HasDebugStringAndShortDebugString {
 private:
  template <typename C>
  static auto CheckDebugString(C*) -> typename std::is_same<
      std::string, decltype(std::declval<const C>().DebugString())>::type;
  template <typename>
  static std::false_type CheckDebugString(...);

  template <typename C>
  static auto CheckShortDebugString(C*) -> typename std::is_same<
      std::string, decltype(std::declval<const C>().ShortDebugString())>::type;
  template <typename>
  static std::false_type CheckShortDebugString(...);

  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr));
  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr));

 public:
  static constexpr bool value =
      HasDebugStringType::value && HasShortDebugStringType::value;
};

template <typename T>
constexpr bool HasDebugStringAndShortDebugString<T>::value;

// When the compiler sees expression IsContainerTest<C>(0), if C is an
// STL-style container class, the first overload of IsContainerTest
// will be viable (since both C::iterator* and C::const_iterator* are
// valid types and NULL can be implicitly converted to them).  It will
// be picked over the second overload as 'int' is a perfect match for
// the type of argument 0.  If C::iterator or C::const_iterator is not
// a valid type, the first overload is not viable, and the second
// overload will be picked.  Therefore, we can determine whether C is
// a container class by checking the type of IsContainerTest<C>(0).
// The value of the expression is insignificant.
//
// In C++11 mode we check the existence of a const_iterator and that an
// iterator is properly implemented for the container.
//
// For pre-C++11 that we look for both C::iterator and C::const_iterator.
// The reason is that C++ injects the name of a class as a member of the
// class itself (e.g. you can refer to class iterator as either
// 'iterator' or 'iterator::iterator').  If we look for C::iterator
// only, for example, we would mistakenly think that a class named
// iterator is an STL container.
//
// Also note that the simpler approach of overloading
// IsContainerTest(typename C::const_iterator*) and
// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
typedef int IsContainer;
template <class C,
          class Iterator = decltype(::std::declval<const C&>().begin()),
          class = decltype(::std::declval<const C&>().end()),
          class = decltype(++::std::declval<Iterator&>()),
          class = decltype(*::std::declval<Iterator>()),
          class = typename C::const_iterator>
IsContainer IsContainerTest(int /* dummy */) {
  return 0;
}

typedef char IsNotContainer;
template <class C>
IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }

// Trait to detect whether a type T is a hash table.
// The heuristic used is that the type contains an inner type `hasher` and does
// not contain an inner type `reverse_iterator`.
// If the container is iterable in reverse, then order might actually matter.
template <typename T>
struct IsHashTable {
 private:
  template <typename U>
  static char test(typename U::hasher*, typename U::reverse_iterator*);
  template <typename U>
  static int test(typename U::hasher*, ...);
  template <typename U>
  static char test(...);

 public:
  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
};

template <typename T>
const bool IsHashTable<T>::value;

template <typename C,
          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
struct IsRecursiveContainerImpl;

template <typename C>
struct IsRecursiveContainerImpl<C, false> : public std::false_type {};

// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
// obey the same inconsistencies as the IsContainerTest, namely check if
// something is a container is relying on only const_iterator in C++11 and
// is relying on both const_iterator and iterator otherwise
template <typename C>
struct IsRecursiveContainerImpl<C, true> {
  using value_type = decltype(*std::declval<typename C::const_iterator>());
  using type =
      std::is_same<typename std::remove_const<
                       typename std::remove_reference<value_type>::type>::type,
                   C>;
};

// IsRecursiveContainer<Type> is a unary compile-time predicate that
// evaluates whether C is a recursive container type. A recursive container
// type is a container type whose value_type is equal to the container type
// itself. An example for a recursive container type is
// boost::filesystem::path, whose iterator has a value_type that is equal to
// boost::filesystem::path.
template <typename C>
struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};

// Utilities for native arrays.

// ArrayEq() compares two k-dimensional native arrays using the
// elements' operator==, where k can be any integer >= 0.  When k is
// 0, ArrayEq() degenerates into comparing a single pair of values.

template <typename T, typename U>
bool ArrayEq(const T* lhs, size_t size, const U* rhs);

// This generic version is used when k is 0.
template <typename T, typename U>
inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }

// This overload is used when k >= 1.
template <typename T, typename U, size_t N>
inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
  return internal::ArrayEq(lhs, N, rhs);
}

// This helper reduces code bloat.  If we instead put its logic inside
// the previous ArrayEq() function, arrays with different sizes would
// lead to different copies of the template code.
template <typename T, typename U>
bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
  for (size_t i = 0; i != size; i++) {
    if (!internal::ArrayEq(lhs[i], rhs[i]))
      return false;
  }
  return true;
}

// Finds the first element in the iterator range [begin, end) that
// equals elem.  Element may be a native array type itself.
template <typename Iter, typename Element>
Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
  for (Iter it = begin; it != end; ++it) {
    if (internal::ArrayEq(*it, elem))
      return it;
  }
  return end;
}

// CopyArray() copies a k-dimensional native array using the elements'
// operator=, where k can be any integer >= 0.  When k is 0,
// CopyArray() degenerates into copying a single value.

template <typename T, typename U>
void CopyArray(const T* from, size_t size, U* to);

// This generic version is used when k is 0.
template <typename T, typename U>
inline void CopyArray(const T& from, U* to) { *to = from; }

// This overload is used when k >= 1.
template <typename T, typename U, size_t N>
inline void CopyArray(const T(&from)[N], U(*to)[N]) {
  internal::CopyArray(from, N, *to);
}

// This helper reduces code bloat.  If we instead put its logic inside
// the previous CopyArray() function, arrays with different sizes
// would lead to different copies of the template code.
template <typename T, typename U>
void CopyArray(const T* from, size_t size, U* to) {
  for (size_t i = 0; i != size; i++) {
    internal::CopyArray(from[i], to + i);
  }
}

// The relation between an NativeArray object (see below) and the
// native array it represents.
// We use 2 different structs to allow non-copyable types to be used, as long
// as RelationToSourceReference() is passed.
struct RelationToSourceReference {};
struct RelationToSourceCopy {};

// Adapts a native array to a read-only STL-style container.  Instead
// of the complete STL container concept, this adaptor only implements
// members useful for Google Mock's container matchers.  New members
// should be added as needed.  To simplify the implementation, we only
// support Element being a raw type (i.e. having no top-level const or
// reference modifier).  It's the client's responsibility to satisfy
// this requirement.  Element can be an array type itself (hence
// multi-dimensional arrays are supported).
template <typename Element>
class NativeArray {
 public:
  // STL-style container typedefs.
  typedef Element value_type;
  typedef Element* iterator;
  typedef const Element* const_iterator;

  // Constructs from a native array. References the source.
  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
    InitRef(array, count);
  }

  // Constructs from a native array. Copies the source.
  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
    InitCopy(array, count);
  }

  // Copy constructor.
  NativeArray(const NativeArray& rhs) {
    (this->*rhs.clone_)(rhs.array_, rhs.size_);
  }

  ~NativeArray() {
    if (clone_ != &NativeArray::InitRef)
      delete[] array_;
  }

  // STL-style container methods.
  size_t size() const { return size_; }
  const_iterator begin() const { return array_; }
  const_iterator end() const { return array_ + size_; }
  bool operator==(const NativeArray& rhs) const {
    return size() == rhs.size() &&
        ArrayEq(begin(), size(), rhs.begin());
  }

 private:
  static_assert(!std::is_const<Element>::value, "Type must not be const");
  static_assert(!std::is_reference<Element>::value,
                "Type must not be a reference");

  // Initializes this object with a copy of the input.
  void InitCopy(const Element* array, size_t a_size) {
    Element* const copy = new Element[a_size];
    CopyArray(array, a_size, copy);
    array_ = copy;
    size_ = a_size;
    clone_ = &NativeArray::InitCopy;
  }

  // Initializes this object with a reference of the input.
  void InitRef(const Element* array, size_t a_size) {
    array_ = array;
    size_ = a_size;
    clone_ = &NativeArray::InitRef;
  }

  const Element* array_;
  size_t size_;
  void (NativeArray::*clone_)(const Element*, size_t);
};

// Backport of std::index_sequence.
template <size_t... Is>
struct IndexSequence {
  using type = IndexSequence;
};

// Double the IndexSequence, and one if plus_one is true.
template <bool plus_one, typename T, size_t sizeofT>
struct DoubleSequence;
template <size_t... I, size_t sizeofT>
struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
};
template <size_t... I, size_t sizeofT>
struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
  using type = IndexSequence<I..., (sizeofT + I)...>;
};

// Backport of std::make_index_sequence.
// It uses O(ln(N)) instantiation depth.
template <size_t N>
struct MakeIndexSequenceImpl
    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
                     N / 2>::type {};

template <>
struct MakeIndexSequenceImpl<0> : IndexSequence<> {};

template <size_t N>
using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;

template <typename... T>
using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;

template <size_t>
struct Ignore {
  Ignore(...);  // NOLINT
};

template <typename>
struct ElemFromListImpl;
template <size_t... I>
struct ElemFromListImpl<IndexSequence<I...>> {
  // We make Ignore a template to solve a problem with MSVC.
  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
  // MSVC doesn't understand how to deal with that pack expansion.
  // Use `0 * I` to have a single instantiation of Ignore.
  template <typename R>
  static R Apply(Ignore<0 * I>..., R (*)(), ...);
};

template <size_t N, typename... T>
struct ElemFromList {
  using type =
      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
          static_cast<T (*)()>(nullptr)...));
};

struct FlatTupleConstructTag {};

template <typename... T>
class FlatTuple;

template <typename Derived, size_t I>
struct FlatTupleElemBase;

template <typename... T, size_t I>
struct FlatTupleElemBase<FlatTuple<T...>, I> {
  using value_type = typename ElemFromList<I, T...>::type;
  FlatTupleElemBase() = default;
  template <typename Arg>
  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t)
      : value(std::forward<Arg>(t)) {}
  value_type value;
};

template <typename Derived, typename Idx>
struct FlatTupleBase;

template <size_t... Idx, typename... T>
struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
  using Indices = IndexSequence<Idx...>;
  FlatTupleBase() = default;
  template <typename... Args>
  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{},
                                                std::forward<Args>(args))... {}

  template <size_t I>
  const typename ElemFromList<I, T...>::type& Get() const {
    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
  }

  template <size_t I>
  typename ElemFromList<I, T...>::type& Get() {
    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
  }

  template <typename F>
  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
    return std::forward<F>(f)(Get<Idx>()...);
  }

  template <typename F>
  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
    return std::forward<F>(f)(Get<Idx>()...);
  }
};

// Analog to std::tuple but with different tradeoffs.
// This class minimizes the template instantiation depth, thus allowing more
// elements than std::tuple would. std::tuple has been seen to require an
// instantiation depth of more than 10x the number of elements in some
// implementations.
// FlatTuple and ElemFromList are not recursive and have a fixed depth
// regardless of T...
// MakeIndexSequence, on the other hand, it is recursive but with an
// instantiation depth of O(ln(N)).
template <typename... T>
class FlatTuple
    : private FlatTupleBase<FlatTuple<T...>,
                            typename MakeIndexSequence<sizeof...(T)>::type> {
  using Indices = typename FlatTupleBase<
      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;

 public:
  FlatTuple() = default;
  template <typename... Args>
  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}

  using FlatTuple::FlatTupleBase::Apply;
  using FlatTuple::FlatTupleBase::Get;
};

// Utility functions to be called with static_assert to induce deprecation
// warnings.
GTEST_INTERNAL_DEPRECATED(
    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
    "INSTANTIATE_TEST_SUITE_P")
constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }

GTEST_INTERNAL_DEPRECATED(
    "TYPED_TEST_CASE_P is deprecated, please use "
    "TYPED_TEST_SUITE_P")
constexpr bool TypedTestCase_P_IsDeprecated() { return true; }

GTEST_INTERNAL_DEPRECATED(
    "TYPED_TEST_CASE is deprecated, please use "
    "TYPED_TEST_SUITE")
constexpr bool TypedTestCaseIsDeprecated() { return true; }

GTEST_INTERNAL_DEPRECATED(
    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
    "REGISTER_TYPED_TEST_SUITE_P")
constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }

GTEST_INTERNAL_DEPRECATED(
    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
    "INSTANTIATE_TYPED_TEST_SUITE_P")
constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }

}  // namespace internal
}  // namespace testing

namespace std {
// Some standard library implementations use `struct tuple_size` and some use
// `class tuple_size`. Clang warns about the mismatch.
// https://reviews.llvm.org/D55466
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
template <typename... Ts>
struct tuple_size<testing::internal::FlatTuple<Ts...>>
    : std::integral_constant<size_t, sizeof...(Ts)> {};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
}  // namespace std

#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
  ::testing::internal::AssertHelper(result_type, file, line, message) \
    = ::testing::Message()

#define GTEST_MESSAGE_(message, result_type) \
  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

#define GTEST_FATAL_FAILURE_(message) \
  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)

#define GTEST_NONFATAL_FAILURE_(message) \
  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)

#define GTEST_SUCCESS_(message) \
  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)

#define GTEST_SKIP_(message) \
  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)

// Suppress MSVC warning 4072 (unreachable code) for the code following
// statement if it returns or throws (or doesn't return or throw in some
// situations).
// NOTE: The "else" is important to keep this expansion to prevent a top-level
// "else" from attaching to our "if".
#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
  if (::testing::internal::AlwaysTrue()) {                        \
    statement;                                                    \
  } else                     /* NOLINT */                         \
    static_assert(true, "")  // User must have a semicolon after expansion.

#if GTEST_HAS_EXCEPTIONS

namespace testing {
namespace internal {

class NeverThrown {
 public:
  const char* what() const noexcept {
    return "this exception should never be thrown";
  }
};

}  // namespace internal
}  // namespace testing

#if GTEST_HAS_RTTI

#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))

#else  // GTEST_HAS_RTTI

#define GTEST_EXCEPTION_TYPE_(e) \
  std::string { "an std::exception-derived error" }

#endif  // GTEST_HAS_RTTI

#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \
  catch (typename std::conditional<                                            \
         std::is_same<typename std::remove_cv<typename std::remove_reference<  \
                          expected_exception>::type>::type,                    \
                      std::exception>::value,                                  \
         const ::testing::internal::NeverThrown&, const std::exception&>::type \
             e) {                                                              \
    gtest_msg.value = "Expected: " #statement                                  \
                      " throws an exception of type " #expected_exception      \
                      ".\n  Actual: it throws ";                               \
    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \
    gtest_msg.value += " with description \"";                                 \
    gtest_msg.value += e.what();                                               \
    gtest_msg.value += "\".";                                                  \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \
  }

#else  // GTEST_HAS_EXCEPTIONS

#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)

#endif  // GTEST_HAS_EXCEPTIONS

#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
  if (::testing::internal::TrueWithString gtest_msg{}) {                    \
    bool gtest_caught_expected = false;                                     \
    try {                                                                   \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \
    } catch (expected_exception const&) {                                   \
      gtest_caught_expected = true;                                         \
    }                                                                       \
    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \
    catch (...) {                                                           \
      gtest_msg.value = "Expected: " #statement                             \
                        " throws an exception of type " #expected_exception \
                        ".\n  Actual: it throws a different type.";         \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
    }                                                                       \
    if (!gtest_caught_expected) {                                           \
      gtest_msg.value = "Expected: " #statement                             \
                        " throws an exception of type " #expected_exception \
                        ".\n  Actual: it throws nothing.";                  \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
    }                                                                       \
  } else /*NOLINT*/                                                         \
    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \
        : fail(gtest_msg.value.c_str())

#if GTEST_HAS_EXCEPTIONS

#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \
  catch (std::exception const& e) {                               \
    gtest_msg.value = "it throws ";                               \
    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \
    gtest_msg.value += " with description \"";                    \
    gtest_msg.value += e.what();                                  \
    gtest_msg.value += "\".";                                     \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
  }

#else  // GTEST_HAS_EXCEPTIONS

#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()

#endif  // GTEST_HAS_EXCEPTIONS

#define GTEST_TEST_NO_THROW_(statement, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (::testing::internal::TrueWithString gtest_msg{}) { \
    try { \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
    } \
    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
    catch (...) { \
      gtest_msg.value = "it throws."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
    } \
  } else \
    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
      fail(("Expected: " #statement " doesn't throw an exception.\n" \
            "  Actual: " + gtest_msg.value).c_str())

#define GTEST_TEST_ANY_THROW_(statement, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (::testing::internal::AlwaysTrue()) { \
    bool gtest_caught_any = false; \
    try { \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
    } \
    catch (...) { \
      gtest_caught_any = true; \
    } \
    if (!gtest_caught_any) { \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
    } \
  } else \
    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
      fail("Expected: " #statement " throws an exception.\n" \
           "  Actual: it doesn't.")


// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
// either a boolean expression or an AssertionResult. text is a textual
// representation of expression as it was passed into the EXPECT_TRUE.
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (const ::testing::AssertionResult gtest_ar_ = \
      ::testing::AssertionResult(expression)) \
    ; \
  else \
    fail(::testing::internal::GetBoolAssertionFailureMessage(\
        gtest_ar_, text, #actual, #expected).c_str())

#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (::testing::internal::AlwaysTrue()) { \
    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
    } \
  } else \
    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
      fail("Expected: " #statement " doesn't generate new fatal " \
           "failures in the current thread.\n" \
           "  Actual: it does.")

// Expands to the name of the class that implements the given test.
#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
  test_suite_name##_##test_name##_Test

// Helper macro for defining tests.
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
                "test_suite_name must not be empty");                         \
  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
                "test_name must not be empty");                               \
  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
      : public parent_class {                                                 \
   public:                                                                    \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
                                                           test_name));       \
    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
                                                           test_name));       \
                                                                              \
   private:                                                                   \
    void TestBody() override;                                                 \
    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
  };                                                                          \
                                                                              \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
                                                    test_name)::test_info_ =  \
      ::testing::internal::MakeAndRegisterTestInfo(                           \
          #test_suite_name, #test_name, nullptr, nullptr,                     \
          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
          ::testing::internal::SuiteApiResolver<                              \
              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
          ::testing::internal::SuiteApiResolver<                              \
              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
              test_suite_name, test_name)>);                                  \
  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file defines the public API for death tests.  It is
// #included by gtest.h so a user doesn't need to include this
// directly.
// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The Google C++ Testing and Mocking Framework (Google Test)
//
// This header file defines internal utilities needed for implementing
// death tests.  They are subject to change without notice.
// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The Google C++ Testing and Mocking Framework (Google Test)
//
// This file implements just enough of the matcher interface to allow
// EXPECT_DEATH and friends to accept a matcher argument.

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

#include <atomic>
#include <memory>
#include <ostream>
#include <string>
#include <type_traits>

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Google Test - The Google C++ Testing and Mocking Framework
//
// This file implements a universal value printer that can print a
// value of any type T:
//
//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
//
// A user can teach this function how to print a class type T by
// defining either operator<<() or PrintTo() in the namespace that
// defines T.  More specifically, the FIRST defined function in the
// following list will be used (assuming T is defined in namespace
// foo):
//
//   1. foo::PrintTo(const T&, ostream*)
//   2. operator<<(ostream&, const T&) defined in either foo or the
//      global namespace.
//
// However if T is an STL-style container then it is printed element-wise
// unless foo::PrintTo(const T&, ostream*) is defined. Note that
// operator<<() is ignored for container types.
//
// If none of the above is defined, it will print the debug string of
// the value if it is a protocol buffer, or print the raw bytes in the
// value otherwise.
//
// To aid debugging: when T is a reference type, the address of the
// value is also printed; when T is a (const) char pointer, both the
// pointer value and the NUL-terminated string it points to are
// printed.
//
// We also provide some convenient wrappers:
//
//   // Prints a value to a string.  For a (const or not) char
//   // pointer, the NUL-terminated string (but not the pointer) is
//   // printed.
//   std::string ::testing::PrintToString(const T& value);
//
//   // Prints a value tersely: for a reference type, the referenced
//   // value (but not the address) is printed; for a (const or not) char
//   // pointer, the NUL-terminated string (but not the pointer) is
//   // printed.
//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
//
//   // Prints value using the type inferred by the compiler.  The difference
//   // from UniversalTersePrint() is that this function prints both the
//   // pointer and the NUL-terminated string for a (const or not) char pointer.
//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
//
//   // Prints the fields of a tuple tersely to a string vector, one
//   // element for each field. Tuple support must be enabled in
//   // gtest-port.h.
//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
//       const Tuple& value);
//
// Known limitation:
//
// The print primitives print the elements of an STL-style container
// using the compiler-inferred type of *iter where iter is a
// const_iterator of the container.  When const_iterator is an input
// iterator but not a forward iterator, this inferred type may not
// match value_type, and the print output may be incorrect.  In
// practice, this is rarely a problem as for most containers
// const_iterator is a forward iterator.  We'll fix this if there's an
// actual need for it.  Note that this fix cannot rely on value_type
// being defined as many user-defined container types don't have
// value_type.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

#include <functional>
#include <memory>
#include <ostream>  // NOLINT
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>


#if GTEST_HAS_RTTI
#include <typeindex>
#include <typeinfo>
#endif  // GTEST_HAS_RTTI

namespace testing {

// Definitions in the internal* namespaces are subject to change without notice.
// DO NOT USE THEM IN USER CODE!
namespace internal {

template <typename T>
void UniversalPrint(const T& value, ::std::ostream* os);

// Used to print an STL-style container when the user doesn't define
// a PrintTo() for it.
struct ContainerPrinter {
  template <typename T,
            typename = typename std::enable_if<
                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
                !IsRecursiveContainer<T>::value>::type>
  static void PrintValue(const T& container, std::ostream* os) {
    const size_t kMaxCount = 32;  // The maximum number of elements to print.
    *os << '{';
    size_t count = 0;
    for (auto&& elem : container) {
      if (count > 0) {
        *os << ',';
        if (count == kMaxCount) {  // Enough has been printed.
          *os << " ...";
          break;
        }
      }
      *os << ' ';
      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
      // handle `elem` being a native array.
      internal::UniversalPrint(elem, os);
      ++count;
    }

    if (count > 0) {
      *os << ' ';
    }
    *os << '}';
  }
};

// Used to print a pointer that is neither a char pointer nor a member
// pointer, when the user doesn't define PrintTo() for it.  (A member
// variable pointer or member function pointer doesn't really point to
// a location in the address space.  Their representation is
// implementation-defined.  Therefore they will be printed as raw
// bytes.)
struct FunctionPointerPrinter {
  template <typename T, typename = typename std::enable_if<
                            std::is_function<T>::value>::type>
  static void PrintValue(T* p, ::std::ostream* os) {
    if (p == nullptr) {
      *os << "NULL";
    } else {
      // T is a function type, so '*os << p' doesn't do what we want
      // (it just prints p as bool).  We want to print p as a const
      // void*.
      *os << reinterpret_cast<const void*>(p);
    }
  }
};

struct PointerPrinter {
  template <typename T>
  static void PrintValue(T* p, ::std::ostream* os) {
    if (p == nullptr) {
      *os << "NULL";
    } else {
      // T is not a function type.  We just call << to print p,
      // relying on ADL to pick up user-defined << for their pointer
      // types, if any.
      *os << p;
    }
  }
};

namespace internal_stream_operator_without_lexical_name_lookup {

// The presence of an operator<< here will terminate lexical scope lookup
// straight away (even though it cannot be a match because of its argument
// types). Thus, the two operator<< calls in StreamPrinter will find only ADL
// candidates.
struct LookupBlocker {};
void operator<<(LookupBlocker, LookupBlocker);

struct StreamPrinter {
  template <typename T,
            // Don't accept member pointers here. We'd print them via implicit
            // conversion to bool, which isn't useful.
            typename = typename std::enable_if<
                !std::is_member_pointer<T>::value>::type,
            // Only accept types for which we can find a streaming operator via
            // ADL (possibly involving implicit conversions).
            typename = decltype(std::declval<std::ostream&>()
                                << std::declval<const T&>())>
  static void PrintValue(const T& value, ::std::ostream* os) {
    // Call streaming operator found by ADL, possibly with implicit conversions
    // of the arguments.
    *os << value;
  }
};

}  // namespace internal_stream_operator_without_lexical_name_lookup

struct ProtobufPrinter {
  // We print a protobuf using its ShortDebugString() when the string
  // doesn't exceed this many characters; otherwise we print it using
  // DebugString() for better readability.
  static const size_t kProtobufOneLinerMaxLength = 50;

  template <typename T,
            typename = typename std::enable_if<
                internal::HasDebugStringAndShortDebugString<T>::value>::type>
  static void PrintValue(const T& value, ::std::ostream* os) {
    std::string pretty_str = value.ShortDebugString();
    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
      pretty_str = "\n" + value.DebugString();
    }
    *os << ("<" + pretty_str + ">");
  }
};

struct ConvertibleToIntegerPrinter {
  // Since T has no << operator or PrintTo() but can be implicitly
  // converted to BiggestInt, we print it as a BiggestInt.
  //
  // Most likely T is an enum type (either named or unnamed), in which
  // case printing it as an integer is the desired behavior.  In case
  // T is not an enum, printing it as an integer is the best we can do
  // given that it has no user-defined printer.
  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
    *os << value;
  }
};

struct ConvertibleToStringViewPrinter {
#if GTEST_INTERNAL_HAS_STRING_VIEW
  static void PrintValue(internal::StringView value, ::std::ostream* os) {
    internal::UniversalPrint(value, os);
  }
#endif
};


// Prints the given number of bytes in the given object to the given
// ostream.
GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
                                     size_t count,
                                     ::std::ostream* os);
struct RawBytesPrinter {
  // SFINAE on `sizeof` to make sure we have a complete type.
  template <typename T, size_t = sizeof(T)>
  static void PrintValue(const T& value, ::std::ostream* os) {
    PrintBytesInObjectTo(
        static_cast<const unsigned char*>(
            // Load bearing cast to void* to support iOS
            reinterpret_cast<const void*>(std::addressof(value))),
        sizeof(value), os);
  }
};

struct FallbackPrinter {
  template <typename T>
  static void PrintValue(const T&, ::std::ostream* os) {
    *os << "(incomplete type)";
  }
};

// Try every printer in order and return the first one that works.
template <typename T, typename E, typename Printer, typename... Printers>
struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};

template <typename T, typename Printer, typename... Printers>
struct FindFirstPrinter<
    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
    Printer, Printers...> {
  using type = Printer;
};

// Select the best printer in the following order:
//  - Print containers (they have begin/end/etc).
//  - Print function pointers.
//  - Print object pointers.
//  - Use the stream operator, if available.
//  - Print protocol buffers.
//  - Print types convertible to BiggestInt.
//  - Print types convertible to StringView, if available.
//  - Fallback to printing the raw bytes of the object.
template <typename T>
void PrintWithFallback(const T& value, ::std::ostream* os) {
  using Printer = typename FindFirstPrinter<
      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
      ProtobufPrinter, ConvertibleToIntegerPrinter,
      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
  Printer::PrintValue(value, os);
}

// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
// value of type ToPrint that is an operand of a comparison assertion
// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
// the comparison, and is used to help determine the best way to
// format the value.  In particular, when the value is a C string
// (char pointer) and the other operand is an STL string object, we
// want to format the C string as a string, since we know it is
// compared by value with the string object.  If the value is a char
// pointer but the other operand is not an STL string object, we don't
// know whether the pointer is supposed to point to a NUL-terminated
// string, and thus want to print it as a pointer to be safe.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

// The default case.
template <typename ToPrint, typename OtherOperand>
class FormatForComparison {
 public:
  static ::std::string Format(const ToPrint& value) {
    return ::testing::PrintToString(value);
  }
};

// Array.
template <typename ToPrint, size_t N, typename OtherOperand>
class FormatForComparison<ToPrint[N], OtherOperand> {
 public:
  static ::std::string Format(const ToPrint* value) {
    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
  }
};

// By default, print C string as pointers to be safe, as we don't know
// whether they actually point to a NUL-terminated string.

#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
  template <typename OtherOperand>                                      \
  class FormatForComparison<CharType*, OtherOperand> {                  \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(static_cast<const void*>(value)); \
    }                                                                   \
  }

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
#ifdef __cpp_char8_t
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
#endif
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);

#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

// If a C string is compared with an STL string object, we know it's meant
// to point to a NUL-terminated string, and thus can print it as a string.

#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
  template <>                                                           \
  class FormatForComparison<CharType*, OtherStringType> {               \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(value);                           \
    }                                                                   \
  }

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
#ifdef __cpp_char8_t
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
#endif
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);

#if GTEST_HAS_STD_WSTRING
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
#endif

#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_

// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
// operand to be used in a failure message.  The type (but not value)
// of the other operand may affect the format.  This allows us to
// print a char* as a raw pointer when it is compared against another
// char* or void*, and print it as a C string when it is compared
// against an std::string object, for example.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename T1, typename T2>
std::string FormatForComparisonFailureMessage(
    const T1& value, const T2& /* other_operand */) {
  return FormatForComparison<T1, T2>::Format(value);
}

// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
// value to the given ostream.  The caller must ensure that
// 'ostream_ptr' is not NULL, or the behavior is undefined.
//
// We define UniversalPrinter as a class template (as opposed to a
// function template), as we need to partially specialize it for
// reference types, which cannot be done with function templates.
template <typename T>
class UniversalPrinter;

// Prints the given value using the << operator if it has one;
// otherwise prints the bytes in it.  This is what
// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
// or overloaded for type T.
//
// A user can override this behavior for a class type Foo by defining
// an overload of PrintTo() in the namespace where Foo is defined.  We
// give the user this option as sometimes defining a << operator for
// Foo is not desirable (e.g. the coding style may prevent doing it,
// or there is already a << operator but it doesn't do what the user
// wants).
template <typename T>
void PrintTo(const T& value, ::std::ostream* os) {
  internal::PrintWithFallback(value, os);
}

// The following list of PrintTo() overloads tells
// UniversalPrinter<T>::Print() how to print standard types (built-in
// types, strings, plain arrays, and pointers).

// Overloads for various char types.
GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
inline void PrintTo(char c, ::std::ostream* os) {
  // When printing a plain char, we always treat it as unsigned.  This
  // way, the output won't be affected by whether the compiler thinks
  // char is signed or not.
  PrintTo(static_cast<unsigned char>(c), os);
}

// Overloads for other simple built-in types.
inline void PrintTo(bool x, ::std::ostream* os) {
  *os << (x ? "true" : "false");
}

// Overload for wchar_t type.
// Prints a wchar_t as a symbol if it is printable or as its internal
// code otherwise and also as its decimal code (except for L'\0').
// The L'\0' char is printed as "L'\\0'". The decimal code is printed
// as signed integer when wchar_t is implemented by the compiler
// as a signed type and is printed as an unsigned integer when wchar_t
// is implemented as an unsigned type.
GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);

GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
inline void PrintTo(char16_t c, ::std::ostream* os) {
  PrintTo(ImplicitCast_<char32_t>(c), os);
}
#ifdef __cpp_char8_t
inline void PrintTo(char8_t c, ::std::ostream* os) {
  PrintTo(ImplicitCast_<char32_t>(c), os);
}
#endif

// Overloads for C strings.
GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
inline void PrintTo(char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const char*>(s), os);
}

// signed/unsigned char is often used for representing binary data, so
// we print pointers to it as void* to be safe.
inline void PrintTo(const signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
#ifdef __cpp_char8_t
// Overloads for u8 strings.
void PrintTo(const char8_t* s, ::std::ostream* os);
inline void PrintTo(char8_t* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const char8_t*>(s), os);
}
#endif
// Overloads for u16 strings.
void PrintTo(const char16_t* s, ::std::ostream* os);
inline void PrintTo(char16_t* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const char16_t*>(s), os);
}
// Overloads for u32 strings.
void PrintTo(const char32_t* s, ::std::ostream* os);
inline void PrintTo(char32_t* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const char32_t*>(s), os);
}

// MSVC can be configured to define wchar_t as a typedef of unsigned
// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
// type.  When wchar_t is a typedef, defining an overload for const
// wchar_t* would cause unsigned short* be printed as a wide string,
// possibly causing invalid memory accesses.
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
// Overloads for wide C strings
GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
inline void PrintTo(wchar_t* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
}
#endif

// Overload for C arrays.  Multi-dimensional arrays are printed
// properly.

// Prints the given number of elements in an array, without printing
// the curly braces.
template <typename T>
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
  UniversalPrint(a[0], os);
  for (size_t i = 1; i != count; i++) {
    *os << ", ";
    UniversalPrint(a[i], os);
  }
}

// Overloads for ::std::string.
GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
  PrintStringTo(s, os);
}

// Overloads for ::std::u8string
#ifdef __cpp_char8_t
GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
  PrintU8StringTo(s, os);
}
#endif

// Overloads for ::std::u16string
GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
  PrintU16StringTo(s, os);
}

// Overloads for ::std::u32string
GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
  PrintU32StringTo(s, os);
}

// Overloads for ::std::wstring.
#if GTEST_HAS_STD_WSTRING
GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
  PrintWideStringTo(s, os);
}
#endif  // GTEST_HAS_STD_WSTRING

#if GTEST_INTERNAL_HAS_STRING_VIEW
// Overload for internal::StringView.
inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
  PrintTo(::std::string(sp), os);
}
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }

template <typename T>
void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
  UniversalPrinter<T&>::Print(ref.get(), os);
}

inline const void* VoidifyPointer(const void* p) { return p; }
inline const void* VoidifyPointer(volatile const void* p) {
  return const_cast<const void*>(p);
}

template <typename T, typename Ptr>
void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
  if (ptr == nullptr) {
    *os << "(nullptr)";
  } else {
    // We can't print the value. Just print the pointer..
    *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
  }
}
template <typename T, typename Ptr,
          typename = typename std::enable_if<!std::is_void<T>::value &&
                                             !std::is_array<T>::value>::type>
void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
  if (ptr == nullptr) {
    *os << "(nullptr)";
  } else {
    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
    UniversalPrinter<T>::Print(*ptr, os);
    *os << ")";
  }
}

template <typename T, typename D>
void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
  (PrintSmartPointer<T>)(ptr, os, 0);
}

template <typename T>
void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
  (PrintSmartPointer<T>)(ptr, os, 0);
}

// Helper function for printing a tuple.  T must be instantiated with
// a tuple type.
template <typename T>
void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
                  ::std::ostream*) {}

template <typename T, size_t I>
void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
                  ::std::ostream* os) {
  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
  if (I > 1) {
    GTEST_INTENTIONAL_CONST_COND_POP_()
    *os << ", ";
  }
  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
      std::get<I - 1>(t), os);
}

template <typename... Types>
void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
  *os << "(";
  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
  *os << ")";
}

// Overload for std::pair.
template <typename T1, typename T2>
void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
  *os << '(';
  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
  // a reference type.  The same for printing value.second.
  UniversalPrinter<T1>::Print(value.first, os);
  *os << ", ";
  UniversalPrinter<T2>::Print(value.second, os);
  *os << ')';
}

#if GTEST_HAS_RTTI
inline void PrintTo(const ::std::type_info& value, ::std::ostream* os) {
  internal::PrintTo<::std::type_info>(value, os);
  *os << " (\"" << value.name() << "\")";
}

inline void PrintTo(const ::std::type_index& value, ::std::ostream* os) {
  internal::PrintTo<::std::type_index>(value, os);
  *os << " (\"" << value.name() << "\")";
}
#endif  // GTEST_HAS_RTTI

// Implements printing a non-reference type T by letting the compiler
// pick the right overload of PrintTo() for T.
template <typename T>
class UniversalPrinter {
 public:
  // MSVC warns about adding const to a function type, so we want to
  // disable the warning.
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)

  // Note: we deliberately don't call this PrintTo(), as that name
  // conflicts with ::testing::internal::PrintTo in the body of the
  // function.
  static void Print(const T& value, ::std::ostream* os) {
    // By default, ::testing::internal::PrintTo() is used for printing
    // the value.
    //
    // Thanks to Koenig look-up, if T is a class and has its own
    // PrintTo() function defined in its namespace, that function will
    // be visible here.  Since it is more specific than the generic ones
    // in ::testing::internal, it will be picked by the compiler in the
    // following statement - exactly what we want.
    PrintTo(value, os);
  }

  GTEST_DISABLE_MSC_WARNINGS_POP_()
};

// Remove any const-qualifiers before passing a type to UniversalPrinter.
template <typename T>
class UniversalPrinter<const T> : public UniversalPrinter<T> {};

#if GTEST_INTERNAL_HAS_ANY

// Printer for std::any / absl::any

template <>
class UniversalPrinter<Any> {
 public:
  static void Print(const Any& value, ::std::ostream* os) {
    if (value.has_value()) {
      *os << "value of type " << GetTypeName(value);
    } else {
      *os << "no value";
    }
  }

 private:
  static std::string GetTypeName(const Any& value) {
#if GTEST_HAS_RTTI
    return internal::GetTypeName(value.type());
#else
    static_cast<void>(value);  // possibly unused
    return "<unknown_type>";
#endif  // GTEST_HAS_RTTI
  }
};

#endif  // GTEST_INTERNAL_HAS_ANY

#if GTEST_INTERNAL_HAS_OPTIONAL

// Printer for std::optional / absl::optional

template <typename T>
class UniversalPrinter<Optional<T>> {
 public:
  static void Print(const Optional<T>& value, ::std::ostream* os) {
    *os << '(';
    if (!value) {
      *os << "nullopt";
    } else {
      UniversalPrint(*value, os);
    }
    *os << ')';
  }
};

#endif  // GTEST_INTERNAL_HAS_OPTIONAL

#if GTEST_INTERNAL_HAS_VARIANT

// Printer for std::variant / absl::variant

template <typename... T>
class UniversalPrinter<Variant<T...>> {
 public:
  static void Print(const Variant<T...>& value, ::std::ostream* os) {
    *os << '(';
#if GTEST_HAS_ABSL
    absl::visit(Visitor{os, value.index()}, value);
#else
    std::visit(Visitor{os, value.index()}, value);
#endif  // GTEST_HAS_ABSL
    *os << ')';
  }

 private:
  struct Visitor {
    template <typename U>
    void operator()(const U& u) const {
      *os << "'" << GetTypeName<U>() << "(index = " << index
          << ")' with value ";
      UniversalPrint(u, os);
    }
    ::std::ostream* os;
    std::size_t index;
  };
};

#endif  // GTEST_INTERNAL_HAS_VARIANT

// UniversalPrintArray(begin, len, os) prints an array of 'len'
// elements, starting at address 'begin'.
template <typename T>
void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
  if (len == 0) {
    *os << "{}";
  } else {
    *os << "{ ";
    const size_t kThreshold = 18;
    const size_t kChunkSize = 8;
    // If the array has more than kThreshold elements, we'll have to
    // omit some details by printing only the first and the last
    // kChunkSize elements.
    if (len <= kThreshold) {
      PrintRawArrayTo(begin, len, os);
    } else {
      PrintRawArrayTo(begin, kChunkSize, os);
      *os << ", ..., ";
      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
    }
    *os << " }";
  }
}
// This overload prints a (const) char array compactly.
GTEST_API_ void UniversalPrintArray(
    const char* begin, size_t len, ::std::ostream* os);

#ifdef __cpp_char8_t
// This overload prints a (const) char8_t array compactly.
GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
                                    ::std::ostream* os);
#endif

// This overload prints a (const) char16_t array compactly.
GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
                                    ::std::ostream* os);

// This overload prints a (const) char32_t array compactly.
GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
                                    ::std::ostream* os);

// This overload prints a (const) wchar_t array compactly.
GTEST_API_ void UniversalPrintArray(
    const wchar_t* begin, size_t len, ::std::ostream* os);

// Implements printing an array type T[N].
template <typename T, size_t N>
class UniversalPrinter<T[N]> {
 public:
  // Prints the given array, omitting some elements when there are too
  // many.
  static void Print(const T (&a)[N], ::std::ostream* os) {
    UniversalPrintArray(a, N, os);
  }
};

// Implements printing a reference type T&.
template <typename T>
class UniversalPrinter<T&> {
 public:
  // MSVC warns about adding const to a function type, so we want to
  // disable the warning.
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)

  static void Print(const T& value, ::std::ostream* os) {
    // Prints the address of the value.  We use reinterpret_cast here
    // as static_cast doesn't compile when T is a function type.
    *os << "@" << reinterpret_cast<const void*>(&value) << " ";

    // Then prints the value itself.
    UniversalPrint(value, os);
  }

  GTEST_DISABLE_MSC_WARNINGS_POP_()
};

// Prints a value tersely: for a reference type, the referenced value
// (but not the address) is printed; for a (const) char pointer, the
// NUL-terminated string (but not the pointer) is printed.

template <typename T>
class UniversalTersePrinter {
 public:
  static void Print(const T& value, ::std::ostream* os) {
    UniversalPrint(value, os);
  }
};
template <typename T>
class UniversalTersePrinter<T&> {
 public:
  static void Print(const T& value, ::std::ostream* os) {
    UniversalPrint(value, os);
  }
};
template <typename T, size_t N>
class UniversalTersePrinter<T[N]> {
 public:
  static void Print(const T (&value)[N], ::std::ostream* os) {
    UniversalPrinter<T[N]>::Print(value, os);
  }
};
template <>
class UniversalTersePrinter<const char*> {
 public:
  static void Print(const char* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(std::string(str), os);
    }
  }
};
template <>
class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
};

#ifdef __cpp_char8_t
template <>
class UniversalTersePrinter<const char8_t*> {
 public:
  static void Print(const char8_t* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::u8string(str), os);
    }
  }
};
template <>
class UniversalTersePrinter<char8_t*>
    : public UniversalTersePrinter<const char8_t*> {};
#endif

template <>
class UniversalTersePrinter<const char16_t*> {
 public:
  static void Print(const char16_t* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::u16string(str), os);
    }
  }
};
template <>
class UniversalTersePrinter<char16_t*>
    : public UniversalTersePrinter<const char16_t*> {};

template <>
class UniversalTersePrinter<const char32_t*> {
 public:
  static void Print(const char32_t* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::u32string(str), os);
    }
  }
};
template <>
class UniversalTersePrinter<char32_t*>
    : public UniversalTersePrinter<const char32_t*> {};

#if GTEST_HAS_STD_WSTRING
template <>
class UniversalTersePrinter<const wchar_t*> {
 public:
  static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }
};
#endif

template <>
class UniversalTersePrinter<wchar_t*> {
 public:
  static void Print(wchar_t* str, ::std::ostream* os) {
    UniversalTersePrinter<const wchar_t*>::Print(str, os);
  }
};

template <typename T>
void UniversalTersePrint(const T& value, ::std::ostream* os) {
  UniversalTersePrinter<T>::Print(value, os);
}

// Prints a value using the type inferred by the compiler.  The
// difference between this and UniversalTersePrint() is that for a
// (const) char pointer, this prints both the pointer and the
// NUL-terminated string.
template <typename T>
void UniversalPrint(const T& value, ::std::ostream* os) {
  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
  // UniversalPrinter with T directly.
  typedef T T1;
  UniversalPrinter<T1>::Print(value, os);
}

typedef ::std::vector< ::std::string> Strings;

  // Tersely prints the first N fields of a tuple to a string vector,
  // one element for each field.
template <typename Tuple>
void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
                               Strings*) {}
template <typename Tuple, size_t I>
void TersePrintPrefixToStrings(const Tuple& t,
                               std::integral_constant<size_t, I>,
                               Strings* strings) {
  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
                            strings);
  ::std::stringstream ss;
  UniversalTersePrint(std::get<I - 1>(t), &ss);
  strings->push_back(ss.str());
}

// Prints the fields of a tuple tersely to a string vector, one
// element for each field.  See the comment before
// UniversalTersePrint() for how we define "tersely".
template <typename Tuple>
Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
  Strings result;
  TersePrintPrefixToStrings(
      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
      &result);
  return result;
}

}  // namespace internal

template <typename T>
::std::string PrintToString(const T& value) {
  ::std::stringstream ss;
  internal::UniversalTersePrinter<T>::Print(value, &ss);
  return ss.str();
}

}  // namespace testing

// Include any custom printer added by the local installation.
// We must include this header at the end to make sure it can use the
// declarations from this file.
// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// This file provides an injection point for custom printers in a local
// installation of gTest.
// It will be included from gtest-printers.h and the overrides in this file
// will be visible to everyone.
//
// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

// MSVC warning C5046 is new as of VS2017 version 15.8.
#if defined(_MSC_VER) && _MSC_VER >= 1915
#define GTEST_MAYBE_5046_ 5046
#else
#define GTEST_MAYBE_5046_
#endif

GTEST_DISABLE_MSC_WARNINGS_PUSH_(
    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
                              clients of class B */
    /* Symbol involving type with internal linkage not defined */)

namespace testing {

// To implement a matcher Foo for type T, define:
//   1. a class FooMatcherMatcher that implements the matcher interface:
//     using is_gtest_matcher = void;
//     bool MatchAndExplain(const T&, std::ostream*);
//       (MatchResultListener* can also be used instead of std::ostream*)
//     void DescribeTo(std::ostream*);
//     void DescribeNegationTo(std::ostream*);
//
//   2. a factory function that creates a Matcher<T> object from a
//      FooMatcherMatcher.

class MatchResultListener {
 public:
  // Creates a listener object with the given underlying ostream.  The
  // listener does not own the ostream, and does not dereference it
  // in the constructor or destructor.
  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
  virtual ~MatchResultListener() = 0;  // Makes this class abstract.

  // Streams x to the underlying ostream; does nothing if the ostream
  // is NULL.
  template <typename T>
  MatchResultListener& operator<<(const T& x) {
    if (stream_ != nullptr) *stream_ << x;
    return *this;
  }

  // Returns the underlying ostream.
  ::std::ostream* stream() { return stream_; }

  // Returns true if and only if the listener is interested in an explanation
  // of the match result.  A matcher's MatchAndExplain() method can use
  // this information to avoid generating the explanation when no one
  // intends to hear it.
  bool IsInterested() const { return stream_ != nullptr; }

 private:
  ::std::ostream* const stream_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
};

inline MatchResultListener::~MatchResultListener() {
}

// An instance of a subclass of this knows how to describe itself as a
// matcher.
class MatcherDescriberInterface {
 public:
  virtual ~MatcherDescriberInterface() {}

  // Describes this matcher to an ostream.  The function should print
  // a verb phrase that describes the property a value matching this
  // matcher should have.  The subject of the verb phrase is the value
  // being matched.  For example, the DescribeTo() method of the Gt(7)
  // matcher prints "is greater than 7".
  virtual void DescribeTo(::std::ostream* os) const = 0;

  // Describes the negation of this matcher to an ostream.  For
  // example, if the description of this matcher is "is greater than
  // 7", the negated description could be "is not greater than 7".
  // You are not required to override this when implementing
  // MatcherInterface, but it is highly advised so that your matcher
  // can produce good error messages.
  virtual void DescribeNegationTo(::std::ostream* os) const {
    *os << "not (";
    DescribeTo(os);
    *os << ")";
  }
};

// The implementation of a matcher.
template <typename T>
class MatcherInterface : public MatcherDescriberInterface {
 public:
  // Returns true if and only if the matcher matches x; also explains the
  // match result to 'listener' if necessary (see the next paragraph), in
  // the form of a non-restrictive relative clause ("which ...",
  // "whose ...", etc) that describes x.  For example, the
  // MatchAndExplain() method of the Pointee(...) matcher should
  // generate an explanation like "which points to ...".
  //
  // Implementations of MatchAndExplain() should add an explanation of
  // the match result *if and only if* they can provide additional
  // information that's not already present (or not obvious) in the
  // print-out of x and the matcher's description.  Whether the match
  // succeeds is not a factor in deciding whether an explanation is
  // needed, as sometimes the caller needs to print a failure message
  // when the match succeeds (e.g. when the matcher is used inside
  // Not()).
  //
  // For example, a "has at least 10 elements" matcher should explain
  // what the actual element count is, regardless of the match result,
  // as it is useful information to the reader; on the other hand, an
  // "is empty" matcher probably only needs to explain what the actual
  // size is when the match fails, as it's redundant to say that the
  // size is 0 when the value is already known to be empty.
  //
  // You should override this method when defining a new matcher.
  //
  // It's the responsibility of the caller (Google Test) to guarantee
  // that 'listener' is not NULL.  This helps to simplify a matcher's
  // implementation when it doesn't care about the performance, as it
  // can talk to 'listener' without checking its validity first.
  // However, in order to implement dummy listeners efficiently,
  // listener->stream() may be NULL.
  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;

  // Inherits these methods from MatcherDescriberInterface:
  //   virtual void DescribeTo(::std::ostream* os) const = 0;
  //   virtual void DescribeNegationTo(::std::ostream* os) const;
};

namespace internal {

struct AnyEq {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a == b; }
};
struct AnyNe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a != b; }
};
struct AnyLt {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a < b; }
};
struct AnyGt {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a > b; }
};
struct AnyLe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a <= b; }
};
struct AnyGe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const { return a >= b; }
};

// A match result listener that ignores the explanation.
class DummyMatchResultListener : public MatchResultListener {
 public:
  DummyMatchResultListener() : MatchResultListener(nullptr) {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
};

// A match result listener that forwards the explanation to a given
// ostream.  The difference between this and MatchResultListener is
// that the former is concrete.
class StreamMatchResultListener : public MatchResultListener {
 public:
  explicit StreamMatchResultListener(::std::ostream* os)
      : MatchResultListener(os) {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
};

struct SharedPayloadBase {
  std::atomic<int> ref{1};
  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); }
  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; }
};

template <typename T>
struct SharedPayload : SharedPayloadBase {
  explicit SharedPayload(const T& v) : value(v) {}
  explicit SharedPayload(T&& v) : value(std::move(v)) {}

  static void Destroy(SharedPayloadBase* shared) {
    delete static_cast<SharedPayload*>(shared);
  }

  T value;
};

template <typename T>
using is_trivially_copy_constructible =
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
    std::has_trivial_copy_constructor<T>;
#else
    std::is_trivially_copy_constructible<T>;
#endif

// An internal class for implementing Matcher<T>, which will derive
// from it.  We put functionalities common to all Matcher<T>
// specializations here to avoid code duplication.
template <typename T>
class MatcherBase : private MatcherDescriberInterface {
 public:
  // Returns true if and only if the matcher matches x; also explains the
  // match result to 'listener'.
  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
    GTEST_CHECK_(vtable_ != nullptr);
    return vtable_->match_and_explain(*this, x, listener);
  }

  // Returns true if and only if this matcher matches x.
  bool Matches(const T& x) const {
    DummyMatchResultListener dummy;
    return MatchAndExplain(x, &dummy);
  }

  // Describes this matcher to an ostream.
  void DescribeTo(::std::ostream* os) const final {
    GTEST_CHECK_(vtable_ != nullptr);
    vtable_->describe(*this, os, false);
  }

  // Describes the negation of this matcher to an ostream.
  void DescribeNegationTo(::std::ostream* os) const final {
    GTEST_CHECK_(vtable_ != nullptr);
    vtable_->describe(*this, os, true);
  }

  // Explains why x matches, or doesn't match, the matcher.
  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
    StreamMatchResultListener listener(os);
    MatchAndExplain(x, &listener);
  }

  // Returns the describer for this matcher object; retains ownership
  // of the describer, which is only guaranteed to be alive when
  // this matcher object is alive.
  const MatcherDescriberInterface* GetDescriber() const {
    if (vtable_ == nullptr) return nullptr;
    return vtable_->get_describer(*this);
  }

 protected:
  MatcherBase() : vtable_(nullptr) {}

  // Constructs a matcher from its implementation.
  template <typename U>
  explicit MatcherBase(const MatcherInterface<U>* impl) {
    Init(impl);
  }

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  MatcherBase(M&& m) {  // NOLINT
    Init(std::forward<M>(m));
  }

  MatcherBase(const MatcherBase& other)
      : vtable_(other.vtable_), buffer_(other.buffer_) {
    if (IsShared()) buffer_.shared->Ref();
  }

  MatcherBase& operator=(const MatcherBase& other) {
    if (this == &other) return *this;
    Destroy();
    vtable_ = other.vtable_;
    buffer_ = other.buffer_;
    if (IsShared()) buffer_.shared->Ref();
    return *this;
  }

  MatcherBase(MatcherBase&& other)
      : vtable_(other.vtable_), buffer_(other.buffer_) {
    other.vtable_ = nullptr;
  }

  MatcherBase& operator=(MatcherBase&& other) {
    if (this == &other) return *this;
    Destroy();
    vtable_ = other.vtable_;
    buffer_ = other.buffer_;
    other.vtable_ = nullptr;
    return *this;
  }

  ~MatcherBase() override { Destroy(); }

 private:
  struct VTable {
    bool (*match_and_explain)(const MatcherBase&, const T&,
                              MatchResultListener*);
    void (*describe)(const MatcherBase&, std::ostream*, bool negation);
    // Returns the captured object if it implements the interface, otherwise
    // returns the MatcherBase itself.
    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&);
    // Called on shared instances when the reference count reaches 0.
    void (*shared_destroy)(SharedPayloadBase*);
  };

  bool IsShared() const {
    return vtable_ != nullptr && vtable_->shared_destroy != nullptr;
  }

  // If the implementation uses a listener, call that.
  template <typename P>
  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
                                  MatchResultListener* listener)
      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) {
    return P::Get(m).MatchAndExplain(value, listener->stream());
  }

  template <typename P>
  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
                                  MatchResultListener* listener)
      -> decltype(P::Get(m).MatchAndExplain(value, listener)) {
    return P::Get(m).MatchAndExplain(value, listener);
  }

  template <typename P>
  static void DescribeImpl(const MatcherBase& m, std::ostream* os,
                           bool negation) {
    if (negation) {
      P::Get(m).DescribeNegationTo(os);
    } else {
      P::Get(m).DescribeTo(os);
    }
  }

  template <typename P>
  static const MatcherDescriberInterface* GetDescriberImpl(
      const MatcherBase& m) {
    // If the impl is a MatcherDescriberInterface, then return it.
    // Otherwise use MatcherBase itself.
    // This allows us to implement the GetDescriber() function without support
    // from the impl, but some users really want to get their impl back when
    // they call GetDescriber().
    // We use std::get on a tuple as a workaround of not having `if constexpr`.
    return std::get<(
        std::is_convertible<decltype(&P::Get(m)),
                            const MatcherDescriberInterface*>::value
            ? 1
            : 0)>(std::make_tuple(&m, &P::Get(m)));
  }

  template <typename P>
  const VTable* GetVTable() {
    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>,
                                       &DescribeImpl<P>, &GetDescriberImpl<P>,
                                       P::shared_destroy};
    return &kVTable;
  }

  union Buffer {
    // Add some types to give Buffer some common alignment/size use cases.
    void* ptr;
    double d;
    int64_t i;
    // And add one for the out-of-line cases.
    SharedPayloadBase* shared;
  };

  void Destroy() {
    if (IsShared() && buffer_.shared->Unref()) {
      vtable_->shared_destroy(buffer_.shared);
    }
  }

  template <typename M>
  static constexpr bool IsInlined() {
    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
           is_trivially_copy_constructible<M>::value &&
           std::is_trivially_destructible<M>::value;
  }

  template <typename M, bool = MatcherBase::IsInlined<M>()>
  struct ValuePolicy {
    static const M& Get(const MatcherBase& m) {
      // When inlined along with Init, need to be explicit to avoid violating
      // strict aliasing rules.
      const M *ptr = static_cast<const M*>(
          static_cast<const void*>(&m.buffer_));
      return *ptr;
    }
    static void Init(MatcherBase& m, M impl) {
      ::new (static_cast<void*>(&m.buffer_)) M(impl);
    }
    static constexpr auto shared_destroy = nullptr;
  };

  template <typename M>
  struct ValuePolicy<M, false> {
    using Shared = SharedPayload<M>;
    static const M& Get(const MatcherBase& m) {
      return static_cast<Shared*>(m.buffer_.shared)->value;
    }
    template <typename Arg>
    static void Init(MatcherBase& m, Arg&& arg) {
      m.buffer_.shared = new Shared(std::forward<Arg>(arg));
    }
    static constexpr auto shared_destroy = &Shared::Destroy;
  };

  template <typename U, bool B>
  struct ValuePolicy<const MatcherInterface<U>*, B> {
    using M = const MatcherInterface<U>;
    using Shared = SharedPayload<std::unique_ptr<M>>;
    static const M& Get(const MatcherBase& m) {
      return *static_cast<Shared*>(m.buffer_.shared)->value;
    }
    static void Init(MatcherBase& m, M* impl) {
      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl));
    }

    static constexpr auto shared_destroy = &Shared::Destroy;
  };

  template <typename M>
  void Init(M&& m) {
    using MM = typename std::decay<M>::type;
    using Policy = ValuePolicy<MM>;
    vtable_ = GetVTable<Policy>();
    Policy::Init(*this, std::forward<M>(m));
  }

  const VTable* vtable_;
  Buffer buffer_;
};

}  // namespace internal

// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
// object that can check whether a value of type T matches.  The
// implementation of Matcher<T> is just a std::shared_ptr to const
// MatcherInterface<T>.  Don't inherit from Matcher!
template <typename T>
class Matcher : public internal::MatcherBase<T> {
 public:
  // Constructs a null matcher.  Needed for storing Matcher objects in STL
  // containers.  A default-constructed matcher is not yet initialized.  You
  // cannot use it until a valid value has been assigned to it.
  explicit Matcher() {}  // NOLINT

  // Constructs a matcher from its implementation.
  explicit Matcher(const MatcherInterface<const T&>* impl)
      : internal::MatcherBase<T>(impl) {}

  template <typename U>
  explicit Matcher(
      const MatcherInterface<U>* impl,
      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
          nullptr)
      : internal::MatcherBase<T>(impl) {}

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT

  // Implicit constructor here allows people to write
  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
  Matcher(T value);  // NOLINT
};

// The following two specializations allow the user to write str
// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
// matcher is expected.
template <>
class GTEST_API_ Matcher<const std::string&>
    : public internal::MatcherBase<const std::string&> {
 public:
  Matcher() {}

  explicit Matcher(const MatcherInterface<const std::string&>* impl)
      : internal::MatcherBase<const std::string&>(impl) {}

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}

  // Allows the user to write str instead of Eq(str) sometimes, where
  // str is a std::string object.
  Matcher(const std::string& s);  // NOLINT

  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT
};

template <>
class GTEST_API_ Matcher<std::string>
    : public internal::MatcherBase<std::string> {
 public:
  Matcher() {}

  explicit Matcher(const MatcherInterface<const std::string&>* impl)
      : internal::MatcherBase<std::string>(impl) {}
  explicit Matcher(const MatcherInterface<std::string>* impl)
      : internal::MatcherBase<std::string>(impl) {}

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}

  // Allows the user to write str instead of Eq(str) sometimes, where
  // str is a string object.
  Matcher(const std::string& s);  // NOLINT

  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT
};

#if GTEST_INTERNAL_HAS_STRING_VIEW
// The following two specializations allow the user to write str
// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
// matcher is expected.
template <>
class GTEST_API_ Matcher<const internal::StringView&>
    : public internal::MatcherBase<const internal::StringView&> {
 public:
  Matcher() {}

  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
      : internal::MatcherBase<const internal::StringView&>(impl) {}

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
  }

  // Allows the user to write str instead of Eq(str) sometimes, where
  // str is a std::string object.
  Matcher(const std::string& s);  // NOLINT

  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT

  // Allows the user to pass absl::string_views or std::string_views directly.
  Matcher(internal::StringView s);  // NOLINT
};

template <>
class GTEST_API_ Matcher<internal::StringView>
    : public internal::MatcherBase<internal::StringView> {
 public:
  Matcher() {}

  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
      : internal::MatcherBase<internal::StringView>(impl) {}
  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
      : internal::MatcherBase<internal::StringView>(impl) {}

  template <typename M, typename = typename std::remove_reference<
                            M>::type::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}

  // Allows the user to write str instead of Eq(str) sometimes, where
  // str is a std::string object.
  Matcher(const std::string& s);  // NOLINT

  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT

  // Allows the user to pass absl::string_views or std::string_views directly.
  Matcher(internal::StringView s);  // NOLINT
};
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

// Prints a matcher in a human-readable format.
template <typename T>
std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
  matcher.DescribeTo(&os);
  return os;
}

// The PolymorphicMatcher class template makes it easy to implement a
// polymorphic matcher (i.e. a matcher that can match values of more
// than one type, e.g. Eq(n) and NotNull()).
//
// To define a polymorphic matcher, a user should provide an Impl
// class that has a DescribeTo() method and a DescribeNegationTo()
// method, and define a member function (or member function template)
//
//   bool MatchAndExplain(const Value& value,
//                        MatchResultListener* listener) const;
//
// See the definition of NotNull() for a complete example.
template <class Impl>
class PolymorphicMatcher {
 public:
  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}

  // Returns a mutable reference to the underlying matcher
  // implementation object.
  Impl& mutable_impl() { return impl_; }

  // Returns an immutable reference to the underlying matcher
  // implementation object.
  const Impl& impl() const { return impl_; }

  template <typename T>
  operator Matcher<T>() const {
    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
  }

 private:
  template <typename T>
  class MonomorphicImpl : public MatcherInterface<T> {
   public:
    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}

    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }

    void DescribeNegationTo(::std::ostream* os) const override {
      impl_.DescribeNegationTo(os);
    }

    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
      return impl_.MatchAndExplain(x, listener);
    }

   private:
    const Impl impl_;
  };

  Impl impl_;
};

// Creates a matcher from its implementation.
// DEPRECATED: Especially in the generic code, prefer:
//   Matcher<T>(new MyMatcherImpl<const T&>(...));
//
// MakeMatcher may create a Matcher that accepts its argument by value, which
// leads to unnecessary copies & lack of support for non-copyable types.
template <typename T>
inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
  return Matcher<T>(impl);
}

// Creates a polymorphic matcher from its implementation.  This is
// easier to use than the PolymorphicMatcher<Impl> constructor as it
// doesn't require you to explicitly write the template argument, e.g.
//
//   MakePolymorphicMatcher(foo);
// vs
//   PolymorphicMatcher<TypeOfFoo>(foo);
template <class Impl>
inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
  return PolymorphicMatcher<Impl>(impl);
}

namespace internal {
// Implements a matcher that compares a given value with a
// pre-supplied value using one of the ==, <=, <, etc, operators.  The
// two values being compared don't have to have the same type.
//
// The matcher defined here is polymorphic (for example, Eq(5) can be
// used to match an int, a short, a double, etc).  Therefore we use
// a template type conversion operator in the implementation.
//
// The following template definition assumes that the Rhs parameter is
// a "bare" type (i.e. neither 'const T' nor 'T&').
template <typename D, typename Rhs, typename Op>
class ComparisonBase {
 public:
  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}

  using is_gtest_matcher = void;

  template <typename Lhs>
  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
    return Op()(lhs, Unwrap(rhs_));
  }
  void DescribeTo(std::ostream* os) const {
    *os << D::Desc() << " ";
    UniversalPrint(Unwrap(rhs_), os);
  }
  void DescribeNegationTo(std::ostream* os) const {
    *os << D::NegatedDesc() << " ";
    UniversalPrint(Unwrap(rhs_), os);
  }

 private:
  template <typename T>
  static const T& Unwrap(const T& v) {
    return v;
  }
  template <typename T>
  static const T& Unwrap(std::reference_wrapper<T> v) {
    return v;
  }

  Rhs rhs_;
};

template <typename Rhs>
class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
 public:
  explicit EqMatcher(const Rhs& rhs)
      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
  static const char* Desc() { return "is equal to"; }
  static const char* NegatedDesc() { return "isn't equal to"; }
};
template <typename Rhs>
class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
 public:
  explicit NeMatcher(const Rhs& rhs)
      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
  static const char* Desc() { return "isn't equal to"; }
  static const char* NegatedDesc() { return "is equal to"; }
};
template <typename Rhs>
class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
 public:
  explicit LtMatcher(const Rhs& rhs)
      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
  static const char* Desc() { return "is <"; }
  static const char* NegatedDesc() { return "isn't <"; }
};
template <typename Rhs>
class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
 public:
  explicit GtMatcher(const Rhs& rhs)
      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
  static const char* Desc() { return "is >"; }
  static const char* NegatedDesc() { return "isn't >"; }
};
template <typename Rhs>
class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
 public:
  explicit LeMatcher(const Rhs& rhs)
      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
  static const char* Desc() { return "is <="; }
  static const char* NegatedDesc() { return "isn't <="; }
};
template <typename Rhs>
class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
 public:
  explicit GeMatcher(const Rhs& rhs)
      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
  static const char* Desc() { return "is >="; }
  static const char* NegatedDesc() { return "isn't >="; }
};

template <typename T, typename = typename std::enable_if<
                          std::is_constructible<std::string, T>::value>::type>
using StringLike = T;

// Implements polymorphic matchers MatchesRegex(regex) and
// ContainsRegex(regex), which can be used as a Matcher<T> as long as
// T can be converted to a string.
class MatchesRegexMatcher {
 public:
  MatchesRegexMatcher(const RE* regex, bool full_match)
      : regex_(regex), full_match_(full_match) {}

#if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    return MatchAndExplain(std::string(s), listener);
  }
#endif  // GTEST_INTERNAL_HAS_STRING_VIEW

  // Accepts pointer types, particularly:
  //   const char*
  //   char*
  //   const wchar_t*
  //   wchar_t*
  template <typename CharType>
  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
    return s != nullptr && MatchAndExplain(std::string(s), listener);
  }

  // Matches anything that can convert to std::string.
  //
  // This is a template, not just a plain function with const std::string&,
  // because absl::string_view has some interfering non-explicit constructors.
  template <class MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
    const std::string& s2(s);
    return full_match_ ? RE::FullMatch(s2, *regex_)
                       : RE::PartialMatch(s2, *regex_);
  }

  void DescribeTo(::std::ostream* os) const {
    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
  }

  void DescribeNegationTo(::std::ostream* os) const {
    *os << "doesn't " << (full_match_ ? "match" : "contain")
        << " regular expression ";
    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
  }

 private:
  const std::shared_ptr<const RE> regex_;
  const bool full_match_;
};
}  // namespace internal

// Matches a string that fully matches regular expression 'regex'.
// The matcher takes ownership of 'regex'.
inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
    const internal::RE* regex) {
  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
}
template <typename T = std::string>
PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
    const internal::StringLike<T>& regex) {
  return MatchesRegex(new internal::RE(std::string(regex)));
}

// Matches a string that contains regular expression 'regex'.
// The matcher takes ownership of 'regex'.
inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
    const internal::RE* regex) {
  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
}
template <typename T = std::string>
PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
    const internal::StringLike<T>& regex) {
  return ContainsRegex(new internal::RE(std::string(regex)));
}

// Creates a polymorphic matcher that matches anything equal to x.
// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
// wouldn't compile.
template <typename T>
inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }

// Constructs a Matcher<T> from a 'value' of type T.  The constructed
// matcher matches any value that's equal to 'value'.
template <typename T>
Matcher<T>::Matcher(T value) { *this = Eq(value); }

// Creates a monomorphic matcher that matches anything with type Lhs
// and equal to rhs.  A user may need to use this instead of Eq(...)
// in order to resolve an overloading ambiguity.
//
// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
// or Matcher<T>(x), but more readable than the latter.
//
// We could define similar monomorphic matchers for other comparison
// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
// it yet as those are used much less than Eq() in practice.  A user
// can always write Matcher<T>(Lt(5)) to be explicit about the type,
// for example.
template <typename Lhs, typename Rhs>
inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }

// Creates a polymorphic matcher that matches anything >= x.
template <typename Rhs>
inline internal::GeMatcher<Rhs> Ge(Rhs x) {
  return internal::GeMatcher<Rhs>(x);
}

// Creates a polymorphic matcher that matches anything > x.
template <typename Rhs>
inline internal::GtMatcher<Rhs> Gt(Rhs x) {
  return internal::GtMatcher<Rhs>(x);
}

// Creates a polymorphic matcher that matches anything <= x.
template <typename Rhs>
inline internal::LeMatcher<Rhs> Le(Rhs x) {
  return internal::LeMatcher<Rhs>(x);
}

// Creates a polymorphic matcher that matches anything < x.
template <typename Rhs>
inline internal::LtMatcher<Rhs> Lt(Rhs x) {
  return internal::LtMatcher<Rhs>(x);
}

// Creates a polymorphic matcher that matches anything != x.
template <typename Rhs>
inline internal::NeMatcher<Rhs> Ne(Rhs x) {
  return internal::NeMatcher<Rhs>(x);
}
}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

#include <stdio.h>
#include <memory>

namespace testing {
namespace internal {

GTEST_DECLARE_string_(internal_run_death_test);

// Names of the flags (needed for parsing Google Test flags).
const char kDeathTestStyleFlag[] = "death_test_style";
const char kDeathTestUseFork[] = "death_test_use_fork";
const char kInternalRunDeathTestFlag[] = "internal_run_death_test";

#if GTEST_HAS_DEATH_TEST

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

// DeathTest is a class that hides much of the complexity of the
// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
// returns a concrete class that depends on the prevailing death test
// style, as defined by the --gtest_death_test_style and/or
// --gtest_internal_run_death_test flags.

// In describing the results of death tests, these terms are used with
// the corresponding definitions:
//
// exit status:  The integer exit information in the format specified
//               by wait(2)
// exit code:    The integer code passed to exit(3), _exit(2), or
//               returned from main()
class GTEST_API_ DeathTest {
 public:
  // Create returns false if there was an error determining the
  // appropriate action to take for the current death test; for example,
  // if the gtest_death_test_style flag is set to an invalid value.
  // The LastMessage method will return a more detailed message in that
  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
  // argument is set.  If the death test should be skipped, the pointer
  // is set to NULL; otherwise, it is set to the address of a new concrete
  // DeathTest object that controls the execution of the current test.
  static bool Create(const char* statement, Matcher<const std::string&> matcher,
                     const char* file, int line, DeathTest** test);
  DeathTest();
  virtual ~DeathTest() { }

  // A helper class that aborts a death test when it's deleted.
  class ReturnSentinel {
   public:
    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
   private:
    DeathTest* const test_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
  } GTEST_ATTRIBUTE_UNUSED_;

  // An enumeration of possible roles that may be taken when a death
  // test is encountered.  EXECUTE means that the death test logic should
  // be executed immediately.  OVERSEE means that the program should prepare
  // the appropriate environment for a child process to execute the death
  // test, then wait for it to complete.
  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };

  // An enumeration of the three reasons that a test might be aborted.
  enum AbortReason {
    TEST_ENCOUNTERED_RETURN_STATEMENT,
    TEST_THREW_EXCEPTION,
    TEST_DID_NOT_DIE
  };

  // Assumes one of the above roles.
  virtual TestRole AssumeRole() = 0;

  // Waits for the death test to finish and returns its status.
  virtual int Wait() = 0;

  // Returns true if the death test passed; that is, the test process
  // exited during the test, its exit status matches a user-supplied
  // predicate, and its stderr output matches a user-supplied regular
  // expression.
  // The user-supplied predicate may be a macro expression rather
  // than a function pointer or functor, or else Wait and Passed could
  // be combined.
  virtual bool Passed(bool exit_status_ok) = 0;

  // Signals that the death test did not die as expected.
  virtual void Abort(AbortReason reason) = 0;

  // Returns a human-readable outcome message regarding the outcome of
  // the last death test.
  static const char* LastMessage();

  static void set_last_death_test_message(const std::string& message);

 private:
  // A string containing a description of the outcome of the last death test.
  static std::string last_death_test_message_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
};

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

// Factory interface for death tests.  May be mocked out for testing.
class DeathTestFactory {
 public:
  virtual ~DeathTestFactory() { }
  virtual bool Create(const char* statement,
                      Matcher<const std::string&> matcher, const char* file,
                      int line, DeathTest** test) = 0;
};

// A concrete DeathTestFactory implementation for normal use.
class DefaultDeathTestFactory : public DeathTestFactory {
 public:
  bool Create(const char* statement, Matcher<const std::string&> matcher,
              const char* file, int line, DeathTest** test) override;
};

// Returns true if exit_status describes a process that was terminated
// by a signal, or exited normally with a nonzero exit code.
GTEST_API_ bool ExitedUnsuccessfully(int exit_status);

// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
// and interpreted as a regex (rather than an Eq matcher) for legacy
// compatibility.
inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    ::testing::internal::RE regex) {
  return ContainsRegex(regex.pattern());
}
inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
  return ContainsRegex(regex);
}
inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    const ::std::string& regex) {
  return ContainsRegex(regex);
}

// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
// used directly.
inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    Matcher<const ::std::string&> matcher) {
  return matcher;
}

// Traps C++ exceptions escaping statement and reports them as test
// failures. Note that trapping SEH exceptions is not implemented here.
# if GTEST_HAS_EXCEPTIONS
#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
  try { \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  } catch (const ::std::exception& gtest_exception) { \
    fprintf(\
        stderr, \
        "\n%s: Caught std::exception-derived exception escaping the " \
        "death test statement. Exception message: %s\n", \
        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
        gtest_exception.what()); \
    fflush(stderr); \
    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
  } catch (...) { \
    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
  }

# else
#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)

# endif

// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
// ASSERT_EXIT*, and EXPECT_EXIT*.
#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
  if (::testing::internal::AlwaysTrue()) {                                     \
    ::testing::internal::DeathTest* gtest_dt;                                  \
    if (!::testing::internal::DeathTest::Create(                               \
            #statement,                                                        \
            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
            __FILE__, __LINE__, &gtest_dt)) {                                  \
      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
    }                                                                          \
    if (gtest_dt != nullptr) {                                                 \
      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
      switch (gtest_dt->AssumeRole()) {                                        \
        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
          }                                                                    \
          break;                                                               \
        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
              gtest_dt);                                                       \
          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
          break;                                                               \
        }                                                                      \
        default:                                                               \
          break;                                                               \
      }                                                                        \
    }                                                                          \
  } else                                                                       \
    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
        : fail(::testing::internal::DeathTest::LastMessage())
// The symbol "fail" here expands to something into which a message
// can be streamed.

// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
// NDEBUG mode. In this case we need the statements to be executed and the macro
// must accept a streamed message even though the message is never printed.
// The regex object is not evaluated, but it is used to prevent "unused"
// warnings and to avoid an expression that doesn't compile in debug mode.
#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
  if (::testing::internal::AlwaysTrue()) {                       \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
  } else if (!::testing::internal::AlwaysTrue()) {               \
    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
  } else                                                         \
    ::testing::Message()

// A class representing the parsed contents of the
// --gtest_internal_run_death_test flag, as it existed when
// RUN_ALL_TESTS was called.
class InternalRunDeathTestFlag {
 public:
  InternalRunDeathTestFlag(const std::string& a_file,
                           int a_line,
                           int an_index,
                           int a_write_fd)
      : file_(a_file), line_(a_line), index_(an_index),
        write_fd_(a_write_fd) {}

  ~InternalRunDeathTestFlag() {
    if (write_fd_ >= 0)
      posix::Close(write_fd_);
  }

  const std::string& file() const { return file_; }
  int line() const { return line_; }
  int index() const { return index_; }
  int write_fd() const { return write_fd_; }

 private:
  std::string file_;
  int line_;
  int index_;
  int write_fd_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
};

// Returns a newly created InternalRunDeathTestFlag object with fields
// initialized from the GTEST_FLAG(internal_run_death_test) flag if
// the flag is specified; otherwise returns NULL.
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();

#endif  // GTEST_HAS_DEATH_TEST

}  // namespace internal
}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

namespace testing {

// This flag controls the style of death tests.  Valid values are "threadsafe",
// meaning that the death test child process will re-execute the test binary
// from the start, running only a single death test, or "fast",
// meaning that the child process will execute the test logic immediately
// after forking.
GTEST_DECLARE_string_(death_test_style);

#if GTEST_HAS_DEATH_TEST

namespace internal {

// Returns a Boolean value indicating whether the caller is currently
// executing in the context of the death test child process.  Tools such as
// Valgrind heap checkers may need this to modify their behavior in death
// tests.  IMPORTANT: This is an internal utility.  Using it may break the
// implementation of death tests.  User code MUST NOT use it.
GTEST_API_ bool InDeathTestChild();

}  // namespace internal

// The following macros are useful for writing death tests.

// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
// executed:
//
//   1. It generates a warning if there is more than one active
//   thread.  This is because it's safe to fork() or clone() only
//   when there is a single thread.
//
//   2. The parent process clone()s a sub-process and runs the death
//   test in it; the sub-process exits with code 0 at the end of the
//   death test, if it hasn't exited already.
//
//   3. The parent process waits for the sub-process to terminate.
//
//   4. The parent process checks the exit code and error message of
//   the sub-process.
//
// Examples:
//
//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
//   for (int i = 0; i < 5; i++) {
//     EXPECT_DEATH(server.ProcessRequest(i),
//                  "Invalid request .* in ProcessRequest()")
//                  << "Failed to die on request " << i;
//   }
//
//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
//
//   bool KilledBySIGHUP(int exit_code) {
//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
//   }
//
//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
//
// On the regular expressions used in death tests:
//
//   GOOGLETEST_CM0005 DO NOT DELETE
//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
//   which uses the POSIX extended regex syntax.
//
//   On other platforms (e.g. Windows or Mac), we only support a simple regex
//   syntax implemented as part of Google Test.  This limited
//   implementation should be enough most of the time when writing
//   death tests; though it lacks many features you can find in PCRE
//   or POSIX extended regex syntax.  For example, we don't support
//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
//   repetition count ("x{5,7}"), among others.
//
//   Below is the syntax that we do support.  We chose it to be a
//   subset of both PCRE and POSIX extended regex, so it's easy to
//   learn wherever you come from.  In the following: 'A' denotes a
//   literal character, period (.), or a single \\ escape sequence;
//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
//   natural numbers.
//
//     c     matches any literal character c
//     \\d   matches any decimal digit
//     \\D   matches any character that's not a decimal digit
//     \\f   matches \f
//     \\n   matches \n
//     \\r   matches \r
//     \\s   matches any ASCII whitespace, including \n
//     \\S   matches any character that's not a whitespace
//     \\t   matches \t
//     \\v   matches \v
//     \\w   matches any letter, _, or decimal digit
//     \\W   matches any character that \\w doesn't match
//     \\c   matches any literal character c, which must be a punctuation
//     .     matches any single character except \n
//     A?    matches 0 or 1 occurrences of A
//     A*    matches 0 or many occurrences of A
//     A+    matches 1 or many occurrences of A
//     ^     matches the beginning of a string (not that of each line)
//     $     matches the end of a string (not that of each line)
//     xy    matches x followed by y
//
//   If you accidentally use PCRE or POSIX extended regex features
//   not implemented by us, you will get a run-time failure.  In that
//   case, please try to rewrite your regular expression within the
//   above syntax.
//
//   This implementation is *not* meant to be as highly tuned or robust
//   as a compiled regex library, but should perform well enough for a
//   death test, which already incurs significant overhead by launching
//   a child process.
//
// Known caveats:
//
//   A "threadsafe" style death test obtains the path to the test
//   program from argv[0] and re-executes it in the sub-process.  For
//   simplicity, the current implementation doesn't search the PATH
//   when launching the sub-process.  This means that the user must
//   invoke the test program via a path that contains at least one
//   path separator (e.g. path/to/foo_test and
//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
//   is rarely a problem as people usually don't put the test binary
//   directory in PATH.
//

// Asserts that a given statement causes the program to exit, with an
// integer exit status that satisfies predicate, and emitting error output
// that matches regex.
# define ASSERT_EXIT(statement, predicate, regex) \
    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)

// Like ASSERT_EXIT, but continues on to successive tests in the
// test suite, if any:
# define EXPECT_EXIT(statement, predicate, regex) \
    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)

// Asserts that a given statement causes the program to exit, either by
// explicitly exiting with a nonzero exit code or being killed by a
// signal, and emitting error output that matches regex.
# define ASSERT_DEATH(statement, regex) \
    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)

// Like ASSERT_DEATH, but continues on to successive tests in the
// test suite, if any:
# define EXPECT_DEATH(statement, regex) \
    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)

// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:

// Tests that an exit code describes a normal exit with a given exit code.
class GTEST_API_ ExitedWithCode {
 public:
  explicit ExitedWithCode(int exit_code);
  ExitedWithCode(const ExitedWithCode&) = default;
  void operator=(const ExitedWithCode& other) = delete;
  bool operator()(int exit_status) const;
 private:
  const int exit_code_;
};

# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
// Tests that an exit code describes an exit due to termination by a
// given signal.
// GOOGLETEST_CM0006 DO NOT DELETE
class GTEST_API_ KilledBySignal {
 public:
  explicit KilledBySignal(int signum);
  bool operator()(int exit_status) const;
 private:
  const int signum_;
};
# endif  // !GTEST_OS_WINDOWS

// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
// The death testing framework causes this to have interesting semantics,
// since the sideeffects of the call are only visible in opt mode, and not
// in debug mode.
//
// In practice, this can be used to test functions that utilize the
// LOG(DFATAL) macro using the following style:
//
// int DieInDebugOr12(int* sideeffect) {
//   if (sideeffect) {
//     *sideeffect = 12;
//   }
//   LOG(DFATAL) << "death";
//   return 12;
// }
//
// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
//   int sideeffect = 0;
//   // Only asserts in dbg.
//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
//
// #ifdef NDEBUG
//   // opt-mode has sideeffect visible.
//   EXPECT_EQ(12, sideeffect);
// #else
//   // dbg-mode no visible sideeffect.
//   EXPECT_EQ(0, sideeffect);
// #endif
// }
//
// This will assert that DieInDebugReturn12InOpt() crashes in debug
// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
// appropriate fallback value (12 in this case) in opt mode. If you
// need to test that a function has appropriate side-effects in opt
// mode, include assertions against the side-effects.  A general
// pattern for this is:
//
// EXPECT_DEBUG_DEATH({
//   // Side-effects here will have an effect after this statement in
//   // opt mode, but none in debug mode.
//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
// }, "death");
//
# ifdef NDEBUG

#  define EXPECT_DEBUG_DEATH(statement, regex) \
  GTEST_EXECUTE_STATEMENT_(statement, regex)

#  define ASSERT_DEBUG_DEATH(statement, regex) \
  GTEST_EXECUTE_STATEMENT_(statement, regex)

# else

#  define EXPECT_DEBUG_DEATH(statement, regex) \
  EXPECT_DEATH(statement, regex)

#  define ASSERT_DEBUG_DEATH(statement, regex) \
  ASSERT_DEATH(statement, regex)

# endif  // NDEBUG for EXPECT_DEBUG_DEATH
#endif  // GTEST_HAS_DEATH_TEST

// This macro is used for implementing macros such as
// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
// death tests are not supported. Those macros must compile on such systems
// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters
// on systems that support death tests. This allows one to write such a macro on
// a system that does not support death tests and be sure that it will compile
// on a death-test supporting system. It is exposed publicly so that systems
// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST
// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
// ASSERT_DEATH_IF_SUPPORTED.
//
// Parameters:
//   statement -  A statement that a macro such as EXPECT_DEATH would test
//                for program termination. This macro has to make sure this
//                statement is compiled but not executed, to ensure that
//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
//                parameter if and only if EXPECT_DEATH compiles with it.
//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
//                the output of statement.  This parameter has to be
//                compiled but not evaluated by this macro, to ensure that
//                this macro only accepts expressions that a macro such as
//                EXPECT_DEATH would accept.
//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
//                compile inside functions where ASSERT_DEATH doesn't
//                compile.
//
//  The branch that has an always false condition is used to ensure that
//  statement and regex are compiled (and thus syntactically correct) but
//  never executed. The unreachable code macro protects the terminator
//  statement from generating an 'unreachable code' warning in case
//  statement unconditionally returns or throws. The Message constructor at
//  the end allows the syntax of streaming additional messages into the
//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::AlwaysTrue()) { \
      GTEST_LOG_(WARNING) \
          << "Death tests are not supported on this platform.\n" \
          << "Statement '" #statement "' cannot be verified."; \
    } else if (::testing::internal::AlwaysFalse()) { \
      ::testing::internal::RE::PartialMatch(".*", (regex)); \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
      terminator; \
    } else \
      ::testing::Message()

// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
// death tests are supported; otherwise they just issue a warning.  This is
// useful when you are combining death test assertions with normal test
// assertions in one test.
#if GTEST_HAS_DEATH_TEST
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
    EXPECT_DEATH(statement, regex)
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
    ASSERT_DEATH(statement, regex)
#else
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
#endif

}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Macros and functions for implementing parameterized tests
// in Google C++ Testing and Mocking Framework (Google Test)
//
// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

// Value-parameterized tests allow you to test your code with different
// parameters without writing multiple copies of the same test.
//
// Here is how you use value-parameterized tests:

#if 0

// To write value-parameterized tests, first you should define a fixture
// class. It is usually derived from testing::TestWithParam<T> (see below for
// another inheritance scheme that's sometimes useful in more complicated
// class hierarchies), where the type of your parameter values.
// TestWithParam<T> is itself derived from testing::Test. T can be any
// copyable type. If it's a raw pointer, you are responsible for managing the
// lifespan of the pointed values.

class FooTest : public ::testing::TestWithParam<const char*> {
  // You can implement all the usual class fixture members here.
};

// Then, use the TEST_P macro to define as many parameterized tests
// for this fixture as you want. The _P suffix is for "parameterized"
// or "pattern", whichever you prefer to think.

TEST_P(FooTest, DoesBlah) {
  // Inside a test, access the test parameter with the GetParam() method
  // of the TestWithParam<T> class:
  EXPECT_TRUE(foo.Blah(GetParam()));
  ...
}

TEST_P(FooTest, HasBlahBlah) {
  ...
}

// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
// case with any set of parameters you want. Google Test defines a number
// of functions for generating test parameters. They return what we call
// (surprise!) parameter generators. Here is a summary of them, which
// are all in the testing namespace:
//
//
//  Range(begin, end [, step]) - Yields values {begin, begin+step,
//                               begin+step+step, ...}. The values do not
//                               include end. step defaults to 1.
//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
//  ValuesIn(container)        - Yields values from a C-style array, an STL
//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
//  Bool()                     - Yields sequence {false, true}.
//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
//                               for the math savvy) of the values generated
//                               by the N generators.
//
// For more details, see comments at the definitions of these functions below
// in this file.
//
// The following statement will instantiate tests from the FooTest test suite
// each with parameter values "meeny", "miny", and "moe".

INSTANTIATE_TEST_SUITE_P(InstantiationName,
                         FooTest,
                         Values("meeny", "miny", "moe"));

// To distinguish different instances of the pattern, (yes, you
// can instantiate it more than once) the first argument to the
// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
// actual test suite name. Remember to pick unique prefixes for different
// instantiations. The tests from the instantiation above will have
// these names:
//
//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
//
// You can use these names in --gtest_filter.
//
// This statement will instantiate all tests from FooTest again, each
// with parameter values "cat" and "dog":

const char* pets[] = {"cat", "dog"};
INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));

// The tests from the instantiation above will have these names:
//
//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
//
// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
// in the given test suite, whether their definitions come before or
// AFTER the INSTANTIATE_TEST_SUITE_P statement.
//
// Please also note that generator expressions (including parameters to the
// generators) are evaluated in InitGoogleTest(), after main() has started.
// This allows the user on one hand, to adjust generator parameters in order
// to dynamically determine a set of tests to run and on the other hand,
// give the user a chance to inspect the generated tests with Google Test
// reflection API before RUN_ALL_TESTS() is executed.
//
// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
// for more examples.
//
// In the future, we plan to publish the API for defining new parameter
// generators. But for now this interface remains part of the internal
// implementation and is subject to change.
//
//
// A parameterized test fixture must be derived from testing::Test and from
// testing::WithParamInterface<T>, where T is the type of the parameter
// values. Inheriting from TestWithParam<T> satisfies that requirement because
// TestWithParam<T> inherits from both Test and WithParamInterface. In more
// complicated hierarchies, however, it is occasionally useful to inherit
// separately from Test and WithParamInterface. For example:

class BaseTest : public ::testing::Test {
  // You can inherit all the usual members for a non-parameterized test
  // fixture here.
};

class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
  // The usual test fixture members go here too.
};

TEST_F(BaseTest, HasFoo) {
  // This is an ordinary non-parameterized test.
}

TEST_P(DerivedTest, DoesBlah) {
  // GetParam works just the same here as if you inherit from TestWithParam.
  EXPECT_TRUE(foo.Blah(GetParam()));
}

#endif  // 0

#include <iterator>
#include <utility>

// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// Type and function utilities for implementing parameterized tests.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

#include <ctype.h>

#include <cassert>
#include <iterator>
#include <memory>
#include <set>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_

#include <iosfwd>
#include <vector>

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// A copyable object representing the result of a test part (i.e. an
// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
//
// Don't inherit from TestPartResult as its destructor is not virtual.
class GTEST_API_ TestPartResult {
 public:
  // The possible outcomes of a test part (i.e. an assertion or an
  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
  enum Type {
    kSuccess,          // Succeeded.
    kNonFatalFailure,  // Failed but the test can continue.
    kFatalFailure,     // Failed and the test should be terminated.
    kSkip              // Skipped.
  };

  // C'tor.  TestPartResult does NOT have a default constructor.
  // Always use this constructor (with parameters) to create a
  // TestPartResult object.
  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
                 const char* a_message)
      : type_(a_type),
        file_name_(a_file_name == nullptr ? "" : a_file_name),
        line_number_(a_line_number),
        summary_(ExtractSummary(a_message)),
        message_(a_message) {}

  // Gets the outcome of the test part.
  Type type() const { return type_; }

  // Gets the name of the source file where the test part took place, or
  // NULL if it's unknown.
  const char* file_name() const {
    return file_name_.empty() ? nullptr : file_name_.c_str();
  }

  // Gets the line in the source file where the test part took place,
  // or -1 if it's unknown.
  int line_number() const { return line_number_; }

  // Gets the summary of the failure message.
  const char* summary() const { return summary_.c_str(); }

  // Gets the message associated with the test part.
  const char* message() const { return message_.c_str(); }

  // Returns true if and only if the test part was skipped.
  bool skipped() const { return type_ == kSkip; }

  // Returns true if and only if the test part passed.
  bool passed() const { return type_ == kSuccess; }

  // Returns true if and only if the test part non-fatally failed.
  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }

  // Returns true if and only if the test part fatally failed.
  bool fatally_failed() const { return type_ == kFatalFailure; }

  // Returns true if and only if the test part failed.
  bool failed() const { return fatally_failed() || nonfatally_failed(); }

 private:
  Type type_;

  // Gets the summary of the failure message by omitting the stack
  // trace in it.
  static std::string ExtractSummary(const char* message);

  // The name of the source file where the test part took place, or
  // "" if the source file is unknown.
  std::string file_name_;
  // The line in the source file where the test part took place, or -1
  // if the line number is unknown.
  int line_number_;
  std::string summary_;  // The test failure summary.
  std::string message_;  // The test failure message.
};

// Prints a TestPartResult object.
std::ostream& operator<<(std::ostream& os, const TestPartResult& result);

// An array of TestPartResult objects.
//
// Don't inherit from TestPartResultArray as its destructor is not
// virtual.
class GTEST_API_ TestPartResultArray {
 public:
  TestPartResultArray() {}

  // Appends the given TestPartResult to the array.
  void Append(const TestPartResult& result);

  // Returns the TestPartResult at the given index (0-based).
  const TestPartResult& GetTestPartResult(int index) const;

  // Returns the number of TestPartResult objects in the array.
  int size() const;

 private:
  std::vector<TestPartResult> array_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
};

// This interface knows how to report a test part result.
class GTEST_API_ TestPartResultReporterInterface {
 public:
  virtual ~TestPartResultReporterInterface() {}

  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
};

namespace internal {

// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
// statement generates new fatal failures. To do so it registers itself as the
// current test part result reporter. Besides checking if fatal failures were
// reported, it only delegates the reporting to the former result reporter.
// The original result reporter is restored in the destructor.
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
class GTEST_API_ HasNewFatalFailureHelper
    : public TestPartResultReporterInterface {
 public:
  HasNewFatalFailureHelper();
  ~HasNewFatalFailureHelper() override;
  void ReportTestPartResult(const TestPartResult& result) override;
  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
 private:
  bool has_new_fatal_failure_;
  TestPartResultReporterInterface* original_reporter_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
};

}  // namespace internal

}  // namespace testing

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_

namespace testing {
// Input to a parameterized test name generator, describing a test parameter.
// Consists of the parameter value and the integer parameter index.
template <class ParamType>
struct TestParamInfo {
  TestParamInfo(const ParamType& a_param, size_t an_index) :
    param(a_param),
    index(an_index) {}
  ParamType param;
  size_t index;
};

// A builtin parameterized test name generator which returns the result of
// testing::PrintToString.
struct PrintToStringParamName {
  template <class ParamType>
  std::string operator()(const TestParamInfo<ParamType>& info) const {
    return PrintToString(info.param);
  }
};

namespace internal {

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
// Utility Functions

// Outputs a message explaining invalid registration of different
// fixture class for the same test suite. This may happen when
// TEST_P macro is used to define two tests with the same name
// but in different namespaces.
GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
                                           CodeLocation code_location);

template <typename> class ParamGeneratorInterface;
template <typename> class ParamGenerator;

// Interface for iterating over elements provided by an implementation
// of ParamGeneratorInterface<T>.
template <typename T>
class ParamIteratorInterface {
 public:
  virtual ~ParamIteratorInterface() {}
  // A pointer to the base generator instance.
  // Used only for the purposes of iterator comparison
  // to make sure that two iterators belong to the same generator.
  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
  // Advances iterator to point to the next element
  // provided by the generator. The caller is responsible
  // for not calling Advance() on an iterator equal to
  // BaseGenerator()->End().
  virtual void Advance() = 0;
  // Clones the iterator object. Used for implementing copy semantics
  // of ParamIterator<T>.
  virtual ParamIteratorInterface* Clone() const = 0;
  // Dereferences the current iterator and provides (read-only) access
  // to the pointed value. It is the caller's responsibility not to call
  // Current() on an iterator equal to BaseGenerator()->End().
  // Used for implementing ParamGenerator<T>::operator*().
  virtual const T* Current() const = 0;
  // Determines whether the given iterator and other point to the same
  // element in the sequence generated by the generator.
  // Used for implementing ParamGenerator<T>::operator==().
  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
};

// Class iterating over elements provided by an implementation of
// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
// and implements the const forward iterator concept.
template <typename T>
class ParamIterator {
 public:
  typedef T value_type;
  typedef const T& reference;
  typedef ptrdiff_t difference_type;

  // ParamIterator assumes ownership of the impl_ pointer.
  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
  ParamIterator& operator=(const ParamIterator& other) {
    if (this != &other)
      impl_.reset(other.impl_->Clone());
    return *this;
  }

  const T& operator*() const { return *impl_->Current(); }
  const T* operator->() const { return impl_->Current(); }
  // Prefix version of operator++.
  ParamIterator& operator++() {
    impl_->Advance();
    return *this;
  }
  // Postfix version of operator++.
  ParamIterator operator++(int /*unused*/) {
    ParamIteratorInterface<T>* clone = impl_->Clone();
    impl_->Advance();
    return ParamIterator(clone);
  }
  bool operator==(const ParamIterator& other) const {
    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
  }
  bool operator!=(const ParamIterator& other) const {
    return !(*this == other);
  }

 private:
  friend class ParamGenerator<T>;
  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
  std::unique_ptr<ParamIteratorInterface<T> > impl_;
};

// ParamGeneratorInterface<T> is the binary interface to access generators
// defined in other translation units.
template <typename T>
class ParamGeneratorInterface {
 public:
  typedef T ParamType;

  virtual ~ParamGeneratorInterface() {}

  // Generator interface definition
  virtual ParamIteratorInterface<T>* Begin() const = 0;
  virtual ParamIteratorInterface<T>* End() const = 0;
};

// Wraps ParamGeneratorInterface<T> and provides general generator syntax
// compatible with the STL Container concept.
// This class implements copy initialization semantics and the contained
// ParamGeneratorInterface<T> instance is shared among all copies
// of the original object. This is possible because that instance is immutable.
template<typename T>
class ParamGenerator {
 public:
  typedef ParamIterator<T> iterator;

  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}

  ParamGenerator& operator=(const ParamGenerator& other) {
    impl_ = other.impl_;
    return *this;
  }

  iterator begin() const { return iterator(impl_->Begin()); }
  iterator end() const { return iterator(impl_->End()); }

 private:
  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
};

// Generates values from a range of two comparable values. Can be used to
// generate sequences of user-defined types that implement operator+() and
// operator<().
// This class is used in the Range() function.
template <typename T, typename IncrementT>
class RangeGenerator : public ParamGeneratorInterface<T> {
 public:
  RangeGenerator(T begin, T end, IncrementT step)
      : begin_(begin), end_(end),
        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
  ~RangeGenerator() override {}

  ParamIteratorInterface<T>* Begin() const override {
    return new Iterator(this, begin_, 0, step_);
  }
  ParamIteratorInterface<T>* End() const override {
    return new Iterator(this, end_, end_index_, step_);
  }

 private:
  class Iterator : public ParamIteratorInterface<T> {
   public:
    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
             IncrementT step)
        : base_(base), value_(value), index_(index), step_(step) {}
    ~Iterator() override {}

    const ParamGeneratorInterface<T>* BaseGenerator() const override {
      return base_;
    }
    void Advance() override {
      value_ = static_cast<T>(value_ + step_);
      index_++;
    }
    ParamIteratorInterface<T>* Clone() const override {
      return new Iterator(*this);
    }
    const T* Current() const override { return &value_; }
    bool Equals(const ParamIteratorInterface<T>& other) const override {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      const int other_index =
          CheckedDowncastToActualType<const Iterator>(&other)->index_;
      return index_ == other_index;
    }

   private:
    Iterator(const Iterator& other)
        : ParamIteratorInterface<T>(),
          base_(other.base_), value_(other.value_), index_(other.index_),
          step_(other.step_) {}

    // No implementation - assignment is unsupported.
    void operator=(const Iterator& other);

    const ParamGeneratorInterface<T>* const base_;
    T value_;
    int index_;
    const IncrementT step_;
  };  // class RangeGenerator::Iterator

  static int CalculateEndIndex(const T& begin,
                               const T& end,
                               const IncrementT& step) {
    int end_index = 0;
    for (T i = begin; i < end; i = static_cast<T>(i + step))
      end_index++;
    return end_index;
  }

  // No implementation - assignment is unsupported.
  void operator=(const RangeGenerator& other);

  const T begin_;
  const T end_;
  const IncrementT step_;
  // The index for the end() iterator. All the elements in the generated
  // sequence are indexed (0-based) to aid iterator comparison.
  const int end_index_;
};  // class RangeGenerator


// Generates values from a pair of STL-style iterators. Used in the
// ValuesIn() function. The elements are copied from the source range
// since the source can be located on the stack, and the generator
// is likely to persist beyond that stack frame.
template <typename T>
class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
 public:
  template <typename ForwardIterator>
  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
      : container_(begin, end) {}
  ~ValuesInIteratorRangeGenerator() override {}

  ParamIteratorInterface<T>* Begin() const override {
    return new Iterator(this, container_.begin());
  }
  ParamIteratorInterface<T>* End() const override {
    return new Iterator(this, container_.end());
  }

 private:
  typedef typename ::std::vector<T> ContainerType;

  class Iterator : public ParamIteratorInterface<T> {
   public:
    Iterator(const ParamGeneratorInterface<T>* base,
             typename ContainerType::const_iterator iterator)
        : base_(base), iterator_(iterator) {}
    ~Iterator() override {}

    const ParamGeneratorInterface<T>* BaseGenerator() const override {
      return base_;
    }
    void Advance() override {
      ++iterator_;
      value_.reset();
    }
    ParamIteratorInterface<T>* Clone() const override {
      return new Iterator(*this);
    }
    // We need to use cached value referenced by iterator_ because *iterator_
    // can return a temporary object (and of type other then T), so just
    // having "return &*iterator_;" doesn't work.
    // value_ is updated here and not in Advance() because Advance()
    // can advance iterator_ beyond the end of the range, and we cannot
    // detect that fact. The client code, on the other hand, is
    // responsible for not calling Current() on an out-of-range iterator.
    const T* Current() const override {
      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
      return value_.get();
    }
    bool Equals(const ParamIteratorInterface<T>& other) const override {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_ ==
          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

   private:
    Iterator(const Iterator& other)
          // The explicit constructor call suppresses a false warning
          // emitted by gcc when supplied with the -Wextra option.
        : ParamIteratorInterface<T>(),
          base_(other.base_),
          iterator_(other.iterator_) {}

    const ParamGeneratorInterface<T>* const base_;
    typename ContainerType::const_iterator iterator_;
    // A cached value of *iterator_. We keep it here to allow access by
    // pointer in the wrapping iterator's operator->().
    // value_ needs to be mutable to be accessed in Current().
    // Use of std::unique_ptr helps manage cached value's lifetime,
    // which is bound by the lifespan of the iterator itself.
    mutable std::unique_ptr<const T> value_;
  };  // class ValuesInIteratorRangeGenerator::Iterator

  // No implementation - assignment is unsupported.
  void operator=(const ValuesInIteratorRangeGenerator& other);

  const ContainerType container_;
};  // class ValuesInIteratorRangeGenerator

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Default parameterized test name generator, returns a string containing the
// integer test parameter index.
template <class ParamType>
std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
  Message name_stream;
  name_stream << info.index;
  return name_stream.GetString();
}

template <typename T = int>
void TestNotEmpty() {
  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
}
template <typename T = int>
void TestNotEmpty(const T&) {}

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Stores a parameter value and later creates tests parameterized with that
// value.
template <class TestClass>
class ParameterizedTestFactory : public TestFactoryBase {
 public:
  typedef typename TestClass::ParamType ParamType;
  explicit ParameterizedTestFactory(ParamType parameter) :
      parameter_(parameter) {}
  Test* CreateTest() override {
    TestClass::SetParam(&parameter_);
    return new TestClass();
  }

 private:
  const ParamType parameter_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// TestMetaFactoryBase is a base class for meta-factories that create
// test factories for passing into MakeAndRegisterTestInfo function.
template <class ParamType>
class TestMetaFactoryBase {
 public:
  virtual ~TestMetaFactoryBase() {}

  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// TestMetaFactory creates test factories for passing into
// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
// ownership of test factory pointer, same factory object cannot be passed
// into that method twice. But ParameterizedTestSuiteInfo is going to call
// it for each Test/Parameter value combination. Thus it needs meta factory
// creator class.
template <class TestSuite>
class TestMetaFactory
    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
 public:
  using ParamType = typename TestSuite::ParamType;

  TestMetaFactory() {}

  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
    return new ParameterizedTestFactory<TestSuite>(parameter);
  }

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestSuiteInfoBase is a generic interface
// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
// accumulates test information provided by TEST_P macro invocations
// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
// and uses that information to register all resulting test instances
// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
// a collection of pointers to the ParameterizedTestSuiteInfo objects
// and calls RegisterTests() on each of them when asked.
class ParameterizedTestSuiteInfoBase {
 public:
  virtual ~ParameterizedTestSuiteInfoBase() {}

  // Base part of test suite name for display purposes.
  virtual const std::string& GetTestSuiteName() const = 0;
  // Test suite id to verify identity.
  virtual TypeId GetTestSuiteTypeId() const = 0;
  // UnitTest class invokes this method to register tests in this
  // test suite right before running them in RUN_ALL_TESTS macro.
  // This method should not be called more than once on any single
  // instance of a ParameterizedTestSuiteInfoBase derived class.
  virtual void RegisterTests() = 0;

 protected:
  ParameterizedTestSuiteInfoBase() {}

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Report a the name of a test_suit as safe to ignore
// as the side effect of construction of this type.
struct MarkAsIgnored {
  explicit MarkAsIgnored(const char* test_suite);
};

GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
                                        CodeLocation location, bool has_test_p);

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
// macro invocations for a particular test suite and generators
// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
// test suite. It registers tests with all values generated by all
// generators when asked.
template <class TestSuite>
class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
 public:
  // ParamType and GeneratorCreationFunc are private types but are required
  // for declarations of public methods AddTestPattern() and
  // AddTestSuiteInstantiation().
  using ParamType = typename TestSuite::ParamType;
  // A function that returns an instance of appropriate generator type.
  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);

  explicit ParameterizedTestSuiteInfo(const char* name,
                                      CodeLocation code_location)
      : test_suite_name_(name), code_location_(code_location) {}

  // Test suite base name for display purposes.
  const std::string& GetTestSuiteName() const override {
    return test_suite_name_;
  }
  // Test suite id to verify identity.
  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
  // TEST_P macro uses AddTestPattern() to record information
  // about a single test in a LocalTestInfo structure.
  // test_suite_name is the base name of the test suite (without invocation
  // prefix). test_base_name is the name of an individual test without
  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
  // test suite base name and DoBar is test base name.
  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory,
                      CodeLocation code_location) {
    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
        test_suite_name, test_base_name, meta_factory, code_location)));
  }
  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
  // about a generator.
  int AddTestSuiteInstantiation(const std::string& instantiation_name,
                                GeneratorCreationFunc* func,
                                ParamNameGeneratorFunc* name_func,
                                const char* file, int line) {
    instantiations_.push_back(
        InstantiationInfo(instantiation_name, func, name_func, file, line));
    return 0;  // Return value used only to run this method in namespace scope.
  }
  // UnitTest class invokes this method to register tests in this test suite
  // right before running tests in RUN_ALL_TESTS macro.
  // This method should not be called more than once on any single
  // instance of a ParameterizedTestSuiteInfoBase derived class.
  // UnitTest has a guard to prevent from calling this method more than once.
  void RegisterTests() override {
    bool generated_instantiations = false;

    for (typename TestInfoContainer::iterator test_it = tests_.begin();
         test_it != tests_.end(); ++test_it) {
      std::shared_ptr<TestInfo> test_info = *test_it;
      for (typename InstantiationContainer::iterator gen_it =
               instantiations_.begin(); gen_it != instantiations_.end();
               ++gen_it) {
        const std::string& instantiation_name = gen_it->name;
        ParamGenerator<ParamType> generator((*gen_it->generator)());
        ParamNameGeneratorFunc* name_func = gen_it->name_func;
        const char* file = gen_it->file;
        int line = gen_it->line;

        std::string test_suite_name;
        if ( !instantiation_name.empty() )
          test_suite_name = instantiation_name + "/";
        test_suite_name += test_info->test_suite_base_name;

        size_t i = 0;
        std::set<std::string> test_param_names;
        for (typename ParamGenerator<ParamType>::iterator param_it =
                 generator.begin();
             param_it != generator.end(); ++param_it, ++i) {
          generated_instantiations = true;

          Message test_name_stream;

          std::string param_name = name_func(
              TestParamInfo<ParamType>(*param_it, i));

          GTEST_CHECK_(IsValidParamName(param_name))
              << "Parameterized test name '" << param_name
              << "' is invalid, in " << file
              << " line " << line << std::endl;

          GTEST_CHECK_(test_param_names.count(param_name) == 0)
              << "Duplicate parameterized test name '" << param_name
              << "', in " << file << " line " << line << std::endl;

          test_param_names.insert(param_name);

          if (!test_info->test_base_name.empty()) {
            test_name_stream << test_info->test_base_name << "/";
          }
          test_name_stream << param_name;
          MakeAndRegisterTestInfo(
              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
              nullptr,  // No type parameter.
              PrintToString(*param_it).c_str(), test_info->code_location,
              GetTestSuiteTypeId(),
              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
              test_info->test_meta_factory->CreateTestFactory(*param_it));
        }  // for param_it
      }  // for gen_it
    }  // for test_it

    if (!generated_instantiations) {
      // There are no generaotrs, or they all generate nothing ...
      InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
                              !tests_.empty());
    }
  }    // RegisterTests

 private:
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo {
    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
             CodeLocation a_code_location)
        : test_suite_base_name(a_test_suite_base_name),
          test_base_name(a_test_base_name),
          test_meta_factory(a_test_meta_factory),
          code_location(a_code_location) {}

    const std::string test_suite_base_name;
    const std::string test_base_name;
    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
    const CodeLocation code_location;
  };
  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
  //  <Instantiation name, Sequence generator creation function,
  //     Name generator function, Source file, Source line>
  struct InstantiationInfo {
      InstantiationInfo(const std::string &name_in,
                        GeneratorCreationFunc* generator_in,
                        ParamNameGeneratorFunc* name_func_in,
                        const char* file_in,
                        int line_in)
          : name(name_in),
            generator(generator_in),
            name_func(name_func_in),
            file(file_in),
            line(line_in) {}

      std::string name;
      GeneratorCreationFunc* generator;
      ParamNameGeneratorFunc* name_func;
      const char* file;
      int line;
  };
  typedef ::std::vector<InstantiationInfo> InstantiationContainer;

  static bool IsValidParamName(const std::string& name) {
    // Check for empty string
    if (name.empty())
      return false;

    // Check for invalid characters
    for (std::string::size_type index = 0; index < name.size(); ++index) {
      if (!isalnum(name[index]) && name[index] != '_')
        return false;
    }

    return true;
  }

  const std::string test_suite_name_;
  CodeLocation code_location_;
  TestInfoContainer tests_;
  InstantiationContainer instantiations_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
};  // class ParameterizedTestSuiteInfo

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
template <class TestCase>
using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestSuiteRegistry contains a map of
// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
// ParameterizedTestSuiteInfo descriptors.
class ParameterizedTestSuiteRegistry {
 public:
  ParameterizedTestSuiteRegistry() {}
  ~ParameterizedTestSuiteRegistry() {
    for (auto& test_suite_info : test_suite_infos_) {
      delete test_suite_info;
    }
  }

  // Looks up or creates and returns a structure containing information about
  // tests and instantiations of a particular test suite.
  template <class TestSuite>
  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
      const char* test_suite_name, CodeLocation code_location) {
    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
    for (auto& test_suite_info : test_suite_infos_) {
      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
          // Complain about incorrect usage of Google Test facilities
          // and terminate the program since we cannot guaranty correct
          // test suite setup and tear-down in this case.
          ReportInvalidTestSuiteType(test_suite_name, code_location);
          posix::Abort();
        } else {
          // At this point we are sure that the object we found is of the same
          // type we are looking for, so we downcast it to that type
          // without further checks.
          typed_test_info = CheckedDowncastToActualType<
              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
        }
        break;
      }
    }
    if (typed_test_info == nullptr) {
      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
          test_suite_name, code_location);
      test_suite_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
  }
  void RegisterTests() {
    for (auto& test_suite_info : test_suite_infos_) {
      test_suite_info->RegisterTests();
    }
  }
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  template <class TestCase>
  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
      const char* test_case_name, CodeLocation code_location) {
    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
  }

#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

 private:
  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;

  TestSuiteInfoContainer test_suite_infos_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
};

// Keep track of what type-parameterized test suite are defined and
// where as well as which are intatiated. This allows susequently
// identifying suits that are defined but never used.
class TypeParameterizedTestSuiteRegistry {
 public:
  // Add a suite definition
  void RegisterTestSuite(const char* test_suite_name,
                         CodeLocation code_location);

  // Add an instantiation of a suit.
  void RegisterInstantiation(const char* test_suite_name);

  // For each suit repored as defined but not reported as instantiation,
  // emit a test that reports that fact (configurably, as an error).
  void CheckForInstantiations();

 private:
  struct TypeParameterizedTestSuiteInfo {
    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
        : code_location(c), instantiated(false) {}

    CodeLocation code_location;
    bool instantiated;
  };

  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
};

}  // namespace internal

// Forward declarations of ValuesIn(), which is implemented in
// include/gtest/gtest-param-test.h.
template <class Container>
internal::ParamGenerator<typename Container::value_type> ValuesIn(
    const Container& container);

namespace internal {
// Used in the Values() function to provide polymorphic capabilities.

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4100)
#endif

template <typename... Ts>
class ValueArray {
 public:
  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}

  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
  }

 private:
  template <typename T, size_t... I>
  std::vector<T> MakeVector(IndexSequence<I...>) const {
    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
  }

  FlatTuple<Ts...> v_;
};

#ifdef _MSC_VER
#pragma warning(pop)
#endif

template <typename... T>
class CartesianProductGenerator
    : public ParamGeneratorInterface<::std::tuple<T...>> {
 public:
  typedef ::std::tuple<T...> ParamType;

  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
      : generators_(g) {}
  ~CartesianProductGenerator() override {}

  ParamIteratorInterface<ParamType>* Begin() const override {
    return new Iterator(this, generators_, false);
  }
  ParamIteratorInterface<ParamType>* End() const override {
    return new Iterator(this, generators_, true);
  }

 private:
  template <class I>
  class IteratorImpl;
  template <size_t... I>
  class IteratorImpl<IndexSequence<I...>>
      : public ParamIteratorInterface<ParamType> {
   public:
    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
        : base_(base),
          begin_(std::get<I>(generators).begin()...),
          end_(std::get<I>(generators).end()...),
          current_(is_end ? end_ : begin_) {
      ComputeCurrentValue();
    }
    ~IteratorImpl() override {}

    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
      return base_;
    }
    // Advance should not be called on beyond-of-range iterators
    // so no component iterators must be beyond end of range, either.
    void Advance() override {
      assert(!AtEnd());
      // Advance the last iterator.
      ++std::get<sizeof...(T) - 1>(current_);
      // if that reaches end, propagate that up.
      AdvanceIfEnd<sizeof...(T) - 1>();
      ComputeCurrentValue();
    }
    ParamIteratorInterface<ParamType>* Clone() const override {
      return new IteratorImpl(*this);
    }

    const ParamType* Current() const override { return current_value_.get(); }

    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      const IteratorImpl* typed_other =
          CheckedDowncastToActualType<const IteratorImpl>(&other);

      // We must report iterators equal if they both point beyond their
      // respective ranges. That can happen in a variety of fashions,
      // so we have to consult AtEnd().
      if (AtEnd() && typed_other->AtEnd()) return true;

      bool same = true;
      bool dummy[] = {
          (same = same && std::get<I>(current_) ==
                              std::get<I>(typed_other->current_))...};
      (void)dummy;
      return same;
    }

   private:
    template <size_t ThisI>
    void AdvanceIfEnd() {
      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;

      bool last = ThisI == 0;
      if (last) {
        // We are done. Nothing else to propagate.
        return;
      }

      constexpr size_t NextI = ThisI - (ThisI != 0);
      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
      ++std::get<NextI>(current_);
      AdvanceIfEnd<NextI>();
    }

    void ComputeCurrentValue() {
      if (!AtEnd())
        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
    }
    bool AtEnd() const {
      bool at_end = false;
      bool dummy[] = {
          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
      (void)dummy;
      return at_end;
    }

    const ParamGeneratorInterface<ParamType>* const base_;
    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
    std::tuple<typename ParamGenerator<T>::iterator...> end_;
    std::tuple<typename ParamGenerator<T>::iterator...> current_;
    std::shared_ptr<ParamType> current_value_;
  };

  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;

  std::tuple<ParamGenerator<T>...> generators_;
};

template <class... Gen>
class CartesianProductHolder {
 public:
  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
  template <typename... T>
  operator ParamGenerator<::std::tuple<T...>>() const {
    return ParamGenerator<::std::tuple<T...>>(
        new CartesianProductGenerator<T...>(generators_));
  }

 private:
  std::tuple<Gen...> generators_;
};

}  // namespace internal
}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

namespace testing {

// Functions producing parameter generators.
//
// Google Test uses these generators to produce parameters for value-
// parameterized tests. When a parameterized test suite is instantiated
// with a particular generator, Google Test creates and runs tests
// for each element in the sequence produced by the generator.
//
// In the following sample, tests from test suite FooTest are instantiated
// each three times with parameter values 3, 5, and 8:
//
// class FooTest : public TestWithParam<int> { ... };
//
// TEST_P(FooTest, TestThis) {
// }
// TEST_P(FooTest, TestThat) {
// }
// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
//

// Range() returns generators providing sequences of values in a range.
//
// Synopsis:
// Range(start, end)
//   - returns a generator producing a sequence of values {start, start+1,
//     start+2, ..., }.
// Range(start, end, step)
//   - returns a generator producing a sequence of values {start, start+step,
//     start+step+step, ..., }.
// Notes:
//   * The generated sequences never include end. For example, Range(1, 5)
//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
//     returns a generator producing {1, 3, 5, 7}.
//   * start and end must have the same type. That type may be any integral or
//     floating-point type or a user defined type satisfying these conditions:
//     * It must be assignable (have operator=() defined).
//     * It must have operator+() (operator+(int-compatible type) for
//       two-operand version).
//     * It must have operator<() defined.
//     Elements in the resulting sequences will also have that type.
//   * Condition start < end must be satisfied in order for resulting sequences
//     to contain any elements.
//
template <typename T, typename IncrementT>
internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
  return internal::ParamGenerator<T>(
      new internal::RangeGenerator<T, IncrementT>(start, end, step));
}

template <typename T>
internal::ParamGenerator<T> Range(T start, T end) {
  return Range(start, end, 1);
}

// ValuesIn() function allows generation of tests with parameters coming from
// a container.
//
// Synopsis:
// ValuesIn(const T (&array)[N])
//   - returns a generator producing sequences with elements from
//     a C-style array.
// ValuesIn(const Container& container)
//   - returns a generator producing sequences with elements from
//     an STL-style container.
// ValuesIn(Iterator begin, Iterator end)
//   - returns a generator producing sequences with elements from
//     a range [begin, end) defined by a pair of STL-style iterators. These
//     iterators can also be plain C pointers.
//
// Please note that ValuesIn copies the values from the containers
// passed in and keeps them to generate tests in RUN_ALL_TESTS().
//
// Examples:
//
// This instantiates tests from test suite StringTest
// each with C-string values of "foo", "bar", and "baz":
//
// const char* strings[] = {"foo", "bar", "baz"};
// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
//
// This instantiates tests from test suite StlStringTest
// each with STL strings with values "a" and "b":
//
// ::std::vector< ::std::string> GetParameterStrings() {
//   ::std::vector< ::std::string> v;
//   v.push_back("a");
//   v.push_back("b");
//   return v;
// }
//
// INSTANTIATE_TEST_SUITE_P(CharSequence,
//                          StlStringTest,
//                          ValuesIn(GetParameterStrings()));
//
//
// This will also instantiate tests from CharTest
// each with parameter values 'a' and 'b':
//
// ::std::list<char> GetParameterChars() {
//   ::std::list<char> list;
//   list.push_back('a');
//   list.push_back('b');
//   return list;
// }
// ::std::list<char> l = GetParameterChars();
// INSTANTIATE_TEST_SUITE_P(CharSequence2,
//                          CharTest,
//                          ValuesIn(l.begin(), l.end()));
//
template <typename ForwardIterator>
internal::ParamGenerator<
    typename std::iterator_traits<ForwardIterator>::value_type>
ValuesIn(ForwardIterator begin, ForwardIterator end) {
  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
  return internal::ParamGenerator<ParamType>(
      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
}

template <typename T, size_t N>
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
  return ValuesIn(array, array + N);
}

template <class Container>
internal::ParamGenerator<typename Container::value_type> ValuesIn(
    const Container& container) {
  return ValuesIn(container.begin(), container.end());
}

// Values() allows generating tests from explicitly specified list of
// parameters.
//
// Synopsis:
// Values(T v1, T v2, ..., T vN)
//   - returns a generator producing sequences with elements v1, v2, ..., vN.
//
// For example, this instantiates tests from test suite BarTest each
// with values "one", "two", and "three":
//
// INSTANTIATE_TEST_SUITE_P(NumSequence,
//                          BarTest,
//                          Values("one", "two", "three"));
//
// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
// The exact type of values will depend on the type of parameter in BazTest.
//
// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
//
//
template <typename... T>
internal::ValueArray<T...> Values(T... v) {
  return internal::ValueArray<T...>(std::move(v)...);
}

// Bool() allows generating tests with parameters in a set of (false, true).
//
// Synopsis:
// Bool()
//   - returns a generator producing sequences with elements {false, true}.
//
// It is useful when testing code that depends on Boolean flags. Combinations
// of multiple flags can be tested when several Bool()'s are combined using
// Combine() function.
//
// In the following example all tests in the test suite FlagDependentTest
// will be instantiated twice with parameters false and true.
//
// class FlagDependentTest : public testing::TestWithParam<bool> {
//   virtual void SetUp() {
//     external_flag = GetParam();
//   }
// }
// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
//
inline internal::ParamGenerator<bool> Bool() {
  return Values(false, true);
}

// Combine() allows the user to combine two or more sequences to produce
// values of a Cartesian product of those sequences' elements.
//
// Synopsis:
// Combine(gen1, gen2, ..., genN)
//   - returns a generator producing sequences with elements coming from
//     the Cartesian product of elements from the sequences generated by
//     gen1, gen2, ..., genN. The sequence elements will have a type of
//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
//     of elements from sequences produces by gen1, gen2, ..., genN.
//
// Example:
//
// This will instantiate tests in test suite AnimalTest each one with
// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
// tuple("dog", BLACK), and tuple("dog", WHITE):
//
// enum Color { BLACK, GRAY, WHITE };
// class AnimalTest
//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
//
// TEST_P(AnimalTest, AnimalLooksNice) {...}
//
// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
//                          Combine(Values("cat", "dog"),
//                                  Values(BLACK, WHITE)));
//
// This will instantiate tests in FlagDependentTest with all variations of two
// Boolean flags:
//
// class FlagDependentTest
//     : public testing::TestWithParam<std::tuple<bool, bool> > {
//   virtual void SetUp() {
//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
//     std::tie(external_flag_1, external_flag_2) = GetParam();
//   }
// };
//
// TEST_P(FlagDependentTest, TestFeature1) {
//   // Test your code using external_flag_1 and external_flag_2 here.
// }
// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
//                          Combine(Bool(), Bool()));
//
template <typename... Generator>
internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
  return internal::CartesianProductHolder<Generator...>(g...);
}

#define TEST_P(test_suite_name, test_name)                                     \
  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
      : public test_suite_name {                                               \
   public:                                                                     \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
    void TestBody() override;                                                  \
                                                                               \
   private:                                                                    \
    static int AddToRegistry() {                                               \
      ::testing::UnitTest::GetInstance()                                       \
          ->parameterized_test_registry()                                      \
          .GetTestSuitePatternHolder<test_suite_name>(                         \
              GTEST_STRINGIFY_(test_suite_name),                               \
              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
          ->AddTestPattern(                                                    \
              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
                  test_suite_name, test_name)>(),                              \
              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
      return 0;                                                                \
    }                                                                          \
    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
                                                           test_name));        \
  };                                                                           \
  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                             test_name)::gtest_registering_dummy_ =            \
      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
// generator and an optional function or functor that generates custom test name
// suffixes based on the test parameters. Such a function or functor should
// accept one argument of type testing::TestParamInfo<class ParamType>, and
// return std::string.
//
// testing::PrintToStringParamName is a builtin test suffix generator that
// returns the value of testing::PrintToString(GetParam()).
//
// Note: test names must be non-empty, unique, and may only contain ASCII
// alphanumeric characters or underscore. Because PrintToString adds quotes
// to std::string and C strings, it won't work for these types.

#define GTEST_EXPAND_(arg) arg
#define GTEST_GET_FIRST_(first, ...) first
#define GTEST_GET_SECOND_(first, second, ...) second

#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
  }                                                                           \
  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
    if (::testing::internal::AlwaysFalse()) {                                 \
      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
          __VA_ARGS__,                                                        \
          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
          DUMMY_PARAM_)));                                                    \
      auto t = std::make_tuple(__VA_ARGS__);                                  \
      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
                    "Too Many Args!");                                        \
    }                                                                         \
    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
        __VA_ARGS__,                                                          \
        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
        DUMMY_PARAM_))))(info);                                               \
  }                                                                           \
  static int gtest_##prefix##test_suite_name##_dummy_                         \
      GTEST_ATTRIBUTE_UNUSED_ =                                               \
          ::testing::UnitTest::GetInstance()                                  \
              ->parameterized_test_registry()                                 \
              .GetTestSuitePatternHolder<test_suite_name>(                    \
                  GTEST_STRINGIFY_(test_suite_name),                          \
                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
              ->AddTestSuiteInstantiation(                                    \
                  GTEST_STRINGIFY_(prefix),                                   \
                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
                  __FILE__, __LINE__)


// Allow Marking a Parameterized test class as not needing to be instantiated.
#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
  namespace gtest_do_not_use_outside_namespace_scope {}                   \
  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
      GTEST_STRINGIFY_(T))

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
#define INSTANTIATE_TEST_CASE_P                                            \
  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
                "");                                                       \
  INSTANTIATE_TEST_SUITE_P
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
// Copyright 2006, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//
// Google C++ Testing and Mocking Framework definitions useful in production code.
// GOOGLETEST_CM0003 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_

// When you need to test the private or protected members of a class,
// use the FRIEND_TEST macro to declare your tests as friends of the
// class.  For example:
//
// class MyClass {
//  private:
//   void PrivateMethod();
//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
// };
//
// class MyClassTest : public testing::Test {
//   // ...
// };
//
// TEST_F(MyClassTest, PrivateMethodWorks) {
//   // Can call MyClass::PrivateMethod() here.
// }
//
// Note: The test class must be in the same namespace as the class being tested.
// For example, putting MyClassTest in an anonymous namespace will not work.

#define FRIEND_TEST(test_case_name, test_name)\
friend class test_case_name##_##test_name##_Test

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_

// This header implements typed tests and type-parameterized tests.

// Typed (aka type-driven) tests repeat the same test for types in a
// list.  You must know which types you want to test with when writing
// typed tests. Here's how you do it:

#if 0

// First, define a fixture class template.  It should be parameterized
// by a type.  Remember to derive it from testing::Test.
template <typename T>
class FooTest : public testing::Test {
 public:
  ...
  typedef std::list<T> List;
  static T shared_;
  T value_;
};

// Next, associate a list of types with the test suite, which will be
// repeated for each type in the list.  The typedef is necessary for
// the macro to parse correctly.
typedef testing::Types<char, int, unsigned int> MyTypes;
TYPED_TEST_SUITE(FooTest, MyTypes);

// If the type list contains only one type, you can write that type
// directly without Types<...>:
//   TYPED_TEST_SUITE(FooTest, int);

// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
// tests for this test suite as you want.
TYPED_TEST(FooTest, DoesBlah) {
  // Inside a test, refer to the special name TypeParam to get the type
  // parameter.  Since we are inside a derived class template, C++ requires
  // us to visit the members of FooTest via 'this'.
  TypeParam n = this->value_;

  // To visit static members of the fixture, add the TestFixture::
  // prefix.
  n += TestFixture::shared_;

  // To refer to typedefs in the fixture, add the "typename
  // TestFixture::" prefix.
  typename TestFixture::List values;
  values.push_back(n);
  ...
}

TYPED_TEST(FooTest, HasPropertyA) { ... }

// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
// class that generates custom test name suffixes based on the type. This should
// be a class which has a static template function GetName(int index) returning
// a string for each type. The provided integer index equals the index of the
// type in the provided type list. In many cases the index can be ignored.
//
// For example:
//   class MyTypeNames {
//    public:
//     template <typename T>
//     static std::string GetName(int) {
//       if (std::is_same<T, char>()) return "char";
//       if (std::is_same<T, int>()) return "int";
//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
//     }
//   };
//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);

#endif  // 0

// Type-parameterized tests are abstract test patterns parameterized
// by a type.  Compared with typed tests, type-parameterized tests
// allow you to define the test pattern without knowing what the type
// parameters are.  The defined pattern can be instantiated with
// different types any number of times, in any number of translation
// units.
//
// If you are designing an interface or concept, you can define a
// suite of type-parameterized tests to verify properties that any
// valid implementation of the interface/concept should have.  Then,
// each implementation can easily instantiate the test suite to verify
// that it conforms to the requirements, without having to write
// similar tests repeatedly.  Here's an example:

#if 0

// First, define a fixture class template.  It should be parameterized
// by a type.  Remember to derive it from testing::Test.
template <typename T>
class FooTest : public testing::Test {
  ...
};

// Next, declare that you will define a type-parameterized test suite
// (the _P suffix is for "parameterized" or "pattern", whichever you
// prefer):
TYPED_TEST_SUITE_P(FooTest);

// Then, use TYPED_TEST_P() to define as many type-parameterized tests
// for this type-parameterized test suite as you want.
TYPED_TEST_P(FooTest, DoesBlah) {
  // Inside a test, refer to TypeParam to get the type parameter.
  TypeParam n = 0;
  ...
}

TYPED_TEST_P(FooTest, HasPropertyA) { ... }

// Now the tricky part: you need to register all test patterns before
// you can instantiate them.  The first argument of the macro is the
// test suite name; the rest are the names of the tests in this test
// case.
REGISTER_TYPED_TEST_SUITE_P(FooTest,
                            DoesBlah, HasPropertyA);

// Finally, you are free to instantiate the pattern with the types you
// want.  If you put the above code in a header file, you can #include
// it in multiple C++ source files and instantiate it multiple times.
//
// To distinguish different instances of the pattern, the first
// argument to the INSTANTIATE_* macro is a prefix that will be added
// to the actual test suite name.  Remember to pick unique prefixes for
// different instances.
typedef testing::Types<char, int, unsigned int> MyTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);

// If the type list contains only one type, you can write that type
// directly without Types<...>:
//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
//
// Similar to the optional argument of TYPED_TEST_SUITE above,
// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
// generate custom names.
//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);

#endif  // 0


// Implements typed tests.

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the name of the typedef for the type parameters of the
// given test suite.
#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_

// Expands to the name of the typedef for the NameGenerator, responsible for
// creating the suffixes of the name.
#define GTEST_NAME_GENERATOR_(TestSuiteName) \
  gtest_type_params_##TestSuiteName##_NameGenerator

#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \
  typedef ::testing::internal::GenerateTypeList<Types>::type            \
      GTEST_TYPE_PARAMS_(CaseName);                                     \
  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
      GTEST_NAME_GENERATOR_(CaseName)

#define TYPED_TEST(CaseName, TestName)                                        \
  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
                "test-name must not be empty");                               \
  template <typename gtest_TypeParam_>                                        \
  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
      : public CaseName<gtest_TypeParam_> {                                   \
   private:                                                                   \
    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
    typedef gtest_TypeParam_ TypeParam;                                       \
    void TestBody() override;                                                 \
  };                                                                          \
  static bool gtest_##CaseName##_##TestName##_registered_                     \
      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
          CaseName,                                                           \
          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
                                                                  TestName)>, \
          GTEST_TYPE_PARAMS_(                                                 \
              CaseName)>::Register("",                                        \
                                   ::testing::internal::CodeLocation(         \
                                       __FILE__, __LINE__),                   \
                                   GTEST_STRINGIFY_(CaseName),                \
                                   GTEST_STRINGIFY_(TestName), 0,             \
                                   ::testing::internal::GenerateNames<        \
                                       GTEST_NAME_GENERATOR_(CaseName),       \
                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
  template <typename gtest_TypeParam_>                                        \
  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
                              TestName)<gtest_TypeParam_>::TestBody()

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
#define TYPED_TEST_CASE                                                \
  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
  TYPED_TEST_SUITE
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

// Implements type-parameterized tests.

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the namespace name that the type-parameterized tests for
// the given type-parameterized test suite are defined in.  The exact
// name of the namespace is subject to change without notice.
#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the name of the variable used to remember the names of
// the defined tests in the given test suite.
#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
  gtest_typed_test_suite_p_state_##TestSuiteName##_

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
//
// Expands to the name of the variable used to remember the names of
// the registered tests in the given test suite.
#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
  gtest_registered_test_names_##TestSuiteName##_

// The variables defined in the type-parameterized test macros are
// static as typically these macros are used in a .h file that can be
// #included in multiple translation units linked together.
#define TYPED_TEST_SUITE_P(SuiteName)              \
  static ::testing::internal::TypedTestSuitePState \
      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
#define TYPED_TEST_CASE_P                                                 \
  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
  TYPED_TEST_SUITE_P
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

#define TYPED_TEST_P(SuiteName, TestName)                             \
  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \
    template <typename gtest_TypeParam_>                              \
    class TestName : public SuiteName<gtest_TypeParam_> {             \
     private:                                                         \
      typedef SuiteName<gtest_TypeParam_> TestFixture;                \
      typedef gtest_TypeParam_ TypeParam;                             \
      void TestBody() override;                                       \
    };                                                                \
    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
            __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
            GTEST_STRINGIFY_(TestName));                              \
  }                                                                   \
  template <typename gtest_TypeParam_>                                \
  void GTEST_SUITE_NAMESPACE_(                                        \
      SuiteName)::TestName<gtest_TypeParam_>::TestBody()

// Note: this won't work correctly if the trailing arguments are macros.
#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \
  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
    typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;    \
  }                                                                         \
  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
#define REGISTER_TYPED_TEST_CASE_P                                           \
  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
                "");                                                         \
  REGISTER_TYPED_TEST_SUITE_P
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \
                "test-suit-prefix must not be empty");                      \
  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
      ::testing::internal::TypeParameterizedTestSuite<                      \
          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
          ::testing::internal::GenerateTypeList<Types>::type>::             \
          Register(GTEST_STRINGIFY_(Prefix),                                \
                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
                   GTEST_STRINGIFY_(SuiteName),                             \
                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
                   ::testing::internal::GenerateNames<                      \
                       ::testing::internal::NameGeneratorSelector<          \
                           __VA_ARGS__>::type,                              \
                       ::testing::internal::GenerateTypeList<Types>::type>())

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
  static_assert(                                                           \
      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
  INSTANTIATE_TYPED_TEST_SUITE_P
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing {

// Silence C4100 (unreferenced formal parameter) and 4805
// unsafe mix of type 'const int' and type 'const bool'
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4805)
# pragma warning(disable:4100)
#endif


// Declares the flags.

// This flag temporary enables the disabled tests.
GTEST_DECLARE_bool_(also_run_disabled_tests);

// This flag brings the debugger on an assertion failure.
GTEST_DECLARE_bool_(break_on_failure);

// This flag controls whether Google Test catches all test-thrown exceptions
// and logs them as failures.
GTEST_DECLARE_bool_(catch_exceptions);

// This flag enables using colors in terminal output. Available values are
// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
// to let Google Test decide.
GTEST_DECLARE_string_(color);

// This flag controls whether the test runner should continue execution past
// first failure.
GTEST_DECLARE_bool_(fail_fast);

// This flag sets up the filter to select by name using a glob pattern
// the tests to run. If the filter is not given all tests are executed.
GTEST_DECLARE_string_(filter);

// This flag controls whether Google Test installs a signal handler that dumps
// debugging information when fatal signals are raised.
GTEST_DECLARE_bool_(install_failure_signal_handler);

// This flag causes the Google Test to list tests. None of the tests listed
// are actually run if the flag is provided.
GTEST_DECLARE_bool_(list_tests);

// This flag controls whether Google Test emits a detailed XML report to a file
// in addition to its normal textual output.
GTEST_DECLARE_string_(output);

// This flags control whether Google Test prints only test failures.
GTEST_DECLARE_bool_(brief);

// This flags control whether Google Test prints the elapsed time for each
// test.
GTEST_DECLARE_bool_(print_time);

// This flags control whether Google Test prints UTF8 characters as text.
GTEST_DECLARE_bool_(print_utf8);

// This flag specifies the random number seed.
GTEST_DECLARE_int32_(random_seed);

// This flag sets how many times the tests are repeated. The default value
// is 1. If the value is -1 the tests are repeating forever.
GTEST_DECLARE_int32_(repeat);

// This flag controls whether Google Test includes Google Test internal
// stack frames in failure stack traces.
GTEST_DECLARE_bool_(show_internal_stack_frames);

// When this flag is specified, tests' order is randomized on every iteration.
GTEST_DECLARE_bool_(shuffle);

// This flag specifies the maximum number of stack frames to be
// printed in a failure message.
GTEST_DECLARE_int32_(stack_trace_depth);

// When this flag is specified, a failed assertion will throw an
// exception if exceptions are enabled, or exit the program with a
// non-zero code otherwise. For use with an external test framework.
GTEST_DECLARE_bool_(throw_on_failure);

// When this flag is set with a "host:port" string, on supported
// platforms test results are streamed to the specified port on
// the specified host machine.
GTEST_DECLARE_string_(stream_result_to);

#if GTEST_USE_OWN_FLAGFILE_FLAG_
GTEST_DECLARE_string_(flagfile);
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_

// The upper limit for valid stack trace depths.
const int kMaxStackTraceDepth = 100;

namespace internal {

class AssertHelper;
class DefaultGlobalTestPartResultReporter;
class ExecDeathTest;
class NoExecDeathTest;
class FinalSuccessChecker;
class GTestFlagSaver;
class StreamingListenerTest;
class TestResultAccessor;
class TestEventListenersAccessor;
class TestEventRepeater;
class UnitTestRecordPropertyTestHelper;
class WindowsDeathTest;
class FuchsiaDeathTest;
class UnitTestImpl* GetUnitTestImpl();
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message);
std::set<std::string>* GetIgnoredParameterizedTestSuites();

}  // namespace internal

// The friend relationship of some of these classes is cyclic.
// If we don't forward declare them the compiler might confuse the classes
// in friendship clauses with same named classes on the scope.
class Test;
class TestSuite;

// Old API is still available but deprecated
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
using TestCase = TestSuite;
#endif
class TestInfo;
class UnitTest;

// A class for indicating whether an assertion was successful.  When
// the assertion wasn't successful, the AssertionResult object
// remembers a non-empty message that describes how it failed.
//
// To create an instance of this class, use one of the factory functions
// (AssertionSuccess() and AssertionFailure()).
//
// This class is useful for two purposes:
//   1. Defining predicate functions to be used with Boolean test assertions
//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
//   2. Defining predicate-format functions to be
//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
//
// For example, if you define IsEven predicate:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
// will print the message
//
//   Value of: IsEven(Fib(5))
//     Actual: false (5 is odd)
//   Expected: true
//
// instead of a more opaque
//
//   Value of: IsEven(Fib(5))
//     Actual: false
//   Expected: true
//
// in case IsEven is a simple Boolean predicate.
//
// If you expect your predicate to be reused and want to support informative
// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
// about half as often as positive ones in our tests), supply messages for
// both success and failure cases:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess() << n << " is even";
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
//
//   Value of: IsEven(Fib(6))
//     Actual: true (8 is even)
//   Expected: false
//
// NB: Predicates that support negative Boolean assertions have reduced
// performance in positive ones so be careful not to use them in tests
// that have lots (tens of thousands) of positive Boolean assertions.
//
// To use this class with EXPECT_PRED_FORMAT assertions such as:
//
//   // Verifies that Foo() returns an even number.
//   EXPECT_PRED_FORMAT1(IsEven, Foo());
//
// you need to define:
//
//   testing::AssertionResult IsEven(const char* expr, int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure()
//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
//   }
//
// If Foo() returns 5, you will see the following message:
//
//   Expected: Foo() is even
//     Actual: it's 5
//
class GTEST_API_ AssertionResult {
 public:
  // Copy constructor.
  // Used in EXPECT_TRUE/FALSE(assertion_result).
  AssertionResult(const AssertionResult& other);

// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
// This warning is not emitted in Visual Studio 2017.
// This warning is off by default starting in Visual Studio 2019 but can be
// enabled with command-line options.
#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
#endif

  // Used in the EXPECT_TRUE/FALSE(bool_expression).
  //
  // T must be contextually convertible to bool.
  //
  // The second parameter prevents this overload from being considered if
  // the argument is implicitly convertible to AssertionResult. In that case
  // we want AssertionResult's copy constructor to be used.
  template <typename T>
  explicit AssertionResult(
      const T& success,
      typename std::enable_if<
          !std::is_convertible<T, AssertionResult>::value>::type*
      /*enabler*/
      = nullptr)
      : success_(success) {}

#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
  GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif

  // Assignment operator.
  AssertionResult& operator=(AssertionResult other) {
    swap(other);
    return *this;
  }

  // Returns true if and only if the assertion succeeded.
  operator bool() const { return success_; }  // NOLINT

  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
  AssertionResult operator!() const;

  // Returns the text streamed into this AssertionResult. Test assertions
  // use it when they fail (i.e., the predicate's outcome doesn't match the
  // assertion's expectation). When nothing has been streamed into the
  // object, returns an empty string.
  const char* message() const {
    return message_.get() != nullptr ? message_->c_str() : "";
  }
  // Deprecated; please use message() instead.
  const char* failure_message() const { return message(); }

  // Streams a custom failure message into this object.
  template <typename T> AssertionResult& operator<<(const T& value) {
    AppendMessage(Message() << value);
    return *this;
  }

  // Allows streaming basic output manipulators such as endl or flush into
  // this object.
  AssertionResult& operator<<(
      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
    AppendMessage(Message() << basic_manipulator);
    return *this;
  }

 private:
  // Appends the contents of message to message_.
  void AppendMessage(const Message& a_message) {
    if (message_.get() == nullptr) message_.reset(new ::std::string);
    message_->append(a_message.GetString().c_str());
  }

  // Swap the contents of this AssertionResult with other.
  void swap(AssertionResult& other);

  // Stores result of the assertion predicate.
  bool success_;
  // Stores the message describing the condition in case the expectation
  // construct is not satisfied with the predicate's outcome.
  // Referenced via a pointer to avoid taking too much stack frame space
  // with test assertions.
  std::unique_ptr< ::std::string> message_;
};

// Makes a successful assertion result.
GTEST_API_ AssertionResult AssertionSuccess();

// Makes a failed assertion result.
GTEST_API_ AssertionResult AssertionFailure();

// Makes a failed assertion result with the given failure message.
// Deprecated; use AssertionFailure() << msg.
GTEST_API_ AssertionResult AssertionFailure(const Message& msg);

}  // namespace testing

// Includes the auto-generated header that implements a family of generic
// predicate assertion macros. This include comes late because it relies on
// APIs declared above.
// Copyright 2006, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
//
// Implements a family of generic predicate assertion macros.
// GOOGLETEST_CM0001 DO NOT DELETE

#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_


namespace testing {

// This header implements a family of generic predicate assertion
// macros:
//
//   ASSERT_PRED_FORMAT1(pred_format, v1)
//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
//   ...
//
// where pred_format is a function or functor that takes n (in the
// case of ASSERT_PRED_FORMATn) values and their source expression
// text, and returns a testing::AssertionResult.  See the definition
// of ASSERT_EQ in gtest.h for an example.
//
// If you don't care about formatting, you can use the more
// restrictive version:
//
//   ASSERT_PRED1(pred, v1)
//   ASSERT_PRED2(pred, v1, v2)
//   ...
//
// where pred is an n-ary function or functor that returns bool,
// and the values v1, v2, ..., must support the << operator for
// streaming to std::ostream.
//
// We also define the EXPECT_* variations.
//
// For now we only support predicates whose arity is at most 5.
// Please email googletestframework@googlegroups.com if you need
// support for higher arities.

// GTEST_ASSERT_ is the basic statement to which all of the assertions
// in this file reduce.  Don't use this in your code.

#define GTEST_ASSERT_(expression, on_failure) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (const ::testing::AssertionResult gtest_ar = (expression)) \
    ; \
  else \
    on_failure(gtest_ar.failure_message())


// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
// this in your code.
template <typename Pred,
          typename T1>
AssertionResult AssertPred1Helper(const char* pred_text,
                                  const char* e1,
                                  Pred pred,
                                  const T1& v1) {
  if (pred(v1)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1);
}

// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
// Don't use this in your code.
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, v1), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
// this in your code.
#define GTEST_PRED1_(pred, v1, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
                                             #v1, \
                                             pred, \
                                             v1), on_failure)

// Unary predicate assertion macros.
#define EXPECT_PRED_FORMAT1(pred_format, v1) \
  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
#define EXPECT_PRED1(pred, v1) \
  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
#define ASSERT_PRED_FORMAT1(pred_format, v1) \
  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
#define ASSERT_PRED1(pred, v1) \
  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)



// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2>
AssertionResult AssertPred2Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2) {
  if (pred(v1, v2)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2);
}

// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
// Don't use this in your code.
#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
// this in your code.
#define GTEST_PRED2_(pred, v1, v2, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             pred, \
                                             v1, \
                                             v2), on_failure)

// Binary predicate assertion macros.
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
#define EXPECT_PRED2(pred, v1, v2) \
  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
#define ASSERT_PRED2(pred, v1, v2) \
  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)



// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2,
          typename T3>
AssertionResult AssertPred3Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  const char* e3,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2,
                                  const T3& v3) {
  if (pred(v1, v2, v3)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3);
}

// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
// Don't use this in your code.
#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
// this in your code.
#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3), on_failure)

// Ternary predicate assertion macros.
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
#define EXPECT_PRED3(pred, v1, v2, v3) \
  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
#define ASSERT_PRED3(pred, v1, v2, v3) \
  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)



// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2,
          typename T3,
          typename T4>
AssertionResult AssertPred4Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  const char* e3,
                                  const char* e4,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2,
                                  const T3& v3,
                                  const T4& v4) {
  if (pred(v1, v2, v3, v4)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
         << e4 << " evaluates to " << ::testing::PrintToString(v4);
}

// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
// Don't use this in your code.
#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
// this in your code.
#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             #v4, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3, \
                                             v4), on_failure)

// 4-ary predicate assertion macros.
#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)



// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5>
AssertionResult AssertPred5Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  const char* e3,
                                  const char* e4,
                                  const char* e5,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2,
                                  const T3& v3,
                                  const T4& v4,
                                  const T5& v5) {
  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
         << ", " << e5 << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
         << e5 << " evaluates to " << ::testing::PrintToString(v5);
}

// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
// Don't use this in your code.
#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
// this in your code.
#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             #v4, \
                                             #v5, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3, \
                                             v4, \
                                             v5), on_failure)

// 5-ary predicate assertion macros.
#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)



}  // namespace testing

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_

namespace testing {

// The abstract class that all tests inherit from.
//
// In Google Test, a unit test program contains one or many TestSuites, and
// each TestSuite contains one or many Tests.
//
// When you define a test using the TEST macro, you don't need to
// explicitly derive from Test - the TEST macro automatically does
// this for you.
//
// The only time you derive from Test is when defining a test fixture
// to be used in a TEST_F.  For example:
//
//   class FooTest : public testing::Test {
//    protected:
//     void SetUp() override { ... }
//     void TearDown() override { ... }
//     ...
//   };
//
//   TEST_F(FooTest, Bar) { ... }
//   TEST_F(FooTest, Baz) { ... }
//
// Test is not copyable.
class GTEST_API_ Test {
 public:
  friend class TestInfo;

  // The d'tor is virtual as we intend to inherit from Test.
  virtual ~Test();

  // Sets up the stuff shared by all tests in this test suite.
  //
  // Google Test will call Foo::SetUpTestSuite() before running the first
  // test in test suite Foo.  Hence a sub-class can define its own
  // SetUpTestSuite() method to shadow the one defined in the super
  // class.
  static void SetUpTestSuite() {}

  // Tears down the stuff shared by all tests in this test suite.
  //
  // Google Test will call Foo::TearDownTestSuite() after running the last
  // test in test suite Foo.  Hence a sub-class can define its own
  // TearDownTestSuite() method to shadow the one defined in the super
  // class.
  static void TearDownTestSuite() {}

  // Legacy API is deprecated but still available. Use SetUpTestSuite and
  // TearDownTestSuite instead.
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  static void TearDownTestCase() {}
  static void SetUpTestCase() {}
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Returns true if and only if the current test has a fatal failure.
  static bool HasFatalFailure();

  // Returns true if and only if the current test has a non-fatal failure.
  static bool HasNonfatalFailure();

  // Returns true if and only if the current test was skipped.
  static bool IsSkipped();

  // Returns true if and only if the current test has a (either fatal or
  // non-fatal) failure.
  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }

  // Logs a property for the current test, test suite, or for the entire
  // invocation of the test program when used outside of the context of a
  // test suite.  Only the last value for a given key is remembered.  These
  // are public static so they can be called from utility functions that are
  // not members of the test fixture.  Calls to RecordProperty made during
  // lifespan of the test (from the moment its constructor starts to the
  // moment its destructor finishes) will be output in XML as attributes of
  // the <testcase> element.  Properties recorded from fixture's
  // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
  // corresponding <testsuite> element.  Calls to RecordProperty made in the
  // global context (before or after invocation of RUN_ALL_TESTS and from
  // SetUp/TearDown method of Environment objects registered with Google
  // Test) will be output as attributes of the <testsuites> element.
  static void RecordProperty(const std::string& key, const std::string& value);
  static void RecordProperty(const std::string& key, int value);

 protected:
  // Creates a Test object.
  Test();

  // Sets up the test fixture.
  virtual void SetUp();

  // Tears down the test fixture.
  virtual void TearDown();

 private:
  // Returns true if and only if the current test has the same fixture class
  // as the first test in the current test suite.
  static bool HasSameFixtureClass();

  // Runs the test after the test fixture has been set up.
  //
  // A sub-class must implement this to define the test logic.
  //
  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
  // Instead, use the TEST or TEST_F macro.
  virtual void TestBody() = 0;

  // Sets up, executes, and tears down the test.
  void Run();

  // Deletes self.  We deliberately pick an unusual name for this
  // internal method to avoid clashing with names used in user TESTs.
  void DeleteSelf_() { delete this; }

  const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;

  // Often a user misspells SetUp() as Setup() and spends a long time
  // wondering why it is never called by Google Test.  The declaration of
  // the following method is solely for catching such an error at
  // compile time:
  //
  //   - The return type is deliberately chosen to be not void, so it
  //   will be a conflict if void Setup() is declared in the user's
  //   test fixture.
  //
  //   - This method is private, so it will be another compiler error
  //   if the method is called from the user's test fixture.
  //
  // DO NOT OVERRIDE THIS FUNCTION.
  //
  // If you see an error about overriding the following function or
  // about it being private, you have mis-spelled SetUp() as Setup().
  struct Setup_should_be_spelled_SetUp {};
  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }

  // We disallow copying Tests.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
};

typedef internal::TimeInMillis TimeInMillis;

// A copyable object representing a user specified test property which can be
// output as a key/value string pair.
//
// Don't inherit from TestProperty as its destructor is not virtual.
class TestProperty {
 public:
  // C'tor.  TestProperty does NOT have a default constructor.
  // Always use this constructor (with parameters) to create a
  // TestProperty object.
  TestProperty(const std::string& a_key, const std::string& a_value) :
    key_(a_key), value_(a_value) {
  }

  // Gets the user supplied key.
  const char* key() const {
    return key_.c_str();
  }

  // Gets the user supplied value.
  const char* value() const {
    return value_.c_str();
  }

  // Sets a new value, overriding the one supplied in the constructor.
  void SetValue(const std::string& new_value) {
    value_ = new_value;
  }

 private:
  // The key supplied by the user.
  std::string key_;
  // The value supplied by the user.
  std::string value_;
};

// The result of a single Test.  This includes a list of
// TestPartResults, a list of TestProperties, a count of how many
// death tests there are in the Test, and how much time it took to run
// the Test.
//
// TestResult is not copyable.
class GTEST_API_ TestResult {
 public:
  // Creates an empty TestResult.
  TestResult();

  // D'tor.  Do not inherit from TestResult.
  ~TestResult();

  // Gets the number of all test parts.  This is the sum of the number
  // of successful test parts and the number of failed test parts.
  int total_part_count() const;

  // Returns the number of the test properties.
  int test_property_count() const;

  // Returns true if and only if the test passed (i.e. no test part failed).
  bool Passed() const { return !Skipped() && !Failed(); }

  // Returns true if and only if the test was skipped.
  bool Skipped() const;

  // Returns true if and only if the test failed.
  bool Failed() const;

  // Returns true if and only if the test fatally failed.
  bool HasFatalFailure() const;

  // Returns true if and only if the test has a non-fatal failure.
  bool HasNonfatalFailure() const;

  // Returns the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const { return elapsed_time_; }

  // Gets the time of the test case start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const { return start_timestamp_; }

  // Returns the i-th test part result among all the results. i can range from 0
  // to total_part_count() - 1. If i is not in that range, aborts the program.
  const TestPartResult& GetTestPartResult(int i) const;

  // Returns the i-th test property. i can range from 0 to
  // test_property_count() - 1. If i is not in that range, aborts the
  // program.
  const TestProperty& GetTestProperty(int i) const;

 private:
  friend class TestInfo;
  friend class TestSuite;
  friend class UnitTest;
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::ExecDeathTest;
  friend class internal::TestResultAccessor;
  friend class internal::UnitTestImpl;
  friend class internal::WindowsDeathTest;
  friend class internal::FuchsiaDeathTest;

  // Gets the vector of TestPartResults.
  const std::vector<TestPartResult>& test_part_results() const {
    return test_part_results_;
  }

  // Gets the vector of TestProperties.
  const std::vector<TestProperty>& test_properties() const {
    return test_properties_;
  }

  // Sets the start time.
  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }

  // Sets the elapsed time.
  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }

  // Adds a test property to the list. The property is validated and may add
  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
  // key names). If a property is already recorded for the same key, the
  // value will be updated, rather than storing multiple values for the same
  // key.  xml_element specifies the element for which the property is being
  // recorded and is used for validation.
  void RecordProperty(const std::string& xml_element,
                      const TestProperty& test_property);

  // Adds a failure if the key is a reserved attribute of Google Test
  // testsuite tags.  Returns true if the property is valid.
  // FIXME: Validate attribute names are legal and human readable.
  static bool ValidateTestProperty(const std::string& xml_element,
                                   const TestProperty& test_property);

  // Adds a test part result to the list.
  void AddTestPartResult(const TestPartResult& test_part_result);

  // Returns the death test count.
  int death_test_count() const { return death_test_count_; }

  // Increments the death test count, returning the new count.
  int increment_death_test_count() { return ++death_test_count_; }

  // Clears the test part results.
  void ClearTestPartResults();

  // Clears the object.
  void Clear();

  // Protects mutable state of the property vector and of owned
  // properties, whose values may be updated.
  internal::Mutex test_properties_mutex_;

  // The vector of TestPartResults
  std::vector<TestPartResult> test_part_results_;
  // The vector of TestProperties
  std::vector<TestProperty> test_properties_;
  // Running count of death tests.
  int death_test_count_;
  // The start time, in milliseconds since UNIX Epoch.
  TimeInMillis start_timestamp_;
  // The elapsed time, in milliseconds.
  TimeInMillis elapsed_time_;

  // We disallow copying TestResult.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
};  // class TestResult

// A TestInfo object stores the following information about a test:
//
//   Test suite name
//   Test name
//   Whether the test should be run
//   A function pointer that creates the test object when invoked
//   Test result
//
// The constructor of TestInfo registers itself with the UnitTest
// singleton such that the RUN_ALL_TESTS() macro knows which tests to
// run.
class GTEST_API_ TestInfo {
 public:
  // Destructs a TestInfo object.  This function is not virtual, so
  // don't inherit from TestInfo.
  ~TestInfo();

  // Returns the test suite name.
  const char* test_suite_name() const { return test_suite_name_.c_str(); }

// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  const char* test_case_name() const { return test_suite_name(); }
#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Returns the test name.
  const char* name() const { return name_.c_str(); }

  // Returns the name of the parameter type, or NULL if this is not a typed
  // or a type-parameterized test.
  const char* type_param() const {
    if (type_param_.get() != nullptr) return type_param_->c_str();
    return nullptr;
  }

  // Returns the text representation of the value parameter, or NULL if this
  // is not a value-parameterized test.
  const char* value_param() const {
    if (value_param_.get() != nullptr) return value_param_->c_str();
    return nullptr;
  }

  // Returns the file name where this test is defined.
  const char* file() const { return location_.file.c_str(); }

  // Returns the line where this test is defined.
  int line() const { return location_.line; }

  // Return true if this test should not be run because it's in another shard.
  bool is_in_another_shard() const { return is_in_another_shard_; }

  // Returns true if this test should run, that is if the test is not
  // disabled (or it is disabled but the also_run_disabled_tests flag has
  // been specified) and its full name matches the user-specified filter.
  //
  // Google Test allows the user to filter the tests by their full names.
  // The full name of a test Bar in test suite Foo is defined as
  // "Foo.Bar".  Only the tests that match the filter will run.
  //
  // A filter is a colon-separated list of glob (not regex) patterns,
  // optionally followed by a '-' and a colon-separated list of
  // negative patterns (tests to exclude).  A test is run if it
  // matches one of the positive patterns and does not match any of
  // the negative patterns.
  //
  // For example, *A*:Foo.* is a filter that matches any string that
  // contains the character 'A' or starts with "Foo.".
  bool should_run() const { return should_run_; }

  // Returns true if and only if this test will appear in the XML report.
  bool is_reportable() const {
    // The XML report includes tests matching the filter, excluding those
    // run in other shards.
    return matches_filter_ && !is_in_another_shard_;
  }

  // Returns the result of the test.
  const TestResult* result() const { return &result_; }

 private:
#if GTEST_HAS_DEATH_TEST
  friend class internal::DefaultDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST
  friend class Test;
  friend class TestSuite;
  friend class internal::UnitTestImpl;
  friend class internal::StreamingListenerTest;
  friend TestInfo* internal::MakeAndRegisterTestInfo(
      const char* test_suite_name, const char* name, const char* type_param,
      const char* value_param, internal::CodeLocation code_location,
      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
      internal::TearDownTestSuiteFunc tear_down_tc,
      internal::TestFactoryBase* factory);

  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
  TestInfo(const std::string& test_suite_name, const std::string& name,
           const char* a_type_param,   // NULL if not a type-parameterized test
           const char* a_value_param,  // NULL if not a value-parameterized test
           internal::CodeLocation a_code_location,
           internal::TypeId fixture_class_id,
           internal::TestFactoryBase* factory);

  // Increments the number of death tests encountered in this test so
  // far.
  int increment_death_test_count() {
    return result_.increment_death_test_count();
  }

  // Creates the test object, runs it, records its result, and then
  // deletes it.
  void Run();

  // Skip and records the test result for this object.
  void Skip();

  static void ClearTestResult(TestInfo* test_info) {
    test_info->result_.Clear();
  }

  // These fields are immutable properties of the test.
  const std::string test_suite_name_;    // test suite name
  const std::string name_;               // Test name
  // Name of the parameter type, or NULL if this is not a typed or a
  // type-parameterized test.
  const std::unique_ptr<const ::std::string> type_param_;
  // Text representation of the value parameter, or NULL if this is not a
  // value-parameterized test.
  const std::unique_ptr<const ::std::string> value_param_;
  internal::CodeLocation location_;
  const internal::TypeId fixture_class_id_;  // ID of the test fixture class
  bool should_run_;           // True if and only if this test should run
  bool is_disabled_;          // True if and only if this test is disabled
  bool matches_filter_;       // True if this test matches the
                              // user-specified filter.
  bool is_in_another_shard_;  // Will be run in another shard.
  internal::TestFactoryBase* const factory_;  // The factory that creates
                                              // the test object

  // This field is mutable and needs to be reset before running the
  // test for the second time.
  TestResult result_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
};

// A test suite, which consists of a vector of TestInfos.
//
// TestSuite is not copyable.
class GTEST_API_ TestSuite {
 public:
  // Creates a TestSuite with the given name.
  //
  // TestSuite does NOT have a default constructor.  Always use this
  // constructor to create a TestSuite object.
  //
  // Arguments:
  //
  //   name:         name of the test suite
  //   a_type_param: the name of the test's type parameter, or NULL if
  //                 this is not a type-parameterized test.
  //   set_up_tc:    pointer to the function that sets up the test suite
  //   tear_down_tc: pointer to the function that tears down the test suite
  TestSuite(const char* name, const char* a_type_param,
            internal::SetUpTestSuiteFunc set_up_tc,
            internal::TearDownTestSuiteFunc tear_down_tc);

  // Destructor of TestSuite.
  virtual ~TestSuite();

  // Gets the name of the TestSuite.
  const char* name() const { return name_.c_str(); }

  // Returns the name of the parameter type, or NULL if this is not a
  // type-parameterized test suite.
  const char* type_param() const {
    if (type_param_.get() != nullptr) return type_param_->c_str();
    return nullptr;
  }

  // Returns true if any test in this test suite should run.
  bool should_run() const { return should_run_; }

  // Gets the number of successful tests in this test suite.
  int successful_test_count() const;

  // Gets the number of skipped tests in this test suite.
  int skipped_test_count() const;

  // Gets the number of failed tests in this test suite.
  int failed_test_count() const;

  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

  // Gets the number of disabled tests in this test suite.
  int disabled_test_count() const;

  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

  // Get the number of tests in this test suite that should run.
  int test_to_run_count() const;

  // Gets the number of all tests in this test suite.
  int total_test_count() const;

  // Returns true if and only if the test suite passed.
  bool Passed() const { return !Failed(); }

  // Returns true if and only if the test suite failed.
  bool Failed() const {
    return failed_test_count() > 0 || ad_hoc_test_result().Failed();
  }

  // Returns the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const { return elapsed_time_; }

  // Gets the time of the test suite start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const { return start_timestamp_; }

  // Returns the i-th test among all the tests. i can range from 0 to
  // total_test_count() - 1. If i is not in that range, returns NULL.
  const TestInfo* GetTestInfo(int i) const;

  // Returns the TestResult that holds test properties recorded during
  // execution of SetUpTestSuite and TearDownTestSuite.
  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }

 private:
  friend class Test;
  friend class internal::UnitTestImpl;

  // Gets the (mutable) vector of TestInfos in this TestSuite.
  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }

  // Gets the (immutable) vector of TestInfos in this TestSuite.
  const std::vector<TestInfo*>& test_info_list() const {
    return test_info_list_;
  }

  // Returns the i-th test among all the tests. i can range from 0 to
  // total_test_count() - 1. If i is not in that range, returns NULL.
  TestInfo* GetMutableTestInfo(int i);

  // Sets the should_run member.
  void set_should_run(bool should) { should_run_ = should; }

  // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
  // destruction of the TestSuite object.
  void AddTestInfo(TestInfo * test_info);

  // Clears the results of all tests in this test suite.
  void ClearResult();

  // Clears the results of all tests in the given test suite.
  static void ClearTestSuiteResult(TestSuite* test_suite) {
    test_suite->ClearResult();
  }

  // Runs every test in this TestSuite.
  void Run();

  // Skips the execution of tests under this TestSuite
  void Skip();

  // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
  // for catching exceptions thrown from SetUpTestSuite().
  void RunSetUpTestSuite() {
    if (set_up_tc_ != nullptr) {
      (*set_up_tc_)();
    }
  }

  // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
  // needed for catching exceptions thrown from TearDownTestSuite().
  void RunTearDownTestSuite() {
    if (tear_down_tc_ != nullptr) {
      (*tear_down_tc_)();
    }
  }

  // Returns true if and only if test passed.
  static bool TestPassed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Passed();
  }

  // Returns true if and only if test skipped.
  static bool TestSkipped(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Skipped();
  }

  // Returns true if and only if test failed.
  static bool TestFailed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Failed();
  }

  // Returns true if and only if the test is disabled and will be reported in
  // the XML report.
  static bool TestReportableDisabled(const TestInfo* test_info) {
    return test_info->is_reportable() && test_info->is_disabled_;
  }

  // Returns true if and only if test is disabled.
  static bool TestDisabled(const TestInfo* test_info) {
    return test_info->is_disabled_;
  }

  // Returns true if and only if this test will appear in the XML report.
  static bool TestReportable(const TestInfo* test_info) {
    return test_info->is_reportable();
  }

  // Returns true if the given test should run.
  static bool ShouldRunTest(const TestInfo* test_info) {
    return test_info->should_run();
  }

  // Shuffles the tests in this test suite.
  void ShuffleTests(internal::Random* random);

  // Restores the test order to before the first shuffle.
  void UnshuffleTests();

  // Name of the test suite.
  std::string name_;
  // Name of the parameter type, or NULL if this is not a typed or a
  // type-parameterized test.
  const std::unique_ptr<const ::std::string> type_param_;
  // The vector of TestInfos in their original order.  It owns the
  // elements in the vector.
  std::vector<TestInfo*> test_info_list_;
  // Provides a level of indirection for the test list to allow easy
  // shuffling and restoring the test order.  The i-th element in this
  // vector is the index of the i-th test in the shuffled test list.
  std::vector<int> test_indices_;
  // Pointer to the function that sets up the test suite.
  internal::SetUpTestSuiteFunc set_up_tc_;
  // Pointer to the function that tears down the test suite.
  internal::TearDownTestSuiteFunc tear_down_tc_;
  // True if and only if any test in this test suite should run.
  bool should_run_;
  // The start time, in milliseconds since UNIX Epoch.
  TimeInMillis start_timestamp_;
  // Elapsed time, in milliseconds.
  TimeInMillis elapsed_time_;
  // Holds test properties recorded during execution of SetUpTestSuite and
  // TearDownTestSuite.
  TestResult ad_hoc_test_result_;

  // We disallow copying TestSuites.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
};

// An Environment object is capable of setting up and tearing down an
// environment.  You should subclass this to define your own
// environment(s).
//
// An Environment object does the set-up and tear-down in virtual
// methods SetUp() and TearDown() instead of the constructor and the
// destructor, as:
//
//   1. You cannot safely throw from a destructor.  This is a problem
//      as in some cases Google Test is used where exceptions are enabled, and
//      we may want to implement ASSERT_* using exceptions where they are
//      available.
//   2. You cannot use ASSERT_* directly in a constructor or
//      destructor.
class Environment {
 public:
  // The d'tor is virtual as we need to subclass Environment.
  virtual ~Environment() {}

  // Override this to define how to set up the environment.
  virtual void SetUp() {}

  // Override this to define how to tear down the environment.
  virtual void TearDown() {}
 private:
  // If you see an error about overriding the following function or
  // about it being private, you have mis-spelled SetUp() as Setup().
  struct Setup_should_be_spelled_SetUp {};
  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
};

#if GTEST_HAS_EXCEPTIONS

// Exception which can be thrown from TestEventListener::OnTestPartResult.
class GTEST_API_ AssertionException
    : public internal::GoogleTestFailureException {
 public:
  explicit AssertionException(const TestPartResult& result)
      : GoogleTestFailureException(result) {}
};

#endif  // GTEST_HAS_EXCEPTIONS

// The interface for tracing execution of tests. The methods are organized in
// the order the corresponding events are fired.
class TestEventListener {
 public:
  virtual ~TestEventListener() {}

  // Fired before any test activity starts.
  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;

  // Fired before each iteration of tests starts.  There may be more than
  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
  // index, starting from 0.
  virtual void OnTestIterationStart(const UnitTest& unit_test,
                                    int iteration) = 0;

  // Fired before environment set-up for each iteration of tests starts.
  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;

  // Fired after environment set-up for each iteration of tests ends.
  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;

  // Fired before the test suite starts.
  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}

  //  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Fired before the test starts.
  virtual void OnTestStart(const TestInfo& test_info) = 0;

  // Fired after a failed assertion or a SUCCEED() invocation.
  // If you want to throw an exception from this function to skip to the next
  // TEST, it must be AssertionException defined above, or inherited from it.
  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;

  // Fired after the test ends.
  virtual void OnTestEnd(const TestInfo& test_info) = 0;

  // Fired after the test suite ends.
  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Fired before environment tear-down for each iteration of tests starts.
  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;

  // Fired after environment tear-down for each iteration of tests ends.
  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;

  // Fired after each iteration of tests finishes.
  virtual void OnTestIterationEnd(const UnitTest& unit_test,
                                  int iteration) = 0;

  // Fired after all test activities have ended.
  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
};

// The convenience class for users who need to override just one or two
// methods and are not concerned that a possible change to a signature of
// the methods they override will not be caught during the build.  For
// comments about each method please see the definition of TestEventListener
// above.
class EmptyTestEventListener : public TestEventListener {
 public:
  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationStart(const UnitTest& /*unit_test*/,
                            int /*iteration*/) override {}
  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  void OnTestStart(const TestInfo& /*test_info*/) override {}
  void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
  void OnTestEnd(const TestInfo& /*test_info*/) override {}
  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationEnd(const UnitTest& /*unit_test*/,
                          int /*iteration*/) override {}
  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
};

// TestEventListeners lets users add listeners to track events in Google Test.
class GTEST_API_ TestEventListeners {
 public:
  TestEventListeners();
  ~TestEventListeners();

  // Appends an event listener to the end of the list. Google Test assumes
  // the ownership of the listener (i.e. it will delete the listener when
  // the test program finishes).
  void Append(TestEventListener* listener);

  // Removes the given event listener from the list and returns it.  It then
  // becomes the caller's responsibility to delete the listener. Returns
  // NULL if the listener is not found in the list.
  TestEventListener* Release(TestEventListener* listener);

  // Returns the standard listener responsible for the default console
  // output.  Can be removed from the listeners list to shut down default
  // console output.  Note that removing this object from the listener list
  // with Release transfers its ownership to the caller and makes this
  // function return NULL the next time.
  TestEventListener* default_result_printer() const {
    return default_result_printer_;
  }

  // Returns the standard listener responsible for the default XML output
  // controlled by the --gtest_output=xml flag.  Can be removed from the
  // listeners list by users who want to shut down the default XML output
  // controlled by this flag and substitute it with custom one.  Note that
  // removing this object from the listener list with Release transfers its
  // ownership to the caller and makes this function return NULL the next
  // time.
  TestEventListener* default_xml_generator() const {
    return default_xml_generator_;
  }

 private:
  friend class TestSuite;
  friend class TestInfo;
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::NoExecDeathTest;
  friend class internal::TestEventListenersAccessor;
  friend class internal::UnitTestImpl;

  // Returns repeater that broadcasts the TestEventListener events to all
  // subscribers.
  TestEventListener* repeater();

  // Sets the default_result_printer attribute to the provided listener.
  // The listener is also added to the listener list and previous
  // default_result_printer is removed from it and deleted. The listener can
  // also be NULL in which case it will not be added to the list. Does
  // nothing if the previous and the current listener objects are the same.
  void SetDefaultResultPrinter(TestEventListener* listener);

  // Sets the default_xml_generator attribute to the provided listener.  The
  // listener is also added to the listener list and previous
  // default_xml_generator is removed from it and deleted. The listener can
  // also be NULL in which case it will not be added to the list. Does
  // nothing if the previous and the current listener objects are the same.
  void SetDefaultXmlGenerator(TestEventListener* listener);

  // Controls whether events will be forwarded by the repeater to the
  // listeners in the list.
  bool EventForwardingEnabled() const;
  void SuppressEventForwarding();

  // The actual list of listeners.
  internal::TestEventRepeater* repeater_;
  // Listener responsible for the standard result output.
  TestEventListener* default_result_printer_;
  // Listener responsible for the creation of the XML output file.
  TestEventListener* default_xml_generator_;

  // We disallow copying TestEventListeners.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
};

// A UnitTest consists of a vector of TestSuites.
//
// This is a singleton class.  The only instance of UnitTest is
// created when UnitTest::GetInstance() is first called.  This
// instance is never deleted.
//
// UnitTest is not copyable.
//
// This class is thread-safe as long as the methods are called
// according to their specification.
class GTEST_API_ UnitTest {
 public:
  // Gets the singleton UnitTest object.  The first time this method
  // is called, a UnitTest object is constructed and returned.
  // Consecutive calls will return the same object.
  static UnitTest* GetInstance();

  // Runs all tests in this UnitTest object and prints the result.
  // Returns 0 if successful, or 1 otherwise.
  //
  // This method can only be called from the main thread.
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
  int Run() GTEST_MUST_USE_RESULT_;

  // Returns the working directory when the first TEST() or TEST_F()
  // was executed.  The UnitTest object owns the string.
  const char* original_working_dir() const;

  // Returns the TestSuite object for the test that's currently running,
  // or NULL if no test is running.
  const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);

// Legacy API is still available but deprecated
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
#endif

  // Returns the TestInfo object for the test that's currently running,
  // or NULL if no test is running.
  const TestInfo* current_test_info() const
      GTEST_LOCK_EXCLUDED_(mutex_);

  // Returns the random seed used at the start of the current test run.
  int random_seed() const;

  // Returns the ParameterizedTestSuiteRegistry object used to keep track of
  // value-parameterized tests and instantiate and register them.
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
      GTEST_LOCK_EXCLUDED_(mutex_);

  // Gets the number of successful test suites.
  int successful_test_suite_count() const;

  // Gets the number of failed test suites.
  int failed_test_suite_count() const;

  // Gets the number of all test suites.
  int total_test_suite_count() const;

  // Gets the number of all test suites that contain at least one test
  // that should run.
  int test_suite_to_run_count() const;

  //  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  int successful_test_case_count() const;
  int failed_test_case_count() const;
  int total_test_case_count() const;
  int test_case_to_run_count() const;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Gets the number of successful tests.
  int successful_test_count() const;

  // Gets the number of skipped tests.
  int skipped_test_count() const;

  // Gets the number of failed tests.
  int failed_test_count() const;

  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

  // Gets the number of disabled tests.
  int disabled_test_count() const;

  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

  // Gets the number of all tests.
  int total_test_count() const;

  // Gets the number of tests that should run.
  int test_to_run_count() const;

  // Gets the time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const;

  // Gets the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const;

  // Returns true if and only if the unit test passed (i.e. all test suites
  // passed).
  bool Passed() const;

  // Returns true if and only if the unit test failed (i.e. some test suite
  // failed or something outside of all tests failed).
  bool Failed() const;

  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  const TestSuite* GetTestSuite(int i) const;

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  const TestCase* GetTestCase(int i) const;
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Returns the TestResult containing information on test failures and
  // properties logged outside of individual test suites.
  const TestResult& ad_hoc_test_result() const;

  // Returns the list of event listeners that can be used to track events
  // inside Google Test.
  TestEventListeners& listeners();

 private:
  // Registers and returns a global test environment.  When a test
  // program is run, all global test environments will be set-up in
  // the order they were registered.  After all tests in the program
  // have finished, all global test environments will be torn-down in
  // the *reverse* order they were registered.
  //
  // The UnitTest object takes ownership of the given environment.
  //
  // This method can only be called from the main thread.
  Environment* AddEnvironment(Environment* env);

  // Adds a TestPartResult to the current TestResult object.  All
  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
  // eventually call this to report their results.  The user code
  // should use the assertion macros instead of calling this directly.
  void AddTestPartResult(TestPartResult::Type result_type,
                         const char* file_name,
                         int line_number,
                         const std::string& message,
                         const std::string& os_stack_trace)
      GTEST_LOCK_EXCLUDED_(mutex_);

  // Adds a TestProperty to the current TestResult object when invoked from
  // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
  // from SetUpTestSuite or TearDownTestSuite, or to the global property set
  // when invoked elsewhere.  If the result already contains a property with
  // the same key, the value will be updated.
  void RecordProperty(const std::string& key, const std::string& value);

  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  TestSuite* GetMutableTestSuite(int i);

  // Accessors for the implementation object.
  internal::UnitTestImpl* impl() { return impl_; }
  const internal::UnitTestImpl* impl() const { return impl_; }

  // These classes and functions are friends as they need to access private
  // members of UnitTest.
  friend class ScopedTrace;
  friend class Test;
  friend class internal::AssertHelper;
  friend class internal::StreamingListenerTest;
  friend class internal::UnitTestRecordPropertyTestHelper;
  friend Environment* AddGlobalTestEnvironment(Environment* env);
  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
  friend void internal::ReportFailureInUnknownLocation(
      TestPartResult::Type result_type,
      const std::string& message);

  // Creates an empty UnitTest.
  UnitTest();

  // D'tor
  virtual ~UnitTest();

  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
  // Google Test trace stack.
  void PushGTestTrace(const internal::TraceInfo& trace)
      GTEST_LOCK_EXCLUDED_(mutex_);

  // Pops a trace from the per-thread Google Test trace stack.
  void PopGTestTrace()
      GTEST_LOCK_EXCLUDED_(mutex_);

  // Protects mutable state in *impl_.  This is mutable as some const
  // methods need to lock it too.
  mutable internal::Mutex mutex_;

  // Opaque implementation object.  This field is never changed once
  // the object is constructed.  We don't mark it as const here, as
  // doing so will cause a warning in the constructor of UnitTest.
  // Mutable state in *impl_ is protected by mutex_.
  internal::UnitTestImpl* impl_;

  // We disallow copying UnitTest.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
};

// A convenient wrapper for adding an environment for the test
// program.
//
// You should call this before RUN_ALL_TESTS() is called, probably in
// main().  If you use gtest_main, you need to call this before main()
// starts for it to take effect.  For example, you can define a global
// variable like this:
//
//   testing::Environment* const foo_env =
//       testing::AddGlobalTestEnvironment(new FooEnvironment);
//
// However, we strongly recommend you to write your own main() and
// call AddGlobalTestEnvironment() there, as relying on initialization
// of global variables makes the code harder to read and may cause
// problems when you register multiple environments from different
// translation units and the environments have dependencies among them
// (remember that the compiler doesn't guarantee the order in which
// global variables from different translation units are initialized).
inline Environment* AddGlobalTestEnvironment(Environment* env) {
  return UnitTest::GetInstance()->AddEnvironment(env);
}

// Initializes Google Test.  This must be called before calling
// RUN_ALL_TESTS().  In particular, it parses a command line for the
// flags that Google Test recognizes.  Whenever a Google Test flag is
// seen, it is removed from argv, and *argc is decremented.
//
// No value is returned.  Instead, the Google Test flag variables are
// updated.
//
// Calling the function for the second time has no user-visible effect.
GTEST_API_ void InitGoogleTest(int* argc, char** argv);

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);

// This overloaded version can be used on Arduino/embedded platforms where
// there is no argc/argv.
GTEST_API_ void InitGoogleTest();

namespace internal {

// Separate the error generating code from the code path to reduce the stack
// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
// when calling EXPECT_* in a tight loop.
template <typename T1, typename T2>
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                                   const char* rhs_expression,
                                   const T1& lhs, const T2& rhs) {
  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// This block of code defines operator==/!=
// to block lexical scope lookup.
// It prevents using invalid operator==/!= defined at namespace scope.
struct faketype {};
inline bool operator==(faketype, faketype) { return true; }
inline bool operator!=(faketype, faketype) { return false; }

// The helper function for {ASSERT|EXPECT}_EQ.
template <typename T1, typename T2>
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            const T1& lhs,
                            const T2& rhs) {
  if (lhs == rhs) {
    return AssertionSuccess();
  }

  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}

class EqHelper {
 public:
  // This templatized version is for the general case.
  template <
      typename T1, typename T2,
      // Disable this overload for cases where one argument is a pointer
      // and the other is the null pointer constant.
      typename std::enable_if<!std::is_integral<T1>::value ||
                              !std::is_pointer<T2>::value>::type* = nullptr>
  static AssertionResult Compare(const char* lhs_expression,
                                 const char* rhs_expression, const T1& lhs,
                                 const T2& rhs) {
    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
  }

  // With this overloaded version, we allow anonymous enums to be used
  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
  // enums can be implicitly cast to BiggestInt.
  //
  // Even though its body looks the same as the above version, we
  // cannot merge the two, as it will make anonymous enums unhappy.
  static AssertionResult Compare(const char* lhs_expression,
                                 const char* rhs_expression,
                                 BiggestInt lhs,
                                 BiggestInt rhs) {
    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
  }

  template <typename T>
  static AssertionResult Compare(
      const char* lhs_expression, const char* rhs_expression,
      // Handle cases where '0' is used as a null pointer literal.
      std::nullptr_t /* lhs */, T* rhs) {
    // We already know that 'lhs' is a null pointer.
    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
                       rhs);
  }
};

// Separate the error generating code from the code path to reduce the stack
// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
// when calling EXPECT_OP in a tight loop.
template <typename T1, typename T2>
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                   const T1& val1, const T2& val2,
                                   const char* op) {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

// A macro for implementing the helper functions needed to implement
// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
// of similar code.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
template <typename T1, typename T2>\
AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                   const T1& val1, const T2& val2) {\
  if (val1 op val2) {\
    return AssertionSuccess();\
  } else {\
    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
  }\
}

// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

// Implements the helper function for {ASSERT|EXPECT}_NE
GTEST_IMPL_CMP_HELPER_(NE, !=)
// Implements the helper function for {ASSERT|EXPECT}_LE
GTEST_IMPL_CMP_HELPER_(LE, <=)
// Implements the helper function for {ASSERT|EXPECT}_LT
GTEST_IMPL_CMP_HELPER_(LT, <)
// Implements the helper function for {ASSERT|EXPECT}_GE
GTEST_IMPL_CMP_HELPER_(GE, >=)
// Implements the helper function for {ASSERT|EXPECT}_GT
GTEST_IMPL_CMP_HELPER_(GT, >)

#undef GTEST_IMPL_CMP_HELPER_

// The helper function for {ASSERT|EXPECT}_STREQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                          const char* s2_expression,
                                          const char* s1,
                                          const char* s2);

// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
                                              const char* s2_expression,
                                              const char* s1,
                                              const char* s2);

// The helper function for {ASSERT|EXPECT}_STRNE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                          const char* s2_expression,
                                          const char* s1,
                                          const char* s2);

// The helper function for {ASSERT|EXPECT}_STRCASENE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                              const char* s2_expression,
                                              const char* s1,
                                              const char* s2);


// Helper function for *_STREQ on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                          const char* s2_expression,
                                          const wchar_t* s1,
                                          const wchar_t* s2);

// Helper function for *_STRNE on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                          const char* s2_expression,
                                          const wchar_t* s1,
                                          const wchar_t* s2);

}  // namespace internal

// IsSubstring() and IsNotSubstring() are intended to be used as the
// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
// themselves.  They check whether needle is a substring of haystack
// (NULL is considered a substring of itself only), and return an
// appropriate error message when they fail.
//
// The {needle,haystack}_expr arguments are the stringified
// expressions that generated the two real arguments.
GTEST_API_ AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
GTEST_API_ AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
GTEST_API_ AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
GTEST_API_ AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
GTEST_API_ AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack);
GTEST_API_ AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack);

#if GTEST_HAS_STD_WSTRING
GTEST_API_ AssertionResult IsSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack);
GTEST_API_ AssertionResult IsNotSubstring(
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack);
#endif  // GTEST_HAS_STD_WSTRING

namespace internal {

// Helper template function for comparing floating-points.
//
// Template parameter:
//
//   RawType: the raw floating-point type (either float or double)
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename RawType>
AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
                                         const char* rhs_expression,
                                         RawType lhs_value,
                                         RawType rhs_value) {
  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);

  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  ::std::stringstream lhs_ss;
  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << lhs_value;

  ::std::stringstream rhs_ss;
  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << rhs_value;

  return EqFailure(lhs_expression,
                   rhs_expression,
                   StringStreamToString(&lhs_ss),
                   StringStreamToString(&rhs_ss),
                   false);
}

// Helper function for implementing ASSERT_NEAR.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
                                                const char* expr2,
                                                const char* abs_error_expr,
                                                double val1,
                                                double val2,
                                                double abs_error);

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
// A class that enables one to stream messages to assertion macros
class GTEST_API_ AssertHelper {
 public:
  // Constructor.
  AssertHelper(TestPartResult::Type type,
               const char* file,
               int line,
               const char* message);
  ~AssertHelper();

  // Message assignment is a semantic trick to enable assertion
  // streaming; see the GTEST_MESSAGE_ macro below.
  void operator=(const Message& message) const;

 private:
  // We put our data in a struct so that the size of the AssertHelper class can
  // be as small as possible.  This is important because gcc is incapable of
  // re-using stack space even for temporary variables, so every EXPECT_EQ
  // reserves stack space for another AssertHelper.
  struct AssertHelperData {
    AssertHelperData(TestPartResult::Type t,
                     const char* srcfile,
                     int line_num,
                     const char* msg)
        : type(t), file(srcfile), line(line_num), message(msg) { }

    TestPartResult::Type const type;
    const char* const file;
    int const line;
    std::string const message;

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
  };

  AssertHelperData* const data_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
};

}  // namespace internal

// The pure interface class that all value-parameterized tests inherit from.
// A value-parameterized class must inherit from both ::testing::Test and
// ::testing::WithParamInterface. In most cases that just means inheriting
// from ::testing::TestWithParam, but more complicated test hierarchies
// may need to inherit from Test and WithParamInterface at different levels.
//
// This interface has support for accessing the test parameter value via
// the GetParam() method.
//
// Use it with one of the parameter generator defining functions, like Range(),
// Values(), ValuesIn(), Bool(), and Combine().
//
// class FooTest : public ::testing::TestWithParam<int> {
//  protected:
//   FooTest() {
//     // Can use GetParam() here.
//   }
//   ~FooTest() override {
//     // Can use GetParam() here.
//   }
//   void SetUp() override {
//     // Can use GetParam() here.
//   }
//   void TearDown override {
//     // Can use GetParam() here.
//   }
// };
// TEST_P(FooTest, DoesBar) {
//   // Can use GetParam() method here.
//   Foo foo;
//   ASSERT_TRUE(foo.DoesBar(GetParam()));
// }
// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));

template <typename T>
class WithParamInterface {
 public:
  typedef T ParamType;
  virtual ~WithParamInterface() {}

  // The current parameter value. Is also available in the test fixture's
  // constructor.
  static const ParamType& GetParam() {
    GTEST_CHECK_(parameter_ != nullptr)
        << "GetParam() can only be called inside a value-parameterized test "
        << "-- did you intend to write TEST_P instead of TEST_F?";
    return *parameter_;
  }

 private:
  // Sets parameter value. The caller is responsible for making sure the value
  // remains alive and unchanged throughout the current test.
  static void SetParam(const ParamType* parameter) {
    parameter_ = parameter;
  }

  // Static value used for accessing parameter during a test lifetime.
  static const ParamType* parameter_;

  // TestClass must be a subclass of WithParamInterface<T> and Test.
  template <class TestClass> friend class internal::ParameterizedTestFactory;
};

template <typename T>
const T* WithParamInterface<T>::parameter_ = nullptr;

// Most value-parameterized classes can ignore the existence of
// WithParamInterface, and can just inherit from ::testing::TestWithParam.

template <typename T>
class TestWithParam : public Test, public WithParamInterface<T> {
};

// Macros for indicating success/failure in test code.

// Skips test in runtime.
// Skipping test aborts current function.
// Skipped tests are neither successful nor failed.
#define GTEST_SKIP() GTEST_SKIP_("")

// ADD_FAILURE unconditionally adds a failure to the current test.
// SUCCEED generates a success - it doesn't automatically make the
// current test successful, as a test is only successful when it has
// no failure.
//
// EXPECT_* verifies that a certain condition is satisfied.  If not,
// it behaves like ADD_FAILURE.  In particular:
//
//   EXPECT_TRUE  verifies that a Boolean condition is true.
//   EXPECT_FALSE verifies that a Boolean condition is false.
//
// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
// that they will also abort the current function on failure.  People
// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
// writing data-driven tests often find themselves using ADD_FAILURE
// and EXPECT_* more.

// Generates a nonfatal failure with a generic message.
#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")

// Generates a nonfatal failure at the given source file location with
// a generic message.
#define ADD_FAILURE_AT(file, line) \
  GTEST_MESSAGE_AT_(file, line, "Failed", \
                    ::testing::TestPartResult::kNonFatalFailure)

// Generates a fatal failure with a generic message.
#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")

// Like GTEST_FAIL(), but at the given source file location.
#define GTEST_FAIL_AT(file, line)         \
  GTEST_MESSAGE_AT_(file, line, "Failed", \
                    ::testing::TestPartResult::kFatalFailure)

// Define this macro to 1 to omit the definition of FAIL(), which is a
// generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_FAIL
# define FAIL() GTEST_FAIL()
#endif

// Generates a success with a generic message.
#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")

// Define this macro to 1 to omit the definition of SUCCEED(), which
// is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_SUCCEED
# define SUCCEED() GTEST_SUCCEED()
#endif

// Macros for testing exceptions.
//
//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
//         Tests that the statement throws the expected exception.
//    * {ASSERT|EXPECT}_NO_THROW(statement):
//         Tests that the statement doesn't throw any exception.
//    * {ASSERT|EXPECT}_ANY_THROW(statement):
//         Tests that the statement throws an exception.

#define EXPECT_THROW(statement, expected_exception) \
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
#define EXPECT_NO_THROW(statement) \
  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define EXPECT_ANY_THROW(statement) \
  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define ASSERT_THROW(statement, expected_exception) \
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
#define ASSERT_NO_THROW(statement) \
  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
#define ASSERT_ANY_THROW(statement) \
  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

// Boolean assertions. Condition can be either a Boolean expression or an
// AssertionResult. For more information on how to use AssertionResult with
// these macros see comments on that class.
#define GTEST_EXPECT_TRUE(condition) \
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_NONFATAL_FAILURE_)
#define GTEST_EXPECT_FALSE(condition) \
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_NONFATAL_FAILURE_)
#define GTEST_ASSERT_TRUE(condition) \
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_FATAL_FAILURE_)
#define GTEST_ASSERT_FALSE(condition) \
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_FATAL_FAILURE_)

// Define these macros to 1 to omit the definition of the corresponding
// EXPECT or ASSERT, which clashes with some users' own code.

#if !GTEST_DONT_DEFINE_EXPECT_TRUE
#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
#endif

#if !GTEST_DONT_DEFINE_EXPECT_FALSE
#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_TRUE
#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_FALSE
#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
#endif

// Macros for testing equalities and inequalities.
//
//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
//
// When they are not, Google Test prints both the tested expressions and
// their actual values.  The values must be compatible built-in types,
// or you will get a compiler error.  By "compatible" we mean that the
// values can be compared by the respective operator.
//
// Note:
//
//   1. It is possible to make a user-defined type work with
//   {ASSERT|EXPECT}_??(), but that requires overloading the
//   comparison operators and is thus discouraged by the Google C++
//   Usage Guide.  Therefore, you are advised to use the
//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
//   equal.
//
//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
//   pointers (in particular, C strings).  Therefore, if you use it
//   with two C strings, you are testing how their locations in memory
//   are related, not how their content is related.  To compare two C
//   strings by content, use {ASSERT|EXPECT}_STR*().
//
//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
//   what the actual value is when it fails, and similarly for the
//   other comparisons.
//
//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
//   evaluate their arguments, which is undefined.
//
//   5. These macros evaluate their arguments exactly once.
//
// Examples:
//
//   EXPECT_NE(Foo(), 5);
//   EXPECT_EQ(a_pointer, NULL);
//   ASSERT_LT(i, array_size);
//   ASSERT_GT(records.size(), 0) << "There is no record left.";

#define EXPECT_EQ(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
#define EXPECT_NE(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
#define EXPECT_LE(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define EXPECT_LT(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define EXPECT_GE(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define EXPECT_GT(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

#define GTEST_ASSERT_EQ(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
#define GTEST_ASSERT_NE(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
#define GTEST_ASSERT_LE(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define GTEST_ASSERT_LT(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define GTEST_ASSERT_GE(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define GTEST_ASSERT_GT(val1, val2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
// ASSERT_XY(), which clashes with some users' own code.

#if !GTEST_DONT_DEFINE_ASSERT_EQ
# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_NE
# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LE
# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LT
# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GE
# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GT
# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
#endif

// C-string Comparisons.  All tests treat NULL and any non-NULL string
// as different.  Two NULLs are equal.
//
//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
//
// For wide or narrow string objects, you can use the
// {ASSERT|EXPECT}_??() macros.
//
// Don't depend on the order in which the arguments are evaluated,
// which is undefined.
//
// These macros evaluate their arguments exactly once.

#define EXPECT_STREQ(s1, s2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
#define EXPECT_STRNE(s1, s2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define EXPECT_STRCASEEQ(s1, s2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
#define EXPECT_STRCASENE(s1, s2)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define ASSERT_STREQ(s1, s2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
#define ASSERT_STRNE(s1, s2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define ASSERT_STRCASEEQ(s1, s2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
#define ASSERT_STRCASENE(s1, s2)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

// Macros for comparing floating-point numbers.
//
//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
//         Tests that two float values are almost equal.
//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
//         Tests that two double values are almost equal.
//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
//         Tests that v1 and v2 are within the given distance to each other.
//
// Google Test uses ULP-based comparison to automatically pick a default
// error bound that is appropriate for the operands.  See the
// FloatingPoint template class in gtest-internal.h if you are
// interested in the implementation details.

#define EXPECT_FLOAT_EQ(val1, val2)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      val1, val2)

#define EXPECT_DOUBLE_EQ(val1, val2)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      val1, val2)

#define ASSERT_FLOAT_EQ(val1, val2)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      val1, val2)

#define ASSERT_DOUBLE_EQ(val1, val2)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      val1, val2)

#define EXPECT_NEAR(val1, val2, abs_error)\
  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

#define ASSERT_NEAR(val1, val2, abs_error)\
  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

// These predicate format functions work on floating-point values, and
// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
//
//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);

// Asserts that val1 is less than, or almost equal to, val2.  Fails
// otherwise.  In particular, it fails if either val1 or val2 is NaN.
GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
                                   float val1, float val2);
GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
                                    double val1, double val2);


#if GTEST_OS_WINDOWS

// Macros that test for HRESULT failure and success, these are only useful
// on Windows, and rely on Windows SDK macros and APIs to compile.
//
//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
//
// When expr unexpectedly fails or succeeds, Google Test prints the
// expected result and the actual result with both a human-readable
// string representation of the error, if available, as well as the
// hex result code.
# define EXPECT_HRESULT_SUCCEEDED(expr) \
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

# define ASSERT_HRESULT_SUCCEEDED(expr) \
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

# define EXPECT_HRESULT_FAILED(expr) \
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

# define ASSERT_HRESULT_FAILED(expr) \
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

#endif  // GTEST_OS_WINDOWS

// Macros that execute statement and check that it doesn't generate new fatal
// failures in the current thread.
//
//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
//
// Examples:
//
//   EXPECT_NO_FATAL_FAILURE(Process());
//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
//
#define ASSERT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
#define EXPECT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

// Causes a trace (including the given source file path and line number,
// and the given message) to be included in every test failure message generated
// by code in the scope of the lifetime of an instance of this class. The effect
// is undone with the destruction of the instance.
//
// The message argument can be anything streamable to std::ostream.
//
// Example:
//   testing::ScopedTrace trace("file.cc", 123, "message");
//
class GTEST_API_ ScopedTrace {
 public:
  // The c'tor pushes the given source file location and message onto
  // a trace stack maintained by Google Test.

  // Template version. Uses Message() to convert the values into strings.
  // Slow, but flexible.
  template <typename T>
  ScopedTrace(const char* file, int line, const T& message) {
    PushTrace(file, line, (Message() << message).GetString());
  }

  // Optimize for some known types.
  ScopedTrace(const char* file, int line, const char* message) {
    PushTrace(file, line, message ? message : "(null)");
  }

  ScopedTrace(const char* file, int line, const std::string& message) {
    PushTrace(file, line, message);
  }

  // The d'tor pops the info pushed by the c'tor.
  //
  // Note that the d'tor is not virtual in order to be efficient.
  // Don't inherit from ScopedTrace!
  ~ScopedTrace();

 private:
  void PushTrace(const char* file, int line, std::string message);

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
                            // c'tor and d'tor.  Therefore it doesn't
                            // need to be used otherwise.

// Causes a trace (including the source file path, the current line
// number, and the given message) to be included in every test failure
// message generated by code in the current scope.  The effect is
// undone when the control leaves the current scope.
//
// The message argument can be anything streamable to std::ostream.
//
// In the implementation, we include the current line number as part
// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
// to appear in the same block - as long as they are on different
// lines.
//
// Assuming that each thread maintains its own stack of traces.
// Therefore, a SCOPED_TRACE() would (correctly) only affect the
// assertions in its own thread.
#define SCOPED_TRACE(message) \
  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
    __FILE__, __LINE__, (message))

// Compile-time assertion for type equality.
// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
// are the same type.  The value it returns is not interesting.
//
// Instead of making StaticAssertTypeEq a class template, we make it a
// function template that invokes a helper class template.  This
// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
// defining objects of that type.
//
// CAVEAT:
//
// When used inside a method of a class template,
// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
// instantiated.  For example, given:
//
//   template <typename T> class Foo {
//    public:
//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
//   };
//
// the code:
//
//   void Test1() { Foo<bool> foo; }
//
// will NOT generate a compiler error, as Foo<bool>::Bar() is never
// actually instantiated.  Instead, you need:
//
//   void Test2() { Foo<bool> foo; foo.Bar(); }
//
// to cause a compiler error.
template <typename T1, typename T2>
constexpr bool StaticAssertTypeEq() noexcept {
  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
  return true;
}

// Defines a test.
//
// The first parameter is the name of the test suite, and the second
// parameter is the name of the test within the test suite.
//
// The convention is to end the test suite name with "Test".  For
// example, a test suite for the Foo class can be named FooTest.
//
// Test code should appear between braces after an invocation of
// this macro.  Example:
//
//   TEST(FooTest, InitializesCorrectly) {
//     Foo foo;
//     EXPECT_TRUE(foo.StatusIsOK());
//   }

// Note that we call GetTestTypeId() instead of GetTypeId<
// ::testing::Test>() here to get the type ID of testing::Test.  This
// is to work around a suspected linker bug when using Google Test as
// a framework on Mac OS X.  The bug causes GetTypeId<
// ::testing::Test>() to return different values depending on whether
// the call is from the Google Test framework itself or from user test
// code.  GetTestTypeId() is guaranteed to always return the same
// value, as it always calls GetTypeId<>() from the Google Test
// framework.
#define GTEST_TEST(test_suite_name, test_name)             \
  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
              ::testing::internal::GetTestTypeId())

// Define this macro to 1 to omit the definition of TEST(), which
// is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_TEST
#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
#endif

// Defines a test that uses a test fixture.
//
// The first parameter is the name of the test fixture class, which
// also doubles as the test suite name.  The second parameter is the
// name of the test within the test suite.
//
// A test fixture class must be declared earlier.  The user should put
// the test code between braces after using this macro.  Example:
//
//   class FooTest : public testing::Test {
//    protected:
//     void SetUp() override { b_.AddElement(3); }
//
//     Foo a_;
//     Foo b_;
//   };
//
//   TEST_F(FooTest, InitializesCorrectly) {
//     EXPECT_TRUE(a_.StatusIsOK());
//   }
//
//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
//     EXPECT_EQ(a_.size(), 0);
//     EXPECT_EQ(b_.size(), 1);
//   }
//
// GOOGLETEST_CM0011 DO NOT DELETE
#if !GTEST_DONT_DEFINE_TEST
#define TEST_F(test_fixture, test_name)\
  GTEST_TEST_(test_fixture, test_name, test_fixture, \
              ::testing::internal::GetTypeId<test_fixture>())
#endif  // !GTEST_DONT_DEFINE_TEST

// Returns a path to temporary directory.
// Tries to determine an appropriate directory for the platform.
GTEST_API_ std::string TempDir();

#ifdef _MSC_VER
#  pragma warning(pop)
#endif

// Dynamically registers a test with the framework.
//
// This is an advanced API only to be used when the `TEST` macros are
// insufficient. The macros should be preferred when possible, as they avoid
// most of the complexity of calling this function.
//
// The `factory` argument is a factory callable (move-constructible) object or
// function pointer that creates a new instance of the Test object. It
// handles ownership to the caller. The signature of the callable is
// `Fixture*()`, where `Fixture` is the test fixture class for the test. All
// tests registered with the same `test_suite_name` must return the same
// fixture type. This is checked at runtime.
//
// The framework will infer the fixture class from the factory and will call
// the `SetUpTestSuite` and `TearDownTestSuite` for it.
//
// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
// undefined.
//
// Use case example:
//
// class MyFixture : public ::testing::Test {
//  public:
//   // All of these optional, just like in regular macro usage.
//   static void SetUpTestSuite() { ... }
//   static void TearDownTestSuite() { ... }
//   void SetUp() override { ... }
//   void TearDown() override { ... }
// };
//
// class MyTest : public MyFixture {
//  public:
//   explicit MyTest(int data) : data_(data) {}
//   void TestBody() override { ... }
//
//  private:
//   int data_;
// };
//
// void RegisterMyTests(const std::vector<int>& values) {
//   for (int v : values) {
//     ::testing::RegisterTest(
//         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
//         std::to_string(v).c_str(),
//         __FILE__, __LINE__,
//         // Important to use the fixture type as the return type here.
//         [=]() -> MyFixture* { return new MyTest(v); });
//   }
// }
// ...
// int main(int argc, char** argv) {
//   std::vector<int> values_to_test = LoadValuesFromConfig();
//   RegisterMyTests(values_to_test);
//   ...
//   return RUN_ALL_TESTS();
// }
//
template <int&... ExplicitParameterBarrier, typename Factory>
TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
                       const char* type_param, const char* value_param,
                       const char* file, int line, Factory factory) {
  using TestT = typename std::remove_pointer<decltype(factory())>::type;

  class FactoryImpl : public internal::TestFactoryBase {
   public:
    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
    Test* CreateTest() override { return factory_(); }

   private:
    Factory factory_;
  };

  return internal::MakeAndRegisterTestInfo(
      test_suite_name, test_name, type_param, value_param,
      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
      new FactoryImpl{std::move(factory)});
}

}  // namespace testing

// Use this function in main() to run all tests.  It returns 0 if all
// tests are successful, or 1 otherwise.
//
// RUN_ALL_TESTS() should be invoked after the command line has been
// parsed by InitGoogleTest().
//
// This function was formerly a macro; thus, it is in the global
// namespace and has an all-caps name.
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;

inline int RUN_ALL_TESTS() {
  return ::testing::UnitTest::GetInstance()->Run();
}

GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_


================================================
FILE: examples/libraries/fmt/test/gtest-extra-test.cc
================================================
// Formatting library for C++ - tests of custom Google Test assertions
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "gtest-extra.h"

#include <gtest/gtest-spi.h>

#include <cstring>
#include <memory>
#include <stdexcept>

#include "fmt/os.h"
#include "util.h"

// Tests that assertion macros evaluate their arguments exactly once.
namespace {
class single_evaluation_test : public ::testing::Test {
 protected:
  single_evaluation_test() {
    p_ = s_;
    a_ = 0;
    b_ = 0;
  }

  static const char* const s_;
  static const char* p_;

  static int a_;
  static int b_;
};
}  // namespace

const char* const single_evaluation_test::s_ = "01234";
const char* single_evaluation_test::p_;
int single_evaluation_test::a_;
int single_evaluation_test::b_;

void do_nothing() {}

FMT_NORETURN void throw_exception() { throw std::runtime_error("test"); }

FMT_NORETURN void throw_system_error() {
  throw fmt::system_error(EDOM, "test");
}

// Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
// exactly once.
TEST_F(single_evaluation_test, failed_expect_throw_msg) {
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(throw_exception(), std::exception, p_++), "01234");
  EXPECT_EQ(s_ + 1, p_);
}

// Tests that when EXPECT_SYSTEM_ERROR fails, it evaluates its message argument
// exactly once.
TEST_F(single_evaluation_test, failed_expect_system_error) {
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, p_++),
                          "01234");
  EXPECT_EQ(s_ + 1, p_);
}

// Tests that assertion arguments are evaluated exactly once.
TEST_F(single_evaluation_test, exception_tests) {
  // successful EXPECT_THROW_MSG
  EXPECT_THROW_MSG(
      {  // NOLINT
        a_++;
        throw_exception();
      },
      std::exception, (b_++, "test"));
  EXPECT_EQ(1, a_);
  EXPECT_EQ(1, b_);

  // failed EXPECT_THROW_MSG, throws different type
  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
                              {  // NOLINT
                                a_++;
                                throw_exception();
                              },
                              std::logic_error, (b_++, "test")),
                          "throws a different type");
  EXPECT_EQ(2, a_);
  EXPECT_EQ(2, b_);

  // failed EXPECT_THROW_MSG, throws an exception with different message
  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
                              {  // NOLINT
                                a_++;
                                throw_exception();
                              },
                              std::exception, (b_++, "other")),
                          "throws an exception with a different message");
  EXPECT_EQ(3, a_);
  EXPECT_EQ(3, b_);

  // failed EXPECT_THROW_MSG, throws nothing
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(a_++, std::exception, (b_++, "test")), "throws nothing");
  EXPECT_EQ(4, a_);
  EXPECT_EQ(4, b_);
}

TEST_F(single_evaluation_test, system_error_tests) {
  // successful EXPECT_SYSTEM_ERROR
  EXPECT_SYSTEM_ERROR(
      {  // NOLINT
        a_++;
        throw_system_error();
      },
      EDOM, (b_++, "test"));
  EXPECT_EQ(1, a_);
  EXPECT_EQ(1, b_);

  // failed EXPECT_SYSTEM_ERROR, throws different type
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
                              {  // NOLINT
                                a_++;
                                throw_exception();
                              },
                              EDOM, (b_++, "test")),
                          "throws a different type");
  EXPECT_EQ(2, a_);
  EXPECT_EQ(2, b_);

  // failed EXPECT_SYSTEM_ERROR, throws an exception with different message
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
                              {  // NOLINT
                                a_++;
                                throw_system_error();
                              },
                              EDOM, (b_++, "other")),
                          "throws an exception with a different message");
  EXPECT_EQ(3, a_);
  EXPECT_EQ(3, b_);

  // failed EXPECT_SYSTEM_ERROR, throws nothing
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(a_++, EDOM, (b_++, "test")),
                          "throws nothing");
  EXPECT_EQ(4, a_);
  EXPECT_EQ(4, b_);
}

#if FMT_USE_FCNTL
// Tests that when EXPECT_WRITE fails, it evaluates its message argument
// exactly once.
TEST_F(single_evaluation_test, failed_expect_write) {
  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), p_++),
                          "01234");
  EXPECT_EQ(s_ + 1, p_);
}

// Tests that assertion arguments are evaluated exactly once.
TEST_F(single_evaluation_test, write_tests) {
  // successful EXPECT_WRITE
  EXPECT_WRITE(
      stdout,
      {  // NOLINT
        a_++;
        std::printf("test");
      },
      (b_++, "test"));
  EXPECT_EQ(1, a_);
  EXPECT_EQ(1, b_);

  // failed EXPECT_WRITE
  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(
                              stdout,
                              {  // NOLINT
                                a_++;
                                std::printf("test");
                              },
                              (b_++, "other")),
                          "Actual: test");
  EXPECT_EQ(2, a_);
  EXPECT_EQ(2, b_);
}

// Tests EXPECT_WRITE.
TEST(gtest_extra_test, expect_write) {
  EXPECT_WRITE(stdout, do_nothing(), "");
  EXPECT_WRITE(stdout, std::printf("test"), "test");
  EXPECT_WRITE(stderr, std::fprintf(stderr, "test"), "test");
  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("that"), "this"),
                          "Expected: this\n"
                          "  Actual: that");
}

TEST(gtest_extra_test, expect_write_streaming) {
  EXPECT_WRITE(stdout, std::printf("test"), "test") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), "other")
                              << "expected failure",
                          "expected failure");
}
#endif  // FMT_USE_FCNTL

// Tests that the compiler will not complain about unreachable code in the
// EXPECT_THROW_MSG macro.
TEST(gtest_extra_test, expect_throw_no_unreachable_code_warning) {
  int n = 0;
  using std::runtime_error;
  EXPECT_THROW_MSG(throw runtime_error(""), runtime_error, "");
  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(n++, runtime_error, ""), "");
  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(throw 1, runtime_error, ""), "");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(throw runtime_error("a"), runtime_error, "b"), "");
}

// Tests that the compiler will not complain about unreachable code in the
// EXPECT_SYSTEM_ERROR macro.
TEST(gtest_extra_test, expect_system_error_no_unreachable_code_warning) {
  int n = 0;
  EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test");
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), "");
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), "");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"),
      "");
}

TEST(gtest_extra_test, expect_throw_behaves_like_single_statement) {
  if (::testing::internal::AlwaysFalse())
    EXPECT_THROW_MSG(do_nothing(), std::exception, "");

  if (::testing::internal::AlwaysTrue())
    EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
  else
    do_nothing();
}

TEST(gtest_extra_test, expect_system_error_behaves_like_single_statement) {
  if (::testing::internal::AlwaysFalse())
    EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "");

  if (::testing::internal::AlwaysTrue())
    EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
  else
    do_nothing();
}

TEST(gtest_extra_test, expect_write_behaves_like_single_statement) {
  if (::testing::internal::AlwaysFalse())
    EXPECT_WRITE(stdout, std::printf("x"), "x");

  if (::testing::internal::AlwaysTrue())
    EXPECT_WRITE(stdout, std::printf("x"), "x");
  else
    do_nothing();
}

// Tests EXPECT_THROW_MSG.
TEST(gtest_extra_test, expect_throw_msg) {
  EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(throw_exception(), std::logic_error, "test"),
      "Expected: throw_exception() throws an exception of "
      "type std::logic_error.\n  Actual: it throws a different type.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(do_nothing(), std::exception, "test"),
      "Expected: do_nothing() throws an exception of type std::exception.\n"
      "  Actual: it throws nothing.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(throw_exception(), std::exception, "other"),
      "throw_exception() throws an exception with a different message.\n"
      "Expected: other\n"
      "  Actual: test");
}

// Tests EXPECT_SYSTEM_ERROR.
TEST(gtest_extra_test, expect_system_error) {
  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"),
      "Expected: throw_exception() throws an exception of "
      "type std::system_error.\n  Actual: it throws a different type.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "test"),
      "Expected: do_nothing() throws an exception of type std::system_error.\n"
      "  Actual: it throws nothing.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"),
      fmt::format(
          "throw_system_error() throws an exception with a different message.\n"
          "Expected: {}\n"
          "  Actual: {}",
          system_error_message(EDOM, "other"),
          system_error_message(EDOM, "test")));
}

TEST(gtest_extra_test, expect_throw_msg_streaming) {
  EXPECT_THROW_MSG(throw_exception(), std::exception, "test")
      << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(
      EXPECT_THROW_MSG(throw_exception(), std::exception, "other")
          << "expected failure",
      "expected failure");
}

TEST(gtest_extra_test, expect_system_error_streaming) {
  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test")
      << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other")
          << "expected failure",
      "expected failure");
}

#if FMT_USE_FCNTL

using fmt::buffered_file;
using fmt::file;

TEST(output_redirect_test, scoped_redirect) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  {
    buffered_file file(write_end.fdopen("w"));
    std::fprintf(file.get(), "[[[");
    {
      output_redirect redir(file.get());
      std::fprintf(file.get(), "censored");
    }
    std::fprintf(file.get(), "]]]");
  }
  EXPECT_READ(read_end, "[[[]]]");
}

// Test that output_redirect handles errors in flush correctly.
TEST(output_redirect_test, flush_error_in_ctor) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  int write_fd = write_end.descriptor();
  file write_copy = write_end.dup(write_fd);
  buffered_file f = write_end.fdopen("w");
  // Put a character in a file buffer.
  EXPECT_EQ('x', fputc('x', f.get()));
  FMT_POSIX(close(write_fd));
  std::unique_ptr<output_redirect> redir{nullptr};
  EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new output_redirect(f.get())), EBADF,
                               "cannot flush stream");
  redir.reset(nullptr);
  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
}

TEST(output_redirect_test, dup_error_in_ctor) {
  buffered_file f = open_buffered_file();
  int fd = (f.fileno)();
  file copy = file::dup(fd);
  FMT_POSIX(close(fd));
  std::unique_ptr<output_redirect> redir{nullptr};
  EXPECT_SYSTEM_ERROR_NOASSERT(
      redir.reset(new output_redirect(f.get())), EBADF,
      fmt::format("cannot duplicate file descriptor {}", fd));
  copy.dup2(fd);  // "undo" close or dtor will fail
}

TEST(output_redirect_test, restore_and_read) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  buffered_file file(write_end.fdopen("w"));
  std::fprintf(file.get(), "[[[");
  output_redirect redir(file.get());
  std::fprintf(file.get(), "censored");
  EXPECT_EQ("censored", redir.restore_and_read());
  EXPECT_EQ("", redir.restore_and_read());
  std::fprintf(file.get(), "]]]");
  file = buffered_file();
  EXPECT_READ(read_end, "[[[]]]");
}

// Test that OutputRedirect handles errors in flush correctly.
TEST(output_redirect_test, flush_error_in_restore_and_read) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  int write_fd = write_end.descriptor();
  file write_copy = write_end.dup(write_fd);
  buffered_file f = write_end.fdopen("w");
  output_redirect redir(f.get());
  // Put a character in a file buffer.
  EXPECT_EQ('x', fputc('x', f.get()));
  FMT_POSIX(close(write_fd));
  EXPECT_SYSTEM_ERROR_NOASSERT(redir.restore_and_read(), EBADF,
                               "cannot flush stream");
  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
}

TEST(output_redirect_test, error_in_dtor) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  int write_fd = write_end.descriptor();
  file write_copy = write_end.dup(write_fd);
  buffered_file f = write_end.fdopen("w");
  std::unique_ptr<output_redirect> redir(new output_redirect(f.get()));
  // Put a character in a file buffer.
  EXPECT_EQ('x', fputc('x', f.get()));
  EXPECT_WRITE(
      stderr,
      {
        // The close function must be called inside EXPECT_WRITE,
        // otherwise the system may recycle closed file descriptor when
        // redirecting the output in EXPECT_STDERR and the second close
        // will break output redirection.
        FMT_POSIX(close(write_fd));
        SUPPRESS_ASSERT(redir.reset(nullptr));
      },
      system_error_message(EBADF, "cannot flush stream"));
  write_copy.dup2(write_fd);  // "undo" close or dtor of buffered_file will fail
}

#endif  // FMT_USE_FCNTL


================================================
FILE: examples/libraries/fmt/test/gtest-extra.cc
================================================
// Formatting library for C++ - custom Google Test assertions
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "gtest-extra.h"

#if FMT_USE_FCNTL

using fmt::file;

output_redirect::output_redirect(FILE* f) : file_(f) {
  flush();
  int fd = FMT_POSIX(fileno(f));
  // Create a file object referring to the original file.
  original_ = file::dup(fd);
  // Create a pipe.
  file write_end;
  file::pipe(read_end_, write_end);
  // Connect the passed FILE object to the write end of the pipe.
  write_end.dup2(fd);
}

output_redirect::~output_redirect() FMT_NOEXCEPT {
  try {
    restore();
  } catch (const std::exception& e) {
    std::fputs(e.what(), stderr);
  }
}

void output_redirect::flush() {
  int result = 0;
  do {
    result = fflush(file_);
  } while (result == EOF && errno == EINTR);
  if (result != 0) throw fmt::system_error(errno, "cannot flush stream");
}

void output_redirect::restore() {
  if (original_.descriptor() == -1) return;  // Already restored.
  flush();
  // Restore the original file.
  original_.dup2(FMT_POSIX(fileno(file_)));
  original_.close();
}

std::string output_redirect::restore_and_read() {
  // Restore output.
  restore();

  // Read everything from the pipe.
  std::string content;
  if (read_end_.descriptor() == -1) return content;  // Already read.
  enum { BUFFER_SIZE = 4096 };
  char buffer[BUFFER_SIZE];
  size_t count = 0;
  do {
    count = read_end_.read(buffer, BUFFER_SIZE);
    content.append(buffer, count);
  } while (count != 0);
  read_end_.close();
  return content;
}

std::string read(file& f, size_t count) {
  std::string buffer(count, '\0');
  size_t n = 0, offset = 0;
  do {
    n = f.read(&buffer[offset], count - offset);
    // We can't read more than size_t bytes since count has type size_t.
    offset += n;
  } while (offset < count && n != 0);
  buffer.resize(offset);
  return buffer;
}

#endif  // FMT_USE_FCNTL


================================================
FILE: examples/libraries/fmt/test/gtest-extra.h
================================================
// Formatting library for C++ - custom Google Test assertions
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_GTEST_EXTRA_H_
#define FMT_GTEST_EXTRA_H_

#include <stdlib.h>  // _invalid_parameter_handler

#include <string>

#include "fmt/os.h"
#include "gmock/gmock.h"

#define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
  if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) {   \
    std::string gtest_expected_message = expected_message;                     \
    bool gtest_caught_expected = false;                                        \
    try {                                                                      \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
    } catch (expected_exception const& e) {                                    \
      if (gtest_expected_message != e.what()) {                                \
        gtest_ar << #statement                                                 \
            " throws an exception with a different message.\n"                 \
                 << "Expected: " << gtest_expected_message << "\n"             \
                 << "  Actual: " << e.what();                                  \
        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
      }                                                                        \
      gtest_caught_expected = true;                                            \
    } catch (...) {                                                            \
      gtest_ar << "Expected: " #statement                                      \
                  " throws an exception of type " #expected_exception          \
                  ".\n  Actual: it throws a different type.";                  \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
    }                                                                          \
    if (!gtest_caught_expected) {                                              \
      gtest_ar << "Expected: " #statement                                      \
                  " throws an exception of type " #expected_exception          \
                  ".\n  Actual: it throws nothing.";                           \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
    }                                                                          \
  } else                                                                       \
    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                      \
        : fail(gtest_ar.failure_message())

// Tests that the statement throws the expected exception and the exception's
// what() method returns expected message.
#define EXPECT_THROW_MSG(statement, expected_exception, expected_message) \
  FMT_TEST_THROW_(statement, expected_exception, expected_message,        \
                  GTEST_NONFATAL_FAILURE_)

inline std::string system_error_message(int error_code,
                                        const std::string& message) {
  auto ec = std::error_code(error_code, std::generic_category());
  return std::system_error(ec, message).what();
}

#define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
  EXPECT_THROW_MSG(statement, std::system_error,            \
                   system_error_message(error_code, message))

#if FMT_USE_FCNTL

// Captures file output by redirecting it to a pipe.
// The output it can handle is limited by the pipe capacity.
class output_redirect {
 private:
  FILE* file_;
  fmt::file original_;  // Original file passed to redirector.
  fmt::file read_end_;  // Read end of the pipe where the output is redirected.

  void flush();
  void restore();

 public:
  explicit output_redirect(FILE* file);
  ~output_redirect() FMT_NOEXCEPT;

  output_redirect(const output_redirect&) = delete;
  void operator=(const output_redirect&) = delete;

  // Restores the original file, reads output from the pipe into a string
  // and returns it.
  std::string restore_and_read();
};

#  define FMT_TEST_WRITE_(statement, expected_output, file, fail)              \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_                                              \
    if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) { \
      std::string gtest_expected_output = expected_output;                     \
      output_redirect gtest_redir(file);                                       \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
      std::string gtest_output = gtest_redir.restore_and_read();               \
      if (gtest_output != gtest_expected_output) {                             \
        gtest_ar << #statement " produces different output.\n"                 \
                 << "Expected: " << gtest_expected_output << "\n"              \
                 << "  Actual: " << gtest_output;                              \
        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
      }                                                                        \
    } else                                                                     \
      GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                    \
          : fail(gtest_ar.failure_message())

// Tests that the statement writes the expected output to file.
#  define EXPECT_WRITE(file, statement, expected_output) \
    FMT_TEST_WRITE_(statement, expected_output, file, GTEST_NONFATAL_FAILURE_)

#  ifdef _MSC_VER

// Suppresses Windows assertions on invalid file descriptors, making
// POSIX functions return proper error codes instead of crashing on Windows.
class suppress_assert {
 private:
  _invalid_parameter_handler original_handler_;
  int original_report_mode_;

  static void handle_invalid_parameter(const wchar_t*, const wchar_t*,
                                       const wchar_t*, unsigned, uintptr_t) {}

 public:
  suppress_assert()
      : original_handler_(
            _set_invalid_parameter_handler(handle_invalid_parameter)),
        original_report_mode_(_CrtSetReportMode(_CRT_ASSERT, 0)) {}
  ~suppress_assert() {
    _set_invalid_parameter_handler(original_handler_);
    _CrtSetReportMode(_CRT_ASSERT, original_report_mode_);
  }
};

#    define SUPPRESS_ASSERT(statement) \
      {                                \
        suppress_assert sa;            \
        statement;                     \
      }
#  else
#    define SUPPRESS_ASSERT(statement) statement
#  endif  // _MSC_VER

#  define EXPECT_SYSTEM_ERROR_NOASSERT(statement, error_code, message) \
    EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)

// Attempts to read count characters from a file.
std::string read(fmt::file& f, size_t count);

#  define EXPECT_READ(file, expected_content) \
    EXPECT_EQ(expected_content,               \
              read(file, fmt::string_view(expected_content).size()))

#else
#  define EXPECT_WRITE(file, statement, expected_output) \
    do {                                                 \
      (void)(file);                                      \
      (void)(statement);                                 \
      (void)(expected_output);                           \
      SUCCEED();                                         \
    } while (false)
#endif  // FMT_USE_FCNTL

#endif  // FMT_GTEST_EXTRA_H_


================================================
FILE: examples/libraries/fmt/test/header-only-test.cc
================================================
// Header-only configuration test

#include "fmt/core.h"

#ifndef FMT_HEADER_ONLY
#  error "Not in the header-only mode."
#endif


================================================
FILE: examples/libraries/fmt/test/mock-allocator.h
================================================
// Formatting library for C++ - mock allocator
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_MOCK_ALLOCATOR_H_
#define FMT_MOCK_ALLOCATOR_H_

#include <assert.h>  // assert
#include <stddef.h>  // size_t

#include <memory>  // std::allocator_traits

#include "gmock/gmock.h"

template <typename T> class mock_allocator {
 public:
  mock_allocator() {}
  mock_allocator(const mock_allocator&) {}
  using value_type = T;
  MOCK_METHOD1_T(allocate, T*(size_t n));
  MOCK_METHOD2_T(deallocate, void(T* p, size_t n));
};

template <typename Allocator> class allocator_ref {
 private:
  Allocator* alloc_;

  void move(allocator_ref& other) {
    alloc_ = other.alloc_;
    other.alloc_ = nullptr;
  }

 public:
  using value_type = typename Allocator::value_type;

  explicit allocator_ref(Allocator* alloc = nullptr) : alloc_(alloc) {}

  allocator_ref(const allocator_ref& other) : alloc_(other.alloc_) {}
  allocator_ref(allocator_ref&& other) { move(other); }

  allocator_ref& operator=(allocator_ref&& other) {
    assert(this != &other);
    move(other);
    return *this;
  }

  allocator_ref& operator=(const allocator_ref& other) {
    alloc_ = other.alloc_;
    return *this;
  }

 public:
  Allocator* get() const { return alloc_; }

  value_type* allocate(size_t n) {
    return std::allocator_traits<Allocator>::allocate(*alloc_, n);
  }
  void deallocate(value_type* p, size_t n) { alloc_->deallocate(p, n); }
};

#endif  // FMT_MOCK_ALLOCATOR_H_


================================================
FILE: examples/libraries/fmt/test/module-test.cc
================================================
// Formatting library for C++ - module tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
//
// Copyright (c) 2021 - present, Daniela Engert
// All Rights Reserved
// {fmt} module.

#ifdef _MSC_FULL_VER
// hide some implementation bugs in msvc
// that are not essential to users of the module.
#  define FMT_HIDE_MODULE_BUGS
#endif

#include <bit>
#include <chrono>
#include <exception>
#include <iterator>
#include <locale>
#include <memory>
#include <ostream>
#include <string>
#include <string_view>
#include <system_error>

#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
     defined(__linux__)) &&                              \
    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
#  include <fcntl.h>
#  define FMT_USE_FCNTL 1
#else
#  define FMT_USE_FCNTL 0
#endif
#define FMT_NOEXCEPT noexcept
#if defined(_WIN32) && !defined(__MINGW32__)
#  define FMT_POSIX(call) _##call
#else
#  define FMT_POSIX(call) call
#endif
#define FMT_OS_H_  // don't pull in os.h directly or indirectly

import fmt;

// check for macros leaking from BMI
static bool macro_leaked =
#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H_)
    true;
#else
    false;
#endif

// Include sources to pick up functions and classes from the module rather than
// from the non-modular library which is baked into the 'test-main' library.
// This averts linker problems:
// - strong ownership model: missing linker symbols
// - weak ownership model: duplicate linker symbols
#include "gtest-extra.cc"
#include "util.cc"

// an implicitly exported namespace must be visible [module.interface]/2.2
TEST(module_test, namespace) {
  using namespace fmt;
  using namespace fmt::literals;
  ASSERT_TRUE(true);
}

namespace detail {
bool oops_detail_namespace_is_visible;
}

namespace fmt {
bool namespace_detail_invisible() {
#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
    _MSC_FULL_VER <= 192930129
  // bug in msvc up to 16.11-pre1:
  // the namespace is visible even when it is neither
  // implicitly nor explicitly exported
  return true;
#else
  using namespace detail;
  // this fails to compile if fmt::detail is visible
  return !oops_detail_namespace_is_visible;
#endif
}
}  // namespace fmt

// the non-exported namespace 'detail' must be invisible [module.interface]/2
TEST(module_test, detail_namespace) {
  EXPECT_TRUE(fmt::namespace_detail_invisible());
}

// macros must not be imported from a *named* module  [cpp.import]/5.1
TEST(module_test, macros) {
#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
    _MSC_FULL_VER <= 192930129
  // bug in msvc up to 16.11-pre1:
  // include-guard macros leak from BMI
  // and even worse: they cannot be #undef-ined
  macro_leaked = false;
#endif
  EXPECT_FALSE(macro_leaked);
}

// The following is less about functional testing (that's done elsewhere)
// but rather visibility of all client-facing overloads, reachability of
// non-exported entities, name lookup and overload resolution within
// template instantitions.
// Excercise all exported entities of the API at least once.
// Instantiate as many code paths as possible.

TEST(module_test, to_string) {
  EXPECT_EQ("42", fmt::to_string(42));
  EXPECT_EQ("42", fmt::to_string(42.0));

  EXPECT_EQ(L"42", fmt::to_wstring(42));
  EXPECT_EQ(L"42", fmt::to_wstring(42.0));
}

TEST(module_test, format) {
  EXPECT_EQ("42", fmt::format("{:}", 42));
  EXPECT_EQ("-42", fmt::format("{0}", -42.0));

  EXPECT_EQ(L"42", fmt::format(L"{:}", 42));
  EXPECT_EQ(L"-42", fmt::format(L"{0}", -42.0));
}

TEST(module_test, format_to) {
  std::string s;
  fmt::format_to(std::back_inserter(s), "{}", 42);
  EXPECT_EQ("42", s);

  char buffer[4] = {0};
  fmt::format_to(buffer, "{}", 42);
  EXPECT_EQ("42", std::string_view(buffer));

  fmt::memory_buffer mb;
  fmt::format_to(mb, "{}", 42);
  EXPECT_EQ("42", std::string_view(buffer));

  std::wstring w;
  fmt::format_to(std::back_inserter(w), L"{}", 42);
  EXPECT_EQ(L"42", w);

  wchar_t wbuffer[4] = {0};
  fmt::format_to(wbuffer, L"{}", 42);
  EXPECT_EQ(L"42", std::wstring_view(wbuffer));

  fmt::wmemory_buffer wb;
  fmt::format_to(wb, L"{}", 42);
  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
}

TEST(module_test, formatted_size) {
  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
  EXPECT_EQ(2u, fmt::formatted_size(L"{}", 42));
}

TEST(module_test, format_to_n) {
  std::string s;
  auto result = fmt::format_to_n(std::back_inserter(s), 1, "{}", 42);
  EXPECT_EQ(2u, result.size);
  char buffer[4] = {0};
  fmt::format_to_n(buffer, 3, "{}", 12345);

  std::wstring w;
  auto wresult = fmt::format_to_n(std::back_inserter(w), 1, L"{}", 42);
  EXPECT_EQ(2u, wresult.size);
  wchar_t wbuffer[4] = {0};
  fmt::format_to_n(wbuffer, 3, L"{}", 12345);
}

TEST(module_test, format_args) {
  auto no_args = fmt::format_args();
  EXPECT_FALSE(no_args.get(1));

  fmt::basic_format_args args = fmt::make_format_args(42);
  EXPECT_TRUE(args.max_size() > 0);
  auto arg0 = args.get(0);
  EXPECT_TRUE(arg0);
  decltype(arg0) arg_none;
  EXPECT_FALSE(arg_none);
  EXPECT_TRUE(arg0.type() != arg_none.type());
}

TEST(module_test, wformat_args) {
  auto no_args = fmt::wformat_args();
  EXPECT_FALSE(no_args.get(1));
  fmt::basic_format_args args = fmt::make_wformat_args(42);
  EXPECT_TRUE(args.get(0));
}

TEST(module_test, checked_format_args) {
  fmt::basic_format_args args = fmt::make_args_checked<int>("{}", 42);
  EXPECT_TRUE(args.get(0));
  fmt::basic_format_args wargs = fmt::make_args_checked<int>(L"{}", 42);
  EXPECT_TRUE(wargs.get(0));
}

TEST(module_test, dynamic_format_args) {
  fmt::dynamic_format_arg_store<fmt::format_context> dyn_store;
  dyn_store.push_back(fmt::arg("a42", 42));
  fmt::basic_format_args args = dyn_store;
  EXPECT_FALSE(args.get(3));
  EXPECT_TRUE(args.get(fmt::string_view("a42")));

  fmt::dynamic_format_arg_store<fmt::wformat_context> wdyn_store;
  wdyn_store.push_back(fmt::arg(L"a42", 42));
  fmt::basic_format_args wargs = wdyn_store;
  EXPECT_FALSE(wargs.get(3));
  EXPECT_TRUE(wargs.get(fmt::wstring_view(L"a42")));
}

TEST(module_test, vformat) {
  EXPECT_EQ("42", fmt::vformat("{}", fmt::make_format_args(42)));
  EXPECT_EQ(L"42", fmt::vformat(fmt::to_string_view(L"{}"),
                                fmt::make_wformat_args(42)));
}

TEST(module_test, vformat_to) {
  auto store = fmt::make_format_args(42);
  std::string s;
  fmt::vformat_to(std::back_inserter(s), "{}", store);
  EXPECT_EQ("42", s);

  char buffer[4] = {0};
  fmt::vformat_to(buffer, "{:}", store);
  EXPECT_EQ("42", std::string_view(buffer));

  auto wstore = fmt::make_wformat_args(42);
  std::wstring w;
  fmt::vformat_to(std::back_inserter(w), L"{}", wstore);
  EXPECT_EQ(L"42", w);

  wchar_t wbuffer[4] = {0};
  fmt::vformat_to(wbuffer, L"{:}", wstore);
  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
}

TEST(module_test, vformat_to_n) {
  auto store = fmt::make_format_args(12345);
  std::string s;
  auto result = fmt::vformat_to_n(std::back_inserter(s), 1, "{}", store);
  char buffer[4] = {0};
  fmt::vformat_to_n(buffer, 3, "{:}", store);

  auto wstore = fmt::make_wformat_args(12345);
  std::wstring w;
  auto wresult = fmt::vformat_to_n(std::back_inserter(w), 1,
                                   fmt::to_string_view(L"{}"), wstore);
  wchar_t wbuffer[4] = {0};
  fmt::vformat_to_n(wbuffer, 3, fmt::to_string_view(L"{:}"), wstore);
}

std::string as_string(std::wstring_view text) {
  return {reinterpret_cast<const char*>(text.data()),
          text.size() * sizeof(text[0])};
}

TEST(module_test, print) {
  EXPECT_WRITE(stdout, fmt::print("{}µ", 42), "42µ");
  EXPECT_WRITE(stderr, fmt::print(stderr, "{}µ", 4.2), "4.2µ");
  if (false) {
    EXPECT_WRITE(stdout, fmt::print(L"{}µ", 42), as_string(L"42µ"));
    EXPECT_WRITE(stderr, fmt::print(stderr, L"{}µ", 4.2), as_string(L"4.2µ"));
  }
}

TEST(module_test, vprint) {
  EXPECT_WRITE(stdout, fmt::vprint("{:}µ", fmt::make_format_args(42)), "42µ");
  EXPECT_WRITE(stderr, fmt::vprint(stderr, "{}", fmt::make_format_args(4.2)),
               "4.2");
  if (false) {
    EXPECT_WRITE(stdout, fmt::vprint(L"{:}µ", fmt::make_wformat_args(42)),
                 as_string(L"42µ"));
    EXPECT_WRITE(stderr, fmt::vprint(stderr, L"{}", fmt::make_wformat_args(42)),
                 as_string(L"42"));
  }
}

TEST(module_test, named_args) {
  EXPECT_EQ("42", fmt::format("{answer}", fmt::arg("answer", 42)));
  EXPECT_EQ(L"42", fmt::format(L"{answer}", fmt::arg(L"answer", 42)));
}

TEST(module_test, literals) {
  using namespace fmt::literals;
  EXPECT_EQ("42", fmt::format("{answer}", "answer"_a = 42));
  EXPECT_EQ("42", "{}"_format(42));
  EXPECT_EQ(L"42", fmt::format(L"{answer}", L"answer"_a = 42));
  EXPECT_EQ(L"42", L"{}"_format(42));
}

TEST(module_test, locale) {
  auto store = fmt::make_format_args(4.2);
  const auto classic = std::locale::classic();
  EXPECT_EQ("4.2", fmt::format(classic, "{:L}", 4.2));
  EXPECT_EQ("4.2", fmt::vformat(classic, "{:L}", store));
  std::string s;
  fmt::vformat_to(std::back_inserter(s), classic, "{:L}", store);
  EXPECT_EQ("4.2", s);
  EXPECT_EQ("4.2", fmt::format("{:L}", 4.2));

  auto wstore = fmt::make_wformat_args(4.2);
  EXPECT_EQ(L"4.2", fmt::format(classic, L"{:L}", 4.2));
  EXPECT_EQ(L"4.2", fmt::vformat(classic, L"{:L}", wstore));
  std::wstring w;
  fmt::vformat_to(std::back_inserter(w), classic, L"{:L}", wstore);
  EXPECT_EQ(L"4.2", w);
  EXPECT_EQ(L"4.2", fmt::format(L"{:L}", 4.2));
}

TEST(module_test, string_view) {
  fmt::string_view nsv("fmt");
  EXPECT_EQ("fmt", nsv);
  EXPECT_TRUE(fmt::string_view("fmt") == nsv);

  fmt::wstring_view wsv(L"fmt");
  EXPECT_EQ(L"fmt", wsv);
  EXPECT_TRUE(fmt::wstring_view(L"fmt") == wsv);
}

TEST(module_test, memory_buffer) {
  fmt::basic_memory_buffer<char, fmt::inline_buffer_size> buffer;
  fmt::format_to(buffer, "{}", "42");
  EXPECT_EQ("42", to_string(buffer));
  fmt::memory_buffer nbuffer(std::move(buffer));
  EXPECT_EQ("42", to_string(nbuffer));
  buffer = std::move(nbuffer);
  EXPECT_EQ("42", to_string(buffer));
  nbuffer.clear();
  EXPECT_EQ(0u, to_string(nbuffer).size());

  fmt::wmemory_buffer wbuffer;
  EXPECT_EQ(0u, to_string(wbuffer).size());
}

TEST(module_test, is_char) {
  EXPECT_TRUE(fmt::is_char<char>());
  EXPECT_TRUE(fmt::is_char<wchar_t>());
  EXPECT_TRUE(fmt::is_char<char8_t>());
  EXPECT_TRUE(fmt::is_char<char16_t>());
  EXPECT_TRUE(fmt::is_char<char32_t>());
  EXPECT_FALSE(fmt::is_char<signed char>());
}

TEST(module_test, ptr) {
  uintptr_t answer = 42;
  auto p = std::bit_cast<int*>(answer);
  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(p)));
  std::unique_ptr<int> up(p);
  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(up)));
  up.release();
  auto sp = std::make_shared<int>(0);
  p = sp.get();
  EXPECT_EQ(fmt::to_string(fmt::ptr(p)), fmt::to_string(fmt::ptr(sp)));
}

TEST(module_test, errors) {
  auto store = fmt::make_format_args(42);
  EXPECT_THROW(throw fmt::format_error("oops"), std::exception);
  EXPECT_THROW(throw fmt::vsystem_error(0, "{}", store), std::system_error);
  EXPECT_THROW(throw fmt::system_error(0, "{}", 42), std::system_error);

  fmt::memory_buffer buffer;
  fmt::format_system_error(buffer, 0, "oops");
  auto oops = to_string(buffer);
  EXPECT_TRUE(oops.size() > 0);
  EXPECT_WRITE(stderr, fmt::report_system_error(0, "oops"), oops + '\n');

#ifdef _WIN32
  EXPECT_THROW(throw fmt::vwindows_error(0, "{}", store), std::system_error);
  EXPECT_THROW(throw fmt::windows_error(0, "{}", 42), std::system_error);
  output_redirect redirect(stderr);
  fmt::report_windows_error(0, "oops");
  EXPECT_TRUE(redirect.restore_and_read().size() > 0);
#endif
}

TEST(module_test, error_code) {
  EXPECT_EQ("generic:42",
            fmt::format("{0}", std::error_code(42, std::generic_category())));
  EXPECT_EQ("system:42",
            fmt::format("{0}", std::error_code(42, fmt::system_category())));
  EXPECT_EQ(L"generic:42",
            fmt::format(L"{0}", std::error_code(42, std::generic_category())));
}

TEST(module_test, format_int) {
  fmt::format_int sanswer(42);
  EXPECT_EQ("42", fmt::string_view(sanswer.data(), sanswer.size()));
  fmt::format_int uanswer(42u);
  EXPECT_EQ("42", fmt::string_view(uanswer.data(), uanswer.size()));
}

struct test_formatter : fmt::formatter<char> {
  bool check() { return true; }
};

struct test_dynamic_formatter : fmt::dynamic_formatter<> {
  bool check() { return true; }
};

TEST(module_test, formatter) {
  EXPECT_TRUE(test_formatter{}.check());
  EXPECT_TRUE(test_dynamic_formatter{}.check());
}

TEST(module_test, join) {
  int arr[3] = {1, 2, 3};
  std::vector<double> vec{1.0, 2.0, 3.0};
  std::initializer_list<int> il{1, 2, 3};
  auto sep = fmt::to_string_view(", ");
  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr + 0, arr + 3, sep)));
  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr, sep)));
  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec.begin(), vec.end(), sep)));
  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec, sep)));
  EXPECT_EQ("1, 2, 3", to_string(fmt::join(il, sep)));

  auto wsep = fmt::to_string_view(L", ");
  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr + 0, arr + 3, wsep)));
  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr, wsep)));
  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(il, wsep)));
}

TEST(module_test, time) {
  auto time_now = std::time(nullptr);
  EXPECT_TRUE(fmt::localtime(time_now).tm_year > 120);
  EXPECT_TRUE(fmt::gmtime(time_now).tm_year > 120);
  auto chrono_now = std::chrono::system_clock::now();
  EXPECT_TRUE(fmt::localtime(chrono_now).tm_year > 120);
  EXPECT_TRUE(fmt::gmtime(chrono_now).tm_year > 120);
}

TEST(module_test, time_point) {
  auto now = std::chrono::system_clock::now();
  std::string_view past("2021-05-20 10:30:15");
  EXPECT_TRUE(past < fmt::format("{:%Y-%m-%d %H:%M:%S}", now));
  std::wstring_view wpast(L"2021-05-20 10:30:15");
  EXPECT_TRUE(wpast < fmt::format(L"{:%Y-%m-%d %H:%M:%S}", now));
}

TEST(module_test, time_duration) {
  using us = std::chrono::duration<double, std::micro>;
  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds{42}));
  EXPECT_EQ("4.2µs", fmt::format("{:3.1}", us{4.234}));
  EXPECT_EQ("4.2µs", fmt::format(std::locale::classic(), "{:L}", us{4.2}));

  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds{42}));
  EXPECT_EQ(L"4.2µs", fmt::format(L"{:3.1}", us{4.234}));
  EXPECT_EQ(L"4.2µs", fmt::format(std::locale::classic(), L"{:L}", us{4.2}));
}

TEST(module_test, weekday) {
  EXPECT_EQ("Monday",
            std::format(std::locale::classic(), "{:%A}", fmt::weekday(1)));
}

TEST(module_test, to_string_view) {
  using fmt::to_string_view;
  fmt::string_view nsv{to_string_view("42")};
  EXPECT_EQ("42", nsv);
  fmt::wstring_view wsv{to_string_view(L"42")};
  EXPECT_EQ(L"42", wsv);
}

TEST(module_test, printf) {
  EXPECT_WRITE(stdout, fmt::printf("%f", 42.123456), "42.123456");
  EXPECT_WRITE(stdout, fmt::printf("%d", 42), "42");
  if (false) {
    EXPECT_WRITE(stdout, fmt::printf(L"%f", 42.123456),
                 as_string(L"42.123456"));
    EXPECT_WRITE(stdout, fmt::printf(L"%d", 42), as_string(L"42"));
  }
}

TEST(module_test, fprintf) {
  EXPECT_WRITE(stderr, fmt::fprintf(stderr, "%d", 42), "42");
  std::ostringstream os;
  fmt::fprintf(os, "%s", "bla");
  EXPECT_EQ("bla", os.str());

  EXPECT_WRITE(stderr, fmt::fprintf(stderr, L"%d", 42), as_string(L"42"));
  std::wostringstream ws;
  fmt::fprintf(ws, L"%s", L"bla");
  EXPECT_EQ(L"bla", ws.str());
}

TEST(module_test, sprintf) {
  EXPECT_EQ("42", fmt::sprintf("%d", 42));
  EXPECT_EQ(L"42", fmt::sprintf(L"%d", 42));
}

TEST(module_test, vprintf) {
  EXPECT_WRITE(stdout, fmt::vprintf("%d", fmt::make_printf_args(42)), "42");
  if (false) {
    EXPECT_WRITE(stdout, fmt::vprintf(L"%d", fmt::make_wprintf_args(42)),
                 as_string(L"42"));
  }
}

TEST(module_test, vfprintf) {
  auto args = fmt::make_printf_args(42);
  EXPECT_WRITE(stderr, fmt::vfprintf(stderr, "%d", args), "42");
  std::ostringstream os;
  fmt::vfprintf(os, "%d", args);
  EXPECT_EQ("42", os.str());
  auto wargs = fmt::make_wprintf_args(42);
  if (false) {
    EXPECT_WRITE(stderr, fmt::vfprintf(stderr, L"%d", wargs), as_string(L"42"));
  }
  std::wostringstream ws;
  fmt::vfprintf(ws, L"%d", wargs);
  EXPECT_EQ(L"42", ws.str());
}

TEST(module_test, vsprintf) {
  EXPECT_EQ("42", fmt::vsprintf("%d", fmt::make_printf_args(42)));
  EXPECT_EQ(L"42", fmt::vsprintf(L"%d", fmt::make_wprintf_args(42)));
}

TEST(module_test, color) {
  auto fg_check = fg(fmt::rgb(255, 200, 30));
  auto bg_check = bg(fmt::color::dark_slate_gray) | fmt::emphasis::italic;
  auto emphasis_check = fmt::emphasis::underline | fmt::emphasis::bold;
  EXPECT_EQ("\x1B[30m42\x1B[0m",
            fmt::format(fg(fmt::terminal_color::black), "{}", 42));
  EXPECT_EQ(L"\x1B[30m42\x1B[0m",
            fmt::format(fg(fmt::terminal_color::black), L"{}", 42));
}

TEST(module_test, cstring_view) {
  auto s = "fmt";
  EXPECT_EQ(s, fmt::cstring_view(s).c_str());
  auto w = L"fmt";
  EXPECT_EQ(w, fmt::wcstring_view(w).c_str());
}

TEST(module_test, buffered_file) {
  EXPECT_TRUE(fmt::buffered_file{}.get() == nullptr);
}

TEST(module_test, output_file) {
  fmt::ostream out = fmt::output_file("module-test", fmt::buffer_size = 1);
  out.close();
}

struct custom_context {
  using char_type = char;
  using parse_context_type = fmt::format_parse_context;
};

TEST(module_test, custom_context) {
  fmt::basic_format_arg<custom_context> custom_arg;
  EXPECT_TRUE(!custom_arg);
}

struct disabled_formatter {};

TEST(module_test, has_formatter) {
  EXPECT_FALSE(
      (fmt::has_formatter<disabled_formatter, fmt::format_context>::value));
}

TEST(module_test, is_formattable) {
  EXPECT_FALSE(fmt::is_formattable<disabled_formatter>::value);
}

TEST(module_test, compile_format_string) {
  using namespace fmt::literals;
  EXPECT_EQ("42", fmt::format("{0:x}"_cf, 0x42));
  EXPECT_EQ(L"42", fmt::format(L"{:}"_cf, 42));
  EXPECT_EQ("4.2", fmt::format("{arg:3.1f}"_cf, "arg"_a = 4.2));
  EXPECT_EQ(L" 42", fmt::format(L"{arg:>3}"_cf, L"arg"_a = L"42"));
}


================================================
FILE: examples/libraries/fmt/test/os-test.cc
================================================
// Formatting library for C++ - tests of the OS-specific functionality
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/os.h"

#include <cstdlib>  // std::exit
#include <cstring>
#include <memory>

#include "gtest-extra.h"
#include "util.h"

#ifdef fileno
#  undef fileno
#endif

using fmt::buffered_file;
using testing::HasSubstr;
using wstring_view = fmt::basic_string_view<wchar_t>;

#ifdef _WIN32

#  include <windows.h>

TEST(util_test, utf16_to_utf8) {
  auto s = std::string("ёжик");
  fmt::detail::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
  EXPECT_EQ(s, u.str());
  EXPECT_EQ(s.size(), u.size());
}

TEST(util_test, utf16_to_utf8_empty_string) {
  std::string s = "";
  fmt::detail::utf16_to_utf8 u(L"");
  EXPECT_EQ(s, u.str());
  EXPECT_EQ(s.size(), u.size());
}

template <typename Converter, typename Char>
void check_utf_conversion_error(
    const char* message,
    fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
  fmt::memory_buffer out;
  fmt::detail::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
  auto error = std::system_error(std::error_code());
  try {
    (Converter)(str);
  } catch (const std::system_error& e) {
    error = e;
  }
  EXPECT_EQ(ERROR_INVALID_PARAMETER, error.code().value());
  EXPECT_THAT(error.what(), HasSubstr(fmt::to_string(out)));
}

TEST(util_test, utf16_to_utf8_error) {
  check_utf_conversion_error<fmt::detail::utf16_to_utf8, wchar_t>(
      "cannot convert string from UTF-16 to UTF-8");
}

TEST(util_test, utf16_to_utf8_convert) {
  fmt::detail::utf16_to_utf8 u;
  EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(wstring_view(0, 1)));
  EXPECT_EQ(ERROR_INVALID_PARAMETER,
            u.convert(wstring_view(L"foo", INT_MAX + 1u)));
}

TEST(os_test, format_std_error_code) {
  EXPECT_EQ("generic:42",
            fmt::format(FMT_STRING("{0}"),
                        std::error_code(42, std::generic_category())));
  EXPECT_EQ("system:42",
            fmt::format(FMT_STRING("{0}"),
                        std::error_code(42, fmt::system_category())));
  EXPECT_EQ("system:-42",
            fmt::format(FMT_STRING("{0}"),
                        std::error_code(-42, fmt::system_category())));
}

TEST(os_test, format_windows_error) {
  LPWSTR message = 0;
  auto result = FormatMessageW(
      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
          FORMAT_MESSAGE_IGNORE_INSERTS,
      0, ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
      reinterpret_cast<LPWSTR>(&message), 0, 0);
  fmt::detail::utf16_to_utf8 utf8_message(wstring_view(message, result - 2));
  LocalFree(message);
  fmt::memory_buffer actual_message;
  fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, "test");
  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
            fmt::to_string(actual_message));
  actual_message.resize(0);
}

TEST(os_test, format_long_windows_error) {
  LPWSTR message = 0;
  // this error code is not available on all Windows platforms and
  // Windows SDKs, so do not fail the test if the error string cannot
  // be retrieved.
  int provisioning_not_allowed = 0x80284013L;  // TBS_E_PROVISIONING_NOT_ALLOWED
  auto result = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                   FORMAT_MESSAGE_FROM_SYSTEM |
                                   FORMAT_MESSAGE_IGNORE_INSERTS,
                               0, static_cast<DWORD>(provisioning_not_allowed),
                               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                               reinterpret_cast<LPWSTR>(&message), 0, 0);
  if (result == 0) {
    LocalFree(message);
    return;
  }
  fmt::detail::utf16_to_utf8 utf8_message(wstring_view(message, result - 2));
  LocalFree(message);
  fmt::memory_buffer actual_message;
  fmt::detail::format_windows_error(actual_message, provisioning_not_allowed,
                                    "test");
  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
            fmt::to_string(actual_message));
}

TEST(os_test, windows_error) {
  auto error = std::system_error(std::error_code());
  try {
    throw fmt::windows_error(ERROR_FILE_EXISTS, "test {}", "error");
  } catch (const std::system_error& e) {
    error = e;
  }
  fmt::memory_buffer message;
  fmt::detail::format_windows_error(message, ERROR_FILE_EXISTS, "test error");
  EXPECT_THAT(error.what(), HasSubstr(to_string(message)));
  EXPECT_EQ(ERROR_FILE_EXISTS, error.code().value());
}

TEST(os_test, report_windows_error) {
  fmt::memory_buffer out;
  fmt::detail::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
  out.push_back('\n');
  EXPECT_WRITE(stderr,
               fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
               fmt::to_string(out));
}

#endif  // _WIN32

#if FMT_USE_FCNTL

using fmt::file;

bool isclosed(int fd) {
  char buffer;
  auto result = std::streamsize();
  SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1)));
  return result == -1 && errno == EBADF;
}

// Opens a file for reading.
file open_file() {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  write_end.write(file_content, std::strlen(file_content));
  write_end.close();
  return read_end;
}

// Attempts to write a string to a file.
void write(file& f, fmt::string_view s) {
  size_t num_chars_left = s.size();
  const char* ptr = s.data();
  do {
    size_t count = f.write(ptr, num_chars_left);
    ptr += count;
    // We can't write more than size_t bytes since num_chars_left
    // has type size_t.
    num_chars_left -= count;
  } while (num_chars_left != 0);
}

TEST(buffered_file_test, default_ctor) {
  auto f = buffered_file();
  EXPECT_TRUE(f.get() == nullptr);
}

TEST(buffered_file_test, move_ctor) {
  buffered_file bf = open_buffered_file();
  FILE* fp = bf.get();
  EXPECT_TRUE(fp != nullptr);
  buffered_file bf2(std::move(bf));
  EXPECT_EQ(fp, bf2.get());
  EXPECT_TRUE(bf.get() == nullptr);
}

TEST(buffered_file_test, move_assignment) {
  buffered_file bf = open_buffered_file();
  FILE* fp = bf.get();
  EXPECT_TRUE(fp != nullptr);
  buffered_file bf2;
  bf2 = std::move(bf);
  EXPECT_EQ(fp, bf2.get());
  EXPECT_TRUE(bf.get() == nullptr);
}

TEST(buffered_file_test, move_assignment_closes_file) {
  buffered_file bf = open_buffered_file();
  buffered_file bf2 = open_buffered_file();
  int old_fd = bf2.fileno();
  bf2 = std::move(bf);
  EXPECT_TRUE(isclosed(old_fd));
}

TEST(buffered_file_test, move_from_temporary_in_ctor) {
  FILE* fp = nullptr;
  buffered_file f = open_buffered_file(&fp);
  EXPECT_EQ(fp, f.get());
}

TEST(buffered_file_test, move_from_temporary_in_assignment) {
  FILE* fp = nullptr;
  auto f = buffered_file();
  f = open_buffered_file(&fp);
  EXPECT_EQ(fp, f.get());
}

TEST(buffered_file_test, move_from_temporary_in_assignment_closes_file) {
  buffered_file f = open_buffered_file();
  int old_fd = f.fileno();
  f = open_buffered_file();
  EXPECT_TRUE(isclosed(old_fd));
}

TEST(buffered_file_test, close_file_in_dtor) {
  int fd = 0;
  {
    buffered_file f = open_buffered_file();
    fd = f.fileno();
  }
  EXPECT_TRUE(isclosed(fd));
}

TEST(buffered_file_test, close_error_in_dtor) {
  auto f =
      std::unique_ptr<buffered_file>(new buffered_file(open_buffered_file()));
  EXPECT_WRITE(
      stderr,
      {
        // The close function must be called inside EXPECT_WRITE,
        // otherwise the system may recycle closed file descriptor when
        // redirecting the output in EXPECT_STDERR and the second close
        // will break output redirection.
        FMT_POSIX(close(f->fileno()));
        SUPPRESS_ASSERT(f.reset(nullptr));
      },
      system_error_message(EBADF, "cannot close file") + "\n");
}

TEST(buffered_file_test, close) {
  buffered_file f = open_buffered_file();
  int fd = f.fileno();
  f.close();
  EXPECT_TRUE(f.get() == nullptr);
  EXPECT_TRUE(isclosed(fd));
}

TEST(buffered_file_test, close_error) {
  buffered_file f = open_buffered_file();
  FMT_POSIX(close(f.fileno()));
  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
  EXPECT_TRUE(f.get() == nullptr);
}

TEST(buffered_file_test, fileno) {
  auto f = open_buffered_file();
  EXPECT_TRUE(f.fileno() != -1);
  file copy = file::dup(f.fileno());
  EXPECT_READ(copy, file_content);
}

TEST(ostream_test, move) {
  fmt::ostream out = fmt::output_file("test-file");
  fmt::ostream moved(std::move(out));
  moved.print("hello");
}

TEST(ostream_test, move_while_holding_data) {
  {
    fmt::ostream out = fmt::output_file("test-file");
    out.print("Hello, ");
    fmt::ostream moved(std::move(out));
    moved.print("world!\n");
  }
  {
    file in("test-file", file::RDONLY);
    EXPECT_READ(in, "Hello, world!\n");
  }
}

TEST(ostream_test, print) {
  fmt::ostream out = fmt::output_file("test-file");
  out.print("The answer is {}.\n",
            fmt::join(std::initializer_list<int>{42}, ", "));
  out.close();
  file in("test-file", file::RDONLY);
  EXPECT_READ(in, "The answer is 42.\n");
}

TEST(ostream_test, buffer_boundary) {
  auto str = std::string(4096, 'x');
  fmt::ostream out = fmt::output_file("test-file");
  out.print("{}", str);
  out.print("{}", str);
  out.close();
  file in("test-file", file::RDONLY);
  EXPECT_READ(in, str + str);
}

TEST(ostream_test, buffer_size) {
  fmt::ostream out = fmt::output_file("test-file", fmt::buffer_size = 1);
  out.print("{}", "foo");
  out.close();
  file in("test-file", file::RDONLY);
  EXPECT_READ(in, "foo");
}

TEST(ostream_test, truncate) {
  {
    fmt::ostream out = fmt::output_file("test-file");
    out.print("0123456789");
  }
  {
    fmt::ostream out = fmt::output_file("test-file");
    out.print("foo");
  }
  file in("test-file", file::RDONLY);
  EXPECT_EQ("foo", read(in, 4));
}

TEST(file_test, default_ctor) {
  file f;
  EXPECT_EQ(-1, f.descriptor());
}

TEST(file_test, open_buffered_file_in_ctor) {
  FILE* fp = safe_fopen("test-file", "w");
  std::fputs(file_content, fp);
  std::fclose(fp);
  file f("test-file", file::RDONLY);
  // Check if the file is open by reading one character from it.
  char buffer;
  bool isopen = FMT_POSIX(read(f.descriptor(), &buffer, 1)) == 1;
  ASSERT_TRUE(isopen);
}

TEST(file_test, open_buffered_file_error) {
  EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT,
                      "cannot open file nonexistent");
}

TEST(file_test, move_ctor) {
  file f = open_file();
  int fd = f.descriptor();
  EXPECT_NE(-1, fd);
  file f2(std::move(f));
  EXPECT_EQ(fd, f2.descriptor());
  EXPECT_EQ(-1, f.descriptor());
}

TEST(file_test, move_assignment) {
  file f = open_file();
  int fd = f.descriptor();
  EXPECT_NE(-1, fd);
  file f2;
  f2 = std::move(f);
  EXPECT_EQ(fd, f2.descriptor());
  EXPECT_EQ(-1, f.descriptor());
}

TEST(file_test, move_assignment_closes_file) {
  file f = open_file();
  file f2 = open_file();
  int old_fd = f2.descriptor();
  f2 = std::move(f);
  EXPECT_TRUE(isclosed(old_fd));
}

file open_buffered_file(int& fd) {
  file f = open_file();
  fd = f.descriptor();
  return f;
}

TEST(file_test, move_from_temporary_in_ctor) {
  int fd = 0xdead;
  file f(open_buffered_file(fd));
  EXPECT_EQ(fd, f.descriptor());
}

TEST(file_test, move_from_temporary_in_assignment) {
  int fd = 0xdead;
  file f;
  f = open_buffered_file(fd);
  EXPECT_EQ(fd, f.descriptor());
}

TEST(file_test, move_from_temporary_in_assignment_closes_file) {
  int fd = 0xdead;
  file f = open_file();
  int old_fd = f.descriptor();
  f = open_buffered_file(fd);
  EXPECT_TRUE(isclosed(old_fd));
}

TEST(file_test, close_file_in_dtor) {
  int fd = 0;
  {
    file f = open_file();
    fd = f.descriptor();
  }
  EXPECT_TRUE(isclosed(fd));
}

TEST(file_test, close_error_in_dtor) {
  std::unique_ptr<file> f(new file(open_file()));
  EXPECT_WRITE(
      stderr,
      {
        // The close function must be called inside EXPECT_WRITE,
        // otherwise the system may recycle closed file descriptor when
        // redirecting the output in EXPECT_STDERR and the second close
        // will break output redirection.
        FMT_POSIX(close(f->descriptor()));
        SUPPRESS_ASSERT(f.reset(nullptr));
      },
      system_error_message(EBADF, "cannot close file") + "\n");
}

TEST(file_test, close) {
  file f = open_file();
  int fd = f.descriptor();
  f.close();
  EXPECT_EQ(-1, f.descriptor());
  EXPECT_TRUE(isclosed(fd));
}

TEST(file_test, close_error) {
  file f = open_file();
  FMT_POSIX(close(f.descriptor()));
  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
  EXPECT_EQ(-1, f.descriptor());
}

TEST(file_test, read) {
  file f = open_file();
  EXPECT_READ(f, file_content);
}

TEST(file_test, read_error) {
  file f("test-file", file::WRONLY);
  char buf;
  // We intentionally read from a file opened in the write-only mode to
  // cause error.
  EXPECT_SYSTEM_ERROR(f.read(&buf, 1), EBADF, "cannot read from file");
}

TEST(file_test, write) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  write(write_end, "test");
  write_end.close();
  EXPECT_READ(read_end, "test");
}

TEST(file_test, write_error) {
  file f("test-file", file::RDONLY);
  // We intentionally write to a file opened in the read-only mode to
  // cause error.
  EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
}

TEST(file_test, dup) {
  file f = open_file();
  file copy = file::dup(f.descriptor());
  EXPECT_NE(f.descriptor(), copy.descriptor());
  EXPECT_EQ(file_content, read(copy, std::strlen(file_content)));
}

#  ifndef __COVERITY__
TEST(file_test, dup_error) {
  int value = -1;
  EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF,
                               "cannot duplicate file descriptor -1");
}
#  endif

TEST(file_test, dup2) {
  file f = open_file();
  file copy = open_file();
  f.dup2(copy.descriptor());
  EXPECT_NE(f.descriptor(), copy.descriptor());
  EXPECT_READ(copy, file_content);
}

TEST(file_test, dup2_error) {
  file f = open_file();
  EXPECT_SYSTEM_ERROR_NOASSERT(
      f.dup2(-1), EBADF,
      fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
}

TEST(file_test, dup2_noexcept) {
  file f = open_file();
  file copy = open_file();
  std::error_code ec;
  f.dup2(copy.descriptor(), ec);
  EXPECT_EQ(ec.value(), 0);
  EXPECT_NE(f.descriptor(), copy.descriptor());
  EXPECT_READ(copy, file_content);
}

TEST(file_test, dup2_noexcept_error) {
  file f = open_file();
  std::error_code ec;
  SUPPRESS_ASSERT(f.dup2(-1, ec));
  EXPECT_EQ(EBADF, ec.value());
}

TEST(file_test, pipe) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  EXPECT_NE(-1, read_end.descriptor());
  EXPECT_NE(-1, write_end.descriptor());
  write(write_end, "test");
  EXPECT_READ(read_end, "test");
}

TEST(file_test, fdopen) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  int read_fd = read_end.descriptor();
  EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
}

#  ifdef FMT_LOCALE
TEST(locale_test, strtod) {
  fmt::locale loc;
  const char *start = "4.2", *ptr = start;
  EXPECT_EQ(4.2, loc.strtod(ptr));
  EXPECT_EQ(start + 3, ptr);
}
#  endif
#endif  // FMT_USE_FCNTL


================================================
FILE: examples/libraries/fmt/test/ostream-test.cc
================================================
// Formatting library for C++ - std::ostream support tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/format.h"

using fmt::runtime;

struct test {};

// Test that there is no issues with specializations when fmt/ostream.h is
// included after fmt/format.h.
namespace fmt {
template <> struct formatter<test> : formatter<int> {
  auto format(const test&, format_context& ctx) -> decltype(ctx.out()) {
    return formatter<int>::format(42, ctx);
  }
};
}  // namespace fmt

#include <sstream>

#include "fmt/ostream.h"
#include "fmt/ranges.h"
#include "gmock/gmock.h"
#include "gtest-extra.h"
#include "util.h"

std::ostream& operator<<(std::ostream& os, const date& d) {
  os << d.year() << '-' << d.month() << '-' << d.day();
  return os;
}

std::wostream& operator<<(std::wostream& os, const date& d) {
  os << d.year() << L'-' << d.month() << L'-' << d.day();
  return os;
}

// Make sure that overloaded comma operators do no harm to is_streamable.
struct type_with_comma_op {};
template <typename T> void operator,(type_with_comma_op, const T&);
template <typename T> type_with_comma_op operator<<(T&, const date&);

enum streamable_enum {};

std::ostream& operator<<(std::ostream& os, streamable_enum) {
  return os << "streamable_enum";
}

enum unstreamable_enum {};

TEST(ostream_test, enum) {
  EXPECT_EQ("streamable_enum", fmt::format("{}", streamable_enum()));
  EXPECT_EQ("0", fmt::format("{}", unstreamable_enum()));
}

TEST(ostream_test, format) {
  EXPECT_EQ("a string", fmt::format("{0}", test_string("a string")));
  EXPECT_EQ("The date is 2012-12-9",
            fmt::format("The date is {0}", date(2012, 12, 9)));
}

TEST(ostream_test, format_specs) {
  using fmt::format_error;
  EXPECT_EQ("def  ", fmt::format("{0:<5}", test_string("def")));
  EXPECT_EQ("  def", fmt::format("{0:>5}", test_string("def")));
  EXPECT_EQ(" def ", fmt::format("{0:^5}", test_string("def")));
  EXPECT_EQ("def**", fmt::format("{0:*<5}", test_string("def")));
  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), test_string()), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), test_string()), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), test_string()), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:#}"), test_string()), format_error,
                   "format specifier requires numeric argument");
  EXPECT_THROW_MSG(fmt::format(runtime("{0:05}"), test_string()), format_error,
                   "format specifier requires numeric argument");
  EXPECT_EQ("test         ", fmt::format("{0:13}", test_string("test")));
  EXPECT_EQ("test         ", fmt::format("{0:{1}}", test_string("test"), 13));
  EXPECT_EQ("te", fmt::format("{0:.2}", test_string("test")));
  EXPECT_EQ("te", fmt::format("{0:.{1}}", test_string("test"), 2));
}

struct empty_test {};
std::ostream& operator<<(std::ostream& os, empty_test) { return os << ""; }

TEST(ostream_test, empty_custom_output) {
  EXPECT_EQ("", fmt::format("{}", empty_test()));
}

TEST(ostream_test, print) {
  std::ostringstream os;
  fmt::print(os, "Don't {}!", "panic");
  EXPECT_EQ("Don't panic!", os.str());
}

TEST(ostream_test, write_to_ostream) {
  std::ostringstream os;
  fmt::memory_buffer buffer;
  const char* foo = "foo";
  buffer.append(foo, foo + std::strlen(foo));
  fmt::detail::write_buffer(os, buffer);
  EXPECT_EQ("foo", os.str());
}

TEST(ostream_test, write_to_ostream_max_size) {
  auto max_size = fmt::detail::max_value<size_t>();
  auto max_streamsize = fmt::detail::max_value<std::streamsize>();
  if (max_size <= fmt::detail::to_unsigned(max_streamsize)) return;

  struct test_buffer final : fmt::detail::buffer<char> {
    explicit test_buffer(size_t size)
        : fmt::detail::buffer<char>(nullptr, size, size) {}
    void grow(size_t) {}
  } buffer(max_size);

  struct mock_streambuf : std::streambuf {
    MOCK_METHOD2(xsputn, std::streamsize(const void* s, std::streamsize n));
    std::streamsize xsputn(const char* s, std::streamsize n) {
      const void* v = s;
      return xsputn(v, n);
    }
  } streambuf;

  struct test_ostream : std::ostream {
    explicit test_ostream(mock_streambuf& output_buffer)
        : std::ostream(&output_buffer) {}
  } os(streambuf);

  testing::InSequence sequence;
  const char* data = nullptr;
  using ustreamsize = std::make_unsigned<std::streamsize>::type;
  ustreamsize size = max_size;
  do {
    auto n = std::min(size, fmt::detail::to_unsigned(max_streamsize));
    EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
        .WillOnce(testing::Return(max_streamsize));
    data += n;
    size -= n;
  } while (size != 0);
  fmt::detail::write_buffer(os, buffer);
}

TEST(ostream_test, join) {
  int v[3] = {1, 2, 3};
  EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, v + 3, ", ")));
}

TEST(ostream_test, join_fallback_formatter) {
  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
  EXPECT_EQ("foo, bar", fmt::format("{}", fmt::join(strs, ", ")));
}

#if FMT_USE_CONSTEXPR
TEST(ostream_test, constexpr_string) {
  EXPECT_EQ("42", format(FMT_STRING("{}"), std::string("42")));
  EXPECT_EQ("a string", format(FMT_STRING("{0}"), test_string("a string")));
}
#endif

namespace fmt_test {
struct abc {};

template <typename Output> Output& operator<<(Output& out, abc) {
  return out << "abc";
}
}  // namespace fmt_test

template <typename T> struct test_template {};

template <typename T>
std::ostream& operator<<(std::ostream& os, test_template<T>) {
  return os << 1;
}

namespace fmt {
template <typename T> struct formatter<test_template<T>> : formatter<int> {
  auto format(test_template<T>, format_context& ctx) -> decltype(ctx.out()) {
    return formatter<int>::format(2, ctx);
  }
};
}  // namespace fmt

TEST(ostream_test, template) {
  EXPECT_EQ("2", fmt::format("{}", test_template<int>()));
}

TEST(ostream_test, format_to_n) {
  char buffer[4];
  buffer[3] = 'x';
  auto result = fmt::format_to_n(buffer, 3, "{}", fmt_test::abc());
  EXPECT_EQ(3u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ("abcx", fmt::string_view(buffer, 4));
  result = fmt::format_to_n(buffer, 3, "x{}y", fmt_test::abc());
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ("xabx", fmt::string_view(buffer, 4));
}

template <typename T> struct convertible {
  T value;
  explicit convertible(const T& val) : value(val) {}
  operator T() const { return value; }
};

TEST(ostream_test, disable_builtin_ostream_operators) {
  EXPECT_EQ("42", fmt::format("{:d}", convertible<unsigned short>(42)));
  EXPECT_EQ("foo", fmt::format("{}", convertible<const char*>("foo")));
}

struct explicitly_convertible_to_string_like {
  template <typename String,
            typename = typename std::enable_if<std::is_constructible<
                String, const char*, size_t>::value>::type>
  explicit operator String() const {
    return String("foo", 3u);
  }
};

std::ostream& operator<<(std::ostream& os,
                         explicitly_convertible_to_string_like) {
  return os << "bar";
}

TEST(ostream_test, format_explicitly_convertible_to_string_like) {
  EXPECT_EQ("bar", fmt::format("{}", explicitly_convertible_to_string_like()));
}

#ifdef FMT_USE_STRING_VIEW
struct explicitly_convertible_to_std_string_view {
  explicit operator fmt::detail::std_string_view<char>() const {
    return {"foo", 3u};
  }
};

std::ostream& operator<<(std::ostream& os,
                         explicitly_convertible_to_std_string_view) {
  return os << "bar";
}

TEST(ostream_test, format_explicitly_convertible_to_std_string_view) {
  EXPECT_EQ("bar", fmt::format("{}", explicitly_convertible_to_string_like()));
}
#endif  // FMT_USE_STRING_VIEW

struct streamable_and_convertible_to_bool {
  operator bool() const { return true; }
};

std::ostream& operator<<(std::ostream& os, streamable_and_convertible_to_bool) {
  return os << "foo";
}

TEST(ostream_test, format_convertible_to_bool) {
  EXPECT_EQ("foo", fmt::format("{}", streamable_and_convertible_to_bool()));
}

struct copyfmt_test {};

std::ostream& operator<<(std::ostream& os, copyfmt_test) {
  std::ios ios(nullptr);
  ios.copyfmt(os);
  return os << "foo";
}

TEST(ostream_test, copyfmt) {
  EXPECT_EQ("foo", fmt::format("{}", copyfmt_test()));
}

TEST(ostream_test, to_string) {
  EXPECT_EQ("abc", fmt::to_string(fmt_test::abc()));
}

TEST(ostream_test, range) {
  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
  EXPECT_EQ("[foo, bar]", fmt::format("{}", strs));
}


================================================
FILE: examples/libraries/fmt/test/posix-mock-test.cc
================================================
// Tests of the C++ interface to POSIX functions that require mocks
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

// Disable bogus MSVC warnings.
#ifndef _CRT_SECURE_NO_WARNINGS
#  define _CRT_SECURE_NO_WARNINGS
#endif

#include "posix-mock.h"

#include <errno.h>
#include <fcntl.h>

#include <climits>
#include <memory>

#include "../src/os.cc"

#ifdef _WIN32
#  include <io.h>
#  undef max
#endif

#include "gmock/gmock.h"
#include "gtest-extra.h"
#include "util.h"

using fmt::buffered_file;

using testing::_;
using testing::Return;
using testing::StrEq;

template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> {
  scoped_mock() { Mock::instance = this; }
  ~scoped_mock() { Mock::instance = nullptr; }
};

namespace {
int open_count;
int close_count;
int dup_count;
int dup2_count;
int fdopen_count;
int read_count;
int write_count;
int pipe_count;
int fopen_count;
int fclose_count;
int fileno_count;
size_t read_nbyte;
size_t write_nbyte;
bool sysconf_error;

enum { none, max_size, error } fstat_sim;
}  // namespace

#define EMULATE_EINTR(func, error_result) \
  if (func##_count != 0) {                \
    if (func##_count++ != 3) {            \
      errno = EINTR;                      \
      return error_result;                \
    }                                     \
  }

#ifndef _MSC_VER
int test::open(const char* path, int oflag, int mode) {
  EMULATE_EINTR(open, -1);
  return ::open(path, oflag, mode);
}
#else
errno_t test::sopen_s(int* pfh, const char* filename, int oflag, int shflag,
                      int pmode) {
  EMULATE_EINTR(open, EINTR);
  return _sopen_s(pfh, filename, oflag, shflag, pmode);
}
#endif

#ifndef _WIN32

long test::sysconf(int name) {
  long result = ::sysconf(name);
  if (!sysconf_error) return result;
  // Simulate an error.
  errno = EINVAL;
  return -1;
}

static off_t max_file_size() { return std::numeric_limits<off_t>::max(); }

int test::fstat(int fd, struct stat* buf) {
  int result = ::fstat(fd, buf);
  if (fstat_sim == max_size) buf->st_size = max_file_size();
  return result;
}

#else

static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); }

DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
  if (fstat_sim == error) {
    SetLastError(ERROR_ACCESS_DENIED);
    return INVALID_FILE_SIZE;
  }
  if (fstat_sim == max_size) {
    DWORD max = std::numeric_limits<DWORD>::max();
    *lpFileSizeHigh = max >> 1;
    return max;
  }
  return ::GetFileSize(hFile, lpFileSizeHigh);
}

#endif

int test::close(int fildes) {
  // Close the file first because close shouldn't be retried.
  int result = ::FMT_POSIX(close(fildes));
  EMULATE_EINTR(close, -1);
  return result;
}

int test::dup(int fildes) {
  EMULATE_EINTR(dup, -1);
  return ::FMT_POSIX(dup(fildes));
}

int test::dup2(int fildes, int fildes2) {
  EMULATE_EINTR(dup2, -1);
  return ::FMT_POSIX(dup2(fildes, fildes2));
}

FILE* test::fdopen(int fildes, const char* mode) {
  EMULATE_EINTR(fdopen, nullptr);
  return ::FMT_POSIX(fdopen(fildes, mode));
}

test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) {
  read_nbyte = nbyte;
  EMULATE_EINTR(read, -1);
  return ::FMT_POSIX(read(fildes, buf, nbyte));
}

test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) {
  write_nbyte = nbyte;
  EMULATE_EINTR(write, -1);
  return ::FMT_POSIX(write(fildes, buf, nbyte));
}

#ifndef _WIN32
int test::pipe(int fildes[2]) {
  EMULATE_EINTR(pipe, -1);
  return ::pipe(fildes);
}
#else
int test::pipe(int* pfds, unsigned psize, int textmode) {
  EMULATE_EINTR(pipe, -1);
  return _pipe(pfds, psize, textmode);
}
#endif

FILE* test::fopen(const char* filename, const char* mode) {
  EMULATE_EINTR(fopen, nullptr);
  return ::fopen(filename, mode);
}

int test::fclose(FILE* stream) {
  EMULATE_EINTR(fclose, EOF);
  return ::fclose(stream);
}

int(test::fileno)(FILE* stream) {
  EMULATE_EINTR(fileno, -1);
#ifdef fileno
  return FMT_POSIX(fileno(stream));
#else
  return ::FMT_POSIX(fileno(stream));
#endif
}

#ifndef _WIN32
#  define EXPECT_RETRY(statement, func, message) \
    func##_count = 1;                            \
    statement;                                   \
    EXPECT_EQ(4, func##_count);                  \
    func##_count = 0;
#  define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual)
#else
#  define EXPECT_RETRY(statement, func, message)    \
    func##_count = 1;                               \
    EXPECT_SYSTEM_ERROR(statement, EINTR, message); \
    func##_count = 0;
#  define EXPECT_EQ_POSIX(expected, actual)
#endif

#if FMT_USE_FCNTL
void write_file(fmt::cstring_view filename, fmt::string_view content) {
  fmt::buffered_file f(filename, "w");
  f.print("{}", content);
}

using fmt::file;

TEST(os_test, getpagesize) {
#  ifdef _WIN32
  SYSTEM_INFO si = {};
  GetSystemInfo(&si);
  EXPECT_EQ(si.dwPageSize, fmt::getpagesize());
#  else
  EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize());
  sysconf_error = true;
  EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL,
                      "cannot get memory page size");
  sysconf_error = false;
#  endif
}

TEST(file_test, open_retry) {
  write_file("temp", "there must be something here");
  std::unique_ptr<file> f{nullptr};
  EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open,
               "cannot open file temp");
#  ifndef _WIN32
  char c = 0;
  f->read(&c, 1);
#  endif
}

TEST(file_test, close_no_retry_in_dtor) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  std::unique_ptr<file> f(new file(std::move(read_end)));
  int saved_close_count = 0;
  EXPECT_WRITE(
      stderr,
      {
        close_count = 1;
        f.reset(nullptr);
        saved_close_count = close_count;
        close_count = 0;
      },
      system_error_message(EINTR, "cannot close file") + "\n");
  EXPECT_EQ(2, saved_close_count);
}

TEST(file_test, close_no_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  close_count = 1;
  EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
  EXPECT_EQ(2, close_count);
  close_count = 0;
}

TEST(file_test, size) {
  std::string content = "top secret, destroy before reading";
  write_file("temp", content);
  file f("temp", file::RDONLY);
  EXPECT_GE(f.size(), 0);
  EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
#  ifdef _WIN32
  auto error_code = std::error_code();
  fstat_sim = error;
  try {
    f.size();
  } catch (const std::system_error& e) {
    error_code = e.code();
  }
  fstat_sim = none;
  EXPECT_EQ(error_code,
            std::error_code(ERROR_ACCESS_DENIED, fmt::system_category()));
#  else
  f.close();
  EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes");
#  endif
}

TEST(file_test, max_size) {
  write_file("temp", "");
  file f("temp", file::RDONLY);
  fstat_sim = max_size;
  EXPECT_GE(f.size(), 0);
  EXPECT_EQ(max_file_size(), f.size());
  fstat_sim = none;
}

TEST(file_test, read_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  enum { SIZE = 4 };
  write_end.write("test", SIZE);
  write_end.close();
  char buffer[SIZE];
  size_t count = 0;
  EXPECT_RETRY(count = read_end.read(buffer, SIZE), read,
               "cannot read from file");
  EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
}

TEST(file_test, write_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  enum { SIZE = 4 };
  size_t count = 0;
  EXPECT_RETRY(count = write_end.write("test", SIZE), write,
               "cannot write to file");
  write_end.close();
#  ifndef _WIN32
  EXPECT_EQ(static_cast<std::streamsize>(SIZE), count);
  char buffer[SIZE + 1];
  read_end.read(buffer, SIZE);
  buffer[SIZE] = '\0';
  EXPECT_STREQ("test", buffer);
#  endif
}

#  ifdef _WIN32
TEST(file_test, convert_read_count) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  char c;
  size_t size = UINT_MAX;
  if (sizeof(unsigned) != sizeof(size_t)) ++size;
  read_count = 1;
  read_nbyte = 0;
  EXPECT_THROW(read_end.read(&c, size), std::system_error);
  read_count = 0;
  EXPECT_EQ(UINT_MAX, read_nbyte);
}

TEST(file_test, convert_write_count) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  char c;
  size_t size = UINT_MAX;
  if (sizeof(unsigned) != sizeof(size_t)) ++size;
  write_count = 1;
  write_nbyte = 0;
  EXPECT_THROW(write_end.write(&c, size), std::system_error);
  write_count = 0;
  EXPECT_EQ(UINT_MAX, write_nbyte);
}
#  endif

TEST(file_test, dup_no_retry) {
  int stdout_fd = FMT_POSIX(fileno(stdout));
  dup_count = 1;
  EXPECT_SYSTEM_ERROR(
      file::dup(stdout_fd), EINTR,
      fmt::format("cannot duplicate file descriptor {}", stdout_fd));
  dup_count = 0;
}

TEST(file_test, dup2_retry) {
  int stdout_fd = FMT_POSIX(fileno(stdout));
  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
  EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
               fmt::format("cannot duplicate file descriptor {} to {}",
                           f1.descriptor(), f2.descriptor()));
}

TEST(file_test, dup2_no_except_retry) {
  int stdout_fd = FMT_POSIX(fileno(stdout));
  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
  std::error_code ec;
  dup2_count = 1;
  f1.dup2(f2.descriptor(), ec);
#  ifndef _WIN32
  EXPECT_EQ(4, dup2_count);
#  else
  EXPECT_EQ(EINTR, ec.value());
#  endif
  dup2_count = 0;
}

TEST(file_test, pipe_no_retry) {
  file read_end, write_end;
  pipe_count = 1;
  EXPECT_SYSTEM_ERROR(file::pipe(read_end, write_end), EINTR,
                      "cannot create pipe");
  pipe_count = 0;
}

TEST(file_test, fdopen_no_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  fdopen_count = 1;
  EXPECT_SYSTEM_ERROR(read_end.fdopen("r"), EINTR,
                      "cannot associate stream with file descriptor");
  fdopen_count = 0;
}

TEST(buffered_file_test, open_retry) {
  write_file("temp", "there must be something here");
  std::unique_ptr<buffered_file> f{nullptr};
  EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen,
               "cannot open file temp");
#  ifndef _WIN32
  char c = 0;
  if (fread(&c, 1, 1, f->get()) < 1)
    throw fmt::system_error(errno, "fread failed");
#  endif
}

TEST(buffered_file_test, close_no_retry_in_dtor) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  std::unique_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
  int saved_fclose_count = 0;
  EXPECT_WRITE(
      stderr,
      {
        fclose_count = 1;
        f.reset(nullptr);
        saved_fclose_count = fclose_count;
        fclose_count = 0;
      },
      system_error_message(EINTR, "cannot close file") + "\n");
  EXPECT_EQ(2, saved_fclose_count);
}

TEST(buffered_file_test, close_no_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  buffered_file f = read_end.fdopen("r");
  fclose_count = 1;
  EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
  EXPECT_EQ(2, fclose_count);
  fclose_count = 0;
}

TEST(buffered_file_test, fileno_no_retry) {
  file read_end, write_end;
  file::pipe(read_end, write_end);
  buffered_file f = read_end.fdopen("r");
  fileno_count = 1;
  EXPECT_SYSTEM_ERROR((f.fileno)(), EINTR, "cannot get file descriptor");
  EXPECT_EQ(2, fileno_count);
  fileno_count = 0;
}
#endif  // FMT_USE_FCNTL

struct test_mock {
  static test_mock* instance;
} * test_mock::instance;

TEST(scoped_mock, scope) {
  {
    scoped_mock<test_mock> mock;
    EXPECT_EQ(&mock, test_mock::instance);
    test_mock& copy = mock;
    static_cast<void>(copy);
  }
  EXPECT_EQ(nullptr, test_mock::instance);
}

#ifdef FMT_LOCALE

using locale_type = fmt::locale::type;

struct locale_mock {
  static locale_mock* instance;
  MOCK_METHOD3(newlocale, locale_type(int category_mask, const char* locale,
                                      locale_type base));
  MOCK_METHOD1(freelocale, void(locale_type locale));

  MOCK_METHOD3(strtod_l,
               double(const char* nptr, char** endptr, locale_type locale));
} * locale_mock::instance;

#  ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4273)
#    ifdef __clang__
#      pragma clang diagnostic push
#      pragma clang diagnostic ignored "-Winconsistent-dllimport"
#    endif

_locale_t _create_locale(int category, const char* locale) {
  return locale_mock::instance->newlocale(category, locale, 0);
}

void _free_locale(_locale_t locale) {
  locale_mock::instance->freelocale(locale);
}

double _strtod_l(const char* nptr, char** endptr, _locale_t locale) {
  return locale_mock::instance->strtod_l(nptr, endptr, locale);
}
#    ifdef __clang__
#      pragma clang diagnostic pop
#    endif
#    pragma warning(pop)
#  endif

#  if defined(__THROW) && \
      ((FMT_GCC_VERSION > 0 && FMT_GCC_VERSION <= 408) || defined(__e2k__))
#    define FMT_LOCALE_THROW __THROW
#  else
#    define FMT_LOCALE_THROW
#  endif

#  if defined(__APPLE__) || \
      (defined(__FreeBSD__) && __FreeBSD_version < 1200002)
typedef int FreeLocaleResult;
#  else
typedef void FreeLocaleResult;
#  endif

FreeLocaleResult freelocale(locale_type locale) FMT_LOCALE_THROW {
  locale_mock::instance->freelocale(locale);
  return FreeLocaleResult();
}

double strtod_l(const char* nptr, char** endptr,
                locale_type locale) FMT_LOCALE_THROW {
  return locale_mock::instance->strtod_l(nptr, endptr, locale);
}

#  undef FMT_LOCALE_THROW

#  ifndef _WIN32
locale_t test::newlocale(int category_mask, const char* locale, locale_t base) {
  return locale_mock::instance->newlocale(category_mask, locale, base);
}

TEST(locale_test, locale_mock) {
  scoped_mock<locale_mock> mock;
  auto locale = reinterpret_cast<locale_type>(11);
  EXPECT_CALL(mock, newlocale(222, StrEq("foo"), locale));
  FMT_SYSTEM(newlocale(222, "foo", locale));
}
#  endif

TEST(locale_test, locale) {
#  ifndef LC_NUMERIC_MASK
  enum { LC_NUMERIC_MASK = LC_NUMERIC };
#  endif
  scoped_mock<locale_mock> mock;
  auto impl = reinterpret_cast<locale_type>(42);
  EXPECT_CALL(mock, newlocale(LC_NUMERIC_MASK, StrEq("C"), nullptr))
      .WillOnce(Return(impl));
  EXPECT_CALL(mock, freelocale(impl));
  fmt::locale loc;
  EXPECT_EQ(impl, loc.get());
}

TEST(locale_test, strtod) {
  scoped_mock<locale_mock> mock;
  EXPECT_CALL(mock, newlocale(_, _, _))
      .WillOnce(Return(reinterpret_cast<locale_type>(42)));
  EXPECT_CALL(mock, freelocale(_));
  fmt::locale loc;
  const char* str = "4.2";
  char end = 'x';
  EXPECT_CALL(mock, strtod_l(str, _, loc.get()))
      .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&end), Return(777)));
  EXPECT_EQ(777, loc.strtod(str));
  EXPECT_EQ(&end, str);
}

#endif  // FMT_LOCALE


================================================
FILE: examples/libraries/fmt/test/posix-mock.h
================================================
// Formatting library for C++ - mocks of POSIX functions
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_POSIX_TEST_H
#define FMT_POSIX_TEST_H

#include <errno.h>
#include <locale.h>
#include <stdio.h>
#ifdef __APPLE__
#  include <xlocale.h>
#endif

#ifdef _WIN32
#  include <windows.h>
#else
#  include <sys/param.h>  // for FreeBSD version
#  include <sys/types.h>  // for ssize_t
#endif

#ifndef _MSC_VER
struct stat;
#endif

namespace test {

#ifndef _MSC_VER
// Size type for read and write.
typedef size_t size_t;
typedef ssize_t ssize_t;
int open(const char* path, int oflag, int mode);
int fstat(int fd, struct stat* buf);
#else
typedef unsigned size_t;
typedef int ssize_t;
errno_t sopen_s(int* pfh, const char* filename, int oflag, int shflag,
                int pmode);
#endif

#ifndef _WIN32
long sysconf(int name);
#else
DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
#endif

int close(int fildes);

int dup(int fildes);
int dup2(int fildes, int fildes2);

FILE* fdopen(int fildes, const char* mode);

ssize_t read(int fildes, void* buf, size_t nbyte);
ssize_t write(int fildes, const void* buf, size_t nbyte);

#ifndef _WIN32
int pipe(int fildes[2]);
#else
int pipe(int* pfds, unsigned psize, int textmode);
#endif

FILE* fopen(const char* filename, const char* mode);
int fclose(FILE* stream);
int(fileno)(FILE* stream);

#if defined(FMT_LOCALE) && !defined(_WIN32)
locale_t newlocale(int category_mask, const char* locale, locale_t base);
#endif
}  // namespace test

#define FMT_SYSTEM(call) test::call

#endif  // FMT_POSIX_TEST_H


================================================
FILE: examples/libraries/fmt/test/printf-test.cc
================================================
// Formatting library for C++ - printf tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/printf.h"

#include <cctype>
#include <climits>
#include <cstring>

#include "fmt/ostream.h"
#include "fmt/xchar.h"
#include "gtest-extra.h"
#include "util.h"

using fmt::format;
using fmt::format_error;
using fmt::detail::max_value;

const unsigned big_num = INT_MAX + 1u;

// Makes format string argument positional.
static std::string make_positional(fmt::string_view format) {
  std::string s(format.data(), format.size());
  s.replace(s.find('%'), 1, "%1$");
  return s;
}

static std::wstring make_positional(fmt::basic_string_view<wchar_t> format) {
  std::wstring s(format.data(), format.size());
  s.replace(s.find(L'%'), 1, L"%1$");
  return s;
}

// A wrapper around fmt::sprintf to workaround bogus warnings about invalid
// format strings in MSVC.
template <typename... Args>
std::string test_sprintf(fmt::string_view format, const Args&... args) {
  return fmt::sprintf(format, args...);
}
template <typename... Args>
std::wstring test_sprintf(fmt::basic_string_view<wchar_t> format,
                          const Args&... args) {
  return fmt::sprintf(format, args...);
}

#define EXPECT_PRINTF(expected_output, format, arg)     \
  EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
      << "format: " << format;                          \
  EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))

TEST(printf_test, no_args) {
  EXPECT_EQ("test", test_sprintf("test"));
  EXPECT_EQ(L"test", fmt::sprintf(L"test"));
}

TEST(printf_test, escape) {
  EXPECT_EQ("%", test_sprintf("%%"));
  EXPECT_EQ("before %", test_sprintf("before %%"));
  EXPECT_EQ("% after", test_sprintf("%% after"));
  EXPECT_EQ("before % after", test_sprintf("before %% after"));
  EXPECT_EQ("%s", test_sprintf("%%s"));
  EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
  EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
  EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
  EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
  EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
}

TEST(printf_test, positional_args) {
  EXPECT_EQ("42", test_sprintf("%1$d", 42));
  EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
  EXPECT_EQ("42 after", test_sprintf("%1$d after", 42));
  EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
  EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
  EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42));
  EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
}

TEST(printf_test, automatic_arg_indexing) {
  EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
}

TEST(printf_test, number_is_too_big_in_arg_index) {
  EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error,
                   "argument not found");
}

TEST(printf_test, switch_arg_indexing) {
  EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error,
                   "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
                   format_error, "number is too big");
  EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error,
                   "cannot switch from manual to automatic argument indexing");

  EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error,
                   "cannot switch from automatic to manual argument indexing");
  EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error,
                   "cannot switch from automatic to manual argument indexing");
  EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error,
                   "cannot switch from automatic to manual argument indexing");

  // Indexing errors override width errors.
  EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2),
                   format_error, "number is too big");
  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
                   format_error, "number is too big");
}

TEST(printf_test, invalid_arg_index) {
  EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
                   "argument not found");
  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
                   "argument not found");

  EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error,
                   "argument not found");
}

TEST(printf_test, default_align_right) {
  EXPECT_PRINTF("   42", "%5d", 42);
  EXPECT_PRINTF("  abc", "%5s", "abc");
}

TEST(printf_test, zero_flag) {
  EXPECT_PRINTF("00042", "%05d", 42);
  EXPECT_PRINTF("-0042", "%05d", -42);

  EXPECT_PRINTF("00042", "%05d", 42);
  EXPECT_PRINTF("-0042", "%05d", -42);
  EXPECT_PRINTF("-004.2", "%06g", -4.2);

  EXPECT_PRINTF("+00042", "%00+6d", 42);

  EXPECT_PRINTF("   42", "%05.d", 42);
  EXPECT_PRINTF(" 0042", "%05.4d", 42);

  // '0' flag is ignored for non-numeric types.
  EXPECT_PRINTF("    x", "%05c", 'x');
}

TEST(printf_test, plus_flag) {
  EXPECT_PRINTF("+42", "%+d", 42);
  EXPECT_PRINTF("-42", "%+d", -42);
  EXPECT_PRINTF("+0042", "%+05d", 42);
  EXPECT_PRINTF("+0042", "%0++5d", 42);

  // '+' flag is ignored for non-numeric types.
  EXPECT_PRINTF("x", "%+c", 'x');

  // '+' flag wins over space flag
  EXPECT_PRINTF("+42", "%+ d", 42);
  EXPECT_PRINTF("-42", "%+ d", -42);
  EXPECT_PRINTF("+42", "% +d", 42);
  EXPECT_PRINTF("-42", "% +d", -42);
  EXPECT_PRINTF("+0042", "% +05d", 42);
  EXPECT_PRINTF("+0042", "%0+ 5d", 42);

  // '+' flag and space flag are both ignored for non-numeric types.
  EXPECT_PRINTF("x", "%+ c", 'x');
  EXPECT_PRINTF("x", "% +c", 'x');
}

TEST(printf_test, minus_flag) {
  EXPECT_PRINTF("abc  ", "%-5s", "abc");
  EXPECT_PRINTF("abc  ", "%0--5s", "abc");

  EXPECT_PRINTF("7    ", "%-5d", 7);
  EXPECT_PRINTF("97   ", "%-5hhi", 'a');
  EXPECT_PRINTF("a    ", "%-5c", 'a');

  // '0' flag is ignored if '-' flag is given
  EXPECT_PRINTF("7    ", "%-05d", 7);
  EXPECT_PRINTF("7    ", "%0-5d", 7);
  EXPECT_PRINTF("a    ", "%-05c", 'a');
  EXPECT_PRINTF("a    ", "%0-5c", 'a');
  EXPECT_PRINTF("97   ", "%-05hhi", 'a');
  EXPECT_PRINTF("97   ", "%0-5hhi", 'a');

  // '-' and space flag don't interfere
  EXPECT_PRINTF(" 42", "%- d", 42);
}

TEST(printf_test, space_flag) {
  EXPECT_PRINTF(" 42", "% d", 42);
  EXPECT_PRINTF("-42", "% d", -42);
  EXPECT_PRINTF(" 0042", "% 05d", 42);
  EXPECT_PRINTF(" 0042", "%0  5d", 42);

  // ' ' flag is ignored for non-numeric types.
  EXPECT_PRINTF("x", "% c", 'x');
}

TEST(printf_test, hash_flag) {
  EXPECT_PRINTF("042", "%#o", 042);
  EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042);
  EXPECT_PRINTF("0", "%#o", 0);

  EXPECT_PRINTF("0x42", "%#x", 0x42);
  EXPECT_PRINTF("0X42", "%#X", 0x42);
  EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x",
                -0x42);
  EXPECT_PRINTF("0", "%#x", 0);

  EXPECT_PRINTF("0x0042", "%#06x", 0x42);
  EXPECT_PRINTF("0x0042", "%0##6x", 0x42);

  EXPECT_PRINTF("-42.000000", "%#f", -42.0);
  EXPECT_PRINTF("-42.000000", "%#F", -42.0);

  char buffer[256];
  safe_sprintf(buffer, "%#e", -42.0);
  EXPECT_PRINTF(buffer, "%#e", -42.0);
  safe_sprintf(buffer, "%#E", -42.0);
  EXPECT_PRINTF(buffer, "%#E", -42.0);

  EXPECT_PRINTF("-42.0000", "%#g", -42.0);
  EXPECT_PRINTF("-42.0000", "%#G", -42.0);

  safe_sprintf(buffer, "%#a", 16.0);
  EXPECT_PRINTF(buffer, "%#a", 16.0);
  safe_sprintf(buffer, "%#A", 16.0);
  EXPECT_PRINTF(buffer, "%#A", 16.0);

  // '#' flag is ignored for non-numeric types.
  EXPECT_PRINTF("x", "%#c", 'x');
}

TEST(printf_test, width) {
  EXPECT_PRINTF("  abc", "%5s", "abc");

  // Width cannot be specified twice.
  EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
                   "invalid type specifier");

  EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error,
                   "number is too big");
  EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error,
                   "number is too big");
}

TEST(printf_test, dynamic_width) {
  EXPECT_EQ("   42", test_sprintf("%*d", 5, 42));
  EXPECT_EQ("42   ", test_sprintf("%*d", -5, 42));
  EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
                   "width is not integer");
  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
  EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error,
                   "number is too big");
}

TEST(printf_test, int_precision) {
  EXPECT_PRINTF("00042", "%.5d", 42);
  EXPECT_PRINTF("-00042", "%.5d", -42);
  EXPECT_PRINTF("00042", "%.5x", 0x42);
  EXPECT_PRINTF("0x00042", "%#.5x", 0x42);
  EXPECT_PRINTF("00042", "%.5o", 042);
  EXPECT_PRINTF("00042", "%#.5o", 042);

  EXPECT_PRINTF("  00042", "%7.5d", 42);
  EXPECT_PRINTF("  00042", "%7.5x", 0x42);
  EXPECT_PRINTF("   0x00042", "%#10.5x", 0x42);
  EXPECT_PRINTF("  00042", "%7.5o", 042);
  EXPECT_PRINTF("     00042", "%#10.5o", 042);

  EXPECT_PRINTF("00042  ", "%-7.5d", 42);
  EXPECT_PRINTF("00042  ", "%-7.5x", 0x42);
  EXPECT_PRINTF("0x00042   ", "%-#10.5x", 0x42);
  EXPECT_PRINTF("00042  ", "%-7.5o", 042);
  EXPECT_PRINTF("00042     ", "%-#10.5o", 042);
}

TEST(printf_test, float_precision) {
  char buffer[256];
  safe_sprintf(buffer, "%.3e", 1234.5678);
  EXPECT_PRINTF(buffer, "%.3e", 1234.5678);
  EXPECT_PRINTF("1234.568", "%.3f", 1234.5678);
  EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678);
  safe_sprintf(buffer, "%.3a", 1234.5678);
  EXPECT_PRINTF(buffer, "%.3a", 1234.5678);
}

TEST(printf_test, string_precision) {
  char test[] = {'H', 'e', 'l', 'l', 'o'};
  EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell");
}

TEST(printf_test, ignore_precision_for_non_numeric_arg) {
  EXPECT_PRINTF("abc", "%.5s", "abc");
}

TEST(printf_test, dynamic_precision) {
  EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
  EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
  EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
                   "precision is not integer");
  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
  EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error,
                   "number is too big");
  if (sizeof(long long) != sizeof(int)) {
    long long prec = static_cast<long long>(INT_MIN) - 1;
    EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
                     "number is too big");
  }
}

template <typename T> struct make_signed { typedef T type; };

#define SPECIALIZE_MAKE_SIGNED(T, S) \
  template <> struct make_signed<T> { typedef S type; }

SPECIALIZE_MAKE_SIGNED(char, signed char);
SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
SPECIALIZE_MAKE_SIGNED(unsigned short, short);
SPECIALIZE_MAKE_SIGNED(unsigned, int);
SPECIALIZE_MAKE_SIGNED(unsigned long, long);
SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);

// Test length format specifier ``length_spec``.
template <typename T, typename U>
void test_length(const char* length_spec, U value) {
  long long signed_value = 0;
  unsigned long long unsigned_value = 0;
  // Apply integer promotion to the argument.
  unsigned long long max = max_value<U>();
  using fmt::detail::const_check;
  if (const_check(max <= static_cast<unsigned>(max_value<int>()))) {
    signed_value = static_cast<int>(value);
    unsigned_value = static_cast<unsigned long long>(value);
  } else if (const_check(max <= max_value<unsigned>())) {
    signed_value = static_cast<unsigned>(value);
    unsigned_value = static_cast<unsigned long long>(value);
  }
  if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
    signed_value = static_cast<long long>(value);
    unsigned_value = static_cast<unsigned long long>(
        static_cast<typename std::make_unsigned<unsigned>::type>(value));
  } else {
    signed_value = static_cast<typename make_signed<T>::type>(value);
    unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
  }
  std::ostringstream os;
  os << signed_value;
  EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value);
  EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value);
  os.str("");
  os << unsigned_value;
  EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value);
  os.str("");
  os << std::oct << unsigned_value;
  EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value);
  os.str("");
  os << std::hex << unsigned_value;
  EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value);
  os.str("");
  os << std::hex << std::uppercase << unsigned_value;
  EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value);
}

template <typename T> void test_length(const char* length_spec) {
  T min = std::numeric_limits<T>::min(), max = max_value<T>();
  test_length<T>(length_spec, 42);
  test_length<T>(length_spec, -42);
  test_length<T>(length_spec, min);
  test_length<T>(length_spec, max);
  long long long_long_min = std::numeric_limits<long long>::min();
  if (static_cast<long long>(min) > long_long_min)
    test_length<T>(length_spec, static_cast<long long>(min) - 1);
  unsigned long long long_long_max = max_value<long long>();
  if (static_cast<unsigned long long>(max) < long_long_max)
    test_length<T>(length_spec, static_cast<long long>(max) + 1);
  test_length<T>(length_spec, std::numeric_limits<short>::min());
  test_length<T>(length_spec, max_value<unsigned short>());
  test_length<T>(length_spec, std::numeric_limits<int>::min());
  test_length<T>(length_spec, max_value<int>());
  test_length<T>(length_spec, std::numeric_limits<unsigned>::min());
  test_length<T>(length_spec, max_value<unsigned>());
  test_length<T>(length_spec, std::numeric_limits<long long>::min());
  test_length<T>(length_spec, max_value<long long>());
  test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min());
  test_length<T>(length_spec, max_value<unsigned long long>());
}

TEST(printf_test, length) {
  test_length<char>("hh");
  test_length<signed char>("hh");
  test_length<unsigned char>("hh");
  test_length<short>("h");
  test_length<unsigned short>("h");
  test_length<long>("l");
  test_length<unsigned long>("l");
  test_length<long long>("ll");
  test_length<unsigned long long>("ll");
  test_length<intmax_t>("j");
  test_length<size_t>("z");
  test_length<std::ptrdiff_t>("t");
  long double max = max_value<long double>();
  EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);
  EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max);
}

TEST(printf_test, bool) {
  EXPECT_PRINTF("1", "%d", true);
  EXPECT_PRINTF("true", "%s", true);
}

TEST(printf_test, int) {
  EXPECT_PRINTF("-42", "%d", -42);
  EXPECT_PRINTF("-42", "%i", -42);
  unsigned u = 0 - 42u;
  EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
  EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
  EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
  EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
}

TEST(printf_test, long_long) {
  // fmt::printf allows passing long long arguments to %d without length
  // specifiers.
  long long max = max_value<long long>();
  EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
}

TEST(printf_test, float) {
  EXPECT_PRINTF("392.650000", "%f", 392.65);
  EXPECT_PRINTF("392.65", "%.2f", 392.65);
  EXPECT_PRINTF("392.6", "%.1f", 392.65);
  EXPECT_PRINTF("393", "%.f", 392.65);
  EXPECT_PRINTF("392.650000", "%F", 392.65);
  char buffer[256];
  safe_sprintf(buffer, "%e", 392.65);
  EXPECT_PRINTF(buffer, "%e", 392.65);
  safe_sprintf(buffer, "%E", 392.65);
  EXPECT_PRINTF(buffer, "%E", 392.65);
  EXPECT_PRINTF("392.65", "%g", 392.65);
  EXPECT_PRINTF("392.65", "%G", 392.65);
  EXPECT_PRINTF("392", "%g", 392.0);
  EXPECT_PRINTF("392", "%G", 392.0);
  EXPECT_PRINTF("4.56e-07", "%g", 0.000000456);
  safe_sprintf(buffer, "%a", -392.65);
  EXPECT_EQ(buffer, format("{:a}", -392.65));
  safe_sprintf(buffer, "%A", -392.65);
  EXPECT_EQ(buffer, format("{:A}", -392.65));
}

TEST(printf_test, inf) {
  double inf = std::numeric_limits<double>::infinity();
  for (const char* type = "fega"; *type; ++type) {
    EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
    char upper = static_cast<char>(std::toupper(*type));
    EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
  }
}

TEST(printf_test, char) {
  EXPECT_PRINTF("x", "%c", 'x');
  int max = max_value<int>();
  EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
  // EXPECT_PRINTF("x", "%lc", L'x');
  EXPECT_PRINTF(L"x", L"%c", L'x');
  EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
}

TEST(printf_test, string) {
  EXPECT_PRINTF("abc", "%s", "abc");
  const char* null_str = nullptr;
  EXPECT_PRINTF("(null)", "%s", null_str);
  EXPECT_PRINTF("    (null)", "%10s", null_str);
  EXPECT_PRINTF(L"abc", L"%s", L"abc");
  const wchar_t* null_wstr = nullptr;
  EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
  EXPECT_PRINTF(L"    (null)", L"%10s", null_wstr);
}

TEST(printf_test, uchar_string) {
  unsigned char str[] = "test";
  unsigned char* pstr = str;
  EXPECT_EQ("test", fmt::sprintf("%s", pstr));
}

TEST(printf_test, pointer) {
  int n;
  void* p = &n;
  EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
  p = nullptr;
  EXPECT_PRINTF("(nil)", "%p", p);
  EXPECT_PRINTF("     (nil)", "%10p", p);
  const char* s = "test";
  EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
  const char* null_str = nullptr;
  EXPECT_PRINTF("(nil)", "%p", null_str);

  p = &n;
  EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
  p = nullptr;
  EXPECT_PRINTF(L"(nil)", L"%p", p);
  EXPECT_PRINTF(L"     (nil)", L"%10p", p);
  const wchar_t* w = L"test";
  EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
  const wchar_t* null_wstr = nullptr;
  EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
}

enum test_enum { answer = 42 };

TEST(printf_test, enum) {
  EXPECT_PRINTF("42", "%d", answer);
  volatile test_enum volatile_enum = answer;
  EXPECT_PRINTF("42", "%d", volatile_enum);
}

#if FMT_USE_FCNTL
TEST(printf_test, examples) {
  const char* weekday = "Thursday";
  const char* month = "August";
  int day = 21;
  EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day),
               "Thursday, 21 August");
}

TEST(printf_test, printf_error) {
  fmt::file read_end, write_end;
  fmt::file::pipe(read_end, write_end);
  int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
  EXPECT_LT(result, 0);
}
#endif

TEST(printf_test, wide_string) {
  EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
}

TEST(printf_test, printf_custom) {
  EXPECT_EQ("abc", test_sprintf("%s", test_string("abc")));
}

TEST(printf_test, vprintf) {
  fmt::format_arg_store<fmt::printf_context, int> as{42};
  fmt::basic_format_args<fmt::printf_context> args(as);
  EXPECT_EQ(fmt::vsprintf("%d", args), "42");
  EXPECT_WRITE(stdout, fmt::vprintf("%d", args), "42");
  EXPECT_WRITE(stdout, fmt::vfprintf(stdout, "%d", args), "42");
}

template <typename... Args>
void check_format_string_regression(fmt::string_view s, const Args&... args) {
  fmt::sprintf(s, args...);
}

TEST(printf_test, check_format_string_regression) {
  check_format_string_regression("%c%s", 'x', "");
}

TEST(printf_test, fixed_large_exponent) {
  EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21));
}

TEST(printf_test, vsprintf_make_args_example) {
  fmt::format_arg_store<fmt::printf_context, int, const char*> as{42,
                                                                  "something"};
  fmt::basic_format_args<fmt::printf_context> args(as);
  EXPECT_EQ("[42] something happened", fmt::vsprintf("[%d] %s happened", args));
  auto as2 = fmt::make_printf_args(42, "something");
  fmt::basic_format_args<fmt::printf_context> args2(as2);
  EXPECT_EQ("[42] something happened",
            fmt::vsprintf("[%d] %s happened", args2));
  EXPECT_EQ("[42] something happened",
            fmt::vsprintf("[%d] %s happened",
                          {fmt::make_printf_args(42, "something")}));
}

TEST(printf_test, vsprintf_make_wargs_example) {
  fmt::format_arg_store<fmt::wprintf_context, int, const wchar_t*> as{
      42, L"something"};
  fmt::basic_format_args<fmt::wprintf_context> args(as);
  EXPECT_EQ(L"[42] something happened",
            fmt::vsprintf(L"[%d] %s happened", args));
  auto as2 = fmt::make_wprintf_args(42, L"something");
  fmt::basic_format_args<fmt::wprintf_context> args2(as2);
  EXPECT_EQ(L"[42] something happened",
            fmt::vsprintf(L"[%d] %s happened", args2));
  EXPECT_EQ(L"[42] something happened",
            fmt::vsprintf(L"[%d] %s happened",
                          {fmt::make_wprintf_args(42, L"something")}));
}


================================================
FILE: examples/libraries/fmt/test/ranges-test.cc
================================================
// Formatting library for C++ - the core API
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
//
// Copyright (c) 2018 - present, Remotion (Igor Schulz)
// All Rights Reserved
// {fmt} support for ranges, containers and types tuple interface.

#include "fmt/ranges.h"

#include <map>
#include <string>
#include <vector>

#include "gtest/gtest.h"

#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 601
#  define FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
#endif

#if !FMT_MSC_VER || FMT_MSC_VER > 1910
#  define FMT_RANGES_TEST_ENABLE_JOIN
#  define FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
#endif

#ifdef FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
TEST(ranges_test, format_array) {
  int arr[] = {1, 2, 3, 5, 7, 11};
  EXPECT_EQ(fmt::format("{}", arr), "[1, 2, 3, 5, 7, 11]");
}

TEST(ranges_test, format_2d_array) {
  int arr[][2] = {{1, 2}, {3, 5}, {7, 11}};
  EXPECT_EQ(fmt::format("{}", arr), "[[1, 2], [3, 5], [7, 11]]");
}

TEST(ranges_test, format_array_of_literals) {
  const char* arr[] = {"1234", "abcd"};
  EXPECT_EQ(fmt::format("{}", arr), "[\"1234\", \"abcd\"]");
}
#endif  // FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY

TEST(ranges_test, format_vector) {
  auto v = std::vector<int>{1, 2, 3, 5, 7, 11};
  EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]");
}

TEST(ranges_test, format_vector2) {
  auto v = std::vector<std::vector<int>>{{1, 2}, {3, 5}, {7, 11}};
  EXPECT_EQ(fmt::format("{}", v), "[[1, 2], [3, 5], [7, 11]]");
}

TEST(ranges_test, format_map) {
  auto m = std::map<std::string, int>{{"one", 1}, {"two", 2}};
  EXPECT_EQ(fmt::format("{}", m), "[(\"one\", 1), (\"two\", 2)]");
}

TEST(ranges_test, format_pair) {
  auto p = std::pair<int, float>(42, 1.5f);
  EXPECT_EQ(fmt::format("{}", p), "(42, 1.5)");
}

TEST(ranges_test, format_tuple) {
  auto t =
      std::tuple<int, float, std::string, char>(42, 1.5f, "this is tuple", 'i');
  EXPECT_EQ(fmt::format("{}", t), "(42, 1.5, \"this is tuple\", 'i')");
  EXPECT_EQ(fmt::format("{}", std::tuple<>()), "()");
}

#ifdef FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
struct tuple_like {
  int i;
  std::string str;

  template <size_t N> fmt::enable_if_t<N == 0, int> get() const noexcept {
    return i;
  }
  template <size_t N>
  fmt::enable_if_t<N == 1, fmt::string_view> get() const noexcept {
    return str;
  }
};

template <size_t N>
auto get(const tuple_like& t) noexcept -> decltype(t.get<N>()) {
  return t.get<N>();
}

namespace std {
template <>
struct tuple_size<tuple_like> : std::integral_constant<size_t, 2> {};

template <size_t N> struct tuple_element<N, tuple_like> {
  using type = decltype(std::declval<tuple_like>().get<N>());
};
}  // namespace std

TEST(ranges_test, format_struct) {
  auto t = tuple_like{42, "foo"};
  EXPECT_EQ(fmt::format("{}", t), "(42, \"foo\")");
}
#endif  // FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT

TEST(ranges_test, format_to) {
  char buf[10];
  auto end = fmt::format_to(buf, "{}", std::vector<int>{1, 2, 3});
  *end = '\0';
  EXPECT_STREQ(buf, "[1, 2, 3]");
}

struct path_like {
  const path_like* begin() const;
  const path_like* end() const;

  operator std::string() const;
};

TEST(ranges_test, path_like) {
  EXPECT_FALSE((fmt::is_range<path_like, char>::value));
}

#ifdef FMT_USE_STRING_VIEW
struct string_like {
  const char* begin();
  const char* end();
  explicit operator fmt::string_view() const { return "foo"; }
  explicit operator std::string_view() const { return "foo"; }
};

TEST(ranges_test, format_string_like) {
  EXPECT_EQ(fmt::format("{}", string_like()), "foo");
}
#endif  // FMT_USE_STRING_VIEW

// A range that provides non-const only begin()/end() to test fmt::join handles
// that.
//
// Some ranges (e.g. those produced by range-v3's views::filter()) can cache
// information during iteration so they only provide non-const begin()/end().
template <typename T> class non_const_only_range {
 private:
  std::vector<T> vec;

 public:
  using const_iterator = typename ::std::vector<T>::const_iterator;

  template <typename... Args>
  explicit non_const_only_range(Args&&... args)
      : vec(std::forward<Args>(args)...) {}

  const_iterator begin() { return vec.begin(); }
  const_iterator end() { return vec.end(); }
};

template <typename T> class noncopyable_range {
 private:
  std::vector<T> vec;

 public:
  using const_iterator = typename ::std::vector<T>::const_iterator;

  template <typename... Args>
  explicit noncopyable_range(Args&&... args)
      : vec(std::forward<Args>(args)...) {}

  noncopyable_range(noncopyable_range const&) = delete;
  noncopyable_range(noncopyable_range&) = delete;

  const_iterator begin() const { return vec.begin(); }
  const_iterator end() const { return vec.end(); }
};

TEST(ranges_test, range) {
  noncopyable_range<int> w(3u, 0);
  EXPECT_EQ(fmt::format("{}", w), "[0, 0, 0]");
  EXPECT_EQ(fmt::format("{}", noncopyable_range<int>(3u, 0)), "[0, 0, 0]");

  non_const_only_range<int> x(3u, 0);
  EXPECT_EQ(fmt::format("{}", x), "[0, 0, 0]");
  EXPECT_EQ(fmt::format("{}", non_const_only_range<int>(3u, 0)), "[0, 0, 0]");

  auto y = std::vector<int>(3u, 0);
  EXPECT_EQ(fmt::format("{}", y), "[0, 0, 0]");
  EXPECT_EQ(fmt::format("{}", std::vector<int>(3u, 0)), "[0, 0, 0]");

  const auto z = std::vector<int>(3u, 0);
  EXPECT_EQ(fmt::format("{}", z), "[0, 0, 0]");
}

#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
struct unformattable {};

TEST(ranges_test, unformattable_range) {
  EXPECT_FALSE((fmt::has_formatter<std::vector<unformattable>,
                                   fmt::format_context>::value));
}
#endif

#ifdef FMT_RANGES_TEST_ENABLE_JOIN
TEST(ranges_test, join_tuple) {
  // Value tuple args.
  auto t1 = std::tuple<char, int, float>('a', 1, 2.0f);
  EXPECT_EQ(fmt::format("({})", fmt::join(t1, ", ")), "(a, 1, 2)");

  // Testing lvalue tuple args.
  int x = 4;
  auto t2 = std::tuple<char, int&>('b', x);
  EXPECT_EQ(fmt::format("{}", fmt::join(t2, " + ")), "b + 4");

  // Empty tuple.
  auto t3 = std::tuple<>();
  EXPECT_EQ(fmt::format("{}", fmt::join(t3, "|")), "");

  // Single element tuple.
  auto t4 = std::tuple<float>(4.0f);
  EXPECT_EQ(fmt::format("{}", fmt::join(t4, "/")), "4");
}

TEST(ranges_test, join_initializer_list) {
  EXPECT_EQ(fmt::format("{}", fmt::join({1, 2, 3}, ", ")), "1, 2, 3");
  EXPECT_EQ(fmt::format("{}", fmt::join({"fmt", "rocks", "!"}, " ")),
            "fmt rocks !");
}

struct zstring_sentinel {};

bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }

struct zstring {
  const char* p;
  const char* begin() const { return p; }
  zstring_sentinel end() const { return {}; }
};

TEST(ranges_test, join_sentinel) {
  auto hello = zstring{"hello"};
  EXPECT_EQ(fmt::format("{}", hello), "['h', 'e', 'l', 'l', 'o']");
  EXPECT_EQ(fmt::format("{}", fmt::join(hello, "_")), "h_e_l_l_o");
}

TEST(ranges_test, join_range) {
  noncopyable_range<int> w(3u, 0);
  EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0");
  EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range<int>(3u, 0), ",")),
            "0,0,0");

  non_const_only_range<int> x(3u, 0);
  EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0");
  EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range<int>(3u, 0), ",")),
            "0,0,0");

  auto y = std::vector<int>(3u, 0);
  EXPECT_EQ(fmt::format("{}", fmt::join(y, ",")), "0,0,0");
  EXPECT_EQ(fmt::format("{}", fmt::join(std::vector<int>(3u, 0), ",")),
            "0,0,0");

  const auto z = std::vector<int>(3u, 0);
  EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0");
}
#endif  // FMT_RANGES_TEST_ENABLE_JOIN


================================================
FILE: examples/libraries/fmt/test/scan-test.cc
================================================
// Formatting library for C++ - scanning API test
//
// Copyright (c) 2019 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "scan.h"

#include <time.h>

#include <climits>

#include "gmock/gmock.h"
#include "gtest-extra.h"

TEST(scan_test, read_text) {
  auto s = fmt::string_view("foo");
  auto end = fmt::scan(s, "foo");
  EXPECT_EQ(end, s.end());
  EXPECT_THROW_MSG(fmt::scan("fob", "foo"), fmt::format_error, "invalid input");
}

TEST(scan_test, read_int) {
  auto n = int();
  fmt::scan("42", "{}", n);
  EXPECT_EQ(n, 42);
  fmt::scan("-42", "{}", n);
  EXPECT_EQ(n, -42);
}

TEST(scan_test, read_longlong) {
  long long n = 0;
  fmt::scan("42", "{}", n);
  EXPECT_EQ(n, 42);
  fmt::scan("-42", "{}", n);
  EXPECT_EQ(n, -42);
}

TEST(scan_test, read_uint) {
  auto n = unsigned();
  fmt::scan("42", "{}", n);
  EXPECT_EQ(n, 42);
  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
                   "invalid input");
}

TEST(scan_test, read_ulonglong) {
  unsigned long long n = 0;
  fmt::scan("42", "{}", n);
  EXPECT_EQ(n, 42);
  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
                   "invalid input");
}

TEST(scan_test, read_string) {
  auto s = std::string();
  fmt::scan("foo", "{}", s);
  EXPECT_EQ(s, "foo");
}

TEST(scan_test, read_string_view) {
  auto s = fmt::string_view();
  fmt::scan("foo", "{}", s);
  EXPECT_EQ(s, "foo");
}

#ifndef _WIN32
namespace fmt {
template <> struct scanner<tm> {
  std::string format;

  scan_parse_context::iterator parse(scan_parse_context& ctx) {
    auto it = ctx.begin();
    if (it != ctx.end() && *it == ':') ++it;
    auto end = it;
    while (end != ctx.end() && *end != '}') ++end;
    format.reserve(detail::to_unsigned(end - it + 1));
    format.append(it, end);
    format.push_back('\0');
    return end;
  }

  template <class ScanContext>
  typename ScanContext::iterator scan(tm& t, ScanContext& ctx) {
    auto result = strptime(ctx.begin(), format.c_str(), &t);
    if (!result) throw format_error("failed to parse time");
    return result;
  }
};
}  // namespace fmt

TEST(scan_test, read_custom) {
  auto input = "Date: 1985-10-25";
  auto t = tm();
  fmt::scan(input, "Date: {0:%Y-%m-%d}", t);
  EXPECT_EQ(t.tm_year, 85);
  EXPECT_EQ(t.tm_mon, 9);
  EXPECT_EQ(t.tm_mday, 25);
}
#endif

TEST(scan_test, invalid_format) {
  EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
                   "argument index out of range");
  EXPECT_THROW_MSG(fmt::scan("", "{"), fmt::format_error,
                   "invalid format string");
}

TEST(scan_test, example) {
  auto key = std::string();
  auto value = int();
  fmt::scan("answer = 42", "{} = {}", key, value);
  EXPECT_EQ(key, "answer");
  EXPECT_EQ(value, 42);
}


================================================
FILE: examples/libraries/fmt/test/scan.h
================================================
// Formatting library for C++ - scanning API proof of concept
//
// Copyright (c) 2019 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <array>
#include <cassert>
#include <climits>

#include "fmt/format.h"

FMT_BEGIN_NAMESPACE
template <typename T, typename Char = char> struct scanner {
  // A deleted default constructor indicates a disabled scanner.
  scanner() = delete;
};

class scan_parse_context {
 private:
  string_view format_;

 public:
  using iterator = string_view::iterator;

  explicit FMT_CONSTEXPR scan_parse_context(string_view format)
      : format_(format) {}

  FMT_CONSTEXPR iterator begin() const { return format_.begin(); }
  FMT_CONSTEXPR iterator end() const { return format_.end(); }

  void advance_to(iterator it) {
    format_.remove_prefix(detail::to_unsigned(it - begin()));
  }
};

struct scan_context {
 private:
  string_view input_;

 public:
  using iterator = const char*;

  explicit scan_context(string_view input) : input_(input) {}

  iterator begin() const { return input_.data(); }
  iterator end() const { return begin() + input_.size(); }

  void advance_to(iterator it) {
    input_.remove_prefix(detail::to_unsigned(it - begin()));
  }
};

namespace detail {
enum class scan_type {
  none_type,
  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  string_type,
  string_view_type,
  custom_type
};

struct custom_scan_arg {
  void* value;
  void (*scan)(void* arg, scan_parse_context& parse_ctx, scan_context& ctx);
};

class scan_arg {
 public:
  scan_type type;
  union {
    int* int_value;
    unsigned* uint_value;
    long long* long_long_value;
    unsigned long long* ulong_long_value;
    std::string* string;
    fmt::string_view* string_view;
    custom_scan_arg custom;
    // TODO: more types
  };

  scan_arg() : type(scan_type::none_type) {}
  scan_arg(int& value) : type(scan_type::int_type), int_value(&value) {}
  scan_arg(unsigned& value) : type(scan_type::uint_type), uint_value(&value) {}
  scan_arg(long long& value)
      : type(scan_type::long_long_type), long_long_value(&value) {}
  scan_arg(unsigned long long& value)
      : type(scan_type::ulong_long_type), ulong_long_value(&value) {}
  scan_arg(std::string& value) : type(scan_type::string_type), string(&value) {}
  scan_arg(fmt::string_view& value)
      : type(scan_type::string_view_type), string_view(&value) {}
  template <typename T> scan_arg(T& value) : type(scan_type::custom_type) {
    custom.value = &value;
    custom.scan = scan_custom_arg<T>;
  }

 private:
  template <typename T>
  static void scan_custom_arg(void* arg, scan_parse_context& parse_ctx,
                              scan_context& ctx) {
    scanner<T> s;
    parse_ctx.advance_to(s.parse(parse_ctx));
    ctx.advance_to(s.scan(*static_cast<T*>(arg), ctx));
  }
};
}  // namespace detail

struct scan_args {
  int size;
  const detail::scan_arg* data;

  template <size_t N>
  scan_args(const std::array<detail::scan_arg, N>& store)
      : size(N), data(store.data()) {
    static_assert(N < INT_MAX, "too many arguments");
  }
};

namespace detail {

struct scan_handler : error_handler {
 private:
  scan_parse_context parse_ctx_;
  scan_context scan_ctx_;
  scan_args args_;
  int next_arg_id_;
  scan_arg arg_;

  template <typename T = unsigned> T read_uint() {
    T value = 0;
    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
    while (it != end) {
      char c = *it++;
      if (c < '0' || c > '9') on_error("invalid input");
      // TODO: check overflow
      value = value * 10 + static_cast<unsigned>(c - '0');
    }
    scan_ctx_.advance_to(it);
    return value;
  }

  template <typename T = int> T read_int() {
    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
    bool negative = it != end && *it == '-';
    if (negative) ++it;
    scan_ctx_.advance_to(it);
    const auto value = read_uint<typename std::make_unsigned<T>::type>();
    if (negative) return -static_cast<T>(value);
    return static_cast<T>(value);
  }

 public:
  scan_handler(string_view format, string_view input, scan_args args)
      : parse_ctx_(format), scan_ctx_(input), args_(args), next_arg_id_(0) {}

  const char* pos() const { return scan_ctx_.begin(); }

  void on_text(const char* begin, const char* end) {
    auto size = to_unsigned(end - begin);
    auto it = scan_ctx_.begin();
    if (it + size > scan_ctx_.end() ||
        !std::equal(begin, end, make_checked(it, size))) {
      on_error("invalid input");
    }
    scan_ctx_.advance_to(it + size);
  }

  FMT_CONSTEXPR int on_arg_id() { return on_arg_id(next_arg_id_++); }
  FMT_CONSTEXPR int on_arg_id(int id) {
    if (id >= args_.size) on_error("argument index out of range");
    arg_ = args_.data[id];
    return id;
  }
  FMT_CONSTEXPR int on_arg_id(string_view id) {
    if (id.data()) on_error("invalid format");
    return 0;
  }

  void on_replacement_field(int, const char*) {
    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
    switch (arg_.type) {
    case scan_type::int_type:
      *arg_.int_value = read_int();
      break;
    case scan_type::uint_type:
      *arg_.uint_value = read_uint();
      break;
    case scan_type::long_long_type:
      *arg_.long_long_value = read_int<long long>();
      break;
    case scan_type::ulong_long_type:
      *arg_.ulong_long_value = read_uint<unsigned long long>();
      break;
    case scan_type::string_type:
      while (it != end && *it != ' ') arg_.string->push_back(*it++);
      scan_ctx_.advance_to(it);
      break;
    case scan_type::string_view_type: {
      auto s = it;
      while (it != end && *it != ' ') ++it;
      *arg_.string_view = fmt::string_view(s, to_unsigned(it - s));
      scan_ctx_.advance_to(it);
      break;
    }
    case scan_type::none_type:
    case scan_type::custom_type:
      assert(false);
    }
  }

  const char* on_format_specs(int, const char* begin, const char*) {
    if (arg_.type != scan_type::custom_type) return begin;
    parse_ctx_.advance_to(begin);
    arg_.custom.scan(arg_.custom.value, parse_ctx_, scan_ctx_);
    return parse_ctx_.begin();
  }
};
}  // namespace detail

template <typename... Args>
std::array<detail::scan_arg, sizeof...(Args)> make_scan_args(Args&... args) {
  return {{args...}};
}

string_view::iterator vscan(string_view input, string_view format_str,
                            scan_args args) {
  detail::scan_handler h(format_str, input, args);
  detail::parse_format_string<false>(format_str, h);
  return input.begin() + (h.pos() - &*input.begin());
}

template <typename... Args>
string_view::iterator scan(string_view input, string_view format_str,
                           Args&... args) {
  return vscan(input, format_str, make_scan_args(args...));
}
FMT_END_NAMESPACE


================================================
FILE: examples/libraries/fmt/test/static-export-test/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.1...3.18)

project(fmt-link CXX)

set(BUILD_SHARED_LIBS OFF)
set(CMAKE_VISIBILITY_INLINES_HIDDEN TRUE)
set(CMAKE_CXX_VISIBILITY_PRESET "hidden")

# Broken LTO on GCC 4
if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
  set(BROKEN_LTO ON)
endif ()

if (NOT BROKEN_LTO AND CMAKE_VERSION VERSION_GREATER "3.8")
  # CMake 3.9+
  include(CheckIPOSupported)
  check_ipo_supported(RESULT HAVE_IPO)
  if (HAVE_IPO)
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
  endif ()
endif ()

add_subdirectory(../.. fmt)
set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)

add_library(library-test SHARED library.cc)
target_link_libraries(library-test PRIVATE fmt::fmt)

add_executable(exe-test main.cc)
target_link_libraries(exe-test PRIVATE library-test)


================================================
FILE: examples/libraries/fmt/test/static-export-test/library.cc
================================================
#include <fmt/compile.h>

__attribute__((visibility("default"))) std::string foo() {
  return fmt::format(FMT_COMPILE("foo bar {}"), 4242);
}


================================================
FILE: examples/libraries/fmt/test/static-export-test/main.cc
================================================
#include <iostream>
#include <string>

extern std::string foo();

int main() { std::cout << foo() << std::endl; }


================================================
FILE: examples/libraries/fmt/test/std-format-test.cc
================================================
#include <format>

#include "gtest/gtest.h"

TEST(std_format_test, escaping) {
  using namespace std;
  string s = format("{0}-{{", 8);  // s == "8-{"
  EXPECT_EQ(s, "8-{");
}

TEST(std_format_test, indexing) {
  using namespace std;
  string s0 = format("{} to {}", "a", "b");    // OK: automatic indexing
  string s1 = format("{1} to {0}", "a", "b");  // OK: manual indexing
  EXPECT_EQ(s0, "a to b");
  EXPECT_EQ(s1, "b to a");
  // Error: mixing automatic and manual indexing
  EXPECT_THROW(string s2 = format("{0} to {}", "a", "b"), std::format_error);
  // Error: mixing automatic and manual indexing
  EXPECT_THROW(string s3 = format("{} to {1}", "a", "b"), std::format_error);
}

TEST(std_format_test, alignment) {
  using namespace std;
  char c = 120;
  string s0 = format("{:6}", 42);     // s0 == "    42"
  string s1 = format("{:6}", 'x');    // s1 == "x     "
  string s2 = format("{:*<6}", 'x');  // s2 == "x*****"
  string s3 = format("{:*>6}", 'x');  // s3 == "*****x"
  string s4 = format("{:*^6}", 'x');  // s4 == "**x***"
  // Error: '=' with charT and no integer presentation type
  EXPECT_THROW(string s5 = format("{:=6}", 'x'), std::format_error);
  string s6 = format("{:6d}", c);    // s6 == "   120"
  string s7 = format("{:6}", true);  // s9 == "true  "
  EXPECT_EQ(s0, "    42");
  EXPECT_EQ(s1, "x     ");
  EXPECT_EQ(s2, "x*****");
  EXPECT_EQ(s3, "*****x");
  EXPECT_EQ(s4, "**x***");
  EXPECT_EQ(s6, "   120");
  EXPECT_EQ(s7, "true  ");
}

TEST(std_format_test, float) {
  using namespace std;
  double inf = numeric_limits<double>::infinity();
  double nan = numeric_limits<double>::quiet_NaN();
  string s0 = format("{0:} {0:+} {0:-} {0: }", 1);   // s0 == "1 +1 1  1"
  string s1 = format("{0:} {0:+} {0:-} {0: }", -1);  // s1 == "-1 -1 -1 -1"
  string s2 =
      format("{0:} {0:+} {0:-} {0: }", inf);  // s2 == "inf +inf inf  inf"
  string s3 =
      format("{0:} {0:+} {0:-} {0: }", nan);  // s3 == "nan +nan nan  nan"
  EXPECT_EQ(s0, "1 +1 1  1");
  EXPECT_EQ(s1, "-1 -1 -1 -1");
  EXPECT_EQ(s2, "inf +inf inf  inf");
  EXPECT_EQ(s3, "nan +nan nan  nan");
}

TEST(std_format_test, int) {
  using namespace std;
  string s0 = format("{}", 42);                       // s0 == "42"
  string s1 = format("{0:b} {0:d} {0:o} {0:x}", 42);  // s1 == "101010 42 52 2a"
  string s2 = format("{0:#x} {0:#X}", 42);            // s2 == "0x2a 0X2A"
  string s3 = format("{:L}", 1234);  // s3 == "1234" (depends on the locale)
  EXPECT_EQ(s0, "42");
  EXPECT_EQ(s1, "101010 42 52 2a");
  EXPECT_EQ(s2, "0x2a 0X2A");
  EXPECT_EQ(s3, "1234");
}

#include <format>

enum color { red, green, blue };

const char* color_names[] = {"red", "green", "blue"};

template <> struct std::formatter<color> : std::formatter<const char*> {
  auto format(color c, format_context& ctx) {
    return formatter<const char*>::format(color_names[c], ctx);
  }
};

struct err {};

TEST(std_format_test, formatter) {
  std::string s0 = std::format("{}", 42);  // OK: library-provided formatter
  // std::string s1 = std::format("{}", L"foo"); // Ill-formed: disabled
  // formatter
  std::string s2 = std::format("{}", red);  // OK: user-provided formatter
  // std::string s3 = std::format("{}", err{});  // Ill-formed: disabled
  // formatter
  EXPECT_EQ(s0, "42");
  EXPECT_EQ(s2, "red");
}

struct S {
  int value;
};

template <> struct std::formatter<S> {
  size_t width_arg_id = 0;

  // Parses a width argument id in the format { <digit> }.
  constexpr auto parse(format_parse_context& ctx) {
    constexpr auto is_ascii_digit = [](const char c) {
      return c >= '0' && c <= '9';
    };

    auto iter = ctx.begin();
    // auto get_char = [&]() { return iter != ctx.end() ? *iter : 0; };
    auto get_char = [&]() { return iter != ctx.end() ? *iter : '\0'; };
    if (get_char() != '{') return iter;
    ++iter;
    char c = get_char();
    if (!is_ascii_digit(c) || (++iter, get_char()) != '}')
      throw format_error("invalid format");
    width_arg_id = fmt::detail::to_unsigned(c - '0');
    ctx.check_arg_id(width_arg_id);
    return ++iter;
  }

  // Formats S with width given by the argument width_arg_id.
  auto format(S s, format_context& ctx) {
    int width = visit_format_arg(
        [](auto value) -> int {
          using type = decltype(value);
          if constexpr (!is_integral_v<type> || is_same_v<type, bool>)
            throw format_error("width is not integral");
          // else if (value < 0 || value > numeric_limits<int>::max())
          else if (fmt::detail::is_negative(value) ||
                   value > numeric_limits<int>::max())
            throw format_error("invalid width");
          else
            return static_cast<int>(value);
        },
        ctx.arg(width_arg_id));
    return format_to(ctx.out(), "{0:{1}}", s.value, width);
  }
};

TEST(std_format_test, parsing) {
  std::string s = std::format("{0:{1}}", S{42}, 10);  // s == "        42"
  EXPECT_EQ(s, "        42");
}

#if FMT_USE_INT128
template <> struct std::formatter<__int128_t> : std::formatter<long long> {
  auto format(__int128_t n, format_context& ctx) {
    // Format as a long long since we only want to check if it is possible to
    // specialize formatter for __int128_t.
    return formatter<long long>::format(static_cast<long long>(n), ctx);
  }
};

TEST(std_format_test, int128) {
  __int128_t n = 42;
  auto s = std::format("{}", n);
  EXPECT_EQ(s, "42");
}
#endif  // FMT_USE_INT128


================================================
FILE: examples/libraries/fmt/test/test-assert.h
================================================
// Formatting library for C++ - test version of FMT_ASSERT
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_TEST_ASSERT_H_
#define FMT_TEST_ASSERT_H_

#include <stdexcept>

void throw_assertion_failure(const char* message);
#define FMT_ASSERT(condition, message) \
  if (!(condition)) throw_assertion_failure(message);

#include "gtest/gtest.h"

class assertion_failure : public std::logic_error {
 public:
  explicit assertion_failure(const char* message) : std::logic_error(message) {}

 private:
  virtual void avoid_weak_vtable();
};

void assertion_failure::avoid_weak_vtable() {}

// We use a separate function (rather than throw directly from FMT_ASSERT) to
// avoid GCC's -Wterminate warning when FMT_ASSERT is used in a destructor.
inline void throw_assertion_failure(const char* message) {
  throw assertion_failure(message);
}

// Expects an assertion failure.
#define EXPECT_ASSERT(stmt, message) \
  FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_)

#endif  // FMT_TEST_ASSERT_H_


================================================
FILE: examples/libraries/fmt/test/test-main.cc
================================================
// Formatting library for C++ - test main function.
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <cstdlib>

#include "gtest/gtest.h"

#ifdef _WIN32
#  include <windows.h>
#endif

#ifdef _MSC_VER
#  include <crtdbg.h>
#else
#  define _CrtSetReportFile(a, b)
#  define _CrtSetReportMode(a, b)
#endif

int main(int argc, char** argv) {
#ifdef _WIN32
  // Don't display any error dialogs. This also suppresses message boxes
  // on assertion failures in MinGW where _set_error_mode/CrtSetReportMode
  // doesn't help.
  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
               SEM_NOOPENFILEERRORBOX);
#endif
  // Disable message boxes on assertion failures.
  _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
  _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
  _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
  _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
  try {
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
  } catch (...) {
    // Catch all exceptions to make Coverity happy.
  }
  return EXIT_FAILURE;
}


================================================
FILE: examples/libraries/fmt/test/unicode-test.cc
================================================
// Formatting library for C++ - Unicode tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <iomanip>
#include <locale>
#include <vector>

#include "fmt/chrono.h"
#include "gmock/gmock.h"
#include "util.h"  // get_locale

using testing::Contains;

TEST(unicode_test, is_utf8) { EXPECT_TRUE(fmt::detail::is_utf8()); }

TEST(unicode_test, legacy_locale) {
  auto loc = get_locale("ru_RU.CP1251", "Russian.1251");
  if (loc == std::locale::classic()) return;

  auto s = std::string();
  try {
    s = fmt::format(loc, "День недели: {:L}", fmt::weekday(1));
  } catch (const fmt::format_error& e) {
    // Formatting can fail due to an unsupported encoding.
    fmt::print("Format error: {}\n", e.what());
    return;
  }

#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 500
  auto&& os = std::ostringstream();
  os.imbue(loc);
  auto tm = std::tm();
  tm.tm_wday = 1;
  os << std::put_time(&tm, "%a");
  auto wd = os.str();
  if (wd == "??") {
    EXPECT_EQ(s, "День недели: ??");
    fmt::print("std::locale gives ?? as a weekday.\n");
    return;
  }
#endif
  EXPECT_THAT((std::vector<std::string>{"День недели: пн", "День недели: Пн"}),
              Contains(s));
}


================================================
FILE: examples/libraries/fmt/test/util.cc
================================================
// Formatting library for C++ - test utilities
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "util.h"

#include <cstring>

const char* const file_content = "Don't panic!";

fmt::buffered_file open_buffered_file(FILE** fp) {
#if FMT_USE_FCNTL
  fmt::file read_end, write_end;
  fmt::file::pipe(read_end, write_end);
  write_end.write(file_content, std::strlen(file_content));
  write_end.close();
  fmt::buffered_file f = read_end.fdopen("r");
  if (fp) *fp = f.get();
#else
  fmt::buffered_file f("test-file", "w");
  fputs(file_content, f.get());
  if (fp) *fp = f.get();
#endif
  return f;
}

std::locale do_get_locale(const char* name) {
  try {
    return std::locale(name);
  } catch (const std::runtime_error&) {
  }
  return std::locale::classic();
}

std::locale get_locale(const char* name, const char* alt_name) {
  auto loc = do_get_locale(name);
  if (loc == std::locale::classic() && alt_name) {
    loc = do_get_locale(alt_name);
  }
  if (loc == std::locale::classic())
    fmt::print(stderr, "{} locale is missing.\n", name);
  return loc;
}


================================================
FILE: examples/libraries/fmt/test/util.h
================================================
// Formatting library for C++ - test utilities
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include <cstdarg>
#include <cstdio>
#include <locale>
#include <string>

#include "fmt/os.h"

#ifdef _MSC_VER
#  define FMT_VSNPRINTF vsprintf_s
#else
#  define FMT_VSNPRINTF vsnprintf
#endif

template <size_t SIZE>
void safe_sprintf(char (&buffer)[SIZE], const char* format, ...) {
  std::va_list args;
  va_start(args, format);
  FMT_VSNPRINTF(buffer, SIZE, format, args);
  va_end(args);
}

extern const char* const file_content;

// Opens a buffered file for reading.
fmt::buffered_file open_buffered_file(FILE** fp = nullptr);

inline FILE* safe_fopen(const char* filename, const char* mode) {
#if defined(_WIN32) && !defined(__MINGW32__)
  // Fix MSVC warning about "unsafe" fopen.
  FILE* f = 0;
  errno = fopen_s(&f, filename, mode);
  return f;
#else
  return std::fopen(filename, mode);
#endif
}

template <typename Char> class basic_test_string {
 private:
  std::basic_string<Char> value_;

  static const Char empty[];

 public:
  explicit basic_test_string(const Char* value = empty) : value_(value) {}

  const std::basic_string<Char>& value() const { return value_; }
};

template <typename Char> const Char basic_test_string<Char>::empty[] = {0};

typedef basic_test_string<char> test_string;
typedef basic_test_string<wchar_t> test_wstring;

template <typename Char>
std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& os,
                                     const basic_test_string<Char>& s) {
  os << s.value();
  return os;
}

class date {
  int year_, month_, day_;

 public:
  date(int year, int month, int day) : year_(year), month_(month), day_(day) {}

  int year() const { return year_; }
  int month() const { return month_; }
  int day() const { return day_; }
};

// Returns a locale with the given name if available or classic locale othewise.
std::locale get_locale(const char* name, const char* alt_name = nullptr);


================================================
FILE: examples/libraries/fmt/test/xchar-test.cc
================================================
// Formatting library for C++ - formatting library tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#include "fmt/xchar.h"

#include <complex>

#include "fmt/chrono.h"
#include "fmt/color.h"
#include "fmt/ostream.h"
#include "fmt/ranges.h"
#include "gtest/gtest.h"

using fmt::detail::max_value;

namespace test_ns {
template <typename Char> class test_string {
 private:
  std::basic_string<Char> s_;

 public:
  test_string(const Char* s) : s_(s) {}
  const Char* data() const { return s_.data(); }
  size_t length() const { return s_.size(); }
  operator const Char*() const { return s_.c_str(); }
};

template <typename Char>
fmt::basic_string_view<Char> to_string_view(const test_string<Char>& s) {
  return {s.data(), s.length()};
}

struct non_string {};
}  // namespace test_ns

template <typename T> class is_string_test : public testing::Test {};

using string_char_types = testing::Types<char, wchar_t, char16_t, char32_t>;
TYPED_TEST_SUITE(is_string_test, string_char_types);

template <typename Char>
struct derived_from_string_view : fmt::basic_string_view<Char> {};

TYPED_TEST(is_string_test, is_string) {
  EXPECT_TRUE(fmt::detail::is_string<TypeParam*>::value);
  EXPECT_TRUE(fmt::detail::is_string<const TypeParam*>::value);
  EXPECT_TRUE(fmt::detail::is_string<TypeParam[2]>::value);
  EXPECT_TRUE(fmt::detail::is_string<const TypeParam[2]>::value);
  EXPECT_TRUE(fmt::detail::is_string<std::basic_string<TypeParam>>::value);
  EXPECT_TRUE(fmt::detail::is_string<fmt::basic_string_view<TypeParam>>::value);
  EXPECT_TRUE(
      fmt::detail::is_string<derived_from_string_view<TypeParam>>::value);
  using fmt_string_view = fmt::detail::std_string_view<TypeParam>;
  EXPECT_TRUE(std::is_empty<fmt_string_view>::value !=
              fmt::detail::is_string<fmt_string_view>::value);
  EXPECT_TRUE(fmt::detail::is_string<test_ns::test_string<TypeParam>>::value);
  EXPECT_FALSE(fmt::detail::is_string<test_ns::non_string>::value);
}

// std::is_constructible is broken in MSVC until version 2015.
#if !FMT_MSC_VER || FMT_MSC_VER >= 1900
struct explicitly_convertible_to_wstring_view {
  explicit operator fmt::wstring_view() const { return L"foo"; }
};

TEST(xchar_test, format_explicitly_convertible_to_wstring_view) {
  EXPECT_EQ(L"foo",
            fmt::format(L"{}", explicitly_convertible_to_wstring_view()));
}
#endif

TEST(xchar_test, format) {
  EXPECT_EQ(L"42", fmt::format(L"{}", 42));
  EXPECT_EQ(L"4.2", fmt::format(L"{}", 4.2));
  EXPECT_EQ(L"abc", fmt::format(L"{}", L"abc"));
  EXPECT_EQ(L"z", fmt::format(L"{}", L'z'));
  EXPECT_THROW(fmt::format(L"{:*\x343E}", 42), fmt::format_error);
  EXPECT_EQ(L"true", fmt::format(L"{}", true));
  EXPECT_EQ(L"a", fmt::format(L"{0}", 'a'));
  EXPECT_EQ(L"a", fmt::format(L"{0}", L'a'));
  EXPECT_EQ(L"Cyrillic letter \x42e",
            fmt::format(L"Cyrillic letter {}", L'\x42e'));
  EXPECT_EQ(L"abc1", fmt::format(L"{}c{}", L"ab", 1));
}

TEST(xchar_test, compile_time_string) {
#if defined(FMT_USE_STRING_VIEW) && __cplusplus >= 201703L
  EXPECT_EQ(L"42", fmt::format(FMT_STRING(std::wstring_view(L"{}")), 42));
#endif
}

#if __cplusplus > 201103L
struct custom_char {
  int value;
  custom_char() = default;

  template <typename T>
  constexpr custom_char(T val) : value(static_cast<int>(val)) {}

  operator int() const { return value; }
};

int to_ascii(custom_char c) { return c; }

FMT_BEGIN_NAMESPACE
template <> struct is_char<custom_char> : std::true_type {};
FMT_END_NAMESPACE

TEST(xchar_test, format_custom_char) {
  const custom_char format[] = {'{', '}', 0};
  auto result = fmt::format(format, custom_char('x'));
  EXPECT_EQ(result.size(), 1);
  EXPECT_EQ(result[0], custom_char('x'));
}
#endif

// Convert a char8_t string to std::string. Otherwise GTest will insist on
// inserting `char8_t` NTBS into a `char` stream which is disabled by P1423.
template <typename S> std::string from_u8str(const S& str) {
  return std::string(str.begin(), str.end());
}

TEST(xchar_test, format_utf8_precision) {
  using str_type = std::basic_string<fmt::detail::char8_type>;
  auto format =
      str_type(reinterpret_cast<const fmt::detail::char8_type*>(u8"{:.4}"));
  auto str = str_type(reinterpret_cast<const fmt::detail::char8_type*>(
      u8"caf\u00e9s"));  // cafés
  auto result = fmt::format(format, str);
  EXPECT_EQ(fmt::detail::compute_width(result), 4);
  EXPECT_EQ(result.size(), 5);
  EXPECT_EQ(from_u8str(result), from_u8str(str.substr(0, 5)));
}

TEST(xchar_test, format_to) {
  auto buf = std::vector<wchar_t>();
  fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0');
  EXPECT_STREQ(buf.data(), L"42");
}

TEST(xchar_test, vformat_to) {
  using wcontext = fmt::wformat_context;
  fmt::basic_format_arg<wcontext> warg = fmt::detail::make_arg<wcontext>(42);
  auto wargs = fmt::basic_format_args<wcontext>(&warg, 1);
  auto w = std::wstring();
  fmt::vformat_to(std::back_inserter(w), L"{}", wargs);
  EXPECT_EQ(L"42", w);
  w.clear();
  fmt::vformat_to(std::back_inserter(w), FMT_STRING(L"{}"), wargs);
  EXPECT_EQ(L"42", w);
}

TEST(format_test, wide_format_to_n) {
  wchar_t buffer[4];
  buffer[3] = L'x';
  auto result = fmt::format_to_n(buffer, 3, L"{}", 12345);
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4));
  buffer[0] = L'x';
  buffer[1] = L'x';
  buffer[2] = L'x';
  result = fmt::format_to_n(buffer, 3, L"{}", L'A');
  EXPECT_EQ(1u, result.size);
  EXPECT_EQ(buffer + 1, result.out);
  EXPECT_EQ(L"Axxx", fmt::wstring_view(buffer, 4));
  result = fmt::format_to_n(buffer, 3, L"{}{} ", L'B', L'C');
  EXPECT_EQ(3u, result.size);
  EXPECT_EQ(buffer + 3, result.out);
  EXPECT_EQ(L"BC x", fmt::wstring_view(buffer, 4));
}

#if FMT_USE_USER_DEFINED_LITERALS
TEST(xchar_test, format_udl) {
  using namespace fmt::literals;
  EXPECT_EQ(L"{}c{}"_format(L"ab", 1), fmt::format(L"{}c{}", L"ab", 1));
}

TEST(xchar_test, named_arg_udl) {
  using namespace fmt::literals;
  auto udl_a =
      fmt::format(L"{first}{second}{first}{third}", L"first"_a = L"abra",
                  L"second"_a = L"cad", L"third"_a = 99);
  EXPECT_EQ(
      fmt::format(L"{first}{second}{first}{third}", fmt::arg(L"first", L"abra"),
                  fmt::arg(L"second", L"cad"), fmt::arg(L"third", 99)),
      udl_a);
}
#endif  // FMT_USE_USER_DEFINED_LITERALS

TEST(xchar_test, print) {
  // Check that the wide print overload compiles.
  if (fmt::detail::const_check(false)) fmt::print(L"test");
}

TEST(xchar_test, join) {
  int v[3] = {1, 2, 3};
  EXPECT_EQ(fmt::format(L"({})", fmt::join(v, v + 3, L", ")), L"(1, 2, 3)");
  auto t = std::tuple<wchar_t, int, float>('a', 1, 2.0f);
  EXPECT_EQ(fmt::format(L"({})", fmt::join(t, L", ")), L"(a, 1, 2)");
}

enum streamable_enum {};

std::wostream& operator<<(std::wostream& os, streamable_enum) {
  return os << L"streamable_enum";
}

enum unstreamable_enum {};

TEST(xchar_test, enum) {
  EXPECT_EQ(L"streamable_enum", fmt::format(L"{}", streamable_enum()));
  EXPECT_EQ(L"0", fmt::format(L"{}", unstreamable_enum()));
}

TEST(xchar_test, sign_not_truncated) {
  wchar_t format_str[] = {
      L'{', L':',
      '+' | static_cast<wchar_t>(1 << fmt::detail::num_bits<char>()), L'}', 0};
  EXPECT_THROW(fmt::format(format_str, 42), fmt::format_error);
}

namespace fake_qt {
class QString {
 public:
  QString(const wchar_t* s) : s_(s) {}
  const wchar_t* utf16() const FMT_NOEXCEPT { return s_.data(); }
  int size() const FMT_NOEXCEPT { return static_cast<int>(s_.size()); }

 private:
  std::wstring s_;
};

fmt::basic_string_view<wchar_t> to_string_view(const QString& s) FMT_NOEXCEPT {
  return {s.utf16(), static_cast<size_t>(s.size())};
}
}  // namespace fake_qt

TEST(format_test, format_foreign_strings) {
  using fake_qt::QString;
  EXPECT_EQ(fmt::format(QString(L"{}"), 42), L"42");
  EXPECT_EQ(fmt::format(QString(L"{}"), QString(L"42")), L"42");
}

TEST(xchar_test, chrono) {
  auto tm = std::tm();
  tm.tm_year = 116;
  tm.tm_mon = 3;
  tm.tm_mday = 25;
  tm.tm_hour = 11;
  tm.tm_min = 22;
  tm.tm_sec = 33;
  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
            "The date is 2016-04-25 11:22:33.");
  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42)));
}

TEST(xchar_test, color) {
  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), L"rgb(255,20,30) wide"),
            L"\x1b[38;2;255;020;030mrgb(255,20,30) wide\x1b[0m");
}

TEST(xchar_test, ostream) {
  std::wostringstream wos;
  fmt::print(wos, L"Don't {}!", L"panic");
  EXPECT_EQ(L"Don't panic!", wos.str());
}

TEST(xchar_test, to_wstring) { EXPECT_EQ(L"42", fmt::to_wstring(42)); }

#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template <typename Char> struct numpunct : std::numpunct<Char> {
 protected:
  Char do_decimal_point() const override { return '?'; }
  std::string do_grouping() const override { return "\03"; }
  Char do_thousands_sep() const override { return '~'; }
};

template <typename Char> struct no_grouping : std::numpunct<Char> {
 protected:
  Char do_decimal_point() const override { return '.'; }
  std::string do_grouping() const override { return ""; }
  Char do_thousands_sep() const override { return ','; }
};

template <typename Char> struct special_grouping : std::numpunct<Char> {
 protected:
  Char do_decimal_point() const override { return '.'; }
  std::string do_grouping() const override { return "\03\02"; }
  Char do_thousands_sep() const override { return ','; }
};

template <typename Char> struct small_grouping : std::numpunct<Char> {
 protected:
  Char do_decimal_point() const override { return '.'; }
  std::string do_grouping() const override { return "\01"; }
  Char do_thousands_sep() const override { return ','; }
};

TEST(locale_test, double_decimal_point) {
  auto loc = std::locale(std::locale(), new numpunct<char>());
  EXPECT_EQ("1?23", fmt::format(loc, "{:L}", 1.23));
  EXPECT_EQ("1?230000", fmt::format(loc, "{:Lf}", 1.23));
}

TEST(locale_test, format) {
  auto loc = std::locale(std::locale(), new numpunct<char>());
  EXPECT_EQ("1234567", fmt::format(std::locale(), "{:L}", 1234567));
  EXPECT_EQ("1~234~567", fmt::format(loc, "{:L}", 1234567));
  EXPECT_EQ("-1~234~567", fmt::format(loc, "{:L}", -1234567));
  EXPECT_EQ("-256", fmt::format(loc, "{:L}", -256));
  fmt::format_arg_store<fmt::format_context, int> as{1234567};
  EXPECT_EQ("1~234~567", fmt::vformat(loc, "{:L}", fmt::format_args(as)));
  auto s = std::string();
  fmt::format_to(std::back_inserter(s), loc, "{:L}", 1234567);
  EXPECT_EQ("1~234~567", s);

  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<char>());
  EXPECT_EQ("1234567", fmt::format(no_grouping_loc, "{:L}", 1234567));

  auto special_grouping_loc =
      std::locale(std::locale(), new special_grouping<char>());
  EXPECT_EQ("1,23,45,678", fmt::format(special_grouping_loc, "{:L}", 12345678));
  EXPECT_EQ("12,345", fmt::format(special_grouping_loc, "{:L}", 12345));

  auto small_grouping_loc =
      std::locale(std::locale(), new small_grouping<char>());
  EXPECT_EQ("4,2,9,4,9,6,7,2,9,5",
            fmt::format(small_grouping_loc, "{:L}", max_value<uint32_t>()));
}

TEST(locale_test, format_detault_align) {
  auto loc = std::locale({}, new special_grouping<char>());
  EXPECT_EQ("  12,345", fmt::format(loc, "{:8L}", 12345));
}

TEST(locale_test, format_plus) {
  auto loc = std::locale({}, new special_grouping<char>());
  EXPECT_EQ("+100", fmt::format(loc, "{:+L}", 100));
}

TEST(locale_test, wformat) {
  auto loc = std::locale(std::locale(), new numpunct<wchar_t>());
  EXPECT_EQ(L"1234567", fmt::format(std::locale(), L"{:L}", 1234567));
  EXPECT_EQ(L"1~234~567", fmt::format(loc, L"{:L}", 1234567));
  using wcontext = fmt::buffer_context<wchar_t>;
  fmt::format_arg_store<wcontext, int> as{1234567};
  EXPECT_EQ(L"1~234~567",
            fmt::vformat(loc, L"{:L}", fmt::basic_format_args<wcontext>(as)));
  EXPECT_EQ(L"1234567", fmt::format(std::locale("C"), L"{:L}", 1234567));

  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<wchar_t>());
  EXPECT_EQ(L"1234567", fmt::format(no_grouping_loc, L"{:L}", 1234567));

  auto special_grouping_loc =
      std::locale(std::locale(), new special_grouping<wchar_t>());
  EXPECT_EQ(L"1,23,45,678",
            fmt::format(special_grouping_loc, L"{:L}", 12345678));

  auto small_grouping_loc =
      std::locale(std::locale(), new small_grouping<wchar_t>());
  EXPECT_EQ(L"4,2,9,4,9,6,7,2,9,5",
            fmt::format(small_grouping_loc, L"{:L}", max_value<uint32_t>()));
}

TEST(locale_test, double_formatter) {
  auto loc = std::locale(std::locale(), new special_grouping<char>());
  auto f = fmt::formatter<int>();
  auto parse_ctx = fmt::format_parse_context("L");
  f.parse(parse_ctx);
  char buf[10] = {};
  fmt::basic_format_context<char*, char> format_ctx(
      buf, {}, fmt::detail::locale_ref(loc));
  *f.format(12345, format_ctx) = 0;
  EXPECT_STREQ("12,345", buf);
}

FMT_BEGIN_NAMESPACE
template <class charT> struct formatter<std::complex<double>, charT> {
 private:
  detail::dynamic_format_specs<char> specs_;

 public:
  FMT_CONSTEXPR typename basic_format_parse_context<charT>::iterator parse(
      basic_format_parse_context<charT>& ctx) {
    using handler_type =
        detail::dynamic_specs_handler<basic_format_parse_context<charT>>;
    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                detail::type::string_type);
    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
    detail::parse_float_type_spec(specs_, ctx.error_handler());
    return it;
  }

  template <class FormatContext>
  typename FormatContext::iterator format(const std::complex<double>& c,
                                          FormatContext& ctx) {
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    auto specs = std::string();
    if (specs_.precision > 0) specs = fmt::format(".{}", specs_.precision);
    if (specs_.type) specs += specs_.type;
    auto real = fmt::format(ctx.locale().template get<std::locale>(),
                            fmt::runtime("{:" + specs + "}"), c.real());
    auto imag = fmt::format(ctx.locale().template get<std::locale>(),
                            fmt::runtime("{:" + specs + "}"), c.imag());
    auto fill_align_width = std::string();
    if (specs_.width > 0) fill_align_width = fmt::format(">{}", specs_.width);
    return format_to(ctx.out(), runtime("{:" + fill_align_width + "}"),
                     c.real() != 0 ? fmt::format("({}+{}i)", real, imag)
                                   : fmt::format("{}i", imag));
  }
};
FMT_END_NAMESPACE

TEST(locale_test, complex) {
  std::string s = fmt::format("{}", std::complex<double>(1, 2));
  EXPECT_EQ(s, "(1+2i)");
  EXPECT_EQ(fmt::format("{:.2f}", std::complex<double>(1, 2)), "(1.00+2.00i)");
  EXPECT_EQ(fmt::format("{:8}", std::complex<double>(1, 2)), "  (1+2i)");
}

#endif  // FMT_STATIC_THOUSANDS_SEPARATOR


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.circleci/config.yml
================================================
version: 2

jobs:
  inspect:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++11
    docker:
      - image: gcc:7
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git xsltproc docbook-xsl docbook-xml -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
            echo "using xsltproc ;" | tee $HOME/user-config.jam
            echo "using boostbook : /usr/share/xml/docbook/stylesheet/docbook-xsl : /usr/share/sgml/docbook/dtd/xml/4.2 ;" | tee -a $HOME/user-config.jam
      - run:
          name: Building inspect
          command: |
            cd $BOOST/boost/tools/inspect/build && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxflags="-std=gnu++14" release dist-bin
      - run:
          name: Building docs
          command: |
            cd $BOOST_REMOVE/doc && rm -rf html/boost_multiprecision && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxflags="-std=gnu++14" release
      - run:
          name: Running Inspect
          command: |
            cd $BOOST_REMOVE && ../../dist/bin/inspect -text
  specfun_mpfr:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++17
    docker:
      - image: gcc:9
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git libmpfr-dev libgmp-dev -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
      - run:
          name: Building specfun MPFR Tests
          command: |
            cd $BOOST/boost/libs/multiprecision/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu specfun_mpfr
  specfun_gmp:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++17
    docker:
      - image: gcc:9
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git libgmp-dev -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
      - run:
          name: Building specfun GMP Tests
          command: |
            cd $BOOST/boost/libs/multiprecision/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu specfun_gmp
  specfun_cpp_dec_float:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++17
    docker:
      - image: gcc:9
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
      - run:
          name: Building specfun cpp_dec_float Tests
          command: |
            cd $BOOST/boost/libs/multiprecision/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu specfun_cpp_dec_float
  specfun_cpp_bin_float:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++17
    docker:
      - image: gcc:9
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
      - run:
          name: Building specfun cpp_bin_float Tests
          command: |
            cd $BOOST/boost/libs/multiprecision/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu specfun_cpp_bin_float
  specfun_float128:
    environment:
      - BOOST_LIBRARY=multiprecision
      - CXX_STANDARD=gnu++17
    docker:
      - image: gcc:9
    steps:
      - checkout
      - run:
          name: Setting up Environment
          command: |
            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
            if [ $CIRCLE_BRANCH = "master" ]; then
                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
            else
                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
            fi
            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
      - run:
          name: install pre dependencies
          command: |
            apt-get update -yqq
            apt-get install git -y
      - run:
          name: Initializing git repo for boost
          command: |
            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
            mkdir $BOOST
            cd $BOOST
            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
            cd boost
            git submodule update --init --merge
            rm -rf $BOOST_REMOVE
            mv $HOME/project $BOOST_REMOVE
      - run:
          name: Bootstrapping boost-build
          command: |
            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
      - run:
          name: Building specfun float128 Tests
          command: |
            cd $BOOST/boost/libs/multiprecision/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu specfun_float128
workflows:
  version: 2
  build_and_test:
    jobs:
      - inspect
      - specfun_mpfr
      - specfun_gmp
      - specfun_cpp_dec_float
      - specfun_float128


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.clang-format
================================================

Language: Cpp

UseTab: Never
IndentWidth: 3
BreakBeforeBraces: Allman
IndentCaseLabels: false
ColumnLimit: 0
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
FixNamespaceComments: true
NamespaceIndentation: None
Standard: Cpp03
CompactNamespaces: true
BreakBeforeBraces: Custom
BraceWrapping:
  AfterEnum: true
  AfterStruct: true
  SplitEmptyFunction: false
  AfterClass: true
  AfterControlStatement: true
  AfterFunction: true
  AfterNamespace: false
  AfterUnion: true
  BeforeCatch: true
  BeforeElse: true
  SplitEmptyFunction: false
  SplitEmptyRecord: false
PointerAlignment: Left
SortIncludes: false



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.drone/after-success.sh
================================================
#!/bin/bash




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.drone/before-install.sh
================================================
#!/bin/bash




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.drone/before-script.sh
================================================
#!/bin/bash




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.drone/boost.sh
================================================
#!/bin/bash

set -ex
export TRAVIS_BUILD_DIR=$(pwd)
export DRONE_BUILD_DIR=$(pwd)
export TRAVIS_BRANCH=$DRONE_BRANCH
export VCS_COMMIT_ID=$DRONE_COMMIT
export GIT_COMMIT=$DRONE_COMMIT
export PATH=~/.local/bin:/usr/local/bin:$PATH

echo '==================================> BEFORE_INSTALL'

. .drone/before-install.sh

echo '==================================> INSTALL'

cd ..
git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
cd boost-root
git submodule update --init tools/build
git submodule update --init libs/config
git submodule update --init libs/polygon
git submodule update --init tools/boost_install
git submodule update --init libs/headers
git submodule update --init tools/boostdep
cp -r $TRAVIS_BUILD_DIR/* libs/multiprecision
python tools/boostdep/depinst/depinst.py multiprecision
./bootstrap.sh
./b2 headers

echo '==================================> BEFORE_SCRIPT'

. $DRONE_BUILD_DIR/.drone/before-script.sh

echo '==================================> SCRIPT'

echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
(cd libs/config/test && ../../../b2 config_info_travis_install toolset=$TOOLSET && ./config_info_travis)
(cd libs/multiprecision/test && ../../../b2 -j3 toolset=$TOOLSET $TEST_SUITE define=CI_SUPPRESS_KNOWN_ISSUES define=SLOW_COMPILER)

echo '==================================> AFTER_SUCCESS'

. $DRONE_BUILD_DIR/.drone/after-success.sh


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.drone.star
================================================
# Use, modification, and distribution are
# subject to the Boost Software License, Version 1.0. (See accompanying
# file LICENSE.txt)
#
# Copyright Rene Rivera 2020.

# For Drone CI we use the Starlark scripting language to reduce duplication.
# As the yaml syntax for Drone CI is rather limited.
#
#
globalenv={}
linuxglobalimage="cppalliance/droneubuntu1604:1"
windowsglobalimage="cppalliance/dronevs2019"

def main(ctx):
  return [
  linux_cxx("Ubunti g++-6 std=gnu++11 arithmetic_tests", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 cpp_int_tests", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 functions_and_limits", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 conversions performance", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 misc", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 compile_fail examples", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++11 concepts", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-6 std=gnu++14 arithmetic_tests", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 cpp_int_tests", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 functions_and_limits", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 conversions performance", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 misc", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 compile_fail examples", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-6 std=gnu++14 concepts", "g++-6", packages="g++-6 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-8 std=gnu++11 arithmetic_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 cpp_int_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 functions_and_limits", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 conversions performance", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 misc", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 compile_fail examples", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++11 concepts", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-8 std=gnu++14 arithmetic_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 cpp_int_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 functions_and_limits", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 conversions performance", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 misc", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 compile_fail examples", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++14 concepts", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-8 std=gnu++17 arithmetic_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 cpp_int_tests", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 functions_and_limits", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 conversions performance", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 misc", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 compile_fail examples", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-8 std=gnu++17 concepts", "g++-8", packages="g++-8 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-9 std=gnu++11 arithmetic_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 cpp_int_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 functions_and_limits", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 conversions performance", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 misc", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 compile_fail examples", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++11 concepts", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-9 std=gnu++14 arithmetic_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 cpp_int_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 functions_and_limits", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 conversions performance", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 misc", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 compile_fail examples", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++14 concepts", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-9 std=gnu++17 arithmetic_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 cpp_int_tests", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 functions_and_limits", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 conversions performance", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 misc", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 compile_fail examples", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-9 std=gnu++17 concepts", "g++-9", packages="g++-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-10 std=gnu++11 arithmetic_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 cpp_int_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 functions_and_limits", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 conversions performance", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 misc", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 compile_fail examples", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++11 concepts", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-10 std=gnu++14 arithmetic_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 cpp_int_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 functions_and_limits", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 conversions performance", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 misc", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 compile_fail examples", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++14 concepts", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-10 std=gnu++17 arithmetic_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++17 cpp_int_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++17 functions_and_limits", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  # No test of performance here, the object files get too large :(
  linux_cxx("Ubunti g++-10 std=gnu++17 conversions", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'conversions', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++17 misc", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++17 compile_fail examples", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++17 concepts", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-10 std=gnu++20 arithmetic_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 cpp_int_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 functions_and_limits", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  # No test of performance here, the object files get too large :(
  linux_cxx("Ubunti g++-10 std=gnu++20 conversions", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'conversions', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 misc", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 compile_fail examples", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 concepts", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-9 std=c++11 arithmetic_tests", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 cpp_int_test", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 functions_and_limits", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 conversions performance", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 misc", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 compile_fail examples", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++11 concepts", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-9 std=c++14 arithmetic_tests", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 cpp_int_test", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 functions_and_limits", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 conversions performance", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 misc", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 compile_fail examples", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++14 concepts", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-9 std=c++17 arithmetic_tests", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 cpp_int_test", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 functions_and_limits", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 conversions performance", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 misc", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 compile_fail examples", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-9 std=c++17 concepts", "clang++-9", packages="clang-9 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': 'c++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-10 std=c++11 arithmetic_tests", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 cpp_int_test", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 functions_and_limits", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 conversions performance", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 misc", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 compile_fail examples", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++11 concepts", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++11', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-10 std=c++14 arithmetic_tests", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 cpp_int_test", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 functions_and_limits", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 conversions performance", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 misc", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 compile_fail examples", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++14 concepts", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-10 std=c++17 arithmetic_tests", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 cpp_int_test", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 functions_and_limits", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 conversions performance", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 misc", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 compile_fail examples", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++17 concepts", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  linux_cxx("Ubunti clang++-10 std=c++20 arithmetic_tests", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 cpp_int_test", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 functions_and_limits", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 conversions performance", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 misc", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 compile_fail examples", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', }, globalenv=globalenv),
  linux_cxx("Ubunti clang++-10 std=c++20 concepts", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  # Sanitizers:
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN arithmetic_tests", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address arithmetic_tests', }, globalenv=globalenv),
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN cpp_int_test", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address cpp_int_tests', }, globalenv=globalenv),
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN functions_and_limits", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address functions_and_limits', }, globalenv=globalenv),
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN conversions", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address conversions', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', }, globalenv=globalenv),
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN misc", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', 'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address misc', }, globalenv=globalenv),
  #linux_cxx("Ubunti clang++-10 std=c++20 ASAN examples", "clang++-10", packages="clang-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TEST_SUITE': 'cxxflags=-fsanitize=address linkflags=-fsanitize=address examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': 'c++20', }, globalenv=globalenv),

  linux_cxx("Ubunti g++-10 std=gnu++20 USAN arithmetic_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined arithmetic_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 USAN cpp_int_tests", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined cpp_int_tests', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 USAN functions_and_limits", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined functions_and_limits', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 USAN conversions", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined define=BOOST_CI_USAN_BUID conversions', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 USAN misc", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', 'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined misc', }, globalenv=globalenv),
  linux_cxx("Ubunti g++-10 std=gnu++20 USAN examples", "g++-10", packages="g++-10 libgmp-dev libmpfr-dev libmpc-dev libmpfi-dev libtommath-dev", buildtype="boost", image="cppalliance/droneubuntu2004:1", environment={'TEST_SUITE': 'cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined examples', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': 'gnu++20', }, globalenv=globalenv),

  # OS X:
  osx_cxx("XCode 11.7, c++14 arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 conversions performance", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 misc", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++14 concepts", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  osx_cxx("XCode 11.7, c++17 arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 conversions performance", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 misc", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++17 concepts", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  osx_cxx("XCode 11.7, c++2a arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a conversions performance", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a misc", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', }, globalenv=globalenv),
  osx_cxx("XCode 11.7, c++2a concepts", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++2a', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  osx_cxx("XCode 10.2, c++17 arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 conversions performance", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 misc", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', }, globalenv=globalenv),
  osx_cxx("XCode 10.2, c++17 concepts", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++17', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  osx_cxx("XCode 9.3, c++14 arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 conversions performance", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 misc", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 9.3, c++14 concepts", "clang++", packages="", buildtype="boost", xcode_version="9.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),

  osx_cxx("XCode 8.3, c++14 arithmetic_tests", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'arithmetic_tests', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 cpp_int_tests", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'cpp_int_tests', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 functions_and_limits", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'functions_and_limits', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 conversions performance", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TEST_SUITE': 'conversions performance', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 misc", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'misc', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 compile_fail examples", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TEST_SUITE': 'compile_fail examples', 'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', }, globalenv=globalenv),
  osx_cxx("XCode 8.3, c++14 concepts", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': 'c++14', 'TEST_SUITE': 'concepts', }, globalenv=globalenv),
  ]

# from https://github.com/boostorg/boost-ci
load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.gitattributes
================================================
* text=auto !eol svneol=native#text/plain
*.gitattributes text svneol=native#text/plain

# Scriptish formats
*.bat        text svneol=native#text/plain
*.bsh        text svneol=native#text/x-beanshell
*.cgi        text svneol=native#text/plain
*.cmd        text svneol=native#text/plain
*.js         text svneol=native#text/javascript
*.php        text svneol=native#text/x-php
*.pl         text svneol=native#text/x-perl
*.pm         text svneol=native#text/x-perl
*.py         text svneol=native#text/x-python
*.sh         eol=lf svneol=LF#text/x-sh
configure    eol=lf svneol=LF#text/x-sh

# Image formats
*.bmp        binary svneol=unset#image/bmp
*.gif        binary svneol=unset#image/gif
*.ico        binary svneol=unset#image/ico
*.jpeg       binary svneol=unset#image/jpeg
*.jpg        binary svneol=unset#image/jpeg
*.png        binary svneol=unset#image/png
*.tif        binary svneol=unset#image/tiff
*.tiff       binary svneol=unset#image/tiff
*.svg        text svneol=native#image/svg%2Bxml

# Data formats
*.pdf        binary svneol=unset#application/pdf
*.avi        binary svneol=unset#video/avi
*.doc        binary svneol=unset#application/msword
*.dsp        text svneol=crlf#text/plain
*.dsw        text svneol=crlf#text/plain
*.eps        binary svneol=unset#application/postscript
*.gz         binary svneol=unset#application/gzip
*.mov        binary svneol=unset#video/quicktime
*.mp3        binary svneol=unset#audio/mpeg
*.ppt        binary svneol=unset#application/vnd.ms-powerpoint
*.ps         binary svneol=unset#application/postscript
*.psd        binary svneol=unset#application/photoshop
*.rdf        binary svneol=unset#text/rdf
*.rss        text svneol=unset#text/xml
*.rtf        binary svneol=unset#text/rtf
*.sln        text svneol=native#text/plain
*.swf        binary svneol=unset#application/x-shockwave-flash
*.tgz        binary svneol=unset#application/gzip
*.vcproj     text svneol=native#text/xml
*.vcxproj    text svneol=native#text/xml
*.vsprops    text svneol=native#text/xml
*.wav        binary svneol=unset#audio/wav
*.xls        binary svneol=unset#application/vnd.ms-excel
*.zip        binary svneol=unset#application/zip

# Text formats
.htaccess    text svneol=native#text/plain
*.bbk        text svneol=native#text/xml
*.cmake      text svneol=native#text/plain
*.css        text svneol=native#text/css
*.dtd        text svneol=native#text/xml
*.htm        text svneol=native#text/html
*.html       text svneol=native#text/html
*.ini        text svneol=native#text/plain
*.log        text svneol=native#text/plain
*.mak        text svneol=native#text/plain
*.qbk        text svneol=native#text/plain
*.rst        text svneol=native#text/plain
*.sql        text svneol=native#text/x-sql
*.txt        text svneol=native#text/plain
*.xhtml      text svneol=native#text/xhtml%2Bxml
*.xml        text svneol=native#text/xml
*.xsd        text svneol=native#text/xml
*.xsl        text svneol=native#text/xml
*.xslt       text svneol=native#text/xml
*.xul        text svneol=native#text/xul
*.yml        text svneol=native#text/plain
boost-no-inspect text svneol=native#text/plain
CHANGES      text svneol=native#text/plain
COPYING      text svneol=native#text/plain
INSTALL      text svneol=native#text/plain
Jamfile      text svneol=native#text/plain
Jamroot      text svneol=native#text/plain
Jamfile.v2   text svneol=native#text/plain
Jamrules     text svneol=native#text/plain
Makefile*    text svneol=native#text/plain
README       text svneol=native#text/plain
TODO         text svneol=native#text/plain

# Code formats
*.c          text svneol=native#text/plain
*.cpp        text svneol=native#text/plain
*.h          text svneol=native#text/plain
*.hpp        text svneol=native#text/plain
*.ipp        text svneol=native#text/plain
*.tpp        text svneol=native#text/plain
*.jam        text svneol=native#text/plain
*.java       text svneol=native#text/plain


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.github/workflows/multiprecision.yml
================================================
# Copyright 2020 Evan Miller
# Copyright 2020 Matt Borland
# Copyright 2021 John Maddock
# Copyright 2021 Christopher Kormanyos
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

name: multiprecision
on:
  push:
    branches:
      - master
      - develop
  pull_request:
  release:
    types: [published, created, edited]
jobs:
  ubuntu-jammy:
    runs-on: ubuntu-22.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-12, clang++-14 ]
        standard: [ c++11, c++14, c++17, c++20, c++2b ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-12 clang-14 libgmp-dev libmpfr-dev libtommath-dev libeigen3-dev libmpfi-dev libmpc-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 -j2 toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES include=/usr/include/eigen3
        working-directory: ../boost-root/libs/multiprecision/test
  ubuntu-focal:
    runs-on: ubuntu-20.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-10, g++-11, clang++-10, clang++-11 ]
        standard: [ c++11, c++14, c++17, c++2a ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-9 g++-10 g++-11 clang-10 clang-11 libgmp-dev libmpfr-dev libtommath-dev libeigen3-dev libmpfi-dev libmpc-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 -j2 toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES include=/usr/include/eigen3
        working-directory: ../boost-root/libs/multiprecision/test
  ubuntu-focal-slow-tests:
    runs-on: ubuntu-20.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-10 ]
        standard: [ c++11, c++17, c++2a ]
        suite: [ specfun_mpfr, specfun_gmp, specfun_cpp_dec_float, specfun_cpp_bin_float, specfun_float128 ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-9 g++-10 clang-10 libgmp-dev libmpfr-dev libtommath-dev libeigen3-dev libmpfi-dev libmpc-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 -j2 toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES include=/usr/include/eigen3
        working-directory: ../boost-root/libs/multiprecision/test
  ubuntu-focal-standalone-tests:
    runs-on: ubuntu-20.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-11 ]
        standard: [ c++11, c++14, c++17, c++20 ]
        suite: [ standalone ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-11 libgmp-dev libmpfr-dev libtommath-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 -j2 toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES
        working-directory: ../boost-root/libs/multiprecision/test
  ubuntu-focal-ASAN:
    runs-on: ubuntu-20.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-10 ]
        standard: [ c++17 ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-10 libgmp-dev libmpfr-dev libtommath-dev libeigen3-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 define=BOOST_CI_ASAN_BUILD define=BOOST_CI_SANITIZER_BUILD cxxflags=-fsanitize=address linkflags=-fsanitize=address toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES
        working-directory: ../boost-root/libs/multiprecision/test
  ubuntu-focal-UBSAN:
    runs-on: ubuntu-20.04
    defaults:
      run:
        shell: bash
    strategy:
      fail-fast: false
      matrix:
        compiler: [ g++-10 ]
        standard: [ c++17 ]
        suite: [ arithmetic_tests, functions_and_limits, misc ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Set TOOLSET
        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
      - name: Add repository
        continue-on-error: true
        id: addrepo
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo
        continue-on-error: true
        id: retry1
        if: steps.addrepo.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Retry Add Repo 2
        continue-on-error: true
        id: retry2
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
        run: sudo apt install g++-10 libgmp-dev libeigen3-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 define=BOOST_CI_UBSAN_BUILD define=BOOST_CI_SANITIZER_BUILD cxxflags=-fsanitize=undefined linkflags=-fsanitize=undefined toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES
        working-directory: ../boost-root/libs/multiprecision/test
  windows_gcc:
    runs-on: windows-2019
    defaults:
      run:
        shell: cmd
    env:
      ARGS: toolset=${{ matrix.toolset }} address-model=64 cxxstd=${{ matrix.standard }}
    strategy:
      fail-fast: false
      matrix:
        toolset: [ gcc ]
        standard: [ 11, 14, 17 ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: bootstrap
        working-directory: ../boost-root
      - name: Generate headers
        run: b2 headers
        working-directory: ../boost-root
      - name: Config info install
        run: ..\..\..\b2 config_info_travis_install %ARGS%
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ..\..\..\b2 -j2 --hash %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES ${{ matrix.suite }}
        working-directory: ../boost-root/libs/multiprecision/test
  windows_msvc_14_0:
    runs-on: windows-2019
    defaults:
      run:
        shell: cmd
    env:
      ARGS: toolset=${{ matrix.toolset }} address-model=64 cxxstd=${{ matrix.standard }}
    strategy:
      fail-fast: false
      matrix:
        toolset: [ msvc-14.0 ]
        standard: [ 14, 17 ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: bootstrap
        working-directory: ../boost-root
      - name: Generate headers
        run: b2 headers
        working-directory: ../boost-root
      - name: Config info install
        run: ..\..\..\b2 config_info_travis_install %ARGS%
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ..\..\..\b2 -j2 --hash %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES ${{ matrix.suite }}
        working-directory: ../boost-root/libs/multiprecision/test
  windows_msvc_14_2:
    runs-on: windows-2019
    defaults:
      run:
        shell: cmd
    env:
      ARGS: toolset=${{ matrix.toolset }} address-model=64 cxxstd=${{ matrix.standard }}
    strategy:
      fail-fast: false
      matrix:
        toolset: [ msvc-14.2 ]
        standard: [ 14, 17, 20 ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: bootstrap
        working-directory: ../boost-root
      - name: Generate headers
        run: b2 headers
        working-directory: ../boost-root
      - name: Config info install
        run: ..\..\..\b2 config_info_travis_install %ARGS%
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ..\..\..\b2 -j2 --hash %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES ${{ matrix.suite }}
        working-directory: ../boost-root/libs/multiprecision/test
  macos:
    runs-on: macos-latest
    strategy:
      fail-fast: false
      matrix:
        toolset: [ clang ]
        standard: [ 11, 14, 17, 2a ]
        suite: [ arithmetic_tests, functions_and_limits, conversions, cpp_int_tests, misc, compile_fail, concepts, examples ]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: '0'
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
        run: git submodule update --init tools/boostdep
        working-directory: ../boost-root
      - name: Copy files
        run: cp -r $GITHUB_WORKSPACE/* libs/multiprecision
        working-directory: ../boost-root
      - name: Install deps
        run: python tools/boostdep/depinst/depinst.py multiprecision
        working-directory: ../boost-root
      - name: Bootstrap
        run: ./bootstrap.sh
        working-directory: ../boost-root
      - name: Generate headers
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Config info install
        run: ../../../b2 config_info_travis_install toolset=${{ matrix.toolset }} cxxstd=${{ matrix.standard }}
        working-directory: ../boost-root/libs/config/test
      - name: Config info
        run: ./config_info_travis
        working-directory: ../boost-root/libs/config/test
      - name: Test
        run: ../../../b2 -j2 toolset=${{ matrix.toolset }} cxxstd=${{ matrix.standard }} ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES
        working-directory: ../boost-root/libs/multiprecision/test


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/.gitignore
================================================
# /boost/libs/multiprecision/.gitignore
# Use of manifest is unclear, so add to .gitignore.
/doc/html/standalone_HTML.manifest
*.DS_Store
/**/*.dSYM/
**/.temps/*
build/*
.vscode/*
.idea/*

# CMake Related Options
*.a
*.o
cmake_install.cmake
CMakeCache.txt
Makefile
**/CMakeFiles/**
**CTestTestfile.cmake
DartConfiguration.tcl
cmake-build-debug/*


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/CMakeLists.txt
================================================
# Generated by `boostdep --cmake multiprecision`
# Copyright 2020 Peter Dimov
# Copyright 2021 Matt Borland
# Distributed under the Boost Software License, Version 1.0.
# https://www.boost.org/LICENSE_1_0.txt

cmake_minimum_required(VERSION 3.5...3.16)

project(boost_multiprecision VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)

add_library(boost_multiprecision INTERFACE)
add_library(Boost::multiprecision ALIAS boost_multiprecision)

target_include_directories(boost_multiprecision INTERFACE include)

include(CMakeDependentOption)

cmake_dependent_option(BOOST_MP_STANDALONE "Use Boost.Multiprecision in standalone mode" ON "NOT BOOST_SUPERPROJECT_VERSION" OFF)

message(STATUS "Boost.Multiprecision: standalone mode ${BOOST_MP_STANDALONE}")

if(BOOST_MP_STANDALONE)

  target_compile_definitions(boost_multiprecision INTERFACE BOOST_MP_STANDALONE=1)

else()

  target_link_libraries(boost_multiprecision
    INTERFACE
      Boost::assert
      Boost::config
      Boost::core
      Boost::integer
      Boost::lexical_cast
      Boost::math
      Boost::random
  )

endif()

if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")

  add_subdirectory(test)

endif()



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/LICENSE
================================================
Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/README.md
================================================
Boost Multiprecision Library
============================

>ANNOUNCEMENT: Support for C++11 will be deprecated in this library starting in July 2023 (Boost 1.82).  
>New features will require *at least* C++14, as will existing features starting with the deprecation release.

|                  |  Master  |   Develop   |
|------------------|----------|-------------|
| Drone            |  [![Build Status](https://drone.cpp.al/api/badges/boostorg/multiprecision/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/multiprecision) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/multiprecision/status.svg)](https://drone.cpp.al/boostorg/multiprecision) |
| Github Actions | [![Build Status](https://github.com/boostorg/multiprecision/workflows/multiprecision/badge.svg?branch=master)](https://github.com/boostorg/multiprecision/actions) | [![Build Status](https://github.com/boostorg/multiprecision/workflows/multiprecision/badge.svg?branch=develop)](https://github.com/boostorg/multiprecision/actions) |

 The Multiprecision Library provides integer, rational, floating-point, complex and interval number types in C++ that have more range and 
 precision than C++'s ordinary built-in types. The big number types in Multiprecision can be used with a wide selection of basic 
 mathematical operations, elementary transcendental functions as well as the functions in Boost.Math. The Multiprecision types can 
 also interoperate with the built-in types in C++ using clearly defined conversion rules. This allows Boost.Multiprecision to be 
 used for all kinds of mathematical calculations involving integer, rational and floating-point types requiring extended range and precision.

Multiprecision consists of a generic interface to the mathematics of large numbers as well as a selection of big number back ends, with 
support for integer, rational and floating-point types. Boost.Multiprecision provides a selection of back ends provided off-the-rack in 
including interfaces to GMP, MPFR, MPIR, TomMath as well as its own collection of Boost-licensed, header-only back ends for integers, 
rationals, floats and complex. In addition, user-defined back ends can be created and used with the interface of Multiprecision, provided the class implementation adheres to the necessary concepts.

Depending upon the number type, precision may be arbitrarily large (limited only by available memory), fixed at compile time 
(for example 50 or 100 decimal digits), or a variable controlled at run-time by member functions. The types are expression-template-enabled 
for better performance than naive user-defined types. 

The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/multiprecision/index.html).

## Standalone ##

Defining BOOST_MP_STANDALONE allows Boost.Multiprecision to be used with the only dependency being [Boost.Config](https://github.com/boostorg/config). Our [package on this page](https://github.com/boostorg/multiprecision/releases)
already includes a copy of Boost.Config so no other donwloads are required. Some functionality is reduced in this mode. A static_assert message will alert you if a particular feature has been disabled by standalone mode.
[Boost.Math](https://github.com/boostorg/math) standalone mode is compatiable, and recommended if special functions are required for the floating point types.

## Support, bugs and feature requests ##

Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/multiprecision/issues)
(see [open issues](https://github.com/boostorg/multiprecision/issues) and
[closed issues](https://github.com/boostorg/multiprecision/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).

You can submit your changes through a [pull request](https://github.com/boostorg/multiprecision/pulls).

There is no mailing-list specific to Boost Multiprecision, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [multiprecision].


## Development ##

Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): 

    git clone https://github.com/boostorg/boost
    cd boost
    git submodule update --init

The Boost Multiprecision Library is located in `libs/multiprecision/`. 

### Running tests ###
First, build the B2 engine by running `bootstrap.sh` in the root of the boost directory. This will generate B2 configuration in `project-config.jam`.
     
    ./bootstrap.sh

Now make sure you are in `libs/multiprecision/test`. You can either run all the tests listed in `Jamfile.v2` or run a single test:

    ../../../b2                        <- run all tests
    ../../../b2 test_complex           <- single test



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/Jamfile.v2
================================================
# copyright John Maddock 2008
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or copy at 
# http://www.boost.org/LICENSE_1_0.txt.

import modules ;
import path ;
import ../../config/checks/config : requires ;

local gmp_path = [ modules.peek : GMP_PATH ] ;
local mpfr_path = [ modules.peek : MPFR_PATH ] ;
local mpfi_path = [ modules.peek : MPFI_PATH ] ;
local tommath_path = [ modules.peek : TOMMATH_PATH ] ;

project : requirements 
   <include>$(gmp_path) 
   <include>$(gmp_path)/mpfr 
   <include>$(gmp_path)/gmpfrxx 
   <include>$(mpfr_path)
   <include>$(mpfi_path)
   <include>$(mpfi_path)/src
   <include>$(tommath_path)
   <include>../../.. 
   <search>$(gmp_path) 
   <search>$(mpfr_path) 
   <search>$(mpfr_path)/build.vc10/lib/Win32/Debug
   <search>$(tommath_path) 
   <search>$(mpfi_path) 
   <search>$(mpfi_path)/src 
   # We set these to make it easier to set up and test GMP and MPFR under Win32:
   <toolset>msvc:<runtime-link>static
   <toolset>msvc:<link>static
   <toolset>intel-win:<runtime-link>static
   <toolset>intel-win:<link>static
   <toolset>msvc:<warnings>all
   <toolset>gcc:<cxxflags>-Wall
   <toolset>gcc:<cxxflags>-Wextra
   ;

lib gmp ;
lib mpfr ;
lib mpfi ;
lib mpc ;
lib quadmath ;
lib tommath ;
lib f2c ;

actions mp_simple_run_action
{
      $(>) > $(<)
}

rule mp-run-simple ( sources + : args * : input-files * : requirements * : target-name )
{
   exe $(target-name)_exe : $(sources) : $(requirements) ;
   explicit $(target-name)_exe ;
   make $(target-name).output : $(target-name)_exe : @mp_simple_run_action ;
   explicit $(target-name).output ;
   alias $(target-name) : $(target-name).output ;
}

mp-run-simple has_gmp.cpp gmp : : :
      <include>$(gmp_path) <include>$(gmp_path)/mpfr <include>$(gmp_path)/gmpfrxx : has_gmp ;
mp-run-simple has_mpfr.cpp mpfr gmp : : :
      <include>$(mpfr_path) <include>$(gmp_path)/mpfr <include>$(gmp_path)/gmpfrxx <include>$(gmp_path) : has_mpfr ;
mp-run-simple has_mpfi.cpp mpfi mpfr gmp : : :
      <include>$(mpfr_path) <include>$(gmp_path)/mpfr <include>$(gmp_path)/gmpfrxx <include>$(gmp_path) : has_mpfi ;
mp-run-simple has_mpc.cpp mpc mpfr gmp : : :
      <include>$(mpfr_path) <include>$(gmp_path)/mpfr <include>$(gmp_path)/gmpfrxx <include>$(gmp_path) : has_mpc ;
mp-run-simple has_tommath.cpp tommath : : :
      <include>$(tommath_path) : has_tommath ;
mp-run-simple has_float128.cpp quadmath : : : : has_float128 ;
exe has_intel_quad : has_intel_quad.cpp : <cxxflags>-Qoption,cpp,--extended_float_type ;
exe has_eigen : has_eigen.cpp ;
exe has_f2c : has_f2c.cpp f2c ;
obj has_is_constant_evaluated : has_is_constant_evaluated.cpp ;
obj has_constexpr_limits : has_constexpr_limits_cmd.cpp : <cxxflags>-fconstexpr-ops-limit=268435456 ;
obj has_big_obj : has_big_obj.cpp : <cxxflags>-Wa,-mbig-obj ;
obj is_ci_sanitizer_run : is_ci_sanitizer_run.cpp ;

explicit has_gmp ;
explicit has_mpfr ;
explicit has_mpfi ;
explicit has_tommath ;
explicit has_float128 ;
explicit has_intel_quad ;
explicit has_mpc ;
explicit has_eigen ;
explicit has_is_constant_evaluated ;
explicit has_constexpr_limits ;
explicit has_big_obj ;
explicit has_f2c ;
explicit is_ci_sanitizer_run ;


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_big_obj.cpp
================================================
//  Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef __GNUC__
#error "compiler is not GCC"
#endif

int main()
{
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_constexpr_limits_cmd.cpp
================================================
//  Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef __GNUC__
#error "Compiler is not GCC"
#endif
#if __GNUC__ < 9
#error "Older GCC versions don't support -fconstexpr-ops-limit"
#endif

int main()
{
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_eigen.cpp
================================================
//  Copyright John Maddock 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <Eigen/Dense>

int main()
{
#if EIGEN_VERSION_AT_LEAST(3, 3, 0)
#else
#error "Obsolete Eigen"
#endif
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_f2c.cpp
================================================
//  Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <f2c.h>

int main()
{
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_float128.cpp
================================================
//  Copyright John Maddock 2013.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/config.hpp>

#ifndef BOOST_HAS_FLOAT128
#error "This doesn't work unless Boost.Config enables __float128 support"
#endif

extern "C" {
#include <quadmath.h>
}

int main()
{
   __float128 f = -2.0Q;
   f            = fabsq(f);
   f            = expq(f);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_gmp.cpp
================================================
//  Copyright John Maddock 2008.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <cstddef> // See https://gcc.gnu.org/gcc-4.9/porting_to.html
#include <gmp.h>
#include <boost/config.hpp>

#ifdef __GNUC__
#pragma message "__GNU_MP_VERSION=" BOOST_STRINGIZE(__GNU_MP_VERSION)
#pragma message "__GNU_MP_VERSION_MINOR=" BOOST_STRINGIZE(__GNU_MP_VERSION_MINOR)
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

int main()
{
   void* (*alloc_func_ptr)(size_t);
   void* (*realloc_func_ptr)(void*, size_t, size_t);
   void (*free_func_ptr)(void*, size_t);

   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

   mpz_t integ;
   mpz_init(integ);
   if (integ[0]._mp_d)
      mpz_clear(integ);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_intel_quad.cpp
================================================
//  Copyright John Maddock 2013.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

extern "C" _Quad __fabs(_Quad);

int main()
{
   _Quad f = -2.0Q;
   f       = __fabsq(f);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_is_constant_evaluated.cpp
================================================
//  Copyright John Maddock 2013.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// This program determines if std::is_constant_evaluated  is available to switch within a function to use compile-time constexp calculations.
// See https://en.cppreference.com/w/cpp/types/is_constant_evaluated
// and https://en.cppreference.com/w/cpp/compiler_support
// Currently only GCC 9 and Clang 9 and <cxxflags>-std=c++2a or  b2 cxxstd=2a

// https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros

// From Clang 10 onwards, __has_builtin(__X) can be used.  but also works for Clang 9

// boost\libs\multiprecision\config>b2 has_is_constant_evaluated toolset=clang-win-9.0.0 cxxstd=2a address-model=64 release  >  mp_is_const_eval_30Sep2019.log

#include <boost/config.hpp>
#include <boost/config/pragma_message.hpp>

#include <boost/multiprecision/number.hpp>

#ifdef __has_builtin
BOOST_PRAGMA_MESSAGE (" __has_builtin is defined.")

#  if __has_builtin(__builtin_is_constant_evaluated)
BOOST_PRAGMA_MESSAGE (" __has_builtin(__builtin_is_constant_evaluated), so BOOST_MP_NO_CONSTEXPR_DETECTION should NOT be defined.")
#  endif // __has_builtin(__builtin_is_constant_evaluated)

#endif // __has_builtin

#ifdef BOOST_MP_HAS_IS_CONSTANT_EVALUATED
BOOST_PRAGMA_MESSAGE ("BOOST_MP_HAS_IS_CONSTANT_EVALUATED defined.")
#else
BOOST_PRAGMA_MESSAGE ("BOOST_MP_HAS_IS_CONSTANT_EVALUATED is NOT defined, so no std::is_constant_evaluated() from std library.")
#endif

#ifdef BOOST_NO_CXX14_CONSTEXPR
BOOST_PRAGMA_MESSAGE ("BOOST_NO_CXX14_CONSTEXPR is defined.")
#endif

#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
#  error 1  "std::is_constant_evaluated is NOT available to determine if a calculation can use constexpr."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_mpc.cpp
================================================
//  Copyright John Maddock 2018.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <cstddef> // See https://gcc.gnu.org/gcc-4.9/porting_to.html
#include <mpc.h>
#include <boost/config.hpp>

#ifdef __GNUC__
#pragma message "MPFR_VERSION_STRING=" MPFR_VERSION_STRING
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

#if (MPFR_VERSION < 3)
#error "Incompatible MPFR version"
#endif

#ifdef __GNUC__
#pragma message "__GNU_MP_VERSION=" BOOST_STRINGIZE(__GNU_MP_VERSION)
#pragma message "__GNU_MP_VERSION_MINOR=" BOOST_STRINGIZE(__GNU_MP_VERSION_MINOR)
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

/*
#ifdef __GNUC__
#pragma message "MPFI_VERSION_MAJOR=" BOOST_STRINGIZE(MPFI_VERSION_MAJOR)
#pragma message "MPFI_VERSION_MAJOR=" BOOST_STRINGIZE(MPFI_VERSION_MAJOR)
#endif 

#if MPFI_VERSION_MAJOR < 1
#error "Incompatible MPFI version"
#endif
#if (MPFI_VERSION_MAJOR == 1) && (MPFI_VERSION_MINOR < 5)
#error "Incompatible MPFI version"
#endif
*/
int main()
{
   void* (*alloc_func_ptr)(size_t);
   void* (*realloc_func_ptr)(void*, size_t, size_t);
   void (*free_func_ptr)(void*, size_t);

   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

   mpfr_buildopt_tls_p();

   mpc_t t;
   mpc_init2(t, 128);
   mpc_clear(t);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_mpfi.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <cstddef> // See https://gcc.gnu.org/gcc-4.9/porting_to.html
#include <mpfi.h>
#include <boost/config.hpp>

#ifdef __GNUC__
#pragma message "MPFR_VERSION_STRING=" MPFR_VERSION_STRING
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

#if (MPFR_VERSION < 3)
#error "Incompatible MPFR version"
#endif

#ifdef __GNUC__
#pragma message "__GNU_MP_VERSION=" BOOST_STRINGIZE(__GNU_MP_VERSION)
#pragma message "__GNU_MP_VERSION_MINOR=" BOOST_STRINGIZE(__GNU_MP_VERSION_MINOR)
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

/*
#ifdef __GNUC__
#pragma message "MPFI_VERSION_MAJOR=" BOOST_STRINGIZE(MPFI_VERSION_MAJOR)
#pragma message "MPFI_VERSION_MAJOR=" BOOST_STRINGIZE(MPFI_VERSION_MAJOR)
#endif 

#if MPFI_VERSION_MAJOR < 1
#error "Incompatible MPFI version"
#endif
#if (MPFI_VERSION_MAJOR == 1) && (MPFI_VERSION_MINOR < 5)
#error "Incompatible MPFI version"
#endif
*/
int main()
{
   void* (*alloc_func_ptr)(size_t);
   void* (*realloc_func_ptr)(void*, size_t, size_t);
   void (*free_func_ptr)(void*, size_t);

   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

   mpfr_buildopt_tls_p();

   mpfi_t t;
   mpfi_init2(t, 128);
   if (t[0].left._mpfr_d)
      mpfi_clear(t);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_mpfr.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <cstddef> // See https://gcc.gnu.org/gcc-4.9/porting_to.html
#include <mpfr.h>
#include <boost/config.hpp>

#ifdef __GNUC__
#pragma message "MPFR_VERSION_STRING=" MPFR_VERSION_STRING
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

#if (MPFR_VERSION < 3)
#error "Incompatible MPFR version"
#endif

#ifdef __GNUC__
#pragma message "__GNU_MP_VERSION=" BOOST_STRINGIZE(__GNU_MP_VERSION)
#pragma message "__GNU_MP_VERSION_MINOR=" BOOST_STRINGIZE(__GNU_MP_VERSION_MINOR)
#endif

#if (__GNU_MP_VERSION < 4) || ((__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR < 2))
#error "Incompatible GMP version"
#endif

int main()
{
   void* (*alloc_func_ptr)(size_t);
   void* (*realloc_func_ptr)(void*, size_t, size_t);
   void (*free_func_ptr)(void*, size_t);

   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

   mpfr_buildopt_tls_p();

   mpfr_t t;
   mpfr_init2(t, 128);
   if (t[0]._mpfr_d)
      mpfr_clear(t);

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/has_tommath.cpp
================================================
//  Copyright John Maddock 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <tommath.h>

int main()
{
   mp_int v;
   mp_init(&v);
   if (v.dp)
      mp_clear(&v);
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/config/is_ci_sanitizer_run.cpp
================================================
//  Copyright John Maddock 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if !defined(BOOST_CI_SANITIZER_BUILD)
#  error "Sanitizer is NOT in effect".
#endif

int main()
{
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/Jamfile.v2
================================================

# Copyright John Maddock 2011. Use, modification, and distribution are
# subject to the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

using quickbook ;
using auto-index ;

path-constant images_location : html ;
path-constant here : . ;

xml multiprecision : multiprecision.qbk ;

boostbook standalone
    :
        multiprecision
    :
        # Path for links to Boost:
        <xsl:param>boost.root=../../../..
        
        # Some general style settings:
        <xsl:param>table.footnote.number.format=1
        <xsl:param>footnote.number.format=1
        #<xsl:param>html.stylesheet=../../../../doc/src/boostbook.css

        # HTML options first:
        # Use graphics not text for navigation:
        <xsl:param>navig.graphics=1
        # How far down we chunk nested sections, basically all of them:
        <xsl:param>chunk.section.depth=10
        # Don't put the first section on the same page as the TOC:
        <xsl:param>chunk.first.sections=10
        # How far down sections get TOC's
        <xsl:param>toc.section.depth=10
        # Max depth in each TOC:
        <xsl:param>toc.max.depth=4
        # How far down we go with TOC's
        #<xsl:param>generate.section.toc.level=10
        # Index on type:
        <xsl:param>index.on.type=1
        <xsl:param>html.stylesheet=multiprecision.css # Local variant for multiprecision,
        # extending 'standard' BOOST_ROOT/doc/src/boostbook.css with
        # @import url('../../../../doc/src/boostbook.css');
        # in location multiprecision/doc/html/multiprecision.css
    
       
        # PDF Options:
        # TOC Generation: this is needed for FOP-0.9 and later:
        <xsl:param>fop1.extensions=0
        <format>pdf:<xsl:param>xep.extensions=1
        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
        <format>pdf:<xsl:param>fop.extensions=0
        <format>pdf:<xsl:param>fop1.extensions=0
        # No indent on body text:
        <format>pdf:<xsl:param>body.start.indent=0pt
        # Margin size:
        <format>pdf:<xsl:param>page.margin.inner=0.5in
        # Margin size:
        <format>pdf:<xsl:param>page.margin.outer=0.5in
        # Paper type = A4
        <format>pdf:<xsl:param>paper.type=A4
        # Yes, we want graphics for admonishments:
        <xsl:param>admon.graphics=1
        # Set these for PDF generation *only*:
        # default PNG graphics are awful in PDF form,
        # better use SVGs instead:
        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
        <format>pdf:<xsl:param>use.role.for.mediaobject=1 
        <format>pdf:<xsl:param>preferred.mediaobject.role=print
        <format>pdf:<xsl:param>img.src.path=$(images_location)/
        <format>pdf:<xsl:param>draft.mode="no"
        # This is copied from math but doesn't look right for here?
        <format>pdf:<xsl:param>boost.url.prefix=http\://www.boost.org/doc/libs/release/libs/math/doc/sf_and_dist/html

# Experimental - use SVG for html to improve image quality.
#  .SVG files are roughly twice the .png size and so a bit gross.
# This also changes the admonitions icons.
#       <format>html:<xsl:param>admon.graphics.extension=".svg"
        <format>html:<xsl:param>use.role.for.mediaobject=1 
        <format>html:<xsl:param>preferred.mediaobject.role=print
     #   <format>html:<xsl:param>img.src.path=$(images_location)/ isn't right for html.
        <format>html:<xsl:param>draft.mode="no"
        <format>html:<xsl:param>boost.url.prefix=http\://www.boost.org/doc/libs/release/libs/multiprecision/doc/html
        
        # Index generation:
        <auto-index>on
        <auto-index-script>$(here)/index.idx
        <auto-index-prefix>$(here)/../../.. 
        <auto-index-verbose>on
        <format>html:<auto-index-internal>on
        <quickbook-define>enable_index 
        <format>pdf:<xsl:param>index.on.type=1
    ;

install pdfinstall : standalone : <location>. <install-type>PDF <name>multiprecision.pdf ;

###############################################################################
alias boostdoc ;
explicit boostdoc ;
alias boostrelease : standalone ;
explicit boostrelease ;


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/floating_point_eg1.mml
================================================
<?xml version='1.0'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN'
  'http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd'
  [<!ENTITY mathml 'http://www.w3.org/1998/Math/MathML'>]>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head><title>floating_point_eg1</title>
<!-- MathML created with MathCast Equation Editor version 0.89 -->
</head>
<body>
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mfenced>
      <mrow>
        <mn>1</mn>
      </mrow>
    </mfenced>
    <mspace width="1em"/>
    <mspace width="1em"/>
    <mtable>
      <mtr>
        <mtd>
          <mi>f</mi>
          <mo>&#x2032;</mo>
          <mfenced>
            <mrow>
              <mi>x</mi>
            </mrow>
          </mfenced>
        </mtd>
        <mtd>
          <mo>&#x2248;</mo>
        </mtd>
        <mtd>
          <msub>
            <mi>m</mi>
            <mn>1</mn>
          </msub>
          <mo>+</mo>
          <mi>O</mi>
          <mfenced>
            <mrow>
              <mi>d</mi>
              <msup>
                <mi>x</mi>
                <mn>2</mn>
              </msup>
            </mrow>
          </mfenced>
        </mtd>
      </mtr>
      <mtr>
        <mtd>
          <mi>f</mi>
          <mo>&#x2032;</mo>
          <mfenced>
            <mrow>
              <mi>x</mi>
            </mrow>
          </mfenced>
        </mtd>
        <mtd>
          <mo>&#x2248;</mo>
        </mtd>
        <mtd>
          <mfrac>
            <mn>4</mn>
            <mn>3</mn>
          </mfrac>
          <msub>
            <mi>m</mi>
            <mn>1</mn>
          </msub>
          <mo>&#x2212;</mo>
          <mfrac>
            <mn>1</mn>
            <mn>3</mn>
          </mfrac>
          <msub>
            <mi>m</mi>
            <mn>2</mn>
          </msub>
          <mo>+</mo>
          <mi>O</mi>
          <mfenced>
            <mrow>
              <mi>d</mi>
              <msup>
                <mi>x</mi>
                <mn>4</mn>
              </msup>
            </mrow>
          </mfenced>
        </mtd>
      </mtr>
      <mtr>
        <mtd>
          <mi>f</mi>
          <mo>&#x2032;</mo>
          <mfenced>
            <mrow>
              <mi>x</mi>
            </mrow>
          </mfenced>
        </mtd>
        <mtd>
          <mo>&#x2248;</mo>
        </mtd>
        <mtd>
          <mfrac>
            <mn>3</mn>
            <mn>2</mn>
          </mfrac>
          <msub>
            <mi>m</mi>
            <mn>1</mn>
          </msub>
          <mo>&#x2212;</mo>
          <mfrac>
            <mn>3</mn>
            <mn>5</mn>
          </mfrac>
          <msub>
            <mi>m</mi>
            <mn>2</mn>
          </msub>
          <mo>+</mo>
          <mfrac>
            <mn>1</mn>
            <mn>10</mn>
          </mfrac>
          <msub>
            <mi>m</mi>
            <mn>3</mn>
          </msub>
          <mo>+</mo>
          <mi>O</mi>
          <mfenced>
            <mrow>
              <mi>d</mi>
              <msup>
                <mi>x</mi>
                <mn>6</mn>
              </msup>
            </mrow>
          </mfenced>
        </mtd>
      </mtr>
    </mtable>
  </mrow>
</math>
</body>
</html>




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/floating_point_eg2.mml
================================================
<?xml version='1.0'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN'
  'http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd'
  [<!ENTITY mathml 'http://www.w3.org/1998/Math/MathML'>]>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head><title>floating_point_eg2</title>
<!-- MathML created with MathCast Equation Editor version 0.89 -->
</head>
<body>
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mfenced>
      <mrow>
        <mn>2</mn>
      </mrow>
    </mfenced>
    <mspace width="1em"/>
    <mspace width="1em"/>
    <mtable>
      <mtr>
        <mtd>
          <msub>
            <mi>m</mi>
            <mn>1</mn>
          </msub>
        </mtd>
        <mtd>
          <mo>=</mo>
        </mtd>
        <mtd>
          <mfrac>
            <mrow>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>+</mo>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
              <mo>&#x2212;</mo>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>&#x2212;</mo>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
            </mrow>
            <mrow>
              <mn>2</mn>
              <mi>d</mi>
              <mi>x</mi>
            </mrow>
          </mfrac>
        </mtd>
      </mtr>
      <mtr>
        <mtd>
          <msub>
            <mi>m</mi>
            <mn>2</mn>
          </msub>
        </mtd>
        <mtd>
          <mo>=</mo>
        </mtd>
        <mtd>
          <mfrac>
            <mrow>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>+</mo>
                  <mn>2</mn>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
              <mo>&#x2212;</mo>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>&#x2212;</mo>
                  <mn>2</mn>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
            </mrow>
            <mrow>
              <mn>4</mn>
              <mi>d</mi>
              <mi>x</mi>
            </mrow>
          </mfrac>
        </mtd>
      </mtr>
      <mtr>
        <mtd>
          <msub>
            <mi>m</mi>
            <mn>3</mn>
          </msub>
        </mtd>
        <mtd>
          <mo>=</mo>
        </mtd>
        <mtd>
          <mfrac>
            <mrow>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>+</mo>
                  <mn>3</mn>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
              <mo>&#x2212;</mo>
              <mi>f</mi>
              <mfenced>
                <mrow>
                  <mi>x</mi>
                  <mo>&#x2212;</mo>
                  <mn>3</mn>
                  <mi>d</mi>
                  <mi>x</mi>
                </mrow>
              </mfenced>
            </mrow>
            <mrow>
              <mn>6</mn>
              <mi>d</mi>
              <mi>x</mi>
            </mrow>
          </mfrac>
        </mtd>
      </mtr>
    </mtable>
  </mrow>
</math>
</body>
</html>



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/floating_point_eg3.mml
================================================
<?xml version='1.0'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN'
  'http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd'
  [<!ENTITY mathml 'http://www.w3.org/1998/Math/MathML'>]>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head><title>floating_point_eg3</title>
<!-- MathML created with MathCast Equation Editor version 0.89 -->
</head>
<body>
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mfenced>
      <mrow>
        <mn>3</mn>
      </mrow>
    </mfenced>
    <mspace width="1em"/>
    <mspace width="1em"/>
    <mfrac>
      <mi>d</mi>
      <mrow>
        <mi>d</mi>
        <mi>x</mi>
      </mrow>
    </mfrac>
    <mi>sin</mi>
    <mi>x</mi>
    <msub>
      <mo>|</mo>
      <mrow>
        <mi>x</mi>
        <mo>=</mo>
        <mfrac>
          <mi>&#x03C0;</mi>
          <mn>3</mn>
        </mfrac>
      </mrow>
    </msub>
    <mo>=</mo>
    <mi>cos</mi>
    <mfrac>
      <mi>&#x03C0;</mi>
      <mn>3</mn>
    </mfrac>
    <mo>=</mo>
    <mfrac>
      <mn>1</mn>
      <mn>2</mn>
    </mfrac>
  </mrow>
</math>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/generate.sh
================================================
#  Copyright John Maddock 2008.
#  Use, modification and distribution are subject to the
#  Boost Software License, Version 1.0. (See accompanying file
#  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#
# Generates SVG and PNG files from the MML masters.
#
# Paths to tools come first, change these to match your system:
#
math2svg='m:\download\open\SVGMath-0.3.1\math2svg.py'
python=/cygdrive/c/Python26/python.exe
inkscape=/cygdrive/c/progra~1/Inkscape/inkscape
# Image DPI:
dpi=120

for mmlfile in $*; do
	svgfile=$(basename $mmlfile .mml).svg
	pngfile=$(basename $svgfile .svg).png
	tempfile=temp.mml
	# strip html wrappers put in by MathCast:
	cat $mmlfile | tr -d "\r\n" | sed -e 's/.*\(<math[^>]*>.*<\/math>\).*/\1/' > $tempfile
	
	echo Generating $svgfile
	$python $math2svg $tempfile > $svgfile
	echo Generating $pngfile
	$inkscape -d $dpi -e $(cygpath -a -w $pngfile) $(cygpath -a -w $svgfile)
	rm $tempfile
done







================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/history.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:map Roadmap]

[section:hist History]

[h4 Multiprecision-4.1.2 (Boost-1.81)]

* Correct thread-safe static initialization of constants for __cpp_bin_float, see [@https://github.com/boostorg/multiprecision/issues/497 497].
* Correct __cpp_int `import_bits` when just importing the leading few bits of the value, see [@https://github.com/boostorg/multiprecision/issues/488 488].
* Remove some C++03 idioms, including use of `0` rather than `nullptr`.
* Minor fixes for gcc-12 on Mingw.

[h4 Multiprecision-4.1.1 (Boost-1.80)]

* [*Mark C++11 support as deprecated]: from 2023 we will move to requiring C++14 as a minimum standard level.  That will drop support for
GCC versions prior to 5 and MSVC prior to 14.1.
* Fix conflict between `boost/cstdfloat.hpp` and this library.
* Clean up lots of gcc and clang warnings.
* Fix input streaming of composite types (complex, interval rational) where there is a trailing delimeter in the stream and no whitespace.
* Fix `constexpr` integer square root where the input is 1, 2 or 3.
* Add missing `#include` of `<memory>` to float128.hpp.
* Correct 2-arg constructor for class `number` to prevent ambiguity in some cases.
* Correct and make more consistent behaviour of divide-by-zero in gmp.hpp.


[h4 Multiprecision-4.1.0 (Boost-1.79)]

* Big update to support use of this library "standalone": ie without the rest of Boost.  A copy
of Boost.Config is still required, and use of Boost.Math to provide the C99 special functions is optional.
* Fix IO of floating point numbers when `std::ios_base::fixed` is in effect and the precision is zero.
* Fix various spurious GCC warnings in cpp_int bitwise operators.
* Use `float128_type` typedef throughout to suppress GCC/clang warnings about using a non-standard extension.
* Correct conversion of Intel's _Quad type to string, see [@https://github.com/boostorg/multiprecision/issues/427 #427].
* Correct usage of Intel intrinsics on GCC to avoid simply checking for the header, see [@https://github.com/boostorg/multiprecision/issues/419 #419].
* Update `signbit` to match `std::signbit` and to return the correct sign when the result is zero, [@https://github.com/boostorg/multiprecision/issues/426 #426].
* Fix over-large reductions in default sin/cos code.
* Fix some mpq rational arithmetic errors: Multiplication by zero should not proceed via gcd, and multiplication by scalar should be restricted to integer types (not floats).
* Support conversion to and from `__int128` and `__float128` everywhere, not just on an add-hock basis, [@https://github.com/boostorg/multiprecision/issues/237 #237].
* Avoid unnecessary copying in cpp_int's add_unsigned, [@https://github.com/boostorg/multiprecision/issues/357 #357].
* Change all bit counts to use `std::size_t` or `std::ptrdiff_t`, [@https://github.com/boostorg/multiprecision/issues/362 #362].
* Bring Eigen traits classes up to date and add tests.
* Fix `is_byte_container` to correctly handle Eigen types, [@https://github.com/boostorg/multiprecision/issues/398 #398].
* Improve cpp_int to float conversion to be insensitive to floating point control flags, [@https://github.com/boostorg/multiprecision/issues/360 #360].
* Correct interop between signed-zeros and complex number types, [@https://github.com/boostorg/multiprecision/issues/396 #396].


[h4 Multiprecision-4.0.2 (Boost-1.78)]

* Rework rational_adaptor to remove dependency on Boost.Rational and improve performance.
* Fix issue with type_traits and clang, see [@https://github.com/boostorg/multiprecision/issues/383 #383].
* Fixed buggy Lehmer's GCD routine, see [@https://github.com/boostorg/multiprecision/issues/370 #370].
* Fix mpc_complex constructors so that lossy conversions are explicit, see [@https://github.com/boostorg/multiprecision/issues/363 #363].
* Correct miscellaneous configuration issues (Intel intrinsic usage and Apple clang).
* Correct some iostream operators for unsigned char types.
* Correct mpq_rational conversions to integer types, see [@https://github.com/boostorg/multiprecision/issues/342 #342].

[h4 Multiprecision-4.0.1 (Boost-1.77)]

* Much improved Karatsuba sqrt for cpp_int/cpp_bin_float.
* Added C++11 compatible `to_string` free function.
* Fixed bug in Lehmer GCD code, see [@https://github.com/boostorg/multiprecision/issues/322 #322]. 
* Fixed debug_adaptor/logged_adaptor to work better with complex, rational and interval types, see [@https://github.com/boostorg/multiprecision/issues/329 #329].
* Big update to mixed-variable precision arithmetic code with better options and thread safety, see [link boost_multiprecision.tut.variable docs].
* Fixed up hashing of bools and enums when creating hash values.
* Improved conversions to and from enum types.
* Restricted use of Intel intrinsics to when we really are building for Intel even though the header may be available, see [@https://github.com/boostorg/multiprecision/issues/321 #321].
* Tidied up Lanczos approximation usage, in conjunction with Boost.Math this improves the reliability and accuracy of many special functions.
* Fix use of libtommath deprecated features.
* Fixed missing sqrt overload, see [@https://github.com/boostorg/multiprecision/issues/319 #319].
* Added Karatsuba multiplication to cpp_dec_float to bring it into line with the other types in this library.
* Added some minor optimizations to mpfr comparison operators.


[h4 Multiprecision-4.0.0 (Boost-1.76)]

* [*BREAKING CHANGE]: Massive refactoring and code simpification makes C++11 an absolute requirement.
* Use BOOST_TRY/CATCH in headers so code can be use din s=exception-free environments.
* Correct corner case in pow, fixes [@https://github.com/boostorg/multiprecision/issues/277 #277]. 
* Correct exception type thrown to match docs in lsb/msb: fixes [@https://github.com/boostorg/multiprecision/issues/257 #257].
* Allow moves and operators between related but different types (ie types with the same allocator), fixes [@https://github.com/boostorg/multiprecision/issues/278 #278].

[h4 Multiprecision-3.2.5 (Boost-1.75)]

* Much improved gcd and modulus operations for __cpp_int.
* Improved addition/subtraction routines for __cpp_int via Intel's intrinsics.
* __gmp_int: add better conversion routines for `long long` and `__int128`.
* __mpfr_float_backend: Fix `log1p` corner case.
* Improve accuracy of complex tan/tanh.
* Improve accuracy of trig functions for __cpp_bin_float.

[h4 Multiprecision-3.2.4 (Boost-1.73)]

* IMPORTANT: Mark C++03 support as deprecated and due for removal in 2021.
* Big update to __cpp_int adds faster Karatsuba and Coomba multiplication routines.
* Fix conversion of __gmp_rational to `long double` and `__float128`, fixes [@https://github.com/boostorg/multiprecision/issues/178 #178].
* Fix up libtommath support to function with the latest libtom releases.
* Fix up some incompatibilities with the latest Intel C++ compiler.
* Fix up `constexpr` arithmetic support for forthcoming MSVC release.

[h4 Multiprecision-3.2.3 (Boost-1.72)]

* Big `constexpr` update allows __cpp_int and __float128__ arithmetic to be fully `constexpr` with gcc and clang 9 or later,
or any compiler supporting `std::is_constant_evaluated()`.

[h4 Multiprecision-3.1.3 (Boost-1.71)]

* Support hexfloat io-formatting for float128.
* Fix various bugs in variable precision interconversions.
* Respect uppercase for '0x' prefix outputs.
* Incorporate some unit tests from the Etherium project.
* Fix some gcc warnings.

[h4 Multiprecision-3.1.2 (Boost-1.70)]

* Fix various conversion issues in the traits classes, check for compatibility with Boost.Optional.
* Prevent instantiation of `std::numeric_limits` on any old type when checking for convertibility.  See [@https://github.com/boostorg/multiprecision/issues/98 #98].
* Update variable precision code to accound for arbitrary precision integers.  See [@https://github.com/boostorg/multiprecision/issues/103 #103].
* Add support for XML serialization archives.
* Fix bug in fixed precision iostream formatting in `mpf_float` and `mpfr_float`.  See [@https://github.com/boostorg/multiprecision/issues/113 #113].
* Add more overloads for special functions which are better handled natively by MPFR.
* Fixed bug in generic `exp` implementation which could cause invariant failure.
* Fixed generic conversion from float to integer to avoid undefined behaviour.  See [@https://github.com/boostorg/multiprecision/issues/110 #110].

[h4 Multiprecision-3.1.1 (Boost-1.69)]

* Big update to better support variable precision types so that the precision of the result
is always the largest of all the arguments.
* Add support for allocators that are `final` in __cpp_int.
* Removed use of deprecated Boost.Endian in favour of Predef.
* Add support for `std::string_view`.
* Fixed minor bug in constant initialization.  See [@https://github.com/boostorg/multiprecision/issues/67 #67].
* Make assignment of non-finite value to `cpp_int` a runtime errors.  See [@https://github.com/boostorg/multiprecision/issues/58 #58].
* Added typedefs for `cpp_bin_float_oct` and `cpp_complex_oct`.

[h4 Multiprecision-3.1.0 (Boost-1.68)]

* Support added for complex multiprecision numbers.
* Changed conversion to unsigned integer types to be truncating to match standard defined behaviour.
* Correct bug in MPFR string formatting.
* Fix undefined behaviour in cpp_dec_float conversion from long long.
* Add support for Eigen interoperability.
* float128.hpp: Fix Intel on Windows build.
* Fix type used in temporaries when expanding expression templates containing mixed expressions.
* Fix infinite loop in gmp_float to fixed-point string conversion.
* Update the expression templates to issue static_asserts with better error messages when you try and do something unsupported.
* Fix bug in cpp_int where incrementing to zero doesn't set the sign correctly.
* Remove erroneous use of std::move, and rely on NVRO instead.
* Fix up support for changes to MPIR-3.0.
* Fix various conversion errors in cpp_bin_float when the exponent type is a `long long`, or else we're converting to
an integer that is wider than we are.
* Fix compatibility issue with GCC-8 caused by the introduction of `std::byte`.

[h4 Multiprecision-3.0.0 (Boost-1.67)]

* [*Breaking Change:] When converting a multiprecision integer to a narrower type, if the value is too large (or negative) to
fit in the smaller type, then the result is either the maximum (or minimum) value of the target type.  This was always the intended
behaviour, but was somewhat haphazardly enforced before.  If you really do want just the low order N bits of a value, then you will
need to mask these out prior to the case, for example: `static_cast<unsigned>(~static_cast<unsigned>(0) & my_value)`.  Note that
technically (to avoid undefined behaviour) you should do the same thing with __fundamental integer types too.
See [@https://svn.boost.org/trac/boost/ticket/13109 #13109].
* Fix bug in conversion of decimal to rational types (zero needs special handling), see [@https://svn.boost.org/trac/boost/ticket/13148 #13148].
* Fix conversion from cpp_bin_float to a wider __fundamental integer type, see [@https://svn.boost.org/trac/boost/ticket/13301 #13301].
* Improve performance heurists used in cpp_bin_float exp function.
* Fix bug in floor/ceil and cpp_bin_float when the exponent type is wider than an int, see [@https://svn.boost.org/trac/boost/ticket/13264 #13264].
* Disable explicit conversion operator when the target type is already constructible from this type, see  [@https://github.com/boostorg/multiprecision/issues/30 #30].
* Fix support for changes new to MPIR-3.0, see [@https://svn.boost.org/trac/boost/ticket/13124 #13124].

[h4 Multiprecision-2.3.2 (Boost-1.65)]

* Updated expression templates to store arithmetic literals directly in the expression template to prevent dangling references, see [@https://github.com/boostorg/multiprecision/issues/19 #19].
* Fix various issues with huge values and overflow in the trig, pow and exp functions, see [@https://github.com/boostorg/multiprecision/issues/24 #24].
* Fix error handling of checked cpp_int multiply that could cause some overflows to be missed.

[h4 Multiprecision-2.3.1 (Boost-1.64)]

* In `cpp_bin_float` prevent double rounding when converting to a denormalized float.  See [@https://svn.boost.org/trac/boost/ticket/12527 #12527].
* Fix bug in integer sqrt for very small integers.  See [@https://svn.boost.org/trac/boost/ticket/12559 #12559].
* Fix conversion to signed-zero in `cpp_bin_float`.
* Change `cpp_bin_float` rounding code to round at arbitrary location so we can use it for conversions, see [@https://svn.boost.org/trac/boost/ticket/12527 #12527].
* Improve performance of 128-bit bit-scan operations.
* Fix subtraction of very small quantities in `cpp_bin_float`.  See: [@https://svn.boost.org/trac/boost/ticket/12580 #12580].
* Bring error handling into line with C99 Annex F.  See [@https://svn.boost.org/trac/boost/ticket/12581 #12581].
* Fix bitwise export of trivial `cpp_int`'s, see [@https://svn.boost.org/trac/boost/ticket/12627 #12627].
* Fix `ilogb` (and code that uses it) to consistently return the smallest value of the exponent type when the argument is zero, see [@https://svn.boost.org/trac/boost/ticket/12625 #12625].
* Allow conversion from `__float128__` to `cpp_bin_float`.
* Fix bug in left shift of `cpp_int` which would result in bit-loss, see [@https://svn.boost.org/trac/boost/ticket/12790 #12790].
* Fixed bugs in bounded but variable precision `cpp_int`'s caused by over-aggressive constexpr optimization, see [@https://svn.boost.org/trac/boost/ticket/12798 #12798].


[h4 Multiprecision-2.3.0 (Boost-1.63)]

* Added support for all the C99 math functions.
* Extended generic-interconversions to handle narrowing cases as well, changed convert_to member function and hence explicit
conversion operators to use the same conversion code as the explicit constructors.
* Fix IO stream parsing error, see [@https://svn.boost.org/trac/boost/ticket/12488 #12488].
* Make default constructed floating point types all zero for consistency, see [@https://svn.boost.org/trac/boost/ticket/12500 #12500].
* Fix conversion of cpp_bin_float to float/double/long double when the exponent value would overflow an int, see [@https://svn.boost.org/trac/boost/ticket/12512 #12512].
* Fix cpp_bin_float subtractions that yield signed-zeros, see [@https://svn.boost.org/trac/boost/ticket/12524 #12524].
* Fix ceil/trunc/round applied to cpp_bin_float and yielding a signed zero, see [@https://svn.boost.org/trac/boost/ticket/12525 #12525].

[h4 Multiprecision-2.2.8 (Boost-1.62)]

* Added support for hashing via `Boost.Hash` or `std::hash`.
* Fixed some arithmetic operations in cpp_bin_float and cpp_dec_float that should generate a NaN, see [@https://svn.boost.org/trac/boost/ticket/12157 #12157].
* Prevent inadvertant instantiation of variable-precision `mpfr_float_backend` with fixed allocation.
* Fixed division over/underflow in cpp_bin_float, see [@https://svn.boost.org/trac/boost/ticket/12167 #12167].
* Added support for signed-zeros throughout the library, including support for `signbit` and `copysign`, mpfr, float128, and cpp_bin_float types
should now respect signed-zeros correctly.
* Fixed bug in conversion of cpp_bin_float infinities to double etc, see [@https://svn.boost.org/trac/boost/ticket/12196 #12196].
* Fix add and subtract of cpp_bin_float when the exponents would overflow., see [@https://svn.boost.org/trac/boost/ticket/12198 #12198].
* Improve variable-precision support in mpfr and mpf backends, allow these types to be used with Boost.Math.
* Fixed bug in subtraction of signed infinities in cpp_bin_float, see [@https://svn.boost.org/trac/boost/ticket/12209 #12209].
* Fix result of sqrt(infinity) in cpp_bin_float (result should be infinity), see [@https://svn.boost.org/trac/boost/ticket/12227 #12227].
* Added workaround in gmp.hpp for recent MPIR releases which are not quite source-compatible with GMP on Windows x64.
* Allow `cpp_int` code to be used with /RTCc with MSVC.
* Fix conversion of `cpp_int` to signed integer when the result is INT_MIN, see [@https://svn.boost.org/trac/boost/ticket/12343 #12343].
* Update uBlas support to match latest uBlas code.
* Fix some errors present when building on big-endian machines (not all `cpp_int` constructors are available on non-little-endian machines).
* Fix fencepost error in rational to float conversion routines, see [@https://svn.boost.org/trac/boost/ticket/12327 #12327].
* Fix some Oracle C++ compiler compatibility issues.
* Add modf support to complete C90 compatibility.
* Fix self assignment bug in expression template code for expressions such as `a = a * a * a`, see [@https://svn.boost.org/trac/boost/ticket/12408 #12408].
* Fixed some compiler errors that occur when converting from `cpp_int` to `cpp_bin_float`.

[h4 Multiprecision-2.2.7 (Boost-1.61)]

* Fixed bug in stream input for integer types, see [@https://svn.boost.org/trac/boost/ticket/11857 #11857].
* Fixed some ambiguous conversions involving expression templates see [@https://svn.boost.org/trac/boost/ticket/11922 #11922].
* Add expression template aware min/max overloads see [@https://svn.boost.org/trac/boost/ticket/11149 #11149].
* Fix bug in right shifting negative small integers in cpp_int see [@https://svn.boost.org/trac/boost/ticket/11999 #11999].
* Use memmove for bitshifts in cpp_int when possible see [@https://svn.boost.org/trac/boost/ticket/9233 #9233].
* Use memcpy for data import into cpp_int where possible, see [@https://svn.boost.org/trac/boost/ticket/9235 #9235].
* Changed `cpp_bin_float.convert_to<double>()` to a function template rather than proceding via `long double` to avoid
double-rounding bug, see [@https://svn.boost.org/trac/boost/ticket/12039 #12039].
* Fixed conversions from NaNs and Infinities, see [@https://svn.boost.org/trac/boost/ticket/12112 #12112].
* Enabled better support for Clang on Windows.
* Fixed handling of NaNs and Infinities in basic arithmetic for cpp_dec_float and cpp_bin_float, see [@https://svn.boost.org/trac/boost/ticket/12090 #12090].
* Fixed fencepost error in cpp_bin_float subtraction.
* Fixed double-rounding in conversion to float routines for cpp_bin_float, see [@https://svn.boost.org/trac/boost/ticket/12039 #12039].
* Make float128 denorm aware, see [@https://svn.boost.org/trac/boost/ticket/12075 #12075].
* Allow the library and tests to be used without exception handling support, see [@https://svn.boost.org/trac/boost/ticket/12070 #12070].
* Fixed buggy comparison operator overloads for boost::rational.
* Added some workarounds for Oracle C++.
* Fixed some missing typecasts for cases where cpp_int's limb_type is wider than unsigned.


[h4 Multiprecision-2.2.6 (Boost-1.60)]

* Fixed result of Miller Rabin primality test for value 2, see [@https://svn.boost.org/trac/boost/ticket/11495 #11495].
* Improved initialization of cpp_int from very large strings of hex or octal digits, see [@https://svn.boost.org/trac/boost/ticket/11590 #11590].
* Fixed fmod behaviour for negative divisors, see [@https://svn.boost.org/trac/boost/ticket/11641 #11641].
* Fixed infinite division loop in cpp_int special case, see [@https://svn.boost.org/trac/boost/ticket/11648 #11648].
* Patched missing return statement in [@https://svn.boost.org/trac/boost/ticket/11762 #11762].
* Fixed mixed mode arithmetic compiler error in [@https://svn.boost.org/trac/boost/ticket/11764 #11764].
* Fixed over-aggressive use of noexcept in [@https://svn.boost.org/trac/boost/ticket/11826 #11826].


[h4 Multiprecision-2.2.5 (Boost-1.59)]

* Depricated boost/multiprecision/random.hpp as it's no longer needed, updated random examples to match.
* Fixed a bug in `cpp_int` right shift operator when shifting negative values - semantics now gives the
same values as shifting 2's compliment integers, though not the same bit pattern.
* Fixed support for GCC-4.6.4 in C++0x mode by disabling conditional noexcept suppoprt for that compiler
see [@https://svn.boost.org/trac/boost/ticket/11402 #11402].
* Suppressed numerous compiler warnings.

[h4 Multiprecision-2.2.4 (Boost-1.58)]

* Changed `frexp` to always be non-expression template generating, see: [@https://svn.boost.org/trac/boost/ticket/10993 10993].
* Improved support of cpp_dec_float on Cygwin and other platforms with missing long double support, see [@https://svn.boost.org/trac/boost/ticket/10924 10924].
* Improved noexcept support and added some more tests, see [@https://svn.boost.org/trac/boost/ticket/10990 10990].
* Various workarounds applied for Intel-15.0 and Solaris-12.4 compilers.

[h4 Multiprecision-2.2.3 (Boost-1.57)]

* Changed rational to float conversions to exactly round to nearest, see [@https://svn.boost.org/trac/boost/ticket/10085 10085].
* Added improved generic float to rational conversions.
* Fixed rare bug in exponent function for __cpp_bin_float.
* Fixed various minor documentation issues.

[h4 Multiprecision-2.2.2 (Boost-1.56)]

* Change floating-point to rational conversions to be implicit, see [@https://svn.boost.org/trac/boost/ticket/10082 10082].
* Fix definition of checked_cpp_rational typedef.

[h4 Multiprecision-2.2.1]

* Fix bug in assignment from string in cpp_int, see [@https://svn.boost.org/trac/boost/ticket/9936 9936].

[h4 Multiprecision-2.2.0]

* Moved to Boost.Multiprecision specific version number - we have one breaking change in Boost-1.54
which makes this major version 2, plus two releases with new features since then.
* Added new __cpp_bin_float backend for binary floating-point.
* Added MSVC-specific #include for compiler intrinsics, see [@https://svn.boost.org/trac/boost/ticket/9336 9336].
* Fixed various typos in docs, see [@https://svn.boost.org/trac/boost/ticket/9432 9432].
* Fixed __gmp_rational to allow move-copy from an already copied-from object, see [@https://svn.boost.org/trac/boost/ticket/9497 9497].
* Added list of values for numeric_limits.

[h4 Boost-1.55]

* Added support for Boost.Serialization.
* Suppressed some GCC warnings.  See [@https://svn.boost.org/trac/boost/ticket/8872 8872].
* Fixed bug in pow for large integer arguments.  See [@https://svn.boost.org/trac/boost/ticket/8809 8809].
* Fixed bug in pow for calculation of 0[super N].  See [@https://svn.boost.org/trac/boost/ticket/8798 8798].
* Fixed bug in fixed precision cpp_int IO code that causes conversion to string to fail when the
bit count is very small (less than CHAR_BIT).  See [@https://svn.boost.org/trac/boost/ticket/8745 8745].
* Fixed bug in cpp_int that causes left shift to fail when a fixed precision type would overflow.
See [@https://svn.boost.org/trac/boost/ticket/8741 8741].
* Fixed some cosmetic warnings from cpp_int.  See [@https://svn.boost.org/trac/boost/ticket/8748 8748].
* Fixed calls to functions which are required to be macros in C99.  See [@https://svn.boost.org/trac/boost/ticket/8732 8732].
* Fixed bug that causes construction from INT_MIN, LONG_MIN etc to fail in cpp_int.  See [@https://svn.boost.org/trac/boost/ticket/8711 8711].

[h4 1.54]

* [*Breaking change] renamed `rational_adapter` to `rational_adaptor`.
* Add support for [mpfi].
* Add logged_adaptor.
* Add support for 128-bit floats via GCC's `__float128` or Intel's `_Quad` data types.
* Add support for user-defined literals in cpp_int, improve `constexpr` support.
* Fixed bug in integer division of `cpp_int` that results in incorrect sign of `cpp_int` when both arguments are small enough
to fit in a `double_limb_type`.  See [@https://svn.boost.org/trac/boost/ticket/8126 8126].
* Fixed bug in subtraction of a single limb in `cpp_int` that results in incorrect value when the result should have a 0
in the last limb: [@https://svn.boost.org/trac/boost/ticket/8133 8133].
* Fixed bug in `cpp_int` where division of 0 by something doesn't get zero in the result: [@https://svn.boost.org/trac/boost/ticket/8160 8160].
* Fixed bug in some transcendental functions that caused incorrect return values when variables are reused, for example with
`a = pow(a, b)`.  See [@https://svn.boost.org/trac/boost/ticket/8326 8326].
* Fixed some assignment operations in the mpfr and gmp backends to be safe if the target has been moved from: [@https://svn.boost.org/trac/boost/ticket/8326 8667].
* Fixed bug in `cpp_int` that gives incorrect answer for 0%N for large N: [@https://svn.boost.org/trac/boost/ticket/8670 8670].
* Fixed set_precision in mpfr backend so it doesn't trample over an existing value: [@https://svn.boost.org/trac/boost/ticket/8692 8692].

[h4 1.53]

* First Release.
* Fix bug in [@https://svn.boost.org/trac/boost/ticket/7878 cpp_int division].
* Fix issue [@https://svn.boost.org/trac/boost/ticket/7806 #7806].

[h4 Post review changes]

* Non-expression template operators further optimised with rvalue reference support.
* Many functions made `constexp`.
* Differentiate between explicit and implicit conversions in the number constructor.
* Removed "mp_" prefix from types.
* Allowed mixed precision arithmetic.
* Changed ExpressionTemplates parameter to class `number` to use enumerated values rather than true/false.
* Changed ExpressionTemplate parameter default value to use a traits class so that the default value depends on the backend used.
* Added support for fused-multiply-add/subtract with GMP support.
* Tweaked expression template unpacking to use fewer temporaries when the LHS also appears in the RHS.
* Refactored `cpp_int_backend` based on review comments with new template parameter structure.
* Added additional template parameter to `mpfr_float_backend` to allow stack-based allocation.
* Added section on mixed precision arithmetic, and added support for operations yielding a higher precision result
than either of the arguments.
* Added overloads of integer-specific functions for __fundamental integer types.

[h4 Pre-review history]

*2011-2012, John Maddock adds an expression template enabled front-end to Christopher's code,
and adds support for other backends.
* 2011, Christopher Kormanyos publishes the decimal floating-point code under the Boost
Software Licence.  The code is published as: [@http://doi.acm.org/10.1145/1916461.1916469
"Algorithm 910: A Portable C++ Multiple-Precision
System for Special-Function Calculations"], in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM,
2011.
* 2002-2011, Christopher Kormanyos develops the all C++ decimal arithmetic floating-point code.

[endsect] [/section:hist History]


[section:todo TODO]

More a list of what ['could] be done, rather than what ['should] be done (which may be a much smaller list!).

* Add back-end support for libdecNumber.
* Add an adaptor back-end for complex number types.
* Add better multiplication routines (Karatsuba, FFT etc) to cpp_int_backend.
* Add assembly level routines to cpp_int_backend.
* Can ring types (exact floating-point types) be supported?  The answer should be yes, but someone needs to write it,
the hard part is IO and binary-decimal conversion.
* Should there be a choice of rounding mode (probably MPFR specific)?
* We can reuse temporaries in multiple subtrees (temporary caching).
* cpp_dec_float should round to nearest.
* A 2's complement fixed precision int that uses exactly N bits and no more.

Things requested in review:

* The performances of mp_number<a_trivial_adaptor<float>, false>respect to
float and mp_number<a_trivial_adaptor<int>, false> and int should be
given to show the cost of using the generic interface (Mostly done, just need to update docs to the latest results).
* Should we provide min/max overloads for expression templates?  (Not done - we can't overload functions declared in the std namespace :-( ).
* The rounding applied when converting must be documented (Done).
* Document why we don't abstract out addition/multiplication algorithms etc. (done - FAQ)
* Document why we don't use proto (compile times)  (Done).
* We can reuse temporaries in multiple subtrees (temporary caching)  Moved to TODO list.
* Emphasise in the docs that ET's may reorder operations (done 2012/10/31).
* Document what happens to small fixed precision cpp_int's (done 2012/10/31).
* The use of bool in template parameters could be improved by the use of
an enum class which will be more explicit. E.g `enum class expression_template {disabled, enabled};
enum class sign {unsigned, signed};`  (Partly done 2012/09/15, done 2012/10/31).
* Each back-end should document the requirements it satisfies (not currently scheduled for inclusion: it's
deliberately an implementation detail, and "optional" requirements are optimisations which can't be detected
by the user).  Not done: this is an implementation detail, the exact list of requirements satisfied is purely
an optimization, not something the user can detect.
* A backend for an overflow aware integers (done 2012/10/31).
* IIUC convert_to is used to emulate in c++98 compilers C++11 explicit
conversions. Could the explicit conversion operator be added on
compilers supporting it?  (Done 2012/09/15).
* The front-end should make the differences between implicit and explicit
construction (Done 2012/09/15).
* The tutorial should add more examples concerning implicit or explicit
conversions. (Done 2012/09/15).
* The documentation must explain how move semantics helps in this domain
and what the backend needs to do to profit from this optimization. (Done 2012/09/15).
* The documentation should contain Throws specification on the mp_number
and backend requirements operations. (Done 2012/09/15).
* The library interface should use the noexcept (noexcept, ...)
facilities (Done 2012/09/15).
* It is unfortunate that the generic mp_number front end can not make use
constexpr as not all the backends can ensure this (done - we can go quite a way).
* literals: The library doesn't provide some kind of literals. I think that the
mp_number class should provide a way to create literals if the backend
is able to.  (Done 2012/09/15).
* The ExpresionTemplate parameter could be defaulted to a traits class for more sensible defaults (done 2012/09/20).
* In a = exp1 op exp2 where a occurs inside one of exp1 or exp2 then we can optimise and eliminate one more temporary (done 2012/09/20).


[h4 Pre-Review Comments]

* Make fixed precision orthogonal to Allocator type in cpp_int.  Possible solution - add an additional MaxBits
template argument that defaults to 0 (meaning keep going till no more space/memory).  Done.
* Can ring types (exact floating-point types) be supported?  The answer should be yes, but someone needs to write it (Moved to TODO list).
* Should there be a choice of rounding mode (probably MPFR specific)?  Moved to TODO list.
* Make the exponent type for cpp_dec_float a template parameter, maybe include support for big-integer exponents.
Open question - what should be the default - int32_t or int64_t?  (done 2012/09/06)
* Document the size requirements of fixed precision ints (done 2012/09/15).
* Document std lib function accuracy (done 2012/09/15).
* Be a bit clearer on the effects of sign-magnitude representation of cpp_int - min == -max etc - done.
* Document cpp_dec_float precision, rounding, and exponent size (done 2012/09/06).
* Can we be clearer in the docs that mixed arithmetic doesn't work (no longer applicable as of 2012/09/06)?
* Document round functions behaviour better (they behave as in C++11) (added note 2012/09/06).
* Document limits on size of cpp_dec_float (done 2012/09/06).
* Add support for fused multiply add (and subtract).  GMP mpz_t could use this (done 2012/09/20).

[endsect] [/section:todo TODO]

[section:faq FAQ]

[variablelist
[[Why do I get compiler errors when passing a `number` to a template function?]
   [Most likely you are actually passing an expression template type to the function and
   template-argument-deduction deduces the "wrong" type.  Try casting the arguments
   involving expressions to the actual number type, or as a last resort turning off
   expression template support in the number type you are using.]]
[[When is expression template support a performance gain?]
   [As a general rule, expression template support adds a small runtime overhead
   creating and unpacking the expression templates, but greatly reduces the number of
   temporaries created.  So it's most effective in improving performance when the cost
   of creating a temporary is high: for example when creating a temporary involves a memory
   allocation.  It is least effective (and may even be a dis-optimisation) when temporaries
   are cheap: for example if the number type is basically a thin wrapper around a native
   arithmetic type.  In addition, since the library makes extensive use of thin inline wrapper
   functions, turning on compiler optimization is essential to achieving high performance.]]
[[Do expression templates reorder operations?]
   [Yes they do, sometimes quite radically so, if this is a concern then they should be turned
   off for the number type you are using.]]
[[I can't construct my number type from ['some other type], but the docs indicate that the conversion should be allowed, what's up?]
   [Some conversions are ['explicit], that includes construction from a string, or constructing from any type
   that may result in loss of precision (for example constructing an integer type from a float).]]
[[Why do I get an exception thrown (or the program crash due to an uncaught exception) when using the bitwise operators on a checked `cpp_int`?]
   [Bitwise operations on negative values (or indeed any signed integer type) are unspecified by the standard.  As a result
   any attempt to carry out a bitwise operation on a negative checked-integer will result in a `std::range_error` being thrown.]]
[[Why do I get compiler errors when trying to use the complement operator?]
   [Use of the complement operator on signed types is problematic as the result is unspecified by the standard, and is further
   complicated by the fact that most extended precision integer types use a sign-magnitude representation rather than the 2's
   complement one favored by most native integer types.  As a result the complement operator is deliberately disabled for
   checked `cpp_int`'s.  Unchecked `cpp_int`'s give the same valued result as a 2's complement type would, but not the same bit-pattern.]]
[[Why can't I negate an unsigned type?]
   [The unary negation operator is deliberately disabled for unsigned integer types as its use would almost always be a programming error.]]
[[Why doesn't the library use proto?]
   [A very early version of the library did use proto, but compile times became too slow
   for the library to be usable.  Since the library only required a tiny fraction of what
   proto has to offer anyway, a lightweight expression template mechanism was used instead.
   Compile times are still too slow...]]
[[Why not abstract out addition/multiplication algorithms?]
   [This was deemed not to be practical: these algorithms are intimately
   tied to the actual data representation used.]]
 [[How do I choose between Boost.Multiprecision `cpp_bin_50` and `cpp_dec_50`?]
   [Unless you have a specific reason to choose `cpp_dec_`, then the default choice should be `cpp_bin_`, 
   for example using the convenience `typedefs` like `boost::multiprecision::cpp_bin_50` or `boost::multiprecision::cpp_bin_100`.

  In general, both work well and give the same results and at roughly the same speed with `cpp_dec_50` sometimes faster.

  `cpp_dec_` was developed first paving the way for `cpp_bin_`. 
  `cpp_dec_` has several guard digits and is not rounded at all, using 'brute force' to get the promised number of decimal digits correct,
  but making it difficult to reason about precision and computational uncertainty, for example see [*https://svn.boost.org/trac10/ticket/12133].
  It also has a fast but imprecise division operator giving surprising results sometimes, see [*https://svn.boost.org/trac10/ticket/11178].

  `cpp_bin_` is correctly/exactly rounded making it possible to reason about both the precision and rounding of the results.]]
] [/variablelist]

[endsect] [/section:faq FAQ]

[section:ack Acknowledgements]

This library would not have happened without:

* Christopher Kormanyos' C++ decimal number code.
* Paul Bristow for patiently testing, and commenting on the library.
* All the folks at GMP, MPFR and libtommath, for providing the "guts" that makes this library work.
* [@http://www-cs-faculty.stanford.edu/~uno/taocp.html "The Art Of Computer Programming"],
Donald E. Knuth, Volume 2: Seminumerical Algorithms, Third Edition
(Reading, Massachusetts: Addison-Wesley, 1997), xiv+762pp. ISBN 0-201-89684-2

[endsect] [/section:ack Acknowledgements]


[endsect] [/section: Roadmap]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/indexes/s01.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Function Index</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../indexes.html" title="Indexes">
<link rel="prev" href="../indexes.html" title="Indexes">
<link rel="next" href="s02.html" title="Class Index">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../indexes.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s02.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="id1236991"></a>Function Index</h3></div></div></div>
<p><a class="link" href="s01.html#idx_id_0">A</a> <a class="link" href="s01.html#idx_id_1">B</a> <a class="link" href="s01.html#idx_id_2">C</a> <a class="link" href="s01.html#idx_id_3">D</a> <a class="link" href="s01.html#idx_id_4">E</a> <a class="link" href="s01.html#idx_id_5">F</a> <a class="link" href="s01.html#idx_id_6">G</a> <a class="link" href="s01.html#idx_id_7">H</a> <a class="link" href="s01.html#idx_id_8">I</a> <a class="link" href="s01.html#idx_id_9">L</a> <a class="link" href="s01.html#idx_id_10">M</a> <a class="link" href="s01.html#idx_id_11">N</a> <a class="link" href="s01.html#idx_id_12">O</a> <a class="link" href="s01.html#idx_id_13">P</a> <a class="link" href="s01.html#idx_id_14">R</a> <a class="link" href="s01.html#idx_id_15">S</a> <a class="link" href="s01.html#idx_id_16">T</a> <a class="link" href="s01.html#idx_id_17">V</a> <a class="link" href="s01.html#idx_id_18">X</a> <a class="link" href="s01.html#idx_id_19">Z</a></p>
<div class="variablelist"><dl class="variablelist">
<dt>
<a name="idx_id_0"></a><span class="term">A</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">a</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">abs</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">acosh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">arg</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">asinh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">assign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">assign_components</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">atanh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_1"></a><span class="term">B</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bits</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/input_output.html" title="Input Output"><span class="index-entry-level-1">Input Output</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rounding.html" title="Rounding Rules for Conversions"><span class="index-entry-level-1">Rounding Rules for Conversions</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_flip</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_set</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_unset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_2"></a><span class="term">C</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cbrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ceil</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">changesign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">compare</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">conj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">convert_to</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">copysign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/gi.html" title="Calculating an Integral"><span class="index-entry-level-1">Calculating an Integral</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_bin_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_dec_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_3"></a><span class="term">D</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">data</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">gmp_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">gmp_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/lits.html" title="Literal Types and constexpr Support"><span class="index-entry-level-1">Literal Types and constexpr Support</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">default_precision</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">denominator</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">cpp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">digits10</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">divide_qr</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_4"></a><span class="term">E</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">e</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">empty</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">erf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">erfc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_acos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_asin</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_atan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_atan2</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_and</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_or</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_xor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_flip</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_set</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_unset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_ceil</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_complement</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_conj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_convert_to</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_cos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_cosh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_decrement</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_divide</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_eq</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_exp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_exp2</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_fabs</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_floor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_fmod</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_frexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_gcd</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_get_sign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_gt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_increment</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_integer_sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_is_zero</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_lcm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_ldexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_left_shift</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_log</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_log10</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_lt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_modf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_modulus</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_msb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply_add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply_subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_nearbyint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_pow</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_powm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_proj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_qr</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_right_shift</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_round</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_scalbn</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_set_imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_set_real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sin</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sinh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_tan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_tanh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_trunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">exp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expm1</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">export_bits</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expression</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_5"></a><span class="term">F</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">f</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">floor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">fma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">fpclassify</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">frexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_6"></a><span class="term">G</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">gcd</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_7"></a><span class="term">H</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">half</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_8"></a><span class="term">I</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">i</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/conversions.html" title="Constructing and Interconverting Between Number Types"><span class="index-entry-level-1">Constructing and Interconverting Between Number Types</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">if</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">Primality Testing</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ilogb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">in</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">infinity</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">integer_modulus</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">iround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isfinite</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isgreater</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isgreaterequal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isinf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isless</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">islessequal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">islessgreater</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isnan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isnormal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isunordered</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">itrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_9"></a><span class="term">L</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ldexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lgamma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">llrint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">llround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lltrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log1p</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log_postfix_event</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log_prefix_event</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lrint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lsb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ltrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_10"></a><span class="term">M</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">miller_rabin_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">Primality Testing</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">modf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">msb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">multiply</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_11"></a><span class="term">N</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">nextafter</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">nexttoward</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">norm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">numerator</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">cpp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_12"></a><span class="term">O</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">of</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">overlap</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_13"></a><span class="term">P</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">polar</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">pow</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">powm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">precision</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/faq.html" title="FAQ"><span class="index-entry-level-1">FAQ</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">proj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">proper_subset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_14"></a><span class="term">R</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">r</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/egs/bitops.html" title="Bit Operations"><span class="index-entry-level-1">Bit Operations</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">remainder</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">remquo</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">result</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">round</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_15"></a><span class="term">S</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scalar</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scoped</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scoped_opts</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">signbit</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">singleton</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">str</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">subset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">swap</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_16"></a><span class="term">T</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">temporary</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tgamma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">the</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">to_string</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">trunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">Defining a Special Function.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_17"></a><span class="term">V</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">v</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">Defining a Special Function.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">value</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/cpp_bin_float_ref.html" title="cpp_bin_float"><span class="index-entry-level-1">cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_18"></a><span class="term">X</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">x</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_19"></a><span class="term">Z</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">zero</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">gmp_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">gmp_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">tom_int</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">zero_in</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../indexes.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s02.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/indexes/s02.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Class Index</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../indexes.html" title="Indexes">
<link rel="prev" href="s01.html" title="Function Index">
<link rel="next" href="s03.html" title="Typedef Index">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s01.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s03.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="id1243944"></a>Class Index</h3></div></div></div>
<p><a class="link" href="s02.html#idx_id_22">C</a> <a class="link" href="s02.html#idx_id_23">D</a> <a class="link" href="s02.html#idx_id_24">E</a> <a class="link" href="s02.html#idx_id_25">F</a> <a class="link" href="s02.html#idx_id_26">G</a> <a class="link" href="s02.html#idx_id_28">I</a> <a class="link" href="s02.html#idx_id_29">L</a> <a class="link" href="s02.html#idx_id_30">M</a> <a class="link" href="s02.html#idx_id_31">N</a> <a class="link" href="s02.html#idx_id_36">T</a></p>
<div class="variablelist"><dl class="variablelist">
<dt>
<a name="idx_id_22"></a><span class="term">C</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex_adaptor.html" title="complex_adaptor"><span class="index-entry-level-0">complex_adaptor</span></a></p></li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">component_type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float"><span class="index-entry-level-0">cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/cpp_dec_float.html" title="cpp_dec_float"><span class="index-entry-level-0">cpp_dec_float</span></a></p></li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_int_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/cpp_int.html" title="cpp_int"><span class="index-entry-level-1">cpp_int</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_23"></a><span class="term">D</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/debug_adaptor.html" title="debug_adaptor"><span class="index-entry-level-0">debug_adaptor</span></a></p></li></ul></div></dd>
<dt>
<a name="idx_id_24"></a><span class="term">E</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expression_template_default</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_25"></a><span class="term">F</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">float128_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_26"></a><span class="term">G</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-0">gmp_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-0">gmp_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-0">gmp_rational</span></a></p></li>
</ul></div></dd>
<dt>
<a name="idx_id_28"></a><span class="term">I</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_equivalent_number_type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_explicitly_convertible</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_lossy_conversion</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_number_expression</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_restricted_conversion</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_signed_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_unsigned_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_29"></a><span class="term">L</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-0">logged_adaptor</span></a></p></li></ul></div></dd>
<dt>
<a name="idx_id_30"></a><span class="term">M</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpc_complex_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfi_float_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfr_float_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../ref/mpfr_ref.html" title="mpfr_float_backend"><span class="index-entry-level-1">mpfr_float_backend</span></a></strong></span></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_31"></a><span class="term">N</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-0">number</span></a></p></li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">number_category</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_36"></a><span class="term">T</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tommath_int</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">tom_int</span></a></p></li></ul></div>
</li></ul></div></dd>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s01.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s03.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/indexes/s03.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Typedef Index</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../indexes.html" title="Indexes">
<link rel="prev" href="s02.html" title="Class Index">
<link rel="next" href="s04.html" title="Index">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s02.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s04.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="id1244577"></a>Typedef Index</h3></div></div></div>
<p></p>
<div class="variablelist"><dl class="variablelist"></dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s02.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s04.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/indexes/s04.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Index</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../indexes.html" title="Indexes">
<link rel="prev" href="s03.html" title="Typedef Index">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s03.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="id1244563"></a>Index</h3></div></div></div>
<p><a class="link" href="s04.html#idx_id_60">A</a> <a class="link" href="s04.html#idx_id_61">B</a> <a class="link" href="s04.html#idx_id_62">C</a> <a class="link" href="s04.html#idx_id_63">D</a> <a class="link" href="s04.html#idx_id_64">E</a> <a class="link" href="s04.html#idx_id_65">F</a> <a class="link" href="s04.html#idx_id_66">G</a> <a class="link" href="s04.html#idx_id_67">H</a> <a class="link" href="s04.html#idx_id_68">I</a> <a class="link" href="s04.html#idx_id_69">L</a> <a class="link" href="s04.html#idx_id_70">M</a> <a class="link" href="s04.html#idx_id_71">N</a> <a class="link" href="s04.html#idx_id_72">O</a> <a class="link" href="s04.html#idx_id_73">P</a> <a class="link" href="s04.html#idx_id_74">R</a> <a class="link" href="s04.html#idx_id_75">S</a> <a class="link" href="s04.html#idx_id_76">T</a> <a class="link" href="s04.html#idx_id_77">V</a> <a class="link" href="s04.html#idx_id_78">X</a> <a class="link" href="s04.html#idx_id_79">Z</a></p>
<div class="variablelist"><dl class="variablelist">
<dt>
<a name="idx_id_60"></a><span class="term">A</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">a</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">abs</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">acosh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">arg</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">asinh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">assign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">assign_components</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">atanh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_61"></a><span class="term">B</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Backend Requirements</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">acosh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">asinh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">atanh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">cbrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">changesign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">copysign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">erf</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">erfc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">expm1</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">lgamma</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">llrint</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">log1p</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">lrint</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">nextafter</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">nexttoward</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">sign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">signbit</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">tgamma</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Bit Operations</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/egs/bitops.html" title="Bit Operations"><span class="index-entry-level-1">BOOST_MP_ASSERT</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/egs/bitops.html" title="Bit Operations"><span class="index-entry-level-1">r</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bits</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/input_output.html" title="Input Output"><span class="index-entry-level-1">Input Output</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rounding.html" title="Rounding Rules for Conversions"><span class="index-entry-level-1">Rounding Rules for Conversions</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_flip</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_set</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">bit_unset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">BOOST_MP_ASSERT</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/egs/bitops.html" title="Bit Operations"><span class="index-entry-level-1">Bit Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/lits.html" title="Literal Types and constexpr Support"><span class="index-entry-level-1">Literal Types and constexpr Support</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">BOOST_MP_MIN_EXPONENT_DIGITS</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/input_output.html" title="Input Output"><span class="index-entry-level-1">Input Output</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">BOOST_MP_USE_FLOAT128</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex128.html" title="complex128"><span class="index-entry-level-1">complex128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">BOOST_MP_USE_QUAD</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex128.html" title="complex128"><span class="index-entry-level-1">complex128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_62"></a><span class="term">C</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Calculating an Integral</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/gi.html" title="Calculating an Integral"><span class="index-entry-level-1">cos</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cbrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ceil</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">changesign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">compare</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">complex128</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex128.html" title="complex128"><span class="index-entry-level-1">BOOST_MP_USE_FLOAT128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex128.html" title="complex128"><span class="index-entry-level-1">BOOST_MP_USE_QUAD</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/complex_adaptor.html" title="complex_adaptor"><span class="index-entry-level-0">complex_adaptor</span></a></p></li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">component_type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Compulsory Requirements on the Backend type.</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_bitwise_or</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_bitwise_xor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_ceil</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_complement</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_conj</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_convert_to</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_divide</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_floor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_frexp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_imag</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_ldexp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_left_shift</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_modulus</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_multiply</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_proj</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_real</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_right_shift</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_set_imag</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_set_real</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_sqrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">eval_subtract</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">conj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Constructing and Interconverting Between Number Types</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/conversions.html" title="Constructing and Interconverting Between Number Types"><span class="index-entry-level-1">i</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">convert_to</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">copysign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/gi.html" title="Calculating an Integral"><span class="index-entry-level-1">Calculating an Integral</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_bin_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float"><span class="index-entry-level-1">cpp_bin_float</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/cpp_bin_float_ref.html" title="cpp_bin_float"><span class="index-entry-level-1">value</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_dec_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/floats/cpp_dec_float.html" title="cpp_dec_float"><span class="index-entry-level-1">cpp_dec_float</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_int</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/cpp_int.html" title="cpp_int"><span class="index-entry-level-1">cpp_int_backend</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_int_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/cpp_int.html" title="cpp_int"><span class="index-entry-level-1">cpp_int</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">cpp_rational</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">denominator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">numerator</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_63"></a><span class="term">D</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">data</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">gmp_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">gmp_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/lits.html" title="Literal Types and constexpr Support"><span class="index-entry-level-1">Literal Types and constexpr Support</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/debug_adaptor.html" title="debug_adaptor"><span class="index-entry-level-0">debug_adaptor</span></a></p></li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">default_precision</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Defining a Special Function.</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">v</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">denominator</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">cpp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">digits10</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">divide_qr</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_64"></a><span class="term">E</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">e</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">empty</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">erf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">erfc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_acos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_asin</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_atan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_atan2</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_and</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_or</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bitwise_xor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_flip</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_set</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_bit_unset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_ceil</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_complement</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_conj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_convert_to</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_cos</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_cosh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_decrement</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_divide</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_eq</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_exp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_exp2</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_fabs</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_floor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_fmod</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_frexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_gcd</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_get_sign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_gt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_increment</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_integer_sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_is_zero</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_lcm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_ldexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_left_shift</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_log</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_log10</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_lt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_modf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_modulus</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_msb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply_add</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_multiply_subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_nearbyint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_pow</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_powm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_proj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_qr</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_right_shift</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_round</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_scalbn</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_set_imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_set_real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sin</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sinh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b" title="Table 1.8. Compulsory Requirements on the Backend type."><span class="index-entry-level-1">Compulsory Requirements on the Backend type.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_tan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_tanh</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">eval_trunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">exp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expm1</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">export_bits</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expression</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">expression_template_default</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_65"></a><span class="term">F</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">f</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">FAQ</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/faq.html" title="FAQ"><span class="index-entry-level-1">precision</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">float128</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">BOOST_MP_USE_FLOAT128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">BOOST_MP_USE_QUAD</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128_backend</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">of</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">float128_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">floor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">fma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">fpclassify</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">frexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_66"></a><span class="term">G</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">gcd</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Generic Integer Operations</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">bit_flip</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">bit_set</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">bit_test</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">bit_unset</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">divide_qr</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">integer_modulus</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">lsb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">miller_rabin_test</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">msb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">multiply</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">powm</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">precision</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">sqrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">subtract</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">the</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">gmp_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">gmp_float</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">gmp_int</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">gmp_int</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">gmp_rational</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">denominator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">numerator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_67"></a><span class="term">H</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">half</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">History</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">ilogb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">sqrt</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_68"></a><span class="term">I</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">i</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/conversions.html" title="Constructing and Interconverting Between Number Types"><span class="index-entry-level-1">Constructing and Interconverting Between Number Types</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">if</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">Primality Testing</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ilogb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">imag</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">bit_set</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">BOOST_MP_ASSERT</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">export_bits</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">f</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">result</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">in</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">infinity</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Input Output</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/input_output.html" title="Input Output"><span class="index-entry-level-1">bits</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/input_output.html" title="Input Output"><span class="index-entry-level-1">BOOST_MP_MIN_EXPONENT_DIGITS</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">integer_modulus</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Internal Support Code</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">is_explicitly_convertible</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">is_lossy_conversion</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">is_restricted_conversion</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">is_signed_number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">is_unsigned_number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Introduction</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">a</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">expression</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">precision</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">result</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">iround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isfinite</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isgreater</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isgreaterequal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isinf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isless</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">islessequal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">islessgreater</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isnan</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isnormal</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">isunordered</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_equivalent_number_type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_explicitly_convertible</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_lossy_conversion</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_number_expression</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_restricted_conversion</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_signed_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">is_unsigned_number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/internals.html" title="Internal Support Code"><span class="index-entry-level-1">Internal Support Code</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">itrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_69"></a><span class="term">L</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ldexp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lgamma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Literal Types and constexpr Support</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/lits.html" title="Literal Types and constexpr Support"><span class="index-entry-level-1">BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/lits.html" title="Literal Types and constexpr Support"><span class="index-entry-level-1">data</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">llrint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">llround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lltrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log1p</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">logged_adaptor</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">log_postfix_event</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">log_prefix_event</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">the</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log_postfix_event</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">log_prefix_event</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lrint</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lround</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">lsb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">ltrunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_70"></a><span class="term">M</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">miller_rabin_test</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">Primality Testing</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Mixed Precision Arithmetic</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">a</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">e</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">i</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">is_equivalent_number_type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">multiply</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">subtract</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">type</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">modf</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpc_complex</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex_backend</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpc_complex_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfi_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">empty</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">in</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float_backend</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">overlap</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">proper_subset</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">singleton</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">subset</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">zero</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">zero_in</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfi_float_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfr_float</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">data</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float_backend</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">mpfr_float_backend</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../ref/mpfr_ref.html" title="mpfr_float_backend"><span class="index-entry-level-1">mpfr_float_backend</span></a></strong></span></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">msb</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">multiply</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_71"></a><span class="term">N</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">nextafter</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">nexttoward</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">norm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">number</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">abs</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">acosh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">arg</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">asinh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">assign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">atanh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">bit_flip</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">bit_set</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">bit_test</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">bit_unset</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">cbrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">ceil</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">changesign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">compare</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">component_type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">conj</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">convert_to</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">copysign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">cos</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">default_precision</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">denominator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">divide_qr</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">erf</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">erfc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">exp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">expm1</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">expression_template_default</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">floor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">fma</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">fpclassify</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">frexp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">gcd</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">ilogb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">imag</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">integer_modulus</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">iround</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isfinite</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isgreater</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isgreaterequal</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isinf</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isless</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">islessequal</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">islessgreater</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isnan</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isnormal</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">isunordered</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">is_number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">is_number_expression</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">itrunc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">ldexp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">lgamma</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">llrint</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">llround</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">lltrunc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">log1p</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">lrint</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">lround</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">lsb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">ltrunc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">miller_rabin_test</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">modf</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">msb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">multiply</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">nextafter</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">nexttoward</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">norm</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></strong></span></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number_category</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">numerator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">polar</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">pow</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">powm</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">precision</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">proj</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">real</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">remainder</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">remquo</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">round</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">scalar</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">sign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">signbit</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">sqrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">str</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">subtract</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">swap</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">tgamma</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">the</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">to_string</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">trunc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">value</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">number_category</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">numerator</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/cpp_rational.html" title="cpp_rational"><span class="index-entry-level-1">cpp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_72"></a><span class="term">O</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">of</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">Optional Requirements on the Backend Type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Optional Requirements on the Backend Type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">assign_components</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_acos</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_asin</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_atan</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_atan2</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bitwise_and</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bitwise_or</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bitwise_xor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bit_flip</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bit_set</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bit_test</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_bit_unset</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_cos</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_cosh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_decrement</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_divide</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_eq</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_exp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_exp2</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_fabs</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_fmod</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_gcd</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_get_sign</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_gt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_increment</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_integer_sqrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_is_zero</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_lcm</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_left_shift</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_log</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_log10</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_lt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_modf</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_modulus</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_msb</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_multiply</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_multiply_add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_multiply_subtract</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_nearbyint</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_pow</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_powm</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_qr</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_right_shift</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_round</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_scalbn</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_sin</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_sinh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_subtract</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_tan</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_tanh</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">eval_trunc</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html#boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac" title="Table 1.9. Optional Requirements on the Backend Type"><span class="index-entry-level-1">of</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">overlap</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_73"></a><span class="term">P</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">polar</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">pow</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">powm</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">precision</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/faq.html" title="FAQ"><span class="index-entry-level-1">FAQ</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Primality Testing</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">if</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/primetest.html" title="Primality Testing"><span class="index-entry-level-1">miller_rabin_test</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">proj</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">proper_subset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_74"></a><span class="term">R</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">r</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/egs/bitops.html" title="Bit Operations"><span class="index-entry-level-1">Bit Operations</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">real</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">remainder</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">remquo</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">result</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float"><span class="index-entry-level-1">Importing and Exporting Data to and from cpp_int and cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../intro.html" title="Introduction"><span class="index-entry-level-1">Introduction</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">round</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Rounding Rules for Conversions</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rounding.html" title="Rounding Rules for Conversions"><span class="index-entry-level-1">bits</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_75"></a><span class="term">S</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scalar</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scoped</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">scoped_opts</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sign</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">signbit</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">singleton</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sp</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">sqrt</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/hist.html" title="History"><span class="index-entry-level-1">History</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">std :: numeric_limits &lt;&gt; functions</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">BOOST_MP_ASSERT</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">infinity</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">sqrt</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">value</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">std::numeric_limits&lt;&gt; constants</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">bits</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">digits10</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">infinity</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">type</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">str</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">subset</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">subtract</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">swap</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_76"></a><span class="term">T</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">temporary</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">TODO</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tgamma</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/backendconc.html" title="Backend Requirements"><span class="index-entry-level-1">Backend Requirements</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">the</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/gen_int.html" title="Generic Integer Operations"><span class="index-entry-level-1">Generic Integer Operations</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/misc/logged_adaptor.html" title="logged_adaptor"><span class="index-entry-level-1">logged_adaptor</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">TODO</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">add</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">cpp_dec_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../map/todo.html" title="TODO"><span class="index-entry-level-1">temporary</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tommath_int</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">tom_int</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tommath_rational</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">denominator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">numerator</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">tom_int</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">tommath_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">zero</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">to_string</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">trunc</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li></ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">type</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">Defining a Special Function.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/float128.html" title="float128"><span class="index-entry-level-1">float128</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/mixed.html" title="Mixed Precision Arithmetic"><span class="index-entry-level-1">Mixed Precision Arithmetic</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_77"></a><span class="term">V</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">v</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/jel.html" title="Defining a Special Function."><span class="index-entry-level-1">Defining a Special Function.</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">Variable Precision Arithmetic</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">value</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/cpp_bin_float_ref.html" title="cpp_bin_float"><span class="index-entry-level-1">cpp_bin_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../ref/number.html" title="number"><span class="index-entry-level-1">number</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/functions.html" title="std::numeric_limits&lt;&gt; functions"><span class="index-entry-level-1">std :: numeric_limits &lt;&gt; functions</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Variable Precision Arithmetic</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">a</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">i</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">of</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">scoped</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">scoped_opts</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic"><span class="index-entry-level-1">v</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">Variable-Precision Newton Evaluation</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">a</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">exp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">f</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">half</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">sp</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">x</span></a></p></li>
</ul></div>
</li>
</ul></div></dd>
<dt>
<a name="idx_id_78"></a><span class="term">X</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">x</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/fp_eg/variable_precision.html" title="Variable-Precision Newton Evaluation"><span class="index-entry-level-1">Variable-Precision Newton Evaluation</span></a></p></li></ul></div>
</li></ul></div></dd>
<dt>
<a name="idx_id_79"></a><span class="term">Z</span>
</dt>
<dd><div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">zero</span></p>
<div class="index"><ul class="index" style="list-style-type: none; ">
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/gmp_float.html" title="gmp_float"><span class="index-entry-level-1">gmp_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/gmp_int.html" title="gmp_int"><span class="index-entry-level-1">gmp_int</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational"><span class="index-entry-level-1">gmp_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/complex/mpc_complex.html" title="mpc_complex"><span class="index-entry-level-1">mpc_complex</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float"><span class="index-entry-level-1">mpfr_float</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/limits/constants.html" title="std::numeric_limits&lt;&gt; constants"><span class="index-entry-level-1">std::numeric_limits&lt;&gt; constants</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/rational/tommath_rational.html" title="tommath_rational"><span class="index-entry-level-1">tommath_rational</span></a></p></li>
<li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/ints/tom_int.html" title="tom_int"><span class="index-entry-level-1">tom_int</span></a></p></li>
</ul></div>
</li>
<li class="listitem" style="list-style-type: none">
<p><span class="index-entry-level-0">zero_in</span></p>
<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../tut/interval/mpfi.html" title="mpfi_float"><span class="index-entry-level-1">mpfi_float</span></a></p></li></ul></div>
</li>
</ul></div></dd>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="s03.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/indexes.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Indexes</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="map/ack.html" title="Acknowledgements">
<link rel="next" href="indexes/s01.html" title="Function Index">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexes/s01.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.indexes"></a><a class="link" href="indexes.html" title="Indexes">Indexes</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="indexes/s01.html">Function Index</a></span></dt>
<dt><span class="section"><a href="indexes/s02.html">Class Index</a></span></dt>
<dt><span class="section"><a href="indexes/s03.html">Typedef Index</a></span></dt>
<dt><span class="section"><a href="indexes/s04.html">Index</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map/ack.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexes/s01.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/intro.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Introduction</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="next" href="tut.html" title="Tutorial">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tut.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.intro"></a><a class="link" href="intro.html" title="Introduction">Introduction</a>
</h2></div></div></div>
<p>
      The Multiprecision Library provides <a class="link" href="tut/ints.html" title="Integer Types">integer</a>,
      <a class="link" href="tut/rational.html" title="Rational Number Types">rational</a>, <a class="link" href="tut/floats.html" title="Floating-point Types">floating-point</a>,
      and <a class="link" href="tut/complex.html" title="Complex Number Types">complex</a> types in
      C++ that have more range and precision than C++'s ordinary <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
      (built-in)</a> types. The big number types in Multiprecision can be used
      with a wide selection of basic mathematical operations, elementary transcendental
      functions as well as the functions in Boost.Math. The Multiprecision types
      can also interoperate with any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
      (built-in) type</a> in C++ using clearly defined conversion rules. This
      allows Boost.Multiprecision to be used for all kinds of mathematical calculations
      involving integer, rational and floating-point types requiring extended range
      and precision.
    </p>
<p>
      Multiprecision consists of a generic interface to the mathematics of large
      numbers as well as a selection of big number back-ends, with support for integer,
      rational, floating-point, and complex types. Boost.Multiprecision provides
      a selection of back-ends provided off-the-rack in including interfaces to GMP,
      MPFR, MPIR, MPC, TomMath as well as its own collection of Boost-licensed, header-only
      back-ends for integers, rationals and floats. In addition, user-defined back-ends
      can be created and used with the interface of Multiprecision, provided the
      class implementation adheres to the necessary <a class="link" href="ref/backendconc.html" title="Backend Requirements">concepts</a>.
    </p>
<p>
      Depending upon the number type, precision may be arbitrarily large (limited
      only by available memory), fixed at compile time (for example, 50 or 100 decimal
      digits), or a variable controlled at run-time by member functions. The types
      are <a href="https://en.wikipedia.org/wiki/Expression_templates" target="_top">expression
      templates</a> - enabled for better performance than naive user-defined
      types.
    </p>
<p>
      The Multiprecision library comes in two distinct parts:
    </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
          An expression-template-enabled front-end <code class="computeroutput"><span class="identifier">number</span></code>
          that handles all the operator overloading, expression evaluation optimization,
          and code reduction.
        </li>
<li class="listitem">
          A selection of back-ends that implement the actual arithmetic operations,
          and need conform only to the reduced interface requirements of the front-end.
        </li>
</ul></div>
<p>
      Separation of front-end and back-end allows use of highly refined, but restricted
      license libraries where possible, but provides Boost license alternatives for
      users who must have a portable unconstrained license. Which is to say some
      back-ends rely on 3rd party libraries, but a header-only Boost license version
      is always available (if somewhat slower).
    </p>
<h6>
<a name="boost_multiprecision.intro.h0"></a>
      <span class="phrase"><a name="boost_multiprecision.intro.getting_started"></a></span><a class="link" href="intro.html#boost_multiprecision.intro.getting_started">Getting
      started with Boost.Multiprecision</a>
    </h6>
<p>
      Should you just wish to 'cut to the chase' just to get bigger integers and/or
      bigger and more precise reals as simply and portably as possible, close to
      'drop-in' replacements for the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
      (built-in) type</a> analogs, then use a fully Boost-licensed number type,
      and skip to one of more of :
    </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
          <a class="link" href="tut/ints/cpp_int.html" title="cpp_int">cpp_int</a> for
          multiprecision integers,
        </li>
<li class="listitem">
          <a class="link" href="tut/rational/cpp_rational.html" title="cpp_rational">cpp_rational</a>
          for rational types,
        </li>
<li class="listitem">
          <a class="link" href="tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
          and <a class="link" href="tut/floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
          for multiprecision floating-point types,
        </li>
<li class="listitem">
          <a class="link" href="tut/complex/cpp_complex.html" title="cpp_complex">cpp_complex</a>
          for complex types.
        </li>
</ul></div>
<p>
      The library is very often used via one of the predefined convenience <code class="computeroutput"><span class="keyword">typedef</span></code>s like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">int128_t</span></code>
      or <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span></code>.
    </p>
<p>
      For example, if you want a signed, 128-bit fixed size integer:
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>  <span class="comment">//  Integer types.</span>

<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">int128_t</span> <span class="identifier">my_128_bit_int</span><span class="special">;</span>
</pre>
<p>
      Alternatively, and more adventurously, if you wanted an <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
      precision</a> integer type using <a href="http://gmplib.org" target="_top">GMP</a>
      as the underlying implementation then you could use:
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>  <span class="comment">// Defines the wrappers around the GMP library's types</span>

<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">mpz_int</span> <span class="identifier">myint</span><span class="special">;</span>    <span class="comment">// Arbitrary precision integer type.</span>
</pre>
<p>
      Or for a simple, portable 128-bit floating-point close to a drop-in for a
      <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental (built-in)
      type</a> like <code class="computeroutput"><span class="keyword">double</span></code>, usually
      64-bit
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span> <span class="identifier">my_quad_real</span><span class="special">;</span>
</pre>
<p>
      Alternatively, you can compose your own 'custom' multiprecision type, by combining
      <code class="computeroutput"><span class="identifier">number</span></code> with one of the predefined
      back-end types. For example, suppose you wanted a 300 decimal digit floating-point
      type based on the <a href="http://www.mpfr.org" target="_top">MPFR</a> library. In
      this case, there's no predefined <code class="computeroutput"><span class="keyword">typedef</span></code>
      with that level of precision, so instead we compose our own:
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>  <span class="comment">// Defines the Backend type that wraps MPFR.</span>

<span class="keyword">namespace</span> <span class="identifier">mp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>     <span class="comment">// Reduce the typing a bit later...</span>

<span class="keyword">typedef</span> <span class="identifier">mp</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mp</span><span class="special">::</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">300</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">my_float</span><span class="special">;</span>

<span class="identifier">my_float</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">c</span><span class="special">;</span> <span class="comment">// These variables have 300 decimal digits precision.</span>
</pre>
<p>
      We can repeat the above example, but with the expression templates disabled
      (for faster compile times, but slower runtimes) by passing a second template
      argument to <code class="computeroutput"><span class="identifier">number</span></code>:
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>  <span class="comment">// Defines the Backend type that wraps MPFR.</span>

<span class="keyword">namespace</span> <span class="identifier">mp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>     <span class="comment">// Reduce the typing a bit later...</span>

<span class="keyword">typedef</span> <span class="identifier">mp</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mp</span><span class="special">::</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">300</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>  <span class="identifier">my_float</span><span class="special">;</span>

<span class="identifier">my_float</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">c</span><span class="special">;</span> <span class="comment">// These variables have 300 decimal digits precision</span>
</pre>
<p>
      We can also mix arithmetic operations between different types, provided there
      is an unambiguous implicit conversion from one type to the other:
    </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">mp</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>     <span class="comment">// Reduce the typing a bit later...</span>

<span class="identifier">mp</span><span class="special">::</span><span class="identifier">int128_t</span> <span class="identifier">a</span><span class="special">(</span><span class="number">3</span><span class="special">),</span> <span class="identifier">b</span><span class="special">(</span><span class="number">4</span><span class="special">);</span>
<span class="identifier">mp</span><span class="special">::</span><span class="identifier">int512_t</span> <span class="identifier">c</span><span class="special">(</span><span class="number">50</span><span class="special">),</span> <span class="identifier">d</span><span class="special">;</span>

<span class="identifier">d</span> <span class="special">=</span> <span class="identifier">c</span> <span class="special">*</span> <span class="identifier">a</span><span class="special">;</span>   <span class="comment">// OK, result of mixed arithmetic is an int512_t</span>
</pre>
<p>
      Conversions are also allowed:
    </p>
<pre class="programlisting"><span class="identifier">d</span> <span class="special">=</span> <span class="identifier">a</span><span class="special">;</span> <span class="comment">// OK, widening conversion.</span>
<span class="identifier">d</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">;</span>  <span class="comment">// OK, can convert from an expression template too.</span>
</pre>
<p>
      However conversions that are inherently lossy are either declared explicit
      or else forbidden altogether:
    </p>
<pre class="programlisting"><span class="identifier">d</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span>  <span class="comment">// Error implicit conversion from double not allowed.</span>
<span class="identifier">d</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">mp</span><span class="special">::</span><span class="identifier">int512_t</span><span class="special">&gt;(</span><span class="number">3.14</span><span class="special">);</span>  <span class="comment">// OK explicit construction is allowed</span>
</pre>
<p>
      Mixed arithmetic will fail if the conversion is either ambiguous or explicit:
    </p>
<pre class="programlisting"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">a</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;,</span> <span class="identifier">et_on</span><span class="special">&gt;</span>  <span class="identifier">b</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>

<span class="identifier">b</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">;</span> <span class="comment">// Error, implicit conversion could go either way.</span>
<span class="identifier">b</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="number">3.14</span><span class="special">;</span> <span class="comment">// Error, no operator overload if the conversion would be explicit.</span>
</pre>
<h5>
<a name="boost_multiprecision.intro.h1"></a>
      <span class="phrase"><a name="boost_multiprecision.intro.move_semantics"></a></span><a class="link" href="intro.html#boost_multiprecision.intro.move_semantics">Move
      Semantics</a>
    </h5>
<p>
      On compilers that support rvalue-references, class <code class="computeroutput"><span class="identifier">number</span></code>
      is move-enabled if the underlying backend is.
    </p>
<p>
      In addition the non-expression template operator overloads (see below) are
      move aware and have overloads that look something like:
    </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">B</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="keyword">operator</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">a</span> <span class="special">+=</span> <span class="identifier">b</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
      These operator overloads ensure that many expressions can be evaluated without
      actually generating any temporaries. However, there are still many simple expressions
      such as
    </p>
<pre class="programlisting"><span class="identifier">a</span> <span class="special">=</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">c</span><span class="special">;</span>
</pre>
<p>
      which don't noticeably benefit from move support. Therefore, optimal performance
      comes from having both move-support, and expression templates enabled.
    </p>
<p>
      Note that while "moved-from" objects are left in a sane state, they
      have an unspecified value, and the only permitted operations on them are destruction
      or the assignment of a new value. Any other operation should be considered
      a programming error and all of our backends will trigger an assertion if any
      other operation is attempted. This behavior allows for optimal performance
      on move-construction (i.e. no allocation required, we just take ownership of
      the existing object's internal state), while maintaining usability in the standard
      library containers.
    </p>
<h5>
<a name="boost_multiprecision.intro.h2"></a>
      <span class="phrase"><a name="boost_multiprecision.intro.expression_templates"></a></span><a class="link" href="intro.html#boost_multiprecision.intro.expression_templates">Expression
      Templates</a>
    </h5>
<p>
      Class <code class="computeroutput"><span class="identifier">number</span></code> is expression-template-enabled:
      that means that rather than having a multiplication operator that looks like
      this:
    </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;</span> <span class="keyword">operator</span> <span class="special">*</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;</span> <span class="identifier">result</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span>
   <span class="identifier">result</span> <span class="special">*=</span> <span class="identifier">b</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
      Instead the operator looks more like this:
    </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="emphasis"><em>unmentionable-type</em></span> <span class="keyword">operator</span> <span class="special">*</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
      Where the '<span class="emphasis"><em>unmentionable</em></span>' return type is an implementation
      detail that, rather than containing the result of the multiplication, contains
      instructions on how to compute the result. In effect it's just a pair of references
      to the arguments of the function, plus some compile-time information that stores
      what the operation is.
    </p>
<p>
      The great advantage of this method is the <span class="emphasis"><em>elimination of temporaries</em></span>:
      for example, the "naive" implementation of <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> above, requires one temporary for computing
      the result, and at least another one to return it. It's true that sometimes
      this overhead can be reduced by using move-semantics, but it can't be eliminated
      completely. For example, lets suppose we're evaluating a polynomial via Horner's
      method, something like this:
    </p>
<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">a</span><span class="special">[</span><span class="number">7</span><span class="special">]</span> <span class="special">=</span> <span class="special">{</span> <span class="comment">/* some values */</span> <span class="special">};</span>
<span class="comment">//....</span>
<span class="identifier">y</span> <span class="special">=</span> <span class="special">(((((</span><span class="identifier">a</span><span class="special">[</span><span class="number">6</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">5</span><span class="special">])</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">4</span><span class="special">])</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">3</span><span class="special">])</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">2</span><span class="special">])</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">1</span><span class="special">])</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">a</span><span class="special">[</span><span class="number">0</span><span class="special">];</span>
</pre>
<p>
      If type <code class="computeroutput"><span class="identifier">T</span></code> is a <code class="computeroutput"><span class="identifier">number</span></code>, then this expression is evaluated
      <span class="emphasis"><em>without creating a single temporary value</em></span>. In contrast,
      if we were using the <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a>
      C++ wrapper for <a href="http://www.mpfr.org" target="_top">MPFR</a> - then this expression
      would result in no less than 11 temporaries (this is true even though <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a> does
      use expression templates to reduce the number of temporaries somewhat). Had
      we used an even simpler wrapper around <a href="http://www.mpfr.org" target="_top">MPFR</a>
      like <a href="http://www.holoborodko.com/pavel/mpfr/" target="_top">mpreal</a> things
      would have been even worse and no less that 24 temporaries are created for
      this simple expression (note - we actually measure the number of memory allocations
      performed rather than the number of temporaries directly, note also that the
      <a href="http://gmplib.org/manual/C_002b_002b-Interface-Floats.html#C_002b_002b-Interface-Floats" target="_top">mpf_class</a>
      wrapper that will be supplied with GMP-5.1 reduces the number of temporaries
      to pretty much zero). Note that if we compile with expression templates disabled
      and rvalue-reference support on, then actually still have no wasted memory
      allocations as even though temporaries are created, their contents are moved
      rather than copied. <a href="#ftn.boost_multiprecision.intro.f0" class="footnote" name="boost_multiprecision.intro.f0"><sup class="footnote">[1]</sup></a>
    </p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top">
<p>
        Expression templates can radically reorder the operations in an expression,
        for example:
      </p>
<p>
        a = (b * c) * a;
      </p>
<p>
        Will get transformed into:
      </p>
<p>
        a *= c; a *= b;
      </p>
<p>
        If this is likely to be an issue for a particular application, then they
        should be disabled.
      </p>
</td></tr>
</table></div>
<p>
      This library also extends expression template support to standard library functions
      like <code class="computeroutput"><span class="identifier">abs</span></code> or <code class="computeroutput"><span class="identifier">sin</span></code>
      with <code class="computeroutput"><span class="identifier">number</span></code> arguments. This
      means that an expression such as:
    </p>
<pre class="programlisting"><span class="identifier">y</span> <span class="special">=</span> <span class="identifier">abs</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
      can be evaluated without a single temporary being calculated. Even expressions
      like:
    </p>
<pre class="programlisting"><span class="identifier">y</span> <span class="special">=</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
      get this treatment, so that variable 'y' is used as "working storage"
      within the implementation of <code class="computeroutput"><span class="identifier">sin</span></code>,
      thus reducing the number of temporaries used by one. Of course, should you
      write:
    </p>
<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
      Then we clearly can't use <code class="computeroutput"><span class="identifier">x</span></code>
      as working storage during the calculation, so then a temporary variable is
      created in this case.
    </p>
<p>
      Given the comments above, you might be forgiven for thinking that expression-templates
      are some kind of universal-panacea: sadly though, all tricks like this have
      their downsides. For one thing, expression template libraries like this one,
      tend to be slower to compile than their simpler cousins, they're also harder
      to debug (should you actually want to step through our code!), and rely on
      compiler optimizations being turned on to give really good performance. Also,
      since the return type from expressions involving <code class="computeroutput"><span class="identifier">number</span></code>s
      is an "unmentionable implementation detail", you have to be careful
      to cast the result of an expression to the actual number type when passing
      an expression to a template function. For example, given:
    </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">my_proc</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
</pre>
<p>
      Then calling:
    </p>
<pre class="programlisting"><span class="identifier">my_proc</span><span class="special">(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
      Will very likely result in obscure error messages inside the body of <code class="computeroutput"><span class="identifier">my_proc</span></code> - since we've passed it an expression
      template type, and not a number type. Instead we probably need:
    </p>
<pre class="programlisting"><span class="identifier">my_proc</span><span class="special">(</span><span class="identifier">my_number_type</span><span class="special">(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">));</span>
</pre>
<p>
      Having said that, these situations don't occur that often - or indeed not at
      all for non-template functions. In addition, all the functions in the Boost.Math
      library will automatically convert expression-template arguments to the underlying
      number type without you having to do anything, so:
    </p>
<pre class="programlisting"><span class="identifier">mpfr_float_100</span> <span class="identifier">a</span><span class="special">(</span><span class="number">20</span><span class="special">),</span> <span class="identifier">delta</span><span class="special">(</span><span class="number">0.125</span><span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gamma_p</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">delta</span><span class="special">);</span>
</pre>
<p>
      Will work just fine, with the <code class="computeroutput"><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">delta</span></code> expression
      template argument getting converted to an <code class="computeroutput"><span class="identifier">mpfr_float_100</span></code>
      internally by the Boost.Math library.
    </p>
<div class="caution"><table border="0" summary="Caution">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../../../../../doc/src/images/caution.png"></td>
<th align="left">Caution</th>
</tr>
<tr><td align="left" valign="top">
<p>
        In C++11 you should never store an expression template using:
      </p>
<p>
        <code class="computeroutput"><span class="keyword">auto</span> <span class="identifier">my_expression</span>
        <span class="special">=</span> <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span> <span class="special">-</span>
        <span class="identifier">c</span><span class="special">;</span></code>
      </p>
<p>
        unless you're absolutely sure that the lifetimes of <code class="computeroutput"><span class="identifier">a</span></code>,
        <code class="computeroutput"><span class="identifier">b</span></code> and <code class="computeroutput"><span class="identifier">c</span></code>
        will outlive that of <code class="computeroutput"><span class="identifier">my_expression</span></code>.
      </p>
<p>
        In fact, it is particularly easy to create dangling references by mixing
        expression templates with the <code class="computeroutput"><span class="keyword">auto</span></code>
        keyword, for example:
      </p>
<p>
        <code class="computeroutput"><span class="keyword">auto</span> <span class="identifier">val</span>
        <span class="special">=</span> <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="string">"23.1"</span><span class="special">)</span> <span class="special">*</span> <span class="number">100</span><span class="special">;</span></code>
      </p>
<p>
        In this situation, the integer literal is stored directly in the expression
        template - so its use is OK here - but the <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
        temporary is stored by reference and then destructed when the statement completes,
        leaving a dangling reference.
      </p>
<p>
        <span class="bold"><strong><span class="emphasis"><em>If in doubt, do not ever mix expression templates
        with the <code class="computeroutput"><span class="keyword">auto</span></code> keyword.</em></span></strong></span>
      </p>
</td></tr>
</table></div>
<p>
      And finally... the performance improvements from an expression template library
      like this are often not as dramatic as the reduction in number of temporaries
      would suggest. For example, if we compare this library with <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a>
      and <a href="http://www.holoborodko.com/pavel/mpfr/" target="_top">mpreal</a>, with
      all three using the underlying <a href="http://www.mpfr.org" target="_top">MPFR</a>
      library at 50 decimal digits precision then we see the following typical results
      for polynomial execution:
    </p>
<div class="table">
<a name="boost_multiprecision.intro.evaluation_of_order_6_polynomial"></a><p class="title"><b>Table 1.1. Evaluation of Order 6 Polynomial.</b></p>
<div class="table-contents"><table class="table" summary="Evaluation of Order 6 Polynomial.">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              <p>
                Library
              </p>
            </th>
<th>
              <p>
                Relative Time
              </p>
            </th>
<th>
              <p>
                Relative number of memory allocations
              </p>
            </th>
</tr></thead>
<tbody>
<tr>
<td>
              <p>
                number
              </p>
            </td>
<td>
              <p>
                1.0 (0.00957s)
              </p>
            </td>
<td>
              <p>
                1.0 (2996 total)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a>
              </p>
            </td>
<td>
              <p>
                1.1 (0.0102s)
              </p>
            </td>
<td>
              <p>
                4.3 (12976 total)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://www.holoborodko.com/pavel/mpfr/" target="_top">mpreal</a>
              </p>
            </td>
<td>
              <p>
                1.6 (0.0151s)
              </p>
            </td>
<td>
              <p>
                9.3 (27947 total)
              </p>
            </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
      As you can see, the execution time increases a lot more slowly than the number
      of memory allocations. There are a number of reasons for this:
    </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
          The cost of extended-precision multiplication and division is so great,
          that the times taken for these tend to swamp everything else.
        </li>
<li class="listitem">
          The cost of an in-place multiplication (using <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>) tends to be more than an out-of-place
          <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
          (typically <code class="computeroutput"><span class="keyword">operator</span> <span class="special">*=</span></code>
          has to create a temporary workspace to carry out the multiplication, where
          as <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
          can use the target variable as workspace). Since the expression templates
          carry out their magic by converting out-of-place operators to in-place
          ones, we necessarily take this hit. Even so the transformation is more
          efficient than creating the extra temporary variable, just not by as much
          as one would hope.
        </li>
</ul></div>
<p>
      Finally, note that <code class="computeroutput"><span class="identifier">number</span></code> takes
      a second template argument, which, when set to <code class="computeroutput"><span class="identifier">et_off</span></code>
      disables all the expression template machinery. The result is much faster to
      compile, but slower at runtime.
    </p>
<p>
      We'll conclude this section by providing some more performance comparisons
      between these three libraries, again, all are using <a href="http://www.mpfr.org" target="_top">MPFR</a>
      to carry out the underlying arithmetic, and all are operating at the same precision
      (50 decimal digits):
    </p>
<div class="table">
<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_besse"></a><p class="title"><b>Table 1.2. Evaluation of Boost.Math's Bessel function test data</b></p>
<div class="table-contents"><table class="table" summary="Evaluation of Boost.Math's Bessel function test data">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              <p>
                Library
              </p>
            </th>
<th>
              <p>
                Relative Time
              </p>
            </th>
<th>
              <p>
                Relative Number of Memory Allocations
              </p>
            </th>
</tr></thead>
<tbody>
<tr>
<td>
              <p>
                mpfr_float_50
              </p>
            </td>
<td>
              <p>
                1.0 (5.78s)
              </p>
            </td>
<td>
              <p>
                1.0 (1611963)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                number&lt;mpfr_float_backend&lt;50&gt;, et_off&gt;<br> (but with
                rvalue reference support)
              </p>
            </td>
<td>
              <p>
                1.1 (6.29s)
              </p>
            </td>
<td>
              <p>
                2.64 (4260868)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a>
              </p>
            </td>
<td>
              <p>
                1.1 (6.28s)
              </p>
            </td>
<td>
              <p>
                2.45 (3948316)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://www.holoborodko.com/pavel/mpfr/" target="_top">mpreal</a>
              </p>
            </td>
<td>
              <p>
                1.65 (9.54s)
              </p>
            </td>
<td>
              <p>
                8.21 (13226029)
              </p>
            </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.intro.evaluation_of_boost_math_s_non_c"></a><p class="title"><b>Table 1.3. Evaluation of Boost.Math's Non-Central T distribution test data</b></p>
<div class="table-contents"><table class="table" summary="Evaluation of Boost.Math's Non-Central T distribution test data">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              <p>
                Library
              </p>
            </th>
<th>
              <p>
                Relative Time
              </p>
            </th>
<th>
              <p>
                Relative Number of Memory Allocations
              </p>
            </th>
</tr></thead>
<tbody>
<tr>
<td>
              <p>
                number
              </p>
            </td>
<td>
              <p>
                1.0 (263s)
              </p>
            </td>
<td>
              <p>
                1.0 (127710873)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                number&lt;mpfr_float_backend&lt;50&gt;, et_off&gt;<br> (but with
                rvalue reference support)
              </p>
            </td>
<td>
              <p>
                1.0 (260s)
              </p>
            </td>
<td>
              <p>
                1.2 (156797871)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://math.berkeley.edu/~wilken/code/gmpfrxx/" target="_top">mpfr_class</a>
              </p>
            </td>
<td>
              <p>
                1.1 (287s)
              </p>
            </td>
<td>
              <p>
                2.1 (268336640)
              </p>
            </td>
</tr>
<tr>
<td>
              <p>
                <a href="http://www.holoborodko.com/pavel/mpfr/" target="_top">mpreal</a>
              </p>
            </td>
<td>
              <p>
                1.5 (389s)
              </p>
            </td>
<td>
              <p>
                3.6 (466960653)
              </p>
            </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
      The above results were generated on Win32 compiling with Visual C++ 2010, all
      optimizations on (/Ox), with MPFR 3.0 and MPIR 2.3.0.
    </p>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.boost_multiprecision.intro.f0" class="footnote"><p><a href="#boost_multiprecision.intro.f0" class="para"><sup class="para">[1] </sup></a>
        The actual number generated will depend on the compiler, how well it optimizes
        the code, and whether it supports rvalue references. The number of 11 temporaries
        was generated with Visual C++ 2010.
      </p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tut.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/map/ack.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Acknowledgements</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../map.html" title="Roadmap">
<link rel="prev" href="faq.html" title="FAQ">
<link rel="next" href="../indexes.html" title="Indexes">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="faq.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../indexes.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.map.ack"></a><a class="link" href="ack.html" title="Acknowledgements">Acknowledgements</a>
</h3></div></div></div>
<p>
        This library would not have happened without:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Christopher Kormanyos' C++ decimal number code.
          </li>
<li class="listitem">
            Paul Bristow for patiently testing, and commenting on the library.
          </li>
<li class="listitem">
            All the folks at GMP, MPFR and libtommath, for providing the "guts"
            that makes this library work.
          </li>
<li class="listitem">
            <a href="http://www-cs-faculty.stanford.edu/~uno/taocp.html" target="_top">"The
            Art Of Computer Programming"</a>, Donald E. Knuth, Volume 2:
            Seminumerical Algorithms, Third Edition (Reading, Massachusetts: Addison-Wesley,
            1997), xiv+762pp. ISBN 0-201-89684-2
          </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="faq.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../indexes.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/map/faq.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>FAQ</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../map.html" title="Roadmap">
<link rel="prev" href="todo.html" title="TODO">
<link rel="next" href="ack.html" title="Acknowledgements">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="todo.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ack.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.map.faq"></a><a class="link" href="faq.html" title="FAQ">FAQ</a>
</h3></div></div></div>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Why do I get compiler errors when passing a <code class="computeroutput"><span class="identifier">number</span></code>
          to a template function?</span></dt>
<dd><p>
              Most likely you are actually passing an expression template type to
              the function and template-argument-deduction deduces the "wrong"
              type. Try casting the arguments involving expressions to the actual
              number type, or as a last resort turning off expression template support
              in the number type you are using.
            </p></dd>
<dt><span class="term">When is expression template support a performance gain?</span></dt>
<dd><p>
              As a general rule, expression template support adds a small runtime
              overhead creating and unpacking the expression templates, but greatly
              reduces the number of temporaries created. So it's most effective in
              improving performance when the cost of creating a temporary is high:
              for example when creating a temporary involves a memory allocation.
              It is least effective (and may even be a dis-optimisation) when temporaries
              are cheap: for example if the number type is basically a thin wrapper
              around a native arithmetic type. In addition, since the library makes
              extensive use of thin inline wrapper functions, turning on compiler
              optimization is essential to achieving high performance.
            </p></dd>
<dt><span class="term">Do expression templates reorder operations?</span></dt>
<dd><p>
              Yes they do, sometimes quite radically so, if this is a concern then
              they should be turned off for the number type you are using.
            </p></dd>
<dt><span class="term">I can't construct my number type from <span class="emphasis"><em>some other type</em></span>,
          but the docs indicate that the conversion should be allowed, what's up?</span></dt>
<dd><p>
              Some conversions are <span class="emphasis"><em>explicit</em></span>, that includes construction
              from a string, or constructing from any type that may result in loss
              of precision (for example constructing an integer type from a float).
            </p></dd>
<dt><span class="term">Why do I get an exception thrown (or the program crash due to an
          uncaught exception) when using the bitwise operators on a checked <code class="computeroutput"><span class="identifier">cpp_int</span></code>?</span></dt>
<dd><p>
              Bitwise operations on negative values (or indeed any signed integer
              type) are unspecified by the standard. As a result any attempt to carry
              out a bitwise operation on a negative checked-integer will result in
              a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code> being thrown.
            </p></dd>
<dt><span class="term">Why do I get compiler errors when trying to use the complement operator?</span></dt>
<dd><p>
              Use of the complement operator on signed types is problematic as the
              result is unspecified by the standard, and is further complicated by
              the fact that most extended precision integer types use a sign-magnitude
              representation rather than the 2's complement one favored by most native
              integer types. As a result the complement operator is deliberately
              disabled for checked <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s.
              Unchecked <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s
              give the same valued result as a 2's complement type would, but not
              the same bit-pattern.
            </p></dd>
<dt><span class="term">Why can't I negate an unsigned type?</span></dt>
<dd><p>
              The unary negation operator is deliberately disabled for unsigned integer
              types as its use would almost always be a programming error.
            </p></dd>
<dt><span class="term">Why doesn't the library use proto?</span></dt>
<dd><p>
              A very early version of the library did use proto, but compile times
              became too slow for the library to be usable. Since the library only
              required a tiny fraction of what proto has to offer anyway, a lightweight
              expression template mechanism was used instead. Compile times are still
              too slow...
            </p></dd>
<dt><span class="term">Why not abstract out addition/multiplication algorithms?</span></dt>
<dd><p>
              This was deemed not to be practical: these algorithms are intimately
              tied to the actual data representation used.
            </p></dd>
<dt><span class="term">How do I choose between Boost.Multiprecision <code class="computeroutput"><span class="identifier">cpp_bin_50</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_dec_50</span></code>?</span></dt>
<dd>
<p>
              Unless you have a specific reason to choose <code class="computeroutput"><span class="identifier">cpp_dec_</span></code>,
              then the default choice should be <code class="computeroutput"><span class="identifier">cpp_bin_</span></code>,
              for example using the convenience <code class="computeroutput"><span class="identifier">typedefs</span></code>
              like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_50</span></code> or <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_100</span></code>.
            </p>
<p>
              In general, both work well and give the same results and at roughly
              the same speed with <code class="computeroutput"><span class="identifier">cpp_dec_50</span></code>
              sometimes faster.
            </p>
<p>
              <code class="computeroutput"><span class="identifier">cpp_dec_</span></code> was developed
              first paving the way for <code class="computeroutput"><span class="identifier">cpp_bin_</span></code>.
              <code class="computeroutput"><span class="identifier">cpp_dec_</span></code> has several
              guard digits and is not rounded at all, using 'brute force' to get
              the promised number of decimal digits correct, but making it difficult
              to reason about precision and computational uncertainty, for example
              see <span class="bold"><strong>https://svn.boost.org/trac10/ticket/12133</strong></span>.
              It also has a fast but imprecise division operator giving surprising
              results sometimes, see <span class="bold"><strong>https://svn.boost.org/trac10/ticket/11178</strong></span>.
            </p>
<p>
              <code class="computeroutput"><span class="identifier">cpp_bin_</span></code> is correctly/exactly
              rounded making it possible to reason about both the precision and rounding
              of the results.
            </p>
</dd>
</dl>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="todo.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ack.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/map/hist.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>History</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../map.html" title="Roadmap">
<link rel="prev" href="../map.html" title="Roadmap">
<link rel="next" href="todo.html" title="TODO">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../map.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="todo.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.map.hist"></a><a class="link" href="hist.html" title="History">History</a>
</h3></div></div></div>
<h5>
<a name="boost_multiprecision.map.hist.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_1_2_boost_1_81"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_1_2_boost_1_81">Multiprecision-4.1.2
        (Boost-1.81)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Correct thread-safe static initialization of constants for <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>,
            see <a href="https://github.com/boostorg/multiprecision/issues/497" target="_top">497</a>.
          </li>
<li class="listitem">
            Correct <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>
            <code class="computeroutput"><span class="identifier">import_bits</span></code> when just
            importing the leading few bits of the value, see <a href="https://github.com/boostorg/multiprecision/issues/488" target="_top">488</a>.
          </li>
<li class="listitem">
            Remove some C++03 idioms, including use of <code class="computeroutput"><span class="number">0</span></code>
            rather than <code class="computeroutput"><span class="keyword">nullptr</span></code>.
          </li>
<li class="listitem">
            Minor fixes for gcc-12 on Mingw.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h1"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_1_1_boost_1_80"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_1_1_boost_1_80">Multiprecision-4.1.1
        (Boost-1.80)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <span class="bold"><strong>Mark C++11 support as deprecated</strong></span>: from
            2023 we will move to requiring C++14 as a minimum standard level. That
            will drop support for GCC versions prior to 5 and MSVC prior to 14.1.
          </li>
<li class="listitem">
            Fix conflict between <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cstdfloat</span><span class="special">.</span><span class="identifier">hpp</span></code>
            and this library.
          </li>
<li class="listitem">
            Clean up lots of gcc and clang warnings.
          </li>
<li class="listitem">
            Fix input streaming of composite types (complex, interval rational) where
            there is a trailing delimeter in the stream and no whitespace.
          </li>
<li class="listitem">
            Fix <code class="computeroutput"><span class="keyword">constexpr</span></code> integer square
            root where the input is 1, 2 or 3.
          </li>
<li class="listitem">
            Add missing <code class="computeroutput"><span class="preprocessor">#include</span></code>
            of <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">memory</span><span class="special">&gt;</span></code> to float128.hpp.
          </li>
<li class="listitem">
            Correct 2-arg constructor for class <code class="computeroutput"><span class="identifier">number</span></code>
            to prevent ambiguity in some cases.
          </li>
<li class="listitem">
            Correct and make more consistent behaviour of divide-by-zero in gmp.hpp.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h2"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_1_0_boost_1_79"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_1_0_boost_1_79">Multiprecision-4.1.0
        (Boost-1.79)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Big update to support use of this library "standalone": ie
            without the rest of Boost. A copy of Boost.Config is still required,
            and use of Boost.Math to provide the C99 special functions is optional.
          </li>
<li class="listitem">
            Fix IO of floating point numbers when <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">fixed</span></code>
            is in effect and the precision is zero.
          </li>
<li class="listitem">
            Fix various spurious GCC warnings in cpp_int bitwise operators.
          </li>
<li class="listitem">
            Use <code class="computeroutput"><span class="identifier">float128_type</span></code> typedef
            throughout to suppress GCC/clang warnings about using a non-standard
            extension.
          </li>
<li class="listitem">
            Correct conversion of Intel's _Quad type to string, see <a href="https://github.com/boostorg/multiprecision/issues/427" target="_top">#427</a>.
          </li>
<li class="listitem">
            Correct usage of Intel intrinsics on GCC to avoid simply checking for
            the header, see <a href="https://github.com/boostorg/multiprecision/issues/419" target="_top">#419</a>.
          </li>
<li class="listitem">
            Update <code class="computeroutput"><span class="identifier">signbit</span></code> to match
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">signbit</span></code> and to return the correct sign
            when the result is zero, <a href="https://github.com/boostorg/multiprecision/issues/426" target="_top">#426</a>.
          </li>
<li class="listitem">
            Fix over-large reductions in default sin/cos code.
          </li>
<li class="listitem">
            Fix some mpq rational arithmetic errors: Multiplication by zero should
            not proceed via gcd, and multiplication by scalar should be restricted
            to integer types (not floats).
          </li>
<li class="listitem">
            Support conversion to and from <code class="computeroutput"><span class="identifier">__int128</span></code>
            and <code class="computeroutput"><span class="identifier">__float128</span></code> everywhere,
            not just on an add-hock basis, <a href="https://github.com/boostorg/multiprecision/issues/237" target="_top">#237</a>.
          </li>
<li class="listitem">
            Avoid unnecessary copying in cpp_int's add_unsigned, <a href="https://github.com/boostorg/multiprecision/issues/357" target="_top">#357</a>.
          </li>
<li class="listitem">
            Change all bit counts to use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>
            or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span></code>, <a href="https://github.com/boostorg/multiprecision/issues/362" target="_top">#362</a>.
          </li>
<li class="listitem">
            Bring Eigen traits classes up to date and add tests.
          </li>
<li class="listitem">
            Fix <code class="computeroutput"><span class="identifier">is_byte_container</span></code>
            to correctly handle Eigen types, <a href="https://github.com/boostorg/multiprecision/issues/398" target="_top">#398</a>.
          </li>
<li class="listitem">
            Improve cpp_int to float conversion to be insensitive to floating point
            control flags, <a href="https://github.com/boostorg/multiprecision/issues/360" target="_top">#360</a>.
          </li>
<li class="listitem">
            Correct interop between signed-zeros and complex number types, <a href="https://github.com/boostorg/multiprecision/issues/396" target="_top">#396</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h3"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_0_2_boost_1_78"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_0_2_boost_1_78">Multiprecision-4.0.2
        (Boost-1.78)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Rework rational_adaptor to remove dependency on Boost.Rational and improve
            performance.
          </li>
<li class="listitem">
            Fix issue with type_traits and clang, see <a href="https://github.com/boostorg/multiprecision/issues/383" target="_top">#383</a>.
          </li>
<li class="listitem">
            Fixed buggy Lehmer's GCD routine, see <a href="https://github.com/boostorg/multiprecision/issues/370" target="_top">#370</a>.
          </li>
<li class="listitem">
            Fix mpc_complex constructors so that lossy conversions are explicit,
            see <a href="https://github.com/boostorg/multiprecision/issues/363" target="_top">#363</a>.
          </li>
<li class="listitem">
            Correct miscellaneous configuration issues (Intel intrinsic usage and
            Apple clang).
          </li>
<li class="listitem">
            Correct some iostream operators for unsigned char types.
          </li>
<li class="listitem">
            Correct mpq_rational conversions to integer types, see <a href="https://github.com/boostorg/multiprecision/issues/342" target="_top">#342</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h4"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_0_1_boost_1_77"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_0_1_boost_1_77">Multiprecision-4.0.1
        (Boost-1.77)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Much improved Karatsuba sqrt for cpp_int/cpp_bin_float.
          </li>
<li class="listitem">
            Added C++11 compatible <code class="computeroutput"><span class="identifier">to_string</span></code>
            free function.
          </li>
<li class="listitem">
            Fixed bug in Lehmer GCD code, see <a href="https://github.com/boostorg/multiprecision/issues/322" target="_top">#322</a>.
          </li>
<li class="listitem">
            Fixed debug_adaptor/logged_adaptor to work better with complex, rational
            and interval types, see <a href="https://github.com/boostorg/multiprecision/issues/329" target="_top">#329</a>.
          </li>
<li class="listitem">
            Big update to mixed-variable precision arithmetic code with better options
            and thread safety, see <a class="link" href="../tut/variable.html" title="Variable Precision Arithmetic">docs</a>.
          </li>
<li class="listitem">
            Fixed up hashing of bools and enums when creating hash values.
          </li>
<li class="listitem">
            Improved conversions to and from enum types.
          </li>
<li class="listitem">
            Restricted use of Intel intrinsics to when we really are building for
            Intel even though the header may be available, see <a href="https://github.com/boostorg/multiprecision/issues/321" target="_top">#321</a>.
          </li>
<li class="listitem">
            Tidied up Lanczos approximation usage, in conjunction with Boost.Math
            this improves the reliability and accuracy of many special functions.
          </li>
<li class="listitem">
            Fix use of libtommath deprecated features.
          </li>
<li class="listitem">
            Fixed missing sqrt overload, see <a href="https://github.com/boostorg/multiprecision/issues/319" target="_top">#319</a>.
          </li>
<li class="listitem">
            Added Karatsuba multiplication to cpp_dec_float to bring it into line
            with the other types in this library.
          </li>
<li class="listitem">
            Added some minor optimizations to mpfr comparison operators.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h5"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_4_0_0_boost_1_76"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_4_0_0_boost_1_76">Multiprecision-4.0.0
        (Boost-1.76)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <span class="bold"><strong>BREAKING CHANGE</strong></span>: Massive refactoring
            and code simpification makes C++11 an absolute requirement.
          </li>
<li class="listitem">
            Use BOOST_TRY/CATCH in headers so code can be use din s=exception-free
            environments.
          </li>
<li class="listitem">
            Correct corner case in pow, fixes <a href="https://github.com/boostorg/multiprecision/issues/277" target="_top">#277</a>.
          </li>
<li class="listitem">
            Correct exception type thrown to match docs in lsb/msb: fixes <a href="https://github.com/boostorg/multiprecision/issues/257" target="_top">#257</a>.
          </li>
<li class="listitem">
            Allow moves and operators between related but different types (ie types
            with the same allocator), fixes <a href="https://github.com/boostorg/multiprecision/issues/278" target="_top">#278</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h6"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_2_5_boost_1_75"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_2_5_boost_1_75">Multiprecision-3.2.5
        (Boost-1.75)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Much improved gcd and modulus operations for <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>.
          </li>
<li class="listitem">
            Improved addition/subtraction routines for <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>
            via Intel's intrinsics.
          </li>
<li class="listitem">
            <a class="link" href="../tut/ints/gmp_int.html" title="gmp_int">gmp_int</a>:
            add better conversion routines for <code class="computeroutput"><span class="keyword">long</span>
            <span class="keyword">long</span></code> and <code class="computeroutput"><span class="identifier">__int128</span></code>.
          </li>
<li class="listitem">
            <a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>:
            Fix <code class="computeroutput"><span class="identifier">log1p</span></code> corner case.
          </li>
<li class="listitem">
            Improve accuracy of complex tan/tanh.
          </li>
<li class="listitem">
            Improve accuracy of trig functions for <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h7"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_2_4_boost_1_73"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_2_4_boost_1_73">Multiprecision-3.2.4
        (Boost-1.73)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            IMPORTANT: Mark C++03 support as deprecated and due for removal in 2021.
          </li>
<li class="listitem">
            Big update to <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>
            adds faster Karatsuba and Coomba multiplication routines.
          </li>
<li class="listitem">
            Fix conversion of <a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational">gmp_rational</a>
            to <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
            and <code class="computeroutput"><span class="identifier">__float128</span></code>, fixes
            <a href="https://github.com/boostorg/multiprecision/issues/178" target="_top">#178</a>.
          </li>
<li class="listitem">
            Fix up libtommath support to function with the latest libtom releases.
          </li>
<li class="listitem">
            Fix up some incompatibilities with the latest Intel C++ compiler.
          </li>
<li class="listitem">
            Fix up <code class="computeroutput"><span class="keyword">constexpr</span></code> arithmetic
            support for forthcoming MSVC release.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h8"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_2_3_boost_1_72"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_2_3_boost_1_72">Multiprecision-3.2.3
        (Boost-1.72)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            Big <code class="computeroutput"><span class="keyword">constexpr</span></code> update allows
            <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>
            and <a class="link" href="../tut/floats/float128.html" title="float128">float128</a>
            arithmetic to be fully <code class="computeroutput"><span class="keyword">constexpr</span></code>
            with gcc and clang 9 or later, or any compiler supporting <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>.
          </li></ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h9"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_1_3_boost_1_71"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_1_3_boost_1_71">Multiprecision-3.1.3
        (Boost-1.71)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Support hexfloat io-formatting for float128.
          </li>
<li class="listitem">
            Fix various bugs in variable precision interconversions.
          </li>
<li class="listitem">
            Respect uppercase for '0x' prefix outputs.
          </li>
<li class="listitem">
            Incorporate some unit tests from the Etherium project.
          </li>
<li class="listitem">
            Fix some gcc warnings.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h10"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_1_2_boost_1_70"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_1_2_boost_1_70">Multiprecision-3.1.2
        (Boost-1.70)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Fix various conversion issues in the traits classes, check for compatibility
            with Boost.Optional.
          </li>
<li class="listitem">
            Prevent instantiation of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
            on any old type when checking for convertibility. See <a href="https://github.com/boostorg/multiprecision/issues/98" target="_top">#98</a>.
          </li>
<li class="listitem">
            Update variable precision code to accound for arbitrary precision integers.
            See <a href="https://github.com/boostorg/multiprecision/issues/103" target="_top">#103</a>.
          </li>
<li class="listitem">
            Add support for XML serialization archives.
          </li>
<li class="listitem">
            Fix bug in fixed precision iostream formatting in <code class="computeroutput"><span class="identifier">mpf_float</span></code>
            and <code class="computeroutput"><span class="identifier">mpfr_float</span></code>. See
            <a href="https://github.com/boostorg/multiprecision/issues/113" target="_top">#113</a>.
          </li>
<li class="listitem">
            Add more overloads for special functions which are better handled natively
            by MPFR.
          </li>
<li class="listitem">
            Fixed bug in generic <code class="computeroutput"><span class="identifier">exp</span></code>
            implementation which could cause invariant failure.
          </li>
<li class="listitem">
            Fixed generic conversion from float to integer to avoid undefined behaviour.
            See <a href="https://github.com/boostorg/multiprecision/issues/110" target="_top">#110</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h11"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_1_1_boost_1_69"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_1_1_boost_1_69">Multiprecision-3.1.1
        (Boost-1.69)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Big update to better support variable precision types so that the precision
            of the result is always the largest of all the arguments.
          </li>
<li class="listitem">
            Add support for allocators that are <code class="computeroutput"><span class="identifier">final</span></code>
            in <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>.
          </li>
<li class="listitem">
            Removed use of deprecated Boost.Endian in favour of Predef.
          </li>
<li class="listitem">
            Add support for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string_view</span></code>.
          </li>
<li class="listitem">
            Fixed minor bug in constant initialization. See <a href="https://github.com/boostorg/multiprecision/issues/67" target="_top">#67</a>.
          </li>
<li class="listitem">
            Make assignment of non-finite value to <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            a runtime errors. See <a href="https://github.com/boostorg/multiprecision/issues/58" target="_top">#58</a>.
          </li>
<li class="listitem">
            Added typedefs for <code class="computeroutput"><span class="identifier">cpp_bin_float_oct</span></code>
            and <code class="computeroutput"><span class="identifier">cpp_complex_oct</span></code>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h12"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_1_0_boost_1_68"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_1_0_boost_1_68">Multiprecision-3.1.0
        (Boost-1.68)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Support added for complex multiprecision numbers.
          </li>
<li class="listitem">
            Changed conversion to unsigned integer types to be truncating to match
            standard defined behaviour.
          </li>
<li class="listitem">
            Correct bug in MPFR string formatting.
          </li>
<li class="listitem">
            Fix undefined behaviour in cpp_dec_float conversion from long long.
          </li>
<li class="listitem">
            Add support for Eigen interoperability.
          </li>
<li class="listitem">
            float128.hpp: Fix Intel on Windows build.
          </li>
<li class="listitem">
            Fix type used in temporaries when expanding expression templates containing
            mixed expressions.
          </li>
<li class="listitem">
            Fix infinite loop in gmp_float to fixed-point string conversion.
          </li>
<li class="listitem">
            Update the expression templates to issue static_asserts with better error
            messages when you try and do something unsupported.
          </li>
<li class="listitem">
            Fix bug in cpp_int where incrementing to zero doesn't set the sign correctly.
          </li>
<li class="listitem">
            Remove erroneous use of std::move, and rely on NVRO instead.
          </li>
<li class="listitem">
            Fix up support for changes to MPIR-3.0.
          </li>
<li class="listitem">
            Fix various conversion errors in cpp_bin_float when the exponent type
            is a <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">long</span></code>,
            or else we're converting to an integer that is wider than we are.
          </li>
<li class="listitem">
            Fix compatibility issue with GCC-8 caused by the introduction of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">byte</span></code>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h13"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_3_0_0_boost_1_67"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_3_0_0_boost_1_67">Multiprecision-3.0.0
        (Boost-1.67)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <span class="bold"><strong>Breaking Change:</strong></span> When converting a multiprecision
            integer to a narrower type, if the value is too large (or negative) to
            fit in the smaller type, then the result is either the maximum (or minimum)
            value of the target type. This was always the intended behaviour, but
            was somewhat haphazardly enforced before. If you really do want just
            the low order N bits of a value, then you will need to mask these out
            prior to the case, for example: <code class="computeroutput"><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">unsigned</span><span class="special">&gt;(~</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">unsigned</span><span class="special">&gt;(</span><span class="number">0</span><span class="special">)</span> <span class="special">&amp;</span> <span class="identifier">my_value</span><span class="special">)</span></code>.
            Note that technically (to avoid undefined behaviour) you should do the
            same thing with <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> integer types too. See <a href="https://svn.boost.org/trac/boost/ticket/13109" target="_top">#13109</a>.
          </li>
<li class="listitem">
            Fix bug in conversion of decimal to rational types (zero needs special
            handling), see <a href="https://svn.boost.org/trac/boost/ticket/13148" target="_top">#13148</a>.
          </li>
<li class="listitem">
            Fix conversion from cpp_bin_float to a wider <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> integer type, see <a href="https://svn.boost.org/trac/boost/ticket/13301" target="_top">#13301</a>.
          </li>
<li class="listitem">
            Improve performance heurists used in cpp_bin_float exp function.
          </li>
<li class="listitem">
            Fix bug in floor/ceil and cpp_bin_float when the exponent type is wider
            than an int, see <a href="https://svn.boost.org/trac/boost/ticket/13264" target="_top">#13264</a>.
          </li>
<li class="listitem">
            Disable explicit conversion operator when the target type is already
            constructible from this type, see <a href="https://github.com/boostorg/multiprecision/issues/30" target="_top">#30</a>.
          </li>
<li class="listitem">
            Fix support for changes new to MPIR-3.0, see <a href="https://svn.boost.org/trac/boost/ticket/13124" target="_top">#13124</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h14"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_3_2_boost_1_65"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_3_2_boost_1_65">Multiprecision-2.3.2
        (Boost-1.65)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Updated expression templates to store arithmetic literals directly in
            the expression template to prevent dangling references, see <a href="https://github.com/boostorg/multiprecision/issues/19" target="_top">#19</a>.
          </li>
<li class="listitem">
            Fix various issues with huge values and overflow in the trig, pow and
            exp functions, see <a href="https://github.com/boostorg/multiprecision/issues/24" target="_top">#24</a>.
          </li>
<li class="listitem">
            Fix error handling of checked cpp_int multiply that could cause some
            overflows to be missed.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h15"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_3_1_boost_1_64"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_3_1_boost_1_64">Multiprecision-2.3.1
        (Boost-1.64)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            In <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> prevent
            double rounding when converting to a denormalized float. See <a href="https://svn.boost.org/trac/boost/ticket/12527" target="_top">#12527</a>.
          </li>
<li class="listitem">
            Fix bug in integer sqrt for very small integers. See <a href="https://svn.boost.org/trac/boost/ticket/12559" target="_top">#12559</a>.
          </li>
<li class="listitem">
            Fix conversion to signed-zero in <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>.
          </li>
<li class="listitem">
            Change <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
            rounding code to round at arbitrary location so we can use it for conversions,
            see <a href="https://svn.boost.org/trac/boost/ticket/12527" target="_top">#12527</a>.
          </li>
<li class="listitem">
            Improve performance of 128-bit bit-scan operations.
          </li>
<li class="listitem">
            Fix subtraction of very small quantities in <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>.
            See: <a href="https://svn.boost.org/trac/boost/ticket/12580" target="_top">#12580</a>.
          </li>
<li class="listitem">
            Bring error handling into line with C99 Annex F. See <a href="https://svn.boost.org/trac/boost/ticket/12581" target="_top">#12581</a>.
          </li>
<li class="listitem">
            Fix bitwise export of trivial <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s,
            see <a href="https://svn.boost.org/trac/boost/ticket/12627" target="_top">#12627</a>.
          </li>
<li class="listitem">
            Fix <code class="computeroutput"><span class="identifier">ilogb</span></code> (and code that
            uses it) to consistently return the smallest value of the exponent type
            when the argument is zero, see <a href="https://svn.boost.org/trac/boost/ticket/12625" target="_top">#12625</a>.
          </li>
<li class="listitem">
            Allow conversion from <code class="computeroutput"><a class="link" href="../tut/floats/float128.html" title="float128">float128</a></code>
            to <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>.
          </li>
<li class="listitem">
            Fix bug in left shift of <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            which would result in bit-loss, see <a href="https://svn.boost.org/trac/boost/ticket/12790" target="_top">#12790</a>.
          </li>
<li class="listitem">
            Fixed bugs in bounded but variable precision <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s
            caused by over-aggressive constexpr optimization, see <a href="https://svn.boost.org/trac/boost/ticket/12798" target="_top">#12798</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h16"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_3_0_boost_1_63"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_3_0_boost_1_63">Multiprecision-2.3.0
        (Boost-1.63)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Added support for all the C99 math functions.
          </li>
<li class="listitem">
            Extended generic-interconversions to handle narrowing cases as well,
            changed convert_to member function and hence explicit conversion operators
            to use the same conversion code as the explicit constructors.
          </li>
<li class="listitem">
            Fix IO stream parsing error, see <a href="https://svn.boost.org/trac/boost/ticket/12488" target="_top">#12488</a>.
          </li>
<li class="listitem">
            Make default constructed floating point types all zero for consistency,
            see <a href="https://svn.boost.org/trac/boost/ticket/12500" target="_top">#12500</a>.
          </li>
<li class="listitem">
            Fix conversion of cpp_bin_float to float/double/long double when the
            exponent value would overflow an int, see <a href="https://svn.boost.org/trac/boost/ticket/12512" target="_top">#12512</a>.
          </li>
<li class="listitem">
            Fix cpp_bin_float subtractions that yield signed-zeros, see <a href="https://svn.boost.org/trac/boost/ticket/12524" target="_top">#12524</a>.
          </li>
<li class="listitem">
            Fix ceil/trunc/round applied to cpp_bin_float and yielding a signed zero,
            see <a href="https://svn.boost.org/trac/boost/ticket/12525" target="_top">#12525</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h17"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_8_boost_1_62"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_8_boost_1_62">Multiprecision-2.2.8
        (Boost-1.62)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Added support for hashing via <code class="computeroutput"><span class="identifier">Boost</span><span class="special">.</span><span class="identifier">Hash</span></code>
            or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">hash</span></code>.
          </li>
<li class="listitem">
            Fixed some arithmetic operations in cpp_bin_float and cpp_dec_float that
            should generate a NaN, see <a href="https://svn.boost.org/trac/boost/ticket/12157" target="_top">#12157</a>.
          </li>
<li class="listitem">
            Prevent inadvertant instantiation of variable-precision <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code> with fixed allocation.
          </li>
<li class="listitem">
            Fixed division over/underflow in cpp_bin_float, see <a href="https://svn.boost.org/trac/boost/ticket/12167" target="_top">#12167</a>.
          </li>
<li class="listitem">
            Added support for signed-zeros throughout the library, including support
            for <code class="computeroutput"><span class="identifier">signbit</span></code> and <code class="computeroutput"><span class="identifier">copysign</span></code>, mpfr, float128, and cpp_bin_float
            types should now respect signed-zeros correctly.
          </li>
<li class="listitem">
            Fixed bug in conversion of cpp_bin_float infinities to double etc, see
            <a href="https://svn.boost.org/trac/boost/ticket/12196" target="_top">#12196</a>.
          </li>
<li class="listitem">
            Fix add and subtract of cpp_bin_float when the exponents would overflow.,
            see <a href="https://svn.boost.org/trac/boost/ticket/12198" target="_top">#12198</a>.
          </li>
<li class="listitem">
            Improve variable-precision support in mpfr and mpf backends, allow these
            types to be used with Boost.Math.
          </li>
<li class="listitem">
            Fixed bug in subtraction of signed infinities in cpp_bin_float, see
            <a href="https://svn.boost.org/trac/boost/ticket/12209" target="_top">#12209</a>.
          </li>
<li class="listitem">
            Fix result of sqrt(infinity) in cpp_bin_float (result should be infinity),
            see <a href="https://svn.boost.org/trac/boost/ticket/12227" target="_top">#12227</a>.
          </li>
<li class="listitem">
            Added workaround in gmp.hpp for recent MPIR releases which are not quite
            source-compatible with GMP on Windows x64.
          </li>
<li class="listitem">
            Allow <code class="computeroutput"><span class="identifier">cpp_int</span></code> code to
            be used with /RTCc with MSVC.
          </li>
<li class="listitem">
            Fix conversion of <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            to signed integer when the result is INT_MIN, see <a href="https://svn.boost.org/trac/boost/ticket/12343" target="_top">#12343</a>.
          </li>
<li class="listitem">
            Update uBlas support to match latest uBlas code.
          </li>
<li class="listitem">
            Fix some errors present when building on big-endian machines (not all
            <code class="computeroutput"><span class="identifier">cpp_int</span></code> constructors
            are available on non-little-endian machines).
          </li>
<li class="listitem">
            Fix fencepost error in rational to float conversion routines, see <a href="https://svn.boost.org/trac/boost/ticket/12327" target="_top">#12327</a>.
          </li>
<li class="listitem">
            Fix some Oracle C++ compiler compatibility issues.
          </li>
<li class="listitem">
            Add modf support to complete C90 compatibility.
          </li>
<li class="listitem">
            Fix self assignment bug in expression template code for expressions such
            as <code class="computeroutput"><span class="identifier">a</span> <span class="special">=</span>
            <span class="identifier">a</span> <span class="special">*</span>
            <span class="identifier">a</span> <span class="special">*</span>
            <span class="identifier">a</span></code>, see <a href="https://svn.boost.org/trac/boost/ticket/12408" target="_top">#12408</a>.
          </li>
<li class="listitem">
            Fixed some compiler errors that occur when converting from <code class="computeroutput"><span class="identifier">cpp_int</span></code> to <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h18"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_7_boost_1_61"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_7_boost_1_61">Multiprecision-2.2.7
        (Boost-1.61)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Fixed bug in stream input for integer types, see <a href="https://svn.boost.org/trac/boost/ticket/11857" target="_top">#11857</a>.
          </li>
<li class="listitem">
            Fixed some ambiguous conversions involving expression templates see
            <a href="https://svn.boost.org/trac/boost/ticket/11922" target="_top">#11922</a>.
          </li>
<li class="listitem">
            Add expression template aware min/max overloads see <a href="https://svn.boost.org/trac/boost/ticket/11149" target="_top">#11149</a>.
          </li>
<li class="listitem">
            Fix bug in right shifting negative small integers in cpp_int see <a href="https://svn.boost.org/trac/boost/ticket/11999" target="_top">#11999</a>.
          </li>
<li class="listitem">
            Use memmove for bitshifts in cpp_int when possible see <a href="https://svn.boost.org/trac/boost/ticket/9233" target="_top">#9233</a>.
          </li>
<li class="listitem">
            Use memcpy for data import into cpp_int where possible, see <a href="https://svn.boost.org/trac/boost/ticket/9235" target="_top">#9235</a>.
          </li>
<li class="listitem">
            Changed <code class="computeroutput"><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;()</span></code> to a function template rather than
            proceding via <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
            to avoid double-rounding bug, see <a href="https://svn.boost.org/trac/boost/ticket/12039" target="_top">#12039</a>.
          </li>
<li class="listitem">
            Fixed conversions from NaNs and Infinities, see <a href="https://svn.boost.org/trac/boost/ticket/12112" target="_top">#12112</a>.
          </li>
<li class="listitem">
            Enabled better support for Clang on Windows.
          </li>
<li class="listitem">
            Fixed handling of NaNs and Infinities in basic arithmetic for cpp_dec_float
            and cpp_bin_float, see <a href="https://svn.boost.org/trac/boost/ticket/12090" target="_top">#12090</a>.
          </li>
<li class="listitem">
            Fixed fencepost error in cpp_bin_float subtraction.
          </li>
<li class="listitem">
            Fixed double-rounding in conversion to float routines for cpp_bin_float,
            see <a href="https://svn.boost.org/trac/boost/ticket/12039" target="_top">#12039</a>.
          </li>
<li class="listitem">
            Make float128 denorm aware, see <a href="https://svn.boost.org/trac/boost/ticket/12075" target="_top">#12075</a>.
          </li>
<li class="listitem">
            Allow the library and tests to be used without exception handling support,
            see <a href="https://svn.boost.org/trac/boost/ticket/12070" target="_top">#12070</a>.
          </li>
<li class="listitem">
            Fixed buggy comparison operator overloads for boost::rational.
          </li>
<li class="listitem">
            Added some workarounds for Oracle C++.
          </li>
<li class="listitem">
            Fixed some missing typecasts for cases where cpp_int's limb_type is wider
            than unsigned.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h19"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_6_boost_1_60"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_6_boost_1_60">Multiprecision-2.2.6
        (Boost-1.60)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Fixed result of Miller Rabin primality test for value 2, see <a href="https://svn.boost.org/trac/boost/ticket/11495" target="_top">#11495</a>.
          </li>
<li class="listitem">
            Improved initialization of cpp_int from very large strings of hex or
            octal digits, see <a href="https://svn.boost.org/trac/boost/ticket/11590" target="_top">#11590</a>.
          </li>
<li class="listitem">
            Fixed fmod behaviour for negative divisors, see <a href="https://svn.boost.org/trac/boost/ticket/11641" target="_top">#11641</a>.
          </li>
<li class="listitem">
            Fixed infinite division loop in cpp_int special case, see <a href="https://svn.boost.org/trac/boost/ticket/11648" target="_top">#11648</a>.
          </li>
<li class="listitem">
            Patched missing return statement in <a href="https://svn.boost.org/trac/boost/ticket/11762" target="_top">#11762</a>.
          </li>
<li class="listitem">
            Fixed mixed mode arithmetic compiler error in <a href="https://svn.boost.org/trac/boost/ticket/11764" target="_top">#11764</a>.
          </li>
<li class="listitem">
            Fixed over-aggressive use of noexcept in <a href="https://svn.boost.org/trac/boost/ticket/11826" target="_top">#11826</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h20"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_5_boost_1_59"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_5_boost_1_59">Multiprecision-2.2.5
        (Boost-1.59)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Depricated boost/multiprecision/random.hpp as it's no longer needed,
            updated random examples to match.
          </li>
<li class="listitem">
            Fixed a bug in <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            right shift operator when shifting negative values - semantics now gives
            the same values as shifting 2's compliment integers, though not the same
            bit pattern.
          </li>
<li class="listitem">
            Fixed support for GCC-4.6.4 in C++0x mode by disabling conditional noexcept
            suppoprt for that compiler see <a href="https://svn.boost.org/trac/boost/ticket/11402" target="_top">#11402</a>.
          </li>
<li class="listitem">
            Suppressed numerous compiler warnings.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h21"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_4_boost_1_58"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_4_boost_1_58">Multiprecision-2.2.4
        (Boost-1.58)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Changed <code class="computeroutput"><span class="identifier">frexp</span></code> to always
            be non-expression template generating, see: <a href="https://svn.boost.org/trac/boost/ticket/10993" target="_top">10993</a>.
          </li>
<li class="listitem">
            Improved support of cpp_dec_float on Cygwin and other platforms with
            missing long double support, see <a href="https://svn.boost.org/trac/boost/ticket/10924" target="_top">10924</a>.
          </li>
<li class="listitem">
            Improved noexcept support and added some more tests, see <a href="https://svn.boost.org/trac/boost/ticket/10990" target="_top">10990</a>.
          </li>
<li class="listitem">
            Various workarounds applied for Intel-15.0 and Solaris-12.4 compilers.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h22"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_3_boost_1_57"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_3_boost_1_57">Multiprecision-2.2.3
        (Boost-1.57)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Changed rational to float conversions to exactly round to nearest, see
            <a href="https://svn.boost.org/trac/boost/ticket/10085" target="_top">10085</a>.
          </li>
<li class="listitem">
            Added improved generic float to rational conversions.
          </li>
<li class="listitem">
            Fixed rare bug in exponent function for <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>.
          </li>
<li class="listitem">
            Fixed various minor documentation issues.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h23"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_2_boost_1_56"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_2_boost_1_56">Multiprecision-2.2.2
        (Boost-1.56)</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Change floating-point to rational conversions to be implicit, see <a href="https://svn.boost.org/trac/boost/ticket/10082" target="_top">10082</a>.
          </li>
<li class="listitem">
            Fix definition of checked_cpp_rational typedef.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h24"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_1"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_1">Multiprecision-2.2.1</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            Fix bug in assignment from string in cpp_int, see <a href="https://svn.boost.org/trac/boost/ticket/9936" target="_top">9936</a>.
          </li></ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h25"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.multiprecision_2_2_0"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.multiprecision_2_2_0">Multiprecision-2.2.0</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Moved to Boost.Multiprecision specific version number - we have one breaking
            change in Boost-1.54 which makes this major version 2, plus two releases
            with new features since then.
          </li>
<li class="listitem">
            Added new <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
            backend for binary floating-point.
          </li>
<li class="listitem">
            Added MSVC-specific #include for compiler intrinsics, see <a href="https://svn.boost.org/trac/boost/ticket/9336" target="_top">9336</a>.
          </li>
<li class="listitem">
            Fixed various typos in docs, see <a href="https://svn.boost.org/trac/boost/ticket/9432" target="_top">9432</a>.
          </li>
<li class="listitem">
            Fixed <a class="link" href="../tut/rational/gmp_rational.html" title="gmp_rational">gmp_rational</a>
            to allow move-copy from an already copied-from object, see <a href="https://svn.boost.org/trac/boost/ticket/9497" target="_top">9497</a>.
          </li>
<li class="listitem">
            Added list of values for numeric_limits.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h26"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.boost_1_55"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.boost_1_55">Boost-1.55</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Added support for Boost.Serialization.
          </li>
<li class="listitem">
            Suppressed some GCC warnings. See <a href="https://svn.boost.org/trac/boost/ticket/8872" target="_top">8872</a>.
          </li>
<li class="listitem">
            Fixed bug in pow for large integer arguments. See <a href="https://svn.boost.org/trac/boost/ticket/8809" target="_top">8809</a>.
          </li>
<li class="listitem">
            Fixed bug in pow for calculation of 0<sup>N</sup>. See <a href="https://svn.boost.org/trac/boost/ticket/8798" target="_top">8798</a>.
          </li>
<li class="listitem">
            Fixed bug in fixed precision cpp_int IO code that causes conversion to
            string to fail when the bit count is very small (less than CHAR_BIT).
            See <a href="https://svn.boost.org/trac/boost/ticket/8745" target="_top">8745</a>.
          </li>
<li class="listitem">
            Fixed bug in cpp_int that causes left shift to fail when a fixed precision
            type would overflow. See <a href="https://svn.boost.org/trac/boost/ticket/8741" target="_top">8741</a>.
          </li>
<li class="listitem">
            Fixed some cosmetic warnings from cpp_int. See <a href="https://svn.boost.org/trac/boost/ticket/8748" target="_top">8748</a>.
          </li>
<li class="listitem">
            Fixed calls to functions which are required to be macros in C99. See
            <a href="https://svn.boost.org/trac/boost/ticket/8732" target="_top">8732</a>.
          </li>
<li class="listitem">
            Fixed bug that causes construction from INT_MIN, LONG_MIN etc to fail
            in cpp_int. See <a href="https://svn.boost.org/trac/boost/ticket/8711" target="_top">8711</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h27"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.1_54"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_54">1.54</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <span class="bold"><strong>Breaking change</strong></span> renamed <code class="computeroutput"><span class="identifier">rational_adapter</span></code> to <code class="computeroutput"><span class="identifier">rational_adaptor</span></code>.
          </li>
<li class="listitem">
            Add support for <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>.
          </li>
<li class="listitem">
            Add logged_adaptor.
          </li>
<li class="listitem">
            Add support for 128-bit floats via GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
            or Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data
            types.
          </li>
<li class="listitem">
            Add support for user-defined literals in cpp_int, improve <code class="computeroutput"><span class="keyword">constexpr</span></code> support.
          </li>
<li class="listitem">
            Fixed bug in integer division of <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            that results in incorrect sign of <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            when both arguments are small enough to fit in a <code class="computeroutput"><span class="identifier">double_limb_type</span></code>.
            See <a href="https://svn.boost.org/trac/boost/ticket/8126" target="_top">8126</a>.
          </li>
<li class="listitem">
            Fixed bug in subtraction of a single limb in <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            that results in incorrect value when the result should have a 0 in the
            last limb: <a href="https://svn.boost.org/trac/boost/ticket/8133" target="_top">8133</a>.
          </li>
<li class="listitem">
            Fixed bug in <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            where division of 0 by something doesn't get zero in the result: <a href="https://svn.boost.org/trac/boost/ticket/8160" target="_top">8160</a>.
          </li>
<li class="listitem">
            Fixed bug in some transcendental functions that caused incorrect return
            values when variables are reused, for example with <code class="computeroutput"><span class="identifier">a</span>
            <span class="special">=</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span></code>. See <a href="https://svn.boost.org/trac/boost/ticket/8326" target="_top">8326</a>.
          </li>
<li class="listitem">
            Fixed some assignment operations in the mpfr and gmp backends to be safe
            if the target has been moved from: <a href="https://svn.boost.org/trac/boost/ticket/8326" target="_top">8667</a>.
          </li>
<li class="listitem">
            Fixed bug in <code class="computeroutput"><span class="identifier">cpp_int</span></code>
            that gives incorrect answer for 0%N for large N: <a href="https://svn.boost.org/trac/boost/ticket/8670" target="_top">8670</a>.
          </li>
<li class="listitem">
            Fixed set_precision in mpfr backend so it doesn't trample over an existing
            value: <a href="https://svn.boost.org/trac/boost/ticket/8692" target="_top">8692</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h28"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.1_53"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.1_53">1.53</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            First Release.
          </li>
<li class="listitem">
            Fix bug in <a href="https://svn.boost.org/trac/boost/ticket/7878" target="_top">cpp_int
            division</a>.
          </li>
<li class="listitem">
            Fix issue <a href="https://svn.boost.org/trac/boost/ticket/7806" target="_top">#7806</a>.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h29"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.post_review_changes"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.post_review_changes">Post
        review changes</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Non-expression template operators further optimised with rvalue reference
            support.
          </li>
<li class="listitem">
            Many functions made <code class="computeroutput"><span class="identifier">constexp</span></code>.
          </li>
<li class="listitem">
            Differentiate between explicit and implicit conversions in the number
            constructor.
          </li>
<li class="listitem">
            Removed "mp_" prefix from types.
          </li>
<li class="listitem">
            Allowed mixed precision arithmetic.
          </li>
<li class="listitem">
            Changed ExpressionTemplates parameter to class <code class="computeroutput"><span class="identifier">number</span></code>
            to use enumerated values rather than true/false.
          </li>
<li class="listitem">
            Changed ExpressionTemplate parameter default value to use a traits class
            so that the default value depends on the backend used.
          </li>
<li class="listitem">
            Added support for fused-multiply-add/subtract with GMP support.
          </li>
<li class="listitem">
            Tweaked expression template unpacking to use fewer temporaries when the
            LHS also appears in the RHS.
          </li>
<li class="listitem">
            Refactored <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>
            based on review comments with new template parameter structure.
          </li>
<li class="listitem">
            Added additional template parameter to <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>
            to allow stack-based allocation.
          </li>
<li class="listitem">
            Added section on mixed precision arithmetic, and added support for operations
            yielding a higher precision result than either of the arguments.
          </li>
<li class="listitem">
            Added overloads of integer-specific functions for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> integer types.
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.hist.h30"></a>
        <span class="phrase"><a name="boost_multiprecision.map.hist.pre_review_history"></a></span><a class="link" href="hist.html#boost_multiprecision.map.hist.pre_review_history">Pre-review
        history</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            2011-2012, John Maddock adds an expression template enabled front-end
            to Christopher's code, and adds support for other backends.
          </li>
<li class="listitem">
            2011, Christopher Kormanyos publishes the decimal floating-point code
            under the Boost Software Licence. The code is published as: <a href="http://doi.acm.org/10.1145/1916461.1916469" target="_top">"Algorithm
            910: A Portable C++ Multiple-Precision System for Special-Function Calculations"</a>,
            in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011.
          </li>
<li class="listitem">
            2002-2011, Christopher Kormanyos develops the all C++ decimal arithmetic
            floating-point code.
          </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../map.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="todo.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/map/todo.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>TODO</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../map.html" title="Roadmap">
<link rel="prev" href="hist.html" title="History">
<link rel="next" href="faq.html" title="FAQ">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="hist.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.map.todo"></a><a class="link" href="todo.html" title="TODO">TODO</a>
</h3></div></div></div>
<p>
        More a list of what <span class="emphasis"><em>could</em></span> be done, rather than what
        <span class="emphasis"><em>should</em></span> be done (which may be a much smaller list!).
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Add back-end support for libdecNumber.
          </li>
<li class="listitem">
            Add an adaptor back-end for complex number types.
          </li>
<li class="listitem">
            Add better multiplication routines (Karatsuba, FFT etc) to cpp_int_backend.
          </li>
<li class="listitem">
            Add assembly level routines to cpp_int_backend.
          </li>
<li class="listitem">
            Can ring types (exact floating-point types) be supported? The answer
            should be yes, but someone needs to write it, the hard part is IO and
            binary-decimal conversion.
          </li>
<li class="listitem">
            Should there be a choice of rounding mode (probably MPFR specific)?
          </li>
<li class="listitem">
            We can reuse temporaries in multiple subtrees (temporary caching).
          </li>
<li class="listitem">
            cpp_dec_float should round to nearest.
          </li>
<li class="listitem">
            A 2's complement fixed precision int that uses exactly N bits and no
            more.
          </li>
</ul></div>
<p>
        Things requested in review:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            The performances of mp_number&lt;a_trivial_adaptor&lt;float&gt;, false&gt;respect
            to float and mp_number&lt;a_trivial_adaptor&lt;int&gt;, false&gt; and
            int should be given to show the cost of using the generic interface (Mostly
            done, just need to update docs to the latest results).
          </li>
<li class="listitem">
            Should we provide min/max overloads for expression templates? (Not done
            - we can't overload functions declared in the std namespace :-( ).
          </li>
<li class="listitem">
            The rounding applied when converting must be documented (Done).
          </li>
<li class="listitem">
            Document why we don't abstract out addition/multiplication algorithms
            etc. (done - FAQ)
          </li>
<li class="listitem">
            Document why we don't use proto (compile times) (Done).
          </li>
<li class="listitem">
            We can reuse temporaries in multiple subtrees (temporary caching) Moved
            to TODO list.
          </li>
<li class="listitem">
            Emphasise in the docs that ET's may reorder operations (done 2012/10/31).
          </li>
<li class="listitem">
            Document what happens to small fixed precision cpp_int's (done 2012/10/31).
          </li>
<li class="listitem">
            The use of bool in template parameters could be improved by the use of
            an enum class which will be more explicit. E.g <code class="computeroutput"><span class="keyword">enum</span>
            <span class="keyword">class</span> <span class="identifier">expression_template</span>
            <span class="special">{</span><span class="identifier">disabled</span><span class="special">,</span> <span class="identifier">enabled</span><span class="special">};</span> <span class="keyword">enum</span> <span class="keyword">class</span> <span class="identifier">sign</span>
            <span class="special">{</span><span class="keyword">unsigned</span><span class="special">,</span> <span class="keyword">signed</span><span class="special">};</span></code> (Partly done 2012/09/15, done 2012/10/31).
          </li>
<li class="listitem">
            Each back-end should document the requirements it satisfies (not currently
            scheduled for inclusion: it's deliberately an implementation detail,
            and "optional" requirements are optimisations which can't be
            detected by the user). Not done: this is an implementation detail, the
            exact list of requirements satisfied is purely an optimization, not something
            the user can detect.
          </li>
<li class="listitem">
            A backend for an overflow aware integers (done 2012/10/31).
          </li>
<li class="listitem">
            IIUC convert_to is used to emulate in c++98 compilers C++11 explicit
            conversions. Could the explicit conversion operator be added on compilers
            supporting it? (Done 2012/09/15).
          </li>
<li class="listitem">
            The front-end should make the differences between implicit and explicit
            construction (Done 2012/09/15).
          </li>
<li class="listitem">
            The tutorial should add more examples concerning implicit or explicit
            conversions. (Done 2012/09/15).
          </li>
<li class="listitem">
            The documentation must explain how move semantics helps in this domain
            and what the backend needs to do to profit from this optimization. (Done
            2012/09/15).
          </li>
<li class="listitem">
            The documentation should contain Throws specification on the mp_number
            and backend requirements operations. (Done 2012/09/15).
          </li>
<li class="listitem">
            The library interface should use the noexcept (noexcept, ...) facilities
            (Done 2012/09/15).
          </li>
<li class="listitem">
            It is unfortunate that the generic mp_number front end can not make use
            constexpr as not all the backends can ensure this (done - we can go quite
            a way).
          </li>
<li class="listitem">
            literals: The library doesn't provide some kind of literals. I think
            that the mp_number class should provide a way to create literals if the
            backend is able to. (Done 2012/09/15).
          </li>
<li class="listitem">
            The ExpresionTemplate parameter could be defaulted to a traits class
            for more sensible defaults (done 2012/09/20).
          </li>
<li class="listitem">
            In a = exp1 op exp2 where a occurs inside one of exp1 or exp2 then we
            can optimise and eliminate one more temporary (done 2012/09/20).
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.map.todo.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.map.todo.pre_review_comments"></a></span><a class="link" href="todo.html#boost_multiprecision.map.todo.pre_review_comments">Pre-Review
        Comments</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Make fixed precision orthogonal to Allocator type in cpp_int. Possible
            solution - add an additional MaxBits template argument that defaults
            to 0 (meaning keep going till no more space/memory). Done.
          </li>
<li class="listitem">
            Can ring types (exact floating-point types) be supported? The answer
            should be yes, but someone needs to write it (Moved to TODO list).
          </li>
<li class="listitem">
            Should there be a choice of rounding mode (probably MPFR specific)? Moved
            to TODO list.
          </li>
<li class="listitem">
            Make the exponent type for cpp_dec_float a template parameter, maybe
            include support for big-integer exponents. Open question - what should
            be the default - int32_t or int64_t? (done 2012/09/06)
          </li>
<li class="listitem">
            Document the size requirements of fixed precision ints (done 2012/09/15).
          </li>
<li class="listitem">
            Document std lib function accuracy (done 2012/09/15).
          </li>
<li class="listitem">
            Be a bit clearer on the effects of sign-magnitude representation of cpp_int
            - min == -max etc - done.
          </li>
<li class="listitem">
            Document cpp_dec_float precision, rounding, and exponent size (done 2012/09/06).
          </li>
<li class="listitem">
            Can we be clearer in the docs that mixed arithmetic doesn't work (no
            longer applicable as of 2012/09/06)?
          </li>
<li class="listitem">
            Document round functions behaviour better (they behave as in C++11) (added
            note 2012/09/06).
          </li>
<li class="listitem">
            Document limits on size of cpp_dec_float (done 2012/09/06).
          </li>
<li class="listitem">
            Add support for fused multiply add (and subtract). GMP mpz_t could use
            this (done 2012/09/20).
          </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="hist.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../map.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/map.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Roadmap</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="perf/rational_performance.html" title="Rational Type Performance">
<link rel="next" href="map/hist.html" title="History">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="perf/rational_performance.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map/hist.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.map"></a><a class="link" href="map.html" title="Roadmap">Roadmap</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="map/hist.html">History</a></span></dt>
<dt><span class="section"><a href="map/todo.html">TODO</a></span></dt>
<dt><span class="section"><a href="map/faq.html">FAQ</a></span></dt>
<dt><span class="section"><a href="map/ack.html">Acknowledgements</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="perf/rational_performance.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map/hist.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/float_performance.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Float Algorithm Performance</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="rational_real_world.html" title="Rational Real World Tests">
<link rel="next" href="integer_performance.html" title="Integer Algorithm Performance">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rational_real_world.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.float_performance"></a><a class="link" href="float_performance.html" title="Float Algorithm Performance">Float Algorithm
      Performance</a>
</h3></div></div></div>
<p>
        Note that these tests are carefully designed to test performance of the underlying
        algorithms and not memory allocation or variable copying. As usual, performance
        results should be taken with a healthy dose of scepticism, and real-world
        performance may vary widely depending upon the specifics of the program.
        In each table relative times are given first, with the best performer given
        a score of 1. Total actual times are given in brackets, measured in seconds
        for 500000 operations.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.float_performance.operator"></a><p class="title"><b>Table 1.22. Operator *</b></p>
<div class="table-contents"><table class="table" summary="Operator *">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  4.45465 (0.0720574s)
                </p>
              </td>
<td>
                <p>
                  4.33995 (0.111688s)
                </p>
              </td>
<td>
                <p>
                  2.90491 (0.850904s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  3.82572 (0.061884s)
                </p>
              </td>
<td>
                <p>
                  5.06288 (0.130292s)
                </p>
              </td>
<td>
                <p>
                  5.77019 (1.6902s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  1.28958 (0.02086s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0257348s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.292919s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0161758s)
                </p>
              </td>
<td>
                <p>
                  2.57159 (0.0661794s)
                </p>
              </td>
<td>
                <p>
                  1.09888 (0.321884s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_int"></a><p class="title"><b>Table 1.23. Operator *(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(int)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  7.78457 (0.0399504s)
                </p>
              </td>
<td>
                <p>
                  8.32801 (0.0464923s)
                </p>
              </td>
<td>
                <p>
                  5.78369 (0.12206s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  12.2836 (0.0630393s)
                </p>
              </td>
<td>
                <p>
                  22.4215 (0.125171s)
                </p>
              </td>
<td>
                <p>
                  115.745 (2.44271s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00513201s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00558264s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0211042s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  6.55686 (0.0336498s)
                </p>
              </td>
<td>
                <p>
                  6.08531 (0.0339721s)
                </p>
              </td>
<td>
                <p>
                  3.75579 (0.0792629s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long"></a><p class="title"><b>Table 1.24. Operator *(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  3.96061 (0.0508387s)
                </p>
              </td>
<td>
                <p>
                  9.0225 (0.0540758s)
                </p>
              </td>
<td>
                <p>
                  3.84877 (0.0843974s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  5.80905 (0.0745654s)
                </p>
              </td>
<td>
                <p>
                  24.6321 (0.147631s)
                </p>
              </td>
<td>
                <p>
                  122.419 (2.68446s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0128361s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00599344s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0219284s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  2.15124 (0.0276134s)
                </p>
              </td>
<td>
                <p>
                  4.61073 (0.0276341s)
                </p>
              </td>
<td>
                <p>
                  2.31056 (0.0506668s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table 1.25. Operator *=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  6.54027 (0.0500366s)
                </p>
              </td>
<td>
                <p>
                  5.58857 (0.0547429s)
                </p>
              </td>
<td>
                <p>
                  3.33593 (0.0987612s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  9.23894 (0.0706828s)
                </p>
              </td>
<td>
                <p>
                  17.6238 (0.172634s)
                </p>
              </td>
<td>
                <p>
                  81.1437 (2.40228s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00765054s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00979552s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0296053s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  2.99517 (0.0229147s)
                </p>
              </td>
<td>
                <p>
                  3.55395 (0.0348128s)
                </p>
              </td>
<td>
                <p>
                  2.42098 (0.0716736s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator0"></a><p class="title"><b>Table 1.26. Operator +</b></p>
<div class="table-contents"><table class="table" summary="Operator +">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  2.61482 (0.0479759s)
                </p>
              </td>
<td>
                <p>
                  6.91285 (0.0901201s)
                </p>
              </td>
<td>
                <p>
                  8.04302 (0.219881s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.08384 (0.0198859s)
                </p>
              </td>
<td>
                <p>
                  1.6631 (0.0216812s)
                </p>
              </td>
<td>
                <p>
                  7.59843 (0.207727s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  1.00042 (0.0183555s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0130366s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0273382s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0183477s)
                </p>
              </td>
<td>
                <p>
                  1.4588 (0.0190178s)
                </p>
              </td>
<td>
                <p>
                  2.22935 (0.0609463s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_int0"></a><p class="title"><b>Table 1.27. Operator +(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(int)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  11.8195 (0.0524679s)
                </p>
              </td>
<td>
                <p>
                  13.9144 (0.0871804s)
                </p>
              </td>
<td>
                <p>
                  13.6745 (0.165014s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  3.22445 (0.0143136s)
                </p>
              </td>
<td>
                <p>
                  2.703 (0.0169356s)
                </p>
              </td>
<td>
                <p>
                  12.5227 (0.151114s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00443909s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00626549s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0120673s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  5.78563 (0.0256829s)
                </p>
              </td>
<td>
                <p>
                  4.78942 (0.0300081s)
                </p>
              </td>
<td>
                <p>
                  5.21353 (0.062913s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table 1.28. Operator +(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  21.4259 (0.109321s)
                </p>
              </td>
<td>
                <p>
                  16.4546 (0.128103s)
                </p>
              </td>
<td>
                <p>
                  14.7256 (0.16427s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  4.53931 (0.0231609s)
                </p>
              </td>
<td>
                <p>
                  3.75913 (0.0292658s)
                </p>
              </td>
<td>
                <p>
                  13.3516 (0.148942s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0051023s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00778526s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0111554s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  5.11905 (0.0261189s)
                </p>
              </td>
<td>
                <p>
                  3.73777 (0.0290995s)
                </p>
              </td>
<td>
                <p>
                  5.52758 (0.0616622s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table 1.29. Operator +=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  6.6778 (0.109847s)
                </p>
              </td>
<td>
                <p>
                  6.84045 (0.0942496s)
                </p>
              </td>
<td>
                <p>
                  9.09759 (0.157162s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.06799 (0.017568s)
                </p>
              </td>
<td>
                <p>
                  1.71962 (0.0236933s)
                </p>
              </td>
<td>
                <p>
                  10.7777 (0.186187s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0164496s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0137783s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0172751s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  3.47654 (0.0571878s)
                </p>
              </td>
<td>
                <p>
                  3.64857 (0.0502709s)
                </p>
              </td>
<td>
                <p>
                  4.56004 (0.0787754s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator1"></a><p class="title"><b>Table 1.30. Operator -</b></p>
<div class="table-contents"><table class="table" summary="Operator -">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  5.04597 (0.0688937s)
                </p>
              </td>
<td>
                <p>
                  4.65775 (0.0896788s)
                </p>
              </td>
<td>
                <p>
                  7.55005 (0.196627s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.42357 (0.0194363s)
                </p>
              </td>
<td>
                <p>
                  1.62766 (0.0313385s)
                </p>
              </td>
<td>
                <p>
                  8.16298 (0.21259s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0136532s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0192537s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0260432s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  1.76726 (0.0241287s)
                </p>
              </td>
<td>
                <p>
                  2.05663 (0.0395976s)
                </p>
              </td>
<td>
                <p>
                  2.48295 (0.0646638s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_int1"></a><p class="title"><b>Table 1.31. Operator -(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(int)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  6.31633 (0.0848243s)
                </p>
              </td>
<td>
                <p>
                  7.07646 (0.084402s)
                </p>
              </td>
<td>
                <p>
                  6.65523 (0.181209s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.6139 (0.0216737s)
                </p>
              </td>
<td>
                <p>
                  2.20945 (0.0263524s)
                </p>
              </td>
<td>
                <p>
                  5.27802 (0.14371s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0134294s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0119272s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0272281s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  5.1551 (0.0692297s)
                </p>
              </td>
<td>
                <p>
                  5.48391 (0.0654074s)
                </p>
              </td>
<td>
                <p>
                  2.6116 (0.0711089s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table 1.32. Operator -(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  9.08373 (0.102878s)
                </p>
              </td>
<td>
                <p>
                  4.54284 (0.0883961s)
                </p>
              </td>
<td>
                <p>
                  7.01771 (0.185162s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  2.19345 (0.0248419s)
                </p>
              </td>
<td>
                <p>
                  1.47898 (0.0287785s)
                </p>
              </td>
<td>
                <p>
                  5.71248 (0.150724s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0113255s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0194584s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.026385s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  5.35926 (0.0606961s)
                </p>
              </td>
<td>
                <p>
                  2.92255 (0.056868s)
                </p>
              </td>
<td>
                <p>
                  3.43277 (0.0905736s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table 1.33. Operator -=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  8.73347 (0.129938s)
                </p>
              </td>
<td>
                <p>
                  4.58762 (0.101449s)
                </p>
              </td>
<td>
                <p>
                  5.43827 (0.163157s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.67927 (0.0249846s)
                </p>
              </td>
<td>
                <p>
                  1.79526 (0.0396995s)
                </p>
              </td>
<td>
                <p>
                  6.63379 (0.199025s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0148782s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0221136s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0300017s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  3.96488 (0.0589902s)
                </p>
              </td>
<td>
                <p>
                  3.30899 (0.0731736s)
                </p>
              </td>
<td>
                <p>
                  3.51566 (0.105476s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator2"></a><p class="title"><b>Table 1.34. Operator /</b></p>
<div class="table-contents"><table class="table" summary="Operator /">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  5.40221 (0.549759s)
                </p>
              </td>
<td>
                <p>
                  10.0182 (1.39191s)
                </p>
              </td>
<td>
                <p>
                  12.3684 (5.32129s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  8.16505 (0.83092s)
                </p>
              </td>
<td>
                <p>
                  12.483 (1.73437s)
                </p>
              </td>
<td>
                <p>
                  52.8644 (22.744s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.101766s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.138938s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.430233s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  1.6699 (0.169939s)
                </p>
              </td>
<td>
                <p>
                  2.16251 (0.300455s)
                </p>
              </td>
<td>
                <p>
                  2.82683 (1.2162s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_int2"></a><p class="title"><b>Table 1.35. Operator /(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(int)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  5.81464 (0.141651s)
                </p>
              </td>
<td>
                <p>
                  12.2991 (0.271491s)
                </p>
              </td>
<td>
                <p>
                  8.20246 (0.643802s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  16.4865 (0.40163s)
                </p>
              </td>
<td>
                <p>
                  39.0331 (0.861622s)
                </p>
              </td>
<td>
                <p>
                  164 (12.8722s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0243611s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0220741s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0784889s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  2.25501 (0.0549347s)
                </p>
              </td>
<td>
                <p>
                  2.6832 (0.0592293s)
                </p>
              </td>
<td>
                <p>
                  1.60852 (0.126251s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table 1.36. Operator /(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  10.879 (0.19558s)
                </p>
              </td>
<td>
                <p>
                  10.4845 (0.244599s)
                </p>
              </td>
<td>
                <p>
                  8.82445 (0.621615s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  22.028 (0.396014s)
                </p>
              </td>
<td>
                <p>
                  42.4784 (0.991001s)
                </p>
              </td>
<td>
                <p>
                  201.351 (14.1836s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0179778s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0233296s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0704423s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  2.89723 (0.0520857s)
                </p>
              </td>
<td>
                <p>
                  2.6935 (0.0628383s)
                </p>
              </td>
<td>
                <p>
                  1.67233 (0.117803s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table 1.37. Operator /=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  11.0264 (0.215322s)
                </p>
              </td>
<td>
                <p>
                  7.78235 (0.256093s)
                </p>
              </td>
<td>
                <p>
                  8.31638 (0.638041s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  20.9412 (0.408938s)
                </p>
              </td>
<td>
                <p>
                  38.8146 (1.27727s)
                </p>
              </td>
<td>
                <p>
                  142.377 (10.9233s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0195279s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.032907s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.076721s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  2.67894 (0.0523141s)
                </p>
              </td>
<td>
                <p>
                  2.16678 (0.071302s)
                </p>
              </td>
<td>
                <p>
                  1.5964 (0.122477s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_construct"></a><p class="title"><b>Table 1.38. Operator construct</b></p>
<div class="table-contents"><table class="table" summary="Operator construct">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0030982s)
                </p>
              </td>
<td>
                <p>
                  1.37355 (0.00608929s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0152335s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  1.23911 (0.00383901s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00443324s)
                </p>
              </td>
<td>
                <p>
                  1.6806 (0.0256013s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  7.50258 (0.0232445s)
                </p>
              </td>
<td>
                <p>
                  5.47554 (0.0242744s)
                </p>
              </td>
<td>
                <p>
                  5.81062 (0.0885159s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  24.9598 (0.0773304s)
                </p>
              </td>
<td>
                <p>
                  19.5526 (0.0866815s)
                </p>
              </td>
<td>
                <p>
                  5.00378 (0.0762248s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table 1.39. Operator construct(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  2.08541 (0.0175206s)
                </p>
              </td>
<td>
                <p>
                  3.12821 (0.0267453s)
                </p>
              </td>
<td>
                <p>
                  1.32687 (0.0570308s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00840151s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00854971s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0429815s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  3.08163 (0.0258903s)
                </p>
              </td>
<td>
                <p>
                  2.44895 (0.0209379s)
                </p>
              </td>
<td>
                <p>
                  2.12806 (0.0914671s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  10.6814 (0.08974s)
                </p>
              </td>
<td>
                <p>
                  8.42482 (0.0720298s)
                </p>
              </td>
<td>
                <p>
                  1.8282 (0.0785786s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_construct_unsigned"></a><p class="title"><b>Table 1.40. Operator construct(unsigned)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  1.04974 (0.00808983s)
                </p>
              </td>
<td>
                <p>
                  1.38823 (0.0120486s)
                </p>
              </td>
<td>
                <p>
                  1.16321 (0.0530205s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00770653s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00867913s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0455813s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  3.88496 (0.0299395s)
                </p>
              </td>
<td>
                <p>
                  2.90503 (0.0252132s)
                </p>
              </td>
<td>
                <p>
                  1.82072 (0.0829907s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  13.3088 (0.102564s)
                </p>
              </td>
<td>
                <p>
                  8.41333 (0.0730204s)
                </p>
              </td>
<td>
                <p>
                  1.78408 (0.0813206s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.operator_str"></a><p class="title"><b>Table 1.41. Operator str</b></p>
<div class="table-contents"><table class="table" summary="Operator str">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  50 Bits
                </p>
              </th>
<th>
                <p>
                  100 Bits
                </p>
              </th>
<th>
                <p>
                  500 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float
                </p>
              </td>
<td>
                <p>
                  6.09659 (0.00301165s)
                </p>
              </td>
<td>
                <p>
                  4.71882 (0.0051705s)
                </p>
              </td>
<td>
                <p>
                  12.4899 (0.043165s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float
                </p>
              </td>
<td>
                <p>
                  2.94087 (0.00145276s)
                </p>
              </td>
<td>
                <p>
                  1.64843 (0.00180621s)
                </p>
              </td>
<td>
                <p>
                  3.16004 (0.0109211s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_float
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000493989s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00109572s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00345598s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float
                </p>
              </td>
<td>
                <p>
                  4.60349 (0.00227407s)
                </p>
              </td>
<td>
                <p>
                  1.21213 (0.00132816s)
                </p>
              </td>
<td>
                <p>
                  1.41569 (0.0048926s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.float_performance.platform"></a><p class="title"><b>Table 1.42. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rational_real_world.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/int_real_world.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Integer Real World Tests</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="realworld.html" title="Floating-Point Real World Tests">
<link rel="next" href="rational_real_world.html" title="Rational Real World Tests">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="realworld.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_real_world.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.int_real_world"></a><a class="link" href="int_real_world.html" title="Integer Real World Tests">Integer Real
      World Tests</a>
</h3></div></div></div>
<p>
        The first set of <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/voronoi_performance.cpp" target="_top">tests</a>
        measure the times taken to execute the multiprecision part of the Voronoi-diagram
        builder from Boost.Polygon. The tests mainly create a large number of temporaries
        "just in case" multiprecision arithmetic is required, for comparison,
        also included in the tests is Boost.Polygon's own partial-multiprecision
        integer type which was custom written for this specific task:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Integer Type
                </p>
              </th>
<th>
                <p>
                  Relative Performance (Actual time in parenthesis)
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  checked_int1024_t
                </p>
              </td>
<td>
                <p>
                  1.53714(0.0415328s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  checked_int256_t
                </p>
              </td>
<td>
                <p>
                  1.20715(0.0326167s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  checked_int512_t
                </p>
              </td>
<td>
                <p>
                  1.2587(0.0340095s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  1.80575(0.0487904s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  extended_int
                </p>
              </td>
<td>
                <p>
                  1.35652(0.0366527s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  int1024_t
                </p>
              </td>
<td>
                <p>
                  1.36237(0.0368107s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  int256_t
                </p>
              </td>
<td>
                <p>
                  1(0.0270196s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  int512_t
                </p>
              </td>
<td>
                <p>
                  1.0779(0.0291243s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpz_int
                </p>
              </td>
<td>
                <p>
                  3.83495(0.103619s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tom_int
                </p>
              </td>
<td>
                <p>
                  41.6378(1.12504s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        Note how for this use case, any dynamic allocation is a performance killer.
      </p>
<p>
        The next <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/miller_rabin_performance.cpp" target="_top">tests</a>
        measure the time taken to generate 1000 128-bit random numbers and test for
        primality using the Miller Rabin test. This is primarily a test of modular-exponentiation
        since that is the rate limiting step:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Integer Type
                </p>
              </th>
<th>
                <p>
                  Relative Performance (Actual time in parenthesis)
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  checked_uint1024_t
                </p>
              </td>
<td>
                <p>
                  9.52301(0.0422246s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  11.2194(0.0497465s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int (1024-bit cache)
                </p>
              </td>
<td>
                <p>
                  10.7941(0.0478607s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int (128-bit cache)
                </p>
              </td>
<td>
                <p>
                  11.0637(0.0490558s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int (256-bit cache)
                </p>
              </td>
<td>
                <p>
                  11.5069(0.0510209s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int (512-bit cache)
                </p>
              </td>
<td>
                <p>
                  10.3303(0.0458041s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int (no Expression templates)
                </p>
              </td>
<td>
                <p>
                  16.1792(0.0717379s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpz_int
                </p>
              </td>
<td>
                <p>
                  1.05106(0.00466034s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpz_int (no Expression templates)
                </p>
              </td>
<td>
                <p>
                  1(0.00443395s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tom_int
                </p>
              </td>
<td>
                <p>
                  5.10595(0.0226395s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tom_int (no Expression templates)
                </p>
              </td>
<td>
                <p>
                  61.9684(0.274765s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  uint1024_t
                </p>
              </td>
<td>
                <p>
                  9.32113(0.0413295s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        It's interesting to note that expression templates have little effect here
        - perhaps because the actual expressions involved are relatively trivial
        in this case - so the time taken for multiplication and division tends to
        dominate. The much quicker times from GMP and tommath are down to their much
        better modular-exponentiation algorithms (GMP's is about 5x faster). That's
        an issue which needs to be addressed in a future release for <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.int_real_world.platform"></a><p class="title"><b>Table 1.17. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="realworld.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_real_world.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/integer_performance.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Integer Algorithm Performance</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="float_performance.html" title="Float Algorithm Performance">
<link rel="next" href="rational_performance.html" title="Rational Type Performance">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="float_performance.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.integer_performance"></a><a class="link" href="integer_performance.html" title="Integer Algorithm Performance">Integer
      Algorithm Performance</a>
</h3></div></div></div>
<p>
        Note that these tests are carefully designed to test performance of the underlying
        algorithms and not memory allocation or variable copying. As usual, performance
        results should be taken with a healthy dose of scepticism, and real-world
        performance may vary widely depending upon the specifics of the program.
        In each table relative times are given first, with the best performer given
        a score of 1. Total actual times are given in brackets, measured in seconds
        for 500000 operations.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator"></a><p class="title"><b>Table 1.43. Operator %</b></p>
<div class="table-contents"><table class="table" summary="Operator %">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  1.51155 (0.0481508s)
                </p>
              </td>
<td>
                <p>
                  1.60666 (0.0825917s)
                </p>
              </td>
<td>
                <p>
                  1.75956 (0.127209s)
                </p>
              </td>
<td>
                <p>
                  1.87154 (0.171986s)
                </p>
              </td>
<td>
                <p>
                  2.58143 (0.368469s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.512768s)
                </p>
              </td>
<td>
                <p>
                  1.42429 (1.03083s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.96988s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0318553s)
                </p>
              </td>
<td>
                <p>
                  1.2913 (0.0663805s)
                </p>
              </td>
<td>
                <p>
                  1.33672 (0.0966394s)
                </p>
              </td>
<td>
                <p>
                  1.97924 (0.181883s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  1.4659 (0.0466966s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0514059s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0722958s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0918952s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.142738s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.24073s)
                </p>
              </td>
<td>
                <p>
                  1.17701 (0.603534s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.723753s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  27.46 (0.874748s)
                </p>
              </td>
<td>
                <p>
                  20.1749 (1.03711s)
                </p>
              </td>
<td>
                <p>
                  17.9774 (1.29969s)
                </p>
              </td>
<td>
                <p>
                  19.0867 (1.75398s)
                </p>
              </td>
<td>
                <p>
                  23.3789 (3.33706s)
                </p>
              </td>
<td>
                <p>
                  26.6546 (6.41658s)
                </p>
              </td>
<td>
                <p>
                  33.4553 (17.1548s)
                </p>
              </td>
<td>
                <p>
                  70.788 (51.233s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int"></a><p class="title"><b>Table 1.44. Operator %(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator %(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00790481s)
                </p>
              </td>
<td>
                <p>
                  1.45288 (0.0215141s)
                </p>
              </td>
<td>
                <p>
                  2.71488 (0.065874s)
                </p>
              </td>
<td>
                <p>
                  4.05695 (0.1044s)
                </p>
              </td>
<td>
                <p>
                  6.59285 (0.288068s)
                </p>
              </td>
<td>
                <p>
                  3.58045 (0.429244s)
                </p>
              </td>
<td>
                <p>
                  6.18417 (0.851447s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.57951s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  2.18748 (0.0172916s)
                </p>
              </td>
<td>
                <p>
                  1.67119 (0.0247468s)
                </p>
              </td>
<td>
                <p>
                  2.83861 (0.0688759s)
                </p>
              </td>
<td>
                <p>
                  4.3186 (0.111133s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  1.50165 (0.0118703s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0148079s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.024264s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0257336s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0436939s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0571251s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.119886s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.137682s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  68.9623 (0.545134s)
                </p>
              </td>
<td>
                <p>
                  54.52 (0.807325s)
                </p>
              </td>
<td>
                <p>
                  38.3573 (0.930702s)
                </p>
              </td>
<td>
                <p>
                  53.0833 (1.36603s)
                </p>
              </td>
<td>
                <p>
                  59.6958 (2.60834s)
                </p>
              </td>
<td>
                <p>
                  103.597 (5.91797s)
                </p>
              </td>
<td>
                <p>
                  133.648 (16.0225s)
                </p>
              </td>
<td>
                <p>
                  392.812 (54.083s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator0"></a><p class="title"><b>Table 1.45. Operator &amp;</b></p>
<div class="table-contents"><table class="table" summary="Operator &amp;">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.82137 (0.0101034s)
                </p>
              </td>
<td>
                <p>
                  3.08842 (0.0128886s)
                </p>
              </td>
<td>
                <p>
                  3.46566 (0.018172s)
                </p>
              </td>
<td>
                <p>
                  2.55025 (0.0204051s)
                </p>
              </td>
<td>
                <p>
                  2.97241 (0.0461406s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0440714s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0811524s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.146531s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00358104s)
                </p>
              </td>
<td>
                <p>
                  1.5374 (0.00641591s)
                </p>
              </td>
<td>
                <p>
                  1.70378 (0.0089337s)
                </p>
              </td>
<td>
                <p>
                  2.40825 (0.019269s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  1.10071 (0.00394167s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00417321s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00524347s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00800121s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.015523s)
                </p>
              </td>
<td>
                <p>
                  1.04806 (0.0384586s)
                </p>
              </td>
<td>
                <p>
                  2.0133 (0.0887291s)
                </p>
              </td>
<td>
                <p>
                  1.38531 (0.112421s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  2.18066 (0.00780901s)
                </p>
              </td>
<td>
                <p>
                  2.22528 (0.00928657s)
                </p>
              </td>
<td>
                <p>
                  2.15567 (0.0113032s)
                </p>
              </td>
<td>
                <p>
                  3.05906 (0.0244762s)
                </p>
              </td>
<td>
                <p>
                  2.34741 (0.0364387s)
                </p>
              </td>
<td>
                <p>
                  1.50551 (0.0552444s)
                </p>
              </td>
<td>
                <p>
                  2.29355 (0.10108s)
                </p>
              </td>
<td>
                <p>
                  3.0313 (0.245997s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int0"></a><p class="title"><b>Table 1.46. Operator &amp;(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator &amp;(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  3.24695 (0.0124861s)
                </p>
              </td>
<td>
                <p>
                  1.81002 (0.0114113s)
                </p>
              </td>
<td>
                <p>
                  2.11984 (0.0179186s)
                </p>
              </td>
<td>
                <p>
                  2.56949 (0.0262296s)
                </p>
              </td>
<td>
                <p>
                  3.62157 (0.063826s)
                </p>
              </td>
<td>
                <p>
                  3.95427 (0.0593859s)
                </p>
              </td>
<td>
                <p>
                  4.84754 (0.102968s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.168385s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0038455s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00630453s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00845281s)
                </p>
              </td>
<td>
                <p>
                  2.20848 (0.0225444s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  3.87448 (0.0148993s)
                </p>
              </td>
<td>
                <p>
                  1.50343 (0.00947844s)
                </p>
              </td>
<td>
                <p>
                  1.59793 (0.013507s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0102081s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0176239s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0121449s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0150182s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0212413s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  25.1094 (0.0965583s)
                </p>
              </td>
<td>
                <p>
                  15.7147 (0.0990734s)
                </p>
              </td>
<td>
                <p>
                  9.65097 (0.0815778s)
                </p>
              </td>
<td>
                <p>
                  8.5208 (0.0869813s)
                </p>
              </td>
<td>
                <p>
                  5.74798 (0.101302s)
                </p>
              </td>
<td>
                <p>
                  10.598 (0.128712s)
                </p>
              </td>
<td>
                <p>
                  12.0534 (0.18102s)
                </p>
              </td>
<td>
                <p>
                  13.0183 (0.276527s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator1"></a><p class="title"><b>Table 1.47. Operator *</b></p>
<div class="table-contents"><table class="table" summary="Operator *">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  12.4201 (0.0145016s)
                </p>
              </td>
<td>
                <p>
                  1.838 (0.0246772s)
                </p>
              </td>
<td>
                <p>
                  2.10406 (0.0631704s)
                </p>
              </td>
<td>
                <p>
                  2.22846 (0.224062s)
                </p>
              </td>
<td>
                <p>
                  2.53789 (0.918685s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (2.65154s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (7.83314s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (26.1836s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00116759s)
                </p>
              </td>
<td>
                <p>
                  1.76789 (0.0237359s)
                </p>
              </td>
<td>
                <p>
                  1.58515 (0.047591s)
                </p>
              </td>
<td>
                <p>
                  1.52628 (0.153461s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  4.80091 (0.00560549s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0134261s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0300231s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.100546s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.361988s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.11701s)
                </p>
              </td>
<td>
                <p>
                  2.08347 (5.52441s)
                </p>
              </td>
<td>
                <p>
                  1.44767 (11.3398s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  16.9604 (0.0198027s)
                </p>
              </td>
<td>
                <p>
                  2.43157 (0.0326465s)
                </p>
              </td>
<td>
                <p>
                  2.82213 (0.0847288s)
                </p>
              </td>
<td>
                <p>
                  1.67653 (0.168568s)
                </p>
              </td>
<td>
                <p>
                  1.27293 (0.460786s)
                </p>
              </td>
<td>
                <p>
                  1.41678 (1.58255s)
                </p>
              </td>
<td>
                <p>
                  2.69181 (7.13744s)
                </p>
              </td>
<td>
                <p>
                  3.30421 (25.8824s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int1"></a><p class="title"><b>Table 1.48. Operator *(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  10.9781 (0.0072726s)
                </p>
              </td>
<td>
                <p>
                  1.52901 (0.00991594s)
                </p>
              </td>
<td>
                <p>
                  3.35266 (0.0194072s)
                </p>
              </td>
<td>
                <p>
                  2.30215 (0.0214459s)
                </p>
              </td>
<td>
                <p>
                  1.95214 (0.047049s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0576663s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0955853s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.167493s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000662467s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00648519s)
                </p>
              </td>
<td>
                <p>
                  1.52643 (0.0088359s)
                </p>
              </td>
<td>
                <p>
                  2.26708 (0.0211192s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  7.14641 (0.00473426s)
                </p>
              </td>
<td>
                <p>
                  1.74133 (0.0112929s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00578859s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00931559s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0241013s)
                </p>
              </td>
<td>
                <p>
                  1.12075 (0.0477494s)
                </p>
              </td>
<td>
                <p>
                  1.96831 (0.113505s)
                </p>
              </td>
<td>
                <p>
                  1.44107 (0.137745s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  156.154 (0.103447s)
                </p>
              </td>
<td>
                <p>
                  14.5292 (0.0942242s)
                </p>
              </td>
<td>
                <p>
                  16.82 (0.0973642s)
                </p>
              </td>
<td>
                <p>
                  11.9029 (0.110883s)
                </p>
              </td>
<td>
                <p>
                  5.61803 (0.135402s)
                </p>
              </td>
<td>
                <p>
                  4.61241 (0.196512s)
                </p>
              </td>
<td>
                <p>
                  5.30415 (0.30587s)
                </p>
              </td>
<td>
                <p>
                  5.73424 (0.548109s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long"></a><p class="title"><b>Table 1.49. Operator *(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  8.98335 (0.00669928s)
                </p>
              </td>
<td>
                <p>
                  1.79861 (0.00820918s)
                </p>
              </td>
<td>
                <p>
                  1.86924 (0.0119122s)
                </p>
              </td>
<td>
                <p>
                  1.71773 (0.0175683s)
                </p>
              </td>
<td>
                <p>
                  2.57826 (0.0539343s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0432066s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0813634s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.159452s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000745744s)
                </p>
              </td>
<td>
                <p>
                  1.07211 (0.00489332s)
                </p>
              </td>
<td>
                <p>
                  1.19888 (0.00764018s)
                </p>
              </td>
<td>
                <p>
                  1.53618 (0.0157115s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  4.97741 (0.00371188s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00456418s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00637276s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0102277s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0209189s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0321931s)
                </p>
              </td>
<td>
                <p>
                  2.05197 (0.0886586s)
                </p>
              </td>
<td>
                <p>
                  1.59261 (0.12958s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  143.938 (0.107341s)
                </p>
              </td>
<td>
                <p>
                  24.0751 (0.109883s)
                </p>
              </td>
<td>
                <p>
                  16.9325 (0.107907s)
                </p>
              </td>
<td>
                <p>
                  11.5473 (0.118102s)
                </p>
              </td>
<td>
                <p>
                  8.08283 (0.169084s)
                </p>
              </td>
<td>
                <p>
                  6.84808 (0.220461s)
                </p>
              </td>
<td>
                <p>
                  8.37134 (0.361697s)
                </p>
              </td>
<td>
                <p>
                  8.20104 (0.667264s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table 1.50. Operator *=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  15.7803 (0.0131299s)
                </p>
              </td>
<td>
                <p>
                  1.67116 (0.00790233s)
                </p>
              </td>
<td>
                <p>
                  1.66661 (0.0119079s)
                </p>
              </td>
<td>
                <p>
                  1.51408 (0.0203561s)
                </p>
              </td>
<td>
                <p>
                  1.23815 (0.0373067s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0424701s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0946934s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.177219s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000832044s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00472864s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00714494s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0134446s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  6.73473 (0.00560359s)
                </p>
              </td>
<td>
                <p>
                  1.81651 (0.00858963s)
                </p>
              </td>
<td>
                <p>
                  1.36813 (0.00977523s)
                </p>
              </td>
<td>
                <p>
                  1.00404 (0.0134989s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0301309s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0457849s)
                </p>
              </td>
<td>
                <p>
                  2.56449 (0.108914s)
                </p>
              </td>
<td>
                <p>
                  2.20384 (0.208689s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  115.266 (0.0959064s)
                </p>
              </td>
<td>
                <p>
                  24.7701 (0.117129s)
                </p>
              </td>
<td>
                <p>
                  15.9941 (0.114277s)
                </p>
              </td>
<td>
                <p>
                  11.3798 (0.152996s)
                </p>
              </td>
<td>
                <p>
                  5.69861 (0.171704s)
                </p>
              </td>
<td>
                <p>
                  5.47882 (0.250847s)
                </p>
              </td>
<td>
                <p>
                  10.6875 (0.453899s)
                </p>
              </td>
<td>
                <p>
                  7.29439 (0.690731s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator2"></a><p class="title"><b>Table 1.51. Operator +</b></p>
<div class="table-contents"><table class="table" summary="Operator +">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  9.80738 (0.0086037s)
                </p>
              </td>
<td>
                <p>
                  2.34204 (0.0160922s)
                </p>
              </td>
<td>
                <p>
                  1.00627 (0.0131305s)
                </p>
              </td>
<td>
                <p>
                  1.67865 (0.0163002s)
                </p>
              </td>
<td>
                <p>
                  1.88916 (0.033949s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0412289s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.083134s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.190174s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000877268s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00687102s)
                </p>
              </td>
<td>
                <p>
                  1.82016 (0.0237507s)
                </p>
              </td>
<td>
                <p>
                  1.90391 (0.0184876s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  5.87168 (0.00515104s)
                </p>
              </td>
<td>
                <p>
                  1.45191 (0.00997612s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0130487s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00971031s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0179704s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0300729s)
                </p>
              </td>
<td>
                <p>
                  1.96754 (0.0811195s)
                </p>
              </td>
<td>
                <p>
                  1.62045 (0.134715s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  13.6707 (0.0119929s)
                </p>
              </td>
<td>
                <p>
                  1.03266 (0.00709542s)
                </p>
              </td>
<td>
                <p>
                  1.02249 (0.0133422s)
                </p>
              </td>
<td>
                <p>
                  1.4749 (0.0143218s)
                </p>
              </td>
<td>
                <p>
                  1.17551 (0.0211244s)
                </p>
              </td>
<td>
                <p>
                  1.08462 (0.0326177s)
                </p>
              </td>
<td>
                <p>
                  1.47125 (0.060658s)
                </p>
              </td>
<td>
                <p>
                  2.75813 (0.229295s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int2"></a><p class="title"><b>Table 1.52. Operator +(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  7.65014 (0.00534018s)
                </p>
              </td>
<td>
                <p>
                  1.8992 (0.0063589s)
                </p>
              </td>
<td>
                <p>
                  1.56778 (0.00666443s)
                </p>
              </td>
<td>
                <p>
                  1.29719 (0.00836612s)
                </p>
              </td>
<td>
                <p>
                  1.73231 (0.0204874s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0198385s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0338486s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0760202s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000698051s)
                </p>
              </td>
<td>
                <p>
                  1.72665 (0.00578118s)
                </p>
              </td>
<td>
                <p>
                  1.57164 (0.00668085s)
                </p>
              </td>
<td>
                <p>
                  1.90796 (0.0123052s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  4.97679 (0.00347405s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0033482s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00425087s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0064494s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0118266s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0195694s)
                </p>
              </td>
<td>
                <p>
                  3.53343 (0.0700979s)
                </p>
              </td>
<td>
                <p>
                  2.28146 (0.0772241s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  127.407 (0.0889366s)
                </p>
              </td>
<td>
                <p>
                  24.8716 (0.0832749s)
                </p>
              </td>
<td>
                <p>
                  20.4864 (0.0870848s)
                </p>
              </td>
<td>
                <p>
                  12.5462 (0.0809152s)
                </p>
              </td>
<td>
                <p>
                  7.07209 (0.083639s)
                </p>
              </td>
<td>
                <p>
                  4.79434 (0.0938225s)
                </p>
              </td>
<td>
                <p>
                  5.93694 (0.11778s)
                </p>
              </td>
<td>
                <p>
                  5.20775 (0.176275s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table 1.53. Operator +(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  9.92952 (0.00893714s)
                </p>
              </td>
<td>
                <p>
                  2.68575 (0.0136811s)
                </p>
              </td>
<td>
                <p>
                  1.73024 (0.0102989s)
                </p>
              </td>
<td>
                <p>
                  1.43961 (0.0115471s)
                </p>
              </td>
<td>
                <p>
                  1.46556 (0.0237404s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0253811s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0350422s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0761856s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000900057s)
                </p>
              </td>
<td>
                <p>
                  1.27396 (0.00648945s)
                </p>
              </td>
<td>
                <p>
                  1.38787 (0.008261s)
                </p>
              </td>
<td>
                <p>
                  1.56798 (0.0125768s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  5.22669 (0.00470432s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00509394s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00595229s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00802101s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0161988s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0174726s)
                </p>
              </td>
<td>
                <p>
                  1.83602 (0.0466003s)
                </p>
              </td>
<td>
                <p>
                  1.90731 (0.0668364s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  100.859 (0.0907784s)
                </p>
              </td>
<td>
                <p>
                  19.2654 (0.0981367s)
                </p>
              </td>
<td>
                <p>
                  14.4537 (0.0860324s)
                </p>
              </td>
<td>
                <p>
                  10.0594 (0.0806864s)
                </p>
              </td>
<td>
                <p>
                  5.71755 (0.0926177s)
                </p>
              </td>
<td>
                <p>
                  6.23483 (0.108939s)
                </p>
              </td>
<td>
                <p>
                  4.63528 (0.117648s)
                </p>
              </td>
<td>
                <p>
                  5.01743 (0.175822s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table 1.54. Operator +=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  12.2366 (0.0106404s)
                </p>
              </td>
<td>
                <p>
                  1.48157 (0.00996803s)
                </p>
              </td>
<td>
                <p>
                  1.58862 (0.0108279s)
                </p>
              </td>
<td>
                <p>
                  2.06658 (0.0131949s)
                </p>
              </td>
<td>
                <p>
                  1.1631 (0.0186902s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0218483s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0394761s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0783171s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000869555s)
                </p>
              </td>
<td>
                <p>
                  1.34779 (0.00906799s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00681593s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00638493s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  11.3522 (0.00987134s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00672804s)
                </p>
              </td>
<td>
                <p>
                  1.27495 (0.00868995s)
                </p>
              </td>
<td>
                <p>
                  2.42237 (0.0154667s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0160693s)
                </p>
              </td>
<td>
                <p>
                  1.09672 (0.0221405s)
                </p>
              </td>
<td>
                <p>
                  2.61199 (0.0570676s)
                </p>
              </td>
<td>
                <p>
                  2.13093 (0.0841208s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  88.4252 (0.0768906s)
                </p>
              </td>
<td>
                <p>
                  14.139 (0.0951277s)
                </p>
              </td>
<td>
                <p>
                  11.6282 (0.0792569s)
                </p>
              </td>
<td>
                <p>
                  14.5551 (0.0929332s)
                </p>
              </td>
<td>
                <p>
                  6.86867 (0.110375s)
                </p>
              </td>
<td>
                <p>
                  5.67471 (0.11456s)
                </p>
              </td>
<td>
                <p>
                  7.29502 (0.159384s)
                </p>
              </td>
<td>
                <p>
                  5.733 (0.226317s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator3"></a><p class="title"><b>Table 1.55. Operator -</b></p>
<div class="table-contents"><table class="table" summary="Operator -">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  4.45457 (0.00859678s)
                </p>
              </td>
<td>
                <p>
                  1.28478 (0.013219s)
                </p>
              </td>
<td>
                <p>
                  1.27873 (0.0117779s)
                </p>
              </td>
<td>
                <p>
                  1.43649 (0.0151597s)
                </p>
              </td>
<td>
                <p>
                  2.82516 (0.0507822s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0463464s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0813138s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.191562s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00192988s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.010289s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00921062s)
                </p>
              </td>
<td>
                <p>
                  1.5372 (0.0162226s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  3.4436 (0.00664573s)
                </p>
              </td>
<td>
                <p>
                  1.25045 (0.0128659s)
                </p>
              </td>
<td>
                <p>
                  1.10953 (0.0102195s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0105533s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.017975s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0321962s)
                </p>
              </td>
<td>
                <p>
                  2.54862 (0.11812s)
                </p>
              </td>
<td>
                <p>
                  1.83623 (0.14931s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  9.3224 (0.0179911s)
                </p>
              </td>
<td>
                <p>
                  1.08796 (0.011194s)
                </p>
              </td>
<td>
                <p>
                  1.93265 (0.017801s)
                </p>
              </td>
<td>
                <p>
                  1.82306 (0.0192393s)
                </p>
              </td>
<td>
                <p>
                  1.55663 (0.0279804s)
                </p>
              </td>
<td>
                <p>
                  1.6544 (0.0532653s)
                </p>
              </td>
<td>
                <p>
                  1.90928 (0.0884881s)
                </p>
              </td>
<td>
                <p>
                  4.41259 (0.358805s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int3"></a><p class="title"><b>Table 1.56. Operator -(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  3.07164 (0.00347144s)
                </p>
              </td>
<td>
                <p>
                  1.38957 (0.00531251s)
                </p>
              </td>
<td>
                <p>
                  1.29053 (0.00548206s)
                </p>
              </td>
<td>
                <p>
                  1.35239 (0.00759591s)
                </p>
              </td>
<td>
                <p>
                  1.50007 (0.0176467s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0209158s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0402632s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0674681s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00113016s)
                </p>
              </td>
<td>
                <p>
                  1.26281 (0.00482789s)
                </p>
              </td>
<td>
                <p>
                  1.25074 (0.00531307s)
                </p>
              </td>
<td>
                <p>
                  3.3923 (0.0190533s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  3.22069 (0.00363988s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00382312s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00424793s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00561665s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0117639s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0225873s)
                </p>
              </td>
<td>
                <p>
                  2.75829 (0.0576919s)
                </p>
              </td>
<td>
                <p>
                  2.03214 (0.0818204s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  81.1433 (0.0917047s)
                </p>
              </td>
<td>
                <p>
                  21.4543 (0.0820224s)
                </p>
              </td>
<td>
                <p>
                  19.3098 (0.0820267s)
                </p>
              </td>
<td>
                <p>
                  16.2994 (0.0915478s)
                </p>
              </td>
<td>
                <p>
                  7.23608 (0.0851246s)
                </p>
              </td>
<td>
                <p>
                  4.48441 (0.101291s)
                </p>
              </td>
<td>
                <p>
                  5.51882 (0.115431s)
                </p>
              </td>
<td>
                <p>
                  4.44737 (0.179066s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table 1.57. Operator -(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  7.02787 (0.00807189s)
                </p>
              </td>
<td>
                <p>
                  1.85949 (0.00922027s)
                </p>
              </td>
<td>
                <p>
                  1.40179 (0.00830959s)
                </p>
              </td>
<td>
                <p>
                  1.22546 (0.00988039s)
                </p>
              </td>
<td>
                <p>
                  1.27526 (0.0235442s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0242017s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0317445s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0783054s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00114855s)
                </p>
              </td>
<td>
                <p>
                  1.03947 (0.00515424s)
                </p>
              </td>
<td>
                <p>
                  1.22566 (0.00726552s)
                </p>
              </td>
<td>
                <p>
                  1.56568 (0.0126235s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  7.54669 (0.00866778s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0049585s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00592785s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00806262s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0184622s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0220616s)
                </p>
              </td>
<td>
                <p>
                  1.79985 (0.0435595s)
                </p>
              </td>
<td>
                <p>
                  2.08427 (0.0661641s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  72.1332 (0.0828488s)
                </p>
              </td>
<td>
                <p>
                  18.985 (0.0941371s)
                </p>
              </td>
<td>
                <p>
                  13.9301 (0.0825755s)
                </p>
              </td>
<td>
                <p>
                  9.93889 (0.0801335s)
                </p>
              </td>
<td>
                <p>
                  5.42256 (0.100113s)
                </p>
              </td>
<td>
                <p>
                  4.58437 (0.101139s)
                </p>
              </td>
<td>
                <p>
                  4.91664 (0.118991s)
                </p>
              </td>
<td>
                <p>
                  5.5407 (0.175887s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table 1.58. Operator -=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  10.8565 (0.0103583s)
                </p>
              </td>
<td>
                <p>
                  2.00541 (0.0102937s)
                </p>
              </td>
<td>
                <p>
                  1.73348 (0.0103591s)
                </p>
              </td>
<td>
                <p>
                  2.53718 (0.0189898s)
                </p>
              </td>
<td>
                <p>
                  1.21308 (0.0265754s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0249248s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0377524s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.070851s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000954108s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00513296s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00597589s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00748462s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  6.6602 (0.00635455s)
                </p>
              </td>
<td>
                <p>
                  1.61345 (0.00828179s)
                </p>
              </td>
<td>
                <p>
                  1.41745 (0.00847054s)
                </p>
              </td>
<td>
                <p>
                  1.41728 (0.0106078s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0219074s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0250737s)
                </p>
              </td>
<td>
                <p>
                  2.12439 (0.05295s)
                </p>
              </td>
<td>
                <p>
                  2.51074 (0.0947863s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  88.858 (0.0847801s)
                </p>
              </td>
<td>
                <p>
                  18.6448 (0.0957029s)
                </p>
              </td>
<td>
                <p>
                  13.7283 (0.0820388s)
                </p>
              </td>
<td>
                <p>
                  13.4423 (0.100611s)
                </p>
              </td>
<td>
                <p>
                  4.83335 (0.105886s)
                </p>
              </td>
<td>
                <p>
                  4.6829 (0.117418s)
                </p>
              </td>
<td>
                <p>
                  7.59449 (0.189292s)
                </p>
              </td>
<td>
                <p>
                  5.86189 (0.2213s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator4"></a><p class="title"><b>Table 1.59. Operator /</b></p>
<div class="table-contents"><table class="table" summary="Operator /">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  3.20876 (0.0878919s)
                </p>
              </td>
<td>
                <p>
                  3.17469 (0.181536s)
                </p>
              </td>
<td>
                <p>
                  3.14517 (0.250544s)
                </p>
              </td>
<td>
                <p>
                  4.14655 (0.365546s)
                </p>
              </td>
<td>
                <p>
                  4.70812 (0.702366s)
                </p>
              </td>
<td>
                <p>
                  2.28619 (1.18106s)
                </p>
              </td>
<td>
                <p>
                  3.54663 (2.26453s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (4.52755s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0273912s)
                </p>
              </td>
<td>
                <p>
                  1.72404 (0.098585s)
                </p>
              </td>
<td>
                <p>
                  2.12584 (0.169344s)
                </p>
              </td>
<td>
                <p>
                  3.71442 (0.327451s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  1.70383 (0.04667s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0571824s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0796599s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0881567s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.149182s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.208719s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.516606s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.638503s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  40.8044 (1.11768s)
                </p>
              </td>
<td>
                <p>
                  17.2975 (0.989116s)
                </p>
              </td>
<td>
                <p>
                  17.4097 (1.38686s)
                </p>
              </td>
<td>
                <p>
                  20.9668 (1.84837s)
                </p>
              </td>
<td>
                <p>
                  20.6415 (3.07934s)
                </p>
              </td>
<td>
                <p>
                  31.5839 (6.59216s)
                </p>
              </td>
<td>
                <p>
                  33.0087 (17.0525s)
                </p>
              </td>
<td>
                <p>
                  81.0894 (51.7759s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int4"></a><p class="title"><b>Table 1.60. Operator /(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  4.50037 (0.0520677s)
                </p>
              </td>
<td>
                <p>
                  6.30243 (0.108097s)
                </p>
              </td>
<td>
                <p>
                  8.34437 (0.193637s)
                </p>
              </td>
<td>
                <p>
                  7.02879 (0.296939s)
                </p>
              </td>
<td>
                <p>
                  6.47793 (0.630264s)
                </p>
              </td>
<td>
                <p>
                  2.64044 (1.08346s)
                </p>
              </td>
<td>
                <p>
                  3.92627 (2.33772s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (4.22641s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  1.27227 (0.0147198s)
                </p>
              </td>
<td>
                <p>
                  4.34067 (0.0744498s)
                </p>
              </td>
<td>
                <p>
                  6.08699 (0.141253s)
                </p>
              </td>
<td>
                <p>
                  6.56549 (0.277366s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0115696s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0171517s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0232057s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0422461s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0972941s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.156597s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.410334s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.595404s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  60.4712 (0.69963s)
                </p>
              </td>
<td>
                <p>
                  44.8464 (0.769191s)
                </p>
              </td>
<td>
                <p>
                  40.4334 (0.938285s)
                </p>
              </td>
<td>
                <p>
                  35.0752 (1.48179s)
                </p>
              </td>
<td>
                <p>
                  26.8178 (2.60921s)
                </p>
              </td>
<td>
                <p>
                  37.2616 (5.83504s)
                </p>
              </td>
<td>
                <p>
                  37.7146 (15.4756s)
                </p>
              </td>
<td>
                <p>
                  84.1326 (50.0929s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table 1.61. Operator /(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  6.09203 (0.0582351s)
                </p>
              </td>
<td>
                <p>
                  6.42997 (0.0982056s)
                </p>
              </td>
<td>
                <p>
                  6.2137 (0.151642s)
                </p>
              </td>
<td>
                <p>
                  6.62408 (0.281298s)
                </p>
              </td>
<td>
                <p>
                  9.30105 (0.706562s)
                </p>
              </td>
<td>
                <p>
                  3.66307 (1.0584s)
                </p>
              </td>
<td>
                <p>
                  4.10257 (2.14867s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (4.2547s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  1.76794 (0.0169001s)
                </p>
              </td>
<td>
                <p>
                  3.59379 (0.0548884s)
                </p>
              </td>
<td>
                <p>
                  5.55499 (0.135566s)
                </p>
              </td>
<td>
                <p>
                  6.36274 (0.2702s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00955921s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0152731s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0244044s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.042466s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0759658s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.125208s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.288938s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.523737s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  63.2738 (0.604848s)
                </p>
              </td>
<td>
                <p>
                  57.3767 (0.876321s)
                </p>
              </td>
<td>
                <p>
                  43.9301 (1.07209s)
                </p>
              </td>
<td>
                <p>
                  40.0122 (1.69916s)
                </p>
              </td>
<td>
                <p>
                  41.1147 (3.12331s)
                </p>
              </td>
<td>
                <p>
                  57.9739 (7.25882s)
                </p>
              </td>
<td>
                <p>
                  68.6676 (19.8407s)
                </p>
              </td>
<td>
                <p>
                  109.312 (57.2509s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table 1.62. Operator /=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  5.21402 (0.0701172s)
                </p>
              </td>
<td>
                <p>
                  4.76442 (0.105309s)
                </p>
              </td>
<td>
                <p>
                  5.1245 (0.171387s)
                </p>
              </td>
<td>
                <p>
                  7.39587 (0.299993s)
                </p>
              </td>
<td>
                <p>
                  6.88568 (0.632889s)
                </p>
              </td>
<td>
                <p>
                  3.2993 (1.05399s)
                </p>
              </td>
<td>
                <p>
                  3.52936 (2.14442s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (4.37618s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  1.68246 (0.0226255s)
                </p>
              </td>
<td>
                <p>
                  3.12633 (0.0691018s)
                </p>
              </td>
<td>
                <p>
                  3.98733 (0.133354s)
                </p>
              </td>
<td>
                <p>
                  6.62903 (0.268888s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0134478s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0221032s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0334445s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0405622s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0919138s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.14699s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.319457s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.607595s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  46.0731 (0.619583s)
                </p>
              </td>
<td>
                <p>
                  43.6571 (0.964961s)
                </p>
              </td>
<td>
                <p>
                  30.1861 (1.00956s)
                </p>
              </td>
<td>
                <p>
                  41.4936 (1.68307s)
                </p>
              </td>
<td>
                <p>
                  32.6785 (3.0036s)
                </p>
              </td>
<td>
                <p>
                  48.2935 (7.09868s)
                </p>
              </td>
<td>
                <p>
                  64.9093 (20.7357s)
                </p>
              </td>
<td>
                <p>
                  111.801 (67.9296s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator5"></a><p class="title"><b>Table 1.63. Operator &lt;&lt;</b></p>
<div class="table-contents"><table class="table" summary="Operator &lt;&lt;">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  9.93178 (0.0116142s)
                </p>
              </td>
<td>
                <p>
                  1.74005 (0.0147029s)
                </p>
              </td>
<td>
                <p>
                  2.68859 (0.0238748s)
                </p>
              </td>
<td>
                <p>
                  2.04419 (0.0394659s)
                </p>
              </td>
<td>
                <p>
                  2.15112 (0.0859331s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0889652s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.190562s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.32803s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00116939s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00844969s)
                </p>
              </td>
<td>
                <p>
                  1.94851 (0.0173029s)
                </p>
              </td>
<td>
                <p>
                  1.55242 (0.0299716s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  4.60815 (0.00538874s)
                </p>
              </td>
<td>
                <p>
                  1.02939 (0.00869801s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00888006s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0193064s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.039948s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0597248s)
                </p>
              </td>
<td>
                <p>
                  1.65224 (0.146992s)
                </p>
              </td>
<td>
                <p>
                  1.08567 (0.206887s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  10.7935 (0.0126218s)
                </p>
              </td>
<td>
                <p>
                  2.38166 (0.0201243s)
                </p>
              </td>
<td>
                <p>
                  2.42444 (0.0215291s)
                </p>
              </td>
<td>
                <p>
                  1.87488 (0.0361972s)
                </p>
              </td>
<td>
                <p>
                  1.73489 (0.0693055s)
                </p>
              </td>
<td>
                <p>
                  1.93177 (0.115375s)
                </p>
              </td>
<td>
                <p>
                  2.49667 (0.222116s)
                </p>
              </td>
<td>
                <p>
                  2.82346 (0.538044s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator6"></a><p class="title"><b>Table 1.64. Operator &gt;&gt;</b></p>
<div class="table-contents"><table class="table" summary="Operator &gt;&gt;">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  12.5304 (0.011709s)
                </p>
              </td>
<td>
                <p>
                  6.85524 (0.0153366s)
                </p>
              </td>
<td>
                <p>
                  8.77866 (0.0209131s)
                </p>
              </td>
<td>
                <p>
                  3.21549 (0.0146098s)
                </p>
              </td>
<td>
                <p>
                  4.04361 (0.0183489s)
                </p>
              </td>
<td>
                <p>
                  3.04276 (0.0219967s)
                </p>
              </td>
<td>
                <p>
                  8.19636 (0.0537598s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0745484s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000934446s)
                </p>
              </td>
<td>
                <p>
                  6.55349 (0.0146615s)
                </p>
              </td>
<td>
                <p>
                  6.51353 (0.0155169s)
                </p>
              </td>
<td>
                <p>
                  4.90631 (0.0222922s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  2.59712 (0.00242687s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0022372s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00238226s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00454358s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00453774s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00313265s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00722919s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00655899s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  102.662 (0.0959319s)
                </p>
              </td>
<td>
                <p>
                  42.5337 (0.0951565s)
                </p>
              </td>
<td>
                <p>
                  39.1437 (0.0932504s)
                </p>
              </td>
<td>
                <p>
                  21.0397 (0.0955953s)
                </p>
              </td>
<td>
                <p>
                  29.6104 (0.134364s)
                </p>
              </td>
<td>
                <p>
                  62.7092 (0.196446s)
                </p>
              </td>
<td>
                <p>
                  49.6167 (0.358689s)
                </p>
              </td>
<td>
                <p>
                  137.105 (0.899272s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator7"></a><p class="title"><b>Table 1.65. Operator ^</b></p>
<div class="table-contents"><table class="table" summary="Operator ^">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.8103 (0.0101384s)
                </p>
              </td>
<td>
                <p>
                  4.11932 (0.0282768s)
                </p>
              </td>
<td>
                <p>
                  2.25923 (0.0139063s)
                </p>
              </td>
<td>
                <p>
                  1.94172 (0.0187085s)
                </p>
              </td>
<td>
                <p>
                  1.66067 (0.0405646s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0369865s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0918676s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.150955s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00360758s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00686442s)
                </p>
              </td>
<td>
                <p>
                  1.50683 (0.00927498s)
                </p>
              </td>
<td>
                <p>
                  1.79076 (0.0172541s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  1.35398 (0.0048846s)
                </p>
              </td>
<td>
                <p>
                  1.00969 (0.00693092s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00615531s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00963503s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0244266s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0429561s)
                </p>
              </td>
<td>
                <p>
                  2.17737 (0.0805332s)
                </p>
              </td>
<td>
                <p>
                  1.3521 (0.124214s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  2.28701 (0.00825059s)
                </p>
              </td>
<td>
                <p>
                  1.65996 (0.0113947s)
                </p>
              </td>
<td>
                <p>
                  2.06089 (0.0126854s)
                </p>
              </td>
<td>
                <p>
                  2.03244 (0.0195826s)
                </p>
              </td>
<td>
                <p>
                  1.4173 (0.0346198s)
                </p>
              </td>
<td>
                <p>
                  1.32237 (0.0568037s)
                </p>
              </td>
<td>
                <p>
                  2.69468 (0.0996668s)
                </p>
              </td>
<td>
                <p>
                  2.55626 (0.234837s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int5"></a><p class="title"><b>Table 1.66. Operator ^(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator ^(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.67312 (0.00991885s)
                </p>
              </td>
<td>
                <p>
                  1.57246 (0.0115174s)
                </p>
              </td>
<td>
                <p>
                  2.50193 (0.0198209s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0153479s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0264078s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0235546s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0392727s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0657809s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00371059s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0073244s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00792226s)
                </p>
              </td>
<td>
                <p>
                  1.04763 (0.0160789s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  2.86377 (0.0106263s)
                </p>
              </td>
<td>
                <p>
                  2.18619 (0.0160125s)
                </p>
              </td>
<td>
                <p>
                  2.18777 (0.0173321s)
                </p>
              </td>
<td>
                <p>
                  1.01844 (0.0156309s)
                </p>
              </td>
<td>
                <p>
                  1.13176 (0.0298873s)
                </p>
              </td>
<td>
                <p>
                  1.9665 (0.0406408s)
                </p>
              </td>
<td>
                <p>
                  3.34613 (0.0788165s)
                </p>
              </td>
<td>
                <p>
                  3.54952 (0.139399s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  26.101 (0.0968501s)
                </p>
              </td>
<td>
                <p>
                  14.6444 (0.107261s)
                </p>
              </td>
<td>
                <p>
                  10.0538 (0.079649s)
                </p>
              </td>
<td>
                <p>
                  5.64392 (0.0866224s)
                </p>
              </td>
<td>
                <p>
                  3.8806 (0.102478s)
                </p>
              </td>
<td>
                <p>
                  6.36386 (0.131519s)
                </p>
              </td>
<td>
                <p>
                  8.07216 (0.190136s)
                </p>
              </td>
<td>
                <p>
                  8.01428 (0.314742s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_construct"></a><p class="title"><b>Table 1.67. Operator construct</b></p>
<div class="table-contents"><table class="table" summary="Operator construct">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  3.24638 (0.00190752s)
                </p>
              </td>
<td>
                <p>
                  1.06172 (0.00258002s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00248269s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00191598s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00273948s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0017072s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00191549s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0016635s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000587582s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00243004s)
                </p>
              </td>
<td>
                <p>
                  1.51116 (0.00375174s)
                </p>
              </td>
<td>
                <p>
                  4.66482 (0.00893771s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  5.61558 (0.00329962s)
                </p>
              </td>
<td>
                <p>
                  1.52898 (0.0037155s)
                </p>
              </td>
<td>
                <p>
                  2.51713 (0.00624925s)
                </p>
              </td>
<td>
                <p>
                  1.755 (0.00336255s)
                </p>
              </td>
<td>
                <p>
                  1.40183 (0.00384029s)
                </p>
              </td>
<td>
                <p>
                  1.60131 (0.00385483s)
                </p>
              </td>
<td>
                <p>
                  4.7818 (0.0081635s)
                </p>
              </td>
<td>
                <p>
                  2.07779 (0.00397999s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  251.1 (0.147542s)
                </p>
              </td>
<td>
                <p>
                  63.6186 (0.154596s)
                </p>
              </td>
<td>
                <p>
                  54.6947 (0.13579s)
                </p>
              </td>
<td>
                <p>
                  66.8839 (0.128148s)
                </p>
              </td>
<td>
                <p>
                  47.8098 (0.130974s)
                </p>
              </td>
<td>
                <p>
                  54.8252 (0.13198s)
                </p>
              </td>
<td>
                <p>
                  74.1436 (0.126578s)
                </p>
              </td>
<td>
                <p>
                  83.945 (0.160796s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table 1.68. Operator construct(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.12644 (0.00192028s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00200418s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00223886s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00189442s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00190833s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00199036s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00200998s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00168004s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000903049s)
                </p>
              </td>
<td>
                <p>
                  1.26395 (0.00253319s)
                </p>
              </td>
<td>
                <p>
                  1.78621 (0.00399907s)
                </p>
              </td>
<td>
                <p>
                  5.10701 (0.0096748s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  27.1389 (0.0245077s)
                </p>
              </td>
<td>
                <p>
                  10.3593 (0.020762s)
                </p>
              </td>
<td>
                <p>
                  9.02272 (0.0202006s)
                </p>
              </td>
<td>
                <p>
                  9.96334 (0.0188747s)
                </p>
              </td>
<td>
                <p>
                  15.2262 (0.0290565s)
                </p>
              </td>
<td>
                <p>
                  8.50239 (0.0244927s)
                </p>
              </td>
<td>
                <p>
                  35.6564 (0.0709692s)
                </p>
              </td>
<td>
                <p>
                  10.9129 (0.0219346s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  183.484 (0.165695s)
                </p>
              </td>
<td>
                <p>
                  83.0709 (0.166489s)
                </p>
              </td>
<td>
                <p>
                  69.5984 (0.155821s)
                </p>
              </td>
<td>
                <p>
                  75.8903 (0.143768s)
                </p>
              </td>
<td>
                <p>
                  85.5979 (0.163349s)
                </p>
              </td>
<td>
                <p>
                  50.8174 (0.146389s)
                </p>
              </td>
<td>
                <p>
                  70.0602 (0.139445s)
                </p>
              </td>
<td>
                <p>
                  95.4952 (0.191943s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_construct_unsigned"></a><p class="title"><b>Table 1.69. Operator construct(unsigned)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.00349 (0.00174712s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00225895s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00241092s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00177047s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00304865s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0018378s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0017583s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00197229s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000872038s)
                </p>
              </td>
<td>
                <p>
                  1.1805 (0.0026667s)
                </p>
              </td>
<td>
                <p>
                  1.66167 (0.00400614s)
                </p>
              </td>
<td>
                <p>
                  5.54475 (0.00981681s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  27.6419 (0.0241048s)
                </p>
              </td>
<td>
                <p>
                  10.0723 (0.0227529s)
                </p>
              </td>
<td>
                <p>
                  7.60577 (0.0183369s)
                </p>
              </td>
<td>
                <p>
                  10.2725 (0.0181871s)
                </p>
              </td>
<td>
                <p>
                  9.38419 (0.0286091s)
                </p>
              </td>
<td>
                <p>
                  9.10394 (0.0220052s)
                </p>
              </td>
<td>
                <p>
                  34.6032 (0.0635939s)
                </p>
              </td>
<td>
                <p>
                  15.7134 (0.0276289s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  207.462 (0.180915s)
                </p>
              </td>
<td>
                <p>
                  84.5379 (0.190967s)
                </p>
              </td>
<td>
                <p>
                  65.2109 (0.157218s)
                </p>
              </td>
<td>
                <p>
                  84.8572 (0.150237s)
                </p>
              </td>
<td>
                <p>
                  47.0682 (0.143494s)
                </p>
              </td>
<td>
                <p>
                  59.4466 (0.143689s)
                </p>
              </td>
<td>
                <p>
                  78.5549 (0.144368s)
                </p>
              </td>
<td>
                <p>
                  103.519 (0.182018s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_gcd"></a><p class="title"><b>Table 1.70. Operator gcd</b></p>
<div class="table-contents"><table class="table" summary="Operator gcd">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.10743 (0.358587s)
                </p>
              </td>
<td>
                <p>
                  1.8778 (1.42989s)
                </p>
              </td>
<td>
                <p>
                  2.03859 (3.30534s)
                </p>
              </td>
<td>
                <p>
                  2.01435 (7.01715s)
                </p>
              </td>
<td>
                <p>
                  2.16957 (17.7583s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (32.2572s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (76.6459s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (201.791s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  3.65486 (0.621889s)
                </p>
              </td>
<td>
                <p>
                  1.78424 (1.35865s)
                </p>
              </td>
<td>
                <p>
                  2.02664 (3.28597s)
                </p>
              </td>
<td>
                <p>
                  1.95328 (6.8044s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.170154s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.761472s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.62139s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (3.48358s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (8.18516s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (18.7879s)
                </p>
              </td>
<td>
                <p>
                  1.82325 (58.8129s)
                </p>
              </td>
<td>
                <p>
                  1.59356 (122.14s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  8.01966 (1.36458s)
                </p>
              </td>
<td>
                <p>
                  4.44226 (3.38266s)
                </p>
              </td>
<td>
                <p>
                  4.55056 (7.37824s)
                </p>
              </td>
<td>
                <p>
                  4.42983 (15.4317s)
                </p>
              </td>
<td>
                <p>
                  5.23788 (42.8729s)
                </p>
              </td>
<td>
                <p>
                  7.25799 (136.362s)
                </p>
              </td>
<td>
                <p>
                  14.6265 (471.81s)
                </p>
              </td>
<td>
                <p>
                  23.1025 (1770.72s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_powm"></a><p class="title"><b>Table 1.71. Operator powm</b></p>
<div class="table-contents"><table class="table" summary="Operator powm">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  14.8198 (0.565871s)
                </p>
              </td>
<td>
                <p>
                  13.2096 (2.0199s)
                </p>
              </td>
<td>
                <p>
                  11.8233 (9.06469s)
                </p>
              </td>
<td>
                <p>
                  9.12533 (46.9932s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  9.40069 (0.35895s)
                </p>
              </td>
<td>
                <p>
                  10.0395 (1.53516s)
                </p>
              </td>
<td>
                <p>
                  10.5353 (8.07714s)
                </p>
              </td>
<td>
                <p>
                  8.49678 (43.7564s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0381833s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.152912s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.766677s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (5.14976s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  11.0485 (0.421869s)
                </p>
              </td>
<td>
                <p>
                  8.44037 (1.29063s)
                </p>
              </td>
<td>
                <p>
                  4.18756 (3.21051s)
                </p>
              </td>
<td>
                <p>
                  2.45216 (12.628s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_str"></a><p class="title"><b>Table 1.72. Operator str</b></p>
<div class="table-contents"><table class="table" summary="Operator str">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  1.47697 (0.000264092s)
                </p>
              </td>
<td>
                <p>
                  2.87174 (0.000644609s)
                </p>
              </td>
<td>
                <p>
                  2.28911 (0.00141073s)
                </p>
              </td>
<td>
                <p>
                  4.92453 (0.00383604s)
                </p>
              </td>
<td>
                <p>
                  5.61647 (0.0137593s)
                </p>
              </td>
<td>
                <p>
                  1.87264 (0.0491109s)
                </p>
              </td>
<td>
                <p>
                  4.29909 (0.171316s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.595522s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  4.73326 (0.00084634s)
                </p>
              </td>
<td>
                <p>
                  1.78742 (0.000401216s)
                </p>
              </td>
<td>
                <p>
                  1.68455 (0.00103815s)
                </p>
              </td>
<td>
                <p>
                  4.30889 (0.00335647s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000178807s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000224466s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00061628s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000778966s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00244981s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00486654s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0262254s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0398493s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  16.7304 (0.00299152s)
                </p>
              </td>
<td>
                <p>
                  26.6015 (0.00597113s)
                </p>
              </td>
<td>
                <p>
                  30.9815 (0.0190933s)
                </p>
              </td>
<td>
                <p>
                  74.7467 (0.0582251s)
                </p>
              </td>
<td>
                <p>
                  82.4773 (0.202054s)
                </p>
              </td>
<td>
                <p>
                  154.996 (0.754295s)
                </p>
              </td>
<td>
                <p>
                  107.534 (2.82013s)
                </p>
              </td>
<td>
                <p>
                  279.178 (11.1251s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator8"></a><p class="title"><b>Table 1.73. Operator |</b></p>
<div class="table-contents"><table class="table" summary="Operator |">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.26845 (0.00991773s)
                </p>
              </td>
<td>
                <p>
                  1.955 (0.00939722s)
                </p>
              </td>
<td>
                <p>
                  2.01122 (0.012635s)
                </p>
              </td>
<td>
                <p>
                  1.76421 (0.0152013s)
                </p>
              </td>
<td>
                <p>
                  1.92162 (0.0293243s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0377549s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0916779s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.152323s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  1.00452 (0.0043918s)
                </p>
              </td>
<td>
                <p>
                  1.37689 (0.00661838s)
                </p>
              </td>
<td>
                <p>
                  1.3138 (0.00825362s)
                </p>
              </td>
<td>
                <p>
                  1.71906 (0.0148123s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00437203s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00480677s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00628228s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00861647s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0152602s)
                </p>
              </td>
<td>
                <p>
                  1.09283 (0.0365187s)
                </p>
              </td>
<td>
                <p>
                  2.43832 (0.0920584s)
                </p>
              </td>
<td>
                <p>
                  1.21204 (0.111118s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  1.69103 (0.00739324s)
                </p>
              </td>
<td>
                <p>
                  1.85402 (0.00891185s)
                </p>
              </td>
<td>
                <p>
                  1.78526 (0.0112155s)
                </p>
              </td>
<td>
                <p>
                  1.86487 (0.0160686s)
                </p>
              </td>
<td>
                <p>
                  1.75184 (0.0267336s)
                </p>
              </td>
<td>
                <p>
                  1.44011 (0.0481236s)
                </p>
              </td>
<td>
                <p>
                  2.33195 (0.0880424s)
                </p>
              </td>
<td>
                <p>
                  2.33204 (0.213797s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.operator_int6"></a><p class="title"><b>Table 1.74. Operator |(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator |(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
<th>
                <p>
                  2048 Bits
                </p>
              </th>
<th>
                <p>
                  4096 Bits
                </p>
              </th>
<th>
                <p>
                  8192 Bits
                </p>
              </th>
<th>
                <p>
                  16384 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int
                </p>
              </td>
<td>
                <p>
                  2.11741 (0.00805945s)
                </p>
              </td>
<td>
                <p>
                  2.16753 (0.0119795s)
                </p>
              </td>
<td>
                <p>
                  1.5717 (0.012189s)
                </p>
              </td>
<td>
                <p>
                  1.10016 (0.0134288s)
                </p>
              </td>
<td>
                <p>
                  1.11289 (0.0309032s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0232284s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.042441s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0711061s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int(fixed)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00380628s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00552682s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00775532s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0122062s)
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  gmp_int
                </p>
              </td>
<td>
                <p>
                  2.62934 (0.010008s)
                </p>
              </td>
<td>
                <p>
                  1.86878 (0.0103284s)
                </p>
              </td>
<td>
                <p>
                  3.19589 (0.0247852s)
                </p>
              </td>
<td>
                <p>
                  1.1073 (0.0135159s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0277685s)
                </p>
              </td>
<td>
                <p>
                  1.67609 (0.0360071s)
                </p>
              </td>
<td>
                <p>
                  3.76493 (0.0874534s)
                </p>
              </td>
<td>
                <p>
                  2.72382 (0.115602s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath_int
                </p>
              </td>
<td>
                <p>
                  22.0502 (0.0839291s)
                </p>
              </td>
<td>
                <p>
                  18.6272 (0.102949s)
                </p>
              </td>
<td>
                <p>
                  9.99323 (0.0775007s)
                </p>
              </td>
<td>
                <p>
                  6.28905 (0.0767652s)
                </p>
              </td>
<td>
                <p>
                  3.28821 (0.0913086s)
                </p>
              </td>
<td>
                <p>
                  5.0968 (0.109494s)
                </p>
              </td>
<td>
                <p>
                  6.47865 (0.150489s)
                </p>
              </td>
<td>
                <p>
                  4.8474 (0.205729s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.integer_performance.platform"></a><p class="title"><b>Table 1.75. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="float_performance.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/overhead.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>The Overhead in the Number Class Wrapper</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="../perf.html" title="Performance Comparison">
<link rel="next" href="realworld.html" title="Floating-Point Real World Tests">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../perf.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="realworld.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.overhead"></a><a class="link" href="overhead.html" title="The Overhead in the Number Class Wrapper">The Overhead in the
      Number Class Wrapper</a>
</h3></div></div></div>
<p>
        Using a simple <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/arithmetic_backend.hpp" target="_top">backend
        class</a> that wraps any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> arithmetic type we can measure the overhead involved in
        wrapping a type inside the <code class="computeroutput"><span class="identifier">number</span></code>
        frontend, and the effect that turning on expression templates has. The following
        table compares the performance between <code class="computeroutput"><span class="keyword">double</span></code>
        and a <code class="computeroutput"><span class="keyword">double</span></code> wrapped inside
        class <code class="computeroutput"><span class="identifier">number</span></code>:
      </p>
<div class="table">
<a name="boost_multiprecision.perf.overhead.bessel_functions_16_digit_precis"></a><p class="title"><b>Table 1.12. Bessel Functions (16 digit precision)</b></p>
<div class="table-contents"><table class="table" summary="Bessel Functions (16 digit precision)">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Type
                </p>
              </th>
<th>
                <p>
                  Time
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  arithmetic_backend&lt;double&gt;
                </p>
              </td>
<td>
                <p>
                  2.09301 (0.00133409s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  arithmetic_backend&lt;double&gt; - no expression templates
                </p>
              </td>
<td>
                <p>
                  1 (0.000637403s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  double
                </p>
              </td>
<td>
                <p>
                  1.07956 (0.000688113s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
        As you can see whether or not there is an overhead, and how large it is depends
        on the actual situation, but the overhead is in any cases small. Expression
        templates generally add a greater overhead the more complex the expression
        becomes due to the logic of figuring out how to best unpack and evaluate
        the expression, but of course this is also the situation where you save more
        temporaries. For a "trivial" backend like this, saving temporaries
        has no benefit, but for larger types it becomes a bigger win.
      </p>
<p>
        The following table compares arithmetic using either <code class="computeroutput"><span class="keyword">long</span>
        <span class="keyword">long</span></code> or <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">arithmetic_backend</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> for the <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/voronoi_performance.cpp" target="_top">voronoi-diagram
        builder test</a>:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Type
                </p>
              </th>
<th>
                <p>
                  Relative time
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">int64_t</span></code>
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1.0</strong></span>(0.0128646s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">arithmetic_backend</span><span class="special">&lt;</span><span class="identifier">int64_t</span><span class="special">&gt;,</span>
                  <span class="identifier">et_off</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  1.005 (0.0129255s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        This test involves mainly creating a lot of temporaries and performing a
        small amount of arithmetic on them, with very little difference in performance
        between the native and "wrapped" types.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.overhead.platform"></a><p class="title"><b>Table 1.13. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../perf.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="realworld.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/rational_performance.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Rational Type Performance</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="integer_performance.html" title="Integer Algorithm Performance">
<link rel="next" href="../map.html" title="Roadmap">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="integer_performance.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../map.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.rational_performance"></a><a class="link" href="rational_performance.html" title="Rational Type Performance">Rational
      Type Performance</a>
</h3></div></div></div>
<p>
        Note that these tests are carefully designed to test performance of the underlying
        algorithms and not memory allocation or variable copying. As usual, performance
        results should be taken with a healthy dose of scepticism, and real-world
        performance may vary widely depending upon the specifics of the program.
        In each table relative times are given first, with the best performer given
        a score of 1. Total actual times are given in brackets, measured in seconds
        for 500000 operations.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator"></a><p class="title"><b>Table 1.76. Operator *</b></p>
<div class="table-contents"><table class="table" summary="Operator *">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.00025 (0.797425s)
                </p>
              </td>
<td>
                <p>
                  1.97726 (2.96998s)
                </p>
              </td>
<td>
                <p>
                  1.86844 (6.73224s)
                </p>
              </td>
<td>
                <p>
                  1.96608 (14.4259s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.398662s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.50207s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (3.60314s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (7.3374s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_int"></a><p class="title"><b>Table 1.77. Operator *(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.88073 (0.0637195s)
                </p>
              </td>
<td>
                <p>
                  1.93184 (0.0917847s)
                </p>
              </td>
<td>
                <p>
                  2.15609 (0.118274s)
                </p>
              </td>
<td>
                <p>
                  2.4236 (0.218283s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0338803s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0475114s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0548556s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0900656s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long"></a><p class="title"><b>Table 1.78. Operator *(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.60877 (0.161844s)
                </p>
              </td>
<td>
                <p>
                  2.33429 (0.240069s)
                </p>
              </td>
<td>
                <p>
                  1.8835 (0.298935s)
                </p>
              </td>
<td>
                <p>
                  2.70338 (0.448194s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.100601s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.102844s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.158713s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.16579s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type"></a><p class="title"><b>Table 1.79. Operator *(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator *(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.97503 (0.408791s)
                </p>
              </td>
<td>
                <p>
                  2.42069 (0.600225s)
                </p>
              </td>
<td>
                <p>
                  2.65138 (0.803009s)
                </p>
              </td>
<td>
                <p>
                  4.65673 (1.54645s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.20698s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.247956s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.302865s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.332089s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table 1.80. Operator *=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.97207 (0.211848s)
                </p>
              </td>
<td>
                <p>
                  2.18482 (0.226179s)
                </p>
              </td>
<td>
                <p>
                  2.43682 (0.319695s)
                </p>
              </td>
<td>
                <p>
                  2.69933 (0.485819s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.107424s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.103523s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.131194s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.179978s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type0"></a><p class="title"><b>Table 1.81. Operator *=(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator *=(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.95211 (0.40255s)
                </p>
              </td>
<td>
                <p>
                  2.60942 (0.629302s)
                </p>
              </td>
<td>
                <p>
                  2.83854 (0.8029s)
                </p>
              </td>
<td>
                <p>
                  4.34054 (1.37083s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.206213s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.241165s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.282857s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.31582s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator0"></a><p class="title"><b>Table 1.82. Operator +</b></p>
<div class="table-contents"><table class="table" summary="Operator +">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.20364 (0.415006s)
                </p>
              </td>
<td>
                <p>
                  1.97574 (1.53458s)
                </p>
              </td>
<td>
                <p>
                  1.75945 (3.41194s)
                </p>
              </td>
<td>
                <p>
                  2.11634 (8.04044s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.188327s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.776716s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.93921s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (3.79923s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_int0"></a><p class="title"><b>Table 1.83. Operator +(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.06836 (0.0177811s)
                </p>
              </td>
<td>
                <p>
                  1.80334 (0.0183744s)
                </p>
              </td>
<td>
                <p>
                  1.38442 (0.020452s)
                </p>
              </td>
<td>
                <p>
                  1.81894 (0.0449351s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00859669s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0101891s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.014773s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.024704s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table 1.84. Operator +(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.07187 (0.0177151s)
                </p>
              </td>
<td>
                <p>
                  2.3005 (0.0241089s)
                </p>
              </td>
<td>
                <p>
                  1.81397 (0.0297836s)
                </p>
              </td>
<td>
                <p>
                  1.72202 (0.046594s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0085503s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0104799s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.016419s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0270577s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type1"></a><p class="title"><b>Table 1.85. Operator +(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator +(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.2805 (0.0265647s)
                </p>
              </td>
<td>
                <p>
                  1.59353 (0.0391054s)
                </p>
              </td>
<td>
                <p>
                  1.26613 (0.044067s)
                </p>
              </td>
<td>
                <p>
                  1.95307 (0.105801s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0207456s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0245401s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0348044s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0541719s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table 1.86. Operator +=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  7.29749 (0.0565983s)
                </p>
              </td>
<td>
                <p>
                  3.77253 (0.0371419s)
                </p>
              </td>
<td>
                <p>
                  2.72128 (0.0556987s)
                </p>
              </td>
<td>
                <p>
                  2.01495 (0.0662456s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00775585s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00984535s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0204678s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.032877s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type2"></a><p class="title"><b>Table 1.87. Operator +=(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator +=(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.92025 (0.0335896s)
                </p>
              </td>
<td>
                <p>
                  2.08321 (0.0422867s)
                </p>
              </td>
<td>
                <p>
                  1.587 (0.0564267s)
                </p>
              </td>
<td>
                <p>
                  1.85357 (0.0840696s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0174923s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0202988s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0355556s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0453556s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator1"></a><p class="title"><b>Table 1.88. Operator -</b></p>
<div class="table-contents"><table class="table" summary="Operator -">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.38126 (0.471759s)
                </p>
              </td>
<td>
                <p>
                  1.92631 (1.52484s)
                </p>
              </td>
<td>
                <p>
                  1.76181 (3.49648s)
                </p>
              </td>
<td>
                <p>
                  2.03462 (7.71926s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.198113s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.791584s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.98459s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (3.79396s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_int1"></a><p class="title"><b>Table 1.89. Operator -(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.44447 (0.0292894s)
                </p>
              </td>
<td>
                <p>
                  2.54602 (0.0346718s)
                </p>
              </td>
<td>
                <p>
                  1.4869 (0.035503s)
                </p>
              </td>
<td>
                <p>
                  1.95344 (0.0577029s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0119819s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.013618s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0238773s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0295391s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table 1.90. Operator -(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.93654 (0.0296698s)
                </p>
              </td>
<td>
                <p>
                  4.23087 (0.0496956s)
                </p>
              </td>
<td>
                <p>
                  1.68041 (0.0461985s)
                </p>
              </td>
<td>
                <p>
                  1.4455 (0.0581714s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0101037s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0117459s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0274924s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.040243s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type3"></a><p class="title"><b>Table 1.91. Operator -(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator -(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.69242 (0.0408789s)
                </p>
              </td>
<td>
                <p>
                  1.5205 (0.0467416s)
                </p>
              </td>
<td>
                <p>
                  1.31525 (0.0548939s)
                </p>
              </td>
<td>
                <p>
                  2.16115 (0.103471s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0241541s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.030741s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0417365s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0478777s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table 1.92. Operator -=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  3.69509 (0.0366534s)
                </p>
              </td>
<td>
                <p>
                  3.7306 (0.0439181s)
                </p>
              </td>
<td>
                <p>
                  1.8352 (0.0491612s)
                </p>
              </td>
<td>
                <p>
                  1.86662 (0.071761s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00991947s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0117724s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0267879s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0384444s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type4"></a><p class="title"><b>Table 1.93. Operator -=(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator -=(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.76299 (0.0421283s)
                </p>
              </td>
<td>
                <p>
                  2.03803 (0.0490152s)
                </p>
              </td>
<td>
                <p>
                  1.84864 (0.053198s)
                </p>
              </td>
<td>
                <p>
                  2.10533 (0.0881228s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.023896s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0240502s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0287769s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.041857s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator2"></a><p class="title"><b>Table 1.94. Operator /</b></p>
<div class="table-contents"><table class="table" summary="Operator /">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  2.03433 (2.28881s)
                </p>
              </td>
<td>
                <p>
                  2.24309 (6.34454s)
                </p>
              </td>
<td>
                <p>
                  2.1203 (13.2036s)
                </p>
              </td>
<td>
                <p>
                  2.36142 (29.3236s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (1.12509s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (2.82848s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (6.22726s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (12.4178s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_int2"></a><p class="title"><b>Table 1.95. Operator /(int)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(int)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.035134s)
                </p>
              </td>
<td>
                <p>
                  1.08556 (0.0774619s)
                </p>
              </td>
<td>
                <p>
                  1.08797 (0.104628s)
                </p>
              </td>
<td>
                <p>
                  1.29134 (0.207067s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  1.85049 (0.0650149s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0713565s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0961679s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.16035s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table 1.96. Operator /(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.31397 (0.170727s)
                </p>
              </td>
<td>
                <p>
                  1.63747 (0.216019s)
                </p>
              </td>
<td>
                <p>
                  1.68581 (0.292536s)
                </p>
              </td>
<td>
                <p>
                  1.76695 (0.435259s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.129932s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.131923s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.173528s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.246334s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type5"></a><p class="title"><b>Table 1.97. Operator /(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator /(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.82473 (0.431612s)
                </p>
              </td>
<td>
                <p>
                  2.20261 (0.596248s)
                </p>
              </td>
<td>
                <p>
                  2.45848 (0.809662s)
                </p>
              </td>
<td>
                <p>
                  3.88675 (1.38001s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.236534s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.270701s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.329335s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.355055s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long6"></a><p class="title"><b>Table 1.98. Operator /=(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.58868 (0.216252s)
                </p>
              </td>
<td>
                <p>
                  1.71288 (0.235781s)
                </p>
              </td>
<td>
                <p>
                  1.78218 (0.314161s)
                </p>
              </td>
<td>
                <p>
                  1.98715 (0.460033s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.136121s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.137652s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.176279s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.231505s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_value_type6"></a><p class="title"><b>Table 1.99. Operator /=(value_type)</b></p>
<div class="table-contents"><table class="table" summary="Operator /=(value_type)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  1.72896 (0.40369s)
                </p>
              </td>
<td>
                <p>
                  2.55949 (0.689514s)
                </p>
              </td>
<td>
                <p>
                  2.4929 (0.832288s)
                </p>
              </td>
<td>
                <p>
                  3.51238 (1.37478s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.233487s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.269395s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.333863s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.391409s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_construct"></a><p class="title"><b>Table 1.100. Operator construct</b></p>
<div class="table-contents"><table class="table" summary="Operator construct">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0135822s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00935293s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0083784s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00962697s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  1.44264 (0.0195942s)
                </p>
              </td>
<td>
                <p>
                  2.18249 (0.0204126s)
                </p>
              </td>
<td>
                <p>
                  2.64725 (0.0221797s)
                </p>
              </td>
<td>
                <p>
                  2.87767 (0.0277033s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_long"></a><p class="title"><b>Table 1.101. Operator construct(unsigned long long)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00806026s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00960336s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00769898s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0176689s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  4.87225 (0.0392716s)
                </p>
              </td>
<td>
                <p>
                  5.91987 (0.0568506s)
                </p>
              </td>
<td>
                <p>
                  9.03811 (0.0695842s)
                </p>
              </td>
<td>
                <p>
                  3.68339 (0.0650815s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned"></a><p class="title"><b>Table 1.102. Operator construct(unsigned)</b></p>
<div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00672081s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.0064826s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00618635s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00923644s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  6.47138 (0.0434929s)
                </p>
              </td>
<td>
                <p>
                  7.48645 (0.0485316s)
                </p>
              </td>
<td>
                <p>
                  8.2942 (0.0513108s)
                </p>
              </td>
<td>
                <p>
                  5.77363 (0.0533278s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.operator_str"></a><p class="title"><b>Table 1.103. Operator str</b></p>
<div class="table-contents"><table class="table" summary="Operator str">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  128 Bits
                </p>
              </th>
<th>
                <p>
                  256 Bits
                </p>
              </th>
<th>
                <p>
                  512 Bits
                </p>
              </th>
<th>
                <p>
                  1024 Bits
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_rational
                </p>
              </td>
<td>
                <p>
                  6.17439 (0.00168424s)
                </p>
              </td>
<td>
                <p>
                  7.6748 (0.0033367s)
                </p>
              </td>
<td>
                <p>
                  6.38435 (0.00662873s)
                </p>
              </td>
<td>
                <p>
                  9.07696 (0.0174979s)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpq_rational
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000272779s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.000434761s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00103828s)
                </p>
              </td>
<td>
                <p>
                  <span class="bold"><strong>1</strong></span> (0.00192772s)
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_performance.platform"></a><p class="title"><b>Table 1.104. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="integer_performance.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../map.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/rational_real_world.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Rational Real World Tests</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="int_real_world.html" title="Integer Real World Tests">
<link rel="next" href="float_performance.html" title="Float Algorithm Performance">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="int_real_world.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="float_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.rational_real_world"></a><a class="link" href="rational_real_world.html" title="Rational Real World Tests">Rational
      Real World Tests</a>
</h3></div></div></div>
<p>
        The first set of <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/rational_bernoulli_bench.cpp" target="_top">tests</a>
        measure the times taken to calculate the n'th Bernoulli number via mixed
        rational/integer arithmetic to give an exact rational result.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.rational_real_world.relative_times_taken_to_calculat"></a><p class="title"><b>Table 1.18. Relative times taken to calculate Bm</b></p>
<div class="table-contents"><table class="table" summary="Relative times taken to calculate Bm">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  m
                </p>
              </th>
<th>
                <p>
                  cpp_rational (time in seconds)
                </p>
              </th>
<th>
                <p>
                  mpq_rational (time relative to cpp_rational)
                </p>
              </th>
<th>
                <p>
                  mpq_class (time relative to cpp_rational)
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  50
                </p>
              </td>
<td>
                <p>
                  1.888453
                </p>
              </td>
<td>
                <p>
                  1.7317576874
                </p>
              </td>
<td>
                <p>
                  1.893438174
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  54
                </p>
              </td>
<td>
                <p>
                  2.250503
                </p>
              </td>
<td>
                <p>
                  2.1519411438
                </p>
              </td>
<td>
                <p>
                  2.4936252029
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  58
                </p>
              </td>
<td>
                <p>
                  2.734527
                </p>
              </td>
<td>
                <p>
                  2.2056805437
                </p>
              </td>
<td>
                <p>
                  1.9866752093
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  62
                </p>
              </td>
<td>
                <p>
                  3.318122
                </p>
              </td>
<td>
                <p>
                  2.5182796172
                </p>
              </td>
<td>
                <p>
                  2.2662876772
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  66
                </p>
              </td>
<td>
                <p>
                  3.887281
                </p>
              </td>
<td>
                <p>
                  2.4263077457
                </p>
              </td>
<td>
                <p>
                  2.588347485
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  70
                </p>
              </td>
<td>
                <p>
                  4.628535
                </p>
              </td>
<td>
                <p>
                  1.9756346231
                </p>
              </td>
<td>
                <p>
                  2.5367158291
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  74
                </p>
              </td>
<td>
                <p>
                  5.3541
                </p>
              </td>
<td>
                <p>
                  1.7052929531
                </p>
              </td>
<td>
                <p>
                  2.3345854579
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  78
                </p>
              </td>
<td>
                <p>
                  6.321172
                </p>
              </td>
<td>
                <p>
                  1.6669601776
                </p>
              </td>
<td>
                <p>
                  2.0390342171
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  82
                </p>
              </td>
<td>
                <p>
                  7.13052
                </p>
              </td>
<td>
                <p>
                  1.7689101216
                </p>
              </td>
<td>
                <p>
                  1.9837833706
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  86
                </p>
              </td>
<td>
                <p>
                  8.390095
                </p>
              </td>
<td>
                <p>
                  1.6245518078
                </p>
              </td>
<td>
                <p>
                  1.5785492298
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  90
                </p>
              </td>
<td>
                <p>
                  10.62176
                </p>
              </td>
<td>
                <p>
                  1.6294440846
                </p>
              </td>
<td>
                <p>
                  1.5779053566
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  94
                </p>
              </td>
<td>
                <p>
                  11.364409
                </p>
              </td>
<td>
                <p>
                  1.5786845581
                </p>
              </td>
<td>
                <p>
                  1.5614997665
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  98
                </p>
              </td>
<td>
                <p>
                  14.030636
                </p>
              </td>
<td>
                <p>
                  1.2616490799
                </p>
              </td>
<td>
                <p>
                  1.4799734666
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  102
                </p>
              </td>
<td>
                <p>
                  15.268211
                </p>
              </td>
<td>
                <p>
                  1.6145657798
                </p>
              </td>
<td>
                <p>
                  1.6128342738
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  106
                </p>
              </td>
<td>
                <p>
                  15.253028
                </p>
              </td>
<td>
                <p>
                  1.8985381788
                </p>
              </td>
<td>
                <p>
                  1.8206293859
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  110
                </p>
              </td>
<td>
                <p>
                  17.637756
                </p>
              </td>
<td>
                <p>
                  1.8283953469
                </p>
              </td>
<td>
                <p>
                  1.6559522084
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  114
                </p>
              </td>
<td>
                <p>
                  18.335007
                </p>
              </td>
<td>
                <p>
                  1.8018346543
                </p>
              </td>
<td>
                <p>
                  1.8343225612
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  118
                </p>
              </td>
<td>
                <p>
                  21.044146
                </p>
              </td>
<td>
                <p>
                  2.0462015897
                </p>
              </td>
<td>
                <p>
                  1.8106934346
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  122
                </p>
              </td>
<td>
                <p>
                  23.71295
                </p>
              </td>
<td>
                <p>
                  2.0041556196
                </p>
              </td>
<td>
                <p>
                  1.7127701108
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  126
                </p>
              </td>
<td>
                <p>
                  25.993901
                </p>
              </td>
<td>
                <p>
                  1.9901613075
                </p>
              </td>
<td>
                <p>
                  1.6974264848
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  130
                </p>
              </td>
<td>
                <p>
                  30.17278
                </p>
              </td>
<td>
                <p>
                  1.8897211328
                </p>
              </td>
<td>
                <p>
                  1.6405006433
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  134
                </p>
              </td>
<td>
                <p>
                  43.992333
                </p>
              </td>
<td>
                <p>
                  1.2223514038
                </p>
              </td>
<td>
                <p>
                  1.2232961594
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  138
                </p>
              </td>
<td>
                <p>
                  40.702777
                </p>
              </td>
<td>
                <p>
                  1.3551305848
                </p>
              </td>
<td>
                <p>
                  1.492072224
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  142
                </p>
              </td>
<td>
                <p>
                  47.01495
                </p>
              </td>
<td>
                <p>
                  1.4361410785
                </p>
              </td>
<td>
                <p>
                  1.4005683724
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  146
                </p>
              </td>
<td>
                <p>
                  51.468592
                </p>
              </td>
<td>
                <p>
                  1.4279172043
                </p>
              </td>
<td>
                <p>
                  1.4072223891
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  150
                </p>
              </td>
<td>
                <p>
                  70.736106
                </p>
              </td>
<td>
                <p>
                  1.3628087048
                </p>
              </td>
<td>
                <p>
                  1.2309294917
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  154
                </p>
              </td>
<td>
                <p>
                  74.638691
                </p>
              </td>
<td>
                <p>
                  1.2509392749
                </p>
              </td>
<td>
                <p>
                  1.2846060497
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  158
                </p>
              </td>
<td>
                <p>
                  76.642396
                </p>
              </td>
<td>
                <p>
                  1.3383691449
                </p>
              </td>
<td>
                <p>
                  1.2555573941
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  162
                </p>
              </td>
<td>
                <p>
                  104.906795
                </p>
              </td>
<td>
                <p>
                  1.1722665057
                </p>
              </td>
<td>
                <p>
                  1.0121124375
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  166
                </p>
              </td>
<td>
                <p>
                  108.175914
                </p>
              </td>
<td>
                <p>
                  0.9272805682
                </p>
              </td>
<td>
                <p>
                  1.2472813403
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  170
                </p>
              </td>
<td>
                <p>
                  125.363885
                </p>
              </td>
<td>
                <p>
                  0.8114005082
                </p>
              </td>
<td>
                <p>
                  1.1349673712
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  174
                </p>
              </td>
<td>
                <p>
                  119.813754
                </p>
              </td>
<td>
                <p>
                  0.9747547014
                </p>
              </td>
<td>
                <p>
                  1.5677900135
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  178
                </p>
              </td>
<td>
                <p>
                  130.672631
                </p>
              </td>
<td>
                <p>
                  0.904429444
                </p>
              </td>
<td>
                <p>
                  1.6089208382
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  182
                </p>
              </td>
<td>
                <p>
                  136.002124
                </p>
              </td>
<td>
                <p>
                  0.8359445107
                </p>
              </td>
<td>
                <p>
                  1.3173987636
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  186
                </p>
              </td>
<td>
                <p>
                  152.169271
                </p>
              </td>
<td>
                <p>
                  0.7919228515
                </p>
              </td>
<td>
                <p>
                  1.3523570012
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  190
                </p>
              </td>
<td>
                <p>
                  149.444035
                </p>
              </td>
<td>
                <p>
                  0.8353259734
                </p>
              </td>
<td>
                <p>
                  1.4571606823
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  194
                </p>
              </td>
<td>
                <p>
                  149.609183
                </p>
              </td>
<td>
                <p>
                  0.8898088896
                </p>
              </td>
<td>
                <p>
                  1.6132629038
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  198
                </p>
              </td>
<td>
                <p>
                  167.594528
                </p>
              </td>
<td>
                <p>
                  0.8947434429
                </p>
              </td>
<td>
                <p>
                  1.326461858
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
        In this use case, most the of the rational numbers are fairly small and so
        the times taken are dominated by the number of allocations performed. The
        following table illustrates how well each type performs on suppressing allocations:
      </p>
<div class="table">
<a name="boost_multiprecision.perf.rational_real_world.total_allocation_counts_for_bern"></a><p class="title"><b>Table 1.19. Total Allocation Counts for Bernoulli Number Calculation</b></p>
<div class="table-contents"><table class="table" summary="Total Allocation Counts for Bernoulli Number Calculation">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  m
                </p>
              </th>
<th>
                <p>
                  cpp_rational
                </p>
              </th>
<th>
                <p>
                  mpq_rational
                </p>
              </th>
<th>
                <p>
                  mpq_class
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  77
                </p>
              </td>
<td>
                <p>
                  101
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  4
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  187
                </p>
              </td>
<td>
                <p>
                  252
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  6
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  345
                </p>
              </td>
<td>
                <p>
                  471
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  8
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  551
                </p>
              </td>
<td>
                <p>
                  758
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  10
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  805
                </p>
              </td>
<td>
                <p>
                  1113
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  12
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  1107
                </p>
              </td>
<td>
                <p>
                  1536
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  14
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  1457
                </p>
              </td>
<td>
                <p>
                  2027
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  16
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  1857
                </p>
              </td>
<td>
                <p>
                  2587
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  18
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  2336
                </p>
              </td>
<td>
                <p>
                  3216
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  20
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  2885
                </p>
              </td>
<td>
                <p>
                  3913
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  22
                </p>
              </td>
<td>
                <p>
                  6
                </p>
              </td>
<td>
                <p>
                  3511
                </p>
              </td>
<td>
                <p>
                  4706
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  24
                </p>
              </td>
<td>
                <p>
                  22
                </p>
              </td>
<td>
                <p>
                  4203
                </p>
              </td>
<td>
                <p>
                  5600
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  26
                </p>
              </td>
<td>
                <p>
                  83
                </p>
              </td>
<td>
                <p>
                  4963
                </p>
              </td>
<td>
                <p>
                  6575
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  28
                </p>
              </td>
<td>
                <p>
                  377
                </p>
              </td>
<td>
                <p>
                  5806
                </p>
              </td>
<td>
                <p>
                  7632
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  30
                </p>
              </td>
<td>
                <p>
                  780
                </p>
              </td>
<td>
                <p>
                  6738
                </p>
              </td>
<td>
                <p>
                  8769
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  32
                </p>
              </td>
<td>
                <p>
                  1454
                </p>
              </td>
<td>
                <p>
                  7771
                </p>
              </td>
<td>
                <p>
                  9988
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  34
                </p>
              </td>
<td>
                <p>
                  2001
                </p>
              </td>
<td>
                <p>
                  9357
                </p>
              </td>
<td>
                <p>
                  11289
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  36
                </p>
              </td>
<td>
                <p>
                  2789
                </p>
              </td>
<td>
                <p>
                  10598
                </p>
              </td>
<td>
                <p>
                  12704
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  38
                </p>
              </td>
<td>
                <p>
                  3669
                </p>
              </td>
<td>
                <p>
                  11948
                </p>
              </td>
<td>
                <p>
                  14252
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  40
                </p>
              </td>
<td>
                <p>
                  4653
                </p>
              </td>
<td>
                <p>
                  13403
                </p>
              </td>
<td>
                <p>
                  15891
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  42
                </p>
              </td>
<td>
                <p>
                  5923
                </p>
              </td>
<td>
                <p>
                  14976
                </p>
              </td>
<td>
                <p>
                  17620
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  44
                </p>
              </td>
<td>
                <p>
                  7379
                </p>
              </td>
<td>
                <p>
                  16622
                </p>
              </td>
<td>
                <p>
                  19449
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  46
                </p>
              </td>
<td>
                <p>
                  8839
                </p>
              </td>
<td>
                <p>
                  18367
                </p>
              </td>
<td>
                <p>
                  21367
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  48
                </p>
              </td>
<td>
                <p>
                  10296
                </p>
              </td>
<td>
                <p>
                  20227
                </p>
              </td>
<td>
                <p>
                  23431
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  50
                </p>
              </td>
<td>
                <p>
                  12045
                </p>
              </td>
<td>
                <p>
                  22857
                </p>
              </td>
<td>
                <p>
                  25646
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  52
                </p>
              </td>
<td>
                <p>
                  13603
                </p>
              </td>
<td>
                <p>
                  25044
                </p>
              </td>
<td>
                <p>
                  27962
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  54
                </p>
              </td>
<td>
                <p>
                  15276
                </p>
              </td>
<td>
                <p>
                  27331
                </p>
              </td>
<td>
                <p>
                  30389
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  56
                </p>
              </td>
<td>
                <p>
                  17239
                </p>
              </td>
<td>
                <p>
                  29749
                </p>
              </td>
<td>
                <p>
                  32919
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  58
                </p>
              </td>
<td>
                <p>
                  19337
                </p>
              </td>
<td>
                <p>
                  32257
                </p>
              </td>
<td>
                <p>
                  35552
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  60
                </p>
              </td>
<td>
                <p>
                  21409
                </p>
              </td>
<td>
                <p>
                  34958
                </p>
              </td>
<td>
                <p>
                  38417
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  62
                </p>
              </td>
<td>
                <p>
                  23694
                </p>
              </td>
<td>
                <p>
                  37800
                </p>
              </td>
<td>
                <p>
                  41396
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  64
                </p>
              </td>
<td>
                <p>
                  27923
                </p>
              </td>
<td>
                <p>
                  39556
                </p>
              </td>
<td>
                <p>
                  44498
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  66
                </p>
              </td>
<td>
                <p>
                  30240
                </p>
              </td>
<td>
                <p>
                  44706
                </p>
              </td>
<td>
                <p>
                  47711
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  68
                </p>
              </td>
<td>
                <p>
                  32566
                </p>
              </td>
<td>
                <p>
                  47934
                </p>
              </td>
<td>
                <p>
                  51042
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  70
                </p>
              </td>
<td>
                <p>
                  35019
                </p>
              </td>
<td>
                <p>
                  51417
                </p>
              </td>
<td>
                <p>
                  54637
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  72
                </p>
              </td>
<td>
                <p>
                  37460
                </p>
              </td>
<td>
                <p>
                  55047
                </p>
              </td>
<td>
                <p>
                  58363
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  74
                </p>
              </td>
<td>
                <p>
                  40282
                </p>
              </td>
<td>
                <p>
                  58777
                </p>
              </td>
<td>
                <p>
                  62211
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  76
                </p>
              </td>
<td>
                <p>
                  42914
                </p>
              </td>
<td>
                <p>
                  62691
                </p>
              </td>
<td>
                <p>
                  66183
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  78
                </p>
              </td>
<td>
                <p>
                  45752
                </p>
              </td>
<td>
                <p>
                  66694
                </p>
              </td>
<td>
                <p>
                  70296
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  80
                </p>
              </td>
<td>
                <p>
                  48681
                </p>
              </td>
<td>
                <p>
                  70905
                </p>
              </td>
<td>
                <p>
                  74620
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  82
                </p>
              </td>
<td>
                <p>
                  51986
                </p>
              </td>
<td>
                <p>
                  77633
                </p>
              </td>
<td>
                <p>
                  79160
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  84
                </p>
              </td>
<td>
                <p>
                  54855
                </p>
              </td>
<td>
                <p>
                  82364
                </p>
              </td>
<td>
                <p>
                  83842
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  86
                </p>
              </td>
<td>
                <p>
                  59032
                </p>
              </td>
<td>
                <p>
                  87239
                </p>
              </td>
<td>
                <p>
                  88659
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  88
                </p>
              </td>
<td>
                <p>
                  63595
                </p>
              </td>
<td>
                <p>
                  92256
                </p>
              </td>
<td>
                <p>
                  93618
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  90
                </p>
              </td>
<td>
                <p>
                  68352
                </p>
              </td>
<td>
                <p>
                  97486
                </p>
              </td>
<td>
                <p>
                  98820
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  92
                </p>
              </td>
<td>
                <p>
                  72446
                </p>
              </td>
<td>
                <p>
                  102974
                </p>
              </td>
<td>
                <p>
                  104256
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  94
                </p>
              </td>
<td>
                <p>
                  76468
                </p>
              </td>
<td>
                <p>
                  108620
                </p>
              </td>
<td>
                <p>
                  109844
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  96
                </p>
              </td>
<td>
                <p>
                  80361
                </p>
              </td>
<td>
                <p>
                  111109
                </p>
              </td>
<td>
                <p>
                  115594
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  98
                </p>
              </td>
<td>
                <p>
                  84783
                </p>
              </td>
<td>
                <p>
                  121460
                </p>
              </td>
<td>
                <p>
                  121486
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  100
                </p>
              </td>
<td>
                <p>
                  89044
                </p>
              </td>
<td>
                <p>
                  127730
                </p>
              </td>
<td>
                <p>
                  127633
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  102
                </p>
              </td>
<td>
                <p>
                  93561
                </p>
              </td>
<td>
                <p>
                  134241
                </p>
              </td>
<td>
                <p>
                  134050
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  104
                </p>
              </td>
<td>
                <p>
                  98452
                </p>
              </td>
<td>
                <p>
                  140919
                </p>
              </td>
<td>
                <p>
                  140616
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  106
                </p>
              </td>
<td>
                <p>
                  103530
                </p>
              </td>
<td>
                <p>
                  147763
                </p>
              </td>
<td>
                <p>
                  147364
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  108
                </p>
              </td>
<td>
                <p>
                  108326
                </p>
              </td>
<td>
                <p>
                  154804
                </p>
              </td>
<td>
                <p>
                  154276
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  110
                </p>
              </td>
<td>
                <p>
                  113891
                </p>
              </td>
<td>
                <p>
                  162184
                </p>
              </td>
<td>
                <p>
                  161562
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  112
                </p>
              </td>
<td>
                <p>
                  119213
                </p>
              </td>
<td>
                <p>
                  169736
                </p>
              </td>
<td>
                <p>
                  169038
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  114
                </p>
              </td>
<td>
                <p>
                  124770
                </p>
              </td>
<td>
                <p>
                  182417
                </p>
              </td>
<td>
                <p>
                  176693
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  116
                </p>
              </td>
<td>
                <p>
                  130624
                </p>
              </td>
<td>
                <p>
                  190589
                </p>
              </td>
<td>
                <p>
                  184519
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  118
                </p>
              </td>
<td>
                <p>
                  137941
                </p>
              </td>
<td>
                <p>
                  198975
                </p>
              </td>
<td>
                <p>
                  192525
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  120
                </p>
              </td>
<td>
                <p>
                  144829
                </p>
              </td>
<td>
                <p>
                  207759
                </p>
              </td>
<td>
                <p>
                  200952
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  122
                </p>
              </td>
<td>
                <p>
                  152045
                </p>
              </td>
<td>
                <p>
                  216736
                </p>
              </td>
<td>
                <p>
                  209561
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  124
                </p>
              </td>
<td>
                <p>
                  158610
                </p>
              </td>
<td>
                <p>
                  225905
                </p>
              </td>
<td>
                <p>
                  218371
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  126
                </p>
              </td>
<td>
                <p>
                  165383
                </p>
              </td>
<td>
                <p>
                  235283
                </p>
              </td>
<td>
                <p>
                  227360
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  128
                </p>
              </td>
<td>
                <p>
                  173971
                </p>
              </td>
<td>
                <p>
                  230678
                </p>
              </td>
<td>
                <p>
                  236670
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  130
                </p>
              </td>
<td>
                <p>
                  181696
                </p>
              </td>
<td>
                <p>
                  248593
                </p>
              </td>
<td>
                <p>
                  246308
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  132
                </p>
              </td>
<td>
                <p>
                  189310
                </p>
              </td>
<td>
                <p>
                  258615
                </p>
              </td>
<td>
                <p>
                  256148
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  134
                </p>
              </td>
<td>
                <p>
                  197708
                </p>
              </td>
<td>
                <p>
                  268800
                </p>
              </td>
<td>
                <p>
                  266192
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  136
                </p>
              </td>
<td>
                <p>
                  205800
                </p>
              </td>
<td>
                <p>
                  279215
                </p>
              </td>
<td>
                <p>
                  276436
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  138
                </p>
              </td>
<td>
                <p>
                  212940
                </p>
              </td>
<td>
                <p>
                  290112
                </p>
              </td>
<td>
                <p>
                  287167
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  140
                </p>
              </td>
<td>
                <p>
                  217502
                </p>
              </td>
<td>
                <p>
                  301235
                </p>
              </td>
<td>
                <p>
                  298101
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  142
                </p>
              </td>
<td>
                <p>
                  223486
                </p>
              </td>
<td>
                <p>
                  312564
                </p>
              </td>
<td>
                <p>
                  309243
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  144
                </p>
              </td>
<td>
                <p>
                  229579
                </p>
              </td>
<td>
                <p>
                  324133
                </p>
              </td>
<td>
                <p>
                  320605
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  146
                </p>
              </td>
<td>
                <p>
                  237213
                </p>
              </td>
<td>
                <p>
                  344671
                </p>
              </td>
<td>
                <p>
                  332333
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  148
                </p>
              </td>
<td>
                <p>
                  248799
                </p>
              </td>
<td>
                <p>
                  357200
                </p>
              </td>
<td>
                <p>
                  344420
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  150
                </p>
              </td>
<td>
                <p>
                  261345
                </p>
              </td>
<td>
                <p>
                  369947
                </p>
              </td>
<td>
                <p>
                  356745
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  152
                </p>
              </td>
<td>
                <p>
                  272741
                </p>
              </td>
<td>
                <p>
                  382909
                </p>
              </td>
<td>
                <p>
                  369279
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  154
                </p>
              </td>
<td>
                <p>
                  283982
                </p>
              </td>
<td>
                <p>
                  396162
                </p>
              </td>
<td>
                <p>
                  382048
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  156
                </p>
              </td>
<td>
                <p>
                  293626
                </p>
              </td>
<td>
                <p>
                  409993
                </p>
              </td>
<td>
                <p>
                  395353
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  158
                </p>
              </td>
<td>
                <p>
                  304036
                </p>
              </td>
<td>
                <p>
                  424022
                </p>
              </td>
<td>
                <p>
                  408907
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  160
                </p>
              </td>
<td>
                <p>
                  313869
                </p>
              </td>
<td>
                <p>
                  427747
                </p>
              </td>
<td>
                <p>
                  422690
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  162
                </p>
              </td>
<td>
                <p>
                  323626
                </p>
              </td>
<td>
                <p>
                  454723
                </p>
              </td>
<td>
                <p>
                  436715
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  164
                </p>
              </td>
<td>
                <p>
                  333294
                </p>
              </td>
<td>
                <p>
                  469863
                </p>
              </td>
<td>
                <p>
                  451304
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  166
                </p>
              </td>
<td>
                <p>
                  343072
                </p>
              </td>
<td>
                <p>
                  485238
                </p>
              </td>
<td>
                <p>
                  466149
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  168
                </p>
              </td>
<td>
                <p>
                  352236
                </p>
              </td>
<td>
                <p>
                  500922
                </p>
              </td>
<td>
                <p>
                  481221
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  170
                </p>
              </td>
<td>
                <p>
                  362793
                </p>
              </td>
<td>
                <p>
                  516840
                </p>
              </td>
<td>
                <p>
                  496561
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  172
                </p>
              </td>
<td>
                <p>
                  372645
                </p>
              </td>
<td>
                <p>
                  533169
                </p>
              </td>
<td>
                <p>
                  512315
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  174
                </p>
              </td>
<td>
                <p>
                  382908
                </p>
              </td>
<td>
                <p>
                  549962
                </p>
              </td>
<td>
                <p>
                  528510
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  176
                </p>
              </td>
<td>
                <p>
                  392507
                </p>
              </td>
<td>
                <p>
                  567018
                </p>
              </td>
<td>
                <p>
                  544947
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  178
                </p>
              </td>
<td>
                <p>
                  404163
                </p>
              </td>
<td>
                <p>
                  597694
                </p>
              </td>
<td>
                <p>
                  561666
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  180
                </p>
              </td>
<td>
                <p>
                  417539
                </p>
              </td>
<td>
                <p>
                  615615
                </p>
              </td>
<td>
                <p>
                  578647
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  182
                </p>
              </td>
<td>
                <p>
                  432009
                </p>
              </td>
<td>
                <p>
                  634079
                </p>
              </td>
<td>
                <p>
                  596234
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  184
                </p>
              </td>
<td>
                <p>
                  444684
                </p>
              </td>
<td>
                <p>
                  652902
                </p>
              </td>
<td>
                <p>
                  614114
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  186
                </p>
              </td>
<td>
                <p>
                  457104
                </p>
              </td>
<td>
                <p>
                  672042
                </p>
              </td>
<td>
                <p>
                  632248
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  188
                </p>
              </td>
<td>
                <p>
                  469331
                </p>
              </td>
<td>
                <p>
                  691451
                </p>
              </td>
<td>
                <p>
                  650654
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  190
                </p>
              </td>
<td>
                <p>
                  481583
                </p>
              </td>
<td>
                <p>
                  711512
                </p>
              </td>
<td>
                <p>
                  669753
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  192
                </p>
              </td>
<td>
                <p>
                  477225
                </p>
              </td>
<td>
                <p>
                  698188
                </p>
              </td>
<td>
                <p>
                  689111
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  194
                </p>
              </td>
<td>
                <p>
                  488955
                </p>
              </td>
<td>
                <p>
                  736905
                </p>
              </td>
<td>
                <p>
                  708760
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  196
                </p>
              </td>
<td>
                <p>
                  499797
                </p>
              </td>
<td>
                <p>
                  757502
                </p>
              </td>
<td>
                <p>
                  728675
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  198
                </p>
              </td>
<td>
                <p>
                  511163
                </p>
              </td>
<td>
                <p>
                  778591
                </p>
              </td>
<td>
                <p>
                  749102
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
        The second <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../performance/rational_determinant_bench.cpp" target="_top">example</a>
        measures the time taken to calculate the determinant of a 3x3 matrix of rational
        numbers. These numbers are randomly generated with <span class="emphasis"><em>n</em></span>
        bits in both numerator and denominator. In this case the rate limiting step
        is the cost of calculating the GCD's during the computation:
      </p>
<div class="table">
<a name="boost_multiprecision.perf.rational_real_world.relative_time_taken_to_calculate"></a><p class="title"><b>Table 1.20. Relative Time Taken to Calculate 100 Determinants of Random 3x3 Matrixes</b></p>
<div class="table-contents"><table class="table" summary="Relative Time Taken to Calculate 100 Determinants of Random 3x3 Matrixes">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Bits
                </p>
              </th>
<th>
                <p>
                  cpp_rational (ms)
                </p>
              </th>
<th>
                <p>
                  mpq_rational (relative to cpp_rational)
                </p>
              </th>
<th>
                <p>
                  mpq_class (relative to cpp_rational)
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  512
                </p>
              </td>
<td>
                <p>
                  45
                </p>
              </td>
<td>
                <p>
                  0.3111111111
                </p>
              </td>
<td>
                <p>
                  0.3177777778
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  1024
                </p>
              </td>
<td>
                <p>
                  103
                </p>
              </td>
<td>
                <p>
                  0.3038834951
                </p>
              </td>
<td>
                <p>
                  0.3038834951
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  2048
                </p>
              </td>
<td>
                <p>
                  251
                </p>
              </td>
<td>
                <p>
                  0.3087649402
                </p>
              </td>
<td>
                <p>
                  0.3011952191
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  4096
                </p>
              </td>
<td>
                <p>
                  667
                </p>
              </td>
<td>
                <p>
                  0.2983508246
                </p>
              </td>
<td>
                <p>
                  0.2893553223
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  8192
                </p>
              </td>
<td>
                <p>
                  2033
                </p>
              </td>
<td>
                <p>
                  0.261682243
                </p>
              </td>
<td>
                <p>
                  0.2956222332
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  16384
                </p>
              </td>
<td>
                <p>
                  6423
                </p>
              </td>
<td>
                <p>
                  0.2358710883
                </p>
              </td>
<td>
                <p>
                  0.3059318076
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  32768
                </p>
              </td>
<td>
                <p>
                  24223
                </p>
              </td>
<td>
                <p>
                  0.1875903067
                </p>
              </td>
<td>
                <p>
                  0.1955992239
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.rational_real_world.platform"></a><p class="title"><b>Table 1.21. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="int_real_world.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="float_performance.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf/realworld.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Floating-Point Real World Tests</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../perf.html" title="Performance Comparison">
<link rel="prev" href="overhead.html" title="The Overhead in the Number Class Wrapper">
<link rel="next" href="int_real_world.html" title="Integer Real World Tests">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overhead.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="int_real_world.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.perf.realworld"></a><a class="link" href="realworld.html" title="Floating-Point Real World Tests">Floating-Point Real
      World Tests</a>
</h3></div></div></div>
<p>
        These tests test the total time taken to execute all of Boost.Math's test
        cases for these functions. In each case the best performing library gets
        a relative score of 1, with the total execution time given in brackets. Times
        are shown for both single threaded runs and concurrent execution - the latter
        increases contension inside new/delete.
      </p>
<div class="table">
<a name="boost_multiprecision.perf.realworld.bessel_functions_50_digit_precis"></a><p class="title"><b>Table 1.14. Bessel Functions (50 digit precision)</b></p>
<div class="table-contents"><table class="table" summary="Bessel Functions (50 digit precision)">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Type
                </p>
              </th>
<th>
                <p>
                  Time
                </p>
              </th>
<th>
                <div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
                      Allocations
                    </li></ol></div>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float_50
                </p>
              </td>
<td>
                <p>
                  2.24409 (0.207745s)
                </p>
              </td>
<td>
                <p>
                  399
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_bin_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  2.87977 (0.266594s)
                </p>
              </td>
<td>
                <p>
                  463
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float_50
                </p>
              </td>
<td>
                <p>
                  4.56157 (0.422285s)
                </p>
              </td>
<td>
                <p>
                  381
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  5.66114 (0.524077s)
                </p>
              </td>
<td>
                <p>
                  424
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50
                </p>
              </td>
<td>
                <p>
                  1.03648 (0.0959515s)
                </p>
              </td>
<td>
                <p>
                  640961
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  1.50439 (0.139268s)
                </p>
              </td>
<td>
                <p>
                  2563517
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50 (no expression templates
                </p>
              </td>
<td>
                <p>
                  1 (0.0925745s)
                </p>
              </td>
<td>
                <p>
                  1019039
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50 (no expression templates (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  1.52451 (0.141131s)
                </p>
              </td>
<td>
                <p>
                  4075842
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50
                </p>
              </td>
<td>
                <p>
                  1.2513 (0.115838s)
                </p>
              </td>
<td>
                <p>
                  583054
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  1.61301 (0.149324s)
                </p>
              </td>
<td>
                <p>
                  2330876
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50 (no expression templates
                </p>
              </td>
<td>
                <p>
                  1.42667 (0.132073s)
                </p>
              </td>
<td>
                <p>
                  999594
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50 (no expression templates (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  2.00203 (0.185337s)
                </p>
              </td>
<td>
                <p>
                  4000039
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  static_mpfr_float_50
                </p>
              </td>
<td>
                <p>
                  1.18358 (0.10957s)
                </p>
              </td>
<td>
                <p>
                  22930
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  static_mpfr_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  1.38802 (0.128496s)
                </p>
              </td>
<td>
                <p>
                  93140
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  static_mpfr_float_50 (no expression templates)
                </p>
              </td>
<td>
                <p>
                  1.14598 (0.106089s)
                </p>
              </td>
<td>
                <p>
                  46861
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  static_mpfr_float_50 (no expression templates) (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  1.24535 (0.115288s)
                </p>
              </td>
<td>
                <p>
                  189227
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.realworld.non_central_t_distribution_50_di"></a><p class="title"><b>Table 1.15. Non-central T Distribution (50 digit precision)</b></p>
<div class="table-contents"><table class="table" summary="Non-central T Distribution (50 digit precision)">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Type
                </p>
              </th>
<th>
                <p>
                  Time
                </p>
              </th>
<th>
                <div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
                      Allocations
                    </li></ol></div>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_bin_float_50
                </p>
              </td>
<td>
                <p>
                  2.38959 (38.5842s)
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_bin_float_50 (3 concurrent threads)
                </p>
              </td>
<td>
                <p>
                  3.50535 (56.6s)
                </p>
              </td>
<td>
                <p>
                  28
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float_50
                </p>
              </td>
<td>
                <p>
                  4.82763 (77.9505s)
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50
                </p>
              </td>
<td>
                <p>
                  1.06817 (17.2475s)
                </p>
              </td>
<td>
                <p>
                  123749688
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpf_float_50 (no expression templates
                </p>
              </td>
<td>
                <p>
                  1 (16.1468s)
                </p>
              </td>
<td>
                <p>
                  152610085
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50
                </p>
              </td>
<td>
                <p>
                  1.18754 (19.1749s)
                </p>
              </td>
<td>
                <p>
                  118401290
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr_float_50 (no expression templates
                </p>
              </td>
<td>
                <p>
                  1.36782 (22.0858s)
                </p>
              </td>
<td>
                <p>
                  152816346
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  static_mpfr_float_50
                </p>
              </td>
<td>
                <p>
                  1.04471 (16.8686s)
                </p>
              </td>
<td>
                <p>
                  113395
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.perf.realworld.platform"></a><p class="title"><b>Table 1.16. Platform Details</b></p>
<div class="table-contents"><table class="table" summary="Platform Details">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
              </th>
<th>
                <p>
                  Version
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  Compiler
                </p>
              </td>
<td>
                <p>
                  GNU C++ version 10.3.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  GMP
                </p>
              </td>
<td>
                <p>
                  6.2.0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  MPFR
                </p>
              </td>
<td>
                <p>
                  262146
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Boost
                </p>
              </td>
<td>
                <p>
                  107800
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  Run date
                </p>
              </td>
<td>
                <p>
                  Sep 30 2021
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overhead.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../perf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="int_real_world.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/perf.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Performance Comparison</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="ref/headers.html" title="Header File Structure">
<link rel="next" href="perf/overhead.html" title="The Overhead in the Number Class Wrapper">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ref/headers.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="perf/overhead.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.perf"></a><a class="link" href="perf.html" title="Performance Comparison">Performance Comparison</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="perf/overhead.html">The Overhead in the
      Number Class Wrapper</a></span></dt>
<dt><span class="section"><a href="perf/realworld.html">Floating-Point Real
      World Tests</a></span></dt>
<dt><span class="section"><a href="perf/int_real_world.html">Integer Real
      World Tests</a></span></dt>
<dt><span class="section"><a href="perf/rational_real_world.html">Rational
      Real World Tests</a></span></dt>
<dt><span class="section"><a href="perf/float_performance.html">Float Algorithm
      Performance</a></span></dt>
<dt><span class="section"><a href="perf/integer_performance.html">Integer
      Algorithm Performance</a></span></dt>
<dt><span class="section"><a href="perf/rational_performance.html">Rational
      Type Performance</a></span></dt>
</dl></div>
<p>
      In the beginning of the project and throughout, many performance analyses,
      counts of multiprecision-operations-per-second and the like have been performed.
      Some of these are already listed in the ensuing sections.
    </p>
<p>
      We will now provide some general notes on performance, valid for all of the
      multiprecision backends, before the detailed benchmarks of the following sections.
    </p>
<p>
      The header-only, library-independent Boost-licenses integer and floating-point
      backends including <a class="link" href="tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>
      for multiprecision integers, <a class="link" href="tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
      and <a class="link" href="tut/floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
      for multiprecision floating-point types are significantly slower than the world's
      fastest implementations generally agreed to be found in GMP/MPIR, MPFR and
      MPC (which are based on GMP). Complex types <a class="link" href="tut/complex/cpp_complex.html" title="cpp_complex">cpp_complex</a>
      that are synthesized from these types share similar relative performances.
    </p>
<p>
      The backends which effectively wrap GMP/MPIR and MPFR retain the superior performance
      of the low-level big-number engines. When these are used (in association with
      at least some level of optmization) they achieve and retain the expected low-level
      performances.
    </p>
<p>
      At low digit counts, however, it is noted that the performances of <a class="link" href="tut/ints/cpp_int.html" title="cpp_int">cpp_int</a>,
      <a class="link" href="tut/floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
      and <a class="link" href="tut/floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
      can actually meet or exceed those encountered for GMP/MPIR, MPFR, etc. The
      reason for this is because stack allocation and/or the use of fast container
      storage can actually out-perform the allocation mechanisms in GMP/MPIR, which
      dominate run-time costs at low digit counts.
    </p>
<p>
      As digit counts rise above about 50 or so, however, GMP/MPIR performance steadily
      increases, and simultaneously increases beyond (in relation to) the performances
      of the Boost-licensed, self-written backends. At around a few hundred to several
      thousands of digits, factors of about two through five are observed, whereby
      GMP/MPIR-based calculations are (performance-wise) supreior ones.
    </p>
<p>
      At a few thousand decimal digits, the upper end of the Boost backends is reached.
      At the moment, advanced big-number multiplication schemes in the Boost-licensed,
      self-written backends is limited to school multiplication and Karatsuba multiplication.
      Higher-orders of Toom-Cook and FFT-based multiplication are not (yet) implemented.
      So it is not yet feasible to perform mega-digit calculations with the Boost-licensed,
      self-written backends, whereas these are readily possible with the GMP/MPIR
      and MPRF based backends.
    </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ref/headers.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="perf/overhead.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/backendconc.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Backend Requirements</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="internals.html" title="Internal Support Code">
<link rel="next" href="headers.html" title="Header File Structure">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="internals.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="headers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.backendconc"></a><a class="link" href="backendconc.html" title="Backend Requirements">Backend Requirements</a>
</h3></div></div></div>
<p>
        The requirements on the <code class="computeroutput"><span class="identifier">Backend</span></code>
        template argument to <code class="computeroutput"><span class="identifier">number</span></code>
        are split up into sections: compulsory and optional.
      </p>
<p>
        Compulsory requirements have no default implementation in the library, therefore
        if the feature they implement is to be supported at all, then they must be
        implemented by the backend.
      </p>
<p>
        Optional requirements have default implementations that are called if the
        backend doesn't provide its own. Typically the backend will implement these
        to improve performance.
      </p>
<p>
        In the following tables, type B is the <code class="computeroutput"><span class="identifier">Backend</span></code>
        template argument to <code class="computeroutput"><span class="identifier">number</span></code>,
        <code class="computeroutput"><span class="identifier">b</span></code> and <code class="computeroutput"><span class="identifier">b2</span></code>
        are a variables of type B, <code class="computeroutput"><span class="identifier">pb</span></code>
        is a variable of type B*, <code class="computeroutput"><span class="identifier">cb</span></code>,
        <code class="computeroutput"><span class="identifier">cb2</span></code> and <code class="computeroutput"><span class="identifier">cb3</span></code>
        are constant variables of type <code class="computeroutput"><span class="keyword">const</span>
        <span class="identifier">B</span></code>, <code class="computeroutput"><span class="identifier">rb</span></code>
        is a variable of type <code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;&amp;</span></code>,
        <code class="computeroutput"><span class="identifier">a</span></code> and <code class="computeroutput"><span class="identifier">a2</span></code>
        are variables of Arithmetic type, <code class="computeroutput"><span class="identifier">s</span></code>
        is a variable of type <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span></code>, <code class="computeroutput"><span class="identifier">ui</span></code> is a variable of type <code class="computeroutput"><span class="keyword">unsigned</span></code>, <code class="computeroutput"><span class="identifier">bb</span></code>
        is a variable of type <code class="computeroutput"><span class="keyword">bool</span></code>,
        <code class="computeroutput"><span class="identifier">pa</span></code> is a variable of type
        pointer-to-arithmetic-type, <code class="computeroutput"><span class="identifier">exp</span></code>
        is a variable of type <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">exp_type</span></code>, <code class="computeroutput"><span class="identifier">pexp</span></code>
        is a variable of type <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">exp_type</span><span class="special">*</span></code>,
        <code class="computeroutput"><span class="identifier">i</span></code> is a variable of type
        <code class="computeroutput"><span class="keyword">int</span></code>, <code class="computeroutput"><span class="identifier">pi</span></code>
        pointer to a variable of type <code class="computeroutput"><span class="keyword">int</span></code>,
        B2 is another type that meets these requirements, b2 is a variable of type
        B2, <code class="computeroutput"><span class="identifier">ss</span></code> is variable of type
        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">streamsize</span></code> and <code class="computeroutput"><span class="identifier">ff</span></code>
        is a variable of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">fmtflags</span></code>.
      </p>
<div class="table">
<a name="boost_multiprecision.ref.backendconc.compulsory_requirements_on_the_b"></a><p class="title"><b>Table 1.8. Compulsory Requirements on the Backend type.</b></p>
<div class="table-contents"><table class="table" summary="Compulsory Requirements on the Backend type.">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Expression
                </p>
              </th>
<th>
                <p>
                  Return Type
                </p>
              </th>
<th>
                <p>
                  Comments
                </p>
              </th>
<th>
                <p>
                  Throws
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">-</span><span class="identifier">list</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  A list of signed integral types that can be assigned to type B.
                  The types shall be listed in order of size, smallest first, and
                  shall terminate in the type that is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">intmax_t</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">-</span><span class="identifier">list</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  A list of unsigned integral types that can be assigned to type
                  B. The types shall be listed in order of size, smallest first,
                  and shall terminate in the type that is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">uintmax_t</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">-</span><span class="identifier">list</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  A list of floating-point types that can be assigned to type B.The
                  types shall be listed in order of size, smallest first, and shall
                  terminate in type <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">exponent_type</span></code>
                </p>
              </td>
<td>
                <p>
                  A signed integral type.
                </p>
              </td>
<td>
                <p>
                  The type of the exponent of type B. This type is required only
                  for floating-point types.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">()</span></code>
                </p>
              </td>
<td>
              </td>
<td>
                <p>
                  Default constructor.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
              </td>
<td>
                <p>
                  Copy Constructor.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">b</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  Assignment operator.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">a</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  Assignment from an Arithmetic type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">s</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  Assignment from a string.
                </p>
              </td>
<td>
                <p>
                  Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> if the string could
                  not be interpreted as a valid number.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Swaps the contents of its arguments.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">ss</span><span class="special">,</span>
                  <span class="identifier">ff</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the string representation of <code class="computeroutput"><span class="identifier">b</span></code>
                  with <code class="computeroutput"><span class="identifier">ss</span></code> digits
                  and formatted according to the flags set in <code class="computeroutput"><span class="identifier">ff</span></code>.
                  If <code class="computeroutput"><span class="identifier">ss</span></code> is zero,
                  then returns as many digits as are required to reconstruct the
                  original value.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span><span class="special">.</span><span class="identifier">negate</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Negates <code class="computeroutput"><span class="identifier">b</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  Compares <code class="computeroutput"><span class="identifier">cb</span></code> and
                  <code class="computeroutput"><span class="identifier">cb2</span></code>, returns a
                  value less than zero if <code class="computeroutput"><span class="identifier">cb</span>
                  <span class="special">&lt;</span> <span class="identifier">cb2</span></code>,
                  a value greater than zero if <code class="computeroutput"><span class="identifier">cb</span>
                  <span class="special">&gt;</span> <span class="identifier">cb2</span></code>
                  and zero if <code class="computeroutput"><span class="identifier">cb</span> <span class="special">==</span> <span class="identifier">cb2</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  Compares <code class="computeroutput"><span class="identifier">cb</span></code> and
                  <code class="computeroutput"><span class="identifier">a</span></code>, returns a value
                  less than zero if <code class="computeroutput"><span class="identifier">cb</span>
                  <span class="special">&lt;</span> <span class="identifier">a</span></code>,
                  a value greater than zero if <code class="computeroutput"><span class="identifier">cb</span>
                  <span class="special">&gt;</span> <span class="identifier">a</span></code>
                  and zero if <code class="computeroutput"><span class="identifier">cb</span> <span class="special">==</span> <span class="identifier">a</span></code>.
                  The type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Adds <code class="computeroutput"><span class="identifier">cb</span></code> to <code class="computeroutput"><span class="identifier">b</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Subtracts <code class="computeroutput"><span class="identifier">cb</span></code> from
                  <code class="computeroutput"><span class="identifier">b</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">b</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Divides <code class="computeroutput"><span class="identifier">b</span></code> by <code class="computeroutput"><span class="identifier">cb</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if cb has the
                  value zero, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">has_infinity</span> <span class="special">==</span>
                  <span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">%=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if cb has the
                  value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">&amp;=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">|=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">^=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_complement</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes the ones-complement of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>,
                  only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an integer type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_left_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">&lt;&lt;=</span>
                  <span class="identifier">ui</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_right_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">&gt;&gt;=</span>
                  <span class="identifier">ui</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_convert_to</span><span class="special">(</span><span class="identifier">pa</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Converts <code class="computeroutput"><span class="identifier">cb</span></code> to
                  the type of <code class="computeroutput"><span class="special">*</span><span class="identifier">pa</span></code>
                  and store the result in <code class="computeroutput"><span class="special">*</span><span class="identifier">pa</span></code>. Type <code class="computeroutput"><span class="identifier">B</span></code>
                  shall support conversion to at least types <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">intmax_t</span></code>,
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">uintmax_t</span></code> and <code class="computeroutput"><span class="keyword">long</span>
                  <span class="keyword">long</span></code>. Conversion to other
                  arithmetic types can then be synthesised using other operations.
                  Conversions to other types are entirely optional.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_frexp</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">pexp</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores values in <code class="computeroutput"><span class="identifier">b</span></code>
                  and <code class="computeroutput"><span class="special">*</span><span class="identifier">pexp</span></code>
                  such that the value of <code class="computeroutput"><span class="identifier">cb</span></code>
                  is b * 2<sup>*pexp</sup>, only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is a floating-point type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_ldexp</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">exp</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores a value in <code class="computeroutput"><span class="identifier">b</span></code>
                  that is cb * 2<sup>exp</sup>, only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is a floating-point type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_frexp</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">pi</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores values in <code class="computeroutput"><span class="identifier">b</span></code>
                  and <code class="computeroutput"><span class="special">*</span><span class="identifier">pi</span></code>
                  such that the value of <code class="computeroutput"><span class="identifier">cb</span></code>
                  is b * 2<sup>*pi</sup>, only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is a floating-point type.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> if the exponent
                  of cb is too large to be stored in an <code class="computeroutput"><span class="keyword">int</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_ldexp</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">i</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores a value in <code class="computeroutput"><span class="identifier">b</span></code>
                  that is cb * 2<sup>i</sup>, only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is a floating-point type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_floor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores the floor of <code class="computeroutput"><span class="identifier">cb</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is a floating-point
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_ceil</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores the ceiling of <code class="computeroutput"><span class="identifier">cb</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is a floating-point
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_sqrt</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Stores the square root of <code class="computeroutput"><span class="identifier">cb</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is a floating-point
                  type.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">N</span></code> is one of the
                  values <code class="computeroutput"><span class="identifier">number_kind_integer</span></code>,
                  <code class="computeroutput"><span class="identifier">number_kind_floating_point</span></code>,
                  <code class="computeroutput"><span class="identifier">number_kind_complex</span></code>,
                  <code class="computeroutput"><span class="identifier">number_kind_rational</span></code>
                  or <code class="computeroutput"><span class="identifier">number_kind_fixed_point</span></code>.
                  Defaults to <code class="computeroutput"><span class="identifier">number_kind_floating_point</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_conj</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the complex
                  conjugate of <code class="computeroutput"><span class="identifier">cb</span></code>.
                  Required for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_proj</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the Riemann
                  projection of <code class="computeroutput"><span class="identifier">cb</span></code>.
                  Required for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_real</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the real
                  part of <code class="computeroutput"><span class="identifier">cb</span></code>. Required
                  for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_imag</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the imaginary
                  of <code class="computeroutput"><span class="identifier">cb</span></code>. Required
                  for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_set_real</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the real part of <code class="computeroutput"><span class="identifier">b</span></code>
                  to <code class="computeroutput"><span class="identifier">cb</span></code>. Required
                  for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_set_imag</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the imaginary part of <code class="computeroutput"><span class="identifier">b</span></code>
                  to <code class="computeroutput"><span class="identifier">cb</span></code>. Required
                  for complex types only - other types have a sensible default.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.ref.backendconc.optional_requirements_on_the_bac"></a><p class="title"><b>Table 1.9. Optional Requirements on the Backend Type</b></p>
<div class="table-contents"><table class="table" summary="Optional Requirements on the Backend Type">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Expression
                </p>
              </th>
<th>
                <p>
                  Returns
                </p>
              </th>
<th>
                <p>
                  Comments
                </p>
              </th>
<th>
                <p>
                  Throws
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>Construct and assign:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">(</span><span class="identifier">rb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span></code>
                </p>
              </td>
<td>
                <p>
                  Move constructor. Afterwards variable <code class="computeroutput"><span class="identifier">rb</span></code>
                  shall be in sane state, albeit with unspecified value. Only destruction
                  and assignment to the moved-from variable <code class="computeroutput"><span class="identifier">rb</span></code>
                  need be supported after the operation.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">rb</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  Move-assign. Afterwards variable <code class="computeroutput"><span class="identifier">rb</span></code>
                  shall be in sane state, albeit with unspecified value. Only destruction
                  and assignment to the moved-from variable <code class="computeroutput"><span class="identifier">rb</span></code>
                  need be supported after the operation.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span></code>
                </p>
              </td>
<td>
                <p>
                  Direct construction from an arithmetic type. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  this operation is simulated using default-construction followed
                  by assignment.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">(</span><span class="identifier">b2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span></code>
                </p>
              </td>
<td>
                <p>
                  Copy constructor from a different back-end type. When not provided,
                  a generic interconversion routine is used. This constructor may
                  be <code class="computeroutput"><span class="keyword">explicit</span></code> if the
                  corresponding frontend constructor should also be <code class="computeroutput"><span class="keyword">explicit</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">b2</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">b</span><span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  Assignment operator from a different back-end type. When not provided,
                  a generic interconversion routine is used.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">assign_components</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Assigns to <code class="computeroutput"><span class="identifier">b</span></code> the
                  two components in the following arguments. Only applies to rational
                  and complex number types. When not provided, arithmetic operations
                  are used to synthesise the result from the two values.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">assign_components</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">b2</span><span class="special">,</span> <span class="identifier">b2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Assigns to <code class="computeroutput"><span class="identifier">b</span></code> the
                  two components in the following arguments. Only applies to rational
                  and complex number types. When not provided, arithmetic operations
                  are used to synthesise the result from the two values.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>Comparisons:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_eq</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">cb2</span></code>
                  are equal in value. When not provided, the default implementation
                  returns <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">cb2</span><span class="special">)</span>
                  <span class="special">==</span> <span class="number">0</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_eq</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>
                  are equal in value. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  return the equivalent of <code class="computeroutput"><span class="identifier">eval_eq</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_eq</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>
                  are equal in value. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version returns <code class="computeroutput"><span class="identifier">eval_eq</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> is less than <code class="computeroutput"><span class="identifier">cb2</span></code> in value. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">cb2</span><span class="special">)</span> <span class="special">&lt;</span>
                  <span class="number">0</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> is less than <code class="computeroutput"><span class="identifier">a</span></code> in value. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">eval_lt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lt</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> is less than <code class="computeroutput"><span class="identifier">cb</span></code> in value. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">eval_gt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> is greater than <code class="computeroutput"><span class="identifier">cb2</span></code> in value. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">cb2</span><span class="special">)</span> <span class="special">&gt;</span>
                  <span class="number">0</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> is greater than <code class="computeroutput"><span class="identifier">a</span></code> in value. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">eval_gt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gt</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> is greater than <code class="computeroutput"><span class="identifier">cb</span></code> in value. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default implementation returns <code class="computeroutput"><span class="identifier">eval_lt</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_is_zero</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">cb</span></code> is zero, otherwise <code class="computeroutput"><span class="keyword">false</span></code>. The default version of this
                  function returns <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">ui_type</span><span class="special">(</span><span class="number">0</span><span class="special">))</span> <span class="special">==</span>
                  <span class="number">0</span></code>, where <code class="computeroutput"><span class="identifier">ui_type</span></code>
                  is <code class="computeroutput"><span class="identifier">ui_type</span></code> is
                  <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="keyword">typename</span>
                  <span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_get_sign</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns a value &lt; zero if <code class="computeroutput"><span class="identifier">cb</span></code>
                  is negative, a value &gt; zero if <code class="computeroutput"><span class="identifier">cb</span></code>
                  is positive, and zero if <code class="computeroutput"><span class="identifier">cb</span></code>
                  is zero. The default version of this function returns <code class="computeroutput"><span class="identifier">cb</span><span class="special">.</span><span class="identifier">compare</span><span class="special">(</span><span class="identifier">ui_type</span><span class="special">(</span><span class="number">0</span><span class="special">))</span></code>,
                  where <code class="computeroutput"><span class="identifier">ui_type</span></code> is
                  <code class="computeroutput"><span class="identifier">ui_type</span></code> is <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="keyword">typename</span>
                  <span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>Basic arithmetic:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Adds <code class="computeroutput"><span class="identifier">a</span></code> to <code class="computeroutput"><span class="identifier">b</span></code>. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Add <code class="computeroutput"><span class="identifier">cb</span></code> to <code class="computeroutput"><span class="identifier">cb2</span></code> and stores the result in
                  <code class="computeroutput"><span class="identifier">b</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Add <code class="computeroutput"><span class="identifier">cb</span></code> to <code class="computeroutput"><span class="identifier">a</span></code> and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Add <code class="computeroutput"><span class="identifier">a</span></code> to <code class="computeroutput"><span class="identifier">cb</span></code> and stores the result in
                  <code class="computeroutput"><span class="identifier">b</span></code>. The type of
                  <code class="computeroutput"><span class="identifier">a</span></code> shall be listed
                  in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Subtracts <code class="computeroutput"><span class="identifier">a</span></code> from
                  <code class="computeroutput"><span class="identifier">b</span></code>. The type of
                  <code class="computeroutput"><span class="identifier">a</span></code> shall be listed
                  in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Subtracts <code class="computeroutput"><span class="identifier">cb2</span></code> from
                  <code class="computeroutput"><span class="identifier">cb</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. When
                  not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Subtracts <code class="computeroutput"><span class="identifier">a</span></code> from
                  <code class="computeroutput"><span class="identifier">cb</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Subtracts <code class="computeroutput"><span class="identifier">cb</span></code> from
                  <code class="computeroutput"><span class="identifier">a</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">);</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">negate</span><span class="special">();</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">b</span></code> by
                  <code class="computeroutput"><span class="identifier">a</span></code>. The type of
                  <code class="computeroutput"><span class="identifier">a</span></code> shall be listed
                  in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and stores
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">a</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">a</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and adds the
                  result to <code class="computeroutput"><span class="identifier">b</span></code>. When
                  not provided does the equivalent of creating a temporary <code class="computeroutput"><span class="identifier">B</span> <span class="identifier">t</span></code>
                  and <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">a</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code> and adds the
                  result to <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided
                  does the equivalent of creating a temporary <code class="computeroutput"><span class="identifier">B</span>
                  <span class="identifier">t</span></code> and <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">a</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code> and adds the
                  result to <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and subtracts
                  the result from <code class="computeroutput"><span class="identifier">b</span></code>.
                  When not provided does the equivalent of creating a temporary
                  <code class="computeroutput"><span class="identifier">B</span> <span class="identifier">t</span></code>
                  and <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">a</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code> and subtracts
                  the result from <code class="computeroutput"><span class="identifier">b</span></code>.
                  The type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided
                  does the equivalent of creating a temporary <code class="computeroutput"><span class="identifier">B</span>
                  <span class="identifier">t</span></code> and <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">a</span></code> by
                  <code class="computeroutput"><span class="identifier">cb</span></code> and subtracts
                  the result from <code class="computeroutput"><span class="identifier">b</span></code>.
                  The type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">,</span> <span class="identifier">cb3</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and adds the
                  result to <code class="computeroutput"><span class="identifier">cb3</span></code> storing
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  When not provided does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb3</span><span class="special">)</span></code>. For brevity, only a version showing
                  all arguments of type <code class="computeroutput"><span class="identifier">B</span></code>
                  is shown here, but you can replace up to any 2 of <code class="computeroutput"><span class="identifier">cb</span></code>, <code class="computeroutput"><span class="identifier">cb2</span></code>
                  and <code class="computeroutput"><span class="identifier">cb3</span></code> with any
                  type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_multiply_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">,</span> <span class="identifier">cb3</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Multiplies <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and subtracts
                  from the result <code class="computeroutput"><span class="identifier">cb3</span></code>
                  storing the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  When not provided does the equivalent of <code class="computeroutput"><span class="identifier">eval_multiply</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb3</span><span class="special">)</span></code>. For brevity, only a version showing
                  all arguments of type <code class="computeroutput"><span class="identifier">B</span></code>
                  is shown here, but you can replace up to any 2 of <code class="computeroutput"><span class="identifier">cb</span></code>, <code class="computeroutput"><span class="identifier">cb2</span></code>
                  and <code class="computeroutput"><span class="identifier">cb3</span></code> with any
                  type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Divides <code class="computeroutput"><span class="identifier">b</span></code> by <code class="computeroutput"><span class="identifier">a</span></code>. The type of <code class="computeroutput"><span class="identifier">a</span></code> shall be listed in one of the
                  type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>, <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>
                  or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;</span>
                  <span class="special">&gt;::</span><span class="identifier">has_infinity</span>
                  <span class="special">==</span> <span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Divides <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">cb2</span></code> and stores
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">cb2</span></code> has the value zero, and
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;</span>
                  <span class="special">&gt;::</span><span class="identifier">has_infinity</span>
                  <span class="special">==</span> <span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Divides <code class="computeroutput"><span class="identifier">cb</span></code> by
                  <code class="computeroutput"><span class="identifier">a</span></code> and stores the
                  result in <code class="computeroutput"><span class="identifier">b</span></code>. The
                  type of <code class="computeroutput"><span class="identifier">a</span></code> shall
                  be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;</span>
                  <span class="special">&gt;::</span><span class="identifier">has_infinity</span>
                  <span class="special">==</span> <span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Divides <code class="computeroutput"><span class="identifier">a</span></code> by <code class="computeroutput"><span class="identifier">cb</span></code> and stores the result in
                  <code class="computeroutput"><span class="identifier">b</span></code>. The type of
                  <code class="computeroutput"><span class="identifier">a</span></code> shall be listed
                  in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_divide</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span> <span class="identifier">cb</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if cb has the
                  value zero, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">has_infinity</span> <span class="special">==</span>
                  <span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_increment</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  void
                </p>
              </td>
<td>
                <p>
                  Increments the value of <code class="computeroutput"><span class="identifier">b</span></code>
                  by one. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">eval_add</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">ui_type</span><span class="special">&gt;(</span><span class="number">1u</span><span class="special">))</span></code>.
                  Where <code class="computeroutput"><span class="identifier">ui_type</span></code> is
                  <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="keyword">typename</span>
                  <span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_decrement</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  void
                </p>
              </td>
<td>
                <p>
                  Decrements the value of <code class="computeroutput"><span class="identifier">b</span></code>
                  by one. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">eval_subtract</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">ui_type</span><span class="special">&gt;(</span><span class="number">1u</span><span class="special">))</span></code>.
                  Where <code class="computeroutput"><span class="identifier">ui_type</span></code> is
                  <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple_element</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="keyword">typename</span>
                  <span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>Integer specific operations:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">%=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">%</span>
                  <span class="identifier">cb2</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">%</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">%</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_modulus</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span> <span class="identifier">cb</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">&amp;=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&amp;</span>
                  <span class="identifier">cb2</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&amp;</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&amp;</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_and</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">|=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">|</span>
                  <span class="identifier">cb2</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">|</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">|</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_or</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">b</span> <span class="special">^=</span>
                  <span class="identifier">cb</span></code>, only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  the default version calls <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">^</span>
                  <span class="identifier">cb2</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">^</span>
                  <span class="identifier">a</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">a</span> <span class="special">^</span>
                  <span class="identifier">cb</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. When not provided,
                  does the equivalent of <code class="computeroutput"><span class="identifier">eval_bitwise_xor</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_left_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&lt;&lt;</span>
                  <span class="identifier">ui</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_left_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">);</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_right_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Computes <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&gt;&gt;</span>
                  <span class="identifier">ui</span></code> and stores the result
                  in <code class="computeroutput"><span class="identifier">b</span></code>, only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. When not provided, does the equivalent of <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span><span class="special">;</span> <span class="identifier">eval_right_shift</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">);</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_qr</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">,</span>
                  <span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">b2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the result
                  of <code class="computeroutput"><span class="identifier">cb</span> <span class="special">/</span>
                  <span class="identifier">cb2</span></code> and <code class="computeroutput"><span class="identifier">b2</span></code> to the result of <code class="computeroutput"><span class="identifier">cb</span> <span class="special">%</span>
                  <span class="identifier">cb2</span></code>. Only required when
                  <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_integer_modulus</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the result of <code class="computeroutput"><span class="identifier">cb</span>
                  <span class="special">%</span> <span class="identifier">ui</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an integer type. The default version of this function is synthesised
                  from other operations above.
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code> if <code class="computeroutput"><span class="identifier">a</span></code> has the value zero.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lsb</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the index of the least significant bit that is set. Only
                  required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an integer type. The default version of this function is synthesised
                  from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_msb</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the index of the most significant bit that is set. Only
                  required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an integer type. The default version of this function is synthesised
                  from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bit_test</span><span class="special">(</span><span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">bool</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns true if <code class="computeroutput"><span class="identifier">cb</span></code>
                  has bit <code class="computeroutput"><span class="identifier">ui</span></code> set.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an integer type. The default version of this function is synthesised
                  from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bit_set</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the bit at index <code class="computeroutput"><span class="identifier">ui</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bit_unset</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Unsets the bit at index <code class="computeroutput"><span class="identifier">ui</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_bit_flip</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">ui</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Flips the bit at index <code class="computeroutput"><span class="identifier">ui</span></code>
                  in <code class="computeroutput"><span class="identifier">b</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gcd</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the greatest
                  common divisor of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lcm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the least
                  common multiple of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gcd</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the greatest
                  common divisor of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. The default version
                  of this function calls <code class="computeroutput"><span class="identifier">eval_gcd</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lcm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the least
                  common multiple of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. The default version
                  of this function calls <code class="computeroutput"><span class="identifier">eval_lcm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">B</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_gcd</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the greatest
                  common divisor of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">a</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. The default version
                  of this function calls <code class="computeroutput"><span class="identifier">eval_gcd</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_lcm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the least
                  common multiple of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">a</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an integer
                  type. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>. The default version
                  of this function calls <code class="computeroutput"><span class="identifier">eval_lcm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_powm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">,</span>
                  <span class="identifier">cb3</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the result
                  of <span class="emphasis"><em>(cb^cb2)%cb3</em></span>. The default version of this
                  function is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_powm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the result
                  of <span class="emphasis"><em>(cb^cb2)%a</em></span>. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>. The default version
                  of this function is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_powm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the result
                  of <span class="emphasis"><em>(cb^a)%cb2</em></span>. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>. The default version
                  of this function is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_powm</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">a2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the result
                  of <span class="emphasis"><em>(cb^a)%a2</em></span>. The type of <code class="computeroutput"><span class="identifier">a</span></code>
                  shall be listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code>. The default version
                  of this function is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_integer_sqrt</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">b2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the largest
                  integer which when squared is less than <code class="computeroutput"><span class="identifier">cb</span></code>,
                  also sets <code class="computeroutput"><span class="identifier">b2</span></code> to
                  the remainder, ie to <span class="emphasis"><em>cb - b<sup>2</sup></em></span>. The default
                  version of this function is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>Sign manipulation:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_abs</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Set <code class="computeroutput"><span class="identifier">b</span></code> to the absolute
                  value of <code class="computeroutput"><span class="identifier">cb</span></code>. The
                  default version of this functions assigns <code class="computeroutput"><span class="identifier">cb</span></code>
                  to <code class="computeroutput"><span class="identifier">b</span></code>, and then
                  calls <code class="computeroutput"><span class="identifier">b</span><span class="special">.</span><span class="identifier">negate</span><span class="special">()</span></code>
                  if <code class="computeroutput"><span class="identifier">eval_get_sign</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span> <span class="special">&lt;</span>
                  <span class="number">0</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fabs</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Set <code class="computeroutput"><span class="identifier">b</span></code> to the absolute
                  value of <code class="computeroutput"><span class="identifier">cb</span></code>. The
                  default version of this functions assigns <code class="computeroutput"><span class="identifier">cb</span></code>
                  to <code class="computeroutput"><span class="identifier">b</span></code>, and then
                  calls <code class="computeroutput"><span class="identifier">b</span><span class="special">.</span><span class="identifier">negate</span><span class="special">()</span></code>
                  if <code class="computeroutput"><span class="identifier">eval_get_sign</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span> <span class="special">&lt;</span>
                  <span class="number">0</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>floating-point functions:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fpclassify</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns one of the same values returned by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fpclassify</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  will only test for zero <code class="computeroutput"><span class="identifier">cb</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_trunc</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">trunc</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_round</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">round</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_exp</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">exp</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_exp2</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">exp2</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is implemented in terms of <code class="computeroutput"><span class="identifier">eval_pow</span></code>.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_log</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">log</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_log10</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">log10</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_sin</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_cos</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cos</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_tan</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">exp</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_asin</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">asin</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_acos</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">acos</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_atan</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atan</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_sinh</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">sinh</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_cosh</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cosh</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_tanh</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tanh</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>
                  and stores the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmod</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fmod</span></code>
                  on arguments <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>, and store
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_modf</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">pb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">modf</span></code>
                  on argument <code class="computeroutput"><span class="identifier">cb</span></code>,
                  and store the integer result in <code class="computeroutput"><span class="special">*</span><span class="identifier">pb</span></code> and the fractional part in
                  <code class="computeroutput"><span class="identifier">b</span></code>. Only required
                  when <code class="computeroutput"><span class="identifier">B</span></code> is an floating-point
                  type. The default version of this function is synthesised from
                  other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_pow</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>
                  on arguments <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>, and store
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_atan2</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Performs the equivalent operation to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atan</span></code>
                  on arguments <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code>, and store
                  the result in <code class="computeroutput"><span class="identifier">b</span></code>.
                  Only required when <code class="computeroutput"><span class="identifier">B</span></code>
                  is an floating-point type. The default version of this function
                  is synthesised from other operations above.
                </p>
              </td>
<td>
                <p>
                   
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_scalbn</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">e</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Scales value <code class="computeroutput"><span class="identifier">cb</span></code>
                  by <span class="emphasis"><em>r<sup>e</sup></em></span>, where <span class="emphasis"><em>r</em></span> is the
                  radix of the type. The default version of this function is implemented
                  in terms of eval_ldexp, consequently this function must be provided
                  for types with a radix other than 2.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_scalbln</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">e</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Calls <code class="computeroutput"><span class="identifier">eval_scalbn</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">e</span><span class="special">)</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_ilogb</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">exponent_type</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the exponent <span class="emphasis"><em>e</em></span> of value <code class="computeroutput"><span class="identifier">cb</span></code> such that <span class="emphasis"><em>1 &lt;=
                  cb*r<sup>-e</sup> &lt; r</em></span>, where <span class="emphasis"><em>r</em></span> is the radix
                  of type B. The default version of this function is implemented
                  in terms of eval_frexp, consequently this function must be provided
                  for types with a radix other than 2.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remquo</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">,</span>
                  <span class="identifier">pi</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                  <span class="identifier">cb</span> <span class="special">-</span>
                  <span class="identifier">n</span> <span class="special">*</span>
                  <span class="identifier">cb2</span></code> and stores <code class="computeroutput"><span class="identifier">n</span></code> in <code class="computeroutput"><span class="special">*</span><span class="identifier">pi</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remquo</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">pi</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version converts a to type B and calls the overload above.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remquo</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">pi</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version converts a to type B and calls the overload above.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remainder</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version calls eval_remquo with a dummy final argument.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remainder</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version calls eval_remquo with a dummy final argument.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_remainder</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version calls eval_remquo with a dummy final argument.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fdim</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version sets <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span>
                  <span class="special">-</span> <span class="identifier">cb2</span></code>
                  if <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&gt;</span>
                  <span class="identifier">cb2</span></code> and zero otherwise.
                  Special cases are handled as in the C99 annex.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fdim</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version sets <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span>
                  <span class="special">-</span> <span class="identifier">cb2</span></code>
                  if <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&gt;</span>
                  <span class="identifier">cb2</span></code> and zero otherwise.
                  Special cases are handled as in the C99 annex.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fdim</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Default version sets <code class="computeroutput"><span class="identifier">b</span>
                  <span class="special">=</span> <span class="identifier">cb</span>
                  <span class="special">-</span> <span class="identifier">cb2</span></code>
                  if <code class="computeroutput"><span class="identifier">cb</span> <span class="special">&gt;</span>
                  <span class="identifier">cb2</span></code> and zero otherwise.
                  Special cases are handled as in the C99 annex.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmax</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the larger
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">cb2</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmax</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the larger
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmax</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the larger
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmin</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the smaller
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">cb2</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmin</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the smaller
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_fmin</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the smaller
                  of <code class="computeroutput"><span class="identifier">cb</span></code> and <code class="computeroutput"><span class="identifier">a</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_hypot</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">cb2</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the square
                  root of the sum of the squares of <code class="computeroutput"><span class="identifier">cb</span></code>
                  and <code class="computeroutput"><span class="identifier">cb2</span></code> without
                  undue over or under flow.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_hypot</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  As above.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_hypot</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  As above.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_logb</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">exponent_type</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the exponent
                  <span class="emphasis"><em>e</em></span> of value <code class="computeroutput"><span class="identifier">cb</span></code>
                  such that <span class="emphasis"><em>1 &lt;= cb*r<sup>-b</sup> &lt; r</em></span>, where <span class="emphasis"><em>r</em></span>
                  is the radix of type B. The default version of this function is
                  implemented in terms of <code class="computeroutput"><span class="identifier">eval_ilogb</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_nearbyint</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Calls <code class="computeroutput"><span class="identifier">eval_round</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_rint</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Calls <code class="computeroutput"><span class="identifier">eval_nearbyint</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">cb</span><span class="special">)</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">eval_log2</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span>
                  <span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets <code class="computeroutput"><span class="identifier">b</span></code> to the logarithm
                  base 2 of <code class="computeroutput"><span class="identifier">cb</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <span class="emphasis"><em>hashing:</em></span>
                </p>
              </td>
<td class="auto-generated"> </td>
<td class="auto-generated"> </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">hash_value</span><span class="special">(</span><span class="identifier">cb</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns a hash value for the argument that is suitable for use
                  with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">hash</span></code> etc. If not provided then
                  no automatic hashing support will be available for the number type.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
        When the tables above place no <span class="emphasis"><em>throws</em></span> requirements on
        an operation, then it is up to each type modelling this concept to decide
        when or whether throwing an exception is desirable. However, thrown exceptions
        should always either be the type, or inherit from the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>.
        For example, a floating-point type might choose to throw <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
        whenever the result of an operation would be infinite, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">underflow_error</span></code>
        whenever it would round to zero.
      </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          The non-member functions are all named with an "eval_" prefix
          to avoid conflicts with template classes of the same name - in point of
          fact this naming convention shouldn't be necessary, but rather works around
          some compiler bugs.
        </p></td></tr>
</table></div>
<h5>
<a name="boost_multiprecision.ref.backendconc.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.backendconc.overloadable_functions"></a></span><a class="link" href="backendconc.html#boost_multiprecision.ref.backendconc.overloadable_functions">Overloadable
        Functions</a>
      </h5>
<p>
        Some of the C99 math functions do not have <code class="computeroutput"><span class="identifier">eval_</span></code>
        functions but must be overloaded directly: these functions are either trivial
        or are forwarded to the Boost.Math implementations by default. The full list
        of these functions is:
      </p>
<pre class="programlisting"><span class="keyword">int</span>           <span class="identifier">sign</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>          <span class="identifier">signbit</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">changesign</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">copysign</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">asinh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">acosh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">atanh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">cbrt</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">erf</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">erfc</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">expm1</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">log1p</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">tgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">lgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span>          <span class="identifier">lrint</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span> <span class="keyword">long</span>     <span class="identifier">llrint</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">nextafter</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>        <span class="identifier">nexttoward</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="internals.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="headers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/cpp_bin_float_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_bin_float</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="mpfr_ref.html" title="mpfr_float_backend">
<link rel="next" href="cpp_dec_ref.html" title="cpp_dec_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.cpp_bin_float_ref"></a><a class="link" href="cpp_bin_float_ref.html" title="cpp_bin_float">cpp_bin_float</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">enum</span> <span class="identifier">digit_base_type</span>
<span class="special">{</span>
   <span class="identifier">digit_base_2</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span>
   <span class="identifier">digit_base_10</span> <span class="special">=</span> <span class="number">10</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">digit_base_type</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">ExponentMin</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">ExponentMax</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_bin_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_100</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">24</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">126</span><span class="special">,</span> <span class="number">127</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>         <span class="identifier">cpp_bin_float_single</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">1022</span><span class="special">,</span> <span class="number">1023</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>       <span class="identifier">cpp_bin_float_double</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>     <span class="identifier">cpp_bin_float_double_extended</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>    <span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">237</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="special">-</span><span class="number">262142</span><span class="special">,</span> <span class="number">262143</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>  <span class="identifier">cpp_bin_float_oct</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The class takes six template parameters:
      </p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Digits</span></dt>
<dd><p>
              The number of digits precision the type should support. This is normally
              expressed as base-10 digits, but that can be changed via the second
              template parameter.
            </p></dd>
<dt><span class="term">base</span></dt>
<dd><p>
              An enumerated value (either <code class="computeroutput"><span class="identifier">digit_base_10</span></code>
              or <code class="computeroutput"><span class="identifier">digit_base_2</span></code>) that
              indicates whether <code class="computeroutput"><span class="identifier">Digits</span></code>
              is base-10 or base-2
            </p></dd>
<dt><span class="term">Allocator</span></dt>
<dd><p>
              The allocator used: defaults to type <code class="computeroutput"><span class="keyword">void</span></code>,
              meaning all storage is within the class, and no dynamic allocation
              is performed, but can be set to a standard library allocator if dynamic
              allocation makes more sense.
            </p></dd>
<dt><span class="term">Exponent</span></dt>
<dd><p>
              A signed integer type to use as the type of the exponent - defaults
              to <code class="computeroutput"><span class="keyword">int</span></code>.
            </p></dd>
<dt><span class="term">ExponentMin</span></dt>
<dd><p>
              The smallest (most negative) permitted exponent, defaults to zero,
              meaning "define as small as possible given the limitations of
              the type and our internal requirements".
            </p></dd>
<dt><span class="term">ExponentMax</span></dt>
<dd><p>
              The largest (most positive) permitted exponent, defaults to zero, meaning
              "define as large as possible given the limitations of the type
              and our internal requirements".
            </p></dd>
</dl>
</div>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/floats/cpp_bin_float.html" title="cpp_bin_float">tutorial</a>.
      </p>
<h5>
<a name="boost_multiprecision.ref.cpp_bin_float_ref.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.cpp_bin_float_ref.implementation_notes"></a></span><a class="link" href="cpp_bin_float_ref.html#boost_multiprecision.ref.cpp_bin_float_ref.implementation_notes">Implementation
        Notes</a>
      </h5>
<p>
        Internally, an N-bit <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
        is represented as an N-bit unsigned integer along with an exponent and a
        sign. The integer part is normalized so that its most significant bit is
        always 1. The decimal point is assumed to be directly after the most significant
        bit of the integer part. The special values zero, infinity and NaN all have
        the integer part set to zero, and the exponent to one of 3 special values
        above the maximum permitted exponent.
      </p>
<p>
        Multiplication is trivial: multiply the two N-bit integer mantissa's to obtain
        a 2N-bit number, then round and adjust the sign and exponent.
      </p>
<p>
        Addition and subtraction proceed similarly - if the exponents are such that
        there is overlap between the two values, then left shift the larger value
        to produce a number with between N and 2N bits, then perform integer addition
        or subtraction, round, and adjust the exponent.
      </p>
<p>
        Division proceeds as follows: first scale the numerator by some power of
        2 so that integer division will produce either an N-bit or N+1 bit result
        plus a remainder. If we get an N bit result then the size of twice the remainder
        compared to the denominator gives us the rounding direction. Otherwise we
        have one extra bit in the result which we can use to determine rounding (in
        this case ties occur only if the remainder is zero and the extra bit is a
        1).
      </p>
<p>
        Square root uses integer square root in a manner analogous to division.
      </p>
<p>
        Decimal string to binary conversion proceeds as follows: first parse the
        digits to produce an integer multiplied by a decimal exponent. Note that
        we stop parsing digits once we have parsed as many as can possibly effect
        the result - this stops the integer part growing too large when there are
        a very large number of input digits provided. At this stage if the decimal
        exponent is positive then the result is an integer and we can in principle
        simply multiply by 10^N to get an exact integer result. In practice however,
        that could produce some very large integers. We also need to be able to divide
        by 10^N in the event that the exponent is negative. Therefore calculation
        of the 10^N values plus the multiplication or division are performed using
        limited precision integer arithmetic, plus an exponent, and a track of the
        accumulated error. At the end of the calculation we will either be able to
        round unambiguously, or the error will be such that we can't tell which way
        to round. In the latter case we simply up the precision and try again until
        we have an unambiguously rounded result.
      </p>
<p>
        Binary to decimal conversion proceeds very similarly to the above, our aim
        is to calculate <code class="computeroutput"><span class="identifier">mantissa</span> <span class="special">*</span> <span class="number">2</span><span class="special">^</span><span class="identifier">shift</span> <span class="special">*</span> <span class="number">10</span><span class="special">^</span><span class="identifier">E</span></code>
        where <code class="computeroutput"><span class="identifier">E</span></code> is the decimal exponent
        and <code class="computeroutput"><span class="identifier">shift</span></code> is calculated so
        that the result is an N bit integer assuming we want N digits printed in
        the result. As before we use limited precision arithmetic to calculate the
        result and up the precision as necessary until the result is unambiguously
        correctly rounded. In addition our initial calculation of the decimal exponent
        may be out by 1, so we have to correct that and loop as well in the that
        case.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/cpp_dec_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_dec_float</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="cpp_bin_float_ref.html" title="cpp_bin_float">
<link rel="next" href="internals.html" title="Internal Support Code">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.cpp_dec_ref"></a><a class="link" href="cpp_dec_ref.html" title="cpp_dec_float">cpp_dec_float</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExponentType</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_dec_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_100</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The class takes three template parameters:
      </p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Digits10</span></dt>
<dd><p>
              The number of decimal digits precision the type should support. Note
              that this type does not normally perform any dynamic memory allocation,
              and as a result the <code class="computeroutput"><span class="identifier">Digits10</span></code>
              template argument should not be set too high or the class's size will
              grow unreasonably large.
            </p></dd>
<dt><span class="term">ExponentType</span></dt>
<dd><p>
              A signed integer type that represents the exponent of the number
            </p></dd>
<dt><span class="term">Allocator</span></dt>
<dd><p>
              The allocator used: defaults to type <code class="computeroutput"><span class="keyword">void</span></code>,
              meaning all storage is within the class, and no dynamic allocation
              is performed, but can be set to a standard library allocator if dynamic
              allocation makes more sense.
            </p></dd>
</dl>
</div>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/floats/cpp_dec_float.html" title="cpp_dec_float">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="internals.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/cpp_int_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_int</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="number.html" title="number">
<link rel="next" href="gmp_int_ref.html" title="gmp_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="number.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.cpp_int_ref"></a><a class="link" href="cpp_int_ref.html" title="cpp_int">cpp_int</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">type</span> <span class="identifier">limb_type</span><span class="special">;</span>

<span class="keyword">enum</span> <span class="identifier">cpp_integer_type</span>    <span class="special">{</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span> <span class="special">};</span>
<span class="keyword">enum</span> <span class="identifier">cpp_int_check_type</span>  <span class="special">{</span> <span class="identifier">checked</span><span class="special">,</span> <span class="identifier">unchecked</span> <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">MinDigits</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
          <span class="keyword">unsigned</span> <span class="identifier">MaxDits</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
          <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span> <span class="special">=</span> <span class="identifier">signed_magnitude</span><span class="special">,</span>
          <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span> <span class="special">=</span> <span class="identifier">unchecked</span><span class="special">,</span>
          <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">limb_type</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_int_backend</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// Expression templates default to et_off if there is no allocator:</span>
<span class="comment">//</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">MinDigits</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">MaxDigits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">expression_template_default</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinDigits</span><span class="special">,</span> <span class="identifier">MaxDigits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="special">{</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">expression_template_option</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">et_off</span><span class="special">;</span> <span class="special">};</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span>              <span class="identifier">cpp_int</span><span class="special">;</span>    <span class="comment">// arbitrary precision integer</span>
<span class="keyword">typedef</span> <span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span>    <span class="identifier">cpp_rational_backend</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_rational_backend</span><span class="special">&gt;</span>            <span class="identifier">cpp_rational</span><span class="special">;</span> <span class="comment">// arbitrary precision rational number</span>

<span class="comment">// Fixed precision unsigned types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">uint1024_t</span><span class="special">;</span>

<span class="comment">// Fixed precision signed types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">int1024_t</span><span class="special">;</span>

<span class="comment">// Over again, but with checking enabled this time:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">&gt;</span> <span class="special">&gt;</span>                 <span class="identifier">checked_cpp_int</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_cpp_rational_backend</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">checked_cpp_rational_backend</span><span class="special">&gt;</span>                                      <span class="identifier">checked_cpp_rational</span><span class="special">;</span>

<span class="comment">// Checked fixed precision unsigned types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">checked_uint1024_t</span><span class="special">;</span>

<span class="comment">// Fixed precision signed types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_int1024_t</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The template arguments are:
      </p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">MinBits</span></dt>
<dd><p>
              Determines the number of Bits to store directly within the object before
              resorting to dynamic memory allocation. When zero, this field is determined
              automatically based on how many bits can be stored in union with the
              dynamic storage header: setting a larger value may improve performance
              as larger integer values will be stored internally before memory allocation
              is required.
            </p></dd>
<dt><span class="term">MaxBits</span></dt>
<dd><p>
              Determines the maximum number of bits to be stored in the type: resulting
              in a fixed precision type. When this value is the same as MinBits,
              then the Allocator parameter is ignored, as no dynamic memory allocation
              will ever be performed: in this situation the Allocator parameter should
              be set to type <code class="computeroutput"><span class="keyword">void</span></code>. Note
              that this parameter should not be used simply to prevent large memory
              allocations, not only is that role better performed by the allocator,
              but fixed precision integers have a tendency to allocate all of MaxBits
              of storage more often than one would expect.
            </p></dd>
<dt><span class="term">SignType</span></dt>
<dd><p>
              Determines whether the resulting type is signed or not. Note that for
              <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
              precision</a> types this parameter must be <code class="computeroutput"><span class="identifier">signed_magnitude</span></code>.
              For fixed precision types then this type may be either <code class="computeroutput"><span class="identifier">signed_magnitude</span></code> or <code class="computeroutput"><span class="identifier">unsigned_magnitude</span></code>.
            </p></dd>
<dt><span class="term">Checked</span></dt>
<dd><p>
              This parameter has two values: <code class="computeroutput"><span class="identifier">checked</span></code>
              or <code class="computeroutput"><span class="identifier">unchecked</span></code>. See the
              <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">tutorial</a>
              for more information.
            </p></dd>
<dt><span class="term">Allocator</span></dt>
<dd><p>
              The allocator to use for dynamic memory allocation, or type <code class="computeroutput"><span class="keyword">void</span></code> if MaxBits == MinBits.
            </p></dd>
</dl>
</div>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_integer</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/ints/cpp_int.html" title="cpp_int">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="number.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/gmp_int_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>gmp_int</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="cpp_int_ref.html" title="cpp_int">
<link rel="next" href="tom_int_ref.html" title="tom_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tom_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.gmp_int_ref"></a><a class="link" href="gmp_int_ref.html" title="gmp_int">gmp_int</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">gmp_int</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span> <span class="special">&gt;</span>         <span class="identifier">mpz_int</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">gmp_int</span></code> fulfils
        all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_integer</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/ints/gmp_int.html" title="gmp_int">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tom_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/headers.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Header File Structure</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="backendconc.html" title="Backend Requirements">
<link rel="next" href="../perf.html" title="Performance Comparison">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="backendconc.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../perf.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.headers"></a><a class="link" href="headers.html" title="Header File Structure">Header File Structure</a>
</h3></div></div></div>
<div class="table">
<a name="boost_multiprecision.ref.headers.top_level_headers"></a><p class="title"><b>Table 1.10. Top level headers</b></p>
<div class="table-contents"><table class="table" summary="Top level headers">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Contains
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int.hpp
                </p>
              </td>
<td>
                <p>
                  The <code class="computeroutput"><span class="identifier">cpp_int</span></code> backend
                  type.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  gmp.hpp
                </p>
              </td>
<td>
                <p>
                  Defines all <a href="http://gmplib.org" target="_top">GMP</a> related
                  backends.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  miller_rabin.hpp
                </p>
              </td>
<td>
                <p>
                  Miller Rabin primality testing code.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  number.hpp
                </p>
              </td>
<td>
                <p>
                  Defines the <code class="computeroutput"><span class="identifier">number</span></code>
                  backend, is included by all the backend headers.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  mpfr.hpp
                </p>
              </td>
<td>
                <p>
                  Defines the mpfr_float_backend backend.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  random.hpp
                </p>
              </td>
<td>
                <p>
                  Defines code to interoperate with Boost.Random.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  rational_adaptor.hpp
                </p>
              </td>
<td>
                <p>
                  Defines the <code class="computeroutput"><span class="identifier">rational_adaptor</span></code>
                  backend.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_dec_float.hpp
                </p>
              </td>
<td>
                <p>
                  Defines the <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
                  backend.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tommath.hpp
                </p>
              </td>
<td>
                <p>
                  Defines the <code class="computeroutput"><span class="identifier">tommath_int</span></code>
                  backend.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  concepts/number_archetypes.hpp
                </p>
              </td>
<td>
                <p>
                  Defines a backend concept archetypes for testing use.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.ref.headers.implementation_headers"></a><p class="title"><b>Table 1.11. Implementation Headers</b></p>
<div class="table-contents"><table class="table" summary="Implementation Headers">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Contains
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  cpp_int/add.hpp
                </p>
              </td>
<td>
                <p>
                  Add and subtract operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/bitwise.hpp
                </p>
              </td>
<td>
                <p>
                  Bitwise operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/checked.hpp
                </p>
              </td>
<td>
                <p>
                  Helper functions for checked arithmetic for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/comparison.hpp
                </p>
              </td>
<td>
                <p>
                  Comparison operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/cpp_int_config.hpp
                </p>
              </td>
<td>
                <p>
                  Basic setup and configuration for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/divide.hpp
                </p>
              </td>
<td>
                <p>
                  Division and modulus operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/limits.hpp
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
                  support for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/misc.hpp
                </p>
              </td>
<td>
                <p>
                  Miscellaneous operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cpp_int/multiply.hpp
                </p>
              </td>
<td>
                <p>
                  Multiply operators for <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/default_ops.hpp
                </p>
              </td>
<td>
                <p>
                  Default versions of the optional backend non-member functions.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/generic_interconvert.hpp
                </p>
              </td>
<td>
                <p>
                  Generic interconversion routines.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/number_base.hpp
                </p>
              </td>
<td>
                <p>
                  All the expression template code, metaprogramming, and operator
                  overloads for <code class="computeroutput"><span class="identifier">number</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/no_et_ops.hpp
                </p>
              </td>
<td>
                <p>
                  The non-expression template operators.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/functions/constants.hpp
                </p>
              </td>
<td>
                <p>
                  Defines constants used by the floating-point functions.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/functions/pow.hpp
                </p>
              </td>
<td>
                <p>
                  Defines default versions of the power and exponential related floating-point
                  functions.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  detail/functions/trig.hpp
                </p>
              </td>
<td>
                <p>
                  Defines default versions of the trigonometric related floating-point
                  functions.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="backendconc.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../perf.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/internals.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Internal Support Code</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="cpp_dec_ref.html" title="cpp_dec_float">
<link rel="next" href="backendconc.html" title="Backend Requirements">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="backendconc.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.internals"></a><a class="link" href="internals.html" title="Internal Support Code">Internal Support
      Code</a>
</h3></div></div></div>
<p>
        There are some traits classes which authors of new backends should be aware
        of:
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">To</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_explicitly_convertible</span><span class="special">;</span>

<span class="special">}}}</span>
</pre>
<p>
        Inherits from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span><span class="keyword">true</span><span class="special">&gt;</span></code> if type <code class="computeroutput"><span class="identifier">From</span></code>
        has an explicit conversion from <code class="computeroutput"><span class="identifier">To</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_lossy_conversion</span>
<span class="special">{</span>
   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">see</span> <span class="identifier">below</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        Member <code class="computeroutput"><span class="identifier">value</span></code> is true if the
        conversion from <code class="computeroutput"><span class="identifier">From</span></code> to
        <code class="computeroutput"><span class="identifier">To</span></code> would result in a loss
        of precision, and <code class="computeroutput"><span class="keyword">false</span></code> otherwise.
      </p>
<p>
        The default version of this trait simply checks whether the <span class="emphasis"><em>kind</em></span>
        of conversion (for example from a floating-point to an integer type) is inherently
        lossy. Note that if either of the types <code class="computeroutput"><span class="identifier">From</span></code>
        or <code class="computeroutput"><span class="identifier">To</span></code> are of an unknown number
        category (because <code class="computeroutput"><span class="identifier">number_category</span></code>
        is not specialised for that type) then this trait will be <code class="computeroutput"><span class="keyword">true</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">To</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_restricted_conversion</span>
<span class="special">{</span>
   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">see</span> <span class="identifier">below</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        Member <code class="computeroutput"><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">From</span></code>
        is only explicitly convertible to <code class="computeroutput"><span class="identifier">To</span></code>
        and not implicitly convertible, or if <code class="computeroutput"><span class="identifier">is_lossy_conversion</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>.
        Otherwise <code class="computeroutput"><span class="keyword">false</span></code>.
      </p>
<p>
        Note that while this trait is the ultimate arbiter of which constructors
        are marked as <code class="computeroutput"><span class="keyword">explicit</span></code> in class
        <code class="computeroutput"><span class="identifier">number</span></code>, authors of backend
        types should generally specialise one of the traits above, rather than this
        one directly.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="identifier">is_signed_number</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="identifier">is_unsigned_number</span><span class="special">;</span>
</pre>
<p>
        These two traits inherit from either <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
        <span class="keyword">true</span><span class="special">&gt;</span></code>
        or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">false</span><span class="special">&gt;</span></code>, by default types are assumed to be signed
        unless <code class="computeroutput"><span class="identifier">is_unsigned_number</span></code>
        is specialized for that type.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_dec_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="backendconc.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/mpf_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>gmp_float</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="tom_int_ref.html" title="tom_int">
<link rel="next" href="mpfr_ref.html" title="mpfr_float_backend">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tom_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.mpf_ref"></a><a class="link" href="mpf_ref.html" title="gmp_float">gmp_float</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">gmp_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpf_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpf_float_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpf_float_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpf_float_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpf_float</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">gmp_float</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The class takes a single template parameter - <code class="computeroutput"><span class="identifier">Digits10</span></code>
        - which is the number of decimal digits precision the type should support.
        When this parameter is zero, then the precision can be set at runtime via
        <code class="computeroutput"><span class="identifier">number</span><span class="special">::</span><span class="identifier">default_precision</span></code> and <code class="computeroutput"><span class="identifier">number</span><span class="special">::</span><span class="identifier">precision</span></code>.
        Note that this type does not in any way change the GMP library's global state
        (for example it does not change the default precision of the mpf_t data type),
        therefore you can safely mix this type with existing code that uses GMP,
        and also mix <code class="computeroutput"><span class="identifier">gmp_float</span></code>s of
        differing precision.
      </p>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/floats/gmp_float.html" title="gmp_float">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tom_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpfr_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/mpfr_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>mpfr_float_backend</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="mpf_ref.html" title="gmp_float">
<link rel="next" href="cpp_bin_float_ref.html" title="cpp_bin_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.mpfr_ref"></a><a class="link" href="mpfr_ref.html" title="mpfr_float_backend">mpfr_float_backend</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">mpfr_float_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpfr_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfr_float_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfr_float_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpfr_float_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpfr_float</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The class takes a single template parameter - <code class="computeroutput"><span class="identifier">Digits10</span></code>
        - which is the number of decimal digits precision the type should support.
        When this parameter is zero, then the precision can be set at runtime via
        <code class="computeroutput"><span class="identifier">number</span><span class="special">::</span><span class="identifier">default_precision</span></code> and <code class="computeroutput"><span class="identifier">number</span><span class="special">::</span><span class="identifier">precision</span></code>.
        Note that this type does not in any way change the GMP or MPFR library's
        global state (for example it does not change the default precision of the
        mpfr_t data type), therefore you can safely mix this type with existing code
        that uses GMP or MPFR, and also mix <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>s
        of differing precision.
      </p>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpf_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_bin_float_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/number.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>number</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="../ref.html" title="Reference">
<link rel="next" href="cpp_int_ref.html" title="cpp_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.number"></a><a class="link" href="number.html" title="number">number</a>
</h3></div></div></div>
<h5>
<a name="boost_multiprecision.ref.number.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.synopsis"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.synopsis">Synopsis</a>
      </h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">enum</span> <span class="identifier">expression_template_option</span> <span class="special">{</span> <span class="identifier">et_on</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">et_off</span> <span class="special">=</span> <span class="number">0</span> <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">expression_template_default</span>
<span class="special">{</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">expression_template_option</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">et_on</span><span class="special">;</span> <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span> <span class="special">=</span> <span class="identifier">expression_template_default</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">number</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">typedef</span>          <span class="identifier">Backend</span>                          <span class="identifier">backend_type</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">component_type</span><span class="special">&lt;</span><span class="identifier">self_type</span><span class="special">&gt;::</span><span class="identifier">type</span>  <span class="identifier">value_type</span><span class="special">;</span>

   <span class="keyword">static</span> <span class="keyword">constexpr</span> <span class="identifier">expression_template_option</span> <span class="identifier">et</span> <span class="special">=</span> <span class="identifier">ExpressionTemplates</span><span class="special">;</span>

   <span class="identifier">number</span><span class="special">();</span>
   <span class="identifier">number</span><span class="special">(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>

   <span class="comment">// Member operators</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--();</span>
   <span class="identifier">number</span>  <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
   <span class="identifier">number</span>  <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span>

   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
   <span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>

   <span class="comment">// Use in Boolean context:</span>
   <span class="keyword">operator</span> <span class="emphasis"><em>convertible-to-bool-type</em></span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="comment">// swap:</span>
   <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">number</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
   <span class="comment">// Sign:</span>
   <span class="keyword">bool</span> <span class="identifier">is_zero</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">int</span> <span class="identifier">sign</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="comment">// string conversion:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">str</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="comment">// Generic conversion mechanism</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
   <span class="identifier">T</span> <span class="identifier">convert_to</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
   <span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="identifier">T</span> <span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="comment">// precision control:</span>
   <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">default_precision</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">default_precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">);</span>
   <span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">void</span> <span class="identifier">precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">);</span>
   <span class="comment">// Comparison:</span>
   <span class="keyword">int</span> <span class="identifier">compare</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;&amp;</span> <span class="identifier">o</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">V</span><span class="special">&gt;</span>
   <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">V</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;,</span> <span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span>
      <span class="identifier">compare</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">V</span><span class="special">&amp;</span> <span class="identifier">o</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
   <span class="comment">// real and imaginary parts:</span>
   <span class="identifier">value_type</span> <span class="identifier">real</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="identifier">value_type</span> <span class="identifier">imag</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
   <span class="keyword">void</span> <span class="identifier">real</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
   <span class="keyword">void</span> <span class="identifier">imag</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
   <span class="comment">// Access to the underlying implementation:</span>
   <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">();</span>
   <span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
<span class="special">};</span>

<span class="comment">// Non member operators:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="comment">// Integer only operations:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
<span class="comment">// Comparison operators:</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>

<span class="comment">// Swap:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// iostream support:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>unmentionable-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&gt;&gt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="identifier">is</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>

<span class="comment">// to_string support:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>

<span class="comment">// Arithmetic with a higher precision result:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">subtract</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="comment">// min and max overloads:</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">min</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">max</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="comment">// C99 Non-member function standard library support:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">abs</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">acos</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">acosh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">asin</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">asinh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">atan</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">atan2</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">atanh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">cbrt</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ceil</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">copysign</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">cos</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">cosh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">erf</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">erfc</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">exp</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">exp2</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">expm1</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fabs</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fdim</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">floor</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fma</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmin</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmax</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmod</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">frexp</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">*);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">hypot</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>integer-type</em></span>                              <span class="identifier">ilogb</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ldexp</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">lgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span> <span class="keyword">long</span>                                 <span class="identifier">llrint</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span> <span class="keyword">long</span>                                 <span class="identifier">llround</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log2</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log10</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">log1p</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">logb</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span>                                      <span class="identifier">lrint</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span>                                      <span class="identifier">lround</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">modf</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">nearbyint</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">nextafter</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">nexttoward</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">pow</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">remainder</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">remquo</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">*);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">rint</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">round</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">scalbn</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">scalbln</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sin</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sinh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sqrt</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">tan</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">tanh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">tgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">trunc</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="keyword">int</span>                                       <span class="identifier">fpclassify</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isfinite</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isinf</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isnan</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isnormal</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">signbit</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="keyword">bool</span>                                      <span class="identifier">isgreater</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isgreaterequal</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isless</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">islessequal</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-typearea</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">islessgreater</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isunordered</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="comment">// Complex number functions:</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">real</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">imag</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">abs</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">arg</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">norm</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">conj</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">proj</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">polar</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="comment">// Misc other common C library functions:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">itrunc</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ltrunc</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">lltrunc</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">iround</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">changesign</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">copysign</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="comment">// Traits support:</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">component_type</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">number_category</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_number</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_number_expression</span><span class="special">;</span>

<span class="comment">// Integer specific functions:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">gcd</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">lcm</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">pow</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">unsigned</span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">powm</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">EXpressionTemplates</span><span class="special">&gt;</span>      <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">EXpressionTemplates</span><span class="special">&gt;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">divide_qr</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span>
               <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span> <span class="identifier">integer_modulus</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Integer</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">unsigned</span> <span class="identifier">lsb</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">unsigned</span> <span class="identifier">msb</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">bit_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_unset</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_flip</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Engine</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">,</span> <span class="identifier">Engine</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">);</span>

<span class="comment">// Rational number support:</span>
<span class="keyword">typename</span> <span class="identifier">component_type</span><span class="special">&lt;</span><span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">numerator</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">typename</span> <span class="identifier">component_type</span><span class="special">&lt;</span><span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>

<span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>

<span class="comment">// Boost.Math interoperability functions:</span>
<span class="keyword">int</span>                                              <span class="identifier">fpclassify</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span>                                             <span class="identifier">isfinite</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span>                                             <span class="identifier">isnan</span>          <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span>                                             <span class="identifier">isinf</span>          <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span>                                             <span class="identifier">isnormal</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>

<span class="comment">// numeric_limits support:</span>
<span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="special">{</span>
   <span class="comment">/* Usual members here */</span>
<span class="special">};</span>

<span class="special">}</span>
</pre>
<h5>
<a name="boost_multiprecision.ref.number.h1"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.description"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.description">Description</a>
      </h5>
<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">expression_template_option</span> <span class="special">{</span> <span class="identifier">et_on</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">et_off</span> <span class="special">=</span> <span class="number">0</span> <span class="special">};</span>
</pre>
<p>
        This enumerated type is used to specify whether expression templates are
        turned on (et_on) or turned off (et_off).
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">expression_template_default</span>
<span class="special">{</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">expression_template_option</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">et_on</span><span class="special">;</span> <span class="special">};</span>
</pre>
<p>
        This traits class specifies the default expression template option to be
        used with a particular Backend type. It defaults to <code class="computeroutput"><span class="identifier">et_on</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span> <span class="special">=</span> <span class="identifier">expression_template_default</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">number</span><span class="special">;</span>
</pre>
<p>
        Class <code class="computeroutput"><span class="identifier">number</span></code> has two template
        arguments:
      </p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">Backend</span></dt>
<dd><p>
              The actual arithmetic back-end that does all the work.
            </p></dd>
<dt><span class="term">ExpressionTemplates</span></dt>
<dd><p>
              A Boolean value: when <code class="computeroutput"><span class="identifier">et_on</span></code>,
              then expression templates are enabled, otherwise when set to <code class="computeroutput"><span class="identifier">et_off</span></code> they are disabled. The default
              for this parameter is computed via the traits class <code class="computeroutput"><span class="identifier">expression_template_default</span></code>
              whose member <code class="computeroutput"><span class="identifier">value</span></code>
              defaults to <code class="computeroutput"><span class="identifier">et_on</span></code> unless
              the traits class is specialized for a particular backend.
            </p></dd>
</dl>
</div>
<pre class="programlisting"><span class="identifier">number</span><span class="special">();</span>
<span class="identifier">number</span><span class="special">(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">see</span><span class="special">-</span><span class="identifier">below</span><span class="special">);</span>
</pre>
<p>
        Type <code class="computeroutput"><span class="identifier">number</span></code> is default constructible,
        and both copy constructible and assignable from:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Itself.
          </li>
<li class="listitem">
            An expression template which is the result of one of the arithmetic operators.
          </li>
<li class="listitem">
            Any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> arithmetic type, as long as the result would not be
            lossy (for example float to integer conversion).
          </li>
<li class="listitem">
            Any type that the Backend is implicitly constructible or assignable from.
          </li>
<li class="listitem">
            An rvalue reference to another <code class="computeroutput"><span class="identifier">number</span></code>.
            Move-semantics are used for construction if the backend also supports
            rvalue reference construction. In the case of assignment, move semantics
            are always supported when the argument is an rvalue reference irrespective
            of the backend.
          </li>
<li class="listitem">
            Any type in the same family, as long as no loss of precision is involved.
            For example from <code class="computeroutput"><span class="identifier">int128_t</span></code>
            to <code class="computeroutput"><span class="identifier">int256_t</span></code>, or <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code> to <code class="computeroutput"><span class="identifier">cpp_dec_float_100</span></code>.
          </li>
</ul></div>
<p>
        Type <code class="computeroutput"><span class="identifier">number</span></code> is explicitly
        constructible from:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Any type mentioned above.
          </li>
<li class="listitem">
            A <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> or any type which is convertible
            to <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span></code>.
          </li>
<li class="listitem">
            Any arithmetic type (including those that would result in lossy conversions).
          </li>
<li class="listitem">
            Any type in the same family, including those that result in loss of precision.
          </li>
<li class="listitem">
            Any type that the Backend is explicitly constructible from.
          </li>
<li class="listitem">
            Any pair of types for which a generic interconversion exists: that is
            from integer to integer, integer to rational, integer to float, rational
            to rational, rational to float, or float to float.
          </li>
</ul></div>
<p>
        The assign member function is available for any type for which an explicit
        converting constructor exists. It is intended to be used where a temporary
        generated from an explicit assignment would be expensive, for example:
      </p>
<pre class="programlisting"><span class="identifier">mpfr_float_50</span>    <span class="identifier">f50</span><span class="special">;</span>
<span class="identifier">mpfr_float_100</span>   <span class="identifier">f100</span><span class="special">;</span>

<span class="identifier">f50</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">mpfr_float_50</span><span class="special">&gt;(</span><span class="identifier">f100</span><span class="special">);</span>  <span class="comment">// explicit cast create a temporary</span>
<span class="identifier">f50</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">f100</span><span class="special">);</span>                        <span class="comment">// explicit call to assign create no temporary</span>
</pre>
<p>
        In addition, if the type has multiple components (for example rational or
        complex number types), then there is a two argument constructor:
      </p>
<pre class="programlisting"><span class="identifier">number</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span><span class="special">);</span>
</pre>
<p>
        Where the two args must either be arithmetic types, or types that are convertible
        to the two components of <code class="computeroutput"><span class="keyword">this</span></code>.
        Rvalue forwarding overloads are provided so either one or both arguments
        may be rvalue-references which will be moved into the result, if the backend
        is able to make use of them.
      </p>
<p>
        Finally, when the type has a variable precision, then there are constructors:
      </p>
<pre class="programlisting"><span class="identifier">number</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">precision</span><span class="special">);</span>
<span class="identifier">number</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span><span class="special">,</span> <span class="identifier">precision</span><span class="special">);</span>
</pre>
<p>
        Where <code class="computeroutput"><span class="identifier">precision</span></code> is an unsigned
        value, the 2 arg version is active for scalar types and/or copy-construction
        with specific precision, and the 3-arg version for complex types.
      </p>
<p>
        Likewise <code class="computeroutput"><span class="identifier">assign</span></code> has a 2-arg
        overloaded, with the second argument being the precision.
      </p>
<pre class="programlisting"><span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--();</span>
<span class="identifier">number</span>  <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
<span class="identifier">number</span>  <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span>
<span class="comment">// Integer only operations:</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
<span class="identifier">number</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
</pre>
<p>
        These operators all take their usual arithmetic meanings.
      </p>
<p>
        The arguments to these operators is either:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Another <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span>
            <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            An expression template derived from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            Any type implicitly convertible to <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span></code>, including some other instance of
            class <code class="computeroutput"><span class="identifier">number</span></code>.
          </li>
</ul></div>
<p>
        For the left and right shift operations, the argument must be a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer type with a positive value (negative values result
        in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> being thrown).
      </p>
<pre class="programlisting"><span class="keyword">operator</span> <span class="emphasis"><em>convertible-to-bool-type</em></span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns an <span class="emphasis"><em>unmentionable-type</em></span> that is usable in Boolean
        contexts (this allows <code class="computeroutput"><span class="identifier">number</span></code>
        to be used in any Boolean context - if statements, conditional statements,
        or as an argument to a logical operator - without type <code class="computeroutput"><span class="identifier">number</span></code>
        being convertible to type <code class="computeroutput"><span class="keyword">bool</span></code>.
      </p>
<p>
        This operator also enables the use of <code class="computeroutput"><span class="identifier">number</span></code>
        with any of the following operators: <code class="computeroutput"><span class="special">!</span></code>,
        <code class="computeroutput"><span class="special">||</span></code>, <code class="computeroutput"><span class="special">&amp;&amp;</span></code>
        and <code class="computeroutput"><span class="special">?:</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">number</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre>
<p>
        Swaps <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        with <code class="computeroutput"><span class="identifier">other</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_zero</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns <code class="computeroutput"><span class="keyword">true</span></code> is <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is zero,
        otherwise <code class="computeroutput"><span class="keyword">false</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">sign</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns a value less than zero if <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is negative, a value greater than zero
        if <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is positive, and zero if <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is zero.
      </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">str</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">scientific</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns the number formatted as a string, with at least <span class="emphasis"><em>precision</em></span>
        digits, and in scientific format if <span class="emphasis"><em>scientific</em></span> is true.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="identifier">T</span> <span class="identifier">convert_to</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="identifier">T</span> <span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Provides a generic conversion mechanism to convert <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> to type <code class="computeroutput"><span class="identifier">T</span></code>.
        Type <code class="computeroutput"><span class="identifier">T</span></code> may be any arithmetic
        type. Optionally other types may also be supported by specific <code class="computeroutput"><span class="identifier">Backend</span></code> types.
      </p>
<pre class="programlisting"><span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">default_precision</span><span class="special">();</span>
<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">default_precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">);</span>
<span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">);</span>
</pre>
<p>
        These functions are only available if the Backend template parameter supports
        runtime changes to precision. They get and set the default precision and
        the precision of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        respectively.
      </p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">compare</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">o</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">V</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">V</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;,</span> <span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span>
   <span class="identifier">compare</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">V</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A value less that 0 for <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">&lt;</span> <span class="identifier">other</span></code>
          </li>
<li class="listitem">
            A value greater that 0 for <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">&gt;</span> <span class="identifier">other</span></code>
          </li>
<li class="listitem">
<p class="simpara">
            Zero for <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span>
            <span class="special">==</span> <span class="identifier">other</span></code>
          </p>
<pre class="programlisting"><span class="identifier">value_type</span> <span class="identifier">real</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
<span class="identifier">value_type</span> <span class="identifier">imag</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
</li>
</ul></div>
<p>
        These return the real and imaginary parts respectively. If the number is
        not a complex type, then the imaginary part is always zero.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">real</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">imag</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
        These set the real and imaginary parts respectively of the number. If the
        number is not a complex type, then setting the real part is equivalent to
        assignment, and attempting to set the imaginary part will result in a compile
        time error.
      </p>
<pre class="programlisting"><span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">();</span>
<span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">backend</span><span class="special">()</span><span class="keyword">const</span><span class="special">;</span>
</pre>
<p>
        Returns the underlying back-end instance used by <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h2"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.non_member_operators"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.non_member_operators">Non-member
        operators</a>
      </h5>
<pre class="programlisting"><span class="comment">// Non member operators:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="comment">// Integer only operations:</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>integer-type</em></span><span class="special">&amp;);</span>
<span class="comment">// Comparison operators:</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>see-below</em></span><span class="special">&amp;);</span>
</pre>
<p>
        These operators all take their usual arithmetic meanings.
      </p>
<p>
        The arguments to these functions must contain at least one of the following:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A <code class="computeroutput"><span class="identifier">number</span></code>.
          </li>
<li class="listitem">
            An expression template type derived from <code class="computeroutput"><span class="identifier">number</span></code>.
          </li>
<li class="listitem">
            Any type for which <code class="computeroutput"><span class="identifier">number</span></code>
            has an implicit constructor - for example a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> arithmetic type.
          </li>
</ul></div>
<p>
        The return type of these operators is either:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            An <span class="emphasis"><em>unmentionable-type</em></span> expression template type when
            <code class="computeroutput"><span class="identifier">ExpressionTemplates</span></code> is
            <code class="computeroutput"><span class="keyword">true</span></code>.
          </li>
<li class="listitem">
            Type <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span>
            <span class="identifier">et_off</span><span class="special">&gt;</span></code>
            when <code class="computeroutput"><span class="identifier">ExpressionTemplates</span></code>
            is <code class="computeroutput"><span class="keyword">false</span></code>.
          </li>
<li class="listitem">
            Type <code class="computeroutput"><span class="keyword">bool</span></code> if the operator
            is a comparison operator.
          </li>
</ul></div>
<p>
        Finally note that the second argument to the left and right shift operations
        must be a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer type, and that the argument must be positive (negative
        arguments result in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
        being thrown).
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h3"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.swap"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.swap">swap</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Swaps <code class="computeroutput"><span class="identifier">a</span></code> and <code class="computeroutput"><span class="identifier">b</span></code>.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h4"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.iostream_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.iostream_support">Iostream
        Support</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Unspecified</span><span class="special">...&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">unmentionable</span><span class="special">-</span><span class="identifier">expression</span><span class="special">-</span><span class="keyword">template</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">&gt;&gt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="identifier">is</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">)</span>
</pre>
<p>
        These operators provided formatted input-output operations on <code class="computeroutput"><span class="identifier">number</span></code> types, and expression templates
        derived from them.
      </p>
<p>
        It's down to the back-end type to actually implement string conversion. However,
        the back-ends provided with this library support all of the iostream formatting
        flags, field width and precision settings.
      </p>
<p>
        In addition, the C++11 <code class="computeroutput"><span class="identifier">to_string</span></code>
        function is provided for use in generic code:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
        This a string with 6 digits of accuracy past the decimal point, matching
        the behavior of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">to_string</span></code>. Note that this is a <span class="emphasis"><em>fixed
        precision</em></span> representation, and hence monstrous strings can be returned.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h5"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.arithmetic_with_a_higher_precisi"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.arithmetic_with_a_higher_precisi">Arithmetic
        with a higher precision result</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">subtract</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        These functions apply the named operator to the arguments <span class="emphasis"><em>a</em></span>
        and <span class="emphasis"><em>b</em></span> and store the result in <span class="emphasis"><em>result</em></span>,
        returning <span class="emphasis"><em>result</em></span>. In all cases they behave "as
        if" arguments <span class="emphasis"><em>a</em></span> and <span class="emphasis"><em>b</em></span> were
        first promoted to type <code class="computeroutput"><span class="identifier">ResultType</span></code>
        before applying the operator, though particular backends may well avoid that
        step by way of an optimization.
      </p>
<p>
        The type <code class="computeroutput"><span class="identifier">ResultType</span></code> must
        be an instance of class <code class="computeroutput"><span class="identifier">number</span></code>,
        and the types <code class="computeroutput"><span class="identifier">Source1</span></code> and
        <code class="computeroutput"><span class="identifier">Source2</span></code> may be either instances
        of class <code class="computeroutput"><span class="identifier">number</span></code> or native
        integer types. The latter is an optimization that allows arithmetic to be
        performed on native integer types producing an extended precision result.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h6"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.non_member_standard_library_func"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.non_member_standard_library_func">Non-member
        standard library function support</a>
      </h5>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">abs</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">acos</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">acosh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">asin</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">asinh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">atan</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">atan2</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">atanh</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">cbrt</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ceil</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">copysign</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">cos</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">cosh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">erf</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">erfc</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">exp</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">exp2</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">expm1</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fabs</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fdim</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">floor</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fma</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmin</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmax</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">fmod</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">frexp</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">*);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">hypot</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>integer-type</em></span>                              <span class="identifier">ilogb</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ldexp</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">lgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span> <span class="keyword">long</span>                                 <span class="identifier">llrint</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span> <span class="keyword">long</span>                                 <span class="identifier">llround</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log2</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">log10</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">log1p</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">logb</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span>                                      <span class="identifier">lrint</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">long</span>                                      <span class="identifier">lround</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">modf</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">nearbyint</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">nextafter</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">nexttoward</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">pow</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">remainder</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">remquo</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">*);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">rint</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">round</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">scalbn</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">scalbln</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="emphasis"><em>integer-type</em></span><span class="special">);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sin</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sinh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sqrt</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">tan</span>        <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">tanh</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">tgamma</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">trunc</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="keyword">int</span>                                       <span class="identifier">fpclassify</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isfinite</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isinf</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isnan</span>      <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isnormal</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">signbit</span>    <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>

<span class="keyword">bool</span>                                      <span class="identifier">isgreater</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isgreaterequal</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isless</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">islessequal</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">islessgreater</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">bool</span>                                      <span class="identifier">isunordered</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
</pre>
<p>
        These functions all behave exactly as their standard library C++11 counterparts
        do: their argument is either an instance of <code class="computeroutput"><span class="identifier">number</span></code>
        or an expression template derived from it; If the argument is of type <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span></code>
        then that is also the return type, otherwise the return type is an expression
        template unless otherwise stated.
      </p>
<p>
        The integer type arguments to <code class="computeroutput"><span class="identifier">ldexp</span></code>,
        <code class="computeroutput"><span class="identifier">frexp</span></code>, <code class="computeroutput"><span class="identifier">scalbn</span></code>
        and <code class="computeroutput"><span class="identifier">ilogb</span></code> may be either type
        <code class="computeroutput"><span class="keyword">int</span></code>, or the actual type of the
        exponent of the number type.
      </p>
<p>
        Complex number types support the following functions:
      </p>
<pre class="programlisting"><span class="comment">// Complex number functions:</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">real</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">imag</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">abs</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">arg</span>   <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number&lt;...&gt;::value_type</em></span>                   <span class="identifier">norm</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">conj</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">proj</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">polar</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
</pre>
<p>
        In addition the functions <code class="computeroutput"><span class="identifier">real</span></code>,
        <code class="computeroutput"><span class="identifier">imag</span></code>, <code class="computeroutput"><span class="identifier">arg</span></code>,
        <code class="computeroutput"><span class="identifier">norm</span></code>, <code class="computeroutput"><span class="identifier">conj</span></code>
        and <code class="computeroutput"><span class="identifier">proj</span></code> are overloaded for
        scalar (ie non-complex) types in the same manner as <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span></code>
        and treat the argument as a value whose imaginary part is zero.
      </p>
<p>
        There are also some functions implemented for compatibility with the Boost.Math
        functions of the same name:
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">itrunc</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">ltrunc</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">lltrunc</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">iround</span> <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">changesign</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="emphasis"><em>number</em></span>                                    <span class="identifier">copysign</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
</pre>
<p>
        All these functions are normally implemented by the Backend type. However,
        default versions are provided for Backend types that don't have native support
        for these functions. Please note however, that this default support requires
        the precision of the type to be a compile time constant - this means for
        example that the <a href="http://gmplib.org" target="_top">GMP</a> MPF Backend will
        not work with these functions when that type is used at variable precision.
      </p>
<p>
        Also note that with the exception of <code class="computeroutput"><span class="identifier">abs</span></code>
        that these functions can only be used with floating-point Backend types (if
        any other types such as fixed precision or complex types are added to the
        library later, then these functions may be extended to support those number
        types).
      </p>
<p>
        The precision of these functions is generally determined by the backend implementation.
        For example the precision of these functions when used with <a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>
        is determined entirely by <a href="http://www.mpfr.org" target="_top">MPFR</a>.
        When these functions use our own implementations, the accuracy of the transcendental
        functions is generally a few epsilon. Note however, that the trigonometrical
        functions incur the usual accuracy loss when reducing arguments by large
        multiples of π. Also note that both <a class="link" href="../tut/floats/gmp_float.html" title="gmp_float">gmp_float</a>
        and <a class="link" href="../tut/floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
        have a number of guard digits beyond their stated precision, so the error
        rates listed for these are in some sense artificially low.
      </p>
<p>
        The following table shows the error rates we observe for these functions
        with various backend types, functions not listed here are exact (tested on
        Win32 with VC++10, MPFR-3.0.0, MPIR-2.1.1):
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Function
                </p>
              </th>
<th>
                <p>
                  mpfr_float_50
                </p>
              </th>
<th>
                <p>
                  mpf_float_50
                </p>
              </th>
<th>
                <p>
                  cpp_dec_float_50
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  sqrt
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  exp
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  log
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  log10
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cos
                </p>
              </td>
<td>
                <p>
                  700eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  sin
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tan
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  acos
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  asin
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  atan
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  cosh
                </p>
              </td>
<td>
                <p>
                  1045eps<a href="#ftn.boost_multiprecision.ref.number.f0" class="footnote" name="boost_multiprecision.ref.number.f0"><sup class="footnote">[1]</sup></a>
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  sinh
                </p>
              </td>
<td>
                <p>
                  2eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  tanh
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  pow
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  4eps
                </p>
              </td>
<td>
                <p>
                  3eps
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  atan2
                </p>
              </td>
<td>
                <p>
                  1eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
<td>
                <p>
                  0eps
                </p>
              </td>
</tr>
</tbody>
<tbody class="footnotes"><tr><td colspan="4"><div id="ftn.boost_multiprecision.ref.number.f0" class="footnote"><p><a href="#boost_multiprecision.ref.number.f0" class="para"><sup class="para">[1] </sup></a>
                    It's likely that the inherent error in the input values to our
                    test cases are to blame here.
                  </p></div></td></tr></tbody>
</table></div>
<h5>
<a name="boost_multiprecision.ref.number.h7"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.traits_class_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.traits_class_support">Traits Class
        Support</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">component_type</span><span class="special">;</span>
</pre>
<p>
        If this is a type with multiple components (for example rational or complex
        types), then this trait has a single member <code class="computeroutput"><span class="identifier">type</span></code>
        that is the type of those components.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">number_category</span><span class="special">;</span>
</pre>
<p>
        A traits class that inherits from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">N</span><span class="special">&gt;</span></code>
        where <code class="computeroutput"><span class="identifier">N</span></code> is one of the enumerated
        values <code class="computeroutput"><span class="identifier">number_kind_integer</span></code>,
        <code class="computeroutput"><span class="identifier">number_kind_floating_point</span></code>,
        <code class="computeroutput"><span class="identifier">number_kind_rational</span></code>, <code class="computeroutput"><span class="identifier">number_kind_fixed_point</span></code>, or <code class="computeroutput"><span class="identifier">number_kind_unknown</span></code>. This traits class
        is specialized for any type that has <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
        support as well as for classes in this library: which means it can be used
        for generic code that must work with <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> arithmetic types as well as multiprecision ones.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_number</span><span class="special">;</span>
</pre>
<p>
        A traits class that inherits from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
        <span class="keyword">true</span><span class="special">&gt;</span></code>
        if T is an instance of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;&gt;</span></code>, otherwise from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
        <span class="keyword">false</span><span class="special">&gt;</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_number_expression</span><span class="special">;</span>
</pre>
<p>
        A traits class that inherits from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
        <span class="keyword">true</span><span class="special">&gt;</span></code>
        if T is an expression template type derived from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;&gt;</span></code>, otherwise from <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
        <span class="keyword">false</span><span class="special">&gt;</span></code>.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h8"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.integer_functions"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.integer_functions">Integer
        functions</a>
      </h5>
<p>
        In addition to functioning with types from this library, these functions
        are also overloaded for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer types if you include <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
        Further, when used with fixed precision types (whether <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integers or multiprecision ones), the functions will promote
        to a wider type internally when the algorithm requires it. Versions overloaded
        for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer types return that integer type rather than an
        expression template.
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">gcd</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Returns the largest integer <code class="computeroutput"><span class="identifier">x</span></code>
        that divides both <code class="computeroutput"><span class="identifier">a</span></code> and
        <code class="computeroutput"><span class="identifier">b</span></code>.
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">lcm</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Returns the smallest integer <code class="computeroutput"><span class="identifier">x</span></code>
        that is divisible by both <code class="computeroutput"><span class="identifier">a</span></code>
        and <code class="computeroutput"><span class="identifier">b</span></code>.
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">pow</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">p</span><span class="special">);</span>
</pre>
<p>
        Returns <span class="emphasis"><em>b<sup>p</sup></em></span> as an expression template. Note that this
        function should be used with extreme care as the result can grow so large
        as to take "effectively forever" to compute, or else simply run
        the host machine out of memory. This is the one function in this category
        that is not overloaded for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer types, further, it's probably not a good idea
        to use it with fixed precision <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s
        either.
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">powm</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
</pre>
<p>
        Returns <span class="emphasis"><em>b<sup>p</sup> mod m</em></span> as an expression template. Fixed precision
        types are promoted internally to ensure accuracy.
      </p>
<pre class="programlisting"><span class="emphasis"><em>unmentionable-expression-template-type</em></span>    <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre>
<p>
        Returns the largest integer <code class="computeroutput"><span class="identifier">x</span></code>
        such that <code class="computeroutput"><span class="identifier">x</span> <span class="special">*</span>
        <span class="identifier">x</span> <span class="special">&lt;</span>
        <span class="identifier">a</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">EXpressionTemplates</span><span class="special">&gt;</span>      <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">EXpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>
</pre>
<p>
        Returns the largest integer <code class="computeroutput"><span class="identifier">x</span></code>
        such that <code class="computeroutput"><span class="identifier">x</span> <span class="special">*</span>
        <span class="identifier">x</span> <span class="special">&lt;</span>
        <span class="identifier">a</span></code>, and sets the remainder <code class="computeroutput"><span class="identifier">r</span></code> such that <code class="computeroutput"><span class="identifier">r</span>
        <span class="special">=</span> <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">x</span> <span class="special">*</span>
        <span class="identifier">x</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">divide_qr</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span>
               <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">r</span><span class="special">);</span>
</pre>
<p>
        Divides x by y and returns both the quotient and remainder. After the call
        <code class="computeroutput"><span class="identifier">q</span> <span class="special">=</span>
        <span class="identifier">x</span> <span class="special">/</span> <span class="identifier">y</span></code> and <code class="computeroutput"><span class="identifier">r</span>
        <span class="special">=</span> <span class="identifier">x</span> <span class="special">%</span> <span class="identifier">y</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span> <span class="identifier">integer_modulus</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Integer</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
        Returns the absolute value of <code class="computeroutput"><span class="identifier">x</span>
        <span class="special">%</span> <span class="identifier">val</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">unsigned</span> <span class="identifier">lsb</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
        Returns the (zero-based) index of the least significant bit that is set to
        1.
      </p>
<p>
        Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code> if the argument is &lt;= 0.
      </p>
<pre class="programlisting"><span class="keyword">unsigned</span> <span class="identifier">msb</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
        Returns the (zero-based) index of the most significant bit.
      </p>
<p>
        Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code> if the argument is &lt;= 0.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">bit_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Returns <code class="computeroutput"><span class="keyword">true</span></code> if the bit at
        <span class="emphasis"><em>index</em></span> in <span class="emphasis"><em>val</em></span> is set.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Sets the bit at <span class="emphasis"><em>index</em></span> in <span class="emphasis"><em>val</em></span>, and
        returns <span class="emphasis"><em>val</em></span>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_unset</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Unsets the bit at <span class="emphasis"><em>index</em></span> in <span class="emphasis"><em>val</em></span>,
        and returns <span class="emphasis"><em>val</em></span>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">bit_flip</span><span class="special">(</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Flips the bit at <span class="emphasis"><em>index</em></span> in <span class="emphasis"><em>val</em></span>,
        and returns <span class="emphasis"><em>val</em></span>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Engine</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">,</span> <span class="identifier">Engine</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">);</span>
</pre>
<p>
        Tests to see if the number <span class="emphasis"><em>n</em></span> is probably prime - the
        test excludes the vast majority of composite numbers by excluding small prime
        factors and performing a single Fermat test. Then performs <span class="emphasis"><em>trials</em></span>
        Miller-Rabin tests. Returns <code class="computeroutput"><span class="keyword">false</span></code>
        if <span class="emphasis"><em>n</em></span> is definitely composite, or <code class="computeroutput"><span class="keyword">true</span></code>
        if <span class="emphasis"><em>n</em></span> is probably prime with the probability of it being
        composite less than 0.25^trials. Fixed precision types are promoted internally
        to ensure accuracy.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h9"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.rational_number_functions"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.rational_number_functions">Rational
        Number Functions</a>
      </h5>
<pre class="programlisting"><span class="keyword">typename</span> <span class="identifier">component_type</span><span class="special">&lt;</span><span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">numerator</span>  <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
<span class="keyword">typename</span> <span class="identifier">component_type</span><span class="special">&lt;</span><span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;);</span>
</pre>
<p>
        These functions return the numerator and denominator of a rational number
        respectively.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h10"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.boost_math_interoperability_supp"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.boost_math_interoperability_supp">Boost.Math
        Interoperability Support</a>
      </h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">math</span><span class="special">{</span>

<span class="keyword">int</span>  <span class="identifier">fpclassify</span>     <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">isfinite</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">isnan</span>          <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">isinf</span>          <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">isnormal</span>       <span class="special">(</span><span class="keyword">const</span> <span class="emphasis"><em>number-or-expression-template-type</em></span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        These floating-point classification functions behave exactly as their Boost.Math
        equivalents.
      </p>
<p>
        Other Boost.Math functions and templates may also be specialized or overloaded
        to ensure interoperability.
      </p>
<h5>
<a name="boost_multiprecision.ref.number.h11"></a>
        <span class="phrase"><a name="boost_multiprecision.ref.number.std_numeric_limits_support"></a></span><a class="link" href="number.html#boost_multiprecision.ref.number.std_numeric_limits_support">std::numeric_limits
        support</a>
      </h5>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="special">{</span>
   <span class="comment">/* Usual members here */</span>
<span class="special">};</span>

<span class="special">}</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> is specialized for all instantiations
        of <code class="computeroutput"><span class="identifier">number</span></code> whose precision
        is known at compile time, plus those types whose precision is unlimited (though
        it is much less useful in those cases). It is not specialized for types whose
        precision can vary at compile time (such as <code class="computeroutput"><span class="identifier">mpf_float</span></code>).
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_int_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref/tom_int_ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>tom_int</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ref.html" title="Reference">
<link rel="prev" href="gmp_int_ref.html" title="gmp_int">
<link rel="next" href="mpf_ref.html" title="gmp_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpf_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.ref.tom_int_ref"></a><a class="link" href="tom_int_ref.html" title="tom_int">tom_int</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">tommath_int</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">tommath_int</span> <span class="special">&gt;</span>         <span class="identifier">tom_int</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
        Class template <code class="computeroutput"><span class="identifier">tommath_int</span></code>
        fulfils all of the requirements for a <a class="link" href="backendconc.html" title="Backend Requirements">Backend</a>
        type. Its members and non-member functions are deliberately not documented:
        these are considered implementation details that are subject to change.
      </p>
<p>
        The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
        <span class="identifier">number_kind_integer</span><span class="special">&gt;</span></code>.
      </p>
<p>
        More information on this type can be found in the <a class="link" href="../tut/ints/tom_int.html" title="tom_int">tutorial</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_int_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ref.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpf_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/ref.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Reference</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="tut/new_backend.html" title="Writing a New Backend">
<link rel="next" href="ref/number.html" title="number">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tut/new_backend.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.ref"></a><a class="link" href="ref.html" title="Reference">Reference</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ref/number.html">number</a></span></dt>
<dt><span class="section"><a href="ref/cpp_int_ref.html">cpp_int</a></span></dt>
<dt><span class="section"><a href="ref/gmp_int_ref.html">gmp_int</a></span></dt>
<dt><span class="section"><a href="ref/tom_int_ref.html">tom_int</a></span></dt>
<dt><span class="section"><a href="ref/mpf_ref.html">gmp_float</a></span></dt>
<dt><span class="section"><a href="ref/mpfr_ref.html">mpfr_float_backend</a></span></dt>
<dt><span class="section"><a href="ref/cpp_bin_float_ref.html">cpp_bin_float</a></span></dt>
<dt><span class="section"><a href="ref/cpp_dec_ref.html">cpp_dec_float</a></span></dt>
<dt><span class="section"><a href="ref/internals.html">Internal Support
      Code</a></span></dt>
<dt><span class="section"><a href="ref/backendconc.html">Backend Requirements</a></span></dt>
<dt><span class="section"><a href="ref/headers.html">Header File Structure</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tut/new_backend.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ref/number.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/complex/complex128.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>complex128</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../complex.html" title="Complex Number Types">
<link rel="prev" href="mpc_complex.html" title="mpc_complex">
<link rel="next" href="complex_adaptor.html" title="complex_adaptor">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpc_complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.complex.complex128"></a><a class="link" href="complex128.html" title="complex128">complex128</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">complex128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">complex128_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">complex128_backend</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>    <span class="identifier">complex128</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">complex128</span></code> number type
          is a very thin wrapper around GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          or Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data types
          and provides a complex-number type that is a drop-in replacement for the
          native C++ floating-point types, but with a 113 bit mantissa, and compatible
          with FORTRAN's 128-bit QUAD real.
        </p>
<p>
          All the usual standard library functions are available, performance should
          be equivalent to the underlying native types.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">float128</span></code> are copy constructible
          and assignable from GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          and Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data
          types.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">complex128</span></code>s
              have the value zero.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              It is not possible to round-trip objects of this type to and from a
              string and get back exactly the same value when compiled with Intel's
              C++ compiler and using <code class="computeroutput"><span class="identifier">_Quad</span></code>
              as the underlying type: this is a current limitation of our code. Round
              tripping when using <code class="computeroutput"><span class="identifier">__float128</span></code>
              as the underlying type is possible (both for GCC and Intel).
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in an infinity being produced.
            </li>
<li class="listitem">
              When using the Intel compiler, the underlying type defaults to <code class="computeroutput"><span class="identifier">__float128</span></code> if it's available and
              <code class="computeroutput"><span class="identifier">_Quad</span></code> if not. You can
              override the default by defining either <code class="computeroutput"><span class="identifier">BOOST_MP_USE_FLOAT128</span></code>
              or <code class="computeroutput"><span class="identifier">BOOST_MP_USE_QUAD</span></code>.
            </li>
<li class="listitem">
              When the underlying type is Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code>
              type, the code must be compiled with the compiler option <code class="computeroutput"><span class="special">-</span><span class="identifier">Qoption</span><span class="special">,</span><span class="identifier">cpp</span><span class="special">,--</span><span class="identifier">extended_float_type</span></code>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.complex.complex128.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.complex.complex128.complex128_example"></a></span><a class="link" href="complex128.html#boost_multiprecision.tut.complex.complex128.complex128_example">complex128
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">complex128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Complex</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">complex_number_examples</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">Complex</span> <span class="identifier">z1</span><span class="special">{</span><span class="number">0</span><span class="special">,</span> <span class="number">1</span><span class="special">};</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">fixed</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Print a complex number: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Square it             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">*</span><span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Real part             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">real</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">real</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Imaginary part        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">imag</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">imag</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Absolute value        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">abs</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Argument              : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Norm                  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">norm</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Complex conjugate     : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">conj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Projection onto Riemann sphere: "</span> <span class="special">&lt;&lt;</span>  <span class="identifier">proj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">r</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">theta</span> <span class="special">=</span> <span class="number">0.8</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">polar</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase = 0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase !=0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">theta</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nElementary special functions:\n"</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exp</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"exp(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log10</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log10(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pow(z1, z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sqrt</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Take its square root  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First, some operations we usually perform with std::complex:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;&gt;();</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nNow the same operations performed using quad precision complex numbers:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">complex128</span><span class="special">&gt;();</span>

    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          Which results in the output:
        </p>
<pre class="programlisting"><span class="identifier">Print</span> <span class="identifier">a</span> <span class="identifier">complex</span> <span class="identifier">number</span><span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Square</span> <span class="identifier">it</span>             <span class="special">:</span> <span class="special">-</span><span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Real</span> <span class="identifier">part</span>             <span class="special">:</span> <span class="number">0.000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">0.000000000000000000000000000000000</span>
<span class="identifier">Imaginary</span> <span class="identifier">part</span>        <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Absolute</span> <span class="identifier">value</span>        <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Argument</span>              <span class="special">:</span> <span class="number">1.570796326794896619231321691639751</span>
<span class="identifier">Norm</span>                  <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Complex</span> <span class="identifier">conjugate</span>     <span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,-</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Projection</span> <span class="identifier">onto</span> <span class="identifier">Riemann</span> <span class="identifier">sphere</span><span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">!=</span><span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="special">(</span><span class="number">0.696706709347165389063740022772449</span><span class="special">,</span><span class="number">0.717356090899522792567167815703377</span><span class="special">)</span>

<span class="identifier">Elementary</span> <span class="identifier">special</span> <span class="identifier">functions</span><span class="special">:</span>
<span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.540302305868139717400936607442977</span><span class="special">,</span><span class="number">0.841470984807896506652502321630299</span><span class="special">)</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.682188176920920673742891812715678</span><span class="special">)</span>
<span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.207879576350761908546955619834979</span>
<span class="identifier">Take</span> <span class="identifier">its</span> <span class="identifier">square</span> <span class="identifier">root</span>  <span class="special">:</span> <span class="special">(</span><span class="number">0.707106781186547524400844362104849</span><span class="special">,</span><span class="number">0.707106781186547524400844362104849</span><span class="special">)</span>
<span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.175201193643801456882381850595601</span><span class="special">)</span>
<span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.543080634815243778477905620757061</span>
<span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.761594155955764888119458282604794</span><span class="special">)</span>
<span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.881373587019543025232609324979792</span><span class="special">)</span>
<span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">1.570796326794896619231321691639751</span><span class="special">,-</span><span class="number">0.881373587019543025232609324979792</span><span class="special">)</span>
<span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="identifier">inf</span><span class="special">)</span>
<span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.841470984807896506652502321630299</span><span class="special">)</span>
<span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.540302305868139717400936607442977</span>
<span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.557407724654902230506974807458360</span><span class="special">)</span>
<span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.881373587019543025232609324979792</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.785398163397448309615660845819876</span><span class="special">)</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpc_complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/complex/complex_adaptor.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>complex_adaptor</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../complex.html" title="Complex Number Types">
<link rel="prev" href="complex128.html" title="complex128">
<link rel="next" href="../rational.html" title="Rational Number Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex128.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.complex.complex_adaptor"></a><a class="link" href="complex_adaptor.html" title="complex_adaptor">complex_adaptor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">complex_adaptor</span><span class="special">;</span>

<span class="special">}}</span>
</pre>
<p>
          Class template <code class="computeroutput"><span class="identifier">complex_adaptor</span></code>
          is designed to sit inbetween class <code class="computeroutput"><span class="identifier">number</span></code>
          and an actual floating point backend, in order to create a new complex
          number type.
        </p>
<p>
          It is the means by which we implement <a class="link" href="cpp_complex.html" title="cpp_complex">cpp_complex</a>
          and <a class="link" href="complex128.html" title="complex128">complex128</a>.
        </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex128.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/complex/cpp_complex.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_complex</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../complex.html" title="Complex Number Types">
<link rel="prev" href="../complex.html" title="Complex Number Types">
<link rel="next" href="mpc_complex.html" title="mpc_complex">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpc_complex.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.complex.cpp_complex"></a><a class="link" href="cpp_complex.html" title="cpp_complex">cpp_complex</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_type</span> <span class="identifier">DigitBase</span> <span class="special">=</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">Exponent</span> <span class="identifier">MinExponent</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">Exponent</span> <span class="identifier">MaxExponent</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
   <span class="keyword">using</span> <span class="identifier">cpp_complex_backend</span> <span class="special">=</span> <span class="identifier">complex_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">DigitBase</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Exponent</span><span class="special">,</span> <span class="identifier">MinExponent</span><span class="special">,</span> <span class="identifier">MaxExponent</span><span class="special">&gt;</span> <span class="special">&gt;;</span>

   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_type</span> <span class="identifier">DigitBase</span> <span class="special">=</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">Exponent</span> <span class="identifier">MinExponent</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">Exponent</span> <span class="identifier">MaxExponent</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span> <span class="special">=</span> <span class="identifier">et_off</span><span class="special">&gt;</span>
   <span class="keyword">using</span> <span class="identifier">cpp_complex</span> <span class="special">=</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">complex_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">DigitBase</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Exponent</span><span class="special">,</span> <span class="identifier">MinExponent</span><span class="special">,</span> <span class="identifier">MaxExponent</span><span class="special">&gt;</span> <span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;;</span>

   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_50</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_100</span><span class="special">;</span>

   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">24</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">126</span><span class="special">,</span> <span class="number">127</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_single</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">1022</span><span class="special">,</span> <span class="number">1023</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_double</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">64</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_extended</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_quad</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">237</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="special">-</span><span class="number">262142</span><span class="special">,</span> <span class="number">262143</span><span class="special">&gt;</span> <span class="identifier">cpp_complex_oct</span><span class="special">;</span>


<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">cpp_complex_backend</span></code>
          back-end is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as an entirely C++ (header only and dependency free) complex number
          type that is a drop-in replacement for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>,
          but with much greater precision.
        </p>
<p>
          The template alias <code class="computeroutput"><span class="identifier">cpp_complex</span></code>
          avoids the need to use class <code class="computeroutput"><span class="identifier">number</span></code>
          directly.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">cpp_complex</span></code> can be
          used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits</span></code>
          template parameter. The typedefs <code class="computeroutput"><span class="identifier">cpp_complex_50</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_complex_100</span></code> provide
          complex number types at 50 and 100 decimal digits precision respectively.
        </p>
<p>
          Optionally, you can specify whether the precision is specified in decimal
          digits or binary bits - for example to declare a <code class="computeroutput"><span class="identifier">cpp_complex</span></code>
          with exactly the same precision as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code> one would use <code class="computeroutput"><span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span>
          <span class="identifier">digit_base_2</span><span class="special">&gt;</span></code>.
          The typedefs <code class="computeroutput"><span class="identifier">cpp_complex_single</span></code>,
          <code class="computeroutput"><span class="identifier">cpp_complex_double</span></code>, <code class="computeroutput"><span class="identifier">cpp_complex_quad</span></code>, <code class="computeroutput"><span class="identifier">cpp_complex_oct</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_complex_double_extended</span></code>
          provide software analogues of the IEEE single, double, quad and octuple
          float data types, plus the Intel-extended-double type respectively. Note
          that while these types are functionally equivalent to the native IEEE types,
          but they do not have the same size or bit-layout as true IEEE compatible
          types.
        </p>
<p>
          Normally <code class="computeroutput"><span class="identifier">cpp_complex</span></code> allocates
          no memory: all of the space required for its digits are allocated directly
          within the class. As a result care should be taken not to use the class
          with too high a digit count as stack space requirements can grow out of
          control. If that represents a problem then providing an allocator as a
          template parameter causes <code class="computeroutput"><span class="identifier">cpp_complex</span></code>
          to dynamically allocate the memory it needs: this significantly reduces
          the size of <code class="computeroutput"><span class="identifier">cpp_complex</span></code>
          and increases the viable upper limit on the number of digits at the expense
          of performance. However, please bear in mind that arithmetic operations
          rapidly become <span class="emphasis"><em>very</em></span> expensive as the digit count grows:
          the current implementation really isn't optimized or designed for large
          digit counts. Note that since the actual type of the objects allocated
          is completely opaque, the suggestion would be to use an allocator with
          <code class="computeroutput"><span class="keyword">char</span></code> <code class="computeroutput"><span class="identifier">value_type</span></code>,
          for example: <code class="computeroutput"><span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">,</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
        </p>
<p>
          The next template parameters determine the type and range of the exponent:
          parameter <code class="computeroutput"><span class="identifier">Exponent</span></code> can
          be any signed integer type, but note that <code class="computeroutput"><span class="identifier">MinExponent</span></code>
          and <code class="computeroutput"><span class="identifier">MaxExponent</span></code> can not
          go right up to the limits of the <code class="computeroutput"><span class="identifier">Exponent</span></code>
          type as there has to be a little extra headroom for internal calculations.
          You will get a compile time error if this is the case. In addition if MinExponent
          or MaxExponent are zero, then the library will choose suitable values that
          are as large as possible given the constraints of the type and need for
          extra headroom for internal calculations.
        </p>
<p>
          Finally, as with class <code class="computeroutput"><span class="identifier">number</span></code>,
          the final template parameter determines whether expression templates are
          turn on or not. Since by default this type allocates no memory, expression
          template support is off by default. However, you should probably turn it
          on if you specify an allocator.
        </p>
<p>
          There is full standard library support available for this type, comparable
          with what <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code> provides.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">cpp_complex</span></code>s
              have a value of zero.
            </li>
<li class="listitem">
              The radix of this type is 2, even when the precision is specified as
              decimal digits.
            </li>
<li class="listitem">
              The type supports both infinities and NaNs. An infinity is generated
              whenever the result would overflow, and a NaN is generated for any
              mathematically undefined operation.
            </li>
<li class="listitem">
              There is no <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> specialisation for
              this type: this is the same behaviour as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>.
              If you need <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> support you need to
              look at <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">my_complex_number_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;</span></code>.
            </li>
<li class="listitem">
              Any <code class="computeroutput"><span class="identifier">number</span></code> instantiated
              on this type, is convertible to any other <code class="computeroutput"><span class="identifier">number</span></code>
              instantiated on this type - for example you can convert from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_complex</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> to <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">SomeOtherValue</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
              Narrowing conversions round to nearest and are <code class="computeroutput"><span class="keyword">explicit</span></code>.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid complex
              number.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.complex.cpp_complex.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.complex.cpp_complex.example"></a></span><a class="link" href="cpp_complex.html#boost_multiprecision.tut.complex.cpp_complex.example">example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Complex</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">complex_number_examples</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">Complex</span> <span class="identifier">z1</span><span class="special">{</span><span class="number">0</span><span class="special">,</span> <span class="number">1</span><span class="special">};</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">fixed</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Print a complex number: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Square it             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">*</span><span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Real part             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">real</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">real</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Imaginary part        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">imag</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">imag</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Absolute value        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">abs</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Argument              : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Norm                  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">norm</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Complex conjugate     : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">conj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Projection onto Riemann sphere: "</span> <span class="special">&lt;&lt;</span>  <span class="identifier">proj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">r</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">theta</span> <span class="special">=</span> <span class="number">0.8</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">polar</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase = 0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase !=0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">theta</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nElementary special functions:\n"</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exp</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"exp(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log10</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log10(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pow(z1, z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sqrt</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Take its square root  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First, some operations we usually perform with std::complex:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;&gt;();</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nNow the same operations performed using quad precision complex numbers:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_complex_quad</span><span class="special">&gt;();</span>

    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          Which produces the output (for the multiprecision type):
        </p>
<pre class="programlisting"><span class="identifier">Print</span> <span class="identifier">a</span> <span class="identifier">complex</span> <span class="identifier">number</span><span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Square</span> <span class="identifier">it</span>             <span class="special">:</span> <span class="special">-</span><span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Real</span> <span class="identifier">part</span>             <span class="special">:</span> <span class="number">0.000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">0.000000000000000000000000000000000</span>
<span class="identifier">Imaginary</span> <span class="identifier">part</span>        <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Absolute</span> <span class="identifier">value</span>        <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Argument</span>              <span class="special">:</span> <span class="number">1.570796326794896619231321691639751</span>
<span class="identifier">Norm</span>                  <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Complex</span> <span class="identifier">conjugate</span>     <span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,-</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Projection</span> <span class="identifier">onto</span> <span class="identifier">Riemann</span> <span class="identifier">sphere</span><span class="special">:</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="number">1.000000000000000000000000000000000</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">!=</span><span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="special">(</span><span class="number">0.696706709347165389063740022772448</span><span class="special">,</span><span class="number">0.717356090899522792567167815703377</span><span class="special">)</span>

<span class="identifier">Elementary</span> <span class="identifier">special</span> <span class="identifier">functions</span><span class="special">:</span>
<span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.540302305868139717400936607442977</span><span class="special">,</span><span class="number">0.841470984807896506652502321630299</span><span class="special">)</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.682188176920920673742891812715678</span><span class="special">)</span>
<span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.207879576350761908546955619834979</span>
<span class="identifier">Take</span> <span class="identifier">its</span> <span class="identifier">square</span> <span class="identifier">root</span>  <span class="special">:</span> <span class="special">(</span><span class="number">0.707106781186547524400844362104849</span><span class="special">,</span><span class="number">0.707106781186547524400844362104849</span><span class="special">)</span>
<span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.175201193643801456882381850595601</span><span class="special">)</span>
<span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.543080634815243778477905620757062</span>
<span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.761594155955764888119458282604794</span><span class="special">)</span>
<span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.881373587019543025232609324979793</span><span class="special">)</span>
<span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">1.570796326794896619231321691639751</span><span class="special">,-</span><span class="number">0.881373587019543025232609324979793</span><span class="special">)</span>
<span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="identifier">inf</span><span class="special">)</span>
<span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.841470984807896506652502321630299</span><span class="special">)</span>
<span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.540302305868139717400936607442977</span>
<span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.557407724654902230506974807458360</span><span class="special">)</span>
<span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.881373587019543025232609324979792</span><span class="special">,</span><span class="number">1.570796326794896619231321691639751</span><span class="special">)</span>
<span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.785398163397448309615660845819876</span><span class="special">)</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpc_complex.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/complex/mpc_complex.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>mpc_complex</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../complex.html" title="Complex Number Types">
<link rel="prev" href="cpp_complex.html" title="cpp_complex">
<link rel="next" href="complex128.html" title="complex128">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex128.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.complex.mpc_complex"></a><a class="link" href="mpc_complex.html" title="mpc_complex">mpc_complex</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">mpc_complex_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpc_complex_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpc_complex_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpc_complex_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpc_complex_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpc_complex</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">mpc_complex_backend</span></code>
          type is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as a thin wrapper around the <a href="http://www.multiprecision.org" target="_top">MPC</a>
          <code class="computeroutput"><span class="identifier">mpc_t</span></code> to provide an real-number
          type that is a drop-in replacement for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>,
          but with much greater precision.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">mpc_complex_backend</span></code>
          can be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits10</span></code>
          template parameter, or at variable precision by setting the template argument
          to zero. The typedefs mpc_complex_50, mpc_complex_100, mpc_complex_500,
          mpc_complex_1000 provide complex types at 50, 100, 500 and 1000 decimal
          digits precision respectively. The typedef mpc_complex provides a variable
          precision type whose precision can be controlled via the <code class="computeroutput"><span class="identifier">number</span></code>s member functions.
        </p>
<p>
          The <code class="computeroutput"><span class="identifier">mpc</span></code> backend should
          allow use of the same syntax as the C++ standard library complex type.
          When using this backend, remember to link with the flags <code class="computeroutput"><span class="special">-</span><span class="identifier">lmpc</span> <span class="special">-</span><span class="identifier">lmpfr</span> <span class="special">-</span><span class="identifier">lgmp</span></code>.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpc_complex_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> are copy constructible and assignable
          from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://gmplib.org" target="_top">GMP</a> native types <code class="computeroutput"><span class="identifier">mpf_t</span></code>, <code class="computeroutput"><span class="identifier">mpz_t</span></code>,
              <code class="computeroutput"><span class="identifier">mpq_t</span></code>.
            </li>
<li class="listitem">
              The <a href="http://www.mpfr.org" target="_top">MPFR</a> native type <code class="computeroutput"><span class="identifier">mpfr_t</span></code>.
            </li>
<li class="listitem">
              The <a href="http://www.multiprecision.org" target="_top">MPC</a> native type
              <code class="computeroutput"><span class="identifier">mpc_t</span></code>.
            </li>
<li class="listitem">
              The <code class="computeroutput"><span class="identifier">number</span></code> wrappers
              around those types: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
              <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpf_float</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span><span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpc_t</span></code>
          via the <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              A default constructed <code class="computeroutput"><span class="identifier">mpc_complex_backend</span></code>
              is set to zero (<span class="emphasis"><em>Note that this is <span class="bold"><strong>not</strong></span>
              the default <a href="http://www.multiprecision.org" target="_top">MPC</a>
              behavior</em></span>).
            </li>
<li class="listitem">
              All operations use round to nearest.
            </li>
<li class="listitem">
              No changes are made to <a href="http://www.multiprecision.org" target="_top">MPC</a>,
              <a href="http://gmplib.org" target="_top">GMP</a> or <a href="http://www.mpfr.org" target="_top">MPFR</a>
              global settings, so this type can coexist with existing <a href="http://www.multiprecision.org" target="_top">MPC</a>,
              <a href="http://www.mpfr.org" target="_top">MPFR</a> or <a href="http://gmplib.org" target="_top">GMP</a>
              code.
            </li>
<li class="listitem">
              The code can equally use <a href="http://mpir.org/" target="_top">MPIR</a>
              in place of <a href="http://gmplib.org" target="_top">GMP</a> - indeed that
              is the preferred option on Win32.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid complex
              number.
            </li>
<li class="listitem">
              Division by zero results in a complex-infinity.
            </li>
<li class="listitem">
              Unlike <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>, you can not use <code class="computeroutput"><span class="keyword">reinterpret_cast</span></code> to treat this type
              as an array of the underlying floating point type.
            </li>
<li class="listitem">
              Unlike <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>, there are no literals for
              imaginary values.
            </li>
<li class="listitem">
              When using the variable precision type <code class="computeroutput"><span class="identifier">mpc_complex</span></code>,
              then copy construction and assignment <span class="emphasis"><em>copies the precision
              of the source variable</em></span>. Likewise move construction and assignment.
            </li>
<li class="listitem">
              When constructing the variable precision type <code class="computeroutput"><span class="identifier">mpc_complex</span></code>
              you can specify two arguments to the constructor - the first is the
              value to assign to the variable, the second is an unsigned integer
              specifying the precision in decimal places. The <code class="computeroutput"><span class="identifier">assign</span></code>
              member function similarly has a 2-argument overload taking the value
              to assign and the precision. You can use this to preserve the precision
              of the target variable using the somewhat arcane: <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">precision</span><span class="special">())</span></code>, which assigns <code class="computeroutput"><span class="identifier">b</span></code>
              to <code class="computeroutput"><span class="identifier">a</span></code> but preserves
              the precision of <code class="computeroutput"><span class="identifier">a</span></code>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.complex.mpc_complex.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.complex.mpc_complex.mpc_example"></a></span><a class="link" href="mpc_complex.html#boost_multiprecision.tut.complex.mpc_complex.mpc_example"> MPC example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">complex</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Complex</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">complex_number_examples</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">Complex</span> <span class="identifier">z1</span><span class="special">{</span><span class="number">0</span><span class="special">,</span> <span class="number">1</span><span class="special">};</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">fixed</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Print a complex number: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Square it             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">*</span><span class="identifier">z1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Real part             : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">real</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">real</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Imaginary part        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">z1</span><span class="special">.</span><span class="identifier">imag</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">imag</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">abs</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Absolute value        : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">abs</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Argument              : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Norm                  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">norm</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Complex conjugate     : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">conj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Projection onto Riemann sphere: "</span> <span class="special">&lt;&lt;</span>  <span class="identifier">proj</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">r</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
    <span class="keyword">typename</span> <span class="identifier">Complex</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">theta</span> <span class="special">=</span> <span class="number">0.8</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">polar</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase = 0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Polar coordinates (phase !=0)    : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">polar</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">theta</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nElementary special functions:\n"</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exp</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"exp(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">log10</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"log10(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pow(z1, z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sqrt</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Take its square root  : "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asin</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asin(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acos</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acos(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atan</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atan(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"sinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"tanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">asinh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"asinh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">acosh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"acosh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
    <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">atanh</span><span class="special">;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"atanh(z1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First, some operations we usually perform with std::complex:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;&gt;();</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nNow the same operations performed using the MPC backend:\n"</span><span class="special">;</span>
    <span class="identifier">complex_number_examples</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">mpc_complex_50</span><span class="special">&gt;();</span>

    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          Which produces the output (for the multiprecision type):
        </p>
<pre class="programlisting"><span class="identifier">Print</span> <span class="identifier">a</span> <span class="identifier">complex</span> <span class="identifier">number</span><span class="special">:</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.00000000000000000000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Square</span> <span class="identifier">it</span>             <span class="special">:</span> <span class="special">-</span><span class="number">1.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Real</span> <span class="identifier">part</span>             <span class="special">:</span> <span class="number">0.00000000000000000000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">0.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Imaginary</span> <span class="identifier">part</span>        <span class="special">:</span> <span class="number">1.00000000000000000000000000000000000000000000000000</span> <span class="special">=</span> <span class="number">1.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Absolute</span> <span class="identifier">value</span>        <span class="special">:</span> <span class="number">1.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Argument</span>              <span class="special">:</span> <span class="number">1.57079632679489661923132169163975144209858469968755</span>
<span class="identifier">Norm</span>                  <span class="special">:</span> <span class="number">1.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Complex</span> <span class="identifier">conjugate</span>     <span class="special">:</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,-</span><span class="number">1.00000000000000000000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Projection</span> <span class="identifier">onto</span> <span class="identifier">Riemann</span> <span class="identifier">sphere</span><span class="special">:</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.00000000000000000000000000000000000000000000000000</span><span class="special">)</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="number">1.00000000000000000000000000000000000000000000000000</span>
<span class="identifier">Polar</span> <span class="identifier">coordinates</span> <span class="special">(</span><span class="identifier">phase</span> <span class="special">!=</span><span class="number">0</span><span class="special">)</span>    <span class="special">:</span> <span class="special">(</span><span class="number">0.69670670934716538906374002277244853473117519431538</span><span class="special">,</span><span class="number">0.71735609089952279256716781570337728075604730751255</span><span class="special">)</span>

<span class="identifier">Elementary</span> <span class="identifier">special</span> <span class="identifier">functions</span><span class="special">:</span>
<span class="identifier">exp</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.54030230586813971740093660744297660373231042061792</span><span class="special">,</span><span class="number">0.84147098480789650665250232163029899962256306079837</span><span class="special">)</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.57079632679489661923132169163975144209858469968755</span><span class="special">)</span>
<span class="identifier">log10</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.68218817692092067374289181271567788510506374186196</span><span class="special">)</span>
<span class="identifier">pow</span><span class="special">(</span><span class="identifier">z1</span><span class="special">,</span> <span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.20787957635076190854695561983497877003387784163177</span>
<span class="identifier">Take</span> <span class="identifier">its</span> <span class="identifier">square</span> <span class="identifier">root</span>  <span class="special">:</span> <span class="special">(</span><span class="number">0.70710678118654752440084436210484903928483593768847</span><span class="special">,</span><span class="number">0.70710678118654752440084436210484903928483593768847</span><span class="special">)</span>
<span class="identifier">sin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.17520119364380145688238185059560081515571798133410</span><span class="special">)</span>
<span class="identifier">cos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.54308063481524377847790562075706168260152911236587</span>
<span class="identifier">tan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.76159415595576488811945828260479359041276859725794</span><span class="special">)</span>
<span class="identifier">asin</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.88137358701954302523260932497979230902816032826163</span><span class="special">)</span>
<span class="identifier">acos</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">1.57079632679489661923132169163975144209858469968755</span><span class="special">,-</span><span class="number">0.88137358701954302523260932497979230902816032826163</span><span class="special">)</span>
<span class="identifier">atan</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="identifier">inf</span><span class="special">)</span>
<span class="identifier">sinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.84147098480789650665250232163029899962256306079837</span><span class="special">)</span>
<span class="identifier">cosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="number">0.54030230586813971740093660744297660373231042061792</span>
<span class="identifier">tanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.55740772465490223050697480745836017308725077238152</span><span class="special">)</span>
<span class="identifier">asinh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">1.57079632679489661923132169163975144209858469968755</span><span class="special">)</span>
<span class="identifier">acosh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.88137358701954302523260932497979230902816032826163</span><span class="special">,</span><span class="number">1.57079632679489661923132169163975144209858469968755</span><span class="special">)</span>
<span class="identifier">atanh</span><span class="special">(</span><span class="identifier">z1</span><span class="special">)</span> <span class="special">=</span> <span class="special">(</span><span class="number">0.00000000000000000000000000000000000000000000000000</span><span class="special">,</span><span class="number">0.78539816339744830961566084581987572104929234984378</span><span class="special">)</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_complex.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../complex.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex128.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/complex.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Complex Number Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="interval/mpfi.html" title="mpfi_float">
<link rel="next" href="complex/cpp_complex.html" title="cpp_complex">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="interval/mpfi.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex/cpp_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.complex"></a><a class="link" href="complex.html" title="Complex Number Types">Complex Number Types</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="complex/cpp_complex.html">cpp_complex</a></span></dt>
<dt><span class="section"><a href="complex/mpc_complex.html">mpc_complex</a></span></dt>
<dt><span class="section"><a href="complex/complex128.html">complex128</a></span></dt>
<dt><span class="section"><a href="complex/complex_adaptor.html">complex_adaptor</a></span></dt>
</dl></div>
<p>
        The following backends provide complex number arithmetic:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend Type
                </p>
              </th>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Radix
                </p>
              </th>
<th>
                <p>
                  Dependencies
                </p>
              </th>
<th>
                <p>
                  Pros
                </p>
              </th>
<th>
                <p>
                  Cons
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cpp_complex</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/cpp_complex.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  An all C++ Boost-licensed implementation.
                </p>
              </td>
<td>
                <p>
                  Slower than <a href="http://www.multiprecision.org" target="_top">MPC</a>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">mpc</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/mpc.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://www.multiprecision.org" target="_top">MPC</a>
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end.
                </p>
              </td>
<td>
                <p>
                  Dependency on LGLP-licensed [MPC] library.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">complex128</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/complex128.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">__float128</span></code> and
                  libquadmath
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient number type.
                </p>
              </td>
<td>
                <p>
                  128-bit precision only, and restricted to GCC.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">complex_adaptor</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/complex_adaptor.hpp
                </p>
              </td>
<td>
                <p>
                  -
                </p>
              </td>
<td>
                <p>
                  none
                </p>
              </td>
<td>
                <p>
                  Can convert any backend type into a complex number backend.
                </p>
              </td>
<td>
                <p>
                  Not a number in its own right, and hard to use as a result.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="interval/mpfi.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex/cpp_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/conversions.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Constructing and Interconverting Between Number Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="misc/visualizers.html" title="Visual C++ Debugger Visualizers">
<link rel="next" href="random.html" title="Generating Random Numbers">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="misc/visualizers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.conversions"></a><a class="link" href="conversions.html" title="Constructing and Interconverting Between Number Types">Constructing and
      Interconverting Between Number Types</a>
</h3></div></div></div>
<p>
        All of the number types that are based on <code class="computeroutput"><span class="identifier">number</span></code>
        have certain conversion rules in common. In particular:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p class="simpara">
            Any number type can be constructed (or assigned) from any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> arithmetic type, as long as the conversion isn't lossy
            (for example float to int conversion):
          </p>
<pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span><span class="special">(</span><span class="number">0.5</span><span class="special">);</span>   <span class="comment">// OK construction from double</span>
<span class="identifier">cpp_int</span>          <span class="identifier">i</span><span class="special">(</span><span class="number">450</span><span class="special">);</span>    <span class="comment">// OK constructs from signed int</span>
<span class="identifier">cpp_int</span>          <span class="identifier">j</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span>  <span class="comment">// Error, lossy conversion.</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            A number can be explicitly constructed from an arithmetic type, even
            when the conversion is lossy:
          </p>
<pre class="programlisting"><span class="identifier">cpp_int</span>          <span class="identifier">i</span><span class="special">(</span><span class="number">3.14</span><span class="special">);</span>       <span class="comment">// OK explicit conversion</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;(</span><span class="number">3.14</span><span class="special">)</span>  <span class="comment">// OK explicit conversion</span>
<span class="identifier">i</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="number">3.14</span><span class="special">);</span>                 <span class="comment">// OK, explicit assign and avoid a temporary from the cast above</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span>                       <span class="comment">// Error, no implicit assignment operator for lossy conversion.</span>
<span class="identifier">cpp_int</span>          <span class="identifier">j</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">;</span>      <span class="comment">// Error, no implicit constructor for lossy conversion.</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            A <code class="computeroutput"><span class="identifier">number</span></code> can be converted
            to any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> type, via the <code class="computeroutput"><span class="identifier">convert_to</span></code>
            member function:
          </p>
<pre class="programlisting"><span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">.</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;();</span> <span class="comment">// sets i to 2</span>
</pre>
</li>
<li class="listitem">
            Conversions to rational numbers from floating-point ones are always allowed,
            and are exact and implicit as long as the rational number uses an unbounded
            integer type. Please be aware that constructing a rational number from
            an extended precision floating-point type with a large exponent range
            can effectively run the system out of memory, as in the extreme case
            <span class="emphasis"><em>2<sup>max_exponent</sup> / CHAR_BITS</em></span> bytes of storage may be
            required. This does not represent a problem for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> floating-point types however, as the exponent range
            for these is rather limited.
          </li>
<li class="listitem">
            Conversions to floating-point numbers from rational ones are rounded
            to nearest (less than 0.5 <a href="http://en.wikipedia.org/wiki/Unit_in_the_last_place" target="_top">Unit
            in the last place (ULP)</a> error) as long as the floating-point
            number is binary, and the integer type used by the rational number is
            unbounded.
          </li>
</ul></div>
<p>
        Additional conversions may be supported by particular backends.
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p class="simpara">
            A <code class="computeroutput"><span class="identifier">number</span></code> can be converted
            to any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> type, via an explicit conversion operator: this functionality
            is only available on compilers supporting C++11's explicit conversion
            syntax.
          </p>
<pre class="programlisting"><span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>                     <span class="comment">// Error, implicit conversion not allowed.</span>
<span class="keyword">int</span> <span class="identifier">j</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">z</span><span class="special">);</span>   <span class="comment">// OK explicit conversion.</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Any number type can be <span class="emphasis"><em>explicitly</em></span> constructed (or
            assigned) from a <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span></code>
            or a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>:
          </p>
<pre class="programlisting"><span class="comment">// pi to 50 places from a string:</span>
<span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span><span class="special">(</span><span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">);</span>
<span class="comment">// Integer type will automatically detect "0x" and "0" prefixes and parse the string accordingly:</span>
<span class="identifier">cpp_int</span>          <span class="identifier">i</span><span class="special">(</span><span class="string">"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000"</span><span class="special">);</span>
<span class="comment">// Invalid input always results in a std::runtime_error being thrown:</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;(</span><span class="string">"3.14"</span><span class="special">);</span>
<span class="comment">// implicit conversions from strings are not allowed:</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="string">"23"</span><span class="special">;</span> <span class="comment">// Error, no assignment operator for implicit conversion from string</span>
<span class="comment">// assign member function, avoids having to create a temporary via a static_cast:</span>
<span class="identifier">i</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="string">"23"</span><span class="special">);</span>  <span class="comment">// OK</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Any number type will interoperate with the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> types in arithmetic expressions as long as the conversions
            are not lossy:
          </p>
<pre class="programlisting"><span class="comment">// pi to 50 places from a string:</span>
<span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span> <span class="special">=</span> <span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">;</span>
<span class="comment">// Multiply by 2 - using an integer literal here is usually more efficient</span>
<span class="comment">// than constructing a temporary:</span>
<span class="identifier">df</span> <span class="special">*=</span> <span class="number">2</span><span class="special">;</span>

<span class="comment">// You can't mix integer types with floats though:</span>
<span class="identifier">cpp_int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">i</span> <span class="special">*=</span> <span class="number">3.14</span><span class="special">;</span>  <span class="comment">// Error, no *= operator will be found.</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Any number type can be streamed to and from the C++ iostreams:
          </p>
<pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span> <span class="special">=</span> <span class="string">"3.14159265358979323846264338327950288419716939937510"</span><span class="special">;</span>
<span class="comment">// Now print at full precision:</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">df</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span>
<span class="identifier">cpp_int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">i</span> <span class="special">&lt;&lt;=</span> <span class="number">256</span><span class="special">;</span>
<span class="comment">// Now print in hex format with prefix:</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">i</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Interconversions between number types of the same family are allowed
            and are implicit conversions if no loss of precision is involved, and
            explicit if it is:
          </p>
<pre class="programlisting"><span class="identifier">int128_t</span>     <span class="identifier">i128</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">int266_t</span>     <span class="identifier">i256</span> <span class="special">=</span> <span class="identifier">i128</span><span class="special">;</span>  <span class="comment">// OK implicit widening conversion</span>
<span class="identifier">i128_t</span>            <span class="special">=</span> <span class="identifier">i256</span><span class="special">;</span>  <span class="comment">// Error, no assignment operator found, narrowing conversion is explicit.</span>
<span class="identifier">i128_t</span>            <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">int128_t</span><span class="special">&gt;(</span><span class="identifier">i256</span><span class="special">);</span> <span class="comment">// OK, explicit narrowing conversion.</span>

<span class="identifier">mpz_int</span>      <span class="identifier">z</span>    <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">mpf_float</span>    <span class="identifier">f</span>    <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>    <span class="comment">// OK, GMP handles this conversion natively, and it's not lossy and therefore implicit.</span>

<span class="identifier">mpf_float_50</span> <span class="identifier">f50</span>  <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">f</span>                 <span class="special">=</span> <span class="identifier">f50</span><span class="special">;</span>  <span class="comment">// OK, conversion from fixed to variable precision, f will have 50 digits precision.</span>
<span class="identifier">f50</span>               <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// Error, conversion from variable to fixed precision is potentially lossy, explicit cast required.</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Some interconversions between number types are completely generic, and
            are always available, albeit the conversions are always <span class="emphasis"><em>explicit</em></span>:
          </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">cppi</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="comment">// We can always convert between numbers of the same category -</span>
<span class="comment">// int to int, rational to rational, or float to float, so this is OK</span>
<span class="comment">// as long as we use an explicit conversion:</span>
<span class="identifier">mpz_int</span> <span class="identifier">z</span><span class="special">(</span><span class="identifier">cppi</span><span class="special">);</span>
<span class="comment">// We can always promote from int to rational, int to float, or rational to float:</span>
<span class="identifier">cpp_rational</span>     <span class="identifier">cppr</span><span class="special">(</span><span class="identifier">cppi</span><span class="special">);</span>  <span class="comment">// OK, int to rational</span>
<span class="identifier">cpp_dec_float_50</span> <span class="identifier">df</span><span class="special">(</span><span class="identifier">cppi</span><span class="special">);</span>    <span class="comment">// OK, int to float</span>
<span class="identifier">df</span>                  <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;(</span><span class="identifier">cppr</span><span class="special">);</span>  <span class="comment">// OK, explicit rational to float conversion</span>
<span class="comment">// However narrowing and/or implicit conversions always fail:</span>
<span class="identifier">cppi</span>                <span class="special">=</span>   <span class="identifier">df</span><span class="special">;</span>    <span class="comment">// Compiler error, conversion not allowed</span>
</pre>
</li>
<li class="listitem">
<p class="simpara">
            Other interconversions may be allowed as special cases, whenever the
            backend allows it:
          </p>
<pre class="programlisting"><span class="identifier">mpf_t</span>     <span class="identifier">m</span><span class="special">;</span>           <span class="comment">// Native GMP type.</span>
<span class="identifier">mpf_init_set_ui</span><span class="special">(</span><span class="identifier">m</span><span class="special">,</span> <span class="number">0</span><span class="special">);</span> <span class="comment">// set to a value;</span>
<span class="identifier">mpf_float</span> <span class="identifier">i</span><span class="special">(</span><span class="identifier">m</span><span class="special">);</span>        <span class="comment">// copies the value of the native type.</span>
</pre>
</li>
</ul></div>
<p>
        More information on what additional types a backend supports conversions
        from are given in the tutorial for each backend. The converting constructor
        will be implicit if the backend's converting constructor is also implicit,
        and explicit if the backends converting constructor is also explicit.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="misc/visualizers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/eigen.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Eigen Interoperability</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="hash.html" title="Hash Function Support">
<link rel="next" href="new_backend.html" title="Writing a New Backend">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="hash.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="new_backend.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.eigen"></a><a class="link" href="eigen.html" title="Eigen Interoperability">Eigen Interoperability</a>
</h3></div></div></div>
<p>
        This library provides the header:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">eigen</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
        which defines the traits classes and functions that the Eigen library needs
        all user-defined number types to provide.
      </p>
<p>
        For example the following code performs quad-precision matrix solving on
        complex numbers:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_complex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">eigen</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">Eigen</span><span class="special">/</span><span class="identifier">Dense</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">Eigen</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_complex_quad</span> <span class="identifier">complex_type</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// We want to solve Ax = b for x,</span>
   <span class="comment">// define A and b first:</span>
   <span class="comment">//</span>
   <span class="identifier">Matrix</span><span class="special">&lt;</span><span class="identifier">complex_type</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="identifier">A</span><span class="special">,</span> <span class="identifier">b</span><span class="special">;</span>
   <span class="identifier">A</span> <span class="special">&lt;&lt;</span> <span class="identifier">complex_type</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">),</span> <span class="identifier">complex_type</span><span class="special">(-</span><span class="number">1</span><span class="special">,</span> <span class="special">-</span><span class="number">2</span><span class="special">),</span> <span class="identifier">complex_type</span><span class="special">(-</span><span class="number">1</span><span class="special">,</span> <span class="special">-</span><span class="number">4</span><span class="special">),</span> <span class="identifier">complex_type</span><span class="special">(</span><span class="number">3</span><span class="special">,</span> <span class="number">6</span><span class="special">);</span>
   <span class="identifier">b</span> <span class="special">&lt;&lt;</span> <span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">,</span> <span class="number">1</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Here is the matrix A:\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">A</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Here is the right hand side b:\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">b</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Solve for x:</span>
   <span class="comment">//</span>
   <span class="identifier">Matrix</span><span class="special">&lt;</span><span class="identifier">complex_type</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">A</span><span class="special">.</span><span class="identifier">fullPivHouseholderQr</span><span class="special">().</span><span class="identifier">solve</span><span class="special">(</span><span class="identifier">b</span><span class="special">);</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"The solution is:\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Compute the error in the solution by using the norms of Ax - b and b:</span>
   <span class="comment">//</span>
   <span class="identifier">complex_type</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">relative_error</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">A</span><span class="special">*</span><span class="identifier">x</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">).</span><span class="identifier">norm</span><span class="special">()</span> <span class="special">/</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">norm</span><span class="special">();</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"The relative error is: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">relative_error</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Which produces the following output:
      </p>
<pre class="programlisting"><span class="identifier">Here</span> <span class="identifier">is</span> <span class="identifier">the</span> <span class="identifier">matrix</span> <span class="identifier">A</span><span class="special">:</span>
<span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">)</span> <span class="special">(-</span><span class="number">1</span><span class="special">,-</span><span class="number">2</span><span class="special">)</span>
<span class="special">(-</span><span class="number">1</span><span class="special">,-</span><span class="number">4</span><span class="special">)</span>   <span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">6</span><span class="special">)</span>
<span class="identifier">Here</span> <span class="identifier">is</span> <span class="identifier">the</span> <span class="identifier">right</span> <span class="identifier">hand</span> <span class="identifier">side</span> <span class="identifier">b</span><span class="special">:</span>
<span class="number">1</span> <span class="number">2</span>
<span class="number">3</span> <span class="number">1</span>
<span class="identifier">The</span> <span class="identifier">solution</span> <span class="identifier">is</span><span class="special">:</span>
<span class="special">(</span><span class="number">0.6</span><span class="special">,-</span><span class="number">0.6</span><span class="special">)</span>   <span class="special">(</span><span class="number">0.7</span><span class="special">,-</span><span class="number">0.7</span><span class="special">)</span>
<span class="special">(</span><span class="number">0.64</span><span class="special">,-</span><span class="number">0.68</span><span class="special">)</span> <span class="special">(</span><span class="number">0.58</span><span class="special">,-</span><span class="number">0.46</span><span class="special">)</span>
<span class="identifier">The</span> <span class="identifier">relative</span> <span class="identifier">error</span> <span class="identifier">is</span><span class="special">:</span> <span class="number">2.63132e-34</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="hash.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="new_backend.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/cpp_bin_float.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_bin_float</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="../floats.html" title="Floating-point Types">
<link rel="next" href="cpp_dec_float.html" title="cpp_dec_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.cpp_bin_float"></a><a class="link" href="cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">enum</span> <span class="identifier">digit_base_type</span>
<span class="special">{</span>
   <span class="identifier">digit_base_2</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span>
   <span class="identifier">digit_base_10</span> <span class="special">=</span> <span class="number">10</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits</span><span class="special">,</span> <span class="identifier">digit_base_type</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Exponent</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">ExponentMin</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">ExponentMax</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_bin_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_bin_float_100</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">24</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">126</span><span class="special">,</span> <span class="number">127</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>         <span class="identifier">cpp_bin_float_single</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">1022</span><span class="special">,</span> <span class="number">1023</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>       <span class="identifier">cpp_bin_float_double</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>     <span class="identifier">cpp_bin_float_double_extended</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int16_t</span><span class="special">,</span> <span class="special">-</span><span class="number">16382</span><span class="special">,</span> <span class="number">16383</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>    <span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">backends</span><span class="special">::</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">237</span><span class="special">,</span> <span class="identifier">backends</span><span class="special">::</span><span class="identifier">digit_base_2</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="special">-</span><span class="number">262142</span><span class="special">,</span> <span class="number">262143</span><span class="special">&gt;,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>  <span class="identifier">cpp_bin_float_oct</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> back-end
          is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as an entirely C++ (header only and dependency free) floating-point
          number type that is a drop-in replacement for the native C++ floating-point
          types, but with much greater precision.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> can
          be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits</span></code>
          template parameter. The typedefs <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_bin_float_100</span></code> provide
          arithmetic types at 50 and 100 decimal digits precision respectively.
        </p>
<p>
          Optionally, you can specify whether the precision is specified in decimal
          digits or binary bits - for example to declare a <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
          with exactly the same precision as <code class="computeroutput"><span class="keyword">double</span></code>
          one would use <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
          The typedefs <code class="computeroutput"><span class="identifier">cpp_bin_float_single</span></code>,
          <code class="computeroutput"><span class="identifier">cpp_bin_float_double</span></code>,
          <code class="computeroutput"><span class="identifier">cpp_bin_float_quad</span></code>, <code class="computeroutput"><span class="identifier">cpp_bin_float_oct</span></code> and <code class="computeroutput"><span class="identifier">cpp_bin_float_double_extended</span></code>
          provide software analogues of the IEEE single, double, quad and octuple
          float data types, plus the Intel-extended-double type respectively. Note
          that while these types are functionally equivalent to the native IEEE types,
          but they do not have the same size or bit-layout as true IEEE compatible
          types.
        </p>
<p>
          Normally <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
          allocates no memory: all of the space required for its digits are allocated
          directly within the class. As a result care should be taken not to use
          the class with too high a digit count as stack space requirements can grow
          out of control. If that represents a problem then providing an allocator
          as a template parameter causes <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
          to dynamically allocate the memory it needs: this significantly reduces
          the size of <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>
          and increases the viable upper limit on the number of digits at the expense
          of performance. However, please bear in mind that arithmetic operations
          rapidly become <span class="emphasis"><em>very</em></span> expensive as the digit count grows:
          the current implementation really isn't optimized or designed for large
          digit counts. Note that since the actual type of the objects allocated
          is completely opaque, the suggestion would be to use an allocator with
          <code class="computeroutput"><span class="keyword">void</span></code> <code class="computeroutput"><span class="identifier">value_type</span></code>,
          for example: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">,</span> <span class="identifier">digit_base_10</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span></code>.
        </p>
<p>
          The final template parameters determine the type and range of the exponent:
          parameter <code class="computeroutput"><span class="identifier">Exponent</span></code> can
          be any signed integer type, but note that <code class="computeroutput"><span class="identifier">MinExponent</span></code>
          and <code class="computeroutput"><span class="identifier">MaxExponent</span></code> can not
          go right up to the limits of the <code class="computeroutput"><span class="identifier">Exponent</span></code>
          type as there has to be a little extra headroom for internal calculations.
          You will get a compile time error if this is the case. In addition if MinExponent
          or MaxExponent are zero, then the library will choose suitable values that
          are as large as possible given the constraints of the type and need for
          extra headroom for internal calculations.
        </p>
<p>
          There is full standard library and <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          support available for this type.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>s
              have a value of zero.
            </li>
<li class="listitem">
              The radix of this type is 2, even when the precision is specified as
              decimal digits.
            </li>
<li class="listitem">
              The type supports both infinities and NaNs. An infinity is generated
              whenever the result would overflow, and a NaN is generated for any
              mathematically undefined operation.
            </li>
<li class="listitem">
              There is a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> specialisation for
              this type.
            </li>
<li class="listitem">
              Any <code class="computeroutput"><span class="identifier">number</span></code> instantiated
              on this type, is convertible to any other <code class="computeroutput"><span class="identifier">number</span></code>
              instantiated on this type - for example you can convert from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> to <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">SomeOtherValue</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
              Narrowing conversions round to nearest and are <code class="computeroutput"><span class="keyword">explicit</span></code>.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              All arithmetic operations are correctly rounded to nearest. String
              conversions and the <code class="computeroutput"><span class="identifier">sqrt</span></code>
              function are also correctly rounded, but transcendental functions (sin,
              cos, pow, exp etc) are not.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.cpp_bin_float.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.cpp_bin_float.cpp_bin_float_example"></a></span><a class="link" href="cpp_bin_float.html#boost_multiprecision.tut.floats.cpp_bin_float.cpp_bin_float_example">cpp_bin_float
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="comment">// Operations at fixed precision and full numeric_limits support:</span>
   <span class="identifier">cpp_bin_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// We can use any C++ std lib function, lets print all the digits as well:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_100</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>

   <span class="comment">// We can also use any function from Boost.Math:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// These even work when the argument is an expression template:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// And since we have an extended exponent range we can generate some really large</span>
   <span class="comment">// numbers here (4.0238726007709377354370243e+2564):</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">cpp_bin_float_100</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../floats.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="cpp_dec_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_dec_float</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="cpp_bin_float.html" title="cpp_bin_float">
<link rel="next" href="gmp_float.html" title="gmp_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_bin_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.cpp_dec_float"></a><a class="link" href="cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExponentType</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_dec_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_100</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code> back-end
          is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as an entirely C++ (header only and dependency free) floating-point
          number type that is a drop-in replacement for the native C++ floating-point
          types, but with much greater precision.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code> can
          be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits10</span></code>
          template parameter. The typedefs <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_dec_float_100</span></code> provide
          arithmetic types at 50 and 100 decimal digits precision respectively. Optionally,
          you can specify an integer type to use for the exponent, this defaults
          to a 32-bit integer type which is more than large enough for the vast majority
          of use cases, but larger types such as <code class="computeroutput"><span class="keyword">long</span>
          <span class="keyword">long</span></code> can also be specified if you
          need a truly huge exponent range. In any case the ExponentType must be
          a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> signed integer type at least 2 bytes and 16-bits wide.
        </p>
<p>
          Normally <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          allocates no memory: all of the space required for its digits are allocated
          directly within the class. As a result care should be taken not to use
          the class with too high a digit count as stack space requirements can grow
          out of control. If that represents a problem then providing an allocator
          as the final template parameter causes <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          to dynamically allocate the memory it needs: this significantly reduces
          the size of <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          and increases the viable upper limit on the number of digits at the expense
          of performance. However, please bear in mind that arithmetic operations
          rapidly become <span class="emphasis"><em>very</em></span> expensive as the digit count grows:
          the current implementation really isn't optimized or designed for large
          digit counts.
        </p>
<p>
          There is full standard library and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          support available for this type.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>s
              have a value of zero.
            </li>
<li class="listitem">
              The radix of this type is 10. As a result it can behave subtly differently
              from base-2 types.
            </li>
<li class="listitem">
              The type has a number of internal guard digits over and above those
              specified in the template argument. Normally these should not be visible
              to the user.
            </li>
<li class="listitem">
              The type supports both infinities and NaNs. An infinity is generated
              whenever the result would overflow, and a NaN is generated for any
              mathematically undefined operation.
            </li>
<li class="listitem">
              There is a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code> specialisation for
              this type.
            </li>
<li class="listitem">
              Any <code class="computeroutput"><span class="identifier">number</span></code> instantiated
              on this type, is convertible to any other <code class="computeroutput"><span class="identifier">number</span></code>
              instantiated on this type - for example you can convert from <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> to <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="identifier">SomeOtherValue</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
              Narrowing conversions are truncating and <code class="computeroutput"><span class="keyword">explicit</span></code>.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              The actual precision of a <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
              is always slightly higher than the number of digits specified in the
              template parameter, actually how much higher is an implementation detail
              but is always at least 8 decimal digits.
            </li>
<li class="listitem">
              Operations involving <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
              are always truncating. However, note that since there are guard digits
              in effect, in practice this has no real impact on accuracy for most
              use cases.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.cpp_dec_float.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example"></a></span><a class="link" href="cpp_dec_float.html#boost_multiprecision.tut.floats.cpp_dec_float.cpp_dec_float_example">cpp_dec_float
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="comment">// Operations at fixed precision and full numeric_limits support:</span>
   <span class="identifier">cpp_dec_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// Note that digits10 is the same as digits, since we're base 10! :</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_100</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// We can use any C++ std lib function, lets print all the digits as well:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_100</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>
   <span class="comment">// We can also use any function from Boost.Math:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// These even work when the argument is an expression template:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// And since we have an extended exponent range we can generate some really large </span>
   <span class="comment">// numbers here (4.0238726007709377354370243e+2564):</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">cpp_dec_float_100</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_bin_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/float128.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>float128</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="mpfr_float.html" title="mpfr_float">
<link rel="next" href="fp_eg.html" title="Examples">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.float128"></a><a class="link" href="float128.html" title="float128">float128</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">float128_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">float128_backend</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>    <span class="identifier">float128</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">float128</span></code> number type
          is a very thin wrapper around GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          or Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data types
          and provides an real-number type that is a drop-in replacement for the
          native C++ floating-point types, but with a 113 bit mantissa, and compatible
          with FORTRAN's 128-bit QUAD real.
        </p>
<p>
          All the usual standard library and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          support are available, performance should be equivalent to the underlying
          native types: for example the LINPACK benchmarks for GCC's <code class="computeroutput"><span class="identifier">__float128</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">float128</span></code>
          both achieved 5.6 MFLOPS<a href="#ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote" name="boost_multiprecision.tut.floats.float128.f0"><sup class="footnote">[3]</sup></a>.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">float128</span></code> are copy constructible
          and assignable from GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          and Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data
          types.
        </p>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">__float128</span></code>
          or <code class="computeroutput"><span class="identifier">_Quad</span></code> type via the
          <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">float128_backend</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">float128</span></code>s
              have the value zero.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              This type is fully <code class="computeroutput"><span class="keyword">constexpr</span></code>
              aware - basic constexpr arithmetic is supported from C++14 and onwards,
              comparisons, plus the functions <code class="computeroutput"><span class="identifier">fabs</span></code>,
              <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnormal</span></code>,
              <code class="computeroutput"><span class="identifier">isfinite</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code> and <code class="computeroutput"><span class="identifier">isnan</span></code>
              are also supported if either the compiler implements C++20's <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>,
              or if the compiler is GCC.
            </li>
<li class="listitem">
              It is not possible to round-trip objects of this type to and from a
              string and get back exactly the same value when compiled with Intel's
              C++ compiler and using <code class="computeroutput"><span class="identifier">_Quad</span></code>
              as the underlying type: this is a current limitation of our code. Round
              tripping when using <code class="computeroutput"><span class="identifier">__float128</span></code>
              as the underlying type is possible (both for GCC and Intel).
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in an infinity being produced.
            </li>
<li class="listitem">
              Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
              used as a literal type (constexpr support).
            </li>
<li class="listitem">
              Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
              used for full <code class="computeroutput"><span class="keyword">constexpr</span></code>
              arithmetic from C++14 and later with GCC. The functions <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fabs</span></code>,
              <code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnan</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code>,
              <code class="computeroutput"><span class="identifier">isfinite</span></code> and <code class="computeroutput"><span class="identifier">isnormal</span></code> are also <code class="computeroutput"><span class="keyword">constexpr</span></code>,
              but the transcendental functions are not.
            </li>
<li class="listitem">
              When using the Intel compiler, the underlying type defaults to <code class="computeroutput"><span class="identifier">__float128</span></code> if it's available and
              <code class="computeroutput"><span class="identifier">_Quad</span></code> if not. You can
              override the default by defining either <code class="computeroutput"><span class="identifier">BOOST_MP_USE_FLOAT128</span></code>
              or <code class="computeroutput"><span class="identifier">BOOST_MP_USE_QUAD</span></code>.
            </li>
<li class="listitem">
              When the underlying type is Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code>
              type, the code must be compiled with the compiler option <code class="computeroutput"><span class="special">-</span><span class="identifier">Qoption</span><span class="special">,</span><span class="identifier">cpp</span><span class="special">,--</span><span class="identifier">extended_float_type</span></code>.
            </li>
<li class="listitem">
              When compiling with <code class="computeroutput"><span class="identifier">gcc</span></code>,
              you need to use the flag <code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">gnu</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code>,
              as the suffix 'Q' is a GNU extension. Compilation fails with the flag
              <code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code> unless you also use <code class="computeroutput"><span class="special">-</span><span class="identifier">fext</span><span class="special">-</span><span class="identifier">numeric</span><span class="special">-</span><span class="identifier">literals</span></code>.
            </li>
<li class="listitem">
              You will need to link to <code class="computeroutput"><span class="identifier">libquadmath</span><span class="special">.</span><span class="identifier">dll</span></code>
              with the link command <code class="computeroutput"><span class="special">-</span><span class="identifier">lquadmath</span></code> and ensure that the DLL
              is visible by the linker. If you are using the B2/bjam build system
              then commands<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">lQUADMATH</span></code>
              and <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">L</span><span class="string">"path/to/lib"</span></code> will be needed.
            </li>
<li class="listitem">
              The values shown by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;</span></code> and extremely close <span class="emphasis"><em>but
              not identical</em></span> to those from the equivalent precision and
              range multiprecision types <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;</span></code> and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_quad</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.float128.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.float128.float128_example"></a></span><a class="link" href="float128.html#boost_multiprecision.tut.floats.float128.float128_example">float128
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span> <span class="comment">// Potential to cause name collisions?</span>
   <span class="comment">// using boost::multiprecision::float128; // is safer.</span>
</pre>
<p>
          The type float128 provides operations at 128-bit precision with <a href="https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#IEEE_754_quadruple-precision_binary_floating-point_format:_binary128" target="_top">Quadruple-precision
          floating-point format</a> and have full <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          support:
        </p>
<pre class="programlisting"><span class="identifier">float128</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
</pre>
<p>
          There are 15 bits of (biased) binary exponent and 113-bits of significand
          precision
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          or 33 decimal places:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          We can use any C++ std library function, so let's show all the at-most
          36 potentially significant digits, and any trailing zeros, as well:
        </p>
<pre class="programlisting"> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">setf</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">showpoint</span><span class="special">);</span> <span class="comment">// Include any trailing zeros.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Shows log(2) = 0.693147180559945309417232121458176575</span>
</pre>
<p>
          We can also use any function from Boost.Math, for example, the 'true gamma'
          function <code class="computeroutput"><span class="identifier">tgamma</span></code>:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          And since we have an extended exponent range, we can generate some really
          large numbers here (4.02387260077093773543702433923004111e+2564):
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">float128</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          We can declare constants using GCC or Intel's native types, and literals
          with the Q suffix, and these can be declared <code class="computeroutput"><span class="keyword">constexpr</span></code>
          if required:
        </p>
<pre class="programlisting"><span class="comment">// std::numeric_limits&lt;float128&gt;::max_digits10 = 36</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.14159265358979323846264338327950288</span><span class="identifier">Q</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pi = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//pi = 3.14159265358979323846264338327950280</span>
</pre>
<p>
          Values for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;</span></code>
          are:
        </p>
<pre class="programlisting"><span class="identifier">GCC</span> <span class="number">8.1</span><span class="special">.</span><span class="number">0</span>

<span class="identifier">Type</span> <span class="identifier">name</span> <span class="identifier">is</span> <span class="identifier">float128_t</span><span class="special">:</span>
<span class="identifier">Type</span> <span class="identifier">is</span> <span class="identifier">g</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_fundamental</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_signed</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_unsigned</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_trivial</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_standard_layout</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_pod</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_exact</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is</span> <span class="identifier">bounded</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_modulo</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_iec559</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">traps</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">tinyness_before</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min</span><span class="special">()</span> <span class="special">=</span> <span class="number">3.36210314311209350626267781732175260e-4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">lowest</span><span class="special">()</span> <span class="special">=</span> <span class="special">-</span><span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min_exponent</span> <span class="special">=</span> <span class="special">-</span><span class="number">16381</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_exponent</span> <span class="special">=</span> <span class="number">16384</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">epsilon</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.92592994438723585305597794258492732e-34</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">radix</span> <span class="special">=</span> <span class="number">2</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits</span> <span class="special">=</span> <span class="number">113</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits10</span> <span class="special">=</span> <span class="number">33</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_digits10</span> <span class="special">=</span> <span class="number">36</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">has</span> <span class="identifier">denorm</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">denorm</span> <span class="identifier">min</span> <span class="special">=</span> <span class="number">6.47517511943802511092443895822764655e-4966</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_loss</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">limits</span><span class="special">::</span><span class="identifier">has_signaling_NaN</span> <span class="special">==</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">quiet_NaN</span> <span class="special">=</span> <span class="identifier">nan</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">infinity</span> <span class="special">=</span> <span class="identifier">inf</span>
</pre>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote"><p><a href="#boost_multiprecision.tut.floats.float128.f0" class="para"><sup class="para">[3] </sup></a>
            On 64-bit Ubuntu 11.10, GCC-4.8.0, Intel Core 2 Duo T5800.
          </p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/aos.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Area of Circle</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="floatbuiltinctor.html" title="Construction from Specific Values Without Precision Loss">
<link rel="next" href="caveats.html" title="Drop-in Caveats">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="floatbuiltinctor.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="caveats.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.aos"></a><a class="link" href="aos.html" title="Area of Circle">Area of
          Circle</a>
</h5></div></div></div>
<p>
            Generic numeric programming employs templates to use the same code for
            different floating-point types and functions. Consider the area of a
            circle a of radius r, given by
          </p>
<div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>a = π * r<sup>2</sup></em></span>
            </p></blockquote></div>
<p>
            The area of a circle can be computed in generic programming using Boost.Math
            for the constant π as shown below:
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">constants</span><span class="special">/</span><span class="identifier">constants</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="identifier">T</span> <span class="identifier">area_of_a_circle</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">r</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="identifier">r</span> <span class="special">*</span> <span class="identifier">r</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            It is possible to use <code class="computeroutput"><span class="identifier">area_of_a_circle</span><span class="special">()</span></code> with built-in floating-point types
            as well as floating-point types from Boost.Multiprecision. In particular,
            consider a system with 4-byte single-precision float, 8-byte double-precision
            double and also the <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
            data type from Boost.Multiprecision with 50 decimal digits of precision.
          </p>
<p>
            We can compute and print the approximate area of a circle with radius
            123/100 for <code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code> and <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
            with the program below (see next section for choosing 123/100 instead
            of 1.23).
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span><span class="special">;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">**)</span>
<span class="special">{</span>
   <span class="keyword">const</span> <span class="keyword">float</span> <span class="identifier">r_f</span><span class="special">(</span><span class="keyword">float</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">);</span>
   <span class="keyword">const</span> <span class="keyword">float</span> <span class="identifier">a_f</span> <span class="special">=</span> <span class="identifier">area_of_a_circle</span><span class="special">(</span><span class="identifier">r_f</span><span class="special">);</span>

   <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">r_d</span><span class="special">(</span><span class="keyword">double</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">);</span>
   <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">a_d</span> <span class="special">=</span> <span class="identifier">area_of_a_circle</span><span class="special">(</span><span class="identifier">r_d</span><span class="special">);</span>

   <span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span> <span class="identifier">r_mp</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">);</span>
   <span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span> <span class="identifier">a_mp</span> <span class="special">=</span> <span class="identifier">area_of_a_circle</span><span class="special">(</span><span class="identifier">r_mp</span><span class="special">);</span>

   <span class="comment">// 4.75292</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">a_f</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 4.752915525616</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">a_d</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 4.7529155256159981904701331745635599135018975843146</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">a_mp</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            In later examples we'll look at calling both standard library and Boost.Math
            functions from within generic code. We'll also show how to cope with
            template arguments which are expression-templates rather than number
            types.
          </p>
<p>
            But first some warnings about how multiprecision types are slightly but
            significantly different <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in) types</a>.
          </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="floatbuiltinctor.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="caveats.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/caveats.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Drop-in Caveats</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="aos.html" title="Area of Circle">
<link rel="next" href="jel.html" title="Defining a Special Function.">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="aos.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="jel.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.caveats"></a><a class="link" href="caveats.html" title="Drop-in Caveats">Drop-in
          Caveats</a>
</h5></div></div></div>
<h6>
<a name="boost_multiprecision.tut.floats.fp_eg.caveats.h0"></a>
            <span class="phrase"><a name="boost_multiprecision.tut.floats.fp_eg.caveats.using_boost_multiprecision_cpp_f"></a></span><a class="link" href="caveats.html#boost_multiprecision.tut.floats.fp_eg.caveats.using_boost_multiprecision_cpp_f">Using
            Boost.Multiprecision <code class="computeroutput"><span class="identifier">cpp_float</span></code>
            types for numerical calculations with higher precision than fundamental
            (built-in) <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>.</a>
          </h6>
<p>
            The Boost.Multiprecision library can be used for computations requiring
            precision exceeding that of standard <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> types such as <code class="computeroutput"><span class="keyword">float</span></code>,
            <code class="computeroutput"><span class="keyword">double</span></code> and <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>.
            For extended-precision calculations, Boost.Multiprecision supplies several
            template data types called <code class="computeroutput"><span class="identifier">cpp_bin_float_</span></code>.
          </p>
<p>
            The number of decimal digits of precision is fixed at compile-time via
            template parameter.
          </p>
<p>
            To use these floating-point types and <a href="https://www.boost.org/doc/libs/release/libs/math/doc/html/constants.html" target="_top">Boost.Math
            collection of high-precision constants</a>, we need some includes:
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">constants</span><span class="special">/</span><span class="identifier">constants</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// that includes some predefined typedefs like:</span>
<span class="comment">// using boost::multiprecision::cpp_bin_float_quad;</span>
<span class="comment">// using boost::multiprecision::cpp_bin_float_50;</span>
<span class="comment">// using boost::multiprecision::cpp_bin_float_100;</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">limits</span><span class="special">&gt;</span>
</pre>
<p>
            So now we can demonstrate with some trivial calculations:
          </p>
<p>
            Using a <code class="computeroutput"><span class="keyword">typedef</span></code> like <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code> hides the complexity
            of multiprecision, and allows us to define variables with 50 decimal
            digit precision just like <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in)</a> <code class="computeroutput"><span class="keyword">double</span></code>.
          </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_50</span><span class="special">;</span>

<span class="identifier">cpp_bin_float_50</span> <span class="identifier">seventh</span> <span class="special">=</span> <span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">/</span> <span class="number">7</span><span class="special">;</span>  <span class="comment">// 1 / 7</span>
</pre>
<p>
            By default, output would only show the standard 6 decimal digits, so
            set precision to show all 50 significant digits, including any trailing
            zeros (to show the full implied 50 digit precision).
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span> <span class="comment">// Show 50 decimal digit precision.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Append any trailing zeros.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">seventh</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            which outputs:
          </p>
<pre class="programlisting"><span class="number">0.14285714285714285714285714285714285714285714285714</span>
</pre>
<p>
            We can also use Boost.Math <a href="https://www.boost.org/doc/libs/release/libs/math/doc/html/math_toolkit/constants.html" target="_top">Boost.Math
            constants</a> like π, guaranteed to be initialized with the very last
            bit of precision for the floating-point type.
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pi = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="identifier">cpp_bin_float_50</span> <span class="identifier">circumference</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">seventh</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"c =  "</span><span class="special">&lt;&lt;</span> <span class="identifier">circumference</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            which outputs
          </p>
<pre class="programlisting"><span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.1415926535897932384626433832795028841971693993751</span>

<span class="identifier">c</span> <span class="special">=</span>  <span class="number">0.89759790102565521098932668093700082405633411410717</span>
</pre>
<p>
            So using <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code>
            looks like a simple 'drop-in' for the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
            (built-in) type</a> like 'double', but beware of less-than-expected
            precision from construction or conversion from <code class="computeroutput"><span class="keyword">double</span></code>
            or other lower precision types. This is a mistake that is very easy to
            make, and very difficult to detect because the difference in precision
            is only visible after about the 17th decimal digit.
          </p>
<p>
            We can show this by constructing a fraction one seventh from <code class="computeroutput"><span class="keyword">double</span></code>:
          </p>
<pre class="programlisting"><span class="identifier">cpp_bin_float_50</span> <span class="identifier">seventh_0</span> <span class="special">=</span> <span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1</span><span class="special">/</span><span class="number">7</span><span class="special">);</span>  <span class="comment">// Avoid the schoolboy-error `double d7 = 1 / 7;` giving zero!</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"seventh_0 = "</span>  <span class="special">&lt;&lt;</span> <span class="identifier">seventh_0</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// seventh_double0 = 0.0000000000000000000000000000000000000000000000000</span>

<span class="identifier">cpp_bin_float_50</span> <span class="identifier">seventh_double</span> <span class="special">=</span> <span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1.</span><span class="special">/</span><span class="number">7</span><span class="special">);</span>  <span class="comment">// Construct from double! (0.14285714285714)</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"seventh_double = "</span>  <span class="special">&lt;&lt;</span> <span class="identifier">seventh_double</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Boost.Multiprecision post-school error!</span>
<span class="comment">// seventh_double = 0.14285714285714284921269268124888185411691665649414</span>
</pre>
<p>
            Did you spot the probably-unintended difference? After the 17th decimal
            digit, result is apparently random and not the expected recurring pattern
            14285714285714...
          </p>
<p>
            The 'random' digits after digit 17 are from the <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code>
            representation of the <code class="computeroutput"><span class="keyword">double</span></code>
            value 0.14285714285714 which is different from the 'better' <code class="computeroutput"><span class="identifier">cpp_bin_float_50</span></code> representation of
            the fraction 1/7
          </p>
<pre class="programlisting"><span class="identifier">cpp_bin_float_50</span> <span class="identifier">seventh_big</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>  <span class="comment">// 1</span>
<span class="identifier">seventh_big</span> <span class="special">/=</span> <span class="number">7</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"seventh_big = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">seventh_big</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//</span>
<span class="comment">// seventh_big     = 0.14285714285714285714285714285714285714285714285714</span>
</pre>
<p>
            Note the recurring 14285714285714 pattern as expected. We can also construct
            a <code class="computeroutput"><span class="keyword">const</span></code> version (but not
            yet <code class="computeroutput"><span class="keyword">constexpr</span></code>) and evaluate
            in a single expression:
          </p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">cpp_bin_float_50</span> <span class="identifier">seventh_const</span> <span class="special">(</span><span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">/</span> <span class="number">7</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"seventh_const = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">seventh_const</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//</span>
<span class="comment">// seventh_const = 0.14285714285714285714285714285714285714285714285714</span>
</pre>
<pre class="programlisting"><span class="comment">// Sadly we cannot (yet) write:</span>
<span class="comment">// constexpr cpp_bin_float_50 any_constexpr(0);</span>

<span class="comment">// constexpr cpp_bin_float_50 seventh_constexpr (cpp_bin_float_50(1) / 7);</span>
<span class="comment">// std::cout &lt;&lt; "seventh_constexpr = " &lt;&lt; seventh_constexpr &lt;&lt; std::endl; //</span>
<span class="comment">// nor use the macro constexpr unless it returns `const`</span>
<span class="comment">// constexpr cpp_bin_float_50 seventh_constexpr(seventh_const);</span>
</pre>
<p>
            For some purposes, this difference in precision may be insignificant,
            but if one is implementing a formula involving a fraction from integers,
            including decimal fractions like 1/10, 1/100, then comparison with other
            computations like <a href="http://www.wolframalpha.com/" target="_top">Wolfram Alpha</a>
            will reveal differences whose cause may be perplexing.
          </p>
<p>
            To get as precise-as-possible decimal fractions like 1.234, we can write
          </p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">cpp_bin_float_50</span> <span class="identifier">f1</span><span class="special">(</span><span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1234</span><span class="special">)</span> <span class="special">/</span> <span class="number">1000</span><span class="special">);</span>  <span class="comment">// Construct from a fraction.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">f1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000) = 1.2340000000000000000000000000000000000000000000000</span>
</pre>
<p>
            or
          </p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">cpp_bin_float_50</span> <span class="identifier">f2</span><span class="special">(</span><span class="string">"1.234"</span><span class="special">);</span>  <span class="comment">// Construct from decimal digit string.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cpp_bin_float_50 f2(\"1.234\") = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">f2</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// cpp_bin_float_50 f2("1.234") = 1.2340000000000000000000000000000000000000000000000</span>
</pre>
<p>
            that are different from constructing from a <code class="computeroutput"><span class="keyword">double</span></code>
            with value 1.234
          </p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">cpp_bin_float_50</span> <span class="identifier">f3</span><span class="special">(</span><span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1.234</span><span class="special">));</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cpp_bin_float_50 f3(cpp_bin_float_50(1.234)) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">f3</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.2339999999999999857891452847979962825775146484375</span>
</pre>
<p>
            Typical output is:
          </p>
<pre class="programlisting"><span class="number">0.14285714285714285714285714285714285714285714285714</span>
<span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.1415926535897932384626433832795028841971693993751</span>
<span class="identifier">c</span> <span class="special">=</span>  <span class="number">0.89759790102565521098932668093700082405633411410717</span>
<span class="identifier">seventh_0</span> <span class="special">=</span> <span class="number">0.0000000000000000000000000000000000000000000000000</span>
<span class="identifier">seventh_double</span> <span class="special">=</span> <span class="number">0.14285714285714284921269268124888185411691665649414</span>
<span class="identifier">seventh_big</span> <span class="special">=</span> <span class="number">0.14285714285714285714285714285714285714285714285714</span>
<span class="identifier">seventh_const</span> <span class="special">=</span> <span class="number">0.14285714285714285714285714285714285714285714285714</span>
<span class="identifier">cpp_bin_float_50</span> <span class="identifier">f1</span><span class="special">(</span><span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1234</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">)</span> <span class="special">=</span> <span class="number">12.340000000000000000000000000000000000000000000000</span>
<span class="identifier">cpp_bin_float_50</span> <span class="identifier">f2</span><span class="special">(</span><span class="string">"1.234"</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.2340000000000000000000000000000000000000000000000</span>
<span class="identifier">cpp_bin_float_50</span> <span class="identifier">f3</span><span class="special">(</span><span class="identifier">cpp_bin_float_50</span><span class="special">(</span><span class="number">1.234</span><span class="special">))</span> <span class="special">=</span> <span class="number">1.2339999999999999857891452847979962825775146484375</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="aos.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="jel.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/floatbuiltinctor.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Construction from Specific Values Without Precision Loss</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="../fp_eg.html" title="Examples">
<link rel="next" href="aos.html" title="Area of Circle">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="aos.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.floatbuiltinctor"></a><a class="link" href="floatbuiltinctor.html" title="Construction from Specific Values Without Precision Loss">Construction
          from Specific Values Without Precision Loss</a>
</h5></div></div></div>
<p>
            Construction of multiprecision types from built-in floating-point types
            can lead to potentially unexpected, yet correct, results. Consider, for
            instance constructing an instance of <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
            from the literal built-in floating-point <code class="computeroutput"><span class="keyword">double</span></code>
            value 11.1.
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">limits</span><span class="special">&gt;</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
  <span class="keyword">using</span> <span class="identifier">my_dec_100</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span><span class="special">;</span>

  <span class="keyword">const</span> <span class="identifier">my_dec_100</span> <span class="identifier">f11</span><span class="special">(</span><span class="number">11.1</span><span class="special">);</span>

  <span class="comment">// On a system with 64-bit double:</span>
  <span class="comment">// 11.09999999999999964472863211994990706443786621093750</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">my_dec_100</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
            <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">fixed</span>
            <span class="special">&lt;&lt;</span> <span class="identifier">f11</span>
            <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            In this example, the system has a 64-bit built in <code class="computeroutput"><span class="keyword">double</span></code>
            representation. The variable <code class="computeroutput"><span class="identifier">f11</span></code>
            is initialized with the literal <code class="computeroutput"><span class="keyword">double</span></code>
            value 11.1. Recall that built-in floating-point representations are based
            on successive binary fractional approximations. These are, in fact, very
            close approximations. But they are approximations nonetheless, having
            their built-in finite precision.
          </p>
<p>
            For this reason, the full multiple precision value of the <code class="computeroutput"><span class="keyword">double</span></code> approximation of 11.1 is given
            by the large value shown above. Observations show us that the value is
            reliable up to the approximate 15 decimal digit precision of built-in
            64-bit <code class="computeroutput"><span class="keyword">double</span></code> on this system.
          </p>
<p>
            If the exact value of 11.1 is desired (within the wider precision of
            the multiprecision type), then construction from literal string or from
            a rational integral construction/division sequence should be used.
          </p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">my_dec_100</span> <span class="identifier">f11_str</span><span class="special">(</span><span class="string">"11.1"</span><span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">my_dec_100</span> <span class="identifier">f11_n</span>  <span class="special">(</span><span class="identifier">my_dec_100</span><span class="special">(</span><span class="number">111</span><span class="special">)</span> <span class="special">/</span> <span class="number">10</span><span class="special">);</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="aos.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/gauss_lagerre_quadrature.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Gauss-Laguerre quadrature</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="variable_precision.html" title="Variable-Precision Newton Evaluation">
<link rel="next" href="../../interval.html" title="Interval Number Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="variable_precision.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../interval.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.gauss_lagerre_quadrature"></a><a class="link" href="gauss_lagerre_quadrature.html" title="Gauss-Laguerre quadrature">Gauss-Laguerre
          quadrature</a>
</h5></div></div></div>
<p>
            This example uses <a href="https://www.boost.org/doc/libs/release/libs/multiprecision/doc/index.html" target="_top">Boost.Multiprecision</a>
            to implement a high-precision Gauss-Laguerre quadrature integration.
            The quadrature is used to calculate the <code class="computeroutput"><span class="identifier">airy_ai</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> function for real-valued <code class="computeroutput"><span class="identifier">x</span></code> on the positive axis with <code class="computeroutput"><span class="identifier">x</span> <span class="special">&gt;=</span> <span class="number">1</span></code>.
          </p>
<p>
            In this way, the integral representation could be seen as part of a scheme
            to calculate real-valued Airy functions on the positive axis for medium
            to large argument. A Taylor series or hypergeometric function (not part
            of this example) could be used for smaller arguments.
          </p>
<p>
            This example has been tested with decimal digits counts ranging from
            21...301, by adjusting the parameter <code class="computeroutput"><span class="identifier">local</span><span class="special">::</span><span class="identifier">my_digits10</span></code>
            at compile time.
          </p>
<p>
            The quadrature integral representaion of <code class="computeroutput"><span class="identifier">airy_ai</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> used in this example can be found in:
          </p>
<p>
            A. Gil, J. Segura, N.M. Temme, "Numerical Methods for Special Functions"
            (SIAM Press 2007), ISBN 9780898717822, Sect. 5.3.3, in particular Eq.
            5.110, page 145.
          </p>
<p>
            Subsequently, Gil et al's book cites the another work: W. Gautschi, "Computation
            of Bessel and Airy functions and of related Gaussian quadrature formulae",
            BIT, 42 (2002), pp. 110-118, <a href="https://doi.org/10.1023/A:1021974203359" target="_top">https://doi.org/10.1023/A:1021974203359</a>
            that is also available as <a href="https://www.cs.purdue.edu/homes/wxg/selected_works/section_02/169.pdf" target="_top">Gautschi_169.pdf</a>.
          </p>
<p>
            This Gauss-Laguerre quadrature is designed for <code class="computeroutput"><span class="identifier">airy_ai</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> with real-valued <code class="computeroutput"><span class="identifier">x</span>
            <span class="special">&gt;=</span> <span class="number">1</span></code>.
          </p>
<p>
            The example uses Gauss-Laguerre quadrature integration to compute <code class="computeroutput"><span class="identifier">airy_ai</span><span class="special">(</span><span class="identifier">x</span> <span class="special">/</span> <span class="number">7</span><span class="special">)</span></code> with
            <code class="computeroutput"><span class="number">7</span> <span class="special">&lt;=</span>
            <span class="identifier">x</span> <span class="special">&lt;=</span>
            <span class="number">120</span></code> and where <code class="computeroutput"><span class="identifier">x</span></code>
            is incremented in steps of 1.
          </p>
<p>
            During development of this example, we have empirically found the numbers
            of Gauss-Laguerre coefficients needed for convergence when using various
            counts of base-10 digits.
          </p>
<p>
            Let's calibrate, for instance, the number of coefficients needed at the
            point <code class="computeroutput"><span class="identifier">x</span> <span class="special">=</span>
            <span class="number">1</span></code>.
          </p>
<p>
            Empirical data were used with <a href="http://www.wolframalpha.com/" target="_top">Wolfram
            Alpha</a> :
          </p>
<pre class="programlisting"><span class="identifier">Fit</span><span class="special">[{{</span><span class="number">21.0</span><span class="special">,</span> <span class="number">3.5</span><span class="special">},</span> <span class="special">{</span><span class="number">51.0</span><span class="special">,</span> <span class="number">11.1</span><span class="special">},</span> <span class="special">{</span><span class="number">101.0</span><span class="special">,</span> <span class="number">22.5</span><span class="special">},</span> <span class="special">{</span><span class="number">201.0</span><span class="special">,</span> <span class="number">46.8</span><span class="special">}},</span> <span class="special">{</span><span class="number">1</span><span class="special">,</span> <span class="identifier">d</span><span class="special">,</span> <span class="identifier">d</span><span class="special">^</span><span class="number">2</span><span class="special">},</span> <span class="identifier">d</span><span class="special">]</span><span class="identifier">FullSimplify</span><span class="special">[%]</span>
  <span class="number">0.0000178915</span> <span class="identifier">d</span><span class="special">^</span><span class="number">2</span> <span class="special">+</span> <span class="number">0.235487</span> <span class="identifier">d</span> <span class="special">-</span> <span class="number">1.28301</span>
  <span class="keyword">or</span>
  <span class="special">-</span><span class="number">1.28301</span> <span class="special">+</span> <span class="special">(</span><span class="number">0.235487</span> <span class="special">+</span> <span class="number">0.0000178915</span> <span class="identifier">d</span><span class="special">)</span> <span class="identifier">d</span>
</pre>
<p>
            We need significantly more coefficients at smaller real values than are
            needed at larger real values because the slope derivative of <code class="computeroutput"><span class="identifier">airy_ai</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
            gets more steep as x approaches zero. <code class="computeroutput"><span class="identifier">laguerre_order</span></code>
            is calculated using this equation.
          </p>
<p>
            Snippets from (copious) output from a progress bar during calculation
            of approximate root estimates followed by calculation of accurate abscissa
            and weights is:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">local</span><span class="special">::</span><span class="identifier">float_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">:</span> <span class="number">101</span>
<span class="identifier">laguerre_order</span><span class="special">:</span> <span class="number">2291</span>

<span class="identifier">Finding</span> <span class="identifier">the</span> <span class="identifier">approximate</span> <span class="identifier">roots</span><span class="special">...</span>
<span class="identifier">root_estimates</span><span class="special">.</span><span class="identifier">size</span><span class="special">():</span> <span class="number">1</span><span class="special">,</span> <span class="number">0.0</span><span class="special">%</span>
<span class="identifier">root_estimates</span><span class="special">.</span><span class="identifier">size</span><span class="special">():</span> <span class="number">8</span><span class="special">,</span> <span class="number">0.3</span><span class="special">%</span>
<span class="identifier">root_estimates</span><span class="special">.</span><span class="identifier">size</span><span class="special">():</span> <span class="number">16</span><span class="special">,</span> <span class="number">0.7</span><span class="special">%</span>
<span class="special">...</span>
<span class="identifier">root_estimates</span><span class="special">.</span><span class="identifier">size</span><span class="special">():</span> <span class="number">2288</span><span class="special">,</span> <span class="number">99.9</span><span class="special">%</span>
<span class="identifier">root_estimates</span><span class="special">.</span><span class="identifier">size</span><span class="special">():</span> <span class="number">2291</span><span class="special">,</span> <span class="number">100.0</span><span class="special">%</span>


<span class="identifier">Calculating</span> <span class="identifier">abscissas</span> <span class="keyword">and</span> <span class="identifier">weights</span><span class="special">.</span> <span class="identifier">Processed</span> <span class="number">1</span><span class="special">,</span> <span class="number">0.0</span><span class="special">%</span>
<span class="identifier">Calculating</span> <span class="identifier">abscissas</span> <span class="keyword">and</span> <span class="identifier">weights</span><span class="special">.</span> <span class="identifier">Processed</span> <span class="number">9</span><span class="special">,</span> <span class="number">0.4</span><span class="special">%</span>
<span class="special">...</span>
<span class="identifier">Calculating</span> <span class="identifier">abscissas</span> <span class="keyword">and</span> <span class="identifier">weights</span><span class="special">.</span> <span class="identifier">Processed</span> <span class="number">2289</span><span class="special">,</span> <span class="number">99.9</span><span class="special">%</span>
<span class="identifier">Calculating</span> <span class="identifier">abscissas</span> <span class="keyword">and</span> <span class="identifier">weights</span><span class="special">.</span> <span class="identifier">Processed</span> <span class="number">2291</span><span class="special">,</span> <span class="number">100.0</span><span class="special">%</span>
</pre>
<p>
            Finally the result using Gauss-Laguerre quadrature is compared with a
            calculation using <code class="computeroutput"><span class="identifier">cyl_bessel_k</span></code>,
            and both are listed, finally confirming that none differ more than a
            small tolerance.
          </p>
<pre class="programlisting"><span class="identifier">airy_ai_value</span>  <span class="special">:</span> <span class="number">0.13529241631288141552414742351546630617494414298833070600910205475763353480226572366348710990874867334</span>
<span class="identifier">airy_ai_control</span><span class="special">:</span> <span class="number">0.13529241631288141552414742351546630617494414298833070600910205475763353480226572366348710990874868323</span>
<span class="identifier">airy_ai_value</span>  <span class="special">:</span> <span class="number">0.11392302126009621102904231059693500086750049240884734708541630001378825889924647699516200868335286103</span>
<span class="identifier">airy_ai_control</span><span class="special">:</span> <span class="number">0.1139230212600962110290423105969350008675004924088473470854163000137882588992464769951620086833528582</span>
<span class="special">...</span>
<span class="identifier">airy_ai_value</span>  <span class="special">:</span> <span class="number">3.8990420982303275013276114626640705170145070824317976771461533035231088620152288641360519429331427451e-22</span>
<span class="identifier">airy_ai_control</span><span class="special">:</span> <span class="number">3.8990420982303275013276114626640705170145070824317976771461533035231088620152288641360519429331426481e-22</span>

<span class="identifier">Total</span><span class="special">...</span> <span class="identifier">result_is_ok</span><span class="special">:</span> <span class="keyword">true</span>
</pre>
<p>
            For more detail see comments in the source code for this example at
            <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../example/gauss_laguerre_quadrature.cpp" target="_top">gauss_laguerre_quadrature.cpp</a>.
          </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="variable_precision.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../interval.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/gi.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Calculating an Integral</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="nd.html" title="Calculating a Derivative">
<link rel="next" href="poly_eg.html" title="Polynomial Evaluation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="nd.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="poly_eg.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.gi"></a><a class="link" href="gi.html" title="Calculating an Integral">Calculating
          an Integral</a>
</h5></div></div></div>
<p>
            Similar to the generic derivative example, we can calculate integrals
            in a similar manner:
          </p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">function_type</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="identifier">value_type</span> <span class="identifier">integral</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">a</span><span class="special">,</span>
                           <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">b</span><span class="special">,</span>
                           <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">tol</span><span class="special">,</span>
                           <span class="identifier">function_type</span> <span class="identifier">func</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">unsigned</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">1U</span><span class="special">;</span>

   <span class="identifier">value_type</span> <span class="identifier">h</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">);</span>
   <span class="identifier">value_type</span> <span class="identifier">I</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">func</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">func</span><span class="special">(</span><span class="identifier">b</span><span class="special">))</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">h</span> <span class="special">/</span> <span class="number">2</span><span class="special">);</span>

   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">k</span> <span class="special">=</span> <span class="number">0U</span><span class="special">;</span> <span class="identifier">k</span> <span class="special">&lt;</span> <span class="number">8U</span><span class="special">;</span> <span class="identifier">k</span><span class="special">++)</span>
   <span class="special">{</span>
      <span class="identifier">h</span> <span class="special">/=</span> <span class="number">2</span><span class="special">;</span>

      <span class="identifier">value_type</span> <span class="identifier">sum</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
      <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">1U</span><span class="special">;</span> <span class="identifier">j</span> <span class="special">&lt;=</span> <span class="identifier">n</span><span class="special">;</span> <span class="identifier">j</span><span class="special">++)</span>
      <span class="special">{</span>
         <span class="identifier">sum</span> <span class="special">+=</span> <span class="identifier">func</span><span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">value_type</span><span class="special">((</span><span class="identifier">j</span> <span class="special">*</span> <span class="number">2</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">h</span><span class="special">));</span>
      <span class="special">}</span>

      <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">I0</span> <span class="special">=</span> <span class="identifier">I</span><span class="special">;</span>
      <span class="identifier">I</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">I</span> <span class="special">/</span> <span class="number">2</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">h</span> <span class="special">*</span> <span class="identifier">sum</span><span class="special">);</span>

      <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">ratio</span>     <span class="special">=</span> <span class="identifier">I0</span> <span class="special">/</span> <span class="identifier">I</span><span class="special">;</span>
      <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">delta</span>     <span class="special">=</span> <span class="identifier">ratio</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
      <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">delta_abs</span> <span class="special">=</span> <span class="special">((</span><span class="identifier">delta</span> <span class="special">&lt;</span> <span class="number">0</span><span class="special">)</span> <span class="special">?</span> <span class="special">-</span><span class="identifier">delta</span> <span class="special">:</span> <span class="identifier">delta</span><span class="special">);</span>

      <span class="keyword">if</span><span class="special">((</span><span class="identifier">k</span> <span class="special">&gt;</span> <span class="number">1U</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">delta_abs</span> <span class="special">&lt;</span> <span class="identifier">tol</span><span class="special">))</span>
      <span class="special">{</span>
         <span class="keyword">break</span><span class="special">;</span>
      <span class="special">}</span>

      <span class="identifier">n</span> <span class="special">*=</span> <span class="number">2U</span><span class="special">;</span>
   <span class="special">}</span>

   <span class="keyword">return</span> <span class="identifier">I</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            The following sample program shows how the function can be called, we
            begin by defining a function object, which when integrated should yield
            the Bessel J function:
          </p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cyl_bessel_j_integral_rep</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
   <span class="identifier">cyl_bessel_j_integral_rep</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">unsigned</span> <span class="identifier">N</span><span class="special">,</span>
      <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span> <span class="identifier">X</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">n</span><span class="special">(</span><span class="identifier">N</span><span class="special">),</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">X</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>

   <span class="identifier">value_type</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">)</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="comment">// pi * Jn(x) = Int_0^pi [cos(x * sin(t) - n*t) dt]</span>
      <span class="keyword">return</span> <span class="identifier">cos</span><span class="special">(</span><span class="identifier">x</span> <span class="special">*</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">*</span> <span class="identifier">t</span><span class="special">));</span>
   <span class="special">}</span>

<span class="keyword">private</span><span class="special">:</span>
   <span class="keyword">const</span> <span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<pre class="programlisting">   <span class="comment">/* The function can now be called as follows: */</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">**)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">mp_type</span><span class="special">;</span>

   <span class="keyword">const</span> <span class="keyword">float</span> <span class="identifier">j2_f</span> <span class="special">=</span>
      <span class="identifier">integral</span><span class="special">(</span><span class="number">0.0F</span><span class="special">,</span>
      <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;(),</span>
      <span class="number">0.01F</span><span class="special">,</span>
      <span class="identifier">cyl_bessel_j_integral_rep</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;(</span><span class="number">2U</span><span class="special">,</span> <span class="number">1.23F</span><span class="special">))</span> <span class="special">/</span> <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;();</span>

   <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">j2_d</span> <span class="special">=</span>
      <span class="identifier">integral</span><span class="special">(</span><span class="number">0.0</span><span class="special">,</span>
      <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(),</span>
      <span class="number">0.0001</span><span class="special">,</span>
      <span class="identifier">cyl_bessel_j_integral_rep</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="number">2U</span><span class="special">,</span> <span class="number">1.23</span><span class="special">))</span> <span class="special">/</span> <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;();</span>

   <span class="keyword">const</span> <span class="identifier">mp_type</span> <span class="identifier">j2_mp</span> <span class="special">=</span>
      <span class="identifier">integral</span><span class="special">(</span><span class="identifier">mp_type</span><span class="special">(</span><span class="number">0</span><span class="special">),</span>
      <span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;(),</span>
      <span class="identifier">mp_type</span><span class="special">(</span><span class="number">1.0E-20</span><span class="special">),</span>
      <span class="identifier">cyl_bessel_j_integral_rep</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;(</span><span class="number">2U</span><span class="special">,</span> <span class="identifier">mp_type</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">))</span> <span class="special">/</span> <span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;();</span>

   <span class="comment">// 0.166369</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">j2_f</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 0.166369383786814</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">j2_d</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 0.16636938378681407351267852431513159437103348245333</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">j2_mp</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">//</span>
   <span class="comment">// Print true value for comparison:</span>
   <span class="comment">// 0.166369383786814073512678524315131594371033482453329</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="identifier">mp_type</span><span class="special">(</span><span class="number">123</span><span class="special">)</span> <span class="special">/</span> <span class="number">100</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="nd.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="poly_eg.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Defining a Special Function.</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="caveats.html" title="Drop-in Caveats">
<link rel="next" href="nd.html" title="Calculating a Derivative">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="caveats.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nd.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.jel"></a><a class="link" href="jel.html" title="Defining a Special Function.">Defining
          a Special Function.</a>
</h5></div></div></div>
<p>
            In this example we'll show several implementations of the <a href="http://mathworld.wolfram.com/LambdaFunction.html" target="_top">Jahnke
            and Emden Lambda function</a>, each implementation a little more
            sophisticated than the last.
          </p>
<p>
            The Jahnke-Emden Lambda function is defined by the equation:
          </p>
<div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>JahnkeEmden(v, z) = Γ(v+1) * J<sub>v</sub>(z) / (z / 2)<sup>v</sup></em></span>
            </p></blockquote></div>
<p>
            If we were to implement this at double precision using Boost.Math's facilities
            for the Gamma and Bessel function calls it would look like this:
          </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">JEL1</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">v</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">v</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            Calling this function as:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">JEL1</span><span class="special">(</span><span class="number">2.5</span><span class="special">,</span> <span class="number">0.5</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            Yields the output:
          </p>
<pre class="programlisting">9.822663964796047e-001</pre>
<p>
            Now let's implement the function again, but this time using the multiprecision
            type <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
            as the argument type:
          </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span>
   <span class="identifier">JEL2</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">v</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            The implementation is almost the same as before, but with one key difference
            - we can no longer call <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>,
            instead we must call the version inside the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span></code>
            namespace. In point of fact, we could have omitted the namespace prefix
            on the call to <code class="computeroutput"><span class="identifier">pow</span></code> since
            the right overload would have been found via <a href="http://en.wikipedia.org/wiki/Argument-dependent_name_lookup" target="_top">argument
            dependent lookup</a> in any case.
          </p>
<p>
            Note also that the first argument to <code class="computeroutput"><span class="identifier">pow</span></code>
            along with the argument to <code class="computeroutput"><span class="identifier">tgamma</span></code>
            in the above code are actually expression templates. The <code class="computeroutput"><span class="identifier">pow</span></code> and <code class="computeroutput"><span class="identifier">tgamma</span></code>
            functions will handle these arguments just fine.
          </p>
<p>
            Here's an example of how the function may be called:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">JEL2</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2.5</span><span class="special">),</span> <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">0.5</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            Which outputs:
          </p>
<pre class="programlisting">9.82266396479604757017335009796882833995903762577173e-01</pre>
<p>
            Now that we've seen some non-template examples, lets repeat the code
            again, but this time as a template that can be called either with a builtin
            type (<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code> etc), or with a multiprecision
            type:
          </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Float</span><span class="special">&gt;</span>
<span class="identifier">Float</span> <span class="identifier">JEL3</span><span class="special">(</span><span class="identifier">Float</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">Float</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">v</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            Once again the code is almost the same as before, but the call to <code class="computeroutput"><span class="identifier">pow</span></code> has changed yet again. We need
            the call to resolve to either <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>
            (when the argument is a builtin type), or to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">pow</span></code>
            (when the argument is a multiprecision type). We do that by making the
            call unqualified so that versions of <code class="computeroutput"><span class="identifier">pow</span></code>
            defined in the same namespace as type <code class="computeroutput"><span class="identifier">Float</span></code>
            are found via argument dependent lookup, while the <code class="computeroutput"><span class="keyword">using</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code> directive makes the standard library
            versions visible for builtin floating point types.
          </p>
<p>
            Let's call the function with both <code class="computeroutput"><span class="keyword">double</span></code>
            and multiprecision arguments:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">JEL3</span><span class="special">(</span><span class="number">2.5</span><span class="special">,</span> <span class="number">0.5</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">JEL3</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2.5</span><span class="special">),</span> <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">0.5</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            Which outputs:
          </p>
<pre class="programlisting">9.822663964796047e-001
9.82266396479604757017335009796882833995903762577173e-01
</pre>
<p>
            Unfortunately there is a problem with this version: if we were to call
            it like this:
          </p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">v</span><span class="special">(</span><span class="number">2</span><span class="special">),</span> <span class="identifier">z</span><span class="special">(</span><span class="number">0.5</span><span class="special">);</span>
<span class="identifier">JEL3</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">0.5</span><span class="special">,</span> <span class="identifier">z</span><span class="special">);</span>
</pre>
<p>
            Then we would get a long and inscrutable error message from the compiler:
            the problem here is that the first argument to <code class="computeroutput"><span class="identifier">JEL3</span></code>
            is not a number type, but an expression template. We could obviously
            add a typecast to fix the issue:
          </p>
<pre class="programlisting"><span class="identifier">JEL</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">0.5</span><span class="special">),</span> <span class="identifier">z</span><span class="special">);</span>
</pre>
<p>
            However, if we want the function JEL to be truly reusable, then a better
            solution might be preferred. To achieve this we can borrow some code
            from Boost.Math which calculates the return type of mixed-argument functions,
            here's how the new code looks now:
          </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Float1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Float2</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">Float1</span><span class="special">,</span> <span class="identifier">Float2</span><span class="special">&gt;::</span><span class="identifier">type</span>
   <span class="identifier">JEL4</span><span class="special">(</span><span class="identifier">Float1</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">Float2</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">v</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            As you can see the two arguments to the function are now separate template
            types, and the return type is computed using the <code class="computeroutput"><span class="identifier">promote_args</span></code>
            metafunction from Boost.Math.
          </p>
<p>
            Now we can call:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_100</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">JEL4</span><span class="special">(</span><span class="identifier">cpp_dec_float_100</span><span class="special">(</span><span class="number">2</span><span class="special">)</span> <span class="special">+</span> <span class="number">0.5</span><span class="special">,</span> <span class="identifier">cpp_dec_float_100</span><span class="special">(</span><span class="number">0.5</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            And get 100 digits of output:
          </p>
<pre class="programlisting">9.8226639647960475701733500979688283399590376257717309069410413822165082248153638454147004236848917775e-01</pre>
<p>
            As a bonus, we can now call the function not just with expression templates,
            but with other mixed types as well: for example <code class="computeroutput"><span class="keyword">float</span></code>
            and <code class="computeroutput"><span class="keyword">double</span></code> or <code class="computeroutput"><span class="keyword">int</span></code> and <code class="computeroutput"><span class="keyword">double</span></code>,
            and the correct return type will be computed in each case.
          </p>
<p>
            Note that while in this case we didn't have to change the body of the
            function, in the general case any function like this which creates local
            variables internally would have to use <code class="computeroutput"><span class="identifier">promote_args</span></code>
            to work out what type those variables should be, for example:
          </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Float1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Float2</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">Float1</span><span class="special">,</span> <span class="identifier">Float2</span><span class="special">&gt;::</span><span class="identifier">type</span>
   <span class="identifier">JEL5</span><span class="special">(</span><span class="identifier">Float1</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">Float2</span> <span class="identifier">z</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">promote_args</span><span class="special">&lt;</span><span class="identifier">Float1</span><span class="special">,</span> <span class="identifier">Float2</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">variable_type</span><span class="special">;</span>
   <span class="identifier">variable_type</span> <span class="identifier">t</span> <span class="special">=</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">z</span> <span class="special">/</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">v</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">t</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="caveats.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nd.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Calculating a Derivative</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="jel.html" title="Defining a Special Function.">
<link rel="next" href="gi.html" title="Calculating an Integral">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="jel.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gi.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.nd"></a><a class="link" href="nd.html" title="Calculating a Derivative">Calculating
          a Derivative</a>
</h5></div></div></div>
<p>
            In this example we'll add even more power to generic numeric programming
            using not only different floating-point types but also function objects
            as template parameters. Consider some well-known central difference rules
            for numerically computing the first derivative of a function <span class="emphasis"><em>f′(x)</em></span>
            with <span class="emphasis"><em>x ∈ ℜ</em></span>:
          </p>
<p>
            <span class="inlinemediaobject"><img src="../../../../../floating_point_eg1.svg"></span>
          </p>
<p>
            Where the difference terms <span class="emphasis"><em>m<sub>n</sub></em></span> are given by:
          </p>
<p>
            <span class="inlinemediaobject"><img src="../../../../../floating_point_eg2.svg"></span>
          </p>
<p>
            and <span class="emphasis"><em>dx</em></span> is the step-size of the derivative.
          </p>
<p>
            The third formula in Equation 1 is a three-point central difference rule.
            It calculates the first derivative of <span class="emphasis"><em>f′(x)</em></span> to <span class="emphasis"><em>O(dx<sup>6</sup>)</em></span>,
            where <span class="emphasis"><em>dx</em></span> is the given step-size. For example, if
            the step-size is 0.01 this derivative calculation has about 6 decimal
            digits of precision - just about right for the 7 decimal digits of single-precision
            float. Let's make a generic template subroutine using this three-point
            central difference rule. In particular:
          </p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">function_type</span><span class="special">&gt;</span>
   <span class="identifier">value_type</span> <span class="identifier">derivative</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dx</span><span class="special">,</span> <span class="identifier">function_type</span> <span class="identifier">func</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">// Compute d/dx[func(*first)] using a three-point</span>
   <span class="comment">// central difference rule of O(dx^6).</span>

   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dx1</span> <span class="special">=</span> <span class="identifier">dx</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dx2</span> <span class="special">=</span> <span class="identifier">dx1</span> <span class="special">*</span> <span class="number">2</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dx3</span> <span class="special">=</span> <span class="identifier">dx1</span> <span class="special">*</span> <span class="number">3</span><span class="special">;</span>

   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">m1</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="identifier">dx1</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="identifier">dx1</span><span class="special">))</span> <span class="special">/</span> <span class="number">2</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">m2</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="identifier">dx2</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="identifier">dx2</span><span class="special">))</span> <span class="special">/</span> <span class="number">4</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">m3</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="identifier">dx3</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">func</span><span class="special">(</span><span class="identifier">x</span> <span class="special">-</span> <span class="identifier">dx3</span><span class="special">))</span> <span class="special">/</span> <span class="number">6</span><span class="special">;</span>

   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">fifteen_m1</span> <span class="special">=</span> <span class="number">15</span> <span class="special">*</span> <span class="identifier">m1</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">six_m2</span>     <span class="special">=</span>  <span class="number">6</span> <span class="special">*</span> <span class="identifier">m2</span><span class="special">;</span>
   <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">ten_dx1</span>    <span class="special">=</span> <span class="number">10</span> <span class="special">*</span> <span class="identifier">dx1</span><span class="special">;</span>

   <span class="keyword">return</span> <span class="special">((</span><span class="identifier">fifteen_m1</span> <span class="special">-</span> <span class="identifier">six_m2</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">m3</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">ten_dx1</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            The <code class="computeroutput"><span class="identifier">derivative</span><span class="special">()</span></code>
            template function can be used to compute the first derivative of any
            function to <span class="emphasis"><em>O(dx<sup>6</sup>)</em></span>. For example, consider the first
            derivative of <span class="emphasis"><em>sin(x)</em></span> evaluated at <span class="emphasis"><em>x =
            π/3</em></span>. In other words,
          </p>
<p>
            <span class="inlinemediaobject"><img src="../../../../../floating_point_eg3.svg"></span>
          </p>
<p>
            The code below computes the derivative in Equation 3 for float, double
            and boost's multiple-precision type cpp_dec_float_50.
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">constants</span><span class="special">/</span><span class="identifier">constants</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>


<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">**)</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// We'll pass a function pointer for the function object passed to derivative,</span>
   <span class="comment">// the typecast is needed to select the correct overload of std::sin:</span>
   <span class="comment">//</span>
   <span class="keyword">const</span> <span class="keyword">float</span> <span class="identifier">d_f</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>
      <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;()</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span>
      <span class="number">0.01F</span><span class="special">,</span>
      <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">(*)(</span><span class="keyword">float</span><span class="special">)&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span><span class="special">)</span>
   <span class="special">);</span>

   <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">d_d</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>
      <span class="identifier">pi</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;()</span> <span class="special">/</span> <span class="number">3</span><span class="special">,</span>
      <span class="number">0.001</span><span class="special">,</span>
      <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">(*)(</span><span class="keyword">double</span><span class="special">)&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">sin</span><span class="special">)</span>
      <span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// In the cpp_dec_float_50 case, the sin function is multiply overloaded</span>
   <span class="comment">// to handle expression templates etc.  As a result it's hard to take its</span>
   <span class="comment">// address without knowing about its implementation details.  We'll use a </span>
   <span class="comment">// C++11 lambda expression to capture the call.</span>
   <span class="comment">// We also need a typecast on the first argument so we don't accidentally pass</span>
   <span class="comment">// an expression template to a template function:</span>
   <span class="comment">//</span>
   <span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span> <span class="identifier">d_mp</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>
      <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;()</span> <span class="special">/</span> <span class="number">3</span><span class="special">),</span>
      <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">1.0E-9</span><span class="special">),</span>
      <span class="special">[](</span><span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">-&gt;</span> <span class="identifier">cpp_dec_float_50</span>
      <span class="special">{</span>
         <span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
      <span class="special">}</span>
      <span class="special">);</span>

   <span class="comment">// 5.000029e-001</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">d_f</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 4.999999999998876e-001</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">d_d</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// 4.99999999999999999999999999999999999999999999999999e-01</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">d_mp</span>
      <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            The expected value of the derivative is 0.5. This central difference
            rule in this example is ill-conditioned, meaning it suffers from slight
            loss of precision. With that in mind, the results agree with the expected
            value of 0.5.
          </p>
<p>
            We can take this a step further and use our derivative function to compute
            a partial derivative. For example if we take the incomplete gamma function
            <span class="emphasis"><em>P(a, z)</em></span>, and take the derivative with respect to
            <span class="emphasis"><em>z</em></span> at <span class="emphasis"><em>(2,2)</em></span> then we can calculate
            the result as shown below, for good measure we'll compare with the "correct"
            result obtained from a call to <span class="emphasis"><em>gamma_p_derivative</em></span>,
            the results agree to approximately 44 digits:
          </p>
<pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">gd</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>
   <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">),</span>
   <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">1.0E-9</span><span class="special">),</span>
   <span class="special">[](</span><span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">-&gt;</span><span class="identifier">cpp_dec_float_50</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gamma_p</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">);</span>
<span class="comment">// 2.70670566473225383787998989944968806815263091819151e-01</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">gd</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// 2.70670566473225383787998989944968806815253190143120e-01</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">gamma_p_derivative</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">),</span> <span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="number">2</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="jel.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gi.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/poly_eg.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Polynomial Evaluation</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="gi.html" title="Calculating an Integral">
<link rel="next" href="variable_precision.html" title="Variable-Precision Newton Evaluation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gi.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="variable_precision.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.poly_eg"></a><a class="link" href="poly_eg.html" title="Polynomial Evaluation">Polynomial
          Evaluation</a>
</h5></div></div></div>
<p>
            In this example we'll look at polynomial evaluation, this is not only
            an important use case, but it's one that <code class="computeroutput"><span class="identifier">number</span></code>
            performs particularly well at because the expression templates <span class="emphasis"><em>completely
            eliminate all temporaries</em></span> from a <a href="http://en.wikipedia.org/wiki/Horner%27s_method" target="_top">Horner
            polynomial evaluation scheme</a>.
          </p>
<p>
            The following code evaluates <code class="computeroutput"><span class="identifier">sin</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> as a polynomial, accurate to at least
            64 decimal places:
          </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">64</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">mp_type</span><span class="special">;</span>

<span class="identifier">mp_type</span> <span class="identifier">mysin</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mp_type</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// Approximation of sin(x * pi/2) for -1 &lt;= x &lt;= 1, using an order 63 polynomial.</span>
  <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">,</span> <span class="number">32U</span><span class="special">&gt;</span> <span class="identifier">coefs</span> <span class="special">=</span>
  <span class="special">{{</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+1.5707963267948966192313216916397514420985846996875529104874722961539082031431044993140174126711"</span><span class="special">),</span> <span class="comment">//"),</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-0.64596409750624625365575656389794573337969351178927307696134454382929989411386887578263960484"</span><span class="special">),</span> <span class="comment">// ^3</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+0.07969262624616704512050554949047802252091164235106119545663865720995702920146198554317279"</span><span class="special">),</span> <span class="comment">// ^5</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-0.0046817541353186881006854639339534378594950280185010575749538605102665157913157426229824"</span><span class="special">),</span> <span class="comment">// ^7</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+0.00016044118478735982187266087016347332970280754062061156858775174056686380286868007443"</span><span class="special">),</span> <span class="comment">// ^9</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-3.598843235212085340458540018208389404888495232432127661083907575106196374913134E-6"</span><span class="special">),</span> <span class="comment">// ^11</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+5.692172921967926811775255303592184372902829756054598109818158853197797542565E-8"</span><span class="special">),</span> <span class="comment">// ^13</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-6.688035109811467232478226335783138689956270985704278659373558497256423498E-10"</span><span class="special">),</span> <span class="comment">// ^15</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+6.066935731106195667101445665327140070166203261129845646380005577490472E-12"</span><span class="special">),</span> <span class="comment">// ^17</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-4.377065467313742277184271313776319094862897030084226361576452003432E-14"</span><span class="special">),</span> <span class="comment">// ^19</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+2.571422892860473866153865950420487369167895373255729246889168337E-16"</span><span class="special">),</span> <span class="comment">// ^21</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-1.253899540535457665340073300390626396596970180355253776711660E-18"</span><span class="special">),</span> <span class="comment">// ^23</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+5.15645517658028233395375998562329055050964428219501277474E-21"</span><span class="special">),</span> <span class="comment">// ^25</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-1.812399312848887477410034071087545686586497030654642705E-23"</span><span class="special">),</span> <span class="comment">// ^27</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+5.50728578652238583570585513920522536675023562254864E-26"</span><span class="special">),</span> <span class="comment">// ^29</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-1.461148710664467988723468673933026649943084902958E-28"</span><span class="special">),</span> <span class="comment">// ^31</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+3.41405297003316172502972039913417222912445427E-31"</span><span class="special">),</span> <span class="comment">// ^33</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-7.07885550810745570069916712806856538290251E-34"</span><span class="special">),</span> <span class="comment">// ^35</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+1.31128947968267628970845439024155655665E-36"</span><span class="special">),</span> <span class="comment">// ^37</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-2.18318293181145698535113946654065918E-39"</span><span class="special">),</span> <span class="comment">// ^39</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+3.28462680978498856345937578502923E-42"</span><span class="special">),</span> <span class="comment">// ^41</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-4.48753699028101089490067137298E-45"</span><span class="special">),</span> <span class="comment">// ^43</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+5.59219884208696457859353716E-48"</span><span class="special">),</span> <span class="comment">// ^45</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-6.38214503973500471720565E-51"</span><span class="special">),</span> <span class="comment">// ^47</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+6.69528558381794452556E-54"</span><span class="special">),</span> <span class="comment">// ^49</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-6.47841373182350206E-57"</span><span class="special">),</span> <span class="comment">// ^51</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+5.800016389666445E-60"</span><span class="special">),</span> <span class="comment">// ^53</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-4.818507347289E-63"</span><span class="special">),</span> <span class="comment">// ^55</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+3.724683686E-66"</span><span class="special">),</span> <span class="comment">// ^57</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-2.6856479E-69"</span><span class="special">),</span> <span class="comment">// ^59</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"+1.81046E-72"</span><span class="special">),</span> <span class="comment">// ^61</span>
    <span class="identifier">mp_type</span><span class="special">(</span><span class="string">"-1.133E-75"</span><span class="special">),</span> <span class="comment">// ^63</span>
  <span class="special">}};</span>

  <span class="keyword">const</span> <span class="identifier">mp_type</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span> <span class="special">*</span> <span class="number">2</span> <span class="special">/</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;();</span>
  <span class="keyword">const</span> <span class="identifier">mp_type</span> <span class="identifier">x2</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">v</span> <span class="special">*</span> <span class="identifier">v</span><span class="special">);</span>
  <span class="comment">//</span>
  <span class="comment">// Polynomial evaluation follows, if mp_type allocates memory then</span>
  <span class="comment">// just one such allocation occurs - to initialize the variable "sum" -</span>
  <span class="comment">// and no temporaries are created at all.</span>
  <span class="comment">//</span>
  <span class="keyword">const</span> <span class="identifier">mp_type</span> <span class="identifier">sum</span> <span class="special">=</span> <span class="special">(((((((((((((((((((((((((((((((</span>     <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">31U</span><span class="special">]</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">30U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">29U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">28U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">27U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">26U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">25U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">24U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">23U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">22U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">21U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">20U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">19U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">18U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">17U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">16U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">15U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">14U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">13U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">12U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">11U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">10U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">9U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">8U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">7U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">6U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">5U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">4U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">3U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">2U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">1U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">x2</span> <span class="special">+</span> <span class="identifier">coefs</span><span class="special">[</span><span class="number">0U</span><span class="special">])</span>
                                                     <span class="special">*</span> <span class="identifier">v</span><span class="special">;</span>

  <span class="keyword">return</span> <span class="identifier">sum</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            Calling the function like so:
          </p>
<pre class="programlisting"><span class="identifier">mp_type</span> <span class="identifier">pid4</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_type</span><span class="special">&gt;()</span> <span class="special">/</span> <span class="number">4</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">mp_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">mysin</span><span class="special">(</span><span class="identifier">pid4</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            Yields the expected output:
          </p>
<pre class="programlisting">7.0710678118654752440084436210484903928483593768847403658833986900e-01</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gi.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="variable_precision.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg/variable_precision.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Variable-Precision Newton Evaluation</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../fp_eg.html" title="Examples">
<link rel="prev" href="poly_eg.html" title="Polynomial Evaluation">
<link rel="next" href="gauss_lagerre_quadrature.html" title="Gauss-Laguerre quadrature">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="poly_eg.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gauss_lagerre_quadrature.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg.variable_precision"></a><a class="link" href="variable_precision.html" title="Variable-Precision Newton Evaluation">Variable-Precision
          Newton Evaluation</a>
</h5></div></div></div>
<p>
            This example illustrates the use of variable-precision arithmetic with
            the <code class="computeroutput"><span class="identifier">mpfr_float</span></code> number
            type. We'll calculate the median of the beta distribution to an absurdly
            high precision and compare the accuracy and times taken for various methods.
            That is, we want to calculate the value of <code class="computeroutput"><span class="identifier">x</span></code>
            for which <span class="emphasis"><em>I<sub>x</sub>(a, b) = 0.5</em></span>.
          </p>
<p>
            Ultimately we'll use Newtons method and set the precision of mpfr_float
            to have just enough digits at each iteration.
          </p>
<p>
            The full source of the this program is in <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../example/mpfr_precision.cpp" target="_top">../../example/mpfr_precision.cpp</a>
          </p>
<p>
            We'll skip over the #includes and using declations, and go straight to
            some support code, first off a simple stopwatch for performance measurement:
          </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">clock_type</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">stopwatch</span> <span class="special">{</span> <span class="comment">/*details \*/</span> <span class="special">};</span>
</pre>
<p>
            We'll use <code class="computeroutput"><span class="identifier">stopwatch</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">chono</span><span class="special">::</span><span class="identifier">high_resolution_clock</span><span class="special">&gt;</span></code>
            as our performance measuring device.
          </p>
<p>
            We also have a small utility class for controlling the current precision
            of mpfr_float:
          </p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">scoped_precision</span>
<span class="special">{</span>
   <span class="keyword">unsigned</span> <span class="identifier">p</span><span class="special">;</span>
   <span class="identifier">scoped_precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">new_p</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">())</span>
   <span class="special">{</span>
      <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="identifier">new_p</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="special">~</span><span class="identifier">scoped_precision</span><span class="special">()</span>
   <span class="special">{</span>
      <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
            We'll begin with a reference method that simply calls the Boost.Math
            function <code class="computeroutput"><span class="identifier">ibeta_inv</span></code> and
            uses the full working precision of the arguments throughout. Our reference
            function takes 3 arguments:
          </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
                The 2 parameters <code class="computeroutput"><span class="identifier">a</span></code>
                and <code class="computeroutput"><span class="identifier">b</span></code> of the beta
                distribution, and
              </li>
<li class="listitem">
                The number of decimal digits precision to achieve in the result.
              </li>
</ul></div>
<p>
            We begin by setting the default working precision to that requested,
            and then, since we don't know where our arguments <code class="computeroutput"><span class="identifier">a</span></code>
            and <code class="computeroutput"><span class="identifier">b</span></code> have been or what
            precision they have, we make a copy of them - note that since copying
            also copies the precision as well as the value, we have to set the precision
            expicitly with a second argument to the copy. Then we can simply return
            the result of <code class="computeroutput"><span class="identifier">ibeta_inv</span></code>:
          </p>
<pre class="programlisting"><span class="identifier">mpfr_float</span> <span class="identifier">beta_distribution_median_method_1</span><span class="special">(</span><span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a_</span><span class="special">,</span> <span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b_</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">scoped_precision</span> <span class="identifier">sp</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">half</span><span class="special">(</span><span class="number">0.5</span><span class="special">),</span> <span class="identifier">a</span><span class="special">(</span><span class="identifier">a_</span><span class="special">,</span> <span class="identifier">digits10</span><span class="special">),</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">b_</span><span class="special">,</span> <span class="identifier">digits10</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="identifier">ibeta_inv</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">half</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            You be wondering why we needed to change the precision of our variables
            <code class="computeroutput"><span class="identifier">a</span></code> and <code class="computeroutput"><span class="identifier">b</span></code>
            as well as setting the default - there are in fact two ways in which
            this can go wrong if we don't do that:
          </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
                The variables have too much precision - this will cause all arithmetic
                operations involving those types to be promoted to the higher precision
                wasting precious calculation time.
              </li>
<li class="listitem">
                The variables have too little precision - this will cause expressions
                involving only those variables to be calculated at the lower precision
                - for example if we calculate <code class="computeroutput"><span class="identifier">exp</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> internally, this will be evaluated
                at the precision of <code class="computeroutput"><span class="identifier">a</span></code>,
                and not the current default.
              </li>
</ul></div>
<p>
            Since our reference method carries out all calculations at the full precision
            requested, an obvious refinement would be to calculate a first approximation
            to <code class="computeroutput"><span class="keyword">double</span></code> precision and
            then to use Newton steps to refine it further.
          </p>
<p>
            Our function begins the same as before: set the new default precision
            and then make copies of our arguments at the correct precision. We then
            call <code class="computeroutput"><span class="identifier">ibeta_inv</span></code> with all
            double precision arguments, promote the result to an <code class="computeroutput"><span class="identifier">mpfr_float</span></code>
            and perform Newton steps to obtain the result. Note that our termination
            condition is somewhat crude: we simply assume that we have approximately
            14 digits correct from the double-precision approximation and that the
            precision doubles with each step. We also cheat, and use an internal
            Boost.Math function that calculates <span class="emphasis"><em>I<sub>x</sub>(a, b)</em></span> and
            its derivative in one go:
          </p>
<pre class="programlisting"><span class="identifier">mpfr_float</span> <span class="identifier">beta_distribution_median_method_2</span><span class="special">(</span><span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a_</span><span class="special">,</span> <span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b_</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">scoped_precision</span> <span class="identifier">sp</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">half</span><span class="special">(</span><span class="number">0.5</span><span class="special">),</span> <span class="identifier">a</span><span class="special">(</span><span class="identifier">a_</span><span class="special">,</span> <span class="identifier">digits10</span><span class="special">),</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">b_</span><span class="special">,</span> <span class="identifier">digits10</span><span class="special">);</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">guess</span> <span class="special">=</span> <span class="identifier">ibeta_inv</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">a</span><span class="special">,</span> <span class="special">(</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">b</span><span class="special">,</span> <span class="number">0.5</span><span class="special">);</span>
   <span class="keyword">unsigned</span> <span class="identifier">current_digits</span> <span class="special">=</span> <span class="number">14</span><span class="special">;</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">f1</span><span class="special">;</span>
   <span class="keyword">while</span> <span class="special">(</span><span class="identifier">current_digits</span> <span class="special">&lt;</span> <span class="identifier">digits10</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">ibeta_imp</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">guess</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">policy</span><span class="special">&lt;&gt;(),</span> <span class="keyword">false</span><span class="special">,</span> <span class="keyword">true</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">f1</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">half</span><span class="special">;</span>
      <span class="identifier">guess</span> <span class="special">-=</span> <span class="identifier">f</span> <span class="special">/</span> <span class="identifier">f1</span><span class="special">;</span>
      <span class="identifier">current_digits</span> <span class="special">*=</span> <span class="number">2</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">return</span> <span class="identifier">guess</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            Before we refine the method further, it might be wise to take stock and
            see how methods 1 and 2 compare. We'll ask them both for 1500 digit precision,
            and compare against the value produced by <code class="computeroutput"><span class="identifier">ibeta_inv</span></code>
            at 1700 digits. Here's what the results look like:
          </p>
<pre class="programlisting">Method 1 time = 0.611647
Relative error: 2.99991e-1501
Method 2 time = 0.646746
Relative error: 7.55843e-1501
</pre>
<p>
            Clearly they are both equally accurate, but Method 1 is actually faster
            and our plan for improved performance hasn't actually worked. It turns
            out that we're not actually comparing like with like, because <code class="computeroutput"><span class="identifier">ibeta_inv</span></code> uses Halley iteration internally
            which churns out more digits of precision rather more rapidly than Newton
            iteration. So the time we save by refining an initial <code class="computeroutput"><span class="keyword">double</span></code>
            approximation, then loose it again by taking more iterations to get to
            the result.
          </p>
<p>
            Time for a more refined approach. It follows the same form as Method
            2, but now we set the working precision within the Newton iteration loop,
            to just enough digits to cover the expected precision at each step. That
            means we also create new copies of our arguments at the correct precision
            within the loop, and likewise change the precision of the current <code class="computeroutput"><span class="identifier">guess</span></code> each time through:
          </p>
<pre class="programlisting"><span class="identifier">mpfr_float</span> <span class="identifier">beta_distribution_median_method_3</span><span class="special">(</span><span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a_</span><span class="special">,</span> <span class="identifier">mpfr_float</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">b_</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">guess</span> <span class="special">=</span> <span class="identifier">ibeta_inv</span><span class="special">((</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">a_</span><span class="special">,</span> <span class="special">(</span><span class="keyword">double</span><span class="special">)</span><span class="identifier">b_</span><span class="special">,</span> <span class="number">0.5</span><span class="special">);</span>
   <span class="keyword">unsigned</span> <span class="identifier">current_digits</span> <span class="special">=</span> <span class="number">14</span><span class="special">;</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">f</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">current_digits</span><span class="special">),</span> <span class="identifier">f1</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">current_digits</span><span class="special">),</span> <span class="identifier">delta</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
   <span class="keyword">while</span> <span class="special">(</span><span class="identifier">current_digits</span> <span class="special">&lt;</span> <span class="identifier">digits10</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">current_digits</span> <span class="special">*=</span> <span class="number">2</span><span class="special">;</span>
      <span class="identifier">scoped_precision</span> <span class="identifier">sp</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">min</span><span class="special">)(</span><span class="identifier">current_digits</span><span class="special">,</span> <span class="identifier">digits10</span><span class="special">));</span>
      <span class="identifier">mpfr_float</span> <span class="identifier">a</span><span class="special">(</span><span class="identifier">a_</span><span class="special">,</span> <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">()),</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">b_</span><span class="special">,</span> <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">());</span>
      <span class="identifier">guess</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">());</span>
      <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">ibeta_imp</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">guess</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">policy</span><span class="special">&lt;&gt;(),</span> <span class="keyword">false</span><span class="special">,</span> <span class="keyword">true</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">f1</span><span class="special">)</span> <span class="special">-</span> <span class="number">0.5f</span><span class="special">;</span>
      <span class="identifier">guess</span> <span class="special">-=</span> <span class="identifier">f</span> <span class="special">/</span> <span class="identifier">f1</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">return</span> <span class="identifier">guess</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            The new performance results look much more promising:
          </p>
<pre class="programlisting">Method 1 time = 0.591244
Relative error: 2.99991e-1501
Method 2 time = 0.622679
Relative error: 7.55843e-1501
Method 3 time = 0.143393
Relative error: 4.03898e-1501
</pre>
<p>
            This time we're 4x faster than <code class="computeroutput"><span class="identifier">ibeta_inv</span></code>,
            and no doubt that could be improved a little more by carefully optimising
            the number of iterations and the method (Halley vs Newton) taken.
          </p>
<p>
            Finally, here's the driver code for the above methods:
          </p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">try</span> <span class="special">{</span>
      <span class="identifier">mpfr_float</span> <span class="identifier">a</span><span class="special">(</span><span class="number">10</span><span class="special">),</span> <span class="identifier">b</span><span class="special">(</span><span class="number">20</span><span class="special">);</span>

      <span class="identifier">mpfr_float</span> <span class="identifier">true_value</span> <span class="special">=</span> <span class="identifier">beta_distribution_median_method_1</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="number">1700</span><span class="special">);</span>

      <span class="identifier">stopwatch</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">high_resolution_clock</span><span class="special">&gt;</span> <span class="identifier">my_stopwatch</span><span class="special">;</span>

      <span class="identifier">mpfr_float</span> <span class="identifier">v1</span> <span class="special">=</span> <span class="identifier">beta_distribution_median_method_1</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="number">1500</span><span class="special">);</span>
      <span class="keyword">float</span> <span class="identifier">hp_time</span> <span class="special">=</span> <span class="identifier">my_stopwatch</span><span class="special">.</span><span class="identifier">elapsed</span><span class="special">();</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Method 1 time = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">hp_time</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Relative error: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">relative_difference</span><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">true_value</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

      <span class="identifier">my_stopwatch</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
      <span class="identifier">mpfr_float</span> <span class="identifier">v2</span> <span class="special">=</span> <span class="identifier">beta_distribution_median_method_2</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="number">1500</span><span class="special">);</span>
      <span class="identifier">hp_time</span> <span class="special">=</span> <span class="identifier">my_stopwatch</span><span class="special">.</span><span class="identifier">elapsed</span><span class="special">();</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Method 2 time = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">hp_time</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Relative error: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">relative_difference</span><span class="special">(</span><span class="identifier">v2</span><span class="special">,</span> <span class="identifier">true_value</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

      <span class="identifier">my_stopwatch</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
      <span class="identifier">mpfr_float</span> <span class="identifier">v3</span> <span class="special">=</span> <span class="identifier">beta_distribution_median_method_3</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">,</span> <span class="number">1500</span><span class="special">);</span>
      <span class="identifier">hp_time</span> <span class="special">=</span> <span class="identifier">my_stopwatch</span><span class="special">.</span><span class="identifier">elapsed</span><span class="special">();</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Method 3 time = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">hp_time</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Relative error: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">relative_difference</span><span class="special">(</span><span class="identifier">v3</span><span class="special">,</span> <span class="identifier">true_value</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Found exception with message: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="poly_eg.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../fp_eg.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gauss_lagerre_quadrature.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/fp_eg.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Examples</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="float128.html" title="float128">
<link rel="next" href="fp_eg/floatbuiltinctor.html" title="Construction from Specific Values Without Precision Loss">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="float128.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg/floatbuiltinctor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.fp_eg"></a><a class="link" href="fp_eg.html" title="Examples">Examples</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="fp_eg/floatbuiltinctor.html">Construction
          from Specific Values Without Precision Loss</a></span></dt>
<dt><span class="section"><a href="fp_eg/aos.html">Area of
          Circle</a></span></dt>
<dt><span class="section"><a href="fp_eg/caveats.html">Drop-in
          Caveats</a></span></dt>
<dt><span class="section"><a href="fp_eg/jel.html">Defining
          a Special Function.</a></span></dt>
<dt><span class="section"><a href="fp_eg/nd.html">Calculating
          a Derivative</a></span></dt>
<dt><span class="section"><a href="fp_eg/gi.html">Calculating
          an Integral</a></span></dt>
<dt><span class="section"><a href="fp_eg/poly_eg.html">Polynomial
          Evaluation</a></span></dt>
<dt><span class="section"><a href="fp_eg/variable_precision.html">Variable-Precision
          Newton Evaluation</a></span></dt>
<dt><span class="section"><a href="fp_eg/gauss_lagerre_quadrature.html">Gauss-Laguerre
          quadrature</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="float128.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg/floatbuiltinctor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/gmp_float.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>gmp_float</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="cpp_dec_float.html" title="cpp_dec_float">
<link rel="next" href="mpfr_float.html" title="mpfr_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_dec_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.gmp_float"></a><a class="link" href="gmp_float.html" title="gmp_float">gmp_float</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">gmp_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpf_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpf_float_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpf_float_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpf_float_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpf_float</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">gmp_float</span></code> back-end
          is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>
          : it acts as a thin wrapper around the <a href="http://gmplib.org" target="_top">GMP</a>
          <code class="computeroutput"><span class="identifier">mpf_t</span></code> to provide an real-number
          type that is a drop-in replacement for the native C++ floating-point types,
          but with much greater precision.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">gmp_float</span></code> can be used
          at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits10</span></code>
          template parameter, or at variable precision by setting the template argument
          to zero. The typedefs mpf_float_50, mpf_float_100, mpf_float_500, mpf_float_1000
          provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
          respectively. The typedef mpf_float provides a variable precision type
          whose precision can be controlled via the <code class="computeroutput"><span class="identifier">number</span></code>s
          member functions.
        </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            This type only provides standard library and <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
            support when the precision is fixed at compile time.
          </p></td></tr>
</table></div>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpf_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> are copy constructible and assignable
          from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://gmplib.org" target="_top">GMP</a> native types <code class="computeroutput"><span class="identifier">mpf_t</span></code>, <code class="computeroutput"><span class="identifier">mpz_t</span></code>,
              <code class="computeroutput"><span class="identifier">mpq_t</span></code>.
            </li>
<li class="listitem">
              The <code class="computeroutput"><span class="identifier">number</span></code> wrappers
              around those types: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpf_float</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
              <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span><span class="special">&gt;</span></code>,
              <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpf_t</span></code>
          via the <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">gmp_float</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">gmp_float</span></code>s
              have the value zero (this is the <a href="http://gmplib.org" target="_top">GMP</a>
              library's default behavior).
            </li>
<li class="listitem">
              No changes are made to the <a href="http://gmplib.org" target="_top">GMP</a>
              library's global settings, so this type can be safely mixed with existing
              <a href="http://gmplib.org" target="_top">GMP</a> code.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              It is not possible to round-trip objects of this type to and from a
              string and get back exactly the same value. This appears to be a limitation
              of <a href="http://gmplib.org" target="_top">GMP</a>.
            </li>
<li class="listitem">
              Since the underlying <a href="http://gmplib.org" target="_top">GMP</a> types
              have no notion of infinities or NaNs, care should be taken to avoid
              numeric overflow or division by zero. That latter will result in a
              std::overflow_error being thrown, while generating excessively large
              exponents may result in instability of the underlying <a href="http://gmplib.org" target="_top">GMP</a>
              library (in testing, converting a number with an excessively large
              or small exponent to a string caused <a href="http://gmplib.org" target="_top">GMP</a>
              to segfault).
            </li>
<li class="listitem">
              This type can equally be used with <a href="http://mpir.org/" target="_top">MPIR</a>
              as the underlying implementation - indeed that is the recommended option
              on Win32.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.gmp_float.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.gmp_float.gmp_example"></a></span><a class="link" href="gmp_float.html#boost_multiprecision.tut.floats.gmp_float.gmp_example"> GMP example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="comment">// Operations at variable precision and limited standard library support:</span>
   <span class="identifier">mpf_float</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">mpf_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="number">1000</span><span class="special">);</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">mpf_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print root-2</span>

   <span class="comment">// Operations at fixed precision and full standard library support:</span>
   <span class="identifier">mpf_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">mpf_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// We can use any C++ std lib function:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>
   <span class="comment">// We can also use any function from Boost.Math:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// These even work when the argument is an expression template:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// Access the underlying representation:</span>
   <span class="identifier">mpf_t</span> <span class="identifier">f</span><span class="special">;</span>
   <span class="identifier">mpf_init</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
   <span class="identifier">mpf_set</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
   <span class="identifier">mpf_clear</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_dec_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats/mpfr_float.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>mpfr_float</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="gmp_float.html" title="gmp_float">
<link rel="next" href="float128.html" title="float128">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="float128.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.mpfr_float"></a><a class="link" href="mpfr_float.html" title="mpfr_float">mpfr_float</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">enum</span> <span class="identifier">mpfr_allocation_type</span>
<span class="special">{</span>
   <span class="identifier">allocate_stack</span><span class="special">,</span>
   <span class="identifier">allocate_dynamic</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">mpfr_allocation_type</span> <span class="identifier">AllocateType</span> <span class="special">=</span> <span class="identifier">allocate_dynamic</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">mpfr_float_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpfr_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfr_float_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfr_float_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpfr_float_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpfr_float</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="identifier">allocate_stack</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">static_mpfr_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">100</span><span class="special">,</span> <span class="identifier">allocate_stack</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">static_mpfr_float_100</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>
          type is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as a thin wrapper around the <a href="http://www.mpfr.org" target="_top">MPFR</a>
          <code class="computeroutput"><span class="identifier">mpfr_t</span></code> to provide an real-number
          type that is a drop-in replacement for the native C++ floating-point types,
          but with much greater precision.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>
          can be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits10</span></code>
          template parameter, or at variable precision by setting the template argument
          to zero. The typedefs mpfr_float_50, mpfr_float_100, mpfr_float_500, mpfr_float_1000
          provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
          respectively. The typedef mpfr_float provides a variable precision type
          whose precision can be controlled via the <code class="computeroutput"><span class="identifier">number</span></code>s
          member functions.
        </p>
<p>
          In addition the second template parameter lets you choose between dynamic
          allocation (the default, and uses MPFR's normal allocation routines), or
          stack allocation (where all the memory required for the underlying data
          types is stored within <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>).
          The latter option can result in significantly faster code, at the expense
          of growing the size of <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>.
          It can only be used at <span class="emphasis"><em>fixed precision</em></span>, and should
          only be used for lower digit counts. Note that we can not guarantee that
          using <code class="computeroutput"><span class="identifier">allocate_stack</span></code> won't
          cause any calls to <code class="computeroutput"><span class="identifier">mpfr</span></code>'s
          allocation routines, as <code class="computeroutput"><span class="identifier">mpfr</span></code>
          may call these inside its own code. The following table gives an idea of
          the performance tradeoff's at 50 decimal digits precision<a href="#ftn.boost_multiprecision.tut.floats.mpfr_float.f0" class="footnote" name="boost_multiprecision.tut.floats.mpfr_float.f0"><sup class="footnote">[2]</sup></a>:
        </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    Type
                  </p>
                </th>
<th>
                  <p>
                    Bessel function evaluation, relative times
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="identifier">allocate_static</span><span class="special">&gt;,</span>
                    <span class="identifier">et_on</span><span class="special">&gt;</span></code>
                  </p>
                </td>
<td>
                  <p>
                    1.0 (5.5s)
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="identifier">allocate_static</span><span class="special">&gt;,</span>
                    <span class="identifier">et_off</span><span class="special">&gt;</span></code>
                  </p>
                </td>
<td>
                  <p>
                    1.05 (5.8s)
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="identifier">allocate_dynamic</span><span class="special">&gt;,</span>
                    <span class="identifier">et_on</span><span class="special">&gt;</span></code>
                  </p>
                </td>
<td>
                  <p>
                    1.05 (5.8s)
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">,</span> <span class="identifier">allocate_dynamic</span><span class="special">&gt;,</span>
                    <span class="identifier">et_off</span><span class="special">&gt;</span></code>
                  </p>
                </td>
<td>
                  <p>
                    1.16 (6.4s)
                  </p>
                </td>
</tr>
</tbody>
</table></div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            This type only provides <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
            support when the precision is fixed at compile time.
          </p></td></tr>
</table></div>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> are copy constructible and assignable
          from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://gmplib.org" target="_top">GMP</a> native types <code class="computeroutput"><span class="identifier">mpf_t</span></code>, <code class="computeroutput"><span class="identifier">mpz_t</span></code>,
              <code class="computeroutput"><span class="identifier">mpq_t</span></code>.
            </li>
<li class="listitem">
              The <a href="http://www.mpfr.org" target="_top">MPFR</a> native type <code class="computeroutput"><span class="identifier">mpfr_t</span></code>.
            </li>
<li class="listitem">
              The <code class="computeroutput"><span class="identifier">number</span></code> wrappers
              around those types: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
              <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpf_float</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span><span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpfr_t</span></code>
          via the data() member function of <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              A default constructed <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>
              is set to zero (<span class="emphasis"><em>Note that this is <span class="bold"><strong>not</strong></span>
              the default <a href="http://www.mpfr.org" target="_top">MPFR</a> behavior</em></span>).
            </li>
<li class="listitem">
              All operations use round to nearest.
            </li>
<li class="listitem">
              No changes are made to <a href="http://gmplib.org" target="_top">GMP</a> or
              <a href="http://www.mpfr.org" target="_top">MPFR</a> global settings, so this
              type can coexist with existing <a href="http://www.mpfr.org" target="_top">MPFR</a>
              or <a href="http://gmplib.org" target="_top">GMP</a> code.
            </li>
<li class="listitem">
              The code can equally use <a href="http://mpir.org/" target="_top">MPIR</a>
              in place of <a href="http://gmplib.org" target="_top">GMP</a> - indeed that
              is the preferred option on Win32.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in an infinity.
            </li>
<li class="listitem">
              When using the variable precision type <code class="computeroutput"><span class="identifier">mpfr_float</span></code>,
              then copy construction and assignment <span class="emphasis"><em>copies the precision
              of the source variable</em></span>. Likewise move construction and assignment.
            </li>
<li class="listitem">
              When constructing the variable precision type <code class="computeroutput"><span class="identifier">mpfr_float</span></code>
              you can specify two arguments to the constructor - the first is the
              value to assign to the variable, the second is an unsigned integer
              specifying the precision in decimal places. The <code class="computeroutput"><span class="identifier">assign</span></code>
              member function similarly has a 2-argument overload taking the value
              to assign and the precision. You can use this to preserve the precision
              of the target variable using the somewhat arcane: <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">precision</span><span class="special">())</span></code>, which assigns <code class="computeroutput"><span class="identifier">b</span></code>
              to <code class="computeroutput"><span class="identifier">a</span></code> but preserves
              the precision of <code class="computeroutput"><span class="identifier">a</span></code>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.mpfr_float.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.mpfr_float.mpfr_example"></a></span><a class="link" href="mpfr_float.html#boost_multiprecision.tut.floats.mpfr_float.mpfr_example"> MPFR example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="comment">// Operations at variable precision and no numeric_limits support:</span>
   <span class="identifier">mpfr_float</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="number">1000</span><span class="special">);</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">mpfr_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print root-2</span>

   <span class="comment">// Operations at fixed precision and full numeric_limits support:</span>
   <span class="identifier">mpfr_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">mpfr_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// We can use any C++ std lib function:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>
   <span class="comment">// We can also use any function from Boost.Math:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// These even work when the argument is an expression template:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="comment">// Access the underlying data:</span>
   <span class="identifier">mpfr_t</span> <span class="identifier">r</span><span class="special">;</span>
   <span class="identifier">mpfr_init</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
   <span class="identifier">mpfr_set</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">(),</span> <span class="identifier">GMP_RNDN</span><span class="special">);</span>
   <span class="identifier">mpfr_clear</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.boost_multiprecision.tut.floats.mpfr_float.f0" class="footnote"><p><a href="#boost_multiprecision.tut.floats.mpfr_float.f0" class="para"><sup class="para">[2] </sup></a>
            Compiled with VC++10 and /Ox, with MPFR-3.0.0 and MPIR-2.3.0
          </p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="float128.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/floats.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Floating-point Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="ints/egs/bitops.html" title="Bit Operations">
<link rel="next" href="floats/cpp_bin_float.html" title="cpp_bin_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_bin_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.floats"></a><a class="link" href="floats.html" title="Floating-point Types">Floating-point Types</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="floats/cpp_bin_float.html">cpp_bin_float</a></span></dt>
<dt><span class="section"><a href="floats/cpp_dec_float.html">cpp_dec_float</a></span></dt>
<dt><span class="section"><a href="floats/gmp_float.html">gmp_float</a></span></dt>
<dt><span class="section"><a href="floats/mpfr_float.html">mpfr_float</a></span></dt>
<dt><span class="section"><a href="floats/float128.html">float128</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="floats/fp_eg/floatbuiltinctor.html">Construction
          from Specific Values Without Precision Loss</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/aos.html">Area of
          Circle</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/caveats.html">Drop-in
          Caveats</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/jel.html">Defining
          a Special Function.</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/nd.html">Calculating
          a Derivative</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/gi.html">Calculating
          an Integral</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/poly_eg.html">Polynomial
          Evaluation</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/variable_precision.html">Variable-Precision
          Newton Evaluation</a></span></dt>
<dt><span class="section"><a href="floats/fp_eg/gauss_lagerre_quadrature.html">Gauss-Laguerre
          quadrature</a></span></dt>
</dl></dd>
</dl></div>
<p>
        The following back-ends provide floating-point arithmetic:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend Type
                </p>
              </th>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Radix
                </p>
              </th>
<th>
                <p>
                  Dependencies
                </p>
              </th>
<th>
                <p>
                  Pros
                </p>
              </th>
<th>
                <p>
                  Cons
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/cpp_bin_float.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  Header only, all C++ implementation. Boost licence.
                </p>
              </td>
<td>
                <p>
                  Approximately 2x slower than the <a href="http://www.mpfr.org" target="_top">MPFR</a>
                  or <a href="http://gmplib.org" target="_top">GMP</a> libraries.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/cpp_dec_float.hpp
                </p>
              </td>
<td>
                <p>
                  10
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  Header only, all C++ implementation. Boost licence.
                </p>
              </td>
<td>
                <p>
                  Approximately 2x slower than the <a href="http://www.mpfr.org" target="_top">MPFR</a>
                  or <a href="http://gmplib.org" target="_top">GMP</a> libraries.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">mpf_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/gmp.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://gmplib.org" target="_top">GMP</a>
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end.
                </p>
              </td>
<td>
                <p>
                  Dependency on GNU licensed <a href="http://gmplib.org" target="_top">GMP</a>
                  library.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">mpfr_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/mpfr.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://gmplib.org" target="_top">GMP</a> and <a href="http://www.mpfr.org" target="_top">MPFR</a>
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end, with its own standard library
                  implementation.
                </p>
              </td>
<td>
                <p>
                  Dependency on GNU licensed <a href="http://gmplib.org" target="_top">GMP</a>
                  and <a href="http://www.mpfr.org" target="_top">MPFR</a> libraries.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">float128</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/float128.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  Either <a href="http://gcc.gnu.org/onlinedocs/libquadmath/" target="_top">libquadmath</a>
                  or the Intel C++ Math library.
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end for 128-bit floating-point values
                  (113-bit mantissa, equivalent to FORTRAN's QUAD real)
                </p>
              </td>
<td>
                <p>
                  Depends on the compiler being either recent GCC or Intel C++ versions.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ints/egs/bitops.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floats/cpp_bin_float.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/gen_int.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Generic Integer Operations</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="variable.html" title="Variable Precision Arithmetic">
<link rel="next" href="serial.html" title="Boost.Serialization Support">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="variable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="serial.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.gen_int"></a><a class="link" href="gen_int.html" title="Generic Integer Operations">Generic Integer Operations</a>
</h3></div></div></div>
<p>
        All of the <a class="link" href="../ref/number.html#boost_multiprecision.ref.number.integer_functions">non-member
        integer operations</a> are overloaded for the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> integer types in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
        Where these operations require a temporary increase in precision (such as
        for <code class="computeroutput"><span class="identifier">powm</span></code>), then if no <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental (built-in)</a>
        type is available, a <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
        of appropriate precision will be used.
      </p>
<p>
        Some of these functions are trivial, others use compiler intrinsics (where
        available) to ensure optimal evaluation.
      </p>
<p>
        The overloaded functions are:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">I2</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Multiplies two <code class="computeroutput"><span class="identifier">I2</span></code> values,
        to produce a wider <code class="computeroutput"><span class="identifier">Integer</span></code>
        result.
      </p>
<p>
        Returns <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
        <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">b</span></code> without overflow or loss of precision
        in the multiplication.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">I2</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Adds two <code class="computeroutput"><span class="identifier">I2</span></code> values, to produce
        a wider <code class="computeroutput"><span class="identifier">Integer</span></code> result.
      </p>
<p>
        Returns <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
        <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span></code> without overflow or loss of precision
        in the addition.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">I2</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">subtract</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">I2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        Subtracts two <code class="computeroutput"><span class="identifier">I2</span></code> values,
        to produce a wider <code class="computeroutput"><span class="identifier">Integer</span></code>
        result.
      </p>
<p>
        Returns <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
        <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span></code> without overflow or loss of precision
        in the subtraction.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span> <span class="identifier">powm</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
</pre>
<p>
        Returns b<sup>p</sup> % m.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">divide_qr</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">q</span><span class="special">,</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
</pre>
<p>
        Sets <code class="computeroutput"><span class="identifier">q</span> <span class="special">=</span>
        <span class="identifier">x</span> <span class="special">/</span> <span class="identifier">y</span></code> and <code class="computeroutput"><span class="identifier">r</span>
        <span class="special">=</span> <span class="identifier">x</span> <span class="special">%</span> <span class="identifier">y</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Integer2</span><span class="special">&gt;</span>
<span class="identifier">Integer2</span> <span class="identifier">integer_modulus</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer1</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Integer2</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
        Returns x % val;
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="keyword">unsigned</span> <span class="identifier">lsb</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
        Returns the (zero-based) index of the least significant bit of <code class="computeroutput"><span class="identifier">x</span></code>.
      </p>
<p>
        Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span></code> if <code class="computeroutput"><span class="identifier">x</span>
        <span class="special">&lt;=</span> <span class="number">0</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="keyword">unsigned</span> <span class="identifier">msb</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
        Returns the (zero-based) index of the most significant bit of <code class="computeroutput"><span class="identifier">x</span></code>.
      </p>
<p>
        Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span></code> if <code class="computeroutput"><span class="identifier">x</span>
        <span class="special">&lt;=</span> <span class="number">0</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">bit_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Returns <code class="computeroutput"><span class="keyword">true</span></code> if bit <code class="computeroutput"><span class="identifier">index</span></code> is set in <code class="computeroutput"><span class="identifier">val</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Sets the <code class="computeroutput"><span class="identifier">index</span></code> bit in <code class="computeroutput"><span class="identifier">val</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">bit_unset</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Unsets the <code class="computeroutput"><span class="identifier">index</span></code> bit in
        <code class="computeroutput"><span class="identifier">val</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">bit_flip</span><span class="special">(</span><span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">index</span><span class="special">);</span>
</pre>
<p>
        Flips the <code class="computeroutput"><span class="identifier">index</span></code> bit in <code class="computeroutput"><span class="identifier">val</span></code>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Integer</span><span class="special">&gt;</span>
<span class="identifier">Integer</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Integer</span><span class="special">&amp;</span> <span class="identifier">r</span><span class="special">);</span>
</pre>
<p>
        Returns the integer square root <code class="computeroutput"><span class="identifier">s</span></code>
        of x and sets <code class="computeroutput"><span class="identifier">r</span></code> to the remainder
        <span class="emphasis"><em>x - s<sup>2</sup></em></span>.
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Engine</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">-</span><span class="keyword">or</span><span class="special">-</span><span class="identifier">expression</span><span class="special">-</span><span class="keyword">template</span><span class="special">-</span><span class="identifier">type</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">,</span> <span class="identifier">Engine</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">-</span><span class="keyword">or</span><span class="special">-</span><span class="identifier">expression</span><span class="special">-</span><span class="keyword">template</span><span class="special">-</span><span class="identifier">type</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">);</span>
</pre>
<p>
        The regular Miller-Rabin functions in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">miller_rabin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        are defined in terms of the above generic operations, and so function equally
        well for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in) types</a> and multiprecision types.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="variable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="serial.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/hash.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Hash Function Support</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="input_output.html" title="Input Output">
<link rel="next" href="eigen.html" title="Eigen Interoperability">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="input_output.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="eigen.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.hash"></a><a class="link" href="hash.html" title="Hash Function Support">Hash Function Support</a>
</h3></div></div></div>
<p>
        All of the types in this library support hashing via boost::hash or std::hash.
        That means we can use multiprecision types directly in hashed containers
        such as std::unordered_set:
      </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>

<span class="identifier">mt19937</span> <span class="identifier">mt</span><span class="special">;</span>
<span class="identifier">uniform_int_distribution</span><span class="special">&lt;</span><span class="identifier">uint256_t</span><span class="special">&gt;</span> <span class="identifier">ui</span><span class="special">;</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">uint256_t</span><span class="special">&gt;</span> <span class="identifier">set</span><span class="special">;</span>
<span class="comment">// Put 1000 random values into the container:</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
   <span class="identifier">set</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">ui</span><span class="special">(</span><span class="identifier">mt</span><span class="special">));</span>
</pre>
<p>
        Or we can define our own hash function, for example in this case based on
        Google's CityHash:
      </p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">cityhash</span>
<span class="special">{</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">uint256_t</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">)</span><span class="keyword">const</span>
   <span class="special">{</span>
      <span class="comment">// create a hash from all the limbs of the argument, this function is probably x64 specific,</span>
      <span class="comment">// and requires that we access the internals of the data type:</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">CityHash64</span><span class="special">(</span><span class="keyword">reinterpret_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;(</span><span class="identifier">val</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">limbs</span><span class="special">()),</span> <span class="identifier">val</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">size</span><span class="special">()</span> <span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">val</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">limbs</span><span class="special">()[</span><span class="number">0</span><span class="special">]));</span>
      <span class="comment">// modify the returned hash based on sign:</span>
      <span class="keyword">return</span> <span class="identifier">val</span> <span class="special">&lt;</span> <span class="number">0</span> <span class="special">?</span> <span class="special">~</span><span class="identifier">result</span> <span class="special">:</span> <span class="identifier">result</span><span class="special">;</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
        As before insert some values into a container, this time using our custom
        hasher:
      </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">uint256_t</span><span class="special">,</span> <span class="identifier">cityhash</span><span class="special">&gt;</span> <span class="identifier">set2</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
   <span class="identifier">set2</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">ui</span><span class="special">(</span><span class="identifier">mt</span><span class="special">));</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="input_output.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="eigen.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/import_export.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Importing and Exporting Data to and from cpp_int and cpp_bin_float</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="lits.html" title="Literal Types and constexpr Support">
<link rel="next" href="rounding.html" title="Rounding Rules for Conversions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="lits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rounding.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.import_export"></a><a class="link" href="import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float">Importing and
      Exporting Data to and from <code class="computeroutput"><span class="identifier">cpp_int</span></code>
      and <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code></a>
</h3></div></div></div>
<p>
        Any integer number type that uses <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>
        as its implementation layer can import or export its bits via two non-member
        functions:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
          <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">export_bits</span><span class="special">(</span>
   <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span>
   <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
   <span class="keyword">unsigned</span> <span class="identifier">chunk_size</span><span class="special">,</span>
   <span class="keyword">bool</span> <span class="identifier">msv_first</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
          <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span>
   <span class="identifier">import_bits</span><span class="special">(</span>
      <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span>
      <span class="identifier">Iterator</span> <span class="identifier">i</span><span class="special">,</span>
      <span class="identifier">Iterator</span> <span class="identifier">j</span><span class="special">,</span>
      <span class="keyword">unsigned</span> <span class="identifier">chunk_size</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
      <span class="keyword">bool</span> <span class="identifier">msv_first</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">);</span>
</pre>
<p>
        These functions are designed for data-interchange with other storage formats,
        and since <a class="link" href="floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>
        uses <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
        internally, by extension they can be used for floating-point numbers based
        on that backend as well (see example below). Parameters and use are as follows:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
          <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">export_bits</span><span class="special">(</span>
   <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span>
   <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
   <span class="keyword">unsigned</span> <span class="identifier">chunk_size</span><span class="special">,</span>
   <span class="keyword">bool</span> <span class="identifier">msv_first</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">);</span>
</pre>
<p>
        Exports the absolute value of <code class="computeroutput"><span class="identifier">val</span></code>
        to OutputIterator <code class="computeroutput"><span class="identifier">out</span></code>. The
        function will write <code class="computeroutput"><span class="identifier">chunk_size</span></code>
        bits at a time to the OutputIterator, and if <code class="computeroutput"><span class="identifier">msv_first</span></code>
        is true, will write the most-significant block first. Byte and bit order
        within each <code class="computeroutput"><span class="identifier">chunk_size</span></code> block
        is always in the machines native format. Further, each block is stored in
        a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">uintmax_t</span></code> when it's assigned to <code class="computeroutput"><span class="special">*</span><span class="identifier">out</span></code>.
      </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          Unfortunately, the standard's OutputIterator concept provides no means
          of deducing the type to output since <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">OutputIteratorType</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
          is type <code class="computeroutput"><span class="keyword">void</span></code>. This is why
          the bit count for each block has to be specified manually. It may also
          result in compiler warnings about the value being narrowed.
        </p></td></tr>
</table></div>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top"><p>
          If you're exporting to non-native byte layout, then use <a href="http://www.boost.org/doc/libs/release/libs/endian/doc/index.html" target="_top">Boost.Endian</a>
          to create a custom OutputIterator that reverses the byte order of each
          chunk prior to actually storing the result.
        </p></td></tr>
</table></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
          <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span>
   <span class="identifier">import_bits</span><span class="special">(</span>
      <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span>
      <span class="identifier">ForwardIterator</span> <span class="identifier">i</span><span class="special">,</span>
      <span class="identifier">ForwardIterator</span> <span class="identifier">j</span><span class="special">,</span>
      <span class="keyword">unsigned</span> <span class="identifier">chunk_size</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
      <span class="keyword">bool</span> <span class="identifier">msv_first</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">);</span>
</pre>
<p>
        Imports bits from the iterator range <span class="emphasis"><em>[i,j)</em></span> and stores
        them in <code class="computeroutput"><span class="identifier">val</span></code> to produce an
        unsigned result (if the result is to be signed you will need to handle that
        separately). When <code class="computeroutput"><span class="identifier">msv_first</span></code>
        is true, takes <code class="computeroutput"><span class="special">*</span><span class="identifier">i</span></code>
        as the most significant chunk. Assumes there are <code class="computeroutput"><span class="identifier">chunk_size</span></code>
        bits in each value read from the iterator range, and that these are in machine
        native bit/byte order. When <code class="computeroutput"><span class="identifier">chunk_size</span></code>
        is zero, then assumes that each chunk contains <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">ForwardIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;::</span><span class="identifier">digits</span></code>,
        note that this will give the wrong result if dereferencing the iterators
        leads to a signed-integer type, <span class="bold"><strong>and</strong></span> the
        sign bit is significant (be particularly careful if you expect type <code class="computeroutput"><span class="keyword">char</span></code> to contain 8-bit values, as by default
        it will extract only 7-bits at a time if <code class="computeroutput"><span class="keyword">char</span></code>
        is signed). As with exporting, if the external data is to be in a non-native
        byte order (within each chunk), then you will need to create an iterator
        adaptor that presents it in native order (see <a href="http://www.boost.org/doc/libs/release/libs/endian/doc/index.html" target="_top">Boost.Endian</a>).
      </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          Note that this function is optimized for the case where the data can be
          <code class="computeroutput"><span class="identifier">memcpy</span></code>ed from the source
          to the integer - in this case both iterators much be pointers, and everything
          must be little-endian.
        </p></td></tr>
</table></div>
<h5>
<a name="boost_multiprecision.tut.import_export.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.import_export.examples"></a></span><a class="link" href="import_export.html#boost_multiprecision.tut.import_export.examples">Examples</a>
      </h5>
<p>
        In this simple example, we'll import/export the bits of a cpp_int to a vector
        of 8-bit unsigned values:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>


<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_int</span><span class="special">;</span>
   <span class="comment">// Create a cpp_int with just a couple of bits set:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="number">5000</span><span class="special">);</span> <span class="comment">// set the 5000'th bit</span>
   <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="number">200</span><span class="special">);</span>
   <span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="number">50</span><span class="special">);</span>
   <span class="comment">// export into 8-bit unsigned values, most significant bit first:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
   <span class="identifier">export_bits</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">v</span><span class="special">),</span> <span class="number">8</span><span class="special">);</span>
   <span class="comment">// import back again, and check for equality:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">j</span><span class="special">;</span>
   <span class="identifier">import_bits</span><span class="special">(</span><span class="identifier">j</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
   <span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">i</span> <span class="special">==</span> <span class="identifier">j</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
        Importing or exporting cpp_bin_float is similar, but we must proceed via
        an intermediate integer:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>


<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_100</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_int</span><span class="special">;</span>
   <span class="comment">// Create a cpp_bin_float to import/export:</span>
   <span class="identifier">cpp_bin_float_100</span> <span class="identifier">f</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
   <span class="identifier">f</span> <span class="special">/=</span> <span class="number">3</span><span class="special">;</span>
   <span class="comment">// export into 8-bit unsigned values, most significant bit first:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
   <span class="identifier">export_bits</span><span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">bits</span><span class="special">()),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">v</span><span class="special">),</span> <span class="number">8</span><span class="special">);</span>
   <span class="comment">// Grab the exponent as well:</span>
   <span class="keyword">int</span> <span class="identifier">e</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">exponent</span><span class="special">();</span>
   <span class="comment">// Import back again, and check for equality, we have to proceed via</span>
   <span class="comment">// an intermediate integer:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">import_bits</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
   <span class="identifier">cpp_bin_float_100</span> <span class="identifier">g</span><span class="special">(</span><span class="identifier">i</span><span class="special">);</span>
   <span class="identifier">g</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">exponent</span><span class="special">()</span> <span class="special">=</span> <span class="identifier">e</span><span class="special">;</span>
   <span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">f</span> <span class="special">==</span> <span class="identifier">g</span><span class="special">);</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="lits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rounding.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/input_output.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Input Output</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="limits/how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">
<link rel="next" href="hash.html" title="Hash Function Support">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="limits/how_to_tell.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="hash.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.input_output"></a><a class="link" href="input_output.html" title="Input Output">Input Output</a>
</h3></div></div></div>
<h5>
<a name="boost_multiprecision.tut.input_output.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.input_output.loopback_testing"></a></span><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.loopback_testing">Loopback
        testing</a>
      </h5>
<p>
        <span class="emphasis"><em>Loopback</em></span> or <span class="emphasis"><em>round-tripping</em></span> refers
        to writing out a value as a decimal digit string using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iostream</span></code>,
        usually to a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span></code>, and then reading the string
        back in to another value, and confirming that the two values are identical.
        A trivial example using <code class="computeroutput"><span class="keyword">float</span></code>
        is:
      </p>
<pre class="programlisting"><span class="keyword">float</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Value to round-trip.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>  <span class="comment">// Read and write std::stringstream.</span>
<span class="identifier">ss</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>  <span class="comment">// Ensure all potentially significant bits are output.</span>
<span class="identifier">ss</span><span class="special">.</span><span class="identifier">flags</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">fmtflags</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">scientific</span><span class="special">));</span> <span class="comment">// Use scientific format.</span>
<span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Output to string.</span>
<span class="keyword">float</span> <span class="identifier">read</span><span class="special">;</span>  <span class="comment">// Expected.</span>
<span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span> <span class="comment">// Read decimal digits string from stringstream.</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">write</span><span class="special">,</span> <span class="identifier">read</span><span class="special">);</span> <span class="comment">// Should be the same.</span>
</pre>
<p>
        and this can be run in a loop for all possible values of a 32-bit float.
        For other floating-point types <code class="computeroutput"><span class="identifier">T</span></code>,
        including <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> <code class="computeroutput"><span class="keyword">double</span></code>, it
        takes far too long to test all values, so a reasonable test strategy is to
        use a large number of random values.
      </p>
<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">write</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
<span class="identifier">ss</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>  <span class="comment">// Ensure all potentially significant bits are output.</span>
<span class="identifier">ss</span><span class="special">.</span><span class="identifier">flags</span><span class="special">(</span><span class="identifier">f</span><span class="special">);</span> <span class="comment">// Changed from default iostream format flags if desired.</span>
<span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span> <span class="comment">// Output to stringstream.</span>

<span class="identifier">T</span> <span class="identifier">read</span><span class="special">;</span>
<span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span> <span class="comment">// Get read using operator&gt;&gt; from stringstream.</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>

<span class="identifier">read</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">());</span> <span class="comment">// Get read by converting from decimal digits string representation of write.</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>

<span class="identifier">read</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">write</span><span class="special">.</span><span class="identifier">str</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">f</span><span class="special">));</span>  <span class="comment">// Get read using format specified when written.</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span><span class="identifier">read</span><span class="special">,</span> <span class="identifier">write</span><span class="special">);</span>
</pre>
<p>
        The test at <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/test_cpp_bin_float_io.cpp" target="_top">test_cpp_bin_float_io.cpp</a>
        allows any floating-point type to be <span class="emphasis"><em>round_tripped</em></span> using
        a wide range of fairly random values. It also includes tests compared a collection
        of <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/string_data.ipp" target="_top">stringdata</a> test cases
        in a file.
      </p>
<h5>
<a name="boost_multiprecision.tut.input_output.h1"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.input_output.comparing_with_output_using_fund"></a></span><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.comparing_with_output_using_fund">Comparing
        with output using fundamental
        (built-in) types</a>
      </h5>
<p>
        One can make some comparisons with the output of
      </p>
<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_count_2</span><span class="special">&gt;</span> <span class="special">&gt;</span>
</pre>
<p>
        which has the same number of significant bits (53) as 64-bit double precision
        floating-point.
      </p>
<p>
        However, although most outputs are identical, there are differences on some
        platforms caused by the implementation-dependent behaviours allowed by the
        C99 specification <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf" target="_top">C99
        ISO/IEC 9899:TC2</a>, incorporated by C++.
      </p>
<div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>"For e, E, f, F, g, and G conversions, if the number of
          significant decimal digits is at most DECIMAL_DIG, then the result should
          be correctly rounded. If the number of significant decimal digits is more
          than DECIMAL_DIG but the source value is exactly representable with DECIMAL_DIG
          digits, then the result should be an exact representation with trailing
          zeros. Otherwise, the source value is bounded by two adjacent decimal strings
          L &lt; U, both having DECIMAL_DIG significant digits; the value of the
          resultant decimal string D should satisfy L&lt;= D &lt;= U, with the extra
          stipulation that the error should have a correct sign for the current rounding
          direction."</em></span>
        </p></blockquote></div>
<p>
        So not only is correct rounding for the full number of digits not required,
        but even if the <span class="bold"><strong>optional</strong></span> recommended practice
        is followed, then the value of these last few digits is unspecified as long
        as the value is within certain bounds.
      </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          Do not expect the output from different platforms to be <span class="bold"><strong>identical</strong></span>,
          but <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>, <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code> (and other backends) outputs
          should be correctly rounded to the number of digits requested by the set
          precision and format.
        </p></td></tr>
</table></div>
<h5>
<a name="boost_multiprecision.tut.input_output.h2"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.input_output.macro_boost_mp_min_exponent_digi"></a></span><a class="link" href="input_output.html#boost_multiprecision.tut.input_output.macro_boost_mp_min_exponent_digi">Macro
        BOOST_MP_MIN_EXPONENT_DIGITS</a>
      </h5>
<p>
        <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf" target="_top">C99
        Standard</a> for format specifiers, 7.19.6 Formatted input/output functions
        requires:
      </p>
<p>
        "The exponent always contains at least two digits, and only as many
        more digits as necessary to represent the exponent."
      </p>
<p>
        So to conform to the C99 standard (incorporated by C++)
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">2</span>
</pre>
<p>
        Confusingly, Microsoft (and MinGW) do not conform to this standard and provide
        <span class="bold"><strong>at least three digits</strong></span>, for example <code class="computeroutput"><span class="number">1e+001</span></code>. So if you want the output to match
        that from <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
        (built-in)</a> floating-point types on compilers that use Microsofts
        runtime then use:
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">3</span>
</pre>
<p>
        Also useful to get the minimum exponent field width is
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">BOOST_MP_MIN_EXPONENT_DIGITS</span> <span class="number">1</span>
</pre>
<p>
        producing a compact output like <code class="computeroutput"><span class="number">2e+4</span></code>,
        useful when conserving space is important.
      </p>
<p>
        Larger values are also supported, for example, value 4 for <code class="computeroutput"><span class="number">2e+0004</span></code> which may be useful to ensure that
        columns line up.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="limits/how_to_tell.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="hash.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/interval/mpfi.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>mpfi_float</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../interval.html" title="Interval Number Types">
<link rel="prev" href="../interval.html" title="Interval Number Types">
<link rel="next" href="../complex.html" title="Complex Number Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../interval.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interval.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../complex.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.interval.mpfi"></a><a class="link" href="mpfi.html" title="mpfi_float">mpfi_float</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">mpfi_float_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>    <span class="identifier">mpfi_float_50</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">100</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfifloat_100</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">500</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">mpfifloat_500</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">mpfi_float_1000</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">mpfi_float</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">mpfi_float_backend</span></code>
          type is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>:
          It acts as a thin wrapper around the <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>
          <code class="computeroutput"><span class="identifier">mpfi_t</span></code> to provide an real-number
          type that is a drop-in replacement for the native C++ floating-point types,
          but with much greater precision and implementing interval arithmetic.
        </p>
<p>
          Type <code class="computeroutput"><span class="identifier">mpfi_float_backend</span></code>
          can be used at fixed precision by specifying a non-zero <code class="computeroutput"><span class="identifier">Digits10</span></code>
          template parameter, or at variable precision by setting the template argument
          to zero. The <code class="computeroutput"><span class="keyword">typedef</span></code>s <code class="computeroutput"><span class="identifier">mpfi_float_50</span></code>, <code class="computeroutput"><span class="identifier">mpfi_float_100</span></code>,
          <code class="computeroutput"><span class="identifier">mpfi_float_500</span></code>, <code class="computeroutput"><span class="identifier">mpfi_float_1000</span></code> provide arithmetic types
          at 50, 100, 500 and 1000 decimal digits precision respectively. The <code class="computeroutput"><span class="keyword">typedef</span> <span class="identifier">mpfi_float</span></code>
          provides a variable precision type whose precision can be controlled via
          theF <code class="computeroutput"><span class="identifier">number</span></code>s member functions.
        </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            This type only provides <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
            support when the precision is fixed at compile time.
          </p></td></tr>
</table></div>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span></code> are copy constructible and assignable
          from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>
              native type <code class="computeroutput"><span class="identifier">mpfi_t</span></code>.
            </li>
<li class="listitem">
              The <code class="computeroutput"><span class="identifier">number</span></code> wrappers
              around <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>
              or <a href="http://www.mpfr.org" target="_top">MPFR</a>: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>
              and <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
            </li>
<li class="listitem">
              There is a two argument constructor taking two <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>
              arguments specifying the interval.
            </li>
</ul></div>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpfi_t</span></code>
          via the <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">mpfi_float_backend</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              A default constructed <code class="computeroutput"><span class="identifier">mpfi_float_backend</span></code>
              is set to zero (<span class="emphasis"><em>Note that this is <span class="bold"><strong>not</strong></span>
              the default <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>
              behavior</em></span>).
            </li>
<li class="listitem">
              No changes are made to <a href="http://gmplib.org" target="_top">GMP</a> or
              <a href="http://www.mpfr.org" target="_top">MPFR</a> global settings, so this
              type can coexist with existing <a href="http://www.mpfr.org" target="_top">MPFR</a>
              or <a href="http://gmplib.org" target="_top">GMP</a> code.
            </li>
<li class="listitem">
              The code can equally use <a href="http://mpir.org/" target="_top">MPIR</a>
              in place of <a href="http://gmplib.org" target="_top">GMP</a> - indeed that
              is the preferred option on Win32.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in an infinity.
            </li>
</ul></div>
<p>
          There are some additional non member functions for working on intervals:
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">lower</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
          Returns the lower end of the interval.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">upper</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
          Returns the upper end of the interval.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">median</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
          Returns the mid point of the interval.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">width</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
          Returns the absolute width of the interval.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">intersect</span><span class="special">(</span>
  <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
  <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span>  <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns the interval which is the intersection of the <span class="emphasis"><em>a</em></span>
          and <span class="emphasis"><em>b</em></span>. Returns an unspecified empty interval if there
          is no such intersection.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span> <span class="identifier">hull</span><span class="special">(</span>
  <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
  <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span>  <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns the interval which is the union of <span class="emphasis"><em>a</em></span> and
          <span class="emphasis"><em>b</em></span>.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">overlap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
             <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span>  <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if the intervals
          <span class="emphasis"><em>a</em></span> and <span class="emphasis"><em>b</em></span> overlap.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates1</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates2</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">in</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates1</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
        <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates2</span><span class="special">&gt;&amp;</span>  <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if point
          <span class="emphasis"><em>a</em></span> is contained within the interval <span class="emphasis"><em>b</em></span>.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">zero_in</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if the interval
          <span class="emphasis"><em>a</em></span> contains the value zero.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">subset</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
            <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if <span class="emphasis"><em>a</em></span>
          is a subset of <span class="emphasis"><em>b</em></span>.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">proper_subset</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                   <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if <span class="emphasis"><em>a</em></span>
          is a proper subset of <span class="emphasis"><em>b</em></span>.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">empty</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> only if <span class="emphasis"><em>a</em></span>
          is an empty interval, equivalent to <code class="computeroutput"><span class="identifier">upper</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
          <span class="special">&lt;</span> <span class="identifier">lower</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>.
        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">singleton</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">Digits10</span><span class="special">&gt;,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre>
<p>
          Returns <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">lower</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">==</span>
          <span class="identifier">upper</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>.
        </p>
<h6>
<a name="boost_multiprecision.tut.interval.mpfi.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.interval.mpfi.mpfi_example"></a></span><a class="link" href="mpfi.html#boost_multiprecision.tut.interval.mpfi.mpfi_example"> MPFI
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="comment">// Operations at variable precision and no numeric_limits support:</span>
   <span class="identifier">mpfi_float</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">mpfi_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="number">1000</span><span class="special">);</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">mpfi_float</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print root-2</span>

   <span class="comment">// Operations at fixed precision and full numeric_limits support:</span>
   <span class="identifier">mpfi_float_100</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">mpfi_float_100</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">// We can use any C++ std lib function:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// print log(2)</span>

   <span class="comment">// Access the underlying data:</span>
   <span class="identifier">mpfi_t</span> <span class="identifier">r</span><span class="special">;</span>
   <span class="identifier">mpfi_init</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
   <span class="identifier">mpfi_set</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>

   <span class="comment">// Construct some explicit intervals and perform set operations:</span>
   <span class="identifier">mpfi_float_50</span> <span class="identifier">i1</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">),</span> <span class="identifier">i2</span><span class="special">(</span><span class="number">1.5</span><span class="special">,</span> <span class="number">2.5</span><span class="special">);</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">intersect</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">hull</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">overlap</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">subset</span><span class="special">(</span><span class="identifier">i1</span><span class="special">,</span> <span class="identifier">i2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">mpfi_clear</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../interval.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interval.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../complex.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/interval.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Interval Number Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="floats/fp_eg/gauss_lagerre_quadrature.html" title="Gauss-Laguerre quadrature">
<link rel="next" href="interval/mpfi.html" title="mpfi_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="floats/fp_eg/gauss_lagerre_quadrature.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="interval/mpfi.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.interval"></a><a class="link" href="interval.html" title="Interval Number Types">Interval Number Types</a>
</h3></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="interval/mpfi.html">mpfi_float</a></span></dt></dl></div>
<p>
        There is one currently only one interval number type supported - <a href="http://perso.ens-lyon.fr/nathalie.revol/software.html" target="_top">MPFI</a>.
      </p>
<p>
        [ section:mpfi mpfi_float]
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="floats/fp_eg/gauss_lagerre_quadrature.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="interval/mpfi.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/cpp_int.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_int</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ints.html" title="Integer Types">
<link rel="prev" href="../ints.html" title="Integer Types">
<link rel="next" href="gmp_int.html" title="gmp_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../ints.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_int.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.ints.cpp_int"></a><a class="link" href="cpp_int.html" title="cpp_int">cpp_int</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">unspecified</span><span class="special">-</span><span class="identifier">type</span> <span class="identifier">limb_type</span><span class="special">;</span>

<span class="keyword">enum</span> <span class="identifier">cpp_integer_type</span>    <span class="special">{</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span> <span class="special">};</span>
<span class="keyword">enum</span> <span class="identifier">cpp_int_check_type</span>  <span class="special">{</span> <span class="identifier">checked</span><span class="special">,</span> <span class="identifier">unchecked</span> <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
          <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
          <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span> <span class="special">=</span> <span class="identifier">signed_magnitude</span><span class="special">,</span>
          <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span> <span class="special">=</span> <span class="identifier">unchecked</span><span class="special">,</span>
          <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">limb_type</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">cpp_int_backend</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// Expression templates default to et_off if there is no allocator:</span>
<span class="comment">//</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">cpp_integer_type</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">cpp_int_check_type</span> <span class="identifier">Checked</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">expression_template_default</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">MinBits</span><span class="special">,</span> <span class="identifier">MaxBits</span><span class="special">,</span> <span class="identifier">SignType</span><span class="special">,</span> <span class="identifier">Checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="special">{</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">expression_template_option</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">et_off</span><span class="special">;</span> <span class="special">};</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span>              <span class="identifier">cpp_int</span><span class="special">;</span>    <span class="comment">// arbitrary precision integer</span>
<span class="keyword">typedef</span> <span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span>    <span class="identifier">cpp_rational_backend</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_rational_backend</span><span class="special">&gt;</span>            <span class="identifier">cpp_rational</span><span class="special">;</span> <span class="comment">// arbitrary precision rational number</span>

<span class="comment">// Fixed precision unsigned types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">uint512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">uint1024_t</span><span class="special">;</span>

<span class="comment">// Fixed precision signed types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">int512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">unchecked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">int1024_t</span><span class="special">;</span>

<span class="comment">// Over again, but with checking enabled this time:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">&gt;</span> <span class="special">&gt;</span>                 <span class="identifier">checked_cpp_int</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_cpp_rational_backend</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_rational_backend</span><span class="special">&gt;</span>                                              <span class="identifier">checked_cpp_rational</span><span class="special">;</span>

<span class="comment">// Checked fixed precision unsigned types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_uint512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">unsigned_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">checked_uint1024_t</span><span class="special">;</span>

<span class="comment">// Fixed precision signed types:</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">128</span><span class="special">,</span> <span class="number">128</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int128_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">256</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int256_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">512</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>       <span class="identifier">checked_int512_t</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">,</span> <span class="number">1024</span><span class="special">,</span> <span class="identifier">signed_magnitude</span><span class="special">,</span> <span class="identifier">checked</span><span class="special">,</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span>     <span class="identifier">checked_int1024_t</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code> type
          is normally used via one of the convenience typedefs given above.
        </p>
<p>
          This back-end is the "Swiss Army Knife" of integer types as it
          can represent both fixed and <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
          precision</a> integer types, and both signed and unsigned types. There
          are five template arguments:
        </p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">MinBits</span></dt>
<dd><p>
                Determines the number of Bits to store directly within the object
                before resorting to dynamic memory allocation. When zero, this field
                is determined automatically based on how many bits can be stored
                in union with the dynamic storage header: setting a larger value
                may improve performance as larger integer values will be stored internally
                before memory allocation is required.
              </p></dd>
<dt><span class="term">MaxBits</span></dt>
<dd><p>
                Determines the maximum number of bits to be stored in the type: resulting
                in a fixed precision type. When this value is the same as MinBits,
                then the Allocator parameter is ignored, as no dynamic memory allocation
                will ever be performed: in this situation the Allocator parameter
                should be set to type <code class="computeroutput"><span class="keyword">void</span></code>.
                Note that this parameter should not be used simply to prevent large
                memory allocations, not only is that role better performed by the
                allocator, but fixed precision integers have a tendency to allocate
                all of MaxBits of storage more often than one would expect.
              </p></dd>
<dt><span class="term">SignType</span></dt>
<dd><p>
                Determines whether the resulting type is signed or not. Note that
                for <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
                precision</a> types this parameter must be <code class="computeroutput"><span class="identifier">signed_magnitude</span></code>.
                For fixed precision types then this type may be either <code class="computeroutput"><span class="identifier">signed_magnitude</span></code> or <code class="computeroutput"><span class="identifier">unsigned_magnitude</span></code>.
              </p></dd>
<dt><span class="term">Checked</span></dt>
<dd><p>
                This parameter has two values: <code class="computeroutput"><span class="identifier">checked</span></code>
                or <code class="computeroutput"><span class="identifier">unchecked</span></code>. See
                below.
              </p></dd>
<dt><span class="term">Allocator</span></dt>
<dd><p>
                The allocator to use for dynamic memory allocation, or type <code class="computeroutput"><span class="keyword">void</span></code> if MaxBits == MinBits.
              </p></dd>
</dl>
</div>
<p>
          When the template parameter Checked is set to <code class="computeroutput"><span class="identifier">checked</span></code>
          then the result is a <span class="emphasis"><em>checked-integer</em></span>, checked and
          unchecked integers have the following properties:
        </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    Condition
                  </p>
                </th>
<th>
                  <p>
                    Checked-Integer
                  </p>
                </th>
<th>
                  <p>
                    Unchecked-Integer
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    Numeric overflow in fixed precision arithmetic
                  </p>
                </td>
<td>
                  <p>
                    Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>.
                  </p>
                </td>
<td>
                  <p>
                    Performs arithmetic modulo 2<sup>MaxBits</sup>
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    Constructing an integer from a value that can not be represented
                    in the target type
                  </p>
                </td>
<td>
                  <p>
                    Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code>.
                  </p>
                </td>
<td>
                  <p>
                    Converts the value modulo 2<sup>MaxBits</sup>, signed to unsigned conversions
                    extract the last MaxBits bits of the 2's complement representation
                    of the input value.
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    Unsigned subtraction yielding a negative value.
                  </p>
                </td>
<td>
                  <p>
                    Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code>.
                  </p>
                </td>
<td>
                  <p>
                    Yields the value that would result from treating the unsigned
                    type as a 2's complement signed type.
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    Attempting a bitwise operation on a negative value.
                  </p>
                </td>
<td>
                  <p>
                    Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code>
                  </p>
                </td>
<td>
                  <p>
                    Yields the value, but not the bit pattern, that would result
                    from performing the operation on a 2's complement integer type.
                  </p>
                </td>
</tr>
</tbody>
</table></div>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>s
              have the value zero.
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Construction from a string that contains invalid non-numeric characters
              results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> being thrown.
            </li>
<li class="listitem">
              Since the precision of <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>
              is necessarily limited when the allocator parameter is void, care should
              be taken to avoid numeric overflow when using this type unless you
              actually want modulo-arithmetic behavior.
            </li>
<li class="listitem">
              The type uses a sign-magnitude representation internally, so type
              <code class="computeroutput"><span class="identifier">int128_t</span></code> has 128-bits
              of precision plus an extra sign bit. In this respect the behaviour
              of these types differs from <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
              (built-in)</a> 2's complement types. In might be tempting to use
              a 127-bit type instead, and indeed this does work, but behaviour is
              still slightly different from a 2's complement <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
              (built-in)</a> type as the minimum and maximum values are identical
              (apart from the sign), where as they differ by one for a true 2's complement
              type. That said it should be noted that there's no requirement for
              fundamental_types to be 2's complement either - it's simply that this
              is the most common format by far.
            </li>
<li class="listitem">
              Attempting to print negative values as either an Octal or Hexadecimal
              string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown, this is a direct consequence of the sign-magnitude representation.
            </li>
<li class="listitem">
              The fixed precision types <code class="computeroutput"><span class="special">[</span><span class="identifier">checked_</span><span class="special">][</span><span class="identifier">u</span><span class="special">]</span><span class="identifier">intXXX_t</span></code> have expression template
              support turned off - it seems to make little difference to the performance
              of these types either way - so we may as well have the faster compile
              times by turning the feature off.
            </li>
<li class="listitem">
              Unsigned types support subtraction - the result is "as if"
              a 2's complement operation had been performed as long as they are not
              <span class="emphasis"><em>checked-integers</em></span> (see above). In other words they
              behave pretty much as a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
              (built-in)</a> integer type would in this situation. So for example
              if we were using <code class="computeroutput"><span class="identifier">uint128_t</span></code>
              then <code class="computeroutput"><span class="identifier">uint128_t</span><span class="special">(</span><span class="number">1</span><span class="special">)-</span><span class="number">4</span></code>
              would result in the value <code class="computeroutput"><span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD</span></code>
              of type <code class="computeroutput"><span class="identifier">uint128_t</span></code>.
              However, had this operation been performed on <code class="computeroutput"><span class="identifier">checked_uint128_t</span></code>
              then a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">range_error</span></code> would have been thrown.
            </li>
<li class="listitem">
              Unary negation of unsigned types results in a compiler error (static
              assertion).
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              When used at fixed precision, the size of this type is always one machine
              word (plus any compiler-applied alignment padding) larger than you
              would expect for an N-bit integer: the extra word stores both the sign,
              and how many machine words in the integer are actually in use. The
              latter is an optimisation for larger fixed precision integers, so that
              a 1024-bit integer has almost the same performance characteristics
              as a 128-bit integer, rather than being 4 times slower for addition
              and 16 times slower for multiplication (assuming the values involved
              would always fit in 128 bits). Typically this means you can use an
              integer type wide enough for the "worst case scenario" with
              only minor performance degradation even if most of the time the arithmetic
              could in fact be done with a narrower type. Also note that unsigned
              fixed precision types small enough to fit inside the largest native
              integer become a simple wrapper around that type, this includes the
              "checked" variants. Small signed types will always have an
              extra sign word and so be larger than their native equivalent.
            </li>
<li class="listitem">
              When used at fixed precision and MaxBits is smaller than the number
              of bits in the largest native integer type, then internally <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code> switches to a "trivial"
              implementation where it is just a thin wrapper around a single integer.
              Note that it will still be slightly slower than a bare native integer,
              as it emulates a signed-magnitude representation rather than simply
              using the platforms native sign representation: this ensures there
              is no step change in behavior as a cpp_int grows in size.
            </li>
<li class="listitem">
              Fixed precision <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s
              have some support for <code class="computeroutput"><span class="keyword">constexpr</span></code>
              values and user-defined literals, see <a class="link" href="../lits.html" title="Literal Types and constexpr Support">here</a>
              for the full description. For example <code class="computeroutput"><span class="number">0xfffff</span><span class="identifier">_cppi1024</span></code> specifies a 1024-bit integer
              with the value 0xffff. This can be used to generate compile-time constants
              that are too large to fit into any <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
              (built-in)</a> number type.
            </li>
<li class="listitem">
              The <a class="link" href="cpp_int.html" title="cpp_int">cpp_int</a>
              types support constexpr arithmetic, provided it is a fixed-precision
              type with no allocator. It may also be a checked integer: in which
              case a compiler error will be generated on overflow or undefined behaviour.
              In addition the free functions <code class="computeroutput"><span class="identifier">abs</span></code>,
              <code class="computeroutput"><span class="identifier">swap</span></code>, <code class="computeroutput"><span class="identifier">multiply</span></code>, <code class="computeroutput"><span class="identifier">add</span></code>,
              <code class="computeroutput"><span class="identifier">subtract</span></code>, <code class="computeroutput"><span class="identifier">divide_qr</span></code>, <code class="computeroutput"><span class="identifier">integer_modulus</span></code>,
              <code class="computeroutput"><span class="identifier">powm</span></code>, <code class="computeroutput"><span class="identifier">lsb</span></code>, <code class="computeroutput"><span class="identifier">msb</span></code>,
              <code class="computeroutput"><span class="identifier">bit_test</span></code>, <code class="computeroutput"><span class="identifier">bit_set</span></code>, <code class="computeroutput"><span class="identifier">bit_unset</span></code>,
              <code class="computeroutput"><span class="identifier">bit_flip</span></code>, <code class="computeroutput"><span class="identifier">sqrt</span></code>, <code class="computeroutput"><span class="identifier">gcd</span></code>,
              <code class="computeroutput"><span class="identifier">lcm</span></code> are all supported.
              Use of <a class="link" href="cpp_int.html" title="cpp_int">cpp_int</a>
              in this way requires either a C++2a compiler (one which supports <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>),
              or GCC-6 or later in C++14 mode. Compilers other than GCC and without
              <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>
              will support a very limited set of operations: expect to hit roadblocks
              rather easily.
            </li>
<li class="listitem">
              You can import/export the raw bits of a <a class="link" href="cpp_int.html" title="cpp_int">cpp_int</a>
              to and from external storage via the <code class="computeroutput"><span class="identifier">import_bits</span></code>
              and <code class="computeroutput"><span class="identifier">export_bits</span></code> functions.
              More information is in the <a class="link" href="../import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float">section
              on import/export</a>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.ints.cpp_int.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.ints.cpp_int.cpp_int_eg"></a></span><a class="link" href="cpp_int.html#boost_multiprecision.tut.ints.cpp_int.cpp_int_eg">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">int128_t</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some fixed precision arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2432902008176640000 (i.e. 20!)</span>

   <span class="comment">// Repeat at arbitrary precision:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">u</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">100</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">u</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>

   <span class="comment">// prints 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 (i.e. 100!)</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">u</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../ints.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_int.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/egs/bitops.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Bit Operations</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../egs.html" title="Examples">
<link rel="prev" href="factorials.html" title="Factorials">
<link rel="next" href="../../floats.html" title="Floating-point Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="factorials.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../egs.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../floats.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.ints.egs.bitops"></a><a class="link" href="bitops.html" title="Bit Operations">Bit Operations</a>
</h5></div></div></div>
<p>
            In this example we'll show how individual bits within an integer may
            be manipulated, we'll start with an often needed calculation of <span class="emphasis"><em>2<sup>n</sup> -
            1</em></span>, which we could obviously implement like this:
          </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_int</span><span class="special">;</span>

<span class="identifier">cpp_int</span> <span class="identifier">b1</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">cpp_int</span> <span class="identifier">r</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="special">(</span><span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
            Calling:
          </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">b1</span><span class="special">(</span><span class="number">200</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
            Yields as expected:
          </p>
<pre class="programlisting">0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF</pre>
<p>
            However, we could equally just set the n'th bit in the result, like this:
          </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">b2</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">cpp_int</span> <span class="identifier">r</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="special">--</span><span class="identifier">bit_set</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">n</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
            Note how the <code class="computeroutput"><span class="identifier">bit_set</span></code>
            function sets the specified bit in its argument and then returns a reference
            to the result - which we can then simply decrement. The result from a
            call to <code class="computeroutput"><span class="identifier">b2</span></code> is the same
            as that to <code class="computeroutput"><span class="identifier">b1</span></code>.
          </p>
<p>
            We can equally test bits, so for example the n'th bit of the result returned
            from <code class="computeroutput"><span class="identifier">b2</span></code> shouldn't be
            set unless we increment it first:
          </p>
<pre class="programlisting"><span class="identifier">BOOST_MP_ASSERT</span><span class="special">(!</span><span class="identifier">bit_test</span><span class="special">(</span><span class="identifier">b1</span><span class="special">(</span><span class="number">200</span><span class="special">),</span> <span class="number">200</span><span class="special">));</span>     <span class="comment">// OK</span>
<span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">bit_test</span><span class="special">(++</span><span class="identifier">b1</span><span class="special">(</span><span class="number">200</span><span class="special">),</span> <span class="number">200</span><span class="special">));</span>    <span class="comment">// OK</span>
</pre>
<p>
            And of course if we flip the n'th bit after increment, then we should
            get back to zero:
          </p>
<pre class="programlisting"><span class="identifier">BOOST_MP_ASSERT</span><span class="special">(!</span><span class="identifier">bit_flip</span><span class="special">(++</span><span class="identifier">b1</span><span class="special">(</span><span class="number">200</span><span class="special">),</span> <span class="number">200</span><span class="special">));</span>   <span class="comment">// OK</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="factorials.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../egs.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../floats.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/egs/factorials.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Factorials</title>
<link rel="stylesheet" href="../../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../egs.html" title="Examples">
<link rel="prev" href="../egs.html" title="Examples">
<link rel="next" href="bitops.html" title="Bit Operations">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../egs.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../egs.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="bitops.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_multiprecision.tut.ints.egs.factorials"></a><a class="link" href="factorials.html" title="Factorials">Factorials</a>
</h5></div></div></div>
<p>
            In this simple example, we'll write a routine to print out all of the
            factorials which will fit into a 128-bit integer. At the end of the routine
            we do some fancy iostream formatting of the results:
          </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>


<span class="keyword">void</span> <span class="identifier">print_factorials</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_int</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Print all the factorials that will fit inside a 128-bit integer.</span>
   <span class="comment">//</span>
   <span class="comment">// Begin by building a big table of factorials, once we know just how</span>
   <span class="comment">// large the largest is, we'll be able to "pretty format" the results.</span>
   <span class="comment">//</span>
   <span class="comment">// Calculate the largest number that will fit inside 128 bits, we could</span>
   <span class="comment">// also have used numeric_limits&lt;int128_t&gt;::max() for this value:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">limit</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">128</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Our table of values:</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;</span> <span class="identifier">results</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Initial values:</span>
   <span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
   <span class="identifier">cpp_int</span> <span class="identifier">factorial</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Cycle through the factorials till we reach the limit:</span>
   <span class="keyword">while</span><span class="special">(</span><span class="identifier">factorial</span> <span class="special">&lt;</span> <span class="identifier">limit</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">results</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">);</span>
      <span class="special">++</span><span class="identifier">i</span><span class="special">;</span>
      <span class="identifier">factorial</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="comment">//</span>
   <span class="comment">// Lets see how many digits the largest factorial was:</span>
   <span class="keyword">unsigned</span> <span class="identifier">digits</span> <span class="special">=</span> <span class="identifier">results</span><span class="special">.</span><span class="identifier">back</span><span class="special">().</span><span class="identifier">str</span><span class="special">().</span><span class="identifier">size</span><span class="special">();</span>
   <span class="comment">//</span>
   <span class="comment">// Now print them out, using right justification, while we're at it</span>
   <span class="comment">// we'll indicate the limit of each integer type, so begin by defining</span>
   <span class="comment">// the limits for 16, 32, 64 etc bit integers:</span>
   <span class="identifier">cpp_int</span> <span class="identifier">limits</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span>
      <span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">16</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
      <span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">32</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
      <span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">64</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
      <span class="special">(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">128</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
   <span class="special">};</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">bit_counts</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="string">"16"</span><span class="special">,</span> <span class="string">"32"</span><span class="special">,</span> <span class="string">"64"</span><span class="special">,</span> <span class="string">"128"</span> <span class="special">};</span>
   <span class="keyword">unsigned</span> <span class="identifier">current_limit</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">j</span> <span class="special">&lt;</span> <span class="identifier">results</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">j</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="keyword">if</span><span class="special">(</span><span class="identifier">limits</span><span class="special">[</span><span class="identifier">current_limit</span><span class="special">]</span> <span class="special">&lt;</span> <span class="identifier">results</span><span class="special">[</span><span class="identifier">j</span><span class="special">])</span>
      <span class="special">{</span>
         <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">message</span> <span class="special">=</span> <span class="string">"Limit of "</span> <span class="special">+</span> <span class="identifier">bit_counts</span><span class="special">[</span><span class="identifier">current_limit</span><span class="special">]</span> <span class="special">+</span> <span class="string">" bit integers"</span><span class="special">;</span>
         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setfill</span><span class="special">(</span><span class="char">'.'</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">digits</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">right</span> <span class="special">&lt;&lt;</span> <span class="identifier">message</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setfill</span><span class="special">(</span><span class="char">' '</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
         <span class="special">++</span><span class="identifier">current_limit</span><span class="special">;</span>
      <span class="special">}</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">digits</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">right</span> <span class="special">&lt;&lt;</span> <span class="identifier">results</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
            The output from this routine is:
          </p>
<pre class="programlisting">                                       1
                                       2
                                       6
                                      24
                                     120
                                     720
                                    5040
                                   40320
................Limit of 16 bit integers
                                  362880
                                 3628800
                                39916800
                               479001600
................Limit of 32 bit integers
                              6227020800
                             87178291200
                           1307674368000
                          20922789888000
                         355687428096000
                        6402373705728000
                      121645100408832000
                     2432902008176640000
................Limit of 64 bit integers
                    51090942171709440000
                  1124000727777607680000
                 25852016738884976640000
                620448401733239439360000
              15511210043330985984000000
             403291461126605635584000000
           10888869450418352160768000000
          304888344611713860501504000000
         8841761993739701954543616000000
       265252859812191058636308480000000
      8222838654177922817725562880000000
    263130836933693530167218012160000000
   8683317618811886495518194401280000000
 295232799039604140847618609643520000000
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../egs.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../egs.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="bitops.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/egs.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Examples</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ints.html" title="Integer Types">
<link rel="prev" href="tom_int.html" title="tom_int">
<link rel="next" href="egs/factorials.html" title="Factorials">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tom_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="egs/factorials.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.ints.egs"></a><a class="link" href="egs.html" title="Examples">Examples</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="egs/factorials.html">Factorials</a></span></dt>
<dt><span class="section"><a href="egs/bitops.html">Bit Operations</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tom_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="egs/factorials.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/gmp_int.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>gmp_int</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ints.html" title="Integer Types">
<link rel="prev" href="cpp_int.html" title="cpp_int">
<link rel="next" href="tom_int.html" title="tom_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tom_int.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.ints.gmp_int"></a><a class="link" href="gmp_int.html" title="gmp_int">gmp_int</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">gmp_int</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span> <span class="special">&gt;</span>         <span class="identifier">mpz_int</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">gmp_int</span></code> back-end is
          used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">mpz_int</span></code>.
          It acts as a thin wrapper around the <a href="http://gmplib.org" target="_top">GMP</a>
          <code class="computeroutput"><span class="identifier">mpz_t</span></code> to provide an integer
          type that is a drop-in replacement for the native C++ integer types, but
          with unlimited precision.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, type
          <code class="computeroutput"><span class="identifier">mpz_int</span></code> is copy constructible
          and assignable from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://gmplib.org" target="_top">GMP</a> native types: <code class="computeroutput"><span class="identifier">mpf_t</span></code>, <code class="computeroutput"><span class="identifier">mpz_t</span></code>,
              <code class="computeroutput"><span class="identifier">mpq_t</span></code>.
            </li>
<li class="listitem">
              Instances of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> that are wrappers around those
              types: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_float</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpz_t</span></code>
          via the <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">gmp_int</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              No changes are made to the GMP library's global settings - so you can
              safely mix this type with existing code that uses <a href="http://gmplib.org" target="_top">GMP</a>.
            </li>
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">gmp_int</span></code>s
              have the value zero (this is GMP's default behavior).
            </li>
<li class="listitem">
              Formatted IO for this type does not support octal or hexadecimal notation
              for negative values, as a result performing formatted output on this
              type when the argument is negative and either of the flags <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">oct</span></code> or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">hex</span></code>
              are set, will result in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              will be thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid integer.
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Although this type is a wrapper around <a href="http://gmplib.org" target="_top">GMP</a>
              it will work equally well with <a href="http://mpir.org/" target="_top">MPIR</a>.
              Indeed use of <a href="http://mpir.org/" target="_top">MPIR</a> is recommended
              on Win32.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.ints.gmp_int.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.ints.gmp_int.example"></a></span><a class="link" href="gmp_int.html#boost_multiprecision.tut.ints.gmp_int.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">mpz_int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000!</span>

   <span class="comment">// Access the underlying representation:</span>
   <span class="identifier">mpz_t</span> <span class="identifier">z</span><span class="special">;</span>
   <span class="identifier">mpz_init</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
   <span class="identifier">mpz_set</span><span class="special">(</span><span class="identifier">z</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
   <span class="identifier">mpz_clear</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tom_int.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints/tom_int.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>tom_int</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../ints.html" title="Integer Types">
<link rel="prev" href="gmp_int.html" title="gmp_int">
<link rel="next" href="egs.html" title="Examples">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="egs.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.ints.tom_int"></a><a class="link" href="tom_int.html" title="tom_int">tom_int</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">tommath_int</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">tommath_int</span> <span class="special">&gt;</span>         <span class="identifier">tom_int</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">tommath_int</span></code> back-end
          is used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">tom_int</span></code>.
          It acts as a thin wrapper around the <a href="http://libtom.net" target="_top">libtommath</a>
          <code class="computeroutput"><span class="identifier">tom_int</span></code> to provide an integer
          type that is a drop-in replacement for the native C++ integer types, but
          with unlimited precision.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed objects have the value zero (this is <a href="http://libtom.net" target="_top">libtommath</a>'s
              default behavior).
            </li>
<li class="listitem">
              Although <code class="computeroutput"><span class="identifier">tom_int</span></code> is
              mostly a drop in replacement for the integer <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
              (built-in) types</a>, it should be noted that it is a rather strange
              beast as it's a signed type that is not a 2's complement type. As a
              result the bitwise operations <code class="computeroutput"><span class="special">|</span>
              <span class="special">&amp;</span> <span class="special">^</span></code>
              will throw a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> exception if either
              of the arguments is negative. Similarly the complement operator<code class="computeroutput"><span class="special">~</span></code> is deliberately not implemented for
              this type.
            </li>
<li class="listitem">
              Formatted IO for this type does not support octal or hexadecimal notation
              for negative values, as a result performing formatted output on this
              type when the argument is negative and either of the flags <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">oct</span></code> or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">hex</span></code>
              are set, will result in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              will be thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid integer.
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.ints.tom_int.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.ints.tom_int.example"></a></span><a class="link" href="tom_int.html#boost_multiprecision.tut.ints.tom_int.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">tom_int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000!</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000! in hex format</span>

   <span class="keyword">try</span><span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="special">-</span><span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Ooops! can't print a negative value in hex format!</span>
   <span class="special">}</span>
   <span class="keyword">catch</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="special">}</span>

   <span class="keyword">try</span><span class="special">{</span>
      <span class="comment">// v is not a 2's complement type, bitwise operations are only supported</span>
      <span class="comment">// on positive values:</span>
      <span class="identifier">v</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">v</span> <span class="special">&amp;</span> <span class="number">2</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">catch</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="special">}</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_int.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ints.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="egs.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/ints.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Integer Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="../tut.html" title="Tutorial">
<link rel="next" href="ints/cpp_int.html" title="cpp_int">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../tut.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ints/cpp_int.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.ints"></a><a class="link" href="ints.html" title="Integer Types">Integer Types</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="ints/cpp_int.html">cpp_int</a></span></dt>
<dt><span class="section"><a href="ints/gmp_int.html">gmp_int</a></span></dt>
<dt><span class="section"><a href="ints/tom_int.html">tom_int</a></span></dt>
<dt><span class="section"><a href="ints/egs.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="ints/egs/factorials.html">Factorials</a></span></dt>
<dt><span class="section"><a href="ints/egs/bitops.html">Bit Operations</a></span></dt>
</dl></dd>
</dl></div>
<p>
        The following back-ends provide integer arithmetic:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend Type
                </p>
              </th>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Radix
                </p>
              </th>
<th>
                <p>
                  Dependencies
                </p>
              </th>
<th>
                <p>
                  Pros
                </p>
              </th>
<th>
                <p>
                  Cons
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cpp_int</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/cpp_int.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  Very versatile, Boost licensed, all C++ integer type which support
                  both <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" target="_top">arbitrary
                  precision</a> and fixed precision integer types.
                </p>
              </td>
<td>
                <p>
                  Slower than <a href="http://gmplib.org" target="_top">GMP</a>, though
                  typically not as slow as <a href="http://libtom.net" target="_top">libtommath</a>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">gmp_int</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/gmp.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://gmplib.org" target="_top">GMP</a>
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end.
                </p>
              </td>
<td>
                <p>
                  Dependency on GNU licensed <a href="http://gmplib.org" target="_top">GMP</a>
                  library.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">tom_int</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/tommath.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://libtom.net" target="_top">libtommath</a>
                </p>
              </td>
<td>
                <p>
                  Public domain back-end with no licence restrictions.
                </p>
              </td>
<td>
                <p>
                  Slower than <a href="http://gmplib.org" target="_top">GMP</a>.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../tut.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ints/cpp_int.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/limits/constants.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>std::numeric_limits&lt;&gt; constants</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../limits.html" title="Numeric Limits">
<link rel="prev" href="../limits.html" title="Numeric Limits">
<link rel="next" href="functions.html" title="std::numeric_limits&lt;&gt; functions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../limits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.limits.constants"></a><a class="link" href="constants.html" title="std::numeric_limits&lt;&gt; constants">std::numeric_limits&lt;&gt;
        constants</a>
</h4></div></div></div>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_specialized"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_specialized">is_specialized</a>
        </h5>
<p>
          <code class="computeroutput"><span class="keyword">true</span></code> for all arithmetic types
          (integer, floating and fixed-point) for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">numeric_limits</span></code>
          is specialized.
        </p>
<p>
          A typical test is
        </p>
<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">false</span><span class="special">)</span>
<span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"type "</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">T</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span>  <span class="special">&lt;&lt;</span> <span class="string">" is not specialized for std::numeric_limits!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// ...</span>
<span class="special">}</span>
</pre>
<p>
          Typically <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span></code>
          is <code class="computeroutput"><span class="keyword">true</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code> where the compile-time constant members
          of <code class="computeroutput"><span class="identifier">numeric_limits</span></code> are indeed
          known at compile time, and don't vary at runtime. For example floating-point
          types with runtime-variable precision such as <code class="computeroutput"><span class="identifier">mpfr_float</span></code>
          have no <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          specialization as it would be impossible to define all the members at compile
          time. In contrast the precision of a type such as <code class="computeroutput"><span class="identifier">mpfr_float_50</span></code>
          is known at compile time, and so it <span class="emphasis"><em>does</em></span> have a <code class="computeroutput"><span class="identifier">numeric_limits</span></code> specialization.
        </p>
<p>
          Note that not all the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          member constants and functions are meaningful for all user-defined types
          (UDT), such as the decimal and binary multiprecision types provided here.
          More information on this is given in the sections below.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h1"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.infinity"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.infinity">infinity</a>
        </h5>
<p>
          For floating-point types, ∞ is defined wherever possible, but clearly infinity
          is meaningless for __arbitrary_precision arithmetic backends, and there
          is one floating-point type (GMP's <code class="computeroutput"><span class="identifier">mpf_t</span></code>,
          see <a class="link" href="../floats/gmp_float.html" title="gmp_float">gmp_float</a>)
          which has no notion of infinity or NaN at all.
        </p>
<p>
          A typical test whether infinity is implemented is
        </p>
<pre class="programlisting"><span class="keyword">if</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_infinity</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          and using tests like this is strongly recommended to improve portability.
        </p>
<div class="warning"><table border="0" summary="Warning">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../../../doc/src/images/warning.png"></td>
<th align="left">Warning</th>
</tr>
<tr><td align="left" valign="top"><p>
            If the backend is switched to a type that does not support infinity (or
            similarly NaNs) then, without checks like this, there will be trouble.
          </p></td></tr>
</table></div>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h2"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_signed"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_signed">is_signed</a>
        </h5>
<p>
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span>
          <span class="keyword">true</span></code> if the type <code class="computeroutput"><span class="identifier">T</span></code>
          is signed.
        </p>
<p>
          For <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> binary types, the sign is held in a single bit, but
          for other types (<code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          and <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code>) it may
          be a separate storage element, usually <code class="computeroutput"><span class="keyword">bool</span></code>.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h3"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_exact"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_exact">is_exact</a>
        </h5>
<p>
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span>
          <span class="keyword">true</span></code> if type T uses exact representations.
        </p>
<p>
          This is defined as <code class="computeroutput"><span class="keyword">true</span></code> for
          all integer types and <code class="computeroutput"><span class="keyword">false</span></code>
          for floating-point types.
        </p>
<p>
          <a href="http://stackoverflow.com/questions/14203654/stdnumeric-limitsis-exact-what-is-a-usable-definition" target="_top">A
          usable definition</a> has been discussed.
        </p>
<p>
          ISO/IEC 10967-1, Language independent arithmetic, noted by the C++ Standard
          defines
        </p>
<pre class="programlisting"><span class="identifier">A</span> <span class="identifier">floating</span><span class="special">-</span><span class="identifier">point</span> <span class="identifier">type</span> <span class="identifier">F</span> <span class="identifier">shall</span> <span class="identifier">be</span> <span class="identifier">a</span> <span class="identifier">finite</span> <span class="identifier">subset</span> <span class="identifier">of</span> <span class="special">[</span><span class="identifier">real</span><span class="special">].</span>
</pre>
<p>
          The important practical distinction is that all integers (up to <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code>)
          can be stored exactly.
        </p>
<p>
          <a href="http://en.wikipedia.org/wiki/Rational_number" target="_top">Rational</a>
          types using two integer types are also exact.
        </p>
<p>
          Floating-point types <span class="bold"><strong>cannot store all real values</strong></span>
          (those in the set of ℜ) <span class="bold"><strong>exactly</strong></span>. For example,
          0.5 can be stored exactly in a binary floating-point, but 0.1 cannot. What
          is stored is the nearest representable real value, that is, rounded to
          nearest.
        </p>
<p>
          Fixed-point types (usually decimal) are also defined as exact, in that
          they only store a <span class="bold"><strong>fixed precision</strong></span>, so
          half cents or pennies (or less) cannot be stored. The results of computations
          are rounded up or down, just like the result of integer division stored
          as an integer result.
        </p>
<p>
          There are number of proposals to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3407.html" target="_top">add
          Decimal floating-point Support to C++</a>.
        </p>
<p>
          <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2849.pdf" target="_top">Decimal
          TR</a>.
        </p>
<p>
          And also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html" target="_top">C++
          Binary Fixed-Point Arithmetic</a>.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h4"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_bounded"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_bounded">is_bounded</a>
        </h5>
<p>
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span>
          <span class="keyword">true</span></code> if the set of values represented
          by the type <code class="computeroutput"><span class="identifier">T</span></code> is finite.
        </p>
<p>
          This is <code class="computeroutput"><span class="keyword">true</span></code> for all <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental (built-in)
          type</a> integer, fixed and floating-point types, and most multi-precision
          types.
        </p>
<p>
          It is only <code class="computeroutput"><span class="keyword">false</span></code> for a few
          __arbitrary_precision types like <code class="computeroutput"><span class="identifier">cpp_int</span></code>.
        </p>
<p>
          Rational and fixed-exponent representations are exact but not integer.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h5"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.is_modulo"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.is_modulo">is_modulo</a>
        </h5>
<p>
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_modulo</span></code> is defined as <code class="computeroutput"><span class="keyword">true</span></code> if adding two positive values of type
          T can yield a result less than either value.
        </p>
<p>
          <code class="computeroutput"><span class="identifier">is_modulo</span> <span class="special">==</span>
          <span class="keyword">true</span></code> means that the type does not
          overflow, but, for example, 'wraps around' to zero, when adding one to
          the <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code>
          value.
        </p>
<p>
          For most <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> integer types, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">is_modulo</span></code>
          is <code class="computeroutput"><span class="keyword">true</span></code>.
        </p>
<p>
          <code class="computeroutput"><span class="keyword">bool</span></code> is the only exception.
        </p>
<p>
          The modulo behaviour is sometimes useful, but also can be unexpected, and
          sometimes undesired, behaviour.
        </p>
<p>
          Overflow of signed integers can be especially unexpected, possibly causing
          change of sign.
        </p>
<p>
          Boost.Multiprecision integer type <code class="computeroutput"><span class="identifier">cpp_int</span></code>
          is not modulo because as an __arbitrary_precision types, it expands to
          hold any value that the machine resources permit.
        </p>
<p>
          However fixed precision <a class="link" href="../ints/cpp_int.html" title="cpp_int">cpp_int</a>'s
          may be modulo if they are unchecked (i.e. they behave just like <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental (built-in)</a>
          integers), but not if they are checked (overflow causes an exception to
          be raised).
        </p>
<p>
          <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> and multi-precision floating-point types are normally
          not modulo.
        </p>
<p>
          Where possible, overflow is to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">infinity</span><span class="special">()</span></code>, provided <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">has_infinity</span>
          <span class="special">==</span> <span class="keyword">true</span></code>.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h6"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.radix"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.radix">radix</a>
        </h5>
<p>
          Constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">radix</span></code> returns either 2 (for <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> and binary types) or 10 (for decimal types).
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h7"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.digits"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.digits">digits</a>
        </h5>
<p>
          The number of <code class="computeroutput"><span class="identifier">radix</span></code> digits
          that be represented without change:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              for integer types, the number of <span class="bold"><strong>non-sign bits</strong></span>
              in the significand.
            </li>
<li class="listitem">
              for floating types, the number of <span class="bold"><strong>radix digits</strong></span>
              in the significand.
            </li>
</ul></div>
<p>
          The values include any implicit bit, so for example, for the ubiquious
          <code class="computeroutput"><span class="keyword">double</span></code> using 64 bits (<a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" target="_top">IEEE
          binary64 </a>), <code class="computeroutput"><span class="identifier">digits</span></code>
          == 53, even though there are only 52 actual bits of the significand stored
          in the representation. The value of <code class="computeroutput"><span class="identifier">digits</span></code>
          reflects the fact that there is one implicit bit which is always set to
          1.
        </p>
<p>
          The Boost.Multiprecision binary types do not use an implicit bit, so the
          <code class="computeroutput"><span class="identifier">digits</span></code> member reflects
          exactly how many bits of precision were requested:
        </p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">53</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span>   <span class="identifier">float64</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float</span><span class="special">&lt;</span><span class="number">113</span><span class="special">,</span> <span class="identifier">digit_base_2</span><span class="special">&gt;</span> <span class="special">&gt;</span>  <span class="identifier">float128</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float64</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">==</span> <span class="number">53.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">==</span> <span class="number">113.</span>
</pre>
<p>
          For the most common case of <code class="computeroutput"><span class="identifier">radix</span>
          <span class="special">==</span> <span class="number">2</span></code>,
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span></code> is the number of bits in the representation,
          not counting any sign bit.
        </p>
<p>
          For a decimal integer type, when <code class="computeroutput"><span class="identifier">radix</span>
          <span class="special">==</span> <span class="number">10</span></code>,
          it is the number of decimal digits.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h8"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.digits10"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.digits10">digits10</a>
        </h5>
<p>
          Constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span></code> returns the number of decimal
          digits that can be represented without change or loss.
        </p>
<p>
          For example, <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">digits10</span></code> is 2.
        </p>
<p>
          This somewhat inscrutable definition means that an <code class="computeroutput"><span class="keyword">unsigned</span>
          <span class="keyword">char</span></code> can hold decimal values <code class="computeroutput"><span class="number">0.</span><span class="special">.</span><span class="number">99</span></code>
          without loss of precision or accuracy, usually from truncation.
        </p>
<p>
          Had the definition been 3 then that would imply it could hold 0..999, but
          as we all know, an 8-bit <code class="computeroutput"><span class="keyword">unsigned</span>
          <span class="keyword">char</span></code> can only hold 0..255, and an
          attempt to store 256 or more will involve loss or change.
        </p>
<p>
          For bounded integers, it is thus <span class="bold"><strong>one less</strong></span>
          than number of decimal digits you need to display the biggest integer
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>.
          This value can be used to predict the layout width required for
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpos</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="comment">// +32767</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span>
  <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">)()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>   <span class="comment">// -32767</span>
</pre>
<p>
          For example, <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">short</span></code>
          is often stored in 16 bits, so the maximum value is 0xFFFF or 65535.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpos</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="comment">//  65535</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span><span class="number">1</span> <span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="comment">// digits10+1, and +1 for sign.</span>
  <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">short</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">)()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>   <span class="comment">//      0</span>
</pre>
<p>
          For bounded floating-point types, if we create a <code class="computeroutput"><span class="keyword">double</span></code>
          with a value with <code class="computeroutput"><span class="identifier">digits10</span></code>
          (usually 15) decimal digits, <code class="computeroutput"><span class="number">1e15</span></code>
          or <code class="computeroutput"><span class="number">1000000000000000</span></code> :
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span>  <span class="number">1e15</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">dp1</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="number">1</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// 1000000000000000</span>
<span class="comment">// 1000000000000001</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span>  <span class="identifier">dp1</span> <span class="special">-</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1</span>
</pre>
<p>
          and we can increment this value to <code class="computeroutput"><span class="number">1000000000000001</span></code>
          as expected and show the difference too.
        </p>
<p>
          But if we try to repeat this with more than <code class="computeroutput"><span class="identifier">digits10</span></code>
          digits,
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span>  <span class="number">1e16</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">dp1</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="number">1</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// 10000000000000000</span>
<span class="comment">// 10000000000000000</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dp1</span> <span class="special">-</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 0 !!!</span>
</pre>
<p>
          then we find that when we add one it has no effect, and display show that
          there is loss of precision. See <a href="http://en.wikipedia.org/wiki/Loss_of_significance" target="_top">Loss
          of significance or cancellation error</a>.
        </p>
<p>
          So <code class="computeroutput"><span class="identifier">digits10</span></code> is the number
          of decimal digits <span class="bold"><strong>guaranteed</strong></span> to be correct.
        </p>
<p>
          For example, 'round-tripping' for <code class="computeroutput"><span class="keyword">double</span></code>:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              If a decimal string with at most <code class="computeroutput"><span class="identifier">digits10</span></code>(
              == 15) significant decimal digits is converted to <code class="computeroutput"><span class="keyword">double</span></code>
              and then converted back to the same number of significant decimal digits,
              then the final string will match the original 15 decimal digit string.
            </li>
<li class="listitem">
              If a <code class="computeroutput"><span class="keyword">double</span></code> floating-point
              number is converted to a decimal string with at least 17 decimal digits
              and then converted back to <code class="computeroutput"><span class="keyword">double</span></code>,
              then the result will be binary identical to the original <code class="computeroutput"><span class="keyword">double</span></code> value.
            </li>
</ul></div>
<p>
          For most purposes, you will much more likely want <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">max_digits10</span></code>,
          the number of decimal digits that ensure that a change of one least significant
          bit (<a href="http://en.wikipedia.org/wiki/Unit_in_the_last_place" target="_top">Unit
          in the last place (ULP)</a>) produces a different decimal digits string.
        </p>
<p>
          For the most common <code class="computeroutput"><span class="keyword">double</span></code>
          floating-point type,<code class="computeroutput"><span class="identifier">max_digits10</span></code>
          is <code class="computeroutput"><span class="identifier">digits10</span><span class="special">+</span><span class="number">2</span></code>, but you should use C++11 <code class="computeroutput"><span class="identifier">max_digits10</span></code> where possible (see <a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.max_digits10">below</a>).
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h9"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.max_digits10"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.max_digits10">max_digits10</a>
        </h5>
<p>
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code> was added for floating-point
          because <code class="computeroutput"><span class="identifier">digits10</span></code> decimal
          digits are insufficient to show a least significant bit (ULP) change giving
          puzzling displays like
        </p>
<pre class="programlisting"><span class="number">0.666666666666667</span> <span class="special">!=</span> <span class="number">0.666666666666667</span>
</pre>
<p>
          from failure to 'round-trip', for example:
        </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">write</span> <span class="special">=</span> <span class="number">2.</span><span class="special">/</span><span class="number">3</span><span class="special">;</span> <span class="comment">// Any arbitrary value that cannot be represented exactly.</span>
<span class="keyword">double</span> <span class="identifier">read</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">s</span><span class="special">;</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span> <span class="comment">// or `float64_t` for 64-bit IEE754 double.</span>
<span class="identifier">s</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span><span class="special">;</span>
<span class="identifier">s</span> <span class="special">&gt;&gt;</span> <span class="identifier">read</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">read</span> <span class="special">!=</span> <span class="identifier">write</span><span class="special">)</span>
<span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span>  <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">)</span>
    <span class="special">&lt;&lt;</span> <span class="identifier">read</span> <span class="special">&lt;&lt;</span> <span class="string">" != "</span> <span class="special">&lt;&lt;</span> <span class="identifier">write</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          If you wish to ensure that a change of one least significant bit (ULP)
          produces a different decimal digits string, then <code class="computeroutput"><span class="identifier">max_digits10</span></code>
          is the precision to use.
        </p>
<p>
          For example:
        </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">double_constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 3.1415926535897931</span>
</pre>
<p>
          will display π to the maximum possible precision using a <code class="computeroutput"><span class="keyword">double</span></code>.
        </p>
<p>
          and similarly for a much higher precision type:
        </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span> <span class="comment">// 50 decimal digits.</span>

<span class="comment">// or using boost::multiprecision::cpp_dec_float_50;</span>

<span class="identifier">cpp_dec_float_50</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// 3.141592653589793238462643383279502884197169399375105820974944592307816406</span>
</pre>
<p>
          For integer types, <code class="computeroutput"><span class="identifier">max_digits10</span></code>
          is implementation-dependent, but is usually <code class="computeroutput"><span class="identifier">digits10</span>
          <span class="special">+</span> <span class="number">2</span></code>.
          This is the output field-width required for the maximum value of the type
          T <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span></code>
          <span class="emphasis"><em>including a sign and a space</em></span>.
        </p>
<p>
          So this will produce neat columns.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setw</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span> <span class="special">...</span>
</pre>
<p>
          The extra two or three least-significant digits are 'noisy' and may be
          junk, but if you want to 'round-trip' - printing a value out as a decimal
          digit string and reading it back in - (most commonly during serialization
          and de-serialization) you must use <code class="computeroutput"><span class="identifier">os</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span></code>.
        </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            For Microsoft Visual Studio 2010, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span></code>
            is wrongly defined as 8. It should be 9.
          </p></td></tr>
</table></div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top">
<p>
            For Microsoft Visual Studio before 2013 and the default floating-point
            format, a small range of double-precision floating-point values with
            a significand of approximately 0.0001 to 0.004 and exponent values of
            1010 to 1014 do not round-trip exactly being off by one least significant
            bit, for probably every third value of the significand.
          </p>
<p>
            A workaround is using the scientific or exponential format <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">scientific</span></code>.
          </p>
<p>
            Other older compilers also fail to implement round-tripping entirely
            fault-free, for example, see <a href="https://www.exploringbinary.com/incorrectly-rounded-conversions-in-gcc-and-glibc/" target="_top">Incorrectly
            Rounded Conversions in GCC and GLIBC</a>.
          </p>
<p>
            For more details see <a href="https://www.exploringbinary.com/incorrect-round-trip-conversions-in-visual-c-plus-plus/" target="_top">Incorrect
            Round-Trip Conversions in Visual C++</a>, and references therein
            and <a href="https://arxiv.org/pdf/1310.8121.pdf" target="_top">Easy Accurate Reading
            and Writing of Floating-Point Numbers, Aubrey Jaffer (August 2018)</a>.
          </p>
<p>
            Microsoft VS2017 and other recent compilers, now use the <a href="https://doi.org/10.1145/3192366.3192369" target="_top">Ryu
            fast float-to-string conversion by Ulf Adams</a> algorithm, claimed
            to be both exact and fast for 32 and 64-bit floating-point numbers.
          </p>
</td></tr>
</table></div>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h10"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.round_style"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.round_style">round_style</a>
        </h5>
<p>
          The rounding style determines how the result of floating-point operations
          is treated when the result cannot be <span class="bold"><strong>exactly represented</strong></span>
          in the significand. Various rounding modes may be provided:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              round to nearest up or down (default for floating-point types).
            </li>
<li class="listitem">
              round up (toward positive infinity).
            </li>
<li class="listitem">
              round down (toward negative infinity).
            </li>
<li class="listitem">
              round toward zero (integer types).
            </li>
<li class="listitem">
              no rounding (if decimal radix).
            </li>
<li class="listitem">
              rounding mode is not determinable.
            </li>
</ul></div>
<p>
          For integer types, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span></code>
          is always towards zero, so
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_to_zero</span><span class="special">;</span>
</pre>
<p>
          A decimal type, <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          rounds in no particular direction, which is to say it doesn't round at
          all. And since there are several guard digits, it's not really the same
          as truncation (round toward zero) either.
        </p>
<p>
          For floating-point types, it is normal to round to nearest.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_to_nearest</span><span class="special">;</span>
</pre>
<p>
          See function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_error</span></code> for the maximum error (in
          ULP) that rounding can cause.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h11"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.has_denorm_loss"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.has_denorm_loss">has_denorm_loss</a>
        </h5>
<p>
          <code class="computeroutput"><span class="keyword">true</span></code> if a loss of precision
          is detected as a <a href="http://en.wikipedia.org/wiki/Denormalization" target="_top">denormalization</a>
          loss, rather than an inexact result.
        </p>
<p>
          Always <code class="computeroutput"><span class="keyword">false</span></code> for integer types.
        </p>
<p>
          <code class="computeroutput"><span class="keyword">false</span></code> for all types which
          do not have <code class="computeroutput"><span class="identifier">has_denorm</span></code>
          == <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span></code>.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h12"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.denorm_style"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.denorm_style">denorm_style</a>
        </h5>
<p>
          <a href="http://en.wikipedia.org/wiki/Denormal_number" target="_top">Denormalized
          values</a> are representations with a variable number of exponent bits
          that can permit gradual underflow, so that, if type T is <code class="computeroutput"><span class="keyword">double</span></code>.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span>
</pre>
<p>
          A type may have any of the following <code class="computeroutput"><span class="keyword">enum</span>
          <span class="identifier">float_denorm_style</span></code> values:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_absent</span></code>, if it does not allow
              denormalized values. (Always used for all integer and exact types).
            </li>
<li class="listitem">
              <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span></code>, if the floating-point
              type allows denormalized values.
            </li>
<li class="listitem">
              <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_indeterminate</span></code>, if indeterminate
              at compile time.
            </li>
</ul></div>
<h5>
<a name="boost_multiprecision.tut.limits.constants.h13"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.constants.tinyness_before_rounding"></a></span><a class="link" href="constants.html#boost_multiprecision.tut.limits.constants.tinyness_before_rounding">Tinyness
          before rounding</a>
        </h5>
<p>
          <code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">tinyness_before</span></code>
        </p>
<p>
          <code class="computeroutput"><span class="keyword">true</span></code> if a type can determine
          that a value is too small to be represent as a normalized value before
          rounding it.
        </p>
<p>
          Generally true for <code class="computeroutput"><span class="identifier">is_iec559</span></code>
          floating-point __fundamantal types, but false for integer types.
        </p>
<p>
          Standard-compliant IEEE 754 floating-point implementations may detect the
          floating-point underflow at three predefined moments:
        </p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
              After computation of a result with absolute value smaller than <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code>,
              such implementation detects <span class="emphasis"><em>tinyness before rounding</em></span>
              (e.g. UltraSparc).
            </li>
<li class="listitem">
              After rounding of the result to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits</span></code>
              bits, if the result is tiny, such implementation detects <span class="emphasis"><em>tinyness
              after rounding</em></span> (e.g. SuperSparc).
            </li>
<li class="listitem">
              If the conversion of the rounded tiny result to subnormal form resulted
              in the loss of precision, such implementation detects <span class="emphasis"><em>denorm
              loss</em></span>.
            </li>
</ol></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../limits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/limits/functions.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>std::numeric_limits&lt;&gt; functions</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../limits.html" title="Numeric Limits">
<link rel="prev" href="constants.html" title="std::numeric_limits&lt;&gt; constants">
<link rel="next" href="limits32.html" title="Numeric limits for 32-bit platform">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="constants.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits32.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.limits.functions"></a><a class="link" href="functions.html" title="std::numeric_limits&lt;&gt; functions"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> functions</a>
</h4></div></div></div>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.max_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.max_function"><code class="computeroutput"><span class="identifier">max</span></code> function</a>
        </h5>
<p>
          Function <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span></code> returns the largest finite value that
          can be represented by the type T. If there is no such value (and <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">bounded</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>)
          then returns <code class="computeroutput"><span class="identifier">T</span><span class="special">()</span></code>.
        </p>
<p>
          For <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> types there is usually a corresponding MACRO value TYPE_MAX,
          where TYPE is CHAR, INT, FLOAT etc.
        </p>
<p>
          Other types, including those provided by a typedef, for example <code class="computeroutput"><span class="identifier">INT64_T_MAX</span></code> for <code class="computeroutput"><span class="identifier">int64_t</span></code>,
          may provide a macro definition.
        </p>
<p>
          To cater for situations where no <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          specialization is available (for example because the precision of the type
          varies at runtime), packaged versions of this (and other functions) are
          provided using
        </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">T</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">max_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
</pre>
<p>
          Of course, these simply use <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span></code>
          if available, but otherwise 'do something sensible'.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h1"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.lowest_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.lowest_function">lowest
          function</a>
        </h5>
<p>
          Since C++11: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">()</span></code>
          is
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              For integral types, the same as function <code class="computeroutput"><span class="identifier">min</span><span class="special">()</span></code>.
            </li>
<li class="listitem">
              For floating-point types, generally the negative of <code class="computeroutput"><span class="identifier">max</span><span class="special">()</span></code> (but implementation-dependent).
            </li>
</ul></div>
<pre class="programlisting"><span class="special">-(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)()</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">();</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h2"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.min_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.min_function"><code class="computeroutput"><span class="identifier">min</span></code> function</a>
        </h5>
<p>
          Function <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">)()</span></code> returns the minimum finite value that
          can be represented by the type T.
        </p>
<p>
          For <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> types, there is usually a corresponding MACRO value
          TYPE_MIN, where TYPE is CHAR, INT, FLOAT etc.
        </p>
<p>
          Other types, including those provided by a <code class="computeroutput"><span class="keyword">typedef</span></code>,
          for example, <code class="computeroutput"><span class="identifier">INT64_T_MIN</span></code>
          for <code class="computeroutput"><span class="identifier">int64_t</span></code>, may provide
          a macro definition.
        </p>
<p>
          For floating-point types, it is more fully defined as the <span class="emphasis"><em>minimum
          positive normalized value</em></span>.
        </p>
<p>
          See <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span></code>
          for the smallest denormalized value, provided
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span>
</pre>
<p>
          To cater for situations where no <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          specialization is available (for example because the precision of the type
          varies at runtime), packaged versions of this (and other functions) are
          provided using
        </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">T</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">min_value</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;();</span>
</pre>
<p>
          Of course, these simply use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span></code> if available.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h3"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.denorm_min_function"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.denorm_min_function">denorm_min
          function</a>
        </h5>
<p>
          Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">()</span></code>
          returns the smallest <a href="http://en.wikipedia.org/wiki/Denormal_number" target="_top">denormalized
          value</a>, provided
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span>
</pre>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">has_denorm</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_present</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">denorm_min</span><span class="special">();</span>

    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//  4.9406564584124654e-324</span>

    <span class="keyword">int</span> <span class="identifier">exponent</span><span class="special">;</span>

    <span class="keyword">double</span> <span class="identifier">significand</span> <span class="special">=</span> <span class="identifier">frexp</span><span class="special">(</span><span class="identifier">d</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">exponent</span><span class="special">);</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"exponent = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">exponent</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//  fffffbcf</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"significand = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">significand</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 0.50000000000000000</span>
<span class="special">}</span>
<span class="keyword">else</span>
<span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"No denormalization. "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          The exponent is effectively reduced from -308 to -324 (though it remains
          encoded as zero and leading zeros appear in the significand, thereby losing
          precision until the significand reaches zero).
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h4"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.round_error"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.round_error">round_error</a>
        </h5>
<p>
          Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">round_error</span><span class="special">()</span></code>
          returns the maximum error (in units of <a href="http://en.wikipedia.org/wiki/Unit_in_the_last_place" target="_top">Unit
          in the last place (ULP)</a>) that can be caused by any basic arithmetic
          operation.
        </p>
<pre class="programlisting"><span class="identifier">round_style</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">round_indeterminate</span><span class="special">;</span>
</pre>
<p>
          The rounding style is indeterminable at compile time.
        </p>
<p>
          For floating-point types, when rounding is to nearest, only half a bit
          is lost by rounding, and <code class="computeroutput"><span class="identifier">round_error</span>
          <span class="special">==</span> <span class="number">0.5</span></code>.
          In contrast when rounding is towards zero, or plus/minus infinity, we can
          loose up to one bit from rounding, and <code class="computeroutput"><span class="identifier">round_error</span>
          <span class="special">==</span> <span class="number">1</span></code>.
        </p>
<p>
          For integer types, rounding always to zero, so at worst almost one bit
          can be rounded, so <code class="computeroutput"><span class="identifier">round_error</span>
          <span class="special">==</span> <span class="number">1</span></code>.
        </p>
<p>
          <code class="computeroutput"><span class="identifier">round_error</span><span class="special">()</span></code>
          can be used with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code>
          to estimate the maximum potential error caused by rounding. For typical
          floating-point types, <code class="computeroutput"><span class="identifier">round_error</span><span class="special">()</span> <span class="special">=</span> <span class="number">1</span><span class="special">/</span><span class="number">2</span></code>, so half
          epsilon is the maximum potential error.
        </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">round_err</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span> <span class="comment">// 2.2204460492503131e-016</span>
                 <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">round_error</span><span class="special">();</span> <span class="comment">// 1/2</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">round_err</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.1102230246251565e-016</span>
</pre>
<p>
          There are, of course, many occasions when much bigger loss of precision
          occurs, for example, caused by <a href="http://en.wikipedia.org/wiki/Loss_of_significance" target="_top">Loss
          of significance or cancellation error</a> or very many iterations.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h5"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.epsilon"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.epsilon">epsilon</a>
        </h5>
<p>
          Function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code>
          is meaningful only for non-integral types.
        </p>
<p>
          It returns the difference between <code class="computeroutput"><span class="number">1.0</span></code>
          and the next value representable by the floating-point type T. So it is
          a one least-significant-bit change in this floating-point value.
        </p>
<p>
          For <code class="computeroutput"><span class="keyword">double</span></code> (<code class="computeroutput"><span class="identifier">float_64t</span></code>) it is <code class="computeroutput"><span class="number">2.2204460492503131e-016</span></code>
          showing all possibly significant 17 decimal digits.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">eps</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">dpeps</span> <span class="special">=</span> <span class="identifier">d</span><span class="special">+</span><span class="identifier">eps</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="comment">// Ensure all trailing zeros are shown.</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">d</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span>           <span class="comment">// 1.0000000000000000</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 2.2204460492503131e-016</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">-</span> <span class="identifier">d</span>   <span class="comment">// 1.0000000000000002</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          We can explicitly increment by one bit using the function <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">float_next</span><span class="special">()</span></code>
          and the result is the same as adding <code class="computeroutput"><span class="identifier">epsilon</span></code>.
        </p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">one</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">nad</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">float_next</span><span class="special">(</span><span class="identifier">one</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">nad</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span>  <span class="comment">//  1.0000000000000002</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">nad</span> <span class="special">-</span> <span class="identifier">one</span> <span class="comment">// 2.2204460492503131e-016</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          Adding any smaller value, like half <code class="computeroutput"><span class="identifier">epsilon</span></code>,
          will have no effect on this value.
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">eps</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">dpeps</span> <span class="special">=</span> <span class="identifier">d</span> <span class="special">+</span> <span class="identifier">eps</span><span class="special">/</span><span class="number">2</span><span class="special">;</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="comment">// Ensure all trailing zeros are shown.</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span>       <span class="comment">// 1.0000000000000000</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">eps</span><span class="special">/</span><span class="number">2</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.1102230246251565e-016</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">dpeps</span> <span class="special">-</span> <span class="identifier">d</span>   <span class="comment">// 0.00000000000000000</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          So this cancellation error leaves the values equal, despite adding half
          <code class="computeroutput"><span class="identifier">epsilon</span></code>.
        </p>
<p>
          To achieve greater portability over platform and floating-point type, Boost.Math
          and Boost.Multiprecision provide a package of functions that 'do something
          sensible' if the standard <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          is not available. To use these <code class="computeroutput"><span class="preprocessor">#include</span>
          <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">precision</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
        </p>
<p>
          A tolerance might be defined using this version of epsilon thus:
        </p>
<pre class="programlisting"><span class="identifier">RealType</span> <span class="identifier">tolerance</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tools</span><span class="special">::</span><span class="identifier">epsilon</span><span class="special">&lt;</span><span class="identifier">RealType</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="number">2</span><span class="special">;</span>
</pre>
<h6>
<a name="boost_multiprecision.tut.limits.functions.h6"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.FP_tolerance"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.FP_tolerance">Tolerance
          for Floating-point Comparisons</a>
        </h6>
<p>
          <a href="https://en.wikipedia.org/wiki/Machine_epsilon" target="_top">Machine epsilon
          ε</a> is very useful to compute a tolerance when comparing floating-point
          values, a much more difficult task than is commonly imagined.
        </p>
<p>
          The C++ standard specifies <a href="https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;::</span><span class="identifier">epsilon</span><span class="special">()</span></code></a>
          and Boost.Multiprecision implements this (where possible) for its program-defined
          types analogous to the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> floating-point types like <code class="computeroutput"><span class="keyword">double</span></code>
          <code class="computeroutput"><span class="keyword">float</span></code>.
        </p>
<p>
          For more information than you probably want (but still need) see <a href="http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" target="_top">What
          Every Computer Scientist Should Know About Floating-Point Arithmetic</a>
        </p>
<p>
          The naive test comparing the absolute difference between two values and
          a tolerance does not give useful results if the values are too large or
          too small.
        </p>
<p>
          So Boost.Test uses an algorithm first devised by Knuth for reliably checking
          if floating-point values are close enough.
        </p>
<p>
          See Donald. E. Knuth. The art of computer programming (vol II). Copyright
          1998 Addison-Wesley Longman, Inc., 0-201-89684-2. Addison-Wesley Professional;
          3rd edition. (The relevant equations are in paragraph 4.2.2, Eq. 36 and
          37.)
        </p>
<p>
          See <a href="https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/testing_tools/extended_comparison/floating_point/floating_points_comparison_theory.html" target="_top">Boost.Math
          floating_point comparison</a> for more details.
        </p>
<p>
          See also:
        </p>
<p>
          <a href="http://adtmag.com/articles/2000/03/15/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target="_top">Alberto
          Squassia, Comparing floats</a>
        </p>
<p>
          <a href="http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target="_top">Alberto
          Squassia, Comparing floats code</a>
        </p>
<p>
          <a href="https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/testing_tools/extended_comparison/floating_point.html" target="_top">Boost.Test
          Floating-Point_Comparison</a>
        </p>
<p>
          For example, if we want a tolerance that might suit about 9 arithmetical
          operations, say sqrt(9) = 3, we could define:
        </p>
<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">tolerance</span> <span class="special">=</span>  <span class="number">3</span> <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
</pre>
<p>
          This is very widely used in Boost.Math testing with Boost.Test's macro
          <code class="computeroutput"><span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span></code>
        </p>
<pre class="programlisting"><span class="identifier">T</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="identifier">T</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>

<span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
</pre>
<p>
          used thus:
        </p>
<pre class="programlisting"><span class="identifier">cd</span> <span class="special">./</span><span class="identifier">test</span>
<span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
</pre>
<p>
          (There is also a version BOOST_CHECK_CLOSE using tolerance as a <span class="bold"><strong>percentage</strong></span> rather than a fraction; usually the fraction
          version is simpler to use).
        </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">number</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">et_off</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;,</span> <span class="identifier">et_off</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span> <span class="comment">// 50 decimal digits.</span>
</pre>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            that Boost.Test does not yet allow floating-point comparisons with expression
            templates on, so the default expression template parameter has been replaced
            by <code class="computeroutput"><span class="identifier">et_off</span></code>.
          </p></td></tr>
</table></div>
<pre class="programlisting"><span class="identifier">cpp_dec_float_50</span> <span class="identifier">tolerance</span> <span class="special">=</span>  <span class="number">3</span> <span class="special">*</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">();</span>
<span class="identifier">cpp_dec_float_50</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">two_pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>
<span class="identifier">cpp_dec_float_50</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_50</span><span class="special">&gt;();</span>

<span class="identifier">BOOST_CHECK_CLOSE_FRACTION</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">,</span> <span class="identifier">tolerance</span><span class="special">);</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h7"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.infinity"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.infinity">Infinity -
          positive and negative</a>
        </h5>
<p>
          For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_infinity</span>
          <span class="special">==</span> <span class="keyword">true</span></code>,
          function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">()</span></code>
          provides an implementation-defined representation for ∞.
        </p>
<p>
          The 'representation' is a particular bit pattern reserved for infinity.
          For IEEE754 system (for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_iec559</span>
          <span class="special">==</span> <span class="keyword">true</span></code>)
          <a href="http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity" target="_top">positive
          and negative infinity</a> are assigned bit patterns for all defined
          floating-point types.
        </p>
<p>
          Confusingly, the string resulting from outputting this representation,
          is also implementation-defined. And the string that can be input to generate
          the representation is also implementation-defined.
        </p>
<p>
          For example, the output is <code class="computeroutput"><span class="number">1.</span><span class="special">#</span><span class="identifier">INF</span></code>
          on Microsoft systems, but <code class="computeroutput"><span class="identifier">inf</span></code>
          on most *nix platforms.
        </p>
<p>
          This implementation-defined-ness has hampered use of infinity (and NaNs)
          but <a href="https://www.boost.org/doc/libs/release/libs/math/doc/index.html" target="_top">Boost.Math</a>
          and <a href="https://www.boost.org/doc/libs/release/libs/multiprecision/doc/index.html" target="_top">Boost.Multiprecision</a>
          work hard to provide a sensible representation for <span class="bold"><strong>all</strong></span>
          floating-point types, not just the <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in) types</a>, which with the use of suitable facets to define
          the input and output strings, makes it possible to use these useful features
          portably and including <a href="https://www.boost.org/doc/libs/release/libs/serialization/doc/index.html" target="_top">Boost.Serialization</a>.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.functions.h8"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.not_a_number_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.not_a_number_nan">Not-A-Number
          NaN</a>
        </h5>
<h6>
<a name="boost_multiprecision.tut.limits.functions.h9"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.quiet_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.quiet_nan">Quiet_NaN</a>
        </h6>
<p>
          For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_quiet_NaN</span>
          <span class="special">==</span> <span class="keyword">true</span></code>,
          function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">()</span></code>
          provides an implementation-defined representation for NaN.
        </p>
<p>
          <a href="http://en.wikipedia.org/wiki/NaN" target="_top">NaNs</a> are values to
          indicate that the result of an assignment or computation is meaningless.
          A typical example is <code class="computeroutput"><span class="number">0</span><span class="special">/</span><span class="number">0</span></code> but there are many others.
        </p>
<p>
          NaNs may also be used, to represent missing values: for example, these
          could, by convention, be ignored in calculations of statistics like means.
        </p>
<p>
          Many of the problems with a representation for <a href="http://en.wikipedia.org/wiki/NaN" target="_top">Not-A-Number</a>
          has hampered portable use, similar to those with infinity.
        </p>
<p>
          NaN can be used with binary multiprecision types like <code class="computeroutput"><span class="identifier">cpp_bin_float_quad</span></code>:
        </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>

<span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;::</span><span class="identifier">has_quiet_NaN</span> <span class="special">==</span> <span class="keyword">true</span><span class="special">)</span>
<span class="special">{</span>
  <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">NaN</span> <span class="special">=</span>  <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cpp_bin_float_quad NaN is "</span>  <span class="special">&lt;&lt;</span> <span class="identifier">NaN</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//   cpp_bin_float_quad NaN is nan</span>

  <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">expected</span> <span class="special">=</span> <span class="identifier">NaN</span><span class="special">;</span>
  <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">calculated</span> <span class="special">=</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">NaN</span><span class="special">;</span>
  <span class="comment">// Comparisons of NaN's always fail:</span>
  <span class="keyword">bool</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">expected</span> <span class="special">==</span> <span class="identifier">calculated</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">b</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
  <span class="identifier">BOOST_CHECK_NE</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">expected</span><span class="special">);</span>
  <span class="identifier">BOOST_CHECK_NE</span><span class="special">(</span><span class="identifier">expected</span><span class="special">,</span> <span class="identifier">calculated</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">else</span>
<span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Type "</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">cpp_bin_float_quad</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">" does not have NaNs!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          But using Boost.Math and suitable facets can permit portable use of both
          NaNs and positive and negative infinity.
        </p>
<p>
          See <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../../../libs/math/example/nonfinite_facet_sstream.cpp" target="_top">boost:/libs/math/example/nonfinite_facet_sstream.cpp</a>
          and we also need
        </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">nonfinite_num_facets</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
          Then we can equally well use a multiprecision type cpp_bin_float_quad:
        </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_bin_float_quad</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">cpp_bin_float_quad</span> <span class="identifier">T</span><span class="special">;</span>

<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">nonfinite_num_put</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">nonfinite_num_get</span><span class="special">;</span>
<span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">old_locale</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">tmp_locale</span><span class="special">(</span><span class="identifier">old_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_put</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">new_locale</span><span class="special">(</span><span class="identifier">tmp_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_get</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
  <span class="identifier">ss</span><span class="special">.</span><span class="identifier">imbue</span><span class="special">(</span><span class="identifier">new_locale</span><span class="special">);</span>
  <span class="identifier">T</span> <span class="identifier">inf</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">();</span>
  <span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">inf</span><span class="special">;</span> <span class="comment">// Write out.</span>
 <span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">==</span> <span class="string">"inf"</span><span class="special">);</span>
  <span class="identifier">T</span> <span class="identifier">r</span><span class="special">;</span>
  <span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">r</span><span class="special">;</span> <span class="comment">// Read back in.</span>
  <span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">inf</span> <span class="special">==</span> <span class="identifier">r</span><span class="special">);</span> <span class="comment">// Confirms that the floating-point values really are identical.</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"infinity output was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"infinity input was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<pre class="programlisting"><span class="identifier">infinity</span> <span class="identifier">output</span> <span class="identifier">was</span> <span class="identifier">inf</span>
<span class="identifier">infinity</span> <span class="identifier">input</span> <span class="identifier">was</span> <span class="identifier">inf</span>
</pre>
<p>
          Similarly we can do the same with NaN (except that we cannot use <code class="computeroutput"><span class="identifier">assert</span></code> (because any comparisons with
          NaN always return false).
        </p>
<pre class="programlisting"><span class="special">{</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">old_locale</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">tmp_locale</span><span class="special">(</span><span class="identifier">old_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_put</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">new_locale</span><span class="special">(</span><span class="identifier">tmp_locale</span><span class="special">,</span> <span class="keyword">new</span> <span class="identifier">nonfinite_num_get</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;);</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span> <span class="identifier">ss</span><span class="special">;</span>
  <span class="identifier">ss</span><span class="special">.</span><span class="identifier">imbue</span><span class="special">(</span><span class="identifier">new_locale</span><span class="special">);</span>
  <span class="identifier">T</span> <span class="identifier">n</span><span class="special">;</span>
  <span class="identifier">T</span> <span class="identifier">NaN</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
  <span class="identifier">ss</span> <span class="special">&lt;&lt;</span> <span class="identifier">NaN</span><span class="special">;</span> <span class="comment">// Write out.</span>
  <span class="identifier">BOOST_MP_ASSERT</span><span class="special">(</span><span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">==</span> <span class="string">"nan"</span><span class="special">);</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"NaN output was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ss</span><span class="special">.</span><span class="identifier">str</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
  <span class="identifier">ss</span> <span class="special">&gt;&gt;</span> <span class="identifier">n</span><span class="special">;</span> <span class="comment">// Read back in.</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"NaN input was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">n</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<pre class="programlisting"><span class="identifier">NaN</span> <span class="identifier">output</span> <span class="identifier">was</span> <span class="identifier">nan</span>
<span class="identifier">NaN</span> <span class="identifier">input</span> <span class="identifier">was</span> <span class="identifier">nan</span>
</pre>
<h6>
<a name="boost_multiprecision.tut.limits.functions.h10"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.functions.signaling_nan"></a></span><a class="link" href="functions.html#boost_multiprecision.tut.limits.functions.signaling_nan">Signaling
          NaN</a>
        </h6>
<p>
          For floating-point types only, for which <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">has_signaling_NaN</span>
          <span class="special">==</span> <span class="keyword">true</span></code>,
          function <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">signaling_NaN</span><span class="special">()</span></code>
          provides an implementation-defined representation for NaN that causes a
          hardware trap. It should be noted however, that at least one implementation
          of this function causes a hardware trap to be triggered simply by calling
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">signaling_NaN</span><span class="special">()</span></code>,
          and not only by using the value returned.
        </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="constants.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits32.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/limits/how_to_tell.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>How to Determine the Kind of a Number From std::numeric_limits</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../limits.html" title="Numeric Limits">
<link rel="prev" href="limits32.html" title="Numeric limits for 32-bit platform">
<link rel="next" href="../input_output.html" title="Input Output">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="limits32.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../input_output.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.limits.how_to_tell"></a><a class="link" href="how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">How to
        Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a>
</h4></div></div></div>
<p>
          Based on the information above, one can see that different kinds of numbers
          can be differentiated based on the information stored in <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>. This is in addition to
          the traits class <a class="link" href="../../ref/number.html#boost_multiprecision.ref.number.traits_class_support">number_category</a>
          provided by this library.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.integer_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.integer_types">Integer
          Types</a>
        </h5>
<p>
          For an integer type T, all of the following conditions hold:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent</span> <span class="special">==</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent</span> <span class="special">==</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent10</span> <span class="special">==</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent10</span> <span class="special">==</span> <span class="number">0</span>
</pre>
<p>
          In addition the type is <span class="emphasis"><em>signed</em></span> if:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span> <span class="keyword">true</span>
</pre>
<p>
          If the type is arbitrary precision then:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span> <span class="keyword">false</span>
</pre>
<p>
          Otherwise the type is bounded, and returns a non zero value from:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span>
</pre>
<p>
          and has:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_modulo</span> <span class="special">==</span> <span class="keyword">true</span>
</pre>
<p>
          if the type implements modulo arithmetic on overflow.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h1"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.rational_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.rational_types">Rational
          Types</a>
        </h5>
<p>
          Rational types are just like integers except that:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">false</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h2"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.fixed_precision_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.fixed_precision_types">Fixed
          Precision Types</a>
        </h5>
<p>
          There appears to be no way to tell these apart from rational types, unless
          they set:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">false</span>
</pre>
<p>
          This is because these types are in essence a rational type with a fixed
          denominator.
        </p>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h3"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.floating_point_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.floating_point_types">floating-point
          Types</a>
        </h5>
<p>
          For a floating-point type T, all of the following conditions hold:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_specialized</span> <span class="special">==</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span> <span class="special">==</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent</span> <span class="special">!=</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent</span> <span class="special">!=</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min_exponent10</span> <span class="special">!=</span> <span class="number">0</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_exponent10</span> <span class="special">!=</span> <span class="number">0</span>
</pre>
<p>
          In addition the type is <span class="emphasis"><em>signed</em></span> if:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_signed</span> <span class="special">==</span> <span class="keyword">true</span>
</pre>
<p>
          And the type may be decimal or binary depending on the value of:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">radix</span>
</pre>
<p>
          In general, there are no arbitrary precision floating-point types, and
          so:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_bounded</span> <span class="special">==</span> <span class="keyword">false</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h4"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.exact_floating_point_types"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.exact_floating_point_types">Exact
          floating-point Types</a>
        </h5>
<p>
          Exact floating-point types are a <a href="http://en.wikipedia.org/wiki/Field_%28mathematics%29" target="_top">field</a>
          composed of an arbitrary precision integer scaled by an exponent. Such
          types have no division operator and are the same as floating-point types
          except:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_exact</span> <span class="special">==</span> <span class="keyword">true</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.limits.how_to_tell.h5"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.limits.how_to_tell.complex_numbers"></a></span><a class="link" href="how_to_tell.html#boost_multiprecision.tut.limits.how_to_tell.complex_numbers">Complex
          Numbers</a>
        </h5>
<p>
          For historical reasons, complex numbers do not specialize <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>, instead you must inspect
          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;</span></code>.
        </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="limits32.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../input_output.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/limits/limits32.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Numeric limits for 32-bit platform</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../limits.html" title="Numeric Limits">
<link rel="prev" href="functions.html" title="std::numeric_limits&lt;&gt; functions">
<link rel="next" href="how_to_tell.html" title="How to Determine the Kind of a Number From std::numeric_limits">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="how_to_tell.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.limits.limits32"></a><a class="link" href="limits32.html" title="Numeric limits for 32-bit platform">Numeric limits
        for 32-bit platform</a>
</h4></div></div></div>
<p>
          These tables were generated using the following program and options:
        </p>
<pre class="programlisting">
Program:
 numeric_limits_qbk.cpp
Mon Nov  4 18:09:06 2013
BuildInfo:
  Platform Win32
  Compiler Microsoft Visual C++ version 10.0
  MSVC version 160040219.
  STL Dinkumware standard library version 520
  Boost version 1.55.0
</pre>
<div class="table">
<a name="boost_multiprecision.tut.limits.limits32.integral_constants"></a><p class="title"><b>Table 1.4. Integer types constants (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
          <span class="special">==</span> <span class="keyword">true</span></code>
          &amp;&amp; is_exact == true)</b></p>
<div class="table-contents"><table class="table" summary="Integer types constants (std::numeric_limits&lt;T&gt;::is_integer
          == true
          &amp;&amp; is_exact == true)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    type
                  </p>
                </th>
<th>
                  <p>
                    signed
                  </p>
                </th>
<th>
                  <p>
                    bound
                  </p>
                </th>
<th>
                  <p>
                    modulo
                  </p>
                </th>
<th>
                  <p>
                    round
                  </p>
                </th>
<th>
                  <p>
                    radix
                  </p>
                </th>
<th>
                  <p>
                    digits
                  </p>
                </th>
<th>
                  <p>
                    digits10
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    bool
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    no
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    1
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    7
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned char
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    8
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char16_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    16
                  </p>
                </td>
<td>
                  <p>
                    4
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char32_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    32
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    short
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    15
                  </p>
                </td>
<td>
                  <p>
                    4
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned short
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    16
                  </p>
                </td>
<td>
                  <p>
                    4
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    31
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    32
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    long
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    31
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned long
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    32
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    long long
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    63
                  </p>
                </td>
<td>
                  <p>
                    18
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned long long
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    64
                  </p>
                </td>
<td>
                  <p>
                    19
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int32_t
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    31
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    uint32_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    32
                  </p>
                </td>
<td>
                  <p>
                    9
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int64_t
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    63
                  </p>
                </td>
<td>
                  <p>
                    18
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    uint64_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    64
                  </p>
                </td>
<td>
                  <p>
                    19
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int128_t
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    128
                  </p>
                </td>
<td>
                  <p>
                    38
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    uint128_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    128
                  </p>
                </td>
<td>
                  <p>
                    38
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int256_t
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    256
                  </p>
                </td>
<td>
                  <p>
                    77
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    uint256_t
                  </p>
                </td>
<td>
                  <p>
                    unsigned
                  </p>
                </td>
<td>
                  <p>
                    bound
                  </p>
                </td>
<td>
                  <p>
                    modulo
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    256
                  </p>
                </td>
<td>
                  <p>
                    77
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    cpp_int
                  </p>
                </td>
<td>
                  <p>
                    signed
                  </p>
                </td>
<td>
                  <p>
                    unbounded
                  </p>
                </td>
<td>
                  <p>
                    no
                  </p>
                </td>
<td>
                  <p>
                    to zero
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    2147483647
                  </p>
                </td>
<td>
                  <p>
                    646392383
                  </p>
                </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.tut.limits.limits32.integral_functions"></a><p class="title"><b>Table 1.5. Integer types functions (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
          <span class="special">==</span> <span class="keyword">true</span>
          <span class="special">&amp;&amp;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">min</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">lowest</span><span class="special">()</span></code> )</b></p>
<div class="table-contents"><table class="table" summary="Integer types functions (std::numeric_limits&lt;T&gt;::is_integer
          == true
          &amp;&amp; std::numeric_limits&lt;T&gt;::min() == std::numeric_limits&lt;T&gt;::lowest() )">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    function
                  </p>
                </th>
<th>
                  <p>
                    max
                  </p>
                </th>
<th>
                  <p>
                    min
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    bool
                  </p>
                </td>
<td>
                  <p>
                    1
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char
                  </p>
                </td>
<td>
                  <p>
                    127
                  </p>
                </td>
<td>
                  <p>
                    -128
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned char
                  </p>
                </td>
<td>
                  <p>
                    255
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char16_t
                  </p>
                </td>
<td>
                  <p>
                    65535
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    char32_t
                  </p>
                </td>
<td>
                  <p>
                    4294967295
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    short
                  </p>
                </td>
<td>
                  <p>
                    32767
                  </p>
                </td>
<td>
                  <p>
                    -32768
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned short
                  </p>
                </td>
<td>
                  <p>
                    65535
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int
                  </p>
                </td>
<td>
                  <p>
                    2147483647
                  </p>
                </td>
<td>
                  <p>
                    -2147483648
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned int
                  </p>
                </td>
<td>
                  <p>
                    4294967295
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    long
                  </p>
                </td>
<td>
                  <p>
                    2147483647
                  </p>
                </td>
<td>
                  <p>
                    -2147483648
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned long
                  </p>
                </td>
<td>
                  <p>
                    4294967295
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    long long
                  </p>
                </td>
<td>
                  <p>
                    9223372036854775807
                  </p>
                </td>
<td>
                  <p>
                    -9223372036854775808
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    unsigned long long
                  </p>
                </td>
<td>
                  <p>
                    18446744073709551615
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int32_t
                  </p>
                </td>
<td>
                  <p>
                    2147483647
                  </p>
                </td>
<td>
                  <p>
                    -2147483648
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int64_t
                  </p>
                </td>
<td>
                  <p>
                    9223372036854775807
                  </p>
                </td>
<td>
                  <p>
                    -9223372036854775808
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    int128_t
                  </p>
                </td>
<td>
                  <p>
                    340282366920938463463374607431768211455
                  </p>
                </td>
<td>
                  <p>
                    -340282366920938463463374607431768211455
                  </p>
                </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.tut.limits.limits32.float_functions"></a><p class="title"><b>Table 1.6. Floating-point types constants (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_signed</span><span class="special">==</span><span class="keyword">true</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_modulo</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_exact</span><span class="special">==</span><span class="keyword">false</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_bound</span><span class="special">==</span><span class="keyword">true</span></code>)</b></p>
<div class="table-contents"><table class="table" summary="Floating-point types constants (std::numeric_limits&lt;T&gt;::is_integer==false &amp;&amp; is_signed==true &amp;&amp; is_modulo==false &amp;&amp; is_exact==false &amp;&amp; is_bound==true)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    type
                  </p>
                </th>
<th>
                  <p>
                    round
                  </p>
                </th>
<th>
                  <p>
                    radix
                  </p>
                </th>
<th>
                  <p>
                    digits
                  </p>
                </th>
<th>
                  <p>
                    digits10
                  </p>
                </th>
<th>
                  <p>
                    max_digits10
                  </p>
                </th>
<th>
                  <p>
                    min_exp
                  </p>
                </th>
<th>
                  <p>
                    min_exp10
                  </p>
                </th>
<th>
                  <p>
                    max_exp
                  </p>
                </th>
<th>
                  <p>
                    max_exp10
                  </p>
                </th>
<th>
                  <p>
                    tiny
                  </p>
                </th>
<th>
                  <p>
                    trap
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    float
                  </p>
                </td>
<td>
                  <p>
                    to nearest
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    24
                  </p>
                </td>
<td>
                  <p>
                    6
                  </p>
                </td>
<td>
                  <p>
                    8
                  </p>
                </td>
<td>
                  <p>
                    -125
                  </p>
                </td>
<td>
                  <p>
                    -37
                  </p>
                </td>
<td>
                  <p>
                    128
                  </p>
                </td>
<td>
                  <p>
                    38
                  </p>
                </td>
<td>
                  <p>
                    tiny
                  </p>
                </td>
<td>
                  <p>
                    traps
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    double
                  </p>
                </td>
<td>
                  <p>
                    to nearest
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    53
                  </p>
                </td>
<td>
                  <p>
                    15
                  </p>
                </td>
<td>
                  <p>
                    17
                  </p>
                </td>
<td>
                  <p>
                    -1021
                  </p>
                </td>
<td>
                  <p>
                    -307
                  </p>
                </td>
<td>
                  <p>
                    1024
                  </p>
                </td>
<td>
                  <p>
                    308
                  </p>
                </td>
<td>
                  <p>
                    tiny
                  </p>
                </td>
<td>
                  <p>
                    traps
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    long double
                  </p>
                </td>
<td>
                  <p>
                    to nearest
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    53
                  </p>
                </td>
<td>
                  <p>
                    15
                  </p>
                </td>
<td>
                  <p>
                    17
                  </p>
                </td>
<td>
                  <p>
                    -1021
                  </p>
                </td>
<td>
                  <p>
                    -307
                  </p>
                </td>
<td>
                  <p>
                    1024
                  </p>
                </td>
<td>
                  <p>
                    308
                  </p>
                </td>
<td>
                  <p>
                    tiny
                  </p>
                </td>
<td>
                  <p>
                    traps
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    cpp_dec_float_50
                  </p>
                </td>
<td>
                  <p>
                    indeterminate
                  </p>
                </td>
<td>
                  <p>
                    10
                  </p>
                </td>
<td>
                  <p>
                    50
                  </p>
                </td>
<td>
                  <p>
                    50
                  </p>
                </td>
<td>
                  <p>
                    80
                  </p>
                </td>
<td>
                  <p>
                    -222953000
                  </p>
                </td>
<td>
                  <p>
                    -67108864
                  </p>
                </td>
<td>
                  <p>
                    222953000
                  </p>
                </td>
<td>
                  <p>
                    67108864
                  </p>
                </td>
<td>
                  <p>
                    no
                  </p>
                </td>
<td>
                  <p>
                    no
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    bin_128bit_double_type
                  </p>
                </td>
<td>
                  <p>
                    to nearest
                  </p>
                </td>
<td>
                  <p>
                    2
                  </p>
                </td>
<td>
                  <p>
                    377
                  </p>
                </td>
<td>
                  <p>
                    113
                  </p>
                </td>
<td>
                  <p>
                    115
                  </p>
                </td>
<td>
                  <p>
                    -2147482894
                  </p>
                </td>
<td>
                  <p>
                    -646392082
                  </p>
                </td>
<td>
                  <p>
                    2147482893
                  </p>
                </td>
<td>
                  <p>
                    646392082
                  </p>
                </td>
<td>
                  <p>
                    no
                  </p>
                </td>
<td>
                  <p>
                    traps
                  </p>
                </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_multiprecision.tut.limits.limits32.float_functions0"></a><p class="title"><b>Table 1.7. Floating-point types functions (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">is_integer</span>
          <span class="special">==</span> <span class="keyword">false</span></code>)</b></p>
<div class="table-contents"><table class="table" summary="Floating-point types functions (std::numeric_limits&lt;T&gt;::is_integer
          == false)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                  <p>
                    function
                  </p>
                </th>
<th>
                  <p>
                    float
                  </p>
                </th>
<th>
                  <p>
                    double
                  </p>
                </th>
<th>
                  <p>
                    long double
                  </p>
                </th>
<th>
                  <p>
                    cpp_dec_50
                  </p>
                </th>
<th>
                  <p>
                    cpp_bin_128
                  </p>
                </th>
</tr></thead>
<tbody>
<tr>
<td>
                  <p>
                    max
                  </p>
                </td>
<td>
                  <p>
                    3.40282e+038
                  </p>
                </td>
<td>
                  <p>
                    1.79769e+308
                  </p>
                </td>
<td>
                  <p>
                    1.79769e+308
                  </p>
                </td>
<td>
                  <p>
                    1e+67108865
                  </p>
                </td>
<td>
                  <p>
                    1.85906e+646456766
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    min
                  </p>
                </td>
<td>
                  <p>
                    1.17549e-038
                  </p>
                </td>
<td>
                  <p>
                    2.22507e-308
                  </p>
                </td>
<td>
                  <p>
                    2.22507e-308
                  </p>
                </td>
<td>
                  <p>
                    1e-67108864
                  </p>
                </td>
<td>
                  <p>
                    5.37906e-646456767
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    epsilon
                  </p>
                </td>
<td>
                  <p>
                    1.19209e-007
                  </p>
                </td>
<td>
                  <p>
                    2.22045e-016
                  </p>
                </td>
<td>
                  <p>
                    2.22045e-016
                  </p>
                </td>
<td>
                  <p>
                    1e-49
                  </p>
                </td>
<td>
                  <p>
                    6.49713e-114
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    round_error
                  </p>
                </td>
<td>
                  <p>
                    0.5
                  </p>
                </td>
<td>
                  <p>
                    0.5
                  </p>
                </td>
<td>
                  <p>
                    0.5
                  </p>
                </td>
<td>
                  <p>
                    0.5
                  </p>
                </td>
<td>
                  <p>
                    0.5
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    infinity
                  </p>
                </td>
<td>
                  <p>
                    1.#INF
                  </p>
                </td>
<td>
                  <p>
                    1.#INF
                  </p>
                </td>
<td>
                  <p>
                    1.#INF
                  </p>
                </td>
<td>
                  <p>
                    inf
                  </p>
                </td>
<td>
                  <p>
                    inf
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    quiet_NaN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    nan
                  </p>
                </td>
<td>
                  <p>
                    nan
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    signaling_NaN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    1.#QNAN
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
<tr>
<td>
                  <p>
                    denorm_min
                  </p>
                </td>
<td>
                  <p>
                    1.4013e-045
                  </p>
                </td>
<td>
                  <p>
                    4.94066e-324
                  </p>
                </td>
<td>
                  <p>
                    4.94066e-324
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
<td>
                  <p>
                    0
                  </p>
                </td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../limits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="how_to_tell.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/limits.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Numeric Limits</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="serial.html" title="Boost.Serialization Support">
<link rel="next" href="limits/constants.html" title="std::numeric_limits&lt;&gt; constants">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="serial.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits/constants.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.limits"></a><a class="link" href="limits.html" title="Numeric Limits">Numeric Limits</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="limits/constants.html">std::numeric_limits&lt;&gt;
        constants</a></span></dt>
<dt><span class="section"><a href="limits/functions.html"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> functions</a></span></dt>
<dt><span class="section"><a href="limits/limits32.html">Numeric limits
        for 32-bit platform</a></span></dt>
<dt><span class="section"><a href="limits/how_to_tell.html">How to
        Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
</dl></div>
<p>
        Boost.Multiprecision tries hard to implement <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
        for all types as far as possible and meaningful because experience with Boost.Math
        has shown that this aids portability.
      </p>
<p>
        The <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf" target="_top">C++
        standard library</a> defines <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
        in section 18.3.2.
      </p>
<p>
        This in turn refers to the C standard <a href="http://www.open-std.org/jtc1/sc22/wg11/docs/n507.pdf" target="_top">SC22/WG11
        N507 DRAFT INTERNATIONAL ISO/IEC STANDARD WD 10967-1</a> Information
        technology Language independent arithmetic Part 1: Integer and floating-point
        arithmetic.
      </p>
<p>
        That C Standard in turn refers to
      </p>
<p>
        <a href="https://doi.org/10.1109/IEEESTD.1985.82928" target="_top">IEEE754 IEEE Standard
        for Binary Floating-Point Arithmetic</a>
      </p>
<p>
        There is a useful summary of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
        at <a href="http://www.cplusplus.com/reference/limits/numeric_limits/" target="_top">C++
        reference</a>.
      </p>
<p>
        The chosen backend often determines how completely <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
        is available.
      </p>
<p>
        Compiler options, processor type, and definition of macros or assembler instructions
        to control denormal numbers will alter the values in the tables given below.
      </p>
<div class="warning"><table border="0" summary="Warning">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../../doc/src/images/warning.png"></td>
<th align="left">Warning</th>
</tr>
<tr><td align="left" valign="top"><p>
          GMP's extendable floatin-point <code class="computeroutput"><span class="identifier">mpf_t</span></code>
          does not have a concept of overflow: operations that lead to overflow eventually
          run of out of resources and terminate with stack overflow (often after
          several seconds).
        </p></td></tr>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="serial.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits/constants.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/lits.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Literal Types and constexpr Support</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="primetest.html" title="Primality Testing">
<link rel="next" href="import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="primetest.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="import_export.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.lits"></a><a class="link" href="lits.html" title="Literal Types and constexpr Support">Literal Types and <code class="computeroutput"><span class="keyword">constexpr</span></code> Support</a>
</h3></div></div></div>
<p>
        There are two kinds of <code class="computeroutput"><span class="keyword">constexpr</span></code>
        support in this library:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            The more basic version requires only C++11 and allow the construction
            of some number types as literals.
          </li>
<li class="listitem">
            The more advanced support permits constexpr arithmetic and requires at
            least C++14 constexpr support, and for many operations C++2a support
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.tut.lits.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.lits.declaring_numeric_literals"></a></span><a class="link" href="lits.html#boost_multiprecision.tut.lits.declaring_numeric_literals">Declaring
        numeric literals</a>
      </h5>
<p>
        There are two backend types which are literals:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <a class="link" href="floats/float128.html" title="float128">float128</a>
            (which requires GCC), and
          </li>
<li class="listitem">
            Instantiations of <code class="computeroutput"><span class="identifier">cpp_int_backend</span></code>
            where the Allocator parameter is type <code class="computeroutput"><span class="keyword">void</span></code>.
            In addition, prior to C++14 the Checked parameter must be <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">unchecked</span></code>.
          </li>
</ul></div>
<p>
        For example:
      </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

<span class="keyword">constexpr</span> <span class="identifier">float128</span>            <span class="identifier">f</span> <span class="special">=</span> <span class="number">0.1</span><span class="identifier">Q</span>   <span class="comment">// OK, float128's are always literals in C++11</span>

<span class="keyword">constexpr</span> <span class="identifier">int128_t</span>            <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>     <span class="comment">// OK, fixed precision int128_t has no allocator.</span>
<span class="keyword">constexpr</span> <span class="identifier">uint1024_t</span>          <span class="identifier">j</span> <span class="special">=</span> <span class="number">0</span><span class="identifier">xFFFFFFFF00000000uLL</span><span class="special">;</span>  <span class="comment">// OK, fixed precision uint1024_t has no allocator.</span>

<span class="keyword">constexpr</span> <span class="identifier">checked_uint128_t</span>   <span class="identifier">k</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="comment">// OK from C++14 and later, not supported for C++11.</span>
<span class="keyword">constexpr</span> <span class="identifier">checked_uint128_t</span>   <span class="identifier">k</span> <span class="special">=</span> <span class="special">-</span><span class="number">1</span><span class="special">;</span> <span class="comment">// Error, as this would normally lead to a runtime failure (exception).</span>
<span class="keyword">constexpr</span> <span class="identifier">cpp_int</span>             <span class="identifier">l</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>  <span class="comment">// Error, type is not a literal as it performs memory management.</span>
</pre>
<p>
        There is also support for user defined-literals with <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
        - these are limited to unchecked, fixed precision <code class="computeroutput"><span class="identifier">cpp_int</span></code>'s
        which are specified in hexadecimal notation. The suffixes supported are:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Suffix
                </p>
              </th>
<th>
                <p>
                  Meaning
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  _cppi
                </p>
              </td>
<td>
                <p>
                  Specifies a value of type: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">signed_magnitude</span><span class="special">,</span><span class="identifier">unchecked</span><span class="special">,</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
                  where N is chosen to contain just enough digits to hold the number
                  specified.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  _cppui
                </p>
              </td>
<td>
                <p>
                  Specifies a value of type: <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">unsigned_magnitude</span><span class="special">,</span><span class="identifier">unchecked</span><span class="special">,</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
                  where N is chosen to contain just enough digits to hold the number
                  specified.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  _cppi<span class="emphasis"><em>N</em></span>
                </p>
              </td>
<td>
                <p>
                  Specifies a value of type <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">signed_magnitude</span><span class="special">,</span><span class="identifier">unchecked</span><span class="special">,</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  _cppui<span class="emphasis"><em>N</em></span>
                </p>
              </td>
<td>
                <p>
                  Specifies a value of type <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">signed_magnitude</span><span class="special">,</span><span class="identifier">unchecked</span><span class="special">,</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>.
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        In each case, use of these suffixes with hexadecimal values produces a <code class="computeroutput"><span class="keyword">constexpr</span></code> result.
      </p>
<p>
        Examples:
      </p>
<pre class="programlisting"><span class="comment">// Any use of user defined literals requires that we import the literal-operators into current scope first:</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">literals</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// To keep things simple in the example, we'll make our types used visible to this scope as well:</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// The value zero as a number&lt;cpp_int_backend&lt;4,4,signed_magnitude,unchecked,void&gt; &gt;:</span>
<span class="keyword">constexpr</span> <span class="keyword">auto</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">0x0</span><span class="identifier">_cppi</span><span class="special">;</span>
<span class="comment">// The type of each constant has 4 bits per hexadecimal digit,</span>
<span class="comment">// so this is of type uint256_t (ie number&lt;cpp_int_backend&lt;256,256,unsigned_magnitude,unchecked,void&gt; &gt;):</span>
<span class="keyword">constexpr</span> <span class="keyword">auto</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// Smaller values can be assigned to larger values:</span>
<span class="identifier">int256_t</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">0x1234</span><span class="identifier">_cppi</span><span class="special">;</span> <span class="comment">// OK</span>
<span class="comment">//</span>
<span class="comment">// However, this only works in constexpr contexts from C++14 onwards:</span>
<span class="keyword">constexpr</span> <span class="identifier">int256_t</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0x1</span><span class="identifier">_cppi</span><span class="special">;</span> <span class="comment">// Compiler error in C++11, requires C++14</span>
<span class="comment">//</span>
<span class="comment">// Constants can be padded out with leading zeros to generate wider types:</span>
<span class="keyword">constexpr</span> <span class="identifier">uint256_t</span> <span class="identifier">e</span> <span class="special">=</span> <span class="number">0</span><span class="identifier">x0000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFF_cppui</span><span class="special">;</span> <span class="comment">// OK</span>
<span class="comment">//</span>
<span class="comment">// However, specific-width types are best produced with specific-width suffixes,</span>
<span class="comment">// ones supported by default are `_cpp[u]i128`, `_cpp[u]i256`, `_cpp[u]i512`, `_cpp[u]i1024`.</span>
<span class="comment">//</span>
<span class="keyword">constexpr</span> <span class="identifier">int128_t</span> <span class="identifier">f</span> <span class="special">=</span> <span class="number">0x1234</span><span class="identifier">_cppi128</span><span class="special">;</span> <span class="comment">// OK, always produces an int128_t as the result.</span>
<span class="keyword">constexpr</span> <span class="identifier">uint1024_t</span> <span class="identifier">g</span> <span class="special">=</span> <span class="number">0</span><span class="identifier">xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccc_cppui1024</span><span class="special">;</span> <span class="comment">// OK,</span>
<span class="comment">//  always produces an uint1024_t as the result.</span>
<span class="comment">//</span>
<span class="comment">// If other specific-width types are required, then there is a macro for generating the operators for these.</span>
<span class="comment">// The macro can be used at namespace scope only:</span>
<span class="comment">//</span>
<span class="identifier">BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL</span><span class="special">(</span><span class="number">2048</span><span class="special">);</span>
<span class="comment">//</span>
<span class="comment">// Now we can create 2048-bit literals as well:</span>
<span class="keyword">constexpr</span> <span class="keyword">auto</span> <span class="identifier">h</span> <span class="special">=</span> <span class="number">0xff</span><span class="identifier">_cppi2048</span><span class="special">;</span> <span class="comment">// h is of type number&lt;cpp_int_backend&lt;2048,2048,signed_magnitude,unchecked,void&gt; &gt;</span>
<span class="comment">//</span>
<span class="comment">// Finally, negative values are handled via the unary minus operator:</span>
<span class="comment">//</span>
<span class="keyword">constexpr</span> <span class="identifier">int1024_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">-</span><span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui1024</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// Which means this also works:</span>
<span class="keyword">constexpr</span> <span class="identifier">int1024_t</span> <span class="identifier">j</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">g</span><span class="special">;</span>   <span class="comment">// OK: unary minus operator is constexpr.</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.lits.h1"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.lits.constexpr_arithmetic"></a></span><a class="link" href="lits.html#boost_multiprecision.tut.lits.constexpr_arithmetic">constexpr
        arithmetic</a>
      </h5>
<p>
        The front end of the library is all <code class="computeroutput"><span class="keyword">constexpr</span></code>
        from C++14 and later. Currently there are only two backend types that are
        <code class="computeroutput"><span class="keyword">constexpr</span></code> aware: __float128
        and <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>.
        More backends will follow at a later date.
      </p>
<p>
        Provided the compiler is GCC, type <a class="link" href="floats/float128.html" title="float128">float128</a>
        support <code class="computeroutput"><span class="keyword">constexpr</span></code> operations
        on all arithmetic operations from C++14, comparisons, <code class="computeroutput"><span class="identifier">abs</span></code>,
        <code class="computeroutput"><span class="identifier">fabs</span></code>, <code class="computeroutput"><span class="identifier">fpclassify</span></code>,
        <code class="computeroutput"><span class="identifier">isnan</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code>,
        <code class="computeroutput"><span class="identifier">isfinite</span></code> and <code class="computeroutput"><span class="identifier">isnormal</span></code> are also fully supported, but
        the transcendental functions are not.
      </p>
<p>
        The <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
        types support constexpr arithmetic, provided it is a fixed precision type
        with no allocator. It may also be a checked integer: in which case a compiler
        error will be generated on overflow or undefined behaviour. In addition the
        free functions <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">swap</span></code>, <code class="computeroutput"><span class="identifier">multiply</span></code>,
        <code class="computeroutput"><span class="identifier">add</span></code>, <code class="computeroutput"><span class="identifier">subtract</span></code>,
        <code class="computeroutput"><span class="identifier">divide_qr</span></code>, <code class="computeroutput"><span class="identifier">integer_modulus</span></code>, <code class="computeroutput"><span class="identifier">powm</span></code>,
        <code class="computeroutput"><span class="identifier">lsb</span></code>, <code class="computeroutput"><span class="identifier">msb</span></code>,
        <code class="computeroutput"><span class="identifier">bit_test</span></code>, <code class="computeroutput"><span class="identifier">bit_set</span></code>,
        <code class="computeroutput"><span class="identifier">bit_unset</span></code>, <code class="computeroutput"><span class="identifier">bit_flip</span></code>, <code class="computeroutput"><span class="identifier">sqrt</span></code>,
        <code class="computeroutput"><span class="identifier">gcd</span></code>, <code class="computeroutput"><span class="identifier">lcm</span></code>
        are all supported. Use of <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
        in this way requires either a C++2a compiler (one which supports <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code> - currently only gcc-9 or clang-9 or later),
        or GCC-6 or later in C++14 mode. Compilers other than GCC and without <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code> will support a very limited set of operations:
        expect to hit roadblocks rather easily.
      </p>
<p>
        See <a href="https://en.cppreference.com/w/cpp/compiler_support" target="_top">compiler
        support</a> for <a href="https://en.cppreference.com/w/cpp/types/is_constant_evaluated" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span></code></a>;
      </p>
<p>
        For example given:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">constants</span><span class="special">/</span><span class="identifier">constants</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// For constant pi with full precision of type T.</span>
<span class="comment">// using  boost::math::constants::pi;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="identifier">circumference</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">radius</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">return</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">;</span>
<span class="special">}</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="identifier">area</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">radius</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span> <span class="special">*</span> <span class="identifier">radius</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        We can now calculate areas and circumferences, using all compile-time <code class="computeroutput"><span class="keyword">constexpr</span></code> arithmetic:
      </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">float128</span><span class="special">;</span>

<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">radius</span> <span class="special">=</span> <span class="number">2.25</span><span class="special">;</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">c</span>      <span class="special">=</span> <span class="identifier">circumference</span><span class="special">(</span><span class="identifier">radius</span><span class="special">);</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">a</span>      <span class="special">=</span> <span class="identifier">area</span><span class="special">(</span><span class="identifier">radius</span><span class="special">);</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Circumference = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">c</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Area = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">a</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
        Note that these make use of the numeric constants from the <a href="https://www.boost.org/doc/libs/release/libs/math/doc/html/math_toolkit/constants.html" target="_top">Boost.Math
        constants</a> library, which also happen to be <code class="computeroutput"><span class="keyword">constexpr</span></code>.
        These usually have the full precision of the floating-point type, here 128-bit,
        about 36 decimal digits.
      </p>
<h6>
<a name="boost_multiprecision.tut.lits.h2"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.lits.hermite_poly_coeffics"></a></span><a class="link" href="lits.html#boost_multiprecision.tut.lits.hermite_poly_coeffics">Calculating
        Hermite Polynomial coefficients at compile time</a>
      </h6>
<p>
        For a more interesting example, in <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../example/constexpr_float_arithmetic_examples.cpp" target="_top">constexpr_float_arithmetic_examples.cpp</a>
        we define a simple class for <code class="computeroutput"><span class="keyword">constexpr</span></code>
        polynomial arithmetic:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">Order</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">const_polynomial</span><span class="special">;</span>
</pre>
<p>
        Given this, we can use recurrence relations to calculate the coefficients
        for various orthogonal polynomials - in the example we use the Hermite polynomials.
        Only the constructor does any work - it uses the recurrence relations to
        calculate the coefficient array:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">Order</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">hermite_polynomial</span>
<span class="special">{</span>
   <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Order</span><span class="special">&gt;</span> <span class="identifier">m_data</span><span class="special">;</span>

 <span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">constexpr</span> <span class="identifier">hermite_polynomial</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">m_data</span><span class="special">(</span><span class="identifier">hermite_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Order</span> <span class="special">-</span> <span class="number">1</span><span class="special">&gt;().</span><span class="identifier">data</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;{</span><span class="number">0</span><span class="special">,</span> <span class="number">2</span><span class="special">}</span> <span class="special">-</span> <span class="identifier">hermite_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Order</span> <span class="special">-</span> <span class="number">1</span><span class="special">&gt;().</span><span class="identifier">data</span><span class="special">().</span><span class="identifier">derivative</span><span class="special">())</span>
   <span class="special">{</span>
   <span class="special">}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Order</span><span class="special">&gt;&amp;</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">)</span><span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">[</span><span class="identifier">N</span><span class="special">];</span>
   <span class="special">}</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
   <span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">U</span> <span class="identifier">val</span><span class="special">)</span><span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">(</span><span class="identifier">val</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
        Now we just need to define <span class="emphasis"><em>H<sub>0</sub></em></span> and <span class="emphasis"><em>H<sub>1</sub></em></span>
        as termination conditions for the recurrence:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">hermite_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">0</span><span class="special">&gt;</span>
<span class="special">{</span>
   <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">0</span><span class="special">&gt;</span> <span class="identifier">m_data</span><span class="special">;</span>

 <span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">constexpr</span> <span class="identifier">hermite_polynomial</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">m_data</span><span class="special">{</span><span class="number">1</span><span class="special">}</span> <span class="special">{}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">0</span><span class="special">&gt;&amp;</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">)</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">[</span><span class="identifier">N</span><span class="special">];</span>
   <span class="special">}</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
   <span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">U</span> <span class="identifier">val</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">(</span><span class="identifier">val</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">hermite_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;</span>
<span class="special">{</span>
   <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;</span> <span class="identifier">m_data</span><span class="special">;</span>

 <span class="keyword">public</span><span class="special">:</span>
   <span class="keyword">constexpr</span> <span class="identifier">hermite_polynomial</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">m_data</span><span class="special">{</span><span class="number">0</span><span class="special">,</span> <span class="number">2</span><span class="special">}</span> <span class="special">{}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">const_polynomial</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="number">1</span><span class="special">&gt;&amp;</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">constexpr</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">)</span> <span class="keyword">const</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">[</span><span class="identifier">N</span><span class="special">];</span>
   <span class="special">}</span>
   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
   <span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">U</span> <span class="identifier">val</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">m_data</span><span class="special">(</span><span class="identifier">val</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
        We can now declare <span class="emphasis"><em>H<sub>9</sub></em></span> as a <code class="computeroutput"><span class="keyword">constexpr</span></code>
        object, access the coefficients, and evaluate at an abscissa value, all at
        compile-time using <code class="computeroutput"><span class="keyword">constexpr</span></code>
        arithmetic:
      </p>
<pre class="programlisting"><span class="keyword">constexpr</span> <span class="identifier">hermite_polynomial</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">,</span> <span class="number">9</span><span class="special">&gt;</span> <span class="identifier">h9</span><span class="special">;</span>
<span class="comment">//</span>
<span class="comment">// Verify that the polynomial's coefficients match the known values:</span>
<span class="comment">//</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">30240</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">3</span><span class="special">]</span> <span class="special">==</span> <span class="special">-</span><span class="number">80640</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">4</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">5</span><span class="special">]</span> <span class="special">==</span> <span class="number">48384</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">6</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">7</span><span class="special">]</span> <span class="special">==</span> <span class="special">-</span><span class="number">9216</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">8</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">[</span><span class="number">9</span><span class="special">]</span> <span class="special">==</span> <span class="number">512</span><span class="special">);</span>
<span class="comment">//</span>
<span class="comment">// Define an abscissa value to evaluate at:</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">abscissa</span><span class="special">(</span><span class="number">0.5</span><span class="special">);</span>
<span class="comment">//</span>
<span class="comment">// Evaluate H_9(0.5) using all constexpr arithmetic, and check that it has the expected result:</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">h9</span><span class="special">(</span><span class="identifier">abscissa</span><span class="special">)</span> <span class="special">==</span> <span class="number">6481</span><span class="special">);</span>
</pre>
<p>
        See <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../example/constexpr_float_arithmetic_examples.cpp" target="_top">constexpr_float_arithmetic_examples.cpp</a>
        for working code.
      </p>
<p>
        Also since the coefficients to the Hermite polynomials are integers, we can
        also generate the Hermite coefficients using (fixed precision) <code class="computeroutput"><span class="identifier">cpp_int</span></code>s: see <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/constexpr_test_cpp_int_6.cpp" target="_top">constexpr_test_cpp_int_6.cpp</a>.
      </p>
<h6>
<a name="boost_multiprecision.tut.lits.h3"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.lits.factorial_constexpr"></a></span><a class="link" href="lits.html#boost_multiprecision.tut.lits.factorial_constexpr"><code class="computeroutput"><span class="keyword">constexpr</span></code> Factorials</a>
      </h6>
<p>
        We can also generate integer factorials in <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/constexpr_test_cpp_int_5.cpp" target="_top">constexpr_test_cpp_int_5.cpp</a>
        like so:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="identifier">T</span> <span class="identifier">factorial</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">?</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span> <span class="special">:</span> <span class="number">1</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        and validate the result:
      </p>
<pre class="programlisting"><span class="keyword">constexpr</span> <span class="identifier">uint1024_t</span> <span class="identifier">f1</span> <span class="special">=</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">uint1024_t</span><span class="special">(</span><span class="number">31</span><span class="special">));</span> <span class="comment">// Factorial 31!</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">f1</span> <span class="special">==</span> <span class="number">0</span><span class="identifier">x1956ad0aae33a4560c5cd2c000000_cppi</span><span class="special">);</span> <span class="comment">// Expected result as an Boost.Multiprecision integer literal. </span>
</pre>
<h6>
<a name="boost_multiprecision.tut.lits.h4"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.lits.random_constexpr"></a></span><a class="link" href="lits.html#boost_multiprecision.tut.lits.random_constexpr">Random
        <code class="computeroutput"><span class="keyword">constexpr</span></code> values</a>
      </h6>
<p>
        Another example in <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/constexpr_test_cpp_int_7.cpp" target="_top">constexpr_test_cpp_int_7.cpp</a>
        generates a fresh multiprecision random number each time the file is compiled.
        It includes an C++ template implementation of the <a href="https://en.wikipedia.org/wiki/KISS_(algorithm)" target="_top">KISS
        random number algorithm by George Marsaglia</a> for <code class="computeroutput"><span class="identifier">cpp_int</span></code>
        integers.
      </p>
<pre class="programlisting"><span class="keyword">constexpr</span> <span class="identifier">uint1024_t</span> <span class="identifier">rand</span> <span class="special">=</span> <span class="identifier">nth_random_value</span><span class="special">&lt;</span><span class="identifier">uint1024_t</span><span class="special">&gt;(</span><span class="number">1000</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">rand</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
        See also the <a class="link" href="random.html" title="Generating Random Numbers">random number
        generation</a> section.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="primetest.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="import_export.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/misc/debug_adaptor.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>debug_adaptor</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../misc.html" title="Miscellaneous Number Types.">
<link rel="prev" href="logged_adaptor.html" title="logged_adaptor">
<link rel="next" href="visualizers.html" title="Visual C++ Debugger Visualizers">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="logged_adaptor.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="visualizers.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.misc.debug_adaptor"></a><a class="link" href="debug_adaptor.html" title="debug_adaptor">debug_adaptor</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">debug_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">debug_adaptor</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Number</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">debug_adaptor_t</span> <span class="special">=</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">debug_adaptor</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Number</span><span class="special">::</span><span class="identifier">backend_type</span><span class="special">&gt;,</span> <span class="identifier">Number</span><span class="special">::</span><span class="identifier">et</span><span class="special">&gt;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">debug_adaptor</span></code> type
          is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>
          and some other backend type: it acts as a thin wrapper around some other
          backend to class <code class="computeroutput"><span class="identifier">number</span></code>
          and intercepts all operations on that object storing the result as a string
          within itself.
        </p>
<p>
          This type provides <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          support whenever the template argument Backend does so.
        </p>
<p>
          This type is particularly useful when your debugger provides a good view
          of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>: when this is the case multiprecision
          values can easily be inspected in the debugger by looking at the <code class="computeroutput"><span class="identifier">debug_value</span></code> member of <code class="computeroutput"><span class="identifier">debug_adaptor</span></code>.
          The down side of this approach is that runtimes are much slower when using
          this type. Set against that it can make debugging very much easier, certainly
          much easier than sprinkling code with <code class="computeroutput"><span class="identifier">printf</span></code>
          statements.
        </p>
<p>
          When used in conjunction with the Visual C++ debugger visualisers, the
          value of a multiprecision type that uses this backend is displayed in the
          debugger just a <a href="https://en.cppreference.com/w/cpp/language/types" target="_top">fundamental
          (built-in)</a> value would be, here we're inspecting a value of type
          <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">debug_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span>
          <span class="special">&gt;</span></code>:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger1.png"></span>
        </p>
<p>
          Otherwise you will need to expand out the view and look at the "debug_value"
          member:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger2.png"></span>
        </p>
<p>
          It works for all the backend types equally too, here it is inspecting a
          <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">debug_adaptor</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span>
          <span class="special">&gt;</span></code>:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger3.png"></span>
        </p>
<p>
          The template alias <code class="computeroutput"><span class="identifier">debug_adaptor_t</span></code>
          is used as a shortcut for converting some other number type to it's debugged
          equivalent, for example:
        </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">mpfr_float_debug</span> <span class="special">=</span> <span class="identifier">debug_adaptor_t</span><span class="special">&lt;</span><span class="identifier">mpfr_float</span><span class="special">&gt;;</span>
</pre>
<p>
          Defines <code class="computeroutput"><span class="identifier">mpfr_float_debug</span></code>
          to be the debugged equivalent of <code class="computeroutput"><span class="identifier">mpfr_float</span></code>.
        </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="logged_adaptor.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="visualizers.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/misc/logged_adaptor.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>logged_adaptor</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../misc.html" title="Miscellaneous Number Types.">
<link rel="prev" href="../misc.html" title="Miscellaneous Number Types.">
<link rel="next" href="debug_adaptor.html" title="debug_adaptor">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../misc.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="debug_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.misc.logged_adaptor"></a><a class="link" href="logged_adaptor.html" title="logged_adaptor">logged_adaptor</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">logged_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_postfix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_postfix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">result1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">result2</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_prefix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_prefix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">arg2</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_prefix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">arg2</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">arg3</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">V</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">log_prefix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Backend</span><span class="special">&amp;</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">arg2</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">U</span><span class="special">&amp;</span> <span class="identifier">arg3</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span><span class="special">&amp;</span> <span class="identifier">arg4</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">logged_adaptor</span><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Number</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">logged_adaptor_t</span> <span class="special">=</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">logged_adaptor</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Number</span><span class="special">::</span><span class="identifier">backend_type</span><span class="special">&gt;,</span> <span class="identifier">Number</span><span class="special">::</span><span class="identifier">et</span><span class="special">&gt;;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">logged_adaptor</span></code> type
          is used in conjunction with <code class="computeroutput"><span class="identifier">number</span></code>
          and some other backend type: it acts as a thin wrapper around some other
          backend to class <code class="computeroutput"><span class="identifier">number</span></code>
          and logs all the events that take place on that object. Before any number
          operation takes place, it calls <code class="computeroutput"><span class="identifier">log_prefix_event</span></code>
          with the arguments to the operation (up to 4), plus a string describing
          the operation. Then after the operation it calls <code class="computeroutput"><span class="identifier">log_postfix_event</span></code>
          with the result of the operation, plus a string describing the operation.
          Optionally, <code class="computeroutput"><span class="identifier">log_postfix_event</span></code>
          takes a second result argument: this occurs when the result of the operation
          is not a <code class="computeroutput"><span class="identifier">number</span></code>, for example
          when <code class="computeroutput"><span class="identifier">fpclassify</span></code> is called,
          <code class="computeroutput"><span class="identifier">log_postfix_event</span></code> will
          be called with <code class="computeroutput"><span class="identifier">result1</span></code>
          being the argument to the function, and <code class="computeroutput"><span class="identifier">result2</span></code>
          being the integer result of <code class="computeroutput"><span class="identifier">fpclassify</span></code>.
        </p>
<p>
          The default versions of <code class="computeroutput"><span class="identifier">log_prefix_event</span></code>
          and <code class="computeroutput"><span class="identifier">log_postfix_event</span></code> do
          nothing, it is therefore up to the user to overload these for the particular
          backend being observed.
        </p>
<p>
          This type provides <code class="computeroutput"><span class="identifier">numeric_limits</span></code>
          support whenever the template argument Backend does so.
        </p>
<p>
          Template alias <code class="computeroutput"><span class="identifier">logged_adaptor_t</span></code>
          can be used as a shortcut for converting some instantiation of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;&gt;</span></code>
          to it's logged euqivalent.
        </p>
<p>
          This type is particularly useful when combined with an interval number
          type - in this case we can use <code class="computeroutput"><span class="identifier">log_postfix_event</span></code>
          to monitor the error accumulated after each operation. We could either
          set some kind of trap whenever the accumulated error exceeds some threshold,
          or simply print out diagnostic information. Using this technique we can
          quickly locate the cause of numerical instability in a particular routine.
          The following example demonstrates this technique in a trivial algorithm
          that deliberately introduces cancellation error:
        </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">mpfi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">logged_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>
<span class="comment">//</span>
<span class="comment">// Begin by overloading log_postfix_event so we can capture each arithmetic event as it happens:</span>
<span class="comment">//</span>
<span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">D</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">log_postfix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">&gt;&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">// Print out the (relative) diameter of the interval:</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">diam</span><span class="special">;</span>
   <span class="identifier">mpfi_diam</span><span class="special">(</span><span class="identifier">diam</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">(),</span> <span class="identifier">val</span><span class="special">.</span><span class="identifier">data</span><span class="special">());</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Diameter was "</span> <span class="special">&lt;&lt;</span> <span class="identifier">diam</span> <span class="special">&lt;&lt;</span> <span class="string">" after operation: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">event_description</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">D</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">log_postfix_event</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">event_description</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">// This version is never called in this example.</span>
<span class="special">}</span>

<span class="special">}}</span>


<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">logged_adaptor</span><span class="special">&lt;</span><span class="identifier">mpfi_float_backend</span><span class="special">&lt;</span><span class="number">17</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">logged_type</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Test case deliberately introduces cancellation error, relative size of interval</span>
   <span class="comment">// gradually gets larger after each operation:</span>
   <span class="comment">//</span>
   <span class="identifier">logged_type</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
   <span class="identifier">a</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>

   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">13</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">logged_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="number">9</span><span class="special">;</span>
      <span class="identifier">b</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>
      <span class="identifier">a</span> <span class="special">-=</span> <span class="identifier">b</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Final value was: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">a</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
          When we examine program output we can clearly see that the diameter of
          the interval increases after each subtraction:
        </p>
<pre class="programlisting"><span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Assignment</span> <span class="identifier">from</span> <span class="identifier">arithmetic</span> <span class="identifier">type</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.33681e-18</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">7.70988e-18</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">9.63735e-18</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.30104e-16</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.30104e-16</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.38537e-16</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.54788e-15</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.54788e-15</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.54863e-15</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.84164e-14</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.84164e-14</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.84221e-14</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">9.19962e-13</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">9.19962e-13</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">9.19966e-13</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.74793e-11</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.74793e-11</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.74793e-11</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">3.32107e-10</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">3.32107e-10</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">3.32107e-10</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">6.31003e-09</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">6.31003e-09</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">6.31003e-09</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.19891e-07</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.19891e-07</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">1.19891e-07</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.27792e-06</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.27792e-06</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">2.27792e-06</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.32805e-05</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.32805e-05</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">4.32805e-05</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.00082233</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.00082233</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.00082233</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.0156243</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="identifier">nan</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="identifier">Default</span> <span class="identifier">construct</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.0156243</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">*</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.0156243</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">/=</span>
<span class="identifier">Diameter</span> <span class="identifier">was</span> <span class="number">0.296861</span> <span class="identifier">after</span> <span class="identifier">operation</span><span class="special">:</span> <span class="special">-=</span>
<span class="identifier">Final</span> <span class="identifier">value</span> <span class="identifier">was</span><span class="special">:</span> <span class="special">{</span><span class="number">8.51569e-15</span><span class="special">,</span><span class="number">1.14843e-14</span><span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../misc.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="debug_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/misc/visualizers.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Visual C++ Debugger Visualizers</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../misc.html" title="Miscellaneous Number Types.">
<link rel="prev" href="debug_adaptor.html" title="debug_adaptor">
<link rel="next" href="../conversions.html" title="Constructing and Interconverting Between Number Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="debug_adaptor.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../conversions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.misc.visualizers"></a><a class="link" href="visualizers.html" title="Visual C++ Debugger Visualizers">Visual C++
        Debugger Visualizers</a>
</h4></div></div></div>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
            This section is seriously out of date compared to recent Visual C++ releases.
          </p></td></tr>
</table></div>
<p>
          Let's face it debugger multiprecision numbers is hard - simply because
          we can't easily inspect the value of the numbers. Visual C++ provides a
          partial solution in the shape of "visualizers" which provide
          improved views of complex data structures, these visualizers need to be
          added to the <code class="computeroutput"><span class="special">[</span><span class="identifier">Visualizer</span><span class="special">]</span></code> section of <code class="computeroutput"><span class="identifier">autoexp</span><span class="special">.</span><span class="identifier">dat</span></code>
          located in the <code class="computeroutput"><span class="identifier">Common7</span><span class="special">/</span><span class="identifier">Packages</span><span class="special">/</span><span class="identifier">Debugger</span></code>
          directory of your Visual Studio installation. The actual visualizer code
          is in the sandbox <a href="https://svn.boost.org/svn/boost/sandbox/boost_docs/subprojects/DebuggerVisualizers/multiprecision.vis.txt" target="_top">here</a>
          - just cut and paste the code into your <code class="computeroutput"><span class="identifier">autoexp</span><span class="special">.</span><span class="identifier">dat</span></code>
          file.
        </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
            These visualizers have only been tested with VC10, also given the ability
            of buggy visualizers to crash your Visual C++ debugger, make sure you
            back up <code class="computeroutput"><span class="identifier">autoexp</span><span class="special">.</span><span class="identifier">dat</span></code> file before using these!!
          </p></td></tr>
</table></div>
<p>
          The first visualizer provides improved views of <code class="computeroutput"><span class="identifier">debug_adaptor</span></code>:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger1.png"></span>
        </p>
<p>
          The next visualizer provides improved views of cpp_int: small numbers are
          displayed as actual values, while larger numbers are displayed as an array
          of hexadecimal parts, with the most significant part first.
        </p>
<p>
          Here's what it looks like for small values:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger4.png"></span>
        </p>
<p>
          And for larger values:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger5.png"></span>
        </p>
<p>
          There is also a <code class="computeroutput"><span class="special">~</span><span class="identifier">raw</span></code>
          child member that lets you see the actual members of the class:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger6.png"></span>
        </p>
<p>
          The visualizer for <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>
          shows the first few digits of the value in the preview field, and the full
          array of digits when you expand the view. As before the <code class="computeroutput"><span class="special">~</span><span class="identifier">raw</span></code> child gives you access to the actual
          data members:
        </p>
<p>
          <span class="inlinemediaobject"><img src="../../../../debugger7.png"></span>
        </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="debug_adaptor.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../misc.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../conversions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/misc.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Miscellaneous Number Types.</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="rational/rational_adaptor.html" title="rational_adaptor">
<link rel="next" href="misc/logged_adaptor.html" title="logged_adaptor">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rational/rational_adaptor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="misc/logged_adaptor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.misc"></a><a class="link" href="misc.html" title="Miscellaneous Number Types.">Miscellaneous Number Types.</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="misc/logged_adaptor.html">logged_adaptor</a></span></dt>
<dt><span class="section"><a href="misc/debug_adaptor.html">debug_adaptor</a></span></dt>
<dt><span class="section"><a href="misc/visualizers.html">Visual C++
        Debugger Visualizers</a></span></dt>
</dl></div>
<p>
        Backend types listed in this section are predominantly designed to aid debugging.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rational/rational_adaptor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="misc/logged_adaptor.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/mixed.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Mixed Precision Arithmetic</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="rounding.html" title="Rounding Rules for Conversions">
<link rel="next" href="variable.html" title="Variable Precision Arithmetic">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rounding.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="variable.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.mixed"></a><a class="link" href="mixed.html" title="Mixed Precision Arithmetic">Mixed Precision Arithmetic</a>
</h3></div></div></div>
<p>
        Mixed precision arithmetic is fully supported by the library.
      </p>
<p>
        There are three different forms:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Where the operands are of different precision or types.
          </li>
<li class="listitem">
            Where the operands are of the same type and precision, but yield a higher
            precision result.
          </li>
<li class="listitem">
            Where the operands or result are different but equivalent types (for
            example types which differ only in their memory management).
          </li>
</ul></div>
<h5>
<a name="boost_multiprecision.tut.mixed.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.mixed.mixing_operands_of_differing_typ"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.mixing_operands_of_differing_typ">Mixing
        Operands of Differing Types or Precision</a>
      </h5>
<p>
        If the arguments to a binary operator are of different types or precision,
        then the operation is allowed as long as there is an unambiguous implicit
        conversion from one argument type to the other. In all cases the arithmetic
        is performed "as if" the lower precision type is promoted to the
        higher precision type before applying the operator. However, particular backends
        may optimise this and avoid actually creating a temporary if they are able
        to do so.
      </p>
<p>
        For example:
      </p>
<pre class="programlisting"><span class="identifier">mpfr_float_50</span>         <span class="identifier">a</span><span class="special">(</span><span class="number">2</span><span class="special">),</span> <span class="identifier">b</span><span class="special">;</span>
<span class="identifier">mpfr_float_100</span>        <span class="identifier">c</span><span class="special">(</span><span class="number">3</span><span class="special">),</span> <span class="identifier">d</span><span class="special">;</span>
<span class="identifier">static_mpfr_float_50</span>  <span class="identifier">e</span><span class="special">(</span><span class="number">5</span><span class="special">),</span> <span class="identifier">f</span><span class="special">;</span>
<span class="identifier">mpz_int</span>               <span class="identifier">i</span><span class="special">(</span><span class="number">20</span><span class="special">);</span>

<span class="identifier">d</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">c</span><span class="special">;</span>  <span class="comment">// OK, result of operand is an mpfr_float_100.</span>
<span class="identifier">b</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">c</span><span class="special">;</span>  <span class="comment">// Error, can't convert the result to an mpfr_float_50 as it will lose digits.</span>
<span class="identifier">f</span> <span class="special">=</span> <span class="identifier">e</span> <span class="special">*</span> <span class="identifier">i</span><span class="special">;</span>  <span class="comment">// OK, unambiguous conversion from mpz_int to static_mpfr_float_50</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.mixed.h1"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.mixed.operands_of_the_same_precision"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.operands_of_the_same_precision">Operands
        of the Same Precision</a>
      </h5>
<p>
        Sometimes you want to apply an operator to two arguments of the same precision
        in such a way as to obtain a result of higher precision. The most common
        situation occurs with fixed precision integers, where you want to multiply
        two N-bit numbers to obtain a 2N-bit result. This is supported in this library
        by the following free functions:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">subtract</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ResultType</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source1</span> <span class="keyword">class</span> <span class="identifier">Source2</span><span class="special">&gt;</span>
<span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ResultType</span><span class="special">&amp;</span> <span class="identifier">result</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source1</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source2</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre>
<p>
        These functions apply the named operator to the arguments <span class="emphasis"><em>a</em></span>
        and <span class="emphasis"><em>b</em></span> and store the result in <span class="emphasis"><em>result</em></span>,
        returning <span class="emphasis"><em>result</em></span>. In all cases they behave "as
        if" arguments <span class="emphasis"><em>a</em></span> and <span class="emphasis"><em>b</em></span> were
        first promoted to type <code class="computeroutput"><span class="identifier">ResultType</span></code>
        before applying the operator, though particular backends may well avoid that
        step by way of an optimization.
      </p>
<p>
        The type <code class="computeroutput"><span class="identifier">ResultType</span></code> must
        be an instance of class <code class="computeroutput"><span class="identifier">number</span></code>,
        and the types <code class="computeroutput"><span class="identifier">Source1</span></code> and
        <code class="computeroutput"><span class="identifier">Source2</span></code> may be either instances
        of class <code class="computeroutput"><span class="identifier">number</span></code> or native
        integer types. The latter is an optimization that allows arithmetic to be
        performed on native integer types producing an extended precision result.
      </p>
<p>
        For example:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">uint64_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">uint64_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)();</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">uint64_t</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="identifier">uint128_t</span> <span class="identifier">ui128</span><span class="special">;</span>
   <span class="identifier">uint256_t</span> <span class="identifier">ui256</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Start by performing arithmetic on 64-bit integers to yield 128-bit results:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">i</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">add</span><span class="special">(</span><span class="identifier">ui128</span><span class="special">,</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ui128</span><span class="special">,</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">i</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// The try squaring a 128-bit integer to yield a 256-bit result:</span>
   <span class="comment">//</span>
   <span class="identifier">ui128</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">uint128_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">)();</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">multiply</span><span class="special">(</span><span class="identifier">ui256</span><span class="special">,</span> <span class="identifier">ui128</span><span class="special">,</span> <span class="identifier">ui128</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Produces the output:
      </p>
<pre class="programlisting"><span class="number">0</span><span class="identifier">xffffffffffffffff</span>
<span class="number">0</span><span class="identifier">x10000000000000000</span>
<span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFE0000000000000001</span>
<span class="number">0</span><span class="identifier">xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000000000000000000000000000001</span>
</pre>
<h5>
<a name="boost_multiprecision.tut.mixed.h2"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.mixed.mixing_different_but_equivalent_"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.mixing_different_but_equivalent_">Mixing
        different, but "equivalent" types</a>
      </h5>
<p>
        Ordinarily, mixing types of the same precision will produce a compiler error
        since there is no unambiguous result type. However, there is a traits class:
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">NumberType1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">NumberType2</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_equivalent_number_type</span><span class="special">;</span>

<span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
        When it's <code class="computeroutput"><span class="identifier">value</span></code> const-member
        value is <code class="computeroutput"><span class="keyword">true</span></code> then the library
        will treat the types <code class="computeroutput"><span class="identifier">NumberType1</span></code>
        and <code class="computeroutput"><span class="identifier">NumberType2</span></code> as if they
        are interchangeable. This is typically used to optimise memory management
        by using two types with differing memory allocation strategies for different
        roles. Typically, we would be using a type with dymanic memory allocation
        and a minimal memory footprint for the main storage type (think large arrays
        or matrices), but a type with internal storage and no dynamic allocation
        (but a larger memory footprint) for a few select calculations.
      </p>
<p>
        There are three backends that define this trait by default:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>'s,
            provided the two types differ only in their internal cache size.
          </li>
<li class="listitem">
            <a class="link" href="floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>'s
            provided they are of the same precision.
          </li>
<li class="listitem">
            <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>'s
            provided they are of the same precision.
          </li>
</ul></div>
<p>
        In addition, while this feature can be used with expression templates turned
        off, this feature minimises temporaries and hence memory allocations when
        expression template are turned on.
      </p>
<p>
        By way of an example, consider the dot product of two vectors of <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>'s,
        our first, fairly trivial implementation might look like this:
      </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">dot_product_1</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v2</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">if</span> <span class="special">(</span><span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">v2</span><span class="special">.</span><span class="identifier">size</span><span class="special">())</span>
      <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span><span class="special">(</span><span class="string">"Mismatched arguments"</span><span class="special">);</span>

   <span class="identifier">cpp_int</span> <span class="identifier">result</span><span class="special">;</span>
   <span class="keyword">for</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">result</span> <span class="special">+=</span> <span class="identifier">v1</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">v2</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
   <span class="comment">//</span>
   <span class="comment">// Named-return value optimisation (even better than a move):</span>
   <span class="comment">//</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        However, in order to reduce the need for memory allocations when constructing
        the temporaries needed for the multiply-and-add operations, we could use
        an equivalent type with a larger internal cache like this:
      </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">dot_product_2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v2</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">if</span> <span class="special">(</span><span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">v2</span><span class="special">.</span><span class="identifier">size</span><span class="special">())</span>
      <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span><span class="special">(</span><span class="string">"Mismatched arguments"</span><span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// If we know that most of our data is of a certain range of values, then we can use a cpp_int type</span>
   <span class="comment">// with an internal cache large enough to *probably* not require an allocation:</span>
   <span class="comment">//</span>
   <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;</span><span class="number">1024</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">result</span><span class="special">;</span>
   <span class="keyword">for</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">result</span> <span class="special">+=</span> <span class="identifier">v1</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">v2</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
   <span class="comment">//</span>
   <span class="comment">// We can't rely on the named-return-value optimisation here, since the variable being returned</span>
   <span class="comment">// is a different type to the return value.  However, since these are "equivalent" types we</span>
   <span class="comment">// can move the result to the return value and get all the expected move-optimisations should</span>
   <span class="comment">// variable result have dynamically allocated:</span>
   <span class="comment">//</span>
   <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">result</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
        Before we compare performance though, there is one other obvious thing we
        could try. By simply declaring a variable for the result of the intermediate
        multiplications, and reusing that variable each time through the loop, we
        might also expect to greatly reduce the number of allocations required.
      </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">dot_product_3</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;&amp;</span> <span class="identifier">v2</span><span class="special">)</span>
<span class="special">{</span>
   <span class="keyword">if</span> <span class="special">(</span><span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">v2</span><span class="special">.</span><span class="identifier">size</span><span class="special">())</span>
      <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span><span class="special">(</span><span class="string">"Mismatched arguments"</span><span class="special">);</span>

   <span class="identifier">cpp_int</span> <span class="identifier">result</span><span class="special">,</span> <span class="identifier">term</span><span class="special">;</span>
   <span class="keyword">for</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">v1</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="comment">//</span>
      <span class="comment">// Re-use the same variable for the result of the multiplications, rather than rely on </span>
      <span class="comment">// an internally generated temporary.  Depending on the input data, this may allocate</span>
      <span class="comment">// a few times depending how soon in the input vector's we encounter the largest values.</span>
      <span class="comment">// In the best case though, or for fairly uniformly sized input data, we will allocate </span>
      <span class="comment">// only once:</span>
      <span class="comment">//</span>
      <span class="identifier">term</span> <span class="special">=</span> <span class="identifier">v1</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">v2</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
      <span class="identifier">result</span> <span class="special">+=</span> <span class="identifier">term</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="comment">//</span>
   <span class="comment">// Named-return value optimisation (even better than a move):</span>
   <span class="comment">//</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        We'll begin by comparing how many actual allocations were required to calculate
        the dot product of 1000 value vectors for random data with various bit counts:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Bit Count
                </p>
              </th>
<th>
                <p>
                  Allocations Count Version 1
                </p>
              </th>
<th>
                <p>
                  Allocations Count Version 2
                </p>
              </th>
<th>
                <p>
                  Allocations Count Version 3
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  32
                </p>
              </td>
<td>
                <p>
                  1<a href="#ftn.boost_multiprecision.tut.mixed.f0" class="footnote" name="boost_multiprecision.tut.mixed.f0"><sup class="footnote">[1]</sup></a>
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
<td>
                <p>
                  0
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  64
                </p>
              </td>
<td>
                <p>
                  1001
                </p>
              </td>
<td>
                <p>
                  1<a href="#ftn.boost_multiprecision.tut.mixed.f1" class="footnote" name="boost_multiprecision.tut.mixed.f1"><sup class="footnote">[2]</sup></a>
                </p>
              </td>
<td>
                <p>
                  1
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  128
                </p>
              </td>
<td>
                <p>
                  1002
                </p>
              </td>
<td>
                <p>
                  1
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  256
                </p>
              </td>
<td>
                <p>
                  1002
                </p>
              </td>
<td>
                <p>
                  1
                </p>
              </td>
<td>
                <p>
                  3<a href="#ftn.boost_multiprecision.tut.mixed.f2" class="footnote" name="boost_multiprecision.tut.mixed.f2"><sup class="footnote">[3]</sup></a>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  512
                </p>
              </td>
<td>
                <p>
                  1002
                </p>
              </td>
<td>
                <p>
                  1
                </p>
              </td>
<td>
                <p>
                  3
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  1024
                </p>
              </td>
<td>
                <p>
                  1002
                </p>
              </td>
<td>
                <p>
                  1001<a href="#ftn.boost_multiprecision.tut.mixed.f3" class="footnote" name="boost_multiprecision.tut.mixed.f3"><sup class="footnote">[4]</sup></a>
                </p>
              </td>
<td>
                <p>
                  3
                </p>
              </td>
</tr>
</tbody>
<tbody class="footnotes"><tr><td colspan="4">
<div id="ftn.boost_multiprecision.tut.mixed.f0" class="footnote"><p><a href="#boost_multiprecision.tut.mixed.f0" class="para"><sup class="para">[1] </sup></a>
                    Here everything fits within <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>'s
                    default internal cache, so no allocation are required.
                  </p></div>
<div id="ftn.boost_multiprecision.tut.mixed.f1" class="footnote"><p><a href="#boost_multiprecision.tut.mixed.f1" class="para"><sup class="para">[2] </sup></a>
                    A single allocation for the return value.
                  </p></div>
<div id="ftn.boost_multiprecision.tut.mixed.f2" class="footnote"><p><a href="#boost_multiprecision.tut.mixed.f2" class="para"><sup class="para">[3] </sup></a>
                    Here the input data is such that more than one allocation is
                    required for the temporary.
                  </p></div>
<div id="ftn.boost_multiprecision.tut.mixed.f3" class="footnote"><p><a href="#boost_multiprecision.tut.mixed.f3" class="para"><sup class="para">[4] </sup></a>
                    At this point we exceed the internal cache of our internal calculation
                    type.
                  </p></div>
</td></tr></tbody>
</table></div>
<p>
        Timings for the three methods are as follows (MSVC-16.8.0, x64):
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Bit Count
                </p>
              </th>
<th>
                <p>
                  time/ms Version 1
                </p>
              </th>
<th>
                <p>
                  time/ms Version 2
                </p>
              </th>
<th>
                <p>
                  time/ms Version 3
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  32
                </p>
              </td>
<td>
                <p>
                  0.021
                </p>
              </td>
<td>
                <p>
                  0.021
                </p>
              </td>
<td>
                <p>
                  0.021
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  64
                </p>
              </td>
<td>
                <p>
                  0.032
                </p>
              </td>
<td>
                <p>
                  0.032
                </p>
              </td>
<td>
                <p>
                  0.029
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  128
                </p>
              </td>
<td>
                <p>
                  0.099
                </p>
              </td>
<td>
                <p>
                  0.041
                </p>
              </td>
<td>
                <p>
                  0.041
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  256
                </p>
              </td>
<td>
                <p>
                  0.154
                </p>
              </td>
<td>
                <p>
                  0.091
                </p>
              </td>
<td>
                <p>
                  0.094
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  512
                </p>
              </td>
<td>
                <p>
                  0.323
                </p>
              </td>
<td>
                <p>
                  0.270
                </p>
              </td>
<td>
                <p>
                  0.269
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  1024
                </p>
              </td>
<td>
                <p>
                  0.998
                </p>
              </td>
<td>
                <p>
                  0.995
                </p>
              </td>
<td>
                <p>
                  0.949
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        As you can see, there is a sweet spot for middling-sized integers where we
        gain: if the values are small, then <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>'s
        own internal cache is large enough anyway, and no allocation occur. Conversely,
        if the values are sufficiently large, then the cost of the actual arithmetic
        dwarfs the memory allocation time. In this particular case, carefully writing
        the code (version 3) is clearly at least as good as using a separate type
        with a larger cache. However, there may be times when it's not practical
        to re-write existing code, purely to optimise it for the multiprecision use
        case.
      </p>
<p>
        A typical example where we can't rewrite our code to avoid unnecessary allocations,
        occurs when we're calling an external routine. For example the arc length
        of an ellipse with radii <span class="emphasis"><em>a</em></span> and <span class="emphasis"><em>b</em></span>
        is given by:
      </p>
<pre class="programlisting">L(a, b) = 4aE(k)</pre>
<p>
        with:
      </p>
<pre class="programlisting">k = √(1 - b<sup>2</sup>/a<sup>2</sup>)</pre>
<p>
        where <span class="emphasis"><em>E(k)</em></span> is the complete elliptic integral of the
        second kind, which is available as a template function <code class="computeroutput"><span class="identifier">ellint_2</span></code>
        in Boost.Math.
      </p>
<p>
        Naively, we might implement this for use with <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>
        like this:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">N</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">elliptic_arc_length_1</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">k</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="number">1</span> <span class="special">-</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span> <span class="special">/</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">*</span> <span class="identifier">a</span><span class="special">));</span>
   <span class="keyword">return</span> <span class="number">4</span> <span class="special">*</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">k</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
        But we might also try mixing our arithmetic types - regular dynamically allocated
        <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>'s
        for the interface to minimise memory footprint in our external storage, and
        statically allocated <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>'s
        for the internal arithmetic:
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">N</span><span class="special">&gt;</span>
<span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">elliptic_arc_length_2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;</span> <span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">)</span>
<span class="special">{</span>
   <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span> <span class="identifier">allocate_stack</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">k</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="number">1</span> <span class="special">-</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">b</span> <span class="special">/</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">*</span> <span class="identifier">a</span><span class="special">));</span>
   <span class="keyword">return</span> <span class="number">4</span> <span class="special">*</span> <span class="identifier">a</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">k</span><span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
        The performance comparisons are surprisingly stark:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  N
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;&gt;</span></code>
                  / ms
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">,</span>
                  <span class="identifier">allocate_stack</span><span class="special">&gt;&gt;</span></code>
                  / ms
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  30
                </p>
              </td>
<td>
                <p>
                  19.5
                </p>
              </td>
<td>
                <p>
                  3.1
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  40
                </p>
              </td>
<td>
                <p>
                  12.5
                </p>
              </td>
<td>
                <p>
                  6.2
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  50
                </p>
              </td>
<td>
                <p>
                  14.4
                </p>
              </td>
<td>
                <p>
                  6.6
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  60
                </p>
              </td>
<td>
                <p>
                  18.0
                </p>
              </td>
<td>
                <p>
                  9.5
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  70
                </p>
              </td>
<td>
                <p>
                  18.0
                </p>
              </td>
<td>
                <p>
                  9.6
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  80
                </p>
              </td>
<td>
                <p>
                  20.0
                </p>
              </td>
<td>
                <p>
                  12.8
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        As before, the results are for MSVC-16.8.0/x64, and in point of fact, the
        results do not always favour non-allocating types so much, it does depend
        very much on the special function being called and/or the arguments used.
      </p>
<h5>
<a name="boost_multiprecision.tut.mixed.h3"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.mixed.backends_with_optimized_mixed_pr"></a></span><a class="link" href="mixed.html#boost_multiprecision.tut.mixed.backends_with_optimized_mixed_pr">Backends
        With Optimized Mixed Precision Arithmetic</a>
      </h5>
<p>
        The following backends have at least some direct support for mixed-precision
        arithmetic, and therefore avoid creating unnecessary temporaries when using
        the interfaces above. Therefore when using these types it's more efficient
        to use mixed-precision arithmetic, than it is to explicitly cast the operands
        to the result type:
      </p>
<p>
        <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>,
        <a class="link" href="floats/gmp_float.html" title="gmp_float">gmp_float</a>,
        <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rounding.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="variable.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/new_backend.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Writing a New Backend</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="eigen.html" title="Eigen Interoperability">
<link rel="next" href="../ref.html" title="Reference">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="eigen.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.new_backend"></a><a class="link" href="new_backend.html" title="Writing a New Backend">Writing a New Backend</a>
</h3></div></div></div>
<p>
        The formal requirements for a backend to class <code class="computeroutput"><span class="identifier">number</span></code>
        are given in the reference, but to help speed and simplify the process there
        is a header <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/skeleton_backend.hpp" target="_top">skeleton_backend.hpp</a>
        where all the methods needed to be written are declared but nothing is implemented.
        The process of writing a new backend then simplifies to:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Save skeleton_backend.hpp under a new name and change its #include guards
            to match.
          </li>
<li class="listitem">
            Search and replace <code class="computeroutput"><span class="identifier">skeleton_backend</span></code>
            to the name of the new backend type.
          </li>
<li class="listitem">
            Fill in the blanks in the class definition and for the compulsary non-members.
          </li>
<li class="listitem">
            Don't forget to mark the functions as <code class="computeroutput"><span class="keyword">inline</span></code>,
            <code class="computeroutput"><span class="keyword">constexpr</span></code> and <code class="computeroutput"><span class="keyword">noexcept</span></code> as required.
          </li>
<li class="listitem">
            Optionally fill in some of the optional methods - the header declares
            these in rather verbose form, for example with overloads for every single
            arithmetic type. No sane backend would ever implement all of these, just
            choose the ones that make sense and leave the others.
          </li>
<li class="listitem">
            Add convenience typedefs for the actual instantiation(s) of class <code class="computeroutput"><span class="identifier">number</span></code> that will use the new backend.
          </li>
</ul></div>
<p>
        To test the new backend, start with a basic arithmetic test, this is a test
        case under <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">test</span></code>
        that looks something like:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">my_new_number_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="string">"test_arithmetic.hpp"</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">my_new_number_type</span><span class="special">&gt;();</span>
   <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre>
<p>
        This will basically "instantiate everything", and perform a few
        runtime sanity checks; it is a very good test that you have written legal
        code!
      </p>
<p>
        You should also create a "header include test" that verifies that
        the new header includes everything it should, see <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/../../test/include_test/mpfr_include_test.cpp" target="_top">mpfr_include_test.cpp</a>
        for an example.
      </p>
<p>
        For integer types, you should add the new type to at least the following
        tests as well:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            test_hash.cpp
          </li>
<li class="listitem">
            test_int_io.cpp
          </li>
<li class="listitem">
            test_move.cpp
          </li>
<li class="listitem">
            test_numeric_limits.cpp
          </li>
</ul></div>
<p>
        For floating point types, you should add the new type to at least the following
        tests as well:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            test_acos.cpp
          </li>
<li class="listitem">
            test_asin.cpp
          </li>
<li class="listitem">
            test_atan.cpp
          </li>
<li class="listitem">
            test_constants.cpp
          </li>
<li class="listitem">
            test_cos.cpp
          </li>
<li class="listitem">
            test_cosh.cpp
          </li>
<li class="listitem">
            test_exp.cpp
          </li>
<li class="listitem">
            test_float_io.cpp
          </li>
<li class="listitem">
            test_fpclassify.cpp
          </li>
<li class="listitem">
            test_hash.cpp
          </li>
<li class="listitem">
            test_log.cpp
          </li>
<li class="listitem">
            test_move.cpp
          </li>
<li class="listitem">
            test_numeric_limits.cpp
          </li>
<li class="listitem">
            test_pow.cpp
          </li>
<li class="listitem">
            test_round.cpp
          </li>
<li class="listitem">
            test_sf_import_c99.cpp
          </li>
<li class="listitem">
            test_sin.cpp
          </li>
<li class="listitem">
            test_sinh.cpp
          </li>
<li class="listitem">
            test_sqrt.cpp
          </li>
<li class="listitem">
            test_tan.cpp
          </li>
<li class="listitem">
            test_tanh.cpp
          </li>
<li class="listitem">
            concepts/number_concept_check.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_basic.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_bessel.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_beta.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_beta_2.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_beta_3.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_elliptic.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_gamma.cpp
          </li>
<li class="listitem">
            concepts/sf_concept_check_poly.cpp
          </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="eigen.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/primetest.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Primality Testing</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="random.html" title="Generating Random Numbers">
<link rel="next" href="lits.html" title="Literal Types and constexpr Support">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="lits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.primetest"></a><a class="link" href="primetest.html" title="Primality Testing">Primality Testing</a>
</h3></div></div></div>
<p>
        The library implements a Miller-Rabin test for primality:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">miller_rabin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Engine</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">,</span> <span class="identifier">Engine</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">expression_template_option</span> <span class="identifier">ExpressionTemplates</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Engine</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">Backend</span><span class="special">,</span> <span class="identifier">ExpressionTemplates</span><span class="special">&gt;&amp;</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">trials</span><span class="special">);</span>
</pre>
<p>
        These functions perform a Miller-Rabin test for primality, if the result
        is <code class="computeroutput"><span class="keyword">false</span></code> then <span class="emphasis"><em>n</em></span>
        is definitely composite, while if the result is true then n is probably prime.
        The probability to declare a composite n as probable prime is at most 0.25<sup>trials</sup>.
        Note that this does not allow a statement about the probability of n being
        actually prime (for that, the prior probability would have to be known).
        The algorithm used performs some trial divisions to exclude small prime factors,
        does one Fermat test to exclude many more composites, and then uses the Miller-Rabin
        algorithm straight out of Knuth Vol 2, which recommends 25 trials for a pretty
        strong likelihood that <span class="emphasis"><em>n</em></span> is prime.
      </p>
<p>
        The third optional argument is for a Uniform Random Number Generator from
        Boost.Random. When not provided the <code class="computeroutput"><span class="identifier">mt19937</span></code>
        generator is used. Note that when producing random primes then you should
        probably use a different random number generator to produce candidate prime
        numbers for testing, than is used internally by <code class="computeroutput"><span class="identifier">miller_rabin_test</span></code>
        for determining whether the value is prime. It also helps of course to seed
        the generators with some source of randomness.
      </p>
<p>
        The following example searches for a prime <code class="computeroutput"><span class="identifier">p</span></code>
        for which <code class="computeroutput"><span class="special">(</span><span class="identifier">p</span><span class="special">-</span><span class="number">1</span><span class="special">)/</span><span class="number">2</span></code> is also probably prime:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">miller_rabin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iomanip</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="keyword">typedef</span> <span class="identifier">cpp_int</span> <span class="identifier">int_type</span><span class="special">;</span>
   <span class="identifier">mt11213b</span> <span class="identifier">base_gen</span><span class="special">(</span><span class="identifier">clock</span><span class="special">());</span>
   <span class="identifier">independent_bits_engine</span><span class="special">&lt;</span><span class="identifier">mt11213b</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">int_type</span><span class="special">&gt;</span> <span class="identifier">gen</span><span class="special">(</span><span class="identifier">base_gen</span><span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// We must use a different generator for the tests and number generation, otherwise</span>
   <span class="comment">// we get false positives.</span>
   <span class="comment">//</span>
   <span class="identifier">mt19937</span> <span class="identifier">gen2</span><span class="special">(</span><span class="identifier">clock</span><span class="special">());</span>

   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">100000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">int_type</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">gen</span><span class="special">();</span>
      <span class="keyword">if</span><span class="special">(</span><span class="identifier">miller_rabin_test</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span> <span class="number">25</span><span class="special">,</span> <span class="identifier">gen2</span><span class="special">))</span>
      <span class="special">{</span>
         <span class="comment">// Value n is probably prime, see if (n-1)/2 is also prime:</span>
         <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"We have a probable prime with value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">n</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
         <span class="keyword">if</span><span class="special">(</span><span class="identifier">miller_rabin_test</span><span class="special">((</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">)/</span><span class="number">2</span><span class="special">,</span> <span class="number">25</span><span class="special">,</span> <span class="identifier">gen2</span><span class="special">))</span>
         <span class="special">{</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"We have a safe prime with value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span> <span class="special">&lt;&lt;</span> <span class="identifier">n</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
            <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
         <span class="special">}</span>
      <span class="special">}</span>
   <span class="special">}</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Ooops, no safe primes were found - probably a bad choice of seed values!"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="lits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/random.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Generating Random Numbers</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="conversions.html" title="Constructing and Interconverting Between Number Types">
<link rel="next" href="primetest.html" title="Primality Testing">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="conversions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="primetest.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.random"></a><a class="link" href="random.html" title="Generating Random Numbers">Generating Random Numbers</a>
</h3></div></div></div>
<p>
        Random numbers are generated in conjunction with Boost.Random.
      </p>
<p>
        There is a single generator that supports generating random integers with
        large bit counts: <a href="http://www.boost.org/doc/html/boost/random/independent_bits_engine.html" target="_top"><code class="computeroutput"><span class="identifier">independent_bits_engine</span></code></a>. This type
        can be used with either <span class="emphasis"><em>unbounded</em></span> integer types, or
        with <span class="emphasis"><em>bounded</em></span> (ie fixed precision) unsigned integers:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>

   <span class="comment">//</span>
   <span class="comment">// Declare our random number generator type, the underlying generator</span>
   <span class="comment">// is the Mersenne twister mt19937 engine, and we'll generate 256 bit</span>
   <span class="comment">// random values, independent_bits_engine will make multiple calls</span>
   <span class="comment">// to the underlying engine until we have the requested number of bits:</span>
   <span class="comment">//</span>
   <span class="keyword">typedef</span> <span class="identifier">independent_bits_engine</span><span class="special">&lt;</span><span class="identifier">mt19937</span><span class="special">,</span> <span class="number">256</span><span class="special">,</span> <span class="identifier">cpp_int</span><span class="special">&gt;</span> <span class="identifier">generator_type</span><span class="special">;</span>
   <span class="identifier">generator_type</span> <span class="identifier">gen</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some values:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">gen</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Alternatively if we wish to generate random values in a fixed-precision</span>
   <span class="comment">// type, then we must use an unsigned type in order to adhere to the</span>
   <span class="comment">// conceptual requirements of the generator:</span>
   <span class="comment">//</span>
   <span class="keyword">typedef</span> <span class="identifier">independent_bits_engine</span><span class="special">&lt;</span><span class="identifier">mt19937</span><span class="special">,</span> <span class="number">512</span><span class="special">,</span> <span class="identifier">uint512_t</span><span class="special">&gt;</span> <span class="identifier">generator512_type</span><span class="special">;</span>
   <span class="identifier">generator512_type</span> <span class="identifier">gen512</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some 1024-bit unsigned values:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hex</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showbase</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">gen512</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
      <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Program output is:
      </p>
<pre class="programlisting">0xD091BB5C22AE9EF6E7E1FAEED5C31F792082352CF807B7DFE9D300053895AFE1
0xA1E24BBA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810
0xF51F2AE7FF1816E4F702EF59F7BADAFA285954A1B9D09511F878C4B3FB2A0137
0xF508E4AA1C1FE6527C419418CC50AA59CCDF2E5C4C0A1F3B2452A9DC01397D8D
0x6BF88C311CCA797AEA6DA4AEA3C78807CACE1969E0E0D4ADF5A14BAB80F00988
0xA7DE9F4CCC450CBA0924668F5C7DC380D96089C53640AC4CEF1A2E6DAE6D9426
0xADC1965B6613BA46C1FB41C2BD9B0ECDBE3DEDFC7989C8EE6468FD6E6C0DF032
0xA7CD66342C826D8B2BD2E4124D4A2DBEB4BF6FA7CC1A89590826328251097330
0x46E46CB0DF577EC20BD1E364262C556418DDA0C9FE7B45D9D2CE21C9D268409A
0xB1E049E1200BFA47512D6E73C3851EEEF341C0817D973E4808D17554A9E20D28
0xD091BB5C22AE9EF6E7E1FAEED5C31F792082352CF807B7DFE9D300053895AFE1A1E24BBA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810
0xF51F2AE7FF1816E4F702EF59F7BADAFA285954A1B9D09511F878C4B3FB2A0137F508E4AA1C1FE6527C419418CC50AA59CCDF2E5C4C0A1F3B2452A9DC01397D8D
0x6BF88C311CCA797AEA6DA4AEA3C78807CACE1969E0E0D4ADF5A14BAB80F00988A7DE9F4CCC450CBA0924668F5C7DC380D96089C53640AC4CEF1A2E6DAE6D9426
0xADC1965B6613BA46C1FB41C2BD9B0ECDBE3DEDFC7989C8EE6468FD6E6C0DF032A7CD66342C826D8B2BD2E4124D4A2DBEB4BF6FA7CC1A89590826328251097330
0x46E46CB0DF577EC20BD1E364262C556418DDA0C9FE7B45D9D2CE21C9D268409AB1E049E1200BFA47512D6E73C3851EEEF341C0817D973E4808D17554A9E20D28
0x70518CE6203AC30361ADD0AB35D0430CC3F8E8920D1C8509CB92388E095436BF2FD6E20868A29AF97D61330B753EC6FC7211EFEA7CD15133A574C4FFCB41F198
0xB598EEF6EBBE7347C1332568CEBA5A7046A99459B4AD9F11AE00FEAA00B8B573A7B480B6B5F0B06C29A0EC27A4DAA0101E76A1C574BE91337F94C950C61F6ED6
0xF5B1C7A192E195F8572384D4E0732C8895D41B68CEE496C3394BBD52048CD47CC05309BED23D2D63414DE9C5D2229F23818666A3F0A8B109B2F6B12769A48341
0xE4123C566C548C8FF5941F6194B993AA8C1651342876763C237CE42EC300D11B263821CA3AEB820241EC0F84CF4AC36DD7393EE6FD0FC06A4118A30A551B54A4
0xD074F86F4CC1C54A3E57A70303774CDAEDE43895379CE62759988939E8490DDC325410E1D9352F6A4047080AF47C081D9DB51A85C765D71F79297527FCCA2773
</pre>
<p>
        In addition, the generator adaptors <a href="http://www.boost.org/doc/html/boost/random/discard_block_engine.html" target="_top"><code class="computeroutput"><span class="identifier">discard_block</span></code></a>, <a href="http://www.boost.org/doc/html/boost/random/xor_combine_engine.html" target="_top"><code class="computeroutput"><span class="identifier">xor_combine_engine</span></code></a> and <a href="http://www.boost.org/doc/html/boost/random/discrete_distribution.html" target="_top"><code class="computeroutput"><span class="identifier">discrete_distribution</span></code></a> can be used
        with multiprecision types. Note that if you seed an <code class="computeroutput"><span class="identifier">independent_bits_engine</span></code>,
        then you are actually seeding the underlying generator, and should therefore
        provide a sequence of unsigned 32-bit values as the seed.
      </p>
<p>
        Alternatively we can generate integers in a given range using <a href="http://www.boost.org/doc/html/boost/random/uniform_int_distribution.html" target="_top"><code class="computeroutput"><span class="identifier">uniform_int_distribution</span></code></a>, this
        will invoke the underlying engine multiple times to build up the required
        number of bits in the result:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>

   <span class="comment">//</span>
   <span class="comment">// Generate integers in a given range using uniform_int,</span>
   <span class="comment">// the underlying generator is invoked multiple times</span>
   <span class="comment">// to generate enough bits:</span>
   <span class="comment">//</span>
   <span class="identifier">mt19937</span> <span class="identifier">mt</span><span class="special">;</span>
   <span class="identifier">uniform_int_distribution</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&gt;</span> <span class="identifier">ui</span><span class="special">(-(</span><span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">256</span><span class="special">),</span> <span class="identifier">cpp_int</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">256</span><span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// Generate the numbers:</span>
   <span class="comment">//</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">ui</span><span class="special">(</span><span class="identifier">mt</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Program output is
      </p>
<pre class="programlisting">25593993629538149833210527544371584707508847463356155903670894544241785158492
12721121657520147247744796431842326146296294180809160027132416389225539366745
106034929479008809862776424170460808190085984129117168803272987114325199071833
86048861429530654936263414134573980939351899046345384016090167510299251354700
-23473382144925885755951447143660880642389842563343761080591177733698450031250
76840269649240973945508128641415259490679375154523618053296924666747244530145
21638369166612496703991271955994563624044383325105383029306009417224944272131
18829152205014764576551421737727569993966577957447887116062495161081023584880
101521572847669971701030312596819435590097618913255156117898217707115132658117
-97490271301923067621481012355971422109456300816856752380346627103308328292057
</pre>
<p>
        It is also possible to use <a href="http://www.boost.org/doc/html/boost/random/uniform_int_distribution.html" target="_top"><code class="computeroutput"><span class="identifier">uniform_int_distribution</span></code></a> with a
        multiprecision generator such as <a href="http://www.boost.org/doc/html/boost/random/independent_bits_engine.html" target="_top"><code class="computeroutput"><span class="identifier">independent_bits_engine</span></code></a>. Or to
        use <a href="http://www.boost.org/doc/html/boost/random/uniform_smallint.html" target="_top"><code class="computeroutput"><span class="identifier">uniform_smallint</span></code></a> or <a href="http://www.boost.org/doc/html/boost/random/random_number_generator.html" target="_top"><code class="computeroutput"><span class="identifier">random_number_generator</span></code></a> with multiprecision
        types.
      </p>
<p>
        floating-point values in [0,1) are most easily generated using <a href="http://www.boost.org/doc/html/boost/random/generate_canonical.html" target="_top"><code class="computeroutput"><span class="identifier">generate_canonical</span></code></a>, note that
        <code class="computeroutput"><span class="identifier">generate_canonical</span></code> will call
        the generator multiple times to produce the requested number of bits, for
        example we can use it with a regular generator like so:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>

   <span class="identifier">mt19937</span> <span class="identifier">gen</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate the values:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="number">50</span><span class="special">);</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">generate_canonical</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">&gt;(</span><span class="identifier">gen</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Which produces the following output:
      </p>
<pre class="programlisting">0.96886777112423135248554451482797431507115448261086
0.54722059636785192454525760726084778627750790023546
0.99646132554800874317788284808573062871409279729804
0.98110969177693891782396443737643892769773768718591
0.29702944955795083040856753579705872634075574515969
0.63976335709815275010379796044374742646738557798647
0.79792861516022605265555700991255998690336456180995
0.68135953856026596523755400091345037778580909233387
0.47475868061723477935404326837783394169122045199915
0.30191312687731969398296589840622989141067852863748
0.87242882006730022427155209451091472382531795659709
0.82190326480741096300318873712966555706035846579562
0.49058903962146072778707295967429263659897501512813
0.2102090745190061764133345429475530760261103345204
0.4087311609617603484960794513055502599728804206333
0.79397497154919267900450180642484943996546102712187
0.70577425166871982574205252142383800792823003687121
0.64396095652194035523385641523010248768636064728226
0.5737546665965914620678634509134819579811035412969
0.017773895576552474810236796736785695789752666554273
</pre>
<p>
        Note however, the distributions do not invoke the generator multiple times
        to fill up the mantissa of a multiprecision floating-point type with random
        bits. For these therefore, we should probably use a multiprecision generator
        (ie <code class="computeroutput"><span class="identifier">independent_bits_engine</span></code>)
        in combination with the distribution:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some distruted values:</span>
   <span class="comment">//</span>
   <span class="identifier">uniform_real_distribution</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;</span> <span class="identifier">ur</span><span class="special">(-</span><span class="number">20</span><span class="special">,</span> <span class="number">20</span><span class="special">);</span>
   <span class="identifier">gamma_distribution</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;</span> <span class="identifier">gd</span><span class="special">(</span><span class="number">20</span><span class="special">);</span>
   <span class="identifier">independent_bits_engine</span><span class="special">&lt;</span><span class="identifier">mt19937</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits</span><span class="special">,</span> <span class="identifier">cpp_int</span><span class="special">&gt;</span> <span class="identifier">gen</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some values:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="number">50</span><span class="special">);</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">ur</span><span class="special">(</span><span class="identifier">gen</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">gd</span><span class="special">(</span><span class="identifier">gen</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        Which produces the following output:
      </p>
<pre class="programlisting">-18.576837157065858312137736538355805944098004018928
4.5605477000094480453928920098152026546185388161216
-1.7611402252150150370944527411235180945558276280598
-2.471338289511354190492328039842914272146783953149
-7.4131520453411321647183692139916357315276121488316
-9.192739117661751364518299455475684051782402347659
7.0126880787149555595443325648941661436898526919013
2.8554749162054097111723076181877881960039268668423
14.390501287552165467965587841551705310012046701036
-8.9747073123748752412086051960748002945548570524149
-8.1305063133718605220959174700954037986278348616362
9.5496899464463627949564295930962040525540578754312
-15.309681742947663333436391348699943078942921692008
2.0454914298189175280771944784358385982869708951824
-10.069253024538932382193363493367304983742246396276
13.449212808583153116670057807764145176004060370818
-6.0065092542772507561228141992257782449634820245355
15.00971466974838379824678369267201922989930663822
16.158514812070905438581736305533045434508525979205
-2.1531361299576399413547008719541457739794964378093
19.398278792113040046930806838893737245011219380822
12.965216582396067073600685365545292876001524716225
19.561779374349650983983836397553672788578622096947
15.982213641588944604037715576313848977716540941271
23.96044616946856385664151481695038833903083043492
21.054716943622792848187523422423642819628010070375
18.596078774135209530930707331338838805575875990091
19.539530839287848627426769425090194390388333335812
17.176133236359396942946640290935498641489373354297
16.228802394876800099035133760539461530246286999827
23.63807160907473465631049083277558060813997674519
12.838499607321990428122225501321564153572478845401
16.878362445712403300584931374939967549572637230102
20.646246409377134464856282996941395597420615529803
16.602429236226052406561338766554127142762673418695
21.680007865714197450495711030406314524681744024329
21.038948660115771777833205901845639760348321521616
30.494499676527802078320016654058105593076348727966
18.704734464995637480940828829962787676146589788572
22.502216997171061548799304902323434654678156658236
</pre>
<p>
        And finally, it is possible to use the floating-point generators <a href="http://www.boost.org/doc/html/boost/random/lagged_fibonacci_01_engine.html" target="_top"><code class="computeroutput"><span class="identifier">lagged_fibonacci_01_engine</span></code></a> and
        <a href="http://www.boost.org/doc/html/boost/random/subtract_with_idp144360752.html" target="_top"><code class="computeroutput"><span class="identifier">subtract_with_carry_01_engine</span></code></a> directly
        with multiprecision floating-point types. It's worth noting however, that
        there is a distinct lack of literature on generating high bit-count random
        numbers, and therefore a lack of "known good" parameters to use
        with these generators in this situation. For this reason, these should probably
        be used for research purposes only:
      </p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_bin_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">random</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">scoped_ptr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some multiprecision values, note that the generator is so large</span>
   <span class="comment">// that we have to allocate it on the heap, otherwise we may run out of</span>
   <span class="comment">// stack space!  We could avoid this by using a floating point type which</span>
   <span class="comment">// allocates it's internal storage on the heap - cpp_bin_float will do</span>
   <span class="comment">// this with the correct template parameters, as will the GMP or MPFR</span>
   <span class="comment">// based reals.</span>
   <span class="comment">//</span>
   <span class="keyword">typedef</span> <span class="identifier">lagged_fibonacci_01_engine</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">,</span> <span class="number">48</span><span class="special">,</span> <span class="number">44497</span><span class="special">,</span> <span class="number">21034</span> <span class="special">&gt;</span> <span class="identifier">big_fib_gen</span><span class="special">;</span>
   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">scoped_ptr</span><span class="special">&lt;</span><span class="identifier">big_fib_gen</span><span class="special">&gt;</span> <span class="identifier">pgen</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">big_fib_gen</span><span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// Generate some values:</span>
   <span class="comment">//</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="number">50</span><span class="special">);</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="special">(*</span><span class="identifier">pgen</span><span class="special">)()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// try again with a ranlux generator, this is not quite so large</span>
   <span class="comment">// so we can use the heap this time:</span>
   <span class="comment">//</span>
   <span class="keyword">typedef</span> <span class="identifier">subtract_with_carry_01_engine</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_50</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">-</span> <span class="number">5</span><span class="special">,</span> <span class="number">10</span><span class="special">,</span> <span class="number">24</span> <span class="special">&gt;</span> <span class="identifier">ranlux_big_base_01</span><span class="special">;</span>
   <span class="keyword">typedef</span> <span class="identifier">discard_block_engine</span><span class="special">&lt;</span> <span class="identifier">ranlux_big_base_01</span><span class="special">,</span> <span class="number">389</span><span class="special">,</span> <span class="number">24</span> <span class="special">&gt;</span> <span class="identifier">big_ranlux</span><span class="special">;</span>
   <span class="identifier">big_ranlux</span> <span class="identifier">rg</span><span class="special">;</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">rg</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="conversions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="primetest.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational/cpp_rational.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>cpp_rational</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../rational.html" title="Rational Number Types">
<link rel="prev" href="../rational.html" title="Rational Number Types">
<link rel="next" href="gmp_rational.html" title="gmp_rational">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.rational.cpp_rational"></a><a class="link" href="cpp_rational.html" title="cpp_rational">cpp_rational</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">cpp_int_backend</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span>    <span class="identifier">cpp_rational_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_rational_backend</span><span class="special">&gt;</span>         <span class="identifier">cpp_rational</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">cpp_rational_backend</span></code>
          type is used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_rational</span></code>.
          It provides a rational number type that is a drop-in replacement for the
          native C++ number types, but with unlimited precision.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">cpp_rational</span></code> are copy
          constructible and assignable from type <code class="computeroutput"><span class="identifier">cpp_int</span></code>.
        </p>
<p>
          There is also a two argument constructor that accepts a numerator and denominator:
          both of type <code class="computeroutput"><span class="identifier">cpp_int</span></code>.
        </p>
<p>
          There are also non-member functions:
        </p>
<pre class="programlisting"><span class="identifier">cpp_int</span> <span class="identifier">numerator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">cpp_rational</span><span class="special">&amp;);</span>
<span class="identifier">cpp_int</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">cpp_rational</span><span class="special">&amp;);</span>
</pre>
<p>
          which return the numerator and denominator of the number.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">cpp_rational</span></code>s
              have the value zero.
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid rational
              number.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.rational.cpp_rational.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.rational.cpp_rational.example"></a></span><a class="link" href="cpp_rational.html#boost_multiprecision.tut.rational.cpp_rational.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_int</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">cpp_rational</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">v</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000! / 10</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">numerator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">denominator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="identifier">cpp_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span>  <span class="comment">// component wise constructor</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gmp_rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational/gmp_rational.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>gmp_rational</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../rational.html" title="Rational Number Types">
<link rel="prev" href="cpp_rational.html" title="cpp_rational">
<link rel="next" href="tommath_rational.html" title="tommath_rational">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tommath_rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.rational.gmp_rational"></a><a class="link" href="gmp_rational.html" title="gmp_rational">gmp_rational</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">gmp_rational</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span> <span class="special">&gt;</span>         <span class="identifier">mpq_rational</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">gmp_rational</span></code> back-end
          is used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">mpq_rational</span></code>.
          It acts as a thin wrapper around the <a href="http://gmplib.org" target="_top">GMP</a>
          <code class="computeroutput"><span class="identifier">mpq_t</span></code> to provide a rational
          number type that is a drop-in replacement for the native C++ number types,
          but with unlimited precision.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_rational</span><span class="special">&gt;</span></code>
          are copy constructible and assignable from:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              The <a href="http://gmplib.org" target="_top">GMP</a> native types: <code class="computeroutput"><span class="identifier">mpz_t</span></code>, <code class="computeroutput"><span class="identifier">mpq_t</span></code>.
            </li>
<li class="listitem">
              <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<p>
          There is also a two-argument constructor that accepts a numerator and denominator
          (both of type <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">gmp_int</span><span class="special">&gt;</span></code>).
        </p>
<p>
          There are also non-member functions:
        </p>
<pre class="programlisting"><span class="identifier">mpz_int</span> <span class="identifier">numerator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mpq_rational</span><span class="special">&amp;);</span>
<span class="identifier">mpz_int</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mpq_rational</span><span class="special">&amp;);</span>
</pre>
<p>
          which return the numerator and denominator of the number.
        </p>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">mpq_t</span></code>
          via the <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">mpq_rational</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">mpq_rational</span></code>s
              have the value zero (this is the <a href="http://gmplib.org" target="_top">GMP</a>
              default behavior).
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid rational
              number.
            </li>
<li class="listitem">
              No changes are made to the <a href="http://gmplib.org" target="_top">GMP</a>
              library's global settings, so this type can coexist with existing
              <a href="http://gmplib.org" target="_top">GMP</a> code.
            </li>
<li class="listitem">
              The code can equally be used with <a href="http://mpir.org/" target="_top">MPIR</a>
              as the underlying library - indeed that is the preferred option on
              Win32.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.rational.gmp_rational.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.rational.gmp_rational.example"></a></span><a class="link" href="gmp_rational.html#boost_multiprecision.tut.rational.gmp_rational.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">gmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">mpq_rational</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">v</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000! / 10</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">numerator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">denominator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="identifier">mpq_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span>  <span class="comment">// component wise constructor</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>

   <span class="comment">// Access the underlying data:</span>
   <span class="identifier">mpq_t</span> <span class="identifier">q</span><span class="special">;</span>
   <span class="identifier">mpq_init</span><span class="special">(</span><span class="identifier">q</span><span class="special">);</span>
   <span class="identifier">mpq_set</span><span class="special">(</span><span class="identifier">q</span><span class="special">,</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">backend</span><span class="special">().</span><span class="identifier">data</span><span class="special">());</span>
   <span class="identifier">mpq_clear</span><span class="special">(</span><span class="identifier">q</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="cpp_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tommath_rational.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational/rational_adaptor.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>rational_adaptor</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../rational.html" title="Rational Number Types">
<link rel="prev" href="tommath_rational0.html" title="tommath_rational">
<link rel="next" href="../misc.html" title="Miscellaneous Number Types.">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tommath_rational0.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../misc.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.rational.rational_adaptor"></a><a class="link" href="rational_adaptor.html" title="rational_adaptor">rational_adaptor</a>
</h4></div></div></div>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">IntBackend</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">rational_adpater</span><span class="special">;</span>

<span class="special">}}</span>
</pre>
<p>
          The class template <code class="computeroutput"><span class="identifier">rational_adaptor</span></code>
          is a back-end for <code class="computeroutput"><span class="identifier">number</span></code>
          which converts any existing integer back-end into a rational-number back-end.
        </p>
<p>
          So for example, given an integer back-end type <code class="computeroutput"><span class="identifier">MyIntegerBackend</span></code>,
          the use would be something like:
        </p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">MyIntegerBackend</span><span class="special">&gt;</span>                    <span class="identifier">MyInt</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">rational_adaptor</span><span class="special">&lt;</span><span class="identifier">MyIntegerBackend</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">MyRational</span><span class="special">;</span>

<span class="identifier">MyRational</span> <span class="identifier">r</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">r</span> <span class="special">/=</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">MyInt</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">numerator</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">i</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tommath_rational0.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../misc.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational/tommath_rational.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>tommath_rational</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../rational.html" title="Rational Number Types">
<link rel="prev" href="gmp_rational.html" title="gmp_rational">
<link rel="next" href="tommath_rational0.html" title="tommath_rational">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tommath_rational0.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.rational.tommath_rational"></a><a class="link" href="tommath_rational.html" title="tommath_rational">tommath_rational</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">rational_adpater</span><span class="special">&lt;</span><span class="identifier">tommath_int</span><span class="special">&gt;</span>        <span class="identifier">tommath_rational</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">tommath_rational</span> <span class="special">&gt;</span>         <span class="identifier">tom_rational</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">tommath_rational</span></code> back-end
          is used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">tom_rational</span></code>.
          It acts as a thin wrapper around <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span><span class="special">&lt;</span><span class="identifier">tom_int</span><span class="special">&gt;</span></code> to provide a rational number type that
          is a drop-in replacement for the native C++ number types, but with unlimited
          precision.
        </p>
<p>
          The advantage of using this type rather than <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span><span class="special">&lt;</span><span class="identifier">tom_int</span><span class="special">&gt;</span></code> directly, is that it is expression-template
          enabled, greatly reducing the number of temporaries created in complex
          expressions.
        </p>
<p>
          There are also non-member functions:
        </p>
<pre class="programlisting"><span class="identifier">tom_int</span> <span class="identifier">numerator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">tom_rational</span><span class="special">&amp;);</span>
<span class="identifier">tom_int</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">tom_rational</span><span class="special">&amp;);</span>
</pre>
<p>
          which return the numerator and denominator of the number.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">tom_rational</span></code>s
              have the value zero (this the inherited Boost.Rational behavior).
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid rational
              number.
            </li>
<li class="listitem">
              No changes are made to <a href="http://libtom.net" target="_top">libtommath</a>'s
              global state, so this type can safely coexist with other <a href="http://libtom.net" target="_top">libtommath</a>
              code.
            </li>
<li class="listitem">
              Performance of this type has been found to be pretty poor - this need
              further investigation - but it appears that Boost.Rational needs some
              improvement in this area.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.rational.tommath_rational.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.rational.tommath_rational.example"></a></span><a class="link" href="tommath_rational.html#boost_multiprecision.tut.rational.tommath_rational.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">tom_rational</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">v</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000! / 10</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">numerator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">denominator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="identifier">tom_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// Component wise constructor</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gmp_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tommath_rational0.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational/tommath_rational0.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>tommath_rational</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../rational.html" title="Rational Number Types">
<link rel="prev" href="tommath_rational.html" title="tommath_rational">
<link rel="next" href="rational_adaptor.html" title="rational_adaptor">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tommath_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.rational.tommath_rational0"></a><a class="link" href="tommath_rational0.html" title="tommath_rational">tommath_rational</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">typedef</span> <span class="identifier">rational_adpater</span><span class="special">&lt;</span><span class="identifier">tommath_int</span><span class="special">&gt;</span>        <span class="identifier">tommath_rational</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">tommath_rational</span> <span class="special">&gt;</span>         <span class="identifier">tom_rational</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">tommath_rational</span></code> back-end
          is used via the typedef <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">tom_rational</span></code>.
          It acts as a thin wrapper around <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span><span class="special">&lt;</span><span class="identifier">tom_int</span><span class="special">&gt;</span></code> to provide a rational number type that
          is a drop-in replacement for the native C++ number types, but with unlimited
          precision.
        </p>
<p>
          The advantage of using this type rather than <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span><span class="special">&lt;</span><span class="identifier">tom_int</span><span class="special">&gt;</span></code> directly, is that it is expression-template
          enabled, greatly reducing the number of temporaries created in complex
          expressions.
        </p>
<p>
          There are also non-member functions:
        </p>
<pre class="programlisting"><span class="identifier">tom_int</span> <span class="identifier">numerator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">tom_rational</span><span class="special">&amp;);</span>
<span class="identifier">tom_int</span> <span class="identifier">denominator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">tom_rational</span><span class="special">&amp;);</span>
</pre>
<p>
          which return the numerator and denominator of the number.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">tom_rational</span></code>s
              have the value zero (this the inherited Boost.Rational behavior).
            </li>
<li class="listitem">
              Division by zero results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">overflow_error</span></code>
              being thrown.
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid rational
              number.
            </li>
<li class="listitem">
              No changes are made to <a href="http://libtom.net" target="_top">libtommath</a>'s
              global state, so this type can safely coexist with other <a href="http://libtom.net" target="_top">libtommath</a>
              code.
            </li>
<li class="listitem">
              Performance of this type has been found to be pretty poor - this need
              further investigation - but it appears that Boost.Rational needs some
              improvement in this area.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.rational.tommath_rational0.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.rational.tommath_rational0.example"></a></span><a class="link" href="tommath_rational0.html#boost_multiprecision.tut.rational.tommath_rational0.example">Example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">tommath</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span>

   <span class="identifier">tom_rational</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>

   <span class="comment">// Do some arithmetic:</span>
   <span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;=</span> <span class="number">1000</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
      <span class="identifier">v</span> <span class="special">*=</span> <span class="identifier">i</span><span class="special">;</span>
   <span class="identifier">v</span> <span class="special">/=</span> <span class="number">10</span><span class="special">;</span>

   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">v</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 1000! / 10</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">numerator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">denominator</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>

   <span class="identifier">tom_rational</span> <span class="identifier">w</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// Component wise constructor</span>
   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">w</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// prints 2/3</span>

   <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tommath_rational.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../rational.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational_adaptor.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rational.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Rational Number Types</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="complex/complex_adaptor.html" title="complex_adaptor">
<link rel="next" href="rational/cpp_rational.html" title="cpp_rational">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex/complex_adaptor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational/cpp_rational.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.rational"></a><a class="link" href="rational.html" title="Rational Number Types">Rational Number Types</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="rational/cpp_rational.html">cpp_rational</a></span></dt>
<dt><span class="section"><a href="rational/gmp_rational.html">gmp_rational</a></span></dt>
<dt><span class="section"><a href="rational/tommath_rational.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="rational/tommath_rational0.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="rational/rational_adaptor.html">rational_adaptor</a></span></dt>
</dl></div>
<p>
        The following back-ends provide rational number arithmetic:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend Type
                </p>
              </th>
<th>
                <p>
                  Header
                </p>
              </th>
<th>
                <p>
                  Radix
                </p>
              </th>
<th>
                <p>
                  Dependencies
                </p>
              </th>
<th>
                <p>
                  Pros
                </p>
              </th>
<th>
                <p>
                  Cons
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">cpp_rational</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/cpp_int.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  An all C++ Boost-licensed implementation.
                </p>
              </td>
<td>
                <p>
                  Slower than <a href="http://gmplib.org" target="_top">GMP</a>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">gmp_rational</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/gmp.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://gmplib.org" target="_top">GMP</a>
                </p>
              </td>
<td>
                <p>
                  Very fast and efficient back-end.
                </p>
              </td>
<td>
                <p>
                  Dependency on GNU licensed <a href="http://gmplib.org" target="_top">GMP</a>
                  library.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">tommath_rational</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/tommath.hpp
                </p>
              </td>
<td>
                <p>
                  2
                </p>
              </td>
<td>
                <p>
                  <a href="http://libtom.net" target="_top">libtommath</a>
                </p>
              </td>
<td>
                <p>
                  All C/C++ implementation that's Boost Software Licence compatible.
                </p>
              </td>
<td>
                <p>
                  Slower than <a href="http://gmplib.org" target="_top">GMP</a>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">rational_adaptor</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/multiprecision/rational_adaptor.hpp
                </p>
              </td>
<td>
                <p>
                  N/A
                </p>
              </td>
<td>
                <p>
                  none
                </p>
              </td>
<td>
                <p>
                  All C++ adaptor that allows any integer back-end type to be used
                  as a rational type.
                </p>
              </td>
<td>
                <p>
                  Requires an underlying integer back-end type.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span></code>
                </p>
              </td>
<td>
                <p>
                  boost/rational.hpp
                </p>
              </td>
<td>
                <p>
                  N/A
                </p>
              </td>
<td>
                <p>
                  None
                </p>
              </td>
<td>
                <p>
                  A C++ rational number type that can used with any <code class="computeroutput"><span class="identifier">number</span></code> integer type.
                </p>
              </td>
<td>
                <p>
                  The expression templates used by <code class="computeroutput"><span class="identifier">number</span></code>
                  end up being "hidden" inside <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rational</span></code>:
                  performance may well suffer as a result.
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex/complex_adaptor.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rational/cpp_rational.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/rounding.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Rounding Rules for Conversions</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="import_export.html" title="Importing and Exporting Data to and from cpp_int and cpp_bin_float">
<link rel="next" href="mixed.html" title="Mixed Precision Arithmetic">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="import_export.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mixed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.rounding"></a><a class="link" href="rounding.html" title="Rounding Rules for Conversions">Rounding Rules for
      Conversions</a>
</h3></div></div></div>
<p>
        As a general rule, all conversions between unrelated types are performed
        using basic arithmetic operations, therefore conversions are either exact,
        or follow the same rounding rules as arithmetic for the type in question.
      </p>
<p>
        The following table summarises the situation for conversions from native
        types:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Backend
                </p>
              </th>
<th>
                <p>
                  Rounding Rules
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
                </p>
              </td>
<td>
                <p>
                  Conversions from integer types are exact if the target has sufficient
                  precision, otherwise they truncate to the first 2^MaxBits bits
                  (modulo arithmetic). Conversions from floating-point types are
                  truncating to the nearest integer.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="ints/gmp_int.html" title="gmp_int">gmp_int</a>
                </p>
              </td>
<td>
                <p>
                  Conversions are performed by the GMP library except for conversion
                  from <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
                  which is truncating.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="ints/tom_int.html" title="tom_int">tom_int</a>
                </p>
              </td>
<td>
                <p>
                  Conversions from floating-point types are truncating, all others
                  are performed by libtommath and are exact.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="floats/gmp_float.html" title="gmp_float">gmp_float</a>
                </p>
              </td>
<td>
                <p>
                  Conversions are performed by the GMP library except for conversion
                  from <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
                  which should be exact provided the target type has as much precision
                  as a <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>
                </p>
              </td>
<td>
                <p>
                  All conversions are performed by the underlying MPFR library.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
                </p>
              </td>
<td>
                <p>
                  All conversions are performed using basic arithmetic operations
                  and are truncating.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="rational/gmp_rational.html" title="gmp_rational">gmp_rational</a>
                </p>
              </td>
<td>
                <p>
                  See <a class="link" href="ints/gmp_int.html" title="gmp_int">gmp_int</a>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="rational/cpp_rational.html" title="cpp_rational">cpp_rational</a>
                </p>
              </td>
<td>
                <p>
                  See <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <a class="link" href="rational/tommath_rational.html" title="tommath_rational">tommath_rational</a>
                </p>
              </td>
<td>
                <p>
                  See <a class="link" href="ints/tom_int.html" title="tom_int">tom_int</a>
                </p>
              </td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="import_export.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mixed.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/serial.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Boost.Serialization Support</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="gen_int.html" title="Generic Integer Operations">
<link rel="next" href="limits.html" title="Numeric Limits">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gen_int.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.serial"></a><a class="link" href="serial.html" title="Boost.Serialization Support">Boost.Serialization
      Support</a>
</h3></div></div></div>
<p>
        Support for serialization comes in two forms:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Classes <a class="link" href="../ref/number.html" title="number">number</a>,
            <a class="link" href="misc/debug_adaptor.html" title="debug_adaptor">debug_adaptor</a>,
            <a class="link" href="misc/logged_adaptor.html" title="logged_adaptor">logged_adaptor</a>
            and <a class="link" href="rational/rational_adaptor.html" title="rational_adaptor">rational_adaptor</a>
            have "pass through" serialization support which requires the
            underlying backend to be serializable.
          </li>
<li class="listitem">
            Backends <a class="link" href="ints/cpp_int.html" title="cpp_int">cpp_int</a>,
            <a class="link" href="floats/cpp_bin_float.html" title="cpp_bin_float">cpp_bin_float</a>,
            <a class="link" href="floats/cpp_dec_float.html" title="cpp_dec_float">cpp_dec_float</a>
            and <a class="link" href="floats/float128.html" title="float128">float128</a>
            have full support for Boost.Serialization.
          </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="gen_int.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="limits.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut/variable.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Variable Precision Arithmetic</title>
<link rel="stylesheet" href="../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="mixed.html" title="Mixed Precision Arithmetic">
<link rel="next" href="gen_int.html" title="Generic Integer Operations">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mixed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gen_int.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_multiprecision.tut.variable"></a><a class="link" href="variable.html" title="Variable Precision Arithmetic">Variable Precision
      Arithmetic</a>
</h3></div></div></div>
<p>
        There are a number of types in this library whose precision can be changed
        at runtime, the purpose of this section is to explain how these types interoperate
        with each other when two variables of the same type can have different precisions.
      </p>
<p>
        The main variable precision types being discussed here are:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <a class="link" href="floats/gmp_float.html" title="gmp_float">gmp_float</a>.
          </li>
<li class="listitem">
            <a class="link" href="floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>.
          </li>
<li class="listitem">
            <a class="link" href="interval/mpfi.html" title="mpfi_float">mpfi_float</a>.
          </li>
<li class="listitem">
            <a class="link" href="complex/mpc_complex.html" title="mpc_complex">mpc_complex</a>.
          </li>
</ul></div>
<p>
        Functions for setting the current working precision are as follows, with
        type <code class="computeroutput"><span class="identifier">Num</span></code> being one of <code class="computeroutput"><span class="identifier">mpf_float</span></code>, <code class="computeroutput"><span class="identifier">mpfr_float</span></code>,
        <code class="computeroutput"><span class="identifier">mpfi_float</span></code> or <code class="computeroutput"><span class="identifier">mpc_float</span></code>, and <code class="computeroutput"><span class="identifier">val</span></code>
        being an object of type <code class="computeroutput"><span class="identifier">Num</span></code>:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Expression
                </p>
              </th>
<th>
                <p>
                  Returns
                </p>
              </th>
<th>
                <p>
                  Comments
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">val</span><span class="special">.</span><span class="identifier">precision</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the precision of variable <code class="computeroutput"><span class="identifier">val</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">val</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the precision of variable <code class="computeroutput"><span class="identifier">val</span></code>
                  to <code class="computeroutput"><span class="identifier">n</span></code> decimal places.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the current global default precision, in decimal digits
                  - this is the precision that all new threads will inherit.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">unsigned</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the current thread default precision, in decimal digits
                  - this is the precision that the current thread will use when constructing
                  new objects of type <code class="computeroutput"><span class="identifier">Num</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">default_precision</span><span class="special">(</span><span class="identifier">Digits10</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the global default precision to Digits10 decimal places, this
                  is the precision that all new threads will inherit, also sets the
                  working precision for the current thread.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">(</span><span class="identifier">Digits10</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the default precision for the current thread to Digits10 decimal
                  places.
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        We must now consider what happens in an expression such as:
      </p>
<pre class="programlisting"><span class="identifier">variable</span> <span class="special">=</span> <span class="identifier">some_expression</span><span class="special">;</span>
</pre>
<p>
        There are basically 2 options here when the precision of <code class="computeroutput"><span class="identifier">variable</span></code>
        and <code class="computeroutput"><span class="identifier">some_expression</span></code> differ:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            We can preserve the precision of the source, so that post assignment,
            source and target are equal.
          </li>
<li class="listitem">
            We can preserve the precision of the target, so that the precision of
            <code class="computeroutput"><span class="identifier">variable</span></code> doesn't change.
          </li>
</ul></div>
<p>
        In addition we must consider what happens if <code class="computeroutput"><span class="identifier">some_expression</span></code>
        contains types other than <code class="computeroutput"><span class="identifier">Num</span></code>.
      </p>
<p>
        The behaviour of the library is controlled by the following enumerated values:
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span> <span class="special">{</span>

   <span class="keyword">enum</span> <span class="keyword">struct</span> <span class="identifier">variable_precision_options</span>
   <span class="special">{</span>
      <span class="identifier">assume_uniform_precision</span> <span class="special">=</span> <span class="special">-</span><span class="number">1</span><span class="special">,</span>
      <span class="identifier">preserve_target_precision</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
      <span class="identifier">preserve_source_precision</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span>
      <span class="identifier">preserve_component_precision</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span>
      <span class="identifier">preserve_related_precision</span> <span class="special">=</span> <span class="number">3</span><span class="special">,</span>
      <span class="identifier">preserve_all_precision</span> <span class="special">=</span> <span class="number">4</span><span class="special">,</span>
   <span class="special">};</span>

<span class="special">}</span>
</pre>
<p>
        The enumerated values have the following meanings, with <code class="computeroutput"><span class="identifier">preserve_related_precision</span></code>
        being the default.
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Value
                </p>
              </th>
<th>
                <p>
                  Meaning
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  assume_uniform_precision
                </p>
              </td>
<td>
                <p>
                  This is the most efficient option - it simply assumes that all
                  variables in the current thread have the same precision, and ignores
                  the precision of all other types. Should these assumptions not
                  hold, then strange unexpected things may happen. No checks are
                  made to ensure that all variables really are of the same precision.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_target_precision
                </p>
              </td>
<td>
                <p>
                  All expressions are evaluated at the precision of the highest precision
                  variable within the expression, and then rounded to the precision
                  of the target variable upon assignment. The precision of other
                  types (including related or component types - see preserve_component_precision/preserve_related_precision)
                  contained within the expression are ignored. This option has the
                  unfortunate side effect, that moves may become full deep copies.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_source_precision
                </p>
              </td>
<td>
                <p>
                  All expressions are evaluated at the precision of the highest precision
                  variable within the expression, and that precision is preserved
                  upon assignment. The precision of other types (including related
                  or component types - see preserve_component_precision/preserve_related_precision)
                  contained within the expression are ignored. Moves, are true moves
                  not copies.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_component_precision
                </p>
              </td>
<td>
                <p>
                  All expressions are evaluated at the precision of the highest precision
                  variable within the expression, and that precision is preserved
                  upon assignment. If the expression contains component types then
                  these are also considered when calculating the precision of the
                  expression. Component types are the types which make up the two
                  components of the number when dealing with interval or complex
                  numbers. They are the same type as <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">value_type</span></code>.
                  Moves, are true moves not copies.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_related_precision
                </p>
              </td>
<td>
                <p>
                  All expressions are evaluated at the precision of the highest precision
                  variable within the expression, and that precision is preserved
                  upon assignment. If the expression contains component types then
                  these are also considered when calculating the precision of the
                  expression. In addition to component types, all related types are
                  considered when evaluating the precision of the expression. Related
                  types are considered to be instantiations of the same template,
                  but with different parameters. So for example <code class="computeroutput"><span class="identifier">mpfr_float_100</span></code>
                  would be a related type to <code class="computeroutput"><span class="identifier">mpfr_float</span></code>,
                  and all expressions containing an <code class="computeroutput"><span class="identifier">mpfr_float_100</span></code>
                  variable would have at least 100 decimal digits of precision when
                  evaluated as an <code class="computeroutput"><span class="identifier">mpfr_float</span></code>
                  expression. Moves, are true moves not copies.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_all_precision
                </p>
              </td>
<td>
                <p>
                  All expressions are evaluated at the precision of the highest precision
                  variable within the expression, and that precision is preserved
                  upon assignment. In addition to component and related types, all
                  types are considered when evaluating the precision of the expression.
                  For example, if the expression contains an <code class="computeroutput"><span class="identifier">mpz_int</span></code>,
                  then the precision of the expression will be sufficient to store
                  all of the digits in the integer unchanged. This option should
                  generally be used with extreme caution, as it can easily cause
                  unintentional precision inflation. Moves, are true moves not copies.
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        Note how the values <code class="computeroutput"><span class="identifier">preserve_source_precision</span></code>,
        <code class="computeroutput"><span class="identifier">preserve_component_precision</span></code>,
        <code class="computeroutput"><span class="identifier">preserve_related_precision</span></code>
        and <code class="computeroutput"><span class="identifier">preserve_all_precision</span></code>
        form a hierarchy, with each adding progressively more types to the one before
        to the list of types that are considered when calculating the precision of
        an expression:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Value
                </p>
              </th>
<th>
                <p>
                  Considers types (lowest in hierarchy first, each builds on the
                  one before)
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  preserve_source_precision
                </p>
              </td>
<td>
                <p>
                  Considers types the same as the result in the expression only.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_component_precision
                </p>
              </td>
<td>
                <p>
                  Also considers component types, ie <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">value_type</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_related_precision
                </p>
              </td>
<td>
                <p>
                  Also considers all instantiations of the backend-template, not
                  just the same type as the result.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  preserve_all_precision
                </p>
              </td>
<td>
                <p>
                  Considers everything, including completely unrelated types such
                  as (possibly arbitrary precision) integers.
                </p>
              </td>
</tr>
</tbody>
</table></div>
<p>
        As with working precision, the above options can be set or queried on either
        a global or thread-local level, note that these options can not be set on
        a per-variable basis since they control whole expressions, not individual
        variables:
      </p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  Expression
                </p>
              </th>
<th>
                <p>
                  Returns
                </p>
              </th>
<th>
                <p>
                  Comments
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">default_variable_precision_options</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">variable_precision_options</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the current global default options, these are the options
                  that all new threads will inherit.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">variable_precision_options</span></code>
                </p>
              </td>
<td>
                <p>
                  Returns the options in use in the current thread when evaluating
                  expressions containing type <code class="computeroutput"><span class="identifier">Num</span></code>.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">default_variable_precision_options</span><span class="special">(</span><span class="identifier">opts</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the global default options to <code class="computeroutput"><span class="identifier">opts</span></code>
                  which must be one of the enumerated <code class="computeroutput"><span class="identifier">variable_precision_options</span></code>
                  values, this is setting that all new threads will inherit, also
                  sets the options for the current thread.
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">Num</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">(</span><span class="identifier">opts</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  Sets the options for the current thread to <code class="computeroutput"><span class="identifier">opts</span></code>
                  which must be one of the <code class="computeroutput"><span class="identifier">variable_precision_options</span></code>
                  enumerated values.
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="boost_multiprecision.tut.variable.h0"></a>
        <span class="phrase"><a name="boost_multiprecision.tut.variable.examples"></a></span><a class="link" href="variable.html#boost_multiprecision.tut.variable.examples">Examples</a>
      </h5>
<p>
        All our precision changing examples are based around <code class="computeroutput"><span class="identifier">mpfr_float</span></code>.
        However, in order to make running this example a little easier to debug,
        we'll use <code class="computeroutput"><span class="identifier">debug_adaptor</span></code> throughout
        so that the values of all variables can be displayed in your debugger of
        choice:
      </p>
<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">mp_t</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">debug_adaptor_t</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">mpfr_float</span><span class="special">&gt;;</span>
</pre>
<p>
        Our first example will investigate calculating the Bessel J function via
        it's well known series representation:
      </p>
<p>
        <span class="inlinemediaobject"><object type="image/svg+xml" data="../../../bessel2.svg"></object></span>
      </p>
<p>
        This simple series suffers from catastrophic cancellation error near the
        roots of the function, so we'll investigate slowly increasing the precision
        of the calculation until we get the result to N-decimal places. We'll begin
        by defining a function to calculate the series for Bessel J, the details
        of which we'll leave in the source code:
      </p>
<pre class="programlisting"><span class="identifier">mp_t</span> <span class="identifier">calculate_bessel_J_as_series</span><span class="special">(</span><span class="identifier">mp_t</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">mp_t</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">mp_t</span><span class="special">*</span> <span class="identifier">err</span><span class="special">)</span>
</pre>
<p>
        Next come some simple helper classes, these allow us to modify the current
        precision and precision-options via scoped objects which will put everything
        back as it was at the end. We'll begin with the class to modify the working
        precision:
      </p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">scoped_mpfr_precision</span>
<span class="special">{</span>
   <span class="keyword">unsigned</span> <span class="identifier">saved_digits10</span><span class="special">;</span>
   <span class="identifier">scoped_mpfr_precision</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">saved_digits10</span><span class="special">(</span><span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">())</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="special">~</span><span class="identifier">scoped_mpfr_precision</span><span class="special">()</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">(</span><span class="identifier">saved_digits10</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">(</span><span class="identifier">saved_digits10</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
        And a second class to modify the precision options:
      </p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">scoped_mpfr_precision_options</span>
<span class="special">{</span>
   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span> <span class="identifier">saved_options</span><span class="special">;</span>
   <span class="identifier">scoped_mpfr_precision_options</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span> <span class="identifier">opts</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">saved_options</span><span class="special">(</span><span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">())</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">(</span><span class="identifier">opts</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="special">~</span><span class="identifier">scoped_mpfr_precision_options</span><span class="special">()</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">(</span><span class="identifier">saved_options</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span> <span class="identifier">opts</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_variable_precision_options</span><span class="special">(</span><span class="identifier">opts</span><span class="special">);</span>
   <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
        We can now begin writing a function to calculate J<sub>v</sub>(z) to a specified precision.
        In order to keep the logic as simple as possible, we'll adopt a <span class="emphasis"><em>uniform
        precision computing</em></span> approach, which is to say, within the body
        of the function, all variables are always at the same working precision.
      </p>
<pre class="programlisting"><span class="identifier">mp_t</span> <span class="identifier">Bessel_J_to_precision</span><span class="special">(</span><span class="identifier">mp_t</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">mp_t</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">//</span>
   <span class="comment">// Begin by backing up digits10:</span>
   <span class="comment">//</span>
   <span class="keyword">unsigned</span> <span class="identifier">saved_digits10</span> <span class="special">=</span> <span class="identifier">digits10</span><span class="special">;</span>
   <span class="comment">// </span>
   <span class="comment">//</span>
   <span class="comment">// Start by defining 2 scoped objects to control precision and associated options.</span>
   <span class="comment">// We'll begin by setting the working precision to the required target precision,</span>
   <span class="comment">// and since all variables will always be of uniform precision, we can tell the</span>
   <span class="comment">// library to ignore all precision control by setting variable_precision_options::assume_uniform_precision:</span>
   <span class="comment">//</span>
   <span class="identifier">scoped_mpfr_precision</span>           <span class="identifier">scoped</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="identifier">scoped_mpfr_precision_options</span>   <span class="identifier">scoped_opts</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">assume_uniform_precision</span><span class="special">);</span>

   <span class="identifier">mp_t</span>            <span class="identifier">result</span><span class="special">;</span>
   <span class="identifier">mp_t</span>            <span class="identifier">current_error</span><span class="special">{</span><span class="number">1</span><span class="special">};</span>
   <span class="identifier">mp_t</span>            <span class="identifier">target_error</span> <span class="special">{</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">(</span><span class="number">10.</span><span class="special">,</span> <span class="special">-</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">digits10</span><span class="special">))};</span>

   <span class="keyword">while</span> <span class="special">(</span><span class="identifier">target_error</span> <span class="special">&lt;</span> <span class="identifier">current_error</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="comment">//</span>
      <span class="comment">// Everything must be of uniform precision in here, including</span>
      <span class="comment">// our input values, so we'll begin by setting their precision:</span>
      <span class="comment">//</span>
      <span class="identifier">v</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
      <span class="identifier">x</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
      <span class="comment">//</span>
      <span class="comment">// Calculate our approximation and error estimate:</span>
      <span class="comment">//</span>
      <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">calculate_bessel_J_as_series</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">current_error</span><span class="special">);</span>
      <span class="comment">//</span>
      <span class="comment">// If the error from the current approximation is too high we'll need </span>
      <span class="comment">// to loop round and try again, in this case we use the simple heuristic</span>
      <span class="comment">// of doubling the working precision with each loop.  More refined approaches</span>
      <span class="comment">// are certainly available:</span>
      <span class="comment">//</span>
      <span class="identifier">digits10</span> <span class="special">*=</span> <span class="number">2</span><span class="special">;</span>
      <span class="identifier">scoped</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="comment">//</span>
   <span class="comment">// We now have an accurate result, but it may have too many digits,</span>
   <span class="comment">// so lets round the result to the requested precision now:</span>
   <span class="comment">//</span>
   <span class="identifier">result</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">saved_digits10</span><span class="special">);</span>
   <span class="comment">//</span>
   <span class="comment">// To maintain uniform precision during function return, lets</span>
   <span class="comment">// reset the default precision now:</span>
   <span class="comment">//</span>
   <span class="identifier">scoped</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">saved_digits10</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        So far, this is all well and good, but there is still a potential trap for
        the unwary here, when the function returns the variable may be copied/moved
        either once or twice depending on whether the compiler implements the named-return-value
        optimisation. And since this all happens outside the scope of this function,
        the precision of the returned value may get unexpected changed - and potentially
        with different behaviour once optimisations are turned on!
      </p>
<p>
        To prevent these kinds of unintended consequences, a function returning a
        value with specified precision must either:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            Be called in a <span class="emphasis"><em>uniform-precision-environment</em></span>, with
            the current working precision, the same as both the returned value and
            the variable to which the result will be assigned.
          </li>
<li class="listitem">
            Be called in an environment that has one of the following set:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  variable_precision_options::preserve_source_precision
                </li>
<li class="listitem">
                  variable_precision_options::preserve_component_precision
                </li>
<li class="listitem">
                  variable_precision_options::preserve_related_precision
                </li>
<li class="listitem">
                  variable_precision_options::preserve_all_precision
                </li>
</ul></div>
          </li>
</ul></div>
<p>
        In the case of our example program, we use a <span class="emphasis"><em>uniform-precision-environment</em></span>
        and call the function with the value of <code class="computeroutput"><span class="number">6541389046624379</span>
        <span class="special">/</span> <span class="number">562949953421312</span></code>
        which happens to be near a root of J<sub>v</sub>(x) and requires a high-precision calculation
        to obtain low relative error in the result of <code class="computeroutput"><span class="special">-</span><span class="number">9.31614245636402072613249153246313221710284959883647822724e-15</span></code>.
      </p>
<p>
        You will note in the example we have so far that there are a number of unnecessary
        temporaries created: we pass values to our functions by value, and we call
        the <code class="computeroutput"><span class="special">.</span><span class="identifier">precision</span><span class="special">()</span></code> member function to change the working precision
        of some variables - something that requires a reallocation internally. We'll
        now make our example just a little more efficient, by removing these temporaries,
        though in the process, we'll need just a little more control over how mixed-precision
        arithmetic behaves.
      </p>
<p>
        It's tempting to simply define the function that calculates the series to
        take arguments by constant reference like so:
      </p>
<pre class="programlisting"><span class="identifier">mp_t</span> <span class="identifier">calculate_bessel_J_as_series_2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mp_t</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">mp_t</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">mp_t</span><span class="special">*</span> <span class="identifier">err</span><span class="special">)</span>
</pre>
<p>
        And to then pass our arguments to it, without first altering their precision
        to match the current working default. However, imagine that <code class="computeroutput"><span class="identifier">calculate_bessel_J_as_series_2</span></code> calculates
        x<sup>2</sup> internally, what precision is the result? If it's the same as the precision
        of <span class="emphasis"><em>x</em></span>, then our calculation will loose precision, since
        we really want the result calculated to the full current working precision,
        which may be significantly higher than that of our input variables. Our new
        version of Bessel_J_to_precision therefore uses <code class="computeroutput"><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_target_precision</span></code>
        internally, so that expressions containing only the low-precision input variables
        are calculated at the precision of (at least) the target - which will have
        been constructed at the current working precision.
      </p>
<p>
        Here's our revised code:
      </p>
<pre class="programlisting"><span class="identifier">mp_t</span> <span class="identifier">Bessel_J_to_precision_2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mp_t</span><span class="special">&amp;</span> <span class="identifier">v</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">mp_t</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">digits10</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">//</span>
   <span class="comment">// Begin with 2 scoped objects, one to manage current working precision, one to</span>
   <span class="comment">// manage mixed precision arithmetic.  Use of variable_precision_options::preserve_target_precision</span>
   <span class="comment">// ensures that expressions containing only low-precision input variables are evaluated at the precision</span>
   <span class="comment">// of the variable they are being assigned to (ie current working precision).</span>
   <span class="comment">//</span>
   <span class="identifier">scoped_mpfr_precision</span> <span class="identifier">scoped</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="identifier">scoped_mpfr_precision_options</span> <span class="identifier">scoped_opts</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_target_precision</span><span class="special">);</span>

   <span class="identifier">mp_t</span>                    <span class="identifier">result</span><span class="special">;</span>
   <span class="identifier">mp_t</span>            <span class="identifier">current_error</span><span class="special">{</span><span class="number">1</span><span class="special">};</span>
   <span class="identifier">mp_t</span>            <span class="identifier">target_error</span><span class="special">{</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span><span class="special">(</span><span class="number">10.</span><span class="special">,</span> <span class="special">-</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">digits10</span><span class="special">))};</span>

   <span class="keyword">while</span> <span class="special">(</span><span class="identifier">target_error</span> <span class="special">&lt;</span> <span class="identifier">current_error</span><span class="special">)</span>
   <span class="special">{</span>
      <span class="comment">//</span>
      <span class="comment">// The assignment here, rounds the high precision result</span>
      <span class="comment">// returned by calculate_bessel_J_as_series_2, to the precision</span>
      <span class="comment">// of variable result: ie to the target precision we specified in</span>
      <span class="comment">// the function call.  This is only the case because we have</span>
      <span class="comment">// variable_precision_options::preserve_target_precision set.</span>
      <span class="comment">//</span>
      <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">calculate_bessel_J_as_series_2</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">current_error</span><span class="special">);</span>

      <span class="identifier">digits10</span> <span class="special">*=</span> <span class="number">2</span><span class="special">;</span>
      <span class="identifier">scoped</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">digits10</span><span class="special">);</span>
   <span class="special">}</span>
   <span class="comment">//</span>
   <span class="comment">// There may be temporaries created when we return, we must make sure</span>
   <span class="comment">// that we reset the working precision and options before we return.</span>
   <span class="comment">// In the case of the options, we must preserve the precision of the source</span>
   <span class="comment">// object during the return, not only here, but in the calling function too:</span>
   <span class="comment">//</span>
   <span class="identifier">scoped</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
   <span class="identifier">scoped_opts</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_source_precision</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        In our final example, we'll look at a (somewhat contrived) case where we
        reduce the argument by N * PI, in this case we change the mixed-precision
        arithmetic options several times, depending what it is we are trying to achieve
        at that moment in time:
      </p>
<pre class="programlisting"><span class="identifier">mp_t</span> <span class="identifier">reduce_n_pi</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">mp_t</span><span class="special">&amp;</span> <span class="identifier">arg</span><span class="special">)</span>
<span class="special">{</span>
   <span class="comment">//</span>
   <span class="comment">// We begin by estimating how many multiples of PI we will be reducing by, </span>
   <span class="comment">// note that this is only an estimate because we're using low precision</span>
   <span class="comment">// arithmetic here to get a quick answer:</span>
   <span class="comment">//</span>
   <span class="keyword">unsigned</span> <span class="identifier">n</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">unsigned</span><span class="special">&gt;(</span><span class="identifier">arg</span> <span class="special">/</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_t</span><span class="special">&gt;());</span>
   <span class="comment">//</span>
   <span class="comment">// Now that we have an estimate for N, we can up the working precision and obtain</span>
   <span class="comment">// a high precision value for PI, best to play safe and preserve the precision of the</span>
   <span class="comment">// source here.  Though note that expressions are evaluated at the highest precision</span>
   <span class="comment">// of any of their components: in this case that's the current working precision</span>
   <span class="comment">// returned by boost::math::constants::pi, and not the precision of arg.</span>
   <span class="comment">// However, should this function be called with assume_uniform_precision set</span>
   <span class="comment">// then all bets are off unless we do this:</span>
   <span class="comment">//</span>
   <span class="identifier">scoped_mpfr_precision</span>            <span class="identifier">scope_1</span><span class="special">(</span><span class="identifier">mp_t</span><span class="special">::</span><span class="identifier">thread_default_precision</span><span class="special">()</span> <span class="special">*</span> <span class="number">2</span><span class="special">);</span>
   <span class="identifier">scoped_mpfr_precision_options</span>    <span class="identifier">scope_2</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_source_precision</span><span class="special">);</span>

   <span class="identifier">mp_t</span> <span class="identifier">reduced</span> <span class="special">=</span> <span class="identifier">arg</span> <span class="special">-</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_t</span><span class="special">&gt;();</span>
   <span class="comment">//</span>
   <span class="comment">// Since N was only an estimate, we may have subtracted one PI too many,</span>
   <span class="comment">// correct if that's the case now:</span>
   <span class="comment">//</span>
   <span class="keyword">if</span> <span class="special">(</span><span class="identifier">reduced</span> <span class="special">&lt;</span> <span class="number">0</span><span class="special">)</span>
      <span class="identifier">reduced</span> <span class="special">+=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">constants</span><span class="special">::</span><span class="identifier">pi</span><span class="special">&lt;</span><span class="identifier">mp_t</span><span class="special">&gt;();</span>
   <span class="comment">//</span>
   <span class="comment">// Our variable "reduced" now has the correct answer, but too many digits precision, </span>
   <span class="comment">// we can either call its .precision() member function, or assign to a new variable</span>
   <span class="comment">// with variable_precision_options::preserve_target_precision set:</span>
   <span class="comment">//</span>
   <span class="identifier">scope_1</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
   <span class="identifier">scope_2</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_target_precision</span><span class="special">);</span>
   <span class="identifier">mp_t</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">reduced</span><span class="special">;</span>
   <span class="comment">//</span>
   <span class="comment">// As with previous examples, returning the result may create temporaries, so lets</span>
   <span class="comment">// make sure that we preserve the precision of result.  Note that this isn't strictly</span>
   <span class="comment">// required if the calling context is always of uniform precision, but we can't be sure </span>
   <span class="comment">// of our calling context:</span>
   <span class="comment">//</span>
   <span class="identifier">scope_2</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">variable_precision_options</span><span class="special">::</span><span class="identifier">preserve_source_precision</span><span class="special">);</span>
   <span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
        And finally... we need to mention <code class="computeroutput"><span class="identifier">preserve_component_precision</span></code>,
        <code class="computeroutput"><span class="identifier">preserve_related_precision</span></code>
        and <code class="computeroutput"><span class="identifier">preserve_all_precision</span></code>.
      </p>
<p>
        These form a hierarchy, with each inheriting the properties of those before
        it. <code class="computeroutput"><span class="identifier">preserve_component_precision</span></code>
        is used when dealing with complex or interval numbers, for example if we
        have:
      </p>
<pre class="programlisting"><span class="identifier">mpc_complex</span> <span class="identifier">val</span> <span class="special">=</span> <span class="identifier">some_expression</span><span class="special">;</span>
</pre>
<p>
        And <code class="computeroutput"><span class="identifier">some_expression</span></code> contains
        scalar values of type <code class="computeroutput"><span class="identifier">mpfr_float</span></code>,
        then the precision of these is ignored unless we specify at least <code class="computeroutput"><span class="identifier">preserve_component_precision</span></code>.
      </p>
<p>
        <code class="computeroutput"><span class="identifier">preserve_related_precision</span></code>
        we'll somewhat skip over - it extends the range of types whose precision
        is considered within an expression to related types - for example all instantiations
        of <code class="computeroutput"><span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">mpfr_float_backend</span><span class="special">&lt;</span><span class="identifier">N</span><span class="special">&gt;,</span> <span class="identifier">ET</span><span class="special">&gt;</span></code>
        when dealing with expression of type <code class="computeroutput"><span class="identifier">mpfr_float</span></code>.
        However, such situations are - and should be - very rare.
      </p>
<p>
        The final option - <code class="computeroutput"><span class="identifier">preserve_all_precision</span></code>
        - is used to preserve the precision of all the types in an expression, for
        example:
      </p>
<pre class="programlisting"><span class="comment">// calculate 2^1000 - 1:</span>
<span class="identifier">mpz_int</span> <span class="identifier">i</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">i</span> <span class="special">&lt;&lt;=</span> <span class="number">1000</span><span class="special">;</span>
<span class="identifier">i</span> <span class="special">-=</span> <span class="number">1</span><span class="special">;</span>

<span class="identifier">mp_t</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">i</span><span class="special">;</span>
</pre>
<p>
        The final assignment above will round the value in <span class="emphasis"><em>i</em></span>
        to the current working precision, unless <code class="computeroutput"><span class="identifier">preserve_all_precision</span></code>
        is set, in which case <span class="emphasis"><em>f</em></span> will end up with sufficient
        precision to store <span class="emphasis"><em>i</em></span> unchanged.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mixed.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="gen_int.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/boost_multiprecision/tut.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Tutorial</title>
<link rel="stylesheet" href="../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="prev" href="intro.html" title="Introduction">
<link rel="next" href="tut/ints.html" title="Integer Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tut/ints.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_multiprecision.tut"></a><a class="link" href="tut.html" title="Tutorial">Tutorial</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="tut/ints.html">Integer Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/ints/cpp_int.html">cpp_int</a></span></dt>
<dt><span class="section"><a href="tut/ints/gmp_int.html">gmp_int</a></span></dt>
<dt><span class="section"><a href="tut/ints/tom_int.html">tom_int</a></span></dt>
<dt><span class="section"><a href="tut/ints/egs.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/ints/egs/factorials.html">Factorials</a></span></dt>
<dt><span class="section"><a href="tut/ints/egs/bitops.html">Bit Operations</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="tut/floats.html">Floating-point Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/floats/cpp_bin_float.html">cpp_bin_float</a></span></dt>
<dt><span class="section"><a href="tut/floats/cpp_dec_float.html">cpp_dec_float</a></span></dt>
<dt><span class="section"><a href="tut/floats/gmp_float.html">gmp_float</a></span></dt>
<dt><span class="section"><a href="tut/floats/mpfr_float.html">mpfr_float</a></span></dt>
<dt><span class="section"><a href="tut/floats/float128.html">float128</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/floats/fp_eg/floatbuiltinctor.html">Construction
          from Specific Values Without Precision Loss</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/aos.html">Area of
          Circle</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/caveats.html">Drop-in
          Caveats</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/jel.html">Defining
          a Special Function.</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/nd.html">Calculating
          a Derivative</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/gi.html">Calculating
          an Integral</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/poly_eg.html">Polynomial
          Evaluation</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/variable_precision.html">Variable-Precision
          Newton Evaluation</a></span></dt>
<dt><span class="section"><a href="tut/floats/fp_eg/gauss_lagerre_quadrature.html">Gauss-Laguerre
          quadrature</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="tut/interval.html">Interval Number Types</a></span></dt>
<dd><dl><dt><span class="section"><a href="tut/interval/mpfi.html">mpfi_float</a></span></dt></dl></dd>
<dt><span class="section"><a href="tut/complex.html">Complex Number Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/complex/cpp_complex.html">cpp_complex</a></span></dt>
<dt><span class="section"><a href="tut/complex/mpc_complex.html">mpc_complex</a></span></dt>
<dt><span class="section"><a href="tut/complex/complex128.html">complex128</a></span></dt>
<dt><span class="section"><a href="tut/complex/complex_adaptor.html">complex_adaptor</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="tut/rational.html">Rational Number Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/rational/cpp_rational.html">cpp_rational</a></span></dt>
<dt><span class="section"><a href="tut/rational/gmp_rational.html">gmp_rational</a></span></dt>
<dt><span class="section"><a href="tut/rational/tommath_rational.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="tut/rational/tommath_rational0.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="tut/rational/rational_adaptor.html">rational_adaptor</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="tut/misc.html">Miscellaneous Number Types.</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/misc/logged_adaptor.html">logged_adaptor</a></span></dt>
<dt><span class="section"><a href="tut/misc/debug_adaptor.html">debug_adaptor</a></span></dt>
<dt><span class="section"><a href="tut/misc/visualizers.html">Visual C++
        Debugger Visualizers</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="tut/conversions.html">Constructing and
      Interconverting Between Number Types</a></span></dt>
<dt><span class="section"><a href="tut/random.html">Generating Random Numbers</a></span></dt>
<dt><span class="section"><a href="tut/primetest.html">Primality Testing</a></span></dt>
<dt><span class="section"><a href="tut/lits.html">Literal Types and <code class="computeroutput"><span class="keyword">constexpr</span></code> Support</a></span></dt>
<dt><span class="section"><a href="tut/import_export.html">Importing and
      Exporting Data to and from <code class="computeroutput"><span class="identifier">cpp_int</span></code>
      and <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code></a></span></dt>
<dt><span class="section"><a href="tut/rounding.html">Rounding Rules for
      Conversions</a></span></dt>
<dt><span class="section"><a href="tut/mixed.html">Mixed Precision Arithmetic</a></span></dt>
<dt><span class="section"><a href="tut/variable.html">Variable Precision
      Arithmetic</a></span></dt>
<dt><span class="section"><a href="tut/gen_int.html">Generic Integer Operations</a></span></dt>
<dt><span class="section"><a href="tut/serial.html">Boost.Serialization
      Support</a></span></dt>
<dt><span class="section"><a href="tut/limits.html">Numeric Limits</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="tut/limits/constants.html">std::numeric_limits&lt;&gt;
        constants</a></span></dt>
<dt><span class="section"><a href="tut/limits/functions.html"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> functions</a></span></dt>
<dt><span class="section"><a href="tut/limits/limits32.html">Numeric limits
        for 32-bit platform</a></span></dt>
<dt><span class="section"><a href="tut/limits/how_to_tell.html">How to
        Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
</dl></dd>
<dt><span class="section"><a href="tut/input_output.html">Input Output</a></span></dt>
<dt><span class="section"><a href="tut/hash.html">Hash Function Support</a></span></dt>
<dt><span class="section"><a href="tut/eigen.html">Eigen Interoperability</a></span></dt>
<dt><span class="section"><a href="tut/new_backend.html">Writing a New Backend</a></span></dt>
</dl></div>
<p>
      In order to use this library you need to make two choices:
    </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
          What kind of number do I want (<a class="link" href="tut/ints.html" title="Integer Types">integer</a>,
          <a class="link" href="tut/floats.html" title="Floating-point Types">floating-point</a>,
          <a class="link" href="tut/rational.html" title="Rational Number Types">rational</a>, or
          <a class="link" href="tut/complex.html" title="Complex Number Types">complex</a>).
        </li>
<li class="listitem">
          Which back-end do I want to perform the actual arithmetic (Boost-supplied,
          GMP, MPFR, MPC, Tommath etc)?
        </li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tut/ints.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/index.html
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Chapter 1. Boost.Multiprecision</title>
<link rel="stylesheet" href="multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="next" href="boost_multiprecision/intro.html" title="Introduction">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
<td align="center"><a href="../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav"><a accesskey="n" href="boost_multiprecision/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
<div class="chapter">
<div class="titlepage"><div>
<div><h2 class="title">
<a name="boost_multiprecision"></a>Chapter 1. Boost.Multiprecision</h2></div>
<div><div class="author"><h3 class="author">
<span class="firstname">John</span> <span class="surname">Maddock</span>
</h3></div></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Christopher</span> <span class="surname">Kormanyos</span>
</h3></div></div>
<div><p class="copyright">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos</p></div>
<div><div class="legalnotice">
<a name="boost_multiprecision.legal"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></div>
</div></div>
<div class="toc">
<p><b>Table of Contents</b></p>
<dl class="toc">
<dt><span class="section"><a href="boost_multiprecision/intro.html">Introduction</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut.html">Tutorial</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/ints.html">Integer Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/cpp_int.html">cpp_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/gmp_int.html">gmp_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/tom_int.html">tom_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/egs.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/egs/factorials.html">Factorials</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/ints/egs/bitops.html">Bit Operations</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/floats.html">Floating-point Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/cpp_bin_float.html">cpp_bin_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/cpp_dec_float.html">cpp_dec_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/gmp_float.html">gmp_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/mpfr_float.html">mpfr_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/float128.html">float128</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg.html">Examples</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/floatbuiltinctor.html">Construction
          from Specific Values Without Precision Loss</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/aos.html">Area of
          Circle</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/caveats.html">Drop-in
          Caveats</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/jel.html">Defining
          a Special Function.</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/nd.html">Calculating
          a Derivative</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/gi.html">Calculating
          an Integral</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/poly_eg.html">Polynomial
          Evaluation</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/variable_precision.html">Variable-Precision
          Newton Evaluation</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/floats/fp_eg/gauss_lagerre_quadrature.html">Gauss-Laguerre
          quadrature</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/interval.html">Interval Number Types</a></span></dt>
<dd><dl><dt><span class="section"><a href="boost_multiprecision/tut/interval/mpfi.html">mpfi_float</a></span></dt></dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/complex.html">Complex Number Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/complex/cpp_complex.html">cpp_complex</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/complex/mpc_complex.html">mpc_complex</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/complex/complex128.html">complex128</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/complex/complex_adaptor.html">complex_adaptor</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/rational.html">Rational Number Types</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/rational/cpp_rational.html">cpp_rational</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/rational/gmp_rational.html">gmp_rational</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/rational/tommath_rational.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/rational/tommath_rational0.html">tommath_rational</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/rational/rational_adaptor.html">rational_adaptor</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/misc.html">Miscellaneous Number Types.</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/misc/logged_adaptor.html">logged_adaptor</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/misc/debug_adaptor.html">debug_adaptor</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/misc/visualizers.html">Visual C++
        Debugger Visualizers</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/conversions.html">Constructing and
      Interconverting Between Number Types</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/random.html">Generating Random Numbers</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/primetest.html">Primality Testing</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/lits.html">Literal Types and <code class="computeroutput"><span class="keyword">constexpr</span></code> Support</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/import_export.html">Importing and
      Exporting Data to and from <code class="computeroutput"><span class="identifier">cpp_int</span></code>
      and <code class="computeroutput"><span class="identifier">cpp_bin_float</span></code></a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/rounding.html">Rounding Rules for
      Conversions</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/mixed.html">Mixed Precision Arithmetic</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/variable.html">Variable Precision
      Arithmetic</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/gen_int.html">Generic Integer Operations</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/serial.html">Boost.Serialization
      Support</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/limits.html">Numeric Limits</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/tut/limits/constants.html">std::numeric_limits&lt;&gt;
        constants</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/limits/functions.html"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> functions</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/limits/limits32.html">Numeric limits
        for 32-bit platform</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/limits/how_to_tell.html">How to
        Determine the Kind of a Number From <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code></a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/tut/input_output.html">Input Output</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/hash.html">Hash Function Support</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/eigen.html">Eigen Interoperability</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/tut/new_backend.html">Writing a New Backend</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/ref.html">Reference</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/ref/number.html">number</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/cpp_int_ref.html">cpp_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/gmp_int_ref.html">gmp_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/tom_int_ref.html">tom_int</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/mpf_ref.html">gmp_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/mpfr_ref.html">mpfr_float_backend</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/cpp_bin_float_ref.html">cpp_bin_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/cpp_dec_ref.html">cpp_dec_float</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/internals.html">Internal Support
      Code</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/backendconc.html">Backend Requirements</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/ref/headers.html">Header File Structure</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/perf.html">Performance Comparison</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/perf/overhead.html">The Overhead in the
      Number Class Wrapper</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/realworld.html">Floating-Point Real
      World Tests</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/int_real_world.html">Integer Real
      World Tests</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/rational_real_world.html">Rational
      Real World Tests</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/float_performance.html">Float Algorithm
      Performance</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/integer_performance.html">Integer
      Algorithm Performance</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/perf/rational_performance.html">Rational
      Type Performance</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/map.html">Roadmap</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/map/hist.html">History</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/map/todo.html">TODO</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/map/faq.html">FAQ</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/map/ack.html">Acknowledgements</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="boost_multiprecision/indexes.html">Indexes</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="boost_multiprecision/indexes/s01.html">Function Index</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/indexes/s02.html">Class Index</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/indexes/s03.html">Typedef Index</a></span></dt>
<dt><span class="section"><a href="boost_multiprecision/indexes/s04.html">Index</a></span></dt>
</dl></dd>
</dl>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"><p><small>Last revised: October 23, 2022 at 17:40:16 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
<div class="spirit-nav"><a accesskey="n" href="boost_multiprecision/intro.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
</body>
</html>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html/multiprecision.css
================================================
@import url('../../../../doc/src/boostbook.css');
/* Contains the basic settings for BoostBook and used by Quickbook to docbook conversion. */

/*=============================================================================
Copyright (c) 2004 Joel de Guzman    http://spirit.sourceforge.net/
Copyright (c) 2014 John Maddock
Copyright 2013 Niall Douglas additions for colors and alignment.
Copyright 2013 Paul A. Bristow additions for more colors and alignments.
Copyright 2019 Paul A. Bristow additions for more control of serif-italic font etc.

Distributed under the Boost Software License, Version 1.0. (See accompany-
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

    This Cascading Style Sheet is used to override and add to the standard Boost
    CSS BoostBook for a particular library, for example Boost.Math and Boost.Multiprecision.

    Visual Studio is recommended for editing this file 
    because it checks syntax, does layout and provides help on options.

IMPORTANT: there are two versions of this file - 

one in libs/math/doc and one in libs/math/doc/html

ONLY EVER EDIT THE FIRST OF THESE  !!!!

=============================================================================*/

/*=============================================================================
Program listings
=============================================================================*/

    /* Code on paragraphs */
    p tt.computeroutput
    {
        font-size: 10pt;
    }

    pre.synopsis
    {
        font-size: 10pt;
        margin: 1pc 4% 0pc 4%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }

    .programlisting,
    .screen
    {
        font-size: 10pt;
        display: block;
        /* was margin: 1pc 4% 0pc 4%; */
        margin: 1pc 2% 0pc 2%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }
		@media screen
    {
       /* Syntax Highlighting */
				.comment { color: green; }
				/* .comment { color: #008000; }	*/
		}						
    /* Program listings in tables don't get borders */
    td .programlisting,
    td .screen
    {
        margin: 0pc 0pc 0pc 0pc;
        padding: 0pc 0pc 0pc 0pc;
    }

/*=============================================================================
Table of contents
=============================================================================*/

    div.toc
    {
       margin: 1pc 4% 0pc 4%;
       padding: 0.1pc 1pc 0.1pc 1pc;
       font-size: 100%;
       line-height: 1.15;
    }

    .boost-toc
    {
       float: right;
       padding: 0.5pc;
    }

    /* Code on toc */
    .toc .computeroutput { font-size: 120% }

    /* No margin on nested menus */

    .toc dl dl { margin: 0; }


/*==============================================================================
Alignment and coloring use 'role' feature, available from Quickbook 1.6 up.
Added from Niall Douglas for role color and alignment.
http://article.gmane.org/gmane.comp.lib.boost.devel/243318
*/

/* Add text alignment (see http://www.w3schools.com/cssref/pr_text_text-align.asp) */
span.aligncenter
{
  display: inline-block; width: 100%; text-align: center;
}
span.alignright
{
  display: inline-block; width: 100%; text-align: right;
}
/* alignleft is the default. */
span.alignleft
{
  display: inline-block; width: 100%; text-align: left;
}

/* alignjustify stretches the word spacing so that each line has equal width
within a chosen fraction of page width (here arbitrarily 20%).
*Not* useful inside table items as the column width remains the total string width.
Nor very useful, except to temporarily restrict the width.
*/
span.alignjustify
{
  display: inline-block; width: 20%; text-align: justify;
}

/* Text colors.
Names at http://www.w3.org/TR/2002/WD-css3-color-20020219/ 4.3. X11 color keywords.
Quickbook Usage: [role red Some red text]

inline-block - Flows a element inline with the text, but allows width and height to be specified.

https://stackoverflow.com/questions/3043021/is-there-any-guide-on-when-to-use-displayblock-when-inline-and-when-inline-b#:~:text=The%20use%20cases%20for%20block,it%27s%20used%20naturally%20for%20images

*/
span.red { display:inline-block; color: red; }
span.green { display:inline-block; color: green; }
span.lime { display:inline-block; color: #00FF00; }
span.blue { display:inline-block; color: blue; }
span.navy { display:inline-block; color: navy; }
span.yellow { display:inline-block; color: yellow; }
span.magenta { display:inline-block; color: magenta; }
span.indigo { display:inline-block; color: #4B0082; }
span.cyan { display:inline-block; color: cyan; }
span.purple { display:inline-block; color: purple; }
span.gold { display:inline-block; color: gold; }
span.silver { display:inline-block; color: silver; } /* lighter gray */
span.gray { display:inline-block; color: #808080; } /* light gray */

/* role for inline Unicode mathematical equations,
    making font an italic (as is conventional for equations)
    and a serif version of font (to match those generated using .mml to SVG or PNG)
    and a little bigger (* 125%) because the serif font appears smaller than the default sans serif fonts.
    Used, for example: [role serif_italic This is in serif font and italic].
    Used in turn by template for inline expressions to match equations as SVG or PNG images.
    Can be combined with colors and bold.
*/
span.serif_italic {
    font-family: serif;
    font-style: italic;
    font-size: 125%;
    font-stretch: expanded;
}

/* Custom indent of paragraphs to make equations look nicer.
https://www.w3schools.com/tags/tag_blockquote.asp says 
  "Most browsers will display the <blockquote> element with left and right margin 40px values: "
*/
blockquote {
    display: block;
    margin-top: 1em;
    margin-bottom: 1em;
    margin-left: 2%;
    margin-right: 2%;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/html4_symbols.qbk
================================================
[/ Symbols and Greek letters (about 120) from HTML4.]
[/ File HTML4_symbols.qbk]
[/ See http://www.htmlhelp.com/reference/html40/entities/symbols.html]
[/ See also http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references]
[/ http://www.alanwood.net/demos/ent4_frame.html]
[/ http://www.unicode.org/charts/PDF/U2200.pdf and others]
[/ All (except 2 angle brackets) show OK on Firefox 2.0 and higher]

[/ See also Latin-1 aka Western (ISO-8859-1) in latin1_symbols.qbk]
[/ http://www.htmlhelp.com/reference/html40/entities/latin1.html]
[/Unicode Latin extended http://www.unicode.org/charts/U0080.pdf]
[/https://en.wikipedia.org/wiki/Template:Unicode_chart_Arrows chart arrows]

[/ Also some miscellaneous math characters added to this list - see the end.]
[/ For others see also math_toolkit.symbols.qbk]

[/ To use, enclose the template name in square brackets, for example: [pi] ]

[template fnof[]'''&#x192;'''] [/  Latin small f with hook = function = florin]
[/ Capital Greek start with capital letter, lower case all small.]
[template Alpha[]'''&#x391;'''] [/ ? Greek capital letter alphadot]
[template Beta[]'''&#x392;'''] [/ ? Greek capital letter beta]
[template Gamma[]'''&#x393;'''] [/ G Greek capital letter gamma]
[template Delta[]'''&#x394;'''] [/ ? Greek capital letter delta]
[template Epsilon[]'''&#x395;'''] [/ ? Greek capital letter epsilon]
[template Zeta[]'''&#x396;'''] [/ ? Greek capital letter zeta]
[template Eta[]'''&#x397;'''] [/ ? Greek capital letter eta]
[template Theta[]'''&#x398;'''] [/ T Greek capital letter theta]
[template Iota[]'''&#x399;'''] [/ ? Greek capital letter iota]
[template Kappa[]'''&#x39A;'''] [/ ? Greek capital letter kappa]
[template Lambda[]'''&#x39B;'''] [/ ? Greek capital letter lambda]
[template Mu[]'''&#x39C;'''] [/ ? Greek capital letter mu]
[template Nu[]'''&#x39D;'''] [/ ? Greek capital letter nu]
[template Xi[]'''&#x39E;'''] [/ ? Greek capital letter xi]
[template Omicron[]'''&#x39F;'''] [/ ? Greek capital letter omicron]
[template Pi[]'''&#x3A0;'''] [/ ? Greek capital letter pi]
[template Rho[]'''&#x3A1;'''] [/ ? Greek capital letter rho]
[template Sigma[]'''&#x3A3;'''] [/ S Greek capital letter sigma]
[template Tau[]'''&#x3A4;'''] [/ ? Greek capital letter tau]
[template Upsilon[]'''&#x3A5;'''] [/ ? Greek capital letter upsilon]
[template Phi[]'''&#x3A6;'''] [/ F Greek capital letter phi]
[template Chi[]'''&#x3A7;'''] [/ ? Greek capital letter chi]
[template Psi[]'''&#x3A8;'''] [/ ? Greek capital letter psi]
[template Omega[]'''&#x3A9;'''] [/ O Greek capital letter omega]
[template alpha[]'''&#x3B1;'''] [/ a Greek small letter alpha]
[template beta[]'''&#x3B2;'''] [/  Greek small letter beta]
[template gamma[]'''&#x3B3;'''] [/ ? Greek small letter gamma]
[template delta[]'''&#x3B4;'''] [/ d Greek small letter delta]
[template epsilon[]'''&#x3B5;'''] [/ e Greek small letter epsilon]
[template zeta[]'''&#x3B6;'''] [/ ? Greek small letter zeta]
[template eta[]'''&#x3B7;'''] [/ ? Greek small letter eta]
[template theta[]'''&#x3B8;'''] [/ ? Greek small letter theta]
[template iota[]'''&#x3B9;'''] [/ ? Greek small letter iota]
[template kappa[]'''&#x3BA;'''] [/ ? Greek small letter kappa]
[template lambda[]'''&#x3BB;'''] [/ ? Greek small letter lambda]
[template mu[]'''&#x3BC;'''] [/  Greek small letter mu]
[template nu[]'''&#x3BD;'''] [/ ? Greek small letter nu]
[template xi[]'''&#x3BE;'''] [/ ? Greek small letter xi]
[template omicron[]'''&#x3BF;'''] [/ ? Greek small letter omicron]
[template pi[]'''&#x3C0;'''] [/ p Greek small letter pi]
[template rho[]'''&#x3C1;'''] [/ ? Greek small letter rho]
[template sigmaf[]'''&#x3C2;'''] [/ ? Greek small letter final sigma]
[template sigma[]'''&#x3C3;'''] [/ s Greek small letter sigma]
[template tau[]'''&#x3C4;'''] [/ t Greek small letter tau]
[template upsilon[]'''&#x3C5;'''] [/ ? Greek small letter upsilon]
[template phi[]'''&#x3C6;'''] [/ f Greek small letter phi]
[template chi[]'''&#x3C7;'''] [/ ? Greek small letter chi]
[template psi[]'''&#x3C8;'''] [/ ? Greek small letter psi]
[template omega[]'''&#x3C9;'''] [/ ? Greek small letter omega]
[template thetasym[]'''&#x3D1;'''] [/ ? Greek small letter theta symbol]
[template upsih[]'''&#x3D2;'''] [/ ? Greek upsilon with hook symbol]
[template piv[]'''&#x3D6;'''] [/ ? Greek pi symbol]

[/Math symbols]

[template bull[]'''&#x2022;'''] [/   bullet = black small circle]
[template hellip[]'''&#x2026;'''] [/   horizontal ellipsis = three dot leader]
[template prime[]'''&#x2032;'''] [/  ' prime = minutes = feet]
[template Prime[]'''&#x2033;'''] [/  ? double prime = seconds = inches]
[template oline[]'''&#x203E;'''] [/  ? overline = spacing overscore]
[template frasl[]'''&#x2044;'''] [/  / fraction slash]
[template weierp[]'''&#x2118;'''] [/  P script capital P = power set = Weierstrass p]
[template image[]'''&#x2111;'''] [/  I blackletter capital I = imaginary part]
[template real[]'''&#x211C;'''] [/  R blackletter capital R = real part math symbol]
[template bigo[]'''&#x1D476;'''] [/  O blackletter capital O = big O symbol]
[template negative[]'''&#x2115;'''] [/  N blackletter capital N = Negative number math symbol]
[template trade[]'''&#x2122;'''] [/   trade mark sign]
[template alefsym[]'''&#x2135;'''] [/  ? alef symbol = first transfinite cardinal]
[template larr[]'''&#x2190;'''] [/  ? leftwards arrow]
[template uarr[]'''&#x2191;'''] [/  ? upwards arrow]
[template rarr[]'''&#x2192;'''] [/  ? rightwards arrow]
[template darr[]'''&#x2193;'''] [/  ? downwards arrow]
[template harr[]'''&#x2194;'''] [/  ? left right arrow]
[template crarr[]'''&#x21B5;'''] [/  ? downwards arrow with corner leftwards = CR]
[template lArr[]'''&#x21D0;'''] [/  ? leftwards double arrow]
[template uArr[]'''&#x21D1;'''] [/  ? upwards double arrow]
[template rArr[]'''&#x21D2;'''] [/  ? rightwards double arrow]
[template dArr[]'''&#x21D3;'''] [/  ? downwards double arrow]
[template hArr[]'''&#x21D4;'''] [/  ? left right double arrow]
[template forall[]'''&#x2200;'''] [/  ? for all]
[template part[]'''&#x2202;'''] [/  ? partial differential]
[template exist[]'''&#x2203;'''] [/  ? there exists]
[template empty[]'''&#x2205;'''] [/   empty set = null set = diameter]
[template nabla[]'''&#x2207;'''] [/  ? nabla = backward difference]
[template isin[]'''&#x2208;'''] [/  ? element of]
[template notin[]'''&#x2209;'''] [/  ? not an element of]
[template ni[]'''&#x220B;'''] [/  ? contains as member]
[template prod[]'''&#x220F;'''] [/  ? n-ary product = PI product sign]
[template sum[]'''&#x2211;'''] [/  ? n-ary sumation]
[template minus[]'''&#x2212;'''] [/  - minus sign]
[template lowast[]'''&#x2217;'''] [/  * asterisk operator]
[template bullet[]'''&#x2219;'''] [/  dot multiply operator ]

[template radic[]'''&#x221A;'''] [/  v square root = radical sign]
[/template sqrt  v square root = radical sign (duplicate of radic)]
[template cbrt[]'''&#x221B;'''] [/  cube root= radical sign]
[template fourthrt[]'''&#x221C;'''] [/  fourth root= radical sign]

[template prop[]'''&#x221D;'''] [/  ? proportional to]
[template infin[]'''&#x221E;'''] [/  8 infinity]
[template ang[]'''&#x2220;'''] [/  ? angle]
[template and[]'''&#x2227;'''] [/  ? logical and = wedge]
[template or[]'''&#x2228;'''] [/  ? logical or = vee]
[template cap[]'''&#x2229;'''] [/  n intersection = cap]
[template cup[]'''&#x222A;'''] [/  ? union = cup]
[template int[]'''&#x222B;'''] [/  ? integral]
[template there4[]'''&#x2234;'''] [/  ? therefore]
[template sim[]'''&#x223C;'''] [/  ~ tilde operator = varies with = similar to]
[template simeq[]'''&#x2243;'''] [/  ~_asymptotic equality]
[template cong[]'''&#x2245;'''] [/  =~ approximately equal to]
[template approx[]'''&#x2248;'''] [/  ? ~~ very approximately equal to]
[template asymp[]'''&#x2248;'''] [/   almost equal to = asymptotic to]
[template ne[]'''&#x2260;'''] [/  ? not equal to]
[template equiv[]'''&#x2261;'''] [/  = identical to]
[template le[]'''&#x2264;'''] [/  = less-than or equal to]
[template ge[]'''&#x2265;'''] [/  = greater-than or equal to]
[template subset[]'''&#x2282;'''] [/  ? subset of]
[template superset[]'''&#x2283;'''] [/  ? superset of]
[template nsubset[]'''&#x2284;'''] [/  ? not a subset of]
[template sube[]'''&#x2286;'''] [/  ? subset of or equal to]
[template supe[]'''&#x2287;'''] [/  ? superset of or equal to]
[template oplus[]'''&#x2295;'''] [/  ? circled plus = direct sum]
[template otimes[]'''&#x2297;'''] [/  ? circled times = vector product]
[template perp[]'''&#x22A5;'''] [/  ? up tack = orthogonal to = perpendicular]
[template sdot[]'''&#x22C5;'''] [/   dot operator]
[template cdot[]'''&#x00B7;'''] [/   dot operator]
[template lceil[]'''&#x2308;'''] [/  ? left ceiling = APL upstile]
[template rceil[]'''&#x2309;'''] [/  ? right ceiling]
[template lfloor[]'''&#x230A;'''] [/  ? left floor = APL downstile]
[template rfloor[]'''&#x230B;'''] [/  ? right floor]
[template lang[]'''&#x2329;'''] [/  < left-pointing angle bracket = bra (Firefox shows ?)]
[template rang[]'''&#x232A;'''] [/  > right-pointing angle bracket = ket (Firefox shows ?)]
[template loz[]'''&#x25CA;'''] [/  ? lozenge]
[template spades[]'''&#x2660;'''] [/  ? black spade suit]
[template clubs[]'''&#x2663;'''] [/  ? black club suit = shamrock]
[template hearts[]'''&#x2665;'''] [/  ? black heart suit = valentine]
[template diams[]'''&#x2666;'''] [/  ? black diamond suit]
[template euro[]'''&#x20AC;'''] [/  ? Euro currency symbol]
[template lchev[]'''&#x27E8;'''] [/  ? left chevron]
[template rchev[]'''&#x27E9;'''] [/  right chevron]
[template rflat[]'''&#x27EE;'''] [/  right flat bracket Misc Math Symbol A]
[template lflat[]'''&#x27EE;'''] [/  left flat bracket]
[template mapsto[]'''&#x21A6;'''] [/  function maps to https://en.wikipedia.org/wiki/Maplet ]
[template obelus[]'''&#x00F7;'''] [/ division dot over and under dash divide symbol]
[template divide[]'''&#x00F7;'''] [/ division dot over and under dash divide symbol (duplicate of obelus)]

[/ U2000.pdf punctuation]
[template endash[]'''&#x2013;'''] [/  em width dash]
[template emdash[]'''&#x2014;'''] [/  en width dash]
[template hbar[]'''&#x2015;'''] [/  ? horizontal bar - introducing quoted text]
[template vert2bar[]'''&#x2016;'''] [/  ? double vertical bar]
[template line2[]'''&#x2016;'''] [/  ? double low line bar]
[template dagger[]'''&#x2020;'''] [/  ? dagger]
[template dagger2[]'''&#x2021;'''] [/  ? double dagger]
[template dot[]'''&#x2024;'''] [/  dot leader]
[template dot2[]'''&#x2025;'''] [/  ? dots leader]
[template ellipsis[]'''&#x2026;'''] [/  horizontal ellipsis]
[template sect[]'''&#x00A7;'''] [/  ? section or paragraph sign]

[template dotover[]'''&#x0307;'''] [/  dot over symbol]
[template recur[]'''&#x200A;&#x0307;'''] [/ math recurring symbol, eg after 0.333]
[/ Note use of a thin space before digit, so that dot isn't placed directly over the digit.]
[/ Use:1[recur]]

[/ Other symbols, not in the HTML4 list:]
[template enquad[] '''&#x2000;'''] [/ en quad space]
[template emquad[] '''&#x2001;'''] [/ em quad space]
[template enspace[] '''&#x2002;'''] [/ em half en space]
[template emspace[] '''&#x2003;'''] [/ em space type size in points]
[template thickspace[] '''&#x2004;'''] [/ 3 per em space]
[template midspace[] '''&#x2005;'''] [/ 4 per em space]
[template sixemspace[] '''&#x2006;'''] [/ 6 em space]
[template indent[] '''&#x2006;&#x2006;&#x2006;'''] [/ 3 * 6 = 18 em space suitable for indenting formulae & equations.]
[template figspace[] '''&#x2007;'''] [/ space = width fixed font digit]
[template punctspace[] '''&#x2008;'''] [/ space = width punctuation]
[template thin[] '''&#x2009;'''] [/ thin space ]
[template hair[] '''&#x200A;'''] [/ hair space]
[template nbsp[] '''&#x00A0;'''] [/ non-breaking space]
[template space[] '''&#x00A0;'''] [/ plain non-breaking space == nbsp]

[template nospace[] '''&#x200B;'''] [/ zero width space]
[template wordjoin[] '''&#x2060;'''] [/ word joiner - no line break either side]
[template narrownbsp[] '''&#x202F;'''] [/ narrow non-breaking space]
[template hyphen[] '''&#x2010;'''] [/ soft hyphen]
[template nbhyphen[] '''&#x2011;'''] [/ non-breaking hyphen]

[template plusminus[]'''&#x00B1;'''] [/  ? plus or minus sign]
[template sqrt[]'''&#x221A;'''] [/  ? square root sqrt symbol]
[/template pow2[]'''&#x2073;'''] [/ 2073 is NOT superscript 2 and 3 characters]
[template pow2[]'''&#x00B2;'''] [/ superscript 2 character]
[template pow3[]'''&#x00B3;'''] [/ superscript 3 character]
[/ Unicode 2070 to 209F has super and subscript digits and characters, unicode.org/charts/PDF/U2070.pdf]
[template pow4[]'''&#x2074;'''] [/ superscript 4 character]
[template pown[]'''&#x207F;'''] [/ superscript n character]
[template frac12[]'''&#x00BD;'''] [/ fraction half]
[template frac13[]'''&#x2153;'''] [/ fraction third]
[template frac14[]'''&#x00BC;'''] [/ fraction quarter]
[template frac34[]'''&#x00BE;'''] [/ fraction three quarter]
[template frac23[]'''&#x2154;'''] [/ fraction two third]
[template sup1[]'''&#xB9;'''] [/ superscript one = superscript digit one ]
[template sup2[]'''&#xB2;'''] [/ superscript two = superscript digit two = squared ]
[template supminus[]'''&#x207B;'''] [/ superscript minus]
[template supplus[]'''&#x207A;'''] [/ superscript plus]

[template cubed[]'''&#xB3;'''] [/ superscript three = superscript digit three = cubed ]
[template macron[]'''&#xAF;'''] [/ macron = spacing macron = overline = APL overbar ]
[template deg[]'''&#xB0;'''] [/ degree sign ]
[template plusmn[]'''&#xB1;'''] [/ plus-minus sign = plus-or-minus sign ]
[template micro[]'''&#xB5;'''] [/ micro sign ]
[template agrave[]'''&#xE0;'''] [/  a  grave ]
[template aacute[]'''&#xE1;'''] [/  a acute ]
[template acircum[]'''&#xE2;'''] [/  a acircum ]
[template atilde[]'''&#xE3;'''] [/  a tilde ]
[template aumlaut[]'''&#xE4;'''] [/  a umlaut ]
[template ae[]'''&#xE5;'''] [/  ae]

[template cedil[]'''&#xB8;'''] [/  cedilla = spacing cedilla  ]
[template ccedil[]'''&#xE7;'''] [/ small c with cedilla ]
[template Ccedil[]'''&#xE7;'''] [/ capial C with cedilla ]

[template eacute[]'''&#xE9;'''] [/ e acute ]
[template egrave[]'''&#xE8;'''] [/ e grave ]
[template eumlaut[]'''&#xEB;'''] [/ e umlaut ]

[template uacute[]'''&#xFA;'''] [/  u acute ]
[template ugrave[]'''&#xF9;'''] [/ u grave ]
[template uumlaut[]'''&#xEB;'''] [/ u umlaut ]

[template ordm[]'''&#xBA;'''] [/ masculine ordinal indicator ]
[template ordf[]'''&#xAA;'''] [/ feminine ordinal indicator ]
[template laquo[]'''&#xAB;'''] [/ left-pointing double angle quotation mark = left pointing guillemet ]
[template raquo[]'''&#xBB;'''] [/ right-pointing double angle quotation mark = right pointing guillemet  ]

[/
Copyright 2007, 2010, 2012 Paul A. Bristow.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/index.idx
================================================
#  Copyright 2011 John Maddock. Distributed under the Boost
#  Software License, Version 1.0. (See accompanying file
#  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#
# Rewrite the class scanner to accept declarations, not just definitions, 
# as the docs don't include full definitions.
#
!define-scanner class_name "^[[:space:]]*(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\<\w+\>([[:blank:]]*\([^)]*\))?[[:space:]]*)*(\<\w*\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\{|:[^;\{()]*\{)" "(?:class|struct)[^;{]+\\<\5\\>\\s*[;{]" \5

!scan-path boost/multiprecision .*\.hpp true










================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/introduction.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:intro Introduction]

The Multiprecision Library provides [link boost_multiprecision.tut.ints integer],
[link boost_multiprecision.tut.rational rational],
[link boost_multiprecision.tut.floats floating-point],
and [link boost_multiprecision.tut.complex complex] types in C++ that have more
range and precision than C++'s ordinary __fundamental types.
The big number types in Multiprecision can be used with a wide
selection of basic mathematical operations, elementary transcendental
functions as well as the functions in Boost.Math.
The Multiprecision types can also interoperate with any
__fundamental_type in C++ using clearly defined conversion rules.
This allows Boost.Multiprecision to be used for all
kinds of mathematical calculations involving integer,
rational and floating-point types requiring extended
range and precision.

Multiprecision consists of a generic interface to the
mathematics of large numbers as well as a selection of
big number back-ends, with support for integer, rational,
floating-point, and complex types. Boost.Multiprecision provides a selection
of back-ends provided off-the-rack in including
interfaces to GMP, MPFR, MPIR, MPC, TomMath as well as
its own collection of Boost-licensed, header-only back-ends for
integers, rationals and floats. In addition, user-defined back-ends
can be created and used with the interface of Multiprecision,
provided the class implementation adheres to the necessary
[link boost_multiprecision.ref.backendconc concepts].

Depending upon the number type, precision may be arbitrarily large
(limited only by available memory), fixed at compile time
(for example, 50 or 100 decimal digits), or a variable controlled at run-time
by member functions. The types are __expression_templates - enabled for
better performance than naive user-defined types.

The Multiprecision library comes in two distinct parts:

* An expression-template-enabled front-end `number`
that handles all the operator overloading, expression evaluation optimization, and code reduction.
* A selection of back-ends that implement the actual arithmetic operations, and need conform only to the
reduced interface requirements of the front-end.

Separation of front-end and back-end allows use of highly refined, but restricted license libraries
where possible, but provides Boost license alternatives for users who must have a portable
unconstrained license.
Which is to say some back-ends rely on 3rd party libraries,
but a header-only Boost license version is always available (if somewhat slower).

[h5:getting_started Getting started with Boost.Multiprecision]

Should you just wish to 'cut to the chase' just to get bigger integers and/or bigger and more precise reals as simply and portably as possible,
close to 'drop-in' replacements for the __fundamental_type analogs,
then use a fully Boost-licensed number type, and skip to one of more of :

* __cpp_int for multiprecision integers, 
* __cpp_rational for rational types,
* __cpp_bin_float and __cpp_dec_float for multiprecision floating-point types,  
* __cpp_complex for complex types.

The library is very often used via one of the predefined convenience `typedef`s 
like `boost::multiprecision::int128_t` or `boost::multiprecision::cpp_bin_float_quad`.

For example, if you want a signed, 128-bit fixed size integer:

   #include <boost/multiprecision/cpp_int.hpp>  //  Integer types.
   
   boost::multiprecision::int128_t my_128_bit_int;

Alternatively, and more adventurously, if you wanted an
[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
integer type using [gmp] as the underlying implementation then you could use:

   #include <boost/multiprecision/gmp.hpp>  // Defines the wrappers around the GMP library's types

   boost::multiprecision::mpz_int myint;    // Arbitrary precision integer type.
   
Or for a simple, portable 128-bit floating-point close to a drop-in for a __fundamental_type like `double`, usually 64-bit   

   #include <boost/multiprecision/cpp_bin_float.hpp>
   
   boost::multiprecision::cpp_bin_float_quad my_quad_real;  

Alternatively, you can compose your own 'custom' multiprecision type, by combining `number` with one of the
predefined back-end types.  For example, suppose you wanted a 300 decimal digit floating-point type
based on the [mpfr] library. In this case, there's no predefined `typedef` with that level of precision,
so instead we compose our own:

   #include <boost/multiprecision/mpfr.hpp>  // Defines the Backend type that wraps MPFR.

   namespace mp = boost::multiprecision;     // Reduce the typing a bit later...

   typedef mp::number<mp::mpfr_float_backend<300> >  my_float;

   my_float a, b, c; // These variables have 300 decimal digits precision.

We can repeat the above example, but with the expression templates disabled (for faster compile times, but slower runtimes)
by passing a second template argument to `number`:

   #include <boost/multiprecision/mpfr.hpp>  // Defines the Backend type that wraps MPFR.

   namespace mp = boost::multiprecision;     // Reduce the typing a bit later...

   typedef mp::number<mp::mpfr_float_backend<300>, et_off>  my_float;

   my_float a, b, c; // These variables have 300 decimal digits precision

We can also mix arithmetic operations between different types, provided there is an unambiguous implicit conversion from one
type to the other:

   #include <boost/multiprecision/cpp_int.hpp>

   namespace mp = boost::multiprecision;     // Reduce the typing a bit later...

   mp::int128_t a(3), b(4);
   mp::int512_t c(50), d;

   d = c * a;   // OK, result of mixed arithmetic is an int512_t

Conversions are also allowed:

   d = a; // OK, widening conversion.
   d = a * b;  // OK, can convert from an expression template too.

However conversions that are inherently lossy are either declared explicit or else forbidden altogether:

   d = 3.14;  // Error implicit conversion from double not allowed.
   d = static_cast<mp::int512_t>(3.14);  // OK explicit construction is allowed

Mixed arithmetic will fail if the conversion is either ambiguous or explicit:

   number<cpp_int_backend<>, et_off> a(2);
   number<cpp_int_backend<>, et_on>  b(3);

   b = a * b; // Error, implicit conversion could go either way.
   b = a * 3.14; // Error, no operator overload if the conversion would be explicit.

[h4 Move Semantics]

On compilers that support rvalue-references, class `number` is move-enabled if the underlying backend is.

In addition the non-expression template operator overloads (see below) are move aware and have overloads
that look something like:

   template <class B>
   number<B, et_off> operator + (number<B, et_off>&& a, const number<B, et_off>& b)
   {
       return std::move(a += b);
   }

These operator overloads ensure that many expressions can be evaluated without actually generating any temporaries.
However, there are still many simple expressions such as

   a = b * c;

which don't noticeably benefit from move support.  Therefore, optimal performance comes from having both
move-support, and expression templates enabled.

Note that while "moved-from" objects are left in a sane state, they have an unspecified value, and the only permitted
operations on them are destruction or the assignment of a new value.  Any other operation should be considered
a programming error and all of our backends will trigger an assertion if any other operation is attempted.  This behavior
allows for optimal performance on move-construction (i.e. no allocation required, we just take ownership of the existing
object's internal state), while maintaining usability in the standard library containers.

[h4:expression_templates Expression Templates]

Class `number` is expression-template-enabled: that means that rather than having a multiplication
operator that looks like this:

   template <class Backend>
   number<Backend> operator * (const number<Backend>& a, const number<Backend>& b)
   {
      number<Backend> result(a);
      result *= b;
      return result;
   }

Instead the operator looks more like this:

   template <class Backend>
   ``['unmentionable-type]`` operator * (const number<Backend>& a, const number<Backend>& b);

Where the '['unmentionable]' return type is an implementation detail that, rather than containing the result
of the multiplication, contains instructions on how to compute the result.  In effect it's just a pair
of references to the arguments of the function, plus some compile-time information that stores what the operation
is.

The great advantage of this method is the ['elimination of temporaries]: for example, the "naive" implementation
of `operator*` above, requires one temporary for computing the result, and at least another one to return it.  It's true
that sometimes this overhead can be reduced by using move-semantics, but it can't be eliminated completely.  For example,
lets suppose we're evaluating a polynomial via Horner's method, something like this:

    T a[7] = { /* some values */ };
    //....
    y = (((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0];

If type `T` is a `number`, then this expression is evaluated ['without creating a single temporary value].  In contrast,
if we were using the [mpfr_class] C++ wrapper for [mpfr] - then this expression would result in no less than 11
temporaries (this is true even though [mpfr_class] does use expression templates to reduce the number of temporaries somewhat).  Had
we used an even simpler wrapper around [mpfr] like [mpreal] things would have been even worse and no less that 24 temporaries
are created for this simple expression (note - we actually measure the number of memory allocations performed rather than
the number of temporaries directly, note also that the [mpf_class] wrapper that will be supplied with GMP-5.1 reduces the number of
temporaries to pretty much zero).  Note that if we compile with expression templates disabled and rvalue-reference support
on, then actually still have no wasted memory allocations as even though temporaries are created, their contents are moved
rather than copied.
[footnote The actual number generated will depend on the compiler, how well it optimizes the code, and whether it supports
rvalue references.  The number of 11 temporaries was generated with Visual C++ 2010.]

[important
Expression templates can radically reorder the operations in an expression, for example:

   a = (b * c) * a;

Will get transformed into:

   a *= c;
   a *= b;

If this is likely to be an issue for a particular application, then they should be disabled.
]

This library also extends expression template support to standard library functions like `abs` or `sin` with `number`
arguments.  This means that an expression such as:

   y = abs(x);

can be evaluated without a single temporary being calculated.  Even expressions like:

   y = sin(x);

get this treatment, so that variable 'y' is used as "working storage" within the implementation of `sin`,
thus reducing the number of temporaries used by one.  Of course, should you write:

   x = sin(x);

Then we clearly can't use `x` as working storage during the calculation, so then a temporary variable
is created in this case.

Given the comments above, you might be forgiven for thinking that expression-templates are some kind of universal-panacea:
sadly though, all tricks like this have their downsides.  For one thing, expression template libraries
like this one, tend to be slower to compile than their simpler cousins, they're also harder to debug
(should you actually want to step through our code!), and rely on compiler optimizations being turned
on to give really good performance.  Also, since the return type from expressions involving `number`s
is an "unmentionable implementation detail", you have to be careful to cast the result of an expression
to the actual number type when passing an expression to a template function.  For example, given:

   template <class T>
   void my_proc(const T&);

Then calling:

   my_proc(a+b);

Will very likely result in obscure error messages inside the body of `my_proc` - since we've passed it
an expression template type, and not a number type.  Instead we probably need:

   my_proc(my_number_type(a+b));

Having said that, these situations don't occur that often - or indeed not at all for non-template functions.
In addition, all the functions in the Boost.Math library will automatically convert expression-template arguments
to the underlying number type without you having to do anything, so:

   mpfr_float_100 a(20), delta(0.125);
   boost::math::gamma_p(a, a + delta);

Will work just fine, with the `a + delta` expression template argument getting converted to an `mpfr_float_100`
internally by the Boost.Math library.

[caution In C++11 you should never store an expression template using:

`auto my_expression = a + b - c;`

unless you're absolutely sure that the lifetimes of `a`, `b` and `c` will outlive that of `my_expression`.

In fact, it is particularly easy to create dangling references by mixing expression templates with the `auto`
keyword, for example:

`auto val = cpp_dec_float_50("23.1") * 100;`

In this situation, the integer literal is stored directly in the expression template - so its use is OK here -
but the `cpp_dec_float_50` temporary is stored by reference and then destructed when the statement completes,
leaving a dangling reference.

[*['If in doubt, do not ever mix expression templates with the `auto` keyword.]]
]

And finally... the performance improvements from an expression template library like this are often not as
dramatic as the reduction in number of temporaries would suggest.  For example, if we compare this library with
[mpfr_class] and [mpreal], with all three using the underlying [mpfr] library at 50 decimal digits precision then
we see the following typical results for polynomial execution:

[table Evaluation of Order 6 Polynomial.
[[Library]         [Relative Time]   [Relative number of memory allocations]]
[[number]          [1.0 (0.00957s)]  [1.0 (2996 total)]]
[[[mpfr_class]]    [1.1 (0.0102s)]   [4.3 (12976 total)]]
[[[mpreal]]        [1.6 (0.0151s)]   [9.3 (27947 total)]]
]

As you can see, the execution time increases a lot more slowly than the number of memory allocations.  There are
a number of reasons for this:

* The cost of extended-precision multiplication and division is so great, that the times taken for these tend to
swamp everything else.
* The cost of an in-place multiplication (using `operator*=`) tends to be more than an out-of-place
`operator*` (typically `operator *=` has to create a temporary workspace to carry out the multiplication, where
as `operator*` can use the target variable as workspace).  Since the expression templates carry out their
magic by converting out-of-place operators to in-place ones, we necessarily take this hit.  Even so the
transformation is more efficient than creating the extra temporary variable, just not by as much as
one would hope.

Finally, note that `number` takes a second template argument, which, when set to `et_off` disables all
the expression template machinery.  The result is much faster to compile, but slower at runtime.

We'll conclude this section by providing some more performance comparisons between these three libraries,
again, all are using [mpfr] to carry out the underlying arithmetic, and all are operating at the same precision
(50 decimal digits):

[table Evaluation of Boost.Math's Bessel function test data
[[Library]                                  [Relative Time] [Relative Number of Memory Allocations]]
[[mpfr_float_50]                            [1.0 (5.78s)]   [1.0 (1611963)]]
[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
                                            [1.1 (6.29s)]   [2.64 (4260868)]]
[[[mpfr_class]]                             [1.1 (6.28s)]   [2.45 (3948316)]]
[[[mpreal]]                                 [1.65 (9.54s)]  [8.21 (13226029)]]
]

[table Evaluation of Boost.Math's Non-Central T distribution test data
[[Library][Relative Time][Relative Number of Memory Allocations]]
[[number]                                   [1.0 (263s)][1.0 (127710873)]]
[[number<mpfr_float_backend<50>, et_off>[br](but with rvalue reference support)]
                                            [1.0 (260s)][1.2 (156797871)]]
[[[mpfr_class]]                             [1.1 (287s)][2.1 (268336640)]]
[[[mpreal]]                                 [1.5 (389s)][3.6 (466960653)]]
]

The above results were generated on Win32 compiling with Visual C++ 2010, all optimizations on (/Ox),
with MPFR 3.0 and MPIR 2.3.0.

[endsect] [/section:intro Introduction]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/multiprecision.css
================================================
/* Contains the basic settings for BoostBook and used by Quickbook to docbook conversion. */ 

/* Note:this import link assumes called from libs/multiprecision/doc/html, not from any backup copy in libs/multiprecision/doc. */
/* boost-no-inspect */
@import url('../../../../doc/src/boostbook.css');

/*=============================================================================
Copyright (c) 2004 Joel de Guzman    http://spirit.sourceforge.net/
Copyright (c) 2014 John Maddock
Copyright 2013 Niall Douglas additions for colors and alignment.
Copyright 2013 Paul A. Bristow additions for more colors and alignments.
Copyright 2019 Paul A. Bristow additions for more control of serif-italic font etc.

Distributed under the Boost Software License, Version 1.0. (See accompany-
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

    This Cascading Style Sheet is used to override and add to the standard Boost
    CSS BoostBook for a particular library, for example Boost.Math and Boost.Multiprecision.

    Visual Studio is recommended for editing this file 
    because it checks syntax, does layout and provides help on options.

IMPORTANT: there are two versions of this file - 

one in libs/math/doc and one in libs/math/doc/html

ONLY EVER EDIT THE FIRST OF THESE  !!!!

=============================================================================*/

/*=============================================================================
Program listings
=============================================================================*/

    /* Code on paragraphs */
    p tt.computeroutput
    {
        font-size: 10pt;
    }

    pre.synopsis
    {
        font-size: 10pt;
        margin: 1pc 4% 0pc 4%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }

    .programlisting,
    .screen
    {
        font-size: 10pt;
        display: block;
        /* was margin: 1pc 4% 0pc 4%; */
        margin: 1pc 2% 0pc 2%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }
		@media screen
    {
       /* Syntax Highlighting */
				.comment { color: green; }
				/* .comment { color: #008000; }	*/
		}						
    /* Program listings in tables don't get borders */
    td .programlisting,
    td .screen
    {
        margin: 0pc 0pc 0pc 0pc;
        padding: 0pc 0pc 0pc 0pc;
    }

/*=============================================================================
Table of contents
=============================================================================*/

    div.toc
    {
       margin: 1pc 4% 0pc 4%;
       padding: 0.1pc 1pc 0.1pc 1pc;
       font-size: 100%;
       line-height: 1.15;
    }

    .boost-toc
    {
       float: right;
       padding: 0.5pc;
    }

    /* Code on toc */
    .toc .computeroutput { font-size: 120% }

    /* No margin on nested menus */

    .toc dl dl { margin: 0; }


/*==============================================================================
Alignment and coloring use 'role' feature, available from Quickbook 1.6 up.
Added from Niall Douglas for role color and alignment.
http://article.gmane.org/gmane.comp.lib.boost.devel/243318
*/

/* Add text alignment (see http://www.w3schools.com/cssref/pr_text_text-align.asp) */
span.aligncenter
{
  display: inline-block; width: 100%; text-align: center;
}
span.alignright
{
  display: inline-block; width: 100%; text-align: right;
}
/* alignleft is the default. */
span.alignleft
{
  display: inline-block; width: 100%; text-align: left;
}

/* alignjustify stretches the word spacing so that each line has equal width
within a chosen fraction of page width (here arbitrarily 20%).
*Not* useful inside table items as the column width remains the total string width.
Nor very useful, except to temporarily restrict the width.
*/
span.alignjustify
{
  display: inline-block; width: 20%; text-align: justify;
}

/* Text colors.
Names at http://www.w3.org/TR/2002/WD-css3-color-20020219/ 4.3. X11 color keywords.
Quickbook Usage: [role red Some red text]

inline-block - Flows a element inline with the text, but allows width and height to be specified.

https://stackoverflow.com/questions/3043021/is-there-any-guide-on-when-to-use-displayblock-when-inline-and-when-inline-b#:~:text=The%20use%20cases%20for%20block,it%27s%20used%20naturally%20for%20images

*/
span.red { display:inline-block; color: red; }
span.green { display:inline-block; color: green; }
span.lime { display:inline-block; color: #00FF00; }
span.blue { display:inline-block; color: blue; }
span.navy { display:inline-block; color: navy; }
span.yellow { display:inline-block; color: yellow; }
span.magenta { display:inline-block; color: magenta; }
span.indigo { display:inline-block; color: #4B0082; }
span.cyan { display:inline-block; color: cyan; }
span.purple { display:inline-block; color: purple; }
span.gold { display:inline-block; color: gold; }
span.silver { display:inline-block; color: silver; } /* lighter gray */
span.gray { display:inline-block; color: #808080; } /* light gray */

/* role for inline Unicode mathematical equations,
    making font an italic (as is conventional for equations)
    and a serif version of font (to match those generated using .mml to SVG or PNG)
    and a little bigger (* 125%) because the serif font appears smaller than the default sans serif fonts.
    Used, for example: [role serif_italic This is in serif font and italic].
    Used in turn by template for inline expressions to match equations as SVG or PNG images.
    Can be combined with colors and bold.
*/
span.serif_italic {
    font-family: serif;
    font-style: italic;
    font-size: 125%;
    font-stretch: expanded;
}

/* Custom indent of paragraphs to make equations look nicer.
https://www.w3schools.com/tags/tag_blockquote.asp says 
  "Most browsers will display the <blockquote> element with left and right margin 40px values: "
*/
blockquote {
    display: block;
    margin-top: 1em;
    margin-bottom: 1em;
    margin-left: 2%;
    margin-right: 2%;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/multiprecision.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[library Boost.Multiprecision
    [quickbook 1.7]
    [copyright 2002-2020 John Maddock and Christopher Kormanyos]
    [purpose Multiprecision Number library]
    [license
         Distributed under the Boost Software License, Version 1.0.
         (See accompanying file LICENSE_1_0.txt or copy at
         [@http://www.boost.org/LICENSE_1_0.txt])
    ]
    [authors [Maddock, John], [Kormanyos, Christopher]]
    [/last-revision $Date: 2011-07-08 18:51:46 +0100 (Fri, 08 Jul 2011) $]
]

[import html4_symbols.qbk] [/Ideally this should be the same as Boost.Math I:\boost\libs\math\doc]

[import ../example/gmp_snips.cpp]
[import ../example/mpfr_snips.cpp]
[import ../example/mpfi_snips.cpp]
[import ../example/float128_snips.cpp]
[import ../example/cpp_dec_float_snips.cpp]
[import ../example/cpp_bin_float_snips.cpp]
[/import ../example/big_seventh.cpp]

[import ../example/cpp_int_import_export.cpp]
[import ../example/cpp_bin_float_import_export.cpp]
[import ../example/tommath_snips.cpp]
[import ../example/cpp_int_snips.cpp]
[import ../example/random_snips.cpp]
[import ../example/safe_prime.cpp]
[import ../example/mixed_integer_arithmetic.cpp]
[import ../example/logged_adaptor.cpp]
[import ../example/numeric_limits_snips.cpp]
[import ../example/hashing_examples.cpp]
[import ../example/cpp_complex_examples.cpp]
[import ../example/mpc_examples.cpp]
[import ../example/complex128_examples.cpp]
[import ../example/eigen_example.cpp]
[import ../example/mpfr_precision.cpp]
[import ../example/constexpr_float_arithmetic_examples.cpp]
[import ../test/constexpr_test_cpp_int_5.cpp]
[import ../test/constexpr_test_cpp_int_7.cpp]
[import ../performance/mixed_equivalent_types_bench.cpp]

[/External links as templates (see also some defs below)]
[template mpfr[] [@http://www.mpfr.org MPFR]]
[template mpc[] [@http://www.multiprecision.org MPC]]
[template mpfi[] [@http://perso.ens-lyon.fr/nathalie.revol/software.html MPFI]]
[template gmp[] [@http://gmplib.org GMP]]
[template mpf_class[] [@http://gmplib.org/manual/C_002b_002b-Interface-Floats.html#C_002b_002b-Interface-Floats mpf_class]]
[template mpfr_class[] [@http://math.berkeley.edu/~wilken/code/gmpfrxx/ mpfr_class]]
[template mpreal[] [@http://www.holoborodko.com/pavel/mpfr/ mpreal]]
[template mpir[] [@http://mpir.org/ MPIR]]
[template tommath[] [@http://libtom.net libtommath]]
[template quadmath[] [@http://gcc.gnu.org/onlinedocs/libquadmath/ libquadmath]]

[template super[x]'''<superscript>'''[x]'''</superscript>''']
[template sub[x]'''<subscript>'''[x]'''</subscript>''']

[/insert Equation as a PNG or SVG image, previous generated with an external tool like Latex.]
[/Used thus [equation ellint6]  - without the file type suffix which will chosen automatically.]

[template equation[name]  '''<inlinemediaobject>
<imageobject role="html">
<imagedata fileref="../'''[name]'''.png"></imagedata>
</imageobject>
<imageobject role="print">
<imagedata fileref="../'''[name]'''.svg"></imagedata>
</imageobject>
</inlinemediaobject>''']

[/insert Indented one-line expression italic and serif font probably using Unicode symbols for Greek and symbols.]
[/Example: [expression [sub 1]F[sub 0](a, z) = (1-z)[super -a]]]
[template expression[equation] 
[:
[role serif_italic [equation]]
]
[/ Hint you may need to enclose equation in brackets if it contains comma(s) to avoid "error invalid number of arguments"]
]

[def __tick [role aligncenter [role green \u2714]]] [/ u2714 is a HEAVY CHECK MARK tick (2713 check mark), green]
[def __cross [role aligncenter [role red \u2718]]] [/ u2718 is a heavy cross, red]
[def __star [role aligncenter [role red \u2736]]] [/ 6-point star red ]

[/Boost.Multiprecision internals links]
[def __cpp_int [link boost_multiprecision.tut.ints.cpp_int cpp_int]]
[def __gmp_int [link boost_multiprecision.tut.ints.gmp_int gmp_int]]
[def __tom_int [link boost_multiprecision.tut.ints.tom_int tom_int]]
[def __gmp_float [link boost_multiprecision.tut.floats.gmp_float gmp_float]]
[def __mpf_float [link boost_multiprecision.tut.floats.gmp_float gmp_float]]
[def __mpfr_float_backend [link boost_multiprecision.tut.floats.mpfr_float mpfr_float]]
[def __cpp_bin_float [link boost_multiprecision.tut.floats.cpp_bin_float cpp_bin_float]]
[def __cpp_dec_float [link boost_multiprecision.tut.floats.cpp_dec_float cpp_dec_float]]
[def __gmp_rational [link boost_multiprecision.tut.rational.gmp_rational gmp_rational]]
[def __cpp_rational [link boost_multiprecision.tut.rational.cpp_rational cpp_rational]]
[def __tommath_rational [link boost_multiprecision.tut.rational.tommath_rational tommath_rational]]
[def __number [link boost_multiprecision.ref.number number]]
[def __float128__ [link boost_multiprecision.tut.floats.float128 float128]]
[def __cpp_complex [link boost_multiprecision.tut.complex.cpp_complex cpp_complex]]
[def __mpc_complex [link boost_multiprecision.tut.complex.mpc_complex mpc_complex]]
[def __debug_adaptor [link boost_multiprecision.tut.misc.debug_adaptor debug_adaptor]]
[def __logged_adaptor [link boost_multiprecision.tut.misc.logged_adaptor logged_adaptor]]
[def __rational_adaptor [link boost_multiprecision.tut.rational.rational_adaptor rational_adaptor]]
[def __cpp_complex [link boost_multiprecision.tut.complex.cpp_complex cpp_complex]]
[def __mpfi_float [link boost_multiprecision.tut.interval.mpfi mpfi_float]]
[def __complex128 [link boost_multiprecision.tut.complex.complex128 complex128]]
[def __complex_adaptor [link boost_multiprecision.tut.complex.complex_adaptor complex_adaptor]]
[def __random [link boost_multiprecision.tut.random random number generation]]
[def __literals [link boost_multiprecision.tut.lits literals]]

[/External references links as macro definitions.]
[def __expression_template [@https://en.wikipedia.org/wiki/Expression_templates expression template]]
[def __expression_templates [@https://en.wikipedia.org/wiki/Expression_templates expression templates]] [/plural version]
[def __UDT [@http://eel.is/c++draft/definitions#defns.prog.def.type program-defined type]]
[def __fundamental_type [@https://en.cppreference.com/w/cpp/language/types fundamental (built-in) type]]
[def __fundamental_types [@https://en.cppreference.com/w/cpp/language/types fundamental (built-in) types]]
[def __fundamental [@https://en.cppreference.com/w/cpp/language/types fundamental (built-in)]]
[def __math_constants [@https://www.boost.org/doc/libs/release/libs/math/doc/html/math_toolkit/constants.html  Boost.Math constants]]
[def __boost_macros [@https://www.boost.org/doc/libs/release/libs/config/doc/html/boost_config/boost_macro_reference.html Boost macros]]
[def __boost_config [@https://www.boost.org/doc/libs/release/libs/config/doc/html/index.html Boost.Config]]
[def __is_constant_evaluated [@https://en.cppreference.com/w/cpp/types/is_constant_evaluated `std::is_constant_evaluated`]]
[def __compiler_support [@https://en.cppreference.com/w/cpp/compiler_support compiler support]]
[def __ULP [@http://en.wikipedia.org/wiki/Unit_in_the_last_place  Unit in the last place (ULP)]]
[def __Mathematica [@http://www.wolfram.com/products/mathematica/index.html Wolfram Mathematica]]
[def __WolframAlpha [@http://www.wolframalpha.com/ Wolfram Alpha]]
[def __Boost_Serialization [@https://www.boost.org/doc/libs/release/libs/serialization/doc/index.html Boost.Serialization]]
[def __Boost_Math [@https://www.boost.org/doc/libs/release/libs/math/doc/index.html Boost.Math]]
[def __Boost_Multiprecision [@https://www.boost.org/doc/libs/release/libs/multiprecision/doc/index.html Boost.Multiprecision]]

[include introduction.qbk]

[include tutorial.qbk]
[include reference.qbk]
[include performance.qbk]
[include history.qbk]

[section:indexes Indexes]

'''
<index type="function_name">
<title>Function Index</title>
</index>

<index type="class_name">
<title>Class Index</title>
</index>

<index type="typedef_name">
<title>Typedef Index</title>
</index>

<index/>
'''

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/numeric_limits_32_tables.qbk
================================================
[/
Copyright 2013 Paul A. Bristow.
Copyright 2013 John Maddock.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
]

[section:limits32 Numeric limits for 32-bit platform]
These tables were generated using the following program and options:

[pre

Program:
 numeric_limits_qbk.cpp 
Mon Nov  4 18:09:06 2013
BuildInfo:
  Platform Win32
  Compiler Microsoft Visual C++ version 10.0
  MSVC version 160040219.
  STL Dinkumware standard library version 520
  Boost version 1.55.0
]

[table:integral_constants Integer types constants (`std::numeric_limits<T>::is_integer == true` && is_exact == true)
[[type][signed][bound][modulo][round][radix][digits][digits10]]
[[bool][unsigned][bound][no][to zero][2][1][0]]
[[char][signed][bound][modulo][to zero][2][7][2]]
[[unsigned char][unsigned][bound][modulo][to zero][2][8][2]]
[[char16_t][unsigned][bound][modulo][to zero][2][16][4]]
[[char32_t][unsigned][bound][modulo][to zero][2][32][9]]
[[short][signed][bound][modulo][to zero][2][15][4]]
[[unsigned short][unsigned][bound][modulo][to zero][2][16][4]]
[[int][signed][bound][modulo][to zero][2][31][9]]
[[unsigned][unsigned][bound][modulo][to zero][2][32][9]]
[[long][signed][bound][modulo][to zero][2][31][9]]
[[unsigned long][unsigned][bound][modulo][to zero][2][32][9]]
[[long long][signed][bound][modulo][to zero][2][63][18]]
[[unsigned long long][unsigned][bound][modulo][to zero][2][64][19]]
[[int32_t][signed][bound][modulo][to zero][2][31][9]]
[[uint32_t][unsigned][bound][modulo][to zero][2][32][9]]
[[int64_t][signed][bound][modulo][to zero][2][63][18]]
[[uint64_t][unsigned][bound][modulo][to zero][2][64][19]]
[[int128_t][signed][bound][modulo][to zero][2][128][38]]
[[uint128_t][unsigned][bound][modulo][to zero][2][128][38]]
[[int256_t][signed][bound][modulo][to zero][2][256][77]]
[[uint256_t][unsigned][bound][modulo][to zero][2][256][77]]
[[cpp_int][signed][unbounded][no][to zero][2][2147483647][646392383]]
]

[table:integral_functions Integer types functions (`std::numeric_limits<T>::is_integer == true && std::numeric_limits<T>::min() == std::numeric_limits<T>::lowest()` )
[[function][max][min]]
[[bool][1][0]]
[[char][127][-128]]
[[unsigned char][255][0]]
[[char16_t][65535][0]]
[[char32_t][4294967295][0]]
[[short][32767][-32768]]
[[unsigned short][65535][0]]
[[int][2147483647][-2147483648]]
[[unsigned int][4294967295][0]]
[[long][2147483647][-2147483648]]
[[unsigned long][4294967295][0]]
[[long long][9223372036854775807][-9223372036854775808]]
[[unsigned long long][18446744073709551615][0]]
[[int32_t][2147483647][-2147483648]]
[[int64_t][9223372036854775807][-9223372036854775808]]
[[int128_t][340282366920938463463374607431768211455][-340282366920938463463374607431768211455]]]
[table:float_functions Floating-point types constants (`std::numeric_limits<T>::is_integer==false && is_signed==true && is_modulo==false && is_exact==false && is_bound==true`)
[[type][round][radix][digits][digits10][max_digits10][min_exp][min_exp10][max_exp][max_exp10][tiny][trap]]
[[float][to nearest][2][24][6][8][-125][-37][128][38][tiny][traps]]

[[double][to nearest][2][53][15][17][-1021][-307][1024][308][tiny][traps]]

[[long double][to nearest][2][53][15][17][-1021][-307][1024][308][tiny][traps]]

[[cpp_dec_float_50][indeterminate][10][50][50][80][-222953000][-67108864][222953000][67108864][no][no]]

[[bin_128bit_double_type][to nearest][2][377][113][115][-2147482894][-646392082][2147482893][646392082][no][traps]]
]
[table:float_functions Floating-point types functions (`std::numeric_limits<T>::is_integer == false`)
[[function][float][double][long double][cpp_dec_50][cpp_bin_128]][[max][3.40282e+038][1.79769e+308][1.79769e+308][1e+67108865][1.85906e+646456766]]
[[min][1.17549e-038][2.22507e-308][2.22507e-308][1e-67108864][5.37906e-646456767]]
[[epsilon][1.19209e-007][2.22045e-016][2.22045e-016][1e-49][6.49713e-114]]
[[round_error][0.5][0.5][0.5][0.5][0.5]]
[[infinity][1.#INF][1.#INF][1.#INF][inf][inf]]
[[quiet_NaN][1.#QNAN][1.#QNAN][1.#QNAN][nan][nan]]
[[signaling_NaN][1.#QNAN][1.#QNAN][1.#QNAN][0][0]]
[[denorm_min][1.4013e-045][4.94066e-324][4.94066e-324][0][0]]
]


[endsect] [/section:limits32  Numeric limits for 32-bit platform]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/numeric_limits_qbk.cpp
================================================
// Copyright Paul A. Bristow 2013

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

// Program to list all numeric_limits items for any type to a file in Quickbook format.

// C standard http://www.open-std.org/jtc1/sc22/wg11/docs/n507.pdf
// SC22/WG11 N507 DRAFT INTERNATIONAL ISO/IEC STANDARD WD 10967-1
// Information technology Language independent arithmetic Part 1: Integer and Floating point arithmetic

/* E.3 C++
The programming language C++ is defined by ISO/IEC 14882:1998, Programming languages C++ [18].
An implementation should follow all the requirements of LIA-1 unless otherwise specified by
this language binding.
*/

// https://doi.org/10.1109/IEEESTD.1985.82928

// http://www.cesura17.net/~will/Professional/Research/Papers/retrospective.pdf

// http://www.exploringbinary.com/using-integers-to-check-a-floating-point-approximation/

// http://stackoverflow.com/questions/12466745/how-to-convert-float-to-doubleboth-stored-in-ieee-754-representation-without-loss


#ifdef _MSC_VER
#  pragma warning (disable : 4127)  // conditional expression is constant.
#  pragma warning (disable : 4100)  // unreferenced formal parameter.
#endif


#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <fstream>
#include <limits> // numeric_limits

#include <typeinfo>

#include <boost/version.hpp>
#include <boost/config.hpp>

// May need extra includes for other types, for example:
#include <boost/multiprecision/cpp_dec_float.hpp> // is decimal.
#include <boost/multiprecision/cpp_bin_float.hpp> // is binary.


// Assume that this will be run on MSVC to get the 32 or 64 bit info.
#ifdef _WIN32
  std::string bits32_64 = "32";
std::string filename = "numeric_limits_32_tables.qbk";
#else
  std::string bits32_64 = "64";
std::string filename = "numeric_limits_64_tables.qbk";
#endif

#ifdef INT32_T_MAX
  int i = INT256_T_MAX;
#endif

std::array<std::string, 16> integer_type_names =
{
"bool",
"char",
"unsigned char",
"char16_t",
"char32_t",
"short",
"unsigned short",
"int",
"unsigned int",
"long",
"unsigned long",
"long long",
"unsigned long long",
"int32_t",
//"uint32_t",
"int64_t",
//"uint64_t",
"int128_t",
//"uint128_t" // Too big?
//"int256_t",
//"uint256_t"
//"int512_t"
};

std::array<std::string, 6> float_type_names =
{
  "function", "float", "double", "long double", "cpp_dec_50", "cpp_bin_128"
};

// Table headings for integer constants.
std::array<std::string, 8> integer_constant_heads =
{
    "type", "signed", "bound", "modulo", "round", "radix", "digits", "digits10", // "max_digits10"
};

// Table headings for integer functions.
std::array<std::string, 2> integer_function_heads =
{
  "max", // "lowest",  assumes is same for all integer types, so not worth listing.
  "min"
};

// Table headings for float constants.
std::array<std::string, 12> float_constant_heads =
{
    "type", // "signed", "exact", "bound", // "modulo",
    "round", "radix", "digits", "digits10", "max_digits10", "min_exp", "min_exp10", "max_exp", "max_exp10", "tiny", "trap"
};

// Table headings for float functions.
std::array<std::string, 10> float_function_heads =
{
  "function", "max", "lowest", "min", "eps", "round", "infinity", "NaN", "sig_NaN", "denorm_min"
};

std::string versions()
{ // Build a string of info about Boost, platform, STL, etc.
  std::stringstream mess;
  //mess << "\n" << "Program:\n\" " __FILE__  << "\"\n"; // \n is mis-interpreted!
  mess << "\n" << "Program:\n numeric_limits_qbk.cpp \n";
#ifdef __TIMESTAMP__
  mess << __TIMESTAMP__;
#endif
  mess << "\nBuildInfo:\n" "  Platform " << BOOST_PLATFORM;
  mess << "\n  Compiler " BOOST_COMPILER;
#ifdef _MSC_FULL_VER
  mess << "\n  MSVC version "<< BOOST_STRINGIZE(_MSC_FULL_VER) << ".";
#endif
  mess << "\n  STL " BOOST_STDLIB;
  mess << "\n  Boost version " << BOOST_VERSION/100000 << "." << BOOST_VERSION/100 % 1000 << "." << BOOST_VERSION % 100 << std::endl;
  return mess.str();
} // std::string versions()

template <typename T>
void out_round_style(std::ostream& os)
{ //! Send short string describing STD::round_style to stream os.
    // os << "Round style is ";
    if (std::numeric_limits<T>::round_style == std::round_indeterminate)
    {
     os << "indeterminate" ;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_zero)
    {
      os << "to zero" ;
    }
    else if (std::numeric_limits<T>::round_style == std::round_to_nearest)
    {
      os << "to nearest" ;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_infinity)
    {
      os << "to infin[]"; // Or << "to \u221E"  << "to infinity" ;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_neg_infinity)
    {
      os << "to -infin[]" ;
    }
    else
    {
      os << "undefined!";
      std::cout << "std::numeric_limits<T>::round_style is undefined value!" << std::endl;
    }
    return;
} // out_round_style(std::ostream& os);

template<typename T>
void integer_constants(std::string type_name, std::ostream& os)
{ //! Output a line of table integer constant values to ostream os.
    os << "\n["
          "[" << type_name << "]" ;
    os << "[" << (std::numeric_limits<T>::is_signed ? "signed" : "unsigned") << "]" ;
    // Is always exact for integer types, so removed:
    // os << "[" << (std::numeric_limits<T>::is_exact ? "exact" : "inexact") << "]" ;
    os << "[" << (std::numeric_limits<T>::is_bounded ? "bound" : "unbounded") << "]" ;
    os << "[" << (std::numeric_limits<T>::is_modulo ? "modulo" : "no") << "]" ;
    os << "[" ; out_round_style<T>(os); os << "]" ;
    os << "[" << std::numeric_limits<T>::radix << "]" ;
    os << "[" << std::numeric_limits<T>::digits << "]" ;
    os << "[" << std::numeric_limits<T>::digits10 << "]" ;
    // Undefined for integers, so removed:
   // os << "[" << std::numeric_limits<T>::max_digits10 << "]"
     os << "]";
} // void integer_constants


template<typename T>
void float_constants(std::string type_name, std::ostream& os)
{ //! Output a row of table values to `ostream` os.
    os << "\n["
          "[" << type_name << "]" ;
    //os << "[" << (std::numeric_limits<T>::is_signed ? "signed" : "unsigned") << "]" ;
    //os << "[" << (std::numeric_limits<T>::is_exact ? "exact" : "inexact") << "]" ;
    //os << "[" << (std::numeric_limits<T>::is_bounded ? "bound" : "no") << "]" ;
    // os << "[" << (std::numeric_limits<T>::is_modulo ? "modulo" : "no") << "]" ;
    os << "[" ; out_round_style<T>(os); os << "]" ;
    os << "[" << std::numeric_limits<T>::radix << "]" ;
    os << "[" << std::numeric_limits<T>::digits << "]" ;
    os << "[" << std::numeric_limits<T>::digits10 << "]" ;
    os << "[" << std::numeric_limits<T>::max_digits10 << "]";
    os << "[" << std::numeric_limits<T>::min_exponent << "]" ;
    os << "[" << std::numeric_limits<T>::min_exponent10 << "]" ;
    os << "[" << std::numeric_limits<T>::max_exponent << "]" ;
    os << "[" << std::numeric_limits<T>::max_exponent10  << "]" ;
    os << "[" << (std::numeric_limits<T>::tinyness_before ? "tiny" : "no") << "]" ;
    os << "[" << (std::numeric_limits<T>::traps ? "traps" : "no") << "]" ;
    os << "]" "\n"; // end of row.
} // void float_constants

/* Types across and two functions down.

template<typename T>
void integer_functions(std::string type_name, std::ostream& os)
{ //! Output a line of table integer function values to `ostream` os.
    os << "\n["
          "[" << type_name << "]" ;
    os << "[" << std::numeric_limits<T>::max() << "]" ;
    //os << "[" << std::numeric_limits<T>::lowest() << "]" ;  always == min for integer types,
    // so removed to save space.
    os << "[" << std::numeric_limits<T>::min() << "]"
      "]";
} // void integer_functions

*/

// Types down and two (or three) functions across.
template<typename T>
void integer_functions(std::string type_name, std::ostream& os)
{ //! Output a line of table integer function values to `ostream` os.
    os << "\n[" // start of row.
          "[" << type_name << "]" ;
    os << "[" << (std::numeric_limits<T>::max)() << "]" ;
   // os << "[" << std::numeric_limits<T>::lowest() << "]" ;
    os << "[" << (std::numeric_limits<T>::min)() << "]" ;
    os <<  "]"; // end of row.
} // void integer_functions


template<typename T>
void float_functions(std::string type_name, std::ostream& os)
{ //! Output a line of table float-point function values to `ostream` os.
    os << "\n[" // start of row.
          "[" << type_name << "]" ;
    os << "[" << (std::numeric_limits<T>::max)() << "]" ;
    os << "[" << (std::numeric_limits<T>::lowest)() << "]" ;
    os << "[" << (std::numeric_limits<T>::min)() << "]"
    os << "[" << std::numeric_limits<T>::epsilon() << "]"
    os << "[" << std::numeric_limits<T>::round_error() << "]"
    os << "[" << std::numeric_limits<T>::infinity() << "]"
    os << "[" << std::numeric_limits<T>::quiet_NaN() << "]"
    os << "[" << std::numeric_limits<T>::signaling_NaN() << "]"
    os << "[" << std::numeric_limits<T>::denorm_min() << "]"
      "]"; // end of row.
} // void float_functions

template<typename T>
int numeric_limits_list(std::string description)
{//!  Output numeric_limits for numeric_limits<T>, for example `numeric_limits_list<bool>()`.
  // This is not used for Quickbook format.
  // std::cout << versions()  << std::endl;

  std::cout << "\n" << description << "\n"  << std::endl; // int, int64_t rather than full long typeid(T).name().

  std::cout << "Type " << typeid(T).name() << " std::numeric_limits::<" << typeid(T).name() << ">\n"  << std::endl;
  // ull long typeid(T).name()

  if (std::numeric_limits<T>::is_specialized == false)
  {
    std::cout << "type " << typeid(T).name()  << " is not specialized for std::numeric_limits!" << std::endl;
    //return -1;
  }

  // Member constants.

  std::cout << (std::numeric_limits<T>::is_signed ? "is signed." : "unsigned.")  << std::endl;
  std::cout << (std::numeric_limits<T>::is_integer ? "is integer." : "not integer (fixed or float-point).")  << std::endl;
  std::cout << (std::numeric_limits<T>::is_exact ? "is exact." : "not exact.")  << std::endl;
  std::cout << (std::numeric_limits<T>::has_infinity ? "has infinity." : "no infinity.")  << std::endl;
  std::cout << (std::numeric_limits<T>::has_quiet_NaN ? "has quiet NaN." : "no quiet NaN.")  << std::endl;
  std::cout << (std::numeric_limits<T>::has_signaling_NaN ? "has signaling NaN." : "no signaling NaN.")  << std::endl;
  if (!std::numeric_limits<T>::is_integer)
  { // is floating_point
    std::cout << "Denorm style is " ;
    if (std::numeric_limits<T>::has_denorm == std::denorm_absent)
    {
      std::cout << "denorm_absent." << std::endl;
    }
    else if (std::numeric_limits<T>::has_denorm == std::denorm_present)
    {
      std::cout << "denorm_present." << std::endl;
    }
    else if (std::numeric_limits<T>::has_denorm == std::denorm_indeterminate)
    {
      std::cout << "denorm_indeterminate." << std::endl;
    }
    else
    {
      std::cout << "std::numeric_limits<T>::has_denorm unexpected value!" << std::endl;
    }

    std::cout << (std::numeric_limits<T>::has_denorm_loss ? "has denorm loss." : "no denorm loss.")  << std::endl;
    // true if a loss of accuracy is detected as a denormalization loss, rather than an inexact result.

    std::cout << "Round style is ";
    if (std::numeric_limits<T>::round_style == std::round_indeterminate)
    {
      std::cout << "round_indeterminate!" << std::endl;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_zero)
    {
      std::cout << "round_toward_zero." << std::endl;
    }
    else if (std::numeric_limits<T>::round_style == std::round_to_nearest)
    {
      std::cout << "round_to_nearest." << std::endl;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_infinity)
    {
      std::cout << "round_toward_infinity." << std::endl;
    }
    else if (std::numeric_limits<T>::round_style == std::round_toward_neg_infinity)
    {
      std::cout << "round_toward_neg_infinity." << std::endl;
    }
    else
    {
      std::cout << "undefined value!" << std::endl;
    }

  } // is floating_point

  std::cout << (std::numeric_limits<T>::is_iec559 ? "is IEC599." : "not IEC599.")  << std::endl;
  std::cout << (std::numeric_limits<T>::is_bounded ? "is bound." : "unbounded.")  << std::endl;
  std::cout << (std::numeric_limits<T>::is_modulo ? "is modulo." : "no modulo.")  << std::endl;
  std::cout << std::dec << "radix " << std::numeric_limits<T>::radix  << std::endl;
  std::cout << "digits " << std::numeric_limits<T>::digits  << std::endl;
  std::cout << "digits10 " << std::numeric_limits<T>::digits10  << std::endl;

  std::cout.precision(std::numeric_limits<T>::max_digits10); // Full precision for floating-point values like max, min ...

  std::cout << "max_digits10 " << std::numeric_limits<T>::max_digits10  << std::endl;
  std::cout << "min_exponent " << std::numeric_limits<T>::min_exponent  << std::endl;
  std::cout << "min_exponent10 " << std::numeric_limits<T>::min_exponent10  << std::endl;
  std::cout << "max_exponent " << std::numeric_limits<T>::max_exponent  << std::endl;
  std::cout << "max_exponent10 " << std::numeric_limits<T>::max_exponent10  << std::endl;

  std::cout << (std::numeric_limits<T>::tinyness_before ? "Can tiny values before rounding." : "no tinyness_before.")  << std::endl;
  // true if the type can detect tiny values before rounding; false if it cannot.
  std::cout << (std::numeric_limits<T>::traps ? "traps" : "no trapping.")  << std::endl;
  // Whether trapping that reports on arithmetic exceptions is implemented for a type.

  std::cout << "Member functions." << std::endl;
  // (assumes operator<< for type T is available).
  // If floating-point then hex format may not be available.

  std::cout << "max = " << (std::numeric_limits<T>::max)() << std::endl;
  //if (std::numeric_limits<T>::is_integer)
  //{
  //  std::cout << "    = " << std::hex << std::numeric_limits<T>::max() << std::endl;
  //}

  std::cout << "lowest = " << std::dec << std::numeric_limits<T>::lowest() << std::endl;
  //if (std::numeric_limits<T>::is_integer)
  //{
  //   std::cout << "       = " << std::hex << std::numeric_limits<T>::lowest() << std::endl;
  //}

  std::cout << "min = " << (std::dec << std::numeric_limits<T>::min)() << std::endl;
  //if (std::numeric_limits<T>::is_integer)
  //{
  //  std::cout << "    = " << std::hex << std::numeric_limits<T>::min() << std::endl;
  //}

  std::cout << "epsilon = " << std::dec << std::numeric_limits<T>::epsilon() << std::endl;
  //if (std::numeric_limits<T>::is_integer)
  //{
  //  std::cout << "        = " << std::hex << std::numeric_limits<T>::epsilon() << std::endl;
  //}
  // round_error is always zero for integer types.
  // round_error is usually 1/2 = (T)0.5 for floating-point types.
  // round_error is ? for fixed-point.
  std::cout << "round_error = " << std::numeric_limits<T>::round_error() << " ULP." << std::endl;

  std::cout << "infinity = " << std::dec << std::numeric_limits<T>::infinity() << std::endl;
  std::cout << "         = " << std::hex << std::numeric_limits<T>::infinity() << std::endl;

  std::cout << "quiet_NaN = " << std::dec << std::numeric_limits<T>::quiet_NaN() << std::endl;
  std::cout << "          = " << std::hex << std::numeric_limits<T>::quiet_NaN() << std::endl;

  std::cout << "signaling_NaN = " << std::dec << std::numeric_limits<T>::signaling_NaN() << std::endl;
  std::cout << "              = " << std::hex << std::numeric_limits<T>::signaling_NaN() << std::endl;

  //  Only meaningful if (std::numeric_limits<T>::has_denorm == std::denorm_present)
  // so might not bother to show if absent?
  std::cout << "denorm_min = " << std::numeric_limits<T>::denorm_min()  << std::endl;
  std::cout << "           = " << std::numeric_limits<T>::denorm_min()  << std::endl;
  return 0;
}

int main()
{



  try
  {
    using namespace boost::multiprecision;

    std::cout << versions() << std::endl;

    std::ofstream fout(filename, std::ios_base::out);
    if (!fout.is_open())
    {
      std::cout << "Unable to open file " << filename << " for output.\n" << std::endl;
      return -1; // boost::EXIT_FAILURE;
    }
    fout <<
      "[/""\n"
      "Copyright 2013 Paul A. Bristow.""\n"
      "Copyright 2013 John Maddock.""\n"
      "Distributed under the Boost Software License, Version 1.0.""\n"
      "(See accompanying file LICENSE_1_0.txt or copy at""\n"
      "http://www.boost.org/LICENSE_1_0.txt).""\n"
      "]""\n"
    << std::endl;

    fout << "[section:limits"<< bits32_64 << " Numeric limits for " << bits32_64 << "-bit platform]" << std::endl;

    // Output platform version info (32 or 64).
    fout << "These tables were generated using the following program and options:\n\n"
      "[pre""\n"
      << versions()
      << "]""\n"
      << std::endl;

    fout << "[table:integral_constants Integer types constants (`std::numeric_limits<T>::is_integer == true` && is_exact == true)" "\n"
      "[";

    for (size_t i = 0; i < integer_constant_heads.size(); i++)
    { // signed, bound, modulo ...
      fout << "[" << integer_constant_heads[i] << "]" ;
    }
    fout << "]";

    integer_constants<bool>("bool", fout);
    integer_constants<char>("char", fout);
    integer_constants<unsigned char>("unsigned char", fout);
    integer_constants<char16_t>("char16_t", fout);
    integer_constants<char32_t>("char32_t", fout);
    integer_constants<short>("short", fout);
    integer_constants<unsigned short>("unsigned short", fout);
    integer_constants<int>("int", fout);
    integer_constants<unsigned int>("unsigned", fout);
    integer_constants<long>("long", fout);
    integer_constants<unsigned long>("unsigned long", fout);
    integer_constants<long long>("long long", fout);
    integer_constants<unsigned long long>("unsigned long long", fout);
    integer_constants<int32_t>("int32_t", fout);
    integer_constants<uint32_t>("uint32_t", fout);
    integer_constants<int64_t>("int64_t", fout);
    integer_constants<uint64_t>("uint64_t", fout);
    integer_constants<int128_t>("int128_t", fout);
    integer_constants<uint128_t>("uint128_t", fout);
    integer_constants<int256_t>("int256_t", fout);
    integer_constants<uint256_t>("uint256_t", fout);
   // integer_constants<int512_t>("int512_t", fout);
    //integer_constants<uint512_t>("uint512_t", fout); // Too big?
    integer_constants<cpp_int>("cpp_int", fout);

    fout << "\n]\n\n";


    fout << "[table:integral_functions Integer types functions (`std::numeric_limits<T>::is_integer == true && std::numeric_limits<T>::min() == std::numeric_limits<T>::lowest()` )" "\n"
      "[";
    // Display types across the page, and 2 (or 3) functions as rows.

    fout << "[function]";
    for (size_t i = 0; i < integer_function_heads.size(); i++)
    {
      fout << "[" << integer_function_heads[i] << "]" ;
    }
    fout << "]"; // end of headings.
    integer_functions<bool>("bool", fout);
    //integer_functions<char>("char", fout); // Need int value not char.
    fout << "\n[" // start of row.
       "[" << "char"<< "]" ;
    fout << "[" << static_cast<int>(std::numeric_limits<char>::max)() << "]" ;
   // fout << "[" << (std::numeric_limits<T>::lowest)() << "]" ;
    fout << "[" << static_cast<int>(std::numeric_limits<char>::min)() << "]" ;
    fout <<  "]"; // end of row.
    //integer_functions<unsigned char>("unsigned char", fout); // Need int value not char.
    fout << "\n[" // start of row.
       "[" << "unsigned char"<< "]" ;
    fout << "[" << static_cast<int>(std::numeric_limits<unsigned char>::max)() << "]" ;
   // fout << "[" << std::numeric_limits<unsigned char>::lowest() << "]" ;
    fout << "[" << static_cast<int>(std::numeric_limits<unsigned char>::min)() << "]" ;
    fout <<  "]"; // end of row.

    integer_functions<char16_t>("char16_t", fout);
    integer_functions<char32_t>("char32_t", fout);
    integer_functions<short>("short", fout);
    integer_functions<unsigned short>("unsigned short", fout);
    integer_functions<int>("int", fout);
    integer_functions<unsigned int>("unsigned int", fout);
    integer_functions<long>("long", fout);
    integer_functions<unsigned long>("unsigned long", fout);
    integer_functions<long long>("long long", fout);
    integer_functions<unsigned long long>("unsigned long long", fout);
    integer_functions<int32_t>("int32_t", fout);
    integer_functions<int64_t>("int64_t", fout);
    integer_functions<int128_t>("int128_t", fout);
    fout << "]" "\n";  // end of table;


    //fout << "[[max]"
    //  << "[" << std::numeric_limits<bool>::max() << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char>::max()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<unsigned char>::max()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char16_t>::max()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char32_t>::max()) << "]"
    //  << "[" << std::numeric_limits<short>::max() << "]"
    //  << "[" << std::numeric_limits<unsigned short>::max() << "]"
    //  << "[" << std::numeric_limits<int>::max() << "]"
    //  << "[" << std::numeric_limits<unsigned int>::max() << "]"
    //  << "[" << std::numeric_limits<long>::max() << "]"
    //  << "[" << std::numeric_limits<unsigned long>::max() << "]"
    //  << "[" << std::numeric_limits<long long>::max() << "]"
    //  << "[" << std::numeric_limits<unsigned long long>::max() << "]"
    //  << "[" << std::numeric_limits<int32_t>::max() << "]"
    //  << "[" << std::numeric_limits<int64_t>::max() << "]"
    //  << "[" << std::numeric_limits<int128_t>::max() << "]"
    //  //<< "[" << std::numeric_limits<int256_t>::max() << "]"  // too big?
    //  //<< "[" << std::numeric_limits<int512_t>::max() << "]" // too big?
    //  << "]" "\n";
    ///*  Assume lowest() is not useful as == min for all integer types.
    // */

    //fout << "[[min]"
    //  << "[" << std::numeric_limits<bool>::min() << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char>::min()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<unsigned char>::min()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char16_t>::min()) << "]"
    //  << "[" << static_cast<int>(std::numeric_limits<char32_t>::min()) << "]"
    //  << "[" << std::numeric_limits<short>::min() << "]"
    //  << "[" << std::numeric_limits<unsigned short>::min() << "]"
    //  << "[" << std::numeric_limits<int>::min() << "]"
    //  << "[" << std::numeric_limits<unsigned int>::min() << "]"
    //  << "[" << std::numeric_limits<long>::min() << "]"
    //  << "[" << std::numeric_limits<unsigned long>::min() << "]"
    //  << "[" << std::numeric_limits<long long>::min() << "]"
    //  << "[" << std::numeric_limits<unsigned long long>::min() << "]"
    //  << "[" << std::numeric_limits<int32_t>::min() << "]"
    //  << "[" << std::numeric_limits<int64_t>::min() << "]"
    //  << "[" << std::numeric_limits<int128_t>::min() << "]"
    //  // << "[" << std::numeric_limits<int256_t>::min() << "]"  // too big?
    //  // << "[" << std::numeric_limits<int512_t>::min() << "]"  // too big?
    //  << "]""\n";



  // Floating-point

    typedef number<cpp_dec_float<50> > cpp_dec_float_50; // 50 decimal digits.
    typedef number<cpp_bin_float<113> > bin_128bit_double_type; // == Binary rare long double.

    fout <<
      //"[table:float_functions Floating-point types constants (`std::numeric_limits<T>::is_integer == false && std::numeric_limits<T>::is_modulo == false` )" "\n"
      "[table:float_functions Floating-point types constants (`std::numeric_limits<T>::is_integer==false && is_signed==true && is_modulo==false && is_exact==false && is_bound==true`)" "\n"
      "[";
    for (size_t i = 0; i < float_constant_heads.size(); i++)
    {
      fout << "[" << float_constant_heads[i] << "]" ;
    }
    fout << "]"; // end of headings.

    float_constants<float>("float", fout);
    float_constants<double>("double", fout);
    float_constants<long double>("long double", fout);
    float_constants<cpp_dec_float_50>("cpp_dec_float_50", fout);
    float_constants<bin_128bit_double_type>("bin_128bit_double_type", fout);
    fout << "]" "\n";  // end of table;

    fout <<
      "[table:float_functions Floating-point types functions (`std::numeric_limits<T>::is_integer == false`)" "\n"
      "[";

    for (size_t i = 0; i < float_type_names.size(); i++)
    {
      fout << "[" << float_type_names[i] << "]" ;
    }
    fout << "]"; // end of headings.

    fout << "[[max]"
      << "[" << (std::numeric_limits<float>::max)() << "]"
      << "[" << (std::numeric_limits<double>::max)() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Perhaps to test Long double is not just a duplication of double (but need change is headings too).
      << "[" << (std::numeric_limits<long double>::max)() << "]"
//#endif
      << "[" << (std::numeric_limits<cpp_dec_float_50>::max)() << "]"
      << "[" << (std::numeric_limits<bin_128bit_double_type >::max)() << "]"
      << "]" "\n"; // end of row.

    fout << "[[min]"
      << "[" << (std::numeric_limits<float>::min)() << "]"
      << "[" << (std::numeric_limits<double>::min)() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << (std::numeric_limits<long double>::min)() << "]"
//#endif
      << "[" << (std::numeric_limits<cpp_dec_float_50 >::min)() << "]"
      << "[" << (std::numeric_limits<bin_128bit_double_type >::min)() << "]"
      << "]" "\n"; // end of row.

    fout << "[[epsilon]"
      << "[" << std::numeric_limits<float>::epsilon() << "]"
      << "[" << std::numeric_limits<double>::epsilon() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::epsilon() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::epsilon() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::epsilon() << "]"
      << "]" "\n"; // end of row.

    fout << "[[round_error]"
      << "[" << std::numeric_limits<float>::round_error() << "]"
      << "[" << std::numeric_limits<double>::round_error() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::round_error() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::round_error() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::round_error() << "]"
      << "]" "\n"; // end of row.

    fout << "[[infinity]"
      << "[" << std::numeric_limits<float>::infinity() << "]"
      << "[" << std::numeric_limits<double>::infinity() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::infinity() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::infinity() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::infinity() << "]"
      << "]" "\n"; // end of row.

    fout << "[[quiet_NaN]"
      << "[" << std::numeric_limits<float>::quiet_NaN() << "]"
      << "[" << std::numeric_limits<double>::quiet_NaN() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::quiet_NaN() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::quiet_NaN() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::quiet_NaN() << "]"
      << "]" "\n"; // end of row.

    fout << "[[signaling_NaN]"
      << "[" << std::numeric_limits<float>::signaling_NaN() << "]"
      << "[" << std::numeric_limits<double>::signaling_NaN() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::signaling_NaN() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::signaling_NaN() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::signaling_NaN() << "]"
      << "]" "\n"; // end of row.

    fout << "[[denorm_min]"
      << "[" << std::numeric_limits<float>::denorm_min() << "]"
      << "[" << std::numeric_limits<double>::denorm_min() << "]"
//#if LDBL_MANT_DIG > DBL_MANT_DIG
    // Long double is not just a duplication of double.
      << "[" << std::numeric_limits<long double>::denorm_min() << "]"
//#endif
      << "[" << std::numeric_limits<cpp_dec_float_50 >::denorm_min() << "]"
      << "[" << std::numeric_limits<bin_128bit_double_type >::denorm_min() << "]"
      << "]" "\n"; // end of row.



     fout << "]" "\n";  // end of table;


       fout <<  "\n\n"
    "[endsect] [/section:limits32  Numeric limits for 32-bit platform]" "\n" << std::endl;



    fout.close();
  }
  catch(std::exception ex)
  {
    std::cout << "exception thrown: " << ex.what() << std::endl;
  }


} // int main()

/*
  Description: Autorun "J:\Cpp\Misc\Debug\numeric_limits_qbk.exe"

  Program: I:\boost-sandbox\multiprecision.cpp_bin_float\libs\multiprecision\doc\numeric_limits_qbk.cpp
  Wed Aug 28 14:17:21 2013
  BuildInfo:
    Platform Win32
    Compiler Microsoft Visual C++ version 10.0
    MSVC version 160040219.
    STL Dinkumware standard library version 520
    Boost version 1.55.0

  */



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:perf Performance Comparison]

In the beginning of the project and throughout,
many performance analyses, counts of multiprecision-operations-per-second
and the like have been performed.
Some of these are already listed in the ensuing sections.

We will now provide some general notes on performance, valid
for all of the multiprecision backends, before the detailed
benchmarks of the following sections.

The header-only, library-independent Boost-licenses integer
and floating-point backends including
__cpp_int for multiprecision integers,
__cpp_bin_float and __cpp_dec_float for multiprecision floating-point types
are significantly slower than the world's fastest implementations
generally agreed to be found in GMP/MPIR, MPFR and MPC (which are based on GMP).
Complex types __cpp_complex that are synthesized from these types
share similar relative performances.

The backends which effectively wrap GMP/MPIR and MPFR
retain the superior performance of the low-level big-number engines.
When these are used (in association with at least some level of optmization)
they achieve and retain the expected low-level performances.

At low digit counts, however, it is noted that the performances of __cpp_int,
__cpp_bin_float and __cpp_dec_float can actually meet or exceed
those encountered for GMP/MPIR, MPFR, etc. The reason for this
is because stack allocation and/or the use of fast container
storage can actually out-perform the allocation mechanisms in
GMP/MPIR, which dominate run-time costs at low digit counts.

As digit counts rise above about 50 or so, however,
GMP/MPIR performance steadily increases,
and simultaneously increases beyond (in relation to)
the performances of the Boost-licensed, self-written backends.
At around a few hundred to several thousands of digits,
factors of about two through five are observed,
whereby GMP/MPIR-based calculations are (performance-wise)
supreior ones.

At a few thousand decimal digits, the upper end of
the Boost backends is reached. At the moment,
advanced big-number multiplication schemes in the
Boost-licensed, self-written backends is limited
to school multiplication and Karatsuba multiplication.
Higher-orders of Toom-Cook and FFT-based multiplication
are not (yet) implemented. So it is not yet
feasible to perform mega-digit calculations
with the Boost-licensed, self-written backends,
whereas these are readily possible with
the GMP/MPIR and MPRF based backends.

[include performance_overhead.qbk]
[include performance_real_world.qbk]
[include performance_integer_real_world.qbk]
[include performance_rational_real_world.qbk]
[include performance_float.qbk]
[include performance_integer.qbk]
[include performance_rational.qbk]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:float_performance Float Algorithm Performance]

Note that these tests are carefully designed to test performance of the underlying algorithms
and not memory allocation or variable copying.  As usual, performance results should be taken
with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
specifics of the program.  In each table relative times are given first, with the best performer
given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
operations.

[table Operator *
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][4.45465 (0.0720574s)][4.33995 (0.111688s)][2.90491 (0.850904s)]]
[[cpp_dec_float][3.82572 (0.061884s)][5.06288 (0.130292s)][5.77019 (1.6902s)]]
[[gmp_float][1.28958 (0.02086s)][[*1] (0.0257348s)][[*1] (0.292919s)]]
[[mpfr_float][[*1] (0.0161758s)][2.57159 (0.0661794s)][1.09888 (0.321884s)]]
]
[table Operator *(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][7.78457 (0.0399504s)][8.32801 (0.0464923s)][5.78369 (0.12206s)]]
[[cpp_dec_float][12.2836 (0.0630393s)][22.4215 (0.125171s)][115.745 (2.44271s)]]
[[gmp_float][[*1] (0.00513201s)][[*1] (0.00558264s)][[*1] (0.0211042s)]]
[[mpfr_float][6.55686 (0.0336498s)][6.08531 (0.0339721s)][3.75579 (0.0792629s)]]
]
[table Operator *(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][3.96061 (0.0508387s)][9.0225 (0.0540758s)][3.84877 (0.0843974s)]]
[[cpp_dec_float][5.80905 (0.0745654s)][24.6321 (0.147631s)][122.419 (2.68446s)]]
[[gmp_float][[*1] (0.0128361s)][[*1] (0.00599344s)][[*1] (0.0219284s)]]
[[mpfr_float][2.15124 (0.0276134s)][4.61073 (0.0276341s)][2.31056 (0.0506668s)]]
]
[table Operator *=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.54027 (0.0500366s)][5.58857 (0.0547429s)][3.33593 (0.0987612s)]]
[[cpp_dec_float][9.23894 (0.0706828s)][17.6238 (0.172634s)][81.1437 (2.40228s)]]
[[gmp_float][[*1] (0.00765054s)][[*1] (0.00979552s)][[*1] (0.0296053s)]]
[[mpfr_float][2.99517 (0.0229147s)][3.55395 (0.0348128s)][2.42098 (0.0716736s)]]
]
[table Operator +
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][2.61482 (0.0479759s)][6.91285 (0.0901201s)][8.04302 (0.219881s)]]
[[cpp_dec_float][1.08384 (0.0198859s)][1.6631 (0.0216812s)][7.59843 (0.207727s)]]
[[gmp_float][1.00042 (0.0183555s)][[*1] (0.0130366s)][[*1] (0.0273382s)]]
[[mpfr_float][[*1] (0.0183477s)][1.4588 (0.0190178s)][2.22935 (0.0609463s)]]
]
[table Operator +(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][11.8195 (0.0524679s)][13.9144 (0.0871804s)][13.6745 (0.165014s)]]
[[cpp_dec_float][3.22445 (0.0143136s)][2.703 (0.0169356s)][12.5227 (0.151114s)]]
[[gmp_float][[*1] (0.00443909s)][[*1] (0.00626549s)][[*1] (0.0120673s)]]
[[mpfr_float][5.78563 (0.0256829s)][4.78942 (0.0300081s)][5.21353 (0.062913s)]]
]
[table Operator +(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][21.4259 (0.109321s)][16.4546 (0.128103s)][14.7256 (0.16427s)]]
[[cpp_dec_float][4.53931 (0.0231609s)][3.75913 (0.0292658s)][13.3516 (0.148942s)]]
[[gmp_float][[*1] (0.0051023s)][[*1] (0.00778526s)][[*1] (0.0111554s)]]
[[mpfr_float][5.11905 (0.0261189s)][3.73777 (0.0290995s)][5.52758 (0.0616622s)]]
]
[table Operator +=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.6778 (0.109847s)][6.84045 (0.0942496s)][9.09759 (0.157162s)]]
[[cpp_dec_float][1.06799 (0.017568s)][1.71962 (0.0236933s)][10.7777 (0.186187s)]]
[[gmp_float][[*1] (0.0164496s)][[*1] (0.0137783s)][[*1] (0.0172751s)]]
[[mpfr_float][3.47654 (0.0571878s)][3.64857 (0.0502709s)][4.56004 (0.0787754s)]]
]
[table Operator -
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.04597 (0.0688937s)][4.65775 (0.0896788s)][7.55005 (0.196627s)]]
[[cpp_dec_float][1.42357 (0.0194363s)][1.62766 (0.0313385s)][8.16298 (0.21259s)]]
[[gmp_float][[*1] (0.0136532s)][[*1] (0.0192537s)][[*1] (0.0260432s)]]
[[mpfr_float][1.76726 (0.0241287s)][2.05663 (0.0395976s)][2.48295 (0.0646638s)]]
]
[table Operator -(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.31633 (0.0848243s)][7.07646 (0.084402s)][6.65523 (0.181209s)]]
[[cpp_dec_float][1.6139 (0.0216737s)][2.20945 (0.0263524s)][5.27802 (0.14371s)]]
[[gmp_float][[*1] (0.0134294s)][[*1] (0.0119272s)][[*1] (0.0272281s)]]
[[mpfr_float][5.1551 (0.0692297s)][5.48391 (0.0654074s)][2.6116 (0.0711089s)]]
]
[table Operator -(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][9.08373 (0.102878s)][4.54284 (0.0883961s)][7.01771 (0.185162s)]]
[[cpp_dec_float][2.19345 (0.0248419s)][1.47898 (0.0287785s)][5.71248 (0.150724s)]]
[[gmp_float][[*1] (0.0113255s)][[*1] (0.0194584s)][[*1] (0.026385s)]]
[[mpfr_float][5.35926 (0.0606961s)][2.92255 (0.056868s)][3.43277 (0.0905736s)]]
]
[table Operator -=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][8.73347 (0.129938s)][4.58762 (0.101449s)][5.43827 (0.163157s)]]
[[cpp_dec_float][1.67927 (0.0249846s)][1.79526 (0.0396995s)][6.63379 (0.199025s)]]
[[gmp_float][[*1] (0.0148782s)][[*1] (0.0221136s)][[*1] (0.0300017s)]]
[[mpfr_float][3.96488 (0.0589902s)][3.30899 (0.0731736s)][3.51566 (0.105476s)]]
]
[table Operator /
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.40221 (0.549759s)][10.0182 (1.39191s)][12.3684 (5.32129s)]]
[[cpp_dec_float][8.16505 (0.83092s)][12.483 (1.73437s)][52.8644 (22.744s)]]
[[gmp_float][[*1] (0.101766s)][[*1] (0.138938s)][[*1] (0.430233s)]]
[[mpfr_float][1.6699 (0.169939s)][2.16251 (0.300455s)][2.82683 (1.2162s)]]
]
[table Operator /(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.81464 (0.141651s)][12.2991 (0.271491s)][8.20246 (0.643802s)]]
[[cpp_dec_float][16.4865 (0.40163s)][39.0331 (0.861622s)][164 (12.8722s)]]
[[gmp_float][[*1] (0.0243611s)][[*1] (0.0220741s)][[*1] (0.0784889s)]]
[[mpfr_float][2.25501 (0.0549347s)][2.6832 (0.0592293s)][1.60852 (0.126251s)]]
]
[table Operator /(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][10.879 (0.19558s)][10.4845 (0.244599s)][8.82445 (0.621615s)]]
[[cpp_dec_float][22.028 (0.396014s)][42.4784 (0.991001s)][201.351 (14.1836s)]]
[[gmp_float][[*1] (0.0179778s)][[*1] (0.0233296s)][[*1] (0.0704423s)]]
[[mpfr_float][2.89723 (0.0520857s)][2.6935 (0.0628383s)][1.67233 (0.117803s)]]
]
[table Operator /=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][11.0264 (0.215322s)][7.78235 (0.256093s)][8.31638 (0.638041s)]]
[[cpp_dec_float][20.9412 (0.408938s)][38.8146 (1.27727s)][142.377 (10.9233s)]]
[[gmp_float][[*1] (0.0195279s)][[*1] (0.032907s)][[*1] (0.076721s)]]
[[mpfr_float][2.67894 (0.0523141s)][2.16678 (0.071302s)][1.5964 (0.122477s)]]
]
[table Operator construct
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][[*1] (0.0030982s)][1.37355 (0.00608929s)][[*1] (0.0152335s)]]
[[cpp_dec_float][1.23911 (0.00383901s)][[*1] (0.00443324s)][1.6806 (0.0256013s)]]
[[gmp_float][7.50258 (0.0232445s)][5.47554 (0.0242744s)][5.81062 (0.0885159s)]]
[[mpfr_float][24.9598 (0.0773304s)][19.5526 (0.0866815s)][5.00378 (0.0762248s)]]
]
[table Operator construct(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][2.08541 (0.0175206s)][3.12821 (0.0267453s)][1.32687 (0.0570308s)]]
[[cpp_dec_float][[*1] (0.00840151s)][[*1] (0.00854971s)][[*1] (0.0429815s)]]
[[gmp_float][3.08163 (0.0258903s)][2.44895 (0.0209379s)][2.12806 (0.0914671s)]]
[[mpfr_float][10.6814 (0.08974s)][8.42482 (0.0720298s)][1.8282 (0.0785786s)]]
]
[table Operator construct(unsigned)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][1.04974 (0.00808983s)][1.38823 (0.0120486s)][1.16321 (0.0530205s)]]
[[cpp_dec_float][[*1] (0.00770653s)][[*1] (0.00867913s)][[*1] (0.0455813s)]]
[[gmp_float][3.88496 (0.0299395s)][2.90503 (0.0252132s)][1.82072 (0.0829907s)]]
[[mpfr_float][13.3088 (0.102564s)][8.41333 (0.0730204s)][1.78408 (0.0813206s)]]
]
[table Operator str
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.09659 (0.00301165s)][4.71882 (0.0051705s)][12.4899 (0.043165s)]]
[[cpp_dec_float][2.94087 (0.00145276s)][1.64843 (0.00180621s)][3.16004 (0.0109211s)]]
[[gmp_float][[*1] (0.000493989s)][[*1] (0.00109572s)][[*1] (0.00345598s)]]
[[mpfr_float][4.60349 (0.00227407s)][1.21213 (0.00132816s)][1.41569 (0.0048926s)]]
]

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_integer.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:integer_performance Integer Algorithm Performance]

Note that these tests are carefully designed to test performance of the underlying algorithms
and not memory allocation or variable copying.  As usual, performance results should be taken
with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
specifics of the program.  In each table relative times are given first, with the best performer
given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
operations.

[table Operator %
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][1.51155 (0.0481508s)][1.60666 (0.0825917s)][1.75956 (0.127209s)][1.87154 (0.171986s)][2.58143 (0.368469s)][[*1] (0.512768s)][1.42429 (1.03083s)][[*1] (1.96988s)]]
[[cpp_int(fixed)][[*1] (0.0318553s)][1.2913 (0.0663805s)][1.33672 (0.0966394s)][1.97924 (0.181883s)]]
[[gmp_int][1.4659 (0.0466966s)][[*1] (0.0514059s)][[*1] (0.0722958s)][[*1] (0.0918952s)][[*1] (0.142738s)][[*1] (0.24073s)][1.17701 (0.603534s)][[*1] (0.723753s)]]
[[tommath_int][27.46 (0.874748s)][20.1749 (1.03711s)][17.9774 (1.29969s)][19.0867 (1.75398s)][23.3789 (3.33706s)][26.6546 (6.41658s)][33.4553 (17.1548s)][70.788 (51.233s)]]
]
[table Operator %(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][[*1] (0.00790481s)][1.45288 (0.0215141s)][2.71488 (0.065874s)][4.05695 (0.1044s)][6.59285 (0.288068s)][3.58045 (0.429244s)][6.18417 (0.851447s)][[*1] (1.57951s)]]
[[cpp_int(fixed)][2.18748 (0.0172916s)][1.67119 (0.0247468s)][2.83861 (0.0688759s)][4.3186 (0.111133s)]]
[[gmp_int][1.50165 (0.0118703s)][[*1] (0.0148079s)][[*1] (0.024264s)][[*1] (0.0257336s)][[*1] (0.0436939s)][[*1] (0.0571251s)][[*1] (0.119886s)][[*1] (0.137682s)]]
[[tommath_int][68.9623 (0.545134s)][54.52 (0.807325s)][38.3573 (0.930702s)][53.0833 (1.36603s)][59.6958 (2.60834s)][103.597 (5.91797s)][133.648 (16.0225s)][392.812 (54.083s)]]
]
[table Operator &
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.82137 (0.0101034s)][3.08842 (0.0128886s)][3.46566 (0.018172s)][2.55025 (0.0204051s)][2.97241 (0.0461406s)][[*1] (0.0440714s)][[*1] (0.0811524s)][[*1] (0.146531s)]]
[[cpp_int(fixed)][[*1] (0.00358104s)][1.5374 (0.00641591s)][1.70378 (0.0089337s)][2.40825 (0.019269s)]]
[[gmp_int][1.10071 (0.00394167s)][[*1] (0.00417321s)][[*1] (0.00524347s)][[*1] (0.00800121s)][[*1] (0.015523s)][1.04806 (0.0384586s)][2.0133 (0.0887291s)][1.38531 (0.112421s)]]
[[tommath_int][2.18066 (0.00780901s)][2.22528 (0.00928657s)][2.15567 (0.0113032s)][3.05906 (0.0244762s)][2.34741 (0.0364387s)][1.50551 (0.0552444s)][2.29355 (0.10108s)][3.0313 (0.245997s)]]
]
[table Operator &(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.24695 (0.0124861s)][1.81002 (0.0114113s)][2.11984 (0.0179186s)][2.56949 (0.0262296s)][3.62157 (0.063826s)][3.95427 (0.0593859s)][4.84754 (0.102968s)][[*1] (0.168385s)]]
[[cpp_int(fixed)][[*1] (0.0038455s)][[*1] (0.00630453s)][[*1] (0.00845281s)][2.20848 (0.0225444s)]]
[[gmp_int][3.87448 (0.0148993s)][1.50343 (0.00947844s)][1.59793 (0.013507s)][[*1] (0.0102081s)][[*1] (0.0176239s)][[*1] (0.0121449s)][[*1] (0.0150182s)][[*1] (0.0212413s)]]
[[tommath_int][25.1094 (0.0965583s)][15.7147 (0.0990734s)][9.65097 (0.0815778s)][8.5208 (0.0869813s)][5.74798 (0.101302s)][10.598 (0.128712s)][12.0534 (0.18102s)][13.0183 (0.276527s)]]
]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.4201 (0.0145016s)][1.838 (0.0246772s)][2.10406 (0.0631704s)][2.22846 (0.224062s)][2.53789 (0.918685s)][[*1] (2.65154s)][[*1] (7.83314s)][[*1] (26.1836s)]]
[[cpp_int(fixed)][[*1] (0.00116759s)][1.76789 (0.0237359s)][1.58515 (0.047591s)][1.52628 (0.153461s)]]
[[gmp_int][4.80091 (0.00560549s)][[*1] (0.0134261s)][[*1] (0.0300231s)][[*1] (0.100546s)][[*1] (0.361988s)][[*1] (1.11701s)][2.08347 (5.52441s)][1.44767 (11.3398s)]]
[[tommath_int][16.9604 (0.0198027s)][2.43157 (0.0326465s)][2.82213 (0.0847288s)][1.67653 (0.168568s)][1.27293 (0.460786s)][1.41678 (1.58255s)][2.69181 (7.13744s)][3.30421 (25.8824s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][10.9781 (0.0072726s)][1.52901 (0.00991594s)][3.35266 (0.0194072s)][2.30215 (0.0214459s)][1.95214 (0.047049s)][[*1] (0.0576663s)][[*1] (0.0955853s)][[*1] (0.167493s)]]
[[cpp_int(fixed)][[*1] (0.000662467s)][[*1] (0.00648519s)][1.52643 (0.0088359s)][2.26708 (0.0211192s)]]
[[gmp_int][7.14641 (0.00473426s)][1.74133 (0.0112929s)][[*1] (0.00578859s)][[*1] (0.00931559s)][[*1] (0.0241013s)][1.12075 (0.0477494s)][1.96831 (0.113505s)][1.44107 (0.137745s)]]
[[tommath_int][156.154 (0.103447s)][14.5292 (0.0942242s)][16.82 (0.0973642s)][11.9029 (0.110883s)][5.61803 (0.135402s)][4.61241 (0.196512s)][5.30415 (0.30587s)][5.73424 (0.548109s)]]
]
[table Operator *(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][8.98335 (0.00669928s)][1.79861 (0.00820918s)][1.86924 (0.0119122s)][1.71773 (0.0175683s)][2.57826 (0.0539343s)][[*1] (0.0432066s)][[*1] (0.0813634s)][[*1] (0.159452s)]]
[[cpp_int(fixed)][[*1] (0.000745744s)][1.07211 (0.00489332s)][1.19888 (0.00764018s)][1.53618 (0.0157115s)]]
[[gmp_int][4.97741 (0.00371188s)][[*1] (0.00456418s)][[*1] (0.00637276s)][[*1] (0.0102277s)][[*1] (0.0209189s)][[*1] (0.0321931s)][2.05197 (0.0886586s)][1.59261 (0.12958s)]]
[[tommath_int][143.938 (0.107341s)][24.0751 (0.109883s)][16.9325 (0.107907s)][11.5473 (0.118102s)][8.08283 (0.169084s)][6.84808 (0.220461s)][8.37134 (0.361697s)][8.20104 (0.667264s)]]
]
[table Operator *=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][15.7803 (0.0131299s)][1.67116 (0.00790233s)][1.66661 (0.0119079s)][1.51408 (0.0203561s)][1.23815 (0.0373067s)][[*1] (0.0424701s)][[*1] (0.0946934s)][[*1] (0.177219s)]]
[[cpp_int(fixed)][[*1] (0.000832044s)][[*1] (0.00472864s)][[*1] (0.00714494s)][[*1] (0.0134446s)]]
[[gmp_int][6.73473 (0.00560359s)][1.81651 (0.00858963s)][1.36813 (0.00977523s)][1.00404 (0.0134989s)][[*1] (0.0301309s)][[*1] (0.0457849s)][2.56449 (0.108914s)][2.20384 (0.208689s)]]
[[tommath_int][115.266 (0.0959064s)][24.7701 (0.117129s)][15.9941 (0.114277s)][11.3798 (0.152996s)][5.69861 (0.171704s)][5.47882 (0.250847s)][10.6875 (0.453899s)][7.29439 (0.690731s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.80738 (0.0086037s)][2.34204 (0.0160922s)][1.00627 (0.0131305s)][1.67865 (0.0163002s)][1.88916 (0.033949s)][[*1] (0.0412289s)][[*1] (0.083134s)][[*1] (0.190174s)]]
[[cpp_int(fixed)][[*1] (0.000877268s)][[*1] (0.00687102s)][1.82016 (0.0237507s)][1.90391 (0.0184876s)]]
[[gmp_int][5.87168 (0.00515104s)][1.45191 (0.00997612s)][[*1] (0.0130487s)][[*1] (0.00971031s)][[*1] (0.0179704s)][[*1] (0.0300729s)][1.96754 (0.0811195s)][1.62045 (0.134715s)]]
[[tommath_int][13.6707 (0.0119929s)][1.03266 (0.00709542s)][1.02249 (0.0133422s)][1.4749 (0.0143218s)][1.17551 (0.0211244s)][1.08462 (0.0326177s)][1.47125 (0.060658s)][2.75813 (0.229295s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][7.65014 (0.00534018s)][1.8992 (0.0063589s)][1.56778 (0.00666443s)][1.29719 (0.00836612s)][1.73231 (0.0204874s)][[*1] (0.0198385s)][[*1] (0.0338486s)][[*1] (0.0760202s)]]
[[cpp_int(fixed)][[*1] (0.000698051s)][1.72665 (0.00578118s)][1.57164 (0.00668085s)][1.90796 (0.0123052s)]]
[[gmp_int][4.97679 (0.00347405s)][[*1] (0.0033482s)][[*1] (0.00425087s)][[*1] (0.0064494s)][[*1] (0.0118266s)][[*1] (0.0195694s)][3.53343 (0.0700979s)][2.28146 (0.0772241s)]]
[[tommath_int][127.407 (0.0889366s)][24.8716 (0.0832749s)][20.4864 (0.0870848s)][12.5462 (0.0809152s)][7.07209 (0.083639s)][4.79434 (0.0938225s)][5.93694 (0.11778s)][5.20775 (0.176275s)]]
]
[table Operator +(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.92952 (0.00893714s)][2.68575 (0.0136811s)][1.73024 (0.0102989s)][1.43961 (0.0115471s)][1.46556 (0.0237404s)][[*1] (0.0253811s)][[*1] (0.0350422s)][[*1] (0.0761856s)]]
[[cpp_int(fixed)][[*1] (0.000900057s)][1.27396 (0.00648945s)][1.38787 (0.008261s)][1.56798 (0.0125768s)]]
[[gmp_int][5.22669 (0.00470432s)][[*1] (0.00509394s)][[*1] (0.00595229s)][[*1] (0.00802101s)][[*1] (0.0161988s)][[*1] (0.0174726s)][1.83602 (0.0466003s)][1.90731 (0.0668364s)]]
[[tommath_int][100.859 (0.0907784s)][19.2654 (0.0981367s)][14.4537 (0.0860324s)][10.0594 (0.0806864s)][5.71755 (0.0926177s)][6.23483 (0.108939s)][4.63528 (0.117648s)][5.01743 (0.175822s)]]
]
[table Operator +=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.2366 (0.0106404s)][1.48157 (0.00996803s)][1.58862 (0.0108279s)][2.06658 (0.0131949s)][1.1631 (0.0186902s)][[*1] (0.0218483s)][[*1] (0.0394761s)][[*1] (0.0783171s)]]
[[cpp_int(fixed)][[*1] (0.000869555s)][1.34779 (0.00906799s)][[*1] (0.00681593s)][[*1] (0.00638493s)]]
[[gmp_int][11.3522 (0.00987134s)][[*1] (0.00672804s)][1.27495 (0.00868995s)][2.42237 (0.0154667s)][[*1] (0.0160693s)][1.09672 (0.0221405s)][2.61199 (0.0570676s)][2.13093 (0.0841208s)]]
[[tommath_int][88.4252 (0.0768906s)][14.139 (0.0951277s)][11.6282 (0.0792569s)][14.5551 (0.0929332s)][6.86867 (0.110375s)][5.67471 (0.11456s)][7.29502 (0.159384s)][5.733 (0.226317s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][4.45457 (0.00859678s)][1.28478 (0.013219s)][1.27873 (0.0117779s)][1.43649 (0.0151597s)][2.82516 (0.0507822s)][[*1] (0.0463464s)][[*1] (0.0813138s)][[*1] (0.191562s)]]
[[cpp_int(fixed)][[*1] (0.00192988s)][[*1] (0.010289s)][[*1] (0.00921062s)][1.5372 (0.0162226s)]]
[[gmp_int][3.4436 (0.00664573s)][1.25045 (0.0128659s)][1.10953 (0.0102195s)][[*1] (0.0105533s)][[*1] (0.017975s)][[*1] (0.0321962s)][2.54862 (0.11812s)][1.83623 (0.14931s)]]
[[tommath_int][9.3224 (0.0179911s)][1.08796 (0.011194s)][1.93265 (0.017801s)][1.82306 (0.0192393s)][1.55663 (0.0279804s)][1.6544 (0.0532653s)][1.90928 (0.0884881s)][4.41259 (0.358805s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.07164 (0.00347144s)][1.38957 (0.00531251s)][1.29053 (0.00548206s)][1.35239 (0.00759591s)][1.50007 (0.0176467s)][[*1] (0.0209158s)][[*1] (0.0402632s)][[*1] (0.0674681s)]]
[[cpp_int(fixed)][[*1] (0.00113016s)][1.26281 (0.00482789s)][1.25074 (0.00531307s)][3.3923 (0.0190533s)]]
[[gmp_int][3.22069 (0.00363988s)][[*1] (0.00382312s)][[*1] (0.00424793s)][[*1] (0.00561665s)][[*1] (0.0117639s)][[*1] (0.0225873s)][2.75829 (0.0576919s)][2.03214 (0.0818204s)]]
[[tommath_int][81.1433 (0.0917047s)][21.4543 (0.0820224s)][19.3098 (0.0820267s)][16.2994 (0.0915478s)][7.23608 (0.0851246s)][4.48441 (0.101291s)][5.51882 (0.115431s)][4.44737 (0.179066s)]]
]
[table Operator -(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][7.02787 (0.00807189s)][1.85949 (0.00922027s)][1.40179 (0.00830959s)][1.22546 (0.00988039s)][1.27526 (0.0235442s)][[*1] (0.0242017s)][[*1] (0.0317445s)][[*1] (0.0783054s)]]
[[cpp_int(fixed)][[*1] (0.00114855s)][1.03947 (0.00515424s)][1.22566 (0.00726552s)][1.56568 (0.0126235s)]]
[[gmp_int][7.54669 (0.00866778s)][[*1] (0.0049585s)][[*1] (0.00592785s)][[*1] (0.00806262s)][[*1] (0.0184622s)][[*1] (0.0220616s)][1.79985 (0.0435595s)][2.08427 (0.0661641s)]]
[[tommath_int][72.1332 (0.0828488s)][18.985 (0.0941371s)][13.9301 (0.0825755s)][9.93889 (0.0801335s)][5.42256 (0.100113s)][4.58437 (0.101139s)][4.91664 (0.118991s)][5.5407 (0.175887s)]]
]
[table Operator -=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][10.8565 (0.0103583s)][2.00541 (0.0102937s)][1.73348 (0.0103591s)][2.53718 (0.0189898s)][1.21308 (0.0265754s)][[*1] (0.0249248s)][[*1] (0.0377524s)][[*1] (0.070851s)]]
[[cpp_int(fixed)][[*1] (0.000954108s)][[*1] (0.00513296s)][[*1] (0.00597589s)][[*1] (0.00748462s)]]
[[gmp_int][6.6602 (0.00635455s)][1.61345 (0.00828179s)][1.41745 (0.00847054s)][1.41728 (0.0106078s)][[*1] (0.0219074s)][[*1] (0.0250737s)][2.12439 (0.05295s)][2.51074 (0.0947863s)]]
[[tommath_int][88.858 (0.0847801s)][18.6448 (0.0957029s)][13.7283 (0.0820388s)][13.4423 (0.100611s)][4.83335 (0.105886s)][4.6829 (0.117418s)][7.59449 (0.189292s)][5.86189 (0.2213s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.20876 (0.0878919s)][3.17469 (0.181536s)][3.14517 (0.250544s)][4.14655 (0.365546s)][4.70812 (0.702366s)][2.28619 (1.18106s)][3.54663 (2.26453s)][[*1] (4.52755s)]]
[[cpp_int(fixed)][[*1] (0.0273912s)][1.72404 (0.098585s)][2.12584 (0.169344s)][3.71442 (0.327451s)]]
[[gmp_int][1.70383 (0.04667s)][[*1] (0.0571824s)][[*1] (0.0796599s)][[*1] (0.0881567s)][[*1] (0.149182s)][[*1] (0.208719s)][[*1] (0.516606s)][[*1] (0.638503s)]]
[[tommath_int][40.8044 (1.11768s)][17.2975 (0.989116s)][17.4097 (1.38686s)][20.9668 (1.84837s)][20.6415 (3.07934s)][31.5839 (6.59216s)][33.0087 (17.0525s)][81.0894 (51.7759s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][4.50037 (0.0520677s)][6.30243 (0.108097s)][8.34437 (0.193637s)][7.02879 (0.296939s)][6.47793 (0.630264s)][2.64044 (1.08346s)][3.92627 (2.33772s)][[*1] (4.22641s)]]
[[cpp_int(fixed)][1.27227 (0.0147198s)][4.34067 (0.0744498s)][6.08699 (0.141253s)][6.56549 (0.277366s)]]
[[gmp_int][[*1] (0.0115696s)][[*1] (0.0171517s)][[*1] (0.0232057s)][[*1] (0.0422461s)][[*1] (0.0972941s)][[*1] (0.156597s)][[*1] (0.410334s)][[*1] (0.595404s)]]
[[tommath_int][60.4712 (0.69963s)][44.8464 (0.769191s)][40.4334 (0.938285s)][35.0752 (1.48179s)][26.8178 (2.60921s)][37.2616 (5.83504s)][37.7146 (15.4756s)][84.1326 (50.0929s)]]
]
[table Operator /(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][6.09203 (0.0582351s)][6.42997 (0.0982056s)][6.2137 (0.151642s)][6.62408 (0.281298s)][9.30105 (0.706562s)][3.66307 (1.0584s)][4.10257 (2.14867s)][[*1] (4.2547s)]]
[[cpp_int(fixed)][1.76794 (0.0169001s)][3.59379 (0.0548884s)][5.55499 (0.135566s)][6.36274 (0.2702s)]]
[[gmp_int][[*1] (0.00955921s)][[*1] (0.0152731s)][[*1] (0.0244044s)][[*1] (0.042466s)][[*1] (0.0759658s)][[*1] (0.125208s)][[*1] (0.288938s)][[*1] (0.523737s)]]
[[tommath_int][63.2738 (0.604848s)][57.3767 (0.876321s)][43.9301 (1.07209s)][40.0122 (1.69916s)][41.1147 (3.12331s)][57.9739 (7.25882s)][68.6676 (19.8407s)][109.312 (57.2509s)]]
]
[table Operator /=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][5.21402 (0.0701172s)][4.76442 (0.105309s)][5.1245 (0.171387s)][7.39587 (0.299993s)][6.88568 (0.632889s)][3.2993 (1.05399s)][3.52936 (2.14442s)][[*1] (4.37618s)]]
[[cpp_int(fixed)][1.68246 (0.0226255s)][3.12633 (0.0691018s)][3.98733 (0.133354s)][6.62903 (0.268888s)]]
[[gmp_int][[*1] (0.0134478s)][[*1] (0.0221032s)][[*1] (0.0334445s)][[*1] (0.0405622s)][[*1] (0.0919138s)][[*1] (0.14699s)][[*1] (0.319457s)][[*1] (0.607595s)]]
[[tommath_int][46.0731 (0.619583s)][43.6571 (0.964961s)][30.1861 (1.00956s)][41.4936 (1.68307s)][32.6785 (3.0036s)][48.2935 (7.09868s)][64.9093 (20.7357s)][111.801 (67.9296s)]]
]
[table Operator <<
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.93178 (0.0116142s)][1.74005 (0.0147029s)][2.68859 (0.0238748s)][2.04419 (0.0394659s)][2.15112 (0.0859331s)][[*1] (0.0889652s)][[*1] (0.190562s)][[*1] (0.32803s)]]
[[cpp_int(fixed)][[*1] (0.00116939s)][[*1] (0.00844969s)][1.94851 (0.0173029s)][1.55242 (0.0299716s)]]
[[gmp_int][4.60815 (0.00538874s)][1.02939 (0.00869801s)][[*1] (0.00888006s)][[*1] (0.0193064s)][[*1] (0.039948s)][[*1] (0.0597248s)][1.65224 (0.146992s)][1.08567 (0.206887s)]]
[[tommath_int][10.7935 (0.0126218s)][2.38166 (0.0201243s)][2.42444 (0.0215291s)][1.87488 (0.0361972s)][1.73489 (0.0693055s)][1.93177 (0.115375s)][2.49667 (0.222116s)][2.82346 (0.538044s)]]
]
[table Operator >>
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.5304 (0.011709s)][6.85524 (0.0153366s)][8.77866 (0.0209131s)][3.21549 (0.0146098s)][4.04361 (0.0183489s)][3.04276 (0.0219967s)][8.19636 (0.0537598s)][[*1] (0.0745484s)]]
[[cpp_int(fixed)][[*1] (0.000934446s)][6.55349 (0.0146615s)][6.51353 (0.0155169s)][4.90631 (0.0222922s)]]
[[gmp_int][2.59712 (0.00242687s)][[*1] (0.0022372s)][[*1] (0.00238226s)][[*1] (0.00454358s)][[*1] (0.00453774s)][[*1] (0.00313265s)][[*1] (0.00722919s)][[*1] (0.00655899s)]]
[[tommath_int][102.662 (0.0959319s)][42.5337 (0.0951565s)][39.1437 (0.0932504s)][21.0397 (0.0955953s)][29.6104 (0.134364s)][62.7092 (0.196446s)][49.6167 (0.358689s)][137.105 (0.899272s)]]
]
[table Operator ^
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.8103 (0.0101384s)][4.11932 (0.0282768s)][2.25923 (0.0139063s)][1.94172 (0.0187085s)][1.66067 (0.0405646s)][[*1] (0.0369865s)][[*1] (0.0918676s)][[*1] (0.150955s)]]
[[cpp_int(fixed)][[*1] (0.00360758s)][[*1] (0.00686442s)][1.50683 (0.00927498s)][1.79076 (0.0172541s)]]
[[gmp_int][1.35398 (0.0048846s)][1.00969 (0.00693092s)][[*1] (0.00615531s)][[*1] (0.00963503s)][[*1] (0.0244266s)][[*1] (0.0429561s)][2.17737 (0.0805332s)][1.3521 (0.124214s)]]
[[tommath_int][2.28701 (0.00825059s)][1.65996 (0.0113947s)][2.06089 (0.0126854s)][2.03244 (0.0195826s)][1.4173 (0.0346198s)][1.32237 (0.0568037s)][2.69468 (0.0996668s)][2.55626 (0.234837s)]]
]
[table Operator ^(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.67312 (0.00991885s)][1.57246 (0.0115174s)][2.50193 (0.0198209s)][[*1] (0.0153479s)][[*1] (0.0264078s)][[*1] (0.0235546s)][[*1] (0.0392727s)][[*1] (0.0657809s)]]
[[cpp_int(fixed)][[*1] (0.00371059s)][[*1] (0.0073244s)][[*1] (0.00792226s)][1.04763 (0.0160789s)]]
[[gmp_int][2.86377 (0.0106263s)][2.18619 (0.0160125s)][2.18777 (0.0173321s)][1.01844 (0.0156309s)][1.13176 (0.0298873s)][1.9665 (0.0406408s)][3.34613 (0.0788165s)][3.54952 (0.139399s)]]
[[tommath_int][26.101 (0.0968501s)][14.6444 (0.107261s)][10.0538 (0.079649s)][5.64392 (0.0866224s)][3.8806 (0.102478s)][6.36386 (0.131519s)][8.07216 (0.190136s)][8.01428 (0.314742s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.24638 (0.00190752s)][1.06172 (0.00258002s)][[*1] (0.00248269s)][[*1] (0.00191598s)][[*1] (0.00273948s)][[*1] (0.0017072s)][[*1] (0.00191549s)][[*1] (0.0016635s)]]
[[cpp_int(fixed)][[*1] (0.000587582s)][[*1] (0.00243004s)][1.51116 (0.00375174s)][4.66482 (0.00893771s)]]
[[gmp_int][5.61558 (0.00329962s)][1.52898 (0.0037155s)][2.51713 (0.00624925s)][1.755 (0.00336255s)][1.40183 (0.00384029s)][1.60131 (0.00385483s)][4.7818 (0.0081635s)][2.07779 (0.00397999s)]]
[[tommath_int][251.1 (0.147542s)][63.6186 (0.154596s)][54.6947 (0.13579s)][66.8839 (0.128148s)][47.8098 (0.130974s)][54.8252 (0.13198s)][74.1436 (0.126578s)][83.945 (0.160796s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.12644 (0.00192028s)][[*1] (0.00200418s)][[*1] (0.00223886s)][[*1] (0.00189442s)][[*1] (0.00190833s)][[*1] (0.00199036s)][[*1] (0.00200998s)][[*1] (0.00168004s)]]
[[cpp_int(fixed)][[*1] (0.000903049s)][1.26395 (0.00253319s)][1.78621 (0.00399907s)][5.10701 (0.0096748s)]]
[[gmp_int][27.1389 (0.0245077s)][10.3593 (0.020762s)][9.02272 (0.0202006s)][9.96334 (0.0188747s)][15.2262 (0.0290565s)][8.50239 (0.0244927s)][35.6564 (0.0709692s)][10.9129 (0.0219346s)]]
[[tommath_int][183.484 (0.165695s)][83.0709 (0.166489s)][69.5984 (0.155821s)][75.8903 (0.143768s)][85.5979 (0.163349s)][50.8174 (0.146389s)][70.0602 (0.139445s)][95.4952 (0.191943s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.00349 (0.00174712s)][[*1] (0.00225895s)][[*1] (0.00241092s)][[*1] (0.00177047s)][[*1] (0.00304865s)][[*1] (0.0018378s)][[*1] (0.0017583s)][[*1] (0.00197229s)]]
[[cpp_int(fixed)][[*1] (0.000872038s)][1.1805 (0.0026667s)][1.66167 (0.00400614s)][5.54475 (0.00981681s)]]
[[gmp_int][27.6419 (0.0241048s)][10.0723 (0.0227529s)][7.60577 (0.0183369s)][10.2725 (0.0181871s)][9.38419 (0.0286091s)][9.10394 (0.0220052s)][34.6032 (0.0635939s)][15.7134 (0.0276289s)]]
[[tommath_int][207.462 (0.180915s)][84.5379 (0.190967s)][65.2109 (0.157218s)][84.8572 (0.150237s)][47.0682 (0.143494s)][59.4466 (0.143689s)][78.5549 (0.144368s)][103.519 (0.182018s)]]
]
[table Operator gcd
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.10743 (0.358587s)][1.8778 (1.42989s)][2.03859 (3.30534s)][2.01435 (7.01715s)][2.16957 (17.7583s)][[*1] (32.2572s)][[*1] (76.6459s)][[*1] (201.791s)]]
[[cpp_int(fixed)][3.65486 (0.621889s)][1.78424 (1.35865s)][2.02664 (3.28597s)][1.95328 (6.8044s)]]
[[gmp_int][[*1] (0.170154s)][[*1] (0.761472s)][[*1] (1.62139s)][[*1] (3.48358s)][[*1] (8.18516s)][[*1] (18.7879s)][1.82325 (58.8129s)][1.59356 (122.14s)]]
[[tommath_int][8.01966 (1.36458s)][4.44226 (3.38266s)][4.55056 (7.37824s)][4.42983 (15.4317s)][5.23788 (42.8729s)][7.25799 (136.362s)][14.6265 (471.81s)][23.1025 (1770.72s)]]
]
[table Operator powm
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][14.8198 (0.565871s)][13.2096 (2.0199s)][11.8233 (9.06469s)][9.12533 (46.9932s)]]
[[cpp_int(fixed)][9.40069 (0.35895s)][10.0395 (1.53516s)][10.5353 (8.07714s)][8.49678 (43.7564s)]]
[[gmp_int][[*1] (0.0381833s)][[*1] (0.152912s)][[*1] (0.766677s)][[*1] (5.14976s)]]
[[tommath_int][11.0485 (0.421869s)][8.44037 (1.29063s)][4.18756 (3.21051s)][2.45216 (12.628s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][1.47697 (0.000264092s)][2.87174 (0.000644609s)][2.28911 (0.00141073s)][4.92453 (0.00383604s)][5.61647 (0.0137593s)][1.87264 (0.0491109s)][4.29909 (0.171316s)][[*1] (0.595522s)]]
[[cpp_int(fixed)][4.73326 (0.00084634s)][1.78742 (0.000401216s)][1.68455 (0.00103815s)][4.30889 (0.00335647s)]]
[[gmp_int][[*1] (0.000178807s)][[*1] (0.000224466s)][[*1] (0.00061628s)][[*1] (0.000778966s)][[*1] (0.00244981s)][[*1] (0.00486654s)][[*1] (0.0262254s)][[*1] (0.0398493s)]]
[[tommath_int][16.7304 (0.00299152s)][26.6015 (0.00597113s)][30.9815 (0.0190933s)][74.7467 (0.0582251s)][82.4773 (0.202054s)][154.996 (0.754295s)][107.534 (2.82013s)][279.178 (11.1251s)]]
]
[table Operator |
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.26845 (0.00991773s)][1.955 (0.00939722s)][2.01122 (0.012635s)][1.76421 (0.0152013s)][1.92162 (0.0293243s)][[*1] (0.0377549s)][[*1] (0.0916779s)][[*1] (0.152323s)]]
[[cpp_int(fixed)][1.00452 (0.0043918s)][1.37689 (0.00661838s)][1.3138 (0.00825362s)][1.71906 (0.0148123s)]]
[[gmp_int][[*1] (0.00437203s)][[*1] (0.00480677s)][[*1] (0.00628228s)][[*1] (0.00861647s)][[*1] (0.0152602s)][1.09283 (0.0365187s)][2.43832 (0.0920584s)][1.21204 (0.111118s)]]
[[tommath_int][1.69103 (0.00739324s)][1.85402 (0.00891185s)][1.78526 (0.0112155s)][1.86487 (0.0160686s)][1.75184 (0.0267336s)][1.44011 (0.0481236s)][2.33195 (0.0880424s)][2.33204 (0.213797s)]]
]
[table Operator |(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.11741 (0.00805945s)][2.16753 (0.0119795s)][1.5717 (0.012189s)][1.10016 (0.0134288s)][1.11289 (0.0309032s)][[*1] (0.0232284s)][[*1] (0.042441s)][[*1] (0.0711061s)]]
[[cpp_int(fixed)][[*1] (0.00380628s)][[*1] (0.00552682s)][[*1] (0.00775532s)][[*1] (0.0122062s)]]
[[gmp_int][2.62934 (0.010008s)][1.86878 (0.0103284s)][3.19589 (0.0247852s)][1.1073 (0.0135159s)][[*1] (0.0277685s)][1.67609 (0.0360071s)][3.76493 (0.0874534s)][2.72382 (0.115602s)]]
[[tommath_int][22.0502 (0.0839291s)][18.6272 (0.102949s)][9.99323 (0.0775007s)][6.28905 (0.0767652s)][3.28821 (0.0913086s)][5.0968 (0.109494s)][6.47865 (0.150489s)][4.8474 (0.205729s)]]
]

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_integer_real_world.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:int_real_world Integer Real World Tests]

The first set of [@../../performance/voronoi_performance.cpp tests] measure the times taken to
execute the multiprecision part of the Voronoi-diagram builder from Boost.Polygon.  The tests
mainly create a large number of temporaries "just in case" multiprecision arithmetic is required,
for comparison, also included in the tests is Boost.Polygon's own partial-multiprecision integer
type which was custom written for this specific task:

[table
[[Integer Type][Relative Performance (Actual time in parenthesis)]]
[[checked_int1024_t][1.53714(0.0415328s)]]
[[checked_int256_t][1.20715(0.0326167s)]]
[[checked_int512_t][1.2587(0.0340095s)]]
[[cpp_int][1.80575(0.0487904s)]]
[[extended_int][1.35652(0.0366527s)]]
[[int1024_t][1.36237(0.0368107s)]]
[[int256_t][1(0.0270196s)]]
[[int512_t][1.0779(0.0291243s)]]
[[mpz_int][3.83495(0.103619s)]]
[[tom_int][41.6378(1.12504s)]]
]

Note how for this use case, any dynamic allocation is a performance killer.

The next [@../../performance/miller_rabin_performance.cpp tests] measure the time taken to generate 1000 128-bit
random numbers and test for primality using the Miller Rabin test.  This is primarily a test of modular-exponentiation
since that is the rate limiting step:

[table
[[Integer Type][Relative Performance (Actual time in parenthesis)]]
[[checked_uint1024_t][9.52301(0.0422246s)]]
[[cpp_int][11.2194(0.0497465s)]]
[[cpp_int (1024-bit cache)][10.7941(0.0478607s)]]
[[cpp_int (128-bit cache)][11.0637(0.0490558s)]]
[[cpp_int (256-bit cache)][11.5069(0.0510209s)]]
[[cpp_int (512-bit cache)][10.3303(0.0458041s)]]
[[cpp_int (no Expression templates)][16.1792(0.0717379s)]]
[[mpz_int][1.05106(0.00466034s)]]
[[mpz_int (no Expression templates)][1(0.00443395s)]]
[[tom_int][5.10595(0.0226395s)]]
[[tom_int (no Expression templates)][61.9684(0.274765s)]]
[[uint1024_t][9.32113(0.0413295s)]]
]

It's interesting to note that expression templates have little effect here - perhaps because the actual expressions involved
are relatively trivial in this case - so the time taken for multiplication and division tends to dominate.  The much 
quicker times from GMP and tommath are down to their
much better modular-exponentiation algorithms (GMP's is about 5x faster).  That's an issue which needs to be addressed
in a future release for __cpp_int.

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_overhead.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:overhead The Overhead in the Number Class Wrapper]

Using a simple [@../../performance/arithmetic_backend.hpp backend class] that wraps any __fundamental arithmetic type
we can measure the overhead involved in wrapping a type inside the `number` frontend, and the effect that turning
on expression templates has.  The following table compares the performance between `double` and a `double` wrapped
inside class `number`:

[table Bessel Functions (16 digit precision)
[[Type][Time]]
[[arithmetic_backend<double>][2.09301 (0.00133409s)]]
[[arithmetic_backend<double> - no expression templates][1 (0.000637403s)]]
[[double][1.07956 (0.000688113s)]]
]

As you can see whether or not there is an overhead, and how large it is depends on the actual situation,
but the overhead is in any cases small.  Expression templates generally add a greater overhead the
more complex the expression becomes due to the logic of figuring out how to best unpack and evaluate
the expression, but of course this is also the situation where you save more temporaries.  For a
"trivial" backend like this, saving temporaries has no benefit, but for larger types it becomes
a bigger win.

The following table compares arithmetic using either `long long` or `number<arithmetic_backend<long long> >`
for the [@../../performance/voronoi_performance.cpp voronoi-diagram builder test]:

[table
[[Type][Relative time]]
[[`int64_t`][[*1.0](0.0128646s)]]
[[`number<arithmetic_backend<int64_t>, et_off>`][1.005 (0.0129255s)]]
]

This test involves mainly creating a lot of temporaries and performing a small amount of arithmetic on them,
with very little difference in performance between the native and "wrapped" types.

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:rational_performance Rational Type Performance]

Note that these tests are carefully designed to test performance of the underlying algorithms
and not memory allocation or variable copying.  As usual, performance results should be taken
with a healthy dose of scepticism, and real-world performance may vary widely depending upon the
specifics of the program.  In each table relative times are given first, with the best performer
given a score of 1.  Total actual times are given in brackets, measured in seconds for 500000
operations.

[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.00025 (0.797425s)][1.97726 (2.96998s)][1.86844 (6.73224s)][1.96608 (14.4259s)]]
[[mpq_rational][[*1] (0.398662s)][[*1] (1.50207s)][[*1] (3.60314s)][[*1] (7.3374s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.88073 (0.0637195s)][1.93184 (0.0917847s)][2.15609 (0.118274s)][2.4236 (0.218283s)]]
[[mpq_rational][[*1] (0.0338803s)][[*1] (0.0475114s)][[*1] (0.0548556s)][[*1] (0.0900656s)]]
]
[table Operator *(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.60877 (0.161844s)][2.33429 (0.240069s)][1.8835 (0.298935s)][2.70338 (0.448194s)]]
[[mpq_rational][[*1] (0.100601s)][[*1] (0.102844s)][[*1] (0.158713s)][[*1] (0.16579s)]]
]
[table Operator *(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.97503 (0.408791s)][2.42069 (0.600225s)][2.65138 (0.803009s)][4.65673 (1.54645s)]]
[[mpq_rational][[*1] (0.20698s)][[*1] (0.247956s)][[*1] (0.302865s)][[*1] (0.332089s)]]
]
[table Operator *=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.97207 (0.211848s)][2.18482 (0.226179s)][2.43682 (0.319695s)][2.69933 (0.485819s)]]
[[mpq_rational][[*1] (0.107424s)][[*1] (0.103523s)][[*1] (0.131194s)][[*1] (0.179978s)]]
]
[table Operator *=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.95211 (0.40255s)][2.60942 (0.629302s)][2.83854 (0.8029s)][4.34054 (1.37083s)]]
[[mpq_rational][[*1] (0.206213s)][[*1] (0.241165s)][[*1] (0.282857s)][[*1] (0.31582s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.20364 (0.415006s)][1.97574 (1.53458s)][1.75945 (3.41194s)][2.11634 (8.04044s)]]
[[mpq_rational][[*1] (0.188327s)][[*1] (0.776716s)][[*1] (1.93921s)][[*1] (3.79923s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.06836 (0.0177811s)][1.80334 (0.0183744s)][1.38442 (0.020452s)][1.81894 (0.0449351s)]]
[[mpq_rational][[*1] (0.00859669s)][[*1] (0.0101891s)][[*1] (0.014773s)][[*1] (0.024704s)]]
]
[table Operator +(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.07187 (0.0177151s)][2.3005 (0.0241089s)][1.81397 (0.0297836s)][1.72202 (0.046594s)]]
[[mpq_rational][[*1] (0.0085503s)][[*1] (0.0104799s)][[*1] (0.016419s)][[*1] (0.0270577s)]]
]
[table Operator +(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.2805 (0.0265647s)][1.59353 (0.0391054s)][1.26613 (0.044067s)][1.95307 (0.105801s)]]
[[mpq_rational][[*1] (0.0207456s)][[*1] (0.0245401s)][[*1] (0.0348044s)][[*1] (0.0541719s)]]
]
[table Operator +=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.29749 (0.0565983s)][3.77253 (0.0371419s)][2.72128 (0.0556987s)][2.01495 (0.0662456s)]]
[[mpq_rational][[*1] (0.00775585s)][[*1] (0.00984535s)][[*1] (0.0204678s)][[*1] (0.032877s)]]
]
[table Operator +=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.92025 (0.0335896s)][2.08321 (0.0422867s)][1.587 (0.0564267s)][1.85357 (0.0840696s)]]
[[mpq_rational][[*1] (0.0174923s)][[*1] (0.0202988s)][[*1] (0.0355556s)][[*1] (0.0453556s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.38126 (0.471759s)][1.92631 (1.52484s)][1.76181 (3.49648s)][2.03462 (7.71926s)]]
[[mpq_rational][[*1] (0.198113s)][[*1] (0.791584s)][[*1] (1.98459s)][[*1] (3.79396s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.44447 (0.0292894s)][2.54602 (0.0346718s)][1.4869 (0.035503s)][1.95344 (0.0577029s)]]
[[mpq_rational][[*1] (0.0119819s)][[*1] (0.013618s)][[*1] (0.0238773s)][[*1] (0.0295391s)]]
]
[table Operator -(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.93654 (0.0296698s)][4.23087 (0.0496956s)][1.68041 (0.0461985s)][1.4455 (0.0581714s)]]
[[mpq_rational][[*1] (0.0101037s)][[*1] (0.0117459s)][[*1] (0.0274924s)][[*1] (0.040243s)]]
]
[table Operator -(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.69242 (0.0408789s)][1.5205 (0.0467416s)][1.31525 (0.0548939s)][2.16115 (0.103471s)]]
[[mpq_rational][[*1] (0.0241541s)][[*1] (0.030741s)][[*1] (0.0417365s)][[*1] (0.0478777s)]]
]
[table Operator -=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][3.69509 (0.0366534s)][3.7306 (0.0439181s)][1.8352 (0.0491612s)][1.86662 (0.071761s)]]
[[mpq_rational][[*1] (0.00991947s)][[*1] (0.0117724s)][[*1] (0.0267879s)][[*1] (0.0384444s)]]
]
[table Operator -=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.76299 (0.0421283s)][2.03803 (0.0490152s)][1.84864 (0.053198s)][2.10533 (0.0881228s)]]
[[mpq_rational][[*1] (0.023896s)][[*1] (0.0240502s)][[*1] (0.0287769s)][[*1] (0.041857s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.03433 (2.28881s)][2.24309 (6.34454s)][2.1203 (13.2036s)][2.36142 (29.3236s)]]
[[mpq_rational][[*1] (1.12509s)][[*1] (2.82848s)][[*1] (6.22726s)][[*1] (12.4178s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.035134s)][1.08556 (0.0774619s)][1.08797 (0.104628s)][1.29134 (0.207067s)]]
[[mpq_rational][1.85049 (0.0650149s)][[*1] (0.0713565s)][[*1] (0.0961679s)][[*1] (0.16035s)]]
]
[table Operator /(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.31397 (0.170727s)][1.63747 (0.216019s)][1.68581 (0.292536s)][1.76695 (0.435259s)]]
[[mpq_rational][[*1] (0.129932s)][[*1] (0.131923s)][[*1] (0.173528s)][[*1] (0.246334s)]]
]
[table Operator /(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.82473 (0.431612s)][2.20261 (0.596248s)][2.45848 (0.809662s)][3.88675 (1.38001s)]]
[[mpq_rational][[*1] (0.236534s)][[*1] (0.270701s)][[*1] (0.329335s)][[*1] (0.355055s)]]
]
[table Operator /=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.58868 (0.216252s)][1.71288 (0.235781s)][1.78218 (0.314161s)][1.98715 (0.460033s)]]
[[mpq_rational][[*1] (0.136121s)][[*1] (0.137652s)][[*1] (0.176279s)][[*1] (0.231505s)]]
]
[table Operator /=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.72896 (0.40369s)][2.55949 (0.689514s)][2.4929 (0.832288s)][3.51238 (1.37478s)]]
[[mpq_rational][[*1] (0.233487s)][[*1] (0.269395s)][[*1] (0.333863s)][[*1] (0.391409s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.0135822s)][[*1] (0.00935293s)][[*1] (0.0083784s)][[*1] (0.00962697s)]]
[[mpq_rational][1.44264 (0.0195942s)][2.18249 (0.0204126s)][2.64725 (0.0221797s)][2.87767 (0.0277033s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.00806026s)][[*1] (0.00960336s)][[*1] (0.00769898s)][[*1] (0.0176689s)]]
[[mpq_rational][4.87225 (0.0392716s)][5.91987 (0.0568506s)][9.03811 (0.0695842s)][3.68339 (0.0650815s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.00672081s)][[*1] (0.0064826s)][[*1] (0.00618635s)][[*1] (0.00923644s)]]
[[mpq_rational][6.47138 (0.0434929s)][7.48645 (0.0485316s)][8.2942 (0.0513108s)][5.77363 (0.0533278s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][6.17439 (0.00168424s)][7.6748 (0.0033367s)][6.38435 (0.00662873s)][9.07696 (0.0174979s)]]
[[mpq_rational][[*1] (0.000272779s)][[*1] (0.000434761s)][[*1] (0.00103828s)][[*1] (0.00192772s)]]
]

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_rational_real_world.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:rational_real_world Rational Real World Tests]

The first set of [@../../performance/rational_bernoulli_bench.cpp tests] measure the times taken to
calculate the n'th Bernoulli number via mixed rational/integer arithmetic to give an exact rational result.

[table Relative times taken to calculate Bm
[[m][cpp_rational (time in seconds)][mpq_rational (time relative to cpp_rational)][mpq_class (time relative to cpp_rational)]]
[[50][1.888453][1.7317576874][1.893438174]]
[[54][2.250503][2.1519411438][2.4936252029]]
[[58][2.734527][2.2056805437][1.9866752093]]
[[62][3.318122][2.5182796172][2.2662876772]]
[[66][3.887281][2.4263077457][2.588347485]]
[[70][4.628535][1.9756346231][2.5367158291]]
[[74][5.3541][1.7052929531][2.3345854579]]
[[78][6.321172][1.6669601776][2.0390342171]]
[[82][7.13052][1.7689101216][1.9837833706]]
[[86][8.390095][1.6245518078][1.5785492298]]
[[90][10.62176][1.6294440846][1.5779053566]]
[[94][11.364409][1.5786845581][1.5614997665]]
[[98][14.030636][1.2616490799][1.4799734666]]
[[102][15.268211][1.6145657798][1.6128342738]]
[[106][15.253028][1.8985381788][1.8206293859]]
[[110][17.637756][1.8283953469][1.6559522084]]
[[114][18.335007][1.8018346543][1.8343225612]]
[[118][21.044146][2.0462015897][1.8106934346]]
[[122][23.71295][2.0041556196][1.7127701108]]
[[126][25.993901][1.9901613075][1.6974264848]]
[[130][30.17278][1.8897211328][1.6405006433]]
[[134][43.992333][1.2223514038][1.2232961594]]
[[138][40.702777][1.3551305848][1.492072224]]
[[142][47.01495][1.4361410785][1.4005683724]]
[[146][51.468592][1.4279172043][1.4072223891]]
[[150][70.736106][1.3628087048][1.2309294917]]
[[154][74.638691][1.2509392749][1.2846060497]]
[[158][76.642396][1.3383691449][1.2555573941]]
[[162][104.906795][1.1722665057][1.0121124375]]
[[166][108.175914][0.9272805682][1.2472813403]]
[[170][125.363885][0.8114005082][1.1349673712]]
[[174][119.813754][0.9747547014][1.5677900135]]
[[178][130.672631][0.904429444][1.6089208382]]
[[182][136.002124][0.8359445107][1.3173987636]]
[[186][152.169271][0.7919228515][1.3523570012]]
[[190][149.444035][0.8353259734][1.4571606823]]
[[194][149.609183][0.8898088896][1.6132629038]]
[[198][167.594528][0.8947434429][1.326461858]]
]

In this use case, most the of the rational numbers are fairly small and so the times taken are dominated by
the number of allocations performed.  The following table illustrates how well each type performs on suppressing
allocations:

[table Total Allocation Counts for Bernoulli Number Calculation
[[m][cpp_rational][mpq_rational][mpq_class]]
[[2][0][77][101]]
[[4][0][187][252]]
[[6][0][345][471]]
[[8][0][551][758]]
[[10][0][805][1113]]
[[12][0][1107][1536]]
[[14][0][1457][2027]]
[[16][0][1857][2587]]
[[18][0][2336][3216]]
[[20][0][2885][3913]]
[[22][6][3511][4706]]
[[24][22][4203][5600]]
[[26][83][4963][6575]]
[[28][377][5806][7632]]
[[30][780][6738][8769]]
[[32][1454][7771][9988]]
[[34][2001][9357][11289]]
[[36][2789][10598][12704]]
[[38][3669][11948][14252]]
[[40][4653][13403][15891]]
[[42][5923][14976][17620]]
[[44][7379][16622][19449]]
[[46][8839][18367][21367]]
[[48][10296][20227][23431]]
[[50][12045][22857][25646]]
[[52][13603][25044][27962]]
[[54][15276][27331][30389]]
[[56][17239][29749][32919]]
[[58][19337][32257][35552]]
[[60][21409][34958][38417]]
[[62][23694][37800][41396]]
[[64][27923][39556][44498]]
[[66][30240][44706][47711]]
[[68][32566][47934][51042]]
[[70][35019][51417][54637]]
[[72][37460][55047][58363]]
[[74][40282][58777][62211]]
[[76][42914][62691][66183]]
[[78][45752][66694][70296]]
[[80][48681][70905][74620]]
[[82][51986][77633][79160]]
[[84][54855][82364][83842]]
[[86][59032][87239][88659]]
[[88][63595][92256][93618]]
[[90][68352][97486][98820]]
[[92][72446][102974][104256]]
[[94][76468][108620][109844]]
[[96][80361][111109][115594]]
[[98][84783][121460][121486]]
[[100][89044][127730][127633]]
[[102][93561][134241][134050]]
[[104][98452][140919][140616]]
[[106][103530][147763][147364]]
[[108][108326][154804][154276]]
[[110][113891][162184][161562]]
[[112][119213][169736][169038]]
[[114][124770][182417][176693]]
[[116][130624][190589][184519]]
[[118][137941][198975][192525]]
[[120][144829][207759][200952]]
[[122][152045][216736][209561]]
[[124][158610][225905][218371]]
[[126][165383][235283][227360]]
[[128][173971][230678][236670]]
[[130][181696][248593][246308]]
[[132][189310][258615][256148]]
[[134][197708][268800][266192]]
[[136][205800][279215][276436]]
[[138][212940][290112][287167]]
[[140][217502][301235][298101]]
[[142][223486][312564][309243]]
[[144][229579][324133][320605]]
[[146][237213][344671][332333]]
[[148][248799][357200][344420]]
[[150][261345][369947][356745]]
[[152][272741][382909][369279]]
[[154][283982][396162][382048]]
[[156][293626][409993][395353]]
[[158][304036][424022][408907]]
[[160][313869][427747][422690]]
[[162][323626][454723][436715]]
[[164][333294][469863][451304]]
[[166][343072][485238][466149]]
[[168][352236][500922][481221]]
[[170][362793][516840][496561]]
[[172][372645][533169][512315]]
[[174][382908][549962][528510]]
[[176][392507][567018][544947]]
[[178][404163][597694][561666]]
[[180][417539][615615][578647]]
[[182][432009][634079][596234]]
[[184][444684][652902][614114]]
[[186][457104][672042][632248]]
[[188][469331][691451][650654]]
[[190][481583][711512][669753]]
[[192][477225][698188][689111]]
[[194][488955][736905][708760]]
[[196][499797][757502][728675]]
[[198][511163][778591][749102]]
]

The second [@../../performance/rational_determinant_bench.cpp example] measures the time taken to calculate the determinant of a 3x3 matrix of rational
numbers.  These numbers are randomly generated with /n/ bits in both numerator and denominator.  In this case the rate limiting step is the cost of
calculating the GCD's during the computation:


[table Relative Time Taken to Calculate 100 Determinants of Random 3x3 Matrixes
[[Bits][cpp_rational (ms)][mpq_rational (relative to cpp_rational)][mpq_class (relative to cpp_rational)]]
[[512][45][0.3111111111][0.3177777778]]
[[1024][103][0.3038834951][0.3038834951]]
[[2048][251][0.3087649402][0.3011952191]]
[[4096][667][0.2983508246][0.2893553223]]
[[8192][2033][0.261682243][0.2956222332]]
[[16384][6423][0.2358710883][0.3059318076]]
[[32768][24223][0.1875903067][0.1955992239]]
]

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/performance_real_world.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:realworld Floating-Point Real World Tests]

These tests test the total time taken to execute all of Boost.Math's test cases for these functions.
In each case the best performing library gets a relative score of 1, with the total execution time
given in brackets.  Times are shown for both single threaded runs and concurrent execution - the latter
increases contension inside new/delete.

[table Bessel Functions (50 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_50][2.24409 (0.207745s)][399]]
[[cpp_bin_float_50 (3 concurrent threads)][2.87977 (0.266594s)][463]]
[[cpp_dec_float_50][4.56157 (0.422285s)][381]]
[[cpp_dec_float_50 (3 concurrent threads)][5.66114 (0.524077s)][424]]
[[mpf_float_50][1.03648 (0.0959515s)][640961]]
[[mpf_float_50 (3 concurrent threads)][1.50439 (0.139268s)][2563517]]
[[mpf_float_50 (no expression templates][1 (0.0925745s)][1019039]]
[[mpf_float_50 (no expression templates (3 concurrent threads)][1.52451 (0.141131s)][4075842]]
[[mpfr_float_50][1.2513 (0.115838s)][583054]]
[[mpfr_float_50 (3 concurrent threads)][1.61301 (0.149324s)][2330876]]
[[mpfr_float_50 (no expression templates][1.42667 (0.132073s)][999594]]
[[mpfr_float_50 (no expression templates (3 concurrent threads)][2.00203 (0.185337s)][4000039]]
[[static_mpfr_float_50][1.18358 (0.10957s)][22930]]
[[static_mpfr_float_50 (3 concurrent threads)][1.38802 (0.128496s)][93140]]
[[static_mpfr_float_50 (no expression templates)][1.14598 (0.106089s)][46861]]
[[static_mpfr_float_50 (no expression templates) (3 concurrent threads)][1.24535 (0.115288s)][189227]]
]

[table Non-central T Distribution (50 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_50][2.38959 (38.5842s)][0]]
[[cpp_bin_float_50 (3 concurrent threads)][3.50535 (56.6s)][28]]
[[cpp_dec_float_50][4.82763 (77.9505s)][0]]
[[mpf_float_50][1.06817 (17.2475s)][123749688]]
[[mpf_float_50 (no expression templates][1 (16.1468s)][152610085]]
[[mpfr_float_50][1.18754 (19.1749s)][118401290]]
[[mpfr_float_50 (no expression templates][1.36782 (22.0858s)][152816346]]
[[static_mpfr_float_50][1.04471 (16.8686s)][113395]]
]

[table:platform Platform Details
[[][Version]]
[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:ref Reference]

[include reference_number.qbk]
[include reference_cpp_int.qbk]
[include reference_gmp_int.qbk]
[include reference_tom_int.qbk]
[include reference_gmp_float.qbk]
[include reference_mpfr_float.qbk]
[include reference_cpp_bin_float.qbk]
[include reference_cpp_dec_float.qbk]
[include reference_internal_support.qbk]
[include reference_backend_requirements.qbk]
[include reference_header_structure.qbk]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_backend_requirements.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:backendconc Backend Requirements]

The requirements on the `Backend` template argument to `number` are split up into
sections: compulsory and optional.

Compulsory requirements have no default implementation in the library, therefore if the feature
they implement is to be supported at all, then they must be implemented by the backend.

Optional requirements have default implementations that are called if the backend doesn't provide
its own.  Typically the backend will implement these to improve performance.

In the following tables, type B is the `Backend` template argument to `number`, `b` and `b2` are
a variables of type B, `pb` is a variable of type B*, `cb`, `cb2` and `cb3` are constant variables of type `const B`,
`rb` is a variable of type `B&&`, `a` and `a2` are variables of Arithmetic type,
`s` is a variable of type `const char*`, `ui` is a variable of type `unsigned`, `bb` is a variable of type `bool`,
`pa` is a variable of type pointer-to-arithmetic-type, `exp` is a variable of type `B::exp_type`,
`pexp` is a variable of type `B::exp_type*`, `i` is a variable of type `int`, `pi` pointer to a variable of type `int`,
B2 is another type that meets these requirements, b2 is a variable of type B2, `ss` is variable of type `std::streamsize`
and `ff` is a variable of type `std::ios_base::fmtflags`.

[table Compulsory Requirements on the Backend type.
[[Expression][Return Type][Comments][Throws]]
[[`B::signed_types`][`std::tuple<type-list>`][A list of signed integral types that can be assigned to type B.  The types shall be
                   listed in order of size, smallest first, and shall terminate in the type that is `std::intmax_t`.][[space]]]
[[`B::unsigned_types`][`std::tuple<type-list>`][A list of unsigned integral types that can be assigned to type B.  The types shall be
                   listed in order of size, smallest first, and shall terminate in the type that is `std::uintmax_t`.][[space]]]
[[`B::float_types`][`std::tuple<type-list>`][A list of floating-point types that can be assigned to type B.The types shall be
                   listed in order of size, smallest first, and shall terminate in type `long double`.][[space]]]
[[`B::exponent_type`][A signed integral type.][The type of the exponent of type B.  This type is required only for floating-point types.][[space]]]
[[`B()`][ ][Default constructor.][[space]]]
[[`B(cb)`][ ][Copy Constructor.][[space]]]
[[`b = b`][`B&`][Assignment operator.][[space]]]
[[`b = a`][`B&`][Assignment from an Arithmetic type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
[[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpreted as a valid number.]]
[[`b.swap(b)`][`void`][Swaps the contents of its arguments.][`noexcept`]]
[[`cb.str(ss, ff)`][`std::string`][Returns the string representation of `b` with `ss` digits and formatted according to the flags set in `ff`.
                  If `ss` is zero, then returns as many digits as are required to reconstruct the original value.][[space]]]
[[`b.negate()`][`void`][Negates `b`.][[space]]]
[[`cb.compare(cb2)`][`int`][Compares `cb` and `cb2`, returns a value less than zero if `cb < cb2`, a value greater than zero if `cb > cb2` and zero
                   if `cb == cb2`.][`noexcept`]]
[[`cb.compare(a)`][`int`][Compares `cb` and `a`, returns a value less than zero if `cb < a`, a value greater than zero if `cb > a` and zero
                   if `cb == a`.  The type of `a` shall be listed in one of the type lists
                   `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
[[`eval_add(b, cb)`][`void`][Adds `cb` to `b`.][[space]]]
[[`eval_subtract(b, cb)`][`void`][Subtracts `cb` from `b`.][[space]]]
[[`eval_multiply(b, cb)`][`void`][Multiplies `b` by `cb`.][[space]]]
[[`eval_divide(b, cb)`][`void`][Divides `b` by `cb`.]
            [`std::overflow_error` if cb has the value zero, and `std::numeric_limits<number<B> >::has_infinity == false`]]
[[`eval_modulus(b, cb)`][`void`][Computes `b %= cb`, only required when `B` is an integer type.]
            [`std::overflow_error` if cb has the value zero.]]
[[`eval_bitwise_and(b, cb)`][`void`][Computes `b &= cb`, only required when `B` is an integer type.][[space]]]
[[`eval_bitwise_or(b, cb)`][`void`][Computes `b |= cb`, only required when `B` is an integer type.][[space]]]
[[`eval_bitwise_xor(b, cb)`][`void`][Computes `b ^= cb`, only required when `B` is an integer type.][[space]]]
[[`eval_complement(b, cb)`][`void`][Computes the ones-complement of `cb` and stores the result in `b`, only required when `B` is an integer type.][[space]]]
[[`eval_left_shift(b, ui)`][`void`][Computes `b <<= ui`, only required when `B` is an integer type.][[space]]]
[[`eval_right_shift(b, ui)`][`void`][Computes `b >>= ui`, only required when `B` is an integer type.][[space]]]
[[`eval_convert_to(pa, cb)`][`void`][Converts `cb` to the type of `*pa` and store the result in `*pa`.  Type `B` shall support
                     conversion to at least types `std::intmax_t`, `std::uintmax_t` and `long long`.
                     Conversion to other arithmetic types can then be synthesised using other operations.
                     Conversions to other types are entirely optional.][[space]]]
[[`eval_frexp(b, cb, pexp)`][`void`][Stores values in `b` and `*pexp` such that the value of `cb` is b * 2[super *pexp], only required when `B` is a floating-point type.][[space]]]
[[`eval_ldexp(b, cb, exp)`][`void`][Stores a value in `b` that is cb * 2[super exp], only required when `B` is a floating-point type.][[space]]]
[[`eval_frexp(b, cb, pi)`][`void`][Stores values in `b` and `*pi` such that the value of `cb` is b * 2[super *pi], only required when `B` is a floating-point type.]
            [`std::runtime_error` if the exponent of cb is too large to be stored in an `int`.]]
[[`eval_ldexp(b, cb, i)`][`void`][Stores a value in `b` that is cb * 2[super i], only required when `B` is a floating-point type.][[space]]]
[[`eval_floor(b, cb)`][`void`][Stores the floor of `cb` in `b`, only required when `B` is a floating-point type.][[space]]]
[[`eval_ceil(b, cb)`][`void`][Stores the ceiling of `cb` in `b`, only required when `B` is a floating-point type.][[space]]]
[[`eval_sqrt(b, cb)`][`void`][Stores the square root of `cb` in `b`, only required when `B` is a floating-point type.][[space]]]
[[`boost::multiprecision::number_category<B>::type`][`std::integral_constant<int, N>`][`N` is one of the values `number_kind_integer`, `number_kind_floating_point`, `number_kind_complex`, `number_kind_rational` or `number_kind_fixed_point`.
                                                Defaults to `number_kind_floating_point`.][[space]]]
[[`eval_conj(b, cb)`][`void`][Sets `b` to the complex conjugate of `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
[[`eval_proj(b, cb)`][`void`][Sets `b` to the Riemann projection of `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
[[`eval_real(b, cb)`][`void`][Sets `b` to the real part of `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
[[`eval_imag(b, cb)`][`void`][Sets `b` to the imaginary of `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
[[`eval_set_real(b, a)`][`void`][Sets the real part of `b` to `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
[[`eval_set_imag(b, a)`][`void`][Sets the imaginary part of `b` to `cb`.  Required for complex types only - other types have a sensible default.][[space]]]
]

[table Optional Requirements on the Backend Type
[[Expression][Returns][Comments][Throws]]

[[['Construct and assign:]]]
[[`B(rb)`][`B`][Move constructor.  Afterwards variable `rb` shall be in sane state, albeit with unspecified value.
      Only destruction and assignment to the moved-from variable `rb` need be supported after the operation.][`noexcept`]]
[[`b = rb`][`B&`][Move-assign.  Afterwards variable `rb` shall be in sane state, albeit with unspecified value.
      Only destruction and assignment to the moved-from variable `rb` need be supported after the operation.][`noexcept`]]
[[`B(a)`][`B`][Direct construction from an arithmetic type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, this operation is simulated using default-construction followed by assignment.][[space]]]
[[`B(b2)`][`B`][Copy constructor from a different back-end type.  When not provided, a generic interconversion routine is used.
          This constructor may be `explicit` if the corresponding frontend constructor should also be `explicit`.][[space]]]
[[`b = b2`][`b&`][Assignment operator from a different back-end type.  When not provided, a generic interconversion routine is used.][[space]]]
[[`assign_components(b, a, a)`][`void`][Assigns to `b` the two components in the following arguments.
                           Only applies to rational and complex number types.
                           When not provided, arithmetic operations are used to synthesise the result from the two values.][[space]]]
[[`assign_components(b, b2, b2)`][`void`][Assigns to `b` the two components in the following arguments.
                           Only applies to rational and complex number types.
                           When not provided, arithmetic operations are used to synthesise the result from the two values.][[space]]]

[[['Comparisons:]]]
[[`eval_eq(cb, cb2)`][`bool`][Returns `true` if `cb` and `cb2` are equal in value.
            When not provided, the default implementation returns `cb.compare(cb2) == 0`.][`noexcept`]]
[[`eval_eq(cb, a)`][`bool`][Returns `true` if `cb` and `a` are equal in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, return the equivalent of `eval_eq(cb, B(a))`.][[space]]]
[[`eval_eq(a, cb)`][`bool`][Returns `true` if `cb` and `a` are equal in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version returns `eval_eq(cb, a)`.][[space]]]
[[`eval_lt(cb, cb2)`][`bool`][Returns `true` if `cb` is less than `cb2` in value.
            When not provided, the default implementation returns `cb.compare(cb2) < 0`.][`noexcept`]]
[[`eval_lt(cb, a)`][`bool`][Returns `true` if `cb` is less than `a` in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default implementation returns `eval_lt(cb, B(a))`.][[space]]]
[[`eval_lt(a, cb)`][`bool`][Returns `true` if `a` is less than `cb` in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default implementation returns `eval_gt(cb, a)`.][[space]]]
[[`eval_gt(cb, cb2)`][`bool`][Returns `true` if `cb` is greater than `cb2` in value.
            When not provided, the default implementation returns `cb.compare(cb2) > 0`.][`noexcept`]]
[[`eval_gt(cb, a)`][`bool`][Returns `true` if `cb` is greater than `a` in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default implementation returns `eval_gt(cb, B(a))`.][[space]]]
[[`eval_gt(a, cb)`][`bool`][Returns `true` if `a` is greater than `cb` in value.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default implementation returns `eval_lt(cb, a)`.][[space]]]
[[`eval_is_zero(cb)`][`bool`][Returns `true` if `cb` is zero, otherwise `false`.  The default version of this function
            returns `cb.compare(ui_type(0)) == 0`, where `ui_type` is `ui_type` is
            `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]]
[[`eval_get_sign(cb)`][`int`][Returns a value < zero if `cb` is negative, a value > zero if `cb` is positive, and zero if `cb` is zero.
            The default version of this function
            returns `cb.compare(ui_type(0))`, where `ui_type` is `ui_type` is
            `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]]

[[['Basic arithmetic:]]]
[[`eval_add(b, a)`][`void`][Adds `a` to `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_add(b, B(a))`][[space]]]
[[`eval_add(b, cb, cb2)`][`void`][Add `cb` to `cb2` and stores the result in `b`.
            When not provided, does the equivalent of `b = cb; eval_add(b, cb2)`.][[space]]]
[[`eval_add(b, cb, a)`][`void`][Add `cb` to `a` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_add(b, cb, B(a))`.][[space]]]
[[`eval_add(b, a, cb)`][`void`][Add `a` to `cb` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_add(b, cb, a)`.][[space]]]
[[`eval_subtract(b, a)`][`void`][Subtracts `a` from `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_subtract(b, B(a))`][[space]]]
[[`eval_subtract(b, cb, cb2)`][`void`][Subtracts `cb2` from `cb` and stores the result in `b`.
            When not provided, does the equivalent of `b = cb; eval_subtract(b, cb2)`.][[space]]]
[[`eval_subtract(b, cb, a)`][`void`][Subtracts `a` from `cb` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_subtract(b, cb, B(a))`.][[space]]]
[[`eval_subtract(b, a, cb)`][`void`][Subtracts `cb` from `a` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_subtract(b, cb, a); b.negate();`.][[space]]]
[[`eval_multiply(b, a)`][`void`][Multiplies `b` by `a`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_multiply(b, B(a))`][[space]]]
[[`eval_multiply(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and stores the result in `b`.
            When not provided, does the equivalent of `b = cb; eval_multiply(b, cb2)`.][[space]]]
[[`eval_multiply(b, cb, a)`][`void`][Multiplies `cb` by `a` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_multiply(b, cb, B(a))`.][[space]]]
[[`eval_multiply(b, a, cb)`][`void`][Multiplies `a` by `cb` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_multiply(b, cb, a)`.][[space]]]
[[`eval_multiply_add(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and adds the result to `b`.
            When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, cb2)` followed by
            `eval_add(b, t)`.][[space]]]
[[`eval_multiply_add(b, cb, a)`][`void`][Multiplies `a` by `cb` and adds the result to `b`.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, a)` followed by
            `eval_add(b, t)`.][[space]]]
[[`eval_multiply_add(b, a, cb)`][`void`][Multiplies `a` by `cb` and adds the result to `b`.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided does the equivalent of  `eval_multiply_add(b, cb, a)`.][[space]]]
[[`eval_multiply_subtract(b, cb, cb2)`][`void`][Multiplies `cb` by `cb2` and subtracts the result from `b`.
            When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, cb2)` followed by
            `eval_subtract(b, t)`.][[space]]]
[[`eval_multiply_subtract(b, cb, a)`][`void`][Multiplies `a` by `cb` and subtracts the result from `b`.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided does the equivalent of creating a temporary `B t` and `eval_multiply(t, cb, a)` followed by
            `eval_subtract(b, t)`.][[space]]]
[[`eval_multiply_subtract(b, a, cb)`][`void`][Multiplies `a` by `cb` and subtracts the result from `b`.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided does the equivalent of  `eval_multiply_subtract(b, cb, a)`.][[space]]]
[[`eval_multiply_add(b, cb, cb2, cb3)`][`void`][Multiplies `cb` by `cb2` and adds the result to `cb3` storing the result in `b`.
            When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by
            `eval_add(b, cb3)`.
            For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of
            `cb`, `cb2` and `cb3` with any type listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
[[`eval_multiply_subtract(b, cb, cb2, cb3)`][`void`][Multiplies `cb` by `cb2` and subtracts from the result `cb3` storing the result in `b`.
            When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by
            `eval_subtract(b, cb3)`.
            For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of
            `cb`, `cb2` and `cb3` with any type listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
[[`eval_divide(b, a)`][`void`][Divides `b` by `a`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_divide(b, B(a))`]
            [`std::overflow_error` if `a` has the value zero, and `std::numeric_limits<number<B> >::has_infinity == false`]]
[[`eval_divide(b, cb, cb2)`][`void`][Divides `cb` by `cb2` and stores the result in `b`.
            When not provided, does the equivalent of `b = cb; eval_divide(b, cb2)`.]
            [`std::overflow_error` if `cb2` has the value zero, and `std::numeric_limits<number<B> >::has_infinity == false`]]
[[`eval_divide(b, cb, a)`][`void`][Divides `cb` by `a` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_divide(b, cb, B(a))`.]
            [`std::overflow_error` if `a` has the value zero, and `std::numeric_limits<number<B> >::has_infinity == false`]]
[[`eval_divide(b, a, cb)`][`void`][Divides `a` by `cb` and stores the result in `b`.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_divide(b, B(a), cb)`.]
            [`std::overflow_error` if cb has the value zero, and `std::numeric_limits<number<B> >::has_infinity == false`]]
[[`eval_increment(b)`][void][Increments the value of `b` by one.
            When not provided, does the equivalent of `eval_add(b, static_cast<ui_type>(1u))`.
            Where `ui_type` is `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]]
[[`eval_decrement(b)`][void][Decrements the value of `b` by one.
            When not provided, does the equivalent of `eval_subtract(b, static_cast<ui_type>(1u))`.
            Where `ui_type` is `typename std::tuple_element<0, typename B::unsigned_types>::type`.][[space]]]

[[['Integer specific operations:]]]
[[`eval_modulus(b, a)`][`void`][Computes `b %= cb`, only required when `B` is an integer type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_modulus(b, B(a))`]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_modulus(b, cb, cb2)`][`void`][Computes `cb % cb2` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_modulus(b, cb2)`.]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_modulus(b, cb, a)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_modulus(b, cb, B(a))`.]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_modulus(b, a, cb)`][`void`][Computes `cb % a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_modulus(b, B(a), cb)`.]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_bitwise_and(b, a)`][`void`][Computes `b &= cb`, only required when `B` is an integer type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_bitwise_and(b, B(a))`][[space]]]
[[`eval_bitwise_and(b, cb, cb2)`][`void`][Computes `cb & cb2` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_bitwise_and(b, cb2)`.][[space]]]
[[`eval_bitwise_and(b, cb, a)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_and(b, cb, B(a))`.][[space]]]
[[`eval_bitwise_and(b, a, cb)`][`void`][Computes `cb & a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_and(b, cb, a)`.][[space]]]
[[`eval_bitwise_or(b, a)`][`void`][Computes `b |= cb`, only required when `B` is an integer type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_bitwise_or(b, B(a))`][[space]]]
[[`eval_bitwise_or(b, cb, cb2)`][`void`][Computes `cb | cb2` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_bitwise_or(b, cb2)`.][[space]]]
[[`eval_bitwise_or(b, cb, a)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_or(b, cb, B(a))`.][[space]]]
[[`eval_bitwise_or(b, a, cb)`][`void`][Computes `cb | a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_or(b, cb, a)`.][[space]]]
[[`eval_bitwise_xor(b, a)`][`void`][Computes `b ^= cb`, only required when `B` is an integer type.  The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, the default version calls `eval_bitwise_xor(b, B(a))`][[space]]]
[[`eval_bitwise_xor(b, cb, cb2)`][`void`][Computes `cb ^ cb2` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_bitwise_xor(b, cb2)`.][[space]]]
[[`eval_bitwise_xor(b, cb, a)`][`void`][Computes `cb ^ a` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_xor(b, cb, B(a))`.][[space]]]
[[`eval_bitwise_xor(b, a, cb)`][`void`][Computes `a ^ cb` and stores the result in `b`, only required when `B` is an integer type. The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            When not provided, does the equivalent of `eval_bitwise_xor(b, cb, a)`.][[space]]]
[[`eval_left_shift(b, cb, ui)`][`void`][Computes `cb << ui` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_left_shift(b, a);`.][[space]]]
[[`eval_right_shift(b, cb, ui)`][`void`][Computes `cb >> ui` and stores the result in `b`, only required when `B` is an integer type.
            When not provided, does the equivalent of `b = cb; eval_right_shift(b, a);`.][[space]]]
[[`eval_qr(cb, cb2, b, b2)`][`void`][Sets `b` to the result of `cb / cb2` and `b2` to the result of `cb % cb2`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_integer_modulus(cb, ui)`][`unsigned`][Returns the result of `cb % ui`.    Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.]
            [`std::overflow_error` if `a` has the value zero.]]
[[`eval_lsb(cb)`][`unsigned`][Returns the index of the least significant bit that is set.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_msb(cb)`][`unsigned`][Returns the index of the most significant bit that is set.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_bit_test(cb, ui)`][`bool`][Returns true if `cb` has bit `ui` set.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_bit_set(b, ui)`][`void`][Sets the bit at index `ui` in `b`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_bit_unset(b, ui)`][`void`][Unsets the bit at index `ui` in `b`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_bit_flip(b, ui)`][`void`][Flips the bit at index `ui` in `b`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_gcd(b, cb, cb2)`][`void`][Sets `b` to the greatest common divisor of `cb` and `cb2`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_lcm(b, cb, cb2)`][`void`][Sets `b` to the least common multiple of `cb` and `cb2`.  Only required when `B` is an integer type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_gcd(b, cb, a)`][`void`][Sets `b` to the greatest common divisor of `cb` and `cb2`.  Only required when `B` is an integer type.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            The default version of this function calls `eval_gcd(b, cb, B(a))`.][[space]]]
[[`eval_lcm(b, cb, a)`][`void`][Sets `b` to the least common multiple of `cb` and `cb2`.  Only required when `B` is an integer type.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            The default version of this function calls `eval_lcm(b, cb, B(a))`.][[space]]]
[[`eval_gcd(b, a, cb)`][`void`][Sets `b` to the greatest common divisor of `cb` and `a`.  Only required when `B` is an integer type.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            The default version of this function calls `eval_gcd(b, cb, a)`.][[space]]]
[[`eval_lcm(b, a, cb)`][`void`][Sets `b` to the least common multiple of `cb` and `a`.  Only required when `B` is an integer type.
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types` or `B::float_types`.
            The default version of this function calls `eval_lcm(b, cb, a)`.][[space]]]
[[`eval_powm(b, cb, cb2, cb3)`][`void`][Sets `b` to the result of ['(cb^cb2)%cb3].
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_powm(b, cb, cb2, a)`][`void`][Sets `b` to the result of ['(cb^cb2)%a].
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types`.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_powm(b, cb, a, cb2)`][`void`][Sets `b` to the result of ['(cb^a)%cb2].
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types`.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_powm(b, cb, a, a2)`][`void`][Sets `b` to the result of ['(cb^a)%a2].
            The type of `a` shall be listed in one of the type lists
            `B::signed_types`, `B::unsigned_types`.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_integer_sqrt(b, cb, b2)`][`void`][Sets `b` to the largest integer which when squared is less than `cb`, also
            sets `b2` to the remainder, ie to ['cb - b[super 2]].
            The default version of this function is synthesised from other operations above.][[space]]]

[[['Sign manipulation:]]]
[[`eval_abs(b, cb)`][`void`][Set `b` to the absolute value of `cb`.
            The default version of this functions assigns `cb` to `b`, and then calls `b.negate()` if
            `eval_get_sign(cb) < 0`.][[space]]]
[[`eval_fabs(b, cb)`][`void`][Set `b` to the absolute value of `cb`.
            The default version of this functions assigns `cb` to `b`, and then calls `b.negate()` if
            `eval_get_sign(cb) < 0`.][[space]]]

[[['floating-point functions:]]]
[[`eval_fpclassify(cb)`][`int`][Returns one of the same values returned by `std::fpclassify`.  Only required when `B` is an floating-point type.
            The default version of this function will only test for zero `cb`.][[space]]]
[[`eval_trunc(b, cb)`][`void`][Performs the equivalent operation to `std::trunc` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_round(b, cb)`][`void`][Performs the equivalent operation to `std::round` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_exp(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_exp2(b, cb)`][`void`][Performs the equivalent operation to `std::exp2` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is implemented in terms of `eval_pow`.][[space]]]
[[`eval_log(b, cb)`][`void`][Performs the equivalent operation to `std::log` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_log10(b, cb)`][`void`][Performs the equivalent operation to `std::log10` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_sin(b, cb)`][`void`][Performs the equivalent operation to `std::sin` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_cos(b, cb)`][`void`][Performs the equivalent operation to `std::cos` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_tan(b, cb)`][`void`][Performs the equivalent operation to `std::exp` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_asin(b, cb)`][`void`][Performs the equivalent operation to `std::asin` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_acos(b, cb)`][`void`][Performs the equivalent operation to `std::acos` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_atan(b, cb)`][`void`][Performs the equivalent operation to `std::atan` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_sinh(b, cb)`][`void`][Performs the equivalent operation to `std::sinh` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_cosh(b, cb)`][`void`][Performs the equivalent operation to `std::cosh` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_tanh(b, cb)`][`void`][Performs the equivalent operation to `std::tanh` on argument `cb` and stores the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_fmod(b, cb, cb2)`][`void`][Performs the equivalent operation to `std::fmod` on arguments `cb` and `cb2`, and store the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_modf(b, cb, pb)`][`void`][Performs the equivalent operation to `std::modf` on argument `cb`, and store the integer result in `*pb` and the fractional part in `b`.
            Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_pow(b, cb, cb2)`][`void`][Performs the equivalent operation to `std::pow` on arguments `cb` and `cb2`, and store the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_atan2(b, cb, cb2)`][`void`][Performs the equivalent operation to `std::atan` on arguments `cb` and `cb2`, and store the result in `b`.  Only required when `B` is an floating-point type.
            The default version of this function is synthesised from other operations above.][[space]]]
[[`eval_scalbn(b, cb, e)`][`void`][Scales value `cb` by ['r[super e]], where ['r] is the radix of the type.  The default version of this function
                  is implemented in terms of eval_ldexp, consequently this function must be provided for types with a radix other than 2.]]
[[`eval_scalbln(b, cb, e)`][`void`][Calls `eval_scalbn(b, cb, e)`.]]
[[`eval_ilogb(cb)`][`B::exponent_type`][Returns the exponent ['e] of value `cb` such that ['1 <= cb*r[super -e] < r], where ['r] is the radix of type B.
                    The default version of this function is implemented in terms of eval_frexp, consequently this function must be provided for types with a radix other than 2.]]
[[`eval_remquo(b, cb, cb2, pi)`][`void`][Sets `b = cb - n * cb2` and stores `n` in `*pi`.]]
[[`eval_remquo(b, cb, a, pi)`][`void`][Default version converts a to type B and calls the overload above.]]
[[`eval_remquo(b, a, cb, pi)`][`void`][Default version converts a to type B and calls the overload above.]]
[[`eval_remainder(b, cb, cb2)`][`void`][Default version calls eval_remquo with a dummy final argument.]]
[[`eval_remainder(b, cb, a)`][`void`][Default version calls eval_remquo with a dummy final argument.]]
[[`eval_remainder(b, a, cb)`][`void`][Default version calls eval_remquo with a dummy final argument.]]

[[`eval_fdim(b, cb, cb2)`][`void`][Default version sets `b = cb - cb2` if `cb > cb2` and zero otherwise.  Special cases are handled as in the C99 annex.]]
[[`eval_fdim(b, cb, a)`][`void`][Default version sets `b = cb - cb2` if `cb > cb2` and zero otherwise.  Special cases are handled as in the C99 annex.]]
[[`eval_fdim(b, a, cb)`][`void`][Default version sets `b = cb - cb2` if `cb > cb2` and zero otherwise.  Special cases are handled as in the C99 annex.]]

[[`eval_fmax(b, cb, cb2)`][`void`][Sets `b` to the larger of `cb` and `cb2`.]]
[[`eval_fmax(b, cb, a)`][`void`][Sets `b` to the larger of `cb` and `a`.]]
[[`eval_fmax(b, a, cb)`][`void`][Sets `b` to the larger of `cb` and `a`.]]
[[`eval_fmin(b, cb, cb2)`][`void`][Sets `b` to the smaller of `cb` and `cb2`.]]
[[`eval_fmin(b, cb, a)`][`void`][Sets `b` to the smaller of `cb` and `a`.]]
[[`eval_fmin(b, a, cb)`][`void`][Sets `b` to the smaller of `cb` and `a`.]]

[[`eval_hypot(b, cb, cb2)`][`void`][Sets `b` to the square root of the sum of the squares of `cb` and `cb2` without undue over or under flow.]]
[[`eval_hypot(b, cb, a)`][`void`][As above.]]
[[`eval_hypot(b, a, cb)`][`void`][As above.]]

[[`eval_logb(b, cb)`][`B::exponent_type`][Sets `b` to the exponent ['e] of value `cb` such that ['1 <= cb*r[super -b] < r], where ['r] is the radix of type B.
                  The default version of this function is implemented in terms of `eval_ilogb`.]]
[[`eval_nearbyint(b, cb)`][`void`][Calls `eval_round(b, cb)`.]]
[[`eval_rint(b, cb)`][`void`][Calls `eval_nearbyint(b, cb)`.]]
[[`eval_log2(b, cb)`][`void`][Sets `b` to the logarithm base 2 of `cb`.]]

[[['hashing:]]]
[[`hash_value(cb)`][`std::size_t`]
         [Returns a hash value for the argument that is suitable for use with `std::hash` etc.  If not provided then no automatic hashing support will be available for the number type.]]
]

When the tables above place no ['throws] requirements on an operation, then it is up to each type modelling this concept to
decide when or whether throwing an exception is desirable.  However, thrown exceptions should always either be the type, or
inherit from the type `std::runtime_error`.  For example, a floating-point type might choose to throw `std::overflow_error`
whenever the result of an operation would be infinite, and `std::underflow_error` whenever it would round to zero.

[note
The non-member functions are all named with an "eval_" prefix to avoid conflicts with template classes of the same name -
in point of fact this naming convention shouldn't be necessary, but rather works around some compiler bugs.]

[h4 Overloadable Functions]

Some of the C99 math functions do not have `eval_` functions but must be overloaded directly: these functions
are either trivial or are forwarded to the Boost.Math implementations by default.
The full list of these functions is:

   int           sign       (const ``['number-or-expression-template-type]``&);
   bool          signbit    (const ``['number-or-expression-template-type]``&);
   ``['number]``        changesign (const ``['number-or-expression-template-type]``&);
   ``['number]``        copysign   (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``        asinh      (const ``['number-or-expression-template-type]``&);
   ``['number]``        acosh      (const ``['number-or-expression-template-type]``&);
   ``['number]``        atanh      (const ``['number-or-expression-template-type]``&);
   ``['number]``        cbrt       (const ``['number-or-expression-template-type]``&);
   ``['number]``        erf        (const ``['number-or-expression-template-type]``&);
   ``['number]``        erfc       (const ``['number-or-expression-template-type]``&);
   ``['number]``        expm1      (const ``['number-or-expression-template-type]``&);
   ``['number]``        log1p      (const ``['number-or-expression-template-type]``&);
   ``['number]``        tgamma     (const ``['number-or-expression-template-type]``&);
   ``['number]``        lgamma     (const ``['number-or-expression-template-type]``&);
   long          lrint      (const ``['number-or-expression-template-type]``&);
   long long     llrint     (const ``['number-or-expression-template-type]``&);
   ``['number]``        nextafter  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``        nexttoward (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_cpp_bin_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_bin_float_ref cpp_bin_float]

   namespace boost{ namespace multiprecision{

   enum digit_base_type
   {
      digit_base_2 = 2,
      digit_base_10 = 10
   };

   template <unsigned Digits, digit_base_type base = digit_base_10, class Allocator = void, class Exponent = int, ExponentMin = 0, ExponentMax = 0>
   class cpp_bin_float;

   typedef number<cpp_bin_float<50> > cpp_bin_float_50;
   typedef number<cpp_bin_float<100> > cpp_bin_float_100;

   typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, std::int16_t, -126, 127>, et_off>         cpp_bin_float_single;
   typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, std::int16_t, -1022, 1023>, et_off>       cpp_bin_float_double;
   typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>     cpp_bin_float_double_extended;
   typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>    cpp_bin_float_quad;
   typedef number<backends::cpp_bin_float<237, backends::digit_base_2, void, std::int32_t, -262142, 262143>, et_off>  cpp_bin_float_oct;

   }} // namespaces

Class template `cpp_bin_float` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The class takes six template parameters:

[variablelist
[[Digits][The number of digits precision the type
should support.  This is normally expressed as base-10 digits, but that can be changed via the second template parameter.]]
[[base][An enumerated value (either `digit_base_10` or `digit_base_2`) that indicates whether `Digits` is base-10 or base-2]]
[[Allocator][The allocator used: defaults to type `void`, meaning all storage is within the class, and no dynamic
allocation is performed, but can be set to a standard library allocator if dynamic allocation makes more sense.]]
[[Exponent][A signed integer type to use as the type of the exponent - defaults to `int`.]]
[[ExponentMin][The smallest (most negative) permitted exponent, defaults to zero, meaning "define as small as possible
given the limitations of the type and our internal requirements".]]
[[ExponentMax][The largest (most positive) permitted exponent, defaults to zero, meaning "define as large as possible
given the limitations of the type and our internal requirements".]]
]

The type of `number_category<cpp_bin_float<Args...> >::type` is `std::integral_constant<int, number_kind_floating_point>`.

More information on this type can be found in the [link boost_multiprecision.tut.floats.cpp_bin_float tutorial].

[h4 Implementation Notes]

Internally, an N-bit `cpp_bin_float` is represented as an N-bit unsigned integer along with an exponent and a sign.
The integer part is normalized so that its most significant bit is always 1.  The decimal point is assumed to be
directly after the most significant bit of the integer part.  The special values zero, infinity and NaN all have
the integer part set to zero, and the exponent to one of 3 special values above the maximum permitted exponent.

Multiplication is trivial: multiply the two N-bit integer mantissa's to obtain a 2N-bit number, then round and
adjust the sign and exponent.

Addition and subtraction proceed similarly - if the exponents are such that there is overlap between the two
values, then left shift the larger value to produce a number with between N and 2N bits, then perform integer
addition or subtraction, round, and adjust the exponent.

Division proceeds as follows: first scale the numerator by some power of 2 so that integer division will
produce either an N-bit or N+1 bit result plus a remainder.  If we get an N bit result then the size of
twice the remainder compared to the denominator gives us the rounding direction.  Otherwise we have one extra bit
in the result which we can use to determine rounding (in this case ties occur only if the remainder is zero and
the extra bit is a 1).

Square root uses integer square root in a manner analogous to division.

Decimal string to binary conversion proceeds as follows: first parse the digits to
produce an integer multiplied by a decimal exponent.  Note that we stop parsing digits
once we have parsed as many as can possibly effect the result - this stops the integer
part growing too large when there are a very large number of input digits provided.
At this stage if the decimal exponent is positive then the result is an integer and we
can in principle simply multiply by 10^N to get an exact integer result.  In practice
however, that could produce some very large integers.  We also need to be able to divide
by 10^N in the event that the exponent is negative.  Therefore calculation of the 10^N
values plus the multiplication or division are performed using limited precision
integer arithmetic, plus an exponent, and a track of the accumulated error.  At the end of
the calculation we will either be able to round unambiguously, or the error will be such
that we can't tell which way to round.  In the latter case we simply up the precision and try
again until we have an unambiguously rounded result.

Binary to decimal conversion proceeds very similarly to the above, our aim is to calculate
`mantissa * 2^shift * 10^E` where `E` is the decimal exponent and `shift` is calculated
so that the result is an N bit integer assuming we want N digits printed in the result.
As before we use limited precision arithmetic to calculate the result and up the
precision as necessary until the result is unambiguously correctly rounded.  In addition
our initial calculation of the decimal exponent may be out by 1, so we have to correct
that and loop as well in the that case.

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_cpp_dec_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_dec_ref cpp_dec_float]

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10, class ExponentType = std::int32_t, class Allocator = void>
   class cpp_dec_float;

   typedef number<cpp_dec_float<50> > cpp_dec_float_50;
   typedef number<cpp_dec_float<100> > cpp_dec_float_100;

   }} // namespaces

Class template `cpp_dec_float` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The class takes three template parameters:

[variablelist
[[Digits10][The number of decimal digits precision the type
should support.  Note that this type does not normally perform any dynamic memory allocation, and as a result the `Digits10`
template argument should not be set too high or the class's size will grow unreasonably large.]]
[[ExponentType][A signed integer type that represents the exponent of the number]]
[[Allocator][The allocator used: defaults to type `void`, meaning all storage is within the class, and no dynamic
allocation is performed, but can be set to a standard library allocator if dynamic allocation makes more sense.]]
]

The type of `number_category<cpp_dec_float<Args...> >::type` is `std::integral_constant<int, number_kind_floating_point>`.

More information on this type can be found in the [link boost_multiprecision.tut.floats.cpp_dec_float tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_cpp_int.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_int_ref cpp_int]

   namespace boost{ namespace multiprecision{

   typedef unspecified-type limb_type;

   enum cpp_integer_type    { signed_magnitude, unsigned_magnitude };
   enum cpp_int_check_type  { checked, unchecked };

   template <unsigned MinDigits = 0,
             unsigned MaxDits = 0,
             cpp_integer_type SignType = signed_magnitude,
             cpp_int_check_type Checked = unchecked,
             class Allocator = std::allocator<limb_type> >
   class cpp_int_backend;
   //
   // Expression templates default to et_off if there is no allocator:
   //
   template <unsigned MinDigits, unsigned MaxDigits, cpp_integer_type SignType, cpp_int_check_type Checked>
   struct expression_template_default<cpp_int_backend<MinDigits, MaxDigits, SignType, Checked, void> >
   { static const expression_template_option value = et_off; };

   typedef number<cpp_int_backend<> >              cpp_int;    // arbitrary precision integer
   typedef rational_adaptor<cpp_int_backend<> >    cpp_rational_backend;
   typedef number<cpp_rational_backend>            cpp_rational; // arbitrary precision rational number

   // Fixed precision unsigned types:
   typedef number<cpp_int_backend<128, 128, unsigned_magnitude, unchecked, void> >   uint128_t;
   typedef number<cpp_int_backend<256, 256, unsigned_magnitude, unchecked, void> >   uint256_t;
   typedef number<cpp_int_backend<512, 512, unsigned_magnitude, unchecked, void> >   uint512_t;
   typedef number<cpp_int_backend<1024, 1024, unsigned_magnitude, unchecked, void> > uint1024_t;

   // Fixed precision signed types:
   typedef number<cpp_int_backend<128, 128, signed_magnitude, unchecked, void> >     int128_t;
   typedef number<cpp_int_backend<256, 256, signed_magnitude, unchecked, void> >     int256_t;
   typedef number<cpp_int_backend<512, 512, signed_magnitude, unchecked, void> >     int512_t;
   typedef number<cpp_int_backend<1024, 1024, signed_magnitude, unchecked, void> >   int1024_t;

   // Over again, but with checking enabled this time:
   typedef number<cpp_int_backend<0, 0, signed_magnitude, checked> >                 checked_cpp_int;
   typedef rational_adaptor<cpp_int_backend<0, 0, signed_magnitude, checked> >       checked_cpp_rational_backend;
   typedef number<checked_cpp_rational_backend>                                      checked_cpp_rational;

   // Checked fixed precision unsigned types:
   typedef number<cpp_int_backend<128, 128, unsigned_magnitude, checked, void> >     checked_uint128_t;
   typedef number<cpp_int_backend<256, 256, unsigned_magnitude, checked, void> >     checked_uint256_t;
   typedef number<cpp_int_backend<512, 512, unsigned_magnitude, checked, void> >     checked_uint512_t;
   typedef number<cpp_int_backend<1024, 1024, unsigned_magnitude, checked, void> >   checked_uint1024_t;

   // Fixed precision signed types:
   typedef number<cpp_int_backend<128, 128, signed_magnitude, checked, void> >       checked_int128_t;
   typedef number<cpp_int_backend<256, 256, signed_magnitude, checked, void> >       checked_int256_t;
   typedef number<cpp_int_backend<512, 512, signed_magnitude, checked, void> >       checked_int512_t;
   typedef number<cpp_int_backend<1024, 1024, signed_magnitude, checked, void> >     checked_int1024_t;

   }} // namespaces

Class template `cpp_int_backend` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The template arguments are:

[variablelist
[[MinBits][Determines the number of Bits to store directly within the object before resorting to dynamic memory
           allocation.  When zero, this field is determined automatically based on how many bits can be stored
           in union with the dynamic storage header: setting a larger value may improve performance as larger integer
           values will be stored internally before memory allocation is required.]]
[[MaxBits][Determines the maximum number of bits to be stored in the type: resulting in a fixed precision type.
           When this value is the same as MinBits, then the Allocator parameter is ignored, as no dynamic
           memory allocation will ever be performed: in this situation the Allocator parameter should be set to
           type `void`.  Note that this parameter should not be used simply to prevent large memory
           allocations, not only is that role better performed by the allocator, but fixed precision
           integers have a tendency to allocate all of MaxBits of storage more often than one would expect.]]
[[SignType][Determines whether the resulting type is signed or not.  Note that for
[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] types
          this parameter must be `signed_magnitude`.  For fixed precision
          types then this type may be either `signed_magnitude` or `unsigned_magnitude`.]]
[[Checked][This parameter has two values: `checked` or `unchecked`.  See the [link boost_multiprecision.tut.ints.cpp_int tutorial] for more information.]]
[[Allocator][The allocator to use for dynamic memory allocation, or type `void` if MaxBits == MinBits.]]
]

The type of `number_category<cpp_int<Args...> >::type` is `std::integral_constant<int, number_kind_integer>`.

More information on this type can be found in the [link boost_multiprecision.tut.ints.cpp_int tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_gmp_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:mpf_ref gmp_float]

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10>
   class gmp_float;

   typedef number<gmp_float<50> >    mpf_float_50;
   typedef number<gmp_float<100> >   mpf_float_100;
   typedef number<gmp_float<500> >   mpf_float_500;
   typedef number<gmp_float<1000> >  mpf_float_1000;
   typedef number<gmp_float<0> >     mpf_float;

   }} // namespaces

Class template `gmp_float` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
should support.  When this parameter is zero, then the precision can be set at runtime via `number::default_precision`
and `number::precision`.  Note that this type does not in any way change the GMP library's global state (for example
it does not change the default precision of the mpf_t data type), therefore you can safely mix this type with existing
code that uses GMP, and also mix `gmp_float`s of differing precision.

The type of `number_category<cpp_int<Args...> >::type` is `std::integral_constant<int, number_kind_floating_point>`.

More information on this type can be found in the [link boost_multiprecision.tut.floats.gmp_float tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_gmp_int.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:gmp_int_ref gmp_int]

   namespace boost{ namespace multiprecision{

   class gmp_int;

   typedef number<gmp_int >         mpz_int;

   }} // namespaces

Class template `gmp_int` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The type of `number_category<cpp_int<Args...> >::type` is `std::integral_constant<int, number_kind_integer>`.

More information on this type can be found in the [link boost_multiprecision.tut.ints.gmp_int tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_header_structure.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:headers Header File Structure]

[table Top level headers
[[Header][Contains]]
[[cpp_int.hpp][The `cpp_int` backend type.]]
[[gmp.hpp][Defines all [gmp] related backends.]]
[[miller_rabin.hpp][Miller Rabin primality testing code.]]
[[number.hpp][Defines the `number` backend, is included by all the backend headers.]]
[[mpfr.hpp][Defines the mpfr_float_backend backend.]]
[[random.hpp][Defines code to interoperate with Boost.Random.]]
[[rational_adaptor.hpp][Defines the `rational_adaptor` backend.]]
[[cpp_dec_float.hpp][Defines the `cpp_dec_float` backend.]]
[[tommath.hpp][Defines the `tommath_int` backend.]]
[[concepts/number_archetypes.hpp][Defines a backend concept archetypes for testing use.]]
]

[table Implementation Headers
[[Header][Contains]]
[[cpp_int/add.hpp][Add and subtract operators for `cpp_int_backend`.]]
[[cpp_int/bitwise.hpp][Bitwise operators for `cpp_int_backend`.]]
[[cpp_int/checked.hpp][Helper functions for checked arithmetic for `cpp_int_backend`.]]
[[cpp_int/comparison.hpp][Comparison operators for `cpp_int_backend`.]]
[[cpp_int/cpp_int_config.hpp][Basic setup and configuration for `cpp_int_backend`.]]
[[cpp_int/divide.hpp][Division and modulus operators for `cpp_int_backend`.]]
[[cpp_int/limits.hpp][`numeric_limits` support for `cpp_int_backend`.]]
[[cpp_int/misc.hpp][Miscellaneous operators for `cpp_int_backend`.]]
[[cpp_int/multiply.hpp][Multiply operators for `cpp_int_backend`.]]
[[detail/default_ops.hpp][Default versions of the optional backend non-member functions.]]
[[detail/generic_interconvert.hpp][Generic interconversion routines.]]
[[detail/number_base.hpp][All the expression template code, metaprogramming, and operator overloads for `number`.]]
[[detail/no_et_ops.hpp][The non-expression template operators.]]
[[detail/functions/constants.hpp][Defines constants used by the floating-point functions.]]
[[detail/functions/pow.hpp][Defines default versions of the power and exponential related floating-point functions.]]
[[detail/functions/trig.hpp][Defines default versions of the trigonometric related floating-point functions.]]
]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_internal_support.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:internals Internal Support Code]

There are some traits classes which authors of new backends should be aware of:

   namespace boost{ namespace multiprecision{ namespace detail{

   template<typename From, typename To>
   struct is_explicitly_convertible;

   }}}

Inherits from `std::integral_constant<bool,true>` if type `From` has an explicit conversion from `To`.

   template <class From, class To>
   struct is_lossy_conversion
   {
      static const bool value = see below;
   };

Member `value` is true if the conversion from `From` to `To` would result in a loss of precision, and `false` otherwise.

The default version of this trait simply checks whether the ['kind] of conversion (for example from a floating-point to an integer type)
is inherently lossy.  Note that if either of the types `From` or `To` are of an unknown number category (because `number_category` is not
specialised for that type) then this trait will be `true`.

   template<typename From, typename To>
   struct is_restricted_conversion
   {
      static const bool value = see below;
   };

Member `value` is `true` if `From` is only explicitly convertible to `To` and not implicitly convertible, or
if `is_lossy_conversion<From, To>::value` is `true`.  Otherwise `false`.

Note that while this trait is the ultimate arbiter of which constructors are marked as `explicit` in class `number`,
authors of backend types should generally specialise one of the traits above, rather than this one directly.

   template <class T>
   is_signed_number;
   template <class T>
   is_unsigned_number;

These two traits inherit from either `std::integral_constant<bool, true>` or `std::integral_constant<bool, false>`, by default types are assumed to be signed unless
`is_unsigned_number` is specialized for that type.

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_mpfr_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:mpfr_ref mpfr_float_backend]

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10>
   class mpfr_float_backend;

   typedef number<mpfr_float_backend<50> >    mpfr_float_50;
   typedef number<mpfr_float_backend<100> >   mpfr_float_100;
   typedef number<mpfr_float_backend<500> >   mpfr_float_500;
   typedef number<mpfr_float_backend<1000> >  mpfr_float_1000;
   typedef number<mpfr_float_backend<0> >     mpfr_float;

   }} // namespaces

Class template `mpfr_float_backend` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
should support.  When this parameter is zero, then the precision can be set at runtime via `number::default_precision`
and `number::precision`.  Note that this type does not in any way change the GMP or MPFR library's global state (for example
it does not change the default precision of the mpfr_t data type), therefore you can safely mix this type with existing
code that uses GMP or MPFR, and also mix `mpfr_float_backend`s of differing precision.

The type of `number_category<cpp_int<Args...> >::type` is `std::integral_constant<int, number_kind_floating_point>`.

More information on this type can be found in the [link boost_multiprecision.tut.floats.mpfr_float tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_number.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:number number]

[h4 Synopsis]

   namespace boost{ namespace multiprecision{

   enum expression_template_option { et_on = 1, et_off = 0 };

   template <class Backend> struct expression_template_default
   { static const expression_template_option value = et_on; };

   template <class Backend, expression_template_option ExpressionTemplates = expression_template_default<Backend>::value>
   class number
   {
   public:
      typedef          Backend                          backend_type;
      typedef typename component_type<self_type>::type  value_type;

      static constexpr expression_template_option et = ExpressionTemplates;

      number();
      number(see-below);
      number& operator=(see-below);
      number& assign(see-below);

      // Member operators
      number& operator+=(const ``['see-below]``&);
      number& operator-=(const ``['see-below]``&);
      number& operator*=(const ``['see-below]``&);
      number& operator/=(const ``['see-below]``&);
      number& operator++();
      number& operator--();
      number  operator++(int);
      number  operator--(int);

      number& operator%=(const ``['see-below]``&);
      number& operator&=(const ``['see-below]``&);
      number& operator|=(const ``['see-below]``&);
      number& operator^=(const ``['see-below]``&);
      number& operator<<=(const ``['integer-type]``&);
      number& operator>>=(const ``['integer-type]``&);

      // Use in Boolean context:
      operator ``['convertible-to-bool-type]``()const;
      // swap:
      void swap(number& other);
      // Sign:
      bool is_zero()const;
      int sign()const;
      // string conversion:
      std::string str()const;
      // Generic conversion mechanism
      template <class T>
      T convert_to()const;
      template <class T>
      explicit operator T ()const;
      // precision control:
      static unsigned default_precision();
      static void default_precision(unsigned digits10);
      unsigned precision()const;
      void precision(unsigned digits10);
      // Comparison:
      int compare(const number<Backend>& o)const;
      template <class V>
      typename std::enable_if<std::is_convertible<V, number<Backend, ExpressionTemplates>::value >, int>::type
         compare(const V& o)const;
      // real and imaginary parts:
      value_type real()const;
      value_type imag()const;
      template <class T>
      void real(const T& val);
      template <class T>
      void imag(const T& val);
      // Access to the underlying implementation:
      Backend& backend();
      const Backend& backend()const;
   };

   // Non member operators:
   ``['unmentionable-expression-template-type]`` operator+(const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator-(const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator+(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator-(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator*(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator/(const ``['see-below]``&, const ``['see-below]``&);
   // Integer only operations:
   ``['unmentionable-expression-template-type]`` operator%(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator&(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator|(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator^(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator<<(const ``['see-below]``&, const ``['integer-type]``&);
   ``['unmentionable-expression-template-type]`` operator>>(const ``['see-below]``&, const ``['integer-type]``&);
   // Comparison operators:
   bool operator==(const ``['see-below]``&, const ``['see-below]``&);
   bool operator!=(const ``['see-below]``&, const ``['see-below]``&);
   bool operator< (const ``['see-below]``&, const ``['see-below]``&);
   bool operator> (const ``['see-below]``&, const ``['see-below]``&);
   bool operator<=(const ``['see-below]``&, const ``['see-below]``&);
   bool operator>=(const ``['see-below]``&, const ``['see-below]``&);

   // Swap:
   template <class Backend, expression_template_option ExpressionTemplates>
   void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b);

   // iostream support:
   template <class Backend, expression_template_option ExpressionTemplates>
   std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r);
   std::ostream& operator << (std::ostream& os, const ``['unmentionable-expression-template-type]``& r);
   template <class Backend, expression_template_option ExpressionTemplates>
   std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r);

   // to_string support:
   template <class Backend, expression_template_option ExpressionTemplates>
   std::string to_string(const number<Backend, ExpressionTemplates>& val);

   // Arithmetic with a higher precision result:
   template <class ResultType, class Source1 class Source2>
   ResultType& add(ResultType& result, const Source1& a, const Source2& b);
   template <class ResultType, class Source1 class Source2>
   ResultType& subtract(ResultType& result, const Source1& a, const Source2& b);
   template <class ResultType, class Source1 class Source2>
   ResultType& multiply(ResultType& result, const Source1& a, const Source2& b);

   // min and max overloads:
   ``['number]``                                    min    (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``                                    max    (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

   // C99 Non-member function standard library support:
   ``['unmentionable-expression-template-type]``    abs        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    acos       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    acosh      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    asin       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    asinh      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    atan       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    atan2      (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``                                    atanh      (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    cbrt       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ceil       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    copysign   (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    cos        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    cosh       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    erf        (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    erfc       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    exp        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    exp2       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    expm1      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fabs       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fdim       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    floor      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fma        (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmin       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmax       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmod       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    frexp      (const ``['number-or-expression-template-type]``&, ``['integer-type]``*);
   ``['unmentionable-expression-template-type]``    hypot      (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['integer-type]``                              ilogb      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ldexp      (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['number]``                                    lgamma     (const ``['number-or-expression-template-type]``&);
   long long                                 llrint     (const ``['number-or-expression-template-type]``&);
   long long                                 llround    (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log2       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log10      (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    log1p      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    logb       (const ``['number-or-expression-template-type]``&);
   long                                      lrint      (const ``['number-or-expression-template-type]``&);
   long                                      lround     (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    modf       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    nearbyint  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    nextafter  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``                                    nexttoward (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    pow        (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    remainder  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    remquo     (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&, int*);
   ``['unmentionable-expression-template-type]``    rint       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    round      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    scalbn     (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['unmentionable-expression-template-type]``    scalbln    (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['unmentionable-expression-template-type]``    sin        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    sinh       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    sqrt       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    tan        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    tanh       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    tgamma     (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    trunc      (const ``['number-or-expression-template-type]``&);

   int                                       fpclassify (const ``['number-or-expression-template-type]``&);
   bool                                      isfinite   (const ``['number-or-expression-template-type]``&);
   bool                                      isinf      (const ``['number-or-expression-template-type]``&);
   bool                                      isnan      (const ``['number-or-expression-template-type]``&);
   bool                                      isnormal   (const ``['number-or-expression-template-type]``&);
   bool                                      signbit    (const ``['number-or-expression-template-type]``&);

   bool                                      isgreater  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isgreaterequal(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isless     (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      islessequal(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-typearea]``&);
   bool                                      islessgreater(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isunordered(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   // Complex number functions:
   ``['number<...>::value_type]``                   real  (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   imag  (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   abs   (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   arg   (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   norm  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    conj  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    proj  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    polar (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   // Misc other common C library functions:
   ``['unmentionable-expression-template-type]``    itrunc (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ltrunc (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    lltrunc(const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    iround (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    changesign(const ``['number-or-expression-template-type]``&);
   ``['number]``                                    copysign(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

   // Traits support:
   template <class T>
   struct component_type;
   template <class T>
   struct number_category;
   template <class T>
   struct is_number;
   template <class T>
   struct is_number_expression;

   // Integer specific functions:
   ``['unmentionable-expression-template-type]``    gcd(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    lcm(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    pow(const ``['number-or-expression-template-type]``&, unsigned);
   ``['unmentionable-expression-template-type]``    powm(const ``['number-or-expression-template-type]``& b, const ``['number-or-expression-template-type]``& p, const ``['number-or-expression-template-type]``& m);
   ``['unmentionable-expression-template-type]``    sqrt(const ``['number-or-expression-template-type]``&);
   template <class Backend, expression_template_option ExpressionTemplates>
   number<Backend, EXpressionTemplates>      sqrt(const ``['number-or-expression-template-type]``&, number<Backend, EXpressionTemplates>&);
   template <class Backend, expression_template_option ExpressionTemplates>
   void divide_qr(const ``['number-or-expression-template-type]``& x, const ``['number-or-expression-template-type]``& y,
                  number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r);
   template <class Integer>
   Integer integer_modulus(const ``['number-or-expression-template-type]``& x, Integer val);
   unsigned lsb(const ``['number-or-expression-template-type]``& x);
   unsigned msb(const ``['number-or-expression-template-type]``& x);
   template <class Backend, class ExpressionTemplates>
   bool bit_test(const number<Backend, ExpressionTemplates>& val, unsigned index);
   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_set(number<Backend, ExpressionTemplates>& val, unsigned index);
   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_unset(number<Backend, ExpressionTemplates>& val, unsigned index);
   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_flip(number<Backend, ExpressionTemplates>& val, unsigned index);
   template <class Engine>
   bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
   bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials);

   // Rational number support:
   typename component_type<``['number-or-expression-template-type]``>::type numerator  (const ``['number-or-expression-template-type]``&);
   typename component_type<``['number-or-expression-template-type]``>::type denominator(const ``['number-or-expression-template-type]``&);

   }} // namespaces

   namespace boost{ namespace math{

   // Boost.Math interoperability functions:
   int                                              fpclassify     (const ``['number-or-expression-template-type]``&, int);
   bool                                             isfinite       (const ``['number-or-expression-template-type]``&, int);
   bool                                             isnan          (const ``['number-or-expression-template-type]``&, int);
   bool                                             isinf          (const ``['number-or-expression-template-type]``&, int);
   bool                                             isnormal       (const ``['number-or-expression-template-type]``&, int);

   }} // namespaces

   // numeric_limits support:
   namespace std{

   template <class Backend, expression_template_option ExpressionTemplates>
   struct numeric_limits<boost::multiprecision<Backend, ExpressionTemplates> >
   {
      /* Usual members here */
   };

   }

[h4 Description]

   enum expression_template_option { et_on = 1, et_off = 0 };

This enumerated type is used to specify whether expression templates are turned on (et_on) or turned off (et_off).

   template <class Backend> struct expression_template_default
   { static const expression_template_option value = et_on; };

This traits class specifies the default expression template option to be used with a particular Backend type.
It defaults to `et_on`.

   template <class Backend, expression_template_option ExpressionTemplates = expression_template_default<Backend>::value>
   class number;

Class `number` has two template arguments:

[variablelist
[[Backend][The actual arithmetic back-end that does all the work.]]
[[ExpressionTemplates][A Boolean value: when `et_on`, then expression templates are enabled, otherwise when set to `et_off` they are disabled.
   The default for this parameter is computed via the traits class `expression_template_default` whose member `value` defaults to `et_on` unless
   the traits class is specialized for a particular backend.]]
]

   number();
   number(see-below);
   number& operator=(see-below);
   number& assign(see-below);

Type `number` is default constructible, and both copy constructible and assignable from:

* Itself.
* An expression template which is the result of one of the arithmetic operators.
* Any __fundamental arithmetic type, as long as the result would not be lossy (for example float to integer conversion).
* Any type that the Backend is implicitly constructible or assignable from.
* An rvalue reference to another `number`.  Move-semantics are used for construction if the backend also
supports rvalue reference construction.  In the case of assignment, move semantics are always supported
when the argument is an rvalue reference irrespective of the backend.
* Any type in the same family, as long as no loss of precision is involved.  For example from `int128_t` to `int256_t`,
or `cpp_dec_float_50` to `cpp_dec_float_100`.

Type `number` is explicitly constructible from:

* Any type mentioned above.
* A `std::string` or any type which is convertible to `const char*`.
* Any arithmetic type (including those that would result in lossy conversions).
* Any type in the same family, including those that result in loss of precision.
* Any type that the Backend is explicitly constructible from.
* Any pair of types for which a generic interconversion exists: that is from integer to integer, integer
to rational, integer to float, rational to rational, rational to float, or float to float.

The assign member function is available for any type for which an explicit converting constructor exists.
It is intended to be used where a temporary generated from an explicit assignment would be expensive, for example:

   mpfr_float_50    f50;
   mpfr_float_100   f100;

   f50 = static_cast<mpfr_float_50>(f100);  // explicit cast create a temporary
   f50.assign(f100);                        // explicit call to assign create no temporary

In addition, if the type has multiple components (for example rational or complex number types), then there is a
two argument constructor:

   number(arg1, arg2);

Where the two args must either be arithmetic types, or types that are convertible to the two components of `this`.
Rvalue forwarding overloads are provided so either one or both arguments may be rvalue-references which will be moved
into the result, if the backend is able to make use of them.

Finally, when the type has a variable precision, then there are constructors:

   number(arg1, precision);
   number(arg1, arg2, precision);

Where `precision` is an unsigned value, the 2 arg version is active for scalar types and/or copy-construction with specific precision, and the 3-arg version for complex types.

Likewise `assign` has a 2-arg overloaded, with the second argument being the precision.

      number& operator+=(const ``['see-below]``&);
      number& operator-=(const ``['see-below]``&);
      number& operator*=(const ``['see-below]``&);
      number& operator/=(const ``['see-below]``&);
      number& operator++();
      number& operator--();
      number  operator++(int);
      number  operator--(int);
      // Integer only operations:
      number& operator%=(const ``['see-below]``&);
      number& operator&=(const ``['see-below]``&);
      number& operator|=(const ``['see-below]``&);
      number& operator^=(const ``['see-below]``&);
      number& operator<<=(const ``['integer-type]``&);
      number& operator>>=(const ``['integer-type]``&);

These operators all take their usual arithmetic meanings.

The arguments to these operators is either:

* Another `number<Backend, ExpressionTemplates>`.
* An expression template derived from `number<Backend>`.
* Any type implicitly convertible to `number<Backend, ExpressionTemplates>`, including some other instance of class `number`.

For the left and right shift operations, the argument must be a __fundamental
integer type with a positive value (negative values result in a `std::runtime_error` being thrown).

      operator ``['convertible-to-bool-type]``()const;

Returns an ['unmentionable-type] that is usable in Boolean contexts (this allows `number` to be used in any
Boolean context - if statements, conditional statements, or as an argument to a logical operator - without
type `number` being convertible to type `bool`.

This operator also enables the use of `number` with any of the following operators:
`!`, `||`, `&&` and `?:`.

      void swap(number& other);

Swaps `*this` with `other`.

      bool is_zero()const;

Returns `true` is `*this` is zero, otherwise `false`.

      int sign()const;

Returns a value less than zero if `*this` is negative, a value greater than zero if `*this` is positive, and zero
if `*this` is zero.

      std::string str(unsigned precision, bool scientific = true)const;

Returns the number formatted as a string, with at least /precision/ digits, and in scientific format
if /scientific/ is true.

      template <class T>
      T convert_to()const;

      template <class T>
      explicit operator T ()const;

Provides a generic conversion mechanism to convert `*this` to type `T`.  Type `T` may be any arithmetic type.
Optionally other types may also be supported by specific `Backend` types.


      static unsigned default_precision();
      static void default_precision(unsigned digits10);
      unsigned precision()const;
      void precision(unsigned digits10);

These functions are only available if the Backend template parameter supports runtime changes to precision.  They get and set
the default precision and the precision of `*this` respectively.

      int compare(const number<Backend, ExpressionTemplates>& o)const;
      template <class V>
      typename std::enable_if<std::is_convertible<V, number<Backend, ExpressionTemplates>::value >, int>::type
         compare(const V& other)const;

Returns:

* A value less that 0 for `*this < other`
* A value greater that 0 for `*this > other`
* Zero for `*this == other`

      value_type real()const;
      value_type imag()const;

These return the real and imaginary parts respectively.  If the number is not a complex type, then the imaginary part is always zero.

      template <class T>
      void real(const T& val);
      template <class T>
      void imag(const T& val);

These set the real and imaginary parts respectively of the number.  If the number is not a complex type, then setting the real part
is equivalent to assignment, and attempting to set the imaginary part will result in a compile time error.

      Backend& backend();
      const Backend& backend()const;

Returns the underlying back-end instance used by `*this`.

[h4 Non-member operators]

   // Non member operators:
   ``['unmentionable-expression-template-type]`` operator+(const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator-(const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator+(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator-(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator*(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator/(const ``['see-below]``&, const ``['see-below]``&);
   // Integer only operations:
   ``['unmentionable-expression-template-type]`` operator%(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator&(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator|(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator^(const ``['see-below]``&, const ``['see-below]``&);
   ``['unmentionable-expression-template-type]`` operator<<(const ``['see-below]``&, const ``['integer-type]``&);
   ``['unmentionable-expression-template-type]`` operator>>(const ``['see-below]``&, const ``['integer-type]``&);
   // Comparison operators:
   bool operator==(const ``['see-below]``&, const ``['see-below]``&);
   bool operator!=(const ``['see-below]``&, const ``['see-below]``&);
   bool operator< (const ``['see-below]``&, const ``['see-below]``&);
   bool operator> (const ``['see-below]``&, const ``['see-below]``&);
   bool operator<=(const ``['see-below]``&, const ``['see-below]``&);
   bool operator>=(const ``['see-below]``&, const ``['see-below]``&);

These operators all take their usual arithmetic meanings.

The arguments to these functions must contain at least one of the following:

* A `number`.
* An expression template type derived from `number`.
* Any type for which `number` has an implicit constructor - for example a __fundamental arithmetic type.

The return type of these operators is either:

* An ['unmentionable-type] expression template type when `ExpressionTemplates` is `true`.
* Type `number<Backend, et_off>` when `ExpressionTemplates` is `false`.
* Type `bool` if the operator is a comparison operator.

Finally note that the second argument to the left and right shift operations must be a __fundamental integer type,
and that the argument must be positive (negative arguments result in a `std::runtime_error` being thrown).

[h4 swap]

   template <class Backend, ExpressionTemplates>
   void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b);

Swaps `a` and `b`.

[h4 Iostream Support]

   template <class Backend, expression_template_option ExpressionTemplates>
   std::ostream& operator << (std::ostream& os, const number<Backend, ExpressionTemplates>& r);
   template <class Unspecified...>
   std::ostream& operator << (std::ostream& os, const unmentionable-expression-template& r);
   template <class Backend, expression_template_option ExpressionTemplates>
   inline std::istream& operator >> (std::istream& is, number<Backend, ExpressionTemplates>& r)

These operators provided formatted input-output operations on `number` types, and expression templates derived from them.

It's down to the back-end type to actually implement string conversion.  However, the back-ends provided with
this library support all of the iostream formatting flags, field width and precision settings.

In addition, the C++11 `to_string` function is provided for use in generic code:

      template <class Backend, expression_template_option ExpressionTemplates>
      std::string to_string(const number<Backend, ExpressionTemplates>& val);

This a string with 6 digits of accuracy past the decimal point, matching the behavior of `std::to_string`.
Note that this is a /fixed precision/ representation, and hence monstrous strings can be returned.

[h4 Arithmetic with a higher precision result]

   template <class ResultType, class Source1 class Source2>
   ResultType& add(ResultType& result, const Source1& a, const Source2& b);

   template <class ResultType, class Source1 class Source2>
   ResultType& subtract(ResultType& result, const Source1& a, const Source2& b);

   template <class ResultType, class Source1 class Source2>
   ResultType& multiply(ResultType& result, const Source1& a, const Source2& b);

These functions apply the named operator to the arguments ['a] and ['b] and store the
result in ['result], returning ['result].  In all cases they behave "as if"
arguments ['a] and ['b] were first promoted to type `ResultType` before applying the
operator, though particular backends may well avoid that step by way of an optimization.

The type `ResultType` must be an instance of class `number`, and the types `Source1` and `Source2`
may be either instances of class `number` or native integer types.  The latter is an optimization
that allows arithmetic to be performed on native integer types producing an extended precision result.

[h4 Non-member standard library function support]

   ``['unmentionable-expression-template-type]``    abs        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    acos       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    acosh      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    asin       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    asinh      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    atan       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    atan2      (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``                                    atanh      (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    cbrt       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ceil       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    copysign   (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    cos        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    cosh       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    erf        (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    erfc       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    exp        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    exp2       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    expm1      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fabs       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fdim       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    floor      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fma        (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmin       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmax       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    fmod       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    frexp      (const ``['number-or-expression-template-type]``&, ``['integer-type]``*);
   ``['unmentionable-expression-template-type]``    hypot      (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['integer-type]``                              ilogb      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ldexp      (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['number]``                                    lgamma     (const ``['number-or-expression-template-type]``&);
   long long                                 llrint     (const ``['number-or-expression-template-type]``&);
   long long                                 llround    (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log2       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    log10      (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    log1p      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    logb       (const ``['number-or-expression-template-type]``&);
   long                                      lrint      (const ``['number-or-expression-template-type]``&);
   long                                      lround     (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    modf       (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    nearbyint  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    nextafter  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['number]``                                    nexttoward (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    pow        (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    remainder  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    remquo     (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&, int*);
   ``['unmentionable-expression-template-type]``    rint       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    round      (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    scalbn     (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['unmentionable-expression-template-type]``    scalbln    (const ``['number-or-expression-template-type]``&, ``['integer-type]``);
   ``['unmentionable-expression-template-type]``    sin        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    sinh       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    sqrt       (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    tan        (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    tanh       (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    tgamma     (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    trunc      (const ``['number-or-expression-template-type]``&);

   int                                       fpclassify (const ``['number-or-expression-template-type]``&);
   bool                                      isfinite   (const ``['number-or-expression-template-type]``&);
   bool                                      isinf      (const ``['number-or-expression-template-type]``&);
   bool                                      isnan      (const ``['number-or-expression-template-type]``&);
   bool                                      isnormal   (const ``['number-or-expression-template-type]``&);
   bool                                      signbit    (const ``['number-or-expression-template-type]``&);

   bool                                      isgreater  (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isgreaterequal(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isless     (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      islessequal(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      islessgreater(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);
   bool                                      isunordered(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

These functions all behave exactly as their standard library C++11 counterparts do: their argument is either an instance of `number` or
an expression template derived from it; If the argument is of type `number<Backend, et_off>` then that is also the return type,
otherwise the return type is an expression template unless otherwise stated.

The integer type arguments to `ldexp`, `frexp`, `scalbn` and `ilogb` may be either type `int`, or the actual
type of the exponent of the number type.

Complex number types support the following functions:

   // Complex number functions:
   ``['number<...>::value_type]``                   real  (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   imag  (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   abs   (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   arg   (const ``['number-or-expression-template-type]``&);
   ``['number<...>::value_type]``                   norm  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    conj  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    proj  (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    polar (const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

In addition the functions `real`, `imag`, `arg`, `norm`, `conj` and `proj` are overloaded for scalar (ie non-complex) types in the same
manner as `<complex>` and treat the argument as a value whose imaginary part is zero.

There are also some functions implemented for compatibility with the Boost.Math functions of the same name:

   ``['unmentionable-expression-template-type]``    itrunc (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    ltrunc (const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    lltrunc(const ``['number-or-expression-template-type]``&);
   ``['unmentionable-expression-template-type]``    iround (const ``['number-or-expression-template-type]``&);
   ``['number]``                                    changesign(const ``['number-or-expression-template-type]``&);
   ``['number]``                                    copysign(const ``['number-or-expression-template-type]``&, const ``['number-or-expression-template-type]``&);

All these functions are normally implemented by the Backend type.  However, default versions are provided for Backend types that
don't have native support for these functions.  Please note however, that this default support requires the precision of the type
to be a compile time constant - this means for example that the [gmp] MPF Backend will not work with these functions when that type is
used at variable precision.

Also note that with the exception of `abs` that these functions can only be used with floating-point Backend types (if any other types
such as fixed precision or complex types are added to the library later, then these functions may be extended to support those number types).

The precision of these functions is generally determined by the backend implementation.  For example the precision
of these functions when used with __mpfr_float_backend is determined entirely by [mpfr].  When these functions use our own
implementations, the accuracy of the transcendental functions is generally a few epsilon.  Note however, that the trigonometrical
functions incur the usual accuracy loss when reducing arguments by large multiples of [pi].  Also note that both __mpf_float
and __cpp_dec_float have a number of guard digits beyond their stated precision, so the error rates listed for these
are in some sense artificially low.

The following table shows the error rates we observe for these functions with various backend types, functions not listed
here are exact (tested on Win32 with VC++10, MPFR-3.0.0, MPIR-2.1.1):

[table
[[Function][mpfr_float_50][mpf_float_50][cpp_dec_float_50]]
[[sqrt][1eps][0eps][0eps]]
[[exp][1eps][0eps][0eps]]
[[log][1eps][0eps][0eps]]
[[log10][1eps][0eps][0eps]]
[[cos][700eps][0eps][0eps]]
[[sin][1eps][0eps][0eps]]
[[tan][0eps][0eps][0eps]]
[[acos][0eps][0eps][0eps]]
[[asin][0eps][0eps][0eps]]
[[atan][1eps][0eps][0eps]]
[[cosh][1045eps[footnote It's likely that the inherent error in the input values to our test cases are to blame here.]][0eps][0eps]]
[[sinh][2eps][0eps][0eps]]
[[tanh][1eps][0eps][0eps]]
[[pow][0eps][4eps][3eps]]
[[atan2][1eps][0eps][0eps]]
]
[h4 Traits Class Support]

   template <class T>
   struct component_type;

If this is a type with multiple components (for example rational or complex types), then this trait has a single member
`type` that is the type of those components.

   template <class T>
   struct number_category;

A traits class that inherits from `std::integral_constant<int, N>` where `N` is one of the enumerated values `number_kind_integer`, `number_kind_floating_point`,
`number_kind_rational`, `number_kind_fixed_point`, or `number_kind_unknown`.  This traits class is specialized for any type that has
`std::numeric_limits` support as well as for classes in this library: which means it can be used for generic code that must work
with __fundamental arithmetic types as well as multiprecision ones.

   template <class T>
   struct is_number;

A traits class that inherits from `std::integral_constant<bool, true>` if T is an instance of `number<>`, otherwise from `std::integral_constant<bool, false>`.

   template <class T>
   struct is_number_expression;

A traits class that inherits from `std::integral_constant<bool, true>` if T is an expression template type derived from `number<>`, otherwise from `std::integral_constant<bool, false>`.


[h4 Integer functions]

In addition to functioning with types from this library, these functions are also overloaded for __fundamental integer
types if you include `<boost/multiprecision/integer.hpp>`.  Further, when used with fixed precision types (whether
__fundamental integers or multiprecision ones), the functions will promote to a wider type internally when the algorithm
requires it.  Versions overloaded for __fundamental integer types return that integer type rather than an expression
template.

   ``['unmentionable-expression-template-type]``    gcd(const ``['number-or-expression-template-type]``& a, const ``['number-or-expression-template-type]``& b);

Returns the largest integer `x` that divides both `a` and `b`.

   ``['unmentionable-expression-template-type]``    lcm(const ``['number-or-expression-template-type]``& a, const ``['number-or-expression-template-type]``& b);

Returns the smallest integer `x` that is divisible by both `a` and `b`.

   ``['unmentionable-expression-template-type]``    pow(const ``['number-or-expression-template-type]``& b, unsigned p);

Returns ['b[super p]] as an expression template.  Note that this function should be used with extreme care as the result can grow so
large as to take "effectively forever" to compute, or else simply run the host machine out of memory.  This is the one function in
this category that is not overloaded for __fundamental integer types, further, it's probably not a good idea to use it with
fixed precision `cpp_int`'s either.

   ``['unmentionable-expression-template-type]``    powm(const ``['number-or-expression-template-type]``& b, const ``['number-or-expression-template-type]``& p, const ``['number-or-expression-template-type]``& m);

Returns ['b[super p] mod m] as an expression template.  Fixed precision types are promoted internally to ensure accuracy.

   ``['unmentionable-expression-template-type]``    sqrt(const ``['number-or-expression-template-type]``& a);

Returns the largest integer `x` such that `x * x < a`.

   template <class Backend, expression_template_option ExpressionTemplates>
   number<Backend, EXpressionTemplates>      sqrt(const ``['number-or-expression-template-type]``& a, number<Backend, EXpressionTemplates>& r);

Returns the largest integer `x` such that `x * x < a`, and sets the remainder `r` such that `r = a - x * x`.

   template <class Backend, expression_template_option ExpressionTemplates>
   void divide_qr(const ``['number-or-expression-template-type]``& x, const ``['number-or-expression-template-type]``& y,
                  number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r);

Divides x by y and returns both the quotient and remainder.  After the call `q = x / y` and `r = x % y`.

   template <class Integer>
   Integer integer_modulus(const ``['number-or-expression-template-type]``& x, Integer val);

Returns the absolute value of `x % val`.

   unsigned lsb(const ``['number-or-expression-template-type]``& x);

Returns the (zero-based) index of the least significant bit that is set to 1.

Throws a `std::range_error` if the argument is <= 0.

   unsigned msb(const ``['number-or-expression-template-type]``& x);

Returns the (zero-based) index of the most significant bit.

Throws a `std::range_error` if the argument is <= 0.

   template <class Backend, class ExpressionTemplates>
   bool bit_test(const number<Backend, ExpressionTemplates>& val, unsigned index);

Returns `true` if the bit at /index/ in /val/ is set.

   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_set(number<Backend, ExpressionTemplates>& val, unsigned index);

Sets the bit at /index/ in /val/, and returns /val/.

   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_unset(number<Backend, ExpressionTemplates>& val, unsigned index);

Unsets the bit at /index/ in /val/, and returns /val/.

   template <class Backend, class ExpressionTemplates>
   number<Backend, ExpressionTemplates>& bit_flip(number<Backend, ExpressionTemplates>& val, unsigned index);

Flips the bit at /index/ in /val/, and returns /val/.

   template <class Engine>
   bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials, Engine& gen);
   bool miller_rabin_test(const ``['number-or-expression-template-type]``& n, unsigned trials);

Tests to see if the number /n/ is probably prime - the test excludes the vast majority of composite numbers
by excluding small prime factors and performing a single Fermat test.  Then performs /trials/ Miller-Rabin
tests.  Returns `false` if /n/ is definitely composite, or `true` if /n/ is probably prime with the
probability of it being composite less than 0.25^trials.  Fixed precision types are promoted internally
to ensure accuracy.

[h4 Rational Number Functions]

   typename component_type<``['number-or-expression-template-type]``>::type numerator  (const ``['number-or-expression-template-type]``&);
   typename component_type<``['number-or-expression-template-type]``>::type denominator(const ``['number-or-expression-template-type]``&);

These functions return the numerator and denominator of a rational number respectively.

[h4 Boost.Math Interoperability Support]

   namespace boost{ namespace math{

   int  fpclassify     (const ``['number-or-expression-template-type]``&, int);
   bool isfinite       (const ``['number-or-expression-template-type]``&, int);
   bool isnan          (const ``['number-or-expression-template-type]``&, int);
   bool isinf          (const ``['number-or-expression-template-type]``&, int);
   bool isnormal       (const ``['number-or-expression-template-type]``&, int);

   }} // namespaces

These floating-point classification functions behave exactly as their Boost.Math equivalents.

Other Boost.Math functions and templates may also be
specialized or overloaded to ensure interoperability.

[h4 std::numeric_limits support]

   namespace std{

   template <class Backend, ExpressionTemplates>
   struct numeric_limits<boost::multiprecision<Backend, ExpressionTemplates> >
   {
      /* Usual members here */
   };

   }

Class template `std::numeric_limits` is specialized for all instantiations of `number` whose precision is known at compile time, plus those
types whose precision is unlimited (though it is much less useful in those cases).  It is not specialized for types
whose precision can vary at compile time (such as `mpf_float`).

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/reference_tom_int.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:tom_int_ref tom_int]

   namespace boost{ namespace multiprecision{

   class tommath_int;

   typedef number<tommath_int >         tom_int;

   }} // namespaces

Class template `tommath_int` fulfils all of the requirements for a [link boost_multiprecision.ref.backendconc Backend] type.
Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject
to change.

The type of `number_category<cpp_int<Args...> >::type` is `std::integral_constant<int, number_kind_integer>`.

More information on this type can be found in the [link boost_multiprecision.tut.ints.tom_int tutorial].

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:tut Tutorial]

In order to use this library you need to make two choices:

* What kind of number do I want ([link boost_multiprecision.tut.ints integer],
[link boost_multiprecision.tut.floats floating-point], [link boost_multiprecision.tut.rational rational], or [link boost_multiprecision.tut.complex complex]).
* Which back-end do I want to perform the actual arithmetic (Boost-supplied, GMP, MPFR, MPC, Tommath etc)?

[include tutorial_integer.qbk]
[include tutorial_floats.qbk]
[include tutorial_interval_mpfi.qbk]
[include tutorial_complex.qbk]
[include tutorial_rational.qbk]
[include tutorial_misc_backends.qbk]
[include tutorial_conversions.qbk]
[include tutorial_random.qbk]
[include tutorial_primality.qbk]
[include tutorial_constexpr.qbk]
[include tutorial_import_export.qbk]
[include tutorial_rounding.qbk]
[include tutorial_mixed_precision.qbk]
[include tutorial_variable_precision.qbk]
[include tutorial_integer_ops.qbk]
[include tutorial_serialization.qbk]
[include tutorial_numeric_limits.qbk]
[include tutorial_io.qbk]
[include tutorial_hash.qbk]
[include tutorial_eigen.qbk]
[include tutorial_new_backend.qbk]

[endsect] [/section:tut Tutorial]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_boost_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:tommath_rational tommath_rational]

`#include <boost/multiprecision/tommath.hpp>`

   namespace boost{ namespace multiprecision{

   typedef rational_adpater<tommath_int>        tommath_rational;
   typedef number<tommath_rational >         tom_rational;

   }} // namespaces

The `tommath_rational` back-end is used via the typedef `boost::multiprecision::tom_rational`.  It acts as a thin wrapper around
`boost::rational<tom_int>`
to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.

The advantage of using this type rather than `boost::rational<tom_int>` directly, is that it is expression-template enabled,
greatly reducing the number of temporaries created in complex expressions.

There are also non-member functions:

   tom_int numerator(const tom_rational&);
   tom_int denominator(const tom_rational&);

which return the numerator and denominator of the number.

Things you should know when using this type:

* Default constructed `tom_rational`s have the value zero (this the inherited Boost.Rational behavior).
* Division by zero results in a `std::overflow_error` being thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be
interpreted as a valid rational number.
* No changes are made to [tommath]'s global state, so this type can safely coexist with other [tommath] code.
* Performance of this type has been found to be pretty poor - this need further investigation - but it appears that Boost.Rational
needs some improvement in this area.

[h5 Example:]

[mp_rat_eg]

[endsect] [/section:tommath_rational tommath_rational]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_complex.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:complex Complex Number Types]

The following backends provide complex number arithmetic:

[table
[[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
[[`cpp_complex`][boost/multiprecision/cpp_complex.hpp][2][None][An all C++ Boost-licensed implementation.][Slower than [mpc].]]
[[`mpc`][boost/multiprecision/mpc.hpp][2][[mpc]][Very fast and efficient back-end.][Dependency on LGLP-licensed [MPC] library.]]
[[`complex128`][boost/multiprecision/complex128.hpp][2][`__float128` and libquadmath][Very fast and efficient number type.][128-bit precision only, and restricted to GCC.]]
[[`complex_adaptor`][boost/multiprecision/complex_adaptor.hpp][-][none][Can convert any backend type into a complex number backend.][Not a number in its own right, and hard to use as a result.]]
]

[include tutorial_cpp_complex.qbk]
[include tutorial_mpc_complex.qbk]
[include tutorial_float128_complex.qbk]
[include tutorial_complex_adaptor.qbk]

[endsect] [/section:complex Complex Number Types]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_complex_adaptor.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:complex_adaptor complex_adaptor]

   namespace boost{ namespace multiprecision{

   template <class Backend>
   struct complex_adaptor;

   }}

Class template `complex_adaptor` is designed to sit inbetween class `number` and an actual floating point backend,
in order to create a new complex number type.

It is the means by which we implement __cpp_complex and __complex128.

[endsect] [/section:complex_adaptor complex_adaptor]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_constexpr.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:lits Literal Types and `constexpr` Support]

There are two kinds of `constexpr` support in this library:

* The more basic version requires only C++11 and allow the construction of some number types as literals.
* The more advanced support permits constexpr arithmetic and requires at least C++14 
constexpr support, and for many operations C++2a support

[h4 Declaring numeric literals]

There are two backend types which are literals:

* __float128__ (which requires GCC), and
* Instantiations of `cpp_int_backend` where the Allocator parameter is type `void`.
In addition, prior to C++14 the Checked parameter must be `boost::multiprecision::unchecked`.

For example:

   using namespace boost::multiprecision;

   constexpr float128            f = 0.1Q   // OK, float128's are always literals in C++11

   constexpr int128_t            i = 0;     // OK, fixed precision int128_t has no allocator.
   constexpr uint1024_t          j = 0xFFFFFFFF00000000uLL;  // OK, fixed precision uint1024_t has no allocator.

   constexpr checked_uint128_t   k = 1; // OK from C++14 and later, not supported for C++11.
   constexpr checked_uint128_t   k = -1; // Error, as this would normally lead to a runtime failure (exception).
   constexpr cpp_int             l = 2;  // Error, type is not a literal as it performs memory management.

There is also support for user defined-literals with __cpp_int - these are limited to unchecked, fixed precision `cpp_int`'s
which are specified in hexadecimal notation.  The suffixes supported are:

[table
[[Suffix][Meaning]]
[[_cppi][Specifies a value of type: `number<cpp_int_backend<N,N,signed_magnitude,unchecked,void> >`, where N is chosen
to contain just enough digits to hold the number specified.]]
[[_cppui][Specifies a value of type: `number<cpp_int_backend<N,N,unsigned_magnitude,unchecked,void> >`, where N is chosen
to contain just enough digits to hold the number specified.]]
[[_cppi['N]][Specifies a value of type `number<cpp_int_backend<N,N,signed_magnitude,unchecked,void> >`.]]
[[_cppui['N]][Specifies a value of type `number<cpp_int_backend<N,N,signed_magnitude,unchecked,void> >`.]]
]

In each case, use of these suffixes with hexadecimal values produces a `constexpr` result.

Examples:

   // Any use of user defined literals requires that we import the literal-operators into current scope first:
   using namespace boost::multiprecision::literals;
   //
   // To keep things simple in the example, we'll make our types used visible to this scope as well:
   using namespace boost::multiprecision;
   //
   // The value zero as a number<cpp_int_backend<4,4,signed_magnitude,unchecked,void> >:
   constexpr auto a = 0x0_cppi;
   // The type of each constant has 4 bits per hexadecimal digit,
   // so this is of type uint256_t (ie number<cpp_int_backend<256,256,unsigned_magnitude,unchecked,void> >):
   constexpr auto b = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui;
   //
   // Smaller values can be assigned to larger values:
   int256_t c = 0x1234_cppi; // OK
   //
   // However, this only works in constexpr contexts from C++14 onwards:
   constexpr int256_t d = 0x1_cppi; // Compiler error in C++11, requires C++14
   //
   // Constants can be padded out with leading zeros to generate wider types:
   constexpr uint256_t e = 0x0000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFF_cppui; // OK
   //
   // However, specific-width types are best produced with specific-width suffixes,
   // ones supported by default are `_cpp[u]i128`, `_cpp[u]i256`, `_cpp[u]i512`, `_cpp[u]i1024`.
   //
   constexpr int128_t f = 0x1234_cppi128; // OK, always produces an int128_t as the result.
   constexpr uint1024_t g = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccc_cppui1024; // OK,
   //  always produces an uint1024_t as the result.
   //
   // If other specific-width types are required, then there is a macro for generating the operators for these.
   // The macro can be used at namespace scope only:
   //
   BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(2048);
   //
   // Now we can create 2048-bit literals as well:
   constexpr auto h = 0xff_cppi2048; // h is of type number<cpp_int_backend<2048,2048,signed_magnitude,unchecked,void> >
   //
   // Finally, negative values are handled via the unary minus operator:
   //
   constexpr int1024_t i = -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui1024;
   //
   // Which means this also works:
   constexpr int1024_t j = -g;   // OK: unary minus operator is constexpr.

[h4 constexpr arithmetic]

The front end of the library is all `constexpr` from C++14 and later.  Currently there are only two
backend types that are `constexpr` aware: __float128 and __cpp_int.  More backends will follow at a later date.

Provided the compiler is GCC, type __float128__ support `constexpr` operations on all arithmetic operations from C++14, comparisons,
`abs`, `fabs`, `fpclassify`, `isnan`, `isinf`, `isfinite` and `isnormal` are also fully supported, but the transcendental functions are not.

The __cpp_int types support constexpr arithmetic, provided it is a fixed precision type with no allocator.  It may also
be a checked integer: in which case a compiler error will be generated on overflow or undefined behaviour.  In addition
the free functions `abs`, `swap`, `multiply`, `add`, `subtract`, `divide_qr`, `integer_modulus`, `powm`, `lsb`, `msb`, 
`bit_test`, `bit_set`, `bit_unset`, `bit_flip`, `sqrt`, `gcd`, `lcm` are all supported.  Use of __cpp_int in this way
requires either a C++2a compiler (one which supports `std::is_constant_evaluated()` - currently only gcc-9 or clang-9 or later), 
or GCC-6 or later in C++14 mode.
Compilers other than GCC and without `std::is_constant_evaluated()` will support a very limited set of operations:
expect to hit roadblocks rather easily.

See __compiler_support for __is_constant_evaluated;

For example given:

[constexpr_circle]

We can now calculate areas and circumferences, using all compile-time `constexpr` arithmetic:

[constexpr_circle_usage]

Note that these make use of the numeric constants from the __math_constants library, which also happen to be `constexpr`. 
These usually have the full precision of the floating-point type, here 128-bit, about 36 decimal digits.

[h5:hermite_poly_coeffics Calculating Hermite Polynomial coefficients at compile time]

For a more interesting example, in [@../../example/constexpr_float_arithmetic_examples.cpp constexpr_float_arithmetic_examples.cpp]
we define a simple class for `constexpr` polynomial arithmetic:

   template <class T, unsigned Order>
   struct const_polynomial;

Given this, we can use recurrence relations to calculate the coefficients for various orthogonal
polynomials - in the example we use the Hermite polynomials. Only the constructor does any work - 
it uses the recurrence relations to calculate the coefficient array:

[hermite_example]

Now we just need to define ['H[sub 0]] and ['H[sub 1]] as termination conditions for the recurrence:

[hermite_example2]

We can now declare ['H[sub 9]] as a `constexpr` object, access the coefficients, and evaluate
at an abscissa value, all at compile-time using `constexpr` arithmetic:

[hermite_example3]

See [@../../example/constexpr_float_arithmetic_examples.cpp constexpr_float_arithmetic_examples.cpp] for working code.

Also since the coefficients to the Hermite polynomials are integers, we can also generate the Hermite
coefficients using (fixed precision) `cpp_int`s: see [@../../test/constexpr_test_cpp_int_6.cpp constexpr_test_cpp_int_6.cpp].

[h5:factorial_constexpr `constexpr` Factorials]

We can also generate integer factorials in [@../../test/constexpr_test_cpp_int_5.cpp constexpr_test_cpp_int_5.cpp] like so:

[factorial_decl]

and validate the result:
 
  constexpr uint1024_t f1 = factorial(uint1024_t(31)); // Factorial 31!
  static_assert(f1 == 0x1956ad0aae33a4560c5cd2c000000_cppi); // Expected result as an Boost.Multiprecision integer literal. 
  
[h5:random_constexpr Random `constexpr` values] 

Another example in [@../../test/constexpr_test_cpp_int_7.cpp constexpr_test_cpp_int_7.cpp] generates
a fresh multiprecision random number each time the file is compiled.  It includes an C++ template implementation of the 
[@https://en.wikipedia.org/wiki/KISS_(algorithm) KISS random number algorithm by George Marsaglia] for `cpp_int` integers.

[random_constexpr_cppint]

See also the __random section.

[endsect] [/section:lits Literal Types and `constexpr` Support]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_conversions.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:conversions Constructing and Interconverting Between Number Types]

All of the number types that are based on `number` have certain conversion rules in common.
In particular:

* Any number type can be constructed (or assigned) from any __fundamental arithmetic type, as long
  as the conversion isn't lossy (for example float to int conversion):

   cpp_dec_float_50 df(0.5);   // OK construction from double
   cpp_int          i(450);    // OK constructs from signed int
   cpp_int          j = 3.14;  // Error, lossy conversion.

* A number can be explicitly constructed from an arithmetic type, even when the conversion is lossy:

   cpp_int          i(3.14);       // OK explicit conversion
   i = static_cast<cpp_int>(3.14)  // OK explicit conversion
   i.assign(3.14);                 // OK, explicit assign and avoid a temporary from the cast above
   i = 3.14;                       // Error, no implicit assignment operator for lossy conversion.
   cpp_int          j = 3.14;      // Error, no implicit constructor for lossy conversion.

* A `number` can be converted to any __fundamental type, via the `convert_to` member function:

   mpz_int z(2);
   int i = z.convert_to<int>(); // sets i to 2

* Conversions to rational numbers from floating-point ones are always allowed, and are exact and implicit
as long as the rational number uses an unbounded integer type.  Please be aware that constructing a rational
number from an extended precision floating-point type with a large exponent range can effectively run the system
out of memory, as in the extreme case ['2[super max_exponent] / CHAR_BITS] bytes of storage may be required.  This
does not represent a problem for __fundamental floating-point types however, as the exponent range for these is rather
limited.

* Conversions to floating-point numbers from rational ones are rounded to nearest (less than 0.5 __ULP error)
as long as the floating-point number is binary, and the integer type used by the rational number is unbounded.

Additional conversions may be supported by particular backends.

* A `number` can be converted to any __fundamental type, via an explicit conversion operator:
this functionality is only available on compilers supporting C++11's explicit conversion syntax.

   mpz_int z(2);
   int i = z;                     // Error, implicit conversion not allowed.
   int j = static_cast<int>(z);   // OK explicit conversion.

* Any number type can be ['explicitly] constructed (or assigned) from a `const char*` or a `std::string`:

   // pi to 50 places from a string:
   cpp_dec_float_50 df("3.14159265358979323846264338327950288419716939937510");
   // Integer type will automatically detect "0x" and "0" prefixes and parse the string accordingly:
   cpp_int          i("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000");
   // Invalid input always results in a std::runtime_error being thrown:
   i = static_cast<cpp_int>("3.14");
   // implicit conversions from strings are not allowed:
   i = "23"; // Error, no assignment operator for implicit conversion from string
   // assign member function, avoids having to create a temporary via a static_cast:
   i.assign("23");  // OK

* Any number type will interoperate with the __fundamental types in arithmetic expressions as long as the conversions
are not lossy:

   // pi to 50 places from a string:
   cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
   // Multiply by 2 - using an integer literal here is usually more efficient
   // than constructing a temporary:
   df *= 2;

   // You can't mix integer types with floats though:
   cpp_int i = 2;
   i *= 3.14;  // Error, no *= operator will be found.

* Any number type can be streamed to and from the C++ iostreams:

   cpp_dec_float_50 df = "3.14159265358979323846264338327950288419716939937510";
   // Now print at full precision:
   std::cout << std::setprecision(std::numeric_limits<cpp_dec_float_50>::max_digits10)
      << df << std::endl
   cpp_int i = 1;
   i <<= 256;
   // Now print in hex format with prefix:
   std::cout << std::hex << std::showbase << i << std::endl;

* Interconversions between number types of the same family are allowed and are implicit conversions if no
loss of precision is involved, and explicit if it is:

   int128_t     i128 = 0;
   int266_t     i256 = i128;  // OK implicit widening conversion
   i128_t            = i256;  // Error, no assignment operator found, narrowing conversion is explicit.
   i128_t            = static_cast<int128_t>(i256); // OK, explicit narrowing conversion.

   mpz_int      z    = 0;
   mpf_float    f    = z;    // OK, GMP handles this conversion natively, and it's not lossy and therefore implicit.

   mpf_float_50 f50  = 2;
   f                 = f50;  // OK, conversion from fixed to variable precision, f will have 50 digits precision.
   f50               = f;    // Error, conversion from variable to fixed precision is potentially lossy, explicit cast required.

* Some interconversions between number types are completely generic, and are always available, albeit the conversions are always ['explicit]:

   cpp_int cppi(2);
   // We can always convert between numbers of the same category -
   // int to int, rational to rational, or float to float, so this is OK
   // as long as we use an explicit conversion:
   mpz_int z(cppi);
   // We can always promote from int to rational, int to float, or rational to float:
   cpp_rational     cppr(cppi);  // OK, int to rational
   cpp_dec_float_50 df(cppi);    // OK, int to float
   df                  = static_cast<cpp_dec_float_50>(cppr);  // OK, explicit rational to float conversion
   // However narrowing and/or implicit conversions always fail:
   cppi                =   df;    // Compiler error, conversion not allowed

* Other interconversions may be allowed as special cases, whenever the backend allows it:

   mpf_t     m;           // Native GMP type.
   mpf_init_set_ui(m, 0); // set to a value;
   mpf_float i(m);        // copies the value of the native type.

More information on what additional types a backend supports conversions from are given in the tutorial for each backend.
The converting constructor will be implicit if the backend's converting constructor is also implicit, and explicit if the
backends converting constructor is also explicit.

[endsect] [/section:conversions Constructing and Interconverting Between Number Types]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_cpp_bin_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_bin_float cpp_bin_float]

`#include <boost/multiprecision/cpp_bin_float.hpp>`

   namespace boost{ namespace multiprecision{

   enum digit_base_type
   {
      digit_base_2 = 2,
      digit_base_10 = 10
   };

   template <unsigned Digits, digit_base_type base = digit_base_10, class Allocator = void, class Exponent = int, ExponentMin = 0, ExponentMax = 0>
   class cpp_bin_float;

   typedef number<cpp_bin_float<50> > cpp_bin_float_50;
   typedef number<cpp_bin_float<100> > cpp_bin_float_100;

   typedef number<backends::cpp_bin_float<24, backends::digit_base_2, void, std::int16_t, -126, 127>, et_off>         cpp_bin_float_single;
   typedef number<backends::cpp_bin_float<53, backends::digit_base_2, void, std::int16_t, -1022, 1023>, et_off>       cpp_bin_float_double;
   typedef number<backends::cpp_bin_float<64, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>     cpp_bin_float_double_extended;
   typedef number<backends::cpp_bin_float<113, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>    cpp_bin_float_quad;
   typedef number<backends::cpp_bin_float<237, backends::digit_base_2, void, std::int32_t, -262142, 262143>, et_off>  cpp_bin_float_oct;

   }} // namespaces

The `cpp_bin_float` back-end is used in conjunction with `number`: It acts as an entirely C++ (header only and dependency free)
floating-point number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

Type `cpp_bin_float` can be used at fixed precision by specifying a non-zero `Digits` template parameter.
The typedefs `cpp_bin_float_50` and `cpp_bin_float_100` provide arithmetic types at 50 and 100 decimal digits precision
respectively.

Optionally, you can specify whether the precision is specified in decimal digits or binary bits - for example
to declare a `cpp_bin_float` with exactly the same precision as `double` one would use
`number<cpp_bin_float<53, digit_base_2> >`.  The typedefs `cpp_bin_float_single`, `cpp_bin_float_double`,
`cpp_bin_float_quad`, `cpp_bin_float_oct` and `cpp_bin_float_double_extended` provide
software analogues of the IEEE single, double, quad and octuple float data types, plus the Intel-extended-double type respectively.
Note that while these types are functionally equivalent to the native IEEE types, but they do not have the same size
or bit-layout as true IEEE compatible types.

Normally `cpp_bin_float` allocates no memory: all of the space required for its digits are allocated
directly within the class.  As a result care should be taken not to use the class with too high a digit count
as stack space requirements can grow out of control.  If that represents a problem then providing an allocator
as a template parameter causes `cpp_bin_float` to dynamically allocate the memory it needs: this
significantly reduces the size of `cpp_bin_float` and increases the viable upper limit on the number of digits
at the expense of performance.  However, please bear in mind that arithmetic operations rapidly become ['very] expensive
as the digit count grows: the current implementation really isn't optimized or designed for large digit counts.
Note that since the actual type of the objects allocated
is completely opaque, the suggestion would be to use an allocator with `void` `value_type`, for example:
`number<cpp_bin_float<1000, digit_base_10, std::allocator<void> > >`.

The final template parameters determine the type and range of the exponent: parameter `Exponent` can be
any signed integer type, but note that `MinExponent` and `MaxExponent` can not go right up to the limits
of the `Exponent` type as there has to be a little extra headroom for internal calculations.  You will
get a compile time error if this is the case.  In addition if MinExponent or MaxExponent are zero, then
the library will choose suitable values that are as large as possible given the constraints of the type
and need for extra headroom for internal calculations.

There is full standard library and `numeric_limits` support available for this type.

Things you should know when using this type:

* Default constructed `cpp_bin_float`s have a value of zero.
* The radix of this type is 2, even when the precision is specified as decimal digits.
* The type supports both infinities and NaNs.  An infinity is generated whenever the result would overflow,
and a NaN is generated for any mathematically undefined operation.
* There is a `std::numeric_limits` specialisation for this type.
* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
for example you can convert from `number<cpp_bin_float<50> >` to `number<cpp_bin_float<SomeOtherValue> >`.
Narrowing conversions round to nearest and are `explicit`.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* All arithmetic operations are correctly rounded to nearest.  String conversions and the `sqrt` function
are also correctly rounded, but transcendental functions (sin, cos, pow, exp etc) are not.

[h5 cpp_bin_float example:]

[cpp_bin_float_eg]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_cpp_complex.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_complex cpp_complex]

`#include <boost/multiprecision/cpp_complex.hpp>`

   namespace boost{ namespace multiprecision{

      template <unsigned Digits, backends::digit_base_type DigitBase = backends::digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0>
      using cpp_complex_backend = complex_adaptor<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> >;

      template <unsigned Digits, backends::digit_base_type DigitBase = digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0, expression_template_option ExpressionTemplates = et_off>
      using cpp_complex = number<complex_adaptor<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> >, ExpressionTemplates>;

      typedef cpp_complex<50> cpp_complex_50;
      typedef cpp_complex<100> cpp_complex_100;

      typedef cpp_complex<24, backends::digit_base_2, void, std::int16_t, -126, 127> cpp_complex_single;
      typedef cpp_complex<53, backends::digit_base_2, void, std::int16_t, -1022, 1023> cpp_complex_double;
      typedef cpp_complex<64, backends::digit_base_2, void, std::int16_t, -16382, 16383> cpp_complex_extended;
      typedef cpp_complex<113, backends::digit_base_2, void, std::int16_t, -16382, 16383> cpp_complex_quad;
      typedef cpp_complex<237, backends::digit_base_2, void, std::int32_t, -262142, 262143> cpp_complex_oct;


   }} // namespaces

The `cpp_complex_backend` back-end is used in conjunction with `number`: It acts as an entirely C++ (header only and dependency free)
complex number type that is a drop-in replacement for `std::complex`, but with much greater precision.

The template alias `cpp_complex` avoids the need to use class `number` directly.

Type `cpp_complex` can be used at fixed precision by specifying a non-zero `Digits` template parameter.
The typedefs `cpp_complex_50` and `cpp_complex_100` provide complex number types at 50 and 100 decimal digits precision
respectively.

Optionally, you can specify whether the precision is specified in decimal digits or binary bits - for example
to declare a `cpp_complex` with exactly the same precision as `std::complex<double>` one would use
`cpp_complex<53, digit_base_2>`.  The typedefs `cpp_complex_single`, `cpp_complex_double`,
`cpp_complex_quad`, `cpp_complex_oct` and `cpp_complex_double_extended` provide
software analogues of the IEEE single, double, quad and octuple float data types, plus the Intel-extended-double type respectively.
Note that while these types are functionally equivalent to the native IEEE types, but they do not have the same size
or bit-layout as true IEEE compatible types.

Normally `cpp_complex` allocates no memory: all of the space required for its digits are allocated
directly within the class.  As a result care should be taken not to use the class with too high a digit count
as stack space requirements can grow out of control.  If that represents a problem then providing an allocator
as a template parameter causes `cpp_complex` to dynamically allocate the memory it needs: this
significantly reduces the size of `cpp_complex` and increases the viable upper limit on the number of digits
at the expense of performance.  However, please bear in mind that arithmetic operations rapidly become ['very] expensive
as the digit count grows: the current implementation really isn't optimized or designed for large digit counts.
Note that since the actual type of the objects allocated
is completely opaque, the suggestion would be to use an allocator with `char` `value_type`, for example:
`cpp_complex<1000, digit_base_10, std::allocator<char> >`.

The next template parameters determine the type and range of the exponent: parameter `Exponent` can be
any signed integer type, but note that `MinExponent` and `MaxExponent` can not go right up to the limits
of the `Exponent` type as there has to be a little extra headroom for internal calculations.  You will
get a compile time error if this is the case.  In addition if MinExponent or MaxExponent are zero, then
the library will choose suitable values that are as large as possible given the constraints of the type
and need for extra headroom for internal calculations.

Finally, as with class `number`, the final template parameter determines whether expression templates are turn
on or not.  Since by default this type allocates no memory, expression template support is off by default.
However, you should probably turn it on if you specify an allocator.

There is full standard library support available for this type, comparable with what `std::complex` provides.

Things you should know when using this type:

* Default constructed `cpp_complex`s have a value of zero.
* The radix of this type is 2, even when the precision is specified as decimal digits.
* The type supports both infinities and NaNs.  An infinity is generated whenever the result would overflow,
and a NaN is generated for any mathematically undefined operation.
* There is no `std::numeric_limits` specialisation for this type: this is the same behaviour as `std::complex`.  If you need
`std::numeric_limits` support you need to look at `std::numeric_limits<my_complex_number_type::value_type>`.
* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
for example you can convert from `number<cpp_complex<50> >` to `number<cpp_bin_float<SomeOtherValue> >`.
Narrowing conversions round to nearest and are `explicit`.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid complex number.

[h5 example:]

[cpp_complex_eg]

Which produces the output (for the multiprecision type):

[cpp_complex_out]

[endsect] [/section:complex Complex Number Types]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_cpp_dec_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_dec_float cpp_dec_float]

`#include <boost/multiprecision/cpp_dec_float.hpp>`

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10, class ExponentType = std::int32_t, class Allocator = void>
   class cpp_dec_float;

   typedef number<cpp_dec_float<50> > cpp_dec_float_50;
   typedef number<cpp_dec_float<100> > cpp_dec_float_100;

   }} // namespaces

The `cpp_dec_float` back-end is used in conjunction with `number`: It acts as an entirely C++ (header only and dependency free)
floating-point number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

Type `cpp_dec_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter.
The typedefs `cpp_dec_float_50` and `cpp_dec_float_100` provide arithmetic types at 50 and 100 decimal digits precision
respectively.  Optionally, you can specify an integer type to use for the exponent, this defaults to a 32-bit integer type
which is more than large enough for the vast majority of use cases, but larger types such as `long long` can also be specified
if you need a truly huge exponent range.  In any case the ExponentType must be a __fundamental signed integer type at least 2 bytes
and 16-bits wide.

Normally `cpp_dec_float` allocates no memory: all of the space required for its digits are allocated
directly within the class.  As a result care should be taken not to use the class with too high a digit count
as stack space requirements can grow out of control.  If that represents a problem then providing an allocator
as the final template parameter causes `cpp_dec_float` to dynamically allocate the memory it needs: this
significantly reduces the size of `cpp_dec_float` and increases the viable upper limit on the number of digits
at the expense of performance.  However, please bear in mind that arithmetic operations rapidly become ['very] expensive
as the digit count grows: the current implementation really isn't optimized or designed for large digit counts.

There is full standard library and `std::numeric_limits` support available for this type.

Things you should know when using this type:

* Default constructed `cpp_dec_float`s have a value of zero.
* The radix of this type is 10.  As a result it can behave subtly differently from base-2 types.
* The type has a number of internal guard digits over and above those specified in the template argument.
Normally these should not be visible to the user.
* The type supports both infinities and NaNs.  An infinity is generated whenever the result would overflow,
and a NaN is generated for any mathematically undefined operation.
* There is a `std::numeric_limits` specialisation for this type.
* Any `number` instantiated on this type, is convertible to any other `number` instantiated on this type -
for example you can convert from `number<cpp_dec_float<50> >` to `number<cpp_dec_float<SomeOtherValue> >`.
Narrowing conversions are truncating and `explicit`.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* The actual precision of a `cpp_dec_float` is always slightly higher than the number of digits specified in
the template parameter, actually how much higher is an implementation detail but is always at least 8 decimal
digits.
* Operations involving `cpp_dec_float` are always truncating.  However, note that since there are guard digits
in effect, in practice this has no real impact on accuracy for most use cases.

[h5 cpp_dec_float example:]

[cpp_dec_float_eg]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_cpp_int.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_int cpp_int]

`#include <boost/multiprecision/cpp_int.hpp>`

   namespace boost{ namespace multiprecision{

   typedef unspecified-type limb_type;

   enum cpp_integer_type    { signed_magnitude, unsigned_magnitude };
   enum cpp_int_check_type  { checked, unchecked };

   template <std::size_t MinBits = 0,
             std::size_t MaxBits = 0,
             cpp_integer_type SignType = signed_magnitude,
             cpp_int_check_type Checked = unchecked,
             class Allocator = std::allocator<limb_type> >
   class cpp_int_backend;
   //
   // Expression templates default to et_off if there is no allocator:
   //
   template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked>
   struct expression_template_default<cpp_int_backend<MinBits, MaxBits, SignType, Checked, void> >
   { static const expression_template_option value = et_off; };

   typedef number<cpp_int_backend<> >              cpp_int;    // arbitrary precision integer
   typedef rational_adaptor<cpp_int_backend<> >    cpp_rational_backend;
   typedef number<cpp_rational_backend>            cpp_rational; // arbitrary precision rational number

   // Fixed precision unsigned types:
   typedef number<cpp_int_backend<128, 128, unsigned_magnitude, unchecked, void> >   uint128_t;
   typedef number<cpp_int_backend<256, 256, unsigned_magnitude, unchecked, void> >   uint256_t;
   typedef number<cpp_int_backend<512, 512, unsigned_magnitude, unchecked, void> >   uint512_t;
   typedef number<cpp_int_backend<1024, 1024, unsigned_magnitude, unchecked, void> > uint1024_t;

   // Fixed precision signed types:
   typedef number<cpp_int_backend<128, 128, signed_magnitude, unchecked, void> >     int128_t;
   typedef number<cpp_int_backend<256, 256, signed_magnitude, unchecked, void> >     int256_t;
   typedef number<cpp_int_backend<512, 512, signed_magnitude, unchecked, void> >     int512_t;
   typedef number<cpp_int_backend<1024, 1024, signed_magnitude, unchecked, void> >   int1024_t;

   // Over again, but with checking enabled this time:
   typedef number<cpp_int_backend<0, 0, signed_magnitude, checked> >                 checked_cpp_int;
   typedef rational_adaptor<cpp_int_backend<0, 0, signed_magnitude, checked> >       checked_cpp_rational_backend;
   typedef number<cpp_rational_backend>                                              checked_cpp_rational;

   // Checked fixed precision unsigned types:
   typedef number<cpp_int_backend<128, 128, unsigned_magnitude, checked, void> >     checked_uint128_t;
   typedef number<cpp_int_backend<256, 256, unsigned_magnitude, checked, void> >     checked_uint256_t;
   typedef number<cpp_int_backend<512, 512, unsigned_magnitude, checked, void> >     checked_uint512_t;
   typedef number<cpp_int_backend<1024, 1024, unsigned_magnitude, checked, void> >   checked_uint1024_t;

   // Fixed precision signed types:
   typedef number<cpp_int_backend<128, 128, signed_magnitude, checked, void> >       checked_int128_t;
   typedef number<cpp_int_backend<256, 256, signed_magnitude, checked, void> >       checked_int256_t;
   typedef number<cpp_int_backend<512, 512, signed_magnitude, checked, void> >       checked_int512_t;
   typedef number<cpp_int_backend<1024, 1024, signed_magnitude, checked, void> >     checked_int1024_t;

   }} // namespaces

The `cpp_int_backend` type is normally used via one of the convenience typedefs given above.

This back-end is the "Swiss Army Knife" of integer types as it can represent both fixed and
[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision]
integer types, and both signed and unsigned types.  There are five template arguments:

[variablelist
[[MinBits][Determines the number of Bits to store directly within the object before resorting to dynamic memory
           allocation.  When zero, this field is determined automatically based on how many bits can be stored
           in union with the dynamic storage header: setting a larger value may improve performance as larger integer
           values will be stored internally before memory allocation is required.]]
[[MaxBits][Determines the maximum number of bits to be stored in the type: resulting in a fixed precision type.
           When this value is the same as MinBits, then the Allocator parameter is ignored, as no dynamic
           memory allocation will ever be performed: in this situation the Allocator parameter should be set to
           type `void`.  Note that this parameter should not be used simply to prevent large memory
           allocations, not only is that role better performed by the allocator, but fixed precision
           integers have a tendency to allocate all of MaxBits of storage more often than one would expect.]]
[[SignType][Determines whether the resulting type is signed or not.  Note that for
[@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] types
          this parameter must be `signed_magnitude`.  For fixed precision
          types then this type may be either `signed_magnitude` or `unsigned_magnitude`.]]
[[Checked][This parameter has two values: `checked` or `unchecked`.  See below.]]
[[Allocator][The allocator to use for dynamic memory allocation, or type `void` if MaxBits == MinBits.]]
]

When the template parameter Checked is set to `checked` then the result is a ['checked-integer], checked
and unchecked integers have the following properties:

[table
[[Condition][Checked-Integer][Unchecked-Integer]]
[[Numeric overflow in fixed precision arithmetic][Throws a `std::overflow_error`.][Performs arithmetic modulo 2[super MaxBits]]]
[[Constructing an integer from a value that can not be represented in the target type][Throws a `std::range_error`.]
[Converts the value modulo 2[super MaxBits], signed to unsigned conversions extract the last MaxBits bits of the
2's complement representation of the input value.]]
[[Unsigned subtraction yielding a negative value.][Throws a `std::range_error`.][Yields the value that would
result from treating the unsigned type as a 2's complement signed type.]]
[[Attempting a bitwise operation on a negative value.][Throws a `std::range_error`][Yields the value, but not the bit pattern,
that would result from performing the operation on a 2's complement integer type.]]
]

Things you should know when using this type:

* Default constructed `cpp_int_backend`s have the value zero.
* Division by zero results in a `std::overflow_error` being thrown.
* Construction from a string that contains invalid non-numeric characters results in a `std::runtime_error` being thrown.
* Since the precision of `cpp_int_backend` is necessarily limited when the allocator parameter is void,
care should be taken to avoid numeric overflow when using this type
unless you actually want modulo-arithmetic behavior.
* The type uses a sign-magnitude representation internally, so type `int128_t` has 128-bits of precision plus an extra sign bit.
In this respect the behaviour of these types differs from __fundamental 2's complement types.  In might be tempting to use a
127-bit type instead, and indeed this does work, but behaviour is still slightly different from a 2's complement __fundamental type
as the minimum and maximum values are identical (apart from the sign), where as they differ by one for a true 2's complement type.
That said it should be noted that there's no requirement for fundamental_types to be 2's complement either - it's simply that this
is the most common format by far.
* Attempting to print negative values as either an Octal or Hexadecimal string results in a `std::runtime_error` being thrown,
this is a direct consequence of the sign-magnitude representation.
* The fixed precision types `[checked_][u]intXXX_t` have expression template support turned off - it seems to make little
difference to the performance of these types either way - so we may as well have the faster compile times by turning
the feature off.
* Unsigned types support subtraction - the result is "as if" a 2's complement operation had been performed as long as they are not
 ['checked-integers] (see above).
 In other words they behave pretty much as a __fundamental integer type would in this situation.  So for example if we were using
 `uint128_t` then `uint128_t(1)-4` would result in the value `0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD`
 of type `uint128_t`.  However, had this operation been performed on `checked_uint128_t` then a `std::range_error` would have
 been thrown.
* Unary negation of unsigned types results in a compiler error (static assertion).
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* When used at fixed precision, the size of this type is always one machine word (plus any compiler-applied alignment padding) 
larger than you would expect for an N-bit integer:
the extra word stores both the sign, and how many machine words in the integer are actually in use.
The latter is an optimisation for larger fixed precision integers, so that a 1024-bit integer has almost the same performance
characteristics as a 128-bit integer, rather than being 4 times slower for addition and 16 times slower for multiplication
 (assuming the values involved would always fit in 128 bits).
Typically this means you can use
an integer type wide enough for the "worst case scenario" with only minor performance degradation even if most of the time
the arithmetic could in fact be done with a narrower type.
Also note that unsigned fixed precision types small enough to fit inside the largest native integer become a simple wrapper around that type,
this includes the "checked" variants.  Small signed types will always have an extra sign word and so be larger than their native equivalent.
* When used at fixed precision and MaxBits is smaller than the number of bits in the largest native integer type, then
internally `cpp_int_backend` switches to a "trivial" implementation where it is just a thin wrapper around a single
integer.  Note that it will still be slightly slower than a bare native integer, as it emulates a
signed-magnitude representation rather than simply using the platforms native sign representation: this ensures
there is no step change in behavior as a cpp_int grows in size.
* Fixed precision `cpp_int`'s have some support for `constexpr` values and user-defined literals, see
[link boost_multiprecision.tut.lits here] for the full description.  For example `0xfffff_cppi1024`
specifies a 1024-bit integer with the value 0xffff.  This can be used to generate compile-time constants that are
too large to fit into any __fundamental number type.
* The __cpp_int types support constexpr arithmetic, provided it is a fixed-precision type with no allocator.  It may also
be a checked integer: in which case a compiler error will be generated on overflow or undefined behaviour.  In addition
the free functions `abs`, `swap`, `multiply`, `add`, `subtract`, `divide_qr`, `integer_modulus`, `powm`, `lsb`, `msb`, 
`bit_test`, `bit_set`, `bit_unset`, `bit_flip`, `sqrt`, `gcd`, `lcm` are all supported.  Use of __cpp_int in this way
requires either a C++2a compiler (one which supports `std::is_constant_evaluated()`), or GCC-6 or later in C++14 mode.
Compilers other than GCC and without `std::is_constant_evaluated()` will support a very limited set of operations:
expect to hit roadblocks rather easily.
* You can import/export the raw bits of a __cpp_int to and from external storage via the `import_bits` and `export_bits`
functions.  More information is in the [link boost_multiprecision.tut.import_export section on import/export].

[h5:cpp_int_eg Example:]

[cpp_int_eg]

[endsect] [/section:cpp_int cpp_int]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_cpp_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:cpp_rational cpp_rational]

`#include <boost/multiprecision/cpp_int.hpp>`

   namespace boost{ namespace multiprecision{

   typedef rational_adaptor<cpp_int_backend<> >    cpp_rational_backend;

   typedef number<cpp_rational_backend>         cpp_rational;

   }} // namespaces

The `cpp_rational_backend` type is used via the typedef `boost::multiprecision::cpp_rational`.  It provides
a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.

As well as the usual conversions from arithmetic and string types, instances of `cpp_rational` are copy constructible
and assignable from type `cpp_int`.

There is also a two argument constructor that accepts a numerator and denominator: both of type `cpp_int`.

There are also non-member functions:

   cpp_int numerator(const cpp_rational&);
   cpp_int denominator(const cpp_rational&);

which return the numerator and denominator of the number.

Things you should know when using this type:

* Default constructed `cpp_rational`s have the value zero.
* Division by zero results in a `std::overflow_error` being thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be
interpreted as a valid rational number.

[h5 Example:]

[cpp_rational_eg]

[endsect] [/section:rational Rational Number Types]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_debug_adaptor.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:debug_adaptor debug_adaptor]

`#include <boost/multiprecision/debug_adaptor.hpp>`

   namespace boost{ namespace multiprecision{

   template <Backend>
   class debug_adaptor;

   template <class Number>
   using debug_adaptor_t = number<debug_adaptor<typename Number::backend_type>, Number::et>

   }} // namespaces

The `debug_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
some other backend to class `number` and intercepts all operations on that object storing the result as a string within itself.

This type provides `numeric_limits` support whenever the template argument Backend does so.

This type is particularly useful when your debugger provides a good view of `std::string`: when this is the case
multiprecision values can easily be inspected in the debugger by looking at the `debug_value` member of `debug_adaptor`.
The down side of this approach is that runtimes are much slower when using this type.  Set against that it can make
debugging very much easier, certainly much easier than sprinkling code with `printf` statements.

When used in conjunction with the Visual C++ debugger visualisers, the value of a multiprecision type that uses this
backend is displayed in the debugger just a __fundamental value would be, here we're inspecting a value of type
`number<debug_adaptor<cpp_dec_float<50> > >`:

[$../debugger1.png]

Otherwise you will need to expand out the view and look at the "debug_value" member:

[$../debugger2.png]

It works for all the backend types equally too, here it is inspecting a `number<debug_adaptor<gmp_rational> >`:

[$../debugger3.png]

The template alias `debug_adaptor_t` is used as a shortcut for converting some other number type to it's debugged equivalent,
for example:

   using mpfr_float_debug = debug_adaptor_t<mpfr_float>;

Defines `mpfr_float_debug` to be the debugged equivalent of `mpfr_float`.


[endsect] [/section:debug_adaptor debug_adaptor]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_eigen.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:eigen Eigen Interoperability]

This library provides the header:

   #include <boost/multiprecision/eigen.hpp>

which defines the traits classes and functions that the Eigen library needs all user-defined number types to provide.

For example the following code performs quad-precision matrix solving on complex numbers:

[eigen_eg]

Which produces the following output:

[eigen_out]

[endsect] [/section:eigen Eigen Interoperability]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_float128.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:float128 float128]

`#include <boost/multiprecision/float128.hpp>`

   namespace boost{ namespace multiprecision{

   class float128_backend;

   typedef number<float128_backend, et_off>    float128;

   }} // namespaces

The `float128` number type is a very thin wrapper around GCC's `__float128` or Intel's `_Quad` data types
and provides an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
a 113 bit mantissa, and compatible with FORTRAN's 128-bit QUAD real.

All the usual standard library and `std::numeric_limits` support are available, performance should be equivalent
to the underlying native types: for example the LINPACK benchmarks for GCC's `__float128` and
`boost::multiprecision::float128` both achieved 5.6 MFLOPS[footnote On 64-bit Ubuntu 11.10, GCC-4.8.0, Intel Core 2 Duo T5800.].

As well as the usual conversions from arithmetic and string types, instances of `float128` are
copy constructible and assignable from GCC's `__float128` and Intel's `_Quad` data types.

It's also possible to access the underlying `__float128` or `_Quad` type via the `data()` member
function of `float128_backend`.

Things you should know when using this type:

* Default constructed `float128`s have the value zero.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* This type is fully `constexpr` aware - basic constexpr arithmetic is supported from C++14 and onwards, comparisons,
plus the functions `fabs`, `abs`, `fpclassify`, `isnormal`, `isfinite`, `isinf` and `isnan` are also supported if either
the compiler implements C++20's `std::is_constant_evaluated()`, or if the compiler is GCC.
* It is not possible to round-trip objects of this type to and from a string and get back
exactly the same value when compiled with Intel's C++ compiler and using `_Quad` as the underlying type: this is a current limitation of
our code.  Round tripping when using `__float128` as the underlying type is possible (both for GCC and Intel).
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* Division by zero results in an infinity being produced.
* Type `float128` can be used as a literal type (constexpr support).
* Type `float128` can be used for full `constexpr` arithmetic from C++14 and later with GCC.  The functions `abs`, `fabs`, 
`fpclassify`, `isnan`, `isinf`, `isfinite` and `isnormal` are also `constexpr`, but the transcendental functions are not.
* When using the Intel compiler, the underlying type defaults to `__float128` if it's available and `_Quad` if not.  You can override
the default by defining either `BOOST_MP_USE_FLOAT128` or `BOOST_MP_USE_QUAD`.
* When the underlying type is Intel's `_Quad` type, the code must be compiled with the compiler option `-Qoption,cpp,--extended_float_type`.
* When compiling with `gcc`, you need to use the flag `--std=gnu++11/14/17`, as the suffix 'Q' is a GNU extension. Compilation fails with the flag `--std=c++11/14/17`
unless you also use `-fext-numeric-literals`.
* You will need to link to `libquadmath.dll` with the link command `-lquadmath` and ensure that the DLL is visible by the linker. 
If you are using the B2/bjam build system then commands`<linkflags>-lQUADMATH` and `<linkflags>-L"path/to/lib"` will be needed.
* The values shown by `std::numeric_limits<float128>` and extremely close ['but not identical]
to those from the equivalent precision and range multiprecision types `std::numeric_limits<cpp_bin_float_quad>` and `std::numeric_limits<cpp_dec_float_quad>`.

[h5 float128 example:]

[float128_eg]

Values for `std::numeric_limits<float128>` are:

[float128_numeric_limits]

[endsect] [/section:float128 float128]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_float128_complex.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:complex128 complex128]

`#include <boost/multiprecision/complex128.hpp>`

   namespace boost{ namespace multiprecision{

   class complex128_backend;

   typedef number<complex128_backend, et_off>    complex128;

   }} // namespaces

The `complex128` number type is a very thin wrapper around GCC's `__float128` or Intel's `_Quad` data types
and provides a complex-number type that is a drop-in replacement for the native C++ floating-point types, but with
a 113 bit mantissa, and compatible with FORTRAN's 128-bit QUAD real.

All the usual standard library functions are available, performance should be equivalent
to the underlying native types.

As well as the usual conversions from arithmetic and string types, instances of `float128` are
copy constructible and assignable from GCC's `__float128` and Intel's `_Quad` data types.

Things you should know when using this type:

* Default constructed `complex128`s have the value zero.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* It is not possible to round-trip objects of this type to and from a string and get back
exactly the same value when compiled with Intel's C++ compiler and using `_Quad` as the underlying type: this is a current limitation of
our code.  Round tripping when using `__float128` as the underlying type is possible (both for GCC and Intel).
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* Division by zero results in an infinity being produced.
* When using the Intel compiler, the underlying type defaults to `__float128` if it's available and `_Quad` if not.  You can override
the default by defining either `BOOST_MP_USE_FLOAT128` or `BOOST_MP_USE_QUAD`.
* When the underlying type is Intel's `_Quad` type, the code must be compiled with the compiler option `-Qoption,cpp,--extended_float_type`.

[h5 complex128 example:]

[complex128_eg]

Which results in the output:

[complex128_out]

[endsect] [/section:complex128 complex128]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_float_builtin_ctor.qbk
================================================
[/
  Copyright 2021 John Maddock.
  Copyright 2021 Paul A. Bristow.
  Copyright 2021 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:floatbuiltinctor Construction from Specific Values Without Precision Loss]

Construction of multiprecision types from built-in floating-point types
can lead to potentially unexpected, yet correct, results.
Consider, for instance constructing an instance of `cpp_dec_float_50`
from the literal built-in floating-point `double` value 11.1.

   #include <iomanip>
   #include <iostream>
   #include <limits>

   #include <boost/multiprecision/cpp_dec_float.hpp>

   int main()
   {
     using my_dec_100 = boost::multiprecision::cpp_dec_float_50;

     const my_dec_100 f11(11.1);

     // On a system with 64-bit double:
     // 11.09999999999999964472863211994990706443786621093750
     std::cout << std::setprecision(std::numeric_limits<my_dec_100>::digits10)
               << std::fixed
               << f11
               << std::endl;
   }

In this example, the system has a 64-bit built in `double` representation.
The variable `f11` is initialized with the literal
`double` value 11.1. Recall that built-in floating-point representations
are based on successive binary fractional approximations.
These are, in fact, very close approximations.
But they are approximations nonetheless, having their built-in finite precision.

For this reason,
the full multiple precision value of the `double` approximation
of 11.1 is given by the large value shown above. Observations show
us that the value is reliable up to the approximate 15 decimal
digit precision of built-in 64-bit `double` on this system.

If the exact value of 11.1 is desired
(within the wider precision of the multiprecision type),
then construction from literal string or from a rational
integral construction/division sequence should be used.

   const my_dec_100 f11_str("11.1");
   const my_dec_100 f11_n  (my_dec_100(111) / 10);

[endsect] [/section:floatbuiltinctor Construction from Built-In Floats]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_float_eg.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:fp_eg Examples]

[include tutorial_float_builtin_ctor.qbk]

[import ../example/floating_point_examples.cpp]

[section:aos Area of Circle]

[/I:\boost\libs\multiprecision\example\floating_point_examples.cpp]
[AOS1]
[AOS2]
[AOS3]

[endsect] [/section:aos Area of Circle]


[section:caveats Drop-in Caveats]
[import ../example/big_seventh.cpp]

[big_seventh_example_1]
[big_seventh_example_2]
[big_seventh_example_3]
[big_seventh_example_constexpr]  [/ Hopefully a temporary restriction.]
[big_seventh_example_4]

Typical output is:
[big_seventh_example_output]

[endsect] [/section:caveats Caveats]

[section:jel Defining a Special Function.]

[JEL]

[endsect] [/section:jel Defining a Special Function.]


[section:nd Calculating a Derivative]

[ND1]
[ND2]
[ND3]

[endsect] [/section:nd Calculating a Derivative]


[section:gi Calculating an Integral]

[GI1]
[GI2]

[endsect] [/section:gi Calculating an Integral]


[section:poly_eg Polynomial Evaluation]

[POLY]

[endsect] [/section:poly_eg Polynomial Evaluation]

[section:variable_precision Variable-Precision Newton Evaluation]

[mpfr_variable]

[endsect] [/section:variable_precision Variable-Precision Newton Evaluation]

[section:gauss_lagerre_quadrature Gauss-Laguerre quadrature]

[import ../example/gauss_laguerre_quadrature.cpp]

This example uses __Boost_Multiprecision to implement a high-precision Gauss-Laguerre quadrature integration.
The quadrature is used to calculate the `airy_ai(x)` function for real-valued `x` on the positive axis with `x >= 1`.

In this way, the integral representation could be seen as part of a scheme to calculate 
real-valued Airy functions on the positive axis for medium to large argument.
A Taylor series or hypergeometric function (not part of this example) could be used for smaller arguments.

This example has been tested with decimal digits counts ranging from 21...301, by adjusting the parameter
`local::my_digits10` at compile time.

The quadrature integral representaion of `airy_ai(x)` used in this example can be found in:

A. Gil, J. Segura, N.M. Temme, "Numerical Methods for Special Functions"
(SIAM Press 2007), ISBN 9780898717822, Sect. 5.3.3, in particular Eq. 5.110, page 145.

Subsequently, Gil et al's book cites the another work:
W. Gautschi, "Computation of Bessel and Airy functions and of related Gaussian quadrature formulae",
BIT, 42 (2002), pp. 110-118, [@https://doi.org/10.1023/A:1021974203359] that is also available as
[@https://www.cs.purdue.edu/homes/wxg/selected_works/section_02/169.pdf Gautschi_169.pdf].

This Gauss-Laguerre quadrature is designed for `airy_ai(x)` with real-valued `x >= 1`.

The example uses Gauss-Laguerre quadrature integration to compute `airy_ai(x / 7)` 
with `7 <= x <= 120` and where `x` is incremented in steps of 1.

During development of this example, we have empirically found the numbers of Gauss-Laguerre coefficients
needed for convergence when using various counts of base-10 digits.

Let's calibrate, for instance, the number of coefficients needed at the point `x = 1`.

Empirical data were used with __WolframAlpha :
``
Fit[{{21.0, 3.5}, {51.0, 11.1}, {101.0, 22.5}, {201.0, 46.8}}, {1, d, d^2}, d]FullSimplify[%]  
  0.0000178915 d^2 + 0.235487 d - 1.28301
  or
  -1.28301 + (0.235487 + 0.0000178915 d) d
``
  
We need significantly more coefficients at smaller real values than are needed
at larger real values because the slope derivative of `airy_ai(x)` gets more
steep as x approaches zero.  `laguerre_order` is calculated using this equation.


Snippets from (copious) output from a progress bar during calculation of approximate root estimates 
followed by calculation of accurate abscissa and weights is:

[gauss_laguerre_quadrature_output_1]

Finally the result using Gauss-Laguerre quadrature is compared with a calculation using `cyl_bessel_k`,
and both are listed, finally confirming that none differ more than a small tolerance.
[gauss_laguerre_quadrature_output_2]

For more detail see comments in the source code for this example at [@../../example/gauss_laguerre_quadrature.cpp gauss_laguerre_quadrature.cpp].

[endsect] [/section:gauss_lagerre_quadrature Gauss-Laguerre quadrature]

[endsect] [/section:fp_eg Examples]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_floats.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:floats Floating-point Types]

The following back-ends provide floating-point arithmetic:

[table
[[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
[[`cpp_bin_float<N>`][boost/multiprecision/cpp_bin_float.hpp][2][None][Header only, all C++ implementation. Boost licence.][Approximately 2x slower than the [mpfr] or [gmp] libraries.]]
[[`cpp_dec_float<N>`][boost/multiprecision/cpp_dec_float.hpp][10][None][Header only, all C++ implementation. Boost licence.][Approximately 2x slower than the [mpfr] or [gmp] libraries.]]
[[`mpf_float<N>`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
[[`mpfr_float<N>`][boost/multiprecision/mpfr.hpp][2][[gmp] and [mpfr]][Very fast and efficient back-end, with its own standard library implementation.][Dependency on GNU licensed [gmp] and [mpfr] libraries.]]
[[`float128`][boost/multiprecision/float128.hpp][2][Either [quadmath] or the Intel C++ Math library.][Very fast and efficient back-end for 128-bit floating-point values (113-bit mantissa, equivalent to FORTRAN's QUAD real)][Depends on the compiler being either recent GCC or Intel C++ versions.]]
]

[include tutorial_cpp_bin_float.qbk]
[include tutorial_cpp_dec_float.qbk]
[include tutorial_gmp_float.qbk]
[include tutorial_mpfr_float.qbk]
[include tutorial_float128.qbk]
[include tutorial_float_eg.qbk]

[endsect] [/section:floats floating-point Numbers]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_gmp_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:gmp_float gmp_float]

`#include <boost/multiprecision/gmp.hpp>`

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10>
   class gmp_float;

   typedef number<gmp_float<50> >    mpf_float_50;
   typedef number<gmp_float<100> >   mpf_float_100;
   typedef number<gmp_float<500> >   mpf_float_500;
   typedef number<gmp_float<1000> >  mpf_float_1000;
   typedef number<gmp_float<0> >     mpf_float;

   }} // namespaces

The `gmp_float` back-end is used in conjunction with `number` : it acts as a thin wrapper around the [gmp] `mpf_t`
to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

Type `gmp_float` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
at variable precision by setting the template argument to zero.  The typedefs mpf_float_50, mpf_float_100,
mpf_float_500, mpf_float_1000 provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
respectively.  The typedef mpf_float provides a variable precision type whose precision can be controlled via the
`number`s member functions.

[note This type only provides standard library and `numeric_limits` support when the precision is fixed at compile time.]

As well as the usual conversions from arithmetic and string types, instances of `number<mpf_float<N> >` are
copy constructible and assignable from:

* The [gmp] native types `mpf_t`, `mpz_t`, `mpq_t`.
* The `number` wrappers around those types: `number<mpf_float<M> >`, `number<gmp_int>`, `number<gmp_rational>`.

It's also possible to access the underlying `mpf_t` via the `data()` member function of `gmp_float`.

Things you should know when using this type:

* Default constructed `gmp_float`s have the value zero (this is the [gmp] library's default behavior).
* No changes are made to the [gmp] library's global settings, so this type can be safely mixed with
existing [gmp] code.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* It is not possible to round-trip objects of this type to and from a string and get back
exactly the same value.  This appears to be a limitation of [gmp].
* Since the underlying [gmp] types have no notion of infinities or NaNs, care should be taken
to avoid numeric overflow or division by zero.  That latter will result in a std::overflow_error being thrown,
while generating excessively large exponents may result in instability of the underlying [gmp]
library (in testing, converting a number with an excessively large or small exponent
to a string caused [gmp] to segfault).
* This type can equally be used with [mpir] as the underlying implementation - indeed that is
the recommended option on Win32.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* Division by zero results in a `std::overflow_error` being thrown.

[h5 [gmp] example:]

[mpf_eg]

[endsect]

================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_gmp_int.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:gmp_int gmp_int]

`#include <boost/multiprecision/gmp.hpp>`

   namespace boost{ namespace multiprecision{

   class gmp_int;

   typedef number<gmp_int >         mpz_int;

   }} // namespaces

The `gmp_int` back-end is used via the typedef `boost::multiprecision::mpz_int`.  It acts as a thin wrapper around the [gmp] `mpz_t`
to provide an integer type that is a drop-in replacement for the native C++ integer types, but with unlimited precision.

As well as the usual conversions from arithmetic and string types, type `mpz_int` is copy constructible and assignable from:

* The [gmp] native types: `mpf_t`, `mpz_t`, `mpq_t`.
* Instances of `number<T>` that are wrappers around those types: `number<gmp_float<N> >`, `number<gmp_rational>`.

It's also possible to access the underlying `mpz_t` via the `data()` member function of `gmp_int`.

Things you should know when using this type:

* No changes are made to the GMP library's global settings - so you can safely mix this type with
existing code that uses [gmp].
* Default constructed `gmp_int`s have the value zero (this is GMP's default behavior).
* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
as a result performing formatted output on this type when the argument is negative and either of the flags
`std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid integer.
* Division by zero results in a `std::overflow_error` being thrown.
* Although this type is a wrapper around [gmp] it will work equally well with [mpir].  Indeed use of [mpir]
is recommended on Win32.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.

[h5 Example:]

[mpz_eg]

[endsect] [/section:gmp_int gmp_int]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_gmp_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:gmp_rational gmp_rational]

`#include <boost/multiprecision/gmp.hpp>`

   namespace boost{ namespace multiprecision{

   class gmp_rational;

   typedef number<gmp_rational >         mpq_rational;

   }} // namespaces

The `gmp_rational` back-end is used via the typedef `boost::multiprecision::mpq_rational`.  It acts as a thin wrapper around the [gmp] `mpq_t`
to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.

As well as the usual conversions from arithmetic and string types, instances of `number<gmp_rational>` are copy constructible
and assignable from:

* The [gmp] native types: `mpz_t`, `mpq_t`.
* `number<gmp_int>`.

There is also a two-argument constructor that accepts a numerator and denominator (both of type `number<gmp_int>`).

There are also non-member functions:

   mpz_int numerator(const mpq_rational&);
   mpz_int denominator(const mpq_rational&);

which return the numerator and denominator of the number.

It's also possible to access the underlying `mpq_t` via the `data()` member function of `mpq_rational`.

Things you should know when using this type:

* Default constructed `mpq_rational`s have the value zero (this is the [gmp] default behavior).
* Division by zero results in a `std::overflow_error` being thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be
interpreted as a valid rational number.
* No changes are made to the [gmp] library's global settings, so this type can coexist with existing
[gmp] code.
* The code can equally be used with [mpir] as the underlying library - indeed that is the preferred option on Win32.

[h5 Example:]

[mpq_eg]

[endsect] [/section:gmp_rational gmp_rational]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_hash.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:hash Hash Function Support]

[hash1]

[hash2]

[hash3]

[hash4]

[endsect] [/section:hash Hash Function Support]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_import_export.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:import_export Importing and Exporting Data to and from `cpp_int` and `cpp_bin_float`]

Any integer number type that uses `cpp_int_backend` as its implementation layer can import or export its bits via two non-member functions:

      template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator,
                expression_template_option ExpressionTemplates, class OutputIterator>
      OutputIterator export_bits(
         const number<const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val,
         OutputIterator out,
         unsigned chunk_size,
         bool msv_first = true);

      template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator,
                expression_template_option ExpressionTemplates, class Iterator>
      number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
         import_bits(
            number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val,
            Iterator i,
            Iterator j,
            unsigned chunk_size = 0,
            bool msv_first = true);

These functions are designed for data-interchange with other storage formats, and since __cpp_bin_float uses __cpp_int internally,
by extension they can be used for floating-point numbers based on that backend as well (see example below). 
Parameters and use are as follows:

      template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator,
                expression_template_option ExpressionTemplates, class OutputIterator>
      OutputIterator export_bits(
         const number<const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val,
         OutputIterator out,
         unsigned chunk_size,
         bool msv_first = true);

Exports the absolute value of `val` to OutputIterator `out`.  The function will write `chunk_size` bits at a time
to the OutputIterator, and if `msv_first` is true, will write the most-significant block first.  Byte and bit order
within each `chunk_size` block is always in the machines native format.  Further, each block is stored in a
`std::uintmax_t` when it's assigned to `*out`.

[note Unfortunately, the standard's OutputIterator concept provides no means of deducing the type to output since
`std::iterator_traits<OutputIteratorType>::value_type` is type `void`.  This is why the bit count for each block
has to be specified manually.  It may also result in compiler warnings about the value being narrowed.]

[tip If you're exporting to non-native byte layout, then use
[@http://www.boost.org/doc/libs/release/libs/endian/doc/index.html  Boost.Endian]
to create a custom OutputIterator that reverses the byte order of each chunk prior to actually storing the result.]

      template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator,
                expression_template_option ExpressionTemplates, class ForwardIterator>
      number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
         import_bits(
            number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val,
            ForwardIterator i,
            ForwardIterator j,
            unsigned chunk_size = 0,
            bool msv_first = true);

Imports bits from the iterator range ['\[i,j)] and stores them in `val` to produce an unsigned result (if the result
is to be signed you will need to handle that separately).  When `msv_first` is true, takes `*i` as the most significant
chunk.  Assumes there are `chunk_size` bits in each value read from the iterator range, and that these are in machine native
bit/byte order.  When `chunk_size` is zero, then assumes that each chunk contains
`std::numeric_limits<std::iterator_traits<ForwardIterator>::value_type>::digits`, note that this will give the wrong result
if dereferencing the iterators leads to a signed-integer type, [*and] the sign bit is significant (be particularly careful
if you expect type `char` to contain 8-bit values, as by default it will extract only 7-bits at a time if `char` is signed).
As with exporting, if the external data is to be in a non-native byte order (within each chunk), then you will need to create an iterator adaptor
that presents it in native order (see [@http://www.boost.org/doc/libs/release/libs/endian/doc/index.html Boost.Endian]).

[note
Note that this function is optimized for the case where the data can be `memcpy`ed from the source to the integer - in this case both
iterators much be pointers, and everything must be little-endian.]

[h4 Examples]

[IE1]

[IE2]

[endsect] [/section:import_export Importing and Exporting Data to and from `cpp_int` and `cpp_bin_float`]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_integer.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:ints Integer Types]

The following back-ends provide integer arithmetic:

[table
[[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
[[`cpp_int`][boost/multiprecision/cpp_int.hpp][2][None]
            [Very versatile, Boost licensed, all C++ integer type which support both [@http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic arbitrary precision] and fixed precision integer types.][Slower than [gmp], though typically not as slow as [tommath]]]
[[`gmp_int`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
[[`tom_int`][boost/multiprecision/tommath.hpp][2][[tommath]][Public domain back-end with no licence restrictions.][Slower than [gmp].]]
]

[include tutorial_cpp_int.qbk]
[include tutorial_gmp_int.qbk]
[include tutorial_tommath.qbk]
[include tutorial_integer_examples.qbk]

[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_integer_examples.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:egs Examples]

[import ../example/integer_examples.cpp]

[section:factorials Factorials]
[FAC1]
[endsect] [/section:factorials Factorials]


[section:bitops Bit Operations]
[BITOPS]
[endsect] [/section:bitops Bit Operations]


[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_integer_ops.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:gen_int Generic Integer Operations]

All of the [link boost_multiprecision.ref.number.integer_functions non-member integer operations] are overloaded for the
__fundamental integer types in
`<boost/multiprecision/integer.hpp>`.
Where these operations require a temporary increase in precision (such as for `powm`), then
if no __fundamental type is available, a __cpp_int of appropriate precision will be used.

Some of these functions are trivial, others use compiler intrinsics (where available) to ensure optimal evaluation.

The overloaded functions are:

   template <class Integer, class I2>
   Integer& multiply(Integer& result, const I2& a, const I2& b);

Multiplies two `I2` values, to produce a wider `Integer` result.

Returns `result = a * b` without overflow or loss of precision in the multiplication.

   template <class Integer, class I2>
   Integer& add(Integer& result, const I2& a, const I2& b);

Adds two `I2` values, to produce a wider `Integer` result.

Returns `result = a + b` without overflow or loss of precision in the addition.

   template <class Integer, class I2>
   Integer& subtract(Integer& result, const I2& a, const I2& b);

Subtracts two `I2` values, to produce a wider `Integer` result.

Returns `result = a - b` without overflow or loss of precision in the subtraction.

   template <class Integer>
   Integer powm(const Integer& b, const Integer& p, const Integer& m);

Returns b[super p] % m.

   template <class Integer>
   void divide_qr(const Integer& x, const Integer& y, Integer& q, Integer& r);

Sets `q = x / y` and `r = x % y`.

   template <class Integer1, class Integer2>
   Integer2 integer_modulus(const Integer1& x, Integer2 val);

Returns x % val;

   template <class Integer>
   unsigned lsb(const Integer& x);

Returns the (zero-based) index of the least significant bit of `x`.

Throws a `std::domain_error` if `x <= 0`.

   template <class Integer>
   unsigned msb(const Integer& x);

Returns the (zero-based) index of the most significant bit of `x`.

Throws a `std::domain_error` if `x <= 0`.

   template <class Integer>
   bool bit_test(const Integer& val, unsigned index);

Returns `true` if bit `index` is set in `val`.

   template <class Integer>
   Integer& bit_set(Integer& val, unsigned index);

Sets the `index` bit in `val`.

   template <class Integer>
   Integer& bit_unset(Integer& val, unsigned index);

Unsets the `index` bit in `val`.

   template <class Integer>
   Integer& bit_flip(Integer& val, unsigned index);

Flips the `index` bit in `val`.

   template <class Integer>
   Integer sqrt(const Integer& x);
   template <class Integer>
   Integer sqrt(const Integer& x, Integer& r);

Returns the integer square root `s` of x and sets `r` to the remainder ['x - s[super 2]].

   template <class Engine>
   bool miller_rabin_test(const number-or-expression-template-type& n, unsigned trials, Engine& gen);
   bool miller_rabin_test(const number-or-expression-template-type& n, unsigned trials);

The regular Miller-Rabin functions in `<boost/multiprecision/miller_rabin.hpp>` are defined in terms of the above
generic operations, and so function equally well for __fundamental_types and multiprecision types.

[endsect] [/section:gen_int Generic Integer Operations]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_interval_mpfi.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:interval Interval Number Types]

There is one currently only one interval number type supported - [mpfi].

[section:mpfi mpfi_float]

`#include <boost/multiprecision/mpfi.hpp>`

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10>
   class mpfi_float_backend;

   typedef number<mpfi_float_backend<50> >    mpfi_float_50;
   typedef number<mpfi_float_backend<100> >   mpfifloat_100;
   typedef number<mpfi_float_backend<500> >   mpfifloat_500;
   typedef number<mpfi_float_backend<1000> >  mpfi_float_1000;
   typedef number<mpfi_float_backend<0> >     mpfi_float;

   }} // namespaces

The `mpfi_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfi] `mpfi_t`
to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision and implementing interval arithmetic.

Type `mpfi_float_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
at variable precision by setting the template argument to zero.  The `typedef`s `mpfi_float_50`, `mpfi_float_100`,
`mpfi_float_500`, `mpfi_float_1000` provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
respectively.  The `typedef mpfi_float` provides a variable precision type whose precision can be controlled via theF
`number`s member functions.

[note This type only provides `numeric_limits` support when the precision is fixed at compile time.]

As well as the usual conversions from arithmetic and string types, instances of `number<mpfi_float_backend<N> >` are
copy constructible and assignable from:

* The [mpfi] native type `mpfi_t`.
* The `number` wrappers around [mpfi] or [mpfr]: `number<mpfi_float_backend<M> >` and `number<mpfr_float<M> >`.
* There is a two argument constructor taking two `number<mpfr_float<M> >` arguments specifying the interval.

It's also possible to access the underlying `mpfi_t` via the `data()` member function of `mpfi_float_backend`.

Things you should know when using this type:

* A default constructed `mpfi_float_backend` is set to zero (['Note that this is [*not] the default [mpfi] behavior]).
* No changes are made to [gmp] or [mpfr] global settings, so this type can coexist with existing
[mpfr] or [gmp] code.
* The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* Division by zero results in an infinity.

There are some additional non member functions for working on intervals:

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfr_float_backend<Digits10>, ExpressionTemplates> lower(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);

Returns the lower end of the interval.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfr_float_backend<Digits10>, ExpressionTemplates> upper(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);

Returns the upper end of the interval.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfr_float_backend<Digits10>, ExpressionTemplates> median(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);

Returns the mid point of the interval.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfr_float_backend<Digits10>, ExpressionTemplates> width(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val);

Returns the absolute width of the interval.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfi_float_backend<Digits10>, ExpressionTemplates> intersect(
    const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
    const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b);

Returns the interval which is the intersection of the ['a] and ['b].  Returns an
unspecified empty interval if there is no such intersection.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  number<mpfi_float_backend<Digits10>, ExpressionTemplates> hull(
    const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
    const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b);

Returns the interval which is the union of ['a] and ['b].

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool overlap(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
               const number<mpfi_float_backend<Digits10>, ExpressionTemplates>&  b);

Returns `true` only if the intervals ['a] and ['b] overlap.

  template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
  bool in(const number<mpfr_float_backend<Digits10>, ExpressionTemplates1>& a,
          const number<mpfi_float_backend<Digits10>, ExpressionTemplates2>&  b);

Returns `true` only if point ['a] is contained within the interval ['b].

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool zero_in(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);

Returns `true` only if the interval ['a] contains the value zero.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
              const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);

Returns `true` only if ['a] is a subset of ['b].

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool proper_subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a,
                     const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b);

Returns `true` only if ['a] is a proper subset of ['b].

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool empty(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);

Returns `true` only if ['a] is an empty interval, equivalent to `upper(a) < lower(a)`.

  template <unsigned Digits10, expression_template_option ExpressionTemplates>
  bool singleton(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a);

Returns `true` if `lower(a) == upper(a)`.

[h5 [mpfi] example:]

[mpfi_eg]

[endsect] [ section:mpfi mpfi_float]

[endsect] [/section:interval Interval Number Types]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_io.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:input_output  Input Output]

[h4  Loopback testing]

['Loopback] or ['round-tripping] refers to writing out a value as a decimal digit string using `std::iostream`,
usually to a `std::stringstream`, and then reading the string back in to another value,
and confirming that the two values are identical.  A trivial example using `float` is:

  float write; // Value to round-trip.
  std::stringstream ss;  // Read and write std::stringstream.
  ss.precision(std::numeric_limits<T>::max_digits10);  // Ensure all potentially significant bits are output.
  ss.flags(std::ios_base::fmtflags(std::ios_base::scientific)); // Use scientific format.
  ss << write; // Output to string.
  float read;  // Expected.
  ss >> read; // Read decimal digits string from stringstream.
  BOOST_CHECK_EQUAL(write, read); // Should be the same.

and this can be run in a loop for all possible values of a 32-bit float.
For other floating-point types `T`, including __fundamental `double`,
it takes far too long to test all values,
so a reasonable test strategy is to use a large number of random values.

  T write;
  std::stringstream ss;
  ss.precision(std::numeric_limits<T>::max_digits10);  // Ensure all potentially significant bits are output.
  ss.flags(f); // Changed from default iostream format flags if desired.
  ss << write; // Output to stringstream.

  T read;
  ss >> read; // Get read using operator>> from stringstream.
  BOOST_CHECK_EQUAL(read, write);

  read = static_cast<T>(ss.str()); // Get read by converting from decimal digits string representation of write.
  BOOST_CHECK_EQUAL(read, write);

  read = static_cast<T>(write.str(0, f));  // Get read using format specified when written.
  BOOST_CHECK_EQUAL(read, write);


The test at
[@../../test/test_cpp_bin_float_io.cpp test_cpp_bin_float_io.cpp]
allows any floating-point type to be ['round_tripped] using a wide range of fairly random values.
It also includes tests compared a collection of
[@../../test/string_data.ipp stringdata] test cases in a file.

[h4 Comparing with output using __fundamental types]

One can make some comparisons with the output of

   <number<cpp_bin_float<53, digit_count_2> >

which has the same number of significant bits (53) as 64-bit double precision floating-point.

However, although most outputs are identical, there are differences on some platforms
caused by the implementation-dependent behaviours allowed by the C99 specification
[@http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf  C99 ISO/IEC 9899:TC2],
incorporated by C++.

[:['"For e, E, f, F, g, and G conversions, if the number of significant decimal digits
is at most DECIMAL_DIG, then the result should be correctly rounded.
If the number of significant decimal digits is more than DECIMAL_DIG
but the source value is exactly representable with DECIMAL_DIG digits,
then the result should be an exact representation with trailing zeros.
Otherwise, the source value is bounded by two adjacent decimal strings L < U,
both having DECIMAL_DIG significant digits;
the value of the resultant decimal string D should satisfy L<= D <= U,
with the extra stipulation that the error should have a correct sign
for the current rounding direction."]]

So not only is correct rounding for the full number of digits not required,
but even if the *optional* recommended practice is followed,
then the value of these last few digits is unspecified
as long as the value is within certain bounds.

[note Do not expect the output from different platforms
to be [*identical], but `cpp_dec_float`, `cpp_bin_float` (and other backends) outputs should be
correctly rounded to the number of digits requested by the set precision and format.]


[h4 Macro BOOST_MP_MIN_EXPONENT_DIGITS]

[@http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf C99 Standard]
for [/e and E] format specifiers, 7.19.6 Formatted input/output functions requires:

\"The exponent always contains at least two digits,
and only as many more digits as necessary to represent the exponent.\"

So to conform to the C99 standard (incorporated by C++)

  #define BOOST_MP_MIN_EXPONENT_DIGITS 2

Confusingly, Microsoft (and MinGW) do not conform to this standard and provide
[*at least three digits], for example `1e+001`.
So if you want the output to match that from
__fundamental floating-point types on compilers that use Microsofts runtime then use:

  #define BOOST_MP_MIN_EXPONENT_DIGITS 3

Also useful to get the minimum exponent field width is

  #define BOOST_MP_MIN_EXPONENT_DIGITS 1

producing a compact output like `2e+4`,
useful when conserving space is important.

Larger values are also supported, for example, value 4 for `2e+0004`
which may be useful to ensure that columns line up.

[endsect] [/section:input_output  Input Output]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_logged_adaptor.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:logged_adaptor logged_adaptor]

`#include <boost/multiprecision/logged_adaptor.hpp>`

   namespace boost{ namespace multiprecision{

   template <class Backend>
   void log_postfix_event(const Backend& result, const char* event_description);
   template <class Backend, class T>
   void log_postfix_event(const Backend& result1, const T& result2, const char* event_description);

   template <class Backend>
   void log_prefix_event(const Backend& arg1, const char* event_description);
   template <class Backend, class T>
   void log_prefix_event(const Backend& arg1, const T& arg2, const char* event_description);
   template <class Backend, class T, class U>
   void log_prefix_event(const Backend& arg1, const T& arg2, const U& arg3, const char* event_description);
   template <class Backend, class T, class U, class V>
   void log_prefix_event(const Backend& arg1, const T& arg2, const U& arg3, const V& arg4, const char* event_description);

   template <Backend>
   class logged_adaptor;

   template <class Number>
   using logged_adaptor_t = number<logged_adaptor<typename Number::backend_type>, Number::et>;

   }} // namespaces

The `logged_adaptor` type is used in conjunction with `number` and some other backend type: it acts as a thin wrapper around
some other backend to class `number` and logs all the events that take place on that object.  Before any number operation takes
place, it calls `log_prefix_event` with the arguments to the operation (up to 4), plus a string describing the operation.
Then after the operation it calls `log_postfix_event` with the result of the operation, plus a string describing the operation.
Optionally, `log_postfix_event` takes a second result argument: this occurs when the result of the operation is not a `number`,
for example when `fpclassify` is called, `log_postfix_event` will be called with `result1` being the argument to the function, and
`result2` being the integer result of `fpclassify`.

The default versions of `log_prefix_event` and `log_postfix_event` do nothing, it is therefore up to the user to overload these
for the particular backend being observed.

This type provides `numeric_limits` support whenever the template argument Backend does so.

Template alias `logged_adaptor_t` can be used as a shortcut for converting some instantiation of `number<>` to it's logged euqivalent.

This type is particularly useful when combined with an interval number type - in this case we can use `log_postfix_event`
to monitor the error accumulated after each operation.  We could either set some kind of trap whenever the accumulated error
exceeds some threshold, or simply print out diagnostic information.  Using this technique we can quickly locate the cause of
numerical instability in a particular routine.  The following example demonstrates this technique in a trivial algorithm
that deliberately introduces cancellation error:

[logged_adaptor]

When we examine program output we can clearly see that the diameter of the interval increases after each subtraction:

[logged_adaptor_output]

[endsect] [/section:logged_adaptor logged_adaptor]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_misc_backends.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:misc Miscellaneous Number Types.]

Backend types listed in this section are predominantly designed to aid debugging.

[include tutorial_logged_adaptor.qbk]
[include tutorial_debug_adaptor.qbk]
[include tutorial_visualizers.qbk]

[endsect]  [/section:misc Miscellaneous Number Types.]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_mixed_precision.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:mixed Mixed Precision Arithmetic]

Mixed precision arithmetic is fully supported by the library.

There are three different forms:

* Where the operands are of different precision or types.
* Where the operands are of the same type and precision, but yield a higher precision result.
* Where the operands or result are different but equivalent types (for example types which differ only in their memory management).

[h4 Mixing Operands of Differing Types or Precision]

If the arguments to a binary operator are of different types or precision, then the operation is allowed
as long as there is an unambiguous implicit conversion from one argument type to the other.
In all cases the arithmetic is performed "as if" the lower precision type is promoted to the
higher precision type before applying the operator.  However, particular backends may optimise
this and avoid actually creating a temporary if they are able to do so.

For example:

   mpfr_float_50         a(2), b;
   mpfr_float_100        c(3), d;
   static_mpfr_float_50  e(5), f;
   mpz_int               i(20);

   d = a * c;  // OK, result of operand is an mpfr_float_100.
   b = a * c;  // Error, can't convert the result to an mpfr_float_50 as it will lose digits.
   f = e * i;  // OK, unambiguous conversion from mpz_int to static_mpfr_float_50

[h4 Operands of the Same Precision]

Sometimes you want to apply an operator to two arguments of the same precision in
such a way as to obtain a result of higher precision.  The most common situation
occurs with fixed precision integers, where you want to multiply two N-bit numbers
to obtain a 2N-bit result.  This is supported in this library by the following
free functions:

   template <class ResultType, class Source1 class Source2>
   ResultType& add(ResultType& result, const Source1& a, const Source2& b);

   template <class ResultType, class Source1 class Source2>
   ResultType& subtract(ResultType& result, const Source1& a, const Source2& b);

   template <class ResultType, class Source1 class Source2>
   ResultType& multiply(ResultType& result, const Source1& a, const Source2& b);

These functions apply the named operator to the arguments ['a] and ['b] and store the
result in ['result], returning ['result].  In all cases they behave "as if"
arguments ['a] and ['b] were first promoted to type `ResultType` before applying the
operator, though particular backends may well avoid that step by way of an optimization.

The type `ResultType` must be an instance of class `number`, and the types `Source1` and `Source2`
may be either instances of class `number` or native integer types.  The latter is an optimization
that allows arithmetic to be performed on native integer types producing an extended precision result.

For example:

[mixed_eg]

Produces the output:

[mixed_output]

[h4 Mixing different, but "equivalent" types]

Ordinarily, mixing types of the same precision will produce a compiler error since there is
no unambiguous result type.  However, there is a traits class:
   
   namespace boost{ namespace multiprecision
   
   template <class NumberType1, class NumberType2>
   struct is_equivalent_number_type;

   }
   }

When it's `value` const-member value is `true` then the library will treat the types `NumberType1` and `NumberType2` as if
they are interchangeable.  This is typically used to optimise memory management by using two types with differing
memory allocation strategies for different roles.  Typically, we would be using a type with dymanic memory allocation and a minimal
memory footprint for the main storage type (think large arrays or matrices), but a type with internal storage and no dynamic 
allocation (but a larger memory footprint) for a few select calculations.

There are three backends that define this trait by default:

* __cpp_int's, provided the two types differ only in their internal cache size.
* __cpp_bin_float's provided they are of the same precision.
* __mpfr_float_backend's provided they are of the same precision.

In addition, while this feature can be used with expression templates turned off, this feature minimises temporaries
and hence memory allocations when expression template are turned on.

By way of an example, consider the dot product of two vectors of __cpp_int's, our first, fairly trivial
implementation might look like this:

[dot_prod_1]

However, in order to reduce the need for memory allocations when constructing the temporaries needed
for the multiply-and-add operations, we could use an equivalent type with a larger internal cache like this:

[dot_prod_2]

Before we compare performance though, there is one other obvious thing we could try.  By simply declaring
a variable for the result of the intermediate multiplications, and reusing that variable each time through
the loop, we might also expect to greatly reduce the number of allocations required.

[dot_prod_3]

We'll begin by comparing how many actual allocations were required to calculate the dot product of 1000 
value vectors for random data with various bit counts:

[table
[[Bit Count][Allocations Count Version 1][Allocations Count Version 2][Allocations Count Version 3]]
[[32][1[footnote Here everything fits within __cpp_int's default internal cache, so no allocation are required.]][0][0]]
[[64][1001][1[footnote A single allocation for the return value.]][1]]
[[128][1002][1][2]]
[[256][1002][1][3[footnote Here the input data is such that more than one allocation is required for the temporary.]]]
[[512][1002][1][3]]
[[1024][1002][1001[footnote At this point we exceed the internal cache of our internal calculation type.]][3]]
]

Timings for the three methods are as follows (MSVC-16.8.0, x64):

[table
[[Bit Count][time/ms Version 1][time/ms Version 2][time/ms Version 3]]
[[32][0.021][0.021][0.021]]
[[64][0.032][0.032][0.029]]
[[128][0.099][0.041][0.041]]
[[256][0.154][0.091][0.094]]
[[512][0.323][0.270][0.269]]
[[1024][0.998][0.995][0.949]]
]

As you can see, there is a sweet spot for middling-sized integers where we gain: if the values are small, then
__cpp_int's own internal cache is large enough anyway, and no allocation occur.  Conversely, if the values are
sufficiently large, then the cost of the actual arithmetic dwarfs the memory allocation time.  In this particular
case, carefully writing the code (version 3) is clearly at least as good as using a separate type with a larger cache.
However, there may be times when it's not practical to re-write existing code, purely to optimise it for the 
multiprecision use case.

A typical example where we can't rewrite our code to avoid unnecessary allocations, occurs when we're calling an
external routine.  For example the arc length of an ellipse with radii ['a] and ['b] is given by:

[pre L(a, b) = 4aE(k)]

with:

[pre k = [sqrt](1 - b[super 2]/a[super 2])]

where ['E(k)] is the complete elliptic integral of the second kind, which is available as a template function `ellint_2` in Boost.Math.

Naively, we might implement this for use with __mpfr_float_backend like this:

[elliptic_arc1]

But we might also try mixing our arithmetic types - regular dynamically allocated __mpfr_float_backend's for the
interface to minimise memory footprint in our external storage, and statically allocated __mpfr_float_backend's
for the internal arithmetic:

[elliptic_arc2]

The performance comparisons are surprisingly stark:

[table
[[N][`number<mpfr_float_backend<N>>` / ms][`number<mpfr_float_backend<N, allocate_stack>>` / ms]]
[[30][19.5][3.1]]
[[40][12.5][6.2]]
[[50][14.4][6.6]]
[[60][18.0][9.5]]
[[70][18.0][9.6]]
[[80][20.0][12.8]]
]

As before, the results are for MSVC-16.8.0/x64, and in point of fact, the results do not always favour
non-allocating types so much, it does depend very much on the special function being called and/or the arguments used.

[h4 Backends With Optimized Mixed Precision Arithmetic]

The following backends have at least some direct support for mixed-precision arithmetic,
and therefore avoid creating unnecessary temporaries when using the interfaces above.
Therefore when using these types it's more efficient to use mixed-precision arithmetic,
than it is to explicitly cast the operands to the result type:

__mpfr_float_backend, __mpf_float, __cpp_int.

[endsect] [/section:mixed Mixed Precision Arithmetic]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_mpc_complex.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:mpc_complex mpc_complex]

`#include <boost/multiprecision/mpc.hpp>`

   namespace boost{ namespace multiprecision{

   template <unsigned Digits10>
   class mpc_complex_backend;

   typedef number<mpc_complex_backend<50> >    mpc_complex_50;
   typedef number<mpc_complex_backend<100> >   mpc_complex_100;
   typedef number<mpc_complex_backend<500> >   mpc_complex_500;
   typedef number<mpc_complex_backend<1000> >  mpc_complex_1000;
   typedef number<mpc_complex_backend<0> >     mpc_complex;

   }} // namespaces

The `mpc_complex_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpc] `mpc_t`
to provide an real-number type that is a drop-in replacement for `std::complex`, but with
much greater precision.

Type `mpc_complex_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
at variable precision by setting the template argument to zero.  The typedefs mpc_complex_50, mpc_complex_100,
mpc_complex_500, mpc_complex_1000 provide complex types at 50, 100, 500 and 1000 decimal digits precision
respectively.  The typedef mpc_complex provides a variable precision type whose precision can be controlled via the
`number`s member functions.

The `mpc` backend should allow use of the same syntax as the C++ standard library complex type.
When using this backend, remember to link with the flags `-lmpc -lmpfr -lgmp`.

As well as the usual conversions from arithmetic and string types, instances of `number<mpc_complex_backend<N> >` are
copy constructible and assignable from:

* The [gmp] native types `mpf_t`, `mpz_t`, `mpq_t`.
* The [mpfr] native type `mpfr_t`.
* The [mpc] native type `mpc_t`.
* The `number` wrappers around those types: `number<mpfr_float_backend<M> >`, `number<mpf_float<M> >`, `number<gmp_int>`, `number<gmp_rational>`.

It's also possible to access the underlying `mpc_t` via the `data()` member function of `mpfr_float_backend`.

Things you should know when using this type:

* A default constructed `mpc_complex_backend` is set to zero (['Note that this is [*not] the default [mpc] behavior]).
* All operations use round to nearest.
* No changes are made to [mpc], [gmp] or [mpfr] global settings, so this type can coexist with existing
[mpc], [mpfr] or [gmp] code.
* The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid complex number.
* Division by zero results in a complex-infinity.
* Unlike `std::complex`, you can not use `reinterpret_cast` to treat this type as an array of the underlying floating point type.
* Unlike `std::complex`, there are no literals for imaginary values.
* When using the variable precision type `mpc_complex`, then copy construction and assignment ['copies the precision
of the source variable].  Likewise move construction and assignment.
* When constructing the variable precision type `mpc_complex` you can specify two arguments to the constructor - the first
is the value to assign to the variable, the second is an unsigned integer specifying the precision in decimal places.  The
`assign` member function similarly has a 2-argument overload taking the value to assign and the precision.  You can use this
to preserve the precision of the target variable using the somewhat arcane: `a.assign(b, a.precision())`, which assigns `b` to `a`
but preserves the precision of `a`.

[h5 [mpc] example:]

[mpc_eg]

Which produces the output (for the multiprecision type):

[mpc_out]

[endsect] [/section:mpc_complex mpc_complex]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_mpfr_float.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:mpfr_float mpfr_float]

`#include <boost/multiprecision/mpfr.hpp>`

   namespace boost{ namespace multiprecision{

   enum mpfr_allocation_type
   {
      allocate_stack,
      allocate_dynamic
   };

   template <unsigned Digits10, mpfr_allocation_type AllocateType = allocate_dynamic>
   class mpfr_float_backend;

   typedef number<mpfr_float_backend<50> >    mpfr_float_50;
   typedef number<mpfr_float_backend<100> >   mpfr_float_100;
   typedef number<mpfr_float_backend<500> >   mpfr_float_500;
   typedef number<mpfr_float_backend<1000> >  mpfr_float_1000;
   typedef number<mpfr_float_backend<0> >     mpfr_float;

   typedef number<mpfr_float_backend<50, allocate_stack> >    static_mpfr_float_50;
   typedef number<mpfr_float_backend<100, allocate_stack> >   static_mpfr_float_100;

   }} // namespaces

The `mpfr_float_backend` type is used in conjunction with `number`: It acts as a thin wrapper around the [mpfr] `mpfr_t`
to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with
much greater precision.

Type `mpfr_float_backend` can be used at fixed precision by specifying a non-zero `Digits10` template parameter, or
at variable precision by setting the template argument to zero.  The typedefs mpfr_float_50, mpfr_float_100,
mpfr_float_500, mpfr_float_1000 provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision
respectively.  The typedef mpfr_float provides a variable precision type whose precision can be controlled via the
`number`s member functions.

In addition the second template parameter lets you choose between dynamic allocation (the default,
and uses MPFR's normal allocation routines),
or stack allocation (where all the memory required for the underlying data types is stored
within `mpfr_float_backend`).  The latter option can result in significantly faster code, at the
expense of growing the size of `mpfr_float_backend`.  It can only be used at ['fixed precision], and
should only be used for lower digit counts.  Note that we can not guarantee that using `allocate_stack`
won't cause any calls to `mpfr`'s allocation routines, as `mpfr` may call these inside its own code.
The following table gives an idea of the performance tradeoff's at 50 decimal digits
precision[footnote Compiled with VC++10 and /Ox, with MPFR-3.0.0 and MPIR-2.3.0]:

[table
[[Type][Bessel function evaluation, relative times]]
[[`number<mpfr_float_backend<50, allocate_static>, et_on>`][1.0 (5.5s)]]
[[`number<mpfr_float_backend<50, allocate_static>, et_off>`][1.05 (5.8s)]]
[[`number<mpfr_float_backend<50, allocate_dynamic>, et_on>`][1.05 (5.8s)]]
[[`number<mpfr_float_backend<50, allocate_dynamic>, et_off>`][1.16 (6.4s)]]
]

[note This type only provides `numeric_limits` support when the precision is fixed at compile time.]

As well as the usual conversions from arithmetic and string types, instances of `number<mpfr_float_backend<N> >` are
copy constructible and assignable from:

* The [gmp] native types `mpf_t`, `mpz_t`, `mpq_t`.
* The [mpfr] native type `mpfr_t`.
* The `number` wrappers around those types: `number<mpfr_float_backend<M> >`, `number<mpf_float<M> >`, `number<gmp_int>`, `number<gmp_rational>`.

It's also possible to access the underlying `mpfr_t` via the data() member function of `mpfr_float_backend`.

Things you should know when using this type:

* A default constructed `mpfr_float_backend` is set to zero (['Note that this is [*not] the default [mpfr] behavior]).
* All operations use round to nearest.
* No changes are made to [gmp] or [mpfr] global settings, so this type can coexist with existing
[mpfr] or [gmp] code.
* The code can equally use [mpir] in place of [gmp] - indeed that is the preferred option on Win32.
* This backend supports rvalue-references and is move-aware, making instantiations of `number` on this backend move aware.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid floating-point number.
* Division by zero results in an infinity.
* When using the variable precision type `mpfr_float`, then copy construction and assignment ['copies the precision
of the source variable].  Likewise move construction and assignment.
* When constructing the variable precision type `mpfr_float` you can specify two arguments to the constructor - the first
is the value to assign to the variable, the second is an unsigned integer specifying the precision in decimal places.  The
`assign` member function similarly has a 2-argument overload taking the value to assign and the precision.  You can use this
to preserve the precision of the target variable using the somewhat arcane: `a.assign(b, a.precision())`, which assigns `b` to `a`
but preserves the precision of `a`.

[h5 [mpfr] example:]

[mpfr_eg]

[endsect] [/section:mpfr_float mpfr_float]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_new_backend.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:new_backend Writing a New Backend]

The formal requirements for a backend to class `number` are given in the reference, but to help
speed and simplify the process there is a header [@../../test/skeleton_backend.hpp skeleton_backend.hpp]
where all the methods needed to be written are declared but nothing is implemented.  The process of
writing a new backend then simplifies to:

* Save skeleton_backend.hpp under a new name and change its #include guards to match.
* Search and replace `skeleton_backend` to the name of the new backend type.
* Fill in the blanks in the class definition and for the compulsary non-members.
* Don't forget to mark the functions as `inline`, `constexpr` and `noexcept` as required.
* Optionally fill in some of the optional methods - the header declares these in rather
  verbose form, for example with overloads for every single arithmetic type.  No sane backend
  would ever implement all of these, just choose the ones that make sense and leave the others.
* Add convenience typedefs for the actual instantiation(s) of class `number` that will use the new backend.

To test the new backend, start with a basic arithmetic test, this is a test case under `libs/math/test`
that looks something like:

   #include <boost/multiprecision/my_new_number_type.hpp>
   #include "test_arithmetic.hpp"

   int main()
   {
      test<boost::multiprecision::my_new_number_type>();
      return boost::report_errors();
   }

This will basically "instantiate everything", and perform a few runtime sanity checks; it is a very good test that you have written legal code!

You should also create a "header include test" that verifies that the new header includes everything it should, see 
[@../../test/include_test/mpfr_include_test.cpp mpfr_include_test.cpp] for an example.

For integer types, you should add the new type to at least the following tests as well:

* test_hash.cpp
* test_int_io.cpp
* test_move.cpp
* test_numeric_limits.cpp

For floating point types, you should add the new type to at least the following tests as well:

* test_acos.cpp
* test_asin.cpp
* test_atan.cpp
* test_constants.cpp
* test_cos.cpp
* test_cosh.cpp
* test_exp.cpp
* test_float_io.cpp
* test_fpclassify.cpp
* test_hash.cpp
* test_log.cpp
* test_move.cpp
* test_numeric_limits.cpp
* test_pow.cpp
* test_round.cpp
* test_sf_import_c99.cpp
* test_sin.cpp
* test_sinh.cpp
* test_sqrt.cpp
* test_tan.cpp
* test_tanh.cpp
* concepts/number_concept_check.cpp
* concepts/sf_concept_check_basic.cpp
* concepts/sf_concept_check_bessel.cpp
* concepts/sf_concept_check_beta.cpp
* concepts/sf_concept_check_beta_2.cpp
* concepts/sf_concept_check_beta_3.cpp
* concepts/sf_concept_check_elliptic.cpp
* concepts/sf_concept_check_gamma.cpp
* concepts/sf_concept_check_poly.cpp

[endsect] [/section:new_backend Writing a New Backend]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_numeric_limits.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:limits Numeric Limits]

Boost.Multiprecision tries hard to implement `std::numeric_limits` for all types
as far as possible and meaningful because experience with Boost.Math has shown that this aids portability.

The [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf C++ standard library]
defines `std::numeric_limits` in section 18.3.2.

This in turn refers to the C standard
[@http://www.open-std.org/jtc1/sc22/wg11/docs/n507.pdf SC22/WG11 N507 DRAFT INTERNATIONAL ISO/IEC STANDARD
 WD 10967-1]
Information technology Language independent arithmetic Part 1: Integer and floating-point arithmetic.

That C Standard in turn refers to

[@https://doi.org/10.1109/IEEESTD.1985.82928 IEEE754 IEEE Standard for Binary
Floating-Point Arithmetic]

There is a useful summary of `std::numeric_limits` at
[@http://www.cplusplus.com/reference/limits/numeric_limits/ C++ reference].

The chosen backend often determines how completely `std::numeric_limits` is available.

Compiler options, processor type, and definition of macros or assembler instructions to control denormal numbers will alter
the values in the tables given below.

[warning GMP's extendable floatin-point `mpf_t` does not have a concept of overflow:
operations that lead to overflow eventually run of out of resources
and terminate with stack overflow (often after several seconds).]

[section:constants std::numeric_limits<>  constants]

[h4 is_specialized]

`true` for all arithmetic types (integer, floating and fixed-point)
for which `std::numeric_limits<T>::numeric_limits` is specialized.

A typical test is

  if (std::numeric_limits<T>::is_specialized == false)
  {
    std::cout << "type " << typeid(T).name()  << " is not specialized for std::numeric_limits!" << std::endl;
  // ...
  }

Typically `numeric_limits<T>::is_specialized` is `true` for all `T` where the compile-time constant
members of `numeric_limits` are indeed known at compile time, and don't vary at runtime.  For example
floating-point types with runtime-variable precision such as `mpfr_float` have no `numeric_limits`
specialization as it would be impossible to define all the members at compile time.  In contrast
the precision of a type such as `mpfr_float_50` is known at compile time, and so it ['does] have a
`numeric_limits` specialization.

Note that not all the `std::numeric_limits` member constants and functions are meaningful for all user-defined types (UDT),
such as the decimal and binary multiprecision types provided here.  More information on this is given in the sections below.

[h4 infinity]

For floating-point types, [infin] is defined wherever possible,
but clearly infinity is meaningless for __arbitrary_precision arithmetic backends,
and there is one floating-point type (GMP's `mpf_t`, see __mpf_float) which has no notion
of infinity or NaN at all.

A typical test whether infinity is implemented is

  if(std::numeric_limits<T>::has_infinity)
  {
     std::cout << std::numeric_limits<T>::infinity() << std::endl;
  }

and using tests like this is strongly recommended to improve portability.

[warning If the backend is switched to a type that does not support infinity (or similarly NaNs) then,
without checks like this, there will be trouble.]

[h4 is_signed]

`std::numeric_limits<T>::is_signed == true` if the type `T` is signed.

For __fundamental binary types, the sign is held in a single bit,
but for other types (`cpp_dec_float` and `cpp_bin_float`)
it may be a separate storage element, usually `bool`.

[h4 is_exact]

`std::numeric_limits<T>::is_exact == true` if type T uses exact representations.

This is defined as `true` for all integer types and `false` for floating-point types.

[@http://stackoverflow.com/questions/14203654/stdnumeric-limitsis-exact-what-is-a-usable-definition A usable definition]
has been discussed.

ISO/IEC 10967-1, Language independent arithmetic, noted by the C++ Standard defines

  A floating-point type F shall be a finite subset of [real].

The important practical distinction is that all integers (up to `max()`) can be stored exactly.

[@http://en.wikipedia.org/wiki/Rational_number Rational]
types using two integer types are also exact.

Floating-point types [*cannot store all real values]
(those in the set of [real]) [*exactly].
For example, 0.5 can be stored exactly in a binary floating-point, but 0.1 cannot.
What is stored is the nearest representable real value, that is, rounded to nearest.

Fixed-point types (usually decimal) are also defined as exact, in that they only
store a [*fixed precision], so half cents or pennies (or less) cannot be stored.
The results of computations are rounded up or down,
just like the result of integer division stored as an integer result.

There are number of proposals to
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3407.html
add Decimal floating-point Support to C++].

[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2849.pdf Decimal TR].

And also
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html
C++ Binary Fixed-Point Arithmetic].

[h4 is_bounded]

`std::numeric_limits<T>::is_bounded == true` if the set of values represented by the type `T` is finite.

This is `true` for all __fundamental_type integer, fixed and floating-point types,
and most multi-precision types.

It is only `false` for a few __arbitrary_precision types like `cpp_int`.

Rational and fixed-exponent representations are exact but not integer.

[h4 is_modulo]

`std::numeric_limits<T>::is_modulo` is defined as `true` if adding two positive values of type T
can yield a result less than either value.

`is_modulo == true` means that the type does not overflow, but, for example,
'wraps around' to zero, when adding one to the `max()` value.

For most __fundamental integer types, `std::numeric_limits<>::is_modulo` is `true`.

`bool` is the only exception.

The modulo behaviour is sometimes useful,
but also can be unexpected, and sometimes undesired, behaviour.

Overflow of signed integers can be especially unexpected,
possibly causing change of sign.

Boost.Multiprecision integer type `cpp_int` is not modulo
because as an __arbitrary_precision types,
it expands to hold any value that the machine resources permit.

However fixed precision __cpp_int's may be modulo if they are unchecked
(i.e. they behave just like __fundamental integers), but not if they are checked
(overflow causes an exception to be raised).

__fundamental and multi-precision floating-point types are normally not modulo.

Where possible, overflow is to `std::numeric_limits<>::infinity()`,
provided `std::numeric_limits<>::has_infinity == true`.

[h4 radix]

Constant `std::numeric_limits<T>::radix` returns either 2 (for __fundamental and binary types)
or 10 (for decimal types).

[h4 digits]

The number of `radix` digits that be represented without change:

* for integer types, the number of [*non-sign bits] in the significand.
* for floating types, the number of [*radix digits] in the significand.

The values include any implicit bit, so for example, for the ubiquious
`double` using 64 bits
([@http://en.wikipedia.org/wiki/Double_precision_floating-point_format IEEE binary64 ]),
`digits` == 53, even though there are only 52 actual bits of the significand stored in the representation.
The value of `digits` reflects the fact that there is one implicit bit which is always set to 1.

The Boost.Multiprecision binary types do not use an implicit bit, so the
`digits` member reflects exactly how many bits of precision were requested:

  typedef number<cpp_bin_float<53, digit_base_2> >   float64;
  typedef number<cpp_bin_float<113, digit_base_2> >  float128;
  std::numeric_limits<float64>::digits == 53.
  std::numeric_limits<float128>::digits == 113.

For the most common case of `radix == 2`,
`std::numeric_limits<T>::digits` is the number of bits in the representation,
not counting any sign bit.

For a decimal integer type, when `radix == 10`, it is the number of decimal digits.

[h4 digits10]

Constant `std::numeric_limits<T>::digits10` returns the number of
decimal digits that can be represented without change or loss.

For example, `numeric_limits<unsigned char>::digits10` is 2.

This somewhat inscrutable definition means that an `unsigned char`
can hold decimal values `0..99`
without loss of precision or accuracy, usually from truncation.

Had the definition been 3 then that would imply it could hold 0..999,
but as we all know, an 8-bit `unsigned char` can only hold 0..255,
and an attempt to store 256 or more will involve loss or change.

For bounded integers, it is thus [*one less] than number of decimal digits
you need to display the biggest integer `std::numeric_limits<T>::max()`.
This value can be used to predict the layout width required for

[digits10_1]

For example, `unsigned short` is often stored in 16 bits,
so the maximum value is 0xFFFF or 65535.

[digits10_2]


For bounded floating-point types,
if we create a `double` with a value with `digits10` (usually 15) decimal digits,
`1e15` or `1000000000000000` :

[digits10_3]

and we can increment this value to `1000000000000001`
as expected and show the difference too.

But if we try to repeat this with more than `digits10` digits,

[digits10_4]

then we find that when we add one it has no effect,
and display show that there is loss of precision. See
[@http://en.wikipedia.org/wiki/Loss_of_significance Loss of significance or cancellation error].

So `digits10` is the number of decimal digits [*guaranteed] to be correct.

For example, 'round-tripping' for `double`:

* If a decimal string with at most `digits10`( == 15) significant decimal digits
is converted to `double` and then converted back to the
same number of significant decimal digits,
then the final string will match the original 15 decimal digit string.
* If a `double` floating-point number is converted to a decimal string
with at least 17 decimal digits
and then converted back to `double`,
then the result will be binary identical to the original `double` value.

For most purposes, you will much more likely want
`std::numeric_limits<>::max_digits10`,
the number of decimal digits that ensure that a change of one least significant bit (__ULP)
produces a different decimal digits string.

For the most common `double` floating-point type,`max_digits10` is `digits10+2`,
but you should use C++11 `max_digits10`
where possible (see [link boost_multiprecision.tut.limits.constants.max_digits10 below]).

[h4:max_digits10 max_digits10]

`std::numeric_limits<T>::max_digits10` was added for floating-point
because `digits10` decimal digits are insufficient to show
a least significant bit (ULP) change giving puzzling displays like

  0.666666666666667 != 0.666666666666667

from failure to 'round-trip', for example:

[max_digits10_2]

If you wish to ensure that a change of one least significant bit (ULP)
produces a different decimal digits string,
then `max_digits10` is the precision to use.

For example:

[max_digits10_3]

will display [pi] to the maximum possible precision using a `double`.

[max_digits10_4]

For integer types, `max_digits10` is implementation-dependent,
but is usually `digits10 + 2`.
This is the output field-width required for the maximum value of the type T
`std::numeric_limits<T>::max()` ['including a sign and a space].

So this will produce neat columns.

  std::cout << std::setw(std::numeric_limits<int>::max_digits10) ...

The extra two or three least-significant digits are 'noisy' and may be junk,
but if you want to 'round-trip' - printing a value out as a decimal digit string and reading it back in -
(most commonly during serialization and de-serialization)
you must use `os.precision(std::numeric_limits<T>::max_digits10)`.

[note For Microsoft Visual Studio 2010,
`std::numeric_limits<float>::max_digits10` is wrongly defined as 8. It should be 9.
]

[note For Microsoft Visual Studio before 2013 and the default floating-point
format, a small range of double-precision floating-point values with a
significand of approximately 0.0001 to 0.004 and exponent values of 1010 to
1014 do not round-trip exactly being off by one least significant bit,
for probably every third value of the significand.

A workaround is using the scientific or exponential format `std::scientific`.

Other older compilers also fail to implement round-tripping entirely fault-free, for example, see
[@https://www.exploringbinary.com/incorrectly-rounded-conversions-in-gcc-and-glibc/  Incorrectly Rounded Conversions in GCC and GLIBC].

For more details see
[@https://www.exploringbinary.com/incorrect-round-trip-conversions-in-visual-c-plus-plus/ Incorrect Round-Trip Conversions in Visual C++],
and references therein
and
[@https://arxiv.org/pdf/1310.8121.pdf  Easy Accurate Reading and Writing of Floating-Point Numbers, Aubrey Jaffer (August 2018)].

Microsoft VS2017 and other recent compilers, now use the
[@https://doi.org/10.1145/3192366.3192369 Ryu fast float-to-string conversion by Ulf Adams]
algorithm, claimed to be both exact and fast for 32 and 64-bit floating-point numbers.
] [/note]

[h4 round_style]

The rounding style determines how the result of floating-point operations
is treated when the result cannot be [*exactly represented] in the significand.
Various rounding modes may be provided:

* round to nearest up or down (default for floating-point types).
* round up (toward positive infinity).
* round down (toward negative infinity).
* round toward zero (integer types).
* no rounding (if decimal radix).
* rounding mode is not determinable.

For integer types, `std::numeric_limits<T>::round_style` is always towards zero, so

  std::numeric_limits<T>::round_style == std::round_to_zero;

A decimal type, `cpp_dec_float` rounds in no particular direction,
which is to say it doesn't round at all.
And since there are several guard digits,
it's not really the same as truncation (round toward zero) either.

For floating-point types, it is normal to round to nearest.

  std::numeric_limits<T>::round_style == std::round_to_nearest;

See function `std::numeric_limits<T>::round_error` for the maximum error (in ULP)
that rounding can cause.

[h4 has_denorm_loss]

`true` if a loss of precision is detected as a
[@http://en.wikipedia.org/wiki/Denormalization denormalization] loss,
rather than an inexact result.

Always `false` for integer types.

`false` for all types which do not have `has_denorm` == `std::denorm_present`.

[h4 denorm_style]

[@http://en.wikipedia.org/wiki/Denormal_number Denormalized values] are
representations with a variable number of exponent bits that can permit
gradual underflow, so that, if type T is `double`.

 std::numeric_limits<T>::denorm_min() < std::numeric_limits<T>::min()

A type may have any of the following `enum float_denorm_style` values:

* `std::denorm_absent`, if it does not allow denormalized values.
(Always used for all integer and exact types).
* `std::denorm_present`, if the floating-point type allows denormalized values.
*`std::denorm_indeterminate`, if indeterminate at compile time.

[h4 Tinyness before rounding]

`bool std::numeric_limits<T>::tinyness_before`

`true` if a type can determine that a value is too small
to be represent as a normalized value before rounding it.

Generally true for `is_iec559` floating-point __fundamantal types,
but false for integer types.

Standard-compliant IEEE 754 floating-point implementations may detect the floating-point underflow at three predefined moments:

# After computation of a result with absolute value smaller than
`std::numeric_limits<T>::min()`,
such implementation detects ['tinyness before rounding] (e.g. UltraSparc).

# After rounding of the result to `std::numeric_limits<T>::digits` bits,
if the result is tiny, such implementation detects ['tinyness after rounding]
(e.g. SuperSparc).

# If the conversion of the rounded tiny result to subnormal form
resulted in the loss of precision, such implementation detects ['denorm loss].

[endsect] [/section:constants std::numeric_limits<> Constants]

[section:functions `std::numeric_limits<>` functions]

[h4:max_function `max` function]

Function `(std::numeric_limits<T>::max)()` returns the largest finite value
that can be represented by the type T.  If there is no such value (and
`numeric_limits<T>::bounded` is `false`) then returns `T()`.

For __fundamental types there is usually a corresponding MACRO value TYPE_MAX,
where TYPE is CHAR, INT, FLOAT etc.

Other types, including those provided by a typedef,
for example `INT64_T_MAX` for `int64_t`, may provide a macro definition.

To cater for situations where no `numeric_limits` specialization is available
(for example because the precision of the type varies at runtime),
packaged versions of this (and other functions) are provided using

  #include <boost/math/tools/precision.hpp>

  T = boost::math::tools::max_value<T>();

Of course, these simply use `(std::numeric_limits<T>::max)()` if available,
but otherwise 'do something sensible'.

[h4 lowest function]

Since C++11: `std::numeric_limits<T>::lowest()` is

* For integral types, the same as function `min()`.
* For floating-point types, generally the negative of `max()`
(but implementation-dependent).

[digits10_5]

[h4:min_function `min` function]

Function `(std::numeric_limits<T>::min)()` returns the minimum finite value
that can be represented by the type T.

For __fundamental types, there is usually a corresponding MACRO value TYPE_MIN,
where TYPE is CHAR, INT, FLOAT etc.

Other types, including those provided by a `typedef`,
for example, `INT64_T_MIN` for `int64_t`, may provide a macro definition.

For floating-point types,
it is more fully defined as the ['minimum positive normalized value].

See `std::numeric_limits<T>::denorm_min()` for the smallest denormalized value, provided

  std::numeric_limits<T>::has_denorm == std::denorm_present

To cater for situations where no `numeric_limits` specialization is available
(for example because the precision of the type varies at runtime),
packaged versions of this (and other functions) are provided using

  #include <boost/math/tools/precision.hpp>

  T = boost::math::tools::min_value<T>();

Of course, these simply use `std::numeric_limits<T>::min()` if available.

[h4 denorm_min function]

Function `std::numeric_limits<T>::denorm_min()`
returns the smallest
[@http://en.wikipedia.org/wiki/Denormal_number denormalized value],
provided

  std::numeric_limits<T>::has_denorm == std::denorm_present

[denorm_min_1]

The exponent is effectively reduced from -308 to -324
(though it remains encoded as zero and leading zeros appear in the significand,
thereby losing precision until the significand reaches zero).

[h4 round_error]

Function `std::numeric_limits<T>::round_error()` returns the maximum error
(in units of __ULP)
that can be caused by any basic arithmetic operation.

  round_style == std::round_indeterminate;

The rounding style is indeterminable at compile time.

For floating-point types, when rounding is to nearest,
only half a bit is lost by rounding, and `round_error == 0.5`.
In contrast when rounding is towards zero, or plus/minus infinity,
we can loose up to one bit from rounding, and `round_error == 1`.

For integer types, rounding always to zero, so at worst almost one bit can be rounded,
so `round_error == 1`.

`round_error()` can be used with `std::numeric_limits<T>::epsilon()` to estimate
the maximum potential error caused by rounding.  For typical floating-point types,
`round_error() = 1/2`, so half epsilon is the maximum potential error.

[round_error_1]

There are, of course, many occasions when much bigger loss of precision occurs,
for example, caused by
[@http://en.wikipedia.org/wiki/Loss_of_significance Loss of significance or cancellation error]
or very many iterations.

[h4:epsilon epsilon]

Function `std::numeric_limits<T>::epsilon()` is meaningful only for non-integral types.

It returns the difference between `1.0` and the next value representable
by the floating-point type T.
So it is a one least-significant-bit change in this floating-point value.

For `double` (`float_64t`) it is `2.2204460492503131e-016`
showing all possibly significant 17 decimal digits.

[epsilon_1]

We can explicitly increment by one bit using the function `boost::math::float_next()`
and the result is the same as adding `epsilon`.

[epsilon_2]

Adding any smaller value, like half `epsilon`,  will have no effect on this value.

[epsilon_3]

So this cancellation error leaves the values equal, despite adding half `epsilon`.

To achieve greater portability over platform and floating-point type,
Boost.Math and Boost.Multiprecision provide a package of functions that
'do something sensible' if the standard `numeric_limits` is not available.
To use these `#include <boost/math/tools/precision.hpp>`.

[epsilon_4]

[h5:FP_tolerance Tolerance for Floating-point Comparisons]

[@https://en.wikipedia.org/wiki/Machine_epsilon Machine epsilon [epsilon]]
is very useful to compute a tolerance when comparing floating-point values,
a much more difficult task than is commonly imagined.

The C++ standard specifies [@https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon  `std::numeric_limits<>::epsilon()`]
and Boost.Multiprecision implements this (where possible) for its program-defined types analogous to the
__fundamental floating-point types like `double` `float`.

For more information than you probably want (but still need) see
[@http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html What Every Computer Scientist Should Know About Floating-Point Arithmetic]

The naive test comparing the absolute difference between two values and a tolerance
does not give useful results if the values are too large or too small.

So Boost.Test uses an algorithm first devised by Knuth
for reliably checking if floating-point values are close enough.

See Donald. E. Knuth. The art of computer programming (vol II).
Copyright 1998 Addison-Wesley Longman, Inc., 0-201-89684-2.
Addison-Wesley Professional; 3rd edition. (The relevant equations are in paragraph 4.2.2, Eq. 36 and 37.)

See [@https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/testing_tools/extended_comparison/floating_point/floating_points_comparison_theory.html Boost.Math floating_point comparison]
for more details.

See also:

[@http://adtmag.com/articles/2000/03/15/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx Alberto Squassia, Comparing floats]

[@http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx Alberto Squassia, Comparing floats code]

[@https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/testing_tools/extended_comparison/floating_point.html Boost.Test Floating-Point_Comparison]

[tolerance_1]

used thus:

  cd ./test
  BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);

(There is also a version BOOST_CHECK_CLOSE using tolerance as a [*percentage] rather than a fraction;
usually the fraction version is simpler to use).

[tolerance_2]

[h4:infinity Infinity - positive and negative]

For floating-point types only, for which
`std::numeric_limits<T>::has_infinity == true`,
function `std::numeric_limits<T>::infinity()`
provides an implementation-defined representation for [infin].

The 'representation' is a particular bit pattern reserved for infinity.
For IEEE754 system (for which `std::numeric_limits<T>::is_iec559 == true`)
[@http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity positive and negative infinity]
are assigned bit patterns for all defined floating-point types.

Confusingly, the string resulting from outputting this representation, is also
implementation-defined. And the string that can be input to generate the representation is also implementation-defined.

For example, the output is `1.#INF` on Microsoft systems, but `inf` on most *nix platforms.

This implementation-defined-ness has hampered use of infinity (and NaNs)
but __Boost_Math and __Boost_Multiprecision work hard to provide a sensible representation
for [*all] floating-point types, not just the __fundamental_types,
which with the use of suitable facets to define the input and output strings, makes it possible
to use these useful features portably and including __Boost_Serialization.

[h4 Not-A-Number NaN]

[h5 Quiet_NaN]

For floating-point types only, for which
`std::numeric_limits<T>::has_quiet_NaN == true`,
function `std::numeric_limits<T>::quiet_NaN()`
provides an implementation-defined representation for NaN.

[@http://en.wikipedia.org/wiki/NaN NaNs] are values to indicate that the
result of an assignment or computation is meaningless.
A typical example is `0/0` but there are many others.

NaNs may also be used, to represent missing values: for example,
these could, by convention, be ignored in calculations of statistics like means.

Many of the problems with a representation for
[@http://en.wikipedia.org/wiki/NaN Not-A-Number] has hampered portable use,
similar to those with infinity.

[nan_1]

But using Boost.Math and suitable facets can permit portable use
of both NaNs and positive and negative infinity.

[facet_1]

[h5 Signaling NaN]

For floating-point types only, for which
`std::numeric_limits<T>::has_signaling_NaN == true`,
function `std::numeric_limits<T>::signaling_NaN()`
provides an implementation-defined representation for NaN that causes a hardware trap.
It should be noted however, that at least one implementation of this function causes a hardware
trap to be triggered simply by calling `std::numeric_limits<T>::signaling_NaN()`, and not only
by using the value returned.

[endsect] [/section:functions std::numeric_limits<>  functions]

[/ Tables of values for numeric_limits for various __fundamental and cpp_bin_float types]
[include numeric_limits_32_tables.qbk]
[/include numeric_limits_64_tables.qbk]

[section:how_to_tell How to Determine the Kind of a Number From `std::numeric_limits`]

Based on the information above, one can see that different kinds of numbers can be
differentiated based on the information stored in `std::numeric_limits`.  This is
in addition to the traits class [link boost_multiprecision.ref.number.traits_class_support
number_category] provided by this library.

[h4 Integer Types]

For an integer type T, all of the following conditions hold:

   std::numeric_limits<T>::is_specialized == true
   std::numeric_limits<T>::is_integer == true
   std::numeric_limits<T>::is_exact == true
   std::numeric_limits<T>::min_exponent == 0
   std::numeric_limits<T>::max_exponent == 0
   std::numeric_limits<T>::min_exponent10 == 0
   std::numeric_limits<T>::max_exponent10 == 0

In addition the type is /signed/ if:

   std::numeric_limits<T>::is_signed == true

If the type is arbitrary precision then:

   std::numeric_limits<T>::is_bounded == false

Otherwise the type is bounded, and returns a non zero value
from:

   std::numeric_limits<T>::max()

and has:

   std::numeric_limits<T>::is_modulo == true

if the type implements modulo arithmetic on overflow.

[h4 Rational Types]

Rational types are just like integers except that:

   std::numeric_limits<T>::is_integer == false

[h4 Fixed Precision Types]

There appears to be no way to tell these apart from rational types, unless they set:

   std::numeric_limits<T>::is_exact == false

This is because these types are in essence a rational type with a fixed denominator.

[h4 floating-point Types]

For a floating-point type T, all of the following conditions hold:

   std::numeric_limits<T>::is_specialized == true
   std::numeric_limits<T>::is_integer == false
   std::numeric_limits<T>::is_exact == false
   std::numeric_limits<T>::min_exponent != 0
   std::numeric_limits<T>::max_exponent != 0
   std::numeric_limits<T>::min_exponent10 != 0
   std::numeric_limits<T>::max_exponent10 != 0

In addition the type is /signed/ if:

   std::numeric_limits<T>::is_signed == true

And the type may be decimal or binary depending on the value of:

   std::numeric_limits<T>::radix

In general, there are no arbitrary precision floating-point types, and so:

   std::numeric_limits<T>::is_bounded == false

[h4 Exact floating-point Types]

Exact floating-point types are a [@http://en.wikipedia.org/wiki/Field_%28mathematics%29 field]
composed of an arbitrary precision integer scaled by an exponent.  Such types
have no division operator and are the same as floating-point types except:

      std::numeric_limits<T>::is_exact == true

[h4 Complex Numbers]

For historical reasons, complex numbers do not specialize `std::numeric_limits`, instead you must
inspect `std::numeric_limits<typename T::value_type>`.

[endsect] [/section:how_to_tell How to Determine the Kind of a Number From `std::numeric_limits`]

[endsect] [/section:limits Numeric Limits]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_primality.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:primetest Primality Testing]

The library implements a Miller-Rabin test for primality:

   #include <boost/multiprecision/miller_rabin.hpp>

   template <class Backend, expression_template_option ExpressionTemplates, class Engine>
   bool miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials, Engine& gen);

   template <class Backend, expression_template_option ExpressionTemplates, class Engine>
   bool miller_rabin_test(const number<Backend, ExpressionTemplates>& n, unsigned trials);

These functions perform a Miller-Rabin test for primality, if the result is `false` then /n/ is definitely composite,
while if the result is true then n is probably prime. The probability to declare a composite n as probable prime is
at most 0.25[super trials]. Note that this does not allow a statement about the probability of n being actually
prime (for that, the prior probability would have to be known).  The algorithm used performs some
trial divisions to exclude small prime factors, does one Fermat test to exclude many more composites, and then
uses the Miller-Rabin algorithm straight out of
Knuth Vol 2, which recommends 25 trials for a pretty strong likelihood that /n/ is prime.

The third optional argument is for a Uniform Random Number Generator from Boost.Random.  When not provided the `mt19937`
generator is used.   Note that when producing random primes then you should probably use a different random number generator
to produce candidate prime numbers for testing, than is used internally by `miller_rabin_test` for determining
whether the value is prime.  It also helps of course to seed the generators with some source of randomness.

The following example searches for a prime `p` for which `(p-1)/2` is also probably prime:

[safe_prime]

[endsect] [/section:primetest Primality Testing]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_random.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:random Generating Random Numbers]

Random numbers are generated in conjunction with Boost.Random.

There is a single generator that supports generating random integers with large bit counts:
[@http://www.boost.org/doc/html/boost/random/independent_bits_engine.html `independent_bits_engine`].
This type can be used with either ['unbounded] integer types, or with ['bounded] (ie fixed precision) unsigned integers:

[random_eg1]

Program output is:

[random_eg1_out]

In addition, the generator adaptors [@http://www.boost.org/doc/html/boost/random/discard_block_engine.html `discard_block`],
[@http://www.boost.org/doc/html/boost/random/xor_combine_engine.html `xor_combine_engine`] and
[@http://www.boost.org/doc/html/boost/random/discrete_distribution.html `discrete_distribution`] can be used
with multiprecision types.  Note that if you seed an `independent_bits_engine`, then you are actually seeding
the underlying generator, and should therefore provide a sequence of unsigned 32-bit values as the seed.

Alternatively we can generate integers in a given range using
[@http://www.boost.org/doc/html/boost/random/uniform_int_distribution.html `uniform_int_distribution`], this will
invoke the underlying engine multiple times to build up the required number of bits in the result:

[random_eg2]

[random_eg2_out]

It is also possible to use [@http://www.boost.org/doc/html/boost/random/uniform_int_distribution.html `uniform_int_distribution`]
with a multiprecision generator such as [@http://www.boost.org/doc/html/boost/random/independent_bits_engine.html `independent_bits_engine`].
Or to use [@http://www.boost.org/doc/html/boost/random/uniform_smallint.html `uniform_smallint`] or
[@http://www.boost.org/doc/html/boost/random/random_number_generator.html `random_number_generator`] with multiprecision types.

floating-point values in \[0,1) are most easily generated using [@http://www.boost.org/doc/html/boost/random/generate_canonical.html `generate_canonical`],
note that `generate_canonical` will call the generator multiple times to produce the requested number of bits, for example we can use
it with a regular generator like so:

[random_eg3]

[random_eg3_out]

Note however, the distributions do not invoke the generator multiple times to fill up the mantissa of a multiprecision floating-point type
with random bits.  For these therefore, we should probably use a multiprecision generator (ie `independent_bits_engine`) in combination
with the distribution:

[random_eg4]

[random_eg4_out]

And finally, it is possible to use the floating-point generators [@http://www.boost.org/doc/html/boost/random/lagged_fibonacci_01_engine.html `lagged_fibonacci_01_engine`]
and [@http://www.boost.org/doc/html/boost/random/subtract_with_idp144360752.html `subtract_with_carry_01_engine`] directly with multiprecision floating-point types.
It's worth noting however, that there is a distinct lack of literature on generating high bit-count random numbers, and therefore a lack of "known good" parameters to
use with these generators in this situation.  For this reason, these should probably be used for research purposes only:

[random_eg5]

[endsect] [/section:random Generating Random Numbers]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:rational Rational Number Types]

The following back-ends provide rational number arithmetic:

[table
[[Backend Type][Header][Radix][Dependencies][Pros][Cons]]
[[`cpp_rational`][boost/multiprecision/cpp_int.hpp][2][None][An all C++ Boost-licensed implementation.][Slower than [gmp].]]
[[`gmp_rational`][boost/multiprecision/gmp.hpp][2][[gmp]][Very fast and efficient back-end.][Dependency on GNU licensed [gmp] library.]]
[[`tommath_rational`][boost/multiprecision/tommath.hpp][2][[tommath]][All C/C++ implementation that's Boost Software Licence compatible.][Slower than [gmp].]]
[[`rational_adaptor`][boost/multiprecision/rational_adaptor.hpp][N/A][none][All C++ adaptor that allows any integer back-end type to be used as a rational type.][Requires an underlying integer back-end type.]]
[[`boost::rational`][boost/rational.hpp][N/A][None][A C++ rational number type that can used with any `number` integer type.][The expression templates used by `number` end up being "hidden" inside `boost::rational`: performance may well suffer as a result.]]
]

[include tutorial_cpp_rational.qbk]
[include tutorial_gmp_rational.qbk]
[include tutorial_tommath_rational.qbk]
[include tutorial_boost_rational.qbk]
[include tutorial_rational_adaptor.qbk]

[endsect] [/section:rational Rational Number Types]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_rational_adaptor.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:rational_adaptor rational_adaptor]

   namespace boost{ namespace multiprecision{

   template <class IntBackend>
   class rational_adpater;

   }}

The class template `rational_adaptor` is a back-end for `number` which converts any existing integer back-end
into a rational-number back-end.

So for example, given an integer back-end type `MyIntegerBackend`, the use would be something like:

   typedef number<MyIntegerBackend>                    MyInt;
   typedef number<rational_adaptor<MyIntegerBackend> > MyRational;

   MyRational r = 2;
   r /= 3;
   MyInt i = numerator(r);
   assert(i == 2);

[endsect] [/section:rational_adaptor rational_adaptor]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_rounding.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:rounding Rounding Rules for Conversions]

As a general rule, all conversions between unrelated types are performed using basic arithmetic operations, therefore
conversions are either exact, or follow the same rounding rules as arithmetic for the type in question.

The following table summarises the situation for conversions from native types:

[table
[[Backend][Rounding Rules]]
[[__cpp_int][Conversions from integer types are exact if the target has sufficient precision, otherwise they
            truncate to the first 2^MaxBits bits (modulo arithmetic).  Conversions from floating-point types
            are truncating to the nearest integer.]]
[[__gmp_int][Conversions are performed by the GMP library except for conversion from `long double` which is truncating.]]
[[__tom_int][Conversions from floating-point types are truncating, all others are performed by libtommath and are exact.]]
[[__gmp_float][Conversions are performed by the GMP library except for conversion from `long double` which should be exact
            provided the target type has as much precision as a `long double`.]]
[[__mpfr_float_backend][All conversions are performed by the underlying MPFR library.]]
[[__cpp_dec_float][All conversions are performed using basic arithmetic operations and are truncating.]]
[[__gmp_rational][See __gmp_int]]
[[__cpp_rational][See __cpp_int]]
[[__tommath_rational][See __tom_int]]
]

[endsect] [/section:rounding Rounding Rules for Conversions]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_serialization.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:serial Boost.Serialization Support]

Support for serialization comes in two forms:

* Classes __number, __debug_adaptor, __logged_adaptor and __rational_adaptor have "pass through" serialization
support which requires the underlying backend to be serializable.
* Backends __cpp_int, __cpp_bin_float, __cpp_dec_float and __float128__ have full support for Boost.Serialization.

[endsect] [/section:serialization Boost Serialization]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_tommath.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:tom_int tom_int]

`#include <boost/multiprecision/tommath.hpp>`

   namespace boost{ namespace multiprecision{

   class tommath_int;

   typedef number<tommath_int >         tom_int;

   }} // namespaces

The `tommath_int` back-end is used via the typedef `boost::multiprecision::tom_int`.  It acts as a thin wrapper around the [tommath] `tom_int`
to provide an integer type that is a drop-in replacement for the native C++ integer types, but with unlimited precision.

Things you should know when using this type:

* Default constructed objects have the value zero (this is [tommath]'s default behavior).
* Although `tom_int` is mostly a drop in replacement for the integer __fundamental_types, it should be noted that it is a
rather strange beast as it's a signed type that is not a 2's complement type.  As a result the bitwise operations
`| & ^` will throw a `std::runtime_error` exception if either of the arguments is negative.  Similarly the complement
operator`~` is deliberately not implemented for this type.
* Formatted IO for this type does not support octal or hexadecimal notation for negative values,
as a result performing formatted output on this type when the argument is negative and either of the flags
`std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted
as a valid integer.
* Division by zero results in a `std::overflow_error` being thrown.

[h5 Example:]

[tommath_eg]

[endsect] [/section:tom_int tom_int]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_tommath_rational.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:tommath_rational tommath_rational]

`#include <boost/multiprecision/tommath.hpp>`

   namespace boost{ namespace multiprecision{

   typedef rational_adpater<tommath_int>        tommath_rational;
   typedef number<tommath_rational >         tom_rational;

   }} // namespaces

The `tommath_rational` back-end is used via the typedef `boost::multiprecision::tom_rational`.  It acts as a thin wrapper around
`boost::rational<tom_int>`
to provide a rational number type that is a drop-in replacement for the native C++ number types, but with unlimited precision.

The advantage of using this type rather than `boost::rational<tom_int>` directly, is that it is expression-template enabled,
greatly reducing the number of temporaries created in complex expressions.

There are also non-member functions:

   tom_int numerator(const tom_rational&);
   tom_int denominator(const tom_rational&);

which return the numerator and denominator of the number.

Things you should know when using this type:

* Default constructed `tom_rational`s have the value zero (this the inherited Boost.Rational behavior).
* Division by zero results in a `std::overflow_error` being thrown.
* Conversion from a string results in a `std::runtime_error` being thrown if the string can not be
interpreted as a valid rational number.
* No changes are made to [tommath]'s global state, so this type can safely coexist with other [tommath] code.
* Performance of this type has been found to be pretty poor - this need further investigation - but it appears that Boost.Rational
needs some improvement in this area.

[h5 Example:]

[mp_rat_eg]

[endsect] [/section:tommath_rational tommath_rational]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_variable_precision.qbk
================================================
[/
  Copyright 2021 John Maddock.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:variable Variable Precision Arithmetic]

There are a number of types in this library whose precision can be changed at runtime,
the purpose of this section is to explain how these types interoperate with each other
when two variables of the same type can have different precisions.

The main variable precision types being discussed here are:

* __mpf_float.
* __mpfr_float_backend.
* __mpfi_float.
* __mpc_complex.

Functions for setting the current working precision are as follows, with type `Num` being one of `mpf_float`, `mpfr_float`, `mpfi_float` or `mpc_float`, and `val` being an object of type `Num`:

[table
[[Expression][Returns][Comments]]
[[`val.precision()`][`unsigned`][Returns the precision of variable `val`.]]
[[`val.precision(n)`][`void`][Sets the precision of variable `val` to `n` decimal places.]]
[[`Num::default_precision()`][`unsigned`][Returns the current global default precision, in decimal digits - this is the precision that all new threads will inherit.]]
[[`Num::thread_default_precision()`][`unsigned`][Returns the current thread default precision, in decimal digits - this is the precision that the current thread will use when constructing new objects of type `Num`.]]
[[`Num::default_precision(Digits10)`][`void`][Sets the global default precision to Digits10 decimal places, this is the precision that all new threads will inherit, also sets the working precision for the current thread.]]
[[`Num::thread_default_precision(Digits10)`][`void`][Sets the default precision for the current thread to Digits10 decimal places.]]
]

We must now consider what happens in an expression such as:

   variable = some_expression;

There are basically 2 options here when the precision of `variable` and `some_expression` differ:

* We can preserve the precision of the source, so that post assignment, source and target are equal.
* We can preserve the precision of the target, so that the precision of `variable` doesn't change.

In addition we must consider what happens if `some_expression` contains types other than `Num`.

The behaviour of the library is controlled by the following enumerated values:

   namespace boost::multiprecision {

      enum struct variable_precision_options
      {
         assume_uniform_precision = -1,
         preserve_target_precision = 0,
         preserve_source_precision = 1,
         preserve_component_precision = 2,
         preserve_related_precision = 3,
         preserve_all_precision = 4,
      };

   }

The enumerated values have the following meanings, with `preserve_related_precision` being the default.

[table
[[Value][Meaning]]
[[assume_uniform_precision][This is the most efficient option - it simply assumes that all variables in the current thread have the same precision, and ignores the precision of all other types.
   Should these assumptions not hold, then strange unexpected things may happen.  No checks are made to ensure that all variables really are of the same precision.]]
[[preserve_target_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and then rounded to the precision
   of the target variable upon assignment.  The precision of other types (including related or component types - see preserve_component_precision/preserve_related_precision) 
   contained within the expression are ignored.
   This option has the unfortunate side effect, that moves may become full deep copies.]]
[[preserve_source_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment.  
   The precision of other types (including related or component types - see preserve_component_precision/preserve_related_precision) contained within the expression are ignored.
   Moves, are true moves not copies.]]
[[preserve_component_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment.  
   If the expression contains component types then these are also considered when calculating the precision of the expression.  Component types are the types which make up the two 
   components of the number when dealing with interval or complex numbers.  They are the same type as `Num::value_type`.
   Moves, are true moves not copies.]]
[[preserve_related_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment.  
   If the expression contains component types then these are also considered when calculating the precision of the expression.  In addition to component types, 
   all related types are considered when evaluating the precision of the expression.
   Related types are considered to be instantiations of the same template, but with different parameters.  So for example `mpfr_float_100` would be a related type to `mpfr_float`, and all expressions
   containing an `mpfr_float_100` variable would have at least 100 decimal digits of precision when evaluated as an `mpfr_float` expression.  Moves, are true moves not copies.]]
[[preserve_all_precision][All expressions are evaluated at the precision of the highest precision variable within the expression, and that precision is preserved upon assignment.  
   In addition to component and related types, all types are considered when evaluating the precision of the expression.
   For example, if the expression contains an `mpz_int`, then the precision of the expression will be sufficient to store all of the digits in the integer unchanged.
   This option should generally be used with extreme caution, as it can easily cause unintentional precision inflation.  Moves, are true moves not copies.]]
]

Note how the values `preserve_source_precision`, `preserve_component_precision`,
`preserve_related_precision` and `preserve_all_precision` form a hierarchy, with each adding progressively more types to the one before to the list of types that are considered when calculating
the precision of an expression:

[table
[[Value][Considers types (lowest in hierarchy first, each builds on the one before)]]
[[preserve_source_precision][Considers types the same as the result in the expression only.]]
[[preserve_component_precision][Also considers component types, ie `Num::value_type`.]]
[[preserve_related_precision][Also considers all instantiations of the backend-template, not just the same type as the result.]]
[[preserve_all_precision][Considers everything, including completely unrelated types such as (possibly arbitrary precision) integers.]]
]

As with working precision, the above options can be set or queried on either a global or thread-local level, note that these options can not be set on a 
per-variable basis since they control whole expressions, not individual variables:

[table
[[Expression][Returns][Comments]]
[[`Num::default_variable_precision_options()`][`variable_precision_options`][Returns the current global default options, these are the options that all new threads will inherit.]]
[[`Num::thread_default_variable_precision_options()`][`variable_precision_options`][Returns the options in use in the current thread when evaluating expressions containing type `Num`.]]
[[`Num::default_variable_precision_options(opts)`][`void`][Sets the global default options to `opts` which must be one of the enumerated `variable_precision_options` values, this is setting that all new threads will inherit, also sets the options for the current thread.]]
[[`Num::thread_default_variable_precision_options(opts)`][`void`][Sets the options for the current thread to `opts` which must be one of the `variable_precision_options` enumerated values.]]
]

[h4 Examples]

[import ../example/scoped_precision_example.cpp]

[scoped_precision_1]

[endsect] [/section:variable Variable Precision Arithmetic]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/doc/tutorial_visualizers.qbk
================================================
[/
  Copyright 2011 - 2020 John Maddock.
  Copyright 2013 - 2019 Paul A. Bristow.
  Copyright 2013 Christopher Kormanyos.

  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:visualizers Visual C++ Debugger Visualizers]

[important This section is seriously out of date compared to recent Visual C++ releases.]

Let's face it debugger multiprecision numbers is hard - simply because we can't easily inspect the value of the numbers.
Visual C++ provides a partial solution in the shape of "visualizers" which provide improved views of complex data structures,
these visualizers need to be added to the `[Visualizer]` section of `autoexp.dat` located in the `Common7/Packages/Debugger`
directory of your Visual Studio installation.  The actual visualizer code is in the sandbox
[@https://svn.boost.org/svn/boost/sandbox/boost_docs/subprojects/DebuggerVisualizers/multiprecision.vis.txt here] - just cut and paste the code
into your `autoexp.dat` file.

[note These visualizers have only been tested with VC10, also given the ability of buggy visualizers to crash your Visual C++
debugger, make sure you back up `autoexp.dat` file before using these!!]

The first visualizer provides improved views of `debug_adaptor`:

[$../debugger1.png]

The next visualizer provides improved views of cpp_int: small numbers are displayed as actual values, while larger numbers are
displayed as an array of hexadecimal parts, with the most significant part first.

Here's what it looks like for small values:

[$../debugger4.png]

And for larger values:

[$../debugger5.png]

There is also a `~raw` child member that
lets you see the actual members of the class:

[$../debugger6.png]

The visualizer for `cpp_dec_float` shows the first few digits of the value in the preview field, and the full array of digits
when you expand the view.  As before the `~raw` child gives you access to the actual data members:

[$../debugger7.png]

[endsect] [/section:visualizers Visual C++ Debugger Visualizers]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/Jamfile.v2
================================================
# \libs\multiprecision\example\jamfile.v2
# Runs multiprecision examples.
# Copyright 2014 John Maddock
# Copyright Paul A. Bristow 2014.
# Copyright Christopher Kormanyos 2014

# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

# Bring in the rules for testing.
import testing ;
import modules ;
import path ;
import ../../config/checks/config : requires ;

local ntl-path = [ modules.peek : NTL_PATH ] ;
local gmp_path = [ modules.peek : GMP_PATH ] ;
local mpfr_path = [ modules.peek : MPFR_PATH ] ;
local mpfi_path = [ modules.peek : MPFI_PATH ] ;
local tommath_path = [ modules.peek : TOMMATH_PATH ] ;

project
    : requirements
     <include>$(gmp_path)
     <include>$(gmp_path)/mpfr
     <include>$(gmp_path)/gmpfrxx
     <include>$(mpfr_path)
     <include>$(mpfi_path)
     <include>$(mpfi_path)/src
     <include>$(tommath_path)
     <include>../include
     <include>../../..
     
      <toolset>gcc:<cxxflags>-Wno-missing-braces
      <toolset>darwin:<cxxflags>-Wno-missing-braces
      <toolset>acc:<cxxflags>+W2068,2461,2236,4070
      <toolset>intel:<cxxflags>-Qwd264,239
      <toolset>msvc:<runtime-link>static
      <toolset>msvc:<link>static
      <toolset>msvc:<warnings>all
      <toolset>msvc:<asynch-exceptions>on
      <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
      <toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE
      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
      <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
      <toolset>msvc:<cxxflags>/wd4996
      <toolset>msvc:<cxxflags>/wd4512
      <toolset>msvc:<cxxflags>/wd4610
      <toolset>msvc:<cxxflags>/wd4510
      #<toolset>msvc:<cxxflags>/wd4127
      <toolset>msvc:<cxxflags>/wd4701
      <toolset>msvc:<cxxflags>/wd4305
      <toolset>clang:<link>static
      [ requires  
         cxx11_rvalue_references cxx11_template_aliases cxx11_hdr_array cxx11_allocator cxx11_constexpr cxx11_explicit_conversion_operators cxx11_ref_qualifiers
         cxx11_hdr_functional cxx11_variadic_templates cxx11_user_defined_literals cxx11_decltype cxx11_static_assert cxx11_defaulted_functions
         cxx11_noexcept cxx11_ref_qualifiers cxx11_user_defined_literals cxx11_hdr_type_traits
         ]
    ;

lib gmp : : <search>$(gmp_path) ;
lib mpfr : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug ;
lib mpfi : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug <search>$(mpfi_path) <search>$(mpfi_path)/src ;
lib quadmath ;

if $(tommath_path)
{
   lib tommath : [ GLOB $(tommath_path) : *.c ] : <visibility>global ;
   TOMMATH = tommath ;
}
else
{
   lib tommath : : <search>$(tommath_path) ;
   TOMMATH = tommath ;
}

lib no_eh_eg_support : ../test/no_eh_test_support.cpp ;

test-suite examples :

      [ run cpp_int_snips.cpp no_eh_eg_support ]
      [ run cpp_int_import_export.cpp no_eh_eg_support ]
      [ run cpp_bin_float_import_export.cpp no_eh_eg_support ]

      [ run cpp_dec_float_snips.cpp no_eh_eg_support ]

      [ run cpp_bin_float_snips.cpp no_eh_eg_support ]

      [ run debug_adaptor_snips.cpp no_eh_eg_support ]
      [ run float128_snips.cpp quadmath no_eh_eg_support : : : [ check-target-builds ../config//has_float128 : : <build>no ] ]

      [ run floating_point_examples.cpp no_eh_eg_support : : : [ check-target-builds ../config//has_big_obj : <cxxflags>-Wa,-mbig-obj <debug-symbols>off ] ]
      [ run gauss_laguerre_quadrature.cpp no_eh_eg_support : : : release [ requires cxx11_lambdas ] ]
      [ run hypergeometric_luke_algorithms.cpp no_eh_eg_support ../../chrono/build//boost_chrono ../../system/build//boost_system : : : [ requires cxx11_nullptr ]  ]
      [ run integer_examples.cpp no_eh_eg_support ]
      [ run logged_adaptor.cpp no_eh_eg_support mpfi mpfr gmp :  :  : [ check-target-builds ../config//has_mpfi : : <build>no ] ]
      [ run mixed_integer_arithmetic.cpp no_eh_eg_support ]
      [ run numeric_limits_snips.cpp no_eh_eg_support /boost//test_exec_monitor : : : [ requires cxx11_numeric_limits ]  [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run random_snips.cpp gmp no_eh_eg_support : : : [ requires cxx11_explicit_conversion_operators ] [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ run safe_prime.cpp no_eh_eg_support ]

      [ run gmp_snips.cpp gmp no_eh_eg_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ run mpfi_snips.cpp mpfi mpfr gmp no_eh_eg_support :  :  : [ check-target-builds ../config//has_mpfi : : <build>no ] ]
      [ run mpfr_snips.cpp mpfr gmp no_eh_eg_support : : : [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run tommath_snips.cpp $(TOMMATH) no_eh_eg_support : : : [ check-target-builds ../config//has_tommath : : <build>no ] ]
      [ compile constexpr_float_arithmetic_examples.cpp : [ requires cxx14_constexpr cxx17_if_constexpr ] ]
      
      [ run big_seventh.cpp no_eh_eg_support ]

      [ run exercise_threading_log_agm.cpp : : : <define>BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE=101 release [ requires cxx11_hdr_atomic cxx11_hdr_thread ] : exercise_threading_log_agm_cpp_dec_float ]
      [ run exercise_threading_log_agm.cpp gmp : : : <define>BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE=102 release [ requires cxx11_hdr_atomic cxx11_hdr_thread ] [ check-target-builds ../config//has_gmp : : <build>no ] : exercise_threading_log_agm_gmp ]
      [ run exercise_threading_log_agm.cpp mpfr gmp : : : <define>BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE=104 release [ requires cxx11_hdr_atomic cxx11_hdr_thread ] [ check-target-builds ../config//has_mpfr : : <build>no ] : exercise_threading_log_agm_mpfr ]
      [ run exercise_threading_log_agm.cpp : : : <define>BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE=103 release [ requires cxx11_hdr_atomic cxx11_hdr_thread ] : exercise_threading_log_agm_cpp_bin_float ]

;


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/big_seventh.cpp
================================================
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

// Copyright Paul A. Bristow 2019.
// Copyright Christopher Kormanyos 2012.
// Copyright John Maddock 2012.

// This file is written to be included from a Quickbook .qbk document.
// It can be compiled by the C++ compiler, and run. Any output can
// also be added here as comment or included or pasted in elsewhere.
// Caution: this file contains Quickbook markup as well as code
// and comments: don't change any of the special comment markups!

#ifdef _MSC_VER
#  pragma warning (disable : 4512) // assignment operator could not be generated.
#  pragma warning (disable : 4996)
#endif

//[big_seventh_example_1

/*`[h5 Using Boost.Multiprecision `cpp_float` types for numerical calculations with higher precision than __fundamental `long double`.]

The Boost.Multiprecision library can be used for computations requiring precision
exceeding that of standard __fundamental types such as `float`, `double`
and `long double`. For extended-precision calculations, Boost.Multiprecision
supplies several template data types called `cpp_bin_float_`.

The number of decimal digits of precision is fixed at compile-time via template parameter.

To use these floating-point types and
[@https://www.boost.org/doc/libs/release/libs/math/doc/html/constants.html Boost.Math collection of high-precision constants],
we need some includes:
*/

#include <boost/math/constants/constants.hpp>

#include <boost/multiprecision/cpp_bin_float.hpp>
// that includes some predefined typedefs like:
// using boost::multiprecision::cpp_bin_float_quad;
// using boost::multiprecision::cpp_bin_float_50;
// using boost::multiprecision::cpp_bin_float_100;

#include <iostream>
#include <limits>

/*` So now we can demonstrate with some trivial calculations:
*/

//] //[big_seventh_example_1]

int main()
{

//[big_seventh_example_2
/*`Using a `typedef` like `cpp_bin_float_50` hides the complexity of multiprecision, and
allows us to define variables with 50 decimal digit precision just like __fundamental `double`.
*/
  using boost::multiprecision::cpp_bin_float_50;

  cpp_bin_float_50 seventh = cpp_bin_float_50(1) / 7;  // 1 / 7

/*`By default, output would only show the standard 6 decimal digits,
 so set precision to show all 50 significant digits, including any trailing zeros (to show the full implied 50 digit precision).
*/
  std::cout.precision(std::numeric_limits<cpp_bin_float_50>::digits10); // Show 50 decimal digit precision.
  std::cout << std::showpoint << std::endl; // Append any trailing zeros.
  std::cout << seventh << std::endl;
/*`which outputs:

  0.14285714285714285714285714285714285714285714285714

We can also use Boost.Math __math_constants like [pi],
guaranteed to be initialized with the very last bit of precision for the floating-point type.
*/
   std::cout << "pi = " << boost::math::constants::pi<cpp_bin_float_50>() << std::endl;
   cpp_bin_float_50 circumference = boost::math::constants::pi<cpp_bin_float_50>() * 2 * seventh;
   std::cout << "c =  "<< circumference << std::endl;

/*`which outputs

  pi = 3.1415926535897932384626433832795028841971693993751

  c =  0.89759790102565521098932668093700082405633411410717
*/
//]  [/big_seventh_example_2]

//[big_seventh_example_3
/*`So using `cpp_bin_float_50` looks like a simple 'drop-in' for the __fundamental_type like 'double',
but beware of less-than-expected precision from construction or conversion from `double` or other lower precision types.
This is a mistake that is very easy to make,
and very difficult to detect because the difference in precision is only visible after about the 17th decimal digit.

We can show this by constructing a fraction one seventh from `double`:
*/
   cpp_bin_float_50 seventh_0 = cpp_bin_float_50(1/7);  // Avoid the schoolboy-error `double d7 = 1 / 7;` giving zero!
   std::cout << "seventh_0 = "  << seventh_0 << std::endl;
   // seventh_double0 = 0.0000000000000000000000000000000000000000000000000

   cpp_bin_float_50 seventh_double = cpp_bin_float_50(1./7);  // Construct from double! (0.14285714285714)
   std::cout << "seventh_double = "  << seventh_double << std::endl; // Boost.Multiprecision post-school error!
   // seventh_double = 0.14285714285714284921269268124888185411691665649414

/*`Did you spot the probably-unintended difference?  After the 17th decimal digit, result is apparently random
and not the expected recurring pattern 14285714285714...

The 'random' digits after digit 17 are from the `cpp_bin_float_50` representation of the `double` value 0.14285714285714
which is different from the 'better' `cpp_bin_float_50` representation of the fraction 1/7
*/

   cpp_bin_float_50 seventh_big(1);  // 1
   seventh_big /= 7;
   std::cout << "seventh_big = " << seventh_big << std::endl; //
   // seventh_big     = 0.14285714285714285714285714285714285714285714285714
//`Note the recurring 14285714285714 pattern as expected.

//`We can also construct a `const` version (but not yet `constexpr`) and evaluate in a single expression:

   const cpp_bin_float_50 seventh_const (cpp_bin_float_50(1) / 7);
   std::cout << "seventh_const = " << seventh_const << std::endl; //
   // seventh_const = 0.14285714285714285714285714285714285714285714285714
//]  [/big_seventh_example_3]

//[big_seventh_example_constexpr

   // Sadly we cannot (yet) write:
   // constexpr cpp_bin_float_50 any_constexpr(0);

   // constexpr cpp_bin_float_50 seventh_constexpr (cpp_bin_float_50(1) / 7);
   // std::cout << "seventh_constexpr = " << seventh_constexpr << std::endl; //
   // nor use the macro constexpr unless it returns `const`
   // constexpr cpp_bin_float_50 seventh_constexpr(seventh_const);

//]  [/big_seventh_example_constexpr]

//[big_seventh_example_4
   /*`For some purposes, this difference in precision may be insignificant,
but if one is implementing a formula involving a fraction from integers,
including decimal fractions like 1/10, 1/100, then comparison with other computations like __WolframAlpha
will reveal differences whose cause may be perplexing.

To get as precise-as-possible decimal fractions like 1.234, we can write
*/

  const cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000);  // Construct from a fraction.
  std::cout << "cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000) = " << f1 << std::endl; // cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 1000) = 1.2340000000000000000000000000000000000000000000000
/*`or
*/
  const cpp_bin_float_50 f2("1.234");  // Construct from decimal digit string.
  std::cout << "cpp_bin_float_50 f2(\"1.234\") = " << f2 << std::endl; // cpp_bin_float_50 f2("1.234") = 1.2340000000000000000000000000000000000000000000000

/*`that are different from constructing from a `double` with value 1.234
*/
  const cpp_bin_float_50 f3(cpp_bin_float_50(1.234));
  std::cout << "cpp_bin_float_50 f3(cpp_bin_float_50(1.234)) = " << f3 << std::endl; // 1.2339999999999999857891452847979962825775146484375

//]  [/big_seventh_example_4]

    return 0;
} // int main()


/*
//[big_seventh_example_output

0.14285714285714285714285714285714285714285714285714
pi = 3.1415926535897932384626433832795028841971693993751
c =  0.89759790102565521098932668093700082405633411410717
seventh_0 = 0.0000000000000000000000000000000000000000000000000
seventh_double = 0.14285714285714284921269268124888185411691665649414
seventh_big = 0.14285714285714285714285714285714285714285714285714
seventh_const = 0.14285714285714285714285714285714285714285714285714
cpp_bin_float_50 f1(cpp_bin_float_50(1234) / 100) = 12.340000000000000000000000000000000000000000000000
cpp_bin_float_50 f2("1.234") = 1.2340000000000000000000000000000000000000000000000
cpp_bin_float_50 f3(cpp_bin_float_50(1.234)) = 1.2339999999999999857891452847979962825775146484375

//] //[/big_seventh_example_output]

*/



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/complex128_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 Nick Thompson. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

/*`This example demonstrates the usage of the MPC backend for multiprecision complex numbers.
In the following, we will show how using MPC backend allows for the same operations as the C++ standard library complex numbers.
*/

//[complex128_eg
#include <iostream>
#include <complex>
#include <boost/multiprecision/complex128.hpp>

template<class Complex>
void complex_number_examples()
{
    Complex z1{0, 1};
    std::cout << std::setprecision(std::numeric_limits<typename Complex::value_type>::digits10);
    std::cout << std::scientific << std::fixed;
    std::cout << "Print a complex number: " << z1 << std::endl;
    std::cout << "Square it             : " << z1*z1 << std::endl;
    std::cout << "Real part             : " << z1.real() << " = " << real(z1) << std::endl;
    std::cout << "Imaginary part        : " << z1.imag() << " = " << imag(z1) << std::endl;
    using std::abs;
    std::cout << "Absolute value        : " << abs(z1) << std::endl;
    std::cout << "Argument              : " << arg(z1) << std::endl;
    std::cout << "Norm                  : " << norm(z1) << std::endl;
    std::cout << "Complex conjugate     : " << conj(z1) << std::endl;
    std::cout << "Projection onto Riemann sphere: " <<  proj(z1) << std::endl;
    typename Complex::value_type r = 1;
    typename Complex::value_type theta = 0.8;
    using std::polar;
    std::cout << "Polar coordinates (phase = 0)    : " << polar(r) << std::endl;
    std::cout << "Polar coordinates (phase !=0)    : " << polar(r, theta) << std::endl;

    std::cout << "\nElementary special functions:\n";
    using std::exp;
    std::cout << "exp(z1) = " << exp(z1) << std::endl;
    using std::log;
    std::cout << "log(z1) = " << log(z1) << std::endl;
    using std::log10;
    std::cout << "log10(z1) = " << log10(z1) << std::endl;
    using std::pow;
    std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl;
    using std::sqrt;
    std::cout << "Take its square root  : " << sqrt(z1) << std::endl;
    using std::sin;
    std::cout << "sin(z1) = " << sin(z1) << std::endl;
    using std::cos;
    std::cout << "cos(z1) = " << cos(z1) << std::endl;
    using std::tan;
    std::cout << "tan(z1) = " << tan(z1) << std::endl;
    using std::asin;
    std::cout << "asin(z1) = " << asin(z1) << std::endl;
    using std::acos;
    std::cout << "acos(z1) = " << acos(z1) << std::endl;
    using std::atan;
    std::cout << "atan(z1) = " << atan(z1) << std::endl;
    using std::sinh;
    std::cout << "sinh(z1) = " << sinh(z1) << std::endl;
    using std::cosh;
    std::cout << "cosh(z1) = " << cosh(z1) << std::endl;
    using std::tanh;
    std::cout << "tanh(z1) = " << tanh(z1) << std::endl;
    using std::asinh;
    std::cout << "asinh(z1) = " << asinh(z1) << std::endl;
    using std::acosh;
    std::cout << "acosh(z1) = " << acosh(z1) << std::endl;
    using std::atanh;
    std::cout << "atanh(z1) = " << atanh(z1) << std::endl;
}

int main()
{
    std::cout << "First, some operations we usually perform with std::complex:\n";
    complex_number_examples<std::complex<double>>();
    std::cout << "\nNow the same operations performed using quad precision complex numbers:\n";
    complex_number_examples<boost::multiprecision::complex128>();

    return 0;
}
//]

/*

//[complex128_out

Print a complex number: (0.000000000000000000000000000000000,1.000000000000000000000000000000000)
Square it             : -1.000000000000000000000000000000000
Real part             : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000
Imaginary part        : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000
Absolute value        : 1.000000000000000000000000000000000
Argument              : 1.570796326794896619231321691639751
Norm                  : 1.000000000000000000000000000000000
Complex conjugate     : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000)
Projection onto Riemann sphere: (0.000000000000000000000000000000000,1.000000000000000000000000000000000)
Polar coordinates (phase = 0)    : 1.000000000000000000000000000000000
Polar coordinates (phase !=0)    : (0.696706709347165389063740022772449,0.717356090899522792567167815703377)

Elementary special functions:
exp(z1) = (0.540302305868139717400936607442977,0.841470984807896506652502321630299)
log(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751)
log10(z1) = (0.000000000000000000000000000000000,0.682188176920920673742891812715678)
pow(z1, z1) = 0.207879576350761908546955619834979
Take its square root  : (0.707106781186547524400844362104849,0.707106781186547524400844362104849)
sin(z1) = (0.000000000000000000000000000000000,1.175201193643801456882381850595601)
cos(z1) = 1.543080634815243778477905620757061
tan(z1) = (0.000000000000000000000000000000000,0.761594155955764888119458282604794)
asin(z1) = (0.000000000000000000000000000000000,0.881373587019543025232609324979792)
acos(z1) = (1.570796326794896619231321691639751,-0.881373587019543025232609324979792)
atan(z1) = (0.000000000000000000000000000000000,inf)
sinh(z1) = (0.000000000000000000000000000000000,0.841470984807896506652502321630299)
cosh(z1) = 0.540302305868139717400936607442977
tanh(z1) = (0.000000000000000000000000000000000,1.557407724654902230506974807458360)
asinh(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751)
acosh(z1) = (0.881373587019543025232609324979792,1.570796326794896619231321691639751)
atanh(z1) = (0.000000000000000000000000000000000,0.785398163397448309615660845819876)
//]
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/constexpr_float_arithmetic_examples.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Contains Quickbook snippets used by boost/libs/multiprecision/doc/multiprecision.qbk,
// section Literal Types and constexpr Support.

#include <iostream>
#include <boost/config.hpp>

#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

//[constexpr_circle
#include <boost/math/constants/constants.hpp> // For constant pi with full precision of type T.
// using  boost::math::constants::pi;

template <class T>
inline constexpr T circumference(T radius)
{
   return 2 * boost::math::constants::pi<T>() * radius;
}

template <class T>
inline constexpr T area(T radius)
{
   return boost::math::constants::pi<T>() * radius * radius;
}
//] [/constexpr_circle]

template <class T, unsigned Order>
struct const_polynomial
{
 public:
   T data[Order + 1];

 public:
   constexpr const_polynomial(T val = 0) : data{val} {}
   constexpr const_polynomial(const std::initializer_list<T>& init) : data{}
   {
      if (init.size() > Order + 1)
         throw std::range_error("Too many initializers in list!");
      for (unsigned i = 0; i < init.size(); ++i)
         data[i] = init.begin()[i];
   }
   constexpr T& operator[](std::size_t N)
   {
      return data[N];
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return data[N];
   }
   template <class U>
   constexpr T operator()(U val)const
   {
      T result = data[Order];
      for (unsigned i = Order; i > 0; --i)
      {
         result *= val;
         result += data[i - 1];
      }
      return result;
   }
   constexpr const_polynomial<T, Order - 1> derivative() const
   {
      const_polynomial<T, Order - 1> result;
      for (unsigned i = 1; i <= Order; ++i)
      {
         result[i - 1] = (*this)[i] * i;
      }
      return result;
   }
   constexpr const_polynomial operator-()
   {
      const_polynomial t(*this);
      for (unsigned i = 0; i <= Order; ++i)
         t[i] = -t[i];
      return t;
   }
   template <class U>
   constexpr const_polynomial& operator*=(U val)
   {
      for (unsigned i = 0; i <= Order; ++i)
         data[i] = data[i] * val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator/=(U val)
   {
      for (unsigned i = 0; i <= Order; ++i)
         data[i] = data[i] / val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator+=(U val)
   {
      data[0] += val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator-=(U val)
   {
      data[0] -= val;
      return *this;
   }
};

template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, (Order1 > Order2 ? Order1 : Order2)> operator+(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   if
      constexpr(Order1 > Order2)
      {
         const_polynomial<T, Order1> result(a);
         for (unsigned i = 0; i <= Order2; ++i)
            result[i] += b[i];
         return result;
      }
   else
   {
      const_polynomial<T, Order2> result(b);
      for (unsigned i = 0; i <= Order1; ++i)
         result[i] += a[i];
      return result;
   }
}
template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, (Order1 > Order2 ? Order1 : Order2)> operator-(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   if
      constexpr(Order1 > Order2)
      {
         const_polynomial<T, Order1> result(a);
         for (unsigned i = 0; i <= Order2; ++i)
            result[i] -= b[i];
         return result;
      }
   else
   {
      const_polynomial<T, Order2> result(b);
      for (unsigned i = 0; i <= Order1; ++i)
         result[i] = a[i] - b[i];
      return result;
   }
}
template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, Order1 + Order2> operator*(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   const_polynomial<T, Order1 + Order2> result;
   for (unsigned i = 0; i <= Order1; ++i)
   {
      for (unsigned j = 0; j <= Order2; ++j)
      {
         result[i + j] += a[i] * b[j];
      }
   }
   return result;
}
template <class T, unsigned Order, class U>
inline constexpr const_polynomial<T, Order> operator*(const const_polynomial<T, Order>& a, const U& b)
{
   const_polynomial<T, Order> result(a);
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] *= b;
   }
   return result;
}
template <class U, class T, unsigned Order>
inline constexpr const_polynomial<T, Order> operator*(const U& b, const const_polynomial<T, Order>& a)
{
   const_polynomial<T, Order> result(a);
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] *= b;
   }
   return result;
}
template <class T, unsigned Order, class U>
inline constexpr const_polynomial<T, Order> operator/(const const_polynomial<T, Order>& a, const U& b)
{
   const_polynomial<T, Order> result;
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] /= b;
   }
   return result;
}

//[hermite_example
template <class T, unsigned Order>
class hermite_polynomial
{
   const_polynomial<T, Order> m_data;

 public:
   constexpr hermite_polynomial() : m_data(hermite_polynomial<T, Order - 1>().data() * const_polynomial<T, 1>{0, 2} - hermite_polynomial<T, Order - 1>().data().derivative())
   {
   }
   constexpr const const_polynomial<T, Order>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N)const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val)const
   {
      return m_data(val);
   }
};
//] [/hermite_example]

//[hermite_example2
template <class T>
class hermite_polynomial<T, 0>
{
   const_polynomial<T, 0> m_data;

 public:
   constexpr hermite_polynomial() : m_data{1} {}
   constexpr const const_polynomial<T, 0>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val)
   {
      return m_data(val);
   }
};

template <class T>
class hermite_polynomial<T, 1>
{
   const_polynomial<T, 1> m_data;

 public:
   constexpr hermite_polynomial() : m_data{0, 2} {}
   constexpr const const_polynomial<T, 1>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val)
   {
      return m_data(val);
   }
};
//] [/hermite_example2]


void test_double()
{
   constexpr double radius = 2.25;
   constexpr double c      = circumference(radius);
   constexpr double a      = area(radius);

   std::cout << "Circumference = " << c << std::endl;
   std::cout << "Area = " << a << std::endl;

   constexpr const_polynomial<double, 2> pa = {3, 4};
   constexpr const_polynomial<double, 2> pb = {5, 6};
   static_assert(pa[0] == 3);
   static_assert(pa[1] == 4);
   constexpr auto pc = pa * 2;
   static_assert(pc[0] == 6);
   static_assert(pc[1] == 8);
   constexpr auto pd = 3 * pa;
   static_assert(pd[0] == 3 * 3);
   static_assert(pd[1] == 4 * 3);
   constexpr auto pe = pa + pb;
   static_assert(pe[0] == 3 + 5);
   static_assert(pe[1] == 4 + 6);
   constexpr auto pf = pa - pb;
   static_assert(pf[0] == 3 - 5);
   static_assert(pf[1] == 4 - 6);
   constexpr auto pg = pa * pb;
   static_assert(pg[0] == 15);
   static_assert(pg[1] == 38);
   static_assert(pg[2] == 24);

   #if defined(__clang__) && (__clang_major__ < 6)
   #else
   constexpr hermite_polynomial<double, 2> h1;
   static_assert(h1[0] == -2);
   static_assert(h1[1] == 0);
   static_assert(h1[2] == 4);

   constexpr hermite_polynomial<double, 3> h3;
   static_assert(h3[0] == 0);
   static_assert(h3[1] == -12);
   static_assert(h3[2] == 0);
   static_assert(h3[3] == 8);

   constexpr hermite_polynomial<double, 9> h9;
   static_assert(h9[0] == 0);
   static_assert(h9[1] == 30240);
   static_assert(h9[2] == 0);
   static_assert(h9[3] == -80640);
   static_assert(h9[4] == 0);
   static_assert(h9[5] == 48384);
   static_assert(h9[6] == 0);
   static_assert(h9[7] == -9216);
   static_assert(h9[8] == 0);
   static_assert(h9[9] == 512);

   static_assert(h9(0.5) == 6481);
   #endif
}

void test_float128()
{
#ifdef BOOST_HAS_FLOAT128
//[constexpr_circle_usage

   using boost::multiprecision::float128;

   constexpr float128 radius = 2.25;
   constexpr float128 c      = circumference(radius);
   constexpr float128 a      = area(radius);

   std::cout << "Circumference = " << c << std::endl;
   std::cout << "Area = " << a << std::endl;

 //]   [/constexpr_circle_usage]


   constexpr hermite_polynomial<float128, 2> h1;
   static_assert(h1[0] == -2);
   static_assert(h1[1] == 0);
   static_assert(h1[2] == 4);

   constexpr hermite_polynomial<float128, 3> h3;
   static_assert(h3[0] == 0);
   static_assert(h3[1] == -12);
   static_assert(h3[2] == 0);
   static_assert(h3[3] == 8);

   //[hermite_example3
   constexpr hermite_polynomial<float128, 9> h9;
   //
   // Verify that the polynomial's coefficients match the known values:
   //
   static_assert(h9[0] == 0);
   static_assert(h9[1] == 30240);
   static_assert(h9[2] == 0);
   static_assert(h9[3] == -80640);
   static_assert(h9[4] == 0);
   static_assert(h9[5] == 48384);
   static_assert(h9[6] == 0);
   static_assert(h9[7] == -9216);
   static_assert(h9[8] == 0);
   static_assert(h9[9] == 512);
   //
   // Define an abscissa value to evaluate at:
   constexpr float128 abscissa(0.5);
   //
   // Evaluate H_9(0.5) using all constexpr arithmetic, and check that it has the expected result:
   static_assert(h9(abscissa) == 6481);
   //]
#endif
}

int main()
{
   test_double();
   test_float128();
   std::cout << "Done!" << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_bin_float_import_export.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>

// Contains Quickbook snippets in comments.

//[IE2

/*`
Importing or exporting cpp_bin_float is similar, but we must proceed via an intermediate integer:
*/
/*=
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>
*/

int main()
{
   using boost::multiprecision::cpp_bin_float_100;
   using boost::multiprecision::cpp_int;
   // Create a cpp_bin_float to import/export:
   cpp_bin_float_100 f(1);
   f /= 3;
   // export into 8-bit unsigned values, most significant bit first:
   std::vector<unsigned char> v;
   export_bits(cpp_int(f.backend().bits()), std::back_inserter(v), 8);
   // Grab the exponent as well:
   int e = f.backend().exponent();
   // Import back again, and check for equality, we have to proceed via
   // an intermediate integer:
   cpp_int i;
   import_bits(i, v.begin(), v.end());
   cpp_bin_float_100 g(i);
   g.backend().exponent() = e;
   BOOST_MP_ASSERT(f == g);
}

//]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_bin_float_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[cpp_bin_float_eg
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/math/special_functions/gamma.hpp>

#include <iostream>

int main()
{
   using namespace boost::multiprecision;

   // Operations at fixed precision and full numeric_limits support:
   cpp_bin_float_100 b = 2;
   std::cout << std::numeric_limits<cpp_bin_float_100>::digits << std::endl;
   std::cout << std::numeric_limits<cpp_bin_float_100>::digits10 << std::endl;

   // We can use any C++ std lib function, lets print all the digits as well:
   std::cout << std::setprecision(std::numeric_limits<cpp_bin_float_100>::max_digits10)
      << log(b) << std::endl; // print log(2)

   // We can also use any function from Boost.Math:
   std::cout << boost::math::tgamma(b) << std::endl;
   // These even work when the argument is an expression template:
   std::cout << boost::math::tgamma(b * b) << std::endl;

   // And since we have an extended exponent range we can generate some really large
   // numbers here (4.0238726007709377354370243e+2564):
   std::cout << boost::math::tgamma(cpp_bin_float_100(1000)) << std::endl;
   return 0;
}

//]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_complex_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 Nick Thompson. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

/*`This example demonstrates the usage of the MPC backend for multiprecision complex numbers.
In the following, we will show how using MPC backend allows for the same operations as the C++ standard library complex numbers.
*/

//[cpp_complex_eg
#include <iostream>
#include <complex>
#include <boost/multiprecision/cpp_complex.hpp>

template<class Complex>
void complex_number_examples()
{
    Complex z1{0, 1};
    std::cout << std::setprecision(std::numeric_limits<typename Complex::value_type>::digits10);
    std::cout << std::scientific << std::fixed;
    std::cout << "Print a complex number: " << z1 << std::endl;
    std::cout << "Square it             : " << z1*z1 << std::endl;
    std::cout << "Real part             : " << z1.real() << " = " << real(z1) << std::endl;
    std::cout << "Imaginary part        : " << z1.imag() << " = " << imag(z1) << std::endl;
    using std::abs;
    std::cout << "Absolute value        : " << abs(z1) << std::endl;
    std::cout << "Argument              : " << arg(z1) << std::endl;
    std::cout << "Norm                  : " << norm(z1) << std::endl;
    std::cout << "Complex conjugate     : " << conj(z1) << std::endl;
    std::cout << "Projection onto Riemann sphere: " <<  proj(z1) << std::endl;
    typename Complex::value_type r = 1;
    typename Complex::value_type theta = 0.8;
    using std::polar;
    std::cout << "Polar coordinates (phase = 0)    : " << polar(r) << std::endl;
    std::cout << "Polar coordinates (phase !=0)    : " << polar(r, theta) << std::endl;

    std::cout << "\nElementary special functions:\n";
    using std::exp;
    std::cout << "exp(z1) = " << exp(z1) << std::endl;
    using std::log;
    std::cout << "log(z1) = " << log(z1) << std::endl;
    using std::log10;
    std::cout << "log10(z1) = " << log10(z1) << std::endl;
    using std::pow;
    std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl;
    using std::sqrt;
    std::cout << "Take its square root  : " << sqrt(z1) << std::endl;
    using std::sin;
    std::cout << "sin(z1) = " << sin(z1) << std::endl;
    using std::cos;
    std::cout << "cos(z1) = " << cos(z1) << std::endl;
    using std::tan;
    std::cout << "tan(z1) = " << tan(z1) << std::endl;
    using std::asin;
    std::cout << "asin(z1) = " << asin(z1) << std::endl;
    using std::acos;
    std::cout << "acos(z1) = " << acos(z1) << std::endl;
    using std::atan;
    std::cout << "atan(z1) = " << atan(z1) << std::endl;
    using std::sinh;
    std::cout << "sinh(z1) = " << sinh(z1) << std::endl;
    using std::cosh;
    std::cout << "cosh(z1) = " << cosh(z1) << std::endl;
    using std::tanh;
    std::cout << "tanh(z1) = " << tanh(z1) << std::endl;
    using std::asinh;
    std::cout << "asinh(z1) = " << asinh(z1) << std::endl;
    using std::acosh;
    std::cout << "acosh(z1) = " << acosh(z1) << std::endl;
    using std::atanh;
    std::cout << "atanh(z1) = " << atanh(z1) << std::endl;
}

int main()
{
    std::cout << "First, some operations we usually perform with std::complex:\n";
    complex_number_examples<std::complex<double>>();
    std::cout << "\nNow the same operations performed using quad precision complex numbers:\n";
    complex_number_examples<boost::multiprecision::cpp_complex_quad>();

    return 0;
}
//]

/*

//[cpp_complex_out

Print a complex number: (0.000000000000000000000000000000000,1.000000000000000000000000000000000)
Square it             : -1.000000000000000000000000000000000
Real part             : 0.000000000000000000000000000000000 = 0.000000000000000000000000000000000
Imaginary part        : 1.000000000000000000000000000000000 = 1.000000000000000000000000000000000
Absolute value        : 1.000000000000000000000000000000000
Argument              : 1.570796326794896619231321691639751
Norm                  : 1.000000000000000000000000000000000
Complex conjugate     : (0.000000000000000000000000000000000,-1.000000000000000000000000000000000)
Projection onto Riemann sphere: (0.000000000000000000000000000000000,1.000000000000000000000000000000000)
Polar coordinates (phase = 0)    : 1.000000000000000000000000000000000
Polar coordinates (phase !=0)    : (0.696706709347165389063740022772448,0.717356090899522792567167815703377)

Elementary special functions:
exp(z1) = (0.540302305868139717400936607442977,0.841470984807896506652502321630299)
log(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751)
log10(z1) = (0.000000000000000000000000000000000,0.682188176920920673742891812715678)
pow(z1, z1) = 0.207879576350761908546955619834979
Take its square root  : (0.707106781186547524400844362104849,0.707106781186547524400844362104849)
sin(z1) = (0.000000000000000000000000000000000,1.175201193643801456882381850595601)
cos(z1) = 1.543080634815243778477905620757062
tan(z1) = (0.000000000000000000000000000000000,0.761594155955764888119458282604794)
asin(z1) = (0.000000000000000000000000000000000,0.881373587019543025232609324979793)
acos(z1) = (1.570796326794896619231321691639751,-0.881373587019543025232609324979793)
atan(z1) = (0.000000000000000000000000000000000,inf)
sinh(z1) = (0.000000000000000000000000000000000,0.841470984807896506652502321630299)
cosh(z1) = 0.540302305868139717400936607442977
tanh(z1) = (0.000000000000000000000000000000000,1.557407724654902230506974807458360)
asinh(z1) = (0.000000000000000000000000000000000,1.570796326794896619231321691639751)
acosh(z1) = (0.881373587019543025232609324979792,1.570796326794896619231321691639751)
atanh(z1) = (0.000000000000000000000000000000000,0.785398163397448309615660845819876)
//]
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_dec_float_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

   //[cpp_dec_float_eg
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

int main()
{
   using namespace boost::multiprecision;

   // Operations at fixed precision and full numeric_limits support:
   cpp_dec_float_100 b = 2;
   std::cout << std::numeric_limits<cpp_dec_float_100>::digits << std::endl;
   // Note that digits10 is the same as digits, since we're base 10! :
   std::cout << std::numeric_limits<cpp_dec_float_100>::digits10 << std::endl;
   // We can use any C++ std lib function, lets print all the digits as well:
   std::cout << std::setprecision(std::numeric_limits<cpp_dec_float_100>::max_digits10) 
      << log(b) << std::endl; // print log(2)
   // We can also use any function from Boost.Math:
   std::cout << boost::math::tgamma(b) << std::endl;
   // These even work when the argument is an expression template:
   std::cout << boost::math::tgamma(b * b) << std::endl;
   // And since we have an extended exponent range we can generate some really large 
   // numbers here (4.0238726007709377354370243e+2564):
   std::cout << boost::math::tgamma(cpp_dec_float_100(1000)) << std::endl;
   return 0;
}
//]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_int_import_export.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>

//[IE1

/*`
In this simple example, we'll import/export the bits of a cpp_int
to a vector of 8-bit unsigned values:
*/
/*=
#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>
*/

int main()
{
   using boost::multiprecision::cpp_int;
   // Create a cpp_int with just a couple of bits set:
   cpp_int i;
   bit_set(i, 5000); // set the 5000'th bit
   bit_set(i, 200);
   bit_set(i, 50);
   // export into 8-bit unsigned values, most significant bit first:
   std::vector<unsigned char> v;
   export_bits(i, std::back_inserter(v), 8);
   // import back again, and check for equality:
   cpp_int j;
   import_bits(j, v.begin(), v.end());
   BOOST_MP_ASSERT(i == j);
}

//]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_int_mul_timing.cpp
================================================
///////////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2019.                        //
//  Distributed under the Boost Software License,                //
//  Version 1.0. (See accompanying file LICENSE_1_0.txt          //
//  or copy at http://www.boost.org/LICENSE_1_0.txt)             //
///////////////////////////////////////////////////////////////////

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <limits>
#include <iterator>
#include <vector>

#include <boost/multiprecision/cpp_int.hpp>

class random_pcg32_fast_base
{
protected:
  using itype = std::uint64_t;

  static constexpr bool is_mcg = false;

public:
  virtual ~random_pcg32_fast_base() = default;

protected:
  explicit random_pcg32_fast_base(const itype = itype()) { }

  random_pcg32_fast_base(const random_pcg32_fast_base&) = default;

  random_pcg32_fast_base& operator=(const random_pcg32_fast_base&) = default;

  template<typename ArithmeticType>
  static ArithmeticType rotr(const ArithmeticType& value_being_shifted,
                             const std::size_t     bits_to_shift)
  {
    const std::size_t left_shift_amount =
      std::numeric_limits<ArithmeticType>::digits - bits_to_shift;

    const ArithmeticType part1 = ((bits_to_shift > 0U) ? ArithmeticType(value_being_shifted >> bits_to_shift)     : value_being_shifted);
    const ArithmeticType part2 = ((bits_to_shift > 0U) ? ArithmeticType(value_being_shifted << left_shift_amount) : 0U);

    return ArithmeticType(part1 | part2);
  }

  template<typename xtype,
           typename itype>
  struct xsh_rr_mixin
  {
    static xtype output(const itype internal_value)
    {
      using bitcount_t = std::size_t;

      constexpr bitcount_t bits         = bitcount_t(sizeof(itype) * 8U);
      constexpr bitcount_t xtypebits    = bitcount_t(sizeof(xtype) * 8U);
      constexpr bitcount_t sparebits    = bits - xtypebits;
      constexpr bitcount_t wantedopbits =   ((xtypebits >= 128U) ? 7U
                                          : ((xtypebits >=  64U) ? 6U
                                          : ((xtypebits >=  32U) ? 5U
                                          : ((xtypebits >=  16U) ? 4U
                                          :                        3U))));

      constexpr bitcount_t opbits       = ((sparebits >= wantedopbits) ? wantedopbits : sparebits);
      constexpr bitcount_t amplifier    = wantedopbits - opbits;
      constexpr bitcount_t mask         = (1ULL << opbits) - 1U;
      constexpr bitcount_t topspare     = opbits;
      constexpr bitcount_t bottomspare  = sparebits - topspare;
      constexpr bitcount_t xshift       = (topspare + xtypebits) / 2U;

      const bitcount_t rot =
        ((opbits != 0U) ? (bitcount_t(internal_value >> (bits - opbits)) & mask)
                        : 0U);

      const bitcount_t amprot = (rot << amplifier) & mask;

      const itype internal_value_xor = internal_value ^ itype(internal_value >> xshift);

      const xtype result = rotr(xtype(internal_value_xor >> bottomspare), amprot);

      return result;
    }
  };
};

class random_pcg32_fast : public random_pcg32_fast_base
{
private:
  static constexpr itype default_multiplier = static_cast<itype>(6364136223846793005ULL);
  static constexpr itype default_increment  = static_cast<itype>(1442695040888963407ULL);

public:
  using result_type = std::uint32_t;

  static constexpr itype default_seed = static_cast<itype>(0xCAFEF00DD15EA5E5ULL);

  explicit random_pcg32_fast(const itype state = default_seed)
    : random_pcg32_fast_base(state),
      my_inc  (default_increment),
      my_state(is_mcg ? state | itype(3U) : bump(state + increment())) { }

  random_pcg32_fast(const random_pcg32_fast& other)
    : random_pcg32_fast_base(other),
      my_inc  (other.my_inc),
      my_state(other.my_state) { }

  virtual ~random_pcg32_fast() = default;

  random_pcg32_fast& operator=(const random_pcg32_fast& other)
  {
    static_cast<void>(random_pcg32_fast_base::operator=(other));

    if(this != &other)
    {
      my_inc   = other.my_inc;
      my_state = other.my_state;
    }

    return *this;
  }

  void seed(const itype state = default_seed)
  {
    my_inc = default_increment;

    my_state = (is_mcg ? state | itype(3U) : bump(state + increment()));
  }

  result_type operator()()
  {
    const result_type value =
      xsh_rr_mixin<result_type, itype>::output(base_generate0());

    return value;
  }

private:
  itype my_inc;
  itype my_state;

  itype multiplier() const
  {
    return default_multiplier;
  }

  itype increment() const
  {
    return default_increment;
  }

  itype bump(const itype state)
  {
    return itype(state * multiplier()) + increment();
  }

  itype base_generate0()
  {
    const itype old_state = my_state;

    my_state = bump(my_state);

    return old_state;
  }
};


template<typename UnsignedIntegralIteratorType,
         typename RandomEngineType>
void get_random_big_uint(RandomEngineType& rng, UnsignedIntegralIteratorType it_out)
{
  using local_random_value_type = typename RandomEngineType::result_type;

  using local_uint_type = typename std::iterator_traits<UnsignedIntegralIteratorType>::value_type;

  constexpr std::size_t digits_of_uint___type = static_cast<std::size_t>(std::numeric_limits<local_uint_type>::digits);
  constexpr std::size_t digits_of_random_type = static_cast<std::size_t>(std::numeric_limits<local_random_value_type>::digits);

  local_random_value_type next_random = rng();

  *it_out = next_random;

  for(std::size_t i = digits_of_random_type; i < digits_of_uint___type; i += digits_of_random_type)
  {
    (*it_out) <<= digits_of_random_type;

    next_random = rng();

    (*it_out) |= next_random;
  }
}

using big_uint_backend_type =
  boost::multiprecision::cpp_int_backend<8192UL << 1U,
                                         8192UL << 1U,
                                         boost::multiprecision::unsigned_magnitude>;

using big_uint_type = boost::multiprecision::number<big_uint_backend_type>;

namespace local
{
  std::vector<big_uint_type> a(1024U);
  std::vector<big_uint_type> b(a.size());
}

int main()
{
  random_pcg32_fast rng;

  rng.seed(std::clock());

  for(auto i = 0U; i < local::a.size(); ++i)
  {
    get_random_big_uint(rng, local::a.begin() + i);
    get_random_big_uint(rng, local::b.begin() + i);
  }

  std::size_t count = 0U;

  float total_time = 0.0F;

  const std::clock_t start = std::clock();

  do
  {
    const std::size_t index = count % local::a.size();

    local::a[index] * local::b[index];

    ++count;
  }
  while((total_time = (float(std::clock() - start) / float(CLOCKS_PER_SEC))) < 10.0F);

  // Boost.Multiprecision 1.71
  // bits: 16384, kops_per_sec: 4.7
  // bits: 32768, kops_per_sec: 1.2
  // bits: 65536, kops_per_sec: 0.3
  // bits: 131072, kops_per_sec: 0.075
  // bits: 262144, kops_per_sec: 0.019
  // bits: 524288, kops_per_sec: 0.0047

  // Boost.Multiprecision + kara mult
  // bits: 16384, kops_per_sec: 4.8
  // bits: 32768, kops_per_sec: 1.6
  // bits: 65536, kops_per_sec: 0.5
  // bits: 131072, kops_per_sec: 0.15
  // bits: 262144, kops_per_sec: 0.043
  // bits: 524288, kops_per_sec: 0.011

  const float kops_per_sec = (float(count) / total_time) / 1000.0F;

  std::cout << "bits: "
            << std::numeric_limits<big_uint_type>::digits
            << ", kops_per_sec: "
            << kops_per_sec
            << count << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/cpp_int_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>

void t1()
{
//[cpp_int_eg
//=#include <boost/multiprecision/cpp_int.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   int128_t v = 1;

   // Do some fixed precision arithmetic:
   for(unsigned i = 1; i <= 20; ++i)
      v *= i;

   std::cout << v << std::endl; // prints 2432902008176640000 (i.e. 20!)

   // Repeat at arbitrary precision:
   cpp_int u = 1;
   for(unsigned i = 1; i <= 100; ++i)
      u *= i;
   
   // prints 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 (i.e. 100!)
   std::cout << u << std::endl;

//=   return 0;
//=}
//]
}

void t3()
{
//[cpp_rational_eg
//=#include <boost/multiprecision/cpp_int.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   cpp_rational v = 1;

   // Do some arithmetic:
   for(unsigned i = 1; i <= 1000; ++i)
      v *= i;
   v /= 10;

   std::cout << v << std::endl; // prints 1000! / 10
   std::cout << numerator(v) << std::endl;
   std::cout << denominator(v) << std::endl;

   cpp_rational w(2, 3);  // component wise constructor
   std::cout << w << std::endl; // prints 2/3
//=   return 0;
//=}
//]
}


int main()
{
   t1();
   t3();
   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/debug_adaptor_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#include <iostream>

void t1()
{
   //[debug_adaptor_eg
   //=#include <boost/multiprecision/debug_adaptor.hpp>
   //=#include <boost/multiprecision/cpp_dec_float.hpp>

   using namespace boost::multiprecision;

   typedef number<debug_adaptor<cpp_dec_float<50> > > fp_type;

   fp_type denom = 1;
   fp_type sum = 1;

   for(unsigned i = 2; i < 50; ++i)
   {
      denom *= i;
      sum += 1 / denom;
   }

   std::cout << std::setprecision(std::numeric_limits<fp_type>::digits) << sum << std::endl;
   //]
}

int main()
{
   t1();
   return 0;
}





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/eigen_example.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[eigen_eg
#include <iostream>
#include <boost/multiprecision/cpp_complex.hpp>
#include <boost/multiprecision/eigen.hpp>
#include <Eigen/Dense>

int main()
{
   using namespace Eigen;
   typedef boost::multiprecision::cpp_complex_quad complex_type;
   //
   // We want to solve Ax = b for x,
   // define A and b first:
   //
   Matrix<complex_type, 2, 2> A, b;
   A << complex_type(2, 3), complex_type(-1, -2), complex_type(-1, -4), complex_type(3, 6);
   b << 1, 2, 3, 1;
   std::cout << "Here is the matrix A:\n" << A << std::endl;
   std::cout << "Here is the right hand side b:\n" << b << std::endl;
   //
   // Solve for x:
   //
   Matrix<complex_type, 2, 2> x = A.fullPivHouseholderQr().solve(b);
   std::cout << "The solution is:\n" << x << std::endl;
   //
   // Compute the error in the solution by using the norms of Ax - b and b:
   //
   complex_type::value_type relative_error = (A*x - b).norm() / b.norm();
   std::cout << "The relative error is: " << relative_error << std::endl;
   return 0;
}
//]

/*
//[eigen_out
Here is the matrix A:
(2,3) (-1,-2)
(-1,-4)   (3,6)
Here is the right hand side b:
1 2
3 1
The solution is:
(0.6,-0.6)   (0.7,-0.7)
(0.64,-0.68) (0.58,-0.46)
The relative error is: 2.63132e-34
//]
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/exercise_threading_log_agm.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//      Copyright Christopher Kormanyos 2020 - 2021.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//

// This example exercises Boost.Multiprecision in concurrent
// multi-threaded environments. To do so a loop involving
// non-trivial calculations of numerous function values
// has been set up within both concurrent as well as
// sequential running environments. In particular,
// this example uses an AGM method to do a "from the ground up"
// calculation of logarithms. The logarithm functions values
// are compared with the values from Boost.Multiprecision's
// specific log functions for the relevant backends.
// The log GM here is not optimized or intended for
// high-performance work, but can be taken as an
// interesting example of an AGM iteration if helpful.

// This example has been initially motivated in part
// by discussions in:
// https://github.com/boostorg/multiprecision/pull/211

// We find the following performance data here:
// https://github.com/boostorg/multiprecision/pull/213
//
// cpp_dec_float:
// result_is_ok_concurrent: true, calculation_time_concurrent: 18.1s
// result_is_ok_sequential: true, calculation_time_sequential: 48.5s
//
// cpp_bin_float:
// result_is_ok_concurrent: true, calculation_time_concurrent: 18.7s
// result_is_ok_sequential: true, calculation_time_sequential: 50.4s
//
// gmp_float:
// result_is_ok_concurrent: true, calculation_time_concurrent: 3.3s
// result_is_ok_sequential: true, calculation_time_sequential: 12.4s
//
// mpfr_float:
// result_is_ok_concurrent: true, calculation_time_concurrent: 0.6s
// result_is_ok_sequential: true, calculation_time_sequential: 1.9s

#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <limits>
#include <thread>
#include <vector>

#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/prime.hpp>

#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT       101
#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT           102
#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT       103
#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT          104

#if !defined(BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE)
#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT
//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT
//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT
//#define BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT
#endif

#if  (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>

using big_float_type = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<501>,
                                                     boost::multiprecision::et_off>;

#elif (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>

using big_float_type = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<501>,
                                                     boost::multiprecision::et_off>;

#elif  (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_GMP_FLOAT)
#include <boost/multiprecision/gmp.hpp>

using big_float_type = boost::multiprecision::number<boost::multiprecision::gmp_float<501>,
                                                     boost::multiprecision::et_off>;

#elif  (BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE == BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_MPFR_FLOAT)
#include <boost/multiprecision/mpfr.hpp>

using big_float_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<501>,
                                                     boost::multiprecision::et_off>;

#else
#error BOOST_MULTIPRECISION_EXERCISE_THREADING_BACKEND_TYPE is undefined.
#endif

namespace boost { namespace multiprecision { namespace exercise_threading {

namespace detail {

namespace my_concurrency {
template<typename index_type,
         typename callable_function_type>
void parallel_for(index_type             start,
                  index_type             end,
                  callable_function_type parallel_function)
{
  // Estimate the number of threads available.
  static const unsigned int number_of_threads_hint =
    std::thread::hardware_concurrency();

  static const unsigned int number_of_threads_total =
    ((number_of_threads_hint == 0U) ? 4U : number_of_threads_hint);

  // Use only 3/4 of the available cores.
  static const unsigned int number_of_threads = number_of_threads_total - (number_of_threads_total / 8U);

  std::cout << "Executing with " << number_of_threads << " threads" << std::endl;

  // Set the size of a slice for the range functions.
  index_type n = index_type(end - start) + index_type(1);

  index_type slice =
    static_cast<index_type>(std::round(n / static_cast<float>(number_of_threads)));

  slice = (std::max)(slice, index_type(1));

  // Inner loop.
  auto launch_range =
    [&parallel_function](index_type index_lo, index_type index_hi)
    {
      for(index_type i = index_lo; i < index_hi; ++i)
      {
        parallel_function(i);
      }
    };

  // Create the thread pool and launch the jobs.
  std::vector<std::thread> pool;

  pool.reserve(number_of_threads);

  index_type i1 = start;
  index_type i2 = (std::min)(index_type(start + slice), end);

  for(index_type i = 0U; ((index_type(i + index_type(1U)) < number_of_threads) && (i1 < end)); ++i)
  {
    pool.emplace_back(launch_range, i1, i2);

    i1 = i2;

    i2 = (std::min)(index_type(i2 + slice), end);
  }

  if(i1 < end)
  {
    pool.emplace_back(launch_range, i1, end);
  }

  // Wait for the jobs to finish.
  for(std::thread& thread_in_pool : pool)
  {
    if(thread_in_pool.joinable())
    {
      thread_in_pool.join();
    }
  }
}
} // namespace my_concurrency

template<typename FloatingPointType,
         typename UnsignedIntegralType>
FloatingPointType pown(const FloatingPointType& b, const UnsignedIntegralType& p)
{
  // Calculate (b ^ p).

  using local_floating_point_type    = FloatingPointType;
  using local_unsigned_integral_type = UnsignedIntegralType;

  local_floating_point_type result;

  if     (p == local_unsigned_integral_type(0U)) { result = local_floating_point_type(1U); }
  else if(p == local_unsigned_integral_type(1U)) { result = b; }
  else if(p == local_unsigned_integral_type(2U)) { result = b; result *= b; }
  else
  {
    result = local_floating_point_type(1U);

    local_floating_point_type y(b);

    for(local_unsigned_integral_type p_local(p); p_local != local_unsigned_integral_type(0U); p_local >>= 1U)
    {
      if((static_cast<unsigned>(p_local) & 1U) != 0U)
      {
        result *= y;
      }

      y *= y;
    }
  }

  return result;
}

const std::vector<std::uint32_t>& primes()
{
  static std::vector<std::uint32_t> my_primes;

  if(my_primes.empty())
  {
    my_primes.resize(10000U);

    // Get exactly 10,000 primes.
    for(std::size_t i = 0U; i < my_primes.size(); ++i)
    {
      my_primes[i] = boost::math::prime((unsigned int) i);
    }
  }

  return my_primes;
}

} // namespace detail

template<typename FloatingPointType>
FloatingPointType log(const FloatingPointType& x)
{
  // Use an AGM method to compute the logarithm of x.

  // For values less than 1 invert the argument and
  // remember (in this case) to negate the result below.
  const bool b_negate = (x < 1);

  const FloatingPointType xx = ((b_negate == false) ? x : 1 / x);

  // Set a0 = 1
  // Set b0 = 4 / (x * 2^m) = 1 / (x * 2^(m - 2))

  FloatingPointType ak(1U);

  const float n_times_factor = static_cast<float>(static_cast<float>(std::numeric_limits<FloatingPointType>::digits10) * 1.67F);
  const float lgx_over_lg2   = std::log(static_cast<float>(xx)) / std::log(2.0F);

  std::int32_t m = static_cast<std::int32_t>(n_times_factor - lgx_over_lg2);

  // Ensure that the resulting power is non-negative.
  // Also enforce that m >= 8.
  m = (std::max)(m, static_cast<std::int32_t>(8));

  FloatingPointType bk = detail::pown(FloatingPointType(2), static_cast<std::uint32_t>(m));

  bk *= xx;
  bk  = 4 / bk;

  FloatingPointType ak_tmp(0U);

  using std::sqrt;

  // Determine the requested precision of the upcoming iteration in units of digits10.
  const FloatingPointType target_tolerance = sqrt(std::numeric_limits<FloatingPointType>::epsilon()) / 100;

  for(std::int32_t k = static_cast<std::int32_t>(0); k < static_cast<std::int32_t>(64); ++k)
  {
    using std::fabs;

    // Check for the number of significant digits to be
    // at least half of the requested digits. If at least
    // half of the requested digits have been achieved,
    // then break after the upcoming iteration.
    const bool break_after_this_iteration = (   (k > static_cast<std::int32_t>(4))
                                             && (fabs(1 - fabs(ak / bk)) < target_tolerance));

    ak_tmp  = ak;
    ak     += bk;
    ak     /= 2;

    if(break_after_this_iteration)
    {
      break;
    }

    bk *= ak_tmp;
    bk  = sqrt(bk);
  }

  // We are now finished with the AGM iteration for log(x).

  // Compute log(x) = {pi / [2 * AGM(1, 4 / 2^m)]} - (m * ln2)
  // Note at this time that (ak = bk) = AGM(...)

  // Retrieve the value of pi, divide by (2 * a) and subtract (m * ln2).
  const FloatingPointType result =
       boost::math::constants::pi<FloatingPointType>() / (ak * 2)
    - (boost::math::constants::ln_two<FloatingPointType>() * m);

  return ((b_negate == true) ? -result : result);
}

} } } // namespace boost::multiprecision::exercise_threading

template<typename FloatingPointType>
bool log_agm_concurrent(float& calculation_time)
{
  const std::size_t count = boost::multiprecision::exercise_threading::detail::primes().size();

  std::vector<FloatingPointType> log_results(count);
  std::vector<FloatingPointType> log_control(count);

  std::atomic_flag log_agm_lock = ATOMIC_FLAG_INIT;

  std::size_t concurrent_log_agm_count = 0U;

  const std::clock_t start = std::clock();

  boost::multiprecision::exercise_threading::detail::my_concurrency::parallel_for
  (
    std::size_t(0U),
    log_results.size(),
    [&log_results, &log_control, &concurrent_log_agm_count, &log_agm_lock](std::size_t i)
    {
      while(log_agm_lock.test_and_set()) { ; }
      const FloatingPointType dx = (FloatingPointType(1U) / (boost::multiprecision::exercise_threading::detail::primes()[i]));
      log_agm_lock.clear();

      const FloatingPointType  x = boost::math::constants::catalan<FloatingPointType>() + dx;

      const FloatingPointType lr = boost::multiprecision::exercise_threading::log(x);
      const FloatingPointType lc = boost::multiprecision::log(x);

      while(log_agm_lock.test_and_set()) { ; }

      log_results[i] = lr;
      log_control[i] = lc;

      ++concurrent_log_agm_count;

      if((concurrent_log_agm_count % 100U) == 0U)
      {
        std::cout << "log agm concurrent at index "
                  << concurrent_log_agm_count
                  << " of "
                  << log_results.size()
                  << ". Total processed so far: "
                  << std::fixed
                  << std::setprecision(1)
                  << (100.0F * float(concurrent_log_agm_count)) / float(log_results.size())
                  << "%."
                  << "\r";
      }

      log_agm_lock.clear();
    }
  );

  calculation_time = static_cast<float>(std::clock() - start) / static_cast<float>(CLOCKS_PER_SEC);

  std::cout << std::endl;

  std::cout << "Checking results concurrent: ";

  bool result_is_ok = true;

  const FloatingPointType tol = std::numeric_limits<FloatingPointType>::epsilon() * 1000000U;

  for(std::size_t i = 0U; i < log_results.size(); ++i)
  {
    using std::fabs;

    const FloatingPointType close_fraction = fabs(1 - (log_results[i] / log_control[i]));

    result_is_ok &= (close_fraction < tol);
  }

  std::cout << std::boolalpha << result_is_ok << std::endl;

  return result_is_ok;
}

template<typename FloatingPointType>
bool log_agm_sequential(float& calculation_time)
{
  const std::size_t count = boost::multiprecision::exercise_threading::detail::primes().size();

  std::vector<FloatingPointType> log_results(count);
  std::vector<FloatingPointType> log_control(count);

  const std::clock_t start = std::clock();

  for(std::size_t i = 0U; i < log_results.size(); ++i)
  {
    const std::size_t sequential_log_agm_count = i + 1U;

    const FloatingPointType dx = (FloatingPointType(1U) / (boost::multiprecision::exercise_threading::detail::primes()[i]));
    const FloatingPointType  x = boost::math::constants::catalan<FloatingPointType>() + dx;

    log_results[i] = boost::multiprecision::exercise_threading::log(x);
    log_control[i] = boost::multiprecision::log(x);

    if((sequential_log_agm_count % 100U) == 0U)
    {
      std::cout << "log agm sequential at index "
                << sequential_log_agm_count
                << " of "
                << log_results.size()
                << ". Total processed so far: "
                << std::fixed
                << std::setprecision(1)
                << (100.0F * float(sequential_log_agm_count)) / float(log_results.size())
                << "%."
                << "\r";
    }
  }

  calculation_time = static_cast<float>(std::clock() - start) / static_cast<float>(CLOCKS_PER_SEC);

  std::cout << std::endl;

  std::cout << "Checking results sequential: ";

  bool result_is_ok = true;

  const FloatingPointType tol = std::numeric_limits<FloatingPointType>::epsilon() * 1000000U;

  for(std::size_t i = 0U; i < log_results.size(); ++i)
  {
    using std::fabs;

    const FloatingPointType close_fraction = fabs(1 - (log_results[i] / log_control[i]));

    result_is_ok &= (close_fraction < tol);
  }

  std::cout << std::boolalpha << result_is_ok << std::endl;

  return result_is_ok;
}

int main()
{
  std::cout << "Calculating "
            << boost::multiprecision::exercise_threading::detail::primes().size()
            << " primes"
            << std::endl;

  float calculation_time_concurrent;
  const bool result_is_ok_concurrent = log_agm_concurrent<big_float_type>(calculation_time_concurrent);

  float calculation_time_sequential;
  const bool result_is_ok_sequential = log_agm_sequential<big_float_type>(calculation_time_sequential);

  std::cout << std::endl;

  std::cout << "result_is_ok_concurrent: "
            << std::boolalpha
            << result_is_ok_concurrent
            << ", calculation_time_concurrent: "
            << std::fixed
            << std::setprecision(1)
            << calculation_time_concurrent
            << "s"
            << std::endl;

  std::cout << "result_is_ok_sequential: "
            << std::boolalpha
            << result_is_ok_sequential
            << ", calculation_time_sequential: "
            << std::fixed
            << std::setprecision(1)
            << calculation_time_sequential
            << "s"
            << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/float128_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

// Demonstrations of using Boost.Multiprecision float128 quad type.
// (Only available using GCC compiler).

// Contains Quickbook markup in comments.

//[float128_eg
#include <boost/multiprecision/float128.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

int main()
{
   using namespace boost::multiprecision; // Potential to cause name collisions?
   // using boost::multiprecision::float128; // is safer.

/*`The type float128 provides operations at 128-bit precision with
[@https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#IEEE_754_quadruple-precision_binary_floating-point_format:_binary128 Quadruple-precision floating-point format]
and have full `std::numeric_limits` support:
*/
   float128 b = 2;
//` There are  15 bits of (biased) binary exponent and 113-bits of significand precision
   std::cout << std::numeric_limits<float128>::digits << std::endl;
//` or 33 decimal places:
   std::cout << std::numeric_limits<float128>::digits10 << std::endl;
   //` We can use any C++ std library function, so let's show all the at-most 36 potentially significant digits, and any trailing zeros, as well:
    std::cout.setf(std::ios_base::showpoint); // Include any trailing zeros.
   std::cout << std::setprecision(std::numeric_limits<float128>::max_digits10)
      << log(b) << std::endl; // Shows log(2) = 0.693147180559945309417232121458176575
   //` We can also use any function from Boost.Math, for example, the 'true gamma' function `tgamma`:
   std::cout << boost::math::tgamma(b) << std::endl;
   /*` And since we have an extended exponent range, we can generate some really large
    numbers here (4.02387260077093773543702433923004111e+2564):
   */
   std::cout << boost::math::tgamma(float128(1000)) << std::endl;
   /*` We can declare constants using GCC or Intel's native types, and literals with the Q suffix, and these can be declared `constexpr` if required:
   */
   // std::numeric_limits<float128>::max_digits10 = 36
   constexpr float128 pi = 3.14159265358979323846264338327950288Q;
   std::cout.precision(std::numeric_limits<float128>::max_digits10);
   std::cout << "pi = " << pi << std::endl; //pi = 3.14159265358979323846264338327950280
//] [/float128_eg]
   return 0;
}

/*
//[float128_numeric_limits

GCC 8.1.0

Type name is float128_t:
Type is g
std::is_fundamental<> = true
boost::multiprecision::detail::is_signed<> = true
boost::multiprecision::detail::is_unsigned<> = false
boost::multiprecision::detail::is_integral<> = false
boost::multiprecision::detail::is_arithmetic<> = true
std::is_const<> = false
std::is_trivial<> = true
std::is_standard_layout<> = true
std::is_pod<> = true
std::numeric_limits::<>is_exact = false
std::numeric_limits::<>is bounded = true
std::numeric_limits::<>is_modulo = false
std::numeric_limits::<>is_iec559 = true
std::numeric_limits::<>traps = false
std::numeric_limits::<>tinyness_before = false
std::numeric_limits::<>max() = 1.18973149535723176508575932662800702e+4932
std::numeric_limits::<>min() = 3.36210314311209350626267781732175260e-4932
std::numeric_limits::<>lowest() = -1.18973149535723176508575932662800702e+4932
std::numeric_limits::<>min_exponent = -16381
std::numeric_limits::<>max_exponent = 16384
std::numeric_limits::<>epsilon() = 1.92592994438723585305597794258492732e-34
std::numeric_limits::<>radix = 2
std::numeric_limits::<>digits = 113
std::numeric_limits::<>digits10 = 33
std::numeric_limits::<>max_digits10 = 36
std::numeric_limits::<>has denorm = true
std::numeric_limits::<>denorm min = 6.47517511943802511092443895822764655e-4966
std::denorm_loss = false
limits::has_signaling_NaN == false
std::numeric_limits::<>quiet_NaN = nan
std::numeric_limits::<>infinity = inf

//] [/float128_numeric_limits]
*/




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/floating_point_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/math/constants/constants.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/special_functions/bessel.hpp>
#include <iostream>
#include <iomanip>

#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_CXX11_LAMBDAS) && !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32))

#include <array>

//[AOS1

/*`Generic numeric programming employs templates to use the same code for different
floating-point types and functions. Consider the area of a circle a of radius r, given by

[:['a = [pi] * r[super 2]]]

The area of a circle can be computed in generic programming using Boost.Math
for the constant [pi] as shown below:

*/

//=#include <boost/math/constants/constants.hpp>

template<typename T>
inline T area_of_a_circle(T r)
{
   using boost::math::constants::pi;
   return pi<T>() * r * r;
}

/*`
It is possible to use `area_of_a_circle()` with built-in floating-point types as
well as floating-point types from Boost.Multiprecision. In particular, consider a
system with 4-byte single-precision float, 8-byte double-precision double and also the
`cpp_dec_float_50` data type from Boost.Multiprecision with 50 decimal digits
of precision.

We can compute and print the approximate area of a circle 
with radius 123/100  for `float`, `double` and `cpp_dec_float_50` with the program below
(see next section for choosing 123/100  instead of 1.23).

*/

//]

//[AOS3

/*`In later examples we'll look at calling both standard library and Boost.Math functions from within generic code.
We'll also show how to cope with template arguments which are expression-templates rather than number types.

But first some warnings about how multiprecision types are slightly but significantly different __fundamental_types. */

//]

//[JEL

/*`
In this example we'll show several implementations of the 
[@http://mathworld.wolfram.com/LambdaFunction.html Jahnke and Emden Lambda function], 
each implementation a little more sophisticated than the last.

The Jahnke-Emden Lambda function is defined by the equation:

[:['JahnkeEmden(v, z) = [Gamma](v+1) * J[sub v](z) / (z / 2)[super v]]]

If we were to implement this at double precision using Boost.Math's facilities for the Gamma and Bessel
function calls it would look like this:

*/

double JEL1(double v, double z)
{
   return boost::math::tgamma(v + 1) * boost::math::cyl_bessel_j(v, z) / std::pow(z / 2, v);
}

/*`
Calling this function as:

   std::cout << std::scientific << std::setprecision(std::numeric_limits<double>::digits10);
   std::cout << JEL1(2.5, 0.5) << std::endl;

Yields the output:

[pre 9.822663964796047e-001]

Now let's implement the function again, but this time using the multiprecision type
`cpp_dec_float_50` as the argument type:

*/   

boost::multiprecision::cpp_dec_float_50 
   JEL2(boost::multiprecision::cpp_dec_float_50 v, boost::multiprecision::cpp_dec_float_50 z)
{
   return boost::math::tgamma(v + 1) * boost::math::cyl_bessel_j(v, z) / boost::multiprecision::pow(z / 2, v);
}

/*`
The implementation is almost the same as before, but with one key difference - we can no longer call
`std::pow`, instead we must call the version inside the `boost::multiprecision` namespace.  In point of
fact, we could have omitted the namespace prefix on the call to `pow` since the right overload would 
have been found via [@http://en.wikipedia.org/wiki/Argument-dependent_name_lookup 
argument dependent lookup] in any case.

Note also that the first argument to `pow` along with the argument to `tgamma` in the above code
are actually expression templates.  The `pow` and `tgamma` functions will handle these arguments
just fine.

Here's an example of how the function may be called:

   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10);
   std::cout << JEL2(cpp_dec_float_50(2.5), cpp_dec_float_50(0.5)) << std::endl;

Which outputs:

[pre 9.82266396479604757017335009796882833995903762577173e-01]

Now that we've seen some non-template examples, lets repeat the code again, but this time as a template
that can be called either with a builtin type (`float`, `double` etc), or with a multiprecision type:

*/

template <class Float>
Float JEL3(Float v, Float z)
{
   using std::pow;
   return boost::math::tgamma(v + 1) * boost::math::cyl_bessel_j(v, z) / pow(z / 2, v);
}

/*`

Once again the code is almost the same as before, but the call to `pow` has changed yet again.
We need the call to resolve to either `std::pow` (when the argument is a builtin type), or
to `boost::multiprecision::pow` (when the argument is a multiprecision type).  We do that by
making the call unqualified so that versions of `pow` defined in the same namespace as type
`Float` are found via argument dependent lookup, while the `using std::pow` directive makes
the standard library versions visible for builtin floating point types.

Let's call the function with both `double` and multiprecision arguments:

   std::cout << std::scientific << std::setprecision(std::numeric_limits<double>::digits10);
   std::cout << JEL3(2.5, 0.5) << std::endl;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10);
   std::cout << JEL3(cpp_dec_float_50(2.5), cpp_dec_float_50(0.5)) << std::endl;

Which outputs:

[pre
9.822663964796047e-001
9.82266396479604757017335009796882833995903762577173e-01
]

Unfortunately there is a problem with this version: if we were to call it like this:

   boost::multiprecision::cpp_dec_float_50 v(2), z(0.5);
   JEL3(v + 0.5, z);

Then we would get a long and inscrutable error message from the compiler: the problem here is that the first
argument to `JEL3` is not a number type, but an expression template.  We could obviously add a typecast to
fix the issue:

   JEL(cpp_dec_float_50(v + 0.5), z);

However, if we want the function JEL to be truly reusable, then a better solution might be preferred.
To achieve this we can borrow some code from Boost.Math which calculates the return type of mixed-argument
functions, here's how the new code looks now:

*/

template <class Float1, class Float2>
typename boost::math::tools::promote_args<Float1, Float2>::type 
   JEL4(Float1 v, Float2 z)
{
   using std::pow;
   return boost::math::tgamma(v + 1) * boost::math::cyl_bessel_j(v, z) / pow(z / 2, v);
}

/*`

As you can see the two arguments to the function are now separate template types, and
the return type is computed using the `promote_args` metafunction from Boost.Math.

Now we can call:

   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_100>::digits10);
   std::cout << JEL4(cpp_dec_float_100(2) + 0.5, cpp_dec_float_100(0.5)) << std::endl;

And get 100 digits of output:

[pre 9.8226639647960475701733500979688283399590376257717309069410413822165082248153638454147004236848917775e-01]

As a bonus, we can now call the function not just with expression templates, but with other mixed types as well:
for example `float` and `double` or `int` and `double`, and the correct return type will be computed in each case.

Note that while in this case we didn't have to change the body of the function, in the general case
any function like this which creates local variables internally would have to use `promote_args`
to work out what type those variables should be, for example:

   template <class Float1, class Float2>
   typename boost::math::tools::promote_args<Float1, Float2>::type 
      JEL5(Float1 v, Float2 z)
   {
      using std::pow;
      typedef typename boost::math::tools::promote_args<Float1, Float2>::type variable_type;
      variable_type t = pow(z / 2, v);
      return boost::math::tgamma(v + 1) * boost::math::cyl_bessel_j(v, z) / t;
   }

*/

//]

//[ND1

/*`
In this example we'll add even more power to generic numeric programming using not only different
floating-point types but also function objects as template parameters. Consider
some well-known central difference rules for numerically computing the first derivative
of a function ['f[prime](x)] with ['x [isin] [real]]:

[equation floating_point_eg1]

Where the difference terms ['m[sub n]] are given by:

[equation floating_point_eg2]

and ['dx] is the step-size of the derivative.

The third formula in Equation 1 is a three-point central difference rule. It calculates
the first derivative of ['f[prime](x)] to ['O(dx[super 6])], where ['dx] is the given step-size. 
For example, if
the step-size is 0.01 this derivative calculation has about 6 decimal digits of precision - 
just about right for the 7 decimal digits of single-precision float.
Let's make a generic template subroutine using this three-point central difference
rule.  In particular:
*/

template<typename value_type, typename function_type>
   value_type derivative(const value_type x, const value_type dx, function_type func)
{
   // Compute d/dx[func(*first)] using a three-point
   // central difference rule of O(dx^6).

   const value_type dx1 = dx;
   const value_type dx2 = dx1 * 2;
   const value_type dx3 = dx1 * 3;

   const value_type m1 = (func(x + dx1) - func(x - dx1)) / 2;
   const value_type m2 = (func(x + dx2) - func(x - dx2)) / 4;
   const value_type m3 = (func(x + dx3) - func(x - dx3)) / 6;

   const value_type fifteen_m1 = 15 * m1;
   const value_type six_m2     =  6 * m2;
   const value_type ten_dx1    = 10 * dx1;

   return ((fifteen_m1 - six_m2) + m3) / ten_dx1;
}

/*`The `derivative()` template function can be used to compute the first derivative
of any function to ['O(dx[super 6])]. For example, consider the first derivative of ['sin(x)] evaluated
at ['x = [pi]/3]. In other words,

[equation floating_point_eg3]

The code below computes the derivative in Equation 3 for float, double and boost's
multiple-precision type cpp_dec_float_50.
*/

//]

//[GI1

/*`
Similar to the generic derivative example, we can calculate integrals in a similar manner:
*/

template<typename value_type, typename function_type>
inline value_type integral(const value_type a, 
                           const value_type b, 
                           const value_type tol, 
                           function_type func)
{
   unsigned n = 1U;

   value_type h = (b - a);
   value_type I = (func(a) + func(b)) * (h / 2);

   for(unsigned k = 0U; k < 8U; k++)
   {
      h /= 2;

      value_type sum(0);
      for(unsigned j = 1U; j <= n; j++)
      {
         sum += func(a + (value_type((j * 2) - 1) * h));
      }

      const value_type I0 = I;
      I = (I / 2) + (h * sum);

      const value_type ratio     = I0 / I;
      const value_type delta     = ratio - 1;
      const value_type delta_abs = ((delta < 0) ? -delta : delta);

      if((k > 1U) && (delta_abs < tol))
      {
         break;
      }

      n *= 2U;
   }

   return I;
}

/*`
The following sample program shows how the function can be called, we begin
by defining a function object, which when integrated should yield the Bessel J
function:
*/

template<typename value_type>
class cyl_bessel_j_integral_rep
{
public:
   cyl_bessel_j_integral_rep(const unsigned N,
      const value_type& X) : n(N), x(X) { }

   value_type operator()(const value_type& t) const
   {
      // pi * Jn(x) = Int_0^pi [cos(x * sin(t) - n*t) dt]
      return cos(x * sin(t) - (n * t));
   }

private:
   const unsigned n;
   const value_type x;
};


//]

//[POLY

/*`
In this example we'll look at polynomial evaluation, this is not only an important
use case, but it's one that `number` performs particularly well at because the
expression templates ['completely eliminate all temporaries] from a 
[@http://en.wikipedia.org/wiki/Horner%27s_method Horner polynomial
evaluation scheme].

The following code evaluates `sin(x)` as a polynomial, accurate to at least 64 decimal places:

*/

using boost::multiprecision::cpp_dec_float;
typedef boost::multiprecision::number<cpp_dec_float<64> > mp_type;

mp_type mysin(const mp_type& x)
{
  // Approximation of sin(x * pi/2) for -1 <= x <= 1, using an order 63 polynomial.
  static const std::array<mp_type, 32U> coefs =
  {{
    mp_type("+1.5707963267948966192313216916397514420985846996875529104874722961539082031431044993140174126711"), //"),
    mp_type("-0.64596409750624625365575656389794573337969351178927307696134454382929989411386887578263960484"), // ^3
    mp_type("+0.07969262624616704512050554949047802252091164235106119545663865720995702920146198554317279"), // ^5
    mp_type("-0.0046817541353186881006854639339534378594950280185010575749538605102665157913157426229824"), // ^7
    mp_type("+0.00016044118478735982187266087016347332970280754062061156858775174056686380286868007443"), // ^9
    mp_type("-3.598843235212085340458540018208389404888495232432127661083907575106196374913134E-6"), // ^11
    mp_type("+5.692172921967926811775255303592184372902829756054598109818158853197797542565E-8"), // ^13
    mp_type("-6.688035109811467232478226335783138689956270985704278659373558497256423498E-10"), // ^15
    mp_type("+6.066935731106195667101445665327140070166203261129845646380005577490472E-12"), // ^17
    mp_type("-4.377065467313742277184271313776319094862897030084226361576452003432E-14"), // ^19
    mp_type("+2.571422892860473866153865950420487369167895373255729246889168337E-16"), // ^21
    mp_type("-1.253899540535457665340073300390626396596970180355253776711660E-18"), // ^23
    mp_type("+5.15645517658028233395375998562329055050964428219501277474E-21"), // ^25
    mp_type("-1.812399312848887477410034071087545686586497030654642705E-23"), // ^27
    mp_type("+5.50728578652238583570585513920522536675023562254864E-26"), // ^29
    mp_type("-1.461148710664467988723468673933026649943084902958E-28"), // ^31
    mp_type("+3.41405297003316172502972039913417222912445427E-31"), // ^33
    mp_type("-7.07885550810745570069916712806856538290251E-34"), // ^35
    mp_type("+1.31128947968267628970845439024155655665E-36"), // ^37
    mp_type("-2.18318293181145698535113946654065918E-39"), // ^39
    mp_type("+3.28462680978498856345937578502923E-42"), // ^41
    mp_type("-4.48753699028101089490067137298E-45"), // ^43
    mp_type("+5.59219884208696457859353716E-48"), // ^45
    mp_type("-6.38214503973500471720565E-51"), // ^47
    mp_type("+6.69528558381794452556E-54"), // ^49
    mp_type("-6.47841373182350206E-57"), // ^51
    mp_type("+5.800016389666445E-60"), // ^53
    mp_type("-4.818507347289E-63"), // ^55
    mp_type("+3.724683686E-66"), // ^57
    mp_type("-2.6856479E-69"), // ^59
    mp_type("+1.81046E-72"), // ^61
    mp_type("-1.133E-75"), // ^63
  }};

  const mp_type v = x * 2 / boost::math::constants::pi<mp_type>();
  const mp_type x2 = (v * v);
  //
  // Polynomial evaluation follows, if mp_type allocates memory then
  // just one such allocation occurs - to initialize the variable "sum" -
  // and no temporaries are created at all.
  //
  const mp_type sum = (((((((((((((((((((((((((((((((     + coefs[31U]
                                                     * x2 + coefs[30U])
                                                     * x2 + coefs[29U])
                                                     * x2 + coefs[28U])
                                                     * x2 + coefs[27U])
                                                     * x2 + coefs[26U])
                                                     * x2 + coefs[25U])
                                                     * x2 + coefs[24U])
                                                     * x2 + coefs[23U])
                                                     * x2 + coefs[22U])
                                                     * x2 + coefs[21U])
                                                     * x2 + coefs[20U])
                                                     * x2 + coefs[19U])
                                                     * x2 + coefs[18U])
                                                     * x2 + coefs[17U])
                                                     * x2 + coefs[16U])
                                                     * x2 + coefs[15U])
                                                     * x2 + coefs[14U])
                                                     * x2 + coefs[13U])
                                                     * x2 + coefs[12U])
                                                     * x2 + coefs[11U])
                                                     * x2 + coefs[10U])
                                                     * x2 + coefs[9U])
                                                     * x2 + coefs[8U])
                                                     * x2 + coefs[7U])
                                                     * x2 + coefs[6U])
                                                     * x2 + coefs[5U])
                                                     * x2 + coefs[4U])
                                                     * x2 + coefs[3U])
                                                     * x2 + coefs[2U])
                                                     * x2 + coefs[1U])
                                                     * x2 + coefs[0U])
                                                     * v;

  return sum;
}

/*`
Calling the function like so:

   mp_type pid4 = boost::math::constants::pi<mp_type>() / 4;
   std::cout << std::setprecision(std::numeric_limits< ::mp_type>::digits10) << std::scientific;
   std::cout << mysin(pid4) << std::endl;

Yields the expected output:

[pre 7.0710678118654752440084436210484903928483593768847403658833986900e-01]

*/

//]


int main()
{
   using namespace boost::multiprecision;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<double>::digits10);
   std::cout << JEL1(2.5, 0.5) << std::endl;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10);
   std::cout << JEL2(cpp_dec_float_50(2.5), cpp_dec_float_50(0.5)) << std::endl;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<double>::digits10);
   std::cout << JEL3(2.5, 0.5) << std::endl;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10);
   std::cout << JEL3(cpp_dec_float_50(2.5), cpp_dec_float_50(0.5)) << std::endl;
   std::cout << std::scientific << std::setprecision(std::numeric_limits<cpp_dec_float_100>::digits10);
   std::cout << JEL4(cpp_dec_float_100(2) + 0.5, cpp_dec_float_100(0.5)) << std::endl;

   //[AOS2

/*=#include <iostream>
#include <iomanip>
#include <boost/multiprecision/cpp_dec_float.hpp>

using boost::multiprecision::cpp_dec_float_50;

int main(int, char**)
{*/
   const float r_f(float(123) / 100);
   const float a_f = area_of_a_circle(r_f);

   const double r_d(double(123) / 100);
   const double a_d = area_of_a_circle(r_d);

   const cpp_dec_float_50 r_mp(cpp_dec_float_50(123) / 100);
   const cpp_dec_float_50 a_mp = area_of_a_circle(r_mp);

   // 4.75292
   std::cout
      << std::setprecision(std::numeric_limits<float>::digits10)
      << a_f
      << std::endl;

   // 4.752915525616
   std::cout
      << std::setprecision(std::numeric_limits<double>::digits10)
      << a_d
      << std::endl;

   // 4.7529155256159981904701331745635599135018975843146
   std::cout
      << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10)
      << a_mp
      << std::endl;
/*=}*/

   //]

   //[ND2
/*=
#include <iostream>
#include <iomanip>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/constants/constants.hpp>


int main(int, char**)
{*/
   using boost::math::constants::pi;
   using boost::multiprecision::cpp_dec_float_50;
   //
   // We'll pass a function pointer for the function object passed to derivative,
   // the typecast is needed to select the correct overload of std::sin:
   //
   const float d_f = derivative(
      pi<float>() / 3,
      0.01F,
      static_cast<float(*)(float)>(std::sin)
   );

   const double d_d = derivative(
      pi<double>() / 3,
      0.001,
      static_cast<double(*)(double)>(std::sin)
      );
   //
   // In the cpp_dec_float_50 case, the sin function is multiply overloaded
   // to handle expression templates etc.  As a result it's hard to take its
   // address without knowing about its implementation details.  We'll use a 
   // C++11 lambda expression to capture the call.
   // We also need a typecast on the first argument so we don't accidentally pass
   // an expression template to a template function:
   //
   const cpp_dec_float_50 d_mp = derivative(
      cpp_dec_float_50(pi<cpp_dec_float_50>() / 3),
      cpp_dec_float_50(1.0E-9),
      [](const cpp_dec_float_50& x) -> cpp_dec_float_50
      {
         return sin(x);
      }
      );

   // 5.000029e-001
   std::cout
      << std::setprecision(std::numeric_limits<float>::digits10)
      << d_f
      << std::endl;

   // 4.999999999998876e-001
   std::cout
      << std::setprecision(std::numeric_limits<double>::digits10)
      << d_d
      << std::endl;

   // 4.99999999999999999999999999999999999999999999999999e-01
   std::cout
      << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10)
      << d_mp
      << std::endl;
//=}

   /*`
   The expected value of the derivative is 0.5. This central difference rule in this
   example is ill-conditioned, meaning it suffers from slight loss of precision. With that
   in mind, the results agree with the expected value of 0.5.*/

   //]

   //[ND3

   /*`
   We can take this a step further and use our derivative function to compute
   a partial derivative.  For example if we take the incomplete gamma function
   ['P(a, z)], and take the derivative with respect to /z/ at /(2,2)/ then we
   can calculate the result as shown below, for good measure we'll compare with
   the "correct" result obtained from a call to ['gamma_p_derivative], the results
   agree to approximately 44 digits:
   */

   cpp_dec_float_50 gd = derivative(
      cpp_dec_float_50(2),
      cpp_dec_float_50(1.0E-9),
      [](const cpp_dec_float_50& x) ->cpp_dec_float_50
      {
         return boost::math::gamma_p(2, x);
      }
   );
   // 2.70670566473225383787998989944968806815263091819151e-01
   std::cout
      << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10)
      << gd
      << std::endl;
   // 2.70670566473225383787998989944968806815253190143120e-01
   std::cout << boost::math::gamma_p_derivative(cpp_dec_float_50(2), cpp_dec_float_50(2)) << std::endl;
   //]

   //[GI2

   /* The function can now be called as follows: */
/*=int main(int, char**)
{*/
   using boost::math::constants::pi;
   typedef boost::multiprecision::cpp_dec_float_50 mp_type;

   const float j2_f =
      integral(0.0F,
      pi<float>(),
      0.01F,
      cyl_bessel_j_integral_rep<float>(2U, 1.23F)) / pi<float>();

   const double j2_d =
      integral(0.0,
      pi<double>(),
      0.0001,
      cyl_bessel_j_integral_rep<double>(2U, 1.23)) / pi<double>();

   const mp_type j2_mp =
      integral(mp_type(0),
      pi<mp_type>(),
      mp_type(1.0E-20),
      cyl_bessel_j_integral_rep<mp_type>(2U, mp_type(123) / 100)) / pi<mp_type>();

   // 0.166369
   std::cout
      << std::setprecision(std::numeric_limits<float>::digits10)
      << j2_f
      << std::endl;

   // 0.166369383786814
   std::cout
      << std::setprecision(std::numeric_limits<double>::digits10)
      << j2_d
      << std::endl;

   // 0.16636938378681407351267852431513159437103348245333
   std::cout
      << std::setprecision(std::numeric_limits<mp_type>::digits10)
      << j2_mp
      << std::endl;

   //
   // Print true value for comparison:
   // 0.166369383786814073512678524315131594371033482453329
   std::cout << boost::math::cyl_bessel_j(2, mp_type(123) / 100) << std::endl;
//=}

   //]

   std::cout << std::setprecision(std::numeric_limits< ::mp_type>::digits10) << std::scientific;
   std::cout << mysin(boost::math::constants::pi< ::mp_type>() / 4) << std::endl;
   std::cout << boost::multiprecision::sin(boost::math::constants::pi< ::mp_type>() / 4) << std::endl;

   return 0;
}

/*

Program output:

9.822663964796047e-001
9.82266396479604757017335009796882833995903762577173e-01
9.822663964796047e-001
9.82266396479604757017335009796882833995903762577173e-01
9.8226639647960475701733500979688283399590376257717309069410413822165082248153638454147004236848917775e-01
4.752916e+000
4.752915525615998e+000
4.75291552561599819047013317456355991350189758431460e+00
5.000029e-001
4.999999999998876e-001
4.99999999999999999999999999999999999999999999999999e-01
2.70670566473225383787998989944968806815263091819151e-01
2.70670566473225383787998989944968806815253190143120e-01
7.0710678118654752440084436210484903928483593768847403658833986900e-01
7.0710678118654752440084436210484903928483593768847403658833986900e-01
*/

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/gauss_laguerre_quadrature.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//      Copyright Christopher Kormanyos 2012 - 2015, 2020.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//

// This example uses Boost.Multiprecision to implement
// a high-precision Gauss-Laguerre quadrature integration.
// The quadrature is used to calculate the airy_ai(x) function
// for real-valued x on the positive axis with x.ge.1.

// In this way, the integral representation could be seen
// as part of a scheme to calculate real-valued Airy functions
// on the positive axis for medium to large argument.
// A Taylor series or hypergeometric function (not part
// of this example) could be used for smaller arguments.

// This example has been tested with decimal digits counts
// ranging from 21...301, by adjusting the parameter
// local::my_digits10 at compile time.

// The quadrature integral representaion of airy_ai(x) used
// in this example can be found in:

// A. Gil, J. Segura, N.M. Temme, "Numerical Methods for Special
// Functions" (SIAM Press 2007), Sect. 5.3.3, in particular Eq. 5.110,
// page 145. Subsequently, Gil et al's book cites the another work:
// W. Gautschi, "Computation of Bessel and Airy functions and of
// related Gaussian quadrature formulae", BIT, 42 (2002), pp. 110-118.

#include <cmath>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <sstream>
#include <tuple>
#include <vector>

#include <boost/cstdfloat.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/math/special_functions/bessel.hpp>
#include <boost/math/special_functions/factorials.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/tools/roots.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/noncopyable.hpp>

namespace gauss { namespace laguerre {

namespace util {

void progress_bar(std::ostream& os, const float percent);

void progress_bar(std::ostream& os, const float percent)
{
  std::stringstream strstrm;

  strstrm.precision(1);

  strstrm << std::fixed << percent << "%";

  os << strstrm.str() << "\r";

  os.flush();
}

}

namespace detail
{
  template<typename T>
  class laguerre_l_object BOOST_FINAL
  {
  public:
    laguerre_l_object(const int n, const T a) noexcept
      : order(n),
        alpha(a),
        p1   (0),
        d2   (0) { }

    laguerre_l_object& operator=(const laguerre_l_object& other)
    {
      if(this != other)
      {
        order = other.order;
        alpha = other.alpha;
        p1    = other.p1;
        d2    = other.d2;
      }

      return *this;
    }

    T operator()(const T& x) const noexcept
    {
      // Calculate (via forward recursion):
      // * the value of the Laguerre function L(n, alpha, x), called (p2),
      // * the value of the derivative of the Laguerre function (d2),
      // * and the value of the corresponding Laguerre function of
      //   previous order (p1).

      // Return the value of the function (p2) in order to be used as a
      // function object with Boost.Math root-finding. Store the values
      // of the Laguerre function derivative (d2) and the Laguerre function
      // of previous order (p1) in class members for later use.

        p1 = T(0);
      T p2 = T(1);
        d2 = T(0);

      T j_plus_alpha = alpha;
      T two_j_plus_one_plus_alpha_minus_x = (1 + alpha) - x;

      const T my_two = 2;

      for(int j = 0; j < order; ++j)
      {
        const T p0(p1);

        // Set the value of the previous Laguerre function.
        p1 = p2;

        // Use a recurrence relation to compute the value of the Laguerre function.
        p2 = ((two_j_plus_one_plus_alpha_minus_x * p1) - (j_plus_alpha * p0)) / (j + 1);

        ++j_plus_alpha;
        two_j_plus_one_plus_alpha_minus_x += my_two;
      }

      // Set the value of the derivative of the Laguerre function.
      d2 = ((p2 * order) - (j_plus_alpha * p1)) / x;

      // Return the value of the Laguerre function.
      return p2;
    }

    const T previous  () const noexcept { return p1; }
    const T derivative() const noexcept { return d2; }

    static bool root_tolerance(const T& a, const T& b) noexcept
    {
      using std::fabs;

      // The relative tolerance here is: ((a - b) * 2) / (a + b).
      return ((fabs(a - b) * 2) < (fabs(a + b) * std::numeric_limits<T>::epsilon()));
    }

  private:
    const   int order;
    const   T   alpha;
    mutable T   p1;
    mutable T   d2;
  };

  template<typename T>
  class abscissas_and_weights : private boost::noncopyable
  {
  public:
    abscissas_and_weights(const int n, const T a) : order(n),
                                                    alpha(a),
                                                    xi   (),
                                                    wi   ()
    {
      if(alpha < -20.0F)
      {
        // Users can decide to perform different range checking.
        std::cout << "Range error: the order of the Laguerre function must exceed -20.0."
                  << std::endl;
      }
      else
      {
        calculate();
      }
    }

    const std::vector<T>& abscissa_n() const noexcept { return xi; }
    const std::vector<T>& weight_n  () const noexcept { return wi; }

  private:
    const int order;
    const T   alpha;

    std::vector<T> xi;
    std::vector<T> wi;

    abscissas_and_weights() : order(),
                              alpha(),
                              xi   (),
                              wi   () { }

    void calculate()
    {
      using std::abs;

      std::cout << "Finding the approximate roots..." << std::endl;

      std::vector<std::tuple<T, T>> root_estimates;

      root_estimates.reserve(static_cast<typename std::vector<std::tuple<T, T>>::size_type>(order));

      const laguerre_l_object<T> laguerre_root_object(order, alpha);

      // Set the initial values of the step size and the running step
      // to be used for finding the estimate of the first root.
      T step_size  = 0.01F;
      T step       = step_size;

      T first_laguerre_root = 0.0F;

      if(alpha < -1.0F)
      {
        // Iteratively step through the Laguerre function using a
        // small step-size in order to find a rough estimate of
        // the first zero.

        const bool this_laguerre_value_is_negative = (laguerre_root_object(T(0)) < 0);

        constexpr int j_max = 10000;

        int j = 0;

        while((j < j_max) && (this_laguerre_value_is_negative != (laguerre_root_object(step) < 0)))
        {
          // Increment the step size until the sign of the Laguerre function
          // switches. This indicates a zero-crossing, signalling the next root.
          step += step_size;

          ++j;
        }
      }
      else
      {
        // Calculate an estimate of the 1st root of a generalized Laguerre
        // function using either a Taylor series or an expansion in Bessel
        // function zeros. The Bessel function zeros expansion is from Tricomi.

        // Here, we obtain an estimate of the first zero of cyl_bessel_j(alpha, x).

        T j_alpha_m1;

        if(alpha < 1.4F)
        {
          // For small alpha, use a short series obtained from Mathematica(R).
          // Series[BesselJZero[v, 1], {v, 0, 3}]
          // N[%, 12]
          j_alpha_m1 = (((          T(0.09748661784476F)
                          * alpha - T(0.17549359276115F))
                          * alpha + T(1.54288974259931F))
                          * alpha + T(2.40482555769577F));
        }
        else
        {
          // For larger alpha, use the first line of Eqs. 10.21.40 in the NIST Handbook.
          const T alpha_pow_third(boost::math::cbrt(alpha));
          const T alpha_pow_minus_two_thirds(T(1) / (alpha_pow_third * alpha_pow_third));

          j_alpha_m1 = alpha * (((((                             + T(0.043F)
                                    * alpha_pow_minus_two_thirds - T(0.0908F))
                                    * alpha_pow_minus_two_thirds - T(0.00397F))
                                    * alpha_pow_minus_two_thirds + T(1.033150F))
                                    * alpha_pow_minus_two_thirds + T(1.8557571F))
                                    * alpha_pow_minus_two_thirds + T(1.0F));
        }

        const T vf             = (  T(order * 4U)
                                  + T(alpha * 2U)
                                  + T(2U));
        const T vf2            = vf * vf;
        const T j_alpha_m1_sqr = j_alpha_m1 * j_alpha_m1;

        first_laguerre_root = (j_alpha_m1_sqr * (   -T(0.6666666666667F)
                                                 + ((T(0.6666666666667F) * alpha) * alpha)
                                                 +  (T(0.3333333333333F) * j_alpha_m1_sqr) + vf2)) / (vf2 * vf);
      }

      bool this_laguerre_value_is_negative = (laguerre_root_object(T(0)) < 0);

      // Re-set the initial value of the step-size based on the
      // estimate of the first root.
      step_size = first_laguerre_root / 2;
      step      = step_size;

      // Step through the Laguerre function using a step-size
      // of dynamic width in order to find the zero crossings
      // of the Laguerre function, providing rough estimates
      // of the roots. Refine the brackets with a few bisection
      // steps, and store the results as bracketed root estimates.

      while(root_estimates.size() < static_cast<std::size_t>(order))
      {
        // Increment the step size until the sign of the Laguerre function
        // switches. This indicates a zero-crossing, signalling the next root.
        step += step_size;

        if(this_laguerre_value_is_negative != (laguerre_root_object(step) < 0))
        {
          // We have found the next zero-crossing.

          // Change the running sign of the Laguerre function.
          this_laguerre_value_is_negative = (!this_laguerre_value_is_negative);

          // We have found the first zero-crossing. Put a loose bracket around
          // the root using a window. Here, we know that the first root lies
          // between (x - step_size) < root < x.

          // Before storing the approximate root, perform a couple of
          // bisection steps in order to tighten up the root bracket.
          std::uintmax_t a_couple_of_iterations = 4U;

          const std::pair<T, T>
            root_estimate_bracket = boost::math::tools::bisect(laguerre_root_object,
                                                               step - step_size,
                                                               step,
                                                               laguerre_l_object<T>::root_tolerance,
                                                               a_couple_of_iterations);

          static_cast<void>(a_couple_of_iterations);

          // Store the refined root estimate as a bracketed range in a tuple.
          root_estimates.push_back(std::tuple<T, T>(std::get<0>(root_estimate_bracket),
                                                    std::get<1>(root_estimate_bracket)));

          if(    (root_estimates.size() == 1U)
             || ((root_estimates.size() % 8U) == 0U)
             ||  (root_estimates.size() == static_cast<std::size_t>(order)))
          {
            const float progress = (100.0F * static_cast<float>(root_estimates.size())) / static_cast<float>(order);

            std::cout << "root_estimates.size(): "
                      << root_estimates.size()
                      << ", "
                      ;

            util::progress_bar(std::cout, progress);
          }

          if(root_estimates.size() >= static_cast<std::size_t>(2U))
          {
            // Determine the next step size. This is based on the distance between
            // the previous two roots, whereby the estimates of the previous roots
            // are computed by taking the average of the lower and upper range of
            // the root-estimate bracket.

            const T r0 = (  std::get<0>(*(root_estimates.crbegin() + 1U))
                          + std::get<1>(*(root_estimates.crbegin() + 1U))) / 2;

            const T r1 = (  std::get<0>(*root_estimates.crbegin())
                          + std::get<1>(*root_estimates.crbegin())) / 2;

            const T distance_between_previous_roots = r1 - r0;

            step_size = distance_between_previous_roots / 3;
          }
        }
      }

      const T norm_g =
        ((alpha == 0) ? T(-1)
                      : -boost::math::tgamma(alpha + order) / boost::math::factorial<T>(order - 1));

      xi.reserve(root_estimates.size());
      wi.reserve(root_estimates.size());

      std::cout << std::endl;

      // Calculate the abscissas and weights to full precision.
      for(std::size_t i = static_cast<std::size_t>(0U); i < root_estimates.size(); ++i)
      {
        if(   ((i % 8U) == 0U)
           || ( i == root_estimates.size() - 1U))
        {
          const float progress = (100.0F * static_cast<float>(i + 1U)) / static_cast<float>(root_estimates.size());

          std::cout << "Calculating abscissas and weights. Processed "
                    << (i + 1U)
                    << ", "
                    ;

          util::progress_bar(std::cout, progress);
        }

        // Calculate the abscissas using iterative root-finding.

        // Select the maximum allowed iterations, being at least 20.
        // The determination of the maximum allowed iterations is
        // based on the number of decimal digits in the numerical
        // type T.
        constexpr int local_math_tools_digits10 =
          static_cast<int>(static_cast<boost::float_least32_t>(boost::math::tools::digits<T>()) * BOOST_FLOAT32_C(0.301));

        const std::uintmax_t number_of_iterations_allowed = (std::max)(20, local_math_tools_digits10 / 2);

        std::uintmax_t number_of_iterations_used = number_of_iterations_allowed;

        // Perform the root-finding using ACM TOMS 748 from Boost.Math.
        const std::pair<T, T>
          laguerre_root_bracket = boost::math::tools::toms748_solve(laguerre_root_object,
                                                                    std::get<0>(root_estimates.at(i)),
                                                                    std::get<1>(root_estimates.at(i)),
                                                                    laguerre_l_object<T>::root_tolerance,
                                                                    number_of_iterations_used);

        static_cast<void>(number_of_iterations_used);

        // Compute the Laguerre root as the average of the values from
        // the solved root bracket.
        const T laguerre_root = (  std::get<0>(laguerre_root_bracket)
                                 + std::get<1>(laguerre_root_bracket)) / 2;

        // Calculate the weight for this Laguerre root. Here, we calculate
        // the derivative of the Laguerre function and the value of the
        // previous Laguerre function on the x-axis at the value of this
        // Laguerre root.
        static_cast<void>(laguerre_root_object(laguerre_root));

        // Store the abscissa and weight for this index.
        xi.push_back(laguerre_root);
        wi.push_back(norm_g / ((laguerre_root_object.derivative() * order) * laguerre_root_object.previous()));
      }

      std::cout << std::endl;
    }
  };

  template<typename T>
  struct airy_ai_object BOOST_FINAL
  {
  public:
    airy_ai_object(const T& x)
      : my_x     (x),
        my_zeta  (((sqrt(x) * x) * 2) / 3),
        my_factor(make_factor(my_zeta)) { }

    T operator()(const T& t) const
    {
      using std::sqrt;

      return my_factor / sqrt(boost::math::cbrt(2 + (t / my_zeta)));
    }

  private:
    const T my_x;
    const T my_zeta;
    const T my_factor;

    airy_ai_object() : my_x     (),
                       my_zeta  (),
                       my_factor() { }

    static T make_factor(const T& z)
    {
      using std::exp;
      using std::sqrt;

      return 1 / ((sqrt(boost::math::constants::pi<T>()) * sqrt(boost::math::cbrt(z * 48))) * (exp(z) * boost::math::tgamma(T(5) / 6)));
    }
  };
} // namespace detail

} } // namespace gauss::laguerre


// A float_type is created to handle the desired number of decimal digits from `cpp_dec_float` without using __expression_templates.
struct local
{
  static constexpr unsigned int my_digits10 = 101U;

  typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<my_digits10>,
                                        boost::multiprecision::et_off>
  float_type;
};

static_assert(local::my_digits10 > 20U,
                        "Error: This example is intended to have more than 20 decimal digits");

int main()
{
  // Use Gauss-Laguerre quadrature integration to compute airy_ai(x / 7)
  // with 7 <= x <= 120 and where x is incremented in steps of 1.

  // During development of this example, we have empirically found
  // the numbers of Gauss-Laguerre coefficients needed for convergence
  // when using various counts of base-10 digits.

  // Let's calibrate, for instance, the number of coefficients needed
  // at the point x = 1.

  // Empirical data lead to:
  // Fit[{{21.0, 3.5}, {51.0, 11.1}, {101.0, 22.5}, {201.0, 46.8}}, {1, d, d^2}, d]
  // FullSimplify[%]
  // -1.28301 + (0.235487 + 0.0000178915 d) d

  // We need significantly more coefficients at smaller real values than are needed
  // at larger real values because the slope derivative of airy_ai(x) gets more
  // steep as x approaches zero.

  // This Gauss-Laguerre quadrature is designed for airy_ai(x) with real-valued x >= 1.

  constexpr boost::float_least32_t d = static_cast<boost::float_least32_t>(std::numeric_limits<local::float_type>::digits10);

  constexpr boost::float_least32_t laguerre_order_factor = -1.28301F + ((0.235487F + (0.0000178915F * d)) * d);

  constexpr int laguerre_order = static_cast<int>(laguerre_order_factor * d);

  std::cout << "std::numeric_limits<local::float_type>::digits10: " << std::numeric_limits<local::float_type>::digits10 << std::endl;
  std::cout << "laguerre_order: " << laguerre_order << std::endl;

  typedef gauss::laguerre::detail::abscissas_and_weights<local::float_type> abscissas_and_weights_type;

  const abscissas_and_weights_type the_abscissas_and_weights(laguerre_order, local::float_type(-1) / 6);

  bool result_is_ok = true;

  for(std::uint32_t u = 7U; u < 121U; ++u)
  {
    const local::float_type x = local::float_type(u) / 7;

    typedef gauss::laguerre::detail::airy_ai_object<local::float_type> airy_ai_object_type;

    const airy_ai_object_type the_airy_ai_object(x);

    const local::float_type airy_ai_value =
      std::inner_product(the_abscissas_and_weights.abscissa_n().cbegin(),
                         the_abscissas_and_weights.abscissa_n().cend(),
                         the_abscissas_and_weights.weight_n().cbegin(),
                         local::float_type(0U),
                         std::plus<local::float_type>(),
                         [&the_airy_ai_object](const local::float_type& this_abscissa,
                                               const local::float_type& this_weight) -> local::float_type
                         {
                           return the_airy_ai_object(this_abscissa) * this_weight;
                         });

    static const local::float_type one_third = 1.0F / local::float_type(3U);

    static const local::float_type one_over_pi_times_one_over_sqrt_three =
      sqrt(one_third) * boost::math::constants::one_div_pi<local::float_type>();

    const local::float_type sqrt_x = sqrt(x);

    const local::float_type airy_ai_control =
       (sqrt_x * one_over_pi_times_one_over_sqrt_three)
      * boost::math::cyl_bessel_k(one_third, ((2.0F * x) * sqrt_x) * one_third);

    std::cout << std::setprecision(std::numeric_limits<local::float_type>::digits10)
              << "airy_ai_value  : "
              << airy_ai_value
              << std::endl;

    std::cout << std::setprecision(std::numeric_limits<local::float_type>::digits10)
              << "airy_ai_control: "
              << airy_ai_control
              << std::endl;

    const local::float_type delta = fabs(1.0F - (airy_ai_control / airy_ai_value));

    static const local::float_type tol("1E-" + boost::lexical_cast<std::string>(std::numeric_limits<local::float_type>::digits10 - 7U));

    result_is_ok &= (delta < tol);
  }

  std::cout << std::endl
            << "Total... result_is_ok: "
            << std::boolalpha
            << result_is_ok
            << std::endl;
} // int main()

/*


Partial output:

//[gauss_laguerre_quadrature_output_1

std::numeric_limits<local::float_type>::digits10: 101
laguerre_order: 2291

Finding the approximate roots...
root_estimates.size(): 1, 0.0%
root_estimates.size(): 8, 0.3%
root_estimates.size(): 16, 0.7%
...
root_estimates.size(): 2288, 99.9%
root_estimates.size(): 2291, 100.0%


Calculating abscissas and weights. Processed 1, 0.0%
Calculating abscissas and weights. Processed 9, 0.4%
...
Calculating abscissas and weights. Processed 2289, 99.9%
Calculating abscissas and weights. Processed 2291, 100.0%
//] [/gauss_laguerre_quadrature_output_1]

//[gauss_laguerre_quadrature_output_2

airy_ai_value  : 0.13529241631288141552414742351546630617494414298833070600910205475763353480226572366348710990874867334
airy_ai_control: 0.13529241631288141552414742351546630617494414298833070600910205475763353480226572366348710990874868323
airy_ai_value  : 0.11392302126009621102904231059693500086750049240884734708541630001378825889924647699516200868335286103
airy_ai_control: 0.1139230212600962110290423105969350008675004924088473470854163000137882588992464769951620086833528582
...
airy_ai_value  : 3.8990420982303275013276114626640705170145070824317976771461533035231088620152288641360519429331427451e-22
airy_ai_control: 3.8990420982303275013276114626640705170145070824317976771461533035231088620152288641360519429331426481e-22

Total... result_is_ok: true

//] [/gauss_laguerre_quadrature_output_2]


*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/gmp_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

void t1()
{
   //[mpz_eg
//=#include <boost/multiprecision/gmp.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   mpz_int v = 1;

   // Do some arithmetic:
   for(unsigned i = 1; i <= 1000; ++i)
      v *= i;

   std::cout << v << std::endl; // prints 1000!

   // Access the underlying representation:
   mpz_t z;
   mpz_init(z);
   mpz_set(z, v.backend().data());
   mpz_clear(z);
//=   return 0;
//=}
//]
}

void t2()
{
//[mpf_eg
//=#include <boost/multiprecision/gmp.hpp>
//=#include <boost/math/special_functions/gamma.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   // Operations at variable precision and limited standard library support:
   mpf_float a = 2;
   mpf_float::default_precision(1000);
   std::cout << mpf_float::default_precision() << std::endl;
   std::cout << sqrt(a) << std::endl; // print root-2

   // Operations at fixed precision and full standard library support:
   mpf_float_100 b = 2;
   std::cout << std::numeric_limits<mpf_float_100>::digits << std::endl;
   // We can use any C++ std lib function:
   std::cout << log(b) << std::endl; // print log(2)
   // We can also use any function from Boost.Math:
   std::cout << boost::math::tgamma(b) << std::endl;
   // These even work when the argument is an expression template:
   std::cout << boost::math::tgamma(b * b) << std::endl;

   // Access the underlying representation:
   mpf_t f;
   mpf_init(f);
   mpf_set(f, a.backend().data());
   mpf_clear(f);
//=   return 0;
//=}
//]
}

void t3()
{
//[mpq_eg
//=#include <boost/multiprecision/gmp.hpp>
//=#include <boost/multiprecision/gmp.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   mpq_rational v = 1;

   // Do some arithmetic:
   for(unsigned i = 1; i <= 1000; ++i)
      v *= i;
   v /= 10;

   std::cout << v << std::endl; // prints 1000! / 10
   std::cout << numerator(v) << std::endl;
   std::cout << denominator(v) << std::endl;

   mpq_rational w(2, 3);  // component wise constructor
   std::cout << w << std::endl; // prints 2/3

   // Access the underlying data:
   mpq_t q;
   mpq_init(q);
   mpq_set(q, v.backend().data());
   mpq_clear(q);
//=   return 0;
//=}
//]
}

int main()
{
   t1();
   t2();
   t3();
   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/hashing_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random.hpp>
#include <boost/functional/hash.hpp>
#include <unordered_set>
#include <city.h>

//[hash1

/*`
All of the types in this library support hashing via boost::hash or std::hash.
That means we can use multiprecision types directly in hashed containers such as std::unordered_set:
*/
//]

void t1()
{
   //[hash2
   using namespace boost::multiprecision;
   using namespace boost::random;

   mt19937 mt;
   uniform_int_distribution<uint256_t> ui;

   std::unordered_set<uint256_t> set;
   // Put 1000 random values into the container:
   for(unsigned i = 0; i < 1000; ++i)
      set.insert(ui(mt));

   //]
}

//[hash3

/*` 
Or we can define our own hash function, for example in this case based on
Google's CityHash:
*/

struct cityhash
{
   std::size_t operator()(const boost::multiprecision::uint256_t& val)const
   {
      // create a hash from all the limbs of the argument, this function is probably x64 specific,
      // and requires that we access the internals of the data type:
      std::size_t result = CityHash64(reinterpret_cast<const char*>(val.backend().limbs()), val.backend().size() * sizeof(val.backend().limbs()[0]));
      // modify the returned hash based on sign:
      return val < 0 ? ~result : result;
   }
};

//]

void t2()
{
//[hash4

/*`As before insert some values into a container, this time using our custom hasher:*/

   std::unordered_set<uint256_t, cityhash> set2;
   for(unsigned i = 0; i < 1000; ++i)
      set2.insert(ui(mt));

//]
}

int main()
{
   t1();
   t2();
   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/hypergeometric_luke_algorithms.cpp
================================================

///////////////////////////////////////////////////////////////////////////////
// Copyright Christopher Kormanyos 2013 - 2014.
// Copyright John Maddock 2013.
// Distributed under the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
//

#include <algorithm>
#include <cstdint>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <numeric>
#include <vector>
#include <boost/math/constants/constants.hpp>
#include <boost/noncopyable.hpp>

//#define USE_CPP_BIN_FLOAT
#define USE_CPP_DEC_FLOAT
//#define USE_MPFR

#if !defined(DIGIT_COUNT)
#define DIGIT_COUNT 100
#endif

#include <chrono>

#if defined(USE_CPP_BIN_FLOAT)
  #include <boost/multiprecision/cpp_bin_float.hpp>
  typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<DIGIT_COUNT + 10> > mp_type;
#elif defined(USE_CPP_DEC_FLOAT)
  #include <boost/multiprecision/cpp_dec_float.hpp>
  typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<DIGIT_COUNT + 10> > mp_type;
#elif defined(USE_MPFR)
  #include <boost/multiprecision/mpfr.hpp>
  typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<DIGIT_COUNT + 10> > mp_type;
#else
  #error no multiprecision floating type is defined
#endif

template <class clock_type>
struct stopwatch
{
public:
  typedef typename clock_type::duration duration_type;

  stopwatch() : m_start(clock_type::now()) { }

  stopwatch(const stopwatch& other) : m_start(other.m_start) { }

  stopwatch& operator=(const stopwatch& other)
  {
    m_start = other.m_start;
    return *this;
  }

  ~stopwatch() { }

  duration_type elapsed() const
  {
    return (clock_type::now() - m_start);
  }

  void reset()
  {
    m_start = clock_type::now();
  }

private:
  typename clock_type::time_point m_start;
};

namespace my_math
{
  template<class T> T chebyshev_t(const std::int32_t n, const T& x);

  template<class T> T chebyshev_t(const std::uint32_t n, const T& x, std::vector<T>* vp);

  template<class T> bool isneg(const T& x) { return (x < T(0)); }

  template<class T> const T& zero() { static const T value_zero(0); return value_zero; }
  template<class T> const T& one () { static const T value_one (1); return value_one; }
  template<class T> const T& two () { static const T value_two (2); return value_two; }
}

namespace orthogonal_polynomial_series
{
  template<typename T> static inline T orthogonal_polynomial_template(const T& x, const std::uint32_t n, std::vector<T>* const vp = static_cast<std::vector<T>*>(0u))
  {
    // Compute the value of an orthogonal chebyshev polinomial.
    // Use stable upward recursion.

    if(vp != nullptr)
    {
      vp->clear();
      vp->reserve(static_cast<std::size_t>(n + 1u));
    }

    T y0 = my_math::one<T>();

    if(vp != nullptr) { vp->push_back(y0); }

    if(n == static_cast<std::uint32_t>(0u))
    {
      return y0;
    }

    T y1 = x;

    if(vp != nullptr) { vp->push_back(y1); }

    if(n == static_cast<std::uint32_t>(1u))
    {
      return y1;
    }

    T a = my_math::two <T>();
    T b = my_math::zero<T>();
    T c = my_math::one <T>();

    T yk;

    // Calculate higher orders using the recurrence relation.
    // The direction of stability is upward recursion.
    for(std::int32_t k = static_cast<std::int32_t>(2); k <= static_cast<std::int32_t>(n); ++k)
    {
      yk = (((a * x) + b) * y1) - (c * y0);

      y0 = y1;
      y1 = yk;

      if(vp != nullptr) { vp->push_back(yk); }
    }

    return yk;
  }
}

template<class T> T my_math::chebyshev_t(const std::int32_t n, const T& x)
{
  if(my_math::isneg(x))
  {
    const bool b_negate = ((n % static_cast<std::int32_t>(2)) != static_cast<std::int32_t>(0));

    const T y = chebyshev_t(n, -x);

    return (!b_negate ? y : -y);
  }

  if(n < static_cast<std::int32_t>(0))
  {
    const std::int32_t nn = static_cast<std::int32_t>(-n);

    return chebyshev_t(nn, x);
  }
  else
  {
    return orthogonal_polynomial_series::orthogonal_polynomial_template(x, static_cast<std::uint32_t>(n));
  }
}

template<class T> T my_math::chebyshev_t(const std::uint32_t n, const T& x, std::vector<T>* const vp) { return orthogonal_polynomial_series::orthogonal_polynomial_template(x, static_cast<std::int32_t>(n),  vp); }

namespace util
{
  template <class T> float digit_scale()
  {
    const int d = ((std::max)(std::numeric_limits<T>::digits10, 15));
    return static_cast<float>(d) / 300.0F;
  }
}

namespace examples
{
  namespace nr_006
  {
    template<typename T> class hypergeometric_pfq_base : private boost::noncopyable
    {
    public:
      virtual ~hypergeometric_pfq_base() { }

      virtual void ccoef() const = 0;

      virtual T series() const
      {
        using my_math::chebyshev_t;

        // Compute the Chebyshev coefficients.
        // Get the values of the shifted Chebyshev polynomials.
        std::vector<T> chebyshev_t_shifted_values;
        const T z_shifted = ((Z / W) * static_cast<std::int32_t>(2)) - static_cast<std::int32_t>(1);

        chebyshev_t(static_cast<std::uint32_t>(C.size()),
                    z_shifted,
                    &chebyshev_t_shifted_values);

        // Luke: C     ---------- COMPUTE SCALE FACTOR                       ----------
        // Luke: C
        // Luke: C     ---------- SCALE THE COEFFICIENTS                     ----------
        // Luke: C

        // The coefficient scaling is preformed after the Chebyshev summation,
        // and it is carried out with a single division operation.
        bool b_neg = false;

        const T scale = std::accumulate(C.begin(),
                                        C.end(),
                                        T(0),
                                        [&b_neg](T scale_sum, const T& ck) -> T
                                        {
                                          ((!b_neg) ? (scale_sum += ck) : (scale_sum -= ck));
                                          b_neg = (!b_neg);
                                          return scale_sum;
                                        });

        // Compute the result of the series expansion using unscaled coefficients.
        const T sum = std::inner_product(C.begin(),
                                         C.end(),
                                         chebyshev_t_shifted_values.begin(),
                                         T(0));

        // Return the properly scaled result.
        return sum / scale;
      }

    protected:
      const   T             Z;
      const   T             W;
      mutable std::deque<T> C;

      hypergeometric_pfq_base(const T& z,
                              const T& w) : Z(z),
                                            W(w),
                                            C(0u) { }

      virtual std::int32_t N() const { return static_cast<std::int32_t>(util::digit_scale<T>() * 500.0F); }
    };

    template<typename T> class ccoef4_hypergeometric_0f1 : public hypergeometric_pfq_base<T>
    {
    public:
      ccoef4_hypergeometric_0f1(const T& c,
                                const T& z,
                                const T& w) : hypergeometric_pfq_base<T>(z, w),
                                              CP(c) { }

      virtual ~ccoef4_hypergeometric_0f1() { }

      virtual void ccoef() const
      {
        // See Luke 1977 page 80.
        const std::int32_t N1 = static_cast<std::int32_t>(this->N() + static_cast<std::int32_t>(1));
        const std::int32_t N2 = static_cast<std::int32_t>(this->N() + static_cast<std::int32_t>(2));

        // Luke: C     ---------- START COMPUTING COEFFICIENTS USING         ----------
        // Luke: C     ---------- BACKWARD RECURRENCE SCHEME                 ----------
        // Luke: C
        T A3(0);
        T A2(0);
        T A1(boost::math::tools::root_epsilon<T>());

        hypergeometric_pfq_base<T>::C.resize(1u, A1);

        std::int32_t X1 = N2;

        T C1 = T(1) - CP;

        const T Z1 = T(4) / hypergeometric_pfq_base<T>::W;

        for(std::int32_t k = static_cast<std::int32_t>(0); k < N1; ++k)
        {
          const T DIVFAC = T(1) / X1;

          --X1;

          // The terms have been slightly re-arranged resulting in lower complexity.
          // Parentheses have been added to avoid reliance on operator precedence.
          const T term =   (A2 - ((A3 * DIVFAC) * X1))
                         + ((A2 * X1) * ((1 + (C1 + X1)) * Z1))
                         + ((A1 * X1) * ((DIVFAC - (C1 * Z1)) + (X1 * Z1)));

          hypergeometric_pfq_base<T>::C.push_front(term);

          A3 = A2;
          A2 = A1;
          A1 = hypergeometric_pfq_base<T>::C.front();
        }

        hypergeometric_pfq_base<T>::C.front() /= static_cast<std::int32_t>(2);
      }

    private:
      const T CP;
    };

    template<typename T> class ccoef1_hypergeometric_1f0 : public hypergeometric_pfq_base<T>
    {
    public:
      ccoef1_hypergeometric_1f0(const T& a,
                                const T& z,
                                const T& w) : hypergeometric_pfq_base<T>(z, w),
                                              AP(a) { }

      virtual ~ccoef1_hypergeometric_1f0() { }

      virtual void ccoef() const
      {
        // See Luke 1977 page 67.
        const std::int32_t N1 = static_cast<std::int32_t>(N() + static_cast<std::int32_t>(1));
        const std::int32_t N2 = static_cast<std::int32_t>(N() + static_cast<std::int32_t>(2));

        // Luke: C     ---------- START COMPUTING COEFFICIENTS USING         ----------
        // Luke: C     ---------- BACKWARD RECURRENCE SCHEME                 ----------
        // Luke: C
        T A2(0);
        T A1(boost::math::tools::root_epsilon<T>());

        hypergeometric_pfq_base<T>::C.resize(1u, A1);

        std::int32_t X1 = N2;

        T V1 = T(1) - AP;

        // Here, we have corrected what appears to be an error in Luke's code.

        // Luke's original code listing has:
        //  AFAC = 2 + FOUR/W
        // But it appears as though the correct form is:
        //  AFAC = 2 - FOUR/W.

        const T AFAC = 2 - (T(4) / hypergeometric_pfq_base<T>::W);

        for(std::int32_t k = static_cast<std::int32_t>(0); k < N1; ++k)
        {
          --X1;

          // The terms have been slightly re-arranged resulting in lower complexity.
          // Parentheses have been added to avoid reliance on operator precedence.
          const T term = -(((X1 * AFAC) * A1) + ((X1 + V1) * A2)) / (X1 - V1);

          hypergeometric_pfq_base<T>::C.push_front(term);

          A2 = A1;
          A1 = hypergeometric_pfq_base<T>::C.front();
        }

        hypergeometric_pfq_base<T>::C.front() /= static_cast<std::int32_t>(2);
      }

    private:
      const T AP;

      virtual std::int32_t N() const { return static_cast<std::int32_t>(util::digit_scale<T>() * 1600.0F); }
    };

    template<typename T> class ccoef3_hypergeometric_1f1 : public hypergeometric_pfq_base<T>
    {
    public:
      ccoef3_hypergeometric_1f1(const T& a,
                                const T& c,
                                const T& z,
                                const T& w) : hypergeometric_pfq_base<T>(z, w),
                                              AP(a),
                                              CP(c) { }

      virtual ~ccoef3_hypergeometric_1f1() { }

      virtual void ccoef() const
      {
        // See Luke 1977 page 74.
        const std::int32_t N1 = static_cast<std::int32_t>(this->N() + static_cast<std::int32_t>(1));
        const std::int32_t N2 = static_cast<std::int32_t>(this->N() + static_cast<std::int32_t>(2));

        // Luke: C     ---------- START COMPUTING COEFFICIENTS USING         ----------
        // Luke: C     ---------- BACKWARD RECURRENCE SCHEME                 ----------
        // Luke: C
        T A3(0);
        T A2(0);
        T A1(boost::math::tools::root_epsilon<T>());

        hypergeometric_pfq_base<T>::C.resize(1u, A1);

        std::int32_t X  = N1;
        std::int32_t X1 = N2;

        T XA  =  X + AP;
        T X3A = (X + 3) - AP;

        const T Z1 = T(4) / hypergeometric_pfq_base<T>::W;

        for(std::int32_t k = static_cast<std::int32_t>(0); k < N1; ++k)
        {
          --X;
          --X1;
          --XA;
          --X3A;

          const T X3A_over_X2 = X3A / static_cast<std::int32_t>(X + 2);

          // The terms have been slightly re-arranged resulting in lower complexity.
          // Parentheses have been added to avoid reliance on operator precedence.
          const T PART1 =  A1 * (((X + CP) * Z1) - X3A_over_X2);
          const T PART2 =  A2 * (Z1 * ((X + 3) - CP) + (XA / X1));
          const T PART3 =  A3 * X3A_over_X2;

          const T term = (((PART1 + PART2) + PART3) * X1) / XA;

          hypergeometric_pfq_base<T>::C.push_front(term);

          A3 = A2;
          A2 = A1;
          A1 = hypergeometric_pfq_base<T>::C.front();
        }

        hypergeometric_pfq_base<T>::C.front() /= static_cast<std::int32_t>(2);
      }

    private:
      const T AP;
      const T CP;
    };

    template<typename T> class ccoef6_hypergeometric_1f2 : public hypergeometric_pfq_base<T>
    {
    public:
      ccoef6_hypergeometric_1f2(const T& a,
                                const T& b,
                                const T& c,
                                const T& z,
                                const T& w) : hypergeometric_pfq_base<T>(z, w),
                                              AP(a),
                                              BP(b),
                                              CP(c) { }

      virtual ~ccoef6_hypergeometric_1f2() { }

      virtual void ccoef() const
      {
        // See Luke 1977 page 85.
        const std::int32_t N1 = static_cast<std::int32_t>(this->N() + static_cast<std::int32_t>(1));

        // Luke: C     ---------- START COMPUTING COEFFICIENTS USING         ----------
        // Luke: C     ---------- BACKWARD RECURRENCE SCHEME                 ----------
        // Luke: C
        T A4(0);
        T A3(0);
        T A2(0);
        T A1(boost::math::tools::root_epsilon<T>());

        hypergeometric_pfq_base<T>::C.resize(1u, A1);

        std::int32_t X  = N1;
        T            PP = X + AP;

        const T Z1 = T(4) / hypergeometric_pfq_base<T>::W;

        for(std::int32_t k = static_cast<std::int32_t>(0); k < N1; ++k)
        {
          --X;
          --PP;

          const std::int32_t TWO_X    = static_cast<std::int32_t>(X * 2);
          const std::int32_t X_PLUS_1 = static_cast<std::int32_t>(X + 1);
          const std::int32_t X_PLUS_3 = static_cast<std::int32_t>(X + 3);
          const std::int32_t X_PLUS_4 = static_cast<std::int32_t>(X + 4);

          const T QQ = T(TWO_X + 3) / static_cast<std::int32_t>(TWO_X + static_cast<std::int32_t>(5));
          const T SS = (X + BP) * (X + CP);

          // The terms have been slightly re-arranged resulting in lower complexity.
          // Parentheses have been added to avoid reliance on operator precedence.
          const T PART1 =   A1 * (((PP - (QQ * (PP + 1))) * 2) + (SS * Z1));
          const T PART2 =  (A2 * (X + 2)) * ((((TWO_X + 1) * PP) / X_PLUS_1) - ((QQ * 4) * (PP + 1)) + (((TWO_X + 3) * (PP + 2)) / X_PLUS_3) + ((Z1 * 2) * (SS - (QQ * (X_PLUS_1 + BP)) * (X_PLUS_1 + CP))));
          const T PART3 =   A3 * ((((X_PLUS_3 - AP) - (QQ * (X_PLUS_4 - AP))) * 2) + (((QQ * Z1) * (X_PLUS_4 - BP)) * (X_PLUS_4 - CP)));
          const T PART4 = ((A4 * QQ) * (X_PLUS_4 - AP)) / X_PLUS_3;

          const T term = (((PART1 - PART2) + (PART3 - PART4)) * X_PLUS_1) / PP;

          hypergeometric_pfq_base<T>::C.push_front(term);

          A4 = A3;
          A3 = A2;
          A2 = A1;
          A1 = hypergeometric_pfq_base<T>::C.front();
        }

        hypergeometric_pfq_base<T>::C.front() /= static_cast<std::int32_t>(2);
      }

    private:
      const T AP;
      const T BP;
      const T CP;
    };

    template<typename T> class ccoef2_hypergeometric_2f1 : public hypergeometric_pfq_base<T>
    {
    public:
      ccoef2_hypergeometric_2f1(const T& a,
                                const T& b,
                                const T& c,
                                const T& z,
                                const T& w) : hypergeometric_pfq_base<T>(z, w),
                                              AP(a),
                                              BP(b),
                                              CP(c) { }

      virtual ~ccoef2_hypergeometric_2f1() { }

      virtual void ccoef() const
      {
        // See Luke 1977 page 59.
        const std::int32_t N1 = static_cast<std::int32_t>(N() + static_cast<std::int32_t>(1));
        const std::int32_t N2 = static_cast<std::int32_t>(N() + static_cast<std::int32_t>(2));

        // Luke: C     ---------- START COMPUTING COEFFICIENTS USING         ----------
        // Luke: C     ---------- BACKWARD RECURRENCE SCHEME                 ----------
        // Luke: C
        T A3(0);
        T A2(0);
        T A1(boost::math::tools::root_epsilon<T>());

        hypergeometric_pfq_base<T>::C.resize(1u, A1);

        std::int32_t X  = N1;
        std::int32_t X1 = N2;
        std::int32_t X3 = static_cast<std::int32_t>((X * 2) + 3);

        T X3A = (X + 3) - AP;
        T X3B = (X + 3) - BP;

        const T Z1 = T(4) / hypergeometric_pfq_base<T>::W;

        for(std::int32_t k = static_cast<std::int32_t>(0); k < N1; ++k)
        {
          --X;
          --X1;
          --X3A;
          --X3B;
          X3 -= 2;

          const std::int32_t X_PLUS_2 = static_cast<std::int32_t>(X + 2);

          const T XAB = T(1) / ((X + AP) * (X + BP));

          // The terms have been slightly re-arranged resulting in lower complexity.
          // Parentheses have been added to avoid reliance on operator precedence.
          const T PART1 = (A1 * X1) * (2 - (((AP + X1) * (BP + X1)) * ((T(X3) / X_PLUS_2) * XAB)) + ((CP + X) * (XAB * Z1)));
          const T PART2 = (A2 * XAB) * ((X3A * X3B) - (X3 * ((X3A + X3B) - 1)) + (((3 - CP) + X) * (X1 * Z1)));
          const T PART3 = (A3 * X1) * (X3A / X_PLUS_2) * (X3B * XAB);

          const T term = (PART1 + PART2) - PART3;

          hypergeometric_pfq_base<T>::C.push_front(term);

          A3 = A2;
          A2 = A1;
          A1 = hypergeometric_pfq_base<T>::C.front();
        }

        hypergeometric_pfq_base<T>::C.front() /= static_cast<std::int32_t>(2);
      }

    private:
      const T AP;
      const T BP;
      const T CP;

      virtual std::int32_t N() const { return static_cast<std::int32_t>(util::digit_scale<T>() * 1600.0F); }
    };

    template<class T> T luke_ccoef4_hypergeometric_0f1(const T& a, const T& x);
    template<class T> T luke_ccoef1_hypergeometric_1f0(const T& a, const T& x);
    template<class T> T luke_ccoef3_hypergeometric_1f1(const T& a, const T& b, const T& x);
    template<class T> T luke_ccoef6_hypergeometric_1f2(const T& a, const T& b, const T& c, const T& x);
    template<class T> T luke_ccoef2_hypergeometric_2f1(const T& a, const T& b, const T& c, const T& x);
  }
}

template<class T>
T examples::nr_006::luke_ccoef4_hypergeometric_0f1(const T& a, const T& x)
{
  const ccoef4_hypergeometric_0f1<T> hypergeometric_0f1_object(a, x, T(-20));

  hypergeometric_0f1_object.ccoef();

  return hypergeometric_0f1_object.series();
}

template<class T>
T examples::nr_006::luke_ccoef1_hypergeometric_1f0(const T& a, const T& x)
{
  const ccoef1_hypergeometric_1f0<T> hypergeometric_1f0_object(a, x, T(-20));

  hypergeometric_1f0_object.ccoef();

  return hypergeometric_1f0_object.series();
}

template<class T>
T examples::nr_006::luke_ccoef3_hypergeometric_1f1(const T& a, const T& b, const T& x)
{
  const ccoef3_hypergeometric_1f1<T> hypergeometric_1f1_object(a, b, x, T(-20));

  hypergeometric_1f1_object.ccoef();

  return hypergeometric_1f1_object.series();
}

template<class T>
T examples::nr_006::luke_ccoef6_hypergeometric_1f2(const T& a, const T& b, const T& c, const T& x)
{
  const ccoef6_hypergeometric_1f2<T> hypergeometric_1f2_object(a, b, c, x, T(-20));

  hypergeometric_1f2_object.ccoef();

  return hypergeometric_1f2_object.series();
}

template<class T>
T examples::nr_006::luke_ccoef2_hypergeometric_2f1(const T& a, const T& b, const T& c, const T& x)
{
  const ccoef2_hypergeometric_2f1<T> hypergeometric_2f1_object(a, b, c, x, T(-20));

  hypergeometric_2f1_object.ccoef();

  return hypergeometric_2f1_object.series();
}

int main()
{
  stopwatch<std::chrono::high_resolution_clock> my_stopwatch;
  float total_time = 0.0F;

  std::vector<mp_type> hypergeometric_0f1_results(20U);
  std::vector<mp_type> hypergeometric_1f0_results(20U);
  std::vector<mp_type> hypergeometric_1f1_results(20U);
  std::vector<mp_type> hypergeometric_2f1_results(20U);
  std::vector<mp_type> hypergeometric_1f2_results(20U);

  const mp_type a(mp_type(3) / 7);
  const mp_type b(mp_type(2) / 3);
  const mp_type c(mp_type(1) / 4);

  std::int_least16_t i;

  std::cout << "test hypergeometric_0f1." << std::endl;
  i = 1U;
  my_stopwatch.reset();

  // Generate a table of values of Hypergeometric0F1.
  // Compare with the Mathematica command:
  // Table[N[HypergeometricPFQ[{}, {3/7}, -(i*EulerGamma)], 100], {i, 1, 20, 1}]
  std::for_each(hypergeometric_0f1_results.begin(),
                hypergeometric_0f1_results.end(),
                [&i, &a](mp_type& new_value)
                {
                  const mp_type x(-(boost::math::constants::euler<mp_type>() * i));

                  new_value = examples::nr_006::luke_ccoef4_hypergeometric_0f1(a, x);

                  ++i;
                });

  total_time += std::chrono::duration_cast<std::chrono::duration<float> >(my_stopwatch.elapsed()).count();

  // Print the values of Hypergeometric0F1.
  std::for_each(hypergeometric_0f1_results.begin(),
                hypergeometric_0f1_results.end(),
                [](const mp_type& h)
                {
                  std::cout << std::setprecision(DIGIT_COUNT) << h << std::endl;
                });

  std::cout << "test hypergeometric_1f0." << std::endl;
  i = 1U;
  my_stopwatch.reset();

  // Generate a table of values of Hypergeometric1F0.
  // Compare with the Mathematica command:
  // Table[N[HypergeometricPFQ[{3/7}, {}, -(i*EulerGamma)], 100], {i, 1, 20, 1}]
  std::for_each(hypergeometric_1f0_results.begin(),
                hypergeometric_1f0_results.end(),
                [&i, &a](mp_type& new_value)
                {
                  const mp_type x(-(boost::math::constants::euler<mp_type>() * i));

                  new_value = examples::nr_006::luke_ccoef1_hypergeometric_1f0(a, x);

                  ++i;
                });

  total_time += std::chrono::duration_cast<std::chrono::duration<float> >(my_stopwatch.elapsed()).count();

  // Print the values of Hypergeometric1F0.
  std::for_each(hypergeometric_1f0_results.begin(),
                hypergeometric_1f0_results.end(),
                [](const mp_type& h)
                {
                  std::cout << std::setprecision(DIGIT_COUNT) << h << std::endl;
                });

  std::cout << "test hypergeometric_1f1." << std::endl;
  i = 1U;
  my_stopwatch.reset();

  // Generate a table of values of Hypergeometric1F1.
  // Compare with the Mathematica command:
  // Table[N[HypergeometricPFQ[{3/7}, {2/3}, -(i*EulerGamma)], 100], {i, 1, 20, 1}]
  std::for_each(hypergeometric_1f1_results.begin(),
                hypergeometric_1f1_results.end(),
                [&i, &a, &b](mp_type& new_value)
                {
                  const mp_type x(-(boost::math::constants::euler<mp_type>() * i));

                  new_value = examples::nr_006::luke_ccoef3_hypergeometric_1f1(a, b, x);

                  ++i;
                });

  total_time += std::chrono::duration_cast<std::chrono::duration<float> >(my_stopwatch.elapsed()).count();

  // Print the values of Hypergeometric1F1.
  std::for_each(hypergeometric_1f1_results.begin(),
                hypergeometric_1f1_results.end(),
                [](const mp_type& h)
                {
                  std::cout << std::setprecision(DIGIT_COUNT) << h << std::endl;
                });

  std::cout << "test hypergeometric_1f2." << std::endl;
  i = 1U;
  my_stopwatch.reset();

  // Generate a table of values of Hypergeometric1F2.
  // Compare with the Mathematica command:
  // Table[N[HypergeometricPFQ[{3/7}, {2/3, 1/4}, -(i*EulerGamma)], 100], {i, 1, 20, 1}]
  std::for_each(hypergeometric_1f2_results.begin(),
                hypergeometric_1f2_results.end(),
                [&i, &a, &b, &c](mp_type& new_value)
                {
                  const mp_type x(-(boost::math::constants::euler<mp_type>() * i));

                  new_value = examples::nr_006::luke_ccoef6_hypergeometric_1f2(a, b, c, x);

                  ++i;
                });

  total_time += std::chrono::duration_cast<std::chrono::duration<float> >(my_stopwatch.elapsed()).count();

  // Print the values of Hypergeometric1F2.
  std::for_each(hypergeometric_1f2_results.begin(),
                hypergeometric_1f2_results.end(),
                [](const mp_type& h)
                {
                  std::cout << std::setprecision(DIGIT_COUNT) << h << std::endl;
                });

  std::cout << "test hypergeometric_2f1." << std::endl;
  i = 1U;
  my_stopwatch.reset();

  // Generate a table of values of Hypergeometric2F1.
  // Compare with the Mathematica command:
  // Table[N[HypergeometricPFQ[{3/7, 2/3}, {1/4}, -(i * EulerGamma)], 100], {i, 1, 20, 1}]
  std::for_each(hypergeometric_2f1_results.begin(),
                hypergeometric_2f1_results.end(),
                [&i, &a, &b, &c](mp_type& new_value)
                {
                  const mp_type x(-(boost::math::constants::euler<mp_type>() * i));

                  new_value = examples::nr_006::luke_ccoef2_hypergeometric_2f1(a, b, c, x);

                  ++i;
                });

  total_time += std::chrono::duration_cast<std::chrono::duration<float> >(my_stopwatch.elapsed()).count();

  // Print the values of Hypergeometric2F1.
  std::for_each(hypergeometric_2f1_results.begin(),
                hypergeometric_2f1_results.end(),
                [](const mp_type& h)
                {
                  std::cout << std::setprecision(DIGIT_COUNT) << h << std::endl;
                });

  std::cout << "Total execution time = " << std::setprecision(3) << total_time << "s" << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/integer_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
#include <iomanip>
#include <vector>

// Includes Quickbook code snippets as comments.

//[FAC1

/*`
In this simple example, we'll write a routine to print out all of the factorials
which will fit into a 128-bit integer.  At the end of the routine we do some
fancy iostream formatting of the results:
*/
/*=
#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
#include <iomanip>
#include <vector>
*/

void print_factorials()
{
   using boost::multiprecision::cpp_int;
   //
   // Print all the factorials that will fit inside a 128-bit integer.
   //
   // Begin by building a big table of factorials, once we know just how
   // large the largest is, we'll be able to "pretty format" the results.
   //
   // Calculate the largest number that will fit inside 128 bits, we could
   // also have used numeric_limits<int128_t>::max() for this value:
   cpp_int limit = (cpp_int(1) << 128) - 1;
   //
   // Our table of values:
   std::vector<cpp_int> results;
   //
   // Initial values:
   unsigned i = 1;
   cpp_int factorial = 1;
   //
   // Cycle through the factorials till we reach the limit:
   while(factorial < limit)
   {
      results.push_back(factorial);
      ++i;
      factorial *= i;
   }
   //
   // Lets see how many digits the largest factorial was:
   unsigned digits = results.back().str().size();
   //
   // Now print them out, using right justification, while we're at it
   // we'll indicate the limit of each integer type, so begin by defining
   // the limits for 16, 32, 64 etc bit integers:
   cpp_int limits[] = {
      (cpp_int(1) << 16) - 1,
      (cpp_int(1) << 32) - 1,
      (cpp_int(1) << 64) - 1,
      (cpp_int(1) << 128) - 1,
   };
   std::string bit_counts[] = { "16", "32", "64", "128" };
   unsigned current_limit = 0;
   for(unsigned j = 0; j < results.size(); ++j)
   {
      if(limits[current_limit] < results[j])
      {
         std::string message = "Limit of " + bit_counts[current_limit] + " bit integers";
         std::cout << std::setfill('.') << std::setw(digits+1) << std::right << message << std::setfill(' ') << std::endl;
         ++current_limit;
      }
      std::cout << std::setw(digits + 1) << std::right << results[j] << std::endl;
   }
}

/*`
The output from this routine is:
[pre
                                       1
                                       2
                                       6
                                      24
                                     120
                                     720
                                    5040
                                   40320
................Limit of 16 bit integers
                                  362880
                                 3628800
                                39916800
                               479001600
................Limit of 32 bit integers
                              6227020800
                             87178291200
                           1307674368000
                          20922789888000
                         355687428096000
                        6402373705728000
                      121645100408832000
                     2432902008176640000
................Limit of 64 bit integers
                    51090942171709440000
                  1124000727777607680000
                 25852016738884976640000
                620448401733239439360000
              15511210043330985984000000
             403291461126605635584000000
           10888869450418352160768000000
          304888344611713860501504000000
         8841761993739701954543616000000
       265252859812191058636308480000000
      8222838654177922817725562880000000
    263130836933693530167218012160000000
   8683317618811886495518194401280000000
 295232799039604140847618609643520000000
]
*/

//]

//[BITOPS

/*`
In this example we'll show how individual bits within an integer may be manipulated,
we'll start with an often needed calculation of ['2[super n] - 1], which we could obviously
implement like this:
*/

using boost::multiprecision::cpp_int;

cpp_int b1(unsigned n)
{
   cpp_int r(1);
   return (r << n) - 1;
}

/*`
Calling:

   std::cout << std::hex << std::showbase << b1(200) << std::endl;

Yields as expected:

[pre 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF]

However, we could equally just set the n'th bit in the result, like this:
*/

cpp_int b2(unsigned n)
{
   cpp_int r(0);
   return --bit_set(r, n);
}

/*`
Note how the `bit_set` function sets the specified bit in its argument and then returns a reference to the result -
which we can then simply decrement.  The result from a call to `b2` is the same as that to `b1`.

We can equally test bits, so for example the n'th bit of the result returned from `b2` shouldn't be set
unless we increment it first:

   BOOST_MP_ASSERT(!bit_test(b1(200), 200));     // OK
   BOOST_MP_ASSERT(bit_test(++b1(200), 200));    // OK

And of course if we flip the n'th bit after increment, then we should get back to zero:

   BOOST_MP_ASSERT(!bit_flip(++b1(200), 200));   // OK
*/

//]

int main()
{
   print_factorials();

   std::cout << std::hex << std::showbase << b1(200) << std::endl;
   std::cout << std::hex << std::showbase << b2(200) << std::endl;
   BOOST_MP_ASSERT(!bit_test(b1(200), 200));  // OK
   BOOST_MP_ASSERT(bit_test(++b1(200), 200));    // OK
   BOOST_MP_ASSERT(!bit_flip(++b1(200), 200));   // OK
   return 0;
}

/*

Program output:

                                       1
                                       2
                                       6
                                      24
                                     120
                                     720
                                    5040
                                   40320
................Limit of 16 bit integers
                                  362880
                                 3628800
                                39916800
                               479001600
................Limit of 32 bit integers
                              6227020800
                             87178291200
                           1307674368000
                          20922789888000
                         355687428096000
                        6402373705728000
                      121645100408832000
                     2432902008176640000
................Limit of 64 bit integers
                    51090942171709440000
                  1124000727777607680000
                 25852016738884976640000
                620448401733239439360000
              15511210043330985984000000
             403291461126605635584000000
           10888869450418352160768000000
          304888344611713860501504000000
         8841761993739701954543616000000
       265252859812191058636308480000000
      8222838654177922817725562880000000
    263130836933693530167218012160000000
   8683317618811886495518194401280000000
 295232799039604140847618609643520000000
 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
 */


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/logged_adaptor.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[logged_adaptor

#include <boost/multiprecision/mpfi.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>
#include <iostream>
#include <iomanip>
//
// Begin by overloading log_postfix_event so we can capture each arithmetic event as it happens:
//
namespace boost{ namespace multiprecision{

template <unsigned D>
inline void log_postfix_event(const mpfi_float_backend<D>& val, const char* event_description)
{
   // Print out the (relative) diameter of the interval:
   using namespace boost::multiprecision;
   number<mpfr_float_backend<D> > diam;
   mpfi_diam(diam.backend().data(), val.data());
   std::cout << "Diameter was " << diam << " after operation: " << event_description << std::endl;
}
template <unsigned D, class T>
inline void log_postfix_event(const mpfi_float_backend<D>&, const T&, const char* event_description)
{
   // This version is never called in this example.
}

}}


int main()
{
   using namespace boost::multiprecision;
   typedef number<logged_adaptor<mpfi_float_backend<17> > > logged_type;
   //
   // Test case deliberately introduces cancellation error, relative size of interval
   // gradually gets larger after each operation:
   //
   logged_type a = 1;
   a /= 10;

   for(unsigned i = 0; i < 13; ++i)
   {
      logged_type b = a * 9;
      b /= 10;
      a -= b;
   }
   std::cout << "Final value was: " << a << std::endl;
   return 0;
}

//]

/*
//[logged_adaptor_output

Diameter was nan after operation: Default construct
Diameter was 0 after operation: Assignment from arithmetic type
Diameter was 4.33681e-18 after operation: /=
Diameter was nan after operation: Default construct
Diameter was 7.70988e-18 after operation: *
Diameter was 9.63735e-18 after operation: /=
Diameter was 1.30104e-16 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 1.30104e-16 after operation: *
Diameter was 1.38537e-16 after operation: /=
Diameter was 2.54788e-15 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 2.54788e-15 after operation: *
Diameter was 2.54863e-15 after operation: /=
Diameter was 4.84164e-14 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 4.84164e-14 after operation: *
Diameter was 4.84221e-14 after operation: /=
Diameter was 9.19962e-13 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 9.19962e-13 after operation: *
Diameter was 9.19966e-13 after operation: /=
Diameter was 1.74793e-11 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 1.74793e-11 after operation: *
Diameter was 1.74793e-11 after operation: /=
Diameter was 3.32107e-10 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 3.32107e-10 after operation: *
Diameter was 3.32107e-10 after operation: /=
Diameter was 6.31003e-09 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 6.31003e-09 after operation: *
Diameter was 6.31003e-09 after operation: /=
Diameter was 1.19891e-07 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 1.19891e-07 after operation: *
Diameter was 1.19891e-07 after operation: /=
Diameter was 2.27792e-06 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 2.27792e-06 after operation: *
Diameter was 2.27792e-06 after operation: /=
Diameter was 4.32805e-05 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 4.32805e-05 after operation: *
Diameter was 4.32805e-05 after operation: /=
Diameter was 0.00082233 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 0.00082233 after operation: *
Diameter was 0.00082233 after operation: /=
Diameter was 0.0156243 after operation: -=
Diameter was nan after operation: Default construct
Diameter was 0.0156243 after operation: *
Diameter was 0.0156243 after operation: /=
Diameter was 0.296861 after operation: -=
Final value was: {8.51569e-15,1.14843e-14}

//]
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/mixed_integer_arithmetic.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#  define _SCL_SECURE_NO_WARNINGS
#endif

//[mixed_eg
#include <boost/multiprecision/cpp_int.hpp>

int main()
{
   using namespace boost::multiprecision;

   std::uint64_t i = (std::numeric_limits<std::uint64_t>::max)();
   std::uint64_t j = 1;

   uint128_t ui128;
   uint256_t ui256;
   //
   // Start by performing arithmetic on 64-bit integers to yield 128-bit results:
   //
   std::cout << std::hex << std::showbase << i << std::endl;
   std::cout << std::hex << std::showbase << add(ui128, i, j) << std::endl;
   std::cout << std::hex << std::showbase << multiply(ui128, i, i) << std::endl;
   //
   // The try squaring a 128-bit integer to yield a 256-bit result:
   //
   ui128 = (std::numeric_limits<uint128_t>::max)();
   std::cout << std::hex << std::showbase << multiply(ui256, ui128, ui128) << std::endl;

   return 0;
}
//]

/* 

Program output:

//[mixed_output

0xffffffffffffffff
0x10000000000000000
0xFFFFFFFFFFFFFFFE0000000000000001
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000000000000000000000000000001

//]
*/



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/mpc_examples.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 Nick Thompson. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

/*`This example demonstrates the usage of the MPC backend for multiprecision complex numbers.
In the following, we will show how using MPC backend allows for the same operations as the C++ standard library complex numbers.
*/

//[mpc_eg
#include <iostream>
#include <complex>
#include <boost/multiprecision/mpc.hpp>

template<class Complex>
void complex_number_examples()
{
    Complex z1{0, 1};
    std::cout << std::setprecision(std::numeric_limits<typename Complex::value_type>::digits10);
    std::cout << std::scientific << std::fixed;
    std::cout << "Print a complex number: " << z1 << std::endl;
    std::cout << "Square it             : " << z1*z1 << std::endl;
    std::cout << "Real part             : " << z1.real() << " = " << real(z1) << std::endl;
    std::cout << "Imaginary part        : " << z1.imag() << " = " << imag(z1) << std::endl;
    using std::abs;
    std::cout << "Absolute value        : " << abs(z1) << std::endl;
    std::cout << "Argument              : " << arg(z1) << std::endl;
    std::cout << "Norm                  : " << norm(z1) << std::endl;
    std::cout << "Complex conjugate     : " << conj(z1) << std::endl;
    std::cout << "Projection onto Riemann sphere: " <<  proj(z1) << std::endl;
    typename Complex::value_type r = 1;
    typename Complex::value_type theta = 0.8;
    using std::polar;
    std::cout << "Polar coordinates (phase = 0)    : " << polar(r) << std::endl;
    std::cout << "Polar coordinates (phase !=0)    : " << polar(r, theta) << std::endl;

    std::cout << "\nElementary special functions:\n";
    using std::exp;
    std::cout << "exp(z1) = " << exp(z1) << std::endl;
    using std::log;
    std::cout << "log(z1) = " << log(z1) << std::endl;
    using std::log10;
    std::cout << "log10(z1) = " << log10(z1) << std::endl;
    using std::pow;
    std::cout << "pow(z1, z1) = " << pow(z1, z1) << std::endl;
    using std::sqrt;
    std::cout << "Take its square root  : " << sqrt(z1) << std::endl;
    using std::sin;
    std::cout << "sin(z1) = " << sin(z1) << std::endl;
    using std::cos;
    std::cout << "cos(z1) = " << cos(z1) << std::endl;
    using std::tan;
    std::cout << "tan(z1) = " << tan(z1) << std::endl;
    using std::asin;
    std::cout << "asin(z1) = " << asin(z1) << std::endl;
    using std::acos;
    std::cout << "acos(z1) = " << acos(z1) << std::endl;
    using std::atan;
    std::cout << "atan(z1) = " << atan(z1) << std::endl;
    using std::sinh;
    std::cout << "sinh(z1) = " << sinh(z1) << std::endl;
    using std::cosh;
    std::cout << "cosh(z1) = " << cosh(z1) << std::endl;
    using std::tanh;
    std::cout << "tanh(z1) = " << tanh(z1) << std::endl;
    using std::asinh;
    std::cout << "asinh(z1) = " << asinh(z1) << std::endl;
    using std::acosh;
    std::cout << "acosh(z1) = " << acosh(z1) << std::endl;
    using std::atanh;
    std::cout << "atanh(z1) = " << atanh(z1) << std::endl;
}

int main()
{
    std::cout << "First, some operations we usually perform with std::complex:\n";
    complex_number_examples<std::complex<double>>();
    std::cout << "\nNow the same operations performed using the MPC backend:\n";
    complex_number_examples<boost::multiprecision::mpc_complex_50>();

    return 0;
}
//]

/*

//[mpc_out

Print a complex number: (0.00000000000000000000000000000000000000000000000000,1.00000000000000000000000000000000000000000000000000)
Square it             : -1.00000000000000000000000000000000000000000000000000
Real part             : 0.00000000000000000000000000000000000000000000000000 = 0.00000000000000000000000000000000000000000000000000
Imaginary part        : 1.00000000000000000000000000000000000000000000000000 = 1.00000000000000000000000000000000000000000000000000
Absolute value        : 1.00000000000000000000000000000000000000000000000000
Argument              : 1.57079632679489661923132169163975144209858469968755
Norm                  : 1.00000000000000000000000000000000000000000000000000
Complex conjugate     : (0.00000000000000000000000000000000000000000000000000,-1.00000000000000000000000000000000000000000000000000)
Projection onto Riemann sphere: (0.00000000000000000000000000000000000000000000000000,1.00000000000000000000000000000000000000000000000000)
Polar coordinates (phase = 0)    : 1.00000000000000000000000000000000000000000000000000
Polar coordinates (phase !=0)    : (0.69670670934716538906374002277244853473117519431538,0.71735609089952279256716781570337728075604730751255)

Elementary special functions:
exp(z1) = (0.54030230586813971740093660744297660373231042061792,0.84147098480789650665250232163029899962256306079837)
log(z1) = (0.00000000000000000000000000000000000000000000000000,1.57079632679489661923132169163975144209858469968755)
log10(z1) = (0.00000000000000000000000000000000000000000000000000,0.68218817692092067374289181271567788510506374186196)
pow(z1, z1) = 0.20787957635076190854695561983497877003387784163177
Take its square root  : (0.70710678118654752440084436210484903928483593768847,0.70710678118654752440084436210484903928483593768847)
sin(z1) = (0.00000000000000000000000000000000000000000000000000,1.17520119364380145688238185059560081515571798133410)
cos(z1) = 1.54308063481524377847790562075706168260152911236587
tan(z1) = (0.00000000000000000000000000000000000000000000000000,0.76159415595576488811945828260479359041276859725794)
asin(z1) = (0.00000000000000000000000000000000000000000000000000,0.88137358701954302523260932497979230902816032826163)
acos(z1) = (1.57079632679489661923132169163975144209858469968755,-0.88137358701954302523260932497979230902816032826163)
atan(z1) = (0.00000000000000000000000000000000000000000000000000,inf)
sinh(z1) = (0.00000000000000000000000000000000000000000000000000,0.84147098480789650665250232163029899962256306079837)
cosh(z1) = 0.54030230586813971740093660744297660373231042061792
tanh(z1) = (0.00000000000000000000000000000000000000000000000000,1.55740772465490223050697480745836017308725077238152)
asinh(z1) = (0.00000000000000000000000000000000000000000000000000,1.57079632679489661923132169163975144209858469968755)
acosh(z1) = (0.88137358701954302523260932497979230902816032826163,1.57079632679489661923132169163975144209858469968755)
atanh(z1) = (0.00000000000000000000000000000000000000000000000000,0.78539816339744830961566084581987572104929234984378)

//]
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/mpfi_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[mpfi_eg
#include <boost/multiprecision/mpfi.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

int main()
{
   using namespace boost::multiprecision;

   // Operations at variable precision and no numeric_limits support:
   mpfi_float a = 2;
   mpfi_float::default_precision(1000);
   std::cout << mpfi_float::default_precision() << std::endl;
   std::cout << sqrt(a) << std::endl; // print root-2

   // Operations at fixed precision and full numeric_limits support:
   mpfi_float_100 b = 2;
   std::cout << std::numeric_limits<mpfi_float_100>::digits << std::endl;
   // We can use any C++ std lib function:
   std::cout << log(b) << std::endl; // print log(2)

   // Access the underlying data:
   mpfi_t r;
   mpfi_init(r);
   mpfi_set(r, b.backend().data());

   // Construct some explicit intervals and perform set operations:
   mpfi_float_50 i1(1, 2), i2(1.5, 2.5);
   std::cout << intersect(i1, i2) << std::endl;
   std::cout << hull(i1, i2) << std::endl;
   std::cout << overlap(i1, i2) << std::endl;
   std::cout << subset(i1, i2) << std::endl;
   mpfi_clear(r);
   return 0;
}
//]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/mpfr_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[mpfr_variable

/*`
This example illustrates the use of variable-precision arithmetic with
the `mpfr_float` number type.  We'll calculate the median of the
beta distribution to an absurdly high precision and compare the
accuracy and times taken for various methods.  That is, we want
to calculate the value of `x` for which ['I[sub x](a, b) = 0.5].

Ultimately we'll use Newtons method and set the precision of
mpfr_float to have just enough digits at each iteration.

The full source of the this program is in [@../../example/mpfr_precision.cpp]

We'll skip over the #includes and using declations, and go straight to
some support code, first off a simple stopwatch for performance measurement:

*/

//=template <class clock_type>
//=struct stopwatch { /*details \*/ };

/*`
We'll use `stopwatch<std::chono::high_resolution_clock>` as our performance measuring device.

We also have a small utility class for controlling the current precision of mpfr_float:

   struct scoped_precision
   {
      unsigned p;
      scoped_precision(unsigned new_p) : p(mpfr_float::default_precision())
      {
         mpfr_float::default_precision(new_p);
      }
      ~scoped_precision()
      {
         mpfr_float::default_precision(p);
      }
   };

*/
//<-
#include <boost/multiprecision/mpfr.hpp>
#include <boost/math/special_functions/beta.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <iostream>
#include <chrono>

using boost::multiprecision::mpfr_float;
using boost::math::ibeta_inv;
using namespace boost::math::policies;

template <class clock_type>
struct stopwatch
{
public:
   typedef typename clock_type::duration duration_type;

   stopwatch() : m_start(clock_type::now()) { }

   stopwatch(const stopwatch& other) : m_start(other.m_start) { }

   stopwatch& operator=(const stopwatch& other)
   {
      m_start = other.m_start;
      return *this;
   }

   ~stopwatch() { }

   float elapsed() const
   {
      return float(std::chrono::nanoseconds((clock_type::now() - m_start)).count()) / 1e9f;
   }

   void reset()
   {
      m_start = clock_type::now();
   }

private:
   typename clock_type::time_point m_start;
};

struct scoped_precision
{
   unsigned p;
   scoped_precision(unsigned new_p) : p(mpfr_float::default_precision())
   {
      mpfr_float::default_precision(new_p);
   }
   ~scoped_precision()
   {
      mpfr_float::default_precision(p);
   }
};
//->

/*`
We'll begin with a reference method that simply calls the Boost.Math function `ibeta_inv` and uses the
full working precision of the arguments throughout.  Our reference function takes 3 arguments:

* The 2 parameters `a` and `b` of the beta distribution, and
* The number of decimal digits precision to achieve in the result.

We begin by setting the default working precision to that requested, and then, since we don't know where
our arguments `a` and `b` have been or what precision they have, we make a copy of them - note that since
copying also copies the precision as well as the value, we have to set the precision expicitly with a
second argument to the copy.  Then we can simply return the result of `ibeta_inv`:
*/
mpfr_float beta_distribution_median_method_1(mpfr_float const& a_, mpfr_float const& b_, unsigned digits10)
{
   scoped_precision sp(digits10);
   mpfr_float half(0.5), a(a_, digits10), b(b_, digits10);
   return ibeta_inv(a, b, half);
}
/*`
You be wondering why we needed to change the precision of our variables `a` and `b` as well as setting the default -
there are in fact two ways in which this can go wrong if we don't do that:

* The variables have too much precision - this will cause all arithmetic operations involving those types to be
promoted to the higher precision wasting precious calculation time.
* The variables have too little precision - this will cause expressions involving only those variables to be
calculated at the lower precision - for example if we calculate `exp(a)` internally, this will be evaluated at
the precision of `a`, and not the current default.

Since our reference method carries out all calculations at the full precision requested, an obvious refinement
would be to calculate a first approximation to `double` precision and then to use Newton steps to refine it further.

Our function begins the same as before: set the new default precision and then make copies of our arguments
at the correct precision.  We then call `ibeta_inv` with all double precision arguments, promote the result
to an `mpfr_float` and perform Newton steps to obtain the result.  Note that our termination condition is somewhat
crude: we simply assume that we have approximately 14 digits correct from the double-precision approximation and
that the precision doubles with each step.  We also cheat, and use an internal Boost.Math function that calculates
['I[sub x](a, b)] and its derivative in one go:

*/
mpfr_float beta_distribution_median_method_2(mpfr_float const& a_, mpfr_float const& b_, unsigned digits10)
{
   scoped_precision sp(digits10);
   mpfr_float half(0.5), a(a_, digits10), b(b_, digits10);
   mpfr_float guess = ibeta_inv((double)a, (double)b, 0.5);
   unsigned current_digits = 14;
   mpfr_float f, f1;
   while (current_digits < digits10)
   {
      f = boost::math::detail::ibeta_imp(a, b, guess, boost::math::policies::policy<>(), false, true, &f1) - half;
      guess -= f / f1;
      current_digits *= 2;
   }
   return guess;
}
/*`
Before we refine the method further, it might be wise to take stock and see how methods 1 and 2 compare.
We'll ask them both for 1500 digit precision, and compare against the value produced by `ibeta_inv` at 1700 digits.
Here's what the results look like:

[pre
Method 1 time = 0.611647
Relative error: 2.99991e-1501
Method 2 time = 0.646746
Relative error: 7.55843e-1501
]

Clearly they are both equally accurate, but Method 1 is actually faster and our plan for improved performance
hasn't actually worked.  It turns out that we're not actually comparing like with like, because `ibeta_inv` uses
Halley iteration internally which churns out more digits of precision rather more rapidly than Newton iteration.
So the time we save by refining an initial `double` approximation, then loose it again by taking more iterations
to get to the result.

Time for a more refined approach.  It follows the same form as Method 2, but now we set the working precision
within the Newton iteration loop, to just enough digits to cover the expected precision at each step.  That means
we also create new copies of our arguments at the correct precision within the loop, and likewise change the precision
of the current `guess` each time through:

*/

mpfr_float beta_distribution_median_method_3(mpfr_float const& a_, mpfr_float const& b_, unsigned digits10)
{
   mpfr_float guess = ibeta_inv((double)a_, (double)b_, 0.5);
   unsigned current_digits = 14;
   mpfr_float f(0, current_digits), f1(0, current_digits), delta(1);
   while (current_digits < digits10)
   {
      current_digits *= 2;
      scoped_precision sp((std::min)(current_digits, digits10));
      mpfr_float a(a_, mpfr_float::default_precision()), b(b_, mpfr_float::default_precision());
      guess.precision(mpfr_float::default_precision());
      f = boost::math::detail::ibeta_imp(a, b, guess, boost::math::policies::policy<>(), false, true, &f1) - 0.5f;
      guess -= f / f1;
   }
   return guess;
}

/*`
The new performance results look much more promising:

[pre
Method 1 time = 0.591244
Relative error: 2.99991e-1501
Method 2 time = 0.622679
Relative error: 7.55843e-1501
Method 3 time = 0.143393
Relative error: 4.03898e-1501
]

This time we're 4x faster than `ibeta_inv`, and no doubt that could be improved a little more by carefully
optimising the number of iterations and the method (Halley vs Newton) taken.

Finally, here's the driver code for the above methods:

*/

int main()
{
   try {
      mpfr_float a(10), b(20);

      mpfr_float true_value = beta_distribution_median_method_1(a, b, 1700);

      stopwatch<std::chrono::high_resolution_clock> my_stopwatch;

      mpfr_float v1 = beta_distribution_median_method_1(a, b, 1500);
      float hp_time = my_stopwatch.elapsed();
      std::cout << "Method 1 time = " << hp_time << std::endl;
      std::cout << "Relative error: " << boost::math::relative_difference(v1, true_value) << std::endl;

      my_stopwatch.reset();
      mpfr_float v2 = beta_distribution_median_method_2(a, b, 1500);
      hp_time = my_stopwatch.elapsed();
      std::cout << "Method 2 time = " << hp_time << std::endl;
      std::cout << "Relative error: " << boost::math::relative_difference(v2, true_value) << std::endl;

      my_stopwatch.reset();
      mpfr_float v3 = beta_distribution_median_method_3(a, b, 1500);
      hp_time = my_stopwatch.elapsed();
      std::cout << "Method 3 time = " << hp_time << std::endl;
      std::cout << "Relative error: " << boost::math::relative_difference(v3, true_value) << std::endl;
   }
   catch (const std::exception& e)
   {
      std::cout << "Found exception with message: " << e.what() << std::endl;
   }
   return 0;
}
//] //[/mpfr_variable]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/mpfr_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[mpfr_eg
#include <boost/multiprecision/mpfr.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

int main()
{
   using namespace boost::multiprecision;

   // Operations at variable precision and no numeric_limits support:
   mpfr_float a = 2;
   mpfr_float::default_precision(1000);
   std::cout << mpfr_float::default_precision() << std::endl;
   std::cout << sqrt(a) << std::endl; // print root-2

   // Operations at fixed precision and full numeric_limits support:
   mpfr_float_100 b = 2;
   std::cout << std::numeric_limits<mpfr_float_100>::digits << std::endl;
   // We can use any C++ std lib function:
   std::cout << log(b) << std::endl; // print log(2)
   // We can also use any function from Boost.Math:
   std::cout << boost::math::tgamma(b) << std::endl;
   // These even work when the argument is an expression template:
   std::cout << boost::math::tgamma(b * b) << std::endl;

   // Access the underlying data:
   mpfr_t r;
   mpfr_init(r);
   mpfr_set(r, b.backend().data(), GMP_RNDN);
   mpfr_clear(r);
   return 0;
}
//]




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/numeric_limits_snips.cpp
================================================
// Copyright Paul A. Bristow 2013
// Copyright John Maddock 2013
// Copyright Christopher Kormanyos

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

// Examples of std::numeric_limits usage as snippets for multiprecision documentation at multiprecision.qbk.

// Includes text as Quickbook comments.

#include <boost/assert.hpp>

#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/nonfinite_num_facets.hpp>

#include <boost/math/special_functions/factorials.hpp>
#include <boost/math/special_functions/next.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp> // is decimal.
#include <boost/multiprecision/cpp_bin_float.hpp> // is binary.

#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp> // Boost.Test
#include <boost/test/tools/floating_point_comparison.hpp>

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <limits> // numeric_limits
#include <iomanip>
#include <locale>

// static long double const log10Two = 0.30102999566398119521373889472449L; // log10(2.)
// It is more portable useful to use a Boost macro
// See https://www.boost.org/doc/libs/release/libs/config/doc/html/boost_config/boost_macro_reference.html
static constexpr long double log10Two = 0.30102999566398119521373889472449L;
// which expands to static constexpr on standard C++11 and up, but static const on earlier versions.

  /*`By default, output would only show the standard 6 decimal digits,
 so set precision to show all 50 significant digits, including any trailing zeros.
 This is generally useful to show the implicit precision of the type of the value.
*/




template <typename T>
int max_digits10()
{
   int significand_digits = std::numeric_limits<T>::digits;
  // constexpr int significand_digits = std::numeric_limits<T>::digits;
   return static_cast<int>(ceil(1 + significand_digits * log10Two));
} // template <typename T> int max_digits10()

// Used to test max_digits10<>() function below.

BOOST_AUTO_TEST_CASE(test_numeric_limits_snips)
{
#if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(BOOST_MSVC) && (BOOST_MSVC == 1600))
  try
  {

// Example of portable way to get `std::numeric_limits<T>::max_digits10`.
//[max_digits10_1

/*`For example, to be portable (including obselete platforms) for type `T` where `T` may be:
 `float`, `double`, `long double`, `128-bit quad type`, `cpp_bin_float_50` ...
*/

  typedef float T;

  std::cout.precision(std::numeric_limits<T>::max_digits10);
  std::cout.precision(std::numeric_limits<T>::digits10);
  std::cout.setf(std::ios_base::showpoint); // Append any trailing zeros,
  // or more memorably
  std::cout << std::showpoint << std::endl; //

  std::cout << "std::cout.precision(max_digits10) = " << std::cout.precision() << std::endl; // 9

  double x = 1.2345678901234567889;

  std::cout << "x = " << x << std::endl; //

/*`which should output:

  std::cout.precision(max_digits10) = 9
  x = 1.23456789
*/

//] [/max_digits10_1]

  {
//[max_digits10_2

  double write = 2./3; // Any arbitrary value that cannot be represented exactly.
  double read = 0;
  std::stringstream s;
  s.precision(std::numeric_limits<double>::digits10); // or `float64_t` for 64-bit IEE754 double.
  s << write;
  s >> read;
  if(read != write)
  {
    std::cout <<  std::setprecision(std::numeric_limits<double>::digits10)
      << read << " != " << write << std::endl;
  }

//] [/max_digits10_2]
  // 0.666666666666667 != 0.666666666666667
  }

  {
//[max_digits10_3

  double pi = boost::math::double_constants::pi;
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  std::cout << pi << std::endl; // 3.1415926535897931

//] [/max_digits10_3]
  }
  {
//[max_digits10_4
/*`and similarly for a much higher precision type:
*/

  using namespace boost::multiprecision;

  typedef number<cpp_dec_float<50> > cpp_dec_float_50; // 50 decimal digits.

  // or using boost::multiprecision::cpp_dec_float_50;

  cpp_dec_float_50 pi = boost::math::constants::pi<cpp_dec_float_50>();
  std::cout.precision(std::numeric_limits<cpp_dec_float_50>::max_digits10);
  std::cout << pi << std::endl;
  // 3.141592653589793238462643383279502884197169399375105820974944592307816406
//] [/max_digits10_4]
  }

  {
//[max_digits10_5

  for (int i = 2; i < 15; i++)
  {
    std::cout << std::setw(std::numeric_limits<int>::max_digits10)
      << boost::math::factorial<double>(i)  << std::endl;
  }

//] [/max_digits10_5]
  }

  }
  catch(const std::exception& ex)
  {
    std::cout << "Caught Exception " << ex.what() << std::endl;
  }

  {
//[max_digits10_6

  typedef double T;

  bool denorm = std::numeric_limits<T>::denorm_min() < (std::numeric_limits<T>::min)();
  BOOST_MP_ASSERT(denorm);

//] [/max_digits10_6]
  }

  {
    unsigned char c = 255;
    std::cout << "char c = " << (int)c << std::endl;
  }

  {
//[digits10_1
    std::cout
      << std::setw(std::numeric_limits<short>::digits10 +1 +1) // digits10+1, and +1 for sign.
      << std::showpos << (std::numeric_limits<short>::max)() // +32767
      << std::endl
      << std::setw(std::numeric_limits<short>::digits10 +1 +1)
      << (std::numeric_limits<short>::min)() << std::endl;   // -32767
//] [/digits10_1]
  }

  {
//[digits10_2
    std::cout
      << std::setw(std::numeric_limits<unsigned short>::digits10 +1 +1) // digits10+1, and +1 for sign.
      << std::showpos << (std::numeric_limits<unsigned short>::max)() //  65535
      << std::endl
      << std::setw(std::numeric_limits<unsigned short>::digits10 +1 +1) // digits10+1, and +1 for sign.
      << (std::numeric_limits<unsigned short>::min)() << std::endl;   //      0
//] [/digits10_2]
  }

  std::cout <<std::noshowpos << std::endl;

  {
//[digits10_3
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  double d =  1e15;
  double dp1 = d+1;
  std::cout << d << "\n" << dp1 << std::endl;
  // 1000000000000000
  // 1000000000000001
  std::cout <<  dp1 - d << std::endl; // 1
//] [/digits10_3]
  }

  {
//[digits10_4
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  double d =  1e16;
  double dp1 = d+1;
  std::cout << d << "\n" << dp1 << std::endl;
  // 10000000000000000
  // 10000000000000000
    std::cout << dp1 - d << std::endl; // 0 !!!
//] [/digits10_4]
  }

  {
//[epsilon_1
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  double d = 1.;
  double eps = std::numeric_limits<double>::epsilon();
  double dpeps = d+eps;
  std::cout << std::showpoint // Ensure all trailing zeros are shown.
    << d << "\n"           // 1.0000000000000000
    << dpeps << std::endl; // 2.2204460492503131e-016
  std::cout << dpeps - d   // 1.0000000000000002
    << std::endl;
//] [epsilon_1]
  }

  {
//[epsilon_2
  double one = 1.;
  double nad = boost::math::float_next(one);
  std::cout << nad << "\n"  //  1.0000000000000002
    << nad - one // 2.2204460492503131e-016
    << std::endl;
//] [epsilon_2]
  }
  {
//[epsilon_3
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  double d = 1.;
  double eps = std::numeric_limits<double>::epsilon();
  double dpeps = d + eps/2;

  std::cout << std::showpoint // Ensure all trailing zeros are shown.
    << dpeps << "\n"       // 1.0000000000000000
    << eps/2 << std::endl; // 1.1102230246251565e-016
  std::cout << dpeps - d   // 0.00000000000000000
    << std::endl;
//] [epsilon_3]
  }

  {
    typedef double RealType;
//[epsilon_4
/*`A tolerance might be defined using this version of epsilon thus:
*/
    RealType tolerance = boost::math::tools::epsilon<RealType>() * 2;
//] [epsilon_4]
    (void)tolerance; // warning suppression
  }

  {
    bool b =
//[digits10_5
    -(std::numeric_limits<double>::max)() == std::numeric_limits<double>::lowest();
//] [/digits10_5]
    (void)b;  // warning suppression
  }

  {
//[denorm_min_1
  std::cout.precision(std::numeric_limits<double>::max_digits10);
  if (std::numeric_limits<double>::has_denorm == std::denorm_present)
  {
    double d = std::numeric_limits<double>::denorm_min();

      std::cout << d << std::endl; //  4.9406564584124654e-324

      int exponent;

      double significand = frexp(d, &exponent);
      std::cout << "exponent = " << std::hex << exponent << std::endl; //  fffffbcf
      std::cout << "significand = " << std::hex << significand << std::endl; // 0.50000000000000000
  }
  else
  {
    std::cout << "No denormalization. " << std::endl;
  }
//] [denorm_min_1]
  }

  {
//[round_error_1
    double round_err = std::numeric_limits<double>::epsilon() // 2.2204460492503131e-016
                     * std::numeric_limits<double>::round_error(); // 1/2
    std::cout << round_err << std::endl; // 1.1102230246251565e-016
//] [/round_error_1]
  }

  {
    typedef double T;
//[tolerance_1
/*`For example, if we want a tolerance that might suit about 9 arithmetical operations,
say sqrt(9) = 3,  we could define:
*/

    T tolerance =  3 * std::numeric_limits<T>::epsilon();

/*`This is very widely used in Boost.Math testing
with Boost.Test's macro `BOOST_CHECK_CLOSE_FRACTION`
*/

    T expected = 1.0;
    T calculated = 1.0 + std::numeric_limits<T>::epsilon();

    BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);

//] [/tolerance_1]
  }

#if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__GNUC__) && defined(_WIN32))
  {
//[tolerance_2

  using boost::multiprecision::number;
  using boost::multiprecision::cpp_dec_float;
  using boost::multiprecision::et_off;

  typedef number<cpp_dec_float<50>, et_off > cpp_dec_float_50; // 50 decimal digits.
/*`[note that Boost.Test does not yet allow floating-point comparisons with expression templates on,
so the default expression template parameter has been replaced by `et_off`.]
*/

  cpp_dec_float_50 tolerance =  3 * std::numeric_limits<cpp_dec_float_50>::epsilon();
  cpp_dec_float_50 expected = boost::math::constants::two_pi<cpp_dec_float_50>();
  cpp_dec_float_50 calculated = 2 * boost::math::constants::pi<cpp_dec_float_50>();

  BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);

//] [/tolerance_2]
  }

  {
//[tolerance_3

  using boost::multiprecision::cpp_bin_float_quad;

  cpp_bin_float_quad tolerance =  3 * std::numeric_limits<cpp_bin_float_quad>::epsilon();
  cpp_bin_float_quad expected = boost::math::constants::two_pi<cpp_bin_float_quad>();
  cpp_bin_float_quad calculated = 2 * boost::math::constants::pi<cpp_bin_float_quad>();

  BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);

//] [/tolerance_3]
  }

  {
//[tolerance_4

  using boost::multiprecision::cpp_bin_float_oct;

  cpp_bin_float_oct tolerance =  3 * std::numeric_limits<cpp_bin_float_oct>::epsilon();
  cpp_bin_float_oct expected = boost::math::constants::two_pi<cpp_bin_float_oct>();
  cpp_bin_float_oct calculated = 2 * boost::math::constants::pi<cpp_bin_float_oct>();

  BOOST_CHECK_CLOSE_FRACTION(expected, calculated, tolerance);

//] [/tolerance_4]
  }

  {
//[nan_1]

/*`NaN can be used with binary multiprecision types like `cpp_bin_float_quad`:
*/
  using boost::multiprecision::cpp_bin_float_quad;

  if (std::numeric_limits<cpp_bin_float_quad>::has_quiet_NaN == true)
  {
    cpp_bin_float_quad NaN =  std::numeric_limits<cpp_bin_float_quad>::quiet_NaN();
    std::cout << "cpp_bin_float_quad NaN is "  << NaN << std::endl; //   cpp_bin_float_quad NaN is nan

    cpp_bin_float_quad expected = NaN;
    cpp_bin_float_quad calculated = 2 * NaN;
    // Comparisons of NaN's always fail:
    bool b = expected == calculated;
    std::cout << b << std::endl;
    BOOST_CHECK_NE(expected, expected);
    BOOST_CHECK_NE(expected, calculated);
  }
  else
  {
    std::cout << "Type " << typeid(cpp_bin_float_quad).name() << " does not have NaNs!" << std::endl;
  }

//]  [/nan_1]
  }

  {
//[facet_1]

/*`
See [@boost:/libs/math/example/nonfinite_facet_sstream.cpp]
and we also need

  #include <boost/math/special_functions/nonfinite_num_facets.hpp>

Then we can equally well use a multiprecision type cpp_bin_float_quad:

*/
  using boost::multiprecision::cpp_bin_float_quad;

  typedef cpp_bin_float_quad T;

  using boost::math::nonfinite_num_put;
  using boost::math::nonfinite_num_get;
  {
    std::locale old_locale;
    std::locale tmp_locale(old_locale, new nonfinite_num_put<char>);
    std::locale new_locale(tmp_locale, new nonfinite_num_get<char>);
    std::stringstream ss;
    ss.imbue(new_locale);
    T inf = std::numeric_limits<T>::infinity();
    ss << inf; // Write out.
   BOOST_MP_ASSERT(ss.str() == "inf");
    T r;
    ss >> r; // Read back in.
    BOOST_MP_ASSERT(inf == r); // Confirms that the floating-point values really are identical.
    std::cout << "infinity output was " << ss.str() << std::endl;
    std::cout << "infinity input was " << r << std::endl;
  }

/*`
``
  infinity output was inf
  infinity input was inf
``
Similarly we can do the same with NaN (except that we cannot use `assert` (because any comparisons with NaN always return false).
*/
  {
    std::locale old_locale;
    std::locale tmp_locale(old_locale, new nonfinite_num_put<char>);
    std::locale new_locale(tmp_locale, new nonfinite_num_get<char>);
    std::stringstream ss;
    ss.imbue(new_locale);
    T n;
    T NaN = std::numeric_limits<T>::quiet_NaN();
    ss << NaN; // Write out.
    BOOST_MP_ASSERT(ss.str() == "nan");
    std::cout << "NaN output was " << ss.str() << std::endl;
    ss >> n; // Read back in.
    std::cout << "NaN input was " << n << std::endl;
  }
/*`
``
  NaN output was nan
  NaN input was nan
``
*/
//]  [/facet_1]
  }

#endif
#endif
} // BOOST_AUTO_TEST_CASE(test_numeric_limits_snips)



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/random_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/random.hpp>
#include <boost/scoped_ptr.hpp>
#include <iostream>
#include <iomanip>

void t1()
{
//[random_eg1
//=#include <boost/multiprecision/cpp_int.hpp>
//=#include <boost/random.hpp>
//=
//=int main()
//={
   using namespace boost::multiprecision;
   using namespace boost::random;

   //
   // Declare our random number generator type, the underlying generator
   // is the Mersenne twister mt19937 engine, and we'll generate 256 bit
   // random values, independent_bits_engine will make multiple calls
   // to the underlying engine until we have the requested number of bits:
   //
   typedef independent_bits_engine<mt19937, 256, cpp_int> generator_type;
   generator_type gen;
   //
   // Generate some values:
   //
   std::cout << std::hex << std::showbase;
   for(unsigned i = 0; i < 10; ++i)
      std::cout << gen() << std::endl;
   //
   // Alternatively if we wish to generate random values in a fixed-precision
   // type, then we must use an unsigned type in order to adhere to the
   // conceptual requirements of the generator:
   //
   typedef independent_bits_engine<mt19937, 512, uint512_t> generator512_type;
   generator512_type gen512;
   //
   // Generate some 1024-bit unsigned values:
   //
   std::cout << std::hex << std::showbase;
   for(unsigned i = 0; i < 10; ++i)
      std::cout << gen512() << std::endl;
   //=   return 0;
//=}
//]
}

//
// Output from t1() is:
//[random_eg1_out
/*`[pre
0xD091BB5C22AE9EF6E7E1FAEED5C31F792082352CF807B7DFE9D300053895AFE1
0xA1E24BBA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810
0xF51F2AE7FF1816E4F702EF59F7BADAFA285954A1B9D09511F878C4B3FB2A0137
0xF508E4AA1C1FE6527C419418CC50AA59CCDF2E5C4C0A1F3B2452A9DC01397D8D
0x6BF88C311CCA797AEA6DA4AEA3C78807CACE1969E0E0D4ADF5A14BAB80F00988
0xA7DE9F4CCC450CBA0924668F5C7DC380D96089C53640AC4CEF1A2E6DAE6D9426
0xADC1965B6613BA46C1FB41C2BD9B0ECDBE3DEDFC7989C8EE6468FD6E6C0DF032
0xA7CD66342C826D8B2BD2E4124D4A2DBEB4BF6FA7CC1A89590826328251097330
0x46E46CB0DF577EC20BD1E364262C556418DDA0C9FE7B45D9D2CE21C9D268409A
0xB1E049E1200BFA47512D6E73C3851EEEF341C0817D973E4808D17554A9E20D28
0xD091BB5C22AE9EF6E7E1FAEED5C31F792082352CF807B7DFE9D300053895AFE1A1E24BBA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810
0xF51F2AE7FF1816E4F702EF59F7BADAFA285954A1B9D09511F878C4B3FB2A0137F508E4AA1C1FE6527C419418CC50AA59CCDF2E5C4C0A1F3B2452A9DC01397D8D
0x6BF88C311CCA797AEA6DA4AEA3C78807CACE1969E0E0D4ADF5A14BAB80F00988A7DE9F4CCC450CBA0924668F5C7DC380D96089C53640AC4CEF1A2E6DAE6D9426
0xADC1965B6613BA46C1FB41C2BD9B0ECDBE3DEDFC7989C8EE6468FD6E6C0DF032A7CD66342C826D8B2BD2E4124D4A2DBEB4BF6FA7CC1A89590826328251097330
0x46E46CB0DF577EC20BD1E364262C556418DDA0C9FE7B45D9D2CE21C9D268409AB1E049E1200BFA47512D6E73C3851EEEF341C0817D973E4808D17554A9E20D28
0x70518CE6203AC30361ADD0AB35D0430CC3F8E8920D1C8509CB92388E095436BF2FD6E20868A29AF97D61330B753EC6FC7211EFEA7CD15133A574C4FFCB41F198
0xB598EEF6EBBE7347C1332568CEBA5A7046A99459B4AD9F11AE00FEAA00B8B573A7B480B6B5F0B06C29A0EC27A4DAA0101E76A1C574BE91337F94C950C61F6ED6
0xF5B1C7A192E195F8572384D4E0732C8895D41B68CEE496C3394BBD52048CD47CC05309BED23D2D63414DE9C5D2229F23818666A3F0A8B109B2F6B12769A48341
0xE4123C566C548C8FF5941F6194B993AA8C1651342876763C237CE42EC300D11B263821CA3AEB820241EC0F84CF4AC36DD7393EE6FD0FC06A4118A30A551B54A4
0xD074F86F4CC1C54A3E57A70303774CDAEDE43895379CE62759988939E8490DDC325410E1D9352F6A4047080AF47C081D9DB51A85C765D71F79297527FCCA2773
]
*/
//]


void t2()
{
   std::cout << std::dec;
//[random_eg2
//=#include <boost/multiprecision/cpp_int.hpp>
//=#include <boost/random.hpp>
//=
//=int main()
//={
   using namespace boost::multiprecision;
   using namespace boost::random;

   //
   // Generate integers in a given range using uniform_int,
   // the underlying generator is invoked multiple times
   // to generate enough bits:
   //
   mt19937 mt;
   uniform_int_distribution<cpp_int> ui(-(cpp_int(1) << 256), cpp_int(1) << 256);
   //
   // Generate the numbers:
   //
   for(unsigned i = 0; i < 10; ++i)
      std::cout << ui(mt) << std::endl;

//=   return 0;
//=}
//]
}
//[random_eg2_out
/*`
Program output is

[pre
25593993629538149833210527544371584707508847463356155903670894544241785158492
12721121657520147247744796431842326146296294180809160027132416389225539366745
106034929479008809862776424170460808190085984129117168803272987114325199071833
86048861429530654936263414134573980939351899046345384016090167510299251354700
-23473382144925885755951447143660880642389842563343761080591177733698450031250
76840269649240973945508128641415259490679375154523618053296924666747244530145
21638369166612496703991271955994563624044383325105383029306009417224944272131
18829152205014764576551421737727569993966577957447887116062495161081023584880
101521572847669971701030312596819435590097618913255156117898217707115132658117
-97490271301923067621481012355971422109456300816856752380346627103308328292057
]
*/
//]

void t3()
{
//[random_eg3
//=#include <boost/multiprecision/cpp_bin_float.hpp>
//=#include <boost/random.hpp>
//=
//=int main()
//={
   using namespace boost::multiprecision;
   using namespace boost::random;

   mt19937 gen;
   //
   // Generate the values:
   //
   std::cout << std::setprecision(50);
   for(unsigned i = 0; i < 20; ++i)
      std::cout << generate_canonical<cpp_bin_float_50, std::numeric_limits<cpp_bin_float_50>::digits>(gen) << std::endl;
//=   return 0;
//=}
//]
}

//[random_eg3_out
/*`
Which produces the following output:

[pre
0.96886777112423135248554451482797431507115448261086
0.54722059636785192454525760726084778627750790023546
0.99646132554800874317788284808573062871409279729804
0.98110969177693891782396443737643892769773768718591
0.29702944955795083040856753579705872634075574515969
0.63976335709815275010379796044374742646738557798647
0.79792861516022605265555700991255998690336456180995
0.68135953856026596523755400091345037778580909233387
0.47475868061723477935404326837783394169122045199915
0.30191312687731969398296589840622989141067852863748
0.87242882006730022427155209451091472382531795659709
0.82190326480741096300318873712966555706035846579562
0.49058903962146072778707295967429263659897501512813
0.2102090745190061764133345429475530760261103345204
0.4087311609617603484960794513055502599728804206333
0.79397497154919267900450180642484943996546102712187
0.70577425166871982574205252142383800792823003687121
0.64396095652194035523385641523010248768636064728226
0.5737546665965914620678634509134819579811035412969
0.017773895576552474810236796736785695789752666554273
]
*/
//]

void t4()
{
   std::cout << std::endl;
//[random_eg4
//=#include <boost/multiprecision/cpp_bin_float.hpp>
//=#include <boost/multiprecision/cpp_int.hpp>
//=#include <boost/random.hpp>
//=
//=int main()
//={
   using namespace boost::multiprecision;
   using namespace boost::random;
   //
   // Generate some distruted values:
   //
   uniform_real_distribution<cpp_bin_float_50> ur(-20, 20);
   gamma_distribution<cpp_bin_float_50> gd(20);
   independent_bits_engine<mt19937, std::numeric_limits<cpp_bin_float_50>::digits, cpp_int> gen;
   //
   // Generate some values:
   //
   std::cout << std::setprecision(50);
   for(unsigned i = 0; i < 20; ++i)
      std::cout << ur(gen) << std::endl;
   for(unsigned i = 0; i < 20; ++i)
      std::cout << gd(gen) << std::endl;
//=   return 0;
//=}
//]
}

//[random_eg4_out
/*`
Which produces the following output:

[pre
-18.576837157065858312137736538355805944098004018928
4.5605477000094480453928920098152026546185388161216
-1.7611402252150150370944527411235180945558276280598
-2.471338289511354190492328039842914272146783953149
-7.4131520453411321647183692139916357315276121488316
-9.192739117661751364518299455475684051782402347659
7.0126880787149555595443325648941661436898526919013
2.8554749162054097111723076181877881960039268668423
14.390501287552165467965587841551705310012046701036
-8.9747073123748752412086051960748002945548570524149
-8.1305063133718605220959174700954037986278348616362
9.5496899464463627949564295930962040525540578754312
-15.309681742947663333436391348699943078942921692008
2.0454914298189175280771944784358385982869708951824
-10.069253024538932382193363493367304983742246396276
13.449212808583153116670057807764145176004060370818
-6.0065092542772507561228141992257782449634820245355
15.00971466974838379824678369267201922989930663822
16.158514812070905438581736305533045434508525979205
-2.1531361299576399413547008719541457739794964378093
19.398278792113040046930806838893737245011219380822
12.965216582396067073600685365545292876001524716225
19.561779374349650983983836397553672788578622096947
15.982213641588944604037715576313848977716540941271
23.96044616946856385664151481695038833903083043492
21.054716943622792848187523422423642819628010070375
18.596078774135209530930707331338838805575875990091
19.539530839287848627426769425090194390388333335812
17.176133236359396942946640290935498641489373354297
16.228802394876800099035133760539461530246286999827
23.63807160907473465631049083277558060813997674519
12.838499607321990428122225501321564153572478845401
16.878362445712403300584931374939967549572637230102
20.646246409377134464856282996941395597420615529803
16.602429236226052406561338766554127142762673418695
21.680007865714197450495711030406314524681744024329
21.038948660115771777833205901845639760348321521616
30.494499676527802078320016654058105593076348727966
18.704734464995637480940828829962787676146589788572
22.502216997171061548799304902323434654678156658236
]
*/
//]

void t5()
{
//[random_eg5
//=#include <boost/multiprecision/cpp_bin_float.hpp>
//=#include <boost/random.hpp>
//=#include <boost/scoped_ptr.hpp>
//=
//=int main()
//={
   using namespace boost::multiprecision;
   using namespace boost::random;
   //
   // Generate some multiprecision values, note that the generator is so large
   // that we have to allocate it on the heap, otherwise we may run out of
   // stack space!  We could avoid this by using a floating point type which
   // allocates it's internal storage on the heap - cpp_bin_float will do
   // this with the correct template parameters, as will the GMP or MPFR
   // based reals.
   //
   typedef lagged_fibonacci_01_engine<cpp_bin_float_50, 48, 44497, 21034 > big_fib_gen;
   boost::scoped_ptr<big_fib_gen> pgen(new big_fib_gen);
   //
   // Generate some values:
   //
   std::cout << std::setprecision(50);
   for(unsigned i = 0; i < 20; ++i)
      std::cout << (*pgen)() << std::endl;
   //
   // try again with a ranlux generator, this is not quite so large
   // so we can use the heap this time:
   //
   typedef subtract_with_carry_01_engine<cpp_bin_float_50, std::numeric_limits<cpp_bin_float_50>::digits - 5, 10, 24 > ranlux_big_base_01;
   typedef discard_block_engine< ranlux_big_base_01, 389, 24 > big_ranlux;
   big_ranlux rg;
   for(unsigned i = 0; i < 20; ++i)
      std::cout << rg() << std::endl;
//=   return 0;
//=}
//]
}

int main()
{
   t1();
   t2();
   t3();
   t4();
   t5();
   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/safe_prime.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//[safe_prime

#include <boost/random.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
#include <iostream>
#include <iomanip>

int main()
{
   using namespace boost::random;
   using namespace boost::multiprecision;

   typedef cpp_int int_type;
   mt11213b base_gen(clock());
   independent_bits_engine<mt11213b, 256, int_type> gen(base_gen);
   //
   // We must use a different generator for the tests and number generation, otherwise
   // we get false positives.
   //
   mt19937 gen2(clock());

   for(unsigned i = 0; i < 100000; ++i)
   {
      int_type n = gen();
      if(miller_rabin_test(n, 25, gen2))
      {
         // Value n is probably prime, see if (n-1)/2 is also prime:
         std::cout << "We have a probable prime with value: " << std::hex << std::showbase << n << std::endl;
         if(miller_rabin_test((n-1)/2, 25, gen2))
         {
            std::cout << "We have a safe prime with value: " << std::hex << std::showbase << n << std::endl;
            return 0;
         }
      }
   }
   std::cout << "Ooops, no safe primes were found - probably a bad choice of seed values!" << std::endl;
   return 0;
}

//]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/scoped_precision_example.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/next.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

//[scoped_precision_1

/*`
All our precision changing examples are based around `mpfr_float`.
However, in order to make running this example a little easier to debug,
we'll use `debug_adaptor` throughout so that the values of all variables
can be displayed in your debugger of choice:
*/

using mp_t = boost::multiprecision::debug_adaptor_t<boost::multiprecision::mpfr_float>;

/*`
Our first example will investigate calculating the Bessel J function via it's well known 
series representation:

[$../bessel2.svg]

This simple series suffers from catastrophic cancellation error
near the roots of the function, so we'll investigate slowly increasing the precision of
the calculation until we get the result to N-decimal places.  We'll begin by defining
a function to calculate the series for Bessel J, the details of which we'll leave in the
source code:
*/
mp_t calculate_bessel_J_as_series(mp_t x, mp_t v, mp_t* err)
//<-
{
   mp_t sum        = pow(x / 2, v) / tgamma(v + 1);
   mp_t abs_sum    = abs(sum);
   mp_t multiplier = -x * x / 4;
   mp_t divider    = v + 1;
   mp_t term       = sum;
   mp_t eps        = boost::math::tools::epsilon<mp_t>();
   unsigned   m          = 1;

   while (fabs(term / abs_sum) > eps)
   {
      term *= multiplier;
      term /= m;
      term /= divider;
      ++divider;
      ++m;
      sum += term;
      abs_sum += abs(term);
   }
   if (err)
      *err = eps * fabs(abs_sum / sum);
   /*
   std::cout << eps << std::endl;
   if (err)
      std::cout << *err << std::endl;
   std::cout << abs_sum << std::endl;
   std::cout << sum << std::endl;
   */
   return sum;
}
//->

/*`
Next come some simple helper classes, these allow us to modify the current precision and precision-options
via scoped objects which will put everything back as it was at the end.  We'll begin with the class to
modify the working precision:
*/
struct scoped_mpfr_precision
{
   unsigned saved_digits10;
   scoped_mpfr_precision(unsigned digits10) : saved_digits10(mp_t::thread_default_precision())
   {
      mp_t::thread_default_precision(digits10);
   }
   ~scoped_mpfr_precision()
   {
      mp_t::thread_default_precision(saved_digits10);
   }
   void reset(unsigned digits10)
   {
      mp_t::thread_default_precision(digits10);
   }
   void reset()
   {
      mp_t::thread_default_precision(saved_digits10);
   }
};
/*`
And a second class to modify the precision options:
*/
struct scoped_mpfr_precision_options
{
   boost::multiprecision::variable_precision_options saved_options;
   scoped_mpfr_precision_options(boost::multiprecision::variable_precision_options opts) : saved_options(mp_t::thread_default_variable_precision_options())
   {
      mp_t::thread_default_variable_precision_options(opts);
   }
   ~scoped_mpfr_precision_options()
   {
      mp_t::thread_default_variable_precision_options(saved_options);
   }
   void reset(boost::multiprecision::variable_precision_options opts)
   {
      mp_t::thread_default_variable_precision_options(opts);
   }
};
/*`
We can now begin writing a function to calculate J[sub v](z) to a specified precision.  
In order to keep the logic as simple as possible, we'll adopt a ['uniform precision computing] approach, 
which is to say, within the body of the function, all variables are always at the same working precision.
*/
mp_t Bessel_J_to_precision(mp_t v, mp_t x, unsigned digits10)
{
   //
   // Begin by backing up digits10:
   //
   unsigned saved_digits10 = digits10;
   // 
   //
   // Start by defining 2 scoped objects to control precision and associated options.
   // We'll begin by setting the working precision to the required target precision,
   // and since all variables will always be of uniform precision, we can tell the
   // library to ignore all precision control by setting variable_precision_options::assume_uniform_precision:
   //
   scoped_mpfr_precision           scoped(digits10);
   scoped_mpfr_precision_options   scoped_opts(boost::multiprecision::variable_precision_options::assume_uniform_precision);

   mp_t            result;
   mp_t            current_error{1};
   mp_t            target_error {std::pow(10., -static_cast<int>(digits10))};

   while (target_error < current_error)
   {
      //
      // Everything must be of uniform precision in here, including
      // our input values, so we'll begin by setting their precision:
      //
      v.precision(digits10);
      x.precision(digits10);
      //
      // Calculate our approximation and error estimate:
      //
      result = calculate_bessel_J_as_series(x, v, &current_error);
      //
      // If the error from the current approximation is too high we'll need 
      // to loop round and try again, in this case we use the simple heuristic
      // of doubling the working precision with each loop.  More refined approaches
      // are certainly available:
      //
      digits10 *= 2;
      scoped.reset(digits10);
   }
   //
   // We now have an accurate result, but it may have too many digits,
   // so lets round the result to the requested precision now:
   //
   result.precision(saved_digits10);
   //
   // To maintain uniform precision during function return, lets
   // reset the default precision now:
   //
   scoped.reset(saved_digits10);
   return result;
}

/*`
So far, this is all well and good, but there is still a potential trap for the unwary here,
when the function returns the variable [/result] may be copied/moved either once or twice
depending on whether the compiler implements the named-return-value optimisation.  And since this
all happens outside the scope of this function, the precision of the returned value may get unexpected
changed - and potentially with different behaviour once optimisations are turned on!

To prevent these kinds of unintended consequences, a function returning a value with specified precision
must either:

* Be called in a /uniform-precision-environment/, with the current working precision, the same as both
the returned value and the variable to which the result will be assigned.
* Be called in an environment that has one of the following set:
   * variable_precision_options::preserve_source_precision
   * variable_precision_options::preserve_component_precision
   * variable_precision_options::preserve_related_precision
   * variable_precision_options::preserve_all_precision

In the case of our example program, we use a /uniform-precision-environment/ and call the function
with the value of `6541389046624379 / 562949953421312` which happens to be near a root of J[sub v](x)
and requires a high-precision calculation to obtain low relative error in the result of 
`-9.31614245636402072613249153246313221710284959883647822724e-15`.

You will note in the example we have so far that there are a number of unnecessary temporaries
created: we pass values to our functions by value, and we call the `.precision()` member function
to change the working precision of some variables - something that requires a reallocation internally.
We'll now make our example just a little more efficient, by removing these temporaries, though in the
process, we'll need just a little more control over how mixed-precision arithmetic behaves.

It's tempting to simply define the function that calculates the series to take arguments
by constant reference like so:

*/

mp_t calculate_bessel_J_as_series_2(const mp_t& x, const mp_t& v, mp_t* err)
//<-
{
   mp_t sum        = pow(x / 2, v) / tgamma(v + 1);
   mp_t abs_sum    = abs(sum);
   mp_t multiplier = -x * x / 4;
   mp_t divider    = v + 1;
   mp_t term       = sum;
   mp_t eps        = boost::math::tools::epsilon<mp_t>();
   unsigned   m          = 1;

   while (fabs(term / abs_sum) > eps)
   {
      term *= multiplier;
      term /= m;
      term /= divider;
      ++divider;
      ++m;
      sum += term;
      abs_sum += abs(term);
   }
   if (err)
      *err = eps * fabs(abs_sum / sum);

   return sum;
}
//->

/*`
And to then pass our arguments to it, without first altering their precision to match
the current working default.  However, imagine that `calculate_bessel_J_as_series_2`
calculates x[super 2] internally, what precision is the result?  If it's the same as the
precision of /x/, then our calculation will loose precision, since we really want the result
calculated to the full current working precision, which may be significantly higher than
that of our input variables.  Our new version of Bessel_J_to_precision therefore uses
`variable_precision_options::preserve_target_precision` internally, so that expressions
containing only the low-precision input variables are calculated at the precision of
(at least) the target - which will have been constructed at the current working precision.

Here's our revised code:

*/

mp_t Bessel_J_to_precision_2(const mp_t& v, const mp_t& x, unsigned digits10)
{
   //
   // Begin with 2 scoped objects, one to manage current working precision, one to
   // manage mixed precision arithmetic.  Use of variable_precision_options::preserve_target_precision
   // ensures that expressions containing only low-precision input variables are evaluated at the precision
   // of the variable they are being assigned to (ie current working precision).
   //
   scoped_mpfr_precision scoped(digits10);
   scoped_mpfr_precision_options scoped_opts(boost::multiprecision::variable_precision_options::preserve_target_precision);

   mp_t                    result;
   mp_t            current_error{1};
   mp_t            target_error{std::pow(10., -static_cast<int>(digits10))};

   while (target_error < current_error)
   {
      //
      // The assignment here, rounds the high precision result
      // returned by calculate_bessel_J_as_series_2, to the precision
      // of variable result: ie to the target precision we specified in
      // the function call.  This is only the case because we have
      // variable_precision_options::preserve_target_precision set.
      //
      result = calculate_bessel_J_as_series_2(x, v, &current_error);

      digits10 *= 2;
      scoped.reset(digits10);
   }
   //
   // There may be temporaries created when we return, we must make sure
   // that we reset the working precision and options before we return.
   // In the case of the options, we must preserve the precision of the source
   // object during the return, not only here, but in the calling function too:
   //
   scoped.reset();
   scoped_opts.reset(boost::multiprecision::variable_precision_options::preserve_source_precision);
   return result;
}

/*`
In our final example, we'll look at a (somewhat contrived) case where we reduce the argument
by N * PI, in this case we change the mixed-precision arithmetic options several times,
depending what it is we are trying to achieve at that moment in time:

*/
mp_t reduce_n_pi(const mp_t& arg)
{
   //
   // We begin by estimating how many multiples of PI we will be reducing by, 
   // note that this is only an estimate because we're using low precision
   // arithmetic here to get a quick answer:
   //
   unsigned n = static_cast<unsigned>(arg / boost::math::constants::pi<mp_t>());
   //
   // Now that we have an estimate for N, we can up the working precision and obtain
   // a high precision value for PI, best to play safe and preserve the precision of the
   // source here.  Though note that expressions are evaluated at the highest precision
   // of any of their components: in this case that's the current working precision
   // returned by boost::math::constants::pi, and not the precision of arg.
   // However, should this function be called with assume_uniform_precision set
   // then all bets are off unless we do this:
   //
   scoped_mpfr_precision            scope_1(mp_t::thread_default_precision() * 2);
   scoped_mpfr_precision_options    scope_2(boost::multiprecision::variable_precision_options::preserve_source_precision);

   mp_t reduced = arg - n * boost::math::constants::pi<mp_t>();
   //
   // Since N was only an estimate, we may have subtracted one PI too many,
   // correct if that's the case now:
   //
   if (reduced < 0)
      reduced += boost::math::constants::pi<mp_t>();
   //
   // Our variable "reduced" now has the correct answer, but too many digits precision, 
   // we can either call its .precision() member function, or assign to a new variable
   // with variable_precision_options::preserve_target_precision set:
   //
   scope_1.reset();
   scope_2.reset(boost::multiprecision::variable_precision_options::preserve_target_precision);
   mp_t result = reduced;
   //
   // As with previous examples, returning the result may create temporaries, so lets
   // make sure that we preserve the precision of result.  Note that this isn't strictly
   // required if the calling context is always of uniform precision, but we can't be sure 
   // of our calling context:
   //
   scope_2.reset(boost::multiprecision::variable_precision_options::preserve_source_precision);
   return result;
}

/*`
And finally... we need to mention `preserve_component_precision`, `preserve_related_precision` and `preserve_all_precision`.

These form a hierarchy, with each inheriting the properties of those before it.
`preserve_component_precision` is used when dealing with complex or interval numbers, for example if we have:

   mpc_complex val = some_expression;

And `some_expression` contains scalar values of type `mpfr_float`, then the precision of these is ignored unless
we specify at least `preserve_component_precision`.

`preserve_related_precision` we'll somewhat skip over - it extends the range of types whose precision is
considered within an expression to related types - for example all instantiations of `number<mpfr_float_backend<N>, ET>`
when dealing with expression of type `mpfr_float`.  However, such situations are - and should be -  very rare.

The final option - `preserve_all_precision` - is used to preserve the precision of all the types in an expression, 
for example:

   // calculate 2^1000 - 1:
   mpz_int i(1);
   i <<= 1000;
   i -= 1;

   mp_t f = i;

The final assignment above will round the value in /i/ to the current working precision, unless `preserve_all_precision`
is set, in which case /f/ will end up with sufficient precision to store /i/ unchanged.

*/

//]

int main()
{
   mp_t::thread_default_precision(50);
   mp_t x{6541389046624379uLL};
   x /= 562949953421312uLL;
   mp_t v{2};
   mp_t err;
   mp_t J = Bessel_J_to_precision(v, x, 50);

   std::cout << std::setprecision(50) << J << std::endl;
   std::cout << J.precision() << std::endl;

   mp_t expected{"-9.31614245636402072613249153246313221710284959883647822724e-15"};
   std::cout << boost::math::relative_difference(expected, J) << std::endl;
   
   J = Bessel_J_to_precision_2(v, x, 50);
   std::cout << boost::math::relative_difference(expected, J) << std::endl;
   std::cout << J.precision() << std::endl;
   
   std::cout << reduce_n_pi(boost::math::float_next(boost::math::float_next(5 * boost::math::constants::pi<mp_t>()))) << std::endl;

   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/standalone_bernoulli_tgamma.cpp
================================================
///////////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2020 - 2022.                 //
//  Distributed under the Boost Software License,                //
//  Version 1.0. (See accompanying file LICENSE_1_0.txt          //
//  or copy at http://www.boost.org/LICENSE_1_0.txt)             //
///////////////////////////////////////////////////////////////////

#include <array>
#include <cstdint>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <memory>
#include <utility>
#include <vector>

#define EXAMPLE008_BERNOULLI_USE_LOCAL_PI

#if !defined(BOOST_MP_STANDALONE)
#define BOOST_MP_STANDALONE
#endif

#if !defined(EXAMPLE008_BERNOULLI_USE_LOCAL_PI)
#if !defined(BOOST_MATH_STANDALONE)
#define BOOST_MATH_STANDALONE
#endif
#include <boost/math/constants/constants.hpp>
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>

// cd /mnt/c/Users/User/Documents/Ks/PC_Software/Test
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -Wshadow -Wundef -O3 -std=c++11 -I/mnt/c/boost/modular_boost/boost/libs/multiprecision/include -I/mnt/c/boost/modular_boost/boost/libs/config/include standalone_bernoulli_tgamma.cpp -o standalone_bernoulli_tgamma.exe

// D:\MinGW_nuwen\MinGW\bin\g++ -Wall -Wextra -Wconversion -Wsign-conversion -Wshadow -Wundef -O3 -std=c++11 -IC:\boost\modular_boost\boost\libs\multiprecision\include -IC:\boost\modular_boost\boost\libs\config\include test.cpp -o test.exe
namespace example008_bernoulli
{
  constexpr std::int32_t wide_decimal_digits10 = INT32_C(1001);

  using wide_float_backend_type = boost::multiprecision::cpp_bin_float<wide_decimal_digits10, boost::multiprecision::digit_base_10, std::allocator<void>>;

  using wide_float_type = boost::multiprecision::number<wide_float_backend_type, boost::multiprecision::et_off>;

  template<typename FloatingPointType>
  auto pi() -> FloatingPointType
  {
    return static_cast<FloatingPointType>(3.1415926535897932384626433832795029L); // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
  }

  #if defined(EXAMPLE008_BERNOULLI_USE_LOCAL_PI)
  template<typename FloatingPointType>
  auto calc_pi() -> FloatingPointType
  {
    // Use a quadratically convergent Gauss AGM to compute pi.

    using floating_point_type = FloatingPointType;

    floating_point_type val_pi;

    floating_point_type a(1U);

    // Initialize bB to 0.5.
    floating_point_type bB(0.5F); // NOLINT(readability-identifier-naming,cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)

    // Initialize t to 0.375.
    floating_point_type t(static_cast<floating_point_type>(3U) / 8U); // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)

    floating_point_type s(bB);

    // This loop is designed for a maximum of several million
    // decimal digits of pi. The index k should reach no higher
    // than about 25 or 30. After about 20 iterations, the precision
    // is about one million decimal digits.

    const auto digits10_iteration_goal =
      static_cast<std::uint32_t>
      (
          static_cast<std::uint32_t>(std::numeric_limits<floating_point_type>::digits10 / 2)
        + static_cast<std::uint32_t>(9U)
      );

    using std::log;
    using std::lround;

    const auto digits10_scale =
      static_cast<std::uint32_t>
      (
        lround
        (
          static_cast<float>(1000.0F * log(static_cast<float>(std::numeric_limits<floating_point_type>::radix))) / log(10.0F)
        )
      );

    for(auto   k = static_cast<unsigned>(UINT8_C(0));
                k < static_cast<unsigned>(UINT8_C(48));
              ++k)
    {
      using std::sqrt;

      a      += sqrt(bB);
      a      /= 2U;
      val_pi  = a;
      val_pi *= a;
      bB      = val_pi;
      bB     -= t;
      bB     *= 2U;

      floating_point_type iterate_term(bB);

      iterate_term -= val_pi;
      iterate_term *= static_cast<unsigned long long>(1ULL << (k + 1U)); // NOLINT(google-runtime-int)

      s += iterate_term;

      // Test the number of precise digits from this iteration.
      // If it is there are enough precise digits, then the calculation
      // is finished.
      const auto ib =
        (std::max)
        (
          static_cast<std::int32_t>(0),
          static_cast<std::int32_t>(-ilogb(iterate_term))
        );

      const auto digits10_of_iteration =
        static_cast<std::uint32_t>
        (
          static_cast<std::uint64_t>(static_cast<std::uint64_t>(ib) * digits10_scale) / UINT32_C(1000)
        );

      // Estimate the approximate decimal digits of this iteration term.
      // If we have attained about half of the total desired digits
      // with this iteration term, then the calculation is finished
      // because the change from the next iteration will be
      // insignificantly small.

      if(digits10_of_iteration > digits10_iteration_goal)
      {
        break;
      }

      t  = val_pi;
      t += bB;
      t /= 4U;
    }

    return (val_pi + bB) / s;
  }

  template<typename FloatingPointType>
  auto my_pi() -> const FloatingPointType&
  {
    using floating_point_type = FloatingPointType;

    static const floating_point_type local_pi = calc_pi<floating_point_type>();

    return local_pi;
  }
  #endif

  template<>
  auto pi() -> wide_float_type
  {
    #if defined(EXAMPLE008_BERNOULLI_USE_LOCAL_PI)
    return my_pi<wide_float_type>();
    #else
    return boost::math::constants::pi<wide_float_type>();
    #endif
  }

  auto bernoulli_table() -> std::vector<wide_float_type>&
  {
    static std::vector<wide_float_type>
      bernoulli_table
      (
        static_cast<std::size_t>
        (
          static_cast<float>(std::numeric_limits<wide_float_type>::digits10) * 0.95F
        )
      );

    return bernoulli_table;
  }

  template<typename FloatingPointType>
  auto bernoulli_b(FloatingPointType* bn, std::uint32_t n) -> void
  {
    using floating_point_type = FloatingPointType;

    // See reference "Computing Bernoulli and Tangent Numbers", Richard P. Brent.
    // See also the book Richard P. Brent and Paul Zimmermann, "Modern Computer Arithmetic",
    // Cambridge University Press, 2010, p. 237.

    const auto m = static_cast<std::uint32_t>(n / 2U);

    std::vector<floating_point_type> tangent_numbers(m + 1U);

    tangent_numbers[0U] = 0U;
    tangent_numbers[1U] = 1U;

    for(std::uint32_t k = 1U; k < m; ++k)
    {
      tangent_numbers[k + 1U] = tangent_numbers[k] * k;
    }

    for(auto k = static_cast<std::uint32_t>(2U); k <= m; ++k)
    {
      for(auto j = k; j <= m; ++j)
      {
        const std::uint32_t j_minus_k = j - k;

        tangent_numbers[j] =   (tangent_numbers[j - 1] *  j_minus_k)
                             + (tangent_numbers[j]     * (j_minus_k + 2U));
      }
    }

    floating_point_type two_pow_two_m(4U);

    for(std::uint32_t i = 1U; i < static_cast<std::uint32_t>(n / 2U); ++i)
    {
      const auto two_i = static_cast<std::uint32_t>(2U * i);

      const floating_point_type b = (tangent_numbers[i] * two_i) / (two_pow_two_m * (two_pow_two_m - 1));

      const bool  b_neg = ((two_i % 4U) == 0U);

      bn[two_i] = ((!b_neg) ? b : -b); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)

      two_pow_two_m *= 4U;
    }

    bn[0U] =  1U;                          // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    bn[1U] = floating_point_type(-1) / 2U; // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  }

  template<typename FloatingPointType>
  auto tgamma(const FloatingPointType& x) -> FloatingPointType
  {
    using floating_point_type = FloatingPointType;

    // Check if the argument should be scaled up for the Bernoulli series expansion.
    static const auto min_arg_n =
      static_cast<std::int32_t>
      (
        static_cast<float>(static_cast<float>(std::numeric_limits<floating_point_type>::digits10) * 0.8F)
      );

    static const floating_point_type min_arg_x = floating_point_type(min_arg_n);

    const auto n_recur =
      static_cast<std::uint32_t>
      (
        (x < min_arg_x) ? static_cast<std::uint32_t>(static_cast<std::uint32_t>(min_arg_n - static_cast<std::int32_t>(x)) + 1U)
                        : static_cast<std::uint32_t>(0U)
      );

    floating_point_type xx(x);

    // Scale the argument up and use downward recursion later for the final result.
    if(n_recur != 0U)
    {
      xx += n_recur;
    }

          floating_point_type one_over_x_pow_two_n_minus_one = 1 / xx;
    const floating_point_type one_over_x2                    =  one_over_x_pow_two_n_minus_one * one_over_x_pow_two_n_minus_one;
          floating_point_type sum                            = (one_over_x_pow_two_n_minus_one * bernoulli_table()[2U]) / 2U;

    floating_point_type tol = std::numeric_limits<floating_point_type>::epsilon();

    using std::log;

    if(xx > 8U) // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
    {
      // In the following code sequence, we extract the approximate logarithm
      // of the argument x and use the leading term of Stirling's approximation,
      // which is Log[Gamma[x]] aprox. (x (Log[x] - 1)) in order to scale
      // the tolerance. In order to do this, we find the built-in floating point
      // approximation of (x (Log[x] - 1)).

      // Limit fx to the range 8 <= fx <= 10^16, where 8 is chosen to
      // ensure that (log(fx) - 1.0F) remains positive and 10^16 is
      // selected arbitrarily, yet ensured to be rather large.
      auto fx_max = (std::max)(static_cast<floating_point_type>(8U), xx); // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)

      auto fx = (std::min)(fx_max, static_cast<floating_point_type>(UINT64_C(10000000000000000)));

      tol *= static_cast<float>(fx * (log(fx) - 1.0F));
    }

    // Perform the Bernoulli series expansion.
    for(auto n2 = static_cast<std::uint32_t>(4U); n2 < static_cast<std::uint32_t>(bernoulli_table().size()); n2 += 2U)
    {
      one_over_x_pow_two_n_minus_one *= one_over_x2;

      const floating_point_type term =
          (one_over_x_pow_two_n_minus_one * bernoulli_table()[n2])
        / static_cast<std::uint64_t>(static_cast<std::uint64_t>(n2) * static_cast<std::uint32_t>(n2 - 1U));

      using std::fabs;

      if((n2 > 6U) && (fabs(term) < tol)) // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
      {
        break;
      }

      sum += term;
    }

    using example008_bernoulli::pi;
    using std::exp;

    static const floating_point_type half           = floating_point_type(1U) / 2U;
    static const floating_point_type half_ln_two_pi = log(pi<floating_point_type>() * 2U) / 2U;

    floating_point_type g = exp(((((xx - half) * log(xx)) - xx) + half_ln_two_pi) + sum);

    // Rescale the result using downward recursion if necessary.
    for(auto k = static_cast<std::uint32_t>(0U); k < n_recur; ++k)
    {
      g /= --xx;
    }

    return g;
  }
} // namespace example008_bernoulli

auto example008_bernoulli_tgamma() -> bool
{
  const std::clock_t start = std::clock();

  // Initialize the table of Bernoulli numbers.
  example008_bernoulli::bernoulli_b
  (
    example008_bernoulli::bernoulli_table().data(),
    static_cast<std::uint32_t>(example008_bernoulli::bernoulli_table().size())
  );

  // In this example, we compute values of Gamma[1/2 + n].

  // We will make use of the relation
  //                     (2n)!
  //   Gamma[1/2 + n] = -------- * Sqrt[Pi].
  //                    (4^n) n!

  // Table[Factorial[2 n]/((4^n) Factorial[n]), {n, 0, 17, 1}]
  const std::array<std::pair<std::uint64_t, std::uint32_t>, 18U> ratios =
  {{
    { UINT64_C(                  1), UINT32_C(     1) },
    { UINT64_C(                  1), UINT32_C(     2) },
    { UINT64_C(                  3), UINT32_C(     4) },
    { UINT64_C(                 15), UINT32_C(     8) },
    { UINT64_C(                105), UINT32_C(    16) },
    { UINT64_C(                945), UINT32_C(    32) },
    { UINT64_C(              10395), UINT32_C(    64) },
    { UINT64_C(             135135), UINT32_C(   128) },
    { UINT64_C(            2027025), UINT32_C(   256) },
    { UINT64_C(           34459425), UINT32_C(   512) },
    { UINT64_C(          654729075), UINT32_C(  1024) },
    { UINT64_C(        13749310575), UINT32_C(  2048) },
    { UINT64_C(       316234143225), UINT32_C(  4096) },
    { UINT64_C(      7905853580625), UINT32_C(  8192) },
    { UINT64_C(    213458046676875), UINT32_C( 16384) },
    { UINT64_C(   6190283353629375), UINT32_C( 32768) },
    { UINT64_C( 191898783962510625), UINT32_C( 65536) },
    { UINT64_C(6332659870762850625), UINT32_C(131072) }
  }};

  bool result_is_ok = true;

  using example008_bernoulli::wide_float_type;

  const wide_float_type tol (std::numeric_limits<wide_float_type>::epsilon() * UINT32_C(100000));
  const wide_float_type half(0.5F);

  for(auto i = static_cast<std::size_t>(0U); i < ratios.size(); ++i)
  {
    // Calculate Gamma[1/2 + i]

    const wide_float_type g = example008_bernoulli::tgamma(half + i);

    // Calculate the control value.

    using example008_bernoulli::pi;
    using std::fabs;
    using std::sqrt;

    const wide_float_type control = (sqrt(pi<wide_float_type>()) * ratios[i].first) / ratios[i].second; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)

    const wide_float_type closeness = fabs(1 - (g / control));

    result_is_ok &= (closeness < tol);
  }

  const std::clock_t stop = std::clock();

  std::cout << "Time example008_bernoulli_tgamma(): "
            << static_cast<float>(stop - start) / static_cast<float>(CLOCKS_PER_SEC)
            << std::endl;

  return result_is_ok;
}

int main()
{
  const bool result_is_ok = example008_bernoulli_tgamma();

  std::cout << "result_is_ok: " << std::boolalpha << result_is_ok << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/example/tommath_snips.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/tommath.hpp>
#include <iostream>

void t1()
{
//[tommath_eg
//=#include <boost/multiprecision/tommath.hpp>
//=#include <iostream>
//=
//=int main()
//={
   boost::multiprecision::tom_int v = 1;

   // Do some arithmetic:
   for(unsigned i = 1; i <= 1000; ++i)
      v *= i;

   std::cout << v << std::endl; // prints 1000!
   std::cout << std::hex << v << std::endl; // prints 1000! in hex format

   try{
      std::cout << std::hex << -v << std::endl; // Ooops! can't print a negative value in hex format!
   }
   catch(const std::runtime_error& e)
   {
      std::cout << e.what() << std::endl;
   }

   try{
      // v is not a 2's complement type, bitwise operations are only supported
      // on positive values:
      v = -v & 2;
   }
   catch(const std::runtime_error& e)
   {
      std::cout << e.what() << std::endl;
   }

//=   return 0;
//=}
//]
}

void t3()
{
//[mp_rat_eg
//=#include <boost/multiprecision/tommath.hpp>
//=#include <iostream>
//=
//=int main()
//={
   using namespace boost::multiprecision;

   tom_rational v = 1;

   // Do some arithmetic:
   for(unsigned i = 1; i <= 1000; ++i)
      v *= i;
   v /= 10;

   std::cout << v << std::endl; // prints 1000! / 10
   std::cout << numerator(v) << std::endl;
   std::cout << denominator(v) << std::endl;

   tom_rational w(2, 3); // Component wise constructor
   std::cout << w << std::endl; // prints 2/3

//=   return 0;
//=}
//]
}

int main()
{
   t1();
   t3();
   return 0;
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi/borland_prefix.hpp
================================================
//  (C) Copyright John Maddock 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  for C++ Builder the following options effect the ABI:
//
//  -b (on or off - effect emum sizes)
//  -Vx  (on or off - empty members)
//  -Ve (on or off - empty base classes)
//  -aX (alignment - 5 options).
//  -pX (Calling convention - 4 options)
//  -VmX (member pointer size and layout - 5 options)
//  -VC (on or off, changes name mangling)
//  -Vl (on or off, changes struct layout).

//  In addition the following warnings are sufficiently annoying (and
//  unfixable) to have them turned off by default:
//
//  8027 - functions containing [for|while] loops are not expanded inline
//  8026 - functions taking class by value arguments are not expanded inline

#pragma nopushoptwarn
#  pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi/borland_suffix.hpp
================================================
//  (C) Copyright John Maddock 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#  pragma option pop
#pragma nopushoptwarn







================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi/msvc_prefix.hpp
================================================
//  (C) Copyright John Maddock 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// Boost binaries are built with the compiler's default ABI settings,
// if the user changes their default alignment in the VS IDE then their
// code will no longer be binary compatible with the bjam built binaries
// unless this header is included to force Boost code into a consistent ABI.
//
// Note that inclusion of this header is only necessary for libraries with 
// separate source, header only libraries DO NOT need this as long as all
// translation units are built with the same options.
//
#if defined(_M_X64)
#  pragma pack(push,16)
#else
#  pragma pack(push,8)
#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi/msvc_suffix.hpp
================================================
//  (C) Copyright John Maddock 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#pragma pack(pop)




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi_prefix.hpp
================================================
//  abi_prefix header  -------------------------------------------------------//

// (c) Copyright John Maddock 2003
   
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).

#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
# define BOOST_CONFIG_ABI_PREFIX_HPP
#else
# error double inclusion of header boost/config/abi_prefix.hpp is an error
#endif

#include <boost/config.hpp>

// this must occur after all other includes and before any code appears:
#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_PREFIX
#endif

#if defined( BOOST_BORLANDC )
#pragma nopushoptwarn
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/abi_suffix.hpp
================================================
//  abi_sufffix header  -------------------------------------------------------//

// (c) Copyright John Maddock 2003
   
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).

// This header should be #included AFTER code that was preceded by a #include
// <boost/config/abi_prefix.hpp>.

#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
# error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp
#else
# undef BOOST_CONFIG_ABI_PREFIX_HPP
#endif

// the suffix header occurs after all of our code:
#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_SUFFIX
#endif

#if defined( BOOST_BORLANDC )
#pragma nopushoptwarn
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx03.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>

#ifdef BOOST_NO_ADL_BARRIER
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_ADL_BARRIER."
#endif
#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP."
#endif
#ifdef BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS."
#endif
#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_COMPLETE_VALUE_INITIALIZATION."
#endif
#ifdef BOOST_NO_CTYPE_FUNCTIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_CTYPE_FUNCTIONS."
#endif
#ifdef BOOST_NO_CV_SPECIALIZATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_CV_SPECIALIZATIONS."
#endif
#ifdef BOOST_NO_CV_VOID_SPECIALIZATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_CV_VOID_SPECIALIZATIONS."
#endif
#ifdef BOOST_NO_CWCHAR
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_CWCHAR."
#endif
#ifdef BOOST_NO_CWCTYPE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_CWCTYPE."
#endif
#ifdef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_DEPENDENT_NESTED_DERIVATIONS."
#endif
#ifdef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS."
#endif
#ifdef BOOST_NO_EXCEPTIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_EXCEPTIONS."
#endif
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_EXCEPTION_STD_NAMESPACE."
#endif
#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS."
#endif
#ifdef BOOST_NO_FENV_H
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_FENV_H."
#endif
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_FUNCTION_TEMPLATE_ORDERING."
#endif
#ifdef BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS."
#endif
#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_INCLASS_MEMBER_INITIALIZATION."
#endif
#ifdef BOOST_NO_INTEGRAL_INT64_T
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_INTEGRAL_INT64_T."
#endif
#ifdef BOOST_NO_INTRINSIC_WCHAR_T
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_INTRINSIC_WCHAR_T."
#endif
#ifdef BOOST_NO_IOSFWD
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_IOSFWD."
#endif
#ifdef BOOST_NO_IOSTREAM
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_IOSTREAM."
#endif
#ifdef BOOST_NO_IS_ABSTRACT
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_IS_ABSTRACT."
#endif
#ifdef BOOST_NO_LIMITS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_LIMITS."
#endif
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS."
#endif
#ifdef BOOST_NO_LONG_LONG
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_LONG_LONG."
#endif
#ifdef BOOST_NO_LONG_LONG_NUMERIC_LIMITS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_LONG_LONG_NUMERIC_LIMITS."
#endif
#ifdef BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS."
#endif
#ifdef BOOST_NO_MEMBER_TEMPLATES
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_MEMBER_TEMPLATES."
#endif
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_MEMBER_TEMPLATE_FRIENDS."
#endif
#ifdef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_MEMBER_TEMPLATE_KEYWORD."
#endif
#ifdef BOOST_NO_NESTED_FRIENDSHIP
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_NESTED_FRIENDSHIP."
#endif
#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_OPERATORS_IN_NAMESPACE."
#endif
#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS."
#endif
#ifdef BOOST_NO_POINTER_TO_MEMBER_CONST
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_POINTER_TO_MEMBER_CONST."
#endif
#ifdef BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS."
#endif
#ifdef BOOST_NO_PRIVATE_IN_AGGREGATE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_PRIVATE_IN_AGGREGATE."
#endif
#ifdef BOOST_NO_RESTRICT_REFERENCES
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_RESTRICT_REFERENCES."
#endif
#ifdef BOOST_NO_RTTI
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_RTTI."
#endif
#ifdef BOOST_NO_SFINAE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_SFINAE."
#endif
#ifdef BOOST_NO_SFINAE_EXPR
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_SFINAE_EXPR."
#endif
#ifdef BOOST_NO_STDC_NAMESPACE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STDC_NAMESPACE."
#endif
#ifdef BOOST_NO_STD_ALLOCATOR
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_ALLOCATOR."
#endif
#ifdef BOOST_NO_STD_DISTANCE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_DISTANCE."
#endif
#ifdef BOOST_NO_STD_ITERATOR
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_ITERATOR."
#endif
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_ITERATOR_TRAITS."
#endif
#ifdef BOOST_NO_STD_LOCALE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_LOCALE."
#endif
#ifdef BOOST_NO_STD_MESSAGES
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_MESSAGES."
#endif
#ifdef BOOST_NO_STD_MIN_MAX
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_MIN_MAX."
#endif
#ifdef BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN."
#endif
#ifdef BOOST_NO_STD_TYPEINFO
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_TYPEINFO."
#endif
#ifdef BOOST_NO_STD_USE_FACET
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_USE_FACET."
#endif
#ifdef BOOST_NO_STD_WSTREAMBUF
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_WSTREAMBUF."
#endif
#ifdef BOOST_NO_STD_WSTRING
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STD_WSTRING."
#endif
#ifdef BOOST_NO_STRINGSTREAM
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_STRINGSTREAM."
#endif
#ifdef BOOST_NO_TEMPLATED_IOSTREAMS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TEMPLATED_IOSTREAMS."
#endif
#ifdef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS."
#endif
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION."
#endif
#ifdef BOOST_NO_TEMPLATE_TEMPLATES
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TEMPLATE_TEMPLATES."
#endif
#ifdef BOOST_NO_TWO_PHASE_NAME_LOOKUP
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TWO_PHASE_NAME_LOOKUP."
#endif
#ifdef BOOST_NO_TYPEID
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TYPEID."
#endif
#ifdef BOOST_NO_TYPENAME_WITH_CTOR
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_TYPENAME_WITH_CTOR."
#endif
#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_UNREACHABLE_RETURN_DETECTION."
#endif
#ifdef BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE."
#endif
#ifdef BOOST_NO_USING_TEMPLATE
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_USING_TEMPLATE."
#endif
#ifdef BOOST_NO_VOID_RETURNS
#  error "Your compiler appears not to be fully C++03 compliant.  Detected via defect macro BOOST_NO_VOID_RETURNS."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx11.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>
#include <boost/config/assert_cxx03.hpp>

#ifdef BOOST_NO_CXX11_ADDRESSOF
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_ADDRESSOF."
#endif
#ifdef BOOST_NO_CXX11_ALIGNAS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_ALIGNAS."
#endif
#ifdef BOOST_NO_CXX11_ALLOCATOR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_ALLOCATOR."
#endif
#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_AUTO_DECLARATIONS."
#endif
#ifdef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS."
#endif
#ifdef BOOST_NO_CXX11_CHAR16_T
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_CHAR16_T."
#endif
#ifdef BOOST_NO_CXX11_CHAR32_T
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_CHAR32_T."
#endif
#ifdef BOOST_NO_CXX11_CONSTEXPR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_CONSTEXPR."
#endif
#ifdef BOOST_NO_CXX11_DECLTYPE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_DECLTYPE."
#endif
#ifdef BOOST_NO_CXX11_DECLTYPE_N3276
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_DECLTYPE_N3276."
#endif
#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_DEFAULTED_FUNCTIONS."
#endif
#ifdef BOOST_NO_CXX11_DEFAULTED_MOVES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_DEFAULTED_MOVES."
#endif
#ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_DELETED_FUNCTIONS."
#endif
#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS."
#endif
#ifdef BOOST_NO_CXX11_EXTERN_TEMPLATE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_EXTERN_TEMPLATE."
#endif
#ifdef BOOST_NO_CXX11_FINAL
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_FINAL."
#endif
#ifdef BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS."
#endif
#ifdef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS."
#endif
#ifdef BOOST_NO_CXX11_HDR_ARRAY
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_ARRAY."
#endif
#ifdef BOOST_NO_CXX11_HDR_ATOMIC
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_ATOMIC."
#endif
#ifdef BOOST_NO_CXX11_HDR_CHRONO
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_CHRONO."
#endif
#ifdef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_CONDITION_VARIABLE."
#endif
#ifdef BOOST_NO_CXX11_HDR_EXCEPTION
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_EXCEPTION."
#endif
#ifdef BOOST_NO_CXX11_HDR_FORWARD_LIST
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_FORWARD_LIST."
#endif
#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_FUNCTIONAL."
#endif
#ifdef BOOST_NO_CXX11_HDR_FUTURE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_FUTURE."
#endif
#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_INITIALIZER_LIST."
#endif
#ifdef BOOST_NO_CXX11_HDR_MUTEX
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_MUTEX."
#endif
#ifdef BOOST_NO_CXX11_HDR_RANDOM
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_RANDOM."
#endif
#ifdef BOOST_NO_CXX11_HDR_RATIO
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_RATIO."
#endif
#ifdef BOOST_NO_CXX11_HDR_REGEX
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_REGEX."
#endif
#ifdef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_SYSTEM_ERROR."
#endif
#ifdef BOOST_NO_CXX11_HDR_THREAD
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_THREAD."
#endif
#ifdef BOOST_NO_CXX11_HDR_TUPLE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_TUPLE."
#endif
#ifdef BOOST_NO_CXX11_HDR_TYPEINDEX
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_TYPEINDEX."
#endif
#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_TYPE_TRAITS."
#endif
#ifdef BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_UNORDERED_MAP."
#endif
#ifdef BOOST_NO_CXX11_HDR_UNORDERED_SET
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_HDR_UNORDERED_SET."
#endif
#ifdef BOOST_NO_CXX11_INLINE_NAMESPACES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_INLINE_NAMESPACES."
#endif
#ifdef BOOST_NO_CXX11_LAMBDAS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_LAMBDAS."
#endif
#ifdef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS."
#endif
#ifdef BOOST_NO_CXX11_NOEXCEPT
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_NOEXCEPT."
#endif
#ifdef BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS."
#endif
#ifdef BOOST_NO_CXX11_NULLPTR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_NULLPTR."
#endif
#ifdef BOOST_NO_CXX11_NUMERIC_LIMITS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_NUMERIC_LIMITS."
#endif
#ifdef BOOST_NO_CXX11_OVERRIDE
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_OVERRIDE."
#endif
#ifdef BOOST_NO_CXX11_POINTER_TRAITS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_POINTER_TRAITS."
#endif
#ifdef BOOST_NO_CXX11_RANGE_BASED_FOR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_RANGE_BASED_FOR."
#endif
#ifdef BOOST_NO_CXX11_RAW_LITERALS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_RAW_LITERALS."
#endif
#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_REF_QUALIFIERS."
#endif
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_RVALUE_REFERENCES."
#endif
#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_SCOPED_ENUMS."
#endif
#ifdef BOOST_NO_CXX11_SFINAE_EXPR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_SFINAE_EXPR."
#endif
#ifdef BOOST_NO_CXX11_SMART_PTR
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_SMART_PTR."
#endif
#ifdef BOOST_NO_CXX11_STATIC_ASSERT
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_STATIC_ASSERT."
#endif
#ifdef BOOST_NO_CXX11_STD_ALIGN
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_STD_ALIGN."
#endif
#ifdef BOOST_NO_CXX11_TEMPLATE_ALIASES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_TEMPLATE_ALIASES."
#endif
#ifdef BOOST_NO_CXX11_THREAD_LOCAL
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_THREAD_LOCAL."
#endif
#ifdef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_TRAILING_RESULT_TYPES."
#endif
#ifdef BOOST_NO_CXX11_UNICODE_LITERALS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_UNICODE_LITERALS."
#endif
#ifdef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX."
#endif
#ifdef BOOST_NO_CXX11_UNRESTRICTED_UNION
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_UNRESTRICTED_UNION."
#endif
#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_USER_DEFINED_LITERALS."
#endif
#ifdef BOOST_NO_CXX11_VARIADIC_MACROS
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_VARIADIC_MACROS."
#endif
#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#  error "Your compiler appears not to be fully C++11 compliant.  Detected via defect macro BOOST_NO_CXX11_VARIADIC_TEMPLATES."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx14.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>
#include <boost/config/assert_cxx11.hpp>

#ifdef BOOST_NO_CXX14_AGGREGATE_NSDMI
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_AGGREGATE_NSDMI."
#endif
#ifdef BOOST_NO_CXX14_BINARY_LITERALS
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_BINARY_LITERALS."
#endif
#ifdef BOOST_NO_CXX14_CONSTEXPR
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_CONSTEXPR."
#endif
#ifdef BOOST_NO_CXX14_DECLTYPE_AUTO
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_DECLTYPE_AUTO."
#endif
#ifdef BOOST_NO_CXX14_DIGIT_SEPARATORS
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_DIGIT_SEPARATORS."
#endif
#ifdef BOOST_NO_CXX14_GENERIC_LAMBDAS
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_GENERIC_LAMBDAS."
#endif
#ifdef BOOST_NO_CXX14_HDR_SHARED_MUTEX
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_HDR_SHARED_MUTEX."
#endif
#ifdef BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES."
#endif
#ifdef BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION."
#endif
#ifdef BOOST_NO_CXX14_STD_EXCHANGE
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_STD_EXCHANGE."
#endif
#ifdef BOOST_NO_CXX14_VARIABLE_TEMPLATES
#  error "Your compiler appears not to be fully C++14 compliant.  Detected via defect macro BOOST_NO_CXX14_VARIABLE_TEMPLATES."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx17.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>
#include <boost/config/assert_cxx14.hpp>

#ifdef BOOST_NO_CXX17_DEDUCTION_GUIDES
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_DEDUCTION_GUIDES."
#endif
#ifdef BOOST_NO_CXX17_FOLD_EXPRESSIONS
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_FOLD_EXPRESSIONS."
#endif
#ifdef BOOST_NO_CXX17_HDR_ANY
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_ANY."
#endif
#ifdef BOOST_NO_CXX17_HDR_CHARCONV
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_CHARCONV."
#endif
#ifdef BOOST_NO_CXX17_HDR_EXECUTION
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_EXECUTION."
#endif
#ifdef BOOST_NO_CXX17_HDR_FILESYSTEM
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_FILESYSTEM."
#endif
#ifdef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_MEMORY_RESOURCE."
#endif
#ifdef BOOST_NO_CXX17_HDR_OPTIONAL
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_OPTIONAL."
#endif
#ifdef BOOST_NO_CXX17_HDR_STRING_VIEW
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_STRING_VIEW."
#endif
#ifdef BOOST_NO_CXX17_HDR_VARIANT
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_HDR_VARIANT."
#endif
#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_IF_CONSTEXPR."
#endif
#ifdef BOOST_NO_CXX17_INLINE_VARIABLES
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_INLINE_VARIABLES."
#endif
#ifdef BOOST_NO_CXX17_ITERATOR_TRAITS
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_ITERATOR_TRAITS."
#endif
#ifdef BOOST_NO_CXX17_STD_APPLY
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_STD_APPLY."
#endif
#ifdef BOOST_NO_CXX17_STD_INVOKE
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_STD_INVOKE."
#endif
#ifdef BOOST_NO_CXX17_STRUCTURED_BINDINGS
#  error "Your compiler appears not to be fully C++17 compliant.  Detected via defect macro BOOST_NO_CXX17_STRUCTURED_BINDINGS."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx20.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>
#include <boost/config/assert_cxx17.hpp>

#ifdef BOOST_NO_CXX20_HDR_BARRIER
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_BARRIER."
#endif
#ifdef BOOST_NO_CXX20_HDR_BIT
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_BIT."
#endif
#ifdef BOOST_NO_CXX20_HDR_COMPARE
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_COMPARE."
#endif
#ifdef BOOST_NO_CXX20_HDR_CONCEPTS
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_CONCEPTS."
#endif
#ifdef BOOST_NO_CXX20_HDR_COROUTINE
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_COROUTINE."
#endif
#ifdef BOOST_NO_CXX20_HDR_FORMAT
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_FORMAT."
#endif
#ifdef BOOST_NO_CXX20_HDR_LATCH
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_LATCH."
#endif
#ifdef BOOST_NO_CXX20_HDR_NUMBERS
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_NUMBERS."
#endif
#ifdef BOOST_NO_CXX20_HDR_RANGES
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_RANGES."
#endif
#ifdef BOOST_NO_CXX20_HDR_SEMAPHORE
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_SEMAPHORE."
#endif
#ifdef BOOST_NO_CXX20_HDR_SOURCE_LOCATION
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_SOURCE_LOCATION."
#endif
#ifdef BOOST_NO_CXX20_HDR_SPAN
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_SPAN."
#endif
#ifdef BOOST_NO_CXX20_HDR_STOP_TOKEN
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_STOP_TOKEN."
#endif
#ifdef BOOST_NO_CXX20_HDR_SYNCSTREAM
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_SYNCSTREAM."
#endif
#ifdef BOOST_NO_CXX20_HDR_VERSION
#  error "Your compiler appears not to be fully C++20 compliant.  Detected via defect macro BOOST_NO_CXX20_HDR_VERSION."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/assert_cxx98.hpp
================================================
//  This file was automatically generated on Wed Mar  3 08:46:11 2021
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-4.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#include <boost/config.hpp>
#include <boost/config/assert_cxx17.hpp>

#ifdef BOOST_NO_CXX98_BINDERS
#  error "Your compiler appears not to be fully C++98 compliant.  Detected via defect macro BOOST_NO_CXX98_BINDERS."
#endif
#ifdef BOOST_NO_CXX98_FUNCTION_BASE
#  error "Your compiler appears not to be fully C++98 compliant.  Detected via defect macro BOOST_NO_CXX98_FUNCTION_BASE."
#endif
#ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE
#  error "Your compiler appears not to be fully C++98 compliant.  Detected via defect macro BOOST_NO_CXX98_RANDOM_SHUFFLE."
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/auto_link.hpp
================================================
//  (C) Copyright John Maddock 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 /*
  *   LOCATION:    see http://www.boost.org for most recent version.
  *   FILE         auto_link.hpp
  *   VERSION      see <boost/version.hpp>
  *   DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers.
  */

/*************************************************************************

USAGE:
~~~~~~

Before including this header you must define one or more of define the following macros:

BOOST_LIB_NAME:           Required: A string containing the basename of the library,
                          for example boost_regex.
BOOST_LIB_TOOLSET:        Optional: the base name of the toolset.
BOOST_DYN_LINK:           Optional: when set link to dll rather than static library.
BOOST_LIB_DIAGNOSTIC:     Optional: when set the header will print out the name
                          of the library selected (useful for debugging).
BOOST_AUTO_LINK_NOMANGLE: Specifies that we should link to BOOST_LIB_NAME.lib,
                          rather than a mangled-name version.
BOOST_AUTO_LINK_TAGGED:   Specifies that we link to libraries built with the --layout=tagged option.
                          This is essentially the same as the default name-mangled version, but without
                          the compiler name and version, or the Boost version.  Just the build options.
BOOST_AUTO_LINK_SYSTEM:   Specifies that we link to libraries built with the --layout=system option.
                          This is essentially the same as the non-name-mangled version, but with
                          the prefix to differentiate static and dll builds

These macros will be undef'ed at the end of the header, further this header
has no include guards - so be sure to include it only once from your library!

Algorithm:
~~~~~~~~~~

Libraries for Borland and Microsoft compilers are automatically
selected here, the name of the lib is selected according to the following
formula:

BOOST_LIB_PREFIX
   + BOOST_LIB_NAME
   + "_"
   + BOOST_LIB_TOOLSET
   + BOOST_LIB_THREAD_OPT
   + BOOST_LIB_RT_OPT
   + BOOST_LIB_ARCH_AND_MODEL_OPT
   "-"
   + BOOST_LIB_VERSION
   + BOOST_LIB_SUFFIX

These are defined as:

BOOST_LIB_PREFIX:     "lib" for static libraries otherwise "".

BOOST_LIB_NAME:       The base name of the lib ( for example boost_regex).

BOOST_LIB_TOOLSET:    The compiler toolset name (vc6, vc7, bcb5 etc).

BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing.

BOOST_LIB_RT_OPT:     A suffix that indicates the runtime library used,
                      contains one or more of the following letters after
                      a hyphen:

                      s      static runtime (dynamic if not present).
                      g      debug/diagnostic runtime (release if not present).
                      y      Python debug/diagnostic runtime (release if not present).
                      d      debug build (release if not present).
                      p      STLport build.
                      n      STLport build without its IOStreams.

BOOST_LIB_ARCH_AND_MODEL_OPT: The architecture and address model
                              (-x32 or -x64 for x86/32 and x86/64 respectively)

BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.

BOOST_LIB_SUFFIX:     Static/import libraries extension (".lib", ".a") for the compiler.

***************************************************************************/

#ifdef __cplusplus
#  ifndef BOOST_CONFIG_HPP
#     include <boost/config.hpp>
#  endif
#elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__)
//
// C language compatability (no, honestly)
//
#  define BOOST_MSVC _MSC_VER
#  define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#  define BOOST_DO_STRINGIZE(X) #X
#endif
//
// Only include what follows for known and supported compilers:
//
#if defined(BOOST_MSVC) \
    || defined(BOOST_EMBTC_WINDOWS) \
    || defined(BOOST_BORLANDC) \
    || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
    || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) \
    || (defined(BOOST_CLANG) && defined(BOOST_WINDOWS) && defined(_MSC_VER) && (__clang_major__ >= 4))

#ifndef BOOST_VERSION_HPP
#  include <boost/version.hpp>
#endif

#ifndef BOOST_LIB_NAME
#  error "Macro BOOST_LIB_NAME not set (internal error)"
#endif

//
// error check:
//
#if defined(__MSVC_RUNTIME_CHECKS) && !defined(_DEBUG)
#  pragma message("Using the /RTC option without specifying a debug runtime will lead to linker errors")
#  pragma message("Hint: go to the code generation options and switch to one of the debugging runtimes")
#  error "Incompatible build options"
#endif
//
// select toolset if not defined already:
//
#ifndef BOOST_LIB_TOOLSET
#  if defined(BOOST_MSVC) && (BOOST_MSVC < 1200)
    // Note: no compilers before 1200 are supported
#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1300)

#    ifdef UNDER_CE
       // eVC4:
#      define BOOST_LIB_TOOLSET "evc4"
#    else
       // vc6:
#      define BOOST_LIB_TOOLSET "vc6"
#    endif

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1310)

     // vc7:
#    define BOOST_LIB_TOOLSET "vc7"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1400)

     // vc71:
#    define BOOST_LIB_TOOLSET "vc71"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1500)

     // vc80:
#    define BOOST_LIB_TOOLSET "vc80"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1600)

     // vc90:
#    define BOOST_LIB_TOOLSET "vc90"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1700)

     // vc10:
#    define BOOST_LIB_TOOLSET "vc100"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)

     // vc11:
#    define BOOST_LIB_TOOLSET "vc110"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1900)

     // vc12:
#    define BOOST_LIB_TOOLSET "vc120"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1910)

     // vc14:
#    define BOOST_LIB_TOOLSET "vc140"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1920)

     // vc14.1:
#    define BOOST_LIB_TOOLSET "vc141"

#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1930)

     // vc14.2:
#    define BOOST_LIB_TOOLSET "vc142"

#  elif defined(BOOST_MSVC)

     // vc14.3:
#    define BOOST_LIB_TOOLSET "vc143"

#  elif defined(BOOST_EMBTC_WINDOWS)

     // Embarcadero Clang based compilers:
#    define BOOST_LIB_TOOLSET "embtc"

#  elif defined(BOOST_BORLANDC)

     // CBuilder 6:
#    define BOOST_LIB_TOOLSET "bcb"

#  elif defined(__ICL)

     // Intel C++, no version number:
#    define BOOST_LIB_TOOLSET "iw"

#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF )

     // Metrowerks CodeWarrior 8.x
#    define BOOST_LIB_TOOLSET "cw8"

#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF )

     // Metrowerks CodeWarrior 9.x
#    define BOOST_LIB_TOOLSET "cw9"

#  elif defined(BOOST_CLANG) && defined(BOOST_WINDOWS) && defined(_MSC_VER) && (__clang_major__ >= 4)

     // Clang on Windows
#    define BOOST_LIB_TOOLSET "clangw" BOOST_STRINGIZE(__clang_major__)

#  endif
#endif // BOOST_LIB_TOOLSET

//
// select thread opt:
//
#if defined(_MT) || defined(__MT__)
#  define BOOST_LIB_THREAD_OPT "-mt"
#else
#  define BOOST_LIB_THREAD_OPT
#endif

#if defined(_MSC_VER) || defined(__MWERKS__)

#  ifdef _DLL

#     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))

#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-gydp"
#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
#            define BOOST_LIB_RT_OPT "-gdp"
#        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-gydp"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        elif defined(_DEBUG)
#            define BOOST_LIB_RT_OPT "-gdp"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        else
#            define BOOST_LIB_RT_OPT "-p"
#        endif

#     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)

#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-gydpn"
#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
#            define BOOST_LIB_RT_OPT "-gdpn"
#        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-gydpn"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        elif defined(_DEBUG)
#            define BOOST_LIB_RT_OPT "-gdpn"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        else
#            define BOOST_LIB_RT_OPT "-pn"
#        endif

#     else

#        if defined(_DEBUG) && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-gyd"
#        elif defined(_DEBUG)
#            define BOOST_LIB_RT_OPT "-gd"
#        else
#            define BOOST_LIB_RT_OPT
#        endif

#     endif

#  else

#     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))

#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-sgydp"
#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
#            define BOOST_LIB_RT_OPT "-sgdp"
#        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#             define BOOST_LIB_RT_OPT "-sgydp"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        elif defined(_DEBUG)
#             define BOOST_LIB_RT_OPT "-sgdp"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        else
#            define BOOST_LIB_RT_OPT "-sp"
#        endif

#     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)

#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#            define BOOST_LIB_RT_OPT "-sgydpn"
#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
#            define BOOST_LIB_RT_OPT "-sgdpn"
#        elif defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#             define BOOST_LIB_RT_OPT "-sgydpn"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        elif defined(_DEBUG)
#             define BOOST_LIB_RT_OPT "-sgdpn"
#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
#            error "Build options aren't compatible with pre-built libraries"
#        else
#            define BOOST_LIB_RT_OPT "-spn"
#        endif

#     else

#        if defined(_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#             define BOOST_LIB_RT_OPT "-sgyd"
#        elif defined(_DEBUG)
#             define BOOST_LIB_RT_OPT "-sgd"
#        else
#            define BOOST_LIB_RT_OPT "-s"
#        endif

#     endif

#  endif

#elif defined(BOOST_EMBTC_WINDOWS)

#  ifdef _RTLDLL

#     if defined(_DEBUG)
#         define BOOST_LIB_RT_OPT "-d"
#     else
#         define BOOST_LIB_RT_OPT
#     endif

#  else

#     if defined(_DEBUG)
#         define BOOST_LIB_RT_OPT "-sd"
#     else
#         define BOOST_LIB_RT_OPT "-s"
#     endif

#  endif

#elif defined(BOOST_BORLANDC)

//
// figure out whether we want the debug builds or not:
//
#if BOOST_BORLANDC > 0x561
#pragma defineonoption BOOST_BORLAND_DEBUG -v
#endif
//
// sanity check:
//
#if defined(__STL_DEBUG) || defined(_STLP_DEBUG)
#error "Pre-built versions of the Boost libraries are not provided in STLport-debug form"
#endif

#  ifdef _RTLDLL

#     if defined(BOOST_BORLAND_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#         define BOOST_LIB_RT_OPT "-yd"
#     elif defined(BOOST_BORLAND_DEBUG)
#         define BOOST_LIB_RT_OPT "-d"
#     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#         define BOOST_LIB_RT_OPT "-y"
#     else
#         define BOOST_LIB_RT_OPT
#     endif

#  else

#     if defined(BOOST_BORLAND_DEBUG)\
               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#         define BOOST_LIB_RT_OPT "-syd"
#     elif defined(BOOST_BORLAND_DEBUG)
#         define BOOST_LIB_RT_OPT "-sd"
#     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
#         define BOOST_LIB_RT_OPT "-sy"
#     else
#         define BOOST_LIB_RT_OPT "-s"
#     endif

#  endif

#endif

//
// BOOST_LIB_ARCH_AND_MODEL_OPT
//

#if defined( _M_IX86 )
#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-x32"
#elif defined( _M_X64 )
#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-x64"
#elif defined( _M_ARM )
#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-a32"
#elif defined( _M_ARM64 )
#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-a64"
#endif

//
// select linkage opt:
//
#if (defined(_DLL) || defined(_RTLDLL)) && defined(BOOST_DYN_LINK)
#  define BOOST_LIB_PREFIX
#elif defined(BOOST_DYN_LINK)
#  error "Mixing a dll boost library with a static runtime is a really bad idea..."
#else
#  define BOOST_LIB_PREFIX "lib"
#endif

//
// now include the lib:
//
#if defined(BOOST_LIB_NAME) \
      && defined(BOOST_LIB_PREFIX) \
      && defined(BOOST_LIB_TOOLSET) \
      && defined(BOOST_LIB_THREAD_OPT) \
      && defined(BOOST_LIB_RT_OPT) \
      && defined(BOOST_LIB_ARCH_AND_MODEL_OPT) \
      && defined(BOOST_LIB_VERSION)

#if defined(BOOST_EMBTC_WIN64)
#  define BOOST_LIB_SUFFIX ".a"
#else
#  define BOOST_LIB_SUFFIX ".lib"
#endif

#ifdef BOOST_AUTO_LINK_NOMANGLE
#  pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
#  ifdef BOOST_LIB_DIAGNOSTIC
#     pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
#  endif
#elif defined(BOOST_AUTO_LINK_TAGGED)
#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT BOOST_LIB_SUFFIX)
#  ifdef BOOST_LIB_DIAGNOSTIC
#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT BOOST_LIB_SUFFIX)
#  endif
#elif defined(BOOST_AUTO_LINK_SYSTEM)
#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
#  ifdef BOOST_LIB_DIAGNOSTIC
#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_SUFFIX)
#  endif
#elif defined(BOOST_LIB_BUILDID)
#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) BOOST_LIB_SUFFIX)
#  ifdef BOOST_LIB_DIAGNOSTIC
#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) BOOST_LIB_SUFFIX)
#  endif
#else
#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION BOOST_LIB_SUFFIX)
#  ifdef BOOST_LIB_DIAGNOSTIC
#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION BOOST_LIB_SUFFIX)
#  endif
#endif

#else
#  error "some required macros where not defined (internal logic error)."
#endif


#endif // _MSC_VER || __BORLANDC__

//
// finally undef any macros we may have set:
//
#ifdef BOOST_LIB_PREFIX
#  undef BOOST_LIB_PREFIX
#endif
#if defined(BOOST_LIB_NAME)
#  undef BOOST_LIB_NAME
#endif
// Don't undef this one: it can be set by the user and should be the 
// same for all libraries:
//#if defined(BOOST_LIB_TOOLSET)
//#  undef BOOST_LIB_TOOLSET
//#endif
#if defined(BOOST_LIB_THREAD_OPT)
#  undef BOOST_LIB_THREAD_OPT
#endif
#if defined(BOOST_LIB_RT_OPT)
#  undef BOOST_LIB_RT_OPT
#endif
#if defined(BOOST_LIB_ARCH_AND_MODEL_OPT)
#  undef BOOST_LIB_ARCH_AND_MODEL_OPT
#endif
#if defined(BOOST_LIB_LINK_OPT)
#  undef BOOST_LIB_LINK_OPT
#endif
#if defined(BOOST_LIB_DEBUG_OPT)
#  undef BOOST_LIB_DEBUG_OPT
#endif
#if defined(BOOST_DYN_LINK)
#  undef BOOST_DYN_LINK
#endif
#if defined(BOOST_LIB_SUFFIX)
#  undef BOOST_LIB_SUFFIX
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/borland.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Borland C++ compiler setup:

//
// versions check:
// we don't support Borland prior to version 5.4:
#if __BORLANDC__ < 0x540
#  error "Compiler not supported or configured - please reconfigure"
#endif

// last known compiler version:
#if (__BORLANDC__ > 0x613)
//#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
//#  else
//#     pragma message( "boost: Unknown compiler version - please run the configure tests and report the results")
//#  endif
#elif (__BORLANDC__ == 0x600)
#  error "CBuilderX preview compiler is no longer supported"
#endif

//
// Support macros to help with standard library detection
#if (__BORLANDC__ < 0x560) || defined(_USE_OLD_RW_STL)
#  define BOOST_BCB_WITH_ROGUE_WAVE
#elif __BORLANDC__ < 0x570
#  define BOOST_BCB_WITH_STLPORT
#else
#  define BOOST_BCB_WITH_DINKUMWARE
#endif

//
// Version 5.0 and below:
#   if __BORLANDC__ <= 0x0550
// Borland C++Builder 4 and 5:
#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#     if __BORLANDC__ == 0x0550
// Borland C++Builder 5, command-line compiler 5.5:
#       define BOOST_NO_OPERATORS_IN_NAMESPACE
#     endif
// Variadic macros do not exist for C++ Builder versions 5 and below
#define BOOST_NO_CXX11_VARIADIC_MACROS
#   endif

// Version 5.51 and below:
#if (__BORLANDC__ <= 0x551)
#  define BOOST_NO_CV_SPECIALIZATIONS
#  define BOOST_NO_CV_VOID_SPECIALIZATIONS
#  define BOOST_NO_DEDUCED_TYPENAME
// workaround for missing WCHAR_MAX/WCHAR_MIN:
#ifdef __cplusplus
#include <climits>
#include <cwchar>
#else
#include <limits.h>
#include <wchar.h>
#endif // __cplusplus
#ifndef WCHAR_MAX
#  define WCHAR_MAX 0xffff
#endif
#ifndef WCHAR_MIN
#  define WCHAR_MIN 0
#endif
#endif

// Borland C++ Builder 6 and below:
#if (__BORLANDC__ <= 0x564)

#  if defined(NDEBUG) && defined(__cplusplus)
      // fix broken <cstring> so that Boost.test works:
#     include <cstring>
#     undef strcmp
#  endif
   // fix broken errno declaration:
#  include <errno.h>
#  ifndef errno
#     define errno errno
#  endif

#endif

//
// new bug in 5.61:
#if (__BORLANDC__ >= 0x561) && (__BORLANDC__ <= 0x580)
   // this seems to be needed by the command line compiler, but not the IDE:
#  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
#endif

// Borland C++ Builder 2006 Update 2 and below:
#if (__BORLANDC__ <= 0x582)
#  define BOOST_NO_SFINAE
#  define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#  define BOOST_NO_TEMPLATE_TEMPLATES

#  define BOOST_NO_PRIVATE_IN_AGGREGATE

#  ifdef _WIN32
#     define BOOST_NO_SWPRINTF
#  elif defined(linux) || defined(__linux__) || defined(__linux)
      // we should really be able to do without this
      // but the wcs* functions aren't imported into std::
#     define BOOST_NO_STDC_NAMESPACE
      // _CPPUNWIND doesn't get automatically set for some reason:
#     pragma defineonoption BOOST_CPPUNWIND -x
#  endif
#endif

#if (__BORLANDC__ <= 0x613)  // Beman has asked Alisdair for more info
   // we shouldn't really need this - but too many things choke
   // without it, this needs more investigation:
#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#  define BOOST_NO_IS_ABSTRACT
#  define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
#  define BOOST_NO_USING_TEMPLATE
#  define BOOST_SP_NO_SP_CONVERTIBLE

// Temporary workaround
#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
#endif

// Borland C++ Builder 2008 and below:
#  define BOOST_NO_INTEGRAL_INT64_T
#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
#  define BOOST_NO_NESTED_FRIENDSHIP
#  define BOOST_NO_TYPENAME_WITH_CTOR
#if (__BORLANDC__ < 0x600)
#  define BOOST_ILLEGAL_CV_REFERENCES
#endif

//
//  Positive Feature detection
//
// Borland C++ Builder 2008 and below:
#if (__BORLANDC__ >= 0x599)
#  pragma defineonoption BOOST_CODEGEAR_0X_SUPPORT -Ax
#endif
//
// C++0x Macros:
//
#if !defined( BOOST_CODEGEAR_0X_SUPPORT ) || (__BORLANDC__ < 0x610)
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#  define BOOST_NO_CXX11_DECLTYPE
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#  define BOOST_NO_CXX11_STATIC_ASSERT
#else
#  define BOOST_HAS_ALIGNOF
#  define BOOST_HAS_CHAR16_T
#  define BOOST_HAS_CHAR32_T
#  define BOOST_HAS_DECLTYPE
#  define BOOST_HAS_EXPLICIT_CONVERSION_OPS
#  define BOOST_HAS_REF_QUALIFIER
#  define BOOST_HAS_RVALUE_REFS
#  define BOOST_HAS_STATIC_ASSERT
#endif

#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DEFAULTED_MOVES
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS    // UTF-8 still not supported
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#if __BORLANDC__ >= 0x590
#  define BOOST_HAS_TR1_HASH

#  define BOOST_HAS_MACRO_USE_FACET
#endif

//
// Post 0x561 we have long long and stdint.h:
#if __BORLANDC__ >= 0x561
#  ifndef __NO_LONG_LONG
#     define BOOST_HAS_LONG_LONG
#  else
#     define BOOST_NO_LONG_LONG
#  endif
   // On non-Win32 platforms let the platform config figure this out:
#  ifdef _WIN32
#      define BOOST_HAS_STDINT_H
#  endif
#endif

// Borland C++Builder 6 defaults to using STLPort.  If _USE_OLD_RW_STL is
// defined, then we have 0x560 or greater with the Rogue Wave implementation
// which presumably has the std::DBL_MAX bug.
#if defined( BOOST_BCB_WITH_ROGUE_WAVE )
// <climits> is partly broken, some macros define symbols that are really in
// namespace std, so you end up having to use illegal constructs like
// std::DBL_MAX, as a fix we'll just include float.h and have done with:
#include <float.h>
#endif
//
// __int64:
//
#if (__BORLANDC__ >= 0x530) && !defined(__STRICT_ANSI__)
#  define BOOST_HAS_MS_INT64
#endif
//
// check for exception handling support:
//
#if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif
//
// all versions have a <dirent.h>:
//
#ifndef __STRICT_ANSI__
#  define BOOST_HAS_DIRENT_H
#endif
//
// all versions support __declspec:
//
#if defined(__STRICT_ANSI__)
// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
#  define BOOST_SYMBOL_EXPORT
#endif
//
// ABI fixing headers:
//
#if __BORLANDC__ != 0x600 // not implemented for version 6 compiler yet
#ifndef BOOST_ABI_PREFIX
#  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
#endif
#ifndef BOOST_ABI_SUFFIX
#  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
#endif
#endif
//
// Disable Win32 support in ANSI mode:
//
#if __BORLANDC__ < 0x600
#  pragma defineonoption BOOST_DISABLE_WIN32 -A
#elif defined(__STRICT_ANSI__)
#  define BOOST_DISABLE_WIN32
#endif
//
// MSVC compatibility mode does some nasty things:
// TODO: look up if this doesn't apply to the whole 12xx range
//
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
#  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#  define BOOST_NO_VOID_RETURNS
#endif

// Borland did not implement value-initialization completely, as I reported
// in 2007, Borland Report 51854, "Value-initialization: POD struct should be
// zero-initialized", http://qc.embarcadero.com/wc/qcmain.aspx?d=51854
// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
// (Niels Dekker, LKEB, April 2010)
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION

#define BOOST_BORLANDC __BORLANDC__
#define BOOST_COMPILER "Classic Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/clang.hpp
================================================
// (C) Copyright Douglas Gregor 2010
//
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

// Clang compiler setup.

#define BOOST_HAS_PRAGMA_ONCE

// Detecting `-fms-extension` compiler flag assuming that _MSC_VER defined when that flag is used.
#if defined (_MSC_VER) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))
#   define BOOST_HAS_PRAGMA_DETECT_MISMATCH
#endif

// When compiling with clang before __has_extension was defined,
// even if one writes 'defined(__has_extension) && __has_extension(xxx)',
// clang reports a compiler error. So the only workaround found is:

#ifndef __has_extension
#define __has_extension __has_feature
#endif

#ifndef __has_attribute
#define __has_attribute(x) 0
#endif

#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) 0
#endif

#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_RTTI)
#  define BOOST_NO_RTTI
#endif

#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_TYPEID)
#  define BOOST_NO_TYPEID
#endif

#if !__has_feature(cxx_thread_local)
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif

#ifdef __is_identifier
#if !__is_identifier(__int64) && !defined(__GNUC__)
#  define BOOST_HAS_MS_INT64
#endif
#endif

#if __has_include(<stdint.h>)
#  define BOOST_HAS_STDINT_H
#endif

#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
#if (__clang_major__ >= 4) && defined(__has_include)
#if __has_include(<quadmath.h>)
#  define BOOST_HAS_FLOAT128
#endif
#endif
#endif


#define BOOST_HAS_NRVO

// Branch prediction hints
#if !defined (__c2__) && defined(__has_builtin)
#if __has_builtin(__builtin_expect)
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#endif
#endif

// Clang supports "long long" in all compilation modes.
#define BOOST_HAS_LONG_LONG

//
// We disable this if the compiler is really nvcc with C++03 as it
// doesn't actually support __int128 as of CUDA_VERSION=7500
// even though it defines __SIZEOF_INT128__.
// See https://svn.boost.org/trac/boost/ticket/10418
//     https://svn.boost.org/trac/boost/ticket/11852
// Only re-enable this for nvcc if you're absolutely sure
// of the circumstances under which it's supported.
// Similarly __SIZEOF_INT128__ is defined when targetting msvc
// compatibility even though the required support functions are absent.
//
#if defined(__CUDACC__)
#  if defined(BOOST_GCC_CXX11)
#    define BOOST_NVCC_CXX11
#  else
#    define BOOST_NVCC_CXX03
#  endif
#endif

#if defined(__SIZEOF_INT128__) && !defined(BOOST_NVCC_CXX03) && !defined(_MSC_VER)
#  define BOOST_HAS_INT128
#endif


//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
#  define BOOST_HAS_DECLSPEC
#  define BOOST_SYMBOL_EXPORT __attribute__((__dllexport__))
#  define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__))
#else
#  define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#  define BOOST_SYMBOL_IMPORT
#endif

//
// The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
// between switch labels.
//
#if __cplusplus >= 201103L && defined(__has_warning)
#  if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
#    define BOOST_FALLTHROUGH [[clang::fallthrough]]
#  endif
#endif

#if !__has_feature(cxx_auto_type)
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#endif

//
// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t
//
#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#endif

#if defined(_MSC_VER) && (_MSC_VER >= 1800) && !defined(__GNUC__)
#define BOOST_HAS_EXPM1
#define BOOST_HAS_LOG1P
#endif

#if !__has_feature(cxx_constexpr)
#  define BOOST_NO_CXX11_CONSTEXPR
#endif

#if !__has_feature(cxx_decltype)
#  define BOOST_NO_CXX11_DECLTYPE
#endif

#if !__has_feature(cxx_decltype_incomplete_return_types)
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#endif

#if !__has_feature(cxx_defaulted_functions)
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#endif

#if !__has_feature(cxx_deleted_functions)
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#endif

#if !__has_feature(cxx_explicit_conversions)
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#endif

#if !__has_feature(cxx_default_function_template_args)
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif

#if !__has_feature(cxx_generalized_initializers)
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#endif

#if !__has_feature(cxx_lambdas)
#  define BOOST_NO_CXX11_LAMBDAS
#endif

#if !__has_feature(cxx_local_type_template_args)
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#endif

#if !__has_feature(cxx_noexcept)
#  define BOOST_NO_CXX11_NOEXCEPT
#endif

#if !__has_feature(cxx_nullptr)
#  define BOOST_NO_CXX11_NULLPTR
#endif

#if !__has_feature(cxx_range_for)
#  define BOOST_NO_CXX11_RANGE_BASED_FOR
#endif

#if !__has_feature(cxx_raw_string_literals)
#  define BOOST_NO_CXX11_RAW_LITERALS
#endif

#if !__has_feature(cxx_reference_qualified_functions)
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#endif

#if !__has_feature(cxx_generalized_initializers)
#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif

#if !__has_feature(cxx_rvalue_references)
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#endif

#if !__has_feature(cxx_strong_enums)
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#endif

#if !__has_feature(cxx_static_assert)
#  define BOOST_NO_CXX11_STATIC_ASSERT
#endif

#if !__has_feature(cxx_alias_templates)
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#endif

#if !__has_feature(cxx_unicode_literals)
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#endif

#if !__has_feature(cxx_variadic_templates)
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif

#if !__has_feature(cxx_user_literals)
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#endif

#if !__has_feature(cxx_alignas)
#  define BOOST_NO_CXX11_ALIGNAS
#endif

#if !__has_feature(cxx_trailing_return)
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#endif

#if !__has_feature(cxx_inline_namespaces)
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#endif

#if !__has_feature(cxx_override_control)
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_OVERRIDE
#endif

#if !__has_feature(cxx_unrestricted_unions)
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif

#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif

#if !__has_feature(__cxx_decltype_auto__)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif

#if !__has_feature(__cxx_aggregate_nsdmi__)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif

#if !__has_feature(__cxx_init_captures__)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif

#if !__has_feature(__cxx_generic_lambdas__)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif

// clang < 3.5 has a defect with dependent type, like following.
//
//  template <class T>
//  constexpr typename enable_if<pred<T> >::type foo(T &)
//  { } // error: no return statement in constexpr function
//
// This issue also affects C++11 mode, but C++11 constexpr requires return stmt.
// Therefore we don't care such case.
//
// Note that we can't check Clang version directly as the numbering system changes depending who's
// creating the Clang release (see https://github.com/boostorg/config/pull/39#issuecomment-59927873)
// so instead verify that we have a feature that was introduced at the same time as working C++14
// constexpr (generic lambda's in this case):
//
#if !__has_feature(__cxx_generic_lambdas__) || !__has_feature(__cxx_relaxed_constexpr__)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif

#if !__has_feature(__cxx_return_type_deduction__)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif

#if !__has_feature(__cxx_variable_templates__)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif

#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

// Clang 3.9+ in c++1z
#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif

#if __cplusplus < 201103L
#define BOOST_NO_CXX11_SFINAE_EXPR
#endif

#if __cplusplus < 201400
// All versions with __cplusplus above this value seem to support this:
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif

// Unreachable code markup
#if defined(__has_builtin)
#if __has_builtin(__builtin_unreachable)
#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
#endif
#endif

// Deprecated symbol markup
#if __has_attribute(deprecated)
#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
#endif

#if (__clang_major__ == 3) && (__clang_minor__ == 0)
// Apparently a clang bug:
#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#endif

// Clang has supported the 'unused' attribute since the first release.
#define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))

// Type aliasing hint.
#if __has_attribute(__may_alias__)
#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
#endif

#ifndef BOOST_COMPILER
#  define BOOST_COMPILER "Clang version " __clang_version__
#endif

// Macro used to identify the Clang compiler.
#define BOOST_CLANG 1

// BOOST_CLANG_VERSION
#include <boost/config/compiler/clang_version.hpp>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/clang_version.hpp
================================================
// Copyright 2021 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt)

#if !defined(__APPLE__)

# define BOOST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ % 100)

#else
# define BOOST_CLANG_REPORTED_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__ % 100)

// https://en.wikipedia.org/wiki/Xcode#Toolchain_versions

# if BOOST_CLANG_REPORTED_VERSION >= 140000
#   define BOOST_CLANG_VERSION 140000

# elif BOOST_CLANG_REPORTED_VERSION >= 130100
#   define BOOST_CLANG_VERSION 130000

# elif BOOST_CLANG_REPORTED_VERSION >= 130000
#   define BOOST_CLANG_VERSION 120000

# elif BOOST_CLANG_REPORTED_VERSION >= 120005
#   define BOOST_CLANG_VERSION 110100

# elif BOOST_CLANG_REPORTED_VERSION >= 120000
#   define BOOST_CLANG_VERSION 100000

# elif BOOST_CLANG_REPORTED_VERSION >= 110003
#   define BOOST_CLANG_VERSION 90000

# elif BOOST_CLANG_REPORTED_VERSION >= 110000
#   define BOOST_CLANG_VERSION 80000

# elif BOOST_CLANG_REPORTED_VERSION >= 100001
#   define BOOST_CLANG_VERSION 70000

# elif BOOST_CLANG_REPORTED_VERSION >= 100000
#   define BOOST_CLANG_VERSION 60001

# elif BOOST_CLANG_REPORTED_VERSION >= 90100
#   define BOOST_CLANG_VERSION 50002

# elif BOOST_CLANG_REPORTED_VERSION >= 90000
#   define BOOST_CLANG_VERSION 40000

# elif BOOST_CLANG_REPORTED_VERSION >= 80000
#   define BOOST_CLANG_VERSION 30900

# elif BOOST_CLANG_REPORTED_VERSION >= 70300
#   define BOOST_CLANG_VERSION 30800

# elif BOOST_CLANG_REPORTED_VERSION >= 70000
#   define BOOST_CLANG_VERSION 30700

# elif BOOST_CLANG_REPORTED_VERSION >= 60100
#   define BOOST_CLANG_VERSION 30600

# elif BOOST_CLANG_REPORTED_VERSION >= 60000
#   define BOOST_CLANG_VERSION 30500

# elif BOOST_CLANG_REPORTED_VERSION >= 50100
#   define BOOST_CLANG_VERSION 30400

# elif BOOST_CLANG_REPORTED_VERSION >= 50000
#   define BOOST_CLANG_VERSION 30300

# elif BOOST_CLANG_REPORTED_VERSION >= 40200
#   define BOOST_CLANG_VERSION 30200

# elif BOOST_CLANG_REPORTED_VERSION >= 30100
#   define BOOST_CLANG_VERSION 30100

# elif BOOST_CLANG_REPORTED_VERSION >= 20100
#   define BOOST_CLANG_VERSION 30000

# else
#   define BOOST_CLANG_VERSION 20900

# endif

# undef BOOST_CLANG_REPORTED_VERSION
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/codegear.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  CodeGear C++ compiler setup:

//
// versions check:
// last known and checked version is 0x740
#if (__CODEGEARC__ > 0x740)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  else
#     pragma message( "boost: Unknown compiler version - please run the configure tests and report the results")
#  endif
#endif

#ifdef __clang__ // Clang enhanced Windows compiler

#  include "clang.hpp"
#  define BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR

// This bug has been reported to Embarcadero

#if defined(BOOST_HAS_INT128)
#undef BOOST_HAS_INT128
#endif
#if defined(BOOST_HAS_FLOAT128)
#undef BOOST_HAS_FLOAT128
#endif

// The clang-based compilers can not do 128 atomic exchanges

#define BOOST_ATOMIC_NO_CMPXCHG16B

// 32 functions are missing from the current RTL in cwchar, so it really can not be used even if it exists

#  define BOOST_NO_CWCHAR

#  ifndef __MT__  /* If compiling in single-threaded mode, assume there is no CXX11_HDR_ATOMIC */
#    define BOOST_NO_CXX11_HDR_ATOMIC
#  endif

/* temporarily disable this until we can link against fegetround fesetround feholdexcept */

#define BOOST_NO_FENV_H

/* Reported this bug to Embarcadero with the latest C++ Builder Rio release */

#define BOOST_NO_CXX11_HDR_EXCEPTION

//
// check for exception handling support:
//
#if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

/*

// On non-Win32 platforms let the platform config figure this out:
#ifdef _WIN32
#  define BOOST_HAS_STDINT_H
#endif

//
// __int64:
//
#if !defined(__STRICT_ANSI__)
#  define BOOST_HAS_MS_INT64
#endif
//
// all versions have a <dirent.h>:
//
#if !defined(__STRICT_ANSI__)
#  define BOOST_HAS_DIRENT_H
#endif
//
// Disable Win32 support in ANSI mode:
//
#  pragma defineonoption BOOST_DISABLE_WIN32 -A
//
// MSVC compatibility mode does some nasty things:
// TODO: look up if this doesn't apply to the whole 12xx range
//
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
#  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#  define BOOST_NO_VOID_RETURNS
#endif
//

*/

// Specific settings for Embarcadero drivers
#  define BOOST_EMBTC          __CODEGEARC__
#  define BOOST_EMBTC_FULL_VER ((__clang_major__      << 16) | \
                                (__clang_minor__      <<  8) | \
                                 __clang_patchlevel__         )

// Detecting which Embarcadero driver is being used
#if defined(BOOST_EMBTC)
#  if defined(_WIN64)
#    define BOOST_EMBTC_WIN64 1
#    define BOOST_EMBTC_WINDOWS 1
#    ifndef BOOST_USE_WINDOWS_H
#      define BOOST_USE_WINDOWS_H
#    endif
#  elif defined(_WIN32)
#    define BOOST_EMBTC_WIN32C 1
#    define BOOST_EMBTC_WINDOWS 1
#    ifndef BOOST_USE_WINDOWS_H
#      define BOOST_USE_WINDOWS_H
#    endif
#  elif defined(__APPLE__) && defined(__arm__)
#    define BOOST_EMBTC_IOSARM 1
#    define BOOST_EMBTC_IOS 1
#  elif defined(__APPLE__) && defined(__aarch64__)
#    define BOOST_EMBTC_IOSARM64 1
#    define BOOST_EMBTC_IOS 1
#  elif defined(__ANDROID__) && defined(__arm__)
#    define BOOST_EMBTC_AARM 1
#    define BOOST_EMBTC_ANDROID 1
#  elif
#    if defined(BOOST_ASSERT_CONFIG)
#       error "Unknown Embarcadero driver"
#    else
#       warning "Unknown Embarcadero driver"
#    endif /* defined(BOOST_ASSERT_CONFIG) */
#  endif
#endif /* defined(BOOST_EMBTC) */

#if defined(BOOST_EMBTC_WINDOWS)

#if !defined(_chdir)
#define _chdir(x) chdir(x)
#endif

#if !defined(_dup2)
#define _dup2(x,y) dup2(x,y)
#endif

#endif

#  undef BOOST_COMPILER
#  define BOOST_COMPILER "Embarcadero-Clang C++ version " BOOST_STRINGIZE(__CODEGEARC__) " clang: " __clang_version__
// #  define __CODEGEARC_CLANG__ __CODEGEARC__
// #  define __EMBARCADERO_CLANG__ __CODEGEARC__
// #  define __BORLANDC_CLANG__ __BORLANDC__

#else // #if !defined(__clang__)

# define BOOST_CODEGEARC  __CODEGEARC__
# define BOOST_BORLANDC   __BORLANDC__

#if !defined( BOOST_WITH_CODEGEAR_WARNINGS )
// these warnings occur frequently in optimized template code
# pragma warn -8004 // var assigned value, but never used
# pragma warn -8008 // condition always true/false
# pragma warn -8066 // dead code can never execute
# pragma warn -8104 // static members with ctors not threadsafe
# pragma warn -8105 // reference member in class without ctors
#endif

// CodeGear C++ Builder 2009
#if (__CODEGEARC__ <= 0x613)
#  define BOOST_NO_INTEGRAL_INT64_T
#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#  define BOOST_NO_PRIVATE_IN_AGGREGATE
#  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
   // we shouldn't really need this - but too many things choke
   // without it, this needs more investigation:
#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#  define BOOST_SP_NO_SP_CONVERTIBLE
#endif

// CodeGear C++ Builder 2010
#if (__CODEGEARC__ <= 0x621)
#  define BOOST_NO_TYPENAME_WITH_CTOR    // Cannot use typename keyword when making temporaries of a dependant type
#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#  define BOOST_NO_NESTED_FRIENDSHIP     // TC1 gives nested classes access rights as any other member
#  define BOOST_NO_USING_TEMPLATE
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
// Temporary hack, until specific MPL preprocessed headers are generated
#  define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS

// CodeGear has not yet completely implemented value-initialization, for
// example for array types, as I reported in 2010: Embarcadero Report 83751,
// "Value-initialization: arrays should have each element value-initialized",
// http://qc.embarcadero.com/wc/qcmain.aspx?d=83751
// Last checked version: Embarcadero C++ 6.21
// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
// (Niels Dekker, LKEB, April 2010)
#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION

#  if defined(NDEBUG) && defined(__cplusplus)
      // fix broken <cstring> so that Boost.test works:
#     include <cstring>
#     undef strcmp
#  endif
   // fix broken errno declaration:
#  include <errno.h>
#  ifndef errno
#     define errno errno
#  endif

#endif

// Reportedly, #pragma once is supported since C++ Builder 2010
#if (__CODEGEARC__ >= 0x620)
#  define BOOST_HAS_PRAGMA_ONCE
#endif

#define BOOST_NO_FENV_H

//
// C++0x macros:
//
#if (__CODEGEARC__ <= 0x620)
#define BOOST_NO_CXX11_STATIC_ASSERT
#else
#define BOOST_HAS_STATIC_ASSERT
#endif
#define BOOST_HAS_CHAR16_T
#define BOOST_HAS_CHAR32_T
#define BOOST_HAS_LONG_LONG
// #define BOOST_HAS_ALIGNOF
#define BOOST_HAS_DECLTYPE
#define BOOST_HAS_EXPLICIT_CONVERSION_OPS
// #define BOOST_HAS_RVALUE_REFS
#define BOOST_HAS_SCOPED_ENUM
// #define BOOST_HAS_STATIC_ASSERT
#define BOOST_HAS_STD_TYPE_TRAITS

#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif

#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif

#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif

#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

//
// TR1 macros:
//
#define BOOST_HAS_TR1_HASH
#define BOOST_HAS_TR1_TYPE_TRAITS
#define BOOST_HAS_TR1_UNORDERED_MAP
#define BOOST_HAS_TR1_UNORDERED_SET

#define BOOST_HAS_MACRO_USE_FACET

#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST

// On non-Win32 platforms let the platform config figure this out:
#ifdef _WIN32
#  define BOOST_HAS_STDINT_H
#endif

//
// __int64:
//
#if !defined(__STRICT_ANSI__)
#  define BOOST_HAS_MS_INT64
#endif
//
// check for exception handling support:
//
#if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif
//
// all versions have a <dirent.h>:
//
#if !defined(__STRICT_ANSI__)
#  define BOOST_HAS_DIRENT_H
#endif
//
// all versions support __declspec:
//
#if defined(__STRICT_ANSI__)
// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
#  define BOOST_SYMBOL_EXPORT
#endif
//
// ABI fixing headers:
//
#ifndef BOOST_ABI_PREFIX
#  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
#endif
#ifndef BOOST_ABI_SUFFIX
#  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
#endif
//
// Disable Win32 support in ANSI mode:
//
#  pragma defineonoption BOOST_DISABLE_WIN32 -A
//
// MSVC compatibility mode does some nasty things:
// TODO: look up if this doesn't apply to the whole 12xx range
//
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
#  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#  define BOOST_NO_VOID_RETURNS
#endif

#define BOOST_COMPILER "CodeGear C++ version " BOOST_STRINGIZE(__CODEGEARC__)

#endif // #if !defined(__clang__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/comeau.hpp
================================================
//  (C) Copyright John Maddock 2001. 
//  (C) Copyright Douglas Gregor 2001. 
//  (C) Copyright Peter Dimov 2001. 
//  (C) Copyright Aleksey Gurtovoy 2003. 
//  (C) Copyright Beman Dawes 2003. 
//  (C) Copyright Jens Maurer 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Comeau C++ compiler setup:

#include <boost/config/compiler/common_edg.hpp>

#if (__COMO_VERSION__ <= 4245)

#  if defined(_MSC_VER) && _MSC_VER <= 1300
#     if _MSC_VER > 100
         // only set this in non-strict mode:
#        define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#     endif
#  endif

// Void returns don't work when emulating VC 6 (Peter Dimov)
// TODO: look up if this doesn't apply to the whole 12xx range
#  if defined(_MSC_VER) && (_MSC_VER < 1300)
#     define BOOST_NO_VOID_RETURNS
#  endif

#endif  // version 4245

//
// enable __int64 support in VC emulation mode
//
#  if defined(_MSC_VER) && (_MSC_VER >= 1200)
#     define BOOST_HAS_MS_INT64
#  endif

#define BOOST_COMPILER "Comeau compiler version " BOOST_STRINGIZE(__COMO_VERSION__)

//
// versions check:
// we don't know Comeau prior to version 4245:
#if __COMO_VERSION__ < 4245
#  error "Compiler not configured - please reconfigure"
#endif
//
// last known and checked version is 4245:
#if (__COMO_VERSION__ > 4245)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif






================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/common_edg.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002.
//  (C) Copyright Jens Maurer 2001.
//  (C) Copyright David Abrahams 2002.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  (C) Copyright Markus Schoepflin 2005.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//
// Options common to all edg based compilers.
//
// This is included from within the individual compiler mini-configs.

#ifndef  __EDG_VERSION__
#  error This file requires that __EDG_VERSION__ be defined.
#endif

#if (__EDG_VERSION__ <= 238)
#   define BOOST_NO_INTEGRAL_INT64_T
#   define BOOST_NO_SFINAE
#endif

#if (__EDG_VERSION__ <= 240)
#   define BOOST_NO_VOID_RETURNS
#endif

#if (__EDG_VERSION__ <= 241) && !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
#   define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#endif

#if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES)
#   define BOOST_NO_TEMPLATE_TEMPLATES
#endif

#if (__EDG_VERSION__ < 300) && !defined(BOOST_NO_IS_ABSTRACT)
#   define BOOST_NO_IS_ABSTRACT
#endif

#if (__EDG_VERSION__ <= 303) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
#   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif

// See also kai.hpp which checks a Kai-specific symbol for EH
# if !defined(__KCC) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
#     define BOOST_NO_EXCEPTIONS
# endif

# if !defined(__NO_LONG_LONG)
#     define BOOST_HAS_LONG_LONG
# else
#     define BOOST_NO_LONG_LONG
# endif

// Not sure what version was the first to support #pragma once, but
// different EDG-based compilers (e.g. Intel) supported it for ages.
// Add a proper version check if it causes problems.
#define BOOST_HAS_PRAGMA_ONCE

//
// C++0x features
//
//   See above for BOOST_NO_LONG_LONG
//
#if (__EDG_VERSION__ < 310)
#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
#endif
#if (__EDG_VERSION__ <= 310)
// No support for initializer lists
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#endif
#if (__EDG_VERSION__ < 400)
#  define BOOST_NO_CXX11_VARIADIC_MACROS
#endif

#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

//__cpp_decltype 200707 possibly?
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276

#if !defined(__cpp_unicode_characters) || (__cpp_unicode_characters < 200704)
#   define BOOST_NO_CXX11_CHAR16_T
#   define BOOST_NO_CXX11_CHAR32_T
#endif
#if !defined(__cpp_unicode_literals) || (__cpp_unicode_literals < 200710)
#   define BOOST_NO_CXX11_UNICODE_LITERALS
#endif
#if !defined(__cpp_user_defined_literals) || (__cpp_user_defined_literals < 200809)
#   define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#endif
#if !defined(__cpp_variadic_templates) || (__cpp_variadic_templates < 200704)
#   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 200907)
#   define BOOST_NO_CXX11_CONSTEXPR
#endif
#if !defined(__cpp_lambdas) || (__cpp_lambdas < 200907)
#   define BOOST_NO_CXX11_LAMBDAS
#endif
#if !defined(__cpp_range_based_for) || (__cpp_range_based_for < 200710)
#   define BOOST_NO_CXX11_RANGE_BASED_FOR
#endif
#if !defined(__cpp_raw_strings) || (__cpp_raw_strings < 200610)
#   define BOOST_NO_CXX11_RAW_LITERALS
#endif


// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif

#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#ifdef c_plusplus
// EDG has "long long" in non-strict mode
// However, some libraries have insufficient "long long" support
// #define BOOST_HAS_LONG_LONG
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/compaq_cxx.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Tru64 C++ compiler setup (now HP):

#define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER)

#include <boost/config/compiler/common_edg.hpp>

//
// versions check:
// Nothing to do here?





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/cray.hpp
================================================
//  Copyright 2011 John Maddock
//  Copyright 2013, 2017-2018 Cray, Inc.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

// Cray C++ compiler setup.
//
// There are a few parameters that affect the macros defined in this file:
//
// - What version of CCE (Cray Compiling Environment) are we running? This
//   comes from the '_RELEASE_MAJOR', '_RELEASE_MINOR', and
//   '_RELEASE_PATCHLEVEL' macros.
// - What C++ standards conformance level are we using (e.g. '-h
//   std=c++14')? This comes from the '__cplusplus' macro.
// - Are we using GCC extensions ('-h gnu' or '-h nognu')? If we have '-h
//   gnu' then CCE emulates GCC, and the macros '__GNUC__',
//   '__GNUC_MINOR__', and '__GNUC_PATCHLEVEL__' are defined.
//
// This file is organized as follows:
//
// - Verify that the combination of parameters listed above is supported.
//   If we have an unsupported combination, we abort with '#error'.
// - Establish baseline values for all Boost macros.
// - Apply changes to the baseline macros based on compiler version. These
//   changes are cummulative so each version section only describes the
//   changes since the previous version.
//   - Within each version section, we may also apply changes based on
//     other parameters (i.e. C++ standards conformance level and GCC
//     extensions).
//
// To test changes to this file:
//
// ```
// module load cce/8.6.5 # Pick the version you want to test.
// cd boost/libs/config/test/all
// b2 -j 8 toolset=cray cxxstd=03 cxxstd=11 cxxstd=14 cxxstd-dialect=gnu linkflags=-lrt
// ```
// Note: Using 'cxxstd-dialect=iso' is not supported at this time (the
// tests run, but many tests fail).
//
// Note: 'linkflags=-lrt' is needed in Cray Linux Environment. Otherwise
// you get an 'undefined reference to clock_gettime' error.
//
// Note: If a test '*_fail.cpp' file compiles, but fails to run, then it is
// reported as a defect. However, this is not actually a defect. This is an
// area where the test system is somewhat broken. Tests that are failing
// because of this problem are noted in the comments.
//
// Pay attention to the macro definitions for the macros you wish to
// modify. For example, only macros categorized as compiler macros should
// appear in this file; platform macros should not appear in this file.
// Also, some macros have to be defined to specific values; it is not
// always enough to define or undefine a macro.
//
// Macro definitions are available in the source code at:
//
// `boost/libs/config/doc/html/boost_config/boost_macro_reference.html`
//
// Macro definitions are also available online at:
//
// http://www.boost.org/doc/libs/master/libs/config/doc/html/boost_config/boost_macro_reference.html
//
// Typically, if you enable a feature, and the tests pass, then you have
// nothing to worry about. However, it's sometimes hard to figure out if a
// disabled feature needs to stay disabled. To get a list of disabled
// features, run 'b2' in 'boost/libs/config/checks'. These are the macros
// you should pay attention to (in addition to macros that cause test
// failures).

////
//// Front matter
////

// In a developer build of the Cray compiler (i.e. a compiler built by a
// Cray employee), the release patch level is reported as "x". This gives
// versions that look like e.g. "8.6.x".
//
// To accomplish this, the the Cray compiler preprocessor inserts:
//
// #define _RELEASE_PATCHLEVEL x
//
// If we are using a developer build of the compiler, we want to use the
// configuration macros for the most recent patch level of the release. To
// accomplish this, we'll pretend that _RELEASE_PATCHLEVEL is 99.
//
// However, it's difficult to detect if _RELEASE_PATCHLEVEL is x. We must
// consider that the x will be expanded if x is defined as a macro
// elsewhere. For example, imagine if someone put "-D x=3" on the command
// line, and _RELEASE_PATCHLEVEL is x. Then _RELEASE_PATCHLEVEL would
// expand to 3, and we could not distinguish it from an actual
// _RELEASE_PATCHLEVEL of 3. This problem only affects developer builds; in
// production builds, _RELEASE_PATCHLEVEL is always an integer.
//
// IMPORTANT: In developer builds, if x is defined as a macro, you will get
// an incorrect configuration. The behavior in this case is undefined.
//
// Even if x is not defined, we have to use some trickery to detect if
// _RELEASE_PATCHLEVEL is x. First we define BOOST_CRAY_x to some arbitrary
// magic value, 9867657. Then we use BOOST_CRAY_APPEND to append the
// expanded value of _RELEASE_PATCHLEVEL to the string "BOOST_CRAY_".
//
// - If _RELEASE_PATCHLEVEL is undefined, we get "BOOST_CRAY_".
// - If _RELEASE_PATCHLEVEL is 5, we get "BOOST_CRAY_5".
// - If _RELEASE_PATCHLEVEL is x (and x is not defined) we get
//   "BOOST_CRAY_x":
//
// Then we check if BOOST_CRAY_x is equal to the output of
// BOOST_CRAY_APPEND. In other words, the output of BOOST_CRAY_APPEND is
// treated as a macro name, and expanded again. If we can safely assume
// that BOOST_CRAY_ is not a macro defined as our magic number, and
// BOOST_CRAY_5 is not a macro defined as our magic number, then the only
// way the equality test can pass is if _RELEASE_PATCHLEVEL expands to x.
//
// So, that is how we detect if we are using a developer build of the Cray
// compiler.

#define BOOST_CRAY_x 9867657 // Arbitrary number
#define BOOST_CRAY_APPEND(MACRO) BOOST_CRAY_APPEND_INTERNAL(MACRO)
#define BOOST_CRAY_APPEND_INTERNAL(MACRO) BOOST_CRAY_##MACRO

#if BOOST_CRAY_x == BOOST_CRAY_APPEND(_RELEASE_PATCHLEVEL)

    // This is a developer build.
    //
    // - _RELEASE_PATCHLEVEL is defined as x, and x is not defined as a macro.

    // Pretend _RELEASE_PATCHLEVEL is 99, so we get the configuration for the
    // most recent patch level in this release.

    #define BOOST_CRAY_VERSION (_RELEASE_MAJOR * 10000 + _RELEASE_MINOR * 100 + 99)

#else

    // This is a production build.
    //
    // _RELEASE_PATCHLEVEL is not defined as x, or x is defined as a macro.

    #define BOOST_CRAY_VERSION (_RELEASE_MAJOR * 10000 + _RELEASE_MINOR * 100 + _RELEASE_PATCHLEVEL)

#endif // BOOST_CRAY_x == BOOST_CRAY_APPEND(_RELEASE_PATCHLEVEL)

#undef BOOST_CRAY_APPEND_INTERNAL
#undef BOOST_CRAY_APPEND
#undef BOOST_CRAY_x


#ifdef __GNUC__
#   define BOOST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif

#ifndef BOOST_COMPILER
#   define BOOST_COMPILER "Cray C++ version " BOOST_STRINGIZE(_RELEASE_MAJOR) "." BOOST_STRINGIZE(_RELEASE_MINOR) "." BOOST_STRINGIZE(_RELEASE_PATCHLEVEL)
#endif

// Since the Cray compiler defines '__GNUC__', we have to emulate some
// additional GCC macros in order to make everything work.
//
// FIXME: Perhaps Cray should fix the compiler to define these additional
// macros for GCC emulation?

#if __cplusplus >= 201103L && defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__)
#   define __GXX_EXPERIMENTAL_CXX0X__ 1
#endif

////
//// Parameter validation
////

// FIXME: Do we really need to support compilers before 8.5? Do they pass
// the Boost.Config tests?

#if BOOST_CRAY_VERSION < 80000
#  error "Boost is not configured for Cray compilers prior to version 8, please try the configure script."
#endif

// We only support recent EDG based compilers.

#ifndef __EDG__
#  error "Unsupported Cray compiler, please try running the configure script."
#endif

////
//// Baseline values
////

#include <boost/config/compiler/common_edg.hpp>

#define BOOST_HAS_NRVO
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_VARIADIC_MACROS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP

//#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#define BOOST_MATH_DISABLE_STD_FPCLASSIFY
//#define BOOST_HAS_FPCLASSIFY

#define BOOST_SP_USE_PTHREADS 
#define BOOST_AC_USE_PTHREADS 

//
// Everything that follows is working around what are thought to be
// compiler shortcomings. Revist all of these regularly.
//

//#define BOOST_USE_ENUM_STATIC_ASSERT
//#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS //(this may be implied by the previous #define

// These constants should be provided by the compiler.

#ifndef __ATOMIC_RELAXED
#define __ATOMIC_RELAXED 0
#define __ATOMIC_CONSUME 1
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_RELEASE 3
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_SEQ_CST 5
#endif

////
//// Version changes
////

//
// 8.5.0
//

#if BOOST_CRAY_VERSION >= 80500

#if __cplusplus >= 201103L

#undef BOOST_HAS_NRVO
#undef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#undef BOOST_NO_CXX11_AUTO_DECLARATIONS
#undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#undef BOOST_NO_CXX11_CHAR16_T
#undef BOOST_NO_CXX11_CHAR32_T
#undef BOOST_NO_CXX11_CONSTEXPR
#undef BOOST_NO_CXX11_DECLTYPE
#undef BOOST_NO_CXX11_DECLTYPE_N3276
#undef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#undef BOOST_NO_CXX11_DELETED_FUNCTIONS
#undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#undef BOOST_NO_CXX11_FINAL
#undef BOOST_NO_CXX11_OVERRIDE
#undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#undef BOOST_NO_CXX11_LAMBDAS
#undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#undef BOOST_NO_CXX11_NOEXCEPT
#undef BOOST_NO_CXX11_NULLPTR
#undef BOOST_NO_CXX11_RANGE_BASED_FOR
#undef BOOST_NO_CXX11_RAW_LITERALS
#undef BOOST_NO_CXX11_REF_QUALIFIERS
#undef BOOST_NO_CXX11_RVALUE_REFERENCES
#undef BOOST_NO_CXX11_SCOPED_ENUMS
#undef BOOST_NO_CXX11_SFINAE_EXPR
#undef BOOST_NO_CXX11_STATIC_ASSERT
#undef BOOST_NO_CXX11_TEMPLATE_ALIASES
#undef BOOST_NO_CXX11_THREAD_LOCAL
#undef BOOST_NO_CXX11_UNICODE_LITERALS
#undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#undef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#undef BOOST_NO_CXX11_VARIADIC_MACROS
#undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#undef BOOST_NO_CXX11_UNRESTRICTED_UNION
#undef BOOST_NO_SFINAE_EXPR
#undef BOOST_NO_TWO_PHASE_NAME_LOOKUP
#undef BOOST_MATH_DISABLE_STD_FPCLASSIFY
#undef BOOST_SP_USE_PTHREADS 
#undef BOOST_AC_USE_PTHREADS 

#define BOOST_HAS_VARIADIC_TMPL
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#define BOOST_HAS_TR1_COMPLEX_OVERLOADS
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_STATIC_ASSERT
#define BOOST_HAS_SIGACTION
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_RVALUE_REFS
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_PTHREAD_YIELD
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#define BOOST_HAS_NRVO
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_NANOSLEEP
#define BOOST_NO_CXX11_SMART_PTR
#define BOOST_NO_CXX11_HDR_FUNCTIONAL
#define BOOST_NO_CXX14_CONSTEXPR
#define BOOST_HAS_LONG_LONG
#define BOOST_HAS_FLOAT128

#if __cplusplus < 201402L
#define BOOST_NO_CXX11_DECLTYPE_N3276
#endif // __cplusplus < 201402L

#endif // __cplusplus >= 201103L

#endif // BOOST_CRAY_VERSION >= 80500

//
// 8.6.4
// (versions prior to 8.6.5 do not define _RELEASE_PATCHLEVEL)
//

#if BOOST_CRAY_VERSION >= 80600

#if __cplusplus >= 199711L
#define BOOST_HAS_FLOAT128
#define BOOST_HAS_PTHREAD_YIELD // This is a platform macro, but it improves test results.
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION // This is correct. Test compiles, but fails to run.
#undef  BOOST_NO_CXX11_CHAR16_T
#undef  BOOST_NO_CXX11_CHAR32_T
#undef  BOOST_NO_CXX11_INLINE_NAMESPACES
#undef  BOOST_NO_CXX11_FINAL
#undef BOOST_NO_CXX11_OVERRIDE
#undef  BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#undef  BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_SFINAE_EXPR // This is correct, even though '*_fail.cpp' test fails.
#undef  BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#undef  BOOST_NO_CXX11_VARIADIC_MACROS
#undef  BOOST_NO_CXX11_VARIADIC_TEMPLATES
// 'BOOST_NO_DEDUCED_TYPENAME' test is broken. The test files are enabled /
// disabled with an '#ifdef BOOST_DEDUCED_TYPENAME'. However,
// 'boost/libs/config/include/boost/config/detail/suffix.hpp' ensures that
// 'BOOST_DEDUCED_TYPENAME' is always defined (the value it is defined as
// depends on 'BOOST_NO_DEDUCED_TYPENAME'). So, modifying
// 'BOOST_NO_DEDUCED_TYPENAME' has no effect on which tests are run.
//
// The 'no_ded_typename_pass.cpp' test should always compile and run
// successfully, because 'BOOST_DEDUCED_TYPENAME' must always have an
// appropriate value (it's not just something that you turn on or off).
// Therefore, if you wish to test changes to 'BOOST_NO_DEDUCED_TYPENAME',
// you have to modify 'no_ded_typename_pass.cpp' to unconditionally include
// 'boost_no_ded_typename.ipp'.
#undef  BOOST_NO_DEDUCED_TYPENAME // This is correct. Test is broken.
#undef  BOOST_NO_SFINAE_EXPR
#undef  BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif // __cplusplus >= 199711L

#if __cplusplus >= 201103L
#undef  BOOST_NO_CXX11_ALIGNAS
#undef  BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_HDR_ATOMIC
#undef  BOOST_NO_CXX11_HDR_FUNCTIONAL
#define BOOST_NO_CXX11_HDR_REGEX // This is correct. Test compiles, but fails to run.
#undef  BOOST_NO_CXX11_SFINAE_EXPR
#undef  BOOST_NO_CXX11_SMART_PTR
#undef  BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#endif // __cplusplus >= 201103L

#if __cplusplus >= 201402L
#undef  BOOST_NO_CXX14_CONSTEXPR
#define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif // __cplusplus == 201402L

#endif // BOOST_CRAY_VERSION >= 80600

//
// 8.6.5
// (no change from 8.6.4)
//

//
// 8.7.0
//

#if BOOST_CRAY_VERSION >= 80700

#if __cplusplus >= 199711L
#endif // __cplusplus >= 199711L

#if __cplusplus >= 201103L
#undef  BOOST_NO_CXX11_HDR_ATOMIC
#undef  BOOST_NO_CXX11_HDR_REGEX
#endif // __cplusplus >= 201103L

#if __cplusplus >= 201402L
#endif // __cplusplus == 201402L

#endif // BOOST_CRAY_VERSION >= 80700

//
// Next release
//

#if BOOST_CRAY_VERSION > 80799

#if __cplusplus >= 199711L
#endif // __cplusplus >= 199711L

#if __cplusplus >= 201103L
#endif // __cplusplus >= 201103L

#if __cplusplus >= 201402L
#endif // __cplusplus == 201402L

#endif // BOOST_CRAY_VERSION > 80799

////
//// Remove temporary macros
////

// I've commented out some '#undef' statements to signify that we purposely
// want to keep certain macros.

//#undef __GXX_EXPERIMENTAL_CXX0X__
//#undef BOOST_COMPILER
#undef BOOST_GCC_VERSION
#undef BOOST_CRAY_VERSION


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/diab.hpp
================================================
//  (C) Copyright Brian Kuhl 2016.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Check this is a recent EDG based compiler, otherwise we don't support it here:


#ifndef __EDG_VERSION__
#     error "Unknown Diab compiler version - please run the configure tests and report the results"
#endif

#include "boost/config/compiler/common_edg.hpp"

#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS

#define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE
#define BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS
#define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_HDR_CODECVT
#define BOOST_NO_CXX11_NUMERIC_LIMITS 

#define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/digitalmars.hpp
================================================
//  Copyright (C) Christof Meerwald 2003
//  Copyright (C) Dan Watkins 2003
//
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  Digital Mars C++ compiler setup:
#define BOOST_COMPILER __DMC_VERSION_STRING__

#define BOOST_HAS_LONG_LONG
#define BOOST_HAS_PRAGMA_ONCE

#if !defined(BOOST_STRICT_CONFIG)
#define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#define BOOST_NO_OPERATORS_IN_NAMESPACE
#define BOOST_NO_UNREACHABLE_RETURN_DETECTION
#define BOOST_NO_SFINAE
#define BOOST_NO_USING_TEMPLATE
#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif

//
// has macros:
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_WINTHREADS

#if (__DMC__ >= 0x847)
#define BOOST_HAS_EXPM1
#define BOOST_HAS_LOG1P
#endif

//
// Is this really the best way to detect whether the std lib is in namespace std?
//
#ifdef __cplusplus
#include <cstddef>
#endif
#if !defined(__STL_IMPORT_VENDOR_CSTD) && !defined(_STLP_IMPORT_VENDOR_CSTD)
#  define BOOST_NO_STDC_NAMESPACE
#endif


// check for exception handling support:
#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

//
// C++0x features
//
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#if (__DMC__ <= 0x840)
#error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version is ...:
#if (__DMC__ > 0x848)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/gcc.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright Darin Adler 2001 - 2002.
//  (C) Copyright Jens Maurer 2001 - 2002.
//  (C) Copyright Beman Dawes 2001 - 2003.
//  (C) Copyright Douglas Gregor 2002.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Synge Todo 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  GNU C++ compiler setup.

//
// Define BOOST_GCC so we know this is "real" GCC and not some pretender:
//
#define BOOST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if !defined(__CUDACC__)
#define BOOST_GCC BOOST_GCC_VERSION
#endif

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
#  define BOOST_GCC_CXX11
#endif

#if __GNUC__ == 3
#  if defined (__PATHSCALE__)
#     define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#     define BOOST_NO_IS_ABSTRACT
#  endif

#  if __GNUC_MINOR__ < 4
#     define BOOST_NO_IS_ABSTRACT
#  endif
#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
#endif
#if __GNUC__ < 4
//
// All problems to gcc-3.x and earlier here:
//
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#  ifdef __OPEN64__
#     define BOOST_NO_IS_ABSTRACT
#  endif
#endif

// GCC prior to 3.4 had #pragma once too but it didn't work well with filesystem links
#if BOOST_GCC_VERSION >= 30400
#define BOOST_HAS_PRAGMA_ONCE
#endif

#if BOOST_GCC_VERSION < 40400
// Previous versions of GCC did not completely implement value-initialization:
// GCC Bug 30111, "Value-initialization of POD base class doesn't initialize
// members", reported by Jonathan Wakely in 2006,
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111 (fixed for GCC 4.4)
// GCC Bug 33916, "Default constructor fails to initialize array members",
// reported by Michael Elizabeth Chastain in 2007,
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916 (fixed for GCC 4.2.4)
// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#endif

#if !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
# define BOOST_NO_EXCEPTIONS
#endif


//
// Threading support: Turn this on unconditionally here (except for
// those platforms where we can know for sure). It will get turned off again
// later if no threading API is detected.
//
#if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__)
# define BOOST_HAS_THREADS
#endif

//
// gcc has "long long"
// Except on Darwin with standard compliance enabled (-pedantic)
// Apple gcc helpfully defines this macro we can query
//
#if !defined(__DARWIN_NO_LONG_LONG)
# define BOOST_HAS_LONG_LONG
#endif

//
// gcc implements the named return value optimization since version 3.1
//
#define BOOST_HAS_NRVO

// Branch prediction hints
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)

//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if __GNUC__ >= 4
#  if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
     // All Win32 development environments, including 64-bit Windows and MinGW, define
     // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
     // so does not define _WIN32 or its variants, but still supports dllexport/dllimport.
#    define BOOST_HAS_DECLSPEC
#    define BOOST_SYMBOL_EXPORT __attribute__((__dllexport__))
#    define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__))
#  else
#    define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#    define BOOST_SYMBOL_IMPORT
#  endif
#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#else
// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
#  define BOOST_SYMBOL_EXPORT
#endif

//
// RTTI and typeinfo detection is possible post gcc-4.3:
//
#if BOOST_GCC_VERSION > 40300
#  ifndef __GXX_RTTI
#     ifndef BOOST_NO_TYPEID
#        define BOOST_NO_TYPEID
#     endif
#     ifndef BOOST_NO_RTTI
#        define BOOST_NO_RTTI
#     endif
#  endif
#endif

//
// Recent GCC versions have __int128 when in 64-bit mode.
//
// We disable this if the compiler is really nvcc with C++03 as it
// doesn't actually support __int128 as of CUDA_VERSION=7500
// even though it defines __SIZEOF_INT128__.
// See https://svn.boost.org/trac/boost/ticket/8048
//     https://svn.boost.org/trac/boost/ticket/11852
// Only re-enable this for nvcc if you're absolutely sure
// of the circumstances under which it's supported:
//
#if defined(__CUDACC__)
#  if defined(BOOST_GCC_CXX11)
#    define BOOST_NVCC_CXX11
#  else
#    define BOOST_NVCC_CXX03
#  endif
#endif

#if defined(__SIZEOF_INT128__) && !defined(BOOST_NVCC_CXX03)
#  define BOOST_HAS_INT128
#endif
//
// Recent GCC versions have a __float128 native type, we need to
// include a std lib header to detect this - not ideal, but we'll
// be including <cstddef> later anyway when we select the std lib.
//
// Nevertheless, as of CUDA 7.5, using __float128 with the host
// compiler in pre-C++11 mode is still not supported.
// See https://svn.boost.org/trac/boost/ticket/11852
//
#ifdef __cplusplus
#include <cstddef>
#else
#include <stddef.h>
#endif
#if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) && !defined(BOOST_NVCC_CXX03)
# define BOOST_HAS_FLOAT128
#endif

// C++0x features in 4.3.n and later
//
#if (BOOST_GCC_VERSION >= 40300) && defined(BOOST_GCC_CXX11)
// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
// passed on the command line, which in turn defines
// __GXX_EXPERIMENTAL_CXX0X__.
#  define BOOST_HAS_DECLTYPE
#  define BOOST_HAS_RVALUE_REFS
#  define BOOST_HAS_STATIC_ASSERT
#  define BOOST_HAS_VARIADIC_TMPL
#else
#  define BOOST_NO_CXX11_DECLTYPE
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_STATIC_ASSERT
#endif

// C++0x features in 4.4.n and later
//
#if (BOOST_GCC_VERSION < 40400) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif

#if BOOST_GCC_VERSION < 40500
#  define BOOST_NO_SFINAE_EXPR
#endif

// GCC 4.5 forbids declaration of defaulted functions in private or protected sections
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ == 5) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#endif

// C++0x features in 4.5.0 and later
//
#if (BOOST_GCC_VERSION < 40500) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_LAMBDAS
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#  define BOOST_NO_CXX11_RAW_LITERALS
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#endif

// C++0x features in 4.5.1 and later
//
#if (BOOST_GCC_VERSION < 40501) || !defined(BOOST_GCC_CXX11)
// scoped enums have a serious bug in 4.4.0, so define BOOST_NO_CXX11_SCOPED_ENUMS before 4.5.1
// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38064
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#endif

// C++0x features in 4.6.n and later
//
#if (BOOST_GCC_VERSION < 40600) || !defined(BOOST_GCC_CXX11)
#define BOOST_NO_CXX11_DEFAULTED_MOVES
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif

// C++0x features in 4.7.n and later
//
#if (BOOST_GCC_VERSION < 40700) || !defined(BOOST_GCC_CXX11)
// Note that while constexpr is partly supported in gcc-4.6 it's a 
// pre-std version with several bugs:
#  define BOOST_NO_CXX11_CONSTEXPR
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#  define BOOST_NO_CXX11_OVERRIDE
#endif

// C++0x features in 4.8.n and later
//
#if (BOOST_GCC_VERSION < 40800) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_SFINAE_EXPR
#endif

// C++0x features in 4.8.1 and later
//
#if (BOOST_GCC_VERSION < 40801) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif

// C++0x features in 4.9.n and later
//
#if (BOOST_GCC_VERSION < 40900) || !defined(BOOST_GCC_CXX11)
// Although alignas support is added in gcc 4.8, it does not accept
// dependent constant expressions as an argument until gcc 4.9.
#  define BOOST_NO_CXX11_ALIGNAS
#endif

// C++0x features in 5.1 and later
//
#if (BOOST_GCC_VERSION < 50100) || !defined(BOOST_GCC_CXX11)
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif

// C++14 features in 4.9.0 and later
//
#if (BOOST_GCC_VERSION < 40900) || (__cplusplus < 201300)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#  if !((BOOST_GCC_VERSION >= 40801) && (BOOST_GCC_VERSION < 40900) && defined(BOOST_GCC_CXX11))
#     define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#  endif
#endif


// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if (BOOST_GCC_VERSION < 50200) || !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#if __GNUC__ >= 7
#  define BOOST_FALLTHROUGH __attribute__((fallthrough))
#endif

#if (__GNUC__ < 11) && defined(__MINGW32__) && !defined(__MINGW64__)
// thread_local was broken on mingw for all 32bit compiler releases prior to 11.x, see
// https://sourceforge.net/p/mingw-w64/bugs/527/
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83562
// Not setting this causes program termination on thread exit.
#define BOOST_NO_CXX11_THREAD_LOCAL
#endif

//
// Unused attribute:
#if __GNUC__ >= 4
#  define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
#endif

// Type aliasing hint. Supported since gcc 3.3.
#define BOOST_MAY_ALIAS __attribute__((__may_alias__))

// Unreachable code markup
#if BOOST_GCC_VERSION >= 40500
#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
#endif

// Deprecated symbol markup
#if BOOST_GCC_VERSION >= 40500
#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
#else
#define BOOST_DEPRECATED(msg) __attribute__((deprecated))
#endif

#ifndef BOOST_COMPILER
#  define BOOST_COMPILER "GNU C++ version " __VERSION__
#endif

// ConceptGCC compiler:
//   http://www.generic-programming.org/software/ConceptGCC/
#ifdef __GXX_CONCEPTS__
#  define BOOST_HAS_CONCEPTS
#  define BOOST_COMPILER "ConceptGCC version " __VERSION__
#endif

// versions check:
// we don't know gcc prior to version 3.30:
#if (BOOST_GCC_VERSION < 30300)
#  error "Compiler not configured - please reconfigure"
#endif
//
// last known and checked version is 8.1:
#if (BOOST_GCC_VERSION > 80100)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
#  else
// we don't emit warnings here anymore since there are no defect macros defined for
// gcc post 3.4, so any failures are gcc regressions...
//#     warning "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/gcc_xml.hpp
================================================
//  (C) Copyright John Maddock 2006.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  GCC-XML C++ compiler setup:

#  if !defined(__GCCXML_GNUC__) || ((__GCCXML_GNUC__ <= 3) && (__GCCXML_GNUC_MINOR__ <= 3))
#     define BOOST_NO_IS_ABSTRACT
#  endif

//
// Threading support: Turn this on unconditionally here (except for
// those platforms where we can know for sure). It will get turned off again
// later if no threading API is detected.
//
#if !defined(__MINGW32__) && !defined(_MSC_VER) && !defined(linux) && !defined(__linux) && !defined(__linux__)
# define BOOST_HAS_THREADS
#endif

//
// gcc has "long long"
//
#define BOOST_HAS_LONG_LONG

// C++0x features:
//
#  define BOOST_NO_CXX11_CONSTEXPR
#  define BOOST_NO_CXX11_NULLPTR
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#  define BOOST_NO_CXX11_DECLTYPE
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_STATIC_ASSERT
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#  define BOOST_NO_CXX11_VARIADIC_MACROS
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#  define BOOST_NO_SFINAE_EXPR
#  define BOOST_NO_CXX11_SFINAE_EXPR
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_LAMBDAS
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#  define BOOST_NO_CXX11_RANGE_BASED_FOR
#  define BOOST_NO_CXX11_RAW_LITERALS
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#  define BOOST_NO_CXX11_NOEXCEPT
#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#  define BOOST_NO_CXX11_ALIGNAS
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_OVERRIDE
#  define BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/greenhills.hpp
================================================
//  (C) Copyright John Maddock 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Greenhills C++ compiler setup:

#define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs)

#include <boost/config/compiler/common_edg.hpp>

//
// versions check:
// we don't support Greenhills prior to version 0:
#if __ghs < 0
#  error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version is 0:
#if (__ghs > 0)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/hp_acc.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright Jens Maurer 2001 - 2003.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Toon Knapen 2003.
//  (C) Copyright Boris Gubenko 2006 - 2007.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  HP aCC C++ compiler setup:

#if defined(__EDG__)
#include <boost/config/compiler/common_edg.hpp>
#endif

#if (__HP_aCC <= 33100)
#    define BOOST_NO_INTEGRAL_INT64_T
#    define BOOST_NO_OPERATORS_IN_NAMESPACE
#  if !defined(_NAMESPACE_STD)
#     define BOOST_NO_STD_LOCALE
#     define BOOST_NO_STRINGSTREAM
#  endif
#endif

#if (__HP_aCC <= 33300)
// member templates are sufficiently broken that we disable them for now
#    define BOOST_NO_MEMBER_TEMPLATES
#    define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#    define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
#endif

#if (__HP_aCC <= 38000)
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif

#if (__HP_aCC > 50000) && (__HP_aCC < 60000)
#    define BOOST_NO_UNREACHABLE_RETURN_DETECTION
#    define BOOST_NO_TEMPLATE_TEMPLATES
#    define BOOST_NO_SWPRINTF
#    define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#    define BOOST_NO_IS_ABSTRACT
#    define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#endif

// optional features rather than defects:
#if (__HP_aCC >= 33900)
#    define BOOST_HAS_LONG_LONG
#    define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#endif

#if (__HP_aCC >= 50000 ) && (__HP_aCC <= 53800 ) || (__HP_aCC < 31300 )
#    define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#endif

// This macro should not be defined when compiling in strict ansi
// mode, but, currently, we don't have the ability to determine
// what standard mode we are compiling with. Some future version
// of aCC6 compiler will provide predefined macros reflecting the
// compilation options, including the standard mode.
#if (__HP_aCC >= 60000) || ((__HP_aCC > 38000) && defined(__hpxstd98))
#    define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif

#define BOOST_COMPILER "HP aCC version " BOOST_STRINGIZE(__HP_aCC)

//
// versions check:
// we don't support HP aCC prior to version 33000:
#if __HP_aCC < 33000
#  error "Compiler not supported or configured - please reconfigure"
#endif

//
// Extended checks for supporting aCC on PA-RISC
#if __HP_aCC > 30000 && __HP_aCC < 50000
#  if __HP_aCC < 38000
      // versions prior to version A.03.80 not supported
#     error "Compiler version not supported - version A.03.80 or higher is required"
#  elif !defined(__hpxstd98)
      // must compile using the option +hpxstd98 with version A.03.80 and above
#     error "Compiler option '+hpxstd98' is required for proper support"
#  endif //PA-RISC
#endif

//
// C++0x features
//
//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
//
#if !defined(__EDG__)

#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

/*
  See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
      https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443436
*/

#if (__HP_aCC < 62500) || !defined(HP_CXX0x_SOURCE)
  #define BOOST_NO_CXX11_VARIADIC_MACROS
#endif

#endif

//
// last known and checked version for HP-UX/ia64 is 61300
// last known and checked version for PA-RISC is 38000
#if ((__HP_aCC > 61300) || ((__HP_aCC > 38000) && defined(__hpxstd98)))
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/intel.hpp
================================================
//  (C) Copyright John Maddock 2001-8.
//  (C) Copyright Peter Dimov 2001.
//  (C) Copyright Jens Maurer 2001.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Aleksey Gurtovoy 2002 - 2003.
//  (C) Copyright Guillaume Melquiond 2002 - 2003.
//  (C) Copyright Beman Dawes 2003.
//  (C) Copyright Martin Wille 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Intel compiler setup:

#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) && (defined(_MSC_VER) || defined(__GNUC__))

#ifdef _MSC_VER

#include <boost/config/compiler/visualc.hpp>

#undef BOOST_MSVC
#undef BOOST_MSVC_FULL_VER

#if (__INTEL_COMPILER >= 1500) && (_MSC_VER >= 1900)
//
// These appear to be supported, even though VC++ may not support them:
//
#define BOOST_HAS_EXPM1
#define BOOST_HAS_LOG1P
#undef BOOST_NO_CXX14_BINARY_LITERALS
// This one may be a little risky to enable??
#undef BOOST_NO_SFINAE_EXPR

#endif

#if (__INTEL_COMPILER <= 1600) && !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

#else // defined(_MSC_VER)

#include <boost/config/compiler/gcc.hpp>

#undef BOOST_GCC_VERSION
#undef BOOST_GCC_CXX11
#undef BOOST_GCC
#undef BOOST_FALLTHROUGH

// Broken in all versions up to 17 (newer versions not tested)
#if (__INTEL_COMPILER <= 1700) && !defined(BOOST_NO_CXX14_CONSTEXPR)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif

#if (__INTEL_COMPILER >= 1800) && (__cplusplus >= 201703)
#  define BOOST_FALLTHROUGH [[fallthrough]]
#endif

#endif // defined(_MSC_VER)

#undef BOOST_COMPILER

#if defined(__INTEL_COMPILER)
#if __INTEL_COMPILER == 9999
#  define BOOST_INTEL_CXX_VERSION 1200 // Intel bug in 12.1.
#else
#  define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER
#endif
#elif defined(__ICL)
#  define BOOST_INTEL_CXX_VERSION __ICL
#elif defined(__ICC)
#  define BOOST_INTEL_CXX_VERSION __ICC
#elif defined(__ECC)
#  define BOOST_INTEL_CXX_VERSION __ECC
#endif

// Flags determined by comparing output of 'icpc -dM -E' with and without '-std=c++0x'
#if (!(defined(_WIN32) || defined(_WIN64)) && defined(__STDC_HOSTED__) && (__STDC_HOSTED__ && (BOOST_INTEL_CXX_VERSION <= 1200))) || defined(__GXX_EXPERIMENTAL_CPP0X__) || defined(__GXX_EXPERIMENTAL_CXX0X__)
#  define BOOST_INTEL_STDCXX0X
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1600)
#  define BOOST_INTEL_STDCXX0X
#endif

#ifdef __GNUC__
#  define BOOST_INTEL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif

#if !defined(BOOST_COMPILER)
#  if defined(BOOST_INTEL_STDCXX0X)
#    define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
#  else
#    define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
#  endif
#endif

#define BOOST_INTEL BOOST_INTEL_CXX_VERSION

#if defined(_WIN32) || defined(_WIN64)
#  define BOOST_INTEL_WIN BOOST_INTEL
#else
#  define BOOST_INTEL_LINUX BOOST_INTEL
#endif

#else // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) && (defined(_MSC_VER) || defined(__GNUC__))

#include <boost/config/compiler/common_edg.hpp>

#if defined(__INTEL_COMPILER)
#if __INTEL_COMPILER == 9999
#  define BOOST_INTEL_CXX_VERSION 1200 // Intel bug in 12.1.
#else
#  define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER
#endif
#elif defined(__ICL)
#  define BOOST_INTEL_CXX_VERSION __ICL
#elif defined(__ICC)
#  define BOOST_INTEL_CXX_VERSION __ICC
#elif defined(__ECC)
#  define BOOST_INTEL_CXX_VERSION __ECC
#endif

// Flags determined by comparing output of 'icpc -dM -E' with and without '-std=c++0x'
#if (!(defined(_WIN32) || defined(_WIN64)) && defined(__STDC_HOSTED__) && (__STDC_HOSTED__ && (BOOST_INTEL_CXX_VERSION <= 1200))) || defined(__GXX_EXPERIMENTAL_CPP0X__) || defined(__GXX_EXPERIMENTAL_CXX0X__)
#  define BOOST_INTEL_STDCXX0X
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1600)
#  define BOOST_INTEL_STDCXX0X
#endif

#ifdef __GNUC__
#  define BOOST_INTEL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif

#if !defined(BOOST_COMPILER)
#  if defined(BOOST_INTEL_STDCXX0X)
#    define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
#  else
#    define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
#  endif
#endif

#define BOOST_INTEL BOOST_INTEL_CXX_VERSION

#if defined(_WIN32) || defined(_WIN64)
#  define BOOST_INTEL_WIN BOOST_INTEL
#else
#  define BOOST_INTEL_LINUX BOOST_INTEL
#endif

#if (BOOST_INTEL_CXX_VERSION <= 600)

#  if defined(_MSC_VER) && (_MSC_VER <= 1300) // added check for <= VC 7 (Peter Dimov)

// Boost libraries assume strong standard conformance unless otherwise
// indicated by a config macro. As configured by Intel, the EDG front-end
// requires certain compiler options be set to achieve that strong conformance.
// Particularly /Qoption,c,--arg_dep_lookup (reported by Kirk Klobe & Thomas Witt)
// and /Zc:wchar_t,forScope. See boost-root/tools/build/intel-win32-tools.jam for
// details as they apply to particular versions of the compiler. When the
// compiler does not predefine a macro indicating if an option has been set,
// this config file simply assumes the option has been set.
// Thus BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP will not be defined, even if
// the compiler option is not enabled.

#     define BOOST_NO_SWPRINTF
#  endif

// Void returns, 64 bit integrals don't work when emulating VC 6 (Peter Dimov)

#  if defined(_MSC_VER) && (_MSC_VER <= 1200)
#     define BOOST_NO_VOID_RETURNS
#     define BOOST_NO_INTEGRAL_INT64_T
#  endif

#endif

#if (BOOST_INTEL_CXX_VERSION <= 710) && defined(_WIN32)
#  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
#endif

// See http://aspn.activestate.com/ASPN/Mail/Message/boost/1614864
#if BOOST_INTEL_CXX_VERSION < 600
#  define BOOST_NO_INTRINSIC_WCHAR_T
#else
// We should test the macro _WCHAR_T_DEFINED to check if the compiler
// supports wchar_t natively. *BUT* there is a problem here: the standard
// headers define this macro if they typedef wchar_t. Anyway, we're lucky
// because they define it without a value, while Intel C++ defines it
// to 1. So we can check its value to see if the macro was defined natively
// or not.
// Under UNIX, the situation is exactly the same, but the macro _WCHAR_T
// is used instead.
#  if ((_WCHAR_T_DEFINED + 0) == 0) && ((_WCHAR_T + 0) == 0)
#    define BOOST_NO_INTRINSIC_WCHAR_T
#  endif
#endif

#if defined(__GNUC__) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
//
// Figure out when Intel is emulating this gcc bug
// (All Intel versions prior to 9.0.26, and versions
// later than that if they are set up to emulate gcc 3.2
// or earlier):
//
#  if ((__GNUC__ == 3) && (__GNUC_MINOR__ <= 2)) || (BOOST_INTEL < 900) || (__INTEL_COMPILER_BUILD_DATE < 20050912)
#     define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#  endif
#endif
#if (defined(__GNUC__) && (__GNUC__ < 4)) || (defined(_WIN32) && (BOOST_INTEL_CXX_VERSION <= 1200)) || (BOOST_INTEL_CXX_VERSION <= 1200)
// GCC or VC emulation:
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif
//
// Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T
// set correctly, if we don't do this now, we will get errors later
// in type_traits code among other things, getting this correct
// for the Intel compiler is actually remarkably fragile and tricky:
//
#ifdef __cplusplus
#if defined(BOOST_NO_INTRINSIC_WCHAR_T)
#include <cwchar>
template< typename T > struct assert_no_intrinsic_wchar_t;
template<> struct assert_no_intrinsic_wchar_t<wchar_t> { typedef void type; };
// if you see an error here then you need to unset BOOST_NO_INTRINSIC_WCHAR_T
// where it is defined above:
typedef assert_no_intrinsic_wchar_t<unsigned short>::type assert_no_intrinsic_wchar_t_;
#else
template< typename T > struct assert_intrinsic_wchar_t;
template<> struct assert_intrinsic_wchar_t<wchar_t> {};
// if you see an error here then define BOOST_NO_INTRINSIC_WCHAR_T on the command line:
template<> struct assert_intrinsic_wchar_t<unsigned short> {};
#endif
#endif

#if defined(_MSC_VER) && (_MSC_VER+0 >= 1000)
#  if _MSC_VER >= 1200
#     define BOOST_HAS_MS_INT64
#  endif
#  define BOOST_NO_SWPRINTF
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#elif defined(_WIN32)
#  define BOOST_DISABLE_WIN32
#endif

// I checked version 6.0 build 020312Z, it implements the NRVO.
// Correct this as you find out which version of the compiler
// implemented the NRVO first.  (Daniel Frey)
#if (BOOST_INTEL_CXX_VERSION >= 600)
#  define BOOST_HAS_NRVO
#endif

// Branch prediction hints
// I'm not sure 8.0 was the first version to support these builtins,
// update the condition if the version is not accurate. (Andrey Semashev)
#if defined(__GNUC__) && BOOST_INTEL_CXX_VERSION >= 800
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#endif

// RTTI
// __RTTI is the EDG macro
// __INTEL_RTTI__ is the Intel macro
// __GXX_RTTI is the g++ macro
// _CPPRTTI is the MSVC++ macro
#if !defined(__RTTI) && !defined(__INTEL_RTTI__) && !defined(__GXX_RTTI) && !defined(_CPPRTTI)

#if !defined(BOOST_NO_RTTI)
# define BOOST_NO_RTTI
#endif

// in MS mode, static typeid works even when RTTI is off
#if !defined(_MSC_VER) && !defined(BOOST_NO_TYPEID)
# define BOOST_NO_TYPEID
#endif

#endif

//
// versions check:
// we don't support Intel prior to version 6.0:
#if BOOST_INTEL_CXX_VERSION < 600
#  error "Compiler not supported or configured - please reconfigure"
#endif

// Intel on MacOS requires
#if defined(__APPLE__) && defined(__INTEL_COMPILER)
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif

// Intel on Altix Itanium
#if defined(__itanium__) && defined(__INTEL_COMPILER)
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif

//
// An attempt to value-initialize a pointer-to-member may trigger an
// internal error on Intel <= 11.1 (last checked version), as was
// reported by John Maddock, Intel support issue 589832, May 2010.
// Moreover, according to test results from Huang-Vista-x86_32_intel,
// intel-vc9-win-11.1 may leave a non-POD array uninitialized, in some
// cases when it should be value-initialized.
// (Niels Dekker, LKEB, May 2010)
// Apparently Intel 12.1 (compiler version number 9999 !!) has the same issue (compiler regression).
#if defined(__INTEL_COMPILER)
#  if (__INTEL_COMPILER <= 1110) || (__INTEL_COMPILER == 9999) || (defined(_WIN32) && (__INTEL_COMPILER < 1600))
#    define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#  endif
#endif

//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#  define BOOST_SYMBOL_EXPORT __attribute__((visibility("default")))
#  define BOOST_SYMBOL_IMPORT
#  define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default")))
#endif

// Type aliasing hint
#if defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1300)
#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
#endif

//
// C++0x features
// For each feature we need to check both the Intel compiler version, 
// and the version of MSVC or GCC that we are emulating.
// See http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
// for a list of which features were implemented in which Intel releases.
//
#if defined(BOOST_INTEL_STDCXX0X)
// BOOST_NO_CXX11_CONSTEXPR:
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && !defined(_MSC_VER)
// Available in earlier Intel versions, but fail our tests:
#  undef BOOST_NO_CXX11_CONSTEXPR
#endif
// BOOST_NO_CXX11_NULLPTR:
#if (BOOST_INTEL_CXX_VERSION >= 1210) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_NULLPTR
#endif
// BOOST_NO_CXX11_TEMPLATE_ALIASES
#if (BOOST_INTEL_CXX_VERSION >= 1210) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_TEMPLATE_ALIASES
#endif

// BOOST_NO_CXX11_DECLTYPE
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_DECLTYPE
#endif

// BOOST_NO_CXX11_DECLTYPE_N3276
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_DECLTYPE_N3276
#endif

// BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif

// BOOST_NO_CXX11_RVALUE_REFERENCES
#if (BOOST_INTEL_CXX_VERSION >= 1300) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
// This is available from earlier Intel versions, but breaks Filesystem and other libraries:
#  undef BOOST_NO_CXX11_RVALUE_REFERENCES
#endif

// BOOST_NO_CXX11_STATIC_ASSERT
#if (BOOST_INTEL_CXX_VERSION >= 1110) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_STATIC_ASSERT
#endif

// BOOST_NO_CXX11_VARIADIC_TEMPLATES
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif

// BOOST_NO_CXX11_VARIADIC_MACROS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40200)) && (!defined(_MSC_VER) || (_MSC_VER >= 1400))
#  undef BOOST_NO_CXX11_VARIADIC_MACROS
#endif

// BOOST_NO_CXX11_AUTO_DECLARATIONS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_AUTO_DECLARATIONS
#endif

// BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#endif

// BOOST_NO_CXX11_CHAR16_T
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
#  undef BOOST_NO_CXX11_CHAR16_T
#endif

// BOOST_NO_CXX11_CHAR32_T
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
#  undef BOOST_NO_CXX11_CHAR32_T
#endif

// BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#endif

// BOOST_NO_CXX11_DELETED_FUNCTIONS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_DELETED_FUNCTIONS
#endif

// BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
#  undef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#endif

// BOOST_NO_CXX11_SCOPED_ENUMS
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40501)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
// This is available but broken in earlier Intel releases.
#  undef BOOST_NO_CXX11_SCOPED_ENUMS
#endif

// BOOST_NO_SFINAE_EXPR
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
#  undef BOOST_NO_SFINAE_EXPR
#endif

// BOOST_NO_CXX11_SFINAE_EXPR
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && !defined(_MSC_VER)
#  undef BOOST_NO_CXX11_SFINAE_EXPR
#endif

// BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
// This is available in earlier Intel releases, but breaks Multiprecision:
#  undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#endif

// BOOST_NO_CXX11_LAMBDAS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
#  undef BOOST_NO_CXX11_LAMBDAS
#endif

// BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500))
#  undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#endif

// BOOST_NO_CXX11_RANGE_BASED_FOR
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
#  undef BOOST_NO_CXX11_RANGE_BASED_FOR
#endif

// BOOST_NO_CXX11_RAW_LITERALS
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_RAW_LITERALS
#endif

// BOOST_NO_CXX11_UNICODE_LITERALS
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
#  undef BOOST_NO_CXX11_UNICODE_LITERALS
#endif

// BOOST_NO_CXX11_NOEXCEPT
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
// Available in earlier Intel release, but generates errors when used with 
// conditional exception specifications, for example in multiprecision:
#  undef BOOST_NO_CXX11_NOEXCEPT
#endif

// BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
#  undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif

// BOOST_NO_CXX11_USER_DEFINED_LITERALS
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
#  undef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#endif

// BOOST_NO_CXX11_ALIGNAS
#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
#  undef BOOST_NO_CXX11_ALIGNAS
#endif

// BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
#  undef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#endif

// BOOST_NO_CXX11_INLINE_NAMESPACES
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
#  undef BOOST_NO_CXX11_INLINE_NAMESPACES
#endif

// BOOST_NO_CXX11_REF_QUALIFIERS
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
#  undef BOOST_NO_CXX11_REF_QUALIFIERS
#endif

// BOOST_NO_CXX11_FINAL
// BOOST_NO_CXX11_OVERRIDE
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
#  undef BOOST_NO_CXX11_FINAL
#  undef BOOST_NO_CXX11_OVERRIDE
#endif

// BOOST_NO_CXX11_UNRESTRICTED_UNION
#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 50100)) && (!defined(_MSC_VER))
#  undef BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif

#endif // defined(BOOST_INTEL_STDCXX0X)

//
// Broken in all versions up to 15:
#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS

#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION <= 1310)
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#endif

#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION == 1400)
// A regression in Intel's compiler means that <tuple> seems to be broken in this release as well as <future> :
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_TUPLE
#endif

#if (BOOST_INTEL_CXX_VERSION < 1200)
//
// fenv.h appears not to work with Intel prior to 12.0:
//
#  define BOOST_NO_FENV_H
#endif

// Intel 13.10 fails to access defaulted functions of a base class declared in private or protected sections,
// producing the following errors:
// error #453: protected function "..." (declared at ...") is not accessible through a "..." pointer or object
#if (BOOST_INTEL_CXX_VERSION <= 1310)
#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#endif

#if defined(_MSC_VER) && (_MSC_VER >= 1600)
#  define BOOST_HAS_STDINT_H
#endif

#if defined(__CUDACC__)
#  if defined(BOOST_GCC_CXX11)
#    define BOOST_NVCC_CXX11
#  else
#    define BOOST_NVCC_CXX03
#  endif
#endif

#if defined(__LP64__) && defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1310) && !defined(BOOST_NVCC_CXX03)
#  define BOOST_HAS_INT128
#endif

#endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) && (defined(_MSC_VER) || defined(__GNUC__))
//
// last known and checked version:
#if (BOOST_INTEL_CXX_VERSION > 1700)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
#  elif defined(_MSC_VER)
//
//      We don't emit this warning any more, since we have so few
//      defect macros set anyway (just the one).
//
//#     pragma message("boost: Unknown compiler version - please run the configure tests and report the results")
#  endif
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/kai.hpp
================================================
//  (C) Copyright John Maddock 2001. 
//  (C) Copyright David Abrahams 2002. 
//  (C) Copyright Aleksey Gurtovoy 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Kai C++ compiler setup:

#include <boost/config/compiler/common_edg.hpp>

#   if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG)
      // at least on Sun, the contents of <cwchar> is not in namespace std
#     define BOOST_NO_STDC_NAMESPACE
#   endif

// see also common_edg.hpp which needs a special check for __KCC
# if !defined(_EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
#     define BOOST_NO_EXCEPTIONS
# endif

//
// last known and checked version is 4001:
#if (__KCC_VERSION > 4001)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/metrowerks.hpp
================================================
//  (C) Copyright John Maddock 2001.
//  (C) Copyright Darin Adler 2001.
//  (C) Copyright Peter Dimov 2001.
//  (C) Copyright David Abrahams 2001 - 2002.
//  (C) Copyright Beman Dawes 2001 - 2003.
//  (C) Copyright Stefan Slapeta 2004.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Metrowerks C++ compiler setup:

// locale support is disabled when linking with the dynamic runtime
#   ifdef _MSL_NO_LOCALE
#     define BOOST_NO_STD_LOCALE
#   endif

#   if __MWERKS__ <= 0x2301  // 5.3
#     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#     define BOOST_NO_POINTER_TO_MEMBER_CONST
#     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#     define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#   endif

#   if __MWERKS__ <= 0x2401  // 6.2
//#     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#   endif

#   if(__MWERKS__ <= 0x2407)  // 7.x
#     define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
#     define BOOST_NO_UNREACHABLE_RETURN_DETECTION
#   endif

#   if(__MWERKS__ <= 0x3003)  // 8.x
#     define BOOST_NO_SFINAE
#    endif

// the "|| !defined(BOOST_STRICT_CONFIG)" part should apply to the last
// tested version *only*:
#   if(__MWERKS__ <= 0x3207) || !defined(BOOST_STRICT_CONFIG) // 9.6
#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#     define BOOST_NO_IS_ABSTRACT
#    endif

#if !__option(wchar_type)
#   define BOOST_NO_INTRINSIC_WCHAR_T
#endif

#if !__option(exceptions) && !defined(BOOST_NO_EXCEPTIONS)
#   define BOOST_NO_EXCEPTIONS
#endif

#if (__INTEL__ && _WIN32) || (__POWERPC__ && macintosh)
#   if __MWERKS__ == 0x3000
#     define BOOST_COMPILER_VERSION 8.0
#   elif __MWERKS__ == 0x3001
#     define BOOST_COMPILER_VERSION 8.1
#   elif __MWERKS__ == 0x3002
#     define BOOST_COMPILER_VERSION 8.2
#   elif __MWERKS__ == 0x3003
#     define BOOST_COMPILER_VERSION 8.3
#   elif __MWERKS__ == 0x3200
#     define BOOST_COMPILER_VERSION 9.0
#   elif __MWERKS__ == 0x3201
#     define BOOST_COMPILER_VERSION 9.1
#   elif __MWERKS__ == 0x3202
#     define BOOST_COMPILER_VERSION 9.2
#   elif __MWERKS__ == 0x3204
#     define BOOST_COMPILER_VERSION 9.3
#   elif __MWERKS__ == 0x3205
#     define BOOST_COMPILER_VERSION 9.4
#   elif __MWERKS__ == 0x3206
#     define BOOST_COMPILER_VERSION 9.5
#   elif __MWERKS__ == 0x3207
#     define BOOST_COMPILER_VERSION 9.6
#   else
#     define BOOST_COMPILER_VERSION __MWERKS__
#   endif
#else
#  define BOOST_COMPILER_VERSION __MWERKS__
#endif

//
// C++0x features
//
//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
//
#if __MWERKS__ > 0x3206 && __option(rvalue_refs)
#  define BOOST_HAS_RVALUE_REFS
#else
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#endif
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_VARIADIC_MACROS
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)

//
// versions check:
// we don't support Metrowerks prior to version 5.3:
#if __MWERKS__ < 0x2301
#  error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version:
#if (__MWERKS__ > 0x3205)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif









================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/mpw.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  MPW C++ compilers setup:

#   if    defined(__SC__)
#     define BOOST_COMPILER "MPW SCpp version " BOOST_STRINGIZE(__SC__)
#   elif defined(__MRC__)
#     define BOOST_COMPILER "MPW MrCpp version " BOOST_STRINGIZE(__MRC__)
#   else
#     error "Using MPW compiler configuration by mistake.  Please update."
#   endif

//
// MPW 8.90:
//
#if (MPW_CPLUS <= 0x890) || !defined(BOOST_STRICT_CONFIG)
#  define BOOST_NO_CV_SPECIALIZATIONS
#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#  define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#  define BOOST_NO_INTRINSIC_WCHAR_T
#  define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#  define BOOST_NO_USING_TEMPLATE

#  define BOOST_NO_CWCHAR
#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS

#  define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */

#endif

//
// C++0x features
//
//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
//
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_VARIADIC_MACROS
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

//
// versions check:
// we don't support MPW prior to version 8.9:
#if MPW_CPLUS < 0x890
#  error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version is 0x890:
#if (MPW_CPLUS > 0x890)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/nvcc.hpp
================================================
//  (C) Copyright Eric Jourdanneau, Joel Falcou 2010
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  NVIDIA CUDA C++ compiler setup

#ifndef BOOST_COMPILER
#  define BOOST_COMPILER "NVIDIA CUDA C++ Compiler"
#endif

#if defined(__CUDACC_VER_MAJOR__) && defined(__CUDACC_VER_MINOR__) && defined(__CUDACC_VER_BUILD__)
#  define BOOST_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__)
#else
// We don't really know what the CUDA version is, but it's definitely before 7.5:
#  define BOOST_CUDA_VERSION 7000000
#endif

// NVIDIA Specific support
// BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
#define BOOST_GPU_ENABLED __host__ __device__

#if !defined(__clang__) || defined(__NVCC__)
// A bug in version 7.0 of CUDA prevents use of variadic templates in some occasions
// https://svn.boost.org/trac/boost/ticket/11897
// This is fixed in 7.5. As the following version macro was introduced in 7.5 an existance
// check is enough to detect versions < 7.5
#if BOOST_CUDA_VERSION < 7050000
#   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif
// The same bug is back again in 8.0:
#if (BOOST_CUDA_VERSION > 8000000) && (BOOST_CUDA_VERSION < 8010000)
#   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif
// CUDA (8.0) has no constexpr support in msvc mode:
#if defined(_MSC_VER) && (BOOST_CUDA_VERSION < 9000000)
#  define BOOST_NO_CXX11_CONSTEXPR
#endif

#endif

#ifdef __CUDACC__
//
// When compiing .cu files, there's a bunch of stuff that doesn't work with msvc:
//
#if defined(_MSC_VER)
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#endif
//
// And this one effects the NVCC front end,
// See https://svn.boost.org/trac/boost/ticket/13049
//
#if (BOOST_CUDA_VERSION >= 8000000) && (BOOST_CUDA_VERSION < 8010000)
#  define BOOST_NO_CXX11_NOEXCEPT
#endif

#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/pathscale.hpp
================================================
//  (C) Copyright Bryce Lelbach 2011

//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

// PathScale EKOPath C++ Compiler

#ifndef BOOST_COMPILER
#  define BOOST_COMPILER "PathScale EKOPath C++ Compiler version " __PATHSCALE__
#endif

#if __PATHCC__ >= 6 
// PathCC is based on clang, and supports the __has_*() builtins used 
// to detect features in clang.hpp. Since the clang toolset is much 
// better maintained, it is more convenient to reuse its definitions. 
#  include "boost/config/compiler/clang.hpp"
#elif __PATHCC__ >= 4 
#  define BOOST_MSVC6_MEMBER_TEMPLATES
#  define BOOST_HAS_UNISTD_H
#  define BOOST_HAS_STDINT_H
#  define BOOST_HAS_SIGACTION
#  define BOOST_HAS_SCHED_YIELD
#  define BOOST_HAS_THREADS
#  define BOOST_HAS_PTHREADS
#  define BOOST_HAS_PTHREAD_YIELD
#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#  define BOOST_HAS_NRVO
#  define BOOST_HAS_NL_TYPES_H
#  define BOOST_HAS_NANOSLEEP
#  define BOOST_HAS_LONG_LONG
#  define BOOST_HAS_LOG1P
#  define BOOST_HAS_GETTIMEOFDAY
#  define BOOST_HAS_EXPM1
#  define BOOST_HAS_DIRENT_H
#  define BOOST_HAS_CLOCK_GETTIME
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#  define BOOST_NO_CXX11_STATIC_ASSERT
#  define BOOST_NO_SFINAE_EXPR
#  define BOOST_NO_CXX11_SFINAE_EXPR
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_RANGE_BASED_FOR
#  define BOOST_NO_CXX11_RAW_LITERALS
#  define BOOST_NO_CXX11_NULLPTR
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_NOEXCEPT
#  define BOOST_NO_CXX11_LAMBDAS
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  define BOOST_NO_CXX11_DECLTYPE
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#  define BOOST_NO_CXX11_CONSTEXPR
#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#  define BOOST_NO_CXX11_CHAR32_T
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#  define BOOST_NO_CXX11_ALIGNAS
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_OVERRIDE
#  define BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/pgi.hpp
================================================
//  (C) Copyright Noel Belcourt 2007.
//  Copyright 2017, NVIDIA CORPORATION.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  PGI C++ compiler setup:

#define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__
#define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)

// PGI is mostly GNU compatible.  So start with that.
#include <boost/config/compiler/gcc.hpp>

// Now adjust for things that are different.

// __float128 is a typedef, not a distinct type.
#undef BOOST_HAS_FLOAT128

// __int128 is not supported.
#undef BOOST_HAS_INT128


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/sgi_mipspro.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  SGI C++ compiler setup:

#define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)

#include <boost/config/compiler/common_edg.hpp>

//
// Threading support:
// Turn this on unconditionally here, it will get turned off again later
// if no threading API is detected.
//
#define BOOST_HAS_THREADS
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP

#undef BOOST_NO_SWPRINTF
#undef BOOST_DEDUCED_TYPENAME

//
// version check:
// probably nothing to do here?




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/sunpro_cc.hpp
================================================
//  (C) Copyright John Maddock 2001.
//  (C) Copyright Jens Maurer 2001 - 2003.
//  (C) Copyright Peter Dimov 2002.
//  (C) Copyright Aleksey Gurtovoy 2002 - 2003.
//  (C) Copyright David Abrahams 2002.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Sun C++ compiler setup:

#    if __SUNPRO_CC <= 0x500
#      define BOOST_NO_MEMBER_TEMPLATES
#      define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#    endif

#    if (__SUNPRO_CC <= 0x520)
       //
       // Sunpro 5.2 and earler:
       //
       // although sunpro 5.2 supports the syntax for
       // inline initialization it often gets the value
       // wrong, especially where the value is computed
       // from other constants (J Maddock 6th May 2001)
#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION

       // Although sunpro 5.2 supports the syntax for
       // partial specialization, it often seems to
       // bind to the wrong specialization.  Better
       // to disable it until suppport becomes more stable
       // (J Maddock 6th May 2001).
#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#    endif

#    if (__SUNPRO_CC <= 0x530)
       // Requesting debug info (-g) with Boost.Python results
       // in an internal compiler error for "static const"
       // initialized in-class.
       //    >> Assertion:   (../links/dbg_cstabs.cc, line 611)
       //         while processing ../test.cpp at line 0.
       // (Jens Maurer according to Gottfried Ganssauge 04 Mar 2002)
#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION

       // SunPro 5.3 has better support for partial specialization,
       // but breaks when compiling std::less<shared_ptr<T> >
       // (Jens Maurer 4 Nov 2001).

       // std::less specialization fixed as reported by George
       // Heintzelman; partial specialization re-enabled
       // (Peter Dimov 17 Jan 2002)

//#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

       // integral constant expressions with 64 bit numbers fail
#      define BOOST_NO_INTEGRAL_INT64_T
#    endif

#    if (__SUNPRO_CC < 0x570)
#      define BOOST_NO_TEMPLATE_TEMPLATES
       // see http://lists.boost.org/MailArchives/boost/msg47184.php
       // and http://lists.boost.org/MailArchives/boost/msg47220.php
#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#      define BOOST_NO_SFINAE
#      define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
#    endif
#    if (__SUNPRO_CC <= 0x580)
#      define BOOST_NO_IS_ABSTRACT
#    endif

#    if (__SUNPRO_CC <= 0x5100)
       // Sun 5.10 may not correctly value-initialize objects of
       // some user defined types, as was reported in April 2010
       // (CR 6947016), and confirmed by Steve Clamage.
       // (Niels Dekker, LKEB, May 2010).
#      define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#    endif

//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if __SUNPRO_CC > 0x500
#  define BOOST_SYMBOL_EXPORT __global
#  define BOOST_SYMBOL_IMPORT __global
#  define BOOST_SYMBOL_VISIBLE __global
#endif

// Deprecated symbol markup
// Oracle Studio 12.4 supports deprecated attribute with a message; this is the first release that supports the attribute.
#if (__SUNPRO_CC >= 0x5130)
#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
#endif

#if (__SUNPRO_CC < 0x5130)
// C++03 features in 12.4:
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_ADL_BARRIER
#define BOOST_NO_CXX11_VARIADIC_MACROS
#endif

#if (__SUNPRO_CC < 0x5130) || (__cplusplus < 201100)
// C++11 only featuires in 12.4:
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_EXTERN_TEMPLATE
#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif

#if (__SUNPRO_CC < 0x5140) || (__cplusplus < 201103)
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_THREAD_LOCAL
#endif

#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
//
// C++0x features
//
#  define BOOST_HAS_LONG_LONG

#define BOOST_NO_CXX11_SFINAE_EXPR

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304) || (__cplusplus < 201402L)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

// Turn on threading support for Solaris 12.
// Ticket #11972
#if (__SUNPRO_CC >= 0x5140) && defined(__SunOS_5_12) && !defined(BOOST_HAS_THREADS)
# define BOOST_HAS_THREADS
#endif

//
// Version
//

#define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC)

//
// versions check:
// we don't support sunpro prior to version 4:
#if __SUNPRO_CC < 0x400
#error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version:
#if (__SUNPRO_CC > 0x5150)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
#  endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/vacpp.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright Toon Knapen 2001 - 2003.
//  (C) Copyright Lie-Quan Lee 2001.
//  (C) Copyright Markus Schoepflin 2002 - 2003.
//  (C) Copyright Beman Dawes 2002 - 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Visual Age (IBM) C++ compiler setup:

#if __IBMCPP__ <= 501
#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
#endif

#if (__IBMCPP__ <= 502)
// Actually the compiler supports inclass member initialization but it
// requires a definition for the class member and it doesn't recognize
// it as an integral constant expression when used as a template argument.
#  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#  define BOOST_NO_INTEGRAL_INT64_T
#  define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#endif

#if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG)
#  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
#endif

#if (__IBMCPP__ <= 1110)
// XL C++ V11.1 and earlier versions may not always value-initialize
// a temporary object T(), when T is a non-POD aggregate class type.
// Michael Wong (IBM Canada Ltd) has confirmed this issue and gave it
// high priority. -- Niels Dekker (LKEB), May 2010.
#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#endif

//
// On AIX thread support seems to be indicated by _THREAD_SAFE:
//
#ifdef _THREAD_SAFE
#  define BOOST_HAS_THREADS
#endif

#define BOOST_COMPILER "IBM Visual Age version " BOOST_STRINGIZE(__IBMCPP__)

//
// versions check:
// we don't support Visual age prior to version 5:
#if __IBMCPP__ < 500
#error "Compiler not supported or configured - please reconfigure"
#endif
//
// last known and checked version is 1210:
#if (__IBMCPP__ > 1210)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "boost: Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif

// Some versions of the compiler have issues with default arguments on partial specializations
#if __IBMCPP__ <= 1010
#define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
#endif

// Type aliasing hint. Supported since XL C++ 13.1
#if (__IBMCPP__ >= 1310)
#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
#endif

//
// C++0x features
//
//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
//
#if ! __IBMCPP_AUTO_TYPEDEDUCTION
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#endif
#if ! __IBMCPP_UTF_LITERAL__
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#endif
#if ! __IBMCPP_CONSTEXPR
#  define BOOST_NO_CXX11_CONSTEXPR
#endif
#if ! __IBMCPP_DECLTYPE
#  define BOOST_NO_CXX11_DECLTYPE
#else
#  define BOOST_HAS_DECLTYPE
#endif
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#if ! __IBMCPP_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#endif
#if ! __IBMCPP_EXTERN_TEMPLATE
#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
#endif
#if ! __IBMCPP_VARIADIC_TEMPLATES
// not enabled separately at this time
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#if ! __IBMCPP_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#endif
#if ! __IBMCPP_SCOPED_ENUM
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#endif
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#if ! __IBMCPP_STATIC_ASSERT
#  define BOOST_NO_CXX11_STATIC_ASSERT
#endif
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
#if ! __IBMCPP_VARIADIC_TEMPLATES
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif
#if ! __C99_MACRO_WITH_VA_ARGS
#  define BOOST_NO_CXX11_VARIADIC_MACROS
#endif
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_UNRESTRICTED_UNION

// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif
#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif
#if (__cplusplus < 201304) // There's no SD6 check for this....
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif
#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif
#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

// C++17
#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif
#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#endif
#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif
#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/visualc.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright Darin Adler 2001 - 2002.
//  (C) Copyright Peter Dimov 2001.
//  (C) Copyright Aleksey Gurtovoy 2002.
//  (C) Copyright David Abrahams 2002 - 2003.
//  (C) Copyright Beman Dawes 2002 - 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.
//
//  Microsoft Visual C++ compiler setup:
//
//  We need to be careful with the checks in this file, as contrary
//  to popular belief there are versions with _MSC_VER with the final
//  digit non-zero (mainly the MIPS cross compiler).
//
//  So we either test _MSC_VER >= XXXX or else _MSC_VER < XXXX.
//  No other comparisons (==, >, or <=) are safe.
//

#define BOOST_MSVC _MSC_VER

//
// Helper macro BOOST_MSVC_FULL_VER for use in Boost code:
//
#if _MSC_FULL_VER > 100000000
#  define BOOST_MSVC_FULL_VER _MSC_FULL_VER
#else
#  define BOOST_MSVC_FULL_VER (_MSC_FULL_VER * 10)
#endif

// Attempt to suppress VC6 warnings about the length of decorated names (obsolete):
#pragma warning( disable : 4503 ) // warning: decorated name length exceeded

#define BOOST_HAS_PRAGMA_ONCE

//
// versions check:
// we don't support Visual C++ prior to version 7.1:
#if _MSC_VER < 1310
#  error "Compiler not supported or configured - please reconfigure"
#endif

// VS2005 (VC8) docs: __assume has been in Visual C++ for multiple releases
#define BOOST_UNREACHABLE_RETURN(x) __assume(0);

#if _MSC_FULL_VER < 180020827
#  define BOOST_NO_FENV_H
#endif

#if _MSC_VER < 1400
// although a conforming signature for swprint exists in VC7.1
// it appears not to actually work:
#  define BOOST_NO_SWPRINTF
// Our extern template tests also fail for this compiler:
#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
// Variadic macros do not exist for VC7.1 and lower
#  define BOOST_NO_CXX11_VARIADIC_MACROS
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#endif

#if _MSC_VER < 1500  // 140X == VC++ 8.0
#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#endif

#if _MSC_VER < 1600  // 150X == VC++ 9.0
   // A bug in VC9:
#  define BOOST_NO_ADL_BARRIER
#endif


#ifndef _NATIVE_WCHAR_T_DEFINED
#  define BOOST_NO_INTRINSIC_WCHAR_T
#endif

//
// check for exception handling support:
#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

//
// __int64 support:
//
#define BOOST_HAS_MS_INT64
#if defined(_MSC_EXTENSIONS) || (_MSC_VER >= 1400)
#   define BOOST_HAS_LONG_LONG
#else
#   define BOOST_NO_LONG_LONG
#endif
#if (_MSC_VER >= 1400) && !defined(_DEBUG)
#   define BOOST_HAS_NRVO
#endif
#if _MSC_VER >= 1600  // 160X == VC++ 10.0
#  define BOOST_HAS_PRAGMA_DETECT_MISMATCH
#endif
//
// disable Win32 API's if compiler extensions are
// turned off:
//
#if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32)
#  define BOOST_DISABLE_WIN32
#endif
#if !defined(_CPPRTTI) && !defined(BOOST_NO_RTTI)
#  define BOOST_NO_RTTI
#endif

// Deprecated symbol markup
#if (_MSC_VER >= 1400)
#define BOOST_DEPRECATED(msg) __declspec(deprecated(msg))
#else
// MSVC 7.1 only supports the attribute without a message
#define BOOST_DEPRECATED(msg) __declspec(deprecated)
#endif

//
// TR1 features:
//
#if (_MSC_VER >= 1700) && defined(_HAS_CXX17) && (_HAS_CXX17 > 0)
// # define BOOST_HAS_TR1_HASH          // don't know if this is true yet.
// # define BOOST_HAS_TR1_TYPE_TRAITS   // don't know if this is true yet.
# define BOOST_HAS_TR1_UNORDERED_MAP
# define BOOST_HAS_TR1_UNORDERED_SET
#endif

//
// C++0x features
//
//   See above for BOOST_NO_LONG_LONG

// C++ features supported by VC++ 10 (aka 2010)
//
#if _MSC_VER < 1600
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  define BOOST_NO_CXX11_LAMBDAS
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#  define BOOST_NO_CXX11_STATIC_ASSERT
#  define BOOST_NO_CXX11_NULLPTR
#  define BOOST_NO_CXX11_DECLTYPE
#endif // _MSC_VER < 1600

#if _MSC_VER >= 1600
#  define BOOST_HAS_STDINT_H
#endif

// C++11 features supported by VC++ 11 (aka 2012)
//
#if _MSC_VER < 1700
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_RANGE_BASED_FOR
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#  define BOOST_NO_CXX11_OVERRIDE
#endif // _MSC_VER < 1700

// C++11 features supported by VC++ 12 (aka 2013).
//
#if _MSC_FULL_VER < 180020827
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#  define BOOST_NO_CXX11_RAW_LITERALS
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#endif

#if _MSC_FULL_VER >= 180020827
#define BOOST_HAS_EXPM1
#define BOOST_HAS_LOG1P
#endif

// C++11 features supported by VC++ 14 (aka 2015)
//
#if (_MSC_FULL_VER < 190023026)
#  define BOOST_NO_CXX11_NOEXCEPT
#  define BOOST_NO_CXX11_DEFAULTED_MOVES
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#  define BOOST_NO_CXX11_ALIGNAS
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#  define BOOST_NO_CXX14_BINARY_LITERALS
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#  define BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif
// C++11 features supported by VC++ 14 update 3 (aka 2015)
//
#if (_MSC_FULL_VER < 190024210)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#  define BOOST_NO_SFINAE_EXPR
#  define BOOST_NO_CXX11_CONSTEXPR
#endif

// C++14 features supported by VC++ 14.1 (Visual Studio 2017)
//
#if (_MSC_VER < 1910)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif

// C++17 features supported by VC++ 14.1 (Visual Studio 2017) Update 3
//
#if (_MSC_VER < 1911) || (_MSVC_LANG < 201703)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#  define BOOST_NO_CXX17_IF_CONSTEXPR
// Let the defaults handle these now:
//#  define BOOST_NO_CXX17_HDR_OPTIONAL
//#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#endif

// MSVC including version 14 has not yet completely
// implemented value-initialization, as is reported:
// "VC++ does not value-initialize members of derived classes without
// user-declared constructor", reported in 2009 by Sylvester Hesp:
// https://connect.microsoft.com/VisualStudio/feedback/details/484295
// "Presence of copy constructor breaks member class initialization",
// reported in 2009 by Alex Vakulenko:
// https://connect.microsoft.com/VisualStudio/feedback/details/499606
// "Value-initialization in new-expression", reported in 2005 by
// Pavel Kuznetsov (MetaCommunications Engineering):
// https://connect.microsoft.com/VisualStudio/feedback/details/100744
// Reported again by John Maddock in 2015 for VC14:
// https://connect.microsoft.com/VisualStudio/feedback/details/1582233/c-subobjects-still-not-value-initialized-correctly
// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
// (Niels Dekker, LKEB, May 2010)
// Still present in VC15.5, Dec 2017.
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
//
// C++ 11:
//
// This is supported with /permissive- for 15.5 onwards, unfortunately we appear to have no way to tell
// if this is in effect or not, in any case nothing in Boost is currently using this, so we'll just go
// on defining it for now:
//
#if (_MSC_FULL_VER < 193030705)  || (_MSVC_LANG < 202004)
#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
#endif

#if (_MSC_VER < 1912) || (_MSVC_LANG < 201402)
// Supported from msvc-15.5 onwards:
#define BOOST_NO_CXX11_SFINAE_EXPR
#endif
#if (_MSC_VER < 1915) || (_MSVC_LANG < 201402)
// C++ 14:
// Still gives internal compiler error for msvc-15.5:
#  define BOOST_NO_CXX14_CONSTEXPR
#endif
// C++ 17:
#if (_MSC_VER < 1912) || (_MSVC_LANG < 201703)
#define BOOST_NO_CXX17_INLINE_VARIABLES
#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif

//
// Things that don't work in clr mode:
//
#ifdef _M_CEE
#ifndef BOOST_NO_CXX11_THREAD_LOCAL
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif
#ifndef BOOST_NO_SFINAE_EXPR
#  define BOOST_NO_SFINAE_EXPR
#endif
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#endif
#endif
#ifdef _M_CEE_PURE
#ifndef BOOST_NO_CXX11_CONSTEXPR
#  define BOOST_NO_CXX11_CONSTEXPR
#endif
#endif

//
// prefix and suffix headers:
//
#ifndef BOOST_ABI_PREFIX
#  define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp"
#endif
#ifndef BOOST_ABI_SUFFIX
#  define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp"
#endif

//
// Approximate compiler conformance version
//
#ifdef _MSVC_LANG
#  define BOOST_CXX_VERSION _MSVC_LANG
#elif defined(_HAS_CXX17)
#  define BOOST_CXX_VERSION 201703L
#elif BOOST_MSVC >= 1916
#  define BOOST_CXX_VERSION 201402L
#endif

#ifndef BOOST_COMPILER
// TODO:
// these things are mostly bogus. 1200 means version 12.0 of the compiler. The
// artificial versions assigned to them only refer to the versions of some IDE
// these compilers have been shipped with, and even that is not all of it. Some
// were shipped with freely downloadable SDKs, others as crosscompilers in eVC.
// IOW, you can't use these 'versions' in any sensible way. Sorry.
# if defined(UNDER_CE)
#   if _MSC_VER < 1400
      // Note: I'm not aware of any CE compiler with version 13xx
#      if defined(BOOST_ASSERT_CONFIG)
#         error "boost: Unknown EVC++ compiler version - please run the configure tests and report the results"
#      else
#         pragma message("boost: Unknown EVC++ compiler version - please run the configure tests and report the results")
#      endif
#   elif _MSC_VER < 1500
#     define BOOST_COMPILER_VERSION evc8
#   elif _MSC_VER < 1600
#     define BOOST_COMPILER_VERSION evc9
#   elif _MSC_VER < 1700
#     define BOOST_COMPILER_VERSION evc10
#   elif _MSC_VER < 1800 
#     define BOOST_COMPILER_VERSION evc11 
#   elif _MSC_VER < 1900 
#     define BOOST_COMPILER_VERSION evc12
#   elif _MSC_VER < 2000  
#     define BOOST_COMPILER_VERSION evc14
#   else
#      if defined(BOOST_ASSERT_CONFIG)
#         error "boost: Unknown EVC++ compiler version - please run the configure tests and report the results"
#      else
#         pragma message("boost: Unknown EVC++ compiler version - please run the configure tests and report the results")
#      endif
#   endif
# else
#   if _MSC_VER < 1200
      // Note: Versions up to 10.0 aren't supported.
#     define BOOST_COMPILER_VERSION 5.0
#   elif _MSC_VER < 1300
#     define BOOST_COMPILER_VERSION 6.0
#   elif _MSC_VER < 1310
#     define BOOST_COMPILER_VERSION 7.0
#   elif _MSC_VER < 1400
#     define BOOST_COMPILER_VERSION 7.1
#   elif _MSC_VER < 1500
#     define BOOST_COMPILER_VERSION 8.0
#   elif _MSC_VER < 1600
#     define BOOST_COMPILER_VERSION 9.0
#   elif _MSC_VER < 1700
#     define BOOST_COMPILER_VERSION 10.0
#   elif _MSC_VER < 1800 
#     define BOOST_COMPILER_VERSION 11.0
#   elif _MSC_VER < 1900
#     define BOOST_COMPILER_VERSION 12.0
#   elif _MSC_VER < 1910
#     define BOOST_COMPILER_VERSION 14.0
#   elif _MSC_VER < 1920
#     define BOOST_COMPILER_VERSION 14.1
#   elif _MSC_VER < 1930
#     define BOOST_COMPILER_VERSION 14.2
#   else
#     define BOOST_COMPILER_VERSION _MSC_VER
#   endif
# endif

#  define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
#endif

#include <boost/config/pragma_message.hpp>

//
// last known and checked version is 19.20.27508 (VC++ 2019 RC3):
#if (_MSC_VER > 1920)
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Boost.Config is older than your current compiler version."
#  elif !defined(BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
      //
      // Disabled as of March 2018 - the pace of VS releases is hard to keep up with
      // and in any case, we have relatively few defect macros defined now.
      // BOOST_PRAGMA_MESSAGE("Info: Boost.Config is older than your compiler version - probably nothing bad will happen - but you may wish to look for an updated Boost version. Define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE to suppress this message.")
#  endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/xlcpp.hpp
================================================
// (C) Copyright Douglas Gregor 2010
//
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  compiler setup for IBM XL C/C++ for Linux (Little Endian) based on clang.

#define BOOST_HAS_PRAGMA_ONCE

// Detecting `-fms-extension` compiler flag assuming that _MSC_VER defined when that flag is used.
#if defined (_MSC_VER) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))
#   define BOOST_HAS_PRAGMA_DETECT_MISMATCH
#endif

// When compiling with clang before __has_extension was defined,
// even if one writes 'defined(__has_extension) && __has_extension(xxx)',
// clang reports a compiler error. So the only workaround found is:

#ifndef __has_extension
#define __has_extension __has_feature
#endif

#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) 0
#endif

#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_RTTI)
#  define BOOST_NO_RTTI
#endif

#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_TYPEID)
#  define BOOST_NO_TYPEID
#endif

#if defined(__int64) && !defined(__GNUC__)
#  define BOOST_HAS_MS_INT64
#endif

#define BOOST_HAS_NRVO

// Branch prediction hints
#if defined(__has_builtin)
#if __has_builtin(__builtin_expect)
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#endif
#endif

// Clang supports "long long" in all compilation modes.
#define BOOST_HAS_LONG_LONG

//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
#if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
#  define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#  define BOOST_SYMBOL_IMPORT
#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#endif

//
// The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
// between switch labels.
//
#if __cplusplus >= 201103L && defined(__has_warning)
#  if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
#    define BOOST_FALLTHROUGH [[clang::fallthrough]]
#  endif
#endif

#if !__has_feature(cxx_auto_type)
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#endif

//
// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t
//
#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
#  define BOOST_NO_CXX11_CHAR16_T
#  define BOOST_NO_CXX11_CHAR32_T
#endif

#if !__has_feature(cxx_constexpr)
#  define BOOST_NO_CXX11_CONSTEXPR
#endif

#if !__has_feature(cxx_decltype)
#  define BOOST_NO_CXX11_DECLTYPE
#endif

#if !__has_feature(cxx_decltype_incomplete_return_types)
#  define BOOST_NO_CXX11_DECLTYPE_N3276
#endif

#if !__has_feature(cxx_defaulted_functions)
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#endif

#if !__has_feature(cxx_deleted_functions)
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#endif

#if !__has_feature(cxx_explicit_conversions)
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#endif

#if !__has_feature(cxx_default_function_template_args)
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif

#if !__has_feature(cxx_generalized_initializers)
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#endif

#if !__has_feature(cxx_lambdas)
#  define BOOST_NO_CXX11_LAMBDAS
#endif

#if !__has_feature(cxx_local_type_template_args)
#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#endif

#if !__has_feature(cxx_noexcept)
#  define BOOST_NO_CXX11_NOEXCEPT
#endif

#if !__has_feature(cxx_nullptr)
#  define BOOST_NO_CXX11_NULLPTR
#endif

#if !__has_feature(cxx_range_for)
#  define BOOST_NO_CXX11_RANGE_BASED_FOR
#endif

#if !__has_feature(cxx_raw_string_literals)
#  define BOOST_NO_CXX11_RAW_LITERALS
#endif

#if !__has_feature(cxx_reference_qualified_functions)
#  define BOOST_NO_CXX11_REF_QUALIFIERS
#endif

#if !__has_feature(cxx_generalized_initializers)
#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif

#if !__has_feature(cxx_rvalue_references)
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#endif

#if !__has_feature(cxx_strong_enums)
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#endif

#if !__has_feature(cxx_static_assert)
#  define BOOST_NO_CXX11_STATIC_ASSERT
#endif

#if !__has_feature(cxx_alias_templates)
#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
#endif

#if !__has_feature(cxx_unicode_literals)
#  define BOOST_NO_CXX11_UNICODE_LITERALS
#endif

#if !__has_feature(cxx_variadic_templates)
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif

#if !__has_feature(cxx_user_literals)
#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#endif

#if !__has_feature(cxx_alignas)
#  define BOOST_NO_CXX11_ALIGNAS
#endif

#if !__has_feature(cxx_trailing_return)
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#endif

#if !__has_feature(cxx_inline_namespaces)
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#endif

#if !__has_feature(cxx_override_control)
#  define BOOST_NO_CXX11_FINAL
#  define BOOST_NO_CXX11_OVERRIDE
#endif

#if !__has_feature(cxx_unrestricted_unions)
#  define BOOST_NO_CXX11_UNRESTRICTED_UNION
#endif

#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
#  define BOOST_NO_CXX14_BINARY_LITERALS
#endif

#if !__has_feature(__cxx_decltype_auto__)
#  define BOOST_NO_CXX14_DECLTYPE_AUTO
#endif

#if !__has_feature(__cxx_aggregate_nsdmi__)
#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
#endif

#if !__has_feature(__cxx_init_captures__)
#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#endif

#if !__has_feature(__cxx_generic_lambdas__)
#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif

// clang < 3.5 has a defect with dependent type, like following.
//
//  template <class T>
//  constexpr typename enable_if<pred<T> >::type foo(T &)
//  { } // error: no return statement in constexpr function
//
// This issue also affects C++11 mode, but C++11 constexpr requires return stmt.
// Therefore we don't care such case.
//
// Note that we can't check Clang version directly as the numbering system changes depending who's
// creating the Clang release (see https://github.com/boostorg/config/pull/39#issuecomment-59927873)
// so instead verify that we have a feature that was introduced at the same time as working C++14
// constexpr (generic lambda's in this case):
//
#if !__has_feature(__cxx_generic_lambdas__) || !__has_feature(__cxx_relaxed_constexpr__)
#  define BOOST_NO_CXX14_CONSTEXPR
#endif

#if !__has_feature(__cxx_return_type_deduction__)
#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#endif

#if !__has_feature(__cxx_variable_templates__)
#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif

#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#endif

#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
#  define BOOST_NO_CXX17_IF_CONSTEXPR
#endif

// Clang 3.9+ in c++1z
#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
#  define BOOST_NO_CXX17_INLINE_VARIABLES
#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#endif

#if !__has_feature(cxx_thread_local)
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif

#if __cplusplus < 201400
// All versions with __cplusplus above this value seem to support this:
#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
#endif

// Deprecated symbol markup
#if __has_attribute(deprecated)
#define BOOST_DEPRECATED(msg) __attribute__((deprecated(msg)))
#endif

// Unused attribute:
#if defined(__GNUC__) && (__GNUC__ >= 4)
#  define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
#endif

// Type aliasing hint.
#if __has_attribute(__may_alias__)
#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
#endif

#ifndef BOOST_COMPILER
#  define BOOST_COMPILER "Clang version " __clang_version__
#endif

// Macro used to identify the Clang compiler.
#define BOOST_CLANG 1

#define BOOST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/compiler/xlcpp_zos.hpp
================================================
//  Copyright (c) 2017 Dynatrace
//
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt

//  See http://www.boost.org for most recent version.

//  Compiler setup for IBM z/OS XL C/C++ compiler.

// Oldest compiler version currently supported is 2.1 (V2R1)
#if !defined(__IBMCPP__) || !defined(__COMPILER_VER__) || __COMPILER_VER__ < 0x42010000
#  error "Compiler not supported or configured - please reconfigure"
#endif

#if __COMPILER_VER__ > 0x42010000
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Unknown compiler version - please run the configure tests and report the results"
#  endif
#endif

#define BOOST_COMPILER "IBM z/OS XL C/C++ version " BOOST_STRINGIZE(__COMPILER_VER__)
#define BOOST_XLCPP_ZOS __COMPILER_VER__

// -------------------------------------

#include <features.h> // For __UU, __C99, __TR1, ...

#if !defined(__IBMCPP_DEFAULTED_AND_DELETED_FUNCTIONS)
#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#endif

// -------------------------------------

#if defined(__UU) || defined(__C99) || defined(__TR1)
#  define BOOST_HAS_LOG1P
#  define BOOST_HAS_EXPM1
#endif

#if defined(__C99) || defined(__TR1)
#  define BOOST_HAS_STDINT_H
#else
#  define BOOST_NO_FENV_H
#endif

// -------------------------------------

#define BOOST_HAS_NRVO

#if !defined(__RTTI_ALL__)
#  define BOOST_NO_RTTI
#endif

#if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
#  define BOOST_NO_EXCEPTIONS
#endif

#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL)
#  define BOOST_HAS_LONG_LONG
#else
#  define BOOST_NO_LONG_LONG
#endif

#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL) || defined(_LP64)
#  define BOOST_HAS_MS_INT64
#endif

#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_SFINAE_EXPR

#if defined(__IBMCPP_VARIADIC_TEMPLATES)
#  define BOOST_HAS_VARIADIC_TMPL
#else
#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif

#if defined(__IBMCPP_STATIC_ASSERT)
#  define BOOST_HAS_STATIC_ASSERT
#else
#  define BOOST_NO_CXX11_STATIC_ASSERT
#endif

#if defined(__IBMCPP_RVALUE_REFERENCES)
#  define BOOST_HAS_RVALUE_REFS
#else
#  define BOOST_NO_CXX11_RVALUE_REFERENCES
#endif

#if !defined(__IBMCPP_SCOPED_ENUM)
#  define BOOST_NO_CXX11_SCOPED_ENUMS
#endif

#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS

#if !defined(__IBMCPP_EXPLICIT_CONVERSION_OPERATORS)
#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#endif

#if !defined(__IBMCPP_DECLTYPE)
#  define BOOST_NO_CXX11_DECLTYPE
#else
#  define BOOST_HAS_DECLTYPE
#endif
#define BOOST_NO_CXX11_DECLTYPE_N3276

#if !defined(__IBMCPP_INLINE_NAMESPACE)
#  define BOOST_NO_CXX11_INLINE_NAMESPACES
#endif

#if !defined(__IBMCPP_AUTO_TYPEDEDUCTION)
#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#endif

#if !defined(__IBM_CHAR32_T__)
#  define BOOST_NO_CXX11_CHAR32_T
#endif
#if !defined(__IBM_CHAR16_T__)
#  define BOOST_NO_CXX11_CHAR16_T
#endif

#if !defined(__IBMCPP_CONSTEXPR)
#  define BOOST_NO_CXX11_CONSTEXPR
#endif

#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RANGE_BASED_FOR
#define BOOST_NO_CXX11_NULLPTR
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_LAMBDAS
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_THREAD_LOCAL
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
#define BOOST_NO_CXX11_OVERRIDE
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_UNRESTRICTED_UNION
#define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#define BOOST_NO_CXX14_AGGREGATE_NSDMI
#define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#define BOOST_NO_CXX14_GENERIC_LAMBDAS
#define BOOST_NO_CXX14_DIGIT_SEPARATORS
#define BOOST_NO_CXX14_DECLTYPE_AUTO
#define BOOST_NO_CXX14_CONSTEXPR
#define BOOST_NO_CXX14_BINARY_LITERALS
#define BOOST_NO_CXX17_STRUCTURED_BINDINGS
#define BOOST_NO_CXX17_INLINE_VARIABLES
#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
#define BOOST_NO_CXX17_IF_CONSTEXPR

// -------------------------------------

#if defined(__IBM_ATTRIBUTES)
#  define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
#  define BOOST_NOINLINE __attribute__ ((__noinline__))
#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
// No BOOST_ALIGNMENT - explicit alignment support is broken (V2R1).
#endif

extern "builtin" long __builtin_expect(long, long);

#define BOOST_LIKELY(x) __builtin_expect((x) && true, 1)
#define BOOST_UNLIKELY(x) __builtin_expect((x) && true, 0)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/cxx_composite.hpp
================================================
//  This file was automatically generated on Sun Jun  5 16:50:18 2022
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-21.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for the most recent version.//
//  Revision $Id$
//

#if defined(BOOST_NO_ADL_BARRIER)\
   || defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)\
   || defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)\
   || defined(BOOST_NO_COMPLETE_VALUE_INITIALIZATION)\
   || defined(BOOST_NO_CTYPE_FUNCTIONS)\
   || defined(BOOST_NO_CV_SPECIALIZATIONS)\
   || defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)\
   || defined(BOOST_NO_CWCHAR)\
   || defined(BOOST_NO_CWCTYPE)\
   || defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)\
   || defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS)\
   || defined(BOOST_NO_EXCEPTIONS)\
   || defined(BOOST_NO_EXCEPTION_STD_NAMESPACE)\
   || defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)\
   || defined(BOOST_NO_FENV_H)\
   || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)\
   || defined(BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS)\
   || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\
   || defined(BOOST_NO_INTEGRAL_INT64_T)\
   || defined(BOOST_NO_INTRINSIC_WCHAR_T)\
   || defined(BOOST_NO_IOSFWD)\
   || defined(BOOST_NO_IOSTREAM)\
   || defined(BOOST_NO_IS_ABSTRACT)\
   || defined(BOOST_NO_LIMITS)\
   || defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)\
   || defined(BOOST_NO_LONG_LONG)\
   || defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)\
   || defined(BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS)\
   || defined(BOOST_NO_MEMBER_TEMPLATES)\
   || defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)\
   || defined(BOOST_NO_MEMBER_TEMPLATE_KEYWORD)\
   || defined(BOOST_NO_NESTED_FRIENDSHIP)\
   || defined(BOOST_NO_OPERATORS_IN_NAMESPACE)\
   || defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)\
   || defined(BOOST_NO_POINTER_TO_MEMBER_CONST)\
   || defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)\
   || defined(BOOST_NO_PRIVATE_IN_AGGREGATE)\
   || defined(BOOST_NO_RESTRICT_REFERENCES)\
   || defined(BOOST_NO_RTTI)\
   || defined(BOOST_NO_SFINAE)\
   || defined(BOOST_NO_SFINAE_EXPR)\
   || defined(BOOST_NO_STDC_NAMESPACE)\
   || defined(BOOST_NO_STD_ALLOCATOR)\
   || defined(BOOST_NO_STD_DISTANCE)\
   || defined(BOOST_NO_STD_ITERATOR)\
   || defined(BOOST_NO_STD_ITERATOR_TRAITS)\
   || defined(BOOST_NO_STD_LOCALE)\
   || defined(BOOST_NO_STD_MESSAGES)\
   || defined(BOOST_NO_STD_MIN_MAX)\
   || defined(BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN)\
   || defined(BOOST_NO_STD_TYPEINFO)\
   || defined(BOOST_NO_STD_USE_FACET)\
   || defined(BOOST_NO_STD_WSTREAMBUF)\
   || defined(BOOST_NO_STD_WSTRING)\
   || defined(BOOST_NO_STRINGSTREAM)\
   || defined(BOOST_NO_TEMPLATED_IOSTREAMS)\
   || defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
   || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)\
   || defined(BOOST_NO_TEMPLATE_TEMPLATES)\
   || defined(BOOST_NO_TWO_PHASE_NAME_LOOKUP)\
   || defined(BOOST_NO_TYPEID)\
   || defined(BOOST_NO_TYPENAME_WITH_CTOR)\
   || defined(BOOST_NO_UNREACHABLE_RETURN_DETECTION)\
   || defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)\
   || defined(BOOST_NO_USING_TEMPLATE)\
   || defined(BOOST_NO_VOID_RETURNS)
#    define BOOST_NO_CXX03
#endif

#if defined(BOOST_NO_CXX03)\
   || defined(BOOST_NO_CXX11_ADDRESSOF)\
   || defined(BOOST_NO_CXX11_ALIGNAS)\
   || defined(BOOST_NO_CXX11_ALLOCATOR)\
   || defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)\
   || defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS)\
   || defined(BOOST_NO_CXX11_CHAR16_T)\
   || defined(BOOST_NO_CXX11_CHAR32_T)\
   || defined(BOOST_NO_CXX11_CONSTEXPR)\
   || defined(BOOST_NO_CXX11_DECLTYPE)\
   || defined(BOOST_NO_CXX11_DECLTYPE_N3276)\
   || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)\
   || defined(BOOST_NO_CXX11_DEFAULTED_MOVES)\
   || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)\
   || defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)\
   || defined(BOOST_NO_CXX11_EXTERN_TEMPLATE)\
   || defined(BOOST_NO_CXX11_FINAL)\
   || defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS)\
   || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)\
   || defined(BOOST_NO_CXX11_HDR_ARRAY)\
   || defined(BOOST_NO_CXX11_HDR_ATOMIC)\
   || defined(BOOST_NO_CXX11_HDR_CHRONO)\
   || defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE)\
   || defined(BOOST_NO_CXX11_HDR_EXCEPTION)\
   || defined(BOOST_NO_CXX11_HDR_FORWARD_LIST)\
   || defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)\
   || defined(BOOST_NO_CXX11_HDR_FUTURE)\
   || defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)\
   || defined(BOOST_NO_CXX11_HDR_MUTEX)\
   || defined(BOOST_NO_CXX11_HDR_RANDOM)\
   || defined(BOOST_NO_CXX11_HDR_RATIO)\
   || defined(BOOST_NO_CXX11_HDR_REGEX)\
   || defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)\
   || defined(BOOST_NO_CXX11_HDR_THREAD)\
   || defined(BOOST_NO_CXX11_HDR_TUPLE)\
   || defined(BOOST_NO_CXX11_HDR_TYPEINDEX)\
   || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)\
   || defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP)\
   || defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)\
   || defined(BOOST_NO_CXX11_INLINE_NAMESPACES)\
   || defined(BOOST_NO_CXX11_LAMBDAS)\
   || defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS)\
   || defined(BOOST_NO_CXX11_NOEXCEPT)\
   || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)\
   || defined(BOOST_NO_CXX11_NULLPTR)\
   || defined(BOOST_NO_CXX11_NUMERIC_LIMITS)\
   || defined(BOOST_NO_CXX11_OVERRIDE)\
   || defined(BOOST_NO_CXX11_POINTER_TRAITS)\
   || defined(BOOST_NO_CXX11_RANGE_BASED_FOR)\
   || defined(BOOST_NO_CXX11_RAW_LITERALS)\
   || defined(BOOST_NO_CXX11_REF_QUALIFIERS)\
   || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)\
   || defined(BOOST_NO_CXX11_SCOPED_ENUMS)\
   || defined(BOOST_NO_CXX11_SFINAE_EXPR)\
   || defined(BOOST_NO_CXX11_SMART_PTR)\
   || defined(BOOST_NO_CXX11_STATIC_ASSERT)\
   || defined(BOOST_NO_CXX11_STD_ALIGN)\
   || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)\
   || defined(BOOST_NO_CXX11_THREAD_LOCAL)\
   || defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)\
   || defined(BOOST_NO_CXX11_UNICODE_LITERALS)\
   || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)\
   || defined(BOOST_NO_CXX11_UNRESTRICTED_UNION)\
   || defined(BOOST_NO_CXX11_USER_DEFINED_LITERALS)\
   || defined(BOOST_NO_CXX11_VARIADIC_MACROS)\
   || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#    define BOOST_NO_CXX11
#endif

#if defined(BOOST_NO_CXX11)\
   || defined(BOOST_NO_CXX14_AGGREGATE_NSDMI)\
   || defined(BOOST_NO_CXX14_BINARY_LITERALS)\
   || defined(BOOST_NO_CXX14_CONSTEXPR)\
   || defined(BOOST_NO_CXX14_DECLTYPE_AUTO)\
   || defined(BOOST_NO_CXX14_DIGIT_SEPARATORS)\
   || defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)\
   || defined(BOOST_NO_CXX14_HDR_SHARED_MUTEX)\
   || defined(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES)\
   || defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)\
   || defined(BOOST_NO_CXX14_STD_EXCHANGE)\
   || defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
#    define BOOST_NO_CXX14
#endif

#if defined(BOOST_NO_CXX14)\
   || defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)\
   || defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS)\
   || defined(BOOST_NO_CXX17_HDR_ANY)\
   || defined(BOOST_NO_CXX17_HDR_CHARCONV)\
   || defined(BOOST_NO_CXX17_HDR_EXECUTION)\
   || defined(BOOST_NO_CXX17_HDR_FILESYSTEM)\
   || defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)\
   || defined(BOOST_NO_CXX17_HDR_OPTIONAL)\
   || defined(BOOST_NO_CXX17_HDR_STRING_VIEW)\
   || defined(BOOST_NO_CXX17_HDR_VARIANT)\
   || defined(BOOST_NO_CXX17_IF_CONSTEXPR)\
   || defined(BOOST_NO_CXX17_INLINE_VARIABLES)\
   || defined(BOOST_NO_CXX17_ITERATOR_TRAITS)\
   || defined(BOOST_NO_CXX17_STD_APPLY)\
   || defined(BOOST_NO_CXX17_STD_INVOKE)\
   || defined(BOOST_NO_CXX17_STRUCTURED_BINDINGS)
#    define BOOST_NO_CXX17
#endif

#if defined(BOOST_NO_CXX17)\
   || defined(BOOST_NO_CXX20_HDR_BARRIER)\
   || defined(BOOST_NO_CXX20_HDR_BIT)\
   || defined(BOOST_NO_CXX20_HDR_COMPARE)\
   || defined(BOOST_NO_CXX20_HDR_CONCEPTS)\
   || defined(BOOST_NO_CXX20_HDR_COROUTINE)\
   || defined(BOOST_NO_CXX20_HDR_FORMAT)\
   || defined(BOOST_NO_CXX20_HDR_LATCH)\
   || defined(BOOST_NO_CXX20_HDR_NUMBERS)\
   || defined(BOOST_NO_CXX20_HDR_RANGES)\
   || defined(BOOST_NO_CXX20_HDR_SEMAPHORE)\
   || defined(BOOST_NO_CXX20_HDR_SOURCE_LOCATION)\
   || defined(BOOST_NO_CXX20_HDR_SPAN)\
   || defined(BOOST_NO_CXX20_HDR_STOP_TOKEN)\
   || defined(BOOST_NO_CXX20_HDR_SYNCSTREAM)\
   || defined(BOOST_NO_CXX20_HDR_VERSION)
#    define BOOST_NO_CXX20
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/posix_features.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


//  See http://www.boost.org for most recent version.

// All POSIX feature tests go in this file,
// Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well
// _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's
// may be present but none-functional unless _POSIX_C_SOURCE and
// _XOPEN_SOURCE have been defined to the right value (it's up
// to the user to do this *before* including any header, although
// in most cases the compiler will do this for you).

#  if defined(BOOST_HAS_UNISTD_H)
#     include <unistd.h>

      // XOpen has <nl_types.h>, but is this the correct version check?
#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3)
#        define BOOST_HAS_NL_TYPES_H
#     endif

      // POSIX version 6 requires <stdint.h>
#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100)
#        define BOOST_HAS_STDINT_H
#     endif

      // POSIX version 2 requires <dirent.h>
#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L)
#        define BOOST_HAS_DIRENT_H
#     endif

      // POSIX version 3 requires <signal.h> to have sigaction:
#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L)
#        define BOOST_HAS_SIGACTION
#     endif
      // POSIX defines _POSIX_THREADS > 0 for pthread support,
      // however some platforms define _POSIX_THREADS without
      // a value, hence the (_POSIX_THREADS+0 >= 0) check.
      // Strictly speaking this may catch platforms with a
      // non-functioning stub <pthreads.h>, but such occurrences should
      // occur very rarely if at all.
#     if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS)
#        define BOOST_HAS_PTHREADS
#     endif

      // BOOST_HAS_NANOSLEEP:
      // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME:
#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \
             || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
#        define BOOST_HAS_NANOSLEEP
#     endif

      // BOOST_HAS_CLOCK_GETTIME:
      // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME
      // but at least one platform - linux - defines that flag without
      // defining clock_gettime):
#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0))
#        define BOOST_HAS_CLOCK_GETTIME
#     endif

      // BOOST_HAS_SCHED_YIELD:
      // This is predicated on _POSIX_PRIORITY_SCHEDULING or
      // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME.
#     if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\
            || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\
            || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
#        define BOOST_HAS_SCHED_YIELD
#     endif

      // BOOST_HAS_GETTIMEOFDAY:
      // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE:
      // These are predicated on _XOPEN_VERSION, and appears to be first released
      // in issue 4, version 2 (_XOPEN_VERSION > 500).
      // Likewise for the functions log1p and expm1.
#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500)
#        define BOOST_HAS_GETTIMEOFDAY
#        if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500)
#           define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#        endif
#        ifndef BOOST_HAS_LOG1P
#           define BOOST_HAS_LOG1P
#        endif
#        ifndef BOOST_HAS_EXPM1
#           define BOOST_HAS_EXPM1
#        endif
#     endif

#  endif






================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/select_compiler_config.hpp
================================================
//  Boost compiler configuration selection header file

//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Martin Wille 2003.
//  (C) Copyright Guillaume Melquiond 2003.
//
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at
//   http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/ for most recent version.

// locate which compiler we are using and define
// BOOST_COMPILER_CONFIG as needed: 

#if defined __CUDACC__
//  NVIDIA CUDA C++ compiler for GPU
#   include "boost/config/compiler/nvcc.hpp"

#endif

#if defined(__GCCXML__)
// GCC-XML emulates other compilers, it has to appear first here!
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp"

#elif defined(_CRAYC)
// EDG based Cray compiler:
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/cray.hpp"

#elif defined __COMO__
//  Comeau C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp"

#elif defined(__PATHSCALE__) && (__PATHCC__ >= 4)
// PathScale EKOPath compiler (has to come before clang and gcc)
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pathscale.hpp"

#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
//  Intel
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"

#elif defined __clang__ && !defined(__ibmxl__) && !defined(__CODEGEARC__)
//  Clang C++ emulates GCC, so it has to appear early.
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"

#elif defined __DMC__
//  Digital Mars C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"

#elif defined __DCC__
//  Wind River Diab C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/diab.hpp"

#elif defined(__PGI)
//  Portland Group Inc.
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp"

# elif defined(__GNUC__) && !defined(__ibmxl__)
//  GNU C++:
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"

#elif defined __KCC
//  Kai C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp"

#elif defined __sgi
//  SGI MIPSpro C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp"

#elif defined __DECCXX
//  Compaq Tru64 Unix cxx
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp"

#elif defined __ghs
//  Greenhills C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"

#elif defined __CODEGEARC__
//  CodeGear - must be checked for before Borland
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp"

#elif defined __BORLANDC__
//  Borland
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"

#elif defined  __MWERKS__
//  Metrowerks CodeWarrior
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp"

#elif defined  __SUNPRO_CC
//  Sun Workshop Compiler C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp"

#elif defined __HP_aCC
//  HP aCC
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp"

#elif defined(__MRC__) || defined(__SC__)
//  MPW MrCpp or SCpp
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"

#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
//  IBM z/OS XL C/C++
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp_zos.hpp"

#elif defined(__ibmxl__)
//  IBM XL C/C++ for Linux (Little Endian)
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp.hpp"

#elif defined(__IBMCPP__)
//  IBM Visual Age or IBM XL C/C++ for Linux (Big Endian)
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp"

#elif defined _MSC_VER
//  Microsoft Visual C++
//
//  Must remain the last #elif since some other vendors (Metrowerks, for
//  example) also #define _MSC_VER
#   define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp"

#elif defined (BOOST_ASSERT_CONFIG)
// this must come last - generate an error if we don't
// recognise the compiler:
#  error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"

#endif

#if 0
//
// This section allows dependency scanners to find all the headers we *might* include:
//
#include <boost/config/compiler/gcc_xml.hpp>
#include <boost/config/compiler/cray.hpp>
#include <boost/config/compiler/comeau.hpp>
#include <boost/config/compiler/pathscale.hpp>
#include <boost/config/compiler/intel.hpp>
#include <boost/config/compiler/clang.hpp>
#include <boost/config/compiler/digitalmars.hpp>
#include <boost/config/compiler/gcc.hpp>
#include <boost/config/compiler/kai.hpp>
#include <boost/config/compiler/sgi_mipspro.hpp>
#include <boost/config/compiler/compaq_cxx.hpp>
#include <boost/config/compiler/greenhills.hpp>
#include <boost/config/compiler/codegear.hpp>
#include <boost/config/compiler/borland.hpp>
#include <boost/config/compiler/metrowerks.hpp>
#include <boost/config/compiler/sunpro_cc.hpp>
#include <boost/config/compiler/hp_acc.hpp>
#include <boost/config/compiler/mpw.hpp>
#include <boost/config/compiler/xlcpp_zos.hpp>
#include <boost/config/compiler/xlcpp.hpp>
#include <boost/config/compiler/vacpp.hpp>
#include <boost/config/compiler/pgi.hpp>
#include <boost/config/compiler/visualc.hpp>

#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/select_platform_config.hpp
================================================
//  Boost compiler configuration selection header file

//  (C) Copyright John Maddock 2001 - 2002. 
//  (C) Copyright Jens Maurer 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
// Note that we define the headers to include using "header_name" not
// <header_name> in order to prevent macro expansion within the header
// name (for example "linux" is a macro on linux systems).

#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"

#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
// BSD:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"

#elif defined(sun) || defined(__sun)
// solaris:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"

#elif defined(__sgi)
// SGI Irix:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"

#elif defined(__hpux)
// hp unix:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"

#elif defined(__CYGWIN__)
// cygwin is not win32:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"

#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
// win32:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"

#elif defined(__HAIKU__)
// Haiku
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/haiku.hpp"

#elif defined(__BEOS__)
// BeOS
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"

#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
// MacOS
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"

#elif defined(__TOS_MVS__)
// IBM z/OS
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/zos.hpp"

#elif defined(__IBMCPP__) || defined(_AIX)
// IBM AIX
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"

#elif defined(__amigaos__)
// AmigaOS
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"

#elif defined(__QNXNTO__)
// QNX:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"

#elif defined(__VXWORKS__)
// vxWorks:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp"

#elif defined(__SYMBIAN32__) 
// Symbian: 
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 

#elif defined(_CRAYC)
// Cray:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" 

#elif defined(__VMS) 
// VMS:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 

#elif defined(__CloudABI__)
// Nuxi CloudABI:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cloudabi.hpp"

#elif defined (__wasm__)
// Web assembly:
#  define BOOST_PLATFORM_CONFIG "boost/config/platform/wasm.hpp"

#else

#  if defined(unix) \
      || defined(__unix) \
      || defined(_XOPEN_SOURCE) \
      || defined(_POSIX_SOURCE)

   // generic unix platform:

#  ifndef BOOST_HAS_UNISTD_H
#     define BOOST_HAS_UNISTD_H
#  endif

#  include <boost/config/detail/posix_features.hpp>

#  endif

#  if defined (BOOST_ASSERT_CONFIG)
      // this must come last - generate an error if we don't
      // recognise the platform:
#     error "Unknown platform - please configure and report the results to boost.org"
#  endif

#endif

#if 0
//
// This section allows dependency scanners to find all the files we *might* include:
//
#  include "boost/config/platform/linux.hpp"
#  include "boost/config/platform/bsd.hpp"
#  include "boost/config/platform/solaris.hpp"
#  include "boost/config/platform/irix.hpp"
#  include "boost/config/platform/hpux.hpp"
#  include "boost/config/platform/cygwin.hpp"
#  include "boost/config/platform/win32.hpp"
#  include "boost/config/platform/beos.hpp"
#  include "boost/config/platform/macos.hpp"
#  include "boost/config/platform/zos.hpp"
#  include "boost/config/platform/aix.hpp"
#  include "boost/config/platform/amigaos.hpp"
#  include "boost/config/platform/qnxnto.hpp"
#  include "boost/config/platform/vxworks.hpp"
#  include "boost/config/platform/symbian.hpp" 
#  include "boost/config/platform/cray.hpp" 
#  include "boost/config/platform/vms.hpp" 
#  include <boost/config/detail/posix_features.hpp>



#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/select_stdlib_config.hpp
================================================
//  Boost compiler configuration selection header file

//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2001 - 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


//  See http://www.boost.org for most recent version.

// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:

// First, check if __has_include is available and <version> include can be located,
// otherwise include <cstddef> to determine if some version of STLport is in use as the std lib
// (do not rely on this header being included since users can short-circuit this header 
//  if they know whose std lib they are using.)
#if defined(__cplusplus) && defined(__has_include)
#  if __has_include(<version>)
// It should be safe to include `<version>` when it is present without checking
// the actual C++ language version as it consists solely of macro definitions.
// [version.syn] p1: The header <version> supplies implementation-dependent
// information about the C++ standard library (e.g., version number and release date).
#    include <version>
#  else
#    include <cstddef>
#  endif
#elif defined(__cplusplus)
#  include <cstddef>
#else
#  include <stddef.h>
#endif

#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
// STLPort library; this _must_ come first, otherwise since
// STLport typically sits on top of some other library, we
// can end up detecting that first rather than STLport:
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp"

#else

// If our std lib was not some version of STLport, and has not otherwise
// been detected, then include <utility> as it is about 
// the smallest of the std lib headers that includes real C++ stuff.
// Some std libs do not include their C++-related macros in <cstddef> 
// so this additional include makes sure we get those definitions.
// Note: do not rely on this header being included since users can short-circuit this 
// #include if they know whose std lib they are using.
#if !defined(__LIBCOMO__) && !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)\
   && !defined(_LIBCPP_VERSION) && !defined(__GLIBCPP__) && !defined(__GLIBCXX__)\
   && !defined(__STL_CONFIG_H) && !defined(__MSL_CPP__) && !defined(__IBMCPP__)\
   && !defined(MSIPL_COMPILE_H) && !defined(_YVALS) && !defined(_CPPLIB_VER)
#include <utility>
#endif

#if defined(__LIBCOMO__)
// Comeau STL:
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp"

#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
// Rogue Wave library:
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp"

#elif defined(_LIBCPP_VERSION)
// libc++
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcpp.hpp"

#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
// GNU libstdc++ 3
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"

#elif defined(__STL_CONFIG_H)
// generic SGI STL
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp"

#elif defined(__MSL_CPP__)
// MSL standard lib:
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"

#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
// IBM z/OS XL C/C++
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/xlcpp_zos.hpp"

#elif defined(__IBMCPP__)
// take the default VACPP std lib
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"

#elif defined(MSIPL_COMPILE_H)
// Modena C++ standard library
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp"

#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
// Dinkumware Library (this has to appear after any possible replacement libraries):
#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp"

#elif defined (BOOST_ASSERT_CONFIG)
// this must come last - generate an error if we don't
// recognise the library:
#  error "Unknown standard library - please configure and report the results to boost.org"

#endif

#endif

#if 0
//
// This section allows dependency scanners to find all the files we *might* include:
//
#  include "boost/config/stdlib/stlport.hpp"
#  include "boost/config/stdlib/libcomo.hpp"
#  include "boost/config/stdlib/roguewave.hpp"
#  include "boost/config/stdlib/libcpp.hpp"
#  include "boost/config/stdlib/libstdcpp3.hpp"
#  include "boost/config/stdlib/sgi.hpp"
#  include "boost/config/stdlib/msl.hpp"
#  include "boost/config/stdlib/xlcpp_zos.hpp"
#  include "boost/config/stdlib/vacpp.hpp"
#  include "boost/config/stdlib/modena.hpp"
#  include "boost/config/stdlib/dinkumware.hpp"
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/detail/suffix.hpp
================================================
//  Boost config.hpp configuration header file  ------------------------------//
//  boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file

//  Copyright (c) 2001-2003 John Maddock
//  Copyright (c) 2001 Darin Adler
//  Copyright (c) 2001 Peter Dimov
//  Copyright (c) 2002 Bill Kempf
//  Copyright (c) 2002 Jens Maurer
//  Copyright (c) 2002-2003 David Abrahams
//  Copyright (c) 2003 Gennaro Prota
//  Copyright (c) 2003 Eric Friedman
//  Copyright (c) 2010 Eric Jourdanneau, Joel Falcou
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/ for most recent version.

//  Boost config.hpp policy and rationale documentation has been moved to
//  http://www.boost.org/libs/config/
//
//  This file is intended to be stable, and relatively unchanging.
//  It should contain boilerplate code only - no compiler specific
//  code unless it is unavoidable - no changes unless unavoidable.

#ifndef BOOST_CONFIG_SUFFIX_HPP
#define BOOST_CONFIG_SUFFIX_HPP

#if defined(__GNUC__) && (__GNUC__ >= 4)
//
// Some GCC-4.x versions issue warnings even when __extension__ is used,
// so use this as a workaround:
//
#pragma GCC system_header
#endif

//
// ensure that visibility macros are always defined, thus simplifying use
//
#ifndef BOOST_SYMBOL_EXPORT
# define BOOST_SYMBOL_EXPORT
#endif
#ifndef BOOST_SYMBOL_IMPORT
# define BOOST_SYMBOL_IMPORT
#endif
#ifndef BOOST_SYMBOL_VISIBLE
# define BOOST_SYMBOL_VISIBLE
#endif

//
// disable explicitly enforced visibility
//
#if defined(BOOST_DISABLE_EXPLICIT_SYMBOL_VISIBILITY)

#undef BOOST_SYMBOL_EXPORT
#define BOOST_SYMBOL_EXPORT

#undef BOOST_SYMBOL_IMPORT
#define BOOST_SYMBOL_IMPORT

#undef BOOST_SYMBOL_VISIBLE
#define BOOST_SYMBOL_VISIBLE

#endif

//
// look for long long by looking for the appropriate macros in <limits.h>.
// Note that we use limits.h rather than climits for maximal portability,
// remember that since these just declare a bunch of macros, there should be
// no namespace issues from this.
//
#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG)                                              \
   && !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC)
# include <limits.h>
# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
#   define BOOST_HAS_LONG_LONG
# else
#   define BOOST_NO_LONG_LONG
# endif
#endif

// GCC 3.x will clean up all of those nasty macro definitions that
// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
// it under GCC 3.x.
#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
#  undef BOOST_NO_CTYPE_FUNCTIONS
#endif

//
// Assume any extensions are in namespace std:: unless stated otherwise:
//
#  ifndef BOOST_STD_EXTENSION_NAMESPACE
#    define BOOST_STD_EXTENSION_NAMESPACE std
#  endif

//
// If cv-qualified specializations are not allowed, then neither are cv-void ones:
//
#  if defined(BOOST_NO_CV_SPECIALIZATIONS) \
      && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
#     define BOOST_NO_CV_VOID_SPECIALIZATIONS
#  endif

//
// If there is no numeric_limits template, then it can't have any compile time
// constants either!
//
#  if defined(BOOST_NO_LIMITS) \
      && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
#     define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#     define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
#  endif

//
// if there is no long long then there is no specialisation
// for numeric_limits<long long> either:
//
#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
#  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
#endif

//
// if there is no __int64 then there is no specialisation
// for numeric_limits<__int64> either:
//
#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#endif

//
// if member templates are supported then so is the
// VC6 subset of member templates:
//
#  if !defined(BOOST_NO_MEMBER_TEMPLATES) \
       && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
#     define BOOST_MSVC6_MEMBER_TEMPLATES
#  endif

//
// Without partial specialization, can't test for partial specialisation bugs:
//
#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
#     define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#  endif

//
// Without partial specialization, we can't have array-type partial specialisations:
//
#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
#     define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
#  endif

//
// Without partial specialization, std::iterator_traits can't work:
//
#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
#     define BOOST_NO_STD_ITERATOR_TRAITS
#  endif

//
// Without partial specialization, partial
// specialization with default args won't work either:
//
#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
      && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#     define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
#  endif

//
// Without member template support, we can't have template constructors
// in the standard library either:
//
#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
      && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
#     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#  endif

//
// Without member template support, we can't have a conforming
// std::allocator template either:
//
#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
      && !defined(BOOST_NO_STD_ALLOCATOR)
#     define BOOST_NO_STD_ALLOCATOR
#  endif

//
// without ADL support then using declarations will break ADL as well:
//
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#endif

//
// Without typeid support we have no dynamic RTTI either:
//
#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
#  define BOOST_NO_RTTI
#endif

//
// If we have a standard allocator, then we have a partial one as well:
//
#if !defined(BOOST_NO_STD_ALLOCATOR)
#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#endif

//
// We can't have a working std::use_facet if there is no std::locale:
//
#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
#     define BOOST_NO_STD_USE_FACET
#  endif

//
// We can't have a std::messages facet if there is no std::locale:
//
#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
#     define BOOST_NO_STD_MESSAGES
#  endif

//
// We can't have a working std::wstreambuf if there is no std::locale:
//
#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
#     define BOOST_NO_STD_WSTREAMBUF
#  endif

//
// We can't have a <cwctype> if there is no <cwchar>:
//
#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
#     define BOOST_NO_CWCTYPE
#  endif

//
// We can't have a swprintf if there is no <cwchar>:
//
#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
#     define BOOST_NO_SWPRINTF
#  endif

//
// If Win32 support is turned off, then we must turn off
// threading support also, unless there is some other
// thread API enabled:
//
#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
   && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
#  define BOOST_DISABLE_THREADS
#endif

//
// Turn on threading support if the compiler thinks that it's in
// multithreaded mode.  We put this here because there are only a
// limited number of macros that identify this (if there's any missing
// from here then add to the appropriate compiler section):
//
#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
    || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
    && !defined(BOOST_HAS_THREADS)
#  define BOOST_HAS_THREADS
#endif

//
// Turn threading support off if BOOST_DISABLE_THREADS is defined:
//
#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
#  undef BOOST_HAS_THREADS
#endif

//
// Turn threading support off if we don't recognise the threading API:
//
#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
      && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
      && !defined(BOOST_HAS_MPTASKS)
#  undef BOOST_HAS_THREADS
#endif

//
// Turn threading detail macros off if we don't (want to) use threading
//
#ifndef BOOST_HAS_THREADS
#  undef BOOST_HAS_PTHREADS
#  undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#  undef BOOST_HAS_PTHREAD_YIELD
#  undef BOOST_HAS_PTHREAD_DELAY_NP
#  undef BOOST_HAS_WINTHREADS
#  undef BOOST_HAS_BETHREADS
#  undef BOOST_HAS_MPTASKS
#endif

//
// If the compiler claims to be C99 conformant, then it had better
// have a <stdint.h>:
//
#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
#     define BOOST_HAS_STDINT_H
#     ifndef BOOST_HAS_LOG1P
#        define BOOST_HAS_LOG1P
#     endif
#     ifndef BOOST_HAS_EXPM1
#        define BOOST_HAS_EXPM1
#     endif
#  endif

//
// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
// Note that this is for backwards compatibility only.
//
#  if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
#     define BOOST_NO_SLIST
#  endif

#  if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
#     define BOOST_NO_HASH
#  endif

//
// Set BOOST_SLIST_HEADER if not set already:
//
#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
#  define BOOST_SLIST_HEADER <slist>
#endif

//
// Set BOOST_HASH_SET_HEADER if not set already:
//
#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
#  define BOOST_HASH_SET_HEADER <hash_set>
#endif

//
// Set BOOST_HASH_MAP_HEADER if not set already:
//
#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
#  define BOOST_HASH_MAP_HEADER <hash_map>
#endif

//  BOOST_HAS_ABI_HEADERS
//  This macro gets set if we have headers that fix the ABI,
//  and prevent ODR violations when linking to external libraries:
#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
#  define BOOST_HAS_ABI_HEADERS
#endif

#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
#  undef BOOST_HAS_ABI_HEADERS
#endif

//  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
//  Because std::size_t usage is so common, even in boost headers which do not
//  otherwise use the C library, the <cstddef> workaround is included here so
//  that ugly workaround code need not appear in many other boost headers.
//  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
//  must still be #included in the usual places so that <cstddef> inclusion
//  works as expected with standard conforming compilers.  The resulting
//  double inclusion of <cstddef> is harmless.

# if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus)
#   include <cstddef>
    namespace std { using ::ptrdiff_t; using ::size_t; }
# endif

//  Workaround for the unfortunate min/max macros defined by some platform headers

#define BOOST_PREVENT_MACRO_SUBSTITUTION

#ifndef BOOST_USING_STD_MIN
#  define BOOST_USING_STD_MIN() using std::min
#endif

#ifndef BOOST_USING_STD_MAX
#  define BOOST_USING_STD_MAX() using std::max
#endif

//  BOOST_NO_STD_MIN_MAX workaround  -----------------------------------------//

#  if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus)

namespace std {
  template <class _Tp>
  inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
    return __b < __a ? __b : __a;
  }
  template <class _Tp>
  inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
    return  __a < __b ? __b : __a;
  }
}

#  endif

// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
// On compilers which don't allow in-class initialization of static integral
// constant members, we must use enums as a workaround if we want the constants
// to be available at compile-time. This macro gives us a convenient way to
// declare such constants.

#  ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#       define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
#  else
#     define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
#  endif

// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
// When the standard library does not have a conforming std::use_facet there
// are various workarounds available, but they differ from library to library.
// The same problem occurs with has_facet.
// These macros provide a consistent way to access a locale's facets.
// Usage:
//    replace
//       std::use_facet<Type>(loc);
//    with
//       BOOST_USE_FACET(Type, loc);
//    Note do not add a std:: prefix to the front of BOOST_USE_FACET!
//  Use for BOOST_HAS_FACET is analogous.

#if defined(BOOST_NO_STD_USE_FACET)
#  ifdef BOOST_HAS_TWO_ARG_USE_FACET
#     define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
#     define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
#  elif defined(BOOST_HAS_MACRO_USE_FACET)
#     define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
#     define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
#  elif defined(BOOST_HAS_STLP_USE_FACET)
#     define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
#     define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
#  endif
#else
#  define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
#  define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
#endif

// BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
// Member templates are supported by some compilers even though they can't use
// the A::template member<U> syntax, as a workaround replace:
//
// typedef typename A::template rebind<U> binder;
//
// with:
//
// typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;

#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#  define BOOST_NESTED_TEMPLATE template
#else
#  define BOOST_NESTED_TEMPLATE
#endif

// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
// is defined, in which case it evaluates to return x; Use when you have a return
// statement that can never be reached.

#ifndef BOOST_UNREACHABLE_RETURN
#  ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
#     define BOOST_UNREACHABLE_RETURN(x) return x;
#  else
#     define BOOST_UNREACHABLE_RETURN(x)
#  endif
#endif

// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
//
// Some compilers don't support the use of `typename' for dependent
// types in deduced contexts, e.g.
//
//     template <class T> void f(T, typename T::type);
//                                  ^^^^^^^^
// Replace these declarations with:
//
//     template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);

#ifndef BOOST_NO_DEDUCED_TYPENAME
#  define BOOST_DEDUCED_TYPENAME typename
#else
#  define BOOST_DEDUCED_TYPENAME
#endif

#ifndef BOOST_NO_TYPENAME_WITH_CTOR
#  define BOOST_CTOR_TYPENAME typename
#else
#  define BOOST_CTOR_TYPENAME
#endif

//
// If we're on a CUDA device (note DEVICE not HOST, irrespective of compiler) then disable __int128 and __float128 support if present:
//
#if defined(__CUDA_ARCH__) && defined(BOOST_HAS_FLOAT128)
#  undef BOOST_HAS_FLOAT128
#endif
#if defined(__CUDA_ARCH__) && defined(BOOST_HAS_INT128)
#  undef BOOST_HAS_INT128
#endif

// long long workaround ------------------------------------------//
// On gcc (and maybe other compilers?) long long is alway supported
// but it's use may generate either warnings (with -ansi), or errors
// (with -pedantic -ansi) unless it's use is prefixed by __extension__
//
#if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus)
namespace boost{
#  ifdef __GNUC__
   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;
#  else
   typedef long long long_long_type;
   typedef unsigned long long ulong_long_type;
#  endif
}
#endif
// same again for __int128:
#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
namespace boost{
#  ifdef __GNUC__
   __extension__ typedef __int128 int128_type;
   __extension__ typedef unsigned __int128 uint128_type;
#  else
   typedef __int128 int128_type;
   typedef unsigned __int128 uint128_type;
#  endif
}
#endif
// same again for __float128:
#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
namespace boost {
#  ifdef __GNUC__
   __extension__ typedef __float128 float128_type;
#  else
   typedef __float128 float128_type;
#  endif
}
#endif

// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//

// These macros are obsolete. Port away and remove.

#  define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
#  define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)

#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)

// When BOOST_NO_STD_TYPEINFO is defined, we can just import
// the global definition into std namespace, 
// see https://svn.boost.org/trac10/ticket/4115
#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus) && defined(BOOST_MSVC)
#include <typeinfo>
namespace std{ using ::type_info; }
// Since we do now have typeinfo, undef the macro:
#undef BOOST_NO_STD_TYPEINFO
#endif

// ---------------------------------------------------------------------------//

// Helper macro BOOST_STRINGIZE:
// Helper macro BOOST_JOIN:

#include <boost/config/helper_macros.hpp>

//
// Set some default values for compiler/library/platform names.
// These are for debugging config setup only:
//
#  ifndef BOOST_COMPILER
#     define BOOST_COMPILER "Unknown ISO C++ Compiler"
#  endif
#  ifndef BOOST_STDLIB
#     define BOOST_STDLIB "Unknown ISO standard library"
#  endif
#  ifndef BOOST_PLATFORM
#     if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
         || defined(_POSIX_SOURCE)
#        define BOOST_PLATFORM "Generic Unix"
#     else
#        define BOOST_PLATFORM "Unknown"
#     endif
#  endif

//
// Set some default values GPU support
//
#  ifndef BOOST_GPU_ENABLED
#  define BOOST_GPU_ENABLED
#  endif

// BOOST_RESTRICT ---------------------------------------------//
// Macro to use in place of 'restrict' keyword variants
#if !defined(BOOST_RESTRICT)
#  if defined(_MSC_VER)
#    define BOOST_RESTRICT __restrict
#    if !defined(BOOST_NO_RESTRICT_REFERENCES) && (_MSC_FULL_VER < 190023026)
#      define BOOST_NO_RESTRICT_REFERENCES
#    endif
#  elif defined(__GNUC__) && __GNUC__ > 3
     // Clang also defines __GNUC__ (as 4)
#    define BOOST_RESTRICT __restrict__
#  else
#    define BOOST_RESTRICT
#    if !defined(BOOST_NO_RESTRICT_REFERENCES)
#      define BOOST_NO_RESTRICT_REFERENCES
#    endif
#  endif
#endif

// BOOST_MAY_ALIAS -----------------------------------------------//
// The macro expands to an attribute to mark a type that is allowed to alias other types.
// The macro is defined in the compiler-specific headers.
#if !defined(BOOST_MAY_ALIAS)
#  define BOOST_NO_MAY_ALIAS
#  define BOOST_MAY_ALIAS
#endif

// BOOST_FORCEINLINE ---------------------------------------------//
// Macro to use in place of 'inline' to force a function to be inline
#if !defined(BOOST_FORCEINLINE)
#  if defined(_MSC_VER)
#    define BOOST_FORCEINLINE __forceinline
#  elif defined(__GNUC__) && __GNUC__ > 3
     // Clang also defines __GNUC__ (as 4)
#    define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
#  else
#    define BOOST_FORCEINLINE inline
#  endif
#endif

// BOOST_NOINLINE ---------------------------------------------//
// Macro to use in place of 'inline' to prevent a function to be inlined
#if !defined(BOOST_NOINLINE)
#  if defined(_MSC_VER)
#    define BOOST_NOINLINE __declspec(noinline)
#  elif defined(__GNUC__) && __GNUC__ > 3
     // Clang also defines __GNUC__ (as 4)
#    if defined(__CUDACC__)
       // nvcc doesn't always parse __noinline__,
       // see: https://svn.boost.org/trac/boost/ticket/9392
#      define BOOST_NOINLINE __attribute__ ((noinline))
#    elif defined(__HIP__)
       // See https://github.com/boostorg/config/issues/392
#      define BOOST_NOINLINE __attribute__ ((noinline))
#    else
#      define BOOST_NOINLINE __attribute__ ((__noinline__))
#    endif
#  else
#    define BOOST_NOINLINE
#  endif
#endif

// BOOST_NORETURN ---------------------------------------------//
// Macro to use before a function declaration/definition to designate
// the function as not returning normally (i.e. with a return statement
// or by leaving the function scope, if the function return type is void).
#if !defined(BOOST_NORETURN)
#  if defined(_MSC_VER)
#    define BOOST_NORETURN __declspec(noreturn)
#  elif defined(__GNUC__) || defined(__CODEGEARC__) && defined(__clang__)
#    define BOOST_NORETURN __attribute__ ((__noreturn__))
#  elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
#    if __has_attribute(noreturn)
#      define BOOST_NORETURN [[noreturn]]
#    endif
#  elif defined(__has_cpp_attribute) 
#    if __has_cpp_attribute(noreturn)
#      define BOOST_NORETURN [[noreturn]]
#    endif
#  endif
#endif

#if !defined(BOOST_NORETURN)
#  define BOOST_NO_NORETURN
#  define BOOST_NORETURN
#endif

// BOOST_DEPRECATED -------------------------------------------//
// The macro can be used to mark deprecated symbols, such as functions, objects and types.
// Any code that uses these symbols will produce warnings, possibly with a message specified
// as an argument. The warnings can be suppressed by defining BOOST_ALLOW_DEPRECATED_SYMBOLS
// or BOOST_ALLOW_DEPRECATED.
#if !defined(BOOST_DEPRECATED) && __cplusplus >= 201402
#define BOOST_DEPRECATED(msg) [[deprecated(msg)]]
#endif

#if defined(BOOST_ALLOW_DEPRECATED_SYMBOLS) || defined(BOOST_ALLOW_DEPRECATED)
#undef BOOST_DEPRECATED
#endif

#if !defined(BOOST_DEPRECATED)
#define BOOST_DEPRECATED(msg)
#endif

// Branch prediction hints
// These macros are intended to wrap conditional expressions that yield true or false
//
//  if (BOOST_LIKELY(var == 10))
//  {
//     // the most probable code here
//  }
//
#if !defined(BOOST_LIKELY)
#  define BOOST_LIKELY(x) x
#endif
#if !defined(BOOST_UNLIKELY)
#  define BOOST_UNLIKELY(x) x
#endif

#if !defined(BOOST_NO_CXX11_OVERRIDE)
#  define BOOST_OVERRIDE override
#else
#  define BOOST_OVERRIDE
#endif

// Type and data alignment specification
//
#if !defined(BOOST_ALIGNMENT)
#  if !defined(BOOST_NO_CXX11_ALIGNAS)
#    define BOOST_ALIGNMENT(x) alignas(x)
#  elif defined(_MSC_VER)
#    define BOOST_ALIGNMENT(x) __declspec(align(x))
#  elif defined(__GNUC__)
#    define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x)))
#  else
#    define BOOST_NO_ALIGNMENT
#    define BOOST_ALIGNMENT(x)
#  endif
#endif

// Lack of non-public defaulted functions is implied by the lack of any defaulted functions
#if !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) && defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#endif

// Lack of defaulted moves is implied by the lack of either rvalue references or any defaulted functions
#if !defined(BOOST_NO_CXX11_DEFAULTED_MOVES) && (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
#  define BOOST_NO_CXX11_DEFAULTED_MOVES
#endif

// Defaulted and deleted function declaration helpers
// These macros are intended to be inside a class definition.
// BOOST_DEFAULTED_FUNCTION accepts the function declaration and its
// body, which will be used if the compiler doesn't support defaulted functions.
// BOOST_DELETED_FUNCTION only accepts the function declaration. It
// will expand to a private function declaration, if the compiler doesn't support
// deleted functions. Because of this it is recommended to use BOOST_DELETED_FUNCTION
// in the end of the class definition.
//
//  class my_class
//  {
//  public:
//      // Default-constructible
//      BOOST_DEFAULTED_FUNCTION(my_class(), {})
//      // Copying prohibited
//      BOOST_DELETED_FUNCTION(my_class(my_class const&))
//      BOOST_DELETED_FUNCTION(my_class& operator= (my_class const&))
//  };
//
#if !(defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS))
#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun = default;
#else
#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun body
#endif

#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
#   define BOOST_DELETED_FUNCTION(fun) fun = delete;
#else
#   define BOOST_DELETED_FUNCTION(fun) private: fun;
#endif

//
// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined
//
#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE
#endif

//  -------------------- Deprecated macros for 1.50 ---------------------------
//  These will go away in a future release

//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP
//           instead of BOOST_NO_STD_UNORDERED
#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET)
# ifndef BOOST_NO_CXX11_STD_UNORDERED
#  define BOOST_NO_CXX11_STD_UNORDERED
# endif
#endif

//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS
#if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS)
#  define BOOST_NO_INITIALIZER_LISTS
#endif

//  Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY
#if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_0X_HDR_ARRAY)
#  define BOOST_NO_0X_HDR_ARRAY
#endif
//  Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO
#if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO)
#  define BOOST_NO_0X_HDR_CHRONO
#endif
//  Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT
#if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT)
#  define BOOST_NO_0X_HDR_CODECVT
#endif
//  Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE
#if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE)
#  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
#endif
//  Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST
#if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST)
#  define BOOST_NO_0X_HDR_FORWARD_LIST
#endif
//  Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE
#if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE)
#  define BOOST_NO_0X_HDR_FUTURE
#endif

//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST
//  instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS
#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
# ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST
#  define BOOST_NO_0X_HDR_INITIALIZER_LIST
# endif
# ifndef BOOST_NO_INITIALIZER_LISTS
#  define BOOST_NO_INITIALIZER_LISTS
# endif
#endif

//  Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX
#if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX)
#  define BOOST_NO_0X_HDR_MUTEX
#endif
//  Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM
#if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM)
#  define BOOST_NO_0X_HDR_RANDOM
#endif
//  Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO
#if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO)
#  define BOOST_NO_0X_HDR_RATIO
#endif
//  Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX
#if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX)
#  define BOOST_NO_0X_HDR_REGEX
#endif
//  Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR
#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR)
#  define BOOST_NO_0X_HDR_SYSTEM_ERROR
#endif
//  Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD
#if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD)
#  define BOOST_NO_0X_HDR_THREAD
#endif
//  Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE
#if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE)
#  define BOOST_NO_0X_HDR_TUPLE
#endif
//  Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS
#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
#  define BOOST_NO_0X_HDR_TYPE_TRAITS
#endif
//  Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX
#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX)
#  define BOOST_NO_0X_HDR_TYPEINDEX
#endif
//  Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP
#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP)
#  define BOOST_NO_0X_HDR_UNORDERED_MAP
#endif
//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET
#if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET)
#  define BOOST_NO_0X_HDR_UNORDERED_SET
#endif

//  ------------------ End of deprecated macros for 1.50 ---------------------------

//  -------------------- Deprecated macros for 1.51 ---------------------------
//  These will go away in a future release

//  Use     BOOST_NO_CXX11_AUTO_DECLARATIONS instead of   BOOST_NO_AUTO_DECLARATIONS
#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS)
#  define BOOST_NO_AUTO_DECLARATIONS
#endif
//  Use     BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of   BOOST_NO_AUTO_MULTIDECLARATIONS
#if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS)
#  define BOOST_NO_AUTO_MULTIDECLARATIONS
#endif
//  Use     BOOST_NO_CXX11_CHAR16_T instead of   BOOST_NO_CHAR16_T
#if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T)
#  define BOOST_NO_CHAR16_T
#endif
//  Use     BOOST_NO_CXX11_CHAR32_T instead of   BOOST_NO_CHAR32_T
#if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T)
#  define BOOST_NO_CHAR32_T
#endif
//  Use     BOOST_NO_CXX11_TEMPLATE_ALIASES instead of   BOOST_NO_TEMPLATE_ALIASES
#if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES)
#  define BOOST_NO_TEMPLATE_ALIASES
#endif
//  Use     BOOST_NO_CXX11_CONSTEXPR instead of   BOOST_NO_CONSTEXPR
#if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR)
#  define BOOST_NO_CONSTEXPR
#endif
//  Use     BOOST_NO_CXX11_DECLTYPE_N3276 instead of   BOOST_NO_DECLTYPE_N3276
#if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276)
#  define BOOST_NO_DECLTYPE_N3276
#endif
//  Use     BOOST_NO_CXX11_DECLTYPE instead of   BOOST_NO_DECLTYPE
#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE)
#  define BOOST_NO_DECLTYPE
#endif
//  Use     BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of   BOOST_NO_DEFAULTED_FUNCTIONS
#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS)
#  define BOOST_NO_DEFAULTED_FUNCTIONS
#endif
//  Use     BOOST_NO_CXX11_DELETED_FUNCTIONS instead of   BOOST_NO_DELETED_FUNCTIONS
#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS)
#  define BOOST_NO_DELETED_FUNCTIONS
#endif
//  Use     BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of   BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
#  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
#endif
//  Use     BOOST_NO_CXX11_EXTERN_TEMPLATE instead of   BOOST_NO_EXTERN_TEMPLATE
#if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE)
#  define BOOST_NO_EXTERN_TEMPLATE
#endif
//  Use     BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of   BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
#  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
#endif
//  Use     BOOST_NO_CXX11_LAMBDAS instead of   BOOST_NO_LAMBDAS
#if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS)
#  define BOOST_NO_LAMBDAS
#endif
//  Use     BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of   BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
#if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS)
#  define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
#endif
//  Use     BOOST_NO_CXX11_NOEXCEPT instead of   BOOST_NO_NOEXCEPT
#if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT)
#  define BOOST_NO_NOEXCEPT
#endif
//  Use     BOOST_NO_CXX11_NULLPTR instead of   BOOST_NO_NULLPTR
#if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR)
#  define BOOST_NO_NULLPTR
#endif
//  Use     BOOST_NO_CXX11_RAW_LITERALS instead of   BOOST_NO_RAW_LITERALS
#if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS)
#  define BOOST_NO_RAW_LITERALS
#endif
//  Use     BOOST_NO_CXX11_RVALUE_REFERENCES instead of   BOOST_NO_RVALUE_REFERENCES
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES)
#  define BOOST_NO_RVALUE_REFERENCES
#endif
//  Use     BOOST_NO_CXX11_SCOPED_ENUMS instead of   BOOST_NO_SCOPED_ENUMS
#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS)
#  define BOOST_NO_SCOPED_ENUMS
#endif
//  Use     BOOST_NO_CXX11_STATIC_ASSERT instead of   BOOST_NO_STATIC_ASSERT
#if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT)
#  define BOOST_NO_STATIC_ASSERT
#endif
//  Use     BOOST_NO_CXX11_STD_UNORDERED instead of   BOOST_NO_STD_UNORDERED
#if defined(BOOST_NO_CXX11_STD_UNORDERED) && !defined(BOOST_NO_STD_UNORDERED)
#  define BOOST_NO_STD_UNORDERED
#endif
//  Use     BOOST_NO_CXX11_UNICODE_LITERALS instead of   BOOST_NO_UNICODE_LITERALS
#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS)
#  define BOOST_NO_UNICODE_LITERALS
#endif
//  Use     BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of   BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX)
#  define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
#endif
//  Use     BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of   BOOST_NO_VARIADIC_TEMPLATES
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
#  define BOOST_NO_VARIADIC_TEMPLATES
#endif
//  Use     BOOST_NO_CXX11_VARIADIC_MACROS instead of   BOOST_NO_VARIADIC_MACROS
#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS)
#  define BOOST_NO_VARIADIC_MACROS
#endif
//  Use     BOOST_NO_CXX11_NUMERIC_LIMITS instead of   BOOST_NO_NUMERIC_LIMITS_LOWEST
#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST)
#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
#endif
//  ------------------ End of deprecated macros for 1.51 ---------------------------


//
// Helper macro for marking types and methods final
//
#if !defined(BOOST_NO_CXX11_FINAL)
#  define BOOST_FINAL final
#else
#  define BOOST_FINAL
#endif

//
// Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR
// These aid the transition to C++11 while still supporting C++03 compilers
//
#ifdef BOOST_NO_CXX11_NOEXCEPT
#  define BOOST_NOEXCEPT
#  define BOOST_NOEXCEPT_OR_NOTHROW throw()
#  define BOOST_NOEXCEPT_IF(Predicate)
#  define BOOST_NOEXCEPT_EXPR(Expression) false
#else
#  define BOOST_NOEXCEPT noexcept
#  define BOOST_NOEXCEPT_OR_NOTHROW noexcept
#  define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
#  define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
#endif
//
// Helper macro BOOST_FALLTHROUGH
// Fallback definition of BOOST_FALLTHROUGH macro used to mark intended
// fall-through between case labels in a switch statement. We use a definition
// that requires a semicolon after it to avoid at least one type of misuse even
// on unsupported compilers.
//
#ifndef BOOST_FALLTHROUGH
#  define BOOST_FALLTHROUGH ((void)0)
#endif

//
// constexpr workarounds
//
#if defined(BOOST_NO_CXX11_CONSTEXPR)
#define BOOST_CONSTEXPR
#define BOOST_CONSTEXPR_OR_CONST const
#else
#define BOOST_CONSTEXPR constexpr
#define BOOST_CONSTEXPR_OR_CONST constexpr
#endif
#if defined(BOOST_NO_CXX14_CONSTEXPR)
#define BOOST_CXX14_CONSTEXPR
#else
#define BOOST_CXX14_CONSTEXPR constexpr
#endif

//
// C++17 inline variables
//
#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
#define BOOST_INLINE_VARIABLE inline
#else
#define BOOST_INLINE_VARIABLE
#endif
//
// C++17 if constexpr
//
#if !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
#  define BOOST_IF_CONSTEXPR if constexpr
#else
#  define BOOST_IF_CONSTEXPR if
#endif

#define BOOST_INLINE_CONSTEXPR  BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST

//
// Unused variable/typedef workarounds:
//
#ifndef BOOST_ATTRIBUTE_UNUSED
#  define BOOST_ATTRIBUTE_UNUSED
#endif
//
// [[nodiscard]]:
//
#if defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
#if __has_attribute(nodiscard)
# define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
#endif
#if __has_attribute(no_unique_address)
# define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
#endif
#elif defined(__has_cpp_attribute)
// clang-6 accepts [[nodiscard]] with -std=c++14, but warns about it -pedantic
#if __has_cpp_attribute(nodiscard) && !(defined(__clang__) && (__cplusplus < 201703L)) && !(defined(__GNUC__) && (__cplusplus < 201100))
# define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
#endif
#if __has_cpp_attribute(no_unique_address) && !(defined(__GNUC__) && (__cplusplus < 201100))
# define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
#endif
#endif
#ifndef BOOST_ATTRIBUTE_NODISCARD
# define BOOST_ATTRIBUTE_NODISCARD
#endif
#ifndef BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS
# define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS
#endif

#define BOOST_STATIC_CONSTEXPR  static BOOST_CONSTEXPR_OR_CONST

#if !defined(BOOST_NO_CXX11_NULLPTR)
# define BOOST_NULLPTR nullptr
#else
# define BOOST_NULLPTR 0
#endif

//
// Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined
//
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT)
#  define BOOST_HAS_STATIC_ASSERT
#endif

//
// Set BOOST_HAS_RVALUE_REFS when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
//
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS)
#define BOOST_HAS_RVALUE_REFS
#endif

//
// Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_CXX11_VARIADIC_TEMPLATES is not defined
//
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL)
#define BOOST_HAS_VARIADIC_TMPL
#endif
//
// Set BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS when
// BOOST_NO_CXX11_VARIADIC_TEMPLATES is set:
//
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS)
#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#endif

// This is a catch all case for obsolete compilers / std libs:
#if !defined(_YVALS) && !defined(_CPPLIB_VER)  // msvc std lib already configured
#if (!defined(__has_include) || (__cplusplus < 201700))
#  define BOOST_NO_CXX17_HDR_OPTIONAL
#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#  define BOOST_NO_CXX17_HDR_VARIANT
#  define BOOST_NO_CXX17_HDR_ANY
#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
#  define BOOST_NO_CXX17_HDR_CHARCONV
#  define BOOST_NO_CXX17_HDR_EXECUTION
#  define BOOST_NO_CXX17_HDR_FILESYSTEM
#else
#if !__has_include(<optional>)
#  define BOOST_NO_CXX17_HDR_OPTIONAL
#endif
#if !__has_include(<string_view>)
#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#endif
#if !__has_include(<variant>)
#  define BOOST_NO_CXX17_HDR_VARIANT
#endif
#if !__has_include(<any>)
#  define BOOST_NO_CXX17_HDR_ANY
#endif
#if !__has_include(<memory_resource>)
#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
#endif
#if !__has_include(<charconv>)
#  define BOOST_NO_CXX17_HDR_CHARCONV
#endif
#if !__has_include(<execution>)
#  define BOOST_NO_CXX17_HDR_EXECUTION
#endif
#if !__has_include(<filesystem>)
#  define BOOST_NO_CXX17_HDR_FILESYSTEM
#endif
#endif
#endif
//
// Define the std level that the compiler claims to support:
//
#ifndef BOOST_CXX_VERSION
#  define BOOST_CXX_VERSION __cplusplus
#endif

#if (!defined(__has_include) || (BOOST_CXX_VERSION < 201704))
#  define BOOST_NO_CXX20_HDR_BARRIER
#  define BOOST_NO_CXX20_HDR_FORMAT
#  define BOOST_NO_CXX20_HDR_SOURCE_LOCATION
#  define BOOST_NO_CXX20_HDR_BIT
#  define BOOST_NO_CXX20_HDR_LATCH
#  define BOOST_NO_CXX20_HDR_SPAN
#  define BOOST_NO_CXX20_HDR_COMPARE
#  define BOOST_NO_CXX20_HDR_NUMBERS
#  define BOOST_NO_CXX20_HDR_STOP_TOKEN
#  define BOOST_NO_CXX20_HDR_CONCEPTS
#  define BOOST_NO_CXX20_HDR_RANGES
#  define BOOST_NO_CXX20_HDR_SYNCSTREAM
#  define BOOST_NO_CXX20_HDR_COROUTINE
#  define BOOST_NO_CXX20_HDR_SEMAPHORE
#else
#if (!__has_include(<barrier>) || !defined(__cpp_lib_barrier) || (__cpp_lib_barrier < 201907L)) && !defined(BOOST_NO_CXX20_HDR_BARRIER)
#  define BOOST_NO_CXX20_HDR_BARRIER
#endif
#if (!__has_include(<format>) || !defined(__cpp_lib_format) || (__cpp_lib_format < 201907L)) && !defined(BOOST_NO_CXX20_HDR_FORMAT)
#  define BOOST_NO_CXX20_HDR_FORMAT
#endif
#if (!__has_include(<source_location>) || !defined(__cpp_lib_source_location) || (__cpp_lib_source_location < 201907L)) && !defined(BOOST_NO_CXX20_HDR_SOURCE_LOCATION)
#  define BOOST_NO_CXX20_HDR_SOURCE_LOCATION
#endif
#if (!__has_include(<bit>) || !defined(__cpp_lib_bit_cast) || (__cpp_lib_bit_cast < 201806L) || !defined(__cpp_lib_bitops) || (__cpp_lib_bitops < 201907L) || !defined(__cpp_lib_endian) || (__cpp_lib_endian < 201907L)) && !defined(BOOST_NO_CXX20_HDR_BIT)
#  define BOOST_NO_CXX20_HDR_BIT
#endif
#if (!__has_include(<latch>) || !defined(__cpp_lib_latch) || (__cpp_lib_latch < 201907L)) && !defined(BOOST_NO_CXX20_HDR_LATCH)
#  define BOOST_NO_CXX20_HDR_LATCH
#endif
#if (!__has_include(<span>) || !defined(__cpp_lib_span) || (__cpp_lib_span < 202002L)) && !defined(BOOST_NO_CXX20_HDR_SPAN)
#  define BOOST_NO_CXX20_HDR_SPAN
#endif
#if (!__has_include(<compare>) || !defined(__cpp_lib_three_way_comparison) || (__cpp_lib_three_way_comparison < 201907L)) && !defined(BOOST_NO_CXX20_HDR_COMPARE)
#  define BOOST_NO_CXX20_HDR_COMPARE
#endif
#if (!__has_include(<numbers>) || !defined(__cpp_lib_math_constants) || (__cpp_lib_math_constants < 201907L)) && !defined(BOOST_NO_CXX20_HDR_NUMBERS)
#  define BOOST_NO_CXX20_HDR_NUMBERS
#endif
#if (!__has_include(<stop_token>) || !defined(__cpp_lib_jthread) || (__cpp_lib_jthread < 201911L)) && !defined(BOOST_NO_CXX20_HDR_STOP_TOKEN)
#  define BOOST_NO_CXX20_HDR_STOP_TOKEN
#endif
#if (!__has_include(<concepts>) || !defined(__cpp_lib_concepts) || (__cpp_lib_concepts < 202002L)) && !defined(_YVALS) && !defined(_CPPLIB_VER) && !defined(BOOST_NO_CXX20_HDR_CONCEPTS)
#  define BOOST_NO_CXX20_HDR_CONCEPTS
#endif
#if (!__has_include(<ranges>) || !defined(__cpp_lib_ranges) || (__cpp_lib_ranges < 201911L)) && !defined(BOOST_NO_CXX20_HDR_RANGES)
#  define BOOST_NO_CXX20_HDR_RANGES
#endif
#if (!__has_include(<syncstream>) || !defined(__cpp_lib_syncbuf) || (__cpp_lib_syncbuf < 201803L)) && !defined(BOOST_NO_CXX20_HDR_SYNCSTREAM)
#  define BOOST_NO_CXX20_HDR_SYNCSTREAM
#endif
#if (!__has_include(<coroutine>) || !defined(__cpp_lib_coroutine) || (__cpp_lib_coroutine < 201902L)) && !defined(BOOST_NO_CXX20_HDR_COROUTINE)
#  define BOOST_NO_CXX20_HDR_COROUTINE
#endif
#if (!__has_include(<semaphore>) || !defined(__cpp_lib_semaphore) || (__cpp_lib_semaphore < 201907L)) && !defined(BOOST_NO_CXX20_HDR_SEMAPHORE)
#  define BOOST_NO_CXX20_HDR_SEMAPHORE
#endif
#endif

#if defined(__cplusplus) && defined(__has_include)
#if !__has_include(<version>)
#  define BOOST_NO_CXX20_HDR_VERSION
#else
// For convenience, this is always included:
#  include <version>
#endif
#else
#  define BOOST_NO_CXX20_HDR_VERSION
#endif

#if defined(BOOST_MSVC)
#if (BOOST_MSVC < 1914) || (_MSVC_LANG < 201703)
#  define BOOST_NO_CXX17_DEDUCTION_GUIDES
#endif
#elif !defined(__cpp_deduction_guides) || (__cpp_deduction_guides < 201606)
#  define BOOST_NO_CXX17_DEDUCTION_GUIDES
#endif

//
// Define composite agregate macros:
//
#include <boost/config/detail/cxx_composite.hpp>

//
// Finish off with checks for macros that are depricated / no longer supported,
// if any of these are set then it's very likely that much of Boost will no
// longer work.  So stop with a #error for now, but give the user a chance
// to continue at their own risk if they really want to:
//
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED)
#  error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!"
#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/header_deprecated.hpp
================================================
#ifndef BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED
#define BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED

//  Copyright 2017 Peter Dimov.
//
//  Distributed under the Boost Software License, Version 1.0.
//
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt
//
//  BOOST_HEADER_DEPRECATED("<alternative>")
//
//  Expands to the equivalent of
//    BOOST_PRAGMA_MESSAGE("This header is deprecated. Use <alternative> instead.")
//
//  Note that this header is C compatible.

#include <boost/config/pragma_message.hpp>

#if defined(BOOST_ALLOW_DEPRECATED_HEADERS) || defined(BOOST_ALLOW_DEPRECATED)
# define BOOST_HEADER_DEPRECATED(a)
#else
# define BOOST_HEADER_DEPRECATED(a) BOOST_PRAGMA_MESSAGE("This header is deprecated. Use " a " instead.")
#endif

#endif // BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/helper_macros.hpp
================================================
#ifndef BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED
#define BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED

//  Copyright 2001 John Maddock.
//  Copyright 2017 Peter Dimov.
//
//  Distributed under the Boost Software License, Version 1.0.
//
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt
//
//  BOOST_STRINGIZE(X)
//  BOOST_JOIN(X, Y)
//
//  Note that this header is C compatible.

//
// Helper macro BOOST_STRINGIZE:
// Converts the parameter X to a string after macro replacement
// on X has been performed.
//
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X

//
// Helper macro BOOST_JOIN:
// The following piece of macro magic joins the two
// arguments together, even when one of the arguments is
// itself a macro (see 16.3.1 in C++ standard).  The key
// is that macro expansion of macro arguments does not
// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
//
#define BOOST_JOIN(X, Y) BOOST_DO_JOIN(X, Y)
#define BOOST_DO_JOIN(X, Y) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2(X, Y) X##Y

#endif // BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/no_tr1/cmath.hpp
================================================
//  (C) Copyright John Maddock 2008.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// The aim of this header is just to include <cmath> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/cmath is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_CMATH
#  define BOOST_CONFIG_CMATH

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_CMATH_RECURSION
#  endif

#  include <cmath>

#  ifdef BOOST_CONFIG_NO_CMATH_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_CMATH_RECURSION
#  endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/no_tr1/complex.hpp
================================================
//  (C) Copyright John Maddock 2005.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// The aim of this header is just to include <complex> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/complex is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_COMPLEX
#  define BOOST_CONFIG_COMPLEX

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_COMPLEX_RECURSION
#  endif

#  include <complex>

#  ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_COMPLEX_RECURSION
#  endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/no_tr1/functional.hpp
================================================
//  (C) Copyright John Maddock 2005.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// The aim of this header is just to include <functional> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/functional is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_FUNCTIONAL
#  define BOOST_CONFIG_FUNCTIONAL

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
#  endif

#  include <functional>

#  ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
#  endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/no_tr1/memory.hpp
================================================
//  (C) Copyright John Maddock 2005.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// The aim of this header is just to include <memory> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/memory is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_MEMORY
#  define BOOST_CONFIG_MEMORY

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_MEMORY_RECURSION
#  endif

#  include <memory>

#  ifdef BOOST_CONFIG_NO_MEMORY_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_MEMORY_RECURSION
#  endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/no_tr1/utility.hpp
================================================
//  (C) Copyright John Maddock 2005.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// The aim of this header is just to include <utility> but to do
// so in a way that does not result in recursive inclusion of
// the Boost TR1 components if boost/tr1/tr1/utility is in the
// include search path.  We have to do this to avoid circular
// dependencies:
//

#ifndef BOOST_CONFIG_UTILITY
#  define BOOST_CONFIG_UTILITY

#  ifndef BOOST_TR1_NO_RECURSION
#     define BOOST_TR1_NO_RECURSION
#     define BOOST_CONFIG_NO_UTILITY_RECURSION
#  endif

#  include <utility>

#  ifdef BOOST_CONFIG_NO_UTILITY_RECURSION
#     undef BOOST_TR1_NO_RECURSION
#     undef BOOST_CONFIG_NO_UTILITY_RECURSION
#  endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/aix.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  IBM/Aix specific config options:

#define BOOST_PLATFORM "IBM Aix"

#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_CLOCK_GETTIME

// This needs support in "boost/cstdint.hpp" exactly like FreeBSD.
// This platform has header named <inttypes.h> which includes all
// the things needed.
#define BOOST_HAS_STDINT_H

// Threading API's:
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_PTHREAD_DELAY_NP
#define BOOST_HAS_SCHED_YIELD
//#define BOOST_HAS_PTHREAD_YIELD

// boilerplate code:
#include <boost/config/detail/posix_features.hpp>






================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/amigaos.hpp
================================================
//  (C) Copyright John Maddock 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

#define BOOST_PLATFORM "AmigaOS"

#define BOOST_DISABLE_THREADS
#define BOOST_NO_CWCHAR
#define BOOST_NO_STD_WSTRING
#define BOOST_NO_INTRINSIC_WCHAR_T
 



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/beos.hpp
================================================
//  (C) Copyright John Maddock 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  BeOS specific config options:

#define BOOST_PLATFORM "BeOS"

#define BOOST_NO_CWCHAR
#define BOOST_NO_CWCTYPE
#define BOOST_HAS_UNISTD_H

#define BOOST_HAS_BETHREADS

#ifndef BOOST_DISABLE_THREADS
#  define BOOST_HAS_THREADS
#endif

// boilerplate code:
#include <boost/config/detail/posix_features.hpp>
 




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/bsd.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Darin Adler 2001. 
//  (C) Copyright Douglas Gregor 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  generic BSD config options:

#if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
#error "This platform is not BSD"
#endif

#ifdef __FreeBSD__
#define BOOST_PLATFORM "FreeBSD " BOOST_STRINGIZE(__FreeBSD__)
#elif defined(__NetBSD__)
#define BOOST_PLATFORM "NetBSD " BOOST_STRINGIZE(__NetBSD__)
#elif defined(__OpenBSD__)
#define BOOST_PLATFORM "OpenBSD " BOOST_STRINGIZE(__OpenBSD__)
#elif defined(__DragonFly__)
#define BOOST_PLATFORM "DragonFly " BOOST_STRINGIZE(__DragonFly__)
#endif

//
// is this the correct version check?
// FreeBSD has <nl_types.h> but does not
// advertise the fact in <unistd.h>:
//
#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) \
   || defined(__OpenBSD__) || defined(__DragonFly__)
#  define BOOST_HAS_NL_TYPES_H
#endif

//
// FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in <pthread.h>
// and not in <unistd.h>
//
#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3))\
   || defined(__OpenBSD__) || defined(__DragonFly__) 
#  define BOOST_HAS_PTHREADS
#endif

//
// No wide character support in the BSD header files:
//
#if defined(__NetBSD__)
#define __NetBSD_GCC__ (__GNUC__         * 1000000 \
                       + __GNUC_MINOR__ *    1000 \
                       + __GNUC_PATCHLEVEL__)
// XXX - the following is required until c++config.h
//       defines _GLIBCXX_HAVE_SWPRINTF and friends
//       or the preprocessor conditionals are removed
//       from the cwchar header.
#define _GLIBCXX_HAVE_SWPRINTF 1
#endif

#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
      || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) \
      || defined(__OpenBSD__) || defined(__DragonFly__))
#  define BOOST_NO_CWCHAR
#endif
//
// The BSD <ctype.h> has macros only, no functions:
//
#if !defined(__OpenBSD__) || defined(__DragonFly__)
#  define BOOST_NO_CTYPE_FUNCTIONS
#endif

//
// thread API's not auto detected:
//
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_SIGACTION
#define BOOST_HAS_CLOCK_GETTIME

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/cloudabi.hpp
================================================
//       Copyright Nuxi, https://nuxi.nl/ 2015.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_PLATFORM "CloudABI"

#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_UNISTD_H

#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_EXPM1
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_LOG1P
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_SCHED_YIELD


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/cray.hpp
================================================
//  (C) Copyright John Maddock 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


//  See http://www.boost.org for most recent version.

//  SGI Irix specific config options:

#define BOOST_PLATFORM "Cray"

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/cygwin.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  cygwin specific config options:

#define BOOST_PLATFORM "Cygwin"
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_LOG1P
#define BOOST_HAS_EXPM1

//
// Threading API:
// See if we have POSIX threads, if we do use them, otherwise
// revert to native Win threads.
#define BOOST_HAS_UNISTD_H
#include <unistd.h>
#if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS)
#  define BOOST_HAS_PTHREADS
#  define BOOST_HAS_SCHED_YIELD
#  define BOOST_HAS_GETTIMEOFDAY
#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
//#  define BOOST_HAS_SIGACTION
#else
#  if !defined(BOOST_HAS_WINTHREADS)
#     define BOOST_HAS_WINTHREADS
#  endif
#  define BOOST_HAS_FTIME
#endif

//
// find out if we have a stdint.h, there should be a better way to do this:
//
#include <sys/types.h>
#ifdef _STDINT_H
#define BOOST_HAS_STDINT_H
#endif
#if __GNUC__ > 5 && !defined(BOOST_HAS_STDINT_H)
#   define BOOST_HAS_STDINT_H
#endif

#include <cygwin/version.h>
#if (CYGWIN_VERSION_API_MAJOR == 0 && CYGWIN_VERSION_API_MINOR < 231)
/// Cygwin has no fenv.h
#define BOOST_NO_FENV_H
#endif

// Cygwin has it's own <pthread.h> which breaks <shared_mutex> unless the correct compiler flags are used:
#ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX
#include <pthread.h>
#if !(__XSI_VISIBLE >= 500 || __POSIX_VISIBLE >= 200112)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#endif

// boilerplate code:
#include <boost/config/detail/posix_features.hpp>

//
// Cygwin lies about XSI conformance, there is no nl_types.h:
//
#ifdef BOOST_HAS_NL_TYPES_H
#  undef BOOST_HAS_NL_TYPES_H
#endif






================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/haiku.hpp
================================================
//  (C) Copyright Jessica Hamilton 2014.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Haiku specific config options:

#define BOOST_PLATFORM "Haiku"

#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_STDINT_H

#ifndef BOOST_DISABLE_THREADS
#  define BOOST_HAS_THREADS
#endif

#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_VARIADIC_MACROS

//
// thread API's not auto detected:
//
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_GETTIMEOFDAY

// boilerplate code:
#include <boost/config/detail/posix_features.hpp>


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/hpux.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2001 - 2003. 
//  (C) Copyright David Abrahams 2002. 
//  (C) Copyright Toon Knapen 2003. 
//  (C) Copyright Boris Gubenko 2006 - 2007.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  hpux specific config options:

#define BOOST_PLATFORM "HP-UX"

// In principle, HP-UX has a nice <stdint.h> under the name <inttypes.h>
// However, it has the following problem:
// Use of UINT32_C(0) results in "0u l" for the preprocessed source
// (verifyable with gcc 2.95.3)
#if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__HP_aCC)
#  define BOOST_HAS_STDINT_H
#endif

#if !(defined(__HP_aCC) || !defined(_INCLUDE__STDC_A1_SOURCE))
#  define BOOST_NO_SWPRINTF
#endif
#if defined(__HP_aCC) && !defined(_INCLUDE__STDC_A1_SOURCE)
#  define BOOST_NO_CWCTYPE
#endif

#if defined(__GNUC__)
#  if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))
      // GNU C on HP-UX does not support threads (checked up to gcc 3.3)
#     define BOOST_DISABLE_THREADS
#  elif !defined(BOOST_DISABLE_THREADS)
      // threads supported from gcc-3.3 onwards:
#     define BOOST_HAS_THREADS
#     define BOOST_HAS_PTHREADS
#  endif
#elif defined(__HP_aCC) && !defined(BOOST_DISABLE_THREADS)
#  define BOOST_HAS_PTHREADS
#endif

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>

// the following are always available:
#ifndef BOOST_HAS_GETTIMEOFDAY
#  define BOOST_HAS_GETTIMEOFDAY
#endif
#ifndef BOOST_HAS_SCHED_YIELD
#    define BOOST_HAS_SCHED_YIELD
#endif
#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#endif
#ifndef BOOST_HAS_NL_TYPES_H
#    define BOOST_HAS_NL_TYPES_H
#endif
#ifndef BOOST_HAS_NANOSLEEP
#    define BOOST_HAS_NANOSLEEP
#endif
#ifndef BOOST_HAS_GETTIMEOFDAY
#    define BOOST_HAS_GETTIMEOFDAY
#endif
#ifndef BOOST_HAS_DIRENT_H
#    define BOOST_HAS_DIRENT_H
#endif
#ifndef BOOST_HAS_CLOCK_GETTIME
#    define BOOST_HAS_CLOCK_GETTIME
#endif
#ifndef BOOST_HAS_SIGACTION
#  define BOOST_HAS_SIGACTION
#endif
#ifndef BOOST_HAS_NRVO 
#  ifndef __parisc
#    define BOOST_HAS_NRVO
#  endif
#endif
#ifndef BOOST_HAS_LOG1P 
#  define BOOST_HAS_LOG1P
#endif
#ifndef BOOST_HAS_EXPM1
#  define BOOST_HAS_EXPM1
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/irix.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


//  See http://www.boost.org for most recent version.

//  SGI Irix specific config options:

#define BOOST_PLATFORM "SGI Irix"

#define BOOST_NO_SWPRINTF 
//
// these are not auto detected by POSIX feature tests:
//
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE

#ifdef __GNUC__
   // GNU C on IRIX does not support threads (checked up to gcc 3.3)
#  define BOOST_DISABLE_THREADS
#endif

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/linux.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  linux specific config options:

#define BOOST_PLATFORM "linux"

// make sure we have __GLIBC_PREREQ if available at all
#ifdef __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>
#endif

//
// <stdint.h> added to glibc 2.1.1
// We can only test for 2.1 though:
//
#if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1)))
   // <stdint.h> defines int64_t unconditionally, but <sys/types.h> defines
   // int64_t only if __GNUC__.  Thus, assume a fully usable <stdint.h>
   // only when using GCC.  Update 2017: this appears not to be the case for
   // recent glibc releases, see bug report: https://svn.boost.org/trac/boost/ticket/13045
#  if defined(__GNUC__) || ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 5)))
#    define BOOST_HAS_STDINT_H
#  endif
#endif

#if defined(__LIBCOMO__)
   //
   // como on linux doesn't have std:: c functions:
   // NOTE: versions of libcomo prior to beta28 have octal version numbering,
   // e.g. version 25 is 21 (dec)
   //
#  if __LIBCOMO_VERSION__ <= 20
#    define BOOST_NO_STDC_NAMESPACE
#  endif

#  if __LIBCOMO_VERSION__ <= 21
#    define BOOST_NO_SWPRINTF
#  endif

#endif

//
// If glibc is past version 2 then we definitely have
// gettimeofday, earlier versions may or may not have it:
//
#if defined(__GLIBC__) && (__GLIBC__ >= 2)
#  define BOOST_HAS_GETTIMEOFDAY
#endif

#ifdef __USE_POSIX199309
#  define BOOST_HAS_NANOSLEEP
#endif

#if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
// __GLIBC_PREREQ is available since 2.1.2

   // swprintf is available since glibc 2.2.0
#  if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98))
#    define BOOST_NO_SWPRINTF
#  endif
#else
#  define BOOST_NO_SWPRINTF
#endif

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>
#if defined(__USE_GNU) && !defined(__ANDROID__) && !defined(ANDROID)
#define BOOST_HAS_PTHREAD_YIELD
#endif

#ifndef __GNUC__
//
// if the compiler is not gcc we still need to be able to parse
// the GNU system headers, some of which (mainly <stdint.h>)
// use GNU specific extensions:
//
#  ifndef __extension__
#     define __extension__
#  endif
#  ifndef __const__
#     define __const__ const
#  endif
#  ifndef __volatile__
#     define __volatile__ volatile
#  endif
#  ifndef __signed__
#     define __signed__ signed
#  endif
#  ifndef __typeof__
#     define __typeof__ typeof
#  endif
#  ifndef __inline__
#     define __inline__ inline
#  endif
#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/macos.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Darin Adler 2001 - 2002. 
//  (C) Copyright Bill Kempf 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Mac OS specific config options:

#define BOOST_PLATFORM "Mac OS"

#if __MACH__ && !defined(_MSL_USING_MSL_C)

// Using the Mac OS X system BSD-style C library.

#  ifndef BOOST_HAS_UNISTD_H
#    define BOOST_HAS_UNISTD_H
#  endif
//
// Begin by including our boilerplate code for POSIX
// feature detection, this is safe even when using
// the MSL as Metrowerks supply their own <unistd.h>
// to replace the platform-native BSD one. G++ users
// should also always be able to do this on MaxOS X.
//
#  include <boost/config/detail/posix_features.hpp>
#  ifndef BOOST_HAS_STDINT_H
#     define BOOST_HAS_STDINT_H
#  endif

//
// BSD runtime has pthreads, sigaction, sched_yield and gettimeofday,
// of these only pthreads are advertised in <unistd.h>, so set the 
// other options explicitly:
//
#  define BOOST_HAS_SCHED_YIELD
#  define BOOST_HAS_GETTIMEOFDAY
#  define BOOST_HAS_SIGACTION

#  if (__GNUC__ < 3) && !defined( __APPLE_CC__)

// GCC strange "ignore std" mode works better if you pretend everything
// is in the std namespace, for the most part.

#    define BOOST_NO_STDC_NAMESPACE
#  endif

#  if (__GNUC__ >= 4)

// Both gcc and intel require these.  
#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#    define BOOST_HAS_NANOSLEEP

#  endif

#else

// Using the MSL C library.

// We will eventually support threads in non-Carbon builds, but we do
// not support this yet.
#  if ( defined(TARGET_API_MAC_CARBON) && TARGET_API_MAC_CARBON ) || ( defined(TARGET_CARBON) && TARGET_CARBON )

#  if !defined(BOOST_HAS_PTHREADS)
// MPTasks support is deprecated/removed from Boost:
//#    define BOOST_HAS_MPTASKS
#  elif ( __dest_os == __mac_os_x )
// We are doing a Carbon/Mach-O/MSL build which has pthreads, but only the
// gettimeofday and no posix.
#  define BOOST_HAS_GETTIMEOFDAY
#  endif

#ifdef BOOST_HAS_PTHREADS
#  define BOOST_HAS_THREADS
#endif

// The remote call manager depends on this.
#    define BOOST_BIND_ENABLE_PASCAL

#  endif

#endif





================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/qnxnto.hpp
================================================
//  (C) Copyright Jim Douglas 2005. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  QNX specific config options:

#define BOOST_PLATFORM "QNX"

#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>

// QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h
// or log1p and expm1:
#undef  BOOST_HAS_NL_TYPES_H
#undef  BOOST_HAS_LOG1P
#undef  BOOST_HAS_EXPM1

#define BOOST_HAS_PTHREADS
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE

#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_NANOSLEEP







================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/solaris.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  sun specific config options:

#define BOOST_PLATFORM "Sun Solaris"

#define BOOST_HAS_GETTIMEOFDAY

// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/detail/posix_features.hpp>

//
// pthreads don't actually work with gcc unless _PTHREADS is defined:
//
#if defined(__GNUC__) && defined(_POSIX_THREADS) && !defined(_PTHREADS)
# undef BOOST_HAS_PTHREADS
#endif

#define BOOST_HAS_STDINT_H 
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
#define BOOST_HAS_LOG1P 
#define BOOST_HAS_EXPM1




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/symbian.hpp
================================================
//  (C) Copyright Yuriy Krasnoschek 2009. 
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  symbian specific config options:


#define BOOST_PLATFORM "Symbian"
#define BOOST_SYMBIAN 1


#if defined(__S60_3X__)
// Open C / C++ plugin was introdused in this SDK, earlier versions don't have CRT / STL
#  define BOOST_S60_3rd_EDITION_FP2_OR_LATER_SDK
// make sure we have __GLIBC_PREREQ if available at all
#ifdef __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>
#endif// boilerplate code:
#  define BOOST_HAS_UNISTD_H
#  include <boost/config/detail/posix_features.hpp>
// S60 SDK defines _POSIX_VERSION as POSIX.1
#  ifndef BOOST_HAS_STDINT_H
#    define BOOST_HAS_STDINT_H
#  endif
#  ifndef BOOST_HAS_GETTIMEOFDAY
#    define BOOST_HAS_GETTIMEOFDAY
#  endif
#  ifndef BOOST_HAS_DIRENT_H
#    define BOOST_HAS_DIRENT_H
#  endif
#  ifndef BOOST_HAS_SIGACTION
#    define BOOST_HAS_SIGACTION
#  endif
#  ifndef BOOST_HAS_PTHREADS
#    define BOOST_HAS_PTHREADS
#  endif
#  ifndef BOOST_HAS_NANOSLEEP
#    define BOOST_HAS_NANOSLEEP
#  endif
#  ifndef BOOST_HAS_SCHED_YIELD
#    define BOOST_HAS_SCHED_YIELD
#  endif
#  ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#  endif
#  ifndef BOOST_HAS_LOG1P
#    define BOOST_HAS_LOG1P
#  endif
#  ifndef BOOST_HAS_EXPM1
#    define BOOST_HAS_EXPM1
#  endif
#  ifndef BOOST_POSIX_API
#    define BOOST_POSIX_API
#  endif
// endianess support
#  include <sys/endian.h>
// Symbian SDK provides _BYTE_ORDER instead of __BYTE_ORDER
#  ifndef __LITTLE_ENDIAN
#    ifdef _LITTLE_ENDIAN
#      define __LITTLE_ENDIAN _LITTLE_ENDIAN
#    else
#      define __LITTLE_ENDIAN 1234
#    endif
#  endif
#  ifndef __BIG_ENDIAN
#    ifdef _BIG_ENDIAN
#      define __BIG_ENDIAN _BIG_ENDIAN
#    else
#      define __BIG_ENDIAN 4321
#    endif
#  endif
#  ifndef __BYTE_ORDER
#    define __BYTE_ORDER __LITTLE_ENDIAN // Symbian is LE
#  endif
// Known limitations
#  define BOOST_ASIO_DISABLE_SERIAL_PORT
#  define BOOST_DATE_TIME_NO_LOCALE
#  define BOOST_NO_STD_WSTRING
#  define BOOST_EXCEPTION_DISABLE
#  define BOOST_NO_EXCEPTIONS

#else // TODO: More platform support e.g. UIQ
#  error "Unsuppoted Symbian SDK"
#endif

#if defined(__WINSCW__) && !defined(BOOST_DISABLE_WIN32)
#  define BOOST_DISABLE_WIN32 // winscw defines WIN32 macro
#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/vms.hpp
================================================
//  (C) Copyright Artyom Beilis 2010.  
//  Use, modification and distribution are subject to the  
//  Boost Software License, Version 1.0. (See accompanying file  
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 

#ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 
#define BOOST_CONFIG_PLATFORM_VMS_HPP 

#define BOOST_PLATFORM "OpenVMS" 

#undef  BOOST_HAS_STDINT_H 
#define BOOST_HAS_UNISTD_H 
#define BOOST_HAS_NL_TYPES_H 
#define BOOST_HAS_GETTIMEOFDAY 
#define BOOST_HAS_DIRENT_H 
#define BOOST_HAS_PTHREADS 
#define BOOST_HAS_NANOSLEEP 
#define BOOST_HAS_CLOCK_GETTIME 
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
#define BOOST_HAS_LOG1P 
#define BOOST_HAS_EXPM1 
#define BOOST_HAS_THREADS 
#undef  BOOST_HAS_SCHED_YIELD 

#endif 


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/vxworks.hpp
================================================
//  (C) Copyright Dustin Spicuzza 2009.
//      Adapted to vxWorks 6.9 by Peter Brockamp 2012.
//      Updated for VxWorks 7 by Brian Kuhl 2016
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Old versions of vxWorks (namely everything below 6.x) are
//  absolutely unable to use boost. Old STLs and compilers 
//  like (GCC 2.96) . Do not even think of getting this to work, 
//  a miserable failure will  be guaranteed!
//
//  VxWorks supports C++ linkage in the kernel with
//  DKMs (Downloadable Kernel Modules). But, until recently 
//  the kernel used a C89 library with no
//  wide character support and no guarantee of ANSI C. 
//  Regardless of the C library the same Dinkum 
//  STL library is used in both contexts. 
//
//  Similarly the Dinkum abridged STL that supports the loosely specified 
//  embedded C++ standard has not been tested and is unlikely to work 
//  on anything but the simplest library.
// ====================================================================
//
// Some important information regarding the usage of POSIX semaphores:
// -------------------------------------------------------------------
//
// VxWorks as a real time operating system handles threads somewhat
// different from what "normal" OSes do, regarding their scheduling!
// This could lead to a scenario called "priority inversion" when using
// semaphores, see http://en.wikipedia.org/wiki/Priority_inversion.
//
// Now, VxWorks POSIX-semaphores for DKM's default to the usage of
// priority inverting semaphores, which is fine. On the other hand,
// for RTP's it defaults to using non priority inverting semaphores,
// which could easily pose a serious problem for a real time process.
//
// To change the default properties for POSIX-semaphores in VxWorks 7
// enable core > CORE_USER Menu > DEFAULT_PTHREAD_PRIO_INHERIT 
//  
// In VxWorks 6.x so as to integrate with boost. 
// - Edit the file 
//   installDir/vxworks-6.x/target/usr/src/posix/pthreadLib.c
// - Around line 917 there should be the definition of the default
//   mutex attributes:
//
//   LOCAL pthread_mutexattr_t defaultMutexAttr =
//       {
//       PTHREAD_INITIALIZED_OBJ, PTHREAD_PRIO_NONE, 0,
//       PTHREAD_MUTEX_DEFAULT
//       };
//
//   Here, replace PTHREAD_PRIO_NONE by PTHREAD_PRIO_INHERIT.
// - Around line 1236 there should be a definition for the function
//   pthread_mutexattr_init(). A couple of lines below you should
//   find a block of code like this:
//
//   pAttr->mutexAttrStatus      = PTHREAD_INITIALIZED_OBJ;
//   pAttr->mutexAttrProtocol    = PTHREAD_PRIO_NONE;
//   pAttr->mutexAttrPrioceiling = 0;
//   pAttr->mutexAttrType        = PTHREAD_MUTEX_DEFAULT;
//
//   Here again, replace PTHREAD_PRIO_NONE by PTHREAD_PRIO_INHERIT.
// - Finally, rebuild your VSB. This will rebuild the libraries
//   with the changed properties. That's it! Now, using boost should
//   no longer cause any problems with task deadlocks!
//
//  ====================================================================

// Block out all versions before vxWorks 6.x, as these don't work:
// Include header with the vxWorks version information and query them
#include <version.h>
#if !defined(_WRS_VXWORKS_MAJOR) || (_WRS_VXWORKS_MAJOR < 6)
#  error "The vxWorks version you're using is so badly outdated,\
          it doesn't work at all with boost, sorry, no chance!"
#endif

// Handle versions above 5.X but below 6.9
#if (_WRS_VXWORKS_MAJOR == 6) && (_WRS_VXWORKS_MINOR < 9)
// TODO: Starting from what version does vxWorks work with boost?
// We can't reasonably insert a #warning "" as a user hint here,
// as this will show up with every file including some boost header,
// badly bugging the user... So for the time being we just leave it.
#endif

// vxWorks specific config options:
// --------------------------------
#define BOOST_PLATFORM "vxWorks"


// Generally available headers:
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_DIRENT_H
//#define BOOST_HAS_SLIST

// vxWorks does not have installed an iconv-library by default,
// so unfortunately no Unicode support from scratch is available!
// Thus, instead it is suggested to switch to ICU, as this seems
// to be the most complete and portable option...
#ifndef BOOST_LOCALE_WITH_ICU
   #define BOOST_LOCALE_WITH_ICU
#endif

// Generally available functionality:
#define BOOST_HAS_THREADS
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_MACRO_USE_FACET

// Generally available threading API's:
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_SIGACTION

// Functionality available for RTPs only:
#ifdef __RTP__
#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#  define BOOST_HAS_LOG1P
#  define BOOST_HAS_EXPM1
#endif

// Functionality available for DKMs only:
#ifdef _WRS_KERNEL
  // Luckily, at the moment there seems to be none!
#endif

// These #defines allow detail/posix_features to work, since vxWorks doesn't
// #define them itself for DKMs (for RTPs on the contrary it does):
#ifdef _WRS_KERNEL
#  ifndef _POSIX_TIMERS
#    define _POSIX_TIMERS  1
#  endif
#  ifndef _POSIX_THREADS
#    define _POSIX_THREADS 1
#  endif
// no sysconf( _SC_PAGESIZE) in kernel
#  define BOOST_THREAD_USES_GETPAGESIZE
#endif

#if (_WRS_VXWORKS_MAJOR < 7) 
// vxWorks-around: <time.h> #defines CLOCKS_PER_SEC as sysClkRateGet() but
//                 miserably fails to #include the required <sysLib.h> to make
//                 sysClkRateGet() available! So we manually include it here.
#  ifdef __RTP__
#    include <time.h>
#    include <sysLib.h>
#  endif

// vxWorks-around: In <stdint.h> the macros INT32_C(), UINT32_C(), INT64_C() and
//                 UINT64_C() are defined erroneously, yielding not a signed/
//                 unsigned long/long long type, but a signed/unsigned int/long
//                 type. Eventually this leads to compile errors in ratio_fwd.hpp,
//                 when trying to define several constants which do not fit into a
//                 long type! We correct them here by redefining.

#  include <cstdint>

// Special behaviour for DKMs:

// Some macro-magic to do the job
#  define VX_JOIN(X, Y)     VX_DO_JOIN(X, Y)
#  define VX_DO_JOIN(X, Y)  VX_DO_JOIN2(X, Y)
#  define VX_DO_JOIN2(X, Y) X##Y

// Correctly setup the macros
#  undef  INT32_C
#  undef  UINT32_C
#  undef  INT64_C
#  undef  UINT64_C
#  define INT32_C(x)  VX_JOIN(x, L)
#  define UINT32_C(x) VX_JOIN(x, UL)
#  define INT64_C(x)  VX_JOIN(x, LL)
#  define UINT64_C(x) VX_JOIN(x, ULL)

// #include Libraries required for the following function adaption
#  include <sys/time.h>
#endif  // _WRS_VXWORKS_MAJOR < 7

#include <ioLib.h>
#include <tickLib.h>

#if defined(_WRS_KERNEL) && (_CPPLIB_VER < 700)
  // recent kernels use Dinkum clib v7.00+
  // with widechar but older kernels
  // do not have the <cwchar>-header,
  // but apparently they do have an intrinsic wchar_t meanwhile!
#  define BOOST_NO_CWCHAR

  // Lots of wide-functions and -headers are unavailable for DKMs as well:
#  define BOOST_NO_CWCTYPE
#  define BOOST_NO_SWPRINTF
#  define BOOST_NO_STD_WSTRING
#  define BOOST_NO_STD_WSTREAMBUF
#endif


// Use C-linkage for the following helper functions
#ifdef __cplusplus
extern "C" {
#endif

// vxWorks-around: The required functions getrlimit() and getrlimit() are missing.
//                 But we have the similar functions getprlimit() and setprlimit(),
//                 which may serve the purpose.
//                 Problem: The vxWorks-documentation regarding these functions
//                 doesn't deserve its name! It isn't documented what the first two
//                 parameters idtype and id mean, so we must fall back to an educated
//                 guess - null, argh... :-/

// TODO: getprlimit() and setprlimit() do exist for RTPs only, for whatever reason.
//       Thus for DKMs there would have to be another implementation.
#if defined ( __RTP__) &&  (_WRS_VXWORKS_MAJOR < 7)
  inline int getrlimit(int resource, struct rlimit *rlp){
    return getprlimit(0, 0, resource, rlp);
  }

  inline int setrlimit(int resource, const struct rlimit *rlp){
    return setprlimit(0, 0, resource, const_cast<struct rlimit*>(rlp));
  }
#endif

// vxWorks has ftruncate() only, so we do simulate truncate():
inline int truncate(const char *p, off_t l){
  int fd = open(p, O_WRONLY);
  if (fd == -1){
    errno = EACCES;
    return -1;
  }
  if (ftruncate(fd, l) == -1){
    close(fd);
    errno = EACCES;
    return -1;
  }
  return close(fd);
}

#ifdef __GNUC__
#  define ___unused __attribute__((unused))
#else
#  define ___unused
#endif

// Fake symlink handling by dummy functions:
inline int symlink(const char* path1 ___unused, const char* path2 ___unused){
  // vxWorks has no symlinks -> always return an error!
  errno = EACCES;
  return -1;
}

inline ssize_t readlink(const char* path1 ___unused, char* path2 ___unused, size_t size ___unused){
  // vxWorks has no symlinks -> always return an error!
  errno = EACCES;
  return -1;
}

#if (_WRS_VXWORKS_MAJOR < 7)

inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
  struct timespec ts;
  clock_gettime(CLOCK_MONOTONIC, &ts);
  tv->tv_sec  = ts.tv_sec;
  tv->tv_usec = ts.tv_nsec / 1000;
  return 0;
}
#endif

#ifdef __cplusplus
} // extern "C"
#endif

/* 
 * moved to os/utils/unix/freind_h/times.h in VxWorks 7
 * to avoid conflict with MPL operator times
 */
#if (_WRS_VXWORKS_MAJOR < 7) 
#  ifdef __cplusplus

// vxWorks provides neither struct tms nor function times()!
// We implement an empty dummy-function, simply setting the user
// and system time to the half of thew actual system ticks-value
// and the child user and system time to 0.
// Rather ugly but at least it suppresses compiler errors...
// Unfortunately, this of course *does* have an severe impact on
// dependant libraries, actually this is chrono only! Here it will
// not be possible to correctly use user and system times! But
// as vxWorks is lacking the ability to calculate user and system
// process times there seems to be no other possible solution.
struct tms{
  clock_t tms_utime;  // User CPU time
  clock_t tms_stime;  // System CPU time
  clock_t tms_cutime; // User CPU time of terminated child processes
  clock_t tms_cstime; // System CPU time of terminated child processes
};


 inline clock_t times(struct tms *t){
  struct timespec ts;
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
  clock_t ticks(static_cast<clock_t>(static_cast<double>(ts.tv_sec)  * CLOCKS_PER_SEC +
                                     static_cast<double>(ts.tv_nsec) * CLOCKS_PER_SEC / 1000000.0));
  t->tms_utime  = ticks/2U;
  t->tms_stime  = ticks/2U;
  t->tms_cutime = 0; // vxWorks is lacking the concept of a child process!
  t->tms_cstime = 0; // -> Set the wait times for childs to 0
  return ticks;
}


namespace std {
    using ::times;
}
#  endif // __cplusplus
#endif // _WRS_VXWORKS_MAJOR < 7


#ifdef __cplusplus
extern "C" void   bzero     (void *, size_t);    // FD_ZERO uses bzero() but doesn't include strings.h

// Put the selfmade functions into the std-namespace, just in case
namespace std {
#  ifdef __RTP__
    using ::getrlimit;
    using ::setrlimit;
#  endif
  using ::truncate;
  using ::symlink;
  using ::readlink;
#  if (_WRS_VXWORKS_MAJOR < 7)  
    using ::gettimeofday;
#  endif  
}
#endif // __cplusplus

// Some more macro-magic:
// vxWorks-around: Some functions are not present or broken in vxWorks
//                 but may be patched to life via helper macros...

// Include signal.h which might contain a typo to be corrected here
#include <signal.h>

#if (_WRS_VXWORKS_MAJOR < 7)
#  define getpagesize()    sysconf(_SC_PAGESIZE)         // getpagesize is deprecated anyway!
inline int lstat(p, b) { return stat(p, b); }  // lstat() == stat(), as vxWorks has no symlinks!
#endif

#ifndef S_ISSOCK
#  define S_ISSOCK(mode) ((mode & S_IFMT) == S_IFSOCK) // Is file a socket?
#endif
#ifndef FPE_FLTINV
#  define FPE_FLTINV     (FPE_FLTSUB+1)                // vxWorks has no FPE_FLTINV, so define one as a dummy
#endif
#if !defined(BUS_ADRALN) && defined(BUS_ADRALNR)
#  define BUS_ADRALN     BUS_ADRALNR                   // Correct a supposed typo in vxWorks' <signal.h>
#endif
typedef int              locale_t;                     // locale_t is a POSIX-extension, currently not present in vxWorks!

// #include boilerplate code:
#include <boost/config/detail/posix_features.hpp>

// vxWorks lies about XSI conformance, there is no nl_types.h:
#undef BOOST_HAS_NL_TYPES_H

// vxWorks 7 adds C++11 support 
// however it is optional, and does not match exactly the support determined
// by examining the Dinkum STL version and GCC version (or ICC and DCC) 
#if !( defined( _WRS_CONFIG_LANG_LIB_CPLUS_CPLUS_USER_2011) || defined(_WRS_CONFIG_LIBCPLUS_STD))
#  define BOOST_NO_CXX11_ADDRESSOF      // C11 addressof operator on memory location
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_NUMERIC_LIMITS  // max_digits10 in test/../print_helper.hpp
#  define BOOST_NO_CXX11_SMART_PTR 
#  define BOOST_NO_CXX11_STD_ALIGN


#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST  //serialization/test/test_list.cpp
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL 
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM      //math/../test_data.hpp
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TYPEINDEX 
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TUPLE 
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET 
#else
#  ifndef  BOOST_SYSTEM_NO_DEPRECATED
#    define BOOST_SYSTEM_NO_DEPRECATED  // workaround link error in spirit
#  endif
#endif


// NONE is used in enums in lamda and other libraries
#undef NONE
// restrict is an iostreams class
#undef restrict
// affects some typeof tests
#undef V7

// use fake poll() from Unix layer in ASIO to get full functionality 
// most libraries will use select() but this define allows 'iostream' functionality
// which is based on poll() only
#if (_WRS_VXWORKS_MAJOR > 6)
#  ifndef BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR
#    define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR
#  endif
#else 
#  define BOOST_ASIO_DISABLE_SERIAL_PORT
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/wasm.hpp
================================================
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  WASM specific config options:

#define BOOST_PLATFORM "Wasm"

#ifdef __has_include
#if __has_include(<unistd.h>)
#  define BOOST_HAS_UNISTD_H
#endif
#endif

// boilerplate code:
#include <boost/config/detail/posix_features.hpp>
//
// fenv lacks the C++11 macros:
//
#define BOOST_NO_FENV_H


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/win32.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Bill Kempf 2001. 
//  (C) Copyright Aleksey Gurtovoy 2003. 
//  (C) Copyright Rene Rivera 2005.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Win32 specific config options:

#define BOOST_PLATFORM "Win32"

//  Get the information about the MinGW runtime, i.e. __MINGW32_*VERSION.
#if defined(__MINGW32__)
#  include <_mingw.h>
#endif

#if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF)
#  define BOOST_NO_SWPRINTF
#endif

//  Default defines for BOOST_SYMBOL_EXPORT and BOOST_SYMBOL_IMPORT
//  If a compiler doesn't support __declspec(dllexport)/__declspec(dllimport),
//  its boost/config/compiler/ file must define BOOST_SYMBOL_EXPORT and
//  BOOST_SYMBOL_IMPORT
#ifndef BOOST_SYMBOL_EXPORT
#  define BOOST_HAS_DECLSPEC
#  define BOOST_SYMBOL_EXPORT __declspec(dllexport)
#  define BOOST_SYMBOL_IMPORT __declspec(dllimport)
#endif

#if defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 2) || ((__MINGW32_MAJOR_VERSION == 2) && (__MINGW32_MINOR_VERSION >= 0)))
#  define BOOST_HAS_STDINT_H
#  ifndef __STDC_LIMIT_MACROS
#     define __STDC_LIMIT_MACROS
#  endif
#  define BOOST_HAS_DIRENT_H
#  define BOOST_HAS_UNISTD_H
#endif

#if defined(__MINGW32__) && (__GNUC__ >= 4)
// Mingw has these functions but there are persistent problems
// with calls to these crashing, so disable for now:
//#  define BOOST_HAS_EXPM1
//#  define BOOST_HAS_LOG1P
#  define BOOST_HAS_GETTIMEOFDAY
#endif
//
// Win32 will normally be using native Win32 threads,
// but there is a pthread library avaliable as an option,
// we used to disable this when BOOST_DISABLE_WIN32 was 
// defined but no longer - this should allow some
// files to be compiled in strict mode - while maintaining
// a consistent setting of BOOST_HAS_THREADS across
// all translation units (needed for shared_ptr etc).
//

#ifndef BOOST_HAS_PTHREADS
#  define BOOST_HAS_WINTHREADS
#endif

//
// WinCE configuration:
//
#if defined(_WIN32_WCE) || defined(UNDER_CE)
#  define BOOST_NO_ANSI_APIS
// Windows CE does not have a conforming signature for swprintf
#  define BOOST_NO_SWPRINTF
#else
#  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
#  define BOOST_HAS_THREADEX
#  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
#endif

//
// Windows Runtime
//
#if defined(WINAPI_FAMILY) && \
  (WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
#  define BOOST_NO_ANSI_APIS
#endif

#ifndef BOOST_DISABLE_WIN32
// WEK: Added
#define BOOST_HAS_FTIME
#define BOOST_WINDOWS 1

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/platform/zos.hpp
================================================
//  Copyright (c) 2017 Dynatrace
//
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt

//  See http://www.boost.org for most recent version.

//  Platform setup for IBM z/OS.

#define BOOST_PLATFORM "IBM z/OS"

#include <features.h> // For __UU, __C99, __TR1, ...

#if defined(__UU)
#  define BOOST_HAS_GETTIMEOFDAY
#endif

#if defined(_OPEN_THREADS) || defined(__SUSV3_THR)
#  define BOOST_HAS_PTHREADS
#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#  define BOOST_HAS_THREADS
#endif

#if defined(__SUSV3) || defined(__SUSV3_THR)
#  define BOOST_HAS_SCHED_YIELD
#endif

#define BOOST_HAS_SIGACTION
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_NL_TYPES_H


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/pragma_message.hpp
================================================
#ifndef BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED
#define BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED

//  Copyright 2017 Peter Dimov.
//
//  Distributed under the Boost Software License, Version 1.0.
//
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt
//
//  BOOST_PRAGMA_MESSAGE("message")
//
//  Expands to the equivalent of #pragma message("message")
//
//  Note that this header is C compatible.

#include <boost/config/helper_macros.hpp>

#if defined(BOOST_DISABLE_PRAGMA_MESSAGE)
# define BOOST_PRAGMA_MESSAGE(x)
#elif defined(__INTEL_COMPILER)
# define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x))
#elif defined(__GNUC__)
# define BOOST_PRAGMA_MESSAGE(x) _Pragma(BOOST_STRINGIZE(message(x)))
#elif defined(_MSC_VER)
# define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x))
#else
# define BOOST_PRAGMA_MESSAGE(x)
#endif

#endif // BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/requires_threads.hpp
================================================
//  (C) Copyright John Maddock 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


#ifndef BOOST_CONFIG_REQUIRES_THREADS_HPP
#define BOOST_CONFIG_REQUIRES_THREADS_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif

#if defined(BOOST_DISABLE_THREADS)

//
// special case to handle versions of gcc which don't currently support threads:
//
#if defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC_MINOR__ <= 3) || !defined(BOOST_STRICT_CONFIG))
//
// this is checked up to gcc 3.3:
//
#if defined(__sgi) || defined(__hpux)
#  error "Multi-threaded programs are not supported by gcc on HPUX or Irix (last checked with gcc 3.3)"
#endif

#endif

#  error "Threading support unavaliable: it has been explicitly disabled with BOOST_DISABLE_THREADS"

#elif !defined(BOOST_HAS_THREADS)

# if defined __COMO__
//  Comeau C++
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_MT (Windows) or -D_REENTRANT (Unix)"

#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
//  Intel
#ifdef _WIN32
#  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"
#else
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -openmp"
#endif

# elif defined __GNUC__
//  GNU C++:
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)"

#elif defined __sgi
//  SGI MIPSpro C++
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_SGI_MP_SOURCE"

#elif defined __DECCXX
//  Compaq Tru64 Unix cxx
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread"

#elif defined BOOST_BORLANDC
//  Borland
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM"

#elif defined  __MWERKS__
//  Metrowerks CodeWarrior
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: either -runtime sm, -runtime smd, -runtime dm, or -runtime dmd"

#elif defined  __SUNPRO_CC
//  Sun Workshop Compiler C++
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"

#elif defined __HP_aCC
//  HP aCC
#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"

#elif defined(__IBMCPP__)
//  IBM Visual Age
#   error "Compiler threading support is not turned on. Please compile the code with the xlC_r compiler"

#elif defined _MSC_VER
//  Microsoft Visual C++
//
//  Must remain the last #elif since some other vendors (Metrowerks, for
//  example) also #define _MSC_VER
#  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"

#else

#  error "Compiler threading support is not turned on.  Please consult your compiler's documentation for the appropriate options to use"

#endif // compilers

#endif // BOOST_HAS_THREADS

#endif // BOOST_CONFIG_REQUIRES_THREADS_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/dinkumware.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003.
//  (C) Copyright Jens Maurer 2001.
//  (C) Copyright Peter Dimov 2001.
//  (C) Copyright David Abrahams 2002.
//  (C) Copyright Guillaume Melquiond 2003.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Dinkumware standard library config:

#if !defined(_YVALS) && !defined(_CPPLIB_VER)
#include <boost/config/no_tr1/utility.hpp>
#if !defined(_YVALS) && !defined(_CPPLIB_VER)
#error This is not the Dinkumware lib!
#endif
#endif


#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
   // full dinkumware 3.06 and above
   // fully conforming provided the compiler supports it:
#  if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(BOOST_BORLANDC) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700))   // can be defined in yvals.h
#     define BOOST_NO_STDC_NAMESPACE
#  endif
#  if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC)
#     define BOOST_NO_STD_ALLOCATOR
#  endif
#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#  if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
      // if this lib version is set up for vc6 then there is no std::use_facet:
#     define BOOST_NO_STD_USE_FACET
#     define BOOST_HAS_TWO_ARG_USE_FACET
      // C lib functions aren't in namespace std either:
#     define BOOST_NO_STDC_NAMESPACE
      // and nor is <exception>
#     define BOOST_NO_EXCEPTION_STD_NAMESPACE
#  endif
// There's no numeric_limits<long long> support unless _LONGLONG is defined:
#  if !defined(_LONGLONG) && (_CPPLIB_VER <= 310)
#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#  endif
// 3.06 appears to have (non-sgi versions of) <hash_set> & <hash_map>,
// and no <slist> at all
#else
#  define BOOST_MSVC_STD_ITERATOR 1
#  define BOOST_NO_STD_ITERATOR
#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#  define BOOST_NO_STD_ALLOCATOR
#  define BOOST_NO_STDC_NAMESPACE
#  define BOOST_NO_STD_USE_FACET
#  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
#  define BOOST_HAS_MACRO_USE_FACET
#  ifndef _CPPLIB_VER
      // Updated Dinkum library defines this, and provides
      // its own min and max definitions, as does MTA version.
#     ifndef __MTA__ 
#        define BOOST_NO_STD_MIN_MAX
#     endif
#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#  endif
#endif

//
// std extension namespace is stdext for vc7.1 and later, 
// the same applies to other compilers that sit on top
// of vc7.1 (Intel and Comeau):
//
#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(BOOST_BORLANDC)
#  define BOOST_STD_EXTENSION_NAMESPACE stdext
#endif


#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(BOOST_BORLANDC)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
   // if we're using a dinkum lib that's
   // been configured for VC6/7 then there is
   // no iterator traits (true even for icl)
#  define BOOST_NO_STD_ITERATOR_TRAITS
#endif

#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310)
// Intel C++ chokes over any non-trivial use of <locale>
// this may be an overly restrictive define, but regex fails without it:
#  define BOOST_NO_STD_LOCALE
#endif

#if ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER))) && (_MSC_VER < 1800)
// Fix for VC++ 8.0 on up ( I do not have a previous version to test )
// or clang-cl. If exceptions are off you must manually include the 
// <exception> header before including the <typeinfo> header. Admittedly 
// trying to use Boost libraries or the standard C++ libraries without 
// exception support is not suggested but currently clang-cl ( v 3.4 ) 
// does not support exceptions and must be compiled with exceptions off.
#if !_HAS_EXCEPTIONS
#include <exception>
#endif
#include <typeinfo>
#if !_HAS_EXCEPTIONS
#  define BOOST_NO_STD_TYPEINFO
#endif  
#endif
#if defined(__ghs__) && !_HAS_NAMESPACE
#  define BOOST_NO_STD_TYPEINFO
#endif

//  C++0x headers implemented in 520 (as shipped by Microsoft)
//
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 520
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_SMART_PTR
#endif

#if ((!defined(_HAS_TR1_IMPORTS) || (_HAS_TR1_IMPORTS+0 == 0)) && !defined(BOOST_NO_CXX11_HDR_TUPLE)) \
  && (!defined(_CPPLIB_VER) || _CPPLIB_VER < 610)
#  define BOOST_NO_CXX11_HDR_TUPLE
#endif

//  C++0x headers implemented in 540 (as shipped by Microsoft)
//
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 540
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_HDR_EXCEPTION
#endif

//  C++0x headers implemented in 610 (as shipped by Microsoft)
//
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 610
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_ALLOCATOR
// 540 has std::align but it is not a conforming implementation
#  define BOOST_NO_CXX11_STD_ALIGN
#endif

// Before 650 std::pointer_traits has a broken rebind template
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 650
#  define BOOST_NO_CXX11_POINTER_TRAITS
#elif defined(BOOST_MSVC) && BOOST_MSVC < 1910
#  define BOOST_NO_CXX11_POINTER_TRAITS
#endif

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif (__cplusplus < 201402) && !defined(_MSC_VER)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#elif !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
#  define BOOST_NO_CXX14_STD_EXCHANGE
#endif

// C++17 features
#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) \
 || ((!defined(BOOST_MSVC) || (BOOST_MSVC < 1910))) && (!defined(__clang__) || !defined(_MSC_VER) || (_MSC_VER < 1929))\
 || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0)
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_ITERATOR_TRAITS
#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#  define BOOST_NO_CXX17_HDR_OPTIONAL
#  define BOOST_NO_CXX17_HDR_VARIANT
#  define BOOST_NO_CXX17_HDR_ANY
#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
#  define BOOST_NO_CXX17_HDR_CHARCONV
#  define BOOST_NO_CXX17_HDR_EXECUTION
#  define BOOST_NO_CXX17_HDR_FILESYSTEM
#endif
#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0) || !defined(_MSVC_STL_UPDATE) || (_MSVC_STL_UPDATE < 201709)
#  define BOOST_NO_CXX17_STD_INVOKE
#endif

// C++20 features which aren't configured in suffix.hpp correctly:
#if !defined(_MSVC_STL_UPDATE) || (_MSVC_STL_UPDATE < 202008L) || !defined(_HAS_CXX20) || (_HAS_CXX20 == 0)
#  define BOOST_NO_CXX20_HDR_CONCEPTS
#endif

#if !(!defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1912) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0))
// Deprecated std::iterator:
#  define BOOST_NO_STD_ITERATOR
#endif

#if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400)
// Intel's compiler can't handle this header yet:
#  define BOOST_NO_CXX11_HDR_ATOMIC
#endif


//  520..610 have std::addressof, but it doesn't support functions
//
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 650
#  define BOOST_NO_CXX11_ADDRESSOF
#endif

// Bug specific to VC14, 
// See https://connect.microsoft.com/VisualStudio/feedback/details/1348277/link-error-when-using-std-codecvt-utf8-utf16-char16-t
// and discussion here: http://blogs.msdn.com/b/vcblog/archive/2014/11/12/visual-studio-2015-preview-now-available.aspx?PageIndex=2
#if defined(_CPPLIB_VER) && (_CPPLIB_VER == 650) && (!defined(_MSVC_STL_VERSION) || (_MSVC_STL_VERSION < 142))
#  define BOOST_NO_CXX11_HDR_CODECVT
#endif

#if (_MSVC_LANG > 201700) && !defined(BOOST_NO_CXX11_HDR_CODECVT)
//
// <codecvt> is deprected as of C++17, and by default MSVC emits hard errors
// if you try to use it, so mark it as unavailable:
//
#  define BOOST_NO_CXX11_HDR_CODECVT
#endif

#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 650)
// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr and std::random_shuffle are not available.
// See https://www.visualstudio.com/en-us/news/vs2015-vs.aspx#C++
// and http://blogs.msdn.com/b/vcblog/archive/2015/06/19/c-11-14-17-features-in-vs-2015-rtm.aspx
#  if defined(_HAS_AUTO_PTR_ETC) && (_HAS_AUTO_PTR_ETC == 0)
#    define BOOST_NO_AUTO_PTR
#    define BOOST_NO_CXX98_RANDOM_SHUFFLE
#    define BOOST_NO_CXX98_FUNCTION_BASE
#    define BOOST_NO_CXX98_BINDERS
#  endif
#endif
//
// Things deprecated in C++20:
//
#if defined(_HAS_CXX20)
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#endif


//
// Things not supported by the CLR:
#ifdef _M_CEE
#ifndef BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_MUTEX
#endif
#ifndef BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_HDR_ATOMIC
#endif
#ifndef BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_FUTURE
#endif
#ifndef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#endif
#ifndef BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_THREAD
#endif
#ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#ifndef BOOST_NO_CXX14_STD_EXCHANGE
#  define BOOST_NO_CXX14_STD_EXCHANGE
#endif
#ifndef BOOST_NO_FENV_H
#  define BOOST_NO_FENV_H
#endif
#endif

#ifdef _CPPLIB_VER
#  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
#else
#  define BOOST_DINKUMWARE_STDLIB 1
#endif

#ifdef _CPPLIB_VER
#  define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER)
#else
#  define BOOST_STDLIB "Dinkumware standard library version 1.x"
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/libcomo.hpp
================================================
//  (C) Copyright John Maddock 2002 - 2003. 
//  (C) Copyright Jens Maurer 2002 - 2003. 
//  (C) Copyright Beman Dawes 2002 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Comeau STL:

#if !defined(__LIBCOMO__)
#  include <boost/config/no_tr1/utility.hpp>
#  if !defined(__LIBCOMO__)
#      error "This is not the Comeau STL!"
#  endif
#endif

//
// std::streambuf<wchar_t> is non-standard
// NOTE: versions of libcomo prior to beta28 have octal version numbering,
// e.g. version 25 is 21 (dec)
#if __LIBCOMO_VERSION__ <= 22
#  define BOOST_NO_STD_WSTREAMBUF
#endif

#if (__LIBCOMO_VERSION__ <= 31) && defined(_WIN32)
#define BOOST_NO_SWPRINTF
#endif

#if __LIBCOMO_VERSION__ >= 31
#  define BOOST_HAS_HASH
#  define BOOST_HAS_SLIST
#endif

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_EXCEPTION
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

//
// Intrinsic type_traits support.
// The SGI STL has it's own __type_traits class, which
// has intrinsic compiler support with SGI's compilers.
// Whatever map SGI style type traits to boost equivalents:
//
#define BOOST_HAS_SGI_TYPE_TRAITS

#define BOOST_STDLIB "Comeau standard library " BOOST_STRINGIZE(__LIBCOMO_VERSION__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/libcpp.hpp
================================================
//  (C) Copyright Christopher Jefferson 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  config for libc++
//  Might need more in here later.

#if !defined(_LIBCPP_VERSION)
#  include <ciso646>
#  if !defined(_LIBCPP_VERSION)
#      error "This is not libc++!"
#  endif
#endif

#define BOOST_STDLIB "libc++ version " BOOST_STRINGIZE(_LIBCPP_VERSION)

#define BOOST_HAS_THREADS

#ifdef _LIBCPP_HAS_NO_VARIADICS
#    define BOOST_NO_CXX11_HDR_TUPLE
#endif

// BOOST_NO_CXX11_ALLOCATOR should imply no support for the C++11
// allocator model. The C++11 allocator model requires a conforming
// std::allocator_traits which is only possible with C++11 template
// aliases since members rebind_alloc and rebind_traits require it.
#if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES)
#    define BOOST_NO_CXX11_ALLOCATOR
#    define BOOST_NO_CXX11_POINTER_TRAITS
#endif

#if __cplusplus < 201103
//
// These two appear to be somewhat useable in C++03 mode, there may be others...
//
//#  define BOOST_NO_CXX11_HDR_ARRAY
//#  define BOOST_NO_CXX11_HDR_FORWARD_LIST

#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_EXCEPTION
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_FUTURE
#elif _LIBCPP_VERSION < 3700
//
// These appear to be unusable/incomplete so far:
//
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_FUTURE
#endif


#if _LIBCPP_VERSION < 3700
// libc++ uses a non-standard messages_base
#define BOOST_NO_STD_MESSAGES
#endif

// C++14 features
#if (_LIBCPP_VERSION < 3700) || (__cplusplus <= 201402L)
#  define BOOST_NO_CXX14_STD_EXCHANGE
#endif

// C++17 features
#if (_LIBCPP_VERSION < 4000) || (__cplusplus <= 201402L)
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_HDR_OPTIONAL
#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#  define BOOST_NO_CXX17_HDR_VARIANT
#endif
#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
#  define BOOST_NO_AUTO_PTR
#endif
#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE)
#  define BOOST_NO_CXX98_RANDOM_SHUFFLE
#endif
#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
#  define BOOST_NO_CXX98_BINDERS
#endif

#if defined(__cplusplus) && defined(__has_include)
#if __has_include(<version>)
#include <version>

#if !defined(__cpp_lib_execution) || (__cpp_lib_execution < 201603L)
#  define BOOST_NO_CXX17_HDR_EXECUTION
#endif
#if !defined(__cpp_lib_invoke) || (__cpp_lib_invoke < 201411L)
#define BOOST_NO_CXX17_STD_INVOKE
#endif

#if(_LIBCPP_VERSION < 9000)
// as_writable_bytes is missing.
#  define BOOST_NO_CXX20_HDR_SPAN
#endif

#else
#define BOOST_NO_CXX17_STD_INVOKE      // Invoke support is incomplete (no invoke_result)
#define BOOST_NO_CXX17_HDR_EXECUTION
#endif
#else
#define BOOST_NO_CXX17_STD_INVOKE      // Invoke support is incomplete (no invoke_result)
#define BOOST_NO_CXX17_HDR_EXECUTION
#endif

#if _LIBCPP_VERSION < 10000  // What's the correct version check here?
#define BOOST_NO_CXX17_ITERATOR_TRAITS
#endif

#if (_LIBCPP_VERSION <= 1101) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
// This is a bit of a sledgehammer, because really it's just libc++abi that has no
// support for thread_local, leading to linker errors such as
// "undefined reference to `__cxa_thread_atexit'".  It is fixed in the
// most recent releases of libc++abi though...
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif

#if defined(__linux__) && (_LIBCPP_VERSION < 6000) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
// After libc++-dev is installed on Trusty, clang++-libc++ almost works,
// except uses of `thread_local` fail with undefined reference to
// `__cxa_thread_atexit`.
//
// clang's libc++abi provides an implementation by deferring to the glibc
// implementation, which may or may not be available (it is not on Trusty).
// clang 4's libc++abi will provide an implementation if one is not in glibc
// though, so thread local support should work with clang 4 and above as long
// as libc++abi is linked in.
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus <= 201103
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

#if !defined(BOOST_NO_CXX14_HDR_SHARED_MUTEX) && (_LIBCPP_VERSION < 5000)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

#if _LIBCPP_VERSION >= 15000
//
// Unary function is now deprecated in C++11 and later:
//
#if __cplusplus >= 201103L
#define BOOST_NO_CXX98_FUNCTION_BASE
#endif
#endif

//  --- end ---


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/libstdcpp3.hpp
================================================
//  (C) Copyright John Maddock 2001.
//  (C) Copyright Jens Maurer 2001.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  config for libstdc++ v3
//  not much to go in here:

#define BOOST_GNU_STDLIB 1

#ifdef __GLIBCXX__
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
#else
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCPP__)
#endif

#if !defined(_GLIBCPP_USE_WCHAR_T) && !defined(_GLIBCXX_USE_WCHAR_T)
#  define BOOST_NO_CWCHAR
#  define BOOST_NO_CWCTYPE
#  define BOOST_NO_STD_WSTRING
#  define BOOST_NO_STD_WSTREAMBUF
#endif

#if defined(__osf__) && !defined(_REENTRANT) \
  && ( defined(_GLIBCXX_HAVE_GTHR_DEFAULT) || defined(_GLIBCPP_HAVE_GTHR_DEFAULT) )
// GCC 3 on Tru64 forces the definition of _REENTRANT when any std lib header
// file is included, therefore for consistency we define it here as well.
#  define _REENTRANT
#endif

#ifdef __GLIBCXX__ // gcc 3.4 and greater:
#  if defined(_GLIBCXX_HAVE_GTHR_DEFAULT) \
        || defined(_GLIBCXX__PTHREADS) \
        || defined(_GLIBCXX_HAS_GTHREADS) \
        || defined(_WIN32) \
        || defined(_AIX) \
        || defined(__HAIKU__)
      //
      // If the std lib has thread support turned on, then turn it on in Boost
      // as well.  We do this because some gcc-3.4 std lib headers define _REENTANT
      // while others do not...
      //
#     define BOOST_HAS_THREADS
#  else
#     define BOOST_DISABLE_THREADS
#  endif
#elif defined(__GLIBCPP__) \
        && !defined(_GLIBCPP_HAVE_GTHR_DEFAULT) \
        && !defined(_GLIBCPP__PTHREADS)
   // disable thread support if the std lib was built single threaded:
#  define BOOST_DISABLE_THREADS
#endif

#if (defined(linux) || defined(__linux) || defined(__linux__)) && defined(__arm__) && defined(_GLIBCPP_HAVE_GTHR_DEFAULT)
// linux on arm apparently doesn't define _REENTRANT
// so just turn on threading support whenever the std lib is thread safe:
#  define BOOST_HAS_THREADS
#endif

#if !defined(_GLIBCPP_USE_LONG_LONG) \
    && !defined(_GLIBCXX_USE_LONG_LONG)\
    && defined(BOOST_HAS_LONG_LONG)
// May have been set by compiler/*.hpp, but "long long" without library
// support is useless.
#  undef BOOST_HAS_LONG_LONG
#endif

// Apple doesn't seem to reliably defined a *unix* macro
#if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
#  include <unistd.h>
#endif

#ifndef __VXWORKS__ // VxWorks uses Dinkum, not GNU STL with GCC 
#if defined(__GLIBCXX__) || (defined(__GLIBCPP__) && __GLIBCPP__>=20020514) // GCC >= 3.1.0
#  define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
#  define BOOST_HAS_SLIST
#  define BOOST_HAS_HASH
#  define BOOST_SLIST_HEADER <ext/slist>
# if !defined(__GNUC__) || __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
#   define BOOST_HASH_SET_HEADER <ext/hash_set>
#   define BOOST_HASH_MAP_HEADER <ext/hash_map>
# else
#   define BOOST_HASH_SET_HEADER <backward/hash_set>
#   define BOOST_HASH_MAP_HEADER <backward/hash_map>
# endif
#endif
#endif

#if defined(__has_include)
#if defined(BOOST_HAS_HASH)
#if !__has_include(BOOST_HASH_SET_HEADER) || (__GNUC__ >= 10)
#undef BOOST_HAS_HASH
#undef BOOST_HAS_SET_HEADER
#undef BOOST_HAS_MAP_HEADER
#endif
#if !__has_include(BOOST_SLIST_HEADER)
#undef BOOST_HAS_SLIST
#undef BOOST_HAS_SLIST_HEADER
#endif
#endif
#endif

//
// Decide whether we have C++11 support turned on:
//
#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103)
#  define BOOST_LIBSTDCXX11
#endif

//
//  Decide which version of libstdc++ we have, normally
//  libstdc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
//  __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the libstdc++
//  developers. He also commented:
//
//       "I'm not sure how useful __GLIBCXX__ is for your purposes, for instance in
//       GCC 4.2.4 it is set to 20080519 but in GCC 4.3.0 it is set to 20080305.
//       Although 4.3.0 was released earlier than 4.2.4, it has better C++0x support
//       than any release in the 4.2 series."
//
//  Another resource for understanding libstdc++ features is:
//  http://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#manual.intro.status.standard.200x
//
//  However, using the GCC version number fails when the compiler is clang since this
//  only ever claims to emulate GCC-4.2, see https://svn.boost.org/trac/boost/ticket/7473
//  for a long discussion on this issue.  What we can do though is use clang's __has_include
//  to detect the presence of a C++11 header that was introduced with a specific GCC release.
//  We still have to be careful though as many such headers were buggy and/or incomplete when
//  first introduced, so we only check for headers that were fully featured from day 1, and then
//  use that to infer the underlying GCC version:
//
#ifdef __clang__

#if __has_include(<expected>)
#  define BOOST_LIBSTDCXX_VERSION 120100
#elif __has_include(<source_location>)
#  define BOOST_LIBSTDCXX_VERSION 110100
#elif __has_include(<compare>)
#  define BOOST_LIBSTDCXX_VERSION 100100
#elif __has_include(<memory_resource>)
#  define BOOST_LIBSTDCXX_VERSION 90100
#elif __has_include(<charconv>)
#  define BOOST_LIBSTDCXX_VERSION 80100
#elif __has_include(<variant>)
#  define BOOST_LIBSTDCXX_VERSION 70100
#elif __has_include(<experimental/memory_resource>)
#  define BOOST_LIBSTDCXX_VERSION 60100
#elif __has_include(<experimental/any>)
#  define BOOST_LIBSTDCXX_VERSION 50100
#elif __has_include(<shared_mutex>)
#  define BOOST_LIBSTDCXX_VERSION 40900
#elif __has_include(<ext/cmath>)
#  define BOOST_LIBSTDCXX_VERSION 40800
#elif __has_include(<scoped_allocator>)
#  define BOOST_LIBSTDCXX_VERSION 40700
#elif __has_include(<typeindex>)
#  define BOOST_LIBSTDCXX_VERSION 40600
#elif __has_include(<future>)
#  define BOOST_LIBSTDCXX_VERSION 40500
#elif  __has_include(<ratio>)
#  define BOOST_LIBSTDCXX_VERSION 40400
#elif __has_include(<array>)
#  define BOOST_LIBSTDCXX_VERSION 40300
#endif
//
// If BOOST_HAS_FLOAT128 is set, now that we know the std lib is libstdc++3, check to see if the std lib is
// configured to support this type.  If not disable it:
//
#if defined(BOOST_HAS_FLOAT128) && !defined(_GLIBCXX_USE_FLOAT128)
#  undef BOOST_HAS_FLOAT128
#endif

#if (BOOST_LIBSTDCXX_VERSION >= 100000) && defined(BOOST_HAS_HASH)
//
// hash_set/hash_map deprecated and have terminal bugs:
//
#undef BOOST_HAS_HASH
#undef BOOST_HAS_SET_HEADER
#undef BOOST_HAS_MAP_HEADER
#endif


#if (BOOST_LIBSTDCXX_VERSION >= 100000) && defined(BOOST_HAS_HASH)
//
// hash_set/hash_map deprecated and have terminal bugs:
//
#undef BOOST_HAS_HASH
#undef BOOST_HAS_SET_HEADER
#undef BOOST_HAS_MAP_HEADER
#endif


#if (BOOST_LIBSTDCXX_VERSION < 50100)
// libstdc++ does not define this function as it's deprecated in C++11, but clang still looks for it,
// defining it here is a terrible cludge, but should get things working:
extern "C" char *gets (char *__s);
#endif
//
// clang is unable to parse some GCC headers, add those workarounds here:
//
#if BOOST_LIBSTDCXX_VERSION < 50000
#  define BOOST_NO_CXX11_HDR_REGEX
#endif
//
// GCC 4.7.x has no __cxa_thread_atexit which
// thread_local objects require for cleanup:
//
#if BOOST_LIBSTDCXX_VERSION < 40800
#  define BOOST_NO_CXX11_THREAD_LOCAL
#endif
//
// Early clang versions can handle <chrono>, not exactly sure which versions
// but certainly up to clang-3.8 and gcc-4.6:
//
#if (__clang_major__ < 5)
#  if BOOST_LIBSTDCXX_VERSION < 40800
#     define BOOST_NO_CXX11_HDR_FUTURE
#     define BOOST_NO_CXX11_HDR_MUTEX
#     define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#     define BOOST_NO_CXX11_HDR_CHRONO
#  endif
#endif

//
//  GCC 4.8 and 9 add working versions of <atomic> and <regex> respectively.
//  However, we have no test for these as the headers were present but broken
//  in early GCC versions.
//
#endif

#if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130) && (__cplusplus >= 201103L)
//
// Oracle Solaris compiler uses it's own verison of libstdc++ but doesn't 
// set __GNUC__
//
#if __SUNPRO_CC >= 0x5140
#define BOOST_LIBSTDCXX_VERSION 50100
#else
#define BOOST_LIBSTDCXX_VERSION 40800
#endif
#endif

#if !defined(BOOST_LIBSTDCXX_VERSION)
#  define BOOST_LIBSTDCXX_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif

// std::auto_ptr isn't provided with _GLIBCXX_DEPRECATED=0 (GCC 4.5 and earlier)
// or _GLIBCXX_USE_DEPRECATED=0 (GCC 4.6 and later).
#if defined(BOOST_LIBSTDCXX11)
#  if BOOST_LIBSTDCXX_VERSION < 40600
#     if !_GLIBCXX_DEPRECATED
#        define BOOST_NO_AUTO_PTR
#     endif
#  elif !_GLIBCXX_USE_DEPRECATED
#     define BOOST_NO_AUTO_PTR
#     define BOOST_NO_CXX98_BINDERS
#  endif
#endif

//  C++0x headers in GCC 4.3.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40300) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#endif

//  C++0x headers in GCC 4.4.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40400) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_EXCEPTION
#else
#  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG 
#  define BOOST_HAS_TR1_COMPLEX_OVERLOADS 
#endif

//  C++0x features in GCC 4.5.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40500) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_RANDOM
#endif

//  C++0x features in GCC 4.6.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40600) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX17_ITERATOR_TRAITS
#endif

//  C++0x features in GCC 4.7.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40700) || !defined(BOOST_LIBSTDCXX11)
// Note that although <chrono> existed prior to 4.7, "steady_clock" is spelled "monotonic_clock"
// so 4.7.0 is the first truly conforming one.
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#endif
//  C++0x features in GCC 4.8.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40800) || !defined(BOOST_LIBSTDCXX11)
// Note that although <atomic> existed prior to gcc 4.8 it was largely unimplemented for many types:
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_HDR_THREAD
#endif
//  C++0x features in GCC 4.9.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40900) || !defined(BOOST_LIBSTDCXX11)
// Although <regex> is present and compilable against, the actual implementation is not functional
// even for the simplest patterns such as "\d" or "[0-9]". This is the case at least in gcc up to 4.8, inclusively.
#  define BOOST_NO_CXX11_HDR_REGEX
#endif
#if (BOOST_LIBSTDCXX_VERSION < 40900) || (__cplusplus <= 201103)
#  define BOOST_NO_CXX14_STD_EXCHANGE
#endif

//
//  C++0x features in GCC 5.1 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 50100) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_STD_ALIGN
#endif

//
//  C++17 features in GCC 7.1 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 70100) || (__cplusplus <= 201402L)
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_HDR_OPTIONAL
#  define BOOST_NO_CXX17_HDR_STRING_VIEW
#  define BOOST_NO_CXX17_HDR_VARIANT
#endif

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus <= 201103
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
//
// <execution> has a dependency to Intel's thread building blocks:
// unless these are installed seperately, including <execution> leads
// to inscrutable errors inside libstdc++'s own headers.
//
#if (BOOST_LIBSTDCXX_VERSION < 100100)
#if !__has_include(<tbb/tbb.h>)
#define BOOST_NO_CXX17_HDR_EXECUTION
#endif
#endif
#elif __cplusplus < 201402 || (BOOST_LIBSTDCXX_VERSION < 40900) || !defined(BOOST_LIBSTDCXX11)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

#if BOOST_LIBSTDCXX_VERSION < 100100
//
// The header may be present but is incomplete:
//
#  define BOOST_NO_CXX17_HDR_CHARCONV
#endif

#if BOOST_LIBSTDCXX_VERSION < 110000
//
// Header <bit> may be present but lacks std::bit_cast:
//
#define BOOST_NO_CXX20_HDR_BIT
#endif

#if BOOST_LIBSTDCXX_VERSION >= 120000
//
// Unary function is now deprecated in C++11 and later:
//
#if __cplusplus >= 201103L
#define BOOST_NO_CXX98_FUNCTION_BASE
#endif
#endif

#ifndef __cpp_impl_coroutine
#  define BOOST_NO_CXX20_HDR_COROUTINE
#endif

//
// These next defines are mostly for older clang versions with a newer libstdc++ :
//
#if !defined(__cpp_lib_concepts)
#if !defined(BOOST_NO_CXX20_HDR_COMPARE)
#  define BOOST_NO_CXX20_HDR_COMPARE
#endif
#if !defined(BOOST_NO_CXX20_HDR_CONCEPTS)
#  define BOOST_NO_CXX20_HDR_CONCEPTS
#endif
#if !defined(BOOST_NO_CXX20_HDR_SPAN)
#  define BOOST_NO_CXX20_HDR_SPAN
#endif
#if !defined(BOOST_NO_CXX20_HDR_RANGES)
#  define BOOST_NO_CXX20_HDR_RANGES
#endif
#endif

#if defined(__clang__)
#if (__clang_major__ < 11) && !defined(BOOST_NO_CXX20_HDR_RANGES)
#  define BOOST_NO_CXX20_HDR_RANGES
#endif
#if (__clang_major__ < 10) && (BOOST_LIBSTDCXX_VERSION >= 110000) && !defined(BOOST_NO_CXX11_HDR_CHRONO)
// Old clang can't parse <chrono>:
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#endif
#endif

//
// Headers not present on Solaris with the Oracle compiler:
#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
#define BOOST_NO_CXX11_HDR_FUTURE
#define BOOST_NO_CXX11_HDR_FORWARD_LIST 
#define BOOST_NO_CXX11_HDR_ATOMIC
// shared_ptr is present, but is not convertible to bool
// which causes all kinds of problems especially in Boost.Thread
// but probably elsewhere as well.
#define BOOST_NO_CXX11_SMART_PTR
#endif

#if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1))
   // Headers not always available:
#  ifndef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#     define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  endif
#  ifndef BOOST_NO_CXX11_HDR_MUTEX
#     define BOOST_NO_CXX11_HDR_MUTEX
#  endif
#  ifndef BOOST_NO_CXX11_HDR_THREAD
#     define BOOST_NO_CXX11_HDR_THREAD
#  endif
#  ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX
#     define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#  endif
#endif

#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX) && (__GNUC__ < 6)
// Timed mutexes are not always available:
#  define BOOST_NO_CXX11_HDR_MUTEX
#endif

//  --- end ---


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/modena.hpp
================================================
//  (C) Copyright Jens Maurer 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Modena C++ standard library (comes with KAI C++)

#if !defined(MSIPL_COMPILE_H)
#  include <boost/config/no_tr1/utility.hpp>
#  if !defined(__MSIPL_COMPILE_H)
#      error "This is not the Modena C++ library!"
#  endif
#endif

#ifndef MSIPL_NL_TYPES
#define BOOST_NO_STD_MESSAGES
#endif

#ifndef MSIPL_WCHART
#define BOOST_NO_STD_WSTRING
#endif

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

#define BOOST_STDLIB "Modena C++ standard library"







================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/msl.hpp
================================================
//  (C) Copyright John Maddock 2001. 
//  (C) Copyright Darin Adler 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Metrowerks standard library:

#ifndef __MSL_CPP__
#  include <boost/config/no_tr1/utility.hpp>
#  ifndef __MSL_CPP__
#     error This is not the MSL standard library!
#  endif
#endif

#if __MSL_CPP__ >= 0x6000  // Pro 6
#  define BOOST_HAS_HASH
#  define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
#endif
#define BOOST_HAS_SLIST

#if __MSL_CPP__ < 0x6209
#  define BOOST_NO_STD_MESSAGES
#endif

// check C lib version for <stdint.h>
#include <cstddef>

#if defined(__MSL__) && (__MSL__ >= 0x5000)
#  define BOOST_HAS_STDINT_H
#  if !defined(__PALMOS_TRAPS__)
#    define BOOST_HAS_UNISTD_H
#  endif
   // boilerplate code:
#  include <boost/config/detail/posix_features.hpp>
#endif

#if defined(_MWMT) || _MSL_THREADSAFE
#  define BOOST_HAS_THREADS
#endif

#ifdef _MSL_NO_EXPLICIT_FUNC_TEMPLATE_ARG
#  define BOOST_NO_STD_USE_FACET
#  define BOOST_HAS_TWO_ARG_USE_FACET
#endif

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/roguewave.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Jens Maurer 2001. 
//  (C) Copyright David Abrahams 2003. 
//  (C) Copyright Boris Gubenko 2007. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  Rogue Wave std lib:

#define BOOST_RW_STDLIB 1 

#if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
#  include <boost/config/no_tr1/utility.hpp>
#  if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
#     error This is not the Rogue Wave standard library
#  endif
#endif
//
// figure out a consistent version number:
//
#ifndef _RWSTD_VER
#  define BOOST_RWSTD_VER 0x010000
#elif _RWSTD_VER < 0x010000
#  define BOOST_RWSTD_VER (_RWSTD_VER << 8)
#else
#  define BOOST_RWSTD_VER _RWSTD_VER
#endif

#ifndef _RWSTD_VER
#  define BOOST_STDLIB "Rogue Wave standard library version (Unknown version)"
#elif _RWSTD_VER < 0x04010200
 #  define BOOST_STDLIB "Rogue Wave standard library version " BOOST_STRINGIZE(_RWSTD_VER)
#else
#  ifdef _RWSTD_VER_STR
#    define BOOST_STDLIB "Apache STDCXX standard library version " _RWSTD_VER_STR
#  else
#    define BOOST_STDLIB "Apache STDCXX standard library version " BOOST_STRINGIZE(_RWSTD_VER)
#  endif
#endif

//
// Prior to version 2.2.0 the primary template for std::numeric_limits
// does not have compile time constants, even though specializations of that
// template do:
//
#if BOOST_RWSTD_VER < 0x020200
#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#endif

// Sun CC 5.5 patch 113817-07 adds long long specialization, but does not change the
// library version number (http://sunsolve6.sun.com/search/document.do?assetkey=1-21-113817):
#if BOOST_RWSTD_VER <= 0x020101 && (!defined(__SUNPRO_CC) || (__SUNPRO_CC < 0x550))
#  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
# endif

//
// Borland version of numeric_limits lacks __int64 specialisation:
//
#ifdef BOOST_BORLANDC
#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#endif

//
// No std::iterator if it can't figure out default template args:
//
#if defined(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || defined(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || (BOOST_RWSTD_VER < 0x020000)
#  define BOOST_NO_STD_ITERATOR
#endif

//
// No iterator traits without partial specialization:
//
#if defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) || defined(RWSTD_NO_CLASS_PARTIAL_SPEC)
#  define BOOST_NO_STD_ITERATOR_TRAITS
#endif

//
// Prior to version 2.0, std::auto_ptr was buggy, and there were no
// new-style iostreams, and no conformant std::allocator:
//
#if (BOOST_RWSTD_VER < 0x020000)
#  define BOOST_NO_AUTO_PTR
#  define BOOST_NO_STRINGSTREAM
#  define BOOST_NO_STD_ALLOCATOR
#  define BOOST_NO_STD_LOCALE
#endif

//
// No template iterator constructors without member template support:
//
#if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES)
#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#endif

//
// RW defines _RWSTD_ALLOCATOR if the allocator is conformant and in use
// (the or _HPACC_ part is a hack - the library seems to define _RWSTD_ALLOCATOR
// on HP aCC systems even though the allocator is in fact broken):
//
#if !defined(_RWSTD_ALLOCATOR) || (defined(__HP_aCC) && __HP_aCC <= 33100)
#  define BOOST_NO_STD_ALLOCATOR
#endif

//
// If we have a std::locale, we still may not have std::use_facet:
//
#if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(BOOST_NO_STD_LOCALE)
#  define BOOST_NO_STD_USE_FACET
#  define BOOST_HAS_TWO_ARG_USE_FACET
#endif

//
// There's no std::distance prior to version 2, or without
// partial specialization support:
//
#if (BOOST_RWSTD_VER < 0x020000) || defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
    #define BOOST_NO_STD_DISTANCE
#endif

//
// Some versions of the rogue wave library don't have assignable
// OutputIterators:
//
#if BOOST_RWSTD_VER < 0x020100
#  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
#endif

//
// Disable BOOST_HAS_LONG_LONG when the library has no support for it.
//
#if !defined(_RWSTD_LONG_LONG) && defined(BOOST_HAS_LONG_LONG)
#  undef BOOST_HAS_LONG_LONG
#endif

//
// check that on HP-UX, the proper RW library is used
//
#if defined(__HP_aCC) && !defined(_HP_NAMESPACE_STD)
#  error "Boost requires Standard RW library. Please compile and link with -AA"
#endif

//
// Define macros specific to RW V2.2 on HP-UX
//
#if defined(__HP_aCC) && (BOOST_RWSTD_VER == 0x02020100)
#  ifndef __HP_TC1_MAKE_PAIR
#    define __HP_TC1_MAKE_PAIR
#  endif
#  ifndef _HP_INSTANTIATE_STD2_VL
#    define _HP_INSTANTIATE_STD2_VL
#  endif
#endif

#if _RWSTD_VER < 0x05000000
#  define BOOST_NO_CXX11_HDR_ARRAY
#endif
// type_traits header is incomplete:
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
//
//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/sgi.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2003. 
//  (C) Copyright Darin Adler 2001. 
//  (C) Copyright Jens Maurer 2001 - 2003. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  generic SGI STL:

#if !defined(__STL_CONFIG_H)
#  include <boost/config/no_tr1/utility.hpp>
#  if !defined(__STL_CONFIG_H)
#      error "This is not the SGI STL!"
#  endif
#endif

//
// No std::iterator traits without partial specialisation:
//
#if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION)
#  define BOOST_NO_STD_ITERATOR_TRAITS
#endif

//
// No std::stringstream with gcc < 3
//
#if defined(__GNUC__) && (__GNUC__ < 3) && \
     ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \
     !defined(__STL_USE_NEW_IOSTREAMS) || \
   defined(__APPLE_CC__)
   // Note that we only set this for GNU C++ prior to 2.95 since the
   // latest patches for that release do contain a minimal <sstream>
   // If you are running a 2.95 release prior to 2.95.3 then this will need
   // setting, but there is no way to detect that automatically (other
   // than by running the configure script).
   // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't
   // have <sstream>.
#  define BOOST_NO_STRINGSTREAM
#endif

// Apple doesn't seem to reliably defined a *unix* macro
#if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
#  include <unistd.h>
#endif


//
// Assume no std::locale without own iostreams (this may be an
// incorrect assumption in some cases):
//
#if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS)
#  define BOOST_NO_STD_LOCALE
#endif

//
// Original native SGI streams have non-standard std::messages facet:
//
#if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS)
#  define BOOST_NO_STD_LOCALE
#endif

//
// SGI's new iostreams have missing "const" in messages<>::open
//
#if defined(__sgi) && (_COMPILER_VERSION <= 740) && defined(__STL_USE_NEW_IOSTREAMS)
#  define BOOST_NO_STD_MESSAGES
#endif

//
// No template iterator constructors, or std::allocator
// without member templates:
//
#if !defined(__STL_MEMBER_TEMPLATES)
#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#  define BOOST_NO_STD_ALLOCATOR
#endif

//
// We always have SGI style hash_set, hash_map, and slist:
//
#define BOOST_HAS_HASH
#define BOOST_HAS_SLIST

//
// If this is GNU libstdc++2, then no <limits> and no std::wstring:
//
#if (defined(__GNUC__) && (__GNUC__ < 3))
#  include <string>
#  if defined(__BASTRING__)
#     define BOOST_NO_LIMITS
// Note: <boost/limits.hpp> will provide compile-time constants
#     undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#     define BOOST_NO_STD_WSTRING
#  endif
#endif

//
// There is no standard iterator unless we have namespace support:
//
#if !defined(__STL_USE_NAMESPACES)
#  define BOOST_NO_STD_ITERATOR
#endif

//
// Intrinsic type_traits support.
// The SGI STL has it's own __type_traits class, which
// has intrinsic compiler support with SGI's compilers.
// Whatever map SGI style type traits to boost equivalents:
//
#define BOOST_HAS_SGI_TYPE_TRAITS

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

#define BOOST_STDLIB "SGI standard library"


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/stlport.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002. 
//  (C) Copyright Darin Adler 2001. 
//  (C) Copyright Jens Maurer 2001. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

//  STLPort standard library config:

#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
#  include <cstddef>
#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
#      error "This is not STLPort!"
#  endif
#endif

// Apple doesn't seem to reliably defined a *unix* macro
#if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
#  include <unistd.h>
#endif

//
// __STL_STATIC_CONST_INIT_BUG implies BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
// for versions prior to 4.1(beta)
//
#if (defined(__STL_STATIC_CONST_INIT_BUG) || defined(_STLP_STATIC_CONST_INIT_BUG)) && (__SGI_STL_PORT <= 0x400)
#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#endif

//
// If STLport thinks that there is no partial specialisation, then there is no
// std::iterator traits:
//
#if !(defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined(__STL_CLASS_PARTIAL_SPECIALIZATION))
#  define BOOST_NO_STD_ITERATOR_TRAITS
#endif

//
// No new style iostreams on GCC without STLport's iostreams enabled:
//
#if (defined(__GNUC__) && (__GNUC__ < 3)) && !(defined(__SGI_STL_OWN_IOSTREAMS) || defined(_STLP_OWN_IOSTREAMS))
#  define BOOST_NO_STRINGSTREAM
#endif

//
// No new iostreams implies no std::locale, and no std::stringstream:
//
#if defined(__STL_NO_IOSTREAMS) || defined(__STL_NO_NEW_IOSTREAMS) || defined(_STLP_NO_IOSTREAMS) || defined(_STLP_NO_NEW_IOSTREAMS)
#  define BOOST_NO_STD_LOCALE
#  define BOOST_NO_STRINGSTREAM
#endif

//
// If the streams are not native, and we have a "using ::x" compiler bug
// then the io stream facets are not available in namespace std::
//
#ifdef _STLPORT_VERSION
#  if !(_STLPORT_VERSION >= 0x500) && !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(BOOST_BORLANDC)
#     define BOOST_NO_STD_LOCALE
#  endif
#else
#  if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(BOOST_BORLANDC)
#     define BOOST_NO_STD_LOCALE
#  endif
#endif

#if defined(_STLPORT_VERSION) && (_STLPORT_VERSION >= 0x520)
#  define BOOST_HAS_TR1_UNORDERED_SET
#  define BOOST_HAS_TR1_UNORDERED_MAP
#endif
//
// Without member template support enabled, their are no template
// iterate constructors, and no std::allocator:
//
#if !(defined(__STL_MEMBER_TEMPLATES) || defined(_STLP_MEMBER_TEMPLATES))
#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#  define BOOST_NO_STD_ALLOCATOR
#endif
//
// however we always have at least a partial allocator:
//
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR

#if !defined(_STLP_MEMBER_TEMPLATE_CLASSES) || defined(_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
#  define BOOST_NO_STD_ALLOCATOR
#endif

#if defined(_STLP_NO_MEMBER_TEMPLATE_KEYWORD) && defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
#  define BOOST_NO_STD_ALLOCATOR
#endif

//
// If STLport thinks there is no wchar_t at all, then we have to disable
// the support for the relevant specilazations of std:: templates.
//
#if !defined(_STLP_HAS_WCHAR_T) && !defined(_STLP_WCHAR_T_IS_USHORT)
#  ifndef  BOOST_NO_STD_WSTRING
#     define BOOST_NO_STD_WSTRING
#  endif
#  ifndef  BOOST_NO_STD_WSTREAMBUF
#     define BOOST_NO_STD_WSTREAMBUF
#  endif
#endif

//
// We always have SGI style hash_set, hash_map, and slist:
//
#ifndef _STLP_NO_EXTENSIONS
#define BOOST_HAS_HASH
#define BOOST_HAS_SLIST
#endif

//
// STLport does a good job of importing names into namespace std::,
// but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since our
// workaround does not conflict with STLports:
//
//
// Harold Howe says:
// Borland switched to STLport in BCB6. Defining BOOST_NO_STDC_NAMESPACE with
// BCB6 does cause problems. If we detect C++ Builder, then don't define 
// BOOST_NO_STDC_NAMESPACE
//
#if !defined(BOOST_BORLANDC) && !defined(__DMC__)
//
// If STLport is using it's own namespace, and the real names are in
// the global namespace, then we duplicate STLport's using declarations
// (by defining BOOST_NO_STDC_NAMESPACE), we do this because STLport doesn't
// necessarily import all the names we need into namespace std::
// 
#  if (defined(__STL_IMPORT_VENDOR_CSTD) \
         || defined(__STL_USE_OWN_NAMESPACE) \
         || defined(_STLP_IMPORT_VENDOR_CSTD) \
         || defined(_STLP_USE_OWN_NAMESPACE)) \
      && (defined(__STL_VENDOR_GLOBAL_CSTD) || defined (_STLP_VENDOR_GLOBAL_CSTD))
#     define BOOST_NO_STDC_NAMESPACE
#     define BOOST_NO_EXCEPTION_STD_NAMESPACE
#  endif
#elif defined(BOOST_BORLANDC) && BOOST_BORLANDC < 0x560
// STLport doesn't import std::abs correctly:
#include <stdlib.h>
namespace std { using ::abs; }
// and strcmp/strcpy don't get imported either ('cos they are macros)
#include <string.h>
#ifdef strcpy
#  undef strcpy
#endif
#ifdef strcmp
#  undef strcmp
#endif
#ifdef _STLP_VENDOR_CSTD
namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; }
#endif
#endif

//
// std::use_facet may be non-standard, uses a class instead:
//
#if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) || defined(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
#  define BOOST_NO_STD_USE_FACET
#  define BOOST_HAS_STLP_USE_FACET
#endif

//
// If STLport thinks there are no wide functions, <cwchar> etc. is not working; but
// only if BOOST_NO_STDC_NAMESPACE is not defined (if it is then we do the import 
// into std:: ourselves).
//
#if defined(_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined(BOOST_NO_STDC_NAMESPACE)
#  define BOOST_NO_CWCHAR
#  define BOOST_NO_CWCTYPE
#endif

//
// If STLport for some reason was configured so that it thinks that wchar_t
// is not an intrinsic type, then we have to disable the support for it as
// well (we would be missing required specializations otherwise).
//
#if !defined( _STLP_HAS_WCHAR_T) || defined(_STLP_WCHAR_T_IS_USHORT)
#  undef  BOOST_NO_INTRINSIC_WCHAR_T
#  define BOOST_NO_INTRINSIC_WCHAR_T
#endif

//
// Borland ships a version of STLport with C++ Builder 6 that lacks
// hashtables and the like:
//
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC == 0x560)
#  undef BOOST_HAS_HASH
#endif

//
// gcc-2.95.3/STLPort does not like the using declarations we use to get ADL with std::min/max
//
#if defined(__GNUC__) && (__GNUC__ < 3)
#  include <algorithm> // for std::min and std::max
#  define BOOST_USING_STD_MIN() ((void)0)
#  define BOOST_USING_STD_MAX() ((void)0)
namespace boost { using std::min; using std::max; }
#endif

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

#define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/vacpp.hpp
================================================
//  (C) Copyright John Maddock 2001 - 2002. 
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for most recent version.

#if __IBMCPP__ <= 501
#  define BOOST_NO_STD_ALLOCATOR
#endif

#define BOOST_HAS_MACRO_USE_FACET
#define BOOST_NO_STD_MESSAGES

// Apple doesn't seem to reliably defined a *unix* macro
#if !defined(CYGWIN) && (  defined(__unix__)  \
                        || defined(__unix)    \
                        || defined(unix)      \
                        || defined(__APPLE__) \
                        || defined(__APPLE)   \
                        || defined(APPLE))
#  include <unistd.h>
#endif

//  C++0x headers not yet implemented
//
#  define BOOST_NO_CXX11_HDR_ARRAY
#  define BOOST_NO_CXX11_HDR_CHRONO
#  define BOOST_NO_CXX11_HDR_CODECVT
#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
#  define BOOST_NO_CXX11_HDR_FUTURE
#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#  define BOOST_NO_CXX11_HDR_MUTEX
#  define BOOST_NO_CXX11_HDR_RANDOM
#  define BOOST_NO_CXX11_HDR_RATIO
#  define BOOST_NO_CXX11_HDR_REGEX
#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#  define BOOST_NO_CXX11_HDR_THREAD
#  define BOOST_NO_CXX11_HDR_TUPLE
#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#  define BOOST_NO_CXX11_HDR_TYPEINDEX
#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
#  define BOOST_NO_CXX11_NUMERIC_LIMITS
#  define BOOST_NO_CXX11_ALLOCATOR
#  define BOOST_NO_CXX11_POINTER_TRAITS
#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#  define BOOST_NO_CXX11_SMART_PTR
#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
#  define BOOST_NO_CXX11_HDR_ATOMIC
#  define BOOST_NO_CXX11_STD_ALIGN
#  define BOOST_NO_CXX11_ADDRESSOF
#  define BOOST_NO_CXX11_HDR_EXCEPTION

#if defined(__has_include)
#if !__has_include(<shared_mutex>)
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#elif __cplusplus < 201402
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif
#else
#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
#endif

// C++14 features
#  define BOOST_NO_CXX14_STD_EXCHANGE

// C++17 features
#  define BOOST_NO_CXX17_STD_APPLY
#  define BOOST_NO_CXX17_STD_INVOKE
#  define BOOST_NO_CXX17_ITERATOR_TRAITS

#define BOOST_STDLIB "Visual Age default standard library"


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/stdlib/xlcpp_zos.hpp
================================================
//  Copyright (c) 2017 Dynatrace
//
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt

//  See http://www.boost.org for most recent version.

//  Standard library setup for IBM z/OS XL C/C++ compiler.

// Oldest library version currently supported is 2.1 (V2R1)
#if __TARGET_LIB__ < 0x42010000
#  error "Library version not supported or configured - please reconfigure"
#endif

#if __TARGET_LIB__ > 0x42010000
#  if defined(BOOST_ASSERT_CONFIG)
#     error "Unknown library version - please run the configure tests and report the results"
#  endif
#endif

#define BOOST_STDLIB "IBM z/OS XL C/C++ standard library"

#define BOOST_HAS_MACRO_USE_FACET

#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST

#define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_NO_CXX11_SMART_PTR
#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#define BOOST_NO_CXX11_NUMERIC_LIMITS
#define BOOST_NO_CXX11_ALLOCATOR
#define BOOST_NO_CXX11_POINTER_TRAITS
#define BOOST_NO_CXX11_HDR_FUNCTIONAL
#define BOOST_NO_CXX11_HDR_UNORDERED_SET
#define BOOST_NO_CXX11_HDR_UNORDERED_MAP
#define BOOST_NO_CXX11_HDR_TYPEINDEX
#define BOOST_NO_CXX11_HDR_TUPLE
#define BOOST_NO_CXX11_HDR_THREAD
#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#define BOOST_NO_CXX11_HDR_REGEX
#define BOOST_NO_CXX11_HDR_RATIO
#define BOOST_NO_CXX11_HDR_RANDOM
#define BOOST_NO_CXX11_HDR_MUTEX
#define BOOST_NO_CXX11_HDR_FUTURE
#define BOOST_NO_CXX11_HDR_FORWARD_LIST
#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#define BOOST_NO_CXX11_HDR_CODECVT
#define BOOST_NO_CXX11_HDR_CHRONO
#define BOOST_NO_CXX11_HDR_ATOMIC
#define BOOST_NO_CXX11_HDR_ARRAY
#define BOOST_NO_CXX11_HDR_EXCEPTION
#define BOOST_NO_CXX11_STD_ALIGN

#define BOOST_NO_CXX14_STD_EXCHANGE
#define BOOST_NO_CXX14_HDR_SHARED_MUTEX

#define BOOST_NO_CXX17_STD_INVOKE
#define BOOST_NO_CXX17_STD_APPLY
#define BOOST_NO_CXX17_ITERATOR_TRAITS


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/user.hpp
================================================
//  boost/config/user.hpp  ---------------------------------------------------//

//  (C) Copyright John Maddock 2001. 
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  Do not check in modified versions of this file,
//  This file may be customized by the end user, but not by boost.

//
//  Use this file to define a site and compiler specific
//  configuration policy:
//

// define this to locate a compiler config file:
// #define BOOST_COMPILER_CONFIG <myheader>

// define this to locate a stdlib config file:
// #define BOOST_STDLIB_CONFIG   <myheader>

// define this to locate a platform config file:
// #define BOOST_PLATFORM_CONFIG <myheader>

// define this to disable compiler config,
// use if your compiler config has nothing to set:
// #define BOOST_NO_COMPILER_CONFIG

// define this to disable stdlib config,
// use if your stdlib config has nothing to set:
// #define BOOST_NO_STDLIB_CONFIG

// define this to disable platform config,
// use if your platform config has nothing to set:
// #define BOOST_NO_PLATFORM_CONFIG

// define this to disable all config options,
// excluding the user config.  Use if your
// setup is fully ISO compliant, and has no
// useful extensions, or for autoconf generated
// setups:
// #define BOOST_NO_CONFIG

// define this to make the config "optimistic"
// about unknown compiler versions.  Normally
// unknown compiler versions are assumed to have
// all the defects of the last known version, however
// setting this flag, causes the config to assume
// that unknown compiler versions are fully conformant
// with the standard:
// #define BOOST_STRICT_CONFIG

// define this to cause the config to halt compilation
// with an #error if it encounters anything unknown --
// either an unknown compiler version or an unknown
// compiler/platform/library:
// #define BOOST_ASSERT_CONFIG


// define if you want to disable threading support, even
// when available:
// #define BOOST_DISABLE_THREADS

// define when you want to disable Win32 specific features
// even when available:
// #define BOOST_DISABLE_WIN32

// BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any 
// prefix/suffix headers that normally control things like struct 
// packing and alignment. 
// #define BOOST_DISABLE_ABI_HEADERS

// BOOST_ABI_PREFIX: A prefix header to include in place of whatever
// boost.config would normally select, any replacement should set up 
// struct packing and alignment options as required. 
// #define BOOST_ABI_PREFIX my-header-name

// BOOST_ABI_SUFFIX: A suffix header to include in place of whatever 
// boost.config would normally select, any replacement should undo 
// the effects of the prefix header. 
// #define BOOST_ABI_SUFFIX my-header-name

// BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, 
// to be linked as dll's rather than static libraries on Microsoft Windows 
// (this macro is used to turn on __declspec(dllimport) modifiers, so that 
// the compiler knows which symbols to look for in a dll rather than in a 
// static library).  Note that there may be some libraries that can only 
// be linked in one way (statically or dynamically), in these cases this 
// macro has no effect.
// #define BOOST_ALL_DYN_LINK
 
// BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll 
// rather than a static library on Microsoft Windows: replace the WHATEVER 
// part of the macro name with the name of the library that you want to 
// dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or 
// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) 
// modifiers, so that the compiler knows which symbols to look for in a dll 
// rather than in a static library).  
// Note that there may be some libraries that can only 
// be linked in one way (statically or dynamically), 
// in these cases this macro is unsupported.
// #define BOOST_WHATEVER_DYN_LINK
 
// BOOST_ALL_NO_LIB: Tells the config system not to automatically select 
// which libraries to link against.  
// Normally if a compiler supports #pragma lib, then the correct library 
// build variant will be automatically selected and linked against, 
// simply by the act of including one of that library's headers.  
// This macro turns that feature off.
// #define BOOST_ALL_NO_LIB
 
// BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically 
// select which library to link against for library "whatever", 
// replace WHATEVER in the macro name with the name of the library; 
// for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB.  
// Normally if a compiler supports #pragma lib, then the correct library 
// build variant will be automatically selected and linked against, simply 
// by the act of including one of that library's headers.  This macro turns 
// that feature off.
// #define BOOST_WHATEVER_NO_LIB
 
// BOOST_LIB_BUILDID: Set to the same value as the value passed to Boost.Build's
// --buildid command line option.  For example if you built using:
//
// bjam address-model=64 --buildid=amd64
//
// then compile your code with:
//
// -DBOOST_LIB_BUILDID = amd64
//
// to ensure the correct libraries are selected at link time.
// #define BOOST_LIB_BUILDID amd64



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/warning_disable.hpp
================================================
//  Copyright John Maddock 2008
//  Use, modification, and distribution is subject to the Boost Software
//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  This file exists to turn off some overly-pedantic warning emitted
//  by certain compilers.  You should include this header only in:
//
//  * A test case, before any other headers, or,
//  * A library source file before any other headers.
//
//  IT SHOULD NOT BE INCLUDED BY ANY BOOST HEADER.
//
//  YOU SHOULD NOT INCLUDE IT IF YOU CAN REASONABLY FIX THE WARNING.
//
//  The only warnings disabled here are those that are:
//
//  * Quite unreasonably pedantic.
//  * Generally only emitted by a single compiler.
//  * Can't easily be fixed: for example if the vendors own std lib 
//    code emits these warnings!
//
//  Note that THIS HEADER MUST NOT INCLUDE ANY OTHER HEADERS:
//  not even std library ones!  Doing so may turn the warning
//  off too late to be of any use.  For example the VC++ C4996
//  warning can be emitted from <iosfwd> if that header is included
//  before or by this one :-(
//

#ifndef BOOST_CONFIG_WARNING_DISABLE_HPP
#define BOOST_CONFIG_WARNING_DISABLE_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1400) 
   // Error 'function': was declared deprecated
   // http://msdn2.microsoft.com/en-us/library/ttcz0bys(VS.80).aspx
   // This error is emitted when you use some perfectly conforming
   // std lib functions in a perfectly correct way, and also by
   // some of Microsoft's own std lib code !
#  pragma warning(disable:4996)
#endif
#if defined(__INTEL_COMPILER) || defined(__ICL)
   // As above: gives warning when a "deprecated"
   // std library function is encountered.
#  pragma warning(disable:1786)
#endif

#endif // BOOST_CONFIG_WARNING_DISABLE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config/workaround.hpp
================================================
// Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONFIG_WORKAROUND_HPP
#define BOOST_CONFIG_WORKAROUND_HPP

// Compiler/library version workaround macro
//
// Usage:
//
//   #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
//      // workaround for eVC4 and VC6
//      ... // workaround code here
//   #endif
//
// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
// first argument must be undefined or expand to a numeric
// value. The above expands to:
//
//   (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
//
// When used for workarounds that apply to the latest known version
// and all earlier versions of a compiler, the following convention
// should be observed:
//
//   #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
//
// The version number in this case corresponds to the last version in
// which the workaround was known to have been required. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
// the workaround for any version of the compiler. When
// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
// error will be issued if the compiler version exceeds the argument
// to BOOST_TESTED_AT().  This can be used to locate workarounds which
// may be obsoleted by newer versions.

#ifndef BOOST_STRICT_CONFIG

#include <boost/config.hpp>

#ifndef __BORLANDC__
#define __BORLANDC___WORKAROUND_GUARD 1
#else
#define __BORLANDC___WORKAROUND_GUARD 0
#endif
#ifndef __CODEGEARC__
#define __CODEGEARC___WORKAROUND_GUARD 1
#else
#define __CODEGEARC___WORKAROUND_GUARD 0
#endif
#ifndef BOOST_BORLANDC
#define BOOST_BORLANDC_WORKAROUND_GUARD 1
#else
#define BOOST_BORLANDC_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_CODEGEARC
#define BOOST_CODEGEARC_WORKAROUND_GUARD 1
#else
#define BOOST_CODEGEARC_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_EMBTC
#define BOOST_EMBTC_WORKAROUND_GUARD 1
#else
#define BOOST_EMBTC_WORKAROUND_GUARD 0
#endif
#ifndef _MSC_VER
#define _MSC_VER_WORKAROUND_GUARD 1
#else
#define _MSC_VER_WORKAROUND_GUARD 0
#endif
#ifndef _MSC_FULL_VER
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#else
#define _MSC_FULL_VER_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_MSVC
#define BOOST_MSVC_WORKAROUND_GUARD 1
#else
#define BOOST_MSVC_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_MSVC_FULL_VER
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
#else
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
#endif
#ifndef __GNUC__
#define __GNUC___WORKAROUND_GUARD 1
#else
#define __GNUC___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_MINOR__
#define __GNUC_MINOR___WORKAROUND_GUARD 1
#else
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#endif
#ifndef __GNUC_PATCHLEVEL__
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
#else
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#endif
#ifndef BOOST_GCC
#define BOOST_GCC_WORKAROUND_GUARD 1
#define BOOST_GCC_VERSION_WORKAROUND_GUARD 1
#else
#define BOOST_GCC_WORKAROUND_GUARD 0
#define BOOST_GCC_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_XLCPP_ZOS
#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 1
#else
#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 0
#endif
#ifndef __IBMCPP__
#define __IBMCPP___WORKAROUND_GUARD 1
#else
#define __IBMCPP___WORKAROUND_GUARD 0
#endif
#ifndef __SUNPRO_CC
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#else
#define __SUNPRO_CC_WORKAROUND_GUARD 0
#endif
#ifndef __DECCXX_VER
#define __DECCXX_VER_WORKAROUND_GUARD 1
#else
#define __DECCXX_VER_WORKAROUND_GUARD 0
#endif
#ifndef __MWERKS__
#define __MWERKS___WORKAROUND_GUARD 1
#else
#define __MWERKS___WORKAROUND_GUARD 0
#endif
#ifndef __EDG__
#define __EDG___WORKAROUND_GUARD 1
#else
#define __EDG___WORKAROUND_GUARD 0
#endif
#ifndef __EDG_VERSION__
#define __EDG_VERSION___WORKAROUND_GUARD 1
#else
#define __EDG_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef __HP_aCC
#define __HP_aCC_WORKAROUND_GUARD 1
#else
#define __HP_aCC_WORKAROUND_GUARD 0
#endif
#ifndef __hpxstd98
#define __hpxstd98_WORKAROUND_GUARD 1
#else
#define __hpxstd98_WORKAROUND_GUARD 0
#endif
#ifndef _CRAYC
#define _CRAYC_WORKAROUND_GUARD 1
#else
#define _CRAYC_WORKAROUND_GUARD 0
#endif
#ifndef __DMC__
#define __DMC___WORKAROUND_GUARD 1
#else
#define __DMC___WORKAROUND_GUARD 0
#endif
#ifndef MPW_CPLUS
#define MPW_CPLUS_WORKAROUND_GUARD 1
#else
#define MPW_CPLUS_WORKAROUND_GUARD 0
#endif
#ifndef __COMO__
#define __COMO___WORKAROUND_GUARD 1
#else
#define __COMO___WORKAROUND_GUARD 0
#endif
#ifndef __COMO_VERSION__
#define __COMO_VERSION___WORKAROUND_GUARD 1
#else
#define __COMO_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef __INTEL_COMPILER
#define __INTEL_COMPILER_WORKAROUND_GUARD 1
#else
#define __INTEL_COMPILER_WORKAROUND_GUARD 0
#endif
#ifndef __ICL
#define __ICL_WORKAROUND_GUARD 1
#else
#define __ICL_WORKAROUND_GUARD 0
#endif
#ifndef _COMPILER_VERSION
#define _COMPILER_VERSION_WORKAROUND_GUARD 1
#else
#define _COMPILER_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef __clang_major__
#define __clang_major___WORKAROUND_GUARD 1
#else
#define __clang_major___WORKAROUND_GUARD 0
#endif

#ifndef _RWSTD_VER
#define _RWSTD_VER_WORKAROUND_GUARD 1
#else
#define _RWSTD_VER_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_RWSTD_VER
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
#else
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
#endif
#ifndef __GLIBCPP__
#define __GLIBCPP___WORKAROUND_GUARD 1
#else
#define __GLIBCPP___WORKAROUND_GUARD 0
#endif
#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#else
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
#endif
#ifndef __SGI_STL_PORT
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#else
#define __SGI_STL_PORT_WORKAROUND_GUARD 0
#endif
#ifndef _STLPORT_VERSION
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#else
#define _STLPORT_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef __LIBCOMO_VERSION__
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
#else
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
#endif
#ifndef _CPPLIB_VER
#define _CPPLIB_VER_WORKAROUND_GUARD 1
#else
#define _CPPLIB_VER_WORKAROUND_GUARD 0
#endif

#ifndef BOOST_INTEL_CXX_VERSION
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL_WIN
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_DINKUMWARE_STDLIB
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#else
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_INTEL
#define BOOST_INTEL_WORKAROUND_GUARD 1
#else
#define BOOST_INTEL_WORKAROUND_GUARD 0
#endif
#ifndef BOOST_CLANG_VERSION
#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 1
#else
#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 0
#endif

// Always define to zero, if it's used it'll be defined my MPL:
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0

#define BOOST_WORKAROUND(symbol, test)                \
       ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
       (symbol != 0) && (1 % (( (symbol test) ) + 1)))
//                              ^ ^           ^ ^
// The extra level of parenthesis nesting above, along with the
// BOOST_OPEN_PAREN indirection below, is required to satisfy the
// broken preprocessor in MWCW 8.3 and earlier.
//
// The basic mechanism works as follows:
//   (symbol test) + 1        =>   if (symbol test) then 2 else 1
//   1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
//
// The complication with % is for cooperation with BOOST_TESTED_AT().
// When "test" is BOOST_TESTED_AT(x) and
// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
//
//   symbol test              =>   if (symbol <= x) then 1 else -1
//   (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
//   1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
//

#ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
#  define BOOST_OPEN_PAREN (
#  define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
#else
#  define BOOST_TESTED_AT(value) != ((value)-(value))
#endif

#else

#define BOOST_WORKAROUND(symbol, test) 0

#endif

#endif // BOOST_CONFIG_WORKAROUND_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/config.hpp
================================================
//  Boost config.hpp configuration header file  ------------------------------//

//  (C) Copyright John Maddock 2002.
//  Use, modification and distribution are subject to the 
//  Boost Software License, Version 1.0. (See accompanying file 
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for most recent version.

//  Boost config.hpp policy and rationale documentation has been moved to
//  http://www.boost.org/libs/config
//
//  CAUTION: This file is intended to be completely stable -
//           DO NOT MODIFY THIS FILE!
//

#ifndef BOOST_CONFIG_HPP
#define BOOST_CONFIG_HPP

// if we don't have a user config, then use the default location:
#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG)
#  define BOOST_USER_CONFIG <boost/config/user.hpp>
#if 0
// For dependency trackers:
#  include <boost/config/user.hpp>
#endif
#endif
// include it first:
#ifdef BOOST_USER_CONFIG
#  include BOOST_USER_CONFIG
#endif

// if we don't have a compiler config set, try and find one:
#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
#  include <boost/config/detail/select_compiler_config.hpp>
#endif
// if we have a compiler config, include it now:
#ifdef BOOST_COMPILER_CONFIG
#  include BOOST_COMPILER_CONFIG
#endif

// if we don't have a std library config set, try and find one:
#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
#  include <boost/config/detail/select_stdlib_config.hpp>
#endif
// if we have a std library config, include it now:
#ifdef BOOST_STDLIB_CONFIG
#  include BOOST_STDLIB_CONFIG
#endif

// if we don't have a platform config set, try and find one:
#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
#  include <boost/config/detail/select_platform_config.hpp>
#endif
// if we have a platform config, include it now:
#ifdef BOOST_PLATFORM_CONFIG
#  include BOOST_PLATFORM_CONFIG
#endif

// get config suffix code:
#include <boost/config/detail/suffix.hpp>

#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif

#endif  // BOOST_CONFIG_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/cstdint.hpp
================================================
//  boost cstdint.hpp header file  ------------------------------------------//

//  (C) Copyright Beman Dawes 1999.
//  (C) Copyright Jens Mauer 2001
//  (C) Copyright John Maddock 2001
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/integer for documentation.

//  Revision History
//   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
//   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
//   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
//   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
//   23 Sep 00  Added INTXX_C macro support (John Maddock).
//   22 Sep 00  Better 64-bit support (John Maddock)
//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
//    8 Aug 99  Initial version (Beman Dawes)


#ifndef BOOST_CSTDINT_HPP
#define BOOST_CSTDINT_HPP

//
// Since we always define the INT#_C macros as per C++0x,
// define __STDC_CONSTANT_MACROS so that <stdint.h> does the right
// thing if possible, and so that the user knows that the macros
// are actually defined as per C99.
//
#ifndef __STDC_CONSTANT_MACROS
#  define __STDC_CONSTANT_MACROS
#endif

#include <boost/config.hpp>
//
// For the following code we get several warnings along the lines of:
//
// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant
//
// So we declare this a system header to suppress these warnings.
// See also https://github.com/boostorg/config/issues/190
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif

//
// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not
// depending upon what headers happen to have been included first...
// so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG.
// See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990
//
#if defined(BOOST_HAS_STDINT_H)            \
  && (!defined(__GLIBC__)                  \
      || defined(__GLIBC_HAVE_LONG_LONG)   \
      || (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17)))))

// The following #include is an implementation artifact; not part of interface.
# ifdef __hpux
// HP-UX has a vaguely nice <stdint.h> in a non-standard location
#   include <inttypes.h>
#   ifdef __STDC_32_MODE__
      // this is triggered with GCC, because it defines __cplusplus < 199707L
#     define BOOST_NO_INT64_T
#   endif
# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
#   include <inttypes.h>
# else
#   include <stdint.h>

// There is a bug in Cygwin two _C macros
#   if defined(INTMAX_C) && defined(__CYGWIN__)
#     undef INTMAX_C
#     undef UINTMAX_C
#     define INTMAX_C(c) c##LL
#     define UINTMAX_C(c) c##ULL
#   endif

# endif

#if defined(__QNX__) && defined(__EXT_QNX) 

// QNX (Dinkumware stdlib) defines these as non-standard names.
// Reflect to the standard names.

typedef ::intleast8_t int_least8_t;
typedef ::intfast8_t int_fast8_t;
typedef ::uintleast8_t uint_least8_t;
typedef ::uintfast8_t uint_fast8_t;

typedef ::intleast16_t int_least16_t;
typedef ::intfast16_t int_fast16_t;
typedef ::uintleast16_t uint_least16_t;
typedef ::uintfast16_t uint_fast16_t;

typedef ::intleast32_t int_least32_t;
typedef ::intfast32_t int_fast32_t;
typedef ::uintleast32_t uint_least32_t;
typedef ::uintfast32_t uint_fast32_t;

# ifndef BOOST_NO_INT64_T

typedef ::intleast64_t int_least64_t;
typedef ::intfast64_t int_fast64_t;
typedef ::uintleast64_t uint_least64_t;
typedef ::uintfast64_t uint_fast64_t;

# endif

#endif

namespace boost
{

  using ::int8_t;
  using ::int_least8_t;
  using ::int_fast8_t;
  using ::uint8_t;
  using ::uint_least8_t;
  using ::uint_fast8_t;

  using ::int16_t;
  using ::int_least16_t;
  using ::int_fast16_t;
  using ::uint16_t;
  using ::uint_least16_t;
  using ::uint_fast16_t;

  using ::int32_t;
  using ::int_least32_t;
  using ::int_fast32_t;
  using ::uint32_t;
  using ::uint_least32_t;
  using ::uint_fast32_t;

# ifndef BOOST_NO_INT64_T

  using ::int64_t;
  using ::int_least64_t;
  using ::int_fast64_t;
  using ::uint64_t;
  using ::uint_least64_t;
  using ::uint_fast64_t;

# endif

  using ::intmax_t;
  using ::uintmax_t;

} // namespace boost

#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS) || defined(__SOLARIS9__) || defined(__NetBSD__)
// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
# include <inttypes.h>

namespace boost {

  using ::int8_t;
  typedef int8_t int_least8_t;
  typedef int8_t int_fast8_t;
  using ::uint8_t;
  typedef uint8_t uint_least8_t;
  typedef uint8_t uint_fast8_t;

  using ::int16_t;
  typedef int16_t int_least16_t;
  typedef int16_t int_fast16_t;
  using ::uint16_t;
  typedef uint16_t uint_least16_t;
  typedef uint16_t uint_fast16_t;

  using ::int32_t;
  typedef int32_t int_least32_t;
  typedef int32_t int_fast32_t;
  using ::uint32_t;
  typedef uint32_t uint_least32_t;
  typedef uint32_t uint_fast32_t;

# ifndef BOOST_NO_INT64_T

  using ::int64_t;
  typedef int64_t int_least64_t;
  typedef int64_t int_fast64_t;
  using ::uint64_t;
  typedef uint64_t uint_least64_t;
  typedef uint64_t uint_fast64_t;

  typedef int64_t intmax_t;
  typedef uint64_t uintmax_t;

# else

  typedef int32_t intmax_t;
  typedef uint32_t uintmax_t;

# endif

} // namespace boost

#else  // BOOST_HAS_STDINT_H

# include <boost/limits.hpp> // implementation artifact; not part of interface
# include <limits.h>         // needed for limits macros


namespace boost
{

//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
//  platforms.  For other systems, they will have to be hand tailored.
//
//  Because the fast types are assumed to be the same as the undecorated types,
//  it may be possible to hand tailor a more efficient implementation.  Such
//  an optimization may be illusionary; on the Intel x86-family 386 on, for
//  example, byte arithmetic and load/stores are as fast as "int" sized ones.

//  8-bit types  ------------------------------------------------------------//

# if UCHAR_MAX == 0xff
     typedef signed char     int8_t;
     typedef signed char     int_least8_t;
     typedef signed char     int_fast8_t;
     typedef unsigned char   uint8_t;
     typedef unsigned char   uint_least8_t;
     typedef unsigned char   uint_fast8_t;
# else
#    error defaults not correct; you must hand modify boost/cstdint.hpp
# endif

//  16-bit types  -----------------------------------------------------------//

# if USHRT_MAX == 0xffff
#  if defined(__crayx1)
     // The Cray X1 has a 16-bit short, however it is not recommend
     // for use in performance critical code.
     typedef short           int16_t;
     typedef short           int_least16_t;
     typedef int             int_fast16_t;
     typedef unsigned short  uint16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned int    uint_fast16_t;
#  else
     typedef short           int16_t;
     typedef short           int_least16_t;
     typedef short           int_fast16_t;
     typedef unsigned short  uint16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned short  uint_fast16_t;
#  endif
# elif (USHRT_MAX == 0xffffffff) && defined(__MTA__)
      // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified
      // MTA / XMT does support the following non-standard integer types
      typedef __short16           int16_t;
      typedef __short16           int_least16_t;
      typedef __short16           int_fast16_t;
      typedef unsigned __short16  uint16_t;
      typedef unsigned __short16  uint_least16_t;
      typedef unsigned __short16  uint_fast16_t;
# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
     // no 16-bit types on Cray:
     typedef short           int_least16_t;
     typedef short           int_fast16_t;
     typedef unsigned short  uint_least16_t;
     typedef unsigned short  uint_fast16_t;
# else
#    error defaults not correct; you must hand modify boost/cstdint.hpp
# endif

//  32-bit types  -----------------------------------------------------------//

# if UINT_MAX == 0xffffffff
     typedef int             int32_t;
     typedef int             int_least32_t;
     typedef int             int_fast32_t;
     typedef unsigned int    uint32_t;
     typedef unsigned int    uint_least32_t;
     typedef unsigned int    uint_fast32_t;
# elif (USHRT_MAX == 0xffffffff)
     typedef short             int32_t;
     typedef short             int_least32_t;
     typedef short             int_fast32_t;
     typedef unsigned short    uint32_t;
     typedef unsigned short    uint_least32_t;
     typedef unsigned short    uint_fast32_t;
# elif ULONG_MAX == 0xffffffff
     typedef long            int32_t;
     typedef long            int_least32_t;
     typedef long            int_fast32_t;
     typedef unsigned long   uint32_t;
     typedef unsigned long   uint_least32_t;
     typedef unsigned long   uint_fast32_t;
# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__)
      // Integers are 64 bits on the MTA / XMT
      typedef __int32           int32_t;
      typedef __int32           int_least32_t;
      typedef __int32           int_fast32_t;
      typedef unsigned __int32  uint32_t;
      typedef unsigned __int32  uint_least32_t;
      typedef unsigned __int32  uint_fast32_t;
# else
#    error defaults not correct; you must hand modify boost/cstdint.hpp
# endif

//  64-bit types + intmax_t and uintmax_t  ----------------------------------//

# if defined(BOOST_HAS_LONG_LONG) && \
   !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC) && \
   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
#    if defined(__hpux)
     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
                                                                 // 2**64 - 1
#    else
#       error defaults not correct; you must hand modify boost/cstdint.hpp
#    endif

     typedef  ::boost::long_long_type            intmax_t;
     typedef  ::boost::ulong_long_type   uintmax_t;
     typedef  ::boost::long_long_type            int64_t;
     typedef  ::boost::long_long_type            int_least64_t;
     typedef  ::boost::long_long_type            int_fast64_t;
     typedef  ::boost::ulong_long_type   uint64_t;
     typedef  ::boost::ulong_long_type   uint_least64_t;
     typedef  ::boost::ulong_long_type   uint_fast64_t;

# elif ULONG_MAX != 0xffffffff

#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
     typedef long                 intmax_t;
     typedef unsigned long        uintmax_t;
     typedef long                 int64_t;
     typedef long                 int_least64_t;
     typedef long                 int_fast64_t;
     typedef unsigned long        uint64_t;
     typedef unsigned long        uint_least64_t;
     typedef unsigned long        uint_fast64_t;
#    else
#       error defaults not correct; you must hand modify boost/cstdint.hpp
#    endif
# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
     __extension__ typedef long long            intmax_t;
     __extension__ typedef unsigned long long   uintmax_t;
     __extension__ typedef long long            int64_t;
     __extension__ typedef long long            int_least64_t;
     __extension__ typedef long long            int_fast64_t;
     __extension__ typedef unsigned long long   uint64_t;
     __extension__ typedef unsigned long long   uint_least64_t;
     __extension__ typedef unsigned long long   uint_fast64_t;
# elif defined(BOOST_HAS_MS_INT64)
     //
     // we have Borland/Intel/Microsoft __int64:
     //
     typedef __int64             intmax_t;
     typedef unsigned __int64    uintmax_t;
     typedef __int64             int64_t;
     typedef __int64             int_least64_t;
     typedef __int64             int_fast64_t;
     typedef unsigned __int64    uint64_t;
     typedef unsigned __int64    uint_least64_t;
     typedef unsigned __int64    uint_fast64_t;
# else // assume no 64-bit integers
#  define BOOST_NO_INT64_T
     typedef int32_t              intmax_t;
     typedef uint32_t             uintmax_t;
# endif

} // namespace boost


#endif // BOOST_HAS_STDINT_H

// intptr_t/uintptr_t are defined separately because they are optional and not universally available
#if defined(BOOST_WINDOWS) && !defined(_WIN32_WCE) && !defined(BOOST_HAS_STDINT_H)
// Older MSVC don't have stdint.h and have intptr_t/uintptr_t defined in stddef.h
#include <stddef.h>
#endif

#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \
    || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
    || defined(__CYGWIN__) || defined(__VXWORKS__) \
    || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || (defined(sun) && !defined(BOOST_HAS_STDINT_H)) || defined(INTPTR_MAX)

namespace boost {
    using ::intptr_t;
    using ::uintptr_t;
}
#define BOOST_HAS_INTPTR_T

// Clang pretends to be GCC, so it'll match this condition
#elif defined(__GNUC__) && defined(__INTPTR_TYPE__) && defined(__UINTPTR_TYPE__)

namespace boost {
    typedef __INTPTR_TYPE__ intptr_t;
    typedef __UINTPTR_TYPE__ uintptr_t;
}
#define BOOST_HAS_INTPTR_T

#endif

#endif // BOOST_CSTDINT_HPP


/****************************************************

Macro definition section:

Added 23rd September 2000 (John Maddock).
Modified 11th September 2001 to be excluded when
BOOST_HAS_STDINT_H is defined (John Maddock).
Modified 11th Dec 2009 to always define the
INT#_C macros if they're not already defined (John Maddock).

******************************************************/

#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \
   (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C))
//
// Undef the macros as a precaution, since we may get here if <stdint.h> has failed
// to define them all, see https://svn.boost.org/trac/boost/ticket/12786
//
#undef INT8_C
#undef INT16_C
#undef INT32_C
#undef INT64_C
#undef INTMAX_C
#undef UINT8_C
#undef UINT16_C
#undef UINT32_C
#undef UINT64_C
#undef UINTMAX_C

#include <limits.h>
# define BOOST__STDC_CONSTANT_MACROS_DEFINED
# if defined(BOOST_HAS_MS_INT64)
//
// Borland/Intel/Microsoft compilers have width specific suffixes:
//
#ifndef INT8_C
#  define INT8_C(value)     value##i8
#endif
#ifndef INT16_C
#  define INT16_C(value)    value##i16
#endif
#ifndef INT32_C
#  define INT32_C(value)    value##i32
#endif
#ifndef INT64_C
#  define INT64_C(value)    value##i64
#endif
#  ifdef BOOST_BORLANDC
    // Borland bug: appending ui8 makes the type a signed char
#   define UINT8_C(value)    static_cast<unsigned char>(value##u)
#  else
#   define UINT8_C(value)    value##ui8
#  endif
#ifndef UINT16_C
#  define UINT16_C(value)   value##ui16
#endif
#ifndef UINT32_C
#  define UINT32_C(value)   value##ui32
#endif
#ifndef UINT64_C
#  define UINT64_C(value)   value##ui64
#endif
#ifndef INTMAX_C
#  define INTMAX_C(value)   value##i64
#  define UINTMAX_C(value)  value##ui64
#endif

# else
//  do it the old fashioned way:

//  8-bit types  ------------------------------------------------------------//

#  if (UCHAR_MAX == 0xff) && !defined(INT8_C)
#   define INT8_C(value) static_cast<boost::int8_t>(value)
#   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
#  endif

//  16-bit types  -----------------------------------------------------------//

#  if (USHRT_MAX == 0xffff) && !defined(INT16_C)
#   define INT16_C(value) static_cast<boost::int16_t>(value)
#   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
#  endif

//  32-bit types  -----------------------------------------------------------//
#ifndef INT32_C
#  if (UINT_MAX == 0xffffffff)
#   define INT32_C(value) value
#   define UINT32_C(value) value##u
#  elif ULONG_MAX == 0xffffffff
#   define INT32_C(value) value##L
#   define UINT32_C(value) value##uL
#  endif
#endif

//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
#ifndef INT64_C
#  if defined(BOOST_HAS_LONG_LONG) && \
    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_ULLONG_MAX) || defined(_LLONG_MAX))

#    if defined(__hpux)
        // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
#       define INT64_C(value) value##LL
#       define UINT64_C(value) value##uLL
#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) ||  \
        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) ||  \
        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \
        (defined(_ULLONG_MAX) && _ULLONG_MAX == 18446744073709551615ULL) || \
        (defined(_LLONG_MAX) && _LLONG_MAX == 9223372036854775807LL)

#       define INT64_C(value) value##LL
#       define UINT64_C(value) value##uLL
#    else
#       error defaults not correct; you must hand modify boost/cstdint.hpp
#    endif
#  elif ULONG_MAX != 0xffffffff

#    if ULONG_MAX == 18446744073709551615U // 2**64 - 1
#       define INT64_C(value) value##L
#       define UINT64_C(value) value##uL
#    else
#       error defaults not correct; you must hand modify boost/cstdint.hpp
#    endif
#  elif defined(BOOST_HAS_LONG_LONG)
     // Usual macros not defined, work things out for ourselves:
#    if(~0uLL == 18446744073709551615ULL)
#       define INT64_C(value) value##LL
#       define UINT64_C(value) value##uLL
#    else
#       error defaults not correct; you must hand modify boost/cstdint.hpp
#    endif
#  else
#    error defaults not correct; you must hand modify boost/cstdint.hpp
#  endif

#  ifdef BOOST_NO_INT64_T
#   define INTMAX_C(value) INT32_C(value)
#   define UINTMAX_C(value) UINT32_C(value)
#  else
#   define INTMAX_C(value) INT64_C(value)
#   define UINTMAX_C(value) UINT64_C(value)
#  endif
#endif
# endif // Borland/Microsoft specific width suffixes

#endif // INT#_C macros.






================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/cxx11_char_types.hpp
================================================
//  boost cxx11_char_types.hpp  --------------------------------------------------------//

//  Copyright Beman Dawes 2011

//  Distributed under the Boost Software License, Version 1.0.
//  See http://www.boost.org/LICENSE_1_0.txt

//--------------------------------------------------------------------------------------//
//                                                                                      //
//  The purpose of this header is to emulate the C++11 char16_t and char32_t            //
//  character and string types so that they can be used in both C++11 and C++03         //
//  programs.                                                                           //
//                                                                                      //
//  The emulation names use char16/char32 rather than char16_t/char32_t to avoid use    //
//  of names that are keywords in C++11.                                                //
//                                                                                      //
//  The emulation names are placed in namespace boost, as is usual for Boost C++11      //
//  emulation names such as those in header <boost/cstdint.hpp>.                        //
//                                                                                      //
//  An alternative would would have been to place the C++11 emulation names at global   //
//  scope, and put the C++11 string types in namespace std. That is the approach taken  //
//  by Microsoft Visual Studio 2010, but is controversion with some Boost users and     //
//  developers, and runs counter to usual Boost practice.                               //
//                                                                                      //
//  Thanks to Mathias Gaunard and others for discussions leading to the final form      //
//  of these typedefs.                                                                  //
//                                                                                      //
//   Boost               C++11            C++03                                         //
//   ----------------    --------------   --------------------------------              //
//   boost::char16       char16_t         uint16_t                                      //
//   boost::char32       char32_t         uint32_t                                      //
//   boost::u16string    std::u16string   std::basic_string<boost::char16>              //
//   boost::u32string    std::u32string   std::basic_string<boost::char32>              //
//                                                                                      //
//   Uses the typedefs provided by Microsoft Visual C++ 2010 if present                 //
//                                                                                      //
//   Thanks to Mathias Gaunard and others for discussions leading to the final form     //
//   of these typedefs.                                                                 //
//                                                                                      //
//--------------------------------------------------------------------------------------//

#if !defined(BOOST_CXX11_CHAR_TYPES_HPP)
# define BOOST_CXX11_CHAR_TYPES_HPP

# include <boost/config.hpp>
# include <boost/cstdint.hpp>
# include <string>

namespace boost
{

# if defined(BOOST_NO_CXX11_CHAR16_T) && (!defined(_MSC_VER) || _MSC_VER < 1600)  // 1600 == VC++10
    typedef boost::uint_least16_t             char16;
    typedef std::basic_string<boost::char16>  u16string;
# else
    typedef char16_t                          char16;
    typedef std::u16string                    u16string;
# endif

# if defined(BOOST_NO_CXX11_CHAR32_T) && (!defined(_MSC_VER) || _MSC_VER < 1600)  // 1600 == VC++10
    typedef  boost::uint_least32_t            char32;
    typedef std::basic_string<boost::char32>  u32string;
# else
    typedef char32_t                          char32;
    typedef std::u32string                    u32string;
# endif

}  // namespace boost

#endif  // !defined(BOOST_CXX11_CHAR_TYPES_HPP)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/detail/workaround.hpp
================================================
// Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_WORKAROUND_DWA2002126_HPP
#define BOOST_WORKAROUND_DWA2002126_HPP

#include <boost/config/workaround.hpp>

#endif // BOOST_WORKAROUND_DWA2002126_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/limits.hpp
================================================

//  (C) Copyright John maddock 1999. 
//  (C) David Abrahams 2002.  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// use this header as a workaround for missing <limits>

//  See http://www.boost.org/libs/compatibility/index.html for documentation.

#ifndef BOOST_LIMITS
#define BOOST_LIMITS

#include <boost/config.hpp>

#ifdef BOOST_NO_LIMITS
#  error "There is no std::numeric_limits suppport available."
#else
# include <limits>
#endif

#if (defined(BOOST_HAS_LONG_LONG) && defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)) \
      || (defined(BOOST_HAS_MS_INT64) && defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS))
// Add missing specializations for numeric_limits:
#ifdef BOOST_HAS_MS_INT64
#  define BOOST_LLT __int64
#  define BOOST_ULLT unsigned __int64
#else
#  define BOOST_LLT  ::boost::long_long_type
#  define BOOST_ULLT  ::boost::ulong_long_type
#endif

#include <climits>  // for CHAR_BIT

namespace std
{
  template<>
  class numeric_limits<BOOST_LLT> 
  {
   public:

      BOOST_STATIC_CONSTANT(bool, is_specialized = true);
#ifdef BOOST_HAS_MS_INT64
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8000000000000000i64; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7FFFFFFFFFFFFFFFi64; }
#elif defined(LLONG_MAX)
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MIN; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MAX; }
#elif defined(LONGLONG_MAX)
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MIN; }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MAX; }
#else
      static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL << (sizeof(BOOST_LLT) * CHAR_BIT - 1); }
      static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(min)(); }
#endif
      BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT -1);
      BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT) - 1) * 301L / 1000);
      BOOST_STATIC_CONSTANT(bool, is_signed = true);
      BOOST_STATIC_CONSTANT(bool, is_integer = true);
      BOOST_STATIC_CONSTANT(bool, is_exact = true);
      BOOST_STATIC_CONSTANT(int, radix = 2);
      static BOOST_LLT epsilon() throw() { return 0; };
      static BOOST_LLT round_error() throw() { return 0; };

      BOOST_STATIC_CONSTANT(int, min_exponent = 0);
      BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent10 = 0);

      BOOST_STATIC_CONSTANT(bool, has_infinity = false);
      BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
      static BOOST_LLT infinity() throw() { return 0; };
      static BOOST_LLT quiet_NaN() throw() { return 0; };
      static BOOST_LLT signaling_NaN() throw() { return 0; };
      static BOOST_LLT denorm_min() throw() { return 0; };

      BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
      BOOST_STATIC_CONSTANT(bool, is_bounded = true);
      BOOST_STATIC_CONSTANT(bool, is_modulo = true);

      BOOST_STATIC_CONSTANT(bool, traps = false);
      BOOST_STATIC_CONSTANT(bool, tinyness_before = false);
      BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
      
  };

  template<>
  class numeric_limits<BOOST_ULLT> 
  {
   public:

      BOOST_STATIC_CONSTANT(bool, is_specialized = true);
#ifdef BOOST_HAS_MS_INT64
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0ui64; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0xFFFFFFFFFFFFFFFFui64; }
#elif defined(ULLONG_MAX) && defined(ULLONG_MIN)
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MIN; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MAX; }
#elif defined(ULONGLONG_MAX) && defined(ULONGLONG_MIN)
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MIN; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MAX; }
#else
      static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0uLL; }
      static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0uLL; }
#endif
      BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT);
      BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT)) * 301L / 1000);
      BOOST_STATIC_CONSTANT(bool, is_signed = false);
      BOOST_STATIC_CONSTANT(bool, is_integer = true);
      BOOST_STATIC_CONSTANT(bool, is_exact = true);
      BOOST_STATIC_CONSTANT(int, radix = 2);
      static BOOST_ULLT epsilon() throw() { return 0; };
      static BOOST_ULLT round_error() throw() { return 0; };

      BOOST_STATIC_CONSTANT(int, min_exponent = 0);
      BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent = 0);
      BOOST_STATIC_CONSTANT(int, max_exponent10 = 0);

      BOOST_STATIC_CONSTANT(bool, has_infinity = false);
      BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm = false);
      BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
      static BOOST_ULLT infinity() throw() { return 0; };
      static BOOST_ULLT quiet_NaN() throw() { return 0; };
      static BOOST_ULLT signaling_NaN() throw() { return 0; };
      static BOOST_ULLT denorm_min() throw() { return 0; };

      BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
      BOOST_STATIC_CONSTANT(bool, is_bounded = true);
      BOOST_STATIC_CONSTANT(bool, is_modulo = true);

      BOOST_STATIC_CONSTANT(bool, traps = false);
      BOOST_STATIC_CONSTANT(bool, tinyness_before = false);
      BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
      
  };
}
#endif 

#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/complex128.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_COMPLEX128_HPP
#define BOOST_MP_COMPLEX128_HPP

#include <boost/multiprecision/float128.hpp>
#include <boost/multiprecision/complex_adaptor.hpp>

namespace boost {
namespace multiprecision {

using complex128 = number<complex_adaptor<float128_backend>, et_off>;

template <>
struct component_type<number<complex_adaptor<float128_backend> > >
{
   using type = float128;
};

}
} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/complex_adaptor.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_COMPLEX_ADAPTOR_HPP
#define BOOST_MP_COMPLEX_ADAPTOR_HPP

#include <boost/multiprecision/number.hpp>
#include <cstdint>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <cmath>
#include <algorithm>
#include <complex>

namespace boost {
namespace multiprecision {
namespace backends {

template <class Backend>
struct debug_adaptor;

template <class Backend>
struct logged_adaptor;

template <class Backend>
struct complex_adaptor
{
 protected:
   Backend m_real, m_imag;

 public:
   Backend& real_data()
   {
      return m_real;
   }
   const Backend& real_data() const
   {
      return m_real;
   }
   Backend& imag_data()
   {
      return m_imag;
   }
   const Backend& imag_data() const
   {
      return m_imag;
   }

   using signed_types = typename Backend::signed_types  ;
   using unsigned_types = typename Backend::unsigned_types;
   using float_types = typename Backend::float_types   ;
   using exponent_type = typename Backend::exponent_type ;

   complex_adaptor() {}
   complex_adaptor(const complex_adaptor& o) : m_real(o.real_data()), m_imag(o.imag_data()) {}
   // Rvalue construct:
   complex_adaptor(complex_adaptor&& o) : m_real(std::move(o.real_data())), m_imag(std::move(o.imag_data()))
   {}
   complex_adaptor(const Backend& val)
       : m_real(val)
   {}

   template <class T>
   complex_adaptor(const T& val, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
       : m_real(val) 
   {}

   complex_adaptor(const std::complex<float>& val)
   {
      m_real = (long double)val.real();
      m_imag = (long double)val.imag();
   }
   complex_adaptor(const std::complex<double>& val)
   {
      m_real = (long double)val.real();
      m_imag = (long double)val.imag();
   }
   complex_adaptor(const std::complex<long double>& val)
   {
      m_real = val.real();
      m_imag = val.imag();
   }
   template <class T, class U>
   complex_adaptor(const T& a, const U& b, typename std::enable_if<std::is_constructible<Backend, T const&>::value&& std::is_constructible<Backend, U const&>::value>::type const* = nullptr)
      : m_real(a), m_imag(b) {}
   template <class T, class U>
   complex_adaptor(T&& a, const U& b, typename std::enable_if<std::is_constructible<Backend, T>::value&& std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_real(static_cast<T&&>(a)), m_imag(b) {}
   template <class T, class U>
   complex_adaptor(T&& a, U&& b, typename std::enable_if<std::is_constructible<Backend, T>::value&& std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_real(static_cast<T&&>(a)), m_imag(static_cast<U&&>(b)) {}
   template <class T, class U>
   complex_adaptor(const T& a, U&& b, typename std::enable_if<std::is_constructible<Backend, T>::value&& std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_real(a), m_imag(static_cast<U&&>(b)) {}

   complex_adaptor& operator=(const complex_adaptor& o)
   {
      m_real = o.real_data();
      m_imag = o.imag_data();
      return *this;
   }
   // rvalue assign:
   complex_adaptor& operator=(complex_adaptor&& o) noexcept
   {
      m_real = std::move(o.real_data());
      m_imag = std::move(o.imag_data());
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<Backend, V>::value, complex_adaptor&>::type operator=(const V& v)
   {
      using ui_type = typename std::tuple_element<0, unsigned_types>::type;
      m_real = v;
      m_imag = ui_type(0u);
      return *this;
   }
   template <class T>
   complex_adaptor& operator=(const std::complex<T>& val)
   {
      m_real = (long double)val.real();
      m_imag = (long double)val.imag();
      return *this;
   }
   complex_adaptor& operator=(const char* s)
   {
      using ui_type = typename std::tuple_element<0, unsigned_types>::type;
      ui_type                                           zero = 0u;

      using default_ops::eval_fpclassify;

      if (s && (*s == '('))
      {
         std::string part;
         const char* p = ++s;
         while (*p && (*p != ',') && (*p != ')'))
            ++p;
         part.assign(s, p);
         if (part.size())
            real_data() = part.c_str();
         else
            real_data() = zero;
         s = p;
         if (*p && (*p != ')'))
         {
            ++p;
            while (*p && (*p != ')'))
               ++p;
            part.assign(s + 1, p);
         }
         else
            part.erase();
         if (part.size())
            imag_data() = part.c_str();
         else
            imag_data() = zero;

         if (eval_fpclassify(imag_data()) == static_cast<int>(FP_NAN))
         {
            real_data() = imag_data();
         }
      }
      else
      {
         real_data() = s;
         imag_data() = zero;
      }
      return *this;
   }

   int compare(const complex_adaptor& o) const
   {
      // They are either equal or not:
      return (m_real.compare(o.real_data()) == 0) && (m_imag.compare(o.imag_data()) == 0) ? 0 : 1;
   }
   template <class T>
   int compare(const T& val) const
   {
      using default_ops::eval_is_zero;
      return (m_real.compare(val) == 0) && eval_is_zero(m_imag) ? 0 : 1;
   }
   void swap(complex_adaptor& o)
   {
      real_data().swap(o.real_data());
      imag_data().swap(o.imag_data());
   }
   std::string str(std::streamsize dig, std::ios_base::fmtflags f) const
   {
      using default_ops::eval_is_zero;
      if (eval_is_zero(imag_data()))
         return m_real.str(dig, f);
      return "(" + m_real.str(dig, f) + "," + m_imag.str(dig, f) + ")";
   }
   void negate()
   {
      m_real.negate();
      m_imag.negate();
   }
};

template <class Backend, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const complex_adaptor<Backend>& a, const T& b) noexcept
{
   return a.compare(b) == 0;
}

template <class Backend>
inline void eval_add(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& o)
{
   eval_add(result.real_data(), o.real_data());
   eval_add(result.imag_data(), o.imag_data());
}
template <class Backend>
inline void eval_subtract(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& o)
{
   eval_subtract(result.real_data(), o.real_data());
   eval_subtract(result.imag_data(), o.imag_data());
}
template <class Backend>
inline void eval_multiply(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& o)
{
   Backend t1, t2, t3;
   eval_multiply(t1, result.real_data(), o.real_data());
   eval_multiply(t2, result.imag_data(), o.imag_data());
   eval_subtract(t3, t1, t2);
   eval_multiply(t1, result.real_data(), o.imag_data());
   eval_multiply(t2, result.imag_data(), o.real_data());
   eval_add(t1, t2);
   result.real_data() = std::move(t3);
   result.imag_data() = std::move(t1);
}
template <class Backend>
inline void eval_divide(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& z)
{
   // (a+bi) / (c + di)
   using default_ops::eval_add;
   using default_ops::eval_divide;
   using default_ops::eval_fabs;
   using default_ops::eval_is_zero;
   using default_ops::eval_multiply;
   using default_ops::eval_subtract;
   Backend t1, t2;

   //
   // Backup sign bits for later, so we can fix up
   // signed zeros at the end:
   //
   int a_sign = eval_signbit(result.real_data());
   int b_sign = eval_signbit(result.imag_data());
   int c_sign = eval_signbit(z.real_data());
   int d_sign = eval_signbit(z.imag_data());

   if (eval_is_zero(z.imag_data()))
   {
      eval_divide(result.real_data(), z.real_data());
      eval_divide(result.imag_data(), z.real_data());
   }
   else
   {
      eval_fabs(t1, z.real_data());
      eval_fabs(t2, z.imag_data());
      if (t1.compare(t2) < 0)
      {
         eval_divide(t1, z.real_data(), z.imag_data()); // t1 = c/d
         eval_multiply(t2, z.real_data(), t1);
         eval_add(t2, z.imag_data()); // denom = c * (c/d) + d
         Backend t_real(result.real_data());
         // real = (a * (c/d) + b) / (denom)
         eval_multiply(result.real_data(), t1);
         eval_add(result.real_data(), result.imag_data());
         eval_divide(result.real_data(), t2);
         // imag = (b * c/d - a) / denom
         eval_multiply(result.imag_data(), t1);
         eval_subtract(result.imag_data(), t_real);
         eval_divide(result.imag_data(), t2);
      }
      else
      {
         eval_divide(t1, z.imag_data(), z.real_data()); // t1 = d/c
         eval_multiply(t2, z.imag_data(), t1);
         eval_add(t2, z.real_data()); // denom = d * d/c + c

         Backend r_t(result.real_data());
         Backend i_t(result.imag_data());

         // real = (b * d/c + a) / denom
         eval_multiply(result.real_data(), result.imag_data(), t1);
         eval_add(result.real_data(), r_t);
         eval_divide(result.real_data(), t2);
         // imag = (-a * d/c + b) / denom
         eval_multiply(result.imag_data(), r_t, t1);
         result.imag_data().negate();
         eval_add(result.imag_data(), i_t);
         eval_divide(result.imag_data(), t2);
      }
   }
   //
   // Finish off by fixing up signed zeros.
   // 
   // This sets the signs "as if" we had evaluated the result using:
   // 
   // real = (ac + bd) / (c^2 + d^2)
   // imag = (bc - ad) / (c^2 + d^2)
   // 
   // ie a zero is negative only if the two parts of the numerator
   // are both negative and zero.
   //
   if (eval_is_zero(result.real_data()))
   {
      int r_sign = eval_signbit(result.real_data());
      int r_required = (a_sign != c_sign) && (b_sign != d_sign);
      if (r_required != r_sign)
         result.real_data().negate();
   }
   if (eval_is_zero(result.imag_data()))
   {
      int i_sign = eval_signbit(result.imag_data());
      int i_required = (b_sign != c_sign) && (a_sign == d_sign);
      if (i_required != i_sign)
         result.imag_data().negate();
   }
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_add(complex_adaptor<Backend>& result, const T& scalar)
{
   using default_ops::eval_add;
   eval_add(result.real_data(), scalar);
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_subtract(complex_adaptor<Backend>& result, const T& scalar)
{
   using default_ops::eval_subtract;
   eval_subtract(result.real_data(), scalar);
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_multiply(complex_adaptor<Backend>& result, const T& scalar)
{
   using default_ops::eval_multiply;
   eval_multiply(result.real_data(), scalar);
   eval_multiply(result.imag_data(), scalar);
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_divide(complex_adaptor<Backend>& result, const T& scalar)
{
   using default_ops::eval_divide;
   eval_divide(result.real_data(), scalar);
   eval_divide(result.imag_data(), scalar);
}
// Optimised 3 arg versions:
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_add(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& a, const T& scalar)
{
   using default_ops::eval_add;
   eval_add(result.real_data(), a.real_data(), scalar);
   result.imag_data() = a.imag_data();
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_subtract(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& a, const T& scalar)
{
   using default_ops::eval_subtract;
   eval_subtract(result.real_data(), a.real_data(), scalar);
   result.imag_data() = a.imag_data();
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_multiply(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& a, const T& scalar)
{
   using default_ops::eval_multiply;
   eval_multiply(result.real_data(), a.real_data(), scalar);
   eval_multiply(result.imag_data(), a.imag_data(), scalar);
}
template <class Backend, class T>
inline typename std::enable_if< !std::is_same<complex_adaptor<Backend>, T>::value>::type eval_divide(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& a, const T& scalar)
{
   using default_ops::eval_divide;
   eval_divide(result.real_data(), a.real_data(), scalar);
   eval_divide(result.imag_data(), a.imag_data(), scalar);
}

template <class Backend>
inline bool eval_is_zero(const complex_adaptor<Backend>& val) noexcept
{
   using default_ops::eval_is_zero;
   return eval_is_zero(val.real_data()) && eval_is_zero(val.imag_data());
}
template <class Backend>
inline int eval_get_sign(const complex_adaptor<Backend>&)
{
   static_assert(sizeof(Backend) == UINT_MAX, "Complex numbers have no sign bit."); // designed to always fail
   return 0;
}

template <class Result, class Backend>
inline typename std::enable_if< !boost::multiprecision::detail::is_complex<Result>::value>::type eval_convert_to(Result* result, const complex_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   using default_ops::eval_is_zero;
   if (!eval_is_zero(val.imag_data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   eval_convert_to(result, val.real_data());
}

template <class Backend, class T>
inline void assign_components(complex_adaptor<Backend>& result, const T& a, const T& b)
{
   result.real_data() = a;
   result.imag_data() = b;
}

//
// Native non-member operations:
//
template <class Backend>
inline void eval_sqrt(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& val)
{
   // Use the following:
   // sqrt(z) = (s, zi / 2s)       for zr >= 0
   //           (|zi| / 2s, +-s)   for zr <  0
   // where s = sqrt{ [ |zr| + sqrt(zr^2 + zi^2) ] / 2 },
   // and the +- sign is the same as the sign of zi.
   using default_ops::eval_abs;
   using default_ops::eval_add;
   using default_ops::eval_divide;
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;

   if (eval_is_zero(val.imag_data()) && (eval_get_sign(val.real_data()) >= 0))
   {
      constexpr typename std::tuple_element<0, typename Backend::unsigned_types>::type zero = 0u;
      eval_sqrt(result.real_data(), val.real_data());
      result.imag_data() = zero;
      return;
   }

   const bool __my_real_part_is_neg(eval_get_sign(val.real_data()) < 0);

   Backend __my_real_part_fabs(val.real_data());
   if (__my_real_part_is_neg)
      __my_real_part_fabs.negate();

   Backend t, __my_sqrt_part;
   eval_abs(__my_sqrt_part, val);
   eval_add(__my_sqrt_part, __my_real_part_fabs);
   eval_ldexp(t, __my_sqrt_part, -1);
   eval_sqrt(__my_sqrt_part, t);

   if (__my_real_part_is_neg == false)
   {
      eval_ldexp(t, __my_sqrt_part, 1);
      eval_divide(result.imag_data(), val.imag_data(), t);
      result.real_data() = __my_sqrt_part;
   }
   else
   {
      const bool __my_imag_part_is_neg(eval_get_sign(val.imag_data()) < 0);

      Backend __my_imag_part_fabs(val.imag_data());
      if (__my_imag_part_is_neg)
         __my_imag_part_fabs.negate();

      eval_ldexp(t, __my_sqrt_part, 1);
      eval_divide(result.real_data(), __my_imag_part_fabs, t);
      if (__my_imag_part_is_neg)
         __my_sqrt_part.negate();
      result.imag_data() = __my_sqrt_part;
   }
}

template <class Backend>
inline void eval_abs(Backend& result, const complex_adaptor<Backend>& val)
{
   Backend t1, t2;
   eval_multiply(t1, val.real_data(), val.real_data());
   eval_multiply(t2, val.imag_data(), val.imag_data());
   eval_add(t1, t2);
   eval_sqrt(result, t1);
}

template <class Backend>
inline void eval_pow(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& b, const complex_adaptor<Backend>& e)
{
   using default_ops::eval_acos;
   using default_ops::eval_cos;
   using default_ops::eval_exp;
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_multiply;
   using default_ops::eval_sin;

   if (eval_is_zero(e))
   {
      typename std::tuple_element<0, typename Backend::unsigned_types>::type one(1);
      result = one;
      return;
   }
   else if (eval_is_zero(b))
   {
      if (eval_is_zero(e.real_data()))
      {
         Backend n          = std::numeric_limits<number<Backend> >::quiet_NaN().backend();
         result.real_data() = n;
         result.imag_data() = n;
      }
      else if (eval_get_sign(e.real_data()) < 0)
      {
         Backend n          = std::numeric_limits<number<Backend> >::infinity().backend();
         result.real_data() = n;
         typename std::tuple_element<0, typename Backend::unsigned_types>::type zero(0);
         if (eval_is_zero(e.imag_data()))
            result.imag_data() = zero;
         else
            result.imag_data() = n;
      }
      else
      {
         typename std::tuple_element<0, typename Backend::unsigned_types>::type zero(0);
         result = zero;
      }
      return;
   }
   complex_adaptor<Backend> t;
   eval_log(t, b);
   eval_multiply(t, e);
   eval_exp(result, t);
}

template <class Backend>
inline void eval_exp(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_cos;
   using default_ops::eval_exp;
   using default_ops::eval_is_zero;
   using default_ops::eval_multiply;
   using default_ops::eval_sin;

   if (eval_is_zero(arg.imag_data()))
   {
      eval_exp(result.real_data(), arg.real_data());
      typename std::tuple_element<0, typename Backend::unsigned_types>::type zero(0);
      result.imag_data() = zero;
      return;
   }
   eval_cos(result.real_data(), arg.imag_data());
   eval_sin(result.imag_data(), arg.imag_data());
   Backend e;
   eval_exp(e, arg.real_data());
   if (eval_is_zero(result.real_data()))
      eval_multiply(result.imag_data(), e);
   else if (eval_is_zero(result.imag_data()))
      eval_multiply(result.real_data(), e);
   else
      eval_multiply(result, e);
}

template <class Backend>
inline void eval_log(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_add;
   using default_ops::eval_atan2;
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_log;
   using default_ops::eval_multiply;

   if (eval_is_zero(arg.imag_data()) && (eval_get_sign(arg.real_data()) >= 0))
   {
      eval_log(result.real_data(), arg.real_data());
      typename std::tuple_element<0, typename Backend::unsigned_types>::type zero(0);
      result.imag_data() = zero;
      return;
   }

   Backend t1, t2;
   eval_multiply(t1, arg.real_data(), arg.real_data());
   eval_multiply(t2, arg.imag_data(), arg.imag_data());
   eval_add(t1, t2);
   eval_log(t2, t1);
   eval_ldexp(result.real_data(), t2, -1);
   eval_atan2(result.imag_data(), arg.imag_data(), arg.real_data());
}

template <class Backend>
inline void eval_log10(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_divide;
   using default_ops::eval_log;

   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;

   Backend ten;
   ten = ui_type(10);
   Backend l_ten;
   eval_log(l_ten, ten);
   eval_log(result, arg);
   eval_divide(result, l_ten);
}

template <class Backend>
inline void eval_sin(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_cos;
   using default_ops::eval_cosh;
   using default_ops::eval_sin;
   using default_ops::eval_sinh;

   Backend t1, t2, t3;
   eval_sin(t1, arg.real_data());
   eval_cosh(t2, arg.imag_data());
   eval_multiply(t3, t1, t2);

   eval_cos(t1, arg.real_data());
   eval_sinh(t2, arg.imag_data());
   eval_multiply(result.imag_data(), t1, t2);
   result.real_data() = t3;
}

template <class Backend>
inline void eval_cos(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_cos;
   using default_ops::eval_cosh;
   using default_ops::eval_sin;
   using default_ops::eval_sinh;

   Backend t1, t2, t3;
   eval_cos(t1, arg.real_data());
   eval_cosh(t2, arg.imag_data());
   eval_multiply(t3, t1, t2);

   eval_sin(t1, arg.real_data());
   eval_sinh(t2, arg.imag_data());
   eval_multiply(result.imag_data(), t1, t2);
   result.imag_data().negate();
   result.real_data() = t3;
}

template <class T>
void tanh_imp(const T& r, const T& i, T& r_result, T& i_result)
{
   using default_ops::eval_tan;
   using default_ops::eval_sinh;
   using default_ops::eval_add;
   using default_ops::eval_fpclassify;
   using default_ops::eval_get_sign;

   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   ui_type one(1);
   //
   // Set:
   // t = tan(i);
   // s = sinh(r);
   // b = s * (1 + t^2);
   // d = 1 + b * s;
   //
   T t, s, b, d;
   eval_tan(t, i);
   eval_sinh(s, r);
   eval_multiply(d, t, t);
   eval_add(d, one);
   eval_multiply(b, d, s);
   eval_multiply(d, b, s);
   eval_add(d, one);

   if (eval_fpclassify(d) == FP_INFINITE)
   {
      r_result = one;
      if (eval_get_sign(s) < 0)
         r_result.negate();
      //
      // Imaginary part is a signed zero:
      //
      ui_type zero(0);
      i_result = zero;
      if (eval_get_sign(t) < 0)
         i_result.negate();
   }
   //
   // Real part is sqrt(1 + s^2) * b / d;
   // Imaginary part is t / d;
   //
   eval_divide(i_result, t, d);
   //
   // variable t is now spare, as is r_result.
   //
   eval_multiply(t, s, s);
   eval_add(t, one);
   eval_sqrt(r_result, t);
   eval_multiply(t, r_result, b);
   eval_divide(r_result, t, d);
}

template <class Backend>
inline void eval_tanh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   tanh_imp(arg.real_data(), arg.imag_data(), result.real_data(), result.imag_data());
}
template <class Backend>
inline void eval_tan(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   Backend t(arg.imag_data());
   t.negate();
   tanh_imp(t, arg.real_data(), result.imag_data(), result.real_data());
   result.imag_data().negate();
}

template <class Backend>
inline void eval_asin(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_add;
   using default_ops::eval_multiply;

   if (eval_is_zero(arg))
   {
      result = arg;
      return;
   }

   complex_adaptor<Backend> t1, t2;
   assign_components(t1, arg.imag_data(), arg.real_data());
   t1.real_data().negate();
   eval_asinh(t2, t1);

   assign_components(result, t2.imag_data(), t2.real_data());
   result.imag_data().negate();
}

template <class Backend>
inline void eval_acos(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;

   using default_ops::eval_asin;

   Backend half_pi, t1;
   t1 = static_cast<ui_type>(1u);
   eval_asin(half_pi, t1);
   eval_asin(result, arg);
   result.negate();
   eval_add(result.real_data(), half_pi);
}

template <class Backend>
inline void eval_atan(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   ui_type                                                             one = (ui_type)1u;

   using default_ops::eval_add;
   using default_ops::eval_is_zero;
   using default_ops::eval_log;
   using default_ops::eval_subtract;

   complex_adaptor<Backend> __my_z_times_i, t1, t2, t3;
   assign_components(__my_z_times_i, arg.imag_data(), arg.real_data());
   __my_z_times_i.real_data().negate();

   eval_add(t1, __my_z_times_i, one);
   eval_log(t2, t1);
   eval_subtract(t1, one, __my_z_times_i);
   eval_log(t3, t1);
   eval_subtract(t1, t3, t2);

   eval_ldexp(result.real_data(), t1.imag_data(), -1);
   eval_ldexp(result.imag_data(), t1.real_data(), -1);
   if (!eval_is_zero(result.real_data()))
      result.real_data().negate();
}

template <class Backend>
inline void eval_sinh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_cos;
   using default_ops::eval_cosh;
   using default_ops::eval_sin;
   using default_ops::eval_sinh;

   Backend t1, t2, t3;
   eval_cos(t1, arg.imag_data());
   eval_sinh(t2, arg.real_data());
   eval_multiply(t3, t1, t2);

   eval_cosh(t1, arg.real_data());
   eval_sin(t2, arg.imag_data());
   eval_multiply(result.imag_data(), t1, t2);
   result.real_data() = t3;
}

template <class Backend>
inline void eval_cosh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_cos;
   using default_ops::eval_cosh;
   using default_ops::eval_sin;
   using default_ops::eval_sinh;

   Backend t1, t2, t3;
   eval_cos(t1, arg.imag_data());
   eval_cosh(t2, arg.real_data());
   eval_multiply(t3, t1, t2);

   eval_sin(t1, arg.imag_data());
   eval_sinh(t2, arg.real_data());
   eval_multiply(result.imag_data(), t1, t2);
   result.real_data() = t3;
}

template <class Backend>
inline void eval_asinh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   ui_type                                                             one = (ui_type)1u;

   using default_ops::eval_add;
   using default_ops::eval_log;
   using default_ops::eval_multiply;

   complex_adaptor<Backend> t1, t2;
   eval_multiply(t1, arg, arg);
   eval_add(t1, one);
   eval_sqrt(t2, t1);
   eval_add(t2, arg);
   eval_log(result, t2);
}

template <class Backend>
inline void eval_acosh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   ui_type                                                             one = (ui_type)1u;

   using default_ops::eval_add;
   using default_ops::eval_divide;
   using default_ops::eval_log;
   using default_ops::eval_multiply;
   using default_ops::eval_subtract;

   complex_adaptor<Backend> __my_zp(arg);
   eval_add(__my_zp.real_data(), one);
   complex_adaptor<Backend> __my_zm(arg);
   eval_subtract(__my_zm.real_data(), one);

   complex_adaptor<Backend> t1, t2;
   eval_divide(t1, __my_zm, __my_zp);
   eval_sqrt(t2, t1);
   eval_multiply(t2, __my_zp);
   eval_add(t2, arg);
   eval_log(result, t2);
}

template <class Backend>
inline void eval_atanh(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   ui_type                                                             one = (ui_type)1u;

   using default_ops::eval_add;
   using default_ops::eval_divide;
   using default_ops::eval_log;
   using default_ops::eval_multiply;
   using default_ops::eval_subtract;

   complex_adaptor<Backend> t1, t2, t3;
   eval_add(t1, arg, one);
   eval_log(t2, t1);
   eval_subtract(t1, one, arg);
   eval_log(t3, t1);
   eval_subtract(t2, t3);

   eval_ldexp(result.real_data(), t2.real_data(), -1);
   eval_ldexp(result.imag_data(), t2.imag_data(), -1);
}

template <class Backend>
inline void eval_conj(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   result = arg;
   result.imag_data().negate();
}

template <class Backend>
inline void eval_proj(complex_adaptor<Backend>& result, const complex_adaptor<Backend>& arg)
{
   using default_ops::eval_get_sign;

   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   ui_type                                                             zero = (ui_type)0u;

   int c1 = eval_fpclassify(arg.real_data());
   int c2 = eval_fpclassify(arg.imag_data());
   if (c1 == FP_INFINITE)
   {
      result.real_data() = arg.real_data();
      if (eval_get_sign(result.real_data()) < 0)
         result.real_data().negate();
      result.imag_data() = zero;
      if (eval_get_sign(arg.imag_data()) < 0)
         result.imag_data().negate();
   }
   else if (c2 == FP_INFINITE)
   {
      result.real_data() = arg.imag_data();
      if (eval_get_sign(result.real_data()) < 0)
         result.real_data().negate();
      result.imag_data() = zero;
      if (eval_get_sign(arg.imag_data()) < 0)
         result.imag_data().negate();
   }
   else
      result = arg;
}

template <class Backend>
inline void eval_real(Backend& result, const complex_adaptor<Backend>& arg)
{
   result = arg.real_data();
}
template <class Backend>
inline void eval_imag(Backend& result, const complex_adaptor<Backend>& arg)
{
   result = arg.imag_data();
}

template <class Backend, class T>
inline void eval_set_imag(complex_adaptor<Backend>& result, const T& arg)
{
   result.imag_data() = arg;
}

template <class Backend, class T>
inline void eval_set_real(complex_adaptor<Backend>& result, const T& arg)
{
   result.real_data() = arg;
}

template <class Backend>
inline std::size_t hash_value(const complex_adaptor<Backend>& val)
{
   std::size_t result  = hash_value(val.real_data());
   std::size_t result2 = hash_value(val.imag_data());
   boost::multiprecision::detail::hash_combine(result, result2);
   return result;
}

} // namespace backends

using boost::multiprecision::backends::complex_adaptor;

template <class Backend>
struct number_category<complex_adaptor<Backend> > : public std::integral_constant<int, boost::multiprecision::number_kind_complex>
{};

template <class Backend, expression_template_option ExpressionTemplates>
struct component_type<number<complex_adaptor<Backend>, ExpressionTemplates> >
{
   using type = number<Backend, ExpressionTemplates>;
};

template <class Backend, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<Backend, ExpressionTemplates> >
{
   using type = number<complex_adaptor<Backend>, ExpressionTemplates>;
};

namespace detail {
   template <class Backend>
   struct is_variable_precision<complex_adaptor<Backend> > : public is_variable_precision<Backend>
   {};
#ifdef BOOST_HAS_INT128
   template <class Backend>
   struct is_convertible_arithmetic<int128_type, complex_adaptor<Backend> > : is_convertible_arithmetic<int128_type, Backend>
   {};
   template <class Backend>
   struct is_convertible_arithmetic<uint128_type, complex_adaptor<Backend> > : is_convertible_arithmetic<uint128_type, Backend>
   {};
#endif
#ifdef BOOST_HAS_FLOAT128
   template <class Backend>
   struct is_convertible_arithmetic<float128_type, complex_adaptor<Backend> > : is_convertible_arithmetic<float128_type, Backend>
   {};
#endif
   } // namespace detail



template <class Backend, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<backends::debug_adaptor<Backend>, ExpressionTemplates> >
{
   using type = number<backends::debug_adaptor<complex_adaptor<Backend> >, ExpressionTemplates>;
};

template <class Backend, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<backends::logged_adaptor<Backend>, ExpressionTemplates> >
{
   using type = number<backends::logged_adaptor<complex_adaptor<Backend> >, ExpressionTemplates>;
};

}

} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/concepts/mp_number_archetypes.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_MP_NUMBER_ARCHETYPES_HPP
#define BOOST_MP_MP_NUMBER_ARCHETYPES_HPP

#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <tuple>
#include <functional>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>

namespace boost {
namespace multiprecision {
namespace concepts {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4244)
#endif

struct number_backend_float_architype
{
   using signed_types = std::tuple<long long> ;
   using unsigned_types = std::tuple<unsigned long long>;
   using float_types = std::tuple<long double>;
   using exponent_type = int;

   number_backend_float_architype()
   {
      m_value = 0;
      std::cout << "Default construct" << std::endl;
   }
   number_backend_float_architype(const number_backend_float_architype& o)
   {
      std::cout << "Copy construct" << std::endl;
      m_value = o.m_value;
   }
   number_backend_float_architype& operator=(const number_backend_float_architype& o)
   {
      m_value = o.m_value;
      std::cout << "Assignment (" << m_value << ")" << std::endl;
      return *this;
   }
   number_backend_float_architype& operator=(unsigned long long i)
   {
      m_value = i;
      std::cout << "UInt Assignment (" << i << ")" << std::endl;
      return *this;
   }
   number_backend_float_architype& operator=(long long i)
   {
      m_value = i;
      std::cout << "Int Assignment (" << i << ")" << std::endl;
      return *this;
   }
   number_backend_float_architype& operator=(long double d)
   {
      m_value = d;
      std::cout << "long double Assignment (" << d << ")" << std::endl;
      return *this;
   }
   number_backend_float_architype& operator=(const char* s)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         #ifndef BOOST_MP_STANDALONE
         m_value = boost::lexical_cast<long double>(s);
         #else
         m_value = std::strtold(s, nullptr);

         if(m_value == HUGE_VALL || m_value == 0)
         {
            BOOST_MP_THROW_EXCEPTION(std::runtime_error("Value can not be assigned in standalone mode. Please disable and try again."));
         }
         #endif
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const std::exception&)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse input string: \"") + s + std::string("\" as a valid floating point number.")));
      }
#endif
      std::cout << "const char* Assignment (" << s << ")" << std::endl;
      return *this;
   }
   void swap(number_backend_float_architype& o)
   {
      std::cout << "Swapping (" << m_value << " with " << o.m_value << ")" << std::endl;
      std::swap(m_value, o.m_value);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      std::stringstream ss;
      ss.flags(f);
      if (digits)
         ss.precision(digits);
      else
         ss.precision(std::numeric_limits<long double>::digits10 + 3);
      std::intmax_t  i = m_value;
      std::uintmax_t u = m_value;
      if (!(f & std::ios_base::scientific) && m_value == i)
         ss << i;
      else if (!(f & std::ios_base::scientific) && m_value == u)
         ss << u;
      else
         ss << m_value;
      std::string s = ss.str();
      std::cout << "Converting to string (" << s << ")" << std::endl;
      return s;
   }
   void negate()
   {
      std::cout << "Negating (" << m_value << ")" << std::endl;
      m_value = -m_value;
   }
   int compare(const number_backend_float_architype& o) const
   {
      std::cout << "Comparison" << std::endl;
      return m_value > o.m_value ? 1 : (m_value < o.m_value ? -1 : 0);
   }
   int compare(long long i) const
   {
      std::cout << "Comparison with int" << std::endl;
      return m_value > i ? 1 : (m_value < i ? -1 : 0);
   }
   int compare(unsigned long long i) const
   {
      std::cout << "Comparison with unsigned" << std::endl;
      return m_value > i ? 1 : (m_value < i ? -1 : 0);
   }
   int compare(long double d) const
   {
      std::cout << "Comparison with long double" << std::endl;
      return m_value > d ? 1 : (m_value < d ? -1 : 0);
   }
   long double m_value;
};

inline void eval_add(number_backend_float_architype& result, const number_backend_float_architype& o)
{
   std::cout << "Addition (" << result.m_value << " += " << o.m_value << ")" << std::endl;
   result.m_value += o.m_value;
}
inline void eval_subtract(number_backend_float_architype& result, const number_backend_float_architype& o)
{
   std::cout << "Subtraction (" << result.m_value << " -= " << o.m_value << ")" << std::endl;
   result.m_value -= o.m_value;
}
inline void eval_multiply(number_backend_float_architype& result, const number_backend_float_architype& o)
{
   std::cout << "Multiplication (" << result.m_value << " *= " << o.m_value << ")" << std::endl;
   result.m_value *= o.m_value;
}
inline void eval_divide(number_backend_float_architype& result, const number_backend_float_architype& o)
{
   std::cout << "Division (" << result.m_value << " /= " << o.m_value << ")" << std::endl;
   result.m_value /= o.m_value;
}

inline void eval_convert_to(unsigned long long* result, const number_backend_float_architype& val)
{
   *result = static_cast<unsigned long long>(val.m_value);
}
inline void eval_convert_to(long long* result, const number_backend_float_architype& val)
{
   *result = static_cast<long long>(val.m_value);
}
inline void eval_convert_to(long double* result, number_backend_float_architype& val)
{
   *result = val.m_value;
}

inline void eval_frexp(number_backend_float_architype& result, const number_backend_float_architype& arg, int* exp)
{
   result = std::frexp(arg.m_value, exp);
}

inline void eval_ldexp(number_backend_float_architype& result, const number_backend_float_architype& arg, int exp)
{
   result = std::ldexp(arg.m_value, exp);
}

inline void eval_floor(number_backend_float_architype& result, const number_backend_float_architype& arg)
{
   result = std::floor(arg.m_value);
}

inline void eval_ceil(number_backend_float_architype& result, const number_backend_float_architype& arg)
{
   result = std::ceil(arg.m_value);
}

inline void eval_sqrt(number_backend_float_architype& result, const number_backend_float_architype& arg)
{
   result = std::sqrt(arg.m_value);
}

inline int eval_fpclassify(const number_backend_float_architype& arg)
{
   return BOOST_MP_FPCLASSIFY(arg.m_value);
}

inline std::size_t hash_value(const number_backend_float_architype& v)
{
   std::hash<long double> hasher;
   return hasher(v.m_value);
}

using mp_number_float_architype = boost::multiprecision::number<number_backend_float_architype>;

} // namespace concepts

template <>
struct number_category<concepts::number_backend_float_architype> : public std::integral_constant<int, number_kind_floating_point>
{};

}} // namespace boost::multiprecision

namespace std {

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype, ExpressionTemplates> > : public std::numeric_limits<long double>
{
   using base_type = std::numeric_limits<long double>                                                                                   ;
   using number_type = boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype, ExpressionTemplates>;

 public:
   static number_type(min)() noexcept { return (base_type::min)(); }
   static number_type(max)() noexcept { return (base_type::max)(); }
   static number_type lowest() noexcept { return -(max)(); }
   static number_type epsilon() noexcept { return base_type::epsilon(); }
   static number_type round_error() noexcept { return base_type::round_error(); }
   static number_type infinity() noexcept { return base_type::infinity(); }
   static number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
   static number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
   static number_type denorm_min() noexcept { return base_type::denorm_min(); }
};

} // namespace std

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_bin_float/io.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_BIN_FLOAT_IO_HPP
#define BOOST_MP_CPP_BIN_FLOAT_IO_HPP

#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision {
namespace cpp_bf_io_detail {

//
// Multiplies a by b and shifts the result so it fits inside max_bits bits,
// returns by how much the result was shifted.
//
template <class I>
inline I restricted_multiply(cpp_int& result, const cpp_int& a, const cpp_int& b, I max_bits, std::int64_t& error)
{
   using local_integral_type = I;

   result   = a * b;
   local_integral_type gb     = static_cast<local_integral_type>(msb(result));
   local_integral_type rshift = 0;
   if (gb > max_bits)
   {
      rshift = gb - max_bits;
      local_integral_type lb      = static_cast<local_integral_type>(lsb(result));
      int roundup = 0;
      // The error rate increases by the error of both a and b,
      // this may be overly pessimistic in many case as we're assuming
      // that a and b have the same level of uncertainty...
      if (lb < rshift)
         error = error ? error * 2 : 1;
      if (rshift)
      {
         BOOST_MP_ASSERT(rshift < INT_MAX);
         if (bit_test(result, static_cast<unsigned>(rshift - 1)))
         {
            if (lb == rshift - 1)
               roundup = 1;
            else
               roundup = 2;
         }
         result >>= rshift;
      }
      if ((roundup == 2) || ((roundup == 1) && (result.backend().limbs()[0] & 1)))
         ++result;
   }
   return rshift;
}
//
// Computes a^e shifted to the right so it fits in max_bits, returns how far
// to the right we are shifted.
//
template <class I>
inline I restricted_pow(cpp_int& result, const cpp_int& a, I e, I max_bits, std::int64_t& error)
{
   BOOST_MP_ASSERT(&result != &a);
   I exp = 0;
   if (e == 1)
   {
      result = a;
      return exp;
   }
   else if (e == 2)
   {
      return restricted_multiply(result, a, a, max_bits, error);
   }
   else if (e == 3)
   {
      exp = restricted_multiply(result, a, a, max_bits, error);
      exp += restricted_multiply(result, result, a, max_bits, error);
      return exp;
   }
   I p = e / 2;
   exp = restricted_pow(result, a, p, max_bits, error);
   exp *= 2;
   exp += restricted_multiply(result, result, result, max_bits, error);
   if (e & 1)
      exp += restricted_multiply(result, result, a, max_bits, error);
   return exp;
}

inline int get_round_mode(const cpp_int& what, std::int64_t location, std::int64_t error)
{
   //
   // Can we round what at /location/, if the error in what is /error/ in
   // units of 0.5ulp.  Return:
   //
   // -1: Can't round.
   //  0: leave as is.
   //  1: tie.
   //  2: round up.
   //
   BOOST_MP_ASSERT(location >= 0);
   BOOST_MP_ASSERT(location < INT_MAX);
   std::int64_t error_radius = error & 1 ? (1 + error) / 2 : error / 2;
   if (error_radius && (static_cast<int>(msb(error_radius)) >= location))
      return -1;
   if (bit_test(what, static_cast<unsigned>(location)))
   {
      if (static_cast<int>(lsb(what)) == location)
         return error ? -1 : 1; // Either a tie or can't round depending on whether we have any error
      if (!error)
         return 2; // no error, round up.
      cpp_int t = what - error_radius;
      if (static_cast<int>(lsb(t)) >= location)
         return -1;
      return 2;
   }
   else if (error)
   {
      cpp_int t = what + error_radius;
      return bit_test(t, static_cast<unsigned>(location)) ? -1 : 0;
   }
   return 0;
}

inline int get_round_mode(cpp_int& r, cpp_int& d, std::int64_t error, const cpp_int& q)
{
   //
   // Lets suppose we have an inexact division by d+delta, where the true
   // value for the divisor is d, and with |delta| <= error/2, then
   // we have calculated q and r such that:
   //
   // n                  r
   // ---       = q + -----------
   // d + error        d + error
   //
   // Rearranging for n / d we get:
   //
   //    n         delta*q + r
   //   --- = q + -------------
   //    d              d
   //
   // So rounding depends on whether 2r + error * q > d.
   //
   // We return:
   //  0 = down down.
   //  1 = tie.
   //  2 = round up.
   // -1 = couldn't decide.
   //
   r <<= 1;
   int c = r.compare(d);
   if (c == 0)
      return error ? -1 : 1;
   if (c > 0)
   {
      if (error)
      {
         r -= error * q;
         return r.compare(d) > 0 ? 2 : -1;
      }
      return 2;
   }
   if (error)
   {
      r += error * q;
      return r.compare(d) < 0 ? 0 : -1;
   }
   return 0;
}

} // namespace cpp_bf_io_detail

namespace backends {

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::operator=(const char* s)
{
             cpp_int       n;
             std::intmax_t decimal_exp     = 0;
             std::intmax_t digits_seen     = 0;
   constexpr std::intmax_t max_digits_seen = 4 + (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count * 301L) / 1000;
             bool          ss              = false;
   //
   // Extract the sign:
   //
   if (*s == '-')
   {
      ss = true;
      ++s;
   }
   else if (*s == '+')
      ++s;
   //
   // Special cases first:
   //
   if ((std::strcmp(s, "nan") == 0) || (std::strcmp(s, "NaN") == 0) || (std::strcmp(s, "NAN") == 0))
   {
      return *this = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
   }
   if ((std::strcmp(s, "inf") == 0) || (std::strcmp(s, "Inf") == 0) || (std::strcmp(s, "INF") == 0) || (std::strcmp(s, "infinity") == 0) || (std::strcmp(s, "Infinity") == 0) || (std::strcmp(s, "INFINITY") == 0))
   {
      *this = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      if (ss)
         negate();
      return *this;
   }
   //
   // Digits before the point:
   //
   while (*s && (*s >= '0') && (*s <= '9'))
   {
      n *= 10u;
      n += *s - '0';
      if (digits_seen || (*s != '0'))
         ++digits_seen;
      ++s;
   }
   // The decimal point (we really should localise this!!)
   if (*s && (*s == '.'))
      ++s;
   //
   // Digits after the point:
   //
   while (*s && (*s >= '0') && (*s <= '9'))
   {
      n *= 10u;
      n += *s - '0';
      --decimal_exp;
      if (digits_seen || (*s != '0'))
         ++digits_seen;
      ++s;
      if (digits_seen > max_digits_seen)
         break;
   }
   //
   // Digits we're skipping:
   //
   while (*s && (*s >= '0') && (*s <= '9'))
      ++s;
   //
   // See if there's an exponent:
   //
   if (*s && ((*s == 'e') || (*s == 'E')))
   {
      ++s;
      std::intmax_t e  = 0;
      bool            es = false;
      if (*s && (*s == '-'))
      {
         es = true;
         ++s;
      }
      else if (*s && (*s == '+'))
         ++s;
      while (*s && (*s >= '0') && (*s <= '9'))
      {
         e *= 10u;
         e += *s - '0';
         ++s;
      }
      if (es)
         e = -e;
      decimal_exp += e;
   }
   if (*s)
   {
      //
      // Oops unexpected input at the end of the number:
      //
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unable to parse string as a valid floating point number."));
   }
   if (n == 0)
   {
      // Result is necessarily zero:
      *this = static_cast<limb_type>(0u);
      return *this;
   }

   constexpr std::size_t limb_bits = sizeof(limb_type) * CHAR_BIT;
   //
   // Set our working precision - this is heuristic based, we want
   // a value as small as possible > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count to avoid large computations
   // and excessive memory usage, but we also want to avoid having to
   // up the computation and start again at a higher precision.
   // So we round cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count up to the nearest whole number of limbs, and add
   // one limb for good measure.  This works very well for small exponents,
   // but for larger exponents we may may need to restart, we could add some
   // extra precision right from the start for larger exponents, but this
   // seems to be slightly slower in the *average* case:
   //
#ifdef BOOST_MP_STRESS_IO
   std::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 32;
#else
   std::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + ((cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits) ? (limb_bits - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits) : 0) + limb_bits;
#endif
   std::int64_t  error          = 0;
   std::intmax_t calc_exp       = 0;
   std::intmax_t final_exponent = 0;

   if (decimal_exp >= 0)
   {
      // Nice and simple, the result is an integer...
      do
      {
         cpp_int t;
         if (decimal_exp)
         {
            calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(t, cpp_int(5), decimal_exp, max_bits, error);
            calc_exp += boost::multiprecision::cpp_bf_io_detail::restricted_multiply(t, t, n, max_bits, error);
         }
         else
            t = n;
         final_exponent = (std::int64_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 + decimal_exp + calc_exp;
         std::ptrdiff_t rshift     = static_cast<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(msb(t)) - static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) + 1);
         if (rshift > 0)
         {
            final_exponent += rshift;
            int roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(t, rshift - 1, error);
            t >>= rshift;
            if ((roundup == 2) || ((roundup == 1) && t.backend().limbs()[0] & 1))
               ++t;
            else if (roundup < 0)
            {
#ifdef BOOST_MP_STRESS_IO
               max_bits += 32;
#else
               max_bits *= 2;
#endif
               error = 0;
               continue;
            }
         }
         else
         {
            BOOST_MP_ASSERT(!error);
         }
         if (final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
         {
            exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
            final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
         }
         else if (final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
         {
            // Underflow:
            exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
            final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
         }
         else
         {
            exponent()     = static_cast<Exponent>(final_exponent);
            final_exponent = 0;
         }
         copy_and_round(*this, t.backend());
         break;
      } while (true);

      if (ss != sign())
         negate();
   }
   else
   {
      // Result is the ratio of two integers: we need to organise the
      // division so as to produce at least an N-bit result which we can
      // round according to the remainder.
      //cpp_int d = pow(cpp_int(5), -decimal_exp);
      do
      {
         cpp_int d;
         calc_exp                   = boost::multiprecision::cpp_bf_io_detail::restricted_pow(d, cpp_int(5), -decimal_exp, max_bits, error);
         const std::ptrdiff_t shift = static_cast<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - static_cast<std::ptrdiff_t>(msb(n)) + static_cast<std::ptrdiff_t>(msb(d)));
         final_exponent             = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 + decimal_exp - calc_exp;
         if (shift > 0)
         {
            n <<= shift;
            final_exponent -= static_cast<Exponent>(shift);
         }
         cpp_int q, r;
         divide_qr(n, d, q, r);
         std::ptrdiff_t gb = static_cast<std::ptrdiff_t>(msb(q));
         BOOST_MP_ASSERT((gb >= static_cast<int>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - 1));
         //
         // Check for rounding conditions we have to
         // handle ourselves:
         //
         int roundup = 0;
         if (gb == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
         {
            // Exactly the right number of bits, use the remainder to round:
            roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(r, d, error, q);
         }
         else if (bit_test(q, static_cast<std::size_t>(gb - static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))) && (static_cast<std::ptrdiff_t>(lsb(q)) == static_cast<std::ptrdiff_t>(gb - static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))))
         {
            // Too many bits in q and the bits in q indicate a tie, but we can break that using r,
            // note that the radius of error in r is error/2 * q:
            std::ptrdiff_t lshift = gb - static_cast<int>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) + 1;
            q >>= lshift;
            final_exponent += static_cast<Exponent>(lshift);
            BOOST_MP_ASSERT((msb(q) >= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
            if (error && (r < (error / 2) * q))
               roundup = -1;
            else if (error && (r + (error / 2) * q >= d))
               roundup = -1;
            else
               roundup = r ? 2 : 1;
         }
         else if (error && (((error / 2) * q + r >= d) || (r < (error / 2) * q)))
         {
            // We might have been rounding up, or got the wrong quotient: can't tell!
            roundup = -1;
         }
         if (roundup < 0)
         {
#ifdef BOOST_MP_STRESS_IO
            max_bits += 32;
#else
            max_bits *= 2;
#endif
            error = 0;
            if (shift > 0)
            {
               n >>= shift;
               final_exponent += static_cast<Exponent>(shift);
            }
            continue;
         }
         else if ((roundup == 2) || ((roundup == 1) && q.backend().limbs()[0] & 1))
            ++q;
         if (final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
         {
            // Overflow:
            exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
            final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
         }
         else if (final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
         {
            // Underflow:
            exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
            final_exponent -= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
         }
         else
         {
            exponent()     = static_cast<Exponent>(final_exponent);
            final_exponent = 0;
         }
         copy_and_round(*this, q.backend());
         if (ss != sign())
            negate();
         break;
      } while (true);
   }
   //
   // Check for scaling and/or over/under-flow:
   //
   final_exponent += exponent();
   if (final_exponent > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
   {
      // Overflow:
      exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
      bits()     = limb_type(0);
   }
   else if (final_exponent < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
   {
      // Underflow:
      exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
      bits()     = limb_type(0);
      sign()     = 0;
   }
   else
   {
      exponent() = static_cast<Exponent>(final_exponent);
   }
   return *this;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
std::string cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::str(std::streamsize dig, std::ios_base::fmtflags f) const
{
   bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
   bool fixed      = !scientific && (f & std::ios_base::fixed);

   if (dig == 0 && !fixed)
      dig = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::max_digits10;

   std::string s;

   if (exponent() <= cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
   {
      // How far to left-shift in order to demormalise the mantissa:
      std::intmax_t shift         = (std::intmax_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - (std::intmax_t)exponent() - 1;
      std::intmax_t digits_wanted = static_cast<int>(dig);
      std::intmax_t base10_exp    = exponent() >= 0 ? static_cast<std::intmax_t>(std::floor(0.30103 * exponent())) : static_cast<std::intmax_t>(std::ceil(0.30103 * exponent()));
      //
      // For fixed formatting we want /dig/ digits after the decimal point,
      // so if the exponent is zero, allowing for the one digit before the
      // decimal point, we want 1 + dig digits etc.
      //
      if (fixed)
         digits_wanted += 1 + base10_exp;
      if (scientific)
         digits_wanted += 1;
      if (digits_wanted < -1)
      {
         // Fixed precision, no significant digits, and nothing to round!
         s = "0";
         if (sign())
            s.insert(static_cast<std::string::size_type>(0), 1, '-');
         boost::multiprecision::detail::format_float_string(s, base10_exp, dig, f, true);
         return s;
      }
      //
      // power10 is the base10 exponent we need to multiply/divide by in order
      // to convert our denormalised number to an integer with the right number of digits:
      //
      std::intmax_t power10 = digits_wanted - base10_exp - 1;
      //
      // If we calculate 5^power10 rather than 10^power10 we need to move
      // 2^power10 into /shift/
      //
      shift -= power10;
      cpp_int               i;
      int                   roundup   = 0; // 0=no rounding, 1=tie, 2=up
      constexpr std::size_t limb_bits = sizeof(limb_type) * CHAR_BIT;
      //
      // Set our working precision - this is heuristic based, we want
      // a value as small as possible > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count to avoid large computations
      // and excessive memory usage, but we also want to avoid having to
      // up the computation and start again at a higher precision.
      // So we round cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count up to the nearest whole number of limbs, and add
      // one limb for good measure.  This works very well for small exponents,
      // but for larger exponents we add a few extra limbs to max_bits:
      //
#ifdef BOOST_MP_STRESS_IO
      std::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 32;
#else
      std::intmax_t max_bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + ((cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits) ? (limb_bits - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count % limb_bits) : 0) + limb_bits;
      if (power10)
      {
         const std::uintmax_t abs_power10 = static_cast<std::uintmax_t>(boost::multiprecision::detail::abs(power10));
         const std::intmax_t  msb_div8    = static_cast<std::intmax_t>(msb(abs_power10) / 8u);

         max_bits += (msb_div8 * static_cast<std::intmax_t>(limb_bits));
      }
#endif
      do
      {
         std::int64_t  error    = 0;
         std::intmax_t calc_exp = 0;
         //
         // Our integer result is: bits() * 2^-shift * 5^power10
         //
         i = bits();
         if (shift < 0)
         {
            if (power10 >= 0)
            {
               // We go straight to the answer with all integer arithmetic,
               // the result is always exact and never needs rounding:
               BOOST_MP_ASSERT(power10 <= (std::intmax_t)INT_MAX);
               i <<= -shift;
               if (power10)
                  i *= pow(cpp_int(5), static_cast<unsigned>(power10));
            }
            else if (power10 < 0)
            {
               cpp_int d;
               calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(d, cpp_int(5), -power10, max_bits, error);
               shift += calc_exp;
               BOOST_MP_ASSERT(shift < 0); // Must still be true!
               i <<= -shift;
               cpp_int r;
               divide_qr(i, d, i, r);
               roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(r, d, error, i);
               if (roundup < 0)
               {
#ifdef BOOST_MP_STRESS_IO
                  max_bits += 32;
#else
                  max_bits *= 2;
#endif
                  shift = (std::intmax_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
                  continue;
               }
            }
         }
         else
         {
            //
            // Our integer is bits() * 2^-shift * 10^power10
            //
            if (power10 > 0)
            {
               if (power10)
               {
                  cpp_int t;
                  calc_exp = boost::multiprecision::cpp_bf_io_detail::restricted_pow(t, cpp_int(5), power10, max_bits, error);
                  calc_exp += boost::multiprecision::cpp_bf_io_detail::restricted_multiply(i, i, t, max_bits, error);
                  shift -= calc_exp;
               }
               if ((shift < 0) || ((shift == 0) && error))
               {
                  // We only get here if we were asked for a crazy number of decimal digits -
                  // more than are present in a 2^max_bits number.
#ifdef BOOST_MP_STRESS_IO
                  max_bits += 32;
#else
                  max_bits *= 2;
#endif
                  shift = (std::intmax_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
                  continue;
               }
               if (shift)
               {
                  roundup = boost::multiprecision::cpp_bf_io_detail::get_round_mode(i, shift - 1, error);
                  if (roundup < 0)
                  {
#ifdef BOOST_MP_STRESS_IO
                     max_bits += 32;
#else
                     max_bits *= 2;
#endif
                     shift = (std::intmax_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
                     continue;
                  }
                  i >>= shift;
               }
            }
            else
            {
               // We're right shifting, *and* dividing by 5^-power10,
               // so 5^-power10 can never be that large or we'd simply
               // get zero as a result, and that case is already handled above:
               cpp_int r;
               BOOST_MP_ASSERT(-power10 < INT_MAX);
               cpp_int d = pow(cpp_int(5), static_cast<unsigned>(-power10));
               d <<= shift;
               divide_qr(i, d, i, r);
               r <<= 1;
               int c   = r.compare(d);
               roundup = c < 0 ? 0 : c == 0 ? 1 : 2;
            }
         }
         s = i.str(0, std::ios_base::fmtflags(0));
         //
         // Check if we got the right number of digits, this
         // is really a test of whether we calculated the
         // decimal exponent correctly:
         //
         std::intmax_t digits_got = i ? static_cast<std::intmax_t>(s.size()) : 0;
         if (digits_got != digits_wanted)
         {
            base10_exp += digits_got - digits_wanted;
            if (fixed)
               digits_wanted = digits_got; // strange but true.
            power10 = digits_wanted - base10_exp - 1;
            shift   = (std::intmax_t)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - exponent() - 1 - power10;
            if (fixed)
               break;
            roundup = 0;
         }
         else
            break;
      } while (true);
      //
      // Check whether we need to round up: note that we could equally round up
      // the integer /i/ above, but since we need to perform the rounding *after*
      // the conversion to a string and the digit count check, we might as well
      // do it here:
      //
      if ((roundup == 2) || ((roundup == 1) && ((s[s.size() - 1] - '0') & 1)))
      {
         boost::multiprecision::detail::round_string_up_at(s, static_cast<int>(s.size() - 1), base10_exp);
      }

      if (sign())
         s.insert(static_cast<std::string::size_type>(0), 1, '-');

      boost::multiprecision::detail::format_float_string(s, base10_exp, dig, f, false);
   }
   else
   {
      switch (exponent())
      {
      case exponent_zero:
         s = sign() ? "-0" : f & std::ios_base::showpos ? "+0" : "0";
         boost::multiprecision::detail::format_float_string(s, 0, dig, f, true);
         break;
      case exponent_nan:
         s = "nan";
         break;
      case exponent_infinity:
         s = sign() ? "-inf" : f & std::ios_base::showpos ? "+inf" : "inf";
         break;
      }
   }
   return s;
}

} // namespace backends
}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_bin_float/transcendental.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_BIN_FLOAT_TRANSCENDENTAL_HPP
#define BOOST_MP_CPP_BIN_FLOAT_TRANSCENDENTAL_HPP

#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision { namespace backends {

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
void eval_exp_taylor(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   constexpr std::ptrdiff_t bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count;
   //
   // Taylor series for small argument, note returns exp(x) - 1:
   //
   res = limb_type(0);
   cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> num(arg), denom, t;
   denom = limb_type(1);
   eval_add(res, num);

   for (std::size_t k = 2;; ++k)
   {
      eval_multiply(denom, k);
      eval_multiply(num, arg);
      eval_divide(t, num, denom);
      eval_add(res, t);
      if (eval_is_zero(t) || (res.exponent() - bits > t.exponent()))
         break;
   }
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
void eval_exp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   //
   // This is based on MPFR's method, let:
   //
   // n = floor(x / ln(2))
   //
   // Then:
   //
   // r = x - n ln(2) : 0 <= r < ln(2)
   //
   // We can reduce r further by dividing by 2^k, with k ~ sqrt(n),
   // so if:
   //
   // e0 = exp(r / 2^k) - 1
   //
   // With e0 evaluated by taylor series for small arguments, then:
   //
   // exp(x) = 2^n (1 + e0)^2^k
   //
   // Note that to preserve precision we actually square (1 + e0) k times, calculating
   // the result less one each time, i.e.
   //
   // (1 + e0)^2 - 1 = e0^2 + 2e0
   //
   // Then add the final 1 at the end, given that e0 is small, this effectively wipes
   // out the error in the last step.
   //
   using default_ops::eval_add;
   using default_ops::eval_convert_to;
   using default_ops::eval_increment;
   using default_ops::eval_multiply;
   using default_ops::eval_subtract;

   int  type  = eval_fpclassify(arg);
   bool isneg = eval_get_sign(arg) < 0;
   if (type == static_cast<int>(FP_NAN))
   {
      res   = arg;
      errno = EDOM;
      return;
   }
   else if (type == static_cast<int>(FP_INFINITE))
   {
      res = arg;
      if (isneg)
         res = limb_type(0u);
      else
         res = arg;
      return;
   }
   else if (type == static_cast<int>(FP_ZERO))
   {
      res = limb_type(1);
      return;
   }
   cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> t, n;
   if (isneg)
   {
      t = arg;
      t.negate();
      eval_exp(res, t);
      t.swap(res);
      res = limb_type(1);
      eval_divide(res, t);
      return;
   }

   eval_divide(n, arg, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
   eval_floor(n, n);
   eval_multiply(t, n, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
   eval_subtract(t, arg);
   t.negate();
   if (t.compare(default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >()) > 0)
   {
      // There are some rare cases where the multiply rounds down leaving a remainder > ln2
      // See https://github.com/boostorg/multiprecision/issues/120
      eval_increment(n);
      t = limb_type(0);
   }
   if (eval_get_sign(t) < 0)
   {
      // There are some very rare cases where arg/ln2 is an integer, and the subsequent multiply
      // rounds up, in that situation t ends up negative at this point which breaks our invariants below:
      t = limb_type(0);
   }

   Exponent k, nn;
   eval_convert_to(&nn, n);

   if (nn == (std::numeric_limits<Exponent>::max)())
   {
      // The result will necessarily oveflow:
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      return;
   }

   BOOST_MP_ASSERT(t.compare(default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >()) < 0);

   k = nn ? Exponent(1) << (msb(nn) / 2) : 0;
   k = (std::min)(k, (Exponent)(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count / 4));
   eval_ldexp(t, t, -k);

   eval_exp_taylor(res, t);
   //
   // Square 1 + res k times:
   //
   for (Exponent s = 0; s < k; ++s)
   {
      t.swap(res);
      eval_multiply(res, t, t);
      eval_ldexp(t, t, 1);
      eval_add(res, t);
   }
   eval_add(res, limb_type(1));
   eval_ldexp(res, res, nn);
}

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_bin_float.hpp
================================================
////////////////////////////////////////////////////////////////
//  Copyright 2013 - 2022 John Maddock.
//  Copyright 2022 Christopher Kormanyos.
//  Distributed under the Boost Software License,
//  Version 1.0. (See accompanying file LICENSE_1_0.txt
//  or copy at https://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_CPP_BIN_FLOAT_HPP
#define BOOST_MP_CPP_BIN_FLOAT_HPP

#include <cmath>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/integer.hpp>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <boost/multiprecision/detail/float_string_cvt.hpp>
#include <boost/multiprecision/traits/max_digits10.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/functions/trunc.hpp>

//
// Some includes we need from Boost.Math, since we rely on that library to provide these functions:
//
#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/asinh.hpp>
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/atanh.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/special_functions/gamma.hpp>
#endif

#ifdef BOOST_HAS_FLOAT128
#include <quadmath.h>
#endif

namespace boost {
namespace multiprecision {
namespace backends {

enum digit_base_type
{
   digit_base_2  = 2,
   digit_base_10 = 10
};

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4522 6326) // multiple assignment operators specified, comparison of two constants
#endif

namespace detail {

template <class U>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<U>::value, bool>::type is_negative(U) { return false; }
template <class S>
inline typename std::enable_if< !boost::multiprecision::detail::is_unsigned<S>::value, bool>::type is_negative(S s) { return s < 0; }

template <class Float, std::ptrdiff_t, bool = number_category<Float>::value == number_kind_floating_point>
struct is_cpp_bin_float_implicitly_constructible_from_type
{
   static constexpr bool value = false;
};

template <class Float, std::ptrdiff_t bit_count>
struct is_cpp_bin_float_implicitly_constructible_from_type<Float, bit_count, true>
{
   static constexpr bool value = (std::numeric_limits<Float>::digits <= static_cast<int>(bit_count)) && (std::numeric_limits<Float>::radix == 2) && std::numeric_limits<Float>::is_specialized
#ifdef BOOST_HAS_FLOAT128
                             && !std::is_same<Float, float128_type>::value
#endif
                             && (std::is_floating_point<Float>::value || is_number<Float>::value);
};

template <class Float, std::ptrdiff_t, bool = number_category<Float>::value == number_kind_floating_point>
struct is_cpp_bin_float_explicitly_constructible_from_type
{
   static constexpr bool value = false;
};

template <class Float, std::ptrdiff_t bit_count>
struct is_cpp_bin_float_explicitly_constructible_from_type<Float, bit_count, true>
{
   static constexpr bool value = (std::numeric_limits<Float>::digits > static_cast<int>(bit_count)) && (std::numeric_limits<Float>::radix == 2) && std::numeric_limits<Float>::is_specialized
#ifdef BOOST_HAS_FLOAT128
                             && !std::is_same<Float, float128_type>::value
#endif
       ;
};

} // namespace detail

template <unsigned Digits, digit_base_type DigitBase = digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0>
class cpp_bin_float
{
 public:
   static constexpr unsigned bit_count = DigitBase == digit_base_2 ? Digits : (Digits * 1000uL) / 301uL + (((Digits * 1000uL) % 301) ? 2u : 1u);
   using rep_type = cpp_int_backend<std::is_void<Allocator>::value ? bit_count : 0, bit_count, std::is_void<Allocator>::value ? unsigned_magnitude : signed_magnitude, unchecked, Allocator>;
   using double_rep_type = cpp_int_backend<std::is_void<Allocator>::value ? 2 * bit_count : 0, 2 * bit_count, std::is_void<Allocator>::value ? unsigned_magnitude : signed_magnitude, unchecked, Allocator>;

   using signed_types = typename rep_type::signed_types;
   using unsigned_types = typename rep_type::unsigned_types;
   using float_types = std::tuple<float, double, long double>;
   using exponent_type = Exponent;

   static constexpr exponent_type max_exponent_limit = (std::numeric_limits<exponent_type>::max)()- 2 * static_cast<exponent_type>(bit_count);
   static constexpr exponent_type min_exponent_limit = (std::numeric_limits<exponent_type>::min)() + 2 * static_cast<exponent_type>(bit_count);

   static_assert(MinExponent >= min_exponent_limit, "Template parameter MinExponent is too negative for our internal logic to function correctly, sorry!");
   static_assert(MaxExponent <= max_exponent_limit, "Template parameter MaxExponent is too large for our internal logic to function correctly, sorry!");
   static_assert(MinExponent <= 0, "Template parameter MinExponent can not be positive!");
   static_assert(MaxExponent >= 0, "Template parameter MaxExponent can not be negative!");

   static constexpr exponent_type max_exponent = MaxExponent == 0 ? max_exponent_limit : MaxExponent;
   static constexpr exponent_type min_exponent = MinExponent == 0 ? min_exponent_limit : MinExponent;

   static constexpr exponent_type exponent_zero     = max_exponent + 1;
   static constexpr exponent_type exponent_infinity = max_exponent + 2;
   static constexpr exponent_type exponent_nan      = max_exponent + 3;

 private:
   rep_type      m_data;
   exponent_type m_exponent;
   bool          m_sign;

 public:
   cpp_bin_float() noexcept(noexcept(rep_type())) : m_data(), m_exponent(exponent_zero), m_sign(false) {}

   cpp_bin_float(const cpp_bin_float& o) noexcept(noexcept(rep_type(std::declval<const rep_type&>())))
       : m_data(o.m_data), m_exponent(o.m_exponent), m_sign(o.m_sign) {}

   template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
   cpp_bin_float(const cpp_bin_float<D, B, A, E, MinE, MaxE>& o, typename std::enable_if<(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = nullptr)
   {
      *this = o;
   }
   template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
   explicit cpp_bin_float(const cpp_bin_float<D, B, A, E, MinE, MaxE>& o, typename std::enable_if< !(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = nullptr)
       : m_exponent(o.exponent()), m_sign(o.sign())
   {
      *this = o;
   }
   // rvalue copy:
   template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
   cpp_bin_float(cpp_bin_float<D, B, A, E, MinE, MaxE>&& o, typename std::enable_if<(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = nullptr)noexcept(noexcept(rep_type(std::declval<rep_type&&>())))
   {
      *this = std::move(o);
   }
   template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
   explicit cpp_bin_float(cpp_bin_float<D, B, A, E, MinE, MaxE>&& o, typename std::enable_if< !(bit_count >= cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count)>::type const* = nullptr) noexcept(noexcept(rep_type(std::declval<rep_type&&>())))
       : m_exponent(o.exponent()), m_sign(o.sign())
   {
      *this = std::move(o);
   }
   template <class Float>
   cpp_bin_float(const Float& f,
                 typename std::enable_if<detail::is_cpp_bin_float_implicitly_constructible_from_type<Float, static_cast<std::ptrdiff_t>(bit_count)>::value>::type const* = nullptr)
       : m_data(), m_exponent(0), m_sign(false)
   {
      this->assign_float(f);
   }

   template <class Float>
   explicit cpp_bin_float(const Float& f,
                          typename std::enable_if<detail::is_cpp_bin_float_explicitly_constructible_from_type<Float, static_cast<std::ptrdiff_t>(bit_count)>::value>::type const* = nullptr)
       : m_data(), m_exponent(0), m_sign(false)
   {
      this->assign_float(f);
   }
#ifdef BOOST_HAS_FLOAT128
   template <class Float>
   cpp_bin_float(const Float& f,
                 typename std::enable_if<
                     std::is_same<Float, float128_type>::value && (static_cast<int>(bit_count) >= 113)>::type const* = nullptr)
       : m_data(), m_exponent(0), m_sign(false)
   {
      this->assign_float(f);
   }
   template <class Float>
   explicit cpp_bin_float(const Float& f,
                          typename std::enable_if<
                              std::is_same<Float, float128_type>::value && (static_cast<int>(bit_count) < 113)>::type const* = nullptr)
       : m_data(), m_exponent(0), m_sign(false)
   {
      this->assign_float(f);
   }
#endif
   cpp_bin_float& operator=(const cpp_bin_float& o) noexcept(noexcept(std::declval<rep_type&>() = std::declval<const rep_type&>()))
   {
      m_data     = o.m_data;
      m_exponent = o.m_exponent;
      m_sign     = o.m_sign;
      return *this;
   }

   template <class A, class E, E MinE, E MaxE>
   cpp_bin_float& operator=(const cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>& o) noexcept(noexcept(std::declval<rep_type&>() = std::declval<const rep_type&>()))
   {
      m_data     = o.bits();
      m_sign     = o.sign();
      if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_zero)
         m_exponent = exponent_zero;
      else if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_nan)
         m_exponent = exponent_nan;
      else if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_infinity)
         m_exponent = exponent_infinity;
      else if (o.exponent() > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
      {
         // Overflow:
         exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
         bits() = static_cast<limb_type>(0u);
      }
      else if (o.exponent() < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
      {
         // Underflow:
         exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
         bits() = static_cast<limb_type>(0u);
      }
      else
         m_exponent = o.exponent();
      return *this;
   }
   // rvalue copy:
   template <class A, class E, E MinE, E MaxE>
   cpp_bin_float& operator=(cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>&& o) noexcept(noexcept(std::declval<rep_type&>() = std::declval<rep_type&&>()))
   {
      m_data     = std::move(o.bits());
      m_sign     = o.sign();
      if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_zero)
         m_exponent = exponent_zero;
      else if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_nan)
         m_exponent = exponent_nan;
      else if (o.exponent() == cpp_bin_float<Digits, DigitBase, A, E, MinE, MaxE>::exponent_infinity)
         m_exponent = exponent_infinity;
      else if (o.exponent() > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
      {
         // Overflow:
         exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
         bits() = static_cast<limb_type>(0u);
      }
      else if (o.exponent() < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
      {
         // Underflow:
         exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
         bits() = static_cast<limb_type>(0u);
      }
      else
         m_exponent = o.exponent();
      return *this;
   }
   template <unsigned D, digit_base_type B, class A, class E, E MinE, E MaxE>
   cpp_bin_float& operator=(const cpp_bin_float<D, B, A, E, MinE, MaxE>& f)
   {
      switch (eval_fpclassify(f))
      {
      case FP_ZERO:
         m_data     = limb_type(0);
         m_sign     = f.sign();
         m_exponent = exponent_zero;
         break;
      case FP_NAN:
         m_data     = limb_type(0);
         m_sign     = false;
         m_exponent = exponent_nan;
         break;
         ;
      case FP_INFINITE:
         m_data     = limb_type(0);
         m_sign     = f.sign();
         m_exponent = exponent_infinity;
         break;
      default:
         typename cpp_bin_float<D, B, A, E, MinE, MaxE>::rep_type b(f.bits());
         this->exponent() = f.exponent() + (E)bit_count - (E)cpp_bin_float<D, B, A, E, MinE, MaxE>::bit_count;
         this->sign()     = f.sign();
         copy_and_round(*this, b);
      }
      return *this;
   }
#ifdef BOOST_HAS_FLOAT128
   template <class Float>
   typename std::enable_if<
       (number_category<Float>::value == number_kind_floating_point)
           //&& (std::numeric_limits<Float>::digits <= static_cast<int>(bit_count))
           && ((std::numeric_limits<Float>::radix == 2) || (std::is_same<Float, float128_type>::value)),
       cpp_bin_float&>::type
   operator=(const Float& f)
#else
   template <class Float>
   typename std::enable_if<
       (number_category<Float>::value == number_kind_floating_point)
           //&& (std::numeric_limits<Float>::digits <= static_cast<int>(bit_count))
           && (std::numeric_limits<Float>::radix == 2),
       cpp_bin_float&>::type
   operator=(const Float& f)
#endif
   {
      return assign_float(f);
   }

#ifdef BOOST_HAS_FLOAT128
   template <class Float>
   typename std::enable_if<std::is_same<Float, float128_type>::value, cpp_bin_float&>::type assign_float(Float f)
   {
      using default_ops::eval_add;
      using bf_int_type = typename boost::multiprecision::detail::canonical<int, cpp_bin_float>::type;
      if (f == 0)
      {
         m_data     = limb_type(0);
         m_sign     = (signbitq(f) > 0);
         m_exponent = exponent_zero;
         return *this;
      }
      else if (isnanq(f))
      {
         m_data     = limb_type(0);
         m_sign     = false;
         m_exponent = exponent_nan;
         return *this;
      }
      else if (isinfq(f))
      {
         m_data     = limb_type(0);
         m_sign     = (f < 0);
         m_exponent = exponent_infinity;
         return *this;
      }
      if (f < 0)
      {
         *this = -f;
         this->negate();
         return *this;
      }

      using ui_type = typename std::tuple_element<0, unsigned_types>::type;
      m_data     = static_cast<ui_type>(0u);
      m_sign     = false;
      m_exponent = 0;

      constexpr std::ptrdiff_t bits = sizeof(int) * CHAR_BIT - 1;
      int              e;
      f = frexpq(f, &e);
      while (f)
      {
         f = ldexpq(f, bits);
         e -= bits;
         int ipart = static_cast<int>(truncq(f));
         f -= ipart;
         m_exponent += bits;
         cpp_bin_float t;
         t = static_cast<bf_int_type>(ipart);
         eval_add(*this, t);
      }
      m_exponent += static_cast<Exponent>(e);
      return *this;
   }
#endif
#ifdef BOOST_HAS_FLOAT128
   template <class Float>
   typename std::enable_if<std::is_floating_point<Float>::value && !std::is_same<Float, float128_type>::value, cpp_bin_float&>::type assign_float(Float f)
#else
   template <class Float>
   typename std::enable_if<std::is_floating_point<Float>::value, cpp_bin_float&>::type assign_float(Float f)
#endif
   {
      using std::frexp;
      using std::ldexp;
      using std::signbit;
      using default_ops::eval_add;
      using bf_int_type = typename boost::multiprecision::detail::canonical<int, cpp_bin_float>::type;

      switch (BOOST_MP_FPCLASSIFY(f))
      {
      case FP_ZERO:
         m_data     = limb_type(0);
         m_sign     = ((signbit)(f));
         m_exponent = exponent_zero;
         return *this;
      case FP_NAN:
         m_data     = limb_type(0);
         m_sign     = false;
         m_exponent = exponent_nan;
         return *this;
      case FP_INFINITE:
         m_data     = limb_type(0);
         m_sign     = (f < 0);
         m_exponent = exponent_infinity;
         return *this;
      }
      if (f < 0)
      {
         *this = -f;
         this->negate();
         return *this;
      }

      using ui_type = typename std::tuple_element<0, unsigned_types>::type;
      m_data     = static_cast<ui_type>(0u);
      m_sign     = false;
      m_exponent = 0;

      constexpr std::ptrdiff_t bits = sizeof(int) * CHAR_BIT - 1;
      int e;
      f = frexp(f, &e);
      while (f != static_cast<Float>(0.0F))
      {
         f = ldexp(f, bits);
         e -= static_cast<int>(bits);
         int ipart = boost::multiprecision::detail::itrunc(f);
         f -= static_cast<Float>(ipart);
         m_exponent += static_cast<exponent_type>(bits);
         cpp_bin_float t;
         t = static_cast<bf_int_type>(ipart);
         eval_add(*this, t);
      }
      m_exponent += static_cast<Exponent>(e);
      return *this;
   }

   template <class Float>
   typename std::enable_if<
       (number_category<Float>::value == number_kind_floating_point) && !std::is_floating_point<Float>::value && (number_category<Float>::value == number_kind_floating_point),
       cpp_bin_float&>::type
   assign_float(Float f)
   {
      using default_ops::eval_add;
      using default_ops::eval_convert_to;
      using default_ops::eval_get_sign;
      using default_ops::eval_subtract;

      using f_int_type = typename boost::multiprecision::detail::canonical<int, Float>::type        ;
      using bf_int_type = typename boost::multiprecision::detail::canonical<int, cpp_bin_float>::type;

      switch (eval_fpclassify(f))
      {
      case FP_ZERO:
         m_data     = limb_type(0);
         m_sign     = (eval_get_sign(f) > 0);
         m_exponent = exponent_zero;
         return *this;
      case FP_NAN:
         m_data     = limb_type(0);
         m_sign     = false;
         m_exponent = exponent_nan;
         return *this;
      case FP_INFINITE:
         m_data     = limb_type(0);
         m_sign     = eval_get_sign(f) < 0;
         m_exponent = exponent_infinity;
         return *this;
      }
      if (eval_get_sign(f) < 0)
      {
         f.negate();
         assign_float(f);
         this->negate();
         return *this;
      }

      using ui_type = typename std::tuple_element<0, unsigned_types>::type;
      m_data     = static_cast<ui_type>(0u);
      m_sign     = false;
      m_exponent = 0;

      constexpr std::ptrdiff_t bits = sizeof(int) * CHAR_BIT - 1;
      int              e;
      eval_frexp(f, f, &e);
      while (eval_get_sign(f) != 0)
      {
         eval_ldexp(f, f, bits);
         e -= bits;
         int ipart;
         eval_convert_to(&ipart, f);
         eval_subtract(f, static_cast<f_int_type>(ipart));
         m_exponent += bits;
         eval_add(*this, static_cast<bf_int_type>(ipart));
      }
      m_exponent += e;
      if (m_exponent > max_exponent)
         m_exponent = exponent_infinity;
      if (m_exponent < min_exponent)
      {
         m_data     = limb_type(0u);
         m_exponent = exponent_zero;
         m_sign     = (eval_get_sign(f) > 0);
      }
      else if (eval_get_sign(m_data) == 0)
      {
         m_exponent = exponent_zero;
         m_sign     = (eval_get_sign(f) > 0);
      }
      return *this;
   }
   template <class B, expression_template_option et>
   cpp_bin_float& assign_float(const number<B, et>& f)
   {
      return assign_float(f.backend());
   }
   
   template <class I>
   typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value, cpp_bin_float&>::type operator=(const I& i)
   {
      using default_ops::eval_bit_test;
      if (!i)
      {
         m_data     = static_cast<limb_type>(0);
         m_exponent = exponent_zero;
         m_sign     = false;
      }
      else
      {
         using ui_type = typename boost::multiprecision::detail::make_unsigned<I>::type                                      ;
         ui_type                                                                            fi = static_cast<ui_type>(boost::multiprecision::detail::unsigned_abs(i));
         using ar_type = typename boost::multiprecision::detail::canonical<ui_type, rep_type>::type;
         m_data         = static_cast<ar_type>(fi);
         std::size_t shift = msb(fi);
         if (shift >= bit_count)
         {
            m_exponent = static_cast<Exponent>(shift);
            m_data     = static_cast<ar_type>(fi >> (shift + 1 - bit_count));
         }
         else
         {
            m_exponent = static_cast<Exponent>(shift);
            eval_left_shift(m_data, bit_count - shift - 1);
         }
         BOOST_MP_ASSERT(eval_bit_test(m_data, bit_count - 1));
         m_sign = detail::is_negative(i);
      }
      return *this;
   }

   cpp_bin_float& operator=(const char* s);

   void swap(cpp_bin_float& o) noexcept
   {
      m_data.swap(o.m_data);
      std::swap(m_exponent, o.m_exponent);
      std::swap(m_sign, o.m_sign);
   }

   std::string str(std::streamsize dig, std::ios_base::fmtflags f) const;

   void negate()
   {
      if (m_exponent != exponent_nan)
         m_sign = !m_sign;
   }

   int compare(const cpp_bin_float& o) const noexcept
   {
      if (m_sign != o.m_sign)
         return (m_exponent == exponent_zero) && (m_exponent == o.m_exponent) ? 0 : m_sign ? -1 : 1;
      int result;
      if (m_exponent == exponent_nan)
         return -1;
      else if (m_exponent != o.m_exponent)
      {
         if (m_exponent == exponent_zero)
            result = -1;
         else if (o.m_exponent == exponent_zero)
            result = 1;
         else
            result = m_exponent > o.m_exponent ? 1 : -1;
      }
      else
         result = m_data.compare(o.m_data);
      if (m_sign)
         result = -result;
      return result;
   }
   template <class A>
   int compare(const A& o) const noexcept
   {
      cpp_bin_float b;
      b = o;
      return compare(b);
   }

   rep_type&            bits() { return m_data; }
   const rep_type&      bits() const { return m_data; }
   exponent_type&       exponent() { return m_exponent; }
   const exponent_type& exponent() const { return m_exponent; }
   bool&                sign() { return m_sign; }
   const bool&          sign() const { return m_sign; }
   void                 check_invariants()
   {
      using default_ops::eval_bit_test;
      using default_ops::eval_is_zero;
      if ((m_exponent <= max_exponent) && (m_exponent >= min_exponent))
      {
         BOOST_MP_ASSERT(eval_bit_test(m_data, bit_count - 1));
      }
      else
      {
         BOOST_MP_ASSERT(m_exponent > max_exponent);
         BOOST_MP_ASSERT(m_exponent <= exponent_nan);
         BOOST_MP_ASSERT(eval_is_zero(m_data));
      }
   }

   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      ar& boost::make_nvp("data", m_data);
      ar& boost::make_nvp("exponent", m_exponent);
      ar& boost::make_nvp("sign", m_sign);
   }
   #endif
};

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class Int>
inline void copy_and_round(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, Int& arg, std::ptrdiff_t bits_to_keep = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
{
   // Precondition: exponent of res must have been set before this function is called
   // as we may need to adjust it based on how many bits_to_keep in arg are set.
   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_increment;
   using default_ops::eval_left_shift;
   using default_ops::eval_lsb;
   using default_ops::eval_msb;
   using default_ops::eval_right_shift;

   // cancellation may have resulted in arg being all zeros:
   if (eval_get_sign(arg) == 0)
   {
      res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
      res.sign()     = false;
      res.bits()     = static_cast<limb_type>(0u);
      return;
   }
   std::ptrdiff_t msb = static_cast<std::ptrdiff_t>(eval_msb(arg));
   if (static_cast<std::ptrdiff_t >(bits_to_keep) > msb + 1)
   {
      // Must have had cancellation in subtraction,
      // or be converting from a narrower type, so shift left:
      res.bits() = arg;
      eval_left_shift(res.bits(), static_cast<double_limb_type>(bits_to_keep - msb - 1));
      res.exponent() -= static_cast<Exponent>(bits_to_keep - msb - 1);
   }
   else if (static_cast<std::ptrdiff_t >(bits_to_keep) < msb + 1)
   {
      // We have more bits_to_keep than we need, so round as required,
      // first get the rounding bit:
      bool roundup = eval_bit_test(arg, static_cast<std::size_t>(msb - bits_to_keep));
      // Then check for a tie:
      if (roundup && (msb - bits_to_keep == static_cast<std::ptrdiff_t>(eval_lsb(arg))))
      {
         // Ties round towards even:
         if (!eval_bit_test(arg, static_cast<std::size_t>(msb - bits_to_keep + 1)))
            roundup = false;
      }
      // Shift off the bits_to_keep we don't need:
      eval_right_shift(arg, static_cast<double_limb_type>(msb - bits_to_keep + 1));
      res.exponent() += static_cast<Exponent>(msb - bits_to_keep + 1);
      if (roundup)
      {
         eval_increment(arg);
         if (bits_to_keep)
         {
            if (eval_bit_test(arg, static_cast<std::size_t>(bits_to_keep)))
            {
               // This happens very very rairly, all the bits left after
               // truncation must be 1's and we're rounding up an order of magnitude:
               eval_right_shift(arg, 1u);
               ++res.exponent();
            }
         }
         else
         {
            // We get here when bits_to_keep is zero but we're rounding up,
            // as a result we end up with a single digit that is a 1:
            ++bits_to_keep;
         }
      }
      if (bits_to_keep != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
      {
         // Normalize result when we're rounding to fewer bits than we can hold, only happens in conversions
         // to narrower types:
         eval_left_shift(arg, static_cast<double_limb_type>(static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - bits_to_keep));
         res.exponent() -= static_cast<Exponent>(static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - bits_to_keep);
      }
      res.bits() = arg;
   }
   else
   {
      res.bits() = arg;
   }
   if (!bits_to_keep && !res.bits().limbs()[0])
   {
      // We're keeping zero bits and did not round up, so result is zero:
      res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
      return;
   }
   // Result must be normalized:
   BOOST_MP_ASSERT(((std::ptrdiff_t )eval_msb(res.bits()) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));

   if (res.exponent() > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent)
   {
      // Overflow:
      res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
      res.bits()     = static_cast<limb_type>(0u);
   }
   else if (res.exponent() < cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent)
   {
      // Underflow:
      res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
      res.bits()     = static_cast<limb_type>(0u);
   }
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class BinFloat2, class BinFloat3>
inline void do_eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const BinFloat2& a, const BinFloat3& b)
{
   if (a.exponent() < b.exponent())
   {
      bool s = a.sign();
      do_eval_add(res, b, a);
      if (res.sign() != s)
         res.negate();
      return;
   }

   using default_ops::eval_add;
   using default_ops::eval_bit_test;

   using exponent_type = typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type;

   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;

   // Special cases first:
   switch (a.exponent())
   {
   case BinFloat2::exponent_zero:
   {
      bool s     = a.sign();
      res        = b;
      res.sign() = s;
      return;
   }
   case BinFloat2::exponent_infinity:
      if (b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan)
         res = b;
      else
         res = a;
      return; // result is still infinite.
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      res = a;
      return; // result is still a NaN.
   }
   switch (b.exponent())
   {
   case BinFloat3::exponent_zero:
      res = a;
      return;
   case BinFloat3::exponent_infinity:
      res = b;
      if (res.sign())
         res.negate();
      return; // result is infinite.
   case BinFloat3::exponent_nan:
      res = b;
      return; // result is a NaN.
   }

   static_assert((std::numeric_limits<exponent_type>::max)() - cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count > cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent, "Exponent range check failed");

   bool s = a.sign();
   dt     = a.bits();
   if (a.exponent() > (std::ptrdiff_t )cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + b.exponent())
   {
      res.exponent() = a.exponent();
   }
   else
   {
      exponent_type e_diff = a.exponent() - b.exponent();
      BOOST_MP_ASSERT(e_diff >= 0);
      eval_left_shift(dt, static_cast<double_limb_type>(e_diff));
      res.exponent() = a.exponent() - e_diff;
      eval_add(dt, b.bits());
   }

   copy_and_round(res, dt);
   res.check_invariants();
   if (res.sign() != s)
      res.negate();
}

template <class BinFloat1, class BinFloat2, class BinFloat3>
inline void do_eval_subtract(BinFloat1& res, const BinFloat2& a, const BinFloat3& b)
{
   using default_ops::eval_bit_test;
   using default_ops::eval_decrement;
   using default_ops::eval_subtract;

   typename BinFloat1::double_rep_type dt;

   // Special cases first:
   switch (a.exponent())
   {
   case BinFloat2::exponent_zero:
      if (b.exponent() == BinFloat3::exponent_nan)
         res = std::numeric_limits<number<BinFloat1> >::quiet_NaN().backend();
      else
      {
         bool s = a.sign();
         res    = b;
         if (res.exponent() == BinFloat1::exponent_zero)
            res.sign() = false;
         else if (res.sign() == s)
            res.negate();
      }
      return;
   case BinFloat2::exponent_infinity:
      if ((b.exponent() == BinFloat3::exponent_nan) || (b.exponent() == BinFloat3::exponent_infinity))
         res = std::numeric_limits<number<BinFloat1> >::quiet_NaN().backend();
      else
         res = a;
      return;
   case BinFloat2::exponent_nan:
      res = a;
      return; // result is still a NaN.
   }
   switch (b.exponent())
   {
   case BinFloat3::exponent_zero:
      res = a;
      return;
   case BinFloat3::exponent_infinity:
      res.exponent() = BinFloat1::exponent_infinity;
      res.sign()     = !a.sign();
      res.bits()     = static_cast<limb_type>(0u);
      return; // result is a NaN.
   case BinFloat3::exponent_nan:
      res = b;
      return; // result is still a NaN.
   }

   bool s = a.sign();
   if ((a.exponent() > b.exponent()) || ((a.exponent() == b.exponent()) && a.bits().compare(b.bits()) >= 0))
   {
      dt = a.bits();
      if (a.exponent() <= (std::ptrdiff_t )BinFloat1::bit_count + b.exponent())
      {
         typename BinFloat1::exponent_type e_diff = a.exponent() - b.exponent();
         eval_left_shift(dt, static_cast<double_limb_type>(e_diff));
         res.exponent() = a.exponent() - e_diff;
         eval_subtract(dt, b.bits());
      }
      else if (a.exponent() == (std::ptrdiff_t )BinFloat1::bit_count + b.exponent() + 1)
      {
         if ((eval_lsb(a.bits()) == BinFloat1::bit_count - 1)
            && (eval_lsb(b.bits()) != BinFloat1::bit_count - 1))
         {
            eval_left_shift(dt, 1);
            eval_decrement(dt);
            res.exponent() = a.exponent() - 1;
         }
         else
            res.exponent() = a.exponent();
      }
      else
         res.exponent() = a.exponent();
   }
   else
   {
      dt = b.bits();
      if (b.exponent() <= (std::ptrdiff_t )BinFloat1::bit_count + a.exponent())
      {
         typename BinFloat1::exponent_type e_diff = a.exponent() - b.exponent();
         eval_left_shift(dt, static_cast<double_limb_type>(-e_diff));
         res.exponent() = b.exponent() + e_diff;
         eval_subtract(dt, a.bits());
      }
      else if (b.exponent() == (std::ptrdiff_t )BinFloat1::bit_count + a.exponent() + 1)
      {
         if ((eval_lsb(a.bits()) != BinFloat1::bit_count - 1)
            && eval_lsb(b.bits()))
         {
            eval_left_shift(dt, 1);
            eval_decrement(dt);
            res.exponent() = b.exponent() - 1;
         }
         else
            res.exponent() = b.exponent();
      }
      else
         res.exponent() = b.exponent();
      s = !s;
   }

   copy_and_round(res, dt);
   if (res.exponent() == BinFloat1::exponent_zero)
      res.sign() = false;
   else if (res.sign() != s)
      res.negate();
   res.check_invariants();
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, 
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2,
   class Allocator3, class Exponent3, Exponent MinE3, Exponent MaxE3>
inline void eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a, 
   const cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>& b)
{
   if (a.sign() == b.sign())
      do_eval_add(res, a, b);
   else
      do_eval_subtract(res, a, b);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_add(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a)
{
   return eval_add(res, res, a);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2,
   class Allocator3, class Exponent3, Exponent MinE3, Exponent MaxE3>
inline void eval_subtract(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a, 
   const cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>& b)
{
   if (a.sign() != b.sign())
      do_eval_add(res, a, b);
   else
      do_eval_subtract(res, a, b);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_subtract(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a)
{
   return eval_subtract(res, res, a);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, 
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2, 
   class Allocator3, class Exponent3, Exponent MinE3, Exponent MaxE3>
inline void eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a, 
   const cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>& b)
{
   using default_ops::eval_bit_test;
   using default_ops::eval_multiply;

   // Special cases first:
   switch (a.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_zero:
   {
      if (b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_nan)
         res = b;
      else if (b.exponent() == cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_infinity)
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      else
      {
         bool s     = a.sign() != b.sign();
         res        = a;
         res.sign() = s;
      }
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_infinity:
      switch (b.exponent())
      {
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_zero:
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
         break;
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_nan:
         res = b;
         break;
      default:
         bool s     = a.sign() != b.sign();
         res        = a;
         res.sign() = s;
         break;
      }
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_nan:
      res = a;
      return;
   }
   if (b.exponent() > cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::max_exponent)
   {
      bool s     = a.sign() != b.sign();
      res        = b;
      res.sign() = s;
      return;
   }
   if ((a.exponent() > 0) && (b.exponent() > 0))
   {
      if (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent + 2 - a.exponent() < b.exponent())
      {
         // We will certainly overflow:
         bool s         = a.sign() != b.sign();
         res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
         res.sign()     = s;
         res.bits()     = static_cast<limb_type>(0u);
         return;
      }
   }
   if ((a.exponent() < 0) && (b.exponent() < 0))
   {
      if (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent - 2 - a.exponent() > b.exponent())
      {
         // We will certainly underflow:
         res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
         res.sign()     = a.sign() != b.sign();
         res.bits()     = static_cast<limb_type>(0u);
         return;
      }
   }

   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type dt;
   eval_multiply(dt, a.bits(), b.bits());
   res.exponent() = a.exponent() + b.exponent() - (Exponent)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count + 1;
   copy_and_round(res, dt);
   res.check_invariants();
   res.sign() = a.sign() != b.sign();
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a)
{
   eval_multiply(res, res, a);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2, class U>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<U>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a, const U& b)
{
   using default_ops::eval_bit_test;
   using default_ops::eval_multiply;

   bool s = a.sign(); // saved for later in case a and res are the same object.

   // Special cases first:
   switch (a.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_zero:
   {
      res        = a;
      res.sign() = s;
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_infinity:
      if (b == 0)
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      else
         res = a;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_nan:
      res = a;
      return;
   }

   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type                                                                     dt;
   using canon_ui_type = typename boost::multiprecision::detail::canonical<U, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::type;
   eval_multiply(dt, a.bits(), static_cast<canon_ui_type>(b));
   res.exponent() = a.exponent();
   copy_and_round(res, dt);
   res.check_invariants();
   res.sign() = s;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<U>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const U& b)
{
   eval_multiply(res, res, b);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2, class S>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& a, const S& b)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
   eval_multiply(res, a, static_cast<ui_type>(boost::multiprecision::detail::unsigned_abs(b)));
   if (b < 0)
      res.negate();
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value>::type eval_multiply(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const S& b)
{
   eval_multiply(res, res, b);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2,
   class Allocator3, class Exponent3, Exponent MinE3, Exponent MaxE3>
inline void eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& u, 
   const cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>& v)
{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326) // comparison of two constants
#endif
   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_increment;
   using default_ops::eval_qr;
   using default_ops::eval_subtract;

   //
   // Special cases first:
   //
   switch (u.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_zero:
   {
      switch (v.exponent())
      {
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_zero:
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_nan:
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
         return;
      }
      bool s     = u.sign() != v.sign();
      res        = u;
      res.sign() = s;
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_infinity:
   {
      switch (v.exponent())
      {
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_infinity:
      case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_nan:
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
         return;
      }
      bool s     = u.sign() != v.sign();
      res        = u;
      res.sign() = s;
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_nan:
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      return;
   }
   switch (v.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_zero:
   {
      bool s     = u.sign() != v.sign();
      res        = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      res.sign() = s;
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_infinity:
      res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
      res.bits()     = limb_type(0);
      res.sign()     = u.sign() != v.sign();
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator3, Exponent3, MinE3, MaxE3>::exponent_nan:
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      return;
   }

   // We can scale u and v so that both are integers, then perform integer
   // division to obtain quotient q and remainder r, such that:
   //
   // q * v + r = u
   //
   // and hense:
   //
   // q + r/v = u/v
   //
   // From this, assuming q has cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count
   // bits we only need to determine whether
   // r/v is less than, equal to, or greater than 0.5 to determine rounding -
   // this we can do with a shift and comparison.
   //
   // We can set the exponent and sign of the result up front:
   //
   if ((v.exponent() < 0) && (u.exponent() > 0))
   {
      // Check for overflow:
      if (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent + v.exponent() < u.exponent() - 1)
      {
         res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
         res.sign()     = u.sign() != v.sign();
         res.bits()     = static_cast<limb_type>(0u);
         return;
      }
   }
   else if ((v.exponent() > 0) && (u.exponent() < 0))
   {
      // Check for underflow:
      if (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent + v.exponent() > u.exponent())
      {
         // We will certainly underflow:
         res.exponent() = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
         res.sign()     = u.sign() != v.sign();
         res.bits()     = static_cast<limb_type>(0u);
         return;
      }
   }
   res.exponent() = u.exponent() - v.exponent() - 1;
   res.sign()     = u.sign() != v.sign();
   //
   // Now get the quotient and remainder:
   //
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(u.bits()), t2(v.bits()), q, r;
   eval_left_shift(t, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count);
   eval_qr(t, t2, q, r);
   //
   // We now have either "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count"
   // or "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1" significant
   // bits in q.
   //
   constexpr unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
   if (eval_bit_test(q, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
   {
      //
      // OK we have cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1 bits,
      // so we already have rounding info,
      // we just need to changes things if the last bit is 1 and either the
      // remainder is non-zero (ie we do not have a tie) or the quotient would
      // be odd if it were shifted to the correct number of bits (ie a tiebreak).
      //
      BOOST_MP_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count));
      if ((q.limbs()[0] & 1u) && (eval_get_sign(r) || (q.limbs()[0] & 2u)))
      {
         eval_increment(q);
      }
   }
   else
   {
      //
      // We have exactly "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" bits in q.
      // Get rounding info, which we can get by comparing 2r with v.
      // We want to call copy_and_round to handle rounding and general cleanup,
      // so we'll left shift q and add some fake digits on the end to represent
      // how we'll be rounding.
      //
      using local_exponent_type = typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type;

      BOOST_MP_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
      constexpr unsigned lshift = (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count < limb_bits) ? 2 : limb_bits;
      eval_left_shift(q, lshift);
      res.exponent() -= static_cast<local_exponent_type>(lshift);
      eval_left_shift(r, 1u);
      int c = r.compare(v.bits());
      if (c == 0)
         q.limbs()[0] |= static_cast<limb_type>(1u) << (lshift - 1);
      else if (c > 0)
         q.limbs()[0] |= (static_cast<limb_type>(1u) << (lshift - 1)) + static_cast<limb_type>(1u);
   }
   copy_and_round(res, q);
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& arg)
{
   eval_divide(res, res, arg);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2, class U>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<U>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& u, const U& v)
{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326) // comparison of two constants
#endif
   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_increment;
   using default_ops::eval_qr;
   using default_ops::eval_subtract;

   //
   // Special cases first:
   //
   switch (u.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_zero:
   {
      if (v == 0)
      {
         res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
         return;
      }
      bool s     = u.sign() != (v < 0);
      res        = u;
      res.sign() = s;
      return;
   }
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_infinity:
      res = u;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>::exponent_nan:
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      return;
   }
   if (v == 0)
   {
      bool s     = u.sign();
      res        = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      res.sign() = s;
      return;
   }

   // We can scale u and v so that both are integers, then perform integer
   // division to obtain quotient q and remainder r, such that:
   //
   // q * v + r = u
   //
   // and hense:
   //
   // q + r/v = u/v
   //
   // From this, assuming q has "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, we only need to determine whether
   // r/v is less than, equal to, or greater than 0.5 to determine rounding -
   // this we can do with a shift and comparison.
   //
   // We can set the exponent and sign of the result up front:
   //
   std::ptrdiff_t  gb         = static_cast<std::ptrdiff_t>(msb(v));
   res.exponent() = u.exponent() - static_cast<Exponent>(gb) - static_cast<Exponent>(1);
   res.sign()     = u.sign();
   //
   // Now get the quotient and remainder:
   //
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(u.bits()), q, r;
   eval_left_shift(t, static_cast<double_limb_type>(gb + 1));
   eval_qr(t, number<typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::canonical_value(v), q, r);
   //
   // We now have either "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" or "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1" significant cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
   //
   constexpr unsigned limb_bits = sizeof(limb_type) * CHAR_BIT;
   if (eval_bit_test(q, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
   {
      //
      // OK we have cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count+1 cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count, so we already have rounding info,
      // we just need to changes things if the last bit is 1 and the
      // remainder is non-zero (ie we do not have a tie).
      //
      BOOST_MP_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count));
      if ((q.limbs()[0] & 1u) && eval_get_sign(r))
      {
         eval_increment(q);
      }
   }
   else
   {
      //
      // We have exactly "cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count" cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in q.
      // Get rounding info, which we can get by comparing 2r with v.
      // We want to call copy_and_round to handle rounding and general cleanup,
      // so we'll left shift q and add some fake cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count on the end to represent
      // how we'll be rounding.
      //
      using local_exponent_type = typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type;

      BOOST_MP_ASSERT((eval_msb(q) == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1));
      constexpr unsigned lshift = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count < limb_bits ? 2 : limb_bits;
      eval_left_shift(q, lshift);
      res.exponent() -= static_cast<local_exponent_type>(lshift);
      eval_left_shift(r, 1u);
      int c = r.compare(number<typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type>::canonical_value(v));
      if (c == 0)
         q.limbs()[0] |= static_cast<limb_type>(1u) << (lshift - 1);
      else if (c > 0)
         q.limbs()[0] |= (static_cast<limb_type>(1u) << (lshift - 1)) + static_cast<limb_type>(1u);
   }
   copy_and_round(res, q);
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class U>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<U>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const U& v)
{
   eval_divide(res, res, v);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2, class S>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, 
   const cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2>& u, const S& v)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
   eval_divide(res, u, static_cast<ui_type>(boost::multiprecision::detail::unsigned_abs(v)));
   if (v < 0)
      res.negate();
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class S>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value>::type eval_divide(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const S& v)
{
   eval_divide(res, res, v);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline int eval_get_sign(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   return arg.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero ? 0 : arg.sign() ? -1 : 1;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline bool eval_is_zero(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   return arg.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline bool eval_eq(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& a, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& b)
{
   if (a.exponent() == b.exponent())
   {
      if (a.exponent() == cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero)
         return true;
      return (a.sign() == b.sign()) && (a.bits().compare(b.bits()) == 0) && (a.exponent() != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan);
   }
   return false;
}

template <class I, unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void convert_to_signed_int(I* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   static constexpr int digits  = std::numeric_limits<I>::is_specialized ? std::numeric_limits<I>::digits : sizeof(I) * CHAR_BIT - 1;
   static constexpr I max_val = std::numeric_limits<I>::is_specialized ? (std::numeric_limits<I>::max)() : (((I(1) << (sizeof(I) * CHAR_BIT - 2)) - 1) << 1) + 1;
   static constexpr I min_val = std::numeric_limits<I>::is_specialized ? (std::numeric_limits<I>::min)() : -max_val - 1;


   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
      *res = 0;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      *res = max_val;
      if (arg.sign())
         *res = -*res;
      return;
   }
   using shift_type = typename std::conditional<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type;
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::rep_type man(arg.bits());
   shift_type                                                                           shift = (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - arg.exponent();
   if (shift > (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
   {
      *res = 0;
      return;
   }
   if (arg.sign() && (arg.compare(min_val) <= 0))
   {
      *res = min_val;
      return;
   }
   else if (!arg.sign() && (arg.compare(max_val) >= 0))
   {
      *res = max_val;
      return;
   }

   if (shift < 0)
   {
      if (static_cast<int>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - static_cast<int>(shift) <= digits)
      {
         // We have more bits in long_long_type than the float, so it's OK to left shift:
         eval_convert_to(res, man);
         *res <<= -shift;
      }
      else
      {
         *res = (std::numeric_limits<I>::max)();
         return;
      }
   }
   else
   {
      eval_right_shift(man, static_cast<double_limb_type>(shift));
      eval_convert_to(res, man);
   }
   if (arg.sign())
   {
      *res = -*res;
   }
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_convert_to(long long* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   convert_to_signed_int(res, arg);
}

#ifdef BOOST_HAS_INT128
template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_convert_to(int128_type* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   convert_to_signed_int(res, arg);
}
#endif

template <class I, unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void convert_to_unsigned_int(I* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   static constexpr int digits  = std::numeric_limits<I>::is_specialized ? std::numeric_limits<I>::digits : sizeof(I) * CHAR_BIT;
   static constexpr I   max_val = std::numeric_limits<I>::is_specialized ? (std::numeric_limits<I>::max)() : ~static_cast<I>(0);

   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
      *res = 0;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      *res = max_val;
      return;
   }
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::rep_type                                                                                                                                                              man(arg.bits());
   using shift_type = typename std::conditional<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type;
   shift_type                                                                                                                                                                                                                                        shift = (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - arg.exponent();
   if (shift > (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1)
   {
      *res = 0;
      return;
   }
   else if (shift < 0)
   {
      if (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - shift <= digits)
      {
         // We have more bits in ulong_long_type than the float, so it's OK to left shift:
         eval_convert_to(res, man);
         *res <<= -shift;
         return;
      }
      *res = max_val;
      return;
   }
   eval_right_shift(man, shift);
   eval_convert_to(res, man);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_convert_to(unsigned long long* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   convert_to_unsigned_int(res, arg);
}

#ifdef BOOST_HAS_INT128
template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_convert_to(uint128_type* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   convert_to_unsigned_int(res, arg);
}
#endif

template <class Float, unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline typename std::enable_if<std::is_floating_point<Float>::value>::type eval_convert_to(Float* res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& original_arg)
{
   using conv_type = cpp_bin_float<std::numeric_limits<Float>::digits, digit_base_2, void, Exponent, MinE, MaxE>;
   using common_exp_type = typename std::common_type<typename conv_type::exponent_type, int>::type;

   static constexpr int float_digits = boost::multiprecision::detail::is_float128<Float>::value ? 113 : std::numeric_limits<Float>::digits;

   BOOST_MP_FLOAT128_USING using std::ldexp;
   //
   // Special cases first:
   //
   switch (original_arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
      *res = 0;
      if (original_arg.sign())
         *res = -*res;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      BOOST_IF_CONSTEXPR(boost::multiprecision::detail::is_float128<Float>::value)
      {
         *res = static_cast<Float>(std::numeric_limits<double>::quiet_NaN());
      }
      else
      {
         *res = std::numeric_limits<Float>::quiet_NaN();
      }
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      BOOST_IF_CONSTEXPR(boost::multiprecision::detail::is_float128<Float>::value)
      {
         *res = static_cast<Float>((std::numeric_limits<double>::infinity)());
      }
      else
      {
         *res = (std::numeric_limits<Float>::infinity)();
      }
      if (original_arg.sign())
         *res = -*res;
      return;
   }
   //
   // Check for super large exponent that must be converted to infinity:
   //
   if (original_arg.exponent() > (boost::multiprecision::detail::is_float128<Float>::value ? 16384 : std::numeric_limits<Float>::max_exponent))
   {
      BOOST_IF_CONSTEXPR(boost::multiprecision::detail::is_float128<Float>::value)
      {
         *res = static_cast<Float>(std::numeric_limits<double>::infinity());
      }
      else
      {
         *res = std::numeric_limits<Float>::has_infinity ? std::numeric_limits<Float>::infinity() : (std::numeric_limits<Float>::max)();
      }
      if (original_arg.sign())
         *res = -*res;
      return;
   }
   //
   // Figure out how many digits we will have in our result,
   // allowing for a possibly denormalized result:
   //
   common_exp_type digits_to_round_to = float_digits;
   if (original_arg.exponent() < std::numeric_limits<Float>::min_exponent - 1)
   {
      common_exp_type diff = original_arg.exponent();
      diff -= boost::multiprecision::detail::is_float128<Float>::value ? -16382 : std::numeric_limits<Float>::min_exponent - 1;
      digits_to_round_to += diff;
   }
   if (digits_to_round_to < 0)
   {
      // Result must be zero:
      *res = 0;
      if (original_arg.sign())
         *res = -*res;
      return;
   }
   //
   // Perform rounding first, then afterwards extract the digits:
   //
   cpp_bin_float<static_cast<unsigned>(float_digits), digit_base_2, Allocator, Exponent, MinE, MaxE>           arg;
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::rep_type bits(original_arg.bits());
   arg.exponent() = original_arg.exponent();
   copy_and_round(arg, bits, (std::ptrdiff_t)digits_to_round_to);
   common_exp_type e = arg.exponent();
   e -= static_cast<common_exp_type>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - 1;
   constexpr std::size_t limbs_needed      = static_cast<std::size_t>(float_digits) / (sizeof(*arg.bits().limbs()) * CHAR_BIT) + (static_cast<std::size_t>(float_digits) % (sizeof(*arg.bits().limbs()) * CHAR_BIT) ? 1 : 0);
   std::size_t                 first_limb_needed = arg.bits().size() - limbs_needed;
   *res                                          = 0;
   e += static_cast<common_exp_type>(first_limb_needed * sizeof(*arg.bits().limbs()) * CHAR_BIT);
   while (first_limb_needed < arg.bits().size())
   {
      *res += ldexp(static_cast<Float>(arg.bits().limbs()[first_limb_needed]), static_cast<int>(e));
      ++first_limb_needed;
      e += static_cast<common_exp_type>(sizeof(*arg.bits().limbs()) * CHAR_BIT);
   }
   if (original_arg.sign())
      *res = -*res;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_frexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg, Exponent* e)
{
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      *e  = 0;
      res = arg;
      return;
   }
   res            = arg;
   *e             = arg.exponent() + 1;
   res.exponent() = -1;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
inline void eval_frexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg, I* pe)
{
   Exponent e;
   eval_frexp(res, arg, &e);
   if ((e > (std::numeric_limits<I>::max)()) || (e < (std::numeric_limits<I>::min)()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent was outside of the range of the argument type to frexp."));
   }
   *pe = static_cast<I>(e);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg, Exponent e)
{
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      res = arg;
      return;
   }
   if ((e > 0) && (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent - e < arg.exponent()))
   {
      // Overflow:
      res        = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      res.sign() = arg.sign();
   }
   else if ((e < 0) && (cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent - e > arg.exponent()))
   {
      // Underflow:
      res = limb_type(0);
   }
   else
   {
      res = arg;
      res.exponent() += e;
   }
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<I>::value>::type eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg, I e)
{
   using si_type = typename boost::multiprecision::detail::make_signed<I>::type;
   if (e > static_cast<I>((std::numeric_limits<si_type>::max)()))
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
   else
      eval_ldexp(res, arg, static_cast<si_type>(e));
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class I>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value>::type eval_ldexp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg, I e)
{
   if ((e > (std::numeric_limits<Exponent>::max)()) || (e < (std::numeric_limits<Exponent>::min)()))
   {
      res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
      if (e < 0)
         res.negate();
   }
   else
      eval_ldexp(res, arg, static_cast<Exponent>(e));
}

/*
* Sign manipulation
*/

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   unsigned Digits2, digit_base_type DigitBase2, class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_abs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits2, DigitBase2, Allocator2, Exponent2, MinE2, MaxE2>& arg)
{
   res        = arg;
   res.sign() = false;
}
template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_abs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   res        = arg;
   res.sign() = false;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE,
   unsigned Digits2, digit_base_type DigitBase2, class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
inline void eval_fabs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits2, DigitBase2, Allocator2, Exponent2, MinE2, MaxE2>& arg)
{
   res        = arg;
   res.sign() = false;
}
template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_fabs(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   res        = arg;
   res.sign() = false;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline int eval_fpclassify(const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
      return FP_ZERO;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      return FP_INFINITE;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      return FP_NAN;
   }
   return FP_NORMAL;
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_sqrt(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   using default_ops::eval_bit_test;
   using default_ops::eval_increment;
   using default_ops::eval_integer_sqrt;
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      errno = EDOM;
      // fallthrough...
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
      res = arg;
      return;
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      if (arg.sign())
      {
         res   = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
         errno = EDOM;
      }
      else
         res = arg;
      return;
   }
   if (arg.sign())
   {
      res   = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::quiet_NaN().backend();
      errno = EDOM;
      return;
   }

   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::double_rep_type t(arg.bits()), r, s;
   eval_left_shift(t, arg.exponent() & 1 ? cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count : cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1);
   eval_integer_sqrt(s, r, t);

   if (!eval_bit_test(s, cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count))
   {
      // We have exactly the right number of cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count in the result, round as required:
      if (s.compare(r) < 0)
      {
         eval_increment(s);
      }
   }
   typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type ae = arg.exponent();
   res.exponent()                                                                               = ae / 2;
   res.sign() = false;
   if ((ae & 1) && (ae < 0))
      --res.exponent();
   copy_and_round(res, s);
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_floor(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   using default_ops::eval_increment;
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      errno = EDOM;
      // fallthrough...
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      res = arg;
      return;
   }
   using shift_type = typename std::conditional<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type;
   shift_type                                                                                                                                                                                                                                        shift =
       (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - arg.exponent() - 1;
   if ((arg.exponent() > (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent) || (shift <= 0))
   {
      // Either arg is already an integer, or a special value:
      res = arg;
      return;
   }
   if (shift >= (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
   {
      res = static_cast<signed_limb_type>(arg.sign() ? -1 : 0);
      return;
   }
   bool fractional = (shift_type)eval_lsb(arg.bits()) < shift;
   res             = arg;
   eval_right_shift(res.bits(), static_cast<double_limb_type>(shift));
   if (fractional && res.sign())
   {
      eval_increment(res.bits());

      const std::ptrdiff_t shift_check =
         static_cast<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count) - 1 - static_cast<std::ptrdiff_t>(shift));

      if (static_cast<std::ptrdiff_t>(eval_msb(res.bits())) != shift_check)
      {
         // Must have extended result by one bit in the increment:
         --shift;
         ++res.exponent();
      }
   }
   eval_left_shift(res.bits(), static_cast<double_limb_type>(shift));
}

template <unsigned Digits, digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
inline void eval_ceil(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>& arg)
{
   using default_ops::eval_increment;
   switch (arg.exponent())
   {
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity:
      errno = EDOM;
      // fallthrough...
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_zero:
   case cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan:
      res = arg;
      return;
   }
   using shift_type = typename std::conditional<sizeof(typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type) < sizeof(int), int, typename cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type>::type;
   shift_type                                                                                                                                                                                                                                        shift = (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - arg.exponent() - 1;
   if ((arg.exponent() > (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent) || (shift <= 0))
   {
      // Either arg is already an integer, or a special value:
      res = arg;
      return;
   }
   if (shift >= (shift_type)cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count)
   {
      bool s     = arg.sign(); // takes care of signed zeros
      res        = static_cast<signed_limb_type>(arg.sign() ? 0 : 1);
      res.sign() = s;
      return;
   }
   bool fractional = (shift_type)eval_lsb(arg.bits()) < shift;
   res             = arg;
   eval_right_shift(res.bits(), shift);
   if (fractional && !res.sign())
   {
      eval_increment(res.bits());
      if ((std::ptrdiff_t)eval_msb(res.bits()) != cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1 - shift)
      {
         // Must have extended result by one bit in the increment:
         --shift;
         ++res.exponent();
      }
   }
   eval_left_shift(res.bits(), shift);
}

template <unsigned D1, backends::digit_base_type B1, class A1, class E1, E1 M1, E1 M2>
int eval_signbit(const cpp_bin_float<D1, B1, A1, E1, M1, M2>& val)
{
   return val.sign();
}

template <unsigned D1, backends::digit_base_type B1, class A1, class E1, E1 M1, E1 M2>
inline std::size_t hash_value(const cpp_bin_float<D1, B1, A1, E1, M1, M2>& val)
{
   std::size_t result = hash_value(val.bits());
   boost::multiprecision::detail::hash_combine(result, val.exponent(), val.sign());
   return result;
}

} // namespace backends

namespace detail {

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent>
struct transcendental_reduction_type<boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> >
{
   //
   // The type used for trigonometric reduction needs 3 times the precision of the base type.
   // This is double the precision of the original type, plus the largest exponent supported.
   // As a practical measure the largest argument supported is 1/eps, as supporting larger
   // arguments requires the division of argument by PI/2 to also be done at higher precision,
   // otherwise the result (an integer) can not be represented exactly.
   // 
   // See ARGUMENT REDUCTION FOR HUGE ARGUMENTS. K C Ng.
   //
   using type = boost::multiprecision::backends::cpp_bin_float<
       boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>::bit_count * 3, 
       boost::multiprecision::backends::digit_base_2, 
       Allocator, Exponent, MinExponent, MaxExponent>;
};
#ifdef BOOST_HAS_INT128
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent>
struct is_convertible_arithmetic<int128_type, boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> > : public std::true_type
{};
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent>
struct is_convertible_arithmetic<uint128_type, boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> > : public std::true_type
{};
#endif

} // namespace detail

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Exponent, Exponent MinE, Exponent MaxE, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates>
    copysign BOOST_PREVENT_MACRO_SUBSTITUTION(
        const boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates>& a,
        const boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates>& b)
{
   boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> res(a);
   res.backend().sign() = b.backend().sign();
   return res;
}

using backends::cpp_bin_float;
using backends::digit_base_10;
using backends::digit_base_2;

template <unsigned Digits, backends::digit_base_type DigitBase, class Exponent, Exponent MinE, Exponent MaxE, class Allocator>
struct number_category<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > : public std::integral_constant<int, boost::multiprecision::number_kind_floating_point>
{};

template <unsigned Digits, backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE>
struct expression_template_default<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >
{
   static constexpr expression_template_option value = std::is_void<Allocator>::value ? et_off : et_on;
};

template <unsigned Digits, backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, class Allocator2, class Exponent2, Exponent MinE2, Exponent MaxE2>
struct is_equivalent_number_type<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, cpp_bin_float<Digits, DigitBase, Allocator2, Exponent2, MinE2, MaxE2> >
   : public std::integral_constant<bool, true> {};

using cpp_bin_float_50 = number<backends::cpp_bin_float<50> > ;
using cpp_bin_float_100 = number<backends::cpp_bin_float<100> >;

using cpp_bin_float_single = number<backends::cpp_bin_float<24, backends::digit_base_2, void, std::int16_t, -126, 127>, et_off>       ;
using cpp_bin_float_double = number<backends::cpp_bin_float<53, backends::digit_base_2, void, std::int16_t, -1022, 1023>, et_off>     ;
using cpp_bin_float_double_extended = number<backends::cpp_bin_float<64, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>   ;
using cpp_bin_float_quad = number<backends::cpp_bin_float<113, backends::digit_base_2, void, std::int16_t, -16382, 16383>, et_off>  ;
using cpp_bin_float_oct = number<backends::cpp_bin_float<237, backends::digit_base_2, void, std::int32_t, -262142, 262143>, et_off>;

} // namespace multiprecision

namespace math {

using boost::multiprecision::copysign;
using boost::multiprecision::signbit;

} // namespace math

} // namespace boost

#include <boost/multiprecision/cpp_bin_float/io.hpp>
#include <boost/multiprecision/cpp_bin_float/transcendental.hpp>

namespace std {

//
// numeric_limits [partial] specializations for the types declared in this header:
//
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates>;

 private:
    //
    // Functions to calculate cached values stored in static values:
    //
    static number_type get_min()
    {
       using ui_type = typename std::tuple_element<0, typename number_type::backend_type::unsigned_types>::type;
       number_type value(ui_type(1u));
       value.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
       return value;
    }
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
    static number_type get_max()
    {
       number_type value;
       BOOST_IF_CONSTEXPR(std::is_void<Allocator>::value)
          eval_complement(value.backend().bits(), value.backend().bits());
       else
       {
          // We jump through hoops here using the backend type directly just to keep VC12 happy
          // (ie compiler workaround, for very strange compiler bug):
          using boost::multiprecision::default_ops::eval_add;
          using boost::multiprecision::default_ops::eval_decrement;
          using boost::multiprecision::default_ops::eval_left_shift;
          using int_backend_type = typename number_type::backend_type::rep_type;
          using ui_type = typename std::tuple_element<0, typename int_backend_type::unsigned_types>::type;
          int_backend_type                                                                    i;
          i = ui_type(1u);
          eval_left_shift(i, boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count - 1);
          int_backend_type j(i);
          eval_decrement(i);
          eval_add(j, i);
          value.backend().bits() = j;
       }
       value.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
       return value;
    }
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
    static number_type get_epsilon()
    {
       using ui_type = typename std::tuple_element<0, typename number_type::backend_type::unsigned_types>::type;
       number_type value(ui_type(1u));
       return ldexp(value, 1 - static_cast<int>(digits));
    }
    // What value should this be????
    static number_type get_round_error()
    {
       // returns 0.5
       return ldexp(number_type(1u), -1);
    }
    static number_type get_infinity()
    {
       number_type value;
       value.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_infinity;
       return value;
    }
    static number_type get_quiet_NaN()
    {
       number_type value;
       value.backend().exponent() = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_nan;
       return value;
    }

 public:
   static constexpr bool is_specialized = true;
   static number_type(min)()
   {
      // C++11 thread safe static initialization:
      static number_type value = get_min();
      return value;
   }
   static number_type(max)()
   {
      // C++11 thread safe static initialization:
      static number_type value = get_max();
      return value;
   }
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
   static constexpr number_type lowest()
   {
      return -(max)();
   }
   static constexpr int digits   = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count;
   static constexpr int digits10 = boost::multiprecision::detail::calc_digits10<static_cast<unsigned>(digits)>::value;
   // Is this really correct???
   static constexpr int  max_digits10 = boost::multiprecision::detail::calc_max_digits10<static_cast<unsigned>(digits)>::value;
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static number_type          epsilon()
   {
      // C++11 thread safe static initialization:
      static number_type value = get_epsilon();
      return value;
   }
   // What value should this be????
   static number_type round_error()
   {
      // returns 0.5
      // C++11 thread safe static initialization:
      static number_type value = get_round_error();
      return value;
   }
   static constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type min_exponent      = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::min_exponent;
   static constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type min_exponent10    = (min_exponent / 1000) * 301L;
   static constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type max_exponent      = boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::max_exponent;
   static constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type max_exponent10    = (max_exponent / 1000) * 301L;
   static constexpr bool                                                                                                             has_infinity      = true;
   static constexpr bool                                                                                                             has_quiet_NaN     = true;
   static constexpr bool                                                                                                             has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm                                                                                                      = denorm_absent;
   static constexpr bool               has_denorm_loss                                                                                                 = false;
   static number_type infinity()
   {
      // C++11 thread safe static initialization:
      static number_type value = get_infinity();
      return value;
   }
   static number_type quiet_NaN()
   {
      // C++11 thread safe static initialization:
      static number_type value = get_quiet_NaN();
      return value;
   }
   static constexpr number_type signaling_NaN()
   {
      return number_type(0);
   }
   static constexpr number_type denorm_min() { return number_type(0); }
   static constexpr bool        is_iec559         = false;
   static constexpr bool        is_bounded        = true;
   static constexpr bool        is_modulo         = false;
   static constexpr bool        traps             = true;
   static constexpr bool        tinyness_before   = false;
   static constexpr float_round_style round_style = round_to_nearest;
};

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::digits;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::digits10;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_signed;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_integer;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_exact;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::radix;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_quiet_NaN;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_signaling_NaN;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_denorm;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::has_denorm_loss;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::traps;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >::round_style;


} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_complex.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_CPP_COMPLEX_HPP
#define BOOST_MP_CPP_COMPLEX_HPP

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/complex_adaptor.hpp>

namespace boost {
namespace multiprecision {

template <unsigned Digits, backends::digit_base_type DigitBase = backends::digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0>
using cpp_complex_backend = complex_adaptor<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> >;

template <unsigned Digits, backends::digit_base_type DigitBase = digit_base_10, class Allocator = void, class Exponent = int, Exponent MinExponent = 0, Exponent MaxExponent = 0, expression_template_option ExpressionTemplates = et_off>
using cpp_complex = number<complex_adaptor<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent> >, ExpressionTemplates>;

using cpp_complex_50 = cpp_complex<50> ;
using cpp_complex_100 = cpp_complex<100>;

using cpp_complex_single = cpp_complex<24, backends::digit_base_2, void, std::int16_t, -126, 127>       ;
using cpp_complex_double = cpp_complex<53, backends::digit_base_2, void, std::int16_t, -1022, 1023>     ;
using cpp_complex_extended = cpp_complex<64, backends::digit_base_2, void, std::int16_t, -16382, 16383>   ;
using cpp_complex_quad = cpp_complex<113, backends::digit_base_2, void, std::int16_t, -16382, 16383>  ;
using cpp_complex_oct = cpp_complex<237, backends::digit_base_2, void, std::int32_t, -262142, 262143>;

}
} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_dec_float.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
// Copyright Christopher Kormanyos 2002 - 2021.
// Copyright 2011 -2021 John Maddock. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
//
// There are some "noexcept" specifications on the functions in this file.
// Unlike in pre-C++11 versions, compilers can now detect noexcept misuse
// at compile time, allowing for simple use of it here.
//

#ifndef BOOST_MP_CPP_DEC_FLOAT_HPP
#define BOOST_MP_CPP_DEC_FLOAT_HPP

#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <algorithm>
#include <array>
#include <initializer_list>
#include <iomanip>
#include <string>
#include <limits>
#include <stdexcept>
#include <sstream>
#include <locale>
#include <ios>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <boost/multiprecision/detail/dynamic_array.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/itos.hpp>
#include <boost/multiprecision/detail/static_array.hpp>
#include <boost/multiprecision/detail/tables.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

#ifdef BOOST_MP_MATH_AVAILABLE
//
// Headers required for Boost.Math integration:
//
#include <boost/math/policies/policy.hpp>
//
// Some includes we need from Boost.Math, since we rely on that library to provide these functions:
//
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/asinh.hpp>
#include <boost/math/special_functions/atanh.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/special_functions/gamma.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326) // comparison of two constants
#endif

namespace boost {
namespace multiprecision {
namespace backends {

template <unsigned Digits10, class ExponentType = std::int32_t, class Allocator = void>
class cpp_dec_float;

} // namespace backends

template <unsigned Digits10, class ExponentType, class Allocator>
struct number_category<backends::cpp_dec_float<Digits10, ExponentType, Allocator> > : public std::integral_constant<int, number_kind_floating_point>
{};

namespace backends {

template <unsigned Digits10, class ExponentType, class Allocator>
class cpp_dec_float
{
 private:
   // Perform some static sanity checks.
   static_assert(boost::multiprecision::detail::is_signed<ExponentType>::value,
                 "ExponentType must be a signed built in integer type.");

   static_assert(sizeof(ExponentType) > 1,
                 "ExponentType is too small.");

   static_assert(Digits10 < UINT32_C(0x80000000),
                 "Digits10 exceeds the maximum.");

   // Private class-local constants.
   static constexpr std::int32_t  cpp_dec_float_digits10_limit_lo = INT32_C(9);
   static constexpr std::int32_t  cpp_dec_float_digits10_limit_hi = static_cast<std::int32_t>((std::numeric_limits<std::int32_t>::max)() - 100);

   static constexpr std::int32_t cpp_dec_float_elem_digits10      = INT32_C(8);
   static constexpr std::int32_t cpp_dec_float_elem_mask          = INT32_C(100000000);

   static constexpr std::int32_t cpp_dec_float_elems_for_kara     = static_cast<std::int32_t>(128 + 1);

 public:
   using signed_types   = std::tuple<long long> ;
   using unsigned_types = std::tuple<unsigned long long>;
   using float_types    = std::tuple<double, long double>;
   using exponent_type  = ExponentType;

   // Public class-local constants.
   static constexpr std::int32_t  cpp_dec_float_radix             = INT32_C(10);
   static constexpr std::int32_t  cpp_dec_float_digits10          = ((static_cast<std::int32_t>(Digits10) < cpp_dec_float_digits10_limit_lo) ? cpp_dec_float_digits10_limit_lo : ((static_cast<std::int32_t>(Digits10) > cpp_dec_float_digits10_limit_hi) ? cpp_dec_float_digits10_limit_hi : static_cast<std::int32_t>(Digits10)));
   static constexpr exponent_type cpp_dec_float_max_exp10         = (static_cast<exponent_type>(1) << (std::numeric_limits<exponent_type>::digits - 5));
   static constexpr exponent_type cpp_dec_float_min_exp10         = -cpp_dec_float_max_exp10;
   static constexpr exponent_type cpp_dec_float_max_exp           = cpp_dec_float_max_exp10;
   static constexpr exponent_type cpp_dec_float_min_exp           = cpp_dec_float_min_exp10;

   static_assert(cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_exp10 == -cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp10, "Failed exponent range check");

   static_assert(0 == cpp_dec_float_max_exp10 % cpp_dec_float_elem_digits10, "Failed digit sanity check");

 private:
   // There are three guard limbs.
   // 1) The first limb has 'play' from 1...8 decimal digits.
   // 2) The last limb also has 'play' from 1...8 decimal digits.
   // 3) One limb can get lost when justifying after multiply.
   static constexpr std::int32_t cpp_dec_float_elem_number    = static_cast<std::int32_t>(((Digits10 / cpp_dec_float_elem_digits10) + (((Digits10 % cpp_dec_float_elem_digits10) != 0) ? 1 : 0)) + 3);

 public:
   static constexpr std::int32_t cpp_dec_float_max_digits10   = static_cast<std::int32_t>(cpp_dec_float_elem_number * cpp_dec_float_elem_digits10);

 private:
   using array_type =
      typename std::conditional<std::is_void<Allocator>::value,
                                detail::static_array <std::uint32_t, static_cast<std::uint32_t>(cpp_dec_float_elem_number)>,
                                detail::dynamic_array<std::uint32_t, static_cast<std::uint32_t>(cpp_dec_float_elem_number), Allocator> >::type;

   typedef enum enum_fpclass_type
   {
      cpp_dec_float_finite,
      cpp_dec_float_inf,
      cpp_dec_float_NaN
   } fpclass_type;

   array_type    data;
   exponent_type exp;
   bool          neg;
   fpclass_type  fpclass;
   std::int32_t  prec_elem;

   // Private constructor from the floating-point class type.
   explicit cpp_dec_float(fpclass_type c) : data(),
                                            exp(static_cast<exponent_type>(0)),
                                            neg(false),
                                            fpclass(c),
                                            prec_elem(cpp_dec_float_elem_number) {}

   // Constructor from an initializer_list, an optional
   // (value-aligned) exponent and a Boolean sign.
   static cpp_dec_float from_lst(std::initializer_list<std::uint32_t> lst,
                                 const exponent_type e = 0,
                                 const bool n = false)
   {
      cpp_dec_float a;

      a.data      = array_type(lst);
      a.exp       = e;
      a.neg       = n;
      a.fpclass   = cpp_dec_float_finite;
      a.prec_elem = cpp_dec_float_elem_number;

      return a;
   }

 public:
   // Public Constructors
   cpp_dec_float() noexcept(noexcept(array_type())) : data(),
                                                      exp(static_cast<exponent_type>(0)),
                                                      neg(false),
                                                      fpclass(cpp_dec_float_finite),
                                                      prec_elem(cpp_dec_float_elem_number) {}

   cpp_dec_float(const char* s) : data(),
                                  exp(static_cast<exponent_type>(0)),
                                  neg(false),
                                  fpclass(cpp_dec_float_finite),
                                  prec_elem(cpp_dec_float_elem_number)
   {
      *this = s;
   }

   template <class I>
   cpp_dec_float(I i,
                 typename std::enable_if<boost::multiprecision::detail::is_unsigned<I>::value && (sizeof(I) <= sizeof(long long))>::type* = nullptr)
      : data(),
        exp(static_cast<exponent_type>(0)),
        neg(false),
        fpclass(cpp_dec_float_finite),
        prec_elem(cpp_dec_float_elem_number)
   {
      from_unsigned_long_long(i);
   }

   template <class I>
   cpp_dec_float(I i,
                 typename std::enable_if<(   boost::multiprecision::detail::is_signed<I>::value
                                          && boost::multiprecision::detail::is_integral<I>::value
                                          && (sizeof(I) <= sizeof(long long)))>::type* = nullptr)
      : data(),
        exp(static_cast<exponent_type>(0)),
        neg(false),
        fpclass(cpp_dec_float_finite),
        prec_elem(cpp_dec_float_elem_number)
   {
      if (i < 0)
      {
         from_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(i));
         negate();
      }
      else
         from_unsigned_long_long(static_cast<unsigned long long>(i));
   }

   cpp_dec_float(const cpp_dec_float& f) noexcept(noexcept(array_type(std::declval<const array_type&>())))
      : data(f.data),
        exp(f.exp),
        neg(f.neg),
        fpclass(f.fpclass),
        prec_elem(f.prec_elem) {}

   template <unsigned D, class ET, class A>
   cpp_dec_float(const cpp_dec_float<D, ET, A>& f, typename std::enable_if<D <= Digits10>::type* = nullptr)
      : data(),
        exp(f.exp),
        neg(f.neg),
        fpclass(static_cast<fpclass_type>(static_cast<int>(f.fpclass))),
        prec_elem(cpp_dec_float_elem_number)
   {
      std::copy(f.data.begin(), f.data.begin() + f.prec_elem, data.begin());
   }
   template <unsigned D, class ET, class A>
   explicit cpp_dec_float(const cpp_dec_float<D, ET, A>& f, typename std::enable_if< !(D <= Digits10)>::type* = nullptr)
      : data(),
        exp(f.exp),
        neg(f.neg),
        fpclass(static_cast<fpclass_type>(static_cast<int>(f.fpclass))),
        prec_elem(cpp_dec_float_elem_number)
   {
      // TODO: this doesn't round!
      std::copy(f.data.begin(), f.data.begin() + prec_elem, data.begin());
   }

   template <class F>
   cpp_dec_float(const F val, typename std::enable_if<std::is_floating_point<F>::value
                                                   >::type* = nullptr) : data(),
                                                                         exp(static_cast<exponent_type>(0)),
                                                                         neg(false),
                                                                         fpclass(cpp_dec_float_finite),
                                                                         prec_elem(cpp_dec_float_elem_number)
   {
      *this = val;
   }

   cpp_dec_float(const double mantissa, const exponent_type exponent);

   std::size_t hash() const
   {
      std::size_t result = 0;
      for (int i = 0; i < prec_elem; ++i)
         boost::multiprecision::detail::hash_combine(result, data[i]);
      boost::multiprecision::detail::hash_combine(result, exp, neg, static_cast<std::size_t>(fpclass));
      return result;
   }

   // Specific special values.
   static const cpp_dec_float&  nan () { static const cpp_dec_float val(cpp_dec_float_NaN); return val; }
   static const cpp_dec_float&  inf () { static const cpp_dec_float val(cpp_dec_float_inf); return val; }
   static const cpp_dec_float& (max)() { static const cpp_dec_float val(from_lst({ std::uint32_t(1u) }, cpp_dec_float_max_exp10)); return val; }
   static const cpp_dec_float& (min)() { static const cpp_dec_float val(from_lst({ std::uint32_t(1u) }, cpp_dec_float_min_exp10)); return val; }
   static const cpp_dec_float&  zero() { static const cpp_dec_float val(from_lst({ std::uint32_t(0u) })); return val; }
   static const cpp_dec_float&  one () { static const cpp_dec_float val(from_lst({ std::uint32_t(1u) })); return val; }
   static const cpp_dec_float&  two () { static const cpp_dec_float val(from_lst({ std::uint32_t(2u) })); return val; }
   static const cpp_dec_float&  half() { static const cpp_dec_float val(from_lst({ std::uint32_t(cpp_dec_float_elem_mask / 2)}, -8)); return val; }

   static const cpp_dec_float& double_min() { static const cpp_dec_float val((std::numeric_limits<double>::min)()); return val; }
   static const cpp_dec_float& double_max() { static const cpp_dec_float val((std::numeric_limits<double>::max)()); return val; }

   static const cpp_dec_float& long_double_min()
   {
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
      static const cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::min)()));
#else
      static const cpp_dec_float val((std::numeric_limits<long double>::min)());
#endif
      return val;
   }

   static const cpp_dec_float& long_double_max()
   {
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
      static const cpp_dec_float val(static_cast<long double>((std::numeric_limits<double>::max)()));
#else
      static const cpp_dec_float val((std::numeric_limits<long double>::max)());
#endif
      return val;
   }

   static const cpp_dec_float& long_long_max () { static const cpp_dec_float val((std::numeric_limits<long long>::max)()); return val; }
   static const cpp_dec_float& long_long_min () { static const cpp_dec_float val((std::numeric_limits<long long>::min)()); return val; }
   static const cpp_dec_float& ulong_long_max() { static const cpp_dec_float val((std::numeric_limits<unsigned long long>::max)()); return val; }

   static const cpp_dec_float& eps()
   {
      static const cpp_dec_float val
      (
        from_lst
        (
          {
            (std::uint32_t) detail::pow10_maker((std::uint32_t) ((std::int32_t) (INT32_C(1) + (std::int32_t) (((cpp_dec_float_digits10 / cpp_dec_float_elem_digits10) + ((cpp_dec_float_digits10 % cpp_dec_float_elem_digits10) != 0 ? 1 : 0)) * cpp_dec_float_elem_digits10)) - cpp_dec_float_digits10))
          },
          -(exponent_type) (((cpp_dec_float_digits10 / cpp_dec_float_elem_digits10) + ((cpp_dec_float_digits10 % cpp_dec_float_elem_digits10) != 0 ? 1 : 0)) * cpp_dec_float_elem_digits10)
        )
      );

      return val;
   }

   // Basic operations.
   cpp_dec_float& operator=(const cpp_dec_float& v) noexcept(noexcept(std::declval<array_type&>() = std::declval<const array_type&>()))
   {
      data      = v.data;
      exp       = v.exp;
      neg       = v.neg;
      fpclass   = v.fpclass;
      prec_elem = v.prec_elem;
      return *this;
   }

   template <unsigned D>
   cpp_dec_float& operator=(const cpp_dec_float<D>& f)
   {
      exp            = f.exp;
      neg            = f.neg;
      fpclass        = static_cast<enum_fpclass_type>(static_cast<int>(f.fpclass));
      unsigned elems = (std::min)(f.prec_elem, cpp_dec_float_elem_number);
      std::copy(f.data.begin(), f.data.begin() + elems, data.begin());
      std::fill(data.begin() + elems, data.end(), 0);
      prec_elem = cpp_dec_float_elem_number;
      return *this;
   }

   cpp_dec_float& operator=(long long v)
   {
      if (v < 0)
      {
         from_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(v));
         negate();
      }
      else
      {
         using local_ulonglong_type = typename boost::multiprecision::detail::make_unsigned<long long>::type;

         from_unsigned_long_long(static_cast<local_ulonglong_type>(v));
      }
      return *this;
   }

   cpp_dec_float& operator=(unsigned long long v)
   {
      from_unsigned_long_long(v);
      return *this;
   }
#ifdef BOOST_HAS_INT128
   cpp_dec_float& operator=(int128_type v)
   {
      *this = boost::multiprecision::detail::unsigned_abs(v);
      if (v < 0)
         negate();
      return *this;
   }

   cpp_dec_float& operator=(uint128_type v)
   {
      using default_ops::eval_add;
      using default_ops::eval_multiply;

      constexpr unsigned     bit_shift = sizeof(unsigned long long) * CHAR_BIT;
      constexpr uint128_type mask      = (static_cast<uint128_type>(1u) << bit_shift) - 1;

      *this = static_cast<unsigned long long>(v & mask);

      v >>= bit_shift;

      while (v)
      {
         cpp_dec_float t(static_cast<unsigned long long>(v & mask));
         eval_multiply(t, cpp_dec_float::pow2(bit_shift));
         eval_add(*this, t);
         v >>= bit_shift;
      }
      return *this;
   }
#endif

   template <class Float>
   typename std::enable_if<std::is_floating_point<Float>::value, cpp_dec_float&>::type operator=(Float v);

   cpp_dec_float& operator=(const char* v)
   {
      rd_string(v);
      return *this;
   }

   cpp_dec_float& operator+=(const cpp_dec_float& v);
   cpp_dec_float& operator-=(const cpp_dec_float& v);
   cpp_dec_float& operator*=(const cpp_dec_float& v);
   cpp_dec_float& operator/=(const cpp_dec_float& v);

   cpp_dec_float& add_unsigned_long_long(const unsigned long long n)
   {
      cpp_dec_float t;
      t.from_unsigned_long_long(n);
      return *this += t;
   }

   cpp_dec_float& sub_unsigned_long_long(const unsigned long long n)
   {
      cpp_dec_float t;
      t.from_unsigned_long_long(n);
      return *this -= t;
   }

   cpp_dec_float& mul_unsigned_long_long(const unsigned long long n);
   cpp_dec_float& div_unsigned_long_long(const unsigned long long n);

   // Elementary primitives.
   cpp_dec_float& calculate_inv();
   cpp_dec_float& calculate_sqrt();

   void negate()
   {
      if (!iszero())
         neg = !neg;
   }

   // Comparison functions
   bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION() const { return (fpclass == cpp_dec_float_NaN); }
   bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION() const { return (fpclass == cpp_dec_float_inf); }
   bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION() const { return (fpclass == cpp_dec_float_finite); }

   bool iszero() const
   {
      return ((fpclass == cpp_dec_float_finite) && (data[0u] == 0u));
   }

   bool isone() const;
   bool isint() const;
   bool isneg() const { return neg; }

   // Operators pre-increment and pre-decrement
   cpp_dec_float& operator++()
   {
      return *this += one();
   }

   cpp_dec_float& operator--()
   {
      return *this -= one();
   }

   std::string str(std::intmax_t digits, std::ios_base::fmtflags f) const;

   int compare(const cpp_dec_float& v) const;

   template <class V>
   int compare(const V& v) const
   {
      cpp_dec_float<Digits10, ExponentType, Allocator> t;
      t = v;
      return compare(t);
   }

   void swap(cpp_dec_float& v)
   {
      data.swap(v.data);
      std::swap(exp, v.exp);
      std::swap(neg, v.neg);
      std::swap(fpclass, v.fpclass);
      std::swap(prec_elem, v.prec_elem);
   }

   double                 extract_double() const;
   long double            extract_long_double() const;
   long long  extract_signed_long_long() const;
   unsigned long long extract_unsigned_long_long() const;
#ifdef BOOST_HAS_INT128
   int128_type  extract_signed_int128() const;
   uint128_type extract_unsigned_int128() const;
#endif
   void                   extract_parts(double& mantissa, exponent_type& exponent) const;
   cpp_dec_float          extract_integer_part() const;

   void precision(const std::int32_t prec_digits)
   {
      const std::int32_t elems =
        static_cast<std::int32_t>(    static_cast<std::int32_t>(prec_digits / cpp_dec_float_elem_digits10)
                                  +                          (((prec_digits % cpp_dec_float_elem_digits10) != 0) ? 1 : 0));

      prec_elem = (std::min)(cpp_dec_float_elem_number, (std::max)(elems, static_cast<std::int32_t>(2)));
   }
   static cpp_dec_float pow2(long long i);
   exponent_type order() const
   {
      const bool bo_order_is_zero = ((!(isfinite)()) || (data[0] == static_cast<std::uint32_t>(0u)));
      //
      // Binary search to find the order of the leading term:
      //
      exponent_type prefix = 0;

      if (data[0] >= 100000UL)
      {
         if (data[0] >= 10000000UL)
         {
            if (data[0] >= 100000000UL)
            {
               if (data[0] >= 1000000000UL)
                  prefix = 9;
               else
                  prefix = 8;
            }
            else
               prefix = 7;
         }
         else
         {
            if (data[0] >= 1000000UL)
               prefix = 6;
            else
               prefix = 5;
         }
      }
      else
      {
         if (data[0] >= 1000UL)
         {
            if (data[0] >= 10000UL)
               prefix = 4;
            else
               prefix = 3;
         }
         else
         {
            if (data[0] >= 100)
               prefix = 2;
            else if (data[0] >= 10)
               prefix = 1;
         }
      }

      return (bo_order_is_zero ? static_cast<exponent_type>(0) : static_cast<exponent_type>(exp + prefix));
   }

   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      for (unsigned i = 0; i < data.size(); ++i)
         ar& boost::make_nvp("digit", data[i]);
      ar& boost::make_nvp("exponent", exp);
      ar& boost::make_nvp("sign", neg);
      ar& boost::make_nvp("class-type", fpclass);
      ar& boost::make_nvp("precision", prec_elem);
   }
   #endif

 private:
   static bool data_elem_is_non_zero_predicate(const std::uint32_t& d) { return (d != static_cast<std::uint32_t>(0u)); }
   static bool data_elem_is_non_nine_predicate(const std::uint32_t& d) { return (d != static_cast<std::uint32_t>(cpp_dec_float::cpp_dec_float_elem_mask - 1)); }
   static bool char_is_nonzero_predicate(const char& c) { return (c != static_cast<char>('0')); }

   void from_unsigned_long_long(const unsigned long long u);

   template <typename InputIteratorTypeLeft,
             typename InputIteratorTypeRight>
   static int compare_ranges(InputIteratorTypeLeft  a,
                             InputIteratorTypeRight b,
                             const std::uint32_t    count = cpp_dec_float_elem_number);

   static std::uint32_t eval_add_n(      std::uint32_t* r,
                                   const std::uint32_t* u,
                                   const std::uint32_t* v,
                                   const std::int32_t   count);

   static std::uint32_t eval_subtract_n(      std::uint32_t* r,
                                        const std::uint32_t* u,
                                        const std::uint32_t* v,
                                        const std::int32_t   count);

   static void eval_multiply_n_by_n_to_2n(      std::uint32_t* r,
                                          const std::uint32_t* a,
                                          const std::uint32_t* b,
                                          const std::uint32_t  count);

   static std::uint32_t mul_loop_n(std::uint32_t* const u, std::uint32_t n, const std::int32_t p);
   static std::uint32_t div_loop_n(std::uint32_t* const u, std::uint32_t n, const std::int32_t p);

   static void eval_multiply_kara_propagate_carry (std::uint32_t* t, const std::uint32_t n, const std::uint32_t carry);
   static void eval_multiply_kara_propagate_borrow(std::uint32_t* t, const std::uint32_t n, const bool has_borrow);
   static void eval_multiply_kara_n_by_n_to_2n    (      std::uint32_t* r,
                                                   const std::uint32_t* a,
                                                   const std::uint32_t* b,
                                                   const std::uint32_t  n,
                                                         std::uint32_t* t);

   template<unsigned D>
   void eval_mul_dispatch_multiplication_method(
      const cpp_dec_float<D, ExponentType, Allocator>& v,
      const std::int32_t prec_elems_for_multiply,
      const typename std::enable_if<   (D == Digits10)
                                    && (cpp_dec_float<D, ExponentType, Allocator>::cpp_dec_float_elem_number < cpp_dec_float_elems_for_kara)>::type* = nullptr)
   {
      // Use school multiplication.

      using array_for_mul_result_type =
         typename std::conditional<std::is_void<Allocator>::value,
                                   detail::static_array <std::uint32_t, std::uint32_t(cpp_dec_float_elem_number * 2)>,
                                   detail::dynamic_array<std::uint32_t, std::uint32_t(cpp_dec_float_elem_number * 2), Allocator> >::type;

      array_for_mul_result_type result;

      eval_multiply_n_by_n_to_2n(result.data(), data.data(), v.data.data(), static_cast<std::uint32_t>(prec_elems_for_multiply));

      // Handle a potential carry.
      if(result[0U] != static_cast<std::uint32_t>(0U))
      {
         exp += static_cast<exponent_type>(cpp_dec_float_elem_digits10);

         // Shift the result of the multiplication one element to the right.
         std::copy(result.cbegin(),
                   result.cbegin() + static_cast<std::ptrdiff_t>(prec_elems_for_multiply),
                   data.begin());
      }
      else
      {
         std::copy(result.cbegin() + 1,
                   result.cbegin() + (std::min)(static_cast<std::int32_t>(prec_elems_for_multiply + 1), cpp_dec_float_elem_number),
                   data.begin());
      }
   }

   template<unsigned D>
   void eval_mul_dispatch_multiplication_method(
      const cpp_dec_float<D, ExponentType, Allocator>& v,
      const std::int32_t prec_elems_for_multiply,
      const typename std::enable_if<    (D == Digits10)
                                    && !(cpp_dec_float<D, ExponentType, Allocator>::cpp_dec_float_elem_number < cpp_dec_float_elems_for_kara)>::type* = nullptr)
   {
      if(prec_elems_for_multiply < cpp_dec_float_elems_for_kara)
      {
         // Use school multiplication.

         using array_for_mul_result_type =
            typename std::conditional<std::is_void<Allocator>::value,
                                      detail::static_array <std::uint32_t, std::uint32_t(cpp_dec_float_elem_number * 2)>,
                                      detail::dynamic_array<std::uint32_t, std::uint32_t(cpp_dec_float_elem_number * 2), Allocator> >::type;

         array_for_mul_result_type result;

         eval_multiply_n_by_n_to_2n(result.data(), data.data(), v.data.data(), static_cast<std::uint32_t>(prec_elems_for_multiply));

         // Handle a potential carry.
         if(result[0U] != static_cast<std::uint32_t>(0U))
         {
            exp += static_cast<exponent_type>(cpp_dec_float_elem_digits10);
         
            // Shift the result of the multiplication one element to the right.
            std::copy(result.cbegin(),
                      result.cbegin() + static_cast<std::ptrdiff_t>(prec_elems_for_multiply),
                      data.begin());
         }
         else
         {
            std::copy(result.cbegin() + 1,
                      result.cbegin() + (std::min)(static_cast<std::int32_t>(prec_elems_for_multiply + 1), cpp_dec_float_elem_number),
                      data.begin());
         }
      }
      else
      {
         // Use Karatsuba multiplication.

         using array_for_kara_tmp_type =
            typename std::conditional<std::is_void<Allocator>::value,
                                      detail::static_array <std::uint32_t, detail::a029750::a029750_as_constexpr(static_cast<std::uint32_t>(cpp_dec_float_elem_number)) * 8U>,
                                      detail::dynamic_array<std::uint32_t, detail::a029750::a029750_as_constexpr(static_cast<std::uint32_t>(cpp_dec_float_elem_number)) * 8U, Allocator> >::type;

         // Sloanes's A029747: Numbers of the form 2^k times 1, 3 or 5.
         const std::uint32_t kara_elems_for_multiply =
            detail::a029750::a029750_as_runtime_value(static_cast<std::uint32_t>(prec_elems_for_multiply));

         array_for_kara_tmp_type my_kara_mul_pool;

         std::uint32_t* result  = my_kara_mul_pool.data() + (kara_elems_for_multiply * 0U);
         std::uint32_t* t       = my_kara_mul_pool.data() + (kara_elems_for_multiply * 2U);
         std::uint32_t* u_local = my_kara_mul_pool.data() + (kara_elems_for_multiply * 6U);
         std::uint32_t* v_local = my_kara_mul_pool.data() + (kara_elems_for_multiply * 7U);

         std::copy(  data.cbegin(),   data.cbegin() + prec_elems_for_multiply, u_local);
         std::copy(v.data.cbegin(), v.data.cbegin() + prec_elems_for_multiply, v_local);

         eval_multiply_kara_n_by_n_to_2n(result,
                                         u_local,
                                         v_local,
                                         kara_elems_for_multiply,
                                         t);

         // Handle a potential carry.
         if(result[0U] != static_cast<std::uint32_t>(0U))
         {
            exp += static_cast<exponent_type>(cpp_dec_float_elem_digits10);

            // Shift the result of the multiplication one element to the right.
            std::copy(result,
                      result + static_cast<std::ptrdiff_t>(prec_elems_for_multiply),
                      data.begin());
         }
         else
         {
            std::copy(result + 1,
                      result + (std::min)(static_cast<std::int32_t>(prec_elems_for_multiply + 1), cpp_dec_float_elem_number),
                      data.begin());
         }
      }
   }

   bool rd_string(const char* const s);

   template <unsigned D, class ET, class A>
   friend class cpp_dec_float;
};

template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_radix;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10_limit_lo;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10_limit_hi;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr ExponentType cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_exp;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr ExponentType cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr ExponentType cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_exp10;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr ExponentType cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp10;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_elem_digits10;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_elem_number;
template <unsigned Digits10, class ExponentType, class Allocator>
constexpr std::int32_t cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_elem_mask;

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::operator+=(const cpp_dec_float<Digits10, ExponentType, Allocator>& v)
{
   if ((isnan)())
   {
      return *this;
   }

   if ((isinf)())
   {
      if ((v.isinf)() && (isneg() != v.isneg()))
      {
         *this = nan();
      }
      return *this;
   }

   if (iszero())
   {
      return operator=(v);
   }

   if ((v.isnan)() || (v.isinf)())
   {
      *this = v;
      return *this;
   }

   // Get the offset for the add/sub operation.
   constexpr exponent_type max_delta_exp =
     static_cast<exponent_type>((cpp_dec_float_elem_number - 1) * cpp_dec_float_elem_digits10);

   const exponent_type ofs_exp = static_cast<exponent_type>(exp - v.exp);

   // Check if the operation is out of range, requiring special handling.
   if (v.iszero() || (ofs_exp > max_delta_exp))
   {
      // Result is *this unchanged since v is negligible compared to *this.
      return *this;
   }
   else if (ofs_exp < -max_delta_exp)
   {
      // Result is *this = v since *this is negligible compared to v.
      return operator=(v);
   }

   // Do the add/sub operation.

   typename array_type::pointer       p_u    = data.data();
   typename array_type::const_pointer p_v    = v.data.data();
   bool                               b_copy = false;
   const std::int32_t                 ofs    = static_cast<std::int32_t>(static_cast<std::int32_t>(ofs_exp) / cpp_dec_float_elem_digits10);
   array_type                         n_data;

   if (neg == v.neg)
   {
      // Add v to *this, where the data array of either *this or v
      // might have to be treated with a positive, negative or zero offset.
      // The result is stored in *this. The data are added one element
      // at a time, each element with carry.
      if (ofs >= static_cast<std::int32_t>(0))
      {
         std::copy(v.data.cbegin(), v.data.cend() - static_cast<std::ptrdiff_t>(ofs), n_data.begin() + static_cast<std::ptrdiff_t>(ofs));
         std::fill(n_data.begin(), n_data.begin() + static_cast<std::ptrdiff_t>(ofs), static_cast<std::uint32_t>(0u));
         p_v = n_data.data();
      }
      else
      {
         std::copy(data.cbegin(), data.cend() - static_cast<std::ptrdiff_t>(-ofs), n_data.begin() + static_cast<std::ptrdiff_t>(-ofs));
         std::fill(n_data.begin(), n_data.begin() + static_cast<std::ptrdiff_t>(-ofs), static_cast<std::uint32_t>(0u));
         p_u    = n_data.data();
         b_copy = true;
      }

      // Addition algorithm
      const std::uint32_t carry = eval_add_n(p_u, p_u, p_v, cpp_dec_float_elem_number);

      if (b_copy)
      {
         data = n_data;
         exp  = v.exp;
      }

      // There needs to be a carry into the element -1 of the array data
      if (carry != static_cast<std::uint32_t>(0u))
      {
         std::copy_backward(data.cbegin(), data.cend() - static_cast<std::size_t>(1u), data.end());
         data[0] = carry;
         exp += static_cast<exponent_type>(cpp_dec_float_elem_digits10);
      }
   }
   else
   {
      // Subtract v from *this, where the data array of either *this or v
      // might have to be treated with a positive, negative or zero offset.
      if ((ofs > static_cast<std::int32_t>(0)) || ((ofs == static_cast<std::int32_t>(0)) && (compare_ranges(data.cbegin(), v.data.cbegin()) > static_cast<std::int32_t>(0))))
      {
         // In this case, |u| > |v| and ofs is positive.
         // Copy the data of v, shifted down to a lower value
         // into the data array m_n. Set the operand pointer p_v
         // to point to the copied, shifted data m_n.
         std::copy(v.data.cbegin(), v.data.cend() - static_cast<std::ptrdiff_t>(ofs), n_data.begin() + static_cast<std::ptrdiff_t>(ofs));
         std::fill(n_data.begin(), n_data.begin() + static_cast<std::ptrdiff_t>(ofs), static_cast<std::uint32_t>(0u));
         p_v = n_data.data();
      }
      else
      {
         if (ofs != static_cast<std::int32_t>(0))
         {
            // In this case, |u| < |v| and ofs is negative.
            // Shift the data of u down to a lower value.
            std::copy_backward(data.cbegin(), data.cend() - static_cast<std::ptrdiff_t>(-ofs), data.end());
            std::fill(data.begin(), data.begin() + static_cast<std::ptrdiff_t>(-ofs), static_cast<std::uint32_t>(0u));
         }

         // Copy the data of v into the data array n_data.
         // Set the u-pointer p_u to point to m_n and the
         // operand pointer p_v to point to the shifted
         // data m_data.
         n_data = v.data;
         p_u    = n_data.data();
         p_v    = data.data();
         b_copy = true;
      }

      // Subtraction algorithm
      static_cast<void>(eval_subtract_n(p_u, p_u, p_v, cpp_dec_float_elem_number));

      if (b_copy)
      {
         data = n_data;
         exp  = v.exp;
         neg  = v.neg;
      }

      // Is it necessary to justify the data?
      const typename array_type::const_iterator first_nonzero_elem = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate);

      if (first_nonzero_elem != data.begin())
      {
         if (first_nonzero_elem == data.end())
         {
            // This result of the subtraction is exactly zero.
            // Reset the sign and the exponent.
            neg = false;
            exp = static_cast<exponent_type>(0);
         }
         else
         {
            // Justify the data
            const std::size_t sj = static_cast<std::size_t>(std::distance<typename array_type::const_iterator>(data.begin(), first_nonzero_elem));

            std::copy(data.begin() + static_cast<std::ptrdiff_t>(sj), data.end(), data.begin());
            std::fill(data.end() - static_cast<std::ptrdiff_t>(sj), data.end(), static_cast<std::uint32_t>(0u));

            exp -= static_cast<exponent_type>(sj * static_cast<std::size_t>(cpp_dec_float_elem_digits10));
         }
      }
   }

   // Handle underflow.
   if (iszero())
      return (*this = zero());

   // Check for potential overflow.
   const bool b_result_might_overflow = (exp >= static_cast<exponent_type>(cpp_dec_float_max_exp10));

   // Handle overflow.
   if (b_result_might_overflow)
   {
      const bool b_result_is_neg = neg;
      neg                        = false;

      if (compare((cpp_dec_float::max)()) > 0)
         *this = inf();

      neg = b_result_is_neg;
   }

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::operator-=(const cpp_dec_float<Digits10, ExponentType, Allocator>& v)
{
   // Use *this - v = -(-*this + v).
   negate();
   *this += v;
   negate();
   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::operator*=(const cpp_dec_float<Digits10, ExponentType, Allocator>& v)
{
   // Evaluate the sign of the result.
   const bool b_result_is_neg = (neg != v.neg);

   // Artificially set the sign of the result to be positive.
   neg = false;

   // Handle special cases like zero, inf and NaN.
   const bool b_u_is_inf  = (isinf)();
   const bool b_v_is_inf  = (v.isinf)();
   const bool b_u_is_zero = iszero();
   const bool b_v_is_zero = v.iszero();

   if (((isnan)() || (v.isnan)()) || (b_u_is_inf && b_v_is_zero) || (b_v_is_inf && b_u_is_zero))
   {
      *this = nan();
      return *this;
   }

   if (b_u_is_inf || b_v_is_inf)
   {
      *this = inf();
      if (b_result_is_neg)
         negate();
      return *this;
   }

   if (b_u_is_zero || b_v_is_zero)
   {
      return *this = zero();
   }

   // Check for potential overflow or underflow.
   const bool b_result_might_overflow  = ((exp + v.exp) >= static_cast<exponent_type>(cpp_dec_float_max_exp10));
   const bool b_result_might_underflow = ((exp + v.exp) <= static_cast<exponent_type>(cpp_dec_float_min_exp10));

   // Set the exponent of the result.
   exp += v.exp;

   const std::int32_t prec_mul = (std::min)(prec_elem, v.prec_elem);

   eval_mul_dispatch_multiplication_method(v, prec_mul);

   // Handle overflow.
   if (b_result_might_overflow && (compare((cpp_dec_float::max)()) > 0))
   {
      *this = inf();
   }

   // Handle underflow.
   if (b_result_might_underflow && (compare((cpp_dec_float::min)()) < 0))
   {
      *this = zero();

      return *this;
   }

   // Set the sign of the result.
   neg = b_result_is_neg;

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::operator/=(const cpp_dec_float<Digits10, ExponentType, Allocator>& v)
{
   if (iszero())
   {
      if ((v.isnan)())
      {
         return *this = v;
      }
      else if (v.iszero())
      {
         return *this = nan();
      }
   }

   const bool u_and_v_are_finite_and_identical = ((isfinite)() && (fpclass == v.fpclass) && (exp == v.exp) && (compare_ranges(data.cbegin(), v.data.cbegin()) == static_cast<std::int32_t>(0)));

   if (u_and_v_are_finite_and_identical)
   {
      if (neg != v.neg)
      {
         *this = one();
         negate();
      }
      else
         *this = one();
      return *this;
   }
   else
   {
      cpp_dec_float t(v);
      t.calculate_inv();
      return operator*=(t);
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::mul_unsigned_long_long(const unsigned long long n)
{
   // Multiply *this with a constant unsigned long long.

   // Evaluate the sign of the result.
   const bool b_neg = neg;

   // Artificially set the sign of the result to be positive.
   neg = false;

   // Handle special cases like zero, inf and NaN.
   const bool b_u_is_inf  = (isinf)();
   const bool b_n_is_zero = (n == static_cast<std::int32_t>(0));

   if ((isnan)() || (b_u_is_inf && b_n_is_zero))
   {
      return (*this = nan());
   }

   if (b_u_is_inf)
   {
      *this = inf();
      if (b_neg)
         negate();
      return *this;
   }

   if (iszero() || b_n_is_zero)
   {
      // Multiplication by zero.
      return *this = zero();
   }

   if (n >= static_cast<unsigned long long>(cpp_dec_float_elem_mask))
   {
      neg = b_neg;
      cpp_dec_float t;
      t = n;
      return operator*=(t);
   }

   if (n == static_cast<unsigned long long>(1u))
   {
      neg = b_neg;
      return *this;
   }

   // Set up the multiplication loop.
   const std::uint32_t nn    = static_cast<std::uint32_t>(n);
   const std::uint32_t carry = mul_loop_n(data.data(), nn, prec_elem);

   // Handle the carry and adjust the exponent.
   if (carry != static_cast<std::uint32_t>(0u))
   {
      exp += static_cast<exponent_type>(cpp_dec_float_elem_digits10);

      // Shift the result of the multiplication one element to the right.
      std::copy_backward(data.begin(),
                         data.begin() + static_cast<std::ptrdiff_t>(prec_elem - static_cast<std::int32_t>(1)),
                         data.begin() + static_cast<std::ptrdiff_t>(prec_elem));

      data.front() = static_cast<std::uint32_t>(carry);
   }

   // Check for potential overflow.
   const bool b_result_might_overflow = (exp >= cpp_dec_float_max_exp10);

   // Handle overflow.
   if (b_result_might_overflow && (compare((cpp_dec_float::max)()) > 0))
   {
      *this = inf();
   }

   // Set the sign.
   neg = b_neg;

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::div_unsigned_long_long(const unsigned long long n)
{
   // Divide *this by a constant unsigned long long.

   // Evaluate the sign of the result.
   const bool b_neg = neg;

   // Artificially set the sign of the result to be positive.
   neg = false;

   // Handle special cases like zero, inf and NaN.
   if ((isnan)())
   {
      return *this;
   }

   if ((isinf)())
   {
      *this = inf();
      if (b_neg)
         negate();
      return *this;
   }

   if (n == static_cast<unsigned long long>(0u))
   {
      // Divide by 0.
      if (iszero())
      {
         *this = nan();
         return *this;
      }
      else
      {
         *this = inf();
         if (isneg())
            negate();
         return *this;
      }
   }

   if (iszero())
   {
      return *this;
   }

   if (n >= static_cast<unsigned long long>(cpp_dec_float_elem_mask))
   {
      neg = b_neg;
      cpp_dec_float t;
      t = n;
      return operator/=(t);
   }

   const std::uint32_t nn = static_cast<std::uint32_t>(n);

   if (nn > static_cast<std::uint32_t>(1u))
   {
      // Do the division loop.
      const std::uint32_t prev = div_loop_n(data.data(), nn, prec_elem);

      // Determine if one leading zero is in the result data.
      if (data[0] == static_cast<std::uint32_t>(0u))
      {
         // Adjust the exponent
         exp -= static_cast<exponent_type>(cpp_dec_float_elem_digits10);

         // Shift result of the division one element to the left.
         std::copy(data.begin() + static_cast<std::ptrdiff_t>(1),
                   data.begin() + static_cast<std::ptrdiff_t>(prec_elem - static_cast<std::int32_t>(1)),
                   data.begin());

         data[static_cast<std::size_t>(prec_elem - static_cast<std::int32_t>(1))] = static_cast<std::uint32_t>(static_cast<std::uint64_t>(prev * static_cast<std::uint64_t>(cpp_dec_float_elem_mask)) / nn);
      }
   }

   // Check for potential underflow.
   const bool b_result_might_underflow = (exp <= cpp_dec_float_min_exp10);

   // Handle underflow.
   if (b_result_might_underflow && (compare((cpp_dec_float::min)()) < 0))
      return (*this = zero());

   // Set the sign of the result.
   neg = b_neg;

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::calculate_inv()
{
   // Compute the inverse of *this.
   const bool b_neg = neg;

   neg = false;

   // Handle special cases like zero, inf and NaN.
   if (iszero())
   {
      *this = inf();
      if (b_neg)
         negate();
      return *this;
   }

   if ((isnan)())
   {
      return *this;
   }

   if ((isinf)())
   {
      return *this = zero();
   }

   if (isone())
   {
      if (b_neg)
         negate();
      return *this;
   }

   // Save the original *this.
   cpp_dec_float<Digits10, ExponentType, Allocator> x(*this);

   // Generate the initial estimate using division.
   // Extract the mantissa and exponent for a "manual"
   // computation of the estimate.
   double        dd;
   exponent_type ne;
   x.extract_parts(dd, ne);

   // Do the inverse estimate using double precision estimates of mantissa and exponent.
   operator=(cpp_dec_float<Digits10, ExponentType, Allocator>(1.0 / dd, -ne));

   // Compute the inverse of *this. Quadratically convergent Newton-Raphson iteration
   // is used. During the iterative steps, the precision of the calculation is limited
   // to the minimum required in order to minimize the run-time.

   constexpr std::int32_t double_digits10_minus_a_few = std::numeric_limits<double>::digits10 - 3;

   for (std::int32_t digits = double_digits10_minus_a_few; digits <= cpp_dec_float_max_digits10; digits *= static_cast<std::int32_t>(2))
   {
      // Adjust precision of the terms.
      precision(static_cast<std::int32_t>((digits + 10) * static_cast<std::int32_t>(2)));
      x.precision(static_cast<std::int32_t>((digits + 10) * static_cast<std::int32_t>(2)));

      // Next iteration.
      cpp_dec_float t(*this);
      t *= x;
      t -= two();
      t.negate();
      *this *= t;
   }

   neg = b_neg;

   prec_elem = cpp_dec_float_elem_number;

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>& cpp_dec_float<Digits10, ExponentType, Allocator>::calculate_sqrt()
{
   // Compute the square root of *this.

   if ((isinf)() && !isneg())
   {
      return *this;
   }

   if (isneg() || (!(isfinite)()))
   {
      *this = nan();
      errno = EDOM;
      return *this;
   }

   if (iszero() || isone())
   {
      return *this;
   }

   // Save the original *this.
   cpp_dec_float<Digits10, ExponentType, Allocator> x(*this);

   // Generate the initial estimate using division.
   // Extract the mantissa and exponent for a "manual"
   // computation of the estimate.
   double        dd;
   exponent_type ne;
   extract_parts(dd, ne);

   // Force the exponent to be an even multiple of two.
   if ((ne % static_cast<exponent_type>(2)) != static_cast<exponent_type>(0))
   {
      ++ne;
      dd /= 10.0;
   }

   // Setup the iteration.
   // Estimate the square root using simple manipulations.
   const double sqd = std::sqrt(dd);

   *this = cpp_dec_float<Digits10, ExponentType, Allocator>(sqd, static_cast<ExponentType>(ne / static_cast<ExponentType>(2)));

   // Estimate 1.0 / (2.0 * x0) using simple manipulations.
   cpp_dec_float<Digits10, ExponentType, Allocator> vi(0.5 / sqd, static_cast<ExponentType>(-ne / static_cast<ExponentType>(2)));

   // Compute the square root of x. Coupled Newton iteration
   // as described in "Pi Unleashed" is used. During the
   // iterative steps, the precision of the calculation is
   // limited to the minimum required in order to minimize
   // the run-time.
   //
   // Book reference to "Pi Unleashed:
   // https://www.springer.com/gp/book/9783642567353

   constexpr std::uint32_t double_digits10_minus_a_few = std::numeric_limits<double>::digits10 - 3;

   for (std::int32_t digits = double_digits10_minus_a_few; digits <= cpp_dec_float_max_digits10; digits *= 2)
   {
      // Adjust precision of the terms.
      precision((digits + 10) * 2);
      vi.precision((digits + 10) * 2);

      // Next iteration of vi
      cpp_dec_float t(*this);
      t *= vi;
      t.negate();
      t.mul_unsigned_long_long(2u);
      t += one();
      t *= vi;
      vi += t;

      // Next iteration of *this
      t = *this;
      t *= *this;
      t.negate();
      t += x;
      t *= vi;
      *this += t;
   }

   prec_elem = cpp_dec_float_elem_number;

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
int cpp_dec_float<Digits10, ExponentType, Allocator>::compare(const cpp_dec_float& v) const
{
   // Compare v with *this.
   // Return +1 for *this > v
   // 0 for *this = v
   // -1 for *this < v

   // Handle all non-finite cases.
   if ((!(isfinite)()) || (!(v.isfinite)()))
   {
      // NaN can never equal NaN. Return an implementation-dependent
      // signed result. Also note that comparison of NaN with NaN
      // using operators greater-than or less-than is undefined.
      if ((isnan)() || (v.isnan)())
      {
         return ((isnan)() ? 1 : -1);
      }

      if ((isinf)() && (v.isinf)())
      {
         // Both *this and v are infinite. They are equal if they have the same sign.
         // Otherwise, *this is less than v if and only if *this is negative.
         return ((neg == v.neg) ? 0 : (neg ? -1 : 1));
      }

      if ((isinf)())
      {
         // *this is infinite, but v is finite.
         // So negative infinite *this is less than any finite v.
         // Whereas positive infinite *this is greater than any finite v.
         return (isneg() ? -1 : 1);
      }
      else
      {
         // *this is finite, and v is infinite.
         // So any finite *this is greater than negative infinite v.
         // Whereas any finite *this is less than positive infinite v.
         return (v.neg ? 1 : -1);
      }
   }

   // And now handle all *finite* cases.
   if (iszero())
   {
      // The value of *this is zero and v is either zero or non-zero.
      return (v.iszero() ? 0
                         : (v.neg ? 1 : -1));
   }
   else if (v.iszero())
   {
      // The value of v is zero and *this is non-zero.
      return (neg ? -1 : 1);
   }
   else
   {
      // Both *this and v are non-zero.

      if (neg != v.neg)
      {
         // The signs are different.
         return (neg ? -1 : 1);
      }
      else if (exp != v.exp)
      {
         // The signs are the same and the exponents are different.
         const int val_cexpression = ((exp < v.exp) ? 1 : -1);

         return (neg ? val_cexpression : -val_cexpression);
      }
      else
      {
         // The signs are the same and the exponents are the same.
         // Compare the data.
         const int val_cmp_data = compare_ranges(data.cbegin(), v.data.cbegin());

         return ((!neg) ? val_cmp_data : -val_cmp_data);
      }
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
bool cpp_dec_float<Digits10, ExponentType, Allocator>::isone() const
{
   // Check if the value of *this is identically 1 or very close to 1.

   const bool not_negative_and_is_finite = ((!neg) && (isfinite)());

   if (not_negative_and_is_finite)
   {
      if ((data[0u] == static_cast<std::uint32_t>(1u)) && (exp == static_cast<exponent_type>(0)))
      {
         const typename array_type::const_iterator it_non_zero = std::find_if(data.begin(), data.end(), data_elem_is_non_zero_predicate);
         return (it_non_zero == data.end());
      }
      else if ((data[0u] == static_cast<std::uint32_t>(cpp_dec_float_elem_mask - 1)) && (exp == static_cast<exponent_type>(-cpp_dec_float_elem_digits10)))
      {
         const typename array_type::const_iterator it_non_nine = std::find_if(data.begin(), data.end(), data_elem_is_non_nine_predicate);
         return (it_non_nine == data.end());
      }
   }

   return false;
}

template <unsigned Digits10, class ExponentType, class Allocator>
bool cpp_dec_float<Digits10, ExponentType, Allocator>::isint() const
{
   if (fpclass != cpp_dec_float_finite)
   {
      return false;
   }

   if (iszero())
   {
      return true;
   }

   if (exp < static_cast<exponent_type>(0))
   {
      return false;
   } // |*this| < 1.

   const typename array_type::size_type offset_decimal_part = static_cast<typename array_type::size_type>(exp / cpp_dec_float_elem_digits10) + 1u;

   if (offset_decimal_part >= static_cast<typename array_type::size_type>(cpp_dec_float_elem_number))
   {
      // The number is too large to resolve the integer part.
      // It considered to be a pure integer.
      return true;
   }

   typename array_type::const_iterator it_non_zero = std::find_if(data.begin() + static_cast<std::ptrdiff_t>(offset_decimal_part), data.end(), data_elem_is_non_zero_predicate);

   return (it_non_zero == data.end());
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::extract_parts(double& mantissa, ExponentType& exponent) const
{
   // Extract the approximate parts mantissa and base-10 exponent from the input cpp_dec_float<Digits10, ExponentType, Allocator> value x.

   // Extracts the mantissa and exponent.
   exponent = exp;

   std::uint32_t p10  = static_cast<std::uint32_t>(1u);
   std::uint32_t test = data[0u];

   for (;;)
   {
      test /= static_cast<std::uint32_t>(10u);

      if (test == static_cast<std::uint32_t>(0u))
      {
         break;
      }

      p10 *= static_cast<std::uint32_t>(10u);
      ++exponent;
   }

   // Establish the upper bound of limbs for extracting the double.
   const int max_elem_in_double_count = static_cast<int>(static_cast<std::int32_t>(std::numeric_limits<double>::digits10) / cpp_dec_float_elem_digits10) + (static_cast<int>(static_cast<std::int32_t>(std::numeric_limits<double>::digits10) % cpp_dec_float_elem_digits10) != 0 ? 1 : 0) + 1;

   // And make sure this upper bound stays within bounds of the elems.
   const std::size_t max_elem_extract_count = static_cast<std::size_t>((std::min)(static_cast<std::int32_t>(max_elem_in_double_count), cpp_dec_float_elem_number));

   // Extract into the mantissa the first limb, extracted as a double.
   mantissa     = static_cast<double>(data[0]);
   double scale = 1.0;

   // Extract the rest of the mantissa piecewise from the limbs.
   for (std::size_t i = 1u; i < max_elem_extract_count; i++)
   {
      scale /= static_cast<double>(cpp_dec_float_elem_mask);
      mantissa += (static_cast<double>(data[i]) * scale);
   }

   mantissa /= static_cast<double>(p10);

   if (neg)
   {
      mantissa = -mantissa;
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
double cpp_dec_float<Digits10, ExponentType, Allocator>::extract_double() const
{
   // Returns the double conversion of a cpp_dec_float<Digits10, ExponentType, Allocator>.

   // Check for non-normal cpp_dec_float<Digits10, ExponentType, Allocator>.
   if (!(isfinite)())
   {
      if ((isnan)())
      {
         return std::numeric_limits<double>::quiet_NaN();
      }
      else
      {
         return ((!neg) ? std::numeric_limits<double>::infinity()
                        : -std::numeric_limits<double>::infinity());
      }
   }

   cpp_dec_float<Digits10, ExponentType, Allocator> xx(*this);
   if (xx.isneg())
      xx.negate();

   // Check if *this cpp_dec_float<Digits10, ExponentType, Allocator> is zero.
   if (iszero() || (xx.compare(double_min()) < 0))
   {
      return 0.0;
   }

   // Check if *this cpp_dec_float<Digits10, ExponentType, Allocator> exceeds the maximum of double.
   if (xx.compare(double_max()) > 0)
   {
      return ((!neg) ? std::numeric_limits<double>::infinity()
                     : -std::numeric_limits<double>::infinity());
   }

   std::stringstream ss;
   ss.imbue(std::locale::classic());

   ss << str(std::numeric_limits<double>::digits10 + (2 + 1), std::ios_base::scientific);

   double d;
   ss >> d;

   return d;
}

template <unsigned Digits10, class ExponentType, class Allocator>
long double cpp_dec_float<Digits10, ExponentType, Allocator>::extract_long_double() const
{
   // Returns the long double conversion of a cpp_dec_float<Digits10, ExponentType, Allocator>.

   // Check if *this cpp_dec_float<Digits10, ExponentType, Allocator> is subnormal.
   if (!(isfinite)())
   {
      if ((isnan)())
      {
         return std::numeric_limits<long double>::quiet_NaN();
      }
      else
      {
         return ((!neg) ? std::numeric_limits<long double>::infinity()
                        : -std::numeric_limits<long double>::infinity());
      }
   }

   cpp_dec_float<Digits10, ExponentType, Allocator> xx(*this);
   if (xx.isneg())
      xx.negate();

   // Check if *this cpp_dec_float<Digits10, ExponentType, Allocator> is zero.
   if (iszero() || (xx.compare(long_double_min()) < 0))
   {
      return static_cast<long double>(0.0);
   }

   // Check if *this cpp_dec_float<Digits10, ExponentType, Allocator> exceeds the maximum of double.
   if (xx.compare(long_double_max()) > 0)
   {
      return ((!neg) ? std::numeric_limits<long double>::infinity()
                     : -std::numeric_limits<long double>::infinity());
   }

   std::stringstream ss;
   ss.imbue(std::locale::classic());

   ss << str(std::numeric_limits<long double>::digits10 + (2 + 1), std::ios_base::scientific);

   long double ld;
   ss >> ld;

   return ld;
}

template <unsigned Digits10, class ExponentType, class Allocator>
long long cpp_dec_float<Digits10, ExponentType, Allocator>::extract_signed_long_long() const
{
   // Extracts a signed long long from *this.
   // If (x > maximum of long long) or (x < minimum of long long),
   // then the maximum or minimum of long long is returned accordingly.

   if (exp < static_cast<exponent_type>(0))
   {
      return static_cast<long long>(0);
   }

   const bool b_neg = isneg();

   unsigned long long val;

   if ((!b_neg) && (compare(long_long_max()) > 0))
   {
      return (std::numeric_limits<long long>::max)();
   }
   else if (b_neg && (compare(long_long_min()) < 0))
   {
      return (std::numeric_limits<long long>::min)();
   }
   else
   {
      // Extract the data into an unsigned long long value.
      cpp_dec_float<Digits10, ExponentType, Allocator> xn(extract_integer_part());
      if (xn.isneg())
         xn.negate();

      val = static_cast<unsigned long long>(xn.data[0]);

      const std::int32_t imax = (std::min)(static_cast<std::int32_t>(static_cast<std::int32_t>(xn.exp) / cpp_dec_float_elem_digits10), static_cast<std::int32_t>(cpp_dec_float_elem_number - static_cast<std::int32_t>(1)));

      for (std::int32_t i = static_cast<std::int32_t>(1); i <= imax; i++)
      {
         val *= static_cast<unsigned long long>(cpp_dec_float_elem_mask);
         val += static_cast<unsigned long long>(xn.data[static_cast<std::size_t>(i)]);
      }
   }

   if (!b_neg)
   {
      return static_cast<long long>(val);
   }
   else
   {
      // This strange expression avoids a hardware trap in the corner case
      // that val is the most negative value permitted in long long.
      // See https://svn.boost.org/trac/boost/ticket/9740.
      //
      long long sval = static_cast<long long>(val - 1);
      sval                       = -sval;
      --sval;
      return sval;
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
unsigned long long cpp_dec_float<Digits10, ExponentType, Allocator>::extract_unsigned_long_long() const
{
   // Extracts an unsigned long long from *this.
   // If x exceeds the maximum of unsigned long long,
   // then the maximum of unsigned long long is returned.
   // If x is negative, then the unsigned long long cast of
   // the long long extracted value is returned.

   if (isneg())
   {
      return static_cast<unsigned long long>(extract_signed_long_long());
   }

   if (exp < static_cast<exponent_type>(0))
   {
      return static_cast<unsigned long long>(0u);
   }

   const cpp_dec_float<Digits10, ExponentType, Allocator> xn(extract_integer_part());

   unsigned long long val;

   if (xn.compare(ulong_long_max()) > 0)
   {
      return (std::numeric_limits<unsigned long long>::max)();
   }
   else
   {
      // Extract the data into an unsigned long long value.
      val = static_cast<unsigned long long>(xn.data[0]);

      const std::int32_t imax = (std::min)(static_cast<std::int32_t>(static_cast<std::int32_t>(xn.exp) / cpp_dec_float_elem_digits10), static_cast<std::int32_t>(cpp_dec_float_elem_number - static_cast<std::int32_t>(1)));

      for (std::int32_t i = static_cast<std::int32_t>(1); i <= imax; i++)
      {
         val *= static_cast<unsigned long long>(cpp_dec_float_elem_mask);
         val += static_cast<unsigned long long>(xn.data[i]);
      }
   }

   return val;
}

#ifdef BOOST_HAS_INT128

template <unsigned Digits10, class ExponentType, class Allocator>
int128_type cpp_dec_float<Digits10, ExponentType, Allocator>::extract_signed_int128() const
{
   // Extracts a signed __int128 from *this.
   // If (x > maximum of __int128) or (x < minimum of __int128),
   // then the maximum or minimum of long long is returned accordingly.

   if (exp < static_cast<exponent_type>(0))
   {
      return static_cast<int128_type>(0);
   }

   const bool b_neg = isneg();
   cpp_dec_float<Digits10, ExponentType, Allocator> i128max;
   i128max = ((~static_cast<uint128_type>(0)) >> 1);
   cpp_dec_float<Digits10, ExponentType, Allocator> i128min;
   i128min = (-1 - static_cast<int128_type>((static_cast<uint128_type>(1) << 127) - 1));

   uint128_type val;

   if ((!b_neg) && (compare(i128max) > 0))
   {
      return ((~static_cast<uint128_type>(0)) >> 1);
   }
   else if (b_neg && (compare(i128min) < 0))
   {
      return (-1 - static_cast<int128_type>((static_cast<uint128_type>(1) << 127) - 1));
   }
   else
   {
      // Extract the data into an unsigned long long value.
      cpp_dec_float<Digits10, ExponentType, Allocator> xn(extract_integer_part());
      if (xn.isneg())
         xn.negate();

      val = static_cast<uint128_type>(xn.data[0]);

      const std::int32_t imax = (std::min)(static_cast<std::int32_t>(static_cast<std::int32_t>(xn.exp) / cpp_dec_float_elem_digits10), static_cast<std::int32_t>(cpp_dec_float_elem_number - static_cast<std::int32_t>(1)));

      for (std::int32_t i = static_cast<std::int32_t>(1); i <= imax; i++)
      {
         val *= static_cast<uint128_type>(cpp_dec_float_elem_mask);
         val += static_cast<uint128_type>(xn.data[static_cast<std::size_t>(i)]);
      }
   }

   if (!b_neg)
   {
      return static_cast<int128_type>(val);
   }
   else
   {
      // This strange expression avoids a hardware trap in the corner case
      // that val is the most negative value permitted in long long.
      // See https://svn.boost.org/trac/boost/ticket/9740.
      //
      int128_type sval = static_cast<int128_type>(val - 1);
      sval                       = -sval;
      --sval;
      return sval;
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
uint128_type cpp_dec_float<Digits10, ExponentType, Allocator>::extract_unsigned_int128() const
{
   // Extracts an unsigned __int128 from *this.
   // If x exceeds the maximum of unsigned __int128,
   // then the maximum of unsigned __int128 is returned.
   // If x is negative, then the unsigned __int128 cast of
   // the __int128 extracted value is returned.

   if (isneg())
   {
      return static_cast<uint128_type>(extract_signed_int128());
   }

   if (exp < static_cast<exponent_type>(0))
   {
      return 0u;
   }

   const cpp_dec_float<Digits10, ExponentType, Allocator> xn(extract_integer_part());
   cpp_dec_float<Digits10, ExponentType, Allocator>       i128max;
   i128max = (~static_cast<uint128_type>(0));

   uint128_type val;

   if (xn.compare(i128max) > 0)
   {
      return (~static_cast<uint128_type>(0));
   }
   else
   {
      // Extract the data into an unsigned long long value.
      val = static_cast<uint128_type>(xn.data[0]);

      const std::int32_t imax = (std::min)(static_cast<std::int32_t>(static_cast<std::int32_t>(xn.exp) / cpp_dec_float_elem_digits10), static_cast<std::int32_t>(cpp_dec_float_elem_number - static_cast<std::int32_t>(1)));

      for (std::int32_t i = static_cast<std::int32_t>(1); i <= imax; i++)
      {
         val *= static_cast<uint128_type>(cpp_dec_float_elem_mask);
         val += static_cast<uint128_type>(xn.data[i]);
      }
   }

   return val;
}

#endif

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator> cpp_dec_float<Digits10, ExponentType, Allocator>::extract_integer_part() const
{
   // Compute the signed integer part of x.

   if (!(isfinite)())
   {
      return *this;
   }

   if (exp < static_cast<ExponentType>(0))
   {
      // The absolute value of the number is smaller than 1.
      // Thus the integer part is zero.
      return zero();
   }

   // Truncate the digits from the decimal part, including guard digits
   // that do not belong to the integer part.

   // Make a local copy.
   cpp_dec_float<Digits10, ExponentType, Allocator> x = *this;

   // Clear out the decimal portion
   const std::size_t first_clear = (static_cast<std::size_t>(x.exp) / static_cast<std::size_t>(cpp_dec_float_elem_digits10)) + 1u;
   const std::size_t last_clear  =  static_cast<std::size_t>(cpp_dec_float_elem_number);

   if (first_clear < last_clear)
      std::fill(x.data.begin() + static_cast<std::ptrdiff_t>(first_clear), x.data.begin() + static_cast<std::ptrdiff_t>(last_clear), static_cast<std::uint32_t>(0u));

   return x;
}

template <unsigned Digits10, class ExponentType, class Allocator>
std::string cpp_dec_float<Digits10, ExponentType, Allocator>::str(std::intmax_t number_of_digits, std::ios_base::fmtflags f) const
{
   if ((this->isinf)())
   {
      if (this->isneg())
         return "-inf";
      else if (f & std::ios_base::showpos)
         return "+inf";
      else
         return "inf";
   }
   else if ((this->isnan)())
   {
      return "nan";
   }

   std::string     str;
   std::intmax_t org_digits(number_of_digits);
   exponent_type    my_exp = order();

   if (!(f & std::ios_base::fixed) && (number_of_digits == 0))
      number_of_digits = cpp_dec_float_max_digits10;

   if (f & std::ios_base::fixed)
   {
      number_of_digits += my_exp + 1;
   }
   else if (f & std::ios_base::scientific)
      ++number_of_digits;
   // Determine the number of elements needed to provide the requested digits from cpp_dec_float<Digits10, ExponentType, Allocator>.
   const std::size_t number_of_elements = (std::min)(static_cast<std::size_t>(static_cast<std::size_t>(number_of_digits / static_cast<std::intmax_t>(cpp_dec_float_elem_digits10)) + 2u),
                                                     static_cast<std::size_t>(cpp_dec_float_elem_number));

   // Extract the remaining digits from cpp_dec_float<Digits10, ExponentType, Allocator> after the decimal point.
   std::stringstream ss;
   ss.imbue(std::locale::classic());
   ss << data[0];
   // Extract all of the digits from cpp_dec_float<Digits10, ExponentType, Allocator>, beginning with the first data element.
   for (std::size_t i = static_cast<std::size_t>(1u); i < number_of_elements; i++)
   {
      ss << std::setw(static_cast<std::streamsize>(cpp_dec_float_elem_digits10))
         << std::setfill(static_cast<char>('0'))
         << data[i];
   }
   str += ss.str();

   bool have_leading_zeros = false;

   if (number_of_digits == 0)
   {
      // We only get here if the output format is "fixed" and we just need to
      // round the first non-zero digit.
      number_of_digits -= my_exp + 1; // reset to original value
      if (number_of_digits)
      {
         str.insert(static_cast<std::string::size_type>(0), std::string::size_type(number_of_digits), '0');
         have_leading_zeros = true;
      }
   }

   if (number_of_digits < 0)
   {
      str = "0";
      if (isneg())
         str.insert(static_cast<std::string::size_type>(0), 1, '-');
      boost::multiprecision::detail::format_float_string(str, 0, number_of_digits - my_exp - 1, f, this->iszero());
      return str;
   }
   else
   {
      // Cut the output to the size of the precision.
      if (str.length() > static_cast<std::string::size_type>(number_of_digits))
      {
         // Get the digit after the last needed digit for rounding
         const std::uint32_t round = static_cast<std::uint32_t>(static_cast<std::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits)]) - static_cast<std::uint32_t>('0'));

         bool need_round_up = round >= 5u;

         if (round == 5u)
         {
            const std::uint32_t ix = number_of_digits == 0 ? 0 : static_cast<std::uint32_t>(static_cast<std::uint32_t>(str[static_cast<std::string::size_type>(number_of_digits - 1)]) - static_cast<std::uint32_t>('0'));
            if ((ix & 1u) == 0)
            {
               // We have an even digit followed by a 5, so we might not actually need to round up
               // if all the remaining digits are zero:
               if (str.find_first_not_of('0', static_cast<std::string::size_type>(number_of_digits + 1)) == std::string::npos)
               {
                  bool all_zeros = true;
                  // No none-zero trailing digits in the string, now check whatever parts we didn't convert to the string:
                  for (std::size_t i = number_of_elements; i < data.size(); i++)
                  {
                     if (data[i])
                     {
                        all_zeros = false;
                        break;
                     }
                  }
                  if (all_zeros)
                     need_round_up = false; // tie break - round to even.
               }
            }
         }

         // Truncate the string
         str.erase(static_cast<std::string::size_type>(number_of_digits));

         if (need_round_up)
         {
            if (str.size())
            {
               std::size_t ix = static_cast<std::size_t>(str.length() - 1u);

               // Every trailing 9 must be rounded up
               while (ix && (static_cast<std::int32_t>(str.at(ix)) - static_cast<std::int32_t>('0') == static_cast<std::int32_t>(9)))
               {
                  str.at(ix) = static_cast<char>('0');
                  --ix;
               }

               if (!ix)
               {
                  // There were nothing but trailing nines.
                  if (static_cast<std::int32_t>(static_cast<std::int32_t>(str.at(ix)) - static_cast<std::int32_t>(0x30)) == static_cast<std::int32_t>(9))
                  {
                     // Increment up to the next order and adjust exponent.
                     str.at(ix) = static_cast<char>('1');
                     ++my_exp;
                  }
                  else
                  {
                     // Round up this digit.
                     ++str.at(ix);
                  }
               }
               else
               {
                  // Round up the last digit.
                  ++str[ix];
               }
            }
            else
            {
               str = "1";
               ++my_exp;
            }
         }
      }
   }

   if (have_leading_zeros)
   {
      // We need to take the zeros back out again, and correct the exponent
      // if we rounded up:
      if (str[std::string::size_type(number_of_digits - 1)] != '0')
      {
         ++my_exp;
         str.erase(0, std::string::size_type(number_of_digits - 1));
      }
      else
         str.erase(0, std::string::size_type(number_of_digits));
   }

   if (isneg())
      str.insert(static_cast<std::string::size_type>(0), 1, '-');

   boost::multiprecision::detail::format_float_string(str, my_exp, org_digits, f, this->iszero());
   return str;
}

template <unsigned Digits10, class ExponentType, class Allocator>
bool cpp_dec_float<Digits10, ExponentType, Allocator>::rd_string(const char* const s)
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif

      std::string str(s);

      // TBD: Using several regular expressions may significantly reduce
      // the code complexity (and perhaps the run-time) of rd_string().

      // Get a possible exponent and remove it.
      exp = static_cast<exponent_type>(0);

      std::size_t pos;

      if (((pos = str.find('e')) != std::string::npos) || ((pos = str.find('E')) != std::string::npos))
      {
         // Remove the exponent part from the string.
         #ifndef BOOST_MP_STANDALONE
         exp = boost::lexical_cast<exponent_type>(static_cast<const char*>(str.c_str() + (pos + 1u)));
         #else
         exp = static_cast<exponent_type>(std::atoll(static_cast<const char*>(str.c_str() + (pos + 1u))));
         #endif
         
         str = str.substr(static_cast<std::size_t>(0u), pos);
      }

      // Get a possible +/- sign and remove it.
      neg = false;

      if (str.size())
      {
         if (str[0] == '-')
         {
            neg = true;
            str.erase(0, 1);
         }
         else if (str[0] == '+')
         {
            str.erase(0, 1);
         }
      }
      //
      // Special cases for infinities and NaN's:
      //
      if ((str == "inf") || (str == "INF") || (str == "infinity") || (str == "INFINITY"))
      {
         if (neg)
         {
            *this = this->inf();
            this->negate();
         }
         else
            *this = this->inf();
         return true;
      }
      if ((str.size() >= 3) && ((str.substr(0, 3) == "nan") || (str.substr(0, 3) == "NAN") || (str.substr(0, 3) == "NaN")))
      {
         *this = this->nan();
         return true;
      }

      // Remove the leading zeros for all input types.
      const std::string::iterator fwd_it_leading_zero = std::find_if(str.begin(), str.end(), char_is_nonzero_predicate);

      if (fwd_it_leading_zero != str.begin())
      {
         if (fwd_it_leading_zero == str.end())
         {
            // The string contains nothing but leading zeros.
            // This string represents zero.
            operator=(zero());
            return true;
         }
         else
         {
            str.erase(str.begin(), fwd_it_leading_zero);
         }
      }

      // Put the input string into the standard cpp_dec_float<Digits10, ExponentType, Allocator> input form
      // aaa.bbbbE+/-n, where aaa has 1...cpp_dec_float_elem_digits10, bbbb has an
      // even multiple of cpp_dec_float_elem_digits10 which are possibly zero padded
      // on the right-end, and n is a signed 64-bit integer which is an
      // even multiple of cpp_dec_float_elem_digits10.

      // Find a possible decimal point.
      pos = str.find(static_cast<char>('.'));

      if (pos != std::string::npos)
      {
         // Remove all trailing insignificant zeros.
         const std::string::const_reverse_iterator rit_non_zero = std::find_if(str.rbegin(), str.rend(), char_is_nonzero_predicate);

         if (rit_non_zero != static_cast<std::string::const_reverse_iterator>(str.rbegin()))
         {
            const std::string::size_type ofs =
               static_cast<std::string::size_type>
               (
                    static_cast<std::ptrdiff_t>(str.length())
                  - std::distance<std::string::const_reverse_iterator>(str.rbegin(), rit_non_zero)
               );
            str.erase(str.begin() + static_cast<std::ptrdiff_t>(ofs), str.end());
         }

         // Check if the input is identically zero.
         if (str == std::string("."))
         {
            operator=(zero());
            return true;
         }

         // Remove leading significant zeros just after the decimal point
         // and adjust the exponent accordingly.
         // Note that the while-loop operates only on strings of the form ".000abcd..."
         // and peels away the zeros just after the decimal point.
         if (str.at(static_cast<std::size_t>(0u)) == static_cast<char>('.'))
         {
            const std::string::iterator it_non_zero = std::find_if(str.begin() + 1u, str.end(), char_is_nonzero_predicate);

            std::size_t delta_exp = static_cast<std::size_t>(0u);

            if (str.at(static_cast<std::size_t>(1u)) == static_cast<char>('0'))
            {
               delta_exp = static_cast<std::size_t>(std::distance<std::string::const_iterator>(str.begin() + 1u, it_non_zero));
            }

            // Bring one single digit into the mantissa and adjust the exponent accordingly.
            str.erase(str.begin(), it_non_zero);
            str.insert(static_cast<std::string::size_type>(1u), ".");
            exp -= static_cast<exponent_type>(delta_exp + 1u);
         }
      }
      else
      {
         // Input string has no decimal point: Append decimal point.
         str.append(".");
      }

      // Shift the decimal point such that the exponent is an even multiple of cpp_dec_float_elem_digits10.
      std::ptrdiff_t       n_shift   = static_cast<std::ptrdiff_t>(0);
      const std::ptrdiff_t n_exp_rem = static_cast<std::ptrdiff_t>(exp % static_cast<exponent_type>(cpp_dec_float_elem_digits10));

      if((exp % static_cast<exponent_type>(cpp_dec_float_elem_digits10)) != static_cast<exponent_type>(0))
      {
         n_shift = ((exp < static_cast<exponent_type>(0))
                        ? static_cast<std::ptrdiff_t>(n_exp_rem + static_cast<std::ptrdiff_t>(cpp_dec_float_elem_digits10))
                        : static_cast<std::ptrdiff_t>(n_exp_rem));
      }

      // Make sure that there are enough digits for the decimal point shift.
      pos = str.find(static_cast<char>('.'));

      std::ptrdiff_t pos_plus_one = static_cast<std::ptrdiff_t>(pos + 1);

      if ((static_cast<std::ptrdiff_t>(str.length()) - pos_plus_one) < n_shift)
      {
         const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(n_shift - (static_cast<std::ptrdiff_t>(str.length()) - pos_plus_one));

         str.append(std::string(static_cast<std::string::size_type>(sz), static_cast<char>('0')));
      }

      // Do the decimal point shift.
      if (n_shift != static_cast<std::ptrdiff_t>(0))
      {
         str.insert(static_cast<std::string::size_type>(pos_plus_one + n_shift), ".");

         str.erase(pos, static_cast<std::ptrdiff_t>(1));

         exp -= static_cast<exponent_type>(n_shift);
      }

      // Cut the size of the mantissa to <= cpp_dec_float_elem_digits10.
      pos          = str.find(static_cast<char>('.'));
      pos_plus_one = static_cast<std::ptrdiff_t>(pos + 1u);

      if (pos > static_cast<std::size_t>(cpp_dec_float_elem_digits10))
      {
         const std::int32_t n_pos         = static_cast<std::int32_t>(pos);
         const std::int32_t n_rem_is_zero = ((static_cast<std::int32_t>(n_pos % cpp_dec_float_elem_digits10) == static_cast<std::int32_t>(0)) ? static_cast<std::int32_t>(1) : static_cast<std::int32_t>(0));
         const std::int32_t n             = static_cast<std::int32_t>(static_cast<std::int32_t>(n_pos / cpp_dec_float_elem_digits10) - n_rem_is_zero);

         str.insert(static_cast<std::size_t>(static_cast<std::int32_t>(n_pos - static_cast<std::int32_t>(n * cpp_dec_float_elem_digits10))), ".");

         str.erase(static_cast<std::size_t>(pos_plus_one), static_cast<std::size_t>(1u));

         exp += static_cast<exponent_type>(static_cast<exponent_type>(n) * static_cast<exponent_type>(cpp_dec_float_elem_digits10));
      }

      // Pad the decimal part such that its value is an even
      // multiple of cpp_dec_float_elem_digits10.
      pos          = str.find(static_cast<char>('.'));
      pos_plus_one = static_cast<std::ptrdiff_t>(pos + 1u);

      // Throws an error for a strange construction like 3.14L
      if(pos != std::string::npos && (str.back() == 'L' || str.back() == 'l' || str.back() == 'u' || str.back() == 'U'))
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Can not construct a floating point with an integer literal"));
      }

      const std::int32_t n_dec = static_cast<std::int32_t>(static_cast<std::int32_t>(str.length() - 1u) - static_cast<std::int32_t>(pos));
      const std::int32_t n_rem = static_cast<std::int32_t>(n_dec % cpp_dec_float_elem_digits10);

      std::int32_t n_cnt = ((n_rem != static_cast<std::int32_t>(0))
                                  ? static_cast<std::int32_t>(cpp_dec_float_elem_digits10 - n_rem)
                                  : static_cast<std::int32_t>(0));

      if (n_cnt != static_cast<std::int32_t>(0))
      {
         str.append(static_cast<std::size_t>(n_cnt), static_cast<char>('0'));
      }

      // Truncate decimal part if it is too long.
      const std::size_t max_dec = static_cast<std::size_t>((cpp_dec_float_elem_number - 1) * cpp_dec_float_elem_digits10);

      if (static_cast<std::size_t>(str.length() - pos) > max_dec)
      {
         str = str.substr(static_cast<std::size_t>(0u),
                          static_cast<std::size_t>(pos_plus_one + static_cast<std::ptrdiff_t>(max_dec)));
      }

      // Now the input string has the standard cpp_dec_float<Digits10, ExponentType, Allocator> input form.
      // (See the comment above.)

      // Set all the data elements to 0.
      std::fill(data.begin(), data.end(), static_cast<std::uint32_t>(0u));

      // Extract the data.

      // First get the digits to the left of the decimal point...
      data[0u] = static_cast<std::uint32_t>(std::stol(str.substr(static_cast<std::size_t>(0u), pos)));

      // ...then get the remaining digits to the right of the decimal point.
      const std::string::size_type i_end =
      (
           static_cast<std::string::size_type>(str.length() - static_cast<std::string::size_type>(pos_plus_one))
         / static_cast<std::string::size_type>(cpp_dec_float_elem_digits10)
      );

      for (std::string::size_type i = static_cast<std::string::size_type>(0u); i < i_end; i++)
      {
         const std::string::const_iterator it =
              str.begin()
            + static_cast<std::ptrdiff_t>
              (
                   static_cast<std::string::size_type>(pos_plus_one)
                 + static_cast<std::string::size_type>(i * static_cast<std::string::size_type>(cpp_dec_float_elem_digits10))
              );

         data[i + 1u] = static_cast<std::uint32_t>(std::stol(std::string(it, it + static_cast<std::string::size_type>(cpp_dec_float_elem_digits10))));
      }

      // Check for overflow...
      if (exp > cpp_dec_float_max_exp10)
      {
         const bool b_result_is_neg = neg;

         *this = inf();
         if (b_result_is_neg)
            negate();
      }

      // ...and check for underflow.
      if (exp <= cpp_dec_float_min_exp10)
      {
         if (exp == cpp_dec_float_min_exp10)
         {
            // Check for identity with the minimum value.
            cpp_dec_float<Digits10, ExponentType, Allocator> test = *this;

            test.exp = static_cast<exponent_type>(0);

            if (test.isone())
            {
               *this = zero();
            }
         }
         else
         {
            *this = zero();
         }
      }

#ifndef BOOST_NO_EXCEPTIONS
   }
   #ifndef BOOST_MP_STANDALONE
   catch (const bad_lexical_cast&)
   #else
   catch (const std::exception&)
   #endif
   {
      // Rethrow with better error message:
      std::string msg = "Unable to parse the string \"";
      msg += s;
      msg += "\" as a floating point value.";
      throw std::runtime_error(msg);
   }
#endif
   return true;
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float(const double mantissa, const ExponentType exponent)
    : data(),
      exp(static_cast<ExponentType>(0)),
      neg(false),
      fpclass(cpp_dec_float_finite),
      prec_elem(cpp_dec_float_elem_number)
{
   // Create *this cpp_dec_float<Digits10, ExponentType, Allocator> from a given mantissa and exponent.
   // Note: This constructor does not maintain the full precision of double.

   const bool mantissa_is_iszero = (::fabs(mantissa) < ((std::numeric_limits<double>::min)() * (1.0 + std::numeric_limits<double>::epsilon())));

   if (mantissa_is_iszero)
   {
      std::fill(data.begin(), data.end(), static_cast<std::uint32_t>(0u));
      return;
   }

   const bool b_neg = (mantissa < 0.0);

   double       d = ((!b_neg) ? mantissa : -mantissa);
   exponent_type e = exponent;

   while (d > 10.0)
   {
      d /= 10.0;
      ++e;
   }
   while (d < 1.0)
   {
      d *= 10.0;
      --e;
   }

   std::int32_t shift = static_cast<std::int32_t>(e % static_cast<std::int32_t>(cpp_dec_float_elem_digits10));

   while (static_cast<std::int32_t>(shift-- % cpp_dec_float_elem_digits10) != static_cast<std::int32_t>(0))
   {
      d *= 10.0;
      --e;
   }

   exp = e;
   neg = b_neg;

   std::fill(data.begin(), data.end(), static_cast<std::uint32_t>(0u));

   constexpr std::int32_t digit_ratio = static_cast<std::int32_t>(static_cast<std::int32_t>(std::numeric_limits<double>::digits10) / static_cast<std::int32_t>(cpp_dec_float_elem_digits10));
   constexpr std::int32_t digit_loops = static_cast<std::int32_t>(digit_ratio + static_cast<std::int32_t>(2));

   for (std::int32_t i = static_cast<std::int32_t>(0); i < digit_loops; i++)
   {
      std::uint32_t n = static_cast<std::uint32_t>(static_cast<std::uint64_t>(d));
      data[static_cast<std::size_t>(i)] = static_cast<std::uint32_t>(n);
      d -= static_cast<double>(n);
      d *= static_cast<double>(cpp_dec_float_elem_mask);
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
template <class Float>
typename std::enable_if<std::is_floating_point<Float>::value, cpp_dec_float<Digits10, ExponentType, Allocator>&>::type cpp_dec_float<Digits10, ExponentType, Allocator>::operator=(Float a)
{
   // Christopher Kormanyos's original code used a cast to long long here, but that fails
   // when long double has more digits than a long long.
   BOOST_MP_FLOAT128_USING
   using std::floor;
   using std::frexp; 
   using std::ldexp;

   if (a == 0)
      return *this = zero();

   if (a == 1)
      return *this = one();

   if (BOOST_MP_ISINF(a))
   {
      *this = inf();
      if (a < 0)
         this->negate();
      return *this;
   }

   if (BOOST_MP_ISNAN(a))
      return *this = nan();

   int         e;
   Float f, term;
   *this = zero();

   f = frexp(a, &e);
   // See https://svn.boost.org/trac/boost/ticket/10924 for an example of why this may go wrong:
   BOOST_MP_ASSERT(!BOOST_MP_ISNAN(f) && !BOOST_MP_ISINF(f));

   constexpr int shift = std::numeric_limits<int>::digits - 1;

   while (f != static_cast<Float>(0.0f))
   {
      // extract int sized bits from f:
      f = ldexp(f, shift);
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(f) && !BOOST_MP_ISINF(f));
      term = floor(f);
      e -= shift;
      *this *= pow2(shift);
      if (term > 0)
         add_unsigned_long_long(static_cast<unsigned>(term));
      else
         sub_unsigned_long_long(static_cast<unsigned>(-term));
      f -= term;
   }

   if (e != 0)
      *this *= pow2(e);

   return *this;
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::from_unsigned_long_long(const unsigned long long u)
{
   std::fill(data.begin(), data.end(), static_cast<std::uint32_t>(0u));

   exp       = static_cast<exponent_type>(0);
   neg       = false;
   fpclass   = cpp_dec_float_finite;
   prec_elem = cpp_dec_float_elem_number;

   if (u == 0)
   {
      return;
   }

   std::size_t i = static_cast<std::size_t>(0u);

   unsigned long long uu = u;

   std::uint32_t temp[(std::numeric_limits<unsigned long long>::digits10 / static_cast<int>(cpp_dec_float_elem_digits10)) + 3] = {static_cast<std::uint32_t>(0u)};

   while (uu != static_cast<unsigned long long>(0u))
   {
      temp[i] = static_cast<std::uint32_t>(uu % static_cast<unsigned long long>(cpp_dec_float_elem_mask));
      uu      = static_cast<unsigned long long>(uu / static_cast<unsigned long long>(cpp_dec_float_elem_mask));
      ++i;
   }

   if (i > static_cast<std::size_t>(1u))
   {
      exp += static_cast<exponent_type>((i - 1u) * static_cast<std::size_t>(cpp_dec_float_elem_digits10));
   }

   std::reverse(temp, temp + i);
   std::copy(temp, temp + (std::min)(i, static_cast<std::size_t>(cpp_dec_float_elem_number)), data.begin());
}

template <unsigned Digits10, class ExponentType, class Allocator>
template <typename InputIteratorTypeLeft, typename InputIteratorTypeRight>
int cpp_dec_float<Digits10, ExponentType, Allocator>::compare_ranges(InputIteratorTypeLeft  a,
                                                                     InputIteratorTypeRight b,
                                                                     const std::uint32_t    count)
{
   using local_iterator_left_type  = InputIteratorTypeLeft;
   using local_iterator_right_type = InputIteratorTypeRight;

   local_iterator_left_type  begin_a(a);
   local_iterator_left_type  end_a  (a + static_cast<typename std::iterator_traits<local_iterator_left_type >::difference_type>(count));
   local_iterator_right_type begin_b(b);
   local_iterator_right_type end_b  (b + static_cast<typename std::iterator_traits<local_iterator_right_type>::difference_type>(count));

   const auto mismatch_pair = std::mismatch(begin_a, end_a, begin_b);

   int n_return;

   if((mismatch_pair.first != end_a) || (mismatch_pair.second != end_b))
   {
      const typename std::iterator_traits<local_iterator_left_type >::value_type left  = *mismatch_pair.first;
      const typename std::iterator_traits<local_iterator_right_type>::value_type right = *mismatch_pair.second;

      n_return = ((left > right) ?  1 : -1);
   }
   else
   {
      n_return = 0;
   }

   return n_return;
}

template <unsigned Digits10, class ExponentType, class Allocator>
std::uint32_t cpp_dec_float<Digits10, ExponentType, Allocator>::eval_add_n(      std::uint32_t* r,
                                                                           const std::uint32_t* u,
                                                                           const std::uint32_t* v,
                                                                           const std::int32_t   count)
{
   // Addition algorithm
   std::uint_fast8_t carry = static_cast<std::uint_fast8_t>(0U);

   for(std::int32_t j = static_cast<std::int32_t>(count - static_cast<std::int32_t>(1)); j >= static_cast<std::int32_t>(0); --j)
   {
      const std::uint32_t t = static_cast<std::uint32_t>(static_cast<std::uint32_t>(u[j] + v[j]) + carry);

      carry = ((t >= static_cast<std::uint32_t>(cpp_dec_float_elem_mask)) ? static_cast<std::uint_fast8_t>(1U)
                                                                   : static_cast<std::uint_fast8_t>(0U));

      r[j]  = static_cast<std::uint32_t>(t - ((carry != 0U) ? static_cast<std::uint32_t>(cpp_dec_float_elem_mask)
                                                            : static_cast<std::uint32_t>(0U)));
   }

   return static_cast<std::uint32_t>(carry);
}

template <unsigned Digits10, class ExponentType, class Allocator>
std::uint32_t cpp_dec_float<Digits10, ExponentType, Allocator>::eval_subtract_n(      std::uint32_t* r,
                                                                                const std::uint32_t* u,
                                                                                const std::uint32_t* v,
                                                                                const std::int32_t   count)
{
   // Subtraction algorithm
   std::int_fast8_t borrow = static_cast<std::int_fast8_t>(0);

   for(std::uint32_t j = static_cast<std::uint32_t>(count - static_cast<std::int32_t>(1)); static_cast<std::int32_t>(j) >= static_cast<std::int32_t>(0); --j)
   {
      std::int32_t t = static_cast<std::int32_t>(  static_cast<std::int32_t>(u[j])
                                                 - static_cast<std::int32_t>(v[j])) - borrow;

      // Underflow? Borrow?
      if(t < 0)
      {
         // Yes, underflow and borrow
         t     += static_cast<std::int32_t>(cpp_dec_float_elem_mask);
         borrow = static_cast<std::int_fast8_t>(1);
      }
      else
      {
         borrow = static_cast<std::int_fast8_t>(0);
      }

      r[j] = static_cast<std::uint32_t>(t);
   }

   return static_cast<std::uint32_t>(borrow);
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::eval_multiply_n_by_n_to_2n(      std::uint32_t* r,
                                                                                  const std::uint32_t* a,
                                                                                  const std::uint32_t* b,
                                                                                  const std::uint32_t  count)
{
   using local_limb_type = std::uint32_t;

   using local_double_limb_type = std::uint64_t;

   using local_reverse_iterator_type = std::reverse_iterator<local_limb_type*>;

   local_reverse_iterator_type ir(r + (count * 2));

   local_double_limb_type carry = 0U;

   for(std::int32_t j = static_cast<std::int32_t>(count - 1); j >= static_cast<std::int32_t>(1); --j)
   {
      local_double_limb_type sum = carry;

      for(std::int32_t i = static_cast<std::int32_t>(count - 1); i >= j; --i)
      {
         sum += local_double_limb_type(
                local_double_limb_type(a[i]) * b[  static_cast<std::int32_t>(count - 1)
                                                - static_cast<std::int32_t>(i - j)]);
      }

      carry = static_cast<local_double_limb_type>(sum / static_cast<local_limb_type>       (cpp_dec_float_elem_mask));
      *ir++ = static_cast<local_limb_type>       (sum - static_cast<local_double_limb_type>(static_cast<local_double_limb_type>(carry) * static_cast<local_limb_type>(cpp_dec_float_elem_mask)));
   }

   for(std::int32_t j = static_cast<std::int32_t>(count - 1); j >= static_cast<std::int32_t>(0); --j)
   {
      local_double_limb_type sum = carry;

      for(std::int32_t i = j; i >= static_cast<std::int32_t>(0); --i)
      {
         sum += static_cast<local_double_limb_type>(a[j - i] * static_cast<local_double_limb_type>(b[i]));
      }

      carry = static_cast<local_double_limb_type>(sum / static_cast<local_limb_type>(cpp_dec_float_elem_mask));
      *ir++ = static_cast<local_limb_type>       (sum - static_cast<local_double_limb_type>(static_cast<local_double_limb_type>(carry) * static_cast<local_limb_type>(cpp_dec_float_elem_mask)));
   }

   *ir = static_cast<local_limb_type>(carry);
}

template <unsigned Digits10, class ExponentType, class Allocator>
std::uint32_t cpp_dec_float<Digits10, ExponentType, Allocator>::mul_loop_n(std::uint32_t* const u, std::uint32_t n, const std::int32_t p)
{
   std::uint64_t carry = static_cast<std::uint64_t>(0u);

   // Multiplication loop.
   for (std::int32_t j = p - 1; j >= static_cast<std::int32_t>(0); j--)
   {
      const std::uint64_t t = static_cast<std::uint64_t>(carry + static_cast<std::uint64_t>(u[j] * static_cast<std::uint64_t>(n)));
      carry                 = static_cast<std::uint64_t>(t / static_cast<std::uint32_t>(cpp_dec_float_elem_mask));
      u[j]                  = static_cast<std::uint32_t>(t - static_cast<std::uint64_t>(static_cast<std::uint32_t>(cpp_dec_float_elem_mask) * static_cast<std::uint64_t>(carry)));
   }

   return static_cast<std::uint32_t>(carry);
}

template <unsigned Digits10, class ExponentType, class Allocator>
std::uint32_t cpp_dec_float<Digits10, ExponentType, Allocator>::div_loop_n(std::uint32_t* const u, std::uint32_t n, const std::int32_t p)
{
   std::uint64_t prev = static_cast<std::uint64_t>(0u);

   for (std::int32_t j = static_cast<std::int32_t>(0); j < p; j++)
   {
      const std::uint64_t t = static_cast<std::uint64_t>(u[j] + static_cast<std::uint64_t>(prev * static_cast<std::uint32_t>(cpp_dec_float_elem_mask)));
      u[j]                    = static_cast<std::uint32_t>(t / n);
      prev                    = static_cast<std::uint64_t>(t - static_cast<std::uint64_t>(n * static_cast<std::uint64_t>(u[j])));
   }

   return static_cast<std::uint32_t>(prev);
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::eval_multiply_kara_propagate_carry(std::uint32_t* t, const std::uint32_t n, const std::uint32_t carry)
{
   std::uint_fast8_t carry_out = ((carry != 0U) ? static_cast<std::uint_fast8_t>(1U)
                                                : static_cast<std::uint_fast8_t>(0U));

   using local_reverse_iterator_type = std::reverse_iterator<std::uint32_t*>;

   local_reverse_iterator_type ri_t  (t + n);
   local_reverse_iterator_type rend_t(t);

   while((carry_out != 0U) && (ri_t != rend_t))
   {
      const std::uint64_t tt = *ri_t + carry_out;

      carry_out = ((tt >= static_cast<std::uint32_t>(cpp_dec_float_elem_mask)) ? static_cast<std::uint_fast8_t>(1U)
                                                                               : static_cast<std::uint_fast8_t>(0U));

      *ri_t++    = static_cast<std::uint32_t>(tt - ((carry_out != 0U) ? static_cast<std::uint32_t>(cpp_dec_float_elem_mask)
                                                                      : static_cast<std::uint32_t>(0U)));
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::eval_multiply_kara_propagate_borrow(std::uint32_t* t, const std::uint32_t n, const bool has_borrow)
{
   std::int_fast8_t borrow = (has_borrow ? static_cast<std::int_fast8_t>(1)
                                         : static_cast<std::int_fast8_t>(0));

   using local_reverse_iterator_type = std::reverse_iterator<std::uint32_t*>;

   local_reverse_iterator_type ri_t  (t + n);
   local_reverse_iterator_type rend_t(t);

   while((borrow != 0U) && (ri_t != rend_t))
   {
      std::int32_t tt = static_cast<std::int32_t>(static_cast<std::int32_t>(*ri_t) - borrow);

      // Underflow? Borrow?
      if(tt < 0)
      {
         // Yes, underflow and borrow
         tt     += static_cast<std::int32_t>(cpp_dec_float_elem_mask);
         borrow  = static_cast<int_fast8_t>(1);
      }
      else
      {
         borrow = static_cast<int_fast8_t>(0);
      }

      *ri_t++ = static_cast<std::uint32_t>(tt);
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
void cpp_dec_float<Digits10, ExponentType, Allocator>::eval_multiply_kara_n_by_n_to_2n(      std::uint32_t* r,
                                                                                       const std::uint32_t* a,
                                                                                       const std::uint32_t* b,
                                                                                       const std::uint32_t  n,
                                                                                             std::uint32_t* t)
{
   if(n <= 32U)
   {
      static_cast<void>(t);

      eval_multiply_n_by_n_to_2n(r, a, b, n);
   }
   else
   {
      // Based on "Algorithm 1.3 KaratsubaMultiply", Sect. 1.3.2, page 5
      // of R.P. Brent and P. Zimmermann, "Modern Computer Arithmetic",
      // Cambridge University Press (2011).

      // The Karatsuba multipliation computes the product of a*b as:
      // [b^N + b^(N/2)] a1*b1 + [b^(N/2)](a1 - a0)(b0 - b1) + [b^(N/2) + 1] a0*b0

      // Here we visualize a and b in two components 1,0 corresponding
      // to the high and low order parts, respectively.

      // Step 1
      // Calculate a1*b1 and store it in the upper-order part of r.
      // Calculate a0*b0 and store it in the lower-order part of r.
      // copy r to t0.

      // Step 2
      // Add a1*b1 (which is t2) to the middle two-quarters of r (which is r1)
      // Add a0*b0 (which is t0) to the middle two-quarters of r (which is r1)

      // Step 3
      // Calculate |a1-a0| in t0 and note the sign (i.e., the borrow flag)

      // Step 4
      // Calculate |b0-b1| in t1 and note the sign (i.e., the borrow flag)

      // Step 5
      // Call kara mul to calculate |a1-a0|*|b0-b1| in (t2),
      // while using temporary storage in t4 along the way.

      // Step 6
      // Check the borrow signs. If a1-a0 and b0-b1 have the same signs,
      // then add |a1-a0|*|b0-b1| to r1, otherwise subtract it from r1.

      const std::uint_fast32_t  nh = n / 2U;

      const std::uint32_t* a0 = a + nh;
      const std::uint32_t* a1 = a + 0U;

      const std::uint32_t* b0 = b + nh;
      const std::uint32_t* b1 = b + 0U;

            std::uint32_t* r0 = r + 0U;
            std::uint32_t* r1 = r + nh;
            std::uint32_t* r2 = r + n;

            std::uint32_t* t0 = t + 0U;
            std::uint32_t* t1 = t + nh;
            std::uint32_t* t2 = t + n;
            std::uint32_t* t4 = t + (n + n);

      // Step 1
      eval_multiply_kara_n_by_n_to_2n(r0, a1, b1, static_cast<std::uint32_t>(nh), t);
      eval_multiply_kara_n_by_n_to_2n(r2, a0, b0, static_cast<std::uint32_t>(nh), t);
      std::copy(r0, r0 + (2U * n), t0);

      // Step 2
      std::uint32_t carry;
      carry = eval_add_n(r1, r1, t0, static_cast<std::int32_t>(n));
      eval_multiply_kara_propagate_carry(r0, static_cast<std::uint32_t>(nh), carry);
      carry = eval_add_n(r1, r1, t2, static_cast<std::int32_t>(n));
      eval_multiply_kara_propagate_carry(r0, static_cast<std::uint32_t>(nh), carry);

      // Step 3
      const int cmp_result_a1a0 = compare_ranges(a1, a0, static_cast<std::uint32_t>(nh));

      if(cmp_result_a1a0 == 1)
         static_cast<void>(eval_subtract_n(t0, a1, a0, static_cast<std::int32_t>(nh)));
      else if(cmp_result_a1a0 == -1)
         static_cast<void>(eval_subtract_n(t0, a0, a1, static_cast<std::int32_t>(nh)));

      // Step 4
      const int cmp_result_b0b1 = compare_ranges(b0, b1, static_cast<std::uint32_t>(nh));

      if(cmp_result_b0b1 == 1)
         static_cast<void>(eval_subtract_n(t1, b0, b1, static_cast<std::int32_t>(nh)));
      else if(cmp_result_b0b1 == -1)
         static_cast<void>(eval_subtract_n(t1, b1, b0, static_cast<std::int32_t>(nh)));

      // Step 5
      eval_multiply_kara_n_by_n_to_2n(t2, t0, t1, static_cast<std::uint32_t>(nh), t4);

      // Step 6
      if((cmp_result_a1a0 * cmp_result_b0b1) == 1)
      {
         carry = eval_add_n(r1, r1, t2, static_cast<std::int32_t>(n));

         eval_multiply_kara_propagate_carry(r0, static_cast<std::uint32_t>(nh), carry);
      }
      else if((cmp_result_a1a0 * cmp_result_b0b1) == -1)
      {
         const bool has_borrow = eval_subtract_n(r1, r1, t2, static_cast<std::int32_t>(n));

         eval_multiply_kara_propagate_borrow(r0, static_cast<std::uint32_t>(nh), has_borrow);
      }
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
cpp_dec_float<Digits10, ExponentType, Allocator> cpp_dec_float<Digits10, ExponentType, Allocator>::pow2(const long long p)
{
   static const std::array<cpp_dec_float<Digits10, ExponentType, Allocator>, 256u> local_pow2_data =
   {{
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       29u, 38735877u,  5571876u, 99218413u, 43055614u, 19454666u, 38919302u, 18803771u, 87926569u, 60431486u, 36817932u, 12890625u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       58u, 77471754u, 11143753u, 98436826u, 86111228u, 38909332u, 77838604u, 37607543u, 75853139u, 20862972u, 73635864u, 25781250u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      117u, 54943508u, 22287507u, 96873653u, 72222456u, 77818665u, 55677208u, 75215087u, 51706278u, 41725945u, 47271728u, 51562500u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      235u,  9887016u, 44575015u, 93747307u, 44444913u, 55637331u, 11354417u, 50430175u,  3412556u, 83451890u, 94543457u,  3125000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      470u, 19774032u, 89150031u, 87494614u, 88889827u, 11274662u, 22708835u,   860350u,  6825113u, 66903781u, 89086914u,  6250000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      940u, 39548065u, 78300063u, 74989229u, 77779654u, 22549324u, 45417670u,  1720700u, 13650227u, 33807563u, 78173828u, 12500000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1880u, 79096131u, 56600127u, 49978459u, 55559308u, 45098648u, 90835340u,  3441400u, 27300454u, 67615127u, 56347656u, 25000000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     3761u, 58192263u, 13200254u, 99956919u, 11118616u, 90197297u, 81670680u,  6882800u, 54600909u, 35230255u, 12695312u, 50000000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     7523u, 16384526u, 26400509u, 99913838u, 22237233u, 80394595u, 63341360u, 13765601u,  9201818u, 70460510u, 25390625u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    15046u, 32769052u, 52801019u, 99827676u, 44474467u, 60789191u, 26682720u, 27531202u, 18403637u, 40921020u, 50781250u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    30092u, 65538105u,  5602039u, 99655352u, 88948935u, 21578382u, 53365440u, 55062404u, 36807274u, 81842041u,  1562500u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    60185u, 31076210u, 11204079u, 99310705u, 77897870u, 43156765u,  6730881u, 10124808u, 73614549u, 63684082u,  3125000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   120370u, 62152420u, 22408159u, 98621411u, 55795740u, 86313530u, 13461762u, 20249617u, 47229099u, 27368164u,  6250000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   240741u, 24304840u, 44816319u, 97242823u, 11591481u, 72627060u, 26923524u, 40499234u, 94458198u, 54736328u, 12500000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   481482u, 48609680u, 89632639u, 94485646u, 23182963u, 45254120u, 53847048u, 80998469u, 88916397u,  9472656u, 25000000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   962964u, 97219361u, 79265279u, 88971292u, 46365926u, 90508241u,  7694097u, 61996939u, 77832794u, 18945312u, 50000000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1925929u, 94438723u, 58530559u, 77942584u, 92731853u, 81016482u, 15388195u, 23993879u, 55665588u, 37890625u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  3851859u, 88877447u, 17061119u, 55885169u, 85463707u, 62032964u, 30776390u, 47987759u, 11331176u, 75781250u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  7703719u, 77754894u, 34122239u, 11770339u, 70927415u, 24065928u, 61552780u, 95975518u, 22662353u, 51562500u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 15407439u, 55509788u, 68244478u, 23540679u, 41854830u, 48131857u, 23105561u, 91951036u, 45324707u,  3125000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 30814879u, 11019577u, 36488956u, 47081358u, 83709660u, 96263714u, 46211123u, 83902072u, 90649414u,  6250000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 61629758u, 22039154u, 72977912u, 94162717u, 67419321u, 92527428u, 92422247u, 67804145u, 81298828u, 12500000u }, -40 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 23259516u, 44078309u, 45955825u, 88325435u, 34838643u, 85054857u, 84844495u, 35608291u, 62597656u, 25000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u, 46519032u, 88156618u, 91911651u, 76650870u, 69677287u, 70109715u, 69688990u, 71216583u, 25195312u, 50000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        4u, 93038065u, 76313237u, 83823303u, 53301741u, 39354575u, 40219431u, 39377981u, 42433166u, 50390625u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        9u, 86076131u, 52626475u, 67646607u,  6603482u, 78709150u, 80438862u, 78755962u, 84866333u,   781250u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       19u, 72152263u,  5252951u, 35293214u, 13206965u, 57418301u, 60877725u, 57511925u, 69732666u,  1562500u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       39u, 44304526u, 10505902u, 70586428u, 26413931u, 14836603u, 21755451u, 15023851u, 39465332u,  3125000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       78u, 88609052u, 21011805u, 41172856u, 52827862u, 29673206u, 43510902u, 30047702u, 78930664u,  6250000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      157u, 77218104u, 42023610u, 82345713u,  5655724u, 59346412u, 87021804u, 60095405u, 57861328u, 12500000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      315u, 54436208u, 84047221u, 64691426u, 11311449u, 18692825u, 74043609u, 20190811u, 15722656u, 25000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      631u,  8872417u, 68094443u, 29382852u, 22622898u, 37385651u, 48087218u, 40381622u, 31445312u, 50000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1262u, 17744835u, 36188886u, 58765704u, 45245796u, 74771302u, 96174436u, 80763244u, 62890625u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     2524u, 35489670u, 72377773u, 17531408u, 90491593u, 49542605u, 92348873u, 61526489u, 25781250u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     5048u, 70979341u, 44755546u, 35062817u, 80983186u, 99085211u, 84697747u, 23052978u, 51562500u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    10097u, 41958682u, 89511092u, 70125635u, 61966373u, 98170423u, 69395494u, 46105957u,  3125000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    20194u, 83917365u, 79022185u, 40251271u, 23932747u, 96340847u, 38790988u, 92211914u,  6250000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    40389u, 67834731u, 58044370u, 80502542u, 47865495u, 92681694u, 77581977u, 84423828u, 12500000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    80779u, 35669463u, 16088741u, 61005084u, 95730991u, 85363389u, 55163955u, 68847656u, 25000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   161558u, 71338926u, 32177483u, 22010169u, 91461983u, 70726779u, 10327911u, 37695312u, 50000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   323117u, 42677852u, 64354966u, 44020339u, 82923967u, 41453558u, 20655822u, 75390625u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   646234u, 85355705u, 28709932u, 88040679u, 65847934u, 82907116u, 41311645u, 50781250u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1292469u, 70711410u, 57419865u, 76081359u, 31695869u, 65814232u, 82623291u,  1562500u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  2584939u, 41422821u, 14839731u, 52162718u, 63391739u, 31628465u, 65246582u,  3125000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  5169878u, 82845642u, 29679463u,  4325437u, 26783478u, 63256931u, 30493164u,  6250000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 10339757u, 65691284u, 59358926u,  8650874u, 53566957u, 26513862u, 60986328u, 12500000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 20679515u, 31382569u, 18717852u, 17301749u,  7133914u, 53027725u, 21972656u, 25000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 41359030u, 62765138u, 37435704u, 34603498u, 14267829u,  6055450u, 43945312u, 50000000u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 82718061u, 25530276u, 74871408u, 69206996u, 28535658u, 12110900u, 87890625u }, -32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 65436122u, 51060553u, 49742817u, 38413992u, 57071316u, 24221801u, 75781250u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        3u, 30872245u,  2121106u, 99485634u, 76827985u, 14142632u, 48443603u, 51562500u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        6u, 61744490u,  4242213u, 98971269u, 53655970u, 28285264u, 96887207u,  3125000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       13u, 23488980u,  8484427u, 97942539u,  7311940u, 56570529u, 93774414u,  6250000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       26u, 46977960u, 16968855u, 95885078u, 14623881u, 13141059u, 87548828u, 12500000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       52u, 93955920u, 33937711u, 91770156u, 29247762u, 26282119u, 75097656u, 25000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      105u, 87911840u, 67875423u, 83540312u, 58495524u, 52564239u, 50195312u, 50000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      211u, 75823681u, 35750847u, 67080625u, 16991049u,  5128479u,   390625u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      423u, 51647362u, 71501695u, 34161250u, 33982098u, 10256958u,   781250u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      847u,  3294725u, 43003390u, 68322500u, 67964196u, 20513916u,  1562500u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1694u,  6589450u, 86006781u, 36645001u, 35928392u, 41027832u,  3125000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     3388u, 13178901u, 72013562u, 73290002u, 71856784u, 82055664u,  6250000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     6776u, 26357803u, 44027125u, 46580005u, 43713569u, 64111328u, 12500000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    13552u, 52715606u, 88054250u, 93160010u, 87427139u, 28222656u, 25000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    27105u,  5431213u, 76108501u, 86320021u, 74854278u, 56445312u, 50000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    54210u, 10862427u, 52217003u, 72640043u, 49708557u, 12890625u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   108420u, 21724855u,  4434007u, 45280086u, 99417114u, 25781250u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   216840u, 43449710u,  8868014u, 90560173u, 98834228u, 51562500u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   433680u, 86899420u, 17736029u, 81120347u, 97668457u,  3125000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   867361u, 73798840u, 35472059u, 62240695u, 95336914u,  6250000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1734723u, 47597680u, 70944119u, 24481391u, 90673828u, 12500000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  3469446u, 95195361u, 41888238u, 48962783u, 81347656u, 25000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  6938893u, 90390722u, 83776476u, 97925567u, 62695312u, 50000000u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 13877787u, 80781445u, 67552953u, 95851135u, 25390625u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 27755575u, 61562891u, 35105907u, 91702270u, 50781250u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 55511151u, 23125782u, 70211815u, 83404541u,  1562500u }, -24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 11022302u, 46251565u, 40423631u, 66809082u,  3125000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u, 22044604u, 92503130u, 80847263u, 33618164u,  6250000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        4u, 44089209u, 85006261u, 61694526u, 67236328u, 12500000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        8u, 88178419u, 70012523u, 23389053u, 34472656u, 25000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       17u, 76356839u, 40025046u, 46778106u, 68945312u, 50000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       35u, 52713678u, 80050092u, 93556213u, 37890625u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       71u,  5427357u, 60100185u, 87112426u, 75781250u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      142u, 10854715u, 20200371u, 74224853u, 51562500u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      284u, 21709430u, 40400743u, 48449707u,  3125000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      568u, 43418860u, 80801486u, 96899414u,  6250000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1136u, 86837721u, 61602973u, 93798828u, 12500000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     2273u, 73675443u, 23205947u, 87597656u, 25000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     4547u, 47350886u, 46411895u, 75195312u, 50000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     9094u, 94701772u, 92823791u, 50390625u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    18189u, 89403545u, 85647583u,   781250u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    36379u, 78807091u, 71295166u,  1562500u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    72759u, 57614183u, 42590332u,  3125000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   145519u, 15228366u, 85180664u,  6250000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   291038u, 30456733u, 70361328u, 12500000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   582076u, 60913467u, 40722656u, 25000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1164153u, 21826934u, 81445312u, 50000000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  2328306u, 43653869u, 62890625u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  4656612u, 87307739u, 25781250u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  9313225u, 74615478u, 51562500u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 18626451u, 49230957u,  3125000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 37252902u, 98461914u,  6250000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 74505805u, 96923828u, 12500000u }, -16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 49011611u, 93847656u, 25000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u, 98023223u, 87695312u, 50000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        5u, 96046447u, 75390625u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       11u, 92092895u, 50781250u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       23u, 84185791u,  1562500u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       47u, 68371582u,  3125000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       95u, 36743164u,  6250000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      190u, 73486328u, 12500000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      381u, 46972656u, 25000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      762u, 93945312u, 50000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1525u, 87890625u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     3051u, 75781250u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     6103u, 51562500u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    12207u,  3125000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    24414u,  6250000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    48828u, 12500000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    97656u, 25000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   195312u, 50000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   390625u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   781250u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1562500u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  3125000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  6250000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 12500000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 25000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 50000000u }, -8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        4u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        8u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       16u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       32u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       64u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      128u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      256u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      512u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1024u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     2048u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     4096u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     8192u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    16384u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    32768u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    65536u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   131072u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   262144u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   524288u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1048576u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  2097152u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  4194304u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  8388608u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 16777216u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 33554432u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 67108864u },  0 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 34217728u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u, 68435456u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        5u, 36870912u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       10u, 73741824u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       21u, 47483648u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       42u, 94967296u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       85u, 89934592u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      171u, 79869184u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      343u, 59738368u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      687u, 19476736u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1374u, 38953472u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     2748u, 77906944u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     5497u, 55813888u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    10995u, 11627776u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    21990u, 23255552u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    43980u, 46511104u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    87960u, 93022208u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   175921u, 86044416u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   351843u, 72088832u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   703687u, 44177664u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1407374u, 88355328u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  2814749u, 76710656u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  5629499u, 53421312u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 11258999u,  6842624u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 22517998u, 13685248u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 45035996u, 27370496u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 90071992u, 54740992u },  8 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 80143985u,  9481984u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        3u, 60287970u, 18963968u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        7u, 20575940u, 37927936u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       14u, 41151880u, 75855872u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       28u, 82303761u, 51711744u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       57u, 64607523u,  3423488u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      115u, 29215046u,  6846976u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      230u, 58430092u, 13693952u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      461u, 16860184u, 27387904u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      922u, 33720368u, 54775808u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1844u, 67440737u,  9551616u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     3689u, 34881474u, 19103232u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     7378u, 69762948u, 38206464u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    14757u, 39525896u, 76412928u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    29514u, 79051793u, 52825856u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    59029u, 58103587u,  5651712u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   118059u, 16207174u, 11303424u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   236118u, 32414348u, 22606848u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   472236u, 64828696u, 45213696u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   944473u, 29657392u, 90427392u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1888946u, 59314785u, 80854784u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  3777893u, 18629571u, 61709568u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  7555786u, 37259143u, 23419136u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 15111572u, 74518286u, 46838272u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 30223145u, 49036572u, 93676544u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 60446290u, 98073145u, 87353088u }, 16 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 20892581u, 96146291u, 74706176u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        2u, 41785163u, 92292583u, 49412352u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        4u, 83570327u, 84585166u, 98824704u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        9u, 67140655u, 69170333u, 97649408u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       19u, 34281311u, 38340667u, 95298816u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       38u, 68562622u, 76681335u, 90597632u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       77u, 37125245u, 53362671u, 81195264u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      154u, 74250491u,  6725343u, 62390528u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      309u, 48500982u, 13450687u, 24781056u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      618u, 97001964u, 26901374u, 49562112u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1237u, 94003928u, 53802748u, 99124224u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     2475u, 88007857u,  7605497u, 98248448u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     4951u, 76015714u, 15210995u, 96496896u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     9903u, 52031428u, 30421991u, 92993792u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    19807u,  4062856u, 60843983u, 85987584u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    39614u,  8125713u, 21687967u, 71975168u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    79228u, 16251426u, 43375935u, 43950336u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   158456u, 32502852u, 86751870u, 87900672u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   316912u, 65005705u, 73503741u, 75801344u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   633825u, 30011411u, 47007483u, 51602688u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1267650u, 60022822u, 94014967u,  3205376u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  2535301u, 20045645u, 88029934u,  6410752u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  5070602u, 40091291u, 76059868u, 12821504u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 10141204u, 80182583u, 52119736u, 25643008u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 20282409u, 60365167u,  4239472u, 51286016u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 40564819u, 20730334u,  8478945u,  2572032u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( { 81129638u, 41460668u, 16957890u,  5144064u }, 24 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        1u, 62259276u, 82921336u, 33915780u, 10288128u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        3u, 24518553u, 65842672u, 67831560u, 20576256u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {        6u, 49037107u, 31685345u, 35663120u, 41152512u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       12u, 98074214u, 63370690u, 71326240u, 82305024u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       25u, 96148429u, 26741381u, 42652481u, 64610048u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {       51u, 92296858u, 53482762u, 85304963u, 29220096u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      103u, 84593717u,  6965525u, 70609926u, 58440192u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      207u, 69187434u, 13931051u, 41219853u, 16880384u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      415u, 38374868u, 27862102u, 82439706u, 33760768u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {      830u, 76749736u, 55724205u, 64879412u, 67521536u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     1661u, 53499473u, 11448411u, 29758825u, 35043072u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     3323u,  6998946u, 22896822u, 59517650u, 70086144u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {     6646u, 13997892u, 45793645u, 19035301u, 40172288u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    13292u, 27995784u, 91587290u, 38070602u, 80344576u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    26584u, 55991569u, 83174580u, 76141205u, 60689152u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {    53169u, 11983139u, 66349161u, 52282411u, 21378304u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   106338u, 23966279u, 32698323u,  4564822u, 42756608u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   212676u, 47932558u, 65396646u,  9129644u, 85513216u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   425352u, 95865117u, 30793292u, 18259289u, 71026432u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {   850705u, 91730234u, 61586584u, 36518579u, 42052864u }, 32 ),
      cpp_dec_float<Digits10, ExponentType, Allocator>::from_lst( {  1701411u, 83460469u, 23173168u, 73037158u, 84105728u }, 32 ),
   }};

   cpp_dec_float<Digits10, ExponentType, Allocator> t;

   if(p < -128L)
      default_ops::detail::pow_imp(t, cpp_dec_float<Digits10, ExponentType, Allocator>::half(), static_cast<unsigned long long>(-p), std::integral_constant<bool, false>());
   else if ((p >= -128L) && (p <= 127L))
      t = local_pow2_data[std::size_t(p + 128)];
   else
      default_ops::detail::pow_imp(t, cpp_dec_float<Digits10, ExponentType, Allocator>::two(), static_cast<unsigned long long>(p), std::integral_constant<bool, false>());

   return t;
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_add(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& o)
{
   result += o;
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_subtract(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& o)
{
   result -= o;
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_multiply(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& o)
{
   result *= o;
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_divide(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& o)
{
   result /= o;
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_add(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const unsigned long long& o)
{
   result.add_unsigned_long_long(o);
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_subtract(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const unsigned long long& o)
{
   result.sub_unsigned_long_long(o);
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_multiply(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const unsigned long long& o)
{
   result.mul_unsigned_long_long(o);
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_divide(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const unsigned long long& o)
{
   result.div_unsigned_long_long(o);
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_add(cpp_dec_float<Digits10, ExponentType, Allocator>& result, long long o)
{
   if (o < 0)
      result.sub_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(o));
   else
   {
      using local_ulonglong_type = typename boost::multiprecision::detail::make_unsigned<long long>::type;

      result.add_unsigned_long_long(static_cast<local_ulonglong_type>(o));
   }
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_subtract(cpp_dec_float<Digits10, ExponentType, Allocator>& result, long long o)
{
   if (o < 0)
      result.add_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(o));
   else
   {
      using local_ulonglong_type = typename boost::multiprecision::detail::make_unsigned<long long>::type;

      result.sub_unsigned_long_long(static_cast<local_ulonglong_type>(o));
   }
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_multiply(cpp_dec_float<Digits10, ExponentType, Allocator>& result, long long o)
{
   if (o < 0)
   {
      result.mul_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(o));
      result.negate();
   }
   else
   {
      using local_ulonglong_type = typename boost::multiprecision::detail::make_unsigned<long long>::type;

      result.mul_unsigned_long_long(static_cast<local_ulonglong_type>(o));
   }
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_divide(cpp_dec_float<Digits10, ExponentType, Allocator>& result, long long o)
{
   if (o < 0)
   {
      result.div_unsigned_long_long(boost::multiprecision::detail::unsigned_abs(o));
      result.negate();
   }
   else
   {
      using local_ulonglong_type = typename boost::multiprecision::detail::make_unsigned<long long>::type;

      result.div_unsigned_long_long(static_cast<local_ulonglong_type>(o));
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(unsigned long long* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_unsigned_long_long();
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(long long* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_signed_long_long();
}
#ifdef BOOST_HAS_INT128
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(uint128_type* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_unsigned_int128();
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(int128_type* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_signed_int128();
}
#endif
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(long double* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_long_double();
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(double* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = val.extract_double();
}
#if defined(BOOST_HAS_FLOAT128)
template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_convert_to(float128_type* result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   *result = float128_procs::strtoflt128(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
#endif

//
// Non member function support:
//
template <unsigned Digits10, class ExponentType, class Allocator>
inline int eval_fpclassify(const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   if ((x.isinf)())
      return FP_INFINITE;
   if ((x.isnan)())
      return FP_NAN;
   if (x.iszero())
      return FP_ZERO;
   return FP_NORMAL;
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_abs(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   result = x;
   if (x.isneg())
      result.negate();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_fabs(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   result = x;
   if (x.isneg())
      result.negate();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_sqrt(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   result = x;
   result.calculate_sqrt();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_floor(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   result = x;
   if (!(x.isfinite)() || x.isint())
   {
      if ((x.isnan)())
         errno = EDOM;
      return;
   }

   if (x.isneg())
      result -= cpp_dec_float<Digits10, ExponentType, Allocator>::one();
   result = result.extract_integer_part();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_ceil(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   result = x;
   if (!(x.isfinite)() || x.isint())
   {
      if ((x.isnan)())
         errno = EDOM;
      return;
   }

   if (!x.isneg())
      result += cpp_dec_float<Digits10, ExponentType, Allocator>::one();
   result = result.extract_integer_part();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_trunc(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x)
{
   if (x.isint() || !(x.isfinite)())
   {
      result = x;
      if ((x.isnan)())
         errno = EDOM;
      return;
   }
   result = x.extract_integer_part();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline ExponentType eval_ilogb(const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   if (val.iszero())
      return (std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::min)();
   if ((val.isinf)())
      return INT_MAX;
   if ((val.isnan)())
#ifdef FP_ILOGBNAN
      return FP_ILOGBNAN;
#else
      return INT_MAX;
#endif
   // Set result, to the exponent of val:
   return val.order();
}
template <unsigned Digits10, class ExponentType, class Allocator, class ArgType>
inline void eval_scalbn(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& val, ArgType e_)
{
   using default_ops::eval_multiply;
   const typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type e = static_cast<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>(e_);
   cpp_dec_float<Digits10, ExponentType, Allocator> t(1.0, e);
   eval_multiply(result, val, t);
}

template <unsigned Digits10, class ExponentType, class Allocator, class ArgType>
inline void eval_ldexp(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x, ArgType e)
{
   const long long the_exp = static_cast<long long>(e);

   if ((the_exp > (std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::max)()) || (the_exp < (std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::min)()))
      BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Exponent value is out of range.")));

   result = x;

   if ((the_exp > static_cast<long long>(-std::numeric_limits<long long>::digits)) && (the_exp < static_cast<long long>(0)))
      result.div_unsigned_long_long(1ULL << static_cast<long long>(-the_exp));
   else if ((the_exp < static_cast<long long>(std::numeric_limits<long long>::digits)) && (the_exp > static_cast<long long>(0)))
      result.mul_unsigned_long_long(1ULL << the_exp);
   else if (the_exp != static_cast<long long>(0))
   {
      if ((the_exp < cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp / 2) && (x.order() > 0))
      {
         long long half_exp = e / 2;
         cpp_dec_float<Digits10, ExponentType, Allocator> t = cpp_dec_float<Digits10, ExponentType, Allocator>::pow2(half_exp);
         result *= t;
         if (2 * half_exp != e)
            t *= 2;
         result *= t;
      }
      else
         result *= cpp_dec_float<Digits10, ExponentType, Allocator>::pow2(e);
   }
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline void eval_frexp(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x, ExponentType* e)
{
   result = x;

   if (result.iszero() || (result.isinf)() || (result.isnan)())
   {
      *e = 0;
      return;
   }

   if (result.isneg())
      result.negate();

   typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type t = result.order();
   BOOST_MP_USING_ABS
   if (abs(t) < ((std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::max)() / 1000))
   {
      t *= 1000;
      t /= 301;
   }
   else
   {
      t /= 301;
      t *= 1000;
   }

   result *= cpp_dec_float<Digits10, ExponentType, Allocator>::pow2(-t);

   if (result.iszero() || (result.isinf)() || (result.isnan)())
   {
      // pow2 overflowed, slip the calculation up:
      result = x;
      if (result.isneg())
         result.negate();
      t /= 2;
      result *= cpp_dec_float<Digits10, ExponentType, Allocator>::pow2(-t);
   }
   BOOST_MP_USING_ABS
   if (abs(result.order()) > 5)
   {
      // If our first estimate doesn't get close enough then try recursion until we do:
      typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type e2;
      cpp_dec_float<Digits10, ExponentType, Allocator>                         r2;
      eval_frexp(r2, result, &e2);
      // overflow protection:
      if ((t > 0) && (e2 > 0) && (t > (std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::max)() - e2))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2."));
      if ((t < 0) && (e2 < 0) && (t < (std::numeric_limits<typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type>::min)() - e2))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is too large to be represented as a power of 2."));
      t += e2;
      result = r2;
   }

   while (result.compare(cpp_dec_float<Digits10, ExponentType, Allocator>::one()) >= 0)
   {
      result /= cpp_dec_float<Digits10, ExponentType, Allocator>::two();
      ++t;
   }
   while (result.compare(cpp_dec_float<Digits10, ExponentType, Allocator>::half()) < 0)
   {
      result *= cpp_dec_float<Digits10, ExponentType, Allocator>::two();
      --t;
   }
   *e = t;
   if (x.isneg())
      result.negate();
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline typename std::enable_if< !std::is_same<ExponentType, int>::value>::type eval_frexp(cpp_dec_float<Digits10, ExponentType, Allocator>& result, const cpp_dec_float<Digits10, ExponentType, Allocator>& x, int* e)
{
   typename cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type t;
   eval_frexp(result, x, &t);
   if ((t > (std::numeric_limits<int>::max)()) || (t < (std::numeric_limits<int>::min)()))
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Exponent is outside the range of an int"));
   *e = static_cast<int>(t);
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline bool eval_is_zero(const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   return val.iszero();
}
template <unsigned Digits10, class ExponentType, class Allocator>
inline int eval_get_sign(const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   return val.iszero() ? 0 : val.isneg() ? -1 : 1;
}

template <unsigned Digits10, class ExponentType, class Allocator>
inline std::size_t hash_value(const cpp_dec_float<Digits10, ExponentType, Allocator>& val)
{
   return val.hash();
}

} // namespace backends

using boost::multiprecision::backends::cpp_dec_float;

using cpp_dec_float_50 = number<cpp_dec_float<50> > ;
using cpp_dec_float_100 = number<cpp_dec_float<100> >;

namespace detail {

template <unsigned Digits10, class ExponentType, class Allocator>
struct transcendental_reduction_type<boost::multiprecision::backends::cpp_dec_float<Digits10, ExponentType, Allocator> >
{
   //
   // The type used for trigonometric reduction needs 3 times the precision of the base type.
   // This is double the precision of the original type, plus the largest exponent supported.
   // As a practical measure the largest argument supported is 1/eps, as supporting larger
   // arguments requires the division of argument by PI/2 to also be done at higher precision,
   // otherwise the result (an integer) can not be represented exactly.
   // 
   // See ARGUMENT REDUCTION FOR HUGE ARGUMENTS. K C Ng.
   //
   using type = boost::multiprecision::backends::cpp_dec_float<Digits10 * 3, ExponentType, Allocator>;
};

} // namespace detail


}} // namespace boost::multiprecision

namespace std {
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >
{
 public:
   static constexpr bool                    is_specialized    = true;
   static constexpr bool                    is_signed         = true;
   static constexpr bool                    is_integer        = false;
   static constexpr bool                    is_exact          = false;
   static constexpr bool                    is_bounded        = true;
   static constexpr bool                    is_modulo         = false;
   static constexpr bool                    is_iec559         = false;
   static constexpr int                     digits            = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10;
   static constexpr int                     digits10          = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10;
   static constexpr int                     max_digits10      = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_digits10;
   static constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type min_exponent                = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp;   // Type differs from int.
   static constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type min_exponent10              = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_min_exp10; // Type differs from int.
   static constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type max_exponent                = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_exp;   // Type differs from int.
   static constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type max_exponent10              = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_max_exp10; // Type differs from int.
   static constexpr int                     radix             = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_radix;
   static constexpr std::float_round_style  round_style       = std::round_indeterminate;
   static constexpr bool                    has_infinity      = true;
   static constexpr bool                    has_quiet_NaN     = true;
   static constexpr bool                    has_signaling_NaN = false;
   static constexpr std::float_denorm_style has_denorm        = std::denorm_absent;
   static constexpr bool                    has_denorm_loss   = false;
   static constexpr bool                    traps             = false;
   static constexpr bool                    tinyness_before   = false;

   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates>(min)() { return (boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::min)(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates>(max)() { return (boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::max)(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> lowest() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::zero(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> epsilon() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::eps(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> round_error() { return 0.5L; }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> infinity() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::inf(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> quiet_NaN() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::nan(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> signaling_NaN() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::zero(); }
   static constexpr boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> denorm_min() { return boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::zero(); }
};

template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::digits;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::digits10;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_signed;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_integer;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_exact;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::radix;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr typename boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::exponent_type numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::has_quiet_NaN;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::has_signaling_NaN;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::has_denorm;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::has_denorm_loss;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::traps;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >::round_style;

} // namespace std

#ifdef BOOST_MP_MATH_AVAILABLE
namespace boost {
namespace math {

namespace policies {

template <unsigned Digits10, class ExponentType, class Allocator, class Policy, boost::multiprecision::expression_template_option ExpressionTemplates>
struct precision<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates>, Policy>
{
   // Define a local copy of cpp_dec_float_digits10 because it might differ
   // from the template parameter Digits10 for small or large digit counts.
   static constexpr std::int32_t cpp_dec_float_digits10 = boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>::cpp_dec_float_digits10;

   using precision_type = typename Policy::precision_type                           ;
   using digits_2 = digits2<((cpp_dec_float_digits10 + 1LL) * 1000LL) / 301LL>;
   using type = typename std::conditional<
       ((digits_2::value <= precision_type::value) || (Policy::precision_type::value <= 0)),
       // Default case, full precision for RealType:
       digits_2,
       // User customized precision:
       precision_type>::type;
};

}

}} // namespace boost::math::policies
#endif

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/add.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_ADD_HPP
#define BOOST_MP_CPP_INT_ADD_HPP

#include <boost/multiprecision/detail/constexpr.hpp>
#include <boost/multiprecision/cpp_int/add_unsigned.hpp>

namespace boost { namespace multiprecision { namespace backends {

//
// As above, but for adding a single limb to a non-trivial cpp_int:
//
template <class CppInt1, class CppInt2>
inline BOOST_MP_CXX14_CONSTEXPR void add_unsigned(CppInt1& result, const CppInt2& a, const limb_type& o) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   // Addition using modular arithmetic.
   // Nothing fancy, just let uintmax_t take the strain:
   if (&result != &a)
      result.resize(a.size(), a.size());
   double_limb_type                     carry = o;
   typename CppInt1::limb_pointer       pr    = result.limbs();
   typename CppInt2::const_limb_pointer pa    = a.limbs();
   std::size_t                             i     = 0;
   // Addition with carry until we either run out of digits or carry is zero:
   for (; carry && (i < result.size()); ++i)
   {
      carry += static_cast<double_limb_type>(pa[i]);
#ifdef __MSVC_RUNTIME_CHECKS
      pr[i] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
      pr[i] = static_cast<limb_type>(carry);
#endif
      carry >>= CppInt1::limb_bits;
   }
   // Just copy any remaining digits:
   if (&a != &result)
   {
      std_constexpr::copy(pa + i, pa + a.size(), pr + i);
   }
   if (carry)
   {
      // We overflowed, need to add one more limb:
      std::size_t x = result.size();
      result.resize(x + 1, x + 1);
      if (result.size() > x)
         result.limbs()[x] = static_cast<limb_type>(carry);
   }
   result.normalize();
   result.sign(a.sign());
}
//
// And again to subtract a single limb:
//
template <class CppInt1, class CppInt2>
inline BOOST_MP_CXX14_CONSTEXPR void subtract_unsigned(CppInt1& result, const CppInt2& a, const limb_type& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   // Subtract one limb.
   // Nothing fancy, just let uintmax_t take the strain:
   constexpr double_limb_type borrow = static_cast<double_limb_type>(CppInt1::max_limb_value) + 1;
   result.resize(a.size(), a.size());
   typename CppInt1::limb_pointer       pr = result.limbs();
   typename CppInt2::const_limb_pointer pa = a.limbs();
   if (*pa >= b)
   {
      *pr = *pa - b;
      if (&result != &a)
      {
         std_constexpr::copy(pa + 1, pa + a.size(), pr + 1);
         result.sign(a.sign());
      }
      else if ((result.size() == 1) && (*pr == 0))
      {
         result.sign(false); // zero is unsigned.
      }
   }
   else if (result.size() == 1)
   {
      *pr = b - *pa;
      result.sign(!a.sign());
   }
   else
   {
      *pr        = static_cast<limb_type>((borrow + *pa) - b);
      std::size_t i = 1;
      while (!pa[i])
      {
         pr[i] = CppInt1::max_limb_value;
         ++i;
      }
      pr[i] = pa[i] - 1;
      if (&result != &a)
      {
         ++i;
         std_constexpr::copy(pa + i, pa + a.size(), pr + i);
      }
      result.normalize();
      result.sign(a.sign());
   }
}

//
// Now the actual functions called by the front end, all of which forward to one of the above:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   eval_add(result, result, o);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (a.sign() != b.sign())
   {
      subtract_unsigned(result, a, b);
      return;
   }
   add_unsigned(result, a, b);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_add(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const limb_type& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (result.sign())
   {
      subtract_unsigned(result, result, o);
   }
   else
      add_unsigned(result, result, o);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const limb_type&                                                            o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (a.sign())
   {
      subtract_unsigned(result, a, o);
   }
   else
      add_unsigned(result, a, o);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    const signed_limb_type&                                               o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (o < 0)
      eval_subtract(result, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));
   else if (o > 0)
      eval_add(result, static_cast<limb_type>(o));
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const signed_limb_type&                                                     o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (o < 0)
      eval_subtract(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));
   else if (o > 0)
      eval_add(result, a, static_cast<limb_type>(o));
   else if (&result != &a)
      result = a;
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    const limb_type&                                                      o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (result.sign())
   {
      add_unsigned(result, result, o);
   }
   else
      subtract_unsigned(result, result, o);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const limb_type&                                                            o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (a.sign())
   {
      add_unsigned(result, a, o);
   }
   else
   {
      subtract_unsigned(result, a, o);
   }
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    const signed_limb_type&                                               o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (o)
   {
      if (o < 0)
         eval_add(result, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));
      else
         eval_subtract(result, static_cast<limb_type>(o));
   }
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const signed_limb_type&                                                     o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (o)
   {
      if (o < 0)
         eval_add(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));
      else
         eval_subtract(result, a, static_cast<limb_type>(o));
   }
   else if (&result != &a)
      result = a;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_increment(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   constexpr limb_type one = 1;

   if (!result.sign() && (result.limbs()[0] < cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value))
      ++result.limbs()[0];
   else if (result.sign() && result.limbs()[0])
   {
      --result.limbs()[0];
      if (!result.limbs()[0] && (result.size() == 1))
         result.sign(false);
   }
   else
      eval_add(result, one);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_decrement(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   constexpr limb_type one = 1;

   if (!result.sign() && result.limbs()[0])
      --result.limbs()[0];
   else if (result.sign() && (result.limbs()[0] < cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value))
      ++result.limbs()[0];
   else
      eval_subtract(result, one);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   eval_subtract(result, result, o);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (a.sign() != b.sign())
   {
      add_unsigned(result, a, b);
      return;
   }
   subtract_unsigned(result, a, b);
}

//
// Simple addition and subtraction routine for trivial cpp_int's come last:
//
// One of the arguments is signed:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type
eval_add(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (result.sign() != o.sign())
   {
      if (*o.limbs() > *result.limbs())
      {
         *result.limbs() = detail::checked_subtract(*o.limbs(), *result.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
         result.negate();
      }
      else
         *result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   }
   else
      *result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}
// Simple version for two unsigned arguments:
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_add(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
         const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

// signed subtraction:
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (result.sign() != o.sign())
   {
      *result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   }
   else if (*result.limbs() < *o.limbs())
   {
      *result.limbs() = detail::checked_subtract(*o.limbs(), *result.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
      result.negate();
   }
   else
      *result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_subtract(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/add_unsigned.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 Madhur Chauhan. 
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_ADD_UNSIGNED_HPP
#define BOOST_MP_ADD_UNSIGNED_HPP

#include <boost/multiprecision/cpp_int/intel_intrinsics.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision { namespace backends {

template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void add_unsigned_constexpr(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   using ::boost::multiprecision::std_constexpr::swap;
   //
   // This is the generic, C++ only version of addition.
   // It's also used for all constexpr branches, hence the name.
   // Nothing fancy, just let uintmax_t take the strain:
   //
   double_limb_type carry = 0;
   std::size_t         m(0), x(0);
   std::size_t         as = a.size();
   std::size_t         bs = b.size();
   minmax(as, bs, m, x);
   if (x == 1)
   {
      bool s = a.sign();
      result = static_cast<double_limb_type>(*a.limbs()) + static_cast<double_limb_type>(*b.limbs());
      result.sign(s);
      return;
   }
   result.resize(x, x);
   typename CppInt2::const_limb_pointer pa     = a.limbs();
   typename CppInt3::const_limb_pointer pb     = b.limbs();
   typename CppInt1::limb_pointer       pr     = result.limbs();
   typename CppInt1::limb_pointer       pr_end = pr + m;

   if (as < bs)
      swap(pa, pb);

   // First where a and b overlap:
   while (pr != pr_end)
   {
      carry += static_cast<double_limb_type>(*pa) + static_cast<double_limb_type>(*pb);
#ifdef __MSVC_RUNTIME_CHECKS
      *pr = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
      *pr = static_cast<limb_type>(carry);
#endif
      carry >>= CppInt1::limb_bits;
      ++pr, ++pa, ++pb;
   }
   pr_end += x - m;
   // Now where only a has digits:
   while (pr != pr_end)
   {
      if (!carry)
      {
         if (pa != pr)
            std_constexpr::copy(pa, pa + (pr_end - pr), pr);
         break;
      }
      carry += static_cast<double_limb_type>(*pa);
#ifdef __MSVC_RUNTIME_CHECKS
      *pr = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
      *pr = static_cast<limb_type>(carry);
#endif
      carry >>= CppInt1::limb_bits;
      ++pr, ++pa;
   }
   if (carry)
   {
      // We overflowed, need to add one more limb:
      result.resize(x + 1, x + 1);
      if (result.size() > x)
         result.limbs()[x] = static_cast<limb_type>(1u);
   }
   result.normalize();
   result.sign(a.sign());
}
//
// Core subtraction routine for all non-trivial cpp_int's:
//
template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void subtract_unsigned_constexpr(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   using ::boost::multiprecision::std_constexpr::swap;
   //
   // This is the generic, C++ only version of subtraction.
   // It's also used for all constexpr branches, hence the name.
   // Nothing fancy, just let uintmax_t take the strain:
   //
   double_limb_type borrow = 0;
   std::size_t         m(0), x(0);
   minmax(a.size(), b.size(), m, x);
   //
   // special cases for small limb counts:
   //
   if (x == 1)
   {
      bool      s  = a.sign();
      limb_type al = *a.limbs();
      limb_type bl = *b.limbs();
      if (bl > al)
      {
         ::boost::multiprecision::std_constexpr::swap(al, bl);
         s = !s;
      }
      result = al - bl;
      result.sign(s);
      return;
   }
   // This isn't used till later, but comparison has to occur before we resize the result,
   // as that may also resize a or b if this is an inplace operation:
   int c = a.compare_unsigned(b);
   // Set up the result vector:
   result.resize(x, x);
   // Now that a, b, and result are stable, get pointers to their limbs:
   typename CppInt2::const_limb_pointer pa      = a.limbs();
   typename CppInt3::const_limb_pointer pb      = b.limbs();
   typename CppInt1::limb_pointer       pr      = result.limbs();
   bool                                 swapped = false;
   if (c < 0)
   {
      swap(pa, pb);
      swapped = true;
   }
   else if (c == 0)
   {
      result = static_cast<limb_type>(0);
      return;
   }

   std::size_t i = 0;
   // First where a and b overlap:
   while (i < m)
   {
      borrow = static_cast<double_limb_type>(pa[i]) - static_cast<double_limb_type>(pb[i]) - borrow;
      pr[i]  = static_cast<limb_type>(borrow);
      borrow = (borrow >> CppInt1::limb_bits) & 1u;
      ++i;
   }
   // Now where only a has digits, only as long as we've borrowed:
   while (borrow && (i < x))
   {
      borrow = static_cast<double_limb_type>(pa[i]) - borrow;
      pr[i]  = static_cast<limb_type>(borrow);
      borrow = (borrow >> CppInt1::limb_bits) & 1u;
      ++i;
   }
   // Any remaining digits are the same as those in pa:
   if ((x != i) && (pa != pr))
      std_constexpr::copy(pa + i, pa + x, pr + i);
   BOOST_MP_ASSERT(0 == borrow);

   //
   // We may have lost digits, if so update limb usage count:
   //
   result.normalize();
   result.sign(a.sign());
   if (swapped)
      result.negate();
}


#ifdef BOOST_MP_HAS_IMMINTRIN_H
//
// This is the key addition routine where all the argument types are non-trivial cpp_int's:
//
//
// This optimization is limited to: GCC, LLVM, ICC (Intel), MSVC for x86_64 and i386.
// If your architecture and compiler supports ADC intrinsic, please file a bug
//
// As of May, 2020 major compilers don't recognize carry chain though adc
// intrinsics are used to hint compilers to use ADC and still compilers don't
// unroll the loop efficiently (except LLVM) so manual unrolling is done.
//
// Also note that these intrinsics were only introduced by Intel as part of the
// ADX processor extensions, even though the addc instruction has been available
// for basically all x86 processors.  That means gcc-9, clang-9, msvc-14.2 and up
// are required to support these intrinsics.
//
template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void add_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(a.size()))
   {
      add_unsigned_constexpr(result, a, b);
   }
   else
#endif
   {
      using std::swap;

      // Nothing fancy, just let uintmax_t take the strain:
      std::size_t m(0), x(0);
      std::size_t as = a.size();
      std::size_t bs = b.size();
      minmax(as, bs, m, x);
      if (x == 1)
      {
         bool s = a.sign();
         result = static_cast<double_limb_type>(*a.limbs()) + static_cast<double_limb_type>(*b.limbs());
         result.sign(s);
         return;
      }
      result.resize(x, x);
      typename CppInt2::const_limb_pointer pa = a.limbs();
      typename CppInt3::const_limb_pointer pb = b.limbs();
      typename CppInt1::limb_pointer       pr = result.limbs();

      if (as < bs)
         swap(pa, pb);
      // First where a and b overlap:
      std::size_t      i = 0;
      unsigned char carry = 0;
#if defined(BOOST_MSVC) && !defined(BOOST_HAS_INT128) && defined(_M_X64)
      //
      // Special case for 32-bit limbs on 64-bit architecture - we can process
      // 2 limbs with each instruction.
      //
      for (; i + 8 <= m; i += 8)
      {
         carry = _addcarry_u64(carry, *(unsigned long long*)(pa + i + 0), *(unsigned long long*)(pb + i + 0), (unsigned long long*)(pr + i));
         carry = _addcarry_u64(carry, *(unsigned long long*)(pa + i + 2), *(unsigned long long*)(pb + i + 2), (unsigned long long*)(pr + i + 2));
         carry = _addcarry_u64(carry, *(unsigned long long*)(pa + i + 4), *(unsigned long long*)(pb + i + 4), (unsigned long long*)(pr + i + 4));
         carry = _addcarry_u64(carry, *(unsigned long long*)(pa + i + 6), *(unsigned long long*)(pb + i + 6), (unsigned long long*)(pr + i + 6));
      }
#else
      for (; i + 4 <= m; i += 4)
      {
         carry = ::boost::multiprecision::detail::addcarry_limb(carry, pa[i + 0], pb[i + 0], pr + i);
         carry = ::boost::multiprecision::detail::addcarry_limb(carry, pa[i + 1], pb[i + 1], pr + i + 1);
         carry = ::boost::multiprecision::detail::addcarry_limb(carry, pa[i + 2], pb[i + 2], pr + i + 2);
         carry = ::boost::multiprecision::detail::addcarry_limb(carry, pa[i + 3], pb[i + 3], pr + i + 3);
      }
#endif
      for (; i < m; ++i)
         carry = ::boost::multiprecision::detail::addcarry_limb(carry, pa[i], pb[i], pr + i);
      for (; i < x && carry; ++i)
         // We know carry is 1, so we just need to increment pa[i] (ie add a literal 1) and capture the carry:
         carry = ::boost::multiprecision::detail::addcarry_limb(0, pa[i], 1, pr + i);
      if (i == x && carry)
      {
         // We overflowed, need to add one more limb:
         result.resize(x + 1, x + 1);
         if (result.size() > x)
            result.limbs()[x] = static_cast<limb_type>(1u);
      }
      else if ((x != i) && (pa != pr))
         // Copy remaining digits only if we need to:
         std_constexpr::copy(pa + i, pa + x, pr + i);
      result.normalize();
      result.sign(a.sign());
   }
}

template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void subtract_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(a.size()))
   {
      subtract_unsigned_constexpr(result, a, b);
   }
   else
#endif
   {
      using std::swap;

      // Nothing fancy, just let uintmax_t take the strain:
      std::size_t         m(0), x(0);
      minmax(a.size(), b.size(), m, x);
      //
      // special cases for small limb counts:
      //
      if (x == 1)
      {
         bool      s = a.sign();
         limb_type al = *a.limbs();
         limb_type bl = *b.limbs();
         if (bl > al)
         {
            ::boost::multiprecision::std_constexpr::swap(al, bl);
            s = !s;
         }
         result = al - bl;
         result.sign(s);
         return;
      }
      // This isn't used till later, but comparison has to occur before we resize the result,
      // as that may also resize a or b if this is an inplace operation:
      int c = a.compare_unsigned(b);
      // Set up the result vector:
      result.resize(x, x);
      // Now that a, b, and result are stable, get pointers to their limbs:
      typename CppInt2::const_limb_pointer pa = a.limbs();
      typename CppInt3::const_limb_pointer pb = b.limbs();
      typename CppInt1::limb_pointer       pr = result.limbs();
      bool                                 swapped = false;
      if (c < 0)
      {
         swap(pa, pb);
         swapped = true;
      }
      else if (c == 0)
      {
         result = static_cast<limb_type>(0);
         return;
      }

      std::size_t i = 0;
      unsigned char borrow = 0;
      // First where a and b overlap:
#if defined(BOOST_MSVC) && !defined(BOOST_HAS_INT128) && defined(_M_X64)
      //
      // Special case for 32-bit limbs on 64-bit architecture - we can process
      // 2 limbs with each instruction.
      //
      for (; i + 8 <= m; i += 8)
      {
         borrow = _subborrow_u64(borrow, *reinterpret_cast<const unsigned long long*>(pa + i), *reinterpret_cast<const unsigned long long*>(pb + i), reinterpret_cast<unsigned long long*>(pr + i));
         borrow = _subborrow_u64(borrow, *reinterpret_cast<const unsigned long long*>(pa + i + 2), *reinterpret_cast<const unsigned long long*>(pb + i + 2), reinterpret_cast<unsigned long long*>(pr + i + 2));
         borrow = _subborrow_u64(borrow, *reinterpret_cast<const unsigned long long*>(pa + i + 4), *reinterpret_cast<const unsigned long long*>(pb + i + 4), reinterpret_cast<unsigned long long*>(pr + i + 4));
         borrow = _subborrow_u64(borrow, *reinterpret_cast<const unsigned long long*>(pa + i + 6), *reinterpret_cast<const unsigned long long*>(pb + i + 6), reinterpret_cast<unsigned long long*>(pr + i + 6));
      }
#else
      for(; i + 4 <= m; i += 4)
      {
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i], pb[i], pr + i);
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i + 1], pb[i + 1], pr + i + 1);
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i + 2], pb[i + 2], pr + i + 2);
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i + 3], pb[i + 3], pr + i + 3);
      }
#endif
      for (; i < m; ++i)
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i], pb[i], pr + i);

      // Now where only a has digits, only as long as we've borrowed:
      while (borrow && (i < x))
      {
         borrow = boost::multiprecision::detail::subborrow_limb(borrow, pa[i], 0, pr + i);
         ++i;
      }
      // Any remaining digits are the same as those in pa:
      if ((x != i) && (pa != pr))
         std_constexpr::copy(pa + i, pa + x, pr + i);
      BOOST_MP_ASSERT(0 == borrow);

      //
      // We may have lost digits, if so update limb usage count:
      //
      result.normalize();
      result.sign(a.sign());
      if (swapped)
         result.negate();
   }  // constepxr.
}

#else

template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void add_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   add_unsigned_constexpr(result, a, b);
}

template <class CppInt1, class CppInt2, class CppInt3>
inline BOOST_MP_CXX14_CONSTEXPR void subtract_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) noexcept(is_non_throwing_cpp_int<CppInt1>::value)
{
   subtract_unsigned_constexpr(result, a, b);
}

#endif

} } }  // namespaces


#endif




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/bitwise.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_BITWISE_HPP
#define BOOST_MP_CPP_INT_BITWISE_HPP

#include <stdexcept>
#include <type_traits>
#include <boost/multiprecision/detail/endian.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4319)
#endif


namespace boost { namespace multiprecision { namespace backends {

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_CXX14_CONSTEXPR void is_valid_bitwise_op(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o, const std::integral_constant<int, checked>&)
{
   if (result.sign() || o.sign())
      BOOST_MP_THROW_EXCEPTION(std::range_error("Bitwise operations on negative values results in undefined behavior."));
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_CXX14_CONSTEXPR void is_valid_bitwise_op(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&, const std::integral_constant<int, unchecked>&) {}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_CXX14_CONSTEXPR void is_valid_bitwise_op(
    const cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>& result, const std::integral_constant<int, checked>&)
{
   if (result.sign())
      BOOST_MP_THROW_EXCEPTION(std::range_error("Bitwise operations on negative values results in undefined behavior."));
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_CXX14_CONSTEXPR void is_valid_bitwise_op(
    const cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>&, const std::integral_constant<int, checked>&) {}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_CXX14_CONSTEXPR void is_valid_bitwise_op(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&, const std::integral_constant<int, unchecked>&) {}

template <class CppInt1, class CppInt2, class Op>
BOOST_MP_CXX14_CONSTEXPR void bitwise_op(
    CppInt1&       result,
    const CppInt2& o,
    Op             op, const std::integral_constant<bool, true>&) noexcept((is_non_throwing_cpp_int<CppInt1>::value))
{
   //
   // There are 4 cases:
   // * Both positive.
   // * result negative, o positive.
   // * o negative, result positive.
   // * Both negative.
   //
   // When one arg is negative we convert to 2's complement form "on the fly",
   // and then convert back to signed-magnitude form at the end.
   //
   // Note however, that if the type is checked, then bitwise ops on negative values
   // are not permitted and an exception will result.
   //
   is_valid_bitwise_op(result, o, typename CppInt1::checked_type());
   //
   // First figure out how big the result needs to be and set up some data:
   //
   std::size_t rs = result.size();
   std::size_t os = o.size();
   std::size_t m(0), x(0);
   minmax(rs, os, m, x);
   result.resize(x, x);
   typename CppInt1::limb_pointer       pr = result.limbs();
   typename CppInt2::const_limb_pointer po = o.limbs();
   for (std::size_t i = rs; i < x; ++i)
      pr[i] = 0;

   limb_type next_limb = 0;

   if (!result.sign())
   {
      if (!o.sign())
      {
         for (std::size_t i = 0; i < os; ++i)
            pr[i] = op(pr[i], po[i]);
         for (std::size_t i = os; i < x; ++i)
            pr[i] = op(pr[i], limb_type(0));
      }
      else
      {
         // "o" is negative:
         double_limb_type carry = 1;
         for (std::size_t i = 0; i < os; ++i)
         {
            carry += static_cast<double_limb_type>(~po[i]);
            pr[i] = op(pr[i], static_cast<limb_type>(carry));
            carry >>= CppInt1::limb_bits;
         }
         for (std::size_t i = os; i < x; ++i)
         {
            carry += static_cast<double_limb_type>(~limb_type(0));
            pr[i] = op(pr[i], static_cast<limb_type>(carry));
            carry >>= CppInt1::limb_bits;
         }
         // Set the overflow into the "extra" limb:
         carry += static_cast<double_limb_type>(~limb_type(0));
         next_limb = op(limb_type(0), static_cast<limb_type>(carry));
      }
   }
   else
   {
      if (!o.sign())
      {
         // "result" is negative:
         double_limb_type carry = 1;
         for (std::size_t i = 0; i < os; ++i)
         {
            carry += static_cast<double_limb_type>(~pr[i]);
            pr[i] = op(static_cast<limb_type>(carry), po[i]);
            carry >>= CppInt1::limb_bits;
         }
         for (std::size_t i = os; i < x; ++i)
         {
            carry += static_cast<double_limb_type>(~pr[i]);
            pr[i] = op(static_cast<limb_type>(carry), limb_type(0));
            carry >>= CppInt1::limb_bits;
         }
         // Set the overflow into the "extra" limb:
         carry += static_cast<double_limb_type>(~limb_type(0));
         next_limb = op(static_cast<limb_type>(carry), limb_type(0));
      }
      else
      {
         // both are negative:
         double_limb_type r_carry = 1;
         double_limb_type o_carry = 1;
         for (std::size_t i = 0; i < os; ++i)
         {
            r_carry += static_cast<double_limb_type>(~pr[i]);
            o_carry += static_cast<double_limb_type>(~po[i]);
            pr[i] = op(static_cast<limb_type>(r_carry), static_cast<limb_type>(o_carry));
            r_carry >>= CppInt1::limb_bits;
            o_carry >>= CppInt1::limb_bits;
         }
         for (std::size_t i = os; i < x; ++i)
         {
            r_carry += static_cast<double_limb_type>(~pr[i]);
            o_carry += static_cast<double_limb_type>(~limb_type(0));
            pr[i] = op(static_cast<limb_type>(r_carry), static_cast<limb_type>(o_carry));
            r_carry >>= CppInt1::limb_bits;
            o_carry >>= CppInt1::limb_bits;
         }
         // Set the overflow into the "extra" limb:
         r_carry += static_cast<double_limb_type>(~limb_type(0));
         o_carry += static_cast<double_limb_type>(~limb_type(0));
         next_limb = op(static_cast<limb_type>(r_carry), static_cast<limb_type>(o_carry));
      }
   }
   //
   // See if the result is negative or not:
   //
   if (static_cast<signed_limb_type>(next_limb) < 0)
   {
      double_limb_type carry = 1;
      for (std::size_t i = 0; i < x; ++i)
      {
         carry += static_cast<double_limb_type>(~pr[i]);
         pr[i] = static_cast<limb_type>(carry);
         carry >>= CppInt1::limb_bits;
      }
      if (carry)
      {
         result.resize(x + 1, x);
         if (result.size() > x)
            result.limbs()[x] = static_cast<limb_type>(carry);
      }
      result.sign(true);
   }
   else
      result.sign(false);

   result.normalize();
}

template <class CppInt1, class CppInt2, class Op>
BOOST_MP_CXX14_CONSTEXPR void bitwise_op(
    CppInt1&       result,
    const CppInt2& o,
    Op             op, const std::integral_constant<bool, false>&) noexcept((is_non_throwing_cpp_int<CppInt1>::value))
{
   //
   // Both arguments are unsigned types, very simple case handled as a special case.
   //
   // First figure out how big the result needs to be and set up some data:
   //
   std::size_t rs = result.size();
   std::size_t os = o.size();
   std::size_t m(0), x(0);
   minmax(rs, os, m, x);
   result.resize(x, x);
   typename CppInt1::limb_pointer       pr = result.limbs();
   typename CppInt2::const_limb_pointer po = o.limbs();
   for (std::size_t i = rs; i < x; ++i)
      pr[i] = 0;

   for (std::size_t i = 0; i < os; ++i)
      pr[i] = op(pr[i], po[i]);
   for (std::size_t i = os; i < x; ++i)
      pr[i] = op(pr[i], limb_type(0));

   result.normalize();
}

struct bit_and
{
   BOOST_MP_CXX14_CONSTEXPR limb_type operator()(limb_type a, limb_type b) const noexcept { return a & b; }
};
struct bit_or
{
   BOOST_MP_CXX14_CONSTEXPR limb_type operator()(limb_type a, limb_type b) const noexcept { return a | b; }
};
struct bit_xor
{
   BOOST_MP_CXX14_CONSTEXPR limb_type operator()(limb_type a, limb_type b) const noexcept { return a ^ b; }
};

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_and(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   bitwise_op(result, o, bit_and(),
              std::integral_constant<bool, std::numeric_limits<number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> > >::is_signed || std::numeric_limits<number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> > >::is_signed > ());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_or(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   bitwise_op(result, o, bit_or(),
              std::integral_constant<bool, std::numeric_limits<number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> > >::is_signed || std::numeric_limits<number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> > >::is_signed > ());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_xor(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   bitwise_op(result, o, bit_xor(),
              std::integral_constant<bool, std::numeric_limits<number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> > >::is_signed || std::numeric_limits<number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> > >::is_signed > ());
}
//
// Again for operands which are single limbs:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1> >::value>::type
eval_bitwise_and(
    cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>& result,
    limb_type                                                                      l) noexcept
{
   result.limbs()[0] &= l;
   result.resize(1, 1);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1> >::value>::type
eval_bitwise_or(
    cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>& result,
    limb_type                                                                      l) noexcept
{
   result.limbs()[0] |= l;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1> >::value>::type
eval_bitwise_xor(
    cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>& result,
    limb_type                                                                      l) noexcept
{
   result.limbs()[0] ^= l;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_complement(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   static_assert(((Checked1 != checked) || (Checked2 != checked)), "Attempt to take the complement of a signed type results in undefined behavior.");
   // Increment and negate:
   result = o;
   eval_increment(result);
   result.negate();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_complement(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   std::size_t os = o.size();
   result.resize(SIZE_MAX, os);
   for (std::size_t i = 0; i < os; ++i)
      result.limbs()[i] = ~o.limbs()[i];
   for (std::size_t i = os; i < result.size(); ++i)
      result.limbs()[i] = ~static_cast<limb_type>(0);
   result.normalize();
}

template <class Int>
inline void left_shift_byte(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   limb_type shift  = static_cast<limb_type>(s % Int::limb_bits);
   std::size_t  ors    = result.size();
   if ((ors == 1) && (!*result.limbs()))
      return; // shifting zero yields zero.
   std::size_t rs = ors;
   if (shift && (result.limbs()[ors - 1] >> (Int::limb_bits - shift)))
      ++rs; // Most significant limb will overflow when shifted
   rs += offset;
   result.resize(rs, rs);
   rs = result.size();

   typename Int::limb_pointer pr = result.limbs();

   if (rs != ors)
      pr[rs - 1] = 0u;
   std::size_t bytes = static_cast<std::size_t>(s / CHAR_BIT);
   std::size_t len   = (std::min)(ors * sizeof(limb_type), rs * sizeof(limb_type) - bytes);
   if (bytes >= rs * sizeof(limb_type))
      result = static_cast<limb_type>(0u);
   else
   {
      unsigned char* pc = reinterpret_cast<unsigned char*>(pr);
      std::memmove(pc + bytes, pc, len);
      std::memset(pc, 0, bytes);
   }
}

template <class Int>
inline BOOST_MP_CXX14_CONSTEXPR void left_shift_limb(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   limb_type shift  = static_cast<limb_type>(s % Int::limb_bits);

   std::size_t ors = result.size();
   if ((ors == 1) && (!*result.limbs()))
      return; // shifting zero yields zero.
   std::size_t rs = ors;
   if (shift && (result.limbs()[ors - 1] >> (Int::limb_bits - shift)))
      ++rs; // Most significant limb will overflow when shifted
   rs += offset;
   result.resize(rs, rs);

   typename Int::limb_pointer pr = result.limbs();

   if (offset > rs)
   {
      // The result is shifted past the end of the result:
      result = static_cast<limb_type>(0);
      return;
   }

   std::size_t i = rs - result.size();
   for (; i < ors; ++i)
      pr[rs - 1 - i] = pr[ors - 1 - i];
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(s))
   {
      for (; i < rs; ++i)
         pr[rs - 1 - i] = 0;
   }
   else
#endif
   {
      std::memset(pr, 0, (rs - i) * sizeof(*pr));
   }
}

template <class Int>
inline BOOST_MP_CXX14_CONSTEXPR void left_shift_generic(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   limb_type shift  = static_cast<limb_type>(s % Int::limb_bits);

   std::size_t ors = result.size();
   if ((ors == 1) && (!*result.limbs()))
      return; // shifting zero yields zero.
   std::size_t rs = ors;
   if (shift && (result.limbs()[ors - 1] >> (Int::limb_bits - shift)))
      ++rs; // Most significant limb will overflow when shifted
   rs += offset;
   result.resize(rs, rs);
   bool truncated = result.size() != rs;

   typename Int::limb_pointer pr = result.limbs();

   if (offset > rs)
   {
      // The result is shifted past the end of the result:
      result = static_cast<limb_type>(0);
      return;
   }

   std::size_t i = rs - result.size();
   // This code only works when shift is non-zero, otherwise we invoke undefined behaviour!
   BOOST_MP_ASSERT(shift);
   if (!truncated)
   {
      if (rs > ors + offset)
      {
         pr[rs - 1 - i] = pr[ors - 1 - i] >> (Int::limb_bits - shift);
         --rs;
      }
      else
      {
         pr[rs - 1 - i] = pr[ors - 1 - i] << shift;
         if (ors > 1)
            pr[rs - 1 - i] |= pr[ors - 2 - i] >> (Int::limb_bits - shift);
         ++i;
      }
   }
   for (; rs - i >= 2 + offset; ++i)
   {
      pr[rs - 1 - i] = pr[rs - 1 - i - offset] << shift;
      pr[rs - 1 - i] |= pr[rs - 2 - i - offset] >> (Int::limb_bits - shift);
   }
   if (rs - i >= 1 + offset)
   {
      pr[rs - 1 - i] = pr[rs - 1 - i - offset] << shift;
      ++i;
   }
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(s))
   {
      for (; i < rs; ++i)
         pr[rs - 1 - i] = 0;
   }
   else
#endif
   {
      std::memset(pr, 0, (rs - i) * sizeof(*pr));
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_left_shift(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    double_limb_type                                                      s) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   if (!s)
      return;

#if BOOST_MP_ENDIAN_LITTLE_BYTE && defined(BOOST_MP_USE_LIMB_SHIFT)
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits - 1;
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

   if ((s & limb_shift_mask) == 0)
   {
      left_shift_limb(result, s);
   }
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   else if ((s & byte_shift_mask) == 0)
#else
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
   {
      left_shift_byte(result, s);
   }
#elif BOOST_MP_ENDIAN_LITTLE_BYTE
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   if ((s & byte_shift_mask) == 0)
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits - 1;
   if (BOOST_MP_IS_CONST_EVALUATED(s) && ((s & limb_shift_mask) == 0))
      left_shift_limb(result, s);
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
   {
      left_shift_byte(result, s);
   }
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits - 1;

   if ((s & limb_shift_mask) == 0)
   {
      left_shift_limb(result, s);
   }
#endif
   else
   {
      left_shift_generic(result, s);
   }
   //
   // We may have shifted off the end and have leading zeros:
   //
   result.normalize();
}

template <class Int>
inline void right_shift_byte(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   BOOST_MP_ASSERT((s % CHAR_BIT) == 0);
   std::size_t ors = result.size();
   std::size_t rs  = ors;
   if (offset >= rs)
   {
      result = limb_type(0);
      return;
   }
   rs -= offset;
   typename Int::limb_pointer pr = result.limbs();
   unsigned char*             pc = reinterpret_cast<unsigned char*>(pr);
   limb_type                  shift = static_cast<limb_type>(s / CHAR_BIT);
   std::memmove(pc, pc + shift, ors * sizeof(pr[0]) - shift);
   shift = (sizeof(limb_type) - shift % sizeof(limb_type)) * CHAR_BIT;
   if (shift < Int::limb_bits)
   {
      pr[ors - offset - 1] &= (static_cast<limb_type>(1u) << shift) - 1;
      if (!pr[ors - offset - 1] && (rs > 1))
         --rs;
   }
   result.resize(rs, rs);
}

template <class Int>
inline BOOST_MP_CXX14_CONSTEXPR void right_shift_limb(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   BOOST_MP_ASSERT((s % Int::limb_bits) == 0);
   std::size_t ors = result.size();
   std::size_t rs  = ors;
   if (offset >= rs)
   {
      result = limb_type(0);
      return;
   }
   rs -= offset;
   typename Int::limb_pointer pr = result.limbs();
   std::size_t                   i  = 0;
   for (; i < rs; ++i)
      pr[i] = pr[i + offset];
   result.resize(rs, rs);
}

template <class Int>
inline BOOST_MP_CXX14_CONSTEXPR void right_shift_generic(Int& result, double_limb_type s)
{
   limb_type offset = static_cast<limb_type>(s / Int::limb_bits);
   limb_type shift  = static_cast<limb_type>(s % Int::limb_bits);
   std::size_t  ors    = result.size();
   std::size_t  rs     = ors;
   if (offset >= rs)
   {
      result = limb_type(0);
      return;
   }
   rs -= offset;
   typename Int::limb_pointer pr = result.limbs();
   if ((pr[ors - 1] >> shift) == 0)
   {
      if (--rs == 0)
      {
         result = limb_type(0);
         return;
      }
   }
   std::size_t i = 0;

   // This code only works for non-zero shift, otherwise we invoke undefined behaviour!
   BOOST_MP_ASSERT(shift);
   for (; i + offset + 1 < ors; ++i)
   {
      pr[i] = pr[i + offset] >> shift;
      pr[i] |= pr[i + offset + 1] << (Int::limb_bits - shift);
   }
   pr[i] = pr[i + offset] >> shift;
   result.resize(rs, rs);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1> >::value>::type
eval_right_shift(
    cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>& result,
    double_limb_type                                                               s) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, typename cpp_int_backend<MinBits1, MaxBits1, unsigned_magnitude, Checked1, Allocator1>::checked_type());
   if (!s)
      return;

#if BOOST_MP_ENDIAN_LITTLE_BYTE && defined(BOOST_MP_USE_LIMB_SHIFT)
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

   if ((s & limb_shift_mask) == 0)
      right_shift_limb(result, s);
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   else if ((s & byte_shift_mask) == 0)
#else
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
      right_shift_byte(result, s);
#elif BOOST_MP_ENDIAN_LITTLE_BYTE
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   if ((s & byte_shift_mask) == 0)
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;
   if (BOOST_MP_IS_CONST_EVALUATED(s) && ((s & limb_shift_mask) == 0))
      right_shift_limb(result, s);
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
      right_shift_byte(result, s);
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;

   if ((s & limb_shift_mask) == 0)
      right_shift_limb(result, s);
#endif
   else
      right_shift_generic(result, s);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1> >::value>::type
eval_right_shift(
    cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>& result,
    double_limb_type                                                             s) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, typename cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::checked_type());
   if (!s)
      return;

   bool is_neg = result.sign();
   if (is_neg)
      eval_increment(result);

#if BOOST_MP_ENDIAN_LITTLE_BYTE && defined(BOOST_MP_USE_LIMB_SHIFT)
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

   if ((s & limb_shift_mask) == 0)
      right_shift_limb(result, s);
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   else if ((s & byte_shift_mask) == 0)
#else
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
      right_shift_byte(result, s);
#elif BOOST_MP_ENDIAN_LITTLE_BYTE
   constexpr limb_type byte_shift_mask = CHAR_BIT - 1;

#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   if ((s & byte_shift_mask) == 0)
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;
   if (BOOST_MP_IS_CONST_EVALUATED(s) && ((s & limb_shift_mask) == 0))
      right_shift_limb(result, s);
   else if (((s & byte_shift_mask) == 0) && !BOOST_MP_IS_CONST_EVALUATED(s))
#endif
      right_shift_byte(result, s);
#else
   constexpr limb_type limb_shift_mask = cpp_int_backend<MinBits1, MaxBits1, signed_magnitude, Checked1, Allocator1>::limb_bits - 1;

   if ((s & limb_shift_mask) == 0)
      right_shift_limb(result, s);
#endif
   else
      right_shift_generic(result, s);
   if (is_neg)
      eval_decrement(result);
}

//
// Over again for trivial cpp_int's:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class T>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value >::type
eval_left_shift(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, T s) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   *result.limbs() = detail::checked_left_shift(*result.limbs(), s, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class T>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value >::type
eval_right_shift(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, T s) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   // Nothing to check here... just make sure we don't invoke undefined behavior:
   is_valid_bitwise_op(result, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   *result.limbs() = (static_cast<unsigned>(s) >= sizeof(*result.limbs()) * CHAR_BIT) ? 0 : (result.sign() ? ((--*result.limbs()) >> s) + 1 : *result.limbs() >> s);
   if (result.sign() && (*result.limbs() == 0))
      result = static_cast<signed_limb_type>(-1);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value)>::type
eval_complement(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   static_assert(((Checked1 != checked) || (Checked2 != checked)), "Attempt to take the complement of a signed type results in undefined behavior.");
   //
   // If we're not checked then emulate 2's complement behavior:
   //
   if (o.sign())
   {
      *result.limbs() = *o.limbs() - 1;
      result.sign(false);
   }
   else
   {
      *result.limbs() = 1 + *o.limbs();
      result.sign(true);
   }
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_complement(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = ~*o.limbs();
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_and(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() &= *o.limbs();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value)>::type
eval_bitwise_and(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, o, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

   using default_ops::eval_bit_test;
   using default_ops::eval_increment;

   if (result.sign() || o.sign())
   {
      constexpr std::size_t m = detail::static_unsigned_max<detail::static_unsigned_max<MinBits1, MinBits2>::value, detail::static_unsigned_max<MaxBits1, MaxBits2>::value>::value;
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t1(result);
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t2(o);
      eval_bitwise_and(t1, t2);
      bool s = eval_bit_test(t1, m + 1);
      if (s)
      {
         eval_complement(t1, t1);
         eval_increment(t1);
      }
      result = t1;
      result.sign(s);
   }
   else
   {
      *result.limbs() &= *o.limbs();
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_or(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() |= *o.limbs();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value)>::type
eval_bitwise_or(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, o, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

   using default_ops::eval_bit_test;
   using default_ops::eval_increment;

   if (result.sign() || o.sign())
   {
      constexpr std::size_t m = detail::static_unsigned_max<detail::static_unsigned_max<MinBits1, MinBits2>::value, detail::static_unsigned_max<MaxBits1, MaxBits2>::value>::value;
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t1(result);
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t2(o);
      eval_bitwise_or(t1, t2);
      bool s = eval_bit_test(t1, m + 1);
      if (s)
      {
         eval_complement(t1, t1);
         eval_increment(t1);
      }
      result = t1;
      result.sign(s);
   }
   else
   {
      *result.limbs() |= *o.limbs();
      result.normalize();
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_bitwise_xor(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() ^= *o.limbs();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value)>::type
eval_bitwise_xor(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   is_valid_bitwise_op(result, o, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

   using default_ops::eval_bit_test;
   using default_ops::eval_increment;

   if (result.sign() || o.sign())
   {
      constexpr std::size_t m = detail::static_unsigned_max<detail::static_unsigned_max<MinBits1, MinBits2>::value, detail::static_unsigned_max<MaxBits1, MaxBits2>::value>::value;
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t1(result);
      cpp_int_backend<m + 1, m + 1, unsigned_magnitude, unchecked, void> t2(o);
      eval_bitwise_xor(t1, t2);
      bool s = eval_bit_test(t1, m + 1);
      if (s)
      {
         eval_complement(t1, t1);
         eval_increment(t1);
      }
      result = t1;
      result.sign(s);
   }
   else
   {
      *result.limbs() ^= *o.limbs();
   }
}

}}} // namespace boost::multiprecision::backends

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/checked.hpp
================================================

//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_CHECKED_HPP
#define BOOST_MP_CPP_INT_CHECKED_HPP

#include <climits>
#include <limits>
#include <type_traits>
#include <stdexcept>
#include <string>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

namespace boost { namespace multiprecision { namespace backends { namespace detail {

//
// Simple routines for performing checked arithmetic with a builtin arithmetic type.
// Note that this is not a complete header, it must be included as part of boost/multiprecision/cpp_int.hpp.
//

template <typename T>
inline constexpr T type_max() noexcept
{
   return 
   #ifdef BOOST_HAS_INT128
   std::is_same<T, boost::multiprecision::int128_type>::value ? INT128_MAX :
   std::is_same<T, boost::multiprecision::uint128_type>::value ? UINT128_MAX :
   #endif
   (std::numeric_limits<T>::max)();
}

template <typename T>
inline constexpr T type_min() noexcept
{
   return 
   #ifdef BOOST_HAS_INT128
   std::is_same<T, boost::multiprecision::int128_type>::value ? INT128_MIN :
   std::is_same<T, boost::multiprecision::uint128_type>::value ? T(0) :
   #endif
   (std::numeric_limits<T>::min)();
}

inline void raise_overflow(std::string op)
{
   BOOST_MP_THROW_EXCEPTION(std::overflow_error("overflow in " + op));
}
inline void raise_add_overflow()
{
   raise_overflow("addition");
}
inline void raise_subtract_overflow()
{
   BOOST_MP_THROW_EXCEPTION(std::range_error("Subtraction resulted in a negative value, but the type is unsigned"));
}
inline void raise_mul_overflow()
{
   raise_overflow("multiplication");
}
inline void raise_div_overflow()
{
   raise_overflow("division");
}

template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_add_imp(A a, A b, const std::integral_constant<bool, true>&)
{
   if (a > 0)
   {
      if ((b > 0) && ((type_max<A>() - b) < a))
         raise_add_overflow();
   }
   else
   {
      if ((b < 0) && ((type_min<A>() - b) > a))
         raise_add_overflow();
   }
   return a + b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_add_imp(A a, A b, const std::integral_constant<bool, false>&)
{
   if ((type_max<A>() - b) < a)
      raise_add_overflow();
   return a + b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_add(A a, A b, const std::integral_constant<int, checked>&)
{
   return checked_add_imp(a, b, std::integral_constant<bool, boost::multiprecision::detail::is_signed<A>::value && boost::multiprecision::detail::is_integral<A>::value > ());
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_add(A a, A b, const std::integral_constant<int, unchecked>&)
{
   return a + b;
}

template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract_imp(A a, A b, const std::integral_constant<bool, true>&)
{
   if (a > 0)
   {
      if ((b < 0) && ((type_max<A>() + b) < a))
         raise_subtract_overflow();
   }
   else
   {
      if ((b > 0) && ((type_min<A>() + b) > a))
         raise_subtract_overflow();
   }
   return a - b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract_imp(A a, A b, const std::integral_constant<bool, false>&)
{
   if (a < b)
      raise_subtract_overflow();
   return a - b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract(A a, A b, const std::integral_constant<int, checked>&)
{
   return checked_subtract_imp(a, b, std::integral_constant<bool, boost::multiprecision::detail::is_signed<A>::value && boost::multiprecision::detail::is_integral<A>::value>());
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract(A a, A b, const std::integral_constant<int, unchecked>&)
{
   return a - b;
}

template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_multiply(A a, A b, const std::integral_constant<int, checked>&)
{
   BOOST_MP_USING_ABS
   if (a && (type_max<A>() / abs(a) < abs(b)))
      raise_mul_overflow();
   return a * b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_multiply(A a, A b, const std::integral_constant<int, unchecked>&)
{
   return a * b;
}

template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_divide(A a, A b, const std::integral_constant<int, checked>&)
{
   if (b == 0)
      raise_div_overflow();
   return a / b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_divide(A a, A b, const std::integral_constant<int, unchecked>&)
{
   return a / b;
}

template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_left_shift(A a, unsigned long long shift, const std::integral_constant<int, checked>&)
{
   if (a && shift)
   {
      if ((shift > sizeof(A) * CHAR_BIT) || (a >> (sizeof(A) * CHAR_BIT - shift)))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Shift out of range"));
   }
   return a << shift;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR A checked_left_shift(A a, unsigned long long shift, const std::integral_constant<int, unchecked>&)
{
   return (shift >= sizeof(A) * CHAR_BIT) ? 0 : a << shift;
}

}}}} // namespace boost::multiprecision::backends::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/comparison.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_COMPARISON_HPP
#define BOOST_MP_CPP_INT_COMPARISON_HPP

#include <boost/multiprecision/detail/constexpr.hpp>

namespace boost { namespace multiprecision { namespace backends {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4018 4389 4996)
#endif

//
// Start with non-trivial cpp_int's:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& a, const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& b) noexcept
{
   return (a.sign() == b.sign()) && (a.size() == b.size()) && std_constexpr::equal(a.limbs(), a.limbs() + a.size(), b.limbs());
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b) noexcept
{
   return (a.sign() == b.sign()) && (a.size() == b.size()) && std_constexpr::equal(a.limbs(), a.limbs() + a.size(), b.limbs());
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   return (a.sign() == false) && (a.size() == 1) && (*a.limbs() == b);
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   return (a.sign() == (b < 0)) && (a.size() == 1) && (*a.limbs() == boost::multiprecision::detail::unsigned_abs(b));
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   return (a.size() == 1) && (*a.limbs() == b);
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   return (b < 0) ? eval_eq(a, cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>(b)) : eval_eq(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   if (a.sign())
      return true;
   if (a.size() > 1)
      return false;
   return *a.limbs() < b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   if ((b == 0) || (a.sign() != (b < 0)))
      return a.sign();
   if (a.sign())
   {
      if (a.size() > 1)
         return true;
      return *a.limbs() > boost::multiprecision::detail::unsigned_abs(b);
   }
   else
   {
      if (a.size() > 1)
         return false;
      return *a.limbs() < boost::multiprecision::detail::unsigned_abs(b);
   }
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   if (a.size() > 1)
      return false;
   return *a.limbs() < b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   return (b < 0) ? a.compare(b) < 0 : eval_lt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   if (a.sign())
      return false;
   if (a.size() > 1)
      return true;
   return *a.limbs() > b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   if (b == 0)
      return !a.sign() && ((a.size() > 1) || *a.limbs());
   if (a.sign() != (b < 0))
      return !a.sign();
   if (a.sign())
   {
      if (a.size() > 1)
         return false;
      return *a.limbs() < boost::multiprecision::detail::unsigned_abs(b);
   }
   else
   {
      if (a.size() > 1)
         return true;
      return *a.limbs() > boost::multiprecision::detail::unsigned_abs(b);
   }
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
{
   if (a.size() > 1)
      return true;
   return *a.limbs() > b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
{
   return (b < 0) ? a.compare(b) > 0 : eval_gt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison.
}
//
// And again for trivial cpp_ints:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::value
eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& b) noexcept
{
   return (a.sign() == b.sign()) && (*a.limbs() == *b.limbs());
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::value
eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
{
   return *a.limbs() == *b.limbs();
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
{
   return !a.sign() && (*a.limbs() == b);
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
{
   return (a.sign() == (b < 0)) && (*a.limbs() == boost::multiprecision::detail::unsigned_abs(b));
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
{
   return *a.limbs() == b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
   if (b < 0)
   {
      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
      return *a.limbs() == *t.limbs();
   }
   else
   {
      return *a.limbs() == static_cast<ui_type>(b);
   }
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
{
   if (a.sign() != b.sign())
      return a.sign();
   return a.sign() ? *a.limbs() > *b.limbs() : *a.limbs() < *b.limbs();
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
{
   return *a.limbs() < *b.limbs();
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
{
   if (a.sign())
      return true;
   return *a.limbs() < b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
{
   if (a.sign() != (b < 0))
      return a.sign();
   return a.sign() ? (*a.limbs() > boost::multiprecision::detail::unsigned_abs(b)) : (*a.limbs() < boost::multiprecision::detail::unsigned_abs(b));
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
{
   return *a.limbs() < b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
   if (b < 0)
   {
      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
      return *a.limbs() < *t.limbs();
   }
   else
   {
      return *a.limbs() < static_cast<ui_type>(b);
   }
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& b) noexcept
{
   if (a.sign() != b.sign())
      return !a.sign();
   return a.sign() ? *a.limbs() < *b.limbs() : *a.limbs() > *b.limbs();
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
{
   return *a.limbs() > *b.limbs();
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
{
   if (a.sign())
      return false;
   return *a.limbs() > b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
{
   if (a.sign() != (b < 0))
      return !a.sign();
   return a.sign() ? (*a.limbs() < boost::multiprecision::detail::unsigned_abs(b)) : (*a.limbs() > boost::multiprecision::detail::unsigned_abs(b));
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
{
   return *a.limbs() > b;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
    bool>::type
eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
   if (b < 0)
   {
      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
      return *a.limbs() > *t.limbs();
   }
   else
   {
      return *a.limbs() > static_cast<ui_type>(b);
   }
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/cpp_int_config.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock.
//  Copyright 2021 Matt Borland.
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_CONFIG_HPP
#define BOOST_MP_CPP_INT_CONFIG_HPP

#include <cstdint>
#include <type_traits>
#include <limits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost {
namespace multiprecision {

namespace detail {

//
// These traits calculate the largest type in the list
// [unsigned] long long, long, int, which has the specified number
// of bits.  Note that int_t and uint_t find the first
// member of the above list, not the last.  We want the last in the
// list to ensure that mixed arithmetic operations are as efficient
// as possible.
//

template <std::size_t Bits>
struct int_t
{
   using exact = typename std::conditional<Bits <= sizeof(signed char) * CHAR_BIT, signed char,
                 typename std::conditional<Bits <= sizeof(short) * CHAR_BIT, short,
                 typename std::conditional<Bits <= sizeof(int) * CHAR_BIT, int,
                 typename std::conditional<Bits <= sizeof(long) * CHAR_BIT, long,
                 typename std::conditional<Bits <= sizeof(long long) * CHAR_BIT, long long, void
                 >::type>::type>::type>::type>::type;

   using least = typename std::conditional<Bits-1 <= std::numeric_limits<signed char>::digits, signed char,
                 typename std::conditional<Bits-1 <= std::numeric_limits<short>::digits, short,
                 typename std::conditional<Bits-1 <= std::numeric_limits<int>::digits, int,
                 typename std::conditional<Bits-1 <= std::numeric_limits<long>::digits, long,
                 typename std::conditional<Bits-1 <= std::numeric_limits<long long>::digits, long long, void
                 >::type>::type>::type>::type>::type;
   
   static_assert(!std::is_same<void, exact>::value && !std::is_same<void, least>::value, "Number of bits does not match any standard data type. \
      Please file an issue at https://github.com/boostorg/multiprecision/ referencing this error from cpp_int_config.hpp");
};

template <std::size_t Bits>
struct uint_t
{
   using exact = typename std::conditional<Bits <= sizeof(unsigned char) * CHAR_BIT, unsigned char,
                 typename std::conditional<Bits <= sizeof(unsigned short) * CHAR_BIT, unsigned short,
                 typename std::conditional<Bits <= sizeof(unsigned int) * CHAR_BIT, unsigned int,
                 typename std::conditional<Bits <= sizeof(unsigned long) * CHAR_BIT, unsigned long,
                 typename std::conditional<Bits <= sizeof(unsigned long long) * CHAR_BIT, unsigned long long, void
                 >::type>::type>::type>::type>::type;

   using least = typename std::conditional<Bits <= std::numeric_limits<unsigned char>::digits, unsigned char,
                 typename std::conditional<Bits <= std::numeric_limits<unsigned short>::digits, unsigned short,
                 typename std::conditional<Bits <= std::numeric_limits<unsigned int>::digits, unsigned int,
                 typename std::conditional<Bits <= std::numeric_limits<unsigned long>::digits, unsigned long,
                 typename std::conditional<Bits <= std::numeric_limits<unsigned long long>::digits, unsigned long long, void
                 >::type>::type>::type>::type>::type;

   static_assert(!std::is_same<void, exact>::value && !std::is_same<void, least>::value, "Number of bits does not match any standard data type. \
      Please file an issue at https://github.com/boostorg/multiprecision/ referencing this error from cpp_int_config.hpp");
};

template <std::size_t N>
struct largest_signed_type
{
   using type = typename std::conditional<
       1 + std::numeric_limits<long long>::digits == N,
       long long,
       typename std::conditional<
           1 + std::numeric_limits<long>::digits == N,
           long,
           typename std::conditional<
               1 + std::numeric_limits<int>::digits == N,
               int,
               typename int_t<N>::exact>::type>::type>::type;
};

template <std::size_t N>
struct largest_unsigned_type
{
   using type = typename std::conditional<
       std::numeric_limits<unsigned long long>::digits == N,
       unsigned long long,
       typename std::conditional<
           std::numeric_limits<unsigned long>::digits == N,
           unsigned long,
           typename std::conditional<
               std::numeric_limits<unsigned int>::digits == N,
               unsigned int,
               typename uint_t<N>::exact>::type>::type>::type;
};

} // namespace detail

#if defined(BOOST_HAS_INT128)

using limb_type = detail::largest_unsigned_type<64>::type;
using signed_limb_type = detail::largest_signed_type<64>::type;
using double_limb_type = boost::multiprecision::uint128_type;
using signed_double_limb_type = boost::multiprecision::int128_type;
constexpr limb_type                       max_block_10        = 1000000000000000000uLL;
constexpr limb_type                       digits_per_block_10 = 18;

inline BOOST_MP_CXX14_CONSTEXPR limb_type block_multiplier(std::size_t count)
{
   constexpr limb_type values[digits_per_block_10] = {10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000, 100000000000000000, 1000000000000000000};
   BOOST_MP_ASSERT(count < digits_per_block_10);
   return values[count];
}

// Can't do formatted IO on an __int128
#define BOOST_MP_NO_DOUBLE_LIMB_TYPE_IO

#else

using limb_type = detail::largest_unsigned_type<32>::type;
using signed_limb_type = detail::largest_signed_type<32>::type  ;
using double_limb_type = detail::largest_unsigned_type<64>::type;
using signed_double_limb_type = detail::largest_signed_type<64>::type  ;
constexpr limb_type                       max_block_10        = 1000000000;
constexpr limb_type                       digits_per_block_10 = 9;

inline limb_type block_multiplier(std::size_t count)
{
   constexpr limb_type values[digits_per_block_10] = {10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
   BOOST_MP_ASSERT(count < digits_per_block_10);
   return values[count];
}

#endif

constexpr std::size_t bits_per_limb = sizeof(limb_type) * CHAR_BIT;

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void minmax(const T& a, const T& b, T& aa, T& bb)
{
   if (a < b)
   {
      aa = a;
      bb = b;
   }
   else
   {
      aa = b;
      bb = a;
   }
}

enum cpp_integer_type
{
   signed_magnitude   = 1,
   unsigned_magnitude = 0,
   signed_packed      = 3,
   unsigned_packed    = 2
};

enum cpp_int_check_type
{
   checked   = 1,
   unchecked = 0
};

} // namespace multiprecision
} // namespace boost

#endif // BOOST_MP_CPP_INT_CONFIG_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/divide.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_DIVIDE_HPP
#define BOOST_MP_CPP_INT_DIVIDE_HPP

#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision { namespace backends {

template <class CppInt1, class CppInt2, class CppInt3>
BOOST_MP_CXX14_CONSTEXPR void divide_unsigned_helper(
    CppInt1*       result,
    const CppInt2& x,
    const CppInt3& y,
    CppInt1&       r)
{
   if (((void*)result == (void*)&x) || ((void*)&r == (void*)&x))
   {
      CppInt2 t(x);
      divide_unsigned_helper(result, t, y, r);
      return;
   }
   if (((void*)result == (void*)&y) || ((void*)&r == (void*)&y))
   {
      CppInt3 t(y);
      divide_unsigned_helper(result, x, t, r);
      return;
   }

   /*
    Very simple, fairly braindead long division.
    Start by setting the remainder equal to x, and the
    result equal to 0.  Then in each loop we calculate our
    "best guess" for how many times y divides into r,
    add our guess to the result, and subtract guess*y
    from the remainder r.  One wrinkle is that the remainder
    may go negative, in which case we subtract the current guess
    from the result rather than adding.  The value of the guess
    is determined by dividing the most-significant-limb of the
    current remainder by the most-significant-limb of y.

    Note that there are more efficient algorithms than this
    available, in particular see Knuth Vol 2.  However for small
    numbers of limbs this generally outperforms the alternatives
    and avoids the normalisation step which would require extra storage.
    */

   using default_ops::eval_subtract;

   if (result == &r)
   {
      CppInt1 rem;
      divide_unsigned_helper(result, x, y, rem);
      r = rem;
      return;
   }

   //
   // Find the most significant words of numerator and denominator.
   //
   std::size_t y_order = y.size() - 1;

   if (y_order == 0)
   {
      //
      // Only a single non-zero limb in the denominator, in this case
      // we can use a specialized divide-by-single-limb routine which is
      // much faster.  This also handles division by zero:
      //
      divide_unsigned_helper(result, x, y.limbs()[y_order], r);
      return;
   }

   typename CppInt2::const_limb_pointer px = x.limbs();
   typename CppInt3::const_limb_pointer py = y.limbs();

   std::size_t r_order = x.size() - 1;
   if ((r_order == 0) && (*px == 0))
   {
      // x is zero, so is the result:
      r = x;
      if (result)
         *result = x;
      return;
   }

   r = x;
   r.sign(false);
   if (result)
      *result = static_cast<limb_type>(0u);
   //
   // Check if the remainder is already less than the divisor, if so
   // we already have the result.  Note we try and avoid a full compare
   // if we can:
   //
   if (r_order <= y_order)
   {
      if ((r_order < y_order) || (r.compare_unsigned(y) < 0))
      {
         return;
      }
   }

   CppInt1 t;
   bool    r_neg = false;

   //
   // See if we can short-circuit long division, and use basic arithmetic instead:
   //
   if (r_order == 0)
   {
      if (result)
      {
         *result = px[0] / py[0];
      }
      r = px[0] % py[0];
      return;
   }
   else if (r_order == 1)
   {
      double_limb_type a = (static_cast<double_limb_type>(px[1]) << CppInt1::limb_bits) | px[0];
      double_limb_type b = y_order ? (static_cast<double_limb_type>(py[1]) << CppInt1::limb_bits) | py[0]
                                   : py[0];
      if (result)
      {
         *result = a / b;
      }
      r = a % b;
      return;
   }
   //
   // prepare result:
   //
   if (result)
      result->resize(1 + r_order - y_order, 1 + r_order - y_order);
   typename CppInt1::const_limb_pointer prem = r.limbs();
   // This is initialised just to keep the compiler from emitting useless warnings later on:
   typename CppInt1::limb_pointer pr = typename CppInt1::limb_pointer();
   if (result)
   {
      pr = result->limbs();
      for (std::size_t i = 1; i < 1 + r_order - y_order; ++i)
         pr[i] = 0;
   }
   bool first_pass = true;

   do
   {
      //
      // Calculate our best guess for how many times y divides into r:
      //
      limb_type guess = 1;
      if ((prem[r_order] <= py[y_order]) && (r_order > 0))
      {
         double_limb_type a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
         double_limb_type b = py[y_order];
         double_limb_type v = a / b;
         if (v <= CppInt1::max_limb_value)
         {
            guess = static_cast<limb_type>(v);
            --r_order;
         }
      }
      else if (r_order == 0)
      {
         guess = prem[0] / py[y_order];
      }
      else
      {
         double_limb_type a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
         double_limb_type b = (y_order > 0) ? (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits) | py[y_order - 1] : (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits);
         BOOST_MP_ASSERT(b);
         double_limb_type v = a / b;
         guess              = static_cast<limb_type>(v);
      }
      BOOST_MP_ASSERT(guess); // If the guess ever gets to zero we go on forever....
      //
      // Update result:
      //
      std::size_t shift = r_order - y_order;
      if (result)
      {
         if (r_neg)
         {
            if (pr[shift] > guess)
               pr[shift] -= guess;
            else
            {
               t.resize(shift + 1, shift + 1);
               t.limbs()[shift] = guess;
               for (std::size_t i = 0; i < shift; ++i)
                  t.limbs()[i] = 0;
               eval_subtract(*result, t);
            }
         }
         else if (CppInt1::max_limb_value - pr[shift] > guess)
            pr[shift] += guess;
         else
         {
            t.resize(shift + 1, shift + 1);
            t.limbs()[shift] = guess;
            for (std::size_t i = 0; i < shift; ++i)
               t.limbs()[i] = 0;
            eval_add(*result, t);
         }
      }
      //
      // Calculate guess * y, we use a fused mutiply-shift O(N) for this
      // rather than a full O(N^2) multiply:
      //
      double_limb_type carry = 0;
      t.resize(y.size() + shift + 1, y.size() + shift);
      bool                           truncated_t = (t.size() != y.size() + shift + 1);
      typename CppInt1::limb_pointer pt          = t.limbs();
      for (std::size_t i = 0; i < shift; ++i)
         pt[i] = 0;
      for (std::size_t i = 0; i < y.size(); ++i)
      {
         carry += static_cast<double_limb_type>(py[i]) * static_cast<double_limb_type>(guess);
#ifdef __MSVC_RUNTIME_CHECKS
         pt[i + shift] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
         pt[i + shift]    = static_cast<limb_type>(carry);
#endif
         carry >>= CppInt1::limb_bits;
      }
      if (carry && !truncated_t)
      {
#ifdef __MSVC_RUNTIME_CHECKS
         pt[t.size() - 1] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
         pt[t.size() - 1] = static_cast<limb_type>(carry);
#endif
      }
      else if (!truncated_t)
      {
         t.resize(t.size() - 1, t.size() - 1);
      }
      //
      // Update r in a way that won't actually produce a negative result
      // in case the argument types are unsigned:
      //
      if (truncated_t && carry)
      {
         // We need to calculate 2^n + t - r
         // where n is the number of bits in this type.
         // Simplest way is to get 2^n - r by complementing
         // r, then add t to it.  Note that we can't call eval_complement
         // in case this is a signed checked type:
         for (std::size_t i = 0; i <= r_order; ++i)
            r.limbs()[i] = ~prem[i];
         r.normalize();
         eval_increment(r);
         eval_add(r, t);
         r_neg = !r_neg;
      }
      else if (r.compare(t) > 0)
      {
         eval_subtract(r, t);
      }
      else
      {
         r.swap(t);
         eval_subtract(r, t);
         prem  = r.limbs();
         r_neg = !r_neg;
      }
      //
      // First time through we need to strip any leading zero, otherwise
      // the termination condition goes belly-up:
      //
      if (result && first_pass)
      {
         first_pass = false;
         while (pr[result->size() - 1] == 0)
            result->resize(result->size() - 1, result->size() - 1);
      }
      //
      // Update r_order:
      //
      r_order = r.size() - 1;
      if (r_order < y_order)
         break;
   }
   // Termination condition is really just a check that r > y, but with a common
   // short-circuit case handled first:
   while ((r_order > y_order) || (r.compare_unsigned(y) >= 0));

   //
   // We now just have to normalise the result:
   //
   if (r_neg && eval_get_sign(r))
   {
      // We have one too many in the result:
      if (result)
         eval_decrement(*result);
      if (y.sign())
      {
         r.negate();
         eval_subtract(r, y);
      }
      else
         eval_subtract(r, y, r);
   }

   BOOST_MP_ASSERT(r.compare_unsigned(y) < 0); // remainder must be less than the divisor or our code has failed
}

template <class CppInt1, class CppInt2>
BOOST_MP_CXX14_CONSTEXPR void divide_unsigned_helper(
    CppInt1*       result,
    const CppInt2& x,
    limb_type      y,
    CppInt1&       r)
{
   if (((void*)result == (void*)&x) || ((void*)&r == (void*)&x))
   {
      CppInt2 t(x);
      divide_unsigned_helper(result, t, y, r);
      return;
   }

   if (result == &r)
   {
      CppInt1 rem;
      divide_unsigned_helper(result, x, y, rem);
      r = rem;
      return;
   }

   // As above, but simplified for integer divisor:

   using default_ops::eval_subtract;

   if (y == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer Division by zero."));
   }
   //
   // Find the most significant word of numerator.
   //
   std::size_t r_order = x.size() - 1;

   //
   // Set remainder and result to their initial values:
   //
   r = x;
   r.sign(false);
   typename CppInt1::limb_pointer pr = r.limbs();

   //
   // check for x < y, try to do this without actually having to
   // do a full comparison:
   //
   if ((r_order == 0) && (*pr < y))
   {
      if (result)
         *result = static_cast<limb_type>(0u);
      return;
   }

   //
   // See if we can short-circuit long division, and use basic arithmetic instead:
   //
   if (r_order == 0)
   {
      if (result)
      {
         *result = *pr / y;
         result->sign(x.sign());
      }
      *pr %= y;
      r.sign(x.sign());
      return;
   }
   else if (r_order == 1)
   {
      double_limb_type a = (static_cast<double_limb_type>(pr[r_order]) << CppInt1::limb_bits) | pr[0];
      if (result)
      {
         *result = a / y;
         result->sign(x.sign());
      }
      r = a % y;
      r.sign(x.sign());
      return;
   }

   // This is initialised just to keep the compiler from emitting useless warnings later on:
   typename CppInt1::limb_pointer pres = typename CppInt1::limb_pointer();
   if (result)
   {
      result->resize(r_order + 1, r_order + 1);
      pres = result->limbs();
      if (result->size() > r_order)
         pres[r_order] = 0; // just in case we don't set the most significant limb below.
   }

   do
   {
      //
      // Calculate our best guess for how many times y divides into r:
      //
      if ((pr[r_order] < y) && r_order)
      {
         double_limb_type a = (static_cast<double_limb_type>(pr[r_order]) << CppInt1::limb_bits) | pr[r_order - 1];
         double_limb_type b = a % y;
         r.resize(r.size() - 1, r.size() - 1);
         --r_order;
         pr[r_order] = static_cast<limb_type>(b);
         if (result)
            pres[r_order] = static_cast<limb_type>(a / y);
         if (r_order && pr[r_order] == 0)
         {
            --r_order; // No remainder, division was exact.
            r.resize(r.size() - 1, r.size() - 1);
            if (result)
               pres[r_order] = static_cast<limb_type>(0u);
         }
      }
      else
      {
         if (result)
            pres[r_order] = pr[r_order] / y;
         pr[r_order] %= y;
         if (r_order && pr[r_order] == 0)
         {
            --r_order; // No remainder, division was exact.
            r.resize(r.size() - 1, r.size() - 1);
            if (result)
               pres[r_order] = static_cast<limb_type>(0u);
         }
      }
   }
   // Termination condition is really just a check that r >= y, but with two common
   // short-circuit cases handled first:
   while (r_order || (pr[r_order] >= y));

   if (result)
   {
      result->normalize();
      result->sign(x.sign());
   }
   r.normalize();
   r.sign(x.sign());

   BOOST_MP_ASSERT(r.compare(y) < 0); // remainder must be less than the divisor or our code has failed
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
{
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
   bool                                                                 s = a.sign() != b.sign();
   divide_unsigned_helper(&result, a, b, r);
   result.sign(s);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    limb_type&                                                                  b)
{
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
   bool                                                                 s = a.sign();
   divide_unsigned_helper(&result, a, b, r);
   result.sign(s);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    signed_limb_type&                                                           b)
{
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> r;
   bool                                                                 s = a.sign() != (b < 0);
   divide_unsigned_helper(&result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(b)), r);
   result.sign(s);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b)
{
   // There is no in place divide:
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
   eval_divide(result, a, b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    limb_type                                                             b)
{
   // There is no in place divide:
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
   eval_divide(result, a, b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    signed_limb_type                                                      b)
{
   // There is no in place divide:
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
   eval_divide(result, a, b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
{
   bool s = a.sign();
   if (b.size() == 1)
      eval_modulus(result, a, *b.limbs());
   else
   {
      using cpp_int_backend1_type = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>;

      divide_unsigned_helper(static_cast<cpp_int_backend1_type*>(nullptr), a, b, result);
   }
   result.sign(s);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const limb_type                                                             mod)
{
   const std::ptrdiff_t n = static_cast<std::ptrdiff_t>(a.size());
   const double_limb_type two_n_mod = static_cast<limb_type>(1u) + (~static_cast<limb_type>(0u) - mod) % mod;
   limb_type              res       = a.limbs()[n - 1] % mod;

   for (std::ptrdiff_t i = n - 2; i >= 0; --i)
      res = static_cast<limb_type>(static_cast<double_limb_type>(static_cast<double_limb_type>(res * two_n_mod) + a.limbs()[i]) % mod);
   //
   // We must not modify result until here in case
   // result and a are the same object:
   //
   result.resize(1, 1);
   *result.limbs() = res;
   result.sign(a.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_modulus(
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
   const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
   signed_limb_type                                                            b)
{
   const limb_type t = b < 0 ? static_cast<limb_type>(-b) : static_cast<limb_type>(b);
   eval_modulus(result, a, t);
   result.sign(a.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b)
{
   // There is no in place divide:
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> a(result);
   eval_modulus(result, a, b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    limb_type                                                             b)
{
   // Single limb modulus is in place:
   eval_modulus(result, result, b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    signed_limb_type                                                      b)
{
   // Single limb modulus is in place:
   eval_modulus(result, result, b);
}

//
// Over again for trivial cpp_int's:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
{
   if (!*o.limbs())
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   *result.limbs() /= *o.limbs();
   result.sign(result.sign() != o.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_divide(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
{
   if (!*o.limbs())
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   *result.limbs() /= *o.limbs();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_modulus(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o)
{
   if (!*o.limbs())
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   *result.limbs() %= *o.limbs();
   result.sign(result.sign());
}

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/import_export.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_IMPORT_EXPORT_HPP
#define BOOST_MP_CPP_INT_IMPORT_EXPORT_HPP

#include <climits>
#include <cstring>
#include <boost/multiprecision/detail/endian.hpp>

namespace boost {
namespace multiprecision {

namespace detail {

template <class Backend, class Unsigned>
void assign_bits(Backend& val, Unsigned bits, std::size_t bit_location, std::size_t chunk_bits, const std::integral_constant<bool, false>& tag)
{
   std::size_t limb  = bit_location / (sizeof(limb_type) * CHAR_BIT);
   std::size_t shift = bit_location % (sizeof(limb_type) * CHAR_BIT);

   limb_type mask = chunk_bits >= sizeof(limb_type) * CHAR_BIT ? ~static_cast<limb_type>(0u) : (static_cast<limb_type>(1u) << chunk_bits) - 1;

   limb_type value = static_cast<limb_type>(bits & mask) << shift;
   if (value)
   {
      if (val.size() == limb)
      {
         val.resize(limb + 1, limb + 1);
         if (val.size() > limb)
            val.limbs()[limb] = value;
      }
      else if (val.size() > limb)
         val.limbs()[limb] |= value;
   }
   if (chunk_bits > sizeof(limb_type) * CHAR_BIT - shift)
   {
      shift = sizeof(limb_type) * CHAR_BIT - shift;
      chunk_bits -= shift;
      bit_location += shift;
      bits >>= shift;
      if (bits)
         assign_bits(val, bits, bit_location, chunk_bits, tag);
   }
}
template <class Backend, class Unsigned>
void assign_bits(Backend& val, Unsigned bits, std::size_t bit_location, std::size_t chunk_bits, const std::integral_constant<bool, true>&)
{
   using local_limb_type = typename Backend::local_limb_type;
   //
   // Check for possible overflow, this may trigger an exception, or have no effect
   // depending on whether this is a checked integer or not:
   //
   if ((bit_location >= sizeof(local_limb_type) * CHAR_BIT) && bits)
      val.resize(2, 2);
   else
   {
      local_limb_type mask  = chunk_bits >= sizeof(local_limb_type) * CHAR_BIT ? ~static_cast<local_limb_type>(0u) : (static_cast<local_limb_type>(1u) << chunk_bits) - 1;
      local_limb_type value = (static_cast<local_limb_type>(bits) & mask) << bit_location;
      *val.limbs() |= value;
      //
      // Check for overflow bits:
      //
      bit_location = sizeof(local_limb_type) * CHAR_BIT - bit_location;
      if ((bit_location < sizeof(bits) * CHAR_BIT) && (bits >>= bit_location))
         val.resize(2, 2); // May throw!
   }
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
inline void resize_to_bit_size(cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& newval, std::size_t bits, const std::integral_constant<bool, false>&)
{
   std::size_t limb_count = static_cast<unsigned>(bits / (sizeof(limb_type) * CHAR_BIT));
   if (bits % (sizeof(limb_type) * CHAR_BIT))
      ++limb_count;
   constexpr std::size_t max_limbs = MaxBits ? MaxBits / (CHAR_BIT * sizeof(limb_type)) + ((MaxBits % (CHAR_BIT * sizeof(limb_type))) ? 1 : 0) : (std::numeric_limits<unsigned>::max)();
   if (limb_count > max_limbs)
      limb_count = max_limbs;
   newval.resize(limb_count, limb_count);
   std::memset(newval.limbs(), 0, newval.size() * sizeof(limb_type));
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
inline void resize_to_bit_size(cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& newval, unsigned, const std::integral_constant<bool, true>&)
{
   *newval.limbs() = 0;
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class Iterator>
number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
import_bits_generic(
    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, Iterator i, Iterator j, std::size_t chunk_size = 0, bool msv_first = true)
{
   typename number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>::backend_type newval;

   using value_type = typename std::iterator_traits<Iterator>::value_type                                  ;
   using unsigned_value_type = typename boost::multiprecision::detail::make_unsigned<value_type>::type                                        ;
   using difference_type = typename std::iterator_traits<Iterator>::difference_type                             ;
   using size_type = typename boost::multiprecision::detail::make_unsigned<difference_type>::type                                   ;
   using tag_type = typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::trivial_tag;

   if (!chunk_size)
      chunk_size = std::numeric_limits<value_type>::digits;

   size_type limbs = std::distance(i, j);
   size_type bits  = limbs * chunk_size;

   detail::resize_to_bit_size(newval, static_cast<unsigned>(bits), tag_type());

   difference_type bit_location        = msv_first ? bits - chunk_size : 0;
   difference_type bit_location_change = msv_first ? -static_cast<difference_type>(chunk_size) : chunk_size;

   while (i != j)
   {
      detail::assign_bits(newval, static_cast<unsigned_value_type>(*i), static_cast<std::size_t>(bit_location), chunk_size, tag_type());
      ++i;
      bit_location += bit_location_change;
   }

   newval.normalize();

   val.backend().swap(newval);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
inline typename std::enable_if< !boost::multiprecision::backends::is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value, number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&>::type
import_bits_fast(
    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0)
{
   std::size_t byte_len = (j - i) * (chunk_size ? chunk_size / CHAR_BIT : sizeof(*i));
   std::size_t limb_len = byte_len / sizeof(limb_type);
   if (byte_len % sizeof(limb_type))
      ++limb_len;
   cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& result = val.backend();
   result.resize(static_cast<unsigned>(limb_len), static_cast<unsigned>(limb_len)); // checked types may throw here if they're not large enough to hold the data!
   result.limbs()[result.size() - 1] = 0u;
   std::memcpy(result.limbs(), i, (std::min)(byte_len, result.size() * sizeof(limb_type)));
   result.normalize(); // In case data has leading zeros.
   return val;
}
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
inline typename std::enable_if<boost::multiprecision::backends::is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value, number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&>::type
import_bits_fast(
    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0)
{
   cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& result   = val.backend();
   std::size_t                                                      byte_len = (j - i) * (chunk_size ? chunk_size / CHAR_BIT : sizeof(*i));
   std::size_t                                                      limb_len = byte_len / sizeof(result.limbs()[0]);
   if (byte_len % sizeof(result.limbs()[0]))
      ++limb_len;
   result.limbs()[0] = 0u;
   result.resize(static_cast<unsigned>(limb_len), static_cast<unsigned>(limb_len)); // checked types may throw here if they're not large enough to hold the data!
   std::memcpy(result.limbs(), i, (std::min)(byte_len, result.size() * sizeof(result.limbs()[0])));
   result.normalize(); // In case data has leading zeros.
   return val;
}
} // namespace detail

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class Iterator>
inline number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
import_bits(
    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, Iterator i, Iterator j, std::size_t chunk_size = 0, bool msv_first = true)
{
   return detail::import_bits_generic(val, i, j, chunk_size, msv_first);
}

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
inline number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
import_bits(
    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0, bool msv_first = true)
{
#if BOOST_MP_ENDIAN_LITTLE_BYTE
   if (((chunk_size % CHAR_BIT) == 0) && !msv_first && (sizeof(*i) * CHAR_BIT == chunk_size))
      return detail::import_bits_fast(val, i, j, chunk_size);
#endif
   return detail::import_bits_generic(val, i, j, chunk_size, msv_first);
}

namespace detail {

template <class Backend>
std::uintmax_t extract_bits(const Backend& val, std::size_t location, std::size_t count, const std::integral_constant<bool, false>& tag)
{
   std::size_t         limb   = location / (sizeof(limb_type) * CHAR_BIT);
   std::size_t         shift  = location % (sizeof(limb_type) * CHAR_BIT);
   std::uintmax_t result = 0;
   std::uintmax_t mask   = count == std::numeric_limits<std::uintmax_t>::digits ? ~static_cast<std::uintmax_t>(0) : (static_cast<std::uintmax_t>(1u) << count) - 1;
   if (count > (sizeof(limb_type) * CHAR_BIT - shift))
   {
      result = extract_bits(val, location + sizeof(limb_type) * CHAR_BIT - shift, count - sizeof(limb_type) * CHAR_BIT + shift, tag);
      result <<= sizeof(limb_type) * CHAR_BIT - shift;
   }
   if (limb < val.size())
      result |= (val.limbs()[limb] >> shift) & mask;
   return result;
}

template <class Backend>
inline std::uintmax_t extract_bits(const Backend& val, std::size_t location, std::size_t count, const std::integral_constant<bool, true>&)
{
   typename Backend::local_limb_type result = *val.limbs();
   typename Backend::local_limb_type mask   = count >= std::numeric_limits<typename Backend::local_limb_type>::digits ? ~static_cast<typename Backend::local_limb_type>(0) : (static_cast<typename Backend::local_limb_type>(1u) << count) - 1;
   return (result >> location) & mask;
}

} // namespace detail

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class OutputIterator>
OutputIterator export_bits(
    const number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, OutputIterator out, std::size_t chunk_size, bool msv_first = true)
{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4244)
#endif
   using tag_type = typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::trivial_tag;
   if (!val)
   {
      *out = 0;
      ++out;
      return out;
   }
   std::size_t bitcount = boost::multiprecision::backends::eval_msb_imp(val.backend()) + 1;

         std::ptrdiff_t bit_location = msv_first ? static_cast<std::ptrdiff_t>(bitcount - chunk_size) : 0;
   const std::ptrdiff_t bit_step     = msv_first ? static_cast<std::ptrdiff_t>(-static_cast<std::ptrdiff_t>(chunk_size)) : static_cast<std::ptrdiff_t>(chunk_size);
   while (bit_location % bit_step)
      ++bit_location;

   do
   {
      *out = detail::extract_bits(val.backend(), bit_location, chunk_size, tag_type());
      ++out;
      bit_location += bit_step;
   } while ((bit_location >= 0) && (bit_location < static_cast<int>(bitcount)));

   return out;
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}

}
} // namespace boost::multiprecision

#endif // BOOST_MP_CPP_INT_IMPORT_EXPORT_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/intel_intrinsics.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 Madhur Chauhan.
//  Copyright 2020 John Maddock. 
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_INTEL_INTRINSICS_HPP
#define BOOST_MP_INTEL_INTRINSICS_HPP
//
// Select which actual implementation header to use:
//
#ifdef __has_include
#if __has_include(<immintrin.h>)
#define BOOST_MP_HAS_IMMINTRIN_H
#endif
#endif
//
// If this is GCC/clang, then check that the actual intrinsic exists:
//
#if defined(__has_builtin) && defined(__GNUC__)
#if !__has_builtin(__builtin_ia32_addcarryx_u64) && defined(BOOST_MP_HAS_IMMINTRIN_H) \
   && !(defined(BOOST_GCC) && (__GNUC__ >= 9) \
      && (defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64)\
          || defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_AMD64) \
          || defined(_M_X64) || defined(__amd64__) || defined(_M_X64)))
#undef BOOST_MP_HAS_IMMINTRIN_H
#endif
#elif defined(BOOST_MP_HAS_IMMINTRIN_H) && defined(__GNUC__) && !(defined(BOOST_GCC) && (__GNUC__ >= 9))
#undef BOOST_MP_HAS_IMMINTRIN_H
#endif

#if defined(__clang_major__) && (__clang_major__ < 9)
// We appear to crash the compiler if we try to use these intrinsics?
#undef BOOST_MP_HAS_IMMINTRIN_H
#endif

#if defined(_WIN32) && (defined(_M_ARM64) || defined(_M_ARM))
//
// When targeting platforms such as ARM, msvc (and also clang when emulating msvc) still has the
// Intel headers in its include path even though they're not usable.
// See https://github.com/boostorg/multiprecision/issues/321
// Also https://github.com/boostorg/multiprecision/issues/475
//
#undef BOOST_MP_HAS_IMMINTRIN_H
#endif

#if defined(__APPLE_CC__) && defined(__clang_major__) && (__clang_major__ < 11) && defined(BOOST_MP_HAS_IMMINTRIN_H)
// Apple clang has it's own version numbers.
#undef BOOST_MP_HAS_IMMINTRIN_H
#endif


//
// If the compiler supports the intrinsics used by GCC internally
// inside <immintrin.h> then we'll use them directly.
// This is a bit of defensive programming, mostly for a modern clang
// sitting on top of an older GCC header install.
//
#if defined(__has_builtin) && !defined(BOOST_INTEL)

# if __has_builtin(__builtin_ia32_addcarryx_u64)
#  define BOOST_MP_ADDC __builtin_ia32_addcarryx_u
# endif

# if __has_builtin(__builtin_ia32_subborrow_u64)
#  define BOOST_MP_SUBB __builtin_ia32_subborrow_u
# elif __has_builtin(__builtin_ia32_sbb_u64)
#  define BOOST_MP_SUBB __builtin_ia32_sbb_u
# endif

#endif

#ifndef BOOST_MP_ADDC
#define BOOST_MP_ADDC _addcarry_u
#endif
#ifndef BOOST_MP_SUBB
#define BOOST_MP_SUBB _subborrow_u
#endif

#ifdef BOOST_MP_HAS_IMMINTRIN_H

#ifdef BOOST_MSVC
//
// This is a subset of the full <immintrin.h> :
//
#include <intrin.h>
#else
#include <immintrin.h>
#endif

#if defined(BOOST_HAS_INT128)

namespace boost { namespace multiprecision { namespace detail {

BOOST_MP_FORCEINLINE unsigned char addcarry_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
{
#ifdef BOOST_INTEL
   using cast_type = unsigned __int64;
#else
   using cast_type = unsigned long long;
#endif
   return BOOST_JOIN(BOOST_MP_ADDC, 64)(carry, a, b, reinterpret_cast<cast_type*>(p_result));
}

BOOST_MP_FORCEINLINE unsigned char subborrow_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
{
#ifdef BOOST_INTEL
   using cast_type = unsigned __int64;
#else
   using cast_type = unsigned long long;
#endif
   return BOOST_JOIN(BOOST_MP_SUBB, 64)(carry, a, b, reinterpret_cast<cast_type*>(p_result));
}

}}} // namespace boost::multiprecision::detail

#else

namespace boost { namespace multiprecision { namespace detail {

BOOST_MP_FORCEINLINE unsigned char addcarry_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
{
   return BOOST_JOIN(BOOST_MP_ADDC, 32)(carry, a, b, reinterpret_cast<unsigned int*>(p_result));
}

BOOST_MP_FORCEINLINE unsigned char subborrow_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
{
   return BOOST_JOIN(BOOST_MP_SUBB, 32)(carry, a, b, reinterpret_cast<unsigned int*>(p_result));
}

}}} // namespace boost::multiprecision::detail

#endif

#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/limits.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_LIMITS_HPP
#define BOOST_MP_CPP_INT_LIMITS_HPP

#include <boost/multiprecision/traits/max_digits10.hpp>

namespace std {

namespace detail {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4307)
#endif

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_CXX14_CONSTEXPR_IF_DETECTION boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&)
{
   // Bounded, signed, and no allocator.
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                               ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MaxBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked>, ExpressionTemplates>;
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   static
#else
   constexpr
#endif
   const result_type                                                                                                                                                                          val = -result_type(~ui_type(0));
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&)
{
   // Bounded, signed, and an allocator (can't be constexpr).
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                               ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MaxBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked>, ExpressionTemplates>;
   static const result_type                                                                                                                                                                          val = -result_type(~ui_type(0));
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_CXX14_CONSTEXPR_IF_DETECTION boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&)
{
   // Bounded, unsigned, no allocator (can be constexpr):
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   static
#else
   constexpr
#endif
   const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&)
{
   // Bounded and std::size_t with allocator (no constexpr):
   static const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates, bool has_allocator>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, has_allocator>&)
{
   // Unbounded and signed, never constexpr because there must be an allocator.
   // There is no minimum value, just return 0:
   static const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates, bool has_allocator>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_min(const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, has_allocator>&)
{
   // Unbound and unsigned, never constexpr because there must be an allocator.
   static const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_CXX14_CONSTEXPR_IF_DETECTION boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&)
{
   // Bounded and signed, no allocator, can be constexpr.
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                               ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MaxBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked>, ExpressionTemplates>;
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   static
#else
   constexpr
#endif
   const result_type                                                                                                                                                                          val = ~ui_type(0);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&)
{
   // Bounded and signed, has an allocator, never constexpr.
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                               ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MaxBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked>, ExpressionTemplates>;
   static const result_type                                                                                                                                                                          val = ~ui_type(0);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_CXX14_CONSTEXPR_IF_DETECTION boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&)
{
   // Bound and unsigned, no allocator so can be constexpr:
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                                          ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, Allocator>, ExpressionTemplates>;
#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
   static
#else
   constexpr
#endif
   const result_type                                                                                                                                                                                     val = ~ui_type(0);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&)
{
   // Bound and unsigned, has an allocator so can never be constexpr:
   using result_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>                                                          ;
   using ui_type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, Allocator>, ExpressionTemplates>;
   static const result_type                                                                                                                                                                                     val = ~ui_type(0);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates, bool has_allocator>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&, const std::integral_constant<bool, has_allocator>&)
{
   // Unbounded and signed.
   // There is no maximum value, just return 0:
   static const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates, bool has_allocator>
inline boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>
get_max(const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&, const std::integral_constant<bool, has_allocator>&)
{
   // Unbound and unsigned:
   static const boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> val(0u);
   return val;
}

} // namespace detail

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >
{
   using backend_type = boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>;
   using number_type = boost::multiprecision::number<backend_type, ExpressionTemplates>                      ;

 public:
   static constexpr bool is_specialized = true;
   //
   // Largest and smallest numbers are bounded only by available memory, set
   // to zero:
   //
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type(min)()
   {
      return detail::get_min<MinBits, MaxBits, SignType, Checked, Allocator, ExpressionTemplates>(boost::multiprecision::backends::is_fixed_precision<backend_type>(), boost::multiprecision::is_signed_number<backend_type>(), std::integral_constant<bool, std::is_void<Allocator>::value>());
   }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type(max)()
   {
      return detail::get_max<MinBits, MaxBits, SignType, Checked, Allocator, ExpressionTemplates>(boost::multiprecision::backends::is_fixed_precision<backend_type>(), boost::multiprecision::is_signed_number<backend_type>(), std::integral_constant<bool, std::is_void<Allocator>::value>());
   }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type          lowest() { return (min)(); }
   static constexpr int  digits       = boost::multiprecision::backends::max_precision<backend_type>::value == SIZE_MAX ? INT_MAX : boost::multiprecision::backends::max_precision<backend_type>::value;
   static constexpr int  digits10     = static_cast<int>(boost::multiprecision::detail::calc_digits10_s<static_cast<std::size_t>(digits)>::value);
   static constexpr int  max_digits10 = static_cast<int>(boost::multiprecision::detail::calc_max_digits10_s<static_cast<std::size_t>(digits)>::value);
   static constexpr bool is_signed    = boost::multiprecision::is_signed_number<backend_type>::value;
   static constexpr bool is_integer   = true;
   static constexpr bool is_exact     = true;
   static constexpr int  radix        = 2;
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type          epsilon() { return 0; }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type          round_error() { return 0; }
   static constexpr int  min_exponent                  = 0;
   static constexpr int  min_exponent10                = 0;
   static constexpr int  max_exponent                  = 0;
   static constexpr int  max_exponent10                = 0;
   static constexpr bool has_infinity                  = false;
   static constexpr bool has_quiet_NaN                 = false;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_absent;
   static constexpr bool               has_denorm_loss = false;
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type                        infinity() { return 0; }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type                        quiet_NaN() { return 0; }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type                        signaling_NaN() { return 0; }
   static BOOST_CXX14_CONSTEXPR_IF_DETECTION number_type                        denorm_min() { return 0; }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = boost::multiprecision::backends::is_fixed_precision<backend_type>::value;
   static constexpr bool               is_modulo       = (boost::multiprecision::backends::is_fixed_precision<backend_type>::value && (Checked == boost::multiprecision::unchecked));
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style round_style      = round_toward_zero;
};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::digits;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::digits10;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::max_digits10;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_signed;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_integer;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_exact;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::radix;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::min_exponent;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::min_exponent10;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::max_exponent;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::max_exponent10;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::has_infinity;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::has_quiet_NaN;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::has_signaling_NaN;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::has_denorm;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::has_denorm_loss;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_iec559;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_bounded;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::is_modulo;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::traps;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::tinyness_before;
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >::round_style;

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/literals.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_LITERALS_HPP
#define BOOST_MP_CPP_INT_LITERALS_HPP

#include <boost/multiprecision/cpp_int/cpp_int_config.hpp>

namespace boost { namespace multiprecision {

namespace literals {
namespace detail {

template <char>
struct hex_value;
template <>
struct hex_value<'0'>
{
   static constexpr limb_type value = 0;
};
template <>
struct hex_value<'1'>
{
   static constexpr limb_type value = 1;
};
template <>
struct hex_value<'2'>
{
   static constexpr limb_type value = 2;
};
template <>
struct hex_value<'3'>
{
   static constexpr limb_type value = 3;
};
template <>
struct hex_value<'4'>
{
   static constexpr limb_type value = 4;
};
template <>
struct hex_value<'5'>
{
   static constexpr limb_type value = 5;
};
template <>
struct hex_value<'6'>
{
   static constexpr limb_type value = 6;
};
template <>
struct hex_value<'7'>
{
   static constexpr limb_type value = 7;
};
template <>
struct hex_value<'8'>
{
   static constexpr limb_type value = 8;
};
template <>
struct hex_value<'9'>
{
   static constexpr limb_type value = 9;
};
template <>
struct hex_value<'a'>
{
   static constexpr limb_type value = 10;
};
template <>
struct hex_value<'b'>
{
   static constexpr limb_type value = 11;
};
template <>
struct hex_value<'c'>
{
   static constexpr limb_type value = 12;
};
template <>
struct hex_value<'d'>
{
   static constexpr limb_type value = 13;
};
template <>
struct hex_value<'e'>
{
   static constexpr limb_type value = 14;
};
template <>
struct hex_value<'f'>
{
   static constexpr limb_type value = 15;
};
template <>
struct hex_value<'A'>
{
   static constexpr limb_type value = 10;
};
template <>
struct hex_value<'B'>
{
   static constexpr limb_type value = 11;
};
template <>
struct hex_value<'C'>
{
   static constexpr limb_type value = 12;
};
template <>
struct hex_value<'D'>
{
   static constexpr limb_type value = 13;
};
template <>
struct hex_value<'E'>
{
   static constexpr limb_type value = 14;
};
template <>
struct hex_value<'F'>
{
   static constexpr limb_type value = 15;
};

template <class Pack, limb_type value>
struct combine_value_to_pack;
template <limb_type first, limb_type... ARGS, limb_type value>
struct combine_value_to_pack<value_pack<first, ARGS...>, value>
{
   using type = value_pack<first | value, ARGS...>;
};

template <char NextChar, char... CHARS>
struct pack_values
{
   static constexpr std::size_t chars_per_limb = sizeof(limb_type) * CHAR_BIT / 4;
   static constexpr std::size_t shift          = ((sizeof...(CHARS)) % chars_per_limb) * 4;
   static constexpr limb_type value_to_add  = shift ? hex_value<NextChar>::value << shift : hex_value<NextChar>::value;

   using recursive_packed_type = typename pack_values<CHARS...>::type                         ;
   using pack_type = typename std::conditional<shift == 0,
                                     typename recursive_packed_type::next_type,
                                     recursive_packed_type>::type;
   using type = typename combine_value_to_pack<pack_type, value_to_add>::type;
};
template <char NextChar>
struct pack_values<NextChar>
{
   static constexpr limb_type value_to_add = hex_value<NextChar>::value;

   using type = value_pack<value_to_add>;
};

template <class T>
struct strip_leading_zeros_from_pack;
template <limb_type... PACK>
struct strip_leading_zeros_from_pack<value_pack<PACK...> >
{
   using type = value_pack<PACK...>;
};
template <limb_type... PACK>
struct strip_leading_zeros_from_pack<value_pack<0u, PACK...> >
{
   using type = typename strip_leading_zeros_from_pack<value_pack<PACK...> >::type;
};

template <limb_type v, class PACK>
struct append_value_to_pack;
template <limb_type v, limb_type... PACK>
struct append_value_to_pack<v, value_pack<PACK...> >
{
   using type = value_pack<PACK..., v>;
};

template <class T>
struct reverse_value_pack;
template <limb_type v, limb_type... VALUES>
struct reverse_value_pack<value_pack<v, VALUES...> >
{
   using lead_values = typename reverse_value_pack<value_pack<VALUES...> >::type;
   using type = typename append_value_to_pack<v, lead_values>::type      ;
};
template <limb_type v>
struct reverse_value_pack<value_pack<v> >
{
   using type = value_pack<v>;
};
template <>
struct reverse_value_pack<value_pack<> >
{
   using type = value_pack<>;
};

template <char l1, char l2, char... STR>
struct make_packed_value_from_str
{
   static_assert(l1 == '0', "Multi-precision integer literals must be in hexadecimal notation.");
   static_assert((l2 == 'X') || (l2 == 'x'), "Multi-precision integer literals must be in hexadecimal notation.");
   using packed_type = typename pack_values<STR...>::type                       ;
   using stripped_type = typename strip_leading_zeros_from_pack<packed_type>::type;
   using type = typename reverse_value_pack<stripped_type>::type         ;
};

template <class Pack, class B>
struct make_backend_from_pack
{
   static constexpr Pack p  = {};
   static constexpr B value = p;
};

template <class Pack, class B>
constexpr B make_backend_from_pack<Pack, B>::value;

template <unsigned Digits>
struct signed_cpp_int_literal_result_type
{
   static constexpr unsigned                                                                               bits = Digits * 4;
   using backend_type = boost::multiprecision::backends::cpp_int_backend<bits, bits, signed_magnitude, unchecked, void>;
   using number_type = number<backend_type, et_off>                                                                   ;
};

template <unsigned Digits>
struct unsigned_cpp_int_literal_result_type
{
   static constexpr unsigned                                                                                 bits = Digits * 4;
   using backend_type = boost::multiprecision::backends::cpp_int_backend<bits, bits, unsigned_magnitude, unchecked, void>;
   using number_type = number<backend_type, et_off>                                                                     ;
};

} // namespace detail

template <char... STR>
constexpr typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<static_cast<unsigned>((sizeof...(STR)) - 2u)>::number_type operator"" _cppi()
{
   using pt = typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type;
   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::signed_cpp_int_literal_result_type<static_cast<unsigned>((sizeof...(STR)) - 2u)>::backend_type>::value;
}

template <char... STR>
constexpr typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<static_cast<unsigned>((sizeof...(STR)) - 2u)>::number_type operator"" _cppui()
{
   using pt = typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type;
   return boost::multiprecision::literals::detail::make_backend_from_pack<pt, typename boost::multiprecision::literals::detail::unsigned_cpp_int_literal_result_type<static_cast<unsigned>((sizeof...(STR)) - 2u)>::backend_type>::value;
}

#define BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(Bits)                                                                                                                                                                                \
   template <char... STR>                                                                                                                                                                                                          \
   constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > operator"" BOOST_JOIN(_cppi, Bits)()    \
   {                                                                                                                                                                                                                               \
      using pt = typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type;                                                                                                                       \
      return boost::multiprecision::literals::detail::make_backend_from_pack<                                                                                                                                                      \
          pt,                                                                                                                                                                                                                      \
          boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >::value;                                                                  \
   }                                                                                                                                                                                                                               \
   template <char... STR>                                                                                                                                                                                                          \
   constexpr boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > operator"" BOOST_JOIN(_cppui, Bits)() \
   {                                                                                                                                                                                                                               \
      using pt = typename boost::multiprecision::literals::detail::make_packed_value_from_str<STR...>::type;                                                                                                                       \
      return boost::multiprecision::literals::detail::make_backend_from_pack<                                                                                                                                                      \
          pt,                                                                                                                                                                                                                      \
          boost::multiprecision::backends::cpp_int_backend<Bits, Bits, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> >::value;                                                                \
   }

BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(128)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(256)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(512)
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(1024)

} // namespace literals

//
// Overload unary minus operator for constexpr use:
//
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
operator-(const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>& a)
{
   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(a.backend(), boost::multiprecision::literals::detail::make_negate_tag());
}
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>
operator-(number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&& a)
{
   return cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>(static_cast<const number<cpp_int_backend<MinBits, MinBits, signed_magnitude, Checked, void>, et_off>&>(a).backend(), boost::multiprecision::literals::detail::make_negate_tag());
}

}} // namespace boost::multiprecision

#endif // BOOST_MP_CPP_INT_CORE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/misc.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-2020 John Maddock.
//  Copyright 2020 Madhur Chauhan.
//  Copyright 2021 Matt Borland.
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at
//   https://www.boost.org/LICENSE_1_0.txt)
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_MISC_HPP
#define BOOST_MP_CPP_INT_MISC_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/multiprecision/cpp_int/cpp_int_config.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/constexpr.hpp>
#include <boost/multiprecision/detail/bitscan.hpp> // lsb etc
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <numeric> // std::gcd
#include <type_traits>
#include <stdexcept>
#include <cmath>

#ifndef BOOST_MP_STANDALONE
#include <boost/integer/common_factor_rt.hpp>
#endif

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/next.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4702)
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
#endif

// Forward decleration of gcd and lcm functions
namespace boost { namespace multiprecision { namespace detail {

template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_gcd(T a, T b) noexcept;

template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_lcm(T a, T b) noexcept;

}}} // namespace boost::multiprecision::detail

namespace boost { namespace multiprecision { namespace backends {

template <class T, bool has_limits = std::numeric_limits<T>::is_specialized>
struct numeric_limits_workaround : public std::numeric_limits<T>
{
};
template <class R>
struct numeric_limits_workaround<R, false>
{
   static constexpr unsigned digits = ~static_cast<R>(0) < 0 ? sizeof(R) * CHAR_BIT - 1 : sizeof(R) * CHAR_BIT;
   static constexpr R (min)(){ return (static_cast<R>(-1) < 0) ? static_cast<R>(1) << digits : 0; }
   static constexpr R (max)() { return (static_cast<R>(-1) < 0) ? ~(static_cast<R>(1) << digits) : ~static_cast<R>(0); }
};

template <class R, class CppInt>
BOOST_MP_CXX14_CONSTEXPR void check_in_range(const CppInt& val, const std::integral_constant<int, checked>&)
{
   using cast_type = typename boost::multiprecision::detail::canonical<R, CppInt>::type;

   if (val.sign())
   {
      BOOST_IF_CONSTEXPR (boost::multiprecision::detail::is_signed<R>::value == false)
         BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to assign a negative value to an unsigned type."));
      if (val.compare(static_cast<cast_type>((numeric_limits_workaround<R>::min)())) < 0)
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Could not convert to the target type - -value is out of range."));
   }
   else
   {
      if (val.compare(static_cast<cast_type>((numeric_limits_workaround<R>::max)())) > 0)
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Could not convert to the target type - -value is out of range."));
   }
}
template <class R, class CppInt>
inline BOOST_MP_CXX14_CONSTEXPR void check_in_range(const CppInt& /*val*/, const std::integral_constant<int, unchecked>&) noexcept {}

inline BOOST_MP_CXX14_CONSTEXPR void check_is_negative(const std::integral_constant<bool, true>&) noexcept {}
inline void                          check_is_negative(const std::integral_constant<bool, false>&)
{
   BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to assign a negative value to an unsigned type."));
}

template <class Integer>
inline BOOST_MP_CXX14_CONSTEXPR Integer negate_integer(Integer i, const std::integral_constant<bool, true>&) noexcept
{
   return -i;
}
template <class Integer>
inline BOOST_MP_CXX14_CONSTEXPR Integer negate_integer(Integer i, const std::integral_constant<bool, false>&) noexcept
{
   return ~(i - 1);
}

template <class R, std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<R>::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, void>::type
eval_convert_to(R* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& backend)
{
   using checked_type = std::integral_constant<int, Checked1>;
   check_in_range<R>(backend, checked_type());

   BOOST_IF_CONSTEXPR(numeric_limits_workaround<R>::digits < cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits)
   {
      if ((backend.sign() && boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value) && (1 + static_cast<boost::multiprecision::limb_type>((std::numeric_limits<R>::max)()) <= backend.limbs()[0]))
      {
         *result = (numeric_limits_workaround<R>::min)();
         return;
      }
      else if (boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value && !backend.sign() && static_cast<boost::multiprecision::limb_type>((std::numeric_limits<R>::max)()) <= backend.limbs()[0])
      {
         *result = (numeric_limits_workaround<R>::max)();
         return;
      }
      else
         *result = static_cast<R>(backend.limbs()[0]);
   }
   else
      *result = static_cast<R>(backend.limbs()[0]);

   BOOST_IF_CONSTEXPR(numeric_limits_workaround<R>::digits > cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits)
   {
     std::size_t shift = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
     std::size_t i     = 1u;

      while ((i < backend.size()) && (shift < static_cast<unsigned>(numeric_limits_workaround<R>::digits - cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits)))
      {
         *result += static_cast<R>(backend.limbs()[i]) << shift;
         shift += cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
         ++i;
      }
      //
      // We have one more limb to extract, but may not need all the bits, so treat this as a special case:
      //
      if (i < backend.size())
      {
         const limb_type mask                 = ((numeric_limits_workaround<R>::digits - shift) == cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits) ? ~static_cast<limb_type>(0) : static_cast<limb_type>(static_cast<limb_type>(1u) << (numeric_limits_workaround<R>::digits - shift)) - 1u;
         const limb_type limb_at_index_masked = static_cast<limb_type>(backend.limbs()[i] & mask);

         *result = static_cast<R>(*result + static_cast<R>(static_cast<R>(limb_at_index_masked) << shift));

         if ((backend.limbs()[i] & static_cast<limb_type>(~mask)) || (i + 1 < backend.size()))
         {
            // Overflow:
            if (backend.sign())
            {
               check_is_negative(boost::multiprecision::detail::is_signed<R>());
               *result = (numeric_limits_workaround<R>::min)();
            }
            else if (boost::multiprecision::detail::is_signed<R>::value)
               *result = (numeric_limits_workaround<R>::max)();
            return;
         }
      }
   }
   else if (backend.size() > 1)
   {
      // Overflow:
      if (backend.sign())
      {
         check_is_negative(boost::multiprecision::detail::is_signed<R>());
         *result = (numeric_limits_workaround<R>::min)();
      }
      else if (boost::multiprecision::detail::is_signed<R>::value)
         *result = (numeric_limits_workaround<R>::max)();
      return;
   }
   if (backend.sign())
   {
      check_is_negative(std::integral_constant<bool, boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value>());
      *result = negate_integer(*result, std::integral_constant<bool, boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value>());
   }
}

template <class R, std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_floating_point<R>::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, void>::type
eval_convert_to(R* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& backend) noexcept(boost::multiprecision::detail::is_arithmetic<R>::value)
{
   BOOST_MP_FLOAT128_USING using std::ldexp;
   if (eval_is_zero(backend))
   {
      *result = 0.0f;
      return;
   }

#ifdef BOOST_HAS_FLOAT128
   std::ptrdiff_t bits_to_keep = static_cast<std::ptrdiff_t>(std::is_same<R, float128_type>::value ? 113 : std::numeric_limits<R>::digits);
#else
   std::ptrdiff_t bits_to_keep = static_cast<std::ptrdiff_t>(std::numeric_limits<R>::digits);
#endif
   std::ptrdiff_t bits = static_cast<std::ptrdiff_t>(eval_msb_imp(backend) + 1);

   if (bits > bits_to_keep)
   {
      // Extract the bits we need, and then manually round the result:
      *result = 0.0f;
      typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::const_limb_pointer p = backend.limbs();
      limb_type mask = ~static_cast<limb_type>(0u);
      std::size_t index = backend.size() - 1;
      std::size_t shift = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits * index;
      while (bits_to_keep > 0)
      {
         if (bits_to_keep < (std::ptrdiff_t)cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits)
         {
            if(index != backend.size() - 1)
            {
               const std::ptrdiff_t left_shift_amount = static_cast<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits) - bits_to_keep);

               mask <<= left_shift_amount;
            }
            else
            {
               std::ptrdiff_t bits_in_first_limb = static_cast<std::ptrdiff_t>(bits % static_cast<std::ptrdiff_t>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits));
               if (bits_in_first_limb == 0)
                  bits_in_first_limb = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
               if (bits_in_first_limb > bits_to_keep)
                  mask <<= bits_in_first_limb - bits_to_keep;
            }
         }
         *result += ldexp(static_cast<R>(p[index] & mask), static_cast<int>(shift));
         shift -= cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;

         const bool bits_has_non_zero_remainder = (bits % static_cast<std::ptrdiff_t>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits) != 0);

         bits_to_keep -= ((index == backend.size() - 1) && bits_has_non_zero_remainder)
            ? bits % static_cast<std::ptrdiff_t>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits)
            :        static_cast<std::ptrdiff_t>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits);
         --index;
      }
      // Perform rounding:
      bits -= 1 + std::numeric_limits<R>::digits;
      if (eval_bit_test(backend, static_cast<unsigned>(bits)))
      {
         if ((eval_lsb_imp(backend) < static_cast<std::size_t>(bits)) || eval_bit_test(backend, static_cast<std::size_t>(bits + 1)))
         {
            #ifdef BOOST_MP_MATH_AVAILABLE
            *result = boost::math::float_next(*result);
            #else
            using std::nextafter; BOOST_MP_FLOAT128_USING
            *result = nextafter(*result, *result * 2);
            #endif
         }
      }
   }
   else
   {
      typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::const_limb_pointer p = backend.limbs();
      std::size_t shift = cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
      *result = static_cast<R>(*p);
      for (std::size_t i = 1; i < backend.size(); ++i)
      {
         *result += static_cast<R>(ldexp(static_cast<long double>(p[i]), static_cast<int>(shift)));
         shift += cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
      }
   }
   if (backend.sign())
      *result = -*result;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, bool>::type
eval_is_zero(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val) noexcept
{
   return (val.size() == 1) && (val.limbs()[0] == 0);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, int>::type
eval_get_sign(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val) noexcept
{
   return eval_is_zero(val) ? 0 : val.sign() ? -1 : 1;
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_abs(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   result = val;
   result.sign(false);
}

//
// Get the location of the least-significant-bit:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_lsb_imp(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   //
   // Find the index of the least significant limb that is non-zero:
   //
   std::size_t index = 0;
   while (!a.limbs()[index] && (index < a.size()))
      ++index;
   //
   // Find the index of the least significant bit within that limb:
   //
   std::size_t result = boost::multiprecision::detail::find_lsb(a.limbs()[index]);

   return result + index * cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_lsb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   using default_ops::eval_get_sign;
   if (eval_get_sign(a) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (a.sign())
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return eval_lsb_imp(a);
}

//
// Get the location of the most-significant-bit:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_msb_imp(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   //
   // Find the index of the most significant bit that is non-zero:
   //
   return (a.size() - 1) * cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits + boost::multiprecision::detail::find_msb(a.limbs()[a.size() - 1]);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_msb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   using default_ops::eval_get_sign;
   if (eval_get_sign(a) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (a.sign())
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return eval_msb_imp(a);
}

#ifdef BOOST_GCC
//
// We really shouldn't need to be disabling this warning, but it really does appear to be
// spurious.  The warning appears only when in release mode, and asserts are on.
//
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, bool>::type
eval_bit_test(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val, std::size_t index) noexcept
{
   std::size_t  offset = index / cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   std::size_t  shift  = index % cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   limb_type mask   = shift ? limb_type(1u) << shift : limb_type(1u);
   if (offset >= val.size())
      return false;
   return val.limbs()[offset] & mask ? true : false;
}

#ifdef BOOST_GCC
#pragma GCC diagnostic pop
#endif

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_bit_set(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val, std::size_t index)
{
   std::size_t  offset = index / cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   std::size_t  shift  = index % cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   limb_type mask   = shift ? limb_type(1u) << shift : limb_type(1u);
   if (offset >= val.size())
   {
      std::size_t os = val.size();
      val.resize(offset + 1, offset + 1);
      if (offset >= val.size())
         return; // fixed precision overflow
      for (std::size_t i = os; i <= offset; ++i)
         val.limbs()[i] = 0;
   }
   val.limbs()[offset] |= mask;
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_bit_unset(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val, std::size_t index) noexcept
{
   std::size_t  offset = index / cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   std::size_t  shift  = index % cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   limb_type mask   = shift ? limb_type(1u) << shift : limb_type(1u);
   if (offset >= val.size())
      return;
   val.limbs()[offset] &= ~mask;
   val.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_bit_flip(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val, std::size_t index)
{
   std::size_t  offset = index / cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   std::size_t  shift  = index % cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
   limb_type mask   = shift ? limb_type(1u) << shift : limb_type(1u);
   if (offset >= val.size())
   {
      std::size_t os = val.size();
      val.resize(offset + 1, offset + 1);
      if (offset >= val.size())
         return; // fixed precision overflow
      for (std::size_t i = os; i <= offset; ++i)
         val.limbs()[i] = 0;
   }
   val.limbs()[offset] ^= mask;
   val.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_qr(
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& x,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& y,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       q,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       r) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   divide_unsigned_helper(&q, x, y, r);
   q.sign(x.sign() != y.sign());
   r.sign(x.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_qr(
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& x,
    limb_type                                                                   y,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       q,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       r) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   divide_unsigned_helper(&q, x, y, r);
   q.sign(x.sign());
   r.sign(x.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<U>::value>::type eval_qr(
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& x,
    U                                                                           y,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       q,
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       r) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   using default_ops::eval_qr;
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t;
   t = y;
   eval_qr(x, t, q, r);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, Integer>::type
eval_integer_modulus(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, Integer mod)
{
   BOOST_IF_CONSTEXPR (sizeof(Integer) <= sizeof(limb_type))
   {
      if (mod <= (std::numeric_limits<limb_type>::max)())
      {
         const std::ptrdiff_t n = a.size();
         const double_limb_type two_n_mod = static_cast<limb_type>(1u) + (~static_cast<limb_type>(0u) - mod) % mod;
         limb_type              res = a.limbs()[n - 1] % mod;

         for (std::ptrdiff_t i = n - 2; i >= 0; --i)
            res = static_cast<limb_type>((res * two_n_mod + a.limbs()[i]) % mod);
         return res;
      }
      else
         return default_ops::eval_integer_modulus(a, mod);
   }
   else
   {
      return default_ops::eval_integer_modulus(a, mod);
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, Integer>::type
eval_integer_modulus(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& x, Integer val)
{
   return eval_integer_modulus(x, boost::multiprecision::detail::unsigned_abs(val));
}

BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR limb_type eval_gcd(limb_type u, limb_type v)
{
   // boundary cases
   if (!u || !v)
      return u | v;
#if (defined(__cpp_lib_gcd_lcm) && (__cpp_lib_gcd_lcm >= 201606L))
   return std::gcd(u, v);
#else
   std::size_t shift = boost::multiprecision::detail::find_lsb(u | v);
   u >>= boost::multiprecision::detail::find_lsb(u);
   do
   {
      v >>= boost::multiprecision::detail::find_lsb(v);
      if (u > v)
         std_constexpr::swap(u, v);
      v -= u;
   } while (v);
   return u << shift;
#endif
}

inline BOOST_MP_CXX14_CONSTEXPR double_limb_type eval_gcd(double_limb_type u, double_limb_type v)
{
#if (defined(__cpp_lib_gcd_lcm) && (__cpp_lib_gcd_lcm >= 201606L)) && (!defined(BOOST_HAS_INT128) || !defined(__STRICT_ANSI__))
   return std::gcd(u, v);
#else
   if (u == 0)
      return v;

   std::size_t shift = boost::multiprecision::detail::find_lsb(u | v);
   u >>= boost::multiprecision::detail::find_lsb(u);
   do
   {
      v >>= boost::multiprecision::detail::find_lsb(v);
      if (u > v)
         std_constexpr::swap(u, v);
      v -= u;
   } while (v);
   return u << shift;
#endif
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    limb_type                                                                   b)
{
   int s = eval_get_sign(a);
   if (!b || !s)
   {
      result = a;
      *result.limbs() |= b;
   }
   else
   {
      eval_modulus(result, a, b);
      limb_type& res = *result.limbs();
      res = eval_gcd(res, b);
   }
   result.sign(false);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    double_limb_type                                                            b)
{
   int s = eval_get_sign(a);
   if (!b || !s)
   {
      if (!s)
         result = b;
      else
         result = a;
      return;
   }
   double_limb_type res = 0;
   if(a.sign() == 0)
      res = eval_integer_modulus(a, b);
   else
   {
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(a);
      t.negate();
      res = eval_integer_modulus(t, b);
   }
   res            = eval_gcd(res, b);
   result = res;
   result.sign(false);
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
   const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
   signed_double_limb_type                                                     v)
{
   eval_gcd(result, a, static_cast<double_limb_type>(v < 0 ? -v : v));
}
//
// These 2 overloads take care of gcd against an (unsigned) short etc:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value && (sizeof(Integer) <= sizeof(limb_type)) && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    const Integer&                                                              v)
{
   eval_gcd(result, a, static_cast<limb_type>(v));
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value && (sizeof(Integer) <= sizeof(limb_type)) && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    const Integer&                                                              v)
{
   eval_gcd(result, a, static_cast<limb_type>(v < 0 ? -v : v));
}
//
// What follows is Lehmer's GCD algorithm:
// Essentially this uses the leading digit(s) of U and V
// only to run a "simulated" Euclid algorithm.  It stops
// when the calculated quotient differs from what would have been
// the true quotient.  At that point the cosequences are used to
// calculate the new U and V.  A nice lucid description appears
// in "An Analysis of Lehmer's Euclidean GCD Algorithm",
// by Jonathan Sorenson.  https://www.researchgate.net/publication/2424634_An_Analysis_of_Lehmer%27s_Euclidean_GCD_Algorithm
// DOI: 10.1145/220346.220378.
//
// There are two versions of this algorithm here, and both are "double digit"
// variations: which is to say if there are k bits per limb, then they extract
// 2k bits into a double_limb_type and then run the algorithm on that.  The first
// version is a straightforward version of the algorithm, and is designed for
// situations where double_limb_type is a native integer (for example where
// limb_type is a 32-bit integer on a 64-bit machine).  For 32-bit limbs it
// reduces the size of U by about 30 bits per call.  The second is a more complex
// version for situations where double_limb_type is a synthetic type: for example
// __int128.  For 64 bit limbs it reduces the size of U by about 62 bits per call.
//
// The complexity of the algorithm given by Sorenson is roughly O(ln^2(N)) for
// two N bit numbers.
//
// The original double-digit version of the algorithm is described in:
// 
// "A Double Digit Lehmer-Euclid Algorithm for Finding the GCD of Long Integers",
// Tudor Jebelean, J Symbolic Computation, 1995 (19), 145.
//
#ifndef BOOST_HAS_INT128
//
// When double_limb_type is a native integer type then we should just use it and not worry about the consequences.
// This can eliminate approximately a full limb with each call.
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Storage>
void eval_gcd_lehmer(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& U, cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& V, std::size_t lu, Storage& storage)
{
   //
   // Extract the leading 2 * bits_per_limb bits from U and V:
   //
   std::size_t         h = lu % bits_per_limb;
   double_limb_type u = (static_cast<double_limb_type>((U.limbs()[U.size() - 1])) << bits_per_limb) | U.limbs()[U.size() - 2];
   double_limb_type v = (static_cast<double_limb_type>((V.size() < U.size() ? 0 : V.limbs()[V.size() - 1])) << bits_per_limb) | V.limbs()[U.size() - 2];
   if (h)
   {
      u <<= bits_per_limb - h;
      u |= U.limbs()[U.size() - 3] >> h;
      v <<= bits_per_limb - h;
      v |= V.limbs()[U.size() - 3] >> h;
   }
   //
   // Co-sequences x an y: we need only the last 3 values of these,
   // the first 2 values are known correct, the third gets checked
   // in each loop operation, and we terminate when they go wrong.
   //
   // x[i+0] is positive for even i.
   // y[i+0] is positive for odd i.
   //
   // However we track only absolute values here:
   //
   double_limb_type x[3] = {1, 0};
   double_limb_type y[3] = {0, 1};
   std::size_t         i    = 0;

#ifdef BOOST_MP_GCD_DEBUG
   cpp_int UU, VV;
   UU = U;
   VV = V;
#endif

   while (true)
   {
      double_limb_type q  = u / v;
      x[2]                = x[0] + q * x[1];
      y[2]                = y[0] + q * y[1];
      double_limb_type tu = u;
      u                   = v;
      v                   = tu - q * v;
      ++i;
      //
      // We must make sure that y[2] occupies a single limb otherwise
      // the multiprecision multiplications below would be much more expensive.
      // This can sometimes lose us one iteration, but is worth it for improved
      // calculation efficiency.
      //
      if (y[2] >> bits_per_limb)
         break;
      //
      // These are Jebelean's exact termination conditions:
      //
      if ((i & 1u) == 0)
      {
         BOOST_MP_ASSERT(u > v);
         if ((v < x[2]) || ((u - v) < (y[2] + y[1])))
            break;
      }
      else
      {
         BOOST_MP_ASSERT(u > v);
         if ((v < y[2]) || ((u - v) < (x[2] + x[1])))
            break;
      }
#ifdef BOOST_MP_GCD_DEBUG
      BOOST_MP_ASSERT(q == UU / VV);
      UU %= VV;
      UU.swap(VV);
#endif
      x[0] = x[1];
      x[1] = x[2];
      y[0] = y[1];
      y[1] = y[2];
   }
   if (i == 1)
   {
      // No change to U and V we've stalled!
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t;
      eval_modulus(t, U, V);
      U.swap(V);
      V.swap(t);
      return;
   }
   //
   // Update U and V.
   // We have:
   //
   // U = x[0]U + y[0]V and
   // V = x[1]U + y[1]V.
   //
   // But since we track only absolute values of x and y
   // we have to take account of the implied signs and perform
   // the appropriate subtraction depending on the whether i is
   // even or odd:
   //
   std::size_t                                                             ts = U.size() + 1;
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t1(storage, ts), t2(storage, ts), t3(storage, ts);
   eval_multiply(t1, U, static_cast<limb_type>(x[0]));
   eval_multiply(t2, V, static_cast<limb_type>(y[0]));
   eval_multiply(t3, U, static_cast<limb_type>(x[1]));
   if ((i & 1u) == 0)
   {
      if (x[0] == 0)
         U = t2;
      else
      {
         BOOST_MP_ASSERT(t2.compare(t1) >= 0);
         eval_subtract(U, t2, t1);
         BOOST_MP_ASSERT(U.sign() == false);
      }
   }
   else
   {
      BOOST_MP_ASSERT(t1.compare(t2) >= 0);
      eval_subtract(U, t1, t2);
      BOOST_MP_ASSERT(U.sign() == false);
   }
   eval_multiply(t2, V, static_cast<limb_type>(y[1]));
   if (i & 1u)
   {
      if (x[1] == 0)
         V = t2;
      else
      {
         BOOST_MP_ASSERT(t2.compare(t3) >= 0);
         eval_subtract(V, t2, t3);
         BOOST_MP_ASSERT(V.sign() == false);
      }
   }
   else
   {
      BOOST_MP_ASSERT(t3.compare(t2) >= 0);
      eval_subtract(V, t3, t2);
      BOOST_MP_ASSERT(V.sign() == false);
   }
   BOOST_MP_ASSERT(U.compare(V) >= 0);
   BOOST_MP_ASSERT(lu > eval_msb(U));
#ifdef BOOST_MP_GCD_DEBUG

   BOOST_MP_ASSERT(UU == U);
   BOOST_MP_ASSERT(VV == V);

   extern std::size_t total_lehmer_gcd_calls;
   extern std::size_t total_lehmer_gcd_bits_saved;
   extern std::size_t total_lehmer_gcd_cycles;

   ++total_lehmer_gcd_calls;
   total_lehmer_gcd_bits_saved += lu - eval_msb(U);
   total_lehmer_gcd_cycles += i;
#endif
   if (lu < 2048)
   {
      //
      // Since we have stripped all common powers of 2 from U and V at the start
      // if either are even at this point, we can remove stray powers of 2 now.
      // Note that it is not possible for *both* U and V to be even at this point.
      //
      // This has an adverse effect on performance for high bit counts, but has
      // a significant positive effect for smaller counts.
      //
      if ((U.limbs()[0] & 1u) == 0)
      {
         eval_right_shift(U, eval_lsb(U));
         if (U.compare(V) < 0)
            U.swap(V);
      }
      else if ((V.limbs()[0] & 1u) == 0)
      {
         eval_right_shift(V, eval_lsb(V));
      }
   }
   storage.deallocate(ts * 3);
}

#else
//
// This branch is taken when double_limb_type is a synthetic type with no native hardware support.
// For example __int128.  The assumption is that add/subtract/multiply of double_limb_type are efficient,
// but that division is very slow.
//
// We begin with a specialized routine for division.
// We know that most of the time this is called the result will be 1.
// For small limb counts, this almost doubles the performance of Lehmer's routine!
//
BOOST_FORCEINLINE void divide_subtract(double_limb_type& q, double_limb_type& u, const double_limb_type& v)
{
   BOOST_MP_ASSERT(q == 1); // precondition on entry.
   u -= v;
   while (u >= v)
   {
      u -= v;
      if (++q > 30)
      {
         double_limb_type t = u / v;
         u -= t * v;
         q += t;
      }
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Storage>
void eval_gcd_lehmer(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& U, cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& V, std::size_t lu, Storage& storage)
{
   //
   // Extract the leading 2*bits_per_limb bits from U and V:
   //
   std::size_t  h = lu % bits_per_limb;
   double_limb_type u, v;
   if (h)
   {
      u = (static_cast<double_limb_type>((U.limbs()[U.size() - 1])) << bits_per_limb) | U.limbs()[U.size() - 2];
      v = (static_cast<double_limb_type>((V.size() < U.size() ? 0 : V.limbs()[V.size() - 1])) << bits_per_limb) | V.limbs()[U.size() - 2];
      u <<= bits_per_limb - h;
      u |= U.limbs()[U.size() - 3] >> h;
      v <<= bits_per_limb - h;
      v |= V.limbs()[U.size() - 3] >> h;
   }
   else
   {
      u = (static_cast<double_limb_type>(U.limbs()[U.size() - 1]) << bits_per_limb) | U.limbs()[U.size() - 2];
      v = (static_cast<double_limb_type>(V.limbs()[U.size() - 1]) << bits_per_limb) | V.limbs()[U.size() - 2];
   }
   //
   // Cosequences are stored as limb_types, we take care not to overflow these:
   //
   // x[i+0] is positive for even i.
   // y[i+0] is positive for odd i.
   //
   // However we track only absolute values here:
   //
   limb_type x[3] = { 1, 0 };
   limb_type y[3] = { 0, 1 };
   std::size_t  i = 0;

#ifdef BOOST_MP_GCD_DEBUG
   cpp_int UU, VV;
   UU = U;
   VV = V;
#endif
   //
   // We begine by running a single digit version of Lehmer's algorithm, we still have
   // to track u and v at double precision, but this adds only a tiny performance penalty.
   // What we gain is fast division, and fast termination testing.
   // When you see static_cast<limb_type>(u >> bits_per_limb) here, this is really just
   // a direct access to the upper bits_per_limb of the double limb type.  For __int128
   // this is simple a load of the upper 64 bits and the "shift" is optimised away.
   //
   double_limb_type old_u, old_v;
   while (true)
   {
      limb_type q = static_cast<limb_type>(u >> bits_per_limb) / static_cast<limb_type>(v >> bits_per_limb);
      x[2] = x[0] + q * x[1];
      y[2] = y[0] + q * y[1];
      double_limb_type tu = u;
      old_u = u;
      old_v = v;
      u = v;
      double_limb_type t = q * v;
      if (tu < t)
      {
         ++i;
         break;
      }
      v = tu - t;
      ++i;
      BOOST_MP_ASSERT((u <= v) || (t / q == old_v));
      if (u <= v)
      {
         // We've gone terribly wrong, probably numeric overflow:
         break;
      }
      if ((i & 1u) == 0)
      {
         if ((static_cast<limb_type>(v >> bits_per_limb) < x[2]) || ((static_cast<limb_type>(u >> bits_per_limb) - static_cast<limb_type>(v >> bits_per_limb)) < (y[2] + y[1])))
            break;
      }
      else
      {
         if ((static_cast<limb_type>(v >> bits_per_limb) < y[2]) || ((static_cast<limb_type>(u >> bits_per_limb) - static_cast<limb_type>(v >> bits_per_limb)) < (x[2] + x[1])))
            break;
      }
#ifdef BOOST_MP_GCD_DEBUG
      BOOST_MP_ASSERT(q == UU / VV);
      UU %= VV;
      UU.swap(VV);
#endif
      x[0] = x[1];
      x[1] = x[2];
      y[0] = y[1];
      y[1] = y[2];
   }
   //
   // We get here when the single digit algorithm has gone wrong, back up i, u and v:
   //
   --i;
   u = old_u;
   v = old_v;
   //
   // Now run the full double-digit algorithm:
   //
   while (true)
   {
      double_limb_type q = 1u;
      double_limb_type tt = u;
      divide_subtract(q, u, v);
      std::swap(u, v);
      tt = y[0] + q * static_cast<double_limb_type>(y[1]);
      //
      // If calculation of y[2] would overflow a single limb, then we *must* terminate.
      // Note that x[2] < y[2] so there is no need to check that as well:
      //
      if (tt >> bits_per_limb)
      {
         ++i;
         break;
      }
      x[2] = static_cast<limb_type>(x[0] + static_cast<double_limb_type>(q * x[1]));
      y[2] = static_cast<limb_type>(tt);
      ++i;
      if ((i & 1u) == 0)
      {
         BOOST_MP_ASSERT(u > v);
         if ((v < x[2]) || ((u - v) < (static_cast<double_limb_type>(y[2]) + y[1])))
            break;
      }
      else
      {
         BOOST_MP_ASSERT(u > v);
         if ((v < y[2]) || ((u - v) < (static_cast<double_limb_type>(x[2]) + x[1])))
            break;
      }
#ifdef BOOST_MP_GCD_DEBUG
      BOOST_MP_ASSERT(q == UU / VV);
      UU %= VV;
      UU.swap(VV);
#endif
      x[0] = x[1];
      x[1] = x[2];
      y[0] = y[1];
      y[1] = y[2];
   }
   if (i == 1)
   {
      // No change to U and V we've stalled!
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t;
      eval_modulus(t, U, V);
      U.swap(V);
      V.swap(t);
      return;
   }
   //
   // Update U and V.
   // We have:
   //
   // U = x[0]U + y[0]V and
   // V = x[1]U + y[1]V.
   //
   // But since we track only absolute values of x and y
   // we have to take account of the implied signs and perform
   // the appropriate subtraction depending on the whether i is
   // even or odd:
   //
   std::size_t ts = U.size() + 1;
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t1(storage, ts), t2(storage, ts), t3(storage, ts);
   eval_multiply(t1, U, x[0]);
   eval_multiply(t2, V, y[0]);
   eval_multiply(t3, U, x[1]);
   if ((i & 1u) == 0)
   {
      if (x[0] == 0)
         U = t2;
      else
      {
         BOOST_MP_ASSERT(t2.compare(t1) >= 0);
         eval_subtract(U, t2, t1);
         BOOST_MP_ASSERT(U.sign() == false);
      }
   }
   else
   {
      BOOST_MP_ASSERT(t1.compare(t2) >= 0);
      eval_subtract(U, t1, t2);
      BOOST_MP_ASSERT(U.sign() == false);
   }
   eval_multiply(t2, V, y[1]);
   if (i & 1u)
   {
      if (x[1] == 0)
         V = t2;
      else
      {
         BOOST_MP_ASSERT(t2.compare(t3) >= 0);
         eval_subtract(V, t2, t3);
         BOOST_MP_ASSERT(V.sign() == false);
      }
   }
   else
   {
      BOOST_MP_ASSERT(t3.compare(t2) >= 0);
      eval_subtract(V, t3, t2);
      BOOST_MP_ASSERT(V.sign() == false);
   }
   BOOST_MP_ASSERT(U.compare(V) >= 0);
   BOOST_MP_ASSERT(lu > eval_msb(U));
#ifdef BOOST_MP_GCD_DEBUG

   BOOST_MP_ASSERT(UU == U);
   BOOST_MP_ASSERT(VV == V);

   extern std::size_t total_lehmer_gcd_calls;
   extern std::size_t total_lehmer_gcd_bits_saved;
   extern std::size_t total_lehmer_gcd_cycles;

   ++total_lehmer_gcd_calls;
   total_lehmer_gcd_bits_saved += lu - eval_msb(U);
   total_lehmer_gcd_cycles += i;
#endif
   if (lu < 2048)
   {
      //
      // Since we have stripped all common powers of 2 from U and V at the start
      // if either are even at this point, we can remove stray powers of 2 now.
      // Note that it is not possible for *both* U and V to be even at this point.
      //
      // This has an adverse effect on performance for high bit counts, but has
      // a significant positive effect for smaller counts.
      //
      if ((U.limbs()[0] & 1u) == 0)
      {
         eval_right_shift(U, eval_lsb(U));
         if (U.compare(V) < 0)
            U.swap(V);
      }
      else if ((V.limbs()[0] & 1u) == 0)
      {
         eval_right_shift(V, eval_lsb(V));
      }
   }
   storage.deallocate(ts * 3);
}

#endif

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
   const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
   const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b)
{
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_lsb;

   if (a.size() == 1)
   {
      eval_gcd(result, b, *a.limbs());
      return;
   }
   if (b.size() == 1)
   {
      eval_gcd(result, a, *b.limbs());
      return;
   }
   std::size_t temp_size = (std::max)(a.size(), b.size()) + 1;
   typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::scoped_shared_storage storage(a, temp_size * 6);

   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> U(storage, temp_size);
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> V(storage, temp_size);
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(storage, temp_size);
   U = a;
   V = b;

   int s = eval_get_sign(U);

   /* GCD(0,x) := x */
   if (s < 0)
   {
      U.negate();
   }
   else if (s == 0)
   {
      result = V;
      return;
   }
   s = eval_get_sign(V);
   if (s < 0)
   {
      V.negate();
   }
   else if (s == 0)
   {
      result = U;
      return;
   }
   //
   // Remove common factors of 2:
   //
   std::size_t us = eval_lsb(U);
   std::size_t vs = eval_lsb(V);
   std::size_t shift = (std::min)(us, vs);
   if (us)
      eval_right_shift(U, us);
   if (vs)
      eval_right_shift(V, vs);

   if (U.compare(V) < 0)
      U.swap(V);

   while (!eval_is_zero(V))
   {
      if (U.size() <= 2)
      {
         //
         // Special case: if V has no more than 2 limbs
         // then we can reduce U and V to a pair of integers and perform
         // direct integer gcd:
         //
         if (U.size() == 1)
            U = eval_gcd(*V.limbs(), *U.limbs());
         else
         {
            double_limb_type i = U.limbs()[0] | (static_cast<double_limb_type>(U.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
            double_limb_type j = (V.size() == 1) ? *V.limbs() : V.limbs()[0] | (static_cast<double_limb_type>(V.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
            U = eval_gcd(i, j);
         }
         break;
      }
      std::size_t lu = eval_msb(U) + 1;
      std::size_t lv = eval_msb(V) + 1;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
      if (!BOOST_MP_IS_CONST_EVALUATED(lu) && (lu - lv <= bits_per_limb / 2))
#else
      if (lu - lv <= bits_per_limb / 2)
#endif
      {
         eval_gcd_lehmer(U, V, lu, storage);
      }
      else
      {
         eval_modulus(t, U, V);
         U.swap(V);
         V.swap(t);
      }
   }
   result = U;
   if (shift)
      eval_left_shift(result, shift);
}
//
// Now again for trivial backends:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_gcd(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b) noexcept
{
   *result.limbs() = boost::multiprecision::detail::constexpr_gcd(*a.limbs(), *b.limbs());
   result.sign(false);
}
// This one is only enabled for unchecked cpp_int's, for checked int's we need the checking in the default version:
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (Checked1 == unchecked)>::type
eval_lcm(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = boost::multiprecision::detail::constexpr_lcm(*a.limbs(), *b.limbs());
   result.normalize(); // result may overflow the specified number of bits
   result.sign(false);
}

inline void conversion_overflow(const std::integral_constant<int, checked>&)
{
   BOOST_MP_THROW_EXCEPTION(std::overflow_error("Overflow in conversion to narrower type"));
}
inline BOOST_MP_CXX14_CONSTEXPR void conversion_overflow(const std::integral_constant<int, unchecked>&) {}

#if defined(__clang__) && defined(__MINGW32__)
//
// clang-11 on Mingw segfaults on conversion of __int128 -> float.
// See: https://bugs.llvm.org/show_bug.cgi?id=48941
// These workarounds pass everything through an intermediate uint64_t.
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && std::is_same<typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type, double_limb_type>::value>::type
eval_convert_to(float* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val)
{
   float f = static_cast<std::uint64_t>((*val.limbs()) >> 64);
   *result = std::ldexp(f, 64);
   *result += static_cast<std::uint64_t>((*val.limbs()));
   if(val.sign())
      *result = -*result;
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && std::is_same<typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type, double_limb_type>::value>::type
eval_convert_to(double* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val)
{
   float f = static_cast<std::uint64_t>((*val.limbs()) >> 64);
   *result = std::ldexp(f, 64);
   *result += static_cast<std::uint64_t>((*val.limbs()));
   if(val.sign())
      *result = -*result;
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && std::is_same<typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type, double_limb_type>::value>::type
eval_convert_to(long double* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val)
{
   float f = static_cast<std::uint64_t>((*val.limbs()) >> 64);
   *result = std::ldexp(f, 64);
   *result += static_cast<std::uint64_t>((*val.limbs()));
   if(val.sign())
      *result = -*result;
}
#endif

template <class R, std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && std::is_convertible<typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type, R>::value>::type
eval_convert_to(R* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val)
{
   BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_specialized)
   {
      using common_type = typename std::common_type<R, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type>::type;

      if (static_cast<common_type>(*val.limbs()) > static_cast<common_type>((std::numeric_limits<R>::max)()))
      {
         if (val.isneg())
         {
            check_is_negative(std::integral_constant < bool, (boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value) || (number_category<R>::value == number_kind_floating_point) > ());
            if (static_cast<common_type>(*val.limbs()) > -static_cast<common_type>((std::numeric_limits<R>::min)()))
               conversion_overflow(typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
            *result = (std::numeric_limits<R>::min)();
         }
         else
         {
            conversion_overflow(typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
            *result = boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value ? (std::numeric_limits<R>::max)() : static_cast<R>(*val.limbs());
         }
      }
      else
      {
         *result = static_cast<R>(*val.limbs());
         if (val.isneg())
         {
            check_is_negative(std::integral_constant < bool, (boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value) || (number_category<R>::value == number_kind_floating_point) > ());
            *result = negate_integer(*result, std::integral_constant < bool, is_signed_number<R>::value || (number_category<R>::value == number_kind_floating_point) > ());
         }
      }
   }
   else
   {
      *result = static_cast<R>(*val.limbs());
      if (val.isneg())
      {
         check_is_negative(std::integral_constant<bool, (boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value) || (number_category<R>::value == number_kind_floating_point) > ());
         *result = negate_integer(*result, std::integral_constant<bool, is_signed_number<R>::value || (number_category<R>::value == number_kind_floating_point) > ());
      }
   }
}

template <class R, std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && std::is_convertible<typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type, R>::value>::type
eval_convert_to(R* result, const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val)
{
   BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_specialized)
   {
      using common_type = typename std::common_type<R, typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type>::type;

      if(static_cast<common_type>(*val.limbs()) > static_cast<common_type>((std::numeric_limits<R>::max)()))
      {
         conversion_overflow(typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
         *result = boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value ? (std::numeric_limits<R>::max)() : static_cast<R>(*val.limbs());
      }
      else
         *result = static_cast<R>(*val.limbs());
   }
   else
      *result = static_cast<R>(*val.limbs());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_lsb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   using default_ops::eval_get_sign;
   if (eval_get_sign(a) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (a.sign())
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   //
   // Find the index of the least significant bit within that limb:
   //
   return boost::multiprecision::detail::find_lsb(*a.limbs());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_msb_imp(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   //
   // Find the index of the least significant bit within that limb:
   //
   return boost::multiprecision::detail::find_msb(*a.limbs());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, std::size_t>::type
eval_msb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
{
   using default_ops::eval_get_sign;
   if (eval_get_sign(a) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (a.sign())
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return eval_msb_imp(a);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t hash_value(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& val) noexcept
{
   std::size_t result = 0;
   for (std::size_t i = 0; i < val.size(); ++i)
   {
      boost::multiprecision::detail::hash_combine(result, val.limbs()[i]);
   }
   boost::multiprecision::detail::hash_combine(result, val.sign());
   return result;
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // Namespace backends

namespace detail {

#ifndef BOOST_MP_STANDALONE
template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_gcd(T a, T b) noexcept
{
   return boost::integer::gcd(a, b);
}

template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_lcm(T a, T b) noexcept
{
   return boost::integer::lcm(a, b);
}

#else

template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_gcd(T a, T b) noexcept
{
   return boost::multiprecision::backends::eval_gcd(a, b);
}

template <typename T>
inline BOOST_CXX14_CONSTEXPR T constexpr_lcm(T a, T b) noexcept
{
   const T ab_gcd = boost::multiprecision::detail::constexpr_gcd(a, b);
   return (a * b) / ab_gcd;
}

#endif // BOOST_MP_STANDALONE

}

}} // Namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/multiply.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-20 John Maddock. 
//  Copyright 2019-20 Christopher Kormanyos. 
//  Copyright 2019-20 Madhur Chauhan. 
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_CPP_INT_MULTIPLY_HPP
#define BOOST_MP_CPP_INT_MULTIPLY_HPP

#include <limits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/endian.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/integer.hpp>

namespace boost { namespace multiprecision { namespace backends {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
//
// Multiplication by a single limb:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const limb_type&                                                            val) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   if (!val)
   {
      result = static_cast<limb_type>(0);
      return;
   }
   if ((void*)&a != (void*)&result)
      result.resize(a.size(), a.size());
   double_limb_type                                                                                  carry = 0;
   typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_pointer       p     = result.limbs();
   typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_pointer       pe    = result.limbs() + result.size();
   typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>::const_limb_pointer pa    = a.limbs();
   while (p != pe)
   {
      carry += static_cast<double_limb_type>(*pa) * static_cast<double_limb_type>(val);
#ifdef __MSVC_RUNTIME_CHECKS
      *p = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
      *p = static_cast<limb_type>(carry);
#endif
      carry >>= cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
      ++p, ++pa;
   }
   if (carry)
   {
      std::size_t i = result.size();
      result.resize(i + 1, i + 1);
      if (result.size() > i)
         result.limbs()[i] = static_cast<limb_type>(carry);
   }
   result.sign(a.sign());
   if (is_fixed_precision<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)
      result.normalize();
}

//
// resize_for_carry forces a resize of the underlying buffer only if a previous request
// for "required" elements could possibly have failed, *and* we have checking enabled.
// This will cause an overflow error inside resize():
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR void resize_for_carry(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& /*result*/, std::size_t /*required*/) {}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, class Allocator1>
inline BOOST_MP_CXX14_CONSTEXPR void resize_for_carry(cpp_int_backend<MinBits1, MaxBits1, SignType1, checked, Allocator1>& result, std::size_t required)
{
   if (result.size() < required)
      result.resize(required, required);
}
//
// Minimum number of limbs required for Karatsuba to be worthwhile:
//
#ifdef BOOST_MP_KARATSUBA_CUTOFF
const size_t karatsuba_cutoff = BOOST_MP_KARATSUBA_CUTOFF;
#else
const size_t karatsuba_cutoff = 40;
#endif
//
// Core (recursive) Karatsuba multiplication, all the storage required is allocated upfront and 
// passed down the stack in this routine.  Note that all the cpp_int_backend's must be the same type
// and full variable precision.  Karatsuba really doesn't play nice with fixed-size integers.  If necessary
// fixed precision integers will get aliased as variable-precision types before this is called.
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
inline void multiply_karatsuba(
    cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>&       result,
    const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a,
    const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& b,
    typename cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>::scoped_shared_storage& storage)
{
   using cpp_int_type = cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>;

   std::size_t as = a.size();
   std::size_t bs = b.size();
   //
   // Termination condition: if either argument is smaller than karatsuba_cutoff
   // then schoolboy multiplication will be faster:
   //
   if ((as < karatsuba_cutoff) || (bs < karatsuba_cutoff))
   {
      eval_multiply(result, a, b);
      return;
   }
   //
   // Partitioning size: split the larger of a and b into 2 halves
   //
   std::size_t n  = (as > bs ? as : bs) / 2 + 1;
   //
   // Partition a and b into high and low parts.
   // ie write a, b as a = a_h * 2^n + a_l, b = b_h * 2^n + b_l
   //
   // We could copy the high and low parts into new variables, but we'll
   // use aliasing to reference the internal limbs of a and b.  There is one wart here:
   // if a and b are mismatched in size, then n may be larger than the smaller
   // of a and b.  In that situation the high part is zero, and we have no limbs
   // to alias, so instead alias a local variable.
   // This raises 2 questions:
   // * Is this the best way to partition a and b?
   // * Since we have one high part zero, the arithmetic simplifies considerably, 
   //   so should we have a special routine for this?
   // 
   std::size_t          sz = (std::min)(as, n);
   const cpp_int_type a_l(a.limbs(), 0, sz);

   sz = (std::min)(bs, n);
   const cpp_int_type b_l(b.limbs(), 0, sz);

   limb_type          zero = 0;
   const cpp_int_type a_h(as > n ? a.limbs() + n : &zero, 0, as > n ? as - n : 1);
   const cpp_int_type b_h(bs > n ? b.limbs() + n : &zero, 0, bs > n ? bs - n : 1);
   //
   // The basis for the Karatsuba algorithm is as follows:
   //
   // let                x = a_h * b_ h
   //                    y = a_l * b_l
   //                    z = (a_h + a_l)*(b_h + b_l) - x - y
   // and therefore  a * b = x * (2 ^ (2 * n))+ z * (2 ^ n) + y
   //
   // Begin by allocating our temporaries, these alias the memory already allocated in the shared storage:
   //
   cpp_int_type t1(storage, 2 * n + 2);
   cpp_int_type t2(storage, n + 1);
   cpp_int_type t3(storage, n + 1);
   //
   // Now we want:
   //
   // result = | a_h*b_h  | a_l*b_l |
   // (bits)              <-- 2*n -->
   //
   // We create aliases for the low and high parts of result, and multiply directly into them:
   //
   cpp_int_type result_low(result.limbs(), 0, 2 * n);
   cpp_int_type result_high(result.limbs(), 2 * n, result.size() - 2 * n);
   //
   // low part of result is a_l * b_l:
   //
   multiply_karatsuba(result_low, a_l, b_l, storage);
   //
   // We haven't zeroed out memory in result, so set to zero any unused limbs,
   // if a_l and b_l have mostly random bits then nothing happens here, but if
   // one is zero or nearly so, then a memset might be faster... it's not clear
   // that it's worth the extra logic though (and is darn hard to measure
   // what the "average" case is).
   //
   for (std::size_t i = result_low.size(); i < 2 * n; ++i)
      result.limbs()[i] = 0;
   //
   // Set the high part of result to a_h * b_h:
   //
   multiply_karatsuba(result_high, a_h, b_h, storage);
   for (std::size_t i = result_high.size() + 2 * n; i < result.size(); ++i)
      result.limbs()[i] = 0;
   //
   // Now calculate (a_h+a_l)*(b_h+b_l):
   //
   add_unsigned(t2, a_l, a_h);
   add_unsigned(t3, b_l, b_h);
   multiply_karatsuba(t1, t2, t3, storage); // t1 = (a_h+a_l)*(b_h+b_l)
   //
   // There is now a slight deviation from Karatsuba, we want to subtract
   // a_l*b_l + a_h*b_h from t1, but rather than use an addition and a subtraction
   // plus one temporary, we'll use 2 subtractions.  On the minus side, a subtraction
   // is on average slightly slower than an addition, but we save a temporary (ie memory)
   // and also hammer the same piece of memory over and over rather than 2 disparate
   // memory regions.  Overall it seems to be a slight win.
   //
   subtract_unsigned(t1, t1, result_high);
   subtract_unsigned(t1, t1, result_low);
   //
   // The final step is to left shift t1 by n bits and add to the result.
   // Rather than do an actual left shift, we can simply alias the result
   // and add to the alias:
   //
   cpp_int_type result_alias(result.limbs(), n, result.size() - n);
   add_unsigned(result_alias, result_alias, t1);
   //
   // Free up storage for use by sister branches to this one:
   //
   storage.deallocate(t1.capacity() + t2.capacity() + t3.capacity());

   result.normalize();
}

inline std::size_t karatsuba_storage_size(std::size_t s)
{
   // 
   // This estimates how much memory we will need based on
   // s-limb multiplication.  In an ideal world the number of limbs
   // would halve with each recursion, and our storage requirements
   // would be 4s in the limit, and rather less in practice since
   // we bail out long before we reach one limb.  In the real world
   // we don't quite halve s in each recursion, so this is an heuristic
   // which over-estimates how much we need.  We could compute an exact
   // value, but it would be rather time consuming.
   //
   return 5 * s;
}
//
// There are 2 entry point routines for Karatsuba multiplication:
// one for variable precision types, and one for fixed precision types.
// These are responsible for allocating all the storage required for the recursive
// routines above, and are always at the outermost level.
//
// Normal variable precision case comes first:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
inline typename std::enable_if<!is_fixed_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value>::type
setup_karatsuba(
   cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& result,
   const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& a,
   const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& b)
{
   std::size_t as = a.size();
   std::size_t bs = b.size();
   std::size_t s = as > bs ? as : bs;
   std::size_t storage_size = karatsuba_storage_size(s);
   if (storage_size < 300)
   {
      //
      // Special case: if we don't need too much memory, we can use stack based storage
      // and save a call to the allocator, this allows us to use Karatsuba multiply
      // at lower limb counts than would otherwise be possible:
      //
      limb_type limbs[300];
      typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::scoped_shared_storage storage(limbs, storage_size);
      multiply_karatsuba(result, a, b, storage);
   }
   else
   {
      typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::scoped_shared_storage storage(result.allocator(), storage_size);
      multiply_karatsuba(result, a, b, storage);
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
inline typename std::enable_if<is_fixed_precision<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_fixed_precision<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value || is_fixed_precision<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
setup_karatsuba(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
{
   //
   // Now comes the fixed precision case.
   // In fact Karatsuba doesn't really work with fixed precision since the logic
   // requires that we calculate all the bits of the result (especially in the
   // temporaries used internally).  So... we'll convert all the arguments
   // to variable precision types by aliasing them, this also
   // reduce the number of template instantations:
   //
   using variable_precision_type = cpp_int_backend<0, 0, signed_magnitude, unchecked, std::allocator<limb_type> >;
   variable_precision_type a_t(a.limbs(), 0, a.size()), b_t(b.limbs(), 0, b.size());
   std::size_t as = a.size();
   std::size_t bs = b.size();
   std::size_t s = as > bs ? as : bs;
   std::size_t sz = as + bs;
   std::size_t storage_size = karatsuba_storage_size(s);

   if (!is_fixed_precision<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || (sz * sizeof(limb_type) * CHAR_BIT <= MaxBits1))
   {
      // Result is large enough for all the bits of the result, so we can use aliasing:
      result.resize(sz, sz);
      variable_precision_type t(result.limbs(), 0, result.size());
      typename variable_precision_type::scoped_shared_storage storage(t.allocator(), storage_size);
      multiply_karatsuba(t, a_t, b_t, storage);
      result.resize(t.size(), t.size());
   }
   else
   {
      //
      // Not enough bit in result for the answer, so we must use a temporary
      // and then truncate (ie modular arithmetic):
      //
      typename variable_precision_type::scoped_shared_storage storage(variable_precision_type::allocator_type(), sz + storage_size);
      variable_precision_type t(storage, sz);
      multiply_karatsuba(t, a_t, b_t, storage);
      //
      // If there is truncation, and result is a checked type then this will throw:
      //
      result = t;
   }
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
inline typename std::enable_if<!is_fixed_precision<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_fixed_precision<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_fixed_precision<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
setup_karatsuba(
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
   const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
   const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b)
{
   //
   // Variable precision, mixed arguments, just alias and forward:
   //
   using variable_precision_type = cpp_int_backend<0, 0, signed_magnitude, unchecked, std::allocator<limb_type> >;
   variable_precision_type a_t(a.limbs(), 0, a.size()), b_t(b.limbs(), 0, b.size());
   std::size_t as = a.size();
   std::size_t bs = b.size();
   std::size_t s = as > bs ? as : bs;
   std::size_t sz = as + bs;
   std::size_t storage_size = karatsuba_storage_size(s);

   result.resize(sz, sz);
   variable_precision_type t(result.limbs(), 0, result.size());
   typename variable_precision_type::scoped_shared_storage storage(t.allocator(), storage_size);
   multiply_karatsuba(t, a_t, b_t, storage);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
inline BOOST_MP_CXX14_CONSTEXPR void
eval_multiply_comba(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   // 
   // see PR #182
   // Comba Multiplier - based on Paul Comba's
   // Exponentiation cryptosystems on the IBM PC, 1990
   //
   std::ptrdiff_t as                                                                                         = a.size(),
       bs                                                                                         = b.size(),
       rs                                                                                         = result.size();
   typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_pointer pr = result.limbs();

   double_limb_type carry    = 0,
                    temp     = 0;
   limb_type      overflow   = 0;
   const std::size_t limb_bits  = sizeof(limb_type) * CHAR_BIT;
   const bool     must_throw = rs < as + bs - 1;
   for (std::ptrdiff_t r = 0, lim = (std::min)(rs, as + bs - 1); r < lim; ++r, overflow = 0)
   {
      std::ptrdiff_t i = r >= as ? as - 1 : r,
          j = r - i,
          k = i < bs - j ? i + 1 : bs - j; // min(i+1, bs-j);

      typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>::const_limb_pointer pa = a.limbs() + i;
      typename cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>::const_limb_pointer pb = b.limbs() + j;

      temp = carry;
      carry += static_cast<double_limb_type>(*(pa)) * (*(pb));
      overflow += carry < temp;
      for (--k; k; k--)
      {
         temp = carry;
         carry += static_cast<double_limb_type>(*(--pa)) * (*(++pb));
         overflow += carry < temp;
      }
      *(pr++) = static_cast<limb_type>(carry);
      carry   = (static_cast<double_limb_type>(overflow) << limb_bits) | (carry >> limb_bits);
   }
   if (carry || must_throw)
   {
      resize_for_carry(result, as + bs);
      if (static_cast<int>(result.size()) >= as + bs)
         *pr = static_cast<limb_type>(carry);
   }
}
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, std::size_t MinBits3, std::size_t MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) 
   noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value 
      && (karatsuba_cutoff * sizeof(limb_type) * CHAR_BIT > MaxBits1) 
      && (karatsuba_cutoff * sizeof(limb_type)* CHAR_BIT > MaxBits2) 
      && (karatsuba_cutoff * sizeof(limb_type)* CHAR_BIT > MaxBits3)))
{
   // Uses simple (O(n^2)) multiplication when the limbs are less
   // otherwise switches to karatsuba algorithm based on experimental value (~40 limbs)
   //
   // Trivial cases first:
   //
   std::size_t                                                                                          as = a.size();
   std::size_t                                                                                          bs = b.size();
   typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>::const_limb_pointer pa = a.limbs();
   typename cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>::const_limb_pointer pb = b.limbs();
   if (as == 1)
   {
      bool s = b.sign() != a.sign();
      if (bs == 1)
      {
         result = static_cast<double_limb_type>(*pa) * static_cast<double_limb_type>(*pb);
      }
      else
      {
         limb_type l = *pa;
         eval_multiply(result, b, l);
      }
      result.sign(s);
      return;
   }
   if (bs == 1)
   {
      bool      s = b.sign() != a.sign();
      limb_type l = *pb;
      eval_multiply(result, a, l);
      result.sign(s);
      return;
   }

   if ((void*)&result == (void*)&a)
   {
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(a);
      eval_multiply(result, t, b);
      return;
   }
   if ((void*)&result == (void*)&b)
   {
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(b);
      eval_multiply(result, a, t);
      return;
   }

   constexpr double_limb_type limb_max        = static_cast<double_limb_type>(~static_cast<limb_type>(0u));
   constexpr double_limb_type double_limb_max = static_cast<double_limb_type>(~static_cast<double_limb_type>(0u));

   result.resize(as + bs, as + bs - 1);
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (!BOOST_MP_IS_CONST_EVALUATED(as) && (as >= karatsuba_cutoff && bs >= karatsuba_cutoff))
#else
   if (as >= karatsuba_cutoff && bs >= karatsuba_cutoff)
#endif
   {
      setup_karatsuba(result, a, b);
      //
      // Set the sign of the result:
      //
      result.sign(a.sign() != b.sign());
      return;
   }
   typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_pointer pr = result.limbs();
   static_assert(double_limb_max - 2 * limb_max >= limb_max * limb_max, "failed limb size sanity check");

#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(as))
   {
      for (std::size_t i = 0; i < result.size(); ++i)
         pr[i] = 0;
   }
   else
#endif
   std::memset(pr, 0, result.size() * sizeof(limb_type));   

#if defined(BOOST_MP_COMBA)
       // 
       // Comba Multiplier might not be efficient because of less efficient assembly
       // by the compiler as of 09/01/2020 (DD/MM/YY). See PR #182
       // Till then this will lay dormant :(
       //
       eval_multiply_comba(result, a, b);
#else

   double_limb_type carry = 0;
   for (std::size_t i = 0; i < as; ++i)
   {
      BOOST_MP_ASSERT(result.size() > i);
      std::size_t inner_limit = !is_fixed_precision<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value ? bs : (std::min)(result.size() - i, bs);
      std::size_t j           = 0;
      for (; j < inner_limit; ++j)
      {
         BOOST_MP_ASSERT(i + j < result.size());
#if (!defined(__GLIBCXX__) && !defined(__GLIBCPP__)) || !BOOST_WORKAROUND(BOOST_GCC_VERSION, <= 50100)
         BOOST_MP_ASSERT(!std::numeric_limits<double_limb_type>::is_specialized || ((std::numeric_limits<double_limb_type>::max)() - carry >
                                                                                 static_cast<double_limb_type>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value) * static_cast<double_limb_type>(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value)));
#endif
         carry += static_cast<double_limb_type>(pa[i]) * static_cast<double_limb_type>(pb[j]);
         BOOST_MP_ASSERT(!std::numeric_limits<double_limb_type>::is_specialized || ((std::numeric_limits<double_limb_type>::max)() - carry >= pr[i + j]));
         carry += pr[i + j];
#ifdef __MSVC_RUNTIME_CHECKS
         pr[i + j] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
         pr[i + j] = static_cast<limb_type>(carry);
#endif
         carry >>= cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
         BOOST_MP_ASSERT(carry <= (cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value));
      }
      if (carry)
      {
         resize_for_carry(result, i + j + 1); // May throw if checking is enabled
         if (i + j < result.size())
#ifdef __MSVC_RUNTIME_CHECKS
            pr[i + j] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
#else
            pr[i + j] = static_cast<limb_type>(carry);
#endif
      }
      carry = 0;
   }
#endif // ifdef(BOOST_MP_COMBA) ends

   result.normalize();
   //
   // Set the sign of the result:
   //
   result.sign(a.sign() != b.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a) 
   noexcept((noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>()))))
{
   eval_multiply(result, result, a);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const limb_type& val) 
   noexcept((noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const limb_type&>()))))
{
   eval_multiply(result, result, val);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const double_limb_type&                                                     val) 
   noexcept(
      (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>(), std::declval<const limb_type&>())))
      && (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>())))
   )
{
   if (val <= (std::numeric_limits<limb_type>::max)())
   {
      eval_multiply(result, a, static_cast<limb_type>(val));
   }
   else
   {
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(val);
#else
      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t;
      t = val;
#endif
      eval_multiply(result, a, t);
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const double_limb_type& val)
   noexcept((noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const double_limb_type&>()))))
{
   eval_multiply(result, result, val);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const signed_limb_type&                                                     val) 
   noexcept((noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>(), std::declval<const limb_type&>()))))
{
   if (val > 0)
      eval_multiply(result, a, static_cast<limb_type>(val));
   else
   {
      eval_multiply(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(val)));
      result.negate();
   }
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const signed_limb_type& val)
   noexcept((noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const limb_type&>()))))
{
   eval_multiply(result, result, val);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,
    const signed_double_limb_type&                                              val)
   noexcept(
   (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>(), std::declval<const limb_type&>())))
      && (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>())))
   )
{
   if (val > 0)
   {
      if (val <= (std::numeric_limits<limb_type>::max)())
      {
         eval_multiply(result, a, static_cast<limb_type>(val));
         return;
      }
   }
   else if (val >= -static_cast<signed_double_limb_type>((std::numeric_limits<limb_type>::max)()))
   {
      eval_multiply(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(val)));
      result.negate();
      return;
   }
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t(val);
#else
   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> t;
   t = val;
#endif
   eval_multiply(result, a, t);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const signed_double_limb_type& val)
   noexcept(
   (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const limb_type&>())))
   && (noexcept(eval_multiply(std::declval<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>(), std::declval<const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&>())))
   )
{
   eval_multiply(result, result, val);
}

//
// Now over again for trivial cpp_int's:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_multiply(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.sign(result.sign() != o.sign());
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_multiply(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_multiply(*a.limbs(), *b.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.sign(a.sign() != b.sign());
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
    const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b) noexcept((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))
{
   *result.limbs() = detail::checked_multiply(*a.limbs(), *b.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());
   result.normalize();
}

//
// Special routines for multiplying two integers to obtain a multiprecision result:
//
template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    signed_double_limb_type a, signed_double_limb_type b)
{
   constexpr signed_double_limb_type mask      = static_cast<signed_double_limb_type>(~static_cast<limb_type>(0));
   constexpr std::size_t             limb_bits = static_cast<std::size_t>(sizeof(limb_type) * CHAR_BIT);

   bool s = false;
   if (a < 0)
   {
      a = -a;
      s = true;
   }
   if (b < 0)
   {
      b = -b;
      s = !s;
   }
   double_limb_type w = a & mask;
   double_limb_type x = static_cast<double_limb_type>(a >> limb_bits);
   double_limb_type y = b & mask;
   double_limb_type z = static_cast<double_limb_type>(b >> limb_bits);

   result.resize(4, 4);
   limb_type* pr = result.limbs();

   double_limb_type carry = w * y;
#ifdef __MSVC_RUNTIME_CHECKS
   pr[0] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry >>= limb_bits;
   carry += w * z + x * y;
   pr[1] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry >>= limb_bits;
   carry += x * z;
   pr[2] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   pr[3] = static_cast<limb_type>(carry >> limb_bits);
#else
   pr[0] = static_cast<limb_type>(carry);
   carry >>= limb_bits;
   carry += w * z + x * y;
   pr[1] = static_cast<limb_type>(carry);
   carry >>= limb_bits;
   carry += x * z;
   pr[2] = static_cast<limb_type>(carry);
   pr[3] = static_cast<limb_type>(carry >> limb_bits);
#endif
   result.sign(s);
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    double_limb_type a, double_limb_type b)
{
   constexpr signed_double_limb_type mask      = static_cast<signed_double_limb_type>(~static_cast<limb_type>(0));
   constexpr std::size_t             limb_bits = static_cast<std::size_t>(sizeof(limb_type) * CHAR_BIT);

   double_limb_type w = a & mask;
   double_limb_type x = a >> limb_bits;
   double_limb_type y = b & mask;
   double_limb_type z = b >> limb_bits;

   result.resize(4, 4);
   limb_type* pr = result.limbs();

   double_limb_type carry = w * y;
#ifdef __MSVC_RUNTIME_CHECKS
   pr[0] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry >>= limb_bits;
   carry += w * z;
   pr[1] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry >>= limb_bits;
   pr[2] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry = x * y + pr[1];
   pr[1] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   carry >>= limb_bits;
   carry += pr[2] + x * z;
   pr[2] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));
   pr[3] = static_cast<limb_type>(carry >> limb_bits);
#else
   pr[0] = static_cast<limb_type>(carry);
   carry >>= limb_bits;
   carry += w * z;
   pr[1] = static_cast<limb_type>(carry);
   carry >>= limb_bits;
   pr[2] = static_cast<limb_type>(carry);
   carry = x * y + pr[1];
   pr[1] = static_cast<limb_type>(carry);
   carry >>= limb_bits;
   carry += pr[2] + x * z;
   pr[2] = static_cast<limb_type>(carry);
   pr[3] = static_cast<limb_type>(carry >> limb_bits);
#endif
   result.sign(false);
   result.normalize();
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1,
          std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
    cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> const& a,
    cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> const& b)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>::local_limb_type, cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::type;
   eval_multiply(result, static_cast<canonical_type>(*a.limbs()), static_cast<canonical_type>(*b.limbs()));
   result.sign(a.sign() != b.sign());
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class SI>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (sizeof(SI) <= sizeof(signed_double_limb_type) / 2)>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    SI a, SI b)
{
   result = static_cast<signed_double_limb_type>(a) * static_cast<signed_double_limb_type>(b);
}

template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class UI>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (sizeof(UI) <= sizeof(signed_double_limb_type) / 2)>::type
eval_multiply(
    cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,
    UI a, UI b)
{
   result = static_cast<double_limb_type>(a) * static_cast<double_limb_type>(b);
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/serialize.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_SERIALIZE_HPP
#define BOOST_MP_CPP_INT_SERIALIZE_HPP

#ifndef BOOST_MP_STANDALONE

namespace boost {

namespace archive {

class binary_oarchive;
class binary_iarchive;

} // namespace archive

namespace serialization {

namespace mp = boost::multiprecision;

namespace cpp_int_detail {

using namespace boost::multiprecision;
using namespace boost::multiprecision::backends;

template <class T>
struct is_binary_archive : public std::integral_constant<bool, false>
{};
template <>
struct is_binary_archive<boost::archive::binary_oarchive> : public std::integral_constant<bool, true>
{};
template <>
struct is_binary_archive<boost::archive::binary_iarchive> : public std::integral_constant<bool, true>
{};

//
// We have 8 serialization methods to fill out (and test), they are all permutations of:
// Load vs Store.
// Trivial or non-trivial cpp_int type.
// Binary or not archive.
//
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, false> const&, std::integral_constant<bool, false> const&, std::integral_constant<bool, false> const&)
{
   // Load.
   // Non-trivial.
   // Non binary.

   using boost::make_nvp;
   bool        s;
   ar&         make_nvp("sign", s);
   std::size_t limb_count;
   std::size_t byte_count;
   ar&         make_nvp("byte-count", byte_count);
   limb_count = byte_count / sizeof(limb_type) + ((byte_count % sizeof(limb_type)) ? 1 : 0);
   val.resize(limb_count, limb_count);
   limb_type* pl = val.limbs();
   for (std::size_t i = 0; i < limb_count; ++i)
   {
      pl[i] = 0;
      for (std::size_t j = 0; (j < sizeof(limb_type)) && byte_count; ++j)
      {
         unsigned char byte;
         ar&           make_nvp("byte", byte);
         pl[i] |= static_cast<limb_type>(byte) << (j * CHAR_BIT);
         --byte_count;
      }
   }
   if (s != val.sign())
      val.negate();
   val.normalize();
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, true> const&, std::integral_constant<bool, false> const&, std::integral_constant<bool, false> const&)
{
   // Store.
   // Non-trivial.
   // Non binary.

   using boost::make_nvp;
   bool        s = val.sign();
   ar&         make_nvp("sign", s);
   limb_type*  pl         = val.limbs();
   std::size_t limb_count = val.size();
   std::size_t byte_count = limb_count * sizeof(limb_type);
   ar&         make_nvp("byte-count", byte_count);

   for (std::size_t i = 0; i < limb_count; ++i)
   {
      limb_type l = pl[i];
      for (std::size_t j = 0; j < sizeof(limb_type); ++j)
      {
         unsigned char byte = static_cast<unsigned char>((l >> (j * CHAR_BIT)) & ((1u << CHAR_BIT) - 1));
         ar&           make_nvp("byte", byte);
      }
   }
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, false> const&, std::integral_constant<bool, true> const&, std::integral_constant<bool, false> const&)
{
   // Load.
   // Trivial.
   // Non binary.
   using boost::make_nvp;
   bool                          s;
   typename Int::local_limb_type l = 0;
   ar&                           make_nvp("sign", s);
   std::size_t                   byte_count;
   ar&                           make_nvp("byte-count", byte_count);
   for (std::size_t i = 0; i < byte_count; ++i)
   {
      unsigned char b;
      ar&           make_nvp("byte", b);
      l |= static_cast<typename Int::local_limb_type>(b) << (i * CHAR_BIT);
   }
   *val.limbs() = l;
   if (s != val.sign())
      val.negate();
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, true> const&, std::integral_constant<bool, true> const&, std::integral_constant<bool, false> const&)
{
   // Store.
   // Trivial.
   // Non binary.
   using boost::make_nvp;
   bool                          s = val.sign();
   typename Int::local_limb_type l = *val.limbs();
   ar&                           make_nvp("sign", s);
   std::size_t                   limb_count = sizeof(l);
   ar&                           make_nvp("byte-count", limb_count);
   for (std::size_t i = 0; i < limb_count; ++i)
   {
      unsigned char b = static_cast<unsigned char>(static_cast<typename Int::local_limb_type>(l >> (i * CHAR_BIT)) & static_cast<typename Int::local_limb_type>((1u << CHAR_BIT) - 1));
      ar&           make_nvp("byte", b);
   }
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, false> const&, std::integral_constant<bool, false> const&, std::integral_constant<bool, true> const&)
{
   // Load.
   // Non-trivial.
   // Binary.
   bool        s;
   std::size_t c;
   ar&         s;
   ar&         c;
   val.resize(c, c);
   ar.load_binary(val.limbs(), c * sizeof(limb_type));
   if (s != val.sign())
      val.negate();
   val.normalize();
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, true> const&, std::integral_constant<bool, false> const&, std::integral_constant<bool, true> const&)
{
   // Store.
   // Non-trivial.
   // Binary.
   bool        s = val.sign();
   std::size_t c = val.size();
   ar&         s;
   ar&         c;
   ar.save_binary(val.limbs(), c * sizeof(limb_type));
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, false> const&, std::integral_constant<bool, true> const&, std::integral_constant<bool, true> const&)
{
   // Load.
   // Trivial.
   // Binary.
   bool s;
   ar&  s;
   ar.load_binary(val.limbs(), sizeof(*val.limbs()));
   if (s != val.sign())
      val.negate();
}
template <class Archive, class Int>
void do_serialize(Archive& ar, Int& val, std::integral_constant<bool, true> const&, std::integral_constant<bool, true> const&, std::integral_constant<bool, true> const&)
{
   // Store.
   // Trivial.
   // Binary.
   bool s = val.sign();
   ar&  s;
   ar.save_binary(val.limbs(), sizeof(*val.limbs()));
}

} // namespace cpp_int_detail

template <class Archive, std::size_t MinBits, std::size_t MaxBits, mp::cpp_integer_type SignType, mp::cpp_int_check_type Checked, class Allocator>
void serialize(Archive& ar, mp::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& val, const unsigned int /*version*/)
{
   using archive_save_tag = typename Archive::is_saving                                ;
   using save_tag = std::integral_constant<bool, archive_save_tag::value>      ;
   using trivial_tag = std::integral_constant<bool, mp::backends::is_trivial_cpp_int<mp::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value>;
   using binary_tag = typename cpp_int_detail::is_binary_archive<Archive>::type  ;

   // Just dispatch to the correct method:
   cpp_int_detail::do_serialize(ar, val, save_tag(), trivial_tag(), binary_tag());
}

} // namespace serialization
} // namespace boost

#endif // BOOST_MP_STANDALONE

#endif // BOOST_MP_CPP_INT_SERIALIZE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int/value_pack.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_CPP_INT_VP_HPP
#define BOOST_MP_CPP_INT_VP_HPP

namespace boost {
namespace multiprecision {

namespace literals { namespace detail {

template <limb_type... VALUES>
struct value_pack
{
   constexpr value_pack() {}

   using next_type = value_pack<0, VALUES...>;
};
template <class T>
struct is_value_pack
{
   static constexpr bool value = false;
};
template <limb_type... VALUES>
struct is_value_pack<value_pack<VALUES...> >
{
   static constexpr bool value = true;
};

struct negate_tag
{};

constexpr negate_tag make_negate_tag()
{
   return negate_tag();
}

}}}} // namespace boost::multiprecision::literals::detail

#endif // BOOST_MP_CPP_INT_CORE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/cpp_int.hpp
================================================
////////////////////////////////////////////////////////////////
//  Copyright 2012 - 2022 John Maddock.
//  Copyright 2022 Christopher Kormanyos.
//  Distributed under the Boost Software License,
//  Version 1.0. (See accompanying file LICENSE_1_0.txt
//  or copy at https://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_CPP_INT_HPP
#define BOOST_MP_CPP_INT_HPP

#include <cstdint>
#include <cstring>
#include <iostream>
#include <iomanip>
#include <type_traits>
#include <string>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/endian.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/multiprecision/detail/rebind.hpp>
#include <boost/multiprecision/cpp_int/cpp_int_config.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>
#include <boost/multiprecision/traits/is_byte_container.hpp>
#include <boost/multiprecision/cpp_int/checked.hpp>
#include <boost/multiprecision/detail/constexpr.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/cpp_int/value_pack.hpp>
#include <boost/multiprecision/detail/empty_value.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4307) // integral constant overflow (oveflow is in a branch not taken when it would overflow)
#pragma warning(disable : 4127) // conditional expression is constant
#pragma warning(disable : 4702) // Unreachable code (reachability depends on template params)
#endif
#if defined(__GNUC__) && !defined(__clang__)
// see https://github.com/boostorg/multiprecision/issues/413
// and https://github.com/boostorg/multiprecision/issues/431
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif

template <std::size_t MinBits = 0, std::size_t MaxBits = 0, boost::multiprecision::cpp_integer_type SignType = signed_magnitude, cpp_int_check_type Checked = unchecked, class Allocator = typename std::conditional<MinBits && (MinBits == MaxBits), void, std::allocator<limb_type> >::type>
struct cpp_int_backend;

} // namespace backends

namespace detail {

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct is_byte_container<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> > : public std::false_type
{};

} // namespace detail

namespace backends {

namespace detail {
   template <std::size_t Value1, std::size_t Value2>
   struct static_unsigned_max
   {
      static constexpr std::size_t value = (Value1 > Value2) ? Value1 : Value2;
   };
} // Namespace detail

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, bool trivial = false>
struct cpp_int_base;
//
// Traits class determines the maximum and minimum precision values:
//
template <class T>
struct max_precision;

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct max_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
{
   static constexpr std::size_t value = std::is_void<Allocator>::value ? detail::static_unsigned_max<MinBits, MaxBits>::value
                                                                       : (((MaxBits >= MinBits) && MaxBits) ? MaxBits : SIZE_MAX);
};

template <class T>
struct min_precision;

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct min_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
{
   static constexpr std::size_t value = (std::is_void<Allocator>::value ? detail::static_unsigned_max<MinBits, MaxBits>::value : MinBits);
};
//
// Traits class determines whether the number of bits precision requested could fit in a native type,
// we call this a "trivial" cpp_int:
//
template <class T>
struct is_trivial_cpp_int
{
   static constexpr bool value = false;
};

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
{
   using self = cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>;
   static constexpr bool value = std::is_void<Allocator>::value && (max_precision<self>::value <= (sizeof(double_limb_type) * CHAR_BIT) - (SignType == signed_packed ? 1 : 0));
};

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct is_trivial_cpp_int<cpp_int_base<MinBits, MaxBits, SignType, Checked, Allocator, true> >
{
   static constexpr bool value = true;
};

} // namespace backends
//
// Traits class to determine whether a cpp_int_backend is signed or not:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct is_unsigned_number<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
    : public std::integral_constant<bool, (SignType == unsigned_magnitude) || (SignType == unsigned_packed)>
{};

namespace backends {
//
// Traits class determines whether T should be implicitly convertible to U, or
// whether the constructor should be made explicit.  The latter happens if we
// are losing the sign, or have fewer digits precision in the target type:
//
template <class T, class U>
struct is_implicit_cpp_int_conversion;

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
struct is_implicit_cpp_int_conversion<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >
{
   using t1 = cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>;
   using t2 = cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>;
   static constexpr bool value =
       (is_signed_number<t2>::value || !is_signed_number<t1>::value) && (max_precision<t1>::value <= max_precision<t2>::value);
};

//
// Traits class to determine whether operations on a cpp_int may throw:
//
template <class T>
struct is_non_throwing_cpp_int : public std::integral_constant<bool, false>
{};
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType>
struct is_non_throwing_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, unchecked, void> > : public std::integral_constant<bool, true>
{};

//
// Traits class, determines whether the cpp_int is fixed precision or not:
//
template <class T>
struct is_fixed_precision;
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct is_fixed_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
    : public std::integral_constant<bool, max_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value != SIZE_MAX>
{};

namespace detail {

inline BOOST_MP_CXX14_CONSTEXPR void verify_new_size(std::size_t new_size, std::size_t min_size, const std::integral_constant<int, checked>&)
{
   if (new_size < min_size)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Unable to allocate sufficient storage for the value of the result: value overflows the maximum allowable magnitude."));
}
inline BOOST_MP_CXX14_CONSTEXPR void verify_new_size(std::size_t /*new_size*/, std::size_t /*min_size*/, const std::integral_constant<int, unchecked>&) {}

template <class U>
inline BOOST_MP_CXX14_CONSTEXPR void verify_limb_mask(bool b, U limb, U mask, const std::integral_constant<int, checked>&)
{
   // When we mask out "limb" with "mask", do we loose bits?  If so it's an overflow error:
   if (b && (limb & ~mask))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Overflow in cpp_int arithmetic: there is insufficient precision in the target type to hold all of the bits of the result."));
}
template <class U>
inline BOOST_MP_CXX14_CONSTEXPR void verify_limb_mask(bool /*b*/, U /*limb*/, U /*mask*/, const std::integral_constant<int, unchecked>&) {}

} // namespace detail

//
// Now define the various data layouts that are possible as partial specializations of the base class,
// starting with the default arbitrary precision signed integer type:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
struct cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false>
    : private boost::multiprecision::detail::empty_value<typename detail::rebind<limb_type, Allocator>::type>
{
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, bool trivial2>
   friend struct cpp_int_base;

   using allocator_type = typename detail::rebind<limb_type, Allocator>::type;
   using limb_pointer = typename std::allocator_traits<allocator_type>::pointer      ;
   using const_limb_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
   using checked_type = std::integral_constant<int, Checked>;

   //
   // Interface invariants:
   //
   static_assert(!std::is_void<Allocator>::value, "Allocator must not be void here");

   using base_type = boost::multiprecision::detail::empty_value<allocator_type>;

private:
   struct limb_data
   {
      std::size_t        capacity;
      limb_pointer    data;
   };

 public:
   static constexpr std::size_t limb_bits           = sizeof(limb_type) * CHAR_BIT;
   static constexpr limb_type   max_limb_value      = ~static_cast<limb_type>(0u);
   static constexpr limb_type   sign_bit_mask       = static_cast<limb_type>(1u) << (limb_bits - 1);
   static constexpr std::size_t internal_limb_count =
                                       MinBits
                                           ? (MinBits / limb_bits + ((MinBits % limb_bits) ? 1 : 0))
                                           : (sizeof(limb_data) / sizeof(limb_type)) > 1 ? (sizeof(limb_data) / sizeof(limb_type)) : 2;
 private:
   union data_type
   {
      limb_data        ld;
      limb_type        la[internal_limb_count];
      limb_type        first;
      double_limb_type double_first;

      constexpr data_type() noexcept : first(0) {}
      constexpr data_type(limb_type i) noexcept : first(i) {}
      constexpr data_type(signed_limb_type i) noexcept : first(static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(i))) {}
#if BOOST_MP_ENDIAN_LITTLE_BYTE
      constexpr data_type(double_limb_type i) noexcept : double_first(i)
      {}
      constexpr data_type(signed_double_limb_type i) noexcept : double_first(static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i))) {}
#endif
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !(defined(BOOST_MSVC) && (BOOST_MSVC < 1900))
      constexpr data_type(limb_type* limbs, std::size_t len) noexcept : ld{ len, limbs }
      {}
#else
      constexpr data_type(limb_type* limbs, std::size_t len) noexcept
      {
         ld.capacity = len;
         ld.data = limbs;
      }
#endif
   };

   data_type m_data;
   std::size_t  m_limbs;
   bool      m_sign, m_internal, m_alias;

 public:
   //
   // Direct construction:
   //
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(limb_type i) noexcept
       : m_data(i),
         m_limbs(1),
         m_sign(false),
         m_internal(true),
         m_alias(false) {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(signed_limb_type i) noexcept
       : m_data(i),
         m_limbs(1),
         m_sign(i < 0),
         m_internal(true),
         m_alias(false) {}
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(double_limb_type i) noexcept
       : m_data(i),
         m_limbs(i > max_limb_value ? 2 : 1),
         m_sign(false),
         m_internal(true),
         m_alias(false)
   {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(signed_double_limb_type i) noexcept
       : m_data(i),
         m_limbs(i < 0 ? (static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i)) > static_cast<double_limb_type>(max_limb_value) ? 2 : 1) : (i > max_limb_value ? 2 : 1)),
         m_sign(i < 0),
         m_internal(true),
         m_alias(false) {}
#endif
   //
   // Aliasing constructor aliases data:
   //
   struct scoped_shared_storage : private boost::multiprecision::detail::empty_value<allocator_type>
   {
    private:
      limb_type*      data;
      std::size_t        capacity;
      std::size_t        allocated;
      bool            is_alias;
      allocator_type& allocator() noexcept { return boost::multiprecision::detail::empty_value<allocator_type>::get(); }

    public:
      scoped_shared_storage(const allocator_type& a, std::size_t len)
          : boost::multiprecision::detail::empty_value<allocator_type>(boost::multiprecision::detail::empty_init_t(), a), capacity(len), allocated(0), is_alias(false)
      {
         data = allocator().allocate(len);
      }
      scoped_shared_storage(const cpp_int_base& i, std::size_t len)
          : boost::multiprecision::detail::empty_value<allocator_type>(boost::multiprecision::detail::empty_init_t(), i.allocator()), capacity(len), allocated(0), is_alias(false)
      {
         data = allocator().allocate(len);
      }
      scoped_shared_storage(limb_type* limbs, std::size_t n) : data(limbs), capacity(n), allocated(0), is_alias(true) {}
      ~scoped_shared_storage()
      {
         if(!is_alias)
            allocator().deallocate(data, capacity);
      }
      limb_type* allocate(std::size_t n) noexcept 
      {
         limb_type* result = data + allocated;
         allocated += n;
         BOOST_MP_ASSERT(allocated <= capacity);
         return result; 
      }
      void deallocate(std::size_t n)
      {
         BOOST_MP_ASSERT(n <= allocated);
         allocated -= n;
      }
   };
   explicit constexpr cpp_int_base(limb_type* data, std::size_t offset, std::size_t len) noexcept
       : m_data(data + offset, len),
         m_limbs(len),
         m_sign(false),
         m_internal(false),
         m_alias(true) {}
   // This next constructor is for constructing const objects from const limb_type*'s only.
   // Unfortunately we appear to have no way to assert that within the language, and the const_cast
   // is a side effect of that :(
   explicit constexpr cpp_int_base(const limb_type* data, std::size_t offset, std::size_t len) noexcept
       : m_data(const_cast<limb_type*>(data) + offset, len),
         m_limbs(len),
         m_sign(false),
         m_internal(false),
         m_alias(true) {}
   explicit cpp_int_base(scoped_shared_storage& data, std::size_t len) noexcept
       : m_data(data.allocate(len), len),
         m_limbs(len),
         m_sign(false),
         m_internal(false),
         m_alias(true) {}
   //
   // Helper functions for getting at our internal data, and manipulating storage:
   //
   BOOST_MP_FORCEINLINE allocator_type&       allocator() noexcept { return base_type::get(); }
   BOOST_MP_FORCEINLINE const allocator_type& allocator() const noexcept { return base_type::get(); }
   BOOST_MP_FORCEINLINE std::size_t              size() const noexcept { return m_limbs; }
   BOOST_MP_FORCEINLINE limb_pointer          limbs() noexcept { return m_internal ? m_data.la : m_data.ld.data; }
   BOOST_MP_FORCEINLINE const_limb_pointer    limbs() const noexcept { return m_internal ? m_data.la : m_data.ld.data; }
   BOOST_MP_FORCEINLINE std::size_t              capacity() const noexcept { return m_internal ? internal_limb_count : m_data.ld.capacity; }
   BOOST_MP_FORCEINLINE bool                  sign() const noexcept { return m_sign; }
   void                                       sign(bool b) noexcept
   {
      m_sign = b;
      // Check for zero value:
      if (m_sign && (m_limbs == 1))
      {
         if (limbs()[0] == 0)
            m_sign = false;
      }
   }
   void resize(std::size_t new_size, std::size_t min_size)
   {
      constexpr std::size_t max_limbs = MaxBits / (CHAR_BIT * sizeof(limb_type)) + ((MaxBits % (CHAR_BIT * sizeof(limb_type))) ? 1 : 0);
      // We never resize beyond MaxSize:
      if (new_size > max_limbs)
         new_size = max_limbs;
      detail::verify_new_size(new_size, min_size, checked_type());
      // See if we have enough capacity already:
      std::size_t cap = capacity();
      if (new_size > cap)
      {
         // We must not be an alias, memory allocation here defeats the whole point of aliasing:
         BOOST_MP_ASSERT(!m_alias);
         // Allocate a new buffer and copy everything over:
         cap             = (std::min)((std::max)(cap * 4, new_size), max_limbs);
         limb_pointer pl = allocator().allocate(cap);
         std::memcpy(pl, limbs(), size() * sizeof(limbs()[0]));
         if (!m_internal && !m_alias)
            allocator().deallocate(limbs(), capacity());
         else
            m_internal = false;
         m_limbs            = new_size;
         m_data.ld.capacity = cap;
         m_data.ld.data     = pl;
      }
      else
      {
         m_limbs = new_size;
      }
   }
   BOOST_MP_FORCEINLINE void normalize() noexcept
   {
      limb_pointer p = limbs();
      while ((m_limbs - 1) && !p[m_limbs - 1])
         --m_limbs;
   }
   BOOST_MP_FORCEINLINE constexpr cpp_int_base() noexcept : m_data(), m_limbs(1), m_sign(false), m_internal(true), m_alias(false){}
   BOOST_MP_FORCEINLINE                 cpp_int_base(const cpp_int_base& o) : base_type(o), m_limbs(o.m_alias ? o.m_limbs : 0), m_sign(o.m_sign), m_internal(o.m_alias ? false : true), m_alias(o.m_alias)
   {
      if (m_alias)
      {
         m_data.ld = o.m_data.ld;
      }
      else
      {
         resize(o.size(), o.size());
         std::memcpy(limbs(), o.limbs(), o.size() * sizeof(limbs()[0]));
      }
   }
   // rvalue copy:
   cpp_int_base(cpp_int_base&& o)
      : base_type(static_cast<base_type&&>(o)), m_limbs(o.m_limbs), m_sign(o.m_sign), m_internal(o.m_internal), m_alias(o.m_alias)
   {
      if (m_internal)
      {
         std::memcpy(limbs(), o.limbs(), o.size() * sizeof(limbs()[0]));
      }
      else
      {
         m_data.ld = o.m_data.ld;
         o.m_limbs = 0;
         o.m_internal = true;
      }
   }
   cpp_int_base& operator=(cpp_int_base&& o) noexcept
   {
      if (!m_internal && !m_alias)
         allocator().deallocate(m_data.ld.data, m_data.ld.capacity);
      *static_cast<base_type*>(this) = static_cast<base_type&&>(o);
      m_limbs = o.m_limbs;
      m_sign = o.m_sign;
      m_internal = o.m_internal;
      m_alias = o.m_alias;
      if (m_internal)
      {
         std::memcpy(limbs(), o.limbs(), o.size() * sizeof(limbs()[0]));
      }
      else
      {
         m_data.ld = o.m_data.ld;
         o.m_limbs = 0;
         o.m_internal = true;
      }
      return *this;
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_int_check_type Checked2>
   cpp_int_base& operator=(cpp_int_base<MinBits2, MaxBits2, signed_magnitude, Checked2, Allocator>&& o) noexcept
   {
      if(o.m_internal)
      {
         m_sign = o.m_sign;
         this->resize(o.size(), o.size());
         std::memcpy(this->limbs(), o.limbs(), o.size() * sizeof(*(o.limbs())));
         return *this;
      }
      if (!m_internal && !m_alias)
         allocator().deallocate(m_data.ld.data, m_data.ld.capacity);
      *static_cast<base_type*>(this) = static_cast<typename cpp_int_base<MinBits2, MaxBits2, signed_magnitude, Checked2, Allocator>::base_type&&>(o);
      m_limbs                        = o.m_limbs;
      m_sign                         = o.m_sign;
      m_internal                     = o.m_internal;
      m_alias                        = o.m_alias;
      m_data.ld.capacity             = o.m_data.ld.capacity;
      m_data.ld.data                 = o.limbs();
      o.m_limbs                      = 0;
      o.m_internal                   = true;
      return *this;
   }
   BOOST_MP_FORCEINLINE ~cpp_int_base() noexcept
   {
      if (!m_internal && !m_alias)
         allocator().deallocate(limbs(), capacity());
   }
   void assign(const cpp_int_base& o)
   {
      if (this != &o)
      {
         static_cast<base_type&>(*this) = static_cast<const base_type&>(o);
         m_limbs                        = 0;
         resize(o.size(), o.size());
         std::memcpy(limbs(), o.limbs(), o.size() * sizeof(limbs()[0]));
         m_sign = o.m_sign;
      }
   }
   BOOST_MP_FORCEINLINE void negate() noexcept
   {
      m_sign = !m_sign;
      // Check for zero value:
      if (m_sign && (m_limbs == 1))
      {
         if (limbs()[0] == 0)
            m_sign = false;
      }
   }
   BOOST_MP_FORCEINLINE bool isneg() const noexcept
   {
      return m_sign;
   }
   BOOST_MP_FORCEINLINE void do_swap(cpp_int_base& o) noexcept
   {
      std::swap(m_data, o.m_data);
      std::swap(m_sign, o.m_sign);
      std::swap(m_internal, o.m_internal);
      std::swap(m_limbs, o.m_limbs);
      std::swap(m_alias, o.m_alias);
   }

 protected:
   template <class A>
   void check_in_range(const A&) noexcept {}
};

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
constexpr std::size_t cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false>::limb_bits;
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
constexpr limb_type cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false>::max_limb_value;
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
constexpr limb_type cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false>::sign_bit_mask;
template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
constexpr std::size_t cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false>::internal_limb_count;

template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
struct cpp_int_base<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator, false>
    : private boost::multiprecision::detail::empty_value<typename detail::rebind<limb_type, Allocator>::type>
{
   //
   // There is currently no support for unsigned arbitrary precision arithmetic, largely
   // because it's not clear what subtraction should do:
   //
   static_assert(((sizeof(Allocator) == 0) && !std::is_void<Allocator>::value), "There is curently no support for unsigned arbitrary precision integers.");
};
//
// Fixed precision (i.e. no allocator), signed-magnitude type with limb-usage count:
//
template <std::size_t MinBits, cpp_int_check_type Checked>
struct cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, false>
{
   using limb_pointer = limb_type*        ;
   using const_limb_pointer = const limb_type*  ;
   using checked_type = std::integral_constant<int, Checked>;

   struct scoped_shared_storage 
   {
      BOOST_MP_CXX14_CONSTEXPR  scoped_shared_storage(const cpp_int_base&, std::size_t) {}
      BOOST_MP_CXX14_CONSTEXPR void deallocate(std::size_t) {}
   };

   //
   // Interface invariants:
   //
   static_assert(MinBits > sizeof(double_limb_type) * CHAR_BIT, "Template parameter MinBits is inconsistent with the parameter trivial - did you mistakingly try to override the trivial parameter?");

 public:
   static constexpr std::size_t limb_bits = sizeof(limb_type) * CHAR_BIT;
   static constexpr limb_type max_limb_value = ~static_cast<limb_type>(0u);
   static constexpr limb_type sign_bit_mask = static_cast<limb_type>(1u) << (limb_bits - 1);
   static constexpr std::size_t  internal_limb_count = MinBits / limb_bits + ((MinBits % limb_bits) ? 1 : 0);
   static constexpr limb_type upper_limb_mask = (MinBits % limb_bits) ? (limb_type(1) << (MinBits % limb_bits)) - 1 : (~limb_type(0));
   static_assert(internal_limb_count >= 2, "A fixed precision integer type must have at least 2 limbs");

 private:
   union data_type
   {
      limb_type        m_data[internal_limb_count];
      limb_type        m_first_limb;
      double_limb_type m_double_first_limb;

      constexpr data_type()
          : m_data{0}
      {}
      constexpr data_type(limb_type i)
          : m_data{i}
      {}
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
      constexpr data_type(limb_type i, limb_type j) : m_data{i, j}
      {}
#endif
      constexpr data_type(double_limb_type i) : m_double_first_limb(i)
      {
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
         if (BOOST_MP_IS_CONST_EVALUATED(m_double_first_limb))
         {
            data_type t(static_cast<limb_type>(i & max_limb_value), static_cast<limb_type>(i >> limb_bits));
            *this = t;
         }
#endif
      }
      template <limb_type... VALUES>
      constexpr data_type(literals::detail::value_pack<VALUES...>) : m_data{VALUES...}
      {}
   } m_wrapper;
   std::uint16_t m_limbs;
   bool            m_sign;

 public:
   //
   // Direct construction:
   //
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(limb_type i) noexcept
       : m_wrapper(i),
         m_limbs(1),
         m_sign(false) {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(signed_limb_type i) noexcept
       : m_wrapper(limb_type(i < 0 ? static_cast<limb_type>(-static_cast<signed_double_limb_type>(i)) : i)),
         m_limbs(1),
         m_sign(i < 0) {}
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(double_limb_type i) noexcept
       : m_wrapper(i),
         m_limbs(i > max_limb_value ? 2 : 1),
         m_sign(false)
   {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(signed_double_limb_type i) noexcept
       : m_wrapper(double_limb_type(i < 0 ? static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i)) : i)),
         m_limbs(i < 0 ? (static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i)) > max_limb_value ? 2 : 1) : (i > max_limb_value ? 2 : 1)),
         m_sign(i < 0) {}
#endif
   template <limb_type... VALUES>
   constexpr cpp_int_base(literals::detail::value_pack<VALUES...> i)
       : m_wrapper(i), m_limbs(sizeof...(VALUES)), m_sign(false)
   {}
   constexpr cpp_int_base(literals::detail::value_pack<> i)
       : m_wrapper(i), m_limbs(1), m_sign(false) {}
   constexpr cpp_int_base(const cpp_int_base& a, const literals::detail::negate_tag&)
       : m_wrapper(a.m_wrapper), m_limbs(a.m_limbs), m_sign((a.m_limbs == 1) && (*a.limbs() == 0) ? false : !a.m_sign) {}
   explicit constexpr cpp_int_base(scoped_shared_storage&, std::size_t) noexcept : m_wrapper(), m_limbs(0), m_sign(false)
   {}
   //
   // These are deprecated in C++20 unless we make them explicit:
   //
   BOOST_MP_CXX14_CONSTEXPR cpp_int_base& operator=(const cpp_int_base&) = default;
   //
   // Helper functions for getting at our internal data, and manipulating storage:
   //
   BOOST_MP_FORCEINLINE constexpr std::size_t              size() const noexcept { return m_limbs; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR limb_pointer limbs() noexcept { return m_wrapper.m_data; }
   BOOST_MP_FORCEINLINE constexpr const_limb_pointer    limbs() const noexcept { return m_wrapper.m_data; }
   BOOST_MP_FORCEINLINE constexpr bool                  sign() const noexcept { return m_sign; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void         sign(bool b) noexcept
   {
      m_sign = b;
      // Check for zero value:
      if (m_sign && (m_limbs == 1))
      {
         if (limbs()[0] == 0)
            m_sign = false;
      }
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void resize(std::size_t new_size, std::size_t min_size) noexcept((Checked == unchecked))
   {
      m_limbs = static_cast<std::uint16_t>((std::min)(new_size, internal_limb_count));
      detail::verify_new_size(m_limbs, min_size, checked_type());
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void normalize() noexcept((Checked == unchecked))
   {
      limb_pointer p = limbs();
      detail::verify_limb_mask(m_limbs == internal_limb_count, p[m_limbs - 1], upper_limb_mask, checked_type());
      p[internal_limb_count - 1] &= upper_limb_mask;
      while ((m_limbs - 1) && !p[m_limbs - 1])
         --m_limbs;
      if ((m_limbs == 1) && (!*p))
         m_sign = false; // zero is always unsigned
   }

   BOOST_MP_FORCEINLINE constexpr cpp_int_base() noexcept : m_wrapper(limb_type(0u)), m_limbs(1), m_sign(false) {}
   // Not defaulted, it breaks constexpr support in the Intel compiler for some reason:
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(const cpp_int_base& o) noexcept
       : m_wrapper(o.m_wrapper),
         m_limbs(o.m_limbs),
         m_sign(o.m_sign) {}
   // Defaulted functions:
   //~cpp_int_base() noexcept {}

   void BOOST_MP_CXX14_CONSTEXPR assign(const cpp_int_base& o) noexcept
   {
      if (this != &o)
      {
         m_limbs = o.m_limbs;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
         if (BOOST_MP_IS_CONST_EVALUATED(m_limbs))
         {
            for (std::size_t i = 0; i < m_limbs; ++i)
               limbs()[i] = o.limbs()[i];
         }
         else
#endif
            std::memcpy(limbs(), o.limbs(), o.size() * sizeof(o.limbs()[0]));
         m_sign = o.m_sign;
      }
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void negate() noexcept
   {
      m_sign = !m_sign;
      // Check for zero value:
      if (m_sign && (m_limbs == 1))
      {
         if (limbs()[0] == 0)
            m_sign = false;
      }
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool isneg() const noexcept
   {
      return m_sign;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void do_swap(cpp_int_base& o) noexcept
   {
      for (std::size_t i = 0; i < (std::max)(size(), o.size()); ++i)
         std_constexpr::swap(m_wrapper.m_data[i], o.m_wrapper.m_data[i]);
      std_constexpr::swap(m_sign, o.m_sign);
      std_constexpr::swap(m_limbs, o.m_limbs);
   }

 protected:
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR void check_in_range(const A&) noexcept {}
};

template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr std::size_t cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, false>::limb_bits;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr limb_type cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, false>::max_limb_value;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr limb_type cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, false>::sign_bit_mask;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr std::size_t cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, false>::internal_limb_count;
//
// Fixed precision (i.e. no allocator), unsigned type with limb-usage count:
//
template <std::size_t MinBits, cpp_int_check_type Checked>
struct cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, false>
{
   using limb_pointer = limb_type*        ;
   using const_limb_pointer = const limb_type*  ;
   using checked_type = std::integral_constant<int, Checked>;

   struct scoped_shared_storage 
   {
      BOOST_MP_CXX14_CONSTEXPR scoped_shared_storage(const cpp_int_base&, std::size_t) {}
      BOOST_MP_CXX14_CONSTEXPR void deallocate(std::size_t) {}
   };
   //
   // Interface invariants:
   //
   static_assert(MinBits > sizeof(double_limb_type) * CHAR_BIT, "Template parameter MinBits is inconsistent with the parameter trivial - did you mistakingly try to override the trivial parameter?");

 public:
   static constexpr std::size_t limb_bits = sizeof(limb_type) * CHAR_BIT;
   static constexpr limb_type max_limb_value = ~static_cast<limb_type>(0u);
   static constexpr limb_type sign_bit_mask = static_cast<limb_type>(1u) << (limb_bits - 1);
   static constexpr std::size_t internal_limb_count = MinBits / limb_bits + ((MinBits % limb_bits) ? 1 : 0);
   static constexpr limb_type upper_limb_mask = (MinBits % limb_bits) ? (limb_type(1) << (MinBits % limb_bits)) - 1 : (~limb_type(0));
   static_assert(internal_limb_count >= 2, "A fixed precision integer type must have at least 2 limbs");

 private:
   union data_type
   {
      limb_type        m_data[internal_limb_count];
      limb_type        m_first_limb;
      double_limb_type m_double_first_limb;

      constexpr data_type()
          : m_data{0}
      {}
      constexpr data_type(limb_type i)
          : m_data{i}
      {}
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
      constexpr data_type(limb_type i, limb_type j) : m_data{i, j}
      {}
#endif
      constexpr data_type(double_limb_type i) : m_double_first_limb(i)
      {
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
         if (BOOST_MP_IS_CONST_EVALUATED(m_double_first_limb))
         {
            data_type t(static_cast<limb_type>(i & max_limb_value), static_cast<limb_type>(i >> limb_bits));
            *this = t;
         }
#endif
      }
      template <limb_type... VALUES>
      constexpr data_type(literals::detail::value_pack<VALUES...>) : m_data{VALUES...}
      {}
   } m_wrapper;
   std::size_t m_limbs;

 public:
   //
   // Direct construction:
   //
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(limb_type i) noexcept
       : m_wrapper(i),
         m_limbs(1) {}
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(signed_limb_type i) noexcept((Checked == unchecked))
       : m_wrapper(static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(i))),
         m_limbs(1)
   {
      if (i < 0)
         negate();
   }
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(double_limb_type i) noexcept
       : m_wrapper(i),
         m_limbs(i > max_limb_value ? 2 : 1)
   {}
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(signed_double_limb_type i) noexcept((Checked == unchecked))
       : m_wrapper(double_limb_type(i < 0 ? static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i)) : i)),
         m_limbs(i < 0 ? (static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i)) > max_limb_value ? 2 : 1) : (i > max_limb_value ? 2 : 1))
   {
      if (i < 0)
         negate();
   }
#endif
   template <limb_type... VALUES>
   constexpr cpp_int_base(literals::detail::value_pack<VALUES...> i)
       : m_wrapper(i), m_limbs(sizeof...(VALUES))
   {}
   constexpr cpp_int_base(literals::detail::value_pack<>)
       : m_wrapper(static_cast<limb_type>(0u)), m_limbs(1) {}
   explicit constexpr cpp_int_base(scoped_shared_storage&, std::size_t) noexcept : m_wrapper(), m_limbs(1)
   {}
       //
   // Helper functions for getting at our internal data, and manipulating storage:
   //
   BOOST_MP_FORCEINLINE constexpr std::size_t              size() const noexcept { return m_limbs; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR limb_pointer limbs() noexcept { return m_wrapper.m_data; }
   BOOST_MP_FORCEINLINE constexpr const_limb_pointer    limbs() const noexcept { return m_wrapper.m_data; }
   BOOST_MP_FORCEINLINE constexpr bool                  sign() const noexcept { return false; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void         sign(bool b) noexcept((Checked == unchecked))
   {
      if (b)
         negate();
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void resize(std::size_t new_size, std::size_t min_size) noexcept((Checked == unchecked))
   {
      m_limbs = (std::min)(new_size, internal_limb_count);
      detail::verify_new_size(m_limbs, min_size, checked_type());
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void normalize() noexcept((Checked == unchecked))
   {
      limb_pointer p = limbs();
      detail::verify_limb_mask(m_limbs == internal_limb_count, p[internal_limb_count - 1], upper_limb_mask, checked_type());
      p[internal_limb_count - 1] &= upper_limb_mask;
      while ((m_limbs - 1) && !p[m_limbs - 1])
         --m_limbs;
   }

   BOOST_MP_FORCEINLINE constexpr cpp_int_base() noexcept
       : m_wrapper(limb_type(0u)),
         m_limbs(1) {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(const cpp_int_base& o) noexcept
       : m_wrapper(o.m_wrapper),
         m_limbs(o.m_limbs) {}
   // Defaulted functions:
   //~cpp_int_base() noexcept {}
   //
   // These are deprecated in C++20 unless we make them explicit:
   //
   BOOST_MP_CXX14_CONSTEXPR cpp_int_base& operator=(const cpp_int_base&) = default;

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void assign(const cpp_int_base& o) noexcept
   {
      if (this != &o)
      {
         m_limbs = o.m_limbs;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
         if (BOOST_MP_IS_CONST_EVALUATED(m_limbs))
         {
            for (std::size_t i = 0; i < m_limbs; ++i)
               limbs()[i] = o.limbs()[i];
         }
         else
#endif
            std::memcpy(limbs(), o.limbs(), o.size() * sizeof(limbs()[0]));
      }
   }

 private:
   void check_negate(const std::integral_constant<int, checked>&)
   {
      BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to negate an unsigned number."));
   }
   BOOST_MP_CXX14_CONSTEXPR void check_negate(const std::integral_constant<int, unchecked>&) {}

 public:
   BOOST_MP_CXX14_CONSTEXPR void negate() noexcept((Checked == unchecked))
   {
      // Not so much a negate as a complement - this gets called when subtraction
      // would result in a "negative" number:
      if ((m_limbs == 1) && (m_wrapper.m_data[0] == 0))
         return; // negating zero is always zero, and always OK.
      check_negate(checked_type());
      std::size_t i = m_limbs;
      for (; i < internal_limb_count; ++i)
         m_wrapper.m_data[i] = 0;
      m_limbs = internal_limb_count;
      for (i = 0; i < internal_limb_count; ++i)
         m_wrapper.m_data[i] = ~m_wrapper.m_data[i];
      normalize();
      eval_increment(static_cast<cpp_int_backend<MinBits, MinBits, unsigned_magnitude, Checked, void>&>(*this));
   }
   BOOST_MP_FORCEINLINE constexpr bool isneg() const noexcept
   {
      return false;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void do_swap(cpp_int_base& o) noexcept
   {
      for (std::size_t i = 0; i < (std::max)(size(), o.size()); ++i)
         std_constexpr::swap(m_wrapper.m_data[i], o.m_wrapper.m_data[i]);
      std_constexpr::swap(m_limbs, o.m_limbs);
   }

 protected:
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR void check_in_range(const A&) noexcept {}
};

template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr std::size_t cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, false>::limb_bits;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr limb_type cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, false>::max_limb_value;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr limb_type cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, false>::sign_bit_mask;
template <std::size_t MinBits, cpp_int_check_type Checked>
constexpr std::size_t cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, false>::internal_limb_count;
//
// Traits classes to figure out a native type with N bits, these vary from boost::uint_t<N> only
// because some platforms have native integer types longer than long long, "really long long" anyone??
//
template <unsigned N, bool s>
struct trivial_limb_type_imp
{
   using type = double_limb_type;
};

template <unsigned N>
struct trivial_limb_type_imp<N, true>
{
   using type = typename boost::multiprecision::detail::uint_t<N>::least;
};

template <unsigned N>
struct trivial_limb_type : public trivial_limb_type_imp<N, N <= sizeof(long long) * CHAR_BIT>
{};
//
// Backend for fixed precision signed-magnitude type which will fit entirely inside a "double_limb_type":
//
template <std::size_t MinBits, cpp_int_check_type Checked>
struct cpp_int_base<MinBits, MinBits, signed_magnitude, Checked, void, true>
{
   using local_limb_type = typename trivial_limb_type<static_cast<unsigned>(MinBits)>::type;
   using limb_pointer = local_limb_type*;
   using const_limb_pointer = const local_limb_type*;
   using checked_type = std::integral_constant<int, Checked>;

   struct scoped_shared_storage 
   {
      BOOST_MP_CXX14_CONSTEXPR      scoped_shared_storage(const cpp_int_base&, std::size_t) {}
      BOOST_MP_CXX14_CONSTEXPR void deallocate(std::size_t) {}
   };

 protected:
   static constexpr std::size_t limb_bits = sizeof(local_limb_type) * CHAR_BIT;
   static constexpr local_limb_type limb_mask = (MinBits < limb_bits) ? local_limb_type((local_limb_type(~local_limb_type(0))) >> (limb_bits - MinBits)) : local_limb_type(~local_limb_type(0));

 private:
   local_limb_type m_data;
   bool            m_sign;

   //
   // Interface invariants:
   //
   static_assert(MinBits <= sizeof(double_limb_type) * CHAR_BIT, "Template parameter MinBits is inconsistent with the parameter trivial - did you mistakingly try to override the trivial parameter?");

 protected:
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(!boost::multiprecision::detail::is_integral<T>::value || (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::digits <= static_cast<int>(MinBits))))>::type
   check_in_range(T val, const std::integral_constant<int, checked>&)
   {
      using common_type = typename std::common_type<typename boost::multiprecision::detail::make_unsigned<T>::type, local_limb_type>::type;

      if (static_cast<common_type>(boost::multiprecision::detail::unsigned_abs(val)) > static_cast<common_type>(limb_mask))
         BOOST_MP_THROW_EXCEPTION(std::range_error("The argument to a cpp_int constructor exceeded the largest value it can represent."));
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::detail::is_integral<T>::value || (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::digits <= static_cast<int>(MinBits))))>::type
   check_in_range(T val, const std::integral_constant<int, checked>&)
   {
      using std::abs;
      using common_type = typename std::common_type<T, local_limb_type>::type;

      if (static_cast<common_type>(abs(val)) > static_cast<common_type>(limb_mask))
         BOOST_MP_THROW_EXCEPTION(std::range_error("The argument to a cpp_int constructor exceeded the largest value it can represent."));
   }
   template <class T, int C>
   BOOST_MP_CXX14_CONSTEXPR void check_in_range(T, const std::integral_constant<int, C>&) noexcept {}

   template <class T>
   BOOST_MP_CXX14_CONSTEXPR void check_in_range(T val) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<T>(), checked_type())))
   {
      check_in_range(val, checked_type());
   }

 public:
   //
   // Direct construction:
   //
   template <class SI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<SI>())))
       : m_data(i < 0 ? static_cast<local_limb_type>(static_cast<typename boost::multiprecision::detail::make_unsigned<SI>::type>(boost::multiprecision::detail::unsigned_abs(i)) & limb_mask) : static_cast<local_limb_type>(i & limb_mask)), m_sign(i < 0) {}
   template <class SI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<SI>())))
       : m_data(i < 0 ? (static_cast<local_limb_type>(static_cast<typename boost::multiprecision::detail::make_unsigned<SI>::type>(boost::multiprecision::detail::unsigned_abs(i)) & limb_mask)) : static_cast<local_limb_type>(i & limb_mask)), m_sign(i < 0)
   {
      check_in_range(i);
   }
   template <class UI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(static_cast<local_limb_type>(i) & limb_mask),
         m_sign(false) {}
   template <class UI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<UI>())))
       : m_data(static_cast<local_limb_type>(i) & limb_mask), m_sign(false) { check_in_range(i); }
#if !(defined(__clang__) && defined(__MINGW32__))
   template <class F>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(F i, typename std::enable_if<std::is_floating_point<F>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(static_cast<local_limb_type>(i < 0 ? -i : i) & limb_mask),
         m_sign(i < 0) {}
   template <class F>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(F i, typename std::enable_if<std::is_floating_point<F>::value && (Checked == checked)>::type const* = nullptr)
       : m_data(static_cast<local_limb_type>(i < 0 ? -i : i) & limb_mask), m_sign(i < 0) { check_in_range(i); }
#else
   //
   // conversion from float to __int128 is broken on clang/mingw, 
   // see: https://bugs.llvm.org/show_bug.cgi?id=48940
   // Since no floating point type has more than 64 bits of
   // precision, we can simply cast to an intermediate type to
   // solve the issue:
   //
   template <class F>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(F i, typename std::enable_if<std::is_floating_point<F>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(static_cast<local_limb_type>(static_cast<std::uint64_t>(i < 0 ? -i : i)) & limb_mask),
         m_sign(i < 0) {}
   template <class F>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(F i, typename std::enable_if<std::is_floating_point<F>::value && (Checked == checked)>::type const* = nullptr)
       : m_data(static_cast<local_limb_type>(static_cast<std::uint64_t>(i < 0 ? -i : i)) & limb_mask), m_sign(i < 0) { check_in_range(i); }
#endif

   constexpr cpp_int_base(literals::detail::value_pack<>) noexcept
       : m_data(static_cast<local_limb_type>(0u)),
         m_sign(false)
   {}
   template <limb_type a>
   constexpr cpp_int_base(literals::detail::value_pack<a>) noexcept
       : m_data(static_cast<local_limb_type>(a)),
         m_sign(false) {}
   template <limb_type a, limb_type b>
   constexpr cpp_int_base(literals::detail::value_pack<a, b>) noexcept
       : m_data(static_cast<local_limb_type>(a) | (static_cast<local_limb_type>(b) << bits_per_limb)),
         m_sign(false) {}
   constexpr cpp_int_base(const cpp_int_base& a, const literals::detail::negate_tag&) noexcept
       : m_data(a.m_data),
         m_sign(a.m_data ? !a.m_sign : false) {}
   //
   // These are deprecated in C++20 unless we make them explicit:
   //
   BOOST_MP_CXX14_CONSTEXPR cpp_int_base& operator=(const cpp_int_base&) = default;

   explicit constexpr cpp_int_base(scoped_shared_storage&, std::size_t) noexcept : m_data(0), m_sign(false)
   {}
       //
   // Helper functions for getting at our internal data, and manipulating storage:
   //
   BOOST_MP_FORCEINLINE constexpr std::size_t              size() const noexcept { return 1; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR limb_pointer limbs() noexcept { return &m_data; }
   BOOST_MP_FORCEINLINE constexpr const_limb_pointer    limbs() const noexcept { return &m_data; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool         sign() const noexcept { return m_sign; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void         sign(bool b) noexcept
   {
      m_sign = b;
      // Check for zero value:
      if (m_sign && !m_data)
      {
         m_sign = false;
      }
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void resize(std::size_t /* new_size */, std::size_t min_size)
   {
      detail::verify_new_size(2, min_size, checked_type());
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void normalize() noexcept((Checked == unchecked))
   {
      if (!m_data)
         m_sign = false; // zero is always unsigned
      detail::verify_limb_mask(true, m_data, limb_mask, checked_type());
      m_data &= limb_mask;
   }

   BOOST_MP_FORCEINLINE constexpr cpp_int_base() noexcept : m_data(0), m_sign(false) {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(const cpp_int_base& o) noexcept
       : m_data(o.m_data),
         m_sign(o.m_sign) {}
   //~cpp_int_base() noexcept {}
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void assign(const cpp_int_base& o) noexcept
   {
      m_data = o.m_data;
      m_sign = o.m_sign;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void negate() noexcept
   {
      m_sign = !m_sign;
      // Check for zero value:
      if (m_data == 0)
      {
         m_sign = false;
      }
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool isneg() const noexcept
   {
      return m_sign;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void do_swap(cpp_int_base& o) noexcept
   {
      std_constexpr::swap(m_sign, o.m_sign);
      std_constexpr::swap(m_data, o.m_data);
   }
};
//
// Backend for unsigned fixed precision (i.e. no allocator) type which will fit entirely inside a "double_limb_type":
//
template <std::size_t MinBits, cpp_int_check_type Checked>
struct cpp_int_base<MinBits, MinBits, unsigned_magnitude, Checked, void, true>
{
   using local_limb_type = typename trivial_limb_type<static_cast<unsigned>(MinBits)>::type;
   using limb_pointer = local_limb_type*                         ;
   using const_limb_pointer = const local_limb_type*                   ;

   struct scoped_shared_storage 
   {
      BOOST_MP_CXX14_CONSTEXPR      scoped_shared_storage(const cpp_int_base&, std::size_t) {}
      BOOST_MP_CXX14_CONSTEXPR void deallocate(std::size_t) {}
   };

 private:
   static constexpr std::size_t limb_bits = sizeof(local_limb_type) * CHAR_BIT;
   static constexpr local_limb_type limb_mask = limb_bits != MinBits ? static_cast<local_limb_type>(static_cast<local_limb_type>(~local_limb_type(0)) >> (limb_bits - MinBits))
                                                                           : static_cast<local_limb_type>(~local_limb_type(0));

   local_limb_type m_data;

   using checked_type = std::integral_constant<int, Checked>;

   //
   // Interface invariants:
   //
   static_assert(MinBits <= sizeof(double_limb_type) * CHAR_BIT, "Template parameter MinBits is inconsistent with the parameter trivial - did you mistakingly try to override the trivial parameter?");

 protected:
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !(std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::digits <= static_cast<int>(MinBits)))>::type
   check_in_range(T val, const std::integral_constant<int, checked>&, const std::integral_constant<bool, false>&)
   {
      using common_type = typename std::common_type<T, local_limb_type>::type;

      if (static_cast<common_type>(val) > limb_mask)
         BOOST_MP_THROW_EXCEPTION(std::range_error("The argument to a cpp_int constructor exceeded the largest value it can represent."));
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR void check_in_range(T val, const std::integral_constant<int, checked>&, const std::integral_constant<bool, true>&)
   {
      using common_type = typename std::common_type<T, local_limb_type>::type;

      if (static_cast<common_type>(val) > static_cast<common_type>(limb_mask))
         BOOST_MP_THROW_EXCEPTION(std::range_error("The argument to a cpp_int constructor exceeded the largest value it can represent."));
      if (val < 0)
         BOOST_MP_THROW_EXCEPTION(std::range_error("The argument to an unsigned cpp_int constructor was negative."));
   }
   template <class T, int C, bool B>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void check_in_range(T, const std::integral_constant<int, C>&, const std::integral_constant<bool, B>&) noexcept {}

   template <class T>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void check_in_range(T val) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<T>(), checked_type(), boost::multiprecision::detail::is_signed<T>())))
   {
      check_in_range(val, checked_type(), boost::multiprecision::detail::is_signed<T>());
   }

 public:
   //
   // Direct construction:
   //
#ifdef __MSVC_RUNTIME_CHECKS
   template <class SI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(i < 0 ? (1 + ~static_cast<local_limb_type>(-i & limb_mask)) & limb_mask : static_cast<local_limb_type>(i & limb_mask))
   {}
   template <class SI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<SI>())))
       : m_data(i < 0 ? 1 + ~static_cast<local_limb_type>(-i & limb_mask) : static_cast<local_limb_type>(i & limb_mask)) { check_in_range(i); }
   template <class UI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(static_cast<local_limb_type>(i& limb_mask)) {}
   template <class UI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<UI>())))
       : m_data(static_cast<local_limb_type>(i & limb_mask)) { check_in_range(i); }
#else
   template <class SI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(i < 0 ? (1 + ~static_cast<local_limb_type>(-i)) & limb_mask : static_cast<local_limb_type>(i) & limb_mask)
   {}
   template <class SI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(SI i, typename std::enable_if<boost::multiprecision::detail::is_signed<SI>::value && boost::multiprecision::detail::is_integral<SI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<SI>())))
       : m_data(i < 0 ? 1 + ~static_cast<local_limb_type>(-i) : static_cast<local_limb_type>(i)) { check_in_range(i); }
   template <class UI>
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == unchecked)>::type const* = nullptr) noexcept
       : m_data(static_cast<local_limb_type>(i) & limb_mask) {}
   template <class UI>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(UI i, typename std::enable_if<boost::multiprecision::detail::is_unsigned<UI>::value && (Checked == checked)>::type const* = nullptr) noexcept(noexcept(std::declval<cpp_int_base>().check_in_range(std::declval<UI>())))
       : m_data(static_cast<local_limb_type>(i)) { check_in_range(i); }
#endif
   template <class F>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_base(F i, typename std::enable_if<std::is_floating_point<F>::value >::type const* = nullptr) noexcept((Checked == unchecked))
       : m_data(static_cast<local_limb_type>(i < 0 ? -i : i) & limb_mask)
   {
      check_in_range(i);
      if (i < 0)
         negate();
   }
   constexpr cpp_int_base(literals::detail::value_pack<>) noexcept
       : m_data(static_cast<local_limb_type>(0u))
   {}
   template <limb_type a>
   constexpr cpp_int_base(literals::detail::value_pack<a>) noexcept
       : m_data(static_cast<local_limb_type>(a)) {}
   template <limb_type a, limb_type b>
   constexpr cpp_int_base(literals::detail::value_pack<a, b>) noexcept
       : m_data(static_cast<local_limb_type>(a) | (static_cast<local_limb_type>(b) << bits_per_limb)) {}
   //
   // These are deprecated in C++20 unless we make them explicit:
   //
   BOOST_MP_CXX14_CONSTEXPR cpp_int_base& operator=(const cpp_int_base&) = default;

   explicit constexpr cpp_int_base(scoped_shared_storage&, std::size_t) noexcept : m_data(0)
   {}
       //
   // Helper functions for getting at our internal data, and manipulating storage:
   //
   BOOST_MP_FORCEINLINE constexpr std::size_t              size() const noexcept { return 1; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR limb_pointer limbs() noexcept { return &m_data; }
   BOOST_MP_FORCEINLINE constexpr const_limb_pointer    limbs() const noexcept { return &m_data; }
   BOOST_MP_FORCEINLINE constexpr bool                  sign() const noexcept { return false; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void         sign(bool b) noexcept((Checked == unchecked))
   {
      if (b)
         negate();
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void resize(unsigned, std::size_t min_size)
   {
      detail::verify_new_size(2, min_size, checked_type());
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void normalize() noexcept((Checked == unchecked))
   {
      detail::verify_limb_mask(true, m_data, limb_mask, checked_type());
      m_data &= limb_mask;
   }

   BOOST_MP_FORCEINLINE constexpr cpp_int_base() noexcept : m_data(0) {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_base(const cpp_int_base& o) noexcept
       : m_data(o.m_data) {}
   //~cpp_int_base() noexcept {}
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void assign(const cpp_int_base& o) noexcept
   {
      m_data = o.m_data;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void negate()
   #if !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   noexcept((Checked == unchecked))
   #endif
   {
      BOOST_IF_CONSTEXPR(Checked == checked)
      {
         BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to negate an unsigned type."));
      }
      m_data = ~m_data;
      ++m_data;
   }
   BOOST_MP_FORCEINLINE constexpr bool isneg() const noexcept
   {
      return false;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void do_swap(cpp_int_base& o) noexcept
   {
      std_constexpr::swap(m_data, o.m_data);
   }
};
//
// Traits class, lets us know whether type T can be directly converted to the base type,
// used to enable/disable constructors etc:
//
template <class Arg, class Base>
struct is_allowed_cpp_int_base_conversion : public std::conditional<
                                                std::is_same<Arg, limb_type>::value || std::is_same<Arg, signed_limb_type>::value
#if BOOST_MP_ENDIAN_LITTLE_BYTE && !defined(BOOST_MP_TEST_NO_LE)
                                                    || std::is_same<Arg, double_limb_type>::value || std::is_same<Arg, signed_double_limb_type>::value
#endif
                                                    || literals::detail::is_value_pack<Arg>::value || (is_trivial_cpp_int<Base>::value && boost::multiprecision::detail::is_arithmetic<Arg>::value),
                                                std::integral_constant<bool, true>,
                                                std::integral_constant<bool, false>>::type
{};
//
// Now the actual backend, normalising parameters passed to the base class:
//
template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct cpp_int_backend
    : public cpp_int_base<
          min_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
          max_precision<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
          SignType,
          Checked,
          Allocator,
          is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value>
{
   using self_type = cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>;
   using base_type = cpp_int_base<
       min_precision<self_type>::value,
       max_precision<self_type>::value,
       SignType,
       Checked,
       Allocator,
       is_trivial_cpp_int<self_type>::value>;
   using trivial_tag = std::integral_constant<bool, is_trivial_cpp_int<self_type>::value>;

 public:
   using signed_types = typename std::conditional<
       is_trivial_cpp_int<self_type>::value,
       std::tuple<
           signed char, short, int, long,
           long long, signed_double_limb_type>,
       std::tuple<signed_limb_type, signed_double_limb_type> >::type;
   using unsigned_types = typename std::conditional<
       is_trivial_cpp_int<self_type>::value,
       std::tuple<unsigned char, unsigned short, unsigned,
                 unsigned long, unsigned long long, double_limb_type>,
       std::tuple<limb_type, double_limb_type> >::type;
   using float_types = typename std::conditional<
       is_trivial_cpp_int<self_type>::value,
       std::tuple<float, double, long double>,
       std::tuple<long double> >::type;
   using checked_type = std::integral_constant<int, Checked>        ;

   BOOST_MP_FORCEINLINE constexpr cpp_int_backend() noexcept {}
   BOOST_MP_FORCEINLINE constexpr cpp_int_backend(const cpp_int_backend& o) noexcept(std::is_void<Allocator>::value) : base_type(o) {}
   // rvalue copy:
   BOOST_MP_FORCEINLINE constexpr cpp_int_backend(cpp_int_backend&& o) noexcept
       : base_type(static_cast<base_type&&>(o))
   {}
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2>
   BOOST_MP_FORCEINLINE BOOST_CXX14_CONSTEXPR cpp_int_backend(cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2>&& o, typename std::enable_if<is_implicit_cpp_int_conversion<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2>, self_type>::value>::type* = nullptr) noexcept
   {
      *this = static_cast<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2>&&>(o);
   }
   //
   // Direct construction from arithmetic type:
   //
   template <class Arg>
   BOOST_MP_FORCEINLINE constexpr cpp_int_backend(Arg i, typename std::enable_if<is_allowed_cpp_int_base_conversion<Arg, base_type>::value>::type const* = nullptr) noexcept(noexcept(base_type(std::declval<Arg>())))
       : base_type(i) {}
   //
   // Aliasing constructor: the result will alias the memory referenced, unless
   // we have fixed precision and storage, in which case we copy the memory:
   //
   explicit constexpr cpp_int_backend(limb_type* data, std::size_t offset, std::size_t len) noexcept
       : base_type(data, offset, len) {}
   explicit cpp_int_backend(const limb_type* data, std::size_t offset, std::size_t len) noexcept
       : base_type(data, offset, len) { this->normalize(); }
   explicit constexpr cpp_int_backend(typename base_type::scoped_shared_storage& data, std::size_t len) noexcept
       : base_type(data, len) {}

 private:
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other, std::true_type const&, std::true_type const&)
   {
      // Assigning trivial type to trivial type:
      this->check_in_range(*other.limbs());
      *this->limbs() = static_cast<typename self_type::local_limb_type>(*other.limbs());
      this->sign(other.sign());
      this->normalize();
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other, std::true_type const&, std::false_type const&)
   {
      // non-trivial to trivial narrowing conversion:
      double_limb_type v = *other.limbs();
      if (other.size() > 1)
      {
         v |= static_cast<double_limb_type>(other.limbs()[1]) << bits_per_limb;
         BOOST_IF_CONSTEXPR(Checked == checked)
         {
            if (other.size() > 2)
            {
               BOOST_MP_THROW_EXCEPTION(std::range_error("Assignment of a cpp_int that is out of range for the target type."));
            }
         }
      }
      *this = v;
      this->sign(other.sign());
      this->normalize();
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other, std::false_type const&, std::true_type const&)
   {
      // trivial to non-trivial, treat the trivial argument as if it were an unsigned arithmetic type, then set the sign afterwards:
      *this = static_cast<
          typename boost::multiprecision::detail::canonical<
              typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>::local_limb_type,
              cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::type>(*other.limbs());
      this->sign(other.sign());
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other, std::false_type const&, std::false_type const&)
   {
      // regular non-trivial to non-trivial assign:
      this->resize(other.size(), other.size());

#if !defined(BOOST_MP_HAS_IS_CONSTANT_EVALUATED) && !defined(BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED) && !defined(BOOST_NO_CXX14_CONSTEXPR)
      std::size_t count = (std::min)(other.size(), this->size());
      for (std::size_t i = 0; i < count; ++i)
         this->limbs()[i] = other.limbs()[i];
#else
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
      if (BOOST_MP_IS_CONST_EVALUATED(other.size()))
      {
         std::size_t count = (std::min)(other.size(), this->size());
         for (std::size_t i = 0; i < count; ++i)
            this->limbs()[i] = other.limbs()[i];
      }
      else
#endif
      {
         static_assert(sizeof(other.limbs()[0]) == sizeof(this->limbs()[0]), "This method requires equal limb sizes");
         std::memcpy(this->limbs(), other.limbs(), (std::min)(other.size() * sizeof(other.limbs()[0]), this->size() * sizeof(this->limbs()[0])));
      }
#endif
      this->sign(other.sign());
      this->normalize();
   }

 public:
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR cpp_int_backend(
       const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other,
       typename std::enable_if<is_implicit_cpp_int_conversion<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>, self_type>::value>::type* = nullptr)
       : base_type()
   {
      do_assign(
          other,
          std::integral_constant<bool, is_trivial_cpp_int<self_type>::value>(),
          std::integral_constant<bool, is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>());
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   explicit BOOST_MP_CXX14_CONSTEXPR cpp_int_backend(
       const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other,
       typename std::enable_if< !(is_implicit_cpp_int_conversion<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>, self_type>::value)>::type* = nullptr)
       : base_type()
   {
      do_assign(
          other,
          std::integral_constant<bool, is_trivial_cpp_int<self_type>::value>(),
          std::integral_constant<bool, is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>());
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR cpp_int_backend& operator=(
       const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& other)
   {
      do_assign(
          other,
          std::integral_constant<bool, is_trivial_cpp_int<self_type>::value>(),
          std::integral_constant<bool, is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>());
      return *this;
   }
   constexpr cpp_int_backend(const cpp_int_backend& a, const literals::detail::negate_tag& tag)
       : base_type(static_cast<const base_type&>(a), tag)
   {}

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_backend& operator=(const cpp_int_backend& o) noexcept(noexcept(std::declval<cpp_int_backend>().assign(std::declval<const cpp_int_backend&>())))
   {
      this->assign(o);
      return *this;
   }
   // rvalue copy:
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR cpp_int_backend& operator=(cpp_int_backend&& o) noexcept(noexcept(std::declval<base_type&>() = std::declval<base_type>()))
   {
      *static_cast<base_type*>(this) = static_cast<base_type&&>(o);
      return *this;
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<((MaxBits2 <= MaxBits) || (MaxBits == 0)) && !std::is_void<Allocator>::value, cpp_int_backend&>::type operator=(cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator>&& o) noexcept
   {
      *static_cast<base_type*>(this) = static_cast<typename cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2>::base_type&&>(o);
      return *this;
   }

   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
         boost::multiprecision::detail::is_unsigned<A>::value
         && trivial_tag::value, cpp_int_backend&>::type 
      operator=(const A& val)
         noexcept(noexcept(std::declval<cpp_int_backend>().check_in_range(std::declval<A>())))
   {
      this->check_in_range(val);
      *this->limbs() = static_cast<typename self_type::local_limb_type>(val);
      this->sign(false);
      this->normalize();
      return *this;
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
         !(boost::multiprecision::detail::is_unsigned<A>::value || !boost::multiprecision::detail::is_integral<A>::value)
         && trivial_tag::value, cpp_int_backend&>::type
      operator=(const A& val)
         noexcept(noexcept(std::declval<cpp_int_backend>().check_in_range(std::declval<A>())) && noexcept(std::declval<cpp_int_backend>().sign(true)))
   {
      this->check_in_range(val);
      *this->limbs() = (val < 0) ? static_cast<typename self_type::local_limb_type>(boost::multiprecision::detail::unsigned_abs(val)) : static_cast<typename self_type::local_limb_type>(val);
      this->sign(val < 0);
      this->normalize();
      return *this;
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
         std::is_convertible<A, limb_type>::value 
         && !boost::multiprecision::detail::is_integral<A>::value
         && trivial_tag::value, cpp_int_backend&>::type 
      operator=(const A& val)
   {
      this->check_in_range(val);
      *this->limbs() = (val < 0) ? static_cast<typename self_type::local_limb_type>(boost::multiprecision::detail::abs(val)) : static_cast<typename self_type::local_limb_type>(val);
      this->sign(val < 0);
      this->normalize();
      return *this;
   }
   template <class A>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
         std::is_same<A, limb_type>::value && !trivial_tag::value, cpp_int_backend&>::type
      operator=(A i) noexcept
   {
      this->resize(1, 1);
      *this->limbs() = i;
      this->sign(false);
      return *this;
   }
   template <class A>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if <
         std::is_same<A, signed_limb_type>::value && !trivial_tag::value, cpp_int_backend&>::type
      operator=(A i) noexcept(noexcept(std::declval<cpp_int_backend>().sign(true)))
   {
      this->resize(1, 1);
      *this->limbs() = static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(i));
      this->sign(i < 0);
      return *this;
   }
   template <class A>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if <
         std::is_same<A, double_limb_type>::value && !trivial_tag::value, cpp_int_backend&>::type
      operator=(A i) noexcept
   {
      static_assert(sizeof(i) == 2 * sizeof(limb_type), "Failed integer size check");
      static_assert(base_type::internal_limb_count >= 2, "Failed internal limb count");
      typename base_type::limb_pointer p = this->limbs();
#ifdef __MSVC_RUNTIME_CHECKS
      *p = static_cast<limb_type>(i & ~static_cast<limb_type>(0));
#else
      *p                        = static_cast<limb_type>(i);
#endif
      p[1] = static_cast<limb_type>(i >> base_type::limb_bits);
      this->resize(p[1] ? 2 : 1, p[1] ? 2 : 1);
      this->sign(false);
      return *this;
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if <
         std::is_same<A, signed_double_limb_type>::value && !trivial_tag::value, cpp_int_backend&>::type
      operator=(A i) noexcept(noexcept(std::declval<cpp_int_backend>().sign(true)))
   {
      static_assert(sizeof(i) == 2 * sizeof(limb_type), "double limb type size check failed");
      static_assert(base_type::internal_limb_count >= 2, "Failed internal limb count check");
      bool s = false;
      if (i < 0)
         s = true;
      double_limb_type                 ui = static_cast<double_limb_type>(boost::multiprecision::detail::unsigned_abs(i));
      typename base_type::limb_pointer p  = this->limbs();
#ifdef __MSVC_RUNTIME_CHECKS
      *p = static_cast<limb_type>(ui & ~static_cast<limb_type>(0));
#else
      *p                        = static_cast<limb_type>(ui);
#endif
      p[1] = static_cast<limb_type>(ui >> base_type::limb_bits);
      this->resize(p[1] ? 2 : 1, p[1] ? 2 : 1);
      this->sign(s);
      return *this;
   }
private:
   template <class F>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_float(F a)
   {
      using default_ops::eval_add;
      using default_ops::eval_subtract;
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      if (a < 0)
      {
         do_assign_float(-a);
         this->sign(true);
         return;
      }

      if (a == 0)
      {
         *this = static_cast<limb_type>(0u);
      }

      if (a == 1)
      {
         *this = static_cast<limb_type>(1u);
      }

      if (!BOOST_MP_ISFINITE(a))
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Cannot convert a non-finite number to an integer."));
      }

      int         e = 0;
      F f(0), term(0);
      *this = static_cast<limb_type>(0u);

      f = frexp(a, &e);

#if !(defined(__clang__) && (__clang_major__ <= 7))
      constexpr limb_type shift = std::numeric_limits<limb_type>::digits;
#else
      // clang 7 has an issue converting long double to unsigned long long in
      // release mode (bits get dropped, conversion appears to go via float)
      // Never extract more than double bits at a time:
      constexpr limb_type shift = std::numeric_limits<limb_type>::digits > std::numeric_limits<double>::digits
            ? std::numeric_limits<double>::digits : std::numeric_limits<limb_type>::digits;
#endif

      while (f != static_cast<F>(0.0f))
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e = e - static_cast<int>(shift);
         eval_left_shift(*this, shift);
#if !(defined(__clang__) && (__clang_major__ <= 7))
         if (term > 0)
            eval_add(*this, static_cast<limb_type>(term));
         else
            eval_subtract(*this, static_cast<limb_type>(-term));
#else
         // clang 7 requires extra cast to double to avoid buggy code generation:
         if (term > 0)
            eval_add(*this, static_cast<limb_type>(static_cast<double>(term)));
         else
            eval_subtract(*this, static_cast<limb_type>(static_cast<double>(-term)));
#endif
         f -= term;
      }
      if (e > 0)
         eval_left_shift(*this, static_cast<unsigned int>(e));
      else if (e < 0)
         eval_right_shift(*this, static_cast<unsigned int>(-e));
   }
public:
   template <class A>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if <
      std::is_floating_point<A>::value && !trivial_tag::value, cpp_int_backend&>::type
      operator=(A a)
   {
      do_assign_float(a);
      return *this;
   }

 private:
   void do_assign_string(const char* s, const std::integral_constant<bool, true>&)
   {
      std::size_t n  = s ? std::strlen(s) : 0;
      *this          = 0;
      unsigned radix = 10;
      bool     isneg = false;
      if (n && (*s == '-'))
      {
         --n;
         ++s;
         isneg = true;
      }
      if (n && (*s == '0'))
      {
         if ((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
         {
            radix = 16;
            s += 2;
            n -= 2;
         }
         else
         {
            radix = 8;
            n -= 1;
         }
      }
      if (n)
      {
         unsigned val;
         while (*s)
         {
            if (*s >= '0' && *s <= '9')
               val = static_cast<unsigned>(*s - '0');
            else if (*s >= 'a' && *s <= 'f')
               val = 10u + static_cast<unsigned>(*s - 'a');
            else if (*s >= 'A' && *s <= 'F')
               val = 10u + static_cast<unsigned>(*s - 'A');
            else
               val = radix + 1u;
            if (val >= radix)
            {
               BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected content found while parsing character string."));
            }
            *this->limbs() = detail::checked_multiply(*this->limbs(), static_cast<typename base_type::local_limb_type>(radix), checked_type());
            *this->limbs() = detail::checked_add(*this->limbs(), static_cast<typename base_type::local_limb_type>(val), checked_type());
            ++s;
         }
      }
      if (isneg)
         this->negate();
   }
   void do_assign_string(const char* s, const std::integral_constant<bool, false>&)
   {
      using default_ops::eval_add;
      using default_ops::eval_multiply;
      std::size_t n  = s ? std::strlen(s) : 0;
      *this          = static_cast<limb_type>(0u);
      unsigned radix = 10;
      bool     isneg = false;
      if (n && (*s == '-'))
      {
         --n;
         ++s;
         isneg = true;
      }
      if (n && (*s == '0'))
      {
         if ((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
         {
            radix = 16;
            s += 2;
            n -= 2;
         }
         else
         {
            radix = 8;
            n -= 1;
         }
      }
      //
      // Exception guarantee: create the result in stack variable "result"
      // then do a swap at the end.  In the event of a throw, *this will
      // be left unchanged.
      //
      cpp_int_backend result;
      if (n)
      {
         if (radix == 16)
         {
            while (*s == '0')
               ++s;
            std::size_t bitcount = 4 * std::strlen(s);
            limb_type   val;
            std::size_t limb, shift;
            if (bitcount > 4)
               bitcount -= 4;
            else
               bitcount = 0;
            std::size_t newsize = bitcount / (sizeof(limb_type) * CHAR_BIT) + 1;
            result.resize(static_cast<unsigned>(newsize), static_cast<unsigned>(newsize)); // will throw if this is a checked integer that cannot be resized
            std::memset(result.limbs(), 0, result.size() * sizeof(limb_type));
            while (*s)
            {
               if (*s >= '0' && *s <= '9')
                  val = static_cast<unsigned>(*s - '0');
               else if (*s >= 'a' && *s <= 'f')
                  val = 10u + static_cast<unsigned>(*s - 'a');
               else if (*s >= 'A' && *s <= 'F')
                  val = 10u + static_cast<unsigned>(*s - 'A');
               else
               {
                  #if defined(BOOST_NO_EXCEPTIONS)
                  val = static_cast<unsigned>('0');
                  #endif

                  BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected content found while parsing character string."));
               }
               limb  = bitcount / (sizeof(limb_type) * CHAR_BIT);
               shift = bitcount % (sizeof(limb_type) * CHAR_BIT);
               val <<= shift;
               if (result.size() > limb)
               {
                  result.limbs()[limb] |= val;
               }
               ++s;
               bitcount -= 4;
            }
            result.normalize();
         }
         else if (radix == 8)
         {
            while (*s == '0')
               ++s;
            std::size_t bitcount = 3 * std::strlen(s);
            limb_type   val;
            std::size_t limb, shift;
            if (bitcount > 3)
               bitcount -= 3;
            else
               bitcount = 0;
            std::size_t newsize = bitcount / (sizeof(limb_type) * CHAR_BIT) + 1;
            result.resize(static_cast<unsigned>(newsize), static_cast<unsigned>(newsize)); // will throw if this is a checked integer that cannot be resized
            std::memset(result.limbs(), 0, result.size() * sizeof(limb_type));
            while (*s)
            {
               if (*s >= '0' && *s <= '7')
                  val = static_cast<unsigned>(*s - '0');
               else
               {
                  #if defined(BOOST_NO_EXCEPTIONS)
                  val = static_cast<unsigned>('0');
                  #endif

                  BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected content found while parsing character string."));
               }
               limb  = bitcount / (sizeof(limb_type) * CHAR_BIT);
               shift = bitcount % (sizeof(limb_type) * CHAR_BIT);
               if (result.size() > limb)
               {
                  result.limbs()[limb] |= (val << shift);
                  if (shift > sizeof(limb_type) * CHAR_BIT - 3)
                  {
                     // Deal with the bits in val that overflow into the next limb:
                     val >>= (sizeof(limb_type) * CHAR_BIT - shift);
                     if (val)
                     {
                        // If this is the most-significant-limb, we may need to allocate an extra one for the overflow:
                        if (limb + 1 == newsize)
                           result.resize(static_cast<unsigned>(newsize + 1), static_cast<unsigned>(newsize + 1));
                        if (result.size() > limb + 1)
                        {
                           result.limbs()[limb + 1] |= val;
                        }
                     }
                  }
               }
               ++s;
               bitcount -= 3;
            }
            result.normalize();
         }
         else
         {
            // Base 10, we extract blocks of size 10^9 at a time, that way
            // the number of multiplications is kept to a minimum:
            limb_type block_mult = max_block_10;
            while (*s)
            {
               limb_type block = 0;
               for (unsigned i = 0; i < digits_per_block_10; ++i)
               {
                  limb_type val;
                  if (*s >= '0' && *s <= '9')
                     val = static_cast<limb_type>(*s - '0');
                  else
                  {
                     #if defined(BOOST_NO_EXCEPTIONS)
                     val = static_cast<unsigned>('0');
                     #endif

                     BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected character encountered in input."));
                  }
                  block *= 10;
                  block += val;
                  if (!*++s)
                  {
                     block_mult = block_multiplier(i);
                     break;
                  }
               }
               eval_multiply(result, block_mult);
               eval_add(result, block);
            }
         }
      }
      if (isneg)
         result.negate();
      result.swap(*this);
   }

 public:
   cpp_int_backend& operator=(const char* s)
   {
      do_assign_string(s, trivial_tag());
      return *this;
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void swap(cpp_int_backend& o) noexcept
   {
      this->do_swap(o);
   }

 private:
   std::string do_get_trivial_string(std::ios_base::fmtflags f, const std::integral_constant<bool, false>&) const
   {
      using io_type = typename std::conditional<sizeof(typename base_type::local_limb_type) == 1, unsigned, typename base_type::local_limb_type>::type;
      if (this->sign() && (((f & std::ios_base::hex) == std::ios_base::hex) || ((f & std::ios_base::oct) == std::ios_base::oct)))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Base 8 or 16 printing of negative numbers is not supported."));
      std::stringstream ss;
      ss.flags(f & ~std::ios_base::showpos);
      ss << static_cast<io_type>(*this->limbs());
      std::string result;
      if (this->sign())
         result += '-';
      else if (f & std::ios_base::showpos)
         result += '+';
      result += ss.str();
      return result;
   }
   std::string do_get_trivial_string(std::ios_base::fmtflags f, const std::integral_constant<bool, true>&) const
   {
      // Even though we have only one limb, we can't do IO on it :-(
      int base = 10;
      if ((f & std::ios_base::oct) == std::ios_base::oct)
         base = 8;
      else if ((f & std::ios_base::hex) == std::ios_base::hex)
         base = 16;
      std::string result;

      std::size_t Bits = sizeof(typename base_type::local_limb_type) * CHAR_BIT;

      if (base == 8 || base == 16)
      {
         if (this->sign())
            BOOST_MP_THROW_EXCEPTION(std::runtime_error("Base 8 or 16 printing of negative numbers is not supported."));
         limb_type                           shift = base == 8 ? 3 : 4;
         limb_type                           mask  = static_cast<limb_type>((1u << shift) - 1);
         typename base_type::local_limb_type v     = *this->limbs();
         result.assign(Bits / shift + (Bits % shift ? 1 : 0), '0');
         std::string::difference_type pos      = static_cast<std::string::difference_type>(result.size() - 1u);
         char                         letter_a = f & std::ios_base::uppercase ? 'A' : 'a';
         for (std::size_t i = 0; i < Bits / shift; ++i)
         {
            char c = static_cast<char>('0' + static_cast<char>(v & mask));
            if (c > '9')
               c = static_cast<char>(c + letter_a - '9' - 1);
            result[static_cast<std::size_t>(pos)] = c;
            --pos;
            v >>= shift;
         }
         if (Bits % shift)
         {
            mask   = static_cast<limb_type>((1u << (Bits % shift)) - 1);
            char c = static_cast<char>('0' + static_cast<char>(v & mask));
            if (c > '9')
               c = static_cast<char>(c + letter_a - '9');
            result[static_cast<std::size_t>(pos)] = c;
         }
         //
         // Get rid of leading zeros:
         //
         std::string::size_type n = result.find_first_not_of('0');
         if (!result.empty() && (n == std::string::npos))
            n = result.size() - 1;
         result.erase(0, n);
         if (f & std::ios_base::showbase)
         {
            const char* pp = base == 8 ? "0" : (f & std::ios_base::uppercase) ? "0X" : "0x";
            result.insert(static_cast<std::string::size_type>(0), pp);
         }
      }
      else
      {
         result.assign(Bits / 3 + 1, '0');
         std::string::difference_type        pos = static_cast<std::string::difference_type>(result.size() - 1u);
         typename base_type::local_limb_type v(*this->limbs());
         bool                                neg = false;
         if (this->sign())
         {
            neg = true;
         }
         while (v)
         {
            result[static_cast<std::string::size_type>(pos)] = static_cast<char>(static_cast<char>(v % 10) + '0');
            --pos;
            v /= 10;
         }
         std::string::size_type n = result.find_first_not_of('0');
         result.erase(0, n);
         if (result.empty())
            result = "0";
         if (neg)
            result.insert(static_cast<std::string::size_type>(0), 1, '-');
         else if (f & std::ios_base::showpos)
            result.insert(static_cast<std::string::size_type>(0), 1, '+');
      }
      return result;
   }
   std::string do_get_string(std::ios_base::fmtflags f, const std::integral_constant<bool, true>&) const
   {
#ifdef BOOST_MP_NO_DOUBLE_LIMB_TYPE_IO
      return do_get_trivial_string(f, std::integral_constant<bool, std::is_same<typename base_type::local_limb_type, double_limb_type>::value>());
#else
      return do_get_trivial_string(f, std::integral_constant<bool, false>());
#endif
   }
   std::string do_get_string(std::ios_base::fmtflags f, const std::integral_constant<bool, false>&) const
   {
      using default_ops::eval_get_sign;
      int base = 10;
      if ((f & std::ios_base::oct) == std::ios_base::oct)
         base = 8;
      else if ((f & std::ios_base::hex) == std::ios_base::hex)
         base = 16;
      std::string result;

      std::size_t Bits = this->size() * base_type::limb_bits;

      if (base == 8 || base == 16)
      {
         if (this->sign())
            BOOST_MP_THROW_EXCEPTION(std::runtime_error("Base 8 or 16 printing of negative numbers is not supported."));
         limb_type       shift = base == 8 ? 3 : 4;
         limb_type       mask  = static_cast<limb_type>((1u << shift) - 1);
         cpp_int_backend t(*this);
         result.assign(Bits / shift + ((Bits % shift) ? 1 : 0), '0');
         std::string::difference_type pos      = static_cast<std::string::difference_type>(result.size() - 1u);
         char                         letter_a = f & std::ios_base::uppercase ? 'A' : 'a';
         for (std::size_t i = 0; i < Bits / shift; ++i)
         {
            char c = static_cast<char>('0' + static_cast<char>(t.limbs()[0] & mask));
            if (c > '9')
               c = static_cast<char>(c + letter_a - '9' - 1);
            result[static_cast<std::size_t>(pos)] = c;
            --pos;
            eval_right_shift(t, shift);
         }
         if (Bits % shift)
         {
            mask   = static_cast<limb_type>((1u << (Bits % shift)) - 1);
            char c = static_cast<char>('0' + static_cast<char>(t.limbs()[0] & mask));
            if (c > '9')
               c = static_cast<char>(c + letter_a - '9');
            result[static_cast<std::size_t>(pos)] = c;
         }
         //
         // Get rid of leading zeros:
         //
         std::string::size_type n = result.find_first_not_of('0');
         if (!result.empty() && (n == std::string::npos))
            n = result.size() - 1;
         result.erase(0, n);
         if (f & std::ios_base::showbase)
         {
            const char* pp = base == 8 ? "0" : (f & std::ios_base::uppercase) ? "0X" : "0x";
            result.insert(static_cast<std::string::size_type>(0), pp);
         }
      }
      else
      {
         result.assign(Bits / 3 + 1, '0');
         std::string::difference_type pos = static_cast<std::string::difference_type>(result.size() - 1u);
         cpp_int_backend              t(*this);
         cpp_int_backend              r;
         bool                         neg = false;
         if (t.sign())
         {
            t.negate();
            neg = true;
         }
         if (this->size() == 1)
         {
            result = std::to_string(t.limbs()[0]);
         }
         else
         {
            cpp_int_backend block10;
            block10 = max_block_10;
            while (eval_get_sign(t) != 0)
            {
               cpp_int_backend t2;
               divide_unsigned_helper(&t2, t, block10, r);
               t           = t2;
               limb_type v = r.limbs()[0];
               for (std::size_t i = 0; i < digits_per_block_10; ++i)
               {
                  char c = static_cast<char>('0' + static_cast<char>(v % 10));
                  v /= 10;
                  result[static_cast<std::size_t>(pos)] = c;
                  if (pos-- == 0u)
                     break;
               }
            }
         }
         std::string::size_type n = result.find_first_not_of('0');
         result.erase(0, n);
         if (result.empty())
            result = std::string(static_cast<std::size_t>(1u), '0');
         if (neg)
            result.insert(static_cast<std::string::size_type>(0), 1, '-');
         else if (f & std::ios_base::showpos)
            result.insert(static_cast<std::string::size_type>(0), 1, '+');
      }
      return result;
   }

 public:
   std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f) const
   {
      return do_get_string(f, trivial_tag());
   }

 private:
   template <class Container>
   void construct_from_container(const Container& c, const std::integral_constant<bool, false>&)
   {
      //
      // We assume that c is a sequence of (unsigned) bytes with the most significant byte first:
      //
      std::size_t newsize = static_cast<unsigned>(c.size() / sizeof(limb_type));
      if (c.size() % sizeof(limb_type))
      {
         ++newsize;
      }
      if (newsize)
      {
         this->resize(newsize, newsize); // May throw
         std::memset(this->limbs(), 0, this->size());
         typename Container::const_iterator i(c.begin()), j(c.end());
         std::size_t                           byte_location = static_cast<unsigned>(c.size() - 1);
         while (i != j)
         {
            std::size_t limb  = byte_location / sizeof(limb_type);
            std::size_t shift = (byte_location % sizeof(limb_type)) * CHAR_BIT;
            if (this->size() > limb)
               this->limbs()[limb] |= static_cast<limb_type>(static_cast<unsigned char>(*i)) << shift;
            ++i;
            --byte_location;
         }
      }
   }
   template <class Container>
   BOOST_MP_CXX14_CONSTEXPR void construct_from_container(const Container& c, const std::integral_constant<bool, true>&)
   {
      //
      // We assume that c is a sequence of (unsigned) bytes with the most significant byte first:
      //
      using local_limb_type = typename base_type::local_limb_type;
      *this->limbs() = 0;
      if (c.size())
      {
         typename Container::const_iterator i(c.begin()), j(c.end());
         std::size_t                           byte_location = static_cast<unsigned>(c.size() - 1);
         while (i != j)
         {
            std::size_t limb  = byte_location / sizeof(local_limb_type);
            std::size_t shift = (byte_location % sizeof(local_limb_type)) * CHAR_BIT;
            if (limb == 0)
               this->limbs()[0] |= static_cast<limb_type>(static_cast<unsigned char>(*i)) << shift;
            ++i;
            --byte_location;
         }
      }
   }

 public:
   template <class Container>
   BOOST_MP_CXX14_CONSTEXPR cpp_int_backend(const Container& c, typename std::enable_if<boost::multiprecision::detail::is_byte_container<Container>::value>::type const* = nullptr)
   {
      //
      // We assume that c is a sequence of (unsigned) bytes with the most significant byte first:
      //
      construct_from_container(c, trivial_tag());
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare_imp(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&) const noexcept
   {
      if (this->sign() != o.sign())
         return this->sign() ? -1 : 1;

      // Only do the compare if the same sign:
      int result = compare_unsigned(o);

      if (this->sign())
         result = -result;
      return result;
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare_imp(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&) const
   {
      cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> t(*this);
      return t.compare(o);
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare_imp(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&) const
   {
      cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> t(o);
      return compare(t);
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare_imp(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&) const noexcept
   {
      if (this->sign())
      {
         if (o.sign())
         {
            return *this->limbs() < *o.limbs() ? 1 : (*this->limbs() > *o.limbs() ? -1 : 0);
         }
         else
            return -1;
      }
      else
      {
         if (o.sign())
            return 1;
         return *this->limbs() < *o.limbs() ? -1 : (*this->limbs() > *o.limbs() ? 1 : 0);
      }
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) const noexcept
   {
      using t1 = std::integral_constant<bool, is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value>     ;
      using t2 = std::integral_constant<bool, is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value>;
      return compare_imp(o, t1(), t2());
   }
   template <std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
   BOOST_MP_CXX14_CONSTEXPR int compare_unsigned(const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) const noexcept
   {
      if (this->size() != o.size())
      {
         return this->size() > o.size() ? 1 : -1;
      }
      typename base_type::const_limb_pointer pa = this->limbs();
      typename base_type::const_limb_pointer pb = o.limbs();
      for (std::ptrdiff_t i = static_cast<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(this->size()) - 1); i >= 0; --i)
      {
         if (pa[i] != pb[i])
            return pa[i] > pb[i] ? 1 : -1;
      }
      return 0;
   }
   template <class Arithmetic>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<Arithmetic>::value, int>::type compare(Arithmetic i) const
   {
      // braindead version:
      cpp_int_backend t;
      t = i;
      return compare(t);
   }
};

} // namespace backends

namespace default_ops {

template <class Backend>
struct double_precision_type;

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct double_precision_type<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >
{
   using type = typename std::conditional<
       backends::is_fixed_precision<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
       backends::cpp_int_backend<
           (std::is_void<Allocator>::value ? 2 * backends::max_precision<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value
                                      : MinBits),
           2 * backends::max_precision<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
           SignType,
           Checked,
           Allocator>,
       backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::type;
};

} // namespace default_ops

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
struct is_equivalent_number_type<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, backends::cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >
   : public std::integral_constant<bool, std::numeric_limits<number<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, et_on> >::digits == std::numeric_limits<number<backends::cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>, et_on> >::digits>{};

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked>
struct expression_template_default<backends::cpp_int_backend<MinBits, MaxBits, SignType, Checked, void> >
{
   static constexpr expression_template_option value = et_off;
};

using boost::multiprecision::backends::cpp_int_backend;

template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
struct number_category<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> > : public std::integral_constant<int, number_kind_integer>
{};

using cpp_int = number<cpp_int_backend<> >          ;
using cpp_rational_backend = rational_adaptor<cpp_int_backend<> >;
using cpp_rational = number<cpp_rational_backend>        ;

// Fixed precision unsigned types:
using uint128_t = number<cpp_int_backend<128, 128, unsigned_magnitude, unchecked, void> >  ;
using uint256_t = number<cpp_int_backend<256, 256, unsigned_magnitude, unchecked, void> >  ;
using uint512_t = number<cpp_int_backend<512, 512, unsigned_magnitude, unchecked, void> >  ;
using uint1024_t = number<cpp_int_backend<1024, 1024, unsigned_magnitude, unchecked, void> >;

// Fixed precision signed types:
using int128_t = number<cpp_int_backend<128, 128, signed_magnitude, unchecked, void> >  ;
using int256_t = number<cpp_int_backend<256, 256, signed_magnitude, unchecked, void> >  ;
using int512_t = number<cpp_int_backend<512, 512, signed_magnitude, unchecked, void> >  ;
using int1024_t = number<cpp_int_backend<1024, 1024, signed_magnitude, unchecked, void> >;

// Over again, but with checking enabled this time:
using checked_cpp_int = number<cpp_int_backend<0, 0, signed_magnitude, checked> >          ;
using checked_cpp_rational_backend = rational_adaptor<cpp_int_backend<0, 0, signed_magnitude, checked> >;
using checked_cpp_rational = number<checked_cpp_rational_backend>                               ;
// Fixed precision unsigned types:
using checked_uint128_t = number<cpp_int_backend<128, 128, unsigned_magnitude, checked, void> >  ;
using checked_uint256_t = number<cpp_int_backend<256, 256, unsigned_magnitude, checked, void> >  ;
using checked_uint512_t = number<cpp_int_backend<512, 512, unsigned_magnitude, checked, void> >  ;
using checked_uint1024_t = number<cpp_int_backend<1024, 1024, unsigned_magnitude, checked, void> >;

// Fixed precision signed types:
using checked_int128_t = number<cpp_int_backend<128, 128, signed_magnitude, checked, void> >  ;
using checked_int256_t = number<cpp_int_backend<256, 256, signed_magnitude, checked, void> >  ;
using checked_int512_t = number<cpp_int_backend<512, 512, signed_magnitude, checked, void> >  ;
using checked_int1024_t = number<cpp_int_backend<1024, 1024, signed_magnitude, checked, void> >;

#if defined(__GNUC__) && !defined(__clang__)
// see https://github.com/boostorg/multiprecision/issues/413
// and https://github.com/boostorg/multiprecision/issues/431
#pragma GCC diagnostic pop
#endif
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

}} // namespace boost::multiprecision

//
// Last of all we include the implementations of all the eval_* non member functions:
//
#include <boost/multiprecision/cpp_int/limits.hpp>
#include <boost/multiprecision/cpp_int/comparison.hpp>
#include <boost/multiprecision/cpp_int/add.hpp>
#include <boost/multiprecision/cpp_int/multiply.hpp>
#include <boost/multiprecision/cpp_int/divide.hpp>
#include <boost/multiprecision/cpp_int/bitwise.hpp>
#include <boost/multiprecision/cpp_int/misc.hpp>
#include <boost/multiprecision/cpp_int/literals.hpp>
#include <boost/multiprecision/cpp_int/serialize.hpp>
#include <boost/multiprecision/cpp_int/import_export.hpp>

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/debug_adaptor.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DEBUG_ADAPTOR_HPP
#define BOOST_MP_DEBUG_ADAPTOR_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/traits/extract_exponent_type.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

template <class Backend>
struct debug_adaptor
{
   using signed_types = typename Backend::signed_types  ;
   using unsigned_types = typename Backend::unsigned_types;
   using float_types = typename Backend::float_types   ;
   using exponent_type = typename extract_exponent_type<Backend, number_category<Backend>::value>::type;

 private:
   std::string debug_value;
   Backend     m_value;

 public:
   void update_view()
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         debug_value = m_value.str(0, static_cast<std::ios_base::fmtflags>(0));
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const std::exception& e)
      {
         debug_value = "String conversion failed with message: \"";
         debug_value += e.what();
         debug_value += "\"";
      }
#endif
   }
   debug_adaptor()
   {
      update_view();
   }
   debug_adaptor(const debug_adaptor& o) : debug_value(o.debug_value), m_value(o.m_value)
   {
   }
   debug_adaptor& operator=(const debug_adaptor& o)
   {
      debug_value = o.debug_value;
      m_value     = o.m_value;
      return *this;
   }
   template <class T>
   debug_adaptor(const T& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
       : m_value(i)
   {
      update_view();
   }
   template <class T>
   debug_adaptor(const debug_adaptor<T>& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
       : m_value(i.value())
   {
      update_view();
   }
   template <class T, class U>
   debug_adaptor(const T& i, const U& j, typename std::enable_if<std::is_constructible<Backend, const T&, const U&>::value>::type* = nullptr)
       : m_value(i, j)
   {
      update_view();
   }
   template <class B2>
   debug_adaptor(const B2& i, unsigned digits10, typename std::enable_if<std::is_same<B2, Backend>::value && std::is_constructible<Backend, const Backend&, unsigned>::value>::type* = nullptr)
       : m_value(i, digits10)
   {
      update_view();
   }
   template <class T>
   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value || std::is_assignable<Backend, T>::value, debug_adaptor&>::type operator=(const T& i)
   {
      m_value = i;
      update_view();
      return *this;
   }
   debug_adaptor& operator=(const char* s)
   {
      m_value = s;
      update_view();
      return *this;
   }
   void swap(debug_adaptor& o)
   {
      std::swap(m_value, o.value());
      std::swap(debug_value, o.debug_value);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      return m_value.str(digits, f);
   }
   void negate()
   {
      m_value.negate();
      update_view();
   }
   int compare(const debug_adaptor& o) const
   {
      return m_value.compare(o.value());
   }
   template <class T>
   int compare(const T& i) const
   {
      return m_value.compare(i);
   }
   Backend& value()
   {
      return m_value;
   }
   const Backend& value() const
   {
      return m_value;
   }

   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      ar & boost::make_nvp("value", m_value);
      using tag = typename Archive::is_loading;
      if (tag::value)
         update_view();
   }
   #endif 
   
   static unsigned default_precision() noexcept
   {
      return Backend::default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      Backend::default_precision(v);
   }
   static unsigned thread_default_precision() noexcept
   {
      return Backend::thread_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      Backend::thread_default_precision(v);
   }
   unsigned precision() const noexcept
   {
      return value().precision();
   }
   void precision(unsigned digits10) noexcept
   {
      value().precision(digits10);
   }
   //
   // Variable precision options:
   // 
   static constexpr variable_precision_options default_variable_precision_options()noexcept
   {
      return Backend::default_variable_precision_options();
   }
   static constexpr variable_precision_options thread_default_variable_precision_options()noexcept
   {
      return Backend::thread_default_variable_precision_options();
   }
   static BOOST_MP_CXX14_CONSTEXPR void default_variable_precision_options(variable_precision_options opts)
   {
      Backend::default_variable_precision_options(opts);
   }
   static BOOST_MP_CXX14_CONSTEXPR void thread_default_variable_precision_options(variable_precision_options opts)
   {
      Backend::thread_default_variable_precision_options(opts);
   }
};

template <class Backend>
inline Backend const& unwrap_debug_type(debug_adaptor<Backend> const& val)
{
   return val.value();
}
template <class T>
inline const T& unwrap_debug_type(const T& val)
{
   return val;
}

template <class Backend, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components(debug_adaptor<Backend>& result, const V& v1, const U& v2)
{
   using default_ops::assign_components;
   assign_components(result.value(), unwrap_debug_type(v1), unwrap_debug_type(v2));
   result.update_view();
}

#define NON_MEMBER_OP1(name, str)                                       \
   template <class Backend>                                             \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result) \
   {                                                                    \
      using default_ops::BOOST_JOIN(eval_, name);                       \
      BOOST_JOIN(eval_, name)                                           \
      (result.value());                                                 \
      result.update_view();                                             \
   }

#define NON_MEMBER_OP2(name, str)                                                                        \
   template <class Backend, class T>                                                                     \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const T& a)                      \
   {                                                                                                     \
      using default_ops::BOOST_JOIN(eval_, name);                                                        \
      BOOST_JOIN(eval_, name)                                                                            \
      (result.value(), unwrap_debug_type(a));                                                            \
      result.update_view();                                                                              \
   }                                                                                                     \
   template <class Backend>                                                                              \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a) \
   {                                                                                                     \
      using default_ops::BOOST_JOIN(eval_, name);                                                        \
      BOOST_JOIN(eval_, name)                                                                            \
      (result.value(), unwrap_debug_type(a));                                                            \
      result.update_view();                                                                              \
   }

#define NON_MEMBER_OP3(name, str)                                                                                                         \
   template <class Backend, class T, class U>                                                                                             \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const T& a, const U& b)                                           \
   {                                                                                                                                      \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                         \
      BOOST_JOIN(eval_, name)                                                                                                             \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b));                                                                       \
      result.update_view();                                                                                                               \
   }                                                                                                                                      \
   template <class Backend, class T>                                                                                                      \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const T& b)                      \
   {                                                                                                                                      \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                         \
      BOOST_JOIN(eval_, name)                                                                                                             \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b));                                                                       \
      result.update_view();                                                                                                               \
   }                                                                                                                                      \
   template <class Backend, class T>                                                                                                      \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const T& a, const debug_adaptor<Backend>& b)                      \
   {                                                                                                                                      \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                         \
      BOOST_JOIN(eval_, name)                                                                                                             \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b));                                                                       \
      result.update_view();                                                                                                               \
   }                                                                                                                                      \
   template <class Backend>                                                                                                               \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const debug_adaptor<Backend>& b) \
   {                                                                                                                                      \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                         \
      BOOST_JOIN(eval_, name)                                                                                                             \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b));                                                                       \
      result.update_view();                                                                                                               \
   }

#define NON_MEMBER_OP4(name, str)                                                                                                                                          \
   template <class Backend, class T, class U, class V>                                                                                                                     \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const T& a, const U& b, const V& c)                                                                \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }                                                                                                                                                                       \
   template <class Backend, class T>                                                                                                                                       \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const debug_adaptor<Backend>& b, const T& c)                      \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }                                                                                                                                                                       \
   template <class Backend, class T>                                                                                                                                       \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const T& b, const debug_adaptor<Backend>& c)                      \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }                                                                                                                                                                       \
   template <class Backend, class T>                                                                                                                                       \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const T& a, const debug_adaptor<Backend>& b, const debug_adaptor<Backend>& c)                      \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }                                                                                                                                                                       \
   template <class Backend>                                                                                                                                                \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const debug_adaptor<Backend>& b, const debug_adaptor<Backend>& c) \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }                                                                                                                                                                       \
   template <class Backend, class T, class U>                                                                                                                              \
   inline void BOOST_JOIN(eval_, name)(debug_adaptor<Backend> & result, const debug_adaptor<Backend>& a, const T& b, const U& c)                                           \
   {                                                                                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                          \
      BOOST_JOIN(eval_, name)                                                                                                                                              \
      (result.value(), unwrap_debug_type(a), unwrap_debug_type(b), unwrap_debug_type(c));                                                                                  \
      result.update_view();                                                                                                                                                \
   }

NON_MEMBER_OP2(add, "+=")
NON_MEMBER_OP2(subtract, "-=")
NON_MEMBER_OP2(multiply, "*=")
NON_MEMBER_OP2(divide, "/=")

template <class Backend, class R>
inline void eval_convert_to(R* result, const debug_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(result, val.value());
}
template <class Backend, class R>
inline void eval_convert_to(debug_adaptor<R>* result, const debug_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(&result->value(), val.value());
}
template <class Backend, class R>
inline void eval_convert_to(debug_adaptor<R>* result, const Backend& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(&result->value(), val);
}

template <class Backend>
inline void eval_convert_to(std::complex<float>* result, const debug_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(result, val.value());
}
template <class Backend>
inline void eval_convert_to(std::complex<double>* result, const debug_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(result, val.value());
}
template <class Backend>
inline void eval_convert_to(std::complex<long double>* result, const debug_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   eval_convert_to(result, val.value());
}



template <class Backend, class Exp>
inline void eval_frexp(debug_adaptor<Backend>& result, const debug_adaptor<Backend>& arg, Exp* exp)
{
   eval_frexp(result.value(), arg.value(), exp);
   result.update_view();
}

template <class Backend, class Exp>
inline void eval_ldexp(debug_adaptor<Backend>& result, const debug_adaptor<Backend>& arg, Exp exp)
{
   eval_ldexp(result.value(), arg.value(), exp);
   result.update_view();
}

template <class Backend, class Exp>
inline void eval_scalbn(debug_adaptor<Backend>& result, const debug_adaptor<Backend>& arg, Exp exp)
{
   using default_ops::eval_scalbn;
   eval_scalbn(result.value(), arg.value(), exp);
   result.update_view();
}

template <class Backend>
inline typename Backend::exponent_type eval_ilogb(const debug_adaptor<Backend>& arg)
{
   using default_ops::eval_ilogb;
   return eval_ilogb(arg.value());
}

NON_MEMBER_OP2(floor, "floor")
NON_MEMBER_OP2(ceil, "ceil")
NON_MEMBER_OP2(sqrt, "sqrt")
NON_MEMBER_OP2(logb, "logb")

template <class Backend>
inline int eval_fpclassify(const debug_adaptor<Backend>& arg)
{
   using default_ops::eval_fpclassify;
   return eval_fpclassify(arg.value());
}

/*********************************************************************
*
* Optional arithmetic operations come next:
*
*********************************************************************/

NON_MEMBER_OP3(add, "+")
NON_MEMBER_OP3(subtract, "-")
NON_MEMBER_OP3(multiply, "*")
NON_MEMBER_OP3(divide, "/")
NON_MEMBER_OP3(multiply_add, "fused-multiply-add")
NON_MEMBER_OP3(multiply_subtract, "fused-multiply-subtract")
NON_MEMBER_OP4(multiply_add, "fused-multiply-add")
NON_MEMBER_OP4(multiply_subtract, "fused-multiply-subtract")

NON_MEMBER_OP1(increment, "increment")
NON_MEMBER_OP1(decrement, "decrement")

/*********************************************************************
*
* Optional integer operations come next:
*
*********************************************************************/

NON_MEMBER_OP2(modulus, "%=")
NON_MEMBER_OP3(modulus, "%")
NON_MEMBER_OP2(bitwise_or, "|=")
NON_MEMBER_OP3(bitwise_or, "|")
NON_MEMBER_OP2(bitwise_and, "&=")
NON_MEMBER_OP3(bitwise_and, "&")
NON_MEMBER_OP2(bitwise_xor, "^=")
NON_MEMBER_OP3(bitwise_xor, "^")
NON_MEMBER_OP4(qr, "quotient-and-remainder")
NON_MEMBER_OP2(complement, "~")

template <class Backend>
inline void eval_left_shift(debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_left_shift;
   eval_left_shift(arg.value(), a);
   arg.update_view();
}
template <class Backend>
inline void eval_left_shift(debug_adaptor<Backend>& arg, const debug_adaptor<Backend>& a, std::size_t b)
{
   using default_ops::eval_left_shift;
   eval_left_shift(arg.value(), a.value(), b);
   arg.update_view();
}
template <class Backend>
inline void eval_right_shift(debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_right_shift;
   eval_right_shift(arg.value(), a);
   arg.update_view();
}
template <class Backend>
inline void eval_right_shift(debug_adaptor<Backend>& arg, const debug_adaptor<Backend>& a, std::size_t b)
{
   using default_ops::eval_right_shift;
   eval_right_shift(arg.value(), a.value(), b);
   arg.update_view();
}

template <class Backend, class T>
inline T eval_integer_modulus(const debug_adaptor<Backend>& arg, const T& a)
{
   using default_ops::eval_integer_modulus;
   return eval_integer_modulus(arg.value(), a);
}

template <class Backend>
inline std::size_t eval_lsb(const debug_adaptor<Backend>& arg)
{
   using default_ops::eval_lsb;
   return eval_lsb(arg.value());
}

template <class Backend>
inline std::size_t eval_msb(const debug_adaptor<Backend>& arg)
{
   using default_ops::eval_msb;
   return eval_msb(arg.value());
}

template <class Backend>
inline bool eval_bit_test(const debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_test;
   return eval_bit_test(arg.value(), a);
}

template <class Backend>
inline void eval_bit_set(const debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_set;
   eval_bit_set(arg.value(), a);
   arg.update_view();
}
template <class Backend>
inline void eval_bit_unset(const debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_unset;
   eval_bit_unset(arg.value(), a);
   arg.update_view();
}
template <class Backend>
inline void eval_bit_flip(const debug_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_flip;
   eval_bit_flip(arg.value(), a);
   arg.update_view();
}

NON_MEMBER_OP3(gcd, "gcd")
NON_MEMBER_OP3(lcm, "lcm")
NON_MEMBER_OP4(powm, "powm")

/*********************************************************************
*
* abs/fabs:
*
*********************************************************************/

NON_MEMBER_OP2(abs, "abs")
NON_MEMBER_OP2(fabs, "fabs")

/*********************************************************************
*
* Floating point functions:
*
*********************************************************************/

NON_MEMBER_OP2(trunc, "trunc")
NON_MEMBER_OP2(round, "round")
NON_MEMBER_OP2(exp, "exp")
NON_MEMBER_OP2(log, "log")
NON_MEMBER_OP2(log10, "log10")
NON_MEMBER_OP2(sin, "sin")
NON_MEMBER_OP2(cos, "cos")
NON_MEMBER_OP2(tan, "tan")
NON_MEMBER_OP2(asin, "asin")
NON_MEMBER_OP2(acos, "acos")
NON_MEMBER_OP2(atan, "atan")
NON_MEMBER_OP2(sinh, "sinh")
NON_MEMBER_OP2(cosh, "cosh")
NON_MEMBER_OP2(tanh, "tanh")
NON_MEMBER_OP2(asinh, "asinh")
NON_MEMBER_OP2(acosh, "acosh")
NON_MEMBER_OP2(atanh, "atanh")
NON_MEMBER_OP3(fmod, "fmod")
NON_MEMBER_OP3(pow, "pow")
NON_MEMBER_OP3(atan2, "atan2")
NON_MEMBER_OP2(conj, "conj")

template <class Backend>
int eval_signbit(const debug_adaptor<Backend>& val)
{
   using default_ops::eval_signbit;
   return eval_signbit(val.value());
}

template <class Backend>
std::size_t hash_value(const debug_adaptor<Backend>& val)
{
   return hash_value(val.value());
}

template <class Backend, expression_template_option ExpressionTemplates>
inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<debug_adaptor<Backend>, ExpressionTemplates>::value_type>::type
   numerator(const number<debug_adaptor<Backend>, ExpressionTemplates>& arg)
{
   number<Backend, ExpressionTemplates> t(arg.backend().value());
   return numerator(t).backend();
}
template <class Backend, expression_template_option ExpressionTemplates>
inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<debug_adaptor<Backend>, ExpressionTemplates>::value_type>::type
   denominator(const number<debug_adaptor<Backend>, ExpressionTemplates>& arg)
{
   number<Backend, ExpressionTemplates> t(arg.backend().value());
   return denominator(t).backend();
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_real(To& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_real;
   eval_real(to, from.value());
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_real(debug_adaptor<To>& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_real;
   eval_real(to.value(), from.value());
   to.update_view();
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_real(debug_adaptor<To>& to, const From& from)
{
   using default_ops::eval_real;
   eval_real(to.value(), from);
   to.update_view();
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_imag(To& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_imag;
   eval_imag(to, from.value());
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_imag(debug_adaptor<To>& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_imag;
   eval_imag(to.value(), from.value());
   to.update_view();
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_imag(debug_adaptor<To>& to, const From& from)
{
   using default_ops::eval_imag;
   eval_imag(to.value(), from);
   to.update_view();
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(To& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_set_real;
   eval_set_real(to, from.value());
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(debug_adaptor<To>& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_set_real;
   eval_set_real(to.value(), from.value());
   to.update_view();
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(debug_adaptor<To>& to, const From& from)
{
   using default_ops::eval_set_real;
   eval_set_real(to.value(), from);
   to.update_view();
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(To& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_set_imag;
   eval_set_imag(to, from.value());
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(debug_adaptor<To>& to, const debug_adaptor<From>& from)
{
   using default_ops::eval_set_imag;
   eval_set_imag(to.value(), from.value());
   to.update_view();
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(debug_adaptor<To>& to, const From& from)
{
   using default_ops::eval_set_imag;
   eval_set_imag(to.value(), from);
   to.update_view();
}


} // namespace backends

using backends::debug_adaptor;

namespace detail {
   template <class Backend>
   struct is_variable_precision<debug_adaptor<Backend> > : public is_variable_precision<Backend>
   {};
#ifdef BOOST_HAS_INT128
   template <class Backend>
   struct is_convertible_arithmetic<int128_type, debug_adaptor<Backend> > : public is_convertible_arithmetic<int128_type, Backend>
   {};
   template <class Backend>
   struct is_convertible_arithmetic<uint128_type, debug_adaptor<Backend> > : public is_convertible_arithmetic<uint128_type, Backend>
   {};
#endif
#ifdef BOOST_HAS_FLOAT128
   template <class Backend>
   struct is_convertible_arithmetic<float128_type, debug_adaptor<Backend> > : public is_convertible_arithmetic<float128_type, Backend>
   {};
#endif
   } // namespace detail

template <class Backend>
struct number_category<backends::debug_adaptor<Backend> > : public number_category<Backend>
{};

template <class Number>
using debug_adaptor_t = number<debug_adaptor<typename Number::backend_type>, Number::et>;


template <class Backend, expression_template_option ExpressionTemplates>
struct component_type<number<debug_adaptor<Backend>, ExpressionTemplates>>
{
   //
   // We'll make the component_type also a debug_adaptor:
   //
   using base_component_type = typename component_type<number<Backend, ExpressionTemplates>>::type;
   using base_component_backend = typename base_component_type::backend_type;
   using type = number<debug_adaptor<base_component_backend>, ExpressionTemplates>;
};

template <class Backend>
struct is_interval_number<backends::debug_adaptor<Backend> > : public is_interval_number<Backend> {};

}} // namespace boost::multiprecision

namespace std {

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<Backend>, ExpressionTemplates> >
    : public std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   using base_type = std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >                          ;
   using number_type = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<Backend>, ExpressionTemplates>;

 public:
   static number_type(min)() noexcept { return (base_type::min)(); }
   static number_type(max)() noexcept { return (base_type::max)(); }
   static number_type lowest() noexcept { return -(max)(); }
   static number_type epsilon() noexcept { return base_type::epsilon(); }
   static number_type round_error() noexcept { return epsilon() / 2; }
   static number_type infinity() noexcept { return base_type::infinity(); }
   static number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
   static number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
   static number_type denorm_min() noexcept { return base_type::denorm_min(); }
};

} // namespace std

#ifdef BOOST_MP_MATH_AVAILABLE
namespace boost {
namespace math {

namespace policies {

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
struct precision<boost::multiprecision::number<boost::multiprecision::debug_adaptor<Backend>, ExpressionTemplates>, Policy>
    : public precision<boost::multiprecision::number<Backend, ExpressionTemplates>, Policy>
{};

#undef NON_MEMBER_OP1
#undef NON_MEMBER_OP2
#undef NON_MEMBER_OP3
#undef NON_MEMBER_OP4

}

}} // namespace boost::math::policies
#else
#undef NON_MEMBER_OP1
#undef NON_MEMBER_OP2
#undef NON_MEMBER_OP3
#undef NON_MEMBER_OP4
#endif // BOOST_MP_MATH_AVAILABLE

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/assert.hpp
================================================
//  (C) Copyright Matt Borland 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// We deliberately use assert in here:
//
// boost-no-inspect

#ifndef BOOST_MP_DETAIL_ASSERT_HPP
#define BOOST_MP_DETAIL_ASSERT_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#ifndef BOOST_MP_STANDALONE

#include <boost/assert.hpp>
#define BOOST_MP_ASSERT(expr) BOOST_ASSERT(expr)
#define BOOST_MP_ASSERT_MSG(expr, msg) BOOST_ASSERT_MSG(expr, msg)

#else // Standalone mode - use cassert

#include <cassert>
#define BOOST_MP_ASSERT(expr) assert(expr)
#define BOOST_MP_ASSERT_MSG(expr, msg) assert((expr)&&(msg))

#endif

#endif // BOOST_MP_DETAIL_ASSERT_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/atomic.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2017 John Maddock
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_ATOMIC_HPP
#define BOOST_MP_DETAIL_ATOMIC_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#ifdef BOOST_HAS_THREADS

#  include <atomic>
#  define BOOST_MATH_ATOMIC_NS std
namespace boost {
   namespace multiprecision {
      namespace detail {
#if ATOMIC_INT_LOCK_FREE == 2
         using atomic_counter_type = std::atomic<int>;
         using atomic_unsigned_type = std::atomic<unsigned>;
         using atomic_integer_type = int;
         using atomic_unsigned_integer_type = unsigned;
#elif ATOMIC_SHORT_LOCK_FREE == 2
         using atomic_counter_type = std::atomic<short>;
         using atomic_unsigned_type = std::atomic<unsigned short>;
         using atomic_integer_type = short;
         using atomic_unsigned_integer_type = unsigned short;
#elif ATOMIC_LONG_LOCK_FREE == 2
         using atomic_unsigned_integer_type = std::atomic<long>;
         using atomic_unsigned_type = std::atomic<unsigned long>;
         using atomic_unsigned_integer_type = unsigned long;
         using atomic_integer_type = long;
#elif ATOMIC_LLONG_LOCK_FREE == 2
         using atomic_unsigned_integer_type = std::atomic<long long>;
         using atomic_unsigned_type = std::atomic<unsigned long long>;
         using atomic_integer_type = long long;
         using atomic_unsigned_integer_type = unsigned long long;
#else

#define BOOST_MT_NO_ATOMIC_INT

#endif
      }
   }}
#else // BOOST_HAS_THREADS

#define BOOST_MT_NO_ATOMIC_INT

#endif // BOOST_HAS_THREADS

namespace boost { namespace multiprecision { namespace detail {

#ifdef BOOST_MT_NO_ATOMIC_INT
using precision_type = unsigned;
#else
using precision_type = atomic_unsigned_type;
#endif

} } }

#endif // BOOST_MP_DETAIL_ATOMIC_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/bitscan.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Comparison operators for cpp_int_backend:
//
#ifndef BOOST_MP_DETAIL_BITSCAN_HPP
#define BOOST_MP_DETAIL_BITSCAN_HPP

#include <cstdint>
#include <climits>
#include <type_traits>
#include <boost/multiprecision/detail/endian.hpp>
#include <boost/multiprecision/detail/standalone_config.hpp>

#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
#include <intrin.h>
#endif

namespace boost { namespace multiprecision { namespace detail {

template <class Unsigned>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb_default(Unsigned mask)
{
   std::size_t result = 0;
   while (!(mask & 1u))
   {
      mask >>= 1;
      ++result;
   }
   return result;
}

template <class Unsigned>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb_default(Unsigned mask)
{
   std::size_t index = 0;
   while (mask)
   {
      ++index;
      mask >>= 1;
   }
   return --index;
}

template <class Unsigned>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask, const std::integral_constant<int, 0>&)
{
   return find_lsb_default(mask);
}

template <class Unsigned>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask, const std::integral_constant<int, 0>&)
{
   return find_msb_default(mask);
}

#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))

#pragma intrinsic(_BitScanForward, _BitScanReverse)

BOOST_FORCEINLINE std::size_t find_lsb(unsigned long mask, const std::integral_constant<int, 1>&)
{
   unsigned long result;
   _BitScanForward(&result, mask);
   return result;
}

BOOST_FORCEINLINE std::size_t find_msb(unsigned long mask, const std::integral_constant<int, 1>&)
{
   unsigned long result;
   _BitScanReverse(&result, mask);
   return result;
}
#ifdef _M_X64

#pragma intrinsic(_BitScanForward64, _BitScanReverse64)

BOOST_FORCEINLINE std::size_t find_lsb(unsigned __int64 mask, const std::integral_constant<int, 2>&)
{
   unsigned long result;
   _BitScanForward64(&result, mask);
   return result;
}
template <class Unsigned>
BOOST_FORCEINLINE std::size_t find_msb(Unsigned mask, const std::integral_constant<int, 2>&)
{
   unsigned long result;
   _BitScanReverse64(&result, mask);
   return result;
}
#endif

template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned long),
       std::integral_constant<int, 1>,
#ifdef _M_X64
       typename std::conditional<
           sizeof(Unsigned) <= sizeof(__int64),
           std::integral_constant<int, 2>,
           std::integral_constant<int, 0> >::type
#else
       std::integral_constant<int, 0>
#endif
       >::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_lsb_default(mask);
   }
   else
#endif
      return find_lsb(static_cast<ui_type>(mask), tag_type());
}

template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned long),
       std::integral_constant<int, 1>,
#ifdef _M_X64
       typename std::conditional<
           sizeof(Unsigned) <= sizeof(__int64),
           std::integral_constant<int, 2>,
           std::integral_constant<int, 0> >::type
#else
       std::integral_constant<int, 0>
#endif
       >::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_msb_default(mask);
   }
   else
#endif
      return find_msb(static_cast<ui_type>(mask), tag_type());
}

#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))

BOOST_FORCEINLINE std::size_t find_lsb(std::size_t mask, std::integral_constant<int, 1> const&)
{
   return static_cast<std::size_t>(__builtin_ctz(static_cast<unsigned int>(mask)));
}
BOOST_FORCEINLINE std::size_t find_lsb(unsigned long mask, std::integral_constant<int, 2> const&)
{
   return static_cast<std::size_t>(__builtin_ctzl(static_cast<unsigned long>(mask)));
}
BOOST_FORCEINLINE std::size_t find_lsb(unsigned long long mask, std::integral_constant<int, 3> const&)
{
   return static_cast<std::size_t>(__builtin_ctzll(static_cast<unsigned long long>(mask)));
}
BOOST_FORCEINLINE std::size_t find_msb(std::size_t mask, std::integral_constant<int, 1> const&)
{
   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clz(static_cast<unsigned int>(mask))));
}
BOOST_FORCEINLINE std::size_t find_msb(unsigned long mask, std::integral_constant<int, 2> const&)
{
   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned long) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clzl(static_cast<unsigned long>(mask))));
}
BOOST_FORCEINLINE std::size_t find_msb(unsigned long long mask, std::integral_constant<int, 3> const&)
{
   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned long long) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clzll(static_cast<unsigned long long>(mask))));
}
#ifdef BOOST_HAS_INT128

BOOST_FORCEINLINE std::size_t find_msb(uint128_type mask, std::integral_constant<int, 0> const&)
{
   union
   {
      uint128_type    v;
      std::uint64_t sv[2];
   } val;
   val.v = mask;
#if BOOST_MP_ENDIAN_LITTLE_BYTE
   if (val.sv[1])
      return find_msb(val.sv[1], std::integral_constant<int, 3>()) + 64;
   return find_msb(val.sv[0], std::integral_constant<int, 3>());
#else
   if (val.sv[0])
      return find_msb(val.sv[0], std::integral_constant<int, 3>()) + 64;
   return find_msb(val.sv[1], std::integral_constant<int, 3>());
#endif
}
BOOST_FORCEINLINE std::size_t find_lsb(uint128_type mask, std::integral_constant<int, 0> const&)
{
   union
   {
      uint128_type    v;
      std::uint64_t sv[2];
   } val;
   val.v = mask;
#if BOOST_MP_ENDIAN_LITTLE_BYTE
   if (val.sv[0] == 0)
      return find_lsb(val.sv[1], std::integral_constant<int, 3>()) + 64;
   return find_lsb(val.sv[0], std::integral_constant<int, 3>());
#else
   if (val.sv[1] == 0)
      return find_lsb(val.sv[0], std::integral_constant<int, 3>()) + 64;
   return find_lsb(val.sv[1], std::integral_constant<int, 3>());
#endif
}
#endif

template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned),
       std::integral_constant<int, 1>,
       typename std::conditional<
           sizeof(Unsigned) <= sizeof(unsigned long),
           std::integral_constant<int, 2>,
           typename std::conditional<
               sizeof(Unsigned) <= sizeof(unsigned long long),
               std::integral_constant<int, 3>,
               std::integral_constant<int, 0> >::type>::type>::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_lsb_default(mask);
   }
   else
#endif
   return find_lsb(static_cast<ui_type>(mask), tag_type());
}
template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned),
       std::integral_constant<int, 1>,
       typename std::conditional<
           sizeof(Unsigned) <= sizeof(unsigned long),
           std::integral_constant<int, 2>,
           typename std::conditional<
               sizeof(Unsigned) <= sizeof(unsigned long long),
               std::integral_constant<int, 3>,
               std::integral_constant<int, 0> >::type>::type>::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_msb_default(mask);
   }
   else
#endif
      return find_msb(static_cast<ui_type>(mask), tag_type());
}
#elif defined(BOOST_INTEL)
BOOST_FORCEINLINE std::size_t find_lsb(std::size_t mask, std::integral_constant<int, 1> const&)
{
   return _bit_scan_forward(mask);
}
BOOST_FORCEINLINE std::size_t find_msb(std::size_t mask, std::integral_constant<int, 1> const&)
{
   return _bit_scan_reverse(mask);
}
template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned),
       std::integral_constant<int, 1>,
       std::integral_constant<int, 0> >::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_lsb_default(mask);
   }
   else
#endif
      return find_lsb(static_cast<ui_type>(mask), tag_type());
}
template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
{
   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
   using tag_type = typename std::conditional<
       sizeof(Unsigned) <= sizeof(unsigned),
       std::integral_constant<int, 1>,
       std::integral_constant<int, 0> >::type;
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(mask))
   {
      return find_msb_default(mask);
   }
   else
#endif
      return find_msb(static_cast<ui_type>(mask), tag_type());
}
#else
template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
{
   return find_lsb(mask, std::integral_constant<int, 0>());
}
template <class Unsigned>
BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
{
   return find_msb(mask, std::integral_constant<int, 0>());
}
#endif

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/check_cpp11_config.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_CHECK_CPP11_CONFIG_HPP
#define BOOST_MP_CHECK_CPP11_CONFIG_HPP

//
// We now require C++11, if something we use is not supported, then error and say why:
//
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_RVALUE_REFERENCES being set"
#endif
#ifdef BOOST_NO_CXX11_TEMPLATE_ALIASES
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_TEMPLATE_ALIASES being set"
#endif
#ifdef BOOST_NO_CXX11_HDR_ARRAY
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_ARRAY being set"
#endif
#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_TYPE_TRAITS being set"
#endif
#ifdef BOOST_NO_CXX11_ALLOCATOR
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_ALLOCATOR being set"
#endif
#ifdef BOOST_NO_CXX11_CONSTEXPR
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_CONSTEXPR being set"
#endif
#ifdef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS being set"
#endif
#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_REF_QUALIFIERS being set"
#endif
#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_FUNCTIONAL being set"
#endif
#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_VARIADIC_TEMPLATES being set"
#endif
#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_USER_DEFINED_LITERALS being set"
#endif
#ifdef BOOST_NO_CXX11_DECLTYPE
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_DECLTYPE being set"
#endif
#ifdef BOOST_NO_CXX11_STATIC_ASSERT
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_STATIC_ASSERT being set"
#endif
#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_DEFAULTED_FUNCTIONS being set"
#endif
#ifdef BOOST_NO_CXX11_NOEXCEPT
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_NOEXCEPT being set"
#endif
#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_REF_QUALIFIERS being set"
#endif
#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_USER_DEFINED_LITERALS being set"
#endif

#endif // BOOST_MP_CHECK_CPP11_CONFIG_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/constexpr.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DETAIL_CONSTEXPR_HPP
#define BOOST_MP_DETAIL_CONSTEXPR_HPP

#include <cstring>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace boost {

namespace multiprecision {

namespace std_constexpr {

template <class T>
inline BOOST_CXX14_CONSTEXPR void swap(T& a, T& b)
{
   T t(a);
   a = b;
   b = t;
}

template <class InputIterator, class OutputIterator>
inline BOOST_CXX14_CONSTEXPR OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
{
   //
   // There are 3 branches here, only one of which is selected at compile time:
   //
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(*first))
   {
      // constexpr safe code, never generates runtime code:
      while (first != last)
      {
         *result = *first;
         ++first;
         ++result;
      }
      return result;
   }
   else
#endif
   {
#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
      if constexpr (std::is_pointer<InputIterator>::value && std::is_pointer<OutputIterator>::value && std::is_trivially_copyable<typename std::remove_reference<decltype(*first)>::type>::value)
      {
         // The normal runtime branch:
         std::memcpy(result, first, static_cast<std::size_t>(static_cast<std::size_t>(last - first) * sizeof(*first)));
         return result + (last - first);
      }
      else
#endif
      {
         // Alternate runtime branch:
         while (first != last)
         {
            *result = *first;
            ++first;
            ++result;
         }
         return result;
      }
   }
}

template <class I>
inline BOOST_CXX14_CONSTEXPR bool equal(const I* first, const I* last, const I* other)
{
   while (first != last)
   {
      if (*first != *other)
         return false;
      ++first;
      ++other;
   }
   return true;
}

}

}

} // namespace boost::multiprecision::std_constexpr

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/default_ops.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011-21 John Maddock.
//  Copyright 2021 Iskandarov Lev. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DEFAULT_OPS
#define BOOST_MP_DEFAULT_OPS

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/traits/is_backend.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <cstdint>
#include <complex>
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
#include <string_view>
#endif

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/math/special_functions/next.hpp>
#include <boost/math/special_functions/hypot.hpp>
#include <boost/math/policies/error_handling.hpp>
#endif

#ifndef INSTRUMENT_BACKEND
#ifndef BOOST_MP_INSTRUMENT
#define INSTRUMENT_BACKEND(x)
#else
#define INSTRUMENT_BACKEND(x) \
   std::cout << BOOST_STRINGIZE(x) << " = " << x.str(0, std::ios_base::scientific) << std::endl;
#endif
#endif

namespace boost {
namespace multiprecision {

namespace detail {

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/);
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_integer>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/);
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_floating_point>& /*from_type*/);
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_rational>& /*from_type*/);
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/);

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR Integer karatsuba_sqrt(const Integer& x, Integer& r, size_t bits);

} // namespace detail

namespace default_ops {

template <class T>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_backend<T>::value, int>::type eval_signbit(const T& val);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!boost::multiprecision::detail::is_backend<T>::value, int>::type eval_signbit(const T& val) { return val < 0; }

inline int eval_signbit(float val) { return (std::signbit)(val); }
inline int eval_signbit(double val) { return (std::signbit)(val); }
inline int eval_signbit(long double val) { return (std::signbit)(val); }
#ifdef BOOST_HAS_FLOAT128
extern "C" int signbitq(float128_type) throw();
inline int            eval_signbit(float128_type val) { return signbitq(val); }
#endif

template <class T>
BOOST_MP_CXX14_CONSTEXPR bool eval_is_zero(const T& val);

#ifdef BOOST_MSVC
// warning C4127: conditional expression is constant
// warning C4146: unary minus operator applied to unsigned type, result still unsigned
#pragma warning(push)
#pragma warning(disable : 4127 4146)
#endif
//
// Default versions of mixed arithmetic, these just construct a temporary
// from the arithmetic value and then do the arithmetic on that, two versions
// of each depending on whether the backend can be directly constructed from type V.
//
// Note that we have to provide *all* the template parameters to class number when used in
// enable_if as MSVC-10 won't compile the code if we rely on a computed-default parameter.
// Since the result of the test doesn't depend on whether expression templates are on or off
// we just use et_on everywhere.  We could use a BOOST_WORKAROUND but that just obfuscates the
// code even more....
//
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_convertible<V, T>::value>::type
eval_add(T& result, V const& v)
{
   T t;
   t = v;
   eval_add(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, T>::value>::type
eval_add(T& result, V const& v)
{
   T t(v);
   eval_add(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_convertible<V, T>::value>::type
eval_subtract(T& result, V const& v)
{
   T t;
   t = v;
   eval_subtract(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, T>::value>::type
eval_subtract(T& result, V const& v)
{
   T t(v);
   eval_subtract(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_convertible<V, T>::value>::type
eval_multiply(T& result, V const& v)
{
   T t;
   t = v;
   eval_multiply(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, T>::value>::type
eval_multiply(T& result, V const& v)
{
   T t(v);
   eval_multiply(result, t);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_multiply(T& t, const U& u, const V& v);

template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(!std::is_same<T, U>::value && std::is_same<T, V>::value)>::type eval_multiply_add(T& t, const U& u, const V& v)
{
   T z;
   eval_multiply(z, u, v);
   eval_add(t, z);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_same<T, U>::value && std::is_same<T, V>::value>::type eval_multiply_add(T& t, const U& u, const V& v)
{
   eval_multiply_add(t, v, u);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(!std::is_same<T, U>::value && std::is_same<T, V>::value)>::type eval_multiply_subtract(T& t, const U& u, const V& v)
{
   T z;
   eval_multiply(z, u, v);
   eval_subtract(t, z);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_same<T, U>::value && std::is_same<T, V>::value>::type eval_multiply_subtract(T& t, const U& u, const V& v)
{
   eval_multiply_subtract(t, v, u);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_divide(T& result, V const& v)
{
   T t;
   t = v;
   eval_divide(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_divide(T& result, V const& v)
{
   T t(v);
   eval_divide(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_modulus(T& result, V const& v)
{
   T t;
   t = v;
   eval_modulus(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_modulus(T& result, V const& v)
{
   T t(v);
   eval_modulus(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_bitwise_and(T& result, V const& v)
{
   T t;
   t = v;
   eval_bitwise_and(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_bitwise_and(T& result, V const& v)
{
   T t(v);
   eval_bitwise_and(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_bitwise_or(T& result, V const& v)
{
   T t;
   t = v;
   eval_bitwise_or(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_bitwise_or(T& result, V const& v)
{
   T t(v);
   eval_bitwise_or(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_bitwise_xor(T& result, V const& v)
{
   T t;
   t = v;
   eval_bitwise_xor(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_bitwise_xor(T& result, V const& v)
{
   T t(v);
   eval_bitwise_xor(result, t);
}

template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && !std::is_convertible<V, T>::value>::type
eval_complement(T& result, V const& v)
{
   T t;
   t = v;
   eval_complement(result, t);
}
template <class T, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, number<T, et_on> >::value && std::is_convertible<V, T>::value>::type
eval_complement(T& result, V const& v)
{
   T t(v);
   eval_complement(result, t);
}

//
// Default versions of 3-arg arithmetic functions, these mostly just forward to the 2 arg versions:
//
template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_add(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add_default(T& t, const T& u, const T& v)
{
   if (&t == &v)
   {
      eval_add(t, u);
   }
   else if (&t == &u)
   {
      eval_add(t, v);
   }
   else
   {
      t = u;
      eval_add(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_add_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_add(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_add_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_add(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value>::type eval_add_default(T& t, const U& u, const T& v)
{
   eval_add(t, v, u);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         eval_add(t, u);
      }
      else
      {
         t = u;
         eval_add(t, v);
      }
   }
   else
   {
      t = u;
      eval_add(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add(T& t, const U& u, const V& v)
{
   eval_add_default(t, u, v);
}

template <class T, class U, class V>
void BOOST_MP_CXX14_CONSTEXPR eval_subtract(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract_default(T& t, const T& u, const T& v)
{
   if ((&t == &v) && is_signed_number<T>::value)
   {
      eval_subtract(t, u);
      t.negate();
   }
   else if (&t == &u)
   {
      eval_subtract(t, v);
   }
   else
   {
      t = u;
      eval_subtract(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_subtract_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_subtract(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_subtract_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_subtract(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && is_signed_number<T>::value && (number_category<T>::value != number_kind_complex)>::type eval_subtract_default(T& t, const U& u, const T& v)
{
   eval_subtract(t, v, u);
   if(!eval_is_zero(t) || (eval_signbit(u) != eval_signbit(v)))
      t.negate();
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && is_signed_number<T>::value && (number_category<T>::value == number_kind_complex)>::type eval_subtract_default(T& t, const U& u, const T& v)
{
   eval_subtract(t, v, u);
   t.negate();
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value && is_unsigned_number<T>::value>::type eval_subtract_default(T& t, const U& u, const T& v)
{
   T temp;
   temp = u;
   eval_subtract(t, temp, v);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value && is_unsigned_number<T>::value>::type eval_subtract_default(T& t, const U& u, const T& v)
{
   T temp(u);
   eval_subtract(t, temp, v);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         eval_subtract(t, u);
         t.negate();
      }
      else
      {
         t = u;
         eval_subtract(t, v);
      }
   }
   else
   {
      t = u;
      eval_subtract(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(T& t, const U& u, const V& v)
{
   eval_subtract_default(t, u, v);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply_default(T& t, const T& u, const T& v)
{
   if (&t == &v)
   {
      eval_multiply(t, u);
   }
   else if (&t == &u)
   {
      eval_multiply(t, v);
   }
   else
   {
      t = u;
      eval_multiply(t, v);
   }
}
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1900)
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_multiply_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_multiply(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_multiply_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_multiply(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value>::type eval_multiply_default(T& t, const U& u, const T& v)
{
   eval_multiply(t, v, u);
}
#endif
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         eval_multiply(t, u);
      }
      else
      {
         t = number<T>::canonical_value(u);
         eval_multiply(t, v);
      }
   }
   else
   {
      t = number<T>::canonical_value(u);
      eval_multiply(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(T& t, const U& u, const V& v)
{
   eval_multiply_default(t, u, v);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply_add(T& t, const T& u, const T& v, const T& x)
{
   if ((void*)&x == (void*)&t)
   {
      T z;
      z = number<T>::canonical_value(x);
      eval_multiply_add(t, u, v, z);
   }
   else
   {
      eval_multiply(t, u, v);
      eval_add(t, x);
   }
}

template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_same<T, U>::value, T>::type make_T(const U& u)
{
   T t;
   t = number<T>::canonical_value(u);
   return t;
}
template <class T>
inline BOOST_MP_CXX14_CONSTEXPR const T& make_T(const T& t)
{
   return t;
}

template <class T, class U, class V, class X>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(!std::is_same<T, U>::value && std::is_same<T, V>::value)>::type eval_multiply_add(T& t, const U& u, const V& v, const X& x)
{
   eval_multiply_add(t, make_T<T>(u), make_T<T>(v), make_T<T>(x));
}
template <class T, class U, class V, class X>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_same<T, U>::value && std::is_same<T, V>::value>::type eval_multiply_add(T& t, const U& u, const V& v, const X& x)
{
   eval_multiply_add(t, v, u, x);
}
template <class T, class U, class V, class X>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(!std::is_same<T, U>::value && std::is_same<T, V>::value)>::type eval_multiply_subtract(T& t, const U& u, const V& v, const X& x)
{
   if ((void*)&x == (void*)&t)
   {
      T z;
      z = x;
      eval_multiply_subtract(t, u, v, z);
   }
   else
   {
      eval_multiply(t, u, v);
      eval_subtract(t, x);
   }
}
template <class T, class U, class V, class X>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_same<T, U>::value && std::is_same<T, V>::value>::type eval_multiply_subtract(T& t, const U& u, const V& v, const X& x)
{
   eval_multiply_subtract(t, v, u, x);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_divide(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide_default(T& t, const T& u, const T& v)
{
   if (&t == &u)
      eval_divide(t, v);
   else if (&t == &v)
   {
      T temp;
      eval_divide(temp, u, v);
      temp.swap(t);
   }
   else
   {
      t = u;
      eval_divide(t, v);
   }
}
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1900)
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_divide_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_divide(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_divide_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_divide(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_divide_default(T& t, const U& u, const T& v)
{
   T uu;
   uu = u;
   eval_divide(t, uu, v);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_divide_default(T& t, const U& u, const T& v)
{
   T uu(u);
   eval_divide(t, uu, v);
}
#endif
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         T temp;
         temp = u;
         eval_divide(temp, v);
         t = temp;
      }
      else
      {
         t = u;
         eval_divide(t, v);
      }
   }
   else
   {
      t = u;
      eval_divide(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide(T& t, const U& u, const V& v)
{
   eval_divide_default(t, u, v);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_modulus(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_modulus_default(T& t, const T& u, const T& v)
{
   if (&t == &u)
      eval_modulus(t, v);
   else if (&t == &v)
   {
      T temp;
      eval_modulus(temp, u, v);
      temp.swap(t);
   }
   else
   {
      t = u;
      eval_modulus(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_modulus_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_modulus(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_modulus_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_modulus(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_modulus_default(T& t, const U& u, const T& v)
{
   T uu;
   uu = u;
   eval_modulus(t, uu, v);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_modulus_default(T& t, const U& u, const T& v)
{
   T uu(u);
   eval_modulus(t, uu, v);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_modulus_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         T temp(u);
         eval_modulus(temp, v);
         t = temp;
      }
      else
      {
         t = u;
         eval_modulus(t, v);
      }
   }
   else
   {
      t = u;
      eval_modulus(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_modulus(T& t, const U& u, const V& v)
{
   eval_modulus_default(t, u, v);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_and(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_and_default(T& t, const T& u, const T& v)
{
   if (&t == &v)
   {
      eval_bitwise_and(t, u);
   }
   else if (&t == &u)
   {
      eval_bitwise_and(t, v);
   }
   else
   {
      t = u;
      eval_bitwise_and(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !std::is_convertible<U, T>::value>::type eval_bitwise_and_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_bitwise_and(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, T>::value>::type eval_bitwise_and_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_bitwise_and(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value>::type eval_bitwise_and_default(T& t, const U& u, const T& v)
{
   eval_bitwise_and(t, v, u);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_same<T, U>::value || std::is_same<T, V>::value>::type eval_bitwise_and_default(T& t, const U& u, const V& v)
{
   t = u;
   eval_bitwise_and(t, v);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_and(T& t, const U& u, const V& v)
{
   eval_bitwise_and_default(t, u, v);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_or(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_or_default(T& t, const T& u, const T& v)
{
   if (&t == &v)
   {
      eval_bitwise_or(t, u);
   }
   else if (&t == &u)
   {
      eval_bitwise_or(t, v);
   }
   else
   {
      t = u;
      eval_bitwise_or(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_bitwise_or_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_bitwise_or(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_bitwise_or_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_bitwise_or(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value>::type eval_bitwise_or_default(T& t, const U& u, const T& v)
{
   eval_bitwise_or(t, v, u);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_or_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         eval_bitwise_or(t, u);
      }
      else
      {
         t = u;
         eval_bitwise_or(t, v);
      }
   }
   else
   {
      t = u;
      eval_bitwise_or(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_or(T& t, const U& u, const V& v)
{
   eval_bitwise_or_default(t, u, v);
}

template <class T, class U, class V>
BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_xor(T& t, const U& u, const V& v);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_xor_default(T& t, const T& u, const T& v)
{
   if (&t == &v)
   {
      eval_bitwise_xor(t, u);
   }
   else if (&t == &u)
   {
      eval_bitwise_xor(t, v);
   }
   else
   {
      t = u;
      eval_bitwise_xor(t, v);
   }
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && !std::is_convertible<U, T>::value>::type eval_bitwise_xor_default(T& t, const T& u, const U& v)
{
   T vv;
   vv = v;
   eval_bitwise_xor(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value && std::is_convertible<U, T>::value>::type eval_bitwise_xor_default(T& t, const T& u, const U& v)
{
   T vv(v);
   eval_bitwise_xor(t, u, vv);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<U, number<T, et_on> >::value>::type eval_bitwise_xor_default(T& t, const U& u, const T& v)
{
   eval_bitwise_xor(t, v, u);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_xor_default(T& t, const U& u, const V& v)
{
   BOOST_IF_CONSTEXPR(std::is_same<T, V>::value)
   {
      if ((void*)&t == (void*)&v)
      {
         eval_bitwise_xor(t, u);
      }
      else
      {
         t = u;
         eval_bitwise_xor(t, v);
      }
   }
   else
   {
      t = u;
      eval_bitwise_xor(t, v);
   }
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_xor(T& t, const U& u, const V& v)
{
   eval_bitwise_xor_default(t, u, v);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_increment(T& val)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   eval_add(val, static_cast<ui_type>(1u));
}
template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_decrement(T& val)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   eval_subtract(val, static_cast<ui_type>(1u));
}

template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_left_shift(T& result, const U& arg, const V val)
{
   result = arg;
   eval_left_shift(result, val);
}

template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_right_shift(T& result, const U& arg, const V val)
{
   result = arg;
   eval_right_shift(result, val);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_is_zero(const T& val)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   return val.compare(static_cast<ui_type>(0)) == 0;
}
template <class T>
inline BOOST_MP_CXX14_CONSTEXPR int eval_get_sign(const T& val)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   return val.compare(static_cast<ui_type>(0));
}

template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp2(T& result, const V& v1, const U& v2, const std::false_type&, const std::false_type&)
{
   using component_number_type = typename component_type<number<T> >::type;

   boost::multiprecision::detail::scoped_precision_options<component_number_type> sp(result);
   (void)sp;

   component_number_type x(v1), y(v2);
   assign_components(result, x.backend(), y.backend());
}
template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp2(T& result, const V& v1, const U& v2, const std::true_type&, const std::false_type&)
{
   boost::multiprecision::detail::scoped_source_precision<number<V>> scope;
   (void)scope;
   assign_components_imp2(result, number<V>(v1), v2, std::false_type(), std::false_type());
}
template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp2(T& result, const V& v1, const U& v2, const std::true_type&, const std::true_type&)
{
   boost::multiprecision::detail::scoped_source_precision<number<V>> scope1;
   boost::multiprecision::detail::scoped_source_precision<number<U>> scope2;
   (void)scope1;
   (void)scope2;
   assign_components_imp2(result, number<V>(v1), number<U>(v2), std::false_type(), std::false_type());
}
template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp2(T& result, const V& v1, const U& v2, const std::false_type&, const std::true_type&)
{
   boost::multiprecision::detail::scoped_source_precision<number<U>> scope;
   (void)scope;
   assign_components_imp2(result, v1, number<U>(v2), std::false_type(), std::false_type());
}


template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp(T& result, const V& v1, const U& v2, const std::integral_constant<int, number_kind_rational>&)
{
   result = v1;
   T t;
   t = v2;
   eval_divide(result, t);
}

template <class T, class V, class U, int N>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components_imp(T& result, const V& v1, const U& v2, const std::integral_constant<int, N>&)
{
   assign_components_imp2(result, v1, v2, boost::multiprecision::detail::is_backend<V>(), boost::multiprecision::detail::is_backend<U>());
}

template <class T, class V, class U>
inline BOOST_MP_CXX14_CONSTEXPR void assign_components(T& result, const V& v1, const U& v2)
{
   return assign_components_imp(result, v1, v2, typename number_category<T>::type());
}
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
template <class Result, class Traits>
inline void assign_from_string_view(Result& result, const std::basic_string_view<char, Traits>& view)
{
   // since most (all?) backends require a const char* to construct from, we just
   // convert to that:
   std::string s(view);
   result = s.c_str();
}
template <class Result, class Traits>
inline void assign_from_string_view(Result& result, const std::basic_string_view<char, Traits>& view_x, const std::basic_string_view<char, Traits>& view_y)
{
   // since most (all?) backends require a const char* to construct from, we just
   // convert to that:
   std::string x(view_x), y(view_y);
   assign_components(result, x.c_str(), y.c_str());
}
#endif
template <class R, int b>
struct has_enough_bits
{
   template <class T>
   struct type : public std::integral_constant<bool, !std::is_same<R, T>::value && (std::numeric_limits<T>::digits >= b)>
   {};
};

template <class R>
struct terminal
{
   BOOST_MP_CXX14_CONSTEXPR terminal(const R& v) : value(v) {}
   BOOST_MP_CXX14_CONSTEXPR terminal() {}
   BOOST_MP_CXX14_CONSTEXPR terminal& operator=(R val)
   {
      value = val;
      return *this;
   }
   R value;
   BOOST_MP_CXX14_CONSTEXPR operator R() const { return value; }
};

template <class Tuple, int i, class T, bool = (i == std::tuple_size<Tuple>::value)>
struct find_index_of_type
{
   static constexpr int value =
      std::is_same<T, typename std::tuple_element<static_cast<std::size_t>(i), Tuple>::type>::value
         ? i
         : find_index_of_type<Tuple, i + 1, T>::value;
};
template <class Tuple, int i, class T>
struct find_index_of_type<Tuple, i, T, true>
{
   static constexpr int value = -1;
};


template <class R, class B>
struct calculate_next_larger_type
{
   // Find which list we're looking through:
   using list_type = typename std::conditional<
       boost::multiprecision::detail::is_signed<R>::value && boost::multiprecision::detail::is_integral<R>::value,
       typename B::signed_types,
       typename std::conditional<
           boost::multiprecision::detail::is_unsigned<R>::value,
           typename B::unsigned_types,
           typename B::float_types>::type>::type;
   static constexpr int start = find_index_of_type<list_type, 0, R>::value;
   static constexpr int index_of_type = boost::multiprecision::detail::find_index_of_large_enough_type<list_type, start == INT_MAX ? 0 : start + 1, boost::multiprecision::detail::bits_of<R>::value> ::value;
   using type = typename boost::multiprecision::detail::dereference_tuple<index_of_type, list_type, terminal<R> >::type;
};

template <class R, class T>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<R>::value, bool>::type check_in_range(const T& t)
{
   // Can t fit in an R?
   if ((t > 0) && std::numeric_limits<R>::is_specialized && std::numeric_limits<R>::is_bounded && (t > (std::numeric_limits<R>::max)()))
      return true;
   else
      return false;
}

template <class R, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<R>::value>::type eval_convert_to(R* result, const B& backend)
{
   using next_type = typename calculate_next_larger_type<R, B>::type;
   next_type                                               n = next_type();
   eval_convert_to(&n, backend);
   BOOST_IF_CONSTEXPR(!boost::multiprecision::detail::is_unsigned<R>::value && std::numeric_limits<R>::is_specialized && std::numeric_limits<R>::is_bounded)
   {
      if(n > static_cast<next_type>((std::numeric_limits<R>::max)()))
      {
         *result = (std::numeric_limits<R>::max)();
         return;
      }
   }
   BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_specialized&& std::numeric_limits<R>::is_bounded)
   {
      if (n < static_cast<next_type>((std::numeric_limits<R>::min)()))
      {
         *result = (std::numeric_limits<R>::min)();
         return;
      }
   }
   *result = static_cast<R>(n);
}

template <class R, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< !boost::multiprecision::detail::is_integral<R>::value && !std::is_enum<R>::value>::type eval_convert_to(R* result, const B& backend)
{
   using next_type = typename calculate_next_larger_type<R, B>::type;
   next_type                                               n = next_type();
   eval_convert_to(&n, backend);
   BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_specialized && std::numeric_limits<R>::is_bounded)
   {
      if ((n > (next_type)(std::numeric_limits<R>::max)() || (n < (next_type) - (std::numeric_limits<R>::max)())))
      {
         *result = n > 0 ? (std::numeric_limits<R>::max)() : -(std::numeric_limits<R>::max)();
      }
      else
         *result = static_cast<R>(n);
   }
   else
      *result = static_cast<R>(n);
}

template <class R, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_enum<R>::value>::type eval_convert_to(R* result, const B& backend)
{
   typename std::underlying_type<R>::type t{};
   eval_convert_to(&t, backend);
   *result = static_cast<R>(t);
}

#ifndef BOOST_MP_STANDALONE
template <class R, class B>
inline void last_chance_eval_convert_to(terminal<R>* result, const B& backend, const std::integral_constant<bool, false>&)
{
   //
   // We ran out of types to try for the conversion, try
   // a lexical_cast and hope for the best:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<R>::is_integer && !std::numeric_limits<R>::is_signed)
      if (eval_get_sign(backend) < 0)
         BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to convert negative value to an unsigned integer results in undefined behaviour"));
   BOOST_MP_TRY {
      result->value = boost::lexical_cast<R>(backend.str(0, std::ios_base::fmtflags(0)));
   }
   BOOST_MP_CATCH (const bad_lexical_cast&)
   {
      if (eval_get_sign(backend) < 0)
      {
         BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_integer && !std::numeric_limits<R>::is_signed)
            *result = (std::numeric_limits<R>::max)(); // we should never get here, exception above will be raised.
         else BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_integer)
            *result = (std::numeric_limits<R>::min)();
         else
            *result = -(std::numeric_limits<R>::max)();
      }
      else
         *result = (std::numeric_limits<R>::max)();
   }
   BOOST_MP_CATCH_END
}

template <class R, class B>
inline void last_chance_eval_convert_to(terminal<R>* result, const B& backend, const std::integral_constant<bool, true>&)
{
   //
   // Last chance conversion to an unsigned integer.
   // We ran out of types to try for the conversion, try
   // a lexical_cast and hope for the best:
   //
   if (eval_get_sign(backend) < 0)
      BOOST_MP_THROW_EXCEPTION(std::range_error("Attempt to convert negative value to an unsigned integer results in undefined behaviour"));
   BOOST_MP_TRY {
      B t(backend);
      R mask = ~static_cast<R>(0u);
      eval_bitwise_and(t, mask);
      result->value = boost::lexical_cast<R>(t.str(0, std::ios_base::fmtflags(0)));
   }
   BOOST_MP_CATCH (const bad_lexical_cast&)
   {
      // We should never really get here...
      *result = (std::numeric_limits<R>::max)();
   }
   BOOST_MP_CATCH_END
}
#else // Using standalone mode

template <class R, class B>
inline void last_chance_eval_convert_to(terminal<R>*, const B&, const std::integral_constant<bool, false>&)
{
   static_assert(sizeof(R) == 1, "This type can not be used in standalone mode. Please de-activate and file a bug at https://github.com/boostorg/multiprecision/");
}

template <class R, class B>
inline void last_chance_eval_convert_to(terminal<R>* result, const B& backend, const std::integral_constant<bool, true>&)
{
   static_cast<void>(result);
   static_cast<void>(backend);

   static_assert(sizeof(R) == 1, "This type can not be used in standalone mode. Please de-activate and file a bug at https://github.com/boostorg/multiprecision/");
}
#endif

template <class R, class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(terminal<R>* result, const B& backend)
{
   using tag_type = std::integral_constant<bool, boost::multiprecision::detail::is_unsigned<R>::value && number_category<B>::value == number_kind_integer>;
   last_chance_eval_convert_to(result, backend, tag_type());
}

template <class B1, class B2, expression_template_option et>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(terminal<number<B1, et> >* result, const B2& backend)
{
   //
   // We ran out of types to try for the conversion, try
   // a generic conversion and hope for the best:
   //
   boost::multiprecision::detail::generic_interconvert(result->value.backend(), backend, number_category<B1>(), number_category<B2>());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(std::string* result, const B& backend)
{
   *result = backend.str(0, std::ios_base::fmtflags(0));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(std::complex<float>* result, const B& backend)
{
   using scalar_type = typename scalar_result_from_possible_complex<multiprecision::number<B> >::type;
   scalar_type                                                                            re, im;
   eval_real(re.backend(), backend);
   eval_imag(im.backend(), backend);

   *result = std::complex<float>(re.template convert_to<float>(), im.template convert_to<float>());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(std::complex<double>* result, const B& backend)
{
   using scalar_type = typename scalar_result_from_possible_complex<multiprecision::number<B> >::type;
   scalar_type                                                                            re, im;
   eval_real(re.backend(), backend);
   eval_imag(im.backend(), backend);

   *result = std::complex<double>(re.template convert_to<double>(), im.template convert_to<double>());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(std::complex<long double>* result, const B& backend)
{
   using scalar_type = typename scalar_result_from_possible_complex<multiprecision::number<B> >::type;
   scalar_type                                                                            re, im;
   eval_real(re.backend(), backend);
   eval_imag(im.backend(), backend);

   *result = std::complex<long double>(re.template convert_to<long double>(), im.template convert_to<long double>());
}

//
// Functions:
//
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR void eval_abs(T& result, const U& arg)
{
   using type_list = typename U::signed_types            ;
   using front = typename std::tuple_element<0, type_list>::type;
   result = arg;
   if (arg.compare(front(0)) < 0)
      result.negate();
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fabs(T& result, const U& arg)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The fabs function is only valid for floating point types.");
   using type_list = typename U::signed_types            ;
   using front = typename std::tuple_element<0, type_list>::type;
   result = arg;
   if (arg.compare(front(0)) < 0)
      result.negate();
}

template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR int eval_fpclassify(const Backend& arg)
{
   static_assert(number_category<Backend>::value == number_kind_floating_point, "The fpclassify function is only valid for floating point types.");
   return eval_is_zero(arg) ? FP_ZERO : FP_NORMAL;
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fmod(T& result, const T& a, const T& b)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The fmod function is only valid for floating point types.");
   if ((&result == &a) || (&result == &b))
   {
      T temp;
      eval_fmod(temp, a, b);
      result = temp;
      return;
   }
   switch (eval_fpclassify(a))
   {
   case FP_ZERO:
      result = a;
      return;
   case FP_INFINITE:
   case FP_NAN:
      result = std::numeric_limits<number<T> >::quiet_NaN().backend();
      errno  = EDOM;
      return;
   }
   switch (eval_fpclassify(b))
   {
   case FP_ZERO:
   case FP_NAN:
      result = std::numeric_limits<number<T> >::quiet_NaN().backend();
      errno  = EDOM;
      return;
   }
   T n;
   eval_divide(result, a, b);
   if (eval_get_sign(result) < 0)
      eval_ceil(n, result);
   else
      eval_floor(n, result);
   eval_multiply(n, b);
   eval_subtract(result, a, n);
}
template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_fmod(T& result, const T& x, const A& a)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = a;
   eval_fmod(result, x, c);
}

template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_fmod(T& result, const A& x, const T& a)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = x;
   eval_fmod(result, c, a);
}

template <class T>
BOOST_MP_CXX14_CONSTEXPR void eval_round(T& result, const T& a);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_remquo(T& result, const T& a, const T& b, int* pi)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The remquo function is only valid for floating point types.");
   if ((&result == &a) || (&result == &b))
   {
      T temp;
      eval_remquo(temp, a, b, pi);
      result = temp;
      return;
   }
   T n;
   eval_divide(result, a, b);
   eval_round(n, result);
   eval_convert_to(pi, n);
   eval_multiply(n, b);
   eval_subtract(result, a, n);
   if (eval_is_zero(result))
   {
      if (eval_signbit(a))
         result.negate();
   }
}
template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_remquo(T& result, const T& x, const A& a, int* pi)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c = cast_type();
   c = a;
   eval_remquo(result, x, c, pi);
}
template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_remquo(T& result, const A& x, const T& a, int* pi)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c = cast_type();
   c = x;
   eval_remquo(result, c, a, pi);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_remainder(T& result, const U& a, const V& b)
{
   int i(0);
   eval_remquo(result, a, b, &i);
}

template <class B>
BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const B& a, const B& b);
template <class T, class U>
BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const T& a, const U& b);
template <class B>
BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const B& a, const B& b);
template <class T, class U>
BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const T& a, const U& b);

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fdim(T& result, const T& a, const T& b)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   const ui_type                                                                zero = 0u;
   switch (eval_fpclassify(b))
   {
   case FP_NAN:
   case FP_INFINITE:
      result = zero;
      return;
   }
   switch (eval_fpclassify(a))
   {
   case FP_NAN:
      result = zero;
      return;
   case FP_INFINITE:
      result = a;
      return;
   }
   if (eval_gt(a, b))
   {
      eval_subtract(result, a, b);
   }
   else
      result = zero;
}

template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value>::type eval_fdim(T& result, const T& a, const A& b)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   using arithmetic_type = typename boost::multiprecision::detail::canonical<A, T>::type       ;
   const ui_type                                                                zero        = 0u;
   arithmetic_type                                                              canonical_b = b;
   switch (BOOST_MP_FPCLASSIFY(b))
   {
   case FP_NAN:
   case FP_INFINITE:
      result = zero;
      return;
   }
   switch (eval_fpclassify(a))
   {
   case FP_NAN:
      result = zero;
      return;
   case FP_INFINITE:
      result = a;
      return;
   }
   if (eval_gt(a, canonical_b))
   {
      eval_subtract(result, a, canonical_b);
   }
   else
      result = zero;
}

template <class T, class A>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value>::type eval_fdim(T& result, const A& a, const T& b)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   using arithmetic_type = typename boost::multiprecision::detail::canonical<A, T>::type       ;
   const ui_type                                                                zero        = 0u;
   arithmetic_type                                                              canonical_a = a;
   switch (eval_fpclassify(b))
   {
   case FP_NAN:
   case FP_INFINITE:
      result = zero;
      return;
   }
   switch (BOOST_MP_FPCLASSIFY(a))
   {
   case FP_NAN:
      result = zero;
      return;
   case FP_INFINITE:
      result = std::numeric_limits<number<T> >::infinity().backend();
      return;
   }
   if (eval_gt(canonical_a, b))
   {
      eval_subtract(result, canonical_a, b);
   }
   else
      result = zero;
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_trunc(T& result, const T& a)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The trunc function is only valid for floating point types.");
   switch (eval_fpclassify(a))
   {
   case FP_NAN:
      errno = EDOM;
      // fallthrough...
   case FP_ZERO:
   case FP_INFINITE:
      result = a;
      return;
   }
   if (eval_get_sign(a) < 0)
      eval_ceil(result, a);
   else
      eval_floor(result, a);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_modf(T& result, T const& arg, T* pipart)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   int                                                                          c = eval_fpclassify(arg);
   if (c == static_cast<int>(FP_NAN))
   {
      if (pipart)
         *pipart = arg;
      result = arg;
      return;
   }
   else if (c == static_cast<int>(FP_INFINITE))
   {
      if (pipart)
         *pipart = arg;
      result = ui_type(0u);
      return;
   }
   if (pipart)
   {
      eval_trunc(*pipart, arg);
      eval_subtract(result, arg, *pipart);
   }
   else
   {
      T ipart;
      eval_trunc(ipart, arg);
      eval_subtract(result, arg, ipart);
   }
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_round(T& result, const T& a)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The round function is only valid for floating point types.");
   using fp_type = typename boost::multiprecision::detail::canonical<float, T>::type;
   int                                                                       c = eval_fpclassify(a);
   if (c == static_cast<int>(FP_NAN))
   {
      result = a;
      errno  = EDOM;
      return;
   }
   if ((c == FP_ZERO) || (c == static_cast<int>(FP_INFINITE)))
   {
      result = a;
   }
   else if (eval_get_sign(a) < 0)
   {
      eval_subtract(result, a, fp_type(0.5f));
      eval_ceil(result, result);
   }
   else
   {
      eval_add(result, a, fp_type(0.5f));
      eval_floor(result, result);
   }
}

template <class B>
BOOST_MP_CXX14_CONSTEXPR void eval_lcm(B& result, const B& a, const B& b);
template <class B>
BOOST_MP_CXX14_CONSTEXPR void eval_gcd(B& result, const B& a, const B& b);

template <class T, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Arithmetic>::value >::type eval_gcd(T& result, const T& a, const Arithmetic& b)
{
   using si_type = typename boost::multiprecision::detail::canonical<Arithmetic, T>::type;
   using default_ops::eval_gcd;
   T t;
   t = static_cast<si_type>(b);
   eval_gcd(result, a, t);
}
template <class T, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Arithmetic>::value >::type eval_gcd(T& result, const Arithmetic& a, const T& b)
{
   eval_gcd(result, b, a);
}
template <class T, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Arithmetic>::value >::type eval_lcm(T& result, const T& a, const Arithmetic& b)
{
   using si_type = typename boost::multiprecision::detail::canonical<Arithmetic, T>::type;
   using default_ops::eval_lcm;
   T t;
   t = static_cast<si_type>(b);
   eval_lcm(result, a, t);
}
template <class T, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Arithmetic>::value >::type eval_lcm(T& result, const Arithmetic& a, const T& b)
{
   eval_lcm(result, b, a);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t eval_lsb(const T& val)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   int                                                                          c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   std::size_t result = 0;
   T        mask, t;
   mask = ui_type(1);
   do
   {
      eval_bitwise_and(t, mask, val);
      ++result;
      eval_left_shift(mask, 1);
   } while (eval_is_zero(t));

   return --result;
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR std::ptrdiff_t eval_msb(const T& val)
{
   int c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   //
   // This implementation is really really rubbish - it does
   // a linear scan for the most-significant-bit.  We should really
   // do a binary search, but as none of our backends actually needs
   // this implementation, we'll leave it for now.  In fact for most
   // backends it's likely that there will always be a more efficient
   // native implementation possible.
   //
   std::size_t result = 0;
   T        t(val);
   while (!eval_is_zero(t))
   {
      eval_right_shift(t, 1);
      ++result;
   }
   --result;

   return static_cast<std::ptrdiff_t>(result);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_bit_test(const T& val, std::size_t index)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   T                                                                            mask, t;
   mask = ui_type(1);
   eval_left_shift(mask, index);
   eval_bitwise_and(t, mask, val);
   return !eval_is_zero(t);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bit_set(T& val, std::size_t index)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   T                                                                            mask;
   mask = ui_type(1);
   eval_left_shift(mask, index);
   eval_bitwise_or(val, mask);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bit_flip(T& val, std::size_t index)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   T                                                                            mask;
   mask = ui_type(1);
   eval_left_shift(mask, index);
   eval_bitwise_xor(val, mask);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bit_unset(T& val, std::size_t index)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   T                                                                            mask, t;
   mask = ui_type(1);
   eval_left_shift(mask, index);
   eval_bitwise_and(t, mask, val);
   if (!eval_is_zero(t))
      eval_bitwise_xor(val, mask);
}

template <class Backend>
BOOST_MP_CXX14_CONSTEXPR void eval_qr(const Backend& x, const Backend& y, Backend& q, Backend& r);

template <class Backend>
BOOST_MP_CXX14_CONSTEXPR void eval_karatsuba_sqrt(Backend& result, const Backend& x, Backend& r, Backend& t, size_t bits)
{
   using default_ops::eval_is_zero;
   using default_ops::eval_subtract;
   using default_ops::eval_right_shift;
   using default_ops::eval_left_shift;
   using default_ops::eval_bit_set;
   using default_ops::eval_decrement;
   using default_ops::eval_bitwise_and;
   using default_ops::eval_add;
   using default_ops::eval_qr;

   using small_uint = typename std::tuple_element<0, typename Backend::unsigned_types>::type;

   constexpr small_uint zero = 0u;

   // we can calculate it faster with std::sqrt
#ifdef BOOST_HAS_INT128
   if (bits <= 128)
   {
      uint128_type a{}, b{}, c{};
      eval_convert_to(&a, x);
      c = boost::multiprecision::detail::karatsuba_sqrt(a, b, bits);
      r = number<Backend>::canonical_value(b);
      result = number<Backend>::canonical_value(c);
      return;
   }
#else
   if (bits <= std::numeric_limits<std::uintmax_t>::digits)
   {
      std::uintmax_t a{ 0 }, b{ 0 }, c{ 0 };
      eval_convert_to(&a, x);
      c = boost::multiprecision::detail::karatsuba_sqrt(a, b, bits);
      r = number<Backend>::canonical_value(b);
      result = number<Backend>::canonical_value(c);
      return;
   }
#endif
   // https://hal.inria.fr/file/index/docid/72854/filename/RR-3805.pdf
   std::size_t  b = bits / 4;
   Backend q(x);
   eval_right_shift(q, b * 2);
   Backend s;
   eval_karatsuba_sqrt(s, q, r, t, bits - b * 2);
   t = zero;
   eval_bit_set(t, static_cast<unsigned>(b * 2));
   eval_left_shift(r, b);
   eval_decrement(t);
   eval_bitwise_and(t, x);
   eval_right_shift(t, b);
   eval_add(t, r);
   eval_left_shift(s, 1u);
   eval_qr(t, s, q, r);
   eval_left_shift(r, b);
   t = zero;
   eval_bit_set(t, static_cast<unsigned>(b));
   eval_decrement(t);
   eval_bitwise_and(t, x);
   eval_add(r, t);
   eval_left_shift(s, b - 1);
   eval_add(s, q);
   eval_multiply(q, q);
   // we substract after, so it works for unsigned integers too
   if (r.compare(q) < 0)
   {
      t = s;
      eval_left_shift(t, 1u);
      eval_decrement(t);
      eval_add(r, t);
      eval_decrement(s);
   }
   eval_subtract(r, q);
   result = s;
}

template <class B>
void BOOST_MP_CXX14_CONSTEXPR eval_integer_sqrt_bitwise(B& s, B& r, const B& x)
{
   //
   // This is slow bit-by-bit integer square root, see for example
   // http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_.28base_2.29
   // There are better methods such as http://hal.inria.fr/docs/00/07/28/54/PDF/RR-3805.pdf
   // and http://hal.inria.fr/docs/00/07/21/13/PDF/RR-4475.pdf which should be implemented
   // at some point.
   //
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, B>::type;

   s = ui_type(0u);
   if (eval_get_sign(x) == 0)
   {
      r = ui_type(0u);
      return;
   }
   std::ptrdiff_t g = static_cast<std::ptrdiff_t>(eval_msb(x));
   if (g <= 1)
   {
      s = ui_type(1);
      eval_subtract(r, x, s);
      return;
   }

   B t;
   r = x;
   g /= 2;
   std::ptrdiff_t org_g = g;
   eval_bit_set(s, static_cast<std::size_t>(g));
   eval_bit_set(t, static_cast<std::size_t>(2 * g));
   eval_subtract(r, x, t);
   --g;
   if (eval_get_sign(r) == 0)
      return;
   std::ptrdiff_t msbr = static_cast<std::ptrdiff_t>(eval_msb(r));
   do
   {
      if (msbr >= org_g + g + 1)
      {
         t = s;
         eval_left_shift(t, static_cast<std::size_t>(g + 1));
         eval_bit_set(t, static_cast<std::size_t>(2 * g));
         if (t.compare(r) <= 0)
         {
            BOOST_MP_ASSERT(g >= 0);
            eval_bit_set(s, static_cast<std::size_t>(g));
            eval_subtract(r, t);
            if (eval_get_sign(r) == 0)
               return;
            msbr = static_cast<std::ptrdiff_t>(eval_msb(r));
         }
      }
      --g;
   } while (g >= 0);
}

template <class Backend>
BOOST_MP_CXX14_CONSTEXPR void eval_integer_sqrt(Backend& result, Backend& r, const Backend& x)
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   // recursive Karatsuba sqrt can cause issues in constexpr context:
   if (BOOST_MP_IS_CONST_EVALUATED(result.size()))
      return eval_integer_sqrt_bitwise(result, r, x);
#endif
   using small_uint = typename std::tuple_element<0, typename Backend::unsigned_types>::type;

   constexpr small_uint zero = 0u;

   if (eval_is_zero(x))
   {
      r = zero;
      result = zero;
      return;
   }
   Backend t;
   eval_karatsuba_sqrt(result, x, r, t, eval_msb(x) + 1);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_conj(B& result, const B& val)
{
   result = val; // assume non-complex result.
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_proj(B& result, const B& val)
{
   result = val; // assume non-complex result.
}

//
// These have to implemented by the backend, declared here so that our macro generated code compiles OK.
//
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_floor();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_ceil();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_trunc();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_sqrt();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_ldexp();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_frexp();
// TODO implement default versions of these:
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_asinh();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_acosh();
template <class T>
typename std::enable_if<sizeof(T) == 0>::type eval_atanh();

//
// eval_logb and eval_scalbn simply assume base 2 and forward to
// eval_ldexp and eval_frexp:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename B::exponent_type eval_ilogb(const B& val)
{
   static_assert(!std::numeric_limits<number<B> >::is_specialized || (std::numeric_limits<number<B> >::radix == 2), "The default implementation of ilogb requires a base 2 number type");
   typename B::exponent_type e(0);
   switch (eval_fpclassify(val))
   {
   case FP_NAN:
#ifdef FP_ILOGBNAN
      return FP_ILOGBNAN > 0 ? (std::numeric_limits<typename B::exponent_type>::max)() : (std::numeric_limits<typename B::exponent_type>::min)();
#else
      return (std::numeric_limits<typename B::exponent_type>::max)();
#endif
   case FP_INFINITE:
      return (std::numeric_limits<typename B::exponent_type>::max)();
   case FP_ZERO:
      return (std::numeric_limits<typename B::exponent_type>::min)();
   }
   B result;
   eval_frexp(result, val, &e);
   return e - 1;
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_logb(B& result, const B& val)
{
   switch (eval_fpclassify(val))
   {
   case FP_NAN:
      result = val;
      errno  = EDOM;
      return;
   case FP_ZERO:
      result = std::numeric_limits<number<B> >::infinity().backend();
      result.negate();
      errno = ERANGE;
      return;
   case FP_INFINITE:
      result = val;
      if (eval_signbit(val))
         result.negate();
      return;
   }
   using max_t = typename std::conditional<std::is_same<std::intmax_t, long>::value, long long, std::intmax_t>::type;
   result = static_cast<max_t>(eval_ilogb(val));
}
template <class B, class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_scalbn(B& result, const B& val, A e)
{
   static_assert(!std::numeric_limits<number<B> >::is_specialized || (std::numeric_limits<number<B> >::radix == 2), "The default implementation of scalbn requires a base 2 number type");
   eval_ldexp(result, val, static_cast<typename B::exponent_type>(e));
}
template <class B, class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_scalbln(B& result, const B& val, A e)
{
   eval_scalbn(result, val, e);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool is_arg_nan(const T& val, std::integral_constant<bool, true> const&, const std::integral_constant<bool, false>&)
{
   return eval_fpclassify(val) == FP_NAN;
}
template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool is_arg_nan(const T& val, std::integral_constant<bool, false> const&, const std::integral_constant<bool, true>&)
{
   return BOOST_MP_ISNAN(val);
}
template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool is_arg_nan(const T&, std::integral_constant<bool, false> const&, const std::integral_constant<bool, false>&)
{
   return false;
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR bool is_arg_nan(const T& val)
{
   return is_arg_nan(val, std::integral_constant<bool, boost::multiprecision::detail::is_backend<T>::value>(), std::is_floating_point<T>());
}

template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fmax(T& result, const U& a, const V& b)
{
   if (is_arg_nan(a))
      result = number<T>::canonical_value(b);
   else if (is_arg_nan(b))
      result = number<T>::canonical_value(a);
   else if (eval_lt(number<T>::canonical_value(a), number<T>::canonical_value(b)))
      result = number<T>::canonical_value(b);
   else
      result = number<T>::canonical_value(a);
}
template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fmin(T& result, const U& a, const V& b)
{
   if (is_arg_nan(a))
      result = number<T>::canonical_value(b);
   else if (is_arg_nan(b))
      result = number<T>::canonical_value(a);
   else if (eval_lt(number<T>::canonical_value(a), number<T>::canonical_value(b)))
      result = number<T>::canonical_value(a);
   else
      result = number<T>::canonical_value(b);
}

template <class R, class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR void eval_hypot(R& result, const T& a, const U& b)
{
   //
   // Normalize x and y, so that both are positive and x >= y:
   //
   R x, y;
   x = number<R>::canonical_value(a);
   y = number<R>::canonical_value(b);
   if (eval_get_sign(x) < 0)
      x.negate();
   if (eval_get_sign(y) < 0)
      y.negate();

   // Special case, see C99 Annex F.
   // The order of the if's is important: do not change!
   int c1 = eval_fpclassify(x);
   int c2 = eval_fpclassify(y);

   if (c1 == FP_ZERO)
   {
      result = y;
      return;
   }
   if (c2 == FP_ZERO)
   {
      result = x;
      return;
   }
   if (c1 == FP_INFINITE)
   {
      result = x;
      return;
   }
   if ((c2 == FP_INFINITE) || (c2 == FP_NAN))
   {
      result = y;
      return;
   }
   if (c1 == FP_NAN)
   {
      result = x;
      return;
   }

   if (eval_gt(y, x))
      x.swap(y);

   eval_multiply(result, x, std::numeric_limits<number<R> >::epsilon().backend());

   if (eval_gt(result, y))
   {
      result = x;
      return;
   }

   R rat;
   eval_divide(rat, y, x);
   eval_multiply(result, rat, rat);
   eval_increment(result);
   eval_sqrt(rat, result);
   eval_multiply(result, rat, x);
}

template <class R, class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_nearbyint(R& result, const T& a)
{
   eval_round(result, a);
}
template <class R, class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_rint(R& result, const T& a)
{
   eval_nearbyint(result, a);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_backend<T>::value, int>::type eval_signbit(const T& val)
{
   return eval_get_sign(val) < 0 ? 1 : 0;
}

//
// Real and imaginary parts:
//
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_real(To& to, const From& from)
{
   to = from;
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_imag(To& to, const From&)
{
   using ui_type = typename std::tuple_element<0, typename To::unsigned_types>::type;
   to = ui_type(0);
}

} // namespace default_ops
namespace default_ops_adl {

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real_imp(To& to, const From& from)
{
   using to_component_type = typename component_type<number<To> >::type;
   typename to_component_type::backend_type           to_component;
   to_component = from;
   eval_set_real(to, to_component);
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag_imp(To& to, const From& from)
{
   using to_component_type = typename component_type<number<To> >::type;
   typename to_component_type::backend_type           to_component;
   to_component = from;
   eval_set_imag(to, to_component);
}

} // namespace default_ops_adl
namespace default_ops {

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<To>::value == number_kind_complex>::type eval_set_real(To& to, const From& from)
{
   default_ops_adl::eval_set_real_imp(to, from);
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<To>::value != number_kind_complex>::type eval_set_real(To& to, const From& from)
{
   to = from;
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(To& to, const From& from)
{
   default_ops_adl::eval_set_imag_imp(to, from);
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(T& to, const T& from)
{
   to = from;
}
template <class T>
void BOOST_MP_CXX14_CONSTEXPR eval_set_imag(T&, const T&)
{
   static_assert(sizeof(T) == INT_MAX, "eval_set_imag needs to be specialised for each specific backend");
}

//
// These functions are implemented in separate files, but expanded inline here,
// DO NOT CHANGE THE ORDER OF THESE INCLUDES:
//
#include <boost/multiprecision/detail/functions/constants.hpp>
#include <boost/multiprecision/detail/functions/pow.hpp>
#include <boost/multiprecision/detail/functions/trig.hpp>

} // namespace default_ops

//
// Default versions of floating point classification routines:
//
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   using multiprecision::default_ops::eval_fpclassify;
   return eval_fpclassify(arg.backend());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return fpclassify                                                                     BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   int v = fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(arg);
   return (v != static_cast<int>(FP_INFINITE)) && (v != static_cast<int>(FP_NAN));
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool isfinite BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return isfinite                                                                       BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(arg) == static_cast<int>(FP_NAN);
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return isnan                                                                          BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(arg) == static_cast<int>(FP_INFINITE);
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return isinf                                                                          BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION(arg) == static_cast<int>(FP_NORMAL);
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool isnormal BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return isnormal                                                                       BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}

// Default versions of sign manipulation functions, if individual backends can do better than this
// (for example with signed zero), then they should overload these functions further:

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR int sign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return arg.sign();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR int sign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return sign                                                                           BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool signbit BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   using default_ops::eval_signbit;
   return static_cast<bool>(eval_signbit(arg.backend()));
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool signbit BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return static_cast<bool>(signbit BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg)));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> changesign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return -arg;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type changesign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return changesign                                                                     BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   return (boost::multiprecision::signbit)(a) != (boost::multiprecision::signbit)(b) ? (boost::multiprecision::changesign)(a) : a;
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& b)
{
   return copysign BOOST_PREVENT_MACRO_SUBSTITUTION(a, multiprecision::number<Backend, ExpressionTemplates>(b));
}
template <class tag, class A1, class A2, class A3, class A4, class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   return copysign BOOST_PREVENT_MACRO_SUBSTITUTION(multiprecision::number<Backend, ExpressionTemplates>(a), b);
}
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return copysign                                                                       BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(a), value_type(b));
}
//
// real and imag:
//
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type
real(const multiprecision::number<Backend, ExpressionTemplates>& a)
{
   using default_ops::eval_real;
   using result_type = typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type;
   boost::multiprecision::detail::scoped_default_precision<result_type>                                              precision_guard(a);
   result_type                                                                                                       result;
   eval_real(result.backend(), a.backend());
   return result;
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type
imag(const multiprecision::number<Backend, ExpressionTemplates>& a)
{
   using default_ops::eval_imag;
   using result_type = typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type;
   boost::multiprecision::detail::scoped_default_precision<result_type>                                              precision_guard(a);
   result_type                                                                                                       result;
   eval_imag(result.backend(), a.backend());
   return result;
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::type
real(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return real(value_type(arg));
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::type
imag(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return imag(value_type(arg));
}

//
// Complex number functions, these are overloaded at the Backend level, we just provide the
// expression template versions here, plus overloads for non-complex types:
//
#ifdef BOOST_MP_MATH_AVAILABLE
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_complex, component_type<number<T, ExpressionTemplates>>>::type::type
abs(const number<T, ExpressionTemplates>& v)
{
   return std::move(boost::math::hypot(real(v), imag(v)));
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_complex, component_type<typename detail::expression<tag, A1, A2, A3, A4>::result_type>>::type::type
abs(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(abs(static_cast<number_type>(v)));
}

template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_complex, typename scalar_result_from_possible_complex<number<T, ExpressionTemplates> >::type>::type
arg(const number<T, ExpressionTemplates>& v)
{
   return std::move(atan2(imag(v), real(v)));
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, typename scalar_result_from_possible_complex<number<T, ExpressionTemplates> >::type>::type
arg(const number<T, ExpressionTemplates>&)
{
   return 0;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_complex || number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_floating_point, typename scalar_result_from_possible_complex<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type>::type
arg(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(arg(static_cast<number_type>(v)));
}
#endif // BOOST_MP_MATH_AVAILABLE

template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_complex, component_type<number<T, ExpressionTemplates>>>::type::type
norm(const number<T, ExpressionTemplates>& v)
{
   typename component_type<number<T, ExpressionTemplates> >::type a(real(v)), b(imag(v));
   return std::move(a * a + b * b);
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value != number_kind_complex, typename scalar_result_from_possible_complex<number<T, ExpressionTemplates> >::type>::type
norm(const number<T, ExpressionTemplates>& v)
{
   return v * v;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
norm(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(norm(static_cast<number_type>(v)));
}

template <class Backend, expression_template_option ExpressionTemplates>
BOOST_MP_CXX14_CONSTEXPR typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type polar(number<Backend, ExpressionTemplates> const& r, number<Backend, ExpressionTemplates> const& theta)
{
   return typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type(number<Backend, ExpressionTemplates>(r * cos(theta)), number<Backend, ExpressionTemplates>(r * sin(theta)));
}

template <class tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_same<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, ExpressionTemplates> >::value,
                     typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type>::type
polar(detail::expression<tag, A1, A2, A3, A4> const& r, number<Backend, ExpressionTemplates> const& theta)
{
   return typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type(number<Backend, ExpressionTemplates>(r * cos(theta)), number<Backend, ExpressionTemplates>(r * sin(theta)));
}

template <class Backend, expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_same<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, ExpressionTemplates> >::value,
                     typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type>::type
polar(number<Backend, ExpressionTemplates> const& r, detail::expression<tag, A1, A2, A3, A4> const& theta)
{
   return typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type(number<Backend, ExpressionTemplates>(r * cos(theta)), number<Backend, ExpressionTemplates>(r * sin(theta)));
}

template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_same<typename detail::expression<tag, A1, A2, A3, A4>::result_type, typename detail::expression<tagb, A1b, A2b, A3b, A4b>::result_type>::value,
                     typename complex_result_from_scalar<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type>::type
polar(detail::expression<tag, A1, A2, A3, A4> const& r, detail::expression<tagb, A1b, A2b, A3b, A4b> const& theta)
{
   using scalar_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return typename complex_result_from_scalar<scalar_type>::type(scalar_type(r * cos(theta)), scalar_type(r * sin(theta)));
}
//
// We also allow the first argument to polar to be an arithmetic type (probably a literal):
//
template <class Scalar, class Backend, expression_template_option ExpressionTemplates>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<Scalar>::value, typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type>::type
polar(Scalar const& r, number<Backend, ExpressionTemplates> const& theta)
{
   return typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type(number<Backend, ExpressionTemplates>(r * cos(theta)), number<Backend, ExpressionTemplates>(r * sin(theta)));
}

template <class tag, class A1, class A2, class A3, class A4, class Scalar>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<Scalar>::value,
                     typename complex_result_from_scalar<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type>::type
polar(Scalar const& r, detail::expression<tag, A1, A2, A3, A4> const& theta)
{
   using scalar_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return typename complex_result_from_scalar<scalar_type>::type(scalar_type(r * cos(theta)), scalar_type(r * sin(theta)));
}
//
// Single argument overloads:
//
template <class Backend, expression_template_option ExpressionTemplates>
BOOST_MP_CXX14_CONSTEXPR typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type polar(number<Backend, ExpressionTemplates> const& r)
{
   return typename complex_result_from_scalar<number<Backend, ExpressionTemplates> >::type(r);
}

template <class tag, class A1, class A2, class A3, class A4>
BOOST_MP_CXX14_CONSTEXPR typename complex_result_from_scalar<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
polar(detail::expression<tag, A1, A2, A3, A4> const& r)
{
   return typename complex_result_from_scalar<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type(r);
}

} // namespace multiprecision

namespace math {

//
// Import Math functions here, so they can be found by Boost.Math:
//
using boost::multiprecision::changesign;
using boost::multiprecision::copysign;
using boost::multiprecision::fpclassify;
using boost::multiprecision::isfinite;
using boost::multiprecision::isinf;
using boost::multiprecision::isnan;
using boost::multiprecision::isnormal;
using boost::multiprecision::sign;
using boost::multiprecision::signbit;

#ifndef BOOST_MP_MATH_AVAILABLE
namespace policies {

template <typename... Args>
class policy {};

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void raise_rounding_error(T1, T2, T3, T4, T5)
{
   BOOST_MP_THROW_EXCEPTION(std::runtime_error("Rounding error"));
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void raise_overflow_error(T1, T2, T3, T4, T5)
{
   BOOST_MP_THROW_EXCEPTION(std::runtime_error("Overflow error"));
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void raise_evaluation_error(T1, T2, T3, T4, T5)
{
   BOOST_MP_THROW_EXCEPTION(std::runtime_error("Evaluation error"));
}

template <typename T, typename... Args>
struct is_policy
{
   static constexpr bool value = false;
};

template <typename... Args>
struct is_policy<policy<Args...>>
{
   static constexpr bool value = true;
};

} // namespace policies
#endif

} // namespace math

namespace multiprecision {
#ifdef BOOST_MP_MATH_AVAILABLE
using c99_error_policy = ::boost::math::policies::policy<
    ::boost::math::policies::domain_error< ::boost::math::policies::errno_on_error>,
    ::boost::math::policies::pole_error< ::boost::math::policies::errno_on_error>,
    ::boost::math::policies::overflow_error< ::boost::math::policies::errno_on_error>,
    ::boost::math::policies::evaluation_error< ::boost::math::policies::errno_on_error>,
    ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error> >;

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value != number_kind_complex, multiprecision::number<Backend, ExpressionTemplates> >::type
    asinh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::asinh(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex, typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::type
    asinh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return asinh(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value != number_kind_complex, multiprecision::number<Backend, ExpressionTemplates> >::type
    acosh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::acosh(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex, typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::type
    acosh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return acosh(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value != number_kind_complex, multiprecision::number<Backend, ExpressionTemplates> >::type
    atanh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::atanh(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex, typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::type
    atanh
    BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return atanh(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::cbrt(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return cbrt(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::erf(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type erf BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return erf(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::erfc(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return erfc(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::expm1(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return expm1(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   multiprecision::number<Backend, ExpressionTemplates>                                    result;
   result = boost::math::lgamma(arg, c99_error_policy());
   if ((boost::multiprecision::isnan)(result) && !(boost::multiprecision::isnan)(arg))
   {
      result = std::numeric_limits<multiprecision::number<Backend, ExpressionTemplates> >::infinity();
      errno  = ERANGE;
   }
   return result;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return lgamma(value_type(arg));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   if ((arg == 0) && std::numeric_limits<multiprecision::number<Backend, ExpressionTemplates> >::has_infinity)
   {
      errno = ERANGE;
      return 1 / arg;
   }
   return boost::math::tgamma(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return tgamma(value_type(arg));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long lrint BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return lround(arg);
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long lrint BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   return lround(arg);
}
#ifndef BOOST_NO_LONG_LONG
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long long llrint BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   return llround(arg);
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long long llrint BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   return llround(arg);
}
#endif
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(arg);
   return boost::math::log1p(arg, c99_error_policy());
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(arg);
   return log1p(value_type(arg));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return boost::math::nextafter(a, b, c99_error_policy());
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return nextafter                                                                        BOOST_PREVENT_MACRO_SUBSTITUTION(a, multiprecision::number<Backend, ExpressionTemplates>(b));
}
template <class tag, class A1, class A2, class A3, class A4, class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return nextafter                                                                        BOOST_PREVENT_MACRO_SUBSTITUTION(multiprecision::number<Backend, ExpressionTemplates>(a), b);
}
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type nextafter BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(a, b);
   return nextafter                                                                      BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(a), value_type(b));
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return boost::math::nextafter(a, b, c99_error_policy());
}
template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::number<Backend, ExpressionTemplates>& a, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return nexttoward                                                                       BOOST_PREVENT_MACRO_SUBSTITUTION(a, multiprecision::number<Backend, ExpressionTemplates>(b));
}
template <class tag, class A1, class A2, class A3, class A4, class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<Backend, ExpressionTemplates> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::number<Backend, ExpressionTemplates>& b)
{
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(a, b);
   return nexttoward                                                                       BOOST_PREVENT_MACRO_SUBSTITUTION(multiprecision::number<Backend, ExpressionTemplates>(a), b);
}
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& a, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
{
   using value_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<value_type>                                          precision_guard(a, b);
   return nexttoward                                                                     BOOST_PREVENT_MACRO_SUBSTITUTION(value_type(a), value_type(b));
}
#endif // BOOST_MP_MATH_AVAILABLE

template <class B1, class B2, class B3, expression_template_option ET1, expression_template_option ET2, expression_template_option ET3>
inline BOOST_MP_CXX14_CONSTEXPR number<B1, ET1>& add(number<B1, ET1>& result, const number<B2, ET2>& a, const number<B3, ET3>& b)
{
   static_assert((std::is_convertible<B2, B1>::value), "No conversion to the target of a mixed precision addition exists");
   static_assert((std::is_convertible<B3, B1>::value), "No conversion to the target of a mixed precision addition exists");
   using default_ops::eval_add;
   eval_add(result.backend(), a.backend(), b.backend());
   return result;
}

template <class B1, class B2, class B3, expression_template_option ET1, expression_template_option ET2, expression_template_option ET3>
inline BOOST_MP_CXX14_CONSTEXPR number<B1, ET1>& subtract(number<B1, ET1>& result, const number<B2, ET2>& a, const number<B3, ET3>& b)
{
   static_assert((std::is_convertible<B2, B1>::value), "No conversion to the target of a mixed precision addition exists");
   static_assert((std::is_convertible<B3, B1>::value), "No conversion to the target of a mixed precision addition exists");
   using default_ops::eval_subtract;
   eval_subtract(result.backend(), a.backend(), b.backend());
   return result;
}

template <class B1, class B2, class B3, expression_template_option ET1, expression_template_option ET2, expression_template_option ET3>
inline BOOST_MP_CXX14_CONSTEXPR number<B1, ET1>& multiply(number<B1, ET1>& result, const number<B2, ET2>& a, const number<B3, ET3>& b)
{
   static_assert((std::is_convertible<B2, B1>::value), "No conversion to the target of a mixed precision addition exists");
   static_assert((std::is_convertible<B3, B1>::value), "No conversion to the target of a mixed precision addition exists");
   using default_ops::eval_multiply;
   eval_multiply(result.backend(), a.backend(), b.backend());
   return result;
}

template <class B, expression_template_option ET, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value, number<B, ET>&>::type
add(number<B, ET>& result, const I& a, const I& b)
{
   using default_ops::eval_add;
   using canonical_type = typename detail::canonical<I, B>::type;
   eval_add(result.backend(), static_cast<canonical_type>(a), static_cast<canonical_type>(b));
   return result;
}

template <class B, expression_template_option ET, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value, number<B, ET>&>::type
subtract(number<B, ET>& result, const I& a, const I& b)
{
   using default_ops::eval_subtract;
   using canonical_type = typename detail::canonical<I, B>::type;
   eval_subtract(result.backend(), static_cast<canonical_type>(a), static_cast<canonical_type>(b));
   return result;
}

template <class B, expression_template_option ET, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value, number<B, ET>&>::type
multiply(number<B, ET>& result, const I& a, const I& b)
{
   using default_ops::eval_multiply;
   using canonical_type = typename detail::canonical<I, B>::type;
   eval_multiply(result.backend(), static_cast<canonical_type>(a), static_cast<canonical_type>(b));
   return result;
}

template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<tag, A1, A2, A3, A4>::result_type trunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(trunc(number_type(v), pol));
}

template <class Backend, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR number<Backend, ExpressionTemplates> trunc(const number<Backend, ExpressionTemplates>& v, const Policy&)
{
   using default_ops::eval_trunc;
   detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(v);
   number<Backend, ExpressionTemplates>                                                    result;
   eval_trunc(result.backend(), v.backend());
   return result;
}

template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR int itrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(trunc(v, pol));
   if ((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::itrunc<%1%>(%1%)", nullptr, number_type(v), 0, pol);
   return r.template convert_to<int>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR int itrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return itrunc(v, boost::math::policies::policy<>());
}
template <class Backend, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR int itrunc(const number<Backend, ExpressionTemplates>& v, const Policy& pol)
{
   number<Backend, ExpressionTemplates> r(trunc(v, pol));
   if ((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::itrunc<%1%>(%1%)", nullptr, v, 0, pol);
   return r.template convert_to<int>();
}
template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR int itrunc(const number<Backend, ExpressionTemplates>& v)
{
   return itrunc(v, boost::math::policies::policy<>());
}
template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long ltrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(trunc(v, pol));
   if ((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::ltrunc<%1%>(%1%)", nullptr, number_type(v), 0L, pol);
   return r.template convert_to<long>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long ltrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return ltrunc(v, boost::math::policies::policy<>());
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long ltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
   number<T, ExpressionTemplates> r(trunc(v, pol));
   if ((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::ltrunc<%1%>(%1%)", nullptr, v, 0L, pol);
   return r.template convert_to<long>();
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long ltrunc(const number<T, ExpressionTemplates>& v)
{
   return ltrunc(v, boost::math::policies::policy<>());
}
#ifndef BOOST_NO_LONG_LONG
template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long long lltrunc(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(trunc(v, pol));
   if ((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::lltrunc<%1%>(%1%)", nullptr, number_type(v), 0LL, pol);
   return r.template convert_to<long long>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long long lltrunc(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return lltrunc(v, boost::math::policies::policy<>());
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long long lltrunc(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
   number<T, ExpressionTemplates> r(trunc(v, pol));
   if ((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::lltrunc<%1%>(%1%)", nullptr, v, 0LL, pol);
   return r.template convert_to<long long>();
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long long lltrunc(const number<T, ExpressionTemplates>& v)
{
   return lltrunc(v, boost::math::policies::policy<>());
}
#endif
template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<tag, A1, A2, A3, A4>::result_type round(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(round(static_cast<number_type>(v), pol));
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR number<T, ExpressionTemplates> round(const number<T, ExpressionTemplates>& v, const Policy&)
{
   using default_ops::eval_round;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_round(result.backend(), v.backend());
   return result;
}

template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR int iround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(round(v, pol));
   if ((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", nullptr, number_type(v), 0, pol);
   return r.template convert_to<int>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR int iround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return iround(v, boost::math::policies::policy<>());
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR int iround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
   number<T, ExpressionTemplates> r(round(v, pol));
   if ((r > (std::numeric_limits<int>::max)()) || r < (std::numeric_limits<int>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", nullptr, v, 0, pol);
   return r.template convert_to<int>();
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR int iround(const number<T, ExpressionTemplates>& v)
{
   return iround(v, boost::math::policies::policy<>());
}
template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long lround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(round(v, pol));
   if ((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::lround<%1%>(%1%)", nullptr, number_type(v), 0L, pol);
   return r.template convert_to<long>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long lround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return lround(v, boost::math::policies::policy<>());
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long lround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
   number<T, ExpressionTemplates> r(round(v, pol));
   if ((r > (std::numeric_limits<long>::max)()) || r < (std::numeric_limits<long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::lround<%1%>(%1%)", nullptr, v, 0L, pol);
   return r.template convert_to<long>();
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long lround(const number<T, ExpressionTemplates>& v)
{
   return lround(v, boost::math::policies::policy<>());
}
#ifndef BOOST_NO_LONG_LONG
template <class tag, class A1, class A2, class A3, class A4, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long long llround(const detail::expression<tag, A1, A2, A3, A4>& v, const Policy& pol)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                           r(round(v, pol));
   if ((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", nullptr, number_type(v), 0LL, pol);
   return r.template convert_to<long long>();
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR long long llround(const detail::expression<tag, A1, A2, A3, A4>& v)
{
   return llround(v, boost::math::policies::policy<>());
}
template <class T, expression_template_option ExpressionTemplates, class Policy>
inline BOOST_MP_CXX14_CONSTEXPR long long llround(const number<T, ExpressionTemplates>& v, const Policy& pol)
{
   number<T, ExpressionTemplates> r(round(v, pol));
   if ((r > (std::numeric_limits<long long>::max)()) || r < (std::numeric_limits<long long>::min)() || !BOOST_MP_ISFINITE(v))
      return boost::math::policies::raise_rounding_error("boost::multiprecision::iround<%1%>(%1%)", nullptr, v, 0LL, pol);
   return r.template convert_to<long long>();
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR long long llround(const number<T, ExpressionTemplates>& v)
{
   return llround(v, boost::math::policies::policy<>());
}
#endif
//
// frexp does not return an expression template since we require the
// integer argument to be evaluated even if the returned value is
// not assigned to anything...
//
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type frexp(const number<T, ExpressionTemplates>& v, short* pint)
{
   using default_ops::eval_frexp;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_frexp(result.backend(), v.backend(), pint);
   return result;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_floating_point, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
frexp(const detail::expression<tag, A1, A2, A3, A4>& v, short* pint)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(frexp(static_cast<number_type>(v), pint));
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type frexp(const number<T, ExpressionTemplates>& v, int* pint)
{
   using default_ops::eval_frexp;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_frexp(result.backend(), v.backend(), pint);
   return result;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_floating_point, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
frexp(const detail::expression<tag, A1, A2, A3, A4>& v, int* pint)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(frexp(static_cast<number_type>(v), pint));
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type frexp(const number<T, ExpressionTemplates>& v, long* pint)
{
   using default_ops::eval_frexp;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_frexp(result.backend(), v.backend(), pint);
   return result;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_floating_point, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
frexp(const detail::expression<tag, A1, A2, A3, A4>& v, long* pint)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(frexp(static_cast<number_type>(v), pint));
}
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type frexp(const number<T, ExpressionTemplates>& v, long long* pint)
{
   using default_ops::eval_frexp;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_frexp(result.backend(), v.backend(), pint);
   return result;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_floating_point, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
frexp(const detail::expression<tag, A1, A2, A3, A4>& v, long long* pint)
{
   using number_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   return std::move(frexp(static_cast<number_type>(v), pint));
}
//
// modf does not return an expression template since we require the
// second argument to be evaluated even if the returned value is
// not assigned to anything...
//
template <class T, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type modf(const number<T, ExpressionTemplates>& v, number<T, ExpressionTemplates>* pipart)
{
   using default_ops::eval_modf;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result;
   eval_modf(result.backend(), v.backend(), pipart ? &pipart->backend() : nullptr);
   return result;
}
template <class T, expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<T>::value == number_kind_floating_point, number<T, ExpressionTemplates> >::type modf(const detail::expression<tag, A1, A2, A3, A4>& v, number<T, ExpressionTemplates>* pipart)
{
   using default_ops::eval_modf;
   detail::scoped_default_precision<multiprecision::number<T, ExpressionTemplates> > precision_guard(v);
   number<T, ExpressionTemplates>                                                    result, arg(v);
   eval_modf(result.backend(), arg.backend(), pipart ? &pipart->backend() : nullptr);
   return result;
}

//
// Integer square root:
//
template <class B, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, ExpressionTemplates> >::type
sqrt(const number<B, ExpressionTemplates>& x)
{
   using default_ops::eval_integer_sqrt;
   number<B, ExpressionTemplates> s, r;
   eval_integer_sqrt(s.backend(), r.backend(), x.backend());
   return s;
}
template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::type
         sqrt(const detail::expression<tag, A1, A2, A3, A4>& arg)
{
   using default_ops::eval_integer_sqrt;
   using result_type = typename detail::expression<tag, A1, A2, A3, A4>::result_type;
   detail::scoped_default_precision<result_type> precision_guard(arg);
   result_type                                   result, v(arg), r;
   eval_integer_sqrt(result.backend(), r.backend(), v.backend());
   return result;
}

//
// fma:
//

namespace default_ops {

struct fma_func
{
   template <class B, class T, class U, class V>
   BOOST_MP_CXX14_CONSTEXPR void operator()(B& result, const T& a, const U& b, const V& c) const
   {
      eval_multiply_add(result, a, b, c);
   }
};

} // namespace default_ops

template <class Backend, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_on> >::value == number_kind_floating_point) &&
        (is_number<U>::value || is_number_expression<U>::value || boost::multiprecision::detail::is_arithmetic<U>::value) &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    detail::expression<detail::function, default_ops::fma_func, number<Backend, et_on>, U, V> >::type
fma(const number<Backend, et_on>& a, const U& b, const V& c)
{
   return detail::expression<detail::function, default_ops::fma_func, number<Backend, et_on>, U, V>(
       default_ops::fma_func(), a, b, c);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_floating_point) &&
        (is_number<U>::value || is_number_expression<U>::value || boost::multiprecision::detail::is_arithmetic<U>::value) &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    detail::expression<detail::function, default_ops::fma_func, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, U, V> >::type
fma(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const U& b, const V& c)
{
   return detail::expression<detail::function, default_ops::fma_func, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, U, V>(
       default_ops::fma_func(), a, b, c);
}

template <class Backend, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_off> >::value == number_kind_floating_point) &&
        (is_number<U>::value || is_number_expression<U>::value || boost::multiprecision::detail::is_arithmetic<U>::value) &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    number<Backend, et_off> >::type
fma(const number<Backend, et_off>& a, const U& b, const V& c)
{
   using default_ops::eval_multiply_add;
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(a, b, c);
   number<Backend, et_off>                                                    result;
   eval_multiply_add(result.backend(), number<Backend, et_off>::canonical_value(a), number<Backend, et_off>::canonical_value(b), number<Backend, et_off>::canonical_value(c));
   return result;
}

template <class U, class Backend, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_on> >::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    detail::expression<detail::function, default_ops::fma_func, U, number<Backend, et_on>, V> >::type
fma(const U& a, const number<Backend, et_on>& b, const V& c)
{
   return detail::expression<detail::function, default_ops::fma_func, U, number<Backend, et_on>, V>(
       default_ops::fma_func(), a, b, c);
}

template <class U, class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    detail::expression<detail::function, default_ops::fma_func, U, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
fma(const U& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b, const V& c)
{
   return detail::expression<detail::function, default_ops::fma_func, U, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(
       default_ops::fma_func(), a, b, c);
}

template <class U, class Backend, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_off> >::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_arithmetic<V>::value),
    number<Backend, et_off> >::type
fma(const U& a, const number<Backend, et_off>& b, const V& c)
{
   using default_ops::eval_multiply_add;
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(a, b, c);
   number<Backend, et_off>                                                    result;
   eval_multiply_add(result.backend(), number<Backend, et_off>::canonical_value(a), number<Backend, et_off>::canonical_value(b), number<Backend, et_off>::canonical_value(c));
   return result;
}

template <class U, class V, class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_on> >::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        boost::multiprecision::detail::is_arithmetic<V>::value,
    detail::expression<detail::function, default_ops::fma_func, U, V, number<Backend, et_on> > >::type
fma(const U& a, const V& b, const number<Backend, et_on>& c)
{
   return detail::expression<detail::function, default_ops::fma_func, U, V, number<Backend, et_on> >(
       default_ops::fma_func(), a, b, c);
}

template <class U, class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        boost::multiprecision::detail::is_arithmetic<V>::value,
    detail::expression<detail::function, default_ops::fma_func, U, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
fma(const U& a, const V& b, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& c)
{
   return detail::expression<detail::function, default_ops::fma_func, U, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(
       default_ops::fma_func(), a, b, c);
}

template <class U, class V, class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<number<Backend, et_off> >::value == number_kind_floating_point) &&
        boost::multiprecision::detail::is_arithmetic<U>::value &&
        boost::multiprecision::detail::is_arithmetic<V>::value,
        number<Backend, et_off> >::type
fma(const U& a, const V& b, const number<Backend, et_off>& c)
{
   using default_ops::eval_multiply_add;
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(a, b, c);
   number<Backend, et_off>                                                    result;
   eval_multiply_add(result.backend(), number<Backend, et_off>::canonical_value(a), number<Backend, et_off>::canonical_value(b), number<Backend, et_off>::canonical_value(c));
   return result;
}

namespace default_ops {

struct remquo_func
{
   template <class B, class T, class U>
   BOOST_MP_CXX14_CONSTEXPR void operator()(B& result, const T& a, const U& b, int* pi) const
   {
      eval_remquo(result, a, b, pi);
   }
};

} // namespace default_ops

template <class Backend, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    number_category<number<Backend, et_on> >::value == number_kind_floating_point,
    detail::expression<detail::function, default_ops::remquo_func, number<Backend, et_on>, U, int*> >::type
remquo(const number<Backend, et_on>& a, const U& b, int* pi)
{
   return detail::expression<detail::function, default_ops::remquo_func, number<Backend, et_on>, U, int*>(
       default_ops::remquo_func(), a, b, pi);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_floating_point,
    detail::expression<detail::function, default_ops::remquo_func, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, U, int*> >::type
remquo(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const U& b, int* pi)
{
   return detail::expression<detail::function, default_ops::remquo_func, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, U, int*>(
       default_ops::remquo_func(), a, b, pi);
}

template <class U, class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    (number_category<number<Backend, et_on> >::value == number_kind_floating_point) && !is_number<U>::value && !is_number_expression<U>::value,
    detail::expression<detail::function, default_ops::remquo_func, U, number<Backend, et_on>, int*> >::type
remquo(const U& a, const number<Backend, et_on>& b, int* pi)
{
   return detail::expression<detail::function, default_ops::remquo_func, U, number<Backend, et_on>, int*>(
       default_ops::remquo_func(), a, b, pi);
}

template <class U, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_floating_point) && !is_number<U>::value && !is_number_expression<U>::value,
    detail::expression<detail::function, default_ops::remquo_func, U, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, int*> >::type
remquo(const U& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b, int* pi)
{
   return detail::expression<detail::function, default_ops::remquo_func, U, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, int*>(
       default_ops::remquo_func(), a, b, pi);
}

template <class Backend, class U>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    number_category<number<Backend, et_on> >::value == number_kind_floating_point,
    number<Backend, et_off> >::type
remquo(const number<Backend, et_off>& a, const U& b, int* pi)
{
   using default_ops::eval_remquo;
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(a, b);
   number<Backend, et_off>                                                    result;
   eval_remquo(result.backend(), a.backend(), number<Backend, et_off>::canonical_value(b), pi);
   return result;
}
template <class U, class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    (number_category<number<Backend, et_on> >::value == number_kind_floating_point) && !is_number<U>::value && !is_number_expression<U>::value,
    number<Backend, et_off> >::type
remquo(const U& a, const number<Backend, et_off>& b, int* pi)
{
   using default_ops::eval_remquo;
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(a, b);
   number<Backend, et_off>                                                    result;
   eval_remquo(result.backend(), number<Backend, et_off>::canonical_value(a), b.backend(), pi);
   return result;
}

template <class B, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, ExpressionTemplates> >::type
sqrt(const number<B, ExpressionTemplates>& x, number<B, ExpressionTemplates>& r)
{
   using default_ops::eval_integer_sqrt;
   detail::scoped_default_precision<multiprecision::number<B, ExpressionTemplates> > precision_guard(x, r);
   number<B, ExpressionTemplates>                                                    s;
   eval_integer_sqrt(s.backend(), r.backend(), x.backend());
   return s;
}
template <class B, expression_template_option ExpressionTemplates, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, ExpressionTemplates> >::type
sqrt(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& arg, number<B, ExpressionTemplates>& r)
{
   using default_ops::eval_integer_sqrt;
   detail::scoped_default_precision<multiprecision::number<B, ExpressionTemplates> > precision_guard(r);
   number<B, ExpressionTemplates>                                                    s;
   number<B, ExpressionTemplates>                                                    x(arg);
   eval_integer_sqrt(s.backend(), r.backend(), x.backend());
   return s;
}

// clang-format off
//
// Regrettably, when the argument to a function is an rvalue we must return by value, and not return an
// expression template, otherwise we can end up with dangling references.
// See https://github.com/boostorg/multiprecision/issues/175.
//
#define UNARY_OP_FUNCTOR_CXX11_RVALUE(func, category)\
   template <class Backend>                                                                                                                                                                               \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category, number<Backend, et_on> > ::type                                                                      \
   func(number<Backend, et_on>&& arg)                                                                                                                                                                     \
   {                                                                                                                                                                                                      \
      detail::scoped_default_precision<multiprecision::number<Backend, et_on> > precision_guard(arg);                                                                                                    \
      number<Backend, et_on>                                                    result;                                                                                                                  \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                         \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend());                                                                                                                                                                  \
      return result;                                                                                                                                                                       \
   }                                                                                                                                                                                                      \

#define BINARY_OP_FUNCTOR_CXX11_RVALUE(func, category)\
   template <class Backend>                                                                                                                                                                                                                                \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category, number<Backend, et_on> >::type func(number<Backend, et_on>&& arg, const number<Backend, et_on>& a)                                                                                              \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_on> > precision_guard(arg, a);                                                                                                                                                  \
      number<Backend, et_on>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend(), a.backend());                                                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }                                                                                                                                                                                                                                                       \
   template <class Backend>                                                                                                                                                                                                                                \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category, number<Backend, et_on> >::type func(const number<Backend, et_on>& arg, number<Backend, et_on>&& a)                                                                                              \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_on> > precision_guard(arg, a);                                                                                                                                                  \
      number<Backend, et_on>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend(), a.backend());                                                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }                                                                                                                                                                                                                                                       \
   template <class Backend>                                                                                                                                                                                                                                \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category, number<Backend, et_on> >::type func(number<Backend, et_on>&& arg, number<Backend, et_on>&& a)                                                                                              \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_on> > precision_guard(arg, a);                                                                                                                                                  \
      number<Backend, et_on>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend(), a.backend());                                                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class tag, class A1, class A2, class A3, class A4>                                                                                                                                                                             \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value == category) && (std::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                           \
           number<Backend, et_on> > ::type                                                                                                                                                                       \
   func(number<Backend, et_on>&& arg, const detail::expression<tag, A1, A2, A3, A4>& a)                                                                                    \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                             \
   }                                                                                                                                                                                                                                                       \
   template <class tag, class A1, class A2, class A3, class A4, class Backend>                                                                                                                                                                             \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value == category) && (std::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                           \
           number<Backend, et_on> > ::type                                                                                                                                                                       \
   func(const detail::expression<tag, A1, A2, A3, A4>& arg, number<Backend, et_on>&& a)                                                                                    \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                             \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
           number<Backend, et_on> >::type                                                                                                                                                                                                     \
   func(number<Backend, et_on>&& arg, const Arithmetic& a)                                                                                                                                               \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>,                                                                                                                                                      \
             number<Backend, et_on>, Arithmetic > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                                                         \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
           number<Backend, et_on> > ::type                                                                                                                                                                                                    \
   func(const Arithmetic& arg, number<Backend, et_on>&& a)                                                                                                                                              \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<                                                                                                                                                                                                                           \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             Arithmetic, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                                          \
   }                                                                                                                                                                                                                                                       \


#define UNARY_OP_FUNCTOR(func, category)                                                                                                                                                                  \
   namespace detail {                                                                                                                                                                                     \
   template <class Backend>                                                                                                                                                                               \
   struct BOOST_JOIN(category, BOOST_JOIN(func, _funct))                                                                                                                                                  \
   {                                                                                                                                                                                                      \
      BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg) const                                                                                                                                          \
      {                                                                                                                                                                                                   \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                      \
         BOOST_JOIN(eval_, func)                                                                                                                                                                          \
         (result, arg);                                                                                                                                                                                   \
      }                                                                                                                                                                                                   \
      template <class U>                                                                                                                                                                                  \
      BOOST_MP_CXX14_CONSTEXPR void operator()(U& result, const Backend& arg) const                                                                                                                                                \
      {                                                                                                                                                                                                   \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                      \
         Backend temp;                                                                                                                                                                                    \
         BOOST_JOIN(eval_, func)                                                                                                                                                                          \
         (temp, arg);                                                                                                                                                                                     \
         result = std::move(temp);                                                                                                                                                                                   \
      }                                                                                                                                                                                                   \
   };                                                                                                                                                                                                     \
   }                                                                                                                                                                                                      \
                                                                                                                                                                                                          \
   template <class tag, class A1, class A2, class A3, class A4>                                                                                                                                           \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category,                                                                     \
                                                        detail::expression<detail::function,                                                                                                              \
                                                        detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,            \
                                                        detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                \
   func(const detail::expression<tag, A1, A2, A3, A4>& arg)                                                                    \
   {                                                                                                                                                                                                      \
      return detail::expression<                                                                                                                                                                          \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                               \
             detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg); \
   }                                                                                                                                                                                                      \
   template <class Backend>                                                                                                                                                                               \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category,                                                                                                      \
          detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>, number<Backend, et_on> > > ::type                                                       \
   func(const number<Backend, et_on>& arg)                                                                                                                                                                \
   {                                                                                                                                                                                                      \
      return detail::expression<                                                                                                                                                                          \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                     \
             number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg);                                                                                        \
   }                                                                                                                                                                                                      \
   template <class Backend>                                                                                                                                                                               \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                    \
       boost::multiprecision::number_category<Backend>::value == category,                                                                                                                                \
       number<Backend, et_off> >::type                                                                                                                                                                    \
   func(const number<Backend, et_off>& arg)                                                                                                                                                               \
   {                                                                                                                                                                                                      \
      detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);                                                                                                    \
      number<Backend, et_off>                                                    result;                                                                                                                  \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                         \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend());                                                                                                                                                                  \
      return result;                                                                                                                                                                       \
   }\
   UNARY_OP_FUNCTOR_CXX11_RVALUE(func, category)\

#define BINARY_OP_FUNCTOR(func, category)                                                                                                                                                                                                                  \
   namespace detail {                                                                                                                                                                                                                                      \
   template <class Backend>                                                                                                                                                                                                                                \
   struct BOOST_JOIN(category, BOOST_JOIN(func, _funct))                                                                                                                                                                                                   \
   {                                                                                                                                                                                                                                                       \
      BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg, const Backend& a) const                                                                                                                                                                         \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (result, arg, a);                                                                                                                                                                                                                                 \
      }                                                                                                                                                                                                                                                    \
      template <class Arithmetic>                                                                                                                                                                                                                          \
      BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg, const Arithmetic& a) const                                                                                                                                                                      \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (result, arg, number<Backend>::canonical_value(a));                                                                                                                                                                                               \
      }                                                                                                                                                                                                                                                    \
      template <class Arithmetic>                                                                                                                                                                                                                          \
      BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Arithmetic& arg, const Backend& a) const                                                                                                                                                                      \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (result, number<Backend>::canonical_value(arg), a);                                                                                                                                                                                               \
      }                                                                                                                                                                                                                                                    \
      template <class U>                                                                                                                                                                                                                                   \
      BOOST_MP_CXX14_CONSTEXPR void operator()(U& result, const Backend& arg, const Backend& a) const                                                                                                                                                                               \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         Backend r;                                                                                                                                                                                                                                        \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (r, arg, a);                                                                                                                                                                                                                                      \
         result = std::move(r);                                                                                                                                                                                                                                       \
      }                                                                                                                                                                                                                                                    \
      template <class U, class Arithmetic>                                                                                                                                                                                                                 \
      BOOST_MP_CXX14_CONSTEXPR void operator()(U& result, const Backend& arg, const Arithmetic& a) const                                                                                                                                                                            \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         Backend r;                                                                                                                                                                                                                                        \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (r, arg, number<Backend>::canonical_value(a));                                                                                                                                                                                                    \
         result = std::move(r);                                                                                                                                                                                                                                       \
      }                                                                                                                                                                                                                                                    \
      template <class U, class Arithmetic>                                                                                                                                                                                                                 \
      BOOST_MP_CXX14_CONSTEXPR void operator()(U& result, const Arithmetic& arg, const Backend& a) const                                                                                                                                                                            \
      {                                                                                                                                                                                                                                                    \
         using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                       \
         Backend r;                                                                                                                                                                                                                                        \
         BOOST_JOIN(eval_, func)                                                                                                                                                                                                                           \
         (r, number<Backend>::canonical_value(arg), a);                                                                                                                                                                                                    \
         result = std::move(r);                                                                                                                                                                                                                                       \
      }                                                                                                                                                                                                                                                    \
   };                                                                                                                                                                                                                                                      \
   }                                                                                                                                                                                                                                                       \
   template <class Backend>                                                                                                                                                                                                                                \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == category, detail::expression<detail::function, \
         detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>, number<Backend, et_on>, number<Backend, et_on> > > ::type                                                                                                                                                                \
   func(const number<Backend, et_on>& arg, const number<Backend, et_on>& a)                                                                                              \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             number<Backend, et_on>, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                                              \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class tag, class A1, class A2, class A3, class A4>                                                                                                                                                                             \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value == category) && (std::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                           \
           detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>, number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                                                                                       \
   func(const number<Backend, et_on>& arg, const detail::expression<tag, A1, A2, A3, A4>& a)                                                                                    \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             number<Backend, et_on>, detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                             \
   }                                                                                                                                                                                                                                                       \
   template <class tag, class A1, class A2, class A3, class A4, class Backend>                                                                                                                                                                             \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value == category) && (std::is_convertible<typename detail::expression<tag, A1, A2, A3, A4>::result_type, number<Backend, et_on> >::value),                           \
           detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>, detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> > > ::type                                                                                                                                                                       \
   func(const detail::expression<tag, A1, A2, A3, A4>& arg, const number<Backend, et_on>& a)                                                                                    \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             detail::expression<tag, A1, A2, A3, A4>, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                             \
   }                                                                                                                                                                                                                                                       \
   template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>                                                                                                                                    \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category) && (number_category<detail::expression<tagb, A1b, A2b, A3b, A4b> >::value == category),                                                                          \
           detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
           detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b> > > ::type                                                                                                                                                 \
   func(const detail::expression<tag, A1, A2, A3, A4>& arg, const detail::expression<tagb, A1b, A2b, A3b, A4b>& a)                                        \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                \
             detail::expression<tag, A1, A2, A3, A4>, detail::expression<tagb, A1b, A2b, A3b, A4b> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>(), arg, a); \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
           detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
           number<Backend, et_on>, Arithmetic> > ::type                                                                                                                                                                                                     \
   func(const number<Backend, et_on>& arg, const Arithmetic& a)                                                                                                                                               \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>,                                                                                                                                                      \
             number<Backend, et_on>, Arithmetic > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct))<Backend>(), arg, a);                                                                                                                         \
   }                                                                                                                                                                                                                                                       \
   template <class tag, class A1, class A2, class A3, class A4, class Arithmetic>                                                                                                                                                                          \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                              \
           detail::expression<                                                                                                                                                                                                                             \
               detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
           detail::expression<tag, A1, A2, A3, A4>, Arithmetic> > ::type                                                                                                                                                                                    \
   func(const detail::expression<tag, A1, A2, A3, A4>& arg, const Arithmetic& a)                                                                                                             \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<                                                                                                                                                                                                                           \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                \
             detail::expression<tag, A1, A2, A3, A4>, Arithmetic > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a);                                  \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, number<Backend, et_on> >::value && (number_category<Backend>::value == category),                                                                                                                     \
           detail::expression<                                                                                                                                                                                                                             \
               detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                        \
           Arithmetic, number<Backend, et_on> > > ::type                                                                                                                                                                                                    \
   func(const Arithmetic& arg, const number<Backend, et_on>& a)                                                                                                                                              \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<                                                                                                                                                                                                                           \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                                                      \
             Arithmetic, number<Backend, et_on> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                                                          \
   }                                                                                                                                                                                                                                                       \
   template <class tag, class A1, class A2, class A3, class A4, class Arithmetic>                                                                                                                                                                          \
       inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                        \
           is_compatible_arithmetic_type<Arithmetic, typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value && (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                              \
           detail::expression<                                                                                                                                                                                                                             \
               detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                  \
           Arithmetic, detail::expression<tag, A1, A2, A3, A4> > > ::type                                                                                                                                                                                   \
   func(const Arithmetic& arg, const detail::expression<tag, A1, A2, A3, A4>& a)                                                                                                            \
   {                                                                                                                                                                                                                                                       \
      return detail::expression<                                                                                                                                                                                                                           \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                                                                \
             Arithmetic, detail::expression<tag, A1, A2, A3, A4> > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a);                                   \
   }                                                                                                                                                                                                                                                       \
   template <class Backend>                                                                                                                                                                                                                                \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value == category), number<Backend, et_off> >::type                                                                                                                                                                                             \
   func(const number<Backend, et_off>& arg, const number<Backend, et_off>& a)                                                                                                                                                                              \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg, a);                                                                                                                                                  \
      number<Backend, et_off>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)(result.backend(), arg.backend(), a.backend());                                                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                            \
       is_compatible_arithmetic_type<Arithmetic, number<Backend, et_off> >::value && (number_category<Backend>::value == category),                                                                                                                        \
       number<Backend, et_off> >::type                                                                                                                                                                                                                     \
   func(const number<Backend, et_off>& arg, const Arithmetic& a)                                                                                                                                                                                           \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);                                                                                                                                                     \
      number<Backend, et_off>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)                                                                                                                                                                                                                              \
      (result.backend(), arg.backend(), number<Backend, et_off>::canonical_value(a));                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }                                                                                                                                                                                                                                                       \
   template <class Backend, class Arithmetic>                                                                                                                                                                                                              \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                                                            \
       is_compatible_arithmetic_type<Arithmetic, number<Backend, et_off> >::value && (number_category<Backend>::value == category),                                                                                                                        \
       number<Backend, et_off> >::type                                                                                                                                                                                                                     \
   func(const Arithmetic& a, const number<Backend, et_off>& arg)                                                                                                                                                                                           \
   {                                                                                                                                                                                                                                                       \
      detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);                                                                                                                                                     \
      number<Backend, et_off>                                                    result;                                                                                                                                                                   \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                                                          \
      BOOST_JOIN(eval_, func)                                                                                                                                                                                                                              \
      (result.backend(), number<Backend, et_off>::canonical_value(a), arg.backend());                                                                                                                                                                      \
      return result;                                                                                                                                                                                                                        \
   }\
   BINARY_OP_FUNCTOR_CXX11_RVALUE(func, category)

#define HETERO_BINARY_OP_FUNCTOR_B(func, Arg2, category)                                                                                                                                                            \
   template <class tag, class A1, class A2, class A3, class A4>                                                                                                                                                     \
       inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                 \
           (number_category<detail::expression<tag, A1, A2, A3, A4> >::value == category),                                                                                                                          \
           detail::expression<                                                                                                                                                                                      \
               detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                           \
           detail::expression<tag, A1, A2, A3, A4>, Arg2> > ::type                                                                                                                                                   \
                                                           func(const detail::expression<tag, A1, A2, A3, A4>& arg, Arg2 const& a)                                                                                  \
   {                                                                                                                                                                                                                \
      return detail::expression<                                                                                                                                                                                    \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>,                                         \
             detail::expression<tag, A1, A2, A3, A4>, Arg2 > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type > (), arg, a); \
   }                                                                                                                                                                                                                \
   template <class Backend>                                                                                                                                                                                         \
       inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                 \
           (number_category<Backend>::value == category),                                                                                                                                                           \
           detail::expression<                                                                                                                                                                                      \
               detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                                 \
           number<Backend, et_on>, Arg2> > ::type                                                                                                                                                                    \
                                          func(const number<Backend, et_on>& arg, Arg2 const& a)                                                                                                                    \
   {                                                                                                                                                                                                                \
      return detail::expression<                                                                                                                                                                                    \
                 detail::function, detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend>,                                                                                                               \
             number<Backend, et_on>, Arg2 > (detail::BOOST_JOIN(category, BOOST_JOIN(func, _funct)) < Backend > (), arg, a);                                                                                        \
   }                                                                                                                                                                                                                \
   template <class Backend>                                                                                                                                                                                         \
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<                                                                                                                                                                                     \
       (number_category<Backend>::value == category),                                                                                                                                                               \
       number<Backend, et_off> >::type                                                                                                                                                                              \
   func(const number<Backend, et_off>& arg, Arg2 const& a)                                                                                                                                                          \
   {                                                                                                                                                                                                                \
      detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg, a);                                                                                                           \
      number<Backend, et_off>                                                    result;                                                                                                                            \
      using default_ops::BOOST_JOIN(eval_, func);                                                                                                                                                                   \
      BOOST_JOIN(eval_, func)                                                                                                                                                                                       \
      (result.backend(), arg.backend(), a);                                                                                                                                                                         \
      return result;                                                                                                                                                                                 \
   }

#define HETERO_BINARY_OP_FUNCTOR(func, Arg2, category)                  \
   namespace detail {                                                   \
   template <class Backend>                                             \
   struct BOOST_JOIN(category, BOOST_JOIN(func, _funct))                \
   {                                                                    \
      template <class Arg>                                              \
      BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, Backend const& arg, Arg a) const \
      {                                                                 \
         using default_ops::BOOST_JOIN(eval_, func);                    \
         BOOST_JOIN(eval_, func)                                        \
         (result, arg, a);                                              \
      }                                                                 \
      template <class U, class Arg>                                              \
      BOOST_MP_CXX14_CONSTEXPR void operator()(U& result, Backend const& arg, Arg a) const \
      {                                                                 \
         using default_ops::BOOST_JOIN(eval_, func);                    \
         Backend temp;                                                  \
         BOOST_JOIN(eval_, func)                                        \
         (temp, arg, a);                                                \
         result = std::move(temp);                                  \
      }                                                                 \
   };                                                                   \
   }                                                                    \
                                                                        \
   HETERO_BINARY_OP_FUNCTOR_B(func, Arg2, category)

// clang-format on

namespace detail {
template <class Backend>
struct abs_funct
{
   BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg) const
   {
      using default_ops::eval_abs;
      eval_abs(result, arg);
   }
};
template <class Backend>
struct conj_funct
{
   BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg) const
   {
      using default_ops::eval_conj;
      eval_conj(result, arg);
   }
};
template <class Backend>
struct proj_funct
{
   BOOST_MP_CXX14_CONSTEXPR void operator()(Backend& result, const Backend& arg) const
   {
      using default_ops::eval_proj;
      eval_proj(result, arg);
   }
};

} // namespace detail

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex,
                                    detail::expression<
                                        detail::function, detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> > >::type
abs(const detail::expression<tag, A1, A2, A3, A4>& arg)
{
   return detail::expression<
       detail::function, detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> >(
       detail::abs_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value != number_kind_complex,
                             detail::expression<
                                 detail::function, detail::abs_funct<Backend>, number<Backend, et_on> > >::type
abs(const number<Backend, et_on>& arg)
{
   return detail::expression<
       detail::function, detail::abs_funct<Backend>, number<Backend, et_on> >(
       detail::abs_funct<Backend>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value != number_kind_complex, number<Backend, et_off> >::type
abs(const number<Backend, et_off>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);
   number<Backend, et_off>                                                    result;
   using default_ops::eval_abs;
   eval_abs(result.backend(), arg.backend());
   return result;
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<
    detail::function, detail::conj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> >
conj(const detail::expression<tag, A1, A2, A3, A4>& arg)
{
   return detail::expression<
       detail::function, detail::conj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> >(
       detail::conj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<
    detail::function, detail::conj_funct<Backend>, number<Backend, et_on> >
conj(const number<Backend, et_on>& arg)
{
   return detail::expression<
       detail::function, detail::conj_funct<Backend>, number<Backend, et_on> >(
       detail::conj_funct<Backend>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR number<Backend, et_off>
conj(const number<Backend, et_off>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);
   number<Backend, et_off>                                                    result;
   using default_ops::eval_conj;
   eval_conj(result.backend(), arg.backend());
   return result;
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<
    detail::function, detail::proj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> >
proj(const detail::expression<tag, A1, A2, A3, A4>& arg)
{
   return detail::expression<
       detail::function, detail::proj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>, detail::expression<tag, A1, A2, A3, A4> >(
       detail::proj_funct<typename detail::backend_type<detail::expression<tag, A1, A2, A3, A4> >::type>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<
    detail::function, detail::proj_funct<Backend>, number<Backend, et_on> >
proj(const number<Backend, et_on>& arg)
{
   return detail::expression<
       detail::function, detail::proj_funct<Backend>, number<Backend, et_on> >(
       detail::proj_funct<Backend>(), arg);
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR number<Backend, et_off>
proj(const number<Backend, et_off>& arg)
{
   detail::scoped_default_precision<multiprecision::number<Backend, et_off> > precision_guard(arg);
   number<Backend, et_off>                                                    result;
   using default_ops::eval_proj;
   eval_proj(result.backend(), arg.backend());
   return result;
}

UNARY_OP_FUNCTOR(fabs, number_kind_floating_point)
UNARY_OP_FUNCTOR(sqrt, number_kind_floating_point)
UNARY_OP_FUNCTOR(floor, number_kind_floating_point)
UNARY_OP_FUNCTOR(ceil, number_kind_floating_point)
UNARY_OP_FUNCTOR(trunc, number_kind_floating_point)
UNARY_OP_FUNCTOR(round, number_kind_floating_point)
UNARY_OP_FUNCTOR(exp, number_kind_floating_point)
UNARY_OP_FUNCTOR(exp2, number_kind_floating_point)
UNARY_OP_FUNCTOR(log, number_kind_floating_point)
UNARY_OP_FUNCTOR(log10, number_kind_floating_point)
UNARY_OP_FUNCTOR(cos, number_kind_floating_point)
UNARY_OP_FUNCTOR(sin, number_kind_floating_point)
UNARY_OP_FUNCTOR(tan, number_kind_floating_point)
UNARY_OP_FUNCTOR(asin, number_kind_floating_point)
UNARY_OP_FUNCTOR(acos, number_kind_floating_point)
UNARY_OP_FUNCTOR(atan, number_kind_floating_point)
UNARY_OP_FUNCTOR(cosh, number_kind_floating_point)
UNARY_OP_FUNCTOR(sinh, number_kind_floating_point)
UNARY_OP_FUNCTOR(tanh, number_kind_floating_point)
UNARY_OP_FUNCTOR(log2, number_kind_floating_point)
UNARY_OP_FUNCTOR(nearbyint, number_kind_floating_point)
UNARY_OP_FUNCTOR(rint, number_kind_floating_point)

HETERO_BINARY_OP_FUNCTOR(ldexp, short, number_kind_floating_point)
//HETERO_BINARY_OP_FUNCTOR(frexp, short*, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(ldexp, int, number_kind_floating_point)
//HETERO_BINARY_OP_FUNCTOR_B(frexp, int*, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(ldexp, long, number_kind_floating_point)
//HETERO_BINARY_OP_FUNCTOR_B(frexp, long*, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(ldexp, long long, number_kind_floating_point)
//HETERO_BINARY_OP_FUNCTOR_B(frexp, long long*, number_kind_floating_point)
BINARY_OP_FUNCTOR(pow, number_kind_floating_point)
BINARY_OP_FUNCTOR(fmod, number_kind_floating_point)
BINARY_OP_FUNCTOR(fmax, number_kind_floating_point)
BINARY_OP_FUNCTOR(fmin, number_kind_floating_point)
BINARY_OP_FUNCTOR(atan2, number_kind_floating_point)
BINARY_OP_FUNCTOR(fdim, number_kind_floating_point)
BINARY_OP_FUNCTOR(hypot, number_kind_floating_point)
BINARY_OP_FUNCTOR(remainder, number_kind_floating_point)

UNARY_OP_FUNCTOR(logb, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR(scalbn, short, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR(scalbln, short, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbn, int, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbln, int, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbn, long, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbln, long, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbn, long long, number_kind_floating_point)
HETERO_BINARY_OP_FUNCTOR_B(scalbln, long long, number_kind_floating_point)

//
// Complex functions:
//
UNARY_OP_FUNCTOR(exp, number_kind_complex)
UNARY_OP_FUNCTOR(log, number_kind_complex)
UNARY_OP_FUNCTOR(log10, number_kind_complex)
BINARY_OP_FUNCTOR(pow, number_kind_complex)
UNARY_OP_FUNCTOR(sqrt, number_kind_complex)
UNARY_OP_FUNCTOR(sin, number_kind_complex)
UNARY_OP_FUNCTOR(cos, number_kind_complex)
UNARY_OP_FUNCTOR(tan, number_kind_complex)
UNARY_OP_FUNCTOR(asin, number_kind_complex)
UNARY_OP_FUNCTOR(acos, number_kind_complex)
UNARY_OP_FUNCTOR(atan, number_kind_complex)
UNARY_OP_FUNCTOR(sinh, number_kind_complex)
UNARY_OP_FUNCTOR(cosh, number_kind_complex)
UNARY_OP_FUNCTOR(tanh, number_kind_complex)
UNARY_OP_FUNCTOR(asinh, number_kind_complex)
UNARY_OP_FUNCTOR(acosh, number_kind_complex)
UNARY_OP_FUNCTOR(atanh, number_kind_complex)

//
// Integer functions:
//
BINARY_OP_FUNCTOR(gcd, number_kind_integer)
BINARY_OP_FUNCTOR(lcm, number_kind_integer)
HETERO_BINARY_OP_FUNCTOR(pow, unsigned, number_kind_integer)

#undef BINARY_OP_FUNCTOR
#undef UNARY_OP_FUNCTOR

//
// ilogb:
//
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_floating_point, typename Backend::exponent_type>::type
ilogb(const multiprecision::number<Backend, ExpressionTemplates>& val)
{
   using default_ops::eval_ilogb;
   return eval_ilogb(val.backend());
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<detail::expression<tag, A1, A2, A3, A4> >::value == number_kind_floating_point, typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type::backend_type::exponent_type>::type
ilogb(const detail::expression<tag, A1, A2, A3, A4>& val)
{
   using default_ops::eval_ilogb;
   typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type arg(val);
   return eval_ilogb(arg.backend());
}

} //namespace multiprecision

namespace math {
//
// Overload of Boost.Math functions that find the wrong overload when used with number:
//
namespace detail {
template <class T>
T sinc_pi_imp(T);
template <class T>
T sinhc_pi_imp(T);
} // namespace detail
template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x)
{
   boost::multiprecision::detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(x);
   return std::move(detail::sinc_pi_imp(x));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline multiprecision::number<Backend, ExpressionTemplates> sinc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x, const Policy&)
{
   boost::multiprecision::detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(x);
   return std::move(detail::sinc_pi_imp(x));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline multiprecision::number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x)
{
   boost::multiprecision::detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(x);
   return std::move(detail::sinhc_pi_imp(x));
}

template <class Backend, multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline multiprecision::number<Backend, ExpressionTemplates> sinhc_pi(const multiprecision::number<Backend, ExpressionTemplates>& x, const Policy&)
{
   boost::multiprecision::detail::scoped_default_precision<multiprecision::number<Backend, ExpressionTemplates> > precision_guard(x);
   return std::move(boost::math::sinhc_pi(x));
}

using boost::multiprecision::gcd;
using boost::multiprecision::lcm;

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
} // namespace math

namespace integer {

using boost::multiprecision::gcd;
using boost::multiprecision::lcm;

} // namespace integer

} // namespace boost

//
// This has to come last of all:
//
#include <boost/multiprecision/detail/no_et_ops.hpp>
#include <boost/multiprecision/detail/et_ops.hpp>
//
// min/max overloads:
//
#include <boost/multiprecision/detail/min_max.hpp>

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/digits.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DETAIL_DIGITS_HPP
#define BOOST_MP_DETAIL_DIGITS_HPP

namespace boost { namespace multiprecision { namespace detail {

inline constexpr unsigned long digits10_2_2(unsigned long d10)
{
   return (d10 * 1000uL) / 301uL + ((d10 * 1000uL) % 301 ? 2u : 1u);
}

inline constexpr unsigned long digits2_2_10(unsigned long d2)
{
   return (d2 * 301uL) / 1000uL;
}


#if ULONG_MAX != SIZE_MAX

inline constexpr std::size_t digits10_2_2(std::size_t d10)
{
   return (d10 * 1000uL) / 301uL + ((d10 * 1000uL) % 301 ? 2u : 1u);
}

inline constexpr std::size_t digits2_2_10(std::size_t d2)
{
   return (d2 * 301uL) / 1000uL;
}

template <class I>
inline constexpr typename std::enable_if<sizeof(I) <= sizeof(unsigned long), unsigned long>::type digits10_2_2(I d10)
{
   return digits10_2_2(static_cast<unsigned long>(d10));
}

template <class I>
inline constexpr typename std::enable_if<sizeof(I) <= sizeof(unsigned long), unsigned long>::type digits2_2_10(I d10)
{
   return digits2_2_10(static_cast<unsigned long>(d10));
}
#endif

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/dynamic_array.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock.
//  Copyright Christopher Kormanyos 2013. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_MP_DETAIL_DYNAMIC_ARRAY_HPP
#define BOOST_MP_DETAIL_DYNAMIC_ARRAY_HPP

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <vector>

#include <boost/multiprecision/detail/rebind.hpp>

namespace boost { namespace multiprecision { namespace backends { namespace detail {
template <class ValueType, const std::uint32_t ElemNumber, class my_allocator>
struct dynamic_array : public std::vector<ValueType, typename rebind<ValueType, my_allocator>::type>
{
private:
   using base_class_type = std::vector<ValueType, typename rebind<ValueType, my_allocator>::type>;

public:
   dynamic_array()
      : base_class_type(static_cast<typename base_class_type::size_type>(ElemNumber),
                        static_cast<typename base_class_type::value_type>(0u)) { }

   dynamic_array(std::initializer_list<std::uint32_t> lst)
      : base_class_type(static_cast<typename base_class_type::size_type>(ElemNumber),
                        static_cast<typename base_class_type::value_type>(0u))
   {
      std::copy(lst.begin(),
                lst.begin() + (std::min)(std::size_t(lst.size()), std::size_t(ElemNumber)),
                data());
   }

         typename base_class_type::value_type* data()       { return &(*(this->begin())); }
   const typename base_class_type::value_type* data() const { return &(*(this->begin())); }
};
}}}} // namespace boost::multiprecision::backends::detail

#endif // BOOST_MP_DETAIL_DYNAMIC_ARRAY_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/empty_value.hpp
================================================
/////////////////////////////////////////////////////////////////////
//  Copyright 2018 Glen Joseph Fernandes. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DETAIL_EMPTY_VALUE_HPP
#define BOOST_MP_DETAIL_EMPTY_VALUE_HPP

#include <utility>
#include <boost/multiprecision/detail/standalone_config.hpp>

#if defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION >= 40700)
#define BOOST_DETAIL_EMPTY_VALUE_BASE
#elif defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1800)
#define BOOST_DETAIL_EMPTY_VALUE_BASE
#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1800)
#define BOOST_DETAIL_EMPTY_VALUE_BASE
#elif defined(BOOST_CLANG) && !defined(__CUDACC__)
#if __has_feature(is_empty) && __has_feature(is_final)
#define BOOST_DETAIL_EMPTY_VALUE_BASE
#endif
#endif

namespace boost { namespace multiprecision { namespace detail {

template <typename T>
struct use_empty_value_base 
{
#if defined(BOOST_DETAIL_EMPTY_VALUE_BASE)
        static constexpr bool value = __is_empty(T) && !__is_final(T);
#else
        static constexpr bool value = false;
#endif
};

struct empty_init_t {};

namespace empty_impl {

template <typename T, unsigned N = 0, 
          bool E = boost::multiprecision::detail::use_empty_value_base<T>::value>
class empty_value
{
private:
    T value_;

public:
    using type = T;

    empty_value() = default;
    explicit empty_value(boost::multiprecision::detail::empty_init_t) : value_ {} {}

    template <typename U, typename... Args>
    empty_value(boost::multiprecision::detail::empty_init_t, U&& value, Args&&... args) :
        value_ {std::forward<U>(value), std::forward<Args>(args)...} {}

    const T& get() const noexcept { return value_; }
    T& get() noexcept { return value_; }
};

template <typename T, unsigned N>
class empty_value<T, N, true> : T
{
public:
    using type = T;

    empty_value() = default;
    explicit empty_value(boost::multiprecision::detail::empty_init_t) : T{} {}

    template <typename U, typename... Args>
    empty_value(boost::multiprecision::detail::empty_init_t, U&& value, Args&&... args) :
        T{std::forward<U>(value), std::forward<Args>(args)...} {}

    const T& get() const noexcept { return *this; }
    T& get() noexcept { return *this; }
};

} // Namespace empty impl

using empty_impl::empty_value;

BOOST_INLINE_CONSTEXPR empty_init_t empty_init = empty_init_t();

}}} // Namespaces

#endif // BOOST_MP_DETAIL_EMPTY_VALUE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/endian.hpp
================================================
////////////////////////////////////////////////////////////////
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DETAIL_ENDIAN_HPP
#define BOOST_MP_DETAIL_ENDIAN_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#ifndef BOOST_MP_STANDALONE

#  include <boost/predef/other/endian.h>
#  define BOOST_MP_ENDIAN_BIG_BYTE BOOST_ENDIAN_BIG_BYTE
#  define BOOST_MP_ENDIAN_LITTLE_BYTE BOOST_ENDIAN_LITTLE_BYTE

#elif defined(_WIN32)

#  define BOOST_MP_ENDIAN_BIG_BYTE 0
#  define BOOST_MP_ENDIAN_LITTLE_BYTE 1

#elif defined(__BYTE_ORDER__)

#  define BOOST_MP_ENDIAN_BIG_BYTE (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#  define BOOST_MP_ENDIAN_LITTLE_BYTE (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)

#else
#  error Could not determine endian type. Please disable standalone mode, and file an issue at https://github.com/boostorg/multiprecision
#endif // Determine endianness

static_assert((BOOST_MP_ENDIAN_BIG_BYTE || BOOST_MP_ENDIAN_LITTLE_BYTE)
    && !(BOOST_MP_ENDIAN_BIG_BYTE && BOOST_MP_ENDIAN_LITTLE_BYTE),
    "Inconsistent endianness detected. Please disable standalone mode, and file an issue at https://github.com/boostorg/multiprecision");

#endif // BOOST_MP_DETAIL_ENDIAN_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/et_ops.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_ET_OPS_HPP
#define BOOST_MP_ET_OPS_HPP

namespace boost { namespace multiprecision {

//
// Non-member operators for number which return expression templates.
// 
// Note that operators taking rvalue-references DO NOT return expression templates
// as this can lead to dangling references, see https://github.com/boostorg/multiprecision/issues/175.
//
// Unary operators first.
// Note that these *must* return by value, even though that's somewhat against
// existing practice.  The issue is that in C++11 land one could easily and legitimately
// write:
//    auto x = +1234_my_user_defined_suffix;
// which would result in a dangling-reference-to-temporary if unary + returned a reference
// to it's argument.  While return-by-value is obviously inefficient in other situations
// the reality is that no one ever uses unary operator+ anyway...!
//
template <class B, expression_template_option ExpressionTemplates>
inline constexpr const number<B, ExpressionTemplates> operator+(const number<B, ExpressionTemplates>& v) { return v; }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline constexpr const detail::expression<tag, Arg1, Arg2, Arg3, Arg4> operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, number<B, et_on> > operator-(const number<B, et_on>& v)
{
   static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
   return detail::expression<detail::negate, number<B, et_on> >(v);
}
// rvalue ops:
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on> operator-(number<B, et_on>&& v)
{
   static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
   v.backend().negate();
   return std::move(v);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v)
{
   static_assert((is_signed_number<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value), "Negating an unsigned type results in ill-defined behavior.");
   return detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::complement_immediates, number<B, et_on> > >::type
operator~(const number<B, et_on>& v) { return detail::expression<detail::complement_immediates, number<B, et_on> >(v); }

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            number<B, et_on> >::type
operator~(number<B, et_on>&& v) 
{ 
   using default_ops::eval_complement;
   eval_complement(v.backend(), v.backend());
   return std::move(v);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
                            detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator~(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
//
// Then addition:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
operator+(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_add;
   eval_add(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_add;
   eval_add(b.backend(), a.backend());
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_add;
   eval_add(a.backend(), b.backend());
   return std::move(a);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, number<B, et_on>, V> >::type
operator+(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::add_immediates, number<B, et_on>, V>(a, b);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator+(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_add;
   eval_add(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
operator+(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator+(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_add;
   eval_add(b.backend(), number<B, et_on>::canonical_value(a));
   return std::move(b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator+(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< 
   std::is_same<typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET> >::value,
   typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a += b;
   return std::move(a);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< 
   !std::is_same<typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET> >::value,
   typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< 
   std::is_same<typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b += a;
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if< 
   !std::is_same<typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator+(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Fused multiply add:
//
template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
                          detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator+(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a);
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
                          detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator+(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
}

template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   a += b;
   return std::move(a);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b += a;
   return std::move(b);
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type>::type
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}

//
// Fused multiply subtract:
//
template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
                          detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> > >::type
operator-(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a));
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value,
                          detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >
operator-(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
}

template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   a -= b;
   return std::move(a);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}

//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
operator+(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
}

template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   a -= b.left_ref();
   return std::move(a);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
operator+(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b -= a.left_ref();
   return std::move(b);
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type>::type
operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator+(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator+(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   using default_ops::eval_subtract;
   eval_subtract(a.backend(), b.left_ref().backend());
   return std::move(a);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
   return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   using default_ops::eval_subtract;
   eval_subtract(b.backend(), a.left_ref().backend());
   return std::move(b);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
   return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(b, a.left_ref());
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
   return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
}

template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
   return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
}

template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
operator+(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}

template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator+(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b.left_ref()));
}
//
// Subtraction:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator-(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_subtract;
   eval_subtract(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_subtract;
   eval_subtract(b.backend(), a.backend());
   b.backend().negate();
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_subtract;
   eval_subtract(a.backend(), b.backend());
   return std::move(a);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, number<B, et_on>, V> >::type
operator-(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::subtract_immediates, number<B, et_on>, V>(a, b);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator-(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_subtract;
   eval_subtract(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
operator-(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(a, b);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator-(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_subtract;
   eval_subtract(b.backend(), number<B, et_on>::canonical_value(a));
   b.backend().negate();
   return std::move(b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator-(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a -= b;
   return std::move(a);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b -= a;
   b.backend().negate();
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator-(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, Arg1>
operator-(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
}

template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   a += b.left_ref();
   return std::move(a);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type, number<B, ET>>::value,
   typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type>::type
operator-(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >
operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(
       detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type>::type
operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b += a.left_ref();
   b.backend().negate();
   return std::move(b);
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type>::type
operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
operator-(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator-(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   using default_ops::eval_add;
   eval_add(a.backend(), b.left_ref().backend());
   return std::move(a);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   using default_ops::eval_add;
   eval_add(b.backend(), a.left_ref().backend());
   b.backend().negate();
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
         detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> > >::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> >(detail::expression<detail::add_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}

template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
operator-(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b.left_ref());
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> > >::type
operator-(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}

template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator-(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}

//
// Multiplication:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >
operator*(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_multiply;
   eval_multiply(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_multiply;
   eval_multiply(b.backend(), a.backend());
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_multiply;
   eval_multiply(a.backend(), b.backend());
   return std::move(a);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >::type
operator*(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a, b);
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator*(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_multiply;
   eval_multiply(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::multiply_immediates, V, number<B, et_on> > >::type
operator*(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::multiply_immediates, V, number<B, et_on> >(a, b);
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator*(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_multiply;
   eval_multiply(b.backend(), number<B, et_on>::canonical_value(a));
   return std::move(b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator*(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator*(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a *= b;
   return std::move(a);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator*(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   b *= a;
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type>::type
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator*(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
operator*(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
       detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
}

template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
operator*(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
       detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
       detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
}

template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
       detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
operator*(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator*(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   a *= b.left_ref();
   a.backend().negate();
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator*(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
         detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   b *= a.left_ref();
   b.backend().negate();
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type, number<B, et_on>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type>::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
         detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}

template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}

template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}

template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
operator*(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, V>(b.left_ref(), a));
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator*(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
}

template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator*(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
}

//
// Division:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >
operator/(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_divide;
   eval_divide(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(const number<B, et_on>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_divide;
   eval_divide(a.backend(), b.backend());
   return std::move(a);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, detail::expression<detail::divide_immediates, number<B, et_on>, V> >::type
operator/(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::divide_immediates, number<B, et_on>, V>(a, b);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && !is_equivalent_number_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator/(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_divide;
   eval_divide(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::divide_immediates, V, number<B, et_on> > >::type
operator/(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, number<B, et_on> >::type
operator/(const V& a, number<B, et_on>&& b)
{
   return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator/(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator/(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a /= b;
   return std::move(a);
}
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator/(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value, detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator/(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >
operator/(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
       detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline typename std::enable_if<
   std::is_same<typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type>::type
operator/(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   a /= b.left_ref();
   a.backend().negate();
   return std::move(a);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline typename std::enable_if<
   !std::is_same<typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type, number<B, ET>>::value,
   typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type>::type
operator/(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
         detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >
operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
       detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >::result_type
operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
       detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
operator/(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator/(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   a /= b.left_ref();
   a.backend().negate();
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> > >::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> >(
       detail::expression<detail::divide_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
       detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > > >::type
operator/(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b.left_ref()));
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >::value, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > > >::type
operator/(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<number<B2, ET>, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >::result_type>::value, number<B, et_on> >::type
operator/(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
   return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
       detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
}
//
// Modulus:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> > >::type
operator%(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator%(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_modulus;
   eval_modulus(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator%(const number<B, et_on>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator%(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_modulus;
   eval_modulus(a.backend(), b.backend());
   return std::move(a);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, number<B, et_on> >::value,
                            detail::expression<detail::modulus_immediates, number<B, et_on>, V> >::type
operator%(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::modulus_immediates, number<B, et_on>, V>(a, b);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, number<B, et_on> >::value,
   number<B, et_on> >::type
operator%(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_modulus;
   eval_modulus(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::modulus_immediates, V, number<B, et_on> > >::type
operator%(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator%(const V& a, number<B, et_on>&& b)
{
   return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator%(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value 
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator%(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a %= b;
   return std::move(a);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value 
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator%(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
                            detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator%(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Left shift:
//
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), detail::expression<detail::shift_left, number<B, et_on>, I> >::type
operator<<(const number<B, et_on>& a, const I& b)
{
   return detail::expression<detail::shift_left, number<B, et_on>, I>(a, b);
}
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_on> >::type
operator<<(number<B, et_on>&& a, const I& b)
{
   using default_ops::eval_left_shift;
   eval_left_shift(a.backend(), b);
   return std::move(a);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
operator<<(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
   return detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Right shift:
//
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::shift_right, number<B, et_on>, I> >::type
operator>>(const number<B, et_on>& a, const I& b)
{
   return detail::expression<detail::shift_right, number<B, et_on>, I>(a, b);
}
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator>>(number<B, et_on>&& a, const I& b)
{
   using default_ops::eval_right_shift;
   eval_right_shift(a.backend(), b);
   return std::move(a);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
operator>>(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
   return detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Bitwise AND:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> > >::type
operator&(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator&(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_bitwise_and;
   eval_bitwise_and(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator&(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_and;
   eval_bitwise_and(b.backend(), a.backend());
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator&(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_and;
   eval_bitwise_and(a.backend(), b.backend());
   return std::move(a);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V> >::type
operator&(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V>(a, b);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator&(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_bitwise_and;
   eval_bitwise_and(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> > >::type
operator&(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> >(a, b);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator&(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_and;
   eval_bitwise_and(b.backend(), number<B, et_on>::canonical_value(a));
   return std::move(b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator&(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator&(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a &= b;
   return std::move(a);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator&(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   b &= a;
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
                            detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator&(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise OR:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> > >::type
operator|(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator|(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_bitwise_or;
   eval_bitwise_or(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator|(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_or;
   eval_bitwise_or(b.backend(), a.backend());
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator|(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_or;
   eval_bitwise_or(a.backend(), b.backend());
   return std::move(a);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V> >::type
operator|(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V>(a, b);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator|(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_bitwise_or;
   eval_bitwise_or(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> > >::type
operator|(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> >(a, b);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator|(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_or;
   eval_bitwise_or(b.backend(), number<B, et_on>::canonical_value(a));
   return std::move(b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator|(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator|(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a |= b;
   return std::move(a);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator|(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   b |= a;
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
                            detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator|(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise XOR:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> > >::type
operator^(const number<B, et_on>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator^(number<B, et_on>&& a, const number<B, et_on>& b)
{
   using default_ops::eval_bitwise_xor;
   eval_bitwise_xor(a.backend(), b.backend());
   return std::move(a);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator^(const number<B, et_on>& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_xor;
   eval_bitwise_xor(b.backend(), a.backend());
   return std::move(b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
   number<B, et_on> >::type
operator^(number<B, et_on>&& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_xor;
   eval_bitwise_xor(a.backend(), b.backend());
   return std::move(a);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V> >::type
operator^(const number<B, et_on>& a, const V& b)
{
   return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V>(a, b);
}
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator^(number<B, et_on>&& a, const V& b)
{
   using default_ops::eval_bitwise_xor;
   eval_bitwise_xor(a.backend(), number<B, et_on>::canonical_value(b));
   return std::move(a);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
                            detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> > >::type
operator^(const V& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> >(a, b);
}
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category<B>::value == number_kind_integer),
   number<B, et_on> >::type
operator^(const V& a, number<B, et_on>&& b)
{
   using default_ops::eval_bitwise_xor;
   eval_bitwise_xor(b.backend(), number<B, et_on>::canonical_value(a));
   return std::move(b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator^(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator^(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   a ^= b;
   return std::move(a);
}
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator^(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer,
                            detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
   return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   std::is_same<typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   b ^= a;
   return std::move(b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
   !std::is_same<typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type, number<B, et_on>>::value
   && number_category<B>::value == number_kind_integer,
   typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
   return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
                            detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
   return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
                            detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
   return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer), detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator^(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
   return detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/float128_functions.hpp
================================================
//  (C) Copyright John Maddock 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// We deliberately use assert in here:
//

#ifndef BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP
#define BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#ifndef BOOST_MP_STANDALONE
#include <boost/cstdfloat.hpp>
#if defined(BOOST_MATH_USE_FLOAT128) && !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT)
#  define BOOST_MP_HAVE_CSTDFLOAT
#endif
#endif

#if defined(BOOST_HAS_FLOAT128)

namespace boost 
{
namespace multiprecision 
{
namespace float128_procs 
{
extern "C" __float128 ldexpq(__float128, int) throw();
extern "C" __float128 frexpq(__float128, int*) throw();
extern "C" __float128 floorq(__float128) throw();
extern "C" __float128 nextafterq(__float128, __float128) throw();
extern "C" int        isinfq(__float128) throw();
extern "C" int        isnanq(__float128) throw();
extern "C" __float128 strtoflt128(const char*, char**) throw();

#ifdef BOOST_MP_HAVE_CSTDFLOAT
using std::ldexp;
using std::frexp;
using std::floor;
using std::nextafter;
#else
inline __float128 ldexp(__float128 f, int i) throw() { return ldexpq(f, i); }
inline __float128 frexp(__float128 f, int* p) throw() { return frexpq(f, p); }
inline __float128 floor(__float128 f) throw() { return floorq(f); }
inline __float128 nextafter(__float128 a, __float128 b) throw() { return nextafterq(a, b); }
#endif
}

namespace detail {

template <class T>
struct is_float128 : public std::is_same<__float128, T>
{};

}
}
}

namespace boost {
namespace math {

   inline __float128 float_next(const __float128& f)
   {
      return boost::multiprecision::float128_procs::nextafterq(f, 2 * f);
   }
   inline int (isinf)(const __float128& f)
   {
      return boost::multiprecision::float128_procs::isinfq(f);
   }
   inline int (isnan)(const __float128& f)
   {
      return boost::multiprecision::float128_procs::isnanq(f);
   }

}}

#define BOOST_MP_FLOAT128_USING using boost::multiprecision::float128_procs::ldexp; using boost::multiprecision::float128_procs::frexp; using boost::multiprecision::float128_procs::floor; using boost::multiprecision::float128_procs::nextafter; using boost::math::isinf; using boost::math::isnan;

#else
#define BOOST_MP_FLOAT128_USING

namespace boost {
namespace multiprecision {
namespace detail {

template <class T>
struct is_float128 : public std::false_type
{};

}}} // namespace boost::multiprecision::detail

#endif

#endif // BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/float_string_cvt.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Generic routines for converting floating point values to and from decimal strings.
// Note that these use "naive" algorithms which result in rounding error - so they
// do not round trip to and from the string representation (but should only be out
// in the last bit).
//

#ifndef BOOST_MP_FLOAT_STRING_CVT_HPP
#define BOOST_MP_FLOAT_STRING_CVT_HPP

#include <string>
#include <cctype>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class I>
inline void round_string_up_at(std::string& s, std::ptrdiff_t pos, I& expon)
{
   //
   // Rounds up a string representation of a number at pos:
   //
   if (pos < 0)
   {
      s.insert(static_cast<std::string::size_type>(0), 1, '1');
      s.erase(s.size() - 1);
      ++expon;
   }
   else if (s[static_cast<std::size_t>(pos)] == '9')
   {
      s[static_cast<std::size_t>(pos)] = '0';
      round_string_up_at(s, pos - 1, expon);
   }
   else
   {
      if ((pos == 0) && (s[static_cast<std::size_t>(pos)] == '0') && (s.size() == 1))
         ++expon;
      ++s[static_cast<std::size_t>(pos)];
   }
}

template <class Backend>
std::string convert_to_string(Backend b, std::streamsize digits, std::ios_base::fmtflags f)
{
   using default_ops::eval_convert_to;
   using default_ops::eval_divide;
   using default_ops::eval_floor;
   using default_ops::eval_fpclassify;
   using default_ops::eval_log10;
   using default_ops::eval_multiply;
   using default_ops::eval_pow;
   using default_ops::eval_subtract;

   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   using exponent_type = typename Backend::exponent_type                            ;

   std::string     result;
   bool            iszero     = false;
   bool            isneg      = false;
   exponent_type   expon      = 0;
   std::streamsize org_digits = digits;
   BOOST_MP_ASSERT(digits > 0);

   int fpt = eval_fpclassify(b);

   if (fpt == static_cast<int>(FP_ZERO))
   {
      result = "0";
      iszero = true;
   }
   else if (fpt == static_cast<int>(FP_INFINITE))
   {
      if (b.compare(ui_type(0)) < 0)
         return "-inf";
      else
         return ((f & std::ios_base::showpos) == std::ios_base::showpos) ? "+inf" : "inf";
   }
   else if (fpt == static_cast<int>(FP_NAN))
   {
      return "nan";
   }
   else
   {
      //
      // Start by figuring out the exponent:
      //
      isneg = b.compare(ui_type(0)) < 0;
      if (isneg)
         b.negate();
      Backend t;
      Backend ten;
      ten = ui_type(10);

      eval_log10(t, b);
      eval_floor(t, t);
      eval_convert_to(&expon, t);
      if (-expon > std::numeric_limits<number<Backend> >::max_exponent10 - 3)
      {
         int     e = -expon / 2;
         Backend t2;
         eval_pow(t2, ten, e);
         eval_multiply(t, t2, b);
         eval_multiply(t, t2);
         if (expon & 1)
            eval_multiply(t, ten);
      }
      else
      {
         eval_pow(t, ten, -expon);
         eval_multiply(t, b);
      }
      //
      // Make sure we're between [1,10) and adjust if not:
      //
      if (t.compare(ui_type(1)) < 0)
      {
         eval_multiply(t, ui_type(10));
         --expon;
      }
      else if (t.compare(ui_type(10)) >= 0)
      {
         eval_divide(t, ui_type(10));
         ++expon;
      }
      Backend digit;
      ui_type cdigit;
      //
      // Adjust the number of digits required based on formatting options:
      //
      if (((f & std::ios_base::fixed) == std::ios_base::fixed) && (expon != -1))
         digits += expon + 1;
      if ((f & std::ios_base::scientific) == std::ios_base::scientific)
         ++digits;
      //
      // Extract the digits one at a time:
      //
      for (unsigned i = 0; i < digits; ++i)
      {
         eval_floor(digit, t);
         eval_convert_to(&cdigit, digit);
         result += static_cast<char>('0' + cdigit);
         eval_subtract(t, digit);
         eval_multiply(t, ten);
      }
      //
      // Possibly round result:
      //
      if (digits >= 0)
      {
         eval_floor(digit, t);
         eval_convert_to(&cdigit, digit);
         eval_subtract(t, digit);
         if ((cdigit == 5) && (t.compare(ui_type(0)) == 0))
         {
            // Bankers rounding:
            if ((*result.rbegin() - '0') & 1)
            {
               round_string_up_at(result, result.size() - 1, expon);
            }
         }
         else if (cdigit >= 5)
         {
            round_string_up_at(result, result.size() - 1, expon);
         }
      }
      eval_floor(t, b);
      if ((t.compare(b) == 0) && (static_cast<std::size_t>(expon + 1) < result.size()))
      {
         // Input is an integer, sometimes we get a result which is not an integer here as a result of printing too
         // many digits, so lets round if required:
         round_string_up_at(result, expon + 1, expon);
         result.erase(expon + 1);
      }
   }
   while ((static_cast<std::streamsize>(result.size()) > digits) && (result.size() != 0U))
   {
      // We may get here as a result of rounding...
      if (result.size() > 1)
         result.erase(result.size() - 1);
      else
      {
         if (expon > 0)
            --expon; // so we put less padding in the result.
         else
            ++expon;
         ++digits;
      }
   }
   BOOST_MP_ASSERT(org_digits >= 0);
   if (isneg)
      result.insert(static_cast<std::string::size_type>(0), 1, '-');
   format_float_string(result, expon, org_digits, f, iszero);

   return result;
}

template <class Backend>
void convert_from_string(Backend& b, const char* p)
{
   using default_ops::eval_add;
   using default_ops::eval_divide;
   using default_ops::eval_multiply;
   using default_ops::eval_pow;

   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
   b = ui_type(0);
   if (!p || (*p == 0))
      return;

   bool                            is_neg       = false;
   bool                            is_neg_expon = false;
   constexpr ui_type               ten          = ui_type(10);
   typename Backend::exponent_type expon        = 0;
   int                             digits_seen  = 0;

   using limits = std::numeric_limits<number<Backend, et_off>>;

   constexpr int max_digits = limits::is_specialized ? limits::max_digits10 + 1 : INT_MAX;

   if (*p == '+')
      ++p;
   else if (*p == '-')
   {
      is_neg = true;
      ++p;
   }
   if ((std::strcmp(p, "nan") == 0) || (std::strcmp(p, "NaN") == 0) || (std::strcmp(p, "NAN") == 0))
   {
      eval_divide(b, ui_type(0));
      if (is_neg)
         b.negate();
      return;
   }
   if ((std::strcmp(p, "inf") == 0) || (std::strcmp(p, "Inf") == 0) || (std::strcmp(p, "INF") == 0))
   {
      b = ui_type(1);
      eval_divide(b, ui_type(0));
      if (is_neg)
         b.negate();
      return;
   }
   //
   // Grab all the leading digits before the decimal point:
   //
   while (std::isdigit(*p))
   {
      eval_multiply(b, ten);
      eval_add(b, ui_type(*p - '0'));
      ++p;
      ++digits_seen;
   }
   if (*p == '.')
   {
      //
      // Grab everything after the point, stop when we've seen
      // enough digits, even if there are actually more available:
      //
      ++p;
      while (std::isdigit(*p))
      {
         eval_multiply(b, ten);
         eval_add(b, ui_type(*p - '0'));
         ++p;
         --expon;
         if (++digits_seen > max_digits)
            break;
      }
      while (std::isdigit(*p))
         ++p;
   }
   //
   // Parse the exponent:
   //
   if ((*p == 'e') || (*p == 'E'))
   {
      ++p;
      if (*p == '+')
         ++p;
      else if (*p == '-')
      {
         is_neg_expon = true;
         ++p;
      }
      typename Backend::exponent_type e2 = 0;
      while (std::isdigit(*p))
      {
         e2 *= 10;
         e2 += (*p - '0');
         ++p;
      }
      if (is_neg_expon)
         e2 = -e2;
      expon += e2;
   }
   if (expon)
   {
      // Scale by 10^expon, note that 10^expon can be
      // outside the range of our number type, even though the
      // result is within range, if that looks likely, then split
      // the calculation in two:
      Backend t;
      t = ten;
      if (expon > limits::min_exponent10 + 2)
      {
         eval_pow(t, t, expon);
         eval_multiply(b, t);
      }
      else
      {
         eval_pow(t, t, expon + digits_seen + 1);
         eval_multiply(b, t);
         t = ten;
         eval_pow(t, t, -digits_seen - 1);
         eval_multiply(b, t);
      }
   }
   if (is_neg)
      b.negate();
   if (*p)
   {
      // Unexpected input in string:
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected characters in string being interpreted as a float128."));
   }
}

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/fpclassify.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2022 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_FPCLASSIFY_HPP
#define BOOST_MP_DETAIL_FPCLASSIFY_HPP

#include <cmath>
#include <limits>
#include <type_traits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/fpclassify.hpp>

#define BOOST_MP_ISNAN(x) (boost::math::isnan)(x)
#define BOOST_MP_ISINF(x) (boost::math::isinf)(x)
#define BOOST_MP_FPCLASSIFY(x) (boost::math::fpclassify)(x)
#define BOOST_MP_ISFINITE(x) (!(boost::math::isnan)(x) && !(boost::math::isinf)(x))

#else

namespace boost { namespace multiprecision { namespace detail {

template <typename T, typename std::enable_if<std::is_floating_point<T>::value
                      #ifdef BOOST_HAS_FLOAT128
                      || std::is_same<T, float128_type>::value
                      #endif
                      , bool>::type = true>
inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    BOOST_MP_FLOAT128_USING;
    using std::isnan;
    return static_cast<bool>((isnan)(x));
}

template <typename T, typename std::enable_if<!std::is_floating_point<T>::value
                      #ifdef BOOST_HAS_FLOAT128
                      && !std::is_same<T, float128_type>::value
                      #endif
                      , bool>::type = true>
inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    return x != x;
}

template <typename T, typename std::enable_if<std::is_floating_point<T>::value
                      #ifdef BOOST_HAS_FLOAT128
                      || std::is_same<T, float128_type>::value
                      #endif
                      , bool>::type = true>
inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    BOOST_MP_FLOAT128_USING;
    using std::isinf;
    return static_cast<bool>((isinf)(x));
}

template <typename T, typename std::enable_if<!std::is_floating_point<T>::value
                      #ifdef BOOST_HAS_FLOAT128
                      && !std::is_same<T, float128_type>::value
                      #endif
                      , bool>::type = true>
inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    return x == std::numeric_limits<T>::infinity() || x == -std::numeric_limits<T>::infinity();
}

template <typename T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = true>
inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    using std::fpclassify;
    return fpclassify(x);
}

template <typename T, typename std::enable_if<!std::is_floating_point<T>::value, bool>::type = true>
inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
{
    BOOST_MP_FLOAT128_USING;
    using std::isnan;
    using std::isinf;
    using std::abs;

    return (isnan)(x) ? FP_NAN :
           (isinf)(x) ? FP_INFINITE :
           abs(x) == T(0) ? FP_ZERO :
           abs(x) > 0 && abs(x) < (std::numeric_limits<T>::min)() ? FP_SUBNORMAL : FP_NORMAL;
}

}}} // Namespace boost::multiprecision::detail

#define BOOST_MP_ISNAN(x) (boost::multiprecision::detail::isnan)(x)
#define BOOST_MP_ISINF(x) (boost::multiprecision::detail::isinf)(x)
#define BOOST_MP_FPCLASSIFY(x) (boost::multiprecision::detail::fpclassify)(x)
#define BOOST_MP_ISFINITE(x) (!(boost::multiprecision::detail::isnan)(x) && !(boost::multiprecision::detail::isinf)(x))

#endif

#endif // BOOST_MP_DETAIL_FPCLASSIFY_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/functions/constants.hpp
================================================
// Copyright 2011 John Maddock.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//
// This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp
//

template <class T>
void calc_log2(T& num, unsigned digits)
{
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;
   using si_type = typename std::tuple_element<0, typename T::signed_types>::type                        ;

   //
   // String value with 1100 digits:
   //
   static const char* string_val = "0."
                                   "6931471805599453094172321214581765680755001343602552541206800094933936219696947156058633269964186875"
                                   "4200148102057068573368552023575813055703267075163507596193072757082837143519030703862389167347112335"
                                   "0115364497955239120475172681574932065155524734139525882950453007095326366642654104239157814952043740"
                                   "4303855008019441706416715186447128399681717845469570262716310645461502572074024816377733896385506952"
                                   "6066834113727387372292895649354702576265209885969320196505855476470330679365443254763274495125040606"
                                   "9438147104689946506220167720424524529612687946546193165174681392672504103802546259656869144192871608"
                                   "2938031727143677826548775664850856740776484514644399404614226031930967354025744460703080960850474866"
                                   "3852313818167675143866747664789088143714198549423151997354880375165861275352916610007105355824987941"
                                   "4729509293113897155998205654392871700072180857610252368892132449713893203784393530887748259701715591"
                                   "0708823683627589842589185353024363421436706118923678919237231467232172053401649256872747782344535347"
                                   "6481149418642386776774406069562657379600867076257199184734022651462837904883062033061144630073719489";
   //
   // Check if we can just construct from string:
   //
   if (digits < 3640) // 3640 binary digits ~ 1100 decimal digits
   {
      num = string_val;
      return;
   }
   //
   // We calculate log2 from using the formula:
   //
   // ln(2) = 3/4 SUM[n>=0] ((-1)^n * N!^2 / (2^n(2n+1)!))
   //
   // Numerator and denominator are calculated separately and then
   // divided at the end, we also precalculate the terms up to n = 5
   // since these fit in a 32-bit integer anyway.
   //
   // See Gourdon, X., and Sebah, P. The logarithmic constant: log 2, Jan. 2004.
   // Also http://www.mpfr.org/algorithms.pdf.
   //
   num = static_cast<ui_type>(1180509120uL);
   T denom, next_term, temp;
   denom        = static_cast<ui_type>(1277337600uL);
   next_term    = static_cast<ui_type>(120uL);
   si_type sign = -1;

   ui_type limit = digits / 3 + 1;

   for (ui_type n = 6; n < limit; ++n)
   {
      temp = static_cast<ui_type>(2);
      eval_multiply(temp, ui_type(2 * n));
      eval_multiply(temp, ui_type(2 * n + 1));
      eval_multiply(num, temp);
      eval_multiply(denom, temp);
      sign = -sign;
      eval_multiply(next_term, n);
      eval_multiply(temp, next_term, next_term);
      if (sign < 0)
         temp.negate();
      eval_add(num, temp);
   }
   eval_multiply(denom, ui_type(4));
   eval_multiply(num, ui_type(3));
   INSTRUMENT_BACKEND(denom);
   INSTRUMENT_BACKEND(num);
   eval_divide(num, denom);
   INSTRUMENT_BACKEND(num);
}

template <class T>
void calc_e(T& result, unsigned digits)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   //
   // 1100 digits in string form:
   //
   const char* string_val = "2."
                            "7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274"
                            "2746639193200305992181741359662904357290033429526059563073813232862794349076323382988075319525101901"
                            "1573834187930702154089149934884167509244761460668082264800168477411853742345442437107539077744992069"
                            "5517027618386062613313845830007520449338265602976067371132007093287091274437470472306969772093101416"
                            "9283681902551510865746377211125238978442505695369677078544996996794686445490598793163688923009879312"
                            "7736178215424999229576351482208269895193668033182528869398496465105820939239829488793320362509443117"
                            "3012381970684161403970198376793206832823764648042953118023287825098194558153017567173613320698112509"
                            "9618188159304169035159888851934580727386673858942287922849989208680582574927961048419844436346324496"
                            "8487560233624827041978623209002160990235304369941849146314093431738143640546253152096183690888707016"
                            "7683964243781405927145635490613031072085103837505101157477041718986106873969655212671546889570350354"
                            "0212340784981933432106817012100562788023519303322474501585390473041995777709350366041699732972508869";
   //
   // Check if we can just construct from string:
   //
   if (digits < 3640) // 3640 binary digits ~ 1100 decimal digits
   {
      result = string_val;
      return;
   }

   T lim;
   lim = ui_type(1);
   eval_ldexp(lim, lim, digits);

   //
   // Standard evaluation from the definition of e: http://functions.wolfram.com/Constants/E/02/
   //
   result = ui_type(2);
   T denom;
   denom     = ui_type(1);
   ui_type i = 2;
   do
   {
      eval_multiply(denom, i);
      eval_multiply(result, i);
      eval_add(result, ui_type(1));
      ++i;
   } while (denom.compare(lim) <= 0);
   eval_divide(result, denom);
}

template <class T>
void calc_pi(T& result, unsigned digits)
{
   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
   using real_type = typename std::tuple_element<0, typename T::float_types>::type   ;
   //
   // 1100 digits in string form:
   //
   const char* string_val = "3."
                            "1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
                            "8214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"
                            "4428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273"
                            "7245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094"
                            "3305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912"
                            "9833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132"
                            "0005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235"
                            "4201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859"
                            "5024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303"
                            "5982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989"
                            "3809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913152";
   //
   // Check if we can just construct from string:
   //
   if (digits < 3640) // 3640 binary digits ~ 1100 decimal digits
   {
      result = string_val;
      return;
   }

   T a;
   a = ui_type(1);
   T b;
   T A(a);
   T B;
   B = real_type(0.5f);
   T D;
   D = real_type(0.25f);

   T lim;
   lim = ui_type(1);
   eval_ldexp(lim, lim, -static_cast<int>(digits));

   //
   // This algorithm is from:
   // Schonhage, A., Grotefeld, A. F. W., and Vetter, E. Fast Algorithms: A Multitape Turing
   // Machine Implementation. BI Wissenschaftverlag, 1994.
   // Also described in MPFR's algorithm guide: http://www.mpfr.org/algorithms.pdf.
   //
   // Let:
   // a[0] = A[0] = 1
   // B[0] = 1/2
   // D[0] = 1/4
   // Then:
   // S[k+1] = (A[k]+B[k]) / 4
   // b[k] = sqrt(B[k])
   // a[k+1] = a[k]^2
   // B[k+1] = 2(A[k+1]-S[k+1])
   // D[k+1] = D[k] - 2^k(A[k+1]-B[k+1])
   // Stop when |A[k]-B[k]| <= 2^(k-p)
   // and PI = B[k]/D[k]

   unsigned k = 1;

   do
   {
      eval_add(result, A, B);
      eval_ldexp(result, result, -2);
      eval_sqrt(b, B);
      eval_add(a, b);
      eval_ldexp(a, a, -1);
      eval_multiply(A, a, a);
      eval_subtract(B, A, result);
      eval_ldexp(B, B, 1);
      eval_subtract(result, A, B);
      bool neg = eval_get_sign(result) < 0;
      if (neg)
         result.negate();
      if (result.compare(lim) <= 0)
         break;
      if (neg)
         result.negate();
      eval_ldexp(result, result, k - 1);
      eval_subtract(D, result);
      ++k;
      eval_ldexp(lim, lim, 1);
   } while (true);

   eval_divide(result, B, D);
}

template <class T>
const T& get_constant_ln2()
{
   static BOOST_MP_THREAD_LOCAL T    result;
   static BOOST_MP_THREAD_LOCAL long digits = 0;
   if ((digits != boost::multiprecision::detail::digits2<number<T> >::value()))
   {
      boost::multiprecision::detail::maybe_promote_precision(&result);
      calc_log2(result, boost::multiprecision::detail::digits2<number<T, et_on> >::value());
      digits = boost::multiprecision::detail::digits2<number<T> >::value();
   }

   return result;
}

template <class T>
const T& get_constant_e()
{
   static BOOST_MP_THREAD_LOCAL T    result;
   static BOOST_MP_THREAD_LOCAL long digits = 0;
   if ((digits != boost::multiprecision::detail::digits2<number<T> >::value()))
   {
      boost::multiprecision::detail::maybe_promote_precision(&result);
      calc_e(result, boost::multiprecision::detail::digits2<number<T, et_on> >::value());
      digits = boost::multiprecision::detail::digits2<number<T> >::value();
   }

   return result;
}

template <class T>
const T& get_constant_pi()
{
   static BOOST_MP_THREAD_LOCAL T             result;
   static BOOST_MP_THREAD_LOCAL long digits = 0;
   if ((digits != boost::multiprecision::detail::digits2<number<T> >::value()))
   {
      boost::multiprecision::detail::maybe_promote_precision(&result);
      calc_pi(result, boost::multiprecision::detail::digits2<number<T, et_on> >::value());
      digits = boost::multiprecision::detail::digits2<number<T> >::value();
   }

   return result;
}
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
template <class T>
const T& get_constant_one_over_epsilon()
{
   static BOOST_MP_THREAD_LOCAL T             result;
   static BOOST_MP_THREAD_LOCAL long digits = 0;
   if ((digits != boost::multiprecision::detail::digits2<number<T> >::value()))
   {
      using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;
      boost::multiprecision::detail::maybe_promote_precision(&result);
      result = static_cast<ui_type>(1u);
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T> >::is_specialized)
         eval_divide(result, std::numeric_limits<number<T> >::epsilon().backend());
      else
         eval_ldexp(result, result, boost::multiprecision::detail::digits2<number<T> >::value() - 1);
      digits = boost::multiprecision::detail::digits2<number<T> >::value();
   }

   return result;
}
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/functions/pow.hpp
================================================

// Copyright Christopher Kormanyos 2002 - 2013.
// Copyright 2011 - 2013 John Maddock.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
//
// This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp
//

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326) // comparison of two constants
#pragma warning(disable : 4127) // conditional expression is constant
#endif

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace detail {

template <typename T, typename U>
inline void pow_imp(T& result, const T& t, const U& p, const std::integral_constant<bool, false>&)
{
   // Compute the pure power of typename T t^p.
   // Use the S-and-X binary method, as described in
   // D. E. Knuth, "The Art of Computer Programming", Vol. 2,
   // Section 4.6.3 . The resulting computational complexity
   // is order log2[abs(p)].

   using int_type = typename boost::multiprecision::detail::canonical<U, T>::type;

   if (&result == &t)
   {
      T temp;
      pow_imp(temp, t, p, std::integral_constant<bool, false>());
      result = temp;
      return;
   }

   // This will store the result.
   if (U(p % U(2)) != U(0))
   {
      result = t;
   }
   else
      result = int_type(1);

   U p2(p);

   // The variable x stores the binary powers of t.
   T x(t);

   while (U(p2 /= 2) != U(0))
   {
      // Square x for each binary power.
      eval_multiply(x, x);

      const bool has_binary_power = (U(p2 % U(2)) != U(0));

      if (has_binary_power)
      {
         // Multiply the result with each binary power contained in the exponent.
         eval_multiply(result, x);
      }
   }
}

template <typename T, typename U>
inline void pow_imp(T& result, const T& t, const U& p, const std::integral_constant<bool, true>&)
{
   // Signed integer power, just take care of the sign then call the unsigned version:
   using int_type = typename boost::multiprecision::detail::canonical<U, T>::type;
   using ui_type = typename boost::multiprecision::detail::make_unsigned<U>::type                         ;

   if (p < 0)
   {
      T temp;
      temp = static_cast<int_type>(1);
      T denom;
      pow_imp(denom, t, static_cast<ui_type>(-p), std::integral_constant<bool, false>());
      eval_divide(result, temp, denom);
      return;
   }
   pow_imp(result, t, static_cast<ui_type>(p), std::integral_constant<bool, false>());
}

} // namespace detail

template <typename T, typename U>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<U>::value>::type eval_pow(T& result, const T& t, const U& p)
{
   detail::pow_imp(result, t, p, boost::multiprecision::detail::is_signed<U>());
}

template <class T>
void hyp0F0(T& H0F0, const T& x)
{
   // Compute the series representation of Hypergeometric0F0 taken from
   // http://functions.wolfram.com/HypergeometricFunctions/Hypergeometric0F0/06/01/
   // There are no checks on input range or parameter boundaries.

   using ui_type = typename std::tuple_element<0, typename T::unsigned_types>::type;

   BOOST_MP_ASSERT(&H0F0 != &x);
   long tol = boost::multiprecision::detail::digits2<number<T, et_on> >::value();
   T    t;

   T x_pow_n_div_n_fact(x);

   eval_add(H0F0, x_pow_n_div_n_fact, ui_type(1));

   T lim;
   eval_ldexp(lim, H0F0, 1 - tol);
   if (eval_get_sign(lim) < 0)
      lim.negate();

   ui_type n;

   const unsigned series_limit =
       boost::multiprecision::detail::digits2<number<T, et_on> >::value() < 100
           ? 100
           : boost::multiprecision::detail::digits2<number<T, et_on> >::value();
   // Series expansion of hyperg_0f0(; ; x).
   for (n = 2; n < series_limit; ++n)
   {
      eval_multiply(x_pow_n_div_n_fact, x);
      eval_divide(x_pow_n_div_n_fact, n);
      eval_add(H0F0, x_pow_n_div_n_fact);
      bool neg = eval_get_sign(x_pow_n_div_n_fact) < 0;
      if (neg)
         x_pow_n_div_n_fact.negate();
      if (lim.compare(x_pow_n_div_n_fact) > 0)
         break;
      if (neg)
         x_pow_n_div_n_fact.negate();
   }
   if (n >= series_limit)
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("H0F0 failed to converge"));
}

template <class T>
void hyp1F0(T& H1F0, const T& a, const T& x)
{
   // Compute the series representation of Hypergeometric1F0 taken from
   // http://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F0/06/01/01/
   // and also see the corresponding section for the power function (i.e. x^a).
   // There are no checks on input range or parameter boundaries.

   using si_type = typename boost::multiprecision::detail::canonical<int, T>::type;

   BOOST_MP_ASSERT(&H1F0 != &x);
   BOOST_MP_ASSERT(&H1F0 != &a);

   T x_pow_n_div_n_fact(x);
   T pochham_a(a);
   T ap(a);

   eval_multiply(H1F0, pochham_a, x_pow_n_div_n_fact);
   eval_add(H1F0, si_type(1));
   T lim;
   eval_ldexp(lim, H1F0, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());
   if (eval_get_sign(lim) < 0)
      lim.negate();

   si_type n;
   T       term, part;

   const si_type series_limit =
       boost::multiprecision::detail::digits2<number<T, et_on> >::value() < 100
           ? 100
           : boost::multiprecision::detail::digits2<number<T, et_on> >::value();
   // Series expansion of hyperg_1f0(a; ; x).
   for (n = 2; n < series_limit; n++)
   {
      eval_multiply(x_pow_n_div_n_fact, x);
      eval_divide(x_pow_n_div_n_fact, n);
      eval_increment(ap);
      eval_multiply(pochham_a, ap);
      eval_multiply(term, pochham_a, x_pow_n_div_n_fact);
      eval_add(H1F0, term);
      if (eval_get_sign(term) < 0)
         term.negate();
      if (lim.compare(term) >= 0)
         break;
   }
   if (n >= series_limit)
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("H1F0 failed to converge"));
}

template <class T>
void eval_exp(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The exp function is only valid for floating point types.");
   if (&x == &result)
   {
      T temp;
      eval_exp(temp, x);
      result = temp;
      return;
   }
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   using si_type = typename boost::multiprecision::detail::canonical<int, T>::type     ;
   using exp_type = typename T::exponent_type                                           ;
   using canonical_exp_type = typename boost::multiprecision::detail::canonical<exp_type, T>::type;

   // Handle special arguments.
   int  type  = eval_fpclassify(x);
   bool isneg = eval_get_sign(x) < 0;
   if (type == static_cast<int>(FP_NAN))
   {
      result = x;
      errno  = EDOM;
      return;
   }
   else if (type == static_cast<int>(FP_INFINITE))
   {
      if (isneg)
         result = ui_type(0u);
      else
         result = x;
      return;
   }
   else if (type == static_cast<int>(FP_ZERO))
   {
      result = ui_type(1);
      return;
   }

   // Get local copy of argument and force it to be positive.
   T xx = x;
   T exp_series;
   if (isneg)
      xx.negate();

   // Check the range of the argument.
   if (xx.compare(si_type(1)) <= 0)
   {
      //
      // Use series for exp(x) - 1:
      //
      T lim;
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::is_specialized)
         lim = std::numeric_limits<number<T, et_on> >::epsilon().backend();
      else
      {
         result = ui_type(1);
         eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());
      }
      unsigned k = 2;
      exp_series = xx;
      result     = si_type(1);
      if (isneg)
         eval_subtract(result, exp_series);
      else
         eval_add(result, exp_series);
      eval_multiply(exp_series, xx);
      eval_divide(exp_series, ui_type(k));
      eval_add(result, exp_series);
      while (exp_series.compare(lim) > 0)
      {
         ++k;
         eval_multiply(exp_series, xx);
         eval_divide(exp_series, ui_type(k));
         if (isneg && (k & 1))
            eval_subtract(result, exp_series);
         else
            eval_add(result, exp_series);
      }
      return;
   }

   // Check for pure-integer arguments which can be either signed or unsigned.
   typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type ll;
   eval_trunc(exp_series, x);
   eval_convert_to(&ll, exp_series);
   if (x.compare(ll) == 0)
   {
      detail::pow_imp(result, get_constant_e<T>(), ll, std::integral_constant<bool, true>());
      return;
   }
   else if (exp_series.compare(x) == 0)
   {
      // We have a value that has no fractional part, but is too large to fit
      // in a long long, in this situation the code below will fail, so
      // we're just going to assume that this will overflow:
      if (isneg)
         result = ui_type(0);
      else
         result = std::numeric_limits<number<T> >::has_infinity ? std::numeric_limits<number<T> >::infinity().backend() : (std::numeric_limits<number<T> >::max)().backend();
      return;
   }

   // The algorithm for exp has been taken from MPFUN.
   // exp(t) = [ (1 + r + r^2/2! + r^3/3! + r^4/4! ...)^p2 ] * 2^n
   // where p2 is a power of 2 such as 2048, r = t_prime / p2, and
   // t_prime = t - n*ln2, with n chosen to minimize the absolute
   // value of t_prime. In the resulting Taylor series, which is
   // implemented as a hypergeometric function, |r| is bounded by
   // ln2 / p2. For small arguments, no scaling is done.

   // Compute the exponential series of the (possibly) scaled argument.

   eval_divide(result, xx, get_constant_ln2<T>());
   exp_type n;
   eval_convert_to(&n, result);

   if (n == (std::numeric_limits<exp_type>::max)())
   {
      // Exponent is too large to fit in our exponent type:
      if (isneg)
         result = ui_type(0);
      else
         result = std::numeric_limits<number<T> >::has_infinity ? std::numeric_limits<number<T> >::infinity().backend() : (std::numeric_limits<number<T> >::max)().backend();
      return;
   }

   // The scaling is 2^11 = 2048.
   const si_type p2 = static_cast<si_type>(si_type(1) << 11);

   eval_multiply(exp_series, get_constant_ln2<T>(), static_cast<canonical_exp_type>(n));
   eval_subtract(exp_series, xx);
   eval_divide(exp_series, p2);
   exp_series.negate();
   hyp0F0(result, exp_series);

   detail::pow_imp(exp_series, result, p2, std::integral_constant<bool, true>());
   result = ui_type(1);
   eval_ldexp(result, result, n);
   eval_multiply(exp_series, result);

   if (isneg)
      eval_divide(result, ui_type(1), exp_series);
   else
      result = exp_series;
}

template <class T>
void eval_log(T& result, const T& arg)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The log function is only valid for floating point types.");
   //
   // We use a variation of http://dlmf.nist.gov/4.45#i
   // using frexp to reduce the argument to x * 2^n,
   // then let y = x - 1 and compute:
   // log(x) = log(2) * n + log1p(1 + y)
   //
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   using exp_type = typename T::exponent_type                                           ;
   using canonical_exp_type = typename boost::multiprecision::detail::canonical<exp_type, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type                  ;
   int                                                                          s = eval_signbit(arg);
   switch (eval_fpclassify(arg))
   {
   case FP_NAN:
      result = arg;
      errno  = EDOM;
      return;
   case FP_INFINITE:
      if (s)
         break;
      result = arg;
      return;
   case FP_ZERO:
      result = std::numeric_limits<number<T> >::has_infinity ? std::numeric_limits<number<T> >::infinity().backend() : (std::numeric_limits<number<T> >::max)().backend();
      result.negate();
      errno = ERANGE;
      return;
   }
   if (s)
   {
      result = std::numeric_limits<number<T> >::quiet_NaN().backend();
      errno  = EDOM;
      return;
   }

   exp_type e;
   T        t;
   eval_frexp(t, arg, &e);
   bool alternate = false;

   if (t.compare(fp_type(2) / fp_type(3)) <= 0)
   {
      alternate = true;
      eval_ldexp(t, t, 1);
      --e;
   }

   eval_multiply(result, get_constant_ln2<T>(), canonical_exp_type(e));
   INSTRUMENT_BACKEND(result);
   eval_subtract(t, ui_type(1)); /* -0.3 <= t <= 0.3 */
   if (!alternate)
      t.negate(); /* 0 <= t <= 0.33333 */
   T pow = t;
   T lim;
   T t2;

   if (alternate)
      eval_add(result, t);
   else
      eval_subtract(result, t);

   BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::is_specialized)
      eval_multiply(lim, result, std::numeric_limits<number<T, et_on> >::epsilon().backend());
   else
      eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());
   if (eval_get_sign(lim) < 0)
      lim.negate();
   INSTRUMENT_BACKEND(lim);

   ui_type k = 1;
   do
   {
      ++k;
      eval_multiply(pow, t);
      eval_divide(t2, pow, k);
      INSTRUMENT_BACKEND(t2);
      if (alternate && ((k & 1) != 0))
         eval_add(result, t2);
      else
         eval_subtract(result, t2);
      INSTRUMENT_BACKEND(result);
   } while (lim.compare(t2) < 0);
}

template <class T>
const T& get_constant_log10()
{
   static BOOST_MP_THREAD_LOCAL T             result;
   static BOOST_MP_THREAD_LOCAL long digits = 0;
   if ((digits != boost::multiprecision::detail::digits2<number<T> >::value()))
   {
      using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
      T                                                                            ten;
      ten = ui_type(10u);
      eval_log(result, ten);
      digits = boost::multiprecision::detail::digits2<number<T> >::value();
   }

   return result;
}

template <class T>
void eval_log10(T& result, const T& arg)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The log10 function is only valid for floating point types.");
   eval_log(result, arg);
   eval_divide(result, get_constant_log10<T>());
}

template <class R, class T>
inline void eval_log2(R& result, const T& a)
{
   eval_log(result, a);
   eval_divide(result, get_constant_ln2<R>());
}

template <typename T>
inline void eval_pow(T& result, const T& x, const T& a)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The pow function is only valid for floating point types.");
   using si_type = typename boost::multiprecision::detail::canonical<int, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type             ;

   if ((&result == &x) || (&result == &a))
   {
      T t;
      eval_pow(t, x, a);
      result = t;
      return;
   }

   if ((a.compare(si_type(1)) == 0) || (x.compare(si_type(1)) == 0))
   {
      result = x;
      return;
   }
   if (a.compare(si_type(0)) == 0)
   {
      result = si_type(1);
      return;
   }

   int type = eval_fpclassify(x);

   switch (type)
   {
   case FP_ZERO:
      switch (eval_fpclassify(a))
      {
      case FP_ZERO:
         result = si_type(1);
         break;
      case FP_NAN:
         result = a;
         break;
      case FP_NORMAL: {
         // Need to check for a an odd integer as a special case:
         BOOST_MP_TRY
         {
            typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type i;
            eval_convert_to(&i, a);
            if (a.compare(i) == 0)
            {
               if (eval_signbit(a))
               {
                  if (i & 1)
                  {
                     result = std::numeric_limits<number<T> >::infinity().backend();
                     if (eval_signbit(x))
                        result.negate();
                     errno = ERANGE;
                  }
                  else
                  {
                     result = std::numeric_limits<number<T> >::infinity().backend();
                     errno  = ERANGE;
                  }
               }
               else if (i & 1)
               {
                  result = x;
               }
               else
                  result = si_type(0);
               return;
            }
         }
         BOOST_MP_CATCH(const std::exception&)
         {
            // fallthrough..
         }
         BOOST_MP_CATCH_END
         BOOST_FALLTHROUGH;
      }
      default:
         if (eval_signbit(a))
         {
            result = std::numeric_limits<number<T> >::infinity().backend();
            errno  = ERANGE;
         }
         else
            result = x;
         break;
      }
      return;
   case FP_NAN:
      result = x;
      errno  = ERANGE;
      return;
   default:;
   }

   int s = eval_get_sign(a);
   if (s == 0)
   {
      result = si_type(1);
      return;
   }

   if (s < 0)
   {
      T t, da;
      t = a;
      t.negate();
      eval_pow(da, x, t);
      eval_divide(result, si_type(1), da);
      return;
   }

   typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type an;
   typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type max_an =
       std::numeric_limits<typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type>::is_specialized ? (std::numeric_limits<typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type>::max)() : static_cast<typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type>(1) << (sizeof(typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type) * CHAR_BIT - 2);
   typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type min_an =
       std::numeric_limits<typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type>::is_specialized ? (std::numeric_limits<typename boost::multiprecision::detail::canonical<std::intmax_t, T>::type>::min)() : -min_an;

   T fa;
   BOOST_MP_TRY
   {
      eval_convert_to(&an, a);
      if (a.compare(an) == 0)
      {
         detail::pow_imp(result, x, an, std::integral_constant<bool, true>());
         return;
      }
   }
   BOOST_MP_CATCH(const std::exception&)
   {
      // conversion failed, just fall through, value is not an integer.
      an = (std::numeric_limits<std::intmax_t>::max)();
   }
   BOOST_MP_CATCH_END
   if ((eval_get_sign(x) < 0))
   {
      typename boost::multiprecision::detail::canonical<std::uintmax_t, T>::type aun;
      BOOST_MP_TRY
      {
         eval_convert_to(&aun, a);
         if (a.compare(aun) == 0)
         {
            fa = x;
            fa.negate();
            eval_pow(result, fa, a);
            if (aun & 1u)
               result.negate();
            return;
         }
      }
      BOOST_MP_CATCH(const std::exception&)
      {
         // conversion failed, just fall through, value is not an integer.
      }
      BOOST_MP_CATCH_END

      eval_floor(result, a);
      // -1^INF is a special case in C99:
      if ((x.compare(si_type(-1)) == 0) && (eval_fpclassify(a) == FP_INFINITE))
      {
         result = si_type(1);
      }
      else if (a.compare(result) == 0)
      {
         // exponent is so large we have no fractional part:
         if (x.compare(si_type(-1)) < 0)
         {
            result = std::numeric_limits<number<T, et_on> >::infinity().backend();
         }
         else
         {
            result = si_type(0);
         }
      }
      else if (type == FP_INFINITE)
      {
         result = std::numeric_limits<number<T, et_on> >::infinity().backend();
      }
      else BOOST_IF_CONSTEXPR (std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
      {
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result of pow is undefined or non-real and there is no NaN for this number type."));
      }
      return;
   }

   T t, da;

   eval_subtract(da, a, an);

   if ((x.compare(fp_type(0.5)) >= 0) && (x.compare(fp_type(0.9)) < 0) && (an < max_an) && (an > min_an))
   {
      if (a.compare(fp_type(1e-5f)) <= 0)
      {
         // Series expansion for small a.
         eval_log(t, x);
         eval_multiply(t, a);
         hyp0F0(result, t);
         return;
      }
      else
      {
         // Series expansion for moderately sized x. Note that for large power of a,
         // the power of the integer part of a is calculated using the pown function.
         if (an)
         {
            da.negate();
            t = si_type(1);
            eval_subtract(t, x);
            hyp1F0(result, da, t);
            detail::pow_imp(t, x, an, std::integral_constant<bool, true>());
            eval_multiply(result, t);
         }
         else
         {
            da = a;
            da.negate();
            t = si_type(1);
            eval_subtract(t, x);
            hyp1F0(result, da, t);
         }
      }
   }
   else
   {
      // Series expansion for pow(x, a). Note that for large power of a, the power
      // of the integer part of a is calculated using the pown function.
      if (an)
      {
         eval_log(t, x);
         eval_multiply(t, da);
         eval_exp(result, t);
         detail::pow_imp(t, x, an, std::integral_constant<bool, true>());
         eval_multiply(result, t);
      }
      else
      {
         eval_log(t, x);
         eval_multiply(t, a);
         eval_exp(result, t);
      }
   }
}

template <class T, class A>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
inline typename std::enable_if<!boost::multiprecision::detail::is_integral<A>::value, void>::type
#else
inline typename std::enable_if<is_compatible_arithmetic_type<A, number<T> >::value && !boost::multiprecision::detail::is_integral<A>::value, void>::type
#endif
eval_pow(T& result, const T& x, const A& a)
{
   // Note this one is restricted to float arguments since pow.hpp already has a version for
   // integer powers....
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = a;
   eval_pow(result, x, c);
}

template <class T, class A>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
inline void
#else
inline typename std::enable_if<is_compatible_arithmetic_type<A, number<T> >::value, void>::type
#endif
eval_pow(T& result, const A& x, const T& a)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = x;
   eval_pow(result, c, a);
}

template <class T>
void eval_exp2(T& result, const T& arg)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The log function is only valid for floating point types.");

   // Check for pure-integer arguments which can be either signed or unsigned.
   typename boost::multiprecision::detail::canonical<typename T::exponent_type, T>::type i;
   T                                                                                     temp;
   BOOST_MP_TRY
   {
      eval_trunc(temp, arg);
      eval_convert_to(&i, temp);
      if (arg.compare(i) == 0)
      {
         temp = static_cast<typename std::tuple_element<0, typename T::unsigned_types>::type>(1u);
         eval_ldexp(result, temp, i);
         return;
      }
   }
   #ifdef BOOST_MP_MATH_AVAILABLE
   BOOST_MP_CATCH(const boost::math::rounding_error&)
   { /* Fallthrough */
   }
   #endif
   BOOST_MP_CATCH(const std::runtime_error&)
   { /* Fallthrough */
   }
   BOOST_MP_CATCH_END

   temp = static_cast<typename std::tuple_element<0, typename T::unsigned_types>::type>(2u);
   eval_pow(result, temp, arg);
}

namespace detail {

template <class T>
void small_sinh_series(T x, T& result)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   bool                                                                         neg = eval_get_sign(x) < 0;
   if (neg)
      x.negate();
   T p(x);
   T mult(x);
   eval_multiply(mult, x);
   result    = x;
   ui_type k = 1;

   T lim(x);
   eval_ldexp(lim, lim, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());

   do
   {
      eval_multiply(p, mult);
      eval_divide(p, ++k);
      eval_divide(p, ++k);
      eval_add(result, p);
   } while (p.compare(lim) >= 0);
   if (neg)
      result.negate();
}

template <class T>
void sinhcosh(const T& x, T* p_sinh, T* p_cosh)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type                  ;

   switch (eval_fpclassify(x))
   {
   case FP_NAN:
      errno = EDOM;
      // fallthrough...
   case FP_INFINITE:
      if (p_sinh)
         *p_sinh = x;
      if (p_cosh)
      {
         *p_cosh = x;
         if (eval_get_sign(x) < 0)
            p_cosh->negate();
      }
      return;
   case FP_ZERO:
      if (p_sinh)
         *p_sinh = x;
      if (p_cosh)
         *p_cosh = ui_type(1);
      return;
   default:;
   }

   bool small_sinh = eval_get_sign(x) < 0 ? x.compare(fp_type(-0.5)) > 0 : x.compare(fp_type(0.5)) < 0;

   if (p_cosh || !small_sinh)
   {
      T e_px, e_mx;
      eval_exp(e_px, x);
      eval_divide(e_mx, ui_type(1), e_px);
      if (eval_signbit(e_mx) != eval_signbit(e_px))
         e_mx.negate(); // Handles lack of signed zero in some types

      if (p_sinh)
      {
         if (small_sinh)
         {
            small_sinh_series(x, *p_sinh);
         }
         else
         {
            eval_subtract(*p_sinh, e_px, e_mx);
            eval_ldexp(*p_sinh, *p_sinh, -1);
         }
      }
      if (p_cosh)
      {
         eval_add(*p_cosh, e_px, e_mx);
         eval_ldexp(*p_cosh, *p_cosh, -1);
      }
   }
   else
   {
      small_sinh_series(x, *p_sinh);
   }
}

} // namespace detail

template <class T>
inline void eval_sinh(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The sinh function is only valid for floating point types.");
   detail::sinhcosh(x, &result, static_cast<T*>(0));
}

template <class T>
inline void eval_cosh(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The cosh function is only valid for floating point types.");
   detail::sinhcosh(x, static_cast<T*>(0), &result);
}

template <class T>
inline void eval_tanh(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The tanh function is only valid for floating point types.");
   T c;
   detail::sinhcosh(x, &result, &c);
   if ((eval_fpclassify(result) == FP_INFINITE) && (eval_fpclassify(c) == FP_INFINITE))
   {
      bool s = eval_signbit(result) != eval_signbit(c);
      result = static_cast<typename std::tuple_element<0, typename T::unsigned_types>::type>(1u);
      if (s)
         result.negate();
      return;
   }
   eval_divide(result, c);
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/functions/trig.hpp
================================================

// Copyright Christopher Kormanyos 2002 - 2011.
// Copyright 2011 John Maddock.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469
//
// This file has no include guards or namespaces - it's expanded inline inside default_ops.hpp
//

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326) // comparison of two constants
#pragma warning(disable : 4127) // conditional expression is constant
#endif

template <class T>
void hyp0F1(T& result, const T& b, const T& x)
{
   using si_type = typename boost::multiprecision::detail::canonical<std::int32_t, T>::type ;
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;

   // Compute the series representation of Hypergeometric0F1 taken from
   // http://functions.wolfram.com/HypergeometricFunctions/Hypergeometric0F1/06/01/01/
   // There are no checks on input range or parameter boundaries.

   T x_pow_n_div_n_fact(x);
   T pochham_b(b);
   T bp(b);

   eval_divide(result, x_pow_n_div_n_fact, pochham_b);
   eval_add(result, ui_type(1));

   si_type n;

   T tol;
   tol = ui_type(1);
   eval_ldexp(tol, tol, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());
   eval_multiply(tol, result);
   if (eval_get_sign(tol) < 0)
      tol.negate();
   T term;

   const int series_limit =
       boost::multiprecision::detail::digits2<number<T, et_on> >::value() < 100
           ? 100
           : boost::multiprecision::detail::digits2<number<T, et_on> >::value();
   // Series expansion of hyperg_0f1(; b; x).
   for (n = 2; n < series_limit; ++n)
   {
      eval_multiply(x_pow_n_div_n_fact, x);
      eval_divide(x_pow_n_div_n_fact, n);
      eval_increment(bp);
      eval_multiply(pochham_b, bp);

      eval_divide(term, x_pow_n_div_n_fact, pochham_b);
      eval_add(result, term);

      bool neg_term = eval_get_sign(term) < 0;
      if (neg_term)
         term.negate();
      if (term.compare(tol) <= 0)
         break;
   }

   if (n >= series_limit)
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("H0F1 Failed to Converge"));
}

template <class T, unsigned N, bool b = boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<T> >::value>
struct scoped_N_precision
{
   template <class U>
   scoped_N_precision(U const&) {}
   template <class U>
   void reduce(U&) {}
};

template <class T, unsigned N>
struct scoped_N_precision<T, N, true>
{
   unsigned old_precision, old_arg_precision;
   scoped_N_precision(T& arg)
   {
      old_precision     = T::thread_default_precision();
      old_arg_precision = arg.precision();
      T::thread_default_precision(old_arg_precision * N);
      arg.precision(old_arg_precision * N);
   }
   ~scoped_N_precision()
   {
      T::thread_default_precision(old_precision);
   }
   void reduce(T& arg) 
   {
      arg.precision(old_arg_precision);
   }
};

template <class T>
void reduce_n_half_pi(T& arg, const T& n, bool go_down)
{
   //
   // We need to perform argument reduction at 3 times the precision of arg
   // in order to ensure a correct result up to arg = 1/epsilon.  Beyond that
   // the value of n will have been incorrectly calculated anyway since it will
   // have a value greater than 1/epsilon and no longer be an exact integer value.
   //
   // More information in ARGUMENT REDUCTION FOR HUGE ARGUMENTS. K C Ng.
   //
   // There are two mutually exclusive ways to achieve this, both of which are 
   // supported here:
   // 1) To define a fixed precision type with 3 times the precision for the calculation.
   // 2) To dynamically increase the precision of the variables.
   //
   using reduction_type = typename boost::multiprecision::detail::transcendental_reduction_type<T>::type;
   //
   // Make a copy of the arg at higher precision:
   //
   reduction_type big_arg(arg);
   //
   // Dynamically increase precision when supported, this increases the default
   // and ups the precision of big_arg to match:
   //
   scoped_N_precision<T, 3> scoped_precision(big_arg);
   //
   // High precision PI:
   //
   reduction_type reduction = get_constant_pi<reduction_type>();
   eval_ldexp(reduction, reduction, -1); // divide by 2
   eval_multiply(reduction, n);

   BOOST_MATH_INSTRUMENT_CODE(big_arg.str(10, std::ios_base::scientific));
   BOOST_MATH_INSTRUMENT_CODE(reduction.str(10, std::ios_base::scientific));

   if (go_down)
      eval_subtract(big_arg, reduction, big_arg);
   else
      eval_subtract(big_arg, reduction);
   arg = T(big_arg);
   //
   // If arg is a variable precision type, then we have just copied the
   // precision of big_arg s well it's value.  Reduce the precision now:
   //
   scoped_precision.reduce(arg);
   BOOST_MATH_INSTRUMENT_CODE(big_arg.str(10, std::ios_base::scientific));
   BOOST_MATH_INSTRUMENT_CODE(arg.str(10, std::ios_base::scientific));
}

template <class T>
void eval_sin(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The sin function is only valid for floating point types.");
   BOOST_MATH_INSTRUMENT_CODE(x.str(0, std::ios_base::scientific));
   if (&result == &x)
   {
      T temp;
      eval_sin(temp, x);
      result = temp;
      return;
   }

   using si_type = typename boost::multiprecision::detail::canonical<std::int32_t, T>::type ;
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type                         ;

   switch (eval_fpclassify(x))
   {
   case FP_INFINITE:
   case FP_NAN:
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   case FP_ZERO:
      result = x;
      return;
   default:;
   }

   // Local copy of the argument
   T xx = x;

   // Analyze and prepare the phase of the argument.
   // Make a local, positive copy of the argument, xx.
   // The argument xx will be reduced to 0 <= xx <= pi/2.
   bool b_negate_sin = false;

   if (eval_get_sign(x) < 0)
   {
      xx.negate();
      b_negate_sin = !b_negate_sin;
   }

   T n_pi, t;
   T half_pi = get_constant_pi<T>();
   eval_ldexp(half_pi, half_pi, -1); // divide by 2
   // Remove multiples of pi/2.
   if (xx.compare(half_pi) > 0)
   {
      eval_divide(n_pi, xx, half_pi);
      eval_trunc(n_pi, n_pi);
      t = ui_type(4);
      eval_fmod(t, n_pi, t);
      bool b_go_down = false;
      if (t.compare(ui_type(1)) == 0)
      {
         b_go_down = true;
      }
      else if (t.compare(ui_type(2)) == 0)
      {
         b_negate_sin = !b_negate_sin;
      }
      else if (t.compare(ui_type(3)) == 0)
      {
         b_negate_sin = !b_negate_sin;
         b_go_down    = true;
      }

      if (b_go_down)
         eval_increment(n_pi);
      //
      // If n_pi is > 1/epsilon, then it is no longer an exact integer value
      // but an approximation.  As a result we can no longer reliably reduce
      // xx to 0 <= xx < pi/2, nor can we tell the sign of the result as we need
      // n_pi % 4 for that, but that will always be zero in this situation.
      // We could use a higher precision type for n_pi, along with division at
      // higher precision, but that's rather expensive.  So for now we do not support
      // this, and will see if anyone complains and has a legitimate use case.
      //
      if (n_pi.compare(get_constant_one_over_epsilon<T>()) > 0)
      {
         result = ui_type(0);
         return;
      }

      reduce_n_half_pi(xx, n_pi, b_go_down);
      //
      // Post reduction we may be a few ulp below zero or above pi/2
      // given that n_pi was calculated at working precision and not
      // at the higher precision used for reduction.  Correct that now:
      //
      if (eval_get_sign(xx) < 0)
      {
         xx.negate();
         b_negate_sin = !b_negate_sin;
      }
      if (xx.compare(half_pi) > 0)
      {
         eval_ldexp(half_pi, half_pi, 1);
         eval_subtract(xx, half_pi, xx);
         eval_ldexp(half_pi, half_pi, -1);
         b_go_down = !b_go_down;
      }

      BOOST_MATH_INSTRUMENT_CODE(xx.str(0, std::ios_base::scientific));
      BOOST_MATH_INSTRUMENT_CODE(n_pi.str(0, std::ios_base::scientific));
      BOOST_MP_ASSERT(xx.compare(half_pi) <= 0);
      BOOST_MP_ASSERT(xx.compare(ui_type(0)) >= 0);
   }

   t = half_pi;
   eval_subtract(t, xx);

   const bool b_zero    = eval_get_sign(xx) == 0;
   const bool b_pi_half = eval_get_sign(t) == 0;

   BOOST_MATH_INSTRUMENT_CODE(xx.str(0, std::ios_base::scientific));
   BOOST_MATH_INSTRUMENT_CODE(t.str(0, std::ios_base::scientific));

   // Check if the reduced argument is very close to 0 or pi/2.
   const bool b_near_zero    = xx.compare(fp_type(1e-1)) < 0;
   const bool b_near_pi_half = t.compare(fp_type(1e-1)) < 0;

   if (b_zero)
   {
      result = ui_type(0);
   }
   else if (b_pi_half)
   {
      result = ui_type(1);
   }
   else if (b_near_zero)
   {
      eval_multiply(t, xx, xx);
      eval_divide(t, si_type(-4));
      T t2;
      t2 = fp_type(1.5);
      hyp0F1(result, t2, t);
      BOOST_MATH_INSTRUMENT_CODE(result.str(0, std::ios_base::scientific));
      eval_multiply(result, xx);
   }
   else if (b_near_pi_half)
   {
      eval_multiply(t, t);
      eval_divide(t, si_type(-4));
      T t2;
      t2 = fp_type(0.5);
      hyp0F1(result, t2, t);
      BOOST_MATH_INSTRUMENT_CODE(result.str(0, std::ios_base::scientific));
   }
   else
   {
      // Scale to a small argument for an efficient Taylor series,
      // implemented as a hypergeometric function. Use a standard
      // divide by three identity a certain number of times.
      // Here we use division by 3^9 --> (19683 = 3^9).

      constexpr si_type n_scale           = 9;
      constexpr si_type n_three_pow_scale = static_cast<si_type>(19683L);

      eval_divide(xx, n_three_pow_scale);

      // Now with small arguments, we are ready for a series expansion.
      eval_multiply(t, xx, xx);
      eval_divide(t, si_type(-4));
      T t2;
      t2 = fp_type(1.5);
      hyp0F1(result, t2, t);
      BOOST_MATH_INSTRUMENT_CODE(result.str(0, std::ios_base::scientific));
      eval_multiply(result, xx);

      // Convert back using multiple angle identity.
      for (std::int32_t k = static_cast<std::int32_t>(0); k < n_scale; k++)
      {
         // Rescale the cosine value using the multiple angle identity.
         eval_multiply(t2, result, ui_type(3));
         eval_multiply(t, result, result);
         eval_multiply(t, result);
         eval_multiply(t, ui_type(4));
         eval_subtract(result, t2, t);
      }
   }

   if (b_negate_sin)
      result.negate();
   BOOST_MATH_INSTRUMENT_CODE(result.str(0, std::ios_base::scientific));
}

template <class T>
void eval_cos(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The cos function is only valid for floating point types.");
   if (&result == &x)
   {
      T temp;
      eval_cos(temp, x);
      result = temp;
      return;
   }

   using si_type = typename boost::multiprecision::detail::canonical<std::int32_t, T>::type ;
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;

   switch (eval_fpclassify(x))
   {
   case FP_INFINITE:
   case FP_NAN:
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   case FP_ZERO:
      result = ui_type(1);
      return;
   default:;
   }

   // Local copy of the argument
   T xx = x;

   // Analyze and prepare the phase of the argument.
   // Make a local, positive copy of the argument, xx.
   // The argument xx will be reduced to 0 <= xx <= pi/2.
   bool b_negate_cos = false;

   if (eval_get_sign(x) < 0)
   {
      xx.negate();
   }
   BOOST_MATH_INSTRUMENT_CODE(xx.str(0, std::ios_base::scientific));

   T n_pi, t;
   T half_pi = get_constant_pi<T>();
   eval_ldexp(half_pi, half_pi, -1); // divide by 2
   // Remove even multiples of pi.
   if (xx.compare(half_pi) > 0)
   {
      eval_divide(t, xx, half_pi);
      eval_trunc(n_pi, t);
      //
      // If n_pi is > 1/epsilon, then it is no longer an exact integer value
      // but an approximation.  As a result we can no longer reliably reduce
      // xx to 0 <= xx < pi/2, nor can we tell the sign of the result as we need
      // n_pi % 4 for that, but that will always be zero in this situation.
      // We could use a higher precision type for n_pi, along with division at
      // higher precision, but that's rather expensive.  So for now we do not support
      // this, and will see if anyone complains and has a legitimate use case.
      //
      if (n_pi.compare(get_constant_one_over_epsilon<T>()) > 0)
      {
         result = ui_type(1);
         return;
      }
      BOOST_MATH_INSTRUMENT_CODE(n_pi.str(0, std::ios_base::scientific));
      t = ui_type(4);
      eval_fmod(t, n_pi, t);

      bool b_go_down = false;
      if (t.compare(ui_type(0)) == 0)
      {
         b_go_down = true;
      }
      else if (t.compare(ui_type(1)) == 0)
      {
         b_negate_cos = true;
      }
      else if (t.compare(ui_type(2)) == 0)
      {
         b_go_down    = true;
         b_negate_cos = true;
      }
      else
      {
         BOOST_MP_ASSERT(t.compare(ui_type(3)) == 0);
      }

      if (b_go_down)
         eval_increment(n_pi);

      reduce_n_half_pi(xx, n_pi, b_go_down);
      //
      // Post reduction we may be a few ulp below zero or above pi/2
      // given that n_pi was calculated at working precision and not
      // at the higher precision used for reduction.  Correct that now:
      //
      if (eval_get_sign(xx) < 0)
      {
         xx.negate();
         b_negate_cos = !b_negate_cos;
      }
      if (xx.compare(half_pi) > 0)
      {
         eval_ldexp(half_pi, half_pi, 1);
         eval_subtract(xx, half_pi, xx);
         eval_ldexp(half_pi, half_pi, -1);
      }
      BOOST_MP_ASSERT(xx.compare(half_pi) <= 0);
      BOOST_MP_ASSERT(xx.compare(ui_type(0)) >= 0);
   }
   else
   {
      n_pi = ui_type(1);
      reduce_n_half_pi(xx, n_pi, true);
   }

   const bool b_zero = eval_get_sign(xx) == 0;

   if (b_zero)
   {
      result = si_type(0);
   }
   else
   {
      eval_sin(result, xx);
   }
   if (b_negate_cos)
      result.negate();
   BOOST_MATH_INSTRUMENT_CODE(result.str(0, std::ios_base::scientific));
}

template <class T>
void eval_tan(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The tan function is only valid for floating point types.");
   if (&result == &x)
   {
      T temp;
      eval_tan(temp, x);
      result = temp;
      return;
   }
   T t;
   eval_sin(result, x);
   eval_cos(t, x);
   eval_divide(result, t);
}

template <class T>
void hyp2F1(T& result, const T& a, const T& b, const T& c, const T& x)
{
   // Compute the series representation of hyperg_2f1 taken from
   // Abramowitz and Stegun 15.1.1.
   // There are no checks on input range or parameter boundaries.

   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;

   T x_pow_n_div_n_fact(x);
   T pochham_a(a);
   T pochham_b(b);
   T pochham_c(c);
   T ap(a);
   T bp(b);
   T cp(c);

   eval_multiply(result, pochham_a, pochham_b);
   eval_divide(result, pochham_c);
   eval_multiply(result, x_pow_n_div_n_fact);
   eval_add(result, ui_type(1));

   T lim;
   eval_ldexp(lim, result, 1 - boost::multiprecision::detail::digits2<number<T, et_on> >::value());

   if (eval_get_sign(lim) < 0)
      lim.negate();

   ui_type n;
   T       term;

   const unsigned series_limit =
       boost::multiprecision::detail::digits2<number<T, et_on> >::value() < 100
           ? 100
           : boost::multiprecision::detail::digits2<number<T, et_on> >::value();
   // Series expansion of hyperg_2f1(a, b; c; x).
   for (n = 2; n < series_limit; ++n)
   {
      eval_multiply(x_pow_n_div_n_fact, x);
      eval_divide(x_pow_n_div_n_fact, n);

      eval_increment(ap);
      eval_multiply(pochham_a, ap);
      eval_increment(bp);
      eval_multiply(pochham_b, bp);
      eval_increment(cp);
      eval_multiply(pochham_c, cp);

      eval_multiply(term, pochham_a, pochham_b);
      eval_divide(term, pochham_c);
      eval_multiply(term, x_pow_n_div_n_fact);
      eval_add(result, term);

      if (eval_get_sign(term) < 0)
         term.negate();
      if (lim.compare(term) >= 0)
         break;
   }
   if (n > series_limit)
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("H2F1 failed to converge."));
}

template <class T>
void eval_asin(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The asin function is only valid for floating point types.");
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type                         ;

   if (&result == &x)
   {
      T t(x);
      eval_asin(result, t);
      return;
   }

   switch (eval_fpclassify(x))
   {
   case FP_NAN:
   case FP_INFINITE:
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   case FP_ZERO:
      result = x;
      return;
   default:;
   }

   const bool b_neg = eval_get_sign(x) < 0;

   T xx(x);
   if (b_neg)
      xx.negate();

   int c = xx.compare(ui_type(1));
   if (c > 0)
   {
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   }
   else if (c == 0)
   {
      result = get_constant_pi<T>();
      eval_ldexp(result, result, -1);
      if (b_neg)
         result.negate();
      return;
   }

   if (xx.compare(fp_type(1e-3)) < 0)
   {
      // http://functions.wolfram.com/ElementaryFunctions/ArcSin/26/01/01/
      eval_multiply(xx, xx);
      T t1, t2;
      t1 = fp_type(0.5f);
      t2 = fp_type(1.5f);
      hyp2F1(result, t1, t1, t2, xx);
      eval_multiply(result, x);
      return;
   }
   else if (xx.compare(fp_type(1 - 5e-2f)) > 0)
   {
      // http://functions.wolfram.com/ElementaryFunctions/ArcSin/26/01/01/
      // This branch is simlilar in complexity to Newton iterations down to
      // the above limit.  It is *much* more accurate.
      T dx1;
      T t1, t2;
      eval_subtract(dx1, ui_type(1), xx);
      t1 = fp_type(0.5f);
      t2 = fp_type(1.5f);
      eval_ldexp(dx1, dx1, -1);
      hyp2F1(result, t1, t1, t2, dx1);
      eval_ldexp(dx1, dx1, 2);
      eval_sqrt(t1, dx1);
      eval_multiply(result, t1);
      eval_ldexp(t1, get_constant_pi<T>(), -1);
      result.negate();
      eval_add(result, t1);
      if (b_neg)
         result.negate();
      return;
   }
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
   using guess_type = typename boost::multiprecision::detail::canonical<long double, T>::type;
#else
   using guess_type = fp_type;
#endif
   // Get initial estimate using standard math function asin.
   guess_type dd;
   eval_convert_to(&dd, xx);

   result = (guess_type)(std::asin(dd));

   // Newton-Raphson iteration, we should double our precision with each iteration,
   // in practice this seems to not quite work in all cases... so terminate when we
   // have at least 2/3 of the digits correct on the assumption that the correction
   // we've just added will finish the job...

   std::intmax_t current_precision = eval_ilogb(result);
   std::intmax_t target_precision  = std::numeric_limits<number<T> >::is_specialized ? 
      current_precision - 1 - (std::numeric_limits<number<T> >::digits * 2) / 3
      : current_precision - 1 - (boost::multiprecision::detail::digits2<number<T> >::value() * 2) / 3;

   // Newton-Raphson iteration
   while (current_precision > target_precision)
   {
      T sine, cosine;
      eval_sin(sine, result);
      eval_cos(cosine, result);
      eval_subtract(sine, xx);
      eval_divide(sine, cosine);
      eval_subtract(result, sine);
      current_precision = eval_ilogb(sine);
      if (current_precision <= (std::numeric_limits<typename T::exponent_type>::min)() + 1)
         break;
   }
   if (b_neg)
      result.negate();
}

template <class T>
inline void eval_acos(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The acos function is only valid for floating point types.");
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;

   switch (eval_fpclassify(x))
   {
   case FP_NAN:
   case FP_INFINITE:
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   case FP_ZERO:
      result = get_constant_pi<T>();
      eval_ldexp(result, result, -1); // divide by two.
      return;
   }

   T xx;
   eval_abs(xx, x);
   int c = xx.compare(ui_type(1));

   if (c > 0)
   {
      BOOST_IF_CONSTEXPR(std::numeric_limits<number<T, et_on> >::has_quiet_NaN)
      {
         result = std::numeric_limits<number<T, et_on> >::quiet_NaN().backend();
         errno  = EDOM;
      }
      else
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Result is undefined or complex and there is no NaN for this number type."));
      return;
   }
   else if (c == 0)
   {
      if (eval_get_sign(x) < 0)
         result = get_constant_pi<T>();
      else
         result = ui_type(0);
      return;
   }

   using fp_type = typename std::tuple_element<0, typename T::float_types>::type;

   if (xx.compare(fp_type(1e-3)) < 0)
   {
      // https://functions.wolfram.com/ElementaryFunctions/ArcCos/26/01/01/
      eval_multiply(xx, xx);
      T t1, t2;
      t1 = fp_type(0.5f);
      t2 = fp_type(1.5f);
      hyp2F1(result, t1, t1, t2, xx);
      eval_multiply(result, x);
      eval_ldexp(t1, get_constant_pi<T>(), -1);
      result.negate();
      eval_add(result, t1);
      return;
   }
   if (eval_get_sign(x) < 0)
   {
      eval_acos(result, xx);
      result.negate();
      eval_add(result, get_constant_pi<T>());
      return;
   }
   else if (xx.compare(fp_type(0.85)) > 0)
   {
      // https://functions.wolfram.com/ElementaryFunctions/ArcCos/26/01/01/
      // This branch is simlilar in complexity to Newton iterations down to
      // the above limit.  It is *much* more accurate.
      T dx1;
      T t1, t2;
      eval_subtract(dx1, ui_type(1), xx);
      t1 = fp_type(0.5f);
      t2 = fp_type(1.5f);
      eval_ldexp(dx1, dx1, -1);
      hyp2F1(result, t1, t1, t2, dx1);
      eval_ldexp(dx1, dx1, 2);
      eval_sqrt(t1, dx1);
      eval_multiply(result, t1);
      return;
   }

#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
   using guess_type = typename boost::multiprecision::detail::canonical<long double, T>::type;
#else
   using guess_type = fp_type;
#endif
   // Get initial estimate using standard math function asin.
   guess_type dd;
   eval_convert_to(&dd, xx);

   result = (guess_type)(std::acos(dd));

   // Newton-Raphson iteration, we should double our precision with each iteration,
   // in practice this seems to not quite work in all cases... so terminate when we
   // have at least 2/3 of the digits correct on the assumption that the correction
   // we've just added will finish the job...

   std::intmax_t current_precision = eval_ilogb(result);
   std::intmax_t target_precision = std::numeric_limits<number<T> >::is_specialized ?
      current_precision - 1 - (std::numeric_limits<number<T> >::digits * 2) / 3
      : current_precision - 1 - (boost::multiprecision::detail::digits2<number<T> >::value() * 2) / 3;

   // Newton-Raphson iteration
   while (current_precision > target_precision)
   {
      T sine, cosine;
      eval_sin(sine, result);
      eval_cos(cosine, result);
      eval_subtract(cosine, xx);
      cosine.negate();
      eval_divide(cosine, sine);
      eval_subtract(result, cosine);
      current_precision = eval_ilogb(cosine);
      if (current_precision <= (std::numeric_limits<typename T::exponent_type>::min)() + 1)
         break;
   }
}

template <class T>
void eval_atan(T& result, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The atan function is only valid for floating point types.");
   using si_type = typename boost::multiprecision::detail::canonical<std::int32_t, T>::type ;
   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;
   using fp_type = typename std::tuple_element<0, typename T::float_types>::type                         ;

   switch (eval_fpclassify(x))
   {
   case FP_NAN:
      result = x;
      errno  = EDOM;
      return;
   case FP_ZERO:
      result = x;
      return;
   case FP_INFINITE:
      if (eval_get_sign(x) < 0)
      {
         eval_ldexp(result, get_constant_pi<T>(), -1);
         result.negate();
      }
      else
         eval_ldexp(result, get_constant_pi<T>(), -1);
      return;
   default:;
   }

   const bool b_neg = eval_get_sign(x) < 0;

   T xx(x);
   if (b_neg)
      xx.negate();

   if (xx.compare(fp_type(0.1)) < 0)
   {
      T t1, t2, t3;
      t1 = ui_type(1);
      t2 = fp_type(0.5f);
      t3 = fp_type(1.5f);
      eval_multiply(xx, xx);
      xx.negate();
      hyp2F1(result, t1, t2, t3, xx);
      eval_multiply(result, x);
      return;
   }

   if (xx.compare(fp_type(10)) > 0)
   {
      T t1, t2, t3;
      t1 = fp_type(0.5f);
      t2 = ui_type(1u);
      t3 = fp_type(1.5f);
      eval_multiply(xx, xx);
      eval_divide(xx, si_type(-1), xx);
      hyp2F1(result, t1, t2, t3, xx);
      eval_divide(result, x);
      if (!b_neg)
         result.negate();
      eval_ldexp(t1, get_constant_pi<T>(), -1);
      eval_add(result, t1);
      if (b_neg)
         result.negate();
      return;
   }

   // Get initial estimate using standard math function atan.
   fp_type d;
   eval_convert_to(&d, xx);
   result = fp_type(std::atan(d));

   // Newton-Raphson iteration, we should double our precision with each iteration,
   // in practice this seems to not quite work in all cases... so terminate when we
   // have at least 2/3 of the digits correct on the assumption that the correction
   // we've just added will finish the job...

   std::intmax_t current_precision = eval_ilogb(result);
   std::intmax_t target_precision  = std::numeric_limits<number<T> >::is_specialized ?
      current_precision - 1 - (std::numeric_limits<number<T> >::digits * 2) / 3
      : current_precision - 1 - (boost::multiprecision::detail::digits2<number<T> >::value() * 2) / 3;

   T s, c, t;
   while (current_precision > target_precision)
   {
      eval_sin(s, result);
      eval_cos(c, result);
      eval_multiply(t, xx, c);
      eval_subtract(t, s);
      eval_multiply(s, t, c);
      eval_add(result, s);
      current_precision = eval_ilogb(s);
      if (current_precision <= (std::numeric_limits<typename T::exponent_type>::min)() + 1)
         break;
   }
   if (b_neg)
      result.negate();
}

template <class T>
void eval_atan2(T& result, const T& y, const T& x)
{
   static_assert(number_category<T>::value == number_kind_floating_point, "The atan2 function is only valid for floating point types.");
   if (&result == &y)
   {
      T temp(y);
      eval_atan2(result, temp, x);
      return;
   }
   else if (&result == &x)
   {
      T temp(x);
      eval_atan2(result, y, temp);
      return;
   }

   using ui_type = typename boost::multiprecision::detail::canonical<std::uint32_t, T>::type;

   switch (eval_fpclassify(y))
   {
   case FP_NAN:
      result = y;
      errno  = EDOM;
      return;
   case FP_ZERO:
   {
      if (eval_signbit(x))
      {
         result = get_constant_pi<T>();
         if (eval_signbit(y))
            result.negate();
      }
      else
      {
         result = y; // Note we allow atan2(0,0) to be +-zero, even though it's mathematically undefined
      }
      return;
   }
   case FP_INFINITE:
   {
      if (eval_fpclassify(x) == FP_INFINITE)
      {
         if (eval_signbit(x))
         {
            // 3Pi/4
            eval_ldexp(result, get_constant_pi<T>(), -2);
            eval_subtract(result, get_constant_pi<T>());
            if (eval_get_sign(y) >= 0)
               result.negate();
         }
         else
         {
            // Pi/4
            eval_ldexp(result, get_constant_pi<T>(), -2);
            if (eval_get_sign(y) < 0)
               result.negate();
         }
      }
      else
      {
         eval_ldexp(result, get_constant_pi<T>(), -1);
         if (eval_get_sign(y) < 0)
            result.negate();
      }
      return;
   }
   }

   switch (eval_fpclassify(x))
   {
   case FP_NAN:
      result = x;
      errno  = EDOM;
      return;
   case FP_ZERO:
   {
      eval_ldexp(result, get_constant_pi<T>(), -1);
      if (eval_get_sign(y) < 0)
         result.negate();
      return;
   }
   case FP_INFINITE:
      if (eval_get_sign(x) > 0)
         result = ui_type(0);
      else
         result = get_constant_pi<T>();
      if (eval_get_sign(y) < 0)
         result.negate();
      return;
   }

   T xx;
   eval_divide(xx, y, x);
   if (eval_get_sign(xx) < 0)
      xx.negate();

   eval_atan(result, xx);

   // Determine quadrant (sign) based on signs of x, y
   const bool y_neg = eval_get_sign(y) < 0;
   const bool x_neg = eval_get_sign(x) < 0;

   if (y_neg != x_neg)
      result.negate();

   if (x_neg)
   {
      if (y_neg)
         eval_subtract(result, get_constant_pi<T>());
      else
         eval_add(result, get_constant_pi<T>());
   }
}
template <class T, class A>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_atan2(T& result, const T& x, const A& a)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = a;
   eval_atan2(result, x, c);
}

template <class T, class A>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, void>::type eval_atan2(T& result, const A& x, const T& a)
{
   using canonical_type = typename boost::multiprecision::detail::canonical<A, T>::type         ;
   using cast_type = typename std::conditional<std::is_same<A, canonical_type>::value, T, canonical_type>::type;
   cast_type                                                                      c;
   c = x;
   eval_atan2(result, c, a);
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/functions/trunc.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2022 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_FUNCTIONS_TRUNC_HPP
#define BOOST_MP_DETAIL_FUNCTIONS_TRUNC_HPP

#include <cmath>
#include <limits>
#include <stdexcept>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/trunc.hpp>
#endif

namespace boost { namespace multiprecision { namespace detail {

namespace impl {

template <typename T>
inline T trunc BOOST_PREVENT_MACRO_SUBSTITUTION (const T arg)
{
    using std::floor;
    using std::ceil;

    return (arg > 0) ? floor(arg) : ceil(arg);
}

} // namespace impl

#ifdef BOOST_MP_MATH_AVAILABLE

template <typename T>
inline long long lltrunc BOOST_PREVENT_MACRO_SUBSTITUTION (const T arg)
{
    return boost::math::lltrunc(arg);
}

template <typename T>
inline int itrunc BOOST_PREVENT_MACRO_SUBSTITUTION (const T arg)
{
    return boost::math::itrunc(arg);
}

#else

template <typename T>
inline long long lltrunc BOOST_PREVENT_MACRO_SUBSTITUTION (const T arg)
{
    if (arg > LLONG_MAX)
    {
        BOOST_MP_THROW_EXCEPTION(std::domain_error("arg cannot be converted into a long long"));
    }

    return static_cast<long long>(boost::multiprecision::detail::impl::trunc(arg));
}

template <typename T>
inline int itrunc BOOST_PREVENT_MACRO_SUBSTITUTION (const T arg)
{
    if (arg > static_cast<T>(INT_MAX))
    {
        BOOST_MP_THROW_EXCEPTION(std::domain_error("arg cannot be converted into an int"));
    }

    return static_cast<int>(boost::multiprecision::detail::impl::trunc(arg));
}

#endif

}}} // Namespaces

#endif // BOOST_MP_DETAIL_FUNCTIONS_TRUNC_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/generic_interconvert.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_GENERIC_INTERCONVERT_HPP
#define BOOST_MP_GENERIC_INTERCONVERT_HPP

#include <cmath>
#include <limits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/default_ops.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/functions/trunc.hpp>

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127 6326)
#endif

namespace boost { namespace multiprecision { namespace detail {

template <class To, class From>
inline To do_cast(const From& from)
{
   return static_cast<To>(from);
}
template <class To, class B, ::boost::multiprecision::expression_template_option et>
inline To do_cast(const number<B, et>& from)
{
   return from.template convert_to<To>();
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/)
{
   using default_ops::eval_add;
   using default_ops::eval_bitwise_and;
   using default_ops::eval_convert_to;
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_ldexp;
   using default_ops::eval_right_shift;
   // smallest unsigned type handled natively by "From" is likely to be it's limb_type:
   using l_limb_type = typename canonical<unsigned char, From>::type;
   // get the corresponding type that we can assign to "To":
   using to_type = typename canonical<l_limb_type, To>::type;
   From                                              t(from);
   bool                                              is_neg = eval_get_sign(t) < 0;
   if (is_neg)
      t.negate();
   // Pick off the first limb:
   l_limb_type limb;
   l_limb_type mask = static_cast<l_limb_type>(~static_cast<l_limb_type>(0));
   From        fl;
   eval_bitwise_and(fl, t, mask);
   eval_convert_to(&limb, fl);
   to = static_cast<to_type>(limb);
   eval_right_shift(t, std::numeric_limits<l_limb_type>::digits);
   //
   // Then keep picking off more limbs until "t" is zero:
   //
   To       l;
   unsigned shift = std::numeric_limits<l_limb_type>::digits;
   while (!eval_is_zero(t))
   {
      eval_bitwise_and(fl, t, mask);
      eval_convert_to(&limb, fl);
      l = static_cast<to_type>(limb);
      eval_right_shift(t, std::numeric_limits<l_limb_type>::digits);
      eval_ldexp(l, l, shift);
      eval_add(to, l);
      shift += std::numeric_limits<l_limb_type>::digits;
   }
   //
   // Finish off by setting the sign:
   //
   if (is_neg)
      to.negate();
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_integer>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/)
{
   using default_ops::eval_bitwise_and;
   using default_ops::eval_bitwise_or;
   using default_ops::eval_convert_to;
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_left_shift;
   using default_ops::eval_right_shift;
   // smallest unsigned type handled natively by "From" is likely to be it's limb_type:
   using limb_type = typename canonical<unsigned char, From>::type;
   // get the corresponding type that we can assign to "To":
   using to_type = typename canonical<limb_type, To>::type;
   From                                            t(from);
   bool                                            is_neg = eval_get_sign(t) < 0;
   if (is_neg)
      t.negate();
   // Pick off the first limb:
   limb_type limb;
   limb_type mask = static_cast<limb_type>(~static_cast<limb_type>(0));
   From      fl;
   eval_bitwise_and(fl, t, mask);
   eval_convert_to(&limb, fl);
   to = static_cast<to_type>(limb);
   eval_right_shift(t, std::numeric_limits<limb_type>::digits);
   //
   // Then keep picking off more limbs until "t" is zero:
   //
   To       l;
   unsigned shift = std::numeric_limits<limb_type>::digits;
   while (!eval_is_zero(t))
   {
      eval_bitwise_and(fl, t, mask);
      eval_convert_to(&limb, fl);
      l = static_cast<to_type>(limb);
      eval_right_shift(t, std::numeric_limits<limb_type>::digits);
      eval_left_shift(l, shift);
      eval_bitwise_or(to, l);
      shift += std::numeric_limits<limb_type>::digits;
   }
   //
   // Finish off by setting the sign:
   //
   if (is_neg)
      to.negate();
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_floating_point>& /*from_type*/)
{
#ifdef BOOST_MSVC
#pragma warning(push)
//#pragma warning(disable : 4127)
#endif
   //
   // The code here only works when the radix of "From" is 2, we could try shifting by other
   // radixes but it would complicate things.... use a string conversion when the radix is other
   // than 2:
   //
   BOOST_IF_CONSTEXPR(std::numeric_limits<number<From> >::radix != 2)
   {
      to = from.str(0, std::ios_base::fmtflags()).c_str();
      return;
   }
   else
   {
      using ui_type = typename canonical<unsigned char, To>::type;

      using default_ops::eval_add;
      using default_ops::eval_convert_to;
      using default_ops::eval_fpclassify;
      using default_ops::eval_get_sign;
      using default_ops::eval_is_zero;
      using default_ops::eval_subtract;

      //
      // First classify the input, then handle the special cases:
      //
      int c = eval_fpclassify(from);

      if (c == static_cast<int>(FP_ZERO))
      {
         to = ui_type(0);
         return;
      }
      else if (c == static_cast<int>(FP_NAN))
      {
         to = static_cast<const char*>("nan");
         return;
      }
      else if (c == static_cast<int>(FP_INFINITE))
      {
         to = static_cast<const char*>("inf");
         if (eval_get_sign(from) < 0)
            to.negate();
         return;
      }

      typename From::exponent_type e;
      From                         f, term;
      to = ui_type(0);

      eval_frexp(f, from, &e);

      constexpr int shift = std::numeric_limits<std::intmax_t>::digits - 1;

      while (!eval_is_zero(f))
      {
         // extract int sized bits from f:
         eval_ldexp(f, f, shift);
         eval_floor(term, f);
         e -= shift;
         eval_ldexp(to, to, shift);
         typename boost::multiprecision::detail::canonical<std::intmax_t, To>::type ll;
         eval_convert_to(&ll, term);
         eval_add(to, ll);
         eval_subtract(f, term);
      }
      using to_exponent = typename To::exponent_type;
      if (e > (std::numeric_limits<to_exponent>::max)())
      {
         to = static_cast<const char*>("inf");
         if (eval_get_sign(from) < 0)
            to.negate();
         return;
      }
      if (e < (std::numeric_limits<to_exponent>::min)())
      {
         to = ui_type(0);
         if (eval_get_sign(from) < 0)
            to.negate();
         return;
      }
      eval_ldexp(to, to, static_cast<to_exponent>(e));
   }
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_rational>& /*from_type*/)
{
   using to_component_type = typename component_type<number<To> >::type;

   number<From>      t(from);
   to_component_type n(numerator(t)), d(denominator(t));
   using default_ops::assign_components;
   assign_components(to, n.backend(), d.backend());
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/)
{
   using to_component_type = typename component_type<number<To> >::type;

   number<From>      t(from);
   to_component_type n(t), d(1);
   using default_ops::assign_components;
   assign_components(to, n.backend(), d.backend());
}

template <class LargeInteger>
inline typename std::enable_if<is_signed_number<LargeInteger>::value>::type make_positive(LargeInteger& val)
{
   if (val.sign() < 0)
      val = -val;
}
template <class LargeInteger>
inline typename std::enable_if<!is_signed_number<LargeInteger>::value>::type make_positive(LargeInteger&){}

template <class R, class LargeInteger>
R safe_convert_to_float(const LargeInteger& i)
{
   if (!i)
      return R(0);
   BOOST_IF_CONSTEXPR(std::numeric_limits<R>::is_specialized && std::numeric_limits<R>::max_exponent)
   {
      using std::ldexp;

      LargeInteger val(i);
      make_positive(val);
      std::size_t mb = msb(val);
      if (mb >= std::numeric_limits<R>::max_exponent)
      {
         int scale_factor = static_cast<int>(mb) + 1 - std::numeric_limits<R>::max_exponent;
         BOOST_MP_ASSERT(scale_factor >= 1);
         val >>= scale_factor;
         R result = val.template convert_to<R>();
         BOOST_IF_CONSTEXPR(std::numeric_limits<R>::digits == 0 || std::numeric_limits<R>::digits >= std::numeric_limits<R>::max_exponent)
         {
            //
            // Calculate and add on the remainder, only if there are more
            // digits in the mantissa that the size of the exponent, in
            // other words if we are dropping digits in the conversion
            // otherwise:
            //
            LargeInteger remainder(i);
            remainder &= (LargeInteger(1) << scale_factor) - 1;
            result += ldexp(safe_convert_to_float<R>(remainder), -scale_factor);
         }
         return i.sign() < 0 ? static_cast<R>(-result) : result;
      }
   }
   return i.template convert_to<R>();
}

template <class To, class Integer>
inline typename std::enable_if<!(is_number<To>::value || std::is_floating_point<To>::value)>::type
generic_convert_rational_to_float_imp(To& result, const Integer& n, const Integer& d, const std::integral_constant<bool, true>&)
{
   //
   // If we get here, then there's something about one type or the other
   // that prevents an exactly rounded result from being calculated
   // (or at least it's not clear how to implement such a thing).
   //
   using default_ops::eval_divide;
   number<To> fn(safe_convert_to_float<number<To> >(n)), fd(safe_convert_to_float<number<To> >(d));
   eval_divide(result, fn.backend(), fd.backend());
}
template <class To, class Integer>
inline typename std::enable_if<is_number<To>::value || std::is_floating_point<To>::value>::type
generic_convert_rational_to_float_imp(To& result, const Integer& n, const Integer& d, const std::integral_constant<bool, true>&)
{
   //
   // If we get here, then there's something about one type or the other
   // that prevents an exactly rounded result from being calculated
   // (or at least it's not clear how to implement such a thing).
   //
   To fd(safe_convert_to_float<To>(d));
   result = safe_convert_to_float<To>(n);
   result /= fd;
}

template <class To, class Integer>
typename std::enable_if<is_number<To>::value || std::is_floating_point<To>::value>::type
generic_convert_rational_to_float_imp(To& result, Integer& num, Integer& denom, const std::integral_constant<bool, false>&)
{
   //
   // If we get here, then the precision of type To is known, and the integer type is unbounded
   // so we can use integer division plus manipulation of the remainder to get an exactly
   // rounded result.
   //
   if (num == 0)
   {
      result = 0;
      return;
   }
   bool s = false;
   if (num < 0)
   {
      s   = true;
      num = -num;
   }
   std::ptrdiff_t denom_bits = msb(denom);
   std::ptrdiff_t shift      = std::numeric_limits<To>::digits + denom_bits - msb(num);
   if (shift > 0)
      num <<= shift;
   else if (shift < 0)
      denom <<= boost::multiprecision::detail::unsigned_abs(shift);
   Integer q, r;
   divide_qr(num, denom, q, r);
   std::ptrdiff_t q_bits = msb(q);
   if (q_bits == std::numeric_limits<To>::digits - 1)
   {
      //
      // Round up if 2 * r > denom:
      //
      r <<= 1;
      int c = r.compare(denom);
      if (c > 0)
         ++q;
      else if ((c == 0) && (q & 1u))
      {
         ++q;
      }
   }
   else
   {
      BOOST_MP_ASSERT(q_bits == std::numeric_limits<To>::digits);
      //
      // We basically already have the rounding info:
      //
      if (q & 1u)
      {
         if (r || (q & 2u))
            ++q;
      }
   }
   using std::ldexp;
   result = do_cast<To>(q);
   result = ldexp(result, static_cast<int>(-shift));
   if (s)
      result = -result;
}
template <class To, class Integer>
inline typename std::enable_if<!(is_number<To>::value || std::is_floating_point<To>::value)>::type
generic_convert_rational_to_float_imp(To& result, Integer& num, Integer& denom, const std::integral_constant<bool, false>& tag)
{
   number<To> t;
   generic_convert_rational_to_float_imp(t, num, denom, tag);
   result = t.backend();
}

template <class To, class From>
inline void generic_convert_rational_to_float(To& result, const From& f)
{
   //
   // Type From is always a Backend to number<>, or an
   // instance of number<>, but we allow
   // To to be either a Backend type, or a real number type,
   // that way we can call this from generic conversions, and
   // from specific conversions to built in types.
   //
   using actual_from_type = typename std::conditional<is_number<From>::value, From, number<From> >::type                                                                                                                                                                                                           ;
   using actual_to_type = typename std::conditional<is_number<To>::value || std::is_floating_point<To>::value, To, number<To> >::type                                                                                                                                                                            ;
   using integer_type = typename component_type<actual_from_type>::type                                                                                                                                                                                                                                 ;
   using dispatch_tag = std::integral_constant<bool, !std::numeric_limits<integer_type>::is_specialized || std::numeric_limits<integer_type>::is_bounded || !std::numeric_limits<actual_to_type>::is_specialized || !std::numeric_limits<actual_to_type>::is_bounded || (std::numeric_limits<actual_to_type>::radix != 2)>;

   integer_type n(numerator(static_cast<actual_from_type>(f))), d(denominator(static_cast<actual_from_type>(f)));
   generic_convert_rational_to_float_imp(result, n, d, dispatch_tag());
}

template <class To, class From>
inline void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_rational>& /*from_type*/)
{
   generic_convert_rational_to_float(to, from);
}

template <class To, class From>
void generic_interconvert_float2rational(To& to, const From& from, const std::integral_constant<int, 2>& /*radix*/)
{
   using std::ldexp;
   using std::frexp;
   using ui_type = typename std::tuple_element<0, typename To::unsigned_types>::type;
   constexpr int shift = std::numeric_limits<long long>::digits;
   typename From::exponent_type e;
   typename component_type<number<To>>::type num, denom;
   number<From> val(from);
   val = frexp(val, &e);
   while (val)
   {
      val = ldexp(val, shift);
      e -= shift;
      long long ll = boost::multiprecision::detail::lltrunc(val);
      val -= ll;
      num <<= shift;
      num += ll;
   }
   denom = ui_type(1u);
   if (e < 0)
      denom <<= -e;
   else if (e > 0)
      num <<= e;
   assign_components(to, num.backend(), denom.backend());
}

template <class To, class From, int Radix>
void generic_interconvert_float2rational(To& to, const From& from, const std::integral_constant<int, Radix>& /*radix*/)
{
   using std::ilogb;
   using std::scalbn;
   using std::pow;
   using std::abs;
   //
   // This is almost the same as the binary case above, but we have to use
   // scalbn and ilogb rather than ldexp and frexp, we also only extract
   // one Radix digit at a time which is terribly inefficient!
   //
   using ui_type = typename std::tuple_element<0, typename To::unsigned_types>::type;
   typename From::exponent_type e;
   typename component_type<number<To>>::type num, denom;
   number<From> val(from);

   if (!val)
   {
      to = ui_type(0u);
      return;
   }

   e   = ilogb(val);
   val = scalbn(val, -e);
   while (val)
   {
      long long ll = boost::multiprecision::detail::lltrunc(val);
      val -= ll;
      val = scalbn(val, 1);
      num *= Radix;
      num += ll;
      --e;
   }
   ++e;
   denom = ui_type(Radix);
   denom = pow(denom, abs(e));
   if (e > 0)
   {
      num *= denom;
      denom = 1;
   }
   assign_components(to, num.backend(), denom.backend());
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_floating_point>& /*from_type*/)
{
   generic_interconvert_float2rational(to, from, std::integral_constant<int, std::numeric_limits<number<From> >::is_specialized ? std::numeric_limits<number<From> >::radix : 2>());
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_integer>& /*to_type*/, const std::integral_constant<int, number_kind_rational>& /*from_type*/)
{
   number<From> t(from);
   number<To>   result(numerator(t) / denominator(t));
   to = result.backend();
}

template <class To, class From>
void generic_interconvert_float2int(To& to, const From& from, const std::integral_constant<int, 2>& /*radix*/)
{
   using std::frexp;
   using std::ldexp;
   
   using exponent_type = typename From::exponent_type;
   constexpr exponent_type              shift = std::numeric_limits<long long>::digits;
   exponent_type                        e;
   number<To>                           num(0u);
   number<From>                         val(from);
   val      = frexp(val, &e);
   bool neg = false;
   if (val.sign() < 0)
   {
      val.backend().negate();
      neg = true;
   }
   while (e > 0)
   {
      exponent_type s = (std::min)(e, shift);
      val             = ldexp(val, s);
      e -= s;
      long long ll = boost::multiprecision::detail::lltrunc(val);
      val -= ll;
      num <<= s;
      num += ll;
   }
   to = num.backend();
   if (neg)
      to.negate();
}

template <class To, class From, int Radix>
void generic_interconvert_float2int(To& to, const From& from, const std::integral_constant<int, Radix>& /*radix*/)
{
   using std::ilogb;
   using std::scalbn;
   //
   // This is almost the same as the binary case above, but we have to use
   // scalbn and ilogb rather than ldexp and frexp, we also only extract
   // one Radix digit at a time which is terribly inefficient!
   //
   typename From::exponent_type e;
   number<To>                   num(0u);
   number<From>                 val(from);
   e   = ilogb(val);
   val = scalbn(val, -e);
   while (e >= 0)
   {
      long long ll = boost::multiprecision::detail::lltrunc(val);
      val -= ll;
      val = scalbn(val, 1);
      num *= Radix;
      num += ll;
      --e;
   }
   to = num.backend();
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_integer>& /*to_type*/, const std::integral_constant<int, number_kind_floating_point>& /*from_type*/)
{
   generic_interconvert_float2int(to, from, std::integral_constant<int, (std::numeric_limits<number<From> >::is_specialized ? std::numeric_limits<number<From> >::radix : 2)>());
}

template <class To, class From, class tag>
void generic_interconvert_complex_to_scalar(To& to, const From& from, const std::integral_constant<bool, true>&, const tag&)
{
   // We just want the real part, and "to" is the correct type already:
   eval_real(to, from);

   To im;
   eval_imag(im, from);
   if (!eval_is_zero(im))
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
}
template <class To, class From>
void generic_interconvert_complex_to_scalar(To& to, const From& from, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&)
{
   using component_number = typename component_type<number<From> >::type;
   using component_backend = typename component_number::backend_type     ;
   //
   // Get the real part and copy-construct the result from it:
   //
   scoped_precision_options<component_number> scope(from);
   component_backend r;
   generic_interconvert_complex_to_scalar(r, from, std::integral_constant<bool, true>(), std::integral_constant<bool, true>());
   to = r;
}
template <class To, class From>
void generic_interconvert_complex_to_scalar(To& to, const From& from, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&)
{
   using component_number = typename component_type<number<From> >::type;
   using component_backend = typename component_number::backend_type;
   //
   // Get the real part and use a generic_interconvert to type To:
   //
   scoped_precision_options<component_number> scope(from);
   component_backend r;
   generic_interconvert_complex_to_scalar(r, from, std::integral_constant<bool, true>(), std::integral_constant<bool, true>());
   generic_interconvert(to, r, std::integral_constant<int, number_category<To>::value>(), std::integral_constant<int, number_category<component_backend>::value>());
}

template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_floating_point>& /*to_type*/, const std::integral_constant<int, number_kind_complex>& /*from_type*/)
{
   using component_number = typename component_type<number<From> >::type;
   using component_backend = typename component_number::backend_type     ;

   generic_interconvert_complex_to_scalar(to, from, std::integral_constant<bool, std::is_same<component_backend, To>::value>(), std::integral_constant<bool, std::is_constructible<To, const component_backend&>::value>());
}
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_integer>& /*to_type*/, const std::integral_constant<int, number_kind_complex>& /*from_type*/)
{
   using component_number = typename component_type<number<From> >::type;
   using component_backend = typename component_number::backend_type     ;

   generic_interconvert_complex_to_scalar(to, from, std::integral_constant<bool, std::is_same<component_backend, To>::value>(), std::integral_constant<bool, std::is_constructible<To, const component_backend&>::value>());
}
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_rational>& /*to_type*/, const std::integral_constant<int, number_kind_complex>& /*from_type*/)
{
   using component_number = typename component_type<number<From> >::type;
   using component_backend = typename component_number::backend_type     ;

   generic_interconvert_complex_to_scalar(to, from, std::integral_constant<bool, std::is_same<component_backend, To>::value>(), std::integral_constant<bool, std::is_constructible<To, const component_backend&>::value>());
}
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_complex>& /*to_type*/, const std::integral_constant<int, number_kind_integer>& /*from_type*/)
{
   using component_number = typename component_type<number<To> >::type;

   scoped_source_precision<number<From> >     scope1;
   scoped_precision_options<component_number> scope2(number<To>::thread_default_precision(), number<To>::thread_default_variable_precision_options());
   (void)scope1;
   (void)scope2;

   number<From>     f(from);
   component_number scalar(f);
   number<To> result(scalar);
   to = result.backend();
}
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_complex>& /*to_type*/, const std::integral_constant<int, number_kind_rational>& /*from_type*/)
{
   using component_number = typename component_type<number<To> >::type;

   scoped_source_precision<number<From> >     scope1;
   scoped_precision_options<component_number> scope2(number<To>::thread_default_precision(), number<To>::thread_default_variable_precision_options());
   (void)scope1;
   (void)scope2;

   number<From>     f(from);
   component_number scalar(f);
   number<To> result(scalar);
   to = result.backend();
}
template <class To, class From>
void generic_interconvert(To& to, const From& from, const std::integral_constant<int, number_kind_complex>& /*to_type*/, const std::integral_constant<int, number_kind_floating_point>& /*from_type*/)
{
   using component_number = typename component_type<number<To> >::type;

   scoped_source_precision<number<From> > scope1;
   scoped_precision_options<component_number> scope2(number<To>::thread_default_precision(), number<To>::thread_default_variable_precision_options());
   (void)scope1;
   (void)scope2;

   number<From> f(from);
   component_number scalar(f);
   number<To> result(scalar);
   to = result.backend();
}
template <class To, class From, int Tag1, int Tag2>
void generic_interconvert(To& /*to*/, const From& /*from*/, const std::integral_constant<int, Tag1>& /*to_type*/, const std::integral_constant<int, Tag2>& /*from_type*/)
{
   static_assert(sizeof(To) == 0, "Sorry, you asked for a conversion bewteen types that hasn't been implemented yet!!");
}

}
}
} // namespace boost::multiprecision::detail

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif // BOOST_MP_GENERIC_INTERCONVERT_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/hash.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_HASH_HPP
#define BOOST_MP_DETAIL_HASH_HPP

#include <cstddef>
#include <functional>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <typename T>
inline std::size_t hash_value(const T& v)
{
    std::hash<T> hasher;
    return hasher(v);
}

#if defined(BOOST_HAS_INT128)

std::size_t hash_value(const uint128_type& val);

inline std::size_t hash_value(const int128_type& val)
{
   return hash_value(static_cast<uint128_type>(val));
}

#endif

inline void hash_combine(std::size_t&) {}

template <typename T, typename... Args>
inline void hash_combine(std::size_t& seed, const T& v, Args... args) 
{
    constexpr std::size_t adder = 0x9e3779b9;
    seed = seed ^ (hash_value(v) + adder + (seed<<6) + (seed>>2));
    hash_combine(seed, args...);
}

#if defined(BOOST_HAS_INT128)

inline std::size_t hash_value(const uint128_type& val)
{
   std::size_t result = static_cast<std::size_t>(val);
   hash_combine(result, static_cast<std::size_t>(val >> 64));
   return result;
}

#endif

}}} // Namespaces

#endif // BOOST_MP_DETAIL_HASH_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/integer_ops.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_DETAIL_INTEGER_OPS_HPP
#define BOOST_MP_DETAIL_INTEGER_OPS_HPP

#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

namespace boost { namespace multiprecision {

namespace default_ops {

template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR void eval_qr(const Backend& x, const Backend& y, Backend& q, Backend& r)
{
   eval_divide(q, x, y);
   eval_modulus(r, x, y);
}

template <class Backend, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR Integer eval_integer_modulus(const Backend& x, Integer val)
{
   BOOST_MP_USING_ABS
   using default_ops::eval_convert_to;
   using default_ops::eval_modulus;
   using int_type = typename boost::multiprecision::detail::canonical<Integer, Backend>::type;
   Backend                                                                           t;
   eval_modulus(t, x, static_cast<int_type>(val));
   Integer result(0);
   eval_convert_to(&result, t);
   return abs(result);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_gcd(B& result, const B& a, const B& b)
{
   using default_ops::eval_get_sign;
   using default_ops::eval_is_zero;
   using default_ops::eval_lsb;

   std::ptrdiff_t shift(0);

   B u(a), v(b);

   int s = eval_get_sign(u);

   /* GCD(0,x) := x */
   if (s < 0)
   {
      u.negate();
   }
   else if (s == 0)
   {
      result = v;
      return;
   }
   s = eval_get_sign(v);
   if (s < 0)
   {
      v.negate();
   }
   else if (s == 0)
   {
      result = u;
      return;
   }

   /* Let shift := lg K, where K is the greatest power of 2
   dividing both u and v. */

   std::size_t us = eval_lsb(u);
   std::size_t vs = eval_lsb(v);
   shift       = static_cast<std::ptrdiff_t>((std::min)(us, vs));
   eval_right_shift(u, us);
   eval_right_shift(v, vs);

   do
   {
      /* Now u and v are both odd, so diff(u, v) is even.
      Let u = min(u, v), v = diff(u, v)/2. */
      s = u.compare(v);
      if (s > 0)
         u.swap(v);
      if (s == 0)
         break;
      eval_subtract(v, u);
      vs = eval_lsb(v);
      eval_right_shift(v, vs);
   } while (true);

   result = u;
   eval_left_shift(result, shift);
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR void eval_lcm(B& result, const B& a, const B& b)
{
   using ui_type = typename std::tuple_element<0, typename B::unsigned_types>::type;
   B                                                             t;
   eval_gcd(t, a, b);

   if (eval_is_zero(t))
   {
      result = static_cast<ui_type>(0);
   }
   else
   {
      eval_divide(result, a, t);
      eval_multiply(result, b);
   }
   if (eval_get_sign(result) < 0)
      result.negate();
}

} // namespace default_ops

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
divide_qr(const number<Backend, ExpressionTemplates>& x, const number<Backend, ExpressionTemplates>& y,
          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
{
   using default_ops::eval_qr;
   eval_qr(x.backend(), y.backend(), q.backend(), r.backend());
}

template <class Backend, expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
divide_qr(const number<Backend, ExpressionTemplates>& x, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& y,
          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
{
   divide_qr(x, number<Backend, ExpressionTemplates>(y), q, r);
}

template <class tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const number<Backend, ExpressionTemplates>& y,
          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
{
   divide_qr(number<Backend, ExpressionTemplates>(x), y, q, r);
}

template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& y,
          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
{
   divide_qr(number<Backend, ExpressionTemplates>(x), number<Backend, ExpressionTemplates>(y), q, r);
}

template <class Backend, expression_template_option ExpressionTemplates, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && (number_category<Backend>::value == number_kind_integer), Integer>::type
integer_modulus(const number<Backend, ExpressionTemplates>& x, Integer val)
{
   using default_ops::eval_integer_modulus;
   return eval_integer_modulus(x.backend(), val);
}

template <class tag, class A1, class A2, class A3, class A4, class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && (number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer), Integer>::type
integer_modulus(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, Integer val)
{
   using result_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   return integer_modulus(result_type(x), val);
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, std::size_t>::type
lsb(const number<Backend, ExpressionTemplates>& x)
{
   using default_ops::eval_lsb;
   return eval_lsb(x.backend());
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, std::size_t>::type
lsb(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x)
{
   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                                           n(x);
   using default_ops::eval_lsb;
   return eval_lsb(n.backend());
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, std::size_t>::type
msb(const number<Backend, ExpressionTemplates>& x)
{
   using default_ops::eval_msb;
   return eval_msb(x.backend());
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, std::size_t>::type
msb(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x)
{
   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                                           n(x);
   using default_ops::eval_msb;
   return eval_msb(n.backend());
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, bool>::type
bit_test(const number<Backend, ExpressionTemplates>& x, std::size_t index)
{
   using default_ops::eval_bit_test;
   return eval_bit_test(x.backend(), index);
}

template <class tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, bool>::type
bit_test(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, std::size_t index)
{
   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
   number_type                                                                           n(x);
   using default_ops::eval_bit_test;
   return eval_bit_test(n.backend(), index);
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
bit_set(number<Backend, ExpressionTemplates>& x, std::size_t index)
{
   using default_ops::eval_bit_set;
   eval_bit_set(x.backend(), index);
   return x;
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
bit_unset(number<Backend, ExpressionTemplates>& x, std::size_t index)
{
   using default_ops::eval_bit_unset;
   eval_bit_unset(x.backend(), index);
   return x;
}

template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
bit_flip(number<Backend, ExpressionTemplates>& x, std::size_t index)
{
   using default_ops::eval_bit_flip;
   eval_bit_flip(x.backend(), index);
   return x;
}

namespace default_ops {

//
// Within powm, we need a type with twice as many digits as the argument type, define
// a traits class to obtain that type:
//
template <class Backend>
struct double_precision_type
{
   using type = Backend;
};

//
// If the exponent is a signed integer type, then we need to
// check the value is positive:
//
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR void check_sign_of_backend(const Backend& v, const std::integral_constant<bool, true>)
{
   if (eval_get_sign(v) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
}
template <class Backend>
inline BOOST_MP_CXX14_CONSTEXPR void check_sign_of_backend(const Backend&, const std::integral_constant<bool, false>) {}
//
// Calculate (a^p)%c:
//
template <class Backend>
BOOST_MP_CXX14_CONSTEXPR void eval_powm(Backend& result, const Backend& a, const Backend& p, const Backend& c)
{
   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_modulus;
   using default_ops::eval_multiply;
   using default_ops::eval_right_shift;

   using double_type = typename double_precision_type<Backend>::type                                      ;
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;

   check_sign_of_backend(p, std::integral_constant<bool, std::numeric_limits<number<Backend> >::is_signed>());

   double_type x, y(a), b(p), t;
   x = ui_type(1u);

   while (eval_get_sign(b) > 0)
   {
      if (eval_bit_test(b, 0))
      {
         eval_multiply(t, x, y);
         eval_modulus(x, t, c);
      }
      eval_multiply(t, y, y);
      eval_modulus(y, t, c);
      eval_right_shift(b, ui_type(1));
   }
   Backend x2(x);
   eval_modulus(result, x2, c);
}

template <class Backend, class Integer>
BOOST_MP_CXX14_CONSTEXPR void eval_powm(Backend& result, const Backend& a, const Backend& p, Integer c)
{
   using double_type = typename double_precision_type<Backend>::type                                      ;
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
   using i1_type = typename boost::multiprecision::detail::canonical<Integer, double_type>::type      ;
   using i2_type = typename boost::multiprecision::detail::canonical<Integer, Backend>::type          ;

   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_modulus;
   using default_ops::eval_multiply;
   using default_ops::eval_right_shift;

   check_sign_of_backend(p, std::integral_constant<bool, std::numeric_limits<number<Backend> >::is_signed>());

   if (eval_get_sign(p) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }

   double_type x, y(a), b(p), t;
   x = ui_type(1u);

   while (eval_get_sign(b) > 0)
   {
      if (eval_bit_test(b, 0))
      {
         eval_multiply(t, x, y);
         eval_modulus(x, t, static_cast<i1_type>(c));
      }
      eval_multiply(t, y, y);
      eval_modulus(y, t, static_cast<i1_type>(c));
      eval_right_shift(b, ui_type(1));
   }
   Backend x2(x);
   eval_modulus(result, x2, static_cast<i2_type>(c));
}

template <class Backend, class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value >::type eval_powm(Backend& result, const Backend& a, Integer b, const Backend& c)
{
   using double_type = typename double_precision_type<Backend>::type                                      ;
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;

   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_modulus;
   using default_ops::eval_multiply;
   using default_ops::eval_right_shift;

   double_type x, y(a), t;
   x = ui_type(1u);

   while (b > 0)
   {
      if (b & 1)
      {
         eval_multiply(t, x, y);
         eval_modulus(x, t, c);
      }
      eval_multiply(t, y, y);
      eval_modulus(y, t, c);
      b >>= 1;
   }
   Backend x2(x);
   eval_modulus(result, x2, c);
}

template <class Backend, class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value>::type eval_powm(Backend& result, const Backend& a, Integer b, const Backend& c)
{
   if (b < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   eval_powm(result, a, static_cast<typename boost::multiprecision::detail::make_unsigned<Integer>::type>(b), c);
}

template <class Backend, class Integer1, class Integer2>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer1>::value >::type eval_powm(Backend& result, const Backend& a, Integer1 b, Integer2 c)
{
   using double_type = typename double_precision_type<Backend>::type                                      ;
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
   using i1_type = typename boost::multiprecision::detail::canonical<Integer1, double_type>::type     ;
   using i2_type = typename boost::multiprecision::detail::canonical<Integer2, Backend>::type         ;

   using default_ops::eval_bit_test;
   using default_ops::eval_get_sign;
   using default_ops::eval_modulus;
   using default_ops::eval_multiply;
   using default_ops::eval_right_shift;

   double_type x, y(a), t;
   x = ui_type(1u);

   while (b > 0)
   {
      if (b & 1)
      {
         eval_multiply(t, x, y);
         eval_modulus(x, t, static_cast<i1_type>(c));
      }
      eval_multiply(t, y, y);
      eval_modulus(y, t, static_cast<i1_type>(c));
      b >>= 1;
   }
   Backend x2(x);
   eval_modulus(result, x2, static_cast<i2_type>(c));
}

template <class Backend, class Integer1, class Integer2>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer1>::value && boost::multiprecision::detail::is_integral<Integer1>::value>::type eval_powm(Backend& result, const Backend& a, Integer1 b, Integer2 c)
{
   if (b < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   eval_powm(result, a, static_cast<typename boost::multiprecision::detail::make_unsigned<Integer1>::type>(b), c);
}

struct powm_func
{
   template <class T, class U, class V>
   BOOST_MP_CXX14_CONSTEXPR void operator()(T& result, const T& b, const U& p, const V& m) const
   {
      eval_powm(result, b, p, m);
   }
   template <class R, class T, class U, class V>
   BOOST_MP_CXX14_CONSTEXPR void operator()(R& result, const T& b, const U& p, const V& m) const
   {
      T temp;
      eval_powm(temp, b, p, m);
      result = std::move(temp);
   }
};

} // namespace default_ops

template <class T, class U, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
        (number_category<T>::value == number_kind_integer) &&
        (is_number<T>::value || is_number_expression<T>::value) &&
        (is_number<U>::value || is_number_expression<U>::value || boost::multiprecision::detail::is_integral<U>::value) &&
        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_integral<V>::value),
    typename std::conditional<
        is_no_et_number<T>::value,
        T,
        typename std::conditional<
            is_no_et_number<U>::value,
            U,
            typename std::conditional<
                is_no_et_number<V>::value,
                V,
                detail::expression<detail::function, default_ops::powm_func, T, U, V> >::type>::type>::type>::type
powm(const T& b, const U& p, const V& mod)
{
   return detail::expression<detail::function, default_ops::powm_func, T, U, V>(
       default_ops::powm_func(), b, p, mod);
}

}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/itos.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// We used to use lexical_cast internally for quick conversions from integers 
// to strings, but that breaks if the global locale is something other than "C".
// See https://github.com/boostorg/multiprecision/issues/167.
//
#ifndef BOOST_MP_DETAIL_ITOS_HPP
#define BOOST_MP_DETAIL_ITOS_HPP

namespace boost { namespace multiprecision { namespace detail {

   template <class Integer>
   std::string itos(Integer val)
   {
      if (!val)  return "0";
      std::string result;
      bool isneg = false;
      if (val < 0)
      {
         val = -val;
         isneg = true;
      }
      while (val)
      {
         result.insert(result.begin(), char('0' + (val % 10)));
         val /= 10;
      }
      if (isneg)
         result.insert(result.begin(), '-');
      return result;
   }


}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/min_max.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_MIN_MAX_HPP
#define BOOST_MP_MIN_MAX_HPP

#include <boost/multiprecision/traits/is_backend.hpp>

namespace boost { namespace multiprecision {

//
// Expression template overloads for (min) and (max):
//
// Introduced in response to https://svn.boost.org/trac/boost/ticket/11149
// note that these can not legally be injected into namespace std, and that doing so
// may break future enhancements to the standard.  None the less adding
// namespace std{ using boost::multiprecision::(min); using boost::multiprecision::(max); }
// to your code may get some generic code working that wouldn't work otherwise.
//
// The use of enable_if on the return type is to avoid poisoning std::min/max,
// otherwise attempting to make an explicit call to min<long>(a, b) when these and std
// versions are in scope, will cause the compiler to try to instantiate the signatures
// for our versions as well as the std ones, which in turn instantiates number<long>
// which fails to compile as "long" is not a valid backend type.
//
template <class Backend>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on>&>::type(min)(const number<Backend, et_on>& a, const number<Backend, et_on>& b)
{
   return a < b ? a : b;
}
template <class Backend, class tag, class A1, class A2, class A3, class A4>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(min)(const number<Backend, et_on>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
{
   number<Backend, et_on> t(b);
   if (a < t)
      return a;
   return std::move(t);
}
template <class tag, class A1, class A2, class A3, class A4, class Backend>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const number<Backend, et_on>& b)
{
   number<Backend, et_on> t(a);
   if (t < b)
      return std::move(t);
   return b;
}
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
{
   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
   if (t1 < t2)
      return std::move(t1);
   return std::move(t2);
}
template <class tag, class A1, class A2, class A3, class A4>
inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
{
   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
   if (t1 < t2)
      return std::move(t1);
   return std::move(t2);
}

template <class Backend>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on>&>::type(max)(const number<Backend, et_on>& a, const number<Backend, et_on>& b)
{
   return a > b ? a : b;
}
template <class Backend, class tag, class A1, class A2, class A3, class A4>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(max)(const number<Backend, et_on>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
{
   number<Backend, et_on> t(b);
   if (a > t)
      return a;
   return std::move(t);
}
template <class tag, class A1, class A2, class A3, class A4, class Backend>
inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const number<Backend, et_on>& b)
{
   number<Backend, et_on> t(a);
   if (t > b)
      return std::move(t);
   return b;
}
template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
{
   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
   if (t1 > t2)
      return std::move(t1);
   return std::move(t2);
}
template <class tag, class A1, class A2, class A3, class A4>
inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
{
   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
   if (t1 > t2)
      return std::move(t1);
   return std::move(t2);
}

}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/no_et_ops.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_NO_ET_OPS_HPP
#define BOOST_MP_NO_ET_OPS_HPP

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4714)
#endif

namespace boost {
   namespace multiprecision {

      //
      // Operators for non-expression template enabled number.
      // NOTE: this is not a complete header - really just a suffix to default_ops.hpp.
      // NOTE: these operators have to be defined after the methods in default_ops.hpp.
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& v)
      {
         static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
         number<B, et_off>                                                    result(v);
         result.backend().negate();
         return result;
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator~(const number<B, et_off>& v)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
         number<B, et_off>                                                    result;
         eval_complement(result.backend(), v.backend());
         return result;
      }
      //
      // Addition:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_add;
         eval_add(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator+(const number<B, et_off>& a, const V& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_add;
         eval_add(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator+(const V& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
         number<B, et_off>                                                    result;
         using default_ops::eval_add;
         eval_add(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
         return result;
      }
      //
      // Subtraction:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_subtract;
         eval_subtract(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator-(const number<B, et_off>& a, const V& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_subtract;
         eval_subtract(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator-(const V& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
         number<B, et_off>                                                    result;
         using default_ops::eval_subtract;
         eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
         return result;
      }
      //
      // Multiply:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_multiply;
         eval_multiply(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator*(const number<B, et_off>& a, const V& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_multiply;
         eval_multiply(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator*(const V& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
         number<B, et_off>                                                    result;
         using default_ops::eval_multiply;
         eval_multiply(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
         return result;
      }
      //
      // divide:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_divide;
         eval_divide(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator/(const number<B, et_off>& a, const V& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_divide;
         eval_divide(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator/(const V& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
         number<B, et_off>                                                    result;
         using default_ops::eval_divide;
         eval_divide(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
         return result;
      }
      //
      // modulus:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         number<B, et_off>                                                    result;
         using default_ops::eval_modulus;
         eval_modulus(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator%(const number<B, et_off>& a, const V& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a);
         number<B, et_off>                                                    result;
         using default_ops::eval_modulus;
         eval_modulus(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator%(const V& a, const number<B, et_off>& b)
      {
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b);
         number<B, et_off>                                                    result;
         using default_ops::eval_modulus;
         eval_modulus(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
         return result;
      }
      //
      // Bitwise or:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator|(const number<B, et_off>& a, const V& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator|(const V& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
         return result;
      }
      //
      // Bitwise xor:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator^(const number<B, et_off>& a, const V& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator^(const V& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
         return result;
      }
      //
      // Bitwise and:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(result.backend(), a.backend(), b.backend());
         return result;
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator&(const number<B, et_off>& a, const V& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
         return result;
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator&(const V& a, const number<B, et_off>& b)
      {
         number<B, et_off> result;
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
         return result;
      }
      //
      // shifts:
      //
      template <class B, class I>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator<<(const number<B, et_off>& a, const I& b)
      {
         number<B, et_off> result(a);
         using default_ops::eval_left_shift;
         detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
         eval_left_shift(result.backend(), b);
         return result;
      }
      template <class B, class I>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator>>(const number<B, et_off>& a, const I& b)
      {
         number<B, et_off> result(a);
         using default_ops::eval_right_shift;
         detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
         eval_right_shift(result.backend(), b);
         return result;
      }

      //
      // If we have rvalue references go all over again with rvalue ref overloads and move semantics.
      // Note that while it would be tempting to implement these so they return an rvalue reference
      // (and indeed this would be optimally efficient), this is unsafe due to users propensity to
      // write:
      //
      // const T& t = a * b;
      //
      // which would lead to a dangling reference if we didn't return by value.  Of course move
      // semantics help a great deal in return by value, so performance is still pretty good...
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& v)
      {
         static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
         v.backend().negate();
         return std::move(v);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator~(number<B, et_off>&& v)
      {
         eval_complement(v.backend(), v.backend());
         return std::move(v);
      }
      //
      // Addition:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_add;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_add(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_add;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_add(b.backend(), a.backend());
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_add;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_add(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator+(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_add;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_add(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator+(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_add;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_add(b.backend(), number<B, et_off>::canonical_value(a));
         return std::move(b);
      }
      //
      // Subtraction:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_subtract;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_subtract(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_signed_number<B>::value, number<B, et_off> >::type operator-(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_subtract;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_subtract(b.backend(), a.backend());
         b.backend().negate();
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_subtract;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_subtract(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator-(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_subtract;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(is_compatible_arithmetic_type<V, number<B, et_off> >::value && is_signed_number<B>::value) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator-(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_subtract;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_subtract(b.backend(), number<B, et_off>::canonical_value(a));
         b.backend().negate();
         return std::move(b);
      }
      //
      // Multiply:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_multiply;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_multiply(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_multiply;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_multiply(b.backend(), a.backend());
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_multiply;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_multiply(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator*(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_multiply;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_multiply(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator*(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_multiply;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_multiply(b.backend(), number<B, et_off>::canonical_value(a));
         return std::move(b);
      }
      //
      // divide:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_divide;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_divide(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
         operator/(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_divide;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_divide(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      //
      // modulus:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_modulus;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_modulus(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator%(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_modulus;
         detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
         eval_modulus(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      //
      // Bitwise or:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(b.backend(), a.backend());
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator|(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator|(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_or;
         eval_bitwise_or(b.backend(), number<B, et_off>::canonical_value(a));
         return std::move(b);
      }
      //
      // Bitwise xor:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(b.backend(), a.backend());
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator^(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator^(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_xor;
         eval_bitwise_xor(b.backend(), number<B, et_off>::canonical_value(a));
         return std::move(b);
      }
      //
      // Bitwise and:
      //
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, const number<B, et_off>& b)
      {
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(b.backend(), a.backend());
         return std::move(b);
      }
      template <class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(a.backend(), b.backend());
         return std::move(a);
      }
      template <class B, class V>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator&(number<B, et_off>&& a, const V& b)
      {
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(a.backend(), number<B, et_off>::canonical_value(b));
         return std::move(a);
      }
      template <class V, class B>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
         operator&(const V& a, number<B, et_off>&& b)
      {
         using default_ops::eval_bitwise_and;
         eval_bitwise_and(b.backend(), number<B, et_off>::canonical_value(a));
         return std::move(b);
      }
      //
      // shifts:
      //
      template <class B, class I>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator<<(number<B, et_off>&& a, const I& b)
      {
         using ui_type = typename boost::multiprecision::detail::make_unsigned<I>::type;

         using default_ops::eval_left_shift;
         eval_left_shift(a.backend(), static_cast<ui_type>(b));
         return std::move(a);
      }
      template <class B, class I>
      BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
         operator>>(number<B, et_off>&& a, const I& b)
      {
         using ui_type = typename boost::multiprecision::detail::make_unsigned<I>::type;

         using default_ops::eval_right_shift;
         eval_right_shift(a.backend(), static_cast<ui_type>(b));
         return std::move(a);
      }
   }
} // namespace boost::multiprecision

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif // BOOST_MP_NO_ET_OPS_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/no_exceptions_support.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2004 - 2021 Pavel Vozenilek.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP
#define BOOST_MP_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#ifdef BOOST_MP_STANDALONE

#ifndef BOOST_NO_EXCEPTIONS
#   define BOOST_MP_TRY { try
#   define BOOST_MP_CATCH(x) catch(x)
#   define BOOST_MP_RETHROW throw;
#   define BOOST_MP_CATCH_END }
#   define BOOST_MP_THROW_EXCEPTION(x) throw (x);
#else
#   if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
#       define BOOST_MP_TRY { if (true)
#       define BOOST_MP_CATCH(x) else if (false)
#   else
        // warning C4127: conditional expression is constant
#       define BOOST_MP_TRY { \
            __pragma(warning(push)) \
            __pragma(warning(disable: 4127)) \
            if (true) \
            __pragma(warning(pop))
#       define BOOST_MP_CATCH(x) else \
            __pragma(warning(push)) \
            __pragma(warning(disable: 4127)) \
            if (false) \
            __pragma(warning(pop))
#   endif
#   define BOOST_MP_RETHROW
#   define BOOST_MP_CATCH_END }
#   define BOOST_MP_THROW_EXCEPTION(x) {static_cast<void>(x);}
#endif

#else // Not standalone mode

#   include <boost/core/no_exceptions_support.hpp>
#   include <boost/throw_exception.hpp>

#   define BOOST_MP_TRY BOOST_TRY
#   define BOOST_MP_CATCH(x) BOOST_CATCH(x)
#   define BOOST_MP_RETHROW BOOST_RETHROW
#   define BOOST_MP_CATCH_END BOOST_CATCH_END
#   define BOOST_MP_THROW_EXCEPTION(x) BOOST_THROW_EXCEPTION(x)

#endif // BOOST_MP_STANDALONE

#endif // BOOST_MP_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/number_base.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_NUMBER_BASE_HPP
#define BOOST_MP_NUMBER_BASE_HPP

#include <climits>
#include <ios>
#include <string>
#include <limits>
#include <type_traits>
#include <stdexcept>
#include <tuple>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/traits/transcendental_reduction_type.hpp>
#include <boost/multiprecision/traits/std_integer_traits.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4307)
#pragma warning(pop)
#endif

#ifndef BOOST_MP_STANDALONE
#include <boost/lexical_cast.hpp>
#include <boost/core/nvp.hpp>
#endif

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/tools/complex.hpp>
#endif

// We now require C++11.
#include <boost/multiprecision/detail/check_cpp11_config.hpp>

#if defined(NDEBUG) && !defined(_DEBUG)
#define BOOST_MP_FORCEINLINE BOOST_FORCEINLINE
#else
#define BOOST_MP_FORCEINLINE inline
#endif

//
// Thread local storage:
// Note fails on Mingw, see https://sourceforge.net/p/mingw-w64/bugs/527/
//
#if defined(BOOST_NO_CXX11_THREAD_LOCAL)
#define BOOST_MP_THREAD_LOCAL
#elif !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ < 9)) && !defined(__clang__))
#define BOOST_MP_THREAD_LOCAL thread_local
#define BOOST_MP_USING_THREAD_LOCAL
#else
#pragma GCC warning "thread_local on mingw is broken, please use MSys mingw gcc-9 or later, see https://sourceforge.net/p/mingw-w64/bugs/527/"
#define BOOST_MP_THREAD_LOCAL
#endif

#ifdef __has_include
# if __has_include(<version>)
#  include <version>
#  ifdef __cpp_lib_is_constant_evaluated
#   include <type_traits>
#   define BOOST_MP_HAS_IS_CONSTANT_EVALUATED
#  endif
# endif
#endif

#ifdef __has_builtin
#if __has_builtin(__builtin_is_constant_evaluated) && !defined(BOOST_NO_CXX14_CONSTEXPR) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
#define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED
#endif
#endif
//
// MSVC also supports __builtin_is_constant_evaluated if it's recent enough:
//
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 192528326)
#  define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED
#endif
//
// As does GCC-9:
//
#if defined(BOOST_GCC) && !defined(BOOST_NO_CXX14_CONSTEXPR) && (__GNUC__ >= 9) && !defined(BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED)
#  define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED
#endif

#if defined(BOOST_MP_HAS_IS_CONSTANT_EVALUATED) && !defined(BOOST_NO_CXX14_CONSTEXPR)
#  define BOOST_MP_IS_CONST_EVALUATED(x) std::is_constant_evaluated()
#elif defined(BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED)
#  define BOOST_MP_IS_CONST_EVALUATED(x) __builtin_is_constant_evaluated()
#elif !defined(BOOST_NO_CXX14_CONSTEXPR) && defined(BOOST_GCC) && (__GNUC__ >= 6)
#  define BOOST_MP_IS_CONST_EVALUATED(x) __builtin_constant_p(x)
#else
#  define BOOST_MP_NO_CONSTEXPR_DETECTION
#endif

#define BOOST_MP_CXX14_CONSTEXPR BOOST_CXX14_CONSTEXPR
//
// Early compiler versions trip over the constexpr code:
//
#if defined(__clang__) && (__clang_major__ < 5)
#undef BOOST_MP_CXX14_CONSTEXPR
#define BOOST_MP_CXX14_CONSTEXPR
#endif
#if defined(__apple_build_version__) && (__clang_major__ < 9)
#undef BOOST_MP_CXX14_CONSTEXPR
#define BOOST_MP_CXX14_CONSTEXPR
#endif
#if defined(BOOST_GCC) && (__GNUC__ < 6)
#undef BOOST_MP_CXX14_CONSTEXPR
#define BOOST_MP_CXX14_CONSTEXPR
#endif
#if defined(BOOST_INTEL)
#undef BOOST_MP_CXX14_CONSTEXPR
#define BOOST_MP_CXX14_CONSTEXPR
#define BOOST_MP_NO_CONSTEXPR_DETECTION
#endif

#ifdef BOOST_MP_NO_CONSTEXPR_DETECTION
#  define BOOST_CXX14_CONSTEXPR_IF_DETECTION
#else
#  define BOOST_CXX14_CONSTEXPR_IF_DETECTION constexpr
#endif

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 6326)
#endif

namespace boost {
namespace multiprecision {

enum expression_template_option
{
   et_off = 0,
   et_on  = 1
};

enum struct variable_precision_options : signed char
{
   assume_uniform_precision = -1,
   preserve_target_precision = 0,
   preserve_source_precision = 1,
   preserve_component_precision = 2,
   preserve_related_precision = 3,
   preserve_all_precision = 4,
};

inline constexpr bool operator==(variable_precision_options a, variable_precision_options b)
{
   return static_cast<unsigned>(a) == static_cast<unsigned>(b);
}

template <class Backend>
struct expression_template_default
{
   static constexpr expression_template_option value = et_on;
};

template <class Backend, expression_template_option ExpressionTemplates = expression_template_default<Backend>::value>
class number;

template <class T>
struct is_number : public std::integral_constant<bool, false>
{};

template <class Backend, expression_template_option ExpressionTemplates>
struct is_number<number<Backend, ExpressionTemplates> > : public std::integral_constant<bool, true>
{};

template <class T>
struct is_et_number : public std::integral_constant<bool, false>
{};

template <class Backend>
struct is_et_number<number<Backend, et_on> > : public std::integral_constant<bool, true>
{};

template <class T>
struct is_no_et_number : public std::integral_constant<bool, false>
{};

template <class Backend>
struct is_no_et_number<number<Backend, et_off> > : public std::integral_constant<bool, true>
{};

namespace detail {

// Forward-declare an expression wrapper
template <class tag, class Arg1 = void, class Arg2 = void, class Arg3 = void, class Arg4 = void>
struct expression;

} // namespace detail

template <class T>
struct is_number_expression : public std::integral_constant<bool, false>
{};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct is_number_expression<detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > : public std::integral_constant<bool, true>
{};

template <class T, class Num>
struct is_compatible_arithmetic_type
    : public std::integral_constant<bool, 
          std::is_convertible<T, Num>::value && !std::is_same<T, Num>::value && !is_number_expression<T>::value>
{};

namespace detail {
//
// Workaround for missing abs(long long) and abs(__int128) on some compilers:
//
template <class T>
constexpr typename std::enable_if<(boost::multiprecision::detail::is_signed<T>::value || std::is_floating_point<T>::value), T>::type abs(T t) noexcept
{
   // This strange expression avoids a hardware trap in the corner case
   // that val is the most negative value permitted in long long.
   // See https://svn.boost.org/trac/boost/ticket/9740.
   return t < 0 ? T(1u) + T(-(t + 1)) : t;
}
template <class T>
constexpr typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value, T>::type abs(T t) noexcept
{
   return t;
}

#define BOOST_MP_USING_ABS using boost::multiprecision::detail::abs;

template <class T>
constexpr typename std::enable_if<(boost::multiprecision::detail::is_signed<T>::value || std::is_floating_point<T>::value), typename boost::multiprecision::detail::make_unsigned<T>::type>::type unsigned_abs(T t) noexcept
{
   // This strange expression avoids a hardware trap in the corner case
   // that val is the most negative value permitted in long long.
   // See https://svn.boost.org/trac/boost/ticket/9740.
   return t < 0 ? static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(1u) + static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(-(t + 1)) : static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(t);
}
template <class T>
constexpr typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value, T>::type unsigned_abs(T t) noexcept
{
   return t;
}

template <class T>
struct bits_of
{
   static_assert(boost::multiprecision::detail::is_integral<T>::value || std::is_enum<T>::value || std::numeric_limits<T>::is_specialized, "Failed integer size check");
   static constexpr unsigned value =
       std::numeric_limits<T>::is_specialized ? std::numeric_limits<T>::digits
                                              : sizeof(T) * CHAR_BIT - (boost::multiprecision::detail::is_signed<T>::value ? 1 : 0);
};

#if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__)
#define BOOST_MP_BITS_OF_FLOAT128_DEFINED
template <>
struct bits_of<float128_type>
{
   static constexpr unsigned value = 113;
};
#endif

template <int b>
struct has_enough_bits
{
   template <class T>
   struct type : public std::integral_constant<bool, bits_of<T>::value >= b>
   {};
};

template <class Tuple, int i, int digits, bool = (i >= std::tuple_size<Tuple>::value)>
struct find_index_of_large_enough_type
{
   static constexpr int value = bits_of<typename std::tuple_element<static_cast<std::size_t>(i), Tuple>::type>::value >= digits ? i : find_index_of_large_enough_type<Tuple, i + 1, digits>::value;
};
template <class Tuple, int i, int digits>
struct find_index_of_large_enough_type<Tuple, i, digits, true>
{
   static constexpr int value = INT_MAX;
};

template <int index, class Tuple, class Fallback, bool = (std::tuple_size<Tuple>::value <= index)>
struct dereference_tuple
{
   using type = typename std::tuple_element<static_cast<std::size_t>(index), Tuple>::type;
};
template <int index, class Tuple, class Fallback>
struct dereference_tuple<index, Tuple, Fallback, true>
{
   using type = Fallback;
};

template <class Val, class Backend, class Tag>
struct canonical_imp
{
   using type = typename std::remove_cv<typename std::decay<const Val>::type>::type;
};
template <class B, class Backend, class Tag>
struct canonical_imp<number<B, et_on>, Backend, Tag>
{
   using type = B;
};
template <class B, class Backend, class Tag>
struct canonical_imp<number<B, et_off>, Backend, Tag>
{
   using type = B;
};
#ifdef __SUNPRO_CC
template <class B, class Backend>
struct canonical_imp<number<B, et_on>, Backend, std::integral_constant<int, 3> >
{
   using type = B;
};
template <class B, class Backend>
struct canonical_imp<number<B, et_off>, Backend, std::integral_constant<int, 3> >
{
   using type = B;
};
#endif
template <class Val, class Backend>
struct canonical_imp<Val, Backend, std::integral_constant<int, 0> >
{
   static constexpr int index = find_index_of_large_enough_type<typename Backend::signed_types, 0, bits_of<Val>::value>::value;
   using type = typename dereference_tuple<index, typename Backend::signed_types, Val>::type;
};
template <class Val, class Backend>
struct canonical_imp<Val, Backend, std::integral_constant<int, 1> >
{
   static constexpr int index = find_index_of_large_enough_type<typename Backend::unsigned_types, 0, bits_of<Val>::value>::value;
   using type = typename dereference_tuple<index, typename Backend::unsigned_types, Val>::type;
};
template <class Val, class Backend>
struct canonical_imp<Val, Backend, std::integral_constant<int, 2> >
{
   static constexpr int index = find_index_of_large_enough_type<typename Backend::float_types, 0, bits_of<Val>::value>::value;
   using type = typename dereference_tuple<index, typename Backend::float_types, Val>::type;
};
template <class Val, class Backend>
struct canonical_imp<Val, Backend, std::integral_constant<int, 3> >
{
   using type = const char*;
};
template <class Val, class Backend>
struct canonical_imp<Val, Backend, std::integral_constant<int, 4> >
{
   using underlying = typename std::underlying_type<Val>::type;
   using tag = typename std::conditional<boost::multiprecision::detail::is_signed<Val>::value, std::integral_constant<int, 0>, std::integral_constant<int, 1>>::type;
   using type = typename canonical_imp<underlying, Backend, tag>::type;
};

template <class Val, class Backend>
struct canonical
{
   using tag_type = typename std::conditional<
       boost::multiprecision::detail::is_signed<Val>::value && boost::multiprecision::detail::is_integral<Val>::value,
       std::integral_constant<int, 0>,
       typename std::conditional<
           boost::multiprecision::detail::is_unsigned<Val>::value,
           std::integral_constant<int, 1>,
           typename std::conditional<
               std::is_floating_point<Val>::value,
               std::integral_constant<int, 2>,
               typename std::conditional<
                   (std::is_convertible<Val, const char*>::value || std::is_same<Val, std::string>::value),
                   std::integral_constant<int, 3>,
                   typename std::conditional<
                     std::is_enum<Val>::value,
                     std::integral_constant<int, 4>,
                     std::integral_constant<int, 5> >::type>::type>::type>::type>::type;

   using type = typename canonical_imp<Val, Backend, tag_type>::type;
};

struct terminal
{};
struct negate
{};
struct plus
{};
struct minus
{};
struct multiplies
{};
struct divides
{};
struct modulus
{};
struct shift_left
{};
struct shift_right
{};
struct bitwise_and
{};
struct bitwise_or
{};
struct bitwise_xor
{};
struct bitwise_complement
{};
struct add_immediates
{};
struct subtract_immediates
{};
struct multiply_immediates
{};
struct divide_immediates
{};
struct modulus_immediates
{};
struct bitwise_and_immediates
{};
struct bitwise_or_immediates
{};
struct bitwise_xor_immediates
{};
struct complement_immediates
{};
struct function
{};
struct multiply_add
{};
struct multiply_subtract
{};

template <class T>
struct backend_type;

template <class T, expression_template_option ExpressionTemplates>
struct backend_type<number<T, ExpressionTemplates> >
{
   using type = T;
};

template <class tag, class A1, class A2, class A3, class A4>
struct backend_type<expression<tag, A1, A2, A3, A4> >
{
   using type = typename backend_type<typename expression<tag, A1, A2, A3, A4>::result_type>::type;
};

template <class T1, class T2>
struct combine_expression
{
   using type = decltype(T1() + T2());
};

template <class T1, expression_template_option ExpressionTemplates, class T2>
struct combine_expression<number<T1, ExpressionTemplates>, T2>
{
   using type = number<T1, ExpressionTemplates>;
};

template <class T1, class T2, expression_template_option ExpressionTemplates>
struct combine_expression<T1, number<T2, ExpressionTemplates> >
{
   using type = number<T2, ExpressionTemplates>;
};

template <class T, expression_template_option ExpressionTemplates>
struct combine_expression<number<T, ExpressionTemplates>, number<T, ExpressionTemplates> >
{
   using type = number<T, ExpressionTemplates>;
};

template <class T1, expression_template_option ExpressionTemplates1, class T2, expression_template_option ExpressionTemplates2>
struct combine_expression<number<T1, ExpressionTemplates1>, number<T2, ExpressionTemplates2> >
{
   using type = typename std::conditional<
       std::is_convertible<number<T2, ExpressionTemplates2>, number<T1, ExpressionTemplates2> >::value,
       number<T1, ExpressionTemplates1>,
       number<T2, ExpressionTemplates2> >::type;
};

template <class T>
struct arg_type
{
   using type = expression<terminal, T>;
};

template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct arg_type<expression<Tag, Arg1, Arg2, Arg3, Arg4> >
{
   using type = expression<Tag, Arg1, Arg2, Arg3, Arg4>;
};

struct unmentionable
{
   unmentionable* proc() { return nullptr; }
};

typedef unmentionable* (unmentionable::*unmentionable_type)();

template <class T, bool b>
struct expression_storage_base
{
   using type = const T&;
};

template <class T>
struct expression_storage_base<T, true>
{
   using type = T;
};

template <class T>
struct expression_storage : public expression_storage_base<T, boost::multiprecision::detail::is_arithmetic<T>::value>
{};

template <class T>
struct expression_storage<T*>
{
   using type = T*;
};

template <class T>
struct expression_storage<const T*>
{
   using type = const T*;
};

template <class tag, class A1, class A2, class A3, class A4>
struct expression_storage<expression<tag, A1, A2, A3, A4> >
{
   using type = expression<tag, A1, A2, A3, A4>;
};

template <class tag, class Arg1>
struct expression<tag, Arg1, void, void, void>
{
   using arity = std::integral_constant<int, 1>                   ;
   using left_type = typename arg_type<Arg1>::type  ;
   using left_result_type = typename left_type::result_type;
   using result_type = typename left_type::result_type;
   using tag_type = tag                            ;

   explicit BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a) : arg(a) {}
   BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg(e.arg) {}

   //
   // If we have static_assert we can give a more useful error message
   // than if we simply have no operator defined at all:
   //
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR left_type left() const
   {
      return left_type(arg);
   }

   BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg; }

   static constexpr unsigned depth = left_type::depth + 1;
   template <class T
#ifndef __SUNPRO_CC
             ,
             typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0
#endif
             >
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return static_cast<T>(static_cast<result_type>(*this));
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      result_type r(*this);
      return static_cast<bool>(r);
   }

   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to()
   {
      result_type r(*this);
      return r.template convert_to<T>();
   }

 private:
   typename expression_storage<Arg1>::type arg;
   expression&                             operator=(const expression&);
};

template <class Arg1>
struct expression<terminal, Arg1, void, void, void>
{
   using arity = std::integral_constant<int, 0>;
   using result_type = Arg1        ;
   using tag_type = terminal    ;

   explicit BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a) : arg(a) {}
   BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg(e.arg) {}

   //
   // If we have static_assert we can give a more useful error message
   // than if we simply have no operator defined at all:
   //
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR const Arg1& value() const noexcept
   {
      return arg;
   }

   static constexpr unsigned depth = 0;

   template <class T
#ifndef __SUNPRO_CC
             ,
             typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0
#endif
             >
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return static_cast<T>(static_cast<result_type>(*this));
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      result_type r(*this);
      return static_cast<bool>(r);
   }

   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to()
   {
      result_type r(*this);
      return r.template convert_to<T>();
   }

 private:
   typename expression_storage<Arg1>::type arg;
   expression&                             operator=(const expression&);
};

template <class tag, class Arg1, class Arg2>
struct expression<tag, Arg1, Arg2, void, void>
{
   using arity = std::integral_constant<int, 2>                                                          ;
   using left_type = typename arg_type<Arg1>::type                                         ;
   using right_type = typename arg_type<Arg2>::type                                         ;
   using left_result_type = typename left_type::result_type                                       ;
   using right_result_type = typename right_type::result_type                                      ;
   using result_type = typename combine_expression<left_result_type, right_result_type>::type;
   using tag_type = tag                                                                   ;

   BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2) : arg1(a1), arg2(a2) {}
   BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2) {}

   //
   // If we have static_assert we can give a more useful error message
   // than if we simply have no operator defined at all:
   //
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR left_type left() const
   {
      return left_type(arg1);
   }
   BOOST_MP_CXX14_CONSTEXPR right_type  right() const { return right_type(arg2); }
   BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg1; }
   BOOST_MP_CXX14_CONSTEXPR const Arg2& right_ref() const noexcept { return arg2; }

   template <class T
#ifndef __SUNPRO_CC
             ,
             typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0
#endif
             >
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return static_cast<T>(static_cast<result_type>(*this));
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      result_type r(*this);
      return static_cast<bool>(r);
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to()
   {
      result_type r(*this);
      return r.template convert_to<T>();
   }

   static const constexpr unsigned                left_depth  = left_type::depth + 1;
   static const constexpr unsigned                right_depth = right_type::depth + 1;
   static const constexpr unsigned                depth       = left_depth > right_depth ? left_depth : right_depth;

 private:
   typename expression_storage<Arg1>::type arg1;
   typename expression_storage<Arg2>::type arg2;
   expression&                             operator=(const expression&);
};

template <class tag, class Arg1, class Arg2, class Arg3>
struct expression<tag, Arg1, Arg2, Arg3, void>
{
   using arity = std::integral_constant<int, 3>                     ;
   using left_type = typename arg_type<Arg1>::type    ;
   using middle_type = typename arg_type<Arg2>::type    ;
   using right_type = typename arg_type<Arg3>::type    ;
   using left_result_type = typename left_type::result_type  ;
   using middle_result_type = typename middle_type::result_type;
   using right_result_type = typename right_type::result_type ;
   using result_type = typename combine_expression<
       left_result_type,
       typename combine_expression<right_result_type, middle_result_type>::type>::type;
   using tag_type = tag                                                                        ;

   BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2, const Arg3& a3) : arg1(a1), arg2(a2), arg3(a3) {}
   BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2), arg3(e.arg3) {}

   //
   // If we have static_assert we can give a more useful error message
   // than if we simply have no operator defined at all:
   //
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR left_type left() const
   {
      return left_type(arg1);
   }
   BOOST_MP_CXX14_CONSTEXPR middle_type middle() const { return middle_type(arg2); }
   BOOST_MP_CXX14_CONSTEXPR right_type  right() const { return right_type(arg3); }
   BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg1; }
   BOOST_MP_CXX14_CONSTEXPR const Arg2& middle_ref() const noexcept { return arg2; }
   BOOST_MP_CXX14_CONSTEXPR const Arg3& right_ref() const noexcept { return arg3; }

   template <class T
#ifndef __SUNPRO_CC
             ,
             typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0
#endif
             >
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return static_cast<T>(static_cast<result_type>(*this));
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      result_type r(*this);
      return static_cast<bool>(r);
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to()
   {
      result_type r(*this);
      return r.template convert_to<T>();
   }

   static constexpr unsigned left_depth   = left_type::depth + 1;
   static constexpr unsigned middle_depth = middle_type::depth + 1;
   static constexpr unsigned right_depth  = right_type::depth + 1;
   static constexpr unsigned depth        = left_depth > right_depth ? (left_depth > middle_depth ? left_depth : middle_depth) : (right_depth > middle_depth ? right_depth : middle_depth);

 private:
   typename expression_storage<Arg1>::type arg1;
   typename expression_storage<Arg2>::type arg2;
   typename expression_storage<Arg3>::type arg3;
   expression&                             operator=(const expression&);
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct expression
{
   using arity = std::integral_constant<int, 4>                           ;
   using left_type = typename arg_type<Arg1>::type          ;
   using left_middle_type = typename arg_type<Arg2>::type          ;
   using right_middle_type = typename arg_type<Arg3>::type          ;
   using right_type = typename arg_type<Arg4>::type          ;
   using left_result_type = typename left_type::result_type        ;
   using left_middle_result_type = typename left_middle_type::result_type ;
   using right_middle_result_type = typename right_middle_type::result_type;
   using right_result_type = typename right_type::result_type       ;
   using result_type = typename combine_expression<
       left_result_type,
       typename combine_expression<
           left_middle_result_type,
           typename combine_expression<right_middle_result_type, right_result_type>::type>::type>::type;
   using tag_type = tag                                                                                         ;

   BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) : arg1(a1), arg2(a2), arg3(a3), arg4(a4) {}
   BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2), arg3(e.arg3), arg4(e.arg4) {}

   //
   // If we have static_assert we can give a more useful error message
   // than if we simply have no operator defined at all:
   //
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator++(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--()
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR expression& operator--(int)
   {
      // This should always fail:
      static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }
   template <class Other>
   BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&)
   {
      // This should always fail:
      static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable?  Or pass an expression to a template function with deduced temnplate arguments?");
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR left_type left() const
   {
      return left_type(arg1);
   }
   BOOST_MP_CXX14_CONSTEXPR left_middle_type  left_middle() const { return left_middle_type(arg2); }
   BOOST_MP_CXX14_CONSTEXPR right_middle_type right_middle() const { return right_middle_type(arg3); }
   BOOST_MP_CXX14_CONSTEXPR right_type        right() const { return right_type(arg4); }
   BOOST_MP_CXX14_CONSTEXPR const Arg1&       left_ref() const noexcept { return arg1; }
   BOOST_MP_CXX14_CONSTEXPR const Arg2&       left_middle_ref() const noexcept { return arg2; }
   BOOST_MP_CXX14_CONSTEXPR const Arg3&       right_middle_ref() const noexcept { return arg3; }
   BOOST_MP_CXX14_CONSTEXPR const Arg4&       right_ref() const noexcept { return arg4; }

   template <class T
#ifndef __SUNPRO_CC
             ,
             typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0
#endif
             >
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return static_cast<T>(static_cast<result_type>(*this));
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      result_type r(*this);
      return static_cast<bool>(r);
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to()
   {
      result_type r(*this);
      return r.template convert_to<T>();
   }

   static constexpr unsigned left_depth         = left_type::depth + 1;
   static constexpr unsigned left_middle_depth  = left_middle_type::depth + 1;
   static constexpr unsigned right_middle_depth = right_middle_type::depth + 1;
   static constexpr unsigned right_depth        = right_type::depth + 1;

   static constexpr unsigned left_max_depth  = left_depth > left_middle_depth ? left_depth : left_middle_depth;
   static constexpr unsigned right_max_depth = right_depth > right_middle_depth ? right_depth : right_middle_depth;

   static constexpr unsigned depth = left_max_depth > right_max_depth ? left_max_depth : right_max_depth;

 private:
   typename expression_storage<Arg1>::type arg1;
   typename expression_storage<Arg2>::type arg2;
   typename expression_storage<Arg3>::type arg3;
   typename expression_storage<Arg4>::type arg4;
   expression&                             operator=(const expression&);
};

template <class T>
struct digits2
{
   static_assert(std::numeric_limits<T>::is_specialized, "numeric_limits must be specialized here");
   static_assert((std::numeric_limits<T>::radix == 2) || (std::numeric_limits<T>::radix == 10), "Failed radix check");
   // If we really have so many digits that this fails, then we're probably going to hit other problems anyway:
   static_assert(LONG_MAX / 1000 > (std::numeric_limits<T>::digits + 1), "Too many digits to cope with here");
   static constexpr long  m_value = std::numeric_limits<T>::radix == 10 ? (((std::numeric_limits<T>::digits + 1) * 1000L) / 301L) : std::numeric_limits<T>::digits;
   static inline constexpr long value() noexcept { return m_value; }
};

#ifndef BOOST_MP_MIN_EXPONENT_DIGITS
#ifdef _MSC_VER
#define BOOST_MP_MIN_EXPONENT_DIGITS 2
#else
#define BOOST_MP_MIN_EXPONENT_DIGITS 2
#endif
#endif

template <class S>
void format_float_string(S& str, std::intmax_t my_exp, std::intmax_t digits, std::ios_base::fmtflags f, bool iszero)
{
   using size_type = typename S::size_type;

   bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
   bool fixed      = (f & std::ios_base::fixed) == std::ios_base::fixed;
   bool showpoint  = (f & std::ios_base::showpoint) == std::ios_base::showpoint;
   bool showpos    = (f & std::ios_base::showpos) == std::ios_base::showpos;

   bool neg = str.size() && (str[0] == '-');

   if (neg)
      str.erase(0, 1);

   if (digits == 0 && !fixed)
   {
      digits = static_cast<std::intmax_t>((std::max)(str.size(), size_type(16)));
   }

   if (iszero || str.empty() || (str.find_first_not_of('0') == S::npos))
   {
      // We will be printing zero, even though the value might not
      // actually be zero (it just may have been rounded to zero).
      str = "0";
      if (scientific || fixed)
      {
         if (showpoint || digits > 0) {
            str.append(1, '.');
            if (digits > 0)
               str.append(size_type(digits), '0');
         }
         if (scientific)
            str.append("e+00");
      }
      else
      {
         if (showpoint)
         {
            str.append(1, '.');
            if (digits > 1)
               str.append(size_type(digits - 1), '0');
         }
      }
      if (neg)
         str.insert(static_cast<std::string::size_type>(0), 1, '-');
      else if (showpos)
         str.insert(static_cast<std::string::size_type>(0), 1, '+');
      return;
   }

   if (!fixed && !scientific && !showpoint)
   {
      //
      // Suppress trailing zeros:
      //
      std::string::iterator pos = str.end();
      while (pos != str.begin() && *--pos == '0')
      {
      }
      if (pos != str.end())
         ++pos;
      str.erase(pos, str.end());
      if (str.empty())
         str = '0';
   }
   else if (!fixed || (my_exp >= 0))
   {
      //
      // Pad out the end with zero's if we need to:
      //
      std::intmax_t chars = static_cast<std::intmax_t>(str.size());
      chars                 = digits - chars;
      if (scientific)
         ++chars;
      if (chars > 0)
      {
         str.append(static_cast<std::string::size_type>(chars), '0');
      }
   }

   if (fixed || (!scientific && (my_exp >= -4) && (my_exp < digits)))
   {
      if (1 + my_exp > static_cast<std::intmax_t>(str.size()))
      {
         // Just pad out the end with zeros:
         str.append(static_cast<std::string::size_type>(1 + my_exp - static_cast<std::intmax_t>(str.size())), '0');
         if (showpoint || (fixed && digits > 0))
            str.append(".");
      }
      else if (my_exp + 1 < static_cast<std::intmax_t>(str.size()))
      {
         if (my_exp < 0)
         {
            str.insert(static_cast<std::string::size_type>(0), static_cast<std::string::size_type>(-1 - my_exp), '0');
            str.insert(static_cast<std::string::size_type>(0), "0.");
         }
         else
         {
            // Insert the decimal point:
            str.insert(static_cast<std::string::size_type>(my_exp + 1), 1, '.');
         }
      }
      else if (showpoint || (fixed && digits > 0)) // we have exactly the digits we require to left of the point
         str += ".";

      if (fixed)
      {
         // We may need to add trailing zeros:
         auto pos = str.find('.');
         if (pos != str.npos) { // this test is probably redundant, but just to be safe and for clarity
            std::intmax_t l = static_cast<std::intmax_t>(pos + 1);
            l               = static_cast<std::intmax_t>(digits - (static_cast<std::intmax_t>(str.size()) - l));
            if (l > 0)
               str.append(size_type(l), '0');
         }
      }
   }
   else
   {
      BOOST_MP_USING_ABS
      // Scientific format:
      if (showpoint || (str.size() > 1))
         str.insert(static_cast<std::string::size_type>(1u), 1, '.');
      str.append(static_cast<std::string::size_type>(1u), 'e');

      S e;

      #ifndef BOOST_MP_STANDALONE
      e = boost::lexical_cast<S>(abs(my_exp));
      #else
      BOOST_IF_CONSTEXPR(std::is_same<S, std::string>::value)
      {
         e = std::to_string(abs(my_exp));
      }
      else
      {
         const std::string str_local_exp = std::to_string(abs(my_exp));
         e = S(str_local_exp.cbegin(), str_local_exp.cend());
      }
      #endif

      if (e.size() < BOOST_MP_MIN_EXPONENT_DIGITS)
         e.insert(static_cast<std::string::size_type>(0), BOOST_MP_MIN_EXPONENT_DIGITS - e.size(), '0');
      if (my_exp < 0)
         e.insert(static_cast<std::string::size_type>(0), 1, '-');
      else
         e.insert(static_cast<std::string::size_type>(0), 1, '+');
      str.append(e);
   }
   if (neg)
      str.insert(static_cast<std::string::size_type>(0), 1, '-');
   else if (showpos)
      str.insert(static_cast<std::string::size_type>(0), 1, '+');
}

template <class V>
BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&)
{
   if (val > (std::numeric_limits<std::size_t>::max)())
      BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max()."));
   if (val < 0)
      BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value."));
}
template <class V>
BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&)
{
   if (val < 0)
      BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value."));
}
template <class V>
BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&)
{
   if (val > (std::numeric_limits<std::size_t>::max)())
      BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max()."));
}
template <class V>
BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&) noexcept {}

template <class T>
BOOST_MP_CXX14_CONSTEXPR const T& evaluate_if_expression(const T& val) { return val; }
template <class T>
BOOST_MP_CXX14_CONSTEXPR T&& evaluate_if_expression(T&& val) { return static_cast<T&&>(val); }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
BOOST_MP_CXX14_CONSTEXPR typename expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type evaluate_if_expression(const expression<tag, Arg1, Arg2, Arg3, Arg4>& val) { return val; }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
BOOST_MP_CXX14_CONSTEXPR typename expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type evaluate_if_expression(expression<tag, Arg1, Arg2, Arg3, Arg4>&& val) { return val; }

template <class T>
struct convertible_to
{
   operator T () const;
};

} // namespace detail

//
// Traits class, lets us know what kind of number we have, defaults to a floating point type:
//
enum number_category_type
{
   number_kind_unknown        = -1,
   number_kind_integer        = 0,
   number_kind_floating_point = 1,
   number_kind_rational       = 2,
   number_kind_fixed_point    = 3,
   number_kind_complex        = 4
};

template <class Num, bool, bool>
struct number_category_base : public std::integral_constant<int, number_kind_unknown>
{};
template <class Num>
struct number_category_base<Num, true, false> : public std::integral_constant<int, std::numeric_limits<Num>::is_integer ? number_kind_integer : (std::numeric_limits<Num>::max_exponent ? number_kind_floating_point : number_kind_unknown)>
{};
template <class Num>
struct number_category : public number_category_base<Num, std::is_class<Num>::value || boost::multiprecision::detail::is_arithmetic<Num>::value, std::is_abstract<Num>::value>
{};
template <class Backend, expression_template_option ExpressionTemplates>
struct number_category<number<Backend, ExpressionTemplates> > : public number_category<Backend>
{};
template <class tag, class A1, class A2, class A3, class A4>
struct number_category<detail::expression<tag, A1, A2, A3, A4> > : public number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type>
{};
//
// Specializations for types which do not always have numberic_limits specializations:
//
#ifdef BOOST_HAS_INT128
template <>
struct number_category<boost::multiprecision::int128_type> : public std::integral_constant<int, number_kind_integer>
{};
template <>
struct number_category<boost::multiprecision::uint128_type> : public std::integral_constant<int, number_kind_integer>
{};
#endif
#ifdef BOOST_HAS_FLOAT128
template <>
struct number_category<boost::multiprecision::float128_type> : public std::integral_constant<int, number_kind_floating_point>
{};
#endif

template <class T>
struct component_type
{
   using type = T;
};
template <class tag, class A1, class A2, class A3, class A4>
struct component_type<detail::expression<tag, A1, A2, A3, A4> > : public component_type<typename detail::expression<tag, A1, A2, A3, A4>::result_type>
{};

template <class T>
struct scalar_result_from_possible_complex
{
   using type = typename std::conditional<number_category<T>::value == number_kind_complex, typename component_type<T>::type, T>::type;
};

template <class T>
struct complex_result_from_scalar; // individual backends must specialize this trait.

template <class T>
struct is_unsigned_number : public std::integral_constant<bool, false>
{};
template <class Backend, expression_template_option ExpressionTemplates>
struct is_unsigned_number<number<Backend, ExpressionTemplates> > : public is_unsigned_number<Backend>
{};
template <class T>
struct is_signed_number : public std::integral_constant<bool, !is_unsigned_number<T>::value>
{};
template <class T>
struct is_interval_number : public std::integral_constant<bool, false>
{};
template <class Backend, expression_template_option ExpressionTemplates>
struct is_interval_number<number<Backend, ExpressionTemplates> > : public is_interval_number<Backend>
{};

template <class T, class U>
struct is_equivalent_number_type : public std::is_same<T, U>
{};

template <class Backend, expression_template_option ExpressionTemplates, class T2>
struct is_equivalent_number_type<number<Backend, ExpressionTemplates>, T2> : public is_equivalent_number_type<Backend, T2>
{};
template <class T1, class Backend, expression_template_option ExpressionTemplates>
struct is_equivalent_number_type<T1, number<Backend, ExpressionTemplates> > : public is_equivalent_number_type<Backend, T1>
{};
template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
struct is_equivalent_number_type<number<Backend, ExpressionTemplates>, number<Backend2, ExpressionTemplates2> > : public is_equivalent_number_type<Backend, Backend2>
{};

}
} // namespace boost

#ifdef BOOST_MP_MATH_AVAILABLE
namespace boost { namespace math {
   namespace tools {

      template <class T>
      struct promote_arg;

      template <class tag, class A1, class A2, class A3, class A4>
      struct promote_arg<boost::multiprecision::detail::expression<tag, A1, A2, A3, A4> >
      {
         using type = typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
      };

      template <class R, class B, boost::multiprecision::expression_template_option ET>
      inline R real_cast(const boost::multiprecision::number<B, ET>& val)
      {
         return val.template convert_to<R>();
      }

      template <class R, class tag, class A1, class A2, class A3, class A4>
      inline R real_cast(const boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>& val)
      {
         using val_type = typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
         return val_type(val).template convert_to<R>();
      }

      template <class B, boost::multiprecision::expression_template_option ET>
      struct is_complex_type<boost::multiprecision::number<B, ET> > : public std::integral_constant<bool, boost::multiprecision::number_category<B>::value == boost::multiprecision::number_kind_complex> {};

} // namespace tools

namespace constants {

template <class T>
struct is_explicitly_convertible_from_string;

template <class B, boost::multiprecision::expression_template_option ET>
struct is_explicitly_convertible_from_string<boost::multiprecision::number<B, ET> >
{
   static constexpr bool value = true;
};

} // namespace constants

}} // namespace boost::math
#endif

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#endif // BOOST_MP_NUMBER_BASE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/number_compare.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_NUMBER_COMPARE_HPP
#define BOOST_MP_NUMBER_COMPARE_HPP

#include <boost/multiprecision/traits/is_backend.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>

//
// Comparison operators for number.
//

namespace boost { namespace multiprecision {

namespace default_ops {

//
// The dispatching mechanism used here to deal with differently typed arguments
// could be better replaced with enable_if overloads, but that breaks MSVC-12
// under strange and hard to reproduce circumstances.
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq(const B& a, const B& b)
{
   return a.compare(b) == 0;
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq_imp(const T& a, const U& b, const std::integral_constant<bool, true>&)
{
   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
   return eval_eq(a, t.backend());
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq_imp(const T& a, const U& b, const std::integral_constant<bool, false>&)
{
   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
   return eval_eq(t.backend(), b);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq(const T& a, const U& b)
{
   using tag_type = std::integral_constant<bool, boost::multiprecision::detail::is_first_backend<T, U>::value>;
   return eval_eq_imp(a, b, tag_type());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const B& a, const B& b)
{
   return a.compare(b) < 0;
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt_imp(const T& a, const U& b, const std::integral_constant<bool, true>&)
{
   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
   return eval_lt(a, t.backend());
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt_imp(const T& a, const U& b, const std::integral_constant<bool, false>&)
{
   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
   return eval_lt(t.backend(), b);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const T& a, const U& b)
{
   using tag_type = std::integral_constant<bool, boost::multiprecision::detail::is_first_backend<T, U>::value>;
   return eval_lt_imp(a, b, tag_type());
}

template <class B>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const B& a, const B& b)
{
   return a.compare(b) > 0;
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt_imp(const T& a, const U& b, const std::integral_constant<bool, true>&)
{
   typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
   return eval_gt(a, t.backend());
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt_imp(const T& a, const U& b, const std::integral_constant<bool, false>&)
{
   typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
   return eval_gt(t.backend(), b);
}
template <class T, class U>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const T& a, const U& b)
{
   using tag_type = std::integral_constant<bool, boost::multiprecision::detail::is_first_backend<T, U>::value>;
   return eval_gt_imp(a, b, tag_type());
}

} // namespace default_ops

namespace detail {

template <class Num, class Val>
struct is_valid_mixed_compare : public std::integral_constant<bool, false>
{};

template <class B, expression_template_option ET, class Val>
struct is_valid_mixed_compare<number<B, ET>, Val> : public std::is_convertible<Val, number<B, ET> >
{};

template <class B, expression_template_option ET>
struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public std::integral_constant<bool, false>
{};

template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> >
    : public std::is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
{};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
    : public std::is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
{};

template <class Backend, expression_template_option ExpressionTemplates>
inline constexpr typename std::enable_if<number_category<Backend>::value != number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>&)
{
   return false;
}
template <class Backend, expression_template_option ExpressionTemplates>
inline constexpr typename std::enable_if<number_category<Backend>::value == number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>& a)
{
   using default_ops::eval_fpclassify;
   return eval_fpclassify(a.backend()) == FP_NAN;
}

template <class Arithmetic>
inline constexpr typename std::enable_if<number_category<Arithmetic>::value != number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic&)
{
   return false;
}
template <class Arithmetic>
inline 
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
    BOOST_MP_CXX14_CONSTEXPR 
#endif
   typename std::enable_if < number_category < Arithmetic> ::value == number_kind_floating_point, bool> ::type
    is_unordered_value(const Arithmetic& a)
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(a))
   {
      return a != a;
   }
   else
#endif
   {
      return BOOST_MP_ISNAN(a);
   }
}

template <class T, class U>
inline constexpr bool is_unordered_comparison(const T& a, const U& b)
{
   return is_unordered_value(a) || is_unordered_value(b);
}

} // namespace detail

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool operator==(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_eq(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && !is_number_expression<Arithmetic>::value, bool>::type
operator==(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && !is_number_expression<Arithmetic>::value, bool>::type
operator==(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_eq(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
operator==(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return false;
   return eval_eq(t.backend(), result_type::canonical_value(a));
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator==(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return false;
   return eval_eq(t.backend(), a.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
operator==(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return false;
   return eval_eq(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator==(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return false;
   return eval_eq(t.backend(), b.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
operator==(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_eq;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   if (detail::is_unordered_comparison(t, t2))
      return false;
   return eval_eq(t.backend(), t2.backend());
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool operator!=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return true;
   return !eval_eq(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && !is_number_expression<Arithmetic>::value, bool>::type
operator!=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return true;
   return !eval_eq(a.backend(), number<Backend, et_on>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && !is_number_expression<Arithmetic>::value, bool>::type
operator!=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_eq;
   if (detail::is_unordered_comparison(a, b))
      return true;
   return !eval_eq(b.backend(), number<Backend, et_on>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
operator!=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return true;
   return !eval_eq(t.backend(), result_type::canonical_value(a));
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator!=(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return true;
   return !eval_eq(t.backend(), a.backend());
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
operator!=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return true;
   return !eval_eq(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator!=(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_eq;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return true;
   return !eval_eq(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
operator!=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_eq;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   if (detail::is_unordered_comparison(t, t2))
      return true;
   return !eval_eq(t.backend(), t2.backend());
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
operator<(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_lt(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator<(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator<(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return false;
   return eval_gt(t.backend(), result_type::canonical_value(a));
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator<(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(b);
   return a < t;
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return false;
   return eval_lt(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator<(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(a);
   return t < b;
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_lt;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   if (detail::is_unordered_comparison(t, t2))
      return false;
   return eval_lt(t.backend(), t2.backend());
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
operator>(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_gt(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator>(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator>(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(b);
   return a > t;
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator>(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(b);
   return a > t;
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(a);
   return t > b;
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator>(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(a);
   return t > b;
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_gt;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   return t > t2;
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
operator<=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_gt(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator<=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator<=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   if (detail::is_unordered_value(a) || detail::is_unordered_value(b))
      return false;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return false;
   return !eval_lt(t.backend(), result_type::canonical_value(a));
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator<=(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   if (detail::is_unordered_value(a) || detail::is_unordered_value(b))
      return false;
   result_type t(b);
   return a <= t;
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return false;
   return !eval_gt(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator<=(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(a);
   return t <= b;
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator<=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_gt;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   if (detail::is_unordered_comparison(t, t2))
      return false;
   return !eval_gt(t.backend(), t2.backend());
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(number_category<Backend>::value != number_kind_complex) && (number_category<Backend2>::value != number_kind_complex), bool>::type
operator>=(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_lt(a.backend(), b.backend());
}
template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator>=(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   using default_ops::eval_lt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
}
template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value && (number_category<Backend>::value != number_kind_complex) && !is_number_expression<Arithmetic>::value, bool>::type
operator>=(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   using default_ops::eval_gt;
   if (detail::is_unordered_comparison(a, b))
      return false;
   return !eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
}
template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>=(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(b);
   if (detail::is_unordered_comparison(a, t))
      return false;
   return !eval_gt(t.backend(), result_type::canonical_value(a));
}
template <class Backend, expression_template_option ExpressionTemplates, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR bool operator>=(const number<Backend, ExpressionTemplates>& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_gt;
   result_type t(b);
   return a >= t;
}
template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>=(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(a);
   if (detail::is_unordered_comparison(t, b))
      return false;
   return !eval_lt(t.backend(), result_type::canonical_value(b));
}
template <class Tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR bool operator>=(const detail::expression<Tag, A1, A2, A3, A4>& a, const number<Backend, ExpressionTemplates>& b)
{
   using result_type = typename detail::expression<Tag, A1, A2, A3, A4>::result_type;
   using default_ops::eval_lt;
   result_type t(a);
   return t >= b;
}
template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value && (number_category<typename detail::expression<Tag, A1, A2, A3, A4>::result_type>::value != number_kind_complex), bool>::type
operator>=(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
{
   using default_ops::eval_lt;
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      t(a);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
   if (detail::is_unordered_comparison(t, t2))
      return false;
   return !eval_lt(t.backend(), t2.backend());
}

//
// C99 comparison macros as functions:
//
template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool isgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a > b; }

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a > b; }

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a > b; }

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a > b; }

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a > b; }

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    isgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a > b; }

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a >= b; }

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isgreaterequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a >= b; }

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isgreaterequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a >= b; }

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isgreaterequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a >= b; }

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isgreaterequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a >= b; }

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    isgreaterequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a >= b; }

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool islessequal BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a <= b; }

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    islessequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a <= b; }

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    islessequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a <= b; }

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    islessequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a <= b; }

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    islessequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a <= b; }

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    islessequal
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a <= b; }

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool isless BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return a < b; }

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isless
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return a < b; }

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isless
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return a < b; }

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isless
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b) { return a < b; }

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isless
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b) { return a < b; }

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    isless
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b) { return a < b; }

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
{
   if (detail::is_unordered_comparison(a, b))
      return false;
   return a != b;
}

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    islessgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
{
   if (detail::is_unordered_comparison(a, b))
      return false;
   return a != b;
}

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    islessgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
{
   if (detail::is_unordered_comparison(a, b))
      return false;
   return a != b;
}

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    islessgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& bb)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type b(bb);
   return islessgreater                                          BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
}

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    islessgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const Arithmetic& b)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
   return islessgreater                                          BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
}

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    islessgreater
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& bb)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      a(aa);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type b(bb);
   return islessgreater                                               BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
}

template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
inline BOOST_MP_CXX14_CONSTEXPR bool isunordered BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b) { return detail::is_unordered_comparison(a, b); }

template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isunordered
    BOOST_PREVENT_MACRO_SUBSTITUTION(const number<Backend, ExpressionTemplates>& a, const Arithmetic& b) { return detail::is_unordered_comparison(a, b); }

template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
    isunordered
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const number<Backend, ExpressionTemplates>& b) { return detail::is_unordered_comparison(a, b); }

template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isunordered
    BOOST_PREVENT_MACRO_SUBSTITUTION(const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& bb)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type b(bb);
   return detail::is_unordered_comparison(a, b);
}

template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
    isunordered
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const Arithmetic& b)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type a(aa);
   return detail::is_unordered_comparison(a, b);
}

template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_equivalent_number_type<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>::value, bool>::type
    isunordered
    BOOST_PREVENT_MACRO_SUBSTITUTION(const detail::expression<Tag, A1, A2, A3, A4>& aa, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& bb)
{
   typename detail::expression<Tag, A1, A2, A3, A4>::result_type      a(aa);
   typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type b(bb);
   return detail::is_unordered_comparison(a, b);
}

}} // namespace boost::multiprecision

#endif // BOOST_MP_NUMBER_COMPARE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/precision.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_DETAIL_PRECISION_HPP
#define BOOST_MP_DETAIL_PRECISION_HPP

#include <boost/multiprecision/traits/is_variable_precision.hpp>
#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class B, boost::multiprecision::expression_template_option ET>
inline constexpr unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>&, const std::integral_constant<int, 0>&)
{
   return std::numeric_limits<boost::multiprecision::number<B, ET> >::digits10;
}
template <class B, boost::multiprecision::expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<int, 1>&)
{
   //
   // We have an arbitrary precision integer, take it's "precision" as the
   // location of the most-significant-bit less the location of the
   // least-significant-bit, ie the number of bits required to represent the
   // the value assuming we will have an exponent to shift things by:
   //
   return static_cast<unsigned>(val.is_zero() ? 1 : 1 + digits2_2_10(msb(abs(val)) - lsb(abs(val)) + 1));
}
template <class B, boost::multiprecision::expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<int, 2>&)
{
   //
   // We have an arbitrary precision rational, take it's "precision" as the
   // the larger of the "precision" of numerator and denominator:
   //
   return (std::max)(current_precision_of_last_chance_imp(numerator(val), std::integral_constant<int, 1>()), current_precision_of_last_chance_imp(denominator(val), std::integral_constant<int, 1>()));
}

template <class B, boost::multiprecision::expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::integral_constant<bool, true>&)
{
   return n.precision();
}
template <class B, boost::multiprecision::expression_template_option ET>
inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<bool, false>&)
{
   using tag = std::integral_constant<int,
                                      std::numeric_limits<boost::multiprecision::number<B, ET> >::is_specialized &&
                                              std::numeric_limits<boost::multiprecision::number<B, ET> >::is_integer &&
                                              std::numeric_limits<boost::multiprecision::number<B, ET> >::is_exact &&
                                              !std::numeric_limits<boost::multiprecision::number<B, ET> >::is_modulo
                                          ? 1
                                      : boost::multiprecision::number_category<boost::multiprecision::number<B, ET> >::value == boost::multiprecision::number_kind_rational ? 2
                                                                                                                                                                            : 0>;
   return current_precision_of_last_chance_imp(val, tag());
}

template <class R, class Terminal>
inline constexpr unsigned current_precision_of_terminal(const Terminal&)
{
   return (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) 
      ? (std::numeric_limits<Terminal>::min_exponent ? std::numeric_limits<Terminal>::digits10 : 1 + std::numeric_limits<Terminal>::digits10) : 0;
}
template <class R, class Terminal>
inline constexpr unsigned current_precision_of(const Terminal& r)
{
   return current_precision_of_terminal<R>(R::canonical_value(r));
}
template <class R>
inline constexpr unsigned current_precision_of(const float&)
{
   using list = typename R::backend_type::float_types;
   using first_float = typename std::tuple_element<0, list>::type;

   return (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) ? std::numeric_limits<first_float>::digits10 : 0;
}

template <class R, class Terminal, std::size_t N>
inline constexpr unsigned current_precision_of(const Terminal (&)[N])
{ // For string literals:
   return 0;
}

template <class R, class B, boost::multiprecision::expression_template_option ET>
inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::true_type&)
{
   return std::is_same<R, boost::multiprecision::number<B, ET> >::value 
      || (std::is_same<typename R::value_type, boost::multiprecision::number<B, ET> >::value && (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_component_precision))
      || (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) 
      ? current_precision_of_imp(n, boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<B, ET> >()) : 0;
}
template <class R, class B, boost::multiprecision::expression_template_option ET>
inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::false_type&)
{
   return std::is_same<R, boost::multiprecision::number<B, ET> >::value 
      || std::is_same<typename R::value_type, boost::multiprecision::number<B, ET> >::value
      ? current_precision_of_imp(n, boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<B, ET> >()) : 0;
}

template <class R, class B, boost::multiprecision::expression_template_option ET>
inline constexpr unsigned current_precision_of(const boost::multiprecision::number<B, ET>& n)
{
   return current_precision_of_imp<R>(n, boost::multiprecision::detail::is_variable_precision<R>());
}

template <class R, class tag, class Arg1>
inline constexpr unsigned current_precision_of(const expression<tag, Arg1, void, void, void>& expr)
{
   return current_precision_of<R>(expr.left_ref());
}

template <class R, class Arg1>
inline constexpr unsigned current_precision_of(const expression<terminal, Arg1, void, void, void>& expr)
{
   return current_precision_of<R>(expr.value());
}

template <class R, class tag, class Arg1, class Arg2>
inline constexpr unsigned current_precision_of(const expression<tag, Arg1, Arg2, void, void>& expr)
{
   return (std::max)(current_precision_of<R>(expr.left_ref()), current_precision_of<R>(expr.right_ref()));
}

template <class R, class tag, class Arg1, class Arg2, class Arg3>
inline constexpr unsigned current_precision_of(const expression<tag, Arg1, Arg2, Arg3, void>& expr)
{
   return (std::max)((std::max)(current_precision_of<R>(expr.left_ref()), current_precision_of<R>(expr.right_ref())), current_precision_of<R>(expr.middle_ref()));
}

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4130)
#endif

template <class R, bool = boost::multiprecision::detail::is_variable_precision<R>::value>
struct scoped_default_precision
{
   template <class T>
   constexpr scoped_default_precision(const T&) {}
   template <class T, class U>
   constexpr scoped_default_precision(const T&, const U&) {}
   template <class T, class U, class V>
   constexpr scoped_default_precision(const T&, const U&, const V&) {}

   //
   // This function is never called: in C++17 it won't be compiled either:
   //
   unsigned precision() const
   {
      BOOST_MP_ASSERT("This function should never be called!!" == nullptr);
      return 0;
   }
};

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

template <class R>
struct scoped_default_precision<R, true>
{
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a)
   {
      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)(R::thread_default_precision(), current_precision_of<R>(a)));
   }
   template <class T, class U>
   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a, const U& b)
   {
      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)(R::thread_default_precision(), (std::max)(current_precision_of<R>(a), current_precision_of<R>(b))));
   }
   template <class T, class U, class V>
   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a, const U& b, const V& c)
   {
      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)((std::max)(current_precision_of<R>(a), current_precision_of<R>(b)), (std::max)(R::thread_default_precision(), current_precision_of<R>(c))));
   }
   ~scoped_default_precision()
   {
      if(m_new_prec != m_old_prec)
         R::thread_default_precision(m_old_prec);
   }
   BOOST_MP_CXX14_CONSTEXPR unsigned precision() const
   {
      return m_new_prec;
   }

   static constexpr bool has_uniform_precision()
   {
      return R::thread_default_variable_precision_options() <= boost::multiprecision::variable_precision_options::assume_uniform_precision;
   }

 private:
   BOOST_MP_CXX14_CONSTEXPR void init(unsigned p)
   {
      m_old_prec = R::thread_default_precision();
      if (p && (p != m_old_prec))
      {
         R::thread_default_precision(p);
         m_new_prec = p;
      }
      else
         m_new_prec = m_old_prec;
   }
   unsigned m_old_prec, m_new_prec;
};

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T*, const std::integral_constant<bool, false>&) {}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T* obj, const std::integral_constant<bool, true>&)
{
   if (obj->precision() != T::thread_default_precision())
   {
      obj->precision(T::thread_default_precision());
   }
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T* obj)
{
   maybe_promote_precision(obj, std::integral_constant<bool, boost::multiprecision::detail::is_variable_precision<T>::value>());
}

#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
#define BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(T) \
   if                                               \
   constexpr(boost::multiprecision::detail::is_variable_precision<T>::value)
#else
#define BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(T) if (boost::multiprecision::detail::is_variable_precision<T>::value)
#endif

template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
struct scoped_target_precision
{
   variable_precision_options opts;
   scoped_target_precision() : opts(T::thread_default_variable_precision_options())
   {
      T::thread_default_variable_precision_options(variable_precision_options::preserve_target_precision);
   }
   ~scoped_target_precision()
   {
      T::thread_default_variable_precision_options(opts);
   }
};
template <class T>
struct scoped_target_precision<T, false> {};

template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
struct scoped_source_precision
{
   variable_precision_options opts;
   scoped_source_precision() : opts(T::thread_default_variable_precision_options())
   {
      T::thread_default_variable_precision_options(variable_precision_options::preserve_source_precision);
   }
   ~scoped_source_precision()
   {
      T::thread_default_variable_precision_options(opts);
   }
};
template <class T>
struct scoped_source_precision<T, false> {};

template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
struct scoped_precision_options
{
   unsigned saved_digits;
   boost::multiprecision::variable_precision_options saved_options;

   scoped_precision_options(unsigned digits) 
      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
   {
      T::thread_default_precision(digits);
   }
   scoped_precision_options(unsigned digits, variable_precision_options opts)
      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
   {
      T::thread_default_precision(digits);
      T::thread_default_variable_precision_options(opts);
   }
   template <class U>
   scoped_precision_options(const U& u)
      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
   {
      T::thread_default_precision(u.precision());
      T::thread_default_variable_precision_options(U::thread_default_variable_precision_options());
   }
   ~scoped_precision_options()
   {
      T::thread_default_variable_precision_options(saved_options);
      T::thread_default_precision(saved_digits);
   }
};

template <class T>
struct scoped_precision_options<T, false>
{
   scoped_precision_options(unsigned) {}
   scoped_precision_options(unsigned, variable_precision_options) {}
   template <class U>
   scoped_precision_options(const U&) {}
   ~scoped_precision_options() {}
};

}
}
} // namespace boost::multiprecision::detail

#endif // BOOST_MP_DETAIL_PRECISION_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/rebind.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock.
//  Copyright Christopher Kormanyos 2013. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_MP_DETAIL_REBIND_HPP
#define BOOST_MP_DETAIL_REBIND_HPP

namespace boost { namespace multiprecision { namespace backends { namespace detail {
template <class value_type, class my_allocator>
struct rebind
{
   using type = typename std::allocator_traits<my_allocator>::template rebind_alloc<value_type>;
};
}}}} // namespace boost::multiprecision::backends::detail

#endif // BOOST_MP_DETAIL_REBIND_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/standalone_config.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2010 - 2021 Douglas Gregor
//  Copyright 2021 Matt Borland.
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
//  Used to support configuration options depending on standalone context
//  by providing either required support or disabling functionality  

#ifndef BOOST_MP_STANDALONE_CONFIG_HPP
#define BOOST_MP_STANDALONE_CONFIG_HPP

#include <climits>

// Boost.Config is dependency free so it is considered a requirement to use Boost.Multiprecision in standalone mode
#ifdef __has_include
#  if __has_include(<boost/config.hpp>)
#    include <boost/config.hpp>
#    include <boost/config/workaround.hpp>
#  else
#    error "Boost.Config is considered a requirement to use Boost.Multiprecision in standalone mode. A package is provided at https://github.com/boostorg/multiprecision/releases"
#  endif
#else
// Provides the less helpful fatal error: 'boost/config.hpp' file not found if not available
#  include <boost/config.hpp>
#  include <boost/config/workaround.hpp>
#endif

// Minimum language standard transition
 #ifdef _MSVC_LANG
 #  if _MSVC_LANG < 201402L
 #    pragma warning("The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)");
 #  endif
 #else
 #  if __cplusplus < 201402L
 #    warning "The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)"
 #  endif
 #endif

// If any of the most frequently used boost headers are missing assume that standalone mode is supposed to be used
#ifdef __has_include
#if !__has_include(<boost/assert.hpp>) || !__has_include(<boost/lexical_cast.hpp>) || \
    !__has_include(<boost/throw_exception.hpp>) || !__has_include(<boost/predef/other/endian.h>)
#   ifndef BOOST_MP_STANDALONE
#       define BOOST_MP_STANDALONE
#   endif
#endif
#endif

#ifndef BOOST_MP_STANDALONE

#include <boost/integer.hpp>
#include <boost/integer_traits.hpp>

// Required typedefs for interoperability with standalone mode
#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
namespace boost { namespace multiprecision {
   using int128_type = boost::int128_type;
   using uint128_type = boost::uint128_type;
}}
#endif
#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
namespace boost { namespace multiprecision {
   using float128_type = boost::float128_type;
}}
#endif

// Boost.Math available by default
#define BOOST_MP_MATH_AVAILABLE

#else // Standalone mode

#ifdef BOOST_MATH_STANDALONE
#  define BOOST_MP_MATH_AVAILABLE
#endif

#ifndef BOOST_MP_MATH_AVAILABLE
#  define BOOST_MATH_INSTRUMENT_CODE(x)
#endif

// Prevent Macro sub
#ifndef BOOST_PREVENT_MACRO_SUBSTITUTION
#  define BOOST_PREVENT_MACRO_SUBSTITUTION
#endif

#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
namespace boost { namespace multiprecision {
#  ifdef __GNUC__
   __extension__ typedef __int128 int128_type;
   __extension__ typedef unsigned __int128 uint128_type;
#  else
   typedef __int128 int128_type;
   typedef unsigned __int128 uint128_type;
#  endif
}}

#endif
// same again for __float128:
#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
namespace boost { namespace multiprecision {
#  ifdef __GNUC__
   __extension__ typedef __float128 float128_type;
#  else
   typedef __float128 float128_type;
#  endif
}}

#endif

#endif // BOOST_MP_STANDALONE

// Workarounds for numeric limits on old compilers
#ifdef BOOST_HAS_INT128
#  ifndef INT128_MAX
#    define INT128_MAX static_cast<boost::multiprecision::int128_type>((static_cast<boost::multiprecision::uint128_type>(1) << ((__SIZEOF_INT128__ * __CHAR_BIT__) - 1)) - 1)
#  endif
#  ifndef INT128_MIN
#    define INT128_MIN (-INT128_MAX - 1)
#  endif
#  ifndef UINT128_MAX
#    define UINT128_MAX ((2 * static_cast<boost::multiprecision::uint128_type>(INT128_MAX)) + 1)
#  endif
#endif

#endif // BOOST_MP_STANDALONE_CONFIG_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/static_array.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock.
//  Copyright Christopher Kormanyos 2021. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_MP_DETAIL_STATIC_ARRAY_HPP
#define BOOST_MP_DETAIL_STATIC_ARRAY_HPP

#include <array>
#include <cstddef>
#include <cstdint>
#include <initializer_list>

namespace boost { namespace multiprecision { namespace backends { namespace detail {
template <class ValueType, const std::uint32_t ElemNumber>
struct static_array : public std::array<ValueType, std::size_t(ElemNumber)>
{
private:
   using base_class_type = std::array<ValueType, std::size_t(ElemNumber)>;

public:
   static_array() noexcept
   {
      base_class_type::fill(typename base_class_type::value_type(0u));
   }

   static_array(std::initializer_list<std::uint32_t> lst) noexcept
   {
      std::copy(lst.begin(),
                lst.begin() + (std::min)(std::size_t(lst.size()), std::size_t(ElemNumber)),
                base_class_type::begin());

      std::fill(base_class_type::begin() + (std::min)(std::size_t(lst.size()), std::size_t(ElemNumber)),
                base_class_type::end(),
                typename base_class_type::value_type(0u));
   }
};
}}}} // namespace boost::multiprecision::backends::detail

#endif // BOOST_MP_DETAIL_STATIC_ARRAY_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/tables.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock.
//  Copyright Christopher Kormanyos 2021. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_MP_DETAIL_TABLES_HPP
#define BOOST_MP_DETAIL_TABLES_HPP

#include <algorithm>
#include <array>
#include <cstdint>

namespace boost { namespace multiprecision { namespace backends { namespace detail {
struct a029750
{
   static constexpr std::uint32_t a029750_as_constexpr(const std::uint32_t value)
   {
      // Sloane's A029750 List of numbers of the form 2^k times 1, 3, 5 or 7.
      // CoefficientList[Series[-(x + 1)^2 (x^2 + 1)^2/(2 x^4 - 1), {x, 0, 78}], x]
      return ((value <= UINT32_C(     32)) ? UINT32_C(     32) : ((value <=  UINT32_C(     40)) ?  UINT32_C(     40) : ((value <= UINT32_C(     48)) ? UINT32_C(     48) : ((value <= UINT32_C(     56)) ? UINT32_C(     56) :
             ((value <= UINT32_C(     64)) ? UINT32_C(     64) : ((value <=  UINT32_C(     80)) ?  UINT32_C(     80) : ((value <= UINT32_C(     96)) ? UINT32_C(     96) : ((value <= UINT32_C(    112)) ? UINT32_C(    112) :
             ((value <= UINT32_C(    128)) ? UINT32_C(    128) : ((value <=  UINT32_C(    160)) ?  UINT32_C(    160) : ((value <= UINT32_C(    192)) ? UINT32_C(    192) : ((value <= UINT32_C(    224)) ? UINT32_C(    224) :
             ((value <= UINT32_C(    256)) ? UINT32_C(    256) : ((value <=  UINT32_C(    320)) ?  UINT32_C(    320) : ((value <= UINT32_C(    384)) ? UINT32_C(    384) : ((value <= UINT32_C(    448)) ? UINT32_C(    448) :
             ((value <= UINT32_C(    512)) ? UINT32_C(    512) : ((value <=  UINT32_C(    640)) ?  UINT32_C(    640) : ((value <= UINT32_C(    768)) ? UINT32_C(    768) : ((value <= UINT32_C(    896)) ? UINT32_C(    896) :
             ((value <= UINT32_C(   1024)) ? UINT32_C(   1024) : ((value <=  UINT32_C(   1280)) ?  UINT32_C(   1280) : ((value <= UINT32_C(   1536)) ? UINT32_C(   1536) : ((value <= UINT32_C(   1792)) ? UINT32_C(   1792) :
             ((value <= UINT32_C(   2048)) ? UINT32_C(   2048) : ((value <=  UINT32_C(   2560)) ?  UINT32_C(   2560) : ((value <= UINT32_C(   3072)) ? UINT32_C(   3072) : ((value <= UINT32_C(   3584)) ? UINT32_C(   3584) :
             ((value <= UINT32_C(   4096)) ? UINT32_C(   4096) : ((value <=  UINT32_C(   5120)) ?  UINT32_C(   5120) : ((value <= UINT32_C(   6144)) ? UINT32_C(   6144) : ((value <= UINT32_C(   7168)) ? UINT32_C(   7168) :
             ((value <= UINT32_C(   8192)) ? UINT32_C(   8192) : ((value <=  UINT32_C(  10240)) ?  UINT32_C(  10240) : ((value <= UINT32_C(  12288)) ? UINT32_C(  12288) : ((value <= UINT32_C(  14336)) ? UINT32_C(  14336) :
             ((value <= UINT32_C(  16384)) ? UINT32_C(  16384) : ((value <=  UINT32_C(  20480)) ?  UINT32_C(  20480) : ((value <= UINT32_C(  24576)) ? UINT32_C(  24576) : ((value <= UINT32_C(  28672)) ? UINT32_C(  28672) :
             ((value <= UINT32_C(  32768)) ? UINT32_C(  32768) : ((value <=  UINT32_C(  40960)) ?  UINT32_C(  40960) : ((value <= UINT32_C(  49152)) ? UINT32_C(  49152) : ((value <= UINT32_C(  57344)) ? UINT32_C(  57344) :
             ((value <= UINT32_C(  65536)) ? UINT32_C(  65536) : ((value <=  UINT32_C(  81920)) ?  UINT32_C(  81920) : ((value <= UINT32_C(  98304)) ? UINT32_C(  98304) : ((value <= UINT32_C( 114688)) ? UINT32_C( 114688) :
             ((value <= UINT32_C( 131072)) ? UINT32_C( 131072) : ((value <=  UINT32_C( 163840)) ?  UINT32_C( 163840) : ((value <= UINT32_C( 196608)) ? UINT32_C( 196608) : ((value <= UINT32_C( 229376)) ? UINT32_C( 229376) :
             ((value <= UINT32_C( 262144)) ? UINT32_C( 262144) : ((value <=  UINT32_C( 327680)) ?  UINT32_C( 327680) : ((value <= UINT32_C( 393216)) ? UINT32_C( 393216) : ((value <= UINT32_C( 458752)) ? UINT32_C( 458752) :
             ((value <= UINT32_C( 524288)) ? UINT32_C( 524288) : ((value <=  UINT32_C( 655360)) ?  UINT32_C( 655360) : ((value <= UINT32_C( 786432)) ? UINT32_C( 786432) : ((value <= UINT32_C( 917504)) ? UINT32_C( 917504) :
             ((value <= UINT32_C(1048576)) ? UINT32_C(1048576) : ((value <=  UINT32_C(1310720)) ?  UINT32_C(1310720) : ((value <= UINT32_C(1572864)) ? UINT32_C(1572864) : ((value <= UINT32_C(1835008)) ? UINT32_C(1835008) : UINT32_C(0x7FFFFFFF)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))));
   }

   static std::uint32_t a029750_as_runtime_value(const std::uint32_t value)
   {
      // Sloane's A029750 List of numbers of the form 2^k times 1, 3, 5 or 7.
      // CoefficientList[Series[-(x + 1)^2 (x^2 + 1)^2/(2 x^4 - 1), {x, 0, 78}], x]
      constexpr std::array<std::uint32_t, 65U> a029750_data =
      {{
         UINT32_C(        32), UINT32_C(     40), UINT32_C(     48), UINT32_C(     56),
         UINT32_C(        64), UINT32_C(     80), UINT32_C(     96), UINT32_C(    112),
         UINT32_C(       128), UINT32_C(    160), UINT32_C(    192), UINT32_C(    224),
         UINT32_C(       256), UINT32_C(    320), UINT32_C(    384), UINT32_C(    448),
         UINT32_C(       512), UINT32_C(    640), UINT32_C(    768), UINT32_C(    896),
         UINT32_C(      1024), UINT32_C(   1280), UINT32_C(   1536), UINT32_C(   1792),
         UINT32_C(      2048), UINT32_C(   2560), UINT32_C(   3072), UINT32_C(   3584),
         UINT32_C(      4096), UINT32_C(   5120), UINT32_C(   6144), UINT32_C(   7168),
         UINT32_C(      8192), UINT32_C(  10240), UINT32_C(  12288), UINT32_C(  14336),
         UINT32_C(     16384), UINT32_C(  20480), UINT32_C(  24576), UINT32_C(  28672),
         UINT32_C(     32768), UINT32_C(  40960), UINT32_C(  49152), UINT32_C(  57344),
         UINT32_C(     65536), UINT32_C(  81920), UINT32_C(  98304), UINT32_C( 114688),
         UINT32_C(    131072), UINT32_C( 163840), UINT32_C( 196608), UINT32_C( 229376),
         UINT32_C(    262144), UINT32_C( 327680), UINT32_C( 393216), UINT32_C( 458752),
         UINT32_C(    524288), UINT32_C( 655360), UINT32_C( 786432), UINT32_C( 917504),
         UINT32_C(   1048576), UINT32_C(1310720), UINT32_C(1572864), UINT32_C(1835008),
         UINT32_C(0x7FFFFFFF)
      }};

      const std::array<std::uint32_t, 65U>::const_iterator it =
         std::lower_bound(a029750_data.cbegin(), a029750_data.cend(), value);

      return ((it != a029750_data.cend()) ? *it : UINT32_C(0xFFFFFFFF));
   }
};

constexpr std::uint32_t pow10_maker(std::uint32_t n)
{
   // Make the constant power of 10^n.
   return ((n == UINT32_C(0)) ? UINT32_C(1) : pow10_maker(n - UINT32_C(1)) * UINT32_C(10));
}

}}}} // namespace boost::multiprecision::backends::detail

#endif // BOOST_MP_DETAIL_TABLES_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/ublas_interop.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_UBLAS_INTEROP_HPP
#define BOOST_MP_UBLAS_INTEROP_HPP

namespace boost { namespace numeric { namespace ublas {

template <class V>
class sparse_vector_element;

template <class V, class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline bool operator==(const sparse_vector_element<V>& a, const ::boost::multiprecision::number<Backend, ExpressionTemplates>& b)
{
   using ref_type = typename sparse_vector_element<V>::const_reference;
   return static_cast<ref_type>(a) == b;
}

template <class X, class Y>
struct promote_traits;

template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class Backend2, boost::multiprecision::expression_template_option ExpressionTemplates2>
struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >
{
   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
   using number2_t = boost::multiprecision::number<Backend2, ExpressionTemplates2>;
   using promote_type = typename std::conditional<
       std::is_convertible<number1_t, number2_t>::value && !std::is_convertible<number2_t, number1_t>::value,
       number2_t, number1_t>::type;
};

template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class Arithmetic>
struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, Arithmetic>
{
   using promote_type = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
};

template <class Arithmetic, class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1>
struct promote_traits<Arithmetic, boost::multiprecision::number<Backend1, ExpressionTemplates1> >
{
   using promote_type = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
};

template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
{
   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>         ;
   using expression_type = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>;
   using number2_t = typename expression_type::result_type                                 ;
   using promote_type = typename promote_traits<number1_t, number2_t>::promote_type           ;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1>
struct promote_traits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::number<Backend1, ExpressionTemplates1> >
{
   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>         ;
   using expression_type = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>;
   using number2_t = typename expression_type::result_type                                 ;
   using promote_type = typename promote_traits<number1_t, number2_t>::promote_type           ;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tagb, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
struct promote_traits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::detail::expression<tagb, Arg1b, Arg2b, Arg3b, Arg4b> >
{
   using expression1_t = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>     ;
   using number1_t = typename expression1_t::result_type                                        ;
   using expression2_t = boost::multiprecision::detail::expression<tagb, Arg1b, Arg2b, Arg3b, Arg4b>;
   using number2_t = typename expression2_t::result_type                                        ;
};

}}} // namespace boost::numeric::ublas

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/uniform_int_distribution.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Jens Maurer 2000-2021
//  Copyright Steven Watanabe 2011-2021
//  Copyright John Maddock 2015-2021
//  Copyright Matt Borland 2021
//  Distributed under the Boost Software License, Version 1.0. 
//  (See accompanying file LICENSE_1_0.txt or copy at 
//  https://www.boost.org/LICENSE_1_0.txt
//
//  This is a C++11 compliant port of Boost.Random's implementation
//  of uniform_int_distribution. See their comments for detailed
//  descriptions

#ifndef BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP
#define BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP

#include <limits>
#include <type_traits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/traits/std_integer_traits.hpp>

namespace boost { namespace multiprecision { 
    
namespace detail {

template <typename T, bool intrinsic>
struct make_unsigned_impl
{
    using type = typename boost::multiprecision::detail::make_unsigned<T>::type;
};

template <typename T>
struct make_unsigned_impl<T, false>
{
    using type = T;
};

template <typename T>
struct make_unsigned_mp
{
    using type = typename make_unsigned_impl<T, boost::multiprecision::detail::is_integral<T>::value>::type;
};

template <typename Engine, typename T>
T generate_uniform_int (Engine& eng, T min_value, T max_value)
{
    using range_type = typename boost::multiprecision::detail::make_unsigned_mp<T>::type;
    using base_result = typename Engine::result_type;
    using base_unsigned = typename boost::multiprecision::detail::make_unsigned_mp<base_result>::type;

    const range_type range = max_value - min_value;
    const base_result bmin = (eng.min)();
    const base_unsigned brange = (eng.max)() - (eng.min)();

    if(range == 0)
    {
        return min_value;
    }
    else if (brange < range)
    {
        for(;;)
        {
            range_type limit;
            if(range == (std::numeric_limits<range_type>::max)())
            {
                limit = range / (range_type(brange) + 1);
                if(range % (range_type(brange) + 1) == range_type(brange))
                {
                    ++limit;
                }
            }
            else
            {
                limit = (range + 1) / (range_type(brange) + 1);
            }

            range_type result = 0;
            range_type mult = 1;

            while (mult <= limit)
            {
                result += static_cast<range_type>(static_cast<range_type>(eng() - bmin) * mult);

                if(mult * range_type(brange) == range - mult + 1)
                {
                    return(result);
                }

                mult *= range_type(brange)+range_type(1);
            }

            range_type result_increment = generate_uniform_int(eng, range_type(0), range_type(range/mult));

            if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment))
            {
                continue;
            }

            result_increment *= mult;
            result += result_increment;

            if(result < result_increment)
            {
                continue;
            }
            if(result > range)
            {
                continue;
            }

            return result + min_value;
        }
    }
    else
    {
        using mixed_range_type = 
        typename std::conditional<std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized &&
                                  (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
                                  range_type, base_unsigned>::type;

        mixed_range_type bucket_size;

        if(brange == (std::numeric_limits<base_unsigned>::max)()) 
        {
            bucket_size = static_cast<mixed_range_type>(brange) / (static_cast<mixed_range_type>(range)+1);
            if(static_cast<mixed_range_type>(brange) % (static_cast<mixed_range_type>(range)+1) == static_cast<mixed_range_type>(range)) 
            {
                ++bucket_size;
            }
        } 
        else 
        {
            bucket_size = static_cast<mixed_range_type>(brange + 1) / (static_cast<mixed_range_type>(range)+1);
        }

        for(;;) 
        {
            mixed_range_type result = eng() - bmin;
            result /= bucket_size;

            if(result <= static_cast<mixed_range_type>(range))
            {
                return result + min_value;
            }
        }
    }
}

} // Namespace detail

template <typename Integer = int>
class uniform_int_distribution
{
private:
    Integer min_;
    Integer max_;

public:
    class param_type
    {
    private:
        Integer min_;
        Integer max_;
    
    public:
        explicit param_type(Integer min_val, Integer max_val) : min_ {min_val}, max_ {max_val}
        {
            BOOST_MP_ASSERT(min_ <= max_);
        }

        Integer a() const { return min_; }
        Integer b() const { return max_; }
    };

    explicit uniform_int_distribution(Integer min_arg, Integer max_arg) : min_ {min_arg}, max_ {max_arg}
    {
        BOOST_MP_ASSERT(min_ <= max_);
    }

    explicit uniform_int_distribution(const param_type& param_arg) : min_ {param_arg.a()}, max_ {param_arg.b()} {}

    Integer min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return min_; }
    Integer max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return max_; }
    
    Integer a() const { return min_; }
    Integer b() const { return max_; }

    param_type param() const { return param_type(min_, max_); }

    void param(const param_type& param_arg)
    {
        min_ = param_arg.a();
        max_ = param_arg.b();
    }

    template <typename Engine>
    Integer operator() (Engine& eng) const
    {
        return detail::generate_uniform_int(eng, min_, max_);
    }

    template <typename Engine>
    Integer operator() (Engine& eng, const param_type& param_arg) const
    {
        return detail::generate_uniform_int(eng, param_arg.a(), param_arg.b());
    }
};

}} // Namespaces

#endif // BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/detail/utype_helper.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock.
//  Copyright Christopher Kormanyos 2013. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_MP_UTYPE_HELPER_HPP
#define BOOST_MP_UTYPE_HELPER_HPP

#include <limits>
#include <cstdint>

namespace boost {
namespace multiprecision {
namespace detail {
template <const unsigned>
struct utype_helper
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<0U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<1U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<2U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<3U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<4U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<5U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<6U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<7U>
{
   using exact = boost::uint8_t;
};
template <>
struct utype_helper<8U>
{
   using exact = boost::uint8_t;
};

template <>
struct utype_helper<9U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<10U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<11U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<12U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<13U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<14U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<15U>
{
   using exact = std::uint16_t;
};
template <>
struct utype_helper<16U>
{
   using exact = std::uint16_t;
};

template <>
struct utype_helper<17U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<18U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<19U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<20U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<21U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<22U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<23U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<24U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<25U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<26U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<27U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<28U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<29U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<30U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<31U>
{
   using exact = std::uint32_t;
};
template <>
struct utype_helper<32U>
{
   using exact = std::uint32_t;
};

template <>
struct utype_helper<33U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<34U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<35U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<36U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<37U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<38U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<39U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<40U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<41U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<42U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<43U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<44U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<45U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<46U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<47U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<48U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<49U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<50U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<51U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<52U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<53U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<54U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<55U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<56U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<57U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<58U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<59U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<60U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<61U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<62U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<63U>
{
   using exact = std::uint64_t;
};
template <>
struct utype_helper<64U>
{
   using exact = std::uint64_t;
};

template <class unsigned_type>
int utype_prior(unsigned_type ui)
{
   // TBD: Implement a templated binary search for this.
   int priority_bit;

   unsigned_type priority_mask = unsigned_type(unsigned_type(1U) << (std::numeric_limits<unsigned_type>::digits - 1));

   for (priority_bit = std::numeric_limits<unsigned_type>::digits - 1; priority_bit >= 0; --priority_bit)
   {
      if (unsigned_type(priority_mask & ui) != unsigned_type(0U))
      {
         break;
      }

      priority_mask >>= 1;
   }

   return priority_bit;
}

}}} // namespace boost::multiprecision::detail

#endif // BOOST_MP_UTYPE_HELPER_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/eigen.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_EIGEN_HPP
#define BOOST_MP_EIGEN_HPP

#include <boost/multiprecision/number.hpp>
#include <Eigen/Core>

//
// Generic Eigen support code:
//
namespace Eigen {

template <class B1, class B2>
struct NumTraitsImp;

template <class B1>
struct NumTraitsImp<B1, B1>
{
   using self_type  = B1;
   using Real       = typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type;
   using NonInteger = self_type; // Not correct but we can't do much better??
   using Literal    = double;
   using Nested     = self_type;
   enum
   {
      IsComplex             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
      IsInteger             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
      ReadCost              = 1,
      AddCost               = 4,
      MulCost               = 8,
      IsSigned              = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
      RequireInitialization = 1,
   };
   static Real epsilon()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::epsilon();
   }
   static Real dummy_precision()
   {
      return 1000 * epsilon();
   }
   static Real highest()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return (std::numeric_limits<Real>::max)();
   }
   static Real lowest()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return (std::numeric_limits<Real>::min)();
   }
   static int digits10_imp(const std::integral_constant<bool, true>&)
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::digits10;
   }
   template <bool B>
   static int digits10_imp(const std::integral_constant<bool, B>&)
   {
      return Real::thread_default_precision();
   }
   static int digits10()
   {
      return digits10_imp(std::integral_constant < bool, std::numeric_limits<Real>::digits10 && (std::numeric_limits<Real>::digits10 != INT_MAX) ? true : false > ());
   }
   static int digits()
   {
      // return the number of digits in the component type in case Real is complex
      // and we have no numeric_limits specialization.
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::digits;
   }
   static int min_exponent()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::min_exponent;
   }
   static int max_exponent()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::max_exponent;
   }
   static Real infinity()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::infinity();
   }
   static Real quiet_NaN()
   {
      static_assert(std::numeric_limits<Real>::is_specialized, "Eigen's NumTraits instantiated on a type with no numeric_limits support.  Are you using a variable precision type?");
      return std::numeric_limits<Real>::quiet_NaN();
   }
};   
   
template <class B1, class B2>
struct NumTraitsImp : public NumTraitsImp<B2, B2>
{
   //
   // This version is instantiated when B1 and B2 are different types, this happens for rational/complex/interval
   // types, in which case many methods defer to those of the "component type" B2.
   //
   using self_type  = B1;
   using Real       = typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type;
   using NonInteger = self_type; // Not correct but we can't do much better??
   using Literal    = double;
   using Nested     = self_type;
   enum
   {
      IsComplex             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
      IsInteger             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
      ReadCost              = 1,
      AddCost               = 4,
      MulCost               = 8,
      IsSigned              = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
      RequireInitialization = 1,
   };
   static B2 epsilon()
   {
      return NumTraitsImp<B2, B2>::epsilon();
   }
   static B2 dummy_precision()
   {
      return 1000 * epsilon();
   }
   static B2 highest()
   {
      return NumTraitsImp<B2, B2>::highest();
   }
   static B2 lowest()
   {
      return NumTraitsImp<B2, B2>::lowest();
   }
   static int digits10()
   {
      return NumTraitsImp<B2, B2>::digits10();
   }
   static int digits()
   {
      return NumTraitsImp<B2, B2>::digits();
   }
   static int min_exponent()
   {
      return NumTraitsImp<B2, B2>::min_exponent();
   }
   static int max_exponent()
   {
      return NumTraitsImp<B2, B2>::max_exponent();
   }
   static B2 infinity()
   {
      return NumTraitsImp<B2, B2>::infinity();
   }
   static B2 quiet_NaN()
   {
      return NumTraitsImp<B2, B2>::quiet_NaN();
   }
};

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct NumTraits<boost::multiprecision::number<Backend, ExpressionTemplates> > : public NumTraitsImp<boost::multiprecision::number<Backend, ExpressionTemplates>, typename boost::multiprecision::number<Backend, ExpressionTemplates>::value_type>
{};
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct NumTraits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > : public NumTraits<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>
{};

#define BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(A)                                                                                                                                                                           \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                                  \
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, A, BinaryOp>                                                                                                               \
   {                                                                                                                                                                                                                   \
      /*static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");*/ \
      using ReturnType = boost::multiprecision::number<Backend, ExpressionTemplates>;                                                                                                                                  \
   };                                                                                                                                                                                                                  \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                                  \
   struct ScalarBinaryOpTraits<A, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>                                                                                                               \
   {                                                                                                                                                                                                                   \
      /*static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");*/ \
      using ReturnType = boost::multiprecision::number<Backend, ExpressionTemplates>;                                                                                                                                  \
   };

BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(float)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(signed char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned long)

#if 0    
      template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Backend2, boost::multiprecision::expression_template_option ExpressionTemplates2, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2>, BinaryOp>
   {
      static_assert(
         boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value
         || boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::value, "Interoperability with this arithmetic type is not supported.");
      using ReturnType = typename std::conditional<std::is_convertible<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value,
         boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::type;
   };

   template<unsigned D, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on>, boost::multiprecision::mpfr_float, BinaryOp>
   {
      using ReturnType = boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on>;
   };

   template<typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::mpfr_float, boost::multiprecision::mpc_complex, BinaryOp>
   {
      using ReturnType = boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<0>, boost::multiprecision::et_on>;
   };

   template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
   {
      using ReturnType = boost::multiprecision::number<Backend, ExpressionTemplates>;
   };
#endif

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class tag, class Arg1, class Arg2, class Arg3, class Arg4, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, BinaryOp>
{
   static_assert(std::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   using ReturnType = boost::multiprecision::number<Backend, ExpressionTemplates>;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
{
   static_assert(std::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   using ReturnType = boost::multiprecision::number<Backend, ExpressionTemplates>;
};

namespace internal {
template <typename Scalar>
struct conj_retval;

template <typename Scalar, bool IsComplex>
struct conj_impl;

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct conj_retval<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
{
   using type = typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
struct conj_impl<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, true>
{
   EIGEN_DEVICE_FUNC
   static inline typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type run(const typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& x)
   {
      return conj(x);
   }
};

} // namespace internal

} // namespace Eigen

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/float128.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_FLOAT128_HPP
#define BOOST_MP_FLOAT128_HPP

// https://gcc.gnu.org/onlinedocs/gcc/Floating-Types.html
#if !defined(__amd64__) && !defined(__amd64) && !defined(__x86_64__) && !defined(__x86_64) && !defined(_M_X64) && !defined(_M_AMD64) && \
    !defined(i386) && !defined(__i386) && !defined(__i386__) && !defined(_M_IX86) && !defined(__X86__) && !defined(_X86_) && !defined(__I86__) && \
    !defined(__ia64__) && !defined(_IA64) && !defined(__IA64__) && !defined(__ia64) && !defined(_M_IA64) && !defined(__itanium__) && \
    !defined(__hppa__) && !defined(__HPPA__) && !defined(__hppa) && \
    !defined(__powerpc) && !defined(_M_PPC) && !defined(_ARCH_PPC) && !defined(_ARCH_PPC64) && !defined(__PPCBROADWAY__)
#error libquadmath only works on on i386, x86_64, IA-64, and hppa HP-UX, as well as on PowerPC GNU/Linux targets that enable the vector scalar (VSX) instruction set.
#endif

#include <memory>
#include <climits>
#include <cfloat>
#include <tuple>
#include <cstring>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

#if defined(BOOST_INTEL) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
#if defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__)
#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
#define BOOST_MP_USE_FLOAT128
#endif
#endif

#ifndef BOOST_MP_USE_FLOAT128
#define BOOST_MP_USE_QUAD
#endif
#endif

#if defined(__GNUC__) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
#define BOOST_MP_USE_FLOAT128
#endif

#if !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
#error "Sorry compiler is neither GCC, not Intel, don't know how to configure this header."
#endif
#if defined(BOOST_MP_USE_FLOAT128) && defined(BOOST_MP_USE_QUAD)
#error "Oh dear, both BOOST_MP_USE_FLOAT128 and BOOST_MP_USE_QUAD are defined, which one should I be using?"
#endif

#if defined(BOOST_MP_USE_FLOAT128)

extern "C" {
#include <quadmath.h>
}

using float128_type = __float128;

#elif defined(BOOST_MP_USE_QUAD)

#include <boost/multiprecision/detail/float_string_cvt.hpp>

using float128_type = _Quad;

extern "C" {
_Quad __ldexpq(_Quad, int);
_Quad __frexpq(_Quad, int*);
_Quad __fabsq(_Quad);
_Quad __floorq(_Quad);
_Quad __ceilq(_Quad);
_Quad __sqrtq(_Quad);
_Quad __truncq(_Quad);
_Quad __expq(_Quad);
_Quad __powq(_Quad, _Quad);
_Quad __logq(_Quad);
_Quad __log10q(_Quad);
_Quad __sinq(_Quad);
_Quad __cosq(_Quad);
_Quad __tanq(_Quad);
_Quad __asinq(_Quad);
_Quad __acosq(_Quad);
_Quad __atanq(_Quad);
_Quad __sinhq(_Quad);
_Quad __coshq(_Quad);
_Quad __tanhq(_Quad);
_Quad __fmodq(_Quad, _Quad);
_Quad __atan2q(_Quad, _Quad);

#define ldexpq __ldexpq
#define frexpq __frexpq
#define fabsq __fabsq
#define floorq __floorq
#define ceilq __ceilq
#define sqrtq __sqrtq
#define truncq __truncq
#define expq __expq
#define powq __powq
#define logq __logq
#define log10q __log10q
#define sinq __sinq
#define cosq __cosq
#define tanq __tanq
#define asinq __asinq
#define acosq __acosq
#define atanq __atanq
#define sinhq __sinhq
#define coshq __coshq
#define tanhq __tanhq
#define fmodq __fmodq
#define atan2q __atan2q
}

inline _Quad isnanq(_Quad v)
{
   return v != v;
}
inline _Quad isinfq(_Quad v)
{
   return __fabsq(v) > 1.18973149535723176508575932662800702e4932Q;
}

#endif

namespace boost {
namespace multiprecision {

#ifndef BOOST_MP_BITS_OF_FLOAT128_DEFINED

namespace detail {

template <>
struct bits_of<float128_type>
{
   static constexpr const unsigned value = 113;
};

}

#endif

namespace backends {

struct float128_backend;

}

using backends::float128_backend;

template <>
struct number_category<backends::float128_backend> : public std::integral_constant<int, number_kind_floating_point>
{};
#if defined(BOOST_MP_USE_QUAD)
template <>
struct number_category<float128_type> : public std::integral_constant<int, number_kind_floating_point>
{};
#endif

using float128 = number<float128_backend, et_off>;

namespace quad_constants {
constexpr float128_type quad_min = static_cast<float128_type>(1) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) / 1073741824;

constexpr float128_type quad_denorm_min = static_cast<float128_type>(1) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) * static_cast<float128_type>(DBL_MIN) / 5.5751862996326557854e+42;

constexpr double     dbl_mult = 8.9884656743115795386e+307;                                              // This has one bit set only.
constexpr float128_type quad_max = (static_cast<float128_type>(1) - 9.62964972193617926527988971292463659e-35) // This now has all bits sets to 1
                                * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * static_cast<float128_type>(dbl_mult) * 65536;
} // namespace quad_constants

#define BOOST_MP_QUAD_MIN boost::multiprecision::quad_constants::quad_min
#define BOOST_MP_QUAD_DENORM_MIN boost::multiprecision::quad_constants::quad_denorm_min
#define BOOST_MP_QUAD_MAX boost::multiprecision::quad_constants::quad_max


namespace backends {

struct float128_backend
{
   using signed_types = std::tuple<signed char, short, int, long, long long>;
   using unsigned_types = std::tuple<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
   using float_types = std::tuple<float, double, long double>;
   using exponent_type = int                                  ;

 private:
   float128_type m_value;

 public:
   constexpr   float128_backend() noexcept : m_value(0) {}
   constexpr   float128_backend(const float128_backend& o) noexcept : m_value(o.m_value) {}
   BOOST_MP_CXX14_CONSTEXPR float128_backend& operator=(const float128_backend& o) noexcept
   {
      m_value = o.m_value;
      return *this;
   }
   template <class T>
   constexpr float128_backend(const T& i, const typename std::enable_if<std::is_convertible<T, float128_type>::value>::type* = nullptr) noexcept(noexcept(std::declval<float128_type&>() = std::declval<const T&>()))
       : m_value(i) {}
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value || std::is_convertible<T, float128_type>::value, float128_backend&>::type operator=(const T& i) noexcept(noexcept(std::declval<float128_type&>() = std::declval<const T&>()))
   {
      m_value = i;
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR float128_backend(long double const& f) : m_value(f)
   {
      if (f > LDBL_MAX)
         m_value = static_cast<float128_type>(HUGE_VAL);
      else if (-f > LDBL_MAX)
         m_value = -static_cast<float128_type>(HUGE_VAL);
   }
   BOOST_MP_CXX14_CONSTEXPR float128_backend& operator=(long double const& f)
   {
      if (f > LDBL_MAX)
         m_value = static_cast<float128_type>(HUGE_VAL);
      else if (-f > LDBL_MAX)
         m_value = -static_cast<float128_type>(HUGE_VAL);
      else
         m_value = f;
      return *this;
   }
   float128_backend& operator=(const char* s)
   {
#ifndef BOOST_MP_USE_QUAD
      char* p_end;
      m_value = strtoflt128(s, &p_end);
      if (p_end - s != (std::ptrdiff_t)std::strlen(s))
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unable to interpret input string as a floating point value"));
      }
#else
      boost::multiprecision::detail::convert_from_string(*this, s);
#endif
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR void swap(float128_backend& o) noexcept
   {
      // We don't call std::swap here because it's no constexpr (yet):
      float128_type t(o.value());
      o.value() = m_value;
      m_value = t;
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
#ifndef BOOST_MP_USE_QUAD
      char        buf[128];
      std::string format = "%";
      if (f & std::ios_base::showpos)
         format += "+";
      if (f & std::ios_base::showpoint)
         format += "#";
      format += ".*";
      if ((digits == 0) && !(f & std::ios_base::fixed))
         digits = 36;
      format += "Q";

      if (f & std::ios_base::scientific)
         format += "e";
      else if (f & std::ios_base::fixed)
         format += "f";
      else
         format += "g";

      int v;
      if ((f & std::ios_base::scientific) && (f & std::ios_base::fixed))
      {
         v = quadmath_snprintf(buf, sizeof buf, "%Qa", m_value);
      }
      else
      {
         v = quadmath_snprintf(buf, sizeof buf, format.c_str(), digits, m_value);
      }

      if ((v < 0) || (v >= 127))
      {
         int                       v_max = v;
         std::unique_ptr<char[]>   buf2;
         buf2.reset(new char[v + 3]);
         v = quadmath_snprintf(&buf2[0], v_max + 3, format.c_str(), digits, m_value);
         if (v >= v_max + 3)
         {
            BOOST_MP_THROW_EXCEPTION(std::runtime_error("Formatting of float128_type failed."));
         }
         return &buf2[0];
      }
      return buf;
#else
      return boost::multiprecision::detail::convert_to_string(*this, digits ? digits : 36, f);
#endif
   }
   BOOST_MP_CXX14_CONSTEXPR void negate() noexcept
   {
      m_value = -m_value;
   }
   BOOST_MP_CXX14_CONSTEXPR int compare(const float128_backend& o) const
   {
      return m_value == o.m_value ? 0 : m_value < o.m_value ? -1 : 1;
   }
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR int compare(const T& i) const
   {
      return m_value == i ? 0 : m_value < i ? -1 : 1;
   }
   BOOST_MP_CXX14_CONSTEXPR float128_type& value()
   {
      return m_value;
   }
   BOOST_MP_CXX14_CONSTEXPR const float128_type& value() const
   {
      return m_value;
   }
};

inline BOOST_MP_CXX14_CONSTEXPR void eval_add(float128_backend& result, const float128_backend& a)
{
   result.value() += a.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add(float128_backend& result, const A& a)
{
   result.value() += a;
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(float128_backend& result, const float128_backend& a)
{
   result.value() -= a.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(float128_backend& result, const A& a)
{
   result.value() -= a;
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(float128_backend& result, const float128_backend& a)
{
   result.value() *= a.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(float128_backend& result, const A& a)
{
   result.value() *= a;
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide(float128_backend& result, const float128_backend& a)
{
   result.value() /= a.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide(float128_backend& result, const A& a)
{
   result.value() /= a;
}

inline BOOST_MP_CXX14_CONSTEXPR void eval_add(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = a.value() + b.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add(float128_backend& result, const float128_backend& a, const A& b)
{
   result.value() = a.value() + b;
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = a.value() - b.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(float128_backend& result, const float128_backend& a, const A& b)
{
   result.value() = a.value() - b;
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(float128_backend& result, const A& a, const float128_backend& b)
{
   result.value() = a - b.value();
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = a.value() * b.value();
}
template <class A>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(float128_backend& result, const float128_backend& a, const A& b)
{
   result.value() = a.value() * b;
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_divide(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = a.value() / b.value();
}

template <class R>
inline BOOST_MP_CXX14_CONSTEXPR void eval_convert_to(R* result, const float128_backend& val)
{
   *result = static_cast<R>(val.value());
}

inline void eval_frexp(float128_backend& result, const float128_backend& arg, int* exp)
{
   result.value() = frexpq(arg.value(), exp);
}

inline void eval_ldexp(float128_backend& result, const float128_backend& arg, int exp)
{
   result.value() = ldexpq(arg.value(), exp);
}

inline void eval_floor(float128_backend& result, const float128_backend& arg)
{
   result.value() = floorq(arg.value());
}
inline void eval_ceil(float128_backend& result, const float128_backend& arg)
{
   result.value() = ceilq(arg.value());
}
inline void eval_sqrt(float128_backend& result, const float128_backend& arg)
{
   result.value() = sqrtq(arg.value());
}

inline void eval_rsqrt(float128_backend& result, const float128_backend& arg)
{
#if (LDBL_MANT_DIG > 100)
   // GCC can't mix and match __float128 and quad precision long double
   // error: __float128 and long double cannot be used in the same expression
   result.value() = 1 / sqrtq(arg.value());
#else
   if (arg.value() < std::numeric_limits<long double>::denorm_min() || arg.value() > (std::numeric_limits<long double>::max)()) {
      result.value() = 1/sqrtq(arg.value());
      return;
   }

   using std::sqrt;
   float128_backend xk = 1/sqrt(static_cast<long double>(arg.value()));

   // Newton iteration for f(x) = arg.value() - 1/x^2.
   BOOST_IF_CONSTEXPR (sizeof(long double) == sizeof(double)) {
       // If the long double is the same as a double, then we need two Newton iterations:
       xk.value() = xk.value() + xk.value()*(1-arg.value()*xk.value()*xk.value())/2;
       result.value() = xk.value() + xk.value()*(1-arg.value()*xk.value()*xk.value())/2;
   }
   else
   {
      // 80 bit long double only needs a single iteration to produce ~2ULPs.
      result.value() = xk.value() + xk.value() * (1 - arg.value() * xk.value() * xk.value()) / 2;
   }
#endif
}
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
inline BOOST_MP_CXX14_CONSTEXPR
#else
inline
#endif
int eval_fpclassify(const float128_backend& arg)
{
   float128_type v = arg.value();
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   if (BOOST_MP_IS_CONST_EVALUATED(v))
   {
      if (v != v)
         return FP_NAN;
      if (v == 0)
         return FP_ZERO;
      float128_type t(v);
      if (t < 0)
         t = -t;
      if (t > BOOST_MP_QUAD_MAX)
         return FP_INFINITE;
      if (t < BOOST_MP_QUAD_MIN)
         return FP_SUBNORMAL;
      return FP_NORMAL;
   }
   else
#endif
   {
      if (isnanq(v))
         return FP_NAN;
      else if (isinfq(v))
         return FP_INFINITE;
      else if (v == 0)
         return FP_ZERO;

      float128_backend t(arg);
      if (t.value() < 0)
         t.negate();
      if (t.value() < BOOST_MP_QUAD_MIN)
         return FP_SUBNORMAL;
      return FP_NORMAL;
   }
}
#if defined(BOOST_GCC) && (__GNUC__ == 9)
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91705
inline BOOST_MP_CXX14_CONSTEXPR void eval_increment(float128_backend& arg)
{
   arg.value() = 1 + arg.value();
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_decrement(float128_backend& arg)
{
   arg.value() = arg.value() - 1;
}
#else
inline BOOST_MP_CXX14_CONSTEXPR void eval_increment(float128_backend& arg)
{
   ++arg.value();
}
inline BOOST_MP_CXX14_CONSTEXPR void eval_decrement(float128_backend& arg)
{
   --arg.value();
}
#endif

/*********************************************************************
*
* abs/fabs:
*
*********************************************************************/

#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
inline BOOST_MP_CXX14_CONSTEXPR void eval_abs(float128_backend& result, const float128_backend& arg)
#else
inline void eval_abs(float128_backend& result, const float128_backend& arg)
#endif
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   float128_type v(arg.value());
   if (BOOST_MP_IS_CONST_EVALUATED(v))
   {
      result.value() = v < 0 ? -v : v;
   }
   else
#endif
   {
      result.value() = fabsq(arg.value());
   }
}
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
inline BOOST_MP_CXX14_CONSTEXPR void eval_fabs(float128_backend& result, const float128_backend& arg)
#else
inline void eval_fabs(float128_backend& result, const float128_backend& arg)
#endif
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   float128_type v(arg.value());
   if (BOOST_MP_IS_CONST_EVALUATED(v))
   {
      result.value() = v < 0 ? -v : v;
   }
   else
#endif
   {
      result.value() = fabsq(arg.value());
   }
}

/*********************************************************************
*
* Floating point functions:
*
*********************************************************************/

inline void eval_trunc(float128_backend& result, const float128_backend& arg)
{
   result.value() = truncq(arg.value());
}
/*
//
// This doesn't actually work... rely on our own default version instead.
//
inline void eval_round(float128_backend& result, const float128_backend& arg)
{
   if(isnanq(arg.value()) || isinf(arg.value()))
   {
      result = boost::math::policies::raise_rounding_error(
            "boost::multiprecision::trunc<%1%>(%1%)", nullptr,
            number<float128_backend, et_off>(arg),
            number<float128_backend, et_off>(arg),
            boost::math::policies::policy<>()).backend();
      return;
   }
   result.value() = roundq(arg.value());
}
*/

inline void eval_exp(float128_backend& result, const float128_backend& arg)
{
   result.value() = expq(arg.value());
}
inline void eval_log(float128_backend& result, const float128_backend& arg)
{
   result.value() = logq(arg.value());
}
inline void eval_log10(float128_backend& result, const float128_backend& arg)
{
   result.value() = log10q(arg.value());
}
inline void eval_sin(float128_backend& result, const float128_backend& arg)
{
   result.value() = sinq(arg.value());
}
inline void eval_cos(float128_backend& result, const float128_backend& arg)
{
   result.value() = cosq(arg.value());
}
inline void eval_tan(float128_backend& result, const float128_backend& arg)
{
   result.value() = tanq(arg.value());
}
inline void eval_asin(float128_backend& result, const float128_backend& arg)
{
   result.value() = asinq(arg.value());
}
inline void eval_acos(float128_backend& result, const float128_backend& arg)
{
   result.value() = acosq(arg.value());
}
inline void eval_atan(float128_backend& result, const float128_backend& arg)
{
   result.value() = atanq(arg.value());
}
inline void eval_sinh(float128_backend& result, const float128_backend& arg)
{
   result.value() = sinhq(arg.value());
}
inline void eval_cosh(float128_backend& result, const float128_backend& arg)
{
   result.value() = coshq(arg.value());
}
inline void eval_tanh(float128_backend& result, const float128_backend& arg)
{
   result.value() = tanhq(arg.value());
}
inline void eval_fmod(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = fmodq(a.value(), b.value());
}
inline void eval_pow(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = powq(a.value(), b.value());
}
inline void eval_atan2(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = atan2q(a.value(), b.value());
}
#ifndef BOOST_MP_USE_QUAD
inline void eval_multiply_add(float128_backend& result, const float128_backend& a, const float128_backend& b, const float128_backend& c)
{
   result.value() = fmaq(a.value(), b.value(), c.value());
}
inline int eval_signbit BOOST_PREVENT_MACRO_SUBSTITUTION(const float128_backend& arg)
{
   return ::signbitq(arg.value());
}
#endif

inline std::size_t hash_value(const float128_backend& val)
{
   return boost::multiprecision::detail::hash_value(static_cast<double>(val.value()));
}

} // namespace backends

template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return asinhq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return acoshq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return atanhq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return cbrtq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return erfq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return erfcq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return expm1q(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return lgammaq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   if(eval_signbit(arg.backend()) != 0)
   {
      const bool result_is_neg = ((static_cast<unsigned long long>(floorq(-arg.backend().value())) % 2U) == 0U);

      const boost::multiprecision::number<float128_backend, ExpressionTemplates> result_of_tgammaq = fabsq(tgammaq(arg.backend().value()));

      return ((result_is_neg == false) ? result_of_tgammaq : -result_of_tgammaq);
   }
   else
   {
      return tgammaq(arg.backend().value());
   }
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   return log1pq(arg.backend().value());
}
template <boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<float128_backend, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<float128_backend, ExpressionTemplates>& arg)
{
   boost::multiprecision::number<float128_backend, ExpressionTemplates> res;
   eval_rsqrt(res.backend(), arg.backend());
   return res;
}

#ifndef BOOST_MP_USE_QUAD
template <multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>& a, const boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>& b)
{
   return ::copysignq(a.backend().value(), b.backend().value());
}

namespace backends {

inline void eval_remainder(float128_backend& result, const float128_backend& a, const float128_backend& b)
{
   result.value() = remainderq(a.value(), b.value());
}
inline void eval_remainder(float128_backend& result, const float128_backend& a, const float128_backend& b, int* pi)
{
   result.value() = remquoq(a.value(), b.value(), pi);
}
} // namespace backends

#endif

} // namespace multiprecision

namespace math {

using boost::multiprecision::copysign;
using boost::multiprecision::signbit;

} // namespace math

} // namespace boost

#ifndef BOOST_MP_STANDALONE
namespace boost {
namespace archive {

class binary_oarchive;
class binary_iarchive;

} // namespace archive

namespace serialization {
namespace float128_detail {

template <class Archive>
void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&)
{
   // saving
   // non-binary
   std::string s(val.str(0, std::ios_base::scientific));
   ar&         boost::make_nvp("value", s);
}
template <class Archive>
void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&)
{
   // loading
   // non-binary
   std::string s;
   ar&         boost::make_nvp("value", s);
   val = s.c_str();
}

template <class Archive>
void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&)
{
   // saving
   // binary
   ar.save_binary(&val, sizeof(val));
}
template <class Archive>
void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&)
{
   // loading
   // binary
   ar.load_binary(&val, sizeof(val));
}

} // namespace float128_detail

template <class Archive>
void serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, unsigned int /*version*/)
{
   using load_tag = typename Archive::is_loading                                                                                                                                         ;
   using loading = std::integral_constant<bool, load_tag::value>                                                                                                                        ;
   using binary_tag = typename std::integral_constant<bool, std::is_same<Archive, boost::archive::binary_oarchive>::value || std::is_same<Archive, boost::archive::binary_iarchive>::value>;

   float128_detail::do_serialize(ar, val, loading(), binary_tag());
}

} // namespace serialization

} // namespace boost
#endif // BOOST_MP_STANDALONE

namespace std {

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = true;
   static BOOST_MP_CXX14_CONSTEXPR number_type(min)() noexcept { return BOOST_MP_QUAD_MIN; }
   static BOOST_MP_CXX14_CONSTEXPR number_type(max)() noexcept { return BOOST_MP_QUAD_MAX; }
   static BOOST_MP_CXX14_CONSTEXPR number_type          lowest() noexcept { return -(max)(); }
   static constexpr int  digits       = 113;
   static constexpr int  digits10     = 33;
   static constexpr int  max_digits10 = 36;
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static BOOST_MP_CXX14_CONSTEXPR number_type          epsilon() { return 1.92592994438723585305597794258492732e-34; /* this double value has only one bit set and so is exact */ }
   static BOOST_MP_CXX14_CONSTEXPR number_type          round_error() { return 0.5; }
   static constexpr int  min_exponent                  = -16381;
   static constexpr int  min_exponent10                = min_exponent * 301L / 1000L;
   static constexpr int  max_exponent                  = 16384;
   static constexpr int  max_exponent10                = max_exponent * 301L / 1000L;
   static constexpr bool has_infinity                  = true;
   static constexpr bool has_quiet_NaN                 = true;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_present;
   static constexpr bool               has_denorm_loss = true;
   static BOOST_MP_CXX14_CONSTEXPR number_type                        infinity() { return HUGE_VAL; /* conversion from double infinity OK */ }
   static BOOST_MP_CXX14_CONSTEXPR number_type                        quiet_NaN() { return number_type(NAN); }
   static BOOST_MP_CXX14_CONSTEXPR number_type                        signaling_NaN() { return 0; }
   static BOOST_MP_CXX14_CONSTEXPR number_type                        denorm_min() { return BOOST_MP_QUAD_DENORM_MIN; }
   static constexpr bool               is_iec559       = true;
   static constexpr bool               is_bounded      = true;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style round_style      = round_to_nearest;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_specialized;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_digits10;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::radix;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent10;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm_loss;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::tinyness_before;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::round_style;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm;

} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/gmp.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_GMP_HPP
#define BOOST_MP_GMP_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/atomic.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <algorithm>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <memory>
#include <type_traits>
#include <utility>

//
// Some includes we need from Boost.Math, since we rely on that library to provide these functions:
//
#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/asinh.hpp>
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/atanh.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/special_functions/gamma.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127)
#endif
#include <gmp.h>
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#if defined(__MPIR_VERSION) && defined(__MPIR_VERSION_MINOR) && defined(__MPIR_VERSION_PATCHLEVEL)
#define BOOST_MP_MPIR_VERSION (__MPIR_VERSION * 10000 + __MPIR_VERSION_MINOR * 100 + __MPIR_VERSION_PATCHLEVEL)
#else
#define BOOST_MP_MPIR_VERSION 0
#endif

namespace boost {
namespace multiprecision {
namespace backends {

#ifdef BOOST_MSVC
// warning C4127: conditional expression is constant
#pragma warning(push)
//#pragma warning(disable : 4127)
#endif

template <unsigned digits10>
struct gmp_float;
struct gmp_int;
struct gmp_rational;

} // namespace backends

template <>
struct number_category<backends::gmp_int> : public std::integral_constant<int, number_kind_integer>
{};
template <>
struct number_category<backends::gmp_rational> : public std::integral_constant<int, number_kind_rational>
{};
template <unsigned digits10>
struct number_category<backends::gmp_float<digits10> > : public std::integral_constant<int, number_kind_floating_point>
{};

namespace backends {
//
// Within this file, the only functions we mark as noexcept are those that manipulate
// (but don't create) an mpf_t.  All other types may allocate at pretty much any time
// via a user-supplied allocator, and therefore throw.
//
namespace detail {

template <unsigned digits10>
struct gmp_float_imp
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;
   using exponent_type = long                          ;

   gmp_float_imp() noexcept
   {
      m_data[0]._mp_d = nullptr; // uninitialized m_data
      m_data[0]._mp_prec = 1;
   }

   gmp_float_imp(const gmp_float_imp& o)
   {
      //
      // We have to do an init followed by a set here, otherwise *this may be at
      // a lower precision than o: seems like mpf_init_set copies just enough bits
      // to get the right value, but if it's then used in further calculations
      // things go badly wrong!!
      //
      mpf_init2(m_data, preserve_source_precision() ? mpf_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      if (o.m_data[0]._mp_d)
         mpf_set(m_data, o.m_data);
   }
   // rvalue copy
   gmp_float_imp(gmp_float_imp&& o) noexcept
   {
      if ((this->get_default_options() == variable_precision_options::preserve_target_precision) && (mpf_get_prec(o.data()) != boost::multiprecision::detail::digits10_2_2(get_default_precision())))
      {
         mpf_init2(m_data, boost::multiprecision::detail::digits10_2_2(get_default_precision()));
         *this = static_cast<const gmp_float_imp&>(o);
      }
      else
      {
         m_data[0] = o.m_data[0];
         o.m_data[0]._mp_d = nullptr;
      }
   }

   gmp_float_imp& operator=(const gmp_float_imp& o)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, preserve_source_precision() ? mpf_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
         mpf_set(m_data, o.m_data);
      }
      else if (preserve_source_precision() && (mpf_get_prec(data()) != mpf_get_prec(o.data())))
      {
         mpf_t t;
         mpf_init2(t, mpf_get_prec(o.data()));
         mpf_set(t, o.data());
         mpf_swap(data(), t);
         mpf_clear(t);
      }
      else
      {
         mpf_set(m_data, o.m_data);
      }
      return *this;
   }
   // rvalue assign
   gmp_float_imp& operator=(gmp_float_imp&& o) noexcept
   {
      if ((this->get_default_options() == variable_precision_options::preserve_target_precision) && (mpf_get_prec(o.data()) != mpf_get_prec(data())))
         *this = static_cast<const gmp_float_imp&>(o);
      else
      {
         mpf_swap(m_data, o.m_data);
      }
      return *this;
   }

#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
   gmp_float_imp& operator=(unsigned long long i)
   {
      *this = static_cast<unsigned long>(i);
      return *this;
   }
#else
   gmp_float_imp& operator=(unsigned long long i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned               shift = 0;
      mpf_t                  t;
      mpf_init2(t, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpf_set_ui(m_data, 0);
      while (i)
      {
         mpf_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpf_mul_2exp(t, t, shift);
         mpf_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpf_clear(t);
      return *this;
   }
#endif
   gmp_float_imp& operator=(long long i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      bool neg = i < 0;
      *this    = static_cast<unsigned long long>(boost::multiprecision::detail::unsigned_abs(i));
      if (neg)
         mpf_neg(m_data, m_data);
      return *this;
   }
#endif
   gmp_float_imp& operator=(unsigned long i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      mpf_set_ui(m_data, i);
      return *this;
   }
   gmp_float_imp& operator=(long i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      mpf_set_si(m_data, i);
      return *this;
   }
#ifdef BOOST_HAS_INT128
   gmp_float_imp& operator=(uint128_type i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      unsigned long      mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned           shift = 0;
      mpf_t              t;
      mpf_init2(t, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpf_set_ui(m_data, 0);
      while (i)
      {
         mpf_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpf_mul_2exp(t, t, shift);
         mpf_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpf_clear(t);
      return *this;
   }
   gmp_float_imp& operator=(int128_type i)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      bool neg = i < 0;
      *this    = static_cast<uint128_type>(boost::multiprecision::detail::unsigned_abs(i));
      if (neg)
         mpf_neg(m_data, m_data);
      return *this;
   }
#endif
   gmp_float_imp& operator=(double d)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      mpf_set_d(m_data, d);
      return *this;
   }
   template <class F>
   gmp_float_imp& assign_float(F a)
   {
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }

      if (a == 0)
      {
         mpf_set_si(m_data, 0);
         return *this;
      }

      if (a == 1)
      {
         mpf_set_si(m_data, 1);
         return *this;
      }

      BOOST_MP_ASSERT(!BOOST_MP_ISINF(a));
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a));

      int         e;
      F f, term;
      mpf_set_ui(m_data, 0u);

      f = frexp(a, &e);

      constexpr int shift = std::numeric_limits<int>::digits - 1;

      while (f)
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpf_mul_2exp(m_data, m_data, shift);
         if (term > 0)
            mpf_add_ui(m_data, m_data, static_cast<unsigned>(term));
         else
            mpf_sub_ui(m_data, m_data, static_cast<unsigned>(-term));
         f -= term;
      }
      if (e > 0)
         mpf_mul_2exp(m_data, m_data, e);
      else if (e < 0)
         mpf_div_2exp(m_data, m_data, -e);
      return *this;
   }
   gmp_float_imp& operator=(long double a)
   {
      return assign_float(a);
   }
#ifdef BOOST_HAS_FLOAT128
   gmp_float_imp& operator= (float128_type a)
   {
      return assign_float(a);
   }
#endif
   gmp_float_imp& operator=(const char* s)
   {
      if (m_data[0]._mp_d == nullptr)
      {
         mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      }
      if (s && (*s == '+'))
         ++s;  // Leading "+" sign not supported by mpf_set_str:
      if (0 != mpf_set_str(m_data, s, 10))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid floating point number.")));
      return *this;
   }
   void swap(gmp_float_imp& o) noexcept
   {
      mpf_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);

      bool            scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
      bool            fixed      = (f & std::ios_base::fixed) == std::ios_base::fixed;
      std::streamsize org_digits(digits);

      if (scientific && digits)
         ++digits;

      std::string result;
      mp_exp_t    e;
      void* (*alloc_func_ptr)(size_t);
      void* (*realloc_func_ptr)(void*, size_t, size_t);
      void (*free_func_ptr)(void*, size_t);
      mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);

      if (mpf_sgn(m_data) == 0)
      {
         e      = 0;
         result = "0";
         if (fixed && digits)
            ++digits;
      }
      else
      {
         char* ps = mpf_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data);
         --e; // To match with what our formatter expects.
         if (fixed)
         {
            // Oops we actually need a different number of digits to what we asked for:
            (*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
            digits += e + 1;
            if (digits == 0)
            {
               // We need to get *all* the digits and then possibly round up,
               // we end up with either "0" or "1" as the result.
               ps = mpf_get_str(nullptr, &e, 10, 0, m_data);
               --e;
               unsigned offset = *ps == '-' ? 1 : 0;
               if (ps[offset] > '5')
               {
                  ++e;
                  ps[offset]     = '1';
                  ps[offset + 1] = 0;
               }
               else if (ps[offset] == '5')
               {
                  unsigned i        = offset + 1;
                  bool     round_up = false;
                  while (ps[i] != 0)
                  {
                     if (ps[i] != '0')
                     {
                        round_up = true;
                        break;
                     }
                     ++i;
                  }
                  if (round_up)
                  {
                     ++e;
                     ps[offset]     = '1';
                     ps[offset + 1] = 0;
                  }
                  else
                  {
                     ps[offset]     = '0';
                     ps[offset + 1] = 0;
                  }
               }
               else
               {
                  ps[offset]     = '0';
                  ps[offset + 1] = 0;
               }
            }
            else if (digits > 0)
            {
               mp_exp_t old_e = e;
               ps             = mpf_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data);
               --e; // To match with what our formatter expects.
               if (old_e > e)
               {
                  // in some cases, when we ask for more digits of precision, it will
                  // change the number of digits to the left of the decimal, if that
                  // happens, account for it here.
                  // example: cout << fixed << setprecision(3) << mpf_float_50("99.9809")
                  digits -= old_e - e;
                  (*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
                  ps = mpf_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data);
                  --e; // To match with what our formatter expects.
               }
            }
            else
            {
               ps = mpf_get_str(nullptr, &e, 10, 1, m_data);
               --e;
               unsigned offset = *ps == '-' ? 1 : 0;
               ps[offset]      = '0';
               ps[offset + 1]  = 0;
            }
         }
         result = ps;
         (*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
      }
      boost::multiprecision::detail::format_float_string(result, e, org_digits, f, mpf_sgn(m_data) == 0);
      return result;
   }
   ~gmp_float_imp() noexcept
   {
      if (m_data[0]._mp_d)
      {
         mpf_clear(m_data);
      }
   }
   void negate() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      mpf_neg(m_data, m_data);
   }
   int compare(const gmp_float<digits10>& o) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d && o.m_data[0]._mp_d);
      return mpf_cmp(m_data, o.m_data);
   }
   int compare(long i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return mpf_cmp_si(m_data, i);
   }
   int compare(unsigned long i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return mpf_cmp_ui(m_data, i);
   }
   template <class V>
   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<V>::value, int>::type compare(V v) const
   {
      gmp_float<digits10> d;
      d = v;
      return compare(d);
   }
   mpf_t& data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return m_data;
   }
   const mpf_t& data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return m_data;
   }

 protected:
   mpf_t            m_data;
   static unsigned& get_default_precision() noexcept
   {
      static BOOST_MP_THREAD_LOCAL unsigned val(get_global_default_precision());
      return val;
   }
   static boost::multiprecision::detail::precision_type& get_global_default_precision() noexcept
   {
      static boost::multiprecision::detail::precision_type val(50);
      return val;
   }
#ifndef BOOST_MT_NO_ATOMIC_INT
   static std::atomic<variable_precision_options>& get_global_default_options() noexcept
#else
   static variable_precision_options& get_global_default_options() noexcept
#endif
   {
#ifndef BOOST_MT_NO_ATOMIC_INT
      static std::atomic<variable_precision_options> val{variable_precision_options::preserve_related_precision};
#else
      static variable_precision_options val{variable_precision_options::preserve_related_precision};
#endif
      return val;
   }
   static variable_precision_options& get_default_options()noexcept
   {
      static BOOST_MP_THREAD_LOCAL variable_precision_options val(get_global_default_options());
      return val;
   }
   static bool preserve_source_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
};

class gmp_char_ptr
{
private:
   char* ptr_val;
   void* (*alloc_func_ptr)(size_t);
   void* (*realloc_func_ptr)(void*, size_t, size_t);
   void  (*free_func_ptr)(void*, size_t);

public:
   gmp_char_ptr() = delete;
   explicit gmp_char_ptr(char* val_) : ptr_val {val_}
   {
      mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
   }
   ~gmp_char_ptr() noexcept
   {
      (*free_func_ptr)((void*)ptr_val, sizeof(*ptr_val));
      ptr_val = nullptr;
   }
   inline char* get() noexcept { return ptr_val; }
};

} // namespace detail

struct gmp_int;
struct gmp_rational;

template <unsigned digits10>
struct gmp_float : public detail::gmp_float_imp<digits10>
{
   gmp_float()
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
   }
   gmp_float(const gmp_float& o) : detail::gmp_float_imp<digits10>(o) {}
   template <unsigned D>
   gmp_float(const gmp_float<D>& o, typename std::enable_if<D <= digits10>::type* = nullptr);
   template <unsigned D>
   explicit gmp_float(const gmp_float<D>& o, typename std::enable_if<!(D <= digits10)>::type* = nullptr);
   gmp_float(const gmp_int& o);
   gmp_float(const gmp_rational& o);
   gmp_float(const mpf_t val)
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set(this->m_data, val);
   }
   gmp_float(const mpz_t val)
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set_z(this->m_data, val);
   }
   gmp_float(const mpq_t val)
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set_q(this->m_data, val);
   }
   // rvalue copy
   gmp_float(gmp_float&& o) noexcept : detail::gmp_float_imp<digits10>(static_cast<detail::gmp_float_imp<digits10>&&>(o))
   {}
   gmp_float& operator=(const gmp_float& o)
   {
      *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10> const&>(o);
      return *this;
   }
   gmp_float& operator=(gmp_float&& o) noexcept
   {
      *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10>&&>(o);
      return *this;
   }
   template <unsigned D>
   gmp_float& operator=(const gmp_float<D>& o);
   gmp_float& operator=(const gmp_int& o);
   gmp_float& operator=(const gmp_rational& o);
   gmp_float& operator=(const mpf_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set(this->m_data, val);
      return *this;
   }
   gmp_float& operator=(const mpz_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set_z(this->m_data, val);
      return *this;
   }
   gmp_float& operator=(const mpq_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set_q(this->m_data, val);
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<detail::gmp_float_imp<digits10>, V>::value, gmp_float&>::type operator=(const V& v)
   {
      *static_cast<detail::gmp_float_imp<digits10>*>(this) = v;
      return *this;
   }
};

template <>
struct gmp_float<0> : public detail::gmp_float_imp<0>
{
   //
   // We have a problem with mpf_t in that the precision we request isn't what we get.
   // As a result the front end can end up chasing it's tail trying to create a variable
   // with the the correct precision to hold the result of an expression.
   // See: https://github.com/boostorg/multiprecision/issues/164
   // The problem is made worse by the fact that our conversions from base10 to 2 and
   // vice-versa do not exactly round trip (and probably never will).
   // The workaround is to keep track of the precision requested, and always return
   // that as the current actual precision.
   //
 private:
   unsigned requested_precision;

 public:
   gmp_float() : requested_precision(get_default_precision())
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   }
   gmp_float(const mpf_t val) : requested_precision(get_default_precision())
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      mpf_set(this->m_data, val);
   }
   gmp_float(const mpz_t val) : requested_precision(get_default_precision())
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      mpf_set_z(this->m_data, val);
   }
   gmp_float(const mpq_t val) : requested_precision(get_default_precision())
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      mpf_set_q(this->m_data, val);
   }
   gmp_float(const gmp_float& o) : detail::gmp_float_imp<0>(o), requested_precision(preserve_source_precision() ? o.requested_precision : get_default_precision()) {}
   template <unsigned D>
   gmp_float(const gmp_float<D>& o)
   {
      mpf_init2(this->m_data, preserve_related_precision() ? mpf_get_prec(o.data()) : multiprecision::detail::digits10_2_2(get_default_precision()));
      mpf_set(this->m_data, o.data());
      requested_precision = preserve_related_precision() ? D : get_default_precision();
   }
   // rvalue copy
   gmp_float(gmp_float&& o) noexcept : detail::gmp_float_imp<0>(static_cast<detail::gmp_float_imp<0>&&>(o)), requested_precision((this->get_default_options() != variable_precision_options::preserve_target_precision) ? o.requested_precision : get_default_precision())
   {}
   gmp_float(const gmp_int& o);
   gmp_float(const gmp_rational& o);
   gmp_float(const gmp_float& o, unsigned digits10) : requested_precision(digits10)
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpf_set(this->m_data, o.data());
   }
   template <class V>
   gmp_float(const V& o, unsigned digits10) : requested_precision(digits10)
   {
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      *this = o;
   }

#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   //
   // Support for new types in C++17
   //
   template <class Traits>
   gmp_float(const std::basic_string_view<char, Traits>& o, unsigned digits10) : requested_precision(digits10)
   {
      using default_ops::assign_from_string_view;
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      assign_from_string_view(*this, o);
   }
#endif
   gmp_float& operator=(const gmp_float& o)
   {
      *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0> const&>(o);
      if(preserve_source_precision())
         requested_precision = o.requested_precision;
      return *this;
   }
   // rvalue copy
   gmp_float& operator=(gmp_float&& o) noexcept
   {
      *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0>&&>(o);
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision))
         requested_precision = o.requested_precision;
      return *this;
   }
   template <unsigned D>
   gmp_float& operator=(const gmp_float<D>& o)
   {
      if (this->m_data[0]._mp_d == nullptr)
      {
         mpf_init2(this->m_data, preserve_related_precision() ? mpf_get_prec(o.data()) : multiprecision::detail::digits10_2_2(get_default_precision()));
      }
      else if(preserve_related_precision())
      {
         mpf_set_prec(this->m_data, mpf_get_prec(o.data()));
      }
      mpf_set(this->m_data, o.data());
      if (preserve_related_precision())
         requested_precision = D;
      return *this;
   }
   gmp_float& operator=(const gmp_int& o);
   gmp_float& operator=(const gmp_rational& o);
   gmp_float& operator=(const mpf_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
      {
         requested_precision = get_default_precision();
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      }
      mpf_set(this->m_data, val);
      return *this;
   }
   gmp_float& operator=(const mpz_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
      {
         requested_precision = get_default_precision();
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      }
      mpf_set_z(this->m_data, val);
      return *this;
   }
   gmp_float& operator=(const mpq_t val)
   {
      if (this->m_data[0]._mp_d == nullptr)
      {
         requested_precision = get_default_precision();
         mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      }
      mpf_set_q(this->m_data, val);
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<detail::gmp_float_imp<0>, V>::value, gmp_float&>::type operator=(const V& v)
   {
      constexpr unsigned d10 = std::is_floating_point<V>::value ?
         std::numeric_limits<V>::digits10 :
         std::numeric_limits<V>::digits10 ? 1 + std::numeric_limits<V>::digits10 :
         1 + boost::multiprecision::detail::digits2_2_10(std::numeric_limits<V>::digits);
      if((thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) && (precision() < d10))
         this->precision(d10);
      *static_cast<detail::gmp_float_imp<0>*>(this) = v;
      return *this;
   }
   static unsigned default_precision() noexcept
   {
      return get_global_default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      get_global_default_precision() = v;
   }
   static unsigned thread_default_precision() noexcept
   {
      return get_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      get_default_precision() = v;
   }
   unsigned precision() const noexcept
   {
      return requested_precision;
   }
   void precision(unsigned digits10) noexcept
   {
      requested_precision = digits10;
      mpf_set_prec(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   }
   //
   // Variable precision options:
   //
   static variable_precision_options default_variable_precision_options()noexcept
   {
      return get_global_default_options();
   }
   static variable_precision_options thread_default_variable_precision_options()noexcept
   {
      return get_default_options();
   }
   static void default_variable_precision_options(variable_precision_options opts)
   {
      get_global_default_options() = opts;
   }
   static void thread_default_variable_precision_options(variable_precision_options opts)
   {
      get_default_options() = opts;
   }
   static bool preserve_source_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
   static bool preserve_related_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_related_precision;
   }
   static bool preserve_all_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_all_precision;
   }
   //
   // swap:
   //
   void swap(gmp_float& o)
   {
      std::swap(requested_precision, o.requested_precision);
      gmp_float_imp<0>::swap(o);
   }
};

template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const gmp_float<digits10>& a, const T& b) noexcept
{
   return a.compare(b) == 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const gmp_float<digits10>& a, const T& b) noexcept
{
   return a.compare(b) < 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const gmp_float<digits10>& a, const T& b) noexcept
{
   return a.compare(b) > 0;
}

template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& result, const gmp_float<D2>& o)
{
   mpf_add(result.data(), result.data(), o.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& result, const gmp_float<D2>& o)
{
   mpf_sub(result.data(), result.data(), o.data());
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& result, const gmp_float<D2>& o)
{
   mpf_mul(result.data(), result.data(), o.data());
}
template <unsigned digits10>
inline bool eval_is_zero(const gmp_float<digits10>& val) noexcept
{
   return mpf_sgn(val.data()) == 0;
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& result, const gmp_float<D2>& o)
{
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpf_div(result.data(), result.data(), o.data());
}
template <unsigned digits10>
inline void eval_add(gmp_float<digits10>& result, unsigned long i)
{
   mpf_add_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_subtract(gmp_float<digits10>& result, unsigned long i)
{
   mpf_sub_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_multiply(gmp_float<digits10>& result, unsigned long i)
{
   mpf_mul_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_divide(gmp_float<digits10>& result, unsigned long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpf_div_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_add(gmp_float<digits10>& result, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpf_add_ui(result.data(), result.data(), static_cast<local_uint_type>(i));
   else if (i < 0)
      mpf_sub_ui(result.data(), result.data(), static_cast<local_uint_type>(-i));
}
template <unsigned digits10>
inline void eval_subtract(gmp_float<digits10>& result, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpf_sub_ui(result.data(), result.data(), static_cast<local_uint_type>(i));
   else if (i < 0)
      mpf_add_ui(result.data(), result.data(), static_cast<local_uint_type>(-i));
}
template <unsigned digits10>
inline void eval_multiply(gmp_float<digits10>& result, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   mpf_mul_ui(result.data(), result.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i)));

   if (i < 0)
      mpf_neg(result.data(), result.data());
}
template <unsigned digits10>
inline void eval_divide(gmp_float<digits10>& result, long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   mpf_div_ui(result.data(), result.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i)));

   if (i < 0)
      mpf_neg(result.data(), result.data());
}
//
// Specialised 3 arg versions of the basic operators:
//
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y)
{
   mpf_add(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y)
{
   mpf_add_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
   if (y < 0)
      mpf_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
   else
      mpf_add_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y)
{
   mpf_add_ui(a.data(), y.data(), x);
}
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (x < 0)
   {
      mpf_ui_sub(a.data(), static_cast<local_uint_type>(-x), y.data());
      mpf_neg(a.data(), a.data());
   }
   else
      mpf_add_ui(a.data(), y.data(), static_cast<local_uint_type>(x));
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y)
{
   mpf_sub(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y)
{
   mpf_sub_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (y < 0)
      mpf_add_ui(a.data(), x.data(), static_cast<local_uint_type>(-y));
   else
      mpf_sub_ui(a.data(), x.data(), static_cast<local_uint_type>(y));
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y)
{
   mpf_ui_sub(a.data(), x, y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (x < 0)
   {
      mpf_add_ui(a.data(), y.data(), static_cast<local_uint_type>(-x));
      mpf_neg(a.data(), a.data());
   }
   else
      mpf_ui_sub(a.data(), static_cast<local_uint_type>(x), y.data());
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y)
{
   mpf_mul(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y)
{
   mpf_mul_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (y < 0)
   {
      mpf_mul_ui(a.data(), x.data(), static_cast<local_uint_type>(-y));
      a.negate();
   }
   else
      mpf_mul_ui(a.data(), x.data(), static_cast<local_uint_type>(y));
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y)
{
   mpf_mul_ui(a.data(), y.data(), x);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (x < 0)
   {
      mpf_mul_ui(a.data(), y.data(), static_cast<local_uint_type>(-x));
      mpf_neg(a.data(), a.data());
   }
   else
      mpf_mul_ui(a.data(), y.data(), static_cast<local_uint_type>(x));
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y)
{
   if (eval_is_zero(y))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpf_div(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y)
{
   if (y == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpf_div_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
   if (y == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (y < 0)
   {
      mpf_div_ui(a.data(), x.data(), static_cast<local_uint_type>(-y));
      a.negate();
   }
   else
      mpf_div_ui(a.data(), x.data(), static_cast<local_uint_type>(y));
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y)
{
   if (eval_is_zero(y))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpf_ui_div(a.data(), x, y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
   if (eval_is_zero(y))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   if (x < 0)
   {
      mpf_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data());
      mpf_neg(a.data(), a.data());
   }
   else
   {
      using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

      mpf_ui_div(a.data(), static_cast<local_uint_type>(x), y.data());
   }
}

template <unsigned digits10>
inline int eval_get_sign(const gmp_float<digits10>& val) noexcept
{
   return mpf_sgn(val.data());
}

template <unsigned digits10>
inline void eval_convert_to(unsigned long* result, const gmp_float<digits10>& val) noexcept
{
   if (0 == mpf_fits_ulong_p(val.data()))
      *result = (std::numeric_limits<unsigned long>::max)();
   else
      *result = static_cast<unsigned long>(mpf_get_ui(val.data()));
}
template <unsigned digits10>
inline void eval_convert_to(long* result, const gmp_float<digits10>& val) noexcept
{
   if (0 == mpf_fits_slong_p(val.data()))
   {
      *result = (std::numeric_limits<long>::max)();
      *result *= mpf_sgn(val.data());
   }
   else
      *result = static_cast<long>(mpf_get_si(val.data()));
}
#ifdef BOOST_MP_STANDALONE
template <unsigned digits10>
inline void eval_convert_to(long double* result, const gmp_float<digits10>& val) noexcept
{
   mp_exp_t exp = 0;

   detail::gmp_char_ptr val_char_ptr {mpf_get_str(nullptr, &exp, 10, LDBL_DIG, val.data())};

   auto temp_string = std::string(val_char_ptr.get());
   if(exp > 0 && static_cast<std::size_t>(exp) < temp_string.size())
   {
      if(temp_string.front() == '-')
      {
         ++exp;
      }

      temp_string.insert(static_cast<std::size_t>(exp), static_cast<std::size_t>(1u), '.');
   }

   *result = std::strtold(temp_string.c_str(), nullptr);

   if((temp_string.size() == 2ul && *result < 0.0l) ||
      (static_cast<std::size_t>(exp) > temp_string.size()))
   {
      *result *= std::pow(10l, exp-1);
   }
}
#endif // BOOST_MP_STANDALONE
template <unsigned digits10>
inline void eval_convert_to(double* result, const gmp_float<digits10>& val) noexcept
{
   *result = mpf_get_d(val.data());
}
#ifdef BOOST_HAS_LONG_LONG
template <unsigned digits10>
inline void eval_convert_to(long long* result, const gmp_float<digits10>& val)
{
   gmp_float<digits10> t(val);
   if (eval_get_sign(t) < 0)
      t.negate();

   long digits = std::numeric_limits<long long>::digits - std::numeric_limits<long>::digits;

   if (digits > 0)
      mpf_div_2exp(t.data(), t.data(), digits);

   if (!mpf_fits_slong_p(t.data()))
   {
      if (eval_get_sign(val) < 0)
         *result = (std::numeric_limits<long long>::min)();
      else
         *result = (std::numeric_limits<long long>::max)();
      return;
   };

   *result = mpf_get_si(t.data());
   while (digits > 0)
   {
      *result <<= digits;
      digits -= std::numeric_limits<unsigned long>::digits;
      mpf_mul_2exp(t.data(), t.data(), digits >= 0 ? std::numeric_limits<unsigned long>::digits : std::numeric_limits<unsigned long>::digits + digits);
      unsigned long l = static_cast<unsigned long>(mpf_get_ui(t.data()));
      if (digits < 0)
         l >>= -digits;
      *result |= l;
   }
   if (eval_get_sign(val) < 0)
      *result = -*result;
}
template <unsigned digits10>
inline void eval_convert_to(unsigned long long* result, const gmp_float<digits10>& val)
{
   gmp_float<digits10> t(val);

   long digits = std::numeric_limits<long long>::digits - std::numeric_limits<long>::digits;

   if (digits > 0)
      mpf_div_2exp(t.data(), t.data(), digits);

   if (!mpf_fits_ulong_p(t.data()))
   {
      *result = (std::numeric_limits<long long>::max)();
      return;
   }

   *result = mpf_get_ui(t.data());
   while (digits > 0)
   {
      *result <<= digits;
      digits -= std::numeric_limits<unsigned long>::digits;
      mpf_mul_2exp(t.data(), t.data(), digits >= 0 ? std::numeric_limits<unsigned long>::digits : std::numeric_limits<unsigned long>::digits + digits);
      unsigned long l = static_cast<unsigned long>(mpf_get_ui(t.data()));
      if (digits < 0)
         l >>= -digits;
      *result |= l;
   }
}
#endif


#ifdef BOOST_HAS_FLOAT128
template <unsigned digits10>
inline void eval_convert_to(float128_type* result, const gmp_float<digits10>& val)
{
   *result = float128_procs::strtoflt128(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
#endif


//
// Native non-member operations:
//
template <unsigned Digits10>
inline void eval_sqrt(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_sqrt(result.data(), val.data());
}

template <unsigned Digits10>
inline void eval_abs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_abs(result.data(), val.data());
}

template <unsigned Digits10>
inline void eval_fabs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_abs(result.data(), val.data());
}
template <unsigned Digits10>
inline void eval_ceil(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_ceil(result.data(), val.data());
}
template <unsigned Digits10>
inline void eval_floor(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_floor(result.data(), val.data());
}
template <unsigned Digits10>
inline void eval_trunc(gmp_float<Digits10>& result, const gmp_float<Digits10>& val)
{
   mpf_trunc(result.data(), val.data());
}
template <unsigned Digits10>
inline void eval_ldexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long e)
{
   if (e > 0)
      mpf_mul_2exp(result.data(), val.data(), static_cast<mp_bitcnt_t>(e));
   else if (e < 0)
      mpf_div_2exp(result.data(), val.data(), static_cast<mp_bitcnt_t>(-e));
   else
      result = val;
}
template <unsigned Digits10>
inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, int* e)
{
#if (BOOST_MP_MPIR_VERSION >= 20600) && (BOOST_MP_MPIR_VERSION < 30000)
   mpir_si v;
   mpf_get_d_2exp(&v, val.data());
#else
   long v;
   mpf_get_d_2exp(&v, val.data());
#endif
   *e = static_cast<int>(v);
   eval_ldexp(result, val, -v);
}
template <unsigned Digits10>
inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long* e)
{
#if (BOOST_MP_MPIR_VERSION >= 20600) && (BOOST_MP_MPIR_VERSION < 30000)
   mpir_si v;
   mpf_get_d_2exp(&v, val.data());
   *e = v;
   eval_ldexp(result, val, -v);
#else
   mpf_get_d_2exp(e, val.data());
   eval_ldexp(result, val, -*e);
#endif
}

template <unsigned Digits10>
inline std::size_t hash_value(const gmp_float<Digits10>& val)
{
   std::size_t result = 0;
   for (int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_exp, val.data()[0]._mp_size);
   return result;
}

struct gmp_int
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;

   gmp_int()
   {
      mpz_init(this->m_data);
   }
   gmp_int(const gmp_int& o)
   {
      if (o.m_data[0]._mp_d)
         mpz_init_set(m_data, o.m_data);
      else
         mpz_init(this->m_data);
   }
   // rvalue
   gmp_int(gmp_int&& o) noexcept
   {
      m_data[0]         = o.m_data[0];
      o.m_data[0]._mp_d = nullptr;
   }
   explicit gmp_int(const mpf_t val)
   {
      mpz_init(this->m_data);
      mpz_set_f(this->m_data, val);
   }
   gmp_int(const mpz_t val)
   {
      mpz_init_set(this->m_data, val);
   }
   gmp_int(long i)
   {
      mpz_init_set_si(this->m_data, i);
   }
   gmp_int(unsigned long i)
   {
      mpz_init_set_ui(this->m_data, i);
   }
   explicit gmp_int(const mpq_t val)
   {
      mpz_init(this->m_data);
      mpz_set_q(this->m_data, val);
   }
   template <unsigned Digits10>
   explicit gmp_int(const gmp_float<Digits10>& o)
   {
      mpz_init(this->m_data);
      mpz_set_f(this->m_data, o.data());
   }
   explicit gmp_int(const gmp_rational& o);
   gmp_int& operator=(const gmp_int& o)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set(m_data, o.m_data);
      return *this;
   }
   // rvalue copy
   gmp_int& operator=(gmp_int&& o) noexcept
   {
      mpz_swap(m_data, o.m_data);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
   gmp_int& operator=(unsigned long long i)
   {
      *this = static_cast<unsigned long>(i);
      return *this;
   }
#else
   gmp_int& operator=(unsigned long long i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned               shift = 0;
      mpz_t                  t;
      mpz_set_ui(m_data, 0);
      mpz_init_set_ui(t, 0);
      while (i)
      {
         mpz_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpz_mul_2exp(t, t, shift);
         mpz_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpz_clear(t);
      return *this;
   }
#endif
   gmp_int& operator=(long long i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpz_neg(m_data, m_data);
      return *this;
   }
#endif
#ifdef BOOST_HAS_INT128
   gmp_int& operator=(uint128_type i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      uint128_type mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned               shift = 0;
      mpz_t                  t;
      mpz_set_ui(m_data, 0);
      mpz_init_set_ui(t, 0);
      while (i)
      {
         mpz_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpz_mul_2exp(t, t, shift);
         mpz_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpz_clear(t);
      return *this;
   }
   gmp_int& operator=(int128_type i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpz_neg(m_data, m_data);
      return *this;
   }
#endif
   gmp_int& operator=(unsigned long i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_ui(m_data, i);
      return *this;
   }
   gmp_int& operator=(long i)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_si(m_data, i);
      return *this;
   }
   gmp_int& operator=(double d)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_d(m_data, d);
      return *this;
   }
   template <class F>
   gmp_int& assign_float(F a)
   {
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);

      if (a == 0)
      {
         mpz_set_si(m_data, 0);
         return *this;
      }

      if (a == 1)
      {
         mpz_set_si(m_data, 1);
         return *this;
      }

      BOOST_MP_ASSERT(!BOOST_MP_ISINF(a));
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a));

      int         e;
      F f, term;
      mpz_set_ui(m_data, 0u);

      f = frexp(a, &e);

      constexpr int shift = std::numeric_limits<int>::digits - 1;

      while (f != static_cast<F>(0.0f))
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpz_mul_2exp(m_data, m_data, shift);
         if (term > 0)
            mpz_add_ui(m_data, m_data, static_cast<unsigned>(term));
         else
            mpz_sub_ui(m_data, m_data, static_cast<unsigned>(-term));
         f -= term;
      }
      if (e > 0)
         mpz_mul_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(e));
      else if (e < 0)
         mpz_div_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(-e));
      return *this;
   }
   gmp_int& operator=(long double a)
   {
      return assign_float(a);
   }
   gmp_int& operator=(const char* s)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      std::size_t n     = s ? std::strlen(s) : 0;
      int         radix = 10;
      if (n && (*s == '0'))
      {
         if ((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
         {
            radix = 16;
            s += 2;
            n -= 2;
         }
         else
         {
            radix = 8;
            n -= 1;
         }
      }
      if (n)
      {
         if (0 != mpz_set_str(m_data, s, radix))
            BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid integer.")));
      }
      else
         mpz_set_ui(m_data, 0);
      return *this;
   }
#ifdef BOOST_HAS_FLOAT128
   gmp_int& operator=(float128_type a)
   {
      return assign_float(a);
   }
#endif
   gmp_int& operator=(const mpf_t val)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_f(this->m_data, val);
      return *this;
   }
   gmp_int& operator=(const mpz_t val)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set(this->m_data, val);
      return *this;
   }
   gmp_int& operator=(const mpq_t val)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_q(this->m_data, val);
      return *this;
   }
   template <unsigned Digits10>
   gmp_int& operator=(const gmp_float<Digits10>& o)
   {
      if (m_data[0]._mp_d == nullptr)
         mpz_init(this->m_data);
      mpz_set_f(this->m_data, o.data());
      return *this;
   }
   gmp_int& operator=(const gmp_rational& o);
   void     swap(gmp_int& o)
   {
      mpz_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);

      int base = 10;
      if ((f & std::ios_base::oct) == std::ios_base::oct)
         base = 8;
      else if ((f & std::ios_base::hex) == std::ios_base::hex)
         base = 16;
      //
      // sanity check, bases 8 and 16 are only available for positive numbers:
      //
      if ((base != 10) && (mpz_sgn(m_data) < 0))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Formatted output in bases 8 or 16 is only available for positive numbers"));
      void* (*alloc_func_ptr)(size_t);
      void* (*realloc_func_ptr)(void*, size_t, size_t);
      void (*free_func_ptr)(void*, size_t);
      const char* ps = mpz_get_str(nullptr, base, m_data);
      std::string s  = ps;
      mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
      (*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
      if (f & std::ios_base::uppercase)
         for (size_t i = 0; i < s.length(); ++i)
            s[i] = static_cast<char>(std::toupper(s[i]));
      if ((base != 10) && (f & std::ios_base::showbase))
      {
         int         pos = s[0] == '-' ? 1 : 0;
         const char* pp  = base == 8 ? "0" : (f & std::ios_base::uppercase) ? "0X" : "0x";
         s.insert(static_cast<std::string::size_type>(pos), pp);
      }
      if ((f & std::ios_base::showpos) && (s[0] != '-'))
         s.insert(static_cast<std::string::size_type>(0), 1, '+');

      return s;
   }
   ~gmp_int() noexcept
   {
      if (m_data[0]._mp_d)
         mpz_clear(m_data);
   }
   void negate() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      mpz_neg(m_data, m_data);
   }
   int compare(const gmp_int& o) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d && o.m_data[0]._mp_d);
      return mpz_cmp(m_data, o.m_data);
   }
   int compare(long i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return mpz_cmp_si(m_data, i);
   }
   int compare(unsigned long i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return mpz_cmp_ui(m_data, i);
   }
   template <class V>
   int compare(V v) const
   {
      gmp_int d;
      d = v;
      return compare(d);
   }
   mpz_t& data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return m_data;
   }
   const mpz_t& data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mp_d);
      return m_data;
   }

 protected:
   mpz_t m_data;
};

template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const gmp_int& a, const T& b)
{
   return a.compare(b) == 0;
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const gmp_int& a, const T& b)
{
   return a.compare(b) < 0;
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const gmp_int& a, const T& b)
{
   return a.compare(b) > 0;
}

inline bool eval_is_zero(const gmp_int& val)
{
   return mpz_sgn(val.data()) == 0;
}
inline void eval_add(gmp_int& t, const gmp_int& o)
{
   mpz_add(t.data(), t.data(), o.data());
}
inline void eval_multiply_add(gmp_int& t, const gmp_int& a, const gmp_int& b)
{
   mpz_addmul(t.data(), a.data(), b.data());
}
inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, const gmp_int& b)
{
   mpz_submul(t.data(), a.data(), b.data());
}
inline void eval_subtract(gmp_int& t, const gmp_int& o)
{
   mpz_sub(t.data(), t.data(), o.data());
}
inline void eval_multiply(gmp_int& t, const gmp_int& o)
{
   mpz_mul(t.data(), t.data(), o.data());
}
inline void eval_divide(gmp_int& t, const gmp_int& o)
{
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpz_tdiv_q(t.data(), t.data(), o.data());
}
inline void eval_modulus(gmp_int& t, const gmp_int& o)
{
   mpz_tdiv_r(t.data(), t.data(), o.data());
}
inline void eval_add(gmp_int& t, unsigned long i)
{
   mpz_add_ui(t.data(), t.data(), i);
}
inline void eval_multiply_add(gmp_int& t, const gmp_int& a, unsigned long i)
{
   mpz_addmul_ui(t.data(), a.data(), i);
}
inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, unsigned long i)
{
   mpz_submul_ui(t.data(), a.data(), i);
}
inline void eval_subtract(gmp_int& t, unsigned long i)
{
   mpz_sub_ui(t.data(), t.data(), i);
}
inline void eval_multiply(gmp_int& t, unsigned long i)
{
   mpz_mul_ui(t.data(), t.data(), i);
}
inline void eval_modulus(gmp_int& t, unsigned long i)
{
   mpz_tdiv_r_ui(t.data(), t.data(), i);
}
inline void eval_divide(gmp_int& t, unsigned long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpz_tdiv_q_ui(t.data(), t.data(), i);
}
inline void eval_add(gmp_int& t, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_add_ui(t.data(), t.data(), static_cast<local_uint_type>(i));
   else if (i < 0)
      mpz_sub_ui(t.data(), t.data(), static_cast<local_uint_type>(-i));
}
inline void eval_multiply_add(gmp_int& t, const gmp_int& a, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_addmul_ui(t.data(), a.data(), static_cast<local_uint_type>(i));
   else
      mpz_submul_ui(t.data(), a.data(), static_cast<local_uint_type>(-i));
}
inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_submul_ui(t.data(), a.data(), static_cast<local_uint_type>(i));
   else
      mpz_addmul_ui(t.data(), a.data(), static_cast<local_uint_type>(-i));
}
inline void eval_subtract(gmp_int& t, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_sub_ui(t.data(), t.data(), static_cast<local_uint_type>(i));
   else if (i < 0)
      mpz_add_ui(t.data(), t.data(), static_cast<local_uint_type>(-i));
}
inline void eval_multiply(gmp_int& t, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   mpz_mul_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i)));

   if (i < 0)
      mpz_neg(t.data(), t.data());
}
inline void eval_modulus(gmp_int& t, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   mpz_tdiv_r_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i)));
}
inline void eval_divide(gmp_int& t, long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   mpz_tdiv_q_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i)));

   if (i < 0)
      mpz_neg(t.data(), t.data());
}
template <class UI>
inline void eval_left_shift(gmp_int& t, UI i)
{
   mpz_mul_2exp(t.data(), t.data(), static_cast<unsigned long>(i));
}
template <class UI>
inline void eval_right_shift(gmp_int& t, UI i)
{
   mpz_fdiv_q_2exp(t.data(), t.data(), static_cast<unsigned long>(i));
}
template <class UI>
inline void eval_left_shift(gmp_int& t, const gmp_int& v, UI i)
{
   mpz_mul_2exp(t.data(), v.data(), static_cast<unsigned long>(i));
}
template <class UI>
inline void eval_right_shift(gmp_int& t, const gmp_int& v, UI i)
{
   mpz_fdiv_q_2exp(t.data(), v.data(), static_cast<unsigned long>(i));
}

inline void eval_bitwise_and(gmp_int& result, const gmp_int& v)
{
   mpz_and(result.data(), result.data(), v.data());
}

inline void eval_bitwise_or(gmp_int& result, const gmp_int& v)
{
   mpz_ior(result.data(), result.data(), v.data());
}

inline void eval_bitwise_xor(gmp_int& result, const gmp_int& v)
{
   mpz_xor(result.data(), result.data(), v.data());
}

inline void eval_add(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
   mpz_add(t.data(), p.data(), o.data());
}
inline void eval_subtract(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
   mpz_sub(t.data(), p.data(), o.data());
}
inline void eval_multiply(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
   mpz_mul(t.data(), p.data(), o.data());
}
inline void eval_divide(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpz_tdiv_q(t.data(), p.data(), o.data());
}
inline void eval_modulus(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
   mpz_tdiv_r(t.data(), p.data(), o.data());
}
inline void eval_add(gmp_int& t, const gmp_int& p, unsigned long i)
{
   mpz_add_ui(t.data(), p.data(), i);
}
inline void eval_subtract(gmp_int& t, const gmp_int& p, unsigned long i)
{
   mpz_sub_ui(t.data(), p.data(), i);
}
inline void eval_multiply(gmp_int& t, const gmp_int& p, unsigned long i)
{
   mpz_mul_ui(t.data(), p.data(), i);
}
inline void eval_modulus(gmp_int& t, const gmp_int& p, unsigned long i)
{
   mpz_tdiv_r_ui(t.data(), p.data(), i);
}
inline void eval_divide(gmp_int& t, const gmp_int& p, unsigned long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpz_tdiv_q_ui(t.data(), p.data(), i);
}
inline void eval_add(gmp_int& t, const gmp_int& p, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_add_ui(t.data(), p.data(), static_cast<local_uint_type>(i));
   else
      mpz_sub_ui(t.data(), p.data(), static_cast<local_uint_type>(-i));
}
inline void eval_subtract(gmp_int& t, const gmp_int& p, long i)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (i > 0)
      mpz_sub_ui(t.data(), p.data(), static_cast<local_uint_type>(i));
   else
      mpz_add_ui(t.data(), p.data(), static_cast<local_uint_type>(-i));
}
inline void eval_multiply(gmp_int& t, const gmp_int& p, long i)
{
   mpz_mul_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
   if (i < 0)
      mpz_neg(t.data(), t.data());
}
inline void eval_modulus(gmp_int& t, const gmp_int& p, long i)
{
   mpz_tdiv_r_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
}
inline void eval_divide(gmp_int& t, const gmp_int& p, long i)
{
   if (i == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpz_tdiv_q_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
   if (i < 0)
      mpz_neg(t.data(), t.data());
}

inline void eval_bitwise_and(gmp_int& result, const gmp_int& u, const gmp_int& v)
{
   mpz_and(result.data(), u.data(), v.data());
}

inline void eval_bitwise_or(gmp_int& result, const gmp_int& u, const gmp_int& v)
{
   mpz_ior(result.data(), u.data(), v.data());
}

inline void eval_bitwise_xor(gmp_int& result, const gmp_int& u, const gmp_int& v)
{
   mpz_xor(result.data(), u.data(), v.data());
}

inline void eval_complement(gmp_int& result, const gmp_int& u)
{
   mpz_com(result.data(), u.data());
}

inline int eval_get_sign(const gmp_int& val)
{
   return mpz_sgn(val.data());
}
inline void eval_convert_to(unsigned long* result, const gmp_int& val)
{
   if (mpz_sgn(val.data()) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour"));
   }
   else
      *result = static_cast<unsigned long>(mpz_get_ui(val.data()));
}
inline void eval_convert_to(long* result, const gmp_int& val)
{
   if (0 == mpz_fits_slong_p(val.data()))
   {
      *result = mpz_sgn(val.data()) < 0 ? (std::numeric_limits<long>::min)() : (std::numeric_limits<long>::max)();
   }
   else
      *result = static_cast<long>(mpz_get_si(val.data()));
}
inline void eval_convert_to(long double* result, const gmp_int& val)
{
   detail::gmp_char_ptr val_char_ptr {mpz_get_str(nullptr, 10, val.data())};
   *result = std::strtold(val_char_ptr.get(), nullptr);
}
inline void eval_convert_to(double* result, const gmp_int& val)
{
   *result = mpz_get_d(val.data());
}
#ifdef BOOST_HAS_LONG_LONG
inline void eval_convert_to(unsigned long long* result, const gmp_int& val)
{
   if (mpz_sgn(val.data()) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour"));
   }
   *result = 0;
   gmp_int t(val);
   unsigned parts = sizeof(unsigned long long) / sizeof(unsigned long);

   for (unsigned i = 0; i < parts; ++i)
   {
      unsigned long long part = mpz_get_ui(t.data());
      if (i)
         *result |= part << (i * sizeof(unsigned long) * CHAR_BIT);
      else
         *result = part;
      mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT);
   }
}
inline void eval_convert_to(long long* result, const gmp_int& val)
{
   int s = mpz_sgn(val.data());
   *result = 0;
   gmp_int t(val);
   unsigned parts = sizeof(unsigned long long) / sizeof(unsigned long);
   unsigned long long unsigned_result = 0;

   for (unsigned i = 0; i < parts; ++i)
   {
      unsigned long long part = mpz_get_ui(t.data());
      if (i)
         unsigned_result |= part << (i * sizeof(unsigned long) * CHAR_BIT);
      else
         unsigned_result = part;
      mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT);
   }
   //
   // Overflow check:
   //
   bool overflow = false;
   if (mpz_sgn(t.data()))
   {
      overflow = true;
   }
   if ((s > 0) && (unsigned_result > static_cast<unsigned long long>((std::numeric_limits<long long>::max)())))
      overflow = true;
   if((s < 0) && (unsigned_result > 1u - static_cast<unsigned long long>((std::numeric_limits<long long>::min)() + 1)))
      overflow = true;
   if(overflow)
      *result = s < 0 ? (std::numeric_limits<long long>::min)() : (std::numeric_limits<long long>::max)();
   else
      *result = s < 0 ? -static_cast<long long>(unsigned_result - 1u) - 1 : static_cast<long long>(unsigned_result);
}
#endif
#ifdef BOOST_HAS_INT128
inline void eval_convert_to(uint128_type* result, const gmp_int& val)
{
   if (mpz_sgn(val.data()) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour"));
   }
   *result = 0;
   gmp_int t(val);
   unsigned parts = sizeof(uint128_type) / sizeof(unsigned long);

   for (unsigned i = 0; i < parts; ++i)
   {
      uint128_type part = mpz_get_ui(t.data());
      if (i)
         *result |= part << (i * sizeof(unsigned long) * CHAR_BIT);
      else
         *result = part;
      mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT);
   }
}
inline void eval_convert_to(int128_type* result, const gmp_int& val)
{
   int s = mpz_sgn(val.data());
   *result = 0;
   gmp_int t(val);
   unsigned parts = sizeof(uint128_type) / sizeof(unsigned long);
   uint128_type unsigned_result = 0;

   for (unsigned i = 0; i < parts; ++i)
   {
      uint128_type part = mpz_get_ui(t.data());
      if (i)
         unsigned_result |= part << (i * sizeof(unsigned long) * CHAR_BIT);
      else
         unsigned_result = part;
      mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT);
   }
   //
   // Overflow check:
   //
   constexpr int128_type int128_max = static_cast<int128_type>((static_cast<uint128_type>(1u) << 127) - 1);
   constexpr int128_type int128_min = static_cast<int128_type>(static_cast<int128_type>(-int128_max) -1);
   bool overflow = false;
   if (mpz_sgn(t.data()))
   {
      overflow = true;
   }
   if ((s > 0) && (unsigned_result > static_cast<uint128_type>(int128_max)))
      overflow = true;
   if ((s < 0) && (unsigned_result > 1u - static_cast<uint128_type>(int128_min + 1)))
      overflow = true;
   if (overflow)
      *result = s < 0 ? int128_min : int128_max;
   else
      *result = s < 0 ? -static_cast<int128_type>(unsigned_result - 1u) - 1 : static_cast<int128_type>(unsigned_result);
}

template <unsigned digits10>
inline void eval_convert_to(int128_type* result, const gmp_float<digits10>& val)
{
   gmp_int i;
   mpz_set_f(i.data(), val.data());
   eval_convert_to(result, i);
}
template <unsigned digits10>
inline void eval_convert_to(uint128_type* result, const gmp_float<digits10>& val)
{
   gmp_int i;
   mpz_set_f(i.data(), val.data());
   eval_convert_to(result, i);
}

#endif

#ifdef BOOST_HAS_FLOAT128
inline void eval_convert_to(float128_type* result, const gmp_int& val)
{
   *result = float128_procs::strtoflt128(val.str(0, std::ios_base::fixed).c_str(), nullptr);
}
#endif

inline void eval_abs(gmp_int& result, const gmp_int& val)
{
   mpz_abs(result.data(), val.data());
}

inline void eval_gcd(gmp_int& result, const gmp_int& a, const gmp_int& b)
{
   mpz_gcd(result.data(), a.data(), b.data());
}
inline void eval_lcm(gmp_int& result, const gmp_int& a, const gmp_int& b)
{
   mpz_lcm(result.data(), a.data(), b.data());
}
template <class I>
inline typename std::enable_if<(boost::multiprecision::detail::is_unsigned<I>::value && (sizeof(I) <= sizeof(unsigned long)))>::type eval_gcd(gmp_int& result, const gmp_int& a, const I b)
{
   mpz_gcd_ui(result.data(), a.data(), b);
}
template <class I>
inline typename std::enable_if<(boost::multiprecision::detail::is_unsigned<I>::value && (sizeof(I) <= sizeof(unsigned long)))>::type eval_lcm(gmp_int& result, const gmp_int& a, const I b)
{
   mpz_lcm_ui(result.data(), a.data(), b);
}
template <class I>
inline typename std::enable_if<(boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value && (sizeof(I) <= sizeof(long)))>::type eval_gcd(gmp_int& result, const gmp_int& a, const I b)
{
   mpz_gcd_ui(result.data(), a.data(), boost::multiprecision::detail::unsigned_abs(b));
}
template <class I>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value && ((sizeof(I) <= sizeof(long)))>::type eval_lcm(gmp_int& result, const gmp_int& a, const I b)
{
   mpz_lcm_ui(result.data(), a.data(), boost::multiprecision::detail::unsigned_abs(b));
}

inline void eval_integer_sqrt(gmp_int& s, gmp_int& r, const gmp_int& x)
{
   mpz_sqrtrem(s.data(), r.data(), x.data());
}

inline std::size_t eval_lsb(const gmp_int& val)
{
   int c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return static_cast<unsigned>(mpz_scan1(val.data(), 0));
}

inline std::size_t eval_msb(const gmp_int& val)
{
   int c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return static_cast<unsigned>(mpz_sizeinbase(val.data(), 2) - 1);
}

inline bool eval_bit_test(const gmp_int& val, std::size_t index)
{
   return mpz_tstbit(val.data(), index) ? true : false;
}

inline void eval_bit_set(gmp_int& val, std::size_t index)
{
   mpz_setbit(val.data(), index);
}

inline void eval_bit_unset(gmp_int& val, std::size_t index)
{
   mpz_clrbit(val.data(), index);
}

inline void eval_bit_flip(gmp_int& val, std::size_t index)
{
   mpz_combit(val.data(), index);
}

inline void eval_qr(const gmp_int& x, const gmp_int& y,
                    gmp_int& q, gmp_int& r)
{
   mpz_tdiv_qr(q.data(), r.data(), x.data(), y.data());
}

template <class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value, Integer>::type eval_integer_modulus(const gmp_int& x, Integer val)
{
#if defined(__MPIR_VERSION) && (__MPIR_VERSION >= 3)
   if ((sizeof(Integer) <= sizeof(mpir_ui)) || (val <= (std::numeric_limits<mpir_ui>::max)()))
#else
   if ((sizeof(Integer) <= sizeof(long)) || (val <= (std::numeric_limits<unsigned long>::max)()))
#endif
   {
      return static_cast<Integer>(mpz_tdiv_ui(x.data(), val));
   }
   else
   {
      return default_ops::eval_integer_modulus(x, val);
   }
}
template <class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value, Integer>::type eval_integer_modulus(const gmp_int& x, Integer val)
{
   return eval_integer_modulus(x, boost::multiprecision::detail::unsigned_abs(val));
}
inline void eval_powm(gmp_int& result, const gmp_int& base, const gmp_int& p, const gmp_int& m)
{
   if (eval_get_sign(p) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   mpz_powm(result.data(), base.data(), p.data(), m.data());
}

template <class Integer>
inline typename std::enable_if<
    boost::multiprecision::detail::is_unsigned<Integer>::value && (sizeof(Integer) <= sizeof(unsigned long))>::type
eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
{
   mpz_powm_ui(result.data(), base.data(), p, m.data());
}
template <class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value && (sizeof(Integer) <= sizeof(unsigned long))>::type
eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
{
   if (p < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   mpz_powm_ui(result.data(), base.data(), p, m.data());
}

inline std::size_t hash_value(const gmp_int& val)
{
   // We should really use mpz_limbs_read here, but that's unsupported on older versions:
   std::size_t result = 0;
   for (int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_size);
   return result;
}

struct gmp_rational;
void eval_add(gmp_rational& t, const gmp_rational& o);

struct gmp_rational
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;

   gmp_rational()
   {
      mpq_init(this->m_data);
   }
   gmp_rational(const gmp_rational& o)
   {
      mpq_init(m_data);
      if (o.m_data[0]._mp_num._mp_d)
         mpq_set(m_data, o.m_data);
   }
   gmp_rational(const gmp_int& o)
   {
      mpz_init_set(&m_data[0]._mp_num, o.data());
      mpz_init_set_ui(&m_data[0]._mp_den, 1u);
   }
   gmp_rational(long i)
   {
      mpz_init_set_si(&m_data[0]._mp_num, i);
      mpz_init_set_ui(&m_data[0]._mp_den, 1u);
   }
   gmp_rational(unsigned long ui)
   {
      mpz_init_set_ui(&m_data[0]._mp_num, ui);
      mpz_init_set_ui(&m_data[0]._mp_den, 1u);
   }
   // 2-arg constructors:
   template <class T, class U>
   gmp_rational(const T& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value && std::is_constructible<gmp_int, U>::value>::type* = nullptr)
   {
      gmp_int i(a), j(b);

      if (eval_is_zero(j))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      m_data[0]._mp_num = i.data()[0];
      m_data[0]._mp_den = j.data()[0];
      mpq_canonicalize(m_data);
      i.data()[0]._mp_d = nullptr;
      j.data()[0]._mp_d = nullptr;
   }
   template <class U>
   gmp_rational(const gmp_int& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, U>::value>::type* = nullptr)
   {
      gmp_int j(b);

      if (eval_is_zero(j))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      mpz_init_set(&m_data[0]._mp_num, a.data());
      m_data[0]._mp_den = j.data()[0];
      if (boost::multiprecision::detail::unsigned_abs(b) > 1)
         mpq_canonicalize(m_data);
      j.data()[0]._mp_d = nullptr;
   }
   template <class U>
   gmp_rational(gmp_int&& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, U>::value>::type* = nullptr)
   {
      gmp_int j(b);

      if (eval_is_zero(j))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      m_data[0]._mp_num = a.data()[0];
      m_data[0]._mp_den = j.data()[0];
      if (boost::multiprecision::detail::unsigned_abs(b) > 1)
         mpq_canonicalize(m_data);
      a.data()[0]._mp_d = nullptr;
      j.data()[0]._mp_d = nullptr;
   }
   template <class T>
   gmp_rational(const T& a, const gmp_int& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value>::type* = nullptr)
   {
      if (eval_is_zero(b))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      gmp_int i(a);
      m_data[0]._mp_num = i.data()[0];
      mpz_init_set(&m_data[0]._mp_den, b.data());
      if(boost::multiprecision::detail::unsigned_abs(a) > 1)
         mpq_canonicalize(m_data);
      i.data()[0]._mp_d = nullptr;
   }
   template <class T>
   gmp_rational(const T& a, gmp_int&& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value>::type* = nullptr)
   {
      if (eval_is_zero(static_cast<gmp_int&&>(b)))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      gmp_int i(a);
      m_data[0]._mp_num = i.data()[0];
      m_data[0]._mp_den = b.data()[0];
      if(boost::multiprecision::detail::unsigned_abs(a) > 1)
         mpq_canonicalize(m_data);
      i.data()[0]._mp_d = nullptr;
      b.data()[0]._mp_d = nullptr;
   }
   gmp_rational(const gmp_int& a, const gmp_int& b)
   {
      if (eval_is_zero(b))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      mpz_init_set(&m_data[0]._mp_num, a.data());
      mpz_init_set(&m_data[0]._mp_den, b.data());
      mpq_canonicalize(m_data);
   }
   gmp_rational(const gmp_int& a, gmp_int&& b)
   {
      if (eval_is_zero(static_cast<gmp_int&&>(b)))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      mpz_init_set(&m_data[0]._mp_num, a.data());
      m_data[0]._mp_den = b.data()[0];
      mpq_canonicalize(m_data);
      b.data()[0]._mp_d = nullptr;
   }
   gmp_rational(gmp_int&& a, const gmp_int& b)
   {
      if (eval_is_zero(b))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      m_data[0]._mp_num = a.data()[0];
      mpz_init_set(&m_data[0]._mp_den, b.data());
      mpq_canonicalize(m_data);
      a.data()[0]._mp_d = nullptr;
   }
   gmp_rational(gmp_int&& a, gmp_int&& b)
   {
      if (eval_is_zero(static_cast<gmp_int&&>(b)))
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

      m_data[0]._mp_num = a.data()[0];
      m_data[0]._mp_den = b.data()[0];
      mpq_canonicalize(m_data);
      a.data()[0]._mp_d = nullptr;
      b.data()[0]._mp_d = nullptr;
   }
   // rvalue copy
   gmp_rational(gmp_rational&& o) noexcept
   {
      m_data[0]                 = o.m_data[0];
      o.m_data[0]._mp_num._mp_d = nullptr;
      o.m_data[0]._mp_den._mp_d = nullptr;
   }
   gmp_rational(const mpq_t o)
   {
      mpq_init(m_data);
      mpq_set(m_data, o);
   }
   gmp_rational(const mpz_t o)
   {
      mpq_init(m_data);
      mpq_set_z(m_data, o);
   }
   gmp_rational& operator=(const gmp_rational& o)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set(m_data, o.m_data);
      return *this;
   }
   // rvalue assign
   gmp_rational& operator=(gmp_rational&& o) noexcept
   {
      mpq_swap(m_data, o.m_data);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
   gmp_rational& operator=(unsigned long long i)
   {
      *this = static_cast<unsigned long>(i);
      return *this;
   }
#else
   gmp_rational& operator=(unsigned long long i)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      gmp_int zi;
      zi = i;
      mpq_set_z(m_data, zi.data());
      return *this;
   }
   gmp_rational& operator=(long long i)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpq_neg(m_data, m_data);
      return *this;
   }
#endif
#endif
   gmp_rational& operator=(unsigned long i)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set_ui(m_data, i, 1);
      return *this;
   }
   gmp_rational& operator=(long i)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set_si(m_data, i, 1);
      return *this;
   }
   gmp_rational& operator=(double d)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set_d(m_data, d);
      return *this;
   }
   template <class F>
   gmp_rational& assign_float(F a)
   {
      using default_ops::eval_add;
      using default_ops::eval_subtract;
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);

      if (a == 0)
      {
         mpq_set_si(m_data, 0, 1);
         return *this;
      }

      if (a == 1)
      {
         mpq_set_si(m_data, 1, 1);
         return *this;
      }

      BOOST_MP_ASSERT(!BOOST_MP_ISINF(a));
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a));

      int         e;
      F f, term;
      mpq_set_ui(m_data, 0, 1);
      mpq_set_ui(m_data, 0u, 1);
      gmp_rational t;

      f = frexp(a, &e);

      constexpr int shift = std::numeric_limits<int>::digits - 1;

      while (f != static_cast<F>(0.0f))
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpq_mul_2exp(m_data, m_data, shift);
         t = static_cast<long>(term);
         eval_add(*this, t);
         f -= term;
      }
      if (e > 0)
         mpq_mul_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(e));
      else if (e < 0)
         mpq_div_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(-e));
      return *this;
   }
   gmp_rational& operator=(long double a)
   {
      return assign_float(a);
   }
#ifdef BOOST_HAS_FLOAT128
   gmp_rational& operator=(float128_type a)
   {
      return assign_float(a);
   }
#endif
#ifdef BOOST_HAS_INT128
   gmp_rational& operator=(uint128_type i)
   {
      gmp_int gi;
      gi = i;
      return *this = gi;
   }
   gmp_rational& operator=(int128_type i)
   {
      gmp_int gi;
      gi = i;
      return *this = gi;
   }
#endif
   gmp_rational& operator=(const char* s)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      if (0 != mpq_set_str(m_data, s, 10))
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid rational number.")));
      return *this;
   }
   gmp_rational& operator=(const gmp_int& o)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set_z(m_data, o.data());
      return *this;
   }
   gmp_rational& operator=(const mpq_t o)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set(m_data, o);
      return *this;
   }
   gmp_rational& operator=(const mpz_t o)
   {
      if (m_data[0]._mp_den._mp_d == nullptr)
         mpq_init(m_data);
      mpq_set_z(m_data, o);
      return *this;
   }
   void swap(gmp_rational& o)
   {
      mpq_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags /*f*/) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      // TODO make a better job of this including handling of f!!
      void* (*alloc_func_ptr)(size_t);
      void* (*realloc_func_ptr)(void*, size_t, size_t);
      void (*free_func_ptr)(void*, size_t);
      const char* ps = mpq_get_str(nullptr, 10, m_data);
      std::string s  = ps;
      mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
      (*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
      return s;
   }
   ~gmp_rational()
   {
      if (m_data[0]._mp_num._mp_d || m_data[0]._mp_den._mp_d)
         mpq_clear(m_data);
   }
   void negate()
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      mpq_neg(m_data, m_data);
   }
   int compare(const gmp_rational& o) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d && o.m_data[0]._mp_num._mp_d);
      return mpq_cmp(m_data, o.m_data);
   }
   template <class V>
   int compare(V v) const
   {
      gmp_rational d;
      d = v;
      return compare(d);
   }
   int compare(unsigned long v) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      return mpq_cmp_ui(m_data, v, 1);
   }
   int compare(long v) const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      return mpq_cmp_si(m_data, v, 1);
   }
   mpq_t& data()
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      return m_data;
   }
   const mpq_t& data() const
   {
      BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d);
      return m_data;
   }

 protected:
   mpq_t m_data;
};

inline bool eval_is_zero(const gmp_rational& val)
{
   return mpq_sgn(val.data()) == 0;
}
template <class T>
inline bool eval_eq(gmp_rational& a, const T& b)
{
   return a.compare(b) == 0;
}
template <class T>
inline bool eval_lt(gmp_rational& a, const T& b)
{
   return a.compare(b) < 0;
}
template <class T>
inline bool eval_gt(gmp_rational& a, const T& b)
{
   return a.compare(b) > 0;
}

inline void eval_add(gmp_rational& t, const gmp_rational& o)
{
   mpq_add(t.data(), t.data(), o.data());
}
inline void eval_subtract(gmp_rational& t, const gmp_rational& o)
{
   mpq_sub(t.data(), t.data(), o.data());
}
inline void eval_multiply(gmp_rational& t, const gmp_rational& o)
{
   mpq_mul(t.data(), t.data(), o.data());
}
inline void eval_divide(gmp_rational& t, const gmp_rational& o)
{
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpq_div(t.data(), t.data(), o.data());
}
inline void eval_add(gmp_rational& t, const gmp_rational& p, const gmp_rational& o)
{
   mpq_add(t.data(), p.data(), o.data());
}
inline void eval_subtract(gmp_rational& t, const gmp_rational& p, const gmp_rational& o)
{
   mpq_sub(t.data(), p.data(), o.data());
}
inline void eval_multiply(gmp_rational& t, const gmp_rational& p, const gmp_rational& o)
{
   mpq_mul(t.data(), p.data(), o.data());
}
inline void eval_divide(gmp_rational& t, const gmp_rational& p, const gmp_rational& o)
{
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));
   mpq_div(t.data(), p.data(), o.data());
}
//
// operator with scalars:
//
inline void eval_add(gmp_rational& result, gmp_rational const& a, gmp_int const& b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
   mpz_addmul(mpq_numref(result.data()), mpq_denref(a.data()), b.data());
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
inline void eval_add(gmp_rational& result, gmp_rational const& a, unsigned long b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
   mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), b);
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
inline void eval_add(gmp_rational& result, gmp_rational const& a, long b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if(b > 0)
      mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(b));
   else
      mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(-b));
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, gmp_rational const& a, const T& b)
{
   gmp_int t;
   t = b;
   eval_add(result, a, t);
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, const T& b, gmp_rational const& a)
{
   eval_add(result, a, b);
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, const T& b)
{
   eval_add(result, result, b);
}
inline void eval_subtract(gmp_rational& result, gmp_rational const& a, gmp_int const& b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
   mpz_submul(mpq_numref(result.data()), mpq_denref(a.data()), b.data());
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
inline void eval_subtract(gmp_rational& result, gmp_rational const& a, unsigned long b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
   mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), b);
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
inline void eval_subtract(gmp_rational& result, gmp_rational const& a, long b)
{
   // we allow result and a to be the same object here:
   if (&a != &result)
   {
      mpz_set(mpq_numref(result.data()), mpq_numref(a.data()));
      mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if(b > 0)
      mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(b));
   else
      mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(-b));
   // no need to normalize, there can be no common divisor as long as a is already normalized.
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, gmp_rational const& a, const T& b)
{
   gmp_int t;
   t = b;
   eval_subtract(result, a, t);
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, const T& b, gmp_rational const& a)
{
   eval_subtract(result, a, b);
   result.negate();
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, const T& b)
{
   eval_subtract(result, result, b);
}

inline void eval_multiply(gmp_rational& result, gmp_rational const& a, gmp_int const& b)
{
   gmp_int g, t;
   mpz_gcd(g.data(), mpq_denref(a.data()), b.data());
   if (!mpz_fits_uint_p(g.data()) || (mpz_get_ui(g.data()) != 1))
   {
      // We get here if the gcd is not unity, this is true if the number is
      // too large for an unsigned long, or if we get an unsigned long and check against 1.
      eval_divide(t, b, g);
      mpz_mul(mpq_numref(result.data()), t.data(), mpq_numref(a.data()));
      mpz_divexact(mpq_denref(result.data()), mpq_denref(a.data()), g.data());
   }
   else
   {
      // gcd is 1.
      mpz_mul(mpq_numref(result.data()), mpq_numref(a.data()), b.data());
      if (&result != &a)
         mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
}
inline void eval_multiply(gmp_rational& result, gmp_rational const& a, unsigned long b)
{
   if (b == 0)
   {
      mpq_set_ui(result.data(), b, 1);
      return;
   }
   if (mpz_sgn(mpq_numref(a.data())) == 0)
   {
      result = a;
      return;
   }
   unsigned long g = static_cast<unsigned long>(mpz_gcd_ui(nullptr, mpq_denref(a.data()), b));
   if (g != 1)
   {
      BOOST_MP_ASSERT(g);
      b /= g;
      mpz_mul_ui(mpq_numref(result.data()), mpq_numref(a.data()), b);
      mpz_divexact_ui(mpq_denref(result.data()), mpq_denref(a.data()), g);
   }
   else
   {
      mpz_mul_ui(mpq_numref(result.data()), mpq_numref(a.data()), b);
      if (&result != &a)
         mpz_set(mpq_denref(result.data()), mpq_denref(a.data()));
   }
}
inline void eval_multiply(gmp_rational& result, gmp_rational const& a, long b)
{
   eval_multiply(result, a, boost::multiprecision::detail::unsigned_abs(b));
   if (b < 0)
      result.negate();
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, gmp_rational const& a, const T& b)
{
   gmp_int t;
   t = b;
   eval_multiply(result, a, t);
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, const T& b, gmp_rational const& a)
{
   eval_multiply(result, a, b);
}
template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, const T& b)
{
   eval_multiply(result, result, b);
}

inline int eval_get_sign(const gmp_rational& val)
{
   return mpq_sgn(val.data());
}
template <class R>
inline typename std::enable_if<number_category<R>::value == number_kind_floating_point>::type eval_convert_to(R* result, const gmp_rational& backend)
{
   //
   // The generic conversion is as good as anything we can write here:
   //
   // This does not round correctly:
   //
   //*result = mpq_get_d(val.data());
   //
   // This does:
   //
   ::boost::multiprecision::detail::generic_convert_rational_to_float(*result, backend);
}
#ifdef BOOST_HAS_FLOAT128
inline void eval_convert_to(float128_type* result, const gmp_rational& val)
{
   using default_ops::eval_convert_to;

   gmp_int n, d;
   float128_type fn, fd;
   mpz_set(n.data(), mpq_numref(val.data()));
   mpz_set(d.data(), mpq_denref(val.data()));

   eval_convert_to(&fn, n);
   eval_convert_to(&fd, d);

   *result = fn / fd;
}
#endif

template <class R>
inline typename std::enable_if<number_category<R>::value == number_kind_integer>::type eval_convert_to(R* result, const gmp_rational& backend)
{
   gmp_int n(mpq_numref(backend.data()));
   gmp_int d(mpq_denref(backend.data()));
   using default_ops::eval_divide;
   eval_divide(n, d);
   using default_ops::eval_convert_to;
   eval_convert_to(result, n);
}

inline void eval_abs(gmp_rational& result, const gmp_rational& val)
{
   mpq_abs(result.data(), val.data());
}

inline void assign_components(gmp_rational& result, unsigned long v1, unsigned long v2)
{
   if (v2 == 0u)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   mpq_set_ui(result.data(), v1, v2);
   mpq_canonicalize(result.data());
}
inline void assign_components(gmp_rational& result, long v1, long v2)
{
   if (v2 == 0)
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (v2 < 0)
      mpq_set_si(result.data(), -v1, static_cast<local_uint_type>(-v2));
   else
      mpq_set_si(result.data(), v1, static_cast<local_uint_type>(v2));

   mpq_canonicalize(result.data());
}
inline void assign_components(gmp_rational& result, gmp_int const& v1, gmp_int const& v2)
{
   if (eval_is_zero(v2))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   mpz_set(mpq_numref(result.data()), v1.data());
   mpz_set(mpq_denref(result.data()), v2.data());
   mpq_canonicalize(result.data());
}
template <class T, class U>
void assign_components(gmp_rational& result, const T& a, const U& b)
{
   gmp_int x, y;

   x = a;
   y = b;

   if (eval_is_zero(y))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   std::swap(result.data()[0]._mp_num, x.data()[0]);
   std::swap(result.data()[0]._mp_den, y.data()[0]);
   mpq_canonicalize(result.data());
}
template <class U>
void assign_components(gmp_rational& result, const gmp_int& a, const U& b)
{
   gmp_int y;

   y = b;

   if (eval_is_zero(y))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   mpz_set(&result.data()[0]._mp_num, a.data());
   std::swap(result.data()[0]._mp_den, y.data()[0]);
   mpq_canonicalize(result.data());
}
template <class T>
void assign_components(gmp_rational& result, const T& a, const gmp_int& b)
{
   if (eval_is_zero(b))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero."));

   gmp_int x;
   x = a;
   std::swap(result.data()[0]._mp_num, x.data()[0]);
   mpz_set(&result.data()[0]._mp_den, b.data());
   mpq_canonicalize(result.data());
}


inline std::size_t hash_value(const gmp_rational& val)
{
   std::size_t result = 0;
   for (int i = 0; i < std::abs(val.data()[0]._mp_num._mp_size); ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_num._mp_d[i]);
   for (int i = 0; i < std::abs(val.data()[0]._mp_den._mp_size); ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_den._mp_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_num._mp_size);
   return result;
}

//
// Some useful helpers:
//
inline std::size_t used_gmp_int_bits(const gmp_int& val)
{
   return eval_msb(val) - eval_lsb(val) + 1;
}
inline std::size_t used_gmp_rational_bits(const gmp_rational& val)
{
   unsigned d2_d = static_cast<unsigned>(mpz_sizeinbase(mpq_denref(val.data()), 2) - mpz_scan1(mpq_denref(val.data()), 0));
   unsigned d2_n = static_cast<unsigned>(mpz_sizeinbase(mpq_numref(val.data()), 2) - mpz_scan1(mpq_numref(val.data()), 0));
   return (std::max)(d2_d, d2_n);
}

//
// Some member functions that are dependent upon previous code go here:
//
template <unsigned Digits10>
template <unsigned D>
inline gmp_float<Digits10>::gmp_float(const gmp_float<D>& o, typename std::enable_if<D <= Digits10>::type*)
{
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set(this->m_data, o.data());
}
template <unsigned Digits10>
template <unsigned D>
inline gmp_float<Digits10>::gmp_float(const gmp_float<D>& o, typename std::enable_if< !(D <= Digits10)>::type*)
{
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set(this->m_data, o.data());
}
template <unsigned Digits10>
inline gmp_float<Digits10>::gmp_float(const gmp_int& o)
{
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set_z(this->data(), o.data());
}
template <unsigned Digits10>
inline gmp_float<Digits10>::gmp_float(const gmp_rational& o)
{
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set_q(this->data(), o.data());
}
template <unsigned Digits10>
template <unsigned D>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_float<D>& o)
{
   if (this->m_data[0]._mp_d == nullptr)
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set(this->m_data, o.data());
   return *this;
}
template <unsigned Digits10>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_int& o)
{
   if (this->m_data[0]._mp_d == nullptr)
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set_z(this->data(), o.data());
   return *this;
}
template <unsigned Digits10>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_rational& o)
{
   if (this->m_data[0]._mp_d == nullptr)
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision()));
   mpf_set_q(this->data(), o.data());
   return *this;
}
inline gmp_float<0>::gmp_float(const gmp_int& o) : requested_precision(get_default_precision())
{
   if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
   {
      std::size_t d2 = used_gmp_int_bits(o);
      std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2);
      if (d10 > requested_precision)
         requested_precision = static_cast<unsigned>(d10);
   }
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   mpf_set_z(this->data(), o.data());
}
inline gmp_float<0>::gmp_float(const gmp_rational& o) : requested_precision(get_default_precision())
{
   if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
   {
      std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o));
      if (d10 > requested_precision)
         requested_precision = static_cast<unsigned>(d10);
   }
   mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   mpf_set_q(this->data(), o.data());
}
inline gmp_float<0>& gmp_float<0>::operator=(const gmp_int& o)
{
   if (this->m_data[0]._mp_d == nullptr)
   {
      requested_precision = this->get_default_precision();
      if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         std::size_t d2 = used_gmp_int_bits(o);
         std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2);
         if (d10 > requested_precision)
            requested_precision = static_cast<unsigned>(d10);
      }
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   }
   else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
   {
      std::size_t d2 = used_gmp_int_bits(o);
      std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2);
      if (d10 > requested_precision)
         this->precision(static_cast<unsigned>(d10));
   }
   mpf_set_z(this->data(), o.data());
   return *this;
}
inline gmp_float<0>& gmp_float<0>::operator=(const gmp_rational& o)
{
   if (this->m_data[0]._mp_d == nullptr)
   {
      requested_precision = this->get_default_precision();
      if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o));
         if (d10 > requested_precision)
            requested_precision = static_cast<unsigned>(d10);
      }
      mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
   }
   else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
   {
      std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o));
      if (d10 > requested_precision)
         this->precision(static_cast<unsigned>(d10));
   }
   mpf_set_q(this->data(), o.data());
   return *this;
}
inline gmp_int::gmp_int(const gmp_rational& o)
{
   mpz_init(this->m_data);
   mpz_set_q(this->m_data, o.data());
}
inline gmp_int& gmp_int::operator=(const gmp_rational& o)
{
   if (this->m_data[0]._mp_d == nullptr)
      mpz_init(this->m_data);
   mpz_set_q(this->m_data, o.data());
   return *this;
}

} //namespace backends

using boost::multiprecision::backends::gmp_float;
using boost::multiprecision::backends::gmp_int;
using boost::multiprecision::backends::gmp_rational;

template <expression_template_option ExpressionTemplates>
struct component_type<number<gmp_rational, ExpressionTemplates> >
{
   using type = number<gmp_int, ExpressionTemplates>;
};

template <expression_template_option ET>
inline number<gmp_int, ET> numerator(const number<gmp_rational, ET>& val)
{
   number<gmp_int, ET> result;
   mpz_set(result.backend().data(), (mpq_numref(val.backend().data())));
   return result;
}
template <expression_template_option ET>
inline number<gmp_int, ET> denominator(const number<gmp_rational, ET>& val)
{
   number<gmp_int, ET> result;
   mpz_set(result.backend().data(), (mpq_denref(val.backend().data())));
   return result;
}

namespace detail {

template <>
struct digits2<number<gmp_float<0>, et_on> >
{
   static long value()
   {
      return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision()));
   }
};

template <>
struct digits2<number<gmp_float<0>, et_off> >
{
   static long value()
   {
      return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision()));
   }
};

template <>
struct digits2<number<debug_adaptor<gmp_float<0> >, et_on> >
{
   static long value()
   {
      return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision()));
   }
};

template <>
struct digits2<number<debug_adaptor<gmp_float<0> >, et_off> >
{
   static long value()
   {
      return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision()));
   }
};

template <unsigned Digits10>
struct transcendental_reduction_type<boost::multiprecision::backends::gmp_float<Digits10> >
{
   //
   // The type used for trigonometric reduction needs 3 times the precision of the base type.
   // This is double the precision of the original type, plus the largest exponent supported.
   // As a practical measure the largest argument supported is 1/eps, as supporting larger
   // arguments requires the division of argument by PI/2 to also be done at higher precision,
   // otherwise the result (an integer) can not be represented exactly.
   //
   // See ARGUMENT REDUCTION FOR HUGE ARGUMENTS. K C Ng.
   //
   using type = boost::multiprecision::backends::gmp_float<Digits10 * 3>;
};


} // namespace detail

template <>
struct number_category<detail::canonical<mpz_t, gmp_int>::type> : public std::integral_constant<int, number_kind_integer>
{};
template <>
struct number_category<detail::canonical<mpq_t, gmp_rational>::type> : public std::integral_constant<int, number_kind_rational>
{};
template <>
struct number_category<detail::canonical<mpf_t, gmp_float<0> >::type> : public std::integral_constant<int, number_kind_floating_point>
{};

namespace detail {
template <>
struct is_variable_precision<backends::gmp_float<0> > : public std::integral_constant<bool, true>
{};
} // namespace detail

using mpf_float_50 = number<gmp_float<50> >;
using mpf_float_100 = number<gmp_float<100> >;
using mpf_float_500 = number<gmp_float<500> >;
using mpf_float_1000 = number<gmp_float<1000> >;
using mpf_float = number<gmp_float<0> >;
using mpz_int = number<gmp_int>;
using mpq_rational = number<gmp_rational>;

} // namespace multiprecision

namespace math { namespace tools {

#ifndef BOOST_MP_MATH_AVAILABLE

template <typename T>
inline int digits();

template <typename T>
inline T max_value();

template <typename T>
inline T min_value();

#endif // BOOST_MP_MATH_AVAILABLE

inline void set_output_precision(const boost::multiprecision::mpf_float& val, std::ostream& os)
{
   const int sz_prec = static_cast<int>(val.precision());

   os << std::setprecision(sz_prec);
}

template <>
inline int digits<boost::multiprecision::mpf_float>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::thread_default_precision()));
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::thread_default_precision()));
}

template <>
inline boost::multiprecision::mpf_float
max_value<boost::multiprecision::mpf_float>()
{
   boost::multiprecision::mpf_float result(0.5);
   mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
   return result;
}

template <>
inline boost::multiprecision::mpf_float
min_value<boost::multiprecision::mpf_float>()
{
   boost::multiprecision::mpf_float result(0.5);
   mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
   mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
   mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
   return result;
}

template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::thread_default_precision()));
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::thread_default_precision()));
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
{
   return max_value<boost::multiprecision::mpf_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
{
   return min_value<boost::multiprecision::mpf_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
{
   return max_value<boost::multiprecision::mpf_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
{
   return min_value<boost::multiprecision::mpf_float>().backend();
}

}} // namespace math::tools

} // namespace boost

namespace std {

//
// numeric_limits [partial] specializations for the types declared in this header:
//
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates>;

   //
   // min and max values chosen so as to not cause segfaults when calling
   // mpf_get_str on 64-bit Linux builds.  Possibly we could use larger
   // exponent values elsewhere.
   //
   static number_type calc_min()
   {
      number_type result(1);
      mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
      return result;
   }
   static number_type calc_max()
   {
      number_type result(1);
      mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
      return result;
   }
   static number_type calc_epsilon()
   {
      number_type result(1);
      mpf_div_2exp(result.backend().data(), result.backend().data(), std::numeric_limits<number_type>::digits - 1);
      return result;
   }


 public:
   static constexpr bool is_specialized = true;
   static number_type(min)()
   {
      // rely on C++11 thread safe initialization of statics:
      static const number_type value{calc_min()};
      return value;
   }
   static number_type(max)()
   {
      static number_type value{calc_max()};
      return value;
   }
   static constexpr number_type lowest()
   {
      return -(max)();
   }
   static constexpr int digits   = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301L ? 2 : 1));
   static constexpr int digits10 = Digits10;
   // Have to allow for a possible extra limb inside the gmp data structure:
   static constexpr int  max_digits10 = Digits10 + 3 + ((GMP_LIMB_BITS * 301L) / 1000L);
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static number_type          epsilon()
   {
      static const number_type value{calc_epsilon()};
      return value;
   }
   // What value should this be????
   static number_type round_error()
   {
      return 1;
   }
   static constexpr long               min_exponent      = LONG_MIN;
   static constexpr long               min_exponent10    = (LONG_MIN / 1000) * 301L;
   static constexpr long               max_exponent      = LONG_MAX;
   static constexpr long               max_exponent10    = (LONG_MAX / 1000) * 301L;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static constexpr number_type        infinity() { return number_type(); }
   static constexpr number_type        quiet_NaN() { return number_type(); }
   static constexpr number_type        signaling_NaN() { return number_type(); }
   static constexpr number_type        denorm_min() { return number_type(); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = true;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = true;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_indeterminate;
};

template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::digits;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::digits10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_signed;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_integer;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_exact;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::radix;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_denorm;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_denorm_loss;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::traps;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::round_style;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = false;
   static number_type(min)() { return number_type(); }
   static number_type(max)() { return number_type(); }
   static number_type                        lowest() { return number_type(); }
   static constexpr int                digits       = 0;
   static constexpr int                digits10     = 0;
   static constexpr int                max_digits10 = 0;
   static constexpr bool               is_signed    = false;
   static constexpr bool               is_integer   = false;
   static constexpr bool               is_exact     = false;
   static constexpr int                radix        = 0;
   static number_type                        epsilon() { return number_type(); }
   static number_type                        round_error() { return number_type(); }
   static constexpr int                min_exponent      = 0;
   static constexpr int                min_exponent10    = 0;
   static constexpr int                max_exponent      = 0;
   static constexpr int                max_exponent10    = 0;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static number_type                        infinity() { return number_type(); }
   static number_type                        quiet_NaN() { return number_type(); }
   static number_type                        signaling_NaN() { return number_type(); }
   static number_type                        denorm_min() { return number_type(); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_indeterminate;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::round_style;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = true;
   //
   // Largest and smallest numbers are bounded only by available memory, set
   // to zero:
   //
   static number_type(min)()
   {
      return number_type();
   }
   static number_type(max)()
   {
      return number_type();
   }
   static number_type                        lowest() { return (min)(); }
   static constexpr int                digits       = INT_MAX;
   static constexpr int                digits10     = (INT_MAX / 1000) * 301L;
   static constexpr int                max_digits10 = digits10 + 3;
   static constexpr bool               is_signed    = true;
   static constexpr bool               is_integer   = true;
   static constexpr bool               is_exact     = true;
   static constexpr int                radix        = 2;
   static number_type                        epsilon() { return number_type(); }
   static number_type                        round_error() { return number_type(); }
   static constexpr int                min_exponent      = 0;
   static constexpr int                min_exponent10    = 0;
   static constexpr int                max_exponent      = 0;
   static constexpr int                max_exponent10    = 0;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static number_type                        infinity() { return number_type(); }
   static number_type                        quiet_NaN() { return number_type(); }
   static number_type                        signaling_NaN() { return number_type(); }
   static number_type                        denorm_min() { return number_type(); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::round_style;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = true;
   //
   // Largest and smallest numbers are bounded only by available memory, set
   // to zero:
   //
   static number_type(min)()
   {
      return number_type();
   }
   static number_type(max)()
   {
      return number_type();
   }
   static number_type lowest() { return (min)(); }
   // Digits are unbounded, use zero for now:
   static constexpr int                digits       = INT_MAX;
   static constexpr int                digits10     = (INT_MAX / 1000) * 301L;
   static constexpr int                max_digits10 = digits10 + 3;
   static constexpr bool               is_signed    = true;
   static constexpr bool               is_integer   = false;
   static constexpr bool               is_exact     = true;
   static constexpr int                radix        = 2;
   static number_type                        epsilon() { return number_type(); }
   static number_type                        round_error() { return number_type(); }
   static constexpr int                min_exponent      = 0;
   static constexpr int                min_exponent10    = 0;
   static constexpr int                max_exponent      = 0;
   static constexpr int                max_exponent10    = 0;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static number_type                        infinity() { return number_type(); }
   static number_type                        quiet_NaN() { return number_type(); }
   static number_type                        signaling_NaN() { return number_type(); }
   static number_type                        denorm_min() { return number_type(); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::round_style;

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // namespace std

namespace Eigen
{

   template <class B1, class B2>
   struct NumTraitsImp;

   template <boost::multiprecision::expression_template_option ExpressionTemplates>
   struct NumTraitsImp<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>, boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
   {
      using self_type = boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>;
      using Real = typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type;
      using NonInteger = self_type; // Not correct but we can't do much better??
      using Literal = double;
      using Nested = self_type;
      enum
      {
         IsComplex = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
         IsInteger = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
         ReadCost = 1,
         AddCost = 4,
         MulCost = 8,
         IsSigned = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
         RequireInitialization = 1,
      };

      static Real highest() noexcept
      {
         return boost::math::tools::max_value<Real>();
      }
      static Real lowest() noexcept
      {
         return boost::math::tools::min_value<Real>();
      }
      static int digits() noexcept
      {
         return boost::math::tools::digits<Real>();
      }
      static int digits10()
      {
         return Real::thread_default_precision();
      }
      static Real epsilon()
      {
         return ldexp(Real(1), 1 - digits());
      }
      static Real dummy_precision()
      {
         return 1000 * epsilon();
      }
      static constexpr long min_exponent() noexcept
      {
         return LONG_MIN;
      }
      static constexpr long max_exponent() noexcept
      {
         return LONG_MAX;
      }
      static Real infinity()
      {
         return Real();
      }
      static Real quiet_NaN()
      {
         return Real();
      }
   };

}


#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/integer.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-21 John Maddock.
//  Copyright 2021 Iskandarov Lev. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_INTEGER_HPP
#define BOOST_MP_INTEGER_HPP

#include <type_traits>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/detail/bitscan.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace boost {
namespace multiprecision {

template <class Integer, class I2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && boost::multiprecision::detail::is_integral<I2>::value, Integer&>::type
multiply(Integer& result, const I2& a, const I2& b)
{
   return result = static_cast<Integer>(a) * static_cast<Integer>(b);
}
template <class Integer, class I2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && boost::multiprecision::detail::is_integral<I2>::value, Integer&>::type
add(Integer& result, const I2& a, const I2& b)
{
   return result = static_cast<Integer>(a) + static_cast<Integer>(b);
}
template <class Integer, class I2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && boost::multiprecision::detail::is_integral<I2>::value, Integer&>::type
subtract(Integer& result, const I2& a, const I2& b)
{
   return result = static_cast<Integer>(a) - static_cast<Integer>(b);
}

template <class Integer>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value>::type divide_qr(const Integer& x, const Integer& y, Integer& q, Integer& r)
{
   q = x / y;
   r = x % y;
}

template <class I1, class I2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I1>::value && boost::multiprecision::detail::is_integral<I2>::value, I2>::type integer_modulus(const I1& x, I2 val)
{
   return static_cast<I2>(x % val);
}

namespace detail {
//
// Figure out the kind of integer that has twice as many bits as some builtin
// integer type I.  Use a native type if we can (including types which may not
// be recognised by boost::int_t because they're larger than long long),
// otherwise synthesize a cpp_int to do the job.
//
template <class I>
struct double_integer
{
   static constexpr const unsigned int_t_digits =
       2 * sizeof(I) <= sizeof(long long) ? std::numeric_limits<I>::digits * 2 : 1;

   using type = typename std::conditional<
       2 * sizeof(I) <= sizeof(long long),
       typename std::conditional<
           boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value,
           typename boost::multiprecision::detail::int_t<int_t_digits>::least,
           typename boost::multiprecision::detail::uint_t<int_t_digits>::least>::type,
       typename std::conditional<
           2 * sizeof(I) <= sizeof(double_limb_type),
           typename std::conditional<
               boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value,
               signed_double_limb_type,
               double_limb_type>::type,
           number<cpp_int_backend<sizeof(I) * CHAR_BIT * 2, sizeof(I) * CHAR_BIT * 2, (boost::multiprecision::detail::is_signed<I>::value ? signed_magnitude : unsigned_magnitude), unchecked, void> > >::type>::type;
};

} // namespace detail

template <class I1, class I2, class I3>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I1>::value && boost::multiprecision::detail::is_unsigned<I2>::value && boost::multiprecision::detail::is_integral<I3>::value, I1>::type
powm(const I1& a, I2 b, I3 c)
{
   using double_type = typename detail::double_integer<I1>::type;

   I1          x(1), y(a);
   double_type result(0);

   while (b > 0)
   {
      if (b & 1)
      {
         multiply(result, x, y);
         x = integer_modulus(result, c);
      }
      multiply(result, y, y);
      y = integer_modulus(result, c);
      b >>= 1;
   }
   return x % c;
}

template <class I1, class I2, class I3>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I1>::value && boost::multiprecision::detail::is_signed<I2>::value && boost::multiprecision::detail::is_integral<I2>::value && boost::multiprecision::detail::is_integral<I3>::value, I1>::type
powm(const I1& a, I2 b, I3 c)
{
   if (b < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   return powm(a, static_cast<typename boost::multiprecision::detail::make_unsigned<I2>::type>(b), c);
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, std::size_t>::type lsb(const Integer& val)
{
   if (val <= 0)
   {
      if (val == 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
      }
      else
      {
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
      }
   }
   return detail::find_lsb(val);
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, std::size_t>::type msb(Integer val)
{
   if (val <= 0)
   {
      if (val == 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
      }
      else
      {
         BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
      }
   }
   return detail::find_msb(val);
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, bool>::type bit_test(const Integer& val, std::size_t index)
{
   Integer mask = 1;
   if (index >= sizeof(Integer) * CHAR_BIT)
      return 0;
   if (index)
      mask <<= index;
   return val & mask ? true : false;
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, Integer&>::type bit_set(Integer& val, std::size_t index)
{
   Integer mask = 1;
   if (index >= sizeof(Integer) * CHAR_BIT)
      return val;
   if (index)
      mask <<= index;
   val |= mask;
   return val;
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, Integer&>::type bit_unset(Integer& val, std::size_t index)
{
   Integer mask = 1;
   if (index >= sizeof(Integer) * CHAR_BIT)
      return val;
   if (index)
      mask <<= index;
   val &= ~mask;
   return val;
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, Integer&>::type bit_flip(Integer& val, std::size_t index)
{
   Integer mask = 1;
   if (index >= sizeof(Integer) * CHAR_BIT)
      return val;
   if (index)
      mask <<= index;
   val ^= mask;
   return val;
}

namespace detail {

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR Integer karatsuba_sqrt(const Integer& x, Integer& r, size_t bits)
{
   //
   // Define the floating point type used for std::sqrt, in our tests, sqrt(double) and sqrt(long double) take
   // about the same amount of time as long as long double is not an emulated 128-bit type (ie the same type
   // as __float128 from libquadmath).  So only use long double if it's an 80-bit type:
   //
#ifndef __clang__
   typedef typename std::conditional<(std::numeric_limits<long double>::digits == 64), long double, double>::type real_cast_type;
#else
   // clang has buggy __int128 -> long double conversion:
   typedef double real_cast_type;
#endif
   //
   // As per the Karatsuba sqrt algorithm, the low order bits/4 bits pay no part in the result, only in the remainder,
   // so define the number of bits our argument must have before passing to std::sqrt is safe, even if doing so
   // looses a few bits:
   //
   constexpr std::size_t cutoff = (std::numeric_limits<real_cast_type>::digits * 4) / 3;
   //
   // Type which can hold at least "cutoff" bits:
   // 
#ifdef BOOST_HAS_INT128
   using cutoff_t = typename std::conditional<(cutoff > 64), uint128_type, std::uint64_t>::type;
#else
   using cutoff_t = std::uint64_t;
#endif
   //
   // See if we can take the fast path:
   //
   if (bits <= cutoff)
   {
      constexpr cutoff_t half_bits = (cutoff_t(1u) << ((sizeof(cutoff_t) * CHAR_BIT) / 2)) - 1;
      cutoff_t       val = static_cast<cutoff_t>(x);
      real_cast_type real_val = static_cast<real_cast_type>(val);
      cutoff_t       s64 = static_cast<cutoff_t>(std::sqrt(real_val));
      // converting to long double can loose some precision, and `sqrt` can give eps error, so we'll fix this
      // this is needed
      while ((s64 > half_bits) || (s64 * s64 > val))
         s64--;
      // in my tests this never fired, but theoretically this might be needed
      while ((s64 < half_bits) && ((s64 + 1) * (s64 + 1) <= val))
         s64++;
      r = static_cast<Integer>(val - s64 * s64);
      return static_cast<Integer>(s64);
   }
   // https://hal.inria.fr/file/index/docid/72854/filename/RR-3805.pdf
   std::size_t b = bits / 4;
   Integer q = x;
   q >>= b * 2;
   Integer s = karatsuba_sqrt(q, r, bits - b * 2);
   Integer t = 0u;
   bit_set(t, static_cast<unsigned>(b * 2));
   r <<= b;
   t--;
   t &= x;
   t >>= b;
   t += r;
   s <<= 1;
   divide_qr(t, s, q, r);
   r <<= b;
   t = 0u;
   bit_set(t, static_cast<unsigned>(b));
   t--;
   t &= x;
   r += t;
   s <<= (b - 1); // we already <<1 it before
   s += q;
   q *= q;
   // we substract after, so it works for unsigned integers too
   if (r < q)
   {
      t = s;
      t <<= 1;
      t--;
      r += t;
      s--;
   }
   r -= q;
   return s;
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR Integer bitwise_sqrt(const Integer& x, Integer& r)
{
   //
   // This is slow bit-by-bit integer square root, see for example
   // http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_.28base_2.29
   // There are better methods such as http://hal.inria.fr/docs/00/07/28/54/PDF/RR-3805.pdf
   // and http://hal.inria.fr/docs/00/07/21/13/PDF/RR-4475.pdf which should be implemented
   // at some point.
   //
   Integer s = 0;
   switch (x)
   {
   case 0:
      r = 0;
      return s;
   case 1:
      r = 0;
      return 1;
   case 2:
      r = 1;
      return 1;
   case 3:
      r = 2;
      return 1;
   default:
      break;
      // fall through:
   }
   std::ptrdiff_t g = msb(x);

   Integer t = 0;
   r = x;
   g /= 2;
   bit_set(s, g);
   bit_set(t, 2 * g);
   r = x - t;
   --g;
   do
   {
      t = s;
      t <<= g + 1;
      bit_set(t, 2 * g);
      if (t <= r)
      {
         bit_set(s, g);
         r -= t;
      }
      --g;
   } while (g >= 0);
   return s;
}

} // namespace detail

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, Integer>::type sqrt(const Integer& x, Integer& r)
{
#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
   // recursive Karatsuba sqrt can cause issues in constexpr context:
   if (BOOST_MP_IS_CONST_EVALUATED(x))
   {
      return detail::bitwise_sqrt(x, r);
   }
#endif
   if (x == 0u) {
      r = 0u;
      return 0u;
   }

   return detail::karatsuba_sqrt(x, r, msb(x) + 1);
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value, Integer>::type sqrt(const Integer& x)
{
   Integer r(0);
   return sqrt(x, r);
}

}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/logged_adaptor.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_LOGGED_ADAPTER_HPP
#define BOOST_MP_LOGGED_ADAPTER_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/traits/extract_exponent_type.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>

namespace boost {
namespace multiprecision {

template <class Backend>
inline void log_postfix_event(const Backend&, const char* /*event_description*/)
{
}
template <class Backend, class T>
inline void log_postfix_event(const Backend&, const T&, const char* /*event_description*/)
{
}
template <class Backend>
inline void log_prefix_event(const Backend&, const char* /*event_description*/)
{
}
template <class Backend, class T>
inline void log_prefix_event(const Backend&, const T&, const char* /*event_description*/)
{
}
template <class Backend, class T, class U>
inline void log_prefix_event(const Backend&, const T&, const U&, const char* /*event_description*/)
{
}
template <class Backend, class T, class U, class V>
inline void log_prefix_event(const Backend&, const T&, const U&, const V&, const char* /*event_description*/)
{
}

namespace backends {

template <class Backend>
struct logged_adaptor
{
   using signed_types = typename Backend::signed_types  ;
   using unsigned_types = typename Backend::unsigned_types;
   using float_types = typename Backend::float_types   ;
   using exponent_type = typename extract_exponent_type<Backend, number_category<Backend>::value>::type;

 private:
   Backend m_value;

 public:
   logged_adaptor()
   {
      log_postfix_event(m_value, "Default construct");
   }
   logged_adaptor(const logged_adaptor& o)
   {
      log_prefix_event(m_value, o.value(), "Copy construct");
      m_value = o.m_value;
      log_postfix_event(m_value, "Copy construct");
   }
   // rvalue copy
   logged_adaptor(logged_adaptor&& o)
   {
      log_prefix_event(m_value, o.value(), "Move construct");
      m_value = static_cast<Backend&&>(o.m_value);
      log_postfix_event(m_value, "Move construct");
   }
   logged_adaptor& operator=(logged_adaptor&& o)
   {
      log_prefix_event(m_value, o.value(), "Move Assignment");
      m_value = static_cast<Backend&&>(o.m_value);
      log_postfix_event(m_value, "Move construct");
      return *this;
   }
   logged_adaptor& operator=(const logged_adaptor& o)
   {
      log_prefix_event(m_value, o.value(), "Assignment");
      m_value = o.m_value;
      log_postfix_event(m_value, "Copy construct");
      return *this;
   }
   template <class T>
   logged_adaptor(const T& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
       : m_value(i)
   {
      log_postfix_event(m_value, "construct from arithmetic type");
   }
   template <class T>
   logged_adaptor(const logged_adaptor<T>& i, const typename std::enable_if<std::is_convertible<T, Backend>::value>::type* = nullptr)
       : m_value(i.value())
   {
      log_postfix_event(m_value, "construct from arithmetic type");
   }
   template <class T, class U>
   logged_adaptor(const T& i, const U& j, typename std::enable_if<std::is_constructible<Backend, const T&, const U&>::value>::type* = nullptr)
      : m_value(i, j)
   {
      log_postfix_event(m_value, "construct from a pair of arithmetic types");
   }
   template <class D = Backend>
   logged_adaptor(const Backend& i, unsigned digits10, typename std::enable_if<std::is_constructible<D, Backend const&, unsigned>::value>::type const* = nullptr)
      : m_value(i, digits10)
   {
      log_postfix_event(m_value, "construct from arithmetic type and precision");
   }
   template <class D = Backend>
   logged_adaptor(const logged_adaptor<Backend>& i, unsigned digits10, typename std::enable_if<std::is_constructible<D, Backend const&, unsigned>::value>::type const* = nullptr)
      : m_value(i.value(), digits10)
   {
      log_postfix_event(m_value, "construct from arithmetic type and precision");
   }
   template <class T>
   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value || std::is_assignable<Backend, T>::value, logged_adaptor&>::type operator=(const T& i)
   {
      log_prefix_event(m_value, i, "Assignment from arithmetic type");
      m_value = i;
      log_postfix_event(m_value, "Assignment from arithmetic type");
      return *this;
   }
   logged_adaptor& operator=(const char* s)
   {
      log_prefix_event(m_value, s, "Assignment from string type");
      m_value = s;
      log_postfix_event(m_value, "Assignment from string type");
      return *this;
   }
   void swap(logged_adaptor& o)
   {
      log_prefix_event(m_value, o.value(), "swap");
      std::swap(m_value, o.value());
      log_postfix_event(m_value, "swap");
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      log_prefix_event(m_value, "Conversion to string");
      std::string s = m_value.str(digits, f);
      log_postfix_event(m_value, s, "Conversion to string");
      return s;
   }
   void negate()
   {
      log_prefix_event(m_value, "negate");
      m_value.negate();
      log_postfix_event(m_value, "negate");
   }
   int compare(const logged_adaptor& o) const
   {
      log_prefix_event(m_value, o.value(), "compare");
      int r = m_value.compare(o.value());
      log_postfix_event(m_value, r, "compare");
      return r;
   }
   template <class T>
   int compare(const T& i) const
   {
      log_prefix_event(m_value, i, "compare");
      int r = m_value.compare(i);
      log_postfix_event(m_value, r, "compare");
      return r;
   }
   Backend& value()
   {
      return m_value;
   }
   const Backend& value() const
   {
      return m_value;
   }
   
   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      log_prefix_event(m_value, "serialize");
      ar& boost::make_nvp("value", m_value);
      log_postfix_event(m_value, "serialize");
   }
   #endif

   static unsigned default_precision() noexcept
   {
      return Backend::default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      Backend::default_precision(v);
   }
   static unsigned thread_default_precision() noexcept
   {
      return Backend::thread_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      Backend::thread_default_precision(v);
   }
   unsigned precision() const noexcept
   {
      return value().precision();
   }
   void precision(unsigned digits10) noexcept
   {
      value().precision(digits10);
   }
   //
   // Variable precision options:
   // 
   static constexpr variable_precision_options default_variable_precision_options()noexcept
   {
      return Backend::default_variable_precision_options();
   }
   static constexpr variable_precision_options thread_default_variable_precision_options()noexcept
   {
      return Backend::thread_default_variable_precision_options();
   }
   static BOOST_MP_CXX14_CONSTEXPR void default_variable_precision_options(variable_precision_options opts)
   {
      Backend::default_variable_precision_options(opts);
   }
   static BOOST_MP_CXX14_CONSTEXPR void thread_default_variable_precision_options(variable_precision_options opts)
   {
      Backend::thread_default_variable_precision_options(opts);
   }
};

template <class T>
inline const T& unwrap_logged_type(const T& a) { return a; }
template <class Backend>
inline const Backend& unwrap_logged_type(const logged_adaptor<Backend>& a) { return a.value(); }

#define NON_MEMBER_OP1(name, str)                                        \
   template <class Backend>                                              \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result) \
   {                                                                     \
      using default_ops::BOOST_JOIN(eval_, name);                        \
      log_prefix_event(result.value(), str);                             \
      BOOST_JOIN(eval_, name)                                            \
      (result.value());                                                  \
      log_postfix_event(result.value(), str);                            \
   }

#define NON_MEMBER_OP2(name, str)                                                                          \
   template <class Backend, class T>                                                                       \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a)                       \
   {                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                          \
      log_prefix_event(result.value(), unwrap_logged_type(a), str);                                        \
      BOOST_JOIN(eval_, name)                                                                              \
      (result.value(), unwrap_logged_type(a));                                                             \
      log_postfix_event(result.value(), str);                                                              \
   }                                                                                                       \
   template <class Backend>                                                                                \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a) \
   {                                                                                                       \
      using default_ops::BOOST_JOIN(eval_, name);                                                          \
      log_prefix_event(result.value(), unwrap_logged_type(a), str);                                        \
      BOOST_JOIN(eval_, name)                                                                              \
      (result.value(), unwrap_logged_type(a));                                                             \
      log_postfix_event(result.value(), str);                                                              \
   }

#define NON_MEMBER_OP3(name, str)                                                                                                            \
   template <class Backend, class T, class U>                                                                                                \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const U& b)                                             \
   {                                                                                                                                         \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
      BOOST_JOIN(eval_, name)                                                                                                                \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
      log_postfix_event(result.value(), str);                                                                                                \
   }                                                                                                                                         \
   template <class Backend, class T>                                                                                                         \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b)                       \
   {                                                                                                                                         \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
      BOOST_JOIN(eval_, name)                                                                                                                \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
      log_postfix_event(result.value(), str);                                                                                                \
   }                                                                                                                                         \
   template <class Backend, class T>                                                                                                         \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const logged_adaptor<Backend>& b)                       \
   {                                                                                                                                         \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
      BOOST_JOIN(eval_, name)                                                                                                                \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
      log_postfix_event(result.value(), str);                                                                                                \
   }                                                                                                                                         \
   template <class Backend>                                                                                                                  \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b) \
   {                                                                                                                                         \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                            \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), str);                                                   \
      BOOST_JOIN(eval_, name)                                                                                                                \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b));                                                                        \
      log_postfix_event(result.value(), str);                                                                                                \
   }

#define NON_MEMBER_OP4(name, str)                                                                                                                                              \
   template <class Backend, class T, class U, class V>                                                                                                                         \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const U& b, const V& c)                                                                   \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }                                                                                                                                                                           \
   template <class Backend, class T>                                                                                                                                           \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b, const T& c)                       \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }                                                                                                                                                                           \
   template <class Backend, class T>                                                                                                                                           \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b, const logged_adaptor<Backend>& c)                       \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }                                                                                                                                                                           \
   template <class Backend, class T>                                                                                                                                           \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const T& a, const logged_adaptor<Backend>& b, const logged_adaptor<Backend>& c)                       \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }                                                                                                                                                                           \
   template <class Backend>                                                                                                                                                    \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const logged_adaptor<Backend>& b, const logged_adaptor<Backend>& c) \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }                                                                                                                                                                           \
   template <class Backend, class T, class U>                                                                                                                                  \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<Backend> & result, const logged_adaptor<Backend>& a, const T& b, const U& c)                                             \
   {                                                                                                                                                                           \
      using default_ops::BOOST_JOIN(eval_, name);                                                                                                                              \
      log_prefix_event(result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c), str);                                                              \
      BOOST_JOIN(eval_, name)                                                                                                                                                  \
      (result.value(), unwrap_logged_type(a), unwrap_logged_type(b), unwrap_logged_type(c));                                                                                   \
      log_postfix_event(result.value(), str);                                                                                                                                  \
   }

NON_MEMBER_OP2(add, "+=")
NON_MEMBER_OP2(subtract, "-=")
NON_MEMBER_OP2(multiply, "*=")
NON_MEMBER_OP2(divide, "/=")

template <class Backend, class R>
inline void eval_convert_to(R* result, const logged_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val.value(), "convert_to");
   eval_convert_to(result, val.value());
   log_postfix_event(val.value(), *result, "convert_to");
}

template <class Backend, class R>
inline void eval_convert_to(logged_adaptor<R>* result, const logged_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val.value(), "convert_to");
   eval_convert_to(&result->value(), val.value());
   log_postfix_event(val.value(), &result->value(), "convert_to");
}
template <class Backend, class R>
inline void eval_convert_to(logged_adaptor<R>* result, const Backend& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val, "convert_to");
   eval_convert_to(&result->value(), val);
   log_postfix_event(val, &result->value(), "convert_to");
}

template <class Backend>
inline void eval_convert_to(std::complex<float>* result, const logged_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val.value(), "convert_to");
   eval_convert_to(result, val.value());
   log_postfix_event(val.value(), *result, "convert_to");
}
template <class Backend>
inline void eval_convert_to(std::complex<double>* result, const logged_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val.value(), "convert_to");
   eval_convert_to(result, val.value());
   log_postfix_event(val.value(), *result, "convert_to");
}
template <class Backend>
inline void eval_convert_to(std::complex<long double>* result, const logged_adaptor<Backend>& val)
{
   using default_ops::eval_convert_to;
   log_prefix_event(val.value(), "convert_to");
   eval_convert_to(result, val.value());
   log_postfix_event(val.value(), *result, "convert_to");
}


template <class Backend, class Exp>
inline void eval_frexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp* exp)
{
   log_prefix_event(arg.value(), "frexp");
   eval_frexp(result.value(), arg.value(), exp);
   log_postfix_event(result.value(), *exp, "frexp");
}

template <class Backend, class Exp>
inline void eval_ldexp(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
{
   log_prefix_event(arg.value(), "ldexp");
   eval_ldexp(result.value(), arg.value(), exp);
   log_postfix_event(result.value(), exp, "ldexp");
}

template <class Backend, class Exp>
inline void eval_scalbn(logged_adaptor<Backend>& result, const logged_adaptor<Backend>& arg, Exp exp)
{
   using default_ops::eval_scalbn;
   log_prefix_event(arg.value(), "scalbn");
   eval_scalbn(result.value(), arg.value(), exp);
   log_postfix_event(result.value(), exp, "scalbn");
}

template <class Backend>
inline typename Backend::exponent_type eval_ilogb(const logged_adaptor<Backend>& arg)
{
   using default_ops::eval_ilogb;
   log_prefix_event(arg.value(), "ilogb");
   typename Backend::exponent_type r = eval_ilogb(arg.value());
   log_postfix_event(arg.value(), "ilogb");
   return r;
}

NON_MEMBER_OP2(floor, "floor")
NON_MEMBER_OP2(ceil, "ceil")
NON_MEMBER_OP2(sqrt, "sqrt")

template <class Backend>
inline int eval_fpclassify(const logged_adaptor<Backend>& arg)
{
   using default_ops::eval_fpclassify;
   log_prefix_event(arg.value(), "fpclassify");
   int r = eval_fpclassify(arg.value());
   log_postfix_event(arg.value(), r, "fpclassify");
   return r;
}

/*********************************************************************
*
* Optional arithmetic operations come next:
*
*********************************************************************/

NON_MEMBER_OP3(add, "+")
NON_MEMBER_OP3(subtract, "-")
NON_MEMBER_OP3(multiply, "*")
NON_MEMBER_OP3(divide, "/")
NON_MEMBER_OP3(multiply_add, "fused-multiply-add")
NON_MEMBER_OP3(multiply_subtract, "fused-multiply-subtract")
NON_MEMBER_OP4(multiply_add, "fused-multiply-add")
NON_MEMBER_OP4(multiply_subtract, "fused-multiply-subtract")

NON_MEMBER_OP1(increment, "increment")
NON_MEMBER_OP1(decrement, "decrement")

/*********************************************************************
*
* Optional integer operations come next:
*
*********************************************************************/

NON_MEMBER_OP2(modulus, "%=")
NON_MEMBER_OP3(modulus, "%")
NON_MEMBER_OP2(bitwise_or, "|=")
NON_MEMBER_OP3(bitwise_or, "|")
NON_MEMBER_OP2(bitwise_and, "&=")
NON_MEMBER_OP3(bitwise_and, "&")
NON_MEMBER_OP2(bitwise_xor, "^=")
NON_MEMBER_OP3(bitwise_xor, "^")
NON_MEMBER_OP4(qr, "quotient-and-remainder")
NON_MEMBER_OP2(complement, "~")

template <class Backend>
inline void eval_left_shift(logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_left_shift;
   log_prefix_event(arg.value(), a, "<<=");
   eval_left_shift(arg.value(), a);
   log_postfix_event(arg.value(), "<<=");
}
template <class Backend>
inline void eval_left_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, std::size_t b)
{
   using default_ops::eval_left_shift;
   log_prefix_event(arg.value(), a, b, "<<");
   eval_left_shift(arg.value(), a.value(), b);
   log_postfix_event(arg.value(), "<<");
}
template <class Backend>
inline void eval_right_shift(logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_right_shift;
   log_prefix_event(arg.value(), a, ">>=");
   eval_right_shift(arg.value(), a);
   log_postfix_event(arg.value(), ">>=");
}
template <class Backend>
inline void eval_right_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, std::size_t b)
{
   using default_ops::eval_right_shift;
   log_prefix_event(arg.value(), a, b, ">>");
   eval_right_shift(arg.value(), a.value(), b);
   log_postfix_event(arg.value(), ">>");
}

template <class Backend, class T>
inline T eval_integer_modulus(const logged_adaptor<Backend>& arg, const T& a)
{
   using default_ops::eval_integer_modulus;
   log_prefix_event(arg.value(), a, "integer-modulus");
   T r = eval_integer_modulus(arg.value(), a);
   log_postfix_event(arg.value(), r, "integer-modulus");
   return r;
}

template <class Backend>
inline std::size_t eval_lsb(const logged_adaptor<Backend>& arg)
{
   using default_ops::eval_lsb;
   log_prefix_event(arg.value(), "least-significant-bit");
   std::size_t r = eval_lsb(arg.value());
   log_postfix_event(arg.value(), r, "least-significant-bit");
   return r;
}

template <class Backend>
inline std::size_t eval_msb(const logged_adaptor<Backend>& arg)
{
   using default_ops::eval_msb;
   log_prefix_event(arg.value(), "most-significant-bit");
   std::size_t r = eval_msb(arg.value());
   log_postfix_event(arg.value(), r, "most-significant-bit");
   return r;
}

template <class Backend>
inline bool eval_bit_test(const logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_test;
   log_prefix_event(arg.value(), a, "bit-test");
   bool r = eval_bit_test(arg.value(), a);
   log_postfix_event(arg.value(), r, "bit-test");
   return r;
}

template <class Backend>
inline void eval_bit_set(const logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_set;
   log_prefix_event(arg.value(), a, "bit-set");
   eval_bit_set(arg.value(), a);
   log_postfix_event(arg.value(), arg, "bit-set");
}
template <class Backend>
inline void eval_bit_unset(const logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_unset;
   log_prefix_event(arg.value(), a, "bit-unset");
   eval_bit_unset(arg.value(), a);
   log_postfix_event(arg.value(), arg, "bit-unset");
}
template <class Backend>
inline void eval_bit_flip(const logged_adaptor<Backend>& arg, std::size_t a)
{
   using default_ops::eval_bit_flip;
   log_prefix_event(arg.value(), a, "bit-flip");
   eval_bit_flip(arg.value(), a);
   log_postfix_event(arg.value(), arg, "bit-flip");
}

NON_MEMBER_OP3(gcd, "gcd")
NON_MEMBER_OP3(lcm, "lcm")
NON_MEMBER_OP4(powm, "powm")

/*********************************************************************
*
* abs/fabs:
*
*********************************************************************/

NON_MEMBER_OP2(abs, "abs")
NON_MEMBER_OP2(fabs, "fabs")

/*********************************************************************
*
* Floating point functions:
*
*********************************************************************/

NON_MEMBER_OP2(trunc, "trunc")
NON_MEMBER_OP2(round, "round")
NON_MEMBER_OP2(exp, "exp")
NON_MEMBER_OP2(log, "log")
NON_MEMBER_OP2(log10, "log10")
NON_MEMBER_OP2(sin, "sin")
NON_MEMBER_OP2(cos, "cos")
NON_MEMBER_OP2(tan, "tan")
NON_MEMBER_OP2(asin, "asin")
NON_MEMBER_OP2(acos, "acos")
NON_MEMBER_OP2(atan, "atan")
NON_MEMBER_OP2(sinh, "sinh")
NON_MEMBER_OP2(cosh, "cosh")
NON_MEMBER_OP2(tanh, "tanh")
NON_MEMBER_OP2(logb, "logb")
NON_MEMBER_OP3(fmod, "fmod")
NON_MEMBER_OP3(pow, "pow")
NON_MEMBER_OP3(atan2, "atan2")
NON_MEMBER_OP2(asinh, "asinh")
NON_MEMBER_OP2(acosh, "acosh")
NON_MEMBER_OP2(atanh, "atanh")
NON_MEMBER_OP2(conj, "conj")

template <class Backend>
int eval_signbit(const logged_adaptor<Backend>& val)
{
   using default_ops::eval_signbit;
   return eval_signbit(val.value());
}

template <class Backend>
std::size_t hash_value(const logged_adaptor<Backend>& val)
{
   return hash_value(val.value());
}

template <class Backend, expression_template_option ExpressionTemplates>
inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<logged_adaptor<Backend>, ExpressionTemplates>::value_type>::type
numerator(const number<logged_adaptor<Backend>, ExpressionTemplates>& arg)
{
   number<Backend, ExpressionTemplates> t(arg.backend().value());
   return numerator(t).backend();
}
template <class Backend, expression_template_option ExpressionTemplates>
inline typename std::enable_if<number_category<Backend>::value == number_kind_rational, typename number<logged_adaptor<Backend>, ExpressionTemplates>::value_type>::type
denominator(const number<logged_adaptor<Backend>, ExpressionTemplates>& arg)
{
   number<Backend, ExpressionTemplates> t(arg.backend().value());
   return denominator(t).backend();
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(To& to, const logged_adaptor<From>& from)
{
   using default_ops::eval_set_real;
   log_prefix_event(to, from.value(), "Set real part");
   eval_set_real(to, from.value());
   log_postfix_event(to, from.value(), "Set real part");
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(logged_adaptor<To>& to, const logged_adaptor<From>& from)
{
   using default_ops::eval_set_real;
   log_prefix_event(to.value(), from.value(), "Set real part");
   eval_set_real(to.value(), from.value());
   log_postfix_event(to.value(), from.value(), "Set real part");
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_real(logged_adaptor<To>& to, const From& from)
{
   using default_ops::eval_set_real;
   log_prefix_event(to.value(), from, "Set real part");
   eval_set_real(to.value(), from);
   log_postfix_event(to.value(), from, "Set real part");
}

template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(To& to, const logged_adaptor<From>& from)
{
   using default_ops::eval_set_imag;
   log_prefix_event(to, from.value(), "Set imag part");
   eval_set_imag(to, from.value());
   log_postfix_event(to, from.value(), "Set imag part");
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(logged_adaptor<To>& to, const logged_adaptor<From>& from)
{
   using default_ops::eval_set_imag;
   log_prefix_event(to.value(), from.value(), "Set imag part");
   eval_set_imag(to.value(), from.value());
   log_postfix_event(to.value(), from.value(), "Set imag part");
}
template <class To, class From>
inline BOOST_MP_CXX14_CONSTEXPR void eval_set_imag(logged_adaptor<To>& to, const From& from)
{
   using default_ops::eval_set_imag;
   log_prefix_event(to.value(), from, "Set imag part");
   eval_set_imag(to.value(), from);
   log_postfix_event(to.value(), from, "Set imag part");
}


#define NON_MEMBER_COMPLEX_TO_REAL(name, str)                                                    \
   template <class B1, class B2>                                                                 \
   inline void BOOST_JOIN(eval_, name)(logged_adaptor<B1> & result, const logged_adaptor<B2>& a) \
   {                                                                                             \
      using default_ops::BOOST_JOIN(eval_, name);                                                \
      log_prefix_event(a.value(), a.value(), str);                                               \
      BOOST_JOIN(eval_, name)                                                                    \
      (result.value(), a.value());                                                               \
      log_postfix_event(result.value(), str);                                                    \
   }                                                                                             \
   template <class B1, class B2>                                                                 \
   inline void BOOST_JOIN(eval_, name)(B1 & result, const logged_adaptor<B2>& a)                 \
   {                                                                                             \
      using default_ops::BOOST_JOIN(eval_, name);                                                \
      log_prefix_event(a.value(), a.value(), str);                                               \
      BOOST_JOIN(eval_, name)                                                                    \
      (result, a.value());                                                                       \
      log_postfix_event(result, str);                                                            \
   }

NON_MEMBER_COMPLEX_TO_REAL(real, "real")
NON_MEMBER_COMPLEX_TO_REAL(imag, "imag")

template <class T, class V, class U>
inline void assign_components(logged_adaptor<T>& result, const V& v1, const U& v2)
{
   using default_ops::assign_components;
   assign_components(result.value(), unwrap_logged_type(v1), unwrap_logged_type(v2));
}

} // namespace backends

using backends::logged_adaptor;

namespace detail {
   template <class Backend>
   struct is_variable_precision<logged_adaptor<Backend> > : public is_variable_precision<Backend>
   {};
#ifdef BOOST_HAS_INT128
   template <class Backend>
   struct is_convertible_arithmetic<int128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<int128_type, Backend>
   {};
   template <class Backend>
   struct is_convertible_arithmetic<uint128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<uint128_type, Backend>
   {};
#endif
#ifdef BOOST_HAS_FLOAT128
   template <class Backend>
   struct is_convertible_arithmetic<float128_type, logged_adaptor<Backend> > : public is_convertible_arithmetic<float128_type, Backend>
   {};
#endif
   } // namespace detail

template <class Backend>
struct number_category<backends::logged_adaptor<Backend> > : public number_category<Backend>
{};

template <class Number>
using logged_adaptor_t = number<logged_adaptor<typename Number::backend_type>, Number::et>;

template <class Backend, expression_template_option ExpressionTemplates>
struct component_type<number<logged_adaptor<Backend>, ExpressionTemplates>>
{
   //
   // We'll make the component_type also a logged_adaptor:
   //
   using base_component_type = typename component_type<number<Backend, ExpressionTemplates>>::type;
   using base_component_backend = typename base_component_type::backend_type;
   using type = number<logged_adaptor<base_component_backend>, ExpressionTemplates>;
};

template <class Backend>
struct is_interval_number<backends::logged_adaptor<Backend> > : public is_interval_number<Backend> {};

}} // namespace boost::multiprecision

namespace std {

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates> >
    : public std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   using base_type = std::numeric_limits<boost::multiprecision::number<Backend, ExpressionTemplates> >                           ;
   using number_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<Backend>, ExpressionTemplates>;

 public:
   static number_type(min)() noexcept { return (base_type::min)(); }
   static number_type(max)() noexcept { return (base_type::max)(); }
   static number_type lowest() noexcept { return -(max)(); }
   static number_type epsilon() noexcept { return base_type::epsilon(); }
   static number_type round_error() noexcept { return epsilon() / 2; }
   static number_type infinity() noexcept { return base_type::infinity(); }
   static number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
   static number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
   static number_type denorm_min() noexcept { return base_type::denorm_min(); }
};

} // namespace std

#ifdef BOOST_MP_MATH_AVAILABLE
namespace boost {
namespace math {

namespace policies {

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
struct precision<boost::multiprecision::number<boost::multiprecision::logged_adaptor<Backend>, ExpressionTemplates>, Policy>
    : public precision<boost::multiprecision::number<Backend, ExpressionTemplates>, Policy>
{};

}

}} // namespace boost::math::policies
#endif // BOOST_MP_MATH_AVAILABLE

#undef NON_MEMBER_OP1
#undef NON_MEMBER_OP2
#undef NON_MEMBER_OP3
#undef NON_MEMBER_OP4

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/miller_rabin.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_MR_HPP
#define BOOST_MP_MR_HPP

#include <random>
#include <cstdint>
#include <type_traits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/integer.hpp>
#include <boost/multiprecision/detail/uniform_int_distribution.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost {
namespace multiprecision {
namespace detail {

template <class I>
bool check_small_factors(const I& n)
{
   constexpr std::uint32_t small_factors1[] = {
       3u, 5u, 7u, 11u, 13u, 17u, 19u, 23u};
   constexpr std::uint32_t pp1 = 223092870u;

   std::uint32_t m1 = integer_modulus(n, pp1);

   for (std::size_t i = 0; i < sizeof(small_factors1) / sizeof(small_factors1[0]); ++i)
   {
      BOOST_MP_ASSERT(pp1 % small_factors1[i] == 0);
      if (m1 % small_factors1[i] == 0)
         return false;
   }

   constexpr std::uint32_t small_factors2[] = {
       29u, 31u, 37u, 41u, 43u, 47u};
   constexpr std::uint32_t pp2 = 2756205443u;

   m1 = integer_modulus(n, pp2);

   for (std::size_t i = 0; i < sizeof(small_factors2) / sizeof(small_factors2[0]); ++i)
   {
      BOOST_MP_ASSERT(pp2 % small_factors2[i] == 0);
      if (m1 % small_factors2[i] == 0)
         return false;
   }

   constexpr std::uint32_t small_factors3[] = {
       53u, 59u, 61u, 67u, 71u};
   constexpr std::uint32_t pp3 = 907383479u;

   m1 = integer_modulus(n, pp3);

   for (std::size_t i = 0; i < sizeof(small_factors3) / sizeof(small_factors3[0]); ++i)
   {
      BOOST_MP_ASSERT(pp3 % small_factors3[i] == 0);
      if (m1 % small_factors3[i] == 0)
         return false;
   }

   constexpr std::uint32_t small_factors4[] = {
       73u, 79u, 83u, 89u, 97u};
   constexpr std::uint32_t pp4 = 4132280413u;

   m1 = integer_modulus(n, pp4);

   for (std::size_t i = 0; i < sizeof(small_factors4) / sizeof(small_factors4[0]); ++i)
   {
      BOOST_MP_ASSERT(pp4 % small_factors4[i] == 0);
      if (m1 % small_factors4[i] == 0)
         return false;
   }

   constexpr std::uint32_t small_factors5[6][4] = {
       {101u, 103u, 107u, 109u},
       {113u, 127u, 131u, 137u},
       {139u, 149u, 151u, 157u},
       {163u, 167u, 173u, 179u},
       {181u, 191u, 193u, 197u},
       {199u, 211u, 223u, 227u}};
   constexpr std::uint32_t pp5[6] =
       {
           121330189u,
           113u * 127u * 131u * 137u,
           139u * 149u * 151u * 157u,
           163u * 167u * 173u * 179u,
           181u * 191u * 193u * 197u,
           199u * 211u * 223u * 227u};

   for (std::size_t k = 0; k < sizeof(pp5) / sizeof(*pp5); ++k)
   {
      m1 = integer_modulus(n, pp5[k]);

      for (std::size_t i = 0; i < 4; ++i)
      {
         BOOST_MP_ASSERT(pp5[k] % small_factors5[k][i] == 0);
         if (m1 % small_factors5[k][i] == 0)
            return false;
      }
   }
   return true;
}

inline bool is_small_prime(std::size_t n)
{
   constexpr unsigned char p[] =
       {
           3u, 5u, 7u, 11u, 13u, 17u, 19u, 23u, 29u, 31u,
           37u, 41u, 43u, 47u, 53u, 59u, 61u, 67u, 71u, 73u,
           79u, 83u, 89u, 97u, 101u, 103u, 107u, 109u, 113u,
           127u, 131u, 137u, 139u, 149u, 151u, 157u, 163u,
           167u, 173u, 179u, 181u, 191u, 193u, 197u, 199u,
           211u, 223u, 227u};
   for (std::size_t i = 0; i < sizeof(p) / sizeof(*p); ++i)
   {
      if (n == p[i])
         return true;
   }
   return false;
}

template <class I>
typename std::enable_if<std::is_convertible<I, unsigned>::value, unsigned>::type
cast_to_unsigned(const I& val)
{
   return static_cast<unsigned>(val);
}
template <class I>
typename std::enable_if<!std::is_convertible<I, unsigned>::value, unsigned>::type
cast_to_unsigned(const I& val)
{
   return val.template convert_to<unsigned>();
}

} // namespace detail

template <class I, class Engine>
typename std::enable_if<number_category<I>::value == number_kind_integer, bool>::type
miller_rabin_test(const I& n, std::size_t trials, Engine& gen)
{
   using number_type = I;

   if (n == 2)
      return true; // Trivial special case.
   if (bit_test(n, 0) == 0)
      return false; // n is even
   if (n <= 227)
      return detail::is_small_prime(detail::cast_to_unsigned(n));

   if (!detail::check_small_factors(n))
      return false;

   number_type nm1 = n - 1;
   //
   // Begin with a single Fermat test - it excludes a lot of candidates:
   //
   number_type q(228), x, y; // We know n is greater than this, as we've excluded small factors
   x = powm(q, nm1, n);
   if (x != 1u)
      return false;

   q          = n - 1;
   std::size_t k = lsb(q);
   q >>= k;

   // Declare our random number generator:
   boost::multiprecision::uniform_int_distribution<number_type> dist(2, n - 2);

   //
   // Execute the trials:
   //
   for (std::size_t i = 0; i < trials; ++i)
   {
      x          = dist(gen);
      y          = powm(x, q, n);
      std::size_t j = 0;
      while (true)
      {
         if (y == nm1)
            break;
         if (y == 1)
         {
            if (j == 0)
               break;
            return false; // test failed
         }
         if (++j == k)
            return false; // failed
         y = powm(y, 2, n);
      }
   }
   return true; // Yeheh! probably prime.
}

template <class I>
typename std::enable_if<number_category<I>::value == number_kind_integer, bool>::type
miller_rabin_test(const I& x, std::size_t trials)
{
   static std::mt19937 gen;
   return miller_rabin_test(x, trials, gen);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Engine>
bool miller_rabin_test(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& n, std::size_t trials, Engine& gen)
{
   using number_type = typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type;
   return miller_rabin_test(number_type(n), trials, gen);
}

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
bool miller_rabin_test(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& n, std::size_t trials)
{
   using number_type = typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type;
   return miller_rabin_test(number_type(n), trials);
}

}} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/mpc.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_MPC_HPP
#define BOOST_MP_MPC_HPP

#include <cstdint>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/atomic.hpp>
#include <boost/multiprecision/traits/is_variable_precision.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <mpc.h>
#include <cmath>
#include <algorithm>
#include <complex>

#ifndef BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION
#define BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION 20
#endif

namespace boost {
namespace multiprecision {
namespace backends {

template <unsigned digits10>
struct mpc_complex_backend;

template <class Backend>
struct logged_adaptor;
template <class Backend>
struct debug_adaptor;

} // namespace backends

template <unsigned digits10>
struct number_category<backends::mpc_complex_backend<digits10> > : public std::integral_constant<int, number_kind_complex>
{};

namespace backends {

namespace detail {

inline void mpc_copy_precision(mpc_t dest, const mpc_t src)
{
   mpfr_prec_t p_dest = mpc_get_prec(dest);
   mpfr_prec_t p_src  = mpc_get_prec(src);
   if (p_dest != p_src)
      mpc_set_prec(dest, p_src);
}
inline void mpc_copy_precision(mpc_t dest, const mpc_t src1, const mpc_t src2)
{
   mpfr_prec_t p_dest = mpc_get_prec(dest);
   mpfr_prec_t p_src1 = mpc_get_prec(src1);
   mpfr_prec_t p_src2 = mpc_get_prec(src2);
   if (p_src2 > p_src1)
      p_src1 = p_src2;
   if (p_dest != p_src1)
      mpc_set_prec(dest, p_src1);
}

template <unsigned digits10>
struct mpc_complex_imp
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;
   using exponent_type = long                          ;

   mpc_complex_imp()
   {
      mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_ui(m_data, 0u, GMP_RNDN);
   }
   mpc_complex_imp(unsigned digits2)
   {
      mpc_init2(m_data, digits2);
      mpc_set_ui(m_data, 0u, GMP_RNDN);
   }

   mpc_complex_imp(const mpc_complex_imp& o)
   {
      mpc_init2(m_data, preserve_source_precision() ? mpc_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      if (o.m_data[0].re[0]._mpfr_d)
         mpc_set(m_data, o.m_data, GMP_RNDN);
   }
   // rvalue copy
   mpc_complex_imp(mpc_complex_imp&& o) noexcept
   {
      mpfr_prec_t binary_default_precision = boost::multiprecision::detail::digits10_2_2(get_default_precision());
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpc_get_prec(o.data()) == binary_default_precision))
      {
         m_data[0] = o.m_data[0];
         o.m_data[0].re[0]._mpfr_d = nullptr;
      }
      else
      {
         // NOTE: C allocation interface must not throw:
         mpc_init2(m_data, binary_default_precision);
         if (o.m_data[0].re[0]._mpfr_d)
            mpc_set(m_data, o.m_data, GMP_RNDN);
      }
   }
   mpc_complex_imp& operator=(const mpc_complex_imp& o)
   {
      if ((o.m_data[0].re[0]._mpfr_d) && (this != &o))
      {
         if (m_data[0].re[0]._mpfr_d == nullptr)
            mpc_init2(m_data, preserve_source_precision() ? mpc_get_prec(o.m_data) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
         else if (preserve_source_precision() && (mpc_get_prec(o.data()) != mpc_get_prec(data())))
         {
            mpc_set_prec(m_data, mpc_get_prec(o.m_data));
         }
         mpc_set(m_data, o.m_data, GMP_RNDN);
      }
      return *this;
   }
   // rvalue assign
   mpc_complex_imp& operator=(mpc_complex_imp&& o) noexcept
   {
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpc_get_prec(o.data()) == mpc_get_prec(data())))
         mpc_swap(m_data, o.m_data);
      else
         *this = static_cast<const mpc_complex_imp&>(o);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#ifdef _MPFR_H_HAVE_INTMAX_T
   mpc_complex_imp& operator=(unsigned long long i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_uj(data(), i, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(long long i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_sj(data(), i, GMP_RNDN);
      return *this;
   }
#else
   mpc_complex_imp& operator=(unsigned long long i)
   {
      mpfr_float_backend<digits10> f(0uL, mpc_get_prec(m_data));
      f = i;
      mpc_set_fr(this->data(), f.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(long long i)
   {
      mpfr_float_backend<digits10> f(0uL, mpc_get_prec(m_data));
      f = i;
      mpc_set_fr(this->data(), f.data(), GMP_RNDN);
      return *this;
   }
#endif
#endif
   mpc_complex_imp& operator=(unsigned long i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_ui(m_data, i, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(long i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_si(m_data, i, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(double d)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_d(m_data, d, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(long double d)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_ld(m_data, d, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(mpz_t i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_z(m_data, i, GMP_RNDN);
      return *this;
   }
   mpc_complex_imp& operator=(gmp_int i)
   {
      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpc_set_z(m_data, i.data(), GMP_RNDN);
      return *this;
   }
#ifdef BOOST_HAS_INT128
   mpc_complex_imp& operator=(int128_type val)
   {
      gmp_int i;
      i            = val;
      return *this = i.data();
   }
   mpc_complex_imp& operator=(uint128_type val)
   {
      gmp_int i;
      i            = val;
      return *this = i.data();
   }
#endif
#ifdef BOOST_HAS_FLOAT128
   mpc_complex_imp& operator=(float128_type val)
   {
      mpfr_float_backend<digits10> f;
      f            = val;
      mpc_set_fr(this->m_data, f.data(), GMP_RNDN);
      return *this;
   }
#endif

   mpc_complex_imp& operator=(const char* s)
   {
      using default_ops::eval_fpclassify;

      if (m_data[0].re[0]._mpfr_d == nullptr)
         mpc_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));

      mpfr_float_backend<digits10> a(0uL, mpc_get_prec(m_data)), b(0uL, mpc_get_prec(m_data));

      if (s && (*s == '('))
      {
         std::string part;
         const char* p = ++s;
         while (*p && (*p != ',') && (*p != ')'))
            ++p;
         part.assign(s, p);
         if (part.size())
            a = part.c_str();
         else
            a = 0uL;
         s = p;
         if (*p && (*p != ')'))
         {
            ++p;
            while (*p && (*p != ')'))
               ++p;
            part.assign(s + 1, p);
         }
         else
            part.erase();
         if (part.size())
            b = part.c_str();
         else
            b = 0uL;
      }
      else
      {
         a = s;
         b = 0uL;
      }

      if (eval_fpclassify(a) == static_cast<int>(FP_NAN))
      {
         mpc_set_fr(this->data(), a.data(), GMP_RNDN);
      }
      else if (eval_fpclassify(b) == static_cast<int>(FP_NAN))
      {
         mpc_set_fr(this->data(), b.data(), GMP_RNDN);
      }
      else
      {
         mpc_set_fr_fr(m_data, a.data(), b.data(), GMP_RNDN);
      }
      return *this;
   }
   void swap(mpc_complex_imp& o) noexcept
   {
      mpc_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);

      mpfr_float_backend<digits10> a(0uL, mpc_get_prec(m_data)), b(0uL, mpc_get_prec(m_data));

      mpc_real(a.data(), m_data, GMP_RNDN);
      mpc_imag(b.data(), m_data, GMP_RNDN);

      if (eval_is_zero(b))
         return a.str(digits, f);

      return "(" + a.str(digits, f) + "," + b.str(digits, f) + ")";
   }
   ~mpc_complex_imp() noexcept
   {
      if (m_data[0].re[0]._mpfr_d)
         mpc_clear(m_data);
   }
   void negate() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);
      mpc_neg(m_data, m_data, GMP_RNDN);
   }
   int compare(const mpc_complex_imp& o) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d && o.m_data[0].re[0]._mpfr_d);
      return mpc_cmp(m_data, o.m_data);
   }
   int compare(const mpc_complex_backend<digits10>& o) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d && o.m_data[0].re[0]._mpfr_d);
      return mpc_cmp(m_data, o.data());
   }
   int compare(long int i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);
      return mpc_cmp_si(m_data, i);
   }
   int compare(unsigned long int i) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);
      constexpr const unsigned long int max_val = (std::numeric_limits<long>::max)();
      if (i > max_val)
      {
         mpc_complex_imp d(mpc_get_prec(m_data));
         d = i;
         return compare(d);
      }
      return mpc_cmp_si(m_data, static_cast<long>(i));
   }
   template <class V>
   int compare(const V& v) const noexcept
   {
      mpc_complex_imp d(mpc_get_prec(m_data));
      d = v;
      return compare(d);
   }
   mpc_t& data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);
      return m_data;
   }
   const mpc_t& data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].re[0]._mpfr_d);
      return m_data;
   }

 protected:
   mpc_t            m_data;
   static boost::multiprecision::detail::precision_type& get_global_default_precision() noexcept
   {
      static boost::multiprecision::detail::precision_type val(BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION);
      return val;
   }
   static unsigned& get_default_precision() noexcept
   {
      static BOOST_MP_THREAD_LOCAL unsigned val(get_global_default_precision());
      return val;
   }
#ifndef BOOST_MT_NO_ATOMIC_INT
   static std::atomic<variable_precision_options>& get_global_default_options() noexcept
#else
   static variable_precision_options& get_global_default_options() noexcept
#endif
   {
#ifndef BOOST_MT_NO_ATOMIC_INT
      static std::atomic<variable_precision_options> val{variable_precision_options::preserve_related_precision};
#else
      static variable_precision_options val{variable_precision_options::preserve_related_precision};
#endif
      return val;
   }
   static variable_precision_options& get_default_options() noexcept
   {
      static BOOST_MP_THREAD_LOCAL variable_precision_options val(get_global_default_options());
      return val;
   }
   static bool preserve_source_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
   static bool preserve_component_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_component_precision;
   }
   static bool preserve_related_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_related_precision;
   }
   static bool preserve_all_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_all_precision;
   }
};

} // namespace detail

template <unsigned digits10>
struct mpc_complex_backend : public detail::mpc_complex_imp<digits10>
{
   mpc_complex_backend() : detail::mpc_complex_imp<digits10>() {}
   mpc_complex_backend(const mpc_complex_backend& o) : detail::mpc_complex_imp<digits10>(o) {}
   // rvalue copy
   mpc_complex_backend(mpc_complex_backend&& o) : detail::mpc_complex_imp<digits10>(static_cast<detail::mpc_complex_imp<digits10>&&>(o))
   {}
   template <unsigned D>
   mpc_complex_backend(const mpc_complex_backend<D>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   explicit mpc_complex_backend(const mpc_complex_backend<D>& val, typename std::enable_if<!(D <= digits10)>::type* = nullptr)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend(const mpc_t val)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend(const std::complex<float>& val)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   mpc_complex_backend(const std::complex<double>& val)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   mpc_complex_backend(const std::complex<long double>& val)
       : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_ld_ld(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   mpc_complex_backend(mpz_srcptr val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_z(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpz_srcptr val)
   {
      mpc_set_z(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(gmp_int const& val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_z(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend& operator=(gmp_int const& val)
   {
      mpc_set_z(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpf_srcptr val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_f(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpf_srcptr val)
   {
      mpc_set_f(this->m_data, val, GMP_RNDN);
      return *this;
   }
   template <unsigned D10>
   mpc_complex_backend(gmp_float<D10> const& val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D10>
   mpc_complex_backend& operator=(gmp_float<D10> const& val)
   {
      mpc_set_f(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpq_srcptr val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_q(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpq_srcptr val)
   {
      mpc_set_q(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(gmp_rational const& val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_q(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend& operator=(gmp_rational const& val)
   {
      mpc_set_q(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpfr_srcptr val) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_fr(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpfr_srcptr val)
   {
      mpc_set_fr(this->m_data, val, GMP_RNDN);
      return *this;
   }
   template <unsigned D10, mpfr_allocation_type AllocationType>
   mpc_complex_backend(mpfr_float_backend<D10, AllocationType> const& val, typename std::enable_if<D10 <= digits10>::type* = nullptr) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D10, mpfr_allocation_type AllocationType>
   explicit mpc_complex_backend(mpfr_float_backend<D10, AllocationType> const& val, typename std::enable_if<!(D10 <= digits10)>::type* = nullptr) : detail::mpc_complex_imp<digits10>()
   {
      mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D10, mpfr_allocation_type AllocationType>
   mpc_complex_backend& operator=(mpfr_float_backend<D10, AllocationType> const& val)
   {
      mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const mpc_complex_backend& o)
   {
      *static_cast<detail::mpc_complex_imp<digits10>*>(this) = static_cast<detail::mpc_complex_imp<digits10> const&>(o);
      return *this;
   }
   // rvalue assign
   mpc_complex_backend& operator=(mpc_complex_backend&& o) noexcept
   {
      *static_cast<detail::mpc_complex_imp<digits10>*>(this) = static_cast<detail::mpc_complex_imp<digits10>&&>(o);
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<detail::mpc_complex_imp<digits10>, V>::value, mpc_complex_backend&>::type operator=(const V& v)
   {
      *static_cast<detail::mpc_complex_imp<digits10>*>(this) = v;
      return *this;
   }
   mpc_complex_backend& operator=(const mpc_t val)
   {
      mpc_set(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<float>& val)
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<double>& val)
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<long double>& val)
   {
      mpc_set_ld_ld(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   // We don't change our precision here, this is a fixed precision type:
   template <unsigned D>
   mpc_complex_backend& operator=(const mpc_complex_backend<D>& val)
   {
      mpc_set(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
};

template <>
struct mpc_complex_backend<0> : public detail::mpc_complex_imp<0>
{
   mpc_complex_backend() : detail::mpc_complex_imp<0>() {}
   mpc_complex_backend(const mpc_t val)
       : detail::mpc_complex_imp<0>(mpc_get_prec(val))
   {
      mpc_set(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend(const mpc_complex_backend& o) : detail::mpc_complex_imp<0>(o) {}
   // rvalue copy
   mpc_complex_backend(mpc_complex_backend&& o) noexcept : detail::mpc_complex_imp<0>(static_cast<detail::mpc_complex_imp<0>&&>(o))
   {}
   mpc_complex_backend(const mpc_complex_backend& o, unsigned digits10)
       : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
   {
      mpc_set(this->m_data, o.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpc_complex_backend(const mpc_complex_backend<D>& val)
       : detail::mpc_complex_imp<0>(preserve_related_precision() ? mpc_get_prec(val.data()) : multiprecision::detail::digits10_2_2(get_default_precision()))
   {
      mpc_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpc_complex_backend(const mpfr_float_backend<D>& val)
       : detail::mpc_complex_imp<0>((D == 0 ? this->preserve_component_precision() : this->preserve_related_precision()) ? mpfr_get_prec(val.data()) : multiprecision::detail::digits10_2_2(this->get_default_precision()))
   {
      mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend(mpz_srcptr val) : detail::mpc_complex_imp<0>()
   {
      mpc_set_z(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpz_srcptr val)
   {
      mpc_set_z(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(gmp_int const& val) : detail::mpc_complex_imp<0>(preserve_all_precision() ? used_gmp_int_bits(val) : boost::multiprecision::detail::digits10_2_2(thread_default_precision()))
   {
      mpc_set_z(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend& operator=(gmp_int const& val)
   {
      if (this->m_data[0].im->_mpfr_d == nullptr)
      {
         unsigned requested_precision = this->thread_default_precision();
         if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
         {
            unsigned d2 = used_gmp_int_bits(val);
            unsigned d10 = 1 + multiprecision::detail::digits2_2_10(d2);
            if (d10 > requested_precision)
               requested_precision = d10;
         }
         mpc_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      }
      else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         unsigned requested_precision = this->thread_default_precision();
         unsigned d2 = used_gmp_int_bits(val);
         unsigned d10 = 1 + multiprecision::detail::digits2_2_10(d2);
         if (d10 > requested_precision)
            this->precision(d10);
      }
      mpc_set_z(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpf_srcptr val) : detail::mpc_complex_imp<0>((unsigned)mpf_get_prec(val))
   {
      mpc_set_f(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpf_srcptr val)
   {
      if ((mp_bitcnt_t)mpc_get_prec(data()) != mpf_get_prec(val))
      {
         mpc_complex_backend t(val);
         t.swap(*this);
      }
      else
         mpc_set_f(this->m_data, val, GMP_RNDN);
      return *this;
   }
   template <unsigned digits10>
   mpc_complex_backend(gmp_float<digits10> const& val) : detail::mpc_complex_imp<0>(preserve_all_precision() ? (unsigned)mpf_get_prec(val.data()) : multiprecision::detail::digits10_2_2(get_default_precision()))
   {
      mpc_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned digits10>
   mpc_complex_backend& operator=(gmp_float<digits10> const& val)
   {
      if (preserve_all_precision() && (mpc_get_prec(data()) != (mpfr_prec_t)mpf_get_prec(val.data())))
      {
         mpc_complex_backend t(val);
         t.swap(*this);
      }
      else
         mpc_set_f(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpq_srcptr val) : detail::mpc_complex_imp<0>()
   {
      mpc_set_q(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpq_srcptr val)
   {
      mpc_set_q(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(gmp_rational const& val) : detail::mpc_complex_imp<0>(preserve_all_precision() ? used_gmp_rational_bits(val) : boost::multiprecision::detail::digits10_2_2(thread_default_precision()))
   {
      mpc_set_q(this->m_data, val.data(), GMP_RNDN);
   }
   mpc_complex_backend& operator=(gmp_rational const& val)
   {
      if (this->m_data[0].im->_mpfr_d == nullptr)
      {
         unsigned requested_precision = this->get_default_precision();
         if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
         {
            unsigned d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(val));
            if (d10 > requested_precision)
               requested_precision = d10;
         }
         mpc_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision));
      }
      else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         unsigned requested_precision = this->get_default_precision();
         unsigned d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(val));
         if (d10 > requested_precision)
            this->precision(d10);
      }
      mpc_set_q(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(mpfr_srcptr val) : detail::mpc_complex_imp<0>(mpfr_get_prec(val))
   {
      mpc_set_fr(this->m_data, val, GMP_RNDN);
   }
   mpc_complex_backend& operator=(mpfr_srcptr val)
   {
      if (mpc_get_prec(data()) != mpfr_get_prec(val))
      {
         mpc_complex_backend t(val);
         t.swap(*this);
      }
      else
         mpc_set_fr(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpc_complex_backend(const std::complex<float>& val)
       : detail::mpc_complex_imp<0>()
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   mpc_complex_backend(const std::complex<double>& val)
       : detail::mpc_complex_imp<0>()
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   mpc_complex_backend(const std::complex<long double>& val)
       : detail::mpc_complex_imp<0>()
   {
      mpc_set_ld_ld(this->m_data, val.real(), val.imag(), GMP_RNDN);
   }
   // Construction with precision:
   template <class T, class U>
   mpc_complex_backend(const T& a, const U& b, unsigned digits10)
       : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
   {
      // We can't use assign_components here because it copies the precision of
      // a and b, not digits10....
      boost::multiprecision::detail::scoped_precision_options<mpfr_float> scoped(*this);
      (void)scoped;
      mpfr_float ca(a), cb(b);
      mpc_set_fr_fr(this->data(), ca.backend().data(), cb.backend().data(), GMP_RNDN);
   }
   template <unsigned N>
   mpc_complex_backend(const mpfr_float_backend<N>& a, const mpfr_float_backend<N>& b, unsigned digits10)
       : detail::mpc_complex_imp<0>(multiprecision::detail::digits10_2_2(digits10))
   {
      mpc_set_fr_fr(this->data(), a.data(), b.data(), GMP_RNDN);
   }

   mpc_complex_backend& operator=(const mpc_complex_backend& o) = default;
   // rvalue assign
   mpc_complex_backend& operator=(mpc_complex_backend&& o) noexcept = default;

   template <class V>
   mpc_complex_backend& operator=(const V& v)
   {
      constexpr unsigned d10 = std::is_floating_point<V>::value ?
         std::numeric_limits<V>::digits10 :
         std::numeric_limits<V>::digits10 ? 1 + std::numeric_limits<V>::digits10 :
         1 + boost::multiprecision::detail::digits2_2_10(std::numeric_limits<V>::digits);

      if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         BOOST_IF_CONSTEXPR(std::is_floating_point<V>::value)
         {
            if (std::numeric_limits<V>::digits > mpc_get_prec(this->data()))
               mpc_set_prec(this->data(), std::numeric_limits<V>::digits);
         }
      else
      {
         if (precision() < d10)
            this->precision(d10);
      }
      }

      *static_cast<detail::mpc_complex_imp<0>*>(this) = v;
      return *this;
   }
   mpc_complex_backend& operator=(const mpc_t val)
   {
      mpc_set_prec(this->m_data, mpc_get_prec(val));
      mpc_set(this->m_data, val, GMP_RNDN);
      return *this;
   }
   template <unsigned D>
   mpc_complex_backend& operator=(const mpc_complex_backend<D>& val)
   {
      mpc_set_prec(this->m_data, mpc_get_prec(val.data()));
      mpc_set(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   template <unsigned D>
   mpc_complex_backend& operator=(const mpfr_float_backend<D>& val)
   {
      if (D == 0 ? this->preserve_component_precision() : this->preserve_related_precision())
         mpc_set_prec(this->m_data, mpfr_get_prec(val.data()));
      mpc_set_fr(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<float>& val)
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<double>& val)
   {
      mpc_set_d_d(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   mpc_complex_backend& operator=(const std::complex<long double>& val)
   {
      mpc_set_ld_ld(this->m_data, val.real(), val.imag(), GMP_RNDN);
      return *this;
   }
   static unsigned default_precision() noexcept
   {
      return get_global_default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      get_global_default_precision() = v;
   }
   static unsigned thread_default_precision() noexcept
   {
      return get_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      get_default_precision() = v;
   }
   unsigned precision() const noexcept
   {
      return multiprecision::detail::digits2_2_10(mpc_get_prec(this->m_data));
   }
   void precision(unsigned digits10) noexcept
   {
      mpfr_prec_round(mpc_realref(this->m_data), multiprecision::detail::digits10_2_2((digits10)), GMP_RNDN);
      mpfr_prec_round(mpc_imagref(this->m_data), multiprecision::detail::digits10_2_2((digits10)), GMP_RNDN);
   }
   //
   // Variable precision options:
   //
   static variable_precision_options default_variable_precision_options() noexcept
   {
      return get_global_default_options();
   }
   static variable_precision_options thread_default_variable_precision_options() noexcept
   {
      return get_default_options();
   }
   static void default_variable_precision_options(variable_precision_options opts)
   {
      get_global_default_options() = opts;
   }
   static void thread_default_variable_precision_options(variable_precision_options opts)
   {
      get_default_options() = opts;
   }
};

template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const mpc_complex_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) == 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const mpc_complex_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) < 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const mpc_complex_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) > 0;
}

template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& result, const mpc_complex_backend<D2>& o)
{
   mpc_add(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& result, const mpfr_float_backend<D2>& o)
{
   mpc_add_fr(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& result, const mpc_complex_backend<D2>& o)
{
   mpc_sub(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& result, const mpfr_float_backend<D2>& o)
{
   mpc_sub_fr(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& result, const mpc_complex_backend<D2>& o)
{
   if ((void*)&result == (void*)&o)
      mpc_sqr(result.data(), o.data(), GMP_RNDN);
   else
      mpc_mul(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& result, const mpfr_float_backend<D2>& o)
{
   mpc_mul_fr(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& result, const mpc_complex_backend<D2>& o)
{
   mpc_div(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& result, const mpfr_float_backend<D2>& o)
{
   mpc_div_fr(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10>
inline void eval_add(mpc_complex_backend<digits10>& result, unsigned long i)
{
   mpc_add_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
inline void eval_subtract(mpc_complex_backend<digits10>& result, unsigned long i)
{
   mpc_sub_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
inline void eval_multiply(mpc_complex_backend<digits10>& result, unsigned long i)
{
   mpc_mul_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
inline void eval_divide(mpc_complex_backend<digits10>& result, unsigned long i)
{
   mpc_div_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10>
inline void eval_add(mpc_complex_backend<digits10>& result, long i)
{
   if (i > 0)
      mpc_add_ui(result.data(), result.data(), i, GMP_RNDN);
   else
      mpc_sub_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
}
template <unsigned digits10>
inline void eval_subtract(mpc_complex_backend<digits10>& result, long i)
{
   if (i > 0)
      mpc_sub_ui(result.data(), result.data(), i, GMP_RNDN);
   else
      mpc_add_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
}
template <unsigned digits10>
inline void eval_multiply(mpc_complex_backend<digits10>& result, long i)
{
   mpc_mul_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
   if (i < 0)
      mpc_neg(result.data(), result.data(), GMP_RNDN);
}
template <unsigned digits10>
inline void eval_divide(mpc_complex_backend<digits10>& result, long i)
{
   mpc_div_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
   if (i < 0)
      mpc_neg(result.data(), result.data(), GMP_RNDN);
}
//
// Specialised 3 arg versions of the basic operators:
//
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_add(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_add(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_add(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpfr_float_backend<D3>& y)
{
   mpc_add_fr(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_add(mpc_complex_backend<D1>& a, const mpfr_float_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_add_fr(a.data(), y.data(), x.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, unsigned long y)
{
   mpc_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
   if (y < 0)
      mpc_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
   else
      mpc_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, unsigned long x, const mpc_complex_backend<D2>& y)
{
   mpc_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
   if (x < 0)
   {
      mpc_ui_sub(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDN);
      mpc_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpc_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_sub(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpfr_float_backend<D3>& y)
{
   mpc_sub_fr(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpfr_float_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_fr_sub(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, unsigned long y)
{
   mpc_sub_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
   if (y < 0)
      mpc_add_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
   else
      mpc_sub_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, unsigned long x, const mpc_complex_backend<D2>& y)
{
   mpc_ui_sub(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
   if (x < 0)
   {
      mpc_add_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDN);
      mpc_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpc_ui_sub(a.data(), x, y.data(), GMP_RNDN);
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   if ((void*)&x == (void*)&y)
      mpc_sqr(a.data(), x.data(), GMP_RNDN);
   else
      mpc_mul(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpfr_float_backend<D3>& y)
{
   mpc_mul_fr(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpfr_float_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_mul_fr(a.data(), y.data(), x.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, unsigned long y)
{
   mpc_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
   if (y < 0)
   {
      mpc_mul_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
      a.negate();
   }
   else
      mpc_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, unsigned long x, const mpc_complex_backend<D2>& y)
{
   mpc_mul_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
   if (x < 0)
   {
      mpc_mul_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDN);
      mpc_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpc_mul_ui(a.data(), y.data(), x, GMP_RNDN);
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_div(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, const mpfr_float_backend<D3>& y)
{
   mpc_div_fr(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpfr_float_backend<D2>& x, const mpc_complex_backend<D3>& y)
{
   mpc_fr_div(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, unsigned long y)
{
   mpc_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, const mpc_complex_backend<D2>& x, long y)
{
   if (y < 0)
   {
      mpc_div_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
      a.negate();
   }
   else
      mpc_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, unsigned long x, const mpc_complex_backend<D2>& y)
{
   mpc_ui_div(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpc_complex_backend<D1>& a, long x, const mpc_complex_backend<D2>& y)
{
   if (x < 0)
   {
      mpc_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDN);
      mpc_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpc_ui_div(a.data(), x, y.data(), GMP_RNDN);
}

template <unsigned digits10>
inline bool eval_is_zero(const mpc_complex_backend<digits10>& val) noexcept
{
   return (0 != mpfr_zero_p(mpc_realref(val.data()))) && (0 != mpfr_zero_p(mpc_imagref(val.data())));
}
template <unsigned digits10>
inline int eval_get_sign(const mpc_complex_backend<digits10>&)
{
   static_assert(digits10 == UINT_MAX, "Complex numbers have no sign bit."); // designed to always fail
   return 0;
}

template <unsigned digits10>
inline void eval_convert_to(unsigned long* result, const mpc_complex_backend<digits10>& val)
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(long* result, const mpc_complex_backend<digits10>& val)
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
#ifdef _MPFR_H_HAVE_INTMAX_T
template <unsigned digits10>
inline void eval_convert_to(unsigned long long* result, const mpc_complex_backend<digits10>& val)
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(long long* result, const mpc_complex_backend<digits10>& val)
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
#endif
template <unsigned digits10>
inline void eval_convert_to(double* result, const mpc_complex_backend<digits10>& val) noexcept
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(long double* result, const mpc_complex_backend<digits10>& val) noexcept
{
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
#ifdef BOOST_HAS_INT128
template <unsigned digits10>
inline void eval_convert_to(uint128_type* result, const mpc_complex_backend<digits10>& val)
{
   using default_ops::eval_convert_to;
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(int128_type* result, const mpc_complex_backend<digits10>& val)
{
   using default_ops::eval_convert_to;
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
#endif
#ifdef BOOST_HAS_FLOAT128
template <unsigned digits10>
inline void eval_convert_to(float128_type* result, const mpc_complex_backend<digits10>& val)
{
   using default_ops::eval_convert_to;
   if (0 == mpfr_zero_p(mpc_imagref(val.data())))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert imaginary number to scalar."));
   }
   mpfr_float_backend<digits10> t;
   mpc_real(t.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, t);
}
#endif

template <mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpc_complex_backend<0>& result, const mpfr_float_backend<0, AllocationType>& a, const mpfr_float_backend<0, AllocationType>& b)
{
   if (result.thread_default_variable_precision_options() >= variable_precision_options::preserve_component_precision)
   {
      unsigned long prec = (std::max)(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
      mpc_set_prec(result.data(), prec);
   }
}
template <unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpc_complex_backend<0>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b)
{
   if (result.thread_default_variable_precision_options() >= variable_precision_options::preserve_related_precision)
   {
      unsigned long prec = (std::max)(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
      mpc_set_prec(result.data(), prec);
   }
}
template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpc_complex_backend<D1>&, const mpfr_float_backend<D2, AllocationType>&, const mpfr_float_backend<D2, AllocationType>&)
{
}

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b)
{
   //
   // This is called from class number's constructors, so if we have variable
   // precision, then copy the precision of the source variables.
   //
   assign_components_set_precision(result, a, b);
   using default_ops::eval_fpclassify;
   if (eval_fpclassify(a) == static_cast<int>(FP_NAN))
   {
      mpc_set_fr(result.data(), a.data(), GMP_RNDN);
   }
   else if (eval_fpclassify(b) == static_cast<int>(FP_NAN))
   {
      mpc_set_fr(result.data(), b.data(), GMP_RNDN);
   }
   else
   {
      mpc_set_fr_fr(result.data(), a.data(), b.data(), GMP_RNDN);
   }
}

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, unsigned long a, unsigned long b)
{
   mpc_set_ui_ui(result.data(), a, b, GMP_RNDN);
}

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, long a, long b)
{
   mpc_set_si_si(result.data(), a, b, GMP_RNDN);
}

#if defined(BOOST_HAS_LONG_LONG) && defined(_MPFR_H_HAVE_INTMAX_T)
template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, unsigned long long a, unsigned long long b)
{
   mpc_set_uj_uj(result.data(), a, b, GMP_RNDN);
}

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, long long a, long long b)
{
   mpc_set_sj_sj(result.data(), a, b, GMP_RNDN);
}
#endif

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, double a, double b)
{
   if (BOOST_MP_ISNAN(a))
   {
      mpc_set_d(result.data(), a, GMP_RNDN);
   }
   else if (BOOST_MP_ISNAN(b))
   {
      mpc_set_d(result.data(), b, GMP_RNDN);
   }
   else
   {
      mpc_set_d_d(result.data(), a, b, GMP_RNDN);
   }
}

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpc_complex_backend<D1>& result, long double a, long double b)
{
   if (BOOST_MP_ISNAN(a))
   {
      mpc_set_d(result.data(), a, GMP_RNDN);
   }
   else if (BOOST_MP_ISNAN(b))
   {
      mpc_set_d(result.data(), b, GMP_RNDN);
   }
   else
   {
      mpc_set_ld_ld(result.data(), a, b, GMP_RNDN);
   }
}

//
// Native non-member operations:
//
template <unsigned Digits10>
inline void eval_sqrt(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& val)
{
   mpc_sqrt(result.data(), val.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_pow(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& b, const mpc_complex_backend<Digits10>& e)
{
   mpc_pow(result.data(), b.data(), e.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_exp(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_exp(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_log(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_log(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_log10(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_log10(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_sin(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_sin(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_cos(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_cos(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_tan(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_tan(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_asin(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_asin(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_acos(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_acos(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_atan(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_atan(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_sinh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_sinh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_cosh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_cosh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_tanh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_tanh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_asinh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_asinh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_acosh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_acosh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_atanh(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_atanh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_conj(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_conj(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_proj(mpc_complex_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpc_proj(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_real(mpfr_float_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpfr_set_prec(result.data(), mpfr_get_prec(mpc_realref(arg.data())));
   mpfr_set(result.data(), mpc_realref(arg.data()), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_imag(mpfr_float_backend<Digits10>& result, const mpc_complex_backend<Digits10>& arg)
{
   mpfr_set_prec(result.data(), mpfr_get_prec(mpc_imagref(arg.data())));
   mpfr_set(result.data(), mpc_imagref(arg.data()), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
   mpfr_set(mpc_imagref(result.data()), arg.data(), GMP_RNDN);
}

template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const mpfr_float_backend<Digits10>& arg)
{
   mpfr_set(mpc_realref(result.data()), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const gmp_int& arg)
{
   mpfr_set_z(mpc_realref(result.data()), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const gmp_rational& arg)
{
   mpfr_set_q(mpc_realref(result.data()), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const unsigned& arg)
{
   mpfr_set_ui(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const unsigned long& arg)
{
   mpfr_set_ui(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const int& arg)
{
   mpfr_set_si(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const long& arg)
{
   mpfr_set_si(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const float& arg)
{
   mpfr_set_flt(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const double& arg)
{
   mpfr_set_d(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const long double& arg)
{
   mpfr_set_ld(mpc_realref(result.data()), arg, GMP_RNDN);
}
#if defined(BOOST_HAS_LONG_LONG) && defined(_MPFR_H_HAVE_INTMAX_T)
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const unsigned long long& arg)
{
   mpfr_set_uj(mpc_realref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_real(mpc_complex_backend<Digits10>& result, const long long& arg)
{
   mpfr_set_sj(mpc_realref(result.data()), arg, GMP_RNDN);
}
#endif

template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const gmp_int& arg)
{
   mpfr_set_z(mpc_imagref(result.data()), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const gmp_rational& arg)
{
   mpfr_set_q(mpc_imagref(result.data()), arg.data(), GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const unsigned& arg)
{
   mpfr_set_ui(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const unsigned long& arg)
{
   mpfr_set_ui(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const int& arg)
{
   mpfr_set_si(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const long& arg)
{
   mpfr_set_si(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const float& arg)
{
   mpfr_set_flt(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const double& arg)
{
   mpfr_set_d(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const long double& arg)
{
   mpfr_set_ld(mpc_imagref(result.data()), arg, GMP_RNDN);
}
#if defined(BOOST_HAS_LONG_LONG) && defined(_MPFR_H_HAVE_INTMAX_T)
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const unsigned long long& arg)
{
   mpfr_set_uj(mpc_imagref(result.data()), arg, GMP_RNDN);
}
template <unsigned Digits10>
inline void eval_set_imag(mpc_complex_backend<Digits10>& result, const long long& arg)
{
   mpfr_set_sj(mpc_imagref(result.data()), arg, GMP_RNDN);
}
#endif

template <unsigned Digits10>
inline std::size_t hash_value(const mpc_complex_backend<Digits10>& val)
{
   std::size_t result = 0;
   std::size_t len    = val.data()[0].re[0]._mpfr_prec / mp_bits_per_limb;
   if (val.data()[0].re[0]._mpfr_prec % mp_bits_per_limb)
      ++len;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0].re[0]._mpfr_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0].re[0]._mpfr_exp, val.data()[0].re[0]._mpfr_sign);

   len = val.data()[0].im[0]._mpfr_prec / mp_bits_per_limb;
   if (val.data()[0].im[0]._mpfr_prec % mp_bits_per_limb)
      ++len;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0].im[0]._mpfr_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0].im[0]._mpfr_exp, val.data()[0].im[0]._mpfr_sign);
   return result;
}

} // namespace backends

namespace detail {
template <>
struct is_variable_precision<backends::mpc_complex_backend<0> > : public std::integral_constant<bool, true>
{};
} // namespace detail

template <>
struct number_category<detail::canonical<mpc_t, backends::mpc_complex_backend<0> >::type> : public std::integral_constant<int, number_kind_floating_point>
{};

using boost::multiprecision::backends::mpc_complex_backend;

using mpc_complex_50 = number<mpc_complex_backend<50> >  ;
using mpc_complex_100 = number<mpc_complex_backend<100> > ;
using mpc_complex_500 = number<mpc_complex_backend<500> > ;
using mpc_complex_1000 = number<mpc_complex_backend<1000> >;
using mpc_complex = number<mpc_complex_backend<0> >   ;

template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct component_type<number<mpc_complex_backend<Digits10>, ExpressionTemplates> >
{
   using type = number<mpfr_float_backend<Digits10>, ExpressionTemplates>;
};

template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct component_type<number<backends::logged_adaptor<mpc_complex_backend<Digits10> >, ExpressionTemplates> >
{
   using type = number<mpfr_float_backend<Digits10>, ExpressionTemplates>;
};
template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct component_type<number<backends::debug_adaptor<mpc_complex_backend<Digits10> >, ExpressionTemplates> >
{
   using type = number<backends::debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates>;
};

template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<mpfr_float_backend<Digits10>, ExpressionTemplates> >
{
   using type = number<mpc_complex_backend<Digits10>, ExpressionTemplates>;
};
template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<backends::logged_adaptor<mpfr_float_backend<Digits10>>, ExpressionTemplates> >
{
   using type = number<mpc_complex_backend<Digits10>, ExpressionTemplates>;
};
template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<backends::debug_adaptor<mpfr_float_backend<Digits10>>, ExpressionTemplates> >
{
   using type = number<backends::debug_adaptor<mpc_complex_backend<Digits10> >, ExpressionTemplates>;
};

}

} // namespace boost::multiprecision

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/mpfi.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_MPFI_HPP
#define BOOST_MP_MPFI_HPP

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <type_traits>
#include <string>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/precision.hpp>
#include <boost/multiprecision/detail/atomic.hpp>
#include <boost/multiprecision/traits/max_digits10.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <mpfi.h>

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/constants/constants.hpp>
#endif

#ifndef BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION
#define BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION 20
#endif

namespace boost {
namespace multiprecision {
namespace backends {

template <unsigned digits10>
struct mpfi_float_backend;

template <class Backend>
struct debug_adaptor;

} // namespace backends

template <unsigned digits10>
struct number_category<backends::mpfi_float_backend<digits10> > : public std::integral_constant<int, number_kind_floating_point>
{};

struct interval_error : public std::runtime_error
{
   interval_error(const std::string& s) : std::runtime_error(s) {}
};

namespace detail {
   template <>
   struct is_variable_precision<backends::mpfi_float_backend<0> > : public std::integral_constant<bool, true>
   {};
} // namespace detail


namespace backends {

namespace detail {

inline int mpfi_sgn(mpfi_srcptr p)
{
   if (mpfi_is_zero(p))
      return 0;
   if (mpfi_is_strictly_pos(p))
      return 1;
   if (mpfi_is_strictly_neg(p))
      return -1;
   BOOST_MP_THROW_EXCEPTION(interval_error("Sign of interval is ambiguous."));
}

template <unsigned digits10>
struct mpfi_float_imp;

template <unsigned digits10>
struct mpfi_float_imp
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;
   using exponent_type = long                          ;

   mpfi_float_imp()
   {
      mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfi_set_ui(m_data, 0u);
   }
   mpfi_float_imp(unsigned prec)
   {
      mpfi_init2(m_data, prec);
      mpfi_set_ui(m_data, 0u);
   }

   mpfi_float_imp(const mpfi_float_imp& o)
   {
      mpfi_init2(m_data, preserve_source_precision() ? mpfi_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      if (o.m_data[0].left._mpfr_d)
         mpfi_set(m_data, o.m_data);
   }
   template <unsigned D, mpfr_allocation_type AllocationType>
   mpfi_float_imp(const mpfr_float_imp<D, AllocationType>& o)
   {
      mpfi_init2(m_data, (D == 0 ? preserve_component_precision() : preserve_related_precision()) ? mpfr_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      if (o.data()[0]._mpfr_d)
         mpfi_set_fr(m_data, o.data());
   }
   // rvalue copy
   mpfi_float_imp(mpfi_float_imp&& o) noexcept
   {
      mpfr_prec_t binary_default_precision = boost::multiprecision::detail::digits10_2_2(get_default_precision());
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpfi_get_prec(o.data()) == binary_default_precision))
      {
         m_data[0]                = o.m_data[0];
         o.m_data[0].left._mpfr_d = nullptr;
      }
      else
      {
         // NOTE: C allocation interface must not throw:
         mpfi_init2(m_data, binary_default_precision);
         mpfi_set(m_data, o.m_data);
      }
   }
   mpfi_float_imp& operator=(const mpfi_float_imp& o)
   {
      if (this != &o)
      {
         if (m_data[0].left._mpfr_d == nullptr)
            mpfi_init2(m_data, preserve_source_precision() ? mpfi_get_prec(o.m_data) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
         else if (preserve_source_precision() && (mpfi_get_prec(o.data()) != mpfi_get_prec(data())))
         {
            mpfi_set_prec(m_data, mpfi_get_prec(o.m_data));
         }
         mpfi_set(m_data, o.m_data);
      }
      return *this;
   }
   // rvalue assign
   mpfi_float_imp& operator=(mpfi_float_imp&& o) noexcept
   {
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpfi_get_prec(o.data()) == mpfi_get_prec(data())))
         mpfi_swap(m_data, o.m_data);
      else
         *this = static_cast<const mpfi_float_imp&>(o);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#ifdef _MPFR_H_HAVE_INTMAX_T
   mpfi_float_imp& operator=(unsigned long long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfr_set_uj(left_data(), i, GMP_RNDD);
      mpfr_set_uj(right_data(), i, GMP_RNDU);
      return *this;
   }
   mpfi_float_imp& operator=(long long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfr_set_sj(left_data(), i, GMP_RNDD);
      mpfr_set_sj(right_data(), i, GMP_RNDU);
      return *this;
   }
#else
   mpfi_float_imp& operator=(unsigned long long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1u);
      unsigned               shift = 0;
      mpfi_t                 t;
      mpfi_init2(t, (std::max)(static_cast<mpfr_prec_t>(std::numeric_limits<unsigned long long>::digits), static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(digits10))));
      mpfi_set_ui(m_data, 0);
      while (i)
      {
         mpfi_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpfi_mul_2exp(t, t, shift);
         mpfi_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpfi_clear(t);
      return *this;
   }
   mpfi_float_imp& operator=(long long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfi_neg(m_data, m_data);
      return *this;
   }
#endif
#endif
#ifdef BOOST_HAS_INT128
   mpfi_float_imp& operator=(uint128_type i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      constexpr uint128_type mask = ((((static_cast<uint128_type>(1u) << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1u);
      unsigned               shift = 0;
      mpfi_t                 t;
      mpfi_init2(t, (std::max)(static_cast<mpfr_prec_t>(128), static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(digits10))));
      mpfi_set_ui(m_data, 0);
      while (i)
      {
         mpfi_set_ui(t, static_cast<unsigned long>(i & mask));
         if (shift)
            mpfi_mul_2exp(t, t, shift);
         mpfi_add(m_data, m_data, t);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpfi_clear(t);
      return *this;
   }
   mpfi_float_imp& operator=(int128_type i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      bool neg = i < 0;
      *this = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfi_neg(m_data, m_data);
      return *this;
   }
#endif
   mpfi_float_imp& operator=(unsigned long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfi_set_ui(m_data, i);
      return *this;
   }
   mpfi_float_imp& operator=(long i)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfi_set_si(m_data, i);
      return *this;
   }
   mpfi_float_imp& operator=(double d)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfi_set_d(m_data, d);
      return *this;
   }
   mpfi_float_imp& operator=(long double a)
   {
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));
      mpfr_set_ld(left_data(), a, GMP_RNDD);
      mpfr_set_ld(right_data(), a, GMP_RNDU);
      return *this;
   }
#ifdef BOOST_HAS_FLOAT128
   mpfi_float_imp& operator=(float128_type a)
   {
      BOOST_MP_FLOAT128_USING
      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));

      if (a == 0)
      {
         mpfi_set_si(m_data, 0);
         return *this;
      }

      if (a == 1)
      {
         mpfi_set_si(m_data, 1);
         return *this;
      }

      BOOST_MP_ASSERT(!BOOST_MP_ISINF(a));
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a));

      int        e;
      float128_type f, term;
      mpfi_set_ui(m_data, 0u);

      f = frexp(a, &e);

      constexpr const int shift = std::numeric_limits<int>::digits - 1;

      while (f)
      {
         // extract int sized bits from f:
         f = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpfi_mul_2exp(m_data, m_data, shift);
         if (term > 0)
            mpfi_add_ui(m_data, m_data, static_cast<unsigned>(term));
         else
            mpfi_sub_ui(m_data, m_data, static_cast<unsigned>(-term));
         f -= term;
      }
      if (e > 0)
         mpfi_mul_2exp(m_data, m_data, e);
      else if (e < 0)
         mpfi_div_2exp(m_data, m_data, -e);
      return *this;
   }
#endif
   mpfi_float_imp& operator=(const char* s)
   {
      using default_ops::eval_fpclassify;

      if (m_data[0].left._mpfr_d == nullptr)
         mpfi_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision()));

      if (s && (*s == '{'))
      {
         mpfr_float_backend<digits10> a, b;
         std::string                  part;
         const char*                  p = ++s;
         while (*p && (*p != ',') && (*p != '}'))
            ++p;
         part.assign(s, p);
         a = part.c_str();
         s = p;
         if (*p && (*p != '}'))
         {
            ++p;
            while (*p && (*p != ',') && (*p != '}'))
               ++p;
            part.assign(s + 1, p);
         }
         else
            part.erase();
         b = part.c_str();

         if (eval_fpclassify(a) == static_cast<int>(FP_NAN))
         {
            mpfi_set_fr(this->data(), a.data());
         }
         else if (eval_fpclassify(b) == static_cast<int>(FP_NAN))
         {
            mpfi_set_fr(this->data(), b.data());
         }
         else
         {
            if (a.compare(b) > 0)
            {
               BOOST_MP_THROW_EXCEPTION(std::runtime_error("Attempt to create interval with invalid range (start is greater than end)."));
            }
            mpfi_interv_fr(m_data, a.data(), b.data());
         }
      }
      else if (mpfi_set_str(m_data, s, 10) != 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse string \"") + s + std::string("\"as a valid floating point number.")));
      }
      return *this;
   }
   void swap(mpfi_float_imp& o) noexcept
   {
      mpfi_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);

      mpfr_float_backend<digits10> a, b;

      mpfi_get_left(a.data(), m_data);
      mpfi_get_right(b.data(), m_data);

      if (a.compare(b) == 0)
         return a.str(digits, f);

      return "{" + a.str(digits, f) + "," + b.str(digits, f) + "}";
   }
   ~mpfi_float_imp() noexcept
   {
      if (m_data[0].left._mpfr_d)
         mpfi_clear(m_data);
   }
   void negate() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      mpfi_neg(m_data, m_data);
   }
   int compare(const mpfi_float_imp& o) const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d && o.m_data[0].left._mpfr_d);
      if (mpfr_cmp(right_data(), o.left_data()) < 0)
         return -1;
      if (mpfr_cmp(left_data(), o.right_data()) > 0)
         return 1;
      if ((mpfr_cmp(left_data(), o.left_data()) == 0) && (mpfr_cmp(right_data(), o.right_data()) == 0))
         return 0;
      BOOST_MP_THROW_EXCEPTION(interval_error("Ambiguous comparison between two values."));
      return 0;
   }
   template <class V>
   int compare(V v) const noexcept
   {
      mpfi_float_imp d;
      d = v;
      return compare(d);
   }
   mpfi_t& data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return m_data;
   }
   const mpfi_t& data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return m_data;
   }
   mpfr_ptr left_data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return &(m_data[0].left);
   }
   mpfr_srcptr left_data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return &(m_data[0].left);
   }
   mpfr_ptr right_data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return &(m_data[0].right);
   }
   mpfr_srcptr right_data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0].left._mpfr_d);
      return &(m_data[0].right);
   }

 protected:
   mpfi_t           m_data;
   static boost::multiprecision::detail::precision_type& get_global_default_precision() noexcept
   {
      static boost::multiprecision::detail::precision_type val(BOOST_MULTIPRECISION_MPFI_DEFAULT_PRECISION);
      return val;
   }
   static unsigned& get_default_precision() noexcept
   {
      static BOOST_MP_THREAD_LOCAL unsigned val(get_global_default_precision());
      return val;
   }
#ifndef BOOST_MT_NO_ATOMIC_INT
   static std::atomic<variable_precision_options>& get_global_default_options() noexcept
#else
   static variable_precision_options& get_global_default_options() noexcept
#endif
   {
#ifndef BOOST_MT_NO_ATOMIC_INT
      static std::atomic<variable_precision_options> val{variable_precision_options::preserve_related_precision};
#else
      static variable_precision_optionss val{variable_precision_options::preserve_related_precision};
#endif
      return val;
   }
   static variable_precision_options& get_default_options() noexcept
   {
      static BOOST_MP_THREAD_LOCAL variable_precision_options val(get_global_default_options());
      return val;
   }
   static bool preserve_source_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
   static bool preserve_component_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_component_precision;
   }
   static bool preserve_related_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_related_precision;
   }
   static bool preserve_all_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_all_precision;
   }
};

} // namespace detail

template <unsigned digits10>
struct mpfi_float_backend : public detail::mpfi_float_imp<digits10>
{
   mpfi_float_backend() : detail::mpfi_float_imp<digits10>() {}
   mpfi_float_backend(const mpfi_float_backend& o) : detail::mpfi_float_imp<digits10>(o) {}
   // rvalue copy
   mpfi_float_backend(mpfi_float_backend&& o) : detail::mpfi_float_imp<digits10>(static_cast<detail::mpfi_float_imp<digits10>&&>(o))
   {}
   template <unsigned D>
   mpfi_float_backend(const mpfi_float_backend<D>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpfi_float_imp<digits10>()
   {
      mpfi_set(this->m_data, val.data());
   }
   template <unsigned D, mpfr_allocation_type AllocationType>
   mpfi_float_backend(const mpfr_float_backend<D, AllocationType>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpfi_float_imp<digits10>(val) {}

   template <unsigned D>
   explicit mpfi_float_backend(const mpfi_float_backend<D>& val, typename std::enable_if<!(D <= digits10)>::type* = nullptr)
       : detail::mpfi_float_imp<digits10>()
   {
      mpfi_set(this->m_data, val.data());
   }
   mpfi_float_backend(const mpfi_t val)
       : detail::mpfi_float_imp<digits10>()
   {
      mpfi_set(this->m_data, val);
   }
   mpfi_float_backend& operator=(const mpfi_float_backend& o)
   {
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = static_cast<detail::mpfi_float_imp<digits10> const&>(o);
      return *this;
   }
   template <unsigned D>
   mpfi_float_backend(const mpfr_float_backend<D>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpfi_float_imp<digits10>()
   {
      mpfi_set_fr(this->m_data, val.data());
   }
   template <unsigned D>
   mpfi_float_backend& operator=(const mpfr_float_backend<D>& val)
   {
      mpfi_set_fr(this->m_data, val.data());
      return *this;
   }
   template <unsigned D>
   explicit mpfi_float_backend(const mpfr_float_backend<D>& val, typename std::enable_if<!(D <= digits10)>::type* = nullptr)
       : detail::mpfi_float_imp<digits10>()
   {
      mpfi_set_fr(this->m_data, val.data());
   }
   // rvalue copy
   mpfi_float_backend& operator=(mpfi_float_backend&& o) noexcept
   {
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = static_cast<detail::mpfi_float_imp<digits10>&&>(o);
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<detail::mpfi_float_imp<digits10>, V>::value, mpfi_float_backend&>::type operator=(const V& v)
   {
      *static_cast<detail::mpfi_float_imp<digits10>*>(this) = v;
      return *this;
   }
   mpfi_float_backend& operator=(const mpfi_t val)
   {
      mpfi_set(this->m_data, val);
      return *this;
   }
   // We don't change our precision here, this is a fixed precision type:
   template <unsigned D>
   mpfi_float_backend& operator=(const mpfi_float_backend<D>& val)
   {
      mpfi_set(this->m_data, val.data());
      return *this;
   }
};

template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
void assign_components(mpfi_float_backend<D1>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b);

template <unsigned Digits10, class V>
typename std::enable_if<std::is_constructible<number<mpfr_float_backend<Digits10, allocate_dynamic>, et_on>, V>::value || std::is_convertible<V, const char*>::value>::type
assign_components(mpfi_float_backend<Digits10>& result, const V& a, const V& b);

template <>
struct mpfi_float_backend<0> : public detail::mpfi_float_imp<0>
{
   mpfi_float_backend() : detail::mpfi_float_imp<0>() {}
   mpfi_float_backend(const mpfi_t val)
       : detail::mpfi_float_imp<0>(mpfi_get_prec(val))
   {
      mpfi_set(this->m_data, val);
   }
   mpfi_float_backend(const mpfi_float_backend& o) : detail::mpfi_float_imp<0>(o) {}

   template <unsigned D, mpfr_allocation_type AllocationType>
   mpfi_float_backend(const mpfr_float_backend<D, AllocationType>& val)
       : detail::mpfi_float_imp<0>(val) {}

   // rvalue copy
   mpfi_float_backend(mpfi_float_backend&& o) noexcept : detail::mpfi_float_imp<0>(static_cast<detail::mpfi_float_imp<0>&&>(o))
   {}
   mpfi_float_backend(const mpfi_float_backend& o, unsigned digits10)
       : detail::mpfi_float_imp<0>(multiprecision::detail::digits10_2_2(digits10))
   {
      mpfi_set(this->m_data, o.data());
   }
   template <class V>
   mpfi_float_backend(const V& a, const V& b, unsigned digits10)
       : detail::mpfi_float_imp<0>(multiprecision::detail::digits10_2_2(digits10))
   {
      boost::multiprecision::detail::scoped_target_precision<mpfi_float_backend<0> > opts;
      assign_components(*this, a, b);
   }

   template <unsigned D>
   mpfi_float_backend(const mpfi_float_backend<D>& val)
       : detail::mpfi_float_imp<0>(mpfi_get_prec(val.data()))
   {
      mpfi_set(this->m_data, val.data());
   }
   mpfi_float_backend& operator=(const mpfi_float_backend& o) = default;
   // rvalue assign
   mpfi_float_backend& operator=(mpfi_float_backend&& o) noexcept = default;

   template <class V>
   mpfi_float_backend& operator=(const V& v)
   {
      constexpr unsigned d10 = std::is_floating_point<V>::value ?
         std::numeric_limits<V>::digits10 :
         std::numeric_limits<V>::digits10 ? 1 + std::numeric_limits<V>::digits10 :
         1 + boost::multiprecision::detail::digits2_2_10(std::numeric_limits<V>::digits);

      if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         BOOST_IF_CONSTEXPR(std::is_floating_point<V>::value)
         {
            if (std::numeric_limits<V>::digits > mpfi_get_prec(this->data()))
               mpfi_set_prec(this->data(), std::numeric_limits<V>::digits);
         }
         else
         {
            if (precision() < d10)
               this->precision(d10);
         }
      }

      *static_cast<detail::mpfi_float_imp<0>*>(this) = v;
      return *this;
   }
   mpfi_float_backend& operator=(const mpfi_t val)
   {
      mpfi_set_prec(this->m_data, mpfi_get_prec(val));
      mpfi_set(this->m_data, val);
      return *this;
   }
   template <unsigned D>
   mpfi_float_backend& operator=(const mpfi_float_backend<D>& val)
   {
      mpfi_set_prec(this->m_data, mpfi_get_prec(val.data()));
      mpfi_set(this->m_data, val.data());
      return *this;
   }
   static unsigned thread_default_precision() noexcept
   {
      return get_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      get_default_precision() = v;
   }
   static unsigned default_precision() noexcept
   {
      return get_global_default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      get_global_default_precision() = v;
   }
   unsigned precision() const noexcept
   {
      return multiprecision::detail::digits2_2_10(mpfi_get_prec(this->m_data));
   }
   void precision(unsigned digits10) noexcept
   {
      mpfi_float_backend t(*this, digits10);
      this->swap(t);
   }
   //
   // Variable precision options:
   //
   static variable_precision_options default_variable_precision_options() noexcept
   {
      return get_global_default_options();
   }
   static variable_precision_options thread_default_variable_precision_options() noexcept
   {
      return get_default_options();
   }
   static void default_variable_precision_options(variable_precision_options opts)
   {
      get_global_default_options() = opts;
   }
   static void thread_default_variable_precision_options(variable_precision_options opts)
   {
      get_default_options() = opts;
   }
};

template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const mpfi_float_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) == 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const mpfi_float_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) < 0;
}
template <unsigned digits10, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const mpfi_float_backend<digits10>& a, const T& b) noexcept
{
   return a.compare(b) > 0;
}

template <unsigned D1, unsigned D2>
inline void eval_add(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
{
   mpfi_add(result.data(), result.data(), o.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
{
   mpfi_sub(result.data(), result.data(), o.data());
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
{
   if ((void*)&result == (void*)&o)
      mpfi_sqr(result.data(), o.data());
   else
      mpfi_mul(result.data(), result.data(), o.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpfi_float_backend<D1>& result, const mpfi_float_backend<D2>& o)
{
   mpfi_div(result.data(), result.data(), o.data());
}
template <unsigned digits10>
inline void eval_add(mpfi_float_backend<digits10>& result, unsigned long i)
{
   mpfi_add_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_subtract(mpfi_float_backend<digits10>& result, unsigned long i)
{
   mpfi_sub_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_multiply(mpfi_float_backend<digits10>& result, unsigned long i)
{
   mpfi_mul_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_divide(mpfi_float_backend<digits10>& result, unsigned long i)
{
   mpfi_div_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_add(mpfi_float_backend<digits10>& result, long i)
{
   if (i > 0)
      mpfi_add_ui(result.data(), result.data(), i);
   else
      mpfi_sub_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
}
template <unsigned digits10>
inline void eval_subtract(mpfi_float_backend<digits10>& result, long i)
{
   if (i > 0)
      mpfi_sub_ui(result.data(), result.data(), i);
   else
      mpfi_add_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
}
template <unsigned digits10>
inline void eval_multiply(mpfi_float_backend<digits10>& result, long i)
{
   mpfi_mul_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
   if (i < 0)
      mpfi_neg(result.data(), result.data());
}
template <unsigned digits10>
inline void eval_divide(mpfi_float_backend<digits10>& result, long i)
{
   mpfi_div_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
   if (i < 0)
      mpfi_neg(result.data(), result.data());
}
//
// Specialised 3 arg versions of the basic operators:
//
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
{
   mpfi_add(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
{
   mpfi_add_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
{
   if (y < 0)
      mpfi_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
   else
      mpfi_add_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
{
   mpfi_add_ui(a.data(), y.data(), x);
}
template <unsigned D1, unsigned D2>
inline void eval_add(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
{
   if (x < 0)
   {
      mpfi_ui_sub(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data());
      mpfi_neg(a.data(), a.data());
   }
   else
      mpfi_add_ui(a.data(), y.data(), x);
}
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
{
   mpfi_sub(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
{
   mpfi_sub_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
{
   if (y < 0)
      mpfi_add_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
   else
      mpfi_sub_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
{
   mpfi_ui_sub(a.data(), x, y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_subtract(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
{
   if (x < 0)
   {
      mpfi_add_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x));
      mpfi_neg(a.data(), a.data());
   }
   else
      mpfi_ui_sub(a.data(), x, y.data());
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
{
   if ((void*)&x == (void*)&y)
      mpfi_sqr(a.data(), x.data());
   else
      mpfi_mul(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
{
   mpfi_mul_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
{
   if (y < 0)
   {
      mpfi_mul_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
      a.negate();
   }
   else
      mpfi_mul_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
{
   mpfi_mul_ui(a.data(), y.data(), x);
}
template <unsigned D1, unsigned D2>
inline void eval_multiply(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
{
   if (x < 0)
   {
      mpfi_mul_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x));
      mpfi_neg(a.data(), a.data());
   }
   else
      mpfi_mul_ui(a.data(), y.data(), x);
}

template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, const mpfi_float_backend<D3>& y)
{
   mpfi_div(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, unsigned long y)
{
   mpfi_div_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpfi_float_backend<D1>& a, const mpfi_float_backend<D2>& x, long y)
{
   if (y < 0)
   {
      mpfi_div_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
      a.negate();
   }
   else
      mpfi_div_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpfi_float_backend<D1>& a, unsigned long x, const mpfi_float_backend<D2>& y)
{
   mpfi_ui_div(a.data(), x, y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(mpfi_float_backend<D1>& a, long x, const mpfi_float_backend<D2>& y)
{
   if (x < 0)
   {
      mpfi_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data());
      mpfi_neg(a.data(), a.data());
   }
   else
      mpfi_ui_div(a.data(), x, y.data());
}

template <unsigned digits10>
inline bool eval_is_zero(const mpfi_float_backend<digits10>& val) noexcept
{
   return 0 != mpfi_is_zero(val.data());
}
template <unsigned digits10>
inline int eval_get_sign(const mpfi_float_backend<digits10>& val)
{
   return detail::mpfi_sgn(val.data());
}

template <unsigned digits10>
inline void eval_convert_to(unsigned long* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(long* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
#ifdef _MPFR_H_HAVE_INTMAX_T
template <unsigned digits10>
inline void eval_convert_to(unsigned long long* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(long long* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
#endif
#ifdef BOOST_HAS_INT128
template <unsigned digits10>
inline void eval_convert_to(uint128_type* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
template <unsigned digits10>
inline void eval_convert_to(int128_type* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
#endif
template <unsigned digits10>
inline void eval_convert_to(double* result, const mpfi_float_backend<digits10>& val) noexcept
{
   *result = mpfi_get_d(val.data());
}
template <unsigned digits10>
inline void eval_convert_to(long double* result, const mpfi_float_backend<digits10>& val) noexcept
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
#ifdef BOOST_HAS_FLOAT128
template <unsigned digits10>
inline void eval_convert_to(float128_type* result, const mpfi_float_backend<digits10>& val)
{
   mpfr_float_backend<digits10> t;
   mpfi_mid(t.data(), val.data());
   eval_convert_to(result, t);
}
#endif
template <mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpfi_float_backend<0>& result, const mpfr_float_backend<0, AllocationType>& a, const mpfr_float_backend<0, AllocationType>& b)
{
   if (result.thread_default_variable_precision_options() >= variable_precision_options::preserve_component_precision)
   {
      unsigned long prec = (std::max)(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
      mpfi_set_prec(result.data(), prec);
   }
}
template <unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpfi_float_backend<0>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b)
{
   if (result.thread_default_variable_precision_options() >= variable_precision_options::preserve_related_precision)
   {
      unsigned long prec = (std::max)(mpfr_get_prec(a.data()), mpfr_get_prec(b.data()));
      mpfi_set_prec(result.data(), prec);
   }
}
template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components_set_precision(mpfi_float_backend<D1>&, const mpfr_float_backend<D2, AllocationType>&, const mpfr_float_backend<D2, AllocationType>&)
{
}


template <unsigned D1, unsigned D2, mpfr_allocation_type AllocationType>
inline void assign_components(mpfi_float_backend<D1>& result, const mpfr_float_backend<D2, AllocationType>& a, const mpfr_float_backend<D2, AllocationType>& b)
{
   //
   // This is called from class number's constructors, so if we have variable
   // precision, then copy the precision of the source variables.
   //
   assign_components_set_precision(result, a, b);

   using default_ops::eval_fpclassify;
   if (eval_fpclassify(a) == static_cast<int>(FP_NAN))
   {
      mpfi_set_fr(result.data(), a.data());
   }
   else if (eval_fpclassify(b) == static_cast<int>(FP_NAN))
   {
      mpfi_set_fr(result.data(), b.data());
   }
   else
   {
      if (a.compare(b) > 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Attempt to create interval with invalid range (start is greater than end)."));
      }
      mpfi_interv_fr(result.data(), a.data(), b.data());
   }
}

template <unsigned Digits10, class V>
inline typename std::enable_if<std::is_constructible<number<mpfr_float_backend<Digits10, allocate_dynamic>, et_on>, V>::value || std::is_convertible<V, const char*>::value>::type
assign_components(mpfi_float_backend<Digits10>& result, const V& a, const V& b)
{
   number<mpfr_float_backend<Digits10, allocate_dynamic>, et_on> x(a), y(b);
   assign_components(result, x.backend(), y.backend());
}

//
// Native non-member operations:
//
template <unsigned Digits10>
inline void eval_sqrt(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
{
   mpfi_sqrt(result.data(), val.data());
}

template <unsigned Digits10>
inline void eval_abs(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
{
   mpfi_abs(result.data(), val.data());
}

template <unsigned Digits10>
inline void eval_fabs(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
{
   mpfi_abs(result.data(), val.data());
}
template <unsigned Digits10>
inline void eval_ceil(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
{
   mpfr_float_backend<Digits10> a, b;
   mpfr_set(a.data(), val.left_data(), GMP_RNDN);
   mpfr_set(b.data(), val.right_data(), GMP_RNDN);
   eval_ceil(a, a);
   eval_ceil(b, b);
   if (a.compare(b) != 0)
   {
      BOOST_MP_THROW_EXCEPTION(interval_error("Attempt to take the ceil of a value that straddles an integer boundary."));
   }
   mpfi_set_fr(result.data(), a.data());
}
template <unsigned Digits10>
inline void eval_floor(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val)
{
   mpfr_float_backend<Digits10> a, b;
   mpfr_set(a.data(), val.left_data(), GMP_RNDN);
   mpfr_set(b.data(), val.right_data(), GMP_RNDN);
   eval_floor(a, a);
   eval_floor(b, b);
   if (a.compare(b) != 0)
   {
      BOOST_MP_THROW_EXCEPTION(interval_error("Attempt to take the floor of a value that straddles an integer boundary."));
   }
   mpfi_set_fr(result.data(), a.data());
}
template <unsigned Digits10>
inline void eval_ldexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, long e)
{
   if (e > 0)
      mpfi_mul_2exp(result.data(), val.data(), e);
   else if (e < 0)
      mpfi_div_2exp(result.data(), val.data(), -e);
   else
      result = val;
}
template <unsigned Digits10>
inline void eval_frexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, int* e)
{
   mpfr_float_backend<Digits10> t, rt;
   mpfi_mid(t.data(), val.data());
   eval_frexp(rt, t, e);
   eval_ldexp(result, val, -*e);
}
template <unsigned Digits10>
inline void eval_frexp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& val, long* e)
{
   mpfr_float_backend<Digits10> t, rt;
   mpfi_mid(t.data(), val.data());
   eval_frexp(rt, t, e);
   eval_ldexp(result, val, -*e);
}

template <unsigned Digits10>
inline int eval_fpclassify(const mpfi_float_backend<Digits10>& val) noexcept
{
   return mpfi_inf_p(val.data()) ? FP_INFINITE : mpfi_nan_p(val.data()) ? FP_NAN : mpfi_is_zero(val.data()) ? FP_ZERO : FP_NORMAL;
}

template <unsigned Digits10>
inline void eval_pow(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& b, const mpfi_float_backend<Digits10>& e)
{
   using ui_type = typename boost::multiprecision::detail::canonical<unsigned, mpfi_float_backend<Digits10> >::type;
   using default_ops::eval_get_sign;
   int s = eval_get_sign(b);
   if (s == 0)
   {
      if (eval_get_sign(e) == 0)
      {
         result = ui_type(1);
      }
      else
      {
         result = ui_type(0);
      }
      return;
   }
   if (s < 0)
   {
      if (eval_get_sign(e) < 0)
      {
         mpfi_float_backend<Digits10> t1, t2;
         t1 = e;
         t1.negate();
         eval_pow(t2, b, t1);
         t1 = ui_type(1);
         eval_divide(result, t1, t2);
         return;
      }
      typename boost::multiprecision::detail::canonical<std::uintmax_t, mpfi_float_backend<Digits10> >::type an;
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         using default_ops::eval_convert_to;
         eval_convert_to(&an, e);
         if (e.compare(an) == 0)
         {
            mpfi_float_backend<Digits10> pb(b);
            pb.negate();
            eval_pow(result, pb, e);
            if (an & 1u)
               result.negate();
            return;
         }
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const std::exception&)
      {
         // conversion failed, just fall through, value is not an integer.
      }
#endif
      result = std::numeric_limits<number<mpfi_float_backend<Digits10>, et_on> >::quiet_NaN().backend();
      return;
   }
   mpfi_log(result.data(), b.data());
   mpfi_mul(result.data(), result.data(), e.data());
   mpfi_exp(result.data(), result.data());
}

template <unsigned Digits10>
inline void eval_exp(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_exp(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_exp2(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_exp2(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_log(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_log(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_log10(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_log10(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_sin(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_sin(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_cos(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_cos(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_tan(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_tan(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_asin(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_asin(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_acos(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_acos(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_atan(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_atan(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_atan2(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg1, const mpfi_float_backend<Digits10>& arg2)
{
   mpfi_atan2(result.data(), arg1.data(), arg2.data());
}

template <unsigned Digits10>
inline void eval_sinh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_sinh(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_cosh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_cosh(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_tanh(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_tanh(result.data(), arg.data());
}

template <unsigned Digits10>
inline void eval_log2(mpfi_float_backend<Digits10>& result, const mpfi_float_backend<Digits10>& arg)
{
   mpfi_log2(result.data(), arg.data());
}

template <unsigned Digits10>
inline std::size_t hash_value(const mpfi_float_backend<Digits10>& val)
{
   std::size_t result = 0;
   std::size_t len    = val.left_data()[0]._mpfr_prec / mp_bits_per_limb;
   if (val.left_data()[0]._mpfr_prec % mp_bits_per_limb)
      ++len;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.left_data()[0]._mpfr_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.left_data()[0]._mpfr_exp, val.left_data()[0]._mpfr_sign);

   len = val.right_data()[0]._mpfr_prec / mp_bits_per_limb;
   if (val.right_data()[0]._mpfr_prec % mp_bits_per_limb)
      ++len;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.right_data()[0]._mpfr_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.right_data()[0]._mpfr_exp, val.right_data()[0]._mpfr_sign);
   return result;
}

template <class To, unsigned D>
void generic_interconvert(To& to, const mpfi_float_backend<D>& from, const std::integral_constant<int, number_kind_integer>& to_type, const std::integral_constant<int, number_kind_floating_point>& from_type)
{
   using boost::multiprecision::detail::generic_interconvert;
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<D>>> scoped(from);
   mpfr_float_backend<D> t;
   mpfi_mid(t.data(), from.data());
   generic_interconvert(to, t, to_type, from_type);
}

template <class To, unsigned D>
void generic_interconvert(To& to, const mpfi_float_backend<D>& from, const std::integral_constant<int, number_kind_rational>& to_type, const std::integral_constant<int, number_kind_floating_point>& from_type)
{
   using boost::multiprecision::detail::generic_interconvert;
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<D>>> scoped(from);
   mpfr_float_backend<D> t;
   mpfi_mid(t.data(), from.data());
   generic_interconvert(to, t, to_type, from_type);
}

template <class To, unsigned D>
void generic_interconvert(To& to, const mpfi_float_backend<D>& from, const std::integral_constant<int, number_kind_floating_point>& to_type, const std::integral_constant<int, number_kind_floating_point>& from_type)
{
   using boost::multiprecision::detail::generic_interconvert;
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<D>>> scoped(from);
   mpfr_float_backend<D> t;
   mpfi_mid(t.data(), from.data());
   generic_interconvert(to, t, to_type, from_type);
}

} // namespace backends

template <>
struct number_category<detail::canonical<mpfi_t, backends::mpfi_float_backend<0> >::type> : public std::integral_constant<int, number_kind_floating_point>
{};
template <unsigned Digits10>
struct is_interval_number<backends::mpfi_float_backend<Digits10> > : public std::integral_constant<bool, true>
{};

using boost::multiprecision::backends::mpfi_float_backend;

using mpfi_float_50 = number<mpfi_float_backend<50> >  ;
using mpfi_float_100 = number<mpfi_float_backend<100> > ;
using mpfi_float_500 = number<mpfi_float_backend<500> > ;
using mpfi_float_1000 = number<mpfi_float_backend<1000> >;
using mpfi_float = number<mpfi_float_backend<0> >   ;

//
// Special interval specific functions:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> lower(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<Digits10>, ExpressionTemplates> > precision_guard(val);
   number<mpfr_float_backend<Digits10> >                                                                               result;
   mpfr_set(result.backend().data(), val.backend().left_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> upper(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<Digits10>, ExpressionTemplates> > precision_guard(val);
   number<mpfr_float_backend<Digits10> >                                                                               result;
   mpfr_set(result.backend().data(), val.backend().right_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> median(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<Digits10>, ExpressionTemplates> > precision_guard(val);
   number<mpfr_float_backend<Digits10> >                                                                               result;
   mpfi_mid(result.backend().data(), val.backend().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfr_float_backend<Digits10>, ExpressionTemplates> width(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_precision_options<number<mpfr_float_backend<Digits10>, ExpressionTemplates> > precision_guard(val);
   number<mpfr_float_backend<Digits10> >                                                                               result;
   mpfi_diam_abs(result.backend().data(), val.backend().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfi_float_backend<Digits10>, ExpressionTemplates> intersect(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(a, b);
   number<mpfi_float_backend<Digits10>, ExpressionTemplates>                                                           result;
   mpfi_intersect(result.backend().data(), a.backend().data(), b.backend().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<mpfi_float_backend<Digits10>, ExpressionTemplates> hull(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(a, b);
   number<mpfi_float_backend<Digits10>, ExpressionTemplates>                                                           result;
   mpfi_union(result.backend().data(), a.backend().data(), b.backend().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool overlap(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b)
{
   return (lower(a) <= lower(b) && lower(b) <= upper(a)) ||
          (lower(b) <= lower(a) && lower(a) <= upper(b));
}

template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
inline bool in(const number<mpfr_float_backend<Digits10>, ExpressionTemplates1>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates2>& b)
{
   return mpfi_is_inside_fr(a.backend().data(), b.backend().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool zero_in(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a)
{
   return mpfi_has_zero(a.backend().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b)
{
   return mpfi_is_inside(a.backend().data(), b.backend().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool proper_subset(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a, const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& b)
{
   return mpfi_is_strictly_inside(a.backend().data(), b.backend().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool empty(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a)
{
   return mpfi_is_empty(a.backend().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool singleton(const number<mpfi_float_backend<Digits10>, ExpressionTemplates>& a)
{
   return mpfr_cmp(a.backend().left_data(), a.backend().right_data()) == 0;
}

//
// Again with debug_adaptor:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> lower(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<debug_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfr_set(result.backend().value().data(), val.backend().value().left_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> upper(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<debug_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfr_set(result.backend().value().data(), val.backend().value().right_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> median(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<debug_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfi_mid(result.backend().value().data(), val.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> width(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<debug_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfi_diam_abs(result.backend().value().data(), val.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> intersect(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(a, b);
   number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>                                                           result;
   mpfi_intersect(result.backend().value().data(), a.backend().value().data(), b.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> hull(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(a, b);
   number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>                                                           result;
   mpfi_union(result.backend().value().data(), a.backend().value().data(), b.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool overlap(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return (lower(a) <= lower(b) && lower(b) <= upper(a)) ||
          (lower(b) <= lower(a) && lower(a) <= upper(b));
}

template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
inline bool in(const number<debug_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates1>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates2>& b)
{
   return mpfi_is_inside_fr(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool zero_in(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfi_has_zero(a.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool subset(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return mpfi_is_inside(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool proper_subset(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return mpfi_is_strictly_inside(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool empty(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfi_is_empty(a.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool singleton(const number<debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfr_cmp(a.backend().value().left_data(), a.backend().value().right_data()) == 0;
}
//
// Again with logged_adaptor:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> lower(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<logged_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfr_set(result.backend().value().data(), val.backend().value().left_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> upper(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<logged_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfr_set(result.backend().value().data(), val.backend().value().right_data(), GMP_RNDN);
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> median(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<logged_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfi_mid(result.backend().value().data(), val.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> width(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& val)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(val);
   number<logged_adaptor<mpfr_float_backend<Digits10> > >                                                                               result;
   mpfi_diam_abs(result.backend().value().data(), val.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> intersect(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(a, b);
   number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>                                                           result;
   mpfi_intersect(result.backend().value().data(), a.backend().value().data(), b.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> hull(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   boost::multiprecision::detail::scoped_default_precision<number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(a, b);
   number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>                                                           result;
   mpfi_union(result.backend().value().data(), a.backend().value().data(), b.backend().value().data());
   return result;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool overlap(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return (lower(a) <= lower(b) && lower(b) <= upper(a)) ||
          (lower(b) <= lower(a) && lower(a) <= upper(b));
}

template <unsigned Digits10, expression_template_option ExpressionTemplates1, expression_template_option ExpressionTemplates2>
inline bool in(const number<logged_adaptor<mpfr_float_backend<Digits10> >, ExpressionTemplates1>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates2>& b)
{
   return mpfi_is_inside_fr(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool zero_in(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfi_has_zero(a.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool subset(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return mpfi_is_inside(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool proper_subset(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a, const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& b)
{
   return mpfi_is_strictly_inside(a.backend().value().data(), b.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool empty(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfi_is_empty(a.backend().value().data()) != 0;
}

template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline bool singleton(const number<logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates>& a)
{
   return mpfr_cmp(a.backend().value().left_data(), a.backend().value().right_data()) == 0;
}
//
// component_type specialization:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
struct component_type<number<mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using type = number<mpfr_float_backend<Digits10>, ExpressionTemplates>;
};

//
// Overloaded special functions which call native mpfr routines:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_asinh(result.backend().data(), arg.backend().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_acosh(result.backend().data(), arg.backend().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_atanh(result.backend().data(), arg.backend().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_cbrt(result.backend().data(), arg.backend().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_expm1(result.backend().data(), arg.backend().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<mpfi_float_backend<Digits10>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> result;
   mpfi_log1p(result.backend().data(), arg.backend().data());
   return result;
}

//
// And again with debug_adaptor:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_asinh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_acosh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_atanh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_cbrt(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_expm1(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::debug_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_log1p(result.backend().value().data(), arg.backend().value().data());
   return result;
}

//
// And again with logged_adaptor:
//
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_asinh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_acosh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_atanh(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_cbrt(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_expm1(result.backend().value().data(), arg.backend().value().data());
   return result;
}
template <unsigned Digits10, expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<mpfi_float_backend<Digits10> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> result;
   mpfi_log1p(result.backend().value().data(), arg.backend().value().data());
   return result;
}

} // namespace multiprecision

namespace math {

namespace tools {

inline void set_output_precision(const boost::multiprecision::mpfi_float& val, std::ostream& os)
{
   os << std::setprecision(val.precision());
}

template <>
inline int digits<boost::multiprecision::mpfi_float>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(boost::multiprecision::mpfi_float::thread_default_precision());
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(boost::multiprecision::mpfi_float::thread_default_precision());
}

template <>
inline boost::multiprecision::mpfi_float
max_value<boost::multiprecision::mpfi_float>()
{
   boost::multiprecision::mpfi_float result(0.5);
   mpfi_mul_2exp(result.backend().data(), result.backend().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::mpfi_float
min_value<boost::multiprecision::mpfi_float>()
{
   boost::multiprecision::mpfi_float result(0.5);
   mpfi_div_2exp(result.backend().data(), result.backend().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> result(0.5);
   mpfi_mul_2exp(result.backend().data(), result.backend().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> result(0.5);
   mpfi_div_2exp(result.backend().data(), result.backend().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

// mpfi gets used with logged_adaptor fairly often, so specialize for that use case as well:
using logged_type1 = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float::backend_type>, boost::multiprecision::et_on> ;
using logged_type2 = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float::backend_type>, boost::multiprecision::et_off>;

template <>
inline int digits<logged_type1>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(logged_type1::thread_default_precision());
}
template <>
inline int digits<logged_type2>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(logged_type1::thread_default_precision());
}

template <>
inline logged_type1
max_value<logged_type1>()
{
   logged_type1 result(0.5);
   mpfi_mul_2exp(result.backend().value().data(), result.backend().value().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline logged_type1
min_value<logged_type1>()
{
   logged_type1 result(0.5);
   mpfi_div_2exp(result.backend().value().data(), result.backend().value().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline logged_type2
max_value<logged_type2>()
{
   logged_type2 result(0.5);
   mpfi_mul_2exp(result.backend().value().data(), result.backend().value().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}

template <>
inline logged_type2
min_value<logged_type2>()
{
   logged_type2 result(0.5);
   mpfi_div_2exp(result.backend().value().data(), result.backend().value().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   return result;
}
// mpfi gets used with debug_adaptor fairly often, so specialize for that use case as well:
using debug_type1 = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float::backend_type>, boost::multiprecision::et_on> ;
using debug_type2 = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float::backend_type>, boost::multiprecision::et_off>;

template <>
inline int digits<debug_type1>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(debug_type1::default_precision());
}
template <>
inline int digits<debug_type2>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return multiprecision::detail::digits10_2_2(debug_type1::default_precision());
}

template <>
inline debug_type1
max_value<debug_type1>()
{
   debug_type1 result(0.5);
   mpfi_mul_2exp(result.backend().value().data(), result.backend().value().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   result.backend().update_view();
   return result;
}

template <>
inline debug_type1
min_value<debug_type1>()
{
   debug_type1 result(0.5);
   mpfi_div_2exp(result.backend().value().data(), result.backend().value().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   result.backend().update_view();
   return result;
}

template <>
inline debug_type2
max_value<debug_type2>()
{
   debug_type2 result(0.5);
   mpfi_mul_2exp(result.backend().value().data(), result.backend().value().data(), mpfr_get_emax());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   result.backend().update_view();
   return result;
}

template <>
inline debug_type2
min_value<debug_type2>()
{
   debug_type2 result(0.5);
   mpfi_div_2exp(result.backend().value().data(), result.backend().value().data(), -mpfr_get_emin());
   //BOOST_MP_ASSERT(mpfi_number_p(result.backend().data()));
   result.backend().update_view();
   return result;
}

} // namespace tools

namespace constants { namespace detail {

template <class T>
struct constant_pi;
template <class T>
struct constant_ln_two;
template <class T>
struct constant_euler;
template <class T>
struct constant_catalan;

template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_pi(result.backend().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_log2(result.backend().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_euler(result.backend().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_catalan(result.backend().data());
      return result;
   }
};
//
// And again with debug_adaptor:
//
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_pi(result.backend().value().data());
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_log2(result.backend().value().data());
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_euler(result.backend().value().data());
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_catalan(result.backend().value().data());
      result.backend().update_view();
      return result;
   }
};
//
// And again with logged_adaptor:
//
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_pi(result.backend().value().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_log2(result.backend().value().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_euler(result.backend().value().data());
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfi_const_catalan(result.backend().value().data());
      return result;
   }
};

}} // namespace constants::detail

} // namespace math
} // namespace boost

namespace std {

//
// numeric_limits [partial] specializations for the types declared in this header:
//
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates>;
   static number_type get_min()
   {
      number_type value(0.5);
      mpfi_div_2exp(value.backend().data(), value.backend().data(), -mpfr_get_emin());
      return value;
   }
   static number_type get_max()
   {
      number_type value(0.5);
      mpfi_mul_2exp(value.backend().data(), value.backend().data(), mpfr_get_emax());
      return value;
   }
   static number_type get_epsilon()
   {
      number_type value(1);
      mpfi_div_2exp(value.backend().data(), value.backend().data(), std::numeric_limits<number_type>::digits - 1);
      return value;
   }
   static number_type get_infinity()
   {
      number_type value;
      boost::multiprecision::mpfr_float_backend<Digits10> t;
      mpfr_set_inf(t.data(), 1);
      mpfi_set_fr(value.backend().data(), t.data());
      return value;
   }
   static number_type get_quiet_NaN()
   {
      number_type value;
      boost::multiprecision::mpfr_float_backend<Digits10> t;
      mpfr_set_nan(t.data());
      mpfi_set_fr(value.backend().data(), t.data());
      return value;
   }

 public:
   static constexpr bool is_specialized = true;
   static number_type(min)()
   {
      static number_type value{get_min()};
      return value;
   }
   static number_type(max)()
   {
      static number_type value{get_max()};
      return value;
   }
   static constexpr number_type lowest()
   {
      return -(max)();
   }
   static constexpr int digits   = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301 ? 2 : 1));
   static constexpr int digits10 = Digits10;
   // Is this really correct???
   static constexpr int  max_digits10 = boost::multiprecision::detail::calc_max_digits10<digits>::value;
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static number_type          epsilon()
   {
      static number_type value{get_epsilon()};
      return value;
   }
   // What value should this be????
   static number_type round_error()
   {
      return 0.5;
   }
   static constexpr long min_exponent                  = MPFR_EMIN_DEFAULT;
   static constexpr long min_exponent10                = (MPFR_EMIN_DEFAULT / 1000) * 301L;
   static constexpr long max_exponent                  = MPFR_EMAX_DEFAULT;
   static constexpr long max_exponent10                = (MPFR_EMAX_DEFAULT / 1000) * 301L;
   static constexpr bool has_infinity                  = true;
   static constexpr bool has_quiet_NaN                 = true;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_absent;
   static constexpr bool               has_denorm_loss = false;
   static number_type                        infinity()
   {
      static number_type value{get_infinity()};
      return value;
   }
   static number_type quiet_NaN()
   {
      static number_type value{get_quiet_NaN()};
      return value;
   }
   static constexpr number_type signaling_NaN()
   {
      return number_type(0);
   }
   static constexpr number_type denorm_min() { return number_type(0); }
   static constexpr bool        is_iec559         = false;
   static constexpr bool        is_bounded        = true;
   static constexpr bool        is_modulo         = false;
   static constexpr bool        traps             = true;
   static constexpr bool        tinyness_before   = false;
   static constexpr float_round_style round_style = round_to_nearest;
};

template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::digits;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::digits10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_signed;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_integer;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_exact;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::radix;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_quiet_NaN;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_signaling_NaN;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_denorm;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::has_denorm_loss;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::traps;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<Digits10>, ExpressionTemplates> >::round_style;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = false;
   static number_type(min)() { return number_type(0); }
   static number_type(max)() { return number_type(0); }
   static number_type          lowest() { return number_type(0); }
   static constexpr int  digits       = 0;
   static constexpr int  digits10     = 0;
   static constexpr int  max_digits10 = 0;
   static constexpr bool is_signed    = false;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 0;
   static number_type          epsilon() { return number_type(0); }
   static number_type          round_error() { return number_type(0); }
   static constexpr int  min_exponent                  = 0;
   static constexpr int  min_exponent10                = 0;
   static constexpr int  max_exponent                  = 0;
   static constexpr int  max_exponent10                = 0;
   static constexpr bool has_infinity                  = false;
   static constexpr bool has_quiet_NaN                 = false;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_absent;
   static constexpr bool               has_denorm_loss = false;
   static number_type                        infinity() { return number_type(0); }
   static number_type                        quiet_NaN() { return number_type(0); }
   static number_type                        signaling_NaN() { return number_type(0); }
   static number_type                        denorm_min() { return number_type(0); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style round_style      = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, ExpressionTemplates> >::round_style;

} // namespace std
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/mpfr.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_MPFR_HPP
#define BOOST_MP_MPFR_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/detail/digits.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/atomic.hpp>
#include <boost/multiprecision/traits/max_digits10.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <mpfr.h>
#include <cmath>
#include <cstdint>
#include <algorithm>
#include <utility>
#include <type_traits>
#include <atomic>

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/gamma.hpp>
#endif

#ifndef BOOST_MULTIPRECISION_MPFR_DEFAULT_PRECISION
#define BOOST_MULTIPRECISION_MPFR_DEFAULT_PRECISION 20
#endif

namespace boost {
namespace multiprecision {

enum mpfr_allocation_type
{
   allocate_stack,
   allocate_dynamic
};

namespace backends {

template <unsigned digits10, mpfr_allocation_type AllocationType = allocate_dynamic>
struct mpfr_float_backend;

template <>
struct mpfr_float_backend<0, allocate_stack>;

} // namespace backends

template <unsigned digits10, mpfr_allocation_type AllocationType>
struct number_category<backends::mpfr_float_backend<digits10, AllocationType> > : public std::integral_constant<int, number_kind_floating_point>
{};

namespace backends {

namespace detail {

template <bool b>
struct mpfr_cleanup
{
   //
   // There are 2 seperate cleanup objects here, one calls
   // mpfr_free_cache on destruction to perform global cleanup
   // the other is declared thread_local and calls
   // mpfr_free_cache2(MPFR_FREE_LOCAL_CACHE) to free thread local data.
   //
   struct initializer
   {
      initializer() {}
      ~initializer() { mpfr_free_cache(); }
      void force_instantiate() const {}
   };
#if MPFR_VERSION_MAJOR >= 4
   struct thread_initializer
   {
      thread_initializer() {}
      ~thread_initializer() { mpfr_free_cache2(MPFR_FREE_LOCAL_CACHE); }
      void force_instantiate() const {}
   };
#endif
   static const initializer init;
   static void              force_instantiate()
   {
#if MPFR_VERSION_MAJOR >= 4
      static const BOOST_MP_THREAD_LOCAL thread_initializer thread_init;
      thread_init.force_instantiate();
#endif
      init.force_instantiate();
   }
};

template <bool b>
typename mpfr_cleanup<b>::initializer const mpfr_cleanup<b>::init;

inline void mpfr_copy_precision(mpfr_t dest, const mpfr_t src)
{
   mpfr_prec_t p_dest = mpfr_get_prec(dest);
   mpfr_prec_t p_src  = mpfr_get_prec(src);
   if (p_dest != p_src)
      mpfr_set_prec(dest, p_src);
}
inline void mpfr_copy_precision(mpfr_t dest, const mpfr_t src1, const mpfr_t src2)
{
   mpfr_prec_t p_dest = mpfr_get_prec(dest);
   mpfr_prec_t p_src1 = mpfr_get_prec(src1);
   mpfr_prec_t p_src2 = mpfr_get_prec(src2);
   if (p_src2 > p_src1)
      p_src1 = p_src2;
   if (p_dest != p_src1)
      mpfr_set_prec(dest, p_src1);
}

template <unsigned digits10, mpfr_allocation_type AllocationType>
struct mpfr_float_imp;

template <unsigned digits10>
struct mpfr_float_imp<digits10, allocate_dynamic>
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;
   using exponent_type = long                          ;

   mpfr_float_imp()
   {
      mpfr_init2(m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision()))));
      mpfr_set_ui(m_data, 0u, GMP_RNDN);
   }
   mpfr_float_imp(unsigned digits2)
   {
      mpfr_init2(m_data, digits2);
      mpfr_set_ui(m_data, 0u, GMP_RNDN);
   }

   mpfr_float_imp(const mpfr_float_imp& o)
   {
      mpfr_init2(m_data, preserve_source_precision() ? mpfr_get_prec(o.data()) : static_cast<mpfr_prec_t>(boost::multiprecision::detail::digits10_2_2(get_default_precision())));
      if (o.m_data[0]._mpfr_d)
         mpfr_set(m_data, o.m_data, GMP_RNDN);
   }
   // rvalue copy
   mpfr_float_imp(mpfr_float_imp&& o) noexcept
   {
      mpfr_prec_t binary_default_precision = static_cast<mpfr_prec_t>(boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpfr_get_prec(o.data()) == binary_default_precision))
      {
         m_data[0] = o.m_data[0];
         o.m_data[0]._mpfr_d = nullptr;
      }
      else
      {
         // NOTE: C allocation interface must not throw:
         mpfr_init2(m_data, binary_default_precision);
         if (o.m_data[0]._mpfr_d)
            mpfr_set(m_data, o.m_data, GMP_RNDN);
      }
   }
   mpfr_float_imp& operator=(const mpfr_float_imp& o)
   {
      if ((o.m_data[0]._mpfr_d) && (this != &o))
      {
         if (m_data[0]._mpfr_d == nullptr)
         {
            mpfr_init2(m_data, preserve_source_precision() ? static_cast<mpfr_prec_t>(mpfr_get_prec(o.m_data)) : static_cast<mpfr_prec_t>(boost::multiprecision::detail::digits10_2_2(get_default_precision())));
         }
         else if (preserve_source_precision() && (mpfr_get_prec(o.data()) != mpfr_get_prec(data())))
         {
            mpfr_set_prec(m_data, mpfr_get_prec(o.m_data));
         }
         mpfr_set(m_data, o.m_data, GMP_RNDN);
      }
      return *this;
   }
   // rvalue assign
   mpfr_float_imp& operator=(mpfr_float_imp&& o) noexcept
   {
      if ((this->get_default_options() != variable_precision_options::preserve_target_precision) || (mpfr_get_prec(o.data()) == mpfr_get_prec(data())))
         mpfr_swap(m_data, o.m_data);
      else
         *this = static_cast<const mpfr_float_imp&>(o);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#ifdef _MPFR_H_HAVE_INTMAX_T
   mpfr_float_imp& operator=(unsigned long long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      mpfr_set_uj(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      mpfr_set_sj(m_data, i, GMP_RNDN);
      return *this;
   }
#else
   mpfr_float_imp& operator=(unsigned long long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned               shift = 0;
      mpfr_t                 t;
      mpfr_init2(t, (std::max)(static_cast<mpfr_prec_t>(std::numeric_limits<unsigned long long>::digits), static_cast<mpfr_prec_t>(mpfr_get_prec(m_data))));
      mpfr_set_ui(m_data, 0, GMP_RNDN);
      while (i)
      {
         mpfr_set_ui(t, static_cast<unsigned long>(i & mask), GMP_RNDN);
         if (shift)
            mpfr_mul_2exp(t, t, shift, GMP_RNDN);
         mpfr_add(m_data, m_data, t, GMP_RNDN);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpfr_clear(t);
      return *this;
   }
   mpfr_float_imp& operator=(long long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfr_neg(m_data, m_data, GMP_RNDN);
      return *this;
   }
#endif
#endif
#ifdef BOOST_HAS_INT128
   mpfr_float_imp& operator=(uint128_type i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
      unsigned           shift = 0;
      mpfr_t             t;
      mpfr_init2(t, (std::max)(static_cast<mpfr_prec_t>(std::numeric_limits<unsigned long long>::digits), static_cast<mpfr_prec_t>(mpfr_get_prec(m_data))));
      mpfr_set_ui(m_data, 0, GMP_RNDN);
      while (i)
      {
         mpfr_set_ui(t, static_cast<unsigned long>(i & mask), GMP_RNDN);
         if (shift)
            mpfr_mul_2exp(t, t, shift, GMP_RNDN);
         mpfr_add(m_data, m_data, t, GMP_RNDN);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      mpfr_clear(t);
      return *this;
   }
   mpfr_float_imp& operator=(int128_type i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfr_neg(m_data, m_data, GMP_RNDN);
      return *this;
   }
#endif
   mpfr_float_imp& operator=(unsigned long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      mpfr_set_ui(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long i)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      mpfr_set_si(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(double d)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision()))));
      mpfr_set_d(m_data, d, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long double a)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));
      mpfr_set_ld(m_data, a, GMP_RNDN);
      return *this;
   }
#ifdef BOOST_HAS_FLOAT128
   mpfr_float_imp& operator=(float128_type a)
   {
      BOOST_MP_FLOAT128_USING
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision())));

      if (a == 0)
      {
         mpfr_set_si(m_data, 0, GMP_RNDN);
         return *this;
      }

      if (a == 1)
      {
         mpfr_set_si(m_data, 1, GMP_RNDN);
         return *this;
      }

      if (BOOST_MP_ISINF(a))
      {
         mpfr_set_inf(m_data, a < 0 ? -1 : 1);
         return *this;
      }
      if (BOOST_MP_ISNAN(a))
      {
         mpfr_set_nan(m_data);
         return *this;
      }

      int        e;
      float128_type f, term;
      mpfr_set_ui(m_data, 0u, GMP_RNDN);

      f = frexp(a, &e);

      constexpr const int shift = std::numeric_limits<int>::digits - 1;

      while (f)
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpfr_mul_2exp(m_data, m_data, shift, GMP_RNDN);
         if (term > 0)
            mpfr_add_ui(m_data, m_data, static_cast<unsigned>(term), GMP_RNDN);
         else
            mpfr_sub_ui(m_data, m_data, static_cast<unsigned>(-term), GMP_RNDN);
         f -= term;
      }
      if (e > 0)
         mpfr_mul_2exp(m_data, m_data, e, GMP_RNDN);
      else if (e < 0)
         mpfr_div_2exp(m_data, m_data, -e, GMP_RNDN);
      return *this;
   }
#endif
   mpfr_float_imp& operator=(const char* s)
   {
      if (m_data[0]._mpfr_d == nullptr)
         mpfr_init2(m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(digits10 ? digits10 : static_cast<unsigned>(get_default_precision()))));
      if (mpfr_set_str(m_data, s, 10, GMP_RNDN) != 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse string \"") + s + std::string("\"as a valid floating point number.")));
      }
      return *this;
   }
   void swap(mpfr_float_imp& o) noexcept
   {
      mpfr_swap(m_data, o.m_data);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);

      bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
      bool fixed      = (f & std::ios_base::fixed) == std::ios_base::fixed;

      std::streamsize org_digits(digits);

      if (scientific && digits)
         ++digits;

      std::string result;
      mp_exp_t    e;
      if (mpfr_inf_p(m_data))
      {
         if (mpfr_sgn(m_data) < 0)
            result = "-inf";
         else if (f & std::ios_base::showpos)
            result = "+inf";
         else
            result = "inf";
         return result;
      }
      if (mpfr_nan_p(m_data))
      {
         result = "nan";
         return result;
      }
      if (mpfr_zero_p(m_data))
      {
         e      = 0;
         if (mpfr_signbit(m_data))
            result = "-0";
         else
            result = "0";
      }
      else if (fixed)
      {
         // We actually need a different number of digits to what one might expect:
         char* ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
         --e;
         mpfr_free_str(ps);
         digits += e + 1;
         if (digits == 0)
         {
            // We need to get *all* the digits and then possibly round up,
            // we end up with either "0" or "1" as the result.
            ps = mpfr_get_str(nullptr, &e, 10, 0, m_data, GMP_RNDN);
            --e;
            unsigned offset = *ps == '-' ? 1 : 0;
            if (ps[offset] > '5')
            {
               ++e;
               ps[offset] = '1';
               ps[offset + 1] = 0;
            }
            else if (ps[offset] == '5')
            {
               unsigned i = offset + 1;
               bool     round_up = false;
               while (ps[i] != 0)
               {
                  if (ps[i] != '0')
                  {
                     round_up = true;
                     break;
                  }
                  ++i;
               }
               if (round_up)
               {
                  ++e;
                  ps[offset] = '1';
                  ps[offset + 1] = 0;
               }
               else
               {
                  ps[offset] = '0';
                  ps[offset + 1] = 0;
               }
            }
            else
            {
               ps[offset] = '0';
               ps[offset + 1] = 0;
            }
         }
         else if (digits > 0)
         {
            mp_exp_t old_e = e;
            ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
            --e; // To match with what our formatter expects.
            if (old_e > e)
            {
               // in some cases, when we ask for more digits of precision, it will
               // change the number of digits to the left of the decimal, if that
               // happens, account for it here.
               // example: cout << fixed << setprecision(3) << mpf_float_50("99.9809")
               mpfr_free_str(ps);
               digits -= old_e - e;
               ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
               --e; // To match with what our formatter expects.
            }
         }
         else
         {
            ps = mpfr_get_str(nullptr, &e, 10, 1, m_data, GMP_RNDN);
            --e;
            unsigned offset = *ps == '-' ? 1 : 0;
            ps[offset] = '0';
            ps[offset + 1] = 0;
         }
         result = ps ? ps : "0";
         if (ps)
            mpfr_free_str(ps);
      }
      else
      {
         char* ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
         --e; // To match with what our formatter expects.
         result = ps ? ps : "0";
         if (ps)
            mpfr_free_str(ps);
      }
      boost::multiprecision::detail::format_float_string(result, e, org_digits, f, 0 != mpfr_zero_p(m_data));
      return result;
   }
   ~mpfr_float_imp() noexcept
   {
      if (m_data[0]._mpfr_d)
         mpfr_clear(m_data);
      detail::mpfr_cleanup<true>::force_instantiate();
   }
   void negate() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      mpfr_neg(m_data, m_data, GMP_RNDN);
   }
   template <mpfr_allocation_type AllocationType>
   int compare(const mpfr_float_backend<digits10, AllocationType>& o) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d && o.m_data[0]._mpfr_d);
      return mpfr_cmp(m_data, o.m_data);
   }
   int compare(long i) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return mpfr_cmp_si(m_data, i);
   }
   int compare(double i) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return mpfr_cmp_d(m_data, i);
   }
   int compare(long double i) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return mpfr_cmp_ld(m_data, i);
   }
   int compare(unsigned long i) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return mpfr_cmp_ui(m_data, i);
   }
   template <class V>
   int compare(V v) const
   {
      mpfr_float_backend<digits10, allocate_dynamic> d(0uL, mpfr_get_prec(m_data));
      d = v;
      return compare(d);
   }
   mpfr_t& data() noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return m_data;
   }
   const mpfr_t& data() const noexcept
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);
      return m_data;
   }

 protected:
   mpfr_t           m_data;
   static boost::multiprecision::detail::precision_type& get_global_default_precision() noexcept
   {
      static boost::multiprecision::detail::precision_type val(BOOST_MULTIPRECISION_MPFR_DEFAULT_PRECISION);
      return val;
   }
   static unsigned& get_default_precision() noexcept
   {
      static BOOST_MP_THREAD_LOCAL unsigned val(get_global_default_precision());
      return val;
   }
#ifndef BOOST_MT_NO_ATOMIC_INT
   static std::atomic<variable_precision_options>& get_global_default_options() noexcept
   {
      static std::atomic<variable_precision_options> val{variable_precision_options::preserve_related_precision};
      return val;
   }
#else
   static variable_precision_options& get_global_default_options() noexcept
   {
      static variable_precision_options val{variable_precision_options::preserve_related_precision};
      return val;
   }
#endif
   static variable_precision_options& get_default_options()noexcept
   {
      static BOOST_MP_THREAD_LOCAL variable_precision_options val(get_global_default_options());
      return val;
   }
   static bool preserve_source_precision() noexcept
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
};

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4127) // Conditional expression is constant
#endif

template <unsigned digits10>
struct mpfr_float_imp<digits10, allocate_stack>
{
#ifdef BOOST_HAS_LONG_LONG
   using signed_types = std::tuple<long, long long>          ;
   using unsigned_types = std::tuple<unsigned long, unsigned long long>;
#else
   using signed_types = std::tuple<long>         ;
   using unsigned_types = std::tuple<unsigned long>;
#endif
   using float_types = std::tuple<double, long double>;
   using exponent_type = long                          ;

   static constexpr const unsigned digits2    = (digits10 * 1000uL) / 301uL + ((digits10 * 1000uL) % 301 ? 2u : 1u);
   static constexpr const unsigned limb_count = mpfr_custom_get_size(digits2) / sizeof(mp_limb_t);

   ~mpfr_float_imp() noexcept
   {
      detail::mpfr_cleanup<true>::force_instantiate();
   }
   mpfr_float_imp()
   {
      mpfr_custom_init(m_buffer, digits2);
      mpfr_custom_init_set(m_data, MPFR_NAN_KIND, 0, digits2, m_buffer);
      mpfr_set_ui(m_data, 0u, GMP_RNDN);
   }

   mpfr_float_imp(const mpfr_float_imp& o)
   {
      mpfr_custom_init(m_buffer, digits2);
      mpfr_custom_init_set(m_data, MPFR_NAN_KIND, 0, digits2, m_buffer);
      mpfr_set(m_data, o.m_data, GMP_RNDN);
   }
   mpfr_float_imp& operator=(const mpfr_float_imp& o)
   {
      mpfr_set(m_data, o.m_data, GMP_RNDN);
      return *this;
   }
#ifdef BOOST_HAS_LONG_LONG
#ifdef _MPFR_H_HAVE_INTMAX_T
   mpfr_float_imp& operator=(unsigned long long i)
   {
      mpfr_set_uj(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long long i)
   {
      mpfr_set_sj(m_data, i, GMP_RNDN);
      return *this;
   }
#else
   mpfr_float_imp& operator=(unsigned long long i)
   {
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uL);
      unsigned               shift = 0;
      mpfr_t                 t;
      mp_limb_t              t_limbs[limb_count];
      mpfr_custom_init(t_limbs, digits2);
      mpfr_custom_init_set(t, MPFR_NAN_KIND, 0, digits2, t_limbs);
      mpfr_set_ui(m_data, 0, GMP_RNDN);
      while (i)
      {
         mpfr_set_ui(t, static_cast<unsigned long>(i & mask), GMP_RNDN);
         if (shift)
            mpfr_mul_2exp(t, t, shift, GMP_RNDN);
         mpfr_add(m_data, m_data, t, GMP_RNDN);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      return *this;
   }
   mpfr_float_imp& operator=(long long i)
   {
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfr_neg(m_data, m_data, GMP_RNDN);
      return *this;
   }
#endif
#endif
#ifdef BOOST_HAS_INT128
   mpfr_float_imp& operator=(uint128_type i)
   {
      unsigned long long mask  = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uL);
      unsigned           shift = 0;
      mpfr_t             t;
      mp_limb_t          t_limbs[limb_count];
      mpfr_custom_init(t_limbs, digits2);
      mpfr_custom_init_set(t, MPFR_NAN_KIND, 0, digits2, t_limbs);
      mpfr_set_ui(m_data, 0, GMP_RNDN);
      while (i)
      {
         mpfr_set_ui(t, static_cast<unsigned long>(i & mask), GMP_RNDN);
         if (shift)
            mpfr_mul_2exp(t, t, shift, GMP_RNDN);
         mpfr_add(m_data, m_data, t, GMP_RNDN);
         shift += std::numeric_limits<unsigned long>::digits;
         i >>= std::numeric_limits<unsigned long>::digits;
      }
      return *this;
   }
   mpfr_float_imp& operator=(int128_type i)
   {
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         mpfr_neg(m_data, m_data, GMP_RNDN);
      return *this;
   }
#endif
   mpfr_float_imp& operator=(unsigned long i)
   {
      mpfr_set_ui(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long i)
   {
      mpfr_set_si(m_data, i, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(double d)
   {
      mpfr_set_d(m_data, d, GMP_RNDN);
      return *this;
   }
   mpfr_float_imp& operator=(long double a)
   {
      mpfr_set_ld(m_data, a, GMP_RNDN);
      return *this;
   }
#ifdef BOOST_HAS_FLOAT128
   mpfr_float_imp& operator=(float128_type a)
   {
      BOOST_MP_FLOAT128_USING
      if (a == 0)
      {
         mpfr_set_si(m_data, 0, GMP_RNDN);
         return *this;
      }

      if (a == 1)
      {
         mpfr_set_si(m_data, 1, GMP_RNDN);
         return *this;
      }

      if (BOOST_MP_ISINF(a))
      {
         mpfr_set_inf(m_data, a < 0 ? -1 : 1);
         return *this;
      }
      if (BOOST_MP_ISNAN(a))
      {
         mpfr_set_nan(m_data);
         return *this;
      }

      int        e;
      float128_type f, term;
      mpfr_set_ui(m_data, 0u, GMP_RNDN);

      f = frexp(a, &e);

      constexpr const int shift = std::numeric_limits<int>::digits - 1;

      while (f)
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         mpfr_mul_2exp(m_data, m_data, shift, GMP_RNDN);
         if (term > 0)
            mpfr_add_ui(m_data, m_data, static_cast<unsigned>(term), GMP_RNDN);
         else
            mpfr_sub_ui(m_data, m_data, static_cast<unsigned>(-term), GMP_RNDN);
         f -= term;
      }
      if (e > 0)
         mpfr_mul_2exp(m_data, m_data, e, GMP_RNDN);
      else if (e < 0)
         mpfr_div_2exp(m_data, m_data, -e, GMP_RNDN);
      return *this;
   }
#endif
   mpfr_float_imp& operator=(const char* s)
   {
      if (mpfr_set_str(m_data, s, 10, GMP_RNDN) != 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Unable to parse string \"") + s + std::string("\"as a valid floating point number.")));
      }
      return *this;
   }
   void swap(mpfr_float_imp& o) noexcept
   {
      // We have to swap by copying:
      mpfr_float_imp t(*this);
      *this = o;
      o     = t;
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data[0]._mpfr_d);

      bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
      bool fixed      = (f & std::ios_base::fixed) == std::ios_base::fixed;

      std::streamsize org_digits(digits);

      if (scientific && digits)
         ++digits;

      std::string result;
      mp_exp_t    e;
      if (mpfr_inf_p(m_data))
      {
         if (mpfr_sgn(m_data) < 0)
            result = "-inf";
         else if (f & std::ios_base::showpos)
            result = "+inf";
         else
            result = "inf";
         return result;
      }
      if (mpfr_nan_p(m_data))
      {
         result = "nan";
         return result;
      }
      if (mpfr_zero_p(m_data))
      {
         e      = 0;
         result = "0";
      }
      else
      {
         char* ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
         --e; // To match with what our formatter expects.
         if (fixed && e != -1)
         {
            // Oops we actually need a different number of digits to what we asked for:
            mpfr_free_str(ps);
            digits += e + 1;
            if (digits == 0)
            {
               // We need to get *all* the digits and then possibly round up,
               // we end up with either "0" or "1" as the result.
               ps = mpfr_get_str(nullptr, &e, 10, 0, m_data, GMP_RNDN);
               --e;
               unsigned offset = *ps == '-' ? 1 : 0;
               if (ps[offset] > '5')
               {
                  ++e;
                  ps[offset]     = '1';
                  ps[offset + 1] = 0;
               }
               else if (ps[offset] == '5')
               {
                  unsigned i        = offset + 1;
                  bool     round_up = false;
                  while (ps[i] != 0)
                  {
                     if (ps[i] != '0')
                     {
                        round_up = true;
                        break;
                     }
                  }
                  if (round_up)
                  {
                     ++e;
                     ps[offset]     = '1';
                     ps[offset + 1] = 0;
                  }
                  else
                  {
                     ps[offset]     = '0';
                     ps[offset + 1] = 0;
                  }
               }
               else
               {
                  ps[offset]     = '0';
                  ps[offset + 1] = 0;
               }
            }
            else if (digits > 0)
            {
               ps = mpfr_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data, GMP_RNDN);
               --e; // To match with what our formatter expects.
            }
            else
            {
               ps = mpfr_get_str(nullptr, &e, 10, 1, m_data, GMP_RNDN);
               --e;
               unsigned offset = *ps == '-' ? 1 : 0;
               ps[offset]      = '0';
               ps[offset + 1]  = 0;
            }
         }
         result = ps ? ps : "0";
         if (ps)
            mpfr_free_str(ps);
      }
      boost::multiprecision::detail::format_float_string(result, e, org_digits, f, 0 != mpfr_zero_p(m_data));
      return result;
   }
   void negate() noexcept
   {
      mpfr_neg(m_data, m_data, GMP_RNDN);
   }
   template <mpfr_allocation_type AllocationType>
   int compare(const mpfr_float_backend<digits10, AllocationType>& o) const
   {
      return mpfr_cmp(m_data, o.m_data);
   }
   int compare(long i) const
   {
      return mpfr_cmp_si(m_data, i);
   }
   int compare(unsigned long i) const
   {
      return mpfr_cmp_ui(m_data, i);
   }
   int compare(double i) const
   {
      return mpfr_cmp_d(m_data, i);
   }
   int compare(long double i) const
   {
      return mpfr_cmp_ld(m_data, i);
   }
   template <class V>
   int compare(V v) const
   {
      mpfr_float_backend<digits10, allocate_stack> d;
      d = v;
      return compare(d);
   }
   mpfr_t& data() noexcept
   {
      return m_data;
   }
   const mpfr_t& data() const noexcept
   {
      return m_data;
   }

 protected:
   mpfr_t    m_data;
   mp_limb_t m_buffer[limb_count];
};

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // namespace detail

template <unsigned digits10, mpfr_allocation_type AllocationType>
struct mpfr_float_backend : public detail::mpfr_float_imp<digits10, AllocationType>
{
   mpfr_float_backend() : detail::mpfr_float_imp<digits10, AllocationType>() {}
   mpfr_float_backend(const mpfr_float_backend& o) : detail::mpfr_float_imp<digits10, AllocationType>(o) {}
   // rvalue copy
   mpfr_float_backend(mpfr_float_backend&& o) noexcept : detail::mpfr_float_imp<digits10, AllocationType>(static_cast<detail::mpfr_float_imp<digits10, AllocationType>&&>(o))
   {}
   template <unsigned D, mpfr_allocation_type AT>
   mpfr_float_backend(const mpfr_float_backend<D, AT>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D, mpfr_allocation_type AT>
   explicit mpfr_float_backend(const mpfr_float_backend<D, AT>& val, typename std::enable_if<!(D <= digits10)>::type* = nullptr)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpfr_float_backend(const gmp_float<D>& val, typename std::enable_if<D <= digits10>::type* = nullptr)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpfr_float_backend(const gmp_float<D>& val, typename std::enable_if<!(D <= digits10)>::type* = nullptr)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   mpfr_float_backend(const gmp_int& val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_z(this->m_data, val.data(), GMP_RNDN);
   }
   mpfr_float_backend(const gmp_rational& val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_q(this->m_data, val.data(), GMP_RNDN);
   }
   mpfr_float_backend(const mpfr_t val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpf_t val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_f(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpz_t val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_z(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpq_t val)
       : detail::mpfr_float_imp<digits10, AllocationType>()
   {
      mpfr_set_q(this->m_data, val, GMP_RNDN);
   }
   // Construction with precision: we ignore the precision here.
   template <class V>
   mpfr_float_backend(const V& o, unsigned)
   {
      *this = o;
   }
   mpfr_float_backend& operator=(const mpfr_float_backend& o)
   {
      *static_cast<detail::mpfr_float_imp<digits10, AllocationType>*>(this) = static_cast<detail::mpfr_float_imp<digits10, AllocationType> const&>(o);
      return *this;
   }
   // rvalue assign
   mpfr_float_backend& operator=(mpfr_float_backend&& o) noexcept
   {
      *static_cast<detail::mpfr_float_imp<digits10, AllocationType>*>(this) = static_cast<detail::mpfr_float_imp<digits10, AllocationType>&&>(o);
      return *this;
   }
   template <class V>
   typename std::enable_if<std::is_assignable<detail::mpfr_float_imp<digits10, AllocationType>, V>::value, mpfr_float_backend&>::type operator=(const V& v)
   {
      *static_cast<detail::mpfr_float_imp<digits10, AllocationType>*>(this) = v;
      return *this;
   }
   mpfr_float_backend& operator=(const mpfr_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpf_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_f(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpz_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_z(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpq_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_q(this->m_data, val, GMP_RNDN);
      return *this;
   }
   // We don't change our precision here, this is a fixed precision type:
   template <unsigned D, mpfr_allocation_type AT>
   mpfr_float_backend& operator=(const mpfr_float_backend<D, AT>& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   template <unsigned D>
   mpfr_float_backend& operator=(const gmp_float<D>& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const gmp_int& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_z(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const gmp_rational& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
      mpfr_set_q(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
};

template <>
struct mpfr_float_backend<0, allocate_dynamic> : public detail::mpfr_float_imp<0, allocate_dynamic>
{
   mpfr_float_backend() : detail::mpfr_float_imp<0, allocate_dynamic>() {}
   mpfr_float_backend(const mpfr_t val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_all_precision() ? static_cast<unsigned>(mpfr_get_prec(val)) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(get_default_precision())))
   {
      mpfr_set(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpf_t val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_all_precision() ? static_cast<unsigned>(mpf_get_prec(val)) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(get_default_precision())))
   {
      mpfr_set_f(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpz_t val)
       : detail::mpfr_float_imp<0, allocate_dynamic>()
   {
      mpfr_set_z(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpq_t val)
       : detail::mpfr_float_imp<0, allocate_dynamic>()
   {
      mpfr_set_q(this->m_data, val, GMP_RNDN);
   }
   mpfr_float_backend(const mpfr_float_backend& o) : detail::mpfr_float_imp<0, allocate_dynamic>(o) {}
   // rvalue copy
   mpfr_float_backend(mpfr_float_backend&& o) noexcept : detail::mpfr_float_imp<0, allocate_dynamic>(static_cast<detail::mpfr_float_imp<0, allocate_dynamic>&&>(o))
   {}
   template <class V>
   mpfr_float_backend(const V& o, unsigned digits10)
       : detail::mpfr_float_imp<0, allocate_dynamic>(static_cast<unsigned>(multiprecision::detail::digits10_2_2(digits10)))
   {
      *this = o;
   }
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   mpfr_float_backend(const std::string_view& o, unsigned digits10)
       : detail::mpfr_float_imp<0, allocate_dynamic>(static_cast<unsigned>(multiprecision::detail::digits10_2_2(digits10)))
   {
      std::string s(o);
      *this = s.c_str();
   }
#endif
   template <unsigned D>
   mpfr_float_backend(const gmp_float<D>& val, unsigned digits10)
       : detail::mpfr_float_imp<0, allocate_dynamic>(static_cast<unsigned>(multiprecision::detail::digits10_2_2(digits10)))
   {
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpfr_float_backend(const mpfr_float_backend<D>& val, unsigned digits10)
       : detail::mpfr_float_imp<0, allocate_dynamic>(static_cast<unsigned>(multiprecision::detail::digits10_2_2(digits10)))
   {
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpfr_float_backend(const mpfr_float_backend<D>& val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_related_precision() ? static_cast<unsigned>(mpfr_get_prec(val.data())) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(get_default_precision())))
   {
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
   }
   template <unsigned D>
   mpfr_float_backend(const gmp_float<D>& val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_all_precision() ? static_cast<unsigned>(mpf_get_prec(val.data())) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(get_default_precision())))
   {
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
   }
   mpfr_float_backend(const gmp_int& val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_all_precision() ? static_cast<unsigned>(used_gmp_int_bits(val)) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(thread_default_precision())))
   {
      mpfr_set_z(this->m_data, val.data(), GMP_RNDN);
   }
   mpfr_float_backend(const gmp_rational& val)
       : detail::mpfr_float_imp<0, allocate_dynamic>(preserve_all_precision() ? static_cast<unsigned>(used_gmp_rational_bits(val)) : static_cast<unsigned>(boost::multiprecision::detail::digits10_2_2(thread_default_precision())))
   {
      mpfr_set_q(this->m_data, val.data(), GMP_RNDN);
   }

   mpfr_float_backend& operator=(const mpfr_float_backend& o) = default;
   // rvalue assign
   mpfr_float_backend& operator=(mpfr_float_backend&& o) noexcept = default;

   template <class V>
   typename std::enable_if<std::is_assignable<detail::mpfr_float_imp<0, allocate_dynamic>, V>::value, mpfr_float_backend&>::type operator=(const V& v)
   {
      constexpr unsigned d10 = std::is_floating_point<V>::value ?
         std::numeric_limits<V>::digits10 :
         std::numeric_limits<V>::digits10 ? 1 + std::numeric_limits<V>::digits10 :
         1 + boost::multiprecision::detail::digits2_2_10(std::numeric_limits<V>::digits);

      if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         BOOST_IF_CONSTEXPR(std::is_floating_point<V>::value)
         {
            if (std::numeric_limits<V>::digits > mpfr_get_prec(this->data()))
               mpfr_set_prec(this->data(), std::numeric_limits<V>::digits);
         }
         else
         {
            if(precision() < d10)
               this->precision(d10);
         }
      }

      *static_cast<detail::mpfr_float_imp<0, allocate_dynamic>*>(this) = v;
      return *this;
   }
   mpfr_float_backend& operator=(const mpfr_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, preserve_all_precision() ? static_cast<mpfr_prec_t>(mpfr_get_prec(val)) : static_cast<mpfr_prec_t>(boost::multiprecision::detail::digits10_2_2(get_default_precision())));
      else if(preserve_all_precision())
         mpfr_set_prec(this->m_data, mpfr_get_prec(val));
      mpfr_set(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpf_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, preserve_all_precision() ? static_cast<mpfr_prec_t>(mpf_get_prec(val)) : static_cast<mpfr_prec_t>(boost::multiprecision::detail::digits10_2_2(get_default_precision())));
      else if(preserve_all_precision())
         mpfr_set_prec(this->m_data, static_cast<mpfr_prec_t>(mpf_get_prec(val)));
      mpfr_set_f(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpz_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(get_default_precision())));
      mpfr_set_z(this->m_data, val, GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const mpq_t val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(get_default_precision())));
      mpfr_set_q(this->m_data, val, GMP_RNDN);
      return *this;
   }
   template <unsigned D>
   mpfr_float_backend& operator=(const mpfr_float_backend<D>& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, preserve_related_precision() ? static_cast<mpfr_prec_t>(mpfr_get_prec(val.data())) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      else if (preserve_related_precision())
         mpfr_set_prec(this->m_data, mpfr_get_prec(val.data()));
      mpfr_set(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   template <unsigned D>
   mpfr_float_backend& operator=(const gmp_float<D>& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
         mpfr_init2(this->m_data, preserve_all_precision() ? static_cast<mpfr_prec_t>(mpf_get_prec(val.data())) : boost::multiprecision::detail::digits10_2_2(get_default_precision()));
      else if (preserve_all_precision())
         mpfr_set_prec(this->m_data, static_cast<mpfr_prec_t>(mpf_get_prec(val.data())));
      mpfr_set_f(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const gmp_int& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
      {
         unsigned requested_precision = this->thread_default_precision();
         if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
         {
            unsigned d2  = static_cast<unsigned>(used_gmp_int_bits(val));
            unsigned d10 = static_cast<unsigned>(1ULL + multiprecision::detail::digits2_2_10(d2));
            if (d10 > requested_precision)
               requested_precision = d10;
         }
         mpfr_init2(this->m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(requested_precision)));
      }
      else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         unsigned requested_precision = this->thread_default_precision();
         unsigned d2  = static_cast<unsigned>(used_gmp_int_bits(val));
         unsigned d10 = static_cast<unsigned>(1ULL + multiprecision::detail::digits2_2_10(d2));
         if (d10 > requested_precision)
            this->precision(d10);
      }
      mpfr_set_z(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   mpfr_float_backend& operator=(const gmp_rational& val)
   {
      if (this->m_data[0]._mpfr_d == nullptr)
      {
         unsigned requested_precision = this->get_default_precision();
         if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
         {
            unsigned d10 = static_cast<unsigned>(1u + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(val)));
            if (d10 > requested_precision)
               requested_precision = d10;
         }
         mpfr_init2(this->m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2(requested_precision)));
      }
      else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision)
      {
         unsigned requested_precision = this->get_default_precision();
         unsigned d10 = static_cast<unsigned>(1u + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(val)));
         if (d10 > requested_precision)
            this->precision(d10);
      }
      mpfr_set_q(this->m_data, val.data(), GMP_RNDN);
      return *this;
   }
   static unsigned default_precision() noexcept
   {
      return get_global_default_precision();
   }
   static void default_precision(unsigned v) noexcept
   {
      get_global_default_precision() = v;
   }
   static unsigned thread_default_precision() noexcept
   {
      return get_default_precision();
   }
   static void thread_default_precision(unsigned v) noexcept
   {
      get_default_precision() = v;
   }
   unsigned precision() const noexcept
   {
      return static_cast<unsigned>(multiprecision::detail::digits2_2_10(static_cast<unsigned long>(mpfr_get_prec(this->m_data))));
   }
   void precision(unsigned digits10) noexcept
   {
      mpfr_prec_round(this->m_data, static_cast<mpfr_prec_t>(multiprecision::detail::digits10_2_2((digits10))), GMP_RNDN);
   }
   //
   // Variable precision options:
   //
   static variable_precision_options default_variable_precision_options()noexcept
   {
      return get_global_default_options();
   }
   static variable_precision_options thread_default_variable_precision_options()noexcept
   {
      return get_default_options();
   }
   static void default_variable_precision_options(variable_precision_options opts)
   {
      get_global_default_options() = opts;
   }
   static void thread_default_variable_precision_options(variable_precision_options opts)
   {
      get_default_options() = opts;
   }
   static bool preserve_source_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_source_precision;
   }
   static bool preserve_related_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_related_precision;
   }
   static bool preserve_all_precision()
   {
      return get_default_options() >= variable_precision_options::preserve_all_precision;
   }
};

template <unsigned digits10, mpfr_allocation_type AllocationType, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const mpfr_float_backend<digits10, AllocationType>& a, const T& b)
{
   return a.compare(b) == 0;
}
template <unsigned digits10, mpfr_allocation_type AllocationType, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const mpfr_float_backend<digits10, AllocationType>& a, const T& b)
{
   return a.compare(b) < 0;
}
template <unsigned digits10, mpfr_allocation_type AllocationType, class T>
inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const mpfr_float_backend<digits10, AllocationType>& a, const T& b)
{
   return a.compare(b) > 0;
}

template <unsigned digits10, mpfr_allocation_type AllocationType>
inline bool eval_eq(const mpfr_float_backend<digits10, AllocationType>& a, const mpfr_float_backend<digits10, AllocationType>& b)noexcept
{
   return mpfr_equal_p(a.data(), b.data());
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline bool eval_lt(const mpfr_float_backend<digits10, AllocationType>& a, const mpfr_float_backend<digits10, AllocationType>& b) noexcept
{
   return mpfr_less_p(a.data(), b.data());
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline bool eval_gt(const mpfr_float_backend<digits10, AllocationType>& a, const mpfr_float_backend<digits10, AllocationType>& b) noexcept
{
   return mpfr_greater_p(a.data(), b.data());
}

template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_add(mpfr_float_backend<D1, A1>& result, const mpfr_float_backend<D2, A2>& o)
{
   mpfr_add(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_subtract(mpfr_float_backend<D1, A1>& result, const mpfr_float_backend<D2, A2>& o)
{
   mpfr_sub(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_multiply(mpfr_float_backend<D1, A1>& result, const mpfr_float_backend<D2, A2>& o)
{
   if ((void*)&o == (void*)&result)
      mpfr_sqr(result.data(), o.data(), GMP_RNDN);
   else
      mpfr_mul(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_divide(mpfr_float_backend<D1, A1>& result, const mpfr_float_backend<D2, A2>& o)
{
   mpfr_div(result.data(), result.data(), o.data(), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_add(mpfr_float_backend<digits10, AllocationType>& result, unsigned long i)
{
   mpfr_add_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_subtract(mpfr_float_backend<digits10, AllocationType>& result, unsigned long i)
{
   mpfr_sub_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_multiply(mpfr_float_backend<digits10, AllocationType>& result, unsigned long i)
{
   mpfr_mul_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_divide(mpfr_float_backend<digits10, AllocationType>& result, unsigned long i)
{
   mpfr_div_ui(result.data(), result.data(), i, GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_add(mpfr_float_backend<digits10, AllocationType>& result, long i)
{
   if (i > 0)
      mpfr_add_ui(result.data(), result.data(), i, GMP_RNDN);
   else
      mpfr_sub_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_subtract(mpfr_float_backend<digits10, AllocationType>& result, long i)
{
   if (i > 0)
      mpfr_sub_ui(result.data(), result.data(), static_cast<typename std::make_unsigned<long>::type>(i), GMP_RNDN);
   else
      mpfr_add_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_multiply(mpfr_float_backend<digits10, AllocationType>& result, long i)
{
   mpfr_mul_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
   if (i < 0)
      mpfr_neg(result.data(), result.data(), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_divide(mpfr_float_backend<digits10, AllocationType>& result, long i)
{
   mpfr_div_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i), GMP_RNDN);
   if (i < 0)
      mpfr_neg(result.data(), result.data(), GMP_RNDN);
}
//
// Specialised 3 arg versions of the basic operators:
//
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2, unsigned D3, mpfr_allocation_type A3>
inline void eval_add(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, const mpfr_float_backend<D3, A3>& y)
{
   mpfr_add(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_add(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, unsigned long y)
{
   mpfr_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_add(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, long y)
{
   if (y < 0)
      mpfr_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
   else
      mpfr_add_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_add(mpfr_float_backend<D1, A1>& a, unsigned long x, const mpfr_float_backend<D2, A2>& y)
{
   mpfr_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_add(mpfr_float_backend<D1, A1>& a, long x, const mpfr_float_backend<D2, A2>& y)
{
   if (x < 0)
   {
      mpfr_ui_sub(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDN);
      mpfr_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpfr_add_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2, unsigned D3, mpfr_allocation_type A3>
inline void eval_subtract(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, const mpfr_float_backend<D3, A3>& y)
{
   mpfr_sub(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_subtract(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, unsigned long y)
{
   mpfr_sub_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_subtract(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, long y)
{
   if (y < 0)
      mpfr_add_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
   else
      mpfr_sub_ui(a.data(), x.data(), static_cast<typename std::make_unsigned<long>::type>(y), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_subtract(mpfr_float_backend<D1, A1>& a, unsigned long x, const mpfr_float_backend<D2, A2>& y)
{
   mpfr_ui_sub(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_subtract(mpfr_float_backend<D1, A1>& a, long x, const mpfr_float_backend<D2, A2>& y)
{
   if (x < 0)
   {
      mpfr_add_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDN);
      mpfr_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpfr_ui_sub(a.data(), x, y.data(), GMP_RNDN);
}

template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2, unsigned D3, mpfr_allocation_type A3>
inline void eval_multiply(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, const mpfr_float_backend<D3, A3>& y)
{
   if ((void*)&x == (void*)&y)
      mpfr_sqr(a.data(), x.data(), GMP_RNDN);
   else
      mpfr_mul(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_multiply(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, unsigned long y)
{
   mpfr_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_multiply(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, long y)
{
   if (y < 0)
   {
      mpfr_mul_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
      a.negate();
   }
   else
      mpfr_mul_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_multiply(mpfr_float_backend<D1, A1>& a, unsigned long x, const mpfr_float_backend<D2, A2>& y)
{
   mpfr_mul_ui(a.data(), y.data(), x, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_multiply(mpfr_float_backend<D1, A1>& a, long x, const mpfr_float_backend<D2, A2>& y)
{
   if (x < 0)
   {
      mpfr_mul_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x), GMP_RNDN);
      mpfr_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpfr_mul_ui(a.data(), y.data(), x, GMP_RNDN);
}

template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2, unsigned D3, mpfr_allocation_type A3>
inline void eval_divide(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, const mpfr_float_backend<D3, A3>& y)
{
   mpfr_div(a.data(), x.data(), y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_divide(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, unsigned long y)
{
   mpfr_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_divide(mpfr_float_backend<D1, A1>& a, const mpfr_float_backend<D2, A2>& x, long y)
{
   if (y < 0)
   {
      mpfr_div_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y), GMP_RNDN);
      a.negate();
   }
   else
      mpfr_div_ui(a.data(), x.data(), y, GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_divide(mpfr_float_backend<D1, A1>& a, unsigned long x, const mpfr_float_backend<D2, A2>& y)
{
   mpfr_ui_div(a.data(), x, y.data(), GMP_RNDN);
}
template <unsigned D1, unsigned D2, mpfr_allocation_type A1, mpfr_allocation_type A2>
inline void eval_divide(mpfr_float_backend<D1, A1>& a, long x, const mpfr_float_backend<D2, A2>& y)
{
   if (x < 0)
   {
      mpfr_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data(), GMP_RNDN);
      mpfr_neg(a.data(), a.data(), GMP_RNDN);
   }
   else
      mpfr_ui_div(a.data(), x, y.data(), GMP_RNDN);
}

template <unsigned digits10, mpfr_allocation_type AllocationType>
inline bool eval_is_zero(const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   return 0 != mpfr_zero_p(val.data());
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline int eval_get_sign(const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   return mpfr_sgn(val.data());
}

template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(unsigned long* result, const mpfr_float_backend<digits10, AllocationType>& val)
{
   if (mpfr_nan_p(val.data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
   }
   *result = mpfr_get_ui(val.data(), GMP_RNDZ);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(long* result, const mpfr_float_backend<digits10, AllocationType>& val)
{
   if (mpfr_nan_p(val.data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
   }
   *result = mpfr_get_si(val.data(), GMP_RNDZ);
}
#ifdef _MPFR_H_HAVE_INTMAX_T
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(unsigned long long* result, const mpfr_float_backend<digits10, AllocationType>& val)
{
   if (mpfr_nan_p(val.data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
   }
   *result = mpfr_get_uj(val.data(), GMP_RNDZ);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(long long* result, const mpfr_float_backend<digits10, AllocationType>& val)
{
   if (mpfr_nan_p(val.data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Could not convert NaN to integer."));
   }
   *result = mpfr_get_sj(val.data(), GMP_RNDZ);
}
#endif
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(float* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   *result = mpfr_get_flt(val.data(), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(double* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   *result = mpfr_get_d(val.data(), GMP_RNDN);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(long double* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   *result = mpfr_get_ld(val.data(), GMP_RNDN);
}

#ifdef BOOST_HAS_INT128
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(int128_type* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   gmp_int i;
   mpfr_get_z(i.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, i);
}
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(uint128_type* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   gmp_int i;
   mpfr_get_z(i.data(), val.data(), GMP_RNDN);
   eval_convert_to(result, i);
}
#endif
#if defined(BOOST_HAS_FLOAT128)
template <unsigned digits10, mpfr_allocation_type AllocationType>
inline void eval_convert_to(float128_type* result, const mpfr_float_backend<digits10, AllocationType>& val) noexcept
{
   *result = float128_procs::strtoflt128(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
#endif

//
// Native non-member operations:
//
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_sqrt(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_sqrt(result.data(), val.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_abs(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_abs(result.data(), val.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_fabs(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_abs(result.data(), val.data(), GMP_RNDN);
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_ceil(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_ceil(result.data(), val.data());
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_floor(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_floor(result.data(), val.data());
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_trunc(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val)
{
   mpfr_trunc(result.data(), val.data());
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_ldexp(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val, long e)
{
   using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type;

   if (e > 0)
      mpfr_mul_2exp(result.data(), val.data(), static_cast<local_uint_type>(e), GMP_RNDN);
   else if (e < 0)
      mpfr_div_2exp(result.data(), val.data(), static_cast<local_uint_type>(-e), GMP_RNDN);
   else
      result = val;
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_frexp(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val, int* e)
{
   if (mpfr_zero_p(val.data()))
   {
      *e = 0;
      result = val;
      return;
   }
   mp_exp_t v = mpfr_get_exp(val.data());
   *e = static_cast<int>(v);
   if (v)
      eval_ldexp(result, val, -v);
   else
      result = val;
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_frexp(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& val, long* e)
{
   if (mpfr_zero_p(val.data()))
   {
      *e = 0;
      result = val;
      return;
   }
   mp_exp_t v = mpfr_get_exp(val.data());
   *e = v;
   if(v)
      eval_ldexp(result, val, -v);
   else
      result = val;
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline int eval_fpclassify(const mpfr_float_backend<Digits10, AllocateType>& val) noexcept
{
   return mpfr_inf_p(val.data()) ? FP_INFINITE : mpfr_nan_p(val.data()) ? FP_NAN : mpfr_zero_p(val.data()) ? FP_ZERO : FP_NORMAL;
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_pow(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& b, const mpfr_float_backend<Digits10, AllocateType>& e)
{
   if (mpfr_zero_p(b.data()) && mpfr_integer_p(e.data()) && (mpfr_signbit(e.data()) == 0) && mpfr_fits_ulong_p(e.data(), GMP_RNDN) && (mpfr_get_ui(e.data(), GMP_RNDN) & 1))
   {
      mpfr_set(result.data(), b.data(), GMP_RNDN);
   }
   else
      mpfr_pow(result.data(), b.data(), e.data(), GMP_RNDN);
}

#ifdef BOOST_MSVC
//
// The enable_if usage below doesn't work with msvc - but only when
// certain other enable_if usages are defined first.  It's a capricious
// and rather annoying compiler bug in other words....
//
#define BOOST_MP_ENABLE_IF_WORKAROUND (Digits10 || !Digits10)&&
#else
#define BOOST_MP_ENABLE_IF_WORKAROUND
#endif

template <unsigned Digits10, mpfr_allocation_type AllocateType, class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value && (BOOST_MP_ENABLE_IF_WORKAROUND(sizeof(Integer) <= sizeof(long)))>::type
eval_pow(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& b, const Integer& e)
{
   mpfr_pow_si(result.data(), b.data(), e, GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType, class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value && (BOOST_MP_ENABLE_IF_WORKAROUND(sizeof(Integer) <= sizeof(long)))>::type
eval_pow(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& b, const Integer& e)
{
   mpfr_pow_ui(result.data(), b.data(), e, GMP_RNDN);
}

#undef BOOST_MP_ENABLE_IF_WORKAROUND

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_exp(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_exp(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_exp2(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_exp2(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_log(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_log(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_log10(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_log10(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_sin(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_sin(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_cos(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_cos(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_tan(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_tan(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_asin(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_asin(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_acos(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_acos(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_atan(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_atan(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_atan2(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg1, const mpfr_float_backend<Digits10, AllocateType>& arg2)
{
   mpfr_atan2(result.data(), arg1.data(), arg2.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_sinh(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_sinh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_cosh(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_cosh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_tanh(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_tanh(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_log2(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   mpfr_log2(result.data(), arg.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_modf(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& arg, mpfr_float_backend<Digits10, AllocateType>* pipart)
{
   if (pipart == nullptr)
   {
      mpfr_float_backend<Digits10, AllocateType> ipart;
      mpfr_modf(ipart.data(), result.data(), arg.data(), GMP_RNDN);
   }
   else
   {
      mpfr_modf(pipart->data(), result.data(), arg.data(), GMP_RNDN);
   }
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_remainder(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b)
{
   mpfr_remainder(result.data(), a.data(), b.data(), GMP_RNDN);
}
template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_remquo(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b, int* pi)
{
   long l;
   mpfr_remquo(result.data(), &l, a.data(), b.data(), GMP_RNDN);
   if (pi)
      *pi = static_cast<int>(l);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_fmod(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b)
{
   mpfr_fmod(result.data(), a.data(), b.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_multiply_add(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b)
{
   mpfr_fma(result.data(), a.data(), b.data(), result.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_multiply_add(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b, const mpfr_float_backend<Digits10, AllocateType>& c)
{
   mpfr_fma(result.data(), a.data(), b.data(), c.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_multiply_subtract(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b)
{
   mpfr_fms(result.data(), a.data(), b.data(), result.data(), GMP_RNDN);
   result.negate();
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline void eval_multiply_subtract(mpfr_float_backend<Digits10, AllocateType>& result, const mpfr_float_backend<Digits10, AllocateType>& a, const mpfr_float_backend<Digits10, AllocateType>& b, const mpfr_float_backend<Digits10, AllocateType>& c)
{
   mpfr_fms(result.data(), a.data(), b.data(), c.data(), GMP_RNDN);
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline int eval_signbit BOOST_PREVENT_MACRO_SUBSTITUTION(const mpfr_float_backend<Digits10, AllocateType>& arg)
{
   return (arg.data()[0]._mpfr_sign < 0) ? 1 : 0;
}

template <unsigned Digits10, mpfr_allocation_type AllocateType>
inline std::size_t hash_value(const mpfr_float_backend<Digits10, AllocateType>& val)
{
   std::size_t result = 0;
   std::size_t len    = val.data()[0]._mpfr_prec / mp_bits_per_limb;
   if (val.data()[0]._mpfr_prec % mp_bits_per_limb)
      ++len;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.data()[0]._mpfr_d[i]);
   boost::multiprecision::detail::hash_combine(result, val.data()[0]._mpfr_exp, val.data()[0]._mpfr_sign);
   return result;
}

} // namespace backends

namespace detail {
template <>
struct is_variable_precision<backends::mpfr_float_backend<0> > : public std::integral_constant<bool, true>
{};
} // namespace detail

template <>
struct number_category<detail::canonical<mpfr_t, backends::mpfr_float_backend<0> >::type> : public std::integral_constant<int, number_kind_floating_point>
{};

template <unsigned D, boost::multiprecision::mpfr_allocation_type A1, boost::multiprecision::mpfr_allocation_type A2>
struct is_equivalent_number_type<backends::mpfr_float_backend<D, A1>, backends::mpfr_float_backend<D, A2> > : public std::integral_constant<bool, true> {};

using boost::multiprecision::backends::mpfr_float_backend;

using mpfr_float_50 = number<mpfr_float_backend<50> >  ;
using mpfr_float_100 = number<mpfr_float_backend<100> > ;
using mpfr_float_500 = number<mpfr_float_backend<500> > ;
using mpfr_float_1000 = number<mpfr_float_backend<1000> >;
using mpfr_float = number<mpfr_float_backend<0> >   ;

using static_mpfr_float_50 = number<mpfr_float_backend<50, allocate_stack> > ;
using static_mpfr_float_100 = number<mpfr_float_backend<100, allocate_stack> >;

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& a, const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& b)
{
   return (boost::multiprecision::signbit)(a) != (boost::multiprecision::signbit)(b) ? boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(-a) : a;
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> copysign BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& a, const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& b)
{
   return (boost::multiprecision::signbit)(a) != (boost::multiprecision::signbit)(b) ? boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>(-a) : a;
}

} // namespace multiprecision

namespace math {

using boost::multiprecision::copysign;
using boost::multiprecision::signbit;

namespace tools {

#ifndef BOOST_MP_MATH_AVAILABLE

template <typename T>
inline int digits();

template <typename T>
inline T max_value();

template <typename T>
inline T min_value();

#endif

inline void set_output_precision(const boost::multiprecision::mpfr_float& val, std::ostream& os)
{
   os << std::setprecision(static_cast<int>(val.precision()));
}

template <>
inline int digits<boost::multiprecision::mpfr_float>()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpfr_float::thread_default_precision()));
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpfr_float::thread_default_precision()));
}

template <>
inline boost::multiprecision::mpfr_float
max_value<boost::multiprecision::mpfr_float>()
{
   boost::multiprecision::mpfr_float result(0.5);
   mpfr_mul_2exp(result.backend().data(), result.backend().data(), static_cast<typename std::make_unsigned<mpfr_exp_t>::type>(mpfr_get_emax()), GMP_RNDN);
   BOOST_MP_ASSERT(mpfr_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::mpfr_float
min_value<boost::multiprecision::mpfr_float>()
{
   boost::multiprecision::mpfr_float result(0.5);
   mpfr_div_2exp(result.backend().data(), result.backend().data(), static_cast<typename std::make_unsigned<mpfr_exp_t>::type>(-mpfr_get_emin()), GMP_RNDN);
   BOOST_MP_ASSERT(mpfr_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> result(0.5);
   mpfr_mul_2exp(result.backend().data(), result.backend().data(), static_cast<typename std::make_unsigned<mpfr_exp_t>::type>(mpfr_get_emax()), GMP_RNDN);
   BOOST_MP_ASSERT(mpfr_number_p(result.backend().data()));
   return result;
}

template <>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >()
{
   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> result(0.5);
   mpfr_div_2exp(result.backend().data(), result.backend().data(), static_cast<typename std::make_unsigned<mpfr_exp_t>::type>(-mpfr_get_emin()), GMP_RNDN);
   BOOST_MP_ASSERT(mpfr_number_p(result.backend().data()));
   return result;
}
//
// Over again with debug_adaptor:
//
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> >::thread_default_precision()));
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> >::thread_default_precision()));
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> >
max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
{
   return max_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> >
min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
{
   return min_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
{
   return max_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
{
   return min_value<boost::multiprecision::mpfr_float>().backend();
}

//
// Over again with logged_adaptor:
//
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> >::default_precision()));
}
template <>
inline int digits<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
    noexcept
#endif
{
   return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> >::default_precision()));
}

template <>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> >
max_value<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
{
   return max_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> >
min_value<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float::backend_type> > >()
{
   return min_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off>
max_value<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
{
   return max_value<boost::multiprecision::mpfr_float>().backend();
}

template <>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off>
min_value<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<0> >, boost::multiprecision::et_off> >()
{
   return min_value<boost::multiprecision::mpfr_float>().backend();
}

} // namespace tools

namespace constants { namespace detail {

template <class T>
struct constant_pi;
template <class T>
struct constant_ln_two;
template <class T>
struct constant_euler;
template <class T>
struct constant_catalan;

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_pi(result.backend().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_log2(result.backend().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_euler(result.backend().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_catalan(result.backend().data(), GMP_RNDN);
      return result;
   }
};
//
// Over again with debug_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_pi(result.backend().value().data(), GMP_RNDN);
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_log2(result.backend().value().data(), GMP_RNDN);
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_euler(result.backend().value().data(), GMP_RNDN);
      result.backend().update_view();
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // Rely on C++11 thread safe initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_catalan(result.backend().value().data(), GMP_RNDN);
      result.backend().update_view();
      return result;
   }
};

//
// Over again with logged_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_pi(result.backend().value().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_ln_two<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_log2(result.backend().value().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_euler<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_euler(result.backend().value().data(), GMP_RNDN);
      return result;
   }
};
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_catalan<boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >
{
   using result_type = boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>;
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&)
   {
      // C++11 thread safe static initialization:
      static result_type result{get(std::integral_constant<int, 0>())};
      return result;
   }
   static inline const result_type get(const std::integral_constant<int, 0>&)
   {
      result_type result;
      mpfr_const_catalan(result.backend().value().data(), GMP_RNDN);
      return result;
   }
};

}} // namespace constants::detail

} // namespace math

namespace multiprecision {
//
// Overloaded special functions which call native mpfr routines:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_asinh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_acosh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_atanh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_cbrt(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_erf(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_erfc(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_expm1(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_lngamma(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_gamma(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_log1p(result.backend().data(), arg.backend().data(), GMP_RNDN);
   return result;
}

//
// Over again with debug_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_asinh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_acosh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_atanh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_cbrt(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_erf(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_erfc(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_expm1(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_lngamma(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_gamma(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_log1p(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   result.backend().update_view();
   return result;
}

//
// Over again with logged_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_asinh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_acosh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_atanh(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_cbrt(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_erf(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_erfc(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_expm1(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_lngamma(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_gamma(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   boost::multiprecision::detail::scoped_default_precision<number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> result;
   mpfr_log1p(result.backend().value().data(), arg.backend().value().data(), GMP_RNDN);
   return result;
}

} // namespace multiprecision

namespace math {
//
// Overloaded special functions which call native mpfr routines:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy&)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_asinh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("asinh<%1%>(%1%)", nullptr, Policy());
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("asinh<%1%>(%1%)", "Unknown error, result is a NaN", result, Policy());
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return asinh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy&)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_acosh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("acosh<%1%>(%1%)", nullptr, Policy());
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("acosh<%1%>(%1%)", "Unknown error, result is a NaN", result, Policy());
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return acosh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& )
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_atanh(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("atanh<%1%>(%1%)", nullptr, Policy());
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("atanh<%1%>(%1%)", "Unknown error, result is a NaN", result, Policy());
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return atanh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy&)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_cbrt(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("cbrt<%1%>(%1%)", nullptr, Policy());
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("cbrt<%1%>(%1%)", "Unknown error, result is a NaN", result, Policy());
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return cbrt(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_erf(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("erf<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("erf<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return erf(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_erfc(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("erfc<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("erfc<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return erfc(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_expm1(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("expm1<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("expm1<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> exm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return expm1(arg, policies::policy<>());
}

#ifdef BOOST_MP_MATH_AVAILABLE
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> arg, int* sign, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);
   (void)precision_guard;  // warning suppression

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   if (arg > 0)
   {
      mpfr_lngamma(result.backend().data(), arg.backend().data(), GMP_RNDN);
      if (sign)
         *sign = 1;
   }
   else
   {
      if (floor(arg) == arg)
         return policies::raise_pole_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >(
             "lgamma<%1%>", "Evaluation of lgamma at a negative integer %1%.", arg, pol);

      boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> t = detail::sinpx(arg);
      arg                                                                                                                     = -arg;
      if (t < 0)
      {
         t = -t;
      }
      result = boost::multiprecision::log(boost::math::constants::pi<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >()) - lgamma(arg, 0, pol) - boost::multiprecision::log(t);
      if (sign)
      {
         boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> phase = 1 - arg;
         phase                                                                                                                       = floor(phase) / 2;
         if (floor(phase) == phase)
            *sign = -1;
         else
            *sign = 1;
      }
   }
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("lgamma<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("lgamma<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, int* sign)
{
   return lgamma(arg, sign, policies::policy<>());
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   return lgamma(arg, 0, pol);
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return lgamma(arg, 0, policies::policy<>());
}
#endif // BOOST_MP_MATH_AVAILABLE

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline typename std::enable_if<boost::math::policies::is_policy<Policy>::value, boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::type tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_gamma(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("tgamma<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("tgamma<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return tgamma(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_log1p(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return (arg == -1 ? -1 : 1) * policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("log1p<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("log1p<%1%>(%1%)", "Unknown error, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return log1p(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg, const Policy& pol)
{
   boost::multiprecision::detail::scoped_default_precision<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> > precision_guard(arg);

   boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> result;
   mpfr_rec_sqrt(result.backend().data(), arg.backend().data(), GMP_RNDN);
   if (mpfr_inf_p(result.backend().data()))
      return policies::raise_overflow_error<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >("rsqrt<%1%>(%1%)", nullptr, pol);
   if (mpfr_nan_p(result.backend().data()))
      return policies::raise_evaluation_error("rsqrt<%1%>(%1%)", "Negative argument, result is a NaN", result, pol);
   return result;
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>& arg)
{
   return rsqrt(arg, policies::policy<>());
}

//
// Over again with debug_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return asinh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return asinh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return acosh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return acosh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return atanh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return atanh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return cbrt(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return cbrt(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return erf(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return erf(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return erfc(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return erfc(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return expm1(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> exm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return expm1(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> arg, int* sign, const Policy& pol)
{
   return lgamma(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), sign, pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, int* sign)
{
   return lgamma(arg, sign, policies::policy<>());
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return lgamma(arg, 0, pol);
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return lgamma(arg, 0, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline typename std::enable_if<boost::math::policies::is_policy<Policy>::value, boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >::type tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return tgamma(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return tgamma(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return log1p(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return log1p(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return rsqrt(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return rsqrt(arg, policies::policy<>());
}

//
// Over again with logged_adaptor:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return asinh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> asinh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return asinh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return acosh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> acosh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return acosh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return atanh(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> atanh BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return atanh(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return cbrt(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> cbrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return cbrt(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return erf(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erf BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return erf(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return erfc(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> erfc BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return erfc(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> expm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return expm1(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> exm1 BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return expm1(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> arg, int* sign, const Policy& pol)
{
   return lgamma(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), sign, pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, int* sign)
{
   return lgamma(arg, sign, policies::policy<>());
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return lgamma(arg, 0, pol);
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> lgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return lgamma(arg, 0, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline typename std::enable_if<boost::math::policies::is_policy<Policy>::value, boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> >::type tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return tgamma(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> tgamma BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return tgamma(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return log1p(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> log1p BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return log1p(arg, policies::policy<>());
}

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates, class Policy>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg, const Policy& pol)
{
   return rsqrt(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>(arg.backend().value()), pol).backend();
}
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
inline boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates> rsqrt BOOST_PREVENT_MACRO_SUBSTITUTION(const boost::multiprecision::number<boost::multiprecision::backends::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>& arg)
{
   return rsqrt(arg, policies::policy<>());
}

} // namespace math

} // namespace boost

namespace Eigen
{

   template <class B1, class B2>
   struct NumTraitsImp;

   template <boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
   struct NumTraitsImp<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>, boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>>
   {
      using self_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>;
      using Real = typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type;
      using NonInteger = self_type; // Not correct but we can't do much better??
      using Literal = double;
      using Nested = self_type;
      enum
      {
         IsComplex = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
         IsInteger = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
         ReadCost = 1,
         AddCost = 4,
         MulCost = 8,
         IsSigned = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
         RequireInitialization = 1,
      };
      static Real epsilon()
      {
         #ifdef BOOST_MP_MATH_AVAILABLE
         return boost::math::tools::epsilon< boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>>();
         #else
         self_type result{1};
         mpfr_div_2exp(result.backend().data(), result.backend().data(), std::numeric_limits<self_type>::digits - 1, GMP_RNDN);
         return result;
         #endif
      }
      static Real dummy_precision()
      {
         return 1000 * epsilon();
      }
      static Real highest()
      {
         #ifdef BOOST_MP_MATH_AVAILABLE
         return boost::math::tools::max_value<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>>();
         #else
         self_type value(0.5);
         mpfr_mul_2exp(value.backend().data(), value.backend().data(), mpfr_get_emax(), GMP_RNDN);
         return value;
         #endif
      }
      static Real lowest()
      {
         #ifdef BOOST_MP_MATH_AVAILABLE
         return boost::math::tools::min_value<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0, AllocateType>, ExpressionTemplates>>();
         #else
         return -(highest)();
         #endif
      }
      static int digits10()
      {
         return Real::thread_default_precision();
      }
      static int digits()
      {
         return boost::math::tools::digits<Real>();
      }
      static int min_exponent()
      {
         return static_cast<int>(mpfr_get_emin());
      }
      static int max_exponent()
      {
         return static_cast<int>(mpfr_get_emax());
      }
      static Real infinity()
      {
         return std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<50, AllocateType>, ExpressionTemplates>>::infinity();
      }
      static Real quiet_NaN()
      {
         return std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<50, AllocateType>, ExpressionTemplates>>::quiet_NaN();
      }
   };

}

namespace std {

//
// numeric_limits [partial] specializations for the types declared in this header:
//
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>;

   static number_type get_min()
   {
      number_type result{0.5};
      mpfr_div_2exp(result.backend().data(), result.backend().data(), -mpfr_get_emin(), GMP_RNDN);
      return result;
   }
   static number_type get_max()
   {
      number_type result{0.5};
      mpfr_mul_2exp(result.backend().data(), result.backend().data(), mpfr_get_emax(), GMP_RNDN);
      return result;
   }
   static number_type get_eps()
   {
      number_type result{1};
      mpfr_div_2exp(result.backend().data(), result.backend().data(), std::numeric_limits<number_type>::digits - 1, GMP_RNDN);
      return result;
   }

 public:
   static constexpr bool is_specialized = true;
   static number_type(min)()
   {
      static number_type value{get_min()};
      return value;
   }
   static number_type(max)()
   {
      static number_type value{get_max()};
      return value;
   }
   static constexpr number_type lowest()
   {
      return -(max)();
   }
   static constexpr int digits   = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301 ? 2 : 1));
   static constexpr int digits10 = Digits10;
   // Is this really correct???
   static constexpr int  max_digits10 = static_cast<int>(boost::multiprecision::detail::calc_max_digits10<static_cast<unsigned>(digits)>::value);
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static number_type          epsilon()
   {
      static number_type value{get_eps()};
      return value;
   }
   // What value should this be????
   static number_type round_error()
   {
      // returns epsilon/2
      return 0.5;
   }
   static constexpr long min_exponent                  = MPFR_EMIN_DEFAULT;
   static constexpr long min_exponent10                = (MPFR_EMIN_DEFAULT / 1000) * 301L;
   static constexpr long max_exponent                  = MPFR_EMAX_DEFAULT;
   static constexpr long max_exponent10                = (MPFR_EMAX_DEFAULT / 1000) * 301L;
   static constexpr bool has_infinity                  = true;
   static constexpr bool has_quiet_NaN                 = true;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_absent;
   static constexpr bool               has_denorm_loss = false;
   static number_type                        infinity()
   {
      number_type value;
      mpfr_set_inf(value.backend().data(), 1);
      return value;
   }
   static number_type quiet_NaN()
   {
      number_type value;
      mpfr_set_nan(value.backend().data());
      return value;
   }
   static constexpr number_type signaling_NaN()
   {
      return number_type(0);
   }
   static constexpr number_type denorm_min() { return number_type(0); }
   static constexpr bool        is_iec559         = false;
   static constexpr bool        is_bounded        = true;
   static constexpr bool        is_modulo         = false;
   static constexpr bool        traps             = true;
   static constexpr bool        tinyness_before   = false;
   static constexpr float_round_style round_style = round_to_nearest;
};

template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::digits;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::digits10;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::max_digits10;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_signed;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_integer;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_exact;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::radix;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::min_exponent;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::min_exponent10;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::max_exponent;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::max_exponent10;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::has_infinity;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::has_quiet_NaN;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::has_signaling_NaN;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::has_denorm;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::has_denorm_loss;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_iec559;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_bounded;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::is_modulo;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::traps;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::tinyness_before;
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates> >::round_style;

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = false;
   static number_type(min)()
   {
      number_type value(0.5);
      mpfr_div_2exp(value.backend().data(), value.backend().data(), -mpfr_get_emin(), GMP_RNDN);
      return value;
   }
   static number_type(max)()
   {
      number_type value(0.5);
      mpfr_mul_2exp(value.backend().data(), value.backend().data(), mpfr_get_emax(), GMP_RNDN);
      return value;
   }
   static number_type lowest()
   {
      return -(max)();
   }
   static constexpr int  digits       = INT_MAX;
   static constexpr int  digits10     = INT_MAX;
   static constexpr int  max_digits10 = INT_MAX;
   static constexpr bool is_signed    = true;
   static constexpr bool is_integer   = false;
   static constexpr bool is_exact     = false;
   static constexpr int  radix        = 2;
   static number_type          epsilon()
   {
      number_type value(1);
      mpfr_div_2exp(value.backend().data(), value.backend().data(), boost::multiprecision::detail::digits10_2_2(number_type::thread_default_precision()) - 1, GMP_RNDN);
      return value;
   }
   static number_type round_error()
   {
      return 0.5;
   }
   static constexpr long min_exponent                  = MPFR_EMIN_DEFAULT;
   static constexpr long min_exponent10                = (MPFR_EMIN_DEFAULT / 1000) * 301L;
   static constexpr long max_exponent                  = MPFR_EMAX_DEFAULT;
   static constexpr long max_exponent10                = (MPFR_EMAX_DEFAULT / 1000) * 301L;
   static constexpr bool has_infinity                  = true;
   static constexpr bool has_quiet_NaN                 = true;
   static constexpr bool has_signaling_NaN             = false;
   static constexpr float_denorm_style has_denorm      = denorm_absent;
   static constexpr bool               has_denorm_loss = false;
   static number_type                        infinity()
   {
      number_type value;
      mpfr_set_inf(value.backend().data(), 1);
      return value;
   }
   static number_type quiet_NaN()
   {
      number_type value;
      mpfr_set_nan(value.backend().data());
      return value;
   }
   static number_type          signaling_NaN() { return number_type(0); }
   static number_type          denorm_min() { return number_type(0); }
   static constexpr bool is_iec559                = false;
   static constexpr bool is_bounded               = true;
   static constexpr bool is_modulo                = false;
   static constexpr bool traps                    = false;
   static constexpr bool tinyness_before          = false;
   static constexpr float_round_style round_style = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, ExpressionTemplates> >::round_style;

} // namespace std
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/number.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_NUMBER_HPP
#define BOOST_MP_NUMBER_HPP

#include <cstdint>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/precision.hpp>
#include <boost/multiprecision/detail/generic_interconvert.hpp>
#include <boost/multiprecision/detail/number_compare.hpp>
#include <boost/multiprecision/traits/is_restricted_conversion.hpp>
#include <boost/multiprecision/traits/is_complex.hpp>
#include <boost/multiprecision/traits/is_convertible_arithmetic.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/number_base.hpp>
#include <istream> // stream operators
#include <cstdio>  // EOF
#include <cctype>  // isspace
#include <functional>  // std::hash
#include <type_traits>
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
#include <string_view>
#endif

#ifndef BOOST_MP_STANDALONE
#include <boost/core/nvp.hpp>
#endif

namespace boost {
namespace multiprecision {

#ifdef BOOST_MSVC
// warning C4127: conditional expression is constant
// warning C4714: function marked as __forceinline not inlined
#pragma warning(push)
#pragma warning(disable : 4127 4714 6326)
#endif

template <class Backend, expression_template_option ExpressionTemplates>
class number
{
   using self_type = number<Backend, ExpressionTemplates>;

 public:
   using backend_type = Backend                                 ;
   using value_type = typename component_type<self_type>::type;

   static constexpr expression_template_option et = ExpressionTemplates;

   BOOST_MP_FORCEINLINE constexpr number() noexcept(noexcept(Backend())) {}
   BOOST_MP_FORCEINLINE constexpr number(const number& e) noexcept(noexcept(Backend(std::declval<Backend const&>()))) : m_backend(e.m_backend) {}
   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v, 
      typename std::enable_if<
      (boost::multiprecision::detail::is_convertible_arithmetic<V, Backend>::value 
            || std::is_same<std::string, V>::value 
            || std::is_convertible<V, const char*>::value) 
      && !std::is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value 
      && !detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value>::type* = nullptr)
   {
      m_backend = canonical_value(v);
   }
   template <class V>
   BOOST_MP_FORCEINLINE constexpr number(const V& v, typename std::enable_if<
                                                         std::is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value && !detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value>::type* = nullptr)
#ifndef BOOST_INTEL
       noexcept(noexcept(Backend(std::declval<typename detail::canonical<V, Backend>::type const&>())))
#endif
       : m_backend(canonical_value(v))
   {}
   template <class V, class U>
   BOOST_MP_FORCEINLINE constexpr number(const V& v, U digits10, 
      typename std::enable_if<
      (boost::multiprecision::detail::is_convertible_arithmetic<V, Backend>::value 
         || std::is_same<std::string, V>::value 
         || std::is_convertible<V, const char*>::value) 
      && !detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value 
      && (boost::multiprecision::number_category<Backend>::value != boost::multiprecision::number_kind_complex) 
      && (boost::multiprecision::number_category<Backend>::value != boost::multiprecision::number_kind_rational)
      && std::is_same<self_type, value_type>::value
      && std::is_integral<U>::value
      && (std::numeric_limits<U>::digits <= std::numeric_limits<unsigned>::digits)
      && std::is_constructible<Backend, typename detail::canonical<V, Backend>::type const&, unsigned>::value>::type* = nullptr)
       : m_backend(canonical_value(v), static_cast<unsigned>(digits10))
   {}
   //
   // Conversions from unscoped enum's are implicit:
   //
   template <class V>
   BOOST_MP_FORCEINLINE 
#if !(defined(BOOST_MSVC) && (BOOST_MSVC <= 1900))
      constexpr 
#endif
      number(const V& v, typename std::enable_if<
      std::is_enum<V>::value && std::is_convertible<V, int>::value && !std::is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value && !detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value>::type* = nullptr)
      : number(static_cast<typename std::underlying_type<V>::type>(v))
   {}
   //
   // Conversions from scoped enum's are explicit:
   //
   template <class V>
   BOOST_MP_FORCEINLINE explicit 
#if !(defined(BOOST_MSVC) && (BOOST_MSVC <= 1900))
       constexpr
#endif
       number(const V& v, typename std::enable_if<
      std::is_enum<V>::value && !std::is_convertible<V, int>::value && !std::is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value && !detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value>::type* = nullptr)
      : number(static_cast<typename std::underlying_type<V>::type>(v))
   {}

   template <class U>
   BOOST_MP_FORCEINLINE constexpr number(const number& e, U digits10, typename std::enable_if<std::is_constructible<Backend, const Backend&, unsigned>::value && std::is_integral<U>::value && (std::numeric_limits<U>::digits <= std::numeric_limits<unsigned>::digits)>::type* = nullptr)
       noexcept(noexcept(Backend(std::declval<Backend const&>(), std::declval<unsigned>())))
       : m_backend(e.m_backend, static_cast<unsigned>(digits10)) {}
   template <class V>
   explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v, typename std::enable_if<
                                                                                 (boost::multiprecision::detail::is_arithmetic<V>::value || std::is_same<std::string, V>::value || std::is_convertible<V, const char*>::value) && !detail::is_explicitly_convertible<typename detail::canonical<V, Backend>::type, Backend>::value && detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value>::type* = nullptr)
       noexcept(noexcept(std::declval<Backend&>() = std::declval<typename detail::canonical<V, Backend>::type const&>()))
   {
      m_backend = canonical_value(v);
   }
   template <class V>
   explicit BOOST_MP_FORCEINLINE constexpr number(const V& v, typename std::enable_if<
                                                                  detail::is_explicitly_convertible<typename detail::canonical<V, Backend>::type, Backend>::value && (detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value || !std::is_convertible<typename detail::canonical<V, Backend>::type, Backend>::value)>::type* = nullptr)
       noexcept(noexcept(Backend(std::declval<typename detail::canonical<V, Backend>::type const&>())))
       : m_backend(canonical_value(v)) {}
   template <class V>
   explicit BOOST_MP_FORCEINLINE constexpr number(const V& v, unsigned digits10, typename std::enable_if<(boost::multiprecision::detail::is_arithmetic<V>::value || std::is_same<std::string, V>::value || std::is_convertible<V, const char*>::value) && detail::is_restricted_conversion<typename detail::canonical<V, Backend>::type, Backend>::value && (boost::multiprecision::number_category<Backend>::value != boost::multiprecision::number_kind_complex) && (boost::multiprecision::number_category<Backend>::value != boost::multiprecision::number_kind_rational)>::type* = nullptr)
       : m_backend(canonical_value(v), digits10) {}

   template <expression_template_option ET>
   BOOST_MP_FORCEINLINE constexpr number(const number<Backend, ET>& val)
       noexcept(noexcept(Backend(std::declval<Backend const&>()))) : m_backend(val.backend()) {}

   template <class Other, expression_template_option ET>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const number<Other, ET>& val,
                                                        typename std::enable_if<(std::is_convertible<Other, Backend>::value && !detail::is_restricted_conversion<Other, Backend>::value)>::type* = nullptr)
       noexcept(noexcept(Backend(std::declval<Other const&>())))
       : m_backend(val.backend()) {}

   template <class Other, expression_template_option ET>
   explicit BOOST_MP_CXX14_CONSTEXPR number(const number<Other, ET>& val, typename std::enable_if<
                                                     (!detail::is_explicitly_convertible<Other, Backend>::value)>::type* = nullptr)
   {
      //
      // Attempt a generic interconvertion:
      //
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard_1(val);
      detail::scoped_default_precision<number<Other, ET> >                    precision_guard_2(val);
      using detail::generic_interconvert;
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      {
         if (precision_guard_1.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
         {
            self_type t;
            generic_interconvert(t.backend(), val.backend(), number_category<Backend>(), number_category<Other>());
            *this = std::move(t);
            return;
         }
      }
      generic_interconvert(backend(), val.backend(), number_category<Backend>(), number_category<Other>());
   }
   template <class Other, expression_template_option ET>
   explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const number<Other, ET>& val, typename std::enable_if<
                                                                                                   (detail::is_explicitly_convertible<Other, Backend>::value && (detail::is_restricted_conversion<Other, Backend>::value || !std::is_convertible<Other, Backend>::value))>::type* = nullptr) noexcept(noexcept(Backend(std::declval<Other const&>())))
       : m_backend(val.backend()) {}

   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2,
      typename std::enable_if<
         (std::is_convertible<V, value_type>::value
            && std::is_convertible<U, value_type>::value
            && !std::is_same<value_type, self_type>::value
            && std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const V&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const U&>()))>::type>::type, Backend>::type const&>::value
            && !boost::multiprecision::detail::is_variable_precision<Backend>::value)>::type* = nullptr)
      : m_backend(canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)))
   {
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(V&& v1, const U& v2,
      typename std::enable_if<
         (std::is_convertible<V, value_type>::value
            && std::is_convertible<U, value_type>::value
            && !std::is_same<value_type, self_type>::value
            && std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const V&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const U&>()))>::type>::type, Backend>::type const&>::value
            && !boost::multiprecision::detail::is_variable_precision<Backend>::value)>::type* = nullptr)
      : m_backend(canonical_value(detail::evaluate_if_expression(static_cast<V&&>(v1))), canonical_value(detail::evaluate_if_expression(v2)))
   {
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, U&& v2,
      typename std::enable_if<
      (std::is_convertible<V, value_type>::value
         && std::is_convertible<U, value_type>::value
         && !std::is_same<value_type, self_type>::value
         && std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const V&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const U&>()))>::type>::type, Backend>::type const&>::value
         && !boost::multiprecision::detail::is_variable_precision<Backend>::value)>::type* = nullptr)
      : m_backend(canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(static_cast<U&&>(v2))))
   {
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(V&& v1, U&& v2,
      typename std::enable_if<
      (std::is_convertible<V, value_type>::value
         && std::is_convertible<U, value_type>::value
         && !std::is_same<value_type, self_type>::value
         && std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const V&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const U&>()))>::type>::type, Backend>::type const&>::value
         && !boost::multiprecision::detail::is_variable_precision<Backend>::value)>::type* = nullptr)
      : m_backend(canonical_value(detail::evaluate_if_expression(static_cast<V&&>(v1))), canonical_value(detail::evaluate_if_expression(static_cast<U&&>(v2))))
   {
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2,
      typename std::enable_if<
         (std::is_convertible<V, value_type>::value 
            && std::is_convertible<U, value_type>::value 
            && !std::is_same<value_type, self_type>::value
            && (!std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const V&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const U&>()))>::type>::type, Backend>::type const&>::value
               || boost::multiprecision::detail::is_variable_precision<Backend>::value))>::type* = nullptr)
   {
      using default_ops::assign_components;
      // Copy precision options from this type to component_type:
      boost::multiprecision::detail::scoped_precision_options<value_type> scoped_opts(*this);
      // precision guards:
      detail::scoped_default_precision<self_type>  precision_guard(v1, v2, *this);
      detail::scoped_default_precision<value_type> component_precision_guard(v1, v2, *this);
      assign_components(m_backend, canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)));
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2,
                                        typename std::enable_if<
                                                                     (std::is_constructible<value_type, V>::value || std::is_convertible<V, std::string>::value) && (std::is_constructible<value_type, U>::value || std::is_convertible<U, std::string>::value) && !std::is_same<value_type, self_type>::value && !std::is_same<V, self_type>::value && !(std::is_convertible<V, value_type>::value && std::is_convertible<U, value_type>::value)>::type* = nullptr)
   {
      using default_ops::assign_components;
      // Copy precision options from this type to component_type:
      boost::multiprecision::detail::scoped_precision_options<value_type> scoped_opts(*this);
      // precision guards:
      detail::scoped_default_precision<self_type>  precision_guard(v1, v2, *this);
      detail::scoped_default_precision<value_type> component_precision_guard(v1, v2, *this);
      assign_components(m_backend, canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)));
   }
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   //
   // Support for new types in C++17
   //
   template <class Traits>
   explicit inline BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view<char, Traits>& view)
   {
      using default_ops::assign_from_string_view;
      assign_from_string_view(this->backend(), view);
   }
   template <class Traits>
   explicit inline BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view<char, Traits>& view_x, const std::basic_string_view<char, Traits>& view_y)
   {
      using default_ops::assign_from_string_view;
      assign_from_string_view(this->backend(), view_x, view_y);
   }
   template <class Traits>
   explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view<char, Traits>& v, unsigned digits10)
       : m_backend(canonical_value(v), digits10) {}
   template <class Traits>
   BOOST_MP_CXX14_CONSTEXPR number& assign(const std::basic_string_view<char, Traits>& view)
   {
      using default_ops::assign_from_string_view;
      assign_from_string_view(this->backend(), view);
      return *this;
   }
#endif

   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, unsigned digits10,
                                                        typename std::enable_if<(std::is_convertible<V, value_type>::value && std::is_convertible<U, value_type>::value && !std::is_same<value_type, self_type>::value)>::type* = nullptr)
       : m_backend(canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)), digits10)
   {}
   template <class V, class U>
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, unsigned digits10,
                                                                 typename std::enable_if<((std::is_constructible<value_type, V>::value || std::is_convertible<V, std::string>::value) && (std::is_constructible<value_type, U>::value || std::is_convertible<U, std::string>::value) && !std::is_same<value_type, self_type>::value) && !(std::is_convertible<V, value_type>::value && std::is_convertible<U, value_type>::value)>::type* = nullptr)
       : m_backend(detail::evaluate_if_expression(v1), detail::evaluate_if_expression(v2), digits10) {}

   template <class Other, expression_template_option ET>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(
      const number<Other, ET>& v1, 
      const number<Other, ET>& v2, 
      typename std::enable_if<
         std::is_convertible<Other, Backend>::value 
         && (!std::is_constructible<Backend, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const number<Other, ET>&>()))>::type>::type, Backend>::type const&, typename detail::canonical<typename std::remove_cv<typename std::remove_reference<decltype(detail::evaluate_if_expression(std::declval<const number<Other, ET>&>()))>::type>::type, Backend>::type const&>::value || boost::multiprecision::detail::is_variable_precision<Backend>::value) >::type* = nullptr)
   {
      using default_ops::assign_components;
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(v1, v2);
      assign_components(m_backend, v1.backend(), v2.backend());
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      using tag_type = std::integral_constant<bool, is_equivalent_number_type<number, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value>;
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> >                                       precision_guard(e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_IF_CONSTEXPR (std::is_same<self_type, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value)
      {
         BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
            if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
            {
               number t(e);
               return *this = std::move(t);
            }
      }
      do_assign(e, tag_type());
      return *this;
   }
   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR number& assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      using tag_type = std::integral_constant<bool, is_equivalent_number_type<number, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value>;

      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_IF_CONSTEXPR(std::is_same<self_type, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value)
      {
         BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
         {
            const detail::scoped_default_precision<number<Backend, ExpressionTemplates>> precision_guard(e);

            if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
            {
               number t;
               t.assign(e);
               return *this = std::move(t);
            }
         }
      }
      do_assign(e, tag_type());
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR number& assign(const value_type& a, const value_type& b)
   {
      assign_components(backend(), a.backend(), b.backend());
      return *this;
   }
   template <class V, class U>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(std::is_convertible<V, value_type>::value&& std::is_convertible<U, value_type>::value && !std::is_same<value_type, self_type>::value), number&>::type 
      assign(const V& v1, const U& v2, unsigned Digits)
   {
      self_type r(v1, v2, Digits);
      boost::multiprecision::detail::scoped_source_precision<self_type> scope;
      return *this = r;
   }
   BOOST_MP_CXX14_CONSTEXPR number& assign(const value_type & a, const value_type & b, unsigned Digits)
   {
      this->precision(Digits);
      boost::multiprecision::detail::scoped_target_precision<self_type> scoped;
      assign_components(backend(), canonical_value(detail::evaluate_if_expression(a)), canonical_value(detail::evaluate_if_expression(b)));
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator=(const number& e)
       noexcept(noexcept(std::declval<Backend&>() = std::declval<Backend const&>()))
   {
      m_backend = e.m_backend;
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator=(const V& v)
       noexcept(noexcept(std::declval<Backend&>() = std::declval<const typename detail::canonical<V, Backend>::type&>()))
   {
      m_backend = canonical_value(v);
      return *this;
   }
   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<Backend, ExpressionTemplates>& assign(const V& v)
       noexcept(noexcept(std::declval<Backend&>() = std::declval<const typename detail::canonical<V, Backend>::type&>()))
   {
      m_backend = canonical_value(v);
      return *this;
   }
   template <class V, class U>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<Backend, ExpressionTemplates>& assign(const V& v, const U& digits10_or_component)
       noexcept(noexcept(std::declval<Backend&>() = std::declval<const typename detail::canonical<V, Backend>::type&>()))
   {
      number t(v, digits10_or_component);
      boost::multiprecision::detail::scoped_source_precision<self_type> scope;
      static_cast<void>(scope);
      return *this = t;
   }
   template <class Other, expression_template_option ET>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!boost::multiprecision::detail::is_explicitly_convertible<Other, Backend>::value, number<Backend, ExpressionTemplates>&>::type
   assign(const number<Other, ET>& v)
   {
      //
      // Attempt a generic interconvertion:
      //
      using detail::generic_interconvert;
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, v);
      detail::scoped_default_precision<number<Other, ET> >                    precision_guard2(*this, v);
      //
      // If the current precision of *this differs from that of value v, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(v);
         return *this = std::move(t);
      }
      generic_interconvert(backend(), v.backend(), number_category<Backend>(), number_category<Other>());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR number(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value>::type* = nullptr)
   {
      //
      // No preicsion guard here, we already have one in operator=
      //
      *this = e;
   }
   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   explicit BOOST_MP_CXX14_CONSTEXPR number(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e,
                                            typename std::enable_if<!std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value && boost::multiprecision::detail::is_explicitly_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value>::type* = nullptr)
   {
      //
      // No precision guard as assign has one already:
      //
      assign(e);
   }

   // rvalues:
   BOOST_MP_FORCEINLINE constexpr number(number&& r)
       noexcept(noexcept(Backend(std::declval<Backend>())))
       : m_backend(static_cast<Backend&&>(r.m_backend))
   {}
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator=(number&& r) noexcept(noexcept(std::declval<Backend&>() = std::declval<Backend>()))
   {
      m_backend = static_cast<Backend&&>(r.m_backend);
      return *this;
   }
   template <class Other, expression_template_option ET>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(number<Other, ET>&& val,
                                                        typename std::enable_if<(std::is_convertible<Other, Backend>::value && !detail::is_restricted_conversion<Other, Backend>::value)>::type* = nullptr)
       noexcept(noexcept(Backend(std::declval<Other const&>())))
       : m_backend(static_cast<number<Other, ET>&&>(val).backend()) {}
   template <class Other, expression_template_option ET>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(std::is_convertible<Other, Backend>::value && !detail::is_restricted_conversion<Other, Backend>::value), number&>::type 
         operator=(number<Other, ET>&& val)
            noexcept(noexcept(Backend(std::declval<Other const&>())))
   {
      m_backend = std::move(val).backend();
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR number& operator+=(const self_type& val)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, val);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(*this + val);
         return *this = std::move(t);
      }
      do_add(detail::expression<detail::terminal, self_type>(val), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator+=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      // Create a copy if e contains this, but not if we're just doing a
      //    x += x
      if ((contains_self(e) && !is_self(e)))
      {
         self_type temp(e);
         do_add(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_add(e, tag());
      }
      return *this;
   }

   template <class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR number& operator+=(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_IF_CONSTEXPR(std::is_same<self_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value)
      {
         BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
         if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
            {
               number t(*this + e);
               return *this = std::move(t);
            }
      }
      //
      // Fused multiply-add:
      //
      using default_ops::eval_multiply_add;
      eval_multiply_add(m_backend, canonical_value(e.left_ref()), canonical_value(e.right_ref()));
      return *this;
   }

   template <class V>
   typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
      BOOST_MP_CXX14_CONSTEXPR operator+=(const V& v)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, v);
      //
      // If the current precision of *this differs from that of value v, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
         {
            number t(*this + v);
            return *this = std::move(t);
         }

      using default_ops::eval_add;
      eval_add(m_backend, canonical_value(v));
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR number& operator-=(const self_type& val)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, val);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(*this - val);
         return *this = std::move(t);
      }
      do_subtract(detail::expression<detail::terminal, self_type>(val), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator-=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      // Create a copy if e contains this:
      if (contains_self(e))
      {
         self_type temp(e);
         do_subtract(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_subtract(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator-=(const V& v)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, v);
      //
      // If the current precision of *this differs from that of value v, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
         {
            number t(*this - v);
            return *this = std::move(t);
         }

      using default_ops::eval_subtract;
      eval_subtract(m_backend, canonical_value(v));
      return *this;
   }

   template <class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR number& operator-=(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_IF_CONSTEXPR(std::is_same<self_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>::value)
      {
         BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
         if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
            {
               number t(*this - e);
               return *this = std::move(t);
            }
      }
      //
      // Fused multiply-subtract:
      //
      using default_ops::eval_multiply_subtract;
      eval_multiply_subtract(m_backend, canonical_value(e.left_ref()), canonical_value(e.right_ref()));
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR number& operator*=(const self_type& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(*this * e);
         return *this = std::move(t);
      }
      do_multiplies(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator*=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      // Create a temporary if the RHS references *this, but not
      // if we're just doing an   x *= x;
      if ((contains_self(e) && !is_self(e)))
      {
         self_type temp(e);
         do_multiplies(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_multiplies(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator*=(const V& v)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, v);
      //
      // If the current precision of *this differs from that of value v, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
         {
            number t(*this * v);
            return *this = std::move(t);
         }

      using default_ops::eval_multiply;
      eval_multiply(m_backend, canonical_value(v));
      return *this;
   }

   BOOST_MP_CXX14_CONSTEXPR number& operator%=(const self_type& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(*this % e);
         return *this = std::move(t);
      }
      do_modulus(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }
   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator%=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      // Create a temporary if the RHS references *this:
      if (contains_self(e))
      {
         self_type temp(e);
         do_modulus(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_modulus(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }
   template <class V>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator%=(const V& v)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      using default_ops::eval_modulus;
      eval_modulus(m_backend, canonical_value(v));
      return *this;
   }

   //
   // These operators are *not* proto-ized.
   // The issue is that the increment/decrement must happen
   // even if the result of the operator *is never used*.
   // Possibly we could modify our expression wrapper to
   // execute the increment/decrement on destruction, but
   // correct implementation will be tricky, so defered for now...
   //
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator++()
   {
      using default_ops::eval_increment;
      eval_increment(m_backend);
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator--()
   {
      using default_ops::eval_decrement;
      eval_decrement(m_backend);
      return *this;
   }

   inline BOOST_MP_CXX14_CONSTEXPR number operator++(int)
   {
      using default_ops::eval_increment;
      self_type temp(*this);
      eval_increment(m_backend);
      return temp;
   }

   inline BOOST_MP_CXX14_CONSTEXPR number operator--(int)
   {
      using default_ops::eval_decrement;
      self_type temp(*this);
      eval_decrement(m_backend);
      return temp;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<V>::value, number&>::type operator<<=(V val)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The left-shift operation is only valid for integer types");
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(V) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<V>::value && boost::multiprecision::detail::is_integral<V>::value > ());
      eval_left_shift(m_backend, static_cast<std::size_t>(canonical_value(val)));
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<V>::value, number&>::type operator>>=(V val)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The right-shift operation is only valid for integer types");
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(V) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<V>::value && boost::multiprecision::detail::is_integral<V>::value>());
      eval_right_shift(m_backend, static_cast<std::size_t>(canonical_value(val)));
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator/=(const self_type& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      //
      // If the current precision of *this differs from that of expression e, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
      {
         number t(*this / e);
         return *this = std::move(t);
      }
      do_divide(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator/=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, e);
      // Create a temporary if the RHS references *this:
      if (contains_self(e))
      {
         self_type temp(e);
         do_divide(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_divide(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator/=(const V& v)
   {
      detail::scoped_default_precision<number<Backend, ExpressionTemplates> > precision_guard(*this, v);
      //
      // If the current precision of *this differs from that of value v, then we
      // create a temporary (which will have the correct precision thanks to precision_guard)
      // and then move the result into *this.  In C++17 we add a leading "if constexpr"
      // which causes this code to be eliminated in the common case that this type is
      // not actually variable precision.  Pre C++17 this code should still be mostly
      // optimised away, but we can't prevent instantiation of the dead code leading
      // to longer build and possibly link times.
      //
      BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number)
      if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of<self_type>(*this))
         {
            number t(*this / v);
            return *this = std::move(t);
         }

      using default_ops::eval_divide;
      eval_divide(m_backend, canonical_value(v));
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator&=(const self_type& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      do_bitwise_and(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator&=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      // Create a temporary if the RHS references *this, but not
      // if we're just doing an   x &= x;
      if (contains_self(e) && !is_self(e))
      {
         self_type temp(e);
         do_bitwise_and(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_bitwise_and(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator&=(const V& v)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      using default_ops::eval_bitwise_and;
      eval_bitwise_and(m_backend, canonical_value(v));
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator|=(const self_type& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      do_bitwise_or(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator|=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      // Create a temporary if the RHS references *this, but not
      // if we're just doing an   x |= x;
      if (contains_self(e) && !is_self(e))
      {
         self_type temp(e);
         do_bitwise_or(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_bitwise_or(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator|=(const V& v)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      using default_ops::eval_bitwise_or;
      eval_bitwise_or(m_backend, canonical_value(v));
      return *this;
   }

   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator^=(const self_type& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      do_bitwise_xor(detail::expression<detail::terminal, self_type>(e), detail::terminal());
      return *this;
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, self_type>::value, number&>::type operator^=(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      if (contains_self(e))
      {
         self_type temp(e);
         do_bitwise_xor(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
      }
      else
      {
         do_bitwise_xor(e, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::tag_type());
      }
      return *this;
   }

   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<V, self_type>::value, number<Backend, ExpressionTemplates>&>::type
   operator^=(const V& v)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      using default_ops::eval_bitwise_xor;
      eval_bitwise_xor(m_backend, canonical_value(v));
      return *this;
   }
   //
   // swap:
   //
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void swap(self_type& other) noexcept(noexcept(std::declval<Backend>().swap(std::declval<Backend&>())))
   {
      m_backend.swap(other.backend());
   }
   //
   // Zero and sign:
   //
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool is_zero() const
   {
      using default_ops::eval_is_zero;
      return eval_is_zero(m_backend);
   }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR int sign() const
   {
      using default_ops::eval_get_sign;
      return eval_get_sign(m_backend);
   }
   //
   // String conversion functions:
   //
   std::string str(std::streamsize digits = 0, std::ios_base::fmtflags f = std::ios_base::fmtflags(0)) const
   {
      return m_backend.str(digits, f);
   }

   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      ar& boost::make_nvp("backend", m_backend);
   }
   #endif

 private:
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(T* result) const
   {
      using default_ops::eval_convert_to;
      eval_convert_to(result, m_backend);
   }
   template <class B2, expression_template_option ET>
   BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(number<B2, ET>* result) const
   {
      result->assign(*this);
   }
   BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(std::string* result) const
   {
      *result = this->str();
   }

 public:
   template <class T>
   BOOST_MP_CXX14_CONSTEXPR T convert_to() const
   {
      T result = T();
      convert_to_imp(&result);
      return result;
   }
   //
   // Use in boolean context, and explicit conversion operators:
   //
#if BOOST_WORKAROUND(BOOST_MSVC, < 1900) || (defined(__apple_build_version__) && BOOST_WORKAROUND(__clang_major__, < 9))
   template <class T>
#else
   template <class T, class = typename std::enable_if<std::is_enum<T>::value || !(std::is_constructible<T, detail::convertible_to<self_type const&> >::value || !std::is_default_constructible<T>::value || (!boost::multiprecision::detail::is_arithmetic<T>::value && !boost::multiprecision::detail::is_complex<T>::value)), T>::type>
#endif
   explicit BOOST_MP_CXX14_CONSTEXPR operator T() const
   {
      return this->template convert_to<T>();
   }
   BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const
   {
      return !is_zero();
   }
   //
   // Default precision:
   //
   static BOOST_MP_CXX14_CONSTEXPR unsigned default_precision() noexcept
   {
      return Backend::default_precision();
   }
   static BOOST_MP_CXX14_CONSTEXPR void default_precision(unsigned digits10)
   {
      Backend::default_precision(digits10);
      Backend::thread_default_precision(digits10);
   }
   static BOOST_MP_CXX14_CONSTEXPR unsigned thread_default_precision() noexcept
   {
      return Backend::thread_default_precision();
   }
   static BOOST_MP_CXX14_CONSTEXPR void thread_default_precision(unsigned digits10)
   {
      Backend::thread_default_precision(digits10);
   }
   BOOST_MP_CXX14_CONSTEXPR unsigned precision() const noexcept
   {
      return m_backend.precision();
   }
   BOOST_MP_CXX14_CONSTEXPR void precision(unsigned digits10)
   {
      m_backend.precision(digits10);
   }
   //
   // Variable precision options:
   // 
   static constexpr variable_precision_options default_variable_precision_options()noexcept
   {
      return Backend::default_variable_precision_options();
   }
   static constexpr variable_precision_options thread_default_variable_precision_options()noexcept
   {
      return Backend::thread_default_variable_precision_options();
   }
   static BOOST_MP_CXX14_CONSTEXPR void default_variable_precision_options(variable_precision_options opts)
   {
      Backend::default_variable_precision_options(opts);
   }
   static BOOST_MP_CXX14_CONSTEXPR void thread_default_variable_precision_options(variable_precision_options opts)
   {
      Backend::thread_default_variable_precision_options(opts);
   }
   //
   // Comparison:
   //
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR int compare(const number<Backend, ExpressionTemplates>& o) const
       noexcept(noexcept(std::declval<Backend>().compare(std::declval<Backend>())))
   {
      return m_backend.compare(o.m_backend);
   }
   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<V>::value && (number_category<Backend>::value != number_kind_complex), int>::type compare(const V& o) const
   {
      using default_ops::eval_get_sign;
      if (o == 0)
         return eval_get_sign(m_backend);
      return m_backend.compare(canonical_value(o));
   }
   template <class V>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<V>::value && (number_category<Backend>::value == number_kind_complex), int>::type compare(const V& o) const
   {
      using default_ops::eval_get_sign;
      return m_backend.compare(canonical_value(o));
   }
   //
   // Direct access to the underlying backend:
   //
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend& backend() & noexcept
   {
      return m_backend;
   }
   BOOST_MP_FORCEINLINE constexpr const Backend& backend() const& noexcept { return m_backend; }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend&& backend() && noexcept { return static_cast<Backend&&>(m_backend); }
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend const&& backend() const&& noexcept { return static_cast<Backend const&&>(m_backend); }
   //
   // Complex number real and imag:
   //
   BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<number<Backend, ExpressionTemplates> >::type
   real() const
   {
      using default_ops::eval_real;
      detail::scoped_default_precision<typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type> precision_guard(*this);
      typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type                                   result;
      eval_real(result.backend(), backend());
      return result;
   }
   BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex<number<Backend, ExpressionTemplates> >::type
   imag() const
   {
      using default_ops::eval_imag;
      detail::scoped_default_precision<typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type> precision_guard(*this);
      typename scalar_result_from_possible_complex<multiprecision::number<Backend, ExpressionTemplates> >::type                                   result;
      eval_imag(result.backend(), backend());
      return result;
   }
   template <class T>
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<T, self_type>::value, self_type&>::type real(const T& val)
   {
      using default_ops::eval_set_real;
      eval_set_real(backend(), canonical_value(val));
      return *this;
   }
   template <class T>
   inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_convertible<T, self_type>::value && number_category<self_type>::value == number_kind_complex, self_type&>::type imag(const T& val)
   {
      using default_ops::eval_set_imag;
      eval_set_imag(backend(), canonical_value(val));
      return *this;
   }

 private:
   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::is_assignable<number, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value>::type 
      do_assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, const std::integral_constant<bool, false>&)
   {
      // The result of the expression isn't the same type as this -
      // create a temporary result and assign it to *this:
      using temp_type = typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type;
      temp_type                                                                     t(e);
      *this = std::move(t);
   }
   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::is_assignable<number, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value>::type 
      do_assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, const std::integral_constant<bool, false>&)
   {
      // The result of the expression isn't the same type as this -
      // create a temporary result and assign it to *this:
      using temp_type = typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type;
      temp_type                                                                     t(e);
      this->assign(t);
   }

   template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e, const std::integral_constant<bool, true>&)
   {
      do_assign(e, tag());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::add_immediates&)
   {
      using default_ops::eval_add;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_add(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::subtract_immediates&)
   {
      using default_ops::eval_subtract;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_immediates&)
   {
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_add&)
   {
      using default_ops::eval_multiply_add;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply_add(m_backend, canonical_value(e.left().value()), canonical_value(e.middle().value()), canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_subtract&)
   {
      using default_ops::eval_multiply_subtract;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply_subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.middle().value()), canonical_value(e.right().value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::divide_immediates&)
   {
      using default_ops::eval_divide;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_divide(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::negate&)
   {
      using left_type = typename Exp::left_type;
      do_assign(e.left(), typename left_type::tag_type());
      m_backend.negate();
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::plus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && br)
      {
         self_type temp(e);
         temp.m_backend.swap(this->m_backend);
      }
      else if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_add(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         // Ignore the right node, it's *this, just add the left:
         do_add(e.left(), typename left_type::tag_type());
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      { // br is always false, but if bl is true we must take the this branch:
         do_assign(e.left(), typename left_type::tag_type());
         do_add(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_add(e.left(), typename left_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::minus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && br)
      {
         self_type temp(e);
         temp.m_backend.swap(this->m_backend);
      }
      else if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just subtract the right:
         do_subtract(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         // Ignore the right node, it's *this, just subtract the left and negate the result:
         do_subtract(e.left(), typename left_type::tag_type());
         m_backend.negate();
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      { // br is always false, but if bl is true we must take the this branch:
         do_assign(e.left(), typename left_type::tag_type());
         do_subtract(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_subtract(e.left(), typename left_type::tag_type());
         m_backend.negate();
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiplies&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && br)
      {
         self_type temp(e);
         temp.m_backend.swap(this->m_backend);
      }
      else if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_multiplies(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         // Ignore the right node, it's *this, just add the left:
         do_multiplies(e.left(), typename left_type::tag_type());
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      { // br is always false, but if bl is true we must take the this branch:
         do_assign(e.left(), typename left_type::tag_type());
         do_multiplies(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_multiplies(e.left(), typename left_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::divides&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_divide(e.right(), typename right_type::tag_type());
      }
      else if (br)
      {
         self_type temp(e);
         temp.m_backend.swap(this->m_backend);
      }
      else
      {
         do_assign(e.left(), typename left_type::tag_type());
         do_divide(e.right(), typename right_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::modulus&)
   {
      //
      // This operation is only valid for integer backends:
      //
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");

      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_modulus(e.right(), typename right_type::tag_type());
      }
      else if (br)
      {
         self_type temp(e);
         temp.m_backend.swap(this->m_backend);
      }
      else
      {
         do_assign(e.left(), typename left_type::tag_type());
         do_modulus(e.right(), typename right_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::modulus_immediates&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      using default_ops::eval_modulus;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_modulus(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_and&)
   {
      //
      // This operation is only valid for integer backends:
      //
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");

      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_bitwise_and(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         do_bitwise_and(e.left(), typename left_type::tag_type());
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      {
         do_assign(e.left(), typename left_type::tag_type());
         do_bitwise_and(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_bitwise_and(e.left(), typename left_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_and_immediates&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
      using default_ops::eval_bitwise_and;
      eval_bitwise_and(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_or&)
   {
      //
      // This operation is only valid for integer backends:
      //
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");

      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_bitwise_or(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         do_bitwise_or(e.left(), typename left_type::tag_type());
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      {
         do_assign(e.left(), typename left_type::tag_type());
         do_bitwise_or(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_bitwise_or(e.left(), typename left_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_or_immediates&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
      using default_ops::eval_bitwise_or;
      eval_bitwise_or(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_xor&)
   {
      //
      // This operation is only valid for integer backends:
      //
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");

      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;

      constexpr int const left_depth  = left_type::depth;
      constexpr int const right_depth = right_type::depth;

      bool bl = contains_self(e.left());
      bool br = contains_self(e.right());

      if (bl && is_self(e.left()))
      {
         // Ignore the left node, it's *this, just add the right:
         do_bitwise_xor(e.right(), typename right_type::tag_type());
      }
      else if (br && is_self(e.right()))
      {
         do_bitwise_xor(e.left(), typename left_type::tag_type());
      }
      else if (!br && (bl || (left_depth >= right_depth)))
      {
         do_assign(e.left(), typename left_type::tag_type());
         do_bitwise_xor(e.right(), typename right_type::tag_type());
      }
      else
      {
         do_assign(e.right(), typename right_type::tag_type());
         do_bitwise_xor(e.left(), typename left_type::tag_type());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_xor_immediates&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "Bitwise operations are only valid for integer types");
      using default_ops::eval_bitwise_xor;
      eval_bitwise_xor(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::terminal&)
   {
      if (!is_self(e))
      {
         m_backend = canonical_value(e.value());
      }
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::function&)
   {
      using tag_type = typename Exp::arity;
      boost::multiprecision::detail::maybe_promote_precision(this);
      do_assign_function(e, tag_type());
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::shift_left&)
   {
      // We can only shift by an integer value, not an arbitrary expression:
      using left_type = typename Exp::left_type   ;
      using right_type = typename Exp::right_type  ;
      using right_arity = typename right_type::arity;
      static_assert(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand.");
      using right_value_type = typename right_type::result_type;
      static_assert(boost::multiprecision::detail::is_integral<right_value_type>::value, "The left shift operator requires an integer value for the shift operand.");
      using tag_type = typename left_type::tag_type;
      do_assign_left_shift(e.left(), canonical_value(e.right().value()), tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::shift_right&)
   {
      // We can only shift by an integer value, not an arbitrary expression:
      using left_type = typename Exp::left_type   ;
      using right_type = typename Exp::right_type  ;
      using right_arity = typename right_type::arity;
      static_assert(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand.");
      using right_value_type = typename right_type::result_type;
      static_assert(boost::multiprecision::detail::is_integral<right_value_type>::value, "The left shift operator requires an integer value for the shift operand.");
      using tag_type = typename left_type::tag_type;
      do_assign_right_shift(e.left(), canonical_value(e.right().value()), tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_complement&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types");
      using default_ops::eval_complement;
      self_type temp(e.left());
      eval_complement(m_backend, temp.backend());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::complement_immediates&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types");
      using default_ops::eval_complement;
      eval_complement(m_backend, canonical_value(e.left().value()));
   }

   template <class Exp, class Val>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_right_shift(const Exp& e, const Val& val, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The right shift operation is only valid for integer types");
      using default_ops::eval_right_shift;
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(Val) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<Val>::value&& boost::multiprecision::detail::is_integral<Val>::value>());
      eval_right_shift(m_backend, canonical_value(e.value()), static_cast<std::size_t>(val));
   }

   template <class Exp, class Val>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_left_shift(const Exp& e, const Val& val, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The left shift operation is only valid for integer types");
      using default_ops::eval_left_shift;
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(Val) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<Val>::value&& boost::multiprecision::detail::is_integral<Val>::value>());
      eval_left_shift(m_backend, canonical_value(e.value()), static_cast<std::size_t>(val));
   }

   template <class Exp, class Val, class Tag>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_right_shift(const Exp& e, const Val& val, const Tag&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The right shift operation is only valid for integer types");
      using default_ops::eval_right_shift;
      self_type temp(e);
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(Val) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<Val>::value&& boost::multiprecision::detail::is_integral<Val>::value>());
      eval_right_shift(m_backend, temp.backend(), static_cast<std::size_t>(val));
   }

   template <class Exp, class Val, class Tag>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_left_shift(const Exp& e, const Val& val, const Tag&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The left shift operation is only valid for integer types");
      using default_ops::eval_left_shift;
      self_type temp(e);
      detail::check_shift_range(val, std::integral_constant<bool, (sizeof(Val) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<Val>::value&& boost::multiprecision::detail::is_integral<Val>::value>());
      eval_left_shift(m_backend, temp.backend(), static_cast<std::size_t>(val));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const std::integral_constant<int, 1>&)
   {
      e.left().value()(&m_backend);
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const std::integral_constant<int, 2>&)
   {
      using right_type = typename Exp::right_type     ;
      using tag_type = typename right_type::tag_type;
      do_assign_function_1(e.left().value(), e.right_ref(), tag_type());
   }
   template <class F, class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_1(const F& f, const Exp& val, const detail::terminal&)
   {
      f(m_backend, function_arg_value(val));
   }
   template <class F, class Exp, class Tag>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_1(const F& f, const Exp& val, const Tag&)
   {
      typename Exp::result_type t(val);
      f(m_backend, t.backend());
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const std::integral_constant<int, 3>&)
   {
      using middle_type = typename Exp::middle_type     ;
      using tag_type = typename middle_type::tag_type;
      using end_type = typename Exp::right_type      ;
      using end_tag = typename end_type::tag_type   ;
      do_assign_function_2(e.left().value(), e.middle_ref(), e.right_ref(), tag_type(), end_tag());
   }
   template <class F, class Exp1, class Exp2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const detail::terminal&)
   {
      f(m_backend, function_arg_value(val1), function_arg_value(val2));
   }
   template <class F, class Exp1, class Exp2, class Tag1>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const detail::terminal&)
   {
      typename Exp1::result_type temp1(val1);
      f(m_backend, std::move(temp1.backend()), function_arg_value(val2));
   }
   template <class F, class Exp1, class Exp2, class Tag2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const Tag2&)
   {
      typename Exp2::result_type temp2(val2);
      f(m_backend, function_arg_value(val1), std::move(temp2.backend()));
   }
   template <class F, class Exp1, class Exp2, class Tag1, class Tag2>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const Tag2&)
   {
      typename Exp1::result_type temp1(val1);
      typename Exp2::result_type temp2(val2);
      f(m_backend, std::move(temp1.backend()), std::move(temp2.backend()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const std::integral_constant<int, 4>&)
   {
      using left_type = typename Exp::left_middle_type ;
      using left_tag_type = typename left_type::tag_type   ;
      using middle_type = typename Exp::right_middle_type;
      using middle_tag_type = typename middle_type::tag_type ;
      using right_type = typename Exp::right_type       ;
      using right_tag_type = typename right_type::tag_type  ;
      do_assign_function_3a(e.left().value(), e.left_middle_ref(), e.right_middle_ref(), e.right_ref(), left_tag_type(), middle_tag_type(), right_tag_type());
   }

   template <class F, class Exp1, class Exp2, class Exp3, class Tag2, class Tag3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag2& t2, const Tag3& t3)
   {
      do_assign_function_3b(f, val1, val2, val3, t2, t3);
   }
   template <class F, class Exp1, class Exp2, class Exp3, class Tag1, class Tag2, class Tag3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag1&, const Tag2& t2, const Tag3& t3)
   {
      typename Exp1::result_type t(val1);
      do_assign_function_3b(f, std::move(t), val2, val3, t2, t3);
   }
   template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag3& t3)
   {
      do_assign_function_3c(f, val1, val2, val3, t3);
   }
   template <class F, class Exp1, class Exp2, class Exp3, class Tag2, class Tag3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag2& /*t2*/, const Tag3& t3)
   {
      typename Exp2::result_type t(val2);
      do_assign_function_3c(f, val1, std::move(t), val3, t3);
   }
   template <class F, class Exp1, class Exp2, class Exp3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&)
   {
      f(m_backend, function_arg_value(val1), function_arg_value(val2), function_arg_value(val3));
   }
   template <class F, class Exp1, class Exp2, class Exp3, class Tag3>
   BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag3& /*t3*/)
   {
      typename Exp3::result_type t(val3);
      do_assign_function_3c(f, val1, val2, std::move(t), detail::terminal());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::terminal&)
   {
      using default_ops::eval_add;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_add(m_backend, canonical_value(e.value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::negate&)
   {
      using left_type = typename Exp::left_type;
      boost::multiprecision::detail::maybe_promote_precision(this);
      do_subtract(e.left(), typename left_type::tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::plus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_add(e.left(), typename left_type::tag_type());
      do_add(e.right(), typename right_type::tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::minus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_add(e.left(), typename left_type::tag_type());
      do_subtract(e.right(), typename right_type::tag_type());
   }

   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const unknown&)
   {
      self_type temp(e);
      do_add(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::add_immediates&)
   {
      using default_ops::eval_add;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_add(m_backend, canonical_value(e.left().value()));
      eval_add(m_backend, canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::subtract_immediates&)
   {
      using default_ops::eval_add;
      using default_ops::eval_subtract;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_add(m_backend, canonical_value(e.left().value()));
      eval_subtract(m_backend, canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::terminal&)
   {
      using default_ops::eval_subtract;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_subtract(m_backend, canonical_value(e.value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::negate&)
   {
      using left_type = typename Exp::left_type;
      do_add(e.left(), typename left_type::tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::plus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_subtract(e.left(), typename left_type::tag_type());
      do_subtract(e.right(), typename right_type::tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::minus&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_subtract(e.left(), typename left_type::tag_type());
      do_add(e.right(), typename right_type::tag_type());
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::add_immediates&)
   {
      using default_ops::eval_subtract;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_subtract(m_backend, canonical_value(e.left().value()));
      eval_subtract(m_backend, canonical_value(e.right().value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const detail::subtract_immediates&)
   {
      using default_ops::eval_add;
      using default_ops::eval_subtract;
      eval_subtract(m_backend, canonical_value(e.left().value()));
      eval_add(m_backend, canonical_value(e.right().value()));
   }
   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_subtract(const Exp& e, const unknown&)
   {
      self_type temp(e);
      do_subtract(detail::expression<detail::terminal, self_type>(temp), detail::terminal());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_multiplies(const Exp& e, const detail::terminal&)
   {
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply(m_backend, canonical_value(e.value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_multiplies(const Exp& e, const detail::negate&)
   {
      using left_type = typename Exp::left_type;
      do_multiplies(e.left(), typename left_type::tag_type());
      m_backend.negate();
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_multiplies(const Exp& e, const detail::multiplies&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_multiplies(e.left(), typename left_type::tag_type());
      do_multiplies(e.right(), typename right_type::tag_type());
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_multiplies(const Exp& e, const detail::divides&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_multiplies(e.left(), typename left_type::tag_type());
      do_divide(e.right(), typename right_type::tag_type());
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_multiplies(const Exp& e, const detail::multiply_immediates&)
   {
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply(m_backend, canonical_value(e.left().value()));
      eval_multiply(m_backend, canonical_value(e.right().value()));
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_multiplies(const Exp& e, const detail::divide_immediates&)
   {
      using default_ops::eval_divide;
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_multiply(m_backend, canonical_value(e.left().value()));
      eval_divide(m_backend, canonical_value(e.right().value()));
   }
   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_multiplies(const Exp& e, const unknown&)
   {
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      self_type temp(e);
      eval_multiply(m_backend, temp.m_backend);
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_divide(const Exp& e, const detail::terminal&)
   {
      using default_ops::eval_divide;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_divide(m_backend, canonical_value(e.value()));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_divide(const Exp& e, const detail::negate&)
   {
      using left_type = typename Exp::left_type;
      do_divide(e.left(), typename left_type::tag_type());
      m_backend.negate();
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_divide(const Exp& e, const detail::multiplies&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_divide(e.left(), typename left_type::tag_type());
      do_divide(e.right(), typename right_type::tag_type());
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_divide(const Exp& e, const detail::divides&)
   {
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_divide(e.left(), typename left_type::tag_type());
      do_multiplies(e.right(), typename right_type::tag_type());
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_divides(const Exp& e, const detail::multiply_immediates&)
   {
      using default_ops::eval_divide;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_divide(m_backend, canonical_value(e.left().value()));
      eval_divide(m_backend, canonical_value(e.right().value()));
   }
   //
   // This rearrangement is disabled for integer types, the test on sizeof(Exp) is simply to make
   // the disable_if dependent on the template argument (the size of 1 can never occur in practice).
   //
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!(boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer || sizeof(Exp) == 1)>::type
   do_divides(const Exp& e, const detail::divide_immediates&)
   {
      using default_ops::eval_divide;
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_divide(m_backend, canonical_value(e.left().value()));
      mutiply(m_backend, canonical_value(e.right().value()));
   }

   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_divide(const Exp& e, const unknown&)
   {
      using default_ops::eval_multiply;
      boost::multiprecision::detail::maybe_promote_precision(this);
      self_type temp(e);
      eval_divide(m_backend, temp.m_backend);
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_modulus(const Exp& e, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      using default_ops::eval_modulus;
      boost::multiprecision::detail::maybe_promote_precision(this);
      eval_modulus(m_backend, canonical_value(e.value()));
   }

   template <class Exp, class Unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_modulus(const Exp& e, const Unknown&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The modulus operation is only valid for integer types");
      using default_ops::eval_modulus;
      boost::multiprecision::detail::maybe_promote_precision(this);
      self_type temp(e);
      eval_modulus(m_backend, canonical_value(temp));
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_and(const Exp& e, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      using default_ops::eval_bitwise_and;
      eval_bitwise_and(m_backend, canonical_value(e.value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_and(const Exp& e, const detail::bitwise_and&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_bitwise_and(e.left(), typename left_type::tag_type());
      do_bitwise_and(e.right(), typename right_type::tag_type());
   }
   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_and(const Exp& e, const unknown&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise & operation is only valid for integer types");
      using default_ops::eval_bitwise_and;
      self_type temp(e);
      eval_bitwise_and(m_backend, temp.m_backend);
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_or(const Exp& e, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      using default_ops::eval_bitwise_or;
      eval_bitwise_or(m_backend, canonical_value(e.value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_or(const Exp& e, const detail::bitwise_or&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_bitwise_or(e.left(), typename left_type::tag_type());
      do_bitwise_or(e.right(), typename right_type::tag_type());
   }
   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_or(const Exp& e, const unknown&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise | operation is only valid for integer types");
      using default_ops::eval_bitwise_or;
      self_type temp(e);
      eval_bitwise_or(m_backend, temp.m_backend);
   }

   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_xor(const Exp& e, const detail::terminal&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      using default_ops::eval_bitwise_xor;
      eval_bitwise_xor(m_backend, canonical_value(e.value()));
   }
   template <class Exp>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_xor(const Exp& e, const detail::bitwise_xor&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      using left_type = typename Exp::left_type ;
      using right_type = typename Exp::right_type;
      do_bitwise_xor(e.left(), typename left_type::tag_type());
      do_bitwise_xor(e.right(), typename right_type::tag_type());
   }
   template <class Exp, class unknown>
   BOOST_MP_CXX14_CONSTEXPR void do_bitwise_xor(const Exp& e, const unknown&)
   {
      static_assert(number_category<Backend>::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types");
      using default_ops::eval_bitwise_xor;
      self_type temp(e);
      eval_bitwise_xor(m_backend, temp.m_backend);
   }

   // Tests if the expression contains a reference to *this:
   template <class Exp>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool contains_self(const Exp& e) const noexcept
   {
      return contains_self(e, typename Exp::arity());
   }
   template <class Exp>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool contains_self(const Exp& e, std::integral_constant<int, 0> const&) const noexcept
   {
      return is_realy_self(e.value());
   }
   template <class Exp>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool contains_self(const Exp& e, std::integral_constant<int, 1> const&) const noexcept
   {
      using child_type = typename Exp::left_type;
      return contains_self(e.left(), typename child_type::arity());
   }
   template <class Exp>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool contains_self(const Exp& e, std::integral_constant<int, 2> const&) const noexcept
   {
      using child0_type = typename Exp::left_type ;
      using child1_type = typename Exp::right_type;
      return contains_self(e.left(), typename child0_type::arity()) || contains_self(e.right(), typename child1_type::arity());
   }
   template <class Exp>
   BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool contains_self(const Exp& e, std::integral_constant<int, 3> const&) const noexcept
   {
      using child0_type = typename Exp::left_type  ;
      using child1_type = typename Exp::middle_type;
      using child2_type = typename Exp::right_type ;
      return contains_self(e.left(), typename child0_type::arity()) || contains_self(e.middle(), typename child1_type::arity()) || contains_self(e.right(), typename child2_type::arity());
   }

   // Test if the expression is a reference to *this:
   template <class Exp>
   BOOST_MP_FORCEINLINE constexpr bool is_self(const Exp& e) const noexcept
   {
      return is_self(e, typename Exp::arity());
   }
   template <class Exp>
   BOOST_MP_FORCEINLINE constexpr bool is_self(const Exp& e, std::integral_constant<int, 0> const&) const noexcept
   {
      return is_realy_self(e.value());
   }
   template <class Exp, int v>
   BOOST_MP_FORCEINLINE constexpr bool is_self(const Exp&, std::integral_constant<int, v> const&) const noexcept
   {
      return false;
   }

   template <class Val>
   BOOST_MP_FORCEINLINE constexpr bool is_realy_self(const Val&) const noexcept { return false; }
   BOOST_MP_FORCEINLINE constexpr bool is_realy_self(const self_type& v) const noexcept { return &v == this; }

   static BOOST_MP_FORCEINLINE constexpr const Backend& function_arg_value(const self_type& v) noexcept { return v.backend(); }
   template <class Other, expression_template_option ET2>
   static BOOST_MP_FORCEINLINE constexpr const Other& function_arg_value(const number<Other, ET2>& v) noexcept { return v.backend(); }
   template <class V>
   static BOOST_MP_FORCEINLINE constexpr const V& function_arg_value(const V& v) noexcept { return v; }
   template <class A1, class A2, class A3, class A4>
   static BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR const A1& function_arg_value(const detail::expression<detail::terminal, A1, A2, A3, A4>& exp) noexcept { return exp.value(); }
   template <class A2, class A3, class A4>
   static BOOST_MP_FORCEINLINE constexpr const Backend& function_arg_value(const detail::expression<detail::terminal, number<Backend>, A2, A3, A4>& exp) noexcept { return exp.value().backend(); }
   Backend                                                    m_backend;

 public:
   //
   // These shouldn't really need to be public, or even member functions, but it makes implementing
   // the non-member operators way easier if they are:
   //
   static BOOST_MP_FORCEINLINE constexpr const Backend& canonical_value(const self_type& v) noexcept { return v.m_backend; }
   template <class B2, expression_template_option ET>
   static BOOST_MP_FORCEINLINE constexpr const B2& canonical_value(const number<B2, ET>& v) noexcept { return v.backend(); }
   template <class B2, expression_template_option ET>
   static BOOST_MP_FORCEINLINE constexpr B2&& canonical_value(number<B2, ET>&& v) noexcept { return static_cast<number<B2, ET>&&>(v).backend(); }
   template <class V>
   static BOOST_MP_FORCEINLINE constexpr typename std::enable_if<!std::is_same<typename detail::canonical<V, Backend>::type, V>::value, typename detail::canonical<V, Backend>::type>::type
   canonical_value(const V& v) noexcept { return static_cast<typename detail::canonical<V, Backend>::type>(v); }
   template <class V>
   static BOOST_MP_FORCEINLINE constexpr typename std::enable_if<std::is_same<typename detail::canonical<V, Backend>::type, V>::value, const V&>::type
   canonical_value(const V& v) noexcept { return v; }
   static BOOST_MP_FORCEINLINE typename detail::canonical<std::string, Backend>::type canonical_value(const std::string& v) noexcept { return v.c_str(); }
};

template <class Backend, expression_template_option ExpressionTemplates>
inline std::ostream& operator<<(std::ostream& os, const number<Backend, ExpressionTemplates>& r)
{
   std::streamsize d  = os.precision();
   std::string     s  = r.str(d, os.flags());
   std::streamsize ss = os.width();
   if (ss > static_cast<std::streamsize>(s.size()))
   {
      char fill = os.fill();
      if ((os.flags() & std::ios_base::left) == std::ios_base::left)
         s.append(static_cast<std::string::size_type>(ss - static_cast<std::streamsize>(s.size())), fill);
      else
         s.insert(static_cast<std::string::size_type>(0), static_cast<std::string::size_type>(ss - static_cast<std::streamsize>(s.size())), fill);
   }
   return os << s;
}

template <class Backend, expression_template_option ExpressionTemplates>
std::string to_string(const number<Backend, ExpressionTemplates>& val)
{
  return val.str(6, std::ios_base::fixed|std::ios_base::showpoint);
}

namespace detail {

template <class tag, class A1, class A2, class A3, class A4>
inline std::ostream& operator<<(std::ostream& os, const expression<tag, A1, A2, A3, A4>& r)
{
   using value_type = typename expression<tag, A1, A2, A3, A4>::result_type;
   value_type                                                    temp(r);
   return os << temp;
}
//
// What follows is the input streaming code: this is not "proper" iostream code at all
// but that's fiendishly hard to write when dealing with multiple backends all
// with different requirements... yes we could deligate this to the backend author...
// but we really want backends to be EASY to write!
// For now just pull in all the characters that could possibly form the number
// and let the backend's string parser make use of it.  This fixes most use cases
// including CSV type formats such as those used by the Random lib.
//
inline std::string read_string_while(std::istream& is, std::string const& permitted_chars)
{
   std::ios_base::iostate     state = std::ios_base::goodbit;
   const std::istream::sentry sentry_check(is);
   std::string                result;

   if (sentry_check)
   {
      int c = is.rdbuf()->sgetc();

      for (;; c = is.rdbuf()->snextc())
         if (std::istream::traits_type::eq_int_type(std::istream::traits_type::eof(), c))
         { // end of file:
            state |= std::ios_base::eofbit;
            break;
         }
         else if (permitted_chars.find_first_of(std::istream::traits_type::to_char_type(c)) == std::string::npos)
         {
            // Invalid numeric character, stop reading:
            //is.rdbuf()->sputbackc(static_cast<char>(c));
            break;
         }
         else
         {
            result.append(1, std::istream::traits_type::to_char_type(c));
         }
   }

   if (!result.size())
      state |= std::ios_base::failbit;
   is.setstate(state);
   return result;
}

} // namespace detail

template <class Backend, expression_template_option ExpressionTemplates>
inline std::istream& operator>>(std::istream& is, number<Backend, ExpressionTemplates>& r)
{
   bool        hex_format = (is.flags() & std::ios_base::hex) == std::ios_base::hex;
   bool        oct_format = (is.flags() & std::ios_base::oct) == std::ios_base::oct;
   std::string s;
   switch (boost::multiprecision::number_category<number<Backend, ExpressionTemplates> >::value)
   {
   case boost::multiprecision::number_kind_integer:
      if (oct_format)
         s = detail::read_string_while(is, "+-01234567");
      else if (hex_format)
         s = detail::read_string_while(is, "+-xXabcdefABCDEF0123456789");
      else
         s = detail::read_string_while(is, "+-0123456789");
      break;
   case boost::multiprecision::number_kind_rational:
      if (oct_format)
         s = detail::read_string_while(is, "+-01234567/");
      else if (hex_format)
         s = detail::read_string_while(is, "+-xXabcdefABCDEF0123456789/");
      else
         s = detail::read_string_while(is, "+-0123456789/");
      break;
   case boost::multiprecision::number_kind_floating_point:
      BOOST_IF_CONSTEXPR(std::is_same<number<Backend, ExpressionTemplates>, typename number<Backend, ExpressionTemplates>::value_type>::value)
         s = detail::read_string_while(is, "+-eE.0123456789infINFnanNANinfinityINFINITY");
      else
         // Interval:
         s = detail::read_string_while(is, "+-eE.0123456789infINFnanNANinfinityINFINITY{,}");
      break;
   case boost::multiprecision::number_kind_complex:
      s = detail::read_string_while(is, "+-eE.0123456789infINFnanNANinfinityINFINITY,()");
      break;
   default:
      is >> s;
   }
   if (s.size())
   {
      if (hex_format && (number_category<Backend>::value == number_kind_integer) && ((s[0] != '0') || (s[1] != 'x')))
         s.insert(s.find_first_not_of("+-"), "0x");
      if (oct_format && (number_category<Backend>::value == number_kind_integer) && (s[0] != '0'))
         s.insert(s.find_first_not_of("+-"), "0");
      r.assign(s);
   }
   else if (!is.fail())
      is.setstate(std::istream::failbit);
   return is;
}

template <class Backend, expression_template_option ExpressionTemplates>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void swap(number<Backend, ExpressionTemplates>& a, number<Backend, ExpressionTemplates>& b)
    noexcept(noexcept(std::declval<number<Backend, ExpressionTemplates>&>() = std::declval<number<Backend, ExpressionTemplates>&>()))
{
   a.swap(b);
}
//
// Boost.Hash support, just call hash_value for the backend, which may or may not be supported:
//
template <class Backend, expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t hash_value(const number<Backend, ExpressionTemplates>& val)
{
   return hash_value(val.backend());
}

namespace detail {

BOOST_MP_FORCEINLINE bool istream_peek(std::istream& is, char& c, bool have_hex)
{
   int i = is.peek();
   c = static_cast<char>(i);
   return (EOF != i) && (c == 'x' || c == 'X' || c == '-' || c == '+' || (c >= '0' && c <= '9') || (have_hex && (c >= 'a' && c <= 'f')) || (have_hex && (c >= 'A' && c <= 'F')));
}

} // namespace detail

} // namespace multiprecision

template <class T>
class rational;

template <class Backend, multiprecision::expression_template_option ExpressionTemplates>
inline std::istream& operator>>(std::istream& is, rational<multiprecision::number<Backend, ExpressionTemplates> >& r)
{
   std::string                                          s1;
   multiprecision::number<Backend, ExpressionTemplates> v1, v2;
   char                                                 c;
   bool                                                 have_hex   = false;
   bool                                                 hex_format = (is.flags() & std::ios_base::hex) == std::ios_base::hex;
   bool                                                 oct_format = (is.flags() & std::ios_base::oct) == std::ios_base::oct;

   while (multiprecision::detail::istream_peek(is, c, have_hex))
   {
      if (c == 'x' || c == 'X')
         have_hex = true;
      s1.append(1, c);
      is.get();
   }
   if (hex_format && ((s1[0] != '0') || (s1[1] != 'x')))
      s1.insert(static_cast<std::string::size_type>(0), "0x");
   if (oct_format && (s1[0] != '0'))
      s1.insert(static_cast<std::string::size_type>(0), "0");
   v1.assign(s1);
   s1.erase();
   if (c == '/')
   {
      is.get();
      while (multiprecision::detail::istream_peek(is, c, have_hex))
      {
         if (c == 'x' || c == 'X')
            have_hex = true;
         s1.append(1, c);
         is.get();
      }
      if (hex_format && ((s1[0] != '0') || (s1[1] != 'x')))
         s1.insert(static_cast<std::string::size_type>(0), "0x");
      if (oct_format && (s1[0] != '0'))
         s1.insert(static_cast<std::string::size_type>(0), "0");
      v2.assign(s1);
   }
   else
      v2 = 1;
   r.assign(v1, v2);
   return is;
}

template <class T, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<T, ExpressionTemplates> numerator(const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
   return a.numerator();
}

template <class T, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR multiprecision::number<T, ExpressionTemplates> denominator(const rational<multiprecision::number<T, ExpressionTemplates> >& a)
{
   return a.denominator();
}

template <class T, multiprecision::expression_template_option ExpressionTemplates>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t hash_value(const rational<multiprecision::number<T, ExpressionTemplates> >& val)
{
   std::size_t result = hash_value(val.numerator());
   boost::multiprecision::detail::hash_combine(result, hash_value(val.denominator()));
   return result;
}

namespace multiprecision {

template <class I>
struct component_type<boost::rational<I> >
{
   using type = I;
};

} // namespace multiprecision

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // namespace boost

namespace std {

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct hash<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   BOOST_MP_CXX14_CONSTEXPR std::size_t operator()(const boost::multiprecision::number<Backend, ExpressionTemplates>& val) const { return hash_value(val); }
};
template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct hash<boost::rational<boost::multiprecision::number<Backend, ExpressionTemplates> > >
{
   BOOST_MP_CXX14_CONSTEXPR std::size_t operator()(const boost::rational<boost::multiprecision::number<Backend, ExpressionTemplates> >& val) const
   {
      std::size_t result = hash_value(val.numerator());
      boost::multiprecision::detail::hash_combine(result, hash_value(val.denominator()));
      return result;
   }
};

} // namespace std

#include <boost/multiprecision/detail/ublas_interop.hpp>

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/random.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Jens Maurer 2006-2011
//  Copyright Steven Watanabe 2011
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_RANDOM_HPP
#define BOOST_MP_RANDOM_HPP

#include <boost/multiprecision/detail/standalone_config.hpp>

#if defined(__GNUC__) || defined(_MSC_VER)
#pragma message("NOTE: Use of this header (boost/multiprecision/random.hpp) is deprecated: please use the random number library headers directly.")
#endif

#ifndef BOOST_MP_STANDALONE
#include <boost/random.hpp>
#else
#error "Use of this header is removed in standalone mode"
#endif

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/rational_adaptor.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_RATIONAL_ADAPTOR_HPP
#define BOOST_MP_RATIONAL_ADAPTOR_HPP

#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/float128_functions.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

template <class Backend>
struct rational_adaptor
{
   //
   // Each backend need to declare 3 type lists which declare the types
   // with which this can interoperate.  These lists must at least contain
   // the widest type in each category - so "long long" must be the final
   // type in the signed_types list for example.  Any narrower types if not
   // present in the list will get promoted to the next wider type that is
   // in the list whenever mixed arithmetic involving that type is encountered.
   //
   typedef typename Backend::signed_types    signed_types;
   typedef typename Backend::unsigned_types  unsigned_types;
   typedef typename Backend::float_types     float_types;

   typedef typename std::tuple_element<0, unsigned_types>::type ui_type;

   static Backend get_one()
   {
      Backend t;
      t = static_cast<ui_type>(1);
      return t;
   }
   static Backend get_zero()
   {
      Backend t;
      t = static_cast<ui_type>(0);
      return t;
   }

   static const Backend& one()
   {
      static const Backend result(get_one());
      return result;
   }
   static const Backend& zero()
   {
      static const Backend result(get_zero());
      return result;
   }

   void normalize()
   {
      using default_ops::eval_gcd;
      using default_ops::eval_eq;
      using default_ops::eval_divide;
      using default_ops::eval_get_sign;

      int s = eval_get_sign(m_denom);

      if(s == 0)
      {
         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      }
      else if (s < 0)
      {
         m_num.negate();
         m_denom.negate();
      }

      Backend g, t;
      eval_gcd(g, m_num, m_denom);
      if (!eval_eq(g, one()))
      {
         eval_divide(t, m_num, g);
         m_num.swap(t);
         eval_divide(t, m_denom, g);
         m_denom = std::move(t);
      }
   }

   // We must have a default constructor:
   rational_adaptor()
      : m_num(zero()), m_denom(one()) {}

   rational_adaptor(const rational_adaptor& o) : m_num(o.m_num), m_denom(o.m_denom) {}
   rational_adaptor(rational_adaptor&& o) = default;

   // Optional constructors, we can make this type slightly more efficient
   // by providing constructors from any type we can handle natively.
   // These will also cause number<> to be implicitly constructible
   // from these types unless we make such constructors explicit.
   //
   template <class Arithmetic>
   rational_adaptor(const Arithmetic& val, typename std::enable_if<std::is_constructible<Backend, Arithmetic>::value && !std::is_floating_point<Arithmetic>::value>::type const* = nullptr)
      : m_num(val), m_denom(one()) {}

   //
   // Pass-through 2-arg construction of components:
   //
   template <class T, class U>
   rational_adaptor(const T& a, const U& b, typename std::enable_if<std::is_constructible<Backend, T const&>::value && std::is_constructible<Backend, U const&>::value>::type const* = nullptr)
      : m_num(a), m_denom(b) 
   {
      normalize();
   }
   template <class T, class U>
   rational_adaptor(T&& a, const U& b, typename std::enable_if<std::is_constructible<Backend, T>::value && std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_num(static_cast<T&&>(a)), m_denom(b) 
   {
      normalize();
   }
   template <class T, class U>
   rational_adaptor(T&& a, U&& b, typename std::enable_if<std::is_constructible<Backend, T>::value && std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_num(static_cast<T&&>(a)), m_denom(static_cast<U&&>(b)) 
   {
      normalize();
   }
   template <class T, class U>
   rational_adaptor(const T& a, U&& b, typename std::enable_if<std::is_constructible<Backend, T>::value && std::is_constructible<Backend, U>::value>::type const* = nullptr)
      : m_num(a), m_denom(static_cast<U&&>(b)) 
   {
      normalize();
   }
   //
   // In the absense of converting constructors, operator= takes the strain.
   // In addition to the usual suspects, there must be one operator= for each type
   // listed in signed_types, unsigned_types, and float_types plus a string constructor.
   //
   rational_adaptor& operator=(const rational_adaptor& o) = default;
   rational_adaptor& operator=(rational_adaptor&& o) = default;
   template <class Arithmetic>
   inline typename std::enable_if<!std::is_floating_point<Arithmetic>::value, rational_adaptor&>::type operator=(const Arithmetic& i)
   {
      m_num = i;
      m_denom = one();
      return *this;
   }
   rational_adaptor& operator=(const char* s)
   {
      using default_ops::eval_eq;

      std::string                        s1;
      multiprecision::number<Backend>    v1, v2;
      char                               c;
      bool                               have_hex = false;
      const char* p = s; // saved for later

      while ((0 != (c = *s)) && (c == 'x' || c == 'X' || c == '-' || c == '+' || (c >= '0' && c <= '9') || (have_hex && (c >= 'a' && c <= 'f')) || (have_hex && (c >= 'A' && c <= 'F'))))
      {
         if (c == 'x' || c == 'X')
            have_hex = true;
         s1.append(1, c);
         ++s;
      }
      v1.assign(s1);
      s1.erase();
      if (c == '/')
      {
         ++s;
         while ((0 != (c = *s)) && (c == 'x' || c == 'X' || c == '-' || c == '+' || (c >= '0' && c <= '9') || (have_hex && (c >= 'a' && c <= 'f')) || (have_hex && (c >= 'A' && c <= 'F'))))
         {
            if (c == 'x' || c == 'X')
               have_hex = true;
            s1.append(1, c);
            ++s;
         }
         v2.assign(s1);
      }
      else
         v2 = 1;
      if (*s)
      {
         BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("Could not parse the string \"") + p + std::string("\" as a valid rational number.")));
      }
      multiprecision::number<Backend> gcd;
      eval_gcd(gcd.backend(), v1.backend(), v2.backend());
      if (!eval_eq(gcd.backend(), one()))
      {
         v1 /= gcd;
         v2 /= gcd;
      }
      num() = std::move(std::move(v1).backend());
      denom() = std::move(std::move(v2).backend());
      return *this;
   }
   template <class Float>
   typename std::enable_if<std::is_floating_point<Float>::value, rational_adaptor&>::type operator=(Float i)
   {
      using default_ops::eval_eq;
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      int   e;
      Float f = frexp(i, &e);
#ifdef BOOST_HAS_FLOAT128
      f = ldexp(f, std::is_same<float128_type, Float>::value ? 113 : std::numeric_limits<Float>::digits);
      e -= std::is_same<float128_type, Float>::value ? 113 : std::numeric_limits<Float>::digits;
#else
      f = ldexp(f, std::numeric_limits<Float>::digits);
      e -= std::numeric_limits<Float>::digits;
#endif
      number<Backend> num(f);
      number<Backend> denom(1u);
      if (e > 0)
      {
         num <<= e;
      }
      else if (e < 0)
      {
         denom <<= -e;
      }
      number<Backend> gcd;
      eval_gcd(gcd.backend(), num.backend(), denom.backend());
      if (!eval_eq(gcd.backend(), one()))
      {
         num /= gcd;
         denom /= gcd;
      }
      this->num() = std::move(std::move(num).backend());
      this->denom() = std::move(std::move(denom).backend());
      return *this;
   }

   void swap(rational_adaptor& o)
   {
      m_num.swap(o.m_num);
      m_denom.swap(o.m_denom);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      using default_ops::eval_eq;
      //
      // We format the string ourselves so we can match what GMP's mpq type does:
      //
      std::string result = num().str(digits, f);
      if (!eval_eq(denom(), one()))
      {
         result.append(1, '/');
         result.append(denom().str(digits, f));
      }
      return result;
   }
   void negate()
   {
      m_num.negate();
   }
   int compare(const rational_adaptor& o) const
   {
      std::ptrdiff_t s1 = eval_get_sign(*this);
      std::ptrdiff_t s2 = eval_get_sign(o);
      if (s1 != s2)
      {
         return s1 < s2 ? -1 : 1;
      }
      else if (s1 == 0)
         return 0; // both zero.

      bool neg = false;
      if (s1 >= 0)
      {
         s1 = eval_msb(num()) + eval_msb(o.denom());
         s2 = eval_msb(o.num()) + eval_msb(denom());
      }
      else
      {
         Backend t(num());
         t.negate();
         s1 = eval_msb(t) + eval_msb(o.denom());
         t = o.num();
         t.negate();
         s2 = eval_msb(t) + eval_msb(denom());
         neg = true;
      }
      s1 -= s2;
      if (s1 < -1)
         return neg ? 1 : -1;
      else if (s1 > 1)
         return neg ? -1 : 1;

      Backend t1, t2;
      eval_multiply(t1, num(), o.denom());
      eval_multiply(t2, o.num(), denom());
      return t1.compare(t2);
   }
   //
   // Comparison with arithmetic types, default just constructs a temporary:
   //
   template <class A>
   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, int>::type compare(A i) const
   {
      rational_adaptor t;
      t = i;  //  Note: construct directly from i if supported.
      return compare(t);
   }

   Backend& num() { return m_num; }
   const Backend& num()const { return m_num; }
   Backend& denom() { return m_denom; }
   const Backend& denom()const { return m_denom; }

   #ifndef BOOST_MP_STANDALONE
   template <class Archive>
   void serialize(Archive& ar, const std::integral_constant<bool, true>&)
   {
      // Saving
      number<Backend> n(num()), d(denom());
      ar& boost::make_nvp("numerator", n);
      ar& boost::make_nvp("denominator", d);
   }
   template <class Archive>
   void serialize(Archive& ar, const std::integral_constant<bool, false>&)
   {
      // Loading
      number<Backend> n, d;
      ar& boost::make_nvp("numerator", n);
      ar& boost::make_nvp("denominator", d);
      num() = n.backend();
      denom() = d.backend();
   }
   template <class Archive>
   void serialize(Archive& ar, const unsigned int /*version*/)
   {
      using tag = typename Archive::is_saving;
      using saving_tag = std::integral_constant<bool, tag::value>;
      serialize(ar, saving_tag());
   }
   #endif // BOOST_MP_STANDALONE
   
 private:
   Backend m_num, m_denom;
};

//
// Helpers:
//
template <class T>
inline constexpr typename std::enable_if<std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_signed, bool>::type
is_minus_one(const T&)
{
   return false;
}
template <class T>
inline constexpr typename std::enable_if<!std::numeric_limits<T>::is_specialized || std::numeric_limits<T>::is_signed, bool>::type
is_minus_one(const T& val)
{
   return val == -1;
}

//
// Required non-members:
//
template <class Backend> 
inline void eval_add(rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   eval_add_subtract_imp(a, a, b, true);
}
template <class Backend> 
inline void eval_subtract(rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   eval_add_subtract_imp(a, a, b, false);
}

template <class Backend> 
inline void eval_multiply(rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   eval_multiply_imp(a, a, b.num(), b.denom());
}

template <class Backend> 
void eval_divide(rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   using default_ops::eval_divide;
   rational_adaptor<Backend> t;
   eval_divide(t, a, b);
   a = std::move(t);
}
//
// Conversions:
//
template <class R, class IntBackend>
inline typename std::enable_if<number_category<R>::value == number_kind_floating_point>::type eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
{
   //
   // The generic conversion is as good as anything we can write here:
   //
   ::boost::multiprecision::detail::generic_convert_rational_to_float(*result, backend);
}

template <class R, class IntBackend>
inline typename std::enable_if<(number_category<R>::value != number_kind_integer) && (number_category<R>::value != number_kind_floating_point) && !std::is_enum<R>::value>::type eval_convert_to(R* result, const rational_adaptor<IntBackend>& backend)
{
   using default_ops::eval_convert_to;
   R d;
   eval_convert_to(result, backend.num());
   eval_convert_to(&d, backend.denom());
   *result /= d;
}

template <class R, class Backend>
inline typename std::enable_if<number_category<R>::value == number_kind_integer>::type eval_convert_to(R* result, const rational_adaptor<Backend>& backend)
{
   using default_ops::eval_divide;
   using default_ops::eval_convert_to;
   Backend t;
   eval_divide(t, backend.num(), backend.denom());
   eval_convert_to(result, t);
}

//
// Hashing support, not strictly required, but it is used in our tests:
//
template <class Backend>
inline std::size_t hash_value(const rational_adaptor<Backend>& arg)
{
   std::size_t result = hash_value(arg.num());
   std::size_t result2 = hash_value(arg.denom());
   boost::multiprecision::detail::hash_combine(result, result2);
   return result;
}
//
// assign_components:
//
template <class Backend>
void assign_components(rational_adaptor<Backend>& result, Backend const& a, Backend const& b)
{
   using default_ops::eval_gcd;
   using default_ops::eval_divide;
   using default_ops::eval_eq;
   using default_ops::eval_is_zero;
   using default_ops::eval_get_sign;

   if (eval_is_zero(b))
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   }
   Backend g;
   eval_gcd(g, a, b);
   if (eval_eq(g, rational_adaptor<Backend>::one()))
   {
      result.num() = a;
      result.denom() = b;
   }
   else
   {
      eval_divide(result.num(), a, g);
      eval_divide(result.denom(), b, g);
   }
   if (eval_get_sign(result.denom()) < 0)
   {
      result.num().negate();
      result.denom().negate();
   }
}
//
// Again for arithmetic types, overload for whatever arithmetic types are directly supported:
//
template <class Backend, class Arithmetic1, class Arithmetic2>
inline void assign_components(rational_adaptor<Backend>& result, const Arithmetic1& a, typename std::enable_if<std::is_arithmetic<Arithmetic1>::value && std::is_arithmetic<Arithmetic2>::value, const Arithmetic2&>::type b)
{
   using default_ops::eval_gcd;
   using default_ops::eval_divide;
   using default_ops::eval_eq;

   if (b == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   }

   Backend g;
   result.num()   = a;
   eval_gcd(g, result.num(), b);
   if (eval_eq(g, rational_adaptor<Backend>::one()))
   {
      result.denom() = b;
   }
   else
   {
      eval_divide(result.num(), g);
      eval_divide(result.denom(), b, g);
   }
   if (eval_get_sign(result.denom()) < 0)
   {
      result.num().negate();
      result.denom().negate();
   }
}
template <class Backend, class Arithmetic1, class Arithmetic2>
inline void assign_components(rational_adaptor<Backend>& result, const Arithmetic1& a, typename std::enable_if<!std::is_arithmetic<Arithmetic1>::value || !std::is_arithmetic<Arithmetic2>::value, const Arithmetic2&>::type b)
{
   using default_ops::eval_gcd;
   using default_ops::eval_divide;
   using default_ops::eval_eq;

   Backend g;
   result.num()   = a;
   result.denom() = b;

   if (eval_get_sign(result.denom()) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   }

   eval_gcd(g, result.num(), result.denom());
   if (!eval_eq(g, rational_adaptor<Backend>::one()))
   {
      eval_divide(result.num(), g);
      eval_divide(result.denom(), g);
   }
   if (eval_get_sign(result.denom()) < 0)
   {
      result.num().negate();
      result.denom().negate();
   }
}
//
// Optional comparison operators:
//
template <class Backend>
inline bool eval_is_zero(const rational_adaptor<Backend>& arg)
{
   using default_ops::eval_is_zero;
   return eval_is_zero(arg.num());
}

template <class Backend>
inline int eval_get_sign(const rational_adaptor<Backend>& arg)
{
   using default_ops::eval_get_sign;
   return eval_get_sign(arg.num());
}

template <class Backend>
inline bool eval_eq(const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   using default_ops::eval_eq;
   return eval_eq(a.num(), b.num()) && eval_eq(a.denom(), b.denom());
}

template <class Backend, class Arithmetic>
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value&& std::is_integral<Arithmetic>::value, bool>::type 
   eval_eq(const rational_adaptor<Backend>& a, Arithmetic b)
{
   using default_ops::eval_eq;
   return eval_eq(a.denom(), rational_adaptor<Backend>::one()) && eval_eq(a.num(), b);
}

template <class Backend, class Arithmetic>
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value&& std::is_integral<Arithmetic>::value, bool>::type 
   eval_eq(Arithmetic b, const rational_adaptor<Backend>& a)
{
   using default_ops::eval_eq;
   return eval_eq(a.denom(), rational_adaptor<Backend>::one()) && eval_eq(a.num(), b);
}

//
// Arithmetic operations, starting with addition:
//
template <class Backend, class Arithmetic> 
void eval_add_subtract_imp(rational_adaptor<Backend>& result, const Arithmetic& arg, bool isaddition)
{
   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_add;
   using default_ops::eval_gcd;
   Backend t;
   eval_multiply(t, result.denom(), arg);
   if (isaddition)
      eval_add(result.num(), t);
   else
      eval_subtract(result.num(), t);
   //
   // There is no need to re-normalize here, we have 
   // (a + bm) / b
   // and gcd(a + bm, b) = gcd(a, b) = 1
   //
   /*
   eval_gcd(t, result.num(), result.denom());
   if (!eval_eq(t, rational_adaptor<Backend>::one()) != 0)
   {
      Backend t2;
      eval_divide(t2, result.num(), t);
      t2.swap(result.num());
      eval_divide(t2, result.denom(), t);
      t2.swap(result.denom());
   }
   */
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_add(rational_adaptor<Backend>& result, const Arithmetic& arg)
{
   eval_add_subtract_imp(result, arg, true);
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_subtract(rational_adaptor<Backend>& result, const Arithmetic& arg)
{
   eval_add_subtract_imp(result, arg, false);
}

template <class Backend>
void eval_add_subtract_imp(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b, bool isaddition)
{
   using default_ops::eval_eq;
   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_add;
   using default_ops::eval_subtract;
   //
   // Let  a = an/ad
   //      b = bn/bd
   //      g = gcd(ad, bd)
   // result = rn/rd
   //
   // Then:
   // rn = an * (bd/g) + bn * (ad/g)
   // rd = ad * (bd/g)
   //    = (ad/g) * (bd/g) * g
   //
   // And the whole thing can then be rescaled by
   //      gcd(rn, g)
   //
   Backend gcd, t1, t2, t3, t4;
   //
   // Begin by getting the gcd of the 2 denominators:
   //
   eval_gcd(gcd, a.denom(), b.denom());
   //
   // Do we have gcd > 1:
   //
   if (!eval_eq(gcd, rational_adaptor<Backend>::one()))
   {
      //
      // Scale the denominators by gcd, and put the results in t1 and t2:
      //
      eval_divide(t1, b.denom(), gcd);
      eval_divide(t2, a.denom(), gcd);
      //
      // multiply the numerators by the scale denominators and put the results in t3, t4:
      //
      eval_multiply(t3, a.num(), t1);
      eval_multiply(t4, b.num(), t2);
      //
      // Add them up:
      //
      if (isaddition)
         eval_add(t3, t4);
      else
         eval_subtract(t3, t4);
      //
      // Get the gcd of gcd and our numerator (t3):
      //
      eval_gcd(t4, t3, gcd);
      if (eval_eq(t4, rational_adaptor<Backend>::one()))
      {
         result.num() = t3;
         eval_multiply(result.denom(), t1, a.denom());
      }
      else
      {
         //
         // Uncommon case where gcd is not 1, divide the numerator
         // and the denominator terms by the new gcd.  Note we perform division
         // on the existing gcd value as this is the smallest of the 3 denominator
         // terms we'll be multiplying together, so there's a good chance it's a
         // single limb value already:
         //
         eval_divide(result.num(), t3, t4);
         eval_divide(t3, gcd, t4);
         eval_multiply(t4, t1, t2);
         eval_multiply(result.denom(), t4, t3);
      }
   }
   else
   {
      //
      // Most common case (approx 60%) where gcd is one:
      //
      eval_multiply(t1, a.num(), b.denom());
      eval_multiply(t2, a.denom(), b.num());
      if (isaddition)
         eval_add(result.num(), t1, t2);
      else
         eval_subtract(result.num(), t1, t2);
      eval_multiply(result.denom(), a.denom(), b.denom());
   }
}


template <class Backend>
inline void eval_add(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   eval_add_subtract_imp(result, a, b, true);
}
template <class Backend>
inline void eval_subtract(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   eval_add_subtract_imp(result, a, b, false);
}

template <class Backend, class Arithmetic>
void eval_add_subtract_imp(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const Arithmetic& b, bool isaddition)
{
   using default_ops::eval_add;
   using default_ops::eval_subtract;
   using default_ops::eval_multiply;

   if (&result == &a)
      return eval_add_subtract_imp(result, b, isaddition);

   eval_multiply(result.num(), a.denom(), b);
   if (isaddition)
      eval_add(result.num(), a.num());
   else
      BOOST_IF_CONSTEXPR(std::numeric_limits<Backend>::is_signed == false)
   {
      Backend t;
      eval_subtract(t, a.num(), result.num());
      result.num() = std::move(t);
   }
   else
   {
      eval_subtract(result.num(), a.num());
      result.negate();
   }
   result.denom() = a.denom();
   //
   // There is no need to re-normalize here, we have 
   // (a + bm) / b
   // and gcd(a + bm, b) = gcd(a, b) = 1
   //
}
template <class Backend, class Arithmetic>
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_add(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const Arithmetic& b)
{
   eval_add_subtract_imp(result, a, b, true);
}
template <class Backend, class Arithmetic>
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_subtract(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const Arithmetic& b)
{
   eval_add_subtract_imp(result, a, b, false);
}

//
// Multiplication:
//
template <class Backend> 
void eval_multiply_imp(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const Backend& b_num, const Backend& b_denom)
{
   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_gcd;
   using default_ops::eval_get_sign;
   using default_ops::eval_eq;

   Backend gcd_left, gcd_right, t1, t2;
   eval_gcd(gcd_left, a.num(), b_denom);
   eval_gcd(gcd_right, b_num, a.denom());
   //
   // Unit gcd's are the most likely case:
   //
   bool b_left = eval_eq(gcd_left, rational_adaptor<Backend>::one());
   bool b_right = eval_eq(gcd_right, rational_adaptor<Backend>::one());

   if (b_left && b_right)
   {
      eval_multiply(result.num(), a.num(), b_num);
      eval_multiply(result.denom(), a.denom(), b_denom);
   }
   else if (b_left)
   {
      eval_divide(t2, b_num, gcd_right);
      eval_multiply(result.num(), a.num(), t2);
      eval_divide(t1, a.denom(), gcd_right);
      eval_multiply(result.denom(), t1, b_denom);
   }
   else if (b_right)
   {
      eval_divide(t1, a.num(), gcd_left);
      eval_multiply(result.num(), t1, b_num);
      eval_divide(t2, b_denom, gcd_left);
      eval_multiply(result.denom(), a.denom(), t2);
   }
   else
   {
      eval_divide(t1, a.num(), gcd_left);
      eval_divide(t2, b_num, gcd_right);
      eval_multiply(result.num(), t1, t2);
      eval_divide(t1, a.denom(), gcd_right);
      eval_divide(t2, b_denom, gcd_left);
      eval_multiply(result.denom(), t1, t2);
   }
   //
   // We may have b_denom negative if this is actually division, if so just correct things now:
   //
   if (eval_get_sign(b_denom) < 0)
   {
      result.num().negate();
      result.denom().negate();
   }
}

template <class Backend> 
void eval_multiply(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   using default_ops::eval_multiply;

   if (&a == &b)
   {
      // squaring, gcd's are 1:
      eval_multiply(result.num(), a.num(), b.num());
      eval_multiply(result.denom(), a.denom(), b.denom());
      return;
   }
   eval_multiply_imp(result, a, b.num(), b.denom());
}

template <class Backend, class Arithmetic> 
void eval_multiply_imp(Backend& result_num, Backend& result_denom, Arithmetic arg)
{
   if (arg == 0)
   {
      result_num = rational_adaptor<Backend>::zero();
      result_denom = rational_adaptor<Backend>::one();
      return;
   }
   else if (arg == 1)
      return;

   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;

   Backend gcd, t;
   Arithmetic integer_gcd;
   eval_gcd(gcd, result_denom, arg);
   eval_convert_to(&integer_gcd, gcd);
   arg /= integer_gcd;
   if (boost::multiprecision::detail::unsigned_abs(arg) > 1)
   {
      eval_multiply(t, result_num, arg);
      result_num = std::move(t);
   }
   else if (is_minus_one(arg))
      result_num.negate();
   if (integer_gcd > 1)
   {
      eval_divide(t, result_denom, integer_gcd);
      result_denom = std::move(t);
   }
}
template <class Backend> 
void eval_multiply_imp(Backend& result_num, Backend& result_denom, Backend arg)
{
   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;
   using default_ops::eval_is_zero;
   using default_ops::eval_eq;
   using default_ops::eval_get_sign;

   if (eval_is_zero(arg))
   {
      result_num = rational_adaptor<Backend>::zero();
      result_denom = rational_adaptor<Backend>::one();
      return;
   }
   else if (eval_eq(arg, rational_adaptor<Backend>::one()))
      return;

   Backend gcd, t;
   eval_gcd(gcd, result_denom, arg);
   if (!eval_eq(gcd, rational_adaptor<Backend>::one()))
   {
      eval_divide(t, arg, gcd);
      arg = t;
   }
   else
      t = arg;
   if (eval_get_sign(arg) < 0)
      t.negate();

   if (!eval_eq(t, rational_adaptor<Backend>::one()))
   {
      eval_multiply(t, result_num, arg);
      result_num = std::move(t);
   }
   else if (eval_get_sign(arg) < 0)
      result_num.negate();
   if (!eval_eq(gcd, rational_adaptor<Backend>::one()))
   {
      eval_divide(t, result_denom, gcd);
      result_denom = std::move(t);
   }
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_multiply(rational_adaptor<Backend>& result, const Arithmetic& arg)
{
   eval_multiply_imp(result.num(), result.denom(), arg);
}

template <class Backend, class Arithmetic> 
typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && std::is_integral<Arithmetic>::value>::type
   eval_multiply_imp(rational_adaptor<Backend>& result, const Backend& a_num, const Backend& a_denom, Arithmetic b)
{
   if (b == 0)
   {
      result.num() = rational_adaptor<Backend>::zero();
      result.denom() = rational_adaptor<Backend>::one();
      return;
   }
   else if (b == 1)
   {
      result.num() = a_num;
      result.denom() = a_denom;
      return;
   }

   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;

   Backend gcd;
   Arithmetic integer_gcd;
   eval_gcd(gcd, a_denom, b);
   eval_convert_to(&integer_gcd, gcd);
   b /= integer_gcd;
   if (boost::multiprecision::detail::unsigned_abs(b) > 1)
      eval_multiply(result.num(), a_num, b);
   else if (is_minus_one(b))
   {
      result.num() = a_num;
      result.num().negate();
   }
   else
      result.num() = a_num;
   if (integer_gcd > 1)
      eval_divide(result.denom(), a_denom, integer_gcd);
   else
      result.denom() = a_denom;
}
template <class Backend> 
inline void eval_multiply_imp(rational_adaptor<Backend>& result, const Backend& a_num, const Backend& a_denom, const Backend& b)
{
   result.num() = a_num;
   result.denom() = a_denom;
   eval_multiply_imp(result.num(), result.denom(), b);
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_multiply(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const Arithmetic& b)
{
   if (&result == &a)
      return eval_multiply(result, b);

   eval_multiply_imp(result, a.num(), a.denom(), b);
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_multiply(rational_adaptor<Backend>& result, const Arithmetic& b, const rational_adaptor<Backend>& a)
{
   return eval_multiply(result, a, b);
}

//
// Division:
//
template <class Backend>
inline void eval_divide(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, const rational_adaptor<Backend>& b)
{
   using default_ops::eval_multiply;
   using default_ops::eval_get_sign;

   if (eval_get_sign(b.num()) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      return;
   }
   if (&a == &b)
   {
      // Huh? Really?
      result.num() = result.denom() = rational_adaptor<Backend>::one();
      return;
   }
   if (&result == &b)
   {
      rational_adaptor<Backend> t(b);
      return eval_divide(result, a, t);
   }
   eval_multiply_imp(result, a, b.denom(), b.num());
}

template <class Backend, class Arithmetic> 
inline typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && (std::is_integral<Arithmetic>::value || std::is_same<Arithmetic, Backend>::value)>::type
   eval_divide(rational_adaptor<Backend>& result, const Arithmetic& b, const rational_adaptor<Backend>& a)
{
   using default_ops::eval_get_sign;

   if (eval_get_sign(a.num()) == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      return;
   }
   if (&a == &result)
   {
      eval_multiply_imp(result.denom(), result.num(), b);
      result.num().swap(result.denom());
   }
   else
      eval_multiply_imp(result, a.denom(), a.num(), b);

   if (eval_get_sign(result.denom()) < 0)
   {
      result.num().negate();
      result.denom().negate();
   }
}

template <class Backend, class Arithmetic>
typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && std::is_integral<Arithmetic>::value>::type
eval_divide(rational_adaptor<Backend>& result, Arithmetic arg)
{
   if (arg == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      return;
   }
   else if (arg == 1)
      return;
   else if (is_minus_one(arg))
   {
      result.negate();
      return;
   }
   if (eval_get_sign(result) == 0)
   {
      return;
   }


   using default_ops::eval_multiply;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;
   using default_ops::eval_divide;

   Backend gcd, t;
   Arithmetic integer_gcd;
   eval_gcd(gcd, result.num(), arg);
   eval_convert_to(&integer_gcd, gcd);
   arg /= integer_gcd;

   eval_multiply(t, result.denom(), boost::multiprecision::detail::unsigned_abs(arg));
   result.denom() = std::move(t);
   if (arg < 0)
   {
      result.num().negate();
   }
   if (integer_gcd > 1)
   {
      eval_divide(t, result.num(), integer_gcd);
      result.num() = std::move(t);
   }
}
template <class Backend>
void eval_divide(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, Backend arg)
{
   using default_ops::eval_multiply;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;
   using default_ops::eval_divide;
   using default_ops::eval_is_zero;
   using default_ops::eval_eq;
   using default_ops::eval_get_sign;

   if (eval_is_zero(arg))
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      return;
   }
   else if (eval_eq(a, rational_adaptor<Backend>::one()) || (eval_get_sign(a) == 0))
   {
      if (&result != &a)
         result = a;
      return;
   }

   Backend gcd, u_arg, t;
   eval_gcd(gcd, a.num(), arg);
   bool has_unit_gcd = eval_eq(gcd, rational_adaptor<Backend>::one());
   if (!has_unit_gcd)
   {
      eval_divide(u_arg, arg, gcd);
      arg = u_arg;
   }
   else
      u_arg = arg;
   if (eval_get_sign(u_arg) < 0)
      u_arg.negate();

   eval_multiply(t, a.denom(), u_arg);
   result.denom() = std::move(t);
   
   if (!has_unit_gcd)
   {
      eval_divide(t, a.num(), gcd);
      result.num() = std::move(t);
   }
   else if (&result != &a)
      result.num() = a.num();

   if (eval_get_sign(arg) < 0)
   {
      result.num().negate();
   }
}
template <class Backend>
void eval_divide(rational_adaptor<Backend>& result, Backend arg)
{
   eval_divide(result, result, arg);
}

template <class Backend, class Arithmetic>
typename std::enable_if<std::is_convertible<Arithmetic, Backend>::value && std::is_integral<Arithmetic>::value>::type
   eval_divide(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& a, Arithmetic arg)
{
   if (&result == &a)
      return eval_divide(result, arg);
   if (arg == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
      return;
   }
   else if (arg == 1)
   {
      result = a;
      return;
   }
   else if (is_minus_one(arg))
   {
      result = a;
      result.num().negate();
      return;
   }

   if (eval_get_sign(a) == 0)
   {
      result = a;
      return;
   }

   using default_ops::eval_multiply;
   using default_ops::eval_divide;
   using default_ops::eval_gcd;
   using default_ops::eval_convert_to;

   Backend gcd;
   Arithmetic integer_gcd;
   eval_gcd(gcd, a.num(), arg);
   eval_convert_to(&integer_gcd, gcd);
   arg /= integer_gcd;
   eval_multiply(result.denom(), a.denom(), boost::multiprecision::detail::unsigned_abs(arg));

   if (integer_gcd > 1)
   {
      eval_divide(result.num(), a.num(), integer_gcd);
   }
   else
      result.num() = a.num();
   if (arg < 0)
   {
      result.num().negate();
   }
}

//
// Increment and decrement:
//
template <class Backend> 
inline void eval_increment(rational_adaptor<Backend>& arg)
{
   using default_ops::eval_add;
   eval_add(arg.num(), arg.denom());
}
template <class Backend> 
inline void eval_decrement(rational_adaptor<Backend>& arg)
{
   using default_ops::eval_subtract;
   eval_subtract(arg.num(), arg.denom());
}

//
// abs:
//
template <class Backend> 
inline void eval_abs(rational_adaptor<Backend>& result, const rational_adaptor<Backend>& arg)
{
   using default_ops::eval_abs;
   eval_abs(result.num(), arg.num());
   result.denom() = arg.denom();
}

} // namespace backends

//
// Import the backend into this namespace:
//
using boost::multiprecision::backends::rational_adaptor;
//
// Define a category for this number type, one of:
// 
//    number_kind_integer
//    number_kind_floating_point
//    number_kind_rational
//    number_kind_fixed_point
//    number_kind_complex
//
template<class Backend>
struct number_category<rational_adaptor<Backend> > : public std::integral_constant<int, number_kind_rational>
{};

template <class IntBackend>
struct expression_template_default<backends::rational_adaptor<IntBackend> > : public expression_template_default<IntBackend>
{};

template <class Backend, expression_template_option ExpressionTemplates>
struct component_type<number<rational_adaptor<Backend>, ExpressionTemplates> >
{
   typedef number<Backend, ExpressionTemplates> type;
};

template <class IntBackend, expression_template_option ET>
inline number<IntBackend, ET> numerator(const number<rational_adaptor<IntBackend>, ET>& val)
{
   return val.backend().num();
}
template <class IntBackend, expression_template_option ET>
inline number<IntBackend, ET> denominator(const number<rational_adaptor<IntBackend>, ET>& val)
{
   return val.backend().denom();
}

template <class Backend>
struct is_unsigned_number<rational_adaptor<Backend> > : public is_unsigned_number<Backend>
{};


}} // namespace boost::multiprecision

namespace std {

   template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
   class numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adaptor<IntBackend>, ExpressionTemplates> > : public std::numeric_limits<boost::multiprecision::number<IntBackend, ExpressionTemplates> >
   {
      using base_type = std::numeric_limits<boost::multiprecision::number<IntBackend> >;
      using number_type = boost::multiprecision::number<boost::multiprecision::rational_adaptor<IntBackend> >;

   public:
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = true;
      static constexpr      number_type(min)() { return (base_type::min)(); }
      static constexpr      number_type(max)() { return (base_type::max)(); }
      static constexpr number_type lowest() { return -(max)(); }
      static constexpr number_type epsilon() { return base_type::epsilon(); }
      static constexpr number_type round_error() { return epsilon() / 2; }
      static constexpr number_type infinity() { return base_type::infinity(); }
      static constexpr number_type quiet_NaN() { return base_type::quiet_NaN(); }
      static constexpr number_type signaling_NaN() { return base_type::signaling_NaN(); }
      static constexpr number_type denorm_min() { return base_type::denorm_min(); }
   };

   template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
   constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adaptor<IntBackend>, ExpressionTemplates> >::is_integer;
   template <class IntBackend, boost::multiprecision::expression_template_option ExpressionTemplates>
   constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::rational_adaptor<IntBackend>, ExpressionTemplates> >::is_exact;

} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/tommath.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_TOMMATH_HPP
#define BOOST_MP_TOMMATH_HPP

#include <cctype>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstddef>
#include <cstdlib>
#include <limits>
#include <memory>
#include <string>

#include <tommath.h>

#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/fpclassify.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>
#include <boost/multiprecision/detail/integer_ops.hpp>
#include <boost/multiprecision/detail/hash.hpp>
#include <boost/multiprecision/detail/no_exceptions_support.hpp>
#include <boost/multiprecision/detail/assert.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

namespace detail {

template <class ErrType>
inline void check_tommath_result(ErrType v)
{
   if (v != MP_OKAY)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error(mp_error_to_string(v)));
   }
}

} // namespace detail

struct tommath_int;

void eval_multiply(tommath_int& t, const tommath_int& o);
void eval_add(tommath_int& t, const tommath_int& o);

struct tommath_int
{
   using signed_types = std::tuple<std::int32_t, long long>  ;
   using unsigned_types = std::tuple<std::uint32_t, unsigned long long>;
   using float_types = std::tuple<long double>                            ;

   tommath_int()
   {
      detail::check_tommath_result(mp_init(&m_data));
   }
   tommath_int(const tommath_int& o)
   {
      detail::check_tommath_result(mp_init_copy(&m_data, const_cast< ::mp_int*>(&o.m_data)));
   }
   // rvalues:
   tommath_int(tommath_int&& o) noexcept
   {
      m_data      = o.m_data;
      o.m_data.dp = 0;
   }
   tommath_int& operator=(tommath_int&& o)
   {
      mp_exch(&m_data, &o.m_data);
      return *this;
   }
   tommath_int& operator=(const tommath_int& o)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      if (o.m_data.dp)
         detail::check_tommath_result(mp_copy(const_cast< ::mp_int*>(&o.m_data), &m_data));
      return *this;
   }
#ifndef mp_get_u64
   // Pick off 32 bit chunks for mp_set_int:
   tommath_int& operator=(unsigned long long i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      unsigned long long mask = ((1uLL << 32) - 1);
      unsigned shift = 0;
      ::mp_int t;
      detail::check_tommath_result(mp_init(&t));
      mp_zero(&m_data);
      while (i)
      {
         detail::check_tommath_result(mp_set_int(&t, static_cast<unsigned>(i & mask)));
         if (shift)
            detail::check_tommath_result(mp_mul_2d(&t, shift, &t));
         detail::check_tommath_result((mp_add(&m_data, &t, &m_data)));
         shift += 32;
         i >>= 32;
      }
      mp_clear(&t);
      return *this;
   }
#elif !defined(ULLONG_MAX) || (ULLONG_MAX != 18446744073709551615uLL)
   // Pick off 64 bit chunks for mp_set_u64:
   tommath_int& operator=(unsigned long long i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      if(sizeof(unsigned long long) * CHAR_BIT == 64)
      {
         mp_set_u64(&m_data, i);
         return *this;
      }
      unsigned long long mask = ((1uLL << 64) - 1);
      unsigned shift = 0;
      ::mp_int t;
      detail::check_tommath_result(mp_init(&t));
      mp_zero(&m_data);
      while (i)
      {
         detail::check_tommath_result(mp_set_u64(&t, static_cast<std::uint64_t>(i & mask)));
         if (shift)
            detail::check_tommath_result(mp_mul_2d(&t, shift, &t));
         detail::check_tommath_result((mp_add(&m_data, &t, &m_data)));
         shift += 64;
         i >>= 64;
      }
      mp_clear(&t);
      return *this;
   }
#else
   tommath_int& operator=(unsigned long long i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      mp_set_u64(&m_data, i);
      return *this;
   }
#endif
   tommath_int& operator=(long long i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         detail::check_tommath_result(mp_neg(&m_data, &m_data));
      return *this;
   }
#ifdef BOOST_HAS_INT128
   // Pick off 64 bit chunks for mp_set_u64:
   tommath_int& operator=(uint128_type i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));

      int128_type  mask  = ((static_cast<uint128_type>(1u) << 64) - 1);
      unsigned           shift = 0;
      ::mp_int           t;
      detail::check_tommath_result(mp_init(&t));
      mp_zero(&m_data);
      while (i)
      {
#ifndef mp_get_u32
         detail::check_tommath_result(mp_set_long_long(&t, static_cast<std::uint64_t>(i & mask)));
#else
         mp_set_u64(&t, static_cast<std::uint64_t>(i & mask));
#endif
         if (shift)
            detail::check_tommath_result(mp_mul_2d(&t, shift, &t));
         detail::check_tommath_result((mp_add(&m_data, &t, &m_data)));
         shift += 64;
         i >>= 64;
      }
      mp_clear(&t);
      return *this;
   }
   tommath_int& operator=(int128_type i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         detail::check_tommath_result(mp_neg(&m_data, &m_data));
      return *this;
   }
#endif
   //
   // Note that although mp_set_int takes an unsigned long as an argument
   // it only sets the first 32-bits to the result, and ignores the rest.
   // So use uint32_t as the largest type to pass to this function.
   //
   tommath_int& operator=(std::uint32_t i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
#ifndef mp_get_u32
      detail::check_tommath_result((mp_set_int(&m_data, i)));
#else
      mp_set_u32(&m_data, i);
#endif
      return *this;
   }
   tommath_int& operator=(std::int32_t i)
   {
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      bool neg = i < 0;
      *this    = boost::multiprecision::detail::unsigned_abs(i);
      if (neg)
         detail::check_tommath_result(mp_neg(&m_data, &m_data));
      return *this;
   }
   template <class F>
   tommath_int& assign_float(F a)
   {
      BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp;

      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));

      if (a == 0)
      {
#ifndef mp_get_u32
         detail::check_tommath_result(mp_set_int(&m_data, 0));
#else
         mp_set_i32(&m_data, 0);
#endif
         return *this;
      }

      if (a == 1)
      {
#ifndef mp_get_u32
         detail::check_tommath_result(mp_set_int(&m_data, 1));
#else
         mp_set_i32(&m_data, 1);
#endif
         return *this;
      }

      BOOST_MP_ASSERT(!BOOST_MP_ISINF(a));
      BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a));

      int         e;
      F f, term;
#ifndef mp_get_u32
      detail::check_tommath_result(mp_set_int(&m_data, 0u));
#else
      mp_set_i32(&m_data, 0);
#endif
      ::mp_int t;
      detail::check_tommath_result(mp_init(&t));

      f = frexp(a, &e);

#ifdef MP_DIGIT_BIT
      constexpr const int shift = std::numeric_limits<int>::digits - 1;
      using part_type = int     ;
#else
      constexpr const int  shift = std::numeric_limits<std::int64_t>::digits - 1;
      using part_type = std::int64_t;
#endif

      while (f)
      {
         // extract int sized bits from f:
         f    = ldexp(f, shift);
         term = floor(f);
         e -= shift;
         detail::check_tommath_result(mp_mul_2d(&m_data, shift, &m_data));
         if (term > 0)
         {
#ifndef mp_get_u64
            detail::check_tommath_result(mp_set_int(&t, static_cast<part_type>(term)));
#else
            mp_set_i64(&t, static_cast<part_type>(term));
#endif
            detail::check_tommath_result(mp_add(&m_data, &t, &m_data));
         }
         else
         {
#ifndef mp_get_u64
            detail::check_tommath_result(mp_set_int(&t, static_cast<part_type>(-term)));
#else
            mp_set_i64(&t, static_cast<part_type>(-term));
#endif
            detail::check_tommath_result(mp_sub(&m_data, &t, &m_data));
         }
         f -= term;
      }
      if (e > 0)
         detail::check_tommath_result(mp_mul_2d(&m_data, e, &m_data));
      else if (e < 0)
      {
         tommath_int t2;
         detail::check_tommath_result(mp_div_2d(&m_data, -e, &m_data, &t2.data()));
      }
      mp_clear(&t);
      return *this;
   }
   tommath_int& operator=(long double a)
   {
      return assign_float(a);
   }
#ifdef BOOST_HAS_FLOAT128
   tommath_int& operator= (float128_type a)
   {
      return assign_float(a);
   }
#endif
   tommath_int& operator=(const char* s)
   {
      //
      // We don't use libtommath's own routine because it doesn't error check the input :-(
      //
      if (m_data.dp == nullptr)
         detail::check_tommath_result(mp_init(&m_data));
      std::size_t n  = s ? std::strlen(s) : 0;
      *this          = static_cast<std::uint32_t>(0u);
      unsigned radix = 10;
      bool     isneg = false;
      if (n && (*s == '-'))
      {
         --n;
         ++s;
         isneg = true;
      }
      if (n && (*s == '0'))
      {
         if ((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
         {
            radix = 16;
            s += 2;
            n -= 2;
         }
         else
         {
            radix = 8;
            n -= 1;
         }
      }
      if (n)
      {
         if (radix == 8 || radix == 16)
         {
            unsigned shift = radix == 8 ? 3 : 4;
#ifndef MP_DIGIT_BIT
            unsigned block_count = DIGIT_BIT / shift;
#else
            unsigned block_count = MP_DIGIT_BIT / shift;
#endif
            unsigned               block_shift = shift * block_count;
            unsigned long long val, block;
            while (*s)
            {
               block = 0;
               for (unsigned i = 0; (i < block_count); ++i)
               {
                  if (*s >= '0' && *s <= '9')
                     val = *s - '0';
                  else if (*s >= 'a' && *s <= 'f')
                     val = 10 + *s - 'a';
                  else if (*s >= 'A' && *s <= 'F')
                     val = 10 + *s - 'A';
                  else
                     val = 400;
                  if (val > radix)
                  {
                     BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected content found while parsing character string."));
                  }
                  block <<= shift;
                  block |= val;
                  if (!*++s)
                  {
                     // final shift is different:
                     block_shift = (i + 1) * shift;
                     break;
                  }
               }
               detail::check_tommath_result(mp_mul_2d(&data(), block_shift, &data()));
               if (data().used)
                  data().dp[0] |= block;
               else
                  *this = block;
            }
         }
         else
         {
            // Base 10, we extract blocks of size 10^9 at a time, that way
            // the number of multiplications is kept to a minimum:
            std::uint32_t block_mult = 1000000000;
            while (*s)
            {
               std::uint32_t block = 0;
               for (unsigned i = 0; i < 9; ++i)
               {
                  std::uint32_t val;
                  if (*s >= '0' && *s <= '9')
                     val = *s - '0';
                  else
                     BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected character encountered in input."));
                  block *= 10;
                  block += val;
                  if (!*++s)
                  {
                     constexpr const std::uint32_t block_multiplier[9] = {10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
                     block_mult                                       = block_multiplier[i];
                     break;
                  }
               }
               tommath_int t;
               t = block_mult;
               eval_multiply(*this, t);
               t = block;
               eval_add(*this, t);
            }
         }
      }
      if (isneg)
         this->negate();
      return *this;
   }
   std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f) const
   {
      BOOST_MP_ASSERT(m_data.dp);
      int base = 10;
      if ((f & std::ios_base::oct) == std::ios_base::oct)
         base = 8;
      else if ((f & std::ios_base::hex) == std::ios_base::hex)
         base = 16;
      //
      // sanity check, bases 8 and 16 are only available for positive numbers:
      //
      if ((base != 10) && m_data.sign)
         BOOST_MP_THROW_EXCEPTION(std::runtime_error("Formatted output in bases 8 or 16 is only available for positive numbers"));

      int s;
      detail::check_tommath_result(mp_radix_size(const_cast< ::mp_int*>(&m_data), base, &s));
      std::unique_ptr<char[]> a(new char[s + 1]);
#ifndef mp_to_binary
      detail::check_tommath_result(mp_toradix_n(const_cast< ::mp_int*>(&m_data), a.get(), base, s + 1));
#else
      std::size_t written;
      detail::check_tommath_result(mp_to_radix(&m_data, a.get(), s + 1, &written, base));
#endif
      std::string result = a.get();
      if (f & std::ios_base::uppercase)
         for (size_t i = 0; i < result.length(); ++i)
            result[i] = std::toupper(result[i]);
      if ((base != 10) && (f & std::ios_base::showbase))
      {
         int         pos = result[0] == '-' ? 1 : 0;
         const char* pp  = base == 8 ? "0" : (f & std::ios_base::uppercase) ? "0X" : "0x";
         result.insert(static_cast<std::string::size_type>(pos), pp);
      }
      if ((f & std::ios_base::showpos) && (result[0] != '-'))
         result.insert(static_cast<std::string::size_type>(0), 1, '+');
      if (((f & std::ios_base::uppercase) == 0) && (base == 16))
      {
         for (std::size_t i = 0; i < result.size(); ++i)
            result[i] = std::tolower(result[i]);
      }
      return result;
   }
   ~tommath_int()
   {
      if (m_data.dp)
         mp_clear(&m_data);
   }
   void negate()
   {
      BOOST_MP_ASSERT(m_data.dp);
      detail::check_tommath_result(mp_neg(&m_data, &m_data));
   }
   int compare(const tommath_int& o) const
   {
      BOOST_MP_ASSERT(m_data.dp && o.m_data.dp);
      return mp_cmp(const_cast< ::mp_int*>(&m_data), const_cast< ::mp_int*>(&o.m_data));
   }
   template <class V>
   int compare(V v) const
   {
      tommath_int d;
      tommath_int t(*this);
      detail::check_tommath_result(mp_shrink(&t.data()));
      d = v;
      return t.compare(d);
   }
   ::mp_int& data()
   {
      BOOST_MP_ASSERT(m_data.dp);
      return m_data;
   }
   const ::mp_int& data() const
   {
      BOOST_MP_ASSERT(m_data.dp);
      return m_data;
   }
   void swap(tommath_int& o) noexcept
   {
      mp_exch(&m_data, &o.data());
   }

 protected:
   ::mp_int m_data;
};

#ifndef mp_isneg
#define BOOST_MP_TOMMATH_BIT_OP_CHECK(x) \
   if (SIGN(&x.data()))                  \
   BOOST_MP_THROW_EXCEPTION(std::runtime_error("Bitwise operations on libtommath negative valued integers are disabled as they produce unpredictable results"))
#else
#define BOOST_MP_TOMMATH_BIT_OP_CHECK(x) \
   if (mp_isneg(&x.data()))              \
   BOOST_MP_THROW_EXCEPTION(std::runtime_error("Bitwise operations on libtommath negative valued integers are disabled as they produce unpredictable results"))
#endif

int eval_get_sign(const tommath_int& val);

inline void eval_add(tommath_int& t, const tommath_int& o)
{
   detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_subtract(tommath_int& t, const tommath_int& o)
{
   detail::check_tommath_result(mp_sub(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_multiply(tommath_int& t, const tommath_int& o)
{
   detail::check_tommath_result(mp_mul(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_divide(tommath_int& t, const tommath_int& o)
{
   using default_ops::eval_is_zero;
   tommath_int temp;
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   detail::check_tommath_result(mp_div(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data(), &temp.data()));
}
inline void eval_modulus(tommath_int& t, const tommath_int& o)
{
   using default_ops::eval_is_zero;
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   bool neg  = eval_get_sign(t) < 0;
   bool neg2 = eval_get_sign(o) < 0;
   detail::check_tommath_result(mp_mod(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
   if ((neg != neg2) && (eval_get_sign(t) != 0))
   {
      t.negate();
      detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
      t.negate();
   }
   else if (neg && (t.compare(o) == 0))
   {
      mp_zero(&t.data());
   }
}
template <class UI>
inline void eval_left_shift(tommath_int& t, UI i)
{
   detail::check_tommath_result(mp_mul_2d(&t.data(), static_cast<unsigned>(i), &t.data()));
}
template <class UI>
inline void eval_right_shift(tommath_int& t, UI i)
{
   using default_ops::eval_decrement;
   using default_ops::eval_increment;
   bool        neg = eval_get_sign(t) < 0;
   tommath_int d;
   if (neg)
      eval_increment(t);
   detail::check_tommath_result(mp_div_2d(&t.data(), static_cast<unsigned>(i), &t.data(), &d.data()));
   if (neg)
      eval_decrement(t);
}
template <class UI>
inline void eval_left_shift(tommath_int& t, const tommath_int& v, UI i)
{
   detail::check_tommath_result(mp_mul_2d(const_cast< ::mp_int*>(&v.data()), static_cast<unsigned>(i), &t.data()));
}
/*
template <class UI>
inline void eval_right_shift(tommath_int& t, const tommath_int& v, UI i)
{
   tommath_int d;
   detail::check_tommath_result(mp_div_2d(const_cast< ::mp_int*>(&v.data()), static_cast<unsigned long>(i), &t.data(), &d.data()));
}
*/
inline void eval_bitwise_and(tommath_int& result, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_and(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
}

inline void eval_bitwise_or(tommath_int& result, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_or(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
}

inline void eval_bitwise_xor(tommath_int& result, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_xor(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
}

inline void eval_add(tommath_int& t, const tommath_int& p, const tommath_int& o)
{
   detail::check_tommath_result(mp_add(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_subtract(tommath_int& t, const tommath_int& p, const tommath_int& o)
{
   detail::check_tommath_result(mp_sub(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_multiply(tommath_int& t, const tommath_int& p, const tommath_int& o)
{
   detail::check_tommath_result(mp_mul(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
}
inline void eval_divide(tommath_int& t, const tommath_int& p, const tommath_int& o)
{
   using default_ops::eval_is_zero;
   tommath_int d;
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   detail::check_tommath_result(mp_div(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data(), &d.data()));
}
inline void eval_modulus(tommath_int& t, const tommath_int& p, const tommath_int& o)
{
   using default_ops::eval_is_zero;
   if (eval_is_zero(o))
      BOOST_MP_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
   bool neg  = eval_get_sign(p) < 0;
   bool neg2 = eval_get_sign(o) < 0;
   detail::check_tommath_result(mp_mod(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
   if ((neg != neg2) && (eval_get_sign(t) != 0))
   {
      t.negate();
      detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
      t.negate();
   }
   else if (neg && (t.compare(o) == 0))
   {
      mp_zero(&t.data());
   }
}

inline void eval_bitwise_and(tommath_int& result, const tommath_int& u, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_and(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
}

inline void eval_bitwise_or(tommath_int& result, const tommath_int& u, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_or(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
}

inline void eval_bitwise_xor(tommath_int& result, const tommath_int& u, const tommath_int& v)
{
   BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
   BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
   detail::check_tommath_result(mp_xor(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
}
/*
inline void eval_complement(tommath_int& result, const tommath_int& u)
{
   //
   // Although this code works, it doesn't really do what the user might expect....
   // and it's hard to see how it ever could.  Disabled for now:
   //
   result = u;
   for(int i = 0; i < result.data().used; ++i)
   {
      result.data().dp[i] = MP_MASK & ~(result.data().dp[i]);
   }
   //
   // We now need to pad out the left of the value with 1's to round up to a whole number of
   // CHAR_BIT * sizeof(mp_digit) units.  Otherwise we'll end up with a very strange number of
   // bits set!
   //
   unsigned shift = result.data().used * DIGIT_BIT;    // How many bits we're actually using
   // How many bits we actually need, reduced by one to account for a mythical sign bit:
   int padding = result.data().used * std::numeric_limits<mp_digit>::digits - shift - 1;
   while(padding >= std::numeric_limits<mp_digit>::digits)
      padding -= std::numeric_limits<mp_digit>::digits;

   // Create a mask providing the extra bits we need and add to result:
   tommath_int mask;
   mask = static_cast<long long>((1u << padding) - 1);
   eval_left_shift(mask, shift);
   add(result, mask);
}
*/
inline bool eval_is_zero(const tommath_int& val)
{
   return mp_iszero(&val.data());
}
inline int eval_get_sign(const tommath_int& val)
{
#ifndef mp_isneg
   return mp_iszero(&val.data()) ? 0 : SIGN(&val.data()) ? -1 : 1;
#else
   return mp_iszero(&val.data()) ? 0 : mp_isneg(&val.data()) ? -1 : 1;
#endif
}

inline void eval_convert_to(unsigned long long* result, const tommath_int& val)
{
   if (mp_isneg(&val.data()))
   {
      BOOST_MP_THROW_EXCEPTION(std::range_error("Converting negative arbitrary precision value to unsigned."));
   }
#ifdef MP_DEPRECATED
   *result = mp_get_ull(&val.data());
#else
   *result = mp_get_long_long(const_cast<mp_int*>(&val.data()));
#endif
}

inline void eval_convert_to(long long* result, const tommath_int& val)
{
   if (!mp_iszero(&val.data()) && (mp_count_bits(const_cast<::mp_int*>(&val.data())) > std::numeric_limits<long long>::digits))
   {
      *result = mp_isneg(&val.data()) ? (std::numeric_limits<long long>::min)() : (std::numeric_limits<long long>::max)();
      return;
   }
#ifdef MP_DEPRECATED
   unsigned long long r = mp_get_mag_ull(&val.data());
#else
   unsigned long long r = mp_get_long_long(const_cast<mp_int*>(&val.data()));
#endif
   if (mp_isneg(&val.data()))
      *result = -static_cast<long long>(r);
   else
      *result = r;
}

#ifdef BOOST_HAS_INT128
inline void eval_convert_to(uint128_type* result, const tommath_int& val)
{
#ifdef MP_DEPRECATED
   if (mp_ubin_size(&val.data()) > sizeof(uint128_type))
   {
      *result = ~static_cast<uint128_type>(0);
      return;
   }
   unsigned char buf[sizeof(uint128_type)];
   std::size_t   len;
   detail::check_tommath_result(mp_to_ubin(&val.data(), buf, sizeof(buf), &len));
   *result = 0;
   for (std::size_t i = 0; i < len; ++i)
   {
      *result <<= CHAR_BIT;
      *result |= buf[i];
   }
#else
   std::size_t len = mp_unsigned_bin_size(const_cast<mp_int*>(&val.data()));
   if (len > sizeof(uint128_type))
   {
      *result = ~static_cast<uint128_type>(0);
      return;
   }
   unsigned char buf[sizeof(uint128_type)];
   detail::check_tommath_result(mp_to_unsigned_bin(const_cast<mp_int*>(&val.data()), buf));
   *result = 0;
   for (std::size_t i = 0; i < len; ++i)
   {
      *result <<= CHAR_BIT;
      *result |= buf[i];
   }
#endif
}
inline void eval_convert_to(int128_type* result, const tommath_int& val)
{
   uint128_type r;
   eval_convert_to(&r, val);
   if (mp_isneg(&val.data()))
      *result = -static_cast<int128_type>(r);
   else
      *result = r;
}
#endif
#if defined(BOOST_HAS_FLOAT128)
inline void eval_convert_to(float128_type* result, const tommath_int& val) noexcept
{
   *result = float128_procs::strtoflt128(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
#endif
inline void eval_convert_to(long double* result, const tommath_int& val) noexcept
{
   *result = std::strtold(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
inline void eval_convert_to(double* result, const tommath_int& val) noexcept
{
   *result = std::strtod(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}
inline void eval_convert_to(float* result, const tommath_int& val) noexcept
{
   *result = std::strtof(val.str(0, std::ios_base::scientific).c_str(), nullptr);
}


inline void eval_abs(tommath_int& result, const tommath_int& val)
{
   detail::check_tommath_result(mp_abs(const_cast< ::mp_int*>(&val.data()), &result.data()));
}
inline void eval_gcd(tommath_int& result, const tommath_int& a, const tommath_int& b)
{
   detail::check_tommath_result(mp_gcd(const_cast< ::mp_int*>(&a.data()), const_cast< ::mp_int*>(&b.data()), const_cast< ::mp_int*>(&result.data())));
}
inline void eval_lcm(tommath_int& result, const tommath_int& a, const tommath_int& b)
{
   detail::check_tommath_result(mp_lcm(const_cast< ::mp_int*>(&a.data()), const_cast< ::mp_int*>(&b.data()), const_cast< ::mp_int*>(&result.data())));
}
inline void eval_powm(tommath_int& result, const tommath_int& base, const tommath_int& p, const tommath_int& m)
{
   if (eval_get_sign(p) < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
   }
   detail::check_tommath_result(mp_exptmod(const_cast< ::mp_int*>(&base.data()), const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&m.data()), &result.data()));
}

inline void eval_qr(const tommath_int& x, const tommath_int& y,
                    tommath_int& q, tommath_int& r)
{
   detail::check_tommath_result(mp_div(const_cast< ::mp_int*>(&x.data()), const_cast< ::mp_int*>(&y.data()), &q.data(), &r.data()));
}

inline std::size_t eval_lsb(const tommath_int& val)
{
   int c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return mp_cnt_lsb(const_cast< ::mp_int*>(&val.data()));
}

inline std::size_t eval_msb(const tommath_int& val)
{
   int c = eval_get_sign(val);
   if (c == 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand."));
   }
   if (c < 0)
   {
      BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined."));
   }
   return mp_count_bits(const_cast< ::mp_int*>(&val.data())) - 1;
}

template <class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value, Integer>::type eval_integer_modulus(const tommath_int& x, Integer val)
{
#ifndef MP_DIGIT_BIT
   constexpr const mp_digit m = (static_cast<mp_digit>(1) << DIGIT_BIT) - 1;
#else
   constexpr const mp_digit m = (static_cast<mp_digit>(1) << MP_DIGIT_BIT) - 1;
#endif
   if (val <= m)
   {
      mp_digit d;
      detail::check_tommath_result(mp_mod_d(const_cast< ::mp_int*>(&x.data()), static_cast<mp_digit>(val), &d));
      return d;
   }
   else
   {
      return default_ops::eval_integer_modulus(x, val);
   }
}
template <class Integer>
inline typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value, Integer>::type eval_integer_modulus(const tommath_int& x, Integer val)
{
   return eval_integer_modulus(x, boost::multiprecision::detail::unsigned_abs(val));
}

inline std::size_t hash_value(const tommath_int& val)
{
   std::size_t result = 0;
   std::size_t len    = val.data().used;
   for (std::size_t i = 0; i < len; ++i)
      boost::multiprecision::detail::hash_combine(result, val.data().dp[i]);
   boost::multiprecision::detail::hash_combine(result, val.data().sign);
   return result;
}

} // namespace backends

using boost::multiprecision::backends::tommath_int;

template <>
struct number_category<tommath_int> : public std::integral_constant<int, number_kind_integer>
{};

using tom_int = number<tommath_int>          ;
using tommath_rational = rational_adaptor<tommath_int>;
using tom_rational = number<tommath_rational>     ;
}
} // namespace boost::multiprecision

namespace std {

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates>;

 public:
   static constexpr bool is_specialized = true;
   //
   // Largest and smallest numbers are bounded only by available memory, set
   // to zero:
   //
   static number_type(min)()
   {
      return number_type();
   }
   static number_type(max)()
   {
      return number_type();
   }
   static number_type                        lowest() { return (min)(); }
   static constexpr int                digits       = INT_MAX;
   static constexpr int                digits10     = (INT_MAX / 1000) * 301L;
   static constexpr int                max_digits10 = digits10 + 3;
   static constexpr bool               is_signed    = true;
   static constexpr bool               is_integer   = true;
   static constexpr bool               is_exact     = true;
   static constexpr int                radix        = 2;
   static number_type                        epsilon() { return number_type(); }
   static number_type                        round_error() { return number_type(); }
   static constexpr int                min_exponent      = 0;
   static constexpr int                min_exponent10    = 0;
   static constexpr int                max_exponent      = 0;
   static constexpr int                max_exponent10    = 0;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static number_type                        infinity() { return number_type(); }
   static number_type                        quiet_NaN() { return number_type(); }
   static number_type                        signaling_NaN() { return number_type(); }
   static number_type                        denorm_min() { return number_type(); }
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::round_style;

} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/explicit_conversion.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright Vicente J. Botet Escriba 2009-2011
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_EXPLICIT_CONVERSION_HPP
#define BOOST_MP_EXPLICIT_CONVERSION_HPP

#include <type_traits>
#include <boost/multiprecision/detail/standalone_config.hpp>
#include <boost/multiprecision/detail/number_base.hpp> // number_category

namespace boost {
namespace multiprecision {
namespace detail {

template <unsigned int N>
struct dummy_size
{};

template <typename S, typename T>
struct has_generic_interconversion
{
   using type = typename std::conditional<
       is_number<S>::value && is_number<T>::value,
       typename std::conditional<
           number_category<S>::value == number_kind_integer,
           typename std::conditional<
               number_category<T>::value == number_kind_integer || number_category<T>::value == number_kind_floating_point || number_category<T>::value == number_kind_rational || number_category<T>::value == number_kind_fixed_point,
               std::true_type,
               std::false_type >::type,
           typename std::conditional<
               number_category<S>::value == number_kind_rational,
               typename std::conditional<
                   number_category<T>::value == number_kind_rational || number_category<T>::value == number_kind_rational,
                   std::true_type,
                   std::false_type >::type,
               typename std::conditional<
                   number_category<T>::value == number_kind_floating_point,
                   std::true_type,
                   std::false_type >::type>::type>::type,
       std::false_type >::type;
};

template <typename S, typename T>
struct is_explicitly_convertible_imp
{
   template <typename S1, typename T1>
   static int selector(dummy_size<static_cast<unsigned int>(sizeof(new T1(std::declval<S1>())))>*);

   template <typename S1, typename T1>
   static char selector(...);

   static constexpr bool value = sizeof(selector<S, T>(nullptr)) == sizeof(int);

   using type = std::integral_constant<bool, value>;
};

template <typename From, typename To>
struct is_explicitly_convertible : public is_explicitly_convertible_imp<From, To>::type
{
};

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/extract_exponent_type.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_EXTRACT_EXPONENT_TYPE_HPP
#define BOOST_MP_EXTRACT_EXPONENT_TYPE_HPP

#include <boost/multiprecision/number.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

template <class Backend, int cat>
struct extract_exponent_type
{
   using type = int;
};
template <class Backend>
struct extract_exponent_type<Backend, number_kind_floating_point>
{
   using type = typename Backend::exponent_type;
};

}}} // namespace boost::multiprecision::backends

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_backend.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_IS_BACKEND_HPP
#define BOOST_MP_IS_BACKEND_HPP

#include <type_traits>
#include <boost/multiprecision/detail/number_base.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class T>
struct has_signed_types
{
   template <class U>
   static double check(U*, typename U::signed_types* = nullptr);
   static char   check(...);
   static T* get();
   static constexpr bool value = sizeof(check(get())) == sizeof(double);
};
template <class T>
struct has_unsigned_types
{
   template <class U>
   static double check(U*, typename U::unsigned_types* = nullptr);
   static char   check(...);
   static T* get();
   static constexpr bool value = sizeof(check(get())) == sizeof(double);
};
template <class T>
struct has_float_types
{
   template <class U>
   static double check(U*, typename U::float_types* = nullptr);
   static char   check(...);
   static T* get();
   static constexpr bool value = sizeof(check(get())) == sizeof(double);
};

template <class T>
struct is_backend : public std::integral_constant<bool, has_signed_types<T>::value && has_unsigned_types<T>::value && has_float_types<T>::value> {};

template <class Backend>
struct other_backend
{
   using type = typename std::conditional<
       std::is_same<number<Backend>, number<Backend, et_on> >::value,
       number<Backend, et_off>, number<Backend, et_on> >::type;
};

template <class B, class V>
struct number_from_backend
{
   using type = typename std::conditional<
       std::is_convertible<V, number<B> >::value,
       number<B>,
       typename other_backend<B>::type>::type;
};

template <bool b, class T, class U>
struct is_first_backend_imp : public std::false_type {};

template <class T, class U>
    struct is_first_backend_imp<true, T, U> : public std::integral_constant < bool, std::is_convertible<U, number<T, et_on> >::value || std::is_convertible<U, number<T, et_off> >::value> {};

template <class T, class U>
struct is_first_backend : is_first_backend_imp<is_backend<T>::value, T, U>
{};

template <bool b, class T, class U>
struct is_second_backend_imp
{
   static constexpr bool value = false;
};
template <class T, class U>
struct is_second_backend_imp<true, T, U>
{
   static constexpr bool value = (std::is_convertible<T, number<U, et_on> >::value || std::is_convertible<T, number<U, et_off> >::value) && !is_first_backend<T, U>::value;
};

template <class T, class U>
struct is_second_backend : is_second_backend_imp<is_backend<U>::value, T, U>
{};

}
}
} // namespace boost::multiprecision::detail

#endif // BOOST_MP_IS_BACKEND_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_byte_container.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_IS_BYTE_CONTAINER_HPP
#define BOOST_IS_BYTE_CONTAINER_HPP

#include <iterator>
#include <type_traits>

namespace boost { namespace multiprecision { namespace detail {

template <class T>
struct has_member_const_iterator
{
   template <class U>
   static double         check(U*, typename U::const_iterator* = nullptr);
   static char           check(...);
   static T*             get();
   static constexpr bool value = sizeof(check(get())) == sizeof(double);
};


template <class C, class Iterator>
struct is_byte_container_imp_2
{
   using container_value_type = typename std::remove_cv<typename std::iterator_traits<typename C::const_iterator>::value_type>::type;
   static constexpr bool value = boost::multiprecision::detail::is_integral<container_value_type>::value && (sizeof(container_value_type) == 1);
};

template <class C>
struct is_byte_container_imp_2<C, void> : public std::false_type
{};

template <class C, bool b>
struct is_byte_container_imp : public is_byte_container_imp_2<C, typename C::const_iterator>
{
};

template <class C>
struct is_byte_container_imp<C, false> : public std::false_type
{};

template <class C>
struct is_byte_container : public is_byte_container_imp<C, has_member_const_iterator<C>::value>
{};

}}} // namespace boost::multiprecision::detail

#endif // BOOST_IS_BYTE_CONTAINER_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_complex.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_IS_COMPLEX_HPP
#define BOOST_MP_IS_COMPLEX_HPP

#include <type_traits>
#include <complex>

namespace boost { namespace multiprecision { namespace detail {

template <class T> struct is_complex : public std::integral_constant<bool, false> {};

template <class T> struct is_complex<std::complex<T> > : public std::integral_constant<bool, true> {};

}
}
} // namespace boost::multiprecision::detail

#endif // BOOST_MP_IS_BACKEND_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_convertible_arithmetic.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_IS_CONVERTIBLE_ARITHMETIC_HPP
#define BOOST_IS_CONVERTIBLE_ARITHMETIC_HPP

#include <type_traits>
#include <boost/multiprecision/detail/number_base.hpp>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class V, class Backend>
struct is_convertible_arithmetic
{
   static constexpr bool value = boost::multiprecision::detail::is_arithmetic<V>::value;
};
//
// For extension types, we don't *require* interoperability, 
// so only enable it if we can convert the type to the backend
// losslessly, ie not via conversion to a narrower type.
// Note that backends with templated constructors/=operators
// will not be selected here, so these need to either specialize
// this trait, or provide a proper non-template constructor/=operator
// for the extension types it supports.
//
#ifdef BOOST_HAS_FLOAT128
template <class Backend>
struct is_convertible_arithmetic<float128_type, Backend>
{
   static constexpr bool value = std::is_assignable<Backend, convertible_to<float128_type>>::value;
};
#endif
#ifdef BOOST_HAS_INT128
template <class Backend>
struct is_convertible_arithmetic<int128_type, Backend>
{
   static constexpr bool value = std::is_assignable<Backend, convertible_to<int128_type>>::value;
};
template <class Backend>
struct is_convertible_arithmetic<uint128_type, Backend>
{
   static constexpr bool value = std::is_assignable<Backend, convertible_to<uint128_type>>::value;
};
#endif

}}} // namespace boost::multiprecision::detail

#endif // BOOST_IS_BYTE_CONTAINER_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_restricted_conversion.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright Vicente J. Botet Escriba 2009-2011
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_IS_RESTRICTED_CONVERSION_HPP
#define BOOST_MP_IS_RESTRICTED_CONVERSION_HPP

#include <boost/multiprecision/traits/explicit_conversion.hpp>
#include <boost/multiprecision/detail/number_base.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class From, class To>
struct is_lossy_conversion
{
   static constexpr bool category_conditional_is_true =
         (   (static_cast<boost::multiprecision::number_category_type>(number_category<From>::value) == number_kind_floating_point)
          && (static_cast<boost::multiprecision::number_category_type>(number_category<To  >::value) == number_kind_integer))
      || (   (static_cast<boost::multiprecision::number_category_type>(number_category<From>::value) == number_kind_rational)
          && (static_cast<boost::multiprecision::number_category_type>(number_category<To  >::value) == number_kind_integer))
      || (   (static_cast<boost::multiprecision::number_category_type>(number_category<From>::value) == number_kind_fixed_point)
          && (static_cast<boost::multiprecision::number_category_type>(number_category<To  >::value) == number_kind_integer))
      ||     (static_cast<boost::multiprecision::number_category_type>(number_category<From>::value) == number_kind_unknown)
      ||     (static_cast<boost::multiprecision::number_category_type>(number_category<To  >::value) == number_kind_unknown);

   using type = typename std::conditional<category_conditional_is_true,
                                          std::integral_constant<bool, true>,
                                          std::integral_constant<bool, false>>::type;

   static constexpr bool value = type::value;
};

template <typename From, typename To>
struct is_restricted_conversion
{
   using type = typename std::conditional<
       ((is_explicitly_convertible<From, To>::value && !std::is_convertible<From, To>::value) || is_lossy_conversion<From, To>::value),
       std::integral_constant<bool, true>,
       std::integral_constant<bool, false>>::type;
   static constexpr const bool                     value = type::value;
};

}}} // namespace boost::multiprecision::detail

#endif // BOOST_MP_IS_RESTRICTED_CONVERSION_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/is_variable_precision.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_IS_VARIABLE_PRECISION_HPP
#define BOOST_MP_IS_VARIABLE_PRECISION_HPP

#include <boost/multiprecision/detail/number_base.hpp>

namespace boost { namespace multiprecision { namespace detail {

template <class Backend>
struct is_variable_precision : public std::integral_constant<bool, false>
{};

template <class Backend, expression_template_option ExpressionTemplates>
struct is_variable_precision<number<Backend, ExpressionTemplates> > : public is_variable_precision<Backend>
{};

}
}
} // namespace boost::multiprecision::detail

#endif // BOOST_MP_IS_BACKEND_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/max_digits10.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_MAX_DIGITS10_HPP
#define BOOST_MP_MAX_DIGITS10_HPP

namespace boost {
namespace multiprecision {
namespace detail {

template <unsigned digits>
struct calc_max_digits10
{
   static constexpr unsigned max_digits_10(unsigned d)
   {
      //
      // We need ceil(log10(2) * d) + 1 decimal places to
      // guarantee round tripping, see: https://www.exploringbinary.com/number-of-digits-required-for-round-trip-conversions/
      // and references therein.  Since log10(2) is irrational, then d*log10(2) will
      // never be exactly an integer so we can replace by trunc(log10(2) * d) + 2
      // and avoid the call to ceil:
      //
      return static_cast<unsigned>(0.301029995663981195213738894724493026768189881462108541310 * d) + 2;
   }
   static constexpr unsigned value = max_digits_10(digits);
};

template <std::size_t digits>
struct calc_max_digits10_s
{
   static constexpr std::size_t max_digits_10(std::size_t d)
   {
      //
      // We need ceil(log10(2) * d) + 1 decimal places to
      // guarantee round tripping, see: https://www.exploringbinary.com/number-of-digits-required-for-round-trip-conversions/
      // and references therein.  Since log10(2) is irrational, then d*log10(2) will
      // never be exactly an integer so we can replace by trunc(log10(2) * d) + 2
      // and avoid the call to ceil:
      //
      return static_cast<std::size_t>(static_cast<std::size_t>(0.301029995663981195213738894724493026768189881462108541310 * static_cast<double>(d)) + 2u);
   }
   static constexpr std::size_t value = max_digits_10(digits);
};

template <unsigned digits>
struct calc_digits10
{
   static constexpr unsigned digits_10(unsigned d)
   {
      //
      // We need floor(log10(2) * (d-1)), see: 
      // https://www.exploringbinary.com/number-of-digits-required-for-round-trip-conversions/
      // and references therein.
      //
      return static_cast<unsigned>(0.301029995663981195213738894724493026768189881462108541310 * static_cast<double>(d - 1u));
   }
   static constexpr unsigned value = digits_10(digits);
};

template <std::size_t digits>
struct calc_digits10_s
{
   static constexpr std::size_t digits_10(std::size_t d)
   {
      //
      // We need floor(log10(2) * (d-1)), see: 
      // https://www.exploringbinary.com/number-of-digits-required-for-round-trip-conversions/
      // and references therein.
      //
      return static_cast<std::size_t>(0.301029995663981195213738894724493026768189881462108541310 * static_cast<double>(d - 1u));
   }
   static constexpr std::size_t value = digits_10(digits);
};

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/std_integer_traits.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-2022 John Maddock.
//  Copyright 2022 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_STD_INTEGER_TRAITS_HPP
#define BOOST_MP_STD_INTEGER_TRAITS_HPP

#include <type_traits>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace boost {
namespace multiprecision {
namespace detail {

template <class T>
struct is_signed : public std::is_signed<T> {};
template <class T>
struct is_unsigned : public std::is_unsigned<T> {};
template <class T>
struct is_integral : public std::is_integral<T> {};
template <class T>
struct is_arithmetic : public std::is_arithmetic<T> {};
template <class T>
struct make_unsigned : public std::make_unsigned<T> {};
template <class T>
struct make_signed : public std::make_signed<T> {};

#ifdef BOOST_HAS_INT128

template <>
struct is_signed<int128_type> : public std::true_type {};
template <>
struct is_signed<uint128_type> : public std::false_type {};
template <>
struct is_unsigned<int128_type> : public std::false_type {};
template <>
struct is_unsigned<uint128_type> : public std::true_type {};
template <>
struct is_integral<int128_type> : public std::true_type {};
template <>
struct is_integral<uint128_type> : public std::true_type {};
template <>
struct is_arithmetic<int128_type> : public std::true_type {};
template <>
struct is_arithmetic<uint128_type> : public std::true_type {};
template <>
struct make_unsigned<int128_type>
{
   using type = uint128_type;
};
template <>
struct make_unsigned<uint128_type>
{
   using type = uint128_type;
};
template <>
struct make_signed<int128_type>
{
   using type = int128_type;
};
template <>
struct make_signed<uint128_type>
{
   using type = int128_type;
};

#endif

// C++17-esque helpers
#if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304L
template <typename T>
BOOST_INLINE_CONSTEXPR bool is_signed_v = is_signed<T>::value;
template <typename T>
BOOST_INLINE_CONSTEXPR bool is_unsigned_v = is_unsigned<T>::value;
template <typename T>
BOOST_INLINE_CONSTEXPR bool is_integral_v = is_integral<T>::value;
template <typename T>
BOOST_INLINE_CONSTEXPR bool is_arithmetic_v = is_arithmetic<T>::value;
#endif

template <typename T>
using make_unsigned_t = typename make_unsigned<T>::type;
template <typename T>
using make_signed_t = typename make_signed<T>::type;

}}} // namespace boost::multiprecision::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/multiprecision/traits/transcendental_reduction_type.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MP_TRANSCENDENTAL_REDUCTION_TYPE_HPP
#define BOOST_MP_TRANSCENDENTAL_REDUCTION_TYPE_HPP

namespace boost { namespace multiprecision { namespace detail {

template <class T>
struct transcendental_reduction_type
{
   using type = T;
};

}
}
} // namespace boost::multiprecision::detail

#endif // BOOST_MP_TRANSCENDENTAL_REDUCTION_TYPE_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/include/boost/version.hpp
================================================
//  Boost version.hpp configuration header file  ------------------------------//

//  (C) Copyright John maddock 1999. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/config for documentation

#ifndef BOOST_VERSION_HPP
#define BOOST_VERSION_HPP

//
//  Caution: this is the only Boost header that is guaranteed
//  to change with every Boost release. Including this header
//  will cause a recompile every time a new Boost version is
//  used.
//
//  BOOST_VERSION % 100 is the patch level
//  BOOST_VERSION / 100 % 1000 is the minor version
//  BOOST_VERSION / 100000 is the major version

#define BOOST_VERSION 108100

//
//  BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
//  but as a *string* in the form "x_y[_z]" where x is the major version
//  number, y is the minor version number, and z is the patch level if not 0.
//  This is used by <config/auto_link.hpp> to select which library version to link to.

#define BOOST_LIB_VERSION "1_81"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/index.html
================================================
<html>
   <head>
      <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
   </head>
   <body>
      <P>
         Automatic redirection failed, please go to <a href="doc/html/index.html">doc/html/index.html</a>.
      </P>
      <P>Copyright&nbsp;John Maddock 2001</P>
      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
   </body>
</html>




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/meta/libraries.json
================================================
{
    "key": "multiprecision",
    "name": "Multiprecision",
    "authors": [
        "John Maddock",
        "Christopher Kormanyos"
    ],
    "description": "Extended precision arithmetic types for floating point, integer andrational arithmetic.",
    "category": [
        "Math"
    ],
    "maintainers": [
        "John Maddock <john -at- johnmaddock.co.uk>",
        "christopher Kormanyos <e_float -at- yahoo.com>"
    ],
    "cxxstd": "11"
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/Jamfile.v2
================================================
# copyright John Maddock 2012
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or copy at 
# http://www.boost.org/LICENSE_1_0.txt.

import modules ;
import path ;
import ../../config/checks/config : requires ;

local ntl-path = [ modules.peek : NTL_PATH ] ;
local gmp_path = [ modules.peek : GMP_PATH ] ;
local mpfr_path = [ modules.peek : MPFR_PATH ] ;
local tommath_path = [ modules.peek : TOMMATH_PATH ] ;

project : requirements 
   <target-os>freebsd:<linkflags>"-lrt" 
   <target-os>linux:<linkflags>"-lrt" 
   <toolset>pgi:<linkflags>"-lrt" 
   <include>$(gmp_path) 
   <include>$(gmp_path)/mpfr 
   <include>$(gmp_path)/gmpfrxx 
   <include>$(mpfr_path)
   <include>$(tommath_path)
   <include>../../.. 
   <search>$(gmp_path) 
   <search>$(mpfr_path) 
   <search>$(mpfr_path)/build.vc10/lib/Win32/Debug
   <search>$(tommath_path) 
   # We set these to make it easier to set up and test GMP and MPFR under Win32:
   <toolset>msvc:<runtime-link>static
   <toolset>msvc:<link>static
   <toolset>intel-win:<runtime-link>static
   <toolset>intel-win:<link>static
   <define>BOOST_ALL_NO_LIB
   <debug-symbols>off
   <define>NDEBUG=1
   ;


lib gmp ;
lib mpfr ;
lib quadmath ;
lib f2c ;

if $(tommath_path)
{
   TOMMATH = [ GLOB $(tommath_path) : *.c ] ;
}
else
{
   lib tommath ;
   TOMMATH = tommath ;
}

test-suite performance :

[ exe performance_test : performance_test.cpp 
            performance_test_files/test01.cpp  performance_test_files/test18.cpp  performance_test_files/test35.cpp
            performance_test_files/test02.cpp  performance_test_files/test19.cpp  performance_test_files/test36.cpp
            performance_test_files/test03.cpp  performance_test_files/test20.cpp  performance_test_files/test37.cpp
            performance_test_files/test04.cpp  performance_test_files/test21.cpp  performance_test_files/test38.cpp
            performance_test_files/test05.cpp  performance_test_files/test22.cpp  performance_test_files/test39.cpp
            performance_test_files/test06.cpp  performance_test_files/test23.cpp  performance_test_files/test40.cpp
            performance_test_files/test07.cpp  performance_test_files/test24.cpp  performance_test_files/test41.cpp
            performance_test_files/test08.cpp  performance_test_files/test25.cpp  performance_test_files/test42.cpp
            performance_test_files/test09.cpp  performance_test_files/test26.cpp  performance_test_files/test43.cpp
            performance_test_files/test10.cpp  performance_test_files/test27.cpp  performance_test_files/test44.cpp
            performance_test_files/test11.cpp  performance_test_files/test28.cpp  performance_test_files/test45.cpp
            performance_test_files/test12.cpp  performance_test_files/test29.cpp  performance_test_files/test46.cpp
            performance_test_files/test13.cpp  performance_test_files/test30.cpp  performance_test_files/test47.cpp
            performance_test_files/test14.cpp  performance_test_files/test31.cpp  performance_test_files/test48.cpp
            performance_test_files/test15.cpp  performance_test_files/test32.cpp  performance_test_files/test49.cpp
            performance_test_files/test16.cpp  performance_test_files/test33.cpp  performance_test_files/test50.cpp
            performance_test_files/test17.cpp  performance_test_files/test34.cpp  performance_test_files/test51.cpp            
            /boost/system//boost_system
          : release
          [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <define>TEST_MPQ <source>gmp : ]
          [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
          [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) : ]
          <define>TEST_CPP_DEC_FLOAT
          <define>TEST_CPP_BIN_FLOAT
          <define>TEST_CPP_INT
          <define>TEST_CPP_INT_RATIONAL
          [ requires cxx11_auto_declarations cxx11_allocator ]
          ]

[ exe miller_rabin_performance : miller_rabin_performance.cpp 
            miller_rabin_performance_files/test01.cpp  miller_rabin_performance_files/test07.cpp
            miller_rabin_performance_files/test02.cpp  miller_rabin_performance_files/test08.cpp
            miller_rabin_performance_files/test03.cpp  miller_rabin_performance_files/test09.cpp
            miller_rabin_performance_files/test04.cpp  miller_rabin_performance_files/test10.cpp
            miller_rabin_performance_files/test05.cpp  miller_rabin_performance_files/test11.cpp
            miller_rabin_performance_files/test06.cpp  miller_rabin_performance_files/test12.cpp
            /boost/system//boost_system /boost/chrono//boost_chrono 
          : release
          [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <source>gmp : ]
          [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
          [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) : ]
          <define>TEST_CPP_DEC_FLOAT
          <define>TEST_CPP_INT
          ]

[ exe sf_performance : sf_performance.cpp sf_performance_basic.cpp sf_performance_bessel.cpp 
                     sf_performance_nct.cpp sf_performance_poly.cpp
                     sf_performance_files/sf_performance_basic_1.cpp    sf_performance_files/sf_performance_nct_06.cpp
                     sf_performance_files/sf_performance_basic_2.cpp    sf_performance_files/sf_performance_nct_07.cpp
                     sf_performance_files/sf_performance_basic_3.cpp    sf_performance_files/sf_performance_nct_08.cpp
                     sf_performance_files/sf_performance_basic_4.cpp    sf_performance_files/sf_performance_nct_09.cpp
                     sf_performance_files/sf_performance_basic_5.cpp    sf_performance_files/sf_performance_nct_10.cpp
                     sf_performance_files/sf_performance_basic_6.cpp    sf_performance_files/sf_performance_nct_11.cpp
                     sf_performance_files/sf_performance_basic_7.cpp    sf_performance_files/sf_performance_nct_12.cpp
                     sf_performance_files/sf_performance_basic_8.cpp    sf_performance_files/sf_performance_nct_13.cpp
                     sf_performance_files/sf_performance_basic_9.cpp    sf_performance_files/sf_performance_nct_14.cpp
                     sf_performance_files/sf_performance_bessel_01.cpp  sf_performance_files/sf_performance_nct_15.cpp
                     sf_performance_files/sf_performance_bessel_02.cpp  sf_performance_files/sf_performance_nct_16.cpp
                     sf_performance_files/sf_performance_bessel_03.cpp  sf_performance_files/sf_performance_nct_17.cpp
                     sf_performance_files/sf_performance_bessel_04.cpp  sf_performance_files/sf_performance_nct_18.cpp
                     sf_performance_files/sf_performance_bessel_05.cpp  sf_performance_files/sf_performance_nct_19.cpp
                     sf_performance_files/sf_performance_bessel_06.cpp  sf_performance_files/sf_performance_nct_20.cpp
                     sf_performance_files/sf_performance_bessel_07.cpp  sf_performance_files/sf_performance_poly_01.cpp
                     sf_performance_files/sf_performance_bessel_08.cpp  sf_performance_files/sf_performance_poly_02.cpp
                     sf_performance_files/sf_performance_bessel_09.cpp  sf_performance_files/sf_performance_poly_03.cpp
                     sf_performance_files/sf_performance_bessel_10.cpp  sf_performance_files/sf_performance_poly_04.cpp
                     sf_performance_files/sf_performance_bessel_11.cpp  sf_performance_files/sf_performance_poly_05.cpp
                     sf_performance_files/sf_performance_bessel_12.cpp  sf_performance_files/sf_performance_poly_06.cpp
                     sf_performance_files/sf_performance_bessel_13.cpp  sf_performance_files/sf_performance_poly_07.cpp
                     sf_performance_files/sf_performance_bessel_14.cpp  sf_performance_files/sf_performance_poly_08.cpp
                     sf_performance_files/sf_performance_bessel_15.cpp  sf_performance_files/sf_performance_poly_09.cpp
                     sf_performance_files/sf_performance_bessel_16.cpp  sf_performance_files/sf_performance_poly_10.cpp
                     sf_performance_files/sf_performance_bessel_17.cpp  sf_performance_files/sf_performance_poly_11.cpp
                     sf_performance_files/sf_performance_bessel_18.cpp  sf_performance_files/sf_performance_poly_12.cpp
                     sf_performance_files/sf_performance_bessel_19.cpp  sf_performance_files/sf_performance_poly_13.cpp
                     sf_performance_files/sf_performance_nct_01.cpp     sf_performance_files/sf_performance_poly_14.cpp
                     sf_performance_files/sf_performance_nct_02.cpp     sf_performance_files/sf_performance_poly_15.cpp
                     sf_performance_files/sf_performance_nct_03.cpp     sf_performance_files/sf_performance_poly_16.cpp
                     sf_performance_files/sf_performance_nct_04.cpp     sf_performance_files/sf_performance_poly_17.cpp
                     sf_performance_files/sf_performance_nct_05.cpp     sf_performance_files/sf_performance_poly_18.cpp
                     /boost/system//boost_system /boost/chrono//boost_chrono /boost/thread//boost_thread
          : release
          [ check-target-builds ../config//has_gmp : <define>TEST_MPF <define>TEST_MPZ <source>gmp : ]
          [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr : ]
          [ check-target-builds ../config//has_float128 : <source>quadmath : ]
          <define>TEST_CPP_DEC_FLOAT
          <define>TEST_CPP_BIN_FLOAT
          <define>TEST_FLOAT
          <toolset>msvc:<cxxflags>-bigobj
          [ requires cxx11_auto_declarations cxx11_allocator ]
          ]
          
[ exe delaunay_test : delaunay_test.cpp /boost/system//boost_system /boost/chrono//boost_chrono ]

[ exe voronoi_performance : voronoi_performance.cpp /boost/system//boost_system /boost/chrono//boost_chrono
   : release
          [ check-target-builds ../config//has_gmp : <define>TEST_GMP <source>gmp : ]
          [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) : ]
   ]

[ obj obj_linpack_benchmark_mpfr : linpack-benchmark.cpp
          : release
          [ check-target-builds ../config//has_mpfr : : <build>no ]
          <define>TEST_MPFR_50
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_mpf : linpack-benchmark.cpp 
          : release
          [ check-target-builds ../config//has_gmp : : <build>no ]
          <define>TEST_MPF_50
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_cpp_float : linpack-benchmark.cpp
          : release
          <define>TEST_CPP_DEC_FLOAT
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_double : linpack-benchmark.cpp
          : release
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_native_float128 : linpack-benchmark.cpp
          : release
          <define>NATIVE_FLOAT128
          [ check-target-builds ../config//has_float128 : : <build>no ]
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_float128 : linpack-benchmark.cpp
          : release
          <define>TEST_FLOAT128
          [ check-target-builds ../config//has_float128 : : <build>no ]
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_cpp_quad_float : linpack-benchmark.cpp
          : release
          <define>TEST_CPP_BIN_FLOAT_QUAD
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ obj obj_linpack_benchmark_cpp_oct_float : linpack-benchmark.cpp
          : release
          <define>TEST_CPP_BIN_FLOAT_OCT
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_mpfr : obj_linpack_benchmark_mpfr mpfr f2c gmp
          : release
          [ check-target-builds ../config//has_mpfr : : <build>no ]
          <define>TEST_MPFR_50
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_mpf : obj_linpack_benchmark_mpf gmp  f2c
          : release
          [ check-target-builds ../config//has_gmp : : <build>no ]
          <define>TEST_MPF_50
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_cpp_float : obj_linpack_benchmark_cpp_float  f2c
          : release
          <define>TEST_CPP_DEC_FLOAT
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_double : obj_linpack_benchmark_double  f2c
          : release
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_native_float128 : obj_linpack_benchmark_native_float128  f2c quadmath
          : release
          [ check-target-builds ../config//has_float128 : : <build>no ]
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_float128 : obj_linpack_benchmark_float128  f2c quadmath
          : release
          [ check-target-builds ../config//has_float128 : : <build>no ]
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_cpp_quad_float : obj_linpack_benchmark_cpp_quad_float  f2c
          : release
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

[ exe linpack_benchmark_cpp_oct_float : obj_linpack_benchmark_cpp_oct_float  f2c
          : release
          [ check-target-builds ../config//has_f2c : : <build>no ]
          ]

;
#
# These cause conflicting targets for the build system when building
# with multiple compilers, so they are not part of the regular CI tests:
#
test-suite performance_install :

[ install miller_rabin_install : miller_rabin_performance : <location>. ]
[ install performance_test_install : performance_test  : <location>. ]
[ install sf_performance_install : sf_performance   : <location>. ]
[ install . : linpack_benchmark_double linpack_benchmark_cpp_float linpack_benchmark_mpf linpack_benchmark_mpfr linpack_benchmark_native_float128 linpack_benchmark_float128 linpack_benchmark_cpp_quad_float linpack_benchmark_cpp_oct_float ]
[ install delaunay_install : delaunay_test : <location>. ]
[ install voronoi_install : voronoi_performance : <location>. ]

;


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/arithmetic_backend.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MATH_FLOAT_BACKEND_HPP
#define BOOST_MATH_FLOAT_BACKEND_HPP

#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdint>
#include <boost/lexical_cast.hpp>
#include <boost/math/concepts/real_concept.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/container_hash/hash.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4389 4244 4018 4244 4127)
#endif

template <class Arithmetic>
struct arithmetic_backend
{
   typedef std::tuple<short, int, long, long long>                                 signed_types;
   typedef std::tuple<unsigned short, unsigned, unsigned long, unsigned long long> unsigned_types;
   typedef std::tuple<float, double, long double>                                  float_types;
   typedef int                                                                    exponent_type;

   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend() : m_value(0) {}
   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend(const arithmetic_backend& o) : m_value(o.m_value) {}
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend(const A& o, const typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value && std::numeric_limits<A>::is_specialized>::type* = nullptr) : m_value(o) {}
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend(const arithmetic_backend<A>& o) : m_value(o.data()) {}
   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend& operator=(const arithmetic_backend& o)
   {
      m_value = o.m_value;
      return *this;
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, arithmetic_backend&>::type operator=(A i)
   {
      m_value = static_cast<Arithmetic>(i);
      return *this;
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR arithmetic_backend& operator=(const arithmetic_backend<A>& i)
   {
      m_value = i.data();
      return *this;
   }
   arithmetic_backend& operator=(const char* s)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         m_value = boost::lexical_cast<Arithmetic>(s);
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const bad_lexical_cast&)
      {
         throw std::runtime_error(std::string("Unable to interpret the string provided: \"") + s + std::string("\" as a compatible number type."));
      }
#endif
      return *this;
   }
   BOOST_MP_CXX14_CONSTEXPR void swap(arithmetic_backend& o)
   {
      std::swap(m_value, o.m_value);
   }
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
   {
      std::stringstream ss;
      ss.flags(f);
      ss << std::setprecision(digits ? digits : std::numeric_limits<Arithmetic>::digits10 + 4) << m_value;
      return ss.str();
   }
   BOOST_MP_CXX14_CONSTEXPR void do_negate(const std::integral_constant<bool, true>&)
   {
      m_value = 1 + ~m_value;
   }
   BOOST_MP_CXX14_CONSTEXPR void do_negate(const std::integral_constant<bool, false>&)
   {
      m_value = -m_value;
   }
   BOOST_MP_CXX14_CONSTEXPR void negate()
   {
      do_negate(std::integral_constant<bool, boost::multiprecision::detail::is_unsigned<Arithmetic>::value>());
   }
   BOOST_MP_CXX14_CONSTEXPR int compare(const arithmetic_backend& o) const
   {
      return m_value > o.m_value ? 1 : (m_value < o.m_value ? -1 : 0);
   }
   template <class A>
   BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, int>::type compare(A i) const
   {
      return m_value > static_cast<Arithmetic>(i) ? 1 : (m_value < static_cast<Arithmetic>(i) ? -1 : 0);
   }
   BOOST_MP_CXX14_CONSTEXPR Arithmetic& data() { return m_value; }
   BOOST_MP_CXX14_CONSTEXPR const Arithmetic& data() const { return m_value; }

 private:
   Arithmetic m_value;
};

template <class R, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<R>::value>::type eval_convert_to(R* result, const arithmetic_backend<Arithmetic>& backend)
{
   using c_type = typename std::common_type<R, Arithmetic>::type;

   constexpr const c_type max = static_cast<c_type>((std::numeric_limits<R>::max)());
   constexpr const c_type min = static_cast<c_type>((std::numeric_limits<R>::min)());
   c_type ct  = static_cast<c_type>(backend.data());

   if ((backend.data() < 0) && !std::numeric_limits<R>::is_signed)
   {
      BOOST_THROW_EXCEPTION(std::range_error("Attempt to convert negative number to unsigned type."));
   }

   if (ct > max)
   {
      *result = boost::multiprecision::detail::is_signed<R>::value ? (std::numeric_limits<R>::max)() : static_cast<R>(backend.data());
   }
   else if (std::numeric_limits<Arithmetic>::is_signed && (ct < min))
   {
      *result = (std::numeric_limits<R>::min)();
   }
   else
   {
      *result = backend.data();
   }
}

template <class R, class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!boost::multiprecision::detail::is_integral<R>::value && !std::is_enum<R>::value>::type eval_convert_to(R* result, const arithmetic_backend<Arithmetic>& backend)
{
   *result = backend.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_eq(const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   return a.data() == b.data();
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value, bool>::type eval_eq(const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   return a.data() == static_cast<Arithmetic>(b);
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_lt(const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   return a.data() < b.data();
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value, bool>::type eval_lt(const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   return a.data() < static_cast<Arithmetic>(b);
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_gt(const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   return a.data() > b.data();
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value, bool>::type eval_gt(const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   return a.data() > static_cast<Arithmetic>(b);
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   result.data() += o.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   result.data() -= o.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   result.data() *= o.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::numeric_limits<Arithmetic>::has_infinity>::type eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   result.data() /= o.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::numeric_limits<Arithmetic>::has_infinity>::type eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   if (!o.data())
      BOOST_THROW_EXCEPTION(std::overflow_error("Divide by zero"));
   result.data() /= o.data();
}

template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_add(arithmetic_backend<Arithmetic>& result, const A2& o)
{
   result.data() += o;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_subtract(arithmetic_backend<Arithmetic>& result, const A2& o)
{
   result.data() -= o;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_multiply(arithmetic_backend<Arithmetic>& result, const A2& o)
{
   result.data() *= o;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(boost::multiprecision::detail::is_arithmetic<A2>::value && !std::numeric_limits<Arithmetic>::has_infinity)>::type
eval_divide(arithmetic_backend<Arithmetic>& result, const A2& o)
{
   if (!o)
      BOOST_THROW_EXCEPTION(std::overflow_error("Divide by zero"));
   result.data() /= o;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(boost::multiprecision::detail::is_arithmetic<A2>::value && std::numeric_limits<Arithmetic>::has_infinity)>::type
eval_divide(arithmetic_backend<Arithmetic>& result, const A2& o)
{
   result.data() /= o;
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_add(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = a.data() + b.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_subtract(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = a.data() - b.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_multiply(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = a.data() * b.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<std::numeric_limits<Arithmetic>::has_infinity>::type eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = a.data() / b.data();
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!std::numeric_limits<Arithmetic>::has_infinity>::type eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   if (!b.data())
      BOOST_THROW_EXCEPTION(std::overflow_error("Divide by zero"));
   result.data() = a.data() / b.data();
}

template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_add(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   result.data() = a.data() + b;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_subtract(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   result.data() = a.data() - b;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A2>::value>::type eval_multiply(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   result.data() = a.data() * b;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(boost::multiprecision::detail::is_arithmetic<A2>::value && !std::numeric_limits<Arithmetic>::has_infinity)>::type
eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   if (!b)
      BOOST_THROW_EXCEPTION(std::overflow_error("Divide by zero"));
   result.data() = a.data() / b;
}
template <class Arithmetic, class A2>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(boost::multiprecision::detail::is_arithmetic<A2>::value && std::numeric_limits<Arithmetic>::has_infinity)>::type
eval_divide(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const A2& b)
{
   result.data() = a.data() / b;
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR bool eval_is_zero(const arithmetic_backend<Arithmetic>& val)
{
   return val.data() == 0;
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    (!std::numeric_limits<Arithmetic>::is_specialized || std::numeric_limits<Arithmetic>::is_signed), int>::type
eval_get_sign(const arithmetic_backend<Arithmetic>& val)
{
   return val.data() == 0 ? 0 : val.data() < 0 ? -1 : 1;
}
template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
    !(std::numeric_limits<Arithmetic>::is_specialized || std::numeric_limits<Arithmetic>::is_signed), int>::type
eval_get_sign(const arithmetic_backend<Arithmetic>& val)
{
   return val.data() == 0 ? 0 : 1;
}

template <class T>
inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value, T>::type abs(T v) { return v; }

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_abs(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   using boost::multiprecision::backends::abs;
   using std::abs;
   result.data() = abs(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fabs(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   result.data() = std::abs(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_floor(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = floor(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_ceil(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = ceil(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_sqrt(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = sqrt(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR int eval_fpclassify(const arithmetic_backend<Arithmetic>& o)
{
   return (boost::math::fpclassify)(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_trunc(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = trunc(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_round(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = round(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_frexp(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, int* v)
{
   BOOST_MATH_STD_USING
   result.data() = frexp(a.data(), v);
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_ldexp(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, int v)
{
   BOOST_MATH_STD_USING
   result.data() = ldexp(a.data(), v);
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_exp(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = exp(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_log(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = log(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_log10(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = log10(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_sin(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = sin(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_cos(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = cos(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_tan(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = tan(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_acos(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = acos(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_asin(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = asin(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_atan(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = atan(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_sinh(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = sinh(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_cosh(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = cosh(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_tanh(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& o)
{
   BOOST_MATH_STD_USING
   result.data() = tanh(o.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_fmod(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   BOOST_MATH_STD_USING
   result.data() = fmod(a.data(), b.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_pow(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   BOOST_MATH_STD_USING
   result.data() = pow(a.data(), b.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_atan2(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   BOOST_MATH_STD_USING
   result.data() = atan2(a.data(), b.data());
}

template <class Arithmetic, class I>
inline BOOST_MP_CXX14_CONSTEXPR void eval_left_shift(arithmetic_backend<Arithmetic>& result, I val)
{
   result.data() <<= val;
}

template <class Arithmetic, class I>
inline BOOST_MP_CXX14_CONSTEXPR void eval_right_shift(arithmetic_backend<Arithmetic>& result, I val)
{
   result.data() >>= val;
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_modulus(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a)
{
   result.data() %= a.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_and(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a)
{
   result.data() &= a.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_or(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a)
{
   result.data() |= a.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_bitwise_xor(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a)
{
   result.data() ^= a.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_complement(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a)
{
   result.data() = ~a.data();
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_gcd(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = boost::integer::gcd(a.data(), b.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR void eval_lcm(arithmetic_backend<Arithmetic>& result, const arithmetic_backend<Arithmetic>& a, const arithmetic_backend<Arithmetic>& b)
{
   result.data() = boost::integer::lcm(a.data(), b.data());
}

template <class Arithmetic>
inline BOOST_MP_CXX14_CONSTEXPR std::size_t hash_value(const arithmetic_backend<Arithmetic>& a)
{
   boost::hash<Arithmetic> hasher;
   return hasher(a.data());
}

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

} // namespace backends

using boost::multiprecision::backends::arithmetic_backend;

template <class Arithmetic>
struct number_category<arithmetic_backend<Arithmetic> > : public std::integral_constant<int, boost::multiprecision::detail::is_integral<Arithmetic>::value ? number_kind_integer : number_kind_floating_point>
{};

namespace detail {

template <class Backend>
struct double_precision_type;

template <class Arithmetic, boost::multiprecision::expression_template_option ET>
struct double_precision_type<number<arithmetic_backend<Arithmetic>, ET> >
{
   typedef number<arithmetic_backend<typename double_precision_type<Arithmetic>::type>, ET> type;
};
template <>
struct double_precision_type<arithmetic_backend<std::int32_t> >
{
   typedef arithmetic_backend<std::int64_t> type;
};

} // namespace detail

}} // namespace boost::multiprecision
#if !(defined(__SGI_STL_PORT) || defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS))
//
// We shouldn't need these to get code to compile, however for the sake of
// "level playing field" performance comparisons they avoid the very slow
// lexical_cast's that would otherwise take place.  Definition has to be guarded
// by the inverse of pp-logic in real_concept.hpp which defines these as a workaround
// for STLPort plus some other old/broken standartd libraries.
//
namespace boost { namespace math { namespace tools {

template <>
inline unsigned int real_cast<unsigned int, concepts::real_concept>(concepts::real_concept r)
{
   return static_cast<unsigned int>(r.value());
}

template <>
inline int real_cast<int, concepts::real_concept>(concepts::real_concept r)
{
   return static_cast<int>(r.value());
}

template <>
inline long real_cast<long, concepts::real_concept>(concepts::real_concept r)
{
   return static_cast<long>(r.value());
}

// Converts from T to narrower floating-point types, float, double & long double.

template <>
inline float real_cast<float, concepts::real_concept>(concepts::real_concept r)
{
   return static_cast<float>(r.value());
}
template <>
inline double real_cast<double, concepts::real_concept>(concepts::real_concept r)
{
   return static_cast<double>(r.value());
}
template <>
inline long double real_cast<long double, concepts::real_concept>(concepts::real_concept r)
{
   return r.value();
}

}}} // namespace boost::math::tools
#endif

namespace std {

template <class Arithmetic, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> > : public std::numeric_limits<Arithmetic>
{
   typedef std::numeric_limits<Arithmetic>                                                                           base_type;
   typedef boost::multiprecision::number<boost::multiprecision::arithmetic_backend<Arithmetic>, ExpressionTemplates> number_type;

 public:
   static constexpr number_type(min)() noexcept { return (base_type::min)(); }
   static constexpr number_type(max)() noexcept { return (base_type::max)(); }
   static constexpr number_type lowest() noexcept { return -(max)(); }
   static constexpr number_type epsilon() noexcept { return base_type::epsilon(); }
   static constexpr number_type round_error() noexcept { return epsilon() / 2; }
   static constexpr number_type infinity() noexcept { return base_type::infinity(); }
   static constexpr number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
   static constexpr number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
   static constexpr number_type denorm_min() noexcept { return base_type::denorm_min(); }
};

template <>
class numeric_limits<boost::math::concepts::real_concept> : public std::numeric_limits<long double>
{
   typedef std::numeric_limits<long double>    base_type;
   typedef boost::math::concepts::real_concept number_type;

 public:
   static const number_type(min)() noexcept { return (base_type::min)(); }
   static const number_type(max)() noexcept { return (base_type::max)(); }
   static const number_type lowest() noexcept { return -(max)(); }
   static const number_type epsilon() noexcept { return base_type::epsilon(); }
   static const number_type round_error() noexcept { return epsilon() / 2; }
   static const number_type infinity() noexcept { return base_type::infinity(); }
   static const number_type quiet_NaN() noexcept { return base_type::quiet_NaN(); }
   static const number_type signaling_NaN() noexcept { return base_type::signaling_NaN(); }
   static const number_type denorm_min() noexcept { return base_type::denorm_min(); }
};

} // namespace std

#include <boost/multiprecision/detail/integer_ops.hpp>

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/cpp_bin_float_conversion_performance.cpp
================================================
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/math/special_functions.hpp>
#include <boost/chrono.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <typename T>
double my_convert_to_double(const T& x)
{
   double ret = 0;
   if (isfinite(x))
   {
      if (x.backend().exponent() >= -1023 - 52 && x != 0)
      {
         if (x.backend().exponent() <= 1023)
         {
            int     e  = x.backend().exponent();
            T       y  = ldexp(abs(x), 55 - e);
            T       t  = trunc(y);
            int64_t ti = t.template convert_to<int64_t>();
            if ((ti & 1) == 0)
            {
               if (t < y)
                  ti |= 1;
            }
            if (e >= -1023 + 1)
            {
               ret = ldexp(double(ti), e - 55);
            }
            else
            {
               // subnormal
               typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<128, boost::multiprecision::backends::digit_base_2> > cpp_bin_float128_t;
               cpp_bin_float128_t                                                                                                               sx = ldexp(cpp_bin_float128_t(ti), e - 55);
               sx += DBL_MIN;
               e                     = -1023 + 1;
               cpp_bin_float128_t sy = ldexp(sx, 55 - e);
               cpp_bin_float128_t st = trunc(sy);
               ti                    = st.convert_to<int64_t>();
               if ((ti & 1) == 0)
               {
                  if (st < sy)
                     ti |= 1;
               }
               ret = ldexp(double(ti), e - 55) - DBL_MIN;
            }
         }
         else
         {
            // overflow
            ret = HUGE_VAL;
         }
      }
   }
   else
   {
      if (isnan(x))
         return nan("");
      // inf
      ret = HUGE_VAL;
   }
   return x.backend().sign() ? -ret : ret;
}

template <class T>
void test_conversion_time(const char* name)
{
   std::cout << "Testing times for type: " << name << "\n";
   std::vector<T> values;

   for (unsigned i = 0; i < 10000000; ++i)
   {
      values.push_back(generate_random<T>());
   }

   boost::chrono::duration<double>                 time;
   stopwatch<boost::chrono::high_resolution_clock> c;

   double total = 0;

   for (typename std::vector<T>::const_iterator i = values.begin(); i != values.end(); ++i)
   {
      total += my_convert_to_double(*i);
   }

   time = c.elapsed();
   std::cout << std::setprecision(3) << std::fixed;
   std::cout << "Reference time: " << std::setw(7) << std::right << time << " (total sum = " << total << ")" << std::endl;

   c.reset();

   total = 0;

   for (typename std::vector<T>::const_iterator i = values.begin(); i != values.end(); ++i)
   {
      total += i->template convert_to<double>();
   }

   time = c.elapsed();
   std::cout << "Boost time:     " << std::setw(7) << std::right << time << " (total sum = " << total << ")" << std::endl;
}

int main()
{
   using namespace boost::multiprecision;

   test_conversion_time<cpp_bin_float_double>("cpp_bin_float_double");
   test_conversion_time<cpp_bin_float_quad>("cpp_bin_float_quad");
   test_conversion_time<cpp_bin_float_oct>("cpp_bin_float_oct");
   test_conversion_time<cpp_bin_float_50>("cpp_bin_float_50");
   test_conversion_time<cpp_bin_float_100>("cpp_bin_float_100");

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/delaunay_test.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock.
//  Copyright 2012 Phil Endecott
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include "arithmetic_backend.hpp"
#include <boost/chrono.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int_distribution.hpp>

#include <fstream>
#include <iomanip>

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

// Custom 128-bit maths used for exact calculation of the Delaunay test.
// Only the few operators actually needed here are implemented.

struct int128_t
{
   int64_t  high;
   uint64_t low;

   int128_t() {}
   int128_t(int32_t i) : high(i >> 31), low(static_cast<int64_t>(i)) {}
   int128_t(uint32_t i) : high(0), low(i) {}
   int128_t(int64_t i) : high(i >> 63), low(i) {}
   int128_t(uint64_t i) : high(0), low(i) {}
};

inline int128_t operator<<(int128_t val, int amt)
{
   int128_t r;
   r.low  = val.low << amt;
   r.high = val.low >> (64 - amt);
   r.high |= val.high << amt;
   return r;
}

inline int128_t& operator+=(int128_t& l, int128_t r)
{
   l.low += r.low;
   bool carry = l.low < r.low;
   l.high += r.high;
   if (carry)
      ++l.high;
   return l;
}

inline int128_t operator-(int128_t val)
{
   val.low  = ~val.low;
   val.high = ~val.high;
   val.low += 1;
   if (val.low == 0)
      val.high += 1;
   return val;
}

inline int128_t operator+(int128_t l, int128_t r)
{
   l += r;
   return l;
}

inline bool operator<(int128_t l, int128_t r)
{
   if (l.high != r.high)
      return l.high < r.high;
   return l.low < r.low;
}

inline int128_t mult_64x64_to_128(int64_t a, int64_t b)
{
   // Make life simple by dealing only with positive numbers:
   bool neg = false;
   if (a < 0)
   {
      neg = !neg;
      a   = -a;
   }
   if (b < 0)
   {
      neg = !neg;
      b   = -b;
   }

   // Divide input into 32-bit halves:
   uint32_t ah = a >> 32;
   uint32_t al = a & 0xffffffff;
   uint32_t bh = b >> 32;
   uint32_t bl = b & 0xffffffff;

   // Long multiplication, with 64-bit temporaries:

   //            ah al
   //          * bh bl
   // ----------------
   //            al*bl   (t1)
   // +       ah*bl      (t2)
   // +       al*bh      (t3)
   // +    ah*bh         (t4)
   // ----------------

   uint64_t t1 = static_cast<uint64_t>(al) * bl;
   uint64_t t2 = static_cast<uint64_t>(ah) * bl;
   uint64_t t3 = static_cast<uint64_t>(al) * bh;
   uint64_t t4 = static_cast<uint64_t>(ah) * bh;

   int128_t r(t1);
   r.high = t4;
   r += int128_t(t2) << 32;
   r += int128_t(t3) << 32;

   if (neg)
      r = -r;

   return r;
}

template <class R, class T>
BOOST_FORCEINLINE void mul_2n(R& r, const T& a, const T& b)
{
   r = a;
   r *= b;
}

template <class B, boost::multiprecision::expression_template_option ET, class T>
BOOST_FORCEINLINE void mul_2n(boost::multiprecision::number<B, ET>& r, const T& a, const T& b)
{
   multiply(r, a, b);
}

BOOST_FORCEINLINE void mul_2n(int128_t& r, const std::int64_t& a, const std::int64_t& b)
{
   r = mult_64x64_to_128(a, b);
}

template <class Traits>
inline bool delaunay_test(int32_t ax, int32_t ay, int32_t bx, int32_t by,
                          int32_t cx, int32_t cy, int32_t dx, int32_t dy)
{
   // Test whether the quadrilateral ABCD's diagonal AC should be flipped to BD.
   // This is the Cline & Renka method.
   // Flip if the sum of the angles ABC and CDA is greater than 180 degrees.
   // Equivalently, flip if sin(ABC + CDA) < 0.
   // Trig identity: cos(ABC) * sin(CDA) + sin(ABC) * cos(CDA) < 0
   // We can use scalar and vector products to find sin and cos, and simplify
   // to the following code.
   // Numerical robustness is important.  This code addresses it by performing
   // exact calculations with large integer types.
   //
   // NOTE: This routine is limited to inputs with up to 30 BIT PRECISION, which
   // is to say all inputs must be in the range [INT_MIN/2, INT_MAX/2].

   typedef typename Traits::i64_t  i64;
   typedef typename Traits::i128_t i128;

   i64 cos_abc, t;
   mul_2n(cos_abc, (ax - bx), (cx - bx)); // subtraction yields 31-bit values, multiplied to give 62-bit values
   mul_2n(t, (ay - by), (cy - by));
   cos_abc += t; // addition yields 63 bit value, leaving one left for the sign

   i64 cos_cda;
   mul_2n(cos_cda, (cx - dx), (ax - dx));
   mul_2n(t, (cy - dy), (ay - dy));
   cos_cda += t;

   if (cos_abc >= 0 && cos_cda >= 0)
      return false;
   if (cos_abc < 0 && cos_cda < 0)
      return true;

   i64 sin_abc;
   mul_2n(sin_abc, (ax - bx), (cy - by));
   mul_2n(t, (cx - bx), (ay - by));
   sin_abc -= t;

   i64 sin_cda;
   mul_2n(sin_cda, (cx - dx), (ay - dy));
   mul_2n(t, (ax - dx), (cy - dy));
   sin_cda -= t;

   i128 sin_sum, t128;
   mul_2n(sin_sum, sin_abc, cos_cda); // 63-bit inputs multiplied to 126-bit output
   mul_2n(t128, cos_abc, sin_cda);
   sin_sum += t128; // Addition yields 127 bit result, leaving one bit for the sign

   return sin_sum < 0;
}

struct dt_dat
{
   int32_t ax, ay, bx, by, cx, cy, dx, dy;
};

typedef std::vector<dt_dat> data_t;
data_t                      data;

template <class Traits>
void do_calc(const char* name)
{
   std::cout << "Running calculations for: " << name << std::endl;

   stopwatch<boost::chrono::high_resolution_clock> w;

   std::uint64_t flips = 0;
   std::uint64_t calcs = 0;

   for (int j = 0; j < 1000; ++j)
   {
      for (data_t::const_iterator i = data.begin(); i != data.end(); ++i)
      {
         const dt_dat& d    = *i;
         bool          flip = delaunay_test<Traits>(d.ax, d.ay, d.bx, d.by, d.cx, d.cy, d.dx, d.dy);
         if (flip)
            ++flips;
         ++calcs;
      }
   }
   double t = boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();

   std::cout << "Number of calculations = " << calcs << std::endl;
   std::cout << "Number of flips = " << flips << std::endl;
   std::cout << "Total execution time = " << t << std::endl;
   std::cout << "Time per calculation = " << t / calcs << std::endl
             << std::endl;
}

template <class I64, class I128>
struct test_traits
{
   typedef I64  i64_t;
   typedef I128 i128_t;
};

dt_dat generate_quadrilateral()
{
   static boost::random::mt19937                    gen;
   static boost::random::uniform_int_distribution<> dist(INT_MIN / 2, INT_MAX / 2);

   dt_dat result;

   result.ax = dist(gen);
   result.ay = dist(gen);
   result.bx = boost::random::uniform_int_distribution<>(result.ax, INT_MAX / 2)(gen); // bx is to the right of ax.
   result.by = dist(gen);
   result.cx = dist(gen);
   result.cy = boost::random::uniform_int_distribution<>(result.cx > result.bx ? result.by : result.ay, INT_MAX / 2)(gen); // cy is below at least one of ay and by.
   result.dx = boost::random::uniform_int_distribution<>(result.cx, INT_MAX / 2)(gen);                                     // dx is to the right of cx.
   result.dy = boost::random::uniform_int_distribution<>(result.cx > result.bx ? result.by : result.ay, INT_MAX / 2)(gen); // cy is below at least one of ay and by.

   return result;
}

static void load_data()
{
   for (unsigned i = 0; i < 100000; ++i)
      data.push_back(generate_quadrilateral());
}

int main()
{
   using namespace boost::multiprecision;
   std::cout << "loading data...\n";
   load_data();

   std::cout << "calculating...\n";

   do_calc<test_traits<std::int64_t, std::int64_t> >("int64_t, int64_t");
   do_calc<test_traits<number<arithmetic_backend<std::int64_t>, et_off>, number<arithmetic_backend<std::int64_t>, et_off> > >("arithmetic_backend<int64_t>, arithmetic_backend<int64_t>");
   do_calc<test_traits<std::int64_t, number<arithmetic_backend<std::int64_t>, et_off> > >("int64_t, arithmetic_backend<int64_t>");
   do_calc<test_traits<number<cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, et_off>, number<cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, et_off> > >("multiprecision::int64_t, multiprecision::int64_t");

   do_calc<test_traits<std::int64_t, ::int128_t> >("int64_t, int128_t");
   do_calc<test_traits<std::int64_t, boost::multiprecision::int128_t> >("int64_t, boost::multiprecision::int128_t");
   do_calc<test_traits<std::int64_t, number<cpp_int_backend<128, 128, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, et_on> > >("int64_t, int128_t (ET)");
   do_calc<test_traits<number<cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, et_off>, boost::multiprecision::int128_t> >("multiprecision::int64_t, multiprecision::int128_t");

   do_calc<test_traits<std::int64_t, cpp_int> >("int64_t, cpp_int");
   do_calc<test_traits<std::int64_t, number<cpp_int_backend<>, et_off> > >("int64_t, cpp_int (no ET's)");
   do_calc<test_traits<std::int64_t, number<cpp_int_backend<128> > > >("int64_t, cpp_int(128-bit cache)");
   do_calc<test_traits<std::int64_t, number<cpp_int_backend<128>, et_off> > >("int64_t, cpp_int (128-bit Cache no ET's)");

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/delaunay_test.log
================================================
loading data...
calculating...
Running calculations for: int64_t, int64_t
Number of calculations = 100000000
Number of flips = 25765000
Total execution time = 4.87739
Time per calculation = 4.87739e-08

Running calculations for: arithmetic_backend<int64_t>, arithmetic_backend<int64_t>
Number of calculations = 100000000
Number of flips = 25765000
Total execution time = 42.5469
Time per calculation = 4.25469e-07

Running calculations for: int64_t, arithmetic_backend<int64_t>
Number of calculations = 100000000
Number of flips = 25765000
Total execution time = 9.24092
Time per calculation = 9.24092e-08

Running calculations for: multiprecision::int64_t, multiprecision::int64_t
Number of calculations = 100000000
Number of flips = 24627000
Total execution time = 66.3086
Time per calculation = 6.63086e-07

Running calculations for: int64_t, int128_t
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 10.3215
Time per calculation = 1.03215e-07

Running calculations for: int64_t, boost::multiprecision::int128_t
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 12.848
Time per calculation = 1.2848e-07

Running calculations for: int64_t, int128_t (ET)
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 12.7641
Time per calculation = 1.27641e-07

Running calculations for: multiprecision::int64_t, multiprecision::int128_t
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 76.4744
Time per calculation = 7.64744e-07

Running calculations for: int64_t, cpp_int
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 17.5545
Time per calculation = 1.75545e-07

Running calculations for: int64_t, cpp_int (no ET's)
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 17.5139
Time per calculation = 1.75139e-07

Running calculations for: int64_t, cpp_int(128-bit cache)
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 17.4647
Time per calculation = 1.74647e-07

Running calculations for: int64_t, cpp_int (128-bit Cache no ET's)
Number of calculations = 100000000
Number of flips = 23892000
Total execution time = 18.6492
Time per calculation = 1.86492e-07



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/gcd_bench.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/random.hpp>
#include <cmath>

#include <immintrin.h>

using namespace boost::multiprecision;
using namespace boost::random;

namespace boost {
   namespace multiprecision {
      namespace backends {

      template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
      inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
      eval_gcd_old(
          cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>&       result,
          const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a,
          const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b)
      {
         using default_ops::eval_get_sign;
         using default_ops::eval_is_zero;
         using default_ops::eval_lsb;

         if (a.size() == 1)
         {
            eval_gcd(result, b, *a.limbs());
            return;
         }
         if (b.size() == 1)
         {
            eval_gcd(result, a, *b.limbs());
            return;
         }

         cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> u(a), v(b);

         int s = eval_get_sign(u);

         /* GCD(0,x) := x */
         if (s < 0)
         {
            u.negate();
         }
         else if (s == 0)
         {
            result = v;
            return;
         }
         s = eval_get_sign(v);
         if (s < 0)
         {
            v.negate();
         }
         else if (s == 0)
         {
            result = u;
            return;
         }

         /* Let shift := lg K, where K is the greatest power of 2
   dividing both u and v. */

         unsigned us    = eval_lsb(u);
         unsigned vs    = eval_lsb(v);
         int      shift = (std::min)(us, vs);
         eval_right_shift(u, us);
         eval_right_shift(v, vs);

         do
         {
            /* Now u and v are both odd, so diff(u, v) is even.
      Let u = min(u, v), v = diff(u, v)/2. */
            s = u.compare(v);
            if (s > 0)
               u.swap(v);
            if (s == 0)
               break;

            while (((u.size() + 2 < v.size()) && (v.size() * 100 / u.size() > 105)) || ((u.size() <= 2) && (v.size() > 4)))
            {
               //
               // Speical case: if u and v differ considerably in size, then a Euclid step
               // is more efficient as we reduce v by several limbs in one go.
               // Unfortunately it requires an expensive long division:
               //
               eval_modulus(v, v, u);
               u.swap(v);
            }
            if (v.size() <= 2)
            {
               //
               // Special case: if v has no more than 2 limbs
               // then we can reduce u and v to a pair of integers and perform
               // direct integer gcd:
               //
               if (v.size() == 1)
                  u = eval_gcd(*v.limbs(), *u.limbs());
               else
               {
                  double_limb_type i = v.limbs()[0] | (static_cast<double_limb_type>(v.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
                  double_limb_type j = (u.size() == 1) ? *u.limbs() : u.limbs()[0] | (static_cast<double_limb_type>(u.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
                  u                  = eval_gcd(i, j);
               }
               break;
            }
            //
            // Regular binary gcd case:
            //
            eval_subtract(v, u);
            vs = eval_lsb(v);
            eval_right_shift(v, vs);
         } while (true);

         result = u;
         eval_left_shift(result, shift);
      }

      }
   }
}

template <class T>
std::tuple<std::vector<T>, std::vector<T>, std::vector<T> >& get_test_vector(unsigned bits)
{
   static std::map<unsigned, std::tuple<std::vector<T>, std::vector<T>, std::vector<T> > > data;

   std::tuple<std::vector<T>, std::vector<T>, std::vector<T> >& result = data[bits];

   if (std::get<0>(result).size() == 0)
   {
      mt19937                     mt;
      uniform_int_distribution<T> ui(T(1) << (bits - 1), T(1) << bits);

      std::vector<T>& a = std::get<0>(result);
      std::vector<T>& b = std::get<1>(result);
      std::vector<T>& c = std::get<2>(result);

      for (unsigned i = 0; i < 1000; ++i)
      {
         a.push_back(ui(mt));
         b.push_back(ui(mt));
         if (b.back() > a.back())
            b.back().swap(a.back());
         c.push_back(0);
      }
   }
   return result;
}

template <class T>
std::vector<T>& get_test_vector_a(unsigned bits)
{
   return std::get<0>(get_test_vector<T>(bits));
}
template <class T>
std::vector<T>& get_test_vector_b(unsigned bits)
{
   return std::get<1>(get_test_vector<T>(bits));
}
template <class T>
std::vector<T>& get_test_vector_c(unsigned bits)
{
   return std::get<2>(get_test_vector<T>(bits));
}


template <typename T>
static void BM_gcd_old(benchmark::State& state)
{
   int                         bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);
   std::vector<T>& c = get_test_vector_c<T>(bits);

   for (auto _ : state)
   {
      for (unsigned i = 0; i < a.size(); ++i)
         eval_gcd_old(c[i].backend(), a[i].backend(), b[i].backend());
   }
   state.SetComplexityN(bits);
}

template <typename T>
static void BM_gcd_current(benchmark::State& state)
{
   int                         bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);
   std::vector<T>& c = get_test_vector_c<T>(bits);

   for (auto _ : state)
   {
      for (unsigned i = 0; i < a.size(); ++i)
         eval_gcd(c[i].backend(), a[i].backend(), b[i].backend());
   }
   state.SetComplexityN(bits);
}

constexpr unsigned lower_range = 512;
constexpr unsigned upper_range = 1 << 15;

BENCHMARK_TEMPLATE(BM_gcd_old, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_gcd_current, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_gcd_old, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_gcd_current, mpz_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_gcd_current, mpz_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/linpack-benchmark.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

/* 1000d.f -- translated by f2c (version 20050501).
You must link the resulting object file with libf2c:
on Microsoft Windows system, link with libf2c.lib;
on Linux or Unix systems, link with .../path/to/libf2c.a -lm
or, if you install libf2c.a in a standard place, with -lf2c -lm
-- in that order, at the end of the command line, as in
cc *.o -lf2c -lm
Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

http://www.netlib.org/f2c/libf2c.zip
*/
#include <iostream>
#include <iomanip>
#include <cmath>

#if defined(TEST_GMPXX)
#include <gmpxx.h>
typedef mpf_class real_type;
#elif defined(TEST_MPFRXX)
#include <gmpfrxx.h>
typedef mpfr_class real_type;
#elif defined(TEST_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>
typedef boost::multiprecision::cpp_dec_float_50 real_type;
#elif defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
typedef boost::multiprecision::mpfr_float_50 real_type;
#elif defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
typedef boost::multiprecision::mpf_float_50 real_type;
#elif defined(NATIVE_FLOAT128)
#include <boost/multiprecision/float128.hpp>
typedef __float128 real_type;

std::ostream& operator<<(std::ostream& os, const __float128& f)
{
   return os << boost::multiprecision::float128(f);
}

#include <boost/type_traits/has_left_shift.hpp>

namespace boost {

template <>
struct has_left_shift<std::basic_ostream<char>, __float128> : public std::integral_constant<bool, true>
{};

template <>
double lexical_cast<double, __float128>(const __float128& f)
{
   return f;
}

} // namespace boost

#elif defined(TEST_FLOAT128)
#include <boost/multiprecision/float128.hpp>
typedef boost::multiprecision::float128 real_type;
#elif defined(TEST_CPP_BIN_FLOAT_QUAD)
#include <boost/multiprecision/cpp_bin_float.hpp>
typedef boost::multiprecision::cpp_bin_float_quad real_type;
#elif defined(TEST_CPP_BIN_FLOAT_OCT)
#include <boost/multiprecision/cpp_bin_float.hpp>
typedef boost::multiprecision::cpp_bin_float_oct real_type;
#else
typedef double real_type;
#endif

#include <boost/lexical_cast.hpp>

#ifndef CAST_TO_RT
#define CAST_TO_RT(x) x
#endif

extern "C" {
#include "f2c.h"
integer s_wsfe(cilist*), e_wsfe(void), do_fio(integer*, char*, ftnlen),
    s_wsle(cilist*), do_lio(integer*, integer*, char*, ftnlen),
    e_wsle(void);
/* Subroutine */ int s_stop(char*, ftnlen);

#undef abs
#undef dabs
#define dabs abs
#undef dmin
#undef dmax
#define dmin min
#define dmax max
}
#include <time.h>

using std::max;
using std::min;

/* Table of constant values */

static integer   c__0 = 0;
static real_type c_b7 = CAST_TO_RT(1);
static integer   c__1 = 1;
static integer   c__9 = 9;

inline double second_(void)
{
   return ((double)(clock())) / CLOCKS_PER_SEC;
}

int       dgefa_(real_type*, integer*, integer*, integer*, integer*), dgesl_(real_type*, integer*, integer*, integer*, real_type*, integer*);
int       dmxpy_(integer*, real_type*, integer*, integer*, real_type*, real_type*);
int       matgen_(real_type*, integer*, integer*, real_type*, real_type*);
real_type epslon_(real_type*);
real_type ran_(integer*);
int       dscal_(integer*, real_type*, real_type*, integer*);
int       daxpy_(integer*, real_type*, real_type*, integer*, real_type*, integer*);
integer   idamax_(integer*, real_type*, integer*);
real_type ddot_(integer*, real_type*, integer*, real_type*, integer*);
int       daxpy_(integer*, real_type*, real_type*, integer*, real_type*, integer*);
int       dmxpy_(integer*, real_type*, integer*, integer*, real_type*, real_type*);

extern "C" int MAIN__()
{
#ifdef TEST_MPF_50
   std::cout << "Testing number<mpf_float<50> >" << std::endl;
#elif defined(TEST_MPFR_50)
   std::cout << "Testing number<mpf_float<50> >" << std::endl;
#elif defined(TEST_GMPXX)
   std::cout << "Testing mpf_class at 50 decimal degits" << std::endl;
   mpf_set_default_prec(((50 + 1) * 1000L) / 301L);
#elif defined(TEST_MPFRXX)
   std::cout << "Testing mpfr_class at 50 decimal degits" << std::endl;
   mpfr_set_default_prec(((50 + 1) * 1000L) / 301L);
#elif defined(TEST_CPP_DEC_FLOAT)
   std::cout << "Testing number<cpp_dec_float<50> >" << std::endl;
#elif defined(NATIVE_FLOAT128)
   std::cout << "Testing __float128" << std::endl;
#elif defined(TEST_FLOAT128)
   std::cout << "Testing number<float128_backend, et_off>" << std::endl;
#else
   std::cout << "Testing double" << std::endl;
#endif

   /* Format strings */
   static char fmt_1[] = "(\002 Please send the results of this run to:\002"
                         "//\002 Jack J. Dongarra\002/\002 Computer Science Department\002/"
                         "\002 University of Tennessee\002/\002 Knoxville, Tennessee 37996"
                         "-1300\002//\002 Fax: 615-974-8296\002//\002 Internet: dongarra@c"
                         "s.utk.edu\002/)";
   static char fmt_40[] = "(\002     norm. resid      resid           mac"
                          "hep\002,\002         x(1)          x(n)\002)";
   static char fmt_50[] = "(1p5e16.8)";
   static char fmt_60[] = "(//\002    times are reported for matrices of or"
                          "der \002,i5)";
   static char fmt_70[] = "(6x,\002factor\002,5x,\002solve\002,6x,\002tota"
                          "l\002,5x,\002mflops\002,7x,\002unit\002,6x,\002ratio\002)";
   static char fmt_80[] = "(\002 times for array with leading dimension o"
                          "f\002,i4)";
   static char fmt_110[] = "(6(1pe11.3))";

   /* System generated locals */
   integer   i__1;
   real_type d__1, d__2, d__3;

   /* Builtin functions */

   /* Local variables */
   static real_type a[1001000] /* was [1001][1000] */, b[1000];
   static integer   i__, n;
   static real_type x[1000];
   static double    t1;
   static integer   lda;
   static double    ops;
   static real_type eps;
   static integer   info;
   static double    time[6], cray, total;
   static integer   ipvt[1000];
   static real_type resid, norma;
   static real_type normx;
   static real_type residn;

   /* Fortran I/O blocks */
   static cilist io___4  = {0, 6, 0, fmt_1, 0};
   static cilist io___20 = {0, 6, 0, fmt_40, 0};
   static cilist io___21 = {0, 6, 0, fmt_50, 0};
   static cilist io___22 = {0, 6, 0, fmt_60, 0};
   static cilist io___23 = {0, 6, 0, fmt_70, 0};
   static cilist io___24 = {0, 6, 0, fmt_80, 0};
   static cilist io___25 = {0, 6, 0, fmt_110, 0};
   static cilist io___26 = {0, 6, 0, 0, 0};

   lda = 1001;

   /*     this program was updated on 10/12/92 to correct a */
   /*     problem with the random number generator. The previous */
   /*     random number generator had a short period and produced */
   /*     singular matrices occasionally. */

   n    = 1000;
   cray = .056f;
   s_wsfe(&io___4);
   e_wsfe();
   /* Computing 3rd power */
   d__1 = (real_type)n;
   /* Computing 2nd power */
   d__2 = (real_type)n;
   ops  = boost::lexical_cast<double>(real_type(d__1 * (d__1 * d__1) * 2. / 3. + d__2 * d__2 * 2.));

   matgen_(a, &lda, &n, b, &norma);

   /* ****************************************************************** */
   /* ****************************************************************** */
   /*        you should replace the call to dgefa and dgesl */
   /*        by calls to your linear equation solver. */
   /* ****************************************************************** */
   /* ****************************************************************** */

   t1 = second_();
   dgefa_(a, &lda, &n, ipvt, &info);
   time[0] = second_() - t1;
   t1      = second_();
   dgesl_(a, &lda, &n, ipvt, b, &c__0);
   time[1] = second_() - t1;
   total   = time[0] + time[1];
   /* ****************************************************************** */
   /* ****************************************************************** */

   /*     compute a residual to verify results. */

   i__1 = n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      x[i__ - 1] = b[i__ - 1];
      /* L10: */
   }
   matgen_(a, &lda, &n, b, &norma);
   i__1 = n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      b[i__ - 1] = -b[i__ - 1];
      /* L20: */
   }
   dmxpy_(&n, b, &n, &lda, x, a);
   resid = CAST_TO_RT(0);
   normx = CAST_TO_RT(0);
   i__1  = n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      /* Computing MAX */
      d__2 = resid, d__3 = (d__1 = b[i__ - 1], abs(d__1));
      resid = (max)(d__2, d__3);
      /* Computing MAX */
      d__2 = normx, d__3 = (d__1 = x[i__ - 1], abs(d__1));
      normx = (max)(d__2, d__3);
      /* L30: */
   }
   eps    = epslon_(&c_b7);
   residn = resid / (n * norma * normx * eps);
   s_wsfe(&io___20);
   e_wsfe();
   s_wsfe(&io___21);
   /*
   do_fio(&c__1, (char *)&residn, (ftnlen)sizeof(real_type));
   do_fio(&c__1, (char *)&resid, (ftnlen)sizeof(real_type));
   do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(real_type));
   do_fio(&c__1, (char *)&x[0], (ftnlen)sizeof(real_type));
   do_fio(&c__1, (char *)&x[n - 1], (ftnlen)sizeof(real_type));
   */
   std::cout << std::setw(12) << std::setprecision(5) << residn << " " << resid << " " << eps << " " << x[0] << " " << x[n - 1] << std::endl;
   e_wsfe();

   s_wsfe(&io___22);
   do_fio(&c__1, (char*)&n, (ftnlen)sizeof(integer));
   e_wsfe();
   s_wsfe(&io___23);
   e_wsfe();

   time[2] = total;
   time[3] = ops / (total * 1e6);
   time[4] = 2. / time[3];
   time[5] = total / cray;
   s_wsfe(&io___24);
   do_fio(&c__1, (char*)&lda, (ftnlen)sizeof(integer));
   e_wsfe();
   s_wsfe(&io___25);
   for (i__ = 1; i__ <= 6; ++i__)
   {
      // do_fio(&c__1, (char *)&time[i__ - 1], (ftnlen)sizeof(real_type));
      std::cout << std::setw(12) << std::setprecision(5) << time[i__ - 1];
   }
   e_wsfe();
   s_wsle(&io___26);
   do_lio(&c__9, &c__1, " end of tests -- this version dated 10/12/92", (ftnlen)44);
   e_wsle();

   s_stop("", (ftnlen)0);
   return 0;
} /* MAIN__ */

/* Subroutine */ int matgen_(real_type* a, integer* lda, integer* n,
                             real_type* b, real_type* norma)
{
   /* System generated locals */
   integer   a_dim1, a_offset, i__1, i__2;
   real_type d__1, d__2;

   /* Local variables */
   static integer i__, j;
   static integer init[4];

   /* Parameter adjustments */
   a_dim1   = *lda;
   a_offset = 1 + a_dim1;
   a -= a_offset;
   --b;

   /* Function Body */
   init[0] = 1;
   init[1] = 2;
   init[2] = 3;
   init[3] = 1325;
   *norma  = CAST_TO_RT(0);
   i__1    = *n;
   for (j = 1; j <= i__1; ++j)
   {
      i__2 = *n;
      for (i__ = 1; i__ <= i__2; ++i__)
      {
         a[i__ + j * a_dim1] = ran_(init) - .5f;
         /* Computing MAX */
         d__2   = (d__1 = a[i__ + j * a_dim1], abs(d__1));
         *norma = (max)(d__2, *norma);
         /* L20: */
      }
      /* L30: */
   }
   i__1 = *n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      b[i__] = CAST_TO_RT(0);
      /* L35: */
   }
   i__1 = *n;
   for (j = 1; j <= i__1; ++j)
   {
      i__2 = *n;
      for (i__ = 1; i__ <= i__2; ++i__)
      {
         b[i__] += a[i__ + j * a_dim1];
         /* L40: */
      }
      /* L50: */
   }
   return 0;
} /* matgen_ */

/* Subroutine */ int dgefa_(real_type* a, integer* lda, integer* n, integer* ipvt, integer* info)
{
   /* System generated locals */
   integer a_dim1, a_offset, i__1, i__2, i__3;

   /* Local variables */
   static integer   j, k, l;
   static real_type t;
   static integer   kp1, nm1;

   /*     dgefa factors a double precision matrix by gaussian elimination. */

   /*     dgefa is usually called by dgeco, but it can be called */
   /*     directly with a saving in time if  rcond  is not needed. */
   /*     (time for dgeco) = (1 + 9/n)*(time for dgefa) . */

   /*     on entry */

   /*        a       double precision(lda, n) */
   /*                the matrix to be factored. */

   /*        lda     integer */
   /*                the leading dimension of the array  a . */

   /*        n       integer */
   /*                the order of the matrix  a . */

   /*     on return */

   /*        a       an upper triangular matrix and the multipliers */
   /*                which were used to obtain it. */
   /*                the factorization can be written  a = l*u  where */
   /*                l  is a product of permutation and unit lower */
   /*                triangular matrices and  u  is upper triangular. */

   /*        ipvt    integer(n) */
   /*                an integer vector of pivot indices. */

   /*        info    integer */
   /*                = 0  normal value. */
   /*                = k  if  u(k,k) .eq. 0.0 .  this is not an error */
   /*                     condition for this subroutine, but it does */
   /*                     indicate that dgesl or dgedi will divide by zero */
   /*                     if called.  use  rcond  in dgeco for a reliable */
   /*                     indication of singularity. */

   /*     linpack. this version dated 08/14/78 . */
   /*     cleve moler, university of new mexico, argonne national lab. */

   /*     subroutines and functions */

   /*     blas daxpy,dscal,idamax */

   /*     internal variables */

   /*     gaussian elimination with partial pivoting */

   /* Parameter adjustments */
   a_dim1   = *lda;
   a_offset = 1 + a_dim1;
   a -= a_offset;
   --ipvt;

   /* Function Body */
   *info = 0;
   nm1   = *n - 1;
   if (nm1 < 1)
   {
      goto L70;
   }
   i__1 = nm1;
   for (k = 1; k <= i__1; ++k)
   {
      kp1 = k + 1;

      /*        find l = pivot index */

      i__2    = *n - k + 1;
      l       = idamax_(&i__2, &a[k + k * a_dim1], &c__1) + k - 1;
      ipvt[k] = l;

      /*        zero pivot implies this column already triangularized */

      if (a[l + k * a_dim1] == 0.)
      {
         goto L40;
      }

      /*           interchange if necessary */

      if (l == k)
      {
         goto L10;
      }
      t                 = a[l + k * a_dim1];
      a[l + k * a_dim1] = a[k + k * a_dim1];
      a[k + k * a_dim1] = t;
   L10:

      /*           compute multipliers */

      t    = -1. / a[k + k * a_dim1];
      i__2 = *n - k;
      dscal_(&i__2, &t, &a[k + 1 + k * a_dim1], &c__1);

      /*           row elimination with column indexing */

      i__2 = *n;
      for (j = kp1; j <= i__2; ++j)
      {
         t = a[l + j * a_dim1];
         if (l == k)
         {
            goto L20;
         }
         a[l + j * a_dim1] = a[k + j * a_dim1];
         a[k + j * a_dim1] = t;
      L20:
         i__3 = *n - k;
         daxpy_(&i__3, &t, &a[k + 1 + k * a_dim1], &c__1, &a[k + 1 + j * a_dim1], &c__1);
         /* L30: */
      }
      goto L50;
   L40:
      *info = k;
   L50:
       /* L60: */
       ;
   }
L70:
   ipvt[*n] = *n;
   if (a[*n + *n * a_dim1] == 0.)
   {
      *info = *n;
   }
   return 0;
} /* dgefa_ */

/* Subroutine */ int dgesl_(real_type* a, integer* lda, integer* n, integer* ipvt, real_type* b, integer* job)
{
   /* System generated locals */
   integer a_dim1, a_offset, i__1, i__2;

   /* Local variables */
   static integer   k, l;
   static real_type t;
   static integer   kb, nm1;

   /*     dgesl solves the double precision system */
   /*     a * x = b  or  trans(a) * x = b */
   /*     using the factors computed by dgeco or dgefa. */

   /*     on entry */

   /*        a       double precision(lda, n) */
   /*                the output from dgeco or dgefa. */

   /*        lda     integer */
   /*                the leading dimension of the array  a . */

   /*        n       integer */
   /*                the order of the matrix  a . */

   /*        ipvt    integer(n) */
   /*                the pivot vector from dgeco or dgefa. */

   /*        b       double precision(n) */
   /*                the right hand side vector. */

   /*        job     integer */
   /*                = 0         to solve  a*x = b , */
   /*                = nonzero   to solve  trans(a)*x = b  where */
   /*                            trans(a)  is the transpose. */

   /*     on return */

   /*        b       the solution vector  x . */

   /*     error condition */

   /*        a division by zero will occur if the input factor contains a */
   /*        zero on the diagonal.  technically this indicates singularity */
   /*        but it is often caused by improper arguments or improper */
   /*        setting of lda .  it will not occur if the subroutines are */
   /*        called correctly and if dgeco has set rcond .gt. 0.0 */
   /*        or dgefa has set info .eq. 0 . */

   /*     to compute  inverse(a) * c  where  c  is a matrix */
   /*     with  p  columns */
   /*           call dgeco(a,lda,n,ipvt,rcond,z) */
   /*           if (rcond is too small) go to ... */
   /*           do 10 j = 1, p */
   /*              call dgesl(a,lda,n,ipvt,c(1,j),0) */
   /*        10 continue */

   /*     linpack. this version dated 08/14/78 . */
   /*     cleve moler, university of new mexico, argonne national lab. */

   /*     subroutines and functions */

   /*     blas daxpy,ddot */

   /*     internal variables */

   /* Parameter adjustments */
   a_dim1   = *lda;
   a_offset = 1 + a_dim1;
   a -= a_offset;
   --ipvt;
   --b;

   /* Function Body */
   nm1 = *n - 1;
   if (*job != 0)
   {
      goto L50;
   }

   /*        job = 0 , solve  a * x = b */
   /*        first solve  l*y = b */

   if (nm1 < 1)
   {
      goto L30;
   }
   i__1 = nm1;
   for (k = 1; k <= i__1; ++k)
   {
      l = ipvt[k];
      t = b[l];
      if (l == k)
      {
         goto L10;
      }
      b[l] = b[k];
      b[k] = t;
   L10:
      i__2 = *n - k;
      daxpy_(&i__2, &t, &a[k + 1 + k * a_dim1], &c__1, &b[k + 1], &c__1);
      /* L20: */
   }
L30:

   /*        now solve  u*x = y */

   i__1 = *n;
   for (kb = 1; kb <= i__1; ++kb)
   {
      k = *n + 1 - kb;
      b[k] /= a[k + k * a_dim1];
      t    = -b[k];
      i__2 = k - 1;
      daxpy_(&i__2, &t, &a[k * a_dim1 + 1], &c__1, &b[1], &c__1);
      /* L40: */
   }
   goto L100;
L50:

   /*        job = nonzero, solve  trans(a) * x = b */
   /*        first solve  trans(u)*y = b */

   i__1 = *n;
   for (k = 1; k <= i__1; ++k)
   {
      i__2 = k - 1;
      t    = ddot_(&i__2, &a[k * a_dim1 + 1], &c__1, &b[1], &c__1);
      b[k] = (b[k] - t) / a[k + k * a_dim1];
      /* L60: */
   }

   /*        now solve trans(l)*x = y */

   if (nm1 < 1)
   {
      goto L90;
   }
   i__1 = nm1;
   for (kb = 1; kb <= i__1; ++kb)
   {
      k    = *n - kb;
      i__2 = *n - k;
      b[k] += ddot_(&i__2, &a[k + 1 + k * a_dim1], &c__1, &b[k + 1], &c__1);
      l = ipvt[k];
      if (l == k)
      {
         goto L70;
      }
      t    = b[l];
      b[l] = b[k];
      b[k] = t;
   L70:
       /* L80: */
       ;
   }
L90:
L100:
   return 0;
} /* dgesl_ */

/* Subroutine */ int daxpy_(integer* n, real_type* da, real_type* dx,
                            integer* incx, real_type* dy, integer* incy)
{
   /* System generated locals */
   integer i__1;

   /* Local variables */
   static integer i__, m, ix, iy, mp1;

   /*     constant times a vector plus a vector. */
   /*     uses unrolled loops for increments equal to one. */
   /*     jack dongarra, linpack, 3/11/78. */

   /* Parameter adjustments */
   --dy;
   --dx;

   /* Function Body */
   if (*n <= 0)
   {
      return 0;
   }
   if (*da == 0.)
   {
      return 0;
   }
   if (*incx == 1 && *incy == 1)
   {
      goto L20;
   }

   /*        code for unequal increments or equal increments */
   /*          not equal to 1 */

   ix = 1;
   iy = 1;
   if (*incx < 0)
   {
      ix = (-(*n) + 1) * *incx + 1;
   }
   if (*incy < 0)
   {
      iy = (-(*n) + 1) * *incy + 1;
   }
   i__1 = *n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      dy[iy] += *da * dx[ix];
      ix += *incx;
      iy += *incy;
      /* L10: */
   }
   return 0;

   /*        code for both increments equal to 1 */

   /*        clean-up loop */

L20:
   m = *n % 4;
   if (m == 0)
   {
      goto L40;
   }
   i__1 = m;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      dy[i__] += *da * dx[i__];
      /* L30: */
   }
   if (*n < 4)
   {
      return 0;
   }
L40:
   mp1  = m + 1;
   i__1 = *n;
   for (i__ = mp1; i__ <= i__1; i__ += 4)
   {
      dy[i__] += *da * dx[i__];
      dy[i__ + 1] += *da * dx[i__ + 1];
      dy[i__ + 2] += *da * dx[i__ + 2];
      dy[i__ + 3] += *da * dx[i__ + 3];
      /* L50: */
   }
   return 0;
} /* daxpy_ */

real_type ddot_(integer* n, real_type* dx, integer* incx, real_type* dy,
                integer* incy)
{
   /* System generated locals */
   integer   i__1;
   real_type ret_val;

   /* Local variables */
   static integer   i__, m, ix, iy, mp1;
   static real_type dtemp;

   /*     forms the dot product of two vectors. */
   /*     uses unrolled loops for increments equal to one. */
   /*     jack dongarra, linpack, 3/11/78. */

   /* Parameter adjustments */
   --dy;
   --dx;

   /* Function Body */
   ret_val = CAST_TO_RT(0);
   dtemp   = CAST_TO_RT(0);
   if (*n <= 0)
   {
      return ret_val;
   }
   if (*incx == 1 && *incy == 1)
   {
      goto L20;
   }

   /*        code for unequal increments or equal increments */
   /*          not equal to 1 */

   ix = 1;
   iy = 1;
   if (*incx < 0)
   {
      ix = (-(*n) + 1) * *incx + 1;
   }
   if (*incy < 0)
   {
      iy = (-(*n) + 1) * *incy + 1;
   }
   i__1 = *n;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      dtemp += dx[ix] * dy[iy];
      ix += *incx;
      iy += *incy;
      /* L10: */
   }
   ret_val = dtemp;
   return ret_val;

   /*        code for both increments equal to 1 */

   /*        clean-up loop */

L20:
   m = *n % 5;
   if (m == 0)
   {
      goto L40;
   }
   i__1 = m;
   for (i__ = 1; i__ <= i__1; ++i__)
   {
      dtemp += dx[i__] * dy[i__];
      /* L30: */
   }
   if (*n < 5)
   {
      goto L60;
   }
L40:
   mp1  = m + 1;
   i__1 = *n;
   for (i__ = mp1; i__ <= i__1; i__ += 5)
   {
      dtemp = dtemp + dx[i__] * dy[i__] + dx[i__ + 1] * dy[i__ + 1] + dx[i__ + 2] * dy[i__ + 2] + dx[i__ + 3] * dy[i__ + 3] + dx[i__ + 4] * dy[i__ + 4];
      /* L50: */
   }
L60:
   ret_val = dtemp;
   return ret_val;
} /* ddot_ */

/* Subroutine */ int dscal_(integer* n, real_type* da, real_type* dx,
                            integer* incx)
{
   /* System generated locals */
   integer i__1, i__2;

   /* Local variables */
   static integer i__, m, mp1, nincx;

   /*     scales a vector by a constant. */
   /*     uses unrolled loops for increment equal to one. */
   /*     jack dongarra, linpack, 3/11/78. */

   /* Parameter adjustments */
   --dx;

   /* Function Body */
   if (*n <= 0)
   {
      return 0;
   }
   if (*incx == 1)
   {
      goto L20;
   }

   /*        code for increment not equal to 1 */

   nincx = *n * *incx;
   i__1  = nincx;
   i__2  = *incx;
   for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2)
   {
      dx[i__] = *da * dx[i__];
      /* L10: */
   }
   return 0;

   /*        code for increment equal to 1 */

   /*        clean-up loop */

L20:
   m = *n % 5;
   if (m == 0)
   {
      goto L40;
   }
   i__2 = m;
   for (i__ = 1; i__ <= i__2; ++i__)
   {
      dx[i__] = *da * dx[i__];
      /* L30: */
   }
   if (*n < 5)
   {
      return 0;
   }
L40:
   mp1  = m + 1;
   i__2 = *n;
   for (i__ = mp1; i__ <= i__2; i__ += 5)
   {
      dx[i__]     = *da * dx[i__];
      dx[i__ + 1] = *da * dx[i__ + 1];
      dx[i__ + 2] = *da * dx[i__ + 2];
      dx[i__ + 3] = *da * dx[i__ + 3];
      dx[i__ + 4] = *da * dx[i__ + 4];
      /* L50: */
   }
   return 0;
} /* dscal_ */

integer idamax_(integer* n, real_type* dx, integer* incx)
{
   /* System generated locals */
   integer   ret_val, i__1;
   real_type d__1;

   /* Local variables */
   static integer   i__, ix;
   static real_type dmax__;

   /*     finds the index of element having max. dabsolute value. */
   /*     jack dongarra, linpack, 3/11/78. */

   /* Parameter adjustments */
   --dx;

   /* Function Body */
   ret_val = 0;
   if (*n < 1)
   {
      return ret_val;
   }
   ret_val = 1;
   if (*n == 1)
   {
      return ret_val;
   }
   if (*incx == 1)
   {
      goto L20;
   }

   /*        code for increment not equal to 1 */

   ix     = 1;
   dmax__ = abs(dx[1]);
   ix += *incx;
   i__1 = *n;
   for (i__ = 2; i__ <= i__1; ++i__)
   {
      if ((d__1 = dx[ix], abs(d__1)) <= dmax__)
      {
         goto L5;
      }
      ret_val = i__;
      dmax__  = (d__1 = dx[ix], abs(d__1));
   L5:
      ix += *incx;
      /* L10: */
   }
   return ret_val;

   /*        code for increment equal to 1 */

L20:
   dmax__ = abs(dx[1]);
   i__1   = *n;
   for (i__ = 2; i__ <= i__1; ++i__)
   {
      if ((d__1 = dx[i__], abs(d__1)) <= dmax__)
      {
         goto L30;
      }
      ret_val = i__;
      dmax__  = (d__1 = dx[i__], abs(d__1));
   L30:;
   }
   return ret_val;
} /* idamax_ */

real_type epslon_(real_type* x)
{
#if defined(TEST_MPF_100) || defined(TEST_MPFR_100) || defined(TEST_GMPXX) || defined(TEST_MPFRXX)
   return std::ldexp(1.0, 1 - ((100 + 1) * 1000L) / 301L);
#elif defined(TEST_CPP_DEC_FLOAT_BN)
   return std::pow(10.0, 1 - std::numeric_limits<efx::cpp_dec_float_50>::digits10);
#elif defined(NATIVE_FLOAT128)
   return FLT128_EPSILON;
#else
   return CAST_TO_RT(std::numeric_limits<real_type>::epsilon());
#endif
} /* epslon_ */

/* Subroutine */ int mm_(real_type* a, integer* lda, integer* n1, integer* n3, real_type* b, integer* ldb, integer* n2, real_type* c__,
                         integer* ldc)
{
   /* System generated locals */
   integer a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2;

   /* Local variables */
   static integer i__, j;

   /*   purpose: */
   /*     multiply matrix b times matrix c and store the result in matrix a. */

   /*   parameters: */

   /*     a double precision(lda,n3), matrix of n1 rows and n3 columns */

   /*     lda integer, leading dimension of array a */

   /*     n1 integer, number of rows in matrices a and b */

   /*     n3 integer, number of columns in matrices a and c */

   /*     b double precision(ldb,n2), matrix of n1 rows and n2 columns */

   /*     ldb integer, leading dimension of array b */

   /*     n2 integer, number of columns in matrix b, and number of rows in */
   /*         matrix c */

   /*     c double precision(ldc,n3), matrix of n2 rows and n3 columns */

   /*     ldc integer, leading dimension of array c */

   /* ---------------------------------------------------------------------- */

   /* Parameter adjustments */
   a_dim1   = *lda;
   a_offset = 1 + a_dim1;
   a -= a_offset;
   b_dim1   = *ldb;
   b_offset = 1 + b_dim1;
   b -= b_offset;
   c_dim1   = *ldc;
   c_offset = 1 + c_dim1;
   c__ -= c_offset;

   /* Function Body */
   i__1 = *n3;
   for (j = 1; j <= i__1; ++j)
   {
      i__2 = *n1;
      for (i__ = 1; i__ <= i__2; ++i__)
      {
         a[i__ + j * a_dim1] = CAST_TO_RT(0);
         /* L10: */
      }
      dmxpy_(n2, &a[j * a_dim1 + 1], n1, ldb, &c__[j * c_dim1 + 1], &b[b_offset]);
      /* L20: */
   }

   return 0;
} /* mm_ */

/* Subroutine */ int dmxpy_(integer* n1, real_type* y, integer* n2, integer* ldm, real_type* x, real_type* m)
{
   /* System generated locals */
   integer m_dim1, m_offset, i__1, i__2;

   /* Local variables */
   static integer i__, j, jmin;

   /*   purpose: */
   /*     multiply matrix m times vector x and add the result to vector y. */

   /*   parameters: */

   /*     n1 integer, number of elements in vector y, and number of rows in */
   /*         matrix m */

   /*     y double precision(n1), vector of length n1 to which is added */
   /*         the product m*x */

   /*     n2 integer, number of elements in vector x, and number of columns */
   /*         in matrix m */

   /*     ldm integer, leading dimension of array m */

   /*     x double precision(n2), vector of length n2 */

   /*     m double precision(ldm,n2), matrix of n1 rows and n2 columns */

   /* ---------------------------------------------------------------------- */

   /*   cleanup odd vector */

   /* Parameter adjustments */
   --y;
   m_dim1   = *ldm;
   m_offset = 1 + m_dim1;
   m -= m_offset;
   --x;

   /* Function Body */
   j = *n2 % 2;
   if (j >= 1)
   {
      i__1 = *n1;
      for (i__ = 1; i__ <= i__1; ++i__)
      {
         y[i__] += x[j] * m[i__ + j * m_dim1];
         /* L10: */
      }
   }

   /*   cleanup odd group of two vectors */

   j = *n2 % 4;
   if (j >= 2)
   {
      i__1 = *n1;
      for (i__ = 1; i__ <= i__1; ++i__)
      {
         y[i__] = y[i__] + x[j - 1] * m[i__ + (j - 1) * m_dim1] + x[j] * m[i__ + j * m_dim1];
         /* L20: */
      }
   }

   /*   cleanup odd group of four vectors */

   j = *n2 % 8;
   if (j >= 4)
   {
      i__1 = *n1;
      for (i__ = 1; i__ <= i__1; ++i__)
      {
         y[i__] = y[i__] + x[j - 3] * m[i__ + (j - 3) * m_dim1] + x[j - 2] * m[i__ + (j - 2) * m_dim1] + x[j - 1] * m[i__ + (j - 1) * m_dim1] + x[j] * m[i__ + j * m_dim1];
         /* L30: */
      }
   }

   /*   cleanup odd group of eight vectors */

   j = *n2 % 16;
   if (j >= 8)
   {
      i__1 = *n1;
      for (i__ = 1; i__ <= i__1; ++i__)
      {
         y[i__] = y[i__] + x[j - 7] * m[i__ + (j - 7) * m_dim1] + x[j - 6] * m[i__ + (j - 6) * m_dim1] + x[j - 5] * m[i__ + (j - 5) * m_dim1] + x[j - 4] * m[i__ + (j - 4) * m_dim1] + x[j - 3] * m[i__ + (j - 3) * m_dim1] + x[j - 2] * m[i__ + (j - 2) * m_dim1] + x[j - 1] * m[i__ + (j - 1) * m_dim1] + x[j] * m[i__ + j * m_dim1];
         /* L40: */
      }
   }

   /*   main loop - groups of sixteen vectors */

   jmin = j + 16;
   i__1 = *n2;
   for (j = jmin; j <= i__1; j += 16)
   {
      i__2 = *n1;
      for (i__ = 1; i__ <= i__2; ++i__)
      {
         y[i__] = y[i__] + x[j - 15] * m[i__ + (j - 15) * m_dim1] + x[j - 14] * m[i__ + (j - 14) * m_dim1] + x[j - 13] * m[i__ + (j - 13) * m_dim1] + x[j - 12] * m[i__ + (j - 12) * m_dim1] + x[j - 11] * m[i__ + (j - 11) * m_dim1] + x[j - 10] * m[i__ + (j - 10) * m_dim1] + x[j - 9] * m[i__ + (j - 9) * m_dim1] + x[j - 8] * m[i__ + (j - 8) * m_dim1] + x[j - 7] * m[i__ + (j - 7) * m_dim1] + x[j - 6] * m[i__ + (j - 6) * m_dim1] + x[j - 5] * m[i__ + (j - 5) * m_dim1] + x[j - 4] * m[i__ + (j - 4) * m_dim1] + x[j - 3] * m[i__ + (j - 3) * m_dim1] + x[j - 2] * m[i__ + (j - 2) * m_dim1] + x[j - 1] * m[i__ + (j - 1) * m_dim1] + x[j] * m[i__ + j * m_dim1];
         /* L50: */
      }
      /* L60: */
   }
   return 0;
} /* dmxpy_ */

real_type ran_(integer* iseed)
{
   /* System generated locals */
   real_type ret_val;

   /* Local variables */
   static integer it1, it2, it3, it4;

   /*     modified from the LAPACK auxiliary routine 10/12/92 JD */
   /*  -- LAPACK auxiliary routine (version 1.0) -- */
   /*     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., */
   /*     Courant Institute, Argonne National Lab, and Rice University */
   /*     February 29, 1992 */

   /*     .. Array Arguments .. */
   /*     .. */

   /*  Purpose */
   /*  ======= */

   /*  DLARAN returns a random double number from a uniform (0,1) */
   /*  distribution. */

   /*  Arguments */
   /*  ========= */

   /*  ISEED   (input/output) INTEGER array, dimension (4) */
   /*          On entry, the seed of the random number generator; the array */
   /*          elements must be between 0 and 4095, and ISEED(4) must be */
   /*          odd. */
   /*          On exit, the seed is updated. */

   /*  Further Details */
   /*  =============== */

   /*  This routine uses a multiplicative congruential method with modulus */
   /*  2**48 and multiplier 33952834046453 (see G.S.Fishman, */
   /*  'Multiplicative congruential random number generators with modulus */
   /*  2**b: an exhaustive analysis for b = 32 and a partial analysis for */
   /*  b = 48', Math. Comp. 189, pp 331-344, 1990). */

   /*  48-bit integers are stored in 4 integer array elements with 12 bits */
   /*  per element. Hence the routine is portable across machines with */
   /*  integers of 32 bits or more. */

   /*     .. Parameters .. */
   /*     .. */
   /*     .. Local Scalars .. */
   /*     .. */
   /*     .. Intrinsic Functions .. */
   /*     .. */
   /*     .. Executable Statements .. */

   /*     multiply the seed by the multiplier modulo 2**48 */

   /* Parameter adjustments */
   --iseed;

   /* Function Body */
   it4 = iseed[4] * 2549;
   it3 = it4 / 4096;
   it4 -= it3 << 12;
   it3 = it3 + iseed[3] * 2549 + iseed[4] * 2508;
   it2 = it3 / 4096;
   it3 -= it2 << 12;
   it2 = it2 + iseed[2] * 2549 + iseed[3] * 2508 + iseed[4] * 322;
   it1 = it2 / 4096;
   it2 -= it1 << 12;
   it1 = it1 + iseed[1] * 2549 + iseed[2] * 2508 + iseed[3] * 322 + iseed[4] * 494;
   it1 %= 4096;

   /*     return updated seed */

   iseed[1] = it1;
   iseed[2] = it2;
   iseed[3] = it3;
   iseed[4] = it4;

   /*     convert 48-bit integer to a double number in the interval (0,1) */

   ret_val = ((real_type)it1 + ((real_type)it2 + ((real_type)it3 + (real_type)it4 * 2.44140625e-4) * 2.44140625e-4) * 2.44140625e-4) * 2.44140625e-4;
   return ret_val;

   /*     End of RAN */

} /* ran_ */

/*

Double results:
~~~~~~~~~~~~~~

norm. resid      resid           machep         x(1)          x(n)
6.4915           7.207e-013      2.2204e-016    1             1



times are reported for matrices of order  1000
factor     solve      total     mflops       unit      ratio
times for array with leading dimension of1001
1.443     0.003      1.446     462.43       0.004325  25.821


mpf_class results:
~~~~~~~~~~~~~~~~~~

norm. resid      resid           machep         x(1)          x(n)
3.6575e-05       5.2257e-103     2.8575e-101    1             1



times are reported for matrices of order  1000
factor     solve      total     mflops       unit      ratio
times for array with leading dimension of1001
266.45     0.798      267.24    2.5021       0.79933   4772.2


number<gmp_float<100> >:
~~~~~~~~~~~~~~~~~~~~~~~~~~~

     norm. resid      resid           machep         x(1)          x(n)
  0.36575e-4          0.52257e-102   0.28575e-100    0.1e1         0.1e1



    times are reported for matrices of order  1000
      factor     solve      total     mflops       unit      ratio
 times for array with leading dimension of1001
      279.96        0.84       280.8      2.3813     0.83988      5014.3

boost::multiprecision::ef::cpp_dec_float_50:
~~~~~~~~~~~~~~~~~~~~~~~~~

     norm. resid      resid           machep         x(1)          x(n)
     2.551330735e-16  1.275665107e-112 1e-99         1             1



    times are reported for matrices of order  1000
      factor     solve      total     mflops       unit      ratio
 times for array with leading dimension of1001
      363.89      1.074     364.97    1.8321       1.0916    6517.3
*/


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "miller_rabin_performance.hpp"

unsigned allocation_count = 0;

void* (*alloc_func_ptr)(size_t);
void* (*realloc_func_ptr)(void*, size_t, size_t);
void (*free_func_ptr)(void*, size_t);

void* alloc_func(size_t n)
{
   ++allocation_count;
   return (*alloc_func_ptr)(n);
}

void free_func(void* p, size_t n)
{
   (*free_func_ptr)(p, n);
}

void* realloc_func(void* p, size_t old, size_t n)
{
   ++allocation_count;
   return (*realloc_func_ptr)(p, old, n);
}

#ifdef TEST_MPZ
boost::chrono::duration<double> test_miller_rabin_gmp()
{
   using namespace boost::random;
   using namespace boost::multiprecision;

   stopwatch<boost::chrono::high_resolution_clock> c;

   independent_bits_engine<mt11213b, 256, mpz_int> gen;

   for (unsigned i = 0; i < 1000; ++i)
   {
      mpz_int n = gen();
      mpz_probab_prime_p(n.backend().data(), 25);
   }
   return c.elapsed();
}
#endif

std::map<std::string, double> results;
double                        min_time = (std::numeric_limits<double>::max)();

void generate_quickbook()
{
   std::cout << "[table\n[[Integer Type][Relative Performance (Actual time in parenthesis)]]\n";

   std::map<std::string, double>::const_iterator i(results.begin()), j(results.end());

   while (i != j)
   {
      double rel = i->second / min_time;
      std::cout << "[[" << i->first << "][" << rel << "(" << i->second << "s)]]\n";
      ++i;
   }

   std::cout << "]\n";
}

int main()
{
   test01();
   test02();
   test03();
   test04();
   test05();
   test06();
   test07();
   test08();
   test09();
   test10();
   test11();
   test12();

   generate_quickbook();

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_CHRONO_HEADER_ONLY

#if !defined(TEST_MPZ) && !defined(TEST_TOMMATH) && !defined(TEST_CPP_INT)
#define TEST_MPZ
#define TEST_TOMMATH
#define TEST_CPP_INT
#endif

#ifdef TEST_MPZ
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#endif
#include <boost/multiprecision/miller_rabin.hpp>
#include <boost/chrono.hpp>
#include <boost/random.hpp>
#include <map>

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

extern unsigned allocation_count;

extern std::map<std::string, double> results;
extern double                        min_time;

template <class IntType>
boost::chrono::duration<double> test_miller_rabin(const char* name)
{
   using namespace boost::random;

   stopwatch<boost::chrono::high_resolution_clock> c;

   independent_bits_engine<mt11213b, 256, IntType> gen;
   //
   // We must use a different generator for the tests and number generation, otherwise
   // we get false positives.
   //
   mt19937  gen2;
   unsigned result_count = 0;

   for (unsigned i = 0; i < 1000; ++i)
   {
      IntType n = gen();
      if (boost::multiprecision::miller_rabin_test(n, 25, gen2))
         ++result_count;
   }
   boost::chrono::duration<double> t = c.elapsed();
   double                          d = t.count();
   if (d < min_time)
      min_time = d;
   results[name] = d;
   std::cout << "Time for " << std::setw(30) << std::left << name << " = " << d << std::endl;
   std::cout << "Number of primes found = " << result_count << std::endl;
   return t;
}

boost::chrono::duration<double> test_miller_rabin_gmp();

void test01();
void test02();
void test03();
void test04();
void test05();
void test06();
void test07();
void test08();
void test09();
void test10();
void test11();
void test12();
void test13();
void test14();
void test15();
void test16();
void test17();
void test18();
void test19();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance.log
================================================
Time for cpp_int (no Expression templates) = 0.0717379
Number of primes found = 9
Time for cpp_int                        = 0.0497465
Number of primes found = 9
Time for cpp_int (128-bit cache)        = 0.0490558
Number of primes found = 9
Time for cpp_int (256-bit cache)        = 0.0510209
Number of primes found = 9
Time for cpp_int (512-bit cache)        = 0.0458041
Number of primes found = 9
Time for cpp_int (1024-bit cache)       = 0.0478607
Number of primes found = 9
Time for uint1024_t                     = 0.0413295
Number of primes found = 9
Time for checked_uint1024_t             = 0.0422246
Number of primes found = 9
Time for mpz_int (no Expression templates) = 0.00443395
Number of primes found = 9
Time for mpz_int                        = 0.00466034
Number of primes found = 9
Time for mpz_int (native Miller Rabin Test) = 0.000165419 seconds
Time for tom_int (no Expression templates) = 0.274765
Number of primes found = 9
Time for tom_int                        = 0.0226395
Number of primes found = 9
[table
[[Integer Type][Relative Performance (Actual time in parenthesis)]]
[[checked_uint1024_t][9.52301(0.0422246s)]]
[[cpp_int][11.2194(0.0497465s)]]
[[cpp_int (1024-bit cache)][10.7941(0.0478607s)]]
[[cpp_int (128-bit cache)][11.0637(0.0490558s)]]
[[cpp_int (256-bit cache)][11.5069(0.0510209s)]]
[[cpp_int (512-bit cache)][10.3303(0.0458041s)]]
[[cpp_int (no Expression templates)][16.1792(0.0717379s)]]
[[mpz_int][1.05106(0.00466034s)]]
[[mpz_int (no Expression templates)][1(0.00443395s)]]
[[tom_int][5.10595(0.0226395s)]]
[[tom_int (no Expression templates)][61.9684(0.274765s)]]
[[uint1024_t][9.32113(0.0413295s)]]
]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test01.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test01()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<number<cpp_int_backend<>, et_off> >("cpp_int (no Expression templates)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test02.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test02()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<cpp_int>("cpp_int");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test03.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test03()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<number<cpp_int_backend<128> > >("cpp_int (128-bit cache)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test04.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test04()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<number<cpp_int_backend<256> > >("cpp_int (256-bit cache)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test05.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test05()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<number<cpp_int_backend<512> > >("cpp_int (512-bit cache)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test06.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test06()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<number<cpp_int_backend<1024> > >("cpp_int (1024-bit cache)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test07.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test07()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<uint1024_t>("uint1024_t");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test08.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test08()
{
   using namespace boost::multiprecision;
#ifdef TEST_CPP_INT
   test_miller_rabin<checked_uint1024_t>("checked_uint1024_t");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test09.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test09()
{
   using namespace boost::multiprecision;
#ifdef TEST_MPZ
   test_miller_rabin<number<gmp_int, et_off> >("mpz_int (no Expression templates)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test10()
{
   using namespace boost::multiprecision;
#ifdef TEST_MPZ
   test_miller_rabin<mpz_int>("mpz_int");
   std::cout << "Time for mpz_int (native Miller Rabin Test) = " << test_miller_rabin_gmp() << std::endl;
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test11()
{
   using namespace boost::multiprecision;
#ifdef TEST_TOMMATH
   test_miller_rabin<number<boost::multiprecision::tommath_int, et_off> >("tom_int (no Expression templates)");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/miller_rabin_performance_files/test12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../miller_rabin_performance.hpp"

void test12()
{
   using namespace boost::multiprecision;
#ifdef TEST_TOMMATH
   test_miller_rabin<boost::multiprecision::tom_int>("tom_int");
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/mixed_equivalent_types_bench.cpp
================================================
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/random.hpp>
#include <boost/math/special_functions/ellint_2.hpp>
#include <cmath>


using namespace boost::multiprecision;
using namespace boost::random;

unsigned allocation_count = 0;

void* operator new(std::size_t count)
{
   ++allocation_count;
   return std::malloc(count);
}
void* operator new[](std::size_t count)
{
   ++allocation_count;
   return std::malloc(count);
}
void operator delete(void* ptr)noexcept
{
   std::free(ptr);
}
void operator delete[](void* ptr) noexcept
{
   std::free(ptr);
}

template <class T>
std::tuple<std::vector<T>, std::vector<T> >& get_test_vector(unsigned bits)
{
   static std::map<unsigned, std::tuple<std::vector<T>, std::vector<T> > > data;

   std::tuple<std::vector<T>, std::vector<T> >& result = data[bits];

   if (std::get<0>(result).size() == 0)
   {
      mt19937                     mt;
      uniform_int_distribution<T> ui(T(1) << (bits - 1), T(1) << bits);

      std::vector<T>& a = std::get<0>(result);
      std::vector<T>& b = std::get<1>(result);

      for (unsigned i = 0; i < 1000; ++i)
      {
         a.push_back(ui(mt));
         b.push_back(ui(mt));
      }
   }
   return result;
}

template <class T>
std::vector<T>& get_test_vector_a(unsigned bits)
{
   return std::get<0>(get_test_vector<T>(bits));
}
template <class T>
std::vector<T>& get_test_vector_b(unsigned bits)
{
   return std::get<1>(get_test_vector<T>(bits));
}

using namespace boost::multiprecision;

//[dot_prod_1
cpp_int dot_product_1(const std::vector<cpp_int>& v1, const std::vector<cpp_int>& v2)
{
   if (v1.size() != v2.size())
      throw std::domain_error("Mismatched arguments");

   cpp_int result;
   for (std::size_t i = 0; i < v1.size(); ++i)
      result += v1[i] * v2[i];
   //
   // Named-return value optimisation (even better than a move):
   //
   return result;
}
//]
//[dot_prod_2
cpp_int dot_product_2(const std::vector<cpp_int>& v1, const std::vector<cpp_int>& v2)
{
   if (v1.size() != v2.size())
      throw std::domain_error("Mismatched arguments");
   //
   // If we know that most of our data is of a certain range of values, then we can use a cpp_int type
   // with an internal cache large enough to *probably* not require an allocation:
   //
   number<cpp_int_backend<1024> > result;
   for (std::size_t i = 0; i < v1.size(); ++i)
      result += v1[i] * v2[i];
   //
   // We can't rely on the named-return-value optimisation here, since the variable being returned
   // is a different type to the return value.  However, since these are "equivalent" types we
   // can move the result to the return value and get all the expected move-optimisations should
   // variable result have dynamically allocated:
   //
   return std::move(result);
}
//]
//[dot_prod_3
cpp_int dot_product_3(const std::vector<cpp_int>& v1, const std::vector<cpp_int>& v2)
{
   if (v1.size() != v2.size())
      throw std::domain_error("Mismatched arguments");

   cpp_int result, term;
   for (std::size_t i = 0; i < v1.size(); ++i)
   {
      //
      // Re-use the same variable for the result of the multiplications, rather than rely on 
      // an internally generated temporary.  Depending on the input data, this may allocate
      // a few times depending how soon in the input vector's we encounter the largest values.
      // In the best case though, or for fairly uniformly sized input data, we will allocate 
      // only once:
      //
      term = v1[i] * v2[i];
      result += term;
   }
   //
   // Named-return value optimisation (even better than a move):
   //
   return result;
}
//]

template <typename T>
static void BM_dot_product_1(benchmark::State& state)
{
   int bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);

   static int done = 0;
   if (done != bits)
   {
      allocation_count = 0;
      benchmark::DoNotOptimize(dot_product_1(a, b));
      std::cout << allocation_count << std::endl;
      done = bits;
   }

   for (auto _ : state)
   {
      benchmark::DoNotOptimize(dot_product_1(a, b));
   }
   state.SetComplexityN(bits);
}
template <typename T>
static void BM_dot_product_2(benchmark::State& state)
{
   int                         bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);

   static int done = 0;
   if (done != bits)
   {
      allocation_count = 0;
      benchmark::DoNotOptimize(dot_product_2(a, b));
      std::cout << allocation_count << std::endl;
      done = bits;
   }

   for (auto _ : state)
   {
      benchmark::DoNotOptimize(dot_product_2(a, b));
   }
   state.SetComplexityN(bits);
}
template <typename T>
static void BM_dot_product_3(benchmark::State& state)
{
   int                         bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);

   static int done = 0;
   if (done != bits)
   {
      allocation_count = 0;
      benchmark::DoNotOptimize(dot_product_3(a, b));
      std::cout << allocation_count << std::endl;
      done = bits;
   }

   for (auto _ : state)
   {
      benchmark::DoNotOptimize(dot_product_3(a, b));
   }
   state.SetComplexityN(bits);
}
//[elliptic_arc1
template <unsigned N>
number<mpfr_float_backend<N> > elliptic_arc_length_1(const number<mpfr_float_backend<N> >& a, const number<mpfr_float_backend<N> >& b)
{
   number<mpfr_float_backend<N> > k = sqrt(1 - b * b / (a * a));
   return 4 * a * boost::math::ellint_2(k);
}
//]
//[elliptic_arc2
template <unsigned N>
number<mpfr_float_backend<N> > elliptic_arc_length_2(const number<mpfr_float_backend<N> >& a, const number<mpfr_float_backend<N> >& b)
{
   number<mpfr_float_backend<N, allocate_stack> > k = sqrt(1 - b * b / (a * a));
   return 4 * a * boost::math::ellint_2(k);
}
//]

template <typename T>
static void BM_elliptic_1(benchmark::State& state)
{
   T a = 25.25 * boost::math::constants::e<T>();
   T b = 3.75 * boost::math::constants::e<T>();

   //std::cout << elliptic_arc_length_1(a, b) << std::endl;

   for (auto _ : state)
   {
      benchmark::DoNotOptimize(elliptic_arc_length_1(a, b));
   }
}
template <typename T>
static void BM_elliptic_2(benchmark::State& state)
{
   T a = 25.25 * boost::math::constants::e<T>();
   T b = 3.75 * boost::math::constants::e<T>();

   //std::cout << elliptic_arc_length_2(a, b) << std::endl;

   for (auto _ : state)
   {
      benchmark::DoNotOptimize(elliptic_arc_length_2(a, b));
   }
}

constexpr unsigned lower_range = 32;
constexpr unsigned upper_range = 1024;

BENCHMARK_TEMPLATE(BM_dot_product_1, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_dot_product_1, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_dot_product_2, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_dot_product_3, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();

BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<30> >);
BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<40> >);
BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<50> >);
BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<60> >);
BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<70> >);
BENCHMARK_TEMPLATE(BM_elliptic_1, number<mpfr_float_backend<80> >);

BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<30> >);
BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<40> >);
BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<50> >);
BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<60> >);
BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<70> >);
BENCHMARK_TEMPLATE(BM_elliptic_2, number<mpfr_float_backend<80> >);

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test-gcc-linux.log
================================================
gmp_float      50        +    0.0180885
gmp_float      50        -    0.0227712
gmp_float      50        *    0.0567584
gmp_float      50        /    0.289062
gmp_float      50        str  0.00354863
gmp_float      50        +(int)0.0129337
gmp_float      50        -(int)0.0256267
gmp_float      50        *(int)0.0197258
gmp_float      50        /(int)0.087785
gmp_float      100       +    0.0196977
gmp_float      100       -    0.024745
gmp_float      100       *    0.0972
gmp_float      100       /    0.393792
gmp_float      100       str  0.00528245
gmp_float      100       +(int)0.0154802
gmp_float      100       -(int)0.0242376
gmp_float      100       *(int)0.0251239
gmp_float      100       /(int)0.100588
gmp_float      500       +    0.034133
gmp_float      500       -    0.0411447
gmp_float      500       *    0.938779
gmp_float      500       /    1.5973
gmp_float      500       str  0.0406575
gmp_float      500       +(int)0.0220839
gmp_float      500       -(int)0.0310849
gmp_float      500       *(int)0.046899
gmp_float      500       /(int)0.240511
gmp_int        128       +    0.0236625
gmp_int        128       -    0.0255431
gmp_int        128       *    0.0164612
gmp_int        128       /    0.20205
gmp_int        128       str  0.000397397
gmp_int        128       +(int)0.00907029
gmp_int        128       -(int)0.0120936
gmp_int        128       *(int)0.0139764
gmp_int        128       /(int)0.061181
gmp_int        128       %    0.167724
gmp_int        128       |    0.0126627
gmp_int        128       &    0.0129377
gmp_int        128       ^    0.0136018
gmp_int        128       <<   0.0109566
gmp_int        128       >>   0.0107283
gmp_int        128       %(int)0.0408971
gmp_int        128       |(int)0.0463637
gmp_int        128       &(int)0.0502028
gmp_int        128       ^(int)0.047593
gmp_int        128       gcd  0.452707
gmp_int        256       +    0.0257277
gmp_int        256       -    0.0314085
gmp_int        256       *    0.0495293
gmp_int        256       /    0.242695
gmp_int        256       str  0.000617745
gmp_int        256       +(int)0.0129046
gmp_int        256       -(int)0.0163165
gmp_int        256       *(int)0.0153128
gmp_int        256       /(int)0.0730963
gmp_int        256       %    0.203102
gmp_int        256       |    0.0149383
gmp_int        256       &    0.0170717
gmp_int        256       ^    0.0160796
gmp_int        256       <<   0.0146023
gmp_int        256       >>   0.010293
gmp_int        256       %(int)0.0525884
gmp_int        256       |(int)0.0501017
gmp_int        256       &(int)0.0508389
gmp_int        256       ^(int)0.0498771
gmp_int        256       gcd  2.17179
gmp_int        512       +    0.0283556
gmp_int        512       -    0.0398509
gmp_int        512       *    0.104633
gmp_int        512       /    0.294206
gmp_int        512       str  0.00125749
gmp_int        512       +(int)0.0156938
gmp_int        512       -(int)0.0204795
gmp_int        512       *(int)0.0190714
gmp_int        512       /(int)0.09638
gmp_int        512       %    0.23687
gmp_int        512       |    0.0244134
gmp_int        512       &    0.0209509
gmp_int        512       ^    0.0266707
gmp_int        512       <<   0.0178981
gmp_int        512       >>   0.0122496
gmp_int        512       %(int)0.0655264
gmp_int        512       |(int)0.0536497
gmp_int        512       &(int)0.0532932
gmp_int        512       ^(int)0.0540655
gmp_int        512       gcd  4.86569
gmp_int        1024      +    0.0417292
gmp_int        1024      -    0.0504965
gmp_int        1024      *    0.330741
gmp_int        1024      /    0.376529
gmp_int        1024      str  0.00295526
gmp_int        1024      +(int)0.0258726
gmp_int        1024      -(int)0.0235972
gmp_int        1024      *(int)0.0326542
gmp_int        1024      /(int)0.148103
gmp_int        1024      %    0.301177
gmp_int        1024      |    0.0262977
gmp_int        1024      &    0.0235786
gmp_int        1024      ^    0.0254182
gmp_int        1024      <<   0.0206225
gmp_int        1024      >>   0.012848
gmp_int        1024      %(int)0.0765616
gmp_int        1024      |(int)0.0495613
gmp_int        1024      &(int)0.0512979
gmp_int        1024      ^(int)0.0491785
gmp_int        1024      gcd  10.2899
cpp_int        128       +    0.0226262
cpp_int        128       -    0.0256171
cpp_int        128       *    0.0363846
cpp_int        128       /    0.227187
cpp_int        128       str  0.000703371
cpp_int        128       +(int)0.0156956
cpp_int        128       -(int)0.0122229
cpp_int        128       *(int)0.0257193
cpp_int        128       /(int)0.129609
cpp_int        128       %    0.226534
cpp_int        128       |    0.0242976
cpp_int        128       &    0.0244482
cpp_int        128       ^    0.0243197
cpp_int        128       <<   0.0182175
cpp_int        128       >>   0.0215535
cpp_int        128       %(int)0.181554
cpp_int        128       |(int)0.0454215
cpp_int        128       &(int)0.0426893
cpp_int        128       ^(int)0.0404509
cpp_int        128       gcd  4.16823
cpp_int        256       +    0.0275581
cpp_int        256       -    0.0305114
cpp_int        256       *    0.100083
cpp_int        256       /    0.467116
cpp_int        256       str  0.00181769
cpp_int        256       +(int)0.017033
cpp_int        256       -(int)0.0143035
cpp_int        256       *(int)0.0294836
cpp_int        256       /(int)0.303922
cpp_int        256       %    0.435207
cpp_int        256       |    0.0281237
cpp_int        256       &    0.028049
cpp_int        256       ^    0.0280192
cpp_int        256       <<   0.0210768
cpp_int        256       >>   0.0175781
cpp_int        256       %(int)0.279274
cpp_int        256       |(int)0.0323883
cpp_int        256       &(int)0.0338674
cpp_int        256       ^(int)0.0299941
cpp_int        256       gcd  8.51244
cpp_int        512       +    0.033691
cpp_int        512       -    0.0422701
cpp_int        512       *    0.343683
cpp_int        512       /    0.755608
cpp_int        512       str  0.00434022
cpp_int        512       +(int)0.0196755
cpp_int        512       -(int)0.0171212
cpp_int        512       *(int)0.039305
cpp_int        512       /(int)0.535727
cpp_int        512       %    0.719958
cpp_int        512       |    0.0339623
cpp_int        512       &    0.0342017
cpp_int        512       ^    0.033929
cpp_int        512       <<   0.0269161
cpp_int        512       >>   0.0216914
cpp_int        512       %(int)0.53345
cpp_int        512       |(int)0.0324562
cpp_int        512       &(int)0.0424884
cpp_int        512       ^(int)0.0323887
cpp_int        512       gcd  19.489
cpp_int        1024      +    0.0456764
cpp_int        1024      -    0.0574919
cpp_int        1024      *    1.28548
cpp_int        1024      /    1.30086
cpp_int        1024      str  0.0122363
cpp_int        1024      +(int)0.0241476
cpp_int        1024      -(int)0.0212992
cpp_int        1024      *(int)0.0540818
cpp_int        1024      /(int)1.00179
cpp_int        1024      %    1.27181
cpp_int        1024      |    0.0457886
cpp_int        1024      &    0.0456006
cpp_int        1024      ^    0.0456494
cpp_int        1024      <<   0.0394128
cpp_int        1024      >>   0.0294462
cpp_int        1024      %(int)0.962651
cpp_int        1024      |(int)0.0372077
cpp_int        1024      &(int)0.0577198
cpp_int        1024      ^(int)0.0372218
cpp_int        1024      gcd  47.7651
cpp_int(fixed) 128       +    0.0183948
cpp_int(fixed) 128       -    0.0182905
cpp_int(fixed) 128       *    0.0201727
cpp_int(fixed) 128       /    0.206852
cpp_int(fixed) 128       str  0.000630107
cpp_int(fixed) 128       +(int)0.00967714
cpp_int(fixed) 128       -(int)0.00810627
cpp_int(fixed) 128       *(int)0.0183201
cpp_int(fixed) 128       /(int)0.111309
cpp_int(fixed) 128       %    0.204164
cpp_int(fixed) 128       |    0.0136789
cpp_int(fixed) 128       &    0.0143848
cpp_int(fixed) 128       ^    0.0137773
cpp_int(fixed) 128       <<   0.0131154
cpp_int(fixed) 128       >>   0.00912176
cpp_int(fixed) 128       %(int)0.115583
cpp_int(fixed) 128       |(int)0.0164462
cpp_int(fixed) 128       &(int)0.0169816
cpp_int(fixed) 128       ^(int)0.014607
cpp_int(fixed) 128       gcd  2.87326
cpp_int(fixed) 256       +    0.0217614
cpp_int(fixed) 256       -    0.0208437
cpp_int(fixed) 256       *    0.0385279
cpp_int(fixed) 256       /    0.321272
cpp_int(fixed) 256       str  0.00149991
cpp_int(fixed) 256       +(int)0.0102395
cpp_int(fixed) 256       -(int)0.00923316
cpp_int(fixed) 256       *(int)0.021549
cpp_int(fixed) 256       /(int)0.219146
cpp_int(fixed) 256       %    0.321039
cpp_int(fixed) 256       |    0.0154596
cpp_int(fixed) 256       &    0.0156443
cpp_int(fixed) 256       ^    0.015493
cpp_int(fixed) 256       <<   0.0169546
cpp_int(fixed) 256       >>   0.0114138
cpp_int(fixed) 256       %(int)0.238857
cpp_int(fixed) 256       |(int)0.015725
cpp_int(fixed) 256       &(int)0.021641
cpp_int(fixed) 256       ^(int)0.0163443
cpp_int(fixed) 256       gcd  6.68597
cpp_int(fixed) 512       +    0.0284799
cpp_int(fixed) 512       -    0.028304
cpp_int(fixed) 512       *    0.119904
cpp_int(fixed) 512       /    0.616699
cpp_int(fixed) 512       str  0.00415653
cpp_int(fixed) 512       +(int)0.0122821
cpp_int(fixed) 512       -(int)0.0110103
cpp_int(fixed) 512       *(int)0.0283635
cpp_int(fixed) 512       /(int)0.451373
cpp_int(fixed) 512       %    0.620217
cpp_int(fixed) 512       |    0.0189862
cpp_int(fixed) 512       &    0.0192657
cpp_int(fixed) 512       ^    0.018973
cpp_int(fixed) 512       <<   0.0188263
cpp_int(fixed) 512       >>   0.0152103
cpp_int(fixed) 512       %(int)0.491398
cpp_int(fixed) 512       |(int)0.0182191
cpp_int(fixed) 512       &(int)0.0277722
cpp_int(fixed) 512       ^(int)0.0182565
cpp_int(fixed) 512       gcd  16.1788
cpp_int(fixed) 1024      +    0.0396571
cpp_int(fixed) 1024      -    0.0413187
cpp_int(fixed) 1024      *    0.371065
cpp_int(fixed) 1024      /    1.09072
cpp_int(fixed) 1024      str  0.011546
cpp_int(fixed) 1024      +(int)0.0254102
cpp_int(fixed) 1024      -(int)0.020939
cpp_int(fixed) 1024      *(int)0.0494233
cpp_int(fixed) 1024      /(int)0.870306
cpp_int(fixed) 1024      %    1.09888
cpp_int(fixed) 1024      |    0.0393824
cpp_int(fixed) 1024      &    0.0397966
cpp_int(fixed) 1024      ^    0.0394082
cpp_int(fixed) 1024      <<   0.0392477
cpp_int(fixed) 1024      >>   0.0214742
cpp_int(fixed) 1024      %(int)0.941513
cpp_int(fixed) 1024      |(int)0.0304613
cpp_int(fixed) 1024      &(int)0.0497983
cpp_int(fixed) 1024      ^(int)0.0333848
cpp_int(fixed) 1024      gcd  41.9178
cpp_rational   128       +    8.33358
cpp_rational   128       -    8.3543
cpp_rational   128       *    15.3196
cpp_rational   128       /    31.794
cpp_rational   128       str  0.00980984
cpp_rational   128       +(int)1.14042
cpp_rational   128       -(int)1.13947
cpp_rational   128       *(int)1.3425
cpp_rational   128       /(int)1.35276
cpp_rational   256       +    24.5753
cpp_rational   256       -    24.3831
cpp_rational   256       *    45.9283
cpp_rational   256       /    80.7871
cpp_rational   256       str  0.0288878
cpp_rational   256       +(int)1.54697
cpp_rational   256       -(int)1.55711
cpp_rational   256       *(int)2.05921
cpp_rational   256       /(int)2.12933
cpp_rational   512       +    58.1983
cpp_rational   512       -    58.3044
cpp_rational   512       *    111.528
cpp_rational   512       /    184.73
cpp_rational   512       str  0.067039
cpp_rational   512       +(int)1.83113
cpp_rational   512       -(int)1.82889
cpp_rational   512       *(int)2.75206
cpp_rational   512       /(int)2.75885
cpp_rational   1024      +    139.884
cpp_rational   1024      -    139.665
cpp_rational   1024      *    270.253
cpp_rational   1024      /    436.471
cpp_rational   1024      str  0.165057
cpp_rational   1024      +(int)2.65768
cpp_rational   1024      -(int)2.68279
cpp_rational   1024      *(int)4.26866
cpp_rational   1024      /(int)4.27228
mpq_rational   128       +    0.518878
mpq_rational   128       -    0.520249
mpq_rational   128       *    0.940549
mpq_rational   128       /    2.63335
mpq_rational   128       str  0.000732008
mpq_rational   128       +(int)0.145745
mpq_rational   128       -(int)0.142505
mpq_rational   128       *(int)0.173305
mpq_rational   128       /(int)0.178914
mpq_rational   256       +    2.2747
mpq_rational   256       -    2.27886
mpq_rational   256       *    4.27402
mpq_rational   256       /    8.07149
mpq_rational   256       str  0.00123256
mpq_rational   256       +(int)0.164417
mpq_rational   256       -(int)0.161741
mpq_rational   256       *(int)0.193095
mpq_rational   256       /(int)0.202255
mpq_rational   512       +    5.09463
mpq_rational   512       -    5.09757
mpq_rational   512       *    9.6481
mpq_rational   512       /    16.9064
mpq_rational   512       str  0.00244388
mpq_rational   512       +(int)0.202901
mpq_rational   512       -(int)0.200644
mpq_rational   512       *(int)0.248942
mpq_rational   512       /(int)0.251928
mpq_rational   1024      +    11.2492
mpq_rational   1024      -    11.2528
mpq_rational   1024      *    21.0227
mpq_rational   1024      /    35.7647
mpq_rational   1024      str  0.00559869
mpq_rational   1024      +(int)0.287349
mpq_rational   1024      -(int)0.28136
mpq_rational   1024      *(int)0.337805
mpq_rational   1024      /(int)0.351164
tommath_int    128       +    0.0169999
tommath_int    128       -    0.025088
tommath_int    128       *    0.0608098
tommath_int    128       /    1.14807
tommath_int    128       str  0.00864677
tommath_int    128       +(int)0.170239
tommath_int    128       -(int)0.169805
tommath_int    128       *(int)0.18998
tommath_int    128       /(int)0.936106
tommath_int    128       %    1.10993
tommath_int    128       |    0.0742258
tommath_int    128       &    0.0747022
tommath_int    128       ^    0.0734074
tommath_int    128       <<   0.0316344
tommath_int    128       >>   0.139155
tommath_int    128       %(int)0.871093
tommath_int    128       |(int)0.249135
tommath_int    128       &(int)0.224394
tommath_int    128       ^(int)0.248407
tommath_int    128       gcd  7.6073
tommath_int    256       +    0.0191462
tommath_int    256       -    0.0267191
tommath_int    256       *    0.0843842
tommath_int    256       /    1.34052
tommath_int    256       str  0.0212684
tommath_int    256       +(int)0.173633
tommath_int    256       -(int)0.173084
tommath_int    256       *(int)0.20074
tommath_int    256       /(int)1.17192
tommath_int    256       %    1.33781
tommath_int    256       |    0.0740269
tommath_int    256       &    0.0747001
tommath_int    256       ^    0.0741847
tommath_int    256       <<   0.0379471
tommath_int    256       >>   0.14164
tommath_int    256       %(int)1.52193
tommath_int    256       |(int)0.251418
tommath_int    256       &(int)0.230435
tommath_int    256       ^(int)0.249516
tommath_int    256       gcd  15.8851
tommath_int    512       +    0.0241933
tommath_int    512       -    0.032154
tommath_int    512       *    0.195855
tommath_int    512       /    2.061
tommath_int    512       str  0.0827649
tommath_int    512       +(int)0.25223
tommath_int    512       -(int)0.25482
tommath_int    512       *(int)0.305608
tommath_int    512       /(int)1.76155
tommath_int    512       %    1.97453
tommath_int    512       |    0.0795209
tommath_int    512       &    0.0815029
tommath_int    512       ^    0.0793004
tommath_int    512       <<   0.0449753
tommath_int    512       >>   0.149597
tommath_int    512       %(int)1.74258
tommath_int    512       |(int)0.253519
tommath_int    512       &(int)0.235246
tommath_int    512       ^(int)0.261762
tommath_int    512       gcd  33.8904
tommath_int    1024      +    0.0356467
tommath_int    1024      -    0.0426379
tommath_int    1024      *    0.563154
tommath_int    1024      /    3.3106
tommath_int    1024      str  0.200351
tommath_int    1024      +(int)0.183982
tommath_int    1024      -(int)0.182348
tommath_int    1024      *(int)0.265242
tommath_int    1024      /(int)2.99248
tommath_int    1024      %    3.36442
tommath_int    1024      |    0.0935681
tommath_int    1024      &    0.0990244
tommath_int    1024      ^    0.0948247
tommath_int    1024      <<   0.0671463
tommath_int    1024      >>   0.167341
tommath_int    1024      %(int)2.8911
tommath_int    1024      |(int)0.26358
tommath_int    1024      &(int)0.244976
tommath_int    1024      ^(int)0.261357
tommath_int    1024      gcd  67.1657
cpp_dec_float  50        +    0.0139248
cpp_dec_float  50        -    0.0142418
cpp_dec_float  50        *    0.118247
cpp_dec_float  50        /    1.82747
cpp_dec_float  50        str  0.00932849
cpp_dec_float  50        +(int)0.0253923
cpp_dec_float  50        -(int)0.0248418
cpp_dec_float  50        *(int)0.0371704
cpp_dec_float  50        /(int)0.199883
cpp_dec_float  100       +    0.0171021
cpp_dec_float  100       -    0.0176287
cpp_dec_float  100       *    0.237033
cpp_dec_float  100       /    3.63766
cpp_dec_float  100       str  0.0201057
cpp_dec_float  100       +(int)0.0330663
cpp_dec_float  100       -(int)0.0332922
cpp_dec_float  100       *(int)0.0606472
cpp_dec_float  100       /(int)0.343778
cpp_dec_float  500       +    0.043194
cpp_dec_float  500       -    0.0443422
cpp_dec_float  500       *    2.12299
cpp_dec_float  500       /    25.7245
cpp_dec_float  500       str  0.0655127
cpp_dec_float  500       +(int)0.0706977
cpp_dec_float  500       -(int)0.0727089
cpp_dec_float  500       *(int)0.239796
cpp_dec_float  500       /(int)1.39609
mpfr_float     50        +    0.019179
mpfr_float     50        -    0.0225632
mpfr_float     50        *    0.0588765
mpfr_float     50        /    0.317276
mpfr_float     50        str  0.00725414
mpfr_float     50        +(int)0.0286079
mpfr_float     50        -(int)0.0465151
mpfr_float     50        *(int)0.0362579
mpfr_float     50        /(int)0.0888645
mpfr_float     100       +    0.0210236
mpfr_float     100       -    0.0250703
mpfr_float     100       *    0.0946262
mpfr_float     100       /    0.456375
mpfr_float     100       str  0.00900848
mpfr_float     100       +(int)0.0320443
mpfr_float     100       -(int)0.0487733
mpfr_float     100       *(int)0.0437034
mpfr_float     100       /(int)0.154203
mpfr_float     500       +    0.033691
mpfr_float     500       -    0.0371954
mpfr_float     500       *    0.851721
mpfr_float     500       /    2.7946
mpfr_float     500       str  0.0342011
mpfr_float     500       +(int)0.0414774
mpfr_float     500       -(int)0.0616173
mpfr_float     500       *(int)0.0826485
mpfr_float     500       /(int)0.254227
[section:float_performance Float Type Perfomance]
[table Operator *
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][2.08334 (0.118247s)][2.50494 (0.237033s)][2.49259 (2.12299s)]]
[[gmp_float][[*1] (0.0567584s)][1.0272 (0.0972s)][1.10221 (0.938779s)]]
[[mpfr_float][1.03732 (0.0588765s)][[*1] (0.0946262s)][[*1] (0.851721s)]]
]
[table Operator *(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][1.88436 (0.0371704s)][2.41392 (0.0606472s)][5.11303 (0.239796s)]]
[[gmp_float][[*1] (0.0197258s)][[*1] (0.0251239s)][[*1] (0.046899s)]]
[[mpfr_float][1.8381 (0.0362579s)][1.73951 (0.0437034s)][1.76227 (0.0826485s)]]
]
[table Operator +
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0139248s)][[*1] (0.0171021s)][1.28206 (0.043194s)]]
[[gmp_float][1.29901 (0.0180885s)][1.15177 (0.0196977s)][1.01312 (0.034133s)]]
[[mpfr_float][1.37732 (0.019179s)][1.2293 (0.0210236s)][[*1] (0.033691s)]]
]
[table Operator +(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][1.96327 (0.0253923s)][2.13604 (0.0330663s)][3.20133 (0.0706977s)]]
[[gmp_float][[*1] (0.0129337s)][[*1] (0.0154802s)][[*1] (0.0220839s)]]
[[mpfr_float][2.21189 (0.0286079s)][2.07002 (0.0320443s)][1.87818 (0.0414774s)]]
]
[table Operator -
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0142418s)][[*1] (0.0176287s)][1.19214 (0.0443422s)]]
[[gmp_float][1.5989 (0.0227712s)][1.40368 (0.024745s)][1.10618 (0.0411447s)]]
[[mpfr_float][1.5843 (0.0225632s)][1.42213 (0.0250703s)][[*1] (0.0371954s)]]
]
[table Operator -(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0248418s)][1.37357 (0.0332922s)][2.33904 (0.0727089s)]]
[[gmp_float][1.03159 (0.0256267s)][[*1] (0.0242376s)][[*1] (0.0310849s)]]
[[mpfr_float][1.87245 (0.0465151s)][2.0123 (0.0487733s)][1.98223 (0.0616173s)]]
]
[table Operator /
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][6.32206 (1.82747s)][9.23752 (3.63766s)][16.1049 (25.7245s)]]
[[gmp_float][[*1] (0.289062s)][[*1] (0.393792s)][[*1] (1.5973s)]]
[[mpfr_float][1.09761 (0.317276s)][1.15892 (0.456375s)][1.74957 (2.7946s)]]
]
[table Operator /(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][2.27696 (0.199883s)][3.41769 (0.343778s)][5.8047 (1.39609s)]]
[[gmp_float][[*1] (0.087785s)][[*1] (0.100588s)][[*1] (0.240511s)]]
[[mpfr_float][1.0123 (0.0888645s)][1.53302 (0.154203s)][1.05703 (0.254227s)]]
]
[table Operator str
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][2.62876 (0.00932849s)][3.80613 (0.0201057s)][1.91552 (0.0655127s)]]
[[gmp_float][[*1] (0.00354863s)][[*1] (0.00528245s)][1.18878 (0.0406575s)]]
[[mpfr_float][2.04421 (0.00725414s)][1.70536 (0.00900848s)][[*1] (0.0342011s)]]
]
[endsect]
[section:integer_performance Integer Type Perfomance]
[table Operator %
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.35064 (0.226534s)][2.1428 (0.435207s)][3.03946 (0.719958s)][4.22281 (1.27181s)]]
[[cpp_int(fixed)][1.21726 (0.204164s)][1.58068 (0.321039s)][2.61838 (0.620217s)][3.6486 (1.09888s)]]
[[gmp_int][[*1] (0.167724s)][[*1] (0.203102s)][[*1] (0.23687s)][[*1] (0.301177s)]]
[[tommath_int][6.61759 (1.10993s)][6.58689 (1.33781s)][8.33593 (1.97453s)][11.1709 (3.36442s)]]
]
[table Operator %(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][4.43928 (0.181554s)][5.31056 (0.279274s)][8.141 (0.53345s)][12.5735 (0.962651s)]]
[[cpp_int(fixed)][2.82619 (0.115583s)][4.54202 (0.238857s)][7.49924 (0.491398s)][12.2974 (0.941513s)]]
[[gmp_int][[*1] (0.0408971s)][[*1] (0.0525884s)][[*1] (0.0655264s)][[*1] (0.0765616s)]]
[[tommath_int][21.2996 (0.871093s)][28.9405 (1.52193s)][26.5936 (1.74258s)][37.7618 (2.8911s)]]
]
[table Operator &
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.88968 (0.0244482s)][1.79292 (0.028049s)][1.77526 (0.0342017s)][1.93398 (0.0456006s)]]
[[cpp_int(fixed)][1.11185 (0.0143848s)][[*1] (0.0156443s)][[*1] (0.0192657s)][1.68783 (0.0397966s)]]
[[gmp_int][[*1] (0.0129377s)][1.09124 (0.0170717s)][1.08747 (0.0209509s)][[*1] (0.0235786s)]]
[[tommath_int][5.77397 (0.0747022s)][4.7749 (0.0747001s)][4.23046 (0.0815029s)][4.19976 (0.0990244s)]]
]
[table Operator &(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.51385 (0.0426893s)][1.56497 (0.0338674s)][1.52989 (0.0424884s)][1.15907 (0.0577198s)]]
[[cpp_int(fixed)][[*1] (0.0169816s)][[*1] (0.021641s)][[*1] (0.0277722s)][[*1] (0.0497983s)]]
[[gmp_int][2.9563 (0.0502028s)][2.3492 (0.0508389s)][1.91894 (0.0532932s)][1.03011 (0.0512979s)]]
[[tommath_int][13.2139 (0.224394s)][10.6481 (0.230435s)][8.47057 (0.235246s)][4.91936 (0.244976s)]]
]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.21032 (0.0363846s)][2.59769 (0.100083s)][3.28466 (0.343683s)][3.88666 (1.28548s)]]
[[cpp_int(fixed)][1.22547 (0.0201727s)][[*1] (0.0385279s)][1.14595 (0.119904s)][1.12192 (0.371065s)]]
[[gmp_int][[*1] (0.0164612s)][1.28554 (0.0495293s)][[*1] (0.104633s)][[*1] (0.330741s)]]
[[tommath_int][3.69412 (0.0608098s)][2.19021 (0.0843842s)][1.87184 (0.195855s)][1.70271 (0.563154s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.8402 (0.0257193s)][1.92542 (0.0294836s)][2.06094 (0.039305s)][1.6562 (0.0540818s)]]
[[cpp_int(fixed)][1.3108 (0.0183201s)][1.40725 (0.021549s)][1.48723 (0.0283635s)][1.51354 (0.0494233s)]]
[[gmp_int][[*1] (0.0139764s)][[*1] (0.0153128s)][[*1] (0.0190714s)][[*1] (0.0326542s)]]
[[tommath_int][13.593 (0.18998s)][13.1093 (0.20074s)][16.0244 (0.305608s)][8.12274 (0.265242s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.33096 (0.0226262s)][1.43935 (0.0275581s)][1.39258 (0.033691s)][1.28136 (0.0456764s)]]
[[cpp_int(fixed)][1.08205 (0.0183948s)][1.13659 (0.0217614s)][1.17718 (0.0284799s)][1.1125 (0.0396571s)]]
[[gmp_int][1.39192 (0.0236625s)][1.34375 (0.0257277s)][1.17204 (0.0283556s)][1.17063 (0.0417292s)]]
[[tommath_int][[*1] (0.0169999s)][[*1] (0.0191462s)][[*1] (0.0241933s)][[*1] (0.0356467s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.73044 (0.0156956s)][1.66346 (0.017033s)][1.60196 (0.0196755s)][[*1] (0.0241476s)]]
[[cpp_int(fixed)][1.06691 (0.00967714s)][[*1] (0.0102395s)][[*1] (0.0122821s)][1.05229 (0.0254102s)]]
[[gmp_int][[*1] (0.00907029s)][1.26028 (0.0129046s)][1.27777 (0.0156938s)][1.07144 (0.0258726s)]]
[[tommath_int][18.7688 (0.170239s)][16.9572 (0.173633s)][20.5363 (0.25223s)][7.61905 (0.183982s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.40057 (0.0256171s)][1.46382 (0.0305114s)][1.49343 (0.0422701s)][1.39142 (0.0574919s)]]
[[cpp_int(fixed)][[*1] (0.0182905s)][[*1] (0.0208437s)][[*1] (0.028304s)][[*1] (0.0413187s)]]
[[gmp_int][1.39653 (0.0255431s)][1.50686 (0.0314085s)][1.40796 (0.0398509s)][1.22212 (0.0504965s)]]
[[tommath_int][1.37164 (0.025088s)][1.28188 (0.0267191s)][1.13602 (0.032154s)][1.03193 (0.0426379s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.50784 (0.0122229s)][1.54914 (0.0143035s)][1.55501 (0.0171212s)][1.0172 (0.0212992s)]]
[[cpp_int(fixed)][[*1] (0.00810627s)][[*1] (0.00923316s)][[*1] (0.0110103s)][[*1] (0.020939s)]]
[[gmp_int][1.49189 (0.0120936s)][1.76716 (0.0163165s)][1.86002 (0.0204795s)][1.12695 (0.0235972s)]]
[[tommath_int][20.9474 (0.169805s)][18.7459 (0.173084s)][23.1437 (0.25482s)][8.70855 (0.182348s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.12441 (0.227187s)][1.92471 (0.467116s)][2.5683 (0.755608s)][3.45487 (1.30086s)]]
[[cpp_int(fixed)][1.02377 (0.206852s)][1.32377 (0.321272s)][2.09615 (0.616699s)][2.89679 (1.09072s)]]
[[gmp_int][[*1] (0.20205s)][[*1] (0.242695s)][[*1] (0.294206s)][[*1] (0.376529s)]]
[[tommath_int][5.68214 (1.14807s)][5.52349 (1.34052s)][7.00529 (2.061s)][8.79242 (3.3106s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.11845 (0.129609s)][4.15783 (0.303922s)][5.55849 (0.535727s)][6.76415 (1.00179s)]]
[[cpp_int(fixed)][1.81934 (0.111309s)][2.99804 (0.219146s)][4.68327 (0.451373s)][5.87635 (0.870306s)]]
[[gmp_int][[*1] (0.061181s)][[*1] (0.0730963s)][[*1] (0.09638s)][[*1] (0.148103s)]]
[[tommath_int][15.3006 (0.936106s)][16.0325 (1.17192s)][18.2771 (1.76155s)][20.2054 (2.99248s)]]
]
[table Operator <<
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.66271 (0.0182175s)][1.44338 (0.0210768s)][1.50386 (0.0269161s)][1.91115 (0.0394128s)]]
[[cpp_int(fixed)][1.19703 (0.0131154s)][1.16109 (0.0169546s)][1.05186 (0.0188263s)][1.90315 (0.0392477s)]]
[[gmp_int][[*1] (0.0109566s)][[*1] (0.0146023s)][[*1] (0.0178981s)][[*1] (0.0206225s)]]
[[tommath_int][2.88726 (0.0316344s)][2.5987 (0.0379471s)][2.51285 (0.0449753s)][3.25597 (0.0671463s)]]
]
[table Operator >>
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.36287 (0.0215535s)][1.70778 (0.0175781s)][1.77078 (0.0216914s)][2.29189 (0.0294462s)]]
[[cpp_int(fixed)][[*1] (0.00912176s)][1.10889 (0.0114138s)][1.2417 (0.0152103s)][1.6714 (0.0214742s)]]
[[gmp_int][1.17612 (0.0107283s)][[*1] (0.010293s)][[*1] (0.0122496s)][[*1] (0.012848s)]]
[[tommath_int][15.2553 (0.139155s)][13.7608 (0.14164s)][12.2124 (0.149597s)][13.0247 (0.167341s)]]
]
[table Operator ^
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.78798 (0.0243197s)][1.8085 (0.0280192s)][1.78828 (0.033929s)][1.79594 (0.0456494s)]]
[[cpp_int(fixed)][1.0129 (0.0137773s)][[*1] (0.015493s)][[*1] (0.018973s)][1.5504 (0.0394082s)]]
[[gmp_int][[*1] (0.0136018s)][1.03786 (0.0160796s)][1.40572 (0.0266707s)][[*1] (0.0254182s)]]
[[tommath_int][5.39689 (0.0734074s)][4.78827 (0.0741847s)][4.17964 (0.0793004s)][3.73059 (0.0948247s)]]
]
[table Operator ^(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.76928 (0.0404509s)][1.83515 (0.0299941s)][1.77409 (0.0323887s)][1.11493 (0.0372218s)]]
[[cpp_int(fixed)][[*1] (0.014607s)][[*1] (0.0163443s)][[*1] (0.0182565s)][[*1] (0.0333848s)]]
[[gmp_int][3.25823 (0.047593s)][3.05166 (0.0498771s)][2.96144 (0.0540655s)][1.47308 (0.0491785s)]]
[[tommath_int][17.006 (0.248407s)][15.2663 (0.249516s)][14.338 (0.261762s)][7.82864 (0.261357s)]]
]
[table Operator gcd
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.20736 (4.16823s)][3.91955 (8.51244s)][4.00539 (19.489s)][4.64192 (47.7651s)]]
[[cpp_int(fixed)][6.34685 (2.87326s)][3.07855 (6.68597s)][3.32507 (16.1788s)][4.07366 (41.9178s)]]
[[gmp_int][[*1] (0.452707s)][[*1] (2.17179s)][[*1] (4.86569s)][[*1] (10.2899s)]]
[[tommath_int][16.804 (7.6073s)][7.31428 (15.8851s)][6.96518 (33.8904s)][6.52732 (67.1657s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.76995 (0.000703371s)][2.94246 (0.00181769s)][3.45149 (0.00434022s)][4.14052 (0.0122363s)]]
[[cpp_int(fixed)][1.58559 (0.000630107s)][2.42804 (0.00149991s)][3.30542 (0.00415653s)][3.90693 (0.011546s)]]
[[gmp_int][[*1] (0.000397397s)][[*1] (0.000617745s)][[*1] (0.00125749s)][[*1] (0.00295526s)]]
[[tommath_int][21.7585 (0.00864677s)][34.4291 (0.0212684s)][65.8175 (0.0827649s)][67.7946 (0.200351s)]]
]
[table Operator |
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.91883 (0.0242976s)][1.88265 (0.0281237s)][1.78879 (0.0339623s)][1.74117 (0.0457886s)]]
[[cpp_int(fixed)][1.08025 (0.0136789s)][1.03489 (0.0154596s)][[*1] (0.0189862s)][1.49756 (0.0393824s)]]
[[gmp_int][[*1] (0.0126627s)][[*1] (0.0149383s)][1.28585 (0.0244134s)][[*1] (0.0262977s)]]
[[tommath_int][5.86177 (0.0742258s)][4.9555 (0.0740269s)][4.18835 (0.0795209s)][3.55804 (0.0935681s)]]
]
[table Operator |(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.76183 (0.0454215s)][2.05967 (0.0323883s)][1.78143 (0.0324562s)][1.22147 (0.0372077s)]]
[[cpp_int(fixed)][[*1] (0.0164462s)][[*1] (0.015725s)][[*1] (0.0182191s)][[*1] (0.0304613s)]]
[[gmp_int][2.81912 (0.0463637s)][3.18611 (0.0501017s)][2.94469 (0.0536497s)][1.62702 (0.0495613s)]]
[[tommath_int][15.1485 (0.249135s)][15.9884 (0.251418s)][13.915 (0.253519s)][8.65293 (0.26358s)]]
]
[endsect]
[section:rational_performance Rational Type Perfomance]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][16.2879 (15.3196s)][10.7459 (45.9283s)][11.5596 (111.528s)][12.8553 (270.253s)]]
[[mpq_rational][[*1] (0.940549s)][[*1] (4.27402s)][[*1] (9.6481s)][[*1] (21.0227s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.7465 (1.3425s)][10.6643 (2.05921s)][11.055 (2.75206s)][12.6365 (4.26866s)]]
[[mpq_rational][[*1] (0.173305s)][[*1] (0.193095s)][[*1] (0.248942s)][[*1] (0.337805s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][16.0608 (8.33358s)][10.8037 (24.5753s)][11.4235 (58.1983s)][12.435 (139.884s)]]
[[mpq_rational][[*1] (0.518878s)][[*1] (2.2747s)][[*1] (5.09463s)][[*1] (11.2492s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.82472 (1.14042s)][9.40883 (1.54697s)][9.02478 (1.83113s)][9.24894 (2.65768s)]]
[[mpq_rational][[*1] (0.145745s)][[*1] (0.164417s)][[*1] (0.202901s)][[*1] (0.287349s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][16.0583 (8.3543s)][10.6997 (24.3831s)][11.4377 (58.3044s)][12.4116 (139.665s)]]
[[mpq_rational][[*1] (0.520249s)][[*1] (2.27886s)][[*1] (5.09757s)][[*1] (11.2528s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.99602 (1.13947s)][9.62717 (1.55711s)][9.1151 (1.82889s)][9.53508 (2.68279s)]]
[[mpq_rational][[*1] (0.142505s)][[*1] (0.161741s)][[*1] (0.200644s)][[*1] (0.28136s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][12.0736 (31.794s)][10.0089 (80.7871s)][10.9267 (184.73s)][12.204 (436.471s)]]
[[mpq_rational][[*1] (2.63335s)][[*1] (8.07149s)][[*1] (16.9064s)][[*1] (35.7647s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.56092 (1.35276s)][10.5279 (2.12933s)][10.9509 (2.75885s)][12.166 (4.27228s)]]
[[mpq_rational][[*1] (0.178914s)][[*1] (0.202255s)][[*1] (0.251928s)][[*1] (0.351164s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][13.4013 (0.00980984s)][23.4372 (0.0288878s)][27.4314 (0.067039s)][29.4814 (0.165057s)]]
[[mpq_rational][[*1] (0.000732008s)][[*1] (0.00123256s)][[*1] (0.00244388s)][[*1] (0.00559869s)]]
]
[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test-intel-linux.log
================================================
gmp_int        64        +    0.016582
gmp_int        64        -    0.0174517
gmp_int        64        *    0.0112253
gmp_int        64        /    0.170951
gmp_int        64        str  0.000343689
gmp_int        64        +(int)0.00688382
gmp_int        64        -(int)0.00734613
gmp_int        64        *(int)0.00881438
gmp_int        64        /(int)0.0465651
gmp_int        64        %    0.164576
gmp_int        64        |    0.0101555
gmp_int        64        &    0.00955666
gmp_int        64        ^    0.00987346
gmp_int        64        <<   0.0106043
gmp_int        64        >>   0.0093887
gmp_int        64        %(int)0.0297463
gmp_int        64        |(int)0.0403338
gmp_int        64        &(int)0.0417288
gmp_int        64        ^(int)0.0405779
gmp_int        64        gcd  0.173816
gmp_int        128       +    0.0183088
gmp_int        128       -    0.0189266
gmp_int        128       *    0.0161084
gmp_int        128       /    0.191775
gmp_int        128       str  0.000374699
gmp_int        128       +(int)0.00866339
gmp_int        128       -(int)0.0089443
gmp_int        128       *(int)0.0114143
gmp_int        128       /(int)0.0534638
gmp_int        128       %    0.161212
gmp_int        128       |    0.0107201
gmp_int        128       &    0.0113559
gmp_int        128       ^    0.0112116
gmp_int        128       <<   0.0103295
gmp_int        128       >>   0.00813413
gmp_int        128       %(int)0.03692
gmp_int        128       |(int)0.0412168
gmp_int        128       &(int)0.0428359
gmp_int        128       ^(int)0.0418522
gmp_int        128       gcd  0.43131
gmp_int        256       +    0.0224834
gmp_int        256       -    0.025062
gmp_int        256       *    0.0417471
gmp_int        256       /    0.233656
gmp_int        256       str  0.00059903
gmp_int        256       +(int)0.0112071
gmp_int        256       -(int)0.0116302
gmp_int        256       *(int)0.0137181
gmp_int        256       /(int)0.0667669
gmp_int        256       %    0.191884
gmp_int        256       |    0.0129489
gmp_int        256       &    0.012778
gmp_int        256       ^    0.0134548
gmp_int        256       <<   0.0121471
gmp_int        256       >>   0.00832878
gmp_int        256       %(int)0.0474363
gmp_int        256       |(int)0.0425591
gmp_int        256       &(int)0.0436742
gmp_int        256       ^(int)0.0425636
gmp_int        256       gcd  2.06855
gmp_int        512       +    0.0277439
gmp_int        512       -    0.0318874
gmp_int        512       *    0.0991032
gmp_int        512       /    0.274993
gmp_int        512       str  0.00129458
gmp_int        512       +(int)0.014283
gmp_int        512       -(int)0.0149874
gmp_int        512       *(int)0.0180512
gmp_int        512       /(int)0.0906691
gmp_int        512       %    0.222477
gmp_int        512       |    0.0217103
gmp_int        512       &    0.0165285
gmp_int        512       ^    0.0208848
gmp_int        512       <<   0.014839
gmp_int        512       >>   0.00988994
gmp_int        512       %(int)0.0605682
gmp_int        512       |(int)0.0462909
gmp_int        512       &(int)0.046599
gmp_int        512       ^(int)0.0456608
gmp_int        512       gcd  4.68499
gmp_int        1024      +    0.0397479
gmp_int        1024      -    0.042232
gmp_int        1024      *    0.31703
gmp_int        1024      /    0.345984
gmp_int        1024      str  0.00271592
gmp_int        1024      +(int)0.0189969
gmp_int        1024      -(int)0.0195046
gmp_int        1024      *(int)0.0260306
gmp_int        1024      /(int)0.140151
gmp_int        1024      %    0.286399
gmp_int        1024      |    0.0261953
gmp_int        1024      &    0.023083
gmp_int        1024      ^    0.0248084
gmp_int        1024      <<   0.0202635
gmp_int        1024      >>   0.0127909
gmp_int        1024      %(int)0.0761102
gmp_int        1024      |(int)0.049175
gmp_int        1024      &(int)0.0499195
gmp_int        1024      ^(int)0.0487102
gmp_int        1024      gcd  10.1127
cpp_int        64        +    0.0152915
cpp_int        64        -    0.0191821
cpp_int        64        *    0.0326218
cpp_int        64        /    0.0951094
cpp_int        64        str  0.000428547
cpp_int        64        +(int)0.0132027
cpp_int        64        -(int)0.0126144
cpp_int        64        *(int)0.0151037
cpp_int        64        /(int)0.0491116
cpp_int        64        %    0.0951581
cpp_int        64        |    0.0199629
cpp_int        64        &    0.0196969
cpp_int        64        ^    0.0208608
cpp_int        64        <<   0.0179372
cpp_int        64        >>   0.0146206
cpp_int        64        %(int)0.0229261
cpp_int        64        |(int)0.0185797
cpp_int        64        &(int)0.0225055
cpp_int        64        ^(int)0.0191337
cpp_int        64        gcd  1.50205
cpp_int        128       +    0.0170788
cpp_int        128       -    0.0228373
cpp_int        128       *    0.0375831
cpp_int        128       /    0.163958
cpp_int        128       str  0.000744647
cpp_int        128       +(int)0.0144833
cpp_int        128       -(int)0.013922
cpp_int        128       *(int)0.0176402
cpp_int        128       /(int)0.0972057
cpp_int        128       %    0.169015
cpp_int        128       |    0.0229631
cpp_int        128       &    0.023126
cpp_int        128       ^    0.0229278
cpp_int        128       <<   0.0215749
cpp_int        128       >>   0.0149198
cpp_int        128       %(int)0.0476063
cpp_int        128       |(int)0.0194697
cpp_int        128       &(int)0.0270183
cpp_int        128       ^(int)0.0194481
cpp_int        128       gcd  3.36986
cpp_int        256       +    0.0231877
cpp_int        256       -    0.0293424
cpp_int        256       *    0.113247
cpp_int        256       /    0.336287
cpp_int        256       str  0.00190436
cpp_int        256       +(int)0.0161733
cpp_int        256       -(int)0.0173225
cpp_int        256       *(int)0.0199426
cpp_int        256       /(int)0.229286
cpp_int        256       %    0.306542
cpp_int        256       |    0.0257191
cpp_int        256       &    0.0254172
cpp_int        256       ^    0.0259082
cpp_int        256       <<   0.0253994
cpp_int        256       >>   0.0172635
cpp_int        256       %(int)0.116093
cpp_int        256       |(int)0.0233559
cpp_int        256       &(int)0.0367792
cpp_int        256       ^(int)0.0232914
cpp_int        256       gcd  7.88882
cpp_int        512       +    0.0291058
cpp_int        512       -    0.0380025
cpp_int        512       *    0.337161
cpp_int        512       /    0.487075
cpp_int        512       str  0.00494162
cpp_int        512       +(int)0.0201989
cpp_int        512       -(int)0.0200688
cpp_int        512       *(int)0.0311497
cpp_int        512       /(int)0.375279
cpp_int        512       %    0.459737
cpp_int        512       |    0.0297101
cpp_int        512       &    0.0297235
cpp_int        512       ^    0.0296913
cpp_int        512       <<   0.0328422
cpp_int        512       >>   0.0234706
cpp_int        512       %(int)0.194709
cpp_int        512       |(int)0.0258992
cpp_int        512       &(int)0.0529542
cpp_int        512       ^(int)0.0258749
cpp_int        512       gcd  19.7141
cpp_int        1024      +    0.0410101
cpp_int        1024      -    0.0576733
cpp_int        1024      *    1.19319
cpp_int        1024      /    0.850798
cpp_int        1024      str  0.0149378
cpp_int        1024      +(int)0.0222435
cpp_int        1024      -(int)0.0219408
cpp_int        1024      *(int)0.0435058
cpp_int        1024      /(int)0.6795
cpp_int        1024      %    0.800961
cpp_int        1024      |    0.0369613
cpp_int        1024      &    0.0368423
cpp_int        1024      ^    0.0371252
cpp_int        1024      <<   0.0474759
cpp_int        1024      >>   0.0297527
cpp_int        1024      %(int)0.360619
cpp_int        1024      |(int)0.0326194
cpp_int        1024      &(int)0.0801744
cpp_int        1024      ^(int)0.0319848
cpp_int        1024      gcd  53.3224
fixed_int      64        +    0.00207275
fixed_int      64        -    0.00214524
fixed_int      64        *    0.00391097
fixed_int      64        /    0.0608466
fixed_int      64        str  0.000292286
fixed_int      64        +(int)0.00357336
fixed_int      64        -(int)0.00352796
fixed_int      64        *(int)0.00292725
fixed_int      64        /(int)0.0243018
fixed_int      64        %    0.0603067
fixed_int      64        |    0.00258063
fixed_int      64        &    0.00257379
fixed_int      64        ^    0.00258525
fixed_int      64        <<   0.00134947
fixed_int      64        >>   0.00560378
fixed_int      64        %(int)0.0241499
fixed_int      64        |(int)0.00201939
fixed_int      64        &(int)0.00206716
fixed_int      64        ^(int)0.00201848
fixed_int      64        gcd  0.82127
fixed_int      128       +    0.00325349
fixed_int      128       -    0.00366953
fixed_int      128       *    0.010445
fixed_int      128       /    0.113697
fixed_int      128       str  0.000564877
fixed_int      128       +(int)0.00377625
fixed_int      128       -(int)0.00360179
fixed_int      128       *(int)0.00418426
fixed_int      128       /(int)0.091141
fixed_int      128       %    0.113804
fixed_int      128       |    0.00360961
fixed_int      128       &    0.00359913
fixed_int      128       ^    0.00361317
fixed_int      128       <<   0.0065905
fixed_int      128       >>   0.00654308
fixed_int      128       %(int)0.0809135
fixed_int      128       |(int)0.00237125
fixed_int      128       &(int)0.00231056
fixed_int      128       ^(int)0.00190464
fixed_int      128       gcd  2.05126
fixed_int      256       +    0.00785776
fixed_int      256       -    0.00635884
fixed_int      256       *    0.0323875
fixed_int      256       /    0.203194
fixed_int      256       str  0.0013816
fixed_int      256       +(int)0.00413397
fixed_int      256       -(int)0.00379699
fixed_int      256       *(int)0.00852456
fixed_int      256       /(int)0.183053
fixed_int      256       %    0.200368
fixed_int      256       |    0.0105747
fixed_int      256       &    0.0105856
fixed_int      256       ^    0.0105755
fixed_int      256       <<   0.00874545
fixed_int      256       >>   0.00906624
fixed_int      256       %(int)0.152826
fixed_int      256       |(int)0.00261619
fixed_int      256       &(int)0.00424202
fixed_int      256       ^(int)0.00263274
fixed_int      256       gcd  5.42715
fixed_int      512       +    0.0131311
fixed_int      512       -    0.0122513
fixed_int      512       *    0.205979
fixed_int      512       /    0.383601
fixed_int      512       str  0.0043558
fixed_int      512       +(int)0.00639746
fixed_int      512       -(int)0.00641876
fixed_int      512       *(int)0.0152369
fixed_int      512       /(int)0.363289
fixed_int      512       %    0.38201
fixed_int      512       |    0.0131075
fixed_int      512       &    0.0131292
fixed_int      512       ^    0.01314
fixed_int      512       <<   0.0130248
fixed_int      512       >>   0.0131451
fixed_int      512       %(int)0.304714
fixed_int      512       |(int)0.00574368
fixed_int      512       &(int)0.00810836
fixed_int      512       ^(int)0.00576694
fixed_int      512       gcd  16.6269
fixed_int      1024      +    0.0322386
fixed_int      1024      -    0.0312142
fixed_int      1024      *    0.716002
fixed_int      1024      /    0.728338
fixed_int      1024      str  0.0135445
fixed_int      1024      +(int)0.011986
fixed_int      1024      -(int)0.0119838
fixed_int      1024      *(int)0.0349878
fixed_int      1024      /(int)0.708856
fixed_int      1024      %    0.723622
fixed_int      1024      |    0.0181468
fixed_int      1024      &    0.0182648
fixed_int      1024      ^    0.018185
fixed_int      1024      <<   0.0252997
fixed_int      1024      >>   0.0257832
fixed_int      1024      %(int)0.597535
fixed_int      1024      |(int)0.0116417
fixed_int      1024      &(int)0.0172111
fixed_int      1024      ^(int)0.011526
fixed_int      1024      gcd  70.6396
[section:integer_performance Integer Type Perfomance]
[table Operator %
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.5779 (0.0951581s)][1.48514 (0.169015s)][1.59753 (0.306542s)][2.06645 (0.459737s)][2.79666 (0.800961s)]]
[[fixed_int][[*1] (0.0603067s)][[*1] (0.113804s)][1.04421 (0.200368s)][1.71708 (0.38201s)][2.52662 (0.723622s)]]
[[gmp_int][2.72898 (0.164576s)][1.41658 (0.161212s)][[*1] (0.191884s)][[*1] (0.222477s)][[*1] (0.286399s)]]
]
[table Operator %(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][[*1] (0.0229261s)][1.28944 (0.0476063s)][2.44735 (0.116093s)][3.21471 (0.194709s)][4.73812 (0.360619s)]]
[[fixed_int][1.05338 (0.0241499s)][2.19159 (0.0809135s)][3.22171 (0.152826s)][5.03092 (0.304714s)][7.85093 (0.597535s)]]
[[gmp_int][1.29749 (0.0297463s)][[*1] (0.03692s)][[*1] (0.0474363s)][[*1] (0.0605682s)][[*1] (0.0761102s)]]
]
[table Operator &
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][7.65289 (0.0196969s)][6.42545 (0.023126s)][2.4011 (0.0254172s)][2.26393 (0.0297235s)][2.01712 (0.0368423s)]]
[[fixed_int][[*1] (0.00257379s)][[*1] (0.00359913s)][[*1] (0.0105856s)][[*1] (0.0131292s)][[*1] (0.0182648s)]]
[[gmp_int][3.71307 (0.00955666s)][3.15518 (0.0113559s)][1.2071 (0.012778s)][1.25891 (0.0165285s)][1.2638 (0.023083s)]]
]
[table Operator &(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][10.8871 (0.0225055s)][11.6934 (0.0270183s)][8.67021 (0.0367792s)][6.53082 (0.0529542s)][4.65829 (0.0801744s)]]
[[fixed_int][[*1] (0.00206716s)][[*1] (0.00231056s)][[*1] (0.00424202s)][[*1] (0.00810836s)][[*1] (0.0172111s)]]
[[gmp_int][20.1865 (0.0417288s)][18.5392 (0.0428359s)][10.2956 (0.0436742s)][5.74703 (0.046599s)][2.90042 (0.0499195s)]]
]
[table Operator *
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][8.34111 (0.0326218s)][3.59818 (0.0375831s)][3.49662 (0.113247s)][3.40211 (0.337161s)][3.76364 (1.19319s)]]
[[fixed_int][[*1] (0.00391097s)][[*1] (0.010445s)][[*1] (0.0323875s)][2.07843 (0.205979s)][2.25847 (0.716002s)]]
[[gmp_int][2.87022 (0.0112253s)][1.54221 (0.0161084s)][1.28899 (0.0417471s)][[*1] (0.0991032s)][[*1] (0.31703s)]]
]
[table Operator *(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][5.15967 (0.0151037s)][4.21584 (0.0176402s)][2.33943 (0.0199426s)][2.04436 (0.0311497s)][1.67133 (0.0435058s)]]
[[fixed_int][[*1] (0.00292725s)][[*1] (0.00418426s)][[*1] (0.00852456s)][[*1] (0.0152369s)][1.3441 (0.0349878s)]]
[[gmp_int][3.01114 (0.00881438s)][2.72791 (0.0114143s)][1.60924 (0.0137181s)][1.1847 (0.0180512s)][[*1] (0.0260306s)]]
]
[table Operator +
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][7.37741 (0.0152915s)][5.2494 (0.0170788s)][2.95092 (0.0231877s)][2.21655 (0.0291058s)][1.27208 (0.0410101s)]]
[[fixed_int][[*1] (0.00207275s)][[*1] (0.00325349s)][[*1] (0.00785776s)][[*1] (0.0131311s)][[*1] (0.0322386s)]]
[[gmp_int][7.99998 (0.016582s)][5.62745 (0.0183088s)][2.86129 (0.0224834s)][2.11283 (0.0277439s)][1.23293 (0.0397479s)]]
]
[table Operator +(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][3.69474 (0.0132027s)][3.83536 (0.0144833s)][3.91229 (0.0161733s)][3.15733 (0.0201989s)][1.85579 (0.0222435s)]]
[[fixed_int][[*1] (0.00357336s)][[*1] (0.00377625s)][[*1] (0.00413397s)][[*1] (0.00639746s)][[*1] (0.011986s)]]
[[gmp_int][1.92643 (0.00688382s)][2.29418 (0.00866339s)][2.71097 (0.0112071s)][2.23261 (0.014283s)][1.58492 (0.0189969s)]]
]
[table Operator -
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][8.94166 (0.0191821s)][6.22351 (0.0228373s)][4.61443 (0.0293424s)][3.10192 (0.0380025s)][1.84766 (0.0576733s)]]
[[fixed_int][[*1] (0.00214524s)][[*1] (0.00366953s)][[*1] (0.00635884s)][[*1] (0.0122513s)][[*1] (0.0312142s)]]
[[gmp_int][8.13505 (0.0174517s)][5.15777 (0.0189266s)][3.94128 (0.025062s)][2.60278 (0.0318874s)][1.35297 (0.042232s)]]
]
[table Operator -(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][3.57555 (0.0126144s)][3.86529 (0.013922s)][4.56215 (0.0173225s)][3.12658 (0.0200688s)][1.83087 (0.0219408s)]]
[[fixed_int][[*1] (0.00352796s)][[*1] (0.00360179s)][[*1] (0.00379699s)][[*1] (0.00641876s)][[*1] (0.0119838s)]]
[[gmp_int][2.08226 (0.00734613s)][2.4833 (0.0089443s)][3.063 (0.0116302s)][2.33493 (0.0149874s)][1.62759 (0.0195046s)]]
]
[table Operator /
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.5631 (0.0951094s)][1.44205 (0.163958s)][1.655 (0.336287s)][1.77123 (0.487075s)][2.45907 (0.850798s)]]
[[fixed_int][[*1] (0.0608466s)][[*1] (0.113697s)][[*1] (0.203194s)][1.39495 (0.383601s)][2.10512 (0.728338s)]]
[[gmp_int][2.80954 (0.170951s)][1.68671 (0.191775s)][1.14992 (0.233656s)][[*1] (0.274993s)][[*1] (0.345984s)]]
]
[table Operator /(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.0209 (0.0491116s)][1.81816 (0.0972057s)][3.43412 (0.229286s)][4.13899 (0.375279s)][4.84836 (0.6795s)]]
[[fixed_int][[*1] (0.0243018s)][1.70472 (0.091141s)][2.74167 (0.183053s)][4.00675 (0.363289s)][5.05782 (0.708856s)]]
[[gmp_int][1.91611 (0.0465651s)][[*1] (0.0534638s)][[*1] (0.0667669s)][[*1] (0.0906691s)][[*1] (0.140151s)]]
]
[table Operator <<
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][13.292 (0.0179372s)][3.27363 (0.0215749s)][2.9043 (0.0253994s)][2.52151 (0.0328422s)][2.34293 (0.0474759s)]]
[[fixed_int][[*1] (0.00134947s)][[*1] (0.0065905s)][[*1] (0.00874545s)][[*1] (0.0130248s)][1.24854 (0.0252997s)]]
[[gmp_int][7.85814 (0.0106043s)][1.56732 (0.0103295s)][1.38897 (0.0121471s)][1.13928 (0.014839s)][[*1] (0.0202635s)]]
]
[table Operator >>
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.60907 (0.0146206s)][2.28025 (0.0149198s)][2.07275 (0.0172635s)][2.37318 (0.0234706s)][2.32609 (0.0297527s)]]
[[fixed_int][[*1] (0.00560378s)][[*1] (0.00654308s)][1.08854 (0.00906624s)][1.32914 (0.0131451s)][2.01575 (0.0257832s)]]
[[gmp_int][1.67542 (0.0093887s)][1.24317 (0.00813413s)][[*1] (0.00832878s)][[*1] (0.00988994s)][[*1] (0.0127909s)]]
]
[table Operator ^
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][8.06918 (0.0208608s)][6.34562 (0.0229278s)][2.44983 (0.0259082s)][2.25961 (0.0296913s)][2.04153 (0.0371252s)]]
[[fixed_int][[*1] (0.00258525s)][[*1] (0.00361317s)][[*1] (0.0105755s)][[*1] (0.01314s)][[*1] (0.018185s)]]
[[gmp_int][3.81916 (0.00987346s)][3.10299 (0.0112116s)][1.27226 (0.0134548s)][1.5894 (0.0208848s)][1.36422 (0.0248084s)]]
]
[table Operator ^(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.47925 (0.0191337s)][10.2109 (0.0194481s)][8.84686 (0.0232914s)][4.48677 (0.0258749s)][2.775 (0.0319848s)]]
[[fixed_int][[*1] (0.00201848s)][[*1] (0.00190464s)][[*1] (0.00263274s)][[*1] (0.00576694s)][[*1] (0.011526s)]]
[[gmp_int][20.1032 (0.0405779s)][21.9738 (0.0418522s)][16.1671 (0.0425636s)][7.91768 (0.0456608s)][4.2261 (0.0487102s)]]
]
[table Operator gcd
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][8.64165 (1.50205s)][7.81307 (3.36986s)][3.81369 (7.88882s)][4.20792 (19.7141s)][5.27284 (53.3224s)]]
[[fixed_int][4.72495 (0.82127s)][4.75589 (2.05126s)][2.62364 (5.42715s)][3.54898 (16.6269s)][6.98527 (70.6396s)]]
[[gmp_int][[*1] (0.173816s)][[*1] (0.43131s)][[*1] (2.06855s)][[*1] (4.68499s)][[*1] (10.1127s)]]
]
[table Operator str
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.46619 (0.000428547s)][1.98732 (0.000744647s)][3.17907 (0.00190436s)][3.81717 (0.00494162s)][5.50009 (0.0149378s)]]
[[fixed_int][[*1] (0.000292286s)][1.50755 (0.000564877s)][2.30639 (0.0013816s)][3.36465 (0.0043558s)][4.98706 (0.0135445s)]]
[[gmp_int][1.17587 (0.000343689s)][[*1] (0.000374699s)][[*1] (0.00059903s)][[*1] (0.00129458s)][[*1] (0.00271592s)]]
]
[table Operator |
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][7.73565 (0.0199629s)][6.36166 (0.0229631s)][2.43214 (0.0257191s)][2.26665 (0.0297101s)][2.0368 (0.0369613s)]]
[[fixed_int][[*1] (0.00258063s)][[*1] (0.00360961s)][[*1] (0.0105747s)][[*1] (0.0131075s)][[*1] (0.0181468s)]]
[[gmp_int][3.9353 (0.0101555s)][2.96987 (0.0107201s)][1.22452 (0.0129489s)][1.65632 (0.0217103s)][1.44352 (0.0261953s)]]
]
[table Operator |(int)
[[Backend][64 Bits][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.20066 (0.0185797s)][8.21071 (0.0194697s)][8.92746 (0.0233559s)][4.50916 (0.0258992s)][2.80194 (0.0326194s)]]
[[fixed_int][[*1] (0.00201939s)][[*1] (0.00237125s)][[*1] (0.00261619s)][[*1] (0.00574368s)][[*1] (0.0116417s)]]
[[gmp_int][19.9733 (0.0403338s)][17.3819 (0.0412168s)][16.2676 (0.0425591s)][8.05945 (0.0462909s)][4.22404 (0.049175s)]]
]
[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test-msvc-10.log
================================================
gmp_float      50        +    0.110988
gmp_float      50        -    0.119898
gmp_float      50        *    0.275044
gmp_float      50        /    1.27708
gmp_float      50        str  0.013276
gmp_float      50        +(int)0.0330888
gmp_float      50        -(int)0.134451
gmp_float      50        *(int)0.0422135
gmp_float      50        /(int)0.180393
gmp_float      50        construct0.19737
gmp_float      50        construct(unsigned)0.208078
gmp_float      50        construct(unsigned long long)0.520025
gmp_float      50        +    0.498089
gmp_float      50        -    0.502235
gmp_float      50        *    0.564768
gmp_float      50        /    0.90324
gmp_float      50        +    0.477999
gmp_float      50        -    0.499682
gmp_float      50        *    0.551747
gmp_float      50        /    0.893752
gmp_float      100       +    0.111217
gmp_float      100       -    0.120498
gmp_float      100       *    0.416175
gmp_float      100       /    1.69515
gmp_float      100       str  0.0202949
gmp_float      100       +(int)0.0386882
gmp_float      100       -(int)0.1351
gmp_float      100       *(int)0.0493716
gmp_float      100       /(int)0.23378
gmp_float      100       construct0.196599
gmp_float      100       construct(unsigned)0.207062
gmp_float      100       construct(unsigned long long)0.51936
gmp_float      100       +    0.517172
gmp_float      100       -    0.509588
gmp_float      100       *    0.575954
gmp_float      100       /    1.04262
gmp_float      100       +    0.476701
gmp_float      100       -    0.503546
gmp_float      100       *    0.564962
gmp_float      100       /    1.03328
gmp_float      500       +    0.15445
gmp_float      500       -    0.164099
gmp_float      500       *    3.32799
gmp_float      500       /    8.12655
gmp_float      500       str  0.141162
gmp_float      500       +(int)0.0646201
gmp_float      500       -(int)0.176876
gmp_float      500       *(int)0.0857876
gmp_float      500       /(int)0.710204
gmp_float      500       construct0.206063
gmp_float      500       construct(unsigned)0.217019
gmp_float      500       construct(unsigned long long)0.538021
gmp_float      500       +    0.552532
gmp_float      500       -    0.555754
gmp_float      500       *    0.717186
gmp_float      500       /    2.24686
gmp_float      500       +    0.490614
gmp_float      500       -    0.547751
gmp_float      500       *    0.700957
gmp_float      500       /    2.24146
gmp_int        128       +    0.0421662
gmp_int        128       -    0.0411848
gmp_int        128       *    0.0708996
gmp_int        128       /    0.868916
gmp_int        128       str  0.00185638
gmp_int        128       +(int)0.0311237
gmp_int        128       -(int)0.030585
gmp_int        128       *(int)0.022756
gmp_int        128       /(int)0.0560401
gmp_int        128       construct0.196182
gmp_int        128       construct(unsigned)0.206113
gmp_int        128       construct(unsigned long long)0.719741
gmp_int        128       %    0.64148
gmp_int        128       |    0.0474678
gmp_int        128       &    0.0538128
gmp_int        128       ^    0.0497194
gmp_int        128       <<   0.0273994
gmp_int        128       >>   0.0288237
gmp_int        128       %(int)0.0572117
gmp_int        128       |(int)0.141119
gmp_int        128       &(int)0.141306
gmp_int        128       ^(int)0.143934
gmp_int        128       gcd  2.45095
gmp_int        128       +    0.71217
gmp_int        128       -    0.687129
gmp_int        128       *    0.716479
gmp_int        128       /    1.04926
gmp_int        128       +    0.68136
gmp_int        128       -    0.681187
gmp_int        128       *    3.1627
gmp_int        128       /    0.685487
gmp_int        256       +    0.0449584
gmp_int        256       -    0.0461316
gmp_int        256       *    0.134302
gmp_int        256       /    0.951505
gmp_int        256       str  0.00344576
gmp_int        256       +(int)0.0428011
gmp_int        256       -(int)0.0400434
gmp_int        256       *(int)0.0282672
gmp_int        256       /(int)0.0982823
gmp_int        256       construct0.201199
gmp_int        256       construct(unsigned)0.211295
gmp_int        256       construct(unsigned long long)0.729487
gmp_int        256       %    0.703592
gmp_int        256       |    0.0618281
gmp_int        256       &    0.0652169
gmp_int        256       ^    0.0630174
gmp_int        256       <<   0.031973
gmp_int        256       >>   0.0310184
gmp_int        256       %(int)0.10258
gmp_int        256       |(int)0.142987
gmp_int        256       &(int)0.139398
gmp_int        256       ^(int)0.144825
gmp_int        256       gcd  5.89505
gmp_int        256       +    0.728978
gmp_int        256       -    0.707806
gmp_int        256       *    0.731454
gmp_int        256       /    1.17203
gmp_int        256       +    0.68929
gmp_int        256       -    0.683532
gmp_int        256       *    3.15114
gmp_int        256       /    0.689516
gmp_int        512       +    0.0522202
gmp_int        512       -    0.0567637
gmp_int        512       *    0.532277
gmp_int        512       /    1.06442
gmp_int        512       str  0.00618403
gmp_int        512       +(int)0.0665539
gmp_int        512       -(int)0.0578194
gmp_int        512       *(int)0.0361075
gmp_int        512       /(int)0.183564
gmp_int        512       construct0.19783
gmp_int        512       construct(unsigned)0.206944
gmp_int        512       construct(unsigned long long)0.724649
gmp_int        512       %    0.819828
gmp_int        512       |    0.0856626
gmp_int        512       &    0.092104
gmp_int        512       ^    0.0869819
gmp_int        512       <<   0.0471709
gmp_int        512       >>   0.0337511
gmp_int        512       %(int)0.188529
gmp_int        512       |(int)0.155656
gmp_int        512       &(int)0.142498
gmp_int        512       ^(int)0.152773
gmp_int        512       gcd  13.6993
gmp_int        512       +    0.759532
gmp_int        512       -    0.732529
gmp_int        512       *    0.779921
gmp_int        512       /    1.39149
gmp_int        512       +    0.694235
gmp_int        512       -    0.69246
gmp_int        512       *    3.17094
gmp_int        512       /    0.688995
gmp_int        1024      +    0.0699873
gmp_int        1024      -    0.0731244
gmp_int        1024      *    1.57852
gmp_int        1024      /    1.30215
gmp_int        1024      str  0.0144523
gmp_int        1024      +(int)0.108272
gmp_int        1024      -(int)0.100541
gmp_int        1024      *(int)0.0518882
gmp_int        1024      /(int)0.352238
gmp_int        1024      construct0.19744
gmp_int        1024      construct(unsigned)0.216229
gmp_int        1024      construct(unsigned long long)0.722262
gmp_int        1024      %    1.01959
gmp_int        1024      |    0.136082
gmp_int        1024      &    0.144412
gmp_int        1024      ^    0.139109
gmp_int        1024      <<   0.0721984
gmp_int        1024      >>   0.0388038
gmp_int        1024      %(int)0.355222
gmp_int        1024      |(int)0.163236
gmp_int        1024      &(int)0.141249
gmp_int        1024      ^(int)0.161662
gmp_int        1024      gcd  33.2232
gmp_int        1024      +    0.83035
gmp_int        1024      -    0.78115
gmp_int        1024      *    0.815503
gmp_int        1024      /    1.84054
gmp_int        1024      +    0.690013
gmp_int        1024      -    0.690838
gmp_int        1024      *    3.20893
gmp_int        1024      /    0.707578
cpp_int(unsigned, fixed)64        +    0.00232166
cpp_int(unsigned, fixed)64        -    0.00234506
cpp_int(unsigned, fixed)64        *    0.00470304
cpp_int(unsigned, fixed)64        /    0.0714786
cpp_int(unsigned, fixed)64        str  0.00256457
cpp_int(unsigned, fixed)64        +(int)0.00162053
cpp_int(unsigned, fixed)64        -(int)0.00163617
cpp_int(unsigned, fixed)64        *(int)0.00236511
cpp_int(unsigned, fixed)64        /(int)0.0299559
cpp_int(unsigned, fixed)64        construct0.00111299
cpp_int(unsigned, fixed)64        construct(unsigned)0.00110489
cpp_int(unsigned, fixed)64        construct(unsigned long long)0.00240876
cpp_int(unsigned, fixed)64        %    0.0702826
cpp_int(unsigned, fixed)64        |    0.00265921
cpp_int(unsigned, fixed)64        &    0.00261653
cpp_int(unsigned, fixed)64        ^    0.0040003
cpp_int(unsigned, fixed)64        <<   0.00161592
cpp_int(unsigned, fixed)64        >>   0.00161599
cpp_int(unsigned, fixed)64        %(int)0.0298064
cpp_int(unsigned, fixed)64        |(int)0.00165538
cpp_int(unsigned, fixed)64        &(int)0.00161431
cpp_int(unsigned, fixed)64        ^(int)0.00184507
cpp_int(unsigned, fixed)64        gcd  0.602722
cpp_int(unsigned, fixed)64        +    0.00253726
cpp_int(unsigned, fixed)64        -    0.00301519
cpp_int(unsigned, fixed)64        *    0.00474872
cpp_int(unsigned, fixed)64        /    0.0450108
cpp_int(unsigned, fixed)64        +    0.0020173
cpp_int(unsigned, fixed)64        -    0.00191079
cpp_int(unsigned, fixed)64        *    0.00445077
cpp_int(unsigned, fixed)64        /    0.0294528
cpp_int(fixed) 64        +    0.00573474
cpp_int(fixed) 64        -    0.0096272
cpp_int(fixed) 64        *    0.00897607
cpp_int(fixed) 64        /    0.0783882
cpp_int(fixed) 64        str  0.00251659
cpp_int(fixed) 64        +(int)0.00636247
cpp_int(fixed) 64        -(int)0.00668367
cpp_int(fixed) 64        *(int)0.00548722
cpp_int(fixed) 64        /(int)0.0362985
cpp_int(fixed) 64        construct0.00161745
cpp_int(fixed) 64        construct(unsigned)0.00209147
cpp_int(fixed) 64        construct(unsigned long long)0.00204998
cpp_int(fixed) 64        %    0.0777437
cpp_int(fixed) 64        |    0.0108982
cpp_int(fixed) 64        &    0.0124165
cpp_int(fixed) 64        ^    0.0110313
cpp_int(fixed) 64        <<   0.00516511
cpp_int(fixed) 64        >>   0.00399499
cpp_int(fixed) 64        %(int)0.0341425
cpp_int(fixed) 64        |(int)0.0111002
cpp_int(fixed) 64        &(int)0.0104782
cpp_int(fixed) 64        ^(int)0.0107199
cpp_int(fixed) 64        gcd  0.604291
cpp_int(fixed) 64        +    0.00605482
cpp_int(fixed) 64        -    0.00714372
cpp_int(fixed) 64        *    0.00873093
cpp_int(fixed) 64        /    0.0510195
cpp_int(fixed) 64        +    0.00430062
cpp_int(fixed) 64        -    0.00387577
cpp_int(fixed) 64        *    0.00567824
cpp_int(fixed) 64        /    0.0320162
cpp_int(fixed) 128       +    0.0358493
cpp_int(fixed) 128       -    0.0397574
cpp_int(fixed) 128       *    0.0672363
cpp_int(fixed) 128       /    0.222933
cpp_int(fixed) 128       str  0.0015613
cpp_int(fixed) 128       +(int)0.0268311
cpp_int(fixed) 128       -(int)0.0241848
cpp_int(fixed) 128       *(int)0.0328109
cpp_int(fixed) 128       /(int)0.137619
cpp_int(fixed) 128       construct0.00164665
cpp_int(fixed) 128       construct(unsigned)0.0015986
cpp_int(fixed) 128       construct(unsigned long long)0.00312994
cpp_int(fixed) 128       %    0.1971
cpp_int(fixed) 128       |    0.0380136
cpp_int(fixed) 128       &    0.0341411
cpp_int(fixed) 128       ^    0.0351059
cpp_int(fixed) 128       <<   0.0320915
cpp_int(fixed) 128       >>   0.0293055
cpp_int(fixed) 128       %(int)0.103684
cpp_int(fixed) 128       |(int)0.0317854
cpp_int(fixed) 128       &(int)0.0417383
cpp_int(fixed) 128       ^(int)0.0312355
cpp_int(fixed) 128       gcd  4.18006
cpp_int(fixed) 128       +    0.0341301
cpp_int(fixed) 128       -    0.0346952
cpp_int(fixed) 128       *    0.0675308
cpp_int(fixed) 128       /    0.466907
cpp_int(fixed) 128       +    0.0168342
cpp_int(fixed) 128       -    0.0169449
cpp_int(fixed) 128       *    0.0673436
cpp_int(fixed) 128       /    0.0327432
cpp_int(fixed) 256       +    0.0552275
cpp_int(fixed) 256       -    0.0560103
cpp_int(fixed) 256       *    0.166666
cpp_int(fixed) 256       /    0.349956
cpp_int(fixed) 256       str  0.00297279
cpp_int(fixed) 256       +(int)0.0410749
cpp_int(fixed) 256       -(int)0.0368306
cpp_int(fixed) 256       *(int)0.049867
cpp_int(fixed) 256       /(int)0.253796
cpp_int(fixed) 256       construct0.00363363
cpp_int(fixed) 256       construct(unsigned)0.00370466
cpp_int(fixed) 256       construct(unsigned long long)0.00388115
cpp_int(fixed) 256       %    0.334027
cpp_int(fixed) 256       |    0.0529581
cpp_int(fixed) 256       &    0.0501131
cpp_int(fixed) 256       ^    0.0530521
cpp_int(fixed) 256       <<   0.0507053
cpp_int(fixed) 256       >>   0.039006
cpp_int(fixed) 256       %(int)0.200647
cpp_int(fixed) 256       |(int)0.0466958
cpp_int(fixed) 256       &(int)0.0539427
cpp_int(fixed) 256       ^(int)0.0476923
cpp_int(fixed) 256       gcd  10.2671
cpp_int(fixed) 256       +    0.0452762
cpp_int(fixed) 256       -    0.0444216
cpp_int(fixed) 256       *    0.112885
cpp_int(fixed) 256       /    1.36886
cpp_int(fixed) 256       +    0.0170491
cpp_int(fixed) 256       -    0.0176783
cpp_int(fixed) 256       *    0.107306
cpp_int(fixed) 256       /    0.0340708
cpp_int(fixed) 512       +    0.0760722
cpp_int(fixed) 512       -    0.0756027
cpp_int(fixed) 512       *    0.500399
cpp_int(fixed) 512       /    0.560837
cpp_int(fixed) 512       str  0.00708386
cpp_int(fixed) 512       +(int)0.0524416
cpp_int(fixed) 512       -(int)0.0503396
cpp_int(fixed) 512       *(int)0.0658566
cpp_int(fixed) 512       /(int)0.446782
cpp_int(fixed) 512       construct0.00576526
cpp_int(fixed) 512       construct(unsigned)0.0058189
cpp_int(fixed) 512       construct(unsigned long long)0.00556537
cpp_int(fixed) 512       %    0.539708
cpp_int(fixed) 512       |    0.0676884
cpp_int(fixed) 512       &    0.0588367
cpp_int(fixed) 512       ^    0.0695132
cpp_int(fixed) 512       <<   0.0597514
cpp_int(fixed) 512       >>   0.0515714
cpp_int(fixed) 512       %(int)0.377704
cpp_int(fixed) 512       |(int)0.0536974
cpp_int(fixed) 512       &(int)0.070425
cpp_int(fixed) 512       ^(int)0.0540962
cpp_int(fixed) 512       gcd  26.2762
cpp_int(fixed) 512       +    0.0571069
cpp_int(fixed) 512       -    0.0563175
cpp_int(fixed) 512       *    0.177444
cpp_int(fixed) 512       /    3.1662
cpp_int(fixed) 512       +    0.0172628
cpp_int(fixed) 512       -    0.0180756
cpp_int(fixed) 512       *    0.171821
cpp_int(fixed) 512       /    0.0444905
cpp_int(fixed) 1024      +    0.121124
cpp_int(fixed) 1024      -    0.114246
cpp_int(fixed) 1024      *    1.54633
cpp_int(fixed) 1024      /    0.975643
cpp_int(fixed) 1024      str  0.0172514
cpp_int(fixed) 1024      +(int)0.0728817
cpp_int(fixed) 1024      -(int)0.0621059
cpp_int(fixed) 1024      *(int)0.0948565
cpp_int(fixed) 1024      /(int)0.84764
cpp_int(fixed) 1024      construct0.00535599
cpp_int(fixed) 1024      construct(unsigned)0.00836042
cpp_int(fixed) 1024      construct(unsigned long long)0.00577713
cpp_int(fixed) 1024      %    0.94847
cpp_int(fixed) 1024      |    0.100936
cpp_int(fixed) 1024      &    0.0774574
cpp_int(fixed) 1024      ^    0.09783
cpp_int(fixed) 1024      <<   0.0677088
cpp_int(fixed) 1024      >>   0.0626121
cpp_int(fixed) 1024      %(int)0.743202
cpp_int(fixed) 1024      |(int)0.0819107
cpp_int(fixed) 1024      &(int)0.112823
cpp_int(fixed) 1024      ^(int)0.0806317
cpp_int(fixed) 1024      gcd  76.2849
cpp_int(fixed) 1024      +    0.0636724
cpp_int(fixed) 1024      -    0.06467
cpp_int(fixed) 1024      *    0.303514
cpp_int(fixed) 1024      /    8.04418
cpp_int(fixed) 1024      +    0.0181245
cpp_int(fixed) 1024      -    0.0190581
cpp_int(fixed) 1024      *    0.299236
cpp_int(fixed) 1024      /    0.106788
cpp_int        128       +    0.0273725
cpp_int        128       -    0.0303219
cpp_int        128       *    0.0774619
cpp_int        128       /    0.589941
cpp_int        128       str  0.00189808
cpp_int        128       +(int)0.0159069
cpp_int        128       -(int)0.0151244
cpp_int        128       *(int)0.0235876
cpp_int        128       /(int)0.235955
cpp_int        128       construct0.00293927
cpp_int        128       construct(unsigned)0.00270684
cpp_int        128       construct(unsigned long long)0.00719854
cpp_int        128       %    0.37333
cpp_int        128       |    0.030991
cpp_int        128       &    0.031605
cpp_int        128       ^    0.0318172
cpp_int        128       <<   0.0256107
cpp_int        128       >>   0.0237523
cpp_int        128       %(int)0.104856
cpp_int        128       |(int)0.0280516
cpp_int        128       &(int)0.0377678
cpp_int        128       ^(int)0.0283305
cpp_int        128       gcd  4.98644
cpp_int        128       +    0.0283071
cpp_int        128       -    0.027289
cpp_int        128       *    0.0584001
cpp_int        128       /    0.733741
cpp_int        128       +    0.0196594
cpp_int        128       -    0.0210968
cpp_int        128       *    7.6372
cpp_int        128       /    0.0578293
cpp_int        256       +    0.0384835
cpp_int        256       -    0.0402028
cpp_int        256       *    0.211395
cpp_int        256       /    0.708882
cpp_int        256       str  0.00391656
cpp_int        256       +(int)0.0218386
cpp_int        256       -(int)0.017199
cpp_int        256       *(int)0.0318939
cpp_int        256       /(int)0.35212
cpp_int        256       construct0.00277479
cpp_int        256       construct(unsigned)0.0030529
cpp_int        256       construct(unsigned long long)0.00725455
cpp_int        256       %    0.673748
cpp_int        256       |    0.0429658
cpp_int        256       &    0.0455929
cpp_int        256       ^    0.0425243
cpp_int        256       <<   0.0401135
cpp_int        256       >>   0.0302534
cpp_int        256       %(int)0.203012
cpp_int        256       |(int)0.0363929
cpp_int        256       &(int)0.0471524
cpp_int        256       ^(int)0.0353555
cpp_int        256       gcd  11.1816
cpp_int        256       +    0.030223
cpp_int        256       -    0.0319489
cpp_int        256       *    0.0885733
cpp_int        256       /    1.62706
cpp_int        256       +    0.0215291
cpp_int        256       -    0.0213343
cpp_int        256       *    7.7121
cpp_int        256       /    0.0615507
cpp_int        512       +    0.0561351
cpp_int        512       -    0.0543342
cpp_int        512       *    0.703234
cpp_int        512       /    0.924042
cpp_int        512       str  0.00832019
cpp_int        512       +(int)0.0316584
cpp_int        512       -(int)0.0248084
cpp_int        512       *(int)0.0427792
cpp_int        512       /(int)0.568032
cpp_int        512       construct0.0028102
cpp_int        512       construct(unsigned)0.00288857
cpp_int        512       construct(unsigned long long)0.00723891
cpp_int        512       %    0.701584
cpp_int        512       |    0.0537846
cpp_int        512       &    0.0546439
cpp_int        512       ^    0.0542436
cpp_int        512       <<   0.0436188
cpp_int        512       >>   0.0355247
cpp_int        512       %(int)0.391566
cpp_int        512       |(int)0.0418143
cpp_int        512       &(int)0.0647085
cpp_int        512       ^(int)0.041758
cpp_int        512       gcd  27.2257
cpp_int        512       +    0.0382495
cpp_int        512       -    0.0386744
cpp_int        512       *    0.14417
cpp_int        512       /    3.61202
cpp_int        512       +    0.0228565
cpp_int        512       -    0.0222868
cpp_int        512       *    7.72815
cpp_int        512       /    0.0732298
cpp_int        1024      +    0.0928746
cpp_int        1024      -    0.0853837
cpp_int        1024      *    2.6591
cpp_int        1024      /    1.38142
cpp_int        1024      str  0.0221599
cpp_int        1024      +(int)0.0430289
cpp_int        1024      -(int)0.0331224
cpp_int        1024      *(int)0.0668616
cpp_int        1024      /(int)0.989885
cpp_int        1024      construct0.00277298
cpp_int        1024      construct(unsigned)0.00265201
cpp_int        1024      construct(unsigned long long)0.00732796
cpp_int        1024      %    1.14369
cpp_int        1024      |    0.0827684
cpp_int        1024      &    0.0843863
cpp_int        1024      ^    0.08333
cpp_int        1024      <<   0.0628544
cpp_int        1024      >>   0.044717
cpp_int        1024      %(int)0.768511
cpp_int        1024      |(int)0.0527075
cpp_int        1024      &(int)0.10089
cpp_int        1024      ^(int)0.0538323
cpp_int        1024      gcd  73.3735
cpp_int        1024      +    0.0463315
cpp_int        1024      -    0.0468398
cpp_int        1024      *    0.255279
cpp_int        1024      /    8.42528
cpp_int        1024      +    0.0227402
cpp_int        1024      -    0.0234526
cpp_int        1024      *    7.86395
cpp_int        1024      /    0.123568
cpp_rational   128       +    18.0021
cpp_rational   128       -    18.0006
cpp_rational   128       *    31.5924
cpp_rational   128       /    65.714
cpp_rational   128       str  0.020339
cpp_rational   128       +(int)2.47739
cpp_rational   128       -(int)2.47959
cpp_rational   128       *(int)2.4377
cpp_rational   128       /(int)2.50843
cpp_rational   128       construct0.0102665
cpp_rational   128       construct(unsigned)0.0624887
cpp_rational   128       construct(unsigned long long)0.0658436
cpp_rational   128       +    2.58812
cpp_rational   128       -    2.60864
cpp_rational   128       *    5.53837
cpp_rational   128       /    5.63033
cpp_rational   128       +    2.68363
cpp_rational   128       -    2.72926
cpp_rational   128       *    57.9393
cpp_rational   128       /    58.0332
cpp_rational   256       +    46.3981
cpp_rational   256       -    46.4818
cpp_rational   256       *    86.0189
cpp_rational   256       /    172.8
cpp_rational   256       str  0.0517328
cpp_rational   256       +(int)2.92179
cpp_rational   256       -(int)2.90579
cpp_rational   256       *(int)2.91325
cpp_rational   256       /(int)3.00689
cpp_rational   256       construct0.0101737
cpp_rational   256       construct(unsigned)0.0609531
cpp_rational   256       construct(unsigned long long)0.0665504
cpp_rational   256       +    3.0953
cpp_rational   256       -    3.08277
cpp_rational   256       *    6.78796
cpp_rational   256       /    6.90941
cpp_rational   256       +    3.15142
cpp_rational   256       -    3.19882
cpp_rational   256       *    59.3172
cpp_rational   256       /    59.5431
cpp_rational   512       +    108.57
cpp_rational   512       -    108.81
cpp_rational   512       *    202.007
cpp_rational   512       /    348.46
cpp_rational   512       str  0.119248
cpp_rational   512       +(int)3.80252
cpp_rational   512       -(int)3.80714
cpp_rational   512       *(int)3.94768
cpp_rational   512       /(int)4.00588
cpp_rational   512       construct0.0101965
cpp_rational   512       construct(unsigned)0.0613968
cpp_rational   512       construct(unsigned long long)0.0659082
cpp_rational   512       +    4.00751
cpp_rational   512       -    4.0117
cpp_rational   512       *    9.43852
cpp_rational   512       /    9.39508
cpp_rational   512       +    4.05684
cpp_rational   512       -    4.08474
cpp_rational   512       *    61.8998
cpp_rational   512       /    61.9712
cpp_rational   1024      +    252.723
cpp_rational   1024      -    253.81
cpp_rational   1024      *    484.128
cpp_rational   1024      /    834.057
cpp_rational   1024      str  0.286067
cpp_rational   1024      +(int)5.51612
cpp_rational   1024      -(int)5.51949
cpp_rational   1024      *(int)5.87507
cpp_rational   1024      /(int)5.92837
cpp_rational   1024      construct0.0102909
cpp_rational   1024      construct(unsigned)0.062674
cpp_rational   1024      construct(unsigned long long)0.0659089
cpp_rational   1024      +    5.7444
cpp_rational   1024      -    5.73296
cpp_rational   1024      *    15.1475
cpp_rational   1024      /    14.9497
cpp_rational   1024      +    5.80438
cpp_rational   1024      -    5.86
cpp_rational   1024      *    67.4139
cpp_rational   1024      /    67.4254
mpq_rational   128       +    3.16879
mpq_rational   128       -    3.18835
mpq_rational   128       *    5.96709
mpq_rational   128       /    15.0571
mpq_rational   128       str  0.0037011
mpq_rational   128       +(int)0.669634
mpq_rational   128       -(int)0.666993
mpq_rational   128       *(int)1.18047
mpq_rational   128       /(int)1.43177
mpq_rational   128       construct0.383107
mpq_rational   128       construct(unsigned)0.394551
mpq_rational   128       construct(unsigned long long)2.13183
mpq_rational   128       +    2.33701
mpq_rational   128       -    2.33227
mpq_rational   128       *    4.15268
mpq_rational   128       /    4.26818
mpq_rational   128       +    2.33097
mpq_rational   128       -    2.31793
mpq_rational   128       *    9.34086
mpq_rational   128       /    9.74135
mpq_rational   256       +    6.93507
mpq_rational   256       -    6.90939
mpq_rational   256       *    12.9674
mpq_rational   256       /    27.1144
mpq_rational   256       str  0.00573278
mpq_rational   256       +(int)0.707818
mpq_rational   256       -(int)0.719174
mpq_rational   256       *(int)1.22229
mpq_rational   256       /(int)1.46082
mpq_rational   256       construct0.381537
mpq_rational   256       construct(unsigned)0.390987
mpq_rational   256       construct(unsigned long long)2.12727
mpq_rational   256       +    2.4159
mpq_rational   256       -    2.41594
mpq_rational   256       *    4.3447
mpq_rational   256       /    4.43342
mpq_rational   256       +    2.40187
mpq_rational   256       -    2.39792
mpq_rational   256       *    9.51195
mpq_rational   256       /    9.65697
mpq_rational   512       +    16.0886
mpq_rational   512       -    16.1169
mpq_rational   512       *    29.597
mpq_rational   512       /    54.8579
mpq_rational   512       str  0.012222
mpq_rational   512       +(int)0.812783
mpq_rational   512       -(int)0.810939
mpq_rational   512       *(int)1.37678
mpq_rational   512       /(int)1.6328
mpq_rational   512       construct0.381355
mpq_rational   512       construct(unsigned)0.392309
mpq_rational   512       construct(unsigned long long)2.1179
mpq_rational   512       +    2.55999
mpq_rational   512       -    2.52842
mpq_rational   512       *    4.82251
mpq_rational   512       /    4.88079
mpq_rational   512       +    2.5091
mpq_rational   512       -    2.50572
mpq_rational   512       *    9.90285
mpq_rational   512       /    10.0077
mpq_rational   1024      +    38.8883
mpq_rational   1024      -    38.9096
mpq_rational   1024      *    71.0635
mpq_rational   1024      /    123.985
mpq_rational   1024      str  0.0291802
mpq_rational   1024      +(int)0.906471
mpq_rational   1024      -(int)0.908293
mpq_rational   1024      *(int)1.52386
mpq_rational   1024      /(int)1.78575
mpq_rational   1024      construct0.383461
mpq_rational   1024      construct(unsigned)0.393504
mpq_rational   1024      construct(unsigned long long)2.12279
mpq_rational   1024      +    2.67794
mpq_rational   1024      -    2.65991
mpq_rational   1024      *    5.4209
mpq_rational   1024      /    5.47417
mpq_rational   1024      +    2.66144
mpq_rational   1024      -    2.64168
mpq_rational   1024      *    10.4664
mpq_rational   1024      /    10.6781
tommath_int    128       +    0.0222815
tommath_int    128       -    0.027712
tommath_int    128       *    0.113094
tommath_int    128       /    3.09636
tommath_int    128       str  0.0175165
tommath_int    128       +(int)0.205506
tommath_int    128       -(int)0.203148
tommath_int    128       *(int)0.245897
tommath_int    128       /(int)2.08045
tommath_int    128       construct0.207455
tommath_int    128       construct(unsigned)0.477971
tommath_int    128       construct(unsigned long long)0.709516
tommath_int    128       %    3.15171
tommath_int    128       |    0.153434
tommath_int    128       &    0.153508
tommath_int    128       ^    0.153931
tommath_int    128       <<   0.0408165
tommath_int    128       >>   0.324163
tommath_int    128       %(int)2.11648
tommath_int    128       |(int)0.376671
tommath_int    128       &(int)0.389144
tommath_int    128       ^(int)0.374303
tommath_int    128       gcd  12.5322
tommath_int    128       +    0.514965
tommath_int    128       -    0.517555
tommath_int    128       *    0.607102
tommath_int    128       /    2.36098
tommath_int    128       +    0.510608
tommath_int    128       -    0.520979
tommath_int    128       *    18.5642
tommath_int    128       /    1.13357
tommath_int    256       +    0.0322049
tommath_int    256       -    0.0407704
tommath_int    256       *    0.346903
tommath_int    256       /    4.01311
tommath_int    256       str  0.0409078
tommath_int    256       +(int)0.211847
tommath_int    256       -(int)0.206481
tommath_int    256       *(int)0.26894
tommath_int    256       /(int)2.7099
tommath_int    256       construct0.208012
tommath_int    256       construct(unsigned)0.470752
tommath_int    256       construct(unsigned long long)0.709045
tommath_int    256       %    4.08522
tommath_int    256       |    0.170093
tommath_int    256       &    0.176384
tommath_int    256       ^    0.172198
tommath_int    256       <<   0.0698155
tommath_int    256       >>   0.383757
tommath_int    256       %(int)2.74052
tommath_int    256       |(int)0.375206
tommath_int    256       &(int)0.389768
tommath_int    256       ^(int)0.379255
tommath_int    256       gcd  26.1755
tommath_int    256       +    0.530504
tommath_int    256       -    0.527832
tommath_int    256       *    0.648438
tommath_int    256       /    3.16803
tommath_int    256       +    0.526199
tommath_int    256       -    0.527479
tommath_int    256       *    18.624
tommath_int    256       /    1.1208
tommath_int    512       +    0.0455267
tommath_int    512       -    0.0515883
tommath_int    512       *    0.999026
tommath_int    512       /    5.95775
tommath_int    512       str  0.111392
tommath_int    512       +(int)0.227429
tommath_int    512       -(int)0.219998
tommath_int    512       *(int)0.31746
tommath_int    512       /(int)4.1339
tommath_int    512       construct0.205622
tommath_int    512       construct(unsigned)0.473807
tommath_int    512       construct(unsigned long long)0.703879
tommath_int    512       %    5.70483
tommath_int    512       |    0.179084
tommath_int    512       &    0.182373
tommath_int    512       ^    0.183434
tommath_int    512       <<   0.0973643
tommath_int    512       >>   0.398354
tommath_int    512       %(int)3.96918
tommath_int    512       |(int)0.381428
tommath_int    512       &(int)0.40432
tommath_int    512       ^(int)0.390434
tommath_int    512       gcd  56.7747
tommath_int    512       +    0.546222
tommath_int    512       -    0.53408
tommath_int    512       *    0.718764
tommath_int    512       /    5.07545
tommath_int    512       +    0.543084
tommath_int    512       -    0.535411
tommath_int    512       *    18.745
tommath_int    512       /    1.15084
tommath_int    1024      +    0.074223
tommath_int    1024      -    0.0786205
tommath_int    1024      *    3.20269
tommath_int    1024      /    12.7383
tommath_int    1024      str  0.345861
tommath_int    1024      +(int)0.250477
tommath_int    1024      -(int)0.2372
tommath_int    1024      *(int)0.408933
tommath_int    1024      /(int)9.04346
tommath_int    1024      construct0.207377
tommath_int    1024      construct(unsigned)0.475755
tommath_int    1024      construct(unsigned long long)0.712949
tommath_int    1024      %    12.6845
tommath_int    1024      |    0.436588
tommath_int    1024      &    0.429721
tommath_int    1024      ^    0.429478
tommath_int    1024      <<   0.167289
tommath_int    1024      >>   0.570323
tommath_int    1024      %(int)9.09202
tommath_int    1024      |(int)0.622404
tommath_int    1024      &(int)0.653128
tommath_int    1024      ^(int)0.62285
tommath_int    1024      gcd  132.299
tommath_int    1024      +    0.578521
tommath_int    1024      -    0.552649
tommath_int    1024      *    0.871648
tommath_int    1024      /    12.2672
tommath_int    1024      +    0.568301
tommath_int    1024      -    0.54931
tommath_int    1024      *    19.0954
tommath_int    1024      /    1.21165
cpp_dec_float  50        +    0.0250949
cpp_dec_float  50        -    0.0264782
cpp_dec_float  50        *    0.163403
cpp_dec_float  50        /    3.9502
cpp_dec_float  50        str  0.0207318
cpp_dec_float  50        +(int)0.0441266
cpp_dec_float  50        -(int)0.0442578
cpp_dec_float  50        *(int)0.234992
cpp_dec_float  50        /(int)1.81469
cpp_dec_float  50        construct0.00925753
cpp_dec_float  50        construct(unsigned)0.0588752
cpp_dec_float  50        construct(unsigned long long)0.0587691
cpp_dec_float  50        +    0.0770875
cpp_dec_float  50        -    0.0741921
cpp_dec_float  50        *    0.329282
cpp_dec_float  50        /    1.9701
cpp_dec_float  50        +    0.0640148
cpp_dec_float  50        -    0.0643402
cpp_dec_float  50        *    0.321363
cpp_dec_float  50        /    1.97464
cpp_dec_float  100       +    0.0291508
cpp_dec_float  100       -    0.0307447
cpp_dec_float  100       *    0.284182
cpp_dec_float  100       /    7.68823
cpp_dec_float  100       str  0.0328218
cpp_dec_float  100       +(int)0.0558389
cpp_dec_float  100       -(int)0.0563278
cpp_dec_float  100       *(int)0.460635
cpp_dec_float  100       /(int)3.62471
cpp_dec_float  100       construct0.0263234
cpp_dec_float  100       construct(unsigned)0.0747853
cpp_dec_float  100       construct(unsigned long long)0.076338
cpp_dec_float  100       +    0.0845054
cpp_dec_float  100       -    0.0844193
cpp_dec_float  100       *    0.582119
cpp_dec_float  100       /    3.8773
cpp_dec_float  100       +    0.0708668
cpp_dec_float  100       -    0.0730765
cpp_dec_float  100       *    0.574512
cpp_dec_float  100       /    3.83437
cpp_dec_float  500       +    0.0630915
cpp_dec_float  500       -    0.0651113
cpp_dec_float  500       *    2.22501
cpp_dec_float  500       /    50.6121
cpp_dec_float  500       str  0.131293
cpp_dec_float  500       +(int)0.0935946
cpp_dec_float  500       -(int)0.0950432
cpp_dec_float  500       *(int)4.36195
cpp_dec_float  500       /(int)24.4855
cpp_dec_float  500       construct0.0306104
cpp_dec_float  500       construct(unsigned)0.114772
cpp_dec_float  500       construct(unsigned long long)0.117075
cpp_dec_float  500       +    0.12407
cpp_dec_float  500       -    0.122646
cpp_dec_float  500       *    4.75508
cpp_dec_float  500       /    25.1602
cpp_dec_float  500       +    0.0865073
cpp_dec_float  500       -    0.0929075
cpp_dec_float  500       *    4.74128
cpp_dec_float  500       /    25.1175
mpfr_float     50        +    0.0624318
mpfr_float     50        -    0.0764497
mpfr_float     50        *    0.342248
mpfr_float     50        /    1.69721
mpfr_float     50        str  0.0289013
mpfr_float     50        +(int)0.121683
mpfr_float     50        -(int)0.149605
mpfr_float     50        *(int)0.1548
mpfr_float     50        /(int)0.213367
mpfr_float     50        construct0.214552
mpfr_float     50        construct(unsigned)0.293892
mpfr_float     50        construct(unsigned long long)0.638307
mpfr_float     50        +    0.553442
mpfr_float     50        -    0.565687
mpfr_float     50        *    0.841214
mpfr_float     50        /    1.26072
mpfr_float     50        +    0.537349
mpfr_float     50        -    0.561924
mpfr_float     50        *    0.833423
mpfr_float     50        /    1.25318
mpfr_float     100       +    0.0669494
mpfr_float     100       -    0.0820912
mpfr_float     100       *    0.478422
mpfr_float     100       /    2.33995
mpfr_float     100       str  0.0390764
mpfr_float     100       +(int)0.117387
mpfr_float     100       -(int)0.150557
mpfr_float     100       *(int)0.166496
mpfr_float     100       /(int)0.267439
mpfr_float     100       construct0.222594
mpfr_float     100       construct(unsigned)0.297568
mpfr_float     100       construct(unsigned long long)0.643108
mpfr_float     100       +    0.573918
mpfr_float     100       -    0.592139
mpfr_float     100       *    0.978674
mpfr_float     100       /    1.5879
mpfr_float     100       +    0.561143
mpfr_float     100       -    0.580528
mpfr_float     100       *    0.97887
mpfr_float     100       /    1.58378
mpfr_float     500       +    0.0817812
mpfr_float     500       -    0.0975533
mpfr_float     500       *    3.8308
mpfr_float     500       /    13.8283
mpfr_float     500       str  0.156188
mpfr_float     500       +(int)0.129266
mpfr_float     500       -(int)0.16446
mpfr_float     500       *(int)0.273431
mpfr_float     500       /(int)0.731526
mpfr_float     500       construct0.222587
mpfr_float     500       construct(unsigned)0.311108
mpfr_float     500       construct(unsigned long long)0.653074
mpfr_float     500       +    0.667956
mpfr_float     500       -    0.684152
mpfr_float     500       *    1.2661
mpfr_float     500       /    7.46167
mpfr_float     500       +    0.642822
mpfr_float     500       -    0.65164
mpfr_float     500       *    1.25714
mpfr_float     500       /    7.46171
[section:float_performance Float Type Perfomance]
[table Operator *
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.321363s)][1.0169 (0.574512s)][6.76401 (4.74128s)]]
[[gmp_float][1.7169 (0.551747s)][[*1] (0.564962s)][[*1] (0.700957s)]]
[[mpfr_float][2.5934 (0.833423s)][1.73263 (0.97887s)][1.79346 (1.25714s)]]
]
[table Operator *(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][5.56675 (0.234992s)][9.32996 (0.460635s)][50.8459 (4.36195s)]]
[[gmp_float][[*1] (0.0422135s)][[*1] (0.0493716s)][[*1] (0.0857876s)]]
[[mpfr_float][3.66707 (0.1548s)][3.37231 (0.166496s)][3.1873 (0.273431s)]]
]
[table Operator +
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0640148s)][[*1] (0.0708668s)][[*1] (0.0865073s)]]
[[gmp_float][7.467 (0.477999s)][6.72671 (0.476701s)][5.67136 (0.490614s)]]
[[mpfr_float][8.39413 (0.537349s)][7.91828 (0.561143s)][7.43085 (0.642822s)]]
]
[table Operator +(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][1.33358 (0.0441266s)][1.4433 (0.0558389s)][1.44838 (0.0935946s)]]
[[gmp_float][[*1] (0.0330888s)][[*1] (0.0386882s)][[*1] (0.0646201s)]]
[[mpfr_float][3.67747 (0.121683s)][3.03419 (0.117387s)][2.00041 (0.129266s)]]
]
[table Operator -
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0643402s)][[*1] (0.0730765s)][[*1] (0.0929075s)]]
[[gmp_float][7.76625 (0.499682s)][6.89067 (0.503546s)][5.89566 (0.547751s)]]
[[mpfr_float][8.73364 (0.561924s)][7.94411 (0.580528s)][7.01385 (0.65164s)]]
]
[table Operator -(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0442578s)][[*1] (0.0563278s)][[*1] (0.0950432s)]]
[[gmp_float][3.0379 (0.134451s)][2.39847 (0.1351s)][1.86101 (0.176876s)]]
[[mpfr_float][3.38031 (0.149605s)][2.67288 (0.150557s)][1.73037 (0.16446s)]]
]
[table Operator /
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][2.20938 (1.97464s)][3.71086 (3.83437s)][11.2059 (25.1175s)]]
[[gmp_float][[*1] (0.893752s)][[*1] (1.03328s)][[*1] (2.24146s)]]
[[mpfr_float][1.40216 (1.25318s)][1.53276 (1.58378s)][3.32895 (7.46171s)]]
]
[table Operator /(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][10.0596 (1.81469s)][15.5048 (3.62471s)][34.4767 (24.4855s)]]
[[gmp_float][[*1] (0.180393s)][[*1] (0.23378s)][[*1] (0.710204s)]]
[[mpfr_float][1.18279 (0.213367s)][1.14398 (0.267439s)][1.03002 (0.731526s)]]
]
[table Operator construct
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.00925753s)][[*1] (0.0263234s)][[*1] (0.0306104s)]]
[[gmp_float][21.32 (0.19737s)][7.4686 (0.196599s)][6.73181 (0.206063s)]]
[[mpfr_float][23.176 (0.214552s)][8.45613 (0.222594s)][7.27162 (0.222587s)]]
]
[table Operator construct(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0587691s)][[*1] (0.076338s)][[*1] (0.117075s)]]
[[gmp_float][8.84863 (0.520025s)][6.80343 (0.51936s)][4.59554 (0.538021s)]]
[[mpfr_float][10.8613 (0.638307s)][8.42448 (0.643108s)][5.57826 (0.653074s)]]
]
[table Operator construct(unsigned)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][[*1] (0.0588752s)][[*1] (0.0747853s)][[*1] (0.114772s)]]
[[gmp_float][3.53421 (0.208078s)][2.76875 (0.207062s)][1.89088 (0.217019s)]]
[[mpfr_float][4.99178 (0.293892s)][3.97896 (0.297568s)][2.71067 (0.311108s)]]
]
[table Operator str
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_dec_float][1.5616 (0.0207318s)][1.61725 (0.0328218s)][[*1] (0.131293s)]]
[[gmp_float][[*1] (0.013276s)][[*1] (0.0202949s)][1.07517 (0.141162s)]]
[[mpfr_float][2.17696 (0.0289013s)][1.92543 (0.0390764s)][1.18962 (0.156188s)]]
]
[endsect]
[section:integer_performance Integer Type Perfomance]
[table Operator %
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][5.31184 (0.37333s)][1.99944e+236 (0.673748s)][2.08204e+236 (0.701584s)][3.39405e+236 (1.14369s)]]
[[cpp_int(fixed)][1.10616 (0.0777437s)][5.8492e+235 (0.1971s)][9.91271e+235 (0.334027s)][1.60165e+236 (0.539708s)][-1.#INF (0.94847s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0702826s)]]
[[gmp_int][9.12715 (0.64148s)][2.088e+236 (0.703592s)][2.43295e+236 (0.819828s)][3.02578e+236 (1.01959s)]]
[[tommath_int][44.8434 (3.15171s)][1.21234e+237 (4.08522s)][1.69298e+237 (5.70483s)][3.7643e+237 (12.6845s)]]
]
[table Operator %(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][3.51789 (0.104856s)][-1.#INF (0.203012s)][-1.#INF (0.391566s)][-1.#INF (0.768511s)]]
[[cpp_int(fixed)][1.14548 (0.0341425s)][-1.#INF (0.103684s)][-1.#INF (0.200647s)][-1.#INF (0.377704s)][-1.#INF (0.743202s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0298064s)]]
[[gmp_int][1.91945 (0.0572117s)][-1.#INF (0.10258s)][-1.#INF (0.188529s)][-1.#INF (0.355222s)]]
[[tommath_int][71.0078 (2.11648s)][-1.#INF (2.74052s)][-1.#INF (3.96918s)][-1.#INF (9.09202s)]]
]
[table Operator &
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][12.079 (0.031605s)][-1.11772e+007 (0.0455929s)][-1.33961e+007 (0.0546439s)][-2.06875e+007 (0.0843863s)]]
[[cpp_int(fixed)][4.74538 (0.0124165s)][-8.36978e+006 (0.0341411s)][-1.22854e+007 (0.0501131s)][-1.4424e+007 (0.0588367s)][-1.#INF (0.0774574s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00261653s)]]
[[gmp_int][20.5664 (0.0538128s)][-1.59881e+007 (0.0652169s)][-2.25796e+007 (0.092104s)][-3.5403e+007 (0.144412s)]]
[[tommath_int][58.6685 (0.153508s)][-4.3241e+007 (0.176384s)][-4.47093e+007 (0.182373s)][-1.05347e+008 (0.429721s)]]
]
[table Operator &(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][23.3956 (0.0377678s)][-7.85844e+307 (0.0471524s)][-1.07843e+308 (0.0647085s)][-1.68143e+308 (0.10089s)]]
[[cpp_int(fixed)][6.49083 (0.0104782s)][-6.95612e+307 (0.0417383s)][-8.99012e+307 (0.0539427s)][-1.17371e+308 (0.070425s)][-1.#INF (0.112823s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00161431s)]]
[[gmp_int][87.5331 (0.141306s)][-1.#INF (0.139398s)][-1.#INF (0.142498s)][-1.#INF (0.141249s)]]
[[tommath_int][241.059 (0.389144s)][-1.#INF (0.389768s)][-1.#INF (0.40432s)][-1.#INF (0.653128s)]]
]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1715.93 (7.6372s)][-4.15607e+276 (7.7121s)][-4.16472e+276 (7.72815s)][-4.23791e+276 (7.86395s)]]
[[cpp_int(fixed)][1.27579 (0.00567824s)][-3.62916e+274 (0.0673436s)][-5.78275e+274 (0.107306s)][-9.2595e+274 (0.171821s)][-1.#INF (0.299236s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00445077s)]]
[[gmp_int][710.595 (3.1627s)][-1.69816e+276 (3.15114s)][-1.70883e+276 (3.17094s)][-1.7293e+276 (3.20893s)]]
[[tommath_int][4171.01 (18.5642s)][-1.00365e+277 (18.624s)][-1.01017e+277 (18.745s)][-1.02906e+277 (19.0954s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.97316 (0.0235876s)][1.#INF (0.0318939s)][1.#INF (0.0427792s)][1.#INF (0.0668616s)]]
[[cpp_int(fixed)][2.32007 (0.00548722s)][1.#INF (0.0328109s)][1.#INF (0.049867s)][1.#INF (0.0658566s)][-1.#INF (0.0948565s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00236511s)]]
[[gmp_int][9.62157 (0.022756s)][1.#INF (0.0282672s)][1.#INF (0.0361075s)][1.#INF (0.0518882s)]]
[[tommath_int][103.969 (0.245897s)][1.#INF (0.26894s)][1.#INF (0.31746s)][1.#INF (0.408933s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.74543 (0.0196594s)][3.98952e+276 (0.0215291s)][4.2355e+276 (0.0228565s)][4.21393e+276 (0.0227402s)]]
[[cpp_int(fixed)][2.13187 (0.00430062s)][3.11951e+276 (0.0168342s)][3.15933e+276 (0.0170491s)][3.19893e+276 (0.0172628s)][-1.#INF (0.0181245s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0020173s)]]
[[gmp_int][337.759 (0.68136s)][1.27731e+278 (0.68929s)][1.28647e+278 (0.694235s)][1.27865e+278 (0.690013s)]]
[[tommath_int][253.115 (0.510608s)][9.75089e+277 (0.526199s)][1.00638e+278 (0.543084s)][1.05311e+278 (0.568301s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.81588 (0.0159069s)][-5.71737e+244 (0.0218386s)][-8.2882e+244 (0.0316584s)][-1.1265e+245 (0.0430289s)]]
[[cpp_int(fixed)][3.92617 (0.00636247s)][-7.02443e+244 (0.0268311s)][-1.07535e+245 (0.0410749s)][-1.37293e+245 (0.0524416s)][-1.#INF (0.0728817s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00162053s)]]
[[gmp_int][19.2059 (0.0311237s)][-1.12054e+245 (0.0428011s)][-1.74239e+245 (0.0665539s)][-2.83458e+245 (0.108272s)]]
[[tommath_int][126.815 (0.205506s)][-5.54618e+245 (0.211847s)][-5.95413e+245 (0.227429s)][-6.55751e+245 (0.250477s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][11.0409 (0.0210968s)][3.86227e+276 (0.0213343s)][4.03471e+276 (0.0222868s)][4.24576e+276 (0.0234526s)]]
[[cpp_int(fixed)][2.02836 (0.00387577s)][3.06763e+276 (0.0169449s)][3.2004e+276 (0.0176783s)][3.27232e+276 (0.0180756s)][-1.#INF (0.0190581s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00191079s)]]
[[gmp_int][356.496 (0.681187s)][1.23744e+278 (0.683532s)][1.2536e+278 (0.69246s)][1.25066e+278 (0.690838s)]]
[[tommath_int][272.651 (0.520979s)][9.54925e+277 (0.527479s)][9.69283e+277 (0.535411s)][9.94446e+277 (0.54931s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][9.24378 (0.0151244s)][-1.01975e-199 (0.017199s)][-1.47092e-199 (0.0248084s)][-1.96387e-199 (0.0331224s)]]
[[cpp_int(fixed)][4.08494 (0.00668367s)][-1.43394e-199 (0.0241848s)][-2.18373e-199 (0.0368306s)][-2.98469e-199 (0.0503396s)][-1.#INF (0.0621059s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00163617s)]]
[[gmp_int][18.693 (0.030585s)][-2.37422e-199 (0.0400434s)][-3.42818e-199 (0.0578194s)][-5.96116e-199 (0.100541s)]]
[[tommath_int][124.161 (0.203148s)][-1.22425e-198 (0.206481s)][-1.30439e-198 (0.219998s)][-1.40639e-198 (0.2372s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.96346 (0.0578293s)][-1.51814e+061 (0.0615507s)][-1.8062e+061 (0.0732298s)][-3.04778e+061 (0.123568s)]]
[[cpp_int(fixed)][1.08704 (0.0320162s)][-8.07606e+060 (0.0327432s)][-8.40351e+060 (0.0340708s)][-1.09735e+061 (0.0444905s)][-1.#INF (0.106788s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0294528s)]]
[[gmp_int][23.2741 (0.685487s)][-1.70068e+062 (0.689516s)][-1.6994e+062 (0.688995s)][-1.74523e+062 (0.707578s)]]
[[tommath_int][38.4876 (1.13357s)][-2.76443e+062 (1.1208s)][-2.83854e+062 (1.15084s)][-2.98853e+062 (1.21165s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][7.87676 (0.235955s)][1.#INF (0.35212s)][1.#INF (0.568032s)][1.#INF (0.989885s)]]
[[cpp_int(fixed)][1.21173 (0.0362985s)][1.#INF (0.137619s)][1.#INF (0.253796s)][1.#INF (0.446782s)][-1.#INF (0.84764s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0299559s)]]
[[gmp_int][1.87075 (0.0560401s)][1.#INF (0.0982823s)][1.#INF (0.183564s)][1.#INF (0.352238s)]]
[[tommath_int][69.4504 (2.08045s)][1.#INF (2.7099s)][1.#INF (4.1339s)][1.#INF (9.04346s)]]
]
[table Operator <<
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][15.849 (0.0256107s)][-5.85461e+126 (0.0401135s)][-6.36621e+126 (0.0436188s)][-9.17366e+126 (0.0628544s)]]
[[cpp_int(fixed)][3.19639 (0.00516511s)][-4.68379e+126 (0.0320915s)][-7.40049e+126 (0.0507053s)][-8.72078e+126 (0.0597514s)][-1.#INF (0.0677088s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00161592s)]]
[[gmp_int][16.956 (0.0273994s)][-4.66649e+126 (0.031973s)][-6.88464e+126 (0.0471709s)][-1.05374e+127 (0.0721984s)]]
[[tommath_int][25.259 (0.0408165s)][-1.01897e+127 (0.0698155s)][-1.42104e+127 (0.0973643s)][-2.4416e+127 (0.167289s)]]
]
[table Operator >>
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][14.6983 (0.0237523s)][-2.28921e+307 (0.0302534s)][-2.68808e+307 (0.0355247s)][-3.38364e+307 (0.044717s)]]
[[cpp_int(fixed)][2.47217 (0.00399499s)][-2.21749e+307 (0.0293055s)][-2.9515e+307 (0.039006s)][-3.9023e+307 (0.0515714s)][-1.#INF (0.0626121s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00161599s)]]
[[gmp_int][17.8366 (0.0288237s)][-2.3471e+307 (0.0310184s)][-2.55387e+307 (0.0337511s)][-2.9362e+307 (0.0388038s)]]
[[tommath_int][200.597 (0.324163s)][-1.#INF (0.383757s)][-1.#INF (0.398354s)][-1.#INF (0.570323s)]]
]
[table Operator ^
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][7.95372 (0.0318172s)][1.21131 (0.0425243s)][1.02246 (0.0542436s)][1.19877 (0.08333s)]]
[[cpp_int(fixed)][2.75762 (0.0110313s)][[*1] (0.0351059s)][[*1] (0.0530521s)][[*1] (0.0695132s)][-1.#INF (0.09783s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.0040003s)]]
[[gmp_int][12.4289 (0.0497194s)][1.79507 (0.0630174s)][1.63955 (0.0869819s)][2.0012 (0.139109s)]]
[[tommath_int][38.4798 (0.153931s)][4.9051 (0.172198s)][3.45761 (0.183434s)][6.17837 (0.429478s)]]
]
[table Operator ^(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][15.3547 (0.0283305s)][-8.92021e+307 (0.0353555s)][-1.05356e+308 (0.041758s)][-1.35819e+308 (0.0538323s)]]
[[cpp_int(fixed)][5.81005 (0.0107199s)][-7.88073e+307 (0.0312355s)][-1.20328e+308 (0.0476923s)][-1.36485e+308 (0.0540962s)][-1.#INF (0.0806317s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00184507s)]]
[[gmp_int][78.0102 (0.143934s)][-1.#INF (0.144825s)][-1.#INF (0.152773s)][-1.#INF (0.161662s)]]
[[tommath_int][202.867 (0.374303s)][-1.#INF (0.379255s)][-1.#INF (0.390434s)][-1.#INF (0.62285s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.64088 (0.00293927s)][1.47161e+238 (0.00277479s)][1.49039e+238 (0.0028102s)][1.47064e+238 (0.00277298s)]]
[[cpp_int(fixed)][1.45325 (0.00161745s)][8.73297e+237 (0.00164665s)][1.92709e+238 (0.00363363s)][3.0576e+238 (0.00576526s)][-1.#INF (0.00535599s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00111299s)]]
[[gmp_int][176.266 (0.196182s)][1.06706e+240 (0.201199s)][1.04919e+240 (0.19783s)][1.04712e+240 (0.19744s)]]
[[tommath_int][186.394 (0.207455s)][1.10319e+240 (0.208012s)][1.09052e+240 (0.205622s)][1.09982e+240 (0.207377s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][3.51152 (0.00719854s)][-2.80497e-148 (0.00725455s)][-2.79893e-148 (0.00723891s)][-2.83336e-148 (0.00732796s)]]
[[cpp_int(fixed)][[*1] (0.00204998s)][-1.21019e-148 (0.00312994s)][-1.50065e-148 (0.00388115s)][-2.15185e-148 (0.00556537s)][-1.#INF (0.00577713s)]]
[[cpp_int(unsigned, fixed)][1.17501 (0.00240876s)]]
[[gmp_int][351.097 (0.719741s)][-2.82056e-146 (0.729487s)][-2.80186e-146 (0.724649s)][-2.79263e-146 (0.722262s)]]
[[tommath_int][346.109 (0.709516s)][-2.74152e-146 (0.709045s)][-2.72155e-146 (0.703879s)][-2.75662e-146 (0.712949s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][2.44987 (0.00270684s)][1.90974 (0.0030529s)][[*1] (0.00288857s)][[*1] (0.00265201s)]]
[[cpp_int(fixed)][1.89292 (0.00209147s)][[*1] (0.0015986s)][1.28253 (0.00370466s)][2.19414 (0.0058189s)][-1.#INF (0.00836042s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00110489s)]]
[[gmp_int][186.546 (0.206113s)][132.175 (0.211295s)][71.6424 (0.206944s)][81.5339 (0.216229s)]]
[[tommath_int][432.596 (0.477971s)][294.478 (0.470752s)][164.029 (0.473807s)][179.394 (0.475755s)]]
]
[table Operator gcd
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][8.27321 (4.98644s)][-1.#INF (11.1816s)][-1.#INF (27.2257s)][-1.#INF (73.3735s)]]
[[cpp_int(fixed)][1.0026 (0.604291s)][-1.#INF (4.18006s)][-1.#INF (10.2671s)][-1.#INF (26.2762s)][-1.#INF (76.2849s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.602722s)]]
[[gmp_int][4.06647 (2.45095s)][-1.#INF (5.89505s)][-1.#INF (13.6993s)][-1.#INF (33.2232s)]]
[[tommath_int][20.7927 (12.5322s)][-1.#INF (26.1755s)][-1.#INF (56.7747s)][-1.#INF (132.299s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][1.02246 (0.00189808s)][-3.42215e+178 (0.00391656s)][-7.26989e+178 (0.00832019s)][-1.93625e+179 (0.0221599s)]]
[[cpp_int(fixed)][1.35564 (0.00251659s)][-1.36421e+178 (0.0015613s)][-2.59752e+178 (0.00297279s)][-6.18963e+178 (0.00708386s)][-1.#INF (0.0172514s)]]
[[cpp_int(unsigned, fixed)][1.38149 (0.00256457s)]]
[[gmp_int][[*1] (0.00185638s)][-3.01078e+178 (0.00344576s)][-5.40339e+178 (0.00618403s)][-1.26279e+179 (0.0144523s)]]
[[tommath_int][9.43586 (0.0175165s)][-3.57438e+179 (0.0409078s)][-9.73304e+179 (0.111392s)][-3.02201e+180 (0.345861s)]]
]
[table Operator |
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][11.6542 (0.030991s)][-6.48076e+046 (0.0429658s)][-8.11261e+046 (0.0537846s)][-1.24844e+047 (0.0827684s)]]
[[cpp_int(fixed)][4.09831 (0.0108982s)][-5.73378e+046 (0.0380136s)][-7.98794e+046 (0.0529581s)][-1.02098e+047 (0.0676884s)][-1.#INF (0.100936s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00265921s)]]
[[gmp_int][17.8503 (0.0474678s)][-9.32586e+046 (0.0618281s)][-1.29209e+047 (0.0856626s)][-2.0526e+047 (0.136082s)]]
[[tommath_int][57.6991 (0.153434s)][-2.5656e+047 (0.170093s)][-2.70121e+047 (0.179084s)][-6.58529e+047 (0.436588s)]]
]
[table Operator |(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][16.9457 (0.0280516s)][-4.17523e+307 (0.0363929s)][-4.79721e+307 (0.0418143s)][-6.04694e+307 (0.0527075s)]]
[[cpp_int(fixed)][6.70551 (0.0111002s)][-3.64663e+307 (0.0317854s)][-5.35725e+307 (0.0466958s)][-6.16052e+307 (0.0536974s)][-1.#INF (0.0819107s)]]
[[cpp_int(unsigned, fixed)][[*1] (0.00165538s)]]
[[gmp_int][85.2488 (0.141119s)][-1.64044e+308 (0.142987s)][-1.78579e+308 (0.155656s)][-1.#INF (0.163236s)]]
[[tommath_int][227.544 (0.376671s)][-1.#INF (0.375206s)][-1.#INF (0.381428s)][-1.#INF (0.622404s)]]
]
[endsect]
[section:rational_performance Rational Type Perfomance]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][6.20279 (57.9393s)][6.23608 (59.3172s)][6.25071 (61.8998s)][6.44097 (67.4139s)]]
[[mpq_rational][[*1] (9.34086s)][[*1] (9.51195s)][[*1] (9.90285s)][[*1] (10.4664s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.06502 (2.4377s)][2.38344 (2.91325s)][2.86734 (3.94768s)][3.8554 (5.87507s)]]
[[mpq_rational][[*1] (1.18047s)][[*1] (1.22229s)][[*1] (1.37678s)][[*1] (1.52386s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.1513 (2.68363s)][1.31207 (3.15142s)][1.61685 (4.05684s)][2.18092 (5.80438s)]]
[[mpq_rational][[*1] (2.33097s)][[*1] (2.40187s)][[*1] (2.5091s)][[*1] (2.66144s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][3.69962 (2.47739s)][4.12788 (2.92179s)][4.67839 (3.80252s)][6.08526 (5.51612s)]]
[[mpq_rational][[*1] (0.669634s)][[*1] (0.707818s)][[*1] (0.812783s)][[*1] (0.906471s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.17746 (2.72926s)][1.334 (3.19882s)][1.63017 (4.08474s)][2.21829 (5.86s)]]
[[mpq_rational][[*1] (2.31793s)][[*1] (2.39792s)][[*1] (2.50572s)][[*1] (2.64168s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][3.71756 (2.47959s)][4.04045 (2.90579s)][4.69474 (3.80714s)][6.07677 (5.51949s)]]
[[mpq_rational][[*1] (0.666993s)][[*1] (0.719174s)][[*1] (0.810939s)][[*1] (0.908293s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][5.95741 (58.0332s)][6.16582 (59.5431s)][6.19235 (61.9712s)][6.31439 (67.4254s)]]
[[mpq_rational][[*1] (9.74135s)][[*1] (9.65697s)][[*1] (10.0077s)][[*1] (10.6781s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.75198 (2.50843s)][2.05836 (3.00689s)][2.45339 (4.00588s)][3.31983 (5.92837s)]]
[[mpq_rational][[*1] (1.43177s)][[*1] (1.46082s)][[*1] (1.6328s)][[*1] (1.78575s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.0102665s)][[*1] (0.0101737s)][[*1] (0.0101965s)][[*1] (0.0102909s)]]
[[mpq_rational][37.3164 (0.383107s)][37.5023 (0.381537s)][37.4005 (0.381355s)][37.2621 (0.383461s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.0658436s)][[*1] (0.0665504s)][[*1] (0.0659082s)][[*1] (0.0659089s)]]
[[mpq_rational][32.3771 (2.13183s)][31.9648 (2.12727s)][32.1342 (2.1179s)][32.2079 (2.12279s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.0624887s)][[*1] (0.0609531s)][[*1] (0.0613968s)][[*1] (0.062674s)]]
[[mpq_rational][6.31396 (0.394551s)][6.41455 (0.390987s)][6.38973 (0.392309s)][6.27858 (0.393504s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][5.4954 (0.020339s)][9.02403 (0.0517328s)][9.75685 (0.119248s)][9.80346 (0.286067s)]]
[[mpq_rational][[*1] (0.0037011s)][[*1] (0.00573278s)][[*1] (0.012222s)][[*1] (0.0291802s)]]
]
[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011-21 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// This is the main entry point for our operator performance test suite.
// In order to build this program, you must compile and link this file against
// all the libs/multiprecision/performance/performance_test_files/*.cpp files.
// 
// The default behaviour is to "test everything", which is probably not what you want.
// In order to restict testing to a specific selection of backends, you will need to
// define one or more of the following macros when building:
// 
// TEST_MPF
// TEST_MPZ
// TEST_CPP_DEC_FLOAT
// TEST_MPFR
// TEST_MPQ
// TEST_TOMMATH
// TEST_TOMMATH_BOOST_RATIONAL
// TEST_MPZ_BOOST_RATIONAL
// TEST_CPP_INT
// TEST_CPP_INT_RATIONAL
// TEST_CPP_BIN_FLOAT
//

#include "performance_test.hpp"

#ifdef TEST_MPZ
#include <gmp.h>
#endif
#ifdef TEST_MPFR
#include <mpfr.h>
#endif
#include <boost/version.hpp>

//
// Keys in order are:
// Category
// Operator
// Type
// Precision
// Time
//
std::map<std::string, std::map<std::string, std::map<std::string, std::map<int, double> > > > result_table;

unsigned bits_wanted; // for integer types

void quickbook_results()
{
   //
   // Keys in order are:
   // Category
   // Operator
   // Type
   // Precision
   // Time
   //
   typedef std::map<std::string, std::map<std::string, std::map<std::string, std::map<int, double> > > >::const_iterator category_iterator;
   typedef std::map<std::string, std::map<std::string, std::map<int, double> > >::const_iterator                         operator_iterator;
   typedef std::map<std::string, std::map<int, double> >::const_iterator                                                 type_iterator;
   typedef std::map<int, double>::const_iterator                                                                         precision_iterator;

   for (category_iterator i = result_table.begin(); i != result_table.end(); ++i)
   {
      std::string cat = i->first;
      cat[0]          = (char)std::toupper((char)cat[0]);
      std::cout << "[section:" << i->first << "_performance " << cat << " Type Perfomance]" << std::endl;

      for (operator_iterator j = i->second.begin(); j != i->second.end(); ++j)
      {
         std::string op = j->first;
         std::cout << "[table Operator " << op << std::endl;
         std::cout << "[[Backend]";

         for (precision_iterator k = j->second.begin()->second.begin(); k != j->second.begin()->second.end(); ++k)
         {
            std::cout << "[" << k->first << " Bits]";
         }
         std::cout << "]\n";

         std::vector<double> best_times(j->second.begin()->second.size(), (std::numeric_limits<double>::max)());
         for (unsigned m = 0; m < j->second.begin()->second.size(); ++m)
         {
            for (type_iterator k = j->second.begin(); k != j->second.end(); ++k)
            {
               if (m < k->second.size())
               {
                  precision_iterator l = k->second.begin();
                  std::advance(l, m);
                  if (best_times[m] > l->second)
                     best_times[m] = l->second ? l->second : best_times[m];
               }
            }
         }

         for (type_iterator k = j->second.begin(); k != j->second.end(); ++k)
         {
            std::cout << "[[" << k->first << "]";

            unsigned m = 0;
            for (precision_iterator l = k->second.begin(); l != k->second.end(); ++l)
            {
               double rel_time = l->second / best_times[m];
               if (rel_time == 1)
                  std::cout << "[[*" << rel_time << "]";
               else
                  std::cout << "[" << rel_time;
               std::cout << " (" << l->second << "s)]";
               ++m;
            }

            std::cout << "]\n";
         }

         std::cout << "]\n";
      }

      std::cout << "[endsect]" << std::endl;
   }
}

#if defined(__HAS_INCLUDE)
#if __has_include(<sys/utsname.h>)
#define HAS_UTSNAME
#include <sys/utsname.h>
#endif
#endif
#ifdef _WIN32
#include <windows.h>
#endif

void quickbook_platform_details()
{
   std::cout << "[table:platform Platform Details\n[[Platform][";
#ifdef HAS_UTSNAME
   utsname name;
   uname(&name);
   std::cout << name.sysname << " " << name.release << ", version " << name.version << ", " << name.machine << "]]\n";
#elif defined(_WIN32)
   std::cout << "Windows ";
#ifdef _M_AMD64
   std::cout << "x64";
#elif defined(_M_IX86)
   std::cout << "x86";
#endif
   std::cout << "]]\n";
#endif
   std::cout << "[[Compiler][" << BOOST_COMPILER << "]]\n";
#ifdef TEST_MPZ
   std::cout << "[[GMP][" << gmp_version << "]]\n";
#endif
#ifdef TEST_MPFR
   std::cout << "[[MPFR][" << MPFR_VERSION << "]]\n";
#endif
   std::cout << "[[Boost][" << BOOST_VERSION << "]]\n";
   std::cout << "[[Run date][" << __DATE__ << "]]\n";
   std::cout << "]\n\n";
}

int main()
{
   quickbook_platform_details();

   test01();
   test02();
   test03();
   test04();
   test05();
   test06();
   test07();
   test08();
   test09();
   test10();
   test11();
   test12();
   test13();
   test14();
   test15();
   test16();
   test17();
   test18();
   test19();
   test20();
   test21();
   test22();
   test23();
   test24();
   test25();
   test26();
   test27();
   test28();
   test29();
   test30();
   test31();
   test32();
   test33();
   test34();
   test35();
   test36();
   test37();
   test38();
   test39();
   test40();
   test41();
   test42();
   test43();
   test44();
   test45();
   test46();
   test47();
   test48();
   test49();
   test50();
   test51();

   quickbook_results();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011-9 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_CHRONO_HEADER_ONLY

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_MPF) && !defined(TEST_MPZ) && \
    !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPQ) && !defined(TEST_TOMMATH) && \
    !defined(TEST_TOMMATH_BOOST_RATIONAL) && !defined(TEST_MPZ_BOOST_RATIONAL) && !defined(TEST_CPP_INT) && \
    !defined(TEST_CPP_INT_RATIONAL) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF
#define TEST_MPZ
#define TEST_MPQ
#define TEST_MPFR
#define TEST_CPP_DEC_FLOAT
#define TEST_MPQ
#define TEST_TOMMATH
#define TEST_CPP_INT
#define TEST_CPP_INT_RATIONAL
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/chrono.hpp>
#include <vector>
#include <map>
#include <string>
#include <cstring>
#include <cctype>
#include <iostream>
#include <iomanip>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/multiprecision/number.hpp>

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

extern unsigned bits_wanted; // for integer types

template <class T, int Type>
struct tester
{
   tester()
   {
      a.assign(500, 0);
      for (int i = 0; i < 500; ++i)
      {
         b.push_back(generate_random());
         c.push_back(generate_random());
         small.push_back(gen());
      }
   }
   double test_add()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] + c[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_subtract()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] - c[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_add_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] + 1;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_subtract_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] - 1;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_multiply()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned k = 0; k < b.size(); ++k)
            a[k] = b[k] * c[k];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_multiply_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] * 3;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_divide()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] / c[j] + b[j] / small[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_divide_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] / 3;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_str(const std::integral_constant<bool, false>&)
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < b.size(); ++i)
         a[i] = boost::lexical_cast<T>(boost::lexical_cast<std::string>(b[i]));
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_str(const std::integral_constant<bool, true>&)
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < b.size(); ++i)
         a[i].assign(b[i].str());
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_str()
   {
      return test_str(std::is_class<T>());
   }
   //
   // The following tests only work for integer types:
   //
   double test_mod()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] % c[i] + b[i] % small[i];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_mod_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] % 254;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_or()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] | c[i];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_or_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] | 234;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_and()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] & c[i];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_and_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] & 234;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_xor()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] ^ c[i];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_xor_int()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] ^ 234;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_complement()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = ~b[i];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_left_shift()
   {
      int                                             max_shift = std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : bits_wanted;
      int                                             shift     = 0;
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] << (shift++ % max_shift);
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_right_shift()
   {
      int                                             max_shift = 2 + std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : bits_wanted;
      int                                             shift     = 0;
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = b[i] >> (shift++) % max_shift;
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_gcd()
   {
      using boost::integer::gcd;
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = gcd(b[i], c[i]);
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_powm()
   {
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 25; ++i)
      {
         for (unsigned i = 0; i < b.size(); ++i)
            a[i] = powm(b[i], b[i] / 2, c[i]);
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   double test_construct()
   {
      std::allocator<T>                               alloc;
      T*                                              pt = alloc.allocate(1000);
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < 1000; ++j)
            new (pt + j) T();
         for (unsigned j = 0; j < 1000; ++j)
            std::allocator_traits<std::allocator<T> >::destroy(alloc, pt + j);
      }
      double result = boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
      alloc.deallocate(pt, 1000);
      return result;
   }
   double test_construct_unsigned()
   {
      std::allocator<T>                               alloc;
      T*                                              pt = alloc.allocate(1000);
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < 1000; ++j)
            new (pt + j) T(j);
         for (unsigned j = 0; j < 1000; ++j)
            std::allocator_traits<std::allocator<T> >::destroy(alloc, pt + j);
      }
      double result = boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
      alloc.deallocate(pt, 1000);
      return result;
   }
   double test_construct_unsigned_ll()
   {
      std::allocator<T>                               alloc;
      T*                                              pt = alloc.allocate(1000);
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned long long j = 0; j < 1000; ++j)
            new (pt + j) T(j);
         for (unsigned j = 0; j < 1000; ++j)
            std::allocator_traits<std::allocator<T>  >::destroy(alloc, pt + j);
      }
      double result = boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
      alloc.deallocate(pt, 1000);
      return result;
   }

   //
   // Hetero operations:
   //
   template <class U>
   static U get_hetero_test_value(std::integral_constant<bool, false> const&)
   {
      return U(2) / 3;
   }
   template <class U>
   static U get_hetero_test_value(std::integral_constant<bool, true> const&)
   {
      return (std::numeric_limits<U>::max)() >> 4;
   }
   template <class U>
   static U get_hetero_test_value()
   {
      return get_hetero_test_value<U>(boost::multiprecision::detail::is_integral<U>());
   }
   template <class U>
   double test_multiply_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] * vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_inplace_multiply_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j], a[j] *= vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_add_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] + vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_inplace_add_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j], a[j] += vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_subtract_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] - vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_inplace_subtract_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j], a[j] -= vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_divide_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j] / vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }
   template <class U>
   double test_inplace_divide_hetero()
   {
      const std::vector<U>&                           vals = get_hetero_test_vector<U>();
      stopwatch<boost::chrono::high_resolution_clock> w;
      for (unsigned i = 0; i < 1000; ++i)
      {
         for (unsigned j = 0; j < b.size(); ++j)
            a[j] = b[j], a[j] /= vals[j];
      }
      return boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   }

 private:
   T generate_random()
   {
      return generate_random<T>(std::integral_constant<int, Type>());
   }
   template <class U>
   U generate_random(const std::integral_constant<int, boost::multiprecision::number_kind_floating_point>&)
   {
      U val      = gen();
      U prev_val = -1;
      while (val != prev_val)
      {
         val *= (gen.max)();
         prev_val = val;
         val += gen();
      }
      int e;
      val = frexp(val, &e);

      typedef typename U::backend_type::exponent_type        e_type;
      static boost::random::uniform_int_distribution<e_type> ui(-30, 30);
      return ldexp(val, static_cast<int>(ui(gen)));
   }
   template <class U>
   U generate_random(const std::integral_constant<int, boost::multiprecision::number_kind_integer>&)
   {
      typedef boost::random::mt19937::result_type random_type;

      U        max_val;
      unsigned digits;
      if (std::numeric_limits<U>::is_bounded)
      {
         max_val = (std::numeric_limits<U>::max)();
         digits  = std::numeric_limits<U>::digits;
      }
      else
      {
         max_val = U(1) << bits_wanted;
         digits  = bits_wanted;
      }

      unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
      while ((random_type(1) << bits_per_r_val) > (gen.max)())
         --bits_per_r_val;

      unsigned terms_needed = digits / bits_per_r_val + 1;

      U val = 0;
      for (unsigned i = 0; i < terms_needed; ++i)
      {
         val *= (gen.max)();
         val += gen();
      }
      val %= max_val;
      return val;
   }
   template <class U>
   U generate_random(const std::integral_constant<int, boost::multiprecision::number_kind_rational>&)
   {
      typedef boost::random::mt19937::result_type                     random_type;
      typedef typename boost::multiprecision::component_type<U>::type IntType;

      IntType  max_val;
      unsigned digits;
      if (std::numeric_limits<IntType>::is_bounded)
      {
         max_val = (std::numeric_limits<IntType>::max)();
         digits  = std::numeric_limits<IntType>::digits;
      }
      else
      {
         max_val = IntType(1) << bits_wanted;
         digits  = bits_wanted;
      }

      unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
      while ((random_type(1) << bits_per_r_val) > (gen.max)())
         --bits_per_r_val;

      unsigned terms_needed = digits / bits_per_r_val + 1;

      IntType val   = 0;
      IntType denom = 0;
      for (unsigned i = 0; i < terms_needed; ++i)
      {
         val *= (gen.max)();
         val += gen();
      }
      for (unsigned i = 0; i < terms_needed; ++i)
      {
         denom *= (gen.max)();
         denom += gen();
      }
      if (denom == 0)
         denom = 1;
      val %= max_val;
      denom %= max_val;
      return U(val, denom);
   }

   template <class U>
   const std::vector<U>& get_hetero_test_vector()
   {
      static std::vector<U> result;
      while (result.size() < a.size())
      {
         result.push_back(generate_random<U>(std::integral_constant<int, boost::multiprecision::number_category<U>::value>()));
      }
      return result;
   }

   std::vector<T>                a, b, c, small;
   static boost::random::mt19937 gen;
};

template <class N, int V>
boost::random::mt19937 tester<N, V>::gen;

inline const char* category_name(const std::integral_constant<int, boost::multiprecision::number_kind_integer>&)
{
   return "integer";
}
inline const char* category_name(const std::integral_constant<int, boost::multiprecision::number_kind_floating_point>&)
{
   return "float";
}
inline const char* category_name(const std::integral_constant<int, boost::multiprecision::number_kind_rational>&)
{
   return "rational";
}

//
// Keys in order are:
// Category
// Operator
// Type
// Precision
// Time
//
extern std::map<std::string, std::map<std::string, std::map<std::string, std::map<int, double> > > > result_table;

inline void report_result(const char* cat, const char* type, const char* op, unsigned precision, double time)
{
   std::cout << std::left << std::setw(15) << type << std::setw(10) << precision << std::setw(35) << op << time << std::endl;
   result_table[cat][op][type][precision] = time;
}

template <class Number, int N>
void test_int_ops(tester<Number, N>& t, const char* type, unsigned precision, const std::integral_constant<int, boost::multiprecision::number_kind_integer>&)
{
   const char* cat = "integer";
   report_result(cat, type, "%", precision, t.test_mod());
   report_result(cat, type, "|", precision, t.test_or());
   report_result(cat, type, "&", precision, t.test_and());
   report_result(cat, type, "^", precision, t.test_xor());
   //report_result(cat, type, "~", precision, t.test_complement());
   report_result(cat, type, "<<", precision, t.test_left_shift());
   report_result(cat, type, ">>", precision, t.test_right_shift());
   // integer ops:
   report_result(cat, type, "%(int)", precision, t.test_mod_int());
   report_result(cat, type, "|(int)", precision, t.test_or_int());
   report_result(cat, type, "&(int)", precision, t.test_and_int());
   report_result(cat, type, "^(int)", precision, t.test_xor_int());
   report_result(cat, type, "gcd", precision, t.test_gcd());
   if(precision <= 1024)
      report_result(cat, type, "powm", precision, t.test_powm());
}
template <class Number, int N, class U>
void test_int_ops(tester<Number, N>&, const char*, unsigned, const U&)
{
}

template <class Number, int N, class U>
void test_related_ops(tester<Number, N>& t, const char* type, unsigned precision, const U&, const char* cat)
{
   report_result(cat, type, "+(value_type)", precision, t.template test_add_hetero<U>());
   report_result(cat, type, "-(value_type)", precision, t.template test_subtract_hetero<U>());
   report_result(cat, type, "*(value_type)", precision, t.template test_multiply_hetero<U>());
   report_result(cat, type, "/(value_type)", precision, t.template test_divide_hetero<U>());
   report_result(cat, type, "+=(value_type)", precision, t.template test_inplace_add_hetero<U>());
   report_result(cat, type, "-=(value_type)", precision, t.template test_inplace_subtract_hetero<U>());
   report_result(cat, type, "*=(value_type)", precision, t.template test_inplace_multiply_hetero<U>());
   report_result(cat, type, "/=(value_type)", precision, t.template test_inplace_divide_hetero<U>());
}
template <class Number, int N>
void test_related_ops(tester<Number, N>& t, const char* type, unsigned precision, const Number&, const char* cat)
{
}

template <class Number>
void test(const char* type, unsigned precision)
{
   bits_wanted = precision;
   tester<Number, boost::multiprecision::number_category<Number>::value> t;
   const char*                                                           cat = category_name(typename boost::multiprecision::number_category<Number>::type());
   //
   // call t.test_multiply() first so that the destination operands are
   // forced to perform whatever memory allocation may be needed.  That way
   // we measure only algorithm performance, and not memory allocation effects.
   //
   t.test_multiply();
   //
   // Now the actual tests:
   //
#ifndef TEST_MUL_ONLY
   report_result(cat, type, "+", precision, t.test_add());
   report_result(cat, type, "-", precision, t.test_subtract());
#endif
   report_result(cat, type, "*", precision, t.test_multiply());
#ifndef TEST_MUL_ONLY
   report_result(cat, type, "/", precision, t.test_divide());
   report_result(cat, type, "str", precision, t.test_str());
   // integer ops:
   report_result(cat, type, "+(int)", precision, t.test_add_int());
   report_result(cat, type, "-(int)", precision, t.test_subtract_int());
   report_result(cat, type, "*(int)", precision, t.test_multiply_int());
   report_result(cat, type, "/(int)", precision, t.test_divide_int());
   // construction and destruction:
   report_result(cat, type, "construct", precision, t.test_construct());
   report_result(cat, type, "construct(unsigned)", precision, t.test_construct_unsigned());
   report_result(cat, type, "construct(unsigned long long)", precision, t.test_construct_unsigned_ll());
   test_int_ops(t, type, precision, typename boost::multiprecision::number_category<Number>::type());
   test_related_ops(t, type, precision, typename Number::value_type(), cat);
   // Hetero ops:
   report_result(cat, type, "+(unsigned long long)", precision, t.template test_add_hetero<unsigned long long>());
   report_result(cat, type, "-(unsigned long long)", precision, t.template test_subtract_hetero<unsigned long long>());
   report_result(cat, type, "*(unsigned long long)", precision, t.template test_multiply_hetero<unsigned long long>());
   report_result(cat, type, "/(unsigned long long)", precision, t.template test_divide_hetero<unsigned long long>());
   report_result(cat, type, "+=(unsigned long long)", precision, t.template test_inplace_add_hetero<unsigned long long>());
   report_result(cat, type, "-=(unsigned long long)", precision, t.template test_inplace_subtract_hetero<unsigned long long>());
   report_result(cat, type, "*=(unsigned long long)", precision, t.template test_inplace_multiply_hetero<unsigned long long>());
   report_result(cat, type, "/=(unsigned long long)", precision, t.template test_inplace_divide_hetero<unsigned long long>());
#endif
}

void test01();
void test02();
void test03();
void test04();
void test05();
void test06();
void test07();
void test08();
void test09();
void test10();
void test11();
void test12();
void test13();
void test14();
void test15();
void test16();
void test17();
void test18();
void test19();
void test20();
void test21();
void test22();
void test23();
void test24();
void test25();
void test26();
void test27();
void test28();
void test29();
void test30();
void test31();
void test32();
void test33();
void test34();
void test35();
void test36();
void test37();
void test38();
void test39();
void test40();
void test41();
void test42();
void test43();
void test44();
void test45();
void test46();
void test47();
void test48();
void test49();
void test50();
void test51();



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test.log
================================================
[table:platform Platform Details
[[Platform][[[Compiler][GNU C++ version 10.3.0]]
[[GMP][6.2.0]]
[[MPFR][262146]]
[[Boost][107800]]
[[Run date][Sep 30 2021]]
]

gmp_float      50        +                                  0.0183555
gmp_float      50        -                                  0.0136532
gmp_float      50        *                                  0.02086
gmp_float      50        /                                  0.101766
gmp_float      50        str                                0.000493989
gmp_float      50        +(int)                             0.00443909
gmp_float      50        -(int)                             0.0134294
gmp_float      50        *(int)                             0.00513201
gmp_float      50        /(int)                             0.0243611
gmp_float      50        construct                          0.0232445
gmp_float      50        construct(unsigned)                0.0299395
gmp_float      50        construct(unsigned long long)      0.0258903
gmp_float      50        +(unsigned long long)              0.0051023
gmp_float      50        -(unsigned long long)              0.0113255
gmp_float      50        *(unsigned long long)              0.0128361
gmp_float      50        /(unsigned long long)              0.0179778
gmp_float      50        +=(unsigned long long)             0.0164496
gmp_float      50        -=(unsigned long long)             0.0148782
gmp_float      50        *=(unsigned long long)             0.00765054
gmp_float      50        /=(unsigned long long)             0.0195279
gmp_float      100       +                                  0.0130366
gmp_float      100       -                                  0.0192537
gmp_float      100       *                                  0.0257348
gmp_float      100       /                                  0.138938
gmp_float      100       str                                0.00109572
gmp_float      100       +(int)                             0.00626549
gmp_float      100       -(int)                             0.0119272
gmp_float      100       *(int)                             0.00558264
gmp_float      100       /(int)                             0.0220741
gmp_float      100       construct                          0.0242744
gmp_float      100       construct(unsigned)                0.0252132
gmp_float      100       construct(unsigned long long)      0.0209379
gmp_float      100       +(unsigned long long)              0.00778526
gmp_float      100       -(unsigned long long)              0.0194584
gmp_float      100       *(unsigned long long)              0.00599344
gmp_float      100       /(unsigned long long)              0.0233296
gmp_float      100       +=(unsigned long long)             0.0137783
gmp_float      100       -=(unsigned long long)             0.0221136
gmp_float      100       *=(unsigned long long)             0.00979552
gmp_float      100       /=(unsigned long long)             0.032907
gmp_float      500       +                                  0.0273382
gmp_float      500       -                                  0.0260432
gmp_float      500       *                                  0.292919
gmp_float      500       /                                  0.430233
gmp_float      500       str                                0.00345598
gmp_float      500       +(int)                             0.0120673
gmp_float      500       -(int)                             0.0272281
gmp_float      500       *(int)                             0.0211042
gmp_float      500       /(int)                             0.0784889
gmp_float      500       construct                          0.0885159
gmp_float      500       construct(unsigned)                0.0829907
gmp_float      500       construct(unsigned long long)      0.0914671
gmp_float      500       +(unsigned long long)              0.0111554
gmp_float      500       -(unsigned long long)              0.026385
gmp_float      500       *(unsigned long long)              0.0219284
gmp_float      500       /(unsigned long long)              0.0704423
gmp_float      500       +=(unsigned long long)             0.0172751
gmp_float      500       -=(unsigned long long)             0.0300017
gmp_float      500       *=(unsigned long long)             0.0296053
gmp_float      500       /=(unsigned long long)             0.076721
gmp_int        128       +                                  0.00515104
gmp_int        128       -                                  0.00664573
gmp_int        128       *                                  0.00560549
gmp_int        128       /                                  0.04667
gmp_int        128       str                                0.000178807
gmp_int        128       +(int)                             0.00347405
gmp_int        128       -(int)                             0.00363988
gmp_int        128       *(int)                             0.00473426
gmp_int        128       /(int)                             0.0115696
gmp_int        128       construct                          0.00329962
gmp_int        128       construct(unsigned)                0.0241048
gmp_int        128       construct(unsigned long long)      0.0245077
gmp_int        128       %                                  0.0466966
gmp_int        128       |                                  0.00437203
gmp_int        128       &                                  0.00394167
gmp_int        128       ^                                  0.0048846
gmp_int        128       <<                                 0.00538874
gmp_int        128       >>                                 0.00242687
gmp_int        128       %(int)                             0.0118703
gmp_int        128       |(int)                             0.010008
gmp_int        128       &(int)                             0.0148993
gmp_int        128       ^(int)                             0.0106263
gmp_int        128       gcd                                0.170154
gmp_int        128       powm                               0.0381833
gmp_int        128       +(unsigned long long)              0.00470432
gmp_int        128       -(unsigned long long)              0.00866778
gmp_int        128       *(unsigned long long)              0.00371188
gmp_int        128       /(unsigned long long)              0.00955921
gmp_int        128       +=(unsigned long long)             0.00987134
gmp_int        128       -=(unsigned long long)             0.00635455
gmp_int        128       *=(unsigned long long)             0.00560359
gmp_int        128       /=(unsigned long long)             0.0134478
gmp_int        256       +                                  0.00997612
gmp_int        256       -                                  0.0128659
gmp_int        256       *                                  0.0134261
gmp_int        256       /                                  0.0571824
gmp_int        256       str                                0.000224466
gmp_int        256       +(int)                             0.0033482
gmp_int        256       -(int)                             0.00382312
gmp_int        256       *(int)                             0.0112929
gmp_int        256       /(int)                             0.0171517
gmp_int        256       construct                          0.0037155
gmp_int        256       construct(unsigned)                0.0227529
gmp_int        256       construct(unsigned long long)      0.020762
gmp_int        256       %                                  0.0514059
gmp_int        256       |                                  0.00480677
gmp_int        256       &                                  0.00417321
gmp_int        256       ^                                  0.00693092
gmp_int        256       <<                                 0.00869801
gmp_int        256       >>                                 0.0022372
gmp_int        256       %(int)                             0.0148079
gmp_int        256       |(int)                             0.0103284
gmp_int        256       &(int)                             0.00947844
gmp_int        256       ^(int)                             0.0160125
gmp_int        256       gcd                                0.761472
gmp_int        256       powm                               0.152912
gmp_int        256       +(unsigned long long)              0.00509394
gmp_int        256       -(unsigned long long)              0.0049585
gmp_int        256       *(unsigned long long)              0.00456418
gmp_int        256       /(unsigned long long)              0.0152731
gmp_int        256       +=(unsigned long long)             0.00672804
gmp_int        256       -=(unsigned long long)             0.00828179
gmp_int        256       *=(unsigned long long)             0.00858963
gmp_int        256       /=(unsigned long long)             0.0221032
gmp_int        512       +                                  0.0130487
gmp_int        512       -                                  0.0102195
gmp_int        512       *                                  0.0300231
gmp_int        512       /                                  0.0796599
gmp_int        512       str                                0.00061628
gmp_int        512       +(int)                             0.00425087
gmp_int        512       -(int)                             0.00424793
gmp_int        512       *(int)                             0.00578859
gmp_int        512       /(int)                             0.0232057
gmp_int        512       construct                          0.00624925
gmp_int        512       construct(unsigned)                0.0183369
gmp_int        512       construct(unsigned long long)      0.0202006
gmp_int        512       %                                  0.0722958
gmp_int        512       |                                  0.00628228
gmp_int        512       &                                  0.00524347
gmp_int        512       ^                                  0.00615531
gmp_int        512       <<                                 0.00888006
gmp_int        512       >>                                 0.00238226
gmp_int        512       %(int)                             0.024264
gmp_int        512       |(int)                             0.0247852
gmp_int        512       &(int)                             0.013507
gmp_int        512       ^(int)                             0.0173321
gmp_int        512       gcd                                1.62139
gmp_int        512       powm                               0.766677
gmp_int        512       +(unsigned long long)              0.00595229
gmp_int        512       -(unsigned long long)              0.00592785
gmp_int        512       *(unsigned long long)              0.00637276
gmp_int        512       /(unsigned long long)              0.0244044
gmp_int        512       +=(unsigned long long)             0.00868995
gmp_int        512       -=(unsigned long long)             0.00847054
gmp_int        512       *=(unsigned long long)             0.00977523
gmp_int        512       /=(unsigned long long)             0.0334445
gmp_int        1024      +                                  0.00971031
gmp_int        1024      -                                  0.0105533
gmp_int        1024      *                                  0.100546
gmp_int        1024      /                                  0.0881567
gmp_int        1024      str                                0.000778966
gmp_int        1024      +(int)                             0.0064494
gmp_int        1024      -(int)                             0.00561665
gmp_int        1024      *(int)                             0.00931559
gmp_int        1024      /(int)                             0.0422461
gmp_int        1024      construct                          0.00336255
gmp_int        1024      construct(unsigned)                0.0181871
gmp_int        1024      construct(unsigned long long)      0.0188747
gmp_int        1024      %                                  0.0918952
gmp_int        1024      |                                  0.00861647
gmp_int        1024      &                                  0.00800121
gmp_int        1024      ^                                  0.00963503
gmp_int        1024      <<                                 0.0193064
gmp_int        1024      >>                                 0.00454358
gmp_int        1024      %(int)                             0.0257336
gmp_int        1024      |(int)                             0.0135159
gmp_int        1024      &(int)                             0.0102081
gmp_int        1024      ^(int)                             0.0156309
gmp_int        1024      gcd                                3.48358
gmp_int        1024      powm                               5.14976
gmp_int        1024      +(unsigned long long)              0.00802101
gmp_int        1024      -(unsigned long long)              0.00806262
gmp_int        1024      *(unsigned long long)              0.0102277
gmp_int        1024      /(unsigned long long)              0.042466
gmp_int        1024      +=(unsigned long long)             0.0154667
gmp_int        1024      -=(unsigned long long)             0.0106078
gmp_int        1024      *=(unsigned long long)             0.0134989
gmp_int        1024      /=(unsigned long long)             0.0405622
cpp_int(fixed) 128       +                                  0.000877268
cpp_int(fixed) 128       -                                  0.00192988
cpp_int(fixed) 128       *                                  0.00116759
cpp_int(fixed) 128       /                                  0.0273912
cpp_int(fixed) 128       str                                0.00084634
cpp_int(fixed) 128       +(int)                             0.000698051
cpp_int(fixed) 128       -(int)                             0.00113016
cpp_int(fixed) 128       *(int)                             0.000662467
cpp_int(fixed) 128       /(int)                             0.0147198
cpp_int(fixed) 128       construct                          0.000587582
cpp_int(fixed) 128       construct(unsigned)                0.000872038
cpp_int(fixed) 128       construct(unsigned long long)      0.000903049
cpp_int(fixed) 128       %                                  0.0318553
cpp_int(fixed) 128       |                                  0.0043918
cpp_int(fixed) 128       &                                  0.00358104
cpp_int(fixed) 128       ^                                  0.00360758
cpp_int(fixed) 128       <<                                 0.00116939
cpp_int(fixed) 128       >>                                 0.000934446
cpp_int(fixed) 128       %(int)                             0.0172916
cpp_int(fixed) 128       |(int)                             0.00380628
cpp_int(fixed) 128       &(int)                             0.0038455
cpp_int(fixed) 128       ^(int)                             0.00371059
cpp_int(fixed) 128       gcd                                0.621889
cpp_int(fixed) 128       powm                               0.35895
cpp_int(fixed) 128       +(unsigned long long)              0.000900057
cpp_int(fixed) 128       -(unsigned long long)              0.00114855
cpp_int(fixed) 128       *(unsigned long long)              0.000745744
cpp_int(fixed) 128       /(unsigned long long)              0.0169001
cpp_int(fixed) 128       +=(unsigned long long)             0.000869555
cpp_int(fixed) 128       -=(unsigned long long)             0.000954108
cpp_int(fixed) 128       *=(unsigned long long)             0.000832044
cpp_int(fixed) 128       /=(unsigned long long)             0.0226255
cpp_int(fixed) 256       +                                  0.00687102
cpp_int(fixed) 256       -                                  0.010289
cpp_int(fixed) 256       *                                  0.0237359
cpp_int(fixed) 256       /                                  0.098585
cpp_int(fixed) 256       str                                0.000401216
cpp_int(fixed) 256       +(int)                             0.00578118
cpp_int(fixed) 256       -(int)                             0.00482789
cpp_int(fixed) 256       *(int)                             0.00648519
cpp_int(fixed) 256       /(int)                             0.0744498
cpp_int(fixed) 256       construct                          0.00243004
cpp_int(fixed) 256       construct(unsigned)                0.0026667
cpp_int(fixed) 256       construct(unsigned long long)      0.00253319
cpp_int(fixed) 256       %                                  0.0663805
cpp_int(fixed) 256       |                                  0.00661838
cpp_int(fixed) 256       &                                  0.00641591
cpp_int(fixed) 256       ^                                  0.00686442
cpp_int(fixed) 256       <<                                 0.00844969
cpp_int(fixed) 256       >>                                 0.0146615
cpp_int(fixed) 256       %(int)                             0.0247468
cpp_int(fixed) 256       |(int)                             0.00552682
cpp_int(fixed) 256       &(int)                             0.00630453
cpp_int(fixed) 256       ^(int)                             0.0073244
cpp_int(fixed) 256       gcd                                1.35865
cpp_int(fixed) 256       powm                               1.53516
cpp_int(fixed) 256       +(unsigned long long)              0.00648945
cpp_int(fixed) 256       -(unsigned long long)              0.00515424
cpp_int(fixed) 256       *(unsigned long long)              0.00489332
cpp_int(fixed) 256       /(unsigned long long)              0.0548884
cpp_int(fixed) 256       +=(unsigned long long)             0.00906799
cpp_int(fixed) 256       -=(unsigned long long)             0.00513296
cpp_int(fixed) 256       *=(unsigned long long)             0.00472864
cpp_int(fixed) 256       /=(unsigned long long)             0.0691018
cpp_int(fixed) 512       +                                  0.0237507
cpp_int(fixed) 512       -                                  0.00921062
cpp_int(fixed) 512       *                                  0.047591
cpp_int(fixed) 512       /                                  0.169344
cpp_int(fixed) 512       str                                0.00103815
cpp_int(fixed) 512       +(int)                             0.00668085
cpp_int(fixed) 512       -(int)                             0.00531307
cpp_int(fixed) 512       *(int)                             0.0088359
cpp_int(fixed) 512       /(int)                             0.141253
cpp_int(fixed) 512       construct                          0.00375174
cpp_int(fixed) 512       construct(unsigned)                0.00400614
cpp_int(fixed) 512       construct(unsigned long long)      0.00399907
cpp_int(fixed) 512       %                                  0.0966394
cpp_int(fixed) 512       |                                  0.00825362
cpp_int(fixed) 512       &                                  0.0089337
cpp_int(fixed) 512       ^                                  0.00927498
cpp_int(fixed) 512       <<                                 0.0173029
cpp_int(fixed) 512       >>                                 0.0155169
cpp_int(fixed) 512       %(int)                             0.0688759
cpp_int(fixed) 512       |(int)                             0.00775532
cpp_int(fixed) 512       &(int)                             0.00845281
cpp_int(fixed) 512       ^(int)                             0.00792226
cpp_int(fixed) 512       gcd                                3.28597
cpp_int(fixed) 512       powm                               8.07714
cpp_int(fixed) 512       +(unsigned long long)              0.008261
cpp_int(fixed) 512       -(unsigned long long)              0.00726552
cpp_int(fixed) 512       *(unsigned long long)              0.00764018
cpp_int(fixed) 512       /(unsigned long long)              0.135566
cpp_int(fixed) 512       +=(unsigned long long)             0.00681593
cpp_int(fixed) 512       -=(unsigned long long)             0.00597589
cpp_int(fixed) 512       *=(unsigned long long)             0.00714494
cpp_int(fixed) 512       /=(unsigned long long)             0.133354
cpp_int(fixed) 1024      +                                  0.0184876
cpp_int(fixed) 1024      -                                  0.0162226
cpp_int(fixed) 1024      *                                  0.153461
cpp_int(fixed) 1024      /                                  0.327451
cpp_int(fixed) 1024      str                                0.00335647
cpp_int(fixed) 1024      +(int)                             0.0123052
cpp_int(fixed) 1024      -(int)                             0.0190533
cpp_int(fixed) 1024      *(int)                             0.0211192
cpp_int(fixed) 1024      /(int)                             0.277366
cpp_int(fixed) 1024      construct                          0.00893771
cpp_int(fixed) 1024      construct(unsigned)                0.00981681
cpp_int(fixed) 1024      construct(unsigned long long)      0.0096748
cpp_int(fixed) 1024      %                                  0.181883
cpp_int(fixed) 1024      |                                  0.0148123
cpp_int(fixed) 1024      &                                  0.019269
cpp_int(fixed) 1024      ^                                  0.0172541
cpp_int(fixed) 1024      <<                                 0.0299716
cpp_int(fixed) 1024      >>                                 0.0222922
cpp_int(fixed) 1024      %(int)                             0.111133
cpp_int(fixed) 1024      |(int)                             0.0122062
cpp_int(fixed) 1024      &(int)                             0.0225444
cpp_int(fixed) 1024      ^(int)                             0.0160789
cpp_int(fixed) 1024      gcd                                6.8044
cpp_int(fixed) 1024      powm                               43.7564
cpp_int(fixed) 1024      +(unsigned long long)              0.0125768
cpp_int(fixed) 1024      -(unsigned long long)              0.0126235
cpp_int(fixed) 1024      *(unsigned long long)              0.0157115
cpp_int(fixed) 1024      /(unsigned long long)              0.2702
cpp_int(fixed) 1024      +=(unsigned long long)             0.00638493
cpp_int(fixed) 1024      -=(unsigned long long)             0.00748462
cpp_int(fixed) 1024      *=(unsigned long long)             0.0134446
cpp_int(fixed) 1024      /=(unsigned long long)             0.268888
cpp_int        128       +                                  0.0086037
cpp_int        128       -                                  0.00859678
cpp_int        128       *                                  0.0145016
cpp_int        128       /                                  0.0878919
cpp_int        128       str                                0.000264092
cpp_int        128       +(int)                             0.00534018
cpp_int        128       -(int)                             0.00347144
cpp_int        128       *(int)                             0.0072726
cpp_int        128       /(int)                             0.0520677
cpp_int        128       construct                          0.00190752
cpp_int        128       construct(unsigned)                0.00174712
cpp_int        128       construct(unsigned long long)      0.00192028
cpp_int        128       %                                  0.0481508
cpp_int        128       |                                  0.00991773
cpp_int        128       &                                  0.0101034
cpp_int        128       ^                                  0.0101384
cpp_int        128       <<                                 0.0116142
cpp_int        128       >>                                 0.011709
cpp_int        128       %(int)                             0.00790481
cpp_int        128       |(int)                             0.00805945
cpp_int        128       &(int)                             0.0124861
cpp_int        128       ^(int)                             0.00991885
cpp_int        128       gcd                                0.358587
cpp_int        128       powm                               0.565871
cpp_int        128       +(unsigned long long)              0.00893714
cpp_int        128       -(unsigned long long)              0.00807189
cpp_int        128       *(unsigned long long)              0.00669928
cpp_int        128       /(unsigned long long)              0.0582351
cpp_int        128       +=(unsigned long long)             0.0106404
cpp_int        128       -=(unsigned long long)             0.0103583
cpp_int        128       *=(unsigned long long)             0.0131299
cpp_int        128       /=(unsigned long long)             0.0701172
cpp_int        256       +                                  0.0160922
cpp_int        256       -                                  0.013219
cpp_int        256       *                                  0.0246772
cpp_int        256       /                                  0.181536
cpp_int        256       str                                0.000644609
cpp_int        256       +(int)                             0.0063589
cpp_int        256       -(int)                             0.00531251
cpp_int        256       *(int)                             0.00991594
cpp_int        256       /(int)                             0.108097
cpp_int        256       construct                          0.00258002
cpp_int        256       construct(unsigned)                0.00225895
cpp_int        256       construct(unsigned long long)      0.00200418
cpp_int        256       %                                  0.0825917
cpp_int        256       |                                  0.00939722
cpp_int        256       &                                  0.0128886
cpp_int        256       ^                                  0.0282768
cpp_int        256       <<                                 0.0147029
cpp_int        256       >>                                 0.0153366
cpp_int        256       %(int)                             0.0215141
cpp_int        256       |(int)                             0.0119795
cpp_int        256       &(int)                             0.0114113
cpp_int        256       ^(int)                             0.0115174
cpp_int        256       gcd                                1.42989
cpp_int        256       powm                               2.0199
cpp_int        256       +(unsigned long long)              0.0136811
cpp_int        256       -(unsigned long long)              0.00922027
cpp_int        256       *(unsigned long long)              0.00820918
cpp_int        256       /(unsigned long long)              0.0982056
cpp_int        256       +=(unsigned long long)             0.00996803
cpp_int        256       -=(unsigned long long)             0.0102937
cpp_int        256       *=(unsigned long long)             0.00790233
cpp_int        256       /=(unsigned long long)             0.105309
cpp_int        512       +                                  0.0131305
cpp_int        512       -                                  0.0117779
cpp_int        512       *                                  0.0631704
cpp_int        512       /                                  0.250544
cpp_int        512       str                                0.00141073
cpp_int        512       +(int)                             0.00666443
cpp_int        512       -(int)                             0.00548206
cpp_int        512       *(int)                             0.0194072
cpp_int        512       /(int)                             0.193637
cpp_int        512       construct                          0.00248269
cpp_int        512       construct(unsigned)                0.00241092
cpp_int        512       construct(unsigned long long)      0.00223886
cpp_int        512       %                                  0.127209
cpp_int        512       |                                  0.012635
cpp_int        512       &                                  0.018172
cpp_int        512       ^                                  0.0139063
cpp_int        512       <<                                 0.0238748
cpp_int        512       >>                                 0.0209131
cpp_int        512       %(int)                             0.065874
cpp_int        512       |(int)                             0.012189
cpp_int        512       &(int)                             0.0179186
cpp_int        512       ^(int)                             0.0198209
cpp_int        512       gcd                                3.30534
cpp_int        512       powm                               9.06469
cpp_int        512       +(unsigned long long)              0.0102989
cpp_int        512       -(unsigned long long)              0.00830959
cpp_int        512       *(unsigned long long)              0.0119122
cpp_int        512       /(unsigned long long)              0.151642
cpp_int        512       +=(unsigned long long)             0.0108279
cpp_int        512       -=(unsigned long long)             0.0103591
cpp_int        512       *=(unsigned long long)             0.0119079
cpp_int        512       /=(unsigned long long)             0.171387
cpp_int        1024      +                                  0.0163002
cpp_int        1024      -                                  0.0151597
cpp_int        1024      *                                  0.224062
cpp_int        1024      /                                  0.365546
cpp_int        1024      str                                0.00383604
cpp_int        1024      +(int)                             0.00836612
cpp_int        1024      -(int)                             0.00759591
cpp_int        1024      *(int)                             0.0214459
cpp_int        1024      /(int)                             0.296939
cpp_int        1024      construct                          0.00191598
cpp_int        1024      construct(unsigned)                0.00177047
cpp_int        1024      construct(unsigned long long)      0.00189442
cpp_int        1024      %                                  0.171986
cpp_int        1024      |                                  0.0152013
cpp_int        1024      &                                  0.0204051
cpp_int        1024      ^                                  0.0187085
cpp_int        1024      <<                                 0.0394659
cpp_int        1024      >>                                 0.0146098
cpp_int        1024      %(int)                             0.1044
cpp_int        1024      |(int)                             0.0134288
cpp_int        1024      &(int)                             0.0262296
cpp_int        1024      ^(int)                             0.0153479
cpp_int        1024      gcd                                7.01715
cpp_int        1024      powm                               46.9932
cpp_int        1024      +(unsigned long long)              0.0115471
cpp_int        1024      -(unsigned long long)              0.00988039
cpp_int        1024      *(unsigned long long)              0.0175683
cpp_int        1024      /(unsigned long long)              0.281298
cpp_int        1024      +=(unsigned long long)             0.0131949
cpp_int        1024      -=(unsigned long long)             0.0189898
cpp_int        1024      *=(unsigned long long)             0.0203561
cpp_int        1024      /=(unsigned long long)             0.299993
cpp_rational   128       +                                  0.415006
cpp_rational   128       -                                  0.471759
cpp_rational   128       *                                  0.797425
cpp_rational   128       /                                  2.28881
cpp_rational   128       str                                0.00168424
cpp_rational   128       +(int)                             0.0177811
cpp_rational   128       -(int)                             0.0292894
cpp_rational   128       *(int)                             0.0637195
cpp_rational   128       /(int)                             0.035134
cpp_rational   128       construct                          0.0135822
cpp_rational   128       construct(unsigned)                0.00672081
cpp_rational   128       construct(unsigned long long)      0.00806026
cpp_rational   128       +(value_type)                      0.0265647
cpp_rational   128       -(value_type)                      0.0408789
cpp_rational   128       *(value_type)                      0.408791
cpp_rational   128       /(value_type)                      0.431612
cpp_rational   128       +=(value_type)                     0.0335896
cpp_rational   128       -=(value_type)                     0.0421283
cpp_rational   128       *=(value_type)                     0.40255
cpp_rational   128       /=(value_type)                     0.40369
cpp_rational   128       +(unsigned long long)              0.0177151
cpp_rational   128       -(unsigned long long)              0.0296698
cpp_rational   128       *(unsigned long long)              0.161844
cpp_rational   128       /(unsigned long long)              0.170727
cpp_rational   128       +=(unsigned long long)             0.0565983
cpp_rational   128       -=(unsigned long long)             0.0366534
cpp_rational   128       *=(unsigned long long)             0.211848
cpp_rational   128       /=(unsigned long long)             0.216252
cpp_rational   256       +                                  1.53458
cpp_rational   256       -                                  1.52484
cpp_rational   256       *                                  2.96998
cpp_rational   256       /                                  6.34454
cpp_rational   256       str                                0.0033367
cpp_rational   256       +(int)                             0.0183744
cpp_rational   256       -(int)                             0.0346718
cpp_rational   256       *(int)                             0.0917847
cpp_rational   256       /(int)                             0.0774619
cpp_rational   256       construct                          0.00935293
cpp_rational   256       construct(unsigned)                0.0064826
cpp_rational   256       construct(unsigned long long)      0.00960336
cpp_rational   256       +(value_type)                      0.0391054
cpp_rational   256       -(value_type)                      0.0467416
cpp_rational   256       *(value_type)                      0.600225
cpp_rational   256       /(value_type)                      0.596248
cpp_rational   256       +=(value_type)                     0.0422867
cpp_rational   256       -=(value_type)                     0.0490152
cpp_rational   256       *=(value_type)                     0.629302
cpp_rational   256       /=(value_type)                     0.689514
cpp_rational   256       +(unsigned long long)              0.0241089
cpp_rational   256       -(unsigned long long)              0.0496956
cpp_rational   256       *(unsigned long long)              0.240069
cpp_rational   256       /(unsigned long long)              0.216019
cpp_rational   256       +=(unsigned long long)             0.0371419
cpp_rational   256       -=(unsigned long long)             0.0439181
cpp_rational   256       *=(unsigned long long)             0.226179
cpp_rational   256       /=(unsigned long long)             0.235781
cpp_rational   512       +                                  3.41194
cpp_rational   512       -                                  3.49648
cpp_rational   512       *                                  6.73224
cpp_rational   512       /                                  13.2036
cpp_rational   512       str                                0.00662873
cpp_rational   512       +(int)                             0.020452
cpp_rational   512       -(int)                             0.035503
cpp_rational   512       *(int)                             0.118274
cpp_rational   512       /(int)                             0.104628
cpp_rational   512       construct                          0.0083784
cpp_rational   512       construct(unsigned)                0.00618635
cpp_rational   512       construct(unsigned long long)      0.00769898
cpp_rational   512       +(value_type)                      0.044067
cpp_rational   512       -(value_type)                      0.0548939
cpp_rational   512       *(value_type)                      0.803009
cpp_rational   512       /(value_type)                      0.809662
cpp_rational   512       +=(value_type)                     0.0564267
cpp_rational   512       -=(value_type)                     0.053198
cpp_rational   512       *=(value_type)                     0.8029
cpp_rational   512       /=(value_type)                     0.832288
cpp_rational   512       +(unsigned long long)              0.0297836
cpp_rational   512       -(unsigned long long)              0.0461985
cpp_rational   512       *(unsigned long long)              0.298935
cpp_rational   512       /(unsigned long long)              0.292536
cpp_rational   512       +=(unsigned long long)             0.0556987
cpp_rational   512       -=(unsigned long long)             0.0491612
cpp_rational   512       *=(unsigned long long)             0.319695
cpp_rational   512       /=(unsigned long long)             0.314161
cpp_rational   1024      +                                  8.04044
cpp_rational   1024      -                                  7.71926
cpp_rational   1024      *                                  14.4259
cpp_rational   1024      /                                  29.3236
cpp_rational   1024      str                                0.0174979
cpp_rational   1024      +(int)                             0.0449351
cpp_rational   1024      -(int)                             0.0577029
cpp_rational   1024      *(int)                             0.218283
cpp_rational   1024      /(int)                             0.207067
cpp_rational   1024      construct                          0.00962697
cpp_rational   1024      construct(unsigned)                0.00923644
cpp_rational   1024      construct(unsigned long long)      0.0176689
cpp_rational   1024      +(value_type)                      0.105801
cpp_rational   1024      -(value_type)                      0.103471
cpp_rational   1024      *(value_type)                      1.54645
cpp_rational   1024      /(value_type)                      1.38001
cpp_rational   1024      +=(value_type)                     0.0840696
cpp_rational   1024      -=(value_type)                     0.0881228
cpp_rational   1024      *=(value_type)                     1.37083
cpp_rational   1024      /=(value_type)                     1.37478
cpp_rational   1024      +(unsigned long long)              0.046594
cpp_rational   1024      -(unsigned long long)              0.0581714
cpp_rational   1024      *(unsigned long long)              0.448194
cpp_rational   1024      /(unsigned long long)              0.435259
cpp_rational   1024      +=(unsigned long long)             0.0662456
cpp_rational   1024      -=(unsigned long long)             0.071761
cpp_rational   1024      *=(unsigned long long)             0.485819
cpp_rational   1024      /=(unsigned long long)             0.460033
mpq_rational   128       +                                  0.188327
mpq_rational   128       -                                  0.198113
mpq_rational   128       *                                  0.398662
mpq_rational   128       /                                  1.12509
mpq_rational   128       str                                0.000272779
mpq_rational   128       +(int)                             0.00859669
mpq_rational   128       -(int)                             0.0119819
mpq_rational   128       *(int)                             0.0338803
mpq_rational   128       /(int)                             0.0650149
mpq_rational   128       construct                          0.0195942
mpq_rational   128       construct(unsigned)                0.0434929
mpq_rational   128       construct(unsigned long long)      0.0392716
mpq_rational   128       +(value_type)                      0.0207456
mpq_rational   128       -(value_type)                      0.0241541
mpq_rational   128       *(value_type)                      0.20698
mpq_rational   128       /(value_type)                      0.236534
mpq_rational   128       +=(value_type)                     0.0174923
mpq_rational   128       -=(value_type)                     0.023896
mpq_rational   128       *=(value_type)                     0.206213
mpq_rational   128       /=(value_type)                     0.233487
mpq_rational   128       +(unsigned long long)              0.0085503
mpq_rational   128       -(unsigned long long)              0.0101037
mpq_rational   128       *(unsigned long long)              0.100601
mpq_rational   128       /(unsigned long long)              0.129932
mpq_rational   128       +=(unsigned long long)             0.00775585
mpq_rational   128       -=(unsigned long long)             0.00991947
mpq_rational   128       *=(unsigned long long)             0.107424
mpq_rational   128       /=(unsigned long long)             0.136121
mpq_rational   256       +                                  0.776716
mpq_rational   256       -                                  0.791584
mpq_rational   256       *                                  1.50207
mpq_rational   256       /                                  2.82848
mpq_rational   256       str                                0.000434761
mpq_rational   256       +(int)                             0.0101891
mpq_rational   256       -(int)                             0.013618
mpq_rational   256       *(int)                             0.0475114
mpq_rational   256       /(int)                             0.0713565
mpq_rational   256       construct                          0.0204126
mpq_rational   256       construct(unsigned)                0.0485316
mpq_rational   256       construct(unsigned long long)      0.0568506
mpq_rational   256       +(value_type)                      0.0245401
mpq_rational   256       -(value_type)                      0.030741
mpq_rational   256       *(value_type)                      0.247956
mpq_rational   256       /(value_type)                      0.270701
mpq_rational   256       +=(value_type)                     0.0202988
mpq_rational   256       -=(value_type)                     0.0240502
mpq_rational   256       *=(value_type)                     0.241165
mpq_rational   256       /=(value_type)                     0.269395
mpq_rational   256       +(unsigned long long)              0.0104799
mpq_rational   256       -(unsigned long long)              0.0117459
mpq_rational   256       *(unsigned long long)              0.102844
mpq_rational   256       /(unsigned long long)              0.131923
mpq_rational   256       +=(unsigned long long)             0.00984535
mpq_rational   256       -=(unsigned long long)             0.0117724
mpq_rational   256       *=(unsigned long long)             0.103523
mpq_rational   256       /=(unsigned long long)             0.137652
mpq_rational   512       +                                  1.93921
mpq_rational   512       -                                  1.98459
mpq_rational   512       *                                  3.60314
mpq_rational   512       /                                  6.22726
mpq_rational   512       str                                0.00103828
mpq_rational   512       +(int)                             0.014773
mpq_rational   512       -(int)                             0.0238773
mpq_rational   512       *(int)                             0.0548556
mpq_rational   512       /(int)                             0.0961679
mpq_rational   512       construct                          0.0221797
mpq_rational   512       construct(unsigned)                0.0513108
mpq_rational   512       construct(unsigned long long)      0.0695842
mpq_rational   512       +(value_type)                      0.0348044
mpq_rational   512       -(value_type)                      0.0417365
mpq_rational   512       *(value_type)                      0.302865
mpq_rational   512       /(value_type)                      0.329335
mpq_rational   512       +=(value_type)                     0.0355556
mpq_rational   512       -=(value_type)                     0.0287769
mpq_rational   512       *=(value_type)                     0.282857
mpq_rational   512       /=(value_type)                     0.333863
mpq_rational   512       +(unsigned long long)              0.016419
mpq_rational   512       -(unsigned long long)              0.0274924
mpq_rational   512       *(unsigned long long)              0.158713
mpq_rational   512       /(unsigned long long)              0.173528
mpq_rational   512       +=(unsigned long long)             0.0204678
mpq_rational   512       -=(unsigned long long)             0.0267879
mpq_rational   512       *=(unsigned long long)             0.131194
mpq_rational   512       /=(unsigned long long)             0.176279
mpq_rational   1024      +                                  3.79923
mpq_rational   1024      -                                  3.79396
mpq_rational   1024      *                                  7.3374
mpq_rational   1024      /                                  12.4178
mpq_rational   1024      str                                0.00192772
mpq_rational   1024      +(int)                             0.024704
mpq_rational   1024      -(int)                             0.0295391
mpq_rational   1024      *(int)                             0.0900656
mpq_rational   1024      /(int)                             0.16035
mpq_rational   1024      construct                          0.0277033
mpq_rational   1024      construct(unsigned)                0.0533278
mpq_rational   1024      construct(unsigned long long)      0.0650815
mpq_rational   1024      +(value_type)                      0.0541719
mpq_rational   1024      -(value_type)                      0.0478777
mpq_rational   1024      *(value_type)                      0.332089
mpq_rational   1024      /(value_type)                      0.355055
mpq_rational   1024      +=(value_type)                     0.0453556
mpq_rational   1024      -=(value_type)                     0.041857
mpq_rational   1024      *=(value_type)                     0.31582
mpq_rational   1024      /=(value_type)                     0.391409
mpq_rational   1024      +(unsigned long long)              0.0270577
mpq_rational   1024      -(unsigned long long)              0.040243
mpq_rational   1024      *(unsigned long long)              0.16579
mpq_rational   1024      /(unsigned long long)              0.246334
mpq_rational   1024      +=(unsigned long long)             0.032877
mpq_rational   1024      -=(unsigned long long)             0.0384444
mpq_rational   1024      *=(unsigned long long)             0.179978
mpq_rational   1024      /=(unsigned long long)             0.231505
tommath_int    128       +                                  0.0119929
tommath_int    128       -                                  0.0179911
tommath_int    128       *                                  0.0198027
tommath_int    128       /                                  1.11768
tommath_int    128       str                                0.00299152
tommath_int    128       +(int)                             0.0889366
tommath_int    128       -(int)                             0.0917047
tommath_int    128       *(int)                             0.103447
tommath_int    128       /(int)                             0.69963
tommath_int    128       construct                          0.147542
tommath_int    128       construct(unsigned)                0.180915
tommath_int    128       construct(unsigned long long)      0.165695
tommath_int    128       %                                  0.874748
tommath_int    128       |                                  0.00739324
tommath_int    128       &                                  0.00780901
tommath_int    128       ^                                  0.00825059
tommath_int    128       <<                                 0.0126218
tommath_int    128       >>                                 0.0959319
tommath_int    128       %(int)                             0.545134
tommath_int    128       |(int)                             0.0839291
tommath_int    128       &(int)                             0.0965583
tommath_int    128       ^(int)                             0.0968501
tommath_int    128       gcd                                1.36458
tommath_int    128       powm                               0.421869
tommath_int    128       +(unsigned long long)              0.0907784
tommath_int    128       -(unsigned long long)              0.0828488
tommath_int    128       *(unsigned long long)              0.107341
tommath_int    128       /(unsigned long long)              0.604848
tommath_int    128       +=(unsigned long long)             0.0768906
tommath_int    128       -=(unsigned long long)             0.0847801
tommath_int    128       *=(unsigned long long)             0.0959064
tommath_int    128       /=(unsigned long long)             0.619583
tommath_int    256       +                                  0.00709542
tommath_int    256       -                                  0.011194
tommath_int    256       *                                  0.0326465
tommath_int    256       /                                  0.989116
tommath_int    256       str                                0.00597113
tommath_int    256       +(int)                             0.0832749
tommath_int    256       -(int)                             0.0820224
tommath_int    256       *(int)                             0.0942242
tommath_int    256       /(int)                             0.769191
tommath_int    256       construct                          0.154596
tommath_int    256       construct(unsigned)                0.190967
tommath_int    256       construct(unsigned long long)      0.166489
tommath_int    256       %                                  1.03711
tommath_int    256       |                                  0.00891185
tommath_int    256       &                                  0.00928657
tommath_int    256       ^                                  0.0113947
tommath_int    256       <<                                 0.0201243
tommath_int    256       >>                                 0.0951565
tommath_int    256       %(int)                             0.807325
tommath_int    256       |(int)                             0.102949
tommath_int    256       &(int)                             0.0990734
tommath_int    256       ^(int)                             0.107261
tommath_int    256       gcd                                3.38266
tommath_int    256       powm                               1.29063
tommath_int    256       +(unsigned long long)              0.0981367
tommath_int    256       -(unsigned long long)              0.0941371
tommath_int    256       *(unsigned long long)              0.109883
tommath_int    256       /(unsigned long long)              0.876321
tommath_int    256       +=(unsigned long long)             0.0951277
tommath_int    256       -=(unsigned long long)             0.0957029
tommath_int    256       *=(unsigned long long)             0.117129
tommath_int    256       /=(unsigned long long)             0.964961
tommath_int    512       +                                  0.0133422
tommath_int    512       -                                  0.017801
tommath_int    512       *                                  0.0847288
tommath_int    512       /                                  1.38686
tommath_int    512       str                                0.0190933
tommath_int    512       +(int)                             0.0870848
tommath_int    512       -(int)                             0.0820267
tommath_int    512       *(int)                             0.0973642
tommath_int    512       /(int)                             0.938285
tommath_int    512       construct                          0.13579
tommath_int    512       construct(unsigned)                0.157218
tommath_int    512       construct(unsigned long long)      0.155821
tommath_int    512       %                                  1.29969
tommath_int    512       |                                  0.0112155
tommath_int    512       &                                  0.0113032
tommath_int    512       ^                                  0.0126854
tommath_int    512       <<                                 0.0215291
tommath_int    512       >>                                 0.0932504
tommath_int    512       %(int)                             0.930702
tommath_int    512       |(int)                             0.0775007
tommath_int    512       &(int)                             0.0815778
tommath_int    512       ^(int)                             0.079649
tommath_int    512       gcd                                7.37824
tommath_int    512       powm                               3.21051
tommath_int    512       +(unsigned long long)              0.0860324
tommath_int    512       -(unsigned long long)              0.0825755
tommath_int    512       *(unsigned long long)              0.107907
tommath_int    512       /(unsigned long long)              1.07209
tommath_int    512       +=(unsigned long long)             0.0792569
tommath_int    512       -=(unsigned long long)             0.0820388
tommath_int    512       *=(unsigned long long)             0.114277
tommath_int    512       /=(unsigned long long)             1.00956
tommath_int    1024      +                                  0.0143218
tommath_int    1024      -                                  0.0192393
tommath_int    1024      *                                  0.168568
tommath_int    1024      /                                  1.84837
tommath_int    1024      str                                0.0582251
tommath_int    1024      +(int)                             0.0809152
tommath_int    1024      -(int)                             0.0915478
tommath_int    1024      *(int)                             0.110883
tommath_int    1024      /(int)                             1.48179
tommath_int    1024      construct                          0.128148
tommath_int    1024      construct(unsigned)                0.150237
tommath_int    1024      construct(unsigned long long)      0.143768
tommath_int    1024      %                                  1.75398
tommath_int    1024      |                                  0.0160686
tommath_int    1024      &                                  0.0244762
tommath_int    1024      ^                                  0.0195826
tommath_int    1024      <<                                 0.0361972
tommath_int    1024      >>                                 0.0955953
tommath_int    1024      %(int)                             1.36603
tommath_int    1024      |(int)                             0.0767652
tommath_int    1024      &(int)                             0.0869813
tommath_int    1024      ^(int)                             0.0866224
tommath_int    1024      gcd                                15.4317
tommath_int    1024      powm                               12.628
tommath_int    1024      +(unsigned long long)              0.0806864
tommath_int    1024      -(unsigned long long)              0.0801335
tommath_int    1024      *(unsigned long long)              0.118102
tommath_int    1024      /(unsigned long long)              1.69916
tommath_int    1024      +=(unsigned long long)             0.0929332
tommath_int    1024      -=(unsigned long long)             0.100611
tommath_int    1024      *=(unsigned long long)             0.152996
tommath_int    1024      /=(unsigned long long)             1.68307
cpp_dec_float  50        +                                  0.0198859
cpp_dec_float  50        -                                  0.0194363
cpp_dec_float  50        *                                  0.061884
cpp_dec_float  50        /                                  0.83092
cpp_dec_float  50        str                                0.00145276
cpp_dec_float  50        +(int)                             0.0143136
cpp_dec_float  50        -(int)                             0.0216737
cpp_dec_float  50        *(int)                             0.0630393
cpp_dec_float  50        /(int)                             0.40163
cpp_dec_float  50        construct                          0.00383901
cpp_dec_float  50        construct(unsigned)                0.00770653
cpp_dec_float  50        construct(unsigned long long)      0.00840151
cpp_dec_float  50        +(unsigned long long)              0.0231609
cpp_dec_float  50        -(unsigned long long)              0.0248419
cpp_dec_float  50        *(unsigned long long)              0.0745654
cpp_dec_float  50        /(unsigned long long)              0.396014
cpp_dec_float  50        +=(unsigned long long)             0.017568
cpp_dec_float  50        -=(unsigned long long)             0.0249846
cpp_dec_float  50        *=(unsigned long long)             0.0706828
cpp_dec_float  50        /=(unsigned long long)             0.408938
cpp_dec_float  100       +                                  0.0216812
cpp_dec_float  100       -                                  0.0313385
cpp_dec_float  100       *                                  0.130292
cpp_dec_float  100       /                                  1.73437
cpp_dec_float  100       str                                0.00180621
cpp_dec_float  100       +(int)                             0.0169356
cpp_dec_float  100       -(int)                             0.0263524
cpp_dec_float  100       *(int)                             0.125171
cpp_dec_float  100       /(int)                             0.861622
cpp_dec_float  100       construct                          0.00443324
cpp_dec_float  100       construct(unsigned)                0.00867913
cpp_dec_float  100       construct(unsigned long long)      0.00854971
cpp_dec_float  100       +(unsigned long long)              0.0292658
cpp_dec_float  100       -(unsigned long long)              0.0287785
cpp_dec_float  100       *(unsigned long long)              0.147631
cpp_dec_float  100       /(unsigned long long)              0.991001
cpp_dec_float  100       +=(unsigned long long)             0.0236933
cpp_dec_float  100       -=(unsigned long long)             0.0396995
cpp_dec_float  100       *=(unsigned long long)             0.172634
cpp_dec_float  100       /=(unsigned long long)             1.27727
cpp_dec_float  500       +                                  0.207727
cpp_dec_float  500       -                                  0.21259
cpp_dec_float  500       *                                  1.6902
cpp_dec_float  500       /                                  22.744
cpp_dec_float  500       str                                0.0109211
cpp_dec_float  500       +(int)                             0.151114
cpp_dec_float  500       -(int)                             0.14371
cpp_dec_float  500       *(int)                             2.44271
cpp_dec_float  500       /(int)                             12.8722
cpp_dec_float  500       construct                          0.0256013
cpp_dec_float  500       construct(unsigned)                0.0455813
cpp_dec_float  500       construct(unsigned long long)      0.0429815
cpp_dec_float  500       +(unsigned long long)              0.148942
cpp_dec_float  500       -(unsigned long long)              0.150724
cpp_dec_float  500       *(unsigned long long)              2.68446
cpp_dec_float  500       /(unsigned long long)              14.1836
cpp_dec_float  500       +=(unsigned long long)             0.186187
cpp_dec_float  500       -=(unsigned long long)             0.199025
cpp_dec_float  500       *=(unsigned long long)             2.40228
cpp_dec_float  500       /=(unsigned long long)             10.9233
cpp_bin_float  50        +                                  0.0479759
cpp_bin_float  50        -                                  0.0688937
cpp_bin_float  50        *                                  0.0720574
cpp_bin_float  50        /                                  0.549759
cpp_bin_float  50        str                                0.00301165
cpp_bin_float  50        +(int)                             0.0524679
cpp_bin_float  50        -(int)                             0.0848243
cpp_bin_float  50        *(int)                             0.0399504
cpp_bin_float  50        /(int)                             0.141651
cpp_bin_float  50        construct                          0.0030982
cpp_bin_float  50        construct(unsigned)                0.00808983
cpp_bin_float  50        construct(unsigned long long)      0.0175206
cpp_bin_float  50        +(unsigned long long)              0.109321
cpp_bin_float  50        -(unsigned long long)              0.102878
cpp_bin_float  50        *(unsigned long long)              0.0508387
cpp_bin_float  50        /(unsigned long long)              0.19558
cpp_bin_float  50        +=(unsigned long long)             0.109847
cpp_bin_float  50        -=(unsigned long long)             0.129938
cpp_bin_float  50        *=(unsigned long long)             0.0500366
cpp_bin_float  50        /=(unsigned long long)             0.215322
cpp_bin_float  100       +                                  0.0901201
cpp_bin_float  100       -                                  0.0896788
cpp_bin_float  100       *                                  0.111688
cpp_bin_float  100       /                                  1.39191
cpp_bin_float  100       str                                0.0051705
cpp_bin_float  100       +(int)                             0.0871804
cpp_bin_float  100       -(int)                             0.084402
cpp_bin_float  100       *(int)                             0.0464923
cpp_bin_float  100       /(int)                             0.271491
cpp_bin_float  100       construct                          0.00608929
cpp_bin_float  100       construct(unsigned)                0.0120486
cpp_bin_float  100       construct(unsigned long long)      0.0267453
cpp_bin_float  100       +(unsigned long long)              0.128103
cpp_bin_float  100       -(unsigned long long)              0.0883961
cpp_bin_float  100       *(unsigned long long)              0.0540758
cpp_bin_float  100       /(unsigned long long)              0.244599
cpp_bin_float  100       +=(unsigned long long)             0.0942496
cpp_bin_float  100       -=(unsigned long long)             0.101449
cpp_bin_float  100       *=(unsigned long long)             0.0547429
cpp_bin_float  100       /=(unsigned long long)             0.256093
cpp_bin_float  500       +                                  0.219881
cpp_bin_float  500       -                                  0.196627
cpp_bin_float  500       *                                  0.850904
cpp_bin_float  500       /                                  5.32129
cpp_bin_float  500       str                                0.043165
cpp_bin_float  500       +(int)                             0.165014
cpp_bin_float  500       -(int)                             0.181209
cpp_bin_float  500       *(int)                             0.12206
cpp_bin_float  500       /(int)                             0.643802
cpp_bin_float  500       construct                          0.0152335
cpp_bin_float  500       construct(unsigned)                0.0530205
cpp_bin_float  500       construct(unsigned long long)      0.0570308
cpp_bin_float  500       +(unsigned long long)              0.16427
cpp_bin_float  500       -(unsigned long long)              0.185162
cpp_bin_float  500       *(unsigned long long)              0.0843974
cpp_bin_float  500       /(unsigned long long)              0.621615
cpp_bin_float  500       +=(unsigned long long)             0.157162
cpp_bin_float  500       -=(unsigned long long)             0.163157
cpp_bin_float  500       *=(unsigned long long)             0.0987612
cpp_bin_float  500       /=(unsigned long long)             0.638041
mpfr_float     50        +                                  0.0106639
mpfr_float     50        -                                  0.0274747
mpfr_float     50        *                                  0.026548
mpfr_float     50        /                                  0.239385
mpfr_float     50        str                                0.000800609
mpfr_float     50        +(int)                             0.029943
mpfr_float     50        -(int)                             0.0662094
mpfr_float     50        *(int)                             0.022273
mpfr_float     50        /(int)                             0.0362858
mpfr_float     50        construct                          0.04809
mpfr_float     50        construct(unsigned)                0.0751445
mpfr_float     50        construct(unsigned long long)      0.0787188
mpfr_float     50        +(unsigned long long)              0.0240813
mpfr_float     50        -(unsigned long long)              0.0438217
mpfr_float     50        *(unsigned long long)              0.0207341
mpfr_float     50        /(unsigned long long)              0.0603899
mpfr_float     50        +=(unsigned long long)             0.0528778
mpfr_float     50        -=(unsigned long long)             0.0613088
mpfr_float     50        *=(unsigned long long)             0.0350654
mpfr_float     50        /=(unsigned long long)             0.0458197
mpfr_float     50        +                                  0.0183477
mpfr_float     50        -                                  0.0241287
mpfr_float     50        *                                  0.0161758
mpfr_float     50        /                                  0.169939
mpfr_float     50        str                                0.00227407
mpfr_float     50        +(int)                             0.0256829
mpfr_float     50        -(int)                             0.0692297
mpfr_float     50        *(int)                             0.0336498
mpfr_float     50        /(int)                             0.0549347
mpfr_float     50        construct                          0.0773304
mpfr_float     50        construct(unsigned)                0.102564
mpfr_float     50        construct(unsigned long long)      0.08974
mpfr_float     50        +(unsigned long long)              0.0261189
mpfr_float     50        -(unsigned long long)              0.0606961
mpfr_float     50        *(unsigned long long)              0.0276134
mpfr_float     50        /(unsigned long long)              0.0520857
mpfr_float     50        +=(unsigned long long)             0.0571878
mpfr_float     50        -=(unsigned long long)             0.0589902
mpfr_float     50        *=(unsigned long long)             0.0229147
mpfr_float     50        /=(unsigned long long)             0.0523141
mpfr_float     100       +                                  0.0190178
mpfr_float     100       -                                  0.0395976
mpfr_float     100       *                                  0.0661794
mpfr_float     100       /                                  0.300455
mpfr_float     100       str                                0.00132816
mpfr_float     100       +(int)                             0.0300081
mpfr_float     100       -(int)                             0.0654074
mpfr_float     100       *(int)                             0.0339721
mpfr_float     100       /(int)                             0.0592293
mpfr_float     100       construct                          0.0866815
mpfr_float     100       construct(unsigned)                0.0730204
mpfr_float     100       construct(unsigned long long)      0.0720298
mpfr_float     100       +(unsigned long long)              0.0290995
mpfr_float     100       -(unsigned long long)              0.056868
mpfr_float     100       *(unsigned long long)              0.0276341
mpfr_float     100       /(unsigned long long)              0.0628383
mpfr_float     100       +=(unsigned long long)             0.0502709
mpfr_float     100       -=(unsigned long long)             0.0731736
mpfr_float     100       *=(unsigned long long)             0.0348128
mpfr_float     100       /=(unsigned long long)             0.071302
mpfr_float     500       +                                  0.0609463
mpfr_float     500       -                                  0.0646638
mpfr_float     500       *                                  0.321884
mpfr_float     500       /                                  1.2162
mpfr_float     500       str                                0.0048926
mpfr_float     500       +(int)                             0.062913
mpfr_float     500       -(int)                             0.0711089
mpfr_float     500       *(int)                             0.0792629
mpfr_float     500       /(int)                             0.126251
mpfr_float     500       construct                          0.0762248
mpfr_float     500       construct(unsigned)                0.0813206
mpfr_float     500       construct(unsigned long long)      0.0785786
mpfr_float     500       +(unsigned long long)              0.0616622
mpfr_float     500       -(unsigned long long)              0.0905736
mpfr_float     500       *(unsigned long long)              0.0506668
mpfr_float     500       /(unsigned long long)              0.117803
mpfr_float     500       +=(unsigned long long)             0.0787754
mpfr_float     500       -=(unsigned long long)             0.105476
mpfr_float     500       *=(unsigned long long)             0.0716736
mpfr_float     500       /=(unsigned long long)             0.122477
gmp_int        2048      +                                  0.0179704
gmp_int        2048      -                                  0.017975
gmp_int        2048      *                                  0.361988
gmp_int        2048      /                                  0.149182
gmp_int        2048      str                                0.00244981
gmp_int        2048      +(int)                             0.0118266
gmp_int        2048      -(int)                             0.0117639
gmp_int        2048      *(int)                             0.0241013
gmp_int        2048      /(int)                             0.0972941
gmp_int        2048      construct                          0.00384029
gmp_int        2048      construct(unsigned)                0.0286091
gmp_int        2048      construct(unsigned long long)      0.0290565
gmp_int        2048      %                                  0.142738
gmp_int        2048      |                                  0.0152602
gmp_int        2048      &                                  0.015523
gmp_int        2048      ^                                  0.0244266
gmp_int        2048      <<                                 0.039948
gmp_int        2048      >>                                 0.00453774
gmp_int        2048      %(int)                             0.0436939
gmp_int        2048      |(int)                             0.0277685
gmp_int        2048      &(int)                             0.0176239
gmp_int        2048      ^(int)                             0.0298873
gmp_int        2048      gcd                                8.18516
gmp_int        2048      +(unsigned long long)              0.0161988
gmp_int        2048      -(unsigned long long)              0.0184622
gmp_int        2048      *(unsigned long long)              0.0209189
gmp_int        2048      /(unsigned long long)              0.0759658
gmp_int        2048      +=(unsigned long long)             0.0160693
gmp_int        2048      -=(unsigned long long)             0.0219074
gmp_int        2048      *=(unsigned long long)             0.0301309
gmp_int        2048      /=(unsigned long long)             0.0919138
gmp_int        4096      +                                  0.0300729
gmp_int        4096      -                                  0.0321962
gmp_int        4096      *                                  1.11701
gmp_int        4096      /                                  0.208719
gmp_int        4096      str                                0.00486654
gmp_int        4096      +(int)                             0.0195694
gmp_int        4096      -(int)                             0.0225873
gmp_int        4096      *(int)                             0.0477494
gmp_int        4096      /(int)                             0.156597
gmp_int        4096      construct                          0.00385483
gmp_int        4096      construct(unsigned)                0.0220052
gmp_int        4096      construct(unsigned long long)      0.0244927
gmp_int        4096      %                                  0.24073
gmp_int        4096      |                                  0.0365187
gmp_int        4096      &                                  0.0384586
gmp_int        4096      ^                                  0.0429561
gmp_int        4096      <<                                 0.0597248
gmp_int        4096      >>                                 0.00313265
gmp_int        4096      %(int)                             0.0571251
gmp_int        4096      |(int)                             0.0360071
gmp_int        4096      &(int)                             0.0121449
gmp_int        4096      ^(int)                             0.0406408
gmp_int        4096      gcd                                18.7879
gmp_int        4096      +(unsigned long long)              0.0174726
gmp_int        4096      -(unsigned long long)              0.0220616
gmp_int        4096      *(unsigned long long)              0.0321931
gmp_int        4096      /(unsigned long long)              0.125208
gmp_int        4096      +=(unsigned long long)             0.0221405
gmp_int        4096      -=(unsigned long long)             0.0250737
gmp_int        4096      *=(unsigned long long)             0.0457849
gmp_int        4096      /=(unsigned long long)             0.14699
cpp_int        2688      +                                  0.0336398
cpp_int        2688      -                                  0.037733
cpp_int        2688      *                                  1.31825
cpp_int        2688      /                                  1.00586
cpp_int        2688      str                                0.0237422
cpp_int        2688      +(int)                             0.024805
cpp_int        2688      -(int)                             0.032706
cpp_int        2688      *(int)                             0.0426049
cpp_int        2688      /(int)                             0.859876
cpp_int        2688      construct                          0.00240729
cpp_int        2688      construct(unsigned)                0.00241711
cpp_int        2688      construct(unsigned long long)      0.00288069
cpp_int        2688      %                                  0.398213
cpp_int        2688      |                                  0.0334167
cpp_int        2688      &                                  0.0366949
cpp_int        2688      ^                                  0.0475314
cpp_int        2688      <<                                 0.0753453
cpp_int        2688      >>                                 0.0183679
cpp_int        2688      %(int)                             0.301827
cpp_int        2688      |(int)                             0.0214828
cpp_int        2688      &(int)                             0.0612567
cpp_int        2688      ^(int)                             0.0206665
cpp_int        2688      gcd                                21.9738
cpp_int        2688      +(unsigned long long)              0.0294774
cpp_int        2688      -(unsigned long long)              0.0222548
cpp_int        2688      *(unsigned long long)              0.052584
cpp_int        2688      /(unsigned long long)              0.832241
cpp_int        2688      +=(unsigned long long)             0.0201879
cpp_int        2688      -=(unsigned long long)             0.0277295
cpp_int        2688      *=(unsigned long long)             0.0527845
cpp_int        2688      /=(unsigned long long)             0.873081
cpp_int        2048      +                                  0.033949
cpp_int        2048      -                                  0.0507822
cpp_int        2048      *                                  0.918685
cpp_int        2048      /                                  0.702366
cpp_int        2048      str                                0.0137593
cpp_int        2048      +(int)                             0.0204874
cpp_int        2048      -(int)                             0.0176467
cpp_int        2048      *(int)                             0.047049
cpp_int        2048      /(int)                             0.630264
cpp_int        2048      construct                          0.00273948
cpp_int        2048      construct(unsigned)                0.00304865
cpp_int        2048      construct(unsigned long long)      0.00190833
cpp_int        2048      %                                  0.368469
cpp_int        2048      |                                  0.0293243
cpp_int        2048      &                                  0.0461406
cpp_int        2048      ^                                  0.0405646
cpp_int        2048      <<                                 0.0859331
cpp_int        2048      >>                                 0.0183489
cpp_int        2048      %(int)                             0.288068
cpp_int        2048      |(int)                             0.0309032
cpp_int        2048      &(int)                             0.063826
cpp_int        2048      ^(int)                             0.0264078
cpp_int        2048      gcd                                17.7583
cpp_int        2048      +(unsigned long long)              0.0237404
cpp_int        2048      -(unsigned long long)              0.0235442
cpp_int        2048      *(unsigned long long)              0.0539343
cpp_int        2048      /(unsigned long long)              0.706562
cpp_int        2048      +=(unsigned long long)             0.0186902
cpp_int        2048      -=(unsigned long long)             0.0265754
cpp_int        2048      *=(unsigned long long)             0.0373067
cpp_int        2048      /=(unsigned long long)             0.632889
tommath_int    2048      +                                  0.0211244
tommath_int    2048      -                                  0.0279804
tommath_int    2048      *                                  0.460786
tommath_int    2048      /                                  3.07934
tommath_int    2048      str                                0.202054
tommath_int    2048      +(int)                             0.083639
tommath_int    2048      -(int)                             0.0851246
tommath_int    2048      *(int)                             0.135402
tommath_int    2048      /(int)                             2.60921
tommath_int    2048      construct                          0.130974
tommath_int    2048      construct(unsigned)                0.143494
tommath_int    2048      construct(unsigned long long)      0.163349
tommath_int    2048      %                                  3.33706
tommath_int    2048      |                                  0.0267336
tommath_int    2048      &                                  0.0364387
tommath_int    2048      ^                                  0.0346198
tommath_int    2048      <<                                 0.0693055
tommath_int    2048      >>                                 0.134364
tommath_int    2048      %(int)                             2.60834
tommath_int    2048      |(int)                             0.0913086
tommath_int    2048      &(int)                             0.101302
tommath_int    2048      ^(int)                             0.102478
tommath_int    2048      gcd                                42.8729
tommath_int    2048      +(unsigned long long)              0.0926177
tommath_int    2048      -(unsigned long long)              0.100113
tommath_int    2048      *(unsigned long long)              0.169084
tommath_int    2048      /(unsigned long long)              3.12331
tommath_int    2048      +=(unsigned long long)             0.110375
tommath_int    2048      -=(unsigned long long)             0.105886
tommath_int    2048      *=(unsigned long long)             0.171704
tommath_int    2048      /=(unsigned long long)             3.0036
tommath_int    4096      +                                  0.0326177
tommath_int    4096      -                                  0.0532653
tommath_int    4096      *                                  1.58255
tommath_int    4096      /                                  6.59216
tommath_int    4096      str                                0.754295
tommath_int    4096      +(int)                             0.0938225
tommath_int    4096      -(int)                             0.101291
tommath_int    4096      *(int)                             0.196512
tommath_int    4096      /(int)                             5.83504
tommath_int    4096      construct                          0.13198
tommath_int    4096      construct(unsigned)                0.143689
tommath_int    4096      construct(unsigned long long)      0.146389
tommath_int    4096      %                                  6.41658
tommath_int    4096      |                                  0.0481236
tommath_int    4096      &                                  0.0552444
tommath_int    4096      ^                                  0.0568037
tommath_int    4096      <<                                 0.115375
tommath_int    4096      >>                                 0.196446
tommath_int    4096      %(int)                             5.91797
tommath_int    4096      |(int)                             0.109494
tommath_int    4096      &(int)                             0.128712
tommath_int    4096      ^(int)                             0.131519
tommath_int    4096      gcd                                136.362
tommath_int    4096      +(unsigned long long)              0.108939
tommath_int    4096      -(unsigned long long)              0.101139
tommath_int    4096      *(unsigned long long)              0.220461
tommath_int    4096      /(unsigned long long)              7.25882
tommath_int    4096      +=(unsigned long long)             0.11456
tommath_int    4096      -=(unsigned long long)             0.117418
tommath_int    4096      *=(unsigned long long)             0.250847
tommath_int    4096      /=(unsigned long long)             7.09868
cpp_int        4096      +                                  0.0412289
cpp_int        4096      -                                  0.0463464
cpp_int        4096      *                                  2.65154
cpp_int        4096      /                                  1.18106
cpp_int        4096      str                                0.0491109
cpp_int        4096      +(int)                             0.0198385
cpp_int        4096      -(int)                             0.0209158
cpp_int        4096      *(int)                             0.0576663
cpp_int        4096      /(int)                             1.08346
cpp_int        4096      construct                          0.0017072
cpp_int        4096      construct(unsigned)                0.0018378
cpp_int        4096      construct(unsigned long long)      0.00199036
cpp_int        4096      %                                  0.512768
cpp_int        4096      |                                  0.0377549
cpp_int        4096      &                                  0.0440714
cpp_int        4096      ^                                  0.0369865
cpp_int        4096      <<                                 0.0889652
cpp_int        4096      >>                                 0.0219967
cpp_int        4096      %(int)                             0.429244
cpp_int        4096      |(int)                             0.0232284
cpp_int        4096      &(int)                             0.0593859
cpp_int        4096      ^(int)                             0.0235546
cpp_int        4096      gcd                                32.2572
cpp_int        4096      +(unsigned long long)              0.0253811
cpp_int        4096      -(unsigned long long)              0.0242017
cpp_int        4096      *(unsigned long long)              0.0432066
cpp_int        4096      /(unsigned long long)              1.0584
cpp_int        4096      +=(unsigned long long)             0.0218483
cpp_int        4096      -=(unsigned long long)             0.0249248
cpp_int        4096      *=(unsigned long long)             0.0424701
cpp_int        4096      /=(unsigned long long)             1.05399
cpp_int        8192      +                                  0.083134
cpp_int        8192      -                                  0.0813138
cpp_int        8192      *                                  7.83314
cpp_int        8192      /                                  2.26453
cpp_int        8192      str                                0.171316
cpp_int        8192      +(int)                             0.0338486
cpp_int        8192      -(int)                             0.0402632
cpp_int        8192      *(int)                             0.0955853
cpp_int        8192      /(int)                             2.33772
cpp_int        8192      construct                          0.00191549
cpp_int        8192      construct(unsigned)                0.0017583
cpp_int        8192      construct(unsigned long long)      0.00200998
cpp_int        8192      %                                  1.03083
cpp_int        8192      |                                  0.0916779
cpp_int        8192      &                                  0.0811524
cpp_int        8192      ^                                  0.0918676
cpp_int        8192      <<                                 0.190562
cpp_int        8192      >>                                 0.0537598
cpp_int        8192      %(int)                             0.851447
cpp_int        8192      |(int)                             0.042441
cpp_int        8192      &(int)                             0.102968
cpp_int        8192      ^(int)                             0.0392727
cpp_int        8192      gcd                                76.6459
cpp_int        8192      +(unsigned long long)              0.0350422
cpp_int        8192      -(unsigned long long)              0.0317445
cpp_int        8192      *(unsigned long long)              0.0813634
cpp_int        8192      /(unsigned long long)              2.14867
cpp_int        8192      +=(unsigned long long)             0.0394761
cpp_int        8192      -=(unsigned long long)             0.0377524
cpp_int        8192      *=(unsigned long long)             0.0946934
cpp_int        8192      /=(unsigned long long)             2.14442
cpp_int        16384     +                                  0.190174
cpp_int        16384     -                                  0.191562
cpp_int        16384     *                                  26.1836
cpp_int        16384     /                                  4.52755
cpp_int        16384     str                                0.595522
cpp_int        16384     +(int)                             0.0760202
cpp_int        16384     -(int)                             0.0674681
cpp_int        16384     *(int)                             0.167493
cpp_int        16384     /(int)                             4.22641
cpp_int        16384     construct                          0.0016635
cpp_int        16384     construct(unsigned)                0.00197229
cpp_int        16384     construct(unsigned long long)      0.00168004
cpp_int        16384     %                                  1.96988
cpp_int        16384     |                                  0.152323
cpp_int        16384     &                                  0.146531
cpp_int        16384     ^                                  0.150955
cpp_int        16384     <<                                 0.32803
cpp_int        16384     >>                                 0.0745484
cpp_int        16384     %(int)                             1.57951
cpp_int        16384     |(int)                             0.0711061
cpp_int        16384     &(int)                             0.168385
cpp_int        16384     ^(int)                             0.0657809
cpp_int        16384     gcd                                201.791
cpp_int        16384     +(unsigned long long)              0.0761856
cpp_int        16384     -(unsigned long long)              0.0783054
cpp_int        16384     *(unsigned long long)              0.159452
cpp_int        16384     /(unsigned long long)              4.2547
cpp_int        16384     +=(unsigned long long)             0.0783171
cpp_int        16384     -=(unsigned long long)             0.070851
cpp_int        16384     *=(unsigned long long)             0.177219
cpp_int        16384     /=(unsigned long long)             4.37618
tommath_int    8192      +                                  0.060658
tommath_int    8192      -                                  0.0884881
tommath_int    8192      *                                  7.13744
tommath_int    8192      /                                  17.0525
tommath_int    8192      str                                2.82013
tommath_int    8192      +(int)                             0.11778
tommath_int    8192      -(int)                             0.115431
tommath_int    8192      *(int)                             0.30587
tommath_int    8192      /(int)                             15.4756
tommath_int    8192      construct                          0.126578
tommath_int    8192      construct(unsigned)                0.144368
tommath_int    8192      construct(unsigned long long)      0.139445
tommath_int    8192      %                                  17.1548
tommath_int    8192      |                                  0.0880424
tommath_int    8192      &                                  0.10108
tommath_int    8192      ^                                  0.0996668
tommath_int    8192      <<                                 0.222116
tommath_int    8192      >>                                 0.358689
tommath_int    8192      %(int)                             16.0225
tommath_int    8192      |(int)                             0.150489
tommath_int    8192      &(int)                             0.18102
tommath_int    8192      ^(int)                             0.190136
tommath_int    8192      gcd                                471.81
tommath_int    8192      +(unsigned long long)              0.117648
tommath_int    8192      -(unsigned long long)              0.118991
tommath_int    8192      *(unsigned long long)              0.361697
tommath_int    8192      /(unsigned long long)              19.8407
tommath_int    8192      +=(unsigned long long)             0.159384
tommath_int    8192      -=(unsigned long long)             0.189292
tommath_int    8192      *=(unsigned long long)             0.453899
tommath_int    8192      /=(unsigned long long)             20.7357
tommath_int    16384     +                                  0.229295
tommath_int    16384     -                                  0.358805
tommath_int    16384     *                                  25.8824
tommath_int    16384     /                                  51.7759
tommath_int    16384     str                                11.1251
tommath_int    16384     +(int)                             0.176275
tommath_int    16384     -(int)                             0.179066
tommath_int    16384     *(int)                             0.548109
tommath_int    16384     /(int)                             50.0929
tommath_int    16384     construct                          0.160796
tommath_int    16384     construct(unsigned)                0.182018
tommath_int    16384     construct(unsigned long long)      0.191943
tommath_int    16384     %                                  51.233
tommath_int    16384     |                                  0.213797
tommath_int    16384     &                                  0.245997
tommath_int    16384     ^                                  0.234837
tommath_int    16384     <<                                 0.538044
tommath_int    16384     >>                                 0.899272
tommath_int    16384     %(int)                             54.083
tommath_int    16384     |(int)                             0.205729
tommath_int    16384     &(int)                             0.276527
tommath_int    16384     ^(int)                             0.314742
tommath_int    16384     gcd                                1770.72
tommath_int    16384     +(unsigned long long)              0.175822
tommath_int    16384     -(unsigned long long)              0.175887
tommath_int    16384     *(unsigned long long)              0.667264
tommath_int    16384     /(unsigned long long)              57.2509
tommath_int    16384     +=(unsigned long long)             0.226317
tommath_int    16384     -=(unsigned long long)             0.2213
tommath_int    16384     *=(unsigned long long)             0.690731
tommath_int    16384     /=(unsigned long long)             67.9296
gmp_int        8192      +                                  0.0811195
gmp_int        8192      -                                  0.11812
gmp_int        8192      *                                  5.52441
gmp_int        8192      /                                  0.516606
gmp_int        8192      str                                0.0262254
gmp_int        8192      +(int)                             0.0700979
gmp_int        8192      -(int)                             0.0576919
gmp_int        8192      *(int)                             0.113505
gmp_int        8192      /(int)                             0.410334
gmp_int        8192      construct                          0.0081635
gmp_int        8192      construct(unsigned)                0.0635939
gmp_int        8192      construct(unsigned long long)      0.0709692
gmp_int        8192      %                                  0.603534
gmp_int        8192      |                                  0.0920584
gmp_int        8192      &                                  0.0887291
gmp_int        8192      ^                                  0.0805332
gmp_int        8192      <<                                 0.146992
gmp_int        8192      >>                                 0.00722919
gmp_int        8192      %(int)                             0.119886
gmp_int        8192      |(int)                             0.0874534
gmp_int        8192      &(int)                             0.0150182
gmp_int        8192      ^(int)                             0.0788165
gmp_int        8192      gcd                                58.8129
gmp_int        8192      +(unsigned long long)              0.0466003
gmp_int        8192      -(unsigned long long)              0.0435595
gmp_int        8192      *(unsigned long long)              0.0886586
gmp_int        8192      /(unsigned long long)              0.288938
gmp_int        8192      +=(unsigned long long)             0.0570676
gmp_int        8192      -=(unsigned long long)             0.05295
gmp_int        8192      *=(unsigned long long)             0.108914
gmp_int        8192      /=(unsigned long long)             0.319457
gmp_int        16384     +                                  0.134715
gmp_int        16384     -                                  0.14931
gmp_int        16384     *                                  11.3398
gmp_int        16384     /                                  0.638503
gmp_int        16384     str                                0.0398493
gmp_int        16384     +(int)                             0.0772241
gmp_int        16384     -(int)                             0.0818204
gmp_int        16384     *(int)                             0.137745
gmp_int        16384     /(int)                             0.595404
gmp_int        16384     construct                          0.00397999
gmp_int        16384     construct(unsigned)                0.0276289
gmp_int        16384     construct(unsigned long long)      0.0219346
gmp_int        16384     %                                  0.723753
gmp_int        16384     |                                  0.111118
gmp_int        16384     &                                  0.112421
gmp_int        16384     ^                                  0.124214
gmp_int        16384     <<                                 0.206887
gmp_int        16384     >>                                 0.00655899
gmp_int        16384     %(int)                             0.137682
gmp_int        16384     |(int)                             0.115602
gmp_int        16384     &(int)                             0.0212413
gmp_int        16384     ^(int)                             0.139399
gmp_int        16384     gcd                                122.14
gmp_int        16384     +(unsigned long long)              0.0668364
gmp_int        16384     -(unsigned long long)              0.0661641
gmp_int        16384     *(unsigned long long)              0.12958
gmp_int        16384     /(unsigned long long)              0.523737
gmp_int        16384     +=(unsigned long long)             0.0841208
gmp_int        16384     -=(unsigned long long)             0.0947863
gmp_int        16384     *=(unsigned long long)             0.208689
gmp_int        16384     /=(unsigned long long)             0.607595
[section:float_performance Float Type Perfomance]
[table Operator *
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][4.45465 (0.0720574s)][4.33995 (0.111688s)][2.90491 (0.850904s)]]
[[cpp_dec_float][3.82572 (0.061884s)][5.06288 (0.130292s)][5.77019 (1.6902s)]]
[[gmp_float][1.28958 (0.02086s)][[*1] (0.0257348s)][[*1] (0.292919s)]]
[[mpfr_float][[*1] (0.0161758s)][2.57159 (0.0661794s)][1.09888 (0.321884s)]]
]
[table Operator *(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][7.78457 (0.0399504s)][8.32801 (0.0464923s)][5.78369 (0.12206s)]]
[[cpp_dec_float][12.2836 (0.0630393s)][22.4215 (0.125171s)][115.745 (2.44271s)]]
[[gmp_float][[*1] (0.00513201s)][[*1] (0.00558264s)][[*1] (0.0211042s)]]
[[mpfr_float][6.55686 (0.0336498s)][6.08531 (0.0339721s)][3.75579 (0.0792629s)]]
]
[table Operator *(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][3.96061 (0.0508387s)][9.0225 (0.0540758s)][3.84877 (0.0843974s)]]
[[cpp_dec_float][5.80905 (0.0745654s)][24.6321 (0.147631s)][122.419 (2.68446s)]]
[[gmp_float][[*1] (0.0128361s)][[*1] (0.00599344s)][[*1] (0.0219284s)]]
[[mpfr_float][2.15124 (0.0276134s)][4.61073 (0.0276341s)][2.31056 (0.0506668s)]]
]
[table Operator *=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.54027 (0.0500366s)][5.58857 (0.0547429s)][3.33593 (0.0987612s)]]
[[cpp_dec_float][9.23894 (0.0706828s)][17.6238 (0.172634s)][81.1437 (2.40228s)]]
[[gmp_float][[*1] (0.00765054s)][[*1] (0.00979552s)][[*1] (0.0296053s)]]
[[mpfr_float][2.99517 (0.0229147s)][3.55395 (0.0348128s)][2.42098 (0.0716736s)]]
]
[table Operator +
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][2.61482 (0.0479759s)][6.91285 (0.0901201s)][8.04302 (0.219881s)]]
[[cpp_dec_float][1.08384 (0.0198859s)][1.6631 (0.0216812s)][7.59843 (0.207727s)]]
[[gmp_float][1.00042 (0.0183555s)][[*1] (0.0130366s)][[*1] (0.0273382s)]]
[[mpfr_float][[*1] (0.0183477s)][1.4588 (0.0190178s)][2.22935 (0.0609463s)]]
]
[table Operator +(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][11.8195 (0.0524679s)][13.9144 (0.0871804s)][13.6745 (0.165014s)]]
[[cpp_dec_float][3.22445 (0.0143136s)][2.703 (0.0169356s)][12.5227 (0.151114s)]]
[[gmp_float][[*1] (0.00443909s)][[*1] (0.00626549s)][[*1] (0.0120673s)]]
[[mpfr_float][5.78563 (0.0256829s)][4.78942 (0.0300081s)][5.21353 (0.062913s)]]
]
[table Operator +(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][21.4259 (0.109321s)][16.4546 (0.128103s)][14.7256 (0.16427s)]]
[[cpp_dec_float][4.53931 (0.0231609s)][3.75913 (0.0292658s)][13.3516 (0.148942s)]]
[[gmp_float][[*1] (0.0051023s)][[*1] (0.00778526s)][[*1] (0.0111554s)]]
[[mpfr_float][5.11905 (0.0261189s)][3.73777 (0.0290995s)][5.52758 (0.0616622s)]]
]
[table Operator +=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.6778 (0.109847s)][6.84045 (0.0942496s)][9.09759 (0.157162s)]]
[[cpp_dec_float][1.06799 (0.017568s)][1.71962 (0.0236933s)][10.7777 (0.186187s)]]
[[gmp_float][[*1] (0.0164496s)][[*1] (0.0137783s)][[*1] (0.0172751s)]]
[[mpfr_float][3.47654 (0.0571878s)][3.64857 (0.0502709s)][4.56004 (0.0787754s)]]
]
[table Operator -
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.04597 (0.0688937s)][4.65775 (0.0896788s)][7.55005 (0.196627s)]]
[[cpp_dec_float][1.42357 (0.0194363s)][1.62766 (0.0313385s)][8.16298 (0.21259s)]]
[[gmp_float][[*1] (0.0136532s)][[*1] (0.0192537s)][[*1] (0.0260432s)]]
[[mpfr_float][1.76726 (0.0241287s)][2.05663 (0.0395976s)][2.48295 (0.0646638s)]]
]
[table Operator -(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.31633 (0.0848243s)][7.07646 (0.084402s)][6.65523 (0.181209s)]]
[[cpp_dec_float][1.6139 (0.0216737s)][2.20945 (0.0263524s)][5.27802 (0.14371s)]]
[[gmp_float][[*1] (0.0134294s)][[*1] (0.0119272s)][[*1] (0.0272281s)]]
[[mpfr_float][5.1551 (0.0692297s)][5.48391 (0.0654074s)][2.6116 (0.0711089s)]]
]
[table Operator -(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][9.08373 (0.102878s)][4.54284 (0.0883961s)][7.01771 (0.185162s)]]
[[cpp_dec_float][2.19345 (0.0248419s)][1.47898 (0.0287785s)][5.71248 (0.150724s)]]
[[gmp_float][[*1] (0.0113255s)][[*1] (0.0194584s)][[*1] (0.026385s)]]
[[mpfr_float][5.35926 (0.0606961s)][2.92255 (0.056868s)][3.43277 (0.0905736s)]]
]
[table Operator -=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][8.73347 (0.129938s)][4.58762 (0.101449s)][5.43827 (0.163157s)]]
[[cpp_dec_float][1.67927 (0.0249846s)][1.79526 (0.0396995s)][6.63379 (0.199025s)]]
[[gmp_float][[*1] (0.0148782s)][[*1] (0.0221136s)][[*1] (0.0300017s)]]
[[mpfr_float][3.96488 (0.0589902s)][3.30899 (0.0731736s)][3.51566 (0.105476s)]]
]
[table Operator /
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.40221 (0.549759s)][10.0182 (1.39191s)][12.3684 (5.32129s)]]
[[cpp_dec_float][8.16505 (0.83092s)][12.483 (1.73437s)][52.8644 (22.744s)]]
[[gmp_float][[*1] (0.101766s)][[*1] (0.138938s)][[*1] (0.430233s)]]
[[mpfr_float][1.6699 (0.169939s)][2.16251 (0.300455s)][2.82683 (1.2162s)]]
]
[table Operator /(int)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][5.81464 (0.141651s)][12.2991 (0.271491s)][8.20246 (0.643802s)]]
[[cpp_dec_float][16.4865 (0.40163s)][39.0331 (0.861622s)][164 (12.8722s)]]
[[gmp_float][[*1] (0.0243611s)][[*1] (0.0220741s)][[*1] (0.0784889s)]]
[[mpfr_float][2.25501 (0.0549347s)][2.6832 (0.0592293s)][1.60852 (0.126251s)]]
]
[table Operator /(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][10.879 (0.19558s)][10.4845 (0.244599s)][8.82445 (0.621615s)]]
[[cpp_dec_float][22.028 (0.396014s)][42.4784 (0.991001s)][201.351 (14.1836s)]]
[[gmp_float][[*1] (0.0179778s)][[*1] (0.0233296s)][[*1] (0.0704423s)]]
[[mpfr_float][2.89723 (0.0520857s)][2.6935 (0.0628383s)][1.67233 (0.117803s)]]
]
[table Operator /=(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][11.0264 (0.215322s)][7.78235 (0.256093s)][8.31638 (0.638041s)]]
[[cpp_dec_float][20.9412 (0.408938s)][38.8146 (1.27727s)][142.377 (10.9233s)]]
[[gmp_float][[*1] (0.0195279s)][[*1] (0.032907s)][[*1] (0.076721s)]]
[[mpfr_float][2.67894 (0.0523141s)][2.16678 (0.071302s)][1.5964 (0.122477s)]]
]
[table Operator construct
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][[*1] (0.0030982s)][1.37355 (0.00608929s)][[*1] (0.0152335s)]]
[[cpp_dec_float][1.23911 (0.00383901s)][[*1] (0.00443324s)][1.6806 (0.0256013s)]]
[[gmp_float][7.50258 (0.0232445s)][5.47554 (0.0242744s)][5.81062 (0.0885159s)]]
[[mpfr_float][24.9598 (0.0773304s)][19.5526 (0.0866815s)][5.00378 (0.0762248s)]]
]
[table Operator construct(unsigned long long)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][2.08541 (0.0175206s)][3.12821 (0.0267453s)][1.32687 (0.0570308s)]]
[[cpp_dec_float][[*1] (0.00840151s)][[*1] (0.00854971s)][[*1] (0.0429815s)]]
[[gmp_float][3.08163 (0.0258903s)][2.44895 (0.0209379s)][2.12806 (0.0914671s)]]
[[mpfr_float][10.6814 (0.08974s)][8.42482 (0.0720298s)][1.8282 (0.0785786s)]]
]
[table Operator construct(unsigned)
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][1.04974 (0.00808983s)][1.38823 (0.0120486s)][1.16321 (0.0530205s)]]
[[cpp_dec_float][[*1] (0.00770653s)][[*1] (0.00867913s)][[*1] (0.0455813s)]]
[[gmp_float][3.88496 (0.0299395s)][2.90503 (0.0252132s)][1.82072 (0.0829907s)]]
[[mpfr_float][13.3088 (0.102564s)][8.41333 (0.0730204s)][1.78408 (0.0813206s)]]
]
[table Operator str
[[Backend][50 Bits][100 Bits][500 Bits]]
[[cpp_bin_float][6.09659 (0.00301165s)][4.71882 (0.0051705s)][12.4899 (0.043165s)]]
[[cpp_dec_float][2.94087 (0.00145276s)][1.64843 (0.00180621s)][3.16004 (0.0109211s)]]
[[gmp_float][[*1] (0.000493989s)][[*1] (0.00109572s)][[*1] (0.00345598s)]]
[[mpfr_float][4.60349 (0.00227407s)][1.21213 (0.00132816s)][1.41569 (0.0048926s)]]
]
[endsect]
[section:integer_performance Integer Type Perfomance]
[table Operator %
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][1.51155 (0.0481508s)][1.60666 (0.0825917s)][1.75956 (0.127209s)][1.87154 (0.171986s)][2.58143 (0.368469s)][1.65419 (0.398213s)][[*1] (0.512768s)][1.42429 (1.03083s)][[*1] (1.96988s)]]
[[cpp_int(fixed)][[*1] (0.0318553s)][1.2913 (0.0663805s)][1.33672 (0.0966394s)][1.97924 (0.181883s)]]
[[gmp_int][1.4659 (0.0466966s)][[*1] (0.0514059s)][[*1] (0.0722958s)][[*1] (0.0918952s)][[*1] (0.142738s)][[*1] (0.24073s)][1.17701 (0.603534s)][[*1] (0.723753s)]]
[[tommath_int][27.46 (0.874748s)][20.1749 (1.03711s)][17.9774 (1.29969s)][19.0867 (1.75398s)][23.3789 (3.33706s)][26.6546 (6.41658s)][33.4553 (17.1548s)][70.788 (51.233s)]]
]
[table Operator %(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][[*1] (0.00790481s)][1.45288 (0.0215141s)][2.71488 (0.065874s)][4.05695 (0.1044s)][6.59285 (0.288068s)][5.28362 (0.301827s)][3.58045 (0.429244s)][6.18417 (0.851447s)][[*1] (1.57951s)]]
[[cpp_int(fixed)][2.18748 (0.0172916s)][1.67119 (0.0247468s)][2.83861 (0.0688759s)][4.3186 (0.111133s)]]
[[gmp_int][1.50165 (0.0118703s)][[*1] (0.0148079s)][[*1] (0.024264s)][[*1] (0.0257336s)][[*1] (0.0436939s)][[*1] (0.0571251s)][[*1] (0.119886s)][[*1] (0.137682s)]]
[[tommath_int][68.9623 (0.545134s)][54.52 (0.807325s)][38.3573 (0.930702s)][53.0833 (1.36603s)][59.6958 (2.60834s)][103.597 (5.91797s)][133.648 (16.0225s)][392.812 (54.083s)]]
]
[table Operator &
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.82137 (0.0101034s)][3.08842 (0.0128886s)][3.46566 (0.018172s)][2.55025 (0.0204051s)][2.97241 (0.0461406s)][[*1] (0.0366949s)][[*1] (0.0440714s)][[*1] (0.0811524s)][[*1] (0.146531s)]]
[[cpp_int(fixed)][[*1] (0.00358104s)][1.5374 (0.00641591s)][1.70378 (0.0089337s)][2.40825 (0.019269s)]]
[[gmp_int][1.10071 (0.00394167s)][[*1] (0.00417321s)][[*1] (0.00524347s)][[*1] (0.00800121s)][[*1] (0.015523s)][1.04806 (0.0384586s)][2.0133 (0.0887291s)][1.38531 (0.112421s)]]
[[tommath_int][2.18066 (0.00780901s)][2.22528 (0.00928657s)][2.15567 (0.0113032s)][3.05906 (0.0244762s)][2.34741 (0.0364387s)][1.50551 (0.0552444s)][2.29355 (0.10108s)][3.0313 (0.245997s)]]
]
[table Operator &(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.24695 (0.0124861s)][1.81002 (0.0114113s)][2.11984 (0.0179186s)][2.56949 (0.0262296s)][3.62157 (0.063826s)][5.04381 (0.0612567s)][3.95427 (0.0593859s)][4.84754 (0.102968s)][[*1] (0.168385s)]]
[[cpp_int(fixed)][[*1] (0.0038455s)][[*1] (0.00630453s)][[*1] (0.00845281s)][2.20848 (0.0225444s)]]
[[gmp_int][3.87448 (0.0148993s)][1.50343 (0.00947844s)][1.59793 (0.013507s)][[*1] (0.0102081s)][[*1] (0.0176239s)][[*1] (0.0121449s)][[*1] (0.0150182s)][[*1] (0.0212413s)]]
[[tommath_int][25.1094 (0.0965583s)][15.7147 (0.0990734s)][9.65097 (0.0815778s)][8.5208 (0.0869813s)][5.74798 (0.101302s)][10.598 (0.128712s)][12.0534 (0.18102s)][13.0183 (0.276527s)]]
]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.4201 (0.0145016s)][1.838 (0.0246772s)][2.10406 (0.0631704s)][2.22846 (0.224062s)][2.53789 (0.918685s)][1.18016 (1.31825s)][[*1] (2.65154s)][[*1] (7.83314s)][[*1] (26.1836s)]]
[[cpp_int(fixed)][[*1] (0.00116759s)][1.76789 (0.0237359s)][1.58515 (0.047591s)][1.52628 (0.153461s)]]
[[gmp_int][4.80091 (0.00560549s)][[*1] (0.0134261s)][[*1] (0.0300231s)][[*1] (0.100546s)][[*1] (0.361988s)][[*1] (1.11701s)][2.08347 (5.52441s)][1.44767 (11.3398s)]]
[[tommath_int][16.9604 (0.0198027s)][2.43157 (0.0326465s)][2.82213 (0.0847288s)][1.67653 (0.168568s)][1.27293 (0.460786s)][1.41678 (1.58255s)][2.69181 (7.13744s)][3.30421 (25.8824s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][10.9781 (0.0072726s)][1.52901 (0.00991594s)][3.35266 (0.0194072s)][2.30215 (0.0214459s)][1.95214 (0.047049s)][[*1] (0.0426049s)][[*1] (0.0576663s)][[*1] (0.0955853s)][[*1] (0.167493s)]]
[[cpp_int(fixed)][[*1] (0.000662467s)][[*1] (0.00648519s)][1.52643 (0.0088359s)][2.26708 (0.0211192s)]]
[[gmp_int][7.14641 (0.00473426s)][1.74133 (0.0112929s)][[*1] (0.00578859s)][[*1] (0.00931559s)][[*1] (0.0241013s)][1.12075 (0.0477494s)][1.96831 (0.113505s)][1.44107 (0.137745s)]]
[[tommath_int][156.154 (0.103447s)][14.5292 (0.0942242s)][16.82 (0.0973642s)][11.9029 (0.110883s)][5.61803 (0.135402s)][4.61241 (0.196512s)][5.30415 (0.30587s)][5.73424 (0.548109s)]]
]
[table Operator *(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][8.98335 (0.00669928s)][1.79861 (0.00820918s)][1.86924 (0.0119122s)][1.71773 (0.0175683s)][2.57826 (0.0539343s)][1.63339 (0.052584s)][[*1] (0.0432066s)][[*1] (0.0813634s)][[*1] (0.159452s)]]
[[cpp_int(fixed)][[*1] (0.000745744s)][1.07211 (0.00489332s)][1.19888 (0.00764018s)][1.53618 (0.0157115s)]]
[[gmp_int][4.97741 (0.00371188s)][[*1] (0.00456418s)][[*1] (0.00637276s)][[*1] (0.0102277s)][[*1] (0.0209189s)][[*1] (0.0321931s)][2.05197 (0.0886586s)][1.59261 (0.12958s)]]
[[tommath_int][143.938 (0.107341s)][24.0751 (0.109883s)][16.9325 (0.107907s)][11.5473 (0.118102s)][8.08283 (0.169084s)][6.84808 (0.220461s)][8.37134 (0.361697s)][8.20104 (0.667264s)]]
]
[table Operator *=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][15.7803 (0.0131299s)][1.67116 (0.00790233s)][1.66661 (0.0119079s)][1.51408 (0.0203561s)][1.23815 (0.0373067s)][1.15288 (0.0527845s)][[*1] (0.0424701s)][[*1] (0.0946934s)][[*1] (0.177219s)]]
[[cpp_int(fixed)][[*1] (0.000832044s)][[*1] (0.00472864s)][[*1] (0.00714494s)][[*1] (0.0134446s)]]
[[gmp_int][6.73473 (0.00560359s)][1.81651 (0.00858963s)][1.36813 (0.00977523s)][1.00404 (0.0134989s)][[*1] (0.0301309s)][[*1] (0.0457849s)][2.56449 (0.108914s)][2.20384 (0.208689s)]]
[[tommath_int][115.266 (0.0959064s)][24.7701 (0.117129s)][15.9941 (0.114277s)][11.3798 (0.152996s)][5.69861 (0.171704s)][5.47882 (0.250847s)][10.6875 (0.453899s)][7.29439 (0.690731s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.80738 (0.0086037s)][2.34204 (0.0160922s)][1.00627 (0.0131305s)][1.67865 (0.0163002s)][1.88916 (0.033949s)][1.11861 (0.0336398s)][[*1] (0.0412289s)][[*1] (0.083134s)][[*1] (0.190174s)]]
[[cpp_int(fixed)][[*1] (0.000877268s)][[*1] (0.00687102s)][1.82016 (0.0237507s)][1.90391 (0.0184876s)]]
[[gmp_int][5.87168 (0.00515104s)][1.45191 (0.00997612s)][[*1] (0.0130487s)][[*1] (0.00971031s)][[*1] (0.0179704s)][[*1] (0.0300729s)][1.96754 (0.0811195s)][1.62045 (0.134715s)]]
[[tommath_int][13.6707 (0.0119929s)][1.03266 (0.00709542s)][1.02249 (0.0133422s)][1.4749 (0.0143218s)][1.17551 (0.0211244s)][1.08462 (0.0326177s)][1.47125 (0.060658s)][2.75813 (0.229295s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][7.65014 (0.00534018s)][1.8992 (0.0063589s)][1.56778 (0.00666443s)][1.29719 (0.00836612s)][1.73231 (0.0204874s)][1.26754 (0.024805s)][[*1] (0.0198385s)][[*1] (0.0338486s)][[*1] (0.0760202s)]]
[[cpp_int(fixed)][[*1] (0.000698051s)][1.72665 (0.00578118s)][1.57164 (0.00668085s)][1.90796 (0.0123052s)]]
[[gmp_int][4.97679 (0.00347405s)][[*1] (0.0033482s)][[*1] (0.00425087s)][[*1] (0.0064494s)][[*1] (0.0118266s)][[*1] (0.0195694s)][3.53343 (0.0700979s)][2.28146 (0.0772241s)]]
[[tommath_int][127.407 (0.0889366s)][24.8716 (0.0832749s)][20.4864 (0.0870848s)][12.5462 (0.0809152s)][7.07209 (0.083639s)][4.79434 (0.0938225s)][5.93694 (0.11778s)][5.20775 (0.176275s)]]
]
[table Operator +(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.92952 (0.00893714s)][2.68575 (0.0136811s)][1.73024 (0.0102989s)][1.43961 (0.0115471s)][1.46556 (0.0237404s)][1.68706 (0.0294774s)][[*1] (0.0253811s)][[*1] (0.0350422s)][[*1] (0.0761856s)]]
[[cpp_int(fixed)][[*1] (0.000900057s)][1.27396 (0.00648945s)][1.38787 (0.008261s)][1.56798 (0.0125768s)]]
[[gmp_int][5.22669 (0.00470432s)][[*1] (0.00509394s)][[*1] (0.00595229s)][[*1] (0.00802101s)][[*1] (0.0161988s)][[*1] (0.0174726s)][1.83602 (0.0466003s)][1.90731 (0.0668364s)]]
[[tommath_int][100.859 (0.0907784s)][19.2654 (0.0981367s)][14.4537 (0.0860324s)][10.0594 (0.0806864s)][5.71755 (0.0926177s)][6.23483 (0.108939s)][4.63528 (0.117648s)][5.01743 (0.175822s)]]
]
[table Operator +=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.2366 (0.0106404s)][1.48157 (0.00996803s)][1.58862 (0.0108279s)][2.06658 (0.0131949s)][1.1631 (0.0186902s)][[*1] (0.0201879s)][[*1] (0.0218483s)][[*1] (0.0394761s)][[*1] (0.0783171s)]]
[[cpp_int(fixed)][[*1] (0.000869555s)][1.34779 (0.00906799s)][[*1] (0.00681593s)][[*1] (0.00638493s)]]
[[gmp_int][11.3522 (0.00987134s)][[*1] (0.00672804s)][1.27495 (0.00868995s)][2.42237 (0.0154667s)][[*1] (0.0160693s)][1.09672 (0.0221405s)][2.61199 (0.0570676s)][2.13093 (0.0841208s)]]
[[tommath_int][88.4252 (0.0768906s)][14.139 (0.0951277s)][11.6282 (0.0792569s)][14.5551 (0.0929332s)][6.86867 (0.110375s)][5.67471 (0.11456s)][7.29502 (0.159384s)][5.733 (0.226317s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][4.45457 (0.00859678s)][1.28478 (0.013219s)][1.27873 (0.0117779s)][1.43649 (0.0151597s)][2.82516 (0.0507822s)][1.17197 (0.037733s)][[*1] (0.0463464s)][[*1] (0.0813138s)][[*1] (0.191562s)]]
[[cpp_int(fixed)][[*1] (0.00192988s)][[*1] (0.010289s)][[*1] (0.00921062s)][1.5372 (0.0162226s)]]
[[gmp_int][3.4436 (0.00664573s)][1.25045 (0.0128659s)][1.10953 (0.0102195s)][[*1] (0.0105533s)][[*1] (0.017975s)][[*1] (0.0321962s)][2.54862 (0.11812s)][1.83623 (0.14931s)]]
[[tommath_int][9.3224 (0.0179911s)][1.08796 (0.011194s)][1.93265 (0.017801s)][1.82306 (0.0192393s)][1.55663 (0.0279804s)][1.6544 (0.0532653s)][1.90928 (0.0884881s)][4.41259 (0.358805s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.07164 (0.00347144s)][1.38957 (0.00531251s)][1.29053 (0.00548206s)][1.35239 (0.00759591s)][1.50007 (0.0176467s)][1.44798 (0.032706s)][[*1] (0.0209158s)][[*1] (0.0402632s)][[*1] (0.0674681s)]]
[[cpp_int(fixed)][[*1] (0.00113016s)][1.26281 (0.00482789s)][1.25074 (0.00531307s)][3.3923 (0.0190533s)]]
[[gmp_int][3.22069 (0.00363988s)][[*1] (0.00382312s)][[*1] (0.00424793s)][[*1] (0.00561665s)][[*1] (0.0117639s)][[*1] (0.0225873s)][2.75829 (0.0576919s)][2.03214 (0.0818204s)]]
[[tommath_int][81.1433 (0.0917047s)][21.4543 (0.0820224s)][19.3098 (0.0820267s)][16.2994 (0.0915478s)][7.23608 (0.0851246s)][4.48441 (0.101291s)][5.51882 (0.115431s)][4.44737 (0.179066s)]]
]
[table Operator -(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][7.02787 (0.00807189s)][1.85949 (0.00922027s)][1.40179 (0.00830959s)][1.22546 (0.00988039s)][1.27526 (0.0235442s)][1.00875 (0.0222548s)][[*1] (0.0242017s)][[*1] (0.0317445s)][[*1] (0.0783054s)]]
[[cpp_int(fixed)][[*1] (0.00114855s)][1.03947 (0.00515424s)][1.22566 (0.00726552s)][1.56568 (0.0126235s)]]
[[gmp_int][7.54669 (0.00866778s)][[*1] (0.0049585s)][[*1] (0.00592785s)][[*1] (0.00806262s)][[*1] (0.0184622s)][[*1] (0.0220616s)][1.79985 (0.0435595s)][2.08427 (0.0661641s)]]
[[tommath_int][72.1332 (0.0828488s)][18.985 (0.0941371s)][13.9301 (0.0825755s)][9.93889 (0.0801335s)][5.42256 (0.100113s)][4.58437 (0.101139s)][4.91664 (0.118991s)][5.5407 (0.175887s)]]
]
[table Operator -=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][10.8565 (0.0103583s)][2.00541 (0.0102937s)][1.73348 (0.0103591s)][2.53718 (0.0189898s)][1.21308 (0.0265754s)][1.10592 (0.0277295s)][[*1] (0.0249248s)][[*1] (0.0377524s)][[*1] (0.070851s)]]
[[cpp_int(fixed)][[*1] (0.000954108s)][[*1] (0.00513296s)][[*1] (0.00597589s)][[*1] (0.00748462s)]]
[[gmp_int][6.6602 (0.00635455s)][1.61345 (0.00828179s)][1.41745 (0.00847054s)][1.41728 (0.0106078s)][[*1] (0.0219074s)][[*1] (0.0250737s)][2.12439 (0.05295s)][2.51074 (0.0947863s)]]
[[tommath_int][88.858 (0.0847801s)][18.6448 (0.0957029s)][13.7283 (0.0820388s)][13.4423 (0.100611s)][4.83335 (0.105886s)][4.6829 (0.117418s)][7.59449 (0.189292s)][5.86189 (0.2213s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.20876 (0.0878919s)][3.17469 (0.181536s)][3.14517 (0.250544s)][4.14655 (0.365546s)][4.70812 (0.702366s)][4.81923 (1.00586s)][2.28619 (1.18106s)][3.54663 (2.26453s)][[*1] (4.52755s)]]
[[cpp_int(fixed)][[*1] (0.0273912s)][1.72404 (0.098585s)][2.12584 (0.169344s)][3.71442 (0.327451s)]]
[[gmp_int][1.70383 (0.04667s)][[*1] (0.0571824s)][[*1] (0.0796599s)][[*1] (0.0881567s)][[*1] (0.149182s)][[*1] (0.208719s)][[*1] (0.516606s)][[*1] (0.638503s)]]
[[tommath_int][40.8044 (1.11768s)][17.2975 (0.989116s)][17.4097 (1.38686s)][20.9668 (1.84837s)][20.6415 (3.07934s)][31.5839 (6.59216s)][33.0087 (17.0525s)][81.0894 (51.7759s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][4.50037 (0.0520677s)][6.30243 (0.108097s)][8.34437 (0.193637s)][7.02879 (0.296939s)][6.47793 (0.630264s)][5.49102 (0.859876s)][2.64044 (1.08346s)][3.92627 (2.33772s)][[*1] (4.22641s)]]
[[cpp_int(fixed)][1.27227 (0.0147198s)][4.34067 (0.0744498s)][6.08699 (0.141253s)][6.56549 (0.277366s)]]
[[gmp_int][[*1] (0.0115696s)][[*1] (0.0171517s)][[*1] (0.0232057s)][[*1] (0.0422461s)][[*1] (0.0972941s)][[*1] (0.156597s)][[*1] (0.410334s)][[*1] (0.595404s)]]
[[tommath_int][60.4712 (0.69963s)][44.8464 (0.769191s)][40.4334 (0.938285s)][35.0752 (1.48179s)][26.8178 (2.60921s)][37.2616 (5.83504s)][37.7146 (15.4756s)][84.1326 (50.0929s)]]
]
[table Operator /(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][6.09203 (0.0582351s)][6.42997 (0.0982056s)][6.2137 (0.151642s)][6.62408 (0.281298s)][9.30105 (0.706562s)][6.64685 (0.832241s)][3.66307 (1.0584s)][4.10257 (2.14867s)][[*1] (4.2547s)]]
[[cpp_int(fixed)][1.76794 (0.0169001s)][3.59379 (0.0548884s)][5.55499 (0.135566s)][6.36274 (0.2702s)]]
[[gmp_int][[*1] (0.00955921s)][[*1] (0.0152731s)][[*1] (0.0244044s)][[*1] (0.042466s)][[*1] (0.0759658s)][[*1] (0.125208s)][[*1] (0.288938s)][[*1] (0.523737s)]]
[[tommath_int][63.2738 (0.604848s)][57.3767 (0.876321s)][43.9301 (1.07209s)][40.0122 (1.69916s)][41.1147 (3.12331s)][57.9739 (7.25882s)][68.6676 (19.8407s)][109.312 (57.2509s)]]
]
[table Operator /=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][5.21402 (0.0701172s)][4.76442 (0.105309s)][5.1245 (0.171387s)][7.39587 (0.299993s)][6.88568 (0.632889s)][5.93971 (0.873081s)][3.2993 (1.05399s)][3.52936 (2.14442s)][[*1] (4.37618s)]]
[[cpp_int(fixed)][1.68246 (0.0226255s)][3.12633 (0.0691018s)][3.98733 (0.133354s)][6.62903 (0.268888s)]]
[[gmp_int][[*1] (0.0134478s)][[*1] (0.0221032s)][[*1] (0.0334445s)][[*1] (0.0405622s)][[*1] (0.0919138s)][[*1] (0.14699s)][[*1] (0.319457s)][[*1] (0.607595s)]]
[[tommath_int][46.0731 (0.619583s)][43.6571 (0.964961s)][30.1861 (1.00956s)][41.4936 (1.68307s)][32.6785 (3.0036s)][48.2935 (7.09868s)][64.9093 (20.7357s)][111.801 (67.9296s)]]
]
[table Operator <<
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][9.93178 (0.0116142s)][1.74005 (0.0147029s)][2.68859 (0.0238748s)][2.04419 (0.0394659s)][2.15112 (0.0859331s)][1.26154 (0.0753453s)][[*1] (0.0889652s)][[*1] (0.190562s)][[*1] (0.32803s)]]
[[cpp_int(fixed)][[*1] (0.00116939s)][[*1] (0.00844969s)][1.94851 (0.0173029s)][1.55242 (0.0299716s)]]
[[gmp_int][4.60815 (0.00538874s)][1.02939 (0.00869801s)][[*1] (0.00888006s)][[*1] (0.0193064s)][[*1] (0.039948s)][[*1] (0.0597248s)][1.65224 (0.146992s)][1.08567 (0.206887s)]]
[[tommath_int][10.7935 (0.0126218s)][2.38166 (0.0201243s)][2.42444 (0.0215291s)][1.87488 (0.0361972s)][1.73489 (0.0693055s)][1.93177 (0.115375s)][2.49667 (0.222116s)][2.82346 (0.538044s)]]
]
[table Operator >>
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][12.5304 (0.011709s)][6.85524 (0.0153366s)][8.77866 (0.0209131s)][3.21549 (0.0146098s)][4.04361 (0.0183489s)][5.86336 (0.0183679s)][3.04276 (0.0219967s)][8.19636 (0.0537598s)][[*1] (0.0745484s)]]
[[cpp_int(fixed)][[*1] (0.000934446s)][6.55349 (0.0146615s)][6.51353 (0.0155169s)][4.90631 (0.0222922s)]]
[[gmp_int][2.59712 (0.00242687s)][[*1] (0.0022372s)][[*1] (0.00238226s)][[*1] (0.00454358s)][[*1] (0.00453774s)][[*1] (0.00313265s)][[*1] (0.00722919s)][[*1] (0.00655899s)]]
[[tommath_int][102.662 (0.0959319s)][42.5337 (0.0951565s)][39.1437 (0.0932504s)][21.0397 (0.0955953s)][29.6104 (0.134364s)][62.7092 (0.196446s)][49.6167 (0.358689s)][137.105 (0.899272s)]]
]
[table Operator ^
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.8103 (0.0101384s)][4.11932 (0.0282768s)][2.25923 (0.0139063s)][1.94172 (0.0187085s)][1.66067 (0.0405646s)][1.10651 (0.0475314s)][[*1] (0.0369865s)][[*1] (0.0918676s)][[*1] (0.150955s)]]
[[cpp_int(fixed)][[*1] (0.00360758s)][[*1] (0.00686442s)][1.50683 (0.00927498s)][1.79076 (0.0172541s)]]
[[gmp_int][1.35398 (0.0048846s)][1.00969 (0.00693092s)][[*1] (0.00615531s)][[*1] (0.00963503s)][[*1] (0.0244266s)][[*1] (0.0429561s)][2.17737 (0.0805332s)][1.3521 (0.124214s)]]
[[tommath_int][2.28701 (0.00825059s)][1.65996 (0.0113947s)][2.06089 (0.0126854s)][2.03244 (0.0195826s)][1.4173 (0.0346198s)][1.32237 (0.0568037s)][2.69468 (0.0996668s)][2.55626 (0.234837s)]]
]
[table Operator ^(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.67312 (0.00991885s)][1.57246 (0.0115174s)][2.50193 (0.0198209s)][[*1] (0.0153479s)][[*1] (0.0264078s)][[*1] (0.0206665s)][[*1] (0.0235546s)][[*1] (0.0392727s)][[*1] (0.0657809s)]]
[[cpp_int(fixed)][[*1] (0.00371059s)][[*1] (0.0073244s)][[*1] (0.00792226s)][1.04763 (0.0160789s)]]
[[gmp_int][2.86377 (0.0106263s)][2.18619 (0.0160125s)][2.18777 (0.0173321s)][1.01844 (0.0156309s)][1.13176 (0.0298873s)][1.9665 (0.0406408s)][3.34613 (0.0788165s)][3.54952 (0.139399s)]]
[[tommath_int][26.101 (0.0968501s)][14.6444 (0.107261s)][10.0538 (0.079649s)][5.64392 (0.0866224s)][3.8806 (0.102478s)][6.36386 (0.131519s)][8.07216 (0.190136s)][8.01428 (0.314742s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][3.24638 (0.00190752s)][1.06172 (0.00258002s)][[*1] (0.00248269s)][[*1] (0.00191598s)][[*1] (0.00273948s)][[*1] (0.00240729s)][[*1] (0.0017072s)][[*1] (0.00191549s)][[*1] (0.0016635s)]]
[[cpp_int(fixed)][[*1] (0.000587582s)][[*1] (0.00243004s)][1.51116 (0.00375174s)][4.66482 (0.00893771s)]]
[[gmp_int][5.61558 (0.00329962s)][1.52898 (0.0037155s)][2.51713 (0.00624925s)][1.755 (0.00336255s)][1.40183 (0.00384029s)][1.60131 (0.00385483s)][4.7818 (0.0081635s)][2.07779 (0.00397999s)]]
[[tommath_int][251.1 (0.147542s)][63.6186 (0.154596s)][54.6947 (0.13579s)][66.8839 (0.128148s)][47.8098 (0.130974s)][54.8252 (0.13198s)][74.1436 (0.126578s)][83.945 (0.160796s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.12644 (0.00192028s)][[*1] (0.00200418s)][[*1] (0.00223886s)][[*1] (0.00189442s)][[*1] (0.00190833s)][[*1] (0.00288069s)][[*1] (0.00199036s)][[*1] (0.00200998s)][[*1] (0.00168004s)]]
[[cpp_int(fixed)][[*1] (0.000903049s)][1.26395 (0.00253319s)][1.78621 (0.00399907s)][5.10701 (0.0096748s)]]
[[gmp_int][27.1389 (0.0245077s)][10.3593 (0.020762s)][9.02272 (0.0202006s)][9.96334 (0.0188747s)][15.2262 (0.0290565s)][8.50239 (0.0244927s)][35.6564 (0.0709692s)][10.9129 (0.0219346s)]]
[[tommath_int][183.484 (0.165695s)][83.0709 (0.166489s)][69.5984 (0.155821s)][75.8903 (0.143768s)][85.5979 (0.163349s)][50.8174 (0.146389s)][70.0602 (0.139445s)][95.4952 (0.191943s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.00349 (0.00174712s)][[*1] (0.00225895s)][[*1] (0.00241092s)][[*1] (0.00177047s)][[*1] (0.00304865s)][[*1] (0.00241711s)][[*1] (0.0018378s)][[*1] (0.0017583s)][[*1] (0.00197229s)]]
[[cpp_int(fixed)][[*1] (0.000872038s)][1.1805 (0.0026667s)][1.66167 (0.00400614s)][5.54475 (0.00981681s)]]
[[gmp_int][27.6419 (0.0241048s)][10.0723 (0.0227529s)][7.60577 (0.0183369s)][10.2725 (0.0181871s)][9.38419 (0.0286091s)][9.10394 (0.0220052s)][34.6032 (0.0635939s)][15.7134 (0.0276289s)]]
[[tommath_int][207.462 (0.180915s)][84.5379 (0.190967s)][65.2109 (0.157218s)][84.8572 (0.150237s)][47.0682 (0.143494s)][59.4466 (0.143689s)][78.5549 (0.144368s)][103.519 (0.182018s)]]
]
[table Operator gcd
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.10743 (0.358587s)][1.8778 (1.42989s)][2.03859 (3.30534s)][2.01435 (7.01715s)][2.16957 (17.7583s)][1.16957 (21.9738s)][[*1] (32.2572s)][[*1] (76.6459s)][[*1] (201.791s)]]
[[cpp_int(fixed)][3.65486 (0.621889s)][1.78424 (1.35865s)][2.02664 (3.28597s)][1.95328 (6.8044s)]]
[[gmp_int][[*1] (0.170154s)][[*1] (0.761472s)][[*1] (1.62139s)][[*1] (3.48358s)][[*1] (8.18516s)][[*1] (18.7879s)][1.82325 (58.8129s)][1.59356 (122.14s)]]
[[tommath_int][8.01966 (1.36458s)][4.44226 (3.38266s)][4.55056 (7.37824s)][4.42983 (15.4317s)][5.23788 (42.8729s)][7.25799 (136.362s)][14.6265 (471.81s)][23.1025 (1770.72s)]]
]
[table Operator powm
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_int][14.8198 (0.565871s)][13.2096 (2.0199s)][11.8233 (9.06469s)][9.12533 (46.9932s)]]
[[cpp_int(fixed)][9.40069 (0.35895s)][10.0395 (1.53516s)][10.5353 (8.07714s)][8.49678 (43.7564s)]]
[[gmp_int][[*1] (0.0381833s)][[*1] (0.152912s)][[*1] (0.766677s)][[*1] (5.14976s)]]
[[tommath_int][11.0485 (0.421869s)][8.44037 (1.29063s)][4.18756 (3.21051s)][2.45216 (12.628s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][1.47697 (0.000264092s)][2.87174 (0.000644609s)][2.28911 (0.00141073s)][4.92453 (0.00383604s)][5.61647 (0.0137593s)][4.87866 (0.0237422s)][1.87264 (0.0491109s)][4.29909 (0.171316s)][[*1] (0.595522s)]]
[[cpp_int(fixed)][4.73326 (0.00084634s)][1.78742 (0.000401216s)][1.68455 (0.00103815s)][4.30889 (0.00335647s)]]
[[gmp_int][[*1] (0.000178807s)][[*1] (0.000224466s)][[*1] (0.00061628s)][[*1] (0.000778966s)][[*1] (0.00244981s)][[*1] (0.00486654s)][[*1] (0.0262254s)][[*1] (0.0398493s)]]
[[tommath_int][16.7304 (0.00299152s)][26.6015 (0.00597113s)][30.9815 (0.0190933s)][74.7467 (0.0582251s)][82.4773 (0.202054s)][154.996 (0.754295s)][107.534 (2.82013s)][279.178 (11.1251s)]]
]
[table Operator |
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.26845 (0.00991773s)][1.955 (0.00939722s)][2.01122 (0.012635s)][1.76421 (0.0152013s)][1.92162 (0.0293243s)][[*1] (0.0334167s)][[*1] (0.0377549s)][[*1] (0.0916779s)][[*1] (0.152323s)]]
[[cpp_int(fixed)][1.00452 (0.0043918s)][1.37689 (0.00661838s)][1.3138 (0.00825362s)][1.71906 (0.0148123s)]]
[[gmp_int][[*1] (0.00437203s)][[*1] (0.00480677s)][[*1] (0.00628228s)][[*1] (0.00861647s)][[*1] (0.0152602s)][1.09283 (0.0365187s)][2.43832 (0.0920584s)][1.21204 (0.111118s)]]
[[tommath_int][1.69103 (0.00739324s)][1.85402 (0.00891185s)][1.78526 (0.0112155s)][1.86487 (0.0160686s)][1.75184 (0.0267336s)][1.44011 (0.0481236s)][2.33195 (0.0880424s)][2.33204 (0.213797s)]]
]
[table Operator |(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits][2048 Bits][2688 Bits][4096 Bits][8192 Bits][16384 Bits]]
[[cpp_int][2.11741 (0.00805945s)][2.16753 (0.0119795s)][1.5717 (0.012189s)][1.10016 (0.0134288s)][1.11289 (0.0309032s)][[*1] (0.0214828s)][[*1] (0.0232284s)][[*1] (0.042441s)][[*1] (0.0711061s)]]
[[cpp_int(fixed)][[*1] (0.00380628s)][[*1] (0.00552682s)][[*1] (0.00775532s)][[*1] (0.0122062s)]]
[[gmp_int][2.62934 (0.010008s)][1.86878 (0.0103284s)][3.19589 (0.0247852s)][1.1073 (0.0135159s)][[*1] (0.0277685s)][1.67609 (0.0360071s)][3.76493 (0.0874534s)][2.72382 (0.115602s)]]
[[tommath_int][22.0502 (0.0839291s)][18.6272 (0.102949s)][9.99323 (0.0775007s)][6.28905 (0.0767652s)][3.28821 (0.0913086s)][5.0968 (0.109494s)][6.47865 (0.150489s)][4.8474 (0.205729s)]]
]
[endsect]
[section:rational_performance Rational Type Perfomance]
[table Operator *
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.00025 (0.797425s)][1.97726 (2.96998s)][1.86844 (6.73224s)][1.96608 (14.4259s)]]
[[mpq_rational][[*1] (0.398662s)][[*1] (1.50207s)][[*1] (3.60314s)][[*1] (7.3374s)]]
]
[table Operator *(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.88073 (0.0637195s)][1.93184 (0.0917847s)][2.15609 (0.118274s)][2.4236 (0.218283s)]]
[[mpq_rational][[*1] (0.0338803s)][[*1] (0.0475114s)][[*1] (0.0548556s)][[*1] (0.0900656s)]]
]
[table Operator *(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.60877 (0.161844s)][2.33429 (0.240069s)][1.8835 (0.298935s)][2.70338 (0.448194s)]]
[[mpq_rational][[*1] (0.100601s)][[*1] (0.102844s)][[*1] (0.158713s)][[*1] (0.16579s)]]
]
[table Operator *(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.97503 (0.408791s)][2.42069 (0.600225s)][2.65138 (0.803009s)][4.65673 (1.54645s)]]
[[mpq_rational][[*1] (0.20698s)][[*1] (0.247956s)][[*1] (0.302865s)][[*1] (0.332089s)]]
]
[table Operator *=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.97207 (0.211848s)][2.18482 (0.226179s)][2.43682 (0.319695s)][2.69933 (0.485819s)]]
[[mpq_rational][[*1] (0.107424s)][[*1] (0.103523s)][[*1] (0.131194s)][[*1] (0.179978s)]]
]
[table Operator *=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.95211 (0.40255s)][2.60942 (0.629302s)][2.83854 (0.8029s)][4.34054 (1.37083s)]]
[[mpq_rational][[*1] (0.206213s)][[*1] (0.241165s)][[*1] (0.282857s)][[*1] (0.31582s)]]
]
[table Operator +
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.20364 (0.415006s)][1.97574 (1.53458s)][1.75945 (3.41194s)][2.11634 (8.04044s)]]
[[mpq_rational][[*1] (0.188327s)][[*1] (0.776716s)][[*1] (1.93921s)][[*1] (3.79923s)]]
]
[table Operator +(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.06836 (0.0177811s)][1.80334 (0.0183744s)][1.38442 (0.020452s)][1.81894 (0.0449351s)]]
[[mpq_rational][[*1] (0.00859669s)][[*1] (0.0101891s)][[*1] (0.014773s)][[*1] (0.024704s)]]
]
[table Operator +(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.07187 (0.0177151s)][2.3005 (0.0241089s)][1.81397 (0.0297836s)][1.72202 (0.046594s)]]
[[mpq_rational][[*1] (0.0085503s)][[*1] (0.0104799s)][[*1] (0.016419s)][[*1] (0.0270577s)]]
]
[table Operator +(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.2805 (0.0265647s)][1.59353 (0.0391054s)][1.26613 (0.044067s)][1.95307 (0.105801s)]]
[[mpq_rational][[*1] (0.0207456s)][[*1] (0.0245401s)][[*1] (0.0348044s)][[*1] (0.0541719s)]]
]
[table Operator +=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][7.29749 (0.0565983s)][3.77253 (0.0371419s)][2.72128 (0.0556987s)][2.01495 (0.0662456s)]]
[[mpq_rational][[*1] (0.00775585s)][[*1] (0.00984535s)][[*1] (0.0204678s)][[*1] (0.032877s)]]
]
[table Operator +=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.92025 (0.0335896s)][2.08321 (0.0422867s)][1.587 (0.0564267s)][1.85357 (0.0840696s)]]
[[mpq_rational][[*1] (0.0174923s)][[*1] (0.0202988s)][[*1] (0.0355556s)][[*1] (0.0453556s)]]
]
[table Operator -
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.38126 (0.471759s)][1.92631 (1.52484s)][1.76181 (3.49648s)][2.03462 (7.71926s)]]
[[mpq_rational][[*1] (0.198113s)][[*1] (0.791584s)][[*1] (1.98459s)][[*1] (3.79396s)]]
]
[table Operator -(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.44447 (0.0292894s)][2.54602 (0.0346718s)][1.4869 (0.035503s)][1.95344 (0.0577029s)]]
[[mpq_rational][[*1] (0.0119819s)][[*1] (0.013618s)][[*1] (0.0238773s)][[*1] (0.0295391s)]]
]
[table Operator -(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.93654 (0.0296698s)][4.23087 (0.0496956s)][1.68041 (0.0461985s)][1.4455 (0.0581714s)]]
[[mpq_rational][[*1] (0.0101037s)][[*1] (0.0117459s)][[*1] (0.0274924s)][[*1] (0.040243s)]]
]
[table Operator -(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.69242 (0.0408789s)][1.5205 (0.0467416s)][1.31525 (0.0548939s)][2.16115 (0.103471s)]]
[[mpq_rational][[*1] (0.0241541s)][[*1] (0.030741s)][[*1] (0.0417365s)][[*1] (0.0478777s)]]
]
[table Operator -=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][3.69509 (0.0366534s)][3.7306 (0.0439181s)][1.8352 (0.0491612s)][1.86662 (0.071761s)]]
[[mpq_rational][[*1] (0.00991947s)][[*1] (0.0117724s)][[*1] (0.0267879s)][[*1] (0.0384444s)]]
]
[table Operator -=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.76299 (0.0421283s)][2.03803 (0.0490152s)][1.84864 (0.053198s)][2.10533 (0.0881228s)]]
[[mpq_rational][[*1] (0.023896s)][[*1] (0.0240502s)][[*1] (0.0287769s)][[*1] (0.041857s)]]
]
[table Operator /
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][2.03433 (2.28881s)][2.24309 (6.34454s)][2.1203 (13.2036s)][2.36142 (29.3236s)]]
[[mpq_rational][[*1] (1.12509s)][[*1] (2.82848s)][[*1] (6.22726s)][[*1] (12.4178s)]]
]
[table Operator /(int)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.035134s)][1.08556 (0.0774619s)][1.08797 (0.104628s)][1.29134 (0.207067s)]]
[[mpq_rational][1.85049 (0.0650149s)][[*1] (0.0713565s)][[*1] (0.0961679s)][[*1] (0.16035s)]]
]
[table Operator /(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.31397 (0.170727s)][1.63747 (0.216019s)][1.68581 (0.292536s)][1.76695 (0.435259s)]]
[[mpq_rational][[*1] (0.129932s)][[*1] (0.131923s)][[*1] (0.173528s)][[*1] (0.246334s)]]
]
[table Operator /(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.82473 (0.431612s)][2.20261 (0.596248s)][2.45848 (0.809662s)][3.88675 (1.38001s)]]
[[mpq_rational][[*1] (0.236534s)][[*1] (0.270701s)][[*1] (0.329335s)][[*1] (0.355055s)]]
]
[table Operator /=(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.58868 (0.216252s)][1.71288 (0.235781s)][1.78218 (0.314161s)][1.98715 (0.460033s)]]
[[mpq_rational][[*1] (0.136121s)][[*1] (0.137652s)][[*1] (0.176279s)][[*1] (0.231505s)]]
]
[table Operator /=(value_type)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][1.72896 (0.40369s)][2.55949 (0.689514s)][2.4929 (0.832288s)][3.51238 (1.37478s)]]
[[mpq_rational][[*1] (0.233487s)][[*1] (0.269395s)][[*1] (0.333863s)][[*1] (0.391409s)]]
]
[table Operator construct
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.0135822s)][[*1] (0.00935293s)][[*1] (0.0083784s)][[*1] (0.00962697s)]]
[[mpq_rational][1.44264 (0.0195942s)][2.18249 (0.0204126s)][2.64725 (0.0221797s)][2.87767 (0.0277033s)]]
]
[table Operator construct(unsigned long long)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.00806026s)][[*1] (0.00960336s)][[*1] (0.00769898s)][[*1] (0.0176689s)]]
[[mpq_rational][4.87225 (0.0392716s)][5.91987 (0.0568506s)][9.03811 (0.0695842s)][3.68339 (0.0650815s)]]
]
[table Operator construct(unsigned)
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][[*1] (0.00672081s)][[*1] (0.0064826s)][[*1] (0.00618635s)][[*1] (0.00923644s)]]
[[mpq_rational][6.47138 (0.0434929s)][7.48645 (0.0485316s)][8.2942 (0.0513108s)][5.77363 (0.0533278s)]]
]
[table Operator str
[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
[[cpp_rational][6.17439 (0.00168424s)][7.6748 (0.0033367s)][6.38435 (0.00662873s)][9.07696 (0.0174979s)]]
[[mpq_rational][[*1] (0.000272779s)][[*1] (0.000434761s)][[*1] (0.00103828s)][[*1] (0.00192772s)]]
]
[endsect]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test01.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"

void test01()
{
#ifdef TEST_INT64
   test<std::uint64_t>("std::uint64_t", 64);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test02.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPF)
#include <boost/multiprecision/gmp.hpp>
#endif

void test02()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float_50>("gmp_float", 50);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test03.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPF)
#include <boost/multiprecision/gmp.hpp>
#endif

void test03()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float_100>("gmp_float", 100);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test04.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPF)
#include <boost/multiprecision/gmp.hpp>
#endif

void test04()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float_500>("gmp_float", 500);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test05.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test05()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test06.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test06()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test07.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test07()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test08.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test08()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 1024);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test09.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test09()
{
#ifdef TEST_CPP_INT
   //test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(unsigned, fixed)", 64);
   //test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(fixed)", 64);
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<128, 128, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(fixed)", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test10()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(fixed)", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test11()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 512, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(fixed)", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test12()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<1024, 1024, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>, boost::multiprecision::et_off> >("cpp_int(fixed)", 1024);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test13.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test13()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test14.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test14()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test15.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test15()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test16.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test16()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 1024);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test17.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT_RATIONAL)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test17()
{
#ifdef TEST_CPP_INT_RATIONAL
   test<boost::multiprecision::cpp_rational>("cpp_rational", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test18.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT_RATIONAL)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test18()
{
#ifdef TEST_CPP_INT_RATIONAL
   test<boost::multiprecision::cpp_rational>("cpp_rational", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test19.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT_RATIONAL)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test19()
{
#ifdef TEST_CPP_INT_RATIONAL
   test<boost::multiprecision::cpp_rational>("cpp_rational", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test20.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT_RATIONAL)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test20()
{
#ifdef TEST_CPP_INT_RATIONAL
   test<boost::multiprecision::cpp_rational>("cpp_rational", 1024);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test21.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test21()
{
#ifdef TEST_MPQ
   test<boost::multiprecision::mpq_rational>("mpq_rational", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test22.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test22()
{
#ifdef TEST_MPQ
   test<boost::multiprecision::mpq_rational>("mpq_rational", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test23.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test23()
{
#ifdef TEST_MPQ
   test<boost::multiprecision::mpq_rational>("mpq_rational", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test24.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test24()
{
#ifdef TEST_MPQ
   test<boost::multiprecision::mpq_rational>("mpq_rational", 1024);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test25.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test25()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 128);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test26.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test26()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 256);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test27.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test27()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 512);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test28.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test28()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 1024);
   /*
   //
   // These are actually too slow to test!!!
   //
   test<boost::multiprecision::tom_rational>("tom_rational", 128);
   test<boost::multiprecision::tom_rational>("tom_rational", 256);
   test<boost::multiprecision::tom_rational>("tom_rational", 512);
   test<boost::multiprecision::tom_rational>("tom_rational", 1024);
   */
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test29.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

void test29()
{
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>("cpp_dec_float", 50);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test30.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

void test30()
{
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_100>("cpp_dec_float", 100);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test31.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

void test31()
{
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<500> > >("cpp_dec_float", 500);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test32.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

void test32()
{
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>("cpp_bin_float", 50);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test33.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

void test33()
{
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_100>("cpp_bin_float", 100);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test34.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

void test34()
{
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<500> > >("cpp_bin_float", 500);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test35.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif

void test35()
{
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_50>("mpfr_float", 50);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test36.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif

void test36()
{
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_50>("mpfr_float", 50);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test37.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif

void test37()
{
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_100>("mpfr_float", 100);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test38.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif

void test38()
{
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_500>("mpfr_float", 500);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test39.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test39()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 1024*2);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test40.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test40()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 1024*4);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test41.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test41()
{
#if defined(TEST_CPP_INT) && defined(TEST_KARATSUBA)
   test<boost::multiprecision::cpp_int>("cpp_int", (boost::multiprecision::backends::karatsuba_cutoff + 2) * sizeof(boost::multiprecision::limb_type) * CHAR_BIT);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test42.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test42()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 1024 * 2);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test43.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test43()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 1024*2);
   /*
   //
   // These are actually too slow to test!!!
   //
   test<boost::multiprecision::tom_rational>("tom_rational", 128);
   test<boost::multiprecision::tom_rational>("tom_rational", 256);
   test<boost::multiprecision::tom_rational>("tom_rational", 512);
   test<boost::multiprecision::tom_rational>("tom_rational", 1024);
   */
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test44.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test44()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 1024*4);
   /*
   //
   // These are actually too slow to test!!!
   //
   test<boost::multiprecision::tom_rational>("tom_rational", 128);
   test<boost::multiprecision::tom_rational>("tom_rational", 256);
   test<boost::multiprecision::tom_rational>("tom_rational", 512);
   test<boost::multiprecision::tom_rational>("tom_rational", 1024);
   */
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test45.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test45()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 1024 * 4);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test46.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test46()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 1024 * 8);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test47.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_CPP_INT)
#include <boost/multiprecision/cpp_int.hpp>
#endif

void test47()
{
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>("cpp_int", 1024 * 16);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test48.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test48()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 1024*8);
   /*
   //
   // These are actually too slow to test!!!
   //
   test<boost::multiprecision::tom_rational>("tom_rational", 128);
   test<boost::multiprecision::tom_rational>("tom_rational", 256);
   test<boost::multiprecision::tom_rational>("tom_rational", 512);
   test<boost::multiprecision::tom_rational>("tom_rational", 1024);
   */
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test49.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif

void test49()
{
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>("tommath_int", 1024*16);
   /*
   //
   // These are actually too slow to test!!!
   //
   test<boost::multiprecision::tom_rational>("tom_rational", 128);
   test<boost::multiprecision::tom_rational>("tom_rational", 256);
   test<boost::multiprecision::tom_rational>("tom_rational", 512);
   test<boost::multiprecision::tom_rational>("tom_rational", 1024);
   */
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test50.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test50()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 1024*8);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/performance_test_files/test51.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../performance_test.hpp"
#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif

void test51()
{
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>("gmp_int", 1024*16);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_bernoulli_allocations.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>

#include <gmpxx.h>

template <class Integer>
inline Integer factorial(unsigned n)
{
   Integer result = 1;
   for (unsigned k = 1; k <= n; ++k)
      result *= k;
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
inline Rational binomial(unsigned n, unsigned k)
{
   return Rational(factorial<Integer>(n), factorial<Integer>(k) * factorial<Integer>(n - k));
}

inline mpz_class pow(mpz_class i, unsigned p)
{
   mpz_class result;
   mpz_pow_ui(result.get_mpz_t(), i.get_mpz_t(), p);
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
Rational Bernoulli(unsigned m)
{
   Rational result = 0;

   for (unsigned k = 0; k <= m; ++k)
   {
      Rational inner = 0;
      for (unsigned v = 0; v <= k; ++v)
      {
         Rational term = binomial<Rational, Integer>(k, v) * Rational(pow(Integer(v), m), k + 1);
         if (v & 1)
            term = -term;
         inner += term;
      }
      result += inner;
   }
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
static void BM_bernoulli(benchmark::State& state)
{
   int m = state.range(0);
   for (auto _ : state)
   {
      benchmark::DoNotOptimize(Bernoulli<Rational, Integer>(m));
   }
}

unsigned allocation_count = 0;

void* (*alloc_func_ptr)(size_t);
void* (*realloc_func_ptr)(void*, size_t, size_t);
void (*free_func_ptr)(void*, size_t);

void* alloc_func(size_t n)
{
   ++allocation_count;
   return (*alloc_func_ptr)(n);
}

void free_func(void* p, size_t n)
{
   (*free_func_ptr)(p, n);
}

void* realloc_func(void* p, size_t old, size_t n)
{
   ++allocation_count;
   return (*realloc_func_ptr)(p, old, n);
}

unsigned new_count = 0;

void* operator new(std::size_t n) throw(std::bad_alloc)
{
   ++new_count;
   return std::malloc(n);
}
void operator delete(void* p) throw()
{
   std::free(p);
}

void* operator new[](std::size_t n) throw(std::bad_alloc)
{
   ++new_count;
   return std::malloc(n);
}
void operator delete[](void* p) throw()
{
   std::free(p);
}


int main()
{
   using namespace boost::multiprecision;

   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
   mp_set_memory_functions(&alloc_func, &realloc_func, &free_func);

   std::cout << "[table Total Allocation Counts for Bernoulli Number Calculation\n"
      "[[m][cpp_rational][mpq_rational][number<rational_adaptor<gmp_int>>][mpq_class]]\n";

   for (unsigned m = 2; m < 200; m += 2)
   {
      std::cout << "[[" << m << "][";
      new_count = 0;
      Bernoulli<cpp_rational>(m);
      std::cout << new_count << "][";
      allocation_count = 0;
      Bernoulli<mpq_rational>(m);
      std::cout << allocation_count << "][";
      allocation_count = 0;
      Bernoulli<number<rational_adaptor<gmp_int>>>(m);
      std::cout << allocation_count << "][";
      allocation_count = 0;
      Bernoulli<mpq_class, mpz_class>(m);
      std::cout << allocation_count << "]]\n";
   }

   std::cout << "]\n";
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_bernoulli_allocations.log
================================================
[table Total Allocation Counts for Bernoulli Number Calculation
[[m][cpp_rational][mpq_rational][number<rational_adaptor<gmp_int>>][mpq_class]]
[[2][0][77][123][101]]
[[4][0][187][320][252]]
[[6][0][345][612][471]]
[[8][0][551][988][758]]
[[10][0][805][1464][1113]]
[[12][0][1107][2044][1536]]
[[14][0][1457][2698][2027]]
[[16][0][1857][3458][2587]]
[[18][0][2336][4320][3216]]
[[20][0][2885][5297][3913]]
[[22][6][3511][6358][4706]]
[[24][22][4203][7601][5600]]
[[26][83][4963][8911][6575]]
[[28][377][5806][10370][7632]]
[[30][780][6738][11947][8769]]
[[32][1454][7771][13644][9988]]
[[34][2001][9357][15947][11289]]
[[36][2789][10598][18023][12704]]
[[38][3669][11948][20185][14252]]
[[40][4653][13403][22538][15891]]
[[42][5923][14976][24990][17620]]
[[44][7379][16622][27596][19449]]
[[46][8839][18367][30287][21367]]
[[48][10296][20227][33295][23431]]
[[50][12045][22857][36898][25646]]
[[52][13603][25044][40220][27962]]
[[54][15276][27331][43755][30389]]
[[56][17239][29749][47410][32919]]
[[58][19337][32257][51151][35552]]
[[60][21409][34958][55308][38417]]
[[62][23694][37800][59426][41396]]
[[64][27923][39556][62540][44498]]
[[66][30240][44706][69096][47711]]
[[68][32566][47934][73872][51042]]
[[70][35019][51417][78779][54637]]
[[72][37460][55047][84163][58363]]
[[74][40282][58777][89439][62211]]
[[76][42914][62691][95055][66183]]
[[78][45752][66694][100709][70296]]
[[80][48681][70905][106834][74620]]
[[82][51986][77633][115045][79160]]
[[84][54855][82364][121949][83842]]
[[86][59032][87239][128670][88659]]
[[88][63595][92256][135592][93618]]
[[90][68352][97486][142665][98820]]
[[92][72446][102974][150380][104256]]
[[94][76468][108620][158006][109844]]
[[96][80361][111109][162765][115594]]
[[98][84783][121460][174932][121486]]
[[100][89044][127730][183611][127633]]
[[102][93561][134241][192393][134050]]
[[104][98452][140919][201349][140616]]
[[106][103530][147763][210413][147364]]
[[108][108326][154804][220168][154276]]
[[110][113891][162184][229824][161562]]
[[112][119213][169736][239900][169038]]
[[114][124770][182417][255032][176693]]
[[116][130624][190589][265966][184519]]
[[118][137941][198975][276703][192525]]
[[120][144829][207759][288645][200952]]
[[122][152045][216736][300007][209561]]
[[124][158610][225905][311860][218371]]
[[126][165383][235283][323744][227360]]
[[128][173971][230678][322303][236670]]
[[130][181696][248593][342618][246308]]
[[132][189310][258615][356021][256148]]
[[134][197708][268800][369164][266192]]
[[136][205800][279215][382459][276436]]
[[138][212940][290112][396424][287167]]
[[140][217502][301235][410903][298101]]
[[142][223486][312564][425431][309243]]
[[144][229579][324133][440945][320605]]
[[146][237213][344671][464320][332333]]
[[148][248799][357200][479845][344420]]
[[150][261345][369947][495567][356745]]
[[152][272741][382909][512422][369279]]
[[154][283982][396162][528719][382048]]
[[156][293626][409993][546804][395353]]
[[158][304036][424022][564050][408907]]
[[160][313869][427747][571797][422690]]
[[162][323626][454723][601473][436715]]
[[164][333294][469863][620894][451304]]
[[166][343072][485238][639579][466149]]
[[168][352236][500922][659464][481221]]
[[170][362793][516840][678534][496561]]
[[172][372645][533169][698760][512315]]
[[174][382908][549962][719939][528510]]
[[176][392507][567018][741432][544947]]
[[178][404163][597694][775274][561666]]
[[180][417539][615615][797960][578647]]
[[182][432009][634079][819557][596234]]
[[184][444684][652902][842915][614114]]
[[186][457104][672042][866413][632248]]
[[188][469331][691451][890093][650654]]
[[190][481583][711512][913753][669753]]
[[192][477225][698188][905638][689111]]
[[194][488955][736905][948365][708760]]
[[196][499797][757502][973031][728675]]
[[198][511163][778591][998650][749102]]
]


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_bernoulli_bench.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>

#include <gmpxx.h>

template <class Integer>
inline Integer factorial(unsigned n)
{
   Integer result = 1;
   for (unsigned k = 1; k <= n; ++k)
      result *= k;
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
inline Rational binomial(unsigned n, unsigned k)
{
   return Rational(factorial<Integer>(n), factorial<Integer>(k) * factorial<Integer>(n - k));
}

inline mpz_class pow(mpz_class i, unsigned p)
{
   mpz_class result;
   mpz_pow_ui(result.get_mpz_t(), i.get_mpz_t(), p);
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
Rational Bernoulli(unsigned m)
{
   Rational result = 0;

   for (unsigned k = 0; k <= m; ++k)
   {
      Rational inner = 0;
      for (unsigned v = 0; v <= k; ++v)
      {
         Rational term = binomial<Rational, Integer>(k, v) * Rational(pow(Integer(v), m), k + 1);
         if (v & 1)
            term = -term;
         inner += term;
      }
      result += inner;
   }
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
static void BM_bernoulli(benchmark::State& state)
{
   int m = state.range(0);
   for (auto _ : state)
   {
      benchmark::DoNotOptimize(Bernoulli<Rational, Integer>(m));
   }
}


BENCHMARK_TEMPLATE(BM_bernoulli, boost::multiprecision::cpp_rational)->DenseRange(50, 200, 4);
BENCHMARK_TEMPLATE(BM_bernoulli, boost::multiprecision::mpq_rational)->DenseRange(50, 200, 4);
BENCHMARK_TEMPLATE(BM_bernoulli, boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >)->DenseRange(50, 200, 4);
BENCHMARK_TEMPLATE(BM_bernoulli, mpq_class, mpz_class)->DenseRange(50, 200, 4);

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_bernoulli_bench.log
================================================
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Benchmark                                                                                                                          Time             CPU   Iterations
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
BM_bernoulli<boost::multiprecision::cpp_rational>/50                                                                         1888495 ns      1888453 ns          354
BM_bernoulli<boost::multiprecision::cpp_rational>/54                                                                         2250552 ns      2250503 ns          294
BM_bernoulli<boost::multiprecision::cpp_rational>/58                                                                         2734589 ns      2734527 ns          246
BM_bernoulli<boost::multiprecision::cpp_rational>/62                                                                         3318196 ns      3318122 ns          206
BM_bernoulli<boost::multiprecision::cpp_rational>/66                                                                         3887371 ns      3887281 ns          166
BM_bernoulli<boost::multiprecision::cpp_rational>/70                                                                         4628631 ns      4628535 ns          135
BM_bernoulli<boost::multiprecision::cpp_rational>/74                                                                         5354148 ns      5354100 ns          131
BM_bernoulli<boost::multiprecision::cpp_rational>/78                                                                         6321412 ns      6321172 ns          111
BM_bernoulli<boost::multiprecision::cpp_rational>/82                                                                         7130681 ns      7130520 ns           99
BM_bernoulli<boost::multiprecision::cpp_rational>/86                                                                         8390270 ns      8390095 ns           77
BM_bernoulli<boost::multiprecision::cpp_rational>/90                                                                        10621849 ns     10621760 ns           70
BM_bernoulli<boost::multiprecision::cpp_rational>/94                                                                        11364659 ns     11364409 ns           64
BM_bernoulli<boost::multiprecision::cpp_rational>/98                                                                        14031215 ns     14030636 ns           53
BM_bernoulli<boost::multiprecision::cpp_rational>/102                                                                       15269101 ns     15268211 ns           50
BM_bernoulli<boost::multiprecision::cpp_rational>/106                                                                       15253625 ns     15253028 ns           44
BM_bernoulli<boost::multiprecision::cpp_rational>/110                                                                       17638148 ns     17637756 ns           42
BM_bernoulli<boost::multiprecision::cpp_rational>/114                                                                       18335439 ns     18335007 ns           37
BM_bernoulli<boost::multiprecision::cpp_rational>/118                                                                       21044600 ns     21044146 ns           33
BM_bernoulli<boost::multiprecision::cpp_rational>/122                                                                       23713449 ns     23712950 ns           29
BM_bernoulli<boost::multiprecision::cpp_rational>/126                                                                       25994484 ns     25993901 ns           26
BM_bernoulli<boost::multiprecision::cpp_rational>/130                                                                       30173460 ns     30172780 ns           25
BM_bernoulli<boost::multiprecision::cpp_rational>/134                                                                       43993250 ns     43992333 ns           15
BM_bernoulli<boost::multiprecision::cpp_rational>/138                                                                       40704613 ns     40702777 ns           16
BM_bernoulli<boost::multiprecision::cpp_rational>/142                                                                       47015864 ns     47014950 ns           13
BM_bernoulli<boost::multiprecision::cpp_rational>/146                                                                       51469463 ns     51468592 ns           10
BM_bernoulli<boost::multiprecision::cpp_rational>/150                                                                       70737464 ns     70736106 ns            8
BM_bernoulli<boost::multiprecision::cpp_rational>/154                                                                       74904669 ns     74638691 ns            8
BM_bernoulli<boost::multiprecision::cpp_rational>/158                                                                       76644012 ns     76642396 ns           10
BM_bernoulli<boost::multiprecision::cpp_rational>/162                                                                      104915811 ns    104906795 ns            7
BM_bernoulli<boost::multiprecision::cpp_rational>/166                                                                      108178263 ns    108175914 ns            7
BM_bernoulli<boost::multiprecision::cpp_rational>/170                                                                      125366340 ns    125363885 ns            5
BM_bernoulli<boost::multiprecision::cpp_rational>/174                                                                      119816144 ns    119813754 ns            5
BM_bernoulli<boost::multiprecision::cpp_rational>/178                                                                      130675436 ns    130672631 ns            6
BM_bernoulli<boost::multiprecision::cpp_rational>/182                                                                      136007472 ns    136002124 ns            6
BM_bernoulli<boost::multiprecision::cpp_rational>/186                                                                      152172095 ns    152169271 ns            4
BM_bernoulli<boost::multiprecision::cpp_rational>/190                                                                      149450814 ns    149444035 ns            4
BM_bernoulli<boost::multiprecision::cpp_rational>/194                                                                      149612169 ns    149609183 ns            4
BM_bernoulli<boost::multiprecision::cpp_rational>/198                                                                      167597787 ns    167594528 ns            4
BM_bernoulli<boost::multiprecision::mpq_rational>/50                                                                         3270409 ns      3270343 ns          224
BM_bernoulli<boost::multiprecision::mpq_rational>/54                                                                         4844123 ns      4842950 ns          188
BM_bernoulli<boost::multiprecision::mpq_rational>/58                                                                         6032271 ns      6031493 ns          137
BM_bernoulli<boost::multiprecision::mpq_rational>/62                                                                         8356124 ns      8355959 ns           76
BM_bernoulli<boost::multiprecision::mpq_rational>/66                                                                         9433065 ns      9431740 ns           74
BM_bernoulli<boost::multiprecision::mpq_rational>/70                                                                         9144751 ns      9144294 ns           70
BM_bernoulli<boost::multiprecision::mpq_rational>/74                                                                         9130475 ns      9130309 ns           61
BM_bernoulli<boost::multiprecision::mpq_rational>/78                                                                        10537362 ns     10537142 ns           66
BM_bernoulli<boost::multiprecision::mpq_rational>/82                                                                        12613844 ns     12613249 ns           63
BM_bernoulli<boost::multiprecision::mpq_rational>/86                                                                        13630412 ns     13630144 ns           52
BM_bernoulli<boost::multiprecision::mpq_rational>/90                                                                        17308942 ns     17307564 ns           40
BM_bernoulli<boost::multiprecision::mpq_rational>/94                                                                        17941604 ns     17940817 ns           33
BM_bernoulli<boost::multiprecision::mpq_rational>/98                                                                        17702116 ns     17701739 ns           30
BM_bernoulli<boost::multiprecision::mpq_rational>/102                                                                       24652890 ns     24651531 ns           27
BM_bernoulli<boost::multiprecision::mpq_rational>/106                                                                       28959599 ns     28958456 ns           25
BM_bernoulli<boost::multiprecision::mpq_rational>/110                                                                       32250123 ns     32248791 ns           24
BM_bernoulli<boost::multiprecision::mpq_rational>/114                                                                       33049744 ns     33036651 ns           18
BM_bernoulli<boost::multiprecision::mpq_rational>/118                                                                       43063349 ns     43060565 ns           16
BM_bernoulli<boost::multiprecision::mpq_rational>/122                                                                       47526128 ns     47524442 ns           19
BM_bernoulli<boost::multiprecision::mpq_rational>/126                                                                       51732892 ns     51732056 ns           10
BM_bernoulli<boost::multiprecision::mpq_rational>/130                                                                       57019065 ns     57018140 ns           10
BM_bernoulli<boost::multiprecision::mpq_rational>/134                                                                       53774927 ns     53774090 ns           10
BM_bernoulli<boost::multiprecision::mpq_rational>/138                                                                       55161523 ns     55157578 ns           11
BM_bernoulli<boost::multiprecision::mpq_rational>/142                                                                       67521287 ns     67520101 ns            9
BM_bernoulli<boost::multiprecision::mpq_rational>/146                                                                       73495897 ns     73492888 ns           11
BM_bernoulli<boost::multiprecision::mpq_rational>/150                                                                       96401524 ns     96399781 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/154                                                                       93370021 ns     93368470 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/158                                                                      102579919 ns    102575818 ns            8
BM_bernoulli<boost::multiprecision::mpq_rational>/162                                                                      122980914 ns    122978722 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/166                                                                      100311142 ns    100309423 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/170                                                                      101722324 ns    101720320 ns            7
BM_bernoulli<boost::multiprecision::mpq_rational>/174                                                                      116791305 ns    116789020 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/178                                                                      118186160 ns    118184175 ns            5
BM_bernoulli<boost::multiprecision::mpq_rational>/182                                                                      113692224 ns    113690229 ns            5
BM_bernoulli<boost::multiprecision::mpq_rational>/186                                                                      120508668 ns    120506323 ns            6
BM_bernoulli<boost::multiprecision::mpq_rational>/190                                                                      124836662 ns    124834484 ns            5
BM_bernoulli<boost::multiprecision::mpq_rational>/194                                                                      133126053 ns    133123581 ns            5
BM_bernoulli<boost::multiprecision::mpq_rational>/198                                                                      149959513 ns    149954105 ns            5
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/50     3290599 ns      3290466 ns          247
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/54     3829254 ns      3829119 ns          189
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/58     5026638 ns      5026546 ns          144
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/62     6338415 ns      6338287 ns          133
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/66     7401079 ns      7400940 ns          112
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/70     8056058 ns      8055920 ns           76
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/74     8688736 ns      8688407 ns           78
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/78     9168196 ns      9168029 ns           77
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/82    10547763 ns     10547404 ns           72
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/86    12687317 ns     12686717 ns           60
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/90    14583805 ns     14583533 ns           53
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/94    17533114 ns     17532466 ns           45
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/98    17795979 ns     17795666 ns           37
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/102   20905344 ns     20904910 ns           37
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/106   24965679 ns     24965242 ns           27
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/110   26153986 ns     26153512 ns           27
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/114   27283324 ns     27282865 ns           24
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/118   30932112 ns     30931542 ns           21
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/122   31709907 ns     31708366 ns           20
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/126   37541157 ns     37539799 ns           19
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/130   47600868 ns     47599791 ns           17
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/134   56589653 ns     56565174 ns           12
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/138   61844701 ns     61840208 ns            9
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/142   62854330 ns     62836747 ns           11
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/146   65305525 ns     65301664 ns            9
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/150   71840692 ns     71806806 ns            8
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/154   86537227 ns     86535425 ns            6
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/158   84476111 ns     84435425 ns            7
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/162   95187582 ns     95163676 ns            6
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/166  116436468 ns    116426811 ns            5
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/170  130978409 ns    130952717 ns            6
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/174  159328406 ns    159282156 ns            4
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/178  170187772 ns    170133406 ns            3
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/182  184317854 ns    184265450 ns            3
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/186  232363854 ns    232345590 ns            3
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/190  156385849 ns    156352248 ns            5
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/194  250575336 ns    250276632 ns            3
BM_bernoulli<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> >>/198  234528878 ns    234451241 ns            4
BM_bernoulli<mpq_class, mpz_class>/50                                                                                        3576313 ns      3575669 ns          166
BM_bernoulli<mpq_class, mpz_class>/54                                                                                        5617333 ns      5611911 ns          143
BM_bernoulli<mpq_class, mpz_class>/58                                                                                        5434013 ns      5432617 ns           93
BM_bernoulli<mpq_class, mpz_class>/62                                                                                        7520189 ns      7519819 ns           84
BM_bernoulli<mpq_class, mpz_class>/66                                                                                       10063667 ns     10061634 ns           84
BM_bernoulli<mpq_class, mpz_class>/70                                                                                       11741489 ns     11741278 ns           43
BM_bernoulli<mpq_class, mpz_class>/74                                                                                       12503901 ns     12499604 ns           48
BM_bernoulli<mpq_class, mpz_class>/78                                                                                       12891372 ns     12889086 ns           45
BM_bernoulli<mpq_class, mpz_class>/82                                                                                       14146644 ns     14145407 ns           36
BM_bernoulli<mpq_class, mpz_class>/86                                                                                       13244909 ns     13244178 ns           46
BM_bernoulli<mpq_class, mpz_class>/90                                                                                       16761246 ns     16760132 ns           45
BM_bernoulli<mpq_class, mpz_class>/94                                                                                       17757867 ns     17745522 ns           38
BM_bernoulli<mpq_class, mpz_class>/98                                                                                       20767614 ns     20764969 ns           34
BM_bernoulli<mpq_class, mpz_class>/102                                                                                      24630855 ns     24625094 ns           28
BM_bernoulli<mpq_class, mpz_class>/106                                                                                      27775007 ns     27770111 ns           24
BM_bernoulli<mpq_class, mpz_class>/110                                                                                      29217021 ns     29207281 ns           23
BM_bernoulli<mpq_class, mpz_class>/114                                                                                      33637566 ns     33632317 ns           20
BM_bernoulli<mpq_class, mpz_class>/118                                                                                      38106044 ns     38104497 ns           19
BM_bernoulli<mpq_class, mpz_class>/122                                                                                      40618000 ns     40614832 ns           17
BM_bernoulli<mpq_class, mpz_class>/126                                                                                      44129039 ns     44122736 ns           15
BM_bernoulli<mpq_class, mpz_class>/130                                                                                      49499438 ns     49498465 ns           12
BM_bernoulli<mpq_class, mpz_class>/134                                                                                      53824996 ns     53815652 ns           11
BM_bernoulli<mpq_class, mpz_class>/138                                                                                      60739365 ns     60731483 ns           11
BM_bernoulli<mpq_class, mpz_class>/142                                                                                      65850315 ns     65847652 ns            9
BM_bernoulli<mpq_class, mpz_class>/146                                                                                      72453391 ns     72427755 ns            9
BM_bernoulli<mpq_class, mpz_class>/150                                                                                      87085907 ns     87071159 ns            7
BM_bernoulli<mpq_class, mpz_class>/154                                                                                      95887543 ns     95881314 ns            6
BM_bernoulli<mpq_class, mpz_class>/158                                                                                      96230949 ns     96228927 ns            7
BM_bernoulli<mpq_class, mpz_class>/162                                                                                     106197691 ns    106177472 ns            6
BM_bernoulli<mpq_class, mpz_class>/166                                                                                     134945572 ns    134925799 ns            5
BM_bernoulli<mpq_class, mpz_class>/170                                                                                     142289415 ns    142283919 ns            4
BM_bernoulli<mpq_class, mpz_class>/174                                                                                     187878516 ns    187842807 ns            5
BM_bernoulli<mpq_class, mpz_class>/178                                                                                     210256150 ns    210241919 ns            3
BM_bernoulli<mpq_class, mpz_class>/182                                                                                     179176686 ns    179169030 ns            3
BM_bernoulli<mpq_class, mpz_class>/186                                                                                     205849055 ns    205787179 ns            3
BM_bernoulli<mpq_class, mpz_class>/190                                                                                     217773129 ns    217763972 ns            3
BM_bernoulli<mpq_class, mpz_class>/194                                                                                     241406118 ns    241358945 ns            3
BM_bernoulli<mpq_class, mpz_class>/198                                                                                     222322076 ns    222307749 ns            3


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_determinant_bench.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <vector>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>

#include <boost/math/special_functions/prime.hpp>
#include <boost/math/special_functions/pow.hpp>

#include <gmpxx.h>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
const std::vector<std::vector<T> >& get_matrix_data(unsigned bits);

template <>
const std::vector<std::vector<boost::multiprecision::cpp_rational> >& get_matrix_data(unsigned bits)
{
   static std::map<unsigned, std::vector<std::vector<boost::multiprecision::cpp_rational> > > data;
   if (data[bits].size() == 0)
   {
      for (unsigned i = 0; i < 100; ++i)
      {
         std::vector<boost::multiprecision::cpp_rational> matrix;
         for (unsigned j = 0; j < 9; ++j)
         {
            boost::multiprecision::cpp_int a(generate_random<boost::multiprecision::cpp_int>(bits)), b(generate_random<boost::multiprecision::cpp_int>(bits));
            matrix.push_back(boost::multiprecision::cpp_rational(a, b));
         }
         data[bits].push_back(matrix);
      }
   }
   return data[bits];
}

template <class T>
const std::vector<std::vector<T> >& get_matrix_data(unsigned bits)
{
   static std::map<unsigned, std::vector<std::vector<T> > > data;
   if (data[bits].empty())
   {
      const std::vector<std::vector<boost::multiprecision::cpp_rational> >& d = get_matrix_data<boost::multiprecision::cpp_rational>(bits);
      for (unsigned i = 0; i < 100; ++i)
      {
         std::vector<T> matrix;
         for (unsigned j = 0; j < 9; ++j)
         {
            matrix.push_back(T(d[i][j].str()));
         }
         data[bits].push_back(matrix);
      }
   }
   return data[bits];
}

template <class T>
T determinant(const std::vector<T>& data)
{
   const T m01 = data[0] * data[4] - data[3] * data[1];
   const T m02 = data[0] * data[7] - data[6] * data[1];
   const T m12 = data[3] * data[7] - data[6] * data[4];
   return m01 * data[8] - m02 * data[5] + m12 * data[2];
}

template <class Rational>
static void BM_determinant(benchmark::State& state)
{
   int                         bits = state.range(0);
   const std::vector<std::vector<Rational> >& data = get_matrix_data<Rational>(bits);
   for (auto _ : state)
   {
      for(unsigned i = 0; i < data.size(); ++i)
         benchmark::DoNotOptimize(determinant(data[i]));
   }
}


constexpr unsigned lower_range = 512;
constexpr unsigned upper_range = 1 << 15;

BENCHMARK_TEMPLATE(BM_determinant, boost::multiprecision::cpp_rational)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(BM_determinant, boost::multiprecision::mpq_rational)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(BM_determinant, mpq_class)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond);

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_determinant_bench.log
================================================
----------------------------------------------------------------------------------------------------
Benchmark                                                          Time             CPU   Iterations
----------------------------------------------------------------------------------------------------
BM_determinant<boost::multiprecision::cpp_rational>/512         45.0 ms         45.0 ms           15
BM_determinant<boost::multiprecision::cpp_rational>/1024         103 ms          103 ms            6
BM_determinant<boost::multiprecision::cpp_rational>/2048         251 ms          251 ms            3
BM_determinant<boost::multiprecision::cpp_rational>/4096         667 ms          667 ms            1
BM_determinant<boost::multiprecision::cpp_rational>/8192        2034 ms         2033 ms            1
BM_determinant<boost::multiprecision::cpp_rational>/16384       6424 ms         6423 ms            1
BM_determinant<boost::multiprecision::cpp_rational>/32768      24227 ms        24223 ms            1
BM_determinant<boost::multiprecision::mpq_rational>/512         14.0 ms         14.0 ms           46
BM_determinant<boost::multiprecision::mpq_rational>/1024        31.3 ms         31.3 ms           22
BM_determinant<boost::multiprecision::mpq_rational>/2048        77.5 ms         77.5 ms            9
BM_determinant<boost::multiprecision::mpq_rational>/4096         199 ms          199 ms            4
BM_determinant<boost::multiprecision::mpq_rational>/8192         532 ms          532 ms            1
BM_determinant<boost::multiprecision::mpq_rational>/16384       1515 ms         1515 ms            1
BM_determinant<boost::multiprecision::mpq_rational>/32768       4544 ms         4544 ms            1
BM_determinant<mpq_class>/512                                   14.3 ms         14.3 ms           46
BM_determinant<mpq_class>/1024                                  31.3 ms         31.3 ms           22
BM_determinant<mpq_class>/2048                                  75.6 ms         75.6 ms            9
BM_determinant<mpq_class>/4096                                   193 ms          193 ms            4
BM_determinant<mpq_class>/8192                                   601 ms          601 ms            1
BM_determinant<mpq_class>/16384                                 1965 ms         1965 ms            1
BM_determinant<mpq_class>/32768                                 4740 ms         4738 ms            1


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/rational_zeta18_bench.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>

#include <boost/math/special_functions/prime.hpp>
#include <boost/math/special_functions/pow.hpp>

#include <gmpxx.h>

template <class Rational, class Integer = typename Rational::value_type>
Rational zeta18()
{
   Rational result = 1;

   for (unsigned i = 0; i < 10; ++i)
   {
      result /= 1 - Rational(1, boost::math::pow<18>(Integer(boost::math::prime(i))));
   }
   return result;
}

template <class Rational, class Integer = typename Rational::value_type>
static void BM_zeta18(benchmark::State& state)
{
   for (auto _ : state)
   {
      benchmark::DoNotOptimize(zeta18<Rational, Integer>());
   }
}


BENCHMARK_TEMPLATE(BM_zeta18, boost::multiprecision::cpp_rational);
BENCHMARK_TEMPLATE(BM_zeta18, boost::multiprecision::mpq_rational);
BENCHMARK_TEMPLATE(BM_zeta18, boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int>>);
BENCHMARK_TEMPLATE(BM_zeta18, mpq_class, mpz_class);

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance-msvc-10.log
================================================
0
11
24
3
13
27
Testing Bessel Functions.....
Time for mpfr_float_50 = 6.47208 seconds
Total allocations for mpfr_float_50 = 2684348
Time for mpf_float_50 = 11.6627 seconds
Total allocations for mpf_float_50 = 2601366
Time for cpp_float_50 = 20.2855 seconds
Total allocations for cpp_float_50 = 0
Time for mpfr_class (50 digits) = 6.48063 seconds
Total allocations for mpfr_class (50 digits) = 3946031
Time for mpreal (50 digits) = 9.98151 seconds
Total allocations for mpreal (50 digits) = 13223017
Time for mpfr_float_100 = 10.154 seconds
Total allocations for mpfr_float_50 = 3671485
Time for mpf_float_100 = 8.51179 seconds
Total allocations for mpf_float_100 = 3593669
Time for cpp_float_100 = 21.0198 seconds
Total allocations for cpp_float_100 = 0
Time for mpfr_class (100 digits) = 9.80571 seconds
Total allocations for mpfr_class (100 digits) = 5447348
Time for mpreal (100 digits) = 13.7021 seconds
Total allocations for mpreal (100 digits) = 16671065
Testing Polynomial Evaluation.....
Time for mpfr_float_50 = 0.00823841 seconds
Total allocations for mpfr_float_50 = 2996
Time for mpf_float_50 = 0.00401608 seconds
Total allocations for mpf_float_50 = 2996
Time for cpp_float_50 = 0.00492116 seconds
Total allocations for cpp_float_50 = 0
Time for mpfr_class (50 digits) = 0.00935629 seconds
Total allocations for mpfr_class (50 digits) = 12976
Time for mpreal (50 digits) = 0.0148374 seconds
Total allocations for mpreal (50 digits = 27947
Time for mpfr_float_100 = 0.00948452 seconds
Total allocations for mpfr_float_100 = 2996
Time for mpf_float_100 = 0.00390071 seconds
Total allocations for mpf_float_100 = 2996
Time for cpp_float_100 = 0.00893563 seconds
Total allocations for cpp_float_100 = 0
Time for mpfr_class (100 digits) = 0.0106166 seconds
Total allocations for mpfr_class (100 digits) = 12976
Time for mpreal (100 digits) = 0.0162364 seconds
Total allocations for mpreal (100 digits) = 27947
Testing Non-Central T.....
Time for mpfr_float_50 = 258.087 seconds
Total allocations for mpfr_float_50 = 139149049
Time for mpf_float_50 = 197.303 seconds
Total allocations for mpf_float_50 = 134600354
Time for cpp_float_50 = 334.503 seconds
Total allocations for cpp_float_50 = 0
Time for mpfr_class (50 digits) = 266.389 seconds
Total allocations for mpfr_class (50 digits) = 252401115
Time for mpreal (50 digits) = 346.641 seconds
Total allocations for mpreal (50 digits) = 447009420
Time for mpfr_float_100 = 516.741 seconds
Total allocations for mpfr_float_100 = 220400854
Time for mpf_float_100 = 397.302 seconds
Total allocations for mpf_float_100 = 212307349
Time for cpp_float_100 = 1064.53 seconds
Total allocations for cpp_float_100 = 0
Time for mpfr_class (100 digits) = 525.74 seconds
Total allocations for mpfr_class (100 digits) = 407154781
Time for mpreal (100 digits) = 649.941 seconds
Total allocations for mpreal (100 digits) = 724581024


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "sf_performance.hpp"

#ifdef __clang__
#if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)
// memory sanitizer is incompatible with this test:
# define DISABLE_THIS_TEST
#endif
#endif

boost::atomic<unsigned>                                                     allocation_count(0);
std::map<std::string, std::map<std::string, std::pair<double, unsigned> > > result_table;

#ifndef DISABLE_THIS_TEST

void* (*alloc_func_ptr)(size_t);
void* (*realloc_func_ptr)(void*, size_t, size_t);
void (*free_func_ptr)(void*, size_t);

void* alloc_func(size_t n)
{
   ++allocation_count;
   return (*alloc_func_ptr)(n);
}

void free_func(void* p, size_t n)
{
   (*free_func_ptr)(p, n);
}

void* realloc_func(void* p, size_t old, size_t n)
{
   ++allocation_count;
   return (*realloc_func_ptr)(p, old, n);
}

void* operator new(std::size_t count)
{
   ++allocation_count;
   return std::malloc(count);
}

void* operator new[](std::size_t count)
{
   ++allocation_count;
   return std::malloc(count);
}

void operator delete(void* ptr)noexcept
{
   std::free(ptr);
}
void operator delete[](void* ptr) noexcept
{
   std::free(ptr);
}

void print_quickbook_tables()
{
   for (auto i = result_table.begin(); i != result_table.end(); ++i)
   {
      std::cout << "[table " << i->first << "\n";
      std::cout << "[[Type][Time][# Allocations]]\n";
      double min_time = (std::numeric_limits<double>::max)();
      for (auto j = i->second.begin(); j != i->second.end(); ++j)
      {
         if (j->second.first < min_time)
            min_time = j->second.first;
      }
      for (auto j = i->second.begin(); j != i->second.end(); ++j)
      {
         double t = j->second.first;
         std::cout << "[[" << j->first << "][" << t / min_time << " (" << t << "s)][" << j->second.second << "]]\n";
      }
      std::cout << "]\n\n";
   }
}

int main()
{
   using namespace boost::multiprecision;

#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS) || defined(TEST_MPREAL) || defined(TEST_MPF)
   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
   mp_set_memory_functions(&alloc_func, &realloc_func, &free_func);
#endif

   basic_tests_1();
   basic_tests_2();
   basic_tests_3();
   basic_tests_4();
   basic_tests_5();
   basic_tests_6();
   basic_tests_7();
   basic_tests_8();
   basic_tests_9();
   bessel_tests();
   poly_tests();
   nct_tests();

   print_quickbook_tables();
}

#else
int main() { return 0; }
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 750
#define BOOST_MATH_PROMOTE_DOUBLE_POLICY false

#if !defined(TEST_MPFR) && !defined(TEST_MPREAL) && !defined(TEST_MPF) && !defined(TEST_MPREAL) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_CLASS) && !defined(TEST_FLOAT) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPFR
#define TEST_MPF
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_BIN_FLOAT
//#  define TEST_MPFR_CLASS
//#  define TEST_MPREAL
#define TEST_FLOAT
#endif

#if defined(TEST_MPFR) && !defined(TEST_MPFR_CLASS)
#if defined(__has_include)
#if __has_include(<gmpfrxx.h>)
#define TEST_MPFR_CLASS
#endif
#endif
#endif

#ifdef TEST_FLOAT
#include "arithmetic_backend.hpp"
#endif
#ifdef TEST_MPFR_CLASS
#include <boost/math/bindings/mpfr.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPREAL
#include <boost/math/bindings/mpreal.hpp>
#endif
#ifdef TEST_MPF
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#include <boost/math/special_functions/bessel.hpp>
#include <boost/math/tools/rational.hpp>
#include <boost/math/distributions/non_central_t.hpp>
#include <libs/math/test/table_type.hpp>
#include <boost/chrono.hpp>
#include <boost/array.hpp>
#include <boost/thread.hpp>
#include <boost/atomic.hpp>

template <class Real>
Real test_bessel();

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

template <class Real>
Real test_bessel()
{
   try
   {
#define T double
#define SC_(x) x
#include "libs/math/test/bessel_i_int_data.ipp"
#include "libs/math/test/bessel_i_data.ipp"

      Real r;

      for (unsigned i = 0; i < bessel_i_int_data.size(); ++i)
      {
         r += boost::math::cyl_bessel_i(Real(bessel_i_int_data[i][0]), Real(bessel_i_int_data[i][1]));
      }
      for (unsigned i = 0; i < bessel_i_data.size(); ++i)
      {
         r += boost::math::cyl_bessel_i(Real(bessel_i_data[i][0]), Real(bessel_i_data[i][1]));
      }

#include "libs/math/test/bessel_j_int_data.ipp"
      for (unsigned i = 0; i < bessel_j_int_data.size(); ++i)
      {
         r += boost::math::cyl_bessel_j(Real(bessel_j_int_data[i][0]), Real(bessel_j_int_data[i][1]));
      }

#include "libs/math/test/bessel_j_data.ipp"
      for (unsigned i = 0; i < bessel_j_data.size(); ++i)
      {
         r += boost::math::cyl_bessel_j(Real(bessel_j_data[i][0]), Real(bessel_j_data[i][1]));
      }

#include "libs/math/test/bessel_j_large_data.ipp"
      for (unsigned i = 0; i < bessel_j_large_data.size(); ++i)
      {
         r += boost::math::cyl_bessel_j(Real(bessel_j_large_data[i][0]), Real(bessel_j_large_data[i][1]));
      }

#include "libs/math/test/sph_bessel_data.ipp"
      for (unsigned i = 0; i < sph_bessel_data.size(); ++i)
      {
         r += boost::math::sph_bessel(static_cast<unsigned>(sph_bessel_data[i][0]), Real(sph_bessel_data[i][1]));
      }

      return r;
   }
   catch (const std::exception& e)
   {
      std::cout << e.what() << std::endl;
   }
   return 0;
}

template <class Real>
Real test_polynomial()
{
   static const unsigned t[] = {
       2, 3, 4, 5, 6, 7, 8};
   Real result = 0;
   for (Real k = 2; k < 1000; ++k)
      result += boost::math::tools::evaluate_polynomial(t, k);

   return result;
}

template <class Real>
Real test_nct()
{
#define T double
#include "libs/math/test/nct.ipp"

   Real result = 0;
   for (unsigned i = 0; i < nct.size(); ++i)
   {
      try
      {
         result += quantile(boost::math::non_central_t_distribution<Real>(nct[i][0], nct[i][1]), nct[i][3]);
         result += cdf(boost::math::non_central_t_distribution<Real>(nct[i][0], nct[i][1]), nct[i][2]);
      }
      catch (const std::exception&)
      {}
   }
   return result;
}

extern boost::atomic<unsigned>                                                     allocation_count;
extern std::map<std::string, std::map<std::string, std::pair<double, unsigned> > > result_table;

template <class Real>
void basic_allocation_test(const char* name, Real x)
{
   static const unsigned a[] = {2, 3, 4, 5, 6, 7, 8};
   allocation_count          = 0;
   Real result               = (((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0];
   std::cout << "Allocation count for type " << name << " = " << allocation_count << std::endl;
}

template <class Real>
void poly_allocation_test(const char* name, Real x)
{
   static const unsigned a[] = {2, 3, 4, 5, 6, 7, 8};
   allocation_count          = 0;
   Real result               = boost::math::tools::evaluate_polynomial(a, x);
   std::cout << "Allocation count for type " << name << " = " << allocation_count << std::endl;
}

template <class Real>
void time_proc(const char* tablename, const char* name, Real (*proc)(), unsigned threads = 1)
{
   try
   {
      static Real total = 0;
      allocation_count  = 0;
      boost::chrono::duration<double>                 time;
      stopwatch<boost::chrono::high_resolution_clock> c;
      total += proc();
      time = c.elapsed();
      std::cout << "Time for " << name << " = " << time << std::endl;
      std::cout << "Total allocations for " << name << " = " << allocation_count << std::endl;

      result_table[tablename][name] = std::make_pair(time.count(), (unsigned)allocation_count);

      if (threads > 1)
      {
         c.reset();
         boost::thread_group g;
         for (unsigned i = 0; i < threads; ++i)
            g.create_thread(proc);
         g.join_all();
         time = c.elapsed();
         std::cout << "Time for " << name << " (" << (threads) << " theads) = " << time << std::endl;
         std::cout << "Total allocations for " << name << " = " << allocation_count << std::endl;

         std::ostringstream ss;
         ss << name << " (" << threads << " concurrent threads)";
         result_table[tablename][ss.str()] = std::make_pair(time.count(), (unsigned)allocation_count);
      }
   }
   catch (const std::exception& e)
   {
      std::cout << e.what() << std::endl;
   }
}

using namespace boost::multiprecision;

void basic_tests_1();
void basic_tests_2();
void basic_tests_3();
void basic_tests_4();
void basic_tests_5();
void basic_tests_6();
void basic_tests_7();
void basic_tests_8();
void basic_tests_9();
void bessel_tests();
void poly_tests();
void nct_tests();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance.log
================================================
Allocation Counts for Horner Evaluation:
Allocation count for type mpfr_float_50 = 3
Allocation count for type mpfr_float_50 - no expression templates = 1
Allocation Counts for boost::math::tools::evaluate_polynomial:
Allocation count for type mpfr_float_50 = 13
Allocation count for type mpfr_float_50 - no expression templates = 9
Time for double = 0.000670234 seconds
Total allocations for double = 14
Time for real_concept = 0.0172589 seconds
Total allocations for real_concept = 0
Time for arithmetic_backend<double> = 0.00172288 seconds
Total allocations for arithmetic_backend<double> = 0
Time for arithmetic_backend<double> - no expression templates = 0.00342056 seconds
Total allocations for arithmetic_backend<double> - no expression templates = 0
Time for double = 0.0573604 seconds
Total allocations for double = 0
Time for real_concept = 0.106877 seconds
Total allocations for real_concept = 0
Time for arithmetic_backend<double> = 0.0958558 seconds
Total allocations for arithmetic_backend<double> = 0
Time for arithmetic_backend<double> - no expression templates = 0.0567841 seconds
Total allocations for arithmetic_backend<double> - no expression templates = 0
Testing Bessel Functions at 50 digits.....
Time for mpfr_float_50 = 0.115838 seconds
Total allocations for mpfr_float_50 = 583054
Time for mpfr_float_50 (3 theads) = 0.149324 seconds
Total allocations for mpfr_float_50 = 2330875
Time for mpfr_float_50 (no expression templates = 0.132073 seconds
Total allocations for mpfr_float_50 (no expression templates = 999594
Time for mpfr_float_50 (no expression templates (3 theads) = 0.185337 seconds
Total allocations for mpfr_float_50 (no expression templates = 4000038
Time for static_mpfr_float_50 = 0.10957 seconds
Total allocations for static_mpfr_float_50 = 22930
Time for static_mpfr_float_50 (3 theads) = 0.128496 seconds
Total allocations for static_mpfr_float_50 = 93139
Time for static_mpfr_float_50 (no expression templates) = 0.106089 seconds
Total allocations for static_mpfr_float_50 (no expression templates) = 46861
Time for static_mpfr_float_50 (no expression templates) (3 theads) = 0.115288 seconds
Total allocations for static_mpfr_float_50 (no expression templates) = 189226
Time for mpf_float_50 = 0.0959515 seconds
Total allocations for mpf_float_50 = 640961
Time for mpf_float_50 (3 theads) = 0.139268 seconds
Total allocations for mpf_float_50 = 2563516
Time for mpf_float_50 (no expression templates = 0.0925745 seconds
Total allocations for mpf_float_50 (no expression templates = 1019039
Time for mpf_float_50 (no expression templates (3 theads) = 0.141131 seconds
Total allocations for mpf_float_50 (no expression templates = 4075841
Time for cpp_dec_float_50 = 0.422285 seconds
Total allocations for cpp_dec_float_50 = 381
Time for cpp_dec_float_50 (3 theads) = 0.524077 seconds
Total allocations for cpp_dec_float_50 = 423
Time for cpp_bin_float_50 = 0.207745 seconds
Total allocations for cpp_bin_float_50 = 399
Time for cpp_bin_float_50 (3 theads) = 0.266594 seconds
Total allocations for cpp_bin_float_50 = 462
Testing Bessel Functions at 100 digits.....
Time for mpfr_float_100 = 0.317635 seconds
Total allocations for mpfr_float_100 = 1236026
Time for mpfr_float_100 (no expression templates = 0.338071 seconds
Total allocations for mpfr_float_100 (no expression templates = 2119472
Time for static_mpfr_float_100 = 0.271907 seconds
Total allocations for static_mpfr_float_100 = 27969
Time for mpf_float_100 = 0.246796 seconds
Total allocations for mpf_float_100 = 1385589
Time for mpf_float_100 (no expression templates = 0.264389 seconds
Total allocations for mpf_float_100 (no expression templates = 2123705
Time for cpp_dec_float_100 = 2.13193 seconds
Total allocations for cpp_dec_float_100 = 6
Time for cpp_bin_float_100 = 0.931753 seconds
Total allocations for cpp_bin_float_100 = 913
Testing Polynomial Evaluation at 50 digits.....
Time for mpfr_float_50 = 0.000770731 seconds
Total allocations for mpfr_float_50 = 12976
Time for mpfr_float_50 (no expression templates = 0.000637226 seconds
Total allocations for mpfr_float_50 (no expression templates = 8984
Time for static_mpfr_float_50 = 0.000645885 seconds
Total allocations for static_mpfr_float_50 = 0
Time for mpf_float_50 = 0.000453308 seconds
Total allocations for mpf_float_50 = 12976
Time for mpf_float_50 (no expression templates = 0.000401807 seconds
Total allocations for mpf_float_50 (no expression templates = 8984
Time for cpp_dec_float_50 = 0.000993151 seconds
Total allocations for cpp_dec_float_50 = 0
Time for cpp_bin_float_50 = 0.000652988 seconds
Total allocations for cpp_bin_float_50 = 0
Testing Polynomial Evaluation at 100 digits.....
Time for mpfr_float_100 = 0.0011754 seconds
Total allocations for mpfr_float_100 = 12976
Time for mpfr_float_100 (no expression templates = 0.00108413 seconds
Total allocations for mpfr_float_100 (no expression templates = 8984
Time for static_mpfr_float_100 = 0.000728305 seconds
Total allocations for static_mpfr_float_100 = 0
Time for mpf_float_100 = 0.000475054 seconds
Total allocations for mpf_float_100 = 12976
Time for mpf_float_100 (no expression templates = 0.000343519 seconds
Total allocations for mpf_float_100 (no expression templates = 8984
Time for cpp_dec_float_100 = 0.00259039 seconds
Total allocations for cpp_dec_float_100 = 0
Time for cpp_bin_float_100 = 0.00239745 seconds
Total allocations for cpp_bin_float_100 = 0
Testing Non-Central T at 50 digits.....
Time for mpfr_float_50 = 19.1749 seconds
Total allocations for mpfr_float_50 = 118401290
Time for mpfr_float_50 (no expression templates = 22.0858 seconds
Total allocations for mpfr_float_50 (no expression templates = 152816346
Time for static_mpfr_float_50 = 16.8686 seconds
Total allocations for static_mpfr_float_50 = 113395
Time for mpf_float_50 = 17.2475 seconds
Total allocations for mpf_float_50 = 123749688
Time for mpf_float_50 (no expression templates = 16.1468 seconds
Total allocations for mpf_float_50 (no expression templates = 152610085
Time for cpp_dec_float_50 = 77.9505 seconds
Total allocations for cpp_dec_float_50 = 0
Time for cpp_bin_float_50 = 38.5842 seconds
Total allocations for cpp_bin_float_50 = 0
Time for cpp_bin_float_50 (3 theads) = 56.6 seconds
Total allocations for cpp_bin_float_50 = 27
Testing Non-Central T at 100 digits.....
Time for mpfr_float_100 = 45.6647 seconds
Total allocations for mpfr_float_100 = 184143656
Time for mpfr_float_100 (no expression templates = 42.8714 seconds
Total allocations for mpfr_float_100 (no expression templates = 237898133
Time for static_mpfr_float_100 = 38.1912 seconds
Total allocations for static_mpfr_float_100 = 131292
Time for mpf_float_100 = 28.4582 seconds
Total allocations for mpf_float_100 = 192516784
Time for mpf_float_100 (no expression templates = 31.2473 seconds
Total allocations for mpf_float_100 (no expression templates = 237462794
Time for cpp_dec_float_100 = 260.738 seconds
Total allocations for cpp_dec_float_100 = 0
Time for cpp_bin_float_100 = 128.675 seconds
Total allocations for cpp_bin_float_100 = 0

[table Bessel Functions (100 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_100][3.77539 (0.931753s)][913]]
[[cpp_dec_float_100][8.63842 (2.13193s)][6]]
[[mpf_float_100][1 (0.246796s)][1385589]]
[[mpf_float_100 (no expression templates][1.07128 (0.264389s)][2123705]]
[[mpfr_float_100][1.28703 (0.317635s)][1236026]]
[[mpfr_float_100 (no expression templates][1.36984 (0.338071s)][2119472]]
[[static_mpfr_float_100][1.10175 (0.271907s)][27969]]
]

[table Bessel Functions (16 digit precision)
[[Type][Time][# Allocations]]
[[arithmetic_backend<double>][2.57057 (0.00172288s)][0]]
[[arithmetic_backend<double> - no expression templates][5.10354 (0.00342056s)][0]]
[[double][1 (0.000670234s)][14]]
[[real_concept][25.7506 (0.0172589s)][0]]
]

[table Bessel Functions (50 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_50][2.24409 (0.207745s)][399]]
[[cpp_bin_float_50 (3 concurrent threads)][2.87977 (0.266594s)][463]]
[[cpp_dec_float_50][4.56157 (0.422285s)][381]]
[[cpp_dec_float_50 (3 concurrent threads)][5.66114 (0.524077s)][424]]
[[mpf_float_50][1.03648 (0.0959515s)][640961]]
[[mpf_float_50 (3 concurrent threads)][1.50439 (0.139268s)][2563517]]
[[mpf_float_50 (no expression templates][1 (0.0925745s)][1019039]]
[[mpf_float_50 (no expression templates (3 concurrent threads)][1.52451 (0.141131s)][4075842]]
[[mpfr_float_50][1.2513 (0.115838s)][583054]]
[[mpfr_float_50 (3 concurrent threads)][1.61301 (0.149324s)][2330876]]
[[mpfr_float_50 (no expression templates][1.42667 (0.132073s)][999594]]
[[mpfr_float_50 (no expression templates (3 concurrent threads)][2.00203 (0.185337s)][4000039]]
[[static_mpfr_float_50][1.18358 (0.10957s)][22930]]
[[static_mpfr_float_50 (3 concurrent threads)][1.38802 (0.128496s)][93140]]
[[static_mpfr_float_50 (no expression templates)][1.14598 (0.106089s)][46861]]
[[static_mpfr_float_50 (no expression templates) (3 concurrent threads)][1.24535 (0.115288s)][189227]]
]

[table Non-central T (16 digit precision)
[[Type][Time][# Allocations]]
[[arithmetic_backend<double>][1.68807 (0.0958558s)][0]]
[[arithmetic_backend<double> - no expression templates][1 (0.0567841s)][0]]
[[double][1.01015 (0.0573604s)][0]]
[[real_concept][1.88216 (0.106877s)][0]]
]

[table Non-central T Distribution (100 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_100][4.52155 (128.675s)][0]]
[[cpp_dec_float_100][9.16214 (260.738s)][0]]
[[mpf_float_100][1 (28.4582s)][192516784]]
[[mpf_float_100 (no expression templates][1.098 (31.2473s)][237462794]]
[[mpfr_float_100][1.60462 (45.6647s)][184143656]]
[[mpfr_float_100 (no expression templates][1.50647 (42.8714s)][237898133]]
[[static_mpfr_float_100][1.34201 (38.1912s)][131292]]
]

[table Non-central T Distribution (50 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_50][2.38959 (38.5842s)][0]]
[[cpp_bin_float_50 (3 concurrent threads)][3.50535 (56.6s)][28]]
[[cpp_dec_float_50][4.82763 (77.9505s)][0]]
[[mpf_float_50][1.06817 (17.2475s)][123749688]]
[[mpf_float_50 (no expression templates][1 (16.1468s)][152610085]]
[[mpfr_float_50][1.18754 (19.1749s)][118401290]]
[[mpfr_float_50 (no expression templates][1.36782 (22.0858s)][152816346]]
[[static_mpfr_float_50][1.04471 (16.8686s)][113395]]
]

[table Polynomial Evaluation (100 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_100][6.97908 (0.00239745s)][0]]
[[cpp_dec_float_100][7.54076 (0.00259039s)][0]]
[[mpf_float_100][1.3829 (0.000475054s)][12976]]
[[mpf_float_100 (no expression templates][1 (0.000343519s)][8984]]
[[mpfr_float_100][3.42163 (0.0011754s)][12976]]
[[static_mpfr_float_100][2.12013 (0.000728305s)][0]]
]

[table Polynomial Evaluation (50 digit precision)
[[Type][Time][# Allocations]]
[[cpp_bin_float_50][1.62513 (0.000652988s)][0]]
[[cpp_dec_float_50][2.47171 (0.000993151s)][0]]
[[mpf_float_50][1.12817 (0.000453308s)][12976]]
[[mpf_float_50 (no expression templates][1 (0.000401807s)][8984]]
[[mpfr_float_100 (no expression templates][2.69812 (0.00108413s)][8984]]
[[mpfr_float_50][1.91816 (0.000770731s)][12976]]
[[mpfr_float_50 (no expression templates][1.5859 (0.000637226s)][8984]]
[[static_mpfr_float_50][1.60745 (0.000645885s)][0]]
]



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_basic.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "sf_performance.hpp"

void basic_tests()
{
   basic_tests_1();
   basic_tests_2();
   basic_tests_3();
   basic_tests_4();
   basic_tests_5();
   basic_tests_6();
   basic_tests_7();
   basic_tests_8();
   basic_tests_9();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_bessel.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "sf_performance.hpp"

void bessel_tests_01();
void bessel_tests_02();
void bessel_tests_03();
void bessel_tests_04();
void bessel_tests_05();
void bessel_tests_06();
void bessel_tests_07();
void bessel_tests_08();
void bessel_tests_09();
void bessel_tests_10();
void bessel_tests_11();
void bessel_tests_12();
void bessel_tests_13();
void bessel_tests_14();
void bessel_tests_15();
void bessel_tests_16();
void bessel_tests_17();
void bessel_tests_18();
void bessel_tests_19();

void bessel_tests()
{
   //
   // 50 digits first:
   //
   std::cout << "Testing Bessel Functions at 50 digits....." << std::endl;
#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS)
   mpfr_set_default_prec(50 * 1000L / 301L);
#endif
#ifdef TEST_MPREAL
   mpfr::mpreal::set_default_prec(50 * 1000L / 301L);
#endif

   bessel_tests_01();
   bessel_tests_02();
   bessel_tests_03();
   bessel_tests_04();
   bessel_tests_05();
   bessel_tests_06();
   bessel_tests_07();
   bessel_tests_08();
   bessel_tests_09();
   bessel_tests_10();

   //
   // Then 100 digits:
   //
   std::cout << "Testing Bessel Functions at 100 digits....." << std::endl;
#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS)
   mpfr_set_default_prec(100 * 1000L / 301L);
#endif
   bessel_tests_11();
   bessel_tests_12();
   bessel_tests_13();
   bessel_tests_14();
   bessel_tests_15();
   bessel_tests_16();
   bessel_tests_17();
   bessel_tests_18();
   bessel_tests_19();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_1()
{

   std::cout << "Allocation Counts for Horner Evaluation:\n";
#ifdef TEST_MPFR
   basic_allocation_test("mpfr_float_50", mpfr_float_50(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_2()
{
#ifdef TEST_MPFR
   basic_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, et_off>(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_3()
{
#ifdef TEST_MPFR_CLASS
   basic_allocation_test("mpfr_class", mpfr_class(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_4()
{
#ifdef TEST_MPREAL
   basic_allocation_test("mpfr::mpreal", mpfr::mpreal(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_5.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_5()
{
   std::cout << "Allocation Counts for boost::math::tools::evaluate_polynomial:\n";
#ifdef TEST_MPFR
   poly_allocation_test("mpfr_float_50", mpfr_float_50(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_6.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_6()
{
#ifdef TEST_MPFR
   poly_allocation_test("mpfr_float_50 - no expression templates", number<mpfr_float_backend<50>, et_off>(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_7.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_7()
{
#ifdef TEST_MPFR_CLASS
   poly_allocation_test("mpfr_class", mpfr_class(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_8.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_8()
{
#ifdef TEST_MPREAL
   poly_allocation_test("mpfr::mpreal", mpfr::mpreal(2));
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_basic_9.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void basic_tests_9()
{
#ifdef TEST_FLOAT
   time_proc("Bessel Functions (16 digit precision)", "double", test_bessel<double>);
   time_proc("Bessel Functions (16 digit precision)", "real_concept", test_bessel<boost::math::concepts::real_concept>);
   time_proc("Bessel Functions (16 digit precision)", "arithmetic_backend<double>", test_bessel<number<arithmetic_backend<double>, et_on> >);
   time_proc("Bessel Functions (16 digit precision)", "arithmetic_backend<double> - no expression templates", test_bessel<number<arithmetic_backend<double>, et_off> >);

   time_proc("Non-central T (16 digit precision)", "double", test_nct<double>);
   time_proc("Non-central T (16 digit precision)", "real_concept", test_nct<boost::math::concepts::real_concept>);
   time_proc("Non-central T (16 digit precision)", "arithmetic_backend<double>", test_nct<number<arithmetic_backend<double>, et_on> >);
   time_proc("Non-central T (16 digit precision)", "arithmetic_backend<double> - no expression templates", test_nct<number<arithmetic_backend<double>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_01.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_01()
{
#ifdef TEST_MPFR
#if MPFR_VERSION < MPFR_VERSION_NUM(3, 0, 0)
   time_proc("Bessel Functions (50 digit precision)", "mpfr_float_50", test_bessel<boost::multiprecision::mpfr_float_50>, 1);
#else
   time_proc("Bessel Functions (50 digit precision)", "mpfr_float_50", test_bessel<boost::multiprecision::mpfr_float_50>, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_02.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_02()
{
#ifdef TEST_MPFR
#if MPFR_VERSION < MPFR_VERSION_NUM(3, 0, 0)
   time_proc("Bessel Functions (50 digit precision)", "mpfr_float_50 (no expression templates)", test_bessel<number<mpfr_float_backend<50>, et_off> >, 1);
#else
   time_proc("Bessel Functions (50 digit precision)", "mpfr_float_50 (no expression templates", test_bessel<number<mpfr_float_backend<50>, et_off> >, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_03.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_03()
{
#ifdef TEST_MPFR
#if MPFR_VERSION < MPFR_VERSION_NUM(3, 0, 0)
   time_proc("Bessel Functions (50 digit precision)", "static_mpfr_float_50", test_bessel<number<mpfr_float_backend<50, allocate_stack>, et_on> >, 1);
#else
   time_proc("Bessel Functions (50 digit precision)", "static_mpfr_float_50", test_bessel<number<mpfr_float_backend<50, allocate_stack>, et_on> >, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_04.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_04()
{
#ifdef TEST_MPFR
#if MPFR_VERSION < MPFR_VERSION_NUM(3, 0, 0)
   time_proc("Bessel Functions (50 digit precision)", "static_mpfr_float_50 (no expression templates)", test_bessel<number<mpfr_float_backend<50, allocate_stack>, et_off> >, 1);
#else
   time_proc("Bessel Functions (50 digit precision)", "static_mpfr_float_50 (no expression templates)", test_bessel<number<mpfr_float_backend<50, allocate_stack>, et_off> >, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_05.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_05()
{
#ifdef TEST_MPF
   time_proc("Bessel Functions (50 digit precision)", "mpf_float_50", test_bessel<mpf_float_50>, 3);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_06.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_06()
{
#ifdef TEST_MPF
   time_proc("Bessel Functions (50 digit precision)", "mpf_float_50 (no expression templates", test_bessel<number<gmp_float<50>, et_off> >, 3);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_07.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_07()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Bessel Functions (50 digit precision)", "cpp_dec_float_50", test_bessel<cpp_dec_float_50>, 3);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_08.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_08()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Bessel Functions (50 digit precision)", "cpp_bin_float_50", test_bessel<cpp_bin_float_50>, 3);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_09.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_09()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Bessel Functions (50 digit precision)", "mpfr_class", test_bessel<mpfr_class>, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_10()
{
#ifdef TEST_MPREAL
   time_proc("Bessel Functions (50 digit precision)", "mpfr::mpreal", test_bessel<mpfr::mpreal>, mpfr_buildopt_tls_p() ? 3 : 1);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_11()
{
#ifdef TEST_MPFR
   time_proc("Bessel Functions (100 digit precision)", "mpfr_float_100", test_bessel<mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_12()
{
#ifdef TEST_MPFR
   time_proc("Bessel Functions (100 digit precision)", "mpfr_float_100 (no expression templates", test_bessel<number<mpfr_float_backend<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_13.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_13()
{
#ifdef TEST_MPFR
   time_proc("Bessel Functions (100 digit precision)", "static_mpfr_float_100", test_bessel<static_mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_14.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_14()
{
#ifdef TEST_MPF
   time_proc("Bessel Functions (100 digit precision)", "mpf_float_100", test_bessel<mpf_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_15.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_15()
{
#ifdef TEST_MPF
   time_proc("Bessel Functions (100 digit precision)", "mpf_float_100 (no expression templates", test_bessel<number<gmp_float<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_16.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_16()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Bessel Functions (100 digit precision)", "cpp_dec_float_100", test_bessel<cpp_dec_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_17.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_17()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Bessel Functions (100 digit precision)", "cpp_bin_float_100", test_bessel<cpp_bin_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_18.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_18()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Bessel Functions (100 digit precision)", "mpfr_class", test_bessel<mpfr_class>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_bessel_19.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void bessel_tests_19()
{
#ifdef TEST_MPREAL
   time_proc("Bessel Functions (100 digit precision)", "mpfr::mpreal", test_bessel<mpfr::mpreal>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_01.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_01()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (50 digit precision)", "mpfr_float_50", test_nct<mpfr_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_02.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_02()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (50 digit precision)", "mpfr_float_50 (no expression templates", test_nct<number<mpfr_float_backend<50>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_03.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_03()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (50 digit precision)", "static_mpfr_float_50", test_nct<static_mpfr_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_04.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_04()
{
#ifdef TEST_MPF
   time_proc("Non-central T Distribution (50 digit precision)", "mpf_float_50", test_nct<mpf_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_05.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_05()
{
#ifdef TEST_MPF
   time_proc("Non-central T Distribution (50 digit precision)", "mpf_float_50 (no expression templates", test_nct<number<gmp_float<50>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_06.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_06()
{
#ifdef TEST_MPREAL
   mpfr::mpreal::set_default_prec(50 * 1000L / 301L);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_07.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_07()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Non-central T Distribution (50 digit precision)", "cpp_dec_float_50", test_nct<cpp_dec_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_08.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_08()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Non-central T Distribution (50 digit precision)", "cpp_bin_float_50", test_nct<cpp_bin_float_50>, 3);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_09.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_09()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Non-central T Distribution (50 digit precision)", "mpfr_class", test_nct<mpfr_class>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_10()
{
#ifdef TEST_MPREAL
   time_proc("Non-central T Distribution (50 digit precision)", "mpfr::mpreal", test_nct<mpfr::mpreal>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_11()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (100 digit precision)", "mpfr_float_100", test_nct<mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_12()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (100 digit precision)", "mpfr_float_100 (no expression templates", test_nct<number<mpfr_float_backend<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_13.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_13()
{
#ifdef TEST_MPFR
   time_proc("Non-central T Distribution (100 digit precision)", "static_mpfr_float_100", test_nct<static_mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_14.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_14()
{
#ifdef TEST_MPF
   time_proc("Non-central T Distribution (100 digit precision)", "mpf_float_100", test_nct<mpf_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_15.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_15()
{
#ifdef TEST_MPF
   time_proc("Non-central T Distribution (100 digit precision)", "mpf_float_100 (no expression templates", test_nct<number<gmp_float<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_16.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_16()
{
#ifdef TEST_MPREAL
   mpfr::mpreal::set_default_prec(100 * 1000L / 301L);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_17.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_17()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Non-central T Distribution (100 digit precision)", "cpp_dec_float_100", test_nct<cpp_dec_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_18.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_18()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Non-central T Distribution (100 digit precision)", "cpp_bin_float_100", test_nct<cpp_bin_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_19.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_19()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Non-central T Distribution (100 digit precision)", "mpfr_class", test_nct<mpfr_class>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_nct_20.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void nct_tests_20()
{
#ifdef TEST_MPREAL
   time_proc("Non-central T Distribution (100 digit precision)", "mpfr::mpreal", test_nct<mpfr::mpreal>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_01.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_01()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (50 digit precision)", "mpfr_float_50", test_polynomial<mpfr_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_02.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_02()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (50 digit precision)", "mpfr_float_50 (no expression templates", test_polynomial<number<mpfr_float_backend<50>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_03.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_03()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (50 digit precision)", "static_mpfr_float_50", test_polynomial<static_mpfr_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_04.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_04()
{
#ifdef TEST_MPF
   time_proc("Polynomial Evaluation (50 digit precision)", "mpf_float_50", test_polynomial<mpf_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_05.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_05()
{
#ifdef TEST_MPF
   time_proc("Polynomial Evaluation (50 digit precision)", "mpf_float_50 (no expression templates", test_polynomial<number<gmp_float<50>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_06.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_06()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Polynomial Evaluation (50 digit precision)", "cpp_dec_float_50", test_polynomial<cpp_dec_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_07.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_07()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Polynomial Evaluation (50 digit precision)", "cpp_bin_float_50", test_polynomial<cpp_bin_float_50>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_08.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_08()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Polynomial Evaluation (50 digit precision)", "mpfr_class", test_polynomial<mpfr_class>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_09.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_09()
{
#ifdef TEST_MPREAL
   time_proc("Polynomial Evaluation (50 digit precision)", "mpfr::mpreal", test_polynomial<mpfr::mpreal>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_10()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (100 digit precision)", "mpfr_float_100", test_polynomial<mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_11()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (50 digit precision)", "mpfr_float_100 (no expression templates", test_polynomial<number<mpfr_float_backend<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_12()
{
#ifdef TEST_MPFR
   time_proc("Polynomial Evaluation (100 digit precision)", "static_mpfr_float_100", test_polynomial<static_mpfr_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_13.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_13()
{
#ifdef TEST_MPF
   time_proc("Polynomial Evaluation (100 digit precision)", "mpf_float_100", test_polynomial<mpf_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_14.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_14()
{
#ifdef TEST_MPF
   time_proc("Polynomial Evaluation (100 digit precision)", "mpf_float_100 (no expression templates", test_polynomial<number<gmp_float<100>, et_off> >);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_15.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_15()
{
#ifdef TEST_CPP_DEC_FLOAT
   time_proc("Polynomial Evaluation (100 digit precision)", "cpp_dec_float_100", test_polynomial<cpp_dec_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_16.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_16()
{
#ifdef TEST_CPP_BIN_FLOAT
   time_proc("Polynomial Evaluation (100 digit precision)", "cpp_bin_float_100", test_polynomial<cpp_bin_float_100>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_17.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_17()
{
#ifdef TEST_MPFR_CLASS
   time_proc("Polynomial Evaluation (100 digit precision)", "mpfr_class", test_polynomial<mpfr_class>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_files/sf_performance_poly_18.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "../sf_performance.hpp"

void poly_tests_18()
{
#ifdef TEST_MPREAL
   time_proc("Polynomial Evaluation (100 digit precision)", "mpfr::mpreal", test_polynomial<mpfr::mpreal>);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_nct.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "sf_performance.hpp"

void nct_tests_01();
void nct_tests_02();
void nct_tests_03();
void nct_tests_04();
void nct_tests_05();
void nct_tests_06();
void nct_tests_07();
void nct_tests_08();
void nct_tests_09();
void nct_tests_10();
void nct_tests_11();
void nct_tests_12();
void nct_tests_13();
void nct_tests_14();
void nct_tests_15();
void nct_tests_16();
void nct_tests_17();
void nct_tests_18();
void nct_tests_19();
void nct_tests_20();

void nct_tests()
{
   //
   // 50 digits first:
   //
   std::cout << "Testing Non-Central T at 50 digits....." << std::endl;
#ifdef TEST_MPFR_CLASS
   mpfr_set_default_prec(50 * 1000L / 301L);
#endif

   nct_tests_01();
   nct_tests_02();
   nct_tests_03();
   nct_tests_04();
   nct_tests_05();
   nct_tests_06();
   nct_tests_07();
   nct_tests_08();
   nct_tests_09();
   nct_tests_10();

   //
   // Then 100 digits:
   //
   std::cout << "Testing Non-Central T at 100 digits....." << std::endl;
#ifdef TEST_MPFR_CLASS
   mpfr_set_default_prec(100 * 1000L / 301L);
#endif
   nct_tests_11();
   nct_tests_12();
   nct_tests_13();
   nct_tests_14();
   nct_tests_15();
   nct_tests_16();
   nct_tests_17();
   nct_tests_18();
   nct_tests_19();
   nct_tests_20();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sf_performance_poly.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "sf_performance.hpp"

void poly_tests_01();
void poly_tests_02();
void poly_tests_03();
void poly_tests_04();
void poly_tests_05();
void poly_tests_06();
void poly_tests_07();
void poly_tests_08();
void poly_tests_09();
void poly_tests_10();
void poly_tests_11();
void poly_tests_12();
void poly_tests_13();
void poly_tests_14();
void poly_tests_15();
void poly_tests_16();
void poly_tests_17();
void poly_tests_18();

void poly_tests()
{
   //
   // 50 digits first:
   //
   std::cout << "Testing Polynomial Evaluation at 50 digits....." << std::endl;
#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS)
   mpfr_set_default_prec(50 * 1000L / 301L);
#endif
#ifdef TEST_MPREAL
   mpfr::mpreal::set_default_prec(50 * 1000L / 301L);
#endif
   poly_tests_01();
   poly_tests_02();
   poly_tests_03();
   poly_tests_04();
   poly_tests_05();
   poly_tests_06();
   poly_tests_07();
   poly_tests_08();
   poly_tests_09();
   //
   // Then 100 digits:
   //
   std::cout << "Testing Polynomial Evaluation at 100 digits....." << std::endl;
#ifdef TEST_MPFR_CLASS
   mpfr_set_default_prec(100 * 1000L / 301L);
#endif
#ifdef TEST_MPREAL
   mpfr::mpreal::set_default_prec(100 * 1000L / 301L);
#endif
   poly_tests_10();
   poly_tests_11();
   poly_tests_12();
   poly_tests_13();
   poly_tests_14();
   poly_tests_15();
   poly_tests_16();
   poly_tests_17();
   poly_tests_18();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/sqrt_bench.cpp
================================================
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <iostream>
#include <benchmark/benchmark.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/integer.hpp>
#include <boost/random.hpp>
#include <cmath>

#include <immintrin.h>

using namespace boost::multiprecision;
using namespace boost::random;

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR Integer sqrt_old(const Integer& x, Integer& r)
{
   //
   // This is slow bit-by-bit integer square root, see for example
   // http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_.28base_2.29
   // There are better methods such as http://hal.inria.fr/docs/00/07/28/54/PDF/RR-3805.pdf
   // and http://hal.inria.fr/docs/00/07/21/13/PDF/RR-4475.pdf which should be implemented
   // at some point.
   //
   Integer s = 0;
   if (x == 0)
   {
      r = 0;
      return s;
   }
   int g = msb(x);
   if (g == 0)
   {
      r = 1;
      return s;
   }

   Integer t = 0;
   r         = x;
   g /= 2;
   bit_set(s, g);
   bit_set(t, 2 * g);
   r = x - t;
   --g;
   do
   {
      t = s;
      t <<= g + 1;
      bit_set(t, 2 * g);
      if (t <= r)
      {
         bit_set(s, g);
         r -= t;
      }
      --g;
   } while (g >= 0);
   return s;
}

template <class Integer>
BOOST_MP_CXX14_CONSTEXPR Integer sqrt_old(const Integer& x)
{
   Integer r(0);
   return sqrt_old(x, r);
}

template <class T>
std::tuple<std::vector<T>, std::vector<T> >& get_test_vector(unsigned bits)
{
   static std::map<unsigned, std::tuple<std::vector<T>, std::vector<T> > > data;

   std::tuple<std::vector<T>, std::vector<T> >& result = data[bits];

   if (std::get<0>(result).size() == 0)
   {
      mt19937                     mt;
      uniform_int_distribution<T> ui(T(1) << (bits - 1), T(1) << bits);

      std::vector<T>& a = std::get<0>(result);
      std::vector<T>& b = std::get<1>(result);

      for (unsigned i = 0; i < 1000; ++i)
      {
         a.push_back(ui(mt));
         b.push_back(0);
      }
   }
   return result;
}

template <class T>
std::vector<T>& get_test_vector_a(unsigned bits)
{
   return std::get<0>(get_test_vector<T>(bits));
}
template <class T>
std::vector<T>& get_test_vector_b(unsigned bits)
{
   return std::get<1>(get_test_vector<T>(bits));
}

template <typename T>
static void BM_sqrt_old(benchmark::State& state)
{
   int                         bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);

   for (auto _ : state)
   {
      for (unsigned i = 0; i < a.size(); ++i)
         b[i] = sqrt_old(a[i]);
   }
   state.SetComplexityN(bits);
}

template <typename T>
static void BM_sqrt_current(benchmark::State& state)
{
   int bits = state.range(0);

   std::vector<T>& a = get_test_vector_a<T>(bits);
   std::vector<T>& b = get_test_vector_b<T>(bits);

   for (auto _ : state)
   {
      for (unsigned i = 0; i < a.size(); ++i)
         b[i] = sqrt(a[i]);
   }
   state.SetComplexityN(bits);
}

constexpr unsigned lower_range = 512;
constexpr unsigned upper_range = 1 << 15;

BENCHMARK_TEMPLATE(BM_sqrt_old, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_sqrt_current, cpp_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();
BENCHMARK_TEMPLATE(BM_sqrt_current, mpz_int)->RangeMultiplier(2)->Range(lower_range, upper_range)->Unit(benchmark::kMillisecond)->Complexity();

BENCHMARK_MAIN();


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/veronoi_performance.log
================================================
Time for extended_int                   = 0.0366527
Time for int256_t                       = 0.0270196
Time for int512_t                       = 0.0291243
Time for int1024_t                      = 0.0368107
Time for checked_int256_t               = 0.0326167
Time for checked_int512_t               = 0.0340095
Time for checked_int1024_t              = 0.0415328
Time for cpp_int                        = 0.0487904
Time for mpz_int                        = 0.103619
Time for tom_int                        = 1.12504
[table
[[Integer Type][Relative Performance (Actual time in parenthesis)]]
[[checked_int1024_t][1.53714(0.0415328s)]]
[[checked_int256_t][1.20715(0.0326167s)]]
[[checked_int512_t][1.2587(0.0340095s)]]
[[cpp_int][1.80575(0.0487904s)]]
[[extended_int][1.35652(0.0366527s)]]
[[int1024_t][1.36237(0.0368107s)]]
[[int256_t][1(0.0270196s)]]
[[int512_t][1.0779(0.0291243s)]]
[[mpz_int][3.83495(0.103619s)]]
[[tom_int][41.6378(1.12504s)]]
]
Time for int64_t                        = 0.0128646
Time for number<arithmetic_backend<std::int64_t>, et_off> = 0.0129255


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/performance/voronoi_performance.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#pragma warning(disable : 4244)
#endif

#include <cstdlib>
#include <boost/polygon/detail/voronoi_predicates.hpp>
#include <boost/polygon/detail/voronoi_structures.hpp>
#include <boost/polygon/detail/voronoi_ctypes.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <vector>
#include <map>
#include <boost/chrono.hpp>
#include <boost/multiprecision/cpp_int.hpp>

#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif

#include "arithmetic_backend.hpp"

typedef boost::polygon::detail::point_2d<std::int32_t> i_point;

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

std::vector<i_point>   points;
boost::random::mt19937 gen;

template <class Big>
struct cpp_int_voronoi_traits
{
   typedef std::int32_t                                          int_type;
   typedef std::int64_t                                          int_x2_type;
   typedef std::uint64_t                                         uint_x2_type;
   typedef Big                                                     big_int_type;
   typedef double                                                  fpt_type;
   typedef boost::polygon::detail::extended_exponent_fpt<fpt_type> efpt_type;
   typedef boost::polygon::detail::ulp_comparison<fpt_type>        ulp_cmp_type;
   struct to_fpt_converter_type
   {
      template <class B, boost::multiprecision::expression_template_option ET>
      double operator()(const boost::multiprecision::number<B, ET>& val)
      {
         return val.template convert_to<double>();
      }
      double operator()(double val)
      {
         return val;
      }
      double operator()(const efpt_type& that) const
      {
         return that.d();
      }
      template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
      double operator()(const boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
      {
         typedef typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type r_t;
         r_t                                                                                                  r(e);
         return r.template convert_to<double>();
      }
   };
   struct to_efpt_converter_type
   {
      template <class B, boost::multiprecision::expression_template_option ET>
      efpt_type operator()(const boost::multiprecision::number<B, ET>& val)
      {
         return efpt_type(val.template convert_to<double>(), 0);
      }
      efpt_type operator()(double val)
      {
         return efpt_type(val, 0);
      }
      template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
      efpt_type operator()(const boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& e)
      {
         typedef typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type r_t;
         r_t                                                                                                  r(e);
         return efpt_type(r.template convert_to<double>(), 0);
      }
   };
};

template <class Big>
struct native_int_voronoi_traits
{
   typedef std::int32_t                                          int_type;
   typedef std::int64_t                                          int_x2_type;
   typedef std::uint64_t                                         uint_x2_type;
   typedef Big                                                     big_int_type;
   typedef double                                                  fpt_type;
   typedef boost::polygon::detail::extended_exponent_fpt<fpt_type> efpt_type;
   typedef boost::polygon::detail::ulp_comparison<fpt_type>        ulp_cmp_type;
   struct to_fpt_converter_type
   {
      template <class T>
      double operator()(const T& val) const
      {
         return val;
      }
      double operator()(const efpt_type& that) const
      {
         return that.d();
      }
   };
   struct to_efpt_converter_type
   {
      template <class T>
      efpt_type operator()(const T& val) const
      {
         return efpt_type(val, 0);
      }
   };
};

std::map<std::string, double> results;
double                        min_time = (std::numeric_limits<double>::max)();

template <class Traits>
double test(const char* name)
{
   typedef boost::polygon::detail::voronoi_predicates<Traits>                             preds;
   typedef boost::polygon::detail::circle_event<std::int32_t>                           circle_event;
   typedef boost::polygon::detail::site_event<std::int32_t>                             site_event;
   typedef typename preds::template mp_circle_formation_functor<site_event, circle_event> circle_pred;

   boost::random::uniform_int_distribution<> dist(0, points.size() - 1);
   circle_pred                               pc;
   circle_event                              event;

   stopwatch<boost::chrono::high_resolution_clock> w;

   for (unsigned i = 0; i < 10000; ++i)
   {
      site_event s1(points[dist(gen)]);
      site_event s2(points[dist(gen)]);
      site_event s3(points[dist(gen)]);
      pc.ppp(s1, s2, s3, event);
      pc.pps(s1, s2, s3, 0, event);
      pc.pss(s1, s2, s3, 0, event);
      pc.sss(s1, s2, s3, event);
   }
   double d = boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count();
   if (d < min_time)
      min_time = d;
   results[name] = d;
   std::cout << "Time for " << std::setw(30) << std::left << name << " = " << d << std::endl;
   return d;
}

void generate_quickbook()
{
   std::cout << "[table\n[[Integer Type][Relative Performance (Actual time in parenthesis)]]\n";

   std::map<std::string, double>::const_iterator i(results.begin()), j(results.end());

   while (i != j)
   {
      double rel = i->second / min_time;
      std::cout << "[[" << i->first << "][" << rel << "(" << i->second << "s)]]\n";
      ++i;
   }

   std::cout << "]\n";
}

int main()
{
   boost::random::uniform_int_distribution<> dist((std::numeric_limits<std::int32_t>::min)() / 2, (std::numeric_limits<std::int32_t>::max)() / 2);

   for (unsigned i = 0; i < 100; ++i)
   {
      points.push_back(i_point(dist(gen), dist(gen)));
   }

   test<boost::polygon::detail::voronoi_ctype_traits<std::int32_t> >("extended_int");

   test<cpp_int_voronoi_traits<boost::multiprecision::int256_t> >("int256_t");
   test<cpp_int_voronoi_traits<boost::multiprecision::int512_t> >("int512_t");
   test<cpp_int_voronoi_traits<boost::multiprecision::int1024_t> >("int1024_t");

   test<cpp_int_voronoi_traits<boost::multiprecision::checked_int256_t> >("checked_int256_t");
   test<cpp_int_voronoi_traits<boost::multiprecision::checked_int512_t> >("checked_int512_t");
   test<cpp_int_voronoi_traits<boost::multiprecision::checked_int1024_t> >("checked_int1024_t");

   test<cpp_int_voronoi_traits<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, boost::multiprecision::et_off> > >("cpp_int");

#ifdef TEST_GMP
   test<cpp_int_voronoi_traits<boost::multiprecision::number<boost::multiprecision::gmp_int, boost::multiprecision::et_off> > >("mpz_int");
#endif
#ifdef TEST_TOMMATH
   test<cpp_int_voronoi_traits<boost::multiprecision::number<boost::multiprecision::tommath_int, boost::multiprecision::et_off> > >("tom_int");
#endif

   generate_quickbook();

   test<native_int_voronoi_traits<std::int64_t> >("int64_t");
   test<cpp_int_voronoi_traits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<std::int64_t>, boost::multiprecision::et_off> > >("number<arithmetic_backend<std::int64_t>, et_off>");
   //test<cpp_int_voronoi_traits<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<std::int64_t>, boost::multiprecision::et_on> > >("number<arithmetic_backend<std::int64_t>, et_on>");

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_acos_errors.cpp
================================================
//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() 
{
   using PreciseReal = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<300> >;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return acos(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return acos(x);
   };

   std::string filename = "cpp_bin_float_acos.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 20;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot              = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-1), CoarseReal(1), samples, perturb_abscissas);
   // Note the argument chaining:
   plot./*clip(clip).*/width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "acos ULP plot cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_asin_errors.cpp
================================================
//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<300> >;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return asin(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return asin(x);
   };

   std::string filename = "cpp_bin_float_asin.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 20;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-1), CoarseReal(1), samples, perturb_abscissas);
   // Note the argument chaining:
   plot/*.clip(clip)*/.width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "asin ULP plot with cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_atan_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return atan(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return atan(x);
   };

   std::string filename = "cpp_bin_float_atan.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 50;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-200), CoarseReal(200), samples, perturb_abscissas);
   // Note the argument chaining:
   plot/*.clip(clip)*/.width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "atan ULP plot with cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_cos_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return cos(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return cos(x);
   };

   std::string filename = "cpp_bin_float_cos.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 50;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-20), CoarseReal(20), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "cos ULP plot with cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_erf_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return erf(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return erf(x);
   };

   std::string filename = "cpp_bin_float_erf.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 40;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-10), CoarseReal(10), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   //std::string title = "Airy Ai ULP plot at " + boost::core::demangle(typeid(CoarseReal).name()) + " precision";
   //plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_erfc_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return erfc(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return erfc(x);
   };

   std::string filename = "cpp_bin_float_erfc.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 200;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-20), CoarseReal(20), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   //std::string title = "Airy Ai ULP plot at " + boost::core::demangle(typeid(CoarseReal).name()) + " precision";
   //plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_exp_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return exp(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return exp(x);
   };

   std::string filename = "cpp_bin_float_exp.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 200;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-100), CoarseReal(100), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   //std::string title = "Airy Ai ULP plot at " + boost::core::demangle(typeid(CoarseReal).name()) + " precision";
   //plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_log_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return log(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return log(x);
   };

   std::string filename = "cpp_bin_float_log.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 20;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(0), CoarseReal(200), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   //std::string title = "Airy Ai ULP plot at " + boost::core::demangle(typeid(CoarseReal).name()) + " precision";
   //plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_sin_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return sin(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return sin(x);
   };

   std::string filename = "cpp_bin_float_sin.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 50;
   // Should we perturb the abscissas? 
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-20), CoarseReal(20), samples, perturb_abscissas);
   // Note the argument chaining:
   plot./*clip(clip).*/width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "sin ULP plot with cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_tan_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return tan(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return tan(x);
   };

   std::string filename = "cpp_bin_float_tan.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 20;
   // Should we perturb the abscissas?
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-20), CoarseReal(20), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   std::string title = "tan ULP plot with cpp_bin_float_50";
   plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/plots/cpp_bin_float_tgamma_errors.cpp
================================================

//  (C) Copyright Nick Thompson 2020.
//  (C) Copyright John Maddock 2020.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <iostream>
#include <boost/math/tools/ulps_plot.hpp>
#include <boost/core/demangle.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

using boost::math::tools::ulps_plot;

int main() {
   using PreciseReal = boost::multiprecision::mpfr_float_100;
   using CoarseReal = boost::multiprecision::cpp_bin_float_50;

   typedef boost::math::policies::policy<
      boost::math::policies::promote_float<false>,
      boost::math::policies::promote_double<false> >
      no_promote_policy;

   auto ai_coarse = [](CoarseReal const& x)->CoarseReal {
      return tgamma(x);
   };
   auto ai_precise = [](PreciseReal const& x)->PreciseReal {
      return tgamma(x);
   };

   std::string filename = "cpp_bin_float_tgamma.svg";
   int samples = 100000;
   // How many pixels wide do you want your .svg?
   int width = 700;
   // Near a root, we have unbounded relative error. So for functions with roots, we define an ULP clip:
   PreciseReal clip = 400;
   // Should we perturb the abscissas? 
   bool perturb_abscissas = false;
   auto plot = ulps_plot<decltype(ai_precise), PreciseReal, CoarseReal>(ai_precise, CoarseReal(-20), CoarseReal(200), samples, perturb_abscissas);
   // Note the argument chaining:
   plot.clip(clip).width(width);
   plot.background_color("white").font_color("black");
   // Sometimes it's useful to set a title, but in many cases it's more useful to just use a caption.
   //std::string title = "Airy Ai ULP plot at " + boost::core::demangle(typeid(CoarseReal).name()) + " precision";
   //plot.title(title);
   plot.vertical_lines(6);
   plot.add_fn(ai_coarse);
   // You can write the plot to a stream:
   //std::cout << plot;
   // Or to a file:
   plot.write(filename);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/Jamfile.v2
================================================
# copyright John Maddock 2011
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt.

import testing ;
import modules ;
import path ;
import ../../config/checks/config : requires ;

local ntl-path = [ modules.peek : NTL_PATH ] ;
local gmp_path = [ modules.peek : GMP_PATH ] ;
local mpfr_path = [ modules.peek : MPFR_PATH ] ;
local mpfi_path = [ modules.peek : MPFI_PATH ] ;
local tommath_path = [ modules.peek : TOMMATH_PATH ] ;


#######################################################################################
#
#  NOTE: Because these tests take a fair while to build and run, they are split up into
#        multiple smaller test suites which are:
#
#        arithmetic_tests
#        functions_and_limits
#        conversions
#        cpp_int_tests
#        misc
#        specfun
#        compile_fail
#        concepts
#        examples
#        
#        You can run an individual suite by passing its name to b2 on the command line.
#        Or you can run all except the "specfun" tests (which are very slow) by not specifying anything.
#
#        Please make sure that any new tests are added to one of the test suites, and that the
#        build times for the various suites are reasonably balanced: otherwise the CI builds
#        will time out if one suite contains too many.
#
#######################################################################################################

path-constant here : . ;

project : requirements
   <include>$(gmp_path)
   <include>$(gmp_path)/mpfr
   <include>$(gmp_path)/gmpfrxx
   <include>$(mpfr_path)
   <include>$(mpfi_path)
   <include>$(mpfi_path)/src
   <include>$(tommath_path)
   <include>../include
   <include>../../..
   # We set these to make it easier to set up and test GMP and MPFR under Win32:
   <toolset>msvc:<runtime-link>static
   <toolset>msvc:<link>static
   <toolset>msvc:<warnings>all
   <toolset>msvc:<cxxflags>/fp\:precise
   <toolset>intel-win:<runtime-link>static
   <toolset>intel-win:<link>static
   <toolset>clang-win:<link>static  # Clang-win does not generate .dlls.
   <toolset>clang:<link>static # Clang-linux does not generate .dlls.
   <toolset>clang:<cxxflags>-Wno-unused-variable  # warning: unused variable 'tolerance' [-Wunused-variable]
   <toolset>clang:<cxxflags>-v
  
   # Assembler error "File too big" caused by lots of C++ templates, for example, math/floating_point_examples.cpp.
   # Some projects on some toolsets may require
   #   <toolset>gcc-mingw:<cxxflags>\"-Wa,-mbig-obj\"
   # See https://digitalkarabela.com/mingw-w64-how-to-fix-file-too-big-too-many-sections/
   # <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj # Some projects may overflow assembler and require equivalent of MSVC /bigobj.
   # Requires version 2.30 of GNU binutils.
   # Best applied only to projects that require this, see multiprecision/example  run math/floating_point_examples.cpp.
   
   # Speed up compiles:
   <toolset>msvc:<debug-symbols>off
   <toolset>intel:<debug-symbols>off
   <toolset>gcc:<cxxflags>-Wall
   <toolset>gcc:<cxxflags>-Wextra
   #<toolset>intel:<define>SLOW_COMPILER
   <toolset>msvc,<optimization>off:<cxxflags>-RTC1
   # We can't yet enable this - it breaks the STL in some tests...
   #<toolset>msvc,<optimization>off:<cxxflags>-RTCc
   #<toolset>msvc,<optimization>off:<define>_ALLOW_RTCc_IN_STL
   [ requires  
      cxx11_rvalue_references cxx11_template_aliases cxx11_hdr_array cxx11_allocator cxx11_constexpr cxx11_explicit_conversion_operators cxx11_ref_qualifiers
      cxx11_hdr_functional cxx11_variadic_templates cxx11_user_defined_literals cxx11_decltype cxx11_static_assert cxx11_defaulted_functions
      cxx11_noexcept cxx11_ref_qualifiers cxx11_user_defined_literals cxx11_hdr_type_traits
      ]
   ;

local enable-specfun = [ MATCH (--enable-specfun) : [ modules.peek : ARGV ] ] ;
local disable-concepts = [ MATCH (--disable-concepts) : [ modules.peek : ARGV ] ] ;

lib gmp : : <search>$(gmp_path) ;
lib mpfr : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug ;
lib mpfi : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug <search>$(mpfi_path) <search>$(mpfi_path)/src ;
lib quadmath ;
lib mpc ;

if $(tommath_path)
{
   lib tommath : [ GLOB $(tommath_path) : *.c ] : <visibility>global ;
   TOMMATH = tommath ;
}
else
{
   lib tommath : : <search>$(tommath_path) ;
   TOMMATH = tommath ;
}

lib no_eh_support : no_eh_test_support.cpp ;

test-suite arithmetic_tests :

   [ run test_arithmetic_backend_concept.cpp no_eh_support ]
   [ compile test_arithmetic_skeleton.cpp ]

   [ run test_arithmetic_cpp_dec_float_1.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_dec_float_2.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_dec_float_3.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_dec_float_3m.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_cpp_bin_float_1.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_bin_float_2.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_bin_float_2m.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_bin_float_3.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_bin_float_4.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_bin_float_5.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_mpf_50.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpf.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpz.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpz_rat.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpz_br.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpq.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_mpfr.cpp mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfr_50.cpp mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfr_50_static.cpp mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_tommath.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_tommath_rat.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_tommath_br.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_cpp_int_1.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_2.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_3.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_4.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_5.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_6.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_7.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_8.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_9.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_10.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_11.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_12.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_13.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_14.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_15.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_16.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_17.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_18.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_19.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_20.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_21.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_22.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_23.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_br.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_ab_1.cpp no_eh_support : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_ab_2.cpp no_eh_support : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_ab_3.cpp no_eh_support : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_cpp_dec_float_round.cpp no_eh_support ]

   [ run test_arithmetic_logged_1.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_logged_2.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_dbg_adptr1.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_dbg_adptr1m.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_dbg_adptr2.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_cpp_complex_dbg_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_dbg_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_rat_dbg_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpf_dbg_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpc_dbg_adptr.cpp mpc mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpc : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfi_dbg_adptr.cpp mpfi mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpfi : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfr_dbg_adptr.cpp mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpq_dbg_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpz_dbg_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_cpp_complex_logged_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_int_logged_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_cpp_rat_logged_adptr.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpf_logged_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpc_logged_adptr.cpp mpc mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpc : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfi_logged_adptr.cpp mpfi mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpfi : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpfr_logged_adptr.cpp mpfr gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpq_logged_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_mpz_logged_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_mpfi_50.cpp mpfi mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfi : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_arithmetic_float_128.cpp quadmath no_eh_support : : : [ check-target-builds ../config//has_float128 : : <build>no ] ]
   [ run test_arithmetic_float_128.cpp no_eh_support : : : [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] : test_arithmetic_intel_quad ]

   [ run test_arithmetic_mpc.cpp mpc mpfr gmp : : : [ check-target-builds ../config//has_mpc : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_mpfr_mpc_precisions.cpp mpc mpfr gmp : : : [ check-target-builds ../config//has_mpc : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_mpfi_precisions.cpp mpfi mpfr gmp : : : [ check-target-builds ../config//has_mpfi : : <build>no ] ]
   [ run test_mpf_precisions.cpp gmp : : : [ check-target-builds ../config//has_gmp : : <build>no ] ]
   [ run test_threaded_precision.cpp mpfr gmp : : : [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPF_50 : test_threaded_precision_mpf ]
   [ run test_complex.cpp : : : [ check-target-builds ../config//has_mpc : <define>TEST_MPC <source>mpc <source>mpfr <source>gmp ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_complex_adaptor.cpp : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_complex_adaptor_2.cpp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
   [ run test_arithmetic_complex128.cpp : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

   [ run test_signed_zero.cpp : : : <define>TEST_CPP_BIN_FLOAT [ requires cxx17_if_constexpr ] : test_signed_zero_cpp_bin_float ]
   [ run test_signed_zero.cpp mpfr gmp : : : <define>TEST_MPFR [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] : test_signed_zero_mpfr ]

   [ run test_complex_signed_zero.cpp : : : <define>TEST_CPP_BIN_FLOAT [ requires cxx17_if_constexpr ] : test_complex_signed_zero_cpp_bin_float ]
   [ run test_complex_signed_zero.cpp mpc mpfr gmp : : : <define>TEST_MPC [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] : test_complex_signed_zero_mpc ]

   [ run test_preserve_source_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_preserve_source_precision_gmp ]
   [ run test_preserve_source_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR  : test_preserve_source_precision_mpfr ]
   [ run test_preserve_source_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_preserve_source_precision_mpc ]
   [ run test_preserve_source_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_preserve_source_precision_mpfi ]
   [ run test_preserve_component_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_preserve_component_precision_gmp ]
   [ run test_preserve_component_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR  : test_preserve_component_precision_mpfr ]
   [ run test_preserve_component_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_preserve_component_precision_mpc ]
   [ run test_preserve_component_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_preserve_component_precision_mpfi ]
   [ run test_preserve_related_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_preserve_related_precision_gmp ]
   [ run test_preserve_related_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR  : test_preserve_related_precision_mpfr ]
   [ run test_preserve_related_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_preserve_related_precision_mpc ]
   [ run test_preserve_related_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_preserve_related_precision_mpfi ]
   [ run test_preserve_all_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_preserve_all_precision_gmp ]
   [ run test_preserve_all_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR  : test_preserve_all_precision_mpfr ]
   [ run test_preserve_all_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_preserve_all_precision_mpc ]
   [ run test_preserve_all_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_preserve_all_precision_mpfi ]
   [ run test_preserve_target_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_preserve_target_precision_gmp ]
   [ run test_preserve_target_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR : test_preserve_target_precision_mpfr ]
   [ run test_preserve_target_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_preserve_target_precision_mpc ]
   [ run test_preserve_target_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_preserve_target_precision_mpfi ]
   [ run test_assume_uniform_precision.cpp gmp : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_gmp : : <build>no ] <define>TEST_MPF : test_assume_uniform_precision_gmp ]
   [ run test_assume_uniform_precision.cpp gmp mpfr : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfr : : <build>no ] <define>TEST_MPFR : test_assume_uniform_precision_mpfr ]
   [ run test_assume_uniform_precision.cpp gmp mpfr mpc : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpc : : <build>no ] <define>TEST_MPC : test_assume_uniform_precision_mpc ]
   [ run test_assume_uniform_precision.cpp gmp mpfr mpfi : : : [ requires cxx17_if_constexpr ] [ check-target-builds ../config//has_mpfi : : <build>no ] <define>TEST_MPFI : test_assume_uniform_precision_mpfi ]

;

alias precision_tests : test_preserve_source_precision_gmp test_preserve_source_precision_mpfr test_preserve_source_precision_mpc test_preserve_source_precision_mpfi 
   test_preserve_component_precision_gmp test_preserve_component_precision_mpfr test_preserve_component_precision_mpc test_preserve_component_precision_mpfi 
   test_preserve_related_precision_gmp test_preserve_related_precision_mpfr test_preserve_related_precision_mpc test_preserve_related_precision_mpfi 
   test_preserve_all_precision_gmp test_preserve_all_precision_mpfr test_preserve_all_precision_mpc test_preserve_all_precision_mpfi 
   test_preserve_target_precision_gmp test_preserve_target_precision_mpfr test_preserve_target_precision_mpc test_preserve_target_precision_mpfi 
   test_assume_uniform_precision_gmp test_assume_uniform_precision_mpfr test_assume_uniform_precision_mpc test_assume_uniform_precision_mpfi 
   test_mpfr_mpc_precisions test_mpfi_precisions test_mpf_precisions test_threaded_precision_mpf ;

rule get_function_tests
{
   local result ;
   for local source in test_exp.cpp test_log.cpp test_pow.cpp test_sinh.cpp test_sqrt.cpp test_cosh.cpp test_tanh.cpp test_sin.cpp test_cos.cpp test_tan.cpp test_asin.cpp test_acos.cpp test_atan.cpp test_round.cpp test_fpclassify.cpp test_sf_import_c99.cpp
   {
         result += [ run $(source) gmp no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_gmp : : <build>no ]
               <define>TEST_MPF_50
              : $(source:B)_mpf50 ] ;
         result += [ run $(source) mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <define>TEST_MPFR_50
              : $(source:B)_mpfr50 ] ;
         result += [ run $(source) mpfi mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_mpfi : : <build>no ]
               <define>TEST_MPFI_50
              : $(source:B)_mpfi50 ] ;
         result += [ run $(source) no_eh_support
              : # command line
              : # input files
              : # requirements
               <define>TEST_CPP_DEC_FLOAT
              : $(source:B)_cpp_dec_float ] ;
         result += [ run $(source) no_eh_support
              : # command line
              : # input files
              : # requirements
               <define>TEST_CPP_BIN_FLOAT
              : $(source:B)_cpp_bin_float ] ;
         result += [ run $(source) quadmath no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_float128 : : <build>no ]
               <define>TEST_FLOAT128
              : $(source:B)_float128 ] ;
         result += [ run $(source) no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ]
               <define>TEST_FLOAT128
              : $(source:B)_intel_quad ] ;
   }
   return $(result) ;
}

test-suite functions_and_limits :

      [ run test_numeric_limits.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_BACKEND
              : test_numeric_limits_backend_concept ]

      [ run test_numeric_limits.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPF_50 <define>PRINT_MAX_DIGITS10
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_numeric_limits_mpf50 ]

      [ run test_numeric_limits.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPF <define>PRINT_MAX_DIGITS10
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_numeric_limits_mpf ]

      [ run test_numeric_limits.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPZ
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_numeric_limits_mpz ]

      [ run test_numeric_limits.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPQ
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_numeric_limits_mpq ]

      [ run test_numeric_limits.cpp mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR <define>PRINT_MAX_DIGITS10
               [ check-target-builds ../config//has_mpfr : : <build>no ]
              : test_numeric_limits_mpfr ]

      [ run test_numeric_limits.cpp mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR_50 <define>PRINT_MAX_DIGITS10
               [ check-target-builds ../config//has_mpfr : : <build>no ]
              : test_numeric_limits_mpfr_50 ]

      [ run test_numeric_limits.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_DEC_FLOAT
              : test_numeric_limits_cpp_dec_float ]

      [ run test_numeric_limits.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_BIN_FLOAT <define>PRINT_MAX_DIGITS10
              : test_numeric_limits_cpp_bin_float ]

      [ run test_numeric_limits.cpp $(TOMMATH) no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_TOMMATH
               [ check-target-builds ../config//has_tommath : : <build>no ]
              : test_numeric_limits_tommath ]

      [ run test_numeric_limits.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_INT
              : test_numeric_limits_cpp_int ]

      [ run test_numeric_limits.cpp mpfi mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFI_50
               [ check-target-builds ../config//has_mpfi : : <build>no ]
              : test_numeric_limits_mpfi_50 ]

      [ run test_numeric_limits.cpp quadmath no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
               [ check-target-builds ../config//has_float128 : : <build>no ]
              : test_numeric_limits_float128 ]
      [ run test_numeric_limits.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
               [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ]
              : test_numeric_limits_intel_quad ]

      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_DEC_FLOAT_2 : test_sf_import_c99_cpp_dec_float_2 ]
      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_DEC_FLOAT_3 : test_sf_import_c99_cpp_dec_float_3 ]
      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_DEC_FLOAT_4 : test_sf_import_c99_cpp_dec_float_4 ]
      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_DEC_FLOAT_5 : test_sf_import_c99_cpp_dec_float_5 ]
      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_DEC_FLOAT_6 : test_sf_import_c99_cpp_dec_float_6 ]

      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_BIN_FLOAT_2 : test_sf_import_c99_cpp_bin_float_2 ]
      [ run test_sf_import_c99.cpp : : : <define>TEST_CPP_BIN_FLOAT_2 : test_sf_import_c99_cpp_bin_float_3 ]

      [ run test_sf_import_c99.cpp mpfi mpfr gmp : : : <define>TEST_MPFI_DEBUG_ADAPTOR [ check-target-builds ../config//has_mpfi : : <build>no ] : test_sf_import_c99_mpfi_debug_adptr  ]
      [ run test_sf_import_c99.cpp mpfr gmp : : : <define>TEST_MPFR_DEBUG_ADAPTOR [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sf_import_c99_mpfr_debug_adptr  ]

      [ run test_sf_import_c99.cpp mpfi mpfr gmp : : : <define>TEST_MPFI_LOGGED_ADAPTOR [ check-target-builds ../config//has_mpfi : : <build>no ] : test_sf_import_c99_mpfi_logged_adptr  ]
      [ run test_sf_import_c99.cpp mpfr gmp : : : <define>TEST_MPFR_LOGGED_ADAPTOR [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sf_import_c99_mpfr_logged_adptr  ]

      [ run test_move.cpp mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR
               [ check-target-builds ../config//has_mpfr : : <build>no ]
              : test_move_mpfr ]

      [ run test_move.cpp mpc mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPC
               [ check-target-builds ../config//has_mpc : : <build>no ]
              : test_move_mpc ]

      [ run test_move.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_GMP
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_move_gmp ]

      [ run test_move.cpp $(TOMMATH) no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_TOMMATH
               [ check-target-builds ../config//has_tommath : : <build>no ]
              : test_move_tommath ]

      [ run test_move.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_INT
              : test_move_cpp_int ]

      [ run test_sin_near_half_pi.cpp mpfr gmp : : : <define>TEST_CPP_BIN_FLOAT release [ check-target-builds ../config//has_float128 : <source>quadmath : ] [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sin_near_half_pi_cpp_bin_float ]
      [ run test_sin_near_half_pi.cpp mpfr gmp : : : <define>TEST_CPP_DEC_FLOAT release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sin_near_half_pi_cpp_dec_float ]
      [ run test_sin_near_half_pi.cpp mpfr gmp : : : <define>TEST_MPF_50 release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sin_near_half_pi_mpf_50 ]
      [ run test_sin_near_half_pi.cpp mpfr gmp : : : <define>TEST_MPFR_50 release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_sin_near_half_pi_mpfr_50 ]
      [ run test_sin_near_half_pi.cpp mpfr gmp quadmath : : : <define>TEST_FLOAT128 release [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : : <build>no ] : test_sin_near_half_pi_float128 ]
      [ run test_cos_near_half_pi.cpp mpfr gmp : : : <define>TEST_CPP_BIN_FLOAT release [ check-target-builds ../config//has_float128 : <source>quadmath : ] [ check-target-builds ../config//has_mpfr : : <build>no ] : test_cos_near_half_pi_cpp_bin_float ]
      [ run test_cos_near_half_pi.cpp mpfr gmp : : : <define>TEST_CPP_DEC_FLOAT release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_cos_near_half_pi_cpp_dec_float ]
      [ run test_cos_near_half_pi.cpp mpfr gmp : : : <define>TEST_MPF_50 release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_cos_near_half_pi_mpf_50 ]
      [ run test_cos_near_half_pi.cpp mpfr gmp : : : <define>TEST_MPFR_50 release [ check-target-builds ../config//has_mpfr : : <build>no ] : test_cos_near_half_pi_mpfr_50 ]
      [ run test_cos_near_half_pi.cpp mpfr gmp quadmath : : : <define>TEST_FLOAT128 release [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_float128 : : <build>no ] : test_cos_near_half_pi_float128 ]

      [ run test_cpp_bin_float_tgamma.cpp ]
      [ run test_cpp_dec_float_tgamma.cpp ]

      [ run test_roots_10k_digits.cpp
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_DEC_FLOAT
              : test_roots_10k_digits_cpp_dec_float ]

      [ run test_roots_10k_digits.cpp
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_BIN_FLOAT
              : test_roots_10k_digits_cpp_bin_float ]

      [ get_function_tests ]
;

test-suite conversions :

   [ run test_gmp_conversions.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath : ] ]

   [ run test_mpfr_conversions.cpp gmp mpfr no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_mpfr : : <build>no ] ]

   [ run test_mpc_conversions.cpp gmp mpfr mpc no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_mpc : : <build>no ] ]

   [ run test_constants.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
           <define>TEST_MPF_50
            [ check-target-builds ../config//has_gmp : : <build>no ]
           : test_constants_mpf50 ]

   [ run test_constants.cpp mpfr gmp no_eh_support
           : # command line
           : # input files
           : # requirements
           <define>TEST_MPFR_50
            [ check-target-builds ../config//has_mpfr : : <build>no ]
           : test_constants_mpfr_50 ]

   [ run test_constants.cpp no_eh_support
           : # command line
           : # input files
           : # requirements
           <define>TEST_CPP_DEC_FLOAT
           : test_constants_cpp_dec_float ]


   [ run test_test.cpp ]
   [ run test_cpp_int_lit.cpp no_eh_support ]
   [ run test_convert_cpp_int_2_float.cpp no_eh_support ]

      #
      # Interconversion tests:
      #
      [ run test_convert_from_cpp_int.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_mpz_int.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_tom_int.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_cpp_rational.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_gmp_rational.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_tom_rational.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_cpp_bin_float.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_cpp_dec_float.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_mpf_float.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_mpfr_float.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_mpfi_float.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
      [ run test_convert_from_float128.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]

      [ run test_cpp_bin_float_conv.cpp ]

      [ run test_cpp_bin_float_io.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_BIN_FLOAT
               <define>TEST1
               release # Otherwise [ runtime is slow
              : test_cpp_bin_float_io_1
              ]

      [ run test_cpp_bin_float_io.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_BIN_FLOAT
               <define>TEST2
               release # Otherwise [ runtime is slow
              : test_cpp_bin_float_io_2
              ]

      [ run test_cpp_bin_float.cpp no_eh_support mpfr gmp /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR
               [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no : ]
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               release # Otherwise [ runtime is slow
              ]

      [ run test_float_io.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_DEC_FLOAT
               release # Otherwise [ runtime is slow
              : test_float_io_cpp_dec_float ]

      [ run test_float_io.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPF_50
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_float_io_mpf ]

      [ run test_float_io.cpp mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR_50
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_mpfr : : <build>no ]
              : test_float_io_mpfr ]

      [ run test_float_io.cpp mpfi mpfr gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFI_50
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_mpfi : : <build>no ]
              : test_float_io_mpfi ]

      [ run test_float_io.cpp quadmath no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_float128 : : <build>no ]
              : test_float_io_float128 ]
      [ run test_float_io.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ]
              : test_float_io_intel_quad ]

      [ run test_int_io.cpp no_eh_support $(TOMMATH)
              : # command line
              : # input files
              : # requirements
              <define>TEST_TOMMATH
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_tommath : : <build>no ]
              : test_int_io_tommath ]

      [ run test_int_io.cpp no_eh_support gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPZ
               release # Otherwise [ runtime is slow
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_int_io_mpz ]

      [ run test_fixed_zero_precision_io.cpp 
              : # command line
              : # input files
              : # requirements
              <define>TEST_BIN_FLOAT
               release
              : test_fixed_zero_precision_io_bin_float ]
      [ run test_fixed_zero_precision_io.cpp 
              : # command line
              : # input files
              : # requirements
              <define>TEST_DEC_FLOAT
               release
              : test_fixed_zero_precision_io_dec_float ]
      [ run test_fixed_zero_precision_io.cpp no_eh_support gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPF
               release
               [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_fixed_zero_precision_io_mpf_float ]
      [ run test_fixed_zero_precision_io.cpp no_eh_support mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFR
               release
               [ check-target-builds ../config//has_mpfr : : <build>no ]
              : test_fixed_zero_precision_io_mpfr_float ]
      [ run test_fixed_zero_precision_io.cpp no_eh_support quadmath
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
               release
               [ check-target-builds ../config//has_float128 : : <build>no ]
              : test_fixed_zero_precision_io_float128 ]

      [ run test_trailing_io_delim.cpp no_eh_support 
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_INT
              : test_trailing_io_delim_cpp ]
      [ run test_trailing_io_delim.cpp no_eh_support gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_GMP
              [ check-target-builds ../config//has_gmp : : <build>no ]
              : test_trailing_io_delim_gmp ]
      [ run test_trailing_io_delim.cpp no_eh_support tommath
              : # command line
              : # input files
              : # requirements
              <define>TEST_TOMMATH
              [ check-target-builds ../config//has_tommath : : <build>no ]
              : test_trailing_io_delim_tommath ]
      [ run test_trailing_io_delim.cpp no_eh_support quadmath
              : # command line
              : # input files
              : # requirements
              <define>TEST_FLOAT128
              [ check-target-builds ../config//has_float128 : : <build>no ]
              : test_trailing_io_delim_float128 ]
      [ run test_trailing_io_delim.cpp no_eh_support mpc mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPC
              [ check-target-builds ../config//has_mpc : : <build>no ]
              : test_trailing_io_delim_mpc ]
      [ run test_trailing_io_delim.cpp no_eh_support mpfi mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPFI
              [ check-target-builds ../config//has_mpfi : : <build>no ]
              : test_trailing_io_delim_mpfi ]
;


test-suite cpp_int_tests :

      [ run test_int_io.cpp no_eh_support
           : # command line
           : # input files
           : # requirements
           <define>TEST_CPP_INT
            release # Otherwise    [ runtime is slow
           : test_int_io_cpp_int ]

      [ run test_cpp_int_left_shift.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST1
            : test_cpp_int_1
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST2
            : test_cpp_int_2
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST3
            : test_cpp_int_3
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST4
            : test_cpp_int_4
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST5
            : test_cpp_int_5
            ]

      [ run test_cpp_int.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST6
            : test_cpp_int_6
            ]

      [ run test_cpp_rational.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            ]

      [ run test_cpp_int_karatsuba.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST=1
            : test_cpp_int_karatsuba_1
            ]
      [ run test_cpp_int_karatsuba.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST=2
            : test_cpp_int_karatsuba_2
            ]
      [ run test_cpp_int_karatsuba.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST=3
            : test_cpp_int_karatsuba_3
            ]
      [ run test_cpp_int_karatsuba.cpp gmp no_eh_support
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            release  # otherwise    [ runtime is too slow!!
            <define>TEST=4
            : test_cpp_int_karatsuba_4
            ]

      [ run test_int_sqrt.cpp no_eh_support ]

      [ run test_checked_cpp_int.cpp no_eh_support ]
      [ run test_unchecked_cpp_int.cpp no_eh_support : : : release ]

      [ run test_cpp_int_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST1 <toolset>gcc-mingw:<link>static : test_cpp_int_serial_1 ]
      [ run test_cpp_int_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST2 <toolset>gcc-mingw:<link>static : test_cpp_int_serial_2 ]
      [ run test_cpp_int_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST3 <toolset>gcc-mingw:<link>static : test_cpp_int_serial_3 ]
      [ run test_cpp_int_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST4 <toolset>gcc-mingw:<link>static : test_cpp_int_serial_4 ]
      [ run test_cpp_int_deserial.cpp ../../serialization/build//boost_serialization ../../filesystem/build//boost_filesystem : $(here)/serial_txts : : release <toolset>gcc-mingw:<link>static  ]
      [ run test_cpp_rat_serial.cpp ../../serialization/build//boost_serialization : : : release <toolset>gcc-mingw:<link>static  ]
      [ run test_gcd.cpp : : : [ requires cxx11_hdr_random ] ]
;

test-suite misc :

      [ compile test_constexpr.cpp : 
         [ check-target-builds ../config//has_float128 : <define>HAVE_FLOAT128 : ] 
         [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type <define>HAVE_FLOAT128 : ] 
         [ requires cxx11_constexpr cxx11_user_defined_literals ] ]

      [ compile constexpr_test_arithmetic_backend.cpp : 
         [ requires cxx14_constexpr cxx17_if_constexpr ] ]
      [ compile constexpr_test_float128.cpp : 
         [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_float128 : <source>quadmath : <build>no ] ]

      [ run constexpr_test_cpp_int.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ run constexpr_test_cpp_int_2.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ run constexpr_test_cpp_int_3.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ run constexpr_test_cpp_int_4.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ run constexpr_test_cpp_int_5.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ run constexpr_test_cpp_int_6.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : <toolset>msvc:<cxxflags>-constexpr:steps10000000 <toolset>clang:<cxxflags>-fconstexpr-steps=268435456 : <build>no ] [ check-target-builds ../config//has_constexpr_limits : <cxxflags>-fconstexpr-ops-limit=268435456 ] ]
      [ run constexpr_test_cpp_int_7.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : <toolset>msvc:<cxxflags>-constexpr:steps10000000 <toolset>clang:<cxxflags>-fconstexpr-steps=268435456 : <build>no ] ]

      [ compile test_nothrow_cpp_int.cpp ]
      [ compile test_nothrow_cpp_rational.cpp ]
      [ compile test_nothrow_cpp_bin_float.cpp ]
      [ compile test_nothrow_cpp_dec_float.cpp ]
      [ compile test_nothrow_float128.cpp : [ check-target-builds ../config//has_float128 : : <build>no ] ]
      [ compile test_nothrow_gmp.cpp : [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ compile test_nothrow_mpfr.cpp : [ check-target-builds ../config//has_mpfr : : <build>no ] ]

      [ run test_miller_rabin.cpp no_eh_support gmp
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_gmp : : <build>no ]
               release  # otherwise [ runtime is too slow!!
               ]

      [ run test_rational_io.cpp $(TOMMATH) no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_TOMMATH
               [ check-target-builds ../config//has_tommath : : <build>no ]
               release # Otherwise [ runtime is slow
              : test_rational_io_tommath ]

      [ run test_rational_io.cpp gmp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_MPQ
               [ check-target-builds ../config//has_gmp : : <build>no ]
               release # Otherwise [ runtime is slow
              : test_rational_io_mpz ]

      [ run test_rational_io.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
              <define>TEST_CPP_INT
               release # Otherwise [ runtime is slow
              : test_rational_io_cpp_int ]

      [ run test_generic_conv.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_gmp : <define>TEST_GMP <source>gmp :  ]
               [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>$(TOMMATH) :  ]
               [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>mpfr :  ]
               release # Otherwise [ runtime is slow
               ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST1
              release 
              : test_rat_float_interconv_1 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST2
              release 
              : test_rat_float_interconv_2 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST3
              release 
              : test_rat_float_interconv_3 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono
              : # command line
              : # input files
              : # requirements
              <define>TEST4
              release 
              : test_rat_float_interconv_4 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST5
              [ check-target-builds ../config//has_mpfr : : <build>no ]
              release 
              : test_rat_float_interconv_5 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST6
              [ check-target-builds ../config//has_mpfr : : <build>no ]
              release 
              : test_rat_float_interconv_6 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST7
              [ check-target-builds ../config//has_mpfr : : <build>no ]
              release 
              : test_rat_float_interconv_7 ]

      [ run test_rat_float_interconv.cpp no_eh_support /boost/system//boost_system /boost/chrono//boost_chrono mpfr gmp
              : # command line
              : # input files
              : # requirements
              <define>TEST8
              [ check-target-builds ../config//has_mpfr : : <build>no ]
              release 
              : test_rat_float_interconv_8 ]

      [ run test_cpp_int_conv.cpp no_eh_support ]
      [ run test_cpp_int_import_export.cpp no_eh_support ]
      [ run test_native_integer.cpp no_eh_support ]

      [ run test_mixed_move_cpp_int.cpp no_eh_support ]
      [ run test_mixed_cpp_int.cpp no_eh_support ]
      [ run test_mixed_float.cpp no_eh_support
              : # command line
              : # input files
              : # requirements
               [ check-target-builds ../config//has_gmp : <define>TEST_GMP <library>gmp : ]
               [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <library>mpfr <library>gmp : ] ]
      [ compile include_test/mpfr_include_test.cpp
                    : # requirements
                     [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ compile include_test/gmp_include_test.cpp
                    : # requirements
                     [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ compile include_test/tommath_include_test.cpp
                    : # requirements
                     [ check-target-builds ../config//has_tommath : : <build>no ] ]
      [ compile include_test/cpp_int_include_test.cpp ]
      [ compile include_test/cpp_dec_float_include_test.cpp ]
      [ compile include_test/cpp_bin_float_include_test.cpp ]

      [ run ublas_interop/test1.cpp ublas_interop/test11.cpp ublas_interop/test12.cpp ublas_interop/test13.cpp no_eh_support ]
      [ run ublas_interop/test2.cpp ublas_interop/test21.cpp ublas_interop/test22.cpp ublas_interop/test23.cpp no_eh_support ]
      #[ run ublas_interop/test3.cpp ublas_interop/test31.cpp ublas_interop/test32.cpp ublas_interop/test33.cpp ]
      [ run ublas_interop/test4.cpp ublas_interop/test42.cpp ublas_interop/test43.cpp no_eh_support ]
      [ run ublas_interop/test5.cpp ublas_interop/test52.cpp ublas_interop/test53.cpp no_eh_support ]
      [ run ublas_interop/test6.cpp ublas_interop/test62.cpp ublas_interop/test63.cpp no_eh_support ]
      #[ run ublas_interop/test7.cpp ublas_interop/test71.cpp ublas_interop/test72.cpp ublas_interop/test73.cpp ]

      [ run ublas_interop/test1.cpp ublas_interop/test11.cpp ublas_interop/test12.cpp ublas_interop/test13.cpp no_eh_support : : : <define>TEST_ET=1 : ublas1_et ]
      [ run ublas_interop/test2.cpp ublas_interop/test21.cpp ublas_interop/test22.cpp ublas_interop/test23.cpp no_eh_support : : : <define>TEST_ET=1 : ublas2_et ]
      #[ run ublas_interop/test3.cpp ublas_interop/test31.cpp ublas_interop/test32.cpp ublas_interop/test33.cpp : : : <define>TEST_ET=1 : ublas3_et ]
      [ run ublas_interop/test4.cpp ublas_interop/test42.cpp ublas_interop/test43.cpp no_eh_support : : : <define>TEST_ET=1 : ublas3_et ]
      [ run ublas_interop/test5.cpp ublas_interop/test52.cpp ublas_interop/test53.cpp no_eh_support : : : <define>TEST_ET=1 : ublas4_et ]
      [ run ublas_interop/test6.cpp ublas_interop/test62.cpp ublas_interop/test63.cpp no_eh_support : : : <define>TEST_ET=1 : ublas5_et ]
      #[ run ublas_interop/test7.cpp ublas_interop/test71.cpp ublas_interop/test72.cpp ublas_interop/test73.cpp : : : <define>TEST_ET=1 : ublas6_et ]

      #
      # Serialization tests, run in release mode so we cycle through more values:
      #
      [ run test_adapt_serial.cpp ../../serialization/build//boost_serialization : : : release <toolset>gcc-mingw:<link>static  ]
      [ run test_cpp_dec_float_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST1 <toolset>gcc-mingw:<link>static  : test_cpp_dec_float_serial_1 ]
      [ run test_cpp_dec_float_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST2 <toolset>gcc-mingw:<link>static  : test_cpp_dec_float_serial_2 ]
      [ run test_float128_serial.cpp ../../serialization/build//boost_serialization quadmath : : : release <toolset>gcc-mingw:<link>static  [ check-target-builds ../config//has_float128 : : <build>no ]  ]
      [ run test_cpp_bin_float_serial.cpp ../../serialization/build//boost_serialization : : : release <toolset>gcc-mingw:<link>static  <define>TEST1 : test_bin_dec_float_serial_1 ]
      [ run test_cpp_bin_float_serial.cpp ../../serialization/build//boost_serialization : : : release <define>TEST2 <toolset>gcc-mingw:<link>static  : test_bin_dec_float_serial_2 ]

      #
      # Mixed mode comparison tests, see: https://svn.boost.org/trac/boost/ticket/11328
      #
      [ run test_checked_mixed_cpp_int.cpp no_eh_support ]
      [ run test_mixed_cpp_bin_float.cpp no_eh_support ]
      [ run test_mixed_cpp_dec_float.cpp no_eh_support ]
      [ run test_mixed_mpf_float.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ run test_mixed_mpfr_float.cpp  mpfr gmp no_eh_support : : : [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      #
      # Check for narrowing conversions:
      #
      [ run test_float_conversions.cpp no_eh_support ]
      #
      # specific bug cases:
      #
      [ compile bug11922.cpp ]
      [ run bug12039.cpp no_eh_support ]
      [ compile git_issue_30.cpp ]
      [ run git_issue_167.cpp ]
      [ run git_issue_370.cpp ]
      [ run git_issue_175.cpp ]
      [ run git_issue_248.cpp ]
      [ run git_issue_265.cpp : : : [ check-target-builds ../config//has_mpfr : <source>gmp <source>mpfr : <build>no ] ]
      [ run git_issue_426.cpp : : : [ check-target-builds ../config//has_mpfr : <source>gmp <source>mpfr <define>TEST_MPFR ] [ check-target-builds ../config//has_float128 : <source>quadmath <define>TEST_FLOAT128 ] ]
      [ run git_issue_277.cpp ]
      [ run git_issue_313.cpp ]
      [ run git_issue_488.cpp ]
      [ compile git_issue_98.cpp : 
         [ check-target-builds ../config//has_float128 : <define>TEST_FLOAT128 <source>quadmath : ]
         [ check-target-builds ../config//has_gmp : <define>TEST_GMP <source>gmp : ]
         [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>gmp <source>mpfr : ]
         [ check-target-builds ../config//has_mpc : <define>TEST_MPC <source>gmp <source>mpfr <source>mpc : ] ]
      [ run issue_13301.cpp ]
      [ run issue_13148.cpp ]
      [ run test_hash.cpp : : : 
         [ check-target-builds ../config//has_float128 : <define>TEST_FLOAT128 <source>quadmath : ]
         [ check-target-builds ../config//has_gmp : <define>TEST_GMP <source>gmp : ]
         [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>gmp <source>mpfr : ]
         [ check-target-builds ../config//has_mpfi : <define>TEST_MPFI <source>gmp <source>mpfr <source>mpfi : ]
         [ check-target-builds ../config//has_tommath : <define>TEST_TOMMATH <source>tommath : ]
          ]
      [ run test_optional_compat.cpp ]
      #
      # Eigen interoperability:
      #
      [ run test_eigen_interop_cpp_int.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_dec_float.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_dec_float_2.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_dec_float_3.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_bin_float_1.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_bin_float_2.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_cpp_bin_float_3.cpp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
      [ run test_eigen_interop_mpfr_1.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_mpfr_2.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_mpfr_3.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_mpfr_4.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_mpfr_5.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_mpfr_6.cpp mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpfr : : <build>no ] ]
      [ run test_eigen_interop_gmp.cpp gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ run test_eigen_interop_gmp_2.cpp gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_gmp : : <build>no ] ]
      [ run test_eigen_interop_mpc.cpp mpc mpfr gmp : : : release [ check-target-builds ../config//has_eigen : : <build>no ] [ check-target-builds ../config//has_mpc : : <build>no ] ]
      [ compile git_issue_393.cpp : release [ check-target-builds ../config//has_eigen : : <build>no ] ]
;

alias eigen_tests : 
    test_eigen_interop_cpp_int test_eigen_interop_cpp_dec_float test_eigen_interop_cpp_dec_float_2 test_eigen_interop_cpp_dec_float_3
    test_eigen_interop_cpp_bin_float_1 test_eigen_interop_cpp_bin_float_2 test_eigen_interop_cpp_bin_float_3 test_eigen_interop_mpfr_1
    test_eigen_interop_mpfr_2 test_eigen_interop_mpfr_3 test_eigen_interop_mpfr_4 test_eigen_interop_mpfr_5 test_eigen_interop_mpfr_6 
    test_eigen_interop_gmp test_eigen_interop_gmp_2 test_eigen_interop_mpc git_issue_393 ;

test-suite standalone :

      [ run standalone_constexpr_test_cpp_int.cpp : : : [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_is_constant_evaluated : : <build>no ] ]
      [ compile standalone_constexpr_test_float128.cpp : 
         [ requires cxx14_constexpr cxx17_if_constexpr ] [ check-target-builds ../config//has_float128 : <source>quadmath : <build>no ] ]
      
      [ run standalone_test_arithmetic_complex128.cpp : : : [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_cpp_bin_float.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_cpp_dec_float.cpp no_eh_support  : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_cpp_int.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_int512.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_cpp_rational.cpp no_eh_support : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_tommath.cpp $(TOMMATH) no_eh_support : : : [ check-target-builds ../config//has_tommath : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_float_128.cpp quadmath no_eh_support : : : [ check-target-builds ../config//has_float128 : : <build>no ] ]
      [ run standalone_test_arithmetic_gmp.cpp gmp no_eh_support : : : [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]
      [ run standalone_test_arithmetic_mpf_logged_adptr.cpp gmp : : : <toolset>msvc:<cxxflags>-bigobj [ check-target-builds ../config//has_gmp : : <build>no ] [ check-target-builds ../config//has_float128 : <source>quadmath ] ]

      [ run standalone_test_miller_rabin.cpp no_eh_support gmp
                : # command line
                : # input files
                : # requirements
                [ check-target-builds ../config//has_gmp : : <build>no ]
                release  # otherwise [ runtime is too slow!!
      ]

      [ run standalone_test_convert_from_tom_int.cpp
              : # command line
              : # input files
              : # requirements
              [ check-target-builds ../config//has_gmp : <define>HAS_GMP <source>gmp : ]
              [ check-target-builds ../config//has_mpfr : <define>HAS_MPFR <source>gmp <source>mpfr : ]
              [ check-target-builds ../config//has_mpfi : <define>HAS_MPFI <source>gmp <source>mpfr <source>mpfi : ]
              [ check-target-builds ../config//has_tommath : <define>HAS_TOMMATH <source>tommath : ]
               [ check-target-builds ../config//has_float128 : <define>HAS_FLOAT128 <source>quadmath : ] 
              ]
;

#
# This take too long to run as a regular part of the tests:
#
run test_cpp_bin_float_round.cpp mpfr gmp ;
explicit test_cpp_bin_float_round ;

high_precision_points = 35 40 41 50 51 60 61 70 71 80 81 100 101 450 ;

rule get_specfun_tests_mpfr
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source) mpfr gmp 
            /boost/test//boost_unit_test_framework/<link>static 
            math/instances//test_instances_mpfr/<link>static
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_mpfr : : <build>no ]
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <define>TEST_MPFR_50
            <optimization>speed
            <define>BOOST_ALL_NO_LIB
            <define>BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
           : $(source:B)_mpfr ] ;
   }
   for local digits in $(high_precision_points)
   {
      result += [ run math/high_prec/test_gamma.cpp
            /boost/test//boost_unit_test_framework/<link>static 
           : # command line
           : # input files
           : # requirements
            <optimization>speed
            <define>BOOST_ALL_NO_LIB
            <define>TEST_PRECISION=$(digits)
            <toolset>msvc:<cxxflags>-bigobj
            [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <source>gmp <source>mpfr : <build>no ]
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <include>../../math/include_private
            release
            : test_gamma_mpfr_$(digits) ] ;

   }
   return $(result) ;
}

rule get_specfun_tests_gmp
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source) gmp 
            /boost/test//boost_unit_test_framework/<link>static 
            math/instances//test_instances_mpf/<link>static
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_gmp : : <build>no ]
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <optimization>speed
            <define>TEST_MPF_50
            <define>BOOST_ALL_NO_LIB
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
           : $(source:B)_mpf ] ;
   }
   for local digits in $(high_precision_points)
   {
      result += [ run math/high_prec/test_gamma.cpp
            /boost/test//boost_unit_test_framework/<link>static 
           : # command line
           : # input files
           : # requirements
            <optimization>speed
            <define>BOOST_ALL_NO_LIB
            <define>TEST_PRECISION=$(digits)
            <toolset>msvc:<cxxflags>-bigobj
            [ check-target-builds ../config//has_gmp : <define>TEST_MPF <source>gmp : <build>no ]
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <include>../../math/include_private
            release
            : test_gamma_gmp_$(digits) ] ;

   }
   return $(result) ;
}

rule get_specfun_tests_cpp_dec_float
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source) /boost/test//boost_unit_test_framework/<link>static 
               math/instances//test_instances_cpp_dec_float/<link>static
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <define>TEST_CPP_DEC_FLOAT
            <define>BOOST_ALL_NO_LIB
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
           : $(source:B)_cpp_dec_float ] ;
   }
   for local digits in $(high_precision_points)
   {
      result += [ run math/high_prec/test_gamma.cpp
            /boost/test//boost_unit_test_framework/<link>static 
           : # command line
           : # input files
           : # requirements
            <optimization>speed
            <define>BOOST_ALL_NO_LIB
            <define>TEST_PRECISION=$(digits)
            <toolset>msvc:<cxxflags>-bigobj
            <define>TEST_CPP_DEC_FLOAT
            <include>../../math/include_private
            release
            : test_gamma_cpp_dec_float_$(digits) ] ;
   }
   return $(result) ;
}

rule get_specfun_tests_cpp_bin_float
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source) /boost/test//boost_unit_test_framework/<link>static 
               math/instances//test_instances_cpp_bin_float/<link>static
           : # command line
           : # input files
           : # requirements
            <define>TEST_CPP_BIN_FLOAT
            <define>BOOST_ALL_NO_LIB
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
           : $(source:B)_cpp_bin_float ] ;
   }
   for local digits in $(high_precision_points)
   {
      result += [ run math/high_prec/test_gamma.cpp
            /boost/test//boost_unit_test_framework/<link>static 
           : # command line
           : # input files
           : # requirements
            <optimization>speed
            <define>BOOST_ALL_NO_LIB
            <define>TEST_PRECISION=$(digits)
            <toolset>msvc:<cxxflags>-bigobj
            <define>TEST_CPP_BIN_FLOAT
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <include>../../math/include_private
            release
            : test_gamma_cpp_bin_float_$(digits) ] ;

   }
   return $(result) ;
}

rule get_specfun_tests_float128
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source) quadmath 
            /boost/test//boost_unit_test_framework/<link>static 
            math/instances//test_instances_float128/<link>static
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_float128 : : <build>no ]
            <optimization>speed
            <define>TEST_FLOAT128
            <define>BOOST_ALL_NO_LIB
            <define>BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
           : $(source:B)_float128 ] ;
   }
   return $(result) ;
}

rule get_specfun_tests_intel_quad
{
   local result ;
   for local source in [ glob math/*.cpp ]
   {
      result += [ run $(source)
            /boost/test//boost_unit_test_framework/<link>static 
            math/instances//test_instances_intel_quad/<link>static
           : # command line
           : # input files
           : # requirements
            [ check-target-builds ../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] 
            [ check-target-builds ../config//has_float128 : <source>quadmath ]
            <optimization>speed
            <define>TEST_FLOAT128
            <define>BOOST_ALL_NO_LIB
            <define>BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
            <toolset>msvc:<cxxflags>-bigobj
            <include>../../math/include_private
            release
           : $(source:B)_intel_quad ] ;
   }
   return $(result) ;
}

test-suite specfun_mpfr : [ get_specfun_tests_mpfr ] ;
explicit specfun_mpfr ;
test-suite specfun_gmp : [ get_specfun_tests_gmp ] ;
explicit specfun_gmp ;
test-suite specfun_cpp_dec_float : [ get_specfun_tests_cpp_dec_float ] ;
explicit specfun_cpp_dec_float ;
test-suite specfun_cpp_bin_float : [ get_specfun_tests_cpp_bin_float ] ;
explicit specfun_cpp_bin_float ;
test-suite specfun_float128 : [ get_specfun_tests_float128 ] ;
explicit specfun_float128 ;
test-suite specfun_intel_quad : [ get_specfun_tests_intel_quad ] ;
explicit specfun_intel_quad ;

test-suite specfun : specfun_mpfr specfun_gmp specfun_cpp_dec_float specfun_cpp_bin_float specfun_float128 specfun_intel_quad ;
explicit specfun ;

rule get_compile_fail_tests
{

   local compile_fail_tests ;

   for local source in [ glob compile_fail/*.cpp ]
   {
      compile_fail_tests +=  $(source:B) ;
      compile-fail $(source)
      :
         [ check-target-builds ../config//has_gmp : <define>TEST_GMP <debug-symbols>off : ]
         [ check-target-builds ../config//has_mpfr : <define>TEST_MPFR <debug-symbols>off : ]
      ;
   }
   return $(compile_fail_tests) ;
}

test-suite compile_fail :  [ get_compile_fail_tests ] ;

rule get_concept_checks
{
   local result ;
   for local source in [ glob concepts/*.cpp ]
   {

      result += [ compile $(source)  mpfr
              : # requirements
              <define>TEST_MPFR_50
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpfr_50 ] ;

      result += [ compile $(source)  mpfr
              : # requirements
              <define>TEST_MPFR_6
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpfr_6 ] ;

      result += [ compile $(source)  mpfr
              : # requirements
              <define>TEST_MPFR_15
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpfr_15 ] ;

      result += [ compile $(source)  mpfr
              : # requirements
              <define>TEST_MPFR_17
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpfr_17 ] ;

      result += [ compile $(source)  mpfr
              : # requirements
              <define>TEST_MPFR_30
               [ check-target-builds ../config//has_mpfr : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpfr_30 ] ;

      result += [ compile $(source)  gmp
              : # requirements
              <define>TEST_MPF_50
               [ check-target-builds ../config//has_gmp : : <build>no ]
               <debug-symbols>off
               <optimization>space
              : $(source:B)_mpf50 ] ;

      result += [ compile $(source)
              : # requirements
              <define>TEST_CPP_DEC_FLOAT
               <debug-symbols>off
               <optimization>space
              : $(source:B)_cpp_dec_float ] ;

      result += [ compile $(source)
              : # requirements
              <define>TEST_CPP_BIN_FLOAT
               <debug-symbols>off
               <optimization>space
              : $(source:B)_cpp_bin_float ] ;

      result += [ compile $(source)
              : # requirements
              <define>TEST_CPP_DEC_FLOAT_NO_ET
               <debug-symbols>off
               <optimization>space
              : $(source:B)_cpp_dec_float_no_et ] ;

      result += [ compile $(source)
              : # requirements
              <define>TEST_BACKEND
               <debug-symbols>off
               <optimization>space
              : $(source:B)_backend_concept ] ;

      result += [ compile $(source)
              : # requirements
              <define>TEST_LOGGED_ADAPTER
               <debug-symbols>off
               <optimization>space
              : $(source:B)_logged_adaptor ] ;
   }
   return $(result) ;
}

test-suite concepts : [ get_concept_checks ] ;

test-suite examples : ../example//examples ;
test-suite performance : ../performance//performance ;


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/bug11922.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <memory>

#if defined(__apple_build_version__) && (__clang_major__ < 9)
//
// Apples clang fails with:
// error: no matching function for call to '__implicit_conversion_to'
// Which is nothing to do with us really...
//
#define DISABLE_TEST
#endif

typedef boost::multiprecision::cpp_int mp_int;

#if !defined(DISABLE_TEST)

class Int1
{
 public:
   Int1(const mp_int& ) {}
   Int1(const Int1& ) {}
};

class Int2
{
 public:
   Int2(const mp_int& ) {}
   Int2(const Int2& ) = delete;
};

int main()
{
   using namespace boost::multiprecision;

   mp_int i(10);
   Int1   a(i + 10);
   Int2   b(i + 20);

   std::shared_ptr<Int1> p1 = std::make_shared<Int1>(i + 10);
   std::shared_ptr<Int2> p2 = std::make_shared<Int2>(i + 10);

   return 0;
}

#else

int main()
{
   return 0;
}

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/bug12039.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>

int main()
{
   typedef boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<256> >  ext_float_t;
   typedef boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<2046> > long_ext_float_t;

   ext_float_t x = 5e15;
   x += 0.5;
   ext_float_t x1 = x + 255.0 / (1 << 20); // + 2^-12 - eps
   ext_float_t x2 = x + 257.0 / (1 << 20); // + 2^-12 + eps
   double      d1 = x1.convert_to<double>();
   double      d2 = x2.convert_to<double>();

   std::cout << std::setprecision(18) << d1 << std::endl;
   std::cout << std::setprecision(18) << d2 << std::endl;

   x        = 1e7 + 0.5;
   x1       = x + ldexp(255.0, -38); // + 2^-30 - eps
   x2       = x + ldexp(257.0, -38); // + 2^-30 + eps
   float f1 = x1.convert_to<float>();
   float f2 = x2.convert_to<float>();

   std::cout << std::setprecision(9) << f1 << std::endl;
   std::cout << std::setprecision(9) << f2 << std::endl;

   long_ext_float_t lf(1);
   lf += std::numeric_limits<long_ext_float_t>::epsilon();
   lf += std::numeric_limits<float>::epsilon() / 2;
   BOOST_MP_ASSERT(lf != 1);
   float f3 = lf.convert_to<float>();
   std::cout << std::setprecision(9) << f3 << std::endl;

   return (d1 == d2) && (f1 == f2) && (f3 != 1) ? 0 : 1;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_01.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

void foo(cpp_int)
{
}

int main()
{
   foo(2.3); // conversion from float is explicit
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_02.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i == 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_03.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i != 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_04.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i <= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_05.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i >= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_06.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i > 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_07.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i < 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_08.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i         = 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_09.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i += 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_10.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i -= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_11.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i *= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_12.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i /= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_13.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i %= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_14.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i |= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_15.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i ^= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_16.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i = 2;
   i &= 2.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_18.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(2);
   i = a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_20.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i = a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_21.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i += a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_22.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i -= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_23.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i *= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_24.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i /= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_25.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i %= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_26.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i &= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_27.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i |= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_28.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   cpp_int          i(3);
   i ^= a * b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_29.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i + 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_30.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 + i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_31.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 - i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_32.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i - 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_33.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i * 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_34.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 * i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_35.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 / i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_36.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i / 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_37.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i % 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_38.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 % i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_39.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 & i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_40.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i & 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_41.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i | 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_42.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 | i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_43.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = 3.3 ^ i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_44.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(3), j;
   j = i ^ 3.3;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_45.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_GMP

#include <boost/multiprecision/gmp.hpp>

using namespace boost::multiprecision;

void foo(mpz_int i);

int main()
{
   mpf_t f
       foo(f);
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_46.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_GMP

#include <boost/multiprecision/gmp.hpp>

using namespace boost::multiprecision;

int main()
{
   mpf_t   f;
   mpz_int i;
   i = f;
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_47.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_GMP

#include <boost/multiprecision/gmp.hpp>

using namespace boost::multiprecision;

void foo(mpf_float_50);

int main()
{
   mpf_float_100 f(2);
   foo(f);
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_48.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_GMP

#include <boost/multiprecision/gmp.hpp>

using namespace boost::multiprecision;

int main()
{
   mpf_float_100 f(2);
   mpf_float_50  f2;
   f2 = f;
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_49.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_MPFR

#include <boost/multiprecision/mpfr.hpp>

using namespace boost::multiprecision;

int main()
{
   mpfr_float_100 f(2);
   mpfr_float_50  f2;
   f2 = f;
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_50.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef TEST_MPFR

#include <boost/multiprecision/mpfr.hpp>

using namespace boost::multiprecision;

int main()
{
   mpfr_float_100 f(2);
   mpfr_float_50  f2 = f;
}

#else

#error "Nothing to test without GMP!"

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_51.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_100 f(2);
   cpp_dec_float_50  f2 = f;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_52.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_100 f(2);
   cpp_dec_float_50  f2;
   f2 = f;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_53.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   int256_t i = 3;
   int128_t j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_54.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   int256_t i = 3;
   int128_t j;
   j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_55.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   int256_t  i = 3;
   uint256_t j;
   j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_56.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   int256_t  i = 3;
   uint256_t j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_57.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int  i = 3;
   int256_t j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_58.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int  i = 3;
   int256_t j;
   j = i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/conv_fail_59.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_int i(1), j(3);
   void*   p = i * j;
   (void)p; // warning suppression.
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/cpp_int_complement.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   checked_int256_t i;
   i = ~i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/cpp_int_negate_1.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   checked_uint256_t i;
   i = -i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/cpp_int_negate_2.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   number<cpp_int_backend<32, 32, unsigned_magnitude>, et_on> i;
   i = -i;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_01.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   number<cpp_dec_float<50>, et_on>  a(2);
   number<cpp_dec_float<50>, et_off> b(2);

   a = a + b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_02.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2);
   cpp_int          b(2);

   a = a + b;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_03.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   ++x;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_04.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x++;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_05.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x--;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_06.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   --x;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_07.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x += a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_08.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x -= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_09.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x *= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_10.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x /= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_11.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x %= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_12.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x |= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_13.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x &= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_14.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x ^= a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_15.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x >>= 2;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_16.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x <<= 2;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_17.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x                  = 2;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/compile_fail/operator_fail_18.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float_50 a(2), b(3);
   auto             x = a + b;
   x                  = a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/number_concept_check.cpp
================================================
//  Copyright John Maddock 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/concepts/real_type_concept.hpp>

template <class T>
void test_extra(T)
{
   T t = 1;
   t   = abs(t);
   t   = abs(t * t);

   t = fabs(t);
   t = fabs(t * t);

   t = sqrt(t);
   t = sqrt(t * t);

   t = floor(t);
   t = floor(t * t);

   t = ceil(t);
   t = ceil(t * t);

   t = trunc(t);
   t = trunc(t * t);

   t = round(t);
   t = round(t * t);

   t = exp(t);
   t = exp(t * t);

   t = log(t);
   t = log(t * t);

   t = log10(t);
   t = log10(t * t);

   t = cos(t);
   t = cos(t * t);

   t = sin(t);
   t = sin(t * t);

   t = tan(t);
   t = tan(t * t);

   t = asin(t);
   t = asin(t * t);

   t = atan(t);
   t = atan(t * t);

   t = acos(t);
   t = acos(t * t);

   t = cosh(t);
   t = cosh(t * t);

   t = sinh(t);
   t = sinh(t * t);

   t = tanh(t);
   t = tanh(t * t);

   double dval = 2;
   t           = pow(t, t);
   t           = pow(t, t * t);
   t           = pow(t, dval);
   t           = pow(t * t, t);
   t           = pow(t * t, t * t);
   t           = pow(t * t, dval);
   t           = pow(dval, t);
   t           = pow(dval, t * t);

   t = atan2(t, t);
   t = atan2(t, t * t);
   t = atan2(t, dval);
   t = atan2(t * t, t);
   t = atan2(t * t, t * t);
   t = atan2(t * t, dval);
   t = atan2(dval, t);
   t = atan2(dval, t * t);

   t = fmod(t, t);
   t = fmod(t, t * t);
   t = fmod(t, dval);
   t = fmod(t * t, t);
   t = fmod(t * t, t * t);
   t = fmod(t * t, dval);
   t = fmod(dval, t);
   t = fmod(dval, t * t);

   typedef typename T::backend_type             backend_type;
   typedef typename backend_type::exponent_type exp_type;
   exp_type                                     e = 0;
   int                                          i = 0;

   t = ldexp(t, i);
   t = ldexp(t * t, i);
   t = ldexp(t, e);
   t = ldexp(t * t, e);

   t = frexp(t, &i);
   t = frexp(t * t, &i);
   t = frexp(t, &e);
   t = frexp(t * t, &e);

   t = scalbn(t, i);
   t = scalbn(t * t, i);
   t = scalbn(t, e);
   t = scalbn(t * t, e);

   t = logb(t);
   t = logb(t * t);
   e = ilogb(t);
   e = ilogb(t * t);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
}

int main()
{
#ifdef TEST_BACKEND
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::concepts::mp_number_float_architype>));
#endif
#ifdef TEST_MPF_50
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpf_float_50>));
#endif
#ifdef TEST_MPFR_50
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
#endif
#ifdef TEST_MPFR_6
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> > >));
#endif
#ifdef TEST_MPFR_15
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> > >));
#endif
#ifdef TEST_MPFR_17
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> > >));
#endif
#ifdef TEST_MPFR_30
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> > >));
#endif
#ifdef TEST_MPFR_50
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::mpfr_float_50>));
#endif
#ifdef TEST_CPP_DEC_FLOAT
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::cpp_dec_float_50>));
#endif
#ifdef TEST_CPP_BIN_FLOAT
   BOOST_CONCEPT_ASSERT((boost::math::concepts::RealTypeConcept<boost::multiprecision::cpp_bin_float_50>));
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_basic.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   int i;
   (boost::math::fpclassify)(v1);
   (boost::math::isfinite)(v1);
   (boost::math::isnormal)(v1);
   (boost::math::isnan)(v1);
   (boost::math::isinf)(v1);
   (boost::math::signbit)(v1);
   (boost::math::copysign)(v1, v2);
   (boost::math::changesign)(v1);
   (boost::math::sign)(v1);
   boost::math::log1p(v1);
   boost::math::expm1(v1);
   boost::math::cbrt(v1);
   boost::math::sqrt1pm1(v1);
   boost::math::powm1(v1, v2);
   boost::math::hypot(v1, v2);
   boost::math::sinc_pi(v1);
   boost::math::sinhc_pi(v1);
   boost::math::asinh(v1);
   boost::math::acosh(v1);
   boost::math::atanh(v1);
   boost::math::sin_pi(v1);
   boost::math::cos_pi(v1);
   boost::math::trunc(v1);
   boost::math::itrunc(v1);
   boost::math::ltrunc(v1);
   boost::math::round(v1);
   boost::math::iround(v1);
   boost::math::lround(v1);
   boost::math::modf(v1, &v1);
   boost::math::modf(v1, &i);
   long l;
   boost::math::modf(v1, &l);
#ifdef BOOST_HAS_LONG_LONG
   boost::math::lltrunc(v1);
   boost::math::llround(v1);
   long long ll;
   boost::math::modf(v1, &ll);
#endif
   boost::math::pow<2>(v1);
   boost::math::nextafter(v1, v1);
   boost::math::float_next(v1);
   boost::math::float_prior(v1);
   boost::math::float_distance(v1, v1);
   // Misc functions that don't fit elsewhere:
   boost::math::expint(v1);
   boost::math::expint(i);
   boost::math::expint(i, v2);
   boost::math::expint(i, i);
   boost::math::zeta(v1);
   boost::math::zeta(i);
   boost::math::owens_t(v1, v2);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_bessel.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   int i(0);
   boost::math::cyl_neumann(v1, v2);
   boost::math::cyl_neumann(i, v2);
#ifndef SLOW_COMPILER
   boost::math::cyl_bessel_j(v1, v2);
   boost::math::cyl_bessel_j(i, v2);
   boost::math::cyl_bessel_i(v1, v2);
   boost::math::cyl_bessel_i(i, v2);
   boost::math::cyl_bessel_k(v1, v2);
   boost::math::cyl_bessel_k(i, v2);
   boost::math::sph_bessel(i, v2);
   boost::math::sph_bessel(i, 1);
   boost::math::sph_neumann(i, v2);
   boost::math::sph_neumann(i, i);
   boost::math::airy_ai(v1);
   boost::math::airy_bi(v1);
   boost::math::airy_ai_prime(v1);
   boost::math::airy_bi_prime(v1);
#endif
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_beta.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   boost::math::beta(v1, v2);
   boost::math::beta(v1, v2, v3);
   boost::math::betac(v1, v2, v3);
   boost::math::ibeta(v1, v2, v3);
   boost::math::ibetac(v1, v2, v3);
   boost::math::ibeta_derivative(v1, v2, v3);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_beta_2.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   boost::math::ibeta_inv(v1, v2, v3);
   boost::math::ibetac_inv(v1, v2, v3);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_beta_3.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   boost::math::ibeta_inva(v1, v2, v3);
   boost::math::ibetac_inva(v1, v2, v3);
   boost::math::ibeta_invb(v1, v2, v3);
   boost::math::ibetac_invb(v1, v2, v3);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_elliptic.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T v1, v2, v3;
   boost::math::ellint_1(v1);
   boost::math::ellint_1(v1, v2);
   boost::math::ellint_2(v1);
   boost::math::ellint_2(v1, v2);
   boost::math::ellint_3(v1, v2);
   boost::math::ellint_3(v1, v2, v3);
   boost::math::ellint_rc(v1, v2);
   boost::math::ellint_rd(v1, v2, v3);
   boost::math::ellint_rf(v1, v2, v3);
   boost::math::ellint_rj(v1, v2, v3, v1);
   boost::math::jacobi_elliptic(v1, v2, &v1, &v2);
   boost::math::jacobi_cd(v1, v2);
   boost::math::jacobi_cn(v1, v2);
   boost::math::jacobi_cs(v1, v2);
   boost::math::jacobi_dc(v1, v2);
   boost::math::jacobi_dn(v1, v2);
   boost::math::jacobi_ds(v1, v2);
   boost::math::jacobi_nc(v1, v2);
   boost::math::jacobi_nd(v1, v2);
   boost::math::jacobi_ns(v1, v2);
   boost::math::jacobi_sc(v1, v2);
   boost::math::jacobi_sd(v1, v2);
   boost::math::jacobi_sn(v1, v2);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_gamma.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T   v1, v2, v3;
   int i;
   boost::math::tgamma(v1);
   boost::math::tgamma1pm1(v1);
   boost::math::lgamma(v1);
   boost::math::lgamma(v1, &i);
   boost::math::digamma(v1);
   boost::math::tgamma_ratio(v1, v2);
   boost::math::tgamma_delta_ratio(v1, v2);
   boost::math::factorial<T>(i);
   boost::math::unchecked_factorial<T>(i);
   i = boost::math::max_factorial<T>::value;
   boost::math::double_factorial<T>(i);
   boost::math::rising_factorial(v1, i);
   boost::math::falling_factorial(v1, i);
   boost::math::gamma_p_derivative(v2, v3);
   boost::math::tgamma(v1, v2);
   boost::math::tgamma_lower(v1, v2);
   boost::math::gamma_p(v1, v2);
   boost::math::gamma_q(v1, v2);
   boost::math::gamma_p_inv(v1, v2);
   boost::math::gamma_q_inv(v1, v2);
   boost::math::gamma_p_inva(v1, v2);
   boost::math::gamma_q_inva(v1, v2);
   boost::math::erf(v1);
   boost::math::erfc(v1);
   boost::math::erf_inv(v1);
   boost::math::erfc_inv(v1);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/concepts/sf_concept_check_poly.cpp
================================================
//  Copyright John Maddock 2012.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This tests that cpp_dec_float_50 meets our
// conceptual requirements when used with Boost.Math.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4800)
#pragma warning(disable : 4512)
#pragma warning(disable : 4127)
#pragma warning(disable : 4512)
#pragma warning(disable : 4503) // decorated name length exceeded, name was truncated
#endif

#include <boost/container_hash/hash.hpp>
#include <libs/math/test/compile_test/poison.hpp>

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFR_6) && !defined(TEST_MPFR_15) && !defined(TEST_MPFR_17) && !defined(TEST_MPFR_30) && !defined(TEST_CPP_DEC_FLOAT_NO_ET) && !defined(TEST_LOGGED_ADAPTER) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR_50
#define TEST_MPFR_6
#define TEST_MPFR_15
#define TEST_MPFR_17
#define TEST_MPFR_30
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_NO_ET
#define TEST_LOGGED_ADAPTER
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_NO_ET) || defined(TEST_LOGGED_ADAPTER)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#if defined(TEST_MPFR_50) || defined(TEST_MPFR_6) || defined(TEST_MPFR_15) || defined(TEST_MPFR_17) || defined(TEST_MPFR_30)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_LOGGED_ADAPTER
#include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/special_functions.hpp>

template <class T>
void test_extra(T)
{
   T v1, v2, v3;
   boost::math::legendre_p(1, v1);
   boost::math::legendre_p(1, 0, v1);
   boost::math::legendre_q(1, v1);
   boost::math::legendre_next(2, v1, v2, v3);
   boost::math::legendre_next(2, 2, v1, v2, v3);
   boost::math::laguerre(1, v1);
   boost::math::laguerre(2, 1, v1);
   boost::math::laguerre(2u, 1u, v1);
   boost::math::laguerre_next(2, v1, v2, v3);
   boost::math::laguerre_next(2, 1, v1, v2, v3);
   boost::math::hermite(1, v1);
   boost::math::hermite_next(2, v1, v2, v3);
   boost::math::spherical_harmonic_r(2, 1, v1, v2);
   boost::math::spherical_harmonic_i(2, 1, v1, v2);
}

void foo()
{
#ifdef TEST_BACKEND
   test_extra(boost::multiprecision::concepts::mp_number_float_architype());
#endif
#ifdef TEST_MPF_50
   test_extra(boost::multiprecision::mpf_float_50());
#endif
#ifdef TEST_MPFR_50
   test_extra(boost::multiprecision::mpfr_float_50());
#endif
#ifdef TEST_MPFR_6
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<6> >());
#endif
#ifdef TEST_MPFR_15
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<15> >());
#endif
#ifdef TEST_MPFR_17
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<17> >());
#endif
#ifdef TEST_MPFR_30
   test_extra(boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> >());
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test_extra(boost::multiprecision::cpp_dec_float_50());
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test_extra(boost::multiprecision::cpp_bin_float_50());
#endif
#ifdef TEST_CPP_DEC_FLOAT_NO_ET
   test_extra(boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off>());
#endif
#ifdef TEST_LOGGED_ADAPTER
   typedef boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > num_t;
   test_extra(num_t());
#endif
}

int main()
{
   foo();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_arithmetric_test.hpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/config.hpp>
#include <boost/multiprecision/number.hpp>
#include <limits>

// clang-format off

#ifdef BOOST_HAS_FLOAT128
#define OR_IS_FLOAT128 || std::is_same<__float128, U>::value
#else
#define OR_IS_FLOAT128
#endif

template <class T, class U>
BOOST_CXX14_CONSTEXPR T do_test_constexpr_add_subtract(T a, U b)
{
   a = +b;
   if constexpr((std::numeric_limits<U>::is_signed OR_IS_FLOAT128) && std::numeric_limits<T>::is_signed)
      b = -b;
   a += b;
   a += a;
   a -= b;
   a -= a;
   ++a;
   --a;
   T bb(b);
   a += bb++;
   a += bb--;
   a = a + b;
   a += a - b;
   if constexpr((std::numeric_limits<U>::is_signed OR_IS_FLOAT128) && std::numeric_limits<T>::is_signed)
      a -= b - -a;
   a += b + a;
   if constexpr(std::numeric_limits<T>::is_signed)
   {
      a = -a;
      if constexpr(std::numeric_limits<U>::is_signed OR_IS_FLOAT128)
         a -= b;
   }
   return a;
}

template <class T>
BOOST_CXX14_CONSTEXPR T test_constexpr_add_subtract(T a)
{
   a += do_test_constexpr_add_subtract(a, a);
   a += do_test_constexpr_add_subtract(a, static_cast<unsigned char>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<signed char>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<char>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<short>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<unsigned short>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<int>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<unsigned int>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<long>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<unsigned long>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<long long>(2));
   a += do_test_constexpr_add_subtract(a, static_cast<unsigned long long>(2));
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
   {
      a += do_test_constexpr_add_subtract(a, static_cast<boost::int128_type>(2));
      a += do_test_constexpr_add_subtract(a, static_cast<boost::uint128_type>(2));
      a -= do_test_constexpr_add_subtract(a, static_cast<boost::int128_type>(2));
      a -= do_test_constexpr_add_subtract(a, static_cast<boost::uint128_type>(2));
   }
#endif

   if constexpr (boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_floating_point)
   {
      a += do_test_constexpr_add_subtract(a, static_cast<float>(2));
      a += do_test_constexpr_add_subtract(a, static_cast<double>(2));
      a += do_test_constexpr_add_subtract(a, static_cast<long double>(2));
#if defined(BOOST_HAS_FLOAT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, __float128>::value)
      a += do_test_constexpr_add_subtract(a, static_cast<__float128>(2));
#endif
   }

   return a;
}

template <class T, class U>
BOOST_CXX14_CONSTEXPR T do_test_constexpr_mul_divide(T a, U b)
{
   a *= b;
   a = a * b;
   if constexpr(std::numeric_limits<T>::is_signed && std::numeric_limits<U>::is_signed)
   {
      a *= -b;
      a = a * -b;
   }
   a /= b;
   a = a / b;
   if constexpr(std::numeric_limits<T>::is_signed && std::numeric_limits<U>::is_signed)
   {
      a /= -b;
      a = a / -b;
   }
   if constexpr (boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_integer && boost::multiprecision::number_category<U>::value == boost::multiprecision::number_kind_integer)
   {
      a %= b;
      a = a % b;
   }
   return a;
}

template <class T>
BOOST_CXX14_CONSTEXPR T test_constexpr_mul_divide(T a)
{
   a += do_test_constexpr_mul_divide(a, a);
   a += do_test_constexpr_mul_divide(a, static_cast<unsigned char>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<signed char>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<char>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<short>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<unsigned short>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<int>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<unsigned int>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<long>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<unsigned long>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<long long>(2));
   a += do_test_constexpr_mul_divide(a, static_cast<unsigned long long>(2));
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
   {
      a += do_test_constexpr_mul_divide(a, static_cast<boost::int128_type>(2));
      a += do_test_constexpr_mul_divide(a, static_cast<boost::uint128_type>(2));
      a -= do_test_constexpr_mul_divide(a, static_cast<boost::int128_type>(2));
      a -= do_test_constexpr_mul_divide(a, static_cast<boost::uint128_type>(2));
   }
#endif

   if constexpr (boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_floating_point)
   {
      a += do_test_constexpr_mul_divide(a, static_cast<float>(2));
      a += do_test_constexpr_mul_divide(a, static_cast<double>(2));
      a += do_test_constexpr_mul_divide(a, static_cast<long double>(2));
#if defined(BOOST_HAS_FLOAT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, __float128>::value)
      a += do_test_constexpr_mul_divide(a, static_cast<__float128>(2));
#endif
    }
   return a;
}

template <class T, class U>
BOOST_CXX14_CONSTEXPR T do_test_constexpr_bitwise(T a, U b)
{
   a |= b;
   a &= b;
   a <<= 2;
   a ^= b;
   a = a | b;
   a = a & b;
   a <<= 2;
   a = a ^ b;
   if constexpr (std::numeric_limits<T>::is_signed == false)
   {
      a = ~a;
      a >>= std::numeric_limits<T>::digits - 3;
   }

   a <<= 5;
   a = a << 2;
   a >>= 5;
   a = a >> 2;

   return a;
}

template <class T>
BOOST_CXX14_CONSTEXPR T test_constexpr_bitwise(T a)
{
   a += do_test_constexpr_bitwise(a, a);
   a += do_test_constexpr_bitwise(a, static_cast<unsigned char>(2));
   a += do_test_constexpr_bitwise(a, static_cast<signed char>(2));
   a += do_test_constexpr_bitwise(a, static_cast<char>(2));
   a += do_test_constexpr_bitwise(a, static_cast<short>(2));
   a += do_test_constexpr_bitwise(a, static_cast<unsigned short>(2));
   a += do_test_constexpr_bitwise(a, static_cast<int>(2));
   a += do_test_constexpr_bitwise(a, static_cast<unsigned int>(2));
   a += do_test_constexpr_bitwise(a, static_cast<long>(2));
   a += do_test_constexpr_bitwise(a, static_cast<unsigned long>(2));
   a += do_test_constexpr_bitwise(a, static_cast<long long>(2));
   a += do_test_constexpr_bitwise(a, static_cast<unsigned long long>(2));
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
   {
      a += do_test_constexpr_bitwise(a, static_cast<boost::int128_type>(2));
      a += do_test_constexpr_bitwise(a, static_cast<boost::uint128_type>(2));
   }
#endif

   return a;
}

template <class T, class U>
BOOST_CXX14_CONSTEXPR T do_test_constexpr_logical(T a, U b)
{
   T result(0);
   if(a || b)
      ++result;
   if(b || a)
      ++result;
   if(a && b)
      ++result;
   if(b && a)
      ++result;
   if(a)
      ++result;
   if(!a)
      ++result;
   return result;
}

template <class T>
BOOST_CXX14_CONSTEXPR T test_constexpr_logical(T a)
{
   a += do_test_constexpr_logical(a, a);
   a += do_test_constexpr_logical(a, static_cast<unsigned char>(2));
   a += do_test_constexpr_logical(a, static_cast<signed char>(2));
   a += do_test_constexpr_logical(a, static_cast<char>(2));
   a += do_test_constexpr_logical(a, static_cast<short>(2));
   a += do_test_constexpr_logical(a, static_cast<unsigned short>(2));
   a += do_test_constexpr_logical(a, static_cast<int>(2));
   a += do_test_constexpr_logical(a, static_cast<unsigned int>(2));
   a += do_test_constexpr_logical(a, static_cast<long>(2));
   a += do_test_constexpr_logical(a, static_cast<unsigned long>(2));
   a += do_test_constexpr_logical(a, static_cast<long long>(2));
   a += do_test_constexpr_logical(a, static_cast<unsigned long long>(2));
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
   {
      a += do_test_constexpr_logical(a, static_cast<boost::int128_type>(2));
      a += do_test_constexpr_logical(a, static_cast<boost::uint128_type>(2));
      a -= do_test_constexpr_logical(a, static_cast<boost::int128_type>(2));
      a -= do_test_constexpr_logical(a, static_cast<boost::uint128_type>(2));
   }
#endif

   return a;
}

template <class T, class U>
BOOST_CXX14_CONSTEXPR T do_test_constexpr_compare(T a, U b)
{
   T result(0);
   if(a == b)
      ++result;
   if(b == a)
      ++result;
   if(a != b)
      ++result;
   if(b != a)
      ++result;
   if(a < b)
      ++result;
   if(b < a)
      ++result;
   if(a <= b)
      ++result;
   if(b <= a)
      ++result;
   if(a > b)
      ++result;
   if(b > a)
      ++result;
   if(a >= b)
      ++result;
   if(b >= a)
      ++result;

   T u(b);
   if(u == a)
      ++result;

   return result;
}

template <class T>
BOOST_CXX14_CONSTEXPR T test_constexpr_compare(T a)
{
   a += do_test_constexpr_compare(a, a);
   a += do_test_constexpr_compare(a, static_cast<unsigned char>(2));
   a += do_test_constexpr_compare(a, static_cast<signed char>(2));
   a += do_test_constexpr_compare(a, static_cast<char>(2));
   a += do_test_constexpr_compare(a, static_cast<short>(2));
   a += do_test_constexpr_compare(a, static_cast<unsigned short>(2));
   a += do_test_constexpr_compare(a, static_cast<int>(2));
   a += do_test_constexpr_compare(a, static_cast<unsigned int>(2));
   a += do_test_constexpr_compare(a, static_cast<long>(2));
   a += do_test_constexpr_compare(a, static_cast<unsigned long>(2));
   a += do_test_constexpr_compare(a, static_cast<long long>(2));
   a += do_test_constexpr_compare(a, static_cast<unsigned long long>(2));
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
   {
      a += do_test_constexpr_compare(a, static_cast<boost::int128_type>(2));
      a += do_test_constexpr_compare(a, static_cast<boost::uint128_type>(2));
      a -= do_test_constexpr_compare(a, static_cast<boost::int128_type>(2));
      a -= do_test_constexpr_compare(a, static_cast<boost::uint128_type>(2));
   }
#endif

   if constexpr (boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_floating_point)
   {
      a += do_test_constexpr_compare(a, static_cast<float>(2));
      a += do_test_constexpr_compare(a, static_cast<double>(2));
      a += do_test_constexpr_compare(a, static_cast<long double>(2));
#if defined(BOOST_HAS_FLOAT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<T, __float128>::value)
      a += do_test_constexpr_compare(a, static_cast<__float128>(2));
#endif
    }
   return a;
}

// clang-format on


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_arithmetic_backend.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "constexpr_arithmetric_test.hpp"
#include "../performance/arithmetic_backend.hpp"

template <class T>
constexpr int expected_1()
{
#ifdef BOOST_HAS_INT128
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
      return 230;
   else
#endif
      return 210;
}
template <class T>
constexpr int expected_2()
{
#ifdef BOOST_HAS_INT128
   if constexpr (std::is_constructible<T, boost::int128_type>::value)
      return 120;
   else
#endif
      return 106;
}


int main()
{
   typedef boost::multiprecision::number<boost::multiprecision::backends::arithmetic_backend<long long>, boost::multiprecision::et_off>          int_backend;
   typedef boost::multiprecision::number<boost::multiprecision::backends::arithmetic_backend<unsigned long long>, boost::multiprecision::et_off> unsigned_backend;

   typedef boost::multiprecision::number<boost::multiprecision::backends::arithmetic_backend<long long>, boost::multiprecision::et_on>          int_backend_et;
   typedef boost::multiprecision::number<boost::multiprecision::backends::arithmetic_backend<unsigned long long>, boost::multiprecision::et_on> unsigned_backend_et;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(llv == -108);
      static_assert(d == 554);
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);

      static_assert(b == expected_1<int_backend>());
      static_assert(d == expected_2<unsigned_backend>());
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
      static_assert(b == 82);
      static_assert(d == 82);
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
      static_assert(b == 95);
      static_assert(d == 95);
   }
   //
   // Over again with expression templates turned on:
   //
   {
      constexpr int_backend_et a(22);
      constexpr unsigned_backend_et c(22);
      constexpr int_backend_et b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend_et d = test_constexpr_add_subtract(c);

      static_assert(b == -108);
      static_assert(d == 554);
   }
   {
      constexpr int_backend_et a(22);
      constexpr unsigned_backend_et c(22);
      constexpr int_backend_et b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend_et d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);
   }
   {
      constexpr int_backend_et a(22);
      constexpr unsigned_backend_et c(22);
      constexpr int_backend_et b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend_et d = test_constexpr_bitwise(c);

      static_assert(b == expected_1<int_backend>());
      static_assert(d == expected_2<int_backend>());
   }
   {
      constexpr int_backend_et a(22);
      constexpr unsigned_backend_et c(22);
      constexpr int_backend_et b      = test_constexpr_logical(a);
      constexpr unsigned_backend_et d = test_constexpr_logical(c);
      static_assert(b == 82);
      static_assert(d == 82);
   }
   {
      constexpr int_backend_et a(22);
      constexpr unsigned_backend_et c(22);
      constexpr int_backend_et b      = test_constexpr_compare(a);
      constexpr unsigned_backend_et d = test_constexpr_compare(c);
      static_assert(b == 95);
      static_assert(d == 95);
   }
   std::cout << "Done!" << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"
#include "test.hpp"

#if !defined(BOOST_MP_NO_CONSTEXPR_DETECTION) && !defined(DISABLE_TESTS)

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

int main()
{
   typedef boost::multiprecision::int256_t  int_backend;
   typedef boost::multiprecision::uint256_t unsigned_backend;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(d == 554);
      static_assert(llv == -108);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 230);
      static_assert(d == 120);
#else
      static_assert(b == 210);
      static_assert(d == 106);
#endif

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
#ifdef BOOST_HAS_INT128
      //static_assert(b == 95);
      //static_assert(d == 95);
#else
      static_assert(b == 82);
      static_assert(d == 82);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 95);
      static_assert(d == 95);
#else
      static_assert(b == 95);
      static_assert(d == 95);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
   }
   return boost::report_errors();
}
#else
int main() {}
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_2.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/config.hpp>
#undef BOOST_HAS_INT128
#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"
#include "test.hpp"

#if !defined(BOOST_MP_NO_CONSTEXPR_DETECTION) && !defined(DISABLE_TESTS)

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

int main()
{
   typedef boost::multiprecision::int128_t  int_backend;
   typedef boost::multiprecision::uint128_t unsigned_backend;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(d == 554);
      static_assert(llv == -108);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 230);
      static_assert(d == 120);
#else
      static_assert(b == 210);
      static_assert(d == 106);
#endif

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
#ifdef BOOST_HAS_INT128
      //static_assert(b == 95);
      //static_assert(d == 95);
#else
      static_assert(b == 82);
      static_assert(d == 82);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 95);
      static_assert(d == 95);
#else
      static_assert(b == 95);
      static_assert(d == 95);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
   }
   return boost::report_errors();
}
#else
int main(){}
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_3.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"
#include "test.hpp"

#if !defined(BOOST_MP_NO_CONSTEXPR_DETECTION) && !defined(DISABLE_TESTS)

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

int main()
{
   typedef boost::multiprecision::checked_int256_t  int_backend;
   typedef boost::multiprecision::checked_uint256_t unsigned_backend;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(d == 554);
      static_assert(llv == -108);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 230);
      static_assert(d == 120);
#else
      static_assert(b == 210);
      static_assert(d == 106);
#endif

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
#ifdef BOOST_HAS_INT128
      //static_assert(b == 95);
      //static_assert(d == 95);
#else
      static_assert(b == 82);
      static_assert(d == 82);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 95);
      static_assert(d == 95);
#else
      static_assert(b == 95);
      static_assert(d == 95);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
   }
   return boost::report_errors();
}
#else
int main(){}
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_4.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"
#include "test.hpp"

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

int main()
{
   typedef boost::multiprecision::checked_int128_t  int_backend;
   typedef boost::multiprecision::checked_uint128_t unsigned_backend;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(d == 554);
      static_assert(llv == -108);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 230);
      static_assert(d == 120);
#else
      static_assert(b == 210);
      static_assert(d == 106);
#endif

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
#ifdef BOOST_HAS_INT128
      //static_assert(b == 95);
      //static_assert(d == 95);
#else
      static_assert(b == 82);
      static_assert(d == 82);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 95);
      static_assert(d == 95);
#else
      static_assert(b == 95);
      static_assert(d == 95);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
   }
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_5.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Contains Quickbook markup, using in Boost.Multiprecision.qbk section on Literals and constexpr, penultimate section on factorials.

#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"
#include "boost/multiprecision/integer.hpp"
#include "test.hpp"

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

//[factorial_decl
template <class T>
constexpr T factorial(const T& a)
{
   return a ? a * factorial(a - 1) : 1;
}
//]

template <class T, class U>
constexpr T big_mul(const U& a, const U& b)
{
   using boost::multiprecision::multiply;
   T result = T();
   multiply(result, a, b);
   return result;
}
template <class T, class U>
constexpr T big_add(const U& a, const U& b)
{
   using boost::multiprecision::add;
   T result = T();
   add(result, a, b);
   return result;
}
template <class T, class U>
constexpr T big_sub(const U& a, const U& b)
{
   using boost::multiprecision::subtract;
   T result = T();
   subtract(result, a, b);
   return result;
}
template <class U>
constexpr U div_qr_d(const U& a, const U& b)
{
   using boost::multiprecision::divide_qr;
   U result = U();
   U r      = U();
   divide_qr(a, b, result, r);
   return result;
}
template <class U>
constexpr U div_qr_r(const U& a, const U& b)
{
   using boost::multiprecision::divide_qr;
   U result = U();
   U r      = U();
   divide_qr(a, b, result, r);
   return r;
}
template <class T>
constexpr T do_bit_set(T val, unsigned pos)
{
   using boost::multiprecision::bit_set;
   bit_set(val, pos);
   return val;
}
template <class T>
constexpr T do_bit_unset(T val, unsigned pos)
{
   using boost::multiprecision::bit_unset;
   bit_unset(val, pos);
   return val;
}
template <class T>
constexpr T do_bit_flip(T val, unsigned pos)
{
   using boost::multiprecision::bit_flip;
   bit_flip(val, pos);
   return val;
}
template <class T>
constexpr T test_swap(T a, T b)
{
   swap(a, b);
   a.swap(b);
   return a;
}

int main()
{
   using namespace boost::multiprecision::literals;

   typedef boost::multiprecision::checked_int1024_t  int_backend;
   typedef boost::multiprecision::checked_int512_t   small_int_backend;
   typedef boost::multiprecision::checked_uint1024_t unsigned_backend;

   constexpr int_backend f1 = factorial(int_backend(31));
   static_assert(f1 == 0x1956ad0aae33a4560c5cd2c000000_cppi);
   constexpr unsigned_backend f2 = factorial(unsigned_backend(31));
   static_assert(f2 == 0x1956ad0aae33a4560c5cd2c000000_cppui);

   //
   // Test integer non-member functions:
   //
   constexpr small_int_backend si1 = (std::numeric_limits<small_int_backend>::max)();
   constexpr small_int_backend si2 = 239876;
   constexpr std::int32_t i        = (std::numeric_limits<int>::max)();
   constexpr std::int32_t j        = 239876;
   // Multiply:
   {
      constexpr int_backend i1 = big_mul<int_backend>(si1, si2);
      int_backend           nc;
      multiply(nc, si1, si2);
      BOOST_CHECK_EQUAL(nc, i1);

      constexpr std::int64_t k = big_mul<std::int64_t>(i, j);
      std::int64_t           ii;
      boost::multiprecision::multiply(ii, i, j);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // Add:
   {
      constexpr int_backend i1 = big_add<int_backend>(si1, si2);
      int_backend           nc;
      add(nc, si1, si2);
      BOOST_CHECK_EQUAL(nc, i1);

      constexpr std::int64_t k = big_add<std::int64_t>(i, j);
      std::int64_t           ii;
      boost::multiprecision::add(ii, i, j);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // Subtract:
   {
      constexpr int_backend i1 = big_sub<int_backend>(si1, -si2);
      int_backend           nc;
      subtract(nc, si1, -si2);
      BOOST_CHECK_EQUAL(nc, i1);

      constexpr std::int64_t k = big_sub<std::int64_t>(i, -j);
      std::int64_t           ii;
      boost::multiprecision::subtract(ii, i, -j);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // divide_qr:
   {
      constexpr small_int_backend i1 = div_qr_d(si1, si2);
      small_int_backend           nc, nc2;
      divide_qr(si1, si2, nc, nc2);
      BOOST_CHECK_EQUAL(nc, i1);

      constexpr std::int64_t k = div_qr_d(i, j);
      std::int32_t           ii, ij;
      boost::multiprecision::divide_qr(i, j, ii, ij);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // divide_qr:
   {
      constexpr small_int_backend i1 = div_qr_r(si1, si2);
      small_int_backend           nc, nc2;
      divide_qr(si1, si2, nc, nc2);
      BOOST_CHECK_EQUAL(nc2, i1);

      constexpr std::int64_t k = div_qr_r(i, j);
      std::int32_t           ii, ij;
      boost::multiprecision::divide_qr(i, j, ii, ij);
      BOOST_CHECK_EQUAL(ij, k);
   }
   // integer_modulus:
   {
      constexpr int     i1 = integer_modulus(si1, 67);
      small_int_backend nc(si1);
      int               r = integer_modulus(nc, 67);
      BOOST_CHECK_EQUAL(r, i1);

      constexpr std::int32_t k = boost::multiprecision::integer_modulus(i, j);
      std::int32_t           ii(i);
      r = boost::multiprecision::integer_modulus(ii, j);
      BOOST_CHECK_EQUAL(r, k);
   }
   // powm:
   {
      constexpr small_int_backend i1 = powm(si1, si2, si2);
      small_int_backend           nc(si1);
      nc = powm(nc, si2, si2);
      BOOST_CHECK_EQUAL(nc, i1);

      constexpr std::int32_t k = boost::multiprecision::powm(i, j, j);
      std::int32_t           ii(i);
      ii = boost::multiprecision::powm(ii, j, j);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // lsb:
   {
      constexpr std::size_t i1 = lsb(si1);
      small_int_backend nc(si1);
      std::size_t nci = lsb(nc);
      BOOST_CHECK_EQUAL(nci, i1);

      constexpr std::size_t k = boost::multiprecision::lsb(i);
      std::size_t ii(i);
      ii = boost::multiprecision::lsb(ii);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // msb:
   {
      constexpr std::size_t i1 = msb(si1);
      small_int_backend nc(si1);
      std::size_t nci = msb(nc);
      BOOST_CHECK_EQUAL(nci, i1);

      constexpr std::size_t k = boost::multiprecision::msb(i);
      std::size_t ii(i);
      ii = boost::multiprecision::msb(ii);
      BOOST_CHECK_EQUAL(ii, k);
   }
   // bit_test:
   {
      constexpr bool b = bit_test(si1, 1);
      static_assert(b);

      constexpr bool k = boost::multiprecision::bit_test(i, 1);
      static_assert(k);
   }
   // bit_set:
   {
      constexpr int_backend i(0);
      constexpr int_backend j = do_bit_set(i, 20);
      static_assert(bit_test(j, 20));

      constexpr int ii(0);
      constexpr int jj = do_bit_set(ii, 20);
      static_assert(boost::multiprecision::bit_test(jj, 20));
   }
   // bit_unset:
   {
      constexpr int_backend r = do_bit_unset(si1, 20);
      static_assert(bit_test(r, 20) == false);

      constexpr int jj = do_bit_unset(i, 20);
      static_assert(boost::multiprecision::bit_test(jj, 20) == false);
   }
   // bit_unset:
   {
      constexpr int_backend r = do_bit_flip(si1, 20);
      static_assert(bit_test(r, 20) == false);

      constexpr int jj = do_bit_flip(i, 20);
      static_assert(boost::multiprecision::bit_test(jj, 20) == false);
   }
   // sqrt:
   {
      constexpr int_backend r = sqrt(si1);
      small_int_backend     nc(si1);
      nc = sqrt(nc);
      BOOST_CHECK_EQUAL(nc, r);
      constexpr int_backend r2 = sqrt(si1 * 1);
      BOOST_CHECK_EQUAL(nc, r2);

      constexpr int jj = boost::multiprecision::sqrt(i);
      int           k  = i;
      k                = boost::multiprecision::sqrt(k);
      BOOST_CHECK_EQUAL(jj, k);
   }
   {
      // swap:
      constexpr small_int_backend r = test_swap(si1, si2);
      static_assert(si1 == r);
   }
   {
      // gcd:
      constexpr int_backend i(si1), j(si1 / 3);
      constexpr int_backend k = gcd(i, j);

      int_backend ii(i), jj(j);
      BOOST_CHECK_EQUAL(k, gcd(ii, jj));

      constexpr unsigned_backend ui(i), uj(j);
      constexpr unsigned_backend uk = gcd(ui, uj);
      unsigned_backend           uii(ui), ujj(uj);
      BOOST_CHECK_EQUAL(uk, gcd(uii, ujj));

      constexpr int_backend l = lcm(i, j);
      BOOST_CHECK_EQUAL(l, lcm(ii, jj));
      constexpr unsigned_backend ul = lcm(ui, uj);
      BOOST_CHECK_EQUAL(ul, lcm(uii, ujj));
   }
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_6.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "boost/multiprecision/cpp_int.hpp"
#include "test.hpp"

template <class T, unsigned Order>
struct const_polynomial
{
 public:
   T data[Order + 1];

 public:
   constexpr const_polynomial(T val = 0) : data{val} {}
   constexpr const_polynomial(const const_polynomial&) = default;
   constexpr const_polynomial(const std::initializer_list<T>& init) : data{}
   {
      if (init.size() > Order + 1)
         throw std::range_error("Too many initializers in list");
      for (unsigned i = 0; i < init.size(); ++i)
         data[i] = init.begin()[i];
   }
   constexpr T& operator[](std::size_t N)
   {
      return data[N];
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return data[N];
   }
   template <class U>
   constexpr T operator()(U val) const
   {
      T result = data[Order];
      for (unsigned i = Order; i > 0; --i)
      {
         result *= val;
         result += data[i - 1];
      }
      return result;
   }
   constexpr const_polynomial<T, Order - 1> derivative() const
   {
      const_polynomial<T, Order - 1> result;
      for (unsigned i = 1; i <= Order; ++i)
      {
         result[i - 1] = (*this)[i] * i;
      }
      return result;
   }
   constexpr const_polynomial operator-()
   {
      const_polynomial t(*this);
      for (unsigned i = 0; i <= Order; ++i)
         t[i] = -t[i];
      return t;
   }
   template <class U>
   constexpr const_polynomial& operator*=(U val)
   {
      for (unsigned i = 0; i <= Order; ++i)
         data[i] = data[i] * val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator/=(U val)
   {
      for (unsigned i = 0; i <= Order; ++i)
         data[i] = data[i] / val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator+=(U val)
   {
      data[0] += val;
      return *this;
   }
   template <class U>
   constexpr const_polynomial& operator-=(U val)
   {
      data[0] -= val;
      return *this;
   }
};

template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, (Order1 > Order2 ? Order1 : Order2)> operator+(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   if
      constexpr(Order1 > Order2)
      {
         const_polynomial<T, Order1> result(a);
         for (unsigned i = 0; i <= Order2; ++i)
            result[i] += b[i];
         return result;
      }
   else
   {
      const_polynomial<T, Order2> result(b);
      for (unsigned i = 0; i <= Order1; ++i)
         result[i] += a[i];
      return result;
   }
}
template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, (Order1 > Order2 ? Order1 : Order2)> operator-(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   if
      constexpr(Order1 > Order2)
      {
         const_polynomial<T, Order1> result(a);
         for (unsigned i = 0; i <= Order2; ++i)
            result[i] -= b[i];
         return result;
      }
   else
   {
      const_polynomial<T, Order2> result(b);
      for (unsigned i = 0; i <= Order1; ++i)
         result[i] = a[i] - b[i];
      return result;
   }
}
template <class T, unsigned Order1, unsigned Order2>
inline constexpr const_polynomial<T, Order1 + Order2> operator*(const const_polynomial<T, Order1>& a, const const_polynomial<T, Order2>& b)
{
   const_polynomial<T, Order1 + Order2> result;
   for (unsigned i = 0; i <= Order1; ++i)
   {
      for (unsigned j = 0; j <= Order2; ++j)
      {
         result[i + j] += a[i] * b[j];
      }
   }
   return result;
}
template <class T, unsigned Order, class U>
inline constexpr const_polynomial<T, Order> operator*(const const_polynomial<T, Order>& a, const U& b)
{
   const_polynomial<T, Order> result(a);
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] *= b;
   }
   return result;
}
template <class U, class T, unsigned Order>
inline constexpr const_polynomial<T, Order> operator*(const U& b, const const_polynomial<T, Order>& a)
{
   const_polynomial<T, Order> result(a);
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] *= b;
   }
   return result;
}
template <class T, unsigned Order, class U>
inline constexpr const_polynomial<T, Order> operator/(const const_polynomial<T, Order>& a, const U& b)
{
   const_polynomial<T, Order> result;
   for (unsigned i = 0; i <= Order; ++i)
   {
      result[i] /= b;
   }
   return result;
}

template <class T, unsigned Order>
class hermite_polynomial
{
   const_polynomial<T, Order> m_data;

 public:
   constexpr hermite_polynomial() : m_data(hermite_polynomial<T, Order - 1>().data() * const_polynomial<T, 1>{0, 2} - hermite_polynomial<T, Order - 1>().data().derivative())
   {
   }
   constexpr const const_polynomial<T, Order>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val) const
   {
      return m_data(val);
   }
};

template <class T>
class hermite_polynomial<T, 0>
{
   const_polynomial<T, 0> m_data;

 public:
   constexpr       hermite_polynomial() : m_data{1} {}
   constexpr const const_polynomial<T, 0>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val)
   {
      return m_data(val);
   }
};

template <class T>
class hermite_polynomial<T, 1>
{
   const_polynomial<T, 1> m_data;

 public:
   constexpr       hermite_polynomial() : m_data{0, 2} {}
   constexpr const const_polynomial<T, 1>& data() const
   {
      return m_data;
   }
   constexpr const T& operator[](std::size_t N) const
   {
      return m_data[N];
   }
   template <class U>
   constexpr T operator()(U val)
   {
      return m_data(val);
   }
};



int main()
{
   using namespace boost::multiprecision::literals;

   typedef boost::multiprecision::checked_int1024_t  int_backend;

   // 8192 x^13 - 319488 x^11 + 4392960 x^9 - 26357760 x^7 + 69189120 x^5 - 69189120 x^3 + 17297280 x
   constexpr hermite_polynomial<int_backend, 13> h;

   static_assert(h[0] == 0);
   static_assert(h[1] == 17297280);
   static_assert(h[2] == 0);
   static_assert(h[3] == -69189120);
   static_assert(h[4] == 0);
   static_assert(h[5] == 69189120);
   static_assert(h[6] == 0);
   static_assert(h[7] == -26357760);
   static_assert(h[8] == 0);
   static_assert(h[9] == 4392960);
   static_assert(h[10] == 0);
   static_assert(h[11] == -319488);
   static_assert(h[12] == 0);
   static_assert(h[13] == 8192);

   return boost::report_errors();
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_cpp_int_7.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).

// Contains Quickbook snippets used by boost/libs/multiprecision/doc/multiprecision.qbk,
// used in section Literal Types and constexpr Support, last example on constexpr randoms.

// A implementation and demonstration of the Keep It Simple Stupid random number generator algorithm https://en.wikipedia.org/wiki/KISS_(algorithm) for cpp_int integers.
// b2 --abbreviate-paths toolset=clang-9.0.0 address-model=64 cxxstd=2a release misc > multiprecision_clang_misc.log

#include <boost/multiprecision/cpp_int.hpp>

#include <iostream>

struct kiss_rand
{
   typedef std::uint64_t result_type;

   constexpr kiss_rand() : x(0x8207ebe160468b32uLL), y(0x2871283e01d45bbduLL), z(0x9c80bfd5db9680c9uLL), c(0x2e2683c2abb878b8uLL) {}
   constexpr kiss_rand(std::uint64_t seed) : x(seed), y(0x2871283e01d45bbduLL), z(0x9c80bfd5db9680c9uLL), c(0x2e2683c2abb878b8uLL) {}
   constexpr kiss_rand(std::uint64_t seed_x, std::uint64_t seed_y) : x(seed_x), y(seed_y), z(0x9c80bfd5db9680c9uLL), c(0x2e2683c2abb878b8uLL) {}
   constexpr kiss_rand(std::uint64_t seed_x, std::uint64_t seed_y, std::uint64_t seed_z) : x(seed_x), y(seed_y), z(seed_z), c(0x2e2683c2abb878b8uLL) {}

   constexpr std::uint64_t operator()()
   {
      return MWC() + XSH() + CNG();
   }

 private:
   constexpr std::uint64_t MWC()
   {
      std::uint64_t t = (x << 58) + c;
      c               = (x >> 6);
      x += t;
      c += (x < t);
      return x;
   }
   constexpr std::uint64_t XSH()
   {
      y ^= (y << 13);
      y ^= (y >> 17);
      return y ^= (y << 43);
   }
   constexpr std::uint64_t CNG()
   {
      return z = 6906969069LL * z + 1234567;
   }
   std::uint64_t x, y, z, c;
};

inline constexpr void hash_combine(std::uint64_t& h, std::uint64_t k)
{
   constexpr const std::uint64_t m = 0xc6a4a7935bd1e995uLL;
   constexpr const int           r = 47;

   k *= m;
   k ^= k >> r;
   k *= m;

   h ^= k;
   h *= m;

   // Completely arbitrary number, to prevent 0's from hashing to 0.
   h += 0xe6546b64;
}

template <std::size_t N>
inline constexpr std::uint64_t string_to_hash(const char (&s)[N])
{
   std::uint64_t hash(0);
   for (unsigned i = 0; i < N; ++i)
      hash_combine(hash, s[i]);
   return hash;
}

template <class UnsignedInteger>
struct multiprecision_generator
{
   typedef UnsignedInteger result_type;
   constexpr               multiprecision_generator(std::uint64_t seed1) : m_gen64(seed1) {}
   constexpr               multiprecision_generator(std::uint64_t seed1, std::uint64_t seed2) : m_gen64(seed1, seed2) {}
   constexpr               multiprecision_generator(std::uint64_t seed1, std::uint64_t seed2, std::uint64_t seed3) : m_gen64(seed1, seed2, seed3) {}

   static constexpr result_type (min)()
   {
      return 0u;
   }
   static constexpr result_type (max)()
   {
      return ~result_type(0u);
   }
   constexpr result_type operator()()
   {
      result_type result(m_gen64());
      unsigned    digits = 64;
      while (digits < std::numeric_limits<result_type>::digits)
      {
         result <<= 64;
         result |= m_gen64();
         digits += 64;
      }
      return result;
   }

 private:
   kiss_rand m_gen64;
};

template <class UnsignedInteger>
constexpr UnsignedInteger nth_random_value(unsigned count = 0)
{
   std::uint64_t                             date_hash = string_to_hash(__DATE__);
   std::uint64_t                             time_hash = string_to_hash(__TIME__);
   multiprecision_generator<UnsignedInteger> big_gen(date_hash, time_hash);
   for (unsigned i = 0; i < count; ++i)
      big_gen();
   return big_gen();
}

int main()
{
   using namespace boost::multiprecision;

//[random_constexpr_cppint
   constexpr uint1024_t rand = nth_random_value<uint1024_t>(1000);
   std::cout << std::hex << rand << std::endl;
//] [/random_constexpr_cppint]
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/constexpr_test_float128.cpp
================================================
//  (C) Copyright John Maddock 2019.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "constexpr_arithmetric_test.hpp"
#include <boost/multiprecision/float128.hpp>
#include <iostream>

int main()
{
   using boost::multiprecision::float128;

   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_add_subtract(a);

      constexpr __float128 f128 = (__float128)b;
      static_assert(f128 == -108.0f);

      constexpr int i = (int)b;
      static_assert(i == -108);

      constexpr short s = (short)b;
      static_assert(s == -108);
   }
   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_mul_divide(a);
      static_assert((__float128)b == 0);
   }
   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_compare(a);
      static_assert((__float128)b == 119);
   }
   {
      constexpr float128 a(0);
      static_assert(fpclassify(a) == FP_ZERO);
      constexpr float128 b(1);
      static_assert(fpclassify(b) == FP_NORMAL);
      constexpr float128 c(-1);
      static_assert(fpclassify(c) == FP_NORMAL);
      static_assert(abs(c) >= 0);
      static_assert(fabs(c) >= 0);
      constexpr float128 d(std::numeric_limits<float128>::epsilon());
      static_assert(fpclassify(c) == FP_NORMAL);
      constexpr float128 e((std::numeric_limits<float128>::min)());
      static_assert(fpclassify(e) == FP_NORMAL);
      constexpr float128 f((std::numeric_limits<float128>::max)());
      static_assert(fpclassify(f) == FP_NORMAL);
      constexpr float128 g(std::numeric_limits<float128>::lowest());
      static_assert(fpclassify(g) == FP_NORMAL);
      constexpr float128 h(std::numeric_limits<float128>::round_error());
      static_assert(fpclassify(h) == FP_NORMAL);
      constexpr float128 i(std::numeric_limits<float128>::denorm_min());
      static_assert(fpclassify(i) == FP_SUBNORMAL);
      constexpr float128 j(-std::numeric_limits<float128>::denorm_min());
      static_assert(fpclassify(j) == FP_SUBNORMAL);
      constexpr float128 k(std::numeric_limits<float128>::infinity());
      static_assert(fpclassify(k) == FP_INFINITE);
      static_assert(isinf(k));
      static_assert(!isnan(k));
      constexpr float128 l(-std::numeric_limits<float128>::infinity());
      static_assert(fpclassify(l) == FP_INFINITE);
      static_assert(isinf(l));
      static_assert(!isnan(l));
   }
   std::cout << "Done!" << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/eigen.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/eigen.hpp>
#include <iostream>
#include <Eigen/Dense>
#include "test.hpp"

using namespace Eigen;

template <class T>
struct related_number
{
   typedef T type;
};

template <class Num>
void example1()
{
   // expected results first:
   Matrix<Num, 2, 2> r1, r2;
   r1 << 3, 5, 4, 8;
   r2 << -1, -1, 2, 0;
   Matrix<Num, 3, 1> r3;
   r3 << -1, -4, -6;

   Matrix<Num, 2, 2> a;
   a << 1, 2, 3, 4;
   Matrix<Num, Dynamic, Dynamic> b(2, 2);
   b << 2, 3, 1, 4;
   std::cout << "a + b =\n"
             << a + b << std::endl;
   BOOST_CHECK_EQUAL(a + b, r1);
   std::cout << "a - b =\n"
             << a - b << std::endl;
   BOOST_CHECK_EQUAL(a - b, r2);
   std::cout << "Doing a += b;" << std::endl;
   a += b;
   std::cout << "Now a =\n"
             << a << std::endl;
   Matrix<Num, 3, 1> v(1, 2, 3);
   Matrix<Num, 3, 1> w(1, 0, 0);
   std::cout << "-v + w - v =\n"
             << -v + w - v << std::endl;
   BOOST_CHECK_EQUAL(-v + w - v, r3);
}

template <class Num>
void example2()
{
   Matrix<Num, 2, 2> a;
   a << 1, 2, 3, 4;
   Matrix<Num, 3, 1> v(1, 2, 3);
   std::cout << "a * 2.5 =\n"
             << a * 2.5 << std::endl;
   std::cout << "0.1 * v =\n"
             << 0.1 * v << std::endl;
   std::cout << "Doing v *= 2;" << std::endl;
   v *= 2;
   std::cout << "Now v =\n"
             << v << std::endl;
   Num n(4);
   std::cout << "Doing v *= Num;" << std::endl;
   v *= n;
   std::cout << "Now v =\n"
             << v << std::endl;
   typedef typename related_number<Num>::type related_type;
   related_type                               r(6);
   std::cout << "Doing v *= RelatedType;" << std::endl;
   v *= r;
   std::cout << "Now v =\n"
             << v << std::endl;
   std::cout << "RelatedType * v =\n"
             << r * v << std::endl;
   std::cout << "Doing v *= RelatedType^2;" << std::endl;
   v *= r * r;
   std::cout << "Now v =\n"
             << v << std::endl;
   std::cout << "RelatedType^2 * v =\n"
             << r * r * v << std::endl;
}

template <class Num>
void example3()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> a = Matrix<Num, Dynamic, Dynamic>::Random(2, 2);
   cout << "Here is the matrix a\n"
        << a << endl;
   cout << "Here is the matrix a^T\n"
        << a.transpose() << endl;
   cout << "Here is the conjugate of a\n"
        << a.conjugate() << endl;
   cout << "Here is the matrix a^*\n"
        << a.adjoint() << endl;
}

template <class Num>
void example4()
{
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   Matrix<Num, 2, 1> u(-1, 1), v(2, 0);
   std::cout << "Here is mat*mat:\n"
             << mat * mat << std::endl;
   std::cout << "Here is mat*u:\n"
             << mat * u << std::endl;
   std::cout << "Here is u^T*mat:\n"
             << u.transpose() * mat << std::endl;
   std::cout << "Here is u^T*v:\n"
             << u.transpose() * v << std::endl;
   std::cout << "Here is u*v^T:\n"
             << u * v.transpose() << std::endl;
   std::cout << "Let's multiply mat by itself" << std::endl;
   mat = mat * mat;
   std::cout << "Now mat is mat:\n"
             << mat << std::endl;
}

template <class Num>
void example5()
{
   using namespace std;
   Matrix<Num, 3, 1> v(1, 2, 3);
   Matrix<Num, 3, 1> w(0, 1, 2);
   cout << "Dot product: " << v.dot(w) << endl;
   Num dp = v.adjoint() * w; // automatic conversion of the inner product to a scalar
   cout << "Dot product via a matrix product: " << dp << endl;
   cout << "Cross product:\n"
        << v.cross(w) << endl;
}

template <class Num>
void example6()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;
}

template <class Num>
void example7()
{
   using namespace std;

   Array<Num, Dynamic, Dynamic> m(2, 2);

   // assign some values coefficient by coefficient
   m(0, 0) = 1.0;
   m(0, 1) = 2.0;
   m(1, 0) = 3.0;
   m(1, 1) = m(0, 1) + m(1, 0);

   // print values to standard output
   cout << m << endl
        << endl;

   // using the comma-initializer is also allowed
   m << 1.0, 2.0,
       3.0, 4.0;

   // print values to standard output
   cout << m << endl;
}

template <class Num>
void example8()
{
   using namespace std;
   Array<Num, Dynamic, Dynamic> a(3, 3);
   Array<Num, Dynamic, Dynamic> b(3, 3);
   a << 1, 2, 3,
       4, 5, 6,
       7, 8, 9;
   b << 1, 2, 3,
       1, 2, 3,
       1, 2, 3;

   // Adding two arrays
   cout << "a + b = " << endl
        << a + b << endl
        << endl;
   // Subtracting a scalar from an array
   cout << "a - 2 = " << endl
        << a - 2 << endl;
}

template <class Num>
void example9()
{
   using namespace std;
   Array<Num, Dynamic, Dynamic> a(2, 2);
   Array<Num, Dynamic, Dynamic> b(2, 2);
   a << 1, 2,
       3, 4;
   b << 5, 6,
       7, 8;
   cout << "a * b = " << endl
        << a * b << endl;
}

template <class Num>
void example10()
{
   using namespace std;
   Array<Num, Dynamic, 1> a = Array<Num, Dynamic, 1>::Random(5);
   a *= 2;
   cout << "a =" << endl
        << a << endl;
   cout << "a.abs() =" << endl
        << a.abs() << endl;
   cout << "a.abs().sqrt() =" << endl
        << a.abs().sqrt() << endl;
   cout << "a.min(a.abs().sqrt()) =" << endl
        << (a.min)(a.abs().sqrt()) << endl;
}

template <class Num>
void example11()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(2, 2);
   Matrix<Num, Dynamic, Dynamic> n(2, 2);
   Matrix<Num, Dynamic, Dynamic> result(2, 2);
   m << 1, 2,
       3, 4;
   n << 5, 6,
       7, 8;
   result = m * n;
   cout << "-- Matrix m*n: --" << endl
        << result << endl
        << endl;
   result = m.array() * n.array();
   cout << "-- Array m*n: --" << endl
        << result << endl
        << endl;
   result = m.cwiseProduct(n);
   cout << "-- With cwiseProduct: --" << endl
        << result << endl
        << endl;
   result = m.array() + 4;
   cout << "-- Array m + 4: --" << endl
        << result << endl
        << endl;
}

template <class Num>
void example12()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(2, 2);
   Matrix<Num, Dynamic, Dynamic> n(2, 2);
   Matrix<Num, Dynamic, Dynamic> result(2, 2);
   m << 1, 2,
       3, 4;
   n << 5, 6,
       7, 8;

   result = (m.array() + 4).matrix() * m;
   cout << "-- Combination 1: --" << endl
        << result << endl
        << endl;
   result = (m.array() * n.array()).matrix() * m;
   cout << "-- Combination 2: --" << endl
        << result << endl
        << endl;
}

template <class Num>
void example13()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(4, 4);
   m << 1, 2, 3, 4,
       5, 6, 7, 8,
       9, 10, 11, 12,
       13, 14, 15, 16;
   cout << "Block in the middle" << endl;
   cout << m.template block<2, 2>(1, 1) << endl
        << endl;
   for (int i = 1; i <= 3; ++i)
   {
      cout << "Block of size " << i << "x" << i << endl;
      cout << m.block(0, 0, i, i) << endl
           << endl;
   }
}

template <class Num>
void example14()
{
   using namespace std;
   Array<Num, 2, 2> m;
   m << 1, 2,
       3, 4;
   Array<Num, 4, 4> a = Array<Num, 4, 4>::Constant(0.6);
   cout << "Here is the array a:" << endl
        << a << endl
        << endl;
   a.template block<2, 2>(1, 1) = m;
   cout << "Here is now a with m copied into its central 2x2 block:" << endl
        << a << endl
        << endl;
   a.block(0, 0, 2, 3) = a.block(2, 1, 2, 3);
   cout << "Here is now a with bottom-right 2x3 block copied into top-left 2x2 block:" << endl
        << a << endl
        << endl;
}

template <class Num>
void example15()
{
   using namespace std;
   Eigen::Matrix<Num, Dynamic, Dynamic> m(3, 3);
   m << 1, 2, 3,
       4, 5, 6,
       7, 8, 9;
   cout << "Here is the matrix m:" << endl
        << m << endl;
   cout << "2nd Row: " << m.row(1) << endl;
   m.col(2) += 3 * m.col(0);
   cout << "After adding 3 times the first column into the third column, the matrix m is:\n";
   cout << m << endl;
}

template <class Num>
void example16()
{
   using namespace std;
   Matrix<Num, 4, 4> m;
   m << 1, 2, 3, 4,
       5, 6, 7, 8,
       9, 10, 11, 12,
       13, 14, 15, 16;
   cout << "m.leftCols(2) =" << endl
        << m.leftCols(2) << endl
        << endl;
   cout << "m.bottomRows<2>() =" << endl
        << m.template bottomRows<2>() << endl
        << endl;
   m.topLeftCorner(1, 3) = m.bottomRightCorner(3, 1).transpose();
   cout << "After assignment, m = " << endl
        << m << endl;
}

template <class Num>
void example17()
{
   using namespace std;
   Array<Num, Dynamic, 1> v(6);
   v << 1, 2, 3, 4, 5, 6;
   cout << "v.head(3) =" << endl
        << v.head(3) << endl
        << endl;
   cout << "v.tail<3>() = " << endl
        << v.template tail<3>() << endl
        << endl;
   v.segment(1, 4) *= 2;
   cout << "after 'v.segment(1,4) *= 2', v =" << endl
        << v << endl;
}

template <class Num>
void example18()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;

   BOOST_CHECK_EQUAL(mat.sum(), 10);
   BOOST_CHECK_EQUAL(mat.prod(), 24);
   BOOST_CHECK_EQUAL(mat.mean(), Num(5) / 2);
   BOOST_CHECK_EQUAL(mat.minCoeff(), 1);
   BOOST_CHECK_EQUAL(mat.maxCoeff(), 4);
   BOOST_CHECK_EQUAL(mat.trace(), 5);
}

template <class Num>
void example18a()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   //cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   //cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;
}

template <class Num>
void example19()
{
   using namespace std;
   Matrix<Num, Dynamic, 1>       v(2);
   Matrix<Num, Dynamic, Dynamic> m(2, 2), n(2, 2);

   v << -1,
       2;

   m << 1, -2,
       -3, 4;
   cout << "v.squaredNorm() = " << v.squaredNorm() << endl;
   cout << "v.norm() = " << v.norm() << endl;
   cout << "v.lpNorm<1>() = " << v.template lpNorm<1>() << endl;
   cout << "v.lpNorm<Infinity>() = " << v.template lpNorm<Infinity>() << endl;
   cout << endl;
   cout << "m.squaredNorm() = " << m.squaredNorm() << endl;
   cout << "m.norm() = " << m.norm() << endl;
   cout << "m.lpNorm<1>() = " << m.template lpNorm<1>() << endl;
   cout << "m.lpNorm<Infinity>() = " << m.template lpNorm<Infinity>() << endl;
}

template <class Num>
void example20()
{
   using namespace std;
   Matrix<Num, 3, 3> A;
   Matrix<Num, 3, 1> b;
   A << 1, 2, 3, 4, 5, 6, 7, 8, 10;
   b << 3, 3, 4;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "Here is the vector b:\n"
        << b << endl;
   Matrix<Num, 3, 1> x = A.colPivHouseholderQr().solve(b);
   cout << "The solution is:\n"
        << x << endl;
}

template <class Num>
void example21()
{
   using namespace std;
   Matrix<Num, 2, 2> A, b;
   A << 2, -1, -1, 3;
   b << 1, 2, 3, 1;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "Here is the right hand side b:\n"
        << b << endl;
   Matrix<Num, 2, 2> x = A.ldlt().solve(b);
   cout << "The solution is:\n"
        << x << endl;
}

template <class Num>
void example22()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> A              = Matrix<Num, Dynamic, Dynamic>::Random(100, 100);
   Matrix<Num, Dynamic, Dynamic> b              = Matrix<Num, Dynamic, Dynamic>::Random(100, 50);
   Matrix<Num, Dynamic, Dynamic> x              = A.fullPivLu().solve(b);
   Matrix<Num, Dynamic, Dynamic> axmb           = A * x - b;
   double                        relative_error = static_cast<double>(abs(axmb.norm() / b.norm())); // norm() is L2 norm
   cout << "norm1 = " << axmb.norm() << endl;
   cout << "norm2 = " << b.norm() << endl;
   cout << "The relative error is:\n"
        << relative_error << endl;
}

template <class Num>
void example23()
{
   using namespace std;
   Matrix<Num, 2, 2> A;
   A << 1, 2, 2, 3;
   cout << "Here is the matrix A:\n"
        << A << endl;
   SelfAdjointEigenSolver<Matrix<Num, 2, 2> > eigensolver(A);
   if (eigensolver.info() != Success)
   {
      std::cout << "Eigenvalue solver failed!" << endl;
   }
   else
   {
      cout << "The eigenvalues of A are:\n"
           << eigensolver.eigenvalues() << endl;
      cout << "Here's a matrix whose columns are eigenvectors of A \n"
           << "corresponding to these eigenvalues:\n"
           << eigensolver.eigenvectors() << endl;
   }
}

template <class Num>
void example24()
{
   using namespace std;
   Matrix<Num, 3, 3> A;
   A << 1, 2, 1,
       2, 1, 0,
       -1, 1, 2;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "The determinant of A is " << A.determinant() << endl;
   cout << "The inverse of A is:\n"
        << A.inverse() << endl;
}

template <class Num>
void test_integer_type()
{
   example1<Num>();
   //example2<Num>();
   example18<Num>();
}

template <class Num>
void test_float_type()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example1<Num>();
   example2<Num>();
   example4<Num>();
   example5<Num>();
   example6<Num>();
   example7<Num>();
   example8<Num>();
   example9<Num>();
   example10<Num>();
   example11<Num>();
   example12<Num>();
   example13<Num>();
   example14<Num>();
   example15<Num>();
   example16<Num>();
   example17<Num>();
}

template <class Num>
void test_float_type_2()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example18<Num>();
   example19<Num>();
   example20<Num>();
#if EIGEN_VERSION_AT_LEAST(3, 4, 0) || (BOOST_CXX_VERSION <= 201703L)
   example21<Num>();
#endif
}

template <class Num>
void test_float_type_3()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example22<Num>();
   example23<Num>();
   example24<Num>();
}

template <class Num>
void test_complex_type()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example1<Num>();
   example2<Num>();
   example3<Num>();
   example4<Num>();
   example5<Num>();
   example7<Num>();
   example8<Num>();
   example9<Num>();
   example11<Num>();
   example12<Num>();
   example13<Num>();
   example14<Num>();
   example15<Num>();
   example16<Num>();
   example17<Num>();
   example18a<Num>();
   example19<Num>();
   example20<Num>();
#if EIGEN_VERSION_AT_LEAST(3, 4, 0) || (BOOST_CXX_VERSION <= 201703L)
   example21<Num>();
#endif
   example22<Num>();
   // example23<Num>();  //requires comparisons.
   example24<Num>();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_167.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test.hpp"

int main()
{
   try{
      std::locale::global(std::locale("en-US"));
      boost::multiprecision::cpp_dec_float_50 d("1234.56");
      std::string s = d.str();

      BOOST_CHECK_EQUAL(s, "1234.56");
   }
   catch(const std::runtime_error&){}  // No en-US locale

   return boost::report_errors();
}




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_175.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

using namespace boost::multiprecision;

template <class B, expression_template_option ET, class T>
void check_type_is_number(const number<B, ET>& v, T t) 
{
   BOOST_CHECK_EQUAL(v, t);
}

template <class T, class U>
void check_type_is_number(const T&, U)
{
   static_assert(sizeof(T) == 1, "Oooops we appear to have an expression template when we should not have done so!");
}

int main()
{
   cpp_dec_float_50 a(1), b(2), c(3);
   check_type_is_number(-cpp_dec_float_50(3), -3);
   check_type_is_number(a + cpp_dec_float_50(3), 4);
   check_type_is_number(a - cpp_dec_float_50(3), -2);
   check_type_is_number(a * cpp_dec_float_50(3), 3);
   check_type_is_number(c / cpp_dec_float_50(3), 1);

   check_type_is_number(cpp_dec_float_50(3) + a, 4);
   check_type_is_number(cpp_dec_float_50(3) - a, 2);
   check_type_is_number(cpp_dec_float_50(3) * a, 3);
   check_type_is_number(cpp_dec_float_50(3) / a, 3);

   check_type_is_number(3 + cpp_dec_float_50(3), 6);
   check_type_is_number(3 - cpp_dec_float_50(3), 0);
   check_type_is_number(3 * cpp_dec_float_50(3), 9);
   check_type_is_number(3 / cpp_dec_float_50(3), 1);

   check_type_is_number(cpp_dec_float_50(3) + 3, 6);
   check_type_is_number(cpp_dec_float_50(3) - 3, 0);
   check_type_is_number(cpp_dec_float_50(3) * 3, 9);
   check_type_is_number(cpp_dec_float_50(3) / 3, 1);
   
   check_type_is_number(-cpp_int(2), -2);
   check_type_is_number(~cpp_int(2), -3);
   check_type_is_number(cpp_int(2) % 3, 2);
   check_type_is_number(2 % cpp_int(3), 2);
   check_type_is_number(2 | cpp_int(3), 2|3);
   check_type_is_number(cpp_int(3)|2, 2|3);
   check_type_is_number(2 & cpp_int(3), 2&3);
   check_type_is_number(cpp_int(3)&2, 2&3);
   check_type_is_number(2 ^ cpp_int(3), 2^3);
   check_type_is_number(cpp_int(3)^2, 2^3);
   check_type_is_number(cpp_int(1) << 4, 1 << 4);
   check_type_is_number(cpp_int(4) >> 1, 2);

   check_type_is_number(asin(cpp_dec_float_50(0)), 0);
   check_type_is_number(pow(cpp_dec_float_50(2), 2), 4);
   check_type_is_number(pow(cpp_dec_float_50(2), b), 4);
   check_type_is_number(pow(2, cpp_dec_float_50(2)), 4);
   check_type_is_number(pow(b, cpp_dec_float_50(2)), 4);
   check_type_is_number(pow(cpp_dec_float_50(2), cpp_dec_float_50(2)), 4);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_248.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>
#include "test.hpp"

using namespace boost::multiprecision;

int main()
{
   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_single>::digits10, 6);
   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_single>::max_digits10, 9);

   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_double>::digits10, 15);
   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_double>::max_digits10, 17);

   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_double_extended>::digits10, 18);
   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_double_extended>::max_digits10, 21);

   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_quad>::digits10, 33);
   BOOST_CHECK_EQUAL(std::numeric_limits<cpp_bin_float_quad>::max_digits10, 36);

   static_assert(std::numeric_limits<cpp_bin_float_single>::digits10 == 6, "Error check");
   static_assert(std::numeric_limits<cpp_bin_float_single>::max_digits10 == 9, "Error check");

   static_assert(std::numeric_limits<cpp_bin_float_double>::digits10 == 15, "Error check");
   static_assert(std::numeric_limits<cpp_bin_float_double>::max_digits10 == 17, "Error check");

   static_assert(std::numeric_limits<cpp_bin_float_double_extended>::digits10 == 18, "Error check");
   static_assert(std::numeric_limits<cpp_bin_float_double_extended>::max_digits10 == 21, "Error check");

   static_assert(std::numeric_limits<cpp_bin_float_quad>::digits10 == 33, "Error check");
   static_assert(std::numeric_limits<cpp_bin_float_quad>::max_digits10 == 36, "Error check");

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_265.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>
#include <boost/math/special_functions/next.hpp>
#include "test.hpp"

using namespace boost::multiprecision;

int main()
{
   mpfr_float_50 half = 0.5;
   mpfr_float_50 under_half = boost::math::float_prior(half);
   BOOST_CHECK_NE(half, under_half);
   int e1, e2;
   mpfr_float_50 norm1, norm2;
   norm1 = frexp(half, &e1);
   norm2 = frexp(under_half, &e2);
   BOOST_CHECK_EQUAL(norm1, half);
   BOOST_CHECK_EQUAL(e1, 0);
   BOOST_CHECK_GT(1, norm2);
   BOOST_CHECK_LE(0.5, norm2);
   BOOST_CHECK_EQUAL(e2, -1);
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_277.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

template <class I>
void test()
{
   I val(1);
   val <<= 512;
   I t(val);
   ++t;
   BOOST_CHECK_EQUAL(t - val, 1);
   --t;
   BOOST_CHECK_EQUAL(t, val);
   --t;
   BOOST_CHECK_EQUAL(val - t, 1);

   val = -val;
   t   = val;
   --t;
   BOOST_CHECK_EQUAL(t - val, -1);
   ++t;
   BOOST_CHECK_EQUAL(t, val);
   ++t;
   BOOST_CHECK_EQUAL(val - t, -1);
}

int main()
{
   test<boost::multiprecision::cpp_int>();
   test<boost::multiprecision::int1024_t>();
   test<boost::multiprecision::checked_int1024_t>();
   return boost::report_errors();
}




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_30.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

struct E
{
   E(boost::multiprecision::cpp_rational const&)
   {
   }
};

void g(boost::multiprecision::cpp_rational const& r)
{
   std::cout << r << std::endl;
}

int main()
{
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !(defined(__APPLE_CC__) && defined(CI_SUPPRESS_KNOWN_ISSUES))
   boost::multiprecision::cpp_int r = 3;
   g(r);
   E x1(r); // triggers explicit conversion operator.
#endif
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_313.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2021 Christopher Kormanyos. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <iomanip>
#include <sstream>

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "test.hpp"

void test()
{
   using local_decfloat_type = boost::multiprecision::cpp_dec_float_100;

   bool result0_is_ok = false;
   bool result1_is_ok = false;

   {
      const local_decfloat_type test = pow(local_decfloat_type{2}, 30) * pow(local_decfloat_type{10}, -3);

      std::stringstream strm;

      strm << std::setprecision(std::numeric_limits<local_decfloat_type>::digits10)
           << std::fixed
           << test;

      result0_is_ok =
         (strm.str() == "1073741.8240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
   }

   {
      const local_decfloat_type test(0.625F);

      std::stringstream strm;

      strm << std::setprecision(std::numeric_limits<local_decfloat_type>::digits10)
           << std::fixed
           << test;

      result1_is_ok =
         (strm.str() == "0.6250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
   }

   const bool result_is_ok = (result0_is_ok && result1_is_ok);

   BOOST_CHECK_EQUAL(result_is_ok, true);
}

int main()
{
   test();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_370.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

int main()
{
   const boost::multiprecision::cpp_int a("500000000000000052504760255204421627079393309355027816932345132815919505535709229444276879024105562954502314530690391078574434507015318513443905076213688875017942541908041275407131568575177172639474548726709751235383681696449966404295647940685784470144122251803020020951078103818191513659921807053133698549053838430992170843235673537548059987539601671975279280846041564435631581262016246808786828637048154067265620710396778995313534536353760281048487250661054626168637371167135426013683337484254647996964562455566714879467026196409913165805735073230830136024016362543811769017875638974011487488573436");
   const boost::multiprecision::cpp_int b("1500000000000000157514280765613264881238179928065083450797035398447758516607127688332830637072316688863506943592071173235723303521045955540331715228641066625053827625724123826221394705725531517918423646180129253706151045089349899212886943822057353410432366755409060062853234311454574540979765421159386595647161515292215193506006556519037965168192736708179557957863203557666055574947146355487693991882510747766220045897624670399027877365714431356466054500731862264092476764347207739651025585146903094168986610767496468412336047796468657032646893153521091155634158263410282629846280069312485301157888001");
   const boost::multiprecision::cpp_int r = gcd(a, b);

   if (a % r)
      return 1;
   if (b % r)
      return 1;
   if (gcd(a / r, b / r) != 1)
      return 1;

   return 0;
}




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_393.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#include <Eigen/Dense>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/eigen.hpp>

typedef boost::multiprecision::cpp_rational               NT;
typedef Eigen::Matrix<NT, Eigen::Dynamic, Eigen::Dynamic> M;

void f(M& m1, M const& m2)
{
   m1 = m2 * m2;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_426.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2019 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include "test.hpp"

template <class T>
void test()
{
   T d = 360;
   for (int i = 2; i >= -2; --i)
   {
      T x = i * d;
      T y = remainder(x, d);
      if (y == 0)
         BOOST_CHECK_EQUAL(signbit(y), signbit(x));
      if (i == 0)
      {
         x = -x;
         y = remainder(x, d);
         if (y == 0)
            BOOST_CHECK_EQUAL(signbit(y), signbit(x));
      }
   }
}

int main()
{
   test<boost::multiprecision::cpp_bin_float_50>();
   // No signed zero:
   //test<boost::multiprecision::cpp_dec_float_50>();
   //test<boost::multiprecision::mpf_float_50>();
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_50>();
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
   return boost::report_errors();
}




================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_464.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2022 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
//  See: https://github.com/boostorg/multiprecision/issues/464

#include <boost/multiprecision/cpp_dec_float.hpp>
#include <locale>
#include "test.hpp"

template <typename T>
void test()
{
    auto a = boost::multiprecision::cpp_dec_float_50 {12345};

    auto d1 = a.convert_to<T>();

    std::locale::global(std::locale("de_DE"));
    auto d2 = a.convert_to<T>();

    BOOST_CHECK_EQUAL(d1, d2);
}

int main(void)
{
    test<double>();
    test<long double>();

    return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_488.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2022 John Maddock. Distributed under the Boost
//  Copyright 2022 Christopher Kormanyos. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <array>
#include <cstdint>
#include <iomanip>
#include <iostream>

#include <boost/multiprecision/cpp_int.hpp>

#include "test.hpp"

int main()
{
   using local_uint265_type = boost::multiprecision::uint256_t;

   std::uint16_t bits[16] = { };
   std::uint8_t  result_bits[16] = { };

   std::fill(std::begin(bits), std::end(bits), static_cast<std::uint16_t>(UINT16_C(0x5678)));
   std::fill(std::begin(result_bits), std::end(result_bits), static_cast<std::uint8_t>(bits[0] & 0xFF));

   local_uint265_type u{}, v{};

   const std::array<bool, static_cast<std::size_t>(UINT8_C(2))> msv_values{ true, false };

   const auto flg = std::cout.flags();

   for (const auto msv_first : msv_values)
   {
      static_cast<void>(import_bits(u, std::begin(bits), std::end(bits), 8u, msv_first));
      static_cast<void>(import_bits(v, std::begin(result_bits), std::end(result_bits), 8u, msv_first));

      std::cout << std::hex << std::uppercase << u << std::endl;

      BOOST_CHECK_EQUAL(u, v);
   }

   std::cout.flags(flg);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/git_issue_98.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_complex.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPC
#include <boost/multiprecision/mpc.hpp>
#endif

struct A
{
   virtual void g() = 0;
};

void f(A&);
void f(boost::multiprecision::cpp_bin_float_50);
void f(boost::multiprecision::cpp_int);
void f(boost::multiprecision::cpp_rational);
void f(boost::multiprecision::cpp_dec_float_50);
void f(boost::multiprecision::cpp_complex_100);
#ifdef TEST_FLOAT128
void f(boost::multiprecision::float128);
#endif
#ifdef TEST_GMP
void f(boost::multiprecision::mpz_int);
void f(boost::multiprecision::mpf_float);
void f(boost::multiprecision::mpq_rational);
#endif
#ifdef TEST_MPFR
void f(boost::multiprecision::mpfr_float);
#endif
#ifdef TEST_MPC
void f(boost::multiprecision::mpc_complex);
#endif

void h(A& a)
{
   f(a);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/cpp_bin_float_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_bin_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_bin_float<50> a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/cpp_dec_float_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

int main()
{
   cpp_dec_float<50> a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/cpp_int_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

int main()
{
   number<cpp_int_backend<> >                                                 a;
   number<cpp_int_backend<>, et_off>                                          b;
   number<cpp_int_backend<64, 64, signed_magnitude, checked, void>, et_off>   c;
   number<cpp_int_backend<128, 128, signed_magnitude, checked, void>, et_off> d;
   number<cpp_int_backend<500, 500, signed_magnitude, checked, void>, et_off> e;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/gmp_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>

using namespace boost::multiprecision;

int main()
{
   mpf_float    a;
   mpz_int      b;
   mpq_rational c;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/mpfr_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpfr.hpp>

using namespace boost::multiprecision;

int main()
{
   mpfr_float a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/include_test/tommath_include_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/tommath.hpp>

using namespace boost::multiprecision;

int main()
{
   tom_int a;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/issue_13148.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

boost::multiprecision::cpp_rational rationalfromStr(const char* str)
{
   boost::multiprecision::cpp_dec_float_50 d1(str);
   boost::multiprecision::cpp_rational     result(d1); // <--- eats CPU forever
   return result;
}

boost::multiprecision::cpp_rational rationalfromStr2(const char* str)
{
   boost::multiprecision::cpp_bin_float_50 d1(str);
   boost::multiprecision::cpp_rational     result(d1); // <--- eats CPU forever
   return result;
}

int main()
{
   // This example is OK.
   {
      boost::multiprecision::cpp_rational expected = 1;
      BOOST_MP_ASSERT(expected == rationalfromStr("1"));
   }
   // This example is OK.
   {
      boost::multiprecision::cpp_rational expected = boost::multiprecision::cpp_rational(25) / boost::multiprecision::cpp_rational(10);
      BOOST_MP_ASSERT(expected == rationalfromStr("2.5"));
   }
   // This example is OK.
   {
      boost::multiprecision::cpp_rational expected = boost::multiprecision::cpp_rational(5) / boost::multiprecision::cpp_rational(1000);
      BOOST_MP_ASSERT(expected == rationalfromStr("0.005"));
   }
   // This example is OK.
   {
      boost::multiprecision::cpp_rational expected = 0;
      BOOST_MP_ASSERT(expected == boost::multiprecision::cpp_rational("0")); // direct cpp_rational from str is OK.
   }
   // This example fails.
   {
      boost::multiprecision::cpp_rational expected = 0;
      // reachable code
      BOOST_MP_ASSERT(expected == rationalfromStr("0")); // cpp_rational from cpp_dec_float_50 is not OK.
            // unreachable code
   }
   {
      boost::multiprecision::cpp_rational expected = 0;
      // reacheble code
      BOOST_MP_ASSERT(expected == rationalfromStr2("0")); // cpp_rational from cpp_dec_float_50 is not OK.
          // unreachable code
   }
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/issue_13301.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>

int main()
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<8, boost::multiprecision::backends::digit_base_2> > quarter_float;

   quarter_float qf(256);

   unsigned int ui = qf.convert_to<unsigned int>();
   if (ui != 256)
      return 1;

   std::uintmax_t m(1), n;
   m <<= std::numeric_limits<std::uintmax_t>::digits - 1;
   qf = m;
   n  = qf.convert_to<std::uintmax_t>();
   if (m != n)
      return 2;
   qf *= 2;
   n = qf.convert_to<std::uintmax_t>();
   m = (std::numeric_limits<std::uintmax_t>::max)();
   if (m != n)
      return 3;

   qf     = 256;
   int si = qf.convert_to<int>();
   if (si != 256)
      return 4;
   std::intmax_t sm(1), sn;
   sm <<= std::numeric_limits<std::intmax_t>::digits - 1;
   qf = sm;
   sn = qf.convert_to<std::intmax_t>();
   if (sm != sn)
      return 5;
   qf *= 2;
   sn = qf.convert_to<std::intmax_t>();
   sm = (std::numeric_limits<std::intmax_t>::max)();
   if (sm != sn)
      return 6;

   // Again with negative numbers:
   qf = -256;
   si = qf.convert_to<int>();
   if (si != -256)
      return 7;
   sm = 1;
   sm <<= std::numeric_limits<std::intmax_t>::digits - 1;
   sm = -sm;
   qf = sm;
   sn = qf.convert_to<std::intmax_t>();
   if (sm != sn)
      return 8;
   qf *= 2;
   sn = qf.convert_to<std::intmax_t>();
   sm = (std::numeric_limits<std::intmax_t>::min)();
   if (sm != sn)
      return 9;

   // Now try conversion to cpp_int:
   qf                               = 256;
   boost::multiprecision::cpp_int i = qf.convert_to<boost::multiprecision::cpp_int>(), j;
   if (i != 256)
      return 10;
   qf = ldexp(qf, 126);
   i  = qf.convert_to<boost::multiprecision::cpp_int>();
   j  = 256;
   j <<= 126;
   if (i != j)
      return 11;

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/gamma.ipp
================================================

//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

static const boost::array<boost::array<typename table_type<T>::type, 3>, 500> gamma = {{{SC_(8.45530509948730468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.11676792084632275714192215809847832812560655161416701540037514678588899552795223636051283861515685855053582939146274240113874531527973814210488207830128530900559599074170389066138081891070712920623473461857632254352617595899153121789055651865429663273105801624222067275035146160407682419814612559770937851333313258174693831239060158272144283644033402005812336141640353704703451805075743457651474500575180336149704581761302422616802534269713673320145810616702623379426577267381016596640646036780085640e+00), SC_(1.10438728442867816609665916944098399086765601795314917615577669041382221945245269046345957164829024229823010663264720601624809651655116368339246859099278886577422386896811750937967494940960029250224075543433744666205413027910764506859493838993507216401131983731121529344952082060498119577899781093069658373786189150246027769179901839580061229387653730476486565832292623869480613925012343335744507187985817127088673548820437219886661135524261767270766239756270078148544872782377812888609878714473093021e-01)},
                                                                                        {SC_(1.39026832580566406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.87837246534584512058304626597150000489120292563756272246130863589440629431328166236343343023478965830481648988944668013833863592688512739847732271129409060356695212103238739655240822053671736250775878014127604440817225103010320322756075484745769185701456653223475749864397685319786785385530182719007531303116138466452735235078861018575437520732342354574967183308070807923233032727588780923086501266291147367564653286869648484915713961300281876539970618140056759819325004245961660980554836491213594461e-01), SC_(-1.18966833717491030777529019926331960352855377707641323046275606078389124027926611789911603150540144713683748681801863772072067302459578683018790819197528173413969356904557087663396842789779718125888832504274452988602707088024742817513733531775897173110489239191365127876847654130551501903438865671258532679739640203442463217240189322306203147786367096739239036281487648421042118138143391813517167916949838797835701356844050619004326570975617904601257077440910867376277877219954044806432791089137635152e-01)},
                                                                                        {SC_(1.43504619598388671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.85908592055477020544823146996462988920753671462990877927427523793784391636857990149923096368122868020391764231333911220440936193158035215379333873738823239728773696032128851923243880532734156757960723683643045365212843713096041451134263420009087064362953191913886157628325070283143368675406959711653730415068180223485945836948634468821206791379329892575297995361852566312748126836116054701645545213593209611892028096694432232545135202461301088136703343459844999000604508302338782169984763967607501314e-01), SC_(-1.21141502936978554470331924245181844536653300286225422140798757837139525637498346623087068230762388958190805297179369893104223420947821790937027145400844138709085611406641604698885150056395888192847451388558341660380510005326476801210828545697252686002267491495285666799318711798085628503140489815338199728719860874280450505965277773655528536902886328052951994398070322644031431224912585052114632613788261969630244977993915035447500319483308338977079266591371885961850522890584558525442875774358053017e-01)},
                                                                                        {SC_(2.42817401885986328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.26548780776578840420381427518520449855608041962978420562324571651972061904909219213050500986673056140976438565871543352029900201913847740572555310587852358164122797887781229263011351199466922757394212036282675265716319706112696638181549111225164845253224133071688478880244916384306812998466169110572223013741424946407661202839829092882797566392445456945362691783965322378415320774013882498835505927125822970066960016136071528037620210173970460365408629248314390843812310532824823798560386378408531758e+00), SC_(2.35457666634852101044747755129837867262195483343254983494923132129084740599968117459876158642974817916730545060077157131801833625262395918879296296970891493947670708984616066541861044565554092681572085484952572699514279293900419924199381144525738569464382042666825565090748449951697963176145208698932021640416912747873111038321169415221202446804427993828714087337477405157815350337354930690780319199568346826770338612483088645913829939414504125261936354188139129621440596127411902107048621213505069787e-01)},
                                                                                        {SC_(3.57062149047851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(3.59555262870334436745200120641865977981082010640223266050140391459729626943767312409363221404703574210201792392329936976650125743512284944198899260106526015752278902956864105662898272567210147921868074256078713905235180221793465538428466586341769298190208746120283067730378397892254705825257704963837122035302991309312466980646767864250193651830956876235658931110573123437458150313676328781121766284025470150078590315090776590886236623802578555557213388547550022167969734537803949609965981618094724875e+00), SC_(1.27969770083427483263559414629301871307474084102320799462455928302879005205354752125421307226546605400047836370140458006536267143631687873530833586669309191906361501163139082755585388593517415370654307293917178772625291488912516115091663101505703539344031184872454811817406134618932582617064239611554551844783746009143025742360911718166833619539628430237988628690562327369791903400381585434826128475496317596229670997626757602054430015393131562841666713598775620637208642977504313979362509202895607109e+00)},
                                                                                        {SC_(4.06173896789550781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(6.48731472437243796002214852775228043537971289437086104501487473581409244022420469963455826960525084857707369435964359746591711750992308312134021384929133564129501204286710897020809578552486451934456957768860362014269537717479180144139729241339620855382881397577147860000032919343487135060920390418900375031787607691106910209429859657872451356560041801073390128288706215902201331458057657139826067439256351480798777075962425946562343717935253011331255750532440357025778171100855280846427732600917368427e+00), SC_(1.86984868922060153870312299296985062230442937856531056759619014069475862184353028955695412404454321279039154862003433554749490171187759936732026866110412946881723664011929498452905443575544100221689429429301260523169470423568601285968829370009543627369171932027568492297164723547129769130081972774445920326671338017681314020368749098739160450063373166716481506986205918192305159100153286510376407089509591108263911145163810109598636638395246173348456104955704883803210682048233858516700403662613611101e+00)},
                                                                                        {SC_(4.62103271484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.37858022875149594619786107410279090175590970152450034841009699269673431346004116478067172178520246853732831755995428799078017457601602619929245113749007303704101480579352988396977510269794581778372002589383281670752713644566761172166567385676042002118864154022560147254396699337453643014632090052598274319291935807114460343942482405484801703954155955722485464313407185661674729088557545190877905944424466140889980199318964713781724109009297813878567602461975916768052038274217796168549609238659912800e+01), SC_(2.62363924281956010702136640841955277162733070564811703055105753296189488826361566652602311409061111092399672290884891722467926760684437721593990663312995512755267781429591466685062354923692239092672056520234671473631058306668809726966855071037418632102365123873577786382809134249130150505178623394283970906330326508036001313708698839654499118129718097194782427944111675244162629125074561075136961120514757170446709158397509674944733810061359837990599512420837675518506637113899833273305688678962765784e+00)},
                                                                                        {SC_(4.95617485046386718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.24718008439809442788209027528859402116653573943432441740659531453629499472973958227907469705875895142256631027950914323449546506579797438670714453791272026575254913719473832861478582258396938106853301770393264870159399799869055007015434958058676797199878997709812870727729689757402018497925646205685684353323505015838079500055817602615533853494694556319446442067489405159190640294404045513497256563510451692946446390653895786899381651426750779600703169258576911088938000280179624657230202494914554453e+01), SC_(3.11226122735527283001436732061482084336251639227376046279662642923418290806738326523996478116609979831948179805587928769153274855556446413175508510433259718452181123790997348386826344699161670878673065209529046397787130480356474953162252901005463887577216685154644547997310645330563385245975795829493688812633389752782939580849857192152477705251876040149405364402545536520601697980677272545641602109841104148780306607027762094861640754264955688050582460828241131111154401178777085333226922469763304802e+00)},
                                                                                        {SC_(5.33216857910156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(4.00553052022210672861172891969975874467163632878273365599590082567135977861246512342058540785194845011420653067457140609085806825580056355742227407837692060683249358855542773800094606807421366553650993901731609418359571760967157147365961249446904066775876923068467870410926669834554889478280924299804868385789300760220221433734929715355322308163278946871106748327149891409242787740148917181937009887358066189115112391852948848072127151790776708831129634358782375387973685405984021144936522217818263887e+01), SC_(3.69026112921665738447356052157805826006261575754715146030823722328052224219481629888200194228992542456666326715599926038404343629111229712712603676960882556465809932702973923780945184481220774715262397366111250231958769743093585550788457957942102664449774653173349379675999754811893646753690219918461483472316926459116111911304869770192038163555120045323216247334529547388917331185628279325595929211450347309515919824526889077762242709640299863499904979658370855846132644540836771202986689516605307719e+00)},
                                                                                        {SC_(5.53525352478027343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(5.54085693989980056689828323360533202581167492518911769584949988804497359322368776091779140395452638417269585036316553435037135219086785310992316684430301271806800120535089861233390960140463559245483746277411779351099714760817803251461088125523272968642271161431162315313967100838668611319145908704926154612773615372669849504199366490997719787759920807270196610305978144012121816428514168683064363810139266508908745055811779478349322540193892120037252674767004050526902154688580542341833753952471325027e+01), SC_(4.01473426408354864195493680270670709888838156351643199813406405422986896254574554048671301238364016812565923123175708018422414574326651898972233934077155639420144616008014038365563539926679491360504159807520765365221328661239870485108541575449867980981545393136165252219742866201168516059324361308415876884333514156647228147093027677746525367094610600724933388522700653405326906335784642279271969391106974692408051454996866825096351519387380897644271891521149125368306133131088394686999544511101518839e+00)},
                                                                                        {SC_(8.76608276367187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.45168218533635930619607726245392030762486255761328567765573105304410142150402005341157069836143490261271426854222130497382499323807115021070916489489298478742485634020491842325402560577110358831959602293247200484183054212413532479513045660120433744022721285308357503948919422710448107932657085485948275312721884150067715974091281450199363008662962715355890258330430671461730647408910607363125434042429218606193952080701992994548099674296660794648968213053267218182313689092204527768537711239353651776e+04), SC_(1.01071147671863185327950157842771848355690961582839471529235262209976315476828727800911954615182577061463048910838217130723874185086084459846607683789832726142832119336764584676848615401316033063394103140884481795844812690718880319719415999249412615982273170075510120797100374050563252653874652680187908298681878272779417833833904258535562275198810553332530273476763030738280101705876045770738375074123044968182559538889713229283788787867195197583120537344575175235851164600007251143003173078342333609e+01)},
                                                                                        {SC_(9.54985427856445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.33124191564895517786198318510639290524555281956888985019623709579905630894735541649077494627871914408573260648955262263687000687922389445792928188297142800467321281724332423337091736902596942422833231242875215268585640866036266522615474645034218515281333865398887209402026567283141579237158080499743426939983616583610354938189196173205223749820692938362654992436789626030738847465823771087487947240361096515842184486374295691072049728572766139104577726261341789838495401824728814337996569514215672530e+05), SC_(1.17990377426754288264606297368466274228437984450810542718576338503909998685774762341929430182869490356000015066861395002069084429748581801250795379187983074979512796001712324478984009900922203447046990385175865774213093475908924123603675885921802990784925766315829148516934071379020928361215249532812742053156207303049568661090315018584992187158785059549794406558582306711751933404845316792962749621780233564966634413100993442521511005188505728824353480225249328012213643562389033203444688486307902948e+01)},
                                                                                        {SC_(9.98056793212890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(3.47351022609890987414462933366655334807141833319973833485251821949760940947774277743644751214737192294292705395291451794427578900001693769046543125025183131602481174315151788533280598536553924629403649863673849420583250744590458701199142358875405761725682245457269733335734933972176546054405142766845620327689012944814485692211235417261699291965304764803083155748787532975237567590477444265639447563674720522368236482299715573776562543955819648355145672683431444493845732956957961329768309749681829985e+05), SC_(1.27580911401497751821060654166800202590984496449712229747428650640526916490109555857587661865937014134922557424041425172181625752089956083590448352036948806676504958753151299078856881837898249233659905040282763080155929482264803438269944110781266460182301983820012339338329983248392343095209177995416838143030575826729498027778841804157021072458776021811820523457953320987753027666066945590262453676053331880351804554644478900495289023610283211137423667420410851307848590104509490230146431500262752007e+01)},
                                                                                        {SC_(1.02951927185058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.08612298941736643153732276006220971148644659875558920927931593935920431599528738660802469977290774445824488741549217537449446921507610892464943125096025919672129084867587667593276450909932572372137644264808977599843418764122976594717814108353372457029584218389242429510238722931886606180430128463378160039188017925774025486288889709479511768650943318951092782687590293596990714433871292584636475060962701358649279139597185057212208578482611189796103472554385131334860031392843178420809951208156923205e+05), SC_(1.34710638279404681644246606540609769374801440275032660885401198256118967063141577514087022647397538479355822457739408871059474039830713174834411157800996577575003311438166402418585060431559564293388138836927893978284436415357597898062083173462936431367544773331148767502281557730664161817089644271957806633291453970250267498511964473754051015546891232872019548172225307272336307735201303435433404493851119019530317135541933469566759049768381966972245871852168677664931061501876261076443912299692533597e+01)},
                                                                                        {SC_(1.03338241577148437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.73986220626843824927920782808904522315975049074439916300919381933777932420492642527484802029254954306553334393810376403407168820887408988932837497169960027734038427684853032090933230195065129695346654952158714462914263685195391164935001537212016209463929695503000587847065615191145442143323988524634373944112251531098789566603760664904054993411039655201562870364683675613858124103659455770298515793225998426718316092021479792672373860638612991767438527054522949865358951955431484811761620729003812382e+05), SC_(1.35593093496056969893535567112872929008143709636940002546329087550711754131154961097197217187455599859178992371199445448253184723282798555078431187938048489946441825776243184601290612049872086792875137747821946976340754196960872289509848440846460379366990183257537708184661560651042893934128712949967929943476493798876208818924397255136148931131306701168208553291581298942881419034795011951056848436534335079031462364949005620152601355133144874348094130199610942718142353840569740996333028520392372556e+01)},
                                                                                        {SC_(1.07135047912597656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.85721439538838439705306064451879294595570947494672710722016789190114576336023487676613177353802996774898485646539303627310434036056012918512753580667010178877478176833272081798430115689170325758260542022430547407739443230778886561790259780329336075012938809440026955925762010679712962413276914273448632895358656771817332068220175020343563819741374166286834026905759809649949412322517870913703226957295986639927654451683223262755262903967113925053844635980417582441070491472062229124222544924029831654e+06), SC_(1.44345882862223439605716424404599011683811886773747370676003171837626128033041503920384113195787471603683676214899764638312008488583005220488335395789219780613434308649120312121034729352210431866865784472394171554538335954672405161157639621786194857241841889876862506839092638714724364137545606219369672259196484835450223961242251728879195312134729976462122220398692613546962503263752599725385404222086718253046013692763924083452585153651775377988077421839166494678150854383938719506103970152877660484e+01)},
                                                                                        {SC_(1.09323768615722656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.09592640575239809666846121677771927780752936023924158222634560987255697519482790694905618663865531239972019760869700752710049719590581148223169481122444885785273943932972303081018927714284131922497997127430750960113524416767507128317210990572045260941311586013903134659634029880246927905370185375976258340419589414037729179865857038384049918002627831330701395495031815286029217668797369925413755055132642560604612676671367161537762429344852598381811521248141946161530867133014459723058597428437642298e+06), SC_(1.49455977426574165881859039685195966050036759954579121951129510480837185650712389225508184363631645514043826849142044045040551855302422436604545319679526057379569083519990130330113590282035739010196088875383247254732201194190303019409460033340883098002366906771159957984278579595308398344453039602978600230132604751443572911980490843010703162398503070960907011556740635051049333707402400411399198983397314439988590436484712278449948781729679812491581015270188673991965076859499698834498233560917960844e+01)},
                                                                                        {SC_(1.21413345336914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.64239751689040135371528638503817996701835072784502236912289045699792089781694820687717658364779020991311296750597862504701825127504810312222159827182159743586084452766637995854336280264240514840579371599354707442049464154449281372330704925798340213382877182134914296548090310931517654388018712040859984515487022805743836777133727700635356020676861026294060728418886449803915821559424461129887396581535139042681015145325091941876084305153799657023785097396446763077777426340282617918626524288619395821e+07), SC_(1.78484047177896642639445392863215588612603563477346865541091120435845320539752039062941627703344836229145165912845742723048104642698908304308667638772267977520902894756788859805097365912048607248507329066498228754882410916966189530240937511360454967870449691910124814867332860502660647255668051145601077719174263919348318346132226844241305817669112243947100811203383986012421488579157948402877689650632629847846451925035467415986612379374365476171911041288360390893986721132229765766169947887290345542e+01)},
                                                                                        {SC_(1.26162376403808593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.82777774460762820033523820034243728079553256953006439450420968262439443258229978114270959300622199344017589718484337858393249911256829041745903345314343540021091394102881560287779214677084313708562306054370961578828297883697715344793988582246419530881616323476544054179572977852567036054414406650284290159158304002405447887376199358950937031103957302647245972058773317232396195945757609876519304214193127881603995124500024819624489413779759179354940420338115740406968621859707865148350733475845952234e+08), SC_(1.90237816256797246227486669171399919483589830643410829499611169780971203727215705417400879721688136824911355853063650984902731234860248092757443311504792998093607313455433758450408496059290244242681574445768041303125717871774734258258916678641036751240624455054024730673671153289368603688545314472036533629426132929060447459830632651096898621496595339844352016930762821590055173084188243609293665424086528103390756940221127719143780039156761291057797334820481397090824517603472596681788452312169840980e+01)},
                                                                                        {SC_(1.29071388244628906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.78979711385686127340767130471521612722379599046594038090610466732167125460890560800984410126533342426520606719054063104503899485854375039568888760720567975382288567002034953346831754769783894495550746676294468918343305967613458205336282656145318524932407160094387129343422463229080277186575794507758607320164639659871754591094259369822469703782501303055901719999275366090375714916904397953707312302390870259506790449629046479476191967195743783510726934853174357019092037673410791812913166721722086061e+08), SC_(1.97529932296499248899054969602240355084343277816619556255091621997733876181221840458375733310196135385376238395185401100147169373094887231377881737783120407576462599446938149701246857892596701863463492500388160036922963943049284016497002288337499802270953933638642449541165787258346216476205325085465966266931418111121786445927723544963171253130667638943355007515068244083212372359033804849408937371366530665125994577600484715961413509838873453584307755874929916416402267850814780033556716715227762552e+01)},
                                                                                        {SC_(1.35178642272949218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.79077380560185807841570990731673158935617629510395723286664787382434734070420593877008246737894206914955382051323852831817642175680990221901969610060683074622704421995675281008392086832771359843513683914881713246638554404384417070742716548305737956113214094245552797225951078125611475598587551455830850591617669298207289396654820780436070659318515035173482574219537805431072651843159786010862043473811995143369242030904717771431696545720568246265152229327411357391069165707328893357622936422285295649e+09), SC_(2.13059136570194254239407391037067150343599098058780133116230659201053633257372017234341370601553301782276116790588041904156794338078073857655337466751556849619829258270710327303032110154928475210007538757757396856518851171282354554599684740830735844823274301963455406614426566730360797546058398185390735765301739067716955024649756045796974198109080635531733693266385265544023263308650055411770824121854510040354730758618787977954637753032683746887026837598494068620361627965127360986086863865184764952e+01)},
                                                                                        {SC_(1.38514175415039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.23325137095218598823971508296873948225192100644656374441758763040983693132346484605144687295568219742283016535118774974652008388142683636350053130008764423355018809447400487103279915093742480389910985450980067599008027299644082243337006654575030469262199653819047967799574420944180011273945204186267448102919341312955232949125097106021914351153335517551925258398293551930646836566455578001158894380204272564162401610398812172090461275428017675992538882528626329695230610272518852177524672384928016285e+09), SC_(2.21662361803630197383736953990278887110574274522483085040259559845237723788490205822308182030543596883541881395918821078845085775974446457476054196005815674612301742772034161774111373919630099608884702083164754366541205908960231443997976417378733390798364374463072495586005992104412336471714153044446120371382372201888375362378102351203405905480129381177692493032749613678787997288916943591927641771378065548744049361287040407849471796087174360733780998130688837875865278700496584306157387077295518105e+01)},
                                                                                        {SC_(1.43832855224609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.69784802869578241859347170270044660362887975172105734174126024565266258464185679860969819855411237159494880208775659644483956130836332702232190530810929795054649744757422772161305573550173240764511358994665056914899731991099146899770847475853729703216656351615055364186019583922630511131963769089890507495016742632213307435586487273302550332698495539906067716345084493618187494962743675749595552332810650864210967199048154977243646054575151056382106763855672206878008442750138657969446338772392977931e+10), SC_(2.35552125136450700909588091745369060423028983139872816520903248095735988926096539408608197096209270376093052063987604229172439260225265802753685264545909375191912435806334754171252744005893682713003301574855225372780111914101629076576865532039773643327758840495625596026543437624197390101438239785844326137114997048983495383674156592651243325855108913317388476131107876404382144566047990082712164794523533480397041648000824123176019495113050076473636073664863555590914648212166240698682112904657612891e+01)},
                                                                                        {SC_(1.48963279724121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.60935895139790537882629053978367065158097494775553779389162718199800962660976404867451369776960552719236591600432068910267380128788079356527364053960742437279838325192792879200780876443511952756771766081043863962521162104251062512261561306936965054762849927286751693584912828216488502812828560112184399975250481114240534601033379784321671805062685095378497826204531693763778896248141719307161590520638212293837683630156089631247838355678237432158041439105369297598948436211360132325716321014950992967e+10), SC_(2.49143375974668240626505214390533380688347483901923600653194410711886779420898803117624305175150341043802258914439817725968253567447217611716808423940751959127906426790655770430309975977208455470753965004376884277299048155174271626994824768948180598101500479226249068284441503076898274128487586798561957754510391434547445793560602560270702926430292523945864871226551425545008082382964277470607798416267823092545061380983203872604535986283661640712327778671943611430748664004317504626424589546239492000e+01)},
                                                                                        {SC_(1.53649291992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.32398807872101770462604880522949845437561627327099970169031926625880177450787091305806943792425166226349760109416361742988524722129994365817234844238217238280776183875198531958136053329307878216615519634840197124976984100478274525072421035701533163566711522102036089012153312827728373125004089091452062656302048171592405945248902229742770091130711022681649993555144430335475329700255829237894423454387315510994513159322878742867851744054629488404979443584886753077599413674731935221399660481631292785e+11), SC_(2.61717207322728943748655952468525991290519456198208118720796690982830007941145343499391768661158582463079187427238318410030877071806806689640550339944814862447936256191385266543955562161363885472431312410894245972233609522570605788757616905274288631653175310899279503906728266948467958956851326816621095525631182949074151124133792081477439296299976706029974164766593650975684320159080549146560042369407008513487199017496956162903888043233189053512653189235110362053698908875636116486463805068025729702e+01)},
                                                                                        {SC_(1.59457702636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.12715953502483062538557724081013911658822971839811638302861945974572255693067688962255936258136107927159156397019302467458578812492570380812155193959085864099568927830194891977976197587003543495844952826714426145342302680345261219277889687416267358065688920139224042982062304137579381400020918547309462488468333765784769924476330423965481843915430241826273531524867193316237485463139697249608343870171918262645258569752948674306051499024008349628321871360036489296090979855831343665951404747705820007e+12), SC_(2.77507218982215256456907361110029229287160594943095798751436085766564504848854056383180784211923609266348581824808197706776547521649865250928950387154147803287982062394737447091407237366260446253353498962361092296149900138781573804265098616530053928097718490754142074711308776540737540544940575655663700893805298458558736564909026609952731500867191306772061678923921512976870506621853315858796712939270551000744125644547207963447164060931746695822731105902019293199464525704273081787738905029417478261e+01)},
                                                                                        {SC_(1.61850357055664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.17392722860575210882743801148121974761526064642942975611851093967221905620309266419763230958019607719000964328222165770505474606502916318180914198593539748204197180563392900865765447623021484552114088793224264781542092820754404856979476987230596794282235555744748141761312510208561694016754873643072407001696236285213178526503889324998095255469101726657562023259585497407965044819950637365173544139973145694386482527985943557955822398804411240998455445554905356819455967232872943701528948385375416924e+12), SC_(2.84075564305649017910192637580161893383118048529446948578453913521326656332735959875038712393333194906778182926725108659503499356843472051464004490569862771906374142762551592434578842405679502902794587372543569122097856395778041583912094359797049297611712374378720254058067502855335154430899898507999303154087163660771590573370318847901286702302096288936111417508352764313313004247849530921319320099265194394899418464209193302262016659209266350773235272677342977910119493741328205818274708511919664895e+01)},
                                                                                        {SC_(1.79338607788085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.94378015972887884516054763336910522189606118466825966602817074458033507748376119333205280093377734568080933812880181397469279239108543720418046546393242253747231118747614435825455274299153710665198721150627177394186314404834695391882245373547307599961727815738420343965876901510326203038625545238547437760286841659242817122054781772597614247162591992302074382664668628852013285031977346808546879744116856146662512084091293248247506035169514171475602206223147110130035231646012874447469928518936288101e+14), SC_(3.33158858259898907905342233247024675861169393707251938469191257033208410100917459972779143360867650229432762775061293525931944909544742308642071992211692350145763818232133352151340411577042857364193387310895562018291498977196157678047600884999805062602410706712089770431715110819479340956053207090126277256504183113502483235445467450928666924159010047323141890303181109020773812171510173380978164764095893619679219250456889910946305970721684560117313859764609917216519924334102644122154693368351826177e+01)},
                                                                                        {SC_(2.02786102294921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.78859109957017847350282806920274651443560302946482537725653125558373588979620547457174307951510988004914510354699121792937106881509562013001424269265755625105237218390644714062461417356368115049002169379320461604955950947878703486762597646209323773900580501157767451153175713764274367992499988740605431735689546683299489274110181899056071627310526130380543907317998501513254047217553619093579672465892040589757413955618873138414486248533989782506156014995258049759728528931005608771532253666614776864e+17), SC_(4.01694830669526712285716830720908080882784605592145521661108558578316317527808950051455910908149355285774153589463257476880357990334424535910402395335745791832884031280007396583426939303870758983307128710895934002284078747537321267500943681680075881059064170031571211276699731527486478859823036488211903833218942468550621597608313941585272130442321011122624067155297304145649696594141596950613934123390910581816377733641660900214634788029862302747808523415329729542689300928045459098419353956909660512e+01)},
                                                                                        {SC_(2.27562866210937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.26972717526065453243497606415341251348549318454328749063345501016789022692738877593139482043483197655452092404409624945435401219712933394751055303990142982542638490626258864903914758776542688825607921286094934655746026741953782617609006929140731656413762147816621347941826019166397620687687617958338526588369802976978492139986030868846810514654286239871261821515071359533295231298352162735118150234734814078164911480645099484217443573112986205065139813455381998998545524503845393344966318045384553643e+20), SC_(4.77136804516938476798186533137278659568953865881033246633845276278658930669490843676898202801665172965195014497394786428050799441324442769697063319265977100562116857211797345235476803678040110610393920650678206124524914628475872696681953068587543500695636587855133335172354100595270626035010678536436625753656761085054662461148396845219288688834873129706103341090689496045171046767844064903536927719224669351215677098391551160145540606820140357781318863155446012873587956509028891262429102384752237783e+01)},
                                                                                        {SC_(2.27900009155273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.85098335220656084805303753490068761820757328359109281073754662291972968463434371144214286766024639873517031309922165539968225455173766065339586915138107926116592127888942444414715885558417950943361068757427461766594924751498397917726333322398470362673163297540882067039707423998766149888779324104167300223636316709020288618852558987393457348461154024630406699740543022425870516117498401176476538043477712028469899604089430212225785183179305838104047207860532079130574368373942186221880210190007152526e+20), SC_(4.78183116013926830266939183259939860179077401608681053044395603667528238495675049839336412704201043952154019083949862173611780027988181004560828830103443451954397089056210419243214747839359840199778090722414767193111651430144242363037947410279734322169557386711391485096580518452505090282238086183149731814313987854823078824578754372724074767852358281888048711745936844806125636457727893417650220468092526639171962956440715985639690264187827522903473648954513132769343415198697642180909536890448571370e+01)},
                                                                                        {SC_(2.32671051025390625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.58604880812110241454443187344936017835854008969901521612448078397011725521182274260449918557110867645491107680639172390431077293986497620091929943773518926625158875779142019678847319857283976396460950914258149177614913206540387945470639191549918779093413871219422081680931454303332602911745577297158040318588167794015942180633957877188108408414511350070549894143107543827204317830609472493471081736807394919923691843857608432586473210000605737670045134417963755562386466190925672412878850646405985887e+21), SC_(4.93044181070299253236362391869236800187815014597272180541031308288681644381707365789003158170467418713749315130448968112655720169833488122960784450610406416247180917673304201957658843133539076388057790707488923355640879455639581251965002019288706112569136442372744159529269447953305171290350588295132657475268242628869310697250145988245409523776241535152519668623579732121296216600629204372942165520109491547688534215654314055296728672031442410394104670473467792491661621391099880487208839854451013164e+01)},
                                                                                        {SC_(2.34526596069335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.62194975792841895720749223385860556288827451704690827966867908358586186377510532992856117196302979122682031742504675468607786075384709904759085834558269602839780592168397856053584192386946531537679056796693158685843165754560716769122635655901255012872787428573542960450960109793983675945004952430318551725091155795551025628653468443465024160434232452983803513580832219466805463816175449786449373136370649942608714940833213805408426003631122813929992880369255230264983494510767186840201746783450842382e+21), SC_(4.98851035944665136137672192015001725735574448523513365461276385649832019558648067889044179541346456242532613476455989696732448879451563256006193760059216702387425562105599088225278858290384189947360462270135584506260058165911777571573884965611063658304139334304428754483287036131773544287342207371086479812475077828218358906305532901236624147816345056599647796401492252269211474910191441753003225672987417389814408598457591482775445660906950641840923145254581785944936501393209938814257429135828147670e+01)},
                                                                                        {SC_(2.43377304077148437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.52671715713697706891160979125509726305938336857375227981739347280081698156098205470753157358393470750460871546434129104796564469110666737796570417551872488487369188073057706502594714426114378400481728758709479982948715130976959130779570582764471731950180408630090081483358852495530725513094749077112560162052669265512824439653875495097130381916363837830846819531583435928645935366793957053876871421785132869570879272293855874083797851986233376775948840120201836281261161838742176319534574897501178287e+22), SC_(5.26753310241112015000557522065224390350586849934355945402173111140887220444172828628317710236715689207521455346719297310453881219153304785874778678385796785828487745332446719392011066902186110879351599887877146447912243725688438833509660397006601972675603832872488107271508427519999279790089693902852256436143910726195407163225441297282809223811266507340119799040506075622206616925202471755069436203816801744865249899061716663635367511603763321855757959797826421739362819278936784467235526333240005423e+01)},
                                                                                        {SC_(2.51464080810546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.91481931939477877200409821527464389427790319314797981010141882262885019600788076048644650040650377535362177964203706602145245768311983616827224624813381373244539635935498182983132360406349699087792646029860366167832523331450326682612483319992522395430103670071900483202700829114060346675708927264287445975661170857236542789818463947863119214258860704868166437681591110751004614832328001369775822848877648740658467576865672192485902213245799314604742998766424238759484022554804825427810329237718912340e+23), SC_(5.52534876777131248526088011136399421247639005261200942662339884519382967508816892218214048321898008927408573543448324823195874404479702411208644428859048494602762423291775256567201245544467201367992361359313525579920316298681194519601969564215992810071603097749504526447365148514435274271195385846780047802038148332510936367474259891938847053684708322750072216689143695444833185320648783070435734567796528700749836875689519053250541378436858107409851809731784721711286317464058683088715442244108225872e+01)},
                                                                                        {SC_(2.53307495117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.79121106112468838114091066050696844501804129293613245609247373367728816889376752295492985773345298518680345254160672777414539504784062244034366992927071130241068099215571660785123653342892863707964883249932645030018511623502406446490102199974777274991930181335480495211340080137603634352285453834075031871718395777239743551495314947314361106557691247822941892794875598790154099400695381011643266719344568091225519853749774286383156255603731266332110509289734693913588439967324719134777130623892593179e+24), SC_(5.58449341933998661286597122372310908068026588697772263463044249340345894176388328944725581420298209141152460517528540753526893441781211306768929743670148144017974107618983180476923611386416457648485096243289792960090120596855752984855873603997392677295099339567129282671168990101291687441406306439558829817161464809106382589575255498512347192513308661185569879472434035194625729156771795356097872108174749327142347398543920205622238328863320715757170431227274886985176738777251222302350541069469760158e+01)},
                                                                                        {SC_(2.56547317504882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.08185222038264310688484759500453549449343601064644164578226877871835233183599988599849700771875502956914278412964901381416613960210544679350823989995570437369036190734750778318562793404061483974309879014653863257393556814923674671866439781516249984035720382974086561705649167984614024640607429055768235065807548056537920522450166912638945908740103020466720001647701905360891552471313012203374488015308653398882613931193426996660927901125500252723485067627245831870925718793482515777531619053612687460e+24), SC_(5.68877180373048439806916604413364161076870205125629884067172953865884788640557118206524342356674419695257884468542292195573826085853803663075083194084437053651584483581690843123643213703040991328755997152307630162420977755970157738226132226009170471317409024940261640805586477529151547757888099874951697765060606236562111098316847459517577939192610719956677422578169633736070048128858421326896189519142109020020555616416933177181768098595337956671066929651426668945879292365721802750367824630784573999e+01)},
                                                                                        {SC_(2.69469451904296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.38946145226621904297694624320451302066263074623211393616779873785651027366717911648120891981347459583972771523166906685960614818223537432379830257868186481779524300591340059147240741531278586780245686715266947950598093181762116682854730864826733954340270125961248165415267045490110541647104674953517683504102672070314779850010955167318136591288937266213480474554707223709046826452399185053344741367632997822647833919635890641991088509209448968323023529655570431435255168043168502497343886638000217508e+26), SC_(6.10878834629790988160802927408530013637487637537408024086854879487937538346516092817902884700523912851786680663531728945594087355952290948434712469565483226874890331364554842522170361208548681220518063358284304337845142884753062170082309483382202799671294604562888151796855985913051886219982752646724472534051089361710730038401364058530216782736954910601778240054306252894308364042420468921770314303281112548652243358425470904234578569201244720441942444412712160479229668466116080101258970797763193003e+01)},
                                                                                        {SC_(2.86065521240234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.18297535561400529862154201588364124930726316786053177741785127024911984659957345520275127146976325947623851930449300294321327287322540455295178302795770977364632677858658542197868062436973426239080094795366182479671021295104621542595009889405064932729645817668857395088805081325759068124462747875534272079475902645304662223083207008913183208964990676916644116280376693740913044811987470193425546341939265091095248895519540770857586981347068792465579320037618105504314455654476903086548497888600391790e+28), SC_(6.65744384237173842615460580640110866830348471432619027751155697794991693556178792187152050398500030319196838124695595345295036549337326091217666830844852771807996923397693517071067680518019247408431217179931029441945675593036150502785807644274142395991615983425158657556886396005376861112808847592605413421879099833573662691886365132153489527485249192638773347480454987269091802611271643541747113868528167028724782368679415651577580896606709898140508508556601010526085370686307990029623178600021561237e+01)},
                                                                                        {SC_(2.89363555908203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.46364169422991361911522707578343379455720401498976706085708772208004310307378137253150372308002784981732170240094025073900289172767739328344138660064293375101443634174935987514315071992162722725383072608509641160645023665173358444455855164226679929391852601054044121137601734835260033769268144202422171248364140069795502358616158799151473495887212541426467037741443982494760074928831400539768195579118314513062832534540055300337488029865295302834134358823392899209355307899399975837372513512615528262e+29), SC_(6.76766083156218277259765307036062635553227023339066248067234884992807148318643296403891585461022484029987169548871600200984229656567414527135292403055378517881471207722154621994051797163447572374473358813303159020377166394396154103712732393989825413389704424065299279408848274531031692626640889901897059424873169831268752195564405077908811735292342504900309993677035536590868613014160891096302448676770957030034583001066480278991292017941290191602708891680676674452826414806539974597961193334063516752e+01)},
                                                                                        {SC_(2.91395339965820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.86734729521848082710338701890470644781523979144988928547521261078461371643143804003634544436307379536701089936804033119939526653843615648442229267012609024807113082453171604450219011300824936008035118170099021658680615814976974679835360871193258898622693738894568685412676828664766739487806291253172480406131437510013598190306985820790872533379477435332338651334325566223190849428336741119210959477577377495620582613192165806843439901031017616746525463204501806407089611814441940521988506672497750797e+29), SC_(6.83575167822765613078684054515645393136576932380725334766476664365352993590275062109168114307596103453010108572728218976725262757036021598627832561241938784794755114892484886153522451656847822582362719077906293051861728306450132286688917383098776586452863162933819969125264194211479702244724500335892028324658730280000067192121885937096181331752363056120072640955413598291279300652293302670284003703187827689607921107713327366686226032251376905617946954001970012496577909171241743428353950962394964080e+01)},
                                                                                        {SC_(2.92621154785156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.34523745563155188256040850939691712650558781254414493284991099149137086775804978560403467599728219475856175016819544619020204249467030945623725845540950345058678326769601337070738476482943736837088975580253665438542042740591916109828199825079851763141821593378584210340486225854165051144199045290135047844682296062829530542554728086498690404716811675041099263451123596611795451479772232958162850444504127494422572533383884316076437492806332042890701380253588643377173905471284161483319427666467625361e+29), SC_(6.87690198348116810755812737868634699468768949217905626771535888361356100725282583209314122253247668616093135958957553107771336225034668220637724665306401194336890593782398203171190925637074066752678780699802538897175854158127889554586448762692453288812540699296363525839207569798672579000882179456645801295452654363970906333003928529475402363082584130085014788661889705740056095052998499027843848922205804376125960585791770656488154392778071834778842343072126162268133953305536914279513720072126961022e+01)},
                                                                                        {SC_(3.02215423583984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.87297339346442413223626441881552996749321322868278677388442717804533541719793945413780361025036005578239666197991100518333589788384638801500010329805962773586448566558417273032380150895643250888070791874193065889150921484137985142416411695450300740875263016453355656734191678187675741194964512719726130824949769908095511629218244723723630403258622347581987003968996993057199504979872174846428171029999991758822801819524388081710906001015766599541753063033276293523002868633523464206937949347128472368e+31), SC_(7.20076651008718393001846413394830211369113155296905387227354397003624157955172192372818147723165782354086885513643610166959516337066924865599773015660602163993110463698236133192801490805972757732043844737488363072660380105391287770687977882635109700948168715378611974019099812843028483020620951971385640401828381583612714653451198525471027241404044969339383278643839951906402460060093046138787896253406949282594744469482087285350575317701851773982283579551304384758910839844880960048254488720717351531e+01)},
                                                                                        {SC_(3.19958267211914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.10529722092897347908375684350487190665386510730995276652694837226076152333891160209381011736663624367269277904203119494159424128154849290145466186191251358876514454753794811668164171088503081783194295000984263660061488617874426296564985345060633416828688738656050177656080448564016966741708683129986866682190353169745781845160526162005405982688031758376601477472002985161237064932920608952502081314817246651441220918323804178243806445392459543046096048748961265026413160455472006160838251124796817586e+33), SC_(7.80778258946240115261517045561166005792687796547024600776968032807657415113574297406466783012067674621855018033737058839515115740858860654069616412947264441341384570632838998094338026850938979006690501945806609196265904893321792150114088608539539741776326911715297018531473204914273174095721894921550227325411988498328959109687266688893801219762969037285120247383013653504865071864740541405778651655191375983172120022638414111231251259362331464540155947096964038949774188789788535095913097967665089985e+01)},
                                                                                        {SC_(3.24185638427734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.49438161917542816534549417847110972760529902701104654598890087201011890720206561865852952926013434976490024873073435910795715920427118281149452661845289951217891902764247541018950583339572116892564901102645427222988297070750380042289494295927433982082431879908501042110776671962769426274191594098526350490499516762791016191688736257490680490659195962464698070712029836564078042389440069057635876071638944161783898392349333989011139633739055040406159649536024346516120217708186552130193376168867187554e+34), SC_(7.95390495888318212998760521002149494523088095049632835167693899200198082090417159595012046716410467802260264700130964429772344648971739989016371122586195899096394787637702142096084678211476489290836862451591217695503566590775034007077763468945954230266946092732190012837261614121604340229450019002476022441998401781862534130907660183488294438797763449874362792394654275157077174892751537287233687405534258323091423343923021443606445885357115522172366770443711515407865380305091563963432540105037663781e+01)},
                                                                                        {SC_(3.29585266113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.27761128930354919701485516775667587490850229398554669934207151381442314632638880588591793769213728389937267758877156797146431055220502649647576202415695404415293690290835812871829309812033783385556845448116306922255075063107579160364093224587629500425003631224353942082977712187414611070893088706021680061826748100814195305872240240281013895126124269098074441195123008020302776033608084468484346891950551401159486446276412149880984130857820108962206580715231553561781131362399471520223258292277658124e+35), SC_(8.14136054684274741964145377939215014807692010292090966149434708384796696984176953862437082883743812556422595798902123120393622328481916071778051151799663129957386718254369476701375784883357238860912730696684301085661489681041613263972448106796350804708520721594200966626630627375617024352994350036701446953170131728026058978104853485950120261498236749505855833440820778208559278867213296060430539496763904209131345097333341183094665414276490139448832082529973477245744065749067843522574988437041848634e+01)},
                                                                                        {SC_(3.33357543945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.48300159181761200701204355363695060229791968154368538754064262719097995063035564600374025008951067252483790948590967248724178893972678588775440775549447497293942678266653534753786827947462288065307814703139034747179856597160532948750746902188231563587909018174823911788915768593476118531727242871056689064731971077728987075607744609112629093496420251907631517330062434138506878049509818111073159446603636714880112371770070022582019195746855578498298366073462908413983843045898442239545322487107538287e+35), SC_(8.27285426032651351766507271768183412890756355274009940387465402129137436561575209724804631194218211989913771391949002133767203973838994464541580492006666861174959066106401079823967507815953112500273849939997916717763734452443126349117613296752896480185065537237343706449268677750584685983026546829631494775101667241984395834326209591964078498650831020349540175250722375517632363885845822067443894671624263457755868122233911423047215640037633600146529028518371062907190179673629943284929582240228457933e+01)},
                                                                                        {SC_(3.33608245849609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.25910975788742653205146646366082007340773610996176154798821130540958169768564085960223240057348637196035929960628015222869494448079409889252897937593634818967229880319441221801264922080032552468069216002312576208837467708731971964200629039661948814022629825999101060910619328263555037652878100470180845146148712279665244935657445018110862558457547071725686710241891281196021326790690207821250385916687871554698057461130870747660433547873539611604037601274071252230760029267104222180344524243865665364e+35), SC_(8.28160861603710079118490053139180341967390190183525780661970734769298370225490936552881352084318266572549229847106951262515221025161177591569889171913498625190184460679288204802168171780327141884782319041783323341744977849737124137079856773929397936817750860289617101494377478049120537435300917814010237687503184844519123896060589568190512563668803865162575733154754837230457246786300598905794327235054896571232850622277200782063661993728071438869663986891063212286553580700214568365161762642741449976e+01)},
                                                                                        {SC_(3.37393493652343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.48031922819823306403456121055533618854815349116051084146233699504748076904249935854937286448179965262152721118856843542120460979737215048811700334413415327659952769299589060285169409827822674705143801238912097877845412052224385841228833750504879006197212007063193332967923414106315429839140702588109049569590790890068717314510166172831649739497878166199567098912310727916539484778388585294038930091526234141318642268922494504101512277533859788856836664268133488842793137383127949202371793208199372652e+36), SC_(8.41401873696057544417316920924880046938250235320124753087311223250489866574699437076387096536169707942889447446804102388757224486826658788938004867333184091912546002317298246728424266932353180419646334522781207966104359297728072535824671094515322040354822991604351531178940114578851898290053775097461417376852674842647500815188669436253178796934787422746875982052670423777598961614364976136407177160333955853407004352977148066120346666204332050285075576875146205115570129251576319589461496209867854095e+01)},
                                                                                        {SC_(3.39577484130859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.48619298028061209986594333844848533957474181352087908334467421738975887543824669352195537925855435254962699056278972594896552243395516661570162654604207808668441002329965436921613187220878992455054164458716043116563863146011454580903097467081800181534328436201435735200565174945504067082424441373813455174315131792153573341277760856295122752191631892485396891765788245229424967621381462454620224418898356765251078488288810214189182624366940263882437751772551099000045085151783935984545593227937300553e+36), SC_(8.49061237357601677757426820584806409653635968531783207842298956209531777624307597237621381316962998494942150317275507789715941449133943051889962932131394249277725601498149620868390677403670219936860302219377586891581268839739950203958740517866213446058571530484194674956798719844014554494087163357384615608021899824063679303890626979693426040721560448647891115365732436107517123110779205849000803887184538252508823293046458420647545970247437214057700091133222182379355251152683343470428337908248743977e+01)},
                                                                                        {SC_(3.52252960205078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.56071715152585497023092290905655959502920460034220527312022335847447157154956146842645630131605527008005874505359774339299742273930860461033228954281920264089749626896578868226710868563927042854240358804527652171128934251989148616435512438069075763900427149132989690880480177660180054073738041633796251162327302376422301097941705408765062731669475812705657287562983925078410268640206842398117229936138220828044117537896910765536074516823769915511458415983380113545538145635109478905390510739920050025e+38), SC_(8.93793334526334738411682956961255144453790132511539285738028665409834504718444888464037221580061474593309610175221455653957374652755769082019267799560912280759842580615594011644440759597791065105166102263051244385684737404118153326841745732831937820401128679071393078811998593562915566091676512497508547760871102253963272015067862936340161303105660559596765477645243666783294043576540378593611717496449877183394450670074809802713021946770650132022480046114445191025317965061628660311957807807192746963e+01)},
                                                                                        {SC_(3.56992950439453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.53689053093554857618544159347188992495443284898295702182825966086324146810862756817904814830792850077597275262900840906884137773903601193086797431603300382282886366275248632332271576233699015109917579568871683861086177595480505648823337658476139211255709306272488775058725681443846528296758964994516545248044490395799486386700760890674575753723174710531471038216033893492356552206670520206684537324374000788465207024929065117767768126198999045992857823887533746905922201915892267316660275240932491649e+39), SC_(9.10640665868190858448532660505908724776333955128402397523296439018923986341125101822015045933309583940961784261950267375844113972950394330335314672511761753499894659082898535243666439383791158489256919862750008378539198210427205060068688218594844978402783702908704355316521120318879716251526598853592425781150901117478569631977765902386804588349601910594652674056748675521414811504462212070930437095416179775298078616861077465917526850161944018776608228044914807483704248490120440411257414585404454543e+01)},
                                                                                        {SC_(3.58641510009765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.36424295432157511535440720990490713142478928850445545882177788146631899583265243156599175619499745407860152595623106429048800824391118470396354418159458891946526901518510468502225964275013364445514500603839105828272246032594586879111881480532434185612132159762451613795842833858892548735482618893000745983825064789554050634942435506397112024172110375299723154354678671706272365214527471172105826515102783386847223543521346016357252788490199361446234119782003104301862373067091039928786671563470091942e+39), SC_(9.16515139128693651595196512708547636324651709683123172234498719549521297558840840169159075720023119839428299786498929100525813570217317085650748538899182704393280910655074778183239450945435128247151520084833379444108879242189647258521809568987184893901906094154668037535011831330451742257699231391514383734240951685863272212864615171585376112089136287668760813342388267415735962675469412313082132336996282245207389344858159858989553753059675271824412086490559176145293682277127850119334630174597027170e+01)},
                                                                                        {SC_(3.69956817626953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.66259459422706588699222738869782517771013101489628084466644305870430406070798942163490690127991724184561667952578780416627685499790363015334958157277107962880588462998393004757322874708922780685347930191019262345739771673209110527629711456840852047746136361035805476632115828791555934130976955731492222877982759318769041605433626949821770046523696970438061167452953903697439594188383812573031381320960762917804462780349360037016873659307232172834758981537825701637399385060943954402291803761025188656e+41), SC_(9.57041606145408355846377105120823310875286105242288743240649449931243534372494492033165984965615897580866359774857197083580527214825807028474050660229744076817699154124010984704156257051369003061832044509444512636886565464528020771580658305752979819543996593298215761253550380750340318878379006801358477171218731347554516929031213372595059582888328507472127737586391933992553030899119731228858902002898978177293675803817519606691852163068196667587353923848696248145698269407401972926102876192198856403e+01)},
                                                                                        {SC_(3.75548248291015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.74892943333515253042738100908952443037802362410857001178764229199499845111375247272035285187196798098716219931748693667186931599552210927405756323100223125808217466598800945427146736702619067016437164165956073787698936391766902777295693220076385374900233043835056148278714940830326392134463942329279148370477479770746280321753286950085635627572858440912629457352464345539633215981584384577339680355270522130806324842705563048601979210064025901207358610376736679572198026858224873784671735129803922494e+42), SC_(9.77197854446636261549767992618612153338901331734174669538240849915777728762665304807044964569279468081317072465445392919466603094510230879224662720866001647403529844997948257752306473456879331453240965568476477444279665524301166509246024032003595520346950239876945351260944757676816304846242018005998244715086433298063772518276585730102267193042838546658977872168589228695054959695774148909268194979897704922505548574157071890259226103350432160503061387135033879084934257843059503719574103241324813901e+01)},
                                                                                        {SC_(3.77689819335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.96230102874396888499645027742495248912447947437066102094493234389694530402927062586053005763812544416332451548507571624128507918007597186949911423259731332697345887948321691383515686149543224694114422053539249065095491560459129555622893486016029603928552949258140662583746543652350183245380752554459137575155817510605776788743415928620015393908452765207340603246552035088794620482996203019784540524531971739259410827368602035166344872030932413661636795971207162080060617878261642791350386883582954744e+42), SC_(9.84940303909663096910241318409289245212500019975324319490665242340160947312198602634920535331626298288860399479371441659954832274982476753196020766157386868652317205632431548553765514639828150740532472745982635933859447403915457191153481050654421953287290317189592103415626818480295779308359194099684087776250961300213691244090639997986010124824245592443696072734945753336322423458290341388515832355186237545984748745345296644163498644022002138599063586519001741166436802987643212337888398090681552556e+01)},
                                                                                        {SC_(3.80960388183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.94966310132054302397003765407203158363486041136357047081300608006350006717205229120710244797692588870835750721429283227140051425723505967609469428044605287187966408282088301594708353782058645924215880213449355758049345549942894658204524680477066959068297785174881565146038159618757197413159523147013373237312323781047617212934678594456598493072554434900688249329779014143005241366335087359096559424072461639852732323393623317543297851215372216617977352868874773093064273882043088007553752439030053374e+43), SC_(9.96788155878398464050970974823848018555124016340239710302064417988281268688475838835239358450786421871399679931398797995835233726341480134191811204238900043548692242681716750073416459676325619327228606567408071791041231548207582968697208109467767013876045530146014314654216878827838721817400523024921837183738330582752480169454610303023596022550679002303388123338606507066113662753266806342456079882031076214547198353221502702511114200315582468949405891307760099327072576116921468452800633334968338123e+01)},
                                                                                        {SC_(3.89539489746093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.42099252482505175224053491172987287464999395110917309159539664973197176042409395425197153828926115134536219562912529335489935304617549050753694848890326784187104443214648869569501137238672773548427757359572273213897705118085729449223906502037596529602469147874376024285396564985400296213619760577825594742208116824657396999627685210334609177578842262952054514305445759630225916599065166880216435147871714146695241425637568248234770007348891729125230806186695311999312890685043669601127902723920549747e+44), SC_(1.02800108315747176667580757624829155137160586685435413939740338603105579138210801292181451092389926592138418710192414626474950090060776597949734074627296310738607025324151493885220015841053889049529946606110349099977487577341271553333304748516674899399995745728225290763832733902563955246130788629755283822495538598306738794563140063680581754879586565113212214718427262543292536373096680727403567530069559782665899562623362724635818341486292882965759589700454690944614847393328224912276180561566065964e+02)},
                                                                                        {SC_(3.89718627929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.71969740749970897730290012846147911686009295785003916412901622093553119195538207033808624095475273429440041234995502918525910378308579137893316016944614824299884881505188300485682346316635475893326590902073416685810355968417714306010036179159455369986745977573646382266585974939814873071165709069115729131193158330432726853181872954032010799755564920125347309967318331099101478259410726026710700865683645570693157050660905015788213110721919051452797761639065826101198888774024165468417198360511986211e+44), SC_(1.02865488780699861093280112199126891329699001554222129308544815672432515028407075944529333679710293149443274036217115425818460906925868653036116530838271231845983723398621926711333323680767611079507871939945224386116305319732929747226426231187768839594051257964947193446101142422220266262855570986577873280585722389225128219470540478608400204575528092251890460091176254511727568693251840571516976921269938059194303054284592498400851945638696563192595531273277999456371365165093683664759202661955453253e+02)},
                                                                                        {SC_(3.95919799804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.56094771887852659754339674542850544692401459751758415883425527494896691657591433112864036598563840079475388260010228239613975962598011953360072295567475554942703652000460050230046640009911511053410735581139875607363314195967702151493277296382101296360216341042964206487286690492474027343515140566285280821536541768298788592515741054243967328597974804693646128792971486653117608353240114118421559251016802090607898167429626748932448659899792094485347321058606630943042209155693453189531774741842546225e+45), SC_(1.05133859619751442523240614026983326612739656777413443094256832978622427439856340253648166152679010556697821281893454391166534792755872927350004043092036260784892300492613463717273263792090452502567869782859374087618583257230710949894488889157036516384452562108265394912037257984765405157055684158071284455805768007363253644757106005305345135932486240034601443873038626841783178895988705252616961545535592391173264126938223796906149475573371275187276597618947176255298870317039030185309540989920657883e+02)},
                                                                                        {SC_(3.98988037109375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.40627593316492444992272825412223262199673436499899274677726470023082915445824866560883298321178664586000020727213649149362741692666250092112899640459218507995683203027836958023404493373619001614106360496422473928381026688562865920584034814624925452283815578341383405590966758597941647998792595251927194506602941990484534536954859045350149803944597373911154560785502492566964912792324178856844111383480846116465140788837075282904017135001794788951305979165560179546941585375123808713637899776357770658e+46), SC_(1.06259859305888378907799738967210580839428887862346589832422646064411864637416651304345889163867424880543696554072713410634078133737343313928341868911506283937450816542628397936908503587683112341752316515252368286680202218031445568313709099582003218980293434823768931289876952350750914371043681284514674653547662409120048898441288382045222987739167127214935250264656780339430988611790989613500898841643685370671893866307781570424733993859701243964579656627126825398781572968795666477881860259909590879e+02)},
                                                                                        {SC_(4.01209106445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.18208916857154395368702420922162848388742166024044813062272795566235213609746749799338864763870238526778712988027884513751820183187654812982992902723115157504157903691430537559791337701464306927810443105593740233499397841866595345518575638157812382630916092366746782345952459608920163041236268086753016916702027845839374869326421498055020440558419581789592663923320342627972875884370276143283894930553232704113807619621842185618990407121653376284442190681954184665323900163113646750719325004409065903e+46), SC_(1.07076452230055961349018934745963009530408242685899091904199838913486514387760205596491425780538983791270407761736341587942426767707401182094852188846903951692725216878150525398824647879901311614817395461224548594179988807081033015265253650683792469069589486412803831092929069079995089595050710980032465698300202811465535855146769754426551932930019839824999335677507135381848141539172684033420408805268269916705873041553871757695257600369210361634571992292136556517653138497930604300512241679666923505e+02)},
                                                                                        {SC_(4.06430969238281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.18082308580047031513981867693577135844953709455788995033927078437485549163341744994659324610448675205268598737314781061892395944903689750754334036944685391608952301161815358037089584556246568491089654734140280148469134598272099686824970323828495736821141447121275150871410273803476560050882524501896961102850106224667959869457944400000142782600575521603363928626040333995457611724197183012279413386055224125252627414715903126580378222565406209200875218927571867836787784546849410912775700152767099491e+47), SC_(1.09001201738556231502109212028821747819744173956937210611145484264719711766529469851601226202101966363674044959771068322529405703004076853427974169568790980436150996312637283223952251608940600902363778319452023869102298665641807940473320405315253276624239835080330467460005112831893908538319723111328787953563154033212840356431710476416136889509518166405292530241843482629331557000897340467712989345938014565837127436715649812066402504490281339082467632965896864817788227698937607171213816703009689475e+02)},
                                                                                        {SC_(4.08205566406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.20115641331440339467310215647884183473659029888921122709491804851243055826685883831686008341760302325362966434000996094005610893172525461862777958822533083698245624745695683931800910290742279054784103111180548974580560857857998796163113975003594791881891987057953771318195446012956801609200507156275155523646011353122292253918238750951175292540631928616440892348597646166577336605887813437522385049922505785826990842424641728141841630627868589447100238126726740130420110706707049750568248233449196792e+47), SC_(1.09656859194614760424481999745730080743689952003240194837592904982820016761495823384151814047070800938228767295724381370266368325577544870673863719799856491179412459655379074570077143642096179778941173607408388539921704892876303972073935153969731007313339109515516504838047336843452280164504414683517404081658767756776332645522534734617981654176135384648344172056441923584367044372654115811002135162379615965022393207966077402824245957958379472204188883421647250253204160191473856460368539032329410990e+02)},
                                                                                        {SC_(4.14003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.59845508598368999690356822122786192315007321315447283315450935378396176720469915594152097905704129591162266777830663415849047027907750838429775541831407696504392052400572121244223497656077607413870009833655228571199174047652016520604380423446828383907772606021709062080986687817756548591328205748985050739484302737720191387375280437378840194735961822813725566987452710076060158391972854275750636578040087619684469317030177741135396923298210480860913790889397509964510394078850965088315821477380776088e+48), SC_(1.11804589074285832381098988403766806882167453395786572096767020977168709412715983641058656609392882765351906530753747748674759546000501253383475774797153523883205963055438064127027071634192397585343592926146251572155586296982850390149169324103514178552519548061443253673605754847105252438455119244896239056965464264638034015785618021431808089844667707221953518060774777061581753081236358805014661389146949376409476029618453753218158016321577730881781246449884935092425611660099548318304231590337873089e+02)},
                                                                                        {SC_(4.15873260498046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.20430850488529878836364552230116299589347139302018600134994455219285339709369731597644890276614623827683116140537538396715869823317619972266589012874381591244984977401846711457385911850204936287595687811998227590480489823148356281121021601075546520736955694475027986337379895562659885275955049946488528780140151750253515909768287231178419256423666497593936884971433525548497845269710395217999826831412786980017642018557542666638085883545424574454847755827465747444331168181845032946278548455872510465e+48), SC_(1.12498763714220540438563524043282372771462861555428713271523103445069408737133622132683121385631156666035245178814443182982329791609993821751785565723767774874223089328820219825695895391915295530433626089156327800417687038667437651350019555366647713635319509137297336970765651464651843715112398253676843172558891061738496378388977055210658974573259349134471597651761705973215638004653278207036224383533445539659302602104811301330599416142944383381481264448711734199195374854997388262185607977034033386e+02)},
                                                                                        {SC_(4.20431518554687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.92880881251103730967749510912480493598843595405471163324545178842772962570010986824734097484061068455093401771772721121531905075903632713457103680305348742610712310874643764232296115355411579409633692937815546374130725635890491394915622412113033710488694412608042964148263407503190063442834332858662083332519073678297422005007330537623373751447891670513197624271083086765042342900506820193007162544510882574550533247086767901068075725892817904636702513614279189463973072045013791188933640113446761420e+49), SC_(1.14195005835502743373307382571057774122368294248710931511975477944474224935395676810003354533563234879263171895376838390229431712878450108220128468846535066479841227481417495748296278603888367872358959348591301458722294073709700839403319205740502995726587431105009713221826249006571718933027393628970732036766349857156430552700157390780713658988715267424292177543833550294196408998572552973896299393525854502939937276559743068770595510048601765523209161655344238224667839406329041480127203972644153661e+02)},
                                                                                        {SC_(4.25659027099609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.76541747444828339579038017619796984359471286039806019316727048877048257539380358253089339523676320298696081898260684379974048573693162756925809315902370541128833474377931812078634583236915517735326549337250047384463153119151884209825460848162821785228341141203651681096449503478365171880240273602509414989550086203413758399602004230055331417266786182692483906103345380471241262882413062169697340607110713479035900893740354405763128235764347187263956844572265588059922589158433642194681578424386410597e+50), SC_(1.16146446258613362025105869625318571393084872722164662450811852325819135149344676536830510727855931806617837276011625611567469842242910743015303242047386557609659788419300778657225959510400921822756093994824407895633345859742201847602706421538229935465533134042778503324053901507147782681107782285461584115094814278955607068224865608673981699876775906032963995715147420329086417091040813993002158649646890276778769302510589547078761773598472659240756642426717399693291853959152186765572951211196144748e+02)},
                                                                                        {SC_(4.34864349365234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.72956656289594422179555435645719665669151490833170931930540394923332882106150775823183828332220383617382510756932983303586915971736098282331585692286768505004181816760462959102656258137386783432201464814268127276757454206286843303172156957352836291888388893119984878538541897998791928690633028009722293016372498432461107862848660944247995493388469064754794464528855028498449553615946195023389978643421041637870937140583011320703704692717358020944793180093220881326254134670415296923074827029778197932e+51), SC_(1.19598555462162467933148026457348534355944193130390148152606330964950606221650592192613479655954671569609330547775869597899466079145779091282799032516775641299076734660916615477683671761556060464003016474451294004767328010445462608326438799050403655130043418389705009651601146153278786675780496717162315309320268991161246457767219490461631831265493559014025530287815822035748847456349829171011845315753981529970028456542663639290669871114712818412020749472624292340800036522128290544206868424173436070e+02)},
                                                                                        {SC_(4.36616973876953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.68814993652251794863224878981547465786534513650004201127112212499173138764713817937139783355819330391823621919799549392189984387660232298430029730994597271728974002087860459810819914998571269691400620834607400152357489032975871154006275142032822382102291315307408953002930868517119909628230070576512926794992880041033667617964619069842646694788337585073682192514955151687845228629957372784705408183386612377901465234782668096718165488873061596447190452739003526477286481993297697013318925649609156329e+52), SC_(1.20258058052873536606684749211320913841318151774994016424062717103555487530105994837794793472882164536014792368199410342812750725570440917170492422759674508616322478334545463606118065035246344840252935442447026513835003563333039593965539598067163193208964897341963900598735929785806647192749611989499779600275587111896635290788289254445462814510539615286540681330222410686601717760100330615252014854253402490991006888805973485701862169066213877234224767156317774928010126959591214640230596839461830891e+02)},
                                                                                        {SC_(4.43486938476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.25468791812059674818075802726253273137197118389500421767647560630915719230566372874805755091307271651210328590029349884142749446165098393203525442334507103793135727453765596469246795513053050205478613191355679257965108739878334191098237820732126348132220181848752784559742716149943714927169182566203113208033329469765353694740919325562090320321287992957548867642768909406976086490542910518621169243395437240396518869340617343894813308282912032715520834572908498174785851002365797607975470857365115363e+53), SC_(1.22850021496549589904106719454578947931632038847321962566863177484470988831972373472928283280292886713704642219705797223420020854888945961080804508893510944936553093798879377213844669481321378157164169646064383220886223821127014941079511752768795228450699483966463786047007034222715103412001785676653468851334388436720728303295782673317779798050475460885436853687370151208583485504058104087062550415852325039810218442842861270794195245093707199758807677284186254790202386093743873559636061406926588127e+02)},
                                                                                        {SC_(4.47341918945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.70051768757705787005643221470781194832110659669260732490569084761259949445373930344602352754134547843607814413559865870653444288084354780008568386496571756770590116919940137054759042323190520830096899456266200917379520710874285797058116513189434882771150673968931300996051810213106882475828122998907839209847395178439543785649629732774647393938811580789297673134309473455986785492853786386676589392766954242379779333402121722590790390721840948655807960929785284246141397812978871417000406569154097752e+53), SC_(1.24309189182622943375037734563801974736052548685045190679047145642944399136878976110953100048370266139467196398387244758623610482609359098186417799117194294840939266874146185433296262149426750483379751307615953537745853268580981343684728567395638480560599565758864428224070365072509754246648958054305875196539342924852749871276537707041372694482750537772405019200044601308756097073098620381025132603017029627009758457770899915858550187083703967813384108647208048033750398229894059929781335876419925270e+02)},
                                                                                        {SC_(4.47881927490234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.19037024787675703270175906824802256668177081322569037374198471868314294187129454601713334226158013396153676975596092094045100532798117503704133665203016590433864389581583864000633714389579846243947748106569550907467089547958630535202463362783895123615607549081555441274565969241979835396858131475534300471286406592205619591878302135023399512555867647254188327963666245636949162413520398427502772639464363877586984294087038276975401950153279258436991500098280019827786097195639103068956276315504273530e+54), SC_(1.24513859413079716889471609149241942716494855657922499808839894694292777650624863833898685903676326925038786164757268460095580647000754352776499175721803590494435582033180536808736692606281673139127694932223203775262221520114380284811901136965375921716273693603354819612296765247177033895333364738342530178933237998008574871220342264341590540844843438163019458832092461223509223687642679511898705977569609176084109816510700188357800752241155562857115035298751914915182894875188271900249895635023723271e+02)},
                                                                                        {SC_(4.57134094238281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.00895985290233668670115700433024083746043210901127969768373352568053703827249253423594342763451352126382377318449657081168034935524493333635557477725982118090998765898303952391564641407905200994222518634479384643334463710034339731549737840578045581764014018294486920638770652996724550267061034708139238146646656924230998620237790675184993271033067273392496695475878552249851339975691034041680399364597040291053269735313150315432017445945415798985208279073996905846439545084621066029644386016432767382e+55), SC_(1.28030711934040369170085309853315597227241145401747153640034732528030582212569910331297382322800356855682037417638163950624408603182347996363131314614965009557147445524418096128223220793705867708483717563206995164971391583728919535379788775190549358067415149827563122933154649794855111962415462311815980167072594373161961801038630838275601277930510440672951033494274773898066936481666055852803363087906658370311631606089216774517991442775368076850394323971774695447095042326288081304896631929106818814e+02)},
                                                                                        {SC_(4.63315277099609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.24633970510507375036559094674156377099419907568922363303903492850844317662813653019477386735973985177161212739874200979711294338447730474049016228761263271752884456089449825831843270569278309670544869163579920596429350006069074209949900748626912423168029920991458384786198991131770280160077208354816753922904957064286491706095964965292514470849442763410757990865377051954391465148410911370575466485228977574335931993387471519823227077476617228714901522411169999281994184409464650004261241911979274201e+56), SC_(1.30390822573659961338953885492676430504665318415000929930781588727919660473425330004665599213258366743276860977259356309724373064227612999936828017700106088400776000722598615709466144474264636357244405886761721391443398396975162054811810036726395042116626137632154634040479605170823260376657811882616309641898973459451948187097879871916870730849711466430394406473832927502387853125314990621335923390986635297785229547982617274024804834064479825192274186986047795822045408221180842199929067855081710101e+02)},
                                                                                        {SC_(4.72839202880859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.63821708870461670236425303997171857446030642780412338351173306670769420147013288475535988037410648087799473150752400456568173627908249768063455553049942951523776155895248754336474963088628030133266198919030517445804497569759652017168608526087979704838259502475893736023690377526230499083604699664347661676504249685925344027667270918850991470512026405416304869157971883893321338683873535306925612356247012349279223576584924497035099790542099372214842899830944429445647061766741233489485547108824785872e+58), SC_(1.34043543903090534762118836981051230555585566568719196383506269461388128995869812946092345008605522173013494204003842705732506469940880871502996137876794902558316655804394646347257188110906618332788660273115107153055290361642853427022117840853464302501387721367941642749893103110450462429556839844591187120760400036347174278368681942538682269212945273519985921088228798700698799134555201169279281163880632451610594798285227398823616422503499241630841435993254601481530490830078736679504569142528714243e+02)},
                                                                                        {SC_(4.74172668457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.73625544353333265615781749855687672233275458008612417052192696528350181797907711794066393266805605907648891659785659212580380748995033976037597055011340614756467279295328929392709562750982325216429658258074075406921660853023861284568266983181973267710575610686993785571322544755119893993236976569824276682221793147216715122417400178890934718771009766770235731147486984899141231312311950165863618395961023563287555561952201873749013746536845402848476835697894251003725120888188217151015886016512516844e+58), SC_(1.34556525752921341531248264471300762341650218841420667462600236955290462762285912840676523938265773113078123711064711053986400179808182028454108757531005055589184901863123207311642722195665966206977456990345232704234193636114226803754398726597017005098191161913021688454814870817048365254142793415000968698201250929034048276110055429109297691792531542243165635466316019586517494151877464553481293731302774038733399293521435396511900710315629691219341794148881653920974852763841833978027174519521269214e+02)},
                                                                                        {SC_(4.86546783447265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.25325538407266915987338128054208766591917080521625232032844421606051606716692398018934495896583835190168394578450544655593684941639460458609078491932924683876005138093769628988685898032468113839313519672841054158902627568138818383065501903544435727569688200034282590190525849337393146535954334850871690759709421545986963882893742725261113224768353821553484890973093373366532100337559039997766419927152717363468430531396385149501726769479316851724933345852867587952241741466215585423270199892907944840e+60), SC_(1.39334761731298862804294539283176125542719436431058675147008496329375768272120874433207437459271939792468453525676563654931838065228633597665996854592456445418437480491771651687917346455353598725781373478363207223312979418798095127626210148168237532580925885969940796364602265897149086132306230778377574686988087734968651616593042854070549623519949581173709044613343996738031038884087072158192721688170089096734410995550902737931277134299753629372186581111952604576449382332015708599711385812002727929e+02)},
                                                                                        {SC_(4.86985473632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.85605192834029189218382008738179247292631112150377520053854361588702465308236543788152859643955616159717704347800062618153825956926948758269128379908040436439460739519248730865784730020101969228605174442358741738309648260938369518383894853506074652829517475555256853569367065354399148381461160001322676112571630439361796016624499301429175718970541254456863490084321031011506829533833770403337825140862081641063908721929082024238174556656134000812422538966413364709887795809753131069028025245303704612e+60), SC_(1.39504749423193591654786436428893291086751708723890647425720776660306813217983849065409301485801164208541110792857647302169748170165192109645040609190672295254145233711255779044092868648154127012809911646563314549786886632500661524379697745831608982215969810270206463912893191422465892270650284797102021309328842937434353263073188688514655448627946379412277805897064154026444676069848850427370729572762314038766464302486857035527720598909564265778204169823731366702461502569042454590366866462252383308e+02)},
                                                                                        {SC_(4.87835235595703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.36035892866928323626003597490688298592375085756767687580221413110290395246119363501254042500161483751096000604731192001474955543954177845351057533404447997454363373648247759245791041482807247733920568308160729224963878297687386572001273988043235573836188152434837448508035574458472108371808169176721812026052119485230621321321887290212166143989977041958322903310001939825724443421609001421308977780470412959500421034470008880264094468021925933219347165639145160097908898804181657671336666324020580857e+60), SC_(1.39834136516787413500007587510694826864396401968853849617697111291158848844054838105490882170287712108401023447992982600168348901295419931547058652315336259524674161908561489574985783144794297757797852248887839090209890498688958249246323290452674141068652938048123555610984820856797509233451931845192133243191526079925354634863247560686566326020005669477315470653309578451268479417275395192731453183344478148664850424200854190633948493894743148373211421781497087971495371828255297385048072836357631041e+02)},
                                                                                        {SC_(4.88616333007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.25676402517775076301468278496934692656483126051057917150182178191344337389295682456895134834722163155658017436685311521936985635026182128820450734590168196821488800119072137854226239436945319459336791804472147889086556562163276827272717286292245052201245450202750152430921971312971942793062920469104989094121415606025694182596873705238964298040995046264827257894977852019200307570425098485465822290848065650171735085078091132334101899949959914884493767480321306446032861913394329267741285906711103952e+60), SC_(1.40137039582554296669086379035601909857486506353212457088148813998433361338780193219865913033475110183234265070635911641095928723479322965406468549987886564786421092927422630145370616108794441359965549476717203659758010615719404053449140959679261059542424230988025529277186859295920766064316356915371416710280108171860963364853471914176384067382710684936643955768838392051528115925620120815181805633665843979941904830873787847412819338996882527616461587934247663102092108148772042092241438971390445839e+02)},
                                                                                        {SC_(4.96946105957031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.84926051435419488511811853980745691886596467533990571070047115255720116282369824411456771076467653111164982159613206766501049189841537324822586271014364389581042302691647366555548159603118608864628163832875165777040744349536109872788458951641450125095608129869448380801609179867060104893607719181097145340673922819404866959063254399533632259195570417957400062003248515558895842302329502301062521977222044431722867167965545645096271129720006691983917625256444131530340709039540437261910682571183129859e+62), SC_(1.43375061602840238196387911284923355888759486677703347734243939633177676980594469572540596647627951945711183677110134004531635998116079359743547196710154174966205304265997127571931089769441782084653674499867407219577029036057998836843043540801353893116712152785856625677177920896429671428856336776949787962164030038320010305538321393785686820222214835038242007614244993161677050533283474490782441167642129200667383925185368224667881315570566275605276821283548240903636414523362833347642677414643623122e+02)},
                                                                                        {SC_(5.02667388916015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.72359609248419203124278009510985183150244007574292494821063931905291192550361199874577620746648765405775126508129293236688227427346471719162252422650453345352475326215160709168099099325488762829380297106893673243955407060725519552650264510115770619462810338844939975728898103700983305307932912418966347390578099419744232245992772015011779396591256115246555221742020146312599500423864539907811528577739346790592133120230665473591894081245216058989214623669344437495460284751390267766164518674189213402e+63), SC_(1.45607273718315360812077351825961960655360335275523759898423031326599125330681285563961346185235347194447848365591085818579430678126800784165200011806167432152401388929448256893026604697653644245440858771972921457080997743870753230688959517171196148580006810436189017937770375761209803895109732893592165660935605510308168495911111906296905196270497034759766422177237314325587252445463647197616815725300323392577986855382680195617434026290840780964702849787897642616565059952095849864010312060252081938e+02)},
                                                                                        {SC_(5.06970062255859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.27644503160924816142832113419390792965291766778937392868625148313812295073960597236367734058867673715159417145390229408534004058590561681905994413322197072847690081504170463658644289597444428583296688754211124952090816353074693404099089089522805150846599390193061140900157003665853955147172152552991287890472933088712333479727116843837275204812883579703691969894360803743262499013764977020715239580640744754902720015964274589271972396515438127488544650757003287351203634500502482942637661308177291122e+63), SC_(1.47290339253539295464002145624242690865101200698759610546313109459314524573119664887849635992343918037054039970448863432946580921064132657981311964698024477353552127320982967180335656081109421094348022842803378303624637039558575136707903053327940879482691080653896232524430500832118478313562318060480974630816752136336011526404841504140903498989821005535936495309592708879760743479628647174400353504680504476422616510089906998023546490011818143779872437202137302789823443968254533389555814196188140398e+02)},
                                                                                        {SC_(5.12124023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.99927687563654832163120177574826164473492516304373483263720224434975728090156994949225082026115772458036505101589570526516824973432795981988428144914029285497164326398802375171273990641022287224424401732206944003581561112156522275454116816621229223008793908586894194170593136109541189183575424736089418849585627318980032235653127492913398162962134870463407859904734476897546237961538370005461048857120820195515090940047137209178643079618644113912972824144160270923947959220286021609552771102745451890e+64), SC_(1.49311252791857571944426443742989240699293169189104984644328788533525071766062614852651073668833512464197788105537498139220394509186286770568588467534532456111838319290866539755611126101502125037727889023843649090520797315622671809084602100822709946349482175131824617113945666387479044506740241810153417195036975445814082078347448259125312588036700092111250540454173356138964523836583453379889372133114319367547150774128027019566755710894205995742742073109015256513593788534779850640976780823596208118e+02)},
                                                                                        {SC_(5.13560028076171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.23026192637653829089933206267149964173181878750951137696266425435477766894776959662393783465354622510883166332313096861504304874217242045231455687124373685234765546537380906671149144631151556882423384102699948151576804252589990470079816451923653014079199791860836899051780037952091022656131842521787241251049432588833471535361080041988546532822087692740422650115265516193410139725509602539651590030574971762007831872907261184051820389377156437317770759725191585333705132134581317603939326528788120470e+65), SC_(1.49875258139600638677384317905313051110930801241264726031823123493178787964241545162365061893622252359253420828909574612757026646021507513309437547545277475444768358612137193307312374400012176105129375230060395894921288074531612453050914778782924708171613350467577656066140634079316430886465783766714152321878107968964528462731310279262933101768782533568602487689238832241854772517147076307206021006254224136315719558970885725011297528338864980243200993681035553490026602098042547489545481928320640399e+02)},
                                                                                        {SC_(5.21595458984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.90981363532390545321821957580981160389379575340353083725526256797176963279392859769357846541564731609442597893669540874701936055129537935484451190072143044000222738279488869366532435971590546803721041182171177688738154267257066471125241819107721424237495527897378823511727860857970760154399303290489105510632949624545822762708632342233005590846781101245713190716795382609572353369541851158507962047279715422507459867212111957471715401541457172773147951175626054512245232328120485001172045198910443721e+66), SC_(1.53038705173895567049914543155942539529563108424105025798868954839393701782777434849481176175639815531720609524352444839956063026657808950015560763311429110479726455402604523788186886421026505595724516333809087073552716062699773479432983413235305842921735857421175536537380992743676101280137113483114395340363769814615698190132874387690604324261096519258991825073089702866596561150304867906248340763186131591391391787918369957028071021291990784941422501181569793228008259915879084846469200023417336312e+02)},
                                                                                        {SC_(5.44718933105468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.80173460431759042276531692713781140224690587653067416859419330202555272594989519785776442562413672670314844845499831814456396603542418495392131474699424007810337531388846940463846884535489991705941523480800988009529316999708021842571965686802509207137254401158482624305999707415827714148979174195240510041877334333999469012836629211860992333238496390024839787170544088609050327601905616073272453702431232853641400462326479878566836051665182851779178144685903980102157367712961317755422758532378214935e+70), SC_(1.62211195236494486842137679955399170210821952986639965664170409799102885629436798584179104241517223062978567846790211939285341389185597963171844038546805098393168320539348298180993080511725958212127383019538951139319500426412312663973743171437651265600679423008288688394357920195658536773809676397543581796728439157519560740884067835306939932346578856048493383325511119070524158665272591734958337263086066922987842300651994068789268007151868001817260951294743313380717844919047107129432137234945088316e+02)},
                                                                                        {SC_(5.45541076660156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.88923093954475296555460010384225108082343518598289742785860838621540066167743233082083037149631143450772288566621466871158873924441131457703196747998028599268995080065238846466216411793416383771276769983993012465337486970399379120945924722620793564589846394211714533987285947129015549885511215640122352742105756827920577188242283366633572586516180526272406089739238082483458311057365615733115202707409705441125056979536148015597812278487353231068666952931126180364642533905090214065855160751150570253e+70), SC_(1.62539167945751436784365061461200949005630300411607114008314187648909852415129401768594670826889962061935904856663650035128421537930667621120193872601440847111405352872571020367561445717633284481417612169617741083612708055944527541391662257911146210363739372586741093027681854255554446655006091132290669608078027957869792605133562698565732501973658345610170317281702751071987392216962406615635572634798673703332621049982782083567199976464591918134442209306173953999317128537923466369577831811990505059e+02)},
                                                                                        {SC_(5.50533447265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.85730944855171128837952400852020457732681738535776686067033565638595958409944167197144361023729960216161600023159694184489531348717782562536407434426714296769627483724028605749310394264725759155728265167995310344108963472950279318135602602405619976237322233553754966277906532700177676410923166095578127366105347200870494860524374321518146934073189297475897914958501944436895033247992910281617521511740888108212444520135924477737728458215906734304055568108571319399902797584473184704901951618601401224e+71), SC_(1.64533422032369233555064135775082372564903634891929403891212957385782265078635506984317907710713735389157508226127087133347180522811226385654349518357170803522331589646835742411988907955552403694425202656698721669355856890469805183019074507700497641719763363327136524479713989118739444056128582381046066604259279394515710551116967860833091013105018097573175423841933592160766326992151395034082321062661561787350295280940705488051266462611896718603847686645062109996393774788240170135481392777288490570e+02)},
                                                                                        {SC_(5.51723327636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.59912571876643112843423672581711050010048297317961607409825899152201568265814939524420270783676418983565192336821959178308980267384169529844813114515861139342326949176632824266265482473183125037840450257459957900212150939142923073681233762674075587052192448025588088282932927107938038749967806775395259684873810981499095151858552234659724816251014527026911090935249406686093634962334581572982993744620288722853674961939196712451509769700523090747951376519438102824496906099852506740240121078438482055e+71), SC_(1.65009407826870653612651933214957347531916913256171357048034416707968507274796838179768517286247353976812021079376446710071709918891506283503353252749845939622475785517947468014113580751946861761977807445698139136003999090928604434264914562129227594145225130236704164978424029429423971788106902840659087081085602478976117497757721020106416920731243987640848390588291719822433054772349194724340191601936560723898339546139749382460638530415300746726876973444199391562140782410955411138156479694530761867e+02)},
                                                                                        {SC_(5.54448852539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.36963348859129932162725830083885765244565298120707229165880920560014323244220273824004697217390516951031394823135845449317019210615190366107106578822663857637154953631879413783762758791737654221732809493474544825324816456840318661919152960357357555388443966261856466700801561203734123800247936068531733100738427856642639151771290953169330378816709811944085113405163922644421852150582157231830068470226209468036866154060478617724774942146332669428672162944119724143173739570707335535113322498841820437e+72), SC_(1.66100669873044010904501433288458732499812967893510651881848204943272568308438668632802976387744572965702081639784750195299092078626713239781119668835184616238019332450833479935928951025069106212418491420026061659292911620401090108396262046980730549281511096258695057625873055136884628573905936028503115321061043301503194818309842899671082066259686213249217936866681165807345765765864262235205654246463596164138969890804318684364225340323672345829962204119687379612492068585994745111171624256672951720e+02)},
                                                                                        {SC_(5.60617828369140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.62728406523296111131355808896408220483122212493644530547421409440889381677426598214179515024723875571304139457495625118625370238465377699843404971592441195605019230840968886831456268096329174168019131782115361294034477360839270231255641106839370252937972696173709528605243232234934094126811293362160797978384326890310737756907774144291689575885298983860501089605430193321841929026875631620592449674704579391768483259112420485117912758686374200703034840412187265262286052457833550937813696437999510829e+73), SC_(1.68575624196050997267266028127284627373835439062853280709730250641775691895659080234915944809115351391194349799081170650336129460284583581311182837182434777787020365926067248555954377811444098668933371106314388177858633906779013732328021748296720192733105063123796421239840606117383188280665865626704745056680142896335801095600347583401898777316702764187536635745970202725607621594424872915595196978772906401516245756637987366616577772028231781285735190365681022311742523413918589921589652465404639048e+02)},
                                                                                        {SC_(5.65145874023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.00532796061027588342555634039840958050072003725524897780153120525098039110972677596923302643017425247011776700456138656970587815343252699971432589970304541137216971653146921253019828921373932258505387424233563536965637072767427539040695829500810356303246421059814881499893139107001150451269597055112993867253825858647093910267606972605767467096492303580321271252736901613460849517094992901230956665411827631262731029008430550242963503955925018314197909669408289089678939618884714603915651885774093117e+74), SC_(1.70396610698802152306545992028045088771637522788687162217040911655994103120991078484591541044681814790234322605912505103279643770594640862031996645079876918340627167621799875799132805688459562663055836041839080964225203965870990530884592024930226824328588293910979352119356940879703753504807864546230692672217401386749251975954569686363045717806665309755015678650005954843235693630661880028625814985348135511544047438477027345440190935907742739453062649940307557554216607174200782135239117705440723125e+02)},
                                                                                        {SC_(5.66864929199218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.00893463079459638306852377972162212832314281566339974094846403036833933679188303046055230387181667031933042449188201886422958599767084705176877993559428627960437073918886961487109618272999237251180284680777602364352806575884701907864629117084864327798406054087618133419827665763186982313802818804484662379248030769718776783842512416335502226422458514344068771367203490351672278569905316747759436759190325047231031396542725204357314732687817257818939988969471353446714317126638405408286279074800705704e+74), SC_(1.71088901428681912074940442067870210399918955371544005621396360219841515025008273102784409149753294662455477907345342433925316078920639523342844469477264979432830558435811422842728066450696651669699657071024334864037418969229809753531292356478515883546040020790521605315474695373051968354857737158398676456447944828086746246078055573703027656096829984338245632039102648845378550125773172367923607477081418755563573116154024358661756787074602643281274378133464726584156719335260469091519291187320234883e+02)},
                                                                                        {SC_(5.83486022949218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.66581874590082465496734219192934428465315333521254767418155023566452551364671696043600154602064786390918015735794727953682909582293741899527795433835466229225777782017578053755928795450576702258516311538492179414197412787539060300069046660508877295084686993107797129273447838446631248831643936224431698066040453728941611191917556730641074451575955824045650867440725370691279897877397079313549571165216405585458263738561225559243034873003030010837858599717957007061657127273454442703054197549781535638e+77), SC_(1.77809368902389560556519654747745448286133172277814730190202423572238433139459498749757973337779309761402913422192990146044788403885949227861537332221601596940991035689185054557174332115771043545920552344987525372742450169315871776578854464324264816033096820391038456926902066367740213891366558650708302768798931468897897175393899041471179739295386490478563083906086506690354436492491188848330806379184668481561917447521582179012903931952812528845553214118197733608383457336735789605458597140262568222e+02)},
                                                                                        {SC_(5.84292755126953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.31111967907968108564453995966284273070652166577412570137755436665123577124838509441936653645447598576576026037074759853571168566602779123395303099783690660924490120450513769954709948709011202016999747959079100427549136730815050629753848445397095734003665257163391679334625280792749112291303920083984170684582246813632656063567466419038283733376599906778545803403574425352630710904790589519407199933474550681175535686868562007253713481702903319248809189782732834090717268736522302713544246016616289193e+77), SC_(1.78136784277199791355980792993301578877401705177001075500315339022921965898320852451122120109942991987872235659312837341982115462584258391166452781567213633529952056867920213872386761172375807748643983194728614291717942731369559504670522696088784050388841124328589714361309478662831427762779233609754195822939445772722611522584916683049270125720102199221013596849873478037351888114024969976004496166291593935489527520236453106735125128078448367001664408677906231281405007287820569237580932655505337116e+02)},
                                                                                        {SC_(5.89785766601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.15434273852608175052051007957642130376175355567520986844405556707169579584277006050601431497552351794410079718939397622430842292284069664653775293360690691144451364004675301732538948711177929343415531902649211880657979203798645415145113592481692269065315857656050259143492366733773252421884545554189076127852258046550549044604541757433866428171998298663197078716604101092736549227739434262194055095943034111018376417700479683389120931266108913510501887702995757124007870448387721782901462590044575863e+78), SC_(1.80369122936847833747244620569394042241403568233584693954872045262000138107949636178412482662572222067060256012498246282026848613652111521810028375472949571037943007108229418943905242079480072521774758221319676601855780617550008032128487904542540431362243741808393437284925124052171322198361092511256761756805568840787495249969603080415359347576499135535249451812386160912834561464667861208207405943872521131917824342896068023785679236468172670460985637658921039909878761896734630899508143826458508817e+02)},
                                                                                        {SC_(5.98653564453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.00132385823406532195342969241575307062220442173885196890428813567099088944230699644113824335346668962868193903487477473257524420549118385296443027202466553272385575239725160345326269538237168306474105845435233094726596350253358535142477920588235087499265949077286638979519744020953413231617901088981004226798455018084713439728199569166897944080677336032949816347254619616891551126954818721258802245261331958655929372783202877550532197146374267293901424907475973903859686473262195736368518574304724290e+79), SC_(1.83983829356798021112695277102918916473354077226552128937050486109009612802197835789738736961915496095990330934870586550492358340881933348554061876390420029246386508770057884901756947512682678410133178882335106137027931123425242262509468851698599678577917986859627502006572635669264212991783791259182455083384598201976527201156604576062694711662752407780348989716944966241981177183352380049513170749345083806975563338443088290155990565362951436323577941305336038226907855799662285201997239942491174813e+02)},
                                                                                        {SC_(5.99618530273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.18668722102926537686863939509792177324229461246086173298665244660060212626005303967211923026239764928480666430339370818761178314295116738937328950259822069208094863002206170870796473287216774849356450437446051969409744263120254398739732763046364310264795258893303437793700374326669976157331901934865550261825914359068943169512619064038979210313222455753372124869774505344923318152917450863789512421579479738334432508076125486689930362625524901574853660403217646683635521674487002926598422228858901666e+80), SC_(1.84377973016661553300761083998264163865041999231213658531016469846184962844040216010269828613767503702200271396320439405197315796937770361355914016214453751567338529140029955190627434035790921793172278249561877341251490913832954139497108122400060599323840039514043471997972511225474546435241748986793882562481512955086942096212395141866194720887944537106646237238255359617235172430682472462560851135251878435044590521732878437044695408173963600011371193781768056156302719569901165806818818566873081647e+02)},
                                                                                        {SC_(6.23226776123046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.91912456670046432469852028589778466351728144671338027224238548727258605194466678572928419297177448918791979245220722313814355499221027013903704799880617596448233076474701583332203353566959481686926189218031159629624421889569371759574983747270910431395179217232975957379645136744743804228085152542422986726758752459429669982098014666639714849501097444268034200478506951313388425485759765909606913437555419471482645604506503985352870252218852203638516838282424150305484003613426746707079008036610862687e+84), SC_(1.94069016938717002121600868465417170068275722132136830549618739673540558528595721646986474264244223997245366273670281481954381402563333141326592053919264453523185795443198806564053180604379559769938027888770407669907747539473560815410497659889430116583677006755491651924796112845533170563607089203807483875211251378906735074149245804771030420040753961966836276519727633696564992683265102297464748789065038807327540135272530607479359251689316239030159424321824274758007537996660136043615694512713923461e+02)},
                                                                                        {SC_(6.24204101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.87204070452368133653844358723219684465183819009686917972438864950303983526648003998000078903116434656906362028654248915812455366066883079692852261024214133379293179572879333758317510445761200423979917977777319858647495824203654635929565314050503868097559911139962937671629145171641481071329414102124252208250217633461118428689666383022894295062276894555947097299092847546251830224087702187626073543130546956809963957622996880721653073905973385612413024120900809097679013486079273744980732653070468486e+84), SC_(1.94472170635469670990129901877781037441234931236216684713262077122035127860610772038408743403779382316925792913510258617846476491211139695534707320363709525445945968639324638064740214239560630493495130726799393135575689124672391884286110335100009167957317042894860507476742519787005926382667001472755932127084995266518174229613287419023814214494746387155814766215779110520219447018454861865608050915048474823759933764583932302677383449086940115653251190200643736920299436772417482218824788254615502032e+02)},
                                                                                        {SC_(6.30627136230468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.07883809322567587351304757700919210201400372370028014733669087628987589983158274706635048998196074484636986287053637580284941284019292351038519817662734698756805000503791605776404718964179164829752346964420397249229213797900541748569898231526572393623133190548136164426880316375610214932566459240778317683457371797073553184975848305506903222036894019361630611615621088249827934571099891820583768933088571065492922189640245014904782422808773799277443981896105025033510586570306426738661697302847069341e+85), SC_(1.97125545071279985432055206158754163270540648066516758657013378166384538578266055959270557408892575336885482608794000336080223297390417923023114804281023887503320918760718681135095586908775440404505075418483157233375973119353660228493481652445978888497972610501593218423789175261014894766342625067988760426210673357531336816557704135310997621019268260940292968299563365486947135813716127173841000025739979707835004269227483468161153151246727699291670427800414125264412036226352142701587621084843256505e+02)},
                                                                                        {SC_(6.30905609130859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.57679865750026937130403923658564977522695010429730697956762246223763963254944582095624083570446236139633946216828720775064575249565825108056873168699600737856992778588391840698550523979297625479814939161335851759855722980810086831768127340710930960729019286335431680773329676256863623979576264110485129404743954192093539203153625739684379335089870802004829007562145642119923820657807875466895498912481110055111761241384215082335460167017039523979462575056521850291932064701022425782985118168843548349e+85), SC_(1.97240732675138865404966804720479811590190385318354047554648859340319512572550562926118989787546352461154699317140709430612541875001002602391460101795979044389923331104070975137782943289806651025391656450371895942135634950530237013746064731025064678707401765676305921885664469729627213468465279967518694064279728433332635769201668442507443550642503464029098718510526907763856324902018709089779176595806441529143846106552685370658607660243268315489642814834632633008382960728962777104428378537063900488e+02)},
                                                                                        {SC_(6.35773010253906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.43413031568444785230583446080523334353678344672827638890428072339897608400118287075075748023575441301152252081381518778105909960253202649716579087577790006138717813293929711234603593342889945612147466568848588310068827187349087762503062501361532456509808803806370919672068134422458480643496217169097363785641909057230701881150030598693049060661775637645655530388973347468061009784075202018600226911603743905594144035721867585123234504154294951857771941049092626495361012512470892419575559684220599104e+86), SC_(1.99256081707899105995238537106332708026334244963919723532514110952603392293425804378689627822409513988073007866856612085968395236548793856786165144179368152868330812796117304609784819548590189391029998601290429925391101535366306045639002309495224031473582463016679597605011525217050180259191810616270062645849536614663707082699976497201935204365325221630524442864415807503299603937528538236291174847569491278382517658996181943173995923450076572037101653211885771916905333999022232021675301162810521983e+02)},
                                                                                        {SC_(6.41318054199218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.42698519898335022546569319874437414223161000361853491645314507012246930440411849024371126814203890210117420903688773509265950146019646804999322046159830789746426084532755841419833713009469348095814753785276557813342806360547275468512809281273857182746592448980100258242561981413748711829776566203219384363064291338316358626801822999624152821809531297592767666163800955537894771893334785422176052647269926841199742845116784302273434716885975538788388539714047585834048357448183283245905993491094483591e+87), SC_(2.01556584014422414705416034728203732392205944644801811404502168456434376113630315163232898457402016141182911028807363439651328454836614863527616927626599755374990658967127451481932277045225117961544308086635341225409726591288485039940137540880564875688261058269186495982113937086209632615041014780508375528611128332946977437941680417056557805521035777021329897035964936079010863537427455263131990129119080954927720597875082491541518620821296109588951507936968477013760594935907715801177547198838422484e+02)},
                                                                                        {SC_(6.51713562011718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.59176538800911938350814428766006978735945421889918747449436416176734427252777388352821120714757111560344853866869242754596614235407063187052084519490127367917461657689856477158122827538313663948496743163417391816727552524399420700989108905425941816917039799183267240679248758347210698287716414463976400404936117652776448357880746252798439463824712564801107914120618254084707517725422190286662576461758872999940377255406507185400907527167274291615298548601355364186235814615625035289236954368588135354e+89), SC_(2.05882412536978094604492822987905038263933337923558139097816338191759338923650770311106570155528318679110140524205765896765715783439245284881543589855028997014931969590587891245257589050135016960379801058699133550089355823471261271483420702999297086101179456455422738790343489292132383400900435369796318443279665308348186077844574157190017761709342311710175434225437182344225198416855422822849165263353074825246033175874829300040290034949824528522691849044017704163743277517242304803034340516836073205e+02)},
                                                                                        {SC_(6.63102111816406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.02042767502802236838052517332070636095415859169105291322614886559121189733678241986292075208016773103947665521996041465641301844729658254655013812226948565114442422547281040480132634202599651244616039520633843921307466447913810731030067065695885450690904548777892319268591263171440880592547970815812433995605132186502349603009727226107723853692642251515143204480281646113214547704739214532918847942892910865647709977877888032239013084740695535189025579840934541409863276417526792192505931529959857981e+91), SC_(2.10640641898066274039032912775682771492148229468233994108303959301748156780453696985967152523444533629282724550139219905281963706053673921436112311017807494239048063400112752991704577927550433643728258578568132056387253315525251876173518206873100174136766538138261863562198346084044445996825023130868924131313576937241312855820375033397304911073941499725560879661034357252668623689396388749398002019488847220513461349610575365395135451608745788625026382151715306395782047438833586733014561981163445820e+02)},
                                                                                        {SC_(6.65240173339843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.39575122167677575610208270386905265806729379941853186968465262209497100975510972380161552808692742665779438250305547514419290093652214875451605701218704075674462088117785674406527678262530298325164572156064158323693760229616518608304153170438231372807984698086309690520793295480452320535401442063000537533059350350288541391932286503974746178889933960602387029641055958763358111090943791587971557202668425888836069857913931126277006417588153765341610635832007349595746112280707875714069931567289920811e+91), SC_(2.11536149138542881429953686350281053300655756618879611049698159678932781608060947504644554480742151376381461339145780777164563886056584828272014896244304294127461783692773902298599152911376586807152218480938440856918333672768654828848322692993711493512910124245380697103447169245927887156729519911056083251564743753952766433718528529400914505812145000197339639864206343409356733570994638564012049842630578161967664437238116642276612216504343225306849207855887203688608862952346693486753793358417226619e+02)},
                                                                                        {SC_(6.70259704589843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.07038187670595133629430007175837432959290946324944333023736730996362439759386622286470232089193331923584334413950641053543771258225138373425862108125488059451118296745371352622417181207120845004565066108038733562551562401132363377720862326126821923914024246148719899804740883548994873018718782653014005434650987876618543298801582017146827879797323285517205221379267910018340442548423315614973812748071871945567795717366271080107924314832979851285930901109782882648617544440093418815787162720366729316e+92), SC_(2.13641250070687384819721023298141854021674308522169699945863526766372631226582693285959195606567409637003709392029624732096703067979349517331008524414985605987119357701477031607859451802951467613970098779547036798545577512518280150523311197695896483937933016610121921897172597952911336551357300967589197328630945125647322578991469766915109898429859732859211713226663253802217668559098004420396578326155965147156055622763520240103001095622696401445939943714952532596484885727462059067739973900614225589e+02)},
                                                                                        {SC_(6.71435852050781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.94654537945542967401303266491965790751135473718332919421309929007687837274073521038496729732185349496360972407556564901268661671079342273794410552499384881092793967734398463779298365152005655118301245048534032769019823477681162565194438728072292877726040908450241010020686027879375861425121224921153291348822636245749868981305654304622482235625212970405991969804089865390472145451576041211655732473907395508260288375509085670079949991686131665876920159108687012939811203138959286213610108382816911859e+92), SC_(2.14135053848290827980384905957152639408443824026010193681584489110942310126243185979385219220756963214320908219292035061403237189243551069499740711645081582968202936867810735282903902280326311100947540780539614924584882544996605110362005409273401341732635401108637729726695608609691853395730754929969880242143643026047293456110413346231976904980922843961028802475219762261569645554798859653297485445421638385289736580847935992207389649744522270606239292155807389736671409208364902918381623727408885929e+02)},
                                                                                        {SC_(6.77765197753906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.42329763943920629786424084656741602177180860476122439376656705986831463674502641173192798441368875545663640838622189524635348813597797599658428178363017662961048512050298836108614557492997978056923113761690573574598964007328708512232703783225888329182799049392903679599962725062094493137928907978794362252063902382230328721329785607967811827657503486237002502359505944620656402414340485916600840331870478584879096444165574504087380072906092173084628459970463197911541316728118307647336691208112146320e+94), SC_(2.16795975202020894959331067783611790241560176157791421153126679456220429243228883228918420730853315357353207568803869203688330691136792045010826542419499052259815629750175692876361572434583284891588446275913905962383345754994948038812469663554314080399736094688636379112725908900709351636469025824840213785169018208417640182991911580842706850103389522631573021289780106348322079882478206677282917783743570640057263485251177052349305371022677908707518709713462763284102106606549773598947439659599324084e+02)},
                                                                                        {SC_(6.82992858886718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.28742728434753828470950476373460937230032048651940555648949326006453882895637418882283825736228591181830700026820424453917638544173629674644723558264007129307065859795981033520492449956951693686957120036443188702573162473328012082936878647736488091582498164371505160579680594612610246164757992856923720952956388260560404273989795199596507365335656143579362306826603961790464250912402365212438307219440061856805177242373633455799268254384021758889527365496892631661843137744874008746911337847621644182e+95), SC_(2.18998229708218472573221124383337319575285443959933652214730444555778968544528871363492835295996330510778846644463129525381504046406834553254285787162473540821992287327195138826382561913503202031608620913208487263375221420207779131355930504270217809136342782183648485925931369193382673398755606007846749454319400029536613121756413080896375333067702367554833212950148397289927961931522491545519692572197670162034618763874158341068695781524700037151022285783627122033713599144787290106762266119419035844e+02)},
                                                                                        {SC_(6.86930847167968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.78194524198764253935293924685960457304186507685341002124795160098720397877248055084547074129421459978314217860635897835210742481364957032335321817600502372035091090721049627357295736936985016617932355533307724475488403022170372901012537447057064407222750371792229474898811793803655895384557679919461705505238331617192249427768904744203739044846861797803931051857381486653754869112682629123778313994659394748686240728046366514815648010511692752805050983119394324243019276569152142835273111131600739305e+95), SC_(2.20659847804083906384907051514872082061230620414541674044042921288843119583551298204632257060496765706867059434541256865718056715357766042999851689620781307975502879660162551314304874688575088583418644818982822427963726538178844288967778976291078192323861012077958372167260468411242670517406288263354005147124463832622774308429881070899793057196386309054065644897572808994660335187044558707052835530972888952967277974508071086506597317741709813213979340438569164933284793186907303388894211408854792992e+02)},
                                                                                        {SC_(6.90468139648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.02274133511019485583988469899204776980456774056684066672286969620453688307444228491814508991434754830000820409365066402249512140453233753077127934740479709875672706144369331562365000549295378072233131975358641001193506696992584528857667157933091543789086178697447848031835456706532575059842492635758962253361643070511799598205228352711927090751127148286879531092647429814165348528175265811953037424595680858019938674670963305706080467545069331967872512258184827331019538116894453702243713920673210901e+96), SC_(2.22154333073937963309284270464451305415567713356183916996809028250224446324976629918561880255034594588139465610035548638444479892335980626915207148799415948364392093782126809151718720827813726904213047270727073845012006511768403305403791771252433182022505470552892587913386905125799070732624224012150635775743017726040000023583318144128558407083977660335631622322836590245813033509831928838790173778685268563388558828899739378886330796996037861831987696663717952401004216895270706364036468781635421504e+02)},
                                                                                        {SC_(6.91464538574218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.60649260710529772233473137984105410544232054261726481804901382352456603736791207353288895878692489945797454994320261720519981568199528074068243600307457024299096270656939240358519093216643966960316998852658905467409459743025668321894542307141623557025880996958371404487147215287026431391504473435758388440094311393508369867761317353700422529638292656142883895250773165627587110507038824743522069804645711709312079958726863572820726828956578534635459474570140307017716422854786215483659376104193538697e+96), SC_(2.22575635672110695115918590577182031381966802318930949156616309616868514484270689147444392774966118458931416771691192119217283518753777221963892104377362200368507925400050176951613839266277524613349776088293713738939903474184705526304759499313018568067983097681361651924611784414420788881822624226463125441429517020372283342751973503754599128184144820600535877488980638508126185420353735890080633115417401716461134997981796942552310592995641498450430406389193343801815830115905801596467675090472416441e+02)},
                                                                                        {SC_(7.04339599609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.07955168370258431501067303765307041042253511749662108499654172995195919890728621572472265604548157874425594951154488292915690876822306705540706807497155520368115695313979997540753080862207102914364114167949746652315616647011583985106051436261150572485947960668686207997789998067343052714998635702824843686520461266899198993863582597484559559022194974388735364402673541227979847184402063848834687319523585326114498450674922707083475386513114793967781049780967212396264967735570494025081299191102600215e+99), SC_(2.28032470053682814150909693659939401086917190673111549985833216202733442036570175244345294263137322389334082412883205915850819372371153905224137138568851070681942685426002412704795068433740533335020313801587357225658388021327925840302498743460913140248750979805432142282679056431020456697874356644535352384674096157999420250192127556344582057179264673020098873791204751289807990176010774686471374333310634428685169600262753904165502175379975971287196138991380181729373176666849173285889871685443192502e+02)},
                                                                                        {SC_(7.11850585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.63350639773014098330391986843573998095148344846438639704280326830561525054532992266151394782624557657729556558678640210625187841674630182373257217648180868976835851508169037646737210618405346034928397410814234450897871401906937806043520003563445652706752649218899032858007417374978845485122177335751403563652773554947671601689033491144144324684814326258879173333280476762089154236210635460147379080147574135092948768026951044779584253185730061594787890924261378815328110413923272130365565592245349050e+100), SC_(2.31226825488706942320221372209052759874582593881790219288020218185543021092397231928378819282290633396851269467760376214835813537601586809929350368068369106408868208462608101592366234623994189052700749994189050838419131640345688000684932907809888196801722858616196932788075245301007454503206331714091483786519540760772557945245114058781412186499228946577913932289437780929138851984933005344343339761935519213236709763065510382791519155409439843482777059517548135082900878411139308805363383410085533831e+02)},
                                                                                        {SC_(7.18507385253906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.49732330886114956729903492967231099120981689988470614601064338672708151166612212409693570573697532552453303336069988141982860111367711698182206854590245467087429086510932930642838004332475148547653465131896243811450945687151783960665902929229554392946636288454705065990897116487932510488896425121635005727457531756737839020028190140709062395495772982206742132290104264959510934652975963427615519539426105392687228317301810268033563861263131522138185870575767315052749438067728273033861538427160068365e+101), SC_(2.34064576791946060896313606119182488082566529844459748960355933124315417775876694818169147442870367658128072602308015711339409451957631318365734395020638352073825545811417527613101240287387166495001733714730462773451775603992969559210417622967701828034603900976804223721336845723876182097307746315092522887814477094532177768451945462296621415438098797333009453107985658002443597004122700883763626112244440083086420053250212325853266731701488423921240429786666074904542048428895402985062775020780609270e+02)},
                                                                                        {SC_(7.19748229980468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.63799471891136424534781581037881734270209689591691691081570741626642848063715581515463925408287199445978593847300138730779433961633501177058550310117564525664058272076855042491774645034794591212729305598946520940175098602170881847040428529672184500046688023767346931914653501159766628184918989164050591313897018136001253593550610968679908774841461364253808215884587220575731471838139199944268527092762417993923355816335944505951209359016119144117907046251862182229203833394494471672149610892614669429e+101), SC_(2.34594229489778730713395183268481268533313625049321103875300316143286582678917655079164628572296479114156318367073710880351321060647563247630502264645451992444023031952017156904306798526134821751416899017432876584158140320330851463120804059509775078069199431076511808513669124909294314859261410937564808861779079999863781431595903854446961976571791779814964065183234651321058423766174913297352318301976488510550472104180145775350394475463204546994493226096306737923551596471864643784269614031627401875e+02)},
                                                                                        {SC_(7.19857482910156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.00270707801080667284049137931007921397071295858533190749182181674533881049617386936830453405939377809182267841513942539726511171736762460427803321822929563423006253553551302220529378391240077466565459187851544672111764831101397708541056852997129266454471645598874823171404589319991748783062461420243374104014114054229392406314737220859305688382677447311497957896298449260797868887844371397774886361677480978196153679381787665490340524747298068806251709718124920062314551977212941639835784458709791310e+101), SC_(2.34640874261590593094127152924672401647639982404939559186941475505215425504035334920198363939078389457481819167880046593190391024230612216202981537917474010637750415091165615994957577277305363583060006173286690346793212661694349941719407081780582350194583204552812083593148042583454042845941903084773893307192833332140901636375439025610597818798045159225257684627844390762342071267673003184928742894850480752496758083244850624302604526313698595834705671677315868214301011365215142174377762024987919291e+02)},
                                                                                        {SC_(7.20227661132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.37303805465152212002933833481069295182808010592267121190344032897885570445603922324812010280450755478774902585298695970671508035354187420144033783169240640838653864920083997632382117139666203979520402870913656694719573287280930814348789662709159554341652970995619762734437041159008417774513513575175997159826455311393615474032080189567347307824752893439818807444114127616338517289998206205732345037054157126317153754271771112658168316678156292870405480742977954214021160941019096116246926351436978164e+101), SC_(2.34798931668183689489811003714947822248687075416433892703360967951861728101603554652920009368534958567518413137244607063745355575358759569756280248655040957334433376108428711420069724040151198409411134694564740958346393856536904924842105919713613062181164174088917032677415822388455660178097338717105926628433933783419222660487149698654081950085336262631094590672129121860761900722620760385227790497260852982842757021734835281954304352709204338967635475836677001274419319261528043022078402221616872309e+02)},
                                                                                        {SC_(7.25073852539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.43520106836729084085778956456263007366457610660211308356804607795903604205903006861626940571616758431188483708705112541065913612170982868979138374222057745044530838311693207402258346596133020939130766196380325691152564593723037668386878730891740735487495367730021135561331968282946393311387564533951038834032038906087160256673685147382181654337851041727860353702694472391018833498621069942838095743280549222839978177874201310102654927981792274736107415722890492564295715073245406504748411010278457116e+102), SC_(2.36869905108431683936809799701037213902840132962445950159087863767151392537365457829088012233860101415133446664625069179705407273558177815837911402413725567621227251553290403977011004098283213060126615067528770905043526027425714284293642772945512987034649149749940987987282066153578004652877777069205069806361585955091537122404255644671900305284645385248418831413253227335874194856373739115256548574919845614247054282038560824065753222632104305482406642615557915998379231124924466235671891452085471228e+02)},
                                                                                        {SC_(7.30574951171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.83368904948692821415701462368046695202486612714101765523339198368422240427056106672521727020788297278838134755029853525826240430171775696905992365128734083532239559070717069572014894326939860499578167798833295684570854229896751700580561265945686503512548554188728825057363206984887300823450384333435198218629970990833645722377925579365942064093032376859696969471250241177602826353281251607669250065823723888615059026741805474782258611176825211988273205012026413517684390964185594288523589770185452205e+103), SC_(2.39224698120410479538322942693900100750302371932518498513970196809717285652555406363425567070534620185762039330299531580293666524672539016689119664898814223622248034618742951717581421540067495872362627125366893309516167623038435271704408134175732192131341050335394507347567907240217514740760674515613232222441102582815234411374214121906829085760029636754767176893524536921973066034719634005122069259187062974845953794788953499793268622745250139533192406234834053053126593008530180248729385294424110576e+02)},
                                                                                        {SC_(7.32414855957031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.72351873906468427927434749243813946718492824644298051464033227651267721874131369030686360453838674597281399653454392712519996838482097315107046317757791590222027589172411232504621489664643848650270625328529794090865340207075554086734771760739189005347247497561092355456867147799893035155774929656399042984297099726370028645869467397024372525417150906070220931522239593143561251296312656675039260494381956881118249845133633386942844663451695203906956726307735499310146186355391329884667423153322820283e+104), SC_(2.40013217650976835621157835233793262249556249983525975778051994370838624089108870584615523205800434868396676458119595830101103363230974997475748135773578471342878612674199773452945355873782988600437154233324008409519071732216320083908700784750442896633871090689414559645936711466290041943618756257745187631302129212076472621111660377092879798381611049325838760290122015763532662852607044508731411589596965193851766890674323066780737296733477691014068044838476213088598919241840640959953310417958070890e+02)},
                                                                                        {SC_(7.43542785644531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.05057539261721842528885509969765973447368871778403642251340693683832762582599686981915475758777749628249363962669620141299715335451343165630801212919842103593909541427972819750900099159556082957831589787429058178547275551230067634268190277872910180466774262088408710522934303590920264498295736830153661283971355721388880579406568443053300160496066408381694585894458038897108824998578614767961733859040676188324483688946286431897634148725088944123683570990210525326213482732816270511822193032938057778e+106), SC_(2.44792140290461559015608660191683906647538337402235360992803950058276397205841643970107666957090600251577902918891601081931217556177441460385443330358798306259795876776818599203615425018561219763807467394039107536233629358829593264171294184649424927776279069503493001556067798490179396110412631967842755164760965853830835968513373138323962196968498642464328928626116147386543025368199899990416183041916861269940388736111702241880139889967663889428674332508520198705205469187793144595358628515304034126e+02)},
                                                                                        {SC_(7.53251342773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.34450173886605871850746175647689853845137789653006693475073046311373226224027841491530308732711009686586842056304257354013893945718172394735140639993167627210518718411216631690896419969571876344561671600388880830098642765589735803154418308628711332909033149022575200265268797452406626511994213601291123000753123661105766161403857816977935150857042024764226795181284878290595587741079595041602434781314700349706197292957258354683643495630988675216599917063436026736324763554545773796709916187725651109e+108), SC_(2.48975213533400885587637691407121384810544183192148335858861452453468279767415393776527155273533576836354512459448312350622908135443050111088976233097955451277405326746182472346034496114600748614371719947507542546467300701612516141702635968086610245143035634860001899594688878405584897710701059457452625844410950210744613604800040262747640680619205824048405143301800770844766969588318895622046783778912109087656103522244258726909926657151419246134983372663728981134772950698713692886267202772290239989e+02)},
                                                                                        {SC_(7.58867797851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.52064099241120839241553555175065154800825782614604145472044725679618326874368100714829996224430528944422099953301775491447673521847023758692869380818929370072753340828440188353412171234222451046111156082148590337005097363676186470812736096355739264956973599076774002187509871114514244238270432371453933456401086514329982789654412301889250531378151629276080470889528069665845043022094265532108347096706819057706648218300430313387835745459242829301745686486046199414046908590639218083263199743197595955e+109), SC_(2.51400907087850065913573947414625032904671121383447551970348482268163455985642835731430617808248297652550140604113191015187375045974571150714301822493699595430322794110657302437321260873980014851953656343264038486498436740894972501820645365798347590337834137982813027441633538926570243517443985279225897432905162521435549176598139109497346323391120019990290150009034934628687017185188831652277517092336899156528663579733300039421610455619418045056887614965483270716367739725999067896145673923299273256e+02)},
                                                                                        {SC_(7.62846374511718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.49922614094816158687439961093661481037234810702887805516931122154637493554212818932955073139417858865556442362239274940666473504207297806766385685660179254296756645324382472145132719416670933652209264214351147717858113551215145625224552303504637643220376444209573042722311431724120473342395806440765185717702904512609122454950044602469120536144869356135738716318579159461251534764894261031872874364617223515229921670219532040826309832424582619620031545239192210739605925994909956967596442929984888754e+109), SC_(2.53121750253461261157926165483338259506280329295050669213959805473005613085786853264918544920351424774759224890919503206082158569005711201804286932818636123198065034824258540195752455187274769227201462726202428280344798809973069251017733585289389080574191285152182058016757534913424799037881047219705041395775580668115715995698157561159537648352763988254360776036505973177141699047221833125099631699656501946106828699155634763374572586547346355388965816585722422683987931689969984006767292244890365688e+02)},
                                                                                        {SC_(7.65285339355468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.44328233143715865979067125362218230750511545691741833774669401675093822089298916821946021749252994666055618327326639446756594002322692098327061303976382405175725973297465838679821381012919266387290046952061939154345453911454165050224113452847446481526177049450322842349725029204286296504235394215207283967407565742687133377051738810399251865021358404288107379562055972010855458043773100181817459739385583448879867365058483501289268058848398485010733777363308695038824615742826196288630982490737619083e+110), SC_(2.54177702582457404872599490166618690101396619429694510433333174582246355837919426933697108445480960272390662026845326249949216372762237888604462531876530331763138586218132408418266282112006133279665782434076767039342072318958799692295680538293762592852051844924349525576494678256521832924987145984682152496544478562763167898941483491938838964834902734326521933830878319015435622053505214202281673655648142102864872210356314882899338205344297510694121925220450582814976347866533520588982742320766439488e+02)},
                                                                                        {SC_(7.72524719238281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.63869307336051372959408243660312533363160373438260403644142677514038035500017680411528973659763860595946543595355948939034470985819043891159099267948201467366660281597652900701211516596330385863199386254721860339020957922080099766864203598309704547571894873772947649942164988823440922198664615400569707361018370742266695047806428050897559497924940067587680446013069045998943685434113022629105921541439968982931122191532865303630945552174649927475106238161562965905486263818811438986496825513637014581e+111), SC_(2.57316597636415280125839885539832422327028384008465105290539607418833102861464491225192479961609800598603388977003020277656192421494339452190729124101492463431890165256699199041374479756510159928563896369245691749784052847992085392738924762063155623268080207335467141395162714018568674082778047127838097779641551291941776339847523209381716124106191078166858784799123524766863312212028306342532526489067229074022676360465811189965473674708416255220146449182899327412136084950163226199948137452893680442e+02)},
                                                                                        {SC_(7.74194030761718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.16396089613489472016995377678658380446923473961245920062030532600259290874052185870763071323324256479433026727236377805170595562642403572323515509706405293503612638534638124581548346108886569907276507031504079347672665740771712883539118519211205906850696296862664443174013717675289484573935053571684852228068285897882661720487640714252756969472629393320568755609971119607547454193719554772166309047227968669585212681948658637840249673648359931543555176934236488679101517981820203875534938182054528036e+112), SC_(2.58041359169692229394146470361757102165171481664924088601840051965221160090493629861255364611644912107425923030168859131035219386259396531102485379780552486978801953153190487248001969894813943359995888684168354367524976902645748180465727249368626912195861924811960911588788400035921242866085423934141173065042123358071932446406617142131624614833689962894262245461566888105904778058762073759481272262928070662967439223048222714778709958246110214128080579870289345281284344445624208510454423495356501333e+02)},
                                                                                        {SC_(7.74887695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.57318503556727811778535046198574625914763729721329800188881059948624355392224696914387989746465413861123970505464968181390903309008515740780910945865981792858625294044088283319093981345833143509860817185609094808435220499094014905467770825885351007714244936734979151217533584392146957401656086507563928928175770816739721410291117377012227173693774106159236840499739132409784400495436998690624432116376101102365629523652827118641421933684786146996920727761397639054842551147160965304785710365897347221e+112), SC_(2.58342632664765299479261435032591639897367252976699088770326519539616458751460436198267419198929221817391439292446653099231773357359378953909093696958925732441991326719007853975630750664600116022789643028746413824014096475355722522052341236795413172551448202780306300398706230667980974479833198735645461251771059269197235819448033765448433853896655518402335711421785716185757300432929144147828841660031749371859857434653339192478951210484668250481047873215582224562308994807088571889566499812208579266e+02)},
                                                                                        {SC_(7.79611206054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.22592881794156458446052462717595126536262539090658937723483697079416119671002260444795643872522105776563001197318927781078731229717855149387116040683142410400288660857353459094132627642437287400100131928719033799002443287445543810490300646052632335621698671153552243167639303608865981129351233813614118131149101613467461610042458138597058419807568525249250630798103454408426222503790875152936389126191608008771920051555513329641652288754274772662938190006918185060994323146861705058362696710330744166e+113), SC_(2.60395814283749057130079935554277584867813599877917620661240914444376387406811844822383436557177931094472429008274043483007263670532295108521433652222694381426330087436463972983665698624623201467334190235491047796740683233227534777329571432018271488637975693352766700581687049143464728836443474208841916151709004417302089301594887700875721776638799017258725766477572363416260427171722136077719566612571650358218332597734123984669843135210714237285262719294895510682502823915696104275394521940544919085e+02)},
                                                                                        {SC_(7.86635131835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.61050567305592220456152565164230942148564845008876468783079125218738568867109739531648027886908405561920936404327008113338837668823045462401416814664853080167844534284333759220396595413078747532795418553321714788783912512656022776146260949338158924577520045933863185993029648129748796563225259082682813710331126899403283474477532377595464796028358150441834390887390602333872930828230106771171894718510083301238439996675425133564310770982602045974376029057672235890376329572299897207660789102547476188e+114), SC_(2.63454244548355645406557573404138621150450803835148763287902126807962988944888186782690423821551077565964473228346552243343425023594359629932950671821996960194806057329125965993803317853525313585118175847049038259803134572085080825944549279422931339045215986274550237455342692737666976538056517491589701667225209690441329079917551451728242728647018956436123513148819620671153439928606916027213268680772701127633453892183849889751158464692401042242515527605717337698362059975173305670741190034582345513e+02)},
                                                                                        {SC_(7.87446594238281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.71837624022682653050662525112014758816867875003265131847902688055964642517176593117496287671116136563264491789852708222849348640239441380785771635209017580907263863687289741192677847138949151131649311369876561874912704943331918988855886232533705013511310935868278254710745534548689545057888076936160205888610699783645733278440630405505887873943782027122090065276384500599678106888523954477191375611451517934837045651078621522364579858561084030976295747171725697367071221913449939276734367948915626281e+114), SC_(2.63807987679752100016175435094436543969868151920491747261488057556253844905264224201473242499982049961008046751556044728136159727267854644919940576112165419414802234138378185979596500527688970168541730602570167372809159118442057938651283236319820022026854148490814115502143927520204879728916437074242250572621439294603499695241505072139606003819854900195753589328738735320410047165217770312930492650858332385736701370183913635591828104119352224598698412801595961685080520596865151065157552096804467251e+02)},
                                                                                        {SC_(7.88913879394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(7.05078178357726410474499063325837303106920910137103134019210104418158882633130228551893986765522818663440917130327860147833061843615538131479644991925275085115368694397206296587077791582003608613030789955656819980122303298903900251318009299018370819489337668916736108240082513671186640654973589456517440546988704885759583400584082572413524186749008182054736492250396198262161257003088599222961663885218760682149801289472257557104489823675144839902973674850172712268025619505445748264626498551225801131e+114), SC_(2.64447839103284956128235684594872838722673490951947089399274815716094892209302547464293885712494797370283683422781177442364743783116820914043603349899664703253477540140367138878150328404445864988238511331734092922313868756906609435883645125621324352909387547291631944141820483150765666108068429269928198949363614471852366168035632259245468001541921511923247124519423964486485058911434025471884809396247264243909679683975547281199015891927901064232110010913948020149398704248939970397857783512416201869e+02)},
                                                                                        {SC_(7.91408691406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.09408630889928784995366101034741320822207279834027238270453249877880584352669825603178562703284706934951631129471239102447693830793569725967938487137562041240629518418460157493730099318010606043518294809161339258419997179007349381751297235189597986225603736673752801175758389468868908522525458882947950545150550030322078819854648909136701639378272181333812445555534256765672912080535194117216902242324000109327520303102170890466509052343854202275380426325647730946059107590555586681253687814620983684e+115), SC_(2.65536403023153584181009366509944939933636512249483928265309684189563613494760548624391320929669336631354799737976611608913222008521274835382161622182309975779259029765302144876959170847767080160732361049556841935864400648818702093248178882045296280850512931678721234983400481397860250228997304157007006352976939819877862820296819278998885809808276622234696039204137254724104197213765964626523801038106954428152996443899583239076910904674512885475994700472760824262723489540535051774095749851263249929e+02)},
                                                                                        {SC_(7.97761840820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.36079199634029091076938651799381162227395151854994589288343070392917661651832778942033252044086374956158961748049622438314469763959461683034382310349408060154074518497763738460082990990829647834192310943330698134017546905950238846166131473096056251978957157805264833546417571995706041453604675019148879806136858368888755272252525296383236157048398929667609392513772845625191397222628185041916430700732817309729016015053983279819231463094079090001106112163736903059352653651668590397732314816765520047e+116), SC_(2.68312047446704936551201646268308565989055995669224270332238971177523275624114106350924550827954832893926360128561841213655745069215375268280053327774384246966880049772271110277211800705320934862873007557937526250918855419370827771874390100701496371022372316379233768522789505608766708182727707608743777576965999789704312554625387227826464806494002725220159991665546408752810364171404216636162283932101127607340416316313963340855647610740487718780190284536361353566264092648153963919226671135448911486e+02)},
                                                                                        {SC_(8.18258972167968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.69497801715505291341823944466394478653573226015069840233760301344112615036232003853340643491253897084350091966138150705300215882019420164546028377252930702792521589338261508474246880627609446162999468530730121238092726471747329156922095797928479805876451237606446524587852029517769329801343279088501888513954275307497747337763865806806406346467581445157182819019726753590749164267109489952242163494169562783305480340836442791424720704311125592005637989205351675021345658628837029739353259846801475693e+120), SC_(2.77301601206713380033617693878153786830344875545259297416229835015583825907512523049571737167755512875924722446676821999765409491382152022874842176237305706792335228881488212118956848611402510374718226442209228435834294021556287185295412732101171221125002257563707702688402289790980389117777811679193784649416884695842513310123040215065358413741319245326119322458004021327888264601330050922125827878039913706293920225934979437023174398406286148561214942428656926999902319051063278086461970390249047859e+02)},
                                                                                        {SC_(8.28075256347656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.03355259286154819704219551226654395906504099781980718189010222046388212585372158450768002121529565043941554076356321710498359531557447501064276145807321202398521366659833156357752972507906824738391654526335132932573107398337998291798297386653691663749579403316591054269038802812169004153547651014880281564220416404484856409392749834859784000416182037739572623416447024555101585323087262487565041454643160808490925993113405987429965247852197914385018523039216649953285606019240086795842095595940237530e+122), SC_(2.81625165654526077068925249924073121003016044311700871305387088866293803727317559314224290963119864575313632947917677680669519628303166226702784572771996712364168797470224812933324626509432447937204021470084030660427032168951011823872492136779555076262106191456052996396539130060062732303932743480718984452917269033526737946263143307278506852358007407585518712083349536526597660621880354083566603740686029120834703866962079788033455307212822174973485847830329491718286072881212539315054338676887614104e+02)},
                                                                                        {SC_(8.30768737792968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.67371114734752908061547616501953362888754075123545344701696519965806930080461201134144351921409889131577000496545476418900593918789113203113291903553623430829522236655918744889767943693226589545898620418956144487819505119387848652166385429031636818347206755380790194158017299123963514719805333452005960947638713859594934023751184336332845824811763594963561199189413088144447828985884611507816281472365035371107039655044344477957681971573509626723153289201570272369616087170053842773571123732195148399e+122), SC_(2.82813557444376584828434965542575667785580707101066679231071503820665911776936151156471394971750487716282814977361877634271653128160695426275036808696002806135071055891547537428728895767109593217204318330470768065883592419876896552206699595320213856775213385864681977009237639675750081260230142974936055389669776620023794558780124186887105662746744143136387863932791251282696227816499996110649743686550043725473956807326664285881088122662448072069170162126507907097586775108499996228535395664775430721e+02)},
                                                                                        {SC_(8.35494689941406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.38087594810824007172317526482395395315515281973323750835943287918036441101522146181320950280907005936536644869459515895630947568893861360978438970984364099029399610364983195697978184477779906525913175411730400106972861856794282812899887472785589696827140820546454454254452546653559671707908916494776611762380091135585066103947092509652659548063168677267386196413563849419530138316458816291678031326659324148655637781459343823674365831836666507888399565257748869028221680258772558892324258985830216952e+123), SC_(2.84900817614821787311354013125196922305347499212422605892549254341126665527540833720877092440986522108374379472367009353725288890020954841214326197685621378601816567939788801160808539787411925765444721012192661714680396001381835054468656070642240272057212425534769467099305112437120256925562311398588675210896965199313735364857636659712200395328346833022585102465227465597221999247665850846990320554146744067996563763776745474329124355234423352968479337161445353341784178484608139997913928508370571956e+02)},
                                                                                        {SC_(8.44881896972656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.42666833057029522002844137163176487295236913142915957746565021804551354855453463093087070413348894685610837082261892298754492817349750668766296094888752650865034632398047114223732322099618094063966849276886337772747081947435890554455490878510521949227307238529178533803221256978213585297126604921130732879198880933145677343705812949585481044421555113226040199998463630234148442473768452479439746175913886297512229427251823762336285728638121354786435192375488215264066783455853500502632517317397191379e+125), SC_(2.89054725081189490845947420649741511146685538739793217547650555624606175297303059819056692884372884078386830075996318731414936158025276846982001943699867169461703458538011827884171588294993801700915253891568635380810721968776398838118775237059164552862557622592417261801286604016100245025050781126892995385023634381604544996542145189076944911500566104957354877363628943389158576238909259399367640949833599148363947749091718337785962555954463897388654227267906460510958277041230544448075498023250718775e+02)},
                                                                                        {SC_(8.48019714355468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.37692934320932297620981374050517322995928364822370056283231561336179289500921370929456719470695055723488408828524737123108775932839056147022184960787602221185341428119369781671947613160459178511396173156859877483907121901485026718017763578420717931798182513542147552062432522848865118538541035507673594516917038643758164417956892842566318015890871496409662436465557092347656329424195954333344196368227152968549834610314913943949187093924403634495721405296173700996916826333049876082586793987975639900e+126), SC_(2.90445577623558718471247339061488213888242311002481185557085466364156718241788153628570698399972521875326124272416540356360973483982924299495472732527445855579350412985885474284574788179173000292494530174623026334523333562459396879146333235990015088570248419292901518441428883606347370774550166714396697556794729204594146604214365196382675843836228991246510493222815148738810134784398272967005152613250351795609342442400866153886535045246197053653739010937545045557089427320285807941370008488299231342e+02)},
                                                                                        {SC_(8.57517089843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.33832909826857639512345469794224629431863744746205019570713593413174355413681840734251323662261286343037475743371405368380106210626282544364717088243965802133669782776732738382008496885261218884763219382809969095376871715586408966585332510293058737930813384640468837357162158315784553713430950671671887901645968817163396711406670251520106298690149906371213473021604786054149922929270903602716062423311090876450852576785572572036859023487557696205357013047761812845708272800521434743464252230061623459e+127), SC_(2.94662434149078852864533044683430890751857634692011865421239447493723034471975719502158478358928569225693134671590721633683310220971342015064124134366039686660903743149425635581599837403308236420466274409421883921364526784964902879126070829463180730626981694996688156372167631098166484804873769772557801740883044257753022047460509209568607086637282554678558212689974540373894216164095727717722436815597302622187007814732051809764574347873019922123648322650228948344186602466898431539586997877758835265e+02)},
                                                                                        {SC_(8.63414916992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.28780442416473245220993417125843211443922827947715176026304195790252522756485988254317574050560830931766655835187600384518616359693792782766315376195334660370712947697015509483345560675594842551719958111070071113346033949776784099516445593701873985922858303738123261934902146229686136604642874942111538415537933528926963380513072791644764824044448102957590604260889847887609094258686316384912242648224998422816568196552377009590433850216097442453499745344913667602947562258887692660118963302873576680e+129), SC_(2.97286415767791898783137273348885728560402374821784965819753791581931702220185036139846739534002423747332846154884200311239613175043647820938132227917299223856302828493526636466913336383317225296782608199960652994652737854245932777169314282737031524304643218872099503414611159163700671360099767073557121674554179784953493763081417956047400998059429146915818627056653259309380153196074968434469066936204442302320347293458731802718060055214439848310727105052057577070572283537251105403348908202350818273e+02)},
                                                                                        {SC_(8.88962402343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.16497091538634954176808558126734139383737220151002586863764390216608325311354224623945807833387024682881726665479459285049470005141090454361104648074463928899349832949354678335633489379248100907353042144547088922659153696935259491401491453935889921332339646024077803179260980585115144981597236105432685913954327379590905087313647429348781575292997793558631588353170474662811666116917800187536083681419094153230087707754630865253287717124464223227710268458962380191485579036954798227359751349462251363e+134), SC_(3.08699098582574540874901131606444829079827093151742779994254570119225093746828470772591943962894899861194077510256353570911176148460678141159128649251499460366252572667406638613671771548486374251674647935746903854762624451710412919721911034042884515928480795510065676168065676205440554995458081789247569791487484423535353436040389054764355826862135210266509691969507902762609484577337926933364517673031481416783636479784014250799567230708999670147781779276540235164766801425268672586312525495522925408e+02)},
                                                                                        {SC_(8.90027465820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.87780606828579839682486297865207414473915059257037797744519875719664626455476718573609744117214029167978785142314872357628234581222424935700531114713879884267432418261610741511776815059877815129756317302341224239276034805977343452323347378456909427278334973253635538590224095981120699481587755946030574521394259861658122318014234956945530178081130491793013572104343521414300728519011590257888824694899803503988988012904865970868166408394593025635261987537708676505790837434031472486324842830042702493e+134), SC_(3.09176506571632456661296387169922633668592672051072655211196652994040766909440003566891242532352089213045883882170560833941457377382708950526763313018699118120380453698053681452767025054914992997126231495133852442181265968658060914464272207315249192819183080634684126063465876851228795083042228478530126646865482437930517430804028064010426712428251729707819686528889880916047040445248119995350317206960036438745949753331377517382844268845949439741976689581628956251067901790913220675968694083673487767e+02)},
                                                                                        {SC_(8.91088256835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.02141237770653771296145159020408881160989590419650870839398196043333840252005325735288677966280345378465299219993301159178503922963933204046292361573954097969187224839371905345548563192140105220315764875768864854417184036541687412890821354212141753891135605827639941760913661912426915299535839242021655832752433343294076763148034591512931393116354813721135709720774782626096642546416987266526920210682051827938993518486923365371794879517158653786326361967520012063105962048816773936536423552751777116e+134), SC_(3.09652126858000418732466228930005261043074491779209335334289775565968084841448943907137967412878070307660884256018325421477534987598584720609289107279261354419541514929763582754168792144055368288970235585293488977201112044387382737255177692549721807160464339051691282827080114501542353004889999789051718622994246873560334278221827736435746212582206773547578069546225067846456243190088267218770093127288806348372196341589640382469134243923012237046136953985881262427736754212363159539850461019015212532e+02)},
                                                                                        {SC_(8.99494934082031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.31558655781768041503471804823072857551660987893193771300923694866722085437810174718689818184686160543355659918836573435131789037101312727466050676295123393694959558094041971618998566373464656975432193808552085084233941827245486553707076687396813195185672678723677125523966734627106140802401897221851259098606091358250676198000082721515457318154554511901375574094053788420170179929670798848962491431604495643329405322390907180789283893100597844735061218202734895598115127593661000761748877366559387127e+136), SC_(3.13425855264940891377739322679679701437736153823573638382405842870462047253093505527290921595414702562601048150543646554826489940007848079633436803489842171709369467138537164298268952136979863927342727600551602860705692198456751414362549778693316384937321572839532158459656954184100209595837489019219748987079473338463489774192604391414722484649705407731580135667950294425840948003237663213903701146822180319710147233578390478895236810346201770445751100986412992634424999142036287829615247919394118871e+02)},
                                                                                        {SC_(9.03739013671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.86792769846398073158588185409127746786518317702712458255738775476500152684870175695995359303076769136193610241864674205406202900267195798945109864942852055462148552705513394540607224575512328698207619061607005694145838607754787666580012469862576573548961202438961423960092870203630962408071476306928156592084871044853220452396635064991834653131047835418341620932617272679036446479227435435487997430981426228453395058498001575602632012466601760224395255128828602403730169970645524832506460262769922979e+136), SC_(3.15334013785828495349532035339943156665607307939960487381337115090498107824790216760180318686253963749203757541456225918165272299768010575932572807072640852990782052206587049806078170264820194544725219973399085424751859003502907821494476427727808358908168867699978266761176417875691596682525237264639469902785748762642384210586356867116426877838848316248603954248921190243183633654720939266664415838936601913936386430973862064257478465914198609972828748670649934640702939726267333018813626726609454334e+02)},
                                                                                        {SC_(9.05481872558593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.94261458224695981141369098133253703867790026761588476125416975351640813358316898519254837574567249935885699486051633712064078624593548009810348066141179943221841646706583752101191904588544454608775434416781644692544877023766579040440447322187741464563615930635828169727556640003402245628046314192028796512950830086356489427205097330722518479146042424090370497276188164843129478617752147158051725479824441211533437609225251604421732365835604215593256934779460210667503156419375982154179739862634423949e+137), SC_(3.16118192528703981418400552726276675687759179303740395416722020128790101184582971472358963500259877654665311620677333946329822781359101955682422429096092123907256975382594705860667116490690402904172004096156672614298752088275735696742123448129137473162400015036946095606068303962089583623495361335018595347294184045421628733381025142172965399120167601720209789608587228023512855514598980256349740228973876344585607589419418869879867146874889122744202917627670004193351717048152115460737505822893451488e+02)},
                                                                                        {SC_(9.05739135742187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.18107069766063532419245836536254822108034581886312685487124135068440298730035208900320969514016652201174178281679735598938523996065020947571579893563292108033119930166754761376804960651592977130363219599641365682045191400497026766381310222652009526402992027295622685573221910910908248077633982927941624925049581407580258434709382788105487147587609374487313222064190424559820002903700012636149088840939067057770871300337937992979322966291480522183800733167189183718550962254058813914237328281314202052e+137), SC_(3.16233973642128564520032932606887103522789825214982046617415401063507803185459982755439000054699836581126390400649617259579813321911330312947020882712562563725983604870138861006695865498089759121565000116233173255402040196144186341206231273407839332614281226634929116514836134924973870494418933399410938288447188299481752862253218523748103363577520034339390698612761924972864249573829620361774154178407493269703532971305225768634929351668515230243975361330413576077265666511139203265571070996965851636e+02)},
                                                                                        {SC_(9.10841674804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.17089665501277517595551491907229733926969412013051104729239208322727072951318423453332457345488055048181460539263686198330703061316372319516650492049625291376040683681859758067121828379387721946617331150152729752363611541139910838851623342515366957959364633894875643012137605026777313017475728823654503490417214077721204466781411604783313610050551137130977111588650236412541939649005511178465633299085498656850775152481958684817849474595139738505147201917724867003003701827781673310025120058637152956e+138), SC_(3.18531883120459976548615729866147634441190179578312525476830885292496876482788328492878473418831237059363988430585051185057339592951272144907044357413502988207447267137688625110010071322221525949923071671571521613355840749305089157474748077261678948397440128206643598140207611964328691008191083631508868839672114731744050729909748981781227060098849159297799612737529871671234603519914901020813641140606586765729072334713248648594326501502908462297493397490043102876133795816567896205915324748575115571e+02)},
                                                                                        {SC_(9.19048461914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.79755081545306548897379109253071423186894482112400872086145886986301975112745218201844640998153519427596175551962716792273867553295516510225315832502296282361571218587929498644543442644312445406818903988138895185284535095750031741193379456797538008865996889750152568147035918802977319367400899386928293301143849614536172256980163098556365135714921713860881948901793786823981460641176103634977234216076900415820825203690705726681647558421218713699918815274959798235428109180875994004078087916625467814e+139), SC_(3.22233801292493518788961789947859975913990456514312793909579443126199933711446105694104239875773517016004540630259354820993243091605328124329481861339187196332689083458888308284212260237240115982648701006355037449090598696837120879199932468347397459713028503969084184990055184508401341459156444093429071507557479441617462602833480285640053902106974820979175129222432824161961256287329517440511054485890040359613179100497094890900276364013150370494988665992020244449985109624724713529242120122364979802e+02)},
                                                                                        {SC_(9.24501037597656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.03347783390537019995503033019530819608166604007801391222097581199482642919778844366630918624668009424402059764475017580151422700726983486117050232924614200359384516915589062855863077559206548341192274226656219242158437998625118666163882645225084170519891503827371743578722940996092006964596609494457061444809309058646513250847902584632763211007670082396148129094454199599918632675755285930859883816437928751984279199981070882010422759307631303773361004562273046166390504043129282537152418344467557623e+141), SC_(3.24697427764470095450376166774512991703359589712997497306649401762049000374460787679508683049679146954502998877961987740384542077388737473823517305509985484988988852971606345314782540584923480056377654521924933162777881870819776897530496276653082358832746433247021011492518676539713762283368975340564191433339902907305832447160388983172881179649272177993224057664902289075282221446020049342897769048937232289163945154508432948331388358608171238071308423485980105911638638134646435087810345033453672797e+02)},
                                                                                        {SC_(9.33306884765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.56163559742893659226156677177183415615362557335830459955572471558565744177992107156024207554426985471898717302110186717801009469009715785804467574873947614452021794699034537593022205783199218855623144954785172443541352762371963971841409175045103636744911478347262427818178642822885762821949102692844133467130594140191577058768672274241329692844448087302575749946551810836961763514438264081274705944074764712006006301467656628284155582794853442402993274559736949774514879090393937800669939634849563033e+142), SC_(3.28682975442356269450804361546353446775558843254411478792369728401699860762124529510889631897131000122723366460873209759442298321848552145472750755150492428806841202335903281774836748820357949322186462461903375376525398853696038655720302809519345764715214843086320812760448812504197113066581913369118760097607632595456891768624200303523556873732191738474213257464469403988760431942133234318675610849865273495733187891293036714164585971922539509751717274889473990366351481095742329281810895159417339621e+02)},
                                                                                        {SC_(9.33645019531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.48245884324047592693378940012945333450224979745418856720209654706125635837956144126715083688340791473619470518428425773625931818233663964590750262499718984011983220430791664799946794905019853484988855659840230414428119993282971449533827793399231610564785213519537138530461802152418285400472181357386639996800791299432222438897290106414967230361477963008007447474679993155355815915254632893949176310973043069033669159455455810718563262746816084461206604787296239673163384054824455148275830637858147254e+142), SC_(3.28836183094662658961822295032749628419239719474009490883816527053315609621861146311931264278595978531924168646428032586966673735242679386468446652243211829021720037890551818831158077264285655764818403466140136311676288139949369930226820606538721191579868075992233332789006736850437132990866630322260318207551070260162047052662890955378320735557477345776481703702937383899591318961756477131142376888760267646781910870095650790562725677733989920486927428741658028463119639185097971191832795958571835833e+02)},
                                                                                        {SC_(9.37523803710937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.76164954038386323004848445587140326469032220373101116257601133416814412241253225685672163730416426100328136156082409851178292149201362700314445578373394967833719655580153780818803583756322339540564203378453973785823049257208158246228542536868014844546805189024288766267804088495153116155120682173974014496007569213229677178097339807860316609301434481972104823908833512243616107207006116063922983558546779879018687190610539761069583007847793120863839934735950847161274713532225092934253594486397581064e+143), SC_(3.30594525866895214951026132241238206166748567400482469598494155136335192618897080105839026840244107305051632317221620706098034393801456511907262008379417555151588665957193894179579989115568231372256173550497100205568070991730712080877788193212107298668456562017219680363644744047830649103890523566400212254885609965053492863377463403703847255492463017184836005150386313379289484470683059285387441033310602739164348747481112900047334917463926166413763627950805183493664296256643963074213528516986813658e+02)},
                                                                                        {SC_(9.49651184082031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.27838376219628673891092217649851988126764531199798807890290146361590940654850007618702649147926834058003362655285112540263448950656129542206938036094550768131763615084015207813115690276604016966803189068013411593812003921954580658407034547403901581019210265845993202918334650153701246384864371215385225953893283458438032316950625126312477346200390326216764345368804641891671497909447055837014162347249478963586084879790434747521877671493340004289609780578035454590620777455870595392157389612690513392e+145), SC_(3.36102525852210065380668443735774423728976193524082620377015936174646576647285438027205142148854452790085614071836922050574459959922606454296862287333058234054022167631344911718426942450703981307806411492642746516468347897430961194466789112389689739809369673466374040976263657414475658834995507613956104273735496371594417968621857137691549510981454555469005437225190699728493247476272421470502012162453174746447750828983776995565113221375302876169954112170144356666613733946218896083396998695009273101e+02)},
                                                                                        {SC_(9.51298217773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.96276747437628698491352460237248259496626684260033707005763227822013370019653342953784232077884190935825645989227161077245116122136934263916315950449044355587721816388549231723743236650269459273141865777655737253552006965141733896779654501922543258025003406101463741888081684328231116460814692958214955556748851267533974424385873830973452925516089784761619003744572571487984030102240163421508616303159507022185205473070031936156375531911971248839059294360815564326009475981758577654219196924254459399e+146), SC_(3.36851779031193908419600146248383629080902012445957782412992132294243572482871977674538504582245516373175991422237922615903665006378579427226267142371150432986512873651136296108959675192147003010518105457487118640943905414430400970973972730175748276752276987821445691530315604382805329868168412943160512162305508314942942981982918029853896405837983025487559033043459552983592659151823279071396895171736819580860744170522245106128382142935325997632157072613927808553020391071460615875612817120823542627e+02)},
                                                                                        {SC_(9.56334838867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.94402294466322492664780789471509891684669808277558270060303082798925971886343113857358108473247312587626779535494118409642777698272855883690084352721186322850448584677396485622430792251796208253402039064690946506099908493726120068544064569965928247691033795776280422468396739129221727700957244652587298495565648741262404576582140864092814679846534962677104260968516280525640566429169570052768898388858777011908253884236193338240045360249963351810888908708660609692865672036587639611587752153131410988e+147), SC_(3.39144768178903611154576513932259822435828878296128644191483079168254033693838887927979397184673718377716882172257342546153685018920203286505133111508789747654771949404501595246222035849289436795912582662676925730885507190721625399973610161674490068558375641100068386604660001870298150423765325113018499943138123861909290369909868670216978062261723067381806756231309995941704325749243483157767001239482771598354837777258928962431942028548237854445433411661741077061012420226965779145908688609131798861e+02)},
                                                                                        {SC_(9.67532043457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.21169744956312399498639455549630793101638510523115256212991432826587137896748185274765824853263981717541314120462560959899030988978065056350270590964980759984318293166529560431663444907668943073203792179359574376805708445722562619888783394502001954316085106412385599888730885960997473921812491801513821448661862450289562198377543474727080955599661344303695664443585113003190765509666260094630216552777786839743320069847183523581786382266370119362625483879039637503342853952338493384883177979748473711e+149), SC_(3.44251978453975978374745800747879774189361811030869185021040420288142023108381585370203061162295491199587721359027345899087313215634137179026773935575206302599871850716081255115454383423425373728218234804045062121974725293497216937165192678316620041794496639914341221603981972746523105510386899410906294184355454380397370980325094540245905990712376814296156381253545591980294873930514771992888761841851391888241814358528503926333370744886324217933385419830722831133674613612592027573978330001465871304e+02)},
                                                                                        {SC_(9.74890441894531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(9.27748828991886412538309707599773754507919038322041847048360331703677164554558750140118371249999112923047856520365587882478092326144398321711017275204417078380790006163788219386093013952074269642134046771675198595738077908437389738569523335022286226393241408867469862637418254358817746652142034322749303696419920176808712593265277216991150957940883348509764711360229737460318908377251092199416863576246462746293745214357831877521522520574163902601228419374989812201640714432568431255668739712278198143e+150), SC_(3.47615354800856447336156742602043631636784276935754163017637226242831700077490633569878084429133081451727469860693462347186772127059315985769843439214265602676092826128277472706807516025993082209419921249964774447215026046195821260324775297102302720656604146624172947236747126720144586144965303896599606841641640538342158145882231977847454315344618666911069649256883623971626487922850619963697283794124504861737713804771202256891702804129038385908043657200508229850073636759622636008148176425703091210e+02)},
                                                                                        {SC_(9.97344665527343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.75212611306447520909858927406858433023122496707177809190073316231201213909552285836588252577681463819793907197633576012254029018017530475940549270670747327875547708149734921788106151648036158235955207982183955863767458078644890985072784784003157657078939847654041154970247192315236124080561972996956826056919766749997692638018042864132793894798768475224229161182646426868561046255948721393550598468635922750973777737790810626367539267239500147871398512741844024844405941448683844846584113373116616584e+155), SC_(3.57913063159066396581073316038608646148770679653962124306743233835262807077597545920350868347013000566526176914739081425845196396586525066488617318862480150671221153881448121348388247107816625173070919595245102453823775236161743405636490832617367473872170698471952246214374847309993080482365037909434794981854043072050647922694348353117006595085077595746987066212532387246587367424722559377450911273762645754169610858342062275803386085396070359095336458652978786511669257538622997396529328362712159203e+02)},
                                                                                        {SC_(1.01136779785156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.75347730083020939485038162912066221581429168828442196039463827459526861430475699995482981019212730791574136303794770558637632653539966787313265805232908285329023762299185014861422418481465071375177624076746341202484154198136575647412930445794774509044561075216290472866615013219185046317886077929047200074616789305725185556966392977981343942503814374008958810840813123055662448373018471435385626941585862611395432770072626644156391905251833391251776044318450848049340149430633834651573099126602231921e+158), SC_(3.64370045538509487768445421235423359724165918482902493162567594435641438527780707450531003969050124751986459088661597995706808788951592146239311177685403275556816691605701950098832189999694016858167797087116289453374157732684624480988017079231000288334505158201945226692599276945487043383856946148759913833496062922481619161243219041334799839274405494278270804667465556754366581890426570645342309897086504847897108276501084043877611362249341645546845389118917835053899026722978063924256857388180755486e+02)},
                                                                                        {SC_(1.01315826416015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.00457510991281502769226727004997679262304075469381924599171977187228770022537420994772365328581224262995097856713877243737738916378690255197406841438367198157367222028885739188819221893998874723494511253133823389573653928815922129563859445580146007786792038790844726836014513597109949268484909314677825366551459118028717639223624781670474311535217218824243945045099528383265311230189072692780987851223423192500364210661988512605277297349004271541908259006339755059345435938135279521158674365292894604e+158), SC_(3.65195882178042198649931968011149621283488971146238633105553740987173403757008718100277733785490878156625277039060382059688590867535166931940037968795818220856593816974768959327664263543693451366193941953177034784288904784400121716218959936061685743343972096090999742020173760420863474502571598091487483375402518801564373621465430088239127603159201322793775638351939991008845336720733856574548730516780561727018106577182606384397065860093671233778487263769017285490842275884249314101743662659144772808e+02)},
                                                                                        {SC_(1.02065887451171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.27801326900345153343880810058385458377628466548919310319356208295001391627711028108964043747715058688010148167891282897721251134516392211229815633735336900159682119149211036994496057477385364371651032335430129210391891032699021075886871436986468388270303685964233997952971494238945883816291938728495688468471763874111752586770041106497240128592171108689645129535717198560117944070009013995125562286608487870236034608620214564008241724858089991811270552418742087333377223955627801273083063706835931394e+160), SC_(3.68658921617580562067411514817835144132866629706014763116035557045564965652500986674593929360163570308689443456931582700224614304705183015314634933020226691177371648521879014819766803156565604404215993318093870166021879012194525067597162546457359170668710956917518936585625659425567139073681368857775138517401175534361146257935927911617665535974359591758903503434806360013917203029465393008200496054786387251147733354953504701878799021807780313234619151600219448162688809231005073094405010463658717590e+02)},
                                                                                        {SC_(1.02115722656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.60896816319517148534428232121099224472906570928174955627205730308593272095810179245609783698681170668816372103853112217011230591695869860419178941850553612575073503675334345279935542462445816555476534631191068558913617382873813056138931058171084616630332337766283314087190503645051068942875378149790513113094622500955980787327266672560687639557162522929706635433286775216561301409145003020847665542949100467257193220016339170437994903646874584701565461530200931941961289559836505330729535444901834160e+160), SC_(3.68889207960158981723583667551616655516830734599087849468445758096998943085919557111615958075388853500061364091220347702900711300471342607601759599003918524084136225550138478001032313242708109422326492734155678074073630480118105464454933040136288641575391783537716074249697494130114919412515825448403613643656748307302754155472693436900441158560131937501670474182282174058574205247092188856406444219190689086275769410408827865199254939649958746821341426770306076300437929253259079804248817293057357612e+02)},
                                                                                        {SC_(1.03151855468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.94228835083308640822499028852065613673755865463851531438327058166669144767579740506836323365776221468064491933954523159827868739172089087439476571447114427920831324461169567100875893875784444712930291417219026660402685651505369912395579027564548381277290431987355918726720732918689421442193807912778226301137893083370436981941699729302604799060234688459784051256944786362508416192857240452539630544116665633911680458559146828307310632090438458941753853672353518092049434148009251404963278657426193131e+162), SC_(3.73682651905258726016324716387992183499818534851084298433410462119434560214759364867102585112961493700822216081248742887146719492455762826533973189295420418841342987957444088003076054261871688210676983131129943218370437493592743430770371244025240198136170570468525556710224653368582018246366989546767129729722257332667137633309476018669688145592375344762651638361779174376851220119649663435444291450998820250943389730137090903748676104493980087117773829641533480707556994175120002401746782494457490678e+02)},
                                                                                        {SC_(1.03178924560546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.20171537110984503746428094029808236968900471595454569801962284884588253557196632314064311459204453401037547137721252899300675605221605850701531766220848178426107307853997571883397237019502185275899323162662253929989135552592369277960721465557378037302534013923856069596458354461160387042584077252216864036273505791483850043082366786730546213958546404008342532072130559596289868522883170995937443132537680477434575640864461406937897986942411334230967925180998172232605542618057362893140400140445826896e+162), SC_(3.73808021835721356724446264394902282290701854468791430816957474104121357346476343358635806510697201871317753385561836211023660949327877603013631398345339633717493827744828981219248357257956092252882039677272319317527100441867500400037527723671076722449747821677450262639970845980491755826511803767753250916930554390222742906323165035718151118786667333899860809495013023183520764835815549229361219355867174863504630209806067234900896411194527257618519084429726183193460574424568568946898172759856223065e+02)},
                                                                                        {SC_(1.03298370361328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.82872819288012606122385963898328361524996417570678799694588697839190735174600170106720351533370631952004594424240260318156779543743334978103622384814628870820163074161490974171932900138828578654353210801510104125408235246750846394710609418092475390627709768228356388946400329979573725826559253114278336778834777284568651859102449899273147358506438973775986112756427925176585046638494816652143034181522337019700644796616551060074006656209089713982818770293251665711950859025929851173563713461219206884e+162), SC_(3.74361317748560163420326195479254375911567393555110750073620747146220483395013793807665984626248280853130047026174123840945129104152085488651750620885774044742807786443568160709678805304668243081991382409243452732728488756014968718551977463681027566731857857313817370028589856267110564911929005514836552959724444301628121435649598322899197331618582218338230007463827482009711821766574469772696231132570472922552328948998512472526034965401802610875788479029246956411298168633713329249088115783146293828e+02)},
                                                                                        {SC_(1.03869995117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.41808227279543671333479039434046626158530188922152731293342661306573119318405563092633134973716965074833789372968028834168586671063089271054131771945825757582712628501547074057648793172598767906983963530048248045469128383694252974808161180554768191225424352766335755702327435659330161865775483738766096509778836487654811038642151241098269833579763630984293257933323924801773786235314368186353578754883559503875701698799907224370192903533452100452108739079966989498051874352278825688032663449334565667e+163), SC_(3.77011112086662963245675580860653273445838266375268938166882906410114995628208781265159991648954543286824698469454566104293241788084417271750687731183944221956896689140884801402020542550881252898680087044980595246072708009401646582838771785004679721221825826352639947747005451212279129556801460350965125343184149109540974126900025713968760305721500405913148311708196503510152872862100655916816216486302262077083994494966967519637823805835378877890290286168019857511375509827417374620490655688713244690e+02)},
                                                                                        {SC_(1.04995117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.00678523887863281704315445004350037860113537505562283492519854184776749854976501039747505498206401986883371851847764028733559550284466617856098938842238483952037050298291535951048537185026105154426436130154396602767164120565673550208366259366381260022023273091633469615283569334286640071657511517754084778826488799083437892306566642932709776272954596072694419598606462123813205893259756109628659535751983281630078565414508016709349672242918983953337604798489765842178411006944951758872882478372023226e+166), SC_(3.82235887759759441458200974176916588835183231553065060110938275665761681247044148976503853974040867874294045938826589445275112659911927287757189056270707637343453819762906900535146711866787538123092016166555831579927012757456022795948174490211311393179055868077067837678849001862692893473813415204752098333075191785274078510424264923538488387176952815122989962722692588617583471346613585349912068428187382230147398757659645529871296093351036151672007480156877831337995025225476574745527346807158512968e+02)},
                                                                                        {SC_(1.05218109130859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.83976634226548322572919174800895706904078782065799096443773537981885185694587486811320986028190855120878999289642598311337692901073887957309137449901201645735680657243697681617222494949638844130220749832373225763896507711466261063162058760477938214785464118394399129254067717894129969752496013723160483839247141974257398086747003573635548210067354653795490286183627182332662761041292473910667668859123430004827439901075874987993414093280641989070969395337540471734658869020146669349679577353694738477e+166), SC_(3.83272847211949837396147225745140765469959845295613313699908764628230030150463473596541716965378611569009511597916333970267521155513934265321685315234895891969446621245232567943644593070652475667579171884451144515803354855337891804564947800457461153269074076789377868905007126549465728836749088552564963936223398281798497975704081603691785971120903388881817641414000874590895163255227705961236388698142750934201258204390506092394191759642714932949354378711173864295679661862382593386315557987799072805e+02)},
                                                                                        {SC_(1.05285705566406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.88900467122852977430860808679378603739475246531678043835303735217279471293400470130370648772140034717690092903165160234871744765682784827549731664070069315567174235375782928260650442113456405116882860216573420614391827950702876286870267067814697164882316796311045310813235466126083138233688957753026489715271094509332593818528703642543607758021186386446874667512334846224158518227540773901225191259373031925996619779278140509075065215271119230249696085858895953181416251932353757464942105324166755880e+166), SC_(3.83587278693323204678890258871277514297122579999980052845382376239620941482865363779403085682074841362888123392166265551639163741824554153804356554969593568545217636228911896958403439549653223554962021643289594844423916874562457761621160982899462863735444243455143610572630923426116761775450603225902128263476482113946133239847073900427016395029587377166423819829557669486815120023155228912681560989377874894297548582630710711089740997403499152876589237622444767284857349769977956865106013347728272228e+02)},
                                                                                        {SC_(1.05497833251953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.04350370816229367100337942994885015279526453304169331541405449930047964503121921902865055650340720039463167689349929845708781929475609818050890432868358093439084801254450413723989850649265525551466442998101968299189171128236309030393012630061038516261354168877970899971437602497714061636143465994990186202477380118969487154531802906088826512149158175433112047766910317896476878380545357357485271295125700882753012863548011070030701648140146862221625454249948037342300094075825716659580134996181284283e+167), SC_(3.84574294531115932149375237677159420320457195540146825957123495914414920297717536466610017007678437690910405675946752707021447129327942411269020836249064404337748747238670706269799881082342729228159556123744710580924770007457392898199441780776607607891806663764705100979849989516424656253155864858901648204573820569648064373007896785842420760427289138945103659594745663220485538043333864464089137493410979015162544737932793386917842752543631253260035596795692444801975621684522304127220533656281498487e+02)},
                                                                                        {SC_(1.05828704833984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.86935956323451034432291565799477420264574942460752629257797287105180125557334515457334508984544079071767666796613033989403748997881217445422941519799379563116273641327023162631941708376299025410868259586929229394778423337476191581551414019662216362920147345185750316039793792632623575204684065564644397428240912491954400102870524046480730628911687821733279947204985165713648677583149023921958316124707430853691606160653731533104584128854331165869722998686041425859590119586352716477202105857590710998e+167), SC_(3.86114672951929698920136727392816843089699454656769141911396678839135235848727229316681941069390642024780171542748255637922022854918760033993710968586074720223630214088649211602114032519767723479347094792538717501386586907984344495988912231703044551071876758677854971788450576635886599900775564701771153163462777589135590249132185730805789045598754662767748313567978567438568723900971984460828591161471563030548874218738918047647263078674169570979611202710872458752522074463742432423744595354217919401e+02)},
                                                                                        {SC_(1.05947570800781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.47057964967248252231166620098113781658646191158671537217794950476766464376688211905662156578593513863165040297072873806429364722113126115761718841905680936283098926911470053640195196526527218515368034033163783510136466037445569865348067661306367025365777355260366857280020526593626915940767362350851006614893489309153646581809145049958378384776781900879014799258412902197094178712661179516840945378026341080851015949108183637856891790502608454874633154649210421029466798941800508041123592391193864637e+167), SC_(3.86668309471944568173873408861675785956750190916661831558743523099932149098629806523288989756114953035470141336019959684812949218557337267651631665600615158996271397540668902113775476540860392860108853985273419143830770029749580455603334250552677535524171319220534100409209112510024597889087808166032884868903601521170566559402919312007576674322088668600236012402348072933729370125454847239009825296717738299684165498340245352212710242840034371086411457472259617137813000304057537478445399704488498025e+02)},
                                                                                        {SC_(1.06391418457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.70253372553870180616568632006838011262008111599288624112221679342026079198720173779667163682688609926140105963022610965054503934880419416222545629271723490635890185015871309235096787227762240948662532331680510789028326905466753803859471535573334773242801683198889129216185936382265840225801389333989729342025191831962960520494997526165478262494935157207218685085223581167474005602834693600612719550255711040569227673243779565592510107034690926824984016810418471339323297415087891987884553051309611794e+168), SC_(3.88736781245899953940754871507990416578546629339707501918767067261604547151163191578885524717075630505524762529790143874069633507144400490235978616476528866086388209735046595453000867923254174967190450967424770807319302177358552810149630796131430929481175954855450418810197954997556927536545749752054152149864042626530175822752029241825831049068593701734017476681900559812610050851961920439652843025993713411192941779830288417577447789660892810097778074201713425542379357723870000890961920731359472053e+02)},
                                                                                        {SC_(1.06903533935546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.30700351289897181314450905054985266289488684324535147146260597763649242079004782619877273438168913943532692353615377684351171321122204064108098010571285355518105232404665880447750758276681478809795964634527929015238334015730735095567847214499189485328582323313544185916079967142912088067287634443222907647626161604553446017786277114953090957290426735983431097623085091413872247113446278833527752761880188686692149421721682834608764942022244622605891794717380016765264738644678048674901409072234496451e+169), SC_(3.91125713989560722178790040938057497009401657262916760720576971411333581458641421159616178119162799252382773272694065770554737953272582538120034885447494838801178651348895761514685750468178877403399909978049083194307117902445860237917261352975524424512326526863242969477672410140371776053823367033985438504290530202855527840453592025869406782714598946028221372940777740084055176888077809785889087862118392485817728132743130196943661570923772169747816074472003406570793358969889066679820010617888748059e+02)},
                                                                                        {SC_(1.08258209228515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.10523563441723981064740219999453918816472405151221426356738600808716133838715299960033690433569133368942619954844287346727777597592291878071099672434078725513928247006865786031356532332235255184614908387965921688554218876519102528055922157730794825502839908312954978533646964247076489581491815711525461012511293783018451464364852741864093985255611963826276485550701285130944198688453437874846595608362202016624464734534199679119447477006060881888640500092737148440161100690107330035937814410794147491e+172), SC_(3.97456899138039707890948570315290488733498513976209565411692258313056522298592145152695582227072825212326333836893020714945122334276123578576097726330488199540062511818312036859542350990047879679407265550936027302443124803145964590805418469726951144986485765622541837619352076240042792150729067920562663214944327090703228239250882201092755142143865892685870733871461597901111448285596377102268529974376493399715131821123420954432137736314556416335446707375069549279793457317288290656669586179599985465e+02)},
                                                                                        {SC_(1.08388183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.54290724282979442706558253940482783650481422003372689166299736333701778003516903631467085844425812079793077081450861842771132198977186551743197361861180089877315441155964532837705687391125274154281502265531452429262571876612425191346931039764014171118854205326273022646394270962898584542088492672505493836667204179076535355815522565984938355503985049327598724861244714407243291752160672007328264253782126273656374903425598076114290525946342701022162520689281713164230473921106508024601591456486075128e+172), SC_(3.98065243678652530679562583928563238573445755920325670751636005098772936721865031618083662090873238650434876181387977561300938564143022242628818771049949796031981885843715917621039814722880110180807880353179423547796765769140998851644554792404933677158601794730016844202445021848938402455820099640791660545892630771071666346567473238325811546810791935690126547720493246166910421170649183272861254531655751957034164881374278460334601212695923927365849230430783670359610897776977879741246916172808908689e+02)},
                                                                                        {SC_(1.08955932617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.07747256194243113885203040297313895556085428852551611711155419564211506922915030780145423949066335564339806351942173279152603844639865708626284369435509418827818163537081641943682876532495274132971730425754987902942973588471091890601320158071135248015690233223958478940459097987698223131485083572666562847234820616407156581422320897862447915301600030652492731470663247160784592141722318665558938527718107662325117911276078258478060384268244801900818744085850967208922319561309747184331498607713479135e+174), SC_(4.00724424259080899275397538109311439592402143854607985548286901285704407355766243132836246175216995560277650826839672358848994227274861071350129887754145398272622904557852220180298232269336737495643739367146692042439940186771597207990128550589751087652655770640311810676854992879707004269436480161814129573600232710135673526371133699418992323131557549743959446123917203316544463415157076253667623706481841406329700061355408235433086573766983539322418292770466535069398951154474788177787251236088223928e+02)},
                                                                                        {SC_(1.10545379638671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.87227475922430528066683457501038039731800377829531631191370060541332189739848568983843566292085906872349548097902062736081335470494263317964978823818253886434354651733415974452242957678323044509043223743842732808498552011499352567002948776936717861071895124245454655823104494275748133952764029853040365521072682198808090947230180891885567723886848126500833318953689991957684640565104686277919805635130003428277463962279583900452292688059066883767252042026961752799826211807342433272535661902642560658e+177), SC_(4.08184715600321276911551202135028705535668959246517460085918517033156794276522217495392415983556663961596454834073539466163115140660260910712924882902401214455183282921081456551903227551122184800224747913430902261405850063460406647718031222060424957718291264904187247019707313522536337186251505805557580890102312193468916919434782659948124963980924145472808365004066553751261152367416034561610490221397823106262088537142605217756024887372578075565606914445109442556506858864414839122870155204990670827e+02)},
                                                                                        {SC_(1.10774017333984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.48596810472108103911498482391077005591672177348146888585874100412414421115200144529572266177869171188289566660493506751163640303725297195005979828119098281650113045979402683887585427807796758162170390373911804746944804512415197933992017332855632322767000863485395892727404856192927711848105515693614975236127664710992118123612438391254504708081904160476013474011504675576221146011859598408566925427571553285299222843745987831201133272612582580336727182010520178742275653301815798644341813060791736667e+177), SC_(4.09259755038503853019497982483630256442577198063393189935621077915044822542092739433619777570961450797852365979698027171593423652063447497296485180127984842816878295603632760179314273261885697476586961945221346066790028349431090187246646455302684385509854393456940868355146420343571892169692424003914360371046893432692541229106214882216832135180069655684513279847700562743318321610726288825126718897540236765739792248697775458869192865519762083790491292602694372954887693326625339263643490793482334838e+02)},
                                                                                        {SC_(1.13550109863281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.65706287284339161473648536938631519339023293105137524829337353668507406650913397434694757238066470452515915675294173592661278967776176659404173138943660488565080044984558460065204526764432108876123996922254835104918583047762860904504550802483953629975101092462727722680540253547476697448410123852667247592575723025426680351302180453534360531204814389542188073742591558289987640506810985842081705354090994604111008304801715084677651387804733695975753476363715879237420498346497275997672732022426979799e+183), SC_(4.22350293347503061210907857753154404089749090555816284618619171028808816639726486694741967621468798003637222773846765986683614652789613176635150938480786422268711789477790093734455461853171295566915024047236178166712259914036169441023401526636005529498366231446006034880000983078476456327322188613649370307361386685150088028871847824392752437056572000056026544203619158103091287763011383227379982322109552391220661259085733791648669952943467336955158379629773254647666577176298639938526736802907171602e+02)},
                                                                                        {SC_(1.13582794189453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.10108526735402953791039146631435277595565662206551241331004276219808208674052659823341551812315094746011518898803597116792210237596426904965313808443513323768162824362993801684712484027959351356509874879083866861136481802056936998618606631917122909886339065825277170238383930682523381383542053429086426528577100238598061074664662171719324239918734496557442508152697613910295792508574304578410047341432410026951738013138207559657356237954009512689081382449079729326306382957245187425063896671331602268e+183), SC_(4.22504824154378805700554761248741137838612335403095564061866846562696448056142283164164983876372066707475090838512513042361061186540149163640088285999423330857650196761700235637105528736165436074717351229838854355019215378585282287195880464623705938056537008553307479838911633227348452874234683972669697126776155473743188764771056778452220553998838745031739070609800144584036111481713682570624111635142010984207622020111453377938775838882778749478995856927714203245407058323183124080698207200648819316e+02)},
                                                                                        {SC_(1.13825653076171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.77941378671180544420926592611394626126082262254572657339771165686948156653641087051493862138255655066000194932072471732158822591803529196848180119329554177268058395376004128960034067499293883118165545257578247062452100968908253253069115952104286596372195806398690862044722282190648245323573975671379228971127013146056881758136620862355912587346738573824034837965312980444762664158326628623341312238448856715435758390079449381673078998750173842552298414729424709689176654902363831333948257583776768019e+183), SC_(4.23653351560151594165888093993712385438773385054935590225652486221893018742900257540062431658397239750958498597461905765829277977173095756335813401723164039140324101052486525141934884704209020119202305835310841513791818420575739308387773213279373033142532298781187226935729515764776913232525906952787293461313689140288721739721215627507636968964154501462538163813352622766607370225330666396825244981311233504032950971781450249876692755944410545529918334138056528165439059929433074876958616761868591807e+02)},
                                                                                        {SC_(1.14133728027343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.20128381223634428197091796398616789003843668299989968556949803261896552701605793178360827741974132313709592972887977386657200538762362643339462317815450734570324415802145047648636478704502346354858408114959842149426042695952544633641388774410223061144535611307529312409957126324762778447558442694304245141103506536627024036565717349803769829164443717149587697156631623215844566617148944231569472472860518187160228166666085439611668440288444443630473655937604179957821087283117161427593928897439949940e+184), SC_(4.25111047259066382143620883930275143995665817329529583698980639042108318083301195918813635238683737679007533880814153961402440296555518428398412220088457992794842540545463712953962607656534582828634465858064962620323309600444499568740650656969574855812201762613515614554999691514297179351160299447307374831534802407922184726217246974594531601638887680998261763534891751530229867605259341683914260163228180884603624927038384491395112235360091306834514813430604092216292868418303964625689842660750630515e+02)},
                                                                                        {SC_(1.14467529296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.04045082832484686610645760220558090416853250826100285492917004659321185791955491919148964014082437989339595003320299344424165419532555701269755569711002137473800445460515985649568538806719901582877620115261947593301192361548423788519072382988981098216887475132191969300597969151487232928775921578843526790468838231802411859180281195261897938414466058376191590065405009015970193360098989276683404067535917028291129928177148037226873370662861577529471516670224930408261557313103931378299928193788821886e+185), SC_(4.26691412981615824154288105659592803753603572241553878232442275497263040983289963012587733051992735262478420570088481183617461288634642827025789213176219751425369327811985669649799788291195032622044705405128386661000384383715807966929792962573104177224099979920925833037813171378376567888039096474303458191177510972411629783089166199836509767373378740300063250542452144019623476599341805708964688793180639261025343058339134833364219384862813076064485266340747011439506311366043277995857458464370333769e+02)},
                                                                                        {SC_(1.14699859619140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.13312555620426978634469842284764916491461832147785714289728903927768857400726157351397438264381982921791859017488027582094078927099048614316743515338014768397045642974722610101439401184170387881494895224693135612934290294439442620044185530024023926782297514189930195290392788122595942308993536110809354520657934235626290498025774148381048574489862472577143836610812926369902808004984385317721744724116864647034723795723574168746366964082097816142051361582792718537689331756674228416478210220813709206e+185), SC_(4.27791946702565627650213115782565286494068066394598357922664668007996492330186613179530827924578785321849504014052092659264394626596036315010545631234732239172956993367997604611240447365849650230167388400446872225976725574862271485612317063690461006283602043150682205419102299886717033451711911162645749086699338979195203863080649811292617625210381547383845646694925084119850569015047764391372783657471277002804567950638827133054286849646825252237510900353964516376040460413449749625321777536043875243e+02)},
                                                                                        {SC_(1.15713134765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.49223116856003146494697381966033823617207296668392641196499793635493336241838893278190357907475413974452678593112619317179726987242261251024962055627141948167075285577628052293851440779664356192572239188393328849786147102590598944098334624116694850876149361211327243825982040457541826200103077881736562910307365829556270400698212192314806280184857209497735011566583055678636826459949372776959286993959413843814198080986168109602960227129669955426350558104792812079619980678343714684681596203796329333e+187), SC_(4.32597279029379451078593933581128081511490431848712683743604931167044650674212475464960395190983992861152310130833947982104077931178608746757099659858416768185195633591587544829826035892370886814261968182096544111610546330820347226310635375866709550410797345342869123549502439902598672800258888282098935849422214095877433979441481096147465685950904792537563677141752949715927180120768645869713001649854730393722803695610051421698543411564805843980646099151893890496122211987074355412172028306410679216e+02)},
                                                                                        {SC_(1.16188751220703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.17004446608904025608956496086628977574244437313516084332425830381370268660733327551254204098763877744436828404040989229648115760372924431294981835591858573086018437745897551811066877142630871603591270037393643754192024624167794865248821435170928199818097473864571292929817439695850567055069753969199615466994134323867646253188303816298694473024975589996825827415809368625547649267047562109751883464453193750244562028761335603498989727176472516538335043961991364219607176094902622059113221775947762645e+188), SC_(4.34855909339158945823349820733929950349328535737884791689763526651127982915961536377556436811553900147283434122632407015715400745873104541398318617580807610012827585359041446025329306346198773919100509217093170344803198183212312808836417504407367313913817722317035668240152089356999677230898067003666913737488729407587241125069849570821175848493118175186198790443922799441668708084943400954084029984215579320457691442750697630580198755156881925172240404256078771322469263426142721875010754671459082354e+02)},
                                                                                        {SC_(1.16570922851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.40887255208281035867750704559793784417499244704236090639115076261045008800969724107997683190847832743574617913246655753127914879904681990364453437162517979351644232747042081332441545262276057551371652404822199613409214559588045052276658580789357800876677593311210082294744849883444811087820486713553890949146749950847472728950517582710277426803043850390694699556629263302186403234708773874470798206961167419791224303617417666633141661501408526909305725836200847602479234229829328153080627125679195420e+189), SC_(4.36672201575523456041454596536294131188781932784084844042490408168204295888706924551771855866027585571339765005757839351190007070373266373376453004038782783894056422405388094024617846764363113495298765208398700982742864644266800600495773664100844143018356916958859846627298641697934002785308101760897033046115657677245398833181741131950133050595525604769040194154654873993658232600817690590371948758209490277164629486699672127013118904784662123805952903357336299953693596564697121878093990337272043475e+02)},
                                                                                        {SC_(1.16584533691406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.70360160259213753789180100158348972704576720287992989634964787772507443062665327685295219962719775184838085418515144183797538993901223193292151724442713503977617739966945381610589216277095340002048061956346000071155984056559048363069690595122453397441014241313190961619336226478558166739503213597425238986149437410678144516877244390390160916975560304961426108112721780487702273801885677095315908468066058764174620472097535602050048249653091958874775509693099506609607290296447933460161394019457708573e+189), SC_(4.36736911089557776411891347841248347848031265364008572962199032596341167038791183474041518273656653293252565066243195097684826414796556738199006582195423116005275947247616796730413120016738573458918854386521477809350946718964091994654562515406880132659358724778258614488447743477560823172627059605516420932550179863787488699611866406676684342910878712865491152162891033389556607746611613386104264195045516611245935760714254172618778132968104526301772141480125426973789401263825536609971087974024055326e+02)},
                                                                                        {SC_(1.16921630859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.33707650511407420339720591544677139847583440499240761893390249300527092433935854581275726205669397537372839551295128273819720900014513423017186178051013750954933650355001940598950197368286391976327871972028969333823756465998975685045529505945773065177909421471456427624857355092428334731555249208809965064364094132158226594839371436170466320839391535741577282604860593672817098980913333012234317236890260810093725541689875452569603975430322374926968660245673621708220632501898593222023384564992994520e+190), SC_(4.38340068460352593041853128398360105928372614479246929107888855049925797094356741419067330097691630494725972056058175798328681520652011827206495283369060314023599806310999055941203768025962206745834689469648285266927418537837329482230448961762068277050481488489872845214734927589532384371671272081923742143052477808992121614798966259211745609582920211818864135428827433532143665942603072688628741001149116323277140268100088017582305707744386004256033001097704730732492079105323552143344930440012918125e+02)},
                                                                                        {SC_(1.17668090820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.16436490634367457798969750472507392026424479360050514672956925393468088356944227288957960978624833220223536496686540033669491596675368077478252374205070592825601621229386491389781842787218977092839609091242493520304764440464559175242982447426045947268234486064089094903055739181013759335711336667434681266881642385184919113676589299554818928170408258560947548717143223754667038751663902597826194264360479949396124241244939250801810083578549044842207396351436607599688535139268430369966864075179747252e+191), SC_(4.41893531702815812414965384203168023987889398681538063026154693658271608682322807825704700384373771517078125781871648317118079847815449248479221733727535587299881523499896203391756400949355697898659418300868115497212917024361805466777459363263913264631478385706799847221495805691577217940431080121283815839824037273676766871422598696398181609697869212484758219752582625354087099818585762706630822257714667416871662058108819315572299699116966753535175777375871105007396235517510639819261601654532267931e+02)},
                                                                                        {SC_(1.17696136474609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.33136148515454582979959568081011908772158617918503111930515858506240629365724820844351135672655371911589620910537818155070307809613339141634247479553220025060180143004127204702599976207613436673974531694360420654656839588132297301151502412839329575987910322087029926071019568592116744571082898431333111905504762084466446729849239392561227292913268011656748018852284681386054172970251316146137013559811816033850454465838166204220706130920291379754492894047646055538723838670387033963929895319035115083e+191), SC_(4.42027133691601559056083311696047274623212981995072618213510081027379340363123911787208441948003265779667819818453619654305566790631607024096745298815674034457696160266076574499804523469503682609205909627495942993957741006720611657299173214061894030777223202304802478730149557775485539259387825988630334751560348958237245258765937982026877868576643953417750759966107069542572413459274494064352879445589426784193075431206977621803993989249432778034910997867087755985377589884143012594270881083251472660e+02)},
                                                                                        {SC_(1.18076934814453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.72865474108149486484131649933421697986107036109869076163957638649793323878283439520907274083593174882530213286554649766086599610548564958475393561154825029636000151810254069838545891177328002608218784675734636331668011385894464531261362321953282270567111851450467493715732844456036654916421903856878879596740523118102004191095518649315568660103864258453270962561375460773293491438638621875417070817219590779057730549958820326485137468696496514038436058982596721528464669693294395717162069725745256981e+192), SC_(4.43841818583339162581867662762709454336726121788332931173651704203372650398720454664477171716866578710861655263311707449625197001412820107802142184875241487388864265356864941579950973863709754182349497752592252541543611466717426169510561909866882015459625465272976349771465429528794301223781309923510600041286382573027526385233354314543935944721705292254115046964467068330460745455746895154715970809904280589133315315700065704348554639443125939821687680355150467743612821134970987973815543512530140762e+02)},
                                                                                        {SC_(1.18472442626953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.77720291504524648648881731322484100687059774555915739315100656823540818898172993635675263351822116719421666243243708127934606690606424157278441104487199775021190355621642350448908747577517834644993210263718823837841735738428835524425698944664829244100612022121795559088758820964331645610795652278410378739312620371379919873738790286343108171703595146089246289228262428437231030391173269829258204101128620174289969565250721188744138165202298567490410461827663163938071487238394441807977777778037365596e+193), SC_(4.45727906714004952352019411516634447921678793175611636458452338500978153784859963484579886393028747524684591865433631006500528549166522805307435775403368427194508889710146046546106944074915606019670019379280979583046743574889070267555995876312413317157042661588567223578199596081826413419005406805024470244494357125294679650565414524294146189417694990115182198251896822853217018815824485438357711253540724070445305826662354765827560513537279465672718974157490136183898221571737838170582599554417024990e+02)},
                                                                                        {SC_(1.19621551513671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.12632460072056672164032175554520318162299060799277652876498432740921295061160079105822462145376124849624622687411579760341465101610303982515304207522762552125894404274918264525264226523957336093426490379004219435451621638943531367592280530906177517166803463541441327839626022737421962372018075207024290175482520455052120192929597813052527550002794190174032632544486930740302340939910993070423587926847233015549678110022226517582237033975197392785613541526775321490051921098223435729241747842941146171e+195), SC_(4.51215256184495322034814640378124737829492800625663972702036194627848702086990975750810503559665459574774331742546372774793559664565158405991032727270850460201746748913582497642099176940338919061791599771394490679379745693031400660666285823647673695113946938961762603198282312107140906011957587528723875098555862871256384168973249715201946941321805116062884989338421373287110592051963072961564395544603178229984614661967869363859781597128577214062280228875210736253758397009188202259833643195489272202e+02)},
                                                                                        {SC_(1.19934783935546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.08077348980552577467799856966874129806077745306757314546694920490194417856677901819475736634867301166901909988147939263955015936935919689267169485903374114723707602998921735669019042728677656713603314725372369403398031451220547520453211776719880376414851795162038306066463287623754670799683004884689855851174370671885606372875464804741979836903994178603002102875553806789997926978261345994295842010408219213896213470634337673891969902678967548285517286858628971297495352901951936750153893953774431428e+196), SC_(4.52712964778115536560754230408068032338466506146945161545262620554748300192994689428291848554819378930240314411464583012351151574447207844853748411074539615824089046068257277315706417665043410755314311935647798326027262205234438658823080124151394620129420221605103927312207324257226542937647783463442091974016434870437350688774760834942488741634052639202981129175045466436484437708603756264783500957174797169707894265058735598260079793491508863643870518850769205134085196507405869611056518147486924823e+02)},
                                                                                        {SC_(1.20542388916015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.47288637649498397463490584839808929107344610045413957416509965616411662620754492287607910583742178882187088654423261931555880460286694447856866599001736048574131286667946604879506648193686097930960676885340696724883366021956564581528420088383402239724521544830822239308580263633238006859445926301426174510863419037725437725663074973111646011479308820277940927132756596393019987806633529537031946064664529736664092175542734795279360535507481102660263101293210183698325646931639087593132760324077862969e+197), SC_(4.55620544640122560656843437269303075065759606287940202607715986535112373369180268980626533887882325748641574439448944963285240352650449345780550030808331175114982871029059334326943641303732970341254153584628471235170271685421005202709751123245502599148992948726707856226830562659670530825796817830667445375018048671910669419687719660351835068592841089533938210488017554586164286630187441895469010537995053529500125516163125122374632192161521107600865323226487233071977031380091577382690495107251966404e+02)},
                                                                                        {SC_(1.21173614501953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.53722657705535336598910755611543251746691532306825212306289845173739595441601211505710512047825341157800665236161940268385049544882426969081454686616468509957211832092624454413299258050304111197225197187190443664627667758746226770246015105661635002229798824365375648042846663413319429415266328578827921576207322954591201540697120246016313190834142152905222425638964983155626433835883759265384755132546340074094818770542401996198591013257396485062740168333429750953823469547333066243677389492493564457e+199), SC_(4.58644413374637360842882413286627596832863499457353684912868817120391985305599507283869864214260994818660446133329828451013576840529769639307245397303177103244908030089963629886178768398852530136778090115640663528597306450749472779155402465819224142729387316405886579895055387969162139785526616166638097094888746274359020949306019745431091550215816611639987551751369387900872058510354599922736312447511389768639756548163994906156467435694696045453497864949553337399079562660304412087378134212260733110e+02)},
                                                                                        {SC_(1.21262542724609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.35432441180218176343831923076856165265118395756366996204625441201239105669269576993661638941379506498174378656574543373382874611165839232650776306884000449853450112297696341788173355032152416931453842827461866840313347597528545828849858021425852678245417948565635534689873746932678010124026651642422953325786760306787737135800797652845269173930743598559869678781520051577027626603211898475806568110368381614142944404399209403983444673817376291361933450954383403082070187806048284861547035093744280182e+199), SC_(4.59070687318157914191312289256104113790017591983647077164852830259422503738220207879411420627809186579434510388947909828016836133662026089031636238529376889590764666508860479892805941188721868324869811209095998124206334784202957565351762618774082417373409488506035230556806557357970542736507765728847754662852921332166714356275159535855081888919895777077090469671053802195518901849564176126196545818556570653046607691804133337133318601405139224802870785218317538354423428299518547257123410617425099304e+02)},
                                                                                        {SC_(1.21494415283203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.15659045645647046879789461950797822357842938573838016664309396293843841980604659172259177724374568231319470748072942100536548136368379171440824838855290513648641361050758454333621494309287273243466778051219672076014031640791247407147219190830952819786954646670566105638659341678686213549597165653636848258020869286818297989326907522574233040943848183902377673509100971107310809753002152971066326373338686451106204131448714521581310850297966338441125873250344288579039624357160299342265673072370548297e+199), SC_(4.60182467180139304860122635340092579968601032403558915020927721877159459605903133537738872391954445998320391991440475148229728954027615453810184757157614020122160516902468729438231341075928619332967049460803204971161325803593284141007002713078428540395863524949658701471206176396484172048956382179728957238338848880618925905859877186803479300174390555670148154246499522320673034317988917032459941542102622995467992685376716310001361008388125079128656241028950167243444796002107206758405710818162522365e+02)},
                                                                                        {SC_(1.22615936279296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.55891707343890861333107528872000125384992069081107343075692250198695335778763764722972116930389768118040284757291345971617866950096348397346497109951267659169682475577409416433777889634622639310763376013335877788979692380859256537584667212808804495473460224553344188816668072382698675833299101831022384552940146020714691250632002644132024347461830447762479310238845499976285814306157714957904442780284713773917878711077207101929047255990870835943667110358440294137462882092311108193751971218457562285e+202), SC_(4.65566180181308601687197214883110710267518162901612389209308337182049787592884988508778265520804774316739377836913985521338311488791870394377733839940584935402195196179079671746821601997600647827253159015330050423400109910092244261447079111113935734112772405809246653266606532893097333263689076071768554831343218620103768759172409660450990819328350346129788218404401533419506904914328984508874434198465948905945973422531515198617482429364905131139829112167523142136913416600664190619507696242221207844e+02)},
                                                                                        {SC_(1.22619323730468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.58449866440180470070191255291350578276430677120008207396604062633952008424517277064268593796831554301512058536322739058255100951061978536288233652914992687980604849466144619188110648281137162102693237773617084748273740092723387623184680690864908739570319524168152761116810062579619604455411809368453388103958420528285875094359460227675579527718338309980408778644406238202194855287733337804770744976939840357419181751496785514223664953084095349641874496362779033280232517588654095915909796647334946538e+202), SC_(4.65582456842031103982765657592733768436482389802303278459170748014779783413746382141872146073444244659037135875051706529023323727096233443454744148765273214127870255401474510571009246531321472548515566713289733557524897722853217818640869277820642987578998266188799347645977999776519628085762656691335248444257233855005328228172874274722463851122172075368501924792150509246112576538951884713556830171505250189733995837713742274803980588397937960976209690666059177038355125038075881849154482068166278949e+02)},
                                                                                        {SC_(1.23799957275390625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.63544640277139549137310217513566911082050773760629450920347694631060367127408233147593401766455841201118446415408325154981230715715455491324204261136261388172357523685001500794964663415016270284775184993907652766125760462281193288661163961171640181277213188681876991560803305358808116180156366567258747830621553185324244095962080075838713097874670376549945099108644580190029004807825399023241743390345060602994050322667462629590994560048444053441040307609763036694175761903442048956889503549495771475e+204), SC_(4.71261091476443044174009031550121164087922587248538936531553670128723998271795627945494627931712563525489483471271490199751464148211247080290612401958890319692956635892067105806772287886971447093677261959379313382459502418691195246517599651939336449072101970360321393345997029507482162837462872933987224296207970512090035167652338412089600998866394410347174794312023591105235384454850107047396137050711372465161615320162198503385589320814580402754630303852772582439987536871840249997710619967447849769e+02)},
                                                                                        {SC_(1.25180114746093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.59164584120759822433729640121908362404382528667366168016211012136262493573796416468934454080722442819592729366199883974592653373814997482285151144183211503181149877896916490249979823147443770241205010083434953609838501059082637860084473488684268662196558549799390015357307833087293487106176398922367044193563778471532663491949066257470709103655086794550502277091853533121528333512273743787909493277348483131594566628676120177624493344214015792039239212666312752007868221875289142232496944883926770983e+207), SC_(4.77913724798800681955430578838170972776147677957335440613483895134458910977979271071998858025956271863451521004480877448444705502394603193543304233173262957178632707280054290322433982514447252840302799604750092243542587286126008195237116029804390008945422461841858714922171644469713848101479824758205483289065080762811556114339695355323157367827915066956513303499241227723078831912676134488999078147639237638181261071999491859319941691836054037447435054688905309468026211939592743544705891962656359890e+02)},
                                                                                        {SC_(1.26056976318359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.47944530448670733794842725159133200821775724242209804922675101264218937133297706754867035444908415693516495267595479792500076322036290057140288518643332783148976313998913201844454266658989159411866622584736805756712772527559512449155625283947557356273137882027305711821105315135660313249431474176183751563787419519341798335634374293968251313382364567201428796735363138379588083817115727239764608230881909271719091638818665238673924844519813045932365983949672602461525090884892917696449113427473432611e+209), SC_(4.82148319303369440301086271858092673802618004483239323480692149410434318394191573757344985828781863681651431261736606862501484815698253191362354120841363869041301488984529555616556948242927585724138368323892636782807303984172331318566293299177190965274838781586071345777819043224174873310548927132848686539982081541439382896169634019565835649734472184794447451074315439663907936970503807173589207462375241228602526217220948754246787406212838192192080655949898449917589909210977252841445312992054564017e+02)},
                                                                                        {SC_(1.26528381347656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.42182663319913496237126334093835825748694886131424002980650014347744295664965549494446481361598225682990330744946648677685520636990135864919476466055236702155334977475359346896462063239402055686737503877208584652625271796936117224137072133094323273608436610195282253939569361186031744098676026263896910237380735503288821386135118854355488827227941496303649637517454456250708426963234851364505960880285882115055099626845148663492195515897643185551754721052128339042608975235122678944659017286496904648e+210), SC_(4.84427391591301650052381022200108849023216628100423803087799853789983959173696199457369094464401636461657272106469921042963581927578733185196179968915269871290038406151649057065311629432268779618446872958199782490908653105319829512103019653489005006190674262042213969375938486355012220489341342510995564500736624365326611243292379195043284007699636871863629074439671812757434360843610488818401522375571442927353714337151485631022366803160047666556979339491290026656136306875038147348360050502176202422e+02)},
                                                                                        {SC_(1.26626281738281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.88862751617505851662619430168993877955565535588536451326356637770034582102421377462236676184908641703483865628055534914138322841803124912110919782553953667775847732352875682462046577536819224779680333308106095240747838269420296233544831460693531183439436736036087423110649963930611949368753098090117161978908560789271073011777487156058298740462440037996088447500657381730154283922695105844777388900104753928353262900550298794492094099799678328596848951263361298417073922920854984503396179548222543585e+210), SC_(4.84900925800517672664483042191143848726171016934065470589319654686496076573905490053994333767886359716240323248830372926283174229250940872975446642437440897096206643110454391026039459587744414572034553130902512860727364002056544507182565004256836206869711152601033474950214308009016121030357246527302131401609263486366587179672052658852113611361502754374513090629260124033425429279447872908660946050193375032680068311406152851252925764663112571081859290354963944257147508729494158019907160352804666125e+02)},
                                                                                        {SC_(1.26949523925781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.85799885745998920983430388775490153127925068873532729669169390918617254746915773463320302282739929494601768464003339167247200641328771725088224797614495744050986505072566022621054416322390914801017366050732480683872837438676396055645169732638593856886846981379591598656894739776614514376900990647800507136987971616732989428416199491647911369262925451227656600583757885470261069111532104994288570336088843258755614269718676778177306165450320965497187597215455165997680296244645872016039685454310101952e+211), SC_(4.86464954647205058932700040335704058990587792445438024904196931470213636195389835233501319979826785327943021837296462912390219851476240131715149969896721901709510374365704507847553672845446422867959018705672481025755092005636269531960624664652432950455618523240891670464839373917635419942739122271834834924041749709718190210192003788420149690752796304096785976223784765116091025926398315502702005847182470739762772788908019519409517116141829756065254842122228844599700547916445634875394905531678596620e+02)},
                                                                                        {SC_(1.27250030517578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.95867387692108285179759791034988666848597887114044088866820859997283869387295514402198804184526431310068686660892500949388956183563166078615891548045187842895926680712128022081015852290913773464495476378852524420987500146395106345745045475155014107754152994521610288846662130574437281981938171901343100109693670867998703435000886741585872179739002921326486635158897103002665484547764176300773045064483556955889408865935686707701790080584648015276776444261866776987067679190914221646479689390537878078e+211), SC_(4.87919717009344131514631289579241154775821488134363277172297134078336073472950412943474019517221019752833987994775391483035469035515957773608825266476207689928976238170180329913439429207552604863895925712737510217595966475355941728504981837187112347523484432981760617659246407461153791516262864269255521106517629930470586062091530539793980986796861848687684093248450187925495436801626253667290891726247757586551327927898827284033405955483379928728052724066771109747194932351277083766072025197131496533e+02)},
                                                                                        {SC_(1.29062194824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.21590360545550004800273328037111759735823539832501501238942066897011899542988253023772482607570048592073969960105247521194785283035579854537779773548296379315267988533237821307089515058672624892673123328290349821346743603749158035761635826782970509488437368459451106153525850871416146912122735487361690533036361909315075565397530552385016488129812930051233200858550863716538886393933272639841709630461564028484065373426802698523392243504736548141458108188126865314438400525162559955957719668783144295e+215), SC_(4.96707507337624230835834582593585099424292829056671491295715545791576712585483386980998849050758102873179382833261429221300624185796786643099268596081224644718649242360750271883099760637988191962094328437016890001127425992362342595015239645206408019289479399322533043610452336515295295372963558098454188185248371949296115543044058358763000583734120104467379609850823760791330220841372016697126011472003915244721536043248287088048686085570184152114208170082711831868667736655604873979138846244857555504e+02)},
                                                                                        {SC_(1.29424133300781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.02635767918607903950666819307682499880944197343260958935080874290175957238114807519205991749378714397245455234462488828189263998761591993374250731656398850403654998342002293021283861294300231498797581907209374665981666986913633321341249973849869957542618774974494400113058322106941110881813291254335466566510306827542788588927974700711757307682138211208910182197058437214618351934024970425963238905879640101814733814925404186995847697463910867546097073029931711592903529105940185039158291317208553695e+216), SC_(4.98465739897072943691074716844816005455804262525363218872826392795772484833822830748945444630946018097946539821268771767792779770797404573656853521184140322276370394751712473314374988767734720967763623587742850797176065743114329696060255957832009138469998584629988890137927939070061921054478030517395210480900363472040704944129357146227657528620536829990523249863698565753597657087229610766086571583276695990881406923809046105229072143139278550641783755595716827060026398988355154407299754484782186800e+02)},
                                                                                        {SC_(1.30573669433593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.11047037112930704613427017755396345874582320279600548545911791156721430660763403861749777389079710057296525391370371745105912549823698755130456815162941916362515793313915165615809709989181259005687120825883272205574689531515756961468600954601723111884113118157764587818186921702290723851808779851977542885044517298186399535323045511040607831764522190868433521573940090638053610732273845854119620294238719238345314171753103940175114885965667184883405140793980515608522435245655397470874175799832355807e+218), SC_(5.04056706138053612227836930773511019745903578081769948489042969445572696905529437229195116592588294463340493654733509712278887972981390782991171166170630641712428688205252527708212949364619634081469924129701596201684932939230739957616882108608304370977642911193102652520219566934599078289847473327558502484550272204555309698138067742627419911106375792189070578053438859727418663988163096021313840652515690583408085348753420825363568538804095479531437589259166639111370167223851459391164324546850328466e+02)},
                                                                                        {SC_(1.30709594726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.57198657473474022361078506195683658976042521298148785406897748857331396634152320328053708095932878868850533117608441519872697482457770382738686874629509079054132087268861517725301960152147300248185854688387424228680961066115514445921170527683726157520838569878477926984709891047082110734796837300766043108427983705112962391598568733135510506107054537900306279418705793740509183901597123501585659962324908263296924279890499500285778556771339753879450690940168946993548531857563915771234202837847081901e+219), SC_(5.04718475519421475308021587903598678827185913061229094073537460481591284692845558765667474673048643744759631465391904335287247101873423929736288890690196047120156062961523815762863551801694694310952078650695378167643471825358756323245862588723828845543910649902448106580483748881080017768254156526727494087330413974462259669018702862098649925680097892943790873992309997891961337675649350233071867566329550971552983101718088589057110957989487091892082611974507156291049908237359197522900089005839019441e+02)},
                                                                                        {SC_(1.30757568359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.98563686705140334136632420794426063419420819635804629691052815342827217474339676322757056107207821055631757016119174791433473323461048935533766001308854797203996184185053061166415162970932624000354196417460847036009606078854375413399147819888558836693415442600056842328952139079661870627878851376683543858361948322311963261616184567635027401932771810155778205621899995613606606027668494150616534496416237206153201761761040527591641945154832290213681862915035222586103839425746298119088508843620302502e+219), SC_(5.04952075068201452877049402384085667382039712175851309712054733696966375348883144866797666228028441956440415208433075850847372002223974621757009454129945034879526159871514410915165309930581213628753781515588339209486892809780812242425478944786501421965168807767801454281400629080690695002606343716236172309756290935605128043867730565378035993871825892925356453618194750102168085639208980352844768548493214808494473737323824092555994291894318005736307117437416184900158723053880736848642925975684657313e+02)},
                                                                                        {SC_(1.30835266113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.89884779338659572340667722627856777950879031841712716039944733865740080403723127724238455822688446890092898714808084039052086275943289859165528633865210355151827064006313537544100159003115195159988934635051028734240337971394218034429756626314745504466543096666716942769105496284698929192456748358076397742633138863541903000820511146383060249820242564286483301649786212731196689928975791326633683177093822391303994311405487828595741176720301420042264863778307503705534200433933511243281215414252329809e+219), SC_(5.05330448711113547740084085728643393088729057540142359716861526592153900166623616172771839263187289188475213653963382206206780656792607292391915440634805523140306540791995474412903174717913885487108082640648389957957627267579671929059416203047208781406829815504908537090233510445576281627930667285757767870170733774400733629969662813491740398249812314185189751521967234574281785209394751043973315949093403987343092713999935938686179092919598408170887392212493275912766983779341242209651461394332425019e+02)},
                                                                                        {SC_(1.31600036621093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.20430297073324444437220821750693753464613246950635491860869524757996034204318778211038386463755184564532939798221167016228509891432529361310635867471398173227367796445371474893031468325983962612610083622234476617695393089714843405448851735353769152837451722948166372435965195916922392652779024473274058020281308553443569989036574389784227263322141079701444013212972193344569946443291355397983426399775757361741547454542158519531653967093517404865222607047227338674158623715647518511691498640412293904e+221), SC_(5.09057206503737122364979164051658316850633623031344072914243731310808350391269043112269701381715236707083042095898779601737200121748253088388122013559603714273813355308810812702883502878053310086795630782520444428271130378445215951339280458638002178123797543483134850833815286322251157103777905455496112357784075324808828808840502260423427623967588990828312971943416360309107231070254504658347786028595677275135150700040966302169892714539505413325343491586338857506633444582388135424475614550206040523e+02)},
                                                                                        {SC_(1.31623291015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.34890153554071906149529006475856843643751489002724557180732809872453487567537580013324845735182681364623819603263290560087424642868366952110053204940750673788040254626990523613160924817804239450455915579901953536902789993286423849735969007117782833444492048897066029577542365441137392306949851570478561227799976033254349445806030147073802728868463768528161767069029113992137784684805014331876027002586606955320060364032209948400145502171437322646568432969224281296125331077633162606235130134587377001e+221), SC_(5.09170596135542071635485907939507005816072655383249004647616859331032889824319132710022885781603007135074720366638005731562930984297217884937926718300870954121095461479959619581243107681841414976524250071299102867834392463171886408570759649746718487447920429310226437182653719834942024506857917378738160034880710110849878165330711698800626112257295745469776597348834001244276042481582814210467327983299164470090152686293651312160064867436343391488754391020479490075778582314493149770434063452256141068e+02)},
                                                                                        {SC_(1.31660949707031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.62080843680019919873850576732273949718248132887610477835752418351373087232255107303429222446767091920867247462884237784576167702378756866685787235723582082194312231685225050220076259431742496269643395666931926989161361245494650469473168200197681613501338828792960004222484214787748680532017999512808760847668203053412185342595402398335751175395526956679304124366562325500718958908066131857708220793387119393581003308929833214831141006329804253792611565281261549823997147097470972678670570753197264921e+221), SC_(5.09354230611513654152529095312610350686660505355384267208484258596926205528732725328825476978975925986320768895807545158809407801219620739849964863592926642717506315967375728028495669860452401275586479241959878160888708620723000916642297309981107745103582534014810105303665195808031508715399216703921652668968868711979325649694202907967900674700074630676585663286896449600740805134040374062365773045491320099146046085609996671401887335881930277977646522083923031915640684425327783098948145569090266835e+02)},
                                                                                        {SC_(1.32367004394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.07974731828554602243598676167524954829604432333249686199200513337750808529123357340982668996969696862888447969719988108175036091908061220618035384938734121256991082466576516387811186986231912523022170688565161099100085850104388725471729075526067491977465916622057303317019411406913265546871133783089297807452484318205531517424877673760203009558823102427187524205890103762796000616913276792686635297763247418931989301460494127323302450925275282375748876100888627116605943075436310393738440647082870976e+222), SC_(5.12799152164536461677625508098828962831750569823734125016345352967428738820658510933926540604886371746216477089640439301522969304604479689124091633260606915614563143949634893714138251907868602359172153932413248182308174356343968882434211883450893172968119039149877442419849286186341796732351571516582537288352338118048183842085010326204779953835882065024477537412670008102631597632482607256740792941129696039209781548558122538256573827278333046224430889866265352039675318823746384170099150914814896127e+02)},
                                                                                        {SC_(1.32803466796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.28070823491571021525239010673229927401137947201366072881652104355715653758563674368037423427825943179632334768820206990671067682112131868828127813760869517245688619623730353791106389098468093493314257541923738404710042820138015545902708203321078405936598569492447767787524108995822184403855483715577641469263403120941922738628425789926464726143448815667666101785768205827774691372221061087963997751796163326855898297808570953176902345206734136236011898491952894937956307253754479421600833336085761764e+223), SC_(5.14930594209023937095252118022912016782660949860856616535319047187025547160832057314457620561305811068004437607306774351795320211730551561202646716443789266629935182231469766334508684080596627066111062924159810854422801600568899593348352290940161554513014104643039559656004795089721242595064414092021121612389698714881600790477067081696100422845333141984137261163653252618760353608323659593957387383454525558195514189040087115895303172455491261027290336633915147987831744448660710264647965445876368458e+02)},
                                                                                        {SC_(1.33675842285156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.04487592056823951749370118133346032782665582332320336770393703280563240947568243037471203707679509318737959335708187651456879316231500557939253820253928459853161274686018563956401269481831555723011013866139819838885243914185192310402785776841977135186839219448331005504911009488722399614370734935701947013822011755227568394117465381976156353147368926632238096446199449983178419653533485890194760272906098477670188283919492256089163777064921090111092199141029427173806536853519859936160629847302923680e+225), SC_(5.19195106075410034290860984504733637153218280246717993248425635237416403493495318589567907863597845130750552805426305743614661189702147283741813335142860258509308269781662847293834728595455208727081878775197451813729921978144441269605318592415485793856003553608714984355030531049414976690328771919030328500222259845443398300762464777894624528249791401507146478046353231433105665917182756627015352926874667121048774520118948393190128289917395422974633167351915837084164576054561860970867812507528309584e+02)},
                                                                                        {SC_(1.34035095214843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.76598204812591379793876223679444078853262430851184176754539163761576104963595030733709073046314624652632727924691401224493533106391708005900869581172982911504735447581738915772003080675668641109785459887130595297204140319103083013549864159762889924606591210223813780057786834462548165187477631205841284653024565678833477403213080316183580107319508037372389034956734737668256753103880241932563617233055230365176675939449771718150718882027105331966170334767838958844427133106900834468556463786935275971e+226), SC_(5.20952937953510311612700996652581835187129670670525219305843861214251304631520267187932335943317776423702990089389840495886950810255579571748485262032805903168965775875734411670750100550222166133984562540778446631872610909260428625472595414222131722611295118606849796262580383861869373865597195159398022742273526431038380628536123929447576022776638903828231378868581144585096060415344645824863351043374712194542900191117931870136066149529632894584675792095636941183422988361538418622753330375645025189e+02)},
                                                                                        {SC_(1.34275268554687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.72257672426884828691799342524423336714621224328121292332405965713113755032186113138530826219867084086181998285740109655389231920400434217980485240762630362516318515206518608895731337543107667246119736500229194697367417769844278581944659860231356492841519374601754707893016975392475518372240771501381577105305041110485323518528774133871865878090055354523988957242238120540653181509338618549137646650793927327789520566641048772697724056450200705092957427006372334621884940334830557330923184989481075378e+226), SC_(5.22128650196882834780259459282760755407083189900754238934391243922566314403107319212937612503047297572240803299424682178101658988970210123124514168813678117747463815253795630968329750494814497716950751389773842284204492352152745197845477388159371449629926682349918291639471700629500236026075236784401238525544228303087377826813849169893932846792228697576558732868556129223397927663038113673265617059961650735929834996007973766584756833331457422233891977712090671035632865121644430763840525098300531833e+02)},
                                                                                        {SC_(1.34866821289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.03758299144100638981185218421401545048858039481957536450374612380269573236280572413492140072301886580231441585024300960761900033108759439986269361149796275039952562150755856406175298652045027556273869273220383518259909901841567808793911274758689689579058306553540568423349241996463204841712225101660223073490905528769727834336511067903286578939532730136204162010869784842499894531704016034480810009720858585593094766121276753436879212423686669486395049415023005120719348180697872547142370502198539619e+228), SC_(5.25026295164316330412148519325657366368341934191738216538835689753718118244637948844029887933590653824478536507726517366715517280707475985040666990300124488759842843675068931885421203762075092808398239500818732566913870839631327080470586159287657640540603782621329907430937887513962909954497139740333551395157204757935707524326186810806941798522726686104974995691572341090784797510421803675247476639268699340282910305104132171213490831314692011881124391726077917804990741090076632485651333706549098088e+02)},
                                                                                        {SC_(1.35162475585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.41980376428646991328403638285001046532541402055318879407523787526196609548782003540736420797312273330747025453433773859568195648080910544797809650823656307940556997217802095934416528012621274676805389838875861717386566374813306011804631755376966636171961046158493908287295098146052007262454837398730973136787757242605461232162225787818324467484620214344455285701914485871832461801535652548797585119173068598820943528138136172443348282911091890227275919280750941144920643114850046197721529498834275680e+228), SC_(5.26475496500526181283223415222931159541474564997542783891234224056488099012061586465358246437404585773392755455671466230019611455028822473946472827901176638302255322883082468946520452433719767478326435979014169829059166262878725946001872060728634606060222396400999645731037033449384300160210919895137357153527340054334814098905421275806946610206047604319348201515764380435364861087257454422699435684669676461222307408958852208149679997649800199413405241735896662373831864075082814473750897919380010591e+02)},
                                                                                        {SC_(1.35277099609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.75330901893496143614480518805021597187220753373090306683623319348243653926755583883821809078252803526660189342177950736963693693418130116521832649223825838146312095865813036730649544678390516412698226308770476471718791195617123322190470103338445472465117667875244772983987288984220754698497563195323971592519002190858693387971198535601156597113239528895027697549041116230589151999239027691989777808200402329520469187931248454991509338333394196096004148435650634439170607672125930211460818875344878619e+228), SC_(5.27037520925066996144123543728795736277209313561233520628514718710667129879712146192231770243356551669952438664771719040493082214047541521130988719545217800317264354623413167385592555762706322082258567717316963570751158300472206989689724105850881671486491348521277463794950583844259767119222102026760477265962584199147543111581892773291923102470529963899022859734152285804769121827324961441111535590535592189163462395036379792298521953571645039332350187185266596748506639369174410682033255965417378528e+02)},
                                                                                        {SC_(1.36809814453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.43665838167351047881636027667694075448999427774273904740299820753970460953894100809479985551588964957306960928805136469924980953880819810833590058279407962197780122638840505416894074609086563129092943564808390488159277136949221096029113036812220956185572407900765503236591662061061916852854842477810045932391848299911950430896675257899862204466940846948382906025354509618691220425907982492301908575380438135427647444247259871750976886865939605259140731189234797205329218519883224564238500581024595703e+232), SC_(5.34562061423232935236510877152296042596078022530607434214664258529691271359977729440850302313542229637342234080210374018623104298122316086647596436295244701395423805145032376676811315322200754593884339580356984239803557355854450272173588624647335756403674507959004051793289238402811538245865888546753458609705052143578748768671177989989096831031565535509057569105543849401773063950233686232012830592153145958757653871091668532173992683886080217342604942002650012032334072330469444777330514617803964186e+02)},
                                                                                        {SC_(1.37396728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.57445931970806583250984507048609472939434344132943111073255083654200899492261863816284964557987973186677399599108698857436440141682472324790876275332614073610885728701014285680660939997127797911824164931280689027600115789770298691618495447837633152318797839464470979545365963361974475998077738567098254810060480017073333408534359527573993333096615594630471279868218917060537792368347184506660224588475026107066059758346687104911799550344066179802636485276455238679107330199981626929311674463083068206e+233), SC_(5.37447966206752035642162949220887667913494247099321037099782266542594292623021717676050787529532715116178887368049118780665173468283257864146805822002244854592284046168039802892090231212639806654404359978154257147248849470858213112883265001894460743735137952859232620515109968476658295957583503989037489853223771096565961197376699581731125653687887089436425254682248503815299994549638506042855321848386908912955900927145521952700624216313900629597683786355911331563926812426498370453980352772244091287e+02)},
                                                                                        {SC_(1.37549072265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.44739806870853855798698202490950606864695117593043550715097510559295232548813664988316665395531619594176287444749444108798452533131857204642671369527004246152238118820312371656837122966212882675668465946859327741171545570202801585675147673421402231485756658720064030527113574783158036247842455280672211892472301354629451152297962450562231788102097454624845758954245145508782659373286589906093172497711014545585098517359319508684005342264391315711745957599603265739304655736626747812329821100113006264e+233), SC_(5.38197464743701669466920822675248386254972181676740047863698971663268651974554470534078078447169258855611630804254247428232364918849597567871875964441111795503383831166191423768561559012434898026793764689292504509729337326575781027128117943992819289247698978928126382933073763904592714881014934910219688679028640141885433509627429372941863297642735889821423251401065908010409591241126459309471086907469438253362943015748884249078474441075907869239597940269825794172317057667757399080180481679248899443e+02)},
                                                                                        {SC_(1.37654602050781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.15610850324474368845825869389237559430406874889279829247883587116534495511797873234893805057999315374032893893325802128264373371567625275567338160151235408720587666700266970202844234236259658223533617213882520561768822825151625138229456384983799105486798915709188654367736214901018871450295995512195617083052005584391228662521793810570017633499857746817609313185426721124641493532532740745789683793723837348322202913340405861516351346814135006965059436198684684966069535318213110411909594630632509634e+233), SC_(5.38716747920140037545182738110377392481973607055341550468766460051014501227627619520670697473888082164744968378691388295036889329356043727813740600303617277934445692121712859838392338379682839092199608515884007571902595422688150659151926573365190816934832987925104354270846739169599050068020636673931660890078580947461574828742683524190435130009285480503000814762955133740311881081153877562610742025345655822398732234042548089087632632537478252641951318926836481942421041203574565831352909552782796367e+02)},
                                                                                        {SC_(1.38742248535156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.94137449285935962923897980881150109167214923436042568057576296930025026633674343917193272859437621196571434178851106361353872539709513063363868747070231790985400509048821056978318710066219644155909699640440830454779830661654766985217725952369183140008441143482827248282311253610020569721896629147790967524890801433810696756626692060910581735656031175688825814405709168176964891456674090351340369813384160376834612425220281506935093571689423172270508239929846781879339155506616628136292925588862609393e+236), SC_(5.44073478170275232544960623750237247802973930421719133513177896493502205239891881569953226928075093059226104060234550276544509721821864387663106084487147418544635302635683849165411433837537721948876332331637692495343785248459016956878988671785418434318670591872540493208251638789808096916956075163558173926897176055610905089961134607376039552934917930006620734130726038566598550633358290330365783195782213973448681712438587824991594267676148213376734117184065384402562995236742493686501297157101274039e+02)},
                                                                                        {SC_(1.40817138671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.45047783862578016771187352316626250639104856503213692940797510094367811683719859371837611948876052889226978388589671660277053201379812838972368868385689068845270488840863386270822552954623006676716684460977619901273200826351757795518310791697371917769666310875915754336145843903156930139978073188934850126108047782541958567841244346147682484158518251765192667106466135047505965766946639676562432318269581456593507844356926543037322049512536555538390905621026319426551197602354083076580019817187774130e+240), SC_(5.54316125600214799588419962417945394332523267556118090767620331268725402488585878663785109565964379443484283988603046143449079496173647142856427776395165218911751915669336253101281121875785693175978516640099613017768900115795539500296330299124520856269777844541770601480926945988230544167248478263819595774845641516075781269952172308738133777384625547194894635615323561692637434420220048823156913290124747030955807793670736745671154828320011088152941136766376276172566953679137781943222876723814726228e+02)},
                                                                                        {SC_(1.41276977539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.29769358197437978289305486828405415593744927224137533421831744096268714482072595019488151878713466297195803067325683594867278144259117267669216271022979525455634885071497709052317371327844232599879493249027819117690288351866923957864254062116454398782338873217268971517767278611167863097447738261861974672168330424639605623446447709583953653269238481720372824627698880292174467910038590456941626401333325664483155084954331720654078806281686076427405275619986065880807363339124300916663793340207234637e+241), SC_(5.56590278964195363055269190813350557132353108454816850370504212598847703736686463269019180345382347527146231458086393692201520736331668808189290877706107323025923572215186361662566575032119908704324689096914199614735075665671862846093075373454056027879605986530987528638208952705784056489726487166045924339232284200052452678800617599413718428834646504150666420322421857852133816613033713612096579105911460653813008349255145140537231944689083118545750975574875846546891821496575472134896542283953354856e+02)},
                                                                                        {SC_(1.41587036132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.45700475084273847824800128949600201193728211676650893383703940376296196707616775460963979387665332250851408505353543405797770371522415314044559061860640290889595020145800442452717688191084580220776684619492249010351273719817504537899153816768661850312452730900022703765789368194538916913263249469249440220255347495396821077127844614725067890479740494432586424591673258511434380055449528918178700376492848806540555098630848479504780748525545422396164312336546370069797912169798077768305656038801516115e+242), SC_(5.58124535531691156358956295727901729015506539956060851209731442013027776110960844689352660619743478047064893828864590892880111411039248744313506509692547593260858956437839183313439859676036277217218579692338253620069842885145918557087647449565059328129795916431330764520212869086559988310558135602601545039694988694691631307700471319706533106459300011127849105994462310176911769253362342042988699831723659352410467715100722497117014805512706273364667515126632483543862981978943369630354581749601486703e+02)},
                                                                                        {SC_(1.41904479980468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.18277659724864023573058199938725005016703241663239935115555242418220171212135112646305947850063102485913655275051836486796200773434429814327002908164764694313054284416932532967316622256652252154918013084591713511558403037848638293814933171582343066678380244082149243054022052803338986675813327622484944489910631057012470427768696858123413430849751475434908731434292467868829860069291608743431929459951034297456950375548090246519738247005570808538267041289349701357231648624558698147475570190605941087e+243), SC_(5.59696042320462978439568756111200475663886377134996576357804457203011096684033312838694859863093553024713705778263178569957006593076761661734563525640132532452211577248177154109646786029086660157725508435204792532722710493791132947690964846647255357603782995381910697774475267480990322814922974293568357886774487856811576818597888244529153401179186252672809621345169721605047079863312166353473034902596376985804904442412811868887448608869454025892661586972785767049716839190669050496289708916166669722e+02)},
                                                                                        {SC_(1.41986633300781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.77656396584746773810737763234272186871275885715203351598530417029865248456108801632671238261817957872613456664507949730737630096134874716558337873020333155609917315392199618322278544157455920095366877241879319536413766792151195033497448838611154021880038869795134840079316970040445597134438351706274525046579007549954716008807737920162573001114168187522750910778425694618872313532377610727503249367402529561172729262904340554323137798863284651190187993266313683732031181549860389058468449515394336613e+243), SC_(5.60102858740052815335507252670728605456101064276882282423270628984738677282705266640353715153201846731931501529985375769984154197255945559179553921682570616652499539841726163456472036272006298078657865914422591324537250171736845540199057243018923351822710363405301840808518096772177326287216662701012976439963333566171534662702503881528405544410730999299958281750588785448427750777596333548634424573673251670956704985134981663192922835689964182975431954866582558727959277487365673323689895389978372552e+02)},
                                                                                        {SC_(1.42427612304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.57870043752239386839726679404420067362103046088107575850638678988832376786939927292949624462590888949034872897552392220471385047650198209385052357152717232361402013151131838254506042599922557021522203836604724366828171398195496260361039842947797321531848898456595509460711058701689033764906979506725961522004603520277924536319487480724263618108020449629489335578962994168936435425940559140677298813409365233961281566701722666960021003137255319724257654134449567368560764349753299806583694895082629591e+244), SC_(5.62287364691243587470418516824702690291803865057369160930517009096543310613885900814270521761820188040079087463496297314973424544697940898240000952686179694874232131262568909826911809714242604935869115516738410465045064829606438287978265035705635104011092898510011508515128175847321762480377743984218712844183082888685354633353033343702368814462795225840254844117082976217461960252923189139447784927849067102167408838543749435085358111309984233582312292772333532391378218839869756553026707212646753024e+02)},
                                                                                        {SC_(1.42991394042968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.58274727945389219384319561854077301522517933430308853974913721288742414638038643710961668011192950919073982455017959454314982046716644999867729476203086917034953232635323996803108863433145158622027740562634056691346529093065748054619201394049768310190120219008587950787612591530405299265360972075564144649730028390439634124490453657094040064774134115734099148027010660153989223513543358084719105524162221506603189279159826755642066698395026788491560522275176546664549031330030827489366792944209215865e+245), SC_(5.65082201452935579386055464673827161043102786912112989828216405327102864980935234010101817675401404810570397749095343902510171623073877304308522566803776644624933433708936493772646755866787686022780705666226923753962424323139011124440467120038633133573520308696615076067682770635159098067002111585312510570323114742145171374950209137328806719638500202143174441193691577014288589245547536497236184245555194037361207570833946398919633703684652413081144011374359706061953325163751597166544102049853137294e+02)},
                                                                                        {SC_(1.45612670898437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.16995178190660470435013968675654057356100423526443047915030442290477885930184525474088450947700707439590535065674535106824773220009688537124707117771163514576605288123717067178670320340096436709623760290967152973913655611581905741163004105168615813991373436869440699128068453152449208988794551675140202420862219385425129905917305100554048419060569258957398702547464611372151334417605606083406430554977895372524524122522697297127705608486291636342174641790417051207283201854369808936799623920129087652e+251), SC_(5.78105820877420254749018375118334573088180310531321871850936637497417432028678014727547139459642045723422376250837241723845231522704894837309175381694580815979227625387064870197782835254715872148088476346944444050912188945000544307533987758164909942296309047775799958061128283376784026199068715674052158710042201798342707251799089380226965044256880845033520435804086815865400254156724737804125780474293752006393862736836350364888814107081013595530656940208743443043610026304270263460379054106949356957e+02)},
                                                                                        {SC_(1.46037475585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.69930605328247784982117215220054678491661056184636042881894505549034812297590622214457938484959346899003559534563845448573036077005798131699075726666607922394799460051240397075879646761566384034086433198905900908454792647076810658122571127376004507690505928563489776258892148234324694693825237765781497223919271315876177476972843059879606582513749639326798714947885640953493053562372224253994285795790891703503002691869858697528467125048354756867826942396363160571134501900605040701724274511833528359e+251), SC_(5.80220912683556918050796809047612356322971511901138834716315060163991718224752307714005300946768648550179251688727047278024879768584854435765331125546818016132028274118768640446647255958617632633138022820716514764039994897626842474300875086256234584506012124722044989463928198934591444333537172423799209759309634771723494530188279308103341596078070178667937026021872013012533565450344166010882477577545424971058180456400883811447349766507230520901879827691207081331498132925503598987639691357581146707e+02)},
                                                                                        {SC_(1.46270629882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.09833808080703326931235501974647441569671295832319519721588610852023346320413283437815113835289088084247445634520575187616176896703878358661268752066563599963112313631480845256454474450059557755162136325216130487396730150025349485159675820857574008820608122842424588512371268744459507483184221425045236998101418458008989238675188688553825206667848231017380725458251129105716305262281243625562854947207889982588869175940821849472906561997424713044310639275973918442426991990997306461733717003965262853e+252), SC_(5.81382309299270564535579676081707966611171658653017094092827483720791290619450931796376715039417461277943213990951541654251641058256672068929863887283386083842584878856037804814013991835121051738643778162387509305336396760941969684817842822617959407571849173442944169183361178744288803625942429124646726715663777722709259287537311638339801749383933175269192971203149450954268678743393795292020521587007890073088982866139201967618214305073267348845300522207706333936760908257989610506416548415479263219e+02)},
                                                                                        {SC_(1.46582702636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.46722428839224364933445153534390252870263560016896366027344595127107415532077675312494028252559444975998945508299618570275996537740007563206032175948500220545257858159362956203884753169958377204702816406872361704080431388666118330226598178503070729088243026366043324511078631406641581821378158693607891036049881762736746429770021390242379020806818043213303084346055539373066210176590687746829845279335842016544380454427052545373244239247460904888110059941673582368553717476735230928940752296368902006e+253), SC_(5.82937400904124313771857658654680903536693350856720197044360510436432724146625327236137374195694638060678005070192195002354093373883939348211806470283647138646535187855898367405801269966834927264039465692194765127396019752349703798238500865615926967160799080598816049076671359038340777318838719564116898836145851137469267927590924905339243038208041402245255562471503050204505849726751154277069216880956460420704787838223766273541296860502599440174180577510684058169114331727826317860586971525577739562e+02)},
                                                                                        {SC_(1.46585266113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.48609104746852988166550018522647705856260853455374177301715633164282439984896637588038055978596733176310255097343028002745264678816222429336552569748307950057640909586383033935322202461828617942970802476309786698868245576379962838221351509934868694248666667209792725178334132469780164580670388246822408692357015442925701820016667520587984594281813978332857223100226068316157674927623979100994076151380045439611853040289281376795624912904587499703727958806542560624448511327027452622815149022017351978e+253), SC_(5.82950177742079433013113852323287507065521795992990305147571429997518635673349074209971445273450120058169771043190822032926913616385411425235494315265651701047313263489198809839157152895827724195170973899369041631236139905928083503722369681635022517818485372405300692090518030025984650759238211391642117051685100914401060570656246564140506770730511271375283962498582542827223224016319990947595147866915442402996202075580324422047466793044978422841282277400294430549734597411656134369181408603858038016e+02)},
                                                                                        {SC_(1.46775756835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.84093479350024209522349037525735200399151710938375792906436280512937352939991230271288779253868690916905180678243427634710216405473907465133213407395299253827011040732436337617031279249861273085543655590262979001746203284896151880852861121105932693354047959815589964574229358103147332960402886162926110737312691716589804750601943575394762647689223408215611376937519384208658146497082212655168476929852303078626676465133482117480364036078901106615139450414686138643561506637150677815761043536708533998e+253), SC_(5.83899744300274859978282451379423423153003139903429419682115526211067217784284204454321960341075305819280505490827110967586029431640699849696412280626068153034782384549707731168609841584742927512660419959069710682265957906615876532549326784199518688629872661985905703316211784089687469299852473035006646465667083047482697426908069123094829154322918776593162934167429171673112572972724119745301364963181498560877517181896682558936500142160350330340530900637773058574094384879091290912117821682712579185e+02)},
                                                                                        {SC_(1.46929321289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.25972461618572822230055612922428436288638626870356858399380923603218491353622285046487399928626304488542635010922555058640113039324095555488374606558086963020613198643118314604331095454798679768015009728613046497261954367491947693198652406641730873262582065619232993261055006523338213587231626658028083596400829750002285407860157932492891573013039634907981705410947701442659940919578843369126428422701136963127819556383495292877414459417857088537806034143536743700907393123798126975927264248730099929e+253), SC_(5.84665419775025846018454293347905981660681838116551024833634429221581591042649057686760451311760299022592227952902681244072633816656804158285635847122214924526185861123447212451694330096630740199026114209195974537979150411418232602107009531811786352415832054571303482321770889913203039756668385306087847467191198252379462097592058609771755564381517376889222807439984693933255798084736221051686366665615876620611297807799660411550316488115159185423785886898249882701387614515550055663747246864638134563e+02)},
                                                                                        {SC_(1.47090454101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.84483670615936102545753884539513053089700151357430321642648476001264799093797281289636104314979677643557260173226794005817099190456625884360973075235766052040644854663723293806762541728047652177148540154587574909357024795826527797265908403825181199585840091075653718260363939384873215253003436210696043894522919132023328399494539233266095876892342791400063712975033300088402085800545553728014319097104373943091383410109118523472799782073410829681595966515062699967298908460066524617615004730672071434e+254), SC_(5.85469004387916506343071426061154024843026943789425756614569107533609910419658917987674983489943873270431728270039707319467479857211834219922771970924193128292570478900929839859892101432983513223218658821830267297956573492472671082998962549618398660634609274923794451229705644482477414966655953057803119768913288192987981056495152214520800757780427010345884322676779043442601525338199010340209291245316113308826806834747533443924746788689222023532853101215021580220317169713595096984875178176143035440e+02)},
                                                                                        {SC_(1.47176696777343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.83648028920450890375408717088234753371966435344750941529277703353771836887905043538823309770995894520968992077022784333505695588252812429540902403587143536426134461715372906996871253875377214202591536594401482259295743122139714002423954239526949389062163645976004215458497879102089074861778164766792510764716390746000695895639804042560511762900633439965557987547831252708309216963101367661361822428355393332980931173739539517321653508992083271558006366113171918271212852138989409090798747755632333352e+254), SC_(5.85899177569263106924767300699652497374739484436933183652120993096146245964603836676044792829372195414144408742853762436816780122889934711794856382587847949014684449384104305880256816982826103832996051439169986296760107274839845592361068806859924003412818815560219927854027159903967001985449057858529989742691061079330366875160748795349546962058672577849208549697245675650365061906972821447097300473888185772933805901670502032961608288634525713334961574899167164424470798708606253617869331779988255928e+02)},
                                                                                        {SC_(1.47259216308593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.28111626837909252696263042706334570150067940548590417532139391797060305604428969091763573841265804254986576605459362666003642615635496092928969207031582498947220761351876404828104238250240183696488891108739699178678661133265321146586192732484736568488518426285664739142989554684468068813905182262127822740297658144899430935476957862868393662440683042929944474700452348297411520682676797379670218760318387140915310464761907001237314828093058310203895564049986922084727721696443734094289785852901837901e+254), SC_(5.86310827406445144203688054657583993102936363273189424952297552413631834722609985053314254378278748310207446818136151242606164682797345826916657255286853012983395893940851250119441549767974392299134505592331689925270770248301527806477518951483009433467007589642002331966035283593134642187675253059005749579849962487556870376008835813981269424316584261707516350709895172640167464935090292269861639386496913842514786877503500565750491455561370311951036303949218184789146422152885424080349997235152416889e+02)},
                                                                                        {SC_(1.47732543945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.54362793639373123432094416265996736888137468491714292282000789985508589396613607985844566402319270097276582972640593182541918284330852399871568702239357404001295099544529148712577772268395519116654494859574221748217352009970650792176486975023125084944274086603763835720220573953967212860935235158236595599580448416721335805424740350194045481697092227809938398723229137494469229561947255112949746257768707256033411199390241498757010185223502807698431815195483610943471760938529764541351535351628752948e+255), SC_(5.88672924511353091942424433079318880885850012922573636584339464289461983154784129551304969242447020741717937992853458631872358037604165601546405430052077416475250849039308527554171290877673103039816934590433186563138907391706230487722781725212669046495371394510107989850450062718078475129645196592697849849558006321114398441259570514103139218002749080521484967283524450411138666894772736176590731277705470348047425587848444981223329516677526477565567100330220816196599270891263816986664580503212239250e+02)},
                                                                                        {SC_(1.47998046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.71048098317977644828980598766163604643834804239003638424293920757546639295646122133400981437794828004393024873252894735372338383856622283917216982604252196343866010073253702845147668210012421852718140009968737478458712445553945785503910790073763359204541504731421482547056897334089793377437382016230893848793849694894733075162819824653467864393679870843748989771965964001927642393796131406601881107629179058475352634430970295605674474879810203113920036858186773620088307400428187435712823616818004342e+256), SC_(5.89998558414152704736089419182709588911661208437658892788029485564231230229447063180990628408020804967845164120562530985690899501561086625860220709996115117311442547000691258000214603082660863682885157950925951668935955590567805007370689102413570560556998536631933543728540270010027691291985758124452380146865650347613841274699137150345741773432893447513552177489297142928738268132428790181860863691779546263051445114611355655308330760203085861954291276326322150834747000547962230731341289744144121286e+02)},
                                                                                        {SC_(1.49509216308593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.26492766549459710744176949193928115117754321598438310343119320191045676580968675189420007617661156542939261296099745987225078755863354110839563667043668744425058948609358004260906709325970889925907191088707121105772663315151788575333069973868685525293754663116530280872156297326431128346159111632746661903260947638287785995405943950455077043693360360235781568782919589997589170741415278870763019465302312066371383782843748428496349541592089056506114570093010525938495130879301433987324535394322494613e+259), SC_(5.97552776693421545740946098710740735472253138139586244451967343752698326895427880070452104872348601377630873548506825434017012088315458226888182590589273685874947344783897343493109440960064711914582372948120075689766311683082827805920017997842008105384156337896001006126813987542435527100292777885619211900623305492684919034378077403988460983157846543110456968849529636108500344054712109904309426907680190926820852901530481096908997041327826895250599440998178099699489686559738666854038290723255069067e+02)},
                                                                                        {SC_(1.49563232421875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.27825223602630873274361627512830742117155119548498076574990571416917010288512787206125597410409756978883789230768419318012509861271900829027701746401255448106722258669292365176045672517781050265877854309300887480494790128083952755995096165863147573750945040358984614668698916603078624780083846786685949787832362901918896495720073819827354752981616406742282512858964235949967185400623626066466309414320198521209778351514414293262092985938911616350371409856216374730191336998574627954737343814605551048e+259), SC_(5.97823083655582873358225236747089728209331301767346327980642759114170987728554227959484379910569262522155546406143337827085106164940148816611368559836978070546163779096071370339702997310635998561710009171394831454594971516618815771915423257751073718119204758567560848974206520953216765524007162624929072219930637334585097265282923974218034213725651988607691916695425401188165449733198195495325916506347537327347259960853512807953803189877500918923040039203799914776737179504234110160844454948611311997e+02)},
                                                                                        {SC_(1.50956970214843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.60465525387296632302040777223412285801137295434966242566431979827406216982641703452419152730310909466362257007704104578258735024185415723485793634651083057206453115389252734230743196440101353311080955820476991721044635409467613984281813863312752404936168510516706567409395543910887825386860203988192333310270304479242040849459860040455928228289441423289304062534703914943786026693435470652039505916803278936706403318022599675311646917352702002915537372277716830784963948437641693482957378711754304593e+262), SC_(6.04804362167907908711799449340682862988324735174584269347440552490720685120262642282465320593464142378877566183750451189995239367828992100557831861543740978181245519543965960414384418920503509398655384927989321398348345705816946834639388569317096449126775178535667070318627470350588227410035497599175803467870984602299283550620747335692058648613113799898670237715876790665741667924219493347770901735216997962048414104963137010150191689056808625594784062571160348584000324026469279724942240423445596914e+02)},
                                                                                        {SC_(1.51098815917968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.37740868121943940923782966908598434861040805444391890361217606732282151467151446344178152129278528183562818398181501048547796861513091424510841917186568323060760599248596196444102768202383178532413151920793092429048100592006871124050220353521690572233254000779945066500163887121310572985767468815429794287680121952312212232567484123100591117469133902082335529064838689479643788241744787774835520116617653216737177703142547519614025479197713530663062364763432246838953596196896849927773262321378540392e+262), SC_(6.05515597829293352250331869186282967095714038368933810258159517348952534823903383028761690496742448749008246009604915295982979901952191675913429840684261303208307611147658168871516319712755190354141413776098136283649715917903242377946844124137661530355179451968619270840785385998232315036789060810897170470150717324222695890259368201594254359167673473851511202537080684624719039039211405219131785663636942283787085263364073738714983189926673210950351174624381231376099486883642661372961738191999517403e+02)},
                                                                                        {SC_(1.51431274414062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.96909890697008352319430956223990533679861037540042697056820743986520614063546931349696576202887450564769554191015324160534353149996433631544761317481796241673928503733185483615855767778468106036648607386465626856497358048410854987136835271215789259183483181758893383060851109239266534980418966242269666667772381167764251891237110061043017446372101096137511855637503933634050738365048474775324107026991113823639696161002109910171882129548037904534819703529117468554973299827624882767407008303963501858e+263), SC_(6.07183117974659900709568910481377550761006130471519431174407355549442313397923882408151812299512903349365057172585295502250869306093719448749660506424057269810461561619496775458900178194330070164902164762869615110209864945536562021956095180200360328476917786617389143147295087680965222311692896643950690064231493658954033605908713183432166313466005434165582816796013619020790117077884427468306833560323003805738127953268606785061048548712152520436001935021736733585844867115048942065844805917752167905e+02)},
                                                                                        {SC_(1.51649536132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.48556076450714618889441679609748084144405569440503215178135349125970286770304809843729836999236512770499832597161673194436210068911618357323646580301942325618608990512739004747019452361174409273540593191772376414524691766077405980583485713014177944994079155367629078092705631817252765451282041176276121405723187910609243399049495476854825753451412909772939398878113990705289459633430454709733094808340334753356598332546814162504030232058504815703563879778069164666853090310189833985669715581872100078e+264), SC_(6.08278256870599270038041620369942254699806564093373580791795496340915306374908983692560682611826092144539663817736052814832053871268208746537378782233857817097861595993313056246652627918137454239817226737292814972347886316235759350833107679901316473975688396316436046269089394425659980912459504832990337516083013704658381989092161407062008229358948103943028387939668832661718616320092501121653635945650399409457526705352966657410287510301508815880034346346171918512479908455755733184367026447996356354e+02)},
                                                                                        {SC_(1.51787109375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.96309635149365794201904327560940983178987087583292973957995881805226670134047631066819192679174720736103724585079710826659233358341405683959075767980803597841250764852343519505110306739935884141856358268994355018856132590407433282779506907499609815935973453065289949682627784935518270512041597188346000227681704664812833455020100966056286928541715678725563883620821938615925204483255330142950792854481108517723976599264054524460354301622825426424009562840774759159300971426192646744565111253398303584e+264), SC_(6.08968699336713414602526015493090477822944607018035856632649717622712005718232333523088611967562313890308819921605674758028341423787568807020809895292643673026824314590681840826672040269147920944436937137475957216745232637583959533622246674618661252534585552142236096776224943793077598893061629070168295342149607222918918272486103929209622360145244381839243373138808990053179312362223124980585442928686745384707048208073046291700591208584498431108108438120399799676750797266700331902208849034288672329e+02)},
                                                                                        {SC_(1.52357482910156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.19414319035371951885126681686728391507451976968617993457141946940047800099128053749741557987649775281529052911964163825284549824613537166467982486762647847691573300589671154870290879078628488146255288491454783153962109865269686037976255517235160004697024222671093489248877838100129107627588525527786912406671937133019820183507090421098718390553280199887567572350927461330085896179514058076806855938641750002120721101671084908269028010397276819524071562016009384006807211584183829835936522443924798817e+265), SC_(6.11832581324698856682421476020089255570418947412117703448713332472659550294230401330014763279275097287369300936961095275127975050900609048980848590046807184669360614810278941664125030147527024332413885084869661385057787713510170325339927027310394996173519769181485618755980901512378172808603838145598528189249493737257041140004336271437647952287962615066747611054118016097751091386761184191614218061761690813813876646244242841601070728057283766120787953214860112185678778531877322640463934025825634788e+02)},
                                                                                        {SC_(1.52552612304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.38430190827876640272358129386243549342419577805544025076548664607816215859365935416703033772674947799272924727020208412219941454166360694242322301526792588993439354979417192188181881604254728582603471519386495445748060233862793838449088037480017760808293352577454866767305210099818191944871452375690792334726853720842010883848686251995478650482626671938741027088755450219295682032933689561841963371523787489791494559579399853350576714070987553523124588199318436032814962595067254515521870708217762459e+266), SC_(6.12812830711642080483306068086943581324695462016662545022159548353368465932470530397946721931705532853802522864002472247876438347984915242167601518014132995894553106883534759325478952738694474766162640219431835417473541585696375188263222650844035630297593100308284969344189619112951105308300577443461349738245559597737616942289400130428166392524405072755611863262861985827710939861281199744917406663013620531741598218403642819299337286300776430864037591565750179760736128689392750435282252531095629809e+02)},
                                                                                        {SC_(1.53231445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.19853650398934345238028262905078467589108413424774000359429266994114735048972543152523759196618219340188040492200313220670718607029602632313753942930122771860148516588697009269795200837958159172129921622913878329429323674793743656179283312503881154092360537038386000665064492339734469086279633540202386117547255283141000345760429844724208865010156888864760631932877276361440687954906983844598023952813414773416352160908689406230851377324978247223823998801818990247016420506271514097280795818558705053e+267), SC_(6.16224955842545105140340908015399544611842948249828336947582842101639995439450096535987873927514663479526950512107911632363178655953524781839782003918719458071690292893812991124023992862607904019678625256428677671844369414300083882332378596310039727338448033959114839571493820725718822281429023129120373115369157231627915138208944956018402374758114969161466317459211510295207658618300820365890643525465589063915499078001156874785150137986933790151122015076819042295672778054912565546410600807491382772e+02)},
                                                                                        {SC_(1.53974853515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.76780074278093093179077751335003435299029855178154083369947188164903929246860377264245506360661701657191220269765609535133568415534508134809320214874411403245076830726314201689354251430796124512543715793671377500289487591725581197517660102362475269117585055117123468761910117441835612034268246746861427135528337884161240518527546902805713379560668415803421749472588193462392156091540352231555796947096218139708491284640607822699077133680872781774923628508886866937304851093814678777890183600355108500e+269), SC_(6.19965126271215403017510712021366614272196133950748215890193496664440720084702912033342923514042553767072934253741271169857558694435403318461257385656674984037109604838701731443587754931043252848126979346023148766693118380007816446645182060087366433357282876286234748218416545079696738538163778645857508124687377048261860514371396221853975483588314737170836353557877957131440613188955160388281733742758419553655249317836927304648300182213388615657260441211534084095859069539566978134697773348009073455e+02)},
                                                                                        {SC_(1.58211425781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.41905086239896348381282491839379771897185719615484748594399376183631294638725793604106194253392473963987848511821170227108501056982306001885793439691444747776620790093339471878535894119479886511798977131649565302591757659652732718075522018006511933923056893034884443351517773534686087063318473844268744914880670107786649859044270623361983326455279551639443059834666747119874461905331152767490796684625738973667049066717572444323161163466159373049621887863357343606637860774828438139983364369474308638e+278), SC_(6.41348018839287515937528663300690217292169242641269273833535545067959983954082570279855214455116116521014307599950184244100234451522569719924376426131519773100596582411190833648767363905541836393355641947259296306765202933306100681947532268188660788264960200351945176267693339049070057820630930984255581143861232286985687219013462071288832683929305494241097571465187039070351078821721665679418617191464418051588057890340747874473215810395852331978691212652389338128410666105002877252132258199411921353e+02)},
                                                                                        {SC_(1.58559936523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.99550052059179001905047618087052158891167074036043208522944751192304423223317564193409652456384486853823068783196416096497490641765403805103177864034980205448591171368896548590422638014920850095508016829749990514583165564873581430083570845216090897761737464607629650013645123138233009088048981115428639511411446334857499823450886187025825513057708813051174298250771572337371902723390612871397812631222171792840435674388031119227665927029667744947143437810347410590573397998671863822748682487437226558e+279), SC_(6.43112135851728244832151577518868890874261871591736840900492813711272937260981853791854267260487112116153602354115614618177820318012964315081967085814740463618269219806778391839396672709343216729614874555583713388497084529668766755692269511757058637068451834450619935666616296063028337326224338283557634589604213877281681283499206040168565212750958710844300902845564997134647200181353483243386262288881272800910481220148345340443659493078541769922539860141451255636421617534360150002145383974905581059e+02)},
                                                                                        {SC_(1.58952575683593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.45749575002857957853555787247251392344932317489868128687704808171647281998876655587490414514382493597060521184361960347107322606089761774257236647563624666199800824212854535329921053474971619491015387328608072940992432732659778216706465868820044886565854423311214163048368659265533926012298617795158206008005959480156325280037270250123559326354406112623351079523325882522236465202639425756154464864576555528569692468808578522512373987609323921567870993940411638682280384943829099732932051391051454310e+280), SC_(6.45100545761638686651800600372215700223526769838982972815445926320419354356395772765176500127870343150970450508890173727516863713430148482471146105437101662553982361557321366759916823118467896413909233359221941030341364546143707211261095608443891005474153786364695433194551440267278927778599398365606439848130583071753387964492124722897618375787120211175956720096719351004084319602720898097426811313625564854872572439650792561562152858313184163762448809162845682305559359181219245225506066190024003561e+02)},
                                                                                        {SC_(1.59239257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.22862065490396080936595815783721179304422380301723085078529149681564159998066536811074176656788041870497415171879636693215637170087232824230913196548481002247250416413833938409097947116817442129958633244085713487581379189469683330843071796813122560109445757783420558842487562850150352850820965894333597164729877669323266316642445991846445640305103122490315232280140496211168456781321311765115803248241210485010289340270608270479866661132306183063761907880487447838637688815206893677218520782314045730e+280), SC_(6.46552980942911504800358062860590613286828173202450526117877301633603133797016237664034141859633874249237800739784856001401838471480771995026068677889749152033164762682886208156490455299502874925871198127518811445455722526925798015726126131025721652376901377288348790808693416614341874054194319827811647488678295318940120687767685429087744751506794713078897973544728373725890665712804665479535385978369197352567104191410144990476859996576576975677999846498855954439571368927415377103155769710073481309e+02)},
                                                                                        {SC_(1.59847656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.36078944795212988200837470943450994016744453623275544443952897986894113512338855075770653765588750083936490104513875299565557929898252596341468098881314145442925401665451028653178226026711657341497432935049664621139930599258285308976156506104667658582913014176035682466296325760112333493454219552259425977330780937756030115613998234824822612223971951156678176021163621951279219004764638397132790089457569105681911042575888913818078518962156191651319859940442019856553481232338709766250006814850549716e+282), SC_(6.49637061232092956498094258221476058136375735813875796293253122026914399571916825402878245685099062194308016451724296739317750408361825573713492039502650320495090499699573467389971156860397607748480740460909967892945967884691582095514669067593087819574760057630689967307758453437070155743108310781606333974237530844672790978266133749954683735095152760209721746051853324766997990798684274708342492240879835423221641049015071457235319166863363025758837391903390263313703309326762439109485222439510164453e+02)},
                                                                                        {SC_(1.60179931640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.34051939269127885656477276097440383519388042650301111400421307720922606174575032834880357676050213234880125021132471925699879026749982784166155083040564160341800664469719663532357364972922530068220654841904559280350193190760108037990900882897009293078983125865530233915775652251212611613763667450275632645902936919941385606456437646174560452904210036627499809119353944628418602265835586645641908515967631966676157509020418200087925591888423839551077928819901741882787555415029316122386662072468139756e+282), SC_(6.51322405826390839349123876351238751766856783930439539782166157927694856847057771789976515358693150393969093881533992861423028668898500172547555116858488892029306605005922566958026522157427892059969300794963134964300440083707075819173564273950660311025537130138865443821373383678588207628553435071896342684482316735742566498131117896247752334725725160609412421588523776887312295345570651580958974981502125859835842053615865627433950799866759652948414760457191192686201761190235018085076236355296877332e+02)},
                                                                                        {SC_(1.61502685546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.05980347773323497966120277435004273533423308079724584522499949080037599291941784781378390073550540703631520064318120215243806319691436044917269744837511018194829029707470698219024598988707530554945944461571913270597475449810503261880436144734033510855408574435143972914069315928745574782371689215435224753909753976275872171923320365627701881969359270678598908805690230926245374608157469157377493190427514721842167469661578919066456394542789553635029465456133348501808026896959330234679777355716680788e+285), SC_(6.58038428873441440193931191862428216288248906600451558141839616570483487278596656975092619866222303991604977685095006184955845976669547406922887747723085530669980175407352018983133671014450245458973452154534382329053184761772521858348418079931174301771324627842954897259689514754184085458264470736429903283075388737742864048154140515120136760098909899478564725087157161612725198337716047182139456979976986375080187458770365736474855101470712634985240763744439241165083516980258983097472801187544951936e+02)},
                                                                                        {SC_(1.62041381835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.36834079790980282523482269789946012466399090175211485155509917681301771846876137270223862469794148354483021088443602730043485733574312669879939440611745966410063757925437229257718542088128665961243085892707960382398945712906224722521842659401623620350300411825868695076229603803212794272973022859369284750788212315287669911015570703445947931936028560393726038783441305945780191617492485884835651992436881293276681367233750887441626129756693547858477311003338312077200087346626663886240806706983987267e+286), SC_(6.60776672600870771749744775111491723636612850537520033516244586834127031644815658701981414824969516596500895806967961734639291800153470375608125767931920499576924027878384102792529629481525682088113565249702486069125339299927492794554035702928515849261917603289938204036684558636117583655482600565310139502287766754079925683880759839919115309399985454693563036020640024057977545792986085818468509375837845882801549997097616830430626053559953152747759867418786956796408250852846007511093255443619788782e+02)},
                                                                                        {SC_(1.63141601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.52862428955550827752854992517641264392307871605868947265519462906275422452853393831195266384771813181749165350184760305534007614175903309510037753423776568709476290716463359311238086626354285761866628705921676383159136074699676469925111833376379739262439856075778774143589364470758852330463332873897494704144625449032285292643254350828001082953176783076531870473141873476305543425977576317669168674332043063041114597546973154040959069857913374610539528380325549846638485824509291951457660702571485979e+289), SC_(6.66374767271059086286696926224725433955320203362325215410435606298042639796472525625629099373686355721812910912633484495198948284779127821989811453968043144827050126116420787803804183178917670779625165370574692094428908481816849939840836378526708581937082642684093884245707991713995884292407223471234934910321992410222257014924372253793365789509842587565048684820887290055695108769548208128275132470150646917840697775504123028786850642045170147400435774695291126069443445938915924595775689217662402254e+02)},
                                                                                        {SC_(1.63216796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.70822569800788098348172757651658947438132073835720205680174939719911270003501514460188981098310450300399675570161306415174646499748066146337796717130110062919430219708067477673949754613097782785094224071299867038026962330900922400248575469514462338547286298341402675112630742573072294540024127343807374910025590180171659227190137240380361901439551720008541010189371779629187129269914627029268140541879747266785160307840750581143335032571903286643423248807690093105847599560886807001954009607634948511e+289), SC_(6.66757645388985854239812538608925293971332840436628781049775363156648150720472166849068522873418642176034390588814857419703888524756192213349130234629051116553611107678393420522077947982106951875678566404475344283829734270819377227588950380957849783430909540957429632251259470023007240746813227264809333230599246903600772849635885716026888489271054253985828330029536580579052156835392800233520521248159434806163977183901465784571731805963448375547604779912192496115965581380608839983923364473599781301e+02)},
                                                                                        {SC_(1.63977539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.78758913570498564436279168274018686505837050427343392283416394388411301663013405873399862331324774594699765776009412231789913405766278147725397313031763537161188054839339216339765472642393648094808975364514371048487920921067518965784053440747021206232341393311070785302346886583845763884137658774141669712692101642945919456052837284888672689105617262480240322054477275178721350876895687595541212753496456486601474224561729308222190835450289469551807087954983239060274280233445290978271300542860286856e+291), SC_(6.70633129921738708952032432126261159523795896373852976026399420289623831411908768280015239148652988330339328617251715315233114505905091947642040817368285846376708671892154966412170314850240206636063239270910362601895697461765861374192280695653878563780008644024544202790907675087103262136203979283389928813051494850137530649564495735509933395054430965306936221399465918252233725823177071957759551702723304774572766065580217416787574262188850851559386017484659135512976397318691947267292750474557991531e+02)},
                                                                                        {SC_(1.64064453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.78393077860631738846677656531516746557404574688511710538639189286598140966377286942487689253321148783268898209861467131921127832837792364246363497136839470045320345471588890426652320234862484118934181794911440494994603795416436451164910031983966953719007512882068339060719850850740923910293723878151701597392475602805315235694858203655117707608412328529529363192518546910631340580510122153809424869553192555638904409657095667663923949171964870557560094438042791726423992809368105377088993234436638825e+291), SC_(6.71076125939424001220264440822656344510651821955384936028197330360096844979584227373130837182819258405516050411643439977727431007402675913432547592863192725800513717693603434710025088487238404862822027628260824633523646687014451276935543928664469750314910592934513092521007970672453768839007818102281136043321502456159581064101704481833005653393348412872436694008814452921649502779006451343808306822085986219803548863474233478432163495662888009131618941563834350825861759762277674624942475956604093242e+02)},
                                                                                        {SC_(1.64102661132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.38252519421794678176651620442885198233073188134278302676162690020862476484310056002097750646818235832206012913571856820156184276399424324173864527736358728002033987882192640522024223476121848611401561584657748261838416135330798241957607458064467384146743894504949859477823342196450885326002466084022303172518264776649974750321805975137260446309708652197159275291889730155945862040762858422473009715337720705248086449142078753194758385277685013635073526286148734539756421197148231198289875305068009348e+291), SC_(6.71270884590703823360455528965723416044818889594032147476534185266961291226390638308950292604715886655999523873105777675869434976596775656396124505168253131518189474895853927158203661307930296743032662098934478110684706396833369064515239649393505224957843638623758306164462852953469616055357546704379612002408359336722604911197021252511455224662550728350015216998769528996043251498133911120102812311125469740697737732709152597974989518076461765853904817134723884881242504611196656335370661782971780388e+02)},
                                                                                        {SC_(1.64164611816406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.63865423673740705997561628278349267384804474286286980915849617283014735406238447141754882435079675732191492867545542551811400246294020759845708148469609580672777397637311443824912861810016311260316860302299544297531657905691694340623642822034087504346832084748014222640613143563402265323922716182076094229662683868104383207214074588444990637044412017108023206354582642762516640671475867295273547320012214869591135305139927403735693161211251790079274589604993790245081351630304207382739053219688833560e+291), SC_(6.71586686350251215368470159030971259431928388514471415506227141631086287093152366877807325802155178189885073231658431160062162054256821720919934462387511036812980890553248234184926945353265444932648435191873951891140930160436331073750977287253483219098916730453918772956178667516990712890317169005974837192436295006958385113712326807982398649559554440941581711468700165822685825881145562652724539360894605301925826774453000678783511546112806694747051230301761302129206360576027367159792900750377151284e+02)},
                                                                                        {SC_(1.64166137695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.67487747286202967561025535321478821581781018004457129440001698095047325439846717418223057685814856266625671211813801558279298999781112900475455476147131053613031994610549092773772509500091540711815343121528476215945182841973189881647992574210028212166263008910465645328006105030815103011817648744131542259230806915229182845844038332487186467395637692860704632290986210696202215960176890745996807927307012399814246929369315485821553804684539355008568659255565351748445656754365747112709024057267500426e+291), SC_(6.71594465014651012587848619416903939921656751397255713201701958970145777927575287092175502946780463517844846341644105994095149277332289004988636693179161505214866323304810399216194296797565465327796355908846527376690773080583226173695488553659072899492619898504247676092332124208381660956585544737401721175316248648994379758494139280888180046130120978627377202933718813194987793949349820708093735427291989705533144865651985816265759036235786480724600937355567070504364612658417148584349192729857358800e+02)},
                                                                                        {SC_(1.64917053222656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.15285010329225273373430968083662700292106583636121539745852851956407560390437995242539753790547083830624966812118494373591849670859303409387073845105152598708676882840168805775303220764230926923181665486518553108602859451643507244964981969309237059250560781661622002944369967564967798771529062062212271498313583419728807712037275086342636226337825943145613271067451969491944136093227265664656865253877999607886855125478454456201233392914550682629606614735653765413337884052492846842204330380998673022e+293), SC_(6.75424224840962245567910427632098623323646817736188367285890347805443142240396198667560510058234890622638528769905486842972412696676063282492455396179345924248846254647755032148269705095495749014362020599175684250067999439514980120399341306255478876812371361884313661149916151109251706651270602016268724150379378374662072820935481714626932717282925050007358516463027917025075530589174688238697106746211002191708140689392703826637858170538421241325393001353062077998637540907702322499660406933012947752e+02)},
                                                                                        {SC_(1.64958007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.65319536179021890358145049382333830435281976288649716387402807460911116161586947193853408251417236732130649501058184538569567087572565343585706530061843151631008818521354604177536228228131631186793258042933760521081487824203182099906085838307012160654795643509433247392008736741103683927153949100832527823977536185153566278599956693204467645766479809201183815996794101234487805280525848181675655261652411269999797719541166046409442978933408601331341980404519866985562490886037982822078786991834887048e+293), SC_(6.75633196957766261204140164173751202661584030677354174567117193819483440707992236952688539610680617493971098967063610563040828071597417156462348510297346599505597363949635572561375227908713846424647047797680003440943565428730555362884464165983512671446894159736590841896962392420191655220300739643615605790124507690580350235950269888625712308198526545351195383485124912638716197578010187665756702428963564939171234619164715965311187207701242818058180821587008706756117296665807261242835332044513863129e+02)},
                                                                                        {SC_(1.65046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.17555580170993216069659701240356378912992532283629508571845705913462522717362476459342299823434647526608301627805222996829392989715278050548254337304191860835447150420890118299352225976520783494090484848994603407906071676197261917423463501919038473176361295741885015206021892279547608481624187132206041509044769921515746997107326694827636397817212916169808494572754962681715428029394912965808485013585570069104453759787805002258078921724715812914407284935740375752682359885419657276365053780793198045e+293), SC_(6.76086679722855771191708397439999450306821281894551407120704622814581498053592540153563322170071612682059242756078717779408763800653590684793866922368478277900521342210603896985247723482522500271075804056980596972990853713823330794276024880372537388022776895901503271856687399446739635714947052425961934459067380033976522538294558903908048066439155733093834269411373011006012463147213117608325370710502108859381836834763324284688603389368790509444037839695744988180958720272205568985303816724234833213e+02)},
                                                                                        {SC_(1.65864318847656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.71198654144943184750018843290107155214748642382624698949739902161872942842656754449525265374194494942558191960503477935791008918425609285567416055164883442286490159629859851244912527342074022729892870584678810858772377474182282937759818649218059797976025754182392121189373588905783311623583280748873649649772391965738994489851866657747360514652992812136877725128061333112911509271001742187189078497267560018445876104975711941469367516313266602946564650830477759919167347473008896241605905507271841849e+295), SC_(6.80260283840716919832502509042538151574490775130290451318846515468402515885297990587064657182045182259858724602178000810750653645985283235507099795232915061507680911458399022596471009051249905789834764907162074610277620252248807341853026743596597019902474364403109961759022642955574015970537755433250292071638713455231231078444202330696670032761551849112267614292579432405333779451742984097732914316326299139979684964531501377727276350151667009075269493993892737931655189987717172432491652881950659820e+02)},
                                                                                        {SC_(1.67480590820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.05272068178205386511784986867129565139431700690883193324843979529127531088991345108621911159549101328405406249868744301171011129891859122816720129988015228742897318195774544753749719887368243690243616438207315103188176672826610305213981133436222369187297684898644446118811311953543109443245571289996684640969823226363692523159158762020317655979723103842784261035470621088900158659557289114888682171989055914834864709928482927363441001218072378755817968930356627770406788571021804899915337196183298026e+299), SC_(6.88524320743717747426305946412873491451063761422306837995230657476633136866429224850195311828901777644305608670799914868630448746408655944250193876646372123836377201358901298141627572502387176123829655220874065932883243511477052497221164013721785179052408696679151905908764966509642956239815070664817904762485357661319686401674204783082355154262851059053657303874634407634102879215830394878250445572973555622012106734928502672355568968367103567336799974156548895007883861218112682583272304941907334137e+02)},
                                                                                        {SC_(1.68467224121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.64639293101046850796155190551873968064250642422162086996302297566751525534935637498576953882605384394945355150898760255553686070724462813083449658836608447672312629550769492658813411336918827722880742829195220989227541165777803189015869094762976475431410543264694116917358850066414650639613572124286999278137083928761194725710089214898655908457434767312539797120634831768909275608671729329854748085293822761833755914253907341099835860459403336593325345842938801172650403260798397393915738007403785150e+301), SC_(6.93576699783692238613770969440881236385681388413122458295420580102163065013242721571083893264446621557594646851097320112750340347888497191193974162969015202492180953017035137007382532650311075824141311254133390547666485589060885283776488172835452843645016054403208785610700756800640586885428558743047322527749804102433864061198206054185432548249702189281545304988184833522937021613637662730411102892827307924710395545750912437323629462542751089608291253872668471968622443703701007458124745765608997827e+02)},
                                                                                        {SC_(1.70346435546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.52784573256719937321087196763126998252072022120717557272934497281653463772182608866741088252761218243919316918934845290049778878130529352011261655117117770126505283054327931050824660018669742968318249435708174504249227255777895369510505125282191626146172621286457835514587036198593990107853152119034404854582337049809970684933897633515835761966471120703639677377344913658188343704863131252767277401285075868948106086062138326274092810458674313633081223773758111431804894112779900549499751299094055769e+305), SC_(7.03215820814096724114069045602758245594300463422780966977131011709797183048832264772841230684748006067721086087305547038329481770580207353734505197134907516427119328044185386106244173057426796725412716922473911942671037043039757994282938137189934979953865989306335438653929026449665946594258891769914798334902696927115545763798472099134253411550343625180228910757618121990170674216143948118762906244758278930708910592816579480588855499343168856249164683179881256711388088797350060516436755525074844177e+02)},
                                                                                        {SC_(1.70647094726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.18400407261817092623884721342493221669030070786214468462085156313123368684933696469695484834842677094969164083913320600436134061620158350377100572558717214935445523158591072218749200636722110926232595341196907255920103693913239831409859755751782690079908432490441755790719823383056565482777324898909969365124549273036012932725687040910925680375737952362124935280715981498805113496697333262784068140614880812539257766889387983165080074949006868879802684509211284508721523019151738739990486548840238993e+306), SC_(7.04759940432345170467607826719026371278508013997656560352655901550812712249956154426475589591818200510430864620641235235867404251478898493629948633771209940231688644243185858092179384863637695304876799723407271698619566142850592169787231666644091055427081657096909420277650971912072836361286951502398523428051627869768780125194127805912443580614191229900341326732559470621566301279171497794531779991574584099214900576211623804711965970155568719864215969415616550239480836476751932721276314438194114851e+02)},
                                                                                        {SC_(1.72126403808593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.37803314419839203240547220202452497324318685752445985744153244189181780588321249805994317106878976746464991206446274587332772511888798973884799787270993655280859324912859408930734386451537107950981522708526430546166612505914533051504045252840419620176064196551239542237091119514195228463974579086346730002255689256052216087401329591747545732037855402711115744828993596545261030009557407696516292870874930812667638001611310499103745573666779723659028715256180754084263341535399397273234441367908635424e+309), SC_(7.12365067471177829581982502006907282449347940834206791393174900515531695591196607951693856418499691375041812455696772456761832442277130647193673176168685995062348895229045453456170865372048384226660132506863193303983837014166504982979843412660035570463010815555299936005108434039809850136863402658886559227940074287120459930170488424961077039754807088218901317099005040834828388878316535125980831265702917270736186224338561052269356846448744982083463217734038565569791005511160484138571955928144989741e+02)},
                                                                                        {SC_(1.72562561035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.24434005665501469146063990275366040691376852763485433476755278826771360634376495809113495885460294860969620139707799020480328136110372363492141486170814672321253197311977354830033585389340203947785876084891931920959751933276093253110687801836757841171238391469250293438701855014660553145819665089536234199774469520388576040016986671996012196516238924123396926765810885462955790434567214623380897770998870500397860458299147997363127880247609464925501356994006541031300339671229318561724353094947709842e+310), SC_(7.14609790344732373472585165097640858209938953680687459805489878704805990316871532408159997314855863458036139006808306883831108350343721093713845845456692985998026225811659640952842897637632847856292549393020977277961828723808656771371587444335735312713589233789352533489498635629806694197944810456127341501347459698787839346725697268692972100305594682016405357986406882768029397614420878620259410944119346394656246734844139687628304332313024703285038356887603236561495296673953221275340416542469003548e+02)},
                                                                                        {SC_(1.73557495117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.77308608567355328977497699062279330067417006934286566791473444637180181976628698496832366290433601556434148275973100898450042146306548933658693829407186181216957259654132290756272977351760427619004554996908540193503079020143313436481742869840489457361191204700986527868858118553812000630716360879297829473971914949440538823393416619408529018915007406730442012630139532311098929616710390873105012637639396901671634915991122696550159731700263144227267235368489345815215154310688082177656433305713806675e+312), SC_(7.19734442271104149199189679382584649129661430050143828014867277788106105456574602593389513247616177764270211053900531751289321611213155464235296929691651945428137990944613932504984458576247916927054706126006157714935290341068498008849478302619970275768710207139076710908360544176864247408346268273175470379732636083073488820403801649872911608162203355845200743684021599833489528031246103873396572125980999508326120552136096446840493379683767532681765622085329644646664825619866496324800124154624129893e+02)},
                                                                                        {SC_(1.73911376953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.33834663322541729732460545356563441889702196866445659629610481261341009190051957058185310112938975334274567066281071207273244691099958327012341796228793559927971962894578058019612739339935896563181046611995729282412934590809093830084408660988304452683148287437677057677619678681355822149412240240586192258405121999563816809594370622029015669890172512854078592891592989177106248016991009786947215904050276514787509073721049675876042840556462077444246058719039341377896859268060477924367985177569622342e+313), SC_(7.21558578219772119344406462546913599023928412489596302090248584098180083140318421114901339104413526765098732066810143507588252444904808600120912201364826589033647336043323616033452022844533631833758297857294555995275178423275934288103749817343091739261366027185264217687141103098127571939768410334051675141506424225988901225154593260788199587646523255694625627768886038221898450421313010782393550029171639711908221299552745353624881607115604207179645387191798678501370657158374089025175136140182881233e+02)},
                                                                                        {SC_(1.74286987304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.62220738429536002180169416581458972793679296351576131551209553305146783313610502973203090358709851626002251792730151277210317616253799170105066796960799752836966561862432469718954968368335099347442305875349124967381601142627346806266405065913379615823527252886538759773577855729101880237968922250178896395374512784000769166702618523501106502843665144019841866146984798065498419781768522334287478244278636695425444401001449360282120309090856243389133618524733529808448678449620925885549382277348447418e+314), SC_(7.23495507004799341315262083422579594864912756717973527304991312009739567920612938602136380197664443476572621035995814823490684903304522944282616517507447476994502599741217950170965925652340366824250234374281866241176857989808513281134223867910780649780894754405821647582396309833041428154881311881889801957076083515438466027614881309944630758936098570679479155819410387366751715386155263245845290096204970711091496386104274350544268068839007744255564610396060912302929241251871411531331548143699697409e+02)},
                                                                                        {SC_(1.75314636230468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.26118375609591224169644622260908248994130744925188982010935189519141771048865789231306446145004375062845340278176602069604493180714835104593826922550988963160326626444544019543134682470074922554983879335657568887579557071574476596602514451756562820265533209236483009386699958977364619107819918575959277263195400388060472968909222360178614223597393609076055566046019185613884387367635442154313801477288660598148250685760655854132329034923362783181472244853350033538937940785952474931874361193981415854e+316), SC_(7.28798979630953466762414521172177621176319746533840701154529949578329104525307183513096524066142937413444387224004744433803667584227546078226621568585369770242212642750827575830560736200453654961573779894041075670468264838735283062966263446614974344114945115331234976125399010861314776853121816865243326706607856301199496434007401149484742006721367828250235151345225243713379780185678075939543812799099558712163937880425393391114415284291920440092562234216236149766540365131326992925715347884128715692e+02)},
                                                                                        {SC_(1.75579223632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.27885166818328819447113025922545292562588253621020047775785137521449003003384446694715659457957427895119184602163391052724622215840509661374986020443738941575689800720566088137246340643942397919895120473851967269956242843670785582944836886449400140834406152797917048535992307766360746608539877091664922151992326825879497504057276199238394045694849640293625504191245096488532903891986434217570856921700781509648676231901214586152015523696528650059453165284699657041468165917311577636114077555778439371e+317), SC_(7.30165437020146438420948435914349685173252682421556550250564960189502722430464022726274889643949603075628710058633379021597881289785543650412469304081764517703544941153949826833420597716940984564633434640647099434033344397839793774998088352969448090577569793738439677171615761384407164015458625538854635690099910038692182418590926060153991285355658017711508592444459297609220521740929341652104655958540657621838237819362822235782306337730281045169155800187222790482835941898961864344146276849696035926e+02)},
                                                                                        {SC_(1.75580322265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.28612940478838613285764710463332317119735977784659402556761765305430124022177847440250963310023783363133733518828871957259941522215671907594138285827899196204118971275960833656968130954879296527594283865196361879217344823543857451976810988633774724185794298875513154826264757434667813298807070594929198830022813725317353376466784326649142999159210350947287487223704445335185738875464598150823052675125268345804486079378477701147592320733258232747006080795302712867920514679667141363562615026018644175e+317), SC_(7.30171111725672926745064343325264521590210602159859072193006656823616585715544235079377133437855586517544623055807696715806056670018049327605401298326837784463566022252056905261917390209465196066309971658905506915382570007098459142912458591209956677955624923819834340592297187370114788270371017444058623742502981616642771211666668765579073509703225731176287597546153169187832926034425152850606162884758531236471896786252353792126653691108896668138262959904720889349343875287758845619452400548080550394e+02)},
                                                                                        {SC_(1.76113403320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.02052582059954444145797302575402828775472549858638258652337449838485400922264880102001814521844455168114683708960371667726418703832112346144276637968562598124383686841479497143128873664735985988820590124724286261077096817377876672490213916481451475344891177267327245111630781949950497885823371189324614090262174265890658492814142677633036388723002037813465512552328967495610585969562560071474504756484845549709521032926948580723130242602998492858040486469858058142960971542246944064913466882596468084e+318), SC_(7.32925417356873090126766966505072849653571561691207197830677583053540573453273156018521283364964897580074052206023593753088714514798211305800197017101968057977416334579947937295480183826788590173899986400332774900517429114007492485133074194706917987032098429864860936179566013841800062932162660034495594333770774589039627760147506692102845847611955819886641733597180566790679444038865854563752182451404067133604953777976266362936802468041363729385216814190500918698133834576267922051073229052550925821e+02)},
                                                                                        {SC_(1.77847106933593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.58696581122280508600807387850237005743376257074412179943433937319007263344403598141115230539884802073681689462575305149087758412391475064495604301808348263271223884315354908696107642637077560202125740242269289984224673549616101557807088463070767797249318699493449990226377560110663908217775503481937102990324949931349055009352204913283444841909374525132390908430445632639993282928324028038125224387486559126265018738936164874835645598242054617954170411069835138779160265076149252382995279152163846018e+322), SC_(7.41894223842372120896971695467778464434331313578387272627690128660440449215113889047238223702217225270557947090642985451098640801240380307959045891016227018945670443378394918589719822433946156998371580853515191912147426719160292211000671895613613862803445071155106185976875019446446785610218985155512414067916832429521477750334205663594205036698758567202054604939201673150111781575427264391874305657184104751242830811012784344407925842826341950378798440166465260713298533266995068427063255465227026153e+02)},
                                                                                        {SC_(1.78351074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.15879959525624809082679521792815306888765184498698273782867804692369318651517881541192702071407855740250348027264727398432619543412091687405921105322147580569054408017841028812920951265678160001310970036202890501551977301103372311586946159880311889620316687427939259448349496566621688871543022174739664098462692687350640613201082085141267837524716787298081319950411594071268312373048165182370619115166290887445465788311960551902411784530322509886325707847543266050487191556108734271485692381261483488e+323), SC_(7.44504537361353563790256866979696561169274292979987135806329745308388622247038615109771750895615435667199178051978312738544686478079611372342783320959891416761667479320362463464749942986322801267031097886473061716886669401182112346121285586340493980406953975487653745158766969158510242023482210490058435092738749610751548647277202591688320385157186225546323039226324054576538352749998390355107047106866506799368109060505372381047569115871095389803469845630883890576681472303492255871355434543074666565e+02)},
                                                                                        {SC_(1.78468811035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.97323090129015304829948670056950672988566620103360069132626705998662293835536886711038452025071627651801563771763546588030112847819556992749418163913209210497610564952666599516069127677852955185029576549295904060045236020947632616677386416176415724245484203451652003913968552102042443192357359181004360958300812496142078474620578952876031709400267524666591864228361642023123714935719318385228306189781016753079919543343577240226564942131538410979287582829807064989009011837262610114084216769765835356e+323), SC_(7.45114564629836903883142880025817532599406578138872604337592075410549354944472192132212648441404449070057481451608836384904734743979541319558484888772177498462069801799490721472281407471300213885149399515249974303546581956898483539540584041550633939581704471730839975216140632264213746582613956062471259638907198389238199065012906441044381052856481738411339494778087328650384450877294643292092137039394922472016400135373405269235588937963012119958064213918352154220651572397570405879668699117408907969e+02)},
                                                                                        {SC_(1.80594543457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.44492573802958081383009778440555292032058510782094707151923019543580063401821464124716334785896731053179360123458331378606583993775964000098336401815208295522974825046288945690021705062653504091293275971452833975396618367960024478069309509212413127761425725702401547503489770787474529254219066383550355113096780860939609783039900115962564637139830430287098957985576757675455555982636793820156920269250858351207376085243542485776765040343621160839693800231230472521909769762667442008620515985598284510e+328), SC_(7.56141925251518514505478689688640485796447031730493178069645349326447710013483810686811609186513204997637549237254227850383700627762478810404841601771875597634294163342387192816297942266390129779089956880080490305981215418622694389695990734843318143646996759429284015850651094450456909447407380010252315728731423895937408514482692709030861097258095824752689896174135887774473314084010169013475172927926134853497572921939904600357153526321244028669506193752266382070436803817234272935880029844151591958e+02)},
                                                                                        {SC_(1.80852905273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.35581191326195651703952631159009131166202209288184110644773817191871658084956909290526151772354562604893182774372066044894019026774162958496575146840786777221554589041308954974103286676024912475152284802713150403242992111453453965532852125999394869800429637241418660255150089818049606049236213833319573166142416880389589096192682582629845272414315172668935758251844897671074953640839529325025692840860945874824728631174619790619252734467377328565212870241811237982353501373680269895720107402908973993e+328), SC_(7.57483908247238706013191041332363564601908643116613794125755092964353166716497824310092103499993135103169507095149901801628319599303236584682978495826304804330608482550238350627808636334580088728426340266618467763937821057688921688867862910931405787908397495646924450623319568412793396037825337388790320632153923066106474780539753764469398887499551564384021577232927092899143543747409049815891732077908467663209515334893771215585650942228198967976932490033024820881898044076565536017246010995364408584e+02)},
                                                                                        {SC_(1.81269409179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.14656489701661666551426150826993742703922081274410062796127543291436741416644043285839056742503182205938143690550766734443196880076092121376940315826438357347225130609638172448389183666605587308926876761496114462796405389916326188916588429464036827906859598543234720421919794910927205272842738201313988559974125729824648074887940641287945470208109479143068884035443262208528622313597969142116946718196958664771847077763157230425357917362298919274465163066462902239081800604016270260980376823982142021e+329), SC_(7.59648091948415383929563715588284797443881076288302786520024431092713365745004664930550660436146448769928908595472831809952371363595290224670598516160488069055990529667027998377177998334784035362027942891905043625791394478679556663143484761342901957151016985586819836736568694434730341614326758350488828166801956142997723502122900228582567347108280898606605440082085072970396016102333986899570083167820363063830295677529090001156223115171747029172473818854569212171572792179196994366136215652618916823e+02)},
                                                                                        {SC_(1.84813415527343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.41843670877955808033711872827583329780399673915389894157355923034275743375969872064760946768395710760692162722563875075469710924197941789203294602594587774825793719222440584479490308163057779223031655837089151369234174058028491687359332918700985100795602659545238860363893105370455875892468056366421278624267111370458213026852824427061957136527226963814492761464341676200095205112479999345378820006266530346736884330680379147863141692485839654227013136972359266657753669089433872427207379533214800380e+337), SC_(7.78101600485969496738907472044805207525845873494964135362477949625407026491453906826628363589151657958255875736182538790127842629471238109386492432595799361811851512335943586219934808061471996676226650373516302737451767234665411655782440426010602537171013317283442130255563851745571845004194270181154095416823876765996074472789789444039190622178292345613883620337241208649102987263300954055289765962798067581253424838965150554183549653035650696686335579449451123006534321368874144073115836490911334493e+02)},
                                                                                        {SC_(1.86107971191406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.24588645855805258012942897324879359693551025583791148397292950102701617281686766503814328086357305875341025350135793052815205254026968929994762764327722507205986125049463465663080368068442225184024979846859779497746475247773819492819638571751788423232524988966985285143728729130330078587242791573411171000071289717978997020517689715808903351460826237012874920523845813327702077005195050813047381259174324216957154073715416491177024185354353075454757007413595044508278174657544345970582127120593395902e+340), SC_(7.84859365540791845126304726360573204383626822141157419885521181927814146148987783802258702151711612074539571709289812117715066864769651085625127711673559831522980738557964350467149519101662228352632669493854289808713484634507521558649057190673127264047506073184500896324426534111398334149971277991497487392753689121494358836984096649384282949073706022769719250547696523433025878899487131973471513734072806237716816347280826527526741380896550902533437911597818220723636306622155516315400521166248311628e+02)},
                                                                                        {SC_(1.86616516113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.03294541201222121164508235571066373185584783264026365544285628384716465880562626719738736266726777828141495974426409739234588935765141361467433423550667015484917877499377883544804718996516925708468346852692904938784521280325456051636101059721615055421494040481026399205200245425246179018984234929101419835846972996798447542294431461489105063581113226507236521567974054749433549150406332582230737081264009306236517071894593832412593632891448685791692110925076392446969911578962300476703897336493029577e+342), SC_(7.87516516148573383895913008437117610513828966119832440703410801419729919905995203130569560312667200209607419566953988839371249474128781296049846211080506555869688783852307005545043774008109290672119990141932485170760708215195471032725809083717874599366950043078590014101716420380906669405324646737674351386160400988120948057811371921198810450718411266755972013252978417746692239750259384976799876215523190205405078321354150384574306425868958987548166631464855831724406198401639410810595751844254740347e+02)},
                                                                                        {SC_(1.86742492675781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.99542610617632270083829336594010133748126478527397353695318364326957590586862931371831347138003505744920298624845026059650548698988042330484539186721232265403150046257528675530435325490841419324373755652405896622859988688336193852997036697395398853034296732749465274555614248914342259771848251941031375144479628794105835391662479355925916761305983404615050624475473265364374847969778079357129647184824207889431920748767321883118227971829526615738983739289995284802134298758725660193990717884773544424e+342), SC_(7.88174959418554783749336757544591894036110709774223224824271344579064868592003828026157621498484293875752814384204082165481351097818052748183336645296027303005209209061594852798759520425403411485530519386155931744924285526953828255995900195550163262460071815540048668676259113309591309366995130837147227376210850285979642759356236865812895138347213488570411672545274468806756163328735520628333095309808687054148465878813916308947887628896300352054261806340245645428791616647768003659528869190971855045e+02)},
                                                                                        {SC_(1.87030639648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.00013208607038784543835466338998761967010060994582435872245800142579849364899223406398425097394985031400661098740065090318866868822430323441202388005446005608006873623476463388499773064032386800278206464129590252790805569332743452949382936785569119293685857945597715052293722655888762017111811753247728204663184932267529632095037738006541235846891204292490822273127166641168390072085570404761325852826928444859462432633259332523118777273482195055560452197092159658295678083252646033008268848210231458e+342), SC_(7.89681341057422191600443509329763089553014955229013084567685248103703964971131505289867916711312319142589541701440748657916415512501891816981039764710739274708136202310894049973715085007799699497369060904560679424531354387361417798792468365505471179015299281792334433454449717667296646280060976616732761157290503242591829563524923135786799501122866943534438663317498936752830952239842824149481773130008874716222086772414842575181297383717442736189388023221494878471500110380734964401070678112067262623e+02)},
                                                                                        {SC_(1.87685546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.76616858008137000876699990128362899264750099077808394561524649985692676037977937790592025450514239974054131412512572691660341256409303095675680120482124234080094878326312900487048692083153338257185131707529228934850663620949790977014187946923664796688831909317799395684080913152026808435329557396447446787999313388110221894455392197928559696795374444133560908745392255035333820654489877927948373476790359653354159066270090908817479957743490674951339486235331068871132731338150805519376049202711418414e+344), SC_(7.93106735168582688465169890579339874633837425696831651151136001688467161621416533173038983338184935821627170059467628295716713846320010996273868218302439350332561849478557474482210296891544334948306362007816158321211010014344462659514888708752522589624332235750728579414986288165829749717073581022485744194322481455837006627579646589897632563246039454243989959497997025639911389053284993839308204536905832851427462848870120129599852959160797785476300547461620901300626983784121544915143656949964583236e+02)},
                                                                                        {SC_(1.88215270996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.42467714153889694379953380561564379431131421450816428693657626870690330823073434015685793654606026646868840725237891149239958998363729095730382305090229348661731733800887853031821278864445868727022694745206687061552658290371598943415470559861714972611034224402957861143266783742329199970555774575972006229341596017093248611306198067771492985679813925847529192174064672914675848858507171475009161384807053302657245394135850548068431010977818799585654853739013357822104473286990116965721350254660700988e+345), SC_(7.95879054396379679973378482359178964806729550808083202102172398711994144813660203436993954323360923769805304648731981286484173671316822747486687213741902959720838697080277644445253650041162710488291300014115594925829430019586557027606925856616083597487344500082836897264808351757451335070114522039549110269709821986159748855085382156833130765768155867203606377950946038383392551541105485904271194223359993252672237127929923238790959033497968914710044389256683014681708221426327506101622672148085636506e+02)},
                                                                                        {SC_(1.89707763671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.10061098729146171845103394060763999173039111869217414996316018397184463923997465979877646241802478343165477206965204865000557671637745488443470810084932904929448960248627613329155428358751235612132452149828463378992857879043312157900406444836530275609942120776649576482912290726026289531385806874581786395583285742571765640725099859979760080824985930717122365163222836550887134466056635668889597323406217518903031265688225953725497191634302109076082771855000561686934307076025887960535271896230147427e+349), SC_(8.03698062923517145096601407356238933655052109507208661450767545474757083651126074300735883840980260933649776465218591362090082739406607617830823299294038457394581883065971684983480422665660829314790121754187906870584232700277230872294257937362261857567942645979635322015903634095957576764535650715493948932219173429955955558467876965951375093951186025684359116435210580219133944771499275409227130247273611229423879358118948772126612588646371176596311828580197827889472666708946315117484033375688997705e+02)},
                                                                                        {SC_(1.89919067382812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.33281206150205146643355244324005183806916710600770049002539606130797266598648508887101464202604273500355664218606794200329997311934044022454918190419379348450843074990032218486726420914860915118079544767976077745142582899761071914741698271203297668481012082730542168912088331717987125035740327757158225679345006449049705029718293267966482166453666335604897523454714256529913015501735844676072631736531130208967443017927115114371729015366934002373254016623559400985672240038275307656801619652676325910e+349), SC_(8.04806013865469625731226447611000679262167245496904460769652369715905835763695986703351601251701757988570727443524524195737627994659580060597599021573044077777978351733520508556802089302268146543969567284533316343869097830310592017030899691608604050193595923658145675861439071686382522253131366884370301553887036168423845773140886619988282982704852197954508298827301251022649079410818467255031031955273197356096071555658682204442003474528731494644459565895341153942754125192947353015610842313374489907e+02)},
                                                                                        {SC_(1.91928955078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.27289443453508087332796313496350003682738987247877702104682167531747985776646817177272941355078798302379866337957633139770515724303137232998996065182019972394147390069021355552622655095550061870827136112999189820158297332123301324005137397021001172414485737522270735603972771739612699090178898122468083951398022515171566920316105159101455125487218519301407450437969176328571576165371562627156385126243702713932115976518400610198315644844874991108140646220089109776050146978223928857875353227915229230e+354), SC_(8.15356416309504951703632605332678821036309251950450806744706264953384295749461971762150742627117821781297591356770773034392144630581794397928939363698659120370639099547683959467363822618083228006061483256645067665154706984754979849976268926741454130725463009144956133345132908516372092826696894902228013387927192035071552009986450795885671353053126809139694384541973300327185242511459235969711308606184671751123423347069659907005661315426399022362349158424073363246554129112770787466603651137216967255e+02)},
                                                                                        {SC_(1.93188293457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.55889878026328766094254545156130405588317042176810492128458172796468478155842356815117505801707088037047728670423711838583162029118369087264171555276251957441043881320191705079482711288472361395027619329630747426689264957636149302235512356863434311160841952861854804538431864303161165529811626406063806693598450258353735003961302814786852326493110745345260159275838103326746732398298170655254923273382405156979074520081560874755475486268353634381812705834403598984084406506678245260553334473684573814e+356), SC_(8.21977765635959627162277398500133267593301883486685264727756479333262135968695319644233559348715251791924592091370385790355807059872793029080405819671585715805688457536727535203139767056986040905271994053868315155429608568913546474209396572356396955393177416138270423827458478089140014488962991931627499145418490058701846811152489764472359962840683277194310750268803254408016566449876018742044930973743436003375612625493736894351927923702238160859898822663084723609117701120883789753847500845214248469e+02)},
                                                                                        {SC_(1.93295410156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.67944971215571230381385402915306563585512555925341189618433360925317643914586339063849824950878127104307013236717528606369305013002830865269395228459287083455488726152695484019042634677797564752625403187358632023115166262329291480761126588425506918775135337653840598704951140885230214908854073322452700218815702551486812145166297182418754255982369386423356005578336376840292343516441822924916960935383497081543119473153333071555039616888811122705286740253504233542914725625248259935386522584340786914e+357), SC_(8.22541344386344242196010914041186665024114069648439392079686386509374236995093782195927762500525996080278244596859642782539204903609411934536775255486958210094173365894420274131302499190778323370310139129238118341874739848464194746295318700707267840903671542235639039646093486808559346979742746946680311647738121918480673164670952151788931901931170626500969058896357777838597047895957396247904756825358032505977306778637196016952959821390142664626683015925603705522917454154540020938849190246465753991e+02)},
                                                                                        {SC_(1.93365173339843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.42430992320999325679716901761938854023772539091622332595739009683583185296453026937618641790078542650510588136420582429206450065309533803404632815354443071354025676672070200124004665167411328304125532406917049457219842210795124059486692276275153480732203812336386422600148261114654394541561078007497308145487109598255499478982975895852651552441528862916255192694217792819101846844204013626833784038081286658695326076316349462736548903860361050866008078993081226997701163281219500204762767794892596876e+357), SC_(8.22908425115018214635612063581608839753092869727377752641769171700126271682157010634919061911194401641974846321342532995136621381223597874473762028259546616779927290488052272662791510845205852053685385181896515373004491784350371134410954170691566805760797284311991129687911851084775531929154515389120642223313112973162938576707970239300848871447062783020049556813912890056887529173933993178266777507443289090428976682711236479015637787419477603505854356179920892139035413965955415729946498477866915695e+02)},
                                                                                        {SC_(1.93893859863281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.91819189255231346972453640919376279998307983396719139738029327074684903718406648892071035406912232184402454246781460374777342947874726566689788273519347374059981337799673386415870380166268204005087081995314356223242279916619304107820077355589734939140641355991069365137331766135349173014631523417771950432494431741121327321514656936780355001014804014071667361178290389171919523673427736200333219628377521586863539820047681662524056914049746933391647730196298338486438719580698910549416527666870550197e+358), SC_(8.25691093587361426148596146015464335448516746162863480735588908784004458410412322215732597244935302406218793360603341363260365762366967561002732715375638004415248735947845958581888757491890066170880837027901650846382494247398569674556139294199420669658231316358184016068129271475099041211669462789964405981626050981066329500071449503538835947208406338108358608890423336962917529958281023406696516876798696125117237126383133829669122189184734418978403466158942567146769067320497613552863389512499524647e+02)},
                                                                                        {SC_(1.94323791503906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.76970488962810376929712442822506799150972175518577683878116032296958443013462979383862783705723933319451732313782128964350816582257723045805256908813585734565498933674642438356874957335664076760773465543393587233211955793690629039976559980811635887444090574644228158847603512451821027583991739047996027426376497589047264545707567250497900075677616374072397216443320073160717286311822549091324020863363267285990699612953867495706685176641173823310806130013816684950638847862639432820761867083234102375e+359), SC_(8.27955045104645154343667339772396766012398852624728938891426269247314828825916535991338091709610871917127552152618059111078959418678739813654847782324433429039010860986016354572906951448201401982849779257620256300672083673458788522336148882360032490933140917654256375790405976486227621750097451654002502861015346050197833419724873461666069884066971182335821194088070054899330445318502006040779689281654357901187198743041689050179676003693402625636799037068007429865185453536037619592363781121849239393e+02)},
                                                                                        {SC_(1.94734619140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.28266491078693236079930505889482845547125001491009809232235625402138987517690582351855054785836060448042403278267915222376926897805477347534963264638197149165940664729313044058079686689562595216239200519439941356636095173846923293128637285688502209436555778780171356993813701298580954984907760437068876535565538630395134017900953276133789505432994858229051305087303614204483595430308393252393687826330879551006222003039667295919054187640462437726280375942789451161245271063078390907316847565839314824e+360), SC_(8.30119289043176032023145415575540825157882404848793759377305457075144300957586366989763766266144808590250488888413557123220202285772294434598407380388732435129545873894291516349267450447185594102826122725546904840257534379265522468101343388191836339735197247640477753997635545264763668117916622255187527053416864645189422056659465731314880919345577920810130440083391940211741342285111847682575427162628827689463093464718063411815127219312548858707951950419445994409706811518582019288596522154579663365e+02)},
                                                                                        {SC_(1.95590576171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.99057106460726837335254951265469949180685916576201366518330799354603068060628399838542489064097378510079085281408037072910045883121492358198076636459015027497276779671608984401557195042204653074735005161488340297886584764785008674332110456414360320943571473989193828182211205085275930074217211380798304194907541431222367151522162493561287748060709536148037198505832631889595578535060602057144165742122933005877093759125801257905145570971678982661859718663150438418717880358751568903502008356204896542e+362), SC_(8.34631268024518024312544346689613320382750591087057053387033282390229282637137735596168071781685011981870157938686929605629865882581454307581180428574441174752453674660172239991452826982296362269651040153776886234755045958881356017477727650927044861068069375267920642929221008639880607020677782236494414997226184139937170443921952401765508153216046501835997059859183922145529568741476210480409142222925674751756811511184363017080292446209479500016727710625667896500980445948942011818349721058860643504e+02)},
                                                                                        {SC_(1.96223693847656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.43702195216244192317676186541952916707280677164984247367539335125897646733564643371688025088467054700538084552068298454029647207243130902537417130476881844646448023777021200128825481774554759366020149296557917257391619382631257126596026694580951641418147336801589028646196536138781855540542155286213166573776679373512962877583322900601066141087719663449951754061391451900849479403767415140909921303521326888597157461091024327408642723617425659345878278777631423831868081457536374025602236321680929720e+363), SC_(8.37971018153910645146849876302671100355878564904416318951717625787199549501672396705587516552761922802410218356442207156678453770361108141405713396857271262666830357861273360399171376453263631906584441274908671489520394913910453124951042230924524915186708987401902202237482590481943808082252089807169702360579064304487475062819045711685267280266165519622716900432024136393172012504561691993731410474635522887745994712603442970545006793254302480947110314655556003246095545965534442886579511856764131891e+02)},
                                                                                        {SC_(1.96529357910156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.23414726746625907416715829443063285923135397751375214247196786835977150147805051398333094509425767588802720603448824250661771073712028894382573028418813647924962558838820236674482914084626131388748080596027314470518145581837598000195509481236116156941383504916079794599291452252308226347555343874962002885311922176274513700554050956675698577966072493017611013450719805180838204308037770887975898160752634753380170589067976564495571187685622124978166758375691766853963371464468158002902770407780660821e+364), SC_(8.39584155804053375527342314852548592073567608519557016287106642711230165566655687717053998009042938360547719401225882983535419584528005800048601958350448310573668435377730089434909243345687233337830049139176062035296650344707700088006827018390690145555342736794903069214927600901587954409530290166291148031911459504898052418814831646552378457779230074298452593752843325946141864017478714236662705888608533264283668477574529443984242441013448105934470619631097589148562165995926859727144858382331478220e+02)},
                                                                                        {SC_(1.96643371582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.72923224783066528023999470490508731323871066602976622785745508540096202365386551203784303321602051695271454525393798393663702021330452189152643525364348428491179832354605979734097307438551875553759245401819634420173345118102522332650577040285051755723434219540758402866110654077683693779161776736404709612287605758539823190928772425476186798455690025685939558676812715159791629245093650208032886520127257083232612658307556470384463828890541787560681418149248831066612808778348525971443490467099021645e+364), SC_(8.40185983386390710192076135704248168925348509816019461214950716437392930063583844921188200852070907125874754160452731394430631464143909381175484393050377049143994089896516302461374658193216554660465413071660423551678695680241168931568491899089984666013477801897927803428918057237287299416570116019014163278726638182750233744164815802505579539237403913772926615589113727011366468082795847664443929239086651854547840693271426594036197020338831595646751390203112117358305985921089855500190951968437725493e+02)},
                                                                                        {SC_(1.96722167968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.17162811815712510039905579380378750968977013363477307164574089945672686217834916896285190643746512384683705292466337425311341098378687575708976991373959046030667770632001217204619539714664370165651664707180686595098102100955000938827975399238685075288710103150084193213363161272046776904672378326819300464241633964472613430867162089247658631038267675808163966731109939642559650197083658534120852141303242102398391010418538136227874086480458366638310586572862462329891594946307476509088866206418732113e+365), SC_(8.40601953278302823715914437001434897326585851451377782359354514510143709016686243390171646070512716911527352890685562128158003076844244060987762076720409802934135114817072570698252972683730666344841130172039600120289262881269496545768851707723811877974915916545908409772521055981201276329797761080478859369338699323312709915881850535299304145924078421899668930260168792437487425790942434771190356780186462366325884970480894071308412938743777497960710040394397614691713396494275690128630923143299145268e+02)},
                                                                                        {SC_(1.96733947753906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.24680353412302939200987044186417286850293617589893350518753259695986642865759373421287222175982632299577154795441851862631143002139876901717084858364499770158486495252092227254919565386732785327109256215044780609106529634459613462687775593813516048326312320737385426270219126203420114241326337895492874001558548526979886090777954237816043152378834201550716350580646477653398287071852116296228427415539474823987711273104208640332096163005959723672683387762960233431767587584060874792860272003416914396e+365), SC_(8.40664142046288586307098578012950982940920247449411400277826481575501321801418111704348374661856526660437304397102157549566140121053024750062211864903938840218438648122369834739503064495501358892588074060772910518224333146793538667621921225711706091391031039758460516782054917885054942929024053977778388080690944908154284224192422437339038235483093925120598697680748923392729193556534361289598031674492625039905995129099332457813491812192053113409382582404365282925969718342484043766758647802760115956e+02)},
                                                                                        {SC_(1.98035827636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.20944618702144819435296995467187386930468724356684581700886145002110052068179595371516095682909198536856567991112384692173130332074878964517612238485811376411574177290248523456198427051263118200164102678815406661467567656506974977501654206587685000986975051917619746085652602655774636443931793431285264833970762057314941793143001674101295340029715164760835449162881448034837306270367044729073839212227407984125064269561365343725931323628942684858873575347992677851552112437064971878939927095370338474e+368), SC_(8.47541476779965877146967331261162470205184650811639496892098953020372961149309349015855337368315515057751894701730812276876556836189845145602599367791449996023449498638627317430955950228073319226682424243409234031059111912399674726336202132089429275328048532277028206481590305886445426026704578735467335483762409481391451847804144090930348202740587590332496209837551411334440093728917031128888721007482363710839178563338178649459997005270530084383360495944436069819269225546530178214790217098076960726e+02)},
                                                                                        {SC_(1.99081604003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.05154196611778131368052401382199557096766465926000728428835404154643680644942997276429557481010925489222942138215117809515648254051601495317154853568251230860379869353011771511330847204161161617505553720745004109075949967059004326850925165650178777793787019317352912344759841467942308320150943031895570624614242670943972923281959878003072390706001341200047441157686391221897443065320844906532339478561195763020866424086276245241727980766550667862958920713461433837413986527397831351664226713597241965e+370), SC_(8.53072131433324045135738664115288434528725110990049135093018145682437475672853017129248153128449935545576341010629882140485762370819485469336716214145271708650949434239195726432153512718403315628017431744827403922372218014961101023728565208273255565761476282562651185175632833997020942688452832742021973579044699786396296838444391108919498160726021420370993213463365965357523436031775621817497533473760274140845623774172583660331569796023531177010010402871966199969403496490153557357968971053015210535e+02)},
                                                                                        {SC_(2.00785522460937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.53038471159972860186924111793349715756121085385852614145376481107328339255980485259779959405018101696655360418689191755947524674657017388250476329778595966331400951317829495575257624387472491518924953792738723609469981049070180796177369199968029593643882570199329343672361584991491269031346325150022217340466726132508732198838832625511102240690996448510956638381866618246882695118686304361068731015207118010591091682776168392299129402985452021724002211070453057481572603019315056376226319100980238753e+374), SC_(8.62095196130873418125016483284525045912485154509044477830735224874607852988001338205640871319027331228596303029271135316155897092769288603729373918059977700494666837436131872233304113502656742361280668423481510626679892941153874337670788441279855253772338766091147270671930907305990963779495199803536426812659375897973408139926629683755551732852800906654397071001114113811621571665099139260312325320803616377742262239469791393991518027606184447445663606181436475760468080061389174559057160775011156343e+02)},
                                                                                        {SC_(2.03620544433593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.65143321926177336947232467996576791774863489571035733142117938518314228443063319609695068414610027830548060080434930101604835199188658799113650928723242301814025419554451927694078109662141249893930843786460464504069541546299010614406284401816717867690561952611836105745932468701940915338669364306561713413455966982778774144387067156781082643925925011086395730031615235115064861012250293912515164198226271080460239215486604284946181939385689141466805797635994968497078929588417846687389792691577730734e+380), SC_(8.77140060335044127577055494658049070138166721729748863702656782677174727127369991092952837475183854737464978173384893960446682000728272207111125387872039608527919906883536583919943191418013126874991816322836075294538833451487444105140477827412747685262087345488602089706624637013863537722237351280931337789386490284036989902558931239406263531199796638196208724851070764277876570713546076655407206602946148987824269335638195963813210790234661646648909037936970322820094144140138232254395372433963069311e+02)},
                                                                                        {SC_(2.03855895996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.02190516077568225352925006625769365538523628156840603558487097060162209263854748755473281975434014844142353875128620627939326967887306014306593567841975974305794673393775625034015256222466339006271631437321916753648305403185715320005442147613108678785138342429363929838778398420532140590256036175166922463382586028314332781200961173923197495568775773587585961994108508539932951639399400263237162689586963349530872504448211520049356871710673258018824927017862546623151939747966842795727006527563387175e+381), SC_(8.78390807911156236890062008968273733740360663293623174807251675415458216401922658468586780495662960342131423688505153117969523401386784563568666607008655615879836550811861510100311871505084981492493286612002043747994798669566839497908664979634082652877580447007256859659711088969505950647552135137503953004816160974936508379329642382457680848803055546205261387408940928932559777105436555542613618571730409097929484613134216940807704668132154778258567706423872979441199450915680868704496734353373289086e+02)},
                                                                                        {SC_(2.03910766601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.04519550061459736737696825558626211223691665250321811232308723146433174599050921285969976391716404523777360036570137965100255328108197885749942363104295245545942330621004157488142377888835256713130658130164571550472724669622986351319273702053031825769243786972865591589485416694117143340366299880923018010637468713737647538773350785374916591192931922511230751706952006046325080510157215169536762010623586769684803443313468266042356424821469695707609410385516618238684812406808168846511558277107504019e+381), SC_(8.78682450311499051705542102592143118531464615073289156275066153608370358980222641854492981697674528230101291949307734557180060219454820905694456625689724158172140191643995631874525516525964315497694017087967969027105037882250779700520278683484866631872791334506197300413024318593614287224835750497851676302698486912204695007325920451209278716499735030880447806516573294488944828862942226613073642614916490317760996816663830852551421666590960790381387398019264063659239790743222793037962387391917471807e+02)},
                                                                                        {SC_(2.03945922851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.87634721420954868320679653396114437042797966640215747114814071292289514679853882420646854333855197669992927145949226440228009068993307726183454975241035328495990463229458605531815349338574874766725546349252526987364072603433578464644703708086973292823936348527413486888173464373298370552283873612506673258171504812993846323225727635777480955133000542387209144433299517186846646032597009982879026954143521098194295817794343273803342274669737273522964476315749430970397810057312143838352903550803963141e+381), SC_(8.78869316848635865143705643570197031402749418119277577772373571777805369195793831867246853876788118380995747830273464810506001333081217540381068885832190844262238438283495357151351813640671486210362169134855621015167660782116400314538798219104763178489465671624454099440552345100590695406473366022421278064064777579668657428993389295582732632068184617079283710640876524667533433223814282991264379338658963728389786465106889424249508756823593288506817598320716914455174905100482212261967621947480780031e+02)},
                                                                                        {SC_(2.04086120605468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.02743657195879596579356190191020540408517748360270772233350187132670368236338558148167947525604182688475307188027154317033127421930022710052512496367214724389204196539529278449587030030071334484516910605002720685471497496454225026002000088826887804231343927284827136523745689320502914776168715156276916400103517192211219702918695741499683669398591603530163539160629662306406208651611461245313107509259596231005682295955767659457243885582231566582253548170137735315226168787241756908838842743163884014e+382), SC_(8.79614572458754574487438084636445918791782946842598909064854843208039568073600862520039360823565124413533980668580492765234600905746526338468204183418828691587116410169624716899406947165866336582654910638119433469897081100329916618234408915291410360063773879765417623721979377686242861657844602397296898607881848910938512269919531855497922480486653311811248022415772798189471108662611248217274101824539210415244984642003166779616904774288957798423352212268246728380419647160759388686249794821839653989e+02)},
                                                                                        {SC_(2.04121948242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.24300648889160775733156586874062402559880556987666128229130787172756384784591504451441176261124778809418081011389957060502911823758697326486324714485420170234982599627159886305816768959504352423650548150553867255926100740917589751743614355742742796617781398611941865255290481457719969272244034198714901317545133168652235430290963725159487045543230285846840648066637514719963010582145585871619341209078028214449667054492759133440212044242066816817432964032357664607423807704341673445484291179983839334e+382), SC_(8.79805038556587630088052582151663919186057969932038946354936203032542340040647864004571291189699384354853888743320567469513593659764584967248393176840575903449023484713535440893208588715116801335911625550485476748157992061702657729396726975122868327645712946965506515046914095427151197705491743892127434492500407518742269514547233097954118003716030823344006660649172687005451703658129727846843123665183503658207565304927556441448742317093787870842638508179717650449751055242144586848607768594191187785e+02)},
                                                                                        {SC_(2.04407836914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.68365143880375845489319696652162824419026790969168725995329854655816619705820353945636910161396447037807847037756979314462525154016702465684852901928273210651067121172463361882515619106014927366661810456400762814084404469237973116680959859782414407726318096421007506245996957000966110130380693389724470385756009610930429325363910814020733925930697199275272434532716117892373776833014261671955960474795544134737715622412344108541340921131232780280256722975350906058098810706636246354999685034963041210e+382), SC_(8.81325099408857538719794037035613437585330054911093644104793245532145037979386327754393840465268689839637222786988346357245198697929909954219639641082423160327772397840576132377955217119504442031191931892682663926226123518747306212014000292170698456264499561629303488314450881147875974120370442892524806700056609702761641793604570902194608296577922136353429253927677170144185836055583240855022684942918042987756630226015309720119954418802506551096807114871722371865431716271845514419922818181405815712e+02)},
                                                                                        {SC_(2.06032592773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.23368879335110617450934014357551697493657637474750402501378696069424612949874139215426421109377131362806210449292180891107227994521619424226713921190507536619922840775083365490639223115181808038134372928082158899059483109948141228058173117784469588559176802113041862627892225932364914852130808947901721381017612761142108749416421802877905190165205282158232272203222263626744097879711745143341899642657615393256170649098208261844829863453807824232217972322816131557985205787917544846401804813255278063e+386), SC_(8.89971469422588303597539528396622584243324889172625081448644041395296435706027612236208502571830144856012771670106672337663679837867361312253255450766285701723474070953793205635315484023113670266674530208759732278650290931173916353216486938355910583143339377937586940163939654903232983739892854298177296720683838065873111881527094988924866455176404496696390392291939407913753835567327579675847802887023575896004603081072015135418794160903940531376215756221420891521350465939446212626450156221583224751e+02)},
                                                                                        {SC_(2.06764343261718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.59483281653793315561944849491802753020517966058457834599780385791671309293006610807112421309007905050950708789029138545321974655614863962614239181289168476368664535037569185913694830534730728853128435738757853396683057364465292937222014085357698132392172515202262764185474647295951255624356377355691744757242649686269646903714536328284782282648025847981449792419786729583440047926271659335029157708036514607118390950018053776103450511487946355391507820701395254860917250728802107678105122194718873445e+388), SC_(8.93869784995215228079262806213738653881194522856027295897307425852239282637371470148992469867322294921829416199244009443917810535291845239126405513404505664264493747643656415802763765640860015275765519501138818763052060049394196697019463988785845282941765893749713246179491764073184207605917045290155137796640590841319138893337388811668060775160471777135759511154718236748314424006758454477250378392325844747846932379992953121602403336808218538896786533378978074484136844477003890524066532376562323754e+02)},
                                                                                        {SC_(2.08448547363281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.26956997938305885861270864992569317634696139234148998025052858279502266314939306211788246505386860720649744516018360473714556008139121829799827022035868102039512241534804171999884878913117696687586248399361631767844908110955487436936381731764811563311551284602425568721570345459759673678971708239163298380331804714768570771197967809270274107792567445801651493571921093538794581945762275991206448239582552434644965640465065190533877901669057295857711633075061271687035424879272346906130060539747433414e+392), SC_(9.02852034697887876184918228950307567210157592557628151025878255337311450794208100108693081194904407586026536627544727891728278559040733771924029921633852777257177574015107284060027121116620982034943842773463671886324211820337774514949846112830989530858641312660736060185766468954284247723301832207041135655922293339773387672759884091687157381626403232630411978395212902188251538779356595094788517395195404838946369098118091514912829187878056761189665514528987389683561188583781930796488958328412937449e+02)},
                                                                                        {SC_(2.08569824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.42541719631346857740870277123179694855803129369299265326895905117967064807970012871120517886376749763782710626876870377672885481093313635938710880192105923620214145310044069994382837658433882697811138471623758415092742862226258875051288635177471107853802211075144303628595023516284959320296001584682085142450298713660175675155635096967704984503105572988443502595645997778786490670016943194988355931481999406719595726362875431386156523099995500516289629399041523024905061365248583663524451744477756744e+392), SC_(9.03499360002975113924127787536975190922985805978380321920413767449345974971555113483633012467505182901649928641087356563730045483247025979178309582017111611644841654759797798030326903242899411834831296715164979209026986975291691071332970132134487130379536819919131162781313226791607387767232186193852256361885239373630809541065907197501412901447388849582877366354207566569900259450804692461959120325998443885169459378332602861106681620963700297035545476682004214466892696013597953569975032135397171122e+02)},
                                                                                        {SC_(2.09722961425781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.14652962119388337892013198073640426716305639367752450241471157249056697505893988153810906568815287379831847592053103240079064792147382117734220104623639114546077700130343551655313649169898489163601042726543497312643959127651877930806732890695009786746063931039887597666210573903294917932796306597253333085308243638049175288306507188385750785364337778307356251935315465638257026383080982013309191395360760465390522476476099715466350718635666319205450199842162724646763547637750632154397143992784357779e+395), SC_(9.09657851391821905248288764942882685538513662571951847769716820430912247756470790243746847239095124383815835596479449815020582004140189922425425031283620580448587760886237528677796437754229866945169284624748190052228864075627322818027343673920476666737417622900906394272502941687757361119603036594805014745950910910766067489773955786771882150998423994134709516232251226515884926278851453839221094787787299099979419856861589551046877849171884303782275573517477294988870970492657537365745908068261007786e+02)},
                                                                                        {SC_(2.11732238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.32488995415917438816245506428540358528324936567957143982831760674606946553953675306132781410037004231238081814752827196659137560785635734654175140548044178318241202722028415001529397684081678940287843275647485327417144964558775590245040343274449146902150499177838113830792660215510801705128411775966433381848395099119531574166093829984257362521690140511511932481075474797419275766050042684668062221317275299543262897442477780881557903915077596028239618806682006388663897431306500641386797547090183402e+399), SC_(9.20403844150120573323313707815163443305546205415320067571623368824100327033250751194469692254021552989334996367488215687821238397209667497882194615770114336746522799261295558491608201716982716372159403627607969448999723588810214131748191646851044970099179978571661008211099865472127499633991481335788001559856818151278413515253321351692025407909474976822663022532537882785669403146380015988041682400534853239853536212974739476804510190882624962978418547837129921262021934860580164989519390697310987195e+02)},
                                                                                        {SC_(2.11813781738281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.23920584189995024108264108441382174581265804453062813967748668597256409290502974917476137156027471780465593434860013512747119492613173661960754556516160997019902325555815105747419678983913395074928383644967234257838183275035853032575137406106812515112775604805291988413086204754420780480482944199551206347499915580094617570264013697766220815619765354642349849162021960389633159121121537405157741736547422517058981713142157673633132258072330362954492601218997356894597490305064009353895881811467528561e+399), SC_(9.20840356065490710629576533428590541960450394297627230852765543314970889049841936678028766187208171546118935983075741374781610923342056839795507928070462593379515984217461275459087034547009064859148045673345196450051882002584567424351090318723867657323371007389165943407650641784608783008011565278189110651932558434081396504135177794283020561431248025981650863165353138893231401452644608333762367635388942206349013882190654054847660235612322249540146064263351496142260634350041205519501124636723775814e+02)},
                                                                                        {SC_(2.12196411132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.39177662229322494124400957157877266131759608311298891642771411182793190826802351307904756477752153520542052784335006734247061055811432642361807977517652673301861483775140119806808771082039441626362631376343659659259724670152753868639146792172739645425843863887789097252286610659867762024588898509234394082610149512719267651794857006628731896773297856599527322125493409497626506094744204938092978787264219579269340061828050172923677638031779966934938174431159781840598119005880074140411916588471617699e+400), SC_(9.22889049459021859963844572074804274810255113529432769562876841607210895116188455115957990182798402004805192186945959965271951508181947270887520970853459793601922584925181225502649594599989457877321892851918600713516779891126827964426645459261970900590176714052451499186326997576594703757359296902179990814537930932453088854601105941403417430440813446008398651849554675102641358597989457375238027473273539076645380290336618043735613466626624312870277349273591291273756709478496959113455072539143305755e+02)},
                                                                                        {SC_(2.12809448242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.70512269115220480595268166531904352330325624791948180356089462647029563967816377152402283553934239754650685522277228585644625963178763461985634087453147507811114399074328277274871421586591394470785652958672442638959834135704467870560725728677870824130990742889477006591329988329388252117288312122037798898578732201281267232366839955064613395628426573109236844150466518272035619875710123316478993314102668129146726093936227472690943052588213409821894956523229315194926353771521764680619545709887817943e+402), SC_(9.26172844451372937297926641784026202226359104984280333952452698885319219565673961992023323224824423511104995712127009602644669134107563593608952662089744340116726101916009626869561136587812837161535913728799259903703727068947653269625719104535040738855813391398842607276573678116770071684704510986375303525438747263213742506177441195801004222400449169302691102086787469350020060636281148117220895253291232844645330875483628172902837608000610315770524202905690307051891801412619078193501905572034002345e+02)},
                                                                                        {SC_(2.13211120605468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.46757388372185984470723464446322922520183834526808381421853345527729862197466784520531881476984910825668844631053249610923109221356654860758105186026559709364720075771750848026506049938609344217127328450666317508274299208718967512572523857314530499456913380346599284157285384253800783853573460804014106723636223147893218665477293263747636187504707811864236779539466966344221910542064312863330245248401392068608381940688389800794655272596581525021764637668020427619801544130878801457932266803401126351e+403), SC_(9.28325403094712022905598205400455323055353530786950080627140655188919001736244506717145898286392584993526261227225187308817678445652981064028338940693732605499844328250378404504032801390611492495535948165817111599938819106674036675419413622056749577970342306044846614268964535244852796128757731498526010730421997711673126579581404924185429868241464395745125993928809118163995543079031650433152888784038925239661975011510989611970619998749887105771762365404895381271943917487402653324189249409463846641e+02)},
                                                                                        {SC_(2.13364746093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.34373636673456515296919127535191349632336915520195642625772798041190709635888287621532647756849280277825279470057062295411472781513494370848467106435282040187692494937120102034139142619940710853591531853439352790300953682922617662188819031965947625065863054332620699152572706061943024843245116280442577774550493173481350989515591331175723347933472804804944111576288065111769983720113685823120396444568406922629079525399967352647863168336447128021465823501879806831619694844779171382781822922998053554e+403), SC_(9.29148881331016017438125891638080018212014292291882679200529590547832304567407184326223596084425686214714986231588578418364950582497062496719725055467621486059207426245249948470330830748203915880625660889547495905324917365284070816415130302032930680680252804195125764041781628393891986449221487360280303514405425381004316480855668602480555837000785595641306828033161731966902155019310529405380690397905678939260016915664078410971970917323430108482202101652422307680513973343390934691531297189839502532e+02)},
                                                                                        {SC_(2.14830200195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.67256447103681992846665737465294479491140557774185558872013991039590161112369580714072727841283114508955245900514838567232530868287689391415360537590686186225366934252607935247607692237346114245242774424129283338340912041906662429742425125240009819454762156263777660340458616775163645203995076874546913465866349507299464269295035492256383237480660937794824870054357393117651593429044017691555159483432555695143676377015861696977994120698081180348729405390282086626734066030673935465537077598305453239e+406), SC_(9.37009712289378842213245428465041698856992514328464053226043507751660011378242955958537701246499474225157792429164668281669766339089933519712342433044104352438802390003954164786043052732709712887759343850099543229121919148743349015236565174499458768840714570982081983359924063622231967320469161737290134596059170102423626835685274301055229984712904852868506882233227515878771133801217376494008126432210768898874172265567661444147476568067640099341375806348321302084885963327830251527427616849254350135e+02)},
                                                                                        {SC_(2.15540954589843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.93991463103998582508864641373133455993632200375224943316978153990730700500580676570675580332397708737392566106200582630296676076963410931095795527671663270455401657747794956074481851286974281894455637980542990782893623962858174859461455913030832156689089788975914341450201015860706012141198241713678732571053326601754180580960420864052353806627676310639654186640023411135528917463407588301019747092967850951436456169284007412270791270032275595170510385886649947458883486800967500632080903173844770573e+408), SC_(9.40825876997397008740718169214925643060875275548222289998742615738079297965310296955213902079748169062362180776611609854642597913581075536671101595288562142531062838748454788405429106350414603053873057156949021832956250130658872272459660462427620450295305163412757457868538197514318433979409599826544160519202163256722145459662877575886036629112345562998069314389977867119630192926097630038593688114768725813003158582062941123230020345569797063986524813578534555280438704685674231877543576332403270414e+02)},
                                                                                        {SC_(2.16148010253906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.02761164835737043084807688662982235295777402691450027760392125197765084121360363895533987597347665898329212674880045433838292058354372919265719061656496013942233619026372895194066349296316449636901727288893036841080969920325396632762110173782177020121048106259133814286713353927137592191667824123460144201495829975242846828791563849339438304174284054860162700849003726441589259832270740699580715686148930618642761973796145981388202692077394044849938524291558363091884290919708442513674511550926076281e+410), SC_(9.44087125449245711324964718946725681457002336914752574180784239638434433261740800047457412285421527739426007490956073668290440888907971364923388038040450732089944005676999616837820395081350030038496820411175501226325416439012012639956746285359687856473985067886496244826541064809091026376980560986751749414294696656832283119146443798309622104504720249141829018011514452990348444644465660497127844197454738129306900700398593715891507484937243549709163813988358176635278586847951067591864723111535477351e+02)},
                                                                                        {SC_(2.17751647949218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.71340431902980835164335762423796436589350350994112072792214738778171203445804164385827969148741478094345925443517347585398501485275407615052525430631963625272970012243841764505731807160622434242814926609466029554521200878574772064056066191281139040442996313225215610751861014869425131528374201938817253066289322132814870942103612911565436241843076514450662026381379893050798719891485183818071811866241701550929831958739365446580273602092936503287791306216378458193675383838809219151103509123255372719e+413), SC_(9.52710458455532851639835038314274498315501215972186403352633860676830029596511878259042607143610127654269615956561600687026648259713548317015317491308191242589764804560361554674638220491591125291771773450012254396706789934186147695605406351507279987276034693925307478989988590092811812125547153934467943528044658158593754520696564958600221972799287132297833915406135313395274815580885467254946870813493050228383823536128439205576179147313077810206988166108614044790010236487489930124166546064473549957e+02)},
                                                                                        {SC_(2.17996276855468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.13129500255707554886187229224041029570439843428214949849750749289110808805580745649778011757392626156241212375807672383606350701411093419389329072918916690387617121971808387005444726650118614438177892597923777144475441198065916783025549180707754824947115518137804797505530079865767199027459482498132114402357141514190576112432658808706859356016385344296231307583552925520220825752250868253480428489603000088048811727519686862608174999989841133390163636881843124682131906236849947330360998589351275932e+414), SC_(9.54026958276930974866786096141207963510282075001695469937993340186571568033819367507207164283465612989883214252153840271538745727411741340941936973021138044583077867913221099816951460103304251072253130282104096476901804295595445398612503617233278249893386418928541879740516087726527713391095610568463469714881207313741822503837317080715513456908612015665137670050918852863930126689754402414644453087641534274015853384313199006755428261671268771821369799195329141474499040909625923167287288193032767468e+02)},
                                                                                        {SC_(2.18086364746093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.46120886422198941176094565575390812993189258240032436842291399903280612691688652521870878527411710319300698338694421827954188059292239416312662344872700594786171809674906839067133898297628838922466623645844692894938719602118558356459692453197914358007351504121151247775914823469065212526339572116621919216307184829717978344011587528068285933875015100214000034281094016309023687824022775549044837455472135657518561532701164785646073041437250541734988572021839186113899968419781789080825966314766700177e+414), SC_(9.54511846410307733251478184151031185470650344379357342194903088885043748304808102474721353322145851967969909882852629598772106818143242169713973570162748400391527590736783952516021674346424346695243891102949590560370125670826511627581419464773259152047995920975025631442461827775898809830765756159112646326941479379822520206359643932720929005125311846665376636941324258967860355646167667192500862151802186073700285051544222028803022755686276279585674275472612395003821390017772949708340236625234425802e+02)},
                                                                                        {SC_(2.19099243164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.09071930058065094245496319664562079255113717209322093772282679444434716466956464796164355537437727770395916936090089222269857365904491254434491886613216692899763966723796954897077521599069572976393753967872106853704538521707960767461481109695537844833766405175885863084650797321337117740541494754684924323503689333664902370956616686323068718959819891317808053871021590598898886639150602749066550286528769125273871409829351057665814458916856560858710544725729239093678663812676906572427729021491622629e+416), SC_(9.59966116324950043746301709963886971173831924283030056135285332150318203910375393754829005925237839246362956635937850997084452898728509824631662233781434620254166767701503446197158574058973097735744336770318186188140114226228467845615371087013275863580849872474235589291638866795385179012628162745789967452025085267379843525230250236013744901475887783526155418739875702778215599395528922818903720738270928962981417436322007321679355490548225012657646778859092051749324834977768226582942177799276045298e+02)},
                                                                                        {SC_(2.19516723632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.67216493641861127200347874593268548852871630014439491996415942153041279169939215226786289608201574099535056715694493811607068238231977670634179134346828638451975784269428952823639868956518158969899741178173624038340036622210995694040562605609640541379819676667055398583577325757720629491760060193629917614248605708364923842454874386649419671196031172536225218287227111727331444795912064143719455965084302879758776249864782510178230962921527551419863483412763214285412435238701301451587284214422959027e+417), SC_(9.62215582614357532310365557514395430405854343037631613350602404229592578489000436551166861196041340959495358591462809081116701912519772088841336574357932955630083399041573213058463639369361474426677033552083021945300370663512156930050060513380077707234067794031787103666219708483240598363402453795766043089918862235084819248988939566391713717315237704138262667981769953433014526496440651921710535828221477319464253494644824502787848819415584580250951534583483743174553704596403923369793145884604935673e+02)},
                                                                                        {SC_(2.19839599609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.37225262707653599653711820353653368292680290042107795549543404450780137995523706257804503588565958265869776422803632286865381333971621580552331042799330399101696279128476684207611968345079835995478386717231086868243199147991189871036918425963831786775382615471035894407844699339741980446582699428550700582217520064182861690291820982938724766185631708141908124286316108280281877499048113512908636162667218747555743344743604076941394277313545374002161667560157713395176545044218642696366437819531115511e+418), SC_(9.63955847223110394389235188267594151754178263699692568317118224904285492248096519957597228717653697302640838284224914466477592933601842476833335001277142296514298191054813024974274015115796967229697533859387415349662239171113229864194230362265528950878253332746404383153621089118565361402590964161957454757890195465653219164433010495228501515210512455114814368619339456463159405016390172376212479239322861777452059833092527450275756275707164090803503172966635432501972444647459835011754132543899603307e+02)},
                                                                                        {SC_(2.22194152832031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.44032262608550903495313976799133886799784197233300486553579224143139553556903624847272076638683768869182459088497481696864297358176383077206958717371353195626849363634979562388962900196036505994767657151750053872585306731106654031487654476647650490389914137506090547371635054136426031331557935145186181680785227757429381582799637850482743930250676439331282867061521315230528320974946749702544505202089729180048458611922316602433935948057076340296214322219855529445898709037420674549154600925080195186e+424), SC_(9.76660946563861461010555925889706895360385538452085228187365134459129072316048007335210857837073714751949133642119138372463788350876624727611896669144379940278862508740728225845604447214346311748388259690873822504933818638163147527164300015506928962779800561757700302703442709568409699620760279637023257711205079507638886106134958413968769285382076583440779626281186698103523780565709021574174683410071972089151302751651383839417241632895323701238879559639015569483986970278258480871461589314159669816e+02)},
                                                                                        {SC_(2.22939697265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.08849830973041339619849880512102258659074015280580181393991109576992015581662038243987459065078898344272399234338807738087565779427641206083387416195456743446844871142780652716783168821917540569775408453731306985285441321115385277438949024832826976239397688820496083049738921276781967448246722442890080168118915151920065301832844367889918254972881511288400418949545608225939548707327204644504068161350836494885138311797731928010526811385937592008345913431320343569291455112217156672641566365009515952e+425), SC_(9.80689107613285059372449543550941420674648369472249828292039754905949142785885007770608892965223885788218745303191118820562691049784660812981229074467947219978885790974253085975473979245632650898788050611589900236206312674843146926926150180087286686402864383874423569723340689835577614487709179170935290493976265256414011971563116125012799652588343350374269900762013290925378701590996729109220525818658456551614163163684491861419634548913453936895204775165372577278837736236627731759811990947945526936e+02)},
                                                                                        {SC_(2.23407836914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.01602641534508128258400950214145374273797050846114242001541284534710542653468207980277399224254098852725750690198614880760636523422915547928831404849495996000800662060445653094965254896675145872932515875338797873448295793020068388660061422362203221153377753128756862647837950009432931683964156189410099104121422217337910185538855320473202311427440306769046317038713811978861575226628070299860658425341993205144141972983264782324488774088125826150530755860120210612244114406558912323853971223086644010e+427), SC_(9.83219734056631214805740645496463436211234524505475410535688867450764188677391013597688715887121794422458254521169369713888832262737552174083801113013767124185581343793696319245352755705382851443269006016905678997236882801656715922216129337829606757125264740764759978132666643390537700039675539669842383538569378954333738842591219063945023136668912312923376846665554737447746308715250063238132804164257172352296735140656470915973499582649443599854482390659748267654064813035319225549619002213427784655e+02)},
                                                                                        {SC_(2.24445434570312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.78203048568578072314975630454129358346597694541867298893268295779312349054115177672961752672090492075729789657087236710851458584409026307715710927531034401281441924823997316505754573561665960838553695186511836116480885300334679016038360405175553662098718417729786579266610185124858219903683024216696158482042037421212370278799528122475509331400384923037092383967020328871785652646339928895909225242591274145726260123768031085217523259780112767159003400904397427387971098997527816604561062545863704335e+429), SC_(9.88832185946077240684590517478819780451128112923953742197222968510336607120384493918723015029894932108493866736441041810700846073361088322303145991164121421652517067040902640800035159265763957018969027518089773608899386328021870308066455195615844063301159614500153922927325923223988512665683867898919540046161912743964469037869808287195463032769869290415963361601589546267939286944320876254302657257848836043740477654481942655172138948629613157341147387125279557708891527067521340447109438205641733816e+02)},
                                                                                        {SC_(2.24982299804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.08570283125744064071408282635378045401241969592156449443996702190835211221986071541294572366818302356541415307755599912973777296065104685126082161106964718360429925262611433859308223046970504685711082907721101589244124275919321272422197307590333345019716462006909782814102785758541341122309780507203078354967106364356788841452814123987602419979869619346935389886649067301781214220457407095330324474516181076545625866257383290602306079211952881872730447864137788597132669824574184100276125868082219937e+430), SC_(9.91738023223958938884009881065376131555309354725573064026172975476434338082532225486389254099218688500604631715941744807852624165530818749931061431911641159805284509729542885397058261027663314979484823063801479848319523581382232395800774141541503586885701947271915541461771489709321299408954375923542489570905202242397918325319450667664823098951604276868695957185084867227098618625300782013524000820771445825352767851760490231492154993825757921566047222920601727369887072890583913275870276765300881030e+02)},
                                                                                        {SC_(2.25380126953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.38397630910989982662319897199822355262622941453933148710342334376170037992638646776455752933851589205088581764884554455093887374427845996862764155987352260193822834547176833268670139068679454516574156176879380637561952215681621594852800964810550559095376156580039180603265458146069909847122696205550963305048559966181875267238018292624066290913132691198433801575590704690978934726613364622856743753227525638991659655514117533570607962282000337241256209304615437910334310799421201705149490460361728658e+431), SC_(9.93892131226120893153528265293455417907692711084056105978330316980314148928761315406931894573674925248184025226781657554740201804246189163054722625736294660437392216588384258232617470370960400836719517748314210351406062703736702358115503393330157503550095174818446533875843065828393830314607111282496509861162829462009002548666854888549395427924117314763624845814073318211354521205215981882366525078448830967768959248245541473022064203770291966690333874553467437510022252495283474042268962476720672426e+02)},
                                                                                        {SC_(2.26118713378906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.39614876650223645360231263473938174402863061383726780064920286322497017588994204480739132264037264067830696295448505052236002652817040227065685829006607407498600502402755802165890384784931203281144550189885342738249756625413223643747714766123370215076755139577913640129626581145595398520375687222484506015632658050093276378770995676010787061717176679192524772406173203270747997823823211655490660005386706548628900207447034920309691242233987394832471599241410916931507071430774418976862458606819343979e+433), SC_(9.97893208034272649735921917255308552717947660761572427906739477910025590562822234904801165366667272410617176406496096031979017585449995098746666193751751704798263175479551023650896948478300341855305364337500163511693100633296716081183263040654911725476599269115441947739032989735343050527770531009113636674631594133928375474154120689814396987658381155565472240695156861646528035166405447476890042313942613111801777675893964149206639663651050740370795921499376283922886501627029955337875033089310146943e+02)},
                                                                                        {SC_(2.26405944824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.13646636560202198632099891680664160012426117926474512793298011866742557967962503462851801678601440639983785150487411359283183879485770055012521243949999488042088058632091504968760071183881899500499054311870097656885020207776773626582838277407992323550059821879498980927970797870285566527105997224181161537398731430198676368582299493467653124665022798275826974277968868235120389957641081271455676439859708153575229872144232451572457106486921328919966629955489765456656814600779054117312431766562222639e+434), SC_(9.99449854128569500985805506445224310036677709286609573497683142955997164920503198575362404784244157536065579835245612214355555848464975016855355135639594467073790826784810797346580125716082966056623799334363918073005591302070871916300341151412762306056300680129128167620210199680205983088439519866540199283793059342411449554638506634701866889380956798891517235822626677959487715208563502387089202510551655001223006521405112790658935808977694335832575278466549610236022748058733733330424726585197232068e+02)},
                                                                                        {SC_(2.26736938476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.83592163442986797248261489827130287085214191461912713722871756512942719246912971920116111414598328800132195109536860912151859983913755051117782302428690879733698225536153593512948050079777922978491605603344718815607149738566040626516318819520326219556183342036942846830134480193107978612564899303586610863384541017906185443789857663780749213169459547627352946245307698991614237316373854125626280241550114161410589975426301226433861910160177253027795524092422080333128793772423986098232596794075720037e+434), SC_(1.00124412166094487150595607398578415184286075429840017750669615166514802670126613942281835373480712693905021482183819887959841186834703214515453967087624374969833838207138357757837601033364944274819528877945665683525023273696360579781024258580591977130803459724731797835879337586908909375561106910629402837014768640173780750180259831466071739462689187458769415107681151656878301679976405020325744495319201309535234547402820679715200331411569575355353298139875377051054506410704721362118338961805382021e+03)},
                                                                                        {SC_(2.27160034179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.77914060211452242008899666386083052076020460649670826869818173953950212848789384309231914463302618136703805838586907800270236441286674518912496507264566775291438162369972641724026905411157420461870414122134915381812750034680648205729906304181318950476533785406078983075377792445976966054236115099984421563591803655093310255335344650795645446758018267005460249434136721239530111153839530584353444102391832796692819618881695984016557439167054304360445240739814704554363517548086200274977304840926256782e+435), SC_(1.00353836579147773636635420989355151208877209533358027678391798050842251076882091526102297723237485323576782054389490788244017367562953521735552232493327071868269081949601477850110684984476768380792623135825977210171083924553780077721841064428303318039606573944924108276012682456299563494701219941692589092680383521323267997227110599698236865458718055683583909203116080409976568849041895018154553004514259189900384004033906605321463098090087570613086042469005894541726984587197472413799479116601460397e+03)},
                                                                                        {SC_(2.27251037597656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.11052867640829454453052291025757960658413543076952380042287916481944028497762444930919833577206505780772868134575482029270280362186487431352723467266851681046659447223730372445397889620596241932010006197386489151164784203310997758817817055876031118766037758710082090563667423346596804851090856128402325164481953294532643117595074818777042264904054121835977363273899344512211175338061641165997292239896036240484605727372545714312692538576299824378621263658983340845164815186123901327436453302450869458e+436), SC_(1.00403193673239295480477602366256121497447077097801182886245727507501880605751496118687196108313777798222668608408777849907357167617461301895673631721072702260667937113872649674371034709014227852308008223979686762780850903215454691388012863664666009490326014487795233371894668135247672648098633958365917296030831908135942177892329974801305128955359313699712818720289855093981017725188789621063984596937521427893485891583226885884185091476361258699871312799317001155755187769395027893412340304105745269e+03)},
                                                                                        {SC_(2.27322021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.63207709849931145871225054785721944060815270545810286089969977505335444573747764291754041567166168909984072499145929255553424803538289854369237713214437709292943536625316190051590509936147341227297889304702762825425433706691825011136068978815653313674255578440420644981144821240708594519845304995263875525581279668909987253339379751496898564952924913409885321685682484389724063805788629863604220917361441950073224320500683681966042090169252647631221869593021473584674311386142486001635907899170124315e+436), SC_(1.00441695404255749750833880843462991068907929587087287878830426780880302332327714066072448615165393695871343789747137099406763660160104408198664809359011139454093806868551932276540681709449766166108503346103751510689832411644488747795814493189289661475279548402061482242873616752441433094303098293394131241740743619715423845997549566048204364866262963318775358123150746620392638753760626010116854941994154786213978711089846362617537172516298750146205786559079059329703118874760423940968396267966798642e+03)},
                                                                                        {SC_(2.28519348144531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.08301840514189880876105210433783730639445773641182813223476146240835132021036070768294989734279876868032148176204430975964088580242578610006274265663450361300155589203181147268538497466525568540177608315212855086785138118570465995366767699292934688282954532312338409594488220264594071958730820220669923128699007881170366835399803417557837301229914738094613784511607844164593733785050701172328912361185164073841579818636273938874589893074550582456915009413640915720313394235265549792227627841020848477e+439), SC_(1.01091460778685136004594973927358453027859253753186731137911366590667427721315216232368931551505274753105674204239182489324570562749892472525571235183751396474083708267602945752573711840268943129444049648503759340713860061917873014164073083341241519446029558416362438957682096199098251924631292725493699838897788658879378577003254305027825024933576706871276335595370704597547489230084515007724277840276175819764288903099904535675324716935973817635743016407309828330516258501329064021982787683819888812e+03)},
                                                                                        {SC_(2.28726379394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.33311688436756978135668900335799951782243083616744817272925412955790668828317289227333073159665410631743395710535180479105886706961342153682055846567446435932423241258460541837360220120837128133247256439424960526881892320363971573205921128491823460172368940613044457808104439560822060067943968490555424906442156565842835604649144097998443821698985872242788369101897121425359453111909831864464469144725496144503959245794020497640252299205666690229453072788621622430551750598503005751988610263971997854e+439), SC_(1.01203876369191391397537008272298388839527230538744183935448891596555756547106702370936403620577459612149080321626505005366386360474333663515629660404711227146888706650007392058871800825243571188452543934339499169951444698418581119928502493208009552933987567068494616176046415894456738453361351153810609329242330485851335454872873720161453739661096346027323557368554037728986429472462030061075682473358814842217702848228898236042470500021601695060248893896909101571407451236019000869189944883935762699e+03)},
                                                                                        {SC_(2.28879394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.65135831041580457776340074210651301162320945447995180897277995994680734216778722114489069796347279351480307803271876171024271448087524642981828536415645430827293276149505557939771406156152035527595413645846904431772492351262479410618119850502260548624885759325692799584044895196359964192470904833213445823262693397368765103870015980883032125896055872150860625736736260444796414464113416970335338021601052071391183889674329406648074533875855540014866492877314882973740174337174058595492036012717678505e+439), SC_(1.01286973901338023465149992260320944767495589451801280341721538674674441760940754891147866157152411375926525316233491535111651170380037233859621103603550695028573602272014224950651686839677320052003641472720756972039317929410042788153661183364726698710636237441430816782807753757609306725639743186114505078794658557227065759866527822826913600964425065939668093305689092805427641579077236082387589576411551620192019239049409819646908724890732828334201726317266119543502185385568991048651259506849007710e+03)},
                                                                                        {SC_(2.29125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.90465795226708556790017669054239224462354429269807487381265966667017548765980723649772797382681027572603162976838938370170818237436251860652000037925826387023967525363791818075226631289162523946339656863465465820726410948453526025835878642915007697195245134620901070936241116545725978462566856005447431730237110518337994080935190293503851444586655133879016012999954639820851270960695432912124491366367196157476373186099072824237976487832801731815070844012065376523608002168148316258296433811753560174e+440), SC_(1.01420375655626517600958716349442133696717847574624546733629537985043871004732049302197607467630694092273058397712207234971393351833901802132958468701652523758663869773292490943710352570936196911816199608025632640693494045837106848016856502024921906420277735092593879433821241801222686972382213994884914975264111441264758851183858195504386844166071843621593620204626779873388818501911290288524863961605511499951632415876373557694746845507515525976867337733345722471269029243915715912551704102811046404e+03)},
                                                                                        {SC_(2.29655029296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.17328599445677156474744540820672325827503902812352631148115214513265962946517542218220056919226266740807495223944787036752065838381374165589386700202040486455853880580142280010396819876123508311556392119531308643280503500980721984340724405123823704600058529878829235661139836755072061244752119337251084892224874879871419347360822727614012404366318296169076312194398681835033319653763984038215775766958241930120997208201748781040464994071186937000864444561568396233212623345228013137366118153649313251e+441), SC_(1.01708353408586320663465879346567561866010735047926971925795156991006351710901470860348123425169599299760458061388919004414254993007807681385496615676672852523516793999597100430287717602574910173941843661595774649577160012203239954479676817977334225778909099418980035309822175188813783777412355264521912530281017758596993478482210024846748055051573736813430251129741166161559839975886738148624765554334431976307623445065727959659503883665121342481570996531822289700354917381018516576773110305371468487e+03)},
                                                                                        {SC_(2.32175109863281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.65028582385747551520996069756490353867743417593138571380490769388198987629714626296717715502866244782857681499028028475966556243813924992217605596798478864360143613600787394349911423257211984469664092217739322955802659803209876171687228289703460196056997651405936184394307129898685842057522879290243672155415398832788162325527224706012592857285492726653693130611300664114986254955950091041390482149622138175561231786819467645864963718337261068245278972211328859600961728760606130535906275048832376807e+447), SC_(1.03079246525354486785673682028102788701570905025091920733312422678260569871283511540662885611428562553382152173385583541472628763740119308880655804360319412568333270266189931465893739996002495397527674848101768381622086371938982695825882518212690735322634868055443393525803981229436585770457381365370767557747687842528234581064046150197526489643411458761621755269420572575103889832653490580441691448344796702085985589530834547695229366221918548114968201850198772489098827165857762773352153090225566242e+03)},
                                                                                        {SC_(2.32473083496093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.35632196482493355248130028476518084667696749878269651171129987099594161236188668987303893295652773972100940879650315989615357005753818087230776696435556405376646870974208936505050108433686460126934829629832266043277453245618620153658714594999035580638727376349710271139659258631431162309088695421077519683884996781795612158187985021119102710380411466638652939872592904181488713684921194827217543223340998110582417974894678896740301600117909599159858363961332219051654706587914484217666688850895098639e+448), SC_(1.03241522357518101737393444391104667102143933628627242178063950059276131574433741373715815692875410742508921901250325766774810623614541705119801498495850448015805077412141164707534647750526939066262688702273524609882263513152715082933872606914620239186161457724986127994417630566256744226848866841314795309971119412070383482707935638126112511003037623452910434306386212485147768519672214373803566820343635071623058580807115864223399827223937207577555928000842687046934803211548105541783448023956266920e+03)},
                                                                                        {SC_(2.32713806152343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.74386328860427139708480522709140156717097295238476263352838905519290853840258687894960348430780392594627170267325386390740490356736554197674894265704099376693689575412504395343274323240660516375703433770729029172958494455848327317377274733684576258763684332319067909261279776488142490370393200561272767820315367346887415877595167559105371975031179734689134061166583608754876775899393186872700984916001642565912685865206349436098463417611566800620904270839696975574154553405606752106422399839471109019e+448), SC_(1.03372647377720390505312461302837813352314109798958416942286520193263268408295070236735892983497373290409609004357017411946557572785522222817843942888562928412052126206322203596191617395362584494214019632663234183527699317139696442854387213730216677280623624507835715064537863198524758711783705028814304816908466887716821972886975156198102878057331998713435430259154109378891515830322267984193884445950766698658585746179858080102463878140826893562429018204866535312097414306336382208063617202539585253e+03)},
                                                                                        {SC_(2.33669311523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.59652230251173342436961689893479071619890832051987682509430642695276639519037742307108764387197561352113017685797688723166487965840386571091728724735963038772103347150810040789916987763976893849742303987555945731072512633613678628685805045698461098106633571091993892970939086933041705624680677838363464668332065912230077706640741447662546088952351730357285599551928479725877541554519897435934938643911703341693287057929274991084144152156871690324637742054897371502532209347255792736638275100784415339e+451), SC_(1.03893370464301812430270273797465443931621589838138001868725539378103245226106211699547624384358779493645877870879950332808476711355159714356127393403248642378213421767795909018688531166529087150824647243498932574293297756523173218892933728579129063958816615693509083598387560219923842940734042656483848413017749736555970446860201572396326629555598835608823615041170198622695968531218784313159597703450018676131370651500498024234738652202512810860093984188364583869338612575330092237235704879515985780e+03)},
                                                                                        {SC_(2.33750122070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.48035542212848748580951456739669118165445155466209970167021107325238198610828827210753611656639746672855622622667573120453801965123116766927533289960343425914807596098189017999233446379611107483123125002084704957184911538582340318168891322148345728809670306031039007532257405968346271664750720477702330999158462667072184270366540303796364834639970791998331915172645614748307729400559386201499163395160431824570064384505391923680439672678391435111828269975380391543551347248276222927047295055329529459e+451), SC_(1.03937427880559721723875271010291664425000712272482747010822303195021385976486936800202960953254150118444336648337138094881785710635932423121552387592325915868032769800362005114311906889861521595924019898210225487486479112793560138223985653696658590301672094662632204539014073516959870013264928770396089685081806702343716357072165714374724696550546140945549149812149654680894376153939404835299018702833912826918021395290784058715404305726774458550537666719274443149307309115195305385504288343493217405e+03)},
                                                                                        {SC_(2.33906799316406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.82801456973999587757205068171942105132180207403568346005866809810735339470733094874377357719203049772673579622321393451563161678435517446669340532686518850474088637061106219503285743890806502286639271864279715100124758920673787054001880755387713460017747265822416656434785819729290755654738067799648133741584907451376231156918405325219771194528968390017849768174019273636367620581094554885412491341496431636058342972195907296418628288471085357048655824569086171978507955092816797735495096425887045867e+451), SC_(1.04022855332859982408415144993024946041011174818687099670272097532904899371291592732450041149667552397760967946814300639448342297729566374160248868428177893306089505241287932322584962371867294002552574092352499399398200413445291454849585896947462797919655765101601678062637862099177449092271828482862475406588574579284971566927994676631802988559874214856462747454011848999818038586875775249135149599695650058521244907805686249923896277154594123193736501988709962120662283636690634118624488957543817233e+03)},
                                                                                        {SC_(2.34068176269531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.40508904242176682116449042514135192129185300516161322566680256906472959720494286731283494975892497776007252984366508092626976683330922807310355867436972081605252190723925418279096272760501795732507173163164226107284022502985421438594469900518824723328937339071511396435506323052491106349230840389684572851957126303924608861311893978012477014999461407617992098219307561041406770984279722844805194001040505486287039050952359443948230834932944819759102109332164838256559450378885359575054433390911366005e+452), SC_(1.04110856270947538101194381180739614501940831547553767910940055080764751365700737334039050520215368295438790839219465634568043357435916437266102639570485279489511205375723738730632840611542004733804093586005982880832704926103737948659000585902591150081724989400373774302479939421280720081357450134541122020935778145630254133929893066156597291486410214481515034569493052557427604557399163276974463797716814061123342134677116493289934436571462786251114054111021383881194629007725260193971237581972192174e+03)},
                                                                                        {SC_(2.34075561523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.46283464171658205673359342187410672824004419696515224137643249493846938374856642233113123504627716101170415495851268629054747411466819072270070335549797785600841880439114525219359795424265817003049954995965790925720619329988435174252153574355193851582031598361707197363444624391173683034448011338759118721330089135315122899534041971055957544421727740563680746798981962962211569590141183476376982177149866375324652933807007761242518507116163066356104492152803643962684824082870010205524536918328580171e+452), SC_(1.04114883812210734373940955716284135535623863254266114994072198399097755575973112137291926747756853106433221244035373782860063705460590431606919373103448643022775888364716485397546859370263675645459152133303174900268442665963271610916778572102610236059216548063098273915034356448502824687565506462661829466649709679761032614191470441920400028363524714808970146412806337881027809064218517206502148220953690841519561424003781360750298388718689647519476416924274628377934089876068772673154382308558782929e+03)},
                                                                                        {SC_(2.34572753906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.20287125067750718079139615179556149905970705737477202140352950933804030796805778020319006806841535937503813753291900950161423130809793829384216797437008137559874967689299880219915847099302300568176588815959888493888204101039844802309440835065942104357220354489196452767916876269412368577518051395695112924365267720945507718005081347987857139692854851937255638787567714405483457942262895187880023159499253905348472908693377988626310754506957615323282981674782173709961832035743109581366596396000766294e+453), SC_(1.04386080874969036801593481122975719273903962696565461185917306643059214852434892615191390663512848662213942068030645143498132360982781771748445235081671909769892554624777006591416892897140518753063119446522392570255162598160952720607925871933199089741106434900914023889219286870930878075220379877321240091849202182599462305189382108479682374213663824792934325082794309818350885816900788616869147146420656414455017195270502741847894234589091567320551824439360401139416133453177107485446208463479050486e+03)},
                                                                                        {SC_(2.37662170410156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.69588476604507350672186752288406627352400913055078408716981871368266246503967469530145974326225125508563872740428116310193834547520347257459038069974561536565731880187322224898653241935568316418632480975662809938034805555067221097564206199023693639788694315721481233294887573640242872312656226893068072414074658464079012129365543673872125822028793450086559970478442297078731733678192698753342197922850083792015244154406863318827061756727188665453791424919024617357701152260593008876378756394918182591e+460), SC_(1.06073582932073893986121819132589284880939121012423411497232498336652819995603546229215616017202919646806970309001181138023501723142882120433469844760382028981120858943613690873484190846929999212626727030228784547105807868110135666964008269575152557091851566554910308685442302810215072724949067920772200007993045157033316185171310625916442647714396076525031888938766630589031942049654503222125110862347322527744114218543156807945012208393754490691843363809339185569868911466295843368629487487889402498e+03)},
                                                                                        {SC_(2.38079223632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.59618044933309459771629537051242306454762477378097715480746577819101505814658760309888699851098124052209552820566129110212081322845191298552461829550023703174727923743890160470567654429821301562819348623836912643125949963952210046866434314885865951794015597027784975902536269974801800646224158739856412737924320313251888837608711617918676184826892515703635752955459512440883646941733927187229956342309875581212455839337808308072959797715711242383447998902505463971959849866808546389345361739978148640e+461), SC_(1.06301695349172781050151628847925561848956764577879967408325982564471939300851272454355600376827087190085627857129662149802055163055954305615719876834754528451285422367660868078171385746539282909272333651366917086823990743687477160421950231251969903877847305883867076189241054568971406032066273149639388192117482419647664014896025094675648822702834273747775461229178334364634670554889108199859490580553973780787630501279613967857482286537056883544715806462908099785746924126543990393689028100842174351e+03)},
                                                                                        {SC_(2.38192504882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.54168175499587073092180520329596804386627391353583263303094023552062376906891760719594234021057259873797695304492667084786828702680774484454771280201969339152006349027913918717203732359785155603647121841894949902238491358184724862469635770671456804740751709698752857245792952692958167870994067809785211732890734268168709749038686040288695548119573734834741760173346998233828155997415833994468018251961981546305932305862226556095018502477012950304314448062794909916360185543437247645207888756894409452e+461), SC_(1.06363668578548250370401252795936678658214146587153696818905389730130100860689831859941425445709214080634074200123610199460512146443301473506822773406672518644428697261299923967031368142897366971037645480512136567654306928245502642527004354203279461009930460943985372427662669531902550869079353228012359246056102213119930261765576845040554072006843098564543925310860540263267292346640960068014576001822334179811230372937424239438270029449033270833514558013170547162234276094554904595124327979610941509e+03)},
                                                                                        {SC_(2.38285339355468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.41947397118963617314788755637586490746572454896226633465996020682987607134116483944555498871433225886651689753038477214838858830924218287124058678338088845707104523190503118871654384066197536681461587863450246542829770363263752298596106123095264963271487497185615800319192434155689153810124072113606953587678619118880329327789427979226603186706909941800117908967798427102472909347910366348048511801362295937601258427254711672197893257522736007583671610268498109326859949487563742610128940397491404627e+462), SC_(1.06414459932340718276254844964333733628424778769854642604502015112233072895843496897918274954904315525586616858168575274984910607132443555116623755233506606519200681838174906410790930968684240895745920089002586394197780631346567289638285171542182710036292522114470875839929401810311049350175156819473410738085571871318604415503971285224403504307872198848550092379662069161420116644278008128925165473851538013617353485002911131744330044949423016346344021720680788560292311324809522043915399725265728324e+03)},
                                                                                        {SC_(2.38449401855468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.48333243944963938460038807628141680728652734242529983503196330107541018884896450269605270390685584045655111474349716665525756455157228888420764079214622095351932293058358702487712129858146589484049191998982061154465391651183192758265896560986975716447245342173644905863227919374482325681486395452150979168995874742224678343035536509001689835933775231898125270451120359615025467375314240659842248179191424322340144486882212653879874824857998197970605647601340495582227310086890254878271533695497507739e+462), SC_(1.06504230239637445500298548527712035599468363901053595843355694420491932752355611922392711324983151830694953190991236781942290030167076003666068983448224125112026026878175583966767564651513079392543162633558750079682061004604189175557534332986159799336667203377326498544563418228880869684058092464801983814894605687842967973700886156083327625053249107724146269370745876324992302075515562943166197597611951013752623883206038944955327246574301159911619035590717538790504354839278215090028669496218534029e+03)},
                                                                                        {SC_(2.38559936523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.37808122622815690500382267097878998873202671046685442784653396143337081057678608592570706493795126392154927007242948720112233181282793401430241937762280269319616797793204397897342957969475363038861577365168816366186542910958418588343939458983916773058239394873634780101047648471639661133358367997072954234292874405452406442527742981415599511950363089879771273194175468368996547944675734246440049985436493390523580066715602232978855450894692366833322734647102955879936879358004621519562816859069515295e+462), SC_(1.06564718026713188221300788798449318822386679631115909377592931542906431858443887400466029853170073638998929438697252698045097914305821507053489106299600238825989467141308357331920923828067422437132050446933445112950337443966605895270715896592560696475023878200116408756694204603869619127754904399915317031123993372253026740340221408263993749904164694045691921290237886562504789443179794622354363137328640326923815192768951334256414041600152528128088087812324405144604755280874532774575173403318420753e+03)},
                                                                                        {SC_(2.39183959960937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.94157018887591895950029163728542793408946464139919208038107596863950722829441714083687636831777205813943883550816030552801676734236213942895231828469129488622190497512267498271372734241655353912289454638756834374374740631824662038440983160832828030547695516846994352199521056353737210131359309268596607489388660329143892165771782457572052944971170530662041681201911170697773201968537217365556169086636229957736037640824751108191430402054974991617792017930927543457126672995400808153693341383139898148e+464), SC_(1.06906298017065378187624790057379699574796094882022841748096997547654221159280120433080931509570527773265455753615325241837047249118641673960630966615848418340752374143544479778090743970295675195405833906591135259210501834917009914510024819940224593740504234476226622913641163692720187046117873687162625839022250044219018455743460108004115584706068872740730671027285122112651489320726745685030709857806650888240277344461191044900007279644812364318130783611173853977564915916670449232336680399309889414e+03)},
                                                                                        {SC_(2.39209228515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.22965588149176883677863436479347098063601506501294581637058486148016429580333788360596199882034574406089046769560689512266958213931179921606214321680718550951158855557957094326401752253776584557021167933373387712139887740399608783535560620660096719919824306142998877127015458350195419957755176242812438880991357564055101611623996309791634738184143468611268765004238420546231730459736500027048766350921461164883247715400680111387616331134653839260533648842805141528698080347847425781597398144335571563e+464), SC_(1.06920133040956932226651899178831678378140063433170676105014975945535835531405946008301947191931154283279937892805815878840500827407033937362784027376567479936168124084428424328261317700025320702773878722368275520967951607263987933289394925217533657502754403110018320534942256277449623683686242687413845378907563655096714280883155894121127292810659928737508254622349637428782210263617211919915908614228230382968923053572998522118132816608706708627636419368172498179970755512087436811012149223971377463e+03)},
                                                                                        {SC_(2.39378540039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.63461988291952864225994067623663602191421327597184383451593828942053451036098732081069702342147329484498920045745203495636876406301906416282879041998359071240498847876047529634489148845103143353711308005345854350554588069697178872742298481923486516611580575893701853113756883215781067314459664603185439939406635958863126359602153526548719951600913660229816848135080377548870406128893804528813003597117460481870901522422075896578188379937723866873740431915974855618157536225920117943597334847302564141e+464), SC_(1.07012841283800635992785085347866970292486590032130157366223234903895565008124948668497341853672145239612551790060801697773393448723730849842221849579781107959912327731829701690060569384960762377536715585087054264030414008181119739550864608854224105461145376575130378766987896347272444288202711970819139827870250265726164033985118120510088470517424190734753160523791757655570320711553538529532632710323455541625836267351628637177586702164245514362606014356078092189507993727668374723826453086374155996e+03)},
                                                                                        {SC_(2.39431701660156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.53867396055322384129488232914025466188733497440373309517782486252619714850055327886426163035942208648761914295268988414701140621233303500790934211370387150788422923163636573186379979212363616183424959345205487229424384610002076834560948561388655982398490920750422073502897509440493515594482913466768255709119088614235011109277824002899721078891354881570180887656136781796818978947996209377914569460272454332454285370991748870572228060060041931960790276358333034863606274148834677200061164484295656059e+464), SC_(1.07041952944848996153966139952161324243402102800025817767865351094156118687619512914777365124438179958233790277907704609382961053311705648107838598705922738898163544660259876911789437818363539705971834315028801352529692294264318469332665195632021693961971710539840417816448269562414199398721368148461849281061565916133828035768483888489411615317067220311570705191413775042769486971819422724652702511400307292805331026316524511907073492287921935165853618049207613131972229451073764106459363046787272503e+03)},
                                                                                        {SC_(2.39895935058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.58440069574079716863433060415505614425792248695001054992436506568573113361125617741080505710931160666409722196210637188289065615828244553129407501359478447712041394737835258206432064680815129181252982191388623689880594520289907379084328244975909228808102020617705819715028591028118727415404627093200583505632221692729880520334396644629277404801609762698874425982020764961452953719532853730335255304997584681802933253940534795961862116737078259312797829485848148571463243429545578162327677104015515565e+465), SC_(1.07296220509155140696716639581772093443397169965248974483583558174561895960246006152036011174855607317424444646458479054017625998172108308784726950437696587884083420633054006725507519193234049878235365252890579007317444947764342402651632392374748434493152421235557911829580866197001662654431022160815169996960631290372264226239871320023503509919344917855854505406637219896990913152625013444888676907600213797217131259342505913976105952930314479063896644806082096327414637850854373415228519407865099881e+03)},
                                                                                        {SC_(2.40020507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.89649718823757400947167077951524460612069569170739924724478610986732054323059049262923936813149857907497991855749115111878553506221462619402833669969186745939146292893351855560996206348889234697487247736688065215920183119411587096419492463789431413669866205678827121112834670698528339566703335928736010958579198829210799654271653874426161996240008947274247261840057377563969157907695123562519093760418451461130854445770752457104931476613410969555068176588469297715515682723988571301019697022594755022e+466), SC_(1.07364466193476492876048551186409738209718738939823728933265735592193249748264877423649331159224627769568207469326271675026368568981774365739915670977530786589394179892817758554208471773608660303919743206731677900514557860817700174377917327700708102074241147868175251517696915049733738343976041728213374667557859050052690033795640638198300864515996594190759430675768272167972727147768409289191063817268205945021688787296404871571373323909155379268103635818844505904906792747070913714314112647577333736e+03)},
                                                                                        {SC_(2.40084106445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.68706908771978335145497419201912653536187825194632165097535475236043557963394839721753084536758345053166882212041647215258832448890646214678813646720700127049153399120304804010492928609325462753341521395961276075108926892547430670637418756699791756760154525651030946861164426897455385903178144514861564395708716016677570811111393049951411930208514784749684637435303949385791283747922569494190899010361625748543158605603674370587879035558450407372816503889721792634688945585092930934850557005438807571e+466), SC_(1.07399310437637022175109953153717158598200508200904978208154121260195712977818631630399426900935494427055182178831447866580572567666402697210381738873289388801029502443567662530529953826539856260050700863085564336238016716473024729408356315992034242075238725117312587052039295391048223523442893809549368471091203199129016405567321764782914135350134185126956493237959734804979980145189650215070941282217344679667446108200314884374982363709898760314475456934985597330611568458113984623669918181477657987e+03)},
                                                                                        {SC_(2.40304382324218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.98379988506134624584554293334006336606012627483173202720669294973690522713177572304694168707406459949265446296998524208404118368290574191567674982097225782245774472717772301332839290622449213487957133087081371198820760622009175357226333728469053391393594151723725413393165786757688131591819097892066077471548298873438325286259403547733777757557043157082065170520140890862301741934782938334333655220921264911228452327010059985166234876779995082414050249291987696141757234529516760139908801481820438505e+466), SC_(1.07520007627782088915699782436285610523850329573383010502659256504687146794475230751227924325397645047272966798126089063310217233507974534484903004997977998846583427673313053049155047015927396972049401157366091216975271099104410337759717590406992188545244291039380522665894882052910674838461833212054822745374761053352047785361998416755664325629469623911698927841249593338616032755404386053212921119186176417863756983455435697681313949377015100023267612639725960334287334440649672025282453011894560158e+03)},
                                                                                        {SC_(2.40633422851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.45290092042270445706517858930954637018954861402108015335284684055533927622287154200369961358224881777399919496725636111525501793489963554569357513118841555869298121393870373678648941324687066893744420374340782981187062658105519368480418752139670355836763277753264552537051454640625911426204994028440408335864444968153088577987893525530695952106855218936088906142519508504535683925692481951242397994049231261957594013192808172290903678160977523000903153149699180047354975260330636608241188832667886421e+467), SC_(1.07700338617426092420360655683716370212100133442920853289554025092105866912032736305524287446942059072340620021122365533451797645705244497213533406333520330179422087477559452722248664993453801786833333880483084927178665861563694223691008298833686527978073987250036184318995019552859242072556251140856415592470963477089808590333932257259883227893181351600907893750933195213601957847584706772825115751509214042479687855350206986519218828193282538913435834812781923710324558728724992140653135621151349700e+03)},
                                                                                        {SC_(2.42259277343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.06707965192344925371397162677896126512940865619524129198376053988071802950580636283161794425288502687836199115252604893527108859386980457600123251661302638968303028713365990799614128517496070368248188936690962021477710113555433623851096004137323921602196764658884601624485472038476539713360000969691552206945021805180549572063814803795836062197874173167505741970459775467999898703289143705817813987926303613057191482659889247680992631658979651851183933690304882341055519698514924982134819974861166383e+471), SC_(1.08592050401186205305252227049854467788866453779727410303235344162755799044942609850759917574063726343195369264571026200029028628699209231711416326192355880978026178354859205411431114281881443861063554264800970587426003157325191648520032701335226655222568148716679403189124880924430337315763108072787361940805568429792360106874877423673351221648739934357265010905545355759831504459830408833514863990027273655666672328214627403178141279175713758688160126348434179960959539992578045180669891977474097155e+03)},
                                                                                        {SC_(2.42452636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.17534614298037142345039474072794647497696754990376840434889758566740309615393859325760700422185944264975187274276221678251846445901506717347325794617383677193930292635564569314924664137782285504547373926526116494078927577102932296955833885396703315241135402451011484656540839764812005017172176813565178956625429875575085260669148326865639709897615495636453077647582700380316251931590038135524676132572718248271200457090571287293949181387998377665436576329144820250885118600935732031232959452642149807e+472), SC_(1.08698172658717316748670683364759355410957402401936662659520228734125636852140668222612737642782068014805017062077305317831951391560113553721854022432860726259611359359906292713160794218426547014373901499615992684721735679759014068037451034041907856685281054083012362210838300218511138876799438302361544441253724297397128578290636884486825921128550097578187812899573717515082635587161840171367822041407730059414135674469645603756294155347743226731560119296989616471054451874695933662905379767299991278e+03)},
                                                                                        {SC_(2.42741149902343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.72767261793890033713582342879738701579788077112133450788635402422551267989595542378170119233843767010110473995671833847169382830427385783099874616214043296727968211231578343013439643264137629921650700894044930573728760946872993793594612026302259154677736019700059131669277019225919605809562944681673683582463411714732539335784484883983966721360030448186386720572509467495206966930519809289988603766588768081042987081659937591175153609021009554169878820680715511157952582546047874695525454598657805603e+472), SC_(1.08856547316652507805741328133311108459071413379849228249592173654082545295697648962569966487142171527958950589368489233562193669286348468590263117513686095496315254550373721483327536824243475567704466296992104689471024583820828327453734111665196157826358004691008560351210986980416020349429176617197355798571002516082466312932251349387198659008274783174241418059580857383921848453662545165049756919518456266016867927855881199852957480701581932966977791110600298286554966460647605864227651410324291959e+03)},
                                                                                        {SC_(2.42920349121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.53201276888197629808862504497772743113466279857008013211366135982551142754132320426024318488783339179230789763582074283483318893320108455863809781825085033351985687373160142766923789148043804328952119961818216374505385632857959777416808269685640550515878131380792531866838773936470948896622365931502897281576409866141191016577447398976611054378520552816163939047214583399324698369172847280593442589174607157816208779995991618341181033390903049574647052471516421384328750846316829073404497883327774745e+473), SC_(1.08954933139224663191373624402730733457145944547090419866603838467045367751592532574797932835457944954526422011372262948587042044041625211829540148410268875546702876076022960618710917472852631492543810552679545678543697576455903935445619223796616816185312040389352576031358782454105047585102933376404231777600244040789873790304251070769599630294575082652813327430711877253661725951109015906181412435940635688141912670529932073988741035400213624650942964235476048057467785727734292766796878737300553607e+03)},
                                                                                        {SC_(2.43474121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.20659830082822807550684162621671242484689725367685698806309531527220651935181788117161449233997312759317999565320419640596565536945722521496265448362031883634996313151572116563625858362959374389422990740551982247108018012316042005491930016052043925455610861097208936363520112103483249651288286282499482846899592608826865439396733597603664674785931212802368771076717041953340816161106811566842209883603837612528826939105638551716536328649996820936321523928280412457356933558946478842255705512594206349e+474), SC_(1.09259054473505185020260148898181799101890053492770093644589558879888631894672765864710016553989091048817273205961860093624982180583460607332174254522806445252745812588451071909896670381103709010753039758448685284652639047827964352787746758304973256731952935723039219875410996554252348640480250159757935783095789835288052595599475246885171573720083904554005862824935045527890974059646530836129165941978331255890016960458670035030354438036004674061852454936042952391002794873772984891769512979230723742e+03)},
                                                                                        {SC_(2.43562194824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.20183637105217623172923797464848997174086992491947364813682740457671115761321245990293640391813511085508785054493124146310014499293839817916212886450320040492723585301112824160387170478701680097002704841078425560263552545088813641594542084519290981979693925736114911356847346902189717268209609703306987517691791491389768925204678100663192557651531973987910224878895144347901448931406404192515698957792272620740819719519296494929217582125057338968893888145174107909888842732982393375296080500940605328e+474), SC_(1.09307434579070212390463170535805904113810048378818863213467969045901282272927061149715379325038509499348521298215151652230004887326191872947747837819133020453913140305285129398782057136293135870673974261164857986017688226208069949771184004151260690362139381005028254664081367364022975748746162913157884385625883666077028737790496723786895885118549491248573315557692107378802923376848648798762400722087762024766463029425455803333519381078371644951888278291836624923756053447624827650934011312835071622e+03)},
                                                                                        {SC_(2.44285400390625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.76686405604412539339661343845758616441052925577958567526210911644354130053974294580554965622254763116679371518596901954851046089478839379935019856089757769537416215481074054367557668496038377323308896774712971360400694072692746824145004924761619270508183207114488008375707213119066484252962447630071449173630135456169285964363547617799892564592692898649897884476943097707995388078440279900796228163496936639058915110372202849596817927782734640853621558576352705315952866622510099846454353115925368207e+476), SC_(1.09704821883431333246878034800913131133004617774237652456133392274541645471697996576787786184156131724914426920347374572715413381334698122293227644961269964509579499308034760939130016407824775142467786384185216359267097020505399225215662449753456672568558196598431193619923958396225496259316083275472599012725017480435935609675108737672060703764757880228784522494341609845875563884048952690812875136063236280669030065004284959365248993460175946184940489450837789168513215809156712485244298278588386575e+03)},
                                                                                        {SC_(2.44417053222656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.70505217151482707560344872388756399027138308394805187822334736401973955947762854604747319589564276506854793958692441633750729878525989640412125275224671557499322634054306329238710314080299049317858080370092529168411441763450207649492644098019508466278100464924576949969538927841268251040178790097128683008741184533864036465320373454339882500767549299083224233514343147298165748260952699007680765162615835008295312794850052062321144867841211153653444320522488018187419379631158239331564040471524068293e+476), SC_(1.09777185639331348788918272466238590013318629710342735299246723455466040107924845548807198614251893421005737503837907341519497482068397078004361309531020459166273788772568115672919382430358447900648111878161378494300520159444389092845636989094866949686312413357276884174317970774180284693716986800797096187980163127206924591208446213909727230018309417417997329102689857694901644134212533436020983025724887211800814292347427750051419458836234795705936034258217168328031894474730984822253622198423502573e+03)},
                                                                                        {SC_(2.44730712890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.19984430794265702185337311741762098081523028079108473148841394181362312227039458196269034918418425270305130877828991235012942340226308355484361800330517854066656481866508614344435151072974063018004352014047903208039592586919540128879448470195191999247855617285204775739238125821232198480472902585944688075608244654414646203243425374981469244192904780712957862108658666171283285380215239244939363534306582969371750000102267330090898441948646706236770972993322153769431130219630190085216838091544767813e+477), SC_(1.09949619151301391950029701805631769611008807262855470222873742389446963187665702698407346027355925707914163363109324845611832638616458910980834281618506832812715189198095906839378587140839475637930705703955932485740864458309356449738226172131360115617487952377927040196173956330961390453788793597922985941602844919957688997866773378935234047882188695886955486341638798418823900473631510128893834881091238844721984521137662584436674499452763698770810319339301618683012370304286131089151905283442836986e+03)},
                                                                                        {SC_(2.45190979003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.02106204698474147038524820492550560078017069549293199948065488925151707195680948651883913102800854671181343239118174750115029170987603798349714984004066433280571146164092224677075143391659389593248105031166450906641965645213949744932246348972143365514093614017110204729888998336406629195032134871831856832592925300558920741295636930261794033998450777264441410893875342827318104090915362249664871589326517510791794741813396559204382660378398493018342872803238742888583802615317030001087509362337208003e+478), SC_(1.10202722050968474888880064215995593379112109407763184142677318641969202105631586870170592026305055821546854216260429646876317242972483104894554438605384123147001152414780082340959228810453386924503798742739771505721596804005351916626174551267059789912776142677129102063642815606482970969242657415622402526470898920184601146762751524687985318360061448522235006610740159558828868956004162656297868411448324293072130029498482599821069779766066458967680123115400643566381137300460459884762483914031653984e+03)},
                                                                                        {SC_(2.45288269042968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.86653972915027720831787156509427502049588713807384140548206034807149055936277513971258726919403475684407026393134105167378727161111256777975926724685784518025558166259097476230351493395673203244939587670021095530405190452611223025617176982378679880717237637319138380855507728364040144584988270825256109859848235931553190263839131489469785119426402499617474922825535381967416304770040184215059668129595048783815231193843315255965980079578631833120339582659051224165256533729464272186344318413587839934e+478), SC_(1.10256233475206431747509830229744348695825520012578348058249577746544275781725989146562524861019186333580363409545874290323216038640277848404846874061351978415170688460061548111738549584200843452963581366737107690051299883448085067024437425360734305824650301990444836621071396666619868718666665828969825040566711951717617737436198630357402086159143736789467227946807362597888350826960054811961623436978477402871717153759169160201862720636297145771214052962801838309044130684014737836400822914960181481e+03)},
                                                                                        {SC_(2.46252197265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.38096943011736509674673011615919808305961932222319258262583119150669566635487276119860709537195546109799159260431275366100571960498146151994729158182304715370819386303096544903502167517457143859367746226625589241588192512253088199098406829707922453296559754998993121494837876796098473959825022556586909344217868664107878544491461745953331538248314157762611033122329751460588143233529408443774607278731112300662480527316225147489103489133744145868506360022751144635157054197315407725299651124462141661e+481), SC_(1.10786621546826987195007506859825647393814182756004267548660323693123339380447008683339135892488131035784723524332747607481952880840029537587194838745950790700568168513918113699566352208858736370252015625402012289581640775846041470738832537494956502369165928251944421967357231818445502243514277188796986759102814465065806239893983839597046751711777777819172965628841918141498876226822417819086400455329187621480204938433761045454329664806456391712777136426361834019662320047971206703407317271604877759e+03)},
                                                                                        {SC_(2.46358215332031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.47531195803984385220259373991263863196139132625622584299388720809526944892459644453006399766745346235189577025111791754660811631605881920043368066137720828690018922395679670557747658688812047710101645315314819931114191824798204539054372323646241621100310942748292925974634391273939159223197506546419024299847343820654771498225336589397096171249530724564793746800703862271358630714796681716614284193641124976194678606406255638866888945926440402096879609886186076055300076244980803447673608525623397129e+481), SC_(1.10844979616186625605833253029253504015354946627663325330087282303836015492416428466451053439709913876946656729047064169497269145569680465765151932617704548890478528912275948615890301795787137218810857821013582435672395986815325923089505139732970299202162852732695774336957942305955163689398891030050257603090237299994409039112842935969574919839046736826971210441138256942972125553484752167871577517930334722750911052303381730436460281525338356651909390383677443569763189492497929048212227813458208889e+03)},
                                                                                        {SC_(2.46373779296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.69673760643584795276021206033535705223188815953273337896454021419631624166583326358966695270250351240035095834418733952817233134677435390604883766984615596611153867054331300437666122626576728397613515354609007712590443749018397601736521690787612358361609603933170074569754443370321961921498137015536480827140800383313532364248611978096086918924314732461789690200115750146814028898033907131724174489068752759467532121110823537148058260538559224656288439428085910830357467392914320088956994609843205720e+481), SC_(1.10853547247865795945628761710077542996121084859000822241768800032208316424503499329143097620992637820232916313097465163950046816998617614602600947085082300024342125823536532903767219924547058423693995923387912473785132428588271542205368801417249704427330743918984619743715945474183650239682783085079081635618694570940600187682735878379496672966389987579537482512660617251110669757738736715933839032694700641225763706175937168613678705451518379268682418215819230946475394437553896147500383286003238504e+03)},
                                                                                        {SC_(2.46570983886718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.98605890905816935902664972585063135495938774365664149844387132247697634154164084544876510822169487261118083307249496397959782219237737663978689185292457683736699829480956647708042231758148347412189687615573222835051653383871701374844130497177648872832349317575163711161378226127585659032059321239230546660838458364462678372266734827883623887605489685635124875492596874688553130430612623073790244658384024270838282508246832433600607913815684472595276763955986441699443427370557865793836367915242181413e+481), SC_(1.10962112711529101534912562943260228361635607185175722798937658771556845854992072759911213958964564672180452090515445311343017214200478219345671347775174508165692998334247601604093914919662291958003446775403802380630023277225515086469228897386064408468042667754801894314178142102755176878099440170737636064691436824061807192711396651740278591754488382561336256458723458462518947726920208751663599691758024144297984912059552460721498628443010295179950458476177309783144390632287281095548875858926172324e+03)},
                                                                                        {SC_(2.46781433105468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.54430070676716862693115810390421948931976002394717224886339767037564534120309176521299537203526080523871864027112261973583827525813579609223639673790081115730358923167691062682991145793513240237999993277579696520091961498898991973113384987345827550340957419508605602232295325172334063050970551689327625632593117746477019819405241059003402966379289957151082999690333889975219062338317455943787360949748695609477496225447970228307114621591908511761768499820035158216292752818940308425133880084975943981e+482), SC_(1.11077987066396813375983550556030116010095363730145009449803074825445312063852390560358313774196456800446660470281817384146147551203766155388059311142626331195591887681033823226527201669049461265320781724032422500740720322636163258283977400327908488324013381231482606703243324327173688936022945632266147475242665538452012298788518949061362244248876185646839216950748382604759541499840961090177329034155811895493525769858346071395373195400748894670107987565252515729906142353996963335676634080810431393e+03)},
                                                                                        {SC_(2.47036621093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.03726697216641365963643583377070861255725839226857137819608236373490116361468665030870506304335667714499350230042144733017895773636837793884654577915209858152075326187319766110671398780490787841461126421773164837214653680613584236558855664435166119999244887247239679329522074528427909659616232716848001691501296415474881129262182123670414079385945766434402522650012935379021133348931497416878234103813435959680042902504145705768202920197061973972115932276009952768960925282718091705337795896965255542e+483), SC_(1.11218518925887846338577082099684373100440129084014869852239046502528659782246144304383897748541818498450034973183658276415327123506136236388676382022743876296087524549286381211212091732033877831656470980749405452135779011348568055155217297691431058355209486124090220868290623085677691510535998882567196745139667930807300190933197510995156237553526751751936307514732732771119749185564433964762101676004967561538612010023100787577408658698862992015520652788974442813172880760711590770657479194250915532e+03)},
                                                                                        {SC_(2.47037353515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.04145957374018197650720966898854598266645480451376292061458143860151860354411403755636933814860351114878878604647625132507089018959340577083703677850415720131715935951684193280715383746394175701726398236160685348482653456024497916524555662841451913967034278766272625454323977888733836104527269030509781760497656144111087052351278517319942230391791063297690705734767980324491585907080640233385252248891696160751017539301773798881331818655389881137477082721948079694145413563849490352756883317903761505e+483), SC_(1.11218922308166972462283664410940559721964372378649599043806838210135440491265701008417555955702028563810322066423784753339768372134107642268262990062196285127625232125084927509829519803552076366252618657266369187932804353684920293503975836689939181678148657953074208352449137766423886929331657848806495657713901893538231832657027288801610772432412359417530231417257373775771556636617375093290326686619839302577808543897564582461527064584060447481565888679542849865718705937486881679827437348009135866e+03)},
                                                                                        {SC_(2.47745056152343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.13836625005141097527253563997570355234879426531556936255847022486054354534643507146654064396771235268200006803985544171202521037242927643948038319469811631366458092220310430382029347066068690253478346102410083374014349226688222946344408939757744674854282342139396887819575150466957497794246765592859150840676197246266078542509982472444650071199261973585796033628678323722649878686652006282394597479785982307348210808314881347762951890629364045844344910191388709963828800633534756374339153845771442027e+484), SC_(1.11608792018787555794761597871425769161833702399109093560266737996699317097999466450275890175088587935348969088992516129577325697871066578394780684085582830095056893431071354092821747992470958415688973268603137839171781365825674962296093015271490570819305200074854091868367524921073343049325325162922582577027829620892489911052952976735639113683060019067439306097985139206284658362904900432923869227530515152449676170301181029318868926577271501564963346393087004648815023217791597906770733748643258720e+03)},
                                                                                        {SC_(2.49248535156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.04561495566920723432260209647631957080999413333797576122207122407499118956399800493049967635372700083459190565775757174038814625946249478359709253575152976557372421788731686697476884579845655840194850232833250041677174205350669758073274529425618616827942406097888052562691387710599994442476905738335356868617474710844779565059857489926659940697801249642493782347425094960895785985883920719175152615025656490821075158608044948449728856201783915133469947560405109683736486457689961041139316807131113309e+488), SC_(1.12437722383720300533732703144576976650220747473127190173801296796953352929238884076703173317343950446261701920731245420014488329122609439902756180874402258206002590923101051526120698243035688178965767382003821300768780606209404145600000183333189285444841853018465689940637292084087799242953540547057571604423804871533766418971394980463330314850661300990984756273857870937193835080327404085295774758740435120394689317047938653705048993815660481680093002460907520326808806036967057815482535649482364239e+03)},
                                                                                        {SC_(2.49364257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.87328438615297744465096194646450231246635572941758649458903195214719841901359184702894285761560019123207949256398052042913900644331280456780967348058826841252429315899772532036801576151043477370241624504866680241705786040256854518280908183896382246797701544528348989231856539034662912089209800566609362450311834076414694488283454493481236958096637055222419819277630965593544354332424539295114451772100540679463612553653245221330337072322537887865352516598157006733971225477202153835823147250412839946e+488), SC_(1.12501562820680443368216702171006240543689597069180001812424410061058920018269439059791412119786982151024384145579756090696325922505051249226306174817059675028531145382112635697429404352105807226042425228062259832608249125279629131902237297461226049849486125890806692627269902627646157070460566893863621199099721657347446944107907958726306400580055247316143057433474694133203623188659133980123159234495668259271505321535182973001369810709246450843405036159665030460788754244976426626617648081851801744e+03)},
                                                                                        {SC_(2.50502563476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.07274708710426480479976309691628020779430124487097720485888334697293065565366058444675559426207689696334219159426908734795423285631204165236249707662088279983336826645930883131590681720259861108637124842224516484063887352372785250144522750132913825577411016201176890878958174595058056045351871163786080741791541971254518293224681558173729276871735946638215653784714368978926486545553845820066592686411503101208530284703276767673195220201625106490763553130345207200320480207536680212451754824233731891e+491), SC_(1.13129815548276061007242799350971956663282969471706439003558893479906950414403629362369362015331119636757232935969902969812126415497430260592802030743862844125148209465495399062169787530128423414073761821003582808807744970238313600717225956185744259518248347831246573614589339623395053881927846409262838468848241417664521706158853425434773273857759955532921647084842627513319137951256056561417527328524705102832473263527516608726622488376179433990348944635143366274694655291646510873085100378581996611e+03)},
                                                                                        {SC_(2.52215148925781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.66546695735448296343500891436923477885275286729668679318641830878176448747444861821913906606784896435601619283389185833995373629552167510816262130864697199232414556580841338932991414809810824963494478598652928206014135759671267276317584552278374538567811744834928749382434036721942532739577951189104244174983415016109197082136721296547613936068538033809115053815273570413891051598222967349815428435950301666838223301085664138390694335058926239694936196625961314619346643082753169947554871576514959612e+495), SC_(1.14076000029284095538812492213530286143000345941738461623639884345622829192804268698288927367755044061416345935302357382599504512596198391076818435077958094843435332039943092077503179319101603900176049018156176118465935531552091150220922336592025582739697402883872841338787398987528411269235431622671778589411799156577821838627054815627778310059804161448592078457382328473104979925464630069007178939435491847656260258311068361335597487518114941132145122236915830686125812822602795267174683116300530176e+03)},
                                                                                        {SC_(2.53292602539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.03191071320884033511504800929100209521357788049753836988719007816657743269363153829861284603676755017468540712580287489877338188655492428703214723938332869709046984508497992544082262210436204249654450943888293408668136211905190942561540445707590771665105850280062222928052516783335865449357107558503225321102670597604561532618065868917428757799536044202654413342139803149624340335917343546095880030999511730206185653398500549506702060248496227902462735664113586870211450859828788244444589828221348896e+498), SC_(1.14671878845614271749617955031050864728541082277909688253507208878920627341593726898326342194956549838258753601773814934347563807364987686960388930510753918021704021087094196133032315743201042841699745017727353076753904550315141209388010549755621073497811466145433233388397790421917741924559531569862030665642872200058098773366381238450010361988239879991136194310305490507300629587338498638630308205817672300083055514329767011529814315092086223350656551068120940251592683878547959366124588107167105734e+03)},
                                                                                        {SC_(2.54540283203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.03005428558617524389642890285878844718736494312802631482911046128287444469152925203052711854349077933234680608713163711599825083984398163850650115758647278817901873859522949426292118538781511678906635435281968738581011364228313768246077506770271284259942560877286339894717728365071225996165010140284660261508044427454324266917571414242254927125283384760348186411316044173719870677247187469764624829288846306396406325633057145838206687944738792492559477168547196965542361335319378649243834807638613038e+501), SC_(1.15362474309532219855629179325020760915467644291640360588973618407166761132890681342534355802445951253763377987714485380753622963278794590499140846663436405925979926677543648596024842185554719244634327980758885810890403708753567653855226133547431436501937187099166102812595018346975443625229718497891574689669961467796276639910612456949263481368164816247410114206146488773291362640159982137381102399444103022912843266112217179576887961610680037352713171485921893461528599472834088357664738039337882088e+03)},
                                                                                        {SC_(2.54738769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.09196180075864530403188183906333091789166563611957397910504118246808674331554103527064172204440255171927959820823856955926732873907899670793820545439159871136458429083040240796590738193503022406711184443444455164915163441143906928799720693284624987892375846891864720725260850423696454131044695480079645082675944262785934839249844685013504382353140264532876676092143431742011579382829524667596451509076288207577022596179958822840908509565631544300384045892449153150046947886464330334138576799443146597e+501), SC_(1.15472393736644797605691250517848268958895310901566935031880346653798199129377083604491862984872508104418000594364925274905660197481151373463523091415460504131469158117407436661270060158254970173747921064652488091181944661775296286005636410325474973905696523224831626056740792161187380762818725182223011180535503959532958509533623242700659610284710155511636044859497322728750861022725217217099532755195977800296327347802414024637639540041460242060325238074278773467372899379908985162705580152090682949e+03)},
                                                                                        {SC_(2.55909301757812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.02682344686683115607830107282795017666472482431979544614282577772499390761907606813616967762882182180541291523079780858381807103407228385883600131657889196817613245431154057591493045054519416721363462642405710982162249458143285907554731764142705744357489416606981695227914674579929086640030479579922939328776905232036531073026566520246648477736090367808919883388883963769810409171869273129526220123913816591012546473914835288435435456636717001304801970284224777873829887682898692231377394789277618400e+504), SC_(1.16120935663196836147684456052183632471162028503248157526172629450345258906449374768531348114470501427511139957706536967247272184666850539727909509085503115172037279703610155102680080757402088905922399501819992944193388283446387129353348109573343329650403005055995515754783631679191959563782070371163606011272135677568359568291367021150032988135908201750228275259118847650568520783802953630180077282788045798258503733397522539037655333302220464231548669210468078260282082167966080994777712544158413172e+03)},
                                                                                        {SC_(2.56335205078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.14892015447846929597320001936383408871375214147460215135246929794255440819993932451177495898957213852828701448765401875627627864497167830577666347436548261744159439146951924013834893635312812132835378623507524565086891484337108765292763791143863051292421436908810607938397016851938224530508922661841878561751356032455589686265729078942318992554715118910378115497136038560986632600371159329183179668739362697001112776460345397004975523207123313873706497511301901771552502809081894487897496242505292535e+505), SC_(1.16357043742423004366388876547397517934923017185696223207230140991950892999681751404777434890527995257306131176871918963498172815283610776154685935213203956920687779270742505157212334566057325315338334595808792743411169275890229071317805069527940036269400858158483627979973809885604651271180430322303210761759282508867472056296337605917830930505848881064672377534806190527764002703313807338123711562799144947895599392700429560372378816923604882635503928104343040556904440453194208759288283461661678358e+03)},
                                                                                        {SC_(2.56762451171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.29703113090415751643660620425745683904714997582351362061363614062666028044674767711616356746446217976093770417467039358862913584638766769747695246010563287270157495880149188378531039015594425891868323113223472370391197166721096153390523109677750651642580513929840575175477224632012638454912162099534083289200692098320612804122242131898938144374717644476449820085207071224035304839571045148864303450412843950585089734935862000922063944874797130648510362103713734504374686478548618437820442343263142025e+506), SC_(1.16593967453145559369544306100308585693201309282869412003228573749046092235465930976818641582095088784604661496590710556872066977581973505247169754578112925822200494857907731722913134974342725157402655749031345094317040512927226925849278843090529115873222689906177777543269101502573110708297252929287992580647243261790339799263792811001485470689828881958611103286102386435502284827728263259952820841941344530544922616127315771484936616092104044789819215274079370627435537585210189816230603452191395811e+03)},
                                                                                        {SC_(2.58803344726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.90790709724804479132556083453909868917919738689504821860823016074637943633666621120172921379923309482747636586327882413175365540729917559878353042643344484745858486573404853536834763233153552760730647864795734072084176699704638875987400879276867531759597191063885876445027943961321753545873221424781519141817001618896421072011195454953414266410455503643937983624981072158134066139721859128817828290084296521427611983218004822564765033604241751045878532798891518548457905811754983202471030014391422152e+511), SC_(1.17726698940062819798313661811942273520790845873333503419335168714286890290988366395454701452158869664784530075683996153711726018285966212794499193689511813836362434409180619002109251930923391128086670327123293742916004443609254051691424405252610542495444742645853335098700474100504548610912679222583691545386259223880631531393531042318494328318467680999402275909159386120548137389295099242482162431108878453172849462368950341510813941902821388175878611540790484083594295642922726698604751529847481327e+03)},
                                                                                        {SC_(2.60608398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.33825116486473479768311080579709605596750081119766588078681795108679798073057384558285689635528924722848305590938936286764686322742759286427064890971927056168742244927723155969145580676203640960182842243162812427718549964513366846846155924458163079609730575483891732217625285801636814884310386634592137582231215997479804017305271357401826752101775394739167376194978234876333182127895644748667859796437622142682912901457659370959850969264192820236006454708303991040714929129509871441566541862106493400e+515), SC_(1.18729879420143225026019891855763274986276008788435922588678058013626980061941098074702278661920966764622549536129161431143638765731491034572885689329888972316596903831943562979837896309698499422058702514637450249006751928367223603724456070076394501026520297668761126961002643331092437595389009216572847039947433534367160704429006850102633148790210588206000533799911108269777867051802815023235050725180268628628008402515679296445445617608893371992794240210063369876282338438543866275160426758974865461e+03)},
                                                                                        {SC_(2.60787597656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.17526369190385711375304023169973528952681457745278357467586004990653921246350085959593509566646565515855934245568024267569767730866850414429559403636636142096970381490652509683543441178751988175989097126015236829094400415707757572003016463654688400294625964188415762942178687066094628160610589258475252111010894981388592209574630069110857205932207628474017828634823399061935483012288393403221248111707188708521846772297762193570515425479358668538827940869783101069606653706771102563806214210048015532e+516), SC_(1.18829540052598717930086868885398749054663698391162067149758431338646843225922411111839066036090981497653653175753375631033750886810077529129171960253170845444390238408261517093583360560676169081386896153240785347947848454192365350123747912935997785681096115251754421457485042201523193260279547620173630972777209581283260011802180279234037764261452055171209905441223407231997070779709687426714853913953891214226688132330622126572736391491813324291715183343651028409055416019073866265182543431335729123e+03)},
                                                                                        {SC_(2.61056030273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.23096701917213007735128490668804108982852620840302517375571160994590717852525433034255803455639403957994821422533703004085223148448947302264931845271539637468047169680426351588913396038585496549648709315371377734334547947721815213286416144598174129316831911185263342182081381904180030408480287754859494879931399449055861035314310746662904304773412957434207864949666180505634362575103041986921608601604685363792453360999683461381031992698553062661646058636504681248030570964239290373753061685500691394e+516), SC_(1.18978850414441605835641788515064534349157471586560323215420751870551845588663247409989979345468061473783507752771630419525579802778371574837448607945213037506305818374563067103941101943606088989160780878860090200756158928978337902738499647832788024326301735304468846618229301631350380585225887106766241661496714167204262680844550670300327413571162964909823939719263953078681346292667663328204195105725394903890764955284397055869083551779690350933791012925788640904230617682818533265231741941197168028e+03)},
                                                                                        {SC_(2.61728637695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.20755685213513123131241483961704942557537414940240899921040535417224148492274154424899960711257276179866709020480788225128645062429183519465818068166331152127388662388293257910161006929863059053166040134708795497441974634831146539096604925223692244286866447289335860848479484227011974567539496451187799314589064082127051792986711551633422015764695240328986957802725727294655147752764794138790643631139600445863319069133107857638025290543106871325915138276665578809600598483931769750171287888945943640e+518), SC_(1.19353096457816161133411987794594608162693115619361136194494148947306339995266854909465498062837771575938309532050716024555980376790223076205498807557015679408775518249589343652402449881580605638038942252728089899063030118227919844039989422762116500169196736977734786819335131866567127722964468221086750612272468969926292040935581739035203779300877278911048436754425883751223852023253065643311364664876272329620642717673556084034031846105193992575066434852221254635758069444868044499540336216532591283e+03)},
                                                                                        {SC_(2.62782836914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.81368971298539218622754882690340024127781012854681913479661657043400871539334700181257351078143869368666062426621153036862005628707117825809053525337859314997426023187576524458117836543204578848739293156516084609444268198664758675609729046892648412253417849050454404115848517921855416430233811724219896833121110946854168257957585963134629913604611610429254726170641528004512415121076113200634054796976650790064349665711002239298146939745533986707327330589355724939440325767952214168877930441350648029e+520), SC_(1.19940012564363448683774716986330278724667629299805381391233636337363142355027380756923740218700471601707583795493916768702777394674480118291332599791718113690770689526674774327312928415401158361325594164065808191037934794167752227027441204037173542748578455421834369136845147376715495868141430148937984847282693667193491679268725516489510562006978596638005009600431829789832720728550309055569247564910478746664766685211824572156591091851566915825774524898965243789824189903845573625624669035752757601e+03)},
                                                                                        {SC_(2.63027221679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.04800843499851140387677209071811733838013921230400090885249481664942895250825989279301907035422376925523767672930810379834293330671252220720319092734675210352815868984391411886622349742272138932310498147521876538701459900552904318727096899607890979878422723979576385190315143792142477981641948305709271570186263763115408315482797905534515470527141372095187840186692877168775705042624008395573226636498690518234552015335274645968146213142028089460352928075599629701051761701294166654531835765279408807e+521), SC_(1.20076132185510633506202420964568193747923257883452445648684096867229218365914648682745485640143436440696003466503416498043039747165853372804246381902852300360413056909530717259915561254894365404651443251195825014343521667727462778167587500962075039619501089461021070567149317862039430779210689521093267908137185534509955078202251428496238784656027547829570303155182984192531246836959154436680983045330533747445032675289906832902909205602824553390685164239876553638543524241869542303323067877296711456e+03)},
                                                                                        {SC_(2.63209106445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.39565391406320319649030161233468532492027713515932979738761833734190181801672681401669883181324346751914329920354898589154316739915656175126100059545915776572596780845396958968753013969165881960535384728928279885381999301278748190437409964482275790074056443847264011827538578023430656845799472891571718649651639547309811478155077032326365280627126192480478587104949209485361827003006391116351394502117244859613944074948672203975925892455389181085239001965440542252845359884796393316132651313936075490e+521), SC_(1.20177454763067111384128165687893621854038991777844547399642133707531286081103375763461947980283552905480044499390184195739946567747136179706624426440048971066117013666075999056758797116993955075891828164495685984595226226878877342316331779254566043461736832916971759389417951463366536064020117326785333215991783392947309741932033640187764726469578114048648028132170443961215652682913569014057793000823666456090351086478815271689877100088608353011369804790412753944908195700790346265903341636076397696e+03)},
                                                                                        {SC_(2.63529174804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.99501375620045768407985427785584880049111114684917813609328440874357575509719619952479883379277988204757363121820805582858322458072129685643019955082411774920734848489421459178439313006637644456655180338530783030565105775464673787065917169690274704331057106971780787245732784668983226650881474207581878144048749544605119816169141719158567436497024127150067907743980703325568729612763499361957136867363556232153063129447736283782776434639929740368240334724427988886402451256933686729856341630226991497e+522), SC_(1.20355785870898265728618126972507572750309420791619278556132868747777929259659904448332621382340490609970695839471168233644516875213300716945199617771312060831469096357827235850659525480515363001842830363024365782648964378332580517470644747269421651366108409740279049311958916117727361200485980527867894181048287305710334764272100052331929591357976325513836676359873207094141599204244498770619307565533703543909651921453667138272310919600843232196337888565849885740029257340224692905767570297929487581e+03)},
                                                                                        {SC_(2.65799438476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.57335640474801863058467507788035451075034407359081765462103544193680340997391017343041456025846730123681646527929926444787439014594054513116510073384815602677876440749717057760627159523500990481032179409497590701389941883572618275839418829581367800358826659762827093331419946151300134899096429378041648813617549020265355659696042662297857888288242201079689075888689323393939145692883899153674284266044340562112633868228621986767215520985950810277151201582973655629895731234593753893164743583115695914e+528), SC_(1.21621814027571271717851177961927638993644428343431650529497232306580352123159508789408501386031561472668406881319931960439899523133409380272912554986645499274407497474326268475308272758373223022978270227431022326186829496838886451020515792101309313416416982131188162038524826560663040813242535090021538471375711761776327113805905931028196711072226863720049579377469898667314245307518301201796644159803528739125596390875010768712587584490508727871235282947313066554020121519702097823154753882996342003e+03)},
                                                                                        {SC_(2.66317749023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.83984797487643691068513869936898285931777336511752862178600811210578100824970088474237568051763114366144226190805369945388778572789683401356529667017684871896630462216089564820545001243366075890410999845683353922649330403586403177792538614976250770602217930704271748587600983585270449955872538579748076770326179077409318906434897372504637212331130315438922644544227549059234619551176521491256025481559743509819899498165871557249430713586534071970451632983405894631409063129611218359530136723319590728e+529), SC_(1.21911126471461741578219431496167109388392112833326721224759910458684698797107414402087762267432276077377381057086558399508218969326418629024709471586086882939874670995370205850298487213523104255872295463836040004543595648504071615083142936876323925152810138819901982039436964280705757748818036165307554228571820779858749719013844666647616118250446690417140867808024505670726443385250598760897064339124536053086450637095118930901907746339345709733202569777460971030581913503097885811904945153154872801e+03)},
                                                                                        {SC_(2.67270874023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.82060549092804969241038241291472432152182720210680778148011471481742600539140214960007785918417041322069087423648646870943820845954433460849425687639132972291304898048664271550680485785489052653646247346968623305371527205606107277707200095034031122138076268983543546921036921777071728974916375806410481752040461615659403036925635746170015523246140185413298043827569650526614608165403410616799189274503348662548500927991207913732399410867422663584384661798652120160244883562616577140960066303964557212e+531), SC_(1.22443408867241214310503388314995678574010017953485632676462698285766620544932815015658927880921937589036547233310773294748673128681895553087879466619537047265753972190665328366162827933508759187173348808576004582394699499076332892311647104131839352336560128208499219306100374439498407387650168791036309018736586533191248438017882077949866090654282862908910137744103000873539824313465914703707606563642695104916209853178567974610574381433362094339259311117818087093158494589749197216468131248295482045e+03)},
                                                                                        {SC_(2.70016113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.70030482760169582852764870022482388345931265938595212715212288396119629498607619124269850869402618720344327479062538146639431117980887854493736685580240369676464490734089346972528469817523862041950269311699569012080038994224660388803374958490654173476496139787936857987348001882149785882254844611306648729763960342116308717814273259706008628044554069619421800362132190958113879693843571921760932962084385011750578818357797168582051706440303849493520560811700024259194948521654134104589906902329600687e+538), SC_(1.23978414469654597550980991436367375336940629385384245684209050855589983968663915762437852682596190419234980492127156530998615233340670285900612772614100306643047367673575209142853728399963555517010885623210954139688194910734637025524375237622991935716892554218818181748183049020420753119709384549350941727520837319781237710722035260144797775415077718520339650547946423009813313395761158987895898048784966748443558920083430155549000720020356669725719031975860430084363466544682498951350310861567970704e+03)},
                                                                                        {SC_(2.70054931640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.35556246881482088435201938745499735443422343721422726909167575701155804660269501753454025198385357942729216148058402888082936843037666756431723805620323501277924485095434283087636017157459559447607435958149522997180906655658405804224417556539760418307105120420897787012071320679768264313898846099066487299460291915971555831387616161510990979847666849751425038488602735610815668024003494135422709726200010471222325314888601185136956402932314776075495450512865503095953107580343076836662674857976996835e+538), SC_(1.24000139943808188769161189044102576790632176716846006826446890343815080424906090643968375906580499735003771916399771255513505839517707999638970608315201287275408889481947817805780237318193232931843071926285335241756192960318030948453057411208503566309936023402088802685291522962991586205852685156815682522626395654750456420780222127098948439918385041424681783818036504325145085819717130531476908848760384059860257475127397343293568253686086778784668084783515883463323506080693263777217731790238160702e+03)},
                                                                                        {SC_(2.70814819335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.36183310341320543649184780325173400163540526173769930780114378475634825477296160168316685403609175589559337491008470655972669702098565121946848573593679324431338475127598316587277136892238372268878441452108433072226956224262370191120904806707643888230324098418888623515864956316042850045865090772817807884853522763923538749356853158927325167076685014314318358981405561956876505456633511175483460920190474812733643490967704064321411488330540453583230477188118896160424873718909273800833108743049568808e+540), SC_(1.24425538827305118357592555393761738435990654574901945987313499664147937484154335765520736983014932993836606434101338832333202125369819770211206899300939246458561612376864158863582216172454087617727999668806234801260065706293556001994731273026786461243331447544042521470067403051408517657026462539105394122382445318834324458333755525518390132339900600741167200682161289164765341401704110242872841171210872232051130938488229750671788141248978582726200946277705990056945784325034403397562184992838413143e+03)},
                                                                                        {SC_(2.71464233398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.97177482381998940535354909763097323015999944458834301573634975511788019780753090619037896503663692109125581228026401826726818967757253432336799304081901564050591039194602193394534389828735752267035638002929194920584088977922524584412143704141726450871318504326228275878221271435821993094593444529758484592683017933971800340296647773611822911322312265445284681378911451787364766178190823150762739346875673293520095107122726261267812965975002330900269774841133314105941446621237561711735416402814685200e+541), SC_(1.24789261882846456869502381133977889113414512802207041950089427681383499351232412630338845192778918152075982048766029158535334182965970101634497444052542503115667587137532245018686132862895470546848612193529361885030004189367863227583075489553950719849565150520983603037596930114194142772543721578803871022143584721472898289816785584334656428166648515113893572441494761575643807538769943605109408829150822345245502393328452815133294840511092409318411992974089640536665579439664513165349645290316517418e+03)},
                                                                                        {SC_(2.71737548828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.14849582174126618819556370085380685971394031476430255285356308348322838222805038231590554165174435445253263818561078257865072811420323484216906397051422469604635799018120057442739318600168625181392538122816490258986286647662007201053207570472532819744886135938220547403721968372689107265180708525405955593270350737123666159626384148303312234568491252099307034291475333683386640404039180958845964662589332759767661498648462420142116439652221832021431731899541207169664755851128939481934288943082737996e+542), SC_(1.24942386621872108445411809148685186710218223946095655864592316047665435324333580594825149922369026798820806926292138544612217677339128634961934549707779417285869400518925174314104626146663237608694626441567102506117330741905588733785952324648414576379697701672627581513544973743360261829174199656081910839370335210342632938562960078584213036546913616421838849368772280104016555355278170458069625306893803869641377223442156007242421924692561278917431342975628669679420993564635808170942119050909852690e+03)},
                                                                                        {SC_(2.72209350585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.83616543804308945749835435795913226502554811146489035840851026110599412031809233110908083307404755354851132729804363092206423094086100827893576757305263865221271616680493559302178070398876441918566907148919215225474476263330711681222803949476337785631250279029633618728878685886868019285858169329173166473976805440113718307604565691274979851551595670394240965439002608645521600181884867075878561717091454741569575957557991402309016328145595971094122976985531978478182977689408685374542462190414504967e+543), SC_(1.25206777947387392334047792966095971046990541157061039545606552540281699888764576542101216130339216501442542058299952976430503295496405143255957217815700010182399825555071244914636174252786355273419079689003429314765336989610049478376974756694621686420631145086612314401117741894118317768781797183241130188707293806751235290450454953552453874701113919448338517270956763590035939804048058942584965507573299803942623314089629820510289969331451117658084963492930492519286455783229518332396323717750308226e+03)},
                                                                                        {SC_(2.72530029296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.52188641624817172519121946336514543937098639604573351000695978434404811271218972027152169632418814649084671956957305177285269165126298136037093796721736816145973874733519665294885734270659972619512158146726367202155509165381708414271370400178799222931569384616697238621630578914016701587720661336428620271875288056871770134636609055680298776682379852464978840310937452501621391689252368351766832176706688029267299842500900389890602682673209217767507311771136235156143268587002398986897813192012150398e+544), SC_(1.25386528734852725901069658762502773426737514481429207405636483380893921373393252239120298232623383010203579618337070690160761642497085916791054643525558365336940892354811946207188293965083441661205108154746585849411307243125915449917690096150525184755415511414133733433796674745989078156357226142701424440176408849796497866360823872280735765729140889211950268280975563281120256482234459507085426314710247864337327040418562992242067841678191977765567235135607789591085902683637872058029702168410328781e+03)},
                                                                                        {SC_(2.73169433593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.27000688056228001165783744708351382443004106267194261654166377111492987297588126340652284657909362589817284734278480220250923687921724658273741222845040725490242716458052595113911397005964358858051409683934082011594080977082227687575765076982261994676358112722561574445593150243454497268640517487219164254590582174732284975023029633682602916383288744284002202685210679793098213814585407447355987570778788517531399935437979893812063549826926918605307432580691076351535093127118694372428667057767677808e+546), SC_(1.25745048309297034215225952220531445391459889261578785962191191269973986900052411717492818974317691759879613764778230129833460704635426001696278239407798187096840776148508738997027824655152850188253412776244667299762684147592733104557697527362405034837859459024028019729857743321602202279638700589971887663830716917136021200477399244700449589835931366044758692844727668608247287709612877989811295228794250549929176633402252250131673226698067627069386143132606288117556752691166133840849164424515936798e+03)},
                                                                                        {SC_(2.73194213867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.45935955605812735495156839693638296198462243581441076048340331635409389260547980405158868074685030372197363686625129804156700369258690205283782313345562255012561206270872506981551312256482533584517674261237204317217652082804172442272303237230430304341018311835011345068681913715420708866207782523431052323184802668955974067735417178283154279812075468130686165925458631934147176186790438845925303667238833076783478575591907165841304527615610353531427214472831817011248671438883122006900507491572977160e+546), SC_(1.25758945845399548334513761484836747762009869404428617210550785484947799916825821741590245776157576456556053200179339128015458381688912635377340082871757228362478131294864511122304924465270742894183506533992717423371247861749808083018612364553857081508199836340857536635789070253936265701803394410400202049374679259690925798433922554703148583113097085061173682816006329799063331159232094483431159854380058634539195720053477928210931223877869495278223645264806353214206465283453045735435319231073321061e+03)},
                                                                                        {SC_(2.73773193359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.75522187142962618723039696060283752240693051970372647998007177632405178888524559501414961401629390159506570353614341028836747312245870179290809531496336371134149970765075268921209985372664141480034627191088756448867177971946255439924512702480221805741310237363955123795638009160537673520402848726868729811823176646009990142770392882939786392934163723877702015180712562167718085438044482343529946738073746232943024022726669789191486301217254547597742218548037111408823649458949471585947496320465505674e+547), SC_(1.26083719323814551421353305262485405862434567729166180424538391532489349156584827995704606388649105068260046169004592235501004892498165529197035397319477296539811575470165982182262980020109104745816462676795854970280500117694084978970615425104440872789238137786456965583924353661391147605745635855906505631769673033633773005799418253412998114829604828082736983221812590844986007810128205855445726749686113893055406600235659582224834902501547253721021711295799503264764508618467137830159598413887211818e+03)},
                                                                                        {SC_(2.74001098632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.34893254008320787144503178120105964194671728299186278281524075300030643207009284068281491580609030408330028307245646169064395328620482827568697063409622255518209761886362109978750063736434634921902131878454124877169053179613895650746834104007447102889153041215532618303989475384161133417389744739612471830051596084327291679923709578735731078510109277219904797142262489006652172664731523563061732982125611513689412785297049223685029009482745198123672726358745250759938159030791625989357769183602468043e+548), SC_(1.26211594452936102710342719135741272183036870602148479587535687512613529652826661637708664494180694865774559333682369819417258657159198774272548187565674868209826350019453898525251480790780933930824013303090286706516081828010609826063540686568568119085564812220058109502952578868894711666038722852673588566039044525927966900765516238991449583986479631623707519364320534242607890649674712816366631757236086264806057425343794131185222098672619086794594983124250351863814742288554823438823348613167218421e+03)},
                                                                                        {SC_(2.74012695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.43963028638349185823005280656218444541170618455375214591813645015022494840216673267261777309484543728861395860015282180490061252159267693052079844011428719248324910430761055431452144980398539874508822626412639310007284896023095914132808753804800384459425625307349534297866351625124866187487286856240545768466410732030757465412220265572977615469607782289154725215331118055969767718716183569923394970560002393108713505658833644827225479316761909755761220073178896919379329480562059487506612444237184452e+548), SC_(1.26218101729579313896351093736544395956614599758855448252141163466602321052519724057974963603297529568189189743164046821940258618202732549574797548959196440866094521888416631817545554967595337237657232619165997336024184824146112247816592263648606263430262853260752530802996686824782343772861987135845423376006182505877145608575758494725345062753542772879577310956393664431500273455031938384785590340004353170588269930105532612586482416935155504762300763321054220808155610614810265234230191497175059165e+03)},
                                                                                        {SC_(2.74720581054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.65156472722469161165253933894090520098810289671675615091603748405246815054424400225681472308631048704885846439700554808282557082572651900194653813339995607802722127367016233953909033386697444709182325963314037904487222310267772208067495020527763476872748958066457362106555635006304594301988301486259335696781593645542338160305910287225269102824966135856190458436438227462369256310585009936974568464708844611153337702463274908801164875432485128519121891089308898451128798468011211076533715663181462280e+549), SC_(1.26615412622016066773428586665042142297687281952025822418360199718251338686504565890728292129670255358725857075704996774875428594281553644585036862953669430162370387022200689480168340965400531245839730373397928642613620048603589983979482163112632265385395129307195649694658168475457632834752337574468191474285680990314398361924863703422165383396417512371003635628367787122049205444527226773279576799466324058411508462096392731146044990369360612521478594051236345101080594003737662281097247638298149229e+03)},
                                                                                        {SC_(2.75135375976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.85593806820452363164033497909416525410349365378407834053194707156878784482888985284063098506415033126802337375451300530273567829908216031777484484345257277817928431903186922600706855492799863354279156419896432234629304075872029839818850926918324906928556777501938151525932562856853438482049865798716373739475110622805349816433702247525385831304462678211094333631090366642525356501865624237006769045716607232954971200546442334576110487586979983133867900463532789292652102356842946922082896814804851549e+550), SC_(1.26848307083437102907999300630746202141491375019357280142433722571632992921958110237580061165890254122257814664244660109015268506150881344154195180348306364082240264197721355149004586222817319938014766159818766842054285164014463945573466663365960921671622869517395815648257837208506059370861424041073773595664128482231766478073321582233064529270793394547797093421786613200069804270872196374529966606599064500072225677737363056111122640437455166363606493268714953802554209835604854149801655308732401940e+03)},
                                                                                        {SC_(2.75158081054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.92422724331120030091206558783828122322889913743417543863135575352674051781582028060856017751032512454913123474696893197513479270502480065338354159771191825527114847980153319575829430540574611725311374198794312905212772030839926655801367881703644064001378770660612691685990522083544157705774493692998115912535772640090538581050505578661984623264263577654537774685867416714114799874816403581310789053598224498041664209642276002614000770248071309725054153966027376042807889943129905053709009374016349420e+550), SC_(1.26861057088725977297887270608413783036524110042507724286694634172319723337793494068752711463209778522643851097559881831407933989806742419040490165023285089006527652146391939734152036605065127611568500822504775282856867457022089892129838642648727941868099021407850497958930844113526694145037095666718766753002804201408746528281364248933906972919793405338218704872022831728671320263555919292074175071318565586882687602491394505574175325991584934111938186652155947501552771879316088365894413243452978556e+03)},
                                                                                        {SC_(2.76262329101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.41128745891919913333173469559771430617891316932726350154899361342963834845484411618462054383990933686083568118326415668440495835330668250110857069332783495242862852089754746059424485421177116293066099426764437299558939787096761118533412760785394166939194624865808283325759243348864254390535973469496856180313093344002743251007822626509752456548095400352126385448621295685627957001297983781743208629694289618628515105096171723496388846434487530078418013897078921392381136291828003628826369189184518512e+553), SC_(1.27481372301335759962280128701923710464323547362928271835697753329563571852836360293641352576422993316593777842989390319238998458994981793740197328538306304016924879242980464210052394470406649460208861986411057813506728447943607011648849192739213642203579410570061338434172386516675591334831637736498514241193016645215647908723422536411191440119054111530341765344073007861534895322762388720683077245798310456478017139675939926160174316233784478261517826049585379846680939308035557512728753523381995712e+03)},
                                                                                        {SC_(2.77013793945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.01290896229530449521621768675207501364779280918185316775655308987570806286315225277375344519364841705475074465492326838322861243541879906453840374270600015557657011703896554262881478667590422454630665634559633267929136834368326148172157153505353291490498352388922861012241917132058797918833367022291788698707243910384166447049173045639947013651574887713049004787810201178929601969346786170503464994395032836151091671866117179729944576214672082490539411215308186320465152067446018745562656878232748089e+555), SC_(1.27903763265641700903228790677911034642609737185380154224047441085341591488848375731981035533713741085039154592503440976192533622118213039058299858619741271669206905489616661399074477263742876818175027887944208747055293265004400262102837492446446400077053116741555686094952969892836091321600631269947120249700030062489250818823458072233799039132131740684394207504525313072453087965512842744697375015762177614115711307649424178836198850918745056670006468481172616878881623786208328488422033921675641592e+03)},
                                                                                        {SC_(2.78247802734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.11372576680750988547931149744006701147047626548900511875343348603356138432798078013648782842377076915546206567185681379774664670413467308733119154763860001605808493578205664080588677634047893591056355879815839278919819427551503369690690693464575945787680549498511845824325791283575449900360326923507589185432897012634350416981921309510087333711604041548114009751580562537766121821126739197363438782145171986640728083962216142031911909647689042696631860667020280503026674691632805578697562722707687072e+558), SC_(1.28597830189560236232596100264571308001432634859744704654093460164480593619800351324976302138560192498860034721676285443559027762467412405622071202836417322702840444276551062467603282750658297968966928815571465811807563183703885782497444963373969400856601488572012516539463327171825467695083911007494104206323441603680320922073784324790846964852222836364282949072314362478880819335231310253197963038528278322852878650705530302794124677011156151843788803423090793399290547472451521864776844706603504264e+03)},
                                                                                        {SC_(2.78656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.10108193135062361753848626951425722037686523239094630443926419520775419009801671924355050899694021282316527306610045849144473702369959930155759229901990015159828353371104157605555650181662047799796842396198529006374887457315064575023378915718643389022463700245801642852379285927654474914813355651444514363683371107890508148097421612899767633648096586793473262544856626505043057234014390261502171534294053615794865329318965865832255241498165538229353598470272709762551189698794179607083662503529692288e+559), SC_(1.28827681804438587983604204404553949143391861980385851148894532571195865098391316190317521228760034687642324313316744596696307856988996099698773627711598995262586769565659933496711496520308734939026815123343054056230094955826448902369232140185013660051068797000829712235164513490915798374114903233948426214504751604916043424765819069158894164661370188055245852497901675556544360020865969471483685069018315596316656491582826469864947673643631058118068198489945817722079505112919909572781993097801473867e+03)},
                                                                                        {SC_(2.78779052734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.18999632833259078663491625225121877399613251497095113697647489780359517672959874286285177147380539269570725265951213206375880012508189269900898886535101989569251378955531766296709632828656530805111626750285084747431528024581336396507344513873204254029475490259851922447055953936399755325606190147403553898922378086529575149613287240351302290518356618207746260462803503240496944233178351998410680200062423037902532211429371476022221653413108321269568410122183737633623184073690247625859035515302537459e+559), SC_(1.28896800147720673383546822262528346769636553839353684610721532223090112957274541836283894940664628274990027915523514654088019311707840702147527836808693983396778150929158380817965589432002343569401233667360975966396309727041537312288649704460780731942527205336568947004821242375529186206058214698370942630628996199623816250437763387073725051032878816586047168250489811932418947227748195602026915334221286845272945176812591274535240935168715644310169712531290897326517437075968625234494261947413073489e+03)},
                                                                                        {SC_(2.78815795898437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.61218618539857076365228227555848748051548775663911736458867566536972264200430088827081530026800447549009017823690041813989472165750258472924046663465130104961109500027169649759148804907355462669329551150071063555206233138310121687352492623754014357614039637684542946892953707868312934514012053163127922723121407814421102679619476350325129089628037204623806894978392340793216185483568288494490052357869289145560450820695828630811931019961170030451724063865118797393882276587768360241935447047810743844e+559), SC_(1.28917481739226487432712060517899736485539445263458769806945903572778299803414922473942450002164197030935581722799464022243117962933502835317194275047322321114589665812824785250110887283661422173405456055784672665901305620932169351555034320183340580645149203649577995105792587544645904290169532332425290368530000946086713419193488832913694353552675816208620800560358936362701010721800423975604266667096261086212576497263363027929807316390043384320778753525829463815714854502847405049958828444961706873e+03)},
                                                                                        {SC_(2.80197875976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.82618455077565126915297668370507696463078476429570315823328753531129756626065975130154624060217793215890339836013811263446588219118078599875589163035301520577628694080057695616275453415389787714158135594663642925777779987128063423556624463619768271630105579456056052411747360560267081334957288034432376147087760751976209577848208396914886679629116296335928876162518673743325181336549339826131138825867214201618669219598102312045114606292406531380544658744867412551837602775082984507873207349095157212e+563), SC_(1.29695763620104621424279442424402218353593178257474260149686803148316201209617238436179477956399814120863265567481557661076422924970313811531689045931819691622838417380884939395885518320561327251774634742690919786007564345786486591470887220729225634754606907191382347441021443725097897625200090078281192025584011261014378384158433599194392317180107812475591599783698794327793533852628389947789538392283722124357725724608644217449589690508056697238201842824741728681909373063043298217590577432868805623e+03)},
                                                                                        {SC_(2.80203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.88099402405625379582485677844450210763455415897255722481574686227363417937117409053301995625098819927112442980128036027629389920429562396936275555092694840939063887879871001616224205900146030091968873372297432644395229673104244472844448436514482940201158513886134935726727954179547387079295489295060441557356044456351366962160279617987350829832855489038745874756871304707715141091736720928177916850437030194033083088297702808983255474300262335482820131321796542651657027226622402405377089959318882934e+563), SC_(1.29698720772895798025158943453829156875400869238953335731285171195655117119014031237313561614022115651397706270203757272172284305522522291681152323315077036158713625671837608213276560467385934213660215188794313332985721385135925392061228608163276968285986313765936369660118739710069076233587060124527614220741608394530526370275941320513289509119357977474420574587040823322704012094059038801017919801127746545051276411798845783723542508444869281179260133612992430179540201257821284844033899164658744600e+03)},
                                                                                        {SC_(2.81700439453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.70162686504736644394390314878436412089963433995104255785939808157776005189305281547847855039113714530850217935564178984216281003601743718197016816169596235507155818977497371764608100727303917704199147465495512737408170198318133117869467747225801301013904150159205381726312672339250627334347473452437445406465862685042204597562520187645401450002221687823130946215956037400680556226799109918666091282373855626857838274358350770576572423894583544986294717276393544223628749919441547837435263449631473201e+566), SC_(1.30542667263879128166272571486432274109829921084109963241842140798609567942422795534093608065831934245392551434390802285547078558805235547320977883107357688613652621017240002991702770452930659864097773326764670362972631745729788725791748302786937944287950017696309987680444508345312453436760156098748574994085832913812082521915982159427627033388672758548745388137805516192190063926389048561475177927472836060670052943508834302998743570767395510580792095160540671750885885226698777234960909972299574714e+03)},
                                                                                        {SC_(2.82022216796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.34217753589702069131306616868506038282257373319827172738780667091969307019646455312864308287397615481329774411266281815295724298091606000843881239554327824467526967025611195553100876426864392970831586122127527464967794739560542541424380886521415834485763759535376733057777254133300530759799729180849166148511616821677442495386544882899049748630493985276357435635414308064546925525056792785334807959685947586005611678117025070074499538938613069288065541397227003871483385417164303143636840159791545980e+567), SC_(1.30724138107573491685896827426364373193013658810550701865300152069361886797607237073725640963698540156673632914074120538569203831593200254334967198069062658222220928631811532368809115887198775397367646369245050193405872721101875368391409676931422544090278751709465519337511128282304626425681229326796045686837842397962198998872549152568288697097833105075232259049135618885873624935536107557563758482206196742361662407453146976402072407598559998606004884247159407724782121531572299014982848673182507712e+03)},
                                                                                        {SC_(2.82615112304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.51458783732163405894555521526962015309779922272530158189730224502876518040091381958401083482804747000702592948434706804842575154899981326078750200305557500966537078476491118588033506305516977483227658456244975957908956924900434450285394570457726527047826725906908332988029576094913767554799624182848382751898396668003177281808107969973456878731577451854873807837523480385706974198126441663840712353670090818197900813731896857559274006723614631495235860083811707071938086170961930605687110286319940295e+569), SC_(1.31058606126098658914749980669137752907814114406047377298698542170705452834351382235468034443572103204615156934431482554766795634082238056041497089565811929568504698404362760057939449831205382779380270533452082343098480659616998197083592604072645417645808177718993404212036256514556392706659292762029813225276453075138185574525199272064713417524708281945875429963950917292224048107864710135263220521510477694608226875434250357557277942987261068956401331239003920845690693249365289936462707227721073667e+03)},
                                                                                        {SC_(2.83436157226562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.55855859415787155083193470210208378361711657010190825266924882127039806081246540316261254469271603852584839833838028915158442164495300298783451422146595109318475173272973235469773243802012118822659568214028455183174646202796115468262518061320628514051619197518613409430128088536388791599960076258092606901879483565868506669185323324927623993840509986953358046598865455601887437743198058974432714936498285279532955043098363830459974567138161539289144424599267729320981318641980183843888366658188879471e+571), SC_(1.31521984951562670782482835206262378008436020285378420546285379263101732820883608949122051631170757207569969358861769005014041362682435194384497463593895032565565074995089647542811142604972111024814957346244370350314824155345964557299689889789136275620641643192836622166752974612956077882034622789825992918310802758209936544891276819168401215829983378362532395170242599025399543486556205575659473596478459784209982144728139189700651481154419757471969688703886902791262574000950576874190220782214559688e+03)},
                                                                                        {SC_(2.84677490234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.72689566466928903369179960330682897548652669399393276051386014744186970417602111688859365137119806591088859832663321322407729010227398222215695102957666650134627135155914461176494093254946845109947797743409068713921582654393922007566627403236138483370758934553341824625899253149387175773174177362605215903747870064505117188137039287465190801492415063762775140078423307957143249016089879815130805538651333771471677541967892826094914960669119630992746822126589833180603476895486306392232601025646825215e+574), SC_(1.32223016876171751930127690260362228451276043259080142776611117447635298976971660676277739244247747333941430777895438910603903364415089362478788277431690184319422663659469678578578848717168461859668307713007709293400300773144834887828835740531915123068180321347100496145412025098700180155572567571693915443983163713525244308076842256668577625794774923216939872890130913395498266933038221955137351683909322710506162758145957963091245936593419942473687050256372597219165699935425159945089177350622914096e+03)},
                                                                                        {SC_(2.85066528320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.55568482360742948178753116447520884506333782707306236545302483382325926362166084203731171797423588082049753343360341823584604001171834314603381134468045601439167627038340683184109907021569287545728777442875651246709845779774709664705864947825953633312531316846756314737720236116818811210815571964220628751566305374162580922891567901030838489391041424097996446585903280298110043217953454271541003270009577929585042697537856830277490571046556295670110615936761205150685944850347747034901156930884704441e+575), SC_(1.32442834432129311020270401230040348757600194967804417411227993297073014371790990846367592283835149736497235335186397373158162058317510538606749879791206757657932690826284904297131052423557484805453670552512398295173126339157782769777536005702817283667830229401111439636352865461538809823298496358462581458296535197586798441690867505747540931768033354539435076941034258127236042998395398619386143844516720567482048995549927600273781698769845551334916514431162430514635136061657393692622426744518401753e+03)},
                                                                                        {SC_(2.86482910156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.67209451393488423647199154835085093626261421778388491758395920651729703075118017085136759283009860995120438245740674900924586133972958469888946144913857894080608167262957035021157949891129883305679378840897014842254727111679019908897771315819131280807540919616131402473292648623536641470203487859280265291071455955908845350748609006177134130302155504053800467229706750960138377058701943393860456198675362051432045232708887993066598492254285598962798227823381877440404684498937240963164738139003676775e+578), SC_(1.33243579122574590984926319328585741226431992976092303142686174774654086734221912050969042358695985194274150239716049202901885309852989554520340477404074130428600506536236702077688238199655525742941193655594162114387542290714158400945853608839737264475177181943991627056464409798943099464512348669426468245342830019675941783095082205207562407358049161151187902485056973380397931585693852275309556091706992133402058673687359431588861810125438604344423923096226075975166061175731874132590146104371235081e+03)},
                                                                                        {SC_(2.86505249023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.30131802710867055802416285405627004944443605305986263864220016184017472240645872115140983470407904672852212946917148540078482946500339207463265403567520374908135573477644464642099544185822754364662518871798355046306149602073380596685748727332010789651405550596757267402346736977673751744188152044313189403529609820760649887511875179928686549497942279718317761533128781879068042442032415413072418875923443795899631304581303173776883445512104657576502172490865494518739857115438253356870867490896677514e+578), SC_(1.33256213922455977812897109845813395173411322007265383882993796689050065344892046472775278678171245623266610779129718446610510847313619006451562400733456071361566843613133299723512877153567582901137929364068682109402160542808037795140991967432369933374079139541609225824607441961330926809954339086860823364451539236061251866540239253822841662056994139018484561055498469801015336435760075931649933637925944530123606696093702091641199180015507732503503040834718390412797954535075284822281239540293937836e+03)},
                                                                                        {SC_(2.86840332031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.52824176750358164076496059131959812500739113559202367289078195570160918639734830618115385785162075449318541138205767026948094148150925380637640534588880247019836297374103359293587348776792862744423037028443442341739444584376146685372640751241126724536643200202594566638152802905830655801709868901425768475610663616352513776004689802989586450583270754102902968325420768131021058225175702285650229687808615313082741556969466351500112049822288399570954833372013589953205376803853225516137432124569222452e+579), SC_(1.33445756850755300886310852366747116373314568156330265929319022765025679605091832760006042634427097972425123990224057714373558214332987821397493655971662158199108983919037889223963127098202330136136304633778191633740186013948492412508899341220977549020099785225073412219228723700367957957766855893202571654848753962304297077793543149474041199571899861685565751348528770358717632425747661550893912005896139963996406692414907483797187577784911543450435275554396157567812421677650523995011467755600814137e+03)},
                                                                                        {SC_(2.87150024414062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.03473996536835749844202230526429008906119041929085596339406306381317263063421363014078546769917249668117684990137811293444537056470273926075360164846312867358742270378020980764225417941673979648725203691862834444807280388402827217076217614875045095619032222224689284984869423339603735989032512003759542368506726476221451220878506625835480860209009536185383283299116072926866925042717482533885968333476709477077317932944663303337428332507026889453387064258608267285223334458864787880893263737675861374e+580), SC_(1.33620972196613057862545018474458683508774246429303078928896604644347843596054727019959159727639180583190207966863834316676279406887323600951026914176870661699641609986904094132247549023546751473416822857842431005653467518202034775579764333672215375560261672962691627243289534807356727849454769254909379982435085844253764478068377569207329781055236843240642891614812135450045500490647261251364538458703549087549771761205156461270664993004990880127287398073324604746729776681174734849962572923360447112e+03)},
                                                                                        {SC_(2.87251953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.62235931368603576744760805973395587210314168683271950713378720952911252196567865355147186057204710095440832034764605460312213725715497048431667726847778327039443061644587527224034248083714553060272185788579571402827986763936335282410900845534727294544319096050890981973359890483671963969083505166305907771042803709137302847083381936425260670606366311098392200245522774051318804059317275427643860440080916850991104769586189508338397170009462336793670429119848844618508684034406012112344661507533868289e+580), SC_(1.33678647949420338257381511183287844313320567831386055535257365475328554305496519960920771030293980187387578864013337221427261284579477331631327370836195986850986581429374989724715718586245126673988663046325581190105459603730601228769927714877805521773064648967141406570859841427717979239688554411762637240681521607016361187193242718598487509174044220184815718059584494651460108260902193436437318293997784314930666732730269053214473092504955520888121967389030757818751397977083873154631473164056671016e+03)},
                                                                                        {SC_(2.87787353515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(7.49822487376928593129496991619456807779571724900433890379016922727179188822817432232391038253946481782904202162602152838368852785921526947231533980514604816364664118194409700938666731824534215020170138929963996312545450362432993246182839764004297289618971955810426335741604446550929541921686956699211067433464486824974358064263080873961207543888113027514374829198159012636739801730156715023126639943081444416910170732607243982442087381161459051088358123684532334791232059683601332093922259371292884508e+581), SC_(1.33981660533857141926925380643566819272260171584725198634232654228134827180197337039287759863210818857870527822246113664420042673194167479981904995496726680432320132048846228792005515980585370574675380564601800250316443183159395144153371117985702044124796126435895171646113569474021227567642338387958328031624320043773312234684942560216098500310809828880827340935714150083392053952689331486262202315295456408573437125156466724639958071186200478992889785094972701513151571600988355148526641362547833068e+03)},
                                                                                        {SC_(2.87847656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.05488333142385484475172231086394675997513598555597927149880029602336592055157215686944121898079547454120473162403818969784561780587409829646247504392438937333878527081074729746707055807781106119400587389122460380472798540673783756469393597940336198328358765912391012719893796119938691127824492393390024337162695503763365189158346405308487182330286763732886461924685718989878827547742759749172444382918249208907202795905711165250423993743454148817205211384215410228405451755126541161105940267179417786e+582), SC_(1.34015795429701939942574215884873268171829288382888259321946097631111617705856662268630326933296580052321731566208579030576247439487978876214455592691116488996075798205203434081869502896527521310827175861845932374667585320301486324405673936118015718696526683793997302764133847612944974467146840256219323504629417706791770176592906004328833751304210817492355088454830780250303083097890307333413326840022932241452011360024877985974082037233006902679105689616851317419865646462378346046207873620661305058e+03)},
                                                                                        {SC_(2.87923095703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.61684979609188826557433785440773960148555792324374067678067834299861637368561450106307525352671585573317867164429408368840880522152937413462007909841896465904377450707318547717135578445169164662798065627783140430551912686608583002804571332263659013417669912496006462805471741068963217116556314786383894369387772034685007293610869961471282286948420396155589385700260825498201238850550110498224894271051040877266872421912258435469297969201321900601286747279169221597757038086685692437637136225209143506e+582), SC_(1.34058500380833376294160862615122068848333040278064690214068451080901959705990853634557062938270962751717159291653068462794816644510986319168200062866703705462037244373394257571865160181401419644160859261897972796948215330656254270416551336873357979648067859339304940383975005645243666175426992692972991225022622372254699271228283799777421629954043892261138987364435140375335941747556293997376921219156934051083559138278975404970391878774938430492037198178935947232494412932088773898615808568060875528e+03)},
                                                                                        {SC_(2.88569335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(6.27741314089775276511662713730952852885550809492562065175360622922536441326404367039128777413795090721022687150934638106628044085536081655315565411956276941995535311165878475675560210707191190941944139340354775975538872413921188374762500573473008692159211048416506508286650565395048219704920208731057283266429575656706558797306599764260726777060658654274541773537319106390479236547469858462458615781476042654947282967222646330746160526064130527966019089586365372152408709894353252495219303939603925911e+583), SC_(1.34424406719090708283852098449092651192912931837151030334253769170706457371212899336088630689782681161596126592790226138758892991724817294626866326137374819653365275485198027843272426021845574546974020258425671147145124463062447922403216960551913842768213917736156663567898484068184653980953644017738392003844971368045836990248784629112811882601436186180470639258326211954852039109234766639251154066833651535312785555213779024424415503778104636556624356299490075804415075445824369005752080160909590418e+03)},
                                                                                        {SC_(2.89466552734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.01178709497846633575165533850964793116822976500009300460736484473906170654242473212160750081881335619578631480862662045163056219988351387754652065630298571387779333809261319746397588721052457496790954620979653820354502309519248134279375683394749297528557515237334478119352835566833184270885227059153740462954718070282552097217238130663545041619512190536745623409307049755143899396219233654553047903976192302718046823190984233338148151019490057620084073666415333004114164650667291546000971693948968025e+586), SC_(1.34932658266278691125859195957356839411956915699838787964270475180585781337904192843463069811989682751105935175120186948864564892651741184747232183683168217893787273582731706152927840688445099541626365323387592592041451846704444548113336365976534758003932783295797338006880559885771565077791261519464921959795073918357492033133764272360975900011607333798512551165276702158609418085774985022998054688888774296419108809744097027098104006421214236914004741214732590966674674694137924684249925480058631236e+03)},
                                                                                        {SC_(2.89489868164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.15468963660064415115584928103612267588077614837764974596676794408194592122185565793366081442594962402231039476916282301481556320279102010770389758954453247008452073441989922664993547819970643883248670436781951311258914960269324244050041217630215108215185133895912128085457556094388818808134157121883961858147812512976161910464056272865818289179486083989079475337016803144989786737740357104787360356449862060721738771491736407919346112388326738341541162845086084757313997223473584824259279211478804411e+586), SC_(1.34945869608947487230347117231108718546669480068803317382610585033887701772499533330299929944260993663552522728552398357556711034867195034208278794084259708811695816233862643367643062820601016048591685465106412204058293624776401577561087203181177900125125258123672283921830786496097423338541135965015952382557422338835010198858944846902564944793337215652278621428765504515905791790356949439200150223236234190140334977483438030495696668322005718859526062624691051817763036420840472519347075855357492120e+03)},
                                                                                        {SC_(2.90308471679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.19524147385219244470132948164768645952387402659176644248232649451332495743225411640806568136577825821777152429787665981081834982965099165131101583405324558957832981364701487772474908186677859521942227871761177456864386077274238636801172587366265694365060499384529511627538568144917639423801710131654895866193991508864772356680744834944104931010934233992516879850234885949044906537343760076941305434841384706369864894114423618730043116321097945958350135127872220329620305258329256908546446817698251246e+588), SC_(1.35409838291563810816734756587973452552312498779625060316470814688864881373868034527316477758088674167091953141712021911254039190874338424718456903461041158566566995442766215323510346525251570992128655213783112880604963189741218176389237558401685191050423694189828428853338979384514574558920844441337526170157218977419725134868817733466328638260429425757730703990119756802378165954215271111925226146883389726423674228332542752122313142235886856916954004866568682712083092292621624945180865855907762336e+03)},
                                                                                        {SC_(2.90592041015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.96616348070008064874616373287210585056507562010636620999589287370494994638712981237978044380341428082759476234800084979754154002254920793570629961443320536090682866102046046605575909343417965965786863402052114762451003234336963160321553061028955902745093007093806222194156890643879106073816537034619581310858126533043798203665861839587148380330784779496490854756078878399132529809488407011884977108694900450342769614999426587923937468534874115245202200752981449160856047469289211964379361040937933363e+588), SC_(1.35570613876827768573077212979918905825378195719256462745557460203157514868421975740484674201729181654869722967493198246560872283580334178114340293621977943603602674782963512789971087589677970295984233970171523356396353278946306310362716981717481409595008106739028777907840661397201950135049887277277864573168266510836965789963844289183363238578955127422486638618731886638218793161544590084681455424256159437152248367727430465133782606865132096602171707784451542766396026631027325589191849782149383204e+03)},
                                                                                        {SC_(2.90660278320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.78487236270559134372523056104521703363019577190355948641112828564566288084234508187456635264973625453609105185408834058802436811939053506425603401091142444688274416257771964890378696256189219702739844815243612702841684872668060505942578914671744054920303915520554542317257099862559900332239128013567708139174454799160800799479359760388823074434936809008038301402078792504784232356560038883331003424937824700805016404899595550493738893677568049586982862458730300726426227556043240232968934551456121231e+588), SC_(1.35609306587302902812608982250575970013655426141478852856735216493382332135628059973769783658467619298850029115736641365842250969915119354961287889178459023534224929246747384311345963439486525054390823839661530981177867422381755670042005241994627896444983033866940424048264962218653661730132248367451464387574438560953281658326212605514731096599341987987954847800804242707347529099158826463446857630154506916573407975685526655366112977283388320309871700245022364864208623837308437148184117729373307138e+03)},
                                                                                        {SC_(2.91177734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.65288544172897875410770232714425601825349427018691148029711608937312937110686432284009751145904244201679369890051895293597053443763047327488339669082164625782135160805589639800451672460273927756145545818554587823518713303746905567633417949183694304856777883735871611818181366535964619214875574773302753339939177908635890491874410909484630978002726242333092288199064599231824493483133047779107704498836164868091080313847473536278000636310060789953287199874170218094292264929075176343559218201978952107e+590), SC_(1.35902772737967500290740961714306170488896006477572595442680354958201757864757179384628434523781484152603766693581406070106863469929795747305410914816479507021518947006516764660803698195357271682898832241808649413478488026150607720256908884879384931441726651471512468750875240490014666611569828987242597178730792611073319550629526091003900086837626632934430727458829037055800608764129229909092363132011276878495404850882563836435689845740109981738759761066122048318825494125511548330815838220808734178e+03)},
                                                                                        {SC_(2.93100585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.07348913872552172438060537336170695465982561385886208512743693117832018077732199717190905087803442769798857774104262030358670872208312136858881211410007479555674339961299252020339682381441400147609402774950129163689293445870814413514269880409238879689669427063972157678850536572019976833369618099902132209169949898022422684069830381857850223500047547437065129388742129657954201361385942970743137393521891326992141234907520915338245404861689565251029578475667289010283668986078095947652654070110147402e+594), SC_(1.36994090211866285156780417655232681730177445549993872158956285643436193188785726991369168977180113887308121341003284593858747631687052712775116809792901903101954218175854827123344938870960635945662719476714050496919288772019479564922849963750897435183204879948753862050909808470755427353099908579773139831785069425719334923580159855697436929336266308377470879117992764845234475018441789422522336437432447449357161002266355972425539397318564426604501700562220380876996017331818203139894455896402617874e+03)},
                                                                                        {SC_(2.93924438476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.77518107286160192975090619348685174723133376553628978514345946773524629460259957306538236431218247589719771312904897231994673364468832936192930648763261752675406554510421585015960517353170251556580035420434104455460987866698271669391429345869792903624251090234888718896512101057543668173614915937208335613310325271905764376677121123085953021174362707398232948259813861064687908746718001238533382117006339455793895982425669115368795569623477820919153916207594666818615923030608437427654845589323915978e+596), SC_(1.37462056205422900177131768888032652216284107554571360819616514988229042546200969659939005358764415303560171951617706762255367766104958031804213014382297422319688298813058708235551668193649903340288755189361107742227218535513218626025724511923454804888841699955879956560431857964054712383407202631291071279632670492761422872806694902505618351331177643874679503332041813298770798197598924991078718392181492357382522981006972272024242659399685114078336370345259455625989793711497515795188040163459176258e+03)},
                                                                                        {SC_(2.93977661132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.32267646091032057264117479996725962524063346984656353737999020878114540714569282911520863318541695168857271164281834054963142403874455537714944794610094817847454389534340638997220111815960372365297777509351400167068848566151722017140369087718396312056664653998858312885922892976462087886956556649717842241242014839711124245453776366990487019310493671290294468619045840033136895236436448767316750131915201026320220829933252188274405549187295208028245090252555079871847589810273006546970939284455610907e+597), SC_(1.37492295782309449109513125899561559012571158869805461774571128862623508327145154344308277303363560712007750147659962343399773292693388940576621127958504002159547486877127912389989264297400117647989214449419964322617476628970597202261690056630970927254789905580122873272954213658268918564331212372900137987854833084079076994612249515996791251235528274811463971874437483786205972286614118579382608006610450261782073705056773556763556901941104471584469923293484169254077441965363686099895150541876731096e+03)},
                                                                                        {SC_(2.94332885742187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(9.95612658759241235812465447721400579291058507058997368439216719564834536617474972374272572743444878958103051493850804833730870744379004716092343451340808448900651563697297156202048777752869166430548783815369375498220508152458737361758440629525376251935383827962247422168872441382301877187549916802482417911130921502426517266682801257699745449609311421877941760615746101613079091796208143355026398173271348541763163751403139719101046525115040043357542232174700518755249666544791105896825235042772545175e+597), SC_(1.37694148861657372633221996636644233713118716362968775446059082421308752990492542112655016520127497825665984296675173284223392313052342248632938493608819811335501981095114726508649312723116398159369267648990864758183952369369770445747903784567043640961953376098996368833449404655587344899951792926546929552656878941202317332213546833149925267669280727273985344675937684787347730438104026654247170240234408656098467412331224560588064323246340067066697094595718870646857370782631751254388800755295550947e+03)},
                                                                                        {SC_(2.94516845703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.83235121645327978963100817691926829574774836418387041252367869003738880090715463590796702022923992217196258528447889299651554001166831682305134686392526769799710803338014777454610533469989652589439509433566027978504843926482018342141188460069390234236110984820182938829956147486561100168203492916619577077303831865784265002705832286267366697360431897838814586852773697832092310576413056123995483314720897488786618951766492245980069150290100881986063379460507766715485056297792098067046256423617545148e+598), SC_(1.37798699279569051539268484261116926029249691596018107627105712272865541497115761053413890113564648869745670969157330919268443233145801337544812367387678593100800097721720770745161522650305518636162761571191979553292900507064486484516999930986293880641437193952931866232710654194575975952948419442840279178032436129355270244808305285140265522939295089250885428468721564173451421499662803310780563761890258732979833512086663368327034867928424960488053958458358767844025973365083982396983240716839739453e+03)},
                                                                                        {SC_(2.94708129882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(8.40107220401845648858321104921071972573843068904574581393733823764249546522923011085269873691590304481547442413231466634293352372853447729039818860387039885562468765763029502515714810352804578440883191056457307887255387835951907496031875719157728495199161142225637130071543332928278068351689075504017772418057823100405861764373978896467017120010559182064013052751961745831965825831898048413917283981900769888374650265549295777335765364301044297505547526992362172175418096483649733236850451843545679352e+598), SC_(1.37907424495147840011273728574087035423995148549659305757124254071347258874590468030259998751169547830863350597609563279895276081581854639206865023478141526629575485808136675655986575500400042238539109670504550946591340944369138810818152137953023879474665080231350201114946254983398873840455552474315302795866740788207662569448783820137343972988100297969962440394649585435235913624950263561619116962468992081029657152257586899630418991424608046084216708981450979535245502060097857018787637261038447371e+03)},
                                                                                        {SC_(2.96237792968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.03812531361052497663902185982298310308174947039421642629383054705158980857570000458751162587598999442550969501344877806292995852725250408981631253697860552855127163779760351868802023611365392677631530032588967742210532444954526900204915603366790139056994017643045361160119941439202100034220334699283274680423864899468223399998488863722189803540528163347927832513506417644347437949876996312168002483041770887790441736368040946838609461428279363030994693956970178860973336803161860812605096805474454889e+602), SC_(1.38777326003371869620392442881659394314184212654519691976144430327762778605149231100358508014213222334062848724474495456377030199975247208148834458623282063601232042599945536939628832663453797158288206962000090542124297705754102560953238816317304253227969932378536387535488664440792357469006990375734638029351740072641073613441843630319110670684134528780043708170928531783433707135360642324541558133958904574236578128175824492672273103186878977416365615410335993463758678593509405604377846659869155365e+03)},
                                                                                        {SC_(2.96513793945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.42268882268952074762792640032759328684967651571243577207098863132733263996320938386643715579579017435978989743411936374344068146932966097272344712291511398694978342948608590458791621485919292779350971700628179667679496540992018470687014109130452657520265421986902521354903018585115809735769773228190274125898973941140028523715291640760179162562465935017483316456021894276548188748672753964780236343206673327046312655684711562528109787810072079323133569680198034562869753881982512229652220972629440068e+603), SC_(1.38934368908253741931372532546702657934556843402551609189277573514421266149793760035791925112950510679579471877063730809126997864933380968782048493657543835986069494201763329457384890314492279549032110236711683011641117230487222872313803153286427155320725106717071421980538293897275039298230191800669234084056995408670362718824696655215389113392924262079402147150679681476538294228185954406608139408498867983511990563329762366594282942222249422166763420544819861986452074220220324342192498318092885746e+03)},
                                                                                        {SC_(2.96556396484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(3.08733061572599544893095738566467122339497124976043359311145114037421107382597535543204831452129395887668572437569163689906023244155552696896433330258453010207813264506542214005957636106390199106891767284964638774356885208041408420667674945789610791509007783885145825791117492078793459984449939239069745839444108063354220391076063653936902128053840086474638033185257395909515727788319705878477916754725675853953182813578309468305653020879049779288986773955413261955830503222456148390770119607850061279e+603), SC_(1.38958611791455538539140025024903036538031954018499820241928788807916920697641911243330441981244344101704951338126434370919427459996053120718181215471398554261097292911510258611322258727819892217553084395333462783927901967145172807897271893648569891446024935790847528674105478865069966576665239532737860234449110568683312347691756466158270802883819994063820227934716748200182565368696233038948342327904478924568114816183798706309654091991387545998978688522428533958731343703051205510768373092342362693e+03)},
                                                                                        {SC_(2.97032958984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.65065488914485337721074521730378317515528229628211789543577343397595391938174832606127820734515276226340187602714937163390715058743098859068633184935898641707783987761133325136500650196760517011958526604789366334946247482909510255060404724687386577726279625168337690865854633129433528501591646453749002858311142169683755867562660678042345855110053262989058121630574544176603053777318271589497620317692160998865399367406053254067650471361244321591961589295685879444782367679684369199464630864478489261e+604), SC_(1.39229840421446158414059401187132308465849144532326911036850400577521133278416325647276549435266209313251580715048230645844396792187212931762819805221020008127577424752135079336787156443980414454085239925046645933754290102904357952168852201296278316339038023098146632704584529640698621272640939910683838008414574922690407592662197907916145616287751826886906546495409842041562181368365116016838774036741578085349625325880779969917664787935921372614468570811677294061895714270986400486024846188318150488e+03)},
                                                                                        {SC_(2.97864379882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(5.28875127758585664775772369274874818401612555425274337362533582990582452925126420407366036043790662099943119495044383901218555398621115723235238928105653588409977146642363663511822358973533155725179276190312086270135178126404634590785344074034531234013198254897678155721810803017572426750846395839994134507626212773021647810222310111491792540190659531837723333160099836715085173957624813875616612821165865440901899376346278715166145438811148949341025193888325761385753016316823036695320702455814532570e+606), SC_(1.39703214851901049022730852986132689400344353670883777626738203137218619923608207548281549143051031906814767390400440706239659220631609341726070691070420176759632763659935375169277291735366323249824862378629001071349370181059513276997413810375233807216152871265647861415532162245231919110084386980394699462489980738391925491112096295812580701854781624576489660871399540669284901636240871074836671380946186021208235418266668230761474074744982036539036786575812798817601971755281530416514867655522337504e+03)},
                                                                                        {SC_(2.98060424804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.61531408834500580532772107043602867378318404792385225424543370217147879407674321500374911123927570357277562524697982438259637553584359745286933795118383404986552639498340920075760638753755502412453774497591004259173728022454736997493074277223895857096584808764955869835419159070254683890288630184887315794922759550515510816638669108715630198832675023654497491609554019113095252440785879594593167667228731692821379267364932925196667801205297985835969866854522482571646694590676945179339543887228204610e+607), SC_(1.39814868086709855977134600387840438343583009672475568261584953393775752729727738937123850138906948368004636032605291156804222574014398500926173351016908140186665959288084045641853830719487264577348797044673186837903257068882131154301224780038356563500545676816291258687767861560304780331302852986780045909398150637259749617748094043327095465488708977742593706777925410210923555828599996570675244242281042710938814482064622965171204431371102148950469779634005498541620629267498792772123502257932713979e+03)},
                                                                                        {SC_(2.98220458984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(4.01913203092977523280798922135732173498586921666201538424869820403397021600598336952297001121393103996753700542498707650326540611849768481692179717994242893806885476998794194069177402969333682804304077419313651329920582994303065174179218201467701455641283135646814953713752441619485507729197595816610567605231679569858816613945496013444813775087311062863524331036489035253800580130826760243342656894102452530853716104597137635561147441993697282252144814718162145119113329588056001316458991522462383674e+607), SC_(1.39906021741400012029338130541586138333662179441839083641847107911711505118695512786481488377805235221735334811404941246813329213578760870463419267543931597716815993356185010958460750220171890471303894087628503066112397751519332692654209127386583618306686241745141251761759667795464413846509226397693885965049803383803654466698341256620598200487751924572966951860386083834483840696255431542474166307319787972505783717380451523714267226550702752068744046987297754855271129593224919642276008709133005615e+03)},
                                                                                        {SC_(2.98840332031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(1.37359841993752752389528450284952588719032553998539093362923427163165276024392153451598136188470553429960467300945028533480912447612482726879636453056079900519350243066627735778877019724228054785376733281199049657751266188715082124548224606743572715963969774355758677695418580597446243619358673177073028020912302484099213566739309206579083967639513232216832100329448238402774060440556297715019456445133475901481261857483140680673267723791756112901783745647254025067495399407661967818140243125299861096e+609), SC_(1.40259175551366672281814595130199410206726729048793535427543493341189776121812450027289243449216527426177690440806453297479911126820442254294041871764078115750415836544057504032671813463168789593968411175040793172851484985271562547310812254585311571787144326593913276030237458872331063762566380120718695914932132664401415837970084609712825212122574426747001629920494310178881410323419257000590706416337038146645031003353012865121499434464278050773933392813060464002111764387049713996501739204866162870e+03)},
                                                                                        {SC_(2.98938354492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+02), SC_(2.40128745781682226203298236348882106711204113071066790067117306638783919196024362048227271234435781132783597852292146590334481038234871609134432585632142383860946595598143957411326129473992169530502153830116859068966251380887313781290116922728446436656897956438795664875165432901199002549538528328347418191193679032353167804422277652497487087572561212728720626116567371242871992837438704365399851502289431526275160228324414200994435018638728055777754033817606169040369089679889121782617702940071870648e+609), SC_(1.40315032666765182414481479399344070753898190684807352041095511052632440751219673443203450724260245162755643217096319709443495890300349565793981782778265089445631678243647078286176671824093508710391601904934585748839861643245004319166749889346213348676303548594053569453927749612822683747646552949406957321033730622162997905829908280484876755402806887983564631942961328692424552970134733664909306834103499207367683550933062248358174018199947934705320477995318133774631674009326510358690314737737744998e+03)}}};
//#undef SC_


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/gamma_0.ipp
================================================
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

static const boost::array<boost::array<typename table_type<T>::type, 3>, 101> gamma_0 = {{{SC_(1.43156441636360688183664865448643158739330056363229723426222506077465368434786796569824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(6.98536502143685108617882284090181520784225065279944459321343460310063824042105596746205061501871754388692206421700826292338586923926227628460021980992867287987375102820871203483062060697666614954318393354992686094982543110966849877446263308176165064356911280715433887048666237697473022869255273999217684089964991492221986910024913642477585922789463545534969256995761341961043378489622694491092689099559034124245255841747358458264103951568451574298386270253381902108950381976482928860300454676297330631e+29), SC_(6.87187849460716195307241085972306257332085866067179593404732520056618176287191986920381800623266452019036583359883694184875415202170061110761480957915606961682069515921066423464205321804055901215315467103669400564886703708251292818882278221076111306170866005908677608207802396451776607673326647945821489765973119269856654977100758235960633379767322574933089743488018675093572248899118887185116534963011794036363538903828089102456817460307090409752243309227015705466471210473582150215759294410478127318e+01)},
                                                                                          {SC_(1.79146693234808763489644628257161121326585477954787539722758538118796423077583312988281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(5.58201763003960861567789539135859580193439485454005702914698335930268444742331582630745213615777247085201364155083693868300803234678816291383457578463565723759685983298265642045770249117431149944641399014596592494299731209900651334858910291525879151363330828856538879949073338110312308363596227316892822743368020808448586000291704754174750156554217552056937856371791137981786534012294619836443861840926728414921766784846846305707429974243911452854519547303013841568504048941438592827646572038542434135e+29), SC_(6.84945179903097403861349744215875103992060757962123025404796608423978602225846553619170965077356955755357802672163974219562277828210284327971512344158362567867847738326049609853308815256769082679556958330239424646993080494046302980172303736275513780193302833410723002758066285468945113082751363817936859921002909109039191137803314698577973722031573009127625727285778678734025455705063199556191858178447008447936782744160858096688591534358039500459582424936993394926936663017800067374964851005923319757e+01)},
                                                                                          {SC_(6.01361845021915553684662812684153866129482788357822620195491936101461760699748992919921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(1.66289233059599382108622045278925250222879368299965805063800397354768670022530740489524286087023172081743657291575193949292317670513431375657893264047630789615214924106176337174346019293635258374337002078109120613262494521256415816444259140590129490551962102684902275473895987026116781659018530303429482685495372173326818893646289757008674753758860465244922365484215329043013694653249383965600156071526093224196543564395256619974579165365709216420397501003922915691506013990491427372931318956493080999e+29), SC_(6.72835261508627487441809388914618718039806766838076765738449388127304650638500226155393279449547157554874214601262165687120232963516589317117744273330309623400314525833549943284641956342219602925993192470847874648719472012633435814459477730435577468888682456785797630097073380249832077254791664762750315685378649126380990575187276250739357550980693771790622800409807477947479455730830600697505092486997466317766437101841783321172164072094610651193846740792964214770153922331926924938123871030133738925e+01)},
                                                                                          {SC_(1.15805324961653822428570241697281798757994191687720197947442102304194122552871704101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(8.63518150250108277194016891306233647484350850467664211488828521671098276856027646738832798460638738889745235576927151073499175108377545838358386482265787302310436375999567002230935819513356910576887220572360144418394608202135272298033654003052182297572299115574956232437725263892943148991293370552472446011183244210703600281122859489582978101451793967074375924992378742386032880290147673310487052110730167491270221379145909984226467052326276061760313245928809376103054222364829784917100855808316020815e+28), SC_(6.66282273346089416734535625179362666621182077643990467879063832625680227791050206585733185502957596233314540660483901760430911805270185678987126994680068402992221525616904588488441229909153800950377006070324398572799927651884646302955793101599665239041508783676953386426252223745918060631306977940834262621283653711331967519129060500243592868823804992668473953470906948420875648942763002156556099370463527314476558063517916220321125974741423139110495117826462394235672451732466307699999303905633370100e+01)},
                                                                                          {SC_(1.42245694944417038241730866879301796566459337427951181709318007051479071378707885742187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(7.03008973586689712434453706188967052189544377452251027190548933242786882782597583872281928283881475602762471967697312305884958111647827996819565671460034196076646349776435256364489761767965592316774008837231548263375054937427862888061428112304485964913506427137973546426799224557859735091281967123454997149655374130493654203587146086260828222294410435287918229997913562020320493066804583330730837073698808542435953750233088861767005232084367280435329039878489987209426255343649661690999646366391423086e+28), SC_(6.64225820742780683535257712261924121209227913749076443473890372060519527816598227736042607832909087984911015926106929130360483186660465408894557878927354666930836674850262877191875658008191764865453073508984311388701881734517396030408218265504769496117527926393550877643119833107884441914845938545843378909648403549025956978676004449802550052939417816321088510807702282974630203123683236264607529541476291560195226774671285268000217027114645279781317099602573341146438849056594216426188392209461223262e+01)},
                                                                                          {SC_(4.97012101832753915362870547787643979509599986062878818060539742873515933752059936523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(2.01202344231147724230810353716656887566130414385907540860402251559475890073645391277780480020189554969458171902799377776861135178157011979373269790864340211440027520775401007836782123067346497601513358857239897301150526329963708751115670484000483500722297344616098324545158500747555859233886573924190763930230809498621227122379869747916191366861272145295954082819043984946331634617739137084318984472461083170724165845505521971897573240355846211686074477671195963638013441293957127903234462875211715646e+28), SC_(6.51715235072511457864378388754998157435356973715673258412791513444778374479836727125230109590192077325601920795178505423399615183618242933697838040985779154418085424257031245674733493517221878558879698506150447439006049190511649430013973295257187798595008470757450564951138158522942211934575884784926138442646487836912254893171857625559424638068958366192061382628054238930763500818744359069789679612002531155109612303921215254254747694195676813610575246106335880547522974750286496268913709809509252474e+01)},
                                                                                          {SC_(9.66007941505749759175817416441747844432341024711874410968448501080274581909179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(1.03518817706743243919823284998017787128647257621455912634163869070166059872671230538431901891097497439179354992612162157669426027906636292231895643723927703757223460655854516477901321769519052303126616273995428548985832279710011127934672239520409848031206199996350739655807535213912727774552045467776829721969059974045525292499046126524249705366001360881203124736372820107025125261106918354118101667092609216938740138156696613533257159162712186798710277184296626585528266265769960723307483161365376229e+28), SC_(6.45069658276162457259303572398885329683158361494024827181717336146058546986400295243949312741758251226140035714229464147482260893374857925924565517856610305565502975329832388352253205506611318819270307820107725007303695608214479732517695140757758354226761553744330994156337100540242975402121772398848516182993789845650062348186821501621405335217798478394612071716443631914367377297227176427909617300917373609884768866750477406306294818746619910517952227127526727803071073422415549147408253665298301300e+01)},
                                                                                          {SC_(1.23292931325318213137633109542739196875415141549381381480543495854362845420837402343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(8.11076506374416877382537129208031545752074797419842750844528587451643362386982055323101915507674024859960406340146989444652626245160911354305121401560514918118286169465374662239310666900739378375958129364148653331105246827262534402832707407165597662287434176607244865340061287749891730809236349890319758864866554723496495254063628105477907236700688483571320960538771287714513893495299885765536699744850957588500735883090986629317497556750278199990341833620560130060637909786621313289257460639001650831e+27), SC_(6.42629897103672909988458723024910870404416821898215222127400022516539410704531383405982899412381871048426582739992646976069868034841151137810871632844074572909965313276374324555176087210170807432149288863515134794938111522097235775211996947623050218416749855639680453817148045797399149820883035794559402140834591578682886608367287283427546427869980860693429982414804171599334229599589490584031942607532254985111818673092821904070864890840147766974757375588542457697599486106018224639916097437571599819e+01)},
                                                                                          {SC_(3.29652280413527321597289728537034730709403803142198974285292933927848935127258300781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(3.03349941564355360012064150184228595706904820067783154892030109296391762822472881195726613182210189442955174212546738337284886561017336690039432370715941439412719089329892531356865265081975064636232370994677816511211572902921257370348330352994628809490300819077932611462301055106584074350770615111880273573943059035962668811432859854690471774370491309454815309809006764621402491823519351139477097886747251831199460054088808790491284984413259166462592982630156453579922162794986104508307975648736654540e+27), SC_(6.32795143866050323716760133418296904749863732946975200928947118578322607994583477068450164307701602413609648444048639207929029056223035086133893270694677420843751377393407833586002432242261752314708430347057295480453578837209532569699006883030625680960140262219134646858202581750831824382271631031980228590555215920432590868320228606184600039560993755754788437087523337075244902961115198620434131953515679906038170612236824559118585723278727600502113865815188191107710031491713156376132212151995325781e+01)},
                                                                                          {SC_(5.28364435768055252017009628713605422886039151425530135952612909022718667984008789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(1.89263306215217388065301450837422131624429762500909613738277870523089267798630746568964190871771157247405784615737404532079180608133788878517212154426651108760035114597438980870405792535468966738754609913368846304859794971254949645193988742238635877174034183157545953026521100953857513511469947369943288857923008731164449119832620087394383402735741445779931513137986706278546522549426676715586900797211295600476831080380451856593421444600033324608401914174483790915085395318359941917879811363209587464e+27), SC_(6.28077665249491897691049827940636540970398543994861233169099871356964217589347125478155697980887940866179062958974044155963995941441194575820156444577833257789890482265650964581797191647152323111036866463941206128044651251402305746085176458414290497006593109264627423072684766714099596688313036477988560744962758440194036696643717238708853234985639383334272562979038431089236482058749177876773587848544135873987589282606791220573117136189470910455726053001892397518963850274607542910338241721343457177e+01)},
                                                                                          {SC_(8.86586057273120049620324386849842094685003081322438589495504857040941715240478515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(1.12792209148394250283821637021946106530198113703610911095488337733749683357735288766824599638075655918840636782440721083365515523554739468482924768722301671735596891690745164252007005619188503105228533256226946150583868513360183143203542320141069898108879458118152610755855595193019270900648744728405474759634285607695917755572614881162868983190243597181686385780385043194947192656483297254721171554847487312358317557282161067168244426453811265351416570323053082026986937719013776178742039427104942286e+27), SC_(6.22901745936964236807423188366699491237395082581362863038475204196764335339422677682424533021060737567932462267191280241127353523262734638192900266136858588339878538342860483208191254394637373839754873788419222515574108790388057884237928241734260216993505146375338473328907938233508277422196718935311128911439714419720575361379606654030425058941565427488999592176540230675586731103811757799195001504320404652187910673241283381657595695105566385412255027821045966205549848464433924669316746507256885131e+01)},
                                                                                          {SC_(2.49966909705205994304740110602803937055616662066270805553358513861894607543945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(4.00052951480390792753792297612547756446636308354112378451456968304268692528633775519125653540337556139742594352743621941853552757231088824292247450739114201180697920406873694369842101729381223009665109087920683089903813373384379869972135737762953748899884850561862020898979033509177864717063968439364396918776475551700928193992691475593786044265808700917232151033008792097742668057139762411818451641133325103860432283894810997209741497147809418396090524305457199005071908197450896512609552069520382170e+26), SC_(6.12536391489047683456791920395172307654373024181199187144911145425432965478592302886538061658534635912284286031438597728058141651972777704999971671030797848009724431879789343164823041816910201631030249867326068929534579895965669649438343390853080251794078983618181753609923762928472591231131609267962196214873011951877052947425588001178855301901711271913497699503029013954248204210958479220752097373121722687614004482162043568710684966204871567240274381394573742635156718926230757319557118639628439420e+01)},
                                                                                          {SC_(4.13105039723262296431436267163873604088076066376267192481464007869362831115722656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(2.42069184309612078735610309396289531456075006005701452319232308780898469481899786562711660638975498443576891437412380505348319376012700732093473068914701828605341797891307189106243524744582901965865091960195620144901563293848963647400347796236403212162016330881728652090676262972985324378411000114398851717735569482703793791472186452067039116212437053446977932154280424530245898016181405959157039069608327504217006545118390787849039405560427420843900632344217146363244036322483055152244720350520312732e+26), SC_(6.07512658027331975479577088722915968953877892639195256368947344929252315379014575284754474798075879668931747060129256164633934573369599205358256458706635358062235593480105093770678843815652602539307431543115040519794608689731244425228894620530188188065811225372150482460249371284136442858221115772490874167846093958384149302455707825340823690871444826129737661538243254629158931922087992517687225059329004092487025701375624298827988692231490866885497114885255366053276979415146569639295467508175390497e+01)},
                                                                                          {SC_(7.67973655713747804159297628821628769124011532065665619484207127243280410766601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(1.30212799952181823165140121882528410353551267300487990139386626525325211291024568030230970848519462523321250316113910391542233495172804953518059438162757195427412584355171613764849732449793589808648756002181462999052595392577807540209762006753250735181780410531193269824922742158457533297763018004418385433117806616100977526675610500618779766320207731845672476138902627160544984413741977497354820351022582824220122963569820651479542153114314134607530615386140027703759180101932525568349064975126058165e+26), SC_(6.01312122667240529166843994063021266541288260960290414568544325404195544575095829794041035120469854123574649673981547316854462290304396763545774453073567613797603142297644704020352034632426024680109753030361110840049738676836013357598960559784241302812865391854524389664056261621870677748278809719438623073587488273527342019260350532258454443364272867066135071843918273298351325211729169344200131324037636430369715829612165506521055551942816236666920875284797438923786575101586645401435561328322074817e+01)},
                                                                                          {SC_(1.99929709006070097053663358872093457378141950764316447930468712002038955688476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(5.00175789266836197992253524274830985249917406243586481928958356437141598411984138722862492208659648540426313645171261046500070366734305739654716860293908480183345282315525066342879659673808912526681216851816527758086674670902923821816912492981456459220446807092272059870287398917856957814911955087942529906020699544749520437288684229226072743323074045476154958594811061595567355441543116054826269870495160775013279838715048442052026193416237173077956430343800236803747119123474588037106300229115319493e+25), SC_(5.91744167540296642932633105438455466640616516641281944106250379983760813618537924832488310046560748278519239110324535565544143210026284763893696541922381258765648942880722642974790705056266372562023064784175361677559270801762988065916285030771581562373334272877335535222265668349615364410562602776765986836342337156864942547577113767363493593568061040388382331590689156231846893431183969526225066656037250767253219801811525307324434690649574834704255754342306560284967752740251238298561968659075731801e+01)},
                                                                                          {SC_(5.15147741524697845975412980082616359162571428864652034462778829038143157958984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(1.94119069034500808603652466533066021838567012298869439701340945032173827546064073709628358298435505063869761045803662384531648487567393382773594440075435175724183604412243156694194932492028878970941961283821446471330266254909674918925098980942551328647919533502012637100674140444753442826674029392350808309173674621706803567435055313380241398358750606063235436398329157810706396769069082270097287993911924029918948917243632827735362569726563281278358132173640383259378355790298494643627193841009125610e+25), SC_(5.82279288675638227521744581984472667501463857487542260681762460523386320409989607920181437766464159215936294441689087772286732842238926045596412700160862731390874584038617859265714534550615456175097106413483539149755980595702034247039218440752863612649821537138773308438672246983171497554091758620898857991717016801958594108321529888222047270727588727745793441847528628771717744394905353164071527110746942189167167910378796313989630478491619937958186173400443704421577577652506214296565647827659664193e+01)},
                                                                                          {SC_(1.01200722207604382263949018037021122481435020379336719997809268534183502197265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(9.88135240723468294587520823096149819619540476689712710623997817993083189475816383577084956312949922972156866572877356452911798009387999009526605954163888106149571728467821461881641485221579135727239840228161933168563012454259847186432292992881836215442485054048489450902048271065397568687760395141387333368815582691028472081451393202540812412060789893208592124641855931693833129410253652436457888009028232812205367434613971048802458771917161720241635834784826416484240215260071905616525517892376198493e+24), SC_(5.75526916175725540760017008791674277403750658183657019667573395043965482862223161211434510621020178646998074509782225975726388192488504530392658732934512207024506529591122416739406187792824292457201619483969139331538455509702323358241424076304580592500270106222576434714589313899240402996303681999603577990188285524562004708292069045649249373724332501528425003869718292101485821916461949819884935827385813682080426761085178755516591092075170285475651907581965934227857501471685138069598110050036387246e+01)},
                                                                                          {SC_(2.06429269589654098179854645662305491103302723665535722830099985003471374511718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(4.84427427364262875842177793582518195279767597643060376319794648994297827081054097195940382072797039218621065892526441246106534412586907979155363395093623504721783967370117346993663134634720015066493921311731770109109810916776708584865494093815063529130112517199074056968525199230121554514145114301260244921843558589363080736372954820248471209753932824991565235931747363147022272578757977659537120808256136053752131562400463651066011428784940346704179494919962842998228211078697496029314646389388898709e+24), SC_(5.68398396772585233454081243163015719457273127694317564671579909124104470082415630897415329078724340316758032857229084552171453692626527967609074784678664906070359314921191268418039853212010471717205985371362797477808024589535717680159846557085388955229865201914116328556336605417711822202289369410146331697923086998315821256230168984504108244541247998403612502502907727077479891826525225618196587293524636550350625327996139236466781075913080290453906357687119354962653760957324187035168960795482516167e+01)},
                                                                                          {SC_(4.06329433289633339525743443387977341628436445120087228133343160152435302734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(2.46105725569527169415983887680710324054112250788475703843400058327137510398066264739078011647200558087326350808351871985106152690049359086642413238317408836089468987877838079876187296081669103803784535166355608455966760897587389088115522647388304688901396509685347705021509288980827182717349153930357355160998461433103157942190593059970182220422601313102141445390082271181048288342624754879410555438595064913555566952651043246646544339420386855070326440604309211163343582298939299136028028873165480769e+24), SC_(5.61626332682108543103894914638265205739494039591792063561869770530274312850585567765343945280850219080051628164852842207643000297697060102013357499398606383713775784855806022728186354069091978795877261624547818135305576719244903321101517119309704129792662326041351319265014075608624116830962662681594177248456643562788865593950429324530694066762617857478074607527695679287002457200156179042326635089136412749258440888089649819236202364351423255552506804629320072380909487742338753291737755545443775797e+01)},
                                                                                          {SC_(8.13819478186073092670198892427626982497279595207828606362454593181610107421875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(1.22877373521325115162328151196138471976141512712124850581584744704992399909168261635541263516328487781554443968352277192925529436530024421006633112093621416957359244265549900396322231619231727354042398710426402533917291689560431212331314867942163998562472153269908152702292325979049258401011838074535270886141399120216251602299571716343713366066427282233107466768238863223341638688213559918551782217436488107168907078748350405159172588636795924752838173975951774548164437216663669472739716812900706291e+24), SC_(5.54680589407017581449312663260900718532236752643429778887916074462724851849598244854808478563726062042713449609513298516922138485589080042918533500047818941095475305997544950753739499731683843803755248795132093107433712169375661072287744142881205356719090133730530388524199409758849195774801927230016968519619337069603229936339950959945894614972178336489693903099001770377373594374895517334732896865347661491160409693023609464135192154062110190404782725103313309390020123729907971058891945976423107090e+01)},
                                                                                          {SC_(9.57554865497999074939999660325683650957673265224912029225379228591918945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(1.04432658224751051534314719319653764492076403254903353940705501087203904226108528788809371267534452777143739782207618775861320582874754248864333937039501094101917228222578478024350733644382871829557399595988827405718915208248754996663898673158999141554101618210328270114242596449908503778350906723150268970162028603276526593042556952793500072272667839653724623032562627561836490475514812167562140191244558846393493937542533932600626398969074932846968713462462457715092757436435680895751950017915638130e+24), SC_(5.53054144906448593874035705960252565327725371930035233374475045868754601997131177506417834643641068577542592682508927413603952599228162183490902725675527826513870330578615340807530339380960658869221743008220977723760935754238139593711178583463897078717435139016330627214829940443565604990205981580028836645095112579577358064065119684256270078779601982060604318757793537509382142428577689380707350625620009954407756292439931086645123086101261977511377525026818121340639711064353707057249378932596923274e+01)},
                                                                                          {SC_(2.85516056186804819386971813584199120922280101808610197622328996658325195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-24), SC_(3.50242999765214323664192679073178441988316976402121689738366828010343200142127297877801696998138244162201391895289627133288966388269820082791501666523174699265748272305684918310912716715770179390342333881476222257119067917382383828097056575473305941584001441668576626536239604665841289353700793779427804962841854234138298713674382597487122053790601814569968031027493158660860778248283756870286152743158063320918616278309751952166743130766591170707371648727380827196137739711391014068466505661904440217e+23), SC_(5.42129141514975251800903561369021896767530710266420752809382078867957345755941405132689457634465145272252196685234760413494992978952209599519173817340434015117011005940702842923245114745048817216891242529483752482359028631069418216006995563505772451582472582577624264823737226327430602918404820892619934026026679795159577460335018994519482732498954471793682959200041271002531143558773649050588603615579031798187421758140576055031223887773975801539821645805264411679468976240805660854787612427720085525e+01)},
                                                                                          {SC_(6.52014364093064091884456528840346284381368491267494391649961471557617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-24), SC_(1.53370854243521973586893102813914310939965427847284394727942326816923530158483359322277635535490460600254860546777471016072796682814782921636329959096588533379368302049694060279320304899005746782369004567388608876800597722684498185816580726353948738996684213751763514979183260672977613294821391044699592421424071378526056882956988747680636997296772179269782489944802968406726338812277631440999738435783684003696158536718815313665608295411332733865266716369836200650975268023336258804965762457776544875e+23), SC_(5.33871458253436267660312480785009601729216078741234807903756510475077269603543815841324029033223878574917502908041974473136581597194818255013348773687457538072821039582681999557815447099340143448346969967803777016864105080422428146552078395204345173179644042513512657540372581522428813903397886613502554964587865832987725841749146742934838411775381167966256392170311556144245615596487835602499722904753756187542702952227808014818824336277067590912165157720497569824343819810963150406333187486453320164e+01)},
                                                                                          {SC_(1.31098837463635003832097749177504342199540587898809462785720825195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(7.62783270505648920867640128917029682085014404223298750921210449188883287957637267346963792923947398577101641982313673140522903767065871959681776941420786346990663932279594126922699186822003592857543574397975415727821273939141093361267052683898474890607767272618049135227041257172444582130532397303361510817394714073504522661387391945133312715542154642780804313417668739292346961368873149467702801677937149054720393235576921825090293378239947540846276937347389762949029484045230989398597611258299015322e+22), SC_(5.26886758016750764532724250391453133579168931661122683861881724102784766335119510458343279795727755360417828961523650183250788076928558998266697318508102942356639306550934079657348019990471331356616671440992693851502497540967879695178087358316196135449214724222581033520195801247039827371115321875006799826166266808354064309683485881431194829649247848425203894402917390733452728328994293143443163498889486622254544214583416155521738672267888911298790423121376809223944061169250554139218709440516067540e+01)},
                                                                                          {SC_(2.59028852225433412082328801177410343425933092476043384522199630737304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(3.86057379866586319878799465520462508773374309731222147451540412289649626604311610271505156892543734630828629717871661915627739337921111016296975526068036546011996321933999439105025263806297456366301563262085095498328808608921907606929694250705204329001618943812913711507301443230672701441796481501946959406058733878796305518832400784536950370251240917339676666211604312502114193270809313318899693038913600801258981405147278842314317813074821654637246696524927484395930153180957204116226311041051575070e+22), SC_(5.20076878708021655204184517590029484781779325945365320134692951662097251746010442303228973955429295220624205734359293984540010475530401054700767967040031802383111862364495871155708008415805050150046955904324684920911708716591437325331213161883361059635649619622139582737775763756910681490313609300987084497727073273136118042184330561290773528921435330943144151579989347270239667075286213199707738173963359766442692057049676746685889195318181733518343155600767669257087994297941841427762786592820580199e+01)},
                                                                                          {SC_(2.93777859556056893705993279786690963728545966660021804273128509521484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(3.40393248664535973451643561545599015646480163251746595187335545294157661290070259654556490228897046833198768473283011025314766585326825660311638945820356275028504108010061473219261760927138383081243874282257741552861246265341571115130840175610661210996672096930564509064007280059700812172651108467231185451280522308365237196553586846212890788781209593678169565625983002898914954626594158457302304321444438490738130358193686145378731322940962556530139169746200404495578798523354146116661641285345779468e+22), SC_(5.18818034228480048495984841998696565418571058823007515216304504326186316117799223812592599800053866943330882932209733319774993987429860654967791070950192182720563465084761871021801510083705614519767136322047619989872914050805017533441004404032584098212597431832228764483076722028111823178273253323659440621758510792485130604460981055521765707306470062276856877280447173587180991702485468042648886026757392434693933943855302891392288442139215967429109453656283435937137806905507213701777697785708916602e+01)},
                                                                                          {SC_(7.86351191582705469613519475556052962250674909228109754621982574462890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(1.27169642610610039353264616927599175234779914344881805733869580633167446969597085449508303449649856295673996772851928970484478455725869106340434214033522429436281717957271664490947874357052247959982209769067209733807145329602247519581626721334004570445050566096313562487889013608558003318113736293222661115116237175842533338824845777635499715409458146778160438857783694339290802398515134559787128147139201279684177329341813791723791645732119236379285735920408460318017210905600269751682346961660174051e+22), SC_(5.08972238235817915756710145375177450823509597274772735688967008797016311927179066425401316234841495457645680749356303387011726052153995399350107102311415173522242349706194436150181002293398019846980279232678924816759224648575930356637357223960768881058525455547490594553426412812113145828448959563668690340567112115668860640488282014428626692311646693602244887490659454290033238900625854342402063608843879097706509412062070869795895634470749766615375813006168918399107358410251103233338070834608171218e+01)},
                                                                                          {SC_(1.90381848086964392834489130147419128080699124438979197293519973754882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(5.25260160066946451216401888059962516778732901049570780683024351572719151667787646855463099146585407964053825766930472772728698256660716949502801050859969127596546505976843647978026708358679238991719723994756553212701512367961114046483288579383813550637161150736903854808004565774707190980542096793989969411975096086259679433124457082433968122358310884166563878035988158013841190648076433223713075923687946218147161294236941276929535940783322870621803800934875095257103638684763412873109654240236089051e+21), SC_(5.00130104497222740728056396948021842053725671133632273915590421086540995885813788156178684793591659855727077330324357543560582420708812233670466083001362821798690316015631303321842998721923280159860116612739436828240078595075021023635482180195173811443143861016540316132682754359770001807411742030056445805013793074054109764814553533227232453792365752365826883614935008145498752931608573064596345947693694716816510723270897599891592664901791763900806485055510666392856983244898302151747117597853439027e+01)},
                                                                                          {SC_(3.81224138507088185839560978023822512827933906010002829134464263916015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(2.62312875547728931624265607213756815229837180169602095107327334620073176917117693941741379801758213948691714295468078460965756685506546144383314549488869924636549335223264787835030053818578531165584930072928904954024349836757669531292599781334847779073929930462134987001491872682250658594585821377388524745624403856725561382616752243818539754229843502888914770520037420032497262912077979169509544962261229110346059316603824642058929794962625900432712959225107275250144027312303800204614559719130614088e+21), SC_(4.93186547396602967807569716447834137730489798578208909181956823619940195091783373690286003795378305170062448815938262002666855919185740745808868834518988746793180050929189726528174841883797281208589583375771652408457949764152811572462780673549541833300927262733221435417215931929623799861721052593168258224331928041117341615950018916874018539855668865299897540452645987293103073809492246918894060636522018825311579944256307429299926433463157773358234415239424681932122613637285458521080913054880393190e+01)},
                                                                                          {SC_(5.49313358014133027717803441948574150188733256072737276554107666015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(1.82045454640895782737597987629015253196424399819770711984867168537754339866104500301965169548440597151564783591998096204750642251097138511714139431677230119316032123096723638435315702956082607856781221770795262706437219993962584257438868249993742164284339577414043879202101786168615719873186715666650725127913925044433708513784715492777075613064868451994980205253786155564432613892877191420027887520647436384687185562679132018990435662701316643628299136576381271167422303030261887730404064469821661616e+21), SC_(4.89533731735552832041589301430161251020130076163841042575523208601949953816095170371768447691586445244814754879873655432782452790720310931894083872122785341863455879689084514113729905769521595789846313097484306889731804610702066651582493944283543411813419736212048892954255421551910526337589242688284096162070571743478755325100547875689720992357527643607016139503743185301042251704701530808508066708422044540174423444837331714045278436889408090514469447622243967937763842767800209868922707391107115056e+01)},
                                                                                          {SC_(9.67215262454222827277166131629965173388541188614908605813980102539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(1.03389600931501929871097748597108012503603240764947686389435163117375649258678792903056071607754243833593207370623936419856377159806444481248117223998829490194577017841692422535813595410446015676576831805051126599707021576420891181154412175525551678059867804876476222326414755412781154745397066502491812883871947516897588521853430063495325076052198574002590913096133461052863926525420514129463693265405456836877870291872408610362015129227970482483273273845790259359266596054256231926761044565464033080e+21), SC_(4.83876211526414979604635716263705953424666129250468312064929767779865870430085106549754942840632302924184467393105280221031089458453346711488164184273691108029712931250317685626244951629221689589424633173262031509079949942052033836097273287253793763926645896482582399059720693766548808207758164347982593877689742387604381713327862363173160844314328159732166305198258012076073150997611295564230600179954076979830331378330132787416576665241470078232795284322184660642563132648624641834323472973518630605e+01)},
                                                                                          {SC_(1.70216887177863917482281209177935599186071158328559249639511108398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(5.87485775694555373167830190810947978074136007912954035211349619261705336638409363420065882452461996702314667318377905295556382085566956103363904724888053444999238638638047322550676699560353465463822389438155518513284160800035024841145198763981778295086704772143892266059585666296705036968955960094559165454125738827162309721849410190497768549790407976026865987343414380830766635337193966062235485294062197370443236409650307028525323119441263966385207051043615749087468096830868638236989811223697512846e+20), SC_(4.78223837080342956793684677947106154961522152824515734094452704401576955395734057320806187417084580015495705104032785915022776196524911035311341716253866023844008453954146289524334796068740032756280072158706992888389727754165739635731112302444977854489414440643254915015070323265306535814024253673397347468234679060454970156387012906763493040337094509367197022134455190670828956855467931764615143248858050259521769945653420149568573354187997851604834498374939753381150748940039401972150105022390568142e+01)},
                                                                                          {SC_(4.81711376218383283936066573301115756322587913018651306629180908203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(2.07593187408273119152469340787584993890199570636061024535034187514866784687246050811341044476827375433480122929541167222047975713155197480798124497902130577079489261717652034359642106356416547649168312264735412183148465876725562907070038342803242173535250774119973305228029222184206457390221388120526840827119402382489085565296916043218667855465146608182737262945596180604152319863495913770032065685967941222160843715367489927722217409213962422170874267170019204004892033424089148243078905283228037205e+20), SC_(4.67821120086936591155861343624377850408269305810050469109688472737615468051095256528958901042725900832184701847084075487537053023539942576971128033660153998945676607285872594089641174041605333823436914379532594652603569351790857962248245167080191475771720972177837880349399147575537558363282997470664643874116717082159563251158697158617110481785942129499655204492946736783592575692219959790344322588335340149192743106478058297032949955331719952339817796143077569677432793189592681892060865012873193475e+01)},
                                                                                          {SC_(7.53835218496289623698718975960963994964458834147080779075622558593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(1.32654985527838137100932148001816998202531058674126548560649347649621723628346782156486921309260567626575505247724488705138662753142944879073548888865365873854899374953797004778789748638581143372102322151991790136819332204708988722277664693837174949456397321602470382326078211353728562381264101144823679289452835745057195794802022960930042459359943364735905222631946467121359896176823730763057059644290401154571759016166486610674803826665802666272410848457505223641701711941719977501447883034136159953e+20), SC_(4.63342833378474888230149349666744582083410493325092779782325990451750115439726645419432244279477421063064027863192770563073507505859141449350699461178579618829859155282280329464471157435721507507621366940722327450189318592513979948532139573299619587090909747514578389070859627428039581931779660251967891631196240115897628890456050781081363826940234999078862646972605461455399964225335297811563651185144751675814309192435649749296000702432933328264772882595395455332123984715360567248273515423621218181e+01)},
                                                                                          {SC_(2.59630539283257292986818211277810775072794058360159397125244140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(3.85162701876530232468016912812562115373016774249503275226081603451011972263884092116338217726073095315378831950037360909099536077599495060933119624377088198449654129198262640605955970599568081504230936190952678753636882742353834162910291504268867570124117933635673759417794194750694611151724251936494514678735433147379446557816715174471231316403411149395136087982745338487971867500234281286818420446085777843840510364259879208876519674749555766856827657168205200716024970765971906489858958552410340209e+19), SC_(4.50976124281920705382894731131297213130572717493742609284798877986990697571350693999371678487948632519864994037977278991511171422997687213322493057461733626999725433941144937352468234189905071478290922464427713382759016633848292380102094051047990921816293731510106932513291229018355894945898305007359239076376113280775919897826671201334146282266277827196326947730939522373694958320901000146985783812074526877946883639947205073390942506470008867088564871610508691951675410364770185985961728739523981618e+01)},
                                                                                          {SC_(4.44458748032432159103292338558910401502544118557125329971313476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(2.24992759041617511461621764486439635331268181524943714185422655502011940305830955842049995629795499038379372105174122525659372487742336448447414773844185770557560669635298671132635822489541669693773055967965532505432053161714602453342903646974643879994358520105467411119547515122875898507996505993250138824454260200092114888103323809959405846895518855899975499562260312288474932728168479107206688794805002289162783128162902120231213764618237747182467147917636833518130802203155531015258002908630659505e+19), SC_(4.45600148005480883843221099327436102666507286396321419246469079708178654036796335564537748997950297615591540727977401329305621673590499008495012173174392772256892507453002392058153845853189319966166580698136193800825737803950908645504563702087417217271483342543855867136519298690260888636782412764723517798316454633414606328262091535579645033263025779535288322669191010012877722363484688404092994821819255479622047806371600580845074877980334211973902257995372110831043126958395107296424305717728039778e+01)},
                                                                                          {SC_(9.71557492149857393706909557129502985617364174686372280120849609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(1.02927516701786239327088559412658766939139020160726492118279488473065998991185050649522612566598502492850845923928935444094096535636546140592813025897441044117222322919932658956040882346732304391680061902209382086302404668689151737674617016917845957206762618188322104946471590369266478660595098732069281192644117382544988957154567918982755878771131501810034492564665202549534237745127922812286537989714258529959375056247550200531755397160082332872499569497564890372601849391656798155826066504423590993e+19), SC_(4.37779716000584398698990777213961810795783081592017743708184220804927904372994901189967649515009735172880623955419740420012315986576189119126543575566904578046919431809875380432523353206754900523923781714480384673715724050123132008911344423077801177226414264244221939888532288642522215169036955971731289164143691078284671577290431144790881842027973573671404137841858557411863925709522264346872510355435006440809714471312012017359301321832215804656521781996390042520886865485354409134425576656515292926e+01)},
                                                                                          {SC_(2.03659828423951236444711457296286027940368512645363807678222656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(4.91014849486338795473190760759441444466067332010736115448451018358708701249483729445665603792278275962824915533363252447208992321271997558403209359068593642512124051171201458814565348168725868138337357097501234373545916690198371201406334166588453088443536369069022785451336023963788649872427573525422434996888534953599038755123121918868508030352785585630353270762249702292785344287764591129078367625041276697406774722135731348618936205273074423355634920869234376105907879152417604078132666329384170075e+18), SC_(4.30378358585949627123043266249905967962887816014864580030065149334627360311264625084269369929010885338331708629099405372167695832844306064622709950330533203706114565842728252858428991981732670460958718014399250740467134868328348527925344194855324451370921408502953554014065116467018777966799168200158046526847454556567370263163616973309536526429423014979421181142030669729325491143297954511079372608224911716501489196081860212695795268550473745083593808696175606006373300488827315794661965705208608074e+01)},
                                                                                          {SC_(4.24897141467077741851980990372972257773653836920857429504394531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(2.35351077333026230535011839474240622219483000391146763132183509793076592234927888232167018165059965341889704087890201558410868910455786613836598080957397030633632176587127990393846747320588225351631383496860587423029556133907670877877103353918512797316094631873557226661613318816657601526325447094347483360340956738001270992373069448262826936645820092382649354305920636802353742283580922610354426889294090123859577447266696482951980426047140310287263459070317723770875069575962886935550805237786695897e+18), SC_(4.23024398333195918158408107850347603783326689000823856751331542763754852295008148151040641858229359628078469346471651904183328738913698501012488411862344210217630892036531716673830832847274975771154382165559196133886158282803537992484348196540541778850787109396622290227802667263982437869403228137310193502583531468534595730634902358307597504479659454456104333192503021970905139088727531342322319258852396765871179050698860655091930182032950808135395012770057668306527411218055974698533878804694897876e+01)},
                                                                                          {SC_(6.52109697062557611797143503062912373025028500705957412719726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(1.53348432710711382412002595519912645825566648563457431696666953405839323663436385415540577078371909268498986232218717729843902408307671822735810898376099999002890492643837786599645083719969138547771263335859855947307816324679806209991631345545056461506588633853780283094320592719021248371654162004605737603691227969348135209903536561923025330689942523293801939078260739547166454712431551868620292198550625950525062132279655944219731109300227921932835486424569827867231613062088487239727349654985918115e+18), SC_(4.18740741580717877834749717580480872663444883214839906712612229928671353630872016793683491013573267754990828537497837278806841156933537456470785351876763297827295195430920851033552990997091396033417305252831735464754273359090537968713199905598504642031010880493394683204614779223808652364642055436096918311854372211100470681108894123216199490765448486492648497952880318710041148392364754006599729496266016887671960468648728381863442366793411335781696166403861745903446537097238299743376393803857573148e+01)},
                                                                                          {SC_(1.43612616409619005828149362891110740747535601258277893066406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(6.96317653003236534270279684056230493480974635294387864151869876012762532284596734951082527306944183471677369290174280413996466386927811922535961306689638808619571896542664757715749540445967495026030505751974090250891098156207641193344218297448568461129691361732130086054347427579303927112472352548506572728853835019753327122688017454392580665395920292338033791221187069780092498336554008503930308658152705336554580268216215995514521220060257848935007955158452333523773525415852441445066559674435759662e+17), SC_(4.10845823491203750269417544215072791519132546542332718178996273127574536831489212657835589746442090649387167240256729528753922301781366890181149045548306041011402050938687552735678160032267437349278570868601663400661323803208330594908106678976157884754069206007117314370496433949931110672961261612716138604168632915180563247416747360388044256592175912181596271822746593829008506529828578871060187771282714872573721122505387176962208757179811399463372209857716091891885223526650002477848497475476979043e+01)},
                                                                                          {SC_(3.11890848786895488590521774430186496829264797270298004150390625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(3.20624989123443732306466173906761681520397454797743411967171013836766623066090680547883575948261116875373758903768745835189573992875216085613141902692685511200847100457475304187579768628665984916839183891132515815084322285924840767805505007345562218865321739461777396150138788712581196262279033992571354092841083584810694368680835024576873243622929377079471785915486205112652151458409005461347986973352151531724888021213681531813870835307532278204228758832097427330025813162846791315218221029824619746e+17), SC_(4.03090485769127361541044518516749793558620098090648641127887094855827700200790074148846586717769702602507584916035694807696947856797493490000517122913319060871005295342371073736921330336059216945323871412710866077897955936403693279226005005938096644598230886353655584378890229552843787958464746461009779666997703222136831645152267985521755750444319743715297346010531544876992967622344263445129450448900510104730168827827208165554824488326702348994212535336245330092400863992833297810181409567228297843e+01)},
                                                                                          {SC_(3.59334537282425688607678804231682079262100160121917724609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(2.78292203015829599261962546957895404990081417377702462561540550534248787923941627519770252374132972956048659251893293996353753189857684586454930049807693801282519389517382281037655102888634397511227508026612893186882009903794224845367685465254686600207247735925185218914216633415917812638411226987452749991767060400949519492513420696456926364234344734374551036206649868606958533670717760397382911283500570331443689754506095339881662222313057843468236763118633209815395160066394239858074758994028666204e+17), SC_(4.01674480465780156756373233991409013436821533054168506258895292628279818069729361806787595136076424384006316279954726598012824241067989855404179824808341722733810737973220122456049123599114093743744591167641745949850999579256815048452990723593892588637365211655957582808948217026490586121983724517543864781645178437196162666472151019598645107712434762601053469666360788143574729074809760313574145036322494425208379260483457212057388135008101922347976288102119321928476946075419079715204273847836843414e+01)},
                                                                                          {SC_(9.44587319976354210931956956187605101149529218673706054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(1.05866337484292391877893553128199112698939570289224932065176817862141085135514836951586667720844659406770612439774968221124632789370844307001432545672057723464869417971709395799424259898055623912235791403741122929999123344770195973794864712554455288234558866684027599817096207096080284146412184004873522071048450897003367401937804000169854687400292647731549224669081176646068486188198521486876180228698061143311696077549270110157042874108852125353259990832498202645937700555218735068731041170828303378e+17), SC_(3.92009537262054234501302376900562352494457658036527151870180025479603504754753461578489644244060365462256407622755712594087048043074770735971508367302683895802466764533029159135853094442397091072625565603081572124195271332301215264596440920186443496183795483255217338464274566920054827464817577632394600445251335490560113043160121251415961773020418811680125283359994707443679440487631092951378592813529930845985123785509843786473207457924902332048362844352195749950987077358017799628118071730249025862e+01)},
                                                                                          {SC_(2.56618226665795902841776809921725543972570449113845825195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-17), SC_(3.89683933597725175319881448875156329550959272329681834568395064472849695620233075370398121094999407832801079152543061082854904293375770342032999568194809723919167029207972483181872792071870253942805732212213696866676682551256652819376616818109748330084069432861352227832513280730680509108965375769828468563041117914052232128632742067003958206273566240057625865861463363448156974487157530828513033287570098452135060842470250942593681513427150841818546592619926264067908663369379108875730639326268033636e+16), SC_(3.82015272857946013868972828269190565241603203009525306048316289669090329472938769874388002268858503344601957377991550737380331618410528604493034595400009144511968159360478428151102928583235292537366903749091753601878616080067370420318789469929376398084229926120334276674083850290518652741873258037928908447880487108384710647297029037281429246371294923692866791630607779476698503708578625544511474622147702976005586821125679388687458018308507924009603884965657863077894756124074217763436492364278673196e+01)},
                                                                                          {SC_(3.36376503340485928823799799403104771045036613941192626953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-17), SC_(2.97285925166949974807457128035170450066477816399282150074283633548132630228050480206101334146278178930908294908408020515338238795065654546119508961075437640461050424638007401351047794124504871288463863754584673855954961126297232599340503171861121561195226942325267400079715661257042576124244835504300757726324585566034800400383463784278686607598194278053396410834529186953102975415973744957865023871122361396135152717126955846865152882110803343610508752652208729776608990800704842038078247817331994336e+16), SC_(3.79308856886101391007069400688611715241306412481945391925641124503755302287114347811486474630031114965526460388140834253480812330063540612899960732864833037424012896192727400080411399823034435528040797825742848919090423377514889994050050630539014368288480412226524143513889592088827662068166527198378253824506638864160188289159987241034610535720713030553745641299836235130444127236622529535246872710565897403446713078126446643276414792539312938432098757656839684732673029434047131943526266196279957187e+01)},
                                                                                          {SC_(1.07358170281591559259981583096532631316222250461578369140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(9.31461478317936154583885573605068314152782065589549609469914565023926800351906893630628413577057329177994311163956620701142336185063877418787239256892852873445087920365235403253490262027044753883469508398410847328265673193194742911647138928314816775890233439455542433156942108387193099894695833914145431402964584546919313488937598696841459038400110037727145266204533694824059513121510339268845269654240403127274651877792927116000049616797253148390354717608718094465314742868903581139626551889300905460e+15), SC_(3.67703610436463545495026752764732073257799710462679383878926040687745483770759737595879677884882603573698864133418997486425012617679062865326383978427075714145698038560113831222027110705069239786335016603569169352428328537042962202684139397465453620032063627325258874434348407817356371726695939425687202245573310859195697100566991928320499898224427193219018938684548326483374310145227660772699544688722421474069378038779652620437195668034097533124429018646466024438627728567972649112787843740899791573e+01)},
                                                                                          {SC_(1.86668379762073861211080227917591400910168886184692382812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(5.35709369350391592768923477986863641641041386670021657907817556703006517389988705389283232109982968543641719672782632683446951123770688487043526051583297000240895361108843806299619059970226545428273207896350988541869699991627107327834801493033331216553070688928465855987579410298857315865277432779893119738942981339000319483447360246902762847090996239733181691824983861438010137642268593931536986215723688557791478609307628514091675490387977196067334917940938095685385256768892170730058270859880636462e+15), SC_(3.62171980015770238529644276256304909762841122755715670454530535932119577983920286373688488828352754734406931597030396464476356557398010697414611460815730595598795724461987357764438028481679345185347219185863071734495762170385287950687445842789959555195963125019478348258106691677467080954410031938373216500393153641016722276609946656713555540444591568662264332738289295169018430812414467670389834383152578763719731976746966496898676584798648716600235148412802550386858248891110592564164992629404214083e+01)},
                                                                                          {SC_(3.72754000856436763788881449954715208150446414947509765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(2.68273445141408911283723006239656257697803268441537091833578995823631479637870109372542433045823942500493538309772882061158620811239346747126416414725632220522897904212689367685374427993307715937071521329955922919964121115209128646024026140952716125111524982773348304152867310039303794124441877617403751368109200025144399966053076218345391645919809571229742549148501577352386134954357696287153144345459858333574657639646117466158790728579741367905998417341437163124394832747783463050305056098538914629e+15), SC_(3.55256129869549746469129190589446112611374971235422325441661743173441106581270111685559740007254639646094495493656624168305177527459509052071035691146800720852814665759057328973021867643432657506024722624096544711014523774399719873932689274731995051138325881077303537458836774065049783694018259907349665329693554519542391840301112676185833713188657051332369184515962004392542293913181461136174541586330573388317276739077974633782704129881107851360100845571979416524943258965369577672126496148058574581e+01)},
                                                                                          {SC_(6.21164623847126305677956992212784825824201107025146484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(1.60987918759215724473296955164050711825489618287045866202801823414693239227582877689612642201828742154418687355121973966292505959901391806799139653809838745188340881684515162988792007848468674612998319858187092531693899932814139414825926557323551114672169822158423992839458703436196401791797911936673436838394240815852947047828174796753313307757136143684480285017719542768808602568057397749873573409112484432828327014784464583830481102656394268086123846746418699465072883104433293290933010401885509252e+15), SC_(3.50149355323288728364329861732880324176031638041336862139807052588032519007018091239566004053112678380594715791614694015553568082314922840573501903934526205826219301106252291108123590770428192799388536288175283950076110976661476116388877098281744244826032674245791119891143171701318333066266192173031544331503256176982628055047348808467609466555103556740155332807731035093879658546200419663988682878676527720256158920797662450751878684463077317141864229153842444817407043542613272320106476743924054420e+01)},
                                                                                          {SC_(1.56118675387513505814496284074266441166400909423828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(6.40538358090616930572199615451805628548811466548124866767301580454193836914688527258945904249400930128393597483821093345931465125659040391786350941651021513731158934861793952123651760083410251936794620985570172329548344492841407057052025958565132036658866728905612768400532182293158835054332981413662202889397861806043910747692211323788804394256779409295771295572821408075298471507736651155422104110473872767486593110874188436686541654282655355161458124621196612875076129336425440541282095043450040255e+14), SC_(3.40933301232014391150868421636533958473440302585740860260848018138238167947147035645125756954671750855391887535317009444065956767921064677968618219945959053639513910191608207857335901642663150813785332414376802057893921745648267995098117737459621623133122851171303514865520860577135966638142992592890484973123904068963085394166183181897269113986078489578835681632904743027489067147409257807141797115092583680460450147123180586018335936955745723770866230963621347586888357455203043177396972833240851176e+01)},
                                                                                          {SC_(3.09201076472299246633568259312596637755632400512695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(3.23414139242036684276083130604740555332102742732209059379463888241652420546423273086068775293720523823200670849046209509059992046513896037709874652313295779648822248664308086223556376242106158616999836997344265976872160860155284371645823226486628544951807381517275685383124474248733832833490965510634823019355780090367489336590037228205353144842183317855983909606680484114170019756574079014702848036194935144988337541633047521822526159654693197431239667075331189787015556708335276605238049315835810949e+14), SC_(3.34099547827158268511113993446903871609732924567423972328264466707266472778778891404558763137098605651259421135963813833515578889335972791280638276638644224502835075692963388704588416382084250235467716489647590712743538560386421899270208473311755340209188808173381086345830251825944994715547816456415714427114514915312552192521665876486824893423925556696142108780583640085356427710300777015891910118866224225325727148526583301327987132946111378409333344173151219474323631718818017607572968466884244881e+01)},
                                                                                          {SC_(6.19284930682226925080513524335401598364114761352539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(1.61476559569818671077849756616782395312094395613347467750921722608840205796460277758977185598066368612152647586355409621867085587660898402276437610012628993258471020827684469653607635220589425130797599931290173046110225841248699388265771294084712117371892010203190259471067461983539407831393871011826817832470708029300694095843415136560615706146315580504139342457709693423001976894072748271524278429319146224988993773668626131510931741784139122901762820252013439990701483599226194926428639331692995557e+14), SC_(3.27153811060745956545208526189697911818865513720855207755872098602864684374322696355123670952633924436258610666907170222209394190047290120323927472415081513666370900738289979879690186626743145600004271927253949261836286290740269610628605968254208476768024418971702204779288095032341257084062060344264304671198009573892376055095018771428144517163652189210316706374200046878577151824403617693596267098982951994663722671034852406566911866665007273958508147641802996795125455444652177198364896323298304893e+01)},
                                                                                          {SC_(1.04787902801498772342725374073779676109552383422851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(9.54308630352406516205359046743618128166013090307817797340778789274961654822225673440177258174542900560867351268330833966280245668620838918829357035489275755644143090680060808839976435761676367940523185523095340333253908768554277364428691654262043043572182784073217355994150549491589487440011307430494117507959296987864631992522761541545646638217243232172299176577840404366061062966572185707442372468239516417574982507870328724871909524033211780972857372209413324807897530256218888609923492076544192109e+13), SC_(3.21894231539638950907826379599187842092021268441575923627069258871771854433853115415782489861480221176798825589829782195888976062477106413518596068053420790907345073056114458972152822792634568125668736336221600151997074169590195016728096593357645536460894160204159094589833050074995328566868137793424194031239361538971519366809470194032401330140171321878243915169056979387038234600397250254904913143463342791005518801681322155705188385276179554739337515081187784957575036642842343229436475007253920317e+01)},
                                                                                          {SC_(1.97847313076864039782520876542548649013042449951171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(5.05440273334157824610291274505331299112537682918356644294065782874967080760819218369358842344722889119059120852563533630957034017900977677765645163762768638444925755118980175905552516718603988596151136262505942788287639943511325025291684945629253287336400993651018048078421763736114277036323128197654243217402405771923455474402297884519301843406468653715197789031889941921922213353229037615872818479641755520825402977352044532728989288131318994792635273076684794348019858198888846251883682434856709647e+13), SC_(3.15538659007727107880083686193998563292533754784239638473546230158371409841656726541189075805403753304475273768163410631304837122301201804069146565821080380728613439679856624459579438773909638520997068262009983521806344833780047975686836856408178527940530668908592418922849294084163218999836168907185916907686225093493625442584462427634364163510373475305542575946640596319788825084236461508223200924347550008190319412896325544644970319132017408695512459624713558941710455539829411743008273160922182276e+01)},
                                                                                          {SC_(4.04181625234673047586397842678707093000411987304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(2.47413523417687237626963417481472433633575119288276766917889956829706449387149542182869256245700252809127224187392299344118680726955621980608527311106641981758457137155249257019959311787800175161249767547732906304767784662313938188488954622233749014151216322402541870100691842879966764316542106877672313850010047940125563794655250325383293007679879162113741747550152520179452876634080967834990748405544440060405645105251924641229465383899510724315835256818990916050429842286719722149892359257192546334e+13), SC_(3.08394971435561524360142991538131117539701549235963414268474100167564253338933446140757694701064289726364423973157455283907856938737731484242330760047331965651566581163412758979346661233941073287719334494551282734269681696866274532457888490449760451692621607033690773687251984208887286450445309681513684821963475136058108812225796383611583847994569380161340863673936288863658102647041572372692358955984131110815821568036946097843162296614207222964877061568985465748411171374575442815448828159106229063e+01)},
                                                                                          {SC_(9.41030023002276116983466636156663298606872558593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(1.06266535132378760631643358293084561511832251368430794866564956367470040705018915409688083875482366263429632275039193240775766717077873313852950906600022896494221965573665971241663302310175858585575545771211409213274114706303571146331076743944647262144373083858176045960978072697190078745416271470663047735107459899716848754352570868678111151112812595107266326009187517941163620835723085933282061532789859285423369697118361841235177506549712822803071392540857286208956514811198187808084053916061721078e+13), SC_(2.99943864434060791143172217492896937207257949517184549417827064206979752588254776175589324103489335524950979308405249931740158481930226889556381324738413768244210883195345624061540768169879851570810583307354423589854007192927945909045754243680609798014063800551099760224902076469760607675735491720932918729762150703739803896371534094356260646920621664361156701208773746212016161641743802207607892411338748745704600883232903687017902944301007840250864179183844517526006505109173025929076962406537777920e+01)},
                                                                                          {SC_(1.33452981738307885350991455197799950838088989257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(7.49327581125803664353332686794462735456476172634230287246141345112050937168008380331979244951518303168542851471161625212402617638944763054689499203513298470645263374349226143689692949458761027910602397479322818253915367494622615901121203986244743934212301062374794036609817418728998513819624985002827010279122684636930340188704487616825826188496239163860134394337564212301369114736279077734733982238018672531979578933946521870429264290190811162244158436887004878920183732188673299621097892176296159380e+12), SC_(2.96450271758229288403252112889839343046264919348997051677770807143229064321698759490104407092173470549790770910195143510892421208124871524048537452270859140340894574198474275240976869613246364719079574395550342755224793264452868148741241005212364301594685738976292681945703335226563931912049610406775300176036592141685864992725787902308843717762037673700674556235606932116716568288702687427879873000484350347814943416258390061621054988463397497969887685774955472977153237799356556556812974507905534520e+01)},
                                                                                          {SC_(2.66296967116330662861400924157351255416870117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(3.75520611754846112229083118399808749001360022124058715474727790108499144051750552773043606887072948591733873717619240063080087438143083644198452449978587541745540668164534368081538836999426749485182722608937514052626546048690634099712339264714521629742112776070046990915446381417847222407042913672916714141265208789710907662269976047802795103569149539665396634565491541483384838198541813267661606162894493363675144867700571511618283433250754834401268934080145757542080423149459099357971487063044420798e+12), SC_(2.89541642911290985674935632628817900504134143476583578690835555153792464486843214230770681727568219370418454410176940082705556788379939494096559518415200599813788233053457422119145514230226273454974164747119856647988194000419844395517976877127785947700998789158949025802776791456070546132318867880519233401001419907844937725860998778948766916982532697956516048925274592479471863457959002692582148207882530569385026392064968869404325018522967272680481727974672171879554684614564347484171235619314903696e+01)},
                                                                                          {SC_(5.92041389871345025142090889858081936836242675781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(1.68907109723691052070486525865106261806854966699127027205669176277569218965909678349600366028971380180385906687809738819931361084816519280585711566815674289584306704539214723315643204060952677418896085153747819431781526018839209148072775102167053932355256696250635369168809087728146494200909522760193515069230982932008136433426818311186461001454876401671432451216807114751593214297322118984996051173573813270457915363615668883625006270008577595200337542985666436051094151406486548468223963306159654578e+12), SC_(2.81551998471470821921826157320225318779020697755817987877133780395168679457427671788226434299866659405041732712114375208646597948004797119550767305131975984686358907282376546079646237181336488345676458337148909817110936069601773500181081630094896836955048561619175391708439600263872860209454397931673667257880817059574772661504631368432527966353704558439825785368252610502124484964110156251032299215447175710893508980200682712137982588485989277355873023709479206867181641268659311575364569507471812106e+01)},
                                                                                          {SC_(1.55163989296047688526414276566356420516967773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(6.44479434007808281945668171737631984460126338755716050528259636607558935755206412545315633066199139062007451090068421786440803136845169038776735288556927740762250530813003376363047126561006457621447061946747652004313806111815894201357327059916054202470401783612662229031472185476081051007630444791825977198318692478573405964267879544376662236850355227144275165845837654094265233204518939903809979157878239002505955765874635670880773744972151920549504126507544870672637337239076996374024550050298288969e+11), SC_(2.71917087488208757956302942278577362295215807788263157065483843364066663844154423713634751254760580365655956711675975357428722671276630188824680533146797115053517339275254913516196328098442855098750314098697115490375504499318013291671780934170480957119848910233193628612157277168981731443947541882834369189186964256514844948997973976691949465374841958954223300229207473839330998856617233994716915993252606356782819485709994926845524965543217686418000523044509663205570777926153154778574864020540675905e+01)},
                                                                                          {SC_(3.26923297461201300961874949280172586441040039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(3.05882146596417234835994602981634843704750827288294119670156575398858570365036581738681250292878619132939544196249745147762777975788702902641322452264655661985803387949475536433707633244000288147225470160054689577928543581745112442814412566861665723976043265302978007164309180647034560028702203990421924922013355345598647705169919067111687823219992429534585941737923695475857355829185398287550483537377689480938908547889512997031717082903798346740384480735275300567744061225303803147502571461670451282e+11), SC_(2.64464657228708503007839379797814889383468623408632356045883940239707796706335741648601257561033703735027993923522266991510795865405348473785708794241059879719326704776023245036986519209326809690606573999809271632372481993912245549990143970731534224585709349233224063569517537604626541649377460349869609607539997644367673174479433895486942986943532920284602864941975113981089301869678030658716662693056171364402660992019175343646111063211321804943853171822947415008191403169872733872982066844706145490e+01)},
                                                                                          {SC_(3.75378547690097263966890750452876091003417968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(2.66397748659682909756214887858083229415894420716762742064573472682474490462580859011373564363428084801314649404922305948134943734902447416261381967458044712729517464413747608514517893451473086812036842641949289328614680708631437977491656865094490800485832412388703509802032685663024816128140980278111665016584380476090092190662589280675294498094956505172465951855876751666393436168631795516138382681944895276698624547918025170510095147475386547606289130297220119860631615057432119740644819489077420394e+11), SC_(2.63082563245997692641649751900943291907691027144583704549442551016776634450412688273893462505301287777070668295183514819852524997814713408510699214857155819476853930204939748762743648482032606225357989833787868484607162940507880034914693458466251230146443827109590823773695084631603391774312246852917983179238312233575917758149911819562050473544307597831316353986629032971639235492193044250270704422734560896220909594598818102479338461828126613160467017936891031331993774585288966541820231566991439324e+01)},
                                                                                          {SC_(9.57916385102564049702777992933988571166992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(1.04393245125189169486027570038996582173487482590748586089822808469387431328301377618370442742826265541497232306444964659164242474807185782150761610210632289940820474500560688335407912085585699972502466458135697942977731536099335360050363930102587739596997254053324420001037812190352819577308953150566568369925711308080252617427664868786203872471901268803117970363715521670230414288279696940737544931751291247921012323221444842194521436843824624549899340782748610804764503134909942955283466392480149356e+11), SC_(2.53714308084356893528465928314436682427710311763825598345994023050258622398573852312837852231659309845437520988033941711696041489046002537658504340143627120828392418786708213179671375739089890154011798708971619878833013355845921783147827319762987629911070090390377141442166911300222465040042045659314267308680084418840737558155857306825315728369486845594480625849530184371295514707954989360252541560432094681464308036399339395096989260992294394578271133139088324006323139537103026881509515892094815868e+01)},
                                                                                          {SC_(1.85816709241670707797311479225754737854003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(5.38164734522710681215600336061308853120702404775145741709026396178823245553137666800524126297374217114724680251167541929241182261687949418995565335029486872157125343290612171119880530101193916858921432756965877000509299499604733026401192518432472807166016347864511370369708185703119315683513347311705471142373926510862090059777086621231383651397623524522666406326397488408425070093854590097402718270173248647652565267172176040569249429679757503140285383909390206192507646517253731439123746131624249013e+10), SC_(2.47088454552427137429056329064109142188843906165891475774275743679190025685194554734484595319669509903930259457820499849598199214676908400721919316015322380864769811197623330485316164544963476410844338145101962702064276881579255860088713997116411562209654938575284162991827148200313426345555058188280286970644756612598695826995893568264874467159345854674115312282747039761533926261402464939091487342073450254851176994505068182111978970672752958497500861843350592146405041615401662481907234472878121134e+01)},
                                                                                          {SC_(5.44948530745159587240777909755706787109375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(1.83503568419782742444110740345485123635192662508026305449822064127200895495506522518300606061885236080150004638907060784485796894919202236803140073697331043211992951972609347054589798075100998594256645375390103519596787348845827032192905773076186985280977236935203223950666348048814013595501435907216666387351197442286860869056417192384391638213785809676518670680508710566800590437787611079311407075165452999495406849472529410938337431736830657048795062807787119744804484928614047453144586034805245789e+10), SC_(2.36329148576872448249942821605627674186499356266069319715954487992643662294411738158241119885349703763796404853789880585762925019414200620292460678339262214588413946187958058256382025002391673480147145270388456894043662461018854194828668215962270960439151474188647474425625494775601112078253792726530286137717752752768842949012627953324732331371323991302860241330919243809216358651674628647197448697291367713884619010229075199219840636262767574903350571262368220355179436844196791555671752462351869046e+01)},
                                                                                          {SC_(6.08951777891775236639659851789474487304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(1.64216615546621064803013134062087811673092748693572885955291086615453038443965746918527089670359832467884627804869657509889650026751673783619206954153041104516844408513248895106916772556394041551875119284869088037479657980868966602129588687470062451815693221099315162782276653334393329494895424621430603591057616248637305903296178334745144236325653690117993496869421243789046117391168563934190450243201956497156633468278725255215744464020504309074023652187498470935365081369407764705200742909320431349e+10), SC_(2.35218671267563612353348723043202312786307472491656736789362170809010927853268720372089773533365322636476747355137070858356044677376510322713056628921780389307345874508065375269999253671352912911300789233090646288480277336399214203824400746311370034317659741344301244189548926906452691866457683693618594716563727782265819613630587556878361391532959913004915741915512858017425295944874612540863724007947904388532017360454437916475157224516660170429346394565018134649549162182163834378038354896787534841e+01)},
                                                                                          {SC_(1.33774435973066374572226777672767639160156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(7.47526979014226168376384951063540791218306464061986362930576004822937035170826747587219778713265013490356876945166420253260555381329073438163483115746514774479474424515084780051629598601133421867960470830504667887885069909772744114866067292970878487141283092292728452415775921280918070442774133326301037901061816917727478717520084018487350667522549017129986542118147485610067262541496627719604571748937052892434485040545825983818735788800698893594461092076293536724104072562332257956291083818308956413e+09), SC_(2.27348660478985728986052090691869895050374367468815674115675413846437487991638874436688243456130558073290283141742095678859644590259358965534318423720133246933305572030632400606313806383078380531211317966778435095299543494045005476053336526881142479116347292899023673200509584071082808986065746925389076777580052558272824153282309889654575678844049352349892755868036262512082925318962285347555701091174821628709528237217604386997327214614368590642701672876321992143952181847423729490477577346381853522e+01)},
                                                                                          {SC_(2.55445886665484067634679377079010009765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(3.91472343871439978910477041965245474686465180195914637204067931155807421046773613195218014343443213281482963786749317221809432998053890797111065514873743303968835421350089217250012183258566393346818055392099509447667423810046789872014606508233744159464480197460174056765333167633380035505451716049617734818251233366973419386831337618966097682993067804646577065386307800044732627324473412332158334409508167829825644048453099756316314804390039245419754866540656073700840066868100898153281112806338309714e+09), SC_(2.20880105224416920895025375311224309333191291243380788898883223848745359017136539357506857766099404650529030796456169266293876522646879739438348110747941991215095622332304227939069152729572485470267183483067041403067149639760009599374303521571969473311055242104395748819301709770976566775902041342531942700926010496460878831692942101086740124837297933734304244538829304784415560885582162795113502131933398817811477963855514503427658668565459402914411004137540469053418634046916829095623083037368147796e+01)},
                                                                                          {SC_(9.28560339730211126152426004409790039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(1.07693593693067459739313196967983697014168456746735348950919376991901134647895921249473783820425440748624729046805302065147100445478576472841997876556348031552956847123213018659344562570860704628256642731968975802662512832765217693879980226435177749884163278536128229784803704747100947313765909472695150172294912887298258373307813501549625979139710091181006478520754982671108876330020574992387977252845102120807513897028338524143351916484881826006078361700760820994355807138708960301667204359286421020e+09), SC_(2.07973857504644610716889395527737992585186849324495128250619250061479886870375850394426233184821495976670242716899017325165163154088869376465418506805353926143256480084118576294761652581847352892907919904429997475140686105674530141840068766707330442895114253613073589774120006201302061827279282589546526093188104157655815622515958409221402489609226382619746450223058090686879130896414033263620750912064412230268748715901437966406012423491677890763788052175548531716952413812038430090387475416035911166e+01)},
                                                                                          {SC_(1.69822733653290924848988652229309082031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(5.88849312166503329222804086517709611102504992551929827158983260288274819355761666131361350403874753215463840071495318131961262300000765445973666229487031598720857498492987143522791355463828265864402139432350575863919550830036469565606199591470156705446960446045999559624084043933730929837654285300895855904989248038146101301631557036491570331704774925320131536014567404874489691389486251736352515404220755516488822817333832143329345542864773188420965679770154373216348702981384689050349014346637868895e+08), SC_(2.01936808721548656388079701232333621990292234406195324994727476802362692900192163204786445631523775797240087658142441617001290954758379696663986806394767773157322284307849876524904682586819191449092688119556710946373436273820321044371035628264815659393916459198676972087410240894826301225696379803232794401251838170344674786562306664018746217590477957014229341960304890117884805982875916303367067026067301211977791816334606548169972461693412588611268696560770810948724317758861874065303224659055768486e+01)},
                                                                                          {SC_(3.39355921141759608872234821319580078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(2.94675865585811635298905545790724556951261971511817324192800337091966952557433897238486040563146326422690127775802629136506732120683355613677456114065442582606140614028294138747202403264952788642284199088873893000648208374234647107722407968127897446593386208233249293959770393729136064523101800224883878867516495924927666979551417108620059324211868720429514373406034762486902686884221653802832710722135064601777922572822590724018314669731551707502644268987523794807797201345037498713836837200106117859e+08), SC_(1.95013865494979315748313424975857460473634359955171433398912789707630274299619009224156325830001463741355320932191136639198272143513408963597746842884554261062767061011794862873805897207009188860568189846504131852234332017714959090717508237726771666011207787732265446873884001434343930063513478218717017119608818828926407280580928774522312004033748177516159660878382197007027146156778530958492741043073137226561947610796232234756201323918090842542134154240717765908943925443129110964257210652469765459e+01)},
                                                                                          {SC_(6.31372820691922242986038327217102050781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(1.58385024439239560678029793644762724145694760750936270448787476917426742365312993416495445258066935770102073399067933673940787592468244489319355965681748597844017136875830896374444946819887498943387605128932905916683614722179628126645099686007619813917603450327015203485661027618036158569766302078449406310364340890783600576522072882996092981719203190666518838669113707153191547698768060884224247649696478290695897698814564809558453790895608263410530264953882534568878304886285345294246575653964394933e+08), SC_(1.88805394901935901312944434284350951219368630628612582497798500377213575430066187911538214347407247506592302835814578379074942968724063304830478545485499104982891564902834873083552388009367885301931886283108030732695152751848460305522542720948518365374089606446212603641365595987395773574687901369258435992285754676676444454303083046616673187875296372440378443356862117485368511965690403951383780793178907009178840322578791980487361471021699988380686049660994558986894513487250480575078814977194988926e+01)},
                                                                                          {SC_(8.38326386087828723248094320297241210937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(1.19285282171266658145508408138097534262559562256796179239060845011847752757742744827549809320449524476525678489254530873060639064343374370418109877624082104111867971537796336728658937487311009651740723155108598523574089439636001946998412481579157288344084972946019075804904453746381170904188301113624111553121632985948929138222683651820769143181173655246038790436308561376021389687302205902619878055292692238813786176438899128455354260304627671521514620334784061653162359203841812596820283636012413155e+08), SC_(1.85970285112369275360019811510798597407616819997535534540861800006130065438481930599974368466408856952940619414764119222982234819668925719824207934180803628792362844837237434872443976991587061436543189016693448298778560625710296335004224090879870402508253963121606317871340026351185428422401899631577649568952634738322641017608299843257260519480390161519206689676784551329384425137071265909687534307017746909409303177372383274507940067443301831530926380849233752290042798372825621637792458149510367158e+01)},
                                                                                          {SC_(1.96263059137891104910522699356079101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(5.09520229157747964001427996680084687728519220880694851417761451758485922028137797926986558108081161647424335273935443009450702693139660492793598652472042922321455560347329476289740970225980232132484721944368298424652675989140325777048780846103353145589579610596228532659731472516752040401388614999099106605361023985232754174754462689599358275454662950394291313192314924154309854807338240568480536882437606662081858664976471783856993462009295129472122922430204094632485111706729685334953903001928515306e+07), SC_(1.77463950207854514067971232064740260529105197804463559048243833216868226570768682518176721601656061733151204368405143742619830734756623431664082017620746152360142944331261018871625099695179564716131664620296596142717865215783930311250469461067216865839155669595131410277575494071155624571181890018520530487012085131270472606584209551187422858235247484254934923176063127943828270477251954203313710078679176167435792694591424828856084830989589146231865386331847539580708042557229489148910726228436273224e+01)},
                                                                                          {SC_(5.25638483850343618541955947875976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(1.90244816615071042976912611629696763144346541035766078085764029503997602581877792049646577520911176605141052583156884910047229341218903573541592559499518194959491983325368765455962448031602893719065828910665027882587968020448370625205459497212847547686522514510967372971354497619542701997056077016761039101147586700231467014866991293439747219121625945505887139948909731139184864350248915445653527417884819966623498522753330295654416087777162453609622667919905235926258921853904509270133969132116091634e+07), SC_(1.67612372162164061692861843009343434771981611053111621976184895674270615702556422861104711239670932942032636331270126587785220494849967705136661812539736970981197905984513517678832773229865521494702028014410160745047515210657408196793002836449416485413273544305012535544219297954738314917704098327165656062964601614781986549238030592926364895039476594734612878189916934277091367272748422762481586851408931992506671596123378100473697510918014617091780151806715692586329303065621890707562029937748330347e+01)},
                                                                                          {SC_(1.16242290459922514855861663818359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(8.60272048104487229772270370408991565622146793420283748432283683850487109590703567341512208842888206543920002357186841608997218745333833023455975206855307233940669287790010316749659645433998894151744284846749708391642403854115820092354766734491127892363620549380243024276736218478701060023730673432191670156499018218581472049008969127266351163613795232939963359099049229223643932353224706265523448130695355903869011220522517153184148351405100515798526771128492374949302429712428995265054565616102236743e+06), SC_(1.59675890462055852493050785354007861019565072353741022812627104322063156529086182292122548245675963093183064733327338722657905893984234890223568744516553902070973717709098500393275533107035456906906513737015232252328472020431774422782634447132083994791646502267731048214337727523605199382839002174372325259458602525164508779404945196242777027746479829450292065967587035499960957349740151867689420397814665735654733186029950552962743110042418202174503847771730953250698037145722977227920266313544340773e+01)},
                                                                                          {SC_(1.77692015768116107210516929626464843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(5.62771429605701866811138968820040581688116632816625983330513767541698354176855994730746674759831971880240445767320154220938966723002674804699555553392464572752062447887107572218019828318385760764849719115812290395527218248512835468451576239683644796014696087840260231260544768733299352553787968817182380161518794267110224517746786086312897558884287582163631755473909091469973820008996113444080900207916568204012349110621060594004089234828356435145317529589017309777517404825895108564229825972606783182e+06), SC_(1.55432139311902849557388986039946494987126573050313531526481779205905405668433477095198392052135320177727361621658987782230848885023817861314864082631463951648319984960611870632532168113895900910854247521399554895529781550582806849790523833389893084518536060834832685622097231090397585685502199395551134545521290924266861842592714224402073494637426674029193910125176587896815977374475577011900752678646424642579248726361363336678870110288587035477510896039630197401429009658705999914443878600811574386e+01)},
                                                                                          {SC_(2.46631088884896598756313323974609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(4.05463829463703525078122574940316185372614216769109157708814571443486612751575690613250765783963915311892809190311521636840848682833365271859823541200911649626456985869205183744879031447905297712068866428485718280809470026817621417084457752394310317819688996380906775828413109847499866410583703740515922882544138759737755727432557079831161548511524423498124090291597806689974390433799904149419080022622021024787189417104421660109962432297064272955004064700460013960135399781819403593602459160459413744e+06), SC_(1.52153720417102064745346523708311080286908527069304380979659806362345202173276520946568894036685196482196087450838867175344344468238318814384356738850916294525418838439245756796795747454256238522398060373267581786207971837564233417365834530177830732568954115312718140425486929049831566682146227958628349055286920128285911779848078583664754564964840731594796819254368142311552040020238959735263159278838020281187709608149004880883080370901523357618622591286058941009526205756711994702121770949864546654e+01)},
                                                                                          {SC_(7.93268782217637635767459869384765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(1.26060619619731797608818932503181830260823421781213048732665695327420696362898453758226660591820476065756957020975520019667707610555894768703507485484222106076869765708337512029685375685746413643372605490449629888194538976635668689248136807099122488332322328884163089485410632245588395068264245821725494222737390864654038651030533750522546976123471768082838483346923830312776214845895208472603705758787692650064498899060550013054720470762070785663552346599987591854146837595704246331651813008524383209e+06), SC_(1.40471032713253781161105456090844398310531699761588801858703943827256004083339187938282688922859386138059958746496554270966644869917724313173459469024731217872312313939028706531208267916779711847875755923115508248648357114981186732018707140167984280398904591328254471708347734049112217021783628832842204199345747439816740684385414946326168177179946882060522211697405823017982624446938981152321786117064296988318870088712395225819402305299983569779003430897690524415945397318576782524369949353588329616e+01)},
                                                                                          {SC_(1.37209326567244715988636016845703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(7.28812853343498664144152447838008783938567673932162819960961771256950384002603126229351335533069556913916892568138616531409143041501189818980704581213281032710490015194970354870756213476299773879811898004568190420013714451336012132400839252929052511244586664386695283946540013669687700896185000308463082744375107020456438967956604931415578634631979274913179204735917911437772705149748195582640430894253267806733655964881188471383295076887111769104559648198985229120804501321038598800302786397869897490e+05), SC_(1.34991722610834251544478254617081208033887846401310469427406095478843346196811171297685073308928006301987164377413398299284980888737753603655332120887310757344649691900092227409561455158414895169100825749492101027579480515522441587439428668126217470515921622120380597586481272803721815179676865176168002630196740690339996435287953994766447951272834237454248437077301244123733043940406921792054573656410299063798548540972124521498460570764799509713656084726107747894221393929095901305152701667831232883e+01)},
                                                                                          {SC_(2.14747706195339560508728027343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(4.65662138219785513456021194162659715040199784495451432714692244736381873142785567562103911931072664389018733512973345980123097086105957143181830422993307222537024789466998094044967709540947345569548881850284232773624903802613550469100983177752083220734207267969462805084427281822878812239074581148461697210298236933264855944662677760069483003826859992395504506972326467470916808301997979437414794764181083226857845955214583704416618979717374942753521670200061935257869925639843860532949699488119920342e+05), SC_(1.30512156248704163419310858052987283807885073935136057758898979845218818037254859855534477451394234492262573113912574193529039772507620648887073103288733240844530015624769737072016655692043999870453260213995786982745953810791105720212177103030589518066961157830316056921435994370920505014296960653565850275264051276660243817416894060431159237063418800675904538400890810373846318565995207426410477915174816465069935340231044180571276528013572674914197376905082237182062279095158542604714638986206139428e+01)},
                                                                                          {SC_(5.27022712049074470996856689453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(1.89744566051396948131191467613435700133438193946287587593391216386661306606335409546369520065981423905125657400592597211211243004697254375450734895459592300815375383152751165081305823627983584181411284526182204207394660389795419887200792166308617327974051439608467092227533174890458055752767205733534348342642249333065058210492219904013467166773249090089125094303714125962392590340230759838587590812261282901800275368686907652321958606428003570401793590415297039558116943719793472143796722363193257473e+05), SC_(1.21534340574375251331797866321470805050072336943670368507800133643376730773790413820040384632351349786576361785072435541887797662530053082201097185957785332034829965887731383605989153147309401665061094744509328906214042555919268939030387813798149437192066156894881989347180491920144816757302805182042339614005936728867964872372329336770418426254156892181076908397406972043893748829677877785432144800417604037445100468162760543750235752313608369165085076555511055641440400557644122506521106201156828000e+01)},
                                                                                          {SC_(9.23316110856831073760986328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(1.08304692055151174435645853312702433563445401245428008062158172231455734708917727233248309622995416103476130730859783426082812474016241501932511000475901840984624284970956268938241100845148302704104227692202374326021995429710412190789499517501742831968214505026085727217377064048749586381949765702833484753838333062317642259075801944397863616645673756838251985742411639158567796696629295388664024665052813892150438181549706074897778508926078559131307287669070666914378154990685310194791830936012072137e+05), SC_(1.15927037566595656608676333962593457748246358442149722307760213653329691390266732585232312633218072213780520674080290918004260905060501441987250389989879522599564165926295894900973356709358185982833184287889198682185728270473692925487109895376481633969407425746209783983216649854424136095892698254944537841867507179483097032287978923877995255955010604613196178590571391372314231476100820183230223610979878398116965034513157331357185817159093437732287357107176531525209785815749703666087413492601638367e+01)},
                                                                                          {SC_(2.69396477960981428623199462890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-05), SC_(3.71194329747660700872822240489096533346970414462319130943332437727673026086395871555354923534426796329307758684090756605125926441079955027284505526484660084516570689496028558153640491596899194314856682287855875398764204347089952167700379787578451809878965118618325856981967306344605010950402177172875745453986482790033650570205353879618538529832262937125092859324209602202715647865832427287280809938499032165592488069349477641753571240221659642079940920995507104949485325593819265961739532385927724001e+04), SC_(1.05218959113191896554438255983392789165506636604484179691160873065455025312686246355084294414971498650330801965012760611510148977404541413264372006775938011586906419749948493205342928656222439747335580984568333324076988203103506297440002347920779866410520674190113274847777131783052870610390167794377546520034787355528411508314922975386358933134353197222922919703716998581882764082601589614612452860504022521256961901296746671426803571353232525264162049239730237299766785596779287518475633276054504511e+01)},
                                                                                          {SC_(3.20805702358484268188476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-05), SC_(3.11709385543515572081573476743918797729420381355450382111209778511181152310932055956563749014637508036076666934504020805229942252077588670358362288265495735084797052807569608353528679336352612738901337701163849825424516929631780124984065988054242480080427910793718686499912898841019187210679705723175454260477745636077694212098776697591722777186050104731968499613418884068268352388977472866805105290135328421979342194632200989741338926428484922875461512185439530419888158628103661380037688089459246622e+04), SC_(1.03472414831310176380983520126166183229500641071994253195046291587080019387137512979227110645263077621786969120878177843284129518960337795398690432074360786303100938249647682482133908324719023468000441189614849101558514019884444875606114225203976467536402967505115161687406889548187118481920055496926584251660690334337239079454029278564608943116880634267663164371010715252754735624250229428238157024613942707533924518433208364222285625505553939009603522382189325666940210790483815089523032160326727186e+01)},
                                                                                          {SC_(1.09570304630324244499206542968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(9.12598326298792575871376208892941821597249145712355235734553245112275791184424920173192390958809327836147088440453600847272070731838167459383457734633274396531286746571484131371295317801711910499009978655927962435202345802991303378916715764960222274468063689080593822570418178751973369105720490378352700618930760845476121115398840126230586994459640874070111920630086235547729480577307390280974311106356863825358553687848655142111054663297488417064528607271372924608147255338609518866735822561855075808e+03), SC_(9.11888092749354750131942804760198365932951387446607940153090806005643231331865994203153064090907668937081238831422255569214073300853117391260189906213547756795578339461193047601491906417607295384073771562974969006175586199307941274383550444330451406419535665500372152406327606813356895490483840883903495107538235046324827393471368712595702254706807119781085992818405020677615041495700125639064504392716280328536528527483253025798036974151336021910553259995244874029242300562997202783539503321465074836e+00)},
                                                                                          {SC_(1.26518658362329006195068359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(7.90339543765010940777148884430598859351624539666986011225276345158776246884141569590179807044935540608336020073420198831987509235879831098864207174778508378299183243304945942399124179383363140239127129852788889394591268763142954004803973096640508764838455634334250452217575170092021719528520780979702520546195516521766092522673675677114507991883621135632426293262864552958004567105759441872777690805227017885582718414531016665919775279511441635073252680404200996526347257159690831721716257307386634020e+03), SC_(8.97504774835078092356190417460687731975039635483901022943615671319109149737911055314981699026784930674690670230372344603892513366502197739637264654321535008940079734351022352120615821558964314283413690614455978052538154196046662526310741944191671468287266268233426532630706431678673817316378735628183210777142361433016716451904550644715844194615744623549079746505429283121123624192521206839116751685248416746623025501661583164546510521555172172770363313019918383836960358393888517833715726142629204114e+00)},
                                                                                          {SC_(2.89763789623975753784179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(3.45050990712494949775484002402506388638080961096441424786111616212629018401813163185537287870628332365611975002748252281954445942791824089759407952360045363041729854235263163931426111990963272192916849625697623347007557637621285946168372199998129262208030995630954149379608985182807987421083472125798154110350638801183057973882308932482367706263206585063709642030346439272821014392389727598715876907984410099739266841331289003132310293615533755248496236332102731721832627511713932767473667701783430362e+03), SC_(8.14627729827083672260241473795882251685177893472958167349605915118977814410015333417694750657030461729339257490528025119250178359084774998230863794007053582161693347623694527222996422723379100574685447013068079638620883177928422256598825247182208799316990898594977407941592694581625618281858646634334423979133024372486968759491378328948502691422577116400902205623065242117642679484587995259074059369354113787583549754706589392229130887348557036144422650603292395363687531902954386667400975083172345586e+00)},
                                                                                          {SC_(6.87856925651431083679199218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(1.45321416213776341402172643653824290406246448625953718991061156275374559371473926240159189562530897642663657874824554509667432592596502028111498876987731731419103181077902550647076830258178738399692656235388664685636163262176946409182939329754572681632034342895691385894677553479890654931971482605617255828759487638944296672758417176666979192400085893856817992255670426756593975946191143479418145211492672337177829308430717007395722848329062849814785306945348487702248579633088084778151184300309266488e+03), SC_(7.28153304578384526584740309475807940366672770326761440940762897710596740030873024930437245041126693802972723766820782336184883357255905701949197956259485841269939774864827721578724722429879285781856120681590534300373112907042521537083714436074932198957147919504117058586652251820950663673303273139893930539087144915014830401325006614936376974832764368207617357592682985463417492708094036271644356036769127411668259712404556319653473155967703044648299583649315831983842605529260138729644416212347308063e+00)},
                                                                                          {SC_(1.45484786480665206909179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(6.86781314954593160454464618092638855307877715120008177395736462810782174656198499987155564941616352195397978189958626591964468149122014404578158273793351109200213113242205214101044790656181720304965625629108123017569222776687767520209813381764274910480897470251188192687862750700740524066029998775711155906709369717589842957496547022861611550070495006016302488665795132883296840140179617961235225362018556687105202197899534545930741979641738181687774160395997039192122337171298869606024764194152572205e+02), SC_(6.53201592270476536860947401963790763923758464656367263306060046607497918271178641252338567185849747672002776634506076650648391589820323978592182449435073300185043423125573525602447945355905816656067022917255389590808978616355532501271604376496797233681175875074422547652589334792206541712331187984801333409296389423652916811105854094159227253078778899017652515577545872921594094374282044642163199705253838209075554053916667166971670921667204169860545673190811176573623732640765103804713524763978549642e+00)},
                                                                                          {SC_(2.84763518720865249633789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(3.50594171696151285909745151539060148090670100756598276592118180115987704129717344737175536146838467429650509880933261757536214809892173281876006961922839017349368918016715871059899525030941759609599269441898890931160728866049789584876193014773218548509654645319159561127258379771324092719966908675957131318483541799312767747733138961436119057779331859641695772856381662725815794379091863942494612270061680368205577445870953007609987741104005991805804886967384188275707554716979388087267636532946282078e+02), SC_(5.85962934855018738649587312234013861000302129002387515656848684744945876545003674583879202077964721098762835565299861962310916008066036172236976819930438289116464091969366411037592261252848982404206750088667969180754458945474285474601066663817491557087065960821804732948417813401515198784400105833419751461696325694087766748324802786184900101367488656974546138080516802723177843393752642666700380479419135279302308967786036757719890914724222867842139605213115580195304952037597706912460432334234902066e+00)},
                                                                                          {SC_(5.64682111144065856933593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(1.76519128540056304742831997519877820920857036914650901573270747956845477500889430697791487592196803258689553507495813881022776480777925700182036665576971280072328890974816214386062388950744611023401725987258039815422475168276086738701705000544747226989884474035058273612828243108186586517112777510088124111564539998697510264649032558567739799755678748844961531931104024399830344324164790517360715481533255431541118846660346844535860168147964486866047359898493337601385827325615954944742621429321977581e+02), SC_(5.17342924749847509395382677345036844101386697468349132677587382453025545597250597832024586312263039851038054560204026648849897213226041789143731646890157430242670947732858306884595312712256217331938275330011909939145523867716578226550295227412107943048043687400262298491544402458520241247144003660180386212975533604735504214749965015720884534279252951041120761999648196048357797420424505106730015081309075580772224806827744896280719587243764810430249896719753220866678503719199010381856204558124856374e+00)},
                                                                                          {SC_(1.16216316819190979003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(8.54805948781229923149687641890635273041975417474905882859150516565590298743474220866223427847397219829369000787365484657820972691183108360605393331283145369982954735683172978957406283752717555211684709068397614268169647182606579192285035162851360588278393626951222557182654523459375034429014293356095258118240324502965413852124342360304922331374659768398497859177287801543512494826720289510820485846755824343228251545178145676407581591245429045649416349044250416913523846071033825128926490142637555209e+01), SC_(4.44828938969349535148810997617139307954227933026998994112515594555692200779333843464356653807921936992867624497189566489714896857491962316363828135293928928346656864064617647335878702422430142925101126291391714324130882393175364831612313548374438381832325779808261417954388871727651255253232705020856911750794487479982819966152311932156460627180969788906322678826909888730809759061812987798687444590362138599953149339329603462078768122099122835718866740346965377935783016681741937074820082041620821229e+00)},
                                                                                          {SC_(2.57236361503601074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(3.83223951967113693849122890317251581426967564682796089915964456835265948178547033943047557579841168870426481105111239555909984888566219617456297725026211199966229821867396896637673047846203677720619527001090874122989539262164276823985235279052457210386157561812538654504918195664295917949283586772716395811634553989103419541323834554767430044867416405158430381076975887538013410973782203585237740277871442626129687031933867672020721719964459784999936157127453790515452253439903564787419239743591953735e+01), SC_(3.64603445628268180815228446194149337645492864618317199432418684416543018270226503511460400594569703029802101239399103310482691389005692181097074338257638671907992807691192922059620682440896513659224462009722394389581858799601911686718694851673895425167333370010580684144797968600958815062396012803331103402562839775473490687537808011575400396372112998895944651405677171661590755009935769417687641381092691734206386019166963834756183746889477962328743513839292774321043859834004242466174346299715639715e+00)},
                                                                                          {SC_(5.60617148876190185546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(1.73130292072055181332528155290397626567590041507263494389423293518332512065213706248091156839903121576423171826799183870730052420390377795841699975327731506894205043429718237598549528618024309783147598930694013249097703503193128875785371460887670941110426110649033031522216424367225466117889459621951853207485923846568405880011044669040489333426682118087888525374235517821551139711223601978742628388427488194084278925710136997272334148684152483989197734051109512385005918855581117719442233374533422244e+01), SC_(2.85145935140559624069624461061073352033685732756820805957005838077186103003354080673737557189099925222021795696661665853518636804085091657285841456607737476426645592333146127781631727888953940992284927928306043552361916447918323282469427741999878319265371284600734940623454427339491501614225992065340251283593925141296480332996912477863604005197249766568111289688786686315245507596213806311552005867021049188904470043625006815633642348871266026153738589428518712450395800127807049373655934687568417331e+00)},
                                                                                          {SC_(1.06835305690765380859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.87937594300137280222785178504237281981439562279757747352051112017636683902262772265882567787341933727313653229652916122291506572903276244906764087817565322262562231578119198439889397172690818865294208195973086367244330613132729788244977350056887782304089958939338325229445338626076593013444094664859749521861056733116710043733177675852597199662862200321171291806334222056142568553511466136167881100235172294895254202442503636358257078278759840849425123630124694068082847314610010282369584001586261853e+00), SC_(2.18373127784552189022885498465497378725174602502279874257568947818012110655570669710383812275007248898023855011570363491375778330408026208369307534619406033795714421333845585977938683598593439353594844370348254064282219915588151065915494297324923171198525509198152675095787497882326067723426000070832410772860559971251231892379783042570498001965458465779101525970184734775905368402518886395167646368847252388395330389342197997105657677203248240392695509386526846047757896615797092836470002490643633298e+00)},
                                                                                          {SC_(2.40109324455261230468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.78368178711231748572573525384921992043324039087841552984182765916536616511007182819817947529256026069114281603423250421784805149083154700929567018507486497721146897268173695523381988008996518312445075106405346666217454765991551115606292938365849946881660425346595554991194890984373406939193890782449870111966141693907909130927359458596551510644771454460052235072482166749519660613764899466155251273563930908045243468567615852308986288038858920350451375815061357930111117157254756816152463843436327128e+00), SC_(1.33069755333858002682528355594543980693815080830370533083954040140260195653398211600745407909514068964724602269394591033304236792153229295793542951189322400050827513942267588200591266599249018149995398100320469707929205615364581942070307474177593988947465298790510611575030618715531455462387945757223905207989659084961839714183952763698696758176669305915307247150797661417783641740176782212774158911335502133645542871042818603699326206692704757081405565700275666335072274515905630940653959113015557377e+00)},
                                                                                          {SC_(4.38671588897705078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.01934827098895240866291564717148470275669350790670181518067930385460960037293047713749104474976545378311550134726627432493246281473486566445456021631400427110536255673815460084692784908956829653495993998690913162566451452325878295142067599750666467140637626487570692754761019581563191008018345327025821296654609413196999811589162106157757140856559879383490075416647663882482288743311346454343684899228300598158351924220896203043721869605613557353107864698167995101951259722097491579350956902970931209e+00), SC_(7.02774821229955033201098872522145702309892877930122696222989524936496725944203147163698086529296544937631736479740341375762633221927065058166212697662139823190263516531129117388895917944769456807118372772711996458078531822620766199003175648806790195767357047125727581511679389676806235768985317112567081989787111582319607295781808387339568984936622732251106484870203126608862728541660239102098528893658125927049289362506476736744933084082880129995438327280953236300426644368771292926944860776376107631e-01)},
                                                                                          {SC_(9.03765439987182617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.06560979056544150631486646775654894531497351725167706096010663906438214437064541280383121734941160110013742022603852718722974043716489921274151432075110987277321452784597219287693334742039128758201596461554834254278304725176897557872665236905185284924160764990132078376209152960730546416782338895816056903193589945923357184438008243261009964597638527688093732813264760840562843021362962398437652711368023143234727399617697596268517882044297733794559710970166806228215768323696486824556471166719059683e+00), SC_(6.35472086047240242476850173653964968094401254249645125812894399696989269072611985147350175386979540001317320432048487161687158377836798760540253238342535989944288732501843277339124525960211590046211344621131449288110335040489171975921179119993706307712533585084502959793358884082738581504049157966802149956240785900918636177358262658800443458403672205227617798438927337432399221706666884340845929646445623501901592486353757974256947960849040821025145345264978638085227457220184701989027155986122840831e-02)},
                                                                                          {SC_(1.27602481842041015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.01414888950966447256741553037802701136914837769904660661341552878720993180981144638082955030623611082112991817736220467858881713541188940021200281798722356747839343824757865378792288085582653852666354963604237824428091058309940381345419447968927454656100213071087794811710211906454576989399445912084143541816722735712338070767965545035059458937634367561872704858664652199384243134873698614575689341524672508628895265595278960478185603597994851716518887234426980755563401446357574835173394489257258389e-01), SC_(-1.03789651277172193944086098338852746711453874554494751358201389145763256548191333008529778141620308270050982442005582738919672606157209775679357946534464297204946198894138476752722800806070647736840953123760641090828638676777046197081472678594658653029924350948826762779384389037531016067478554113108266601116041196944329962447909678357418268110606803095785064013479379529072212712584934963239795181858596438347804510477316820666489360204187718259096876068752105120502150744520502695973277633725886243e-01)}}};
//#undef SC_


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/gamma_1_2.ipp
================================================
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

static const boost::array<boost::array<typename table_type<T>::type, 3>, 42> gamma_1_2 = {{{SC_(1.00000143051147460937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99999174288391999092757871949960760944599692334161113632612001448234829888352099654097074654344285708898686038400924243326257000995473599459860412189476206535957778861551088462375468578938240500307167618043731787467573306745319965463132052615688418631316435531309275145303892395341676733095522386701856522207240447267708668301329563326443831046210450368179263405643106444973478994275343456845976754204700528622443064906871609264433329448562184863557194334628845647631027980086626707202034219860132039e-01), SC_(-8.25711948900924692597299306183832574130326734078524848537366321722804959189414089321374321487571322916700881394838168937675017756067526027059906924659380618507813551107141661082752510377407448366888067712646753094821383103251070103298799663269077425948810538745741157050557462080083874347930605957984000258314264095908394093097201357665227991167061298266665567091332898437498972810629979744483195488186797207794753595348181654435055140261537588799716884603608921499148980999953580901141143177940912987e-07)},
                                                                                           {SC_(1.00000190734863281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99998899052088870556298015139749114669312651159953142848295392815303317500016029969635974482718991700497816055817263571292901954688370348906253549005287861083171410201406647883485474421222649893000205148346129113166971062186410799748091336730057656052509954292585979817626028277775407407112537788176094920236533009104994139384430523864665582176691381647483160502797293814016280767994802120063648051546796192887146643586658388925305855542153022171696856252158767172309183370455258068376853535216362470e-01), SC_(-1.10094851717304002712268894099127595921487972573933586334689334527229248323934919014638550108524145553527405840273344353639000207218741487766297554573091476469480049905558271838458052416000410785954618163762239772914309942293307957081996934083616872743593791436745000684254951241300456576383726667911197040993317728453157236842228209877681100498209542136619826560930165076125847234456840374995616717759747291279589613997037378064178672114262185168274084948288257929977168303768505416039428474173888808e-06)},
                                                                                           {SC_(1.00000715255737304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99995871482439030123562974470516145713394424812766636877383802416011979320279049083203112581733456099995683282738209665836532102308697025612534875128891666457345958520964130243018916433692201391748875528601051438277602513487355536872792386028259758535373151611332556663150738220804194424251848920431250539383936484964316068698893034940814586752406503829065074575875145977149630424770495659102034695665964258237898580634499483188073724936730054003089085359012125236558137262535083336056587140852800456e-01), SC_(-4.12852608332195851691203735959218082583309360270436920767851544796916430110170536266576060329474456009336058048427569309546294249770163912414335808655484082224000396074276450271816190829739395101572464054265620776265007334847480163917450671956548131916218767194273440313568874946498741895154818277265159531908173961864655218297464043731661102093299016819229971909322404880656592327408588191219928932127624518196151869557514361114934732089059682453199895851884381325844177861206907545771018319777526395e-06)},
                                                                                           {SC_(1.00001382827758789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99992018290683797846000226935056171185859936503128820835471750919976663152444739936675800355406606711512157240239127384452319098942674657017897817468120805836926848121657068423652761200611382709254842088377275403963217241357409925817025690122325186353402737193791739281574809393066322820848698863824029214072384456058169355314312772713088236719681578106869264305967664276510843791749709913005299240434221449190581606080546735845029507633743966156522363875224608869485434247381577247694136841387337506e-01), SC_(-7.98174117021345792583197715106148864099769997469814968659586924923411082051309399423820083379003398574828706106026847702771900443355053076333928564661934959347977543844422372354610528704694194514369673005031394800075820697954595056265037686466809758696282814462959586452027325510485481129596043614869818722579861830854885232173045580402917981131629803571485201158990471407846736365894690896340575434314344665619486163529114866521238533471912104264466874277993839991170047144881087379199096956344930374e-06)},
                                                                                           {SC_(1.00001716613769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99990091727863163325242222177264151557699017886575216984231288977651535626638346381310234072695038675659981791249420691007156006802164340387989178169488325851634552002703894997675940814211199538881805758913622490627980631399097588920415763179341948229307099650348008989816592713813726915109074989891788978965796994913538811183413860908256492363372407238104866387595665466503765367010396538799223340678265221385147175632220501459281016668716802117533163355282958056372905167080533658897792045054410079e-01), SC_(-9.90832122408929040408559547336655735086172539547473819642814546268213452104179698046816192544343649213516276050992499286077179633065711247130052986266586612792198019407011580703718749973206816410430099598884696898621732263753199017370635170322352068229418089019905571698341346767171969043521773124763386169098538786284978144876183616053588253360709161373130687567240750392131068350600396793696828309634567406848106245558829741030294161625454805367042624975175240236006902139797188269658688359388850604e-06)},
                                                                                           {SC_(1.00006008148193359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99965323597539602107075328547761587261019813359390369760751109252264732839906671037031518875134968012136696641174447037803904262082887969976109296285684390252157866836780186592932702237009167943025982890755934376143300721600433843080584322613515975251145176495194038059333781579482810573482380992838639055654464946705171224947543458455875016762570976299577906723146773198425090625559656009265422616400519050536628957500842705209930585910280037352659669895054043861427070231539351464283935980884908931e-01), SC_(-3.46770037007409655757667178857746223190711811787178225776104706289662004501688838200316229177747817138199803885280303413474034927454764780105040241282675413678168958627420206298519414644689489796825217807297340862467260672318740929958999360584422503219415448595860007050952381087378585257254009183598634422465183290108846220184440918709834134414756286915640039850168914802758353098152897222212865686814139570252607648258247174783738621351343846323154823824135361645528936757373238593936453258830559626e-05)},
                                                                                           {SC_(1.00011682510375976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99932580217349322111022028953617401331744333751403970060804097152155125562795257245209990189244390955065622803586974115564775452579165277800679992202499294033532574731584142945934294435673450155960678373595954883991435191422966953073303251361033522456325375489064785213746192226948204738894305982149533115149748405385850564842587242123139516721576059297438931817529512643270863422808208534475683331512001048644854819051058927620674300198483640232556173168539289960682363209643255386743487137951435608e-01), SC_(-6.74220554663799556877310402772443112760157761571902023463311635516217433897770295691084680383277023834238210219871774978089885153707718168224025213708002539939323526485458159206065857983075309830686070983216968357999309570523171700990741684698946763301064392077432210536224126429808942160450023453639044757019826692163047432599057748754815292572362647469482812022241942671262055942485364235176211540596083535537009938706493439634976520904423708619194103147768525477352233702757523202626115873106021273e-05)},
                                                                                           {SC_(1.00014877319335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99914147670522157119990095816051182525869285752191570299986635498915136588896493248365257759438213001482731183963093196649233881218040818957792374396660936598196305684819148527571896894670840843075654286835564773000594859074473690225403830688350354252139596396883469105131902182804954743787255215002586550458745855022390733700033552487189754708762505434494766042941772545691183075216127229908050031032252997777058211897547918467712668931901682746348165792889219319764070713850889628242784768424868130e-01), SC_(-8.58560150000232182840017338970199207015444462387386607649752923794156356753324749863484023674482826368894211048585691962413851546114269579480065761062341760434702534740992077291531596054368583871596159082563812571726762650773153069310637429285445540476388286200085615639301380104059851185751956992083481298692217441089203287067778907940777696367340030092049574459913524572177529000648022805010658269187678613395820117311947653348295570171839424515238720298923295035866057993641637438770886487510361427e-05)},
                                                                                           {SC_(1.00039815902709960937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99770333110831492808746107899166135280142203963707103455559351498353730379622819894763111240763432539056047936359580766442659319921652358936987966214938950939435663301222127947502411131332209082447717639899925306161185533504539560696196046757852273728024849898337683541947420067193081937907625447769106391972105734465495304033409391663299515305873457058683377675271966433428080840182451133769485259668772279477913835172938605800816170644204743795319739336290349933820409636830617776722200662226423410e-01), SC_(-2.29693266647263659905267506634368150483626461773464138564883162577609178712280408452312056570476352591647966867985753773286072034838577415545063255615155600715276129983764450847384254995243544335451212874166249277514712689608517250431900213708104149683916395785770433269863454207362975420101202621074988088246180747303492773111501326915687144736749558273211568644678725198708337441028102186739131006289732732451411357227579446820937346539059417079097069904499656657749370706773592719032343614925133271e-04)},
                                                                                           {SC_(1.00063848495483398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99631859447795538102193086350466626797653070729794205440800520055636280763885061673862015030796869853893789243475736071832934110880676018608126876844999256516872278028164486551902037327521458584687257382213309438429801326762332746780555937892390377489762791671064874927604230957617846733925263989858598196284959978561705689127705026814246454264077811405090206416845460825762177518652427086599576814868159221508338773364149774888148314871107526895227752545125757315695610947566263171638714842858738272e-01), SC_(-3.68208332573195956331210081624594239749394416803950908768685933543093626633451555793231113756331335425963182990684777112954271367958172970283738601921956301734980965046021109384234366447704543598220974149455699644080458292345192792596261425685403086325921370880394538207189224801004010561669507034655239854624541613368723129243328830529900319847443342058489559670277958326928917863667680577628031005468470452675568722782294683578292536699572826364160501920571986429433940804663506127245264105983664301e-04)},
                                                                                           {SC_(1.00107145309448242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.99382674822601667403239575382618951458893199251301947146215993352196283762341237298698231312941265613694903447679790369281559605314211409159830913156190622044924254885952656386521417492543976139615818498174187287133742132249380106828717540300112779917059538337849851096305151233791188029858916028445980753589436609863762082166374840070247490176396648225666182221677814131865874707658977935654371728304366144253753158711600380365080650129423678311958337349802342329016782920332415801360758065052764693e-01), SC_(-6.17515801040877325131151232919778004462797029509263756439665376295049986314719517615619416044020139941656219729463770419342221308377598718445537314327839397064675755119235423378203363475348607407689849591829201234719170773126477412940229835868424119423489707620954508876185462076594438172323119672045609009061662915362180538360149343723949200326445809001654182581777638480231628275052706847821672195497723988024572921599072175197242142212195116944762930191378376328084045634116582617540525060723552551e-04)},
                                                                                           {SC_(1.00302171707153320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.98264823461931536749416512755660281120989924865707625229833257960645264035500100250336898184907448998921042036230368188091708046504522273427794078979113111960829807534456665305177251159579747032678402428834297225115471239166750815621846487365110340243197886307308000837905364975250652215207125797086578339200177075082274308974522430592585814094736901318362632618659922741288815306432900856791717414156527945120488582581537806945315376665198216838443054961618230007143995001406730984367520071959292714e-01), SC_(-1.73668370059196286526539979196054130140895376467504060472269120641199689896392717833308713991174930707390895685228964418616313569936348016118980224344687827465558226448493405115419933128303920683280943663247672453726972961437611838482173177548854889388730797437720783444466661451141517724151590371105457213113919681710114442333257409145438562709571297072489258507270738823389529512161726965101165499837215710030502282466952003769887407843034316530688055949633407900696533642354006548208448645662316917e-03)},
                                                                                           {SC_(1.00499391555786132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.97141987555054340304313176463811884706264975589409907711234106560058609393271957307055082872891129410102083699500728283618347812653629468281551207846668700643470399586576624117253612700605418076832930868289087002572928070786756405137053359765443944765968271908912062956518242691227870162853819197340367908118996679846253679049356114011183750259927716203480089987629318935061831663652778532993830636783378403442682358220843386678860533265544542528384278621171051277427390347574579492853577100128619407e-01), SC_(-2.86210436087086001219787203735569562421372152373863548640068045829675888249714024869717239721994061219165785957749026372538378678509251738859065487118286167323424304865392614274250231752411862994497835172325480685039413276552426722185380374001250774890081771218253381634489468447683838615323458562556132390816770034833055105238636360789783990787873918822664133911201583322251908688863597569845687382260426660773087641598696053109034352095877056488917071635782120160167491767030736813586543030924751972e-03)},
                                                                                           {SC_(1.00928401947021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.94725649294890404479691100544964299212951704478613530903971822806017329877156708018465369324189948798034254635780503202894085998084733850371417658768318005687261606936611555053869547658745148804444802910439708812910773154353420286199364712053375318222724588767021914345493933709903167527793547413249855259854089366858866896664154070656991436736886582807429735741274943744190439486793177574882112810679231693943021915551996830675255244876341153517755183653646041518858296397522796201891082052630011680e-01), SC_(-5.28830919574000394857298213309555217277552558169501942679144421480630307191430194474561267421233056506945756642955882873960771251210761377932729055199230933294031635221988391115425824318672303823777879654381369427266345995275947337336618588685415927144581932003652590401257458835032565848265828024191566846037511249492915676767412627621261275712261144003161259984311425096376028822716363239133708904326402490271273591177695515131973061269294472455115171077929366425109455097808718265759636660823511773e-03)},
                                                                                           {SC_(1.02416992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.86614048062602117123406311118908657526377765145590897833523630975503363209176138538389943023236553603567032030295329814866052858161398959719488439602760043127493599629647790910368650401083097710387444443112945732297448026376057799816375936299971289892260452026548899140129220485002888583419955984239574912694509374491745016651528016606029396150839935179771239942510295480902170767514068781705260053508993213902538634255145495226403542335065511017877104815179205392647102946016289317357707173178319778e-01), SC_(-1.34763514204995372109520288412048333775377813106008243000148150918296004262962726414132914028794577353429614250975299694173700835973336120904901398475019010957711015087496744076484212085372674226997687893794106127390983166014459284671204531469581065659308636723155764096816681418792159648003075197102825097837643825841085478699904544782275291790410274144152650577672862729352423481593131480537858719681819399045310180592496365519546516973520373011933766484977458014591739445077700073769103597250567667e-02)},
                                                                                           {SC_(1.06227731704711914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.67683284737636217813685234156898327768051602711302285901829303009936564635927633847791905521633600182260778451883080067109265151115529992925211612926715722203426431025001128565716170432011945340670439807499803976561841973814640123513684707855300283766826345586152363103902831064307590922557520983011890727883861293257299222429489009382052966333548186633019471937742818976913809802674997409468133243009640443196713199007760299064535991343883139271256226294904557987948005599961383926203112142304751891e-01), SC_(-3.28504304307040642219585079239267415655387519327605107558648615710409468862569859227455978653146395616102834823083140570843368962391564290326611187884817002376245922067354288141538130729190429210727139841839276253448391616940778575204647813069308428390814330462539441519296405032309130029624726521666062066510420118474939973861641972779471516623719555431865569868101377367606319715633947259100590108593611531959008242872074641637498065015954588974509068119809908143583335322131919999217251753951186048e-02)},
                                                                                           {SC_(1.12234401702880859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.42719540443721868609002739661970901317374072285768379447466866954674796223379001999201565264677947553367307391082852503202607769289913522567688887058955685132616165787742839855998640874824219137049123198709821760747886535404924436193564823937315970827009692703009325365564932429177420389197235892443670127598813072041078050012898789236697316107241881629714345634175264626532960435557492555881063944965513891366901261370042103809394595612230568364837051250994297966981292812529454999511053648268266764e-01), SC_(-5.89864526271249351144556212579822618917436335049065095559579674127451726947716815647990915471041353567929075619948343725717548053442557223884779131419367919157584133387553223567375506176942960614314964694763936598785587324632686320182733715386907383114749720665798633555874573366724394801004742262541189978425319883592782254726978670759080718710838718774274176068877873338044184550009341943947599806101348846632287258040041525848381664958987160401558865553412301389282414760154376012162803848258086080e-02)},
                                                                                           {SC_(1.24955749511718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.06493816701717652070796129681189279368155581078682075820670134311300664131805878872586560909347774849547077856785642913530318887990663829885598997306430503539463747760384445798729628986584285556511189918203631381512642237968267976800749340764140551780790213440489556072013302545763169764814551474864925015186841329299201026352946069132722200522135595378262960918915145172163243476478068099324456198209609874843860356636542021486098870105783313973496928190246231924822313645766881423162228482926452743e-01), SC_(-9.81710698786497220376429335539270291577202696321668505055577023289661137227566055993679749549766918458699591847594920910105255828822634290141131935936546209147240316032812525952523382179180640249028818445846744545617651819215028796677831516376847157547306218459444490819966549093798582410582121073841724280247709105859157726125972512495037490263556773941212263105105345816502885995240534301400324958919560073963596185728670816181963867297997989630900958703732881856633201726987832993395543288655355655e-02)},
                                                                                           {SC_(1.49122190475463867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.85975092788991742528041047924561577192733154188411771443460511494016648390575001890695683272836236515321056943442804539359597265274910084710921603660396269156598507728775879061867953195401830327778287272821941688982147004473011352892866957493463356307424660232522691594801771101120466915823926551028340522696126815833575982012695964065305355745762363170848885276046624884963565926602220756773747996380869706730672003309814235399043910590132770511920234964269726502103389367669862235505150898557966263e-01), SC_(-1.21066440748512404475024426968054339220139475801816468185017851452260119203818813132939295220966959576860336864073002283446059920152906043012149024456589573987061299654713751597706989918988719559690035557918832819457973675159107009641096292984585286590294204090882255710857113184702854471283701290417226824298947728969222795981705252849942735333352549341821313583386938754136637061655567217513693143381971281132686015952311886746414259153818520215140430872206179626007079632596580406780773162650910071e-01)},
                                                                                           {SC_(1.98384714126586914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.93277940863746060094197659735027757230706286917741917762496289768909973927152319136925826790987137836060306879047113080832050742214997883337058606749529722735374603438145977294427160833784267011312076909076550541477208463886596934763667375400780519791449104728834334555489059974684968690493160617288828111978728838786866301310864555490911074901146366512699766804528603943358823947495513863982273895087758009700096077066283343694119497087163296220588369077116759749556165607389286281631813045097817428e-01), SC_(-6.74475393680727792069762024270330812537700489703053013284255062343350182439674474578730149516053038676811013704009948324320350047574120923780989626605300836004879573275984536698779115493092794651554687907372115587742289911340235342079018983733618420038276859524379547071361323963477361912857826074181438032171394433343549277630241247535256024056315554535944762558500606719649195939605908602554320144187923405070267451743300647279690038646110638038235596246122379284569329673191480466839566772904937236e-03)},
                                                                                           {SC_(2.00000095367431640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000040319893632897083396218235250442687645120641744558071205705190318147242371991332042156751805833852697631957330509506196708584945266641045457660989815172203541816266426236940069173585211589763128871697578680808418618594108833421417980995744773022193915847912330485683365230207586357094671604272787550530903600224806658987408719323099820976084511227529072261830260642708557524072773978716369615012122132057589880483944058104433222796365791263393617076632690550955298233611068528870707089364095396e+00), SC_(4.03198855044301554816172072614225033788691505795611432584438613689610292824028384688095043674471559124897800612350231064864096087718457160639337450525089464591496773979407785076356708014174129536539640532615095723967138046302232419186403372347709059543748470408896810291291180015648613156670374402027509167511951650054983758492567575324143010258003034809361205157135224850913835714293416750775594448006015222943082316111780423579293934013166760093499975251633169677773646504254854198727344120013504365e-07)},
                                                                                           {SC_(2.00000190734863281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000080639862179156320749294205460277721263993072638189466465607403289991143399112081618390192080963070354362886119327646176199516603660937826302901159928779494258019082124712407057933583908441496121322063683259318008058781175829274964725273678817450354460034581300882836023853249853243649983467946063352515390711748246817082161654458328562433974332388415775058145731044093471875681157457108697886142238279184839101146584613813640533770816777389788965810315717293167650115988276824457403595566759389e+00), SC_(8.06398296652369388346753570212806293434617232720966725801587802276808064585926804588184187043135604602686396171466242066554348032404711308797270594130241494161534533864038783147874657175104558077883552634080070849598914179245766012967264457383839298001666035383180768607693646745391307544328709128695266429891189065277448225084990453870685304089249021637700855765025758836941010684469612390178013299005220982859478280091515998345131481699299506763765052696832472588629108234998520472751599705762862356e-07)},
                                                                                           {SC_(2.00000667572021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000282240828612370720432797341957422445599590783120191598452050016192718431252156475433521025107815241299689727688190713762804692078252171442580070457989886811171740362147708150897847246521021353648087384510766114323922511042794780794963611368596831842470145084109206592297151053427050373627219979831633894688588291555439270912595000568295516884494034186513041322990336045552200687704404122041643387206167556427413751475495475766262400293533115355573835729416036577460770575506761724680166442542205e+00), SC_(2.82240430313693482259741002317161344692584090816350421570061439040390205793534184180679012494641343828056263558002807243971560338327014657463162594242259880851334402250020991610342925766542062329630756367550321323211687945637272726042075205149190416983911272664024992320980212857811481896974987286244636574782770763547904245074167747630014211411345847779432353677900379896876560812240587252030790328354166673314806061716097732347525218908223708776924400221206951936181129323023407095316462578683205523e-06)},
                                                                                           {SC_(2.00001335144042968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000564485327991968668594609717588743187620334387669560320925683608138323706505379186671848228233776630265493443006782405469373155950681711638198173774648872464328767774535861493087995322216857536320454566762040450313550698727293463258463329821616727965930447601219959984721044168618580561296210950745646574464740623985999575897298077649444083254875738139464502197343599936704712558359823411346914202036213419554769879303409746624911821501582952260886957328885985322110392828234082593263639947413253e+00), SC_(5.64483734779536708386785894934199777725964876845433467264447717112994234556972534192218656188108493669337126323346525968019986211081211701648787471584545174938623855070199540574827647819065018548603418529971801560701167562341186495748315805711171811817613909853725214174720409287402657526024192981129576773427177060556261477821785713896316233730786535929598718603282821984633658641971448620591249698834069603542821378964494629888597814475264502798958300823972230397309547512496385402948011659018612308e-06)},
                                                                                           {SC_(2.00001716613769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000725769547171200167564651655781339501747509170098598324110434935716090095444696937906607363088739878177923814143661505313658313437339243393242291780132442290199415466622168654728458608339173247740576549746614640956566066866430011407322576072587095409588704181386960856222173704985729295910394663867051373449414642750484101682727247737150988891422843497594286426018641870789465070238089390338211030500873713792516468514692736358005370399134292567498197113950550095013629986729155685259947938135536e+00), SC_(7.25766913476765189195943994441059059063931591396766321180095950635741905767289274108973144158196620893048522962182368196336453133307209215602635345230143943859407773807168277575281927389367146545537872394784276831689726825577222687305283368915549011001823219543451522711095115473870948208010149514574062931974517483036146556187182145659391171551431216570623340783643192270760300569668149898941633206468627648411118821538870638769588745778143031469232973340074226512043471253590740081694584319298530296e-06)},
                                                                                           {SC_(2.00006008148193359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00002540299606354791065346284198395071392875295770431323580196614759982793856324349365396015329614421966458647642567726829113804005273586077478149065754298525775201160607751664030681223021989523182566039331380106760457489528499350049417578075515249135149538682436349952364131677792289256760214855379993211811298605656429676833893492196246177835739676095563228276086226377489403591966271602430351591781580342925613408409569377283919944732510580834336822851093251943664838933995360754027866586976925851e+00), SC_(2.54026734129075920683292497513548989135470818393407385853298137294395173713099726839012404342665592243399085416582332060628801690208097983739002406025934607527022791719818585971188300777024910785735796519500643466487320162076429378768121348997496169212590642570240123161578934167744566979249172495862343250947755453958462282871032707952094614466497359897253881671158104674131343402296124478766617373684005972841762744006880609634714505140811507944847363892081962397928329908133631675224301028449247209e-05)},
                                                                                           {SC_(2.00011634826660156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00004919579971274987085172264051528477688620257556098733179199797634993006055608473993509011423580085655400431431748032522949606654990020016568322885459038549486931421278268572942503971061688380325649937281598614721987287749832098883394446271542552887155227649358981358083752285904573279825696370210973258395291081843521899210367510309139360759318429085870041933795710719739751402675370645882893834096485696907489845929951714564265042472412399767903286958066978690375487334358793398429830456561541246e+00), SC_(4.91945896390820475195370970645602094808037804377590418877034537519903014145963070050094790711325337883992554088808760086026030902259009588513453547405813184039270067427528313371078524967343062809805890477343634441228005677940570227333130604677886144106807165848097649545352137718974323948752964644308680893166137837610910555163484988859334163045674658729040392892717423042002979632823737182738830808717162341432139261825185824243512121766256143995598535133134723195587750262495436621336439795174387835e-05)},
                                                                                           {SC_(2.00014877319335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00006290809135631836010117832694910884162897852465378752121504232411219503893527713522395467812648391482447399141309991293749270126109922804569579351974393592882118993134665992128136689581102395919839579729236175109716400885285467347857304588838104602389799424028052742153471950528851108394765447248467693160600801279958904164762839085292385657809249863560539720701829052485256749042278246123879349245502162062142354267095491755531429549626456789964981518584088969769936886585070722733145919395422821e+00), SC_(6.29061127253201440487758474836373805783136286628744476010931129298030354555338078339617930326707541807536724443762505067268693291418747671368044733699672217831004599282343529717810773460926922006823045900978640697730593796486796292597553994448182322203424673613673826679553245785071474823905571747970217285633939851724732886368648977212490174113663820136503886232944614523399811332727124466745548877384069974675038479667681516039717424797860050660126927295087191793263665124491531011381265079322510497e-05)},
                                                                                           {SC_(2.00039863586425781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00016860244976056265274104250042339264795490885298408767683185991260848173515982048063530097499917171148194931029349352640670782785724424106239359449491337847227802622585196405678868931956700176591838250468804948749651418462210706999940223229935053155558688743886448270973803464416218977188135288871521807292536522613240793899596571718868959233786678163988748880988951672966050324443415049581691737548496916730217092347107982502603129665491416261845625192330758149843287258281523770384959803934715742e+00), SC_(1.68588237964936617725573866192084801300187025488573449723958905292528558677560307939136401071488780012664616755906250008647359831845341046315862971508236868311850624153598433932470170707220423511352555441028287147256686322654153696151693628355062766009121440388562309459578300783864351215367098079641124426125653492611009828966768679542829405019789539978282261729619815161598550862768014752088779305148355628992689441225448919902699678811993936710593983239834116001627961033784077675665187451904779153e-04)},
                                                                                           {SC_(2.00063800811767578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00026990750041852421765366910628431973474865306478493810159708621323870871973118744454114814939325483626647062327232431721609165735997428833979053416183622439983621245874940645789317173396881439394408015656296494647112371565895925809887772690783846745411149877139730876519000006744104903586271269698152110744658555649922874109964207178521955852588404483178141111968812445948355284551749269795546643581115097967186393797452722030686805063649653415569480391265099835897962993260240130068971271304727487e+00), SC_(2.69871081942065723897833099470995487800158997999008998347813401241773943654131765184972285158614214641749498196406392645505184508075530625363890023930226819460655785021303840797155528371522530911358371088155260193772440453024087940353600470087063993834537412713544819005646799581180031366714889866852653659503836096784982086654775806436187485934147132190078275537650223336741258760920441829149880313735373118931133566363904035798043218143706480154098407247747391184674434380504850962356703140842776482e-04)},
                                                                                           {SC_(2.00107192993164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00045366850244676328437925811291073214721976041570836260525501664695528715250408575145931378349350227688837316676868254719113597414318217870885844613229100808084497215923555968306851384139377823756137707740468543389970979577970623128733809962698992633941000918916641725087330663136277097326315490132382010503633074057199260098276330149620295467434128041592429716319985644497132929559777710003514847010029779221896564946779046395621309674719671941599041158491221996485551059405243097093577110261783446e+00), SC_(4.53565626005065278926467940737642886605249081041802313480807335050258790272115953359716522668419818080599307266053631904431521057302273515725629853746800638510488383571198722159231860540917028344994514956013946808052183595119710018510329469789737703176433796292351366450813161229871010564403903786056927568689158871830933860651600507487702193264045530383700007441066684051740039536729108634765214756819077820262508689114004651424406631533658945395417870161936749479421943272531385382088836918042945083e-04)},
                                                                                           {SC_(2.00302124023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00128109453382675805173992936811235013623574400347864620287586318438309294296665771775467445713658191501098042317502832687005143325478326763307131985706554101553485442510186534211913551363194311510651662998641180078528045675828899947117843797072061127185592558360128674206812796658575963285754372198258684165702376177309610909388042634428491075001412861942564107042409560615729123629146679339990196142809886924437774615022430018387187232103447017447004392918496134872896723476265006537164632595098140e+00), SC_(1.28027463239724483573557591805281156031783786455407331932724556092523281693077215723336812242738030575971419315597244134798471470509239217931886729204522846233287533744777134652447761428596469288172600899533917013300359587696649805109934740082670700437170661671201465552822434017620867488841178011239797068554314139917114166483646378072990776989847016014395621598620280894638628718729791912651882959514839837935385891368255358441348171707916587078365790333842092452342852422428006539026507499595286123e-03)},
                                                                                           {SC_(2.00499343872070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00212142687656938141755270267953218765354768440933747494815728726712151222070491619095448970333895393102444381708475627275738580419453523195048052196379247915358684398503757315017141406139047336197575310525733968756298578987992499076885165365084990221306522699178292450185978338864665272953117267614937180452725496381985816195572219564378217691076292404788320272952577105820443381455242824711291502490670740124425205103598528630778954594116895950873773335330424825150256890064566932046528756803850377e+00), SC_(2.11917982797806522188180583003778103974751450356379656023292543359724208118117325946572388778921904109959311356271811647949638546545148491244584564070484155125952798837608461639766227062066344856863585936876232794773824375120613111140413086769458486596098060127417623954442102532030333552359584958516332878683424121585275505850970921650425493840174528373209639623509936585019571702003296293023302489480387225826279840718692043287032926120545307827287470013099533025763093667172429225118318113870786208e-03)},
                                                                                           {SC_(2.00928401947021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00396070159046626935511242705234690901218236095282169771624882103505993499719962388966570231900481119384425168785810482517055802032380367843668498408199062053383972024792891639768193707683013646734312421126399867391625714088146455431741320398132294311867702699910710257806208656164296257925674148222338444701332204049088886668733363978488089027829282411338212114532892893682282276507146315808397645071291768383839937827086383616329198213608310939839268318908099732004589321018099591371493619747249631e+00), SC_(3.95287866131048848362949332955482809813076597121930182265468445712788358294143596058339399774748227605315495370143056461809371109597058293347314059761260952541527829461615326949940335043617147241318395774085607956500413456369858807011840974780701301554326183297359957043339930077882451930283804249507686065739672454172144114535956579235090987261573105806998672929894099870037590014574603650514557889886665766715585784345883317933151789624097968432728774013964196082834709374955951419821387012151249400e-03)},
                                                                                           {SC_(2.02416992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.01046043252505270540348864139253462361405144648089692783487100389214760953674167508997700463439388241380949691579319056966872356933278042871661474710292440940425675059725890695043859580872646359743050035128388851244819200943544005620842213202597157253369936431918277145821339842153005800963054574069458416961754561181466561153641602286677082930975916212869637489229264881405874178948279261212245261827886389949246815690926156066278390139052729949218614616691327310111196212366658537263564003698316686e+00), SC_(1.04061007614633015888506552864890187300424291776713882118559537231037896435738358627458345297202553217351350725032661791909644351751312758522401030616953479527240248501544067448116919217029247318494741938200819289498451100715539693480677760858450468487286554749460935161181430847180062573510341370004226635188701720062386639582275639420676796347377428587899902624464686139266483219004395187251433297865892676882328269889806653848707748007936999905330214536016979834048012739320965030439429057045382243e-02)},
                                                                                           {SC_(2.06227684020996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.02794777691629049193504390235516903904685488713247685582519603512105260522463735818554622361453962807292107231999993865443863636016422482468073136921333975898098163990514820931936483699455271677262446764306240533746033838338608816064501896947661274923124993994172638131485369377970739578593544353021087099305294127230319375266951896578913720592622847270176439826888386290790930789539393963150979413129440604185373077854075465693083153485136923946684182484672155068069363826098702103238635420489190320e+00), SC_(2.75643650774888061670685649048190767794082581488473953554589507676339470495854150371718710075080407758280379482617006492575884521367017539656756513515621826253686899723946040513136318257344014516389163303047441444416452076515352022257721695414093144578314213761291012013465662826539298879963192579050341577937021219782512691210616431141692894047421455586943199613536641000412200192791271919535732465144076608722082755046949411524847483821817449723308031951964499163351930528842227963221257503313906453e-02)},
                                                                                           {SC_(2.12234401702880859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.05805563595315918870620421524696928104121094020123122438591403908241219015868614428499827547272175158643580386943048386142399843901618528166730694455229164550039869186159172224183094834887338162067894198894809433633712767764687117266852119387945316827334128187517324798364147479381468438290770208748715873468048281517169879643662462978121501305190754179038096804244270749490304891307019935778794914003748853181431342998479066888373904416656160676722262062683000801879454155276475143345792496648973201e+00), SC_(5.64329180205833189457202528539405980451202615961305194101203405759309850646470129298871261850384869366086721140086742612879750402334731484485411214841852903126716872739314918112243534983931682696927881636448720345394093622904476579243712320772347374338360965150249665935072437073635189766843122322561564241771470220052390739248148539657800012921462649571509627481171784835330155295559197243566391110694212531989990104509951797406602267883991910533467933935868541283958081404580151382316102798202818663e-02)},
                                                                                           {SC_(2.15761280059814453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.07723244020951674736879024409015567278674737427280181790958191485280131080304291237276361807466338094341891840492656978367711727637106416679804070829852978008261215431888758036898775633940482292123134601737585845696200859486998264872046143555878009818620345847733547045237356831681855942609725505498410349738410778577001739079204840229118046714852909334644202624686546361760524439047857738766396297664386891608925813105226195741601654256704110771917895237804372499638318366040599062738662549672075233e+00), SC_(7.43951968096078567450169038225671190608692238403345259369787919244023060889967195591743644105668461468324843850667686453041016494846928923754334711387649093526562013857192333261291836182288952913133602463831698851059598556266445835039363674561701274012167017363825904055449988055678519606988903967580415182626339877700624724471311093486364881415001248271337139615419880940596287705173710534987910042007765327377593821618312773836917297573770845920102032310648380234431643136775836112724418122395944148e-02)},
                                                                                           {SC_(2.24955749511718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.13271614293701721566359811181216844599514203933890310472153469801157718942898125040824868865093076523138824085647633489733751440515813372334536113721345367989120827892830875626989392162079427686322414937731343959752581459822783558484176886389947866708191972913902481439656435178795000816666303153729497641630043980861878770826826639629131704289181832948488360798051269765157501482440590629153105228466160831086484632057682895937375064959461519416204280008586813626946447886299889658545193561852005221e+00), SC_(1.24618414855135508767735862376307617769086138922393052111180412177914174153912067255243690888418634491489827308484772844885839836965633854624454396599801250844003229947321063187141240211496575790700669319652484948080298117038544086335592701606904389673878974576502676541776966818151447737115996064285788233106715666059725339111146196422616638378704568975707438135210898185649605602870819709122240260077954056652903506653003017718439923455933787418857732758136503190158208436673133318059105277181156412e-01)},
                                                                                           {SC_(2.49122142791748046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.32118502516972019933515927336103098702121708295751105812488772605156911772365536897112612268098693177769841152502858397420026350114877465933729535497144281541135352932345376700618048099509451546579901663817269885709441847417283354768740949858195062449544534092668839707066796039624277249009376670869597887289998728613927141880549915613031747586675073174707758681855414360545031137199348021318900766417674431763100410455529404359261909164635053011626589643775277596465694320978005200845792741119134923e+00), SC_(2.78529080205747320956767680429427836727030590567393648909624132802498276501643152789574992070355469843620486053404278844738924735963376178005736900575827387449444173046088740850247064273970170875025909159212947254188496477090539228691270466260135938060766950587422809929080227478886503787218528163783429861153888831422036541043806448191088131552215464050108120064521772377215109248113444727286949161594653754349157193957064235785340374457082073732189833403792835120283596916983131946632783704229344885e-01)},
                                                                                           {SC_(2.98384761810302734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.97051246451251004874297221651138180345200782932645719112022459091787403373578707385755420465767533219748291242620211816297976513805852385613057268665258624866786329786770605380611756547438670824706673187364215059858745216541250405466404493859927324923837716320256664591098922123313952256060988714854976076730317786737382453301647556986241140930376187251202917157565110807687607281314119017889615728891326998507934487463676042713528408643485678529499707961566325046935529271977875583020481735625488347e+00), SC_(6.78293643191154116848661827621536468687319156088981302335984034354394098918670578514850294622645014725444282962568987918377119334481020922962448682614893199281184250591877900628340274535241952010329002672245246619180248418868815716112830856589649442068135409054374901175591316255625024021080534714749685122924217144697864262275559713954426478414234946523413370091910838172379349297462696560662622315457938241067416843354716162216438293199111251634403925999902117392283474387998693379008921611473955473e-01)},
                                                                                           {SC_(3.15761280059814453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.32425050221562870893368319780797394502817705273594528358155653513258895338852991948442481762704658601512028960856664174705178007652730881053103452425905994757107112196568675848578038090243587386920465763852835375409931606980737782869414814138253290988781796906638316383011766510477539256606138027072161714425587703780135013131440824352265816084541543950839110895486794382401092016139119485089882925184402328205831095706309275623235851502520342823708778821762663111690734745040834591026561416904111976e+00), SC_(8.43397622430231011639234819630572061422916186592913090140786438989872494587211928954110495101933895495925703033051008272776118939841084357793355479541145156028164488321529335753503026225753481617089830803055726056893347536445132561599214506486246671154145383768011338983825577386537992051530467922693326426358214921270214143368096532528712261953843791787651479311894578525584043960413997661258765749538291326432123667367635267757124285917821294505087615185252902658005357658301585065221283038946577912e-01)}}};
//#undef SC_


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/gamma_neg.ipp
================================================
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

static const boost::array<boost::array<typename table_type<T>::type, 3>, 37> gamma_neg = {{{SC_(-1.99999923706054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.38759967029644469616560016595808625878165115132471799422204595092834392971724800295938555800538579100535589193822651301525500332693249993444773179507605929981356967101597471714913951503842754010685235605590797063810809157738833492835143542871035345598564520502417261905785944669205716043072390494373490322257034881967960644010974493437512042261352756680026670684484992045553462469360277775982744564680091587106757967345008672070319207656022615608926133979854875552214891487061214012912806431933345947e-14), SC_(-3.05520913463708585014455473559668296916495608452525817143535406097314334283489713736687704477991497991743275712369308074041840740834063476031830765479882984731724892451179592298597321676916458283977757781247413334326383052593649852562076019260959425621178055912343813003433354826966649421695320908213626776555336215272482327946648668250227228003910957432402159538084527454011770143934418513330640797665570919946502860682207966694798401992754387345165102379010439953671041677549784758078058910327404016e+01)},
                                                                                           {SC_(-1.99999847412109375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.69386191462138420561447561038626224725117398415048907272463757295904788742894427112020961644079599036497975583044564125160703746233180407160915929733564532906838635276687410781434210968261046929963453818364947812836593421630201317463294954608503146564867836821695405794382366118304227852763276692341615826262038036617817133464411475558985554970017557556048465581312483241407482874644374899521475569917118996299966475968950890235428728201297431223495619259559376314387803604742172470399752300894010086e-14), SC_(-3.12452154818785908505194845842029487392648620731103347207456198557211206269365761877112968634636619292832400844203780475198066901590319174974134489763347121929467737468999532787760555110439805900327811331337512388862249634034030061740800094556846919604832510099987981577497784616554033244322463034054231121064946938163159446958559684540678853656682058592193991149452718861454400627271395975031543423753488544502623725092389101829686729006797143129176563509552320320921307398500613227697762154498835511e+01)},
                                                                                           {SC_(-1.99999389648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.73558608044741627613413161420894656660058244124013446415180740530561515977792519827786858298784888263741224694297801215204067458618582387642758104711087267937066115855571693609659647797364715279501851796768712301165273782031584039675949865273825182234792801200308929645339256017900697087444360181691659499183064954028133244891427139092630423281589186925295403769367835997750592932795632852612041064703694287432540499377174363368787259684826128422805916075141721701587432972834880653382078107215883569e-15), SC_(-3.26313715687234132229989418098489729669001773722991796067366352789851953766781785355780461541281354995935763718291948133987534108182481755843147601008349939129025054962326064655846767144347454369030917012611615739585725945726636841524124521503115786360787497866575048827515382394272660988449740261822693490509884264357425735902873622582534393835987530480698916877954377750564674591032227255165999311213894591898118964168841058394282558238633558154941771511534821685892908044060408931199226908086343943e+01)},
                                                                                           {SC_(-1.99998855590820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.59289216564568867632702480652600850125829511549703922062266320158421424945544656850160568897182121831684617893475524325850864891292297653913606807975675975259957804287451864251597624292500430910033064835076068306145275196971245113751174694351289752436653598202952240666859873317646170787625375676127677093291213853982061950730506074442529379206213215500763520379868910898060124741913721352876983505985493576120693388339647532467182999015385778276273816304969530871418809352985232191692793886546790925e-15), SC_(-3.32598188995743285208683140963089026685291890297515664542182571526269358171760131460685426882247943951266520599997842598239034632786604956930951026409905645612178203533000816237119225706763979794277386461267856071615237308870990401079821797917297401362178969714385727645391303737983992056296555425202777558250602185647615246086261095852465123851993283123459088339560080939847486920372910054110601643702914129947575674545524987272553810415588957364532956825624756792802124871830851169286718730345076044e+01)},
                                                                                           {SC_(-1.99998550415039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(2.83675532880791262845798274405227695235033818177720368767405099886788298502720505506737073601491437069052878767318115279839599543294975971086469127221299768974331834475248890837021523371368669625126416159480047062370540379650501227130334801934061779388454285066925574880229903013006356948564197074783512804183686582041834740914665869149472027830410017522882553274815242510011488283003509522030509719207159703981174448399923693748764711596103978889294945567655009609890761231551879773894045537823223462e-15), SC_(-3.34961154857329925541635513497050400332662351138593933473844965073376184380974825540094827220199831836256601695304595681236351737563191092937057976123211083578736440989629133694878674815811112503347936133530329173329879480671346713361169216781015612727459739168481942328351139199093627019073630639474288952641525920120137291224330266952104831972482144790213202830122960682344010877454347229224834877045631606844170259520138732358563629137082590241957714093961736983665819824994290029280116463796880875e+01)},
                                                                                           {SC_(-1.99996032714843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.03729552375196358164740823460318662026973060198107914419372487099372162041568590539256488351737294708523272012421089326748220291729909853186126389486113602638037464798917737352578675188372501828555604004282598929675982180626022680345741303618408192247021657568663913526028145211755475939928912712220082787359546364322306724776665922707491021987748181730488961439404139976335171257397123062907938178893465064874123590923110807357554574554643393980484325533171785555026546386123991644766170357635345163e-15), SC_(-3.45021595267521522639899367590843824281454294119481346405490171556502599486260615042880032833991036355745335331680454463826120830401167139969159200447111666769627258035766487364251085432525590308678370165837088127339748301089081077402924517920562849507307652504302081878680928064486340213487200592331694635202674901052848664744765324810044662367009830275349486690000382804760826758049268567991748597475549641935103602495852342532731294563801468186295906896930304103397585963644636392968366808491056441e+01)},
                                                                                           {SC_(-1.99993667602539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(6.50336577581735374471539264511018136719038458490199957731403809327992936679603463170316969907154025316626545553077722739733428346351928958003365080018329659007527067598438140087551150592925781388041096628034671302288112794755460098741102335498879716538819752808264418019802651491433352739354961564539598747849748848117392060902676118393565211519914525721009406620287609767915697521527717887383428629878372324308027451918296365023086525610451863304311902094773107178133171972202267956223000573838315409e-16), SC_(-3.49690416333571289161141805470911904438937037541235254693432508247352990157294679615675082059562226915476749521015549982260241269072669817183369963155899076472793137757186516087976809566510969597392117692900885107874333937105112403653596700299504956687509734290164995796117059729520144653593975744039317354321263755199656661265000435813191510872148915404528536453962323659146004419193306903056331043177656069646402815420399785981092446542074041177156746147470483132801996220688719111352348233653928675e+01)},
                                                                                           {SC_(-1.99989318847656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.86063929638686016500929938628120959904067448411287969196392885063559322770495366475727319122352450102372852768514367925813022215988708482806225319665665321959515984729363297544833258326504479048316249972543983343692720159781733035015676131873586475183939930321798151919207267354975040689004986327902522486381765817411164156193416250909025739418186991916936533719895706334810544577545675978353778516293280116029537817342097826395833368093844428397016931704389447997220570933235918212908707219681481974e-16), SC_(-3.54905286973159947948750002420348464584768884030695883466932404080114006756721010835426851676572950604843679049664249591827700119156571903610687481690319310894243129467281993060943865782714232253365668805576757241352750911798706606877038236096410062796907424004941101804850412041415612888889142024699971409528765711806754586271162013403266475016725698526855443238047897496154800538159403234101936140209280775009365332436270880758824408358848375439036589335337097474868865637374358575703628226606450184e+01)},
                                                                                           {SC_(-1.99969787597656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.37296605913515361209346540202645177501313411989850196817831068108372375868698241625156022771492511583367533337112524747137376096188024626936865639985676068925111095711404844373506733964319467852524083811984784373381226532512835075887454516237755489043135364608775170190200412813090698924043357984126479176586376756159697557036152924657642856869840911463747408646106382428964892168730182978444090514519785431129789029809068157041005541390960262548429023375641881292147792481840988867797477893326322641e-16), SC_(-3.65243880816464760868506252402030899768537444817173639067626077224643410635383857951770206143048299455767678092911959462194958237349255784440281069736923951115195900525720970672659685445864634967211738574969728491522452441232876494313586792230920291557195541800208355430057608697033133628867008170699978894609223080268842824992876510398676587888102517619145854012111900360196844437532665850195258458365957831131118671029406298076244722381387187475421481983813869442681219469329754750417755896370948969e+01)},
                                                                                           {SC_(-1.99950103759765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.36316098020149180336594485727979876737128531049589362065952907061128596733355987994139338062282819185131032168871304103838446925611937887286709237542280460889870514607319873770051359260602656881815374243469950002986395095763327646299989180128548271795696996616366271013899283537815894308994710220989138890689498075406940349870190603536266322693466386629525658624153938658038587233321888072480206909717393660016512978949214008003450101524012340915085779176171569261451020905517736412363755791242890699e-17), SC_(-3.70201101175872571127612018877735829289966222633530480008790833909574728125746598013668396826018331577307207372571982536533375670475766159667463037138088770336085182557008789072830655187964737898150055547782089485266963996311464860472366058905616323822767606450565779266186426287478141325974133538136797321588449900712817576885367547610257758543776619302254787853687553904258173810544999430721010167498949352803124945816205122693480879826249820387852287044996010468333861760347726199104230160743408478e+01)},
                                                                                           {SC_(-1.99907150268554687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.55339584071212341970474422785353660335901128887742233122439875862920707194709937014271143578039223357371625602683087493114976678579159611028025254056758984409396564016410385502091566184046478439774591236752200564488173276514562388115552233268886746457616005677169443947968693409313673715975716502229752528058290122345523747766183736578870392873680550485661565438774444289782054502237465714943954936280012187025428899218172715554379144501923864512768311526035511226614602973765215151761547340902268370e-17), SC_(-3.76280732876900368843995872688914724614766154503743721290613036628252140382589938365197204680237191190001881516350171816957619447557143555943272967301450033805129891032664320382026387520989511492279683113722987258147580642668261454744731897953576935131567781599631138897409307262073904306157094335890447418596502741921164480836998465436241085557109219685455546928104579025472976271631871646590293559539692930387307698947995638166323978942065107209641441448364860473477127717748096251490511457991615810e+01)},
                                                                                           {SC_(-1.99758300781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(1.83112246049503080122237146768131561239165952861593764069083980656816133071712600960126755835070573344294099663480500749234277531625134201523458774258146034706967637818193536687702316522518109967144083177724938390732877090353677111923631003890839246683408350813534760772908633353691555931803914631321008476959514080214886540068969482875815279211161969636081606072812897989696761978145941506005215530706064321986891160384968334289256503133484325711859503334368481471089648442036399714132070514073271488e-17), SC_(-3.85390174356869999540631662416944424563343017686448585510542768258924935140650334849245812809797936619220558584447129061161041883006839073990822052685785409771053711522282916161209407932769517709141272339612700282656114462228083301569573087217876966524822852660405655108177399957462906307133994832931312250720150198781043931995519887737824647670514087352012661228211226654083530423287061165013493196255071502175665757791125308633317577890200630453290697760723342257941341060738612939219142306627366078e+01)},
                                                                                           {SC_(-1.99377288818359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(8.01693535144367134273026553716785218082557806877438069452199116781270088995242302917025486913792901625954351735018669523044519100879209643963924846343671760259128187972279606679894790449933954614431176061448363551333157736564270069025829703781191430082548068512059881337098970687760711178849491103179947661198372103494820622922005592888312013696994032759249871346260932504701246018860440581729582268067100718234234048848838644129619402845961461869654578671179269984398862736189203756380345464201767839e-18), SC_(-3.93649754507982034381210646062863889826566407396586975519455023065492015354853815571908666749309967422373602978936644556653681367138699578243570034459145777728357737438098138773965351146277352775387753534175672639907881178942069832564535372795578198481177342329606823641171271987457158600793352179440621485289920354571261729043734932851097530391769255629080894457549056652983860155757537030310811891415672594623748985942179579702560080484257706177836201715188778902120252813872548170570887000653852548e+01)},
                                                                                           {SC_(-1.98776550292968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.98159560642572769471679705760108836819553955845800653128274010665601005987113492561900144703140593263012810898767831966112217178821909223692669428149071863352847858293401245228236222196431038944392838651399436151035061048674526100274807374332221465652597940640163828271896168262085854120463603484811367456030167748780453221643535013315782836700239386693513547142120678068170315881364584464800999707226761493522115272499655210215888713274077764088440307774404249258692132112421830220308351144796995272e-18), SC_(-3.98407814312775750632655948505759119176224779884004606328890064673378552554757525193686835579511255181447342618200748378512699382992907049291693727164093761074261774488881410349964002706401261019405532796610313343889643193242858329740583589555489079186864603705090245097892687910273553815861117241007098888369393865117288758351588015571301443677764852078943272158047284630193828321764955315198313162218460948366246394905166119336122793138255072000587630491211601554256892640021898219920359539490157396e+01)},
                                                                                           {SC_(-1.97504425048828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(3.88017517014452933045956819481950900807442551001110048857097121388844647225043963352097526055371187772211576037491223350763235789821957483113201097090187557142479511185822625644332601233189362904562543687030267056348820314236473401764915276126764508190793356448802422301055179132213830892895126747969022229207179654266700452361663827823698960959744143211716265805526259617770857043895851450506769945022455533546585246809998963177901672080828114457141550881049970982949788268111495485160913989116636720e-18), SC_(-4.00906513743322665419511458996323201349225723259180576722869519970546509690314650847321858066902702770000558036920171548448588183887422509784019051198560190291912395148953616433361398321514302827291262158546114298443380391432156907120792226017162472101359939072979047805376875854177883215361737326229238270663527682112094510414417814556366321261289112288963812063166466882072152697607360930495102462227364399384308239732395749233273524462963918739611835992415189220703065178811224998580501294593845387e+01)},
                                                                                           {SC_(-1.95087814331054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(5.66230758491304665147102795245257419168217425592069799711487549608018624231364246953680468305752531986636297376301769325469502322471851593437159783231444403919853087066138399456497488977163427187775150730353446247259557640310543636216009045448281263625535378734382579698241218759759321642473879630568556532741823005839076245488105531230805809097403229237856626425257554186031699591598706644445689476274304227074824189207132578864764869307517588437106652581485851204451182521307598680869063344876248827e-18), SC_(-3.97127001642503306431018368868510822813077871040576980406279757790165788671386554429152492910562270875591570029751557166531867479172532187313780163974363901193188247687564696358109292582669997918861573399693339019987764495770565847958538474202672366615977739249614693866637380917451450693278590366704600806358477108821780498846825219688755857579333418703501660820620185048127256366395207162761266299559089783037567994540506596565789573094137658844891091983842233401459345063120752104143501754444023158e+01)},
                                                                                           {SC_(-1.90161590576171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+01), SC_(4.85094648700543313219398847352478326318965185964013459447512351308953428156330384712645652203197410950029142959888065828019087576686061648451263295485805361576784764261272652852562003088603485865016423910075013225407371024651921073341767205327719612880437487232429260544546978675694647337189003765337117000483128461838798268376650578166160655894616540371072755498153305326101649796044091099125863886705708174964952292493207651779512080603498273845117371411314850322040626713326460161210144724561957487e-16), SC_(-3.52621876500351226734458234233118143948269880088724578239971352285058450102495101628806600063576867220760570143096935930387888839883871325947380486391444764415658337923993597824917478464190608223034931307344415287605970181326241463624079727938746083914284903273883746077127195587651357194104990693139512263661207224321519387943330426769205283325696095926588091655231810133980594401096500720257700076361998811811146688344672735928725322254167146864192016693678802172165337148496655031068154755053397560e+01)},
                                                                                           {SC_(-1.99999856948852539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(3.49525794726840724332770531742533210760949030939150064838849016603929268240158079420646351018919870494992130816864538525681906800880110432809969608373357971562835031734463223617852856504288206717678633312929264358647621602816062958926953223434105587532619209946310434142604470287978627247076447003701407698280595109919257213101058520954002976857547124960200649769434010243812418865367203197435757976365462214320598427713582886554278342144196536549039933080774089051881208606675782058795172014506845303e+05), SC_(1.27643326425873384881093285872508179452498455083997386123791846098069683786954557724381755242107237737456425334403752138877081887262366450587882895441315426542862717610214957783062806011631463216155577579618174650591505415429230334239897241979183736600447839459322334682781809803931591656670137078437915218993972869573877667878499135915127684776967501369254905929674054441263057139938370034060614992097975121503535832913846498802397038787145978975145932851219785278838191467481268690078676805417976721e+01)},
                                                                                           {SC_(-1.99999809265136718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.62144461393954005576677083959081224922682116942680784382663786554477354091505652256089930582387034905082987123783686147384272776233357697778646519293202177088216260442953567427598742176128969392234701519966700913406593927278601397437655998843292257685500339055591109815077998948276221540695712670281137196054397511966305435012680590384519239723484669607888029902896624532963675465522555566371306498097745971066287647001776895938202191310694024225146378391339368362904975412072348405920930457524036247e+05), SC_(1.24766510101557213545766721136410453138493641946701292802442833827425797129904704540382723544412893379170946550873814658598452156889382215401141401793226256683432769439816435341614070628592950211106046360463620980685141352456520751056501335577860424890706166122786273183690252206928481409437290040107105400612762800109051739183939915165333256045614229952868762702587943061762211192907487015355715364832639902186783136127312606318416615322477883301125855361137217733810005631030743897129203961853211027e+01)},
                                                                                           {SC_(-1.99999284744262695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(6.99055280655334542175930436122069761290133983548532006796388549146348861014908087320598296301346411160370998401799938159888581866029751709088497185296824652466348119973211092989927709171600849203078010491110192497753213703526766239773066725748253740735453992439234492136465118555665575916337934823367953504368600730298086700097339519387123179747593007744532120692065230765100349251170948099553510882642363863764989129016733554206631919332143211983726526321979280034119468474152360465290561460889421071e+04), SC_(1.11549000104386469310318581217378978404108798637142623264790614654551465860165613766525338763896231086889849040052677873804922746038702465326123925324974167767546597691474395687144765863502639894309407960627926456751853434942337376342500635127429736502870706249417725219963966572260543383329779151091348926626121712222870254056682569389363695658167304526644142491795103808689641219761812209725779841832246666770063334779395069189440602891823050244930124977284293529931332541390700588598213343893338842e+01)},
                                                                                           {SC_(-1.99998617172241210937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(3.61582545085677523556564265061789275558420085423109560412225366655176897025562182547560897903508146991920512133842894068247188574004266983236166092320549776589666149301791876532193556310533756455744076037828943414924970515395338284159141116848403267093343282623079098773385537741681300833604756206687517267176183543188779918320955585390478066609031999902486182302841138297064961474034093076746888050514577947727440163188133886399891285573031624715880708476160240564600719219019397480953999125929120509e+04), SC_(1.04956605420071580634032606781744741643474075940276116906157128451763874787833226406335746586932167180819392693617547623661699198379679879472241104399115810710557215037397886139363442663864810170688720344252581932587162490590864881208800226527734817497087958248051970771681187067072798822926758914302554781620566550310313780069405270970525254314192982629980655282219306257104525199495277176758155346742765033720532454849549319731995469240561404515682193542797042174160374339788351958917688789360771947e+01)},
                                                                                           {SC_(-1.99998283386230468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.91275725193569561590016689655794168420228620966571368298273980157450738791800185120799393755360245105069027560472999937324445108650485939272745440145190606819951995859593113790682980972371233653642538147083802660603411711601177697879434359991996803571036009274557243778779042479466989793965641132673409423494548458675468354610730403558385953326702507473607969684599828544980277541551562751143225934516347787042819331835666113193607653180381361180597983599271660349253323506245247421653025229085236314e+04), SC_(1.02794405138122896402314881940604738282900129600289077017952090146533317079696982995762083502539714627487177044864707417428225158512882028105664966645423607544687065459887843793363464574058076111354667801476050818320352369918049033162304956069323775352811046342871920615690769829844887402721730480175673536482624050186765972164860620055019128295545319689415291206842391403816794856743485445184092820235173998625164635470678238711809067512302214434889317749801451335300035481668507468143889828201299775e+01)},
                                                                                           {SC_(-1.99993991851806640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.32249319447518855598944610753617854039292256296476311990145714296558036998458656918821506365009251364959904572811137153770442631195626341569236149478584546737152245266768341432912467447854655346609375771648779530400158279627455200777370366845760135645185689952161850401675559394594343764985201521321411485981589624799291023082308588711466604815036184548423850387050145798777986608977987885716993412252737556898589674064937119199668191811649392150573408930676461291127997714867381873466120503286044037e+03), SC_(9.02671715172282446918804818996023162518571481778646046484772732956317384828370353304559181558297863222891421673682259823646868763561090354017312583652702865410886724466141311870458212107420735691179628014825875988413082971512446430075718596153929353099382259317366492027748573322899645753821024940590770562279794986846425203365367429895656694890464472785718353612966631247824841684093739368884029310135508998603813321714361278534324740132357271577747825991014287136486456695451934992266661402277777663e+00)},
                                                                                           {SC_(-1.99988317489624023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(4.28036354241400130058705381882725999046241639116013619551075255606826877452636644604651341982568405913848090528825454016811852979966987414441609765953883845437810285948143114055346163368138808620153511140821913074294970274338981459461780195745846293255296962943905772921194262962996046024179304101202489373713805917724003109833450915814218273799360011692079574105261349340456724888786747274634828459793848677285899074058389948313476620716037763888535835434918698233782953812196563303570201525502018082e+03), SC_(8.36179322478501597977292274589283139518886305065425844964868164614874617907207649168636165810357009938065944927926474292133794500748914040902098872429767836976820558374914415660195744428422875053172805157494295734822572067475458679220611073040292089429138135583549225532487580813118021701211972393905414957119675165616825504727370662519623020660471291479495592691629449894598588052845768596631451491242905371300688736178966934044620811224456695685298401168269691120168797520928268746534849598073563811e+00)},
                                                                                           {SC_(-1.99985122680664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(3.36128204434740291283107770354586378346283439595679593594949210524489234356178902618762378562267535666175904129785120747651662911412143665104975016955458793784393118196269263025523335076889406349897444787005159277370437761470788599663401819981999218853086656741435415793526095051182679856992784435195588655487630156922150016378044927741531191682364126255096178922384753868717405690697258379485738398999670904341069842876887589302579704145040802034099243873580319117957884661068510923385025291814370594e+03), SC_(8.12007774099911224077674031582939293407072268410283120160248139177467352236787950741709327449661204101627452104848400096463204118967596688892445723941631704314577678297562783209606807172475052038356749473705814057932311825150329963969840788980156891988724759699083494912402524105501158989635979848925608920814051135828808581751025198832642962437007614912625066655215144555621135720046502168379860877317008493966281141249674566270190908231807924116067930262174250983880414789548679270954647569186496750e+00)},
                                                                                           {SC_(-1.99960184097290039062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.25624140592261575267278271940484289518480075580483297157581531914241110338376984136137853209559376401394082718883689331623249516193255900664815163812238640876028719844395892650957249605235281921292365169610839189461985220288383617439943753120747512365782707225814583627987391209031475228703173867481353781649110067039019107568342750599488417067674630339554122732514191362032832650736326962969325600194583793133488118555116227453949453195477751278597776714609414190745942394922450934781953398450326125e+03), SC_(7.13587953072736147036355816528887639826802159553598947589664831543550103506708350908036736344560077734555208589346657689427289222767237531129789832460866479029748071799264780934688947071994838969349226996016594353993409065278399027492505780692124331908601902223025677408337501345388598227277841303952412480274312085114055529429662028907729170169955023222056216936933071019581969634258689455594667577889504726170140818995305538107515921870405332546135662650561723462419727826606351956874268372077877037e+00)},
                                                                                           {SC_(-1.99936151504516601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(7.83565799289483280163155191361710148301806473769761421399736971707242043580137349085685963832290398889029922835758280315794977396758526824072817586429369366819702994429539223254414178932724794214207553405219491444239189835949198854269913836625506190203997818880282941522759814620371563416612371995530706016140699823029408579568047443293909880799984307203726160291494410696322200124464725600048565966565754337103788411893096012339982460843838115831744031219115508893136183317751243764313795428254149897e+02), SC_(6.66385503949446161490964353057404700759932498170314993855319685951519772420415762755612421329517512507401754140021735737698406265001504947108209652508027151273513300798240944398325824766620559433751144975606238110713670040924420573411292751049952618117581043972629261655204241979398389497786642517477127879747879911916212390205737871315629451177077435383637605445069483064166519416309498119797004666497875239844370204211268529236996878715800888282012049095445736065307218750923128759227529173184642168e+00)},
                                                                                           {SC_(-1.99892854690551757812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(4.67118382295204743401937254501573767480943199671434360254938823190850915833403801934586371844867967744091651336925376675907730238237282784349607890778234013193475547292318213052077228166933141756756427422908924797442949317616023112830726410939123632261991571101547351409931185486745127483145748880375700113736466217793925966792127947533799373560028173512435035840471258751889735357702600083584858668192495922189397869660685532274994141154462611707405745124099969669821149028958221777027109971294922745e+02), SC_(6.14658272082320896011483535569679739810604213770036400800091715689086571577772544734146180493197362913239895242960038327988879986011628251613934969785754160387923144866290327766088039955675828649148829131779854684483641828507579815539643578858903851037091320577884007201080127451064224748179877998328836094513147205379315186158274591836586471728654183660074243464409077906266941964012223839770573446137342312495426534839819825875176576557071861399281398737582929236303062411601392244029488439456818833e+00)},
                                                                                           {SC_(-1.99697828292846679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.65933062799030026499031857286439573057825979180067481887402769956172122065685585045807000188347841407446707061639560625027426711596987076073907063407152889853367716469339236825757603750989741418798526629185714446971058613215430702718134769670033959677353759278619689100985901866594875380700877023837639752859867845590036857634241490796985154991724793857881301211565140606814321931538215083761281490341050122521686748462324199594599613474854498378317283969209955088313651411879706436345504630018044507e+02), SC_(5.11158447088456327285300991228539833660960693481988131847235078680072149045886373239208411487942182624090802533750571463998951400823698957276812111506615598974444394407002484070136921088302169422280429906757027574361223644628984594464458979582031307353205737054490228551750014379346366992651980878945818669148232194215084018810484639556344683423385036117630305071212095451395510462976995162898640449446072737496747538413155936339856232998187919840618112609672401660774998188565640799563785241420846260e+00)},
                                                                                           {SC_(-1.99500608444213867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00587924761262775169663795112260658037813947243467846497585581476114421955317726749299731893226976937786324525582979731451343618075158212147675841143631582133466673077443893912530929063915059519648906249109279163465361129828794671469604941649949503326733151583929465567177496741612440164389015649600945687108836677050341799638872055874936125676513217903248696451648905457756723999758260862431168673835335778352509374833228745218167089341287526408377545911888789543737719512886725946916517409332708090e+02), SC_(4.61103221826699148685639421692714907149023874354715583149540785712901180479986015308857435216493645251391475968763231392296253595822154704197625561993779495939587815270692703284985173572898009432860996066960256782260922905962033845140459253829997088395227562256155357408928027795042056851131597625916921613972564329947415717361332777224365352001281348486892227555044666198023818913069027420599174805373709297093151673659228558391608953421210854147088652563286506485526491116085429363408683935355806458e+00)},
                                                                                           {SC_(-1.99071598052978515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(5.43261342855207683321471367667634298993130164657395652940698347263805738244409299534274904253386808889723658245910828689572671872488701248351438198079823607168177338643148221671730425380866440723755055782205029208883973464213226966927488613575887327563514670858991324649773947981306614998043425095910306427769091089568418431383074642514512607267342885724246706884212512928162866598488111182269355360471107723126753986315318461572934230251910391906053447975979536562592026495313363254270083774897227910e+01), SC_(3.99500540554754084783116320755550040070795432896218051460244050016027307080516706025452328930707372122940539374531280006067457432152053795595498975958414099013978454227666236747637245745994127339007567514632056680017225765921602312064993984668132176623992913227625767485150934657465772535770444759472966423694768064411036564532278372406920442580119572879366391149796455805306682150702485604169317571816315397840571826029052197640137590412415034348881647261441103457141167021267904530044433362633611162e+00)},
                                                                                           {SC_(-1.97583007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.11713355568508717186749430619455765829944389572953926593387890142986425079118903228956466586034785656323975993009534744183681179572261067731704233666473752088214892713750726737578557299700556027748703489229191099881534356383060180175679305951211955138626254129859879913269047628471637484062282241878647186202424197930824531409890981709923645213793111935481046064792058678430210190296837963826587771101718103456760424093803975964255040042094700470767798212710711395227541566115973718114167151353452363e+01), SC_(3.05264817039591626862655099057939465179986667409005989715731859835690744704141548649122835851318344963701626601849114047531501048253619307346542776757184996977322377721381903566522822193104272396856042012430952816660726199339620731273536703263596123187839602228525400866664014760527003573811641632152035485360466326099946891663139486579902585522603531845013464113857010883947455000566195208734139820203755841940384563874720751791136755270346532812155352274399187564800218881502549907841988304120114349e+00)},
                                                                                           {SC_(-1.93772268295288085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.55140154989742563031795592761223740222933037369091117707548701719417324436043594149148839366125866753441846926747757961691743831816447266296249525417689639205635396869873026915817137619485725479365301425493165818599553310689074177762635654066147134250624424695555873412452228602918989020578249224991765324833399206904878229623160267226643725994540540538379700800744103037352863243040436490709462020440501244109441318942868408148457761252155085028567393589233216009163593304138395619387918531501329911e+00), SC_(2.14609519347921503734928390248919269700812373570607862587046702400866080506820226775324131591047922770564148385412775051426850391054709262710094222461322018730704436853657999982086234982157335335068267734765087205570600956372991002414990208544840151216306267557887490905482009859533035497930769422922408290206507773022866238259045914192630771754449840812003788665755318698278462898424482576176640522119386371054173657148616621611488616395440426423349037282231697273048104290956235560812518904511850199e+00)},
                                                                                           {SC_(-1.87765598297119140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(4.67583771863249529055109655612510730374992827217946078088186977344497390855781646691754105222138655257893095020731116355227986362966515780707698772485437094967536468214023834308178727836619801089569663047174119105167664428805441275112046007267349102582601522528843355129981789218535438305077043911372259440397637216382121093112527069891468207241109974792875017384778909045872929763491293848256218126413836287410323590383274638262206213949333260073094188650218883981854689988805258114662583813833446691e+00), SC_(1.54240833783916950711674299830094269420860989032914842380787685725906602802135415488922671751862561471742098321629469719633973418191421678612807986946832211852615654801599794257019902991588352013561017386475372562025192264722784055215705770996735617454145764311884033826035333514369114597097399498198288990985692089872458755227609611715846210608700162484829844243005353297597437263446897165946773288544966416662536713250022257470084584378142797370192831228494237130188132449079088561127554388813866227e+00)},
                                                                                           {SC_(-1.75044250488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.76521531383342777536096826241083426988946791885237328153143902257712477146935957758546160579910756476446412711524400835410428680030114368815367047441732692355740342646344258723284625720868992172797296604448481954562244959416221336611138303608751397924213759395368298472950576084573813186054133277598316804445815058268350200019426078774535372726241320430678110500166163408536083013133803069777977592233712273587393272238129354441223170323562228826009632634564393605136023563596897017566916161568373558e+00), SC_(1.01711850312999107612643679883702069406371231132721256058245671646048087783154950748443714431866884713764648019078645174991892339907448517840206497874509210723364252694864538940590777681188468426542254545822716725767597072139557232884783690928384523253232018333698447015173227162147433007643510931963840890536915692608769823429517486692530853117073535699778387722764300165446366925590821938117578815481931433033378039640398390812437572623525032416583644099198377439870409387433496490925947152048515148e+00)},
                                                                                           {SC_(-1.50877809524536132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(2.34957878792805622220208627908796604209022753669777984013397021521718672847364045384997126602247009262704209508441637059874646258845906595804811471172246490386367479387582395386750422304786391974080908751447734295954413870878215699818713260911166524456609372522274214548306662348939976667197188998712694834713732786481840430018084860503372392470155335279086088777016531440557532208724574181694106222640898095734633283023280509442132397047312680409203121903723018562056868440028789425492262012646158458e+00), SC_(8.54236072911255595134717828491113927004144370403410251865930440928741075566141261658507132665592617412770458712290479329578412453713534343230061302053867333849975384386984877754318709543893927568366266399879554366360287159464342728205089795418872839137202008820491949662117655143235966641935511312425859340479786978199551078742416307594623543083605438644209653394275575880139888266125377643794668219915008503333812637400462494313054948847229967539105158899413449126349909264243755409897303557758406009e-01)},
                                                                                           {SC_(-1.01615285873413085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(6.15084416829118046468452991400544498224185271615854347433260694549800043224355246574675466376373859960529333306270890955207636581369067853640476864447701152058770453365710243687329890852220965032159894431838134171173269029343559984826337258962443251204686313483188492817659715061679938111171826115917411885607899751127343441029695150225474485591386587193176839356863531438827218409852706526496642971237672335817246193209499962435510622872455796720812217398126074771344905297363577965377107684959317397e+01), SC_(4.11917442852952711543741507530337656290736016465506639741742101611014731373074855727222493539896474697110498858504643770565949929474195415135105179617700802945752394424643368615173443852328593935472829240359653696116395379824510508393155403134258111311673599669939241747207061523079182632547737365431783702760141194142731371171480274286029170854076168498596924110170468837240766315428782766656743993971526078852137464960957958084824518999844115962290565276220206898969535823972967013864671556923956906e+00)}}};
//#undef SC_


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/readme.txt
================================================
These tests are designed to test Boost.Math's code at really rather high precision - 500 decimal digits or so.

As such they use their own test data, and take rather a long time to run.

//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/test_gamma.cpp
================================================
//  (C) Copyright John Maddock 2006, 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include "test_gamma.hpp"
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPF
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                                          // compiler
       ".*",                                          // stdlib
       ".*",                                          // platform
       ".*",                                          // test type(s)
       ".*near 1.*",                                  // test data group
       ".*lgamma.*", 100000000000LL, 100000000000LL); // test function
   add_expected_result(
       ".*",                          // compiler
       ".*",                          // stdlib
       ".*",                          // platform
       ".*",                          // test type(s)
       ".*near 0.*",                  // test data group
       ".*lgamma.*", 300000, 100000); // test function
   add_expected_result(
       ".*",                 // compiler
       ".*",                 // stdlib
       ".*",                 // platform
       ".*",                 // test type(s)
       ".*",                 // test data group
       ".*", 110000, 50000); // test function

   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

#ifndef TEST_PRECISION
#define TEST_PRECISION 450
#endif

BOOST_AUTO_TEST_CASE(test_main)
{
   expected_results();
   BOOST_MATH_CONTROL_FP;

#ifdef TEST_MPFR
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<TEST_PRECISION> > mp_type;
   const char*                                                                            name = "number<mpfr_float_backend<" BOOST_STRINGIZE(TEST_PRECISION) "> >";
#endif
#ifdef TEST_MPF
   typedef boost::multiprecision::number<boost::multiprecision::gmp_float<TEST_PRECISION> > mp_type;
   const char*                                                                              name = "number<gmp_float<" BOOST_STRINGIZE(TEST_PRECISION) "> >";
#endif
#ifdef TEST_CPP_BIN_FLOAT
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<TEST_PRECISION> > mp_type;
   const char*                                                                                  name = "number<cpp_bin_float<" BOOST_STRINGIZE(TEST_PRECISION) "> >";
#endif
#ifdef TEST_CPP_DEC_FLOAT
   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<TEST_PRECISION> > mp_type;
   const char*                                                                                  name = "number<cpp_dec_float<" BOOST_STRINGIZE(TEST_PRECISION) "> >";
#endif

   test_gamma(mp_type(0), name);
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/high_prec/test_gamma.hpp
================================================
// Copyright John Maddock 2006.
// Copyright Paul A. Bristow 2007, 2009
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

#include <boost/math/special_functions/gamma.hpp>
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <boost/math/tools/stats.hpp>
#include <boost/math/tools/test.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/array.hpp>
#include "libs/math/test/functor.hpp"

#include "libs/math/test/handle_test_result.hpp"
#include "../table_type.hpp"

#ifndef SC_
#define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L))
#endif

template <class Real, class T>
void do_test_gamma(const T& data, const char* type_name, const char* test_name)
{
   typedef typename T::value_type row_type;
   typedef Real                   value_type;

   typedef value_type (*pg)(value_type);
#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
   pg funcp = boost::math::tgamma<value_type>;
#else
   pg funcp = boost::math::tgamma;
#endif

   boost::math::tools::test_result<value_type> result;

   std::cout << "Testing " << test_name << " with type " << type_name
             << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";

   //
   // test tgamma against data:
   //
   result = boost::math::tools::test_hetero<Real>(
       data,
       bind_func<Real>(funcp, 0),
       extract_result<Real>(1));
   handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::tgamma", test_name);

   //
   // test lgamma against data:
   //
#if defined(BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS)
   funcp = boost::math::lgamma<value_type>;
#else
   funcp    = boost::math::lgamma;
#endif
   result = boost::math::tools::test_hetero<Real>(
       data,
       bind_func<Real>(funcp, 0),
       extract_result<Real>(2));
   handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::lgamma", test_name);

   std::cout << std::endl;
}

template <class T>
void test_gamma(T, const char* name)
{
#include "gamma.ipp"

   do_test_gamma<T>(gamma, name, "random values");

#include "gamma_1_2.ipp"

   do_test_gamma<T>(gamma_1_2, name, "Values near 1 and 2");

#include "gamma_0.ipp"

   do_test_gamma<T>(gamma_0, name, "Values near 0");

#include "gamma_neg.ipp"

   do_test_gamma<T>(gamma_neg, name, "Negative arguments");
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/instances/Jamfile.v2
================================================
# copyright John Maddock 2013
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt.

import modules ;
import path ;

local ntl-path = [ modules.peek : NTL_PATH ] ;
local gmp_path = [ modules.peek : GMP_PATH ] ;
local mpfr_path = [ modules.peek : MPFR_PATH ] ;
local mpfi_path = [ modules.peek : MPFI_PATH ] ;
local tommath_path = [ modules.peek : TOMMATH_PATH ] ;

project : requirements
   <include>$(gmp_path)
   <include>$(gmp_path)/mpfr
   <include>$(gmp_path)/gmpfrxx
   <include>$(mpfr_path)
   <include>$(mpfi_path)
   <include>$(mpfi_path)/src
   <include>$(tommath_path)
   <include>../../..
   # We set these to make it easier to set up and test GMP and MPFR under Win32:
   #<toolset>msvc:<runtime-link>static
   #<toolset>msvc:<link>static
   #<toolset>msvc:<warnings>all
   #<toolset>intel-win:<runtime-link>static
   #<toolset>intel-win:<link>static
   # Speed up compiles:
   #<toolset>msvc:<debug-symbols>off
   #<toolset>intel:<debug-symbols>off
   <toolset>gcc:<cxxflags>-Wall
   <toolset>gcc:<cxxflags>-Wextra
   <toolset>intel:<define>SLOW_COMPILER
   <define>BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
   ;

lib gmp : : <search>$(gmp_path) ;
lib mpfr : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug ;
lib mpfi : : <search>$(gmp_path) <search>$(mpfr_path) <search>$(mpfr_path)/build.vc10/lib/Win32/Debug <search>$(mpfi_path) <search>$(mpfi_path)/src ;
lib quadmath ;

rule generate_objs ( suffix : variant_count : build_opts * )
{
   local result ;
   switch $(variant_count)
   {
   case "1" : variant_list = 1 ;
   case "2" : variant_list = 1 2 ;
   case "3" : variant_list = 1 2 3 ;
   case "4" : variant_list = 1 2 3 4 ;
   case "5" : variant_list = 1 2 3 4 5 ;
   case "6" : variant_list = 1 2 3 4 5 6 ;
   }

   for group_id in 1 2 3 4 5 6 7 8 9 10
   {
      for variant_id in $(variant_list)
      {
         name = "test_instances$(suffix)_$(group_id)_$(variant_id)" ;
         obj $(name) : instances.cpp : release <define>BOOST_MATH_TEST_TYPE=test_type_$(variant_id) <define>TEST_GROUP_$(group_id) $(build_opts) ;
         result += $(name) ;
      }
   }
   return $(result) ;
}

lib test_instances_mpf : [ generate_objs "_mpf" : 5 : <define>TEST_MPF_50 ] : [ check-target-builds ../../../config//has_gmp : : <build>no ] ;
lib test_instances_mpfr : [ generate_objs "_mpfr" : 4 : <define>TEST_MPFR_50 ] : [ check-target-builds ../../../config//has_mpfr : : <build>no ] ;
lib test_instances_cpp_dec_float : [ generate_objs "_cpp_dec_float" : 3 : <define>TEST_CPP_DEC_FLOAT ] : ;
lib test_instances_cpp_bin_float : [ generate_objs "_cpp_bin_float" : 1 : <define>TEST_CPP_BIN_FLOAT ] : ;
lib test_instances_float128 : [ generate_objs "_float128" : 1 : <define>TEST_FLOAT128 ] : [ check-target-builds ../../../config//has_float128 : : <build>no ] ;
lib test_instances_intel_quad : [ generate_objs "_intel_quad" : 1 : <define>TEST_FLOAT128 <cxxflags>-Qoption,cpp,--extended_float_type ] : [ check-target-builds ../../../config//has_intel_quad : <cxxflags>-Qoption,cpp,--extended_float_type : <build>no ] ;

explicit test_instances_mpf ;
explicit test_instances_mpfr ;
explicit test_instances_cpp_dec_float ;
explicit test_instances_cpp_bin_float ;
explicit test_instances_float128 ;
explicit test_instances_intel_quad ;



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/instances/instances.cpp
================================================
// Copyright John Maddock 2013.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error

#include "../setup.hpp"
#include <boost/math/special_functions.hpp>

//#define BOOST_MATH_TEST_TYPE double
//#define TEST_GROUP_1
#include "../../../../math/test/test_instances/test_instances.hpp"


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/log1p_expm1_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
//#include <boost/math/special_functions/log1p.hpp>
//#include <boost/math/special_functions/expm1.hpp>
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <boost/math/special_functions/math_fwd.hpp>

#include "table_type.hpp"

#include "libs/math/test/log1p_expm1_test.hpp"

//
// DESCRIPTION:
// ~~~~~~~~~~~~
//
// This file tests the functions log1p and expm1.  The accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
// is too tight for most platforms.  In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable.  Either way please
// report the results to the Boost mailing list.  Acceptable rates of
// error are marked up below as a series of regular expressions that
// identify the compiler/stdlib/platform/data-type/test-data/test-function
// along with the maximum expected peek and RMS mean errors for that
// test.
//

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //

   //
   // Catch all cases come last:
   //
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*gmp_float<18>.*", // test type(s)
       ".*",                // test data group
       ".*",                // test function
       500,                 // Max Peek error
       100);                // Max mean error
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*",                         // test function
       500,                          // Max Peek error
       100);                         // Max mean error
   add_expected_result(
       ".*", // compiler
       ".*", // stdlib
       ".*", // platform
       ".*", // test type(s)
       ".*", // test data group
       ".*", // test function
       8,    // Max Peek error
       5);   // Max mean error

   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/powm1_sqrtp1m1_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <boost/math/special_functions/math_fwd.hpp>

#include "table_type.hpp"

#include "libs/math/test/powm1_sqrtp1m1_test.hpp"

//
// DESCRIPTION:
// ~~~~~~~~~~~~
//
// This file tests the functions log1p and expm1.  The accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
// is too tight for most platforms.  In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable.  Either way please
// report the results to the Boost mailing list.  Acceptable rates of
// error are marked up below as a series of regular expressions that
// identify the compiler/stdlib/platform/data-type/test-data/test-function
// along with the maximum expected peek and RMS mean errors for that
// test.
//

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //

   //
   // Catch all cases come last:
   //
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*",                         // test function
       300,                          // Max Peek error
       50);                          // Max mean error
   add_expected_result(
       ".*", // compiler
       ".*", // stdlib
       ".*", // platform
       ".*", // test type(s)
       ".*", // test data group
       ".*", // test function
       15,   // Max Peek error
       5);   // Max mean error

   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_powm1_sqrtp1m1(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // We test two different precisions:
   // 18 decimal digits triggers Boost.Math's 64-bit long double support.
   // 30 decimal digits triggers Boost.Math's 128-bit long double support.
   // 35 decimal digits triggers true arbitrary precision support.
   //
   ALL_SMALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/readme.txt
================================================
These tests verify that the multiprecision types can interoperate with Boost.Math.

We use Boost.Math's own test data for these and test at various precisions which trigger
different code inside the Math lib.  We don't test at very high precision here as
Boost.Math's test data doesn't go much beyond 35 digits (for good reason, some compilers
choke when attempting to parse higher precision numbers as double's).


//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/setup.hpp
================================================
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_MATH_SETUP_HPP
#define BOOST_MP_MATH_SETUP_HPP

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#undef BOOST_MATH_SMALL_CONSTANT
#define BOOST_MATH_SMALL_CONSTANT(x) x

#if !defined(TEST_MPF_50) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#define MPF_TESTS /*test(number<gmp_float<18> >(), "number<gmp_float<18> >");*/ \
   mpf_float::default_precision(20);                                            \
   test(mpf_float(), "number<gmp_float<0> > (20 digit precision)");             \
   mpf_float::default_precision(35);                                            \
   test(mpf_float(), "number<gmp_float<0> > (35 digit precision)");             \
   test(number<gmp_float<30> >(), "number<gmp_float<30> >");                    \
   test(number<gmp_float<35> >(), "number<gmp_float<35> >");                    \
   /* there should be at least one test with expression templates off: */       \
   test(number<gmp_float<35>, et_off>(), "number<gmp_float<35>, et_off>");
#define MPF_SMALL_TESTS /*test(number<gmp_float<18> >(), "number<gmp_float<18> >");*/ \
   test(number<gmp_float<30> >(), "number<gmp_float<30> >");                          \
   test(number<gmp_float<35> >(), "number<gmp_float<35> >");                          \
   /* there should be at least one test with expression templates off: */             \
   test(number<gmp_float<35>, et_off>(), "number<gmp_float<35>, et_off>");            \
   mpf_float::default_precision(20);                                                  \
   test(mpf_float(), "number<gmp_float<0> > (20 digit precision)");                   \
   mpf_float::default_precision(35);                                                  \
   test(mpf_float(), "number<gmp_float<0> > (35 digit precision)");

typedef boost::multiprecision::number<boost::multiprecision::gmp_float<18> >                               test_type_1;
typedef boost::multiprecision::number<boost::multiprecision::gmp_float<30> >                               test_type_2;
typedef boost::multiprecision::number<boost::multiprecision::gmp_float<35> >                               test_type_3;
typedef boost::multiprecision::number<boost::multiprecision::gmp_float<35>, boost::multiprecision::et_off> test_type_4;
typedef boost::multiprecision::mpf_float                                                                   test_type_5;

#else

#define MPF_TESTS
#define MPF_SMALL_TESTS

#endif

#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>

#define MPFR_TESTS                                                                                                     \
   test(number<mpfr_float_backend<18> >(), "number<mpfr_float_backend<18> >");                                         \
   test(number<mpfr_float_backend<30> >(), "number<mpfr_float_backend<30> >");                                         \
   test(number<mpfr_float_backend<35> >(), "number<mpfr_float_backend<35> >");                                         \
   /* Test variable precision at 2 different precisions - checks our ability to handle dynamic changes in precision */ \
   mpfr_float::default_precision(20);                                                                                  \
   test(mpfr_float(), "number<mpfr_float_backend<0> > (20-digit precision)");                                          \
   mpfr_float::default_precision(35);                                                                                  \
   test(mpfr_float(), "number<mpfr_float_backend<0> > (35-digit precision)");

typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<18> > test_type_1;
typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<30> > test_type_2;
typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<35> > test_type_3;
typedef boost::multiprecision::mpfr_float                                             test_type_4;

#else

#define MPFR_TESTS

#endif

#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>

#define CPP_DEC_FLOAT_TESTS                                          \
   test(number<cpp_dec_float<18> >(), "number<cpp_dec_float<18> >"); \
   test(number<cpp_dec_float<30> >(), "number<cpp_dec_float<30> >"); \
   test(number<cpp_dec_float<35, long long, std::allocator<char> > >(), "number<cpp_dec_float<35, long long, std::allocator<char> > >");

typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> >                                   test_type_1;
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<30> >                                   test_type_2;
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<35, long long, std::allocator<char> > > test_type_3;

#else

#define CPP_DEC_FLOAT_TESTS

#endif

#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

//#define CPP_BIN_FLOAT_TESTS test(number<debug_adaptor<cpp_bin_float_quad::backend_type>, et_off>(), "cpp_bin_float_quad");
#define CPP_BIN_FLOAT_TESTS test(cpp_bin_float_quad(), "cpp_bin_float_quad");

//typedef boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::cpp_bin_float_quad::backend_type>, boost::multiprecision::et_off> test_type_1;
typedef boost::multiprecision::cpp_bin_float_quad test_type_1;

#else

#define CPP_BIN_FLOAT_TESTS

#endif

#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>

#define FLOAT128_TESTS test(float128(), "float128");

typedef boost::multiprecision::float128 test_type_1;

#else

#define FLOAT128_TESTS

#endif

#ifndef BOOST_MATH_TEST_TYPE
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/test/floating_point_comparison.hpp>
#endif

#define ALL_TESTS      \
   MPF_TESTS           \
   MPFR_TESTS          \
   CPP_DEC_FLOAT_TESTS \
   FLOAT128_TESTS      \
   CPP_BIN_FLOAT_TESTS

#define ALL_SMALL_TESTS \
   MPF_SMALL_TESTS      \
   MPFR_TESTS           \
   CPP_DEC_FLOAT_TESTS  \
   FLOAT128_TESTS       \
   CPP_BIN_FLOAT_TESTS

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/table_type.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_TABLE_TYPE
#define BOOST_MP_TABLE_TYPE

#include <libs/math/test/table_type.hpp>
#include <boost/multiprecision/number.hpp>

struct string_table_entry
{
 private:
   const char* m_data;

 public:
   string_table_entry(const char* p) : m_data(p) {}

   template <class T>
   operator T() const
   {
      return static_cast<T>(m_data);
   }
};

inline std::ostream& operator<<(std::ostream& os, string_table_entry const& what)
{
   return os << static_cast<const char*>(what);
}

template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct table_type<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   typedef string_table_entry type;
};

#define SC_(x) string_table_entry(BOOST_STRINGIZE(x))

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_bessel_i.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_bessel_i.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //

   //
   // Catch all cases come last:
   //
   add_expected_result(
       ".*", // compiler
       ".*", // stdlib
       ".*", // platform
       ".*", // test type(s)
       ".*", // test data group
       ".*", // test function
       500,  // Max Peek error
       200); // Max mean error

   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_bessel(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   //  9 decimal digits: tests the least wide arbitrary precision code
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_SMALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_bessel_j.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_bessel_j.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //

   add_expected_result(
       ".*",                             // compiler
       ".*",                             // stdlib
       ".*",                             // platform
       ".*mpfr_float_backend<18>.*",     // test type(s)
       ".*J0.*Tricky.*",                 // test data group
       ".*", 10000000000L, 5000000000L); // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*",                        // test type(s)
       ".*J0.*Tricky.*",            // test data group
       ".*", 400000000, 400000000); // test function
   add_expected_result(
       ".*",                           // compiler
       ".*",                           // stdlib
       ".*",                           // platform
       ".*mpfr_float_backend<18>.*",   // test type(s)
       ".*J1.*Tricky.*",               // test data group
       ".*", 1000000000L, 500000000L); // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*",                     // test type(s)
       ".*J1.*Tricky.*",         // test data group
       ".*", 10000000, 5000000); // test function
   add_expected_result(
       ".*",                  // compiler
       ".*",                  // stdlib
       ".*",                  // platform
       ".*cpp_bin_float.*",   // test type(s)
       ".*JN.*Integer.*",     // test data group
       ".*", 500000, 150000); // test function
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*",                // test type(s)
       ".*JN.*Integer.*",   // test data group
       ".*", 50000, 15000); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*(JN|j).*|.*Tricky.*",      // test data group
       ".*", 70000, 7000);           // test function
   add_expected_result(
       ".*",                    // compiler
       ".*",                    // stdlib
       ".*",                    // platform
       ".*cpp_bin_float.*",     // test type(s)
       ".*(JN|j).*|.*Tricky.*", // test data group
       ".*", 500000, 200000);   // test function
   add_expected_result(
       ".*",                    // compiler
       ".*",                    // stdlib
       ".*",                    // platform
       ".*",                    // test type(s)
       ".*(JN|j).*|.*Tricky.*", // test data group
       ".*", 7000, 3000);       // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 40, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_bessel(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_bessel_k.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_bessel_k.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*gmp.*",         // test type(s)
       ".*",              // test data group
       ".*", 2000, 1500); // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",            // compiler
       ".*",            // stdlib
       ".*",            // platform
       ".*float128.*",  // test type(s)
       ".*",            // test data group
       ".*", 300, 100); // test function
#endif
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 3000, 1000);            // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*",                        // test data group
       ".*", 300, 150);             // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*large.*",   // test data group
       ".*", 80, 50); // test function
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*cpp_bin_float.*", // test type(s)
       ".*",                // test data group
       ".*", 300, 150);     // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 50, 15); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_bessel(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_bessel_y.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_bessel_y.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*(Y[nv]|y).*Random.*",      // test data group
       ".*", 200000, 10000);         // test function
   add_expected_result(
       ".*",                    // compiler
       ".*",                    // stdlib
       ".*",                    // platform
       ".*cpp_bin_float.*",     // test type(s)
       ".*(Y[nv]|y).*Random.*", // test data group
       ".*", 2000000, 1000000); // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*(Y[nv]|y).*Random.*",     // test data group
       ".*", 150000, 15000);        // test function
   add_expected_result(
       ".*",                    // compiler
       ".*",                    // stdlib
       ".*",                    // platform
       ".*",                    // test type(s)
       ".*(Y[nv]|y).*Random.*", // test data group
       ".*", 70000, 4000);      // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*Y0.*",                     // test data group
       ".*", 3000, 2000);            // test function
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*cpp_bin_float.*", // test type(s)
       ".*Y0.*",            // test data group
       ".*", 40000, 20000); // test function
   add_expected_result(
       ".*",            // compiler
       ".*",            // stdlib
       ".*",            // platform
       ".*",            // test type(s)
       ".*Y0.*",        // test data group
       ".*", 800, 400); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*Yn.*",                     // test data group
       ".*", 400000, 70000);         // test function
   add_expected_result(
       ".*",                  // compiler
       ".*",                  // stdlib
       ".*",                  // platform
       ".*cpp_bin_float.*",   // test type(s)
       ".*Yn.*",              // test data group
       ".*", 400000, 200000); // test function
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*Yn.*",         // test data group
       ".*", 1700, 600); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 15000, 4000);           // test function
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*cpp_bin_float.*", // test type(s)
       ".*",                // test data group
       ".*", 50000, 20000); // test function
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*",           // test type(s)
       ".*",           // test data group
       ".*", 150, 60); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_bessel(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_SMALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_beta.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_beta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                      // compiler
       ".*",                      // stdlib
       ".*",                      // platform
       ".*gmp.*",                 // test type(s)
       "Beta Function: Medium.*", // test data group
       "beta", 2300, 1000);       // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*gmp.*",                    // test type(s)
       "Beta Function: Divergent.*", // test data group
       "beta", 2200, 1000);          // test function
   add_expected_result(
       ".*",                             // compiler
       ".*",                             // stdlib
       ".*",                             // platform
       ".*mpfr_float_backend\\<18\\>.*", // test type(s)
       "Beta Function: Small.*",         // test data group
       "beta", 1000, 750);               // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*",                     // test type(s)
       "Beta Function: Small.*", // test data group
       "beta", 12, 8);            // test function
   add_expected_result(
       ".*",                      // compiler
       ".*",                      // stdlib
       ".*",                      // platform
       ".*",                      // test type(s)
       "Beta Function: Medium.*", // test data group
       "beta", 1000, 750);        // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*",                         // test type(s)
       "Beta Function: Divergent.*", // test data group
       "beta", 1000, 700);           // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_binomial_coeff.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_binomial_coeff.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*gmp.*",         // test type(s)
       ".*",              // test data group
       ".*", 3000, 1500); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 750, 150);              // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*",                        // test data group
       ".*", 150, 100);             // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend.*", // test type(s)
       ".*",                        // test data group
       ".*", 150, 100);             // test function
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*",           // test type(s)
       ".*",           // test data group
       ".*", 100, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_binomial(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_carlson_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT
#define TEST1

#include <boost/math/special_functions/math_fwd.hpp>
#include <boost/math/special_functions/ellint_rf.hpp>
#include "libs/math/test/test_carlson.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*RJ.*",           // test data group
       ".*", 40000, 4000); // test function
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*RJ.*",         // test data group
       ".*", 2700, 250); // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*RC.*",           // test data group
       ".*", 7000, 1000);  // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*RF.*",           // test data group
       ".*", 20000, 800);  // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 40, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_carlson_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT
#define TEST2

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_carlson.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*RJ.*",           // test data group
       ".*", 40000, 4000); // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*RC.*",           // test data group
       ".*", 7000, 1000);  // test function
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*RJ.*",         // test data group
       ".*", 2700, 250); // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 40, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_carlson_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT
#define TEST3

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_carlson.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*RJ.*",         // test data group
       ".*", 2700, 250); // test function
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*",           // test type(s)
       ".*RD: y = z",  // test data group
       ".*", 120, 30); // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 40, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_carlson_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT
#define TEST4

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_carlson.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                      // compiler
       ".*",                      // stdlib
       ".*",                      // platform
       ".*",                      // test type(s)
       "RG: two values the same", // test data group
       ".*", 10000, 700);         // test function
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*RJ.*",         // test data group
       ".*", 2700, 250); // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 40, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_cbrt.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_cbrt.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",        // compiler
       ".*",        // stdlib
       ".*",        // platform
       ".*",        // test type(s)
       ".*",        // test data group
       ".*", 5, 3); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_cbrt(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_digamma.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_digamma.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*Negative.*",               // test data group
       ".*", 20000, 2000);           // test function
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*",           // test type(s)
       ".*Negative.*", // test data group
       ".*", 550, 40); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*cpp_dec_float.*",          // test type(s)
       ".*Near the Positive Root.*", // test data group
       ".*", 2500, 200);             // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<0>.*",  // test type(s)
       ".*Near the Positive Root.*", // test data group
       ".*", 30000, 2000);           // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*",                         // test type(s)
       ".*Near the Positive Root.*", // test data group
       ".*", 6000, 1000);            // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 80, 30); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_digamma(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ellint_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ellint_1.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 1000, 200);             // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 70, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ellint_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ellint_2.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",            // compiler
       ".*",            // stdlib
       ".*",            // platform
       ".*",            // test type(s)
       ".*",            // test data group
       ".*", 300, 200); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ellint_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ellint_3.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*gmp_float<18>.*", // test type(s)
       ".*",                // test data group
       ".*", 3000, 500);    // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 10000, 3000);           // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*Mathworld.*",             // test data group
       ".*", 10000, 3000);          // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*gmp_float<0>.*", // test type(s)
       ".*",               // test data group
       ".*", 12000, 1300); // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*Large.*",   // test data group
       ".*", 75, 40); // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*cpp_bin_float_quad.*", // test type(s)
       ".*Mathworld.*",          // test data group
       ".*", 500, 100);          // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*float128.*", // test type(s)
       ".*",           // test data group
       ".*", 200, 30); // test function
#endif
   add_expected_result(
       ".*",            // compiler
       ".*",            // stdlib
       ".*",            // platform
       ".*",            // test type(s)
       ".*Mathworld.*", // test data group
       ".*", 600, 300); // test function
   add_expected_result(
       ".*",          // compiler
       ".*",          // stdlib
       ".*",          // platform
       ".*",          // test type(s)
       ".*",          // test data group
       ".*", 60, 30); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_spots(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_erf.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_erf.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                 // compiler
       ".*",                 // stdlib
       ".*",                 // platform
       ".*gmp_float<18>.*",  // test type(s)
       "Erf Function:.*",    // test data group
       "erfc?", 2200, 1500); // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*gmp_float<18>.*",      // test type(s)
       "Inverse Erf.*",          // test data group
       "erfc?_inv", 2200, 1500); // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",                  // compiler
       ".*",                  // stdlib
       ".*",                  // platform
       "float128",            // test type(s)
       "Erf Function:.*",     // test data group
       "erfc?", 15000, 1000); // test function
#endif
   add_expected_result(
       ".*",                 // compiler
       ".*",                 // stdlib
       ".*",                 // platform
       ".*cpp_bin_float.*",  // test type(s)
       "Erf Function:.*",    // test data group
       "erfc?", 3000, 1000); // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*",                        // test data group
       ".*", 600, 100);             // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*",               // test type(s)
       "Erf Function:.*",  // test data group
       "erfc?", 300, 200); // test function
   add_expected_result(
       ".*",                 // compiler
       ".*",                 // stdlib
       ".*",                 // platform
       ".*",                 // test type(s)
       "Inverse Erf.*",      // test data group
       "erfc?_inv", 60, 20); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_erf(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_expint.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_expint.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*gmp_float<18>.*", // test type(s)
       ".*",                // test data group
       ".*", 2500, 1500);   // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 1000, 500);             // test function
   add_expected_result(
       ".*",            // compiler
       ".*",            // stdlib
       ".*",            // platform
       ".*gmp_float.*", // test type(s)
       ".*",            // test data group
       ".*", 250, 100); // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       "float128",        // test type(s)
       ".*",              // test data group
       ".*", 4500, 1000); // test function
#endif
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*cpp_bin_float.*", // test type(s)
       ".*",                // test data group
       ".*", 5000, 2000);   // test function
   add_expected_result(
       ".*",           // compiler
       ".*",           // stdlib
       ".*",           // platform
       ".*",           // test type(s)
       ".*",           // test data group
       ".*", 250, 50); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_expint(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_gamma.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_gamma.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                  // compiler
       ".*",                  // stdlib
       ".*",                  // platform
       ".*gmp_float<18>.*",   // test type(s)
       ".*",                  // test data group
       "tgamma", 4000, 2500); // test function
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       "factorials",                // test data group
       "tgamma", 400, 100);         // test function
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*",               // test type(s)
       "factorials",       // test data group
       "tgamma", 170, 70); // test function
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*",                // test type(s)
       "factorials",        // test data group
       "lgamma", 750, 100); // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",                   // compiler
       ".*",                   // stdlib
       ".*",                   // platform
       "float128",             // test type(s)
       ".*near -.*",           // test data group
       ".*", 150000L, 30000L); // test function
#endif
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*",                // test type(s)
       "near.*",            // test data group
       "tgamma", 250, 120); // test function
   add_expected_result(
       ".*",                 // compiler
       ".*",                 // stdlib
       ".*",                 // platform
       ".*",                 // test type(s)
       "near.*",             // test data group
       "lgamma", 1400, 250); // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*",                     // test type(s)
       "tgamma1pm1.*",           // test data group
       "tgamma1pm1", 1500, 400); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_gamma(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_hermite.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_hermite.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       "float128",         // test type(s)
       ".*",               // test data group
       "hermite", 70, 25); // test function
#endif
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*",              // test type(s)
       ".*",              // test data group
       "hermite", 10, 5); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_hermite(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 1

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       "[^|]*",             // compiler
       "[^|]*",             // stdlib
       "[^|]*",             // platform
       ".*gmp_float<18>.*", // test type(s)
       "(?i).*small.*",     // test data group
       ".*", 3000, 1000);   // test function
   add_expected_result(
       "[^|]*",                      // compiler
       "[^|]*",                      // stdlib
       "[^|]*",                      // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       "(?i).*small.*",              // test data group
       ".*", 2000, 500);             // test function
   add_expected_result(
       "[^|]*",                     // compiler
       "[^|]*",                     // stdlib
       "[^|]*",                     // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       "(?i).*small.*",             // test data group
       ".*", 1000, 100);            // test function
#ifdef BOOST_INTEL
   add_expected_result(
       "[^|]*",         // compiler
       "[^|]*",         // stdlib
       "[^|]*",         // platform
       "float128",      // test type(s)
       "(?i).*small.*", // test data group
       ".*", 500, 100); // test function
#endif
   add_expected_result(
       "[^|]*",         // compiler
       "[^|]*",         // stdlib
       "[^|]*",         // platform
       ".*",            // test type(s)
       "(?i).*small.*", // test data group
       ".*", 90, 25);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*medium.*", // test data group
       ".*", 150, 50);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*large.*",  // test data group
       ".*", 5000, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 2

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       "[^|]*",             // compiler
       "[^|]*",             // stdlib
       "[^|]*",             // platform
       ".*gmp_float<18>.*", // test type(s)
       "(?i).*medium.*",    // test data group
       ".*", 4000, 1000);   // test function
   add_expected_result(
       "[^|]*",                      // compiler
       "[^|]*",                      // stdlib
       "[^|]*",                      // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       "(?i).*medium.*",             // test data group
       ".*", 20000, 1000);           // test function
   add_expected_result(
       "[^|]*",                     // compiler
       "[^|]*",                     // stdlib
       "[^|]*",                     // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       "(?i).*medium.*",            // test data group
       ".*", 400, 100);             // test function
   add_expected_result(
       "[^|]*",         // compiler
       "[^|]*",         // stdlib
       "[^|]*",         // platform
       ".*",            // test type(s)
       "(?i).*small.*", // test data group
       ".*", 90, 25);   // test function
#ifdef BOOST_INTEL
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       "float128",       // test type(s)
       "(?i).*medium.*", // test data group
       ".*", 5000, 500); // test function
#endif
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*medium.*", // test data group
       ".*", 220, 50);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*large.*",  // test data group
       ".*", 5000, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 3

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       "[^|]*",         // compiler
       "[^|]*",         // stdlib
       "[^|]*",         // platform
       ".*",            // test type(s)
       "(?i).*small.*", // test data group
       ".*", 90, 25);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*medium.*", // test data group
       ".*", 200, 50);   // test function
   add_expected_result(
       "[^|]*",                // compiler
       "[^|]*",                // stdlib
       "[^|]*",                // platform
       ".*",                   // test type(s)
       "(?i).*large.*",        // test data group
       ".*", 6000000, 500000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 4

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       "[^|]*",           // compiler
       "[^|]*",           // stdlib
       "[^|]*",           // platform
       ".*",              // test type(s)
       "(?i).*small.*",   // test data group
       ".*", 4000, 1000); // test function
   add_expected_result(
       "[^|]*",         // compiler
       "[^|]*",         // stdlib
       "[^|]*",         // platform
       ".*",            // test type(s)
       "(?i).*small.*", // test data group
       ".*", 90, 25);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*medium.*", // test data group
       ".*", 200, 50);   // test function
   add_expected_result(
       "[^|]*",          // compiler
       "[^|]*",          // stdlib
       "[^|]*",          // platform
       ".*",             // test type(s)
       "(?i).*large.*",  // test data group
       ".*", 5000, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta_inv_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 4

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta_inv.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                        // compiler
       ".*",                        // stdlib
       ".*",                        // platform
       ".*mpfr_float_backend<0>.*", // test type(s)
       ".*",                        // test data group
       ".*", 20000000, 1000000);    // test function
   add_expected_result(
       ".*",                     // compiler
       ".*",                     // stdlib
       ".*",                     // platform
       ".*gmp_float<0>.*",       // test type(s)
       ".*",                     // test data group
       ".*", 20000000, 1000000); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 50000000, 7000000);     // test function
   add_expected_result(
       ".*",                   // compiler
       ".*",                   // stdlib
       ".*",                   // platform
       ".*",                   // test type(s)
       ".*",                   // test data group
       ".*", 1000000, 100000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_SMALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_ibeta_inv_ab_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#define TEST_DATA 4
#define FULL_TEST

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_ibeta_inv_ab.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",               // compiler
       ".*",               // stdlib
       ".*",               // platform
       ".*",               // test type(s)
       ".*",               // test data group
       ".*", 10000, 1000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_beta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_igamma.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_igamma.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                       // compiler
       ".*",                       // stdlib
       ".*",                       // platform
       ".*",                       // test type(s)
       ".*large.*",                // test data group
       ".*", 20000000L, 1000000L); // test function
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*",              // test type(s)
       ".*",              // test data group
       ".*", 7000, 2000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_gamma(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_igamma_inv.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef TEST_MPF_50
#define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 250
#endif

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_igamma_inv.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                           // compiler
       ".*",                           // stdlib
       ".*",                           // platform
       ".*gmp_float<18>.*",            // test type(s)
       ".*small.*",                    // test data group
       ".*", 2000000000L, 300000000L); // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*small.*",                  // test data group
       ".*", 30000000L, 20000000L);  // test function
   add_expected_result(
       ".*",                       // compiler
       ".*",                       // stdlib
       ".*",                       // platform
       ".*",                       // test type(s)
       ".*small.*",                // test data group
       ".*", 10000000L, 2500000L); // test function
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*",              // test type(s)
       ".*",              // test data group
       ".*", 7000, 2000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_gamma(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_igamma_inva.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_igamma_inva.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",              // compiler
       ".*",              // stdlib
       ".*",              // platform
       ".*",              // test type(s)
       ".*",              // test data group
       ".*", 7000, 2000); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_gamma(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_laguerre.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_laguerre.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*",             // test data group
       ".*", 7500, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_laguerre(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_legendre.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_legendre.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*",             // test data group
       ".*", 6000, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_legendre_p(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_tgamma_ratio.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_tgamma_ratio.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                // compiler
       ".*",                // stdlib
       ".*",                // platform
       ".*gmp_float<18>.*", // test type(s)
       ".*",                // test data group
       ".*", 4000, 2000);   // test function
   add_expected_result(
       ".*",                         // compiler
       ".*",                         // stdlib
       ".*",                         // platform
       ".*mpfr_float_backend<18>.*", // test type(s)
       ".*",                         // test data group
       ".*", 20000, 7000);           // test function
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*",             // test data group
       ".*", 2000, 500); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_tgamma_ratio(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/math/test_zeta.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include "setup.hpp"
#include "table_type.hpp"
#define TEST_UDT

#include <boost/math/special_functions/math_fwd.hpp>
#include "libs/math/test/test_zeta.hpp"

void expected_results()
{
   //
   // Define the max and mean errors expected for
   // various compilers and platforms.
   //
   add_expected_result(
       ".*",                          // compiler
       ".*",                          // stdlib
       ".*",                          // platform
       ".*",                          // test type(s)
       ".*Random values less than 1", // test data group
       ".*", 6000, 3000);             // test function
#ifdef BOOST_INTEL
   add_expected_result(
       ".*",                           // compiler
       ".*",                           // stdlib
       ".*",                           // platform
       "float128",                     // test type(s)
       ".*close to and less than 1.*", // test data group
       ".*", 10000000L, 2000000L);     // test function
#endif
   add_expected_result(
       ".*",             // compiler
       ".*",             // stdlib
       ".*",             // platform
       ".*",             // test type(s)
       ".*",             // test data group
       ".*", 1000, 200); // test function
   //
   // Finish off by printing out the compiler/stdlib/platform names,
   // we do this to make it easier to mark up expected error rates.
   //
   std::cout << "Tests run with " << BOOST_COMPILER << ", "
             << BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}

template <class T>
void test(T t, const char* p)
{
   test_zeta(t, p);
}

BOOST_AUTO_TEST_CASE(test_main)
{
   using namespace boost::multiprecision;
   expected_results();
   //
   // Test at:
   //  9 decimal digits: tests the least wide arbitrary precision code
   // 18 decimal digits: tests 80-bit long double approximations
   // 30 decimal digits: tests 128-bit long double approximations
   // 35 decimal digits: tests arbitrary precision code
   //
   ALL_TESTS
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/no_eh_test_support.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2016 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/throw_exception.hpp>
#include <boost/config.hpp>

#ifdef BOOST_NO_EXCEPTIONS

#include <iostream>
#include <iomanip>

namespace boost {

void throw_exception(std::exception const& e)
{
   std::cerr << "Terminating with exception: " << e.what() << std::endl;
}

} // namespace boost

#else

namespace boost { namespace detail {
void dummy_proc() {}
}} // namespace boost::detail

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/boost-no-inspect
================================================


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int1024_serial32.txt
================================================
22 serialization::archive 10 0 0 0 0 0 108 240 216 207 212 25 178 183 244 196 236 95 147 174 198 156 135 30 192 249 71 150 58 81 90 83 157 31 192 97 218 61 242 6 92 59 181 100 93 130 250 188 246 144 44 168 35 244 193 47 12 158 190 153 204 174 128 206 100 236 32 18 126 89 123 194 22 35 211 231 76 148 27 235 109 5 183 33 227 88 207 58 215 251 252 155 139 128 94 102 109 67 113 84 50 31 117 129 72 215 77 164 152 225 243 6 0 0 0 1 108 240 216 207 212 25 178 183 244 196 236 95 147 174 198 156 135 30 192 249 71 150 58 81 90 83 157 31 192 97 218 61 242 6 92 59 181 100 93 130 250 188 246 144 44 168 35 244 193 47 12 158 190 153 204 174 128 206 100 236 32 18 126 89 123 194 22 35 211 231 76 148 27 235 109 5 183 33 227 88 207 58 215 251 252 155 139 128 94 102 109 67 113 84 50 31 117 129 72 215 77 164 152 225 243 6 0 0 0 0 20 233 110 98 40 22 77 153 193 59 146 80 175 250 132 156 155 86 10 0 0 1 20 233 110 98 40 22 77 153 193 59 146 80 175 250 132 156 155 86 10 0 0 0 116 195 197 234 211 167 46 136 167 128 33 88 13 108 237 91 62 12 92 69 154 204 29 67 225 108 76 250 33 86 106 195 35 211 56 231 162 75 128 234 92 136 184 82 7 210 243 108 153 53 77 201 114 146 101 203 238 16 127 62 157 89 147 7 159 33 49 73 121 45 71 184 101 48 57 231 136 53 32 117 91 72 53 49 149 132 120 220 38 202 141 199 61 152 225 162 88 241 96 97 235 194 95 106 102 77 171 141 79 25 171 118 0 150 152 162 225 1 116 195 197 234 211 167 46 136 167 128 33 88 13 108 237 91 62 12 92 69 154 204 29 67 225 108 76 250 33 86 106 195 35 211 56 231 162 75 128 234 92 136 184 82 7 210 243 108 153 53 77 201 114 146 101 203 238 16 127 62 157 89 147 7 159 33 49 73 121 45 71 184 101 48 57 231 136 53 32 117 91 72 53 49 149 132 120 220 38 202 141 199 61 152 225 162 88 241 96 97 235 194 95 106 102 77 171 141 79 25 171 118 0 150 152 162 225 0 108 52 251 142 48 154 38 230 245 135 197 116 187 16 93 121 73 166 67 73 14 108 247 153 173 155 1 1 27 39 117 50 208 104 14 143 42 205 185 79 111 156 236 127 179 134 12 211 3 186 248 224 18 111 115 8 241 120 193 95 162 144 223 81 125 100 15 75 159 151 135 167 7 105 70 42 112 187 150 50 81 238 10 88 7 185 247 8 238 5 251 173 132 245 18 238 209 93 5 153 183 17 250 77 56 125 31 2 0 1 108 52 251 142 48 154 38 230 245 135 197 116 187 16 93 121 73 166 67 73 14 108 247 153 173 155 1 1 27 39 117 50 208 104 14 143 42 205 185 79 111 156 236 127 179 134 12 211 3 186 248 224 18 111 115 8 241 120 193 95 162 144 223 81 125 100 15 75 159 151 135 167 7 105 70 42 112 187 150 50 81 238 10 88 7 185 247 8 238 5 251 173 132 245 18 238 209 93 5 153 183 17 250 77 56 125 31 2 0 0 20 197 207 215 162 39 250 228 2 55 205 156 2 210 250 185 127 9 0 0 0 1 20 197 207 215 162 39 250 228 2 55 205 156 2 210 250 185 127 9 0 0 0 0 124 24 227 82 233 197 174 88 134 19 71 12 155 49 99 207 184 189 139 213 148 142 65 83 22 86 59 113 20 118 242 15 207 165 34 25 223 113 59 30 140 39 47 19 17 91 233 70 193 187 55 81 125 94 114 235 6 80 26 251 206 129 223 96 50 3 188 107 248 74 130 151 7 40 68 162 241 8 76 185 168 192 189 109 17 104 12 100 42 186 31 15 28 113 72 249 213 10 120 161 189 54 95 145 140 93 52 223 83 153 80 25 250 68 102 71 63 122 51 3 222 201 139 253 189 1 124 24 227 82 233 197 174 88 134 19 71 12 155 49 99 207 184 189 139 213 148 142 65 83 22 86 59 113 20 118 242 15 207 165 34 25 223 113 59 30 140 39 47 19 17 91 233 70 193 187 55 81 125 94 114 235 6 80 26 251 206 129 223 96 50 3 188 107 248 74 130 151 7 40 68 162 241 8 76 185 168 192 189 109 17 104 12 100 42 186 31 15 28 113 72 249 213 10 120 161 189 54 95 145 140 93 52 223 83 153 80 25 250 68 102 71 63 122 51 3 222 201 139 253 189 0 120 84 215 85 155 83 224 217 17 152 203 112 82 122 193 196 197 212 174 168 135 168 249 185 103 45 35 64 229 91 250 210 186 58 210 182 98 118 15 126 35 18 69 254 92 98 253 202 81 186 80 212 23 15 9 32 39 1 22 16 116 63 86 191 203 58 113 189 250 81 8 87 78 224 55 184 247 69 246 57 99 3 71 4 32 58 206 214 203 112 60 52 83 234 29 3 197 37 251 251 84 166 130 63 190 142 0 143 110 160 134 104 117 192 171 252 58 243 0 0 0 1 120 84 215 85 155 83 224 217 17 152 203 112 82 122 193 196 197 212 174 168 135 168 249 185 103 45 35 64 229 91 250 210 186 58 210 182 98 118 15 126 35 18 69 254 92 98 253 202 81 186 80 212 23 15 9 32 39 1 22 16 116 63 86 191 203 58 113 189 250 81 8 87 78 224 55 184 247 69 246 57 99 3 71 4 32 58 206 214 203 112 60 52 83 234 29 3 197 37 251 251 84 166 130 63 190 142 0 143 110 160 134 104 117 192 171 252 58 243 0 0 0 0 32 75 106 211 223 67 33 39 159 137 42 62 13 132 4 148 172 13 129 231 52 23 5 189 177 132 71 127 112 12 0 0 0 1 32 75 106 211 223 67 33 39 159 137 42 62 13 132 4 148 172 13 129 231 52 23 5 189 177 132 71 127 112 12 0 0 0 0 84 71 66 188 102 218 45 89 79 100 203 161 190 29 126 44 173 44 86 244 243 53 45 157 176 5 233 73 112 206 44 106 109 159 71 109 87 77 104 184 44 147 80 22 206 180 74 221 169 143 209 179 215 195 26 222 89 28 178 48 206 169 22 229 44 34 14 33 215 159 185 161 56 150 95 20 128 199 66 223 66 113 0 0 0 1 84 71 66 188 102 218 45 89 79 100 203 161 190 29 126 44 173 44 86 244 243 53 45 157 176 5 233 73 112 206 44 106 109 159 71 109 87 77 104 184 44 147 80 22 206 180 74 221 169 143 209 179 215 195 26 222 89 28 178 48 206 169 22 229 44 34 14 33 215 159 185 161 56 150 95 20 128 199 66 223 66 113 0 0 0 0 40 74 104 149 210 252 235 123 239 168 56 124 239 105 91 87 48 183 253 146 69 244 5 94 42 167 100 207 53 34 116 207 197 97 199 198 121 102 204 246 31 1 40 74 104 149 210 252 235 123 239 168 56 124 239 105 91 87 48 183 253 146 69 244 5 94 42 167 100 207 53 34 116 207 197 97 199 198 121 102 204 246 31 0 16 127 135 241 163 116 139 210 196 195 216 24 255 21 0 0 0 1 16 127 135 241 163 116 139 210 196 195 216 24 255 21 0 0 0 0 72 150 29 179 100 132 144 156 216 95 57 162 101 198 179 215 51 244 149 122 162 171 105 83 53 56 158 83 10 80 190 228 125 131 48 41 93 2 177 156 179 17 217 253 155 46 30 105 35 223 134 100 76 170 35 206 233 252 210 117 27 160 154 210 45 234 95 74 76 159 147 2 0 1 72 150 29 179 100 132 144 156 216 95 57 162 101 198 179 215 51 244 149 122 162 171 105 83 53 56 158 83 10 80 190 228 125 131 48 41 93 2 177 156 179 17 217 253 155 46 30 105 35 223 134 100 76 170 35 206 233 252 210 117 27 160 154 210 45 234 95 74 76 159 147 2 0 0 36 220 123 216 188 130 233 64 162 111 163 35 146 32 32 192 228 163 205 248 224 147 90 97 37 29 2 241 105 156 63 40 242 105 209 126 40 1 36 220 123 216 188 130 233 64 162 111 163 35 146 32 32 192 228 163 205 248 224 147 90 97 37 29 2 241 105 156 63 40 242 105 209 126 40 0 28 230 134 234 52 30 2 41 143 232 97 74 82 171 119 128 41 82 147 155 86 202 151 8 81 3 0 0 0 1 28 230 134 234 52 30 2 41 143 232 97 74 82 171 119 128 41 82 147 155 86 202 151 8 81 3 0 0 0 0 72 15 249 15 27 178 199 148 79 23 3 197 198 33 75 3 164 156 4 165 168 224 178 69 133 25 107 103 207 249 91 170 31 103 38 157 136 237 182 137 145 28 255 143 214 212 22 229 64 150 206 235 209 33 197 227 224 182 51 28 205 88 80 228 111 77 96 3 34 184 34 1 0 1 72 15 249 15 27 178 199 148 79 23 3 197 198 33 75 3 164 156 4 165 168 224 178 69 133 25 107 103 207 249 91 170 31 103 38 157 136 237 182 137 145 28 255 143 214 212 22 229 64 150 206 235 209 33 197 227 224 182 51 28 205 88 80 228 111 77 96 3 34 184 34 1 0 0 128 218 44 245 9 8 123 94 221 100 47 84 11 243 15 172 179 239 47 175 194 3 71 55 191 38 122 159 236 92 247 18 47 19 56 134 218 188 171 164 240 122 46 184 162 129 134 174 138 64 233 80 170 255 199 102 146 231 63 160 16 196 95 226 19 153 123 117 200 46 233 120 129 83 125 132 105 126 85 36 229 17 65 127 187 245 154 8 240 255 6 80 120 99 170 69 125 132 67 244 85 139 199 7 155 182 253 26 132 174 228 45 164 121 122 120 13 138 138 103 108 205 110 58 205 79 100 212 0 1 128 218 44 245 9 8 123 94 221 100 47 84 11 243 15 172 179 239 47 175 194 3 71 55 191 38 122 159 236 92 247 18 47 19 56 134 218 188 171 164 240 122 46 184 162 129 134 174 138 64 233 80 170 255 199 102 146 231 63 160 16 196 95 226 19 153 123 117 200 46 233 120 129 83 125 132 105 126 85 36 229 17 65 127 187 245 154 8 240 255 6 80 120 99 170 69 125 132 67 244 85 139 199 7 155 182 253 26 132 174 228 45 164 121 122 120 13 138 138 103 108 205 110 58 205 79 100 212 0 0 124 42 11 175 85 234 29 127 39 168 190 213 6 131 53 241 65 78 99 129 50 177 192 60 169 254 225 53 185 10 30 128 144 147 118 226 21 168 226 101 136 76 35 162 12 195 5 204 132 123 33 134 136 228 63 232 165 209 64 49 61 69 88 217 222 49 226 15 38 80 170 183 154 76 90 32 162 103 214 88 163 4 232 2 248 216 110 84 43 233 82 171 178 169 49 99 13 2 111 187 145 184 169 169 143 134 196 5 58 127 58 229 193 147 117 193 58 158 31 111 94 152 222 23 0 1 124 42 11 175 85 234 29 127 39 168 190 213 6 131 53 241 65 78 99 129 50 177 192 60 169 254 225 53 185 10 30 128 144 147 118 226 21 168 226 101 136 76 35 162 12 195 5 204 132 123 33 134 136 228 63 232 165 209 64 49 61 69 88 217 222 49 226 15 38 80 170 183 154 76 90 32 162 103 214 88 163 4 232 2 248 216 110 84 43 233 82 171 178 169 49 99 13 2 111 187 145 184 169 169 143 134 196 5 58 127 58 229 193 147 117 193 58 158 31 111 94 152 222 23 0 0 128 117 32 231 128 78 121 139 240 228 103 68 36 169 251 164 16 50 57 142 227 5 246 77 80 110 198 12 68 1 149 50 69 54 143 139 95 198 108 21 41 162 236 219 40 173 104 226 58 15 180 5 40 31 118 13 168 210 43 211 239 7 182 203 237 162 68 33 8 250 179 25 22 162 85 109 252 238 129 170 97 47 77 76 109 6 111 254 168 196 19 35 76 81 88 241 48 255 104 111 142 75 147 180 52 99 76 255 134 237 245 122 252 21 255 187 122 115 41 176 130 69 131 13 23 37 127 20 3 1 128 117 32 231 128 78 121 139 240 228 103 68 36 169 251 164 16 50 57 142 227 5 246 77 80 110 198 12 68 1 149 50 69 54 143 139 95 198 108 21 41 162 236 219 40 173 104 226 58 15 180 5 40 31 118 13 168 210 43 211 239 7 182 203 237 162 68 33 8 250 179 25 22 162 85 109 252 238 129 170 97 47 77 76 109 6 111 254 168 196 19 35 76 81 88 241 48 255 104 111 142 75 147 180 52 99 76 255 134 237 245 122 252 21 255 187 122 115 41 176 130 69 131 13 23 37 127 20 3 0 124 225 196 245 38 129 95 130 255 14 194 101 192 198 28 5 135 65 33 59 109 254 232 229 27 245 239 185 134 58 127 181 232 77 234 159 110 69 82 234 174 133 243 107 210 244 202 250 155 41 109 253 34 38 165 23 103 75 242 126 154 90 16 155 40 180 198 123 44 56 133 74 228 20 41 104 110 42 251 181 50 43 108 181 28 98 126 48 202 202 240 10 236 228 75 105 111 132 35 221 75 171 251 197 139 242 114 49 206 195 33 149 113 119 94 226 71 220 139 93 218 202 156 199 9 1 124 225 196 245 38 129 95 130 255 14 194 101 192 198 28 5 135 65 33 59 109 254 232 229 27 245 239 185 134 58 127 181 232 77 234 159 110 69 82 234 174 133 243 107 210 244 202 250 155 41 109 253 34 38 165 23 103 75 242 126 154 90 16 155 40 180 198 123 44 56 133 74 228 20 41 104 110 42 251 181 50 43 108 181 28 98 126 48 202 202 240 10 236 228 75 105 111 132 35 221 75 171 251 197 139 242 114 49 206 195 33 149 113 119 94 226 71 220 139 93 218 202 156 199 9 0 124 130 190 211 115 201 224 67 206 209 66 76 220 164 193 3 192 104 19 174 139 21 103 49 247 223 227 161 141 190 242 11 120 201 238 152 120 157 159 206 140 138 29 151 173 117 118 102 209 136 234 50 127 131 161 166 19 148 165 245 82 205 11 104 226 229 91 148 136 10 234 81 120 171 169 131 54 235 207 59 211 127 77 24 204 157 197 253 233 237 199 174 3 72 33 142 5 218 73 26 111 135 205 112 166 233 98 13 15 33 27 131 103 119 191 23 179 123 179 24 99 136 111 206 103 1 124 130 190 211 115 201 224 67 206 209 66 76 220 164 193 3 192 104 19 174 139 21 103 49 247 223 227 161 141 190 242 11 120 201 238 152 120 157 159 206 140 138 29 151 173 117 118 102 209 136 234 50 127 131 161 166 19 148 165 245 82 205 11 104 226 229 91 148 136 10 234 81 120 171 169 131 54 235 207 59 211 127 77 24 204 157 197 253 233 237 199 174 3 72 33 142 5 218 73 26 111 135 205 112 166 233 98 13 15 33 27 131 103 119 191 23 179 123 179 24 99 136 111 206 103 0 24 236 146 150 122 80 138 70 55 218 171 50 71 53 136 214 55 85 125 93 128 4 0 0 0 1 24 236 146 150 122 80 138 70 55 218 171 50 71 53 136 214 55 85 125 93 128 4 0 0 0 0 96 168 120 24 52 192 139 221 73 242 242 97 74 214 206 178 206 134 205 255 80 249 81 103 62 255 235 105 87 255 215 122 234 6 85 194 142 4 80 39 228 210 83 78 57 126 13 175 79 207 117 247 77 43 53 164 8 185 89 108 206 201 3 63 111 26 179 169 0 252 20 51 5 213 56 133 204 63 19 45 245 58 168 12 87 82 182 175 2 1 111 83 252 59 0 0 0 1 96 168 120 24 52 192 139 221 73 242 242 97 74 214 206 178 206 134 205 255 80 249 81 103 62 255 235 105 87 255 215 122 234 6 85 194 142 4 80 39 228 210 83 78 57 126 13 175 79 207 117 247 77 43 53 164 8 185 89 108 206 201 3 63 111 26 179 169 0 252 20 51 5 213 56 133 204 63 19 45 245 58 168 12 87 82 182 175 2 1 111 83 252 59 0 0 0 0 128 185 132 187 44 241 228 100 105 22 119 238 94 124 126 113 117 10 214 51 133 149 172 201 211 213 121 160 34 164 142 116 97 112 84 155 255 6 108 94 78 4 233 188 142 66 190 97 40 135 40 45 103 104 89 35 225 9 229 254 125 210 134 186 83 219 39 156 96 79 116 202 44 226 193 33 197 237 19 205 187 104 142 222 208 110 38 156 236 173 194 237 92 12 94 102 228 230 145 128 127 23 155 108 123 159 28 189 122 77 188 51 141 193 44 74 135 72 161 176 196 25 238 215 249 1 0 0 0 1 128 185 132 187 44 241 228 100 105 22 119 238 94 124 126 113 117 10 214 51 133 149 172 201 211 213 121 160 34 164 142 116 97 112 84 155 255 6 108 94 78 4 233 188 142 66 190 97 40 135 40 45 103 104 89 35 225 9 229 254 125 210 134 186 83 219 39 156 96 79 116 202 44 226 193 33 197 237 19 205 187 104 142 222 208 110 38 156 236 173 194 237 92 12 94 102 228 230 145 128 127 23 155 108 123 159 28 189 122 77 188 51 141 193 44 74 135 72 161 176 196 25 238 215 249 1 0 0 0 0 128 196 189 1 242 155 244 232 152 101 227 3 217 39 244 236 150 9 178 16 175 212 22 120 54 105 227 225 242 229 156 121 86 139 227 54 127 184 190 41 133 3 17 52 18 138 148 221 246 233 48 84 88 59 192 24 21 252 227 123 179 109 113 77 255 247 152 43 152 181 143 190 106 157 133 109 3 97 155 223 142 24 220 123 209 115 48 134 39 181 47 225 199 64 0 47 19 50 112 64 18 160 79 199 188 82 123 15 244 22 146 43 21 149 157 118 9 188 127 178 30 174 37 125 174 1 17 0 0 1 128 196 189 1 242 155 244 232 152 101 227 3 217 39 244 236 150 9 178 16 175 212 22 120 54 105 227 225 242 229 156 121 86 139 227 54 127 184 190 41 133 3 17 52 18 138 148 221 246 233 48 84 88 59 192 24 21 252 227 123 179 109 113 77 255 247 152 43 152 181 143 190 106 157 133 109 3 97 155 223 142 24 220 123 209 115 48 134 39 181 47 225 199 64 0 47 19 50 112 64 18 160 79 199 188 82 123 15 244 22 146 43 21 149 157 118 9 188 127 178 30 174 37 125 174 1 17 0 0 0 124 125 72 103 215 83 251 97 191 63 231 211 75 247 3 48 39 242 99 75 38 207 10 64 114 118 90 122 122 77 183 190 7 147 103 181 244 49 65 243 162 67 68 8 208 134 116 48 95 95 233 35 252 112 16 102 203 11 124 40 193 161 239 28 210 11 139 204 89 203 38 245 182 150 96 26 18 46 113 77 175 20 177 91 174 135 42 135 219 19 174 215 57 19 213 152 24 76 23 175 160 29 5 177 176 24 219 163 255 97 214 199 54 191 77 15 45 73 191 156 156 85 231 7 0 1 124 125 72 103 215 83 251 97 191 63 231 211 75 247 3 48 39 242 99 75 38 207 10 64 114 118 90 122 122 77 183 190 7 147 103 181 244 49 65 243 162 67 68 8 208 134 116 48 95 95 233 35 252 112 16 102 203 11 124 40 193 161 239 28 210 11 139 204 89 203 38 245 182 150 96 26 18 46 113 77 175 20 177 91 174 135 42 135 219 19 174 215 57 19 213 152 24 76 23 175 160 29 5 177 176 24 219 163 255 97 214 199 54 191 77 15 45 73 191 156 156 85 231 7 0 0 16 252 17 170 79 122 224 151 223 165 53 141 155 37 87 4 0 1 16 252 17 170 79 122 224 151 223 165 53 141 155 37 87 4 0 0 64 137 35 96 204 136 177 189 143 1 212 169 28 91 106 152 238 147 179 84 155 35 195 77 99 22 143 175 243 178 108 188 125 52 89 146 208 125 21 94 228 98 194 201 165 96 57 144 208 56 103 133 48 45 120 4 182 247 48 112 89 188 153 1 0 1 64 137 35 96 204 136 177 189 143 1 212 169 28 91 106 152 238 147 179 84 155 35 195 77 99 22 143 175 243 178 108 188 125 52 89 146 208 125 21 94 228 98 194 201 165 96 57 144 208 56 103 133 48 45 120 4 182 247 48 112 89 188 153 1 0 0 104 243 59 23 181 19 206 54 217 4 43 183 169 25 245 43 129 181 198 110 56 213 123 240 160 71 185 170 96 174 21 188 158 209 73 67 245 248 18 139 233 181 53 185 30 209 172 198 74 139 145 21 133 168 4 186 236 48 15 19 25 234 227 177 154 240 64 215 74 77 178 193 160 155 223 234 55 201 144 185 140 71 87 18 218 192 168 98 86 67 205 126 50 211 88 59 69 53 208 210 119 1 82 1 0 1 104 243 59 23 181 19 206 54 217 4 43 183 169 25 245 43 129 181 198 110 56 213 123 240 160 71 185 170 96 174 21 188 158 209 73 67 245 248 18 139 233 181 53 185 30 209 172 198 74 139 145 21 133 168 4 186 236 48 15 19 25 234 227 177 154 240 64 215 74 77 178 193 160 155 223 234 55 201 144 185 140 71 87 18 218 192 168 98 86 67 205 126 50 211 88 59 69 53 208 210 119 1 82 1 0 0 104 30 237 199 208 43 126 134 188 221 77 44 64 109 31 47 206 70 172 101 140 66 232 0 138 101 218 81 243 45 157 119 221 30 64 253 209 50 12 45 150 152 200 9 167 220 210 114 70 151 149 141 34 162 151 188 82 189 246 149 204 99 143 240 240 11 119 55 107 27 196 176 61 52 227 44 160 102 215 226 28 36 252 136 5 162 100 95 194 183 2 28 199 117 193 177 41 170 115 62 93 181 186 1 0 1 104 30 237 199 208 43 126 134 188 221 77 44 64 109 31 47 206 70 172 101 140 66 232 0 138 101 218 81 243 45 157 119 221 30 64 253 209 50 12 45 150 152 200 9 167 220 210 114 70 151 149 141 34 162 151 188 82 189 246 149 204 99 143 240 240 11 119 55 107 27 196 176 61 52 227 44 160 102 215 226 28 36 252 136 5 162 100 95 194 183 2 28 199 117 193 177 41 170 115 62 93 181 186 1 0 0 40 53 120 130 161 159 72 98 85 190 182 236 225 240 60 214 46 141 103 182 195 63 222 96 51 133 198 58 90 110 132 208 137 203 153 172 98 79 220 0 0 1 40 53 120 130 161 159 72 98 85 190 182 236 225 240 60 214 46 141 103 182 195 63 222 96 51 133 198 58 90 110 132 208 137 203 153 172 98 79 220 0 0 0 20 118 29 12 161 58 173 221 244 97 16 129 132 213 223 100 52 220 195 7 0 1 20 118 29 12 161 58 173 221 244 97 16 129 132 213 223 100 52 220 195 7 0 0 4 48 0 0 0 1 4 48 0 0 0 0 56 231 92 254 163 124 164 150 140 111 46 208 48 245 131 79 191 167 93 72 251 225 197 183 198 127 122 236 47 16 214 74 14 201 193 171 20 118 155 238 33 155 90 192 58 99 154 59 127 53 8 120 227 43 170 1 0 1 56 231 92 254 163 124 164 150 140 111 46 208 48 245 131 79 191 167 93 72 251 225 197 183 198 127 122 236 47 16 214 74 14 201 193 171 20 118 155 238 33 155 90 192 58 99 154 59 127 53 8 120 227 43 170 1 0 0 16 251 177 154 124 124 51 12 184 170 246 21 206 136 0 6 0 1 16 251 177 154 124 124 51 12 184 170 246 21 206 136 0 6 0 0 120 135 228 154 97 97 37 218 64 185 90 19 175 246 80 210 161 113 157 100 67 139 11 67 170 100 55 10 137 62 200 98 216 164 1 43 71 31 156 64 144 57 219 81 105 211 65 2 203 127 45 87 116 177 120 38 220 221 127 219 9 89 68 112 249 96 102 183 83 157 239 104 243 95 199 142 2 33 66 225 186 67 111 177 72 133 48 17 239 26 98 202 8 125 61 65 118 6 55 147 154 167 90 0 162 128 74 17 187 146 174 37 228 190 12 117 100 32 3 0 0 1 120 135 228 154 97 97 37 218 64 185 90 19 175 246 80 210 161 113 157 100 67 139 11 67 170 100 55 10 137 62 200 98 216 164 1 43 71 31 156 64 144 57 219 81 105 211 65 2 203 127 45 87 116 177 120 38 220 221 127 219 9 89 68 112 249 96 102 183 83 157 239 104 243 95 199 142 2 33 66 225 186 67 111 177 72 133 48 17 239 26 98 202 8 125 61 65 118 6 55 147 154 167 90 0 162 128 74 17 187 146 174 37 228 190 12 117 100 32 3 0 0 0 84 26 161 163 242 118 221 0 66 192 252 133 199 57 227 98 231 11 157 63 23 214 37 26 128 100 49 131 94 235 250 249 147 154 51 50 25 98 235 243 5 108 187 118 252 12 79 151 103 7 110 124 8 167 181 214 104 91 65 119 78 66 98 82 217 239 238 114 229 245 1 243 155 98 149 133 248 106 172 101 16 223 244 0 0 1 84 26 161 163 242 118 221 0 66 192 252 133 199 57 227 98 231 11 157 63 23 214 37 26 128 100 49 131 94 235 250 249 147 154 51 50 25 98 235 243 5 108 187 118 252 12 79 151 103 7 110 124 8 167 181 214 104 91 65 119 78 66 98 82 217 239 238 114 229 245 1 243 155 98 149 133 248 106 172 101 16 223 244 0 0 0 104 51 242 193 71 40 33 244 183 39 87 209 231 123 23 102 244 164 169 195 247 118 193 238 212 202 61 62 28 173 71 226 3 123 32 247 24 21 127 54 196 17 12 180 107 10 66 175 208 88 113 145 18 93 77 231 82 5 172 142 122 173 202 80 213 151 67 189 246 154 57 40 60 62 225 173 49 197 99 197 109 106 160 126 116 179 205 235 122 139 21 129 249 231 216 211 119 4 117 66 52 193 10 0 0 1 104 51 242 193 71 40 33 244 183 39 87 209 231 123 23 102 244 164 169 195 247 118 193 238 212 202 61 62 28 173 71 226 3 123 32 247 24 21 127 54 196 17 12 180 107 10 66 175 208 88 113 145 18 93 77 231 82 5 172 142 122 173 202 80 213 151 67 189 246 154 57 40 60 62 225 173 49 197 99 197 109 106 160 126 116 179 205 235 122 139 21 129 249 231 216 211 119 4 117 66 52 193 10 0 0 0 116 117 133 12 7 22 147 126 60 222 126 15 234 208 110 144 185 13 98 7 11 209 57 121 79 194 58 253 148 206 85 251 165 5 213 112 244 92 244 25 196 40 68 91 10 147 74 13 72 165 3 119 45 32 170 129 46 133 146 166 13 69 50 36 228 124 251 190 233 4 155 225 95 178 231 135 226 223 143 88 24 162 178 240 101 140 125 124 184 151 110 254 193 242 30 230 88 55 219 178 42 54 111 9 248 91 46 181 248 183 164 152 211 7 0 0 0 1 116 117 133 12 7 22 147 126 60 222 126 15 234 208 110 144 185 13 98 7 11 209 57 121 79 194 58 253 148 206 85 251 165 5 213 112 244 92 244 25 196 40 68 91 10 147 74 13 72 165 3 119 45 32 170 129 46 133 146 166 13 69 50 36 228 124 251 190 233 4 155 225 95 178 231 135 226 223 143 88 24 162 178 240 101 140 125 124 184 151 110 254 193 242 30 230 88 55 219 178 42 54 111 9 248 91 46 181 248 183 164 152 211 7 0 0 0 0 124 63 77 192 16 39 116 41 118 84 43 197 253 236 106 62 1 183 234 241 28 170 49 21 191 231 212 161 33 61 235 39 160 228 125 57 52 78 189 69 47 1 79 177 75 103 238 153 2 38 182 148 88 116 210 38 64 96 188 136 248 75 74 182 169 213 110 205 104 170 28 203 171 146 250 72 188 184 135 129 123 246 18 94 241 239 179 131 133 192 152 204 226 228 3 166 119 222 138 54 116 129 186 64 160 210 30 139 163 195 186 2 85 155 194 170 83 132 36 74 216 27 254 85 0 1 124 63 77 192 16 39 116 41 118 84 43 197 253 236 106 62 1 183 234 241 28 170 49 21 191 231 212 161 33 61 235 39 160 228 125 57 52 78 189 69 47 1 79 177 75 103 238 153 2 38 182 148 88 116 210 38 64 96 188 136 248 75 74 182 169 213 110 205 104 170 28 203 171 146 250 72 188 184 135 129 123 246 18 94 241 239 179 131 133 192 152 204 226 228 3 166 119 222 138 54 116 129 186 64 160 210 30 139 163 195 186 2 85 155 194 170 83 132 36 74 216 27 254 85 0 0 68 216 172 85 194 158 216 82 110 65 133 85 128 49 103 72 173 54 61 199 26 210 206 103 163 37 220 221 193 233 238 254 54 206 213 124 6 203 165 26 21 241 141 165 246 128 184 43 72 242 66 159 97 79 134 33 147 97 136 247 186 217 103 81 199 29 0 0 0 1 68 216 172 85 194 158 216 82 110 65 133 85 128 49 103 72 173 54 61 199 26 210 206 103 163 37 220 221 193 233 238 254 54 206 213 124 6 203 165 26 21 241 141 165 246 128 184 43 72 242 66 159 97 79 134 33 147 97 136 247 186 217 103 81 199 29 0 0 0 0 88 198 204 237 247 146 195 97 49 165 23 187 22 34 150 126 136 183 220 165 82 194 13 172 190 161 249 20 192 177 147 243 49 113 56 111 194 238 6 98 97 129 35 110 42 246 44 179 219 221 190 182 94 40 254 25 246 171 109 11 181 1 138 90 3 209 233 133 179 57 67 179 0 223 103 18 74 138 136 231 35 199 161 29 157 1 0 0 0 1 88 198 204 237 247 146 195 97 49 165 23 187 22 34 150 126 136 183 220 165 82 194 13 172 190 161 249 20 192 177 147 243 49 113 56 111 194 238 6 98 97 129 35 110 42 246 44 179 219 221 190 182 94 40 254 25 246 171 109 11 181 1 138 90 3 209 233 133 179 57 67 179 0 223 103 18 74 138 136 231 35 199 161 29 157 1 0 0 0 0 104 200 111 223 113 76 183 17 189 185 203 122 115 218 100 205 191 105 223 132 140 147 126 199 180 195 206 12 73 110 39 71 147 85 229 115 193 236 45 39 98 81 104 24 231 243 122 80 84 171 200 163 28 188 108 159 81 0 102 179 40 112 195 41 169 248 78 181 155 111 130 188 233 129 78 9 71 59 223 40 71 154 214 88 94 144 232 156 144 221 110 76 114 52 34 145 84 178 218 142 15 103 173 3 0 1 104 200 111 223 113 76 183 17 189 185 203 122 115 218 100 205 191 105 223 132 140 147 126 199 180 195 206 12 73 110 39 71 147 85 229 115 193 236 45 39 98 81 104 24 231 243 122 80 84 171 200 163 28 188 108 159 81 0 102 179 40 112 195 41 169 248 78 181 155 111 130 188 233 129 78 9 71 59 223 40 71 154 214 88 94 144 232 156 144 221 110 76 114 52 34 145 84 178 218 142 15 103 173 3 0 0 8 177 137 11 132 66 0 0 0 1 8 177 137 11 132 66 0 0 0 0 48 33 167 44 60 43 5 212 10 233 199 142 141 206 188 38 153 75 245 28 138 78 90 196 228 196 226 63 171 99 123 61 129 93 169 246 14 54 98 199 66 102 119 74 122 163 104 13 0 1 48 33 167 44 60 43 5 212 10 233 199 142 141 206 188 38 153 75 245 28 138 78 90 196 228 196 226 63 171 99 123 61 129 93 169 246 14 54 98 199 66 102 119 74 122 163 104 13 0 0 112 13 142 178 152 223 193 158 172 255 203 197 100 76 79 42 99 97 196 198 42 60 211 249 142 174 154 123 158 254 134 251 235 151 207 55 209 178 137 7 234 137 81 211 255 191 135 78 179 11 30 121 13 152 88 34 61 56 32 249 153 111 6 135 83 62 197 83 191 163 251 20 161 116 248 36 161 123 44 251 45 216 82 212 120 237 125 134 142 89 7 182 228 191 54 121 104 50 110 8 142 248 42 214 76 253 13 190 143 50 0 0 0 1 112 13 142 178 152 223 193 158 172 255 203 197 100 76 79 42 99 97 196 198 42 60 211 249 142 174 154 123 158 254 134 251 235 151 207 55 209 178 137 7 234 137 81 211 255 191 135 78 179 11 30 121 13 152 88 34 61 56 32 249 153 111 6 135 83 62 197 83 191 163 251 20 161 116 248 36 161 123 44 251 45 216 82 212 120 237 125 134 142 89 7 182 228 191 54 121 104 50 110 8 142 248 42 214 76 253 13 190 143 50 0 0 0 0 28 135 115 67 224 57 26 67 50 161 116 97 239 175 143 9 168 232 95 142 29 48 16 121 194 48 241 158 6 1 28 135 115 67 224 57 26 67 50 161 116 97 239 175 143 9 168 232 95 142 29 48 16 121 194 48 241 158 6 0 120 179 69 194 42 93 120 64 237 75 176 251 199 63 49 12 217 68 117 60 17 14 70 160 57 29 60 226 156 164 120 98 6 241 147 20 139 159 7 106 210 46 18 44 209 147 45 254 121 230 97 80 19 35 222 34 109 179 236 84 205 123 213 217 33 100 118 217 223 98 205 210 213 162 16 151 66 225 173 235 73 110 112 76 172 232 124 30 64 29 119 3 178 184 119 33 176 53 248 40 157 126 127 125 242 209 202 221 233 124 59 53 81 231 151 52 49 122 224 122 27 1 120 179 69 194 42 93 120 64 237 75 176 251 199 63 49 12 217 68 117 60 17 14 70 160 57 29 60 226 156 164 120 98 6 241 147 20 139 159 7 106 210 46 18 44 209 147 45 254 121 230 97 80 19 35 222 34 109 179 236 84 205 123 213 217 33 100 118 217 223 98 205 210 213 162 16 151 66 225 173 235 73 110 112 76 172 232 124 30 64 29 119 3 178 184 119 33 176 53 248 40 157 126 127 125 242 209 202 221 233 124 59 53 81 231 151 52 49 122 224 122 27 0 88 202 249 247 72 190 100 43 14 53 119 130 14 137 197 240 200 81 190 103 225 158 134 179 33 43 177 147 126 191 141 162 245 224 193 132 144 147 134 16 189 234 157 212 246 176 172 112 191 110 66 141 195 94 234 133 171 20 190 248 55 25 132 147 148 135 183 201 74 89 229 183 214 200 16 91 233 10 37 163 27 133 153 134 93 213 152 142 7 1 88 202 249 247 72 190 100 43 14 53 119 130 14 137 197 240 200 81 190 103 225 158 134 179 33 43 177 147 126 191 141 162 245 224 193 132 144 147 134 16 189 234 157 212 246 176 172 112 191 110 66 141 195 94 234 133 171 20 190 248 55 25 132 147 148 135 183 201 74 89 229 183 214 200 16 91 233 10 37 163 27 133 153 134 93 213 152 142 7 0 88 77 103 16 15 148 98 115 149 166 118 218 10 199 232 124 175 175 165 211 217 182 127 122 39 230 51 107 111 80 51 18 145 177 162 46 2 119 80 163 33 253 187 253 121 34 222 134 85 8 230 102 107 120 117 240 151 81 89 38 47 90 107 129 149 16 144 78 38 26 58 78 61 163 182 119 241 129 192 139 249 183 46 39 109 17 15 240 0 1 88 77 103 16 15 148 98 115 149 166 118 218 10 199 232 124 175 175 165 211 217 182 127 122 39 230 51 107 111 80 51 18 145 177 162 46 2 119 80 163 33 253 187 253 121 34 222 134 85 8 230 102 107 120 117 240 151 81 89 38 47 90 107 129 149 16 144 78 38 26 58 78 61 163 182 119 241 129 192 139 249 183 46 39 109 17 15 240 0 0 52 234 213 76 110 121 53 109 162 71 58 96 120 32 67 142 4 161 13 37 85 104 226 206 115 224 160 35 117 179 108 202 225 198 59 157 91 182 20 254 20 5 196 54 221 64 27 198 127 155 96 99 2 1 52 234 213 76 110 121 53 109 162 71 58 96 120 32 67 142 4 161 13 37 85 104 226 206 115 224 160 35 117 179 108 202 225 198 59 157 91 182 20 254 20 5 196 54 221 64 27 198 127 155 96 99 2 0 100 130 27 80 132 149 206 104 74 186 108 76 162 61 90 101 136 56 238 26 128 103 13 215 175 217 2 94 203 185 103 235 57 73 179 67 251 148 153 157 188 175 176 9 190 11 144 240 204 176 77 140 59 173 23 41 195 49 211 129 99 226 89 41 61 117 216 244 229 187 66 250 141 7 162 242 64 30 74 137 170 157 234 46 180 106 67 91 184 254 133 132 150 83 202 121 109 229 1 0 0 1 100 130 27 80 132 149 206 104 74 186 108 76 162 61 90 101 136 56 238 26 128 103 13 215 175 217 2 94 203 185 103 235 57 73 179 67 251 148 153 157 188 175 176 9 190 11 144 240 204 176 77 140 59 173 23 41 195 49 211 129 99 226 89 41 61 117 216 244 229 187 66 250 141 7 162 242 64 30 74 137 170 157 234 46 180 106 67 91 184 254 133 132 150 83 202 121 109 229 1 0 0 0 96 180 177 20 52 197 85 168 138 255 101 101 71 208 219 45 169 123 61 167 239 15 8 52 226 172 233 153 47 28 118 122 247 246 33 225 192 78 230 61 188 196 197 48 3 32 37 12 172 242 129 25 220 16 26 252 131 142 114 105 69 201 34 95 85 12 39 146 145 217 235 38 66 245 145 202 77 22 159 59 0 129 139 201 197 42 198 93 48 54 136 29 220 157 47 43 0 1 96 180 177 20 52 197 85 168 138 255 101 101 71 208 219 45 169 123 61 167 239 15 8 52 226 172 233 153 47 28 118 122 247 246 33 225 192 78 230 61 188 196 197 48 3 32 37 12 172 242 129 25 220 16 26 252 131 142 114 105 69 201 34 95 85 12 39 146 145 217 235 38 66 245 145 202 77 22 159 59 0 129 139 201 197 42 198 93 48 54 136 29 220 157 47 43 0 0 96 228 177 197 157 201 233 218 33 173 105 143 149 114 247 135 47 252 136 226 112 224 250 62 15 148 29 202 26 68 127 193 62 109 233 165 67 21 221 99 246 160 113 232 255 240 215 55 219 168 67 172 220 239 70 18 44 75 90 190 126 188 2 138 148 81 54 76 45 139 27 198 140 152 73 84 62 77 207 250 184 202 70 93 74 35 192 212 68 254 66 167 55 43 72 51 1 1 96 228 177 197 157 201 233 218 33 173 105 143 149 114 247 135 47 252 136 226 112 224 250 62 15 148 29 202 26 68 127 193 62 109 233 165 67 21 221 99 246 160 113 232 255 240 215 55 219 168 67 172 220 239 70 18 44 75 90 190 126 188 2 138 148 81 54 76 45 139 27 198 140 152 73 84 62 77 207 250 184 202 70 93 74 35 192 212 68 254 66 167 55 43 72 51 1 0 64 214 194 164 243 67 99 159 221 32 79 138 118 10 246 26 53 220 63 121 128 209 86 55 147 46 21 147 111 73 114 48 231 199 129 181 226 153 2 49 119 72 168 113 113 77 187 140 153 22 15 24 250 59 186 131 64 170 188 226 4 136 0 0 0 1 64 214 194 164 243 67 99 159 221 32 79 138 118 10 246 26 53 220 63 121 128 209 86 55 147 46 21 147 111 73 114 48 231 199 129 181 226 153 2 49 119 72 168 113 113 77 187 140 153 22 15 24 250 59 186 131 64 170 188 226 4 136 0 0 0 0 52 137 1 85 110 191 240 53 229 183 92 119 252 131 102 74 251 188 32 178 3 182 241 244 250 87 89 25 222 123 231 114 153 55 41 42 92 80 171 133 162 143 161 81 69 72 198 206 202 152 186 2 0 1 52 137 1 85 110 191 240 53 229 183 92 119 252 131 102 74 251 188 32 178 3 182 241 244 250 87 89 25 222 123 231 114 153 55 41 42 92 80 171 133 162 143 161 81 69 72 198 206 202 152 186 2 0 0 56 211 76 143 162 185 129 219 122 124 64 67 106 130 145 59 54 198 182 118 11 1 159 173 227 145 183 65 74 210 107 97 244 37 234 225 245 194 126 48 168 194 239 99 117 113 246 7 68 90 122 30 120 121 204 1 0 1 56 211 76 143 162 185 129 219 122 124 64 67 106 130 145 59 54 198 182 118 11 1 159 173 227 145 183 65 74 210 107 97 244 37 234 225 245 194 126 48 168 194 239 99 117 113 246 7 68 90 122 30 120 121 204 1 0 0 84 105 73 115 54 214 7 115 255 61 66 95 124 249 26 243 37 155 74 9 85 217 163 49 217 173 61 95 67 196 72 63 156 172 27 80 167 165 134 208 52 201 202 92 55 128 155 17 60 176 105 63 30 206 211 19 235 211 182 152 83 135 179 180 37 195 226 138 134 144 171 149 80 65 145 226 242 243 230 43 132 178 250 39 215 1 84 105 73 115 54 214 7 115 255 61 66 95 124 249 26 243 37 155 74 9 85 217 163 49 217 173 61 95 67 196 72 63 156 172 27 80 167 165 134 208 52 201 202 92 55 128 155 17 60 176 105 63 30 206 211 19 235 211 182 152 83 135 179 180 37 195 226 138 134 144 171 149 80 65 145 226 242 243 230 43 132 178 250 39 215 0 24 238 147 112 201 202 57 233 73 216 169 141 254 73 1 28 115 92 180 201 139 174 21 11 0 1 24 238 147 112 201 202 57 233 73 216 169 141 254 73 1 28 115 92 180 201 139 174 21 11 0 0 24 11 98 186 29 212 176 86 13 53 40 93 147 195 178 153 54 152 222 244 40 193 19 0 0 1 24 11 98 186 29 212 176 86 13 53 40 93 147 195 178 153 54 152 222 244 40 193 19 0 0 0 40 247 180 251 141 141 62 11 228 178 124 25 179 207 78 30 191 6 166 89 240 173 89 181 244 213 201 90 164 248 113 18 220 53 196 159 235 161 36 114 0 1 40 247 180 251 141 141 62 11 228 178 124 25 179 207 78 30 191 6 166 89 240 173 89 181 244 213 201 90 164 248 113 18 220 53 196 159 235 161 36 114 0 0 92 197 219 246 150 141 204 249 197 122 42 147 254 26 80 88 29 210 60 108 233 49 53 58 229 228 74 204 32 164 150 72 227 75 126 222 254 223 216 61 51 43 121 144 51 162 181 207 169 112 177 75 201 49 79 92 41 7 31 62 225 233 82 103 28 12 148 8 127 39 116 68 202 216 227 213 140 255 16 22 227 223 27 82 6 151 211 143 89 62 252 11 0 1 92 197 219 246 150 141 204 249 197 122 42 147 254 26 80 88 29 210 60 108 233 49 53 58 229 228 74 204 32 164 150 72 227 75 126 222 254 223 216 61 51 43 121 144 51 162 181 207 169 112 177 75 201 49 79 92 41 7 31 62 225 233 82 103 28 12 148 8 127 39 116 68 202 216 227 213 140 255 16 22 227 223 27 82 6 151 211 143 89 62 252 11 0 0 104 84 85 201 229 80 220 110 27 89 135 96 8 25 169 247 170 52 98 214 179 116 102 103 90 190 212 155 200 5 237 5 33 189 15 223 142 50 1 136 100 122 203 43 219 41 31 201 158 108 205 137 41 171 131 15 69 19 41 170 64 244 118 157 0 134 78 207 249 103 223 37 193 0 163 144 187 16 102 223 27 90 215 43 229 11 42 66 58 117 150 42 248 101 141 189 6 240 7 0 242 197 127 1 0 1 104 84 85 201 229 80 220 110 27 89 135 96 8 25 169 247 170 52 98 214 179 116 102 103 90 190 212 155 200 5 237 5 33 189 15 223 142 50 1 136 100 122 203 43 219 41 31 201 158 108 205 137 41 171 131 15 69 19 41 170 64 244 118 157 0 134 78 207 249 103 223 37 193 0 163 144 187 16 102 223 27 90 215 43 229 11 42 66 58 117 150 42 248 101 141 189 6 240 7 0 242 197 127 1 0 0 8 185 243 251 131 7 0 0 0 1 8 185 243 251 131 7 0 0 0 0 44 188 64 12 102 153 116 180 169 232 182 207 120 2 241 87 106 199 3 100 211 214 177 149 40 69 55 14 15 24 136 141 41 198 26 255 238 213 146 192 182 42 0 0 0 1 44 188 64 12 102 153 116 180 169 232 182 207 120 2 241 87 106 199 3 100 211 214 177 149 40 69 55 14 15 24 136 141 41 198 26 255 238 213 146 192 182 42 0 0 0 0 36 60 69 243 184 98 7 253 248 147 154 234 108 139 170 83 33 71 50 181 137 96 0 97 65 238 127 238 220 145 220 30 197 164 169 50 39 1 36 60 69 243 184 98 7 253 248 147 154 234 108 139 170 83 33 71 50 181 137 96 0 97 65 238 127 238 220 145 220 30 197 164 169 50 39 0 112 226 167 90 98 229 230 91 40 155 26 167 140 217 74 204 150 223 188 123 34 82 92 87 7 182 125 184 131 72 19 168 23 168 126 18 67 33 218 228 80 219 32 115 52 91 153 74 185 188 251 88 141 206 245 147 186 188 9 11 227 190 147 53 27 159 175 207 126 95 65 244 167 190 77 129 82 251 142 246 254 93 98 112 160 141 225 214 75 62 208 202 45 97 98 146 177 111 133 60 28 249 233 207 10 171 89 174 70 14 94 129 40 1 112 226 167 90 98 229 230 91 40 155 26 167 140 217 74 204 150 223 188 123 34 82 92 87 7 182 125 184 131 72 19 168 23 168 126 18 67 33 218 228 80 219 32 115 52 91 153 74 185 188 251 88 141 206 245 147 186 188 9 11 227 190 147 53 27 159 175 207 126 95 65 244 167 190 77 129 82 251 142 246 254 93 98 112 160 141 225 214 75 62 208 202 45 97 98 146 177 111 133 60 28 249 233 207 10 171 89 174 70 14 94 129 40 0 8 109 138 127 241 182 108 3 0 1 8 109 138 127 241 182 108 3 0 0 20 253 248 186 235 248 125 194 176 203 231 91 182 41 233 0 226 122 118 84 2 1 20 253 248 186 235 248 125 194 176 203 231 91 182 41 233 0 226 122 118 84 2 0 16 230 16 7 220 125 232 51 204 126 74 73 232 59 0 0 0 1 16 230 16 7 220 125 232 51 204 126 74 73 232 59 0 0 0 0 128 96 188 53 88 57 212 250 97 99 241 119 39 211 59 47 120 144 156 173 166 143 114 227 10 41 16 55 214 158 53 92 82 10 117 44 252 226 154 161 113 202 150 106 200 19 38 79 40 100 2 216 168 103 49 218 150 159 173 218 238 0 59 105 125 25 202 77 232 122 113 96 184 174 146 91 150 158 119 220 235 41 130 173 153 183 164 219 127 2 22 89 184 116 175 152 236 46 180 242 142 205 40 40 121 115 78 145 79 246 133 130 224 161 140 56 114 143 192 138 82 110 74 44 22 99 135 217 2 1 128 96 188 53 88 57 212 250 97 99 241 119 39 211 59 47 120 144 156 173 166 143 114 227 10 41 16 55 214 158 53 92 82 10 117 44 252 226 154 161 113 202 150 106 200 19 38 79 40 100 2 216 168 103 49 218 150 159 173 218 238 0 59 105 125 25 202 77 232 122 113 96 184 174 146 91 150 158 119 220 235 41 130 173 153 183 164 219 127 2 22 89 184 116 175 152 236 46 180 242 142 205 40 40 121 115 78 145 79 246 133 130 224 161 140 56 114 143 192 138 82 110 74 44 22 99 135 217 2 0 108 183 215 158 47 73 44 220 50 163 229 15 148 225 154 78 50 189 136 15 137 135 196 30 145 70 78 206 57 19 181 129 163 193 193 234 155 1 250 142 170 197 218 122 99 180 214 31 196 167 42 38 254 90 90 60 16 232 180 119 19 88 155 128 27 128 25 230 39 205 154 156 158 153 88 120 44 1 136 211 209 30 179 28 159 46 164 62 97 233 105 33 20 253 209 183 59 98 45 110 88 170 73 103 237 172 14 0 0 1 108 183 215 158 47 73 44 220 50 163 229 15 148 225 154 78 50 189 136 15 137 135 196 30 145 70 78 206 57 19 181 129 163 193 193 234 155 1 250 142 170 197 218 122 99 180 214 31 196 167 42 38 254 90 90 60 16 232 180 119 19 88 155 128 27 128 25 230 39 205 154 156 158 153 88 120 44 1 136 211 209 30 179 28 159 46 164 62 97 233 105 33 20 253 209 183 59 98 45 110 88 170 73 103 237 172 14 0 0 0 108 109 39 198 116 134 109 137 3 154 63 133 155 109 82 108 240 13 83 246 109 126 71 168 5 252 39 139 51 83 180 93 45 15 158 50 208 87 19 218 21 230 235 83 238 84 254 144 65 87 7 55 39 65 75 33 1 137 221 191 101 104 101 15 201 217 163 216 64 237 92 24 199 180 178 166 245 190 146 159 89 122 28 142 102 176 245 112 28 239 140 93 48 144 224 181 154 244 92 174 112 189 17 186 11 61 0 0 0 1 108 109 39 198 116 134 109 137 3 154 63 133 155 109 82 108 240 13 83 246 109 126 71 168 5 252 39 139 51 83 180 93 45 15 158 50 208 87 19 218 21 230 235 83 238 84 254 144 65 87 7 55 39 65 75 33 1 137 221 191 101 104 101 15 201 217 163 216 64 237 92 24 199 180 178 166 245 190 146 159 89 122 28 142 102 176 245 112 28 239 140 93 48 144 224 181 154 244 92 174 112 189 17 186 11 61 0 0 0 0 92 115 25 74 181 122 105 117 16 23 160 104 186 173 148 142 130 124 69 176 164 120 37 35 164 26 5 203 211 81 114 102 172 157 224 92 119 72 40 156 152 170 218 239 244 122 119 68 255 223 165 182 239 221 222 170 86 17 177 252 123 251 137 160 2 17 88 15 181 45 222 85 1 145 242 26 221 26 143 50 5 231 126 165 15 88 139 246 42 136 0 0 0 1 92 115 25 74 181 122 105 117 16 23 160 104 186 173 148 142 130 124 69 176 164 120 37 35 164 26 5 203 211 81 114 102 172 157 224 92 119 72 40 156 152 170 218 239 244 122 119 68 255 223 165 182 239 221 222 170 86 17 177 252 123 251 137 160 2 17 88 15 181 45 222 85 1 145 242 26 221 26 143 50 5 231 126 165 15 88 139 246 42 136 0 0 0 0 20 11 96 10 112 174 90 0 74 17 97 66 74 95 235 134 176 1 0 0 0 1 20 11 96 10 112 174 90 0 74 17 97 66 74 95 235 134 176 1 0 0 0 0 44 154 185 66 152 86 30 237 20 211 200 92 232 231 159 111 104 239 215 186 246 153 131 145 191 158 17 100 149 87 115 114 80 153 175 127 213 20 30 55 123 56 0 0 0 1 44 154 185 66 152 86 30 237 20 211 200 92 232 231 159 111 104 239 215 186 246 153 131 145 191 158 17 100 149 87 115 114 80 153 175 127 213 20 30 55 123 56 0 0 0 0 100 200 46 197 117 247 255 182 227 22 29 184 198 24 211 143 87 190 175 196 153 250 144 95 50 47 199 87 38 91 196 72 184 66 112 224 205 213 241 213 215 217 50 114 236 249 135 67 151 218 231 131 138 171 95 70 223 55 110 156 24 86 4 116 64 213 4 169 211 115 62 175 39 13 169 242 237 56 166 5 99 183 238 116 46 114 188 183 203 8 57 40 83 132 247 182 225 184 108 0 0 1 100 200 46 197 117 247 255 182 227 22 29 184 198 24 211 143 87 190 175 196 153 250 144 95 50 47 199 87 38 91 196 72 184 66 112 224 205 213 241 213 215 217 50 114 236 249 135 67 151 218 231 131 138 171 95 70 223 55 110 156 24 86 4 116 64 213 4 169 211 115 62 175 39 13 169 242 237 56 166 5 99 183 238 116 46 114 188 183 203 8 57 40 83 132 247 182 225 184 108 0 0 0 124 94 235 124 73 23 127 111 55 10 111 84 126 170 16 77 106 181 163 73 165 249 170 40 170 90 228 108 176 252 39 45 191 204 225 251 145 26 45 5 233 1 112 57 57 75 136 241 126 114 242 43 156 144 93 196 214 225 123 243 163 118 208 74 233 52 78 129 73 101 32 94 180 49 175 158 209 26 110 42 125 133 11 133 252 19 105 165 220 63 81 214 85 35 166 157 95 220 199 190 78 235 205 161 109 38 86 178 173 75 16 150 107 115 202 87 90 44 122 250 44 242 3 0 0 1 124 94 235 124 73 23 127 111 55 10 111 84 126 170 16 77 106 181 163 73 165 249 170 40 170 90 228 108 176 252 39 45 191 204 225 251 145 26 45 5 233 1 112 57 57 75 136 241 126 114 242 43 156 144 93 196 214 225 123 243 163 118 208 74 233 52 78 129 73 101 32 94 180 49 175 158 209 26 110 42 125 133 11 133 252 19 105 165 220 63 81 214 85 35 166 157 95 220 199 190 78 235 205 161 109 38 86 178 173 75 16 150 107 115 202 87 90 44 122 250 44 242 3 0 0 0 64 33 38 244 173 112 88 99 122 250 156 144 15 79 132 196 15 41 75 133 177 70 36 29 76 228 221 155 246 69 197 87 207 178 221 150 150 163 43 125 211 170 119 162 199 18 140 88 14 141 156 131 55 86 105 131 87 183 202 138 193 250 146 7 0 1 64 33 38 244 173 112 88 99 122 250 156 144 15 79 132 196 15 41 75 133 177 70 36 29 76 228 221 155 246 69 197 87 207 178 221 150 150 163 43 125 211 170 119 162 199 18 140 88 14 141 156 131 55 86 105 131 87 183 202 138 193 250 146 7 0 0 8 193 65 150 116 8 0 0 0 1 8 193 65 150 116 8 0 0 0 0 88 222 76 87 0 39 117 3 50 43 76 65 78 229 242 96 28 45 68 9 84 77 32 141 102 105 143 7 223 208 38 17 171 1 5 64 101 80 4 202 47 105 247 32 207 194 242 83 135 163 54 216 178 26 17 93 139 73 169 226 217 99 11 82 47 3 157 215 215 153 31 216 121 218 217 197 70 198 39 255 50 228 150 229 67 199 1 0 0 1 88 222 76 87 0 39 117 3 50 43 76 65 78 229 242 96 28 45 68 9 84 77 32 141 102 105 143 7 223 208 38 17 171 1 5 64 101 80 4 202 47 105 247 32 207 194 242 83 135 163 54 216 178 26 17 93 139 73 169 226 217 99 11 82 47 3 157 215 215 153 31 216 121 218 217 197 70 198 39 255 50 228 150 229 67 199 1 0 0 0 60 132 11 227 148 45 72 132 90 43 39 166 76 172 224 159 49 82 126 46 147 149 229 112 96 19 103 129 209 180 204 78 161 218 161 137 155 40 142 2 48 80 224 51 94 209 169 119 94 212 151 125 134 39 145 109 231 4 0 0 0 1 60 132 11 227 148 45 72 132 90 43 39 166 76 172 224 159 49 82 126 46 147 149 229 112 96 19 103 129 209 180 204 78 161 218 161 137 155 40 142 2 48 80 224 51 94 209 169 119 94 212 151 125 134 39 145 109 231 4 0 0 0 0 20 123 47 118 34 191 206 207 171 213 67 79 77 219 89 68 92 2 0 0 0 1 20 123 47 118 34 191 206 207 171 213 67 79 77 219 89 68 92 2 0 0 0 0 52 181 219 18 61 30 154 15 167 192 14 196 148 216 66 206 1 98 115 173 137 197 47 49 228 38 188 178 148 202 18 96 2 103 255 202 246 177 221 107 35 180 27 33 72 172 31 69 128 123 0 0 0 1 52 181 219 18 61 30 154 15 167 192 14 196 148 216 66 206 1 98 115 173 137 197 47 49 228 38 188 178 148 202 18 96 2 103 255 202 246 177 221 107 35 180 27 33 72 172 31 69 128 123 0 0 0 0 28 7 82 250 163 171 151 193 242 222 208 224 252 8 145 119 231 240 219 237 115 112 17 84 150 54 234 247 1 1 28 7 82 250 163 171 151 193 242 222 208 224 252 8 145 119 231 240 219 237 115 112 17 84 150 54 234 247 1 0 100 106 128 3 1 188 158 131 102 30 13 165 34 56 140 67 110 15 41 20 34 218 85 212 56 208 97 6 198 121 86 231 16 60 41 116 51 112 68 146 225 249 153 79 173 152 178 167 118 161 49 82 252 223 181 39 89 10 249 163 146 32 111 19 91 56 141 207 248 45 150 31 199 164 135 69 61 48 86 28 152 157 46 95 110 240 67 68 230 61 162 195 46 59 109 223 151 104 231 1 0 1 100 106 128 3 1 188 158 131 102 30 13 165 34 56 140 67 110 15 41 20 34 218 85 212 56 208 97 6 198 121 86 231 16 60 41 116 51 112 68 146 225 249 153 79 173 152 178 167 118 161 49 82 252 223 181 39 89 10 249 163 146 32 111 19 91 56 141 207 248 45 150 31 199 164 135 69 61 48 86 28 152 157 46 95 110 240 67 68 230 61 162 195 46 59 109 223 151 104 231 1 0 0 8 71 170 230 149 60 169 8 0 1 8 71 170 230 149 60 169 8 0 0 104 197 60 13 194 96 169 102 36 193 199 30 151 61 112 84 43 43 191 194 1 161 56 139 53 115 136 32 148 17 113 135 55 123 181 224 91 143 170 42 70 154 95 146 126 90 132 159 105 180 251 18 41 35 80 231 44 31 43 32 145 245 182 101 28 236 119 33 66 1 225 23 219 129 219 214 243 191 203 150 13 208 77 171 34 153 52 224 233 94 147 246 3 95 62 22 212 102 7 164 241 174 21 0 0 1 104 197 60 13 194 96 169 102 36 193 199 30 151 61 112 84 43 43 191 194 1 161 56 139 53 115 136 32 148 17 113 135 55 123 181 224 91 143 170 42 70 154 95 146 126 90 132 159 105 180 251 18 41 35 80 231 44 31 43 32 145 245 182 101 28 236 119 33 66 1 225 23 219 129 219 214 243 191 203 150 13 208 77 171 34 153 52 224 233 94 147 246 3 95 62 22 212 102 7 164 241 174 21 0 0 0 8 255 177 136 137 82 0 0 0 1 8 255 177 136 137 82 0 0 0 0 28 244 28 97 243 182 228 22 188 140 208 197 48 85 163 246 9 179 58 95 58 150 166 115 224 1 0 0 0 1 28 244 28 97 243 182 228 22 188 140 208 197 48 85 163 246 9 179 58 95 58 150 166 115 224 1 0 0 0 0 56 18 166 152 245 55 183 20 61 65 95 235 22 101 208 144 158 244 134 73 6 107 252 90 131 187 46 111 218 192 193 204 157 69 78 249 68 158 131 231 84 169 155 246 223 255 125 237 56 39 124 83 222 2 0 0 0 1 56 18 166 152 245 55 183 20 61 65 95 235 22 101 208 144 158 244 134 73 6 107 252 90 131 187 46 111 218 192 193 204 157 69 78 249 68 158 131 231 84 169 155 246 223 255 125 237 56 39 124 83 222 2 0 0 0 0 64 125 215 194 190 138 172 44 82 18 4 12 27 37 152 98 142 28 176 36 149 113 6 134 186 247 114 113 24 143 28 126 9 132 211 32 84 48 255 229 143 210 55 139 145 108 151 47 228 54 230 198 125 130 0 191 218 241 25 250 223 160 158 116 0 1 64 125 215 194 190 138 172 44 82 18 4 12 27 37 152 98 142 28 176 36 149 113 6 134 186 247 114 113 24 143 28 126 9 132 211 32 84 48 255 229 143 210 55 139 145 108 151 47 228 54 230 198 125 130 0 191 218 241 25 250 223 160 158 116 0 0 60 3 57 187 171 211 24 69 12 134 135 186 26 223 242 182 51 228 122 123 228 34 89 39 47 189 254 2 149 226 207 2 67 99 42 86 56 191 230 17 56 161 156 156 78 118 244 228 6 251 250 232 155 46 194 10 138 122 135 43 0 1 60 3 57 187 171 211 24 69 12 134 135 186 26 223 242 182 51 228 122 123 228 34 89 39 47 189 254 2 149 226 207 2 67 99 42 86 56 191 230 17 56 161 156 156 78 118 244 228 6 251 250 232 155 46 194 10 138 122 135 43 0 0 60 172 126 95 38 172 16 35 220 31 69 231 168 50 246 181 132 163 59 105 107 11 195 114 20 55 43 40 50 235 159 196 170 131 133 34 254 126 123 149 223 8 155 192 190 96 9 65 243 130 152 203 23 54 157 5 6 21 0 0 0 1 60 172 126 95 38 172 16 35 220 31 69 231 168 50 246 181 132 163 59 105 107 11 195 114 20 55 43 40 50 235 159 196 170 131 133 34 254 126 123 149 223 8 155 192 190 96 9 65 243 130 152 203 23 54 157 5 6 21 0 0 0 0 64 2 111 152 136 184 111 221 198 128 165 251 127 213 81 172 8 106 234 51 14 82 18 6 231 152 0 230 43 112 55 155 160 105 77 184 34 204 159 232 23 202 84 150 215 63 252 216 202 135 94 254 143 56 128 190 119 156 93 36 146 106 50 31 0 1 64 2 111 152 136 184 111 221 198 128 165 251 127 213 81 172 8 106 234 51 14 82 18 6 231 152 0 230 43 112 55 155 160 105 77 184 34 204 159 232 23 202 84 150 215 63 252 216 202 135 94 254 143 56 128 190 119 156 93 36 146 106 50 31 0 0 84 67 179 87 45 0 244 146 0 251 216 55 206 169 143 153 155 204 98 242 127 58 228 9 185 140 50 24 85 71 140 103 173 214 208 88 197 18 88 42 237 5 249 171 151 55 8 19 64 247 14 51 205 117 38 200 199 107 98 33 41 209 251 142 166 190 178 246 165 231 178 156 209 134 137 201 40 51 114 105 214 176 192 40 0 1 84 67 179 87 45 0 244 146 0 251 216 55 206 169 143 153 155 204 98 242 127 58 228 9 185 140 50 24 85 71 140 103 173 214 208 88 197 18 88 42 237 5 249 171 151 55 8 19 64 247 14 51 205 117 38 200 199 107 98 33 41 209 251 142 166 190 178 246 165 231 178 156 209 134 137 201 40 51 114 105 214 176 192 40 0 0 104 210 223 181 52 158 133 105 60 206 60 97 88 35 84 39 241 68 117 46 200 25 178 180 2 135 170 228 237 78 95 141 220 192 61 243 38 81 141 157 147 134 105 20 141 231 139 98 217 141 233 206 38 63 88 41 115 146 165 44 212 80 120 9 35 155 237 10 49 241 130 64 144 5 183 157 196 6 21 107 70 41 197 111 109 215 116 229 241 167 89 202 52 203 220 160 217 246 30 235 144 235 19 0 0 1 104 210 223 181 52 158 133 105 60 206 60 97 88 35 84 39 241 68 117 46 200 25 178 180 2 135 170 228 237 78 95 141 220 192 61 243 38 81 141 157 147 134 105 20 141 231 139 98 217 141 233 206 38 63 88 41 115 146 165 44 212 80 120 9 35 155 237 10 49 241 130 64 144 5 183 157 196 6 21 107 70 41 197 111 109 215 116 229 241 167 89 202 52 203 220 160 217 246 30 235 144 235 19 0 0 0 92 152 150 20 214 127 232 198 173 9 79 27 3 184 211 18 63 222 243 206 88 162 250 92 190 84 152 234 94 69 155 44 142 240 190 37 73 181 195 210 164 18 87 93 129 136 94 136 136 217 218 51 29 223 183 84 208 218 2 84 239 77 91 212 169 82 20 75 248 125 91 121 11 45 39 139 41 225 254 195 35 239 16 190 22 173 227 229 119 204 69 22 0 1 92 152 150 20 214 127 232 198 173 9 79 27 3 184 211 18 63 222 243 206 88 162 250 92 190 84 152 234 94 69 155 44 142 240 190 37 73 181 195 210 164 18 87 93 129 136 94 136 136 217 218 51 29 223 183 84 208 218 2 84 239 77 91 212 169 82 20 75 248 125 91 121 11 45 39 139 41 225 254 195 35 239 16 190 22 173 227 229 119 204 69 22 0 0 120 44 138 21 104 121 166 168 12 110 50 53 151 231 148 52 129 170 198 240 95 34 68 28 124 55 201 57 159 127 63 21 5 63 2 162 178 197 92 197 192 93 104 136 44 43 255 49 242 182 132 190 94 80 205 87 26 3 171 184 215 205 47 219 227 179 185 205 230 127 65 231 66 123 92 125 163 244 195 94 188 196 160 223 181 5 166 64 111 85 190 120 122 41 201 0 186 192 106 199 252 164 20 92 37 80 149 48 19 150 123 103 189 229 79 223 27 244 74 0 0 1 120 44 138 21 104 121 166 168 12 110 50 53 151 231 148 52 129 170 198 240 95 34 68 28 124 55 201 57 159 127 63 21 5 63 2 162 178 197 92 197 192 93 104 136 44 43 255 49 242 182 132 190 94 80 205 87 26 3 171 184 215 205 47 219 227 179 185 205 230 127 65 231 66 123 92 125 163 244 195 94 188 196 160 223 181 5 166 64 111 85 190 120 122 41 201 0 186 192 106 199 252 164 20 92 37 80 149 48 19 150 123 103 189 229 79 223 27 244 74 0 0 0 100 245 181 98 66 108 43 27 238 39 17 236 216 168 31 46 226 159 160 142 67 146 30 10 164 14 213 242 136 234 225 199 106 255 33 115 237 228 171 8 216 45 122 202 182 141 16 25 154 11 32 53 253 203 2 153 173 247 193 28 139 204 11 42 191 71 206 216 60 1 99 141 204 17 235 245 239 210 176 83 155 175 144 26 254 215 45 202 84 103 74 45 94 174 24 228 158 37 0 0 0 1 100 245 181 98 66 108 43 27 238 39 17 236 216 168 31 46 226 159 160 142 67 146 30 10 164 14 213 242 136 234 225 199 106 255 33 115 237 228 171 8 216 45 122 202 182 141 16 25 154 11 32 53 253 203 2 153 173 247 193 28 139 204 11 42 191 71 206 216 60 1 99 141 204 17 235 245 239 210 176 83 155 175 144 26 254 215 45 202 84 103 74 45 94 174 24 228 158 37 0 0 0 0 104 57 246 11 97 62 119 196 46 75 16 79 108 49 113 219 104 188 179 248 78 58 245 127 216 140 166 196 171 132 59 25 253 51 249 216 140 222 121 230 30 172 32 207 74 205 85 44 90 36 173 79 87 194 82 25 79 135 112 132 221 164 76 173 137 126 195 194 92 248 173 9 87 209 223 59 125 95 65 85 163 122 135 111 167 236 33 52 80 27 61 178 237 205 251 204 39 240 191 179 209 167 168 143 7 1 104 57 246 11 97 62 119 196 46 75 16 79 108 49 113 219 104 188 179 248 78 58 245 127 216 140 166 196 171 132 59 25 253 51 249 216 140 222 121 230 30 172 32 207 74 205 85 44 90 36 173 79 87 194 82 25 79 135 112 132 221 164 76 173 137 126 195 194 92 248 173 9 87 209 223 59 125 95 65 85 163 122 135 111 167 236 33 52 80 27 61 178 237 205 251 204 39 240 191 179 209 167 168 143 7 0 36 163 89 48 170 102 43 220 156 66 109 77 113 21 188 67 203 215 226 3 205 170 236 98 121 244 145 200 70 209 174 177 8 139 184 149 27 1 36 163 89 48 170 102 43 220 156 66 109 77 113 21 188 67 203 215 226 3 205 170 236 98 121 244 145 200 70 209 174 177 8 139 184 149 27 0 92 53 9 22 111 90 93 185 232 66 232 61 190 77 71 90 216 56 212 22 125 84 142 129 138 224 63 243 92 90 116 216 187 231 68 78 132 78 241 87 154 62 85 115 206 103 51 246 75 206 191 127 30 122 123 36 8 228 202 50 139 177 122 8 243 137 70 204 22 54 249 70 184 115 203 134 211 234 65 106 138 66 20 24 187 65 57 199 142 254 18 13 0 1 92 53 9 22 111 90 93 185 232 66 232 61 190 77 71 90 216 56 212 22 125 84 142 129 138 224 63 243 92 90 116 216 187 231 68 78 132 78 241 87 154 62 85 115 206 103 51 246 75 206 191 127 30 122 123 36 8 228 202 50 139 177 122 8 243 137 70 204 22 54 249 70 184 115 203 134 211 234 65 106 138 66 20 24 187 65 57 199 142 254 18 13 0 0 88 149 88 176 69 223 36 37 144 73 234 120 8 99 221 137 178 30 189 44 46 85 157 48 42 245 113 38 233 244 178 224 211 47 14 147 125 42 18 227 2 75 4 61 200 33 227 150 10 58 244 38 21 49 115 166 218 124 93 108 5 73 235 24 7 87 152 177 21 225 23 170 204 54 120 154 213 94 174 62 0 72 37 253 148 145 218 243 1 1 88 149 88 176 69 223 36 37 144 73 234 120 8 99 221 137 178 30 189 44 46 85 157 48 42 245 113 38 233 244 178 224 211 47 14 147 125 42 18 227 2 75 4 61 200 33 227 150 10 58 244 38 21 49 115 166 218 124 93 108 5 73 235 24 7 87 152 177 21 225 23 170 204 54 120 154 213 94 174 62 0 72 37 253 148 145 218 243 1 0 4 30 0 0 0 1 4 30 0 0 0 0 84 155 231 228 201 142 243 71 208 249 176 228 44 166 218 152 155 74 36 194 74 148 67 125 239 134 32 23 215 211 53 175 202 69 44 53 118 45 165 95 123 12 108 231 154 213 28 20 163 249 156 33 65 206 61 154 174 104 60 98 109 32 78 242 212 129 149 248 201 134 148 123 181 199 217 155 194 96 140 22 149 241 60 138 83 1 84 155 231 228 201 142 243 71 208 249 176 228 44 166 218 152 155 74 36 194 74 148 67 125 239 134 32 23 215 211 53 175 202 69 44 53 118 45 165 95 123 12 108 231 154 213 28 20 163 249 156 33 65 206 61 154 174 104 60 98 109 32 78 242 212 129 149 248 201 134 148 123 181 199 217 155 194 96 140 22 149 241 60 138 83 0 92 144 67 10 47 192 191 82 221 35 118 53 159 135 152 112 38 73 15 23 69 58 219 225 247 78 102 170 227 6 163 149 12 249 225 137 246 239 39 40 234 163 207 114 112 115 115 194 219 16 202 159 189 202 35 212 109 38 217 132 76 179 231 7 209 218 188 27 208 113 230 164 84 51 101 32 180 123 194 122 68 150 119 65 252 204 137 177 46 234 227 67 1 1 92 144 67 10 47 192 191 82 221 35 118 53 159 135 152 112 38 73 15 23 69 58 219 225 247 78 102 170 227 6 163 149 12 249 225 137 246 239 39 40 234 163 207 114 112 115 115 194 219 16 202 159 189 202 35 212 109 38 217 132 76 179 231 7 209 218 188 27 208 113 230 164 84 51 101 32 180 123 194 122 68 150 119 65 252 204 137 177 46 234 227 67 1 0 24 72 56 22 141 170 58 90 163 187 180 242 135 44 169 146 74 211 248 249 78 94 0 0 0 1 24 72 56 22 141 170 58 90 163 187 180 242 135 44 169 146 74 211 248 249 78 94 0 0 0 0 84 212 210 42 73 12 25 196 31 47 75 120 243 73 247 127 147 72 96 165 96 14 69 196 39 172 6 5 194 11 134 119 124 92 255 174 158 25 36 41 88 174 179 156 60 218 178 156 41 175 187 120 209 98 0 19 182 231 198 178 95 52 119 23 97 47 127 143 101 176 216 52 159 106 61 182 27 146 186 142 96 231 29 27 0 1 84 212 210 42 73 12 25 196 31 47 75 120 243 73 247 127 147 72 96 165 96 14 69 196 39 172 6 5 194 11 134 119 124 92 255 174 158 25 36 41 88 174 179 156 60 218 178 156 41 175 187 120 209 98 0 19 182 231 198 178 95 52 119 23 97 47 127 143 101 176 216 52 159 106 61 182 27 146 186 142 96 231 29 27 0 0 16 202 192 8 50 72 83 78 188 175 88 50 125 131 102 195 3 1 16 202 192 8 50 72 83 78 188 175 88 50 125 131 102 195 3 0 60 129 235 99 25 168 162 143 14 181 191 24 1 54 4 85 204 63 111 78 71 241 253 45 225 56 177 121 166 226 7 163 1 182 155 9 74 40 35 9 9 175 144 171 35 224 162 163 133 97 35 188 126 220 236 73 96 97 129 14 0 1 60 129 235 99 25 168 162 143 14 181 191 24 1 54 4 85 204 63 111 78 71 241 253 45 225 56 177 121 166 226 7 163 1 182 155 9 74 40 35 9 9 175 144 171 35 224 162 163 133 97 35 188 126 220 236 73 96 97 129 14 0 0 64 108 92 234 131 231 188 232 51 18 198 215 40 15 157 152 141 79 144 203 196 249 187 115 41 230 177 33 50 91 32 10 169 73 162 155 234 98 212 245 92 106 18 104 75 83 194 149 253 23 63 13 64 214 243 154 201 132 100 31 187 255 119 206 203 1 64 108 92 234 131 231 188 232 51 18 198 215 40 15 157 152 141 79 144 203 196 249 187 115 41 230 177 33 50 91 32 10 169 73 162 155 234 98 212 245 92 106 18 104 75 83 194 149 253 23 63 13 64 214 243 154 201 132 100 31 187 255 119 206 203 0 100 234 116 169 65 23 182 136 224 163 211 105 192 204 31 82 240 175 46 102 159 95 158 50 9 145 106 22 60 50 33 177 26 225 82 114 86 212 7 154 44 212 126 161 171 72 116 119 246 52 229 38 173 55 41 107 40 184 253 98 215 24 91 66 142 30 173 123 90 125 69 86 227 60 60 95 206 124 147 44 60 155 141 241 90 83 7 53 206 71 46 134 127 122 180 31 53 82 214 176 0 1 100 234 116 169 65 23 182 136 224 163 211 105 192 204 31 82 240 175 46 102 159 95 158 50 9 145 106 22 60 50 33 177 26 225 82 114 86 212 7 154 44 212 126 161 171 72 116 119 246 52 229 38 173 55 41 107 40 184 253 98 215 24 91 66 142 30 173 123 90 125 69 86 227 60 60 95 206 124 147 44 60 155 141 241 90 83 7 53 206 71 46 134 127 122 180 31 53 82 214 176 0 0 124 246 224 179 231 248 85 24 201 210 110 165 232 153 136 96 155 10 189 255 115 232 19 11 61 42 152 98 194 221 200 42 3 215 220 12 102 106 69 77 69 216 253 146 196 230 240 63 118 205 224 76 129 107 174 183 121 74 199 99 224 180 49 180 47 34 35 35 224 247 193 61 42 51 142 16 105 58 239 223 3 189 5 85 19 221 249 251 255 86 9 113 209 31 184 51 28 17 30 9 254 164 62 237 123 73 56 8 110 166 164 217 88 106 22 85 183 98 156 139 221 73 253 52 0 1 124 246 224 179 231 248 85 24 201 210 110 165 232 153 136 96 155 10 189 255 115 232 19 11 61 42 152 98 194 221 200 42 3 215 220 12 102 106 69 77 69 216 253 146 196 230 240 63 118 205 224 76 129 107 174 183 121 74 199 99 224 180 49 180 47 34 35 35 224 247 193 61 42 51 142 16 105 58 239 223 3 189 5 85 19 221 249 251 255 86 9 113 209 31 184 51 28 17 30 9 254 164 62 237 123 73 56 8 110 166 164 217 88 106 22 85 183 98 156 139 221 73 253 52 0 0 76 114 71 65 89 237 36 19 196 155 136 82 8 202 243 70 78 29 120 129 104 2 108 32 185 184 120 36 214 143 191 219 217 92 173 243 221 253 134 71 240 107 182 126 78 197 54 130 17 174 97 201 95 84 153 156 87 239 78 186 103 226 240 168 109 214 167 102 253 22 173 79 216 165 16 0 0 1 76 114 71 65 89 237 36 19 196 155 136 82 8 202 243 70 78 29 120 129 104 2 108 32 185 184 120 36 214 143 191 219 217 92 173 243 221 253 134 71 240 107 182 126 78 197 54 130 17 174 97 201 95 84 153 156 87 239 78 186 103 226 240 168 109 214 167 102 253 22 173 79 216 165 16 0 0 0 44 205 174 153 159 175 148 18 158 235 107 21 147 172 130 150 6 109 216 1 3 85 18 35 218 2 59 66 219 110 2 146 243 32 186 68 69 178 58 234 207 205 114 206 3 1 44 205 174 153 159 175 148 18 158 235 107 21 147 172 130 150 6 109 216 1 3 85 18 35 218 2 59 66 219 110 2 146 243 32 186 68 69 178 58 234 207 205 114 206 3 0 116 6 227 111 143 56 164 39 218 18 125 60 7 225 195 8 232 184 177 163 16 21 29 165 72 172 201 28 230 132 0 86 23 246 125 104 127 83 109 13 113 149 216 245 166 173 128 120 168 110 19 178 216 69 212 66 94 179 133 240 181 66 121 14 166 89 77 60 143 152 41 85 140 62 121 51 44 123 188 123 173 52 74 2 31 233 7 229 187 139 234 225 45 79 247 235 210 113 240 84 200 66 137 125 254 189 83 79 17 221 213 32 54 4 0 0 0 1 116 6 227 111 143 56 164 39 218 18 125 60 7 225 195 8 232 184 177 163 16 21 29 165 72 172 201 28 230 132 0 86 23 246 125 104 127 83 109 13 113 149 216 245 166 173 128 120 168 110 19 178 216 69 212 66 94 179 133 240 181 66 121 14 166 89 77 60 143 152 41 85 140 62 121 51 44 123 188 123 173 52 74 2 31 233 7 229 187 139 234 225 45 79 247 235 210 113 240 84 200 66 137 125 254 189 83 79 17 221 213 32 54 4 0 0 0 0 76 180 196 94 156 54 195 58 2 39 205 18 27 183 204 87 155 155 103 140 143 118 225 162 141 198 191 103 246 251 35 33 200 114 204 108 157 138 202 183 109 135 225 247 167 85 247 149 166 13 150 140 115 191 119 88 74 150 209 45 234 64 143 177 65 18 230 195 62 134 19 33 86 117 177 249 0 1 76 180 196 94 156 54 195 58 2 39 205 18 27 183 204 87 155 155 103 140 143 118 225 162 141 198 191 103 246 251 35 33 200 114 204 108 157 138 202 183 109 135 225 247 167 85 247 149 166 13 150 140 115 191 119 88 74 150 209 45 234 64 143 177 65 18 230 195 62 134 19 33 86 117 177 249 0 0 104 77 194 158 250 209 247 60 209 53 237 237 50 69 209 78 167 168 156 255 102 176 89 29 124 236 2 92 64 171 213 222 61 154 151 17 221 163 26 188 48 218 181 25 207 24 78 174 96 77 4 92 36 81 77 82 53 226 55 109 24 229 73 137 228 213 186 236 231 140 148 101 63 106 130 255 94 160 246 229 63 254 107 254 48 15 56 43 131 180 38 166 178 234 233 86 61 2 85 154 172 81 81 66 9 1 104 77 194 158 250 209 247 60 209 53 237 237 50 69 209 78 167 168 156 255 102 176 89 29 124 236 2 92 64 171 213 222 61 154 151 17 221 163 26 188 48 218 181 25 207 24 78 174 96 77 4 92 36 81 77 82 53 226 55 109 24 229 73 137 228 213 186 236 231 140 148 101 63 106 130 255 94 160 246 229 63 254 107 254 48 15 56 43 131 180 38 166 178 234 233 86 61 2 85 154 172 81 81 66 9 0 32 159 255 244 214 47 170 4 34 47 46 170 236 221 0 119 135 29 199 192 21 169 211 135 216 147 25 112 187 63 0 0 0 1 32 159 255 244 214 47 170 4 34 47 46 170 236 221 0 119 135 29 199 192 21 169 211 135 216 147 25 112 187 63 0 0 0 0 4 136 102 2 0 1 4 136 102 2 0 0 100 182 114 42 214 204 210 88 197 7 199 39 124 27 200 142 13 162 188 42 112 118 92 202 215 78 160 112 52 72 100 65 30 205 199 86 182 35 211 245 70 139 86 183 94 139 115 30 32 188 225 10 237 169 169 192 188 84 209 158 78 210 48 148 84 141 6 11 247 62 239 52 100 249 186 173 138 163 134 212 20 243 14 250 162 155 177 89 175 243 3 44 202 80 198 163 43 3 0 0 0 1 100 182 114 42 214 204 210 88 197 7 199 39 124 27 200 142 13 162 188 42 112 118 92 202 215 78 160 112 52 72 100 65 30 205 199 86 182 35 211 245 70 139 86 183 94 139 115 30 32 188 225 10 237 169 169 192 188 84 209 158 78 210 48 148 84 141 6 11 247 62 239 52 100 249 186 173 138 163 134 212 20 243 14 250 162 155 177 89 175 243 3 44 202 80 198 163 43 3 0 0 0 0 108 99 120 242 101 168 63 63 168 132 177 224 65 190 4 179 252 98 42 247 140 190 31 23 0 117 179 116 199 98 202 211 102 139 65 63 177 51 13 22 232 149 208 247 101 128 25 173 165 160 191 102 145 173 51 230 242 244 7 170 233 242 115 73 120 62 67 64 36 3 41 74 159 24 59 71 166 190 104 193 40 86 159 53 253 65 67 111 21 48 43 46 214 182 41 210 212 59 110 156 33 239 225 212 27 107 0 0 0 1 108 99 120 242 101 168 63 63 168 132 177 224 65 190 4 179 252 98 42 247 140 190 31 23 0 117 179 116 199 98 202 211 102 139 65 63 177 51 13 22 232 149 208 247 101 128 25 173 165 160 191 102 145 173 51 230 242 244 7 170 233 242 115 73 120 62 67 64 36 3 41 74 159 24 59 71 166 190 104 193 40 86 159 53 253 65 67 111 21 48 43 46 214 182 41 210 212 59 110 156 33 239 225 212 27 107 0 0 0 0 36 182 35 41 118 252 144 79 94 31 128 26 169 129 98 79 185 77 204 158 170 99 105 83 166 57 204 35 71 231 68 17 161 7 0 0 0 1 36 182 35 41 118 252 144 79 94 31 128 26 169 129 98 79 185 77 204 158 170 99 105 83 166 57 204 35 71 231 68 17 161 7 0 0 0 0 108 19 121 68 172 165 141 93 53 202 225 143 125 21 127 168 150 223 142 78 163 244 135 194 197 17 161 238 159 225 207 232 231 141 188 186 185 170 238 141 145 164 234 7 144 31 97 144 227 0 100 164 181 137 33 28 59 136 10 218 56 168 254 166 106 145 203 39 49 163 15 174 143 31 5 178 130 153 84 87 87 61 221 163 29 252 65 53 122 68 235 160 127 229 67 219 215 172 22 9 124 37 73 237 104 38 0 0 0 1 108 19 121 68 172 165 141 93 53 202 225 143 125 21 127 168 150 223 142 78 163 244 135 194 197 17 161 238 159 225 207 232 231 141 188 186 185 170 238 141 145 164 234 7 144 31 97 144 227 0 100 164 181 137 33 28 59 136 10 218 56 168 254 166 106 145 203 39 49 163 15 174 143 31 5 178 130 153 84 87 87 61 221 163 29 252 65 53 122 68 235 160 127 229 67 219 215 172 22 9 124 37 73 237 104 38 0 0 0 0 68 131 157 197 45 185 223 236 53 246 15 184 5 182 184 23 147 3 15 46 179 218 118 209 114 37 235 220 187 201 154 47 207 166 122 35 26 91 3 127 154 179 249 232 233 237 129 34 68 202 138 161 0 13 77 112 252 203 92 187 188 230 39 55 132 247 0 0 0 1 68 131 157 197 45 185 223 236 53 246 15 184 5 182 184 23 147 3 15 46 179 218 118 209 114 37 235 220 187 201 154 47 207 166 122 35 26 91 3 127 154 179 249 232 233 237 129 34 68 202 138 161 0 13 77 112 252 203 92 187 188 230 39 55 132 247 0 0 0 0 124 215 194 0 199 219 223 102 242 204 248 124 17 112 73 119 161 49 131 84 207 207 67 43 12 67 150 210 126 148 3 13 241 16 225 134 108 33 87 2 157 76 211 58 133 210 144 225 220 56 131 147 199 231 84 32 218 43 221 252 165 30 119 252 165 229 211 167 197 150 182 197 108 234 8 252 127 239 35 237 26 80 187 183 139 105 103 168 55 42 221 202 112 37 234 50 199 248 234 249 61 133 62 20 172 135 114 63 241 161 127 1 136 155 71 88 83 222 156 240 240 1 0 0 0 1 124 215 194 0 199 219 223 102 242 204 248 124 17 112 73 119 161 49 131 84 207 207 67 43 12 67 150 210 126 148 3 13 241 16 225 134 108 33 87 2 157 76 211 58 133 210 144 225 220 56 131 147 199 231 84 32 218 43 221 252 165 30 119 252 165 229 211 167 197 150 182 197 108 234 8 252 127 239 35 237 26 80 187 183 139 105 103 168 55 42 221 202 112 37 234 50 199 248 234 249 61 133 62 20 172 135 114 63 241 161 127 1 136 155 71 88 83 222 156 240 240 1 0 0 0 0 92 77 228 31 76 241 138 249 4 98 9 115 184 112 82 183 229 236 138 162 82 102 251 28 188 12 113 181 158 79 211 194 251 196 166 73 83 83 80 42 120 93 243 152 162 232 39 205 85 189 126 54 242 156 193 86 191 44 44 252 55 14 21 27 116 194 191 250 7 74 203 105 99 89 106 178 14 2 236 178 68 170 192 252 120 41 130 72 87 206 11 0 0 1 92 77 228 31 76 241 138 249 4 98 9 115 184 112 82 183 229 236 138 162 82 102 251 28 188 12 113 181 158 79 211 194 251 196 166 73 83 83 80 42 120 93 243 152 162 232 39 205 85 189 126 54 242 156 193 86 191 44 44 252 55 14 21 27 116 194 191 250 7 74 203 105 99 89 106 178 14 2 236 178 68 170 192 252 120 41 130 72 87 206 11 0 0 0 56 134 225 44 69 119 64 234 84 89 109 244 85 126 103 94 170 253 103 245 228 230 48 38 166 108 164 43 22 74 31 25 224 196 60 126 145 211 177 41 97 248 197 232 65 242 142 255 87 64 104 166 218 221 0 0 0 1 56 134 225 44 69 119 64 234 84 89 109 244 85 126 103 94 170 253 103 245 228 230 48 38 166 108 164 43 22 74 31 25 224 196 60 126 145 211 177 41 97 248 197 232 65 242 142 255 87 64 104 166 218 221 0 0 0 0 116 229 172 191 36 121 40 254 104 25 228 24 190 128 20 169 193 240 145 60 136 35 241 68 254 62 193 45 112 102 236 245 29 64 94 62 47 36 42 252 13 28 27 219 9 245 94 181 136 19 177 1 212 5 30 243 157 117 94 95 128 151 156 4 203 11 190 27 0 62 198 137 167 143 73 204 232 2 248 129 253 159 82 186 78 87 59 101 197 100 160 249 30 152 93 125 199 107 24 125 64 176 236 44 0 171 123 140 55 132 181 2 66 228 115 0 0 1 116 229 172 191 36 121 40 254 104 25 228 24 190 128 20 169 193 240 145 60 136 35 241 68 254 62 193 45 112 102 236 245 29 64 94 62 47 36 42 252 13 28 27 219 9 245 94 181 136 19 177 1 212 5 30 243 157 117 94 95 128 151 156 4 203 11 190 27 0 62 198 137 167 143 73 204 232 2 248 129 253 159 82 186 78 87 59 101 197 100 160 249 30 152 93 125 199 107 24 125 64 176 236 44 0 171 123 140 55 132 181 2 66 228 115 0 0 0 56 242 178 209 149 127 105 215 100 20 77 91 129 188 44 67 89 61 245 2 145 100 176 98 45 200 226 215 226 171 178 81 56 196 210 25 211 24 236 80 114 182 153 187 70 254 227 193 36 163 1 237 117 87 122 2 0 1 56 242 178 209 149 127 105 215 100 20 77 91 129 188 44 67 89 61 245 2 145 100 176 98 45 200 226 215 226 171 178 81 56 196 210 25 211 24 236 80 114 182 153 187 70 254 227 193 36 163 1 237 117 87 122 2 0 0 124 134 51 146 212 174 146 101 32 54 80 14 156 174 236 212 195 81 90 58 116 149 201 205 7 130 14 255 190 241 205 207 249 221 121 67 167 233 3 91 49 79 77 255 115 246 112 74 5 197 106 119 29 238 202 62 53 27 223 236 152 234 237 36 19 234 248 83 103 87 80 106 110 27 202 134 182 123 143 10 59 147 105 206 20 112 193 190 220 192 38 172 241 167 90 129 71 185 246 137 86 12 195 102 17 186 107 173 97 103 140 196 114 119 155 196 217 44 13 55 170 195 147 93 0 1 124 134 51 146 212 174 146 101 32 54 80 14 156 174 236 212 195 81 90 58 116 149 201 205 7 130 14 255 190 241 205 207 249 221 121 67 167 233 3 91 49 79 77 255 115 246 112 74 5 197 106 119 29 238 202 62 53 27 223 236 152 234 237 36 19 234 248 83 103 87 80 106 110 27 202 134 182 123 143 10 59 147 105 206 20 112 193 190 220 192 38 172 241 167 90 129 71 185 246 137 86 12 195 102 17 186 107 173 97 103 140 196 114 119 155 196 217 44 13 55 170 195 147 93 0 0 76 252 151 248 45 49 178 79 128 161 10 102 252 132 63 0 196 234 37 213 196 19 233 200 48 79 135 72 224 67 120 56 21 130 243 118 44 119 71 20 190 181 163 216 126 133 133 98 134 74 16 85 129 28 141 49 184 195 10 187 170 152 61 100 174 129 141 139 49 17 137 166 184 197 148 14 0 1 76 252 151 248 45 49 178 79 128 161 10 102 252 132 63 0 196 234 37 213 196 19 233 200 48 79 135 72 224 67 120 56 21 130 243 118 44 119 71 20 190 181 163 216 126 133 133 98 134 74 16 85 129 28 141 49 184 195 10 187 170 152 61 100 174 129 141 139 49 17 137 166 184 197 148 14 0 0 72 201 189 132 146 184 73 235 58 191 160 218 55 99 221 69 240 85 82 95 206 66 232 212 65 234 63 77 180 226 245 185 90 39 91 117 118 212 95 63 202 231 49 115 110 103 125 28 251 84 217 64 21 37 74 176 91 16 243 99 51 19 229 146 28 76 167 138 98 3 86 2 0 1 72 201 189 132 146 184 73 235 58 191 160 218 55 99 221 69 240 85 82 95 206 66 232 212 65 234 63 77 180 226 245 185 90 39 91 117 118 212 95 63 202 231 49 115 110 103 125 28 251 84 217 64 21 37 74 176 91 16 243 99 51 19 229 146 28 76 167 138 98 3 86 2 0 0 24 4 127 113 119 170 147 209 114 124 184 151 70 216 77 57 33 8 170 193 201 10 0 0 0 1 24 4 127 113 119 170 147 209 114 124 184 151 70 216 77 57 33 8 170 193 201 10 0 0 0 0 20 221 119 146 70 38 139 89 31 158 39 212 71 222 63 236 44 183 75 0 0 1 20 221 119 146 70 38 139 89 31 158 39 212 71 222 63 236 44 183 75 0 0 0 100 15 190 40 142 118 234 227 167 165 244 200 26 49 57 37 9 217 227 141 192 139 18 100 130 160 53 103 125 170 120 113 53 121 232 23 248 218 111 12 114 85 152 168 69 138 153 228 55 175 99 6 29 234 191 118 238 18 250 139 127 248 148 96 36 236 164 252 127 71 230 13 95 200 86 106 201 201 168 74 148 207 42 56 34 173 114 89 220 58 197 209 56 194 93 253 36 57 2 0 0 1 100 15 190 40 142 118 234 227 167 165 244 200 26 49 57 37 9 217 227 141 192 139 18 100 130 160 53 103 125 170 120 113 53 121 232 23 248 218 111 12 114 85 152 168 69 138 153 228 55 175 99 6 29 234 191 118 238 18 250 139 127 248 148 96 36 236 164 252 127 71 230 13 95 200 86 106 201 201 168 74 148 207 42 56 34 173 114 89 220 58 197 209 56 194 93 253 36 57 2 0 0 0 20 241 138 87 82 7 150 25 154 252 91 216 29 106 84 123 71 145 238 230 5 1 20 241 138 87 82 7 150 25 154 252 91 216 29 106 84 123 71 145 238 230 5 0 32 151 63 193 99 4 229 248 206 122 164 94 141 132 110 0 199 239 244 9 150 62 180 68 138 132 112 26 31 217 46 0 0 1 32 151 63 193 99 4 229 248 206 122 164 94 141 132 110 0 199 239 244 9 150 62 180 68 138 132 112 26 31 217 46 0 0 0 36 151 219 5 222 229 79 21 136 176 12 133 59 166 175 203 218 102 58 176 141 26 127 152 21 81 49 214 17 132 22 14 243 177 3 0 0 1 36 151 219 5 222 229 79 21 136 176 12 133 59 166 175 203 218 102 58 176 141 26 127 152 21 81 49 214 17 132 22 14 243 177 3 0 0 0 104 6 168 179 178 70 132 236 140 85 20 22 237 179 132 40 18 248 209 250 75 115 245 45 67 206 107 231 237 102 198 61 0 53 181 149 233 167 119 49 80 107 58 194 191 82 80 182 33 90 50 185 65 82 236 47 123 143 42 21 75 76 220 97 26 140 95 213 177 133 178 200 249 254 187 252 127 168 64 33 103 133 36 183 203 53 160 28 249 121 153 43 163 187 30 115 14 218 222 176 173 69 117 99 12 1 104 6 168 179 178 70 132 236 140 85 20 22 237 179 132 40 18 248 209 250 75 115 245 45 67 206 107 231 237 102 198 61 0 53 181 149 233 167 119 49 80 107 58 194 191 82 80 182 33 90 50 185 65 82 236 47 123 143 42 21 75 76 220 97 26 140 95 213 177 133 178 200 249 254 187 252 127 168 64 33 103 133 36 183 203 53 160 28 249 121 153 43 163 187 30 115 14 218 222 176 173 69 117 99 12 0 108 2 212 34 173 196 82 79 56 112 170 220 63 200 109 239 119 47 163 110 174 76 171 32 84 196 96 74 147 73 116 212 7 81 2 123 170 250 193 70 154 132 132 185 57 39 161 95 139 69 234 233 243 142 195 223 169 214 193 142 130 202 53 250 215 1 232 72 89 42 138 164 214 96 81 207 117 204 208 64 159 221 205 19 127 120 90 20 23 72 45 155 78 40 43 86 112 83 186 201 240 77 86 191 92 249 160 247 61 1 108 2 212 34 173 196 82 79 56 112 170 220 63 200 109 239 119 47 163 110 174 76 171 32 84 196 96 74 147 73 116 212 7 81 2 123 170 250 193 70 154 132 132 185 57 39 161 95 139 69 234 233 243 142 195 223 169 214 193 142 130 202 53 250 215 1 232 72 89 42 138 164 214 96 81 207 117 204 208 64 159 221 205 19 127 120 90 20 23 72 45 155 78 40 43 86 112 83 186 201 240 77 86 191 92 249 160 247 61 0 128 102 251 156 92 43 108 29 62 40 215 42 15 198 118 248 50 157 25 129 219 206 70 124 249 193 82 122 51 209 211 166 198 129 204 78 210 123 124 106 191 69 198 115 9 187 105 170 16 189 25 66 30 61 214 177 166 27 0 66 226 174 106 52 23 197 236 68 43 88 169 245 109 62 252 144 219 129 154 127 116 74 210 197 53 171 56 209 150 200 215 71 80 187 84 179 235 71 14 27 0 159 145 132 91 170 69 4 77 60 185 156 0 93 72 67 68 185 235 189 29 178 144 42 227 35 59 27 0 1 128 102 251 156 92 43 108 29 62 40 215 42 15 198 118 248 50 157 25 129 219 206 70 124 249 193 82 122 51 209 211 166 198 129 204 78 210 123 124 106 191 69 198 115 9 187 105 170 16 189 25 66 30 61 214 177 166 27 0 66 226 174 106 52 23 197 236 68 43 88 169 245 109 62 252 144 219 129 154 127 116 74 210 197 53 171 56 209 150 200 215 71 80 187 84 179 235 71 14 27 0 159 145 132 91 170 69 4 77 60 185 156 0 93 72 67 68 185 235 189 29 178 144 42 227 35 59 27 0 0 36 22 179 130 104 210 45 171 95 5 140 87 49 187 173 206 147 141 26 50 138 30 228 117 173 59 57 138 187 138 30 79 102 10 0 0 0 1 36 22 179 130 104 210 45 171 95 5 140 87 49 187 173 206 147 141 26 50 138 30 228 117 173 59 57 138 187 138 30 79 102 10 0 0 0 0 44 245 222 165 23 160 186 7 2 211 238 67 132 133 157 254 89 199 178 45 73 151 206 197 254 6 172 31 88 199 204 161 72 65 160 25 246 142 223 123 52 172 12 6 0 1 44 245 222 165 23 160 186 7 2 211 238 67 132 133 157 254 89 199 178 45 73 151 206 197 254 6 172 31 88 199 204 161 72 65 160 25 246 142 223 123 52 172 12 6 0 0 108 222 47 68 13 28 124 145 191 235 84 137 87 165 230 34 132 42 90 242 140 248 118 51 137 4 68 91 156 194 220 89 46 217 200 72 50 124 24 209 194 179 150 236 12 223 90 150 72 220 112 234 137 123 179 108 65 16 250 73 68 13 219 174 119 68 216 117 5 143 105 238 147 162 128 99 201 30 204 31 130 46 147 73 191 185 192 73 212 83 18 90 106 146 126 18 59 63 194 86 25 42 52 82 92 6 0 0 0 1 108 222 47 68 13 28 124 145 191 235 84 137 87 165 230 34 132 42 90 242 140 248 118 51 137 4 68 91 156 194 220 89 46 217 200 72 50 124 24 209 194 179 150 236 12 223 90 150 72 220 112 234 137 123 179 108 65 16 250 73 68 13 219 174 119 68 216 117 5 143 105 238 147 162 128 99 201 30 204 31 130 46 147 73 191 185 192 73 212 83 18 90 106 146 126 18 59 63 194 86 25 42 52 82 92 6 0 0 0 0 40 74 204 182 19 172 57 74 106 161 11 250 172 174 63 33 117 146 108 133 108 20 20 28 215 14 216 35 120 250 72 181 31 75 237 185 64 125 38 30 0 1 40 74 204 182 19 172 57 74 106 161 11 250 172 174 63 33 117 146 108 133 108 20 20 28 215 14 216 35 120 250 72 181 31 75 237 185 64 125 38 30 0 0 32 39 90 158 132 213 173 24 145 199 200 240 251 85 122 152 148 224 56 26 234 37 58 180 82 137 37 60 8 144 85 118 5 1 32 39 90 158 132 213 173 24 145 199 200 240 251 85 122 152 148 224 56 26 234 37 58 180 82 137 37 60 8 144 85 118 5 0 4 138 84 0 0 1 4 138 84 0 0 0 120 6 116 242 108 248 14 140 127 243 249 231 147 68 151 120 38 231 8 34 6 106 4 211 91 3 66 139 242 76 75 130 178 43 63 174 27 78 5 184 165 84 187 23 158 140 41 71 59 22 178 59 239 6 145 6 103 216 172 37 75 231 145 41 56 213 208 27 181 52 16 183 237 193 209 238 106 47 104 214 15 82 217 35 168 104 64 76 104 111 95 151 127 241 27 86 63 95 186 251 237 14 164 119 230 211 234 83 245 143 10 244 120 135 32 125 144 92 8 189 0 1 120 6 116 242 108 248 14 140 127 243 249 231 147 68 151 120 38 231 8 34 6 106 4 211 91 3 66 139 242 76 75 130 178 43 63 174 27 78 5 184 165 84 187 23 158 140 41 71 59 22 178 59 239 6 145 6 103 216 172 37 75 231 145 41 56 213 208 27 181 52 16 183 237 193 209 238 106 47 104 214 15 82 217 35 168 104 64 76 104 111 95 151 127 241 27 86 63 95 186 251 237 14 164 119 230 211 234 83 245 143 10 244 120 135 32 125 144 92 8 189 0 0 28 169 164 216 5 23 138 199 97 227 119 26 63 15 87 131 107 175 132 108 223 46 17 101 176 195 214 100 232 1 28 169 164 216 5 23 138 199 97 227 119 26 63 15 87 131 107 175 132 108 223 46 17 101 176 195 214 100 232 0 48 8 170 244 92 198 184 32 64 24 118 241 85 66 189 103 28 33 244 60 230 74 7 243 100 2 1 93 74 149 165 150 65 102 220 228 186 83 101 123 141 123 109 182 122 105 0 0 0 1 48 8 170 244 92 198 184 32 64 24 118 241 85 66 189 103 28 33 244 60 230 74 7 243 100 2 1 93 74 149 165 150 65 102 220 228 186 83 101 123 141 123 109 182 122 105 0 0 0 0 120 12 158 20 122 77 167 176 86 158 51 230 99 136 241 101 17 244 121 59 87 103 26 111 205 53 244 235 242 229 169 15 224 95 241 248 47 71 217 197 177 238 46 133 175 43 178 246 61 15 216 239 68 140 164 169 9 17 109 185 231 2 170 188 140 250 123 194 232 88 232 26 60 214 152 106 181 39 234 136 137 58 62 209 190 251 104 89 19 70 178 56 124 109 18 185 167 142 60 123 228 26 54 187 187 148 203 130 114 248 49 111 198 191 107 86 222 3 0 0 0 1 120 12 158 20 122 77 167 176 86 158 51 230 99 136 241 101 17 244 121 59 87 103 26 111 205 53 244 235 242 229 169 15 224 95 241 248 47 71 217 197 177 238 46 133 175 43 178 246 61 15 216 239 68 140 164 169 9 17 109 185 231 2 170 188 140 250 123 194 232 88 232 26 60 214 152 106 181 39 234 136 137 58 62 209 190 251 104 89 19 70 178 56 124 109 18 185 167 142 60 123 228 26 54 187 187 148 203 130 114 248 49 111 198 191 107 86 222 3 0 0 0 0 28 105 179 233 126 169 174 183 251 227 117 195 127 211 122 235 34 108 161 29 184 19 156 152 225 139 6 0 0 1 28 105 179 233 126 169 174 183 251 227 117 195 127 211 122 235 34 108 161 29 184 19 156 152 225 139 6 0 0 0 112 107 214 160 47 12 148 181 229 136 85 57 117 58 49 175 91 20 92 201 244 247 222 130 215 158 98 242 146 190 210 201 180 77 219 243 130 159 138 227 73 54 255 186 170 144 106 170 66 197 143 127 162 210 122 37 99 171 90 242 115 145 250 57 97 176 167 16 225 132 49 247 59 22 25 236 36 64 252 125 139 145 215 22 92 228 240 79 244 183 178 12 93 194 169 217 159 169 69 179 171 96 5 35 137 33 198 85 237 12 0 0 0 1 112 107 214 160 47 12 148 181 229 136 85 57 117 58 49 175 91 20 92 201 244 247 222 130 215 158 98 242 146 190 210 201 180 77 219 243 130 159 138 227 73 54 255 186 170 144 106 170 66 197 143 127 162 210 122 37 99 171 90 242 115 145 250 57 97 176 167 16 225 132 49 247 59 22 25 236 36 64 252 125 139 145 215 22 92 228 240 79 244 183 178 12 93 194 169 217 159 169 69 179 171 96 5 35 137 33 198 85 237 12 0 0 0 0 36 151 236 140 234 49 95 40 136 48 181 242 198 107 168 119 133 33 148 222 230 48 187 177 235 54 92 147 200 220 8 9 80 3 0 0 0 1 36 151 236 140 234 49 95 40 136 48 181 242 198 107 168 119 133 33 148 222 230 48 187 177 235 54 92 147 200 220 8 9 80 3 0 0 0 0 124 86 110 24 37 97 222 163 92 216 221 199 229 79 95 24 16 74 176 194 98 40 169 140 19 1 205 231 70 185 36 255 18 60 202 214 208 120 214 232 112 172 228 176 230 94 127 136 74 11 44 237 249 68 118 244 151 238 132 77 38 186 252 14 206 146 197 57 245 192 244 29 199 74 59 195 148 69 151 165 29 107 182 98 147 191 148 189 200 184 33 221 44 102 236 230 236 155 131 213 212 11 163 71 97 118 61 218 110 71 189 129 17 181 221 250 137 80 48 231 83 123 104 6 0 1 124 86 110 24 37 97 222 163 92 216 221 199 229 79 95 24 16 74 176 194 98 40 169 140 19 1 205 231 70 185 36 255 18 60 202 214 208 120 214 232 112 172 228 176 230 94 127 136 74 11 44 237 249 68 118 244 151 238 132 77 38 186 252 14 206 146 197 57 245 192 244 29 199 74 59 195 148 69 151 165 29 107 182 98 147 191 148 189 200 184 33 221 44 102 236 230 236 155 131 213 212 11 163 71 97 118 61 218 110 71 189 129 17 181 221 250 137 80 48 231 83 123 104 6 0 0 80 243 176 186 126 186 98 210 179 162 140 92 40 240 184 134 105 0 157 103 36 223 108 115 65 73 109 222 11 169 151 183 215 249 45 86 167 172 26 95 222 130 112 5 193 174 61 230 154 13 242 26 53 125 184 23 119 6 116 85 81 153 220 146 138 224 238 242 57 50 24 89 106 223 20 181 86 96 139 192 0 1 80 243 176 186 126 186 98 210 179 162 140 92 40 240 184 134 105 0 157 103 36 223 108 115 65 73 109 222 11 169 151 183 215 249 45 86 167 172 26 95 222 130 112 5 193 174 61 230 154 13 242 26 53 125 184 23 119 6 116 85 81 153 220 146 138 224 238 242 57 50 24 89 106 223 20 181 86 96 139 192 0 0 100 118 189 65 124 187 124 164 181 40 78 215 14 181 239 248 104 169 212 147 203 95 26 103 54 4 23 49 26 46 240 31 57 71 166 134 221 134 146 219 246 49 7 96 225 138 247 198 120 76 183 208 201 100 120 240 147 60 217 93 237 131 48 5 244 23 233 221 83 229 102 159 120 118 222 134 200 86 131 193 55 124 183 137 148 160 79 166 91 219 240 18 236 83 72 210 216 101 108 113 68 1 100 118 189 65 124 187 124 164 181 40 78 215 14 181 239 248 104 169 212 147 203 95 26 103 54 4 23 49 26 46 240 31 57 71 166 134 221 134 146 219 246 49 7 96 225 138 247 198 120 76 183 208 201 100 120 240 147 60 217 93 237 131 48 5 244 23 233 221 83 229 102 159 120 118 222 134 200 86 131 193 55 124 183 137 148 160 79 166 91 219 240 18 236 83 72 210 216 101 108 113 68 0 64 6 22 71 2 163 86 17 242 164 39 109 95 160 109 98 241 37 105 112 221 113 19 63 140 96 143 87 147 41 36 27 242 55 158 16 197 226 52 235 172 133 128 179 181 251 150 32 196 95 149 76 252 69 10 230 30 27 76 224 226 22 0 0 0 1 64 6 22 71 2 163 86 17 242 164 39 109 95 160 109 98 241 37 105 112 221 113 19 63 140 96 143 87 147 41 36 27 242 55 158 16 197 226 52 235 172 133 128 179 181 251 150 32 196 95 149 76 252 69 10 230 30 27 76 224 226 22 0 0 0 0 128 30 130 103 205 32 243 152 123 79 104 19 33 177 209 230 129 178 23 223 13 94 146 223 35 144 45 101 240 232 191 92 122 248 142 90 70 70 227 195 145 191 197 239 106 26 240 233 128 67 75 182 93 107 72 57 103 203 190 221 242 163 253 180 159 146 253 103 81 208 252 1 223 226 217 70 222 240 174 35 247 131 232 230 20 50 149 109 33 236 254 14 141 202 198 2 116 168 2 254 234 211 168 142 232 27 76 165 171 140 74 161 29 242 180 17 221 182 28 140 165 153 167 81 47 103 223 10 0 1 128 30 130 103 205 32 243 152 123 79 104 19 33 177 209 230 129 178 23 223 13 94 146 223 35 144 45 101 240 232 191 92 122 248 142 90 70 70 227 195 145 191 197 239 106 26 240 233 128 67 75 182 93 107 72 57 103 203 190 221 242 163 253 180 159 146 253 103 81 208 252 1 223 226 217 70 222 240 174 35 247 131 232 230 20 50 149 109 33 236 254 14 141 202 198 2 116 168 2 254 234 211 168 142 232 27 76 165 171 140 74 161 29 242 180 17 221 182 28 140 165 153 167 81 47 103 223 10 0 0 48 150 89 14 218 228 227 23 162 153 39 113 34 98 183 194 25 93 68 57 205 28 17 6 69 82 191 227 207 100 5 188 188 211 209 220 205 0 146 180 251 104 31 119 91 104 1 0 0 1 48 150 89 14 218 228 227 23 162 153 39 113 34 98 183 194 25 93 68 57 205 28 17 6 69 82 191 227 207 100 5 188 188 211 209 220 205 0 146 180 251 104 31 119 91 104 1 0 0 0 12 3 75 50 16 21 240 211 149 188 0 0 0 1 12 3 75 50 16 21 240 211 149 188 0 0 0 0 108 9 115 108 68 232 102 178 176 69 243 217 106 209 14 224 172 167 195 216 60 119 98 115 232 110 47 157 119 32 78 224 248 168 59 100 46 75 172 15 39 92 41 128 82 192 201 101 82 196 22 185 109 161 212 23 243 181 215 188 245 6 226 125 224 129 249 88 9 231 215 83 203 0 1 5 225 190 75 41 64 109 105 106 37 227 156 251 13 180 250 104 241 34 187 224 79 84 147 11 127 35 64 121 111 143 12 0 0 1 108 9 115 108 68 232 102 178 176 69 243 217 106 209 14 224 172 167 195 216 60 119 98 115 232 110 47 157 119 32 78 224 248 168 59 100 46 75 172 15 39 92 41 128 82 192 201 101 82 196 22 185 109 161 212 23 243 181 215 188 245 6 226 125 224 129 249 88 9 231 215 83 203 0 1 5 225 190 75 41 64 109 105 106 37 227 156 251 13 180 250 104 241 34 187 224 79 84 147 11 127 35 64 121 111 143 12 0 0 0 104 240 35 102 147 107 156 95 120 67 253 248 209 46 242 211 131 200 126 89 191 255 206 143 125 130 26 163 12 32 199 40 52 166 9 162 113 48 113 189 72 74 18 54 6 99 229 23 115 221 174 124 195 235 108 45 255 154 244 4 181 164 158 200 138 77 6 47 98 56 178 18 75 69 235 225 139 243 201 174 122 249 136 131 59 94 43 192 187 209 135 159 123 162 213 155 59 184 180 92 174 163 38 0 0 1 104 240 35 102 147 107 156 95 120 67 253 248 209 46 242 211 131 200 126 89 191 255 206 143 125 130 26 163 12 32 199 40 52 166 9 162 113 48 113 189 72 74 18 54 6 99 229 23 115 221 174 124 195 235 108 45 255 154 244 4 181 164 158 200 138 77 6 47 98 56 178 18 75 69 235 225 139 243 201 174 122 249 136 131 59 94 43 192 187 209 135 159 123 162 213 155 59 184 180 92 174 163 38 0 0 0 76 34 44 18 251 194 132 188 93 116 144 0 196 15 253 248 161 78 252 35 178 201 70 179 45 245 2 116 179 119 55 186 117 38 191 38 14 139 33 131 60 35 40 0 31 70 182 70 55 167 178 147 137 65 30 203 93 63 183 214 107 14 138 249 141 189 54 170 164 36 100 151 195 142 247 0 1 1 76 34 44 18 251 194 132 188 93 116 144 0 196 15 253 248 161 78 252 35 178 201 70 179 45 245 2 116 179 119 55 186 117 38 191 38 14 139 33 131 60 35 40 0 31 70 182 70 55 167 178 147 137 65 30 203 93 63 183 214 107 14 138 249 141 189 54 170 164 36 100 151 195 142 247 0 1 0 76 79 161 242 148 36 174 71 109 70 137 27 172 124 50 231 16 178 199 67 3 78 176 12 53 168 39 253 247 13 21 191 128 38 67 12 15 248 234 73 154 95 171 123 99 52 42 32 229 121 208 121 181 151 154 103 80 7 41 152 206 129 106 69 208 252 39 163 130 241 51 69 244 247 1 5 121 1 76 79 161 242 148 36 174 71 109 70 137 27 172 124 50 231 16 178 199 67 3 78 176 12 53 168 39 253 247 13 21 191 128 38 67 12 15 248 234 73 154 95 171 123 99 52 42 32 229 121 208 121 181 151 154 103 80 7 41 152 206 129 106 69 208 252 39 163 130 241 51 69 244 247 1 5 121 0 72 100 73 185 231 4 112 172 84 227 126 234 51 137 221 166 192 16 157 41 74 141 121 176 14 135 245 170 38 223 239 224 207 235 164 137 197 183 43 64 0 12 216 240 6 61 23 238 237 201 225 110 75 253 193 88 168 185 218 43 229 167 97 130 102 214 215 134 90 204 214 6 0 1 72 100 73 185 231 4 112 172 84 227 126 234 51 137 221 166 192 16 157 41 74 141 121 176 14 135 245 170 38 223 239 224 207 235 164 137 197 183 43 64 0 12 216 240 6 61 23 238 237 201 225 110 75 253 193 88 168 185 218 43 229 167 97 130 102 214 215 134 90 204 214 6 0 0 96 219 203 221 208 224 159 230 219 11 100 135 13 4 127 208 103 80 48 213 73 245 143 157 122 152 178 240 239 253 126 244 30 239 102 14 87 67 14 70 171 224 149 9 84 107 219 85 124 178 61 180 47 218 225 163 193 116 189 130 11 146 64 142 109 98 176 49 26 100 226 15 127 68 213 132 163 70 52 46 10 247 185 6 76 76 180 190 205 124 250 143 171 106 50 0 0 1 96 219 203 221 208 224 159 230 219 11 100 135 13 4 127 208 103 80 48 213 73 245 143 157 122 152 178 240 239 253 126 244 30 239 102 14 87 67 14 70 171 224 149 9 84 107 219 85 124 178 61 180 47 218 225 163 193 116 189 130 11 146 64 142 109 98 176 49 26 100 226 15 127 68 213 132 163 70 52 46 10 247 185 6 76 76 180 190 205 124 250 143 171 106 50 0 0 0 120 217 116 20 196 181 6 137 250 178 207 36 29 215 183 251 28 156 129 254 149 110 35 250 145 188 199 148 182 206 23 143 174 147 1 195 119 32 158 253 47 241 245 160 161 23 172 143 224 166 48 241 224 180 60 40 55 163 113 65 217 210 254 250 75 125 222 20 146 22 127 207 180 19 232 245 117 4 55 117 208 11 134 81 103 44 211 65 174 30 21 186 123 156 224 41 168 144 253 5 228 247 219 192 43 85 242 13 199 36 248 50 226 239 233 47 12 212 3 0 0 1 120 217 116 20 196 181 6 137 250 178 207 36 29 215 183 251 28 156 129 254 149 110 35 250 145 188 199 148 182 206 23 143 174 147 1 195 119 32 158 253 47 241 245 160 161 23 172 143 224 166 48 241 224 180 60 40 55 163 113 65 217 210 254 250 75 125 222 20 146 22 127 207 180 19 232 245 117 4 55 117 208 11 134 81 103 44 211 65 174 30 21 186 123 156 224 41 168 144 253 5 228 247 219 192 43 85 242 13 199 36 248 50 226 239 233 47 12 212 3 0 0 0 92 94 102 6 123 33 254 222 92 46 211 170 116 91 71 221 6 87 3 144 77 231 38 4 248 202 135 81 159 100 30 21 111 114 225 52 100 98 124 212 26 0 192 179 224 123 152 186 35 198 14 32 169 2 28 91 12 93 226 2 56 176 203 77 155 47 63 21 131 158 27 252 110 108 46 2 205 114 62 224 151 97 97 251 197 34 255 29 36 247 1 0 0 1 92 94 102 6 123 33 254 222 92 46 211 170 116 91 71 221 6 87 3 144 77 231 38 4 248 202 135 81 159 100 30 21 111 114 225 52 100 98 124 212 26 0 192 179 224 123 152 186 35 198 14 32 169 2 28 91 12 93 226 2 56 176 203 77 155 47 63 21 131 158 27 252 110 108 46 2 205 114 62 224 151 97 97 251 197 34 255 29 36 247 1 0 0 0 40 213 155 45 217 157 63 158 214 179 178 45 31 167 171 88 99 135 205 98 19 102 250 247 155 144 144 184 108 185 216 134 183 188 174 39 244 81 0 0 0 1 40 213 155 45 217 157 63 158 214 179 178 45 31 167 171 88 99 135 205 98 19 102 250 247 155 144 144 184 108 185 216 134 183 188 174 39 244 81 0 0 0 0 88 143 221 144 99 71 55 91 51 132 189 170 46 209 246 137 32 255 61 37 105 68 54 129 75 74 69 209 169 194 207 43 51 79 37 156 64 84 31 147 49 63 100 147 137 157 156 108 126 196 246 233 144 88 124 237 160 146 162 62 111 128 118 225 95 72 29 227 189 100 72 148 6 238 216 74 124 168 129 102 216 225 99 39 71 85 27 125 1 1 88 143 221 144 99 71 55 91 51 132 189 170 46 209 246 137 32 255 61 37 105 68 54 129 75 74 69 209 169 194 207 43 51 79 37 156 64 84 31 147 49 63 100 147 137 157 156 108 126 196 246 233 144 88 124 237 160 146 162 62 111 128 118 225 95 72 29 227 189 100 72 148 6 238 216 74 124 168 129 102 216 225 99 39 71 85 27 125 1 0 100 154 59 8 214 250 135 152 185 224 10 174 79 58 146 203 236 143 30 28 53 247 75 23 46 61 14 153 250 130 43 106 99 3 114 97 134 236 14 79 134 253 241 239 191 59 197 179 112 33 255 64 2 35 190 107 61 57 182 11 43 73 118 122 234 246 107 208 63 148 121 113 255 201 200 66 134 64 61 39 183 76 142 5 123 90 113 163 171 46 238 92 52 235 152 239 73 131 0 0 0 1 100 154 59 8 214 250 135 152 185 224 10 174 79 58 146 203 236 143 30 28 53 247 75 23 46 61 14 153 250 130 43 106 99 3 114 97 134 236 14 79 134 253 241 239 191 59 197 179 112 33 255 64 2 35 190 107 61 57 182 11 43 73 118 122 234 246 107 208 63 148 121 113 255 201 200 66 134 64 61 39 183 76 142 5 123 90 113 163 171 46 238 92 52 235 152 239 73 131 0 0 0 0 52 1 38 134 41 29 170 88 160 233 145 132 85 205 36 47 50 209 38 92 196 100 126 18 43 149 60 250 154 84 98 23 80 203 61 86 37 43 121 198 250 148 214 237 218 106 31 30 52 22 223 4 0 1 52 1 38 134 41 29 170 88 160 233 145 132 85 205 36 47 50 209 38 92 196 100 126 18 43 149 60 250 154 84 98 23 80 203 61 86 37 43 121 198 250 148 214 237 218 106 31 30 52 22 223 4 0 0 100 215 110 214 250 112 196 210 135 44 106 41 81 231 208 226 187 180 124 169 6 101 223 131 248 7 59 123 141 245 45 155 111 191 45 243 237 47 248 47 233 222 27 53 116 18 174 176 121 70 241 49 29 54 248 100 119 186 7 84 242 46 154 182 14 231 49 213 37 52 160 79 242 253 165 71 241 87 50 98 158 58 249 163 206 75 138 146 172 232 178 183 137 30 153 204 59 17 0 0 0 1 100 215 110 214 250 112 196 210 135 44 106 41 81 231 208 226 187 180 124 169 6 101 223 131 248 7 59 123 141 245 45 155 111 191 45 243 237 47 248 47 233 222 27 53 116 18 174 176 121 70 241 49 29 54 248 100 119 186 7 84 242 46 154 182 14 231 49 213 37 52 160 79 242 253 165 71 241 87 50 98 158 58 249 163 206 75 138 146 172 232 178 183 137 30 153 204 59 17 0 0 0 0 72 226 229 244 239 100 207 243 201 63 193 44 114 73 253 9 63 199 34 184 12 34 181 93 167 70 38 119 43 136 85 61 200 200 27 101 128 179 178 146 168 152 45 163 217 123 227 167 40 116 43 26 248 220 216 17 126 35 228 188 102 203 130 134 149 10 8 144 5 253 158 4 186 1 72 226 229 244 239 100 207 243 201 63 193 44 114 73 253 9 63 199 34 184 12 34 181 93 167 70 38 119 43 136 85 61 200 200 27 101 128 179 178 146 168 152 45 163 217 123 227 167 40 116 43 26 248 220 216 17 126 35 228 188 102 203 130 134 149 10 8 144 5 253 158 4 186 0 52 94 1 134 237 212 63 41 32 13 66 189 152 40 150 138 20 124 116 62 140 23 229 83 230 85 61 202 206 29 102 39 28 182 37 173 34 29 120 65 193 196 145 186 204 173 159 132 183 115 0 0 0 1 52 94 1 134 237 212 63 41 32 13 66 189 152 40 150 138 20 124 116 62 140 23 229 83 230 85 61 202 206 29 102 39 28 182 37 173 34 29 120 65 193 196 145 186 204 173 159 132 183 115 0 0 0 0 28 172 92 233 22 126 43 253 105 39 155 94 185 44 226 60 168 170 203 19 17 108 152 224 242 209 228 43 0 1 28 172 92 233 22 126 43 253 105 39 155 94 185 44 226 60 168 170 203 19 17 108 152 224 242 209 228 43 0 0 76 76 207 112 0 53 15 20 52 176 51 179 204 201 221 199 215 198 47 180 117 63 178 218 237 224 7 238 83 244 101 132 225 169 14 209 41 140 228 33 125 131 46 213 26 149 30 9 194 107 82 49 220 69 57 63 176 58 107 164 112 122 14 78 212 162 39 156 86 247 229 146 165 114 0 0 0 1 76 76 207 112 0 53 15 20 52 176 51 179 204 201 221 199 215 198 47 180 117 63 178 218 237 224 7 238 83 244 101 132 225 169 14 209 41 140 228 33 125 131 46 213 26 149 30 9 194 107 82 49 220 69 57 63 176 58 107 164 112 122 14 78 212 162 39 156 86 247 229 146 165 114 0 0 0 0 68 251 218 113 128 106 254 150 82 225 107 92 157 216 88 77 244 99 157 1 98 151 72 130 185 194 141 147 195 242 231 156 213 157 138 94 239 99 178 106 231 226 192 202 146 27 248 176 225 209 153 7 186 7 50 120 183 212 126 50 190 105 134 94 43 155 64 125 6 1 68 251 218 113 128 106 254 150 82 225 107 92 157 216 88 77 244 99 157 1 98 151 72 130 185 194 141 147 195 242 231 156 213 157 138 94 239 99 178 106 231 226 192 202 146 27 248 176 225 209 153 7 186 7 50 120 183 212 126 50 190 105 134 94 43 155 64 125 6 0 12 209 108 141 185 23 199 10 211 38 178 0 0 1 12 209 108 141 185 23 199 10 211 38 178 0 0 0 52 154 210 229 202 23 25 195 186 179 6 6 199 170 59 41 215 172 79 12 201 40 201 127 61 38 143 15 80 87 105 227 146 32 219 224 101 136 180 226 214 34 112 110 89 114 34 177 212 74 212 106 6 1 52 154 210 229 202 23 25 195 186 179 6 6 199 170 59 41 215 172 79 12 201 40 201 127 61 38 143 15 80 87 105 227 146 32 219 224 101 136 180 226 214 34 112 110 89 114 34 177 212 74 212 106 6 0 8 100 135 7 25 201 86 188 2 1 8 100 135 7 25 201 86 188 2 0 48 109 14 55 6 23 219 83 134 16 29 117 179 205 24 254 117 81 245 228 115 29 245 23 120 19 143 171 136 217 234 105 176 54 200 15 132 252 117 219 34 127 228 168 111 203 2 0 0 1 48 109 14 55 6 23 219 83 134 16 29 117 179 205 24 254 117 81 245 228 115 29 245 23 120 19 143 171 136 217 234 105 176 54 200 15 132 252 117 219 34 127 228 168 111 203 2 0 0 0 68 189 190 26 27 18 245 206 184 37 205 141 131 212 0 127 17 122 35 32 152 79 200 69 20 74 161 75 208 251 152 129 241 33 169 49 200 168 98 138 154 1 201 2 137 248 97 109 91 51 92 185 150 229 58 56 137 252 73 190 235 237 144 130 251 152 190 194 0 1 68 189 190 26 27 18 245 206 184 37 205 141 131 212 0 127 17 122 35 32 152 79 200 69 20 74 161 75 208 251 152 129 241 33 169 49 200 168 98 138 154 1 201 2 137 248 97 109 91 51 92 185 150 229 58 56 137 252 73 190 235 237 144 130 251 152 190 194 0 0 76 207 251 128 22 249 241 160 213 177 156 81 63 226 211 104 180 224 253 194 155 185 4 55 89 47 114 245 7 150 248 180 92 51 125 222 246 36 165 153 246 217 229 236 207 71 52 111 220 127 235 87 138 209 205 186 72 20 6 162 209 199 59 28 143 29 40 129 110 196 31 138 191 210 255 29 45 1 76 207 251 128 22 249 241 160 213 177 156 81 63 226 211 104 180 224 253 194 155 185 4 55 89 47 114 245 7 150 248 180 92 51 125 222 246 36 165 153 246 217 229 236 207 71 52 111 220 127 235 87 138 209 205 186 72 20 6 162 209 199 59 28 143 29 40 129 110 196 31 138 191 210 255 29 45 0 100 34 105 251 242 196 29 25 191 13 57 197 24 56 214 71 179 84 16 80 235 205 101 211 115 134 253 214 216 165 198 158 63 242 99 11 173 46 16 134 146 11 55 237 102 192 144 220 243 114 208 229 213 0 218 193 226 110 51 184 76 183 51 12 136 3 140 173 50 245 19 16 15 166 7 51 67 86 66 36 164 78 174 152 214 177 106 255 43 110 199 185 127 79 12 140 96 198 60 160 102 1 100 34 105 251 242 196 29 25 191 13 57 197 24 56 214 71 179 84 16 80 235 205 101 211 115 134 253 214 216 165 198 158 63 242 99 11 173 46 16 134 146 11 55 237 102 192 144 220 243 114 208 229 213 0 218 193 226 110 51 184 76 183 51 12 136 3 140 173 50 245 19 16 15 166 7 51 67 86 66 36 164 78 174 152 214 177 106 255 43 110 199 185 127 79 12 140 96 198 60 160 102 0 48 151 50 240 113 2 240 195 92 196 249 19 127 144 80 105 89 196 158 41 252 36 228 125 87 223 38 175 180 160 171 217 8 107 79 15 49 18 96 89 233 92 36 110 25 144 127 0 0 1 48 151 50 240 113 2 240 195 92 196 249 19 127 144 80 105 89 196 158 41 252 36 228 125 87 223 38 175 180 160 171 217 8 107 79 15 49 18 96 89 233 92 36 110 25 144 127 0 0 0 120 220 111 204 84 44 130 217 213 198 206 117 146 194 10 147 26 202 239 193 244 37 205 135 142 56 32 249 87 168 225 194 69 224 42 44 177 94 77 94 53 91 119 184 126 54 91 178 96 62 34 235 141 251 16 10 187 157 41 198 141 167 60 123 73 194 190 232 21 131 122 95 94 19 80 131 0 80 156 191 71 14 30 148 74 123 179 226 24 229 233 126 54 51 237 55 92 191 74 239 104 108 155 8 161 36 74 77 55 133 160 139 207 243 154 53 85 221 49 167 10 1 120 220 111 204 84 44 130 217 213 198 206 117 146 194 10 147 26 202 239 193 244 37 205 135 142 56 32 249 87 168 225 194 69 224 42 44 177 94 77 94 53 91 119 184 126 54 91 178 96 62 34 235 141 251 16 10 187 157 41 198 141 167 60 123 73 194 190 232 21 131 122 95 94 19 80 131 0 80 156 191 71 14 30 148 74 123 179 226 24 229 233 126 54 51 237 55 92 191 74 239 104 108 155 8 161 36 74 77 55 133 160 139 207 243 154 53 85 221 49 167 10 0 124 66 181 48 69 164 115 164 70 89 243 215 101 175 87 235 67 90 105 180 75 47 179 125 207 87 227 224 42 29 17 96 44 75 24 133 40 113 24 135 93 121 59 20 187 166 95 86 53 166 161 86 99 27 119 194 156 39 207 117 76 162 208 78 38 249 64 104 247 119 216 98 220 191 85 93 88 71 67 153 91 210 137 198 13 84 67 129 197 58 103 183 253 111 51 7 9 158 89 134 12 78 19 173 133 159 221 103 18 198 238 156 111 121 141 61 104 245 244 206 7 118 23 61 26 1 124 66 181 48 69 164 115 164 70 89 243 215 101 175 87 235 67 90 105 180 75 47 179 125 207 87 227 224 42 29 17 96 44 75 24 133 40 113 24 135 93 121 59 20 187 166 95 86 53 166 161 86 99 27 119 194 156 39 207 117 76 162 208 78 38 249 64 104 247 119 216 98 220 191 85 93 88 71 67 153 91 210 137 198 13 84 67 129 197 58 103 183 253 111 51 7 9 158 89 134 12 78 19 173 133 159 221 103 18 198 238 156 111 121 141 61 104 245 244 206 7 118 23 61 26 0 20 53 158 199 70 207 47 204 168 124 200 230 150 58 31 240 105 24 0 0 0 1 20 53 158 199 70 207 47 204 168 124 200 230 150 58 31 240 105 24 0 0 0 0 20 44 216 57 222 28 184 85 185 207 83 175 57 221 190 218 247 150 5 9 117 1 20 44 216 57 222 28 184 85 185 207 83 175 57 221 190 218 247 150 5 9 117 0 76 175 96 135 121 157 156 226 243 56 243 161 244 255 180 122 46 138 241 238 214 239 108 19 34 52 247 13 21 71 51 38 3 155 181 28 151 11 194 1 127 89 168 237 141 215 157 75 68 132 79 117 113 7 76 199 243 237 109 44 236 225 116 106 60 77 216 199 25 21 97 116 178 189 0 0 0 1 76 175 96 135 121 157 156 226 243 56 243 161 244 255 180 122 46 138 241 238 214 239 108 19 34 52 247 13 21 71 51 38 3 155 181 28 151 11 194 1 127 89 168 237 141 215 157 75 68 132 79 117 113 7 76 199 243 237 109 44 236 225 116 106 60 77 216 199 25 21 97 116 178 189 0 0 0 0 52 202 229 137 148 154 5 233 137 136 40 13 16 169 117 12 152 29 203 90 68 73 225 131 236 45 230 124 112 148 9 55 131 227 132 115 213 238 10 238 61 255 35 176 204 139 43 31 180 151 38 28 0 1 52 202 229 137 148 154 5 233 137 136 40 13 16 169 117 12 152 29 203 90 68 73 225 131 236 45 230 124 112 148 9 55 131 227 132 115 213 238 10 238 61 255 35 176 204 139 43 31 180 151 38 28 0 0 60 235 98 102 1 125 196 43 138 213 140 187 232 56 154 133 53 67 83 164 240 80 16 61 51 160 252 62 34 180 200 255 184 169 84 36 69 72 6 78 7 150 152 1 13 250 97 34 132 97 157 173 219 115 157 86 128 104 9 243 111 1 60 235 98 102 1 125 196 43 138 213 140 187 232 56 154 133 53 67 83 164 240 80 16 61 51 160 252 62 34 180 200 255 184 169 84 36 69 72 6 78 7 150 152 1 13 250 97 34 132 97 157 173 219 115 157 86 128 104 9 243 111 0 52 110 238 199 119 170 141 33 211 193 225 211 65 71 230 113 169 249 100 145 146 90 130 63 193 239 121 202 133 82 133 133 53 185 111 84 99 172 253 212 36 243 170 231 244 134 94 195 226 84 11 0 0 1 52 110 238 199 119 170 141 33 211 193 225 211 65 71 230 113 169 249 100 145 146 90 130 63 193 239 121 202 133 82 133 133 53 185 111 84 99 172 253 212 36 243 170 231 244 134 94 195 226 84 11 0 0 0 4 106 26 0 0 1 4 106 26 0 0 0 96 55 152 73 157 134 83 107 104 157 196 53 164 2 160 29 214 41 144 154 185 26 161 178 109 113 19 105 96 157 167 54 34 103 42 200 114 164 164 104 227 67 103 2 210 8 116 188 135 174 40 62 91 190 166 226 195 250 41 221 152 30 57 61 233 241 101 130 10 63 191 169 19 148 16 188 139 65 132 105 232 99 49 96 137 153 204 114 212 66 194 182 129 146 0 0 0 1 96 55 152 73 157 134 83 107 104 157 196 53 164 2 160 29 214 41 144 154 185 26 161 178 109 113 19 105 96 157 167 54 34 103 42 200 114 164 164 104 227 67 103 2 210 8 116 188 135 174 40 62 91 190 166 226 195 250 41 221 152 30 57 61 233 241 101 130 10 63 191 169 19 148 16 188 139 65 132 105 232 99 49 96 137 153 204 114 212 66 194 182 129 146 0 0 0 0 44 215 234 168 32 222 91 186 69 25 72 240 30 59 198 171 46 112 186 148 235 6 205 150 234 108 20 173 83 144 129 239 167 253 152 161 53 229 15 251 248 211 51 238 4 1 44 215 234 168 32 222 91 186 69 25 72 240 30 59 198 171 46 112 186 148 235 6 205 150 234 108 20 173 83 144 129 239 167 253 152 161 53 229 15 251 248 211 51 238 4 0 52 189 135 39 96 175 218 106 164 199 43 5 248 111 65 179 200 109 31 254 255 126 80 190 92 65 237 178 43 23 153 58 10 9 97 226 246 198 243 117 174 24 218 33 231 128 164 157 128 151 190 0 0 1 52 189 135 39 96 175 218 106 164 199 43 5 248 111 65 179 200 109 31 254 255 126 80 190 92 65 237 178 43 23 153 58 10 9 97 226 246 198 243 117 174 24 218 33 231 128 164 157 128 151 190 0 0 0 24 239 56 183 78 45 154 165 142 40 239 207 3 167 77 151 86 239 3 11 209 79 0 0 0 1 24 239 56 183 78 45 154 165 142 40 239 207 3 167 77 151 86 239 3 11 209 79 0 0 0 0 120 130 184 128 68 207 249 83 80 33 163 142 32 202 202 145 151 232 83 195 182 58 116 163 243 175 189 47 35 208 19 5 175 59 26 2 94 105 183 66 152 203 200 32 2 26 199 8 181 211 38 92 194 207 149 100 136 89 145 224 231 176 230 123 222 97 24 81 114 242 42 179 218 87 154 251 235 53 36 114 72 81 186 89 13 87 192 22 111 97 8 245 31 80 244 208 101 196 210 93 76 175 182 133 13 74 7 144 34 186 229 253 42 25 120 196 253 145 203 34 0 1 120 130 184 128 68 207 249 83 80 33 163 142 32 202 202 145 151 232 83 195 182 58 116 163 243 175 189 47 35 208 19 5 175 59 26 2 94 105 183 66 152 203 200 32 2 26 199 8 181 211 38 92 194 207 149 100 136 89 145 224 231 176 230 123 222 97 24 81 114 242 42 179 218 87 154 251 235 53 36 114 72 81 186 89 13 87 192 22 111 97 8 245 31 80 244 208 101 196 210 93 76 175 182 133 13 74 7 144 34 186 229 253 42 25 120 196 253 145 203 34 0 0 104 177 43 20 0 140 140 47 23 231 84 40 77 91 102 55 158 233 117 153 218 25 252 97 80 128 163 220 227 30 148 92 31 92 123 175 218 18 184 223 122 242 27 52 233 221 142 227 84 175 165 149 51 30 52 3 112 242 251 194 123 45 37 79 48 197 65 154 217 117 129 115 239 202 140 4 219 13 126 27 135 146 152 96 151 82 124 223 118 24 195 194 175 191 121 134 29 81 56 114 151 40 33 0 0 1 104 177 43 20 0 140 140 47 23 231 84 40 77 91 102 55 158 233 117 153 218 25 252 97 80 128 163 220 227 30 148 92 31 92 123 175 218 18 184 223 122 242 27 52 233 221 142 227 84 175 165 149 51 30 52 3 112 242 251 194 123 45 37 79 48 197 65 154 217 117 129 115 239 202 140 4 219 13 126 27 135 146 152 96 151 82 124 223 118 24 195 194 175 191 121 134 29 81 56 114 151 40 33 0 0 0 56 226 202 173 6 149 116 30 177 236 7 160 65 73 122 165 121 36 223 128 217 110 236 2 31 124 183 89 207 252 6 59 84 137 76 50 38 76 184 223 208 6 130 201 233 242 76 37 234 218 223 126 70 103 75 198 17 1 56 226 202 173 6 149 116 30 177 236 7 160 65 73 122 165 121 36 223 128 217 110 236 2 31 124 183 89 207 252 6 59 84 137 76 50 38 76 184 223 208 6 130 201 233 242 76 37 234 218 223 126 70 103 75 198 17 0 40 143 226 94 34 87 62 30 33 239 85 79 57 245 111 192 126 163 234 125 86 103 149 210 150 242 12 158 215 135 158 29 55 151 47 136 29 80 31 37 252 1 40 143 226 94 34 87 62 30 33 239 85 79 57 245 111 192 126 163 234 125 86 103 149 210 150 242 12 158 215 135 158 29 55 151 47 136 29 80 31 37 252 0 112 181 27 23 157 82 76 57 33 149 24 89 155 221 152 127 94 66 164 208 210 148 182 78 234 184 210 234 72 255 16 100 229 47 58 156 105 247 59 66 253 245 169 65 48 79 130 122 51 190 191 81 1 34 200 63 2 65 127 95 41 111 129 132 49 253 173 167 197 104 55 130 14 224 162 119 109 66 142 188 11 186 58 39 173 207 179 212 181 61 158 3 218 40 241 226 184 47 0 88 220 135 180 224 61 164 169 34 189 151 91 0 0 1 112 181 27 23 157 82 76 57 33 149 24 89 155 221 152 127 94 66 164 208 210 148 182 78 234 184 210 234 72 255 16 100 229 47 58 156 105 247 59 66 253 245 169 65 48 79 130 122 51 190 191 81 1 34 200 63 2 65 127 95 41 111 129 132 49 253 173 167 197 104 55 130 14 224 162 119 109 66 142 188 11 186 58 39 173 207 179 212 181 61 158 3 218 40 241 226 184 47 0 88 220 135 180 224 61 164 169 34 189 151 91 0 0 0 68 245 37 28 124 5 215 158 136 244 187 142 156 141 44 84 13 112 140 11 136 159 80 12 232 82 107 30 135 75 126 13 223 106 21 218 151 253 45 223 202 227 61 206 171 121 209 68 8 191 131 100 178 102 54 84 51 65 145 226 154 248 80 115 68 154 209 63 76 1 68 245 37 28 124 5 215 158 136 244 187 142 156 141 44 84 13 112 140 11 136 159 80 12 232 82 107 30 135 75 126 13 223 106 21 218 151 253 45 223 202 227 61 206 171 121 209 68 8 191 131 100 178 102 54 84 51 65 145 226 154 248 80 115 68 154 209 63 76 0 80 135 137 38 34 14 3 46 79 186 179 131 28 57 25 247 29 19 45 197 193 203 121 109 165 119 101 172 185 115 171 154 177 182 27 155 85 37 5 182 213 87 183 42 234 134 15 60 0 46 192 218 165 41 22 150 148 218 236 133 178 67 163 140 233 134 213 210 71 193 23 166 26 63 204 170 123 79 127 246 26 1 80 135 137 38 34 14 3 46 79 186 179 131 28 57 25 247 29 19 45 197 193 203 121 109 165 119 101 172 185 115 171 154 177 182 27 155 85 37 5 182 213 87 183 42 234 134 15 60 0 46 192 218 165 41 22 150 148 218 236 133 178 67 163 140 233 134 213 210 71 193 23 166 26 63 204 170 123 79 127 246 26 0 24 161 11 98 151 34 241 111 106 193 28 3 100 220 97 185 34 185 14 129 244 209 10 0 0 1 24 161 11 98 151 34 241 111 106 193 28 3 100 220 97 185 34 185 14 129 244 209 10 0 0 0 16 130 229 241 126 185 171 21 95 192 161 17 185 7 19 79 20 1 16 130 229 241 126 185 171 21 95 192 161 17 185 7 19 79 20 0 80 9 13 228 66 211 156 80 135 182 180 214 181 47 183 227 46 41 12 246 131 232 90 158 5 19 60 63 252 117 169 61 164 189 193 27 141 183 254 18 152 59 130 30 176 181 167 165 190 60 186 198 100 145 152 47 75 69 203 253 237 35 74 191 49 205 55 93 241 175 147 35 169 57 234 147 255 216 2 0 0 1 80 9 13 228 66 211 156 80 135 182 180 214 181 47 183 227 46 41 12 246 131 232 90 158 5 19 60 63 252 117 169 61 164 189 193 27 141 183 254 18 152 59 130 30 176 181 167 165 190 60 186 198 100 145 152 47 75 69 203 253 237 35 74 191 49 205 55 93 241 175 147 35 169 57 234 147 255 216 2 0 0 0 64 141 139 202 76 43 47 180 136 161 170 209 0 136 207 136 36 208 145 71 130 83 221 226 101 19 151 187 159 109 224 255 62 88 129 165 22 98 27 176 90 80 16 65 129 69 250 183 187 147 190 130 199 5 11 138 101 83 65 161 2 6 0 0 0 1 64 141 139 202 76 43 47 180 136 161 170 209 0 136 207 136 36 208 145 71 130 83 221 226 101 19 151 187 159 109 224 255 62 88 129 165 22 98 27 176 90 80 16 65 129 69 250 183 187 147 190 130 199 5 11 138 101 83 65 161 2 6 0 0 0 0 36 187 72 171 67 22 57 200 41 156 125 20 118 214 230 17 121 132 100 6 245 170 66 142 117 245 148 173 113 251 22 92 19 155 30 0 0 1 36 187 72 171 67 22 57 200 41 156 125 20 118 214 230 17 121 132 100 6 245 170 66 142 117 245 148 173 113 251 22 92 19 155 30 0 0 0 44 101 58 72 216 138 4 45 140 222 69 239 13 13 50 235 67 209 36 214 49 165 77 35 96 140 27 164 215 181 180 73 146 42 130 29 96 159 153 232 94 77 175 255 20 1 44 101 58 72 216 138 4 45 140 222 69 239 13 13 50 235 67 209 36 214 49 165 77 35 96 140 27 164 215 181 180 73 146 42 130 29 96 159 153 232 94 77 175 255 20 0 84 219 224 155 211 221 151 19 144 234 158 11 45 122 35 132 149 62 141 108 208 26 84 49 255 193 206 21 192 119 23 25 107 230 224 23 255 211 84 131 200 163 22 3 191 95 246 22 164 37 9 116 62 212 138 8 160 64 31 218 139 106 242 89 216 218 255 147 91 71 129 205 194 18 209 161 119 85 170 226 225 162 83 212 20 1 84 219 224 155 211 221 151 19 144 234 158 11 45 122 35 132 149 62 141 108 208 26 84 49 255 193 206 21 192 119 23 25 107 230 224 23 255 211 84 131 200 163 22 3 191 95 246 22 164 37 9 116 62 212 138 8 160 64 31 218 139 106 242 89 216 218 255 147 91 71 129 205 194 18 209 161 119 85 170 226 225 162 83 212 20 0 68 14 156 116 249 212 16 111 35 17 9 212 224 210 14 154 158 72 254 112 138 10 30 123 27 209 114 67 151 154 58 185 70 230 39 91 161 175 96 144 42 108 176 175 129 131 222 206 150 81 39 184 66 31 183 226 159 121 73 128 206 177 92 204 53 155 0 167 103 1 68 14 156 116 249 212 16 111 35 17 9 212 224 210 14 154 158 72 254 112 138 10 30 123 27 209 114 67 151 154 58 185 70 230 39 91 161 175 96 144 42 108 176 175 129 131 222 206 150 81 39 184 66 31 183 226 159 121 73 128 206 177 92 204 53 155 0 167 103 0 92 24 127 183 77 135 143 95 88 89 95 188 40 117 29 239 121 158 197 98 117 88 96 129 197 2 191 220 182 209 38 73 53 151 197 255 5 2 62 107 10 40 43 253 32 105 98 219 212 155 202 52 7 137 199 16 43 208 83 186 41 89 60 249 93 40 107 182 175 147 127 53 185 207 74 51 82 246 167 59 57 221 250 206 122 32 222 85 116 2 0 0 0 1 92 24 127 183 77 135 143 95 88 89 95 188 40 117 29 239 121 158 197 98 117 88 96 129 197 2 191 220 182 209 38 73 53 151 197 255 5 2 62 107 10 40 43 253 32 105 98 219 212 155 202 52 7 137 199 16 43 208 83 186 41 89 60 249 93 40 107 182 175 147 127 53 185 207 74 51 82 246 167 59 57 221 250 206 122 32 222 85 116 2 0 0 0 0 92 147 237 31 71 216 196 26 132 246 73 163 25 96 43 245 7 209 8 5 54 169 7 250 78 177 89 40 0 243 40 2 158 24 11 198 234 171 172 170 64 188 187 101 123 162 237 222 202 89 40 19 173 38 211 166 45 226 3 80 235 195 110 200 92 16 163 19 117 163 211 172 5 18 87 238 191 193 83 143 189 110 113 70 107 147 246 94 49 35 15 198 45 1 92 147 237 31 71 216 196 26 132 246 73 163 25 96 43 245 7 209 8 5 54 169 7 250 78 177 89 40 0 243 40 2 158 24 11 198 234 171 172 170 64 188 187 101 123 162 237 222 202 89 40 19 173 38 211 166 45 226 3 80 235 195 110 200 92 16 163 19 117 163 211 172 5 18 87 238 191 193 83 143 189 110 113 70 107 147 246 94 49 35 15 198 45 0 96 64 61 164 44 87 227 172 18 31 65 156 146 28 18 93 184 64 206 182 188 247 38 246 148 197 40 179 134 87 253 99 200 144 207 105 35 236 191 211 141 2 166 22 69 97 111 181 148 114 108 196 62 4 205 40 5 94 207 78 159 83 52 193 205 124 45 112 37 168 234 114 146 238 213 231 94 67 171 153 42 253 122 194 188 137 165 213 50 253 178 210 172 158 19 49 97 1 96 64 61 164 44 87 227 172 18 31 65 156 146 28 18 93 184 64 206 182 188 247 38 246 148 197 40 179 134 87 253 99 200 144 207 105 35 236 191 211 141 2 166 22 69 97 111 181 148 114 108 196 62 4 205 40 5 94 207 78 159 83 52 193 205 124 45 112 37 168 234 114 146 238 213 231 94 67 171 153 42 253 122 194 188 137 165 213 50 253 178 210 172 158 19 49 97 0 128 18 25 43 69 203 163 208 25 129 70 179 87 12 27 80 85 159 26 23 217 250 145 72 121 50 16 37 139 240 158 153 146 201 8 164 249 47 152 57 202 235 15 58 45 34 201 248 69 113 190 138 170 65 10 208 146 132 110 25 228 113 14 229 109 123 49 220 88 192 96 240 71 116 139 193 10 198 27 240 251 107 253 255 213 42 221 24 113 228 220 232 119 71 248 233 220 92 90 99 190 197 160 163 32 110 191 182 102 164 156 66 22 63 71 173 246 104 8 68 245 41 178 81 182 144 193 28 0 1 128 18 25 43 69 203 163 208 25 129 70 179 87 12 27 80 85 159 26 23 217 250 145 72 121 50 16 37 139 240 158 153 146 201 8 164 249 47 152 57 202 235 15 58 45 34 201 248 69 113 190 138 170 65 10 208 146 132 110 25 228 113 14 229 109 123 49 220 88 192 96 240 71 116 139 193 10 198 27 240 251 107 253 255 213 42 221 24 113 228 220 232 119 71 248 233 220 92 90 99 190 197 160 163 32 110 191 182 102 164 156 66 22 63 71 173 246 104 8 68 245 41 178 81 182 144 193 28 0 0 60 106 111 228 235 51 226 122 218 7 64 133 195 240 189 43 175 243 131 132 104 152 3 70 2 1 203 253 95 8 193 163 40 223 43 68 152 88 4 207 245 179 156 172 179 217 24 72 255 34 91 50 116 117 25 16 159 79 126 0 0 1 60 106 111 228 235 51 226 122 218 7 64 133 195 240 189 43 175 243 131 132 104 152 3 70 2 1 203 253 95 8 193 163 40 223 43 68 152 88 4 207 245 179 156 172 179 217 24 72 255 34 91 50 116 117 25 16 159 79 126 0 0 0 96 242 78 165 200 211 109 6 120 204 217 25 19 113 152 179 73 130 49 149 173 66 167 106 162 150 87 123 191 217 234 1 44 116 181 9 66 210 127 251 186 48 185 108 188 94 122 96 63 201 235 22 186 67 42 225 10 180 91 176 96 61 82 61 81 28 92 254 57 197 179 147 78 166 147 71 129 176 7 57 241 168 104 58 31 131 207 114 100 228 122 222 33 1 0 0 0 1 96 242 78 165 200 211 109 6 120 204 217 25 19 113 152 179 73 130 49 149 173 66 167 106 162 150 87 123 191 217 234 1 44 116 181 9 66 210 127 251 186 48 185 108 188 94 122 96 63 201 235 22 186 67 42 225 10 180 91 176 96 61 82 61 81 28 92 254 57 197 179 147 78 166 147 71 129 176 7 57 241 168 104 58 31 131 207 114 100 228 122 222 33 1 0 0 0 0 12 97 77 106 250 36 19 39 116 255 76 19 0 1 12 97 77 106 250 36 19 39 116 255 76 19 0 0 120 111 83 184 168 71 100 200 47 99 200 7 122 64 223 9 88 127 36 176 17 86 69 21 128 134 171 205 233 96 184 231 129 34 199 145 56 105 1 143 43 41 220 152 215 178 124 68 220 20 206 108 104 17 70 117 37 42 80 169 70 134 89 10 29 153 175 13 143 30 175 166 31 179 51 111 40 201 178 167 176 195 238 36 55 237 111 116 105 132 211 219 6 26 164 101 240 113 151 131 108 247 150 189 114 192 163 218 28 145 0 191 98 2 111 27 49 39 0 0 0 1 120 111 83 184 168 71 100 200 47 99 200 7 122 64 223 9 88 127 36 176 17 86 69 21 128 134 171 205 233 96 184 231 129 34 199 145 56 105 1 143 43 41 220 152 215 178 124 68 220 20 206 108 104 17 70 117 37 42 80 169 70 134 89 10 29 153 175 13 143 30 175 166 31 179 51 111 40 201 178 167 176 195 238 36 55 237 111 116 105 132 211 219 6 26 164 101 240 113 151 131 108 247 150 189 114 192 163 218 28 145 0 191 98 2 111 27 49 39 0 0 0 0 32 81 112 148 108 23 32 68 197 136 108 75 125 74 153 138 193 143 46 240 12 147 141 114 195 168 154 52 204 254 27 0 0 1 32 81 112 148 108 23 32 68 197 136 108 75 125 74 153 138 193 143 46 240 12 147 141 114 195 168 154 52 204 254 27 0 0 0 68 229 45 84 95 24 25 32 216 165 111 25 116 164 115 152 232 97 207 181 82 250 83 172 4 143 100 89 243 176 103 143 89 97 174 71 138 98 227 83 33 167 157 210 208 119 156 79 89 223 158 79 207 126 107 230 151 179 67 137 75 82 190 93 51 33 0 0 0 1 68 229 45 84 95 24 25 32 216 165 111 25 116 164 115 152 232 97 207 181 82 250 83 172 4 143 100 89 243 176 103 143 89 97 174 71 138 98 227 83 33 167 157 210 208 119 156 79 89 223 158 79 207 126 107 230 151 179 67 137 75 82 190 93 51 33 0 0 0 0 120 221 101 250 13 148 219 147 8 203 24 156 18 193 222 45 207 235 157 11 245 111 54 46 193 242 190 64 24 32 5 137 205 125 176 100 17 201 24 239 205 106 167 230 189 153 124 31 64 237 182 168 183 7 51 170 88 147 80 176 116 117 47 23 224 52 179 41 43 139 109 178 28 245 173 29 90 7 170 105 16 115 2 213 39 87 247 94 160 195 0 33 49 96 68 43 87 69 180 255 100 174 99 176 29 24 104 158 236 125 224 97 89 243 65 242 94 178 0 0 0 1 120 221 101 250 13 148 219 147 8 203 24 156 18 193 222 45 207 235 157 11 245 111 54 46 193 242 190 64 24 32 5 137 205 125 176 100 17 201 24 239 205 106 167 230 189 153 124 31 64 237 182 168 183 7 51 170 88 147 80 176 116 117 47 23 224 52 179 41 43 139 109 178 28 245 173 29 90 7 170 105 16 115 2 213 39 87 247 94 160 195 0 33 49 96 68 43 87 69 180 255 100 174 99 176 29 24 104 158 236 125 224 97 89 243 65 242 94 178 0 0 0 0 72 184 253 189 224 206 45 217 58 19 82 204 156 74 148 217 108 38 0 212 209 189 122 237 87 236 106 6 235 35 39 176 243 21 191 101 210 52 159 254 224 228 116 193 110 127 138 238 156 91 101 182 243 43 212 2 192 249 29 46 143 26 92 106 122 73 98 4 82 141 13 112 16 1 72 184 253 189 224 206 45 217 58 19 82 204 156 74 148 217 108 38 0 212 209 189 122 237 87 236 106 6 235 35 39 176 243 21 191 101 210 52 159 254 224 228 116 193 110 127 138 238 156 91 101 182 243 43 212 2 192 249 29 46 143 26 92 106 122 73 98 4 82 141 13 112 16 0 20 141 65 210 229 224 235 23 20 177 164 60 252 191 64 31 44 84 216 95 0 1 20 141 65 210 229 224 235 23 20 177 164 60 252 191 64 31 44 84 216 95 0 0 68 48 154 41 124 74 158 181 70 130 132 240 230 198 88 167 2 237 114 242 9 139 158 87 188 104 154 110 210 176 38 252 92 77 243 54 213 93 179 111 60 173 65 242 154 5 78 138 79 93 20 212 247 205 148 243 182 244 13 15 150 159 207 103 38 24 0 0 0 1 68 48 154 41 124 74 158 181 70 130 132 240 230 198 88 167 2 237 114 242 9 139 158 87 188 104 154 110 210 176 38 252 92 77 243 54 213 93 179 111 60 173 65 242 154 5 78 138 79 93 20 212 247 205 148 243 182 244 13 15 150 159 207 103 38 24 0 0 0 0 108 78 251 44 163 60 65 61 73 160 130 160 8 28 61 196 90 12 152 7 115 142 7 114 17 198 170 252 19 236 254 162 201 32 45 18 43 189 44 46 90 207 184 59 237 162 203 126 224 42 136 170 154 0 222 28 154 135 82 229 44 204 68 59 154 17 125 179 36 205 42 28 134 10 215 115 12 32 14 56 173 76 9 183 175 169 7 152 168 55 94 109 58 166 129 180 156 71 14 106 140 11 108 205 121 170 23 0 0 1 108 78 251 44 163 60 65 61 73 160 130 160 8 28 61 196 90 12 152 7 115 142 7 114 17 198 170 252 19 236 254 162 201 32 45 18 43 189 44 46 90 207 184 59 237 162 203 126 224 42 136 170 154 0 222 28 154 135 82 229 44 204 68 59 154 17 125 179 36 205 42 28 134 10 215 115 12 32 14 56 173 76 9 183 175 169 7 152 168 55 94 109 58 166 129 180 156 71 14 106 140 11 108 205 121 170 23 0 0 0 60 99 133 203 247 192 63 4 144 228 175 21 211 17 186 191 58 203 241 243 89 132 220 36 39 238 217 164 218 253 0 222 143 219 114 227 127 56 66 234 167 126 143 213 130 213 113 84 86 215 204 56 188 57 9 152 64 225 239 108 6 1 60 99 133 203 247 192 63 4 144 228 175 21 211 17 186 191 58 203 241 243 89 132 220 36 39 238 217 164 218 253 0 222 143 219 114 227 127 56 66 234 167 126 143 213 130 213 113 84 86 215 204 56 188 57 9 152 64 225 239 108 6 0 72 77 228 188 235 97 138 100 91 238 49 139 79 56 188 11 184 173 83 39 221 20 245 96 38 125 60 181 72 3 128 43 118 106 90 15 200 8 233 181 34 5 7 174 190 71 134 170 210 207 164 152 232 51 89 112 82 165 188 21 114 191 123 230 238 197 193 95 140 244 0 0 0 1 72 77 228 188 235 97 138 100 91 238 49 139 79 56 188 11 184 173 83 39 221 20 245 96 38 125 60 181 72 3 128 43 118 106 90 15 200 8 233 181 34 5 7 174 190 71 134 170 210 207 164 152 232 51 89 112 82 165 188 21 114 191 123 230 238 197 193 95 140 244 0 0 0 0 72 200 145 197 200 104 129 137 228 214 164 61 15 232 3 217 235 218 189 116 152 154 227 248 233 253 158 5 97 255 64 215 227 139 23 14 251 106 37 121 16 114 173 198 111 218 117 222 246 94 169 123 172 250 61 68 19 205 181 67 85 17 104 14 254 137 136 84 247 78 166 0 0 1 72 200 145 197 200 104 129 137 228 214 164 61 15 232 3 217 235 218 189 116 152 154 227 248 233 253 158 5 97 255 64 215 227 139 23 14 251 106 37 121 16 114 173 198 111 218 117 222 246 94 169 123 172 250 61 68 19 205 181 67 85 17 104 14 254 137 136 84 247 78 166 0 0 0 128 191 181 108 55 139 94 198 152 77 78 82 43 3 109 236 227 118 234 47 173 167 61 164 86 55 233 192 147 235 37 168 97 183 33 155 177 136 201 235 222 168 48 190 137 110 204 183 228 175 147 199 33 208 144 139 202 91 20 77 67 243 128 152 254 108 127 176 61 57 40 166 158 31 208 193 11 83 26 80 21 170 235 14 210 177 151 96 197 239 137 246 114 65 165 208 148 237 25 245 124 152 104 92 83 194 136 203 136 100 251 64 2 205 220 145 219 198 171 222 38 134 250 16 34 65 224 146 28 1 128 191 181 108 55 139 94 198 152 77 78 82 43 3 109 236 227 118 234 47 173 167 61 164 86 55 233 192 147 235 37 168 97 183 33 155 177 136 201 235 222 168 48 190 137 110 204 183 228 175 147 199 33 208 144 139 202 91 20 77 67 243 128 152 254 108 127 176 61 57 40 166 158 31 208 193 11 83 26 80 21 170 235 14 210 177 151 96 197 239 137 246 114 65 165 208 148 237 25 245 124 152 104 92 83 194 136 203 136 100 251 64 2 205 220 145 219 198 171 222 38 134 250 16 34 65 224 146 28 0 60 63 224 19 125 187 26 164 208 55 163 27 59 187 247 242 95 30 57 122 111 64 134 84 248 151 190 15 136 136 161 61 28 228 22 27 68 11 3 140 252 156 29 4 41 11 48 15 96 244 213 20 233 6 76 130 58 119 15 0 0 1 60 63 224 19 125 187 26 164 208 55 163 27 59 187 247 242 95 30 57 122 111 64 134 84 248 151 190 15 136 136 161 61 28 228 22 27 68 11 3 140 252 156 29 4 41 11 48 15 96 244 213 20 233 6 76 130 58 119 15 0 0 0 12 199 42 98 80 178 185 90 221 165 35 3 0 1 12 199 42 98 80 178 185 90 221 165 35 3 0 0 112 211 92 224 84 192 161 220 29 37 84 220 160 179 136 96 15 250 25 26 167 119 216 78 12 23 28 94 80 65 148 105 37 226 205 178 88 179 130 190 233 252 123 197 227 186 157 58 116 47 213 216 8 19 202 72 179 134 248 62 205 139 137 198 65 155 154 205 249 99 56 187 14 119 158 233 203 37 34 208 100 56 19 122 70 223 132 177 96 84 56 150 254 49 2 204 7 119 253 28 226 37 130 47 153 193 3 66 88 188 3 0 0 1 112 211 92 224 84 192 161 220 29 37 84 220 160 179 136 96 15 250 25 26 167 119 216 78 12 23 28 94 80 65 148 105 37 226 205 178 88 179 130 190 233 252 123 197 227 186 157 58 116 47 213 216 8 19 202 72 179 134 248 62 205 139 137 198 65 155 154 205 249 99 56 187 14 119 158 233 203 37 34 208 100 56 19 122 70 223 132 177 96 84 56 150 254 49 2 204 7 119 253 28 226 37 130 47 153 193 3 66 88 188 3 0 0 0 60 140 122 119 39 180 83 252 77 149 191 129 134 12 141 62 96 133 98 170 229 37 197 136 97 68 58 105 144 236 92 39 65 44 221 243 133 48 202 183 51 237 155 98 163 154 52 14 169 35 49 67 177 150 145 49 75 8 0 0 0 1 60 140 122 119 39 180 83 252 77 149 191 129 134 12 141 62 96 133 98 170 229 37 197 136 97 68 58 105 144 236 92 39 65 44 221 243 133 48 202 183 51 237 155 98 163 154 52 14 169 35 49 67 177 150 145 49 75 8 0 0 0 0 80 9 61 184 172 233 13 43 45 30 119 185 68 107 159 107 243 178 49 80 0 96 120 155 240 156 53 48 213 202 121 253 151 95 14 88 52 193 70 56 174 121 49 216 9 237 188 33 131 0 202 142 97 27 187 215 252 182 119 74 239 189 124 236 151 198 110 105 243 51 188 18 131 2 91 205 73 28 4 0 0 1 80 9 61 184 172 233 13 43 45 30 119 185 68 107 159 107 243 178 49 80 0 96 120 155 240 156 53 48 213 202 121 253 151 95 14 88 52 193 70 56 174 121 49 216 9 237 188 33 131 0 202 142 97 27 187 215 252 182 119 74 239 189 124 236 151 198 110 105 243 51 188 18 131 2 91 205 73 28 4 0 0 0 16 137 77 210 245 248 194 39 160 111 226 179 107 25 44 0 0 1 16 137 77 210 245 248 194 39 160 111 226 179 107 25 44 0 0 0 64 90 160 7 65 4 255 208 168 205 179 4 240 248 31 206 47 175 22 191 41 103 114 135 198 218 147 111 186 210 117 127 71 122 113 161 142 45 56 90 182 5 196 124 208 246 99 179 100 179 27 123 2 247 71 97 127 214 218 135 188 45 50 128 224 1 64 90 160 7 65 4 255 208 168 205 179 4 240 248 31 206 47 175 22 191 41 103 114 135 198 218 147 111 186 210 117 127 71 122 113 161 142 45 56 90 182 5 196 124 208 246 99 179 100 179 27 123 2 247 71 97 127 214 218 135 188 45 50 128 224 0 124 32 154 212 74 8 112 124 62 201 195 129 67 76 87 211 0 54 149 15 2 59 137 176 18 143 114 152 101 173 81 166 31 220 98 29 15 12 143 193 186 10 214 32 46 186 56 227 96 71 41 12 224 186 32 190 104 219 81 226 245 30 187 162 67 12 238 66 40 214 182 170 73 67 29 245 229 231 140 16 172 204 90 196 85 159 37 247 5 72 91 26 80 132 221 105 222 230 137 161 192 217 213 175 8 134 107 130 255 104 27 119 215 213 254 251 29 13 165 7 158 123 144 75 0 1 124 32 154 212 74 8 112 124 62 201 195 129 67 76 87 211 0 54 149 15 2 59 137 176 18 143 114 152 101 173 81 166 31 220 98 29 15 12 143 193 186 10 214 32 46 186 56 227 96 71 41 12 224 186 32 190 104 219 81 226 245 30 187 162 67 12 238 66 40 214 182 170 73 67 29 245 229 231 140 16 172 204 90 196 85 159 37 247 5 72 91 26 80 132 221 105 222 230 137 161 192 217 213 175 8 134 107 130 255 104 27 119 215 213 254 251 29 13 165 7 158 123 144 75 0 0 128 239 164 224 84 239 190 177 240 167 255 153 207 198 235 157 218 101 209 117 110 57 158 113 160 68 242 223 109 247 33 237 229 57 186 145 95 59 2 2 106 153 109 194 24 239 241 188 61 245 211 125 238 32 54 37 170 29 197 209 243 122 188 213 28 57 75 147 38 170 70 103 138 223 146 28 2 3 91 146 155 55 185 226 218 164 234 79 158 254 61 31 183 119 148 157 226 56 110 177 236 227 71 43 83 82 161 247 161 196 1 164 120 80 136 191 208 140 164 14 207 160 41 164 244 119 14 0 0 1 128 239 164 224 84 239 190 177 240 167 255 153 207 198 235 157 218 101 209 117 110 57 158 113 160 68 242 223 109 247 33 237 229 57 186 145 95 59 2 2 106 153 109 194 24 239 241 188 61 245 211 125 238 32 54 37 170 29 197 209 243 122 188 213 28 57 75 147 38 170 70 103 138 223 146 28 2 3 91 146 155 55 185 226 218 164 234 79 158 254 61 31 183 119 148 157 226 56 110 177 236 227 71 43 83 82 161 247 161 196 1 164 120 80 136 191 208 140 164 14 207 160 41 164 244 119 14 0 0 0 4 117 0 0 0 1 4 117 0 0 0 0 8 167 54 193 64 7 0 0 0 1 8 167 54 193 64 7 0 0 0 0 100 163 255 64 83 203 87 36 149 94 156 52 123 63 158 204 53 182 225 176 27 17 88 255 208 169 246 109 207 8 64 136 93 175 10 180 61 49 204 55 239 115 146 100 212 148 94 230 159 166 203 181 245 53 40 149 146 56 136 42 224 170 147 35 157 91 64 177 60 196 240 153 231 11 78 17 76 195 177 43 46 180 131 25 83 109 63 119 225 27 57 57 188 91 199 152 23 5 174 91 1 1 100 163 255 64 83 203 87 36 149 94 156 52 123 63 158 204 53 182 225 176 27 17 88 255 208 169 246 109 207 8 64 136 93 175 10 180 61 49 204 55 239 115 146 100 212 148 94 230 159 166 203 181 245 53 40 149 146 56 136 42 224 170 147 35 157 91 64 177 60 196 240 153 231 11 78 17 76 195 177 43 46 180 131 25 83 109 63 119 225 27 57 57 188 91 199 152 23 5 174 91 1 0 128 208 138 109 225 227 64 152 153 2 96 34 145 164 157 131 115 155 183 104 200 193 145 244 83 249 93 179 164 174 212 200 81 147 54 91 88 194 241 160 176 132 66 20 118 17 178 241 133 189 166 164 150 50 53 47 1 210 38 252 20 112 90 129 36 107 137 165 239 174 138 211 103 99 134 246 76 212 170 81 144 177 228 153 120 20 106 60 41 27 26 142 218 209 123 220 154 21 104 181 204 11 114 252 113 18 117 199 212 53 240 129 51 13 132 82 236 158 244 158 200 100 104 97 216 25 1 0 0 1 128 208 138 109 225 227 64 152 153 2 96 34 145 164 157 131 115 155 183 104 200 193 145 244 83 249 93 179 164 174 212 200 81 147 54 91 88 194 241 160 176 132 66 20 118 17 178 241 133 189 166 164 150 50 53 47 1 210 38 252 20 112 90 129 36 107 137 165 239 174 138 211 103 99 134 246 76 212 170 81 144 177 228 153 120 20 106 60 41 27 26 142 218 209 123 220 154 21 104 181 204 11 114 252 113 18 117 199 212 53 240 129 51 13 132 82 236 158 244 158 200 100 104 97 216 25 1 0 0 0 108 88 85 211 200 39 154 110 112 105 110 167 223 36 85 108 22 191 129 29 63 186 205 74 174 242 107 26 190 218 113 172 16 57 224 133 51 114 134 142 127 13 144 200 97 128 128 218 245 64 148 11 69 93 180 151 220 172 202 66 76 33 187 244 229 35 36 242 82 235 185 65 36 190 117 245 110 49 206 180 71 37 57 255 79 12 219 105 17 123 252 191 204 128 157 112 79 129 176 184 68 206 60 102 245 5 0 0 0 1 108 88 85 211 200 39 154 110 112 105 110 167 223 36 85 108 22 191 129 29 63 186 205 74 174 242 107 26 190 218 113 172 16 57 224 133 51 114 134 142 127 13 144 200 97 128 128 218 245 64 148 11 69 93 180 151 220 172 202 66 76 33 187 244 229 35 36 242 82 235 185 65 36 190 117 245 110 49 206 180 71 37 57 255 79 12 219 105 17 123 252 191 204 128 157 112 79 129 176 184 68 206 60 102 245 5 0 0 0 0 48 148 74 37 131 247 53 39 99 216 223 47 18 9 18 136 179 193 37 55 33 91 7 244 148 62 42 57 238 215 181 93 98 8 101 69 225 214 132 204 75 52 125 56 24 213 200 8 0 1 48 148 74 37 131 247 53 39 99 216 223 47 18 9 18 136 179 193 37 55 33 91 7 244 148 62 42 57 238 215 181 93 98 8 101 69 225 214 132 204 75 52 125 56 24 213 200 8 0 0 112 64 220 239 97 7 93 87 27 105 63 207 167 21 133 15 227 58 185 168 161 239 33 193 128 172 161 15 59 239 186 103 81 115 178 232 138 149 139 198 145 252 165 58 125 110 48 134 211 40 242 174 206 78 255 94 75 31 44 237 250 204 57 72 109 14 12 198 119 229 200 254 145 184 208 143 78 161 97 105 128 146 153 84 125 239 129 93 98 110 23 17 170 158 50 181 141 42 47 152 191 196 3 192 174 110 71 240 178 232 63 60 2 1 112 64 220 239 97 7 93 87 27 105 63 207 167 21 133 15 227 58 185 168 161 239 33 193 128 172 161 15 59 239 186 103 81 115 178 232 138 149 139 198 145 252 165 58 125 110 48 134 211 40 242 174 206 78 255 94 75 31 44 237 250 204 57 72 109 14 12 198 119 229 200 254 145 184 208 143 78 161 97 105 128 146 153 84 125 239 129 93 98 110 23 17 170 158 50 181 141 42 47 152 191 196 3 192 174 110 71 240 178 232 63 60 2 0 88 246 113 176 137 13 123 106 26 224 128 91 228 193 243 252 242 15 62 220 212 178 30 202 11 111 66 230 161 177 241 60 253 100 208 201 117 225 216 68 197 128 174 145 95 149 128 91 24 175 176 25 111 104 124 66 50 242 232 64 14 195 239 251 14 206 116 190 242 168 216 235 100 161 227 42 119 101 187 234 141 57 76 100 11 246 212 179 0 1 88 246 113 176 137 13 123 106 26 224 128 91 228 193 243 252 242 15 62 220 212 178 30 202 11 111 66 230 161 177 241 60 253 100 208 201 117 225 216 68 197 128 174 145 95 149 128 91 24 175 176 25 111 104 124 66 50 242 232 64 14 195 239 251 14 206 116 190 242 168 216 235 100 161 227 42 119 101 187 234 141 57 76 100 11 246 212 179 0 0 12 55 56 172 187 58 164 70 156 120 82 181 1 1 12 55 56 172 187 58 164 70 156 120 82 181 1 0 48 220 172 17 9 205 156 24 242 134 168 180 223 153 206 236 236 90 205 11 224 120 98 214 90 123 243 129 201 165 220 225 6 36 19 55 134 83 178 129 164 32 109 15 112 3 0 0 0 1 48 220 172 17 9 205 156 24 242 134 168 180 223 153 206 236 236 90 205 11 224 120 98 214 90 123 243 129 201 165 220 225 6 36 19 55 134 83 178 129 164 32 109 15 112 3 0 0 0 0 52 193 141 127 34 209 21 199 67 68 204 143 241 45 80 225 214 45 100 21 48 33 106 113 2 148 20 23 159 40 68 202 237 170 200 232 238 164 242 236 171 136 93 52 242 83 251 122 237 48 94 107 2 1 52 193 141 127 34 209 21 199 67 68 204 143 241 45 80 225 214 45 100 21 48 33 106 113 2 148 20 23 159 40 68 202 237 170 200 232 238 164 242 236 171 136 93 52 242 83 251 122 237 48 94 107 2 0 112 207 93 175 32 64 88 139 55 246 244 132 171 62 72 184 11 242 187 171 224 39 148 96 224 166 191 87 37 46 103 39 90 112 54 172 23 47 108 13 198 12 169 216 111 103 124 235 201 195 16 145 148 127 191 56 185 218 102 131 173 6 53 96 126 92 36 77 124 130 17 196 69 227 95 129 211 148 22 209 224 108 6 158 123 117 167 143 244 183 183 224 114 73 162 213 215 117 83 229 22 1 63 246 155 62 220 132 1 179 0 0 0 1 112 207 93 175 32 64 88 139 55 246 244 132 171 62 72 184 11 242 187 171 224 39 148 96 224 166 191 87 37 46 103 39 90 112 54 172 23 47 108 13 198 12 169 216 111 103 124 235 201 195 16 145 148 127 191 56 185 218 102 131 173 6 53 96 126 92 36 77 124 130 17 196 69 227 95 129 211 148 22 209 224 108 6 158 123 117 167 143 244 183 183 224 114 73 162 213 215 117 83 229 22 1 63 246 155 62 220 132 1 179 0 0 0 0 36 28 191 13 194 165 182 248 57 186 139 244 112 207 96 200 175 106 69 10 84 43 142 147 3 182 157 30 118 79 126 104 103 178 4 0 0 1 36 28 191 13 194 165 182 248 57 186 139 244 112 207 96 200 175 106 69 10 84 43 142 147 3 182 157 30 118 79 126 104 103 178 4 0 0 0 8 212 78 222 60 176 142 1 0 1 8 212 78 222 60 176 142 1 0 0 104 145 100 67 42 119 254 160 245 196 55 20 64 100 33 63 183 247 83 171 250 148 186 67 236 130 147 92 200 183 110 211 65 19 126 207 82 103 84 16 52 82 16 73 99 33 53 16 184 44 239 234 154 184 25 81 99 110 127 146 231 156 136 36 208 247 98 178 87 0 213 166 40 147 186 233 193 12 80 213 75 67 53 102 157 20 22 155 226 99 40 237 217 91 216 187 183 209 192 42 100 71 58 1 0 1 104 145 100 67 42 119 254 160 245 196 55 20 64 100 33 63 183 247 83 171 250 148 186 67 236 130 147 92 200 183 110 211 65 19 126 207 82 103 84 16 52 82 16 73 99 33 53 16 184 44 239 234 154 184 25 81 99 110 127 146 231 156 136 36 208 247 98 178 87 0 213 166 40 147 186 233 193 12 80 213 75 67 53 102 157 20 22 155 226 99 40 237 217 91 216 187 183 209 192 42 100 71 58 1 0 0 88 125 231 30 134 199 198 64 150 204 149 136 212 55 251 17 236 75 172 60 103 13 112 161 248 228 121 4 183 230 238 235 81 68 11 65 213 88 3 234 7 110 178 57 19 166 16 98 54 80 226 89 131 81 212 59 162 55 8 27 204 124 98 217 79 46 181 86 195 56 99 31 161 60 165 222 210 115 82 149 178 121 38 60 117 25 0 0 0 1 88 125 231 30 134 199 198 64 150 204 149 136 212 55 251 17 236 75 172 60 103 13 112 161 248 228 121 4 183 230 238 235 81 68 11 65 213 88 3 234 7 110 178 57 19 166 16 98 54 80 226 89 131 81 212 59 162 55 8 27 204 124 98 217 79 46 181 86 195 56 99 31 161 60 165 222 210 115 82 149 178 121 38 60 117 25 0 0 0 0 56 55 79 115 254 18 45 144 84 54 237 229 99 113 73 136 188 244 213 254 183 151 168 225 91 201 252 214 57 183 27 164 26 210 240 237 171 92 108 203 191 175 120 3 12 116 19 67 245 233 249 115 5 240 214 35 0 1 56 55 79 115 254 18 45 144 84 54 237 229 99 113 73 136 188 244 213 254 183 151 168 225 91 201 252 214 57 183 27 164 26 210 240 237 171 92 108 203 191 175 120 3 12 116 19 67 245 233 249 115 5 240 214 35 0 0 96 149 115 162 199 81 74 3 202 108 176 213 7 202 56 50 54 238 173 104 162 72 222 19 198 247 157 194 69 205 163 168 225 51 180 210 187 109 152 138 75 137 178 226 20 227 183 17 221 228 33 75 27 234 181 159 148 112 168 204 13 44 22 165 143 41 73 80 229 106 191 38 16 134 93 174 157 141 69 61 203 130 122 44 39 131 2 164 80 62 160 63 47 120 166 28 140 1 96 149 115 162 199 81 74 3 202 108 176 213 7 202 56 50 54 238 173 104 162 72 222 19 198 247 157 194 69 205 163 168 225 51 180 210 187 109 152 138 75 137 178 226 20 227 183 17 221 228 33 75 27 234 181 159 148 112 168 204 13 44 22 165 143 41 73 80 229 106 191 38 16 134 93 174 157 141 69 61 203 130 122 44 39 131 2 164 80 62 160 63 47 120 166 28 140 0 120 177 73 66 225 183 251 124 47 179 14 57 160 213 173 196 252 133 171 44 98 102 65 108 221 64 128 144 3 168 15 10 125 144 93 198 204 237 212 228 129 58 93 188 102 216 32 20 56 110 5 186 118 149 188 145 246 98 31 144 172 117 122 179 94 110 54 137 100 169 159 233 64 176 40 159 107 80 248 222 131 122 156 155 179 205 124 225 233 168 165 4 29 207 254 20 155 7 94 221 210 178 187 38 94 68 88 18 166 136 0 118 237 105 249 139 19 14 0 0 0 1 120 177 73 66 225 183 251 124 47 179 14 57 160 213 173 196 252 133 171 44 98 102 65 108 221 64 128 144 3 168 15 10 125 144 93 198 204 237 212 228 129 58 93 188 102 216 32 20 56 110 5 186 118 149 188 145 246 98 31 144 172 117 122 179 94 110 54 137 100 169 159 233 64 176 40 159 107 80 248 222 131 122 156 155 179 205 124 225 233 168 165 4 29 207 254 20 155 7 94 221 210 178 187 38 94 68 88 18 166 136 0 118 237 105 249 139 19 14 0 0 0 0 20 144 98 85 217 149 150 223 122 8 206 59 47 131 103 65 155 173 0 0 0 1 20 144 98 85 217 149 150 223 122 8 206 59 47 131 103 65 155 173 0 0 0 0 24 220 124 42 149 85 78 138 33 185 250 196 15 48 72 171 163 134 2 88 6 85 142 130 2 1 24 220 124 42 149 85 78 138 33 185 250 196 15 48 72 171 163 134 2 88 6 85 142 130 2 0 128 212 122 169 156 54 138 107 16 121 38 59 69 203 193 117 75 63 180 179 47 63 118 224 1 181 147 133 85 37 60 119 246 102 174 58 174 167 181 225 245 128 208 200 176 210 149 71 173 107 114 230 170 178 95 214 144 188 159 164 164 189 64 23 6 49 14 195 137 72 104 1 156 208 120 58 123 105 78 15 149 254 83 83 82 154 175 59 38 12 161 82 182 68 227 130 172 160 38 178 36 70 164 50 135 65 11 243 87 239 25 151 184 247 104 210 135 241 219 1 53 174 119 60 149 230 43 0 0 1 128 212 122 169 156 54 138 107 16 121 38 59 69 203 193 117 75 63 180 179 47 63 118 224 1 181 147 133 85 37 60 119 246 102 174 58 174 167 181 225 245 128 208 200 176 210 149 71 173 107 114 230 170 178 95 214 144 188 159 164 164 189 64 23 6 49 14 195 137 72 104 1 156 208 120 58 123 105 78 15 149 254 83 83 82 154 175 59 38 12 161 82 182 68 227 130 172 160 38 178 36 70 164 50 135 65 11 243 87 239 25 151 184 247 104 210 135 241 219 1 53 174 119 60 149 230 43 0 0 0 36 100 188 84 92 121 120 255 45 117 214 25 143 9 160 32 125 250 37 133 240 255 252 20 126 29 171 3 237 205 240 235 36 208 143 0 0 1 36 100 188 84 92 121 120 255 45 117 214 25 143 9 160 32 125 250 37 133 240 255 252 20 126 29 171 3 237 205 240 235 36 208 143 0 0 0 16 204 130 239 246 187 158 93 86 47 108 73 1 13 0 0 0 1 16 204 130 239 246 187 158 93 86 47 108 73 1 13 0 0 0 0 20 202 131 231 76 126 186 127 132 23 187 208 204 73 5 178 40 150 139 35 0 1 20 202 131 231 76 126 186 127 132 23 187 208 204 73 5 178 40 150 139 35 0 0 40 107 133 121 0 139 12 135 132 162 235 102 36 43 184 250 87 59 67 137 202 96 199 100 109 243 118 70 114 158 224 173 101 40 37 48 74 1 0 0 0 1 40 107 133 121 0 139 12 135 132 162 235 102 36 43 184 250 87 59 67 137 202 96 199 100 109 243 118 70 114 158 224 173 101 40 37 48 74 1 0 0 0 0 20 102 233 199 173 120 192 172 230 96 54 194 151 124 92 161 206 20 63 0 0 1 20 102 233 199 173 120 192 172 230 96 54 194 151 124 92 161 206 20 63 0 0 0 104 100 11 95 76 33 185 232 209 233 63 34 185 176 109 189 253 110 207 211 238 172 100 29 184 164 214 167 6 238 105 2 20 159 93 77 69 163 157 21 207 95 133 129 211 104 170 34 230 70 233 190 110 110 143 167 140 190 151 103 146 32 227 27 255 248 240 157 241 20 32 236 100 44 139 162 28 213 191 101 140 119 176 40 84 199 138 241 56 14 243 128 9 9 244 235 30 65 225 224 112 146 250 26 0 1 104 100 11 95 76 33 185 232 209 233 63 34 185 176 109 189 253 110 207 211 238 172 100 29 184 164 214 167 6 238 105 2 20 159 93 77 69 163 157 21 207 95 133 129 211 104 170 34 230 70 233 190 110 110 143 167 140 190 151 103 146 32 227 27 255 248 240 157 241 20 32 236 100 44 139 162 28 213 191 101 140 119 176 40 84 199 138 241 56 14 243 128 9 9 244 235 30 65 225 224 112 146 250 26 0 0 112 182 231 30 134 177 100 37 122 104 11 71 195 133 25 28 169 0 181 147 130 44 177 101 57 112 42 199 21 101 103 140 223 42 216 201 189 53 195 100 237 238 71 248 113 40 44 240 38 199 64 195 184 81 25 41 68 92 218 4 53 122 241 204 51 58 42 144 93 242 88 103 109 196 188 0 52 79 84 246 121 89 177 54 12 27 96 80 73 210 243 157 157 69 16 99 156 41 206 86 47 228 138 204 240 83 60 157 254 252 73 192 5 1 112 182 231 30 134 177 100 37 122 104 11 71 195 133 25 28 169 0 181 147 130 44 177 101 57 112 42 199 21 101 103 140 223 42 216 201 189 53 195 100 237 238 71 248 113 40 44 240 38 199 64 195 184 81 25 41 68 92 218 4 53 122 241 204 51 58 42 144 93 242 88 103 109 196 188 0 52 79 84 246 121 89 177 54 12 27 96 80 73 210 243 157 157 69 16 99 156 41 206 86 47 228 138 204 240 83 60 157 254 252 73 192 5 0 12 197 213 123 115 98 52 254 70 238 15 1 0 1 12 197 213 123 115 98 52 254 70 238 15 1 0 0 76 210 145 122 99 89 37 131 47 52 147 113 130 64 191 58 127 124 89 27 75 1 37 219 223 7 191 140 168 223 254 58 21 31 33 247 253 167 137 36 155 41 0 231 239 197 12 2 35 195 249 194 240 216 58 92 5 213 221 245 127 195 161 21 118 66 85 175 221 8 222 64 201 103 150 0 0 1 76 210 145 122 99 89 37 131 47 52 147 113 130 64 191 58 127 124 89 27 75 1 37 219 223 7 191 140 168 223 254 58 21 31 33 247 253 167 137 36 155 41 0 231 239 197 12 2 35 195 249 194 240 216 58 92 5 213 221 245 127 195 161 21 118 66 85 175 221 8 222 64 201 103 150 0 0 0 84 102 17 96 82 154 52 112 87 18 167 167 218 54 218 124 208 194 201 83 97 231 176 221 100 220 46 62 248 6 192 115 8 87 141 125 98 123 239 88 101 67 173 98 197 3 232 107 94 225 39 234 38 220 115 81 68 201 24 107 126 207 211 147 102 232 111 120 175 151 194 198 220 102 170 182 69 63 31 181 226 6 0 0 0 1 84 102 17 96 82 154 52 112 87 18 167 167 218 54 218 124 208 194 201 83 97 231 176 221 100 220 46 62 248 6 192 115 8 87 141 125 98 123 239 88 101 67 173 98 197 3 232 107 94 225 39 234 38 220 115 81 68 201 24 107 126 207 211 147 102 232 111 120 175 151 194 198 220 102 170 182 69 63 31 181 226 6 0 0 0 0 72 145 142 130 152 168 95 187 252 167 72 111 60 173 234 4 233 25 77 201 212 221 165 137 12 169 149 226 137 232 12 31 136 171 31 255 243 138 160 179 185 30 246 120 97 97 100 77 175 51 130 43 32 46 143 163 120 150 96 104 169 233 159 139 198 126 120 21 227 79 54 10 0 1 72 145 142 130 152 168 95 187 252 167 72 111 60 173 234 4 233 25 77 201 212 221 165 137 12 169 149 226 137 232 12 31 136 171 31 255 243 138 160 179 185 30 246 120 97 97 100 77 175 51 130 43 32 46 143 163 120 150 96 104 169 233 159 139 198 126 120 21 227 79 54 10 0 0 4 209 5 0 0 1 4 209 5 0 0 0 20 69 29 214 123 179 196 196 154 251 96 42 73 71 146 179 99 47 210 101 0 1 20 69 29 214 123 179 196 196 154 251 96 42 73 71 146 179 99 47 210 101 0 0 88 205 231 92 64 63 136 90 54 204 92 82 240 111 88 87 211 205 64 177 174 111 246 250 90 188 132 108 77 132 226 209 192 221 34 204 124 101 65 183 13 73 28 188 123 178 61 12 115 7 113 85 201 249 122 39 164 5 195 152 12 24 213 221 225 91 183 40 236 164 234 105 15 207 109 160 192 144 206 42 56 17 71 51 153 182 149 229 1 1 88 205 231 92 64 63 136 90 54 204 92 82 240 111 88 87 211 205 64 177 174 111 246 250 90 188 132 108 77 132 226 209 192 221 34 204 124 101 65 183 13 73 28 188 123 178 61 12 115 7 113 85 201 249 122 39 164 5 195 152 12 24 213 221 225 91 183 40 236 164 234 105 15 207 109 160 192 144 206 42 56 17 71 51 153 182 149 229 1 0 112 75 185 2 45 158 234 42 220 77 129 40 207 111 250 118 209 102 233 123 133 227 197 44 57 196 23 50 237 189 56 114 42 117 188 70 201 140 176 85 119 26 80 196 78 38 152 73 81 60 72 29 44 30 96 127 77 209 43 84 19 238 161 199 121 222 254 69 226 80 194 175 85 135 165 209 175 199 237 223 219 141 82 63 115 118 194 96 58 8 45 138 219 118 118 250 164 228 179 178 255 210 12 129 255 206 164 214 156 233 1 0 0 1 112 75 185 2 45 158 234 42 220 77 129 40 207 111 250 118 209 102 233 123 133 227 197 44 57 196 23 50 237 189 56 114 42 117 188 70 201 140 176 85 119 26 80 196 78 38 152 73 81 60 72 29 44 30 96 127 77 209 43 84 19 238 161 199 121 222 254 69 226 80 194 175 85 135 165 209 175 199 237 223 219 141 82 63 115 118 194 96 58 8 45 138 219 118 118 250 164 228 179 178 255 210 12 129 255 206 164 214 156 233 1 0 0 0 72 170 113 192 138 104 174 124 39 73 93 28 193 169 216 164 220 91 84 152 21 86 210 138 141 248 203 166 85 144 162 254 201 183 85 193 224 116 40 113 190 178 244 129 164 250 249 19 14 209 96 142 161 190 213 129 69 159 67 19 1 205 41 215 144 51 30 49 29 6 0 0 0 1 72 170 113 192 138 104 174 124 39 73 93 28 193 169 216 164 220 91 84 152 21 86 210 138 141 248 203 166 85 144 162 254 201 183 85 193 224 116 40 113 190 178 244 129 164 250 249 19 14 209 96 142 161 190 213 129 69 159 67 19 1 205 41 215 144 51 30 49 29 6 0 0 0 0 80 187 125 249 0 237 185 92 151 185 34 111 175 129 204 191 155 242 60 103 220 201 34 29 144 204 63 230 124 192 11 86 89 46 248 84 65 216 118 216 186 101 34 52 12 183 171 200 31 196 236 206 37 26 50 4 49 58 103 122 211 219 34 244 124 191 195 111 184 185 248 253 224 239 127 121 202 148 98 106 14 1 80 187 125 249 0 237 185 92 151 185 34 111 175 129 204 191 155 242 60 103 220 201 34 29 144 204 63 230 124 192 11 86 89 46 248 84 65 216 118 216 186 101 34 52 12 183 171 200 31 196 236 206 37 26 50 4 49 58 103 122 211 219 34 244 124 191 195 111 184 185 248 253 224 239 127 121 202 148 98 106 14 0 60 139 102 172 114 149 72 104 165 114 58 106 15 225 235 97 205 254 36 224 45 49 116 146 137 86 251 107 88 136 139 83 17 137 15 7 72 222 67 112 165 159 252 189 213 77 46 142 192 37 63 205 124 221 187 30 104 5 0 0 0 1 60 139 102 172 114 149 72 104 165 114 58 106 15 225 235 97 205 254 36 224 45 49 116 146 137 86 251 107 88 136 139 83 17 137 15 7 72 222 67 112 165 159 252 189 213 77 46 142 192 37 63 205 124 221 187 30 104 5 0 0 0 0 48 193 117 186 128 69 247 91 107 62 131 175 40 131 137 103 76 253 5 75 34 122 71 127 130 217 242 2 7 156 145 247 63 191 243 59 172 98 22 239 18 159 250 155 96 146 0 0 0 1 48 193 117 186 128 69 247 91 107 62 131 175 40 131 137 103 76 253 5 75 34 122 71 127 130 217 242 2 7 156 145 247 63 191 243 59 172 98 22 239 18 159 250 155 96 146 0 0 0 0 28 47 51 76 163 249 78 98 148 84 63 232 105 55 224 47 211 142 180 28 84 89 211 77 14 249 46 0 0 1 28 47 51 76 163 249 78 98 148 84 63 232 105 55 224 47 211 142 180 28 84 89 211 77 14 249 46 0 0 0 68 201 214 155 246 50 22 166 239 223 78 244 233 195 105 89 119 99 157 184 116 51 233 12 83 167 255 76 111 102 220 89 20 93 143 234 73 99 250 59 120 26 217 181 201 39 66 23 209 115 214 70 225 241 60 167 247 136 252 1 227 55 151 13 131 195 45 0 0 1 68 201 214 155 246 50 22 166 239 223 78 244 233 195 105 89 119 99 157 184 116 51 233 12 83 167 255 76 111 102 220 89 20 93 143 234 73 99 250 59 120 26 217 181 201 39 66 23 209 115 214 70 225 241 60 167 247 136 252 1 227 55 151 13 131 195 45 0 0 0 20 23 30 33 8 157 238 224 164 246 31 43 191 176 252 7 205 45 242 0 0 1 20 23 30 33 8 157 238 224 164 246 31 43 191 176 252 7 205 45 242 0 0 0 52 54 228 32 91 115 93 129 151 246 253 217 44 135 61 82 191 178 138 66 53 138 127 124 132 49 110 155 83 6 68 149 49 137 123 196 184 39 167 125 47 74 249 193 203 43 79 83 101 134 133 9 11 1 52 54 228 32 91 115 93 129 151 246 253 217 44 135 61 82 191 178 138 66 53 138 127 124 132 49 110 155 83 6 68 149 49 137 123 196 184 39 167 125 47 74 249 193 203 43 79 83 101 134 133 9 11 0 52 77 188 100 119 111 50 9 100 13 63 121 125 142 166 34 201 103 64 166 45 83 205 159 233 137 246 116 27 220 206 160 89 216 10 52 203 22 78 211 51 23 240 179 183 83 170 242 111 240 0 0 0 1 52 77 188 100 119 111 50 9 100 13 63 121 125 142 166 34 201 103 64 166 45 83 205 159 233 137 246 116 27 220 206 160 89 216 10 52 203 22 78 211 51 23 240 179 183 83 170 242 111 240 0 0 0 0 12 183 62 167 189 129 14 105 162 209 89 0 0 1 12 183 62 167 189 129 14 105 162 209 89 0 0 0 100 118 204 239 47 128 120 188 223 1 55 39 227 110 234 226 46 9 49 105 96 118 213 142 45 148 25 46 222 99 148 85 221 31 128 11 140 49 253 179 116 86 166 9 89 85 77 43 213 244 104 94 141 180 94 152 53 231 238 203 17 49 2 219 158 139 90 32 173 163 68 117 8 23 52 205 75 107 41 4 131 110 118 52 89 83 200 125 45 226 180 48 90 244 16 175 35 209 5 0 0 1 100 118 204 239 47 128 120 188 223 1 55 39 227 110 234 226 46 9 49 105 96 118 213 142 45 148 25 46 222 99 148 85 221 31 128 11 140 49 253 179 116 86 166 9 89 85 77 43 213 244 104 94 141 180 94 152 53 231 238 203 17 49 2 219 158 139 90 32 173 163 68 117 8 23 52 205 75 107 41 4 131 110 118 52 89 83 200 125 45 226 180 48 90 244 16 175 35 209 5 0 0 0 32 141 129 3 16 248 10 239 222 142 76 62 151 42 178 39 242 64 15 167 154 168 11 249 175 85 5 12 3 103 49 42 0 1 32 141 129 3 16 248 10 239 222 142 76 62 151 42 178 39 242 64 15 167 154 168 11 249 175 85 5 12 3 103 49 42 0 0 8 123 78 196 123 153 10 0 0 1 8 123 78 196 123 153 10 0 0 0 16 144 212 195 123 171 191 34 243 189 164 67 38 150 212 224 39 1 16 144 212 195 123 171 191 34 243 189 164 67 38 150 212 224 39 0 32 187 134 178 60 106 197 246 170 105 173 38 215 230 126 251 232 114 84 137 220 128 251 54 111 198 172 1 114 19 30 189 175 1 32 187 134 178 60 106 197 246 170 105 173 38 215 230 126 251 232 114 84 137 220 128 251 54 111 198 172 1 114 19 30 189 175 0 24 143 215 216 189 149 84 197 67 202 64 106 120 162 162 86 42 64 51 134 144 124 43 171 16 1 24 143 215 216 189 149 84 197 67 202 64 106 120 162 162 86 42 64 51 134 144 124 43 171 16 0 68 139 212 65 201 234 213 89 222 141 127 253 158 87 57 57 116 99 73 197 165 146 10 238 243 162 67 87 231 145 147 216 148 210 201 209 126 220 255 168 121 230 233 9 201 51 185 90 86 120 23 45 86 96 77 163 130 157 206 192 50 201 33 37 54 59 0 0 0 1 68 139 212 65 201 234 213 89 222 141 127 253 158 87 57 57 116 99 73 197 165 146 10 238 243 162 67 87 231 145 147 216 148 210 201 209 126 220 255 168 121 230 233 9 201 51 185 90 86 120 23 45 86 96 77 163 130 157 206 192 50 201 33 37 54 59 0 0 0 0 32 23 231 42 113 193 81 226 51 220 131 214 166 146 8 75 191 48 0 176 34 36 39 225 46 186 62 45 29 56 240 98 0 1 32 23 231 42 113 193 81 226 51 220 131 214 166 146 8 75 191 48 0 176 34 36 39 225 46 186 62 45 29 56 240 98 0 0 108 227 163 90 90 118 151 96 241 208 91 153 230 68 148 109 36 156 59 108 3 56 117 211 213 19 39 240 123 158 82 0 37 126 14 223 103 223 22 131 216 204 69 250 101 220 238 12 18 77 151 114 103 62 43 207 60 13 44 63 145 155 196 15 104 68 124 226 214 9 255 2 209 143 177 56 5 128 66 245 24 171 251 123 103 175 179 158 169 79 76 238 144 42 92 164 86 181 59 182 45 185 118 125 221 29 2 0 0 1 108 227 163 90 90 118 151 96 241 208 91 153 230 68 148 109 36 156 59 108 3 56 117 211 213 19 39 240 123 158 82 0 37 126 14 223 103 223 22 131 216 204 69 250 101 220 238 12 18 77 151 114 103 62 43 207 60 13 44 63 145 155 196 15 104 68 124 226 214 9 255 2 209 143 177 56 5 128 66 245 24 171 251 123 103 175 179 158 169 79 76 238 144 42 92 164 86 181 59 182 45 185 118 125 221 29 2 0 0 0 56 21 205 7 125 176 60 227 180 194 177 238 254 236 214 253 45 120 92 88 238 119 13 43 164 250 120 212 254 127 151 28 105 87 83 93 136 139 49 151 198 102 118 229 122 40 245 156 201 162 113 68 119 67 16 0 0 1 56 21 205 7 125 176 60 227 180 194 177 238 254 236 214 253 45 120 92 88 238 119 13 43 164 250 120 212 254 127 151 28 105 87 83 93 136 139 49 151 198 102 118 229 122 40 245 156 201 162 113 68 119 67 16 0 0 0 128 109 98 40 183 212 31 133 44 220 177 117 246 95 158 65 148 190 211 252 136 162 225 177 247 115 56 178 10 194 128 11 57 161 119 91 128 227 125 160 201 170 74 199 20 117 57 205 164 167 39 140 51 104 152 111 244 236 125 79 209 50 96 221 6 70 174 222 210 141 0 0 38 91 25 23 175 171 151 185 223 189 29 181 4 186 136 186 187 211 92 240 132 239 86 157 142 233 42 105 221 144 98 224 139 152 138 40 2 75 65 232 64 78 37 25 85 43 247 17 170 71 235 54 68 95 61 0 0 1 128 109 98 40 183 212 31 133 44 220 177 117 246 95 158 65 148 190 211 252 136 162 225 177 247 115 56 178 10 194 128 11 57 161 119 91 128 227 125 160 201 170 74 199 20 117 57 205 164 167 39 140 51 104 152 111 244 236 125 79 209 50 96 221 6 70 174 222 210 141 0 0 38 91 25 23 175 171 151 185 223 189 29 181 4 186 136 186 187 211 92 240 132 239 86 157 142 233 42 105 221 144 98 224 139 152 138 40 2 75 65 232 64 78 37 25 85 43 247 17 170 71 235 54 68 95 61 0 0 0 8 84 104 15 69 62 160 26 0 1 8 84 104 15 69 62 160 26 0 0 108 219 65 187 13 190 48 46 122 32 188 62 55 54 62 116 201 244 243 89 151 14 43 21 29 19 142 33 75 56 94 48 19 170 145 179 161 25 76 133 125 215 133 4 159 74 89 201 157 226 92 172 10 213 88 179 123 109 36 223 242 66 12 21 230 200 219 144 151 19 8 235 54 85 254 74 95 63 248 92 164 209 97 251 119 65 142 10 170 247 216 222 98 38 21 72 54 73 122 224 248 221 198 101 236 254 0 0 0 1 108 219 65 187 13 190 48 46 122 32 188 62 55 54 62 116 201 244 243 89 151 14 43 21 29 19 142 33 75 56 94 48 19 170 145 179 161 25 76 133 125 215 133 4 159 74 89 201 157 226 92 172 10 213 88 179 123 109 36 223 242 66 12 21 230 200 219 144 151 19 8 235 54 85 254 74 95 63 248 92 164 209 97 251 119 65 142 10 170 247 216 222 98 38 21 72 54 73 122 224 248 221 198 101 236 254 0 0 0 0 116 173 131 100 228 57 121 99 67 36 188 26 116 195 11 33 238 99 149 244 192 69 122 152 142 206 32 93 57 158 59 204 109 129 133 85 46 84 246 35 199 170 91 5 153 166 135 136 100 219 159 177 96 71 252 20 164 194 225 242 95 219 102 176 247 177 135 49 219 166 200 159 163 69 215 174 34 15 87 114 111 202 124 88 204 39 19 12 146 233 34 22 85 241 111 63 103 250 222 19 62 55 235 240 190 151 122 115 229 120 69 13 175 97 196 211 28 1 116 173 131 100 228 57 121 99 67 36 188 26 116 195 11 33 238 99 149 244 192 69 122 152 142 206 32 93 57 158 59 204 109 129 133 85 46 84 246 35 199 170 91 5 153 166 135 136 100 219 159 177 96 71 252 20 164 194 225 242 95 219 102 176 247 177 135 49 219 166 200 159 163 69 215 174 34 15 87 114 111 202 124 88 204 39 19 12 146 233 34 22 85 241 111 63 103 250 222 19 62 55 235 240 190 151 122 115 229 120 69 13 175 97 196 211 28 0 40 243 42 248 54 150 57 118 223 89 213 123 0 145 11 121 246 65 78 171 9 235 26 93 69 20 253 245 14 109 46 33 35 29 254 140 52 122 13 60 0 1 40 243 42 248 54 150 57 118 223 89 213 123 0 145 11 121 246 65 78 171 9 235 26 93 69 20 253 245 14 109 46 33 35 29 254 140 52 122 13 60 0 0 124 203 79 238 32 121 29 119 220 119 105 16 43 194 81 73 221 217 2 148 227 212 111 94 30 4 186 210 125 205 136 245 32 214 39 108 83 11 185 216 199 221 176 13 218 150 42 152 40 224 210 120 250 254 120 131 79 250 21 126 178 2 237 252 78 209 43 98 114 190 99 82 138 216 142 31 167 59 58 104 199 119 105 205 151 40 188 42 120 215 171 111 159 24 71 230 74 3 175 149 59 28 47 26 232 212 124 173 155 1 51 182 82 59 115 81 68 151 198 197 107 41 0 0 0 1 124 203 79 238 32 121 29 119 220 119 105 16 43 194 81 73 221 217 2 148 227 212 111 94 30 4 186 210 125 205 136 245 32 214 39 108 83 11 185 216 199 221 176 13 218 150 42 152 40 224 210 120 250 254 120 131 79 250 21 126 178 2 237 252 78 209 43 98 114 190 99 82 138 216 142 31 167 59 58 104 199 119 105 205 151 40 188 42 120 215 171 111 159 24 71 230 74 3 175 149 59 28 47 26 232 212 124 173 155 1 51 182 82 59 115 81 68 151 198 197 107 41 0 0 0 0 8 70 47 94 78 85 213 4 0 1 8 70 47 94 78 85 213 4 0 0 64 168 239 3 109 249 109 253 64 147 102 173 10 159 193 47 134 235 24 116 111 234 17 218 47 133 118 130 4 234 130 216 79 86 7 158 19 179 226 92 28 11 213 95 197 165 161 196 126 158 172 83 45 60 0 243 82 11 125 51 88 204 253 201 0 1 64 168 239 3 109 249 109 253 64 147 102 173 10 159 193 47 134 235 24 116 111 234 17 218 47 133 118 130 4 234 130 216 79 86 7 158 19 179 226 92 28 11 213 95 197 165 161 196 126 158 172 83 45 60 0 243 82 11 125 51 88 204 253 201 0 0 32 91 8 155 0 244 185 150 213 21 51 193 238 33 114 252 243 203 63 197 56 17 152 0 158 202 81 224 155 176 168 48 8 1 32 91 8 155 0 244 185 150 213 21 51 193 238 33 114 252 243 203 63 197 56 17 152 0 158 202 81 224 155 176 168 48 8 0 64 237 110 141 244 234 81 71 9 84 235 128 228 166 210 171 84 207 172 13 18 245 134 71 141 15 168 153 177 38 185 201 244 241 170 222 1 133 147 146 102 43 229 200 175 199 75 172 190 162 84 189 67 156 147 154 31 13 207 129 50 200 231 74 0 1 64 237 110 141 244 234 81 71 9 84 235 128 228 166 210 171 84 207 172 13 18 245 134 71 141 15 168 153 177 38 185 201 244 241 170 222 1 133 147 146 102 43 229 200 175 199 75 172 190 162 84 189 67 156 147 154 31 13 207 129 50 200 231 74 0 0 72 87 52 91 18 47 239 64 167 1 198 52 25 230 164 41 73 76 171 61 96 213 30 252 201 4 21 212 155 40 229 150 154 204 69 5 231 234 118 236 96 115 165 148 146 43 62 108 172 9 72 82 112 145 170 221 58 127 30 73 27 88 182 208 159 212 102 122 105 69 67 0 0 1 72 87 52 91 18 47 239 64 167 1 198 52 25 230 164 41 73 76 171 61 96 213 30 252 201 4 21 212 155 40 229 150 154 204 69 5 231 234 118 236 96 115 165 148 146 43 62 108 172 9 72 82 112 145 170 221 58 127 30 73 27 88 182 208 159 212 102 122 105 69 67 0 0 0 44 64 172 114 48 214 193 164 216 67 60 29 158 200 157 119 130 148 115 28 173 33 19 100 127 6 67 27 159 246 211 0 250 103 226 195 106 155 248 97 202 123 209 221 13 1 44 64 172 114 48 214 193 164 216 67 60 29 158 200 157 119 130 148 115 28 173 33 19 100 127 6 67 27 159 246 211 0 250 103 226 195 106 155 248 97 202 123 209 221 13 0 116 81 252 110 197 13 166 231 72 130 41 106 65 232 254 107 124 243 255 107 207 47 194 183 40 150 50 4 210 204 224 43 196 247 122 120 215 166 135 245 209 137 61 188 138 187 74 103 184 183 141 129 116 149 165 53 145 106 74 23 238 142 63 216 57 144 68 13 165 129 66 25 38 206 230 110 91 93 226 41 154 75 235 92 163 186 140 230 191 218 201 127 59 108 139 3 252 44 100 3 234 46 162 34 110 218 167 38 61 218 67 214 231 20 40 0 0 1 116 81 252 110 197 13 166 231 72 130 41 106 65 232 254 107 124 243 255 107 207 47 194 183 40 150 50 4 210 204 224 43 196 247 122 120 215 166 135 245 209 137 61 188 138 187 74 103 184 183 141 129 116 149 165 53 145 106 74 23 238 142 63 216 57 144 68 13 165 129 66 25 38 206 230 110 91 93 226 41 154 75 235 92 163 186 140 230 191 218 201 127 59 108 139 3 252 44 100 3 234 46 162 34 110 218 167 38 61 218 67 214 231 20 40 0 0 0 116 243 247 18 11 29 244 71 100 171 9 7 235 135 165 185 174 82 125 144 46 101 141 39 25 219 161 166 142 138 73 193 151 231 217 184 5 47 234 106 36 39 20 133 77 81 241 34 12 59 55 212 158 163 139 77 54 232 111 133 109 11 226 82 170 77 232 17 218 114 50 113 152 83 202 219 168 218 132 34 241 173 58 247 200 6 151 173 6 185 4 118 166 131 92 255 162 247 111 148 166 68 56 169 253 254 48 168 30 109 251 179 213 140 46 219 3 1 116 243 247 18 11 29 244 71 100 171 9 7 235 135 165 185 174 82 125 144 46 101 141 39 25 219 161 166 142 138 73 193 151 231 217 184 5 47 234 106 36 39 20 133 77 81 241 34 12 59 55 212 158 163 139 77 54 232 111 133 109 11 226 82 170 77 232 17 218 114 50 113 152 83 202 219 168 218 132 34 241 173 58 247 200 6 151 173 6 185 4 118 166 131 92 255 162 247 111 148 166 68 56 169 253 254 48 168 30 109 251 179 213 140 46 219 3 0 48 170 134 196 251 187 25 104 34 95 69 85 184 199 0 89 253 150 101 212 7 202 243 18 178 248 98 105 134 18 215 189 22 99 238 235 78 124 3 142 134 188 8 188 178 2 0 0 0 1 48 170 134 196 251 187 25 104 34 95 69 85 184 199 0 89 253 150 101 212 7 202 243 18 178 248 98 105 134 18 215 189 22 99 238 235 78 124 3 142 134 188 8 188 178 2 0 0 0 0 48 200 105 57 90 124 53 229 14 158 143 66 34 150 228 210 143 188 213 175 175 21 92 123 213 52 223 97 128 64 234 169 31 165 1 230 126 33 17 32 28 25 238 131 159 125 84 120 8 1 48 200 105 57 90 124 53 229 14 158 143 66 34 150 228 210 143 188 213 175 175 21 92 123 213 52 223 97 128 64 234 169 31 165 1 230 126 33 17 32 28 25 238 131 159 125 84 120 8 0 8 236 26 245 49 19 0 0 0 1 8 236 26 245 49 19 0 0 0 0 16 134 207 199 26 175 188 103 160 76 140 48 55 30 189 7 0 1 16 134 207 199 26 175 188 103 160 76 140 48 55 30 189 7 0 0 24 7 216 8 30 195 251 90 24 198 179 171 59 27 243 102 163 205 126 247 84 4 0 0 0 1 24 7 216 8 30 195 251 90 24 198 179 171 59 27 243 102 163 205 126 247 84 4 0 0 0 0 100 89 190 73 217 127 252 160 134 16 114 94 182 255 223 176 58 217 71 107 33 21 118 140 226 166 128 254 219 248 19 33 93 9 225 89 44 103 188 91 203 146 155 17 20 40 125 153 23 87 125 86 166 25 181 17 220 165 143 13 245 94 144 64 231 41 17 165 224 79 44 34 246 169 187 130 155 57 121 213 161 21 178 163 44 75 169 37 6 67 200 63 171 50 214 213 230 10 148 179 25 1 100 89 190 73 217 127 252 160 134 16 114 94 182 255 223 176 58 217 71 107 33 21 118 140 226 166 128 254 219 248 19 33 93 9 225 89 44 103 188 91 203 146 155 17 20 40 125 153 23 87 125 86 166 25 181 17 220 165 143 13 245 94 144 64 231 41 17 165 224 79 44 34 246 169 187 130 155 57 121 213 161 21 178 163 44 75 169 37 6 67 200 63 171 50 214 213 230 10 148 179 25 0 116 239 141 241 165 45 224 229 17 155 67 37 181 127 150 115 133 137 72 239 12 3 103 142 204 53 108 13 4 11 96 213 15 192 155 67 147 30 66 19 222 160 17 202 156 77 143 151 241 100 236 128 33 207 105 116 196 68 142 109 237 94 29 86 196 190 96 158 51 78 107 53 2 158 62 195 101 125 181 245 191 185 105 37 77 113 109 85 110 93 152 188 115 136 136 93 10 235 225 51 77 110 7 74 32 118 44 157 117 193 127 80 54 2 0 0 0 1 116 239 141 241 165 45 224 229 17 155 67 37 181 127 150 115 133 137 72 239 12 3 103 142 204 53 108 13 4 11 96 213 15 192 155 67 147 30 66 19 222 160 17 202 156 77 143 151 241 100 236 128 33 207 105 116 196 68 142 109 237 94 29 86 196 190 96 158 51 78 107 53 2 158 62 195 101 125 181 245 191 185 105 37 77 113 109 85 110 93 152 188 115 136 136 93 10 235 225 51 77 110 7 74 32 118 44 157 117 193 127 80 54 2 0 0 0 0 52 161 103 132 41 228 199 245 93 101 166 142 168 205 96 95 52 143 127 100 173 175 132 102 181 237 4 42 52 30 10 219 202 27 68 79 23 201 116 89 53 50 85 239 183 254 11 165 100 129 247 0 0 1 52 161 103 132 41 228 199 245 93 101 166 142 168 205 96 95 52 143 127 100 173 175 132 102 181 237 4 42 52 30 10 219 202 27 68 79 23 201 116 89 53 50 85 239 183 254 11 165 100 129 247 0 0 0 28 255 251 221 115 146 46 163 229 176 14 203 138 27 28 41 62 22 109 49 16 185 119 54 172 191 85 184 0 1 28 255 251 221 115 146 46 163 229 176 14 203 138 27 28 41 62 22 109 49 16 185 119 54 172 191 85 184 0 0 32 247 33 196 253 43 205 187 127 110 212 213 12 214 143 22 252 209 96 90 89 50 103 47 68 146 216 72 215 61 226 134 3 1 32 247 33 196 253 43 205 187 127 110 212 213 12 214 143 22 252 209 96 90 89 50 103 47 68 146 216 72 215 61 226 134 3 0 36 59 97 19 31 78 83 69 133 60 42 103 67 71 156 83 145 176 67 103 93 114 176 15 117 43 90 82 152 45 121 12 17 76 244 53 1 1 36 59 97 19 31 78 83 69 133 60 42 103 67 71 156 83 145 176 67 103 93 114 176 15 117 43 90 82 152 45 121 12 17 76 244 53 1 0 52 219 241 133 51 75 86 155 36 83 56 69 111 93 54 193 19 54 88 242 30 144 132 66 61 131 189 217 126 87 64 134 162 139 199 3 85 234 160 230 114 164 25 154 94 87 76 241 251 243 147 109 83 1 52 219 241 133 51 75 86 155 36 83 56 69 111 93 54 193 19 54 88 242 30 144 132 66 61 131 189 217 126 87 64 134 162 139 199 3 85 234 160 230 114 164 25 154 94 87 76 241 251 243 147 109 83 0 64 43 137 16 132 202 104 91 201 107 180 196 200 93 138 129 13 78 33 73 134 236 116 150 83 184 197 132 23 82 3 247 20 140 181 22 152 27 60 63 98 254 172 152 20 58 101 176 236 139 225 217 61 37 39 22 240 147 101 158 189 117 172 129 3 1 64 43 137 16 132 202 104 91 201 107 180 196 200 93 138 129 13 78 33 73 134 236 116 150 83 184 197 132 23 82 3 247 20 140 181 22 152 27 60 63 98 254 172 152 20 58 101 176 236 139 225 217 61 37 39 22 240 147 101 158 189 117 172 129 3 0 16 174 250 80 27 225 76 117 105 139 6 48 23 21 0 0 0 1 16 174 250 80 27 225 76 117 105 139 6 48 23 21 0 0 0 0 32 79 208 51 133 78 86 8 203 246 180 251 28 21 185 125 159 144 112 64 104 31 37 123 126 115 170 223 1 66 0 0 0 1 32 79 208 51 133 78 86 8 203 246 180 251 28 21 185 125 159 144 112 64 104 31 37 123 126 115 170 223 1 66 0 0 0 0 20 59 170 196 192 162 161 183 242 120 40 171 157 254 236 242 64 223 1 0 0 1 20 59 170 196 192 162 161 183 242 120 40 171 157 254 236 242 64 223 1 0 0 0 64 158 138 13 99 212 72 79 220 230 16 119 150 64 148 121 100 5 104 182 189 57 158 100 143 129 122 146 11 169 192 52 74 169 74 4 0 229 160 168 226 62 202 182 250 171 51 251 90 159 122 13 111 16 28 141 139 1 41 229 97 17 73 120 0 1 64 158 138 13 99 212 72 79 220 230 16 119 150 64 148 121 100 5 104 182 189 57 158 100 143 129 122 146 11 169 192 52 74 169 74 4 0 229 160 168 226 62 202 182 250 171 51 251 90 159 122 13 111 16 28 141 139 1 41 229 97 17 73 120 0 0 124 54 211 84 85 147 162 152 160 127 96 156 128 144 183 140 26 170 242 255 112 211 16 24 233 93 177 189 62 26 230 8 18 162 102 53 79 255 93 127 37 173 116 119 61 21 221 30 71 51 18 217 197 225 89 208 228 54 16 14 158 40 254 222 6 144 144 95 30 116 51 208 187 221 207 73 40 215 178 180 184 67 243 230 235 85 174 4 118 231 32 148 73 211 37 140 151 196 184 12 41 14 98 78 190 103 107 141 66 52 100 222 58 141 135 84 85 90 76 97 21 18 0 0 0 1 124 54 211 84 85 147 162 152 160 127 96 156 128 144 183 140 26 170 242 255 112 211 16 24 233 93 177 189 62 26 230 8 18 162 102 53 79 255 93 127 37 173 116 119 61 21 221 30 71 51 18 217 197 225 89 208 228 54 16 14 158 40 254 222 6 144 144 95 30 116 51 208 187 221 207 73 40 215 178 180 184 67 243 230 235 85 174 4 118 231 32 148 73 211 37 140 151 196 184 12 41 14 98 78 190 103 107 141 66 52 100 222 58 141 135 84 85 90 76 97 21 18 0 0 0 0 124 94 236 109 194 205 86 41 192 155 21 79 52 203 207 37 42 40 126 224 32 228 152 22 204 190 205 68 99 253 159 127 249 241 8 5 27 151 203 115 75 236 216 195 28 184 201 166 85 152 106 8 201 248 148 93 54 156 87 135 56 251 121 202 96 173 198 190 134 110 223 180 127 230 136 159 180 9 44 207 255 43 80 213 238 43 117 135 78 121 149 22 24 198 179 157 59 238 245 168 85 45 36 70 88 161 109 52 49 133 96 74 209 106 244 99 200 247 185 127 197 240 97 2 0 1 124 94 236 109 194 205 86 41 192 155 21 79 52 203 207 37 42 40 126 224 32 228 152 22 204 190 205 68 99 253 159 127 249 241 8 5 27 151 203 115 75 236 216 195 28 184 201 166 85 152 106 8 201 248 148 93 54 156 87 135 56 251 121 202 96 173 198 190 134 110 223 180 127 230 136 159 180 9 44 207 255 43 80 213 238 43 117 135 78 121 149 22 24 198 179 157 59 238 245 168 85 45 36 70 88 161 109 52 49 133 96 74 209 106 244 99 200 247 185 127 197 240 97 2 0 0 124 14 202 151 114 198 177 79 116 173 42 198 179 37 189 161 34 90 109 151 134 15 53 12 218 203 186 227 104 124 114 146 230 193 76 40 120 134 85 85 179 206 122 201 169 68 255 199 58 19 184 117 183 58 105 131 49 120 224 207 113 249 249 52 245 213 117 133 240 15 235 167 111 253 250 71 98 115 41 241 120 23 72 80 150 152 182 145 130 4 69 103 219 252 177 172 87 76 137 67 198 105 98 131 12 8 87 204 104 138 42 101 155 161 225 254 112 96 164 148 113 139 130 6 0 1 124 14 202 151 114 198 177 79 116 173 42 198 179 37 189 161 34 90 109 151 134 15 53 12 218 203 186 227 104 124 114 146 230 193 76 40 120 134 85 85 179 206 122 201 169 68 255 199 58 19 184 117 183 58 105 131 49 120 224 207 113 249 249 52 245 213 117 133 240 15 235 167 111 253 250 71 98 115 41 241 120 23 72 80 150 152 182 145 130 4 69 103 219 252 177 172 87 76 137 67 198 105 98 131 12 8 87 204 104 138 42 101 155 161 225 254 112 96 164 148 113 139 130 6 0 0 84 222 236 36 90 191 241 183 85 110 108 88 240 111 232 78 103 27 70 144 224 71 76 230 109 75 89 21 251 126 142 18 121 105 170 253 72 64 73 2 238 74 157 109 22 80 12 236 206 45 90 23 64 23 14 190 116 110 37 81 228 238 254 84 202 140 111 243 20 88 246 161 13 249 31 162 155 221 13 64 215 171 161 29 14 1 84 222 236 36 90 191 241 183 85 110 108 88 240 111 232 78 103 27 70 144 224 71 76 230 109 75 89 21 251 126 142 18 121 105 170 253 72 64 73 2 238 74 157 109 22 80 12 236 206 45 90 23 64 23 14 190 116 110 37 81 228 238 254 84 202 140 111 243 20 88 246 161 13 249 31 162 155 221 13 64 215 171 161 29 14 0 76 69 2 96 19 137 241 75 149 54 240 119 4 53 193 106 38 190 90 56 134 205 201 129 251 62 99 112 152 118 97 184 216 164 110 226 53 156 74 62 42 32 199 114 107 27 36 188 14 59 253 131 97 129 87 74 48 164 130 23 116 217 134 169 80 29 241 90 26 86 7 137 144 117 50 0 0 1 76 69 2 96 19 137 241 75 149 54 240 119 4 53 193 106 38 190 90 56 134 205 201 129 251 62 99 112 152 118 97 184 216 164 110 226 53 156 74 62 42 32 199 114 107 27 36 188 14 59 253 131 97 129 87 74 48 164 130 23 116 217 134 169 80 29 241 90 26 86 7 137 144 117 50 0 0 0 100 60 2 183 139 129 88 99 244 170 89 0 177 28 40 203 18 239 70 82 138 113 96 148 242 156 70 22 152 221 31 149 38 127 107 45 254 28 166 210 227 215 191 161 12 230 95 230 64 209 16 253 82 63 212 15 119 73 178 25 88 182 249 227 148 207 62 209 192 72 37 56 62 203 161 110 196 250 228 14 19 181 87 35 11 15 255 155 107 206 61 54 223 191 92 51 188 42 0 0 0 1 100 60 2 183 139 129 88 99 244 170 89 0 177 28 40 203 18 239 70 82 138 113 96 148 242 156 70 22 152 221 31 149 38 127 107 45 254 28 166 210 227 215 191 161 12 230 95 230 64 209 16 253 82 63 212 15 119 73 178 25 88 182 249 227 148 207 62 209 192 72 37 56 62 203 161 110 196 250 228 14 19 181 87 35 11 15 255 155 107 206 61 54 223 191 92 51 188 42 0 0 0 0 8 161 145 84 161 51 102 34 163 1 8 161 145 84 161 51 102 34 163 0 56 160 51 60 244 243 228 49 105 198 184 5 130 241 114 177 248 245 101 241 141 249 87 160 252 119 173 82 11 10 104 49 95 69 254 101 134 79 46 129 192 118 64 243 147 3 51 61 70 176 159 167 235 86 145 44 55 1 56 160 51 60 244 243 228 49 105 198 184 5 130 241 114 177 248 245 101 241 141 249 87 160 252 119 173 82 11 10 104 49 95 69 254 101 134 79 46 129 192 118 64 243 147 3 51 61 70 176 159 167 235 86 145 44 55 0 32 180 181 48 71 211 35 86 174 153 231 246 211 154 205 97 74 237 0 199 183 8 131 127 228 121 26 229 18 39 183 3 0 1 32 180 181 48 71 211 35 86 174 153 231 246 211 154 205 97 74 237 0 199 183 8 131 127 228 121 26 229 18 39 183 3 0 0 72 235 208 249 69 198 27 28 175 48 201 165 210 55 86 150 90 198 36 230 165 54 20 213 19 85 189 110 233 79 254 190 153 19 131 115 116 152 36 49 241 5 53 57 191 108 36 43 245 224 105 242 219 194 163 217 52 122 224 205 161 21 47 142 100 254 80 178 115 134 181 158 0 1 72 235 208 249 69 198 27 28 175 48 201 165 210 55 86 150 90 198 36 230 165 54 20 213 19 85 189 110 233 79 254 190 153 19 131 115 116 152 36 49 241 5 53 57 191 108 36 43 245 224 105 242 219 194 163 217 52 122 224 205 161 21 47 142 100 254 80 178 115 134 181 158 0 0 48 24 216 31 31 121 32 6 35 230 132 116 1 93 231 239 114 29 239 68 226 187 220 209 191 89 111 162 77 90 222 196 5 16 190 98 88 179 228 211 83 191 201 156 101 38 6 0 0 1 48 24 216 31 31 121 32 6 35 230 132 116 1 93 231 239 114 29 239 68 226 187 220 209 191 89 111 162 77 90 222 196 5 16 190 98 88 179 228 211 83 191 201 156 101 38 6 0 0 0 8 120 9 155 198 227 119 139 0 1 8 120 9 155 198 227 119 139 0 0 108 67 233 173 239 2 147 31 164 67 28 157 14 181 143 121 205 94 47 18 212 89 86 192 240 97 248 17 119 22 163 109 127 226 138 109 233 234 45 230 169 33 186 2 126 255 20 183 106 178 83 140 195 205 223 184 177 109 237 177 147 165 5 252 192 192 124 61 142 140 69 133 239 214 170 94 162 222 231 95 68 100 116 183 60 109 34 233 105 48 238 47 153 181 219 232 176 110 180 54 190 173 160 203 79 0 3 0 0 1 108 67 233 173 239 2 147 31 164 67 28 157 14 181 143 121 205 94 47 18 212 89 86 192 240 97 248 17 119 22 163 109 127 226 138 109 233 234 45 230 169 33 186 2 126 255 20 183 106 178 83 140 195 205 223 184 177 109 237 177 147 165 5 252 192 192 124 61 142 140 69 133 239 214 170 94 162 222 231 95 68 100 116 183 60 109 34 233 105 48 238 47 153 181 219 232 176 110 180 54 190 173 160 203 79 0 3 0 0 0 44 113 179 208 89 229 97 41 83 34 181 248 69 45 117 67 182 227 176 114 161 166 167 142 142 47 25 191 4 182 213 77 37 61 119 165 249 59 176 118 228 161 1 0 0 1 44 113 179 208 89 229 97 41 83 34 181 248 69 45 117 67 182 227 176 114 161 166 167 142 142 47 25 191 4 182 213 77 37 61 119 165 249 59 176 118 228 161 1 0 0 0 4 205 230 1 0 1 4 205 230 1 0 0 52 77 166 237 60 159 113 214 225 225 196 126 16 105 189 104 42 252 167 15 186 63 111 11 23 250 53 128 208 225 81 238 136 75 225 4 178 227 11 107 243 121 83 238 164 31 105 2 177 163 135 105 60 1 52 77 166 237 60 159 113 214 225 225 196 126 16 105 189 104 42 252 167 15 186 63 111 11 23 250 53 128 208 225 81 238 136 75 225 4 178 227 11 107 243 121 83 238 164 31 105 2 177 163 135 105 60 0 8 7 177 200 9 87 48 0 0 1 8 7 177 200 9 87 48 0 0 0 120 95 0 17 198 196 3 168 29 232 224 109 67 23 135 235 50 52 214 192 80 146 255 65 119 139 83 153 210 130 123 45 5 148 58 19 42 240 226 164 159 61 91 236 215 59 183 160 255 155 79 104 47 81 69 79 205 46 250 193 179 14 221 169 205 128 237 109 128 36 7 21 98 118 172 243 166 158 151 127 232 156 225 22 108 82 127 8 238 182 238 200 235 199 229 34 2 128 5 166 74 164 159 85 41 32 254 62 100 188 86 40 138 142 240 122 56 2 0 0 0 1 120 95 0 17 198 196 3 168 29 232 224 109 67 23 135 235 50 52 214 192 80 146 255 65 119 139 83 153 210 130 123 45 5 148 58 19 42 240 226 164 159 61 91 236 215 59 183 160 255 155 79 104 47 81 69 79 205 46 250 193 179 14 221 169 205 128 237 109 128 36 7 21 98 118 172 243 166 158 151 127 232 156 225 22 108 82 127 8 238 182 238 200 235 199 229 34 2 128 5 166 74 164 159 85 41 32 254 62 100 188 86 40 138 142 240 122 56 2 0 0 0 0 24 52 171 120 247 245 238 38 189 200 10 21 246 79 73 111 224 107 101 199 80 238 49 0 0 1 24 52 171 120 247 245 238 38 189 200 10 21 246 79 73 111 224 107 101 199 80 238 49 0 0 0 104 57 158 161 115 39 26 101 249 18 39 40 1 93 199 25 128 79 244 212 44 60 231 196 18 52 157 210 236 197 32 195 30 224 115 47 62 183 108 27 196 234 161 196 225 103 21 202 150 178 236 60 175 217 66 254 151 71 126 230 34 45 143 24 111 88 165 51 57 138 241 251 139 79 160 192 71 182 96 28 48 193 182 46 229 150 230 46 13 249 26 35 98 104 138 125 230 36 173 131 138 29 153 37 15 1 104 57 158 161 115 39 26 101 249 18 39 40 1 93 199 25 128 79 244 212 44 60 231 196 18 52 157 210 236 197 32 195 30 224 115 47 62 183 108 27 196 234 161 196 225 103 21 202 150 178 236 60 175 217 66 254 151 71 126 230 34 45 143 24 111 88 165 51 57 138 241 251 139 79 160 192 71 182 96 28 48 193 182 46 229 150 230 46 13 249 26 35 98 104 138 125 230 36 173 131 138 29 153 37 15 0 84 201 67 176 170 12 214 223 113 151 240 121 127 115 67 246 173 119 207 202 219 102 176 87 124 64 46 160 253 231 56 131 2 167 194 119 80 227 152 34 209 118 189 9 5 175 115 207 20 15 201 85 82 139 3 122 200 232 151 18 106 251 0 202 255 146 176 226 219 69 250 238 111 233 251 3 57 189 253 30 108 224 253 116 0 1 84 201 67 176 170 12 214 223 113 151 240 121 127 115 67 246 173 119 207 202 219 102 176 87 124 64 46 160 253 231 56 131 2 167 194 119 80 227 152 34 209 118 189 9 5 175 115 207 20 15 201 85 82 139 3 122 200 232 151 18 106 251 0 202 255 146 176 226 219 69 250 238 111 233 251 3 57 189 253 30 108 224 253 116 0 0 36 216 207 22 26 220 111 75 102 80 113 167 57 132 171 148 110 197 33 103 213 177 123 206 218 242 178 9 228 125 117 218 221 76 2 0 0 1 36 216 207 22 26 220 111 75 102 80 113 167 57 132 171 148 110 197 33 103 213 177 123 206 218 242 178 9 228 125 117 218 221 76 2 0 0 0 96 209 38 226 122 66 37 110 32 0 244 215 135 36 169 50 93 130 191 147 142 209 240 154 14 39 115 83 99 104 166 126 171 89 95 133 0 168 235 114 121 112 237 201 242 105 25 68 88 53 63 4 70 8 16 14 139 78 16 28 216 131 240 108 136 129 244 99 100 247 236 64 222 120 6 100 242 25 164 196 251 190 21 202 16 243 72 23 21 27 253 232 129 65 12 0 0 1 96 209 38 226 122 66 37 110 32 0 244 215 135 36 169 50 93 130 191 147 142 209 240 154 14 39 115 83 99 104 166 126 171 89 95 133 0 168 235 114 121 112 237 201 242 105 25 68 88 53 63 4 70 8 16 14 139 78 16 28 216 131 240 108 136 129 244 99 100 247 236 64 222 120 6 100 242 25 164 196 251 190 21 202 16 243 72 23 21 27 253 232 129 65 12 0 0 0 20 137 7 71 104 123 1 230 162 84 85 84 78 76 1 146 149 3 0 0 0 1 20 137 7 71 104 123 1 230 162 84 85 84 78 76 1 146 149 3 0 0 0 0 84 17 135 189 91 189 22 119 161 7 236 246 162 42 137 207 149 58 10 147 68 241 83 242 92 176 9 168 195 250 98 204 19 131 82 40 2 115 30 134 119 85 234 171 51 248 6 232 13 126 100 100 208 191 92 68 52 56 79 102 83 41 100 249 214 204 9 147 69 246 254 24 120 21 121 111 194 137 125 190 39 201 58 31 0 1 84 17 135 189 91 189 22 119 161 7 236 246 162 42 137 207 149 58 10 147 68 241 83 242 92 176 9 168 195 250 98 204 19 131 82 40 2 115 30 134 119 85 234 171 51 248 6 232 13 126 100 100 208 191 92 68 52 56 79 102 83 41 100 249 214 204 9 147 69 246 254 24 120 21 121 111 194 137 125 190 39 201 58 31 0 0 64 174 140 149 163 3 107 111 4 34 250 106 21 208 102 247 217 125 106 201 189 50 165 180 247 173 193 91 219 22 221 135 48 75 167 217 77 123 120 130 238 30 6 129 157 63 162 58 79 199 175 93 130 164 195 209 241 206 111 166 90 218 65 223 2 1 64 174 140 149 163 3 107 111 4 34 250 106 21 208 102 247 217 125 106 201 189 50 165 180 247 173 193 91 219 22 221 135 48 75 167 217 77 123 120 130 238 30 6 129 157 63 162 58 79 199 175 93 130 164 195 209 241 206 111 166 90 218 65 223 2 0 60 94 39 245 99 17 252 182 140 162 112 156 230 137 46 180 2 25 35 78 204 212 30 138 67 63 147 188 132 251 223 228 122 221 52 247 47 60 130 213 221 67 57 251 17 236 100 5 136 157 85 85 137 180 82 210 206 141 57 0 0 1 60 94 39 245 99 17 252 182 140 162 112 156 230 137 46 180 2 25 35 78 204 212 30 138 67 63 147 188 132 251 223 228 122 221 52 247 47 60 130 213 221 67 57 251 17 236 100 5 136 157 85 85 137 180 82 210 206 141 57 0 0 0 52 130 153 165 204 195 100 32 242 200 177 22 23 48 222 90 173 238 62 11 195 207 31 94 106 111 19 23 102 123 154 11 25 69 140 143 38 27 47 211 73 199 58 157 241 52 98 114 254 14 0 0 0 1 52 130 153 165 204 195 100 32 242 200 177 22 23 48 222 90 173 238 62 11 195 207 31 94 106 111 19 23 102 123 154 11 25 69 140 143 38 27 47 211 73 199 58 157 241 52 98 114 254 14 0 0 0 0 72 242 139 53 248 243 242 47 139 119 188 176 74 227 81 33 108 130 169 69 136 245 21 31 87 103 135 189 216 110 191 185 187 15 111 235 113 59 97 210 163 3 82 39 248 57 165 173 26 7 64 153 147 109 165 237 85 23 91 144 96 82 212 163 110 172 233 196 20 189 194 1 0 1 72 242 139 53 248 243 242 47 139 119 188 176 74 227 81 33 108 130 169 69 136 245 21 31 87 103 135 189 216 110 191 185 187 15 111 235 113 59 97 210 163 3 82 39 248 57 165 173 26 7 64 153 147 109 165 237 85 23 91 144 96 82 212 163 110 172 233 196 20 189 194 1 0 0 92 63 196 195 103 33 69 53 0 35 106 115 86 145 225 79 206 13 41 97 138 221 49 15 101 120 43 207 2 164 87 76 203 63 18 204 117 208 102 150 11 45 65 74 88 87 11 31 221 40 244 204 108 35 1 221 236 192 33 114 34 255 16 27 102 160 251 229 204 178 67 44 210 45 249 116 212 232 9 246 165 134 232 228 248 94 170 234 243 13 232 1 125 1 92 63 196 195 103 33 69 53 0 35 106 115 86 145 225 79 206 13 41 97 138 221 49 15 101 120 43 207 2 164 87 76 203 63 18 204 117 208 102 150 11 45 65 74 88 87 11 31 221 40 244 204 108 35 1 221 236 192 33 114 34 255 16 27 102 160 251 229 204 178 67 44 210 45 249 116 212 232 9 246 165 134 232 228 248 94 170 234 243 13 232 1 125 0 40 179 181 131 162 149 183 138 252 30 154 1 146 137 121 52 190 246 1 224 28 36 102 79 202 159 212 210 252 214 150 156 61 194 235 164 133 239 142 0 0 1 40 179 181 131 162 149 183 138 252 30 154 1 146 137 121 52 190 246 1 224 28 36 102 79 202 159 212 210 252 214 150 156 61 194 235 164 133 239 142 0 0 0 40 60 58 79 249 6 113 81 42 62 163 64 45 148 17 196 92 207 75 88 80 225 216 133 32 64 220 110 107 147 131 21 223 245 83 192 232 107 0 0 0 1 40 60 58 79 249 6 113 81 42 62 163 64 45 148 17 196 92 207 75 88 80 225 216 133 32 64 220 110 107 147 131 21 223 245 83 192 232 107 0 0 0 0 96 12 165 17 255 148 106 77 76 190 146 244 60 246 21 69 4 108 6 135 121 71 44 77 148 210 123 228 244 192 7 178 234 75 27 35 56 139 157 89 246 205 166 104 142 71 22 111 74 215 198 253 47 185 250 203 223 186 72 48 140 56 78 5 248 174 81 223 135 55 86 65 183 39 125 199 89 36 113 114 101 100 241 34 118 182 139 64 184 93 41 222 250 83 8 126 2 1 96 12 165 17 255 148 106 77 76 190 146 244 60 246 21 69 4 108 6 135 121 71 44 77 148 210 123 228 244 192 7 178 234 75 27 35 56 139 157 89 246 205 166 104 142 71 22 111 74 215 198 253 47 185 250 203 223 186 72 48 140 56 78 5 248 174 81 223 135 55 86 65 183 39 125 199 89 36 113 114 101 100 241 34 118 182 139 64 184 93 41 222 250 83 8 126 2 0 80 194 39 168 144 47 63 164 168 230 144 217 13 24 96 155 100 12 59 177 151 216 92 228 192 145 88 206 81 45 221 226 39 93 88 12 250 68 153 137 36 20 58 0 113 35 195 22 121 71 66 8 241 39 201 196 133 230 128 125 7 217 82 221 87 57 93 151 146 24 13 11 157 51 151 229 8 102 193 170 254 1 80 194 39 168 144 47 63 164 168 230 144 217 13 24 96 155 100 12 59 177 151 216 92 228 192 145 88 206 81 45 221 226 39 93 88 12 250 68 153 137 36 20 58 0 113 35 195 22 121 71 66 8 241 39 201 196 133 230 128 125 7 217 82 221 87 57 93 151 146 24 13 11 157 51 151 229 8 102 193 170 254 0 28 115 165 0 181 114 222 7 59 3 124 183 26 196 172 167 125 136 168 200 232 107 92 130 217 10 0 0 0 1 28 115 165 0 181 114 222 7 59 3 124 183 26 196 172 167 125 136 168 200 232 107 92 130 217 10 0 0 0 0 104 236 68 87 125 155 29 32 62 230 30 136 150 217 197 37 30 35 255 242 108 93 176 111 33 250 237 114 238 160 77 113 171 147 43 61 144 12 84 87 115 160 128 222 109 180 248 55 195 181 75 255 203 79 219 130 244 94 36 238 156 212 175 171 162 174 87 117 209 113 175 106 193 36 21 66 244 243 166 248 81 121 94 110 189 10 52 188 102 198 136 150 183 191 180 96 29 51 207 65 251 163 177 216 188 1 104 236 68 87 125 155 29 32 62 230 30 136 150 217 197 37 30 35 255 242 108 93 176 111 33 250 237 114 238 160 77 113 171 147 43 61 144 12 84 87 115 160 128 222 109 180 248 55 195 181 75 255 203 79 219 130 244 94 36 238 156 212 175 171 162 174 87 117 209 113 175 106 193 36 21 66 244 243 166 248 81 121 94 110 189 10 52 188 102 198 136 150 183 191 180 96 29 51 207 65 251 163 177 216 188 0 88 199 62 219 38 224 64 98 122 250 132 90 246 191 177 175 129 238 74 103 140 144 205 156 27 249 53 223 251 192 95 121 104 139 113 181 72 177 157 33 140 244 253 143 104 230 164 205 233 17 33 203 84 40 89 149 26 16 144 238 213 168 166 242 186 189 255 169 165 234 16 127 90 100 62 217 16 139 41 102 89 93 97 62 95 147 122 238 237 1 88 199 62 219 38 224 64 98 122 250 132 90 246 191 177 175 129 238 74 103 140 144 205 156 27 249 53 223 251 192 95 121 104 139 113 181 72 177 157 33 140 244 253 143 104 230 164 205 233 17 33 203 84 40 89 149 26 16 144 238 213 168 166 242 186 189 255 169 165 234 16 127 90 100 62 217 16 139 41 102 89 93 97 62 95 147 122 238 237 0 44 45 84 26 33 30 184 117 77 114 45 211 193 64 207 224 237 136 114 3 145 150 20 213 238 240 36 201 64 122 69 244 22 129 142 201 1 185 151 174 233 1 0 0 0 1 44 45 84 26 33 30 184 117 77 114 45 211 193 64 207 224 237 136 114 3 145 150 20 213 238 240 36 201 64 122 69 244 22 129 142 201 1 185 151 174 233 1 0 0 0 0 24 118 96 110 163 151 234 7 30 202 198 169 47 210 145 198 195 223 20 211 133 162 187 75 48 1 24 118 96 110 163 151 234 7 30 202 198 169 47 210 145 198 195 223 20 211 133 162 187 75 48 0 52 166 132 83 15 114 76 5 198 105 107 64 21 201 37 152 38 123 234 29 114 185 178 23 194 54 124 93 52 128 139 153 108 32 85 243 44 247 113 25 108 194 143 136 29 222 174 212 74 73 19 0 0 1 52 166 132 83 15 114 76 5 198 105 107 64 21 201 37 152 38 123 234 29 114 185 178 23 194 54 124 93 52 128 139 153 108 32 85 243 44 247 113 25 108 194 143 136 29 222 174 212 74 73 19 0 0 0 48 123 248 179 54 119 191 224 218 82 168 17 9 213 235 78 184 70 111 32 105 157 160 212 123 240 230 248 188 30 46 115 251 167 248 212 75 179 20 91 203 47 80 142 34 152 174 246 1 1 48 123 248 179 54 119 191 224 218 82 168 17 9 213 235 78 184 70 111 32 105 157 160 212 123 240 230 248 188 30 46 115 251 167 248 212 75 179 20 91 203 47 80 142 34 152 174 246 1 0 48 156 96 100 244 230 81 145 6 56 18 242 19 211 56 11 208 136 192 193 247 21 84 210 245 251 22 164 190 142 62 191 235 148 86 107 108 228 229 161 113 8 169 132 37 3 0 0 0 1 48 156 96 100 244 230 81 145 6 56 18 242 19 211 56 11 208 136 192 193 247 21 84 210 245 251 22 164 190 142 62 191 235 148 86 107 108 228 229 161 113 8 169 132 37 3 0 0 0 0 84 253 53 33 48 131 189 25 65 204 174 99 186 204 72 230 129 192 106 8 141 23 186 143 8 176 75 97 190 2 190 127 52 92 22 252 200 15 45 98 21 11 157 128 28 145 217 54 150 99 213 145 99 58 65 64 149 218 156 253 58 0 9 210 203 145 96 237 185 130 70 116 6 209 240 157 58 59 8 33 55 1 0 0 0 1 84 253 53 33 48 131 189 25 65 204 174 99 186 204 72 230 129 192 106 8 141 23 186 143 8 176 75 97 190 2 190 127 52 92 22 252 200 15 45 98 21 11 157 128 28 145 217 54 150 99 213 145 99 58 65 64 149 218 156 253 58 0 9 210 203 145 96 237 185 130 70 116 6 209 240 157 58 59 8 33 55 1 0 0 0 0 108 140 139 49 207 205 64 240 199 59 87 85 34 45 23 247 226 20 175 76 118 24 188 97 163 249 238 130 105 219 76 167 90 29 31 159 229 181 73 152 183 74 134 209 139 34 200 210 113 231 227 99 224 196 220 80 243 62 167 195 5 201 123 178 100 95 190 235 171 32 64 54 178 111 83 175 134 22 73 175 164 79 39 170 74 102 74 233 210 216 226 3 131 100 81 201 127 195 224 208 29 109 171 156 77 11 0 0 0 1 108 140 139 49 207 205 64 240 199 59 87 85 34 45 23 247 226 20 175 76 118 24 188 97 163 249 238 130 105 219 76 167 90 29 31 159 229 181 73 152 183 74 134 209 139 34 200 210 113 231 227 99 224 196 220 80 243 62 167 195 5 201 123 178 100 95 190 235 171 32 64 54 178 111 83 175 134 22 73 175 164 79 39 170 74 102 74 233 210 216 226 3 131 100 81 201 127 195 224 208 29 109 171 156 77 11 0 0 0 0 100 222 231 217 128 82 99 10 214 110 228 128 78 114 45 119 81 180 185 243 203 206 92 162 40 82 46 54 187 93 28 152 69 4 123 103 77 208 204 181 235 42 147 170 143 2 139 154 218 144 51 223 215 163 89 75 72 123 205 0 240 64 100 207 207 158 197 65 249 187 175 80 167 154 152 209 32 55 42 171 219 232 238 66 244 61 205 209 141 94 43 111 8 205 151 59 230 205 24 205 241 1 100 222 231 217 128 82 99 10 214 110 228 128 78 114 45 119 81 180 185 243 203 206 92 162 40 82 46 54 187 93 28 152 69 4 123 103 77 208 204 181 235 42 147 170 143 2 139 154 218 144 51 223 215 163 89 75 72 123 205 0 240 64 100 207 207 158 197 65 249 187 175 80 167 154 152 209 32 55 42 171 219 232 238 66 244 61 205 209 141 94 43 111 8 205 151 59 230 205 24 205 241 0 88 207 251 142 39 144 108 252 57 106 73 11 186 19 131 187 69 26 149 177 211 238 136 251 62 89 7 238 7 115 168 92 155 211 100 253 171 162 138 116 33 152 91 134 33 55 71 164 201 152 4 49 26 55 186 161 250 57 85 28 39 171 17 196 138 245 10 0 73 155 144 183 97 4 3 242 240 169 248 22 116 210 225 61 191 6 115 0 0 1 88 207 251 142 39 144 108 252 57 106 73 11 186 19 131 187 69 26 149 177 211 238 136 251 62 89 7 238 7 115 168 92 155 211 100 253 171 162 138 116 33 152 91 134 33 55 71 164 201 152 4 49 26 55 186 161 250 57 85 28 39 171 17 196 138 245 10 0 73 155 144 183 97 4 3 242 240 169 248 22 116 210 225 61 191 6 115 0 0 0 12 137 130 140 24 236 12 214 199 10 105 31 0 1 12 137 130 140 24 236 12 214 199 10 105 31 0 0 52 108 175 196 156 55 213 72 113 207 244 180 56 88 213 35 165 75 248 211 20 212 57 60 188 217 211 48 37 134 141 243 246 161 245 39 195 123 248 138 183 15 28 111 146 50 155 93 170 4 0 0 0 1 52 108 175 196 156 55 213 72 113 207 244 180 56 88 213 35 165 75 248 211 20 212 57 60 188 217 211 48 37 134 141 243 246 161 245 39 195 123 248 138 183 15 28 111 146 50 155 93 170 4 0 0 0 0 120 112 113 30 136 233 190 54 137 121 169 50 162 49 32 173 179 18 162 50 40 203 206 65 185 66 186 230 219 176 80 103 123 27 250 226 122 23 191 77 80 214 47 76 55 89 65 20 139 103 231 246 32 248 93 179 33 222 25 246 60 212 174 114 116 72 105 47 23 51 143 138 172 27 39 246 135 133 254 162 107 108 22 2 166 141 243 6 251 77 176 135 206 2 231 124 148 132 69 84 79 111 64 235 234 76 164 46 49 159 31 188 209 182 60 173 197 202 76 16 0 1 120 112 113 30 136 233 190 54 137 121 169 50 162 49 32 173 179 18 162 50 40 203 206 65 185 66 186 230 219 176 80 103 123 27 250 226 122 23 191 77 80 214 47 76 55 89 65 20 139 103 231 246 32 248 93 179 33 222 25 246 60 212 174 114 116 72 105 47 23 51 143 138 172 27 39 246 135 133 254 162 107 108 22 2 166 141 243 6 251 77 176 135 206 2 231 124 148 132 69 84 79 111 64 235 234 76 164 46 49 159 31 188 209 182 60 173 197 202 76 16 0 0 60 47 160 84 82 9 238 207 219 151 156 134 131 89 62 11 68 11 147 237 99 121 15 73 200 84 95 87 214 232 187 96 240 53 52 195 55 200 190 88 28 76 29 80 151 156 97 63 20 181 127 200 147 98 254 76 151 61 118 77 0 1 60 47 160 84 82 9 238 207 219 151 156 134 131 89 62 11 68 11 147 237 99 121 15 73 200 84 95 87 214 232 187 96 240 53 52 195 55 200 190 88 28 76 29 80 151 156 97 63 20 181 127 200 147 98 254 76 151 61 118 77 0 0 100 238 56 196 120 62 80 239 58 25 190 123 255 60 22 240 193 64 200 155 205 65 125 162 46 114 82 168 130 71 226 104 252 45 143 77 84 254 194 132 208 96 195 7 173 173 156 202 242 175 234 16 37 97 18 174 179 230 94 208 69 94 78 160 223 97 151 58 36 237 203 214 110 180 89 134 104 29 12 23 140 193 36 70 29 183 50 17 167 28 12 196 65 172 236 156 91 251 73 127 1 1 100 238 56 196 120 62 80 239 58 25 190 123 255 60 22 240 193 64 200 155 205 65 125 162 46 114 82 168 130 71 226 104 252 45 143 77 84 254 194 132 208 96 195 7 173 173 156 202 242 175 234 16 37 97 18 174 179 230 94 208 69 94 78 160 223 97 151 58 36 237 203 214 110 180 89 134 104 29 12 23 140 193 36 70 29 183 50 17 167 28 12 196 65 172 236 156 91 251 73 127 1 0 40 149 114 1 116 102 17 2 174 6 173 97 185 176 52 172 147 84 122 233 135 57 32 185 232 151 166 16 42 84 99 130 237 14 101 51 119 173 115 53 0 1 40 149 114 1 116 102 17 2 174 6 173 97 185 176 52 172 147 84 122 233 135 57 32 185 232 151 166 16 42 84 99 130 237 14 101 51 119 173 115 53 0 0 64 242 217 97 202 37 38 150 206 207 10 52 100 102 27 105 39 214 77 170 228 242 244 122 45 230 139 116 113 248 171 76 193 78 80 198 37 181 97 228 185 29 21 241 62 210 131 193 6 1 89 93 123 149 252 254 234 21 49 121 54 70 123 12 0 1 64 242 217 97 202 37 38 150 206 207 10 52 100 102 27 105 39 214 77 170 228 242 244 122 45 230 139 116 113 248 171 76 193 78 80 198 37 181 97 228 185 29 21 241 62 210 131 193 6 1 89 93 123 149 252 254 234 21 49 121 54 70 123 12 0 0 120 126 216 172 15 25 129 241 98 17 2 168 135 214 24 154 85 56 125 146 150 225 161 82 46 26 201 64 204 132 245 111 192 88 211 123 3 119 58 58 245 118 104 138 91 147 19 185 226 101 33 139 62 235 15 91 204 29 220 53 8 11 61 142 142 93 77 162 71 38 142 116 213 43 79 225 85 174 86 234 214 249 189 86 69 229 181 99 122 154 144 192 66 13 218 96 118 124 80 14 168 5 230 111 79 37 76 42 49 185 18 80 157 188 50 80 199 22 0 0 0 1 120 126 216 172 15 25 129 241 98 17 2 168 135 214 24 154 85 56 125 146 150 225 161 82 46 26 201 64 204 132 245 111 192 88 211 123 3 119 58 58 245 118 104 138 91 147 19 185 226 101 33 139 62 235 15 91 204 29 220 53 8 11 61 142 142 93 77 162 71 38 142 116 213 43 79 225 85 174 86 234 214 249 189 86 69 229 181 99 122 154 144 192 66 13 218 96 118 124 80 14 168 5 230 111 79 37 76 42 49 185 18 80 157 188 50 80 199 22 0 0 0 0 56 243 53 196 121 165 92 144 118 3 3 222 84 206 144 5 157 57 16 134 139 198 69 129 221 11 133 183 218 71 108 13 56 83 246 113 103 6 198 202 227 68 93 146 59 161 12 248 177 166 51 150 47 96 161 239 236 1 56 243 53 196 121 165 92 144 118 3 3 222 84 206 144 5 157 57 16 134 139 198 69 129 221 11 133 183 218 71 108 13 56 83 246 113 103 6 198 202 227 68 93 146 59 161 12 248 177 166 51 150 47 96 161 239 236 0 64 153 28 132 11 210 222 158 84 204 251 210 22 227 11 36 206 23 140 161 60 159 143 123 206 191 31 7 46 144 178 243 58 169 39 112 174 47 119 109 7 130 69 51 2 125 253 241 144 64 234 96 3 245 113 8 190 14 182 65 46 222 249 3 0 1 64 153 28 132 11 210 222 158 84 204 251 210 22 227 11 36 206 23 140 161 60 159 143 123 206 191 31 7 46 144 178 243 58 169 39 112 174 47 119 109 7 130 69 51 2 125 253 241 144 64 234 96 3 245 113 8 190 14 182 65 46 222 249 3 0 0 60 98 185 79 194 105 170 12 86 252 124 124 192 23 205 211 77 162 50 205 89 40 158 46 179 237 22 171 26 56 121 32 6 69 111 60 114 251 180 204 199 96 135 46 64 144 243 102 201 99 166 113 208 152 168 179 161 1 6 0 0 1 60 98 185 79 194 105 170 12 86 252 124 124 192 23 205 211 77 162 50 205 89 40 158 46 179 237 22 171 26 56 121 32 6 69 111 60 114 251 180 204 199 96 135 46 64 144 243 102 201 99 166 113 208 152 168 179 161 1 6 0 0 0 100 142 26 227 150 238 69 151 6 3 30 46 190 46 96 134 217 131 85 161 92 34 208 158 197 175 196 117 64 216 114 195 81 101 252 52 106 185 71 47 193 32 27 53 120 25 14 193 3 5 106 149 116 208 152 66 126 218 195 178 209 4 241 87 44 185 217 57 224 49 139 77 191 217 218 19 215 78 14 143 87 180 5 177 20 62 54 52 235 79 31 44 20 98 23 221 250 34 0 0 0 1 100 142 26 227 150 238 69 151 6 3 30 46 190 46 96 134 217 131 85 161 92 34 208 158 197 175 196 117 64 216 114 195 81 101 252 52 106 185 71 47 193 32 27 53 120 25 14 193 3 5 106 149 116 208 152 66 126 218 195 178 209 4 241 87 44 185 217 57 224 49 139 77 191 217 218 19 215 78 14 143 87 180 5 177 20 62 54 52 235 79 31 44 20 98 23 221 250 34 0 0 0 0 40 32 168 235 44 56 166 243 210 154 91 226 40 229 249 145 209 125 211 169 133 252 161 224 125 81 253 117 254 153 178 166 34 26 180 249 135 33 222 152 13 1 40 32 168 235 44 56 166 243 210 154 91 226 40 229 249 145 209 125 211 169 133 252 161 224 125 81 253 117 254 153 178 166 34 26 180 249 135 33 222 152 13 0 16 114 51 72 217 92 64 168 124 50 132 58 208 128 106 1 0 1 16 114 51 72 217 92 64 168 124 50 132 58 208 128 106 1 0 0 68 69 4 0 153 42 90 20 74 230 90 168 97 72 101 100 19 28 241 147 219 3 93 60 246 145 183 55 230 232 224 115 211 143 158 209 214 247 84 89 209 186 139 133 34 124 5 207 184 125 115 201 88 222 241 97 109 108 6 13 211 125 187 117 94 222 2 0 0 1 68 69 4 0 153 42 90 20 74 230 90 168 97 72 101 100 19 28 241 147 219 3 93 60 246 145 183 55 230 232 224 115 211 143 158 209 214 247 84 89 209 186 139 133 34 124 5 207 184 125 115 201 88 222 241 97 109 108 6 13 211 125 187 117 94 222 2 0 0 0 52 153 84 205 104 19 159 225 153 148 74 194 235 72 23 144 76 152 243 229 1 90 189 92 32 175 52 88 183 242 20 84 239 175 56 99 222 31 211 114 93 122 135 65 160 226 51 48 207 12 116 28 0 1 52 153 84 205 104 19 159 225 153 148 74 194 235 72 23 144 76 152 243 229 1 90 189 92 32 175 52 88 183 242 20 84 239 175 56 99 222 31 211 114 93 122 135 65 160 226 51 48 207 12 116 28 0 0 68 245 53 109 105 191 82 1 66 103 122 80 160 241 193 52 254 117 182 127 138 99 142 106 221 128 239 15 222 14 129 176 110 43 113 122 176 232 88 250 58 0 161 215 14 126 59 139 23 140 13 122 239 14 189 40 72 35 18 82 213 254 53 121 213 234 12 0 0 1 68 245 53 109 105 191 82 1 66 103 122 80 160 241 193 52 254 117 182 127 138 99 142 106 221 128 239 15 222 14 129 176 110 43 113 122 176 232 88 250 58 0 161 215 14 126 59 139 23 140 13 122 239 14 189 40 72 35 18 82 213 254 53 121 213 234 12 0 0 0 112 159 8 16 9 71 195 199 198 21 242 159 80 249 120 17 254 76 140 121 166 78 213 92 89 178 160 20 177 8 14 182 122 65 115 133 119 121 16 112 118 105 211 205 62 12 236 55 80 1 131 163 0 83 205 178 80 88 102 233 133 195 61 239 174 246 227 234 216 85 176 76 5 36 121 112 51 212 181 246 245 241 105 195 137 147 72 56 237 179 190 73 134 142 177 146 141 8 159 112 222 16 234 231 234 198 20 89 52 189 194 119 1 1 112 159 8 16 9 71 195 199 198 21 242 159 80 249 120 17 254 76 140 121 166 78 213 92 89 178 160 20 177 8 14 182 122 65 115 133 119 121 16 112 118 105 211 205 62 12 236 55 80 1 131 163 0 83 205 178 80 88 102 233 133 195 61 239 174 246 227 234 216 85 176 76 5 36 121 112 51 212 181 246 245 241 105 195 137 147 72 56 237 179 190 73 134 142 177 146 141 8 159 112 222 16 234 231 234 198 20 89 52 189 194 119 1 0 108 80 214 13 177 215 159 125 169 151 12 42 72 121 18 76 208 238 240 149 68 234 73 20 164 91 171 220 52 255 98 21 228 111 4 175 56 163 222 123 128 30 97 59 67 228 49 187 237 223 220 86 109 144 229 187 251 70 7 146 195 116 106 122 232 185 78 78 58 225 39 134 160 118 235 208 242 69 148 226 101 73 25 136 159 25 99 137 101 248 54 26 247 229 7 34 61 19 28 201 190 36 74 102 133 25 0 0 0 1 108 80 214 13 177 215 159 125 169 151 12 42 72 121 18 76 208 238 240 149 68 234 73 20 164 91 171 220 52 255 98 21 228 111 4 175 56 163 222 123 128 30 97 59 67 228 49 187 237 223 220 86 109 144 229 187 251 70 7 146 195 116 106 122 232 185 78 78 58 225 39 134 160 118 235 208 242 69 148 226 101 73 25 136 159 25 99 137 101 248 54 26 247 229 7 34 61 19 28 201 190 36 74 102 133 25 0 0 0 0 48 214 54 94 179 164 240 155 40 191 186 107 180 206 48 82 137 213 91 241 62 39 183 229 184 237 121 223 179 199 117 185 240 244 56 38 125 32 5 140 166 122 78 243 77 252 116 1 0 1 48 214 54 94 179 164 240 155 40 191 186 107 180 206 48 82 137 213 91 241 62 39 183 229 184 237 121 223 179 199 117 185 240 244 56 38 125 32 5 140 166 122 78 243 77 252 116 1 0 0 104 54 55 200 109 82 156 202 152 175 66 36 193 252 78 5 135 125 117 139 57 40 153 71 77 232 6 37 188 28 77 2 71 137 173 143 223 127 105 125 144 234 178 168 38 38 22 213 12 86 146 58 86 128 124 44 36 53 34 45 2 168 71 121 160 250 8 153 10 51 71 123 250 225 95 140 177 159 103 47 148 120 154 141 97 250 155 186 25 61 104 158 48 167 246 20 132 6 84 93 66 112 47 0 0 1 104 54 55 200 109 82 156 202 152 175 66 36 193 252 78 5 135 125 117 139 57 40 153 71 77 232 6 37 188 28 77 2 71 137 173 143 223 127 105 125 144 234 178 168 38 38 22 213 12 86 146 58 86 128 124 44 36 53 34 45 2 168 71 121 160 250 8 153 10 51 71 123 250 225 95 140 177 159 103 47 148 120 154 141 97 250 155 186 25 61 104 158 48 167 246 20 132 6 84 93 66 112 47 0 0 0 120 6 90 182 206 193 58 216 170 220 9 22 52 156 242 120 157 30 209 26 98 51 196 178 88 228 65 154 229 210 70 170 198 64 16 247 102 16 21 58 87 235 200 244 76 203 136 132 209 76 195 94 143 2 113 149 235 158 1 227 205 1 208 16 81 131 189 40 241 92 36 170 156 224 56 199 188 154 79 125 102 121 78 97 150 233 11 79 62 109 25 212 226 161 220 35 23 232 13 90 56 183 223 124 31 159 158 14 223 62 85 83 193 110 187 158 93 203 8 0 0 1 120 6 90 182 206 193 58 216 170 220 9 22 52 156 242 120 157 30 209 26 98 51 196 178 88 228 65 154 229 210 70 170 198 64 16 247 102 16 21 58 87 235 200 244 76 203 136 132 209 76 195 94 143 2 113 149 235 158 1 227 205 1 208 16 81 131 189 40 241 92 36 170 156 224 56 199 188 154 79 125 102 121 78 97 150 233 11 79 62 109 25 212 226 161 220 35 23 232 13 90 56 183 223 124 31 159 158 14 223 62 85 83 193 110 187 158 93 203 8 0 0 0 84 47 45 238 181 215 239 242 99 34 179 237 146 38 184 178 32 39 156 91 232 37 68 223 154 247 174 99 147 112 220 68 13 168 71 188 111 58 166 58 109 244 156 76 173 12 217 7 247 229 168 222 84 82 81 171 9 74 74 20 144 71 106 164 117 234 163 235 12 58 184 167 68 145 254 103 0 233 175 219 91 115 45 23 0 1 84 47 45 238 181 215 239 242 99 34 179 237 146 38 184 178 32 39 156 91 232 37 68 223 154 247 174 99 147 112 220 68 13 168 71 188 111 58 166 58 109 244 156 76 173 12 217 7 247 229 168 222 84 82 81 171 9 74 74 20 144 71 106 164 117 234 163 235 12 58 184 167 68 145 254 103 0 233 175 219 91 115 45 23 0 0 72 40 180 241 104 90 252 242 234 235 240 236 39 250 255 76 167 29 116 156 87 88 207 205 175 125 89 77 12 21 97 61 253 152 65 25 101 5 139 108 225 153 138 24 18 112 100 115 211 39 249 92 242 104 78 15 126 214 21 35 238 183 248 195 174 170 41 249 203 160 8 0 0 1 72 40 180 241 104 90 252 242 234 235 240 236 39 250 255 76 167 29 116 156 87 88 207 205 175 125 89 77 12 21 97 61 253 152 65 25 101 5 139 108 225 153 138 24 18 112 100 115 211 39 249 92 242 104 78 15 126 214 21 35 238 183 248 195 174 170 41 249 203 160 8 0 0 0 52 22 27 151 194 115 92 119 11 236 51 137 144 137 103 129 95 89 105 130 240 243 170 243 35 191 215 206 102 95 172 26 80 149 177 248 238 54 111 45 244 22 23 22 224 158 95 94 118 19 0 0 0 1 52 22 27 151 194 115 92 119 11 236 51 137 144 137 103 129 95 89 105 130 240 243 170 243 35 191 215 206 102 95 172 26 80 149 177 248 238 54 111 45 244 22 23 22 224 158 95 94 118 19 0 0 0 0 20 156 43 16 56 55 4 61 155 177 58 74 163 225 4 11 131 179 24 1 0 1 20 156 43 16 56 55 4 61 155 177 58 74 163 225 4 11 131 179 24 1 0 0 104 73 76 101 151 31 35 209 56 36 69 31 173 147 81 94 123 172 22 210 79 45 203 20 140 58 218 46 34 183 138 96 94 97 161 218 71 10 21 254 228 117 64 245 83 14 74 129 103 121 90 57 125 205 210 39 213 162 107 185 36 194 249 86 241 82 226 200 210 202 80 195 105 63 67 249 109 65 100 248 77 32 184 210 162 76 62 215 70 139 167 97 35 196 73 132 172 243 85 144 160 14 20 22 193 1 104 73 76 101 151 31 35 209 56 36 69 31 173 147 81 94 123 172 22 210 79 45 203 20 140 58 218 46 34 183 138 96 94 97 161 218 71 10 21 254 228 117 64 245 83 14 74 129 103 121 90 57 125 205 210 39 213 162 107 185 36 194 249 86 241 82 226 200 210 202 80 195 105 63 67 249 109 65 100 248 77 32 184 210 162 76 62 215 70 139 167 97 35 196 73 132 172 243 85 144 160 14 20 22 193 0 28 126 1 30 104 79 113 99 127 177 76 179 201 53 24 182 29 192 54 96 132 91 248 133 211 86 2 0 0 1 28 126 1 30 104 79 113 99 127 177 76 179 201 53 24 182 29 192 54 96 132 91 248 133 211 86 2 0 0 0 72 92 159 45 128 70 93 245 63 92 118 241 226 212 23 182 127 131 42 229 253 64 210 240 253 132 150 70 236 28 94 44 2 105 246 1 151 224 138 233 135 254 20 25 124 118 13 182 172 20 197 252 20 174 143 186 57 51 58 222 119 36 51 0 104 163 78 183 107 2 0 0 0 1 72 92 159 45 128 70 93 245 63 92 118 241 226 212 23 182 127 131 42 229 253 64 210 240 253 132 150 70 236 28 94 44 2 105 246 1 151 224 138 233 135 254 20 25 124 118 13 182 172 20 197 252 20 174 143 186 57 51 58 222 119 36 51 0 104 163 78 183 107 2 0 0 0 0 124 74 103 198 93 113 70 83 77 90 199 193 206 145 183 35 249 192 236 161 64 7 17 137 53 0 187 116 255 249 232 191 215 71 6 51 192 57 52 156 221 118 241 145 238 148 141 72 31 162 90 235 117 210 45 34 240 215 118 239 161 128 10 59 244 108 240 132 108 62 94 40 142 165 219 48 78 211 95 143 5 181 44 128 205 117 175 172 46 236 144 98 44 44 86 152 86 44 46 101 89 209 229 168 49 93 54 154 211 126 167 37 43 164 36 251 17 187 90 218 47 68 10 0 0 1 124 74 103 198 93 113 70 83 77 90 199 193 206 145 183 35 249 192 236 161 64 7 17 137 53 0 187 116 255 249 232 191 215 71 6 51 192 57 52 156 221 118 241 145 238 148 141 72 31 162 90 235 117 210 45 34 240 215 118 239 161 128 10 59 244 108 240 132 108 62 94 40 142 165 219 48 78 211 95 143 5 181 44 128 205 117 175 172 46 236 144 98 44 44 86 152 86 44 46 101 89 209 229 168 49 93 54 154 211 126 167 37 43 164 36 251 17 187 90 218 47 68 10 0 0 0 48 5 35 182 112 113 188 253 125 124 37 72 205 161 238 42 235 141 207 222 101 115 216 55 107 133 114 20 89 39 233 135 120 225 238 214 101 146 108 76 33 35 58 202 67 65 1 0 0 1 48 5 35 182 112 113 188 253 125 124 37 72 205 161 238 42 235 141 207 222 101 115 216 55 107 133 114 20 89 39 233 135 120 225 238 214 101 146 108 76 33 35 58 202 67 65 1 0 0 0 128 104 135 234 221 147 43 69 249 95 82 22 184 215 149 229 138 106 92 255 169 236 121 106 240 235 221 243 154 22 155 148 218 188 88 136 234 72 234 250 14 92 227 117 188 12 118 41 224 174 244 46 222 46 196 200 235 191 13 185 217 77 182 148 203 3 127 173 173 34 254 84 187 72 234 176 92 208 9 125 82 232 207 39 192 114 153 168 166 210 148 43 5 225 117 107 205 99 179 177 46 90 12 119 11 225 27 124 151 136 98 153 156 122 129 197 79 159 225 89 237 180 211 34 198 224 232 1 0 1 128 104 135 234 221 147 43 69 249 95 82 22 184 215 149 229 138 106 92 255 169 236 121 106 240 235 221 243 154 22 155 148 218 188 88 136 234 72 234 250 14 92 227 117 188 12 118 41 224 174 244 46 222 46 196 200 235 191 13 185 217 77 182 148 203 3 127 173 173 34 254 84 187 72 234 176 92 208 9 125 82 232 207 39 192 114 153 168 166 210 148 43 5 225 117 107 205 99 179 177 46 90 12 119 11 225 27 124 151 136 98 153 156 122 129 197 79 159 225 89 237 180 211 34 198 224 232 1 0 0 124 30 16 152 189 248 187 194 106 86 218 107 172 24 210 165 36 4 181 124 54 238 59 132 56 110 109 236 68 95 102 145 133 240 159 128 36 169 4 207 140 229 186 242 94 18 174 89 159 26 138 112 65 245 118 85 137 113 110 126 144 76 37 227 235 138 77 233 26 84 155 51 80 31 201 113 46 222 200 95 96 232 140 13 80 38 36 30 104 180 121 216 89 15 185 161 136 55 32 42 160 149 50 168 225 1 104 50 30 10 3 96 136 60 23 224 146 203 81 219 70 1 0 0 0 1 124 30 16 152 189 248 187 194 106 86 218 107 172 24 210 165 36 4 181 124 54 238 59 132 56 110 109 236 68 95 102 145 133 240 159 128 36 169 4 207 140 229 186 242 94 18 174 89 159 26 138 112 65 245 118 85 137 113 110 126 144 76 37 227 235 138 77 233 26 84 155 51 80 31 201 113 46 222 200 95 96 232 140 13 80 38 36 30 104 180 121 216 89 15 185 161 136 55 32 42 160 149 50 168 225 1 104 50 30 10 3 96 136 60 23 224 146 203 81 219 70 1 0 0 0 0 32 31 3 148 175 154 99 152 211 246 153 40 92 93 24 93 5 168 109 224 21 185 107 37 219 63 153 164 130 241 93 111 0 1 32 31 3 148 175 154 99 152 211 246 153 40 92 93 24 93 5 168 109 224 21 185 107 37 219 63 153 164 130 241 93 111 0 0 112 73 246 239 200 138 198 5 244 5 61 186 215 203 39 176 220 88 141 123 23 70 239 91 228 24 9 208 86 173 30 190 190 160 205 169 222 186 254 3 42 110 229 120 37 181 245 217 107 172 221 147 223 37 33 9 82 153 101 228 62 236 28 113 251 178 124 157 88 255 13 110 233 60 45 129 160 39 244 17 113 220 114 236 12 12 23 203 127 173 99 182 203 235 40 81 17 163 180 158 157 229 232 88 42 248 234 216 11 207 20 25 51 1 112 73 246 239 200 138 198 5 244 5 61 186 215 203 39 176 220 88 141 123 23 70 239 91 228 24 9 208 86 173 30 190 190 160 205 169 222 186 254 3 42 110 229 120 37 181 245 217 107 172 221 147 223 37 33 9 82 153 101 228 62 236 28 113 251 178 124 157 88 255 13 110 233 60 45 129 160 39 244 17 113 220 114 236 12 12 23 203 127 173 99 182 203 235 40 81 17 163 180 158 157 229 232 88 42 248 234 216 11 207 20 25 51 0 4 39 132 6 0 1 4 39 132 6 0 0 72 220 180 23 131 143 83 213 131 208 206 205 120 25 87 192 44 119 67 69 124 227 114 112 253 61 85 176 134 4 56 189 104 188 137 70 0 24 85 129 75 88 245 68 129 51 145 7 213 104 238 115 223 7 147 12 4 53 239 245 119 158 197 135 154 106 50 38 170 151 176 21 0 1 72 220 180 23 131 143 83 213 131 208 206 205 120 25 87 192 44 119 67 69 124 227 114 112 253 61 85 176 134 4 56 189 104 188 137 70 0 24 85 129 75 88 245 68 129 51 145 7 213 104 238 115 223 7 147 12 4 53 239 245 119 158 197 135 154 106 50 38 170 151 176 21 0 0 52 53 186 59 167 241 59 136 87 128 215 201 225 137 253 171 55 175 94 153 156 167 180 232 139 32 51 246 11 119 98 59 201 174 243 8 69 82 213 30 147 100 60 26 207 249 44 53 34 200 114 0 0 1 52 53 186 59 167 241 59 136 87 128 215 201 225 137 253 171 55 175 94 153 156 167 180 232 139 32 51 246 11 119 98 59 201 174 243 8 69 82 213 30 147 100 60 26 207 249 44 53 34 200 114 0 0 0 80 174 62 24 34 239 200 187 235 239 204 93 34 151 115 205 129 228 152 167 94 171 72 91 21 73 128 43 106 226 191 23 128 76 125 32 132 209 72 252 64 195 197 154 199 15 13 192 133 198 108 88 181 61 227 187 44 34 215 108 151 40 54 253 218 203 218 197 100 1 207 108 14 183 168 181 1 75 68 203 52 1 80 174 62 24 34 239 200 187 235 239 204 93 34 151 115 205 129 228 152 167 94 171 72 91 21 73 128 43 106 226 191 23 128 76 125 32 132 209 72 252 64 195 197 154 199 15 13 192 133 198 108 88 181 61 227 187 44 34 215 108 151 40 54 253 218 203 218 197 100 1 207 108 14 183 168 181 1 75 68 203 52 0 100 178 153 248 14 228 148 99 29 41 180 54 4 212 37 168 181 45 110 40 79 241 192 17 133 242 242 158 27 85 230 33 102 187 163 67 188 94 83 9 227 224 31 154 239 89 44 152 114 79 160 147 226 52 244 38 46 88 71 34 217 114 156 13 83 85 223 134 253 133 126 56 188 90 85 65 29 106 94 50 165 88 56 132 55 180 80 212 40 199 4 162 37 213 90 184 228 101 203 7 49 1 100 178 153 248 14 228 148 99 29 41 180 54 4 212 37 168 181 45 110 40 79 241 192 17 133 242 242 158 27 85 230 33 102 187 163 67 188 94 83 9 227 224 31 154 239 89 44 152 114 79 160 147 226 52 244 38 46 88 71 34 217 114 156 13 83 85 223 134 253 133 126 56 188 90 85 65 29 106 94 50 165 88 56 132 55 180 80 212 40 199 4 162 37 213 90 184 228 101 203 7 49 0 76 38 182 96 145 194 1 121 109 64 49 154 66 199 208 229 235 239 165 41 198 204 230 234 178 15 29 203 140 160 143 49 211 78 57 102 214 114 58 133 221 75 184 224 8 199 190 6 247 208 197 161 3 41 23 120 225 80 183 58 134 227 154 146 238 63 175 177 103 131 253 150 250 82 57 2 3 1 76 38 182 96 145 194 1 121 109 64 49 154 66 199 208 229 235 239 165 41 198 204 230 234 178 15 29 203 140 160 143 49 211 78 57 102 214 114 58 133 221 75 184 224 8 199 190 6 247 208 197 161 3 41 23 120 225 80 183 58 134 227 154 146 238 63 175 177 103 131 253 150 250 82 57 2 3 0 64 248 119 27 143 213 236 116 221 199 155 29 196 80 96 187 63 97 42 122 209 144 117 56 28 149 170 177 209 56 44 150 204 131 187 222 85 190 214 23 67 242 17 199 67 116 180 19 62 92 46 154 222 244 151 104 165 83 192 191 210 45 2 0 0 1 64 248 119 27 143 213 236 116 221 199 155 29 196 80 96 187 63 97 42 122 209 144 117 56 28 149 170 177 209 56 44 150 204 131 187 222 85 190 214 23 67 242 17 199 67 116 180 19 62 92 46 154 222 244 151 104 165 83 192 191 210 45 2 0 0 0 28 75 182 65 120 225 60 231 204 95 201 188 204 81 75 120 231 176 122 123 44 181 212 75 241 199 197 22 0 1 28 75 182 65 120 225 60 231 204 95 201 188 204 81 75 120 231 176 122 123 44 181 212 75 241 199 197 22 0 0 72 223 250 238 211 74 58 16 147 125 7 190 218 142 15 49 69 24 56 233 70 213 49 22 223 242 236 38 167 130 195 39 254 92 251 3 205 152 4 121 107 79 85 199 20 69 53 93 242 156 125 37 228 96 255 30 188 96 67 150 203 206 75 217 143 153 171 129 99 51 5 0 0 1 72 223 250 238 211 74 58 16 147 125 7 190 218 142 15 49 69 24 56 233 70 213 49 22 223 242 236 38 167 130 195 39 254 92 251 3 205 152 4 121 107 79 85 199 20 69 53 93 242 156 125 37 228 96 255 30 188 96 67 150 203 206 75 217 143 153 171 129 99 51 5 0 0 0 40 108 135 124 124 29 149 22 174 63 189 26 9 249 247 17 17 89 247 0 255 90 36 201 133 122 164 9 110 235 211 222 139 25 132 124 219 40 148 57 0 1 40 108 135 124 124 29 149 22 174 63 189 26 9 249 247 17 17 89 247 0 255 90 36 201 133 122 164 9 110 235 211 222 139 25 132 124 219 40 148 57 0 0 4 221 214 2 0 1 4 221 214 2 0 0 64 147 243 38 63 33 71 153 12 98 251 245 150 131 176 144 216 39 46 89 50 223 16 34 113 69 13 67 16 135 235 91 48 79 129 250 166 204 227 58 148 218 46 57 182 34 191 165 85 34 220 7 11 186 11 50 182 83 77 72 179 7 0 0 0 1 64 147 243 38 63 33 71 153 12 98 251 245 150 131 176 144 216 39 46 89 50 223 16 34 113 69 13 67 16 135 235 91 48 79 129 250 166 204 227 58 148 218 46 57 182 34 191 165 85 34 220 7 11 186 11 50 182 83 77 72 179 7 0 0 0 0 116 233 246 77 131 243 68 158 180 136 87 207 157 192 121 128 83 72 237 157 134 56 179 201 1 58 190 146 20 153 238 215 88 195 223 67 97 118 17 130 145 223 169 2 15 100 207 216 142 60 64 52 15 48 69 172 151 212 137 218 247 204 232 97 61 38 179 246 161 46 207 132 202 4 168 89 164 121 208 120 93 104 32 129 66 68 235 47 162 233 166 150 103 24 240 136 140 27 137 9 61 79 35 201 200 190 255 32 23 133 194 43 148 11 47 84 2 1 116 233 246 77 131 243 68 158 180 136 87 207 157 192 121 128 83 72 237 157 134 56 179 201 1 58 190 146 20 153 238 215 88 195 223 67 97 118 17 130 145 223 169 2 15 100 207 216 142 60 64 52 15 48 69 172 151 212 137 218 247 204 232 97 61 38 179 246 161 46 207 132 202 4 168 89 164 121 208 120 93 104 32 129 66 68 235 47 162 233 166 150 103 24 240 136 140 27 137 9 61 79 35 201 200 190 255 32 23 133 194 43 148 11 47 84 2 0 32 158 132 247 73 243 86 76 181 117 114 74 0 73 167 54 232 186 178 119 62 251 36 87 106 243 46 78 254 30 13 0 0 1 32 158 132 247 73 243 86 76 181 117 114 74 0 73 167 54 232 186 178 119 62 251 36 87 106 243 46 78 254 30 13 0 0 0 28 187 109 237 12 177 145 13 138 110 36 103 212 219 254 32 2 199 207 206 58 33 91 157 82 142 0 0 0 1 28 187 109 237 12 177 145 13 138 110 36 103 212 219 254 32 2 199 207 206 58 33 91 157 82 142 0 0 0 0 108 191 156 137 40 227 120 81 180 191 249 128 101 54 189 222 126 135 44 172 229 198 254 122 200 254 68 241 155 189 52 134 12 32 127 165 213 33 74 112 219 180 120 124 62 203 145 126 182 239 201 194 229 70 199 78 71 165 89 3 82 85 207 202 83 229 239 95 208 222 39 184 4 206 170 105 230 130 175 81 36 41 97 157 125 234 216 239 63 206 58 107 124 78 26 131 144 70 157 163 62 27 234 177 215 202 140 179 217 1 108 191 156 137 40 227 120 81 180 191 249 128 101 54 189 222 126 135 44 172 229 198 254 122 200 254 68 241 155 189 52 134 12 32 127 165 213 33 74 112 219 180 120 124 62 203 145 126 182 239 201 194 229 70 199 78 71 165 89 3 82 85 207 202 83 229 239 95 208 222 39 184 4 206 170 105 230 130 175 81 36 41 97 157 125 234 216 239 63 206 58 107 124 78 26 131 144 70 157 163 62 27 234 177 215 202 140 179 217 0 116 255 98 44 67 145 156 67 69 207 144 154 245 114 32 23 127 211 123 148 182 146 150 170 172 74 232 254 188 127 136 34 39 122 230 35 121 2 76 118 160 187 17 37 250 134 176 133 100 139 227 15 230 54 106 167 246 167 233 207 141 247 103 135 96 18 251 188 166 202 113 88 34 38 81 212 236 236 142 153 242 1 12 51 124 236 57 28 83 109 124 63 127 190 114 111 5 105 32 46 141 46 195 82 228 121 27 143 106 94 116 99 98 35 8 0 0 1 116 255 98 44 67 145 156 67 69 207 144 154 245 114 32 23 127 211 123 148 182 146 150 170 172 74 232 254 188 127 136 34 39 122 230 35 121 2 76 118 160 187 17 37 250 134 176 133 100 139 227 15 230 54 106 167 246 167 233 207 141 247 103 135 96 18 251 188 166 202 113 88 34 38 81 212 236 236 142 153 242 1 12 51 124 236 57 28 83 109 124 63 127 190 114 111 5 105 32 46 141 46 195 82 228 121 27 143 106 94 116 99 98 35 8 0 0 0 28 232 106 75 132 234 67 145 119 175 2 68 218 133 30 27 34 7 172 120 42 19 45 118 178 216 1 0 0 1 28 232 106 75 132 234 67 145 119 175 2 68 218 133 30 27 34 7 172 120 42 19 45 118 178 216 1 0 0 0 60 129 215 181 185 15 177 200 177 68 80 119 183 36 206 190 141 54 145 230 111 190 97 150 77 141 67 185 87 206 214 237 78 15 79 202 150 147 74 113 9 154 9 23 173 146 190 131 137 247 142 224 174 235 35 57 206 3 0 0 0 1 60 129 215 181 185 15 177 200 177 68 80 119 183 36 206 190 141 54 145 230 111 190 97 150 77 141 67 185 87 206 214 237 78 15 79 202 150 147 74 113 9 154 9 23 173 146 190 131 137 247 142 224 174 235 35 57 206 3 0 0 0 0 32 115 158 93 203 145 117 229 203 77 183 195 60 46 1 188 230 187 238 14 154 176 183 66 57 250 253 70 58 37 0 0 0 1 32 115 158 93 203 145 117 229 203 77 183 195 60 46 1 188 230 187 238 14 154 176 183 66 57 250 253 70 58 37 0 0 0 0 20 81 129 71 67 43 121 89 51 236 18 78 211 96 141 172 26 113 13 214 3 1 20 81 129 71 67 43 121 89 51 236 18 78 211 96 141 172 26 113 13 214 3 0 24 184 13 246 1 153 149 55 198 59 23 173 215 119 87 65 163 114 196 32 40 213 121 0 0 1 24 184 13 246 1 153 149 55 198 59 23 173 215 119 87 65 163 114 196 32 40 213 121 0 0 0 32 56 51 141 41 47 230 78 216 176 139 28 23 160 170 28 45 110 124 64 37 171 195 108 121 74 182 76 40 76 153 115 0 1 32 56 51 141 41 47 230 78 216 176 139 28 23 160 170 28 45 110 124 64 37 171 195 108 121 74 182 76 40 76 153 115 0 0 32 206 242 236 149 72 96 46 45 248 108 12 136 166 194 52 138 152 63 46 130 98 126 192 209 228 24 24 197 243 7 0 0 1 32 206 242 236 149 72 96 46 45 248 108 12 136 166 194 52 138 152 63 46 130 98 126 192 209 228 24 24 197 243 7 0 0 0 104 163 224 244 5 84 160 193 30 20 248 69 99 186 48 205 24 55 21 110 164 203 99 211 59 80 177 211 86 41 161 229 184 106 19 96 95 57 76 140 135 150 249 39 235 242 249 52 35 6 105 190 17 117 228 226 214 214 171 123 84 78 178 176 91 241 160 229 1 232 67 196 8 201 235 118 130 80 124 105 29 101 75 30 179 181 153 56 118 147 86 245 65 10 214 206 110 133 122 248 252 15 53 12 0 1 104 163 224 244 5 84 160 193 30 20 248 69 99 186 48 205 24 55 21 110 164 203 99 211 59 80 177 211 86 41 161 229 184 106 19 96 95 57 76 140 135 150 249 39 235 242 249 52 35 6 105 190 17 117 228 226 214 214 171 123 84 78 178 176 91 241 160 229 1 232 67 196 8 201 235 118 130 80 124 105 29 101 75 30 179 181 153 56 118 147 86 245 65 10 214 206 110 133 122 248 252 15 53 12 0 0 56 255 163 247 43 209 230 164 208 61 194 65 9 8 102 145 97 240 236 201 123 138 71 245 15 204 218 185 57 76 20 213 174 59 153 22 62 121 255 64 38 76 67 69 50 49 114 127 89 242 171 78 13 84 189 144 206 1 56 255 163 247 43 209 230 164 208 61 194 65 9 8 102 145 97 240 236 201 123 138 71 245 15 204 218 185 57 76 20 213 174 59 153 22 62 121 255 64 38 76 67 69 50 49 114 127 89 242 171 78 13 84 189 144 206 0 64 119 123 244 71 66 212 59 231 215 217 150 174 254 235 5 68 31 31 6 176 61 197 15 162 18 140 92 194 120 2 15 65 53 175 46 99 56 24 73 7 37 185 106 245 175 110 29 253 204 28 202 76 47 79 71 204 251 4 48 167 1 0 0 0 1 64 119 123 244 71 66 212 59 231 215 217 150 174 254 235 5 68 31 31 6 176 61 197 15 162 18 140 92 194 120 2 15 65 53 175 46 99 56 24 73 7 37 185 106 245 175 110 29 253 204 28 202 76 47 79 71 204 251 4 48 167 1 0 0 0 0 40 75 92 25 115 221 208 198 30 142 204 73 223 50 228 83 175 70 246 95 204 121 169 116 174 231 117 55 245 122 146 164 239 74 119 247 71 4 100 3 243 1 40 75 92 25 115 221 208 198 30 142 204 73 223 50 228 83 175 70 246 95 204 121 169 116 174 231 117 55 245 122 146 164 239 74 119 247 71 4 100 3 243 0 12 34 19 120 45 63 194 247 76 181 223 195 16 1 12 34 19 120 45 63 194 247 76 181 223 195 16 0 120 11 156 157 89 152 7 19 248 49 41 66 116 237 10 201 152 231 23 143 156 186 202 203 178 43 1 204 30 223 30 82 205 180 255 123 84 194 132 200 55 172 127 23 130 112 165 163 165 42 122 249 39 165 158 69 42 153 176 150 166 240 46 132 80 211 8 120 35 97 238 127 32 91 232 38 236 223 213 67 53 103 162 194 187 151 60 152 119 172 25 69 23 189 153 199 219 236 157 195 152 26 202 31 27 199 10 79 34 126 168 67 114 24 246 235 163 169 176 2 0 1 120 11 156 157 89 152 7 19 248 49 41 66 116 237 10 201 152 231 23 143 156 186 202 203 178 43 1 204 30 223 30 82 205 180 255 123 84 194 132 200 55 172 127 23 130 112 165 163 165 42 122 249 39 165 158 69 42 153 176 150 166 240 46 132 80 211 8 120 35 97 238 127 32 91 232 38 236 223 213 67 53 103 162 194 187 151 60 152 119 172 25 69 23 189 153 199 219 236 157 195 152 26 202 31 27 199 10 79 34 126 168 67 114 24 246 235 163 169 176 2 0 0 84 85 223 220 13 86 122 92 125 254 224 25 165 190 213 4 132 224 45 245 246 242 4 21 101 215 192 193 89 76 244 92 59 156 26 236 182 254 202 196 35 75 32 109 229 252 167 15 126 64 249 191 76 96 115 179 17 42 165 113 135 249 231 21 159 208 162 179 200 212 213 61 123 49 118 34 59 181 1 182 39 112 251 16 0 1 84 85 223 220 13 86 122 92 125 254 224 25 165 190 213 4 132 224 45 245 246 242 4 21 101 215 192 193 89 76 244 92 59 156 26 236 182 254 202 196 35 75 32 109 229 252 167 15 126 64 249 191 76 96 115 179 17 42 165 113 135 249 231 21 159 208 162 179 200 212 213 61 123 49 118 34 59 181 1 182 39 112 251 16 0 0 56 241 153 124 222 255 91 80 137 188 25 206 200 154 27 122 16 125 75 240 248 246 78 65 142 23 205 193 163 87 157 134 225 91 123 69 215 210 244 123 101 159 224 170 194 255 111 207 183 177 8 44 102 228 238 181 2 1 56 241 153 124 222 255 91 80 137 188 25 206 200 154 27 122 16 125 75 240 248 246 78 65 142 23 205 193 163 87 157 134 225 91 123 69 215 210 244 123 101 159 224 170 194 255 111 207 183 177 8 44 102 228 238 181 2 0 84 108 208 238 121 156 133 32 223 68 75 136 121 125 29 189 121 101 228 164 37 65 109 220 250 136 48 233 198 101 96 135 47 117 233 2 196 191 211 238 100 182 234 243 0 91 97 184 199 182 220 252 38 146 252 212 245 32 52 172 255 55 60 67 104 138 139 119 31 23 22 151 0 79 220 46 31 165 72 73 119 91 0 0 0 1 84 108 208 238 121 156 133 32 223 68 75 136 121 125 29 189 121 101 228 164 37 65 109 220 250 136 48 233 198 101 96 135 47 117 233 2 196 191 211 238 100 182 234 243 0 91 97 184 199 182 220 252 38 146 252 212 245 32 52 172 255 55 60 67 104 138 139 119 31 23 22 151 0 79 220 46 31 165 72 73 119 91 0 0 0 0 24 213 179 45 133 224 12 22 86 217 206 37 101 183 225 74 147 210 205 0 173 128 31 240 53 1 24 213 179 45 133 224 12 22 86 217 206 37 101 183 225 74 147 210 205 0 173 128 31 240 53 0 76 90 55 247 101 97 91 255 60 228 172 4 69 150 197 105 130 9 216 50 222 145 121 93 91 122 8 47 193 246 47 193 9 162 74 30 3 151 221 91 204 206 19 231 186 13 155 24 132 70 140 134 148 236 198 3 189 248 97 75 45 121 50 215 87 150 150 229 138 138 91 126 104 37 101 138 0 1 76 90 55 247 101 97 91 255 60 228 172 4 69 150 197 105 130 9 216 50 222 145 121 93 91 122 8 47 193 246 47 193 9 162 74 30 3 151 221 91 204 206 19 231 186 13 155 24 132 70 140 134 148 236 198 3 189 248 97 75 45 121 50 215 87 150 150 229 138 138 91 126 104 37 101 138 0 0 116 115 168 21 247 112 94 184 201 248 149 252 240 29 141 154 150 50 97 41 31 56 85 247 163 55 145 23 152 45 131 53 22 104 104 156 123 120 164 40 242 48 192 145 28 44 4 132 15 113 134 148 171 248 224 123 182 163 113 254 55 6 161 136 98 198 188 165 53 144 141 184 125 14 170 160 0 214 41 35 209 54 31 123 30 107 49 216 97 58 154 19 33 192 193 123 112 203 64 156 187 211 15 178 212 189 77 250 84 218 228 148 93 53 115 124 112 1 116 115 168 21 247 112 94 184 201 248 149 252 240 29 141 154 150 50 97 41 31 56 85 247 163 55 145 23 152 45 131 53 22 104 104 156 123 120 164 40 242 48 192 145 28 44 4 132 15 113 134 148 171 248 224 123 182 163 113 254 55 6 161 136 98 198 188 165 53 144 141 184 125 14 170 160 0 214 41 35 209 54 31 123 30 107 49 216 97 58 154 19 33 192 193 123 112 203 64 156 187 211 15 178 212 189 77 250 84 218 228 148 93 53 115 124 112 0 96 124 82 249 217 103 152 210 105 101 179 152 26 43 32 241 184 13 170 187 237 6 89 158 142 202 72 9 130 229 186 22 231 141 253 32 147 157 150 169 239 239 208 239 192 162 97 2 190 76 255 147 85 133 38 206 102 92 234 167 23 138 70 25 133 14 226 134 237 118 29 40 218 196 187 239 239 178 225 158 55 21 189 63 14 233 211 32 249 204 188 227 125 20 0 0 0 1 96 124 82 249 217 103 152 210 105 101 179 152 26 43 32 241 184 13 170 187 237 6 89 158 142 202 72 9 130 229 186 22 231 141 253 32 147 157 150 169 239 239 208 239 192 162 97 2 190 76 255 147 85 133 38 206 102 92 234 167 23 138 70 25 133 14 226 134 237 118 29 40 218 196 187 239 239 178 225 158 55 21 189 63 14 233 211 32 249 204 188 227 125 20 0 0 0 0 128 177 60 161 102 138 146 247 69 176 188 18 92 242 96 135 152 103 107 37 160 86 206 146 191 253 129 245 98 150 12 55 16 198 207 141 173 254 8 189 100 126 62 201 64 132 146 143 251 54 46 248 170 236 238 107 85 4 232 188 238 154 172 221 156 205 139 30 154 186 201 53 77 80 85 0 164 126 169 125 95 209 214 94 114 253 109 143 69 147 26 150 229 49 67 202 41 185 188 58 222 135 170 143 147 169 56 199 253 208 108 79 241 186 223 39 47 118 166 2 119 183 150 198 249 52 6 0 0 1 128 177 60 161 102 138 146 247 69 176 188 18 92 242 96 135 152 103 107 37 160 86 206 146 191 253 129 245 98 150 12 55 16 198 207 141 173 254 8 189 100 126 62 201 64 132 146 143 251 54 46 248 170 236 238 107 85 4 232 188 238 154 172 221 156 205 139 30 154 186 201 53 77 80 85 0 164 126 169 125 95 209 214 94 114 253 109 143 69 147 26 150 229 49 67 202 41 185 188 58 222 135 170 143 147 169 56 199 253 208 108 79 241 186 223 39 47 118 166 2 119 183 150 198 249 52 6 0 0 0 48 121 50 208 121 198 113 59 191 8 122 194 42 131 235 44 67 197 194 251 149 183 60 30 84 243 193 92 233 207 81 221 84 214 60 215 107 83 0 178 5 171 252 181 246 155 13 0 0 1 48 121 50 208 121 198 113 59 191 8 122 194 42 131 235 44 67 197 194 251 149 183 60 30 84 243 193 92 233 207 81 221 84 214 60 215 107 83 0 178 5 171 252 181 246 155 13 0 0 0 56 166 53 117 196 161 229 248 189 4 118 22 159 55 250 249 52 240 65 18 192 100 153 107 30 88 36 106 130 0 220 222 225 150 0 193 132 255 124 153 51 146 110 36 253 172 218 35 80 8 122 3 16 206 124 33 42 1 56 166 53 117 196 161 229 248 189 4 118 22 159 55 250 249 52 240 65 18 192 100 153 107 30 88 36 106 130 0 220 222 225 150 0 193 132 255 124 153 51 146 110 36 253 172 218 35 80 8 122 3 16 206 124 33 42 0 88 106 68 182 59 178 196 127 243 157 52 191 25 43 145 111 238 141 79 101 131 239 1 63 142 28 0 132 32 245 126 60 32 214 17 147 90 227 5 98 15 248 217 212 142 124 197 131 140 236 233 147 37 78 121 156 176 23 194 249 199 210 9 238 29 123 193 74 93 96 82 46 195 174 189 189 138 161 169 130 51 227 225 203 252 54 230 59 1 1 88 106 68 182 59 178 196 127 243 157 52 191 25 43 145 111 238 141 79 101 131 239 1 63 142 28 0 132 32 245 126 60 32 214 17 147 90 227 5 98 15 248 217 212 142 124 197 131 140 236 233 147 37 78 121 156 176 23 194 249 199 210 9 238 29 123 193 74 93 96 82 46 195 174 189 189 138 161 169 130 51 227 225 203 252 54 230 59 1 0 16 91 51 80 52 153 106 15 96 178 33 98 180 208 107 15 0 1 16 91 51 80 52 153 106 15 96 178 33 98 180 208 107 15 0 0 92 146 234 254 250 136 181 23 108 220 189 235 39 183 250 50 211 23 108 166 159 135 169 94 214 225 32 1 13 78 240 181 132 87 93 98 20 18 115 26 247 31 145 41 94 224 210 84 160 74 211 209 64 225 64 180 241 208 245 103 182 102 43 178 61 140 91 159 243 48 233 2 13 121 164 43 215 31 105 2 197 114 135 82 116 240 53 2 223 62 194 1 0 1 92 146 234 254 250 136 181 23 108 220 189 235 39 183 250 50 211 23 108 166 159 135 169 94 214 225 32 1 13 78 240 181 132 87 93 98 20 18 115 26 247 31 145 41 94 224 210 84 160 74 211 209 64 225 64 180 241 208 245 103 182 102 43 178 61 140 91 159 243 48 233 2 13 121 164 43 215 31 105 2 197 114 135 82 116 240 53 2 223 62 194 1 0 0 36 185 152 217 29 34 198 116 253 71 146 190 251 229 82 88 248 120 47 21 213 170 170 112 236 72 88 154 181 235 239 69 222 48 2 0 0 1 36 185 152 217 29 34 198 116 253 71 146 190 251 229 82 88 248 120 47 21 213 170 170 112 236 72 88 154 181 235 239 69 222 48 2 0 0 0 24 29 136 104 174 70 11 214 125 207 165 237 74 237 199 33 28 122 6 213 243 25 0 0 0 1 24 29 136 104 174 70 11 214 125 207 165 237 74 237 199 33 28 122 6 213 243 25 0 0 0 0 56 208 160 113 38 148 89 13 191 95 94 203 140 7 30 57 94 69 180 223 237 240 172 171 247 162 165 245 245 5 100 24 96 24 245 62 100 128 18 89 116 205 89 200 251 14 195 113 223 134 107 202 24 7 0 0 0 1 56 208 160 113 38 148 89 13 191 95 94 203 140 7 30 57 94 69 180 223 237 240 172 171 247 162 165 245 245 5 100 24 96 24 245 62 100 128 18 89 116 205 89 200 251 14 195 113 223 134 107 202 24 7 0 0 0 0 20 164 26 119 125 80 143 88 12 173 143 157 18 207 147 18 133 102 5 0 0 1 20 164 26 119 125 80 143 88 12 173 143 157 18 207 147 18 133 102 5 0 0 0 80 240 91 93 80 200 2 55 132 40 130 206 143 31 138 22 6 196 227 42 127 4 69 60 97 99 42 199 161 115 16 243 173 96 104 227 89 184 61 55 91 197 16 30 116 69 157 9 62 186 27 47 108 196 231 54 53 86 238 78 204 233 137 113 247 34 18 212 144 7 152 39 169 110 99 156 198 1 0 0 0 1 80 240 91 93 80 200 2 55 132 40 130 206 143 31 138 22 6 196 227 42 127 4 69 60 97 99 42 199 161 115 16 243 173 96 104 227 89 184 61 55 91 197 16 30 116 69 157 9 62 186 27 47 108 196 231 54 53 86 238 78 204 233 137 113 247 34 18 212 144 7 152 39 169 110 99 156 198 1 0 0 0 0 60 164 36 243 234 38 238 24 36 226 207 250 29 63 195 44 89 189 228 110 154 71 14 125 43 159 59 53 176 232 184 148 203 158 152 210 156 44 195 201 57 165 81 190 91 35 122 171 243 195 109 195 142 67 89 184 14 18 25 0 0 1 60 164 36 243 234 38 238 24 36 226 207 250 29 63 195 44 89 189 228 110 154 71 14 125 43 159 59 53 176 232 184 148 203 158 152 210 156 44 195 201 57 165 81 190 91 35 122 171 243 195 109 195 142 67 89 184 14 18 25 0 0 0 36 168 114 107 133 10 23 139 104 205 120 166 131 193 1 223 63 29 201 98 120 19 62 117 38 159 115 66 105 171 210 74 142 248 0 0 0 1 36 168 114 107 133 10 23 139 104 205 120 166 131 193 1 223 63 29 201 98 120 19 62 117 38 159 115 66 105 171 210 74 142 248 0 0 0 0 8 188 118 208 125 103 29 0 0 1 8 188 118 208 125 103 29 0 0 0 80 93 36 106 167 48 129 182 121 19 12 119 143 58 46 98 169 218 191 211 74 102 51 142 112 70 65 240 134 104 65 202 183 210 160 25 144 232 17 193 129 249 86 192 216 157 46 31 9 89 42 0 255 32 223 228 36 241 177 228 240 221 30 38 173 183 42 128 15 55 48 187 131 109 78 5 178 203 7 0 0 1 80 93 36 106 167 48 129 182 121 19 12 119 143 58 46 98 169 218 191 211 74 102 51 142 112 70 65 240 134 104 65 202 183 210 160 25 144 232 17 193 129 249 86 192 216 157 46 31 9 89 42 0 255 32 223 228 36 241 177 228 240 221 30 38 173 183 42 128 15 55 48 187 131 109 78 5 178 203 7 0 0 0 104 209 253 145 149 140 101 72 59 80 61 95 87 223 103 111 142 120 156 200 160 119 178 162 183 243 3 59 250 14 151 250 48 55 97 183 44 47 166 154 9 238 68 13 148 84 67 106 86 157 132 235 187 35 17 121 154 165 226 136 96 27 177 250 145 13 38 0 109 173 58 16 189 45 0 156 64 166 8 87 150 211 191 66 117 148 187 227 116 144 40 22 160 105 172 245 89 17 98 157 251 122 154 0 0 1 104 209 253 145 149 140 101 72 59 80 61 95 87 223 103 111 142 120 156 200 160 119 178 162 183 243 3 59 250 14 151 250 48 55 97 183 44 47 166 154 9 238 68 13 148 84 67 106 86 157 132 235 187 35 17 121 154 165 226 136 96 27 177 250 145 13 38 0 109 173 58 16 189 45 0 156 64 166 8 87 150 211 191 66 117 148 187 227 116 144 40 22 160 105 172 245 89 17 98 157 251 122 154 0 0 0 92 48 216 197 206 211 163 26 178 30 38 25 126 254 218 154 197 147 60 114 177 112 98 153 149 94 247 85 223 187 252 210 64 20 63 98 66 201 175 4 146 53 51 161 164 120 186 172 160 189 77 68 186 110 221 45 4 254 96 67 66 66 64 145 122 236 241 192 130 240 110 229 191 58 172 70 147 64 128 67 77 37 143 90 168 105 183 130 40 128 162 204 0 1 92 48 216 197 206 211 163 26 178 30 38 25 126 254 218 154 197 147 60 114 177 112 98 153 149 94 247 85 223 187 252 210 64 20 63 98 66 201 175 4 146 53 51 161 164 120 186 172 160 189 77 68 186 110 221 45 4 254 96 67 66 66 64 145 122 236 241 192 130 240 110 229 191 58 172 70 147 64 128 67 77 37 143 90 168 105 183 130 40 128 162 204 0 0 24 176 183 71 106 140 200 146 60 201 141 49 175 206 219 24 51 141 203 213 202 124 18 0 0 1 24 176 183 71 106 140 200 146 60 201 141 49 175 206 219 24 51 141 203 213 202 124 18 0 0 0 32 97 221 208 156 227 180 222 58 51 5 156 2 70 25 102 197 16 16 222 115 157 90 121 207 16 211 217 208 2 0 0 0 1 32 97 221 208 156 227 180 222 58 51 5 156 2 70 25 102 197 16 16 222 115 157 90 121 207 16 211 217 208 2 0 0 0 0 108 178 156 236 219 98 243 32 106 184 211 76 115 58 138 184 11 243 158 111 214 180 249 75 209 228 102 1 198 201 169 202 134 82 247 29 60 251 130 101 5 79 254 236 4 3 154 24 213 80 110 237 105 114 57 175 148 37 189 215 96 26 164 159 215 189 91 213 117 182 250 78 196 91 184 197 122 91 11 110 49 145 65 35 242 27 150 116 151 97 138 84 129 122 101 163 101 143 206 236 240 17 99 91 63 34 187 4 0 1 108 178 156 236 219 98 243 32 106 184 211 76 115 58 138 184 11 243 158 111 214 180 249 75 209 228 102 1 198 201 169 202 134 82 247 29 60 251 130 101 5 79 254 236 4 3 154 24 213 80 110 237 105 114 57 175 148 37 189 215 96 26 164 159 215 189 91 213 117 182 250 78 196 91 184 197 122 91 11 110 49 145 65 35 242 27 150 116 151 97 138 84 129 122 101 163 101 143 206 236 240 17 99 91 63 34 187 4 0 0 16 191 50 248 33 176 205 97 154 211 182 118 170 186 32 76 1 1 16 191 50 248 33 176 205 97 154 211 182 118 170 186 32 76 1 0 44 234 193 100 178 9 208 13 92 237 227 179 241 244 131 30 214 22 128 221 109 129 32 221 92 143 17 196 16 142 53 151 122 200 63 163 198 197 112 127 42 47 2 0 0 1 44 234 193 100 178 9 208 13 92 237 227 179 241 244 131 30 214 22 128 221 109 129 32 221 92 143 17 196 16 142 53 151 122 200 63 163 198 197 112 127 42 47 2 0 0 0 40 165 3 177 221 137 96 40 2 95 239 12 147 159 69 92 8 226 226 89 13 220 87 111 111 4 46 185 191 135 108 64 28 98 137 121 69 157 147 3 0 1 40 165 3 177 221 137 96 40 2 95 239 12 147 159 69 92 8 226 226 89 13 220 87 111 111 4 46 185 191 135 108 64 28 98 137 121 69 157 147 3 0 0 88 117 70 136 141 37 22 10 38 199 136 67 121 78 100 165 189 58 199 68 147 53 35 88 254 145 48 3 64 111 49 252 79 215 24 85 125 88 7 197 53 75 129 196 177 222 97 246 145 156 189 140 144 166 41 155 175 68 115 133 179 126 64 86 56 38 73 200 37 103 6 154 47 83 59 156 31 165 8 192 161 64 77 224 85 1 0 0 0 1 88 117 70 136 141 37 22 10 38 199 136 67 121 78 100 165 189 58 199 68 147 53 35 88 254 145 48 3 64 111 49 252 79 215 24 85 125 88 7 197 53 75 129 196 177 222 97 246 145 156 189 140 144 166 41 155 175 68 115 133 179 126 64 86 56 38 73 200 37 103 6 154 47 83 59 156 31 165 8 192 161 64 77 224 85 1 0 0 0 0 44 217 185 213 61 101 246 30 87 9 40 115 28 155 141 207 255 17 194 181 7 208 69 15 189 18 161 29 215 47 247 4 172 133 64 239 27 206 90 55 197 113 0 0 0 1 44 217 185 213 61 101 246 30 87 9 40 115 28 155 141 207 255 17 194 181 7 208 69 15 189 18 161 29 215 47 247 4 172 133 64 239 27 206 90 55 197 113 0 0 0 0 56 148 182 61 42 123 22 99 146 228 21 87 117 190 75 48 0 97 189 188 28 85 193 232 154 144 129 19 107 255 92 192 179 73 21 211 208 243 243 72 10 53 231 255 190 241 19 69 17 2 153 53 8 39 246 0 0 1 56 148 182 61 42 123 22 99 146 228 21 87 117 190 75 48 0 97 189 188 28 85 193 232 154 144 129 19 107 255 92 192 179 73 21 211 208 243 243 72 10 53 231 255 190 241 19 69 17 2 153 53 8 39 246 0 0 0 56 211 66 149 196 5 244 108 154 21 75 148 133 24 12 252 29 159 127 240 191 48 35 202 86 177 34 52 193 54 229 170 58 106 119 182 50 240 221 151 21 237 110 249 225 73 237 49 54 255 10 114 182 126 107 8 0 1 56 211 66 149 196 5 244 108 154 21 75 148 133 24 12 252 29 159 127 240 191 48 35 202 86 177 34 52 193 54 229 170 58 106 119 182 50 240 221 151 21 237 110 249 225 73 237 49 54 255 10 114 182 126 107 8 0 0 104 225 214 120 250 248 166 189 72 25 10 51 38 36 179 73 86 127 210 96 225 42 108 183 54 154 102 128 235 61 79 169 19 33 27 197 27 140 126 108 68 180 57 222 96 50 135 137 200 40 109 22 3 187 139 78 175 226 173 222 38 56 155 201 55 29 54 110 130 125 243 53 89 135 235 66 91 26 131 150 14 181 180 220 56 68 157 222 65 169 237 15 194 167 35 49 59 236 93 240 247 1 0 0 0 1 104 225 214 120 250 248 166 189 72 25 10 51 38 36 179 73 86 127 210 96 225 42 108 183 54 154 102 128 235 61 79 169 19 33 27 197 27 140 126 108 68 180 57 222 96 50 135 137 200 40 109 22 3 187 139 78 175 226 173 222 38 56 155 201 55 29 54 110 130 125 243 53 89 135 235 66 91 26 131 150 14 181 180 220 56 68 157 222 65 169 237 15 194 167 35 49 59 236 93 240 247 1 0 0 0 0 68 250 13 100 76 198 39 97 190 132 34 30 132 205 55 142 174 37 28 5 136 138 69 4 127 203 225 200 100 221 206 243 94 81 111 236 255 188 143 231 143 35 187 81 173 188 250 232 196 70 175 70 188 195 241 113 46 158 102 170 214 243 177 164 189 186 2 0 0 1 68 250 13 100 76 198 39 97 190 132 34 30 132 205 55 142 174 37 28 5 136 138 69 4 127 203 225 200 100 221 206 243 94 81 111 236 255 188 143 231 143 35 187 81 173 188 250 232 196 70 175 70 188 195 241 113 46 158 102 170 214 243 177 164 189 186 2 0 0 0 16 252 62 17 105 107 27 138 254 209 166 253 232 14 173 53 0 1 16 252 62 17 105 107 27 138 254 209 166 253 232 14 173 53 0 0 12 248 20 114 16 45 167 199 205 247 93 60 1 1 12 248 20 114 16 45 167 199 205 247 93 60 1 0 128 68 85 139 65 128 103 40 178 143 96 39 160 16 180 192 162 49 134 53 77 80 87 249 241 72 43 118 116 184 230 72 29 217 203 233 243 99 73 223 120 79 37 252 19 42 245 193 177 160 241 111 129 21 196 151 106 142 158 95 161 24 140 154 174 72 129 49 87 117 19 229 253 93 146 82 164 63 11 89 51 145 182 224 167 87 85 133 130 24 56 22 86 126 37 63 50 11 25 59 22 7 198 60 94 176 166 72 203 118 45 191 236 253 8 4 237 208 247 95 191 61 131 45 100 233 41 140 1 1 128 68 85 139 65 128 103 40 178 143 96 39 160 16 180 192 162 49 134 53 77 80 87 249 241 72 43 118 116 184 230 72 29 217 203 233 243 99 73 223 120 79 37 252 19 42 245 193 177 160 241 111 129 21 196 151 106 142 158 95 161 24 140 154 174 72 129 49 87 117 19 229 253 93 146 82 164 63 11 89 51 145 182 224 167 87 85 133 130 24 56 22 86 126 37 63 50 11 25 59 22 7 198 60 94 176 166 72 203 118 45 191 236 253 8 4 237 208 247 95 191 61 131 45 100 233 41 140 1 0 36 171 175 7 24 85 197 52 53 222 109 116 70 7 33 47 129 85 73 230 121 23 188 153 132 54 221 247 177 60 250 118 199 113 48 0 0 1 36 171 175 7 24 85 197 52 53 222 109 116 70 7 33 47 129 85 73 230 121 23 188 153 132 54 221 247 177 60 250 118 199 113 48 0 0 0 24 93 217 212 50 244 177 120 129 193 148 208 62 51 48 197 29 12 127 5 133 232 174 163 14 1 24 93 217 212 50 244 177 120 129 193 148 208 62 51 48 197 29 12 127 5 133 232 174 163 14 0 104 61 140 155 145 23 121 180 150 193 253 181 78 221 177 28 155 147 231 109 135 40 213 10 176 7 92 102 36 228 91 74 59 128 90 66 174 228 143 117 219 65 92 198 227 147 31 210 199 101 130 185 96 20 234 102 37 117 134 38 231 28 208 231 74 69 32 133 140 236 129 186 142 89 0 72 223 168 63 132 85 4 58 183 202 56 212 86 111 8 7 182 11 108 42 143 34 30 250 94 6 24 226 5 0 1 104 61 140 155 145 23 121 180 150 193 253 181 78 221 177 28 155 147 231 109 135 40 213 10 176 7 92 102 36 228 91 74 59 128 90 66 174 228 143 117 219 65 92 198 227 147 31 210 199 101 130 185 96 20 234 102 37 117 134 38 231 28 208 231 74 69 32 133 140 236 129 186 142 89 0 72 223 168 63 132 85 4 58 183 202 56 212 86 111 8 7 182 11 108 42 143 34 30 250 94 6 24 226 5 0 0 100 69 203 211 226 232 194 190 174 38 42 219 202 126 170 213 67 251 214 240 5 57 56 204 220 229 22 83 177 58 244 203 158 220 19 118 48 28 104 202 235 222 18 48 27 53 30 213 133 250 43 151 110 53 51 81 104 66 224 80 32 48 197 127 8 196 143 211 86 42 231 40 1 196 225 20 87 198 99 207 33 242 133 186 174 87 131 82 161 85 98 41 79 235 6 54 208 79 63 0 0 1 100 69 203 211 226 232 194 190 174 38 42 219 202 126 170 213 67 251 214 240 5 57 56 204 220 229 22 83 177 58 244 203 158 220 19 118 48 28 104 202 235 222 18 48 27 53 30 213 133 250 43 151 110 53 51 81 104 66 224 80 32 48 197 127 8 196 143 211 86 42 231 40 1 196 225 20 87 198 99 207 33 242 133 186 174 87 131 82 161 85 98 41 79 235 6 54 208 79 63 0 0 0 4 106 133 253 254 1 4 106 133 253 254 0 36 52 160 46 168 248 117 14 87 213 169 244 54 52 54 90 204 139 227 70 129 237 255 102 107 43 17 92 104 188 166 27 224 59 206 1 0 1 36 52 160 46 168 248 117 14 87 213 169 244 54 52 54 90 204 139 227 70 129 237 255 102 107 43 17 92 104 188 166 27 224 59 206 1 0 0 120 181 140 78 163 1 144 166 35 223 120 26 62 194 182 189 188 203 150 222 242 105 153 199 190 59 209 251 150 143 51 233 52 50 171 137 94 76 60 155 162 163 194 72 102 39 206 211 44 149 8 71 7 3 14 238 150 49 199 209 147 173 71 223 95 145 84 45 137 227 252 43 100 85 213 9 217 99 70 100 168 88 110 229 244 46 8 112 7 141 228 169 214 105 143 254 11 226 135 101 6 67 255 70 224 194 81 96 193 178 170 189 80 169 153 245 174 120 167 5 0 1 120 181 140 78 163 1 144 166 35 223 120 26 62 194 182 189 188 203 150 222 242 105 153 199 190 59 209 251 150 143 51 233 52 50 171 137 94 76 60 155 162 163 194 72 102 39 206 211 44 149 8 71 7 3 14 238 150 49 199 209 147 173 71 223 95 145 84 45 137 227 252 43 100 85 213 9 217 99 70 100 168 88 110 229 244 46 8 112 7 141 228 169 214 105 143 254 11 226 135 101 6 67 255 70 224 194 81 96 193 178 170 189 80 169 153 245 174 120 167 5 0 0 32 19 169 230 106 158 164 68 252 228 52 75 229 81 25 134 88 61 171 29 148 225 103 206 90 122 156 116 158 229 80 62 7 1 32 19 169 230 106 158 164 68 252 228 52 75 229 81 25 134 88 61 171 29 148 225 103 206 90 122 156 116 158 229 80 62 7 0 96 44 24 45 150 1 57 124 51 120 88 192 53 82 3 14 197 181 78 62 96 149 139 236 70 23 91 206 58 4 12 63 75 51 192 197 2 242 185 178 73 152 109 161 60 142 161 171 63 201 195 243 198 2 124 119 14 189 184 21 26 90 196 117 3 207 78 196 78 191 210 218 232 185 4 72 102 10 124 94 142 17 14 238 243 191 213 250 160 226 11 56 213 156 15 0 0 1 96 44 24 45 150 1 57 124 51 120 88 192 53 82 3 14 197 181 78 62 96 149 139 236 70 23 91 206 58 4 12 63 75 51 192 197 2 242 185 178 73 152 109 161 60 142 161 171 63 201 195 243 198 2 124 119 14 189 184 21 26 90 196 117 3 207 78 196 78 191 210 218 232 185 4 72 102 10 124 94 142 17 14 238 243 191 213 250 160 226 11 56 213 156 15 0 0 0 16 5 128 98 100 111 201 242 99 239 114 208 3 48 1 0 0 1 16 5 128 98 100 111 201 242 99 239 114 208 3 48 1 0 0 0 64 55 164 28 11 235 113 86 122 52 237 225 241 179 197 83 95 114 107 69 13 182 58 173 152 229 230 108 171 135 2 108 102 81 246 165 202 47 238 229 240 109 119 151 6 36 92 18 67 160 204 138 149 79 36 130 164 116 48 77 57 61 42 21 0 1 64 55 164 28 11 235 113 86 122 52 237 225 241 179 197 83 95 114 107 69 13 182 58 173 152 229 230 108 171 135 2 108 102 81 246 165 202 47 238 229 240 109 119 151 6 36 92 18 67 160 204 138 149 79 36 130 164 116 48 77 57 61 42 21 0 0 48 94 61 43 8 236 81 175 216 38 46 240 164 24 125 150 38 110 153 168 221 238 46 195 146 161 141 191 230 139 251 175 57 243 39 106 55 170 158 83 212 72 98 28 253 2 0 0 0 1 48 94 61 43 8 236 81 175 216 38 46 240 164 24 125 150 38 110 153 168 221 238 46 195 146 161 141 191 230 139 251 175 57 243 39 106 55 170 158 83 212 72 98 28 253 2 0 0 0 0 76 48 94 140 165 180 105 31 16 145 182 147 88 246 146 184 137 158 100 218 254 225 130 175 24 164 19 172 15 135 152 163 48 137 131 182 181 101 168 51 195 131 251 4 29 231 230 96 29 58 177 144 95 60 187 109 242 143 92 252 239 108 72 4 59 210 46 232 34 139 28 238 105 211 76 0 0 1 76 48 94 140 165 180 105 31 16 145 182 147 88 246 146 184 137 158 100 218 254 225 130 175 24 164 19 172 15 135 152 163 48 137 131 182 181 101 168 51 195 131 251 4 29 231 230 96 29 58 177 144 95 60 187 109 242 143 92 252 239 108 72 4 59 210 46 232 34 139 28 238 105 211 76 0 0 0 40 234 82 61 126 225 47 95 67 86 217 19 160 166 207 107 2 63 101 138 71 14 205 171 155 149 191 239 138 12 202 149 100 120 202 78 69 3 0 0 0 1 40 234 82 61 126 225 47 95 67 86 217 19 160 166 207 107 2 63 101 138 71 14 205 171 155 149 191 239 138 12 202 149 100 120 202 78 69 3 0 0 0 0 32 254 34 44 189 14 4 206 100 120 172 67 182 70 62 43 236 232 71 120 86 45 165 252 19 123 77 145 98 252 22 8 0 1 32 254 34 44 189 14 4 206 100 120 172 67 182 70 62 43 236 232 71 120 86 45 165 252 19 123 77 145 98 252 22 8 0 0 124 133 133 183 97 16 40 176 80 73 78 7 25 246 204 110 33 191 19 111 253 42 125 217 152 191 133 9 231 196 126 215 115 228 86 114 230 179 150 254 155 22 188 36 125 187 206 19 227 235 11 176 130 143 111 209 43 29 89 113 147 102 119 48 191 43 79 47 89 120 0 227 25 169 53 18 37 83 52 60 241 101 240 255 139 61 119 189 13 92 89 30 29 252 1 22 209 105 170 119 94 158 16 175 58 110 238 74 117 112 41 56 246 67 154 141 63 25 112 206 160 3 84 134 50 1 124 133 133 183 97 16 40 176 80 73 78 7 25 246 204 110 33 191 19 111 253 42 125 217 152 191 133 9 231 196 126 215 115 228 86 114 230 179 150 254 155 22 188 36 125 187 206 19 227 235 11 176 130 143 111 209 43 29 89 113 147 102 119 48 191 43 79 47 89 120 0 227 25 169 53 18 37 83 52 60 241 101 240 255 139 61 119 189 13 92 89 30 29 252 1 22 209 105 170 119 94 158 16 175 58 110 238 74 117 112 41 56 246 67 154 141 63 25 112 206 160 3 84 134 50 0 60 242 208 163 166 217 157 45 88 172 11 229 109 23 46 229 250 139 217 234 229 172 253 211 253 11 8 225 163 20 87 100 148 249 249 188 166 122 64 131 225 233 55 241 36 232 11 174 172 83 153 87 165 3 39 84 162 67 204 110 0 1 60 242 208 163 166 217 157 45 88 172 11 229 109 23 46 229 250 139 217 234 229 172 253 211 253 11 8 225 163 20 87 100 148 249 249 188 166 122 64 131 225 233 55 241 36 232 11 174 172 83 153 87 165 3 39 84 162 67 204 110 0 0 28 62 99 60 181 249 169 105 74 220 130 197 142 213 226 245 78 96 45 105 171 176 157 17 155 32 93 59 15 1 28 62 99 60 181 249 169 105 74 220 130 197 142 213 226 245 78 96 45 105 171 176 157 17 155 32 93 59 15


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int1024_serial64.txt
================================================
22 serialization::archive 10 0 0 0 0 0 112 240 216 207 212 25 178 183 244 196 236 95 147 174 198 156 135 30 192 249 71 150 58 81 90 83 157 31 192 97 218 61 242 6 92 59 181 100 93 130 250 188 246 144 44 168 35 244 193 47 12 158 190 153 204 174 128 206 100 236 32 18 126 89 123 194 22 35 211 231 76 148 27 235 109 5 183 33 227 88 207 58 215 251 252 155 139 128 94 102 109 67 113 84 50 31 117 129 72 215 77 164 152 225 243 6 0 0 0 0 0 0 0 1 112 240 216 207 212 25 178 183 244 196 236 95 147 174 198 156 135 30 192 249 71 150 58 81 90 83 157 31 192 97 218 61 242 6 92 59 181 100 93 130 250 188 246 144 44 168 35 244 193 47 12 158 190 153 204 174 128 206 100 236 32 18 126 89 123 194 22 35 211 231 76 148 27 235 109 5 183 33 227 88 207 58 215 251 252 155 139 128 94 102 109 67 113 84 50 31 117 129 72 215 77 164 152 225 243 6 0 0 0 0 0 0 0 0 24 233 110 98 40 22 77 153 193 59 146 80 175 250 132 156 155 86 10 0 0 0 0 0 0 1 24 233 110 98 40 22 77 153 193 59 146 80 175 250 132 156 155 86 10 0 0 0 0 0 0 0 120 195 197 234 211 167 46 136 167 128 33 88 13 108 237 91 62 12 92 69 154 204 29 67 225 108 76 250 33 86 106 195 35 211 56 231 162 75 128 234 92 136 184 82 7 210 243 108 153 53 77 201 114 146 101 203 238 16 127 62 157 89 147 7 159 33 49 73 121 45 71 184 101 48 57 231 136 53 32 117 91 72 53 49 149 132 120 220 38 202 141 199 61 152 225 162 88 241 96 97 235 194 95 106 102 77 171 141 79 25 171 118 0 150 152 162 225 0 0 0 0 1 120 195 197 234 211 167 46 136 167 128 33 88 13 108 237 91 62 12 92 69 154 204 29 67 225 108 76 250 33 86 106 195 35 211 56 231 162 75 128 234 92 136 184 82 7 210 243 108 153 53 77 201 114 146 101 203 238 16 127 62 157 89 147 7 159 33 49 73 121 45 71 184 101 48 57 231 136 53 32 117 91 72 53 49 149 132 120 220 38 202 141 199 61 152 225 162 88 241 96 97 235 194 95 106 102 77 171 141 79 25 171 118 0 150 152 162 225 0 0 0 0 0 112 52 251 142 48 154 38 230 245 135 197 116 187 16 93 121 73 166 67 73 14 108 247 153 173 155 1 1 27 39 117 50 208 104 14 143 42 205 185 79 111 156 236 127 179 134 12 211 3 186 248 224 18 111 115 8 241 120 193 95 162 144 223 81 125 100 15 75 159 151 135 167 7 105 70 42 112 187 150 50 81 238 10 88 7 185 247 8 238 5 251 173 132 245 18 238 209 93 5 153 183 17 250 77 56 125 31 2 0 0 0 0 0 1 112 52 251 142 48 154 38 230 245 135 197 116 187 16 93 121 73 166 67 73 14 108 247 153 173 155 1 1 27 39 117 50 208 104 14 143 42 205 185 79 111 156 236 127 179 134 12 211 3 186 248 224 18 111 115 8 241 120 193 95 162 144 223 81 125 100 15 75 159 151 135 167 7 105 70 42 112 187 150 50 81 238 10 88 7 185 247 8 238 5 251 173 132 245 18 238 209 93 5 153 183 17 250 77 56 125 31 2 0 0 0 0 0 0 24 197 207 215 162 39 250 228 2 55 205 156 2 210 250 185 127 9 0 0 0 0 0 0 0 1 24 197 207 215 162 39 250 228 2 55 205 156 2 210 250 185 127 9 0 0 0 0 0 0 0 0 128 24 227 82 233 197 174 88 134 19 71 12 155 49 99 207 184 189 139 213 148 142 65 83 22 86 59 113 20 118 242 15 207 165 34 25 223 113 59 30 140 39 47 19 17 91 233 70 193 187 55 81 125 94 114 235 6 80 26 251 206 129 223 96 50 3 188 107 248 74 130 151 7 40 68 162 241 8 76 185 168 192 189 109 17 104 12 100 42 186 31 15 28 113 72 249 213 10 120 161 189 54 95 145 140 93 52 223 83 153 80 25 250 68 102 71 63 122 51 3 222 201 139 253 189 0 0 0 0 1 128 24 227 82 233 197 174 88 134 19 71 12 155 49 99 207 184 189 139 213 148 142 65 83 22 86 59 113 20 118 242 15 207 165 34 25 223 113 59 30 140 39 47 19 17 91 233 70 193 187 55 81 125 94 114 235 6 80 26 251 206 129 223 96 50 3 188 107 248 74 130 151 7 40 68 162 241 8 76 185 168 192 189 109 17 104 12 100 42 186 31 15 28 113 72 249 213 10 120 161 189 54 95 145 140 93 52 223 83 153 80 25 250 68 102 71 63 122 51 3 222 201 139 253 189 0 0 0 0 0 120 84 215 85 155 83 224 217 17 152 203 112 82 122 193 196 197 212 174 168 135 168 249 185 103 45 35 64 229 91 250 210 186 58 210 182 98 118 15 126 35 18 69 254 92 98 253 202 81 186 80 212 23 15 9 32 39 1 22 16 116 63 86 191 203 58 113 189 250 81 8 87 78 224 55 184 247 69 246 57 99 3 71 4 32 58 206 214 203 112 60 52 83 234 29 3 197 37 251 251 84 166 130 63 190 142 0 143 110 160 134 104 117 192 171 252 58 243 0 0 0 1 120 84 215 85 155 83 224 217 17 152 203 112 82 122 193 196 197 212 174 168 135 168 249 185 103 45 35 64 229 91 250 210 186 58 210 182 98 118 15 126 35 18 69 254 92 98 253 202 81 186 80 212 23 15 9 32 39 1 22 16 116 63 86 191 203 58 113 189 250 81 8 87 78 224 55 184 247 69 246 57 99 3 71 4 32 58 206 214 203 112 60 52 83 234 29 3 197 37 251 251 84 166 130 63 190 142 0 143 110 160 134 104 117 192 171 252 58 243 0 0 0 0 32 75 106 211 223 67 33 39 159 137 42 62 13 132 4 148 172 13 129 231 52 23 5 189 177 132 71 127 112 12 0 0 0 1 32 75 106 211 223 67 33 39 159 137 42 62 13 132 4 148 172 13 129 231 52 23 5 189 177 132 71 127 112 12 0 0 0 0 88 71 66 188 102 218 45 89 79 100 203 161 190 29 126 44 173 44 86 244 243 53 45 157 176 5 233 73 112 206 44 106 109 159 71 109 87 77 104 184 44 147 80 22 206 180 74 221 169 143 209 179 215 195 26 222 89 28 178 48 206 169 22 229 44 34 14 33 215 159 185 161 56 150 95 20 128 199 66 223 66 113 0 0 0 0 0 0 0 1 88 71 66 188 102 218 45 89 79 100 203 161 190 29 126 44 173 44 86 244 243 53 45 157 176 5 233 73 112 206 44 106 109 159 71 109 87 77 104 184 44 147 80 22 206 180 74 221 169 143 209 179 215 195 26 222 89 28 178 48 206 169 22 229 44 34 14 33 215 159 185 161 56 150 95 20 128 199 66 223 66 113 0 0 0 0 0 0 0 0 40 74 104 149 210 252 235 123 239 168 56 124 239 105 91 87 48 183 253 146 69 244 5 94 42 167 100 207 53 34 116 207 197 97 199 198 121 102 204 246 31 1 40 74 104 149 210 252 235 123 239 168 56 124 239 105 91 87 48 183 253 146 69 244 5 94 42 167 100 207 53 34 116 207 197 97 199 198 121 102 204 246 31 0 16 127 135 241 163 116 139 210 196 195 216 24 255 21 0 0 0 1 16 127 135 241 163 116 139 210 196 195 216 24 255 21 0 0 0 0 72 150 29 179 100 132 144 156 216 95 57 162 101 198 179 215 51 244 149 122 162 171 105 83 53 56 158 83 10 80 190 228 125 131 48 41 93 2 177 156 179 17 217 253 155 46 30 105 35 223 134 100 76 170 35 206 233 252 210 117 27 160 154 210 45 234 95 74 76 159 147 2 0 1 72 150 29 179 100 132 144 156 216 95 57 162 101 198 179 215 51 244 149 122 162 171 105 83 53 56 158 83 10 80 190 228 125 131 48 41 93 2 177 156 179 17 217 253 155 46 30 105 35 223 134 100 76 170 35 206 233 252 210 117 27 160 154 210 45 234 95 74 76 159 147 2 0 0 40 220 123 216 188 130 233 64 162 111 163 35 146 32 32 192 228 163 205 248 224 147 90 97 37 29 2 241 105 156 63 40 242 105 209 126 40 0 0 0 0 1 40 220 123 216 188 130 233 64 162 111 163 35 146 32 32 192 228 163 205 248 224 147 90 97 37 29 2 241 105 156 63 40 242 105 209 126 40 0 0 0 0 0 32 230 134 234 52 30 2 41 143 232 97 74 82 171 119 128 41 82 147 155 86 202 151 8 81 3 0 0 0 0 0 0 0 1 32 230 134 234 52 30 2 41 143 232 97 74 82 171 119 128 41 82 147 155 86 202 151 8 81 3 0 0 0 0 0 0 0 0 72 15 249 15 27 178 199 148 79 23 3 197 198 33 75 3 164 156 4 165 168 224 178 69 133 25 107 103 207 249 91 170 31 103 38 157 136 237 182 137 145 28 255 143 214 212 22 229 64 150 206 235 209 33 197 227 224 182 51 28 205 88 80 228 111 77 96 3 34 184 34 1 0 1 72 15 249 15 27 178 199 148 79 23 3 197 198 33 75 3 164 156 4 165 168 224 178 69 133 25 107 103 207 249 91 170 31 103 38 157 136 237 182 137 145 28 255 143 214 212 22 229 64 150 206 235 209 33 197 227 224 182 51 28 205 88 80 228 111 77 96 3 34 184 34 1 0 0 128 218 44 245 9 8 123 94 221 100 47 84 11 243 15 172 179 239 47 175 194 3 71 55 191 38 122 159 236 92 247 18 47 19 56 134 218 188 171 164 240 122 46 184 162 129 134 174 138 64 233 80 170 255 199 102 146 231 63 160 16 196 95 226 19 153 123 117 200 46 233 120 129 83 125 132 105 126 85 36 229 17 65 127 187 245 154 8 240 255 6 80 120 99 170 69 125 132 67 244 85 139 199 7 155 182 253 26 132 174 228 45 164 121 122 120 13 138 138 103 108 205 110 58 205 79 100 212 0 1 128 218 44 245 9 8 123 94 221 100 47 84 11 243 15 172 179 239 47 175 194 3 71 55 191 38 122 159 236 92 247 18 47 19 56 134 218 188 171 164 240 122 46 184 162 129 134 174 138 64 233 80 170 255 199 102 146 231 63 160 16 196 95 226 19 153 123 117 200 46 233 120 129 83 125 132 105 126 85 36 229 17 65 127 187 245 154 8 240 255 6 80 120 99 170 69 125 132 67 244 85 139 199 7 155 182 253 26 132 174 228 45 164 121 122 120 13 138 138 103 108 205 110 58 205 79 100 212 0 0 128 42 11 175 85 234 29 127 39 168 190 213 6 131 53 241 65 78 99 129 50 177 192 60 169 254 225 53 185 10 30 128 144 147 118 226 21 168 226 101 136 76 35 162 12 195 5 204 132 123 33 134 136 228 63 232 165 209 64 49 61 69 88 217 222 49 226 15 38 80 170 183 154 76 90 32 162 103 214 88 163 4 232 2 248 216 110 84 43 233 82 171 178 169 49 99 13 2 111 187 145 184 169 169 143 134 196 5 58 127 58 229 193 147 117 193 58 158 31 111 94 152 222 23 0 0 0 0 0 1 128 42 11 175 85 234 29 127 39 168 190 213 6 131 53 241 65 78 99 129 50 177 192 60 169 254 225 53 185 10 30 128 144 147 118 226 21 168 226 101 136 76 35 162 12 195 5 204 132 123 33 134 136 228 63 232 165 209 64 49 61 69 88 217 222 49 226 15 38 80 170 183 154 76 90 32 162 103 214 88 163 4 232 2 248 216 110 84 43 233 82 171 178 169 49 99 13 2 111 187 145 184 169 169 143 134 196 5 58 127 58 229 193 147 117 193 58 158 31 111 94 152 222 23 0 0 0 0 0 0 128 117 32 231 128 78 121 139 240 228 103 68 36 169 251 164 16 50 57 142 227 5 246 77 80 110 198 12 68 1 149 50 69 54 143 139 95 198 108 21 41 162 236 219 40 173 104 226 58 15 180 5 40 31 118 13 168 210 43 211 239 7 182 203 237 162 68 33 8 250 179 25 22 162 85 109 252 238 129 170 97 47 77 76 109 6 111 254 168 196 19 35 76 81 88 241 48 255 104 111 142 75 147 180 52 99 76 255 134 237 245 122 252 21 255 187 122 115 41 176 130 69 131 13 23 37 127 20 3 1 128 117 32 231 128 78 121 139 240 228 103 68 36 169 251 164 16 50 57 142 227 5 246 77 80 110 198 12 68 1 149 50 69 54 143 139 95 198 108 21 41 162 236 219 40 173 104 226 58 15 180 5 40 31 118 13 168 210 43 211 239 7 182 203 237 162 68 33 8 250 179 25 22 162 85 109 252 238 129 170 97 47 77 76 109 6 111 254 168 196 19 35 76 81 88 241 48 255 104 111 142 75 147 180 52 99 76 255 134 237 245 122 252 21 255 187 122 115 41 176 130 69 131 13 23 37 127 20 3 0 128 225 196 245 38 129 95 130 255 14 194 101 192 198 28 5 135 65 33 59 109 254 232 229 27 245 239 185 134 58 127 181 232 77 234 159 110 69 82 234 174 133 243 107 210 244 202 250 155 41 109 253 34 38 165 23 103 75 242 126 154 90 16 155 40 180 198 123 44 56 133 74 228 20 41 104 110 42 251 181 50 43 108 181 28 98 126 48 202 202 240 10 236 228 75 105 111 132 35 221 75 171 251 197 139 242 114 49 206 195 33 149 113 119 94 226 71 220 139 93 218 202 156 199 9 0 0 0 0 1 128 225 196 245 38 129 95 130 255 14 194 101 192 198 28 5 135 65 33 59 109 254 232 229 27 245 239 185 134 58 127 181 232 77 234 159 110 69 82 234 174 133 243 107 210 244 202 250 155 41 109 253 34 38 165 23 103 75 242 126 154 90 16 155 40 180 198 123 44 56 133 74 228 20 41 104 110 42 251 181 50 43 108 181 28 98 126 48 202 202 240 10 236 228 75 105 111 132 35 221 75 171 251 197 139 242 114 49 206 195 33 149 113 119 94 226 71 220 139 93 218 202 156 199 9 0 0 0 0 0 128 130 190 211 115 201 224 67 206 209 66 76 220 164 193 3 192 104 19 174 139 21 103 49 247 223 227 161 141 190 242 11 120 201 238 152 120 157 159 206 140 138 29 151 173 117 118 102 209 136 234 50 127 131 161 166 19 148 165 245 82 205 11 104 226 229 91 148 136 10 234 81 120 171 169 131 54 235 207 59 211 127 77 24 204 157 197 253 233 237 199 174 3 72 33 142 5 218 73 26 111 135 205 112 166 233 98 13 15 33 27 131 103 119 191 23 179 123 179 24 99 136 111 206 103 0 0 0 0 1 128 130 190 211 115 201 224 67 206 209 66 76 220 164 193 3 192 104 19 174 139 21 103 49 247 223 227 161 141 190 242 11 120 201 238 152 120 157 159 206 140 138 29 151 173 117 118 102 209 136 234 50 127 131 161 166 19 148 165 245 82 205 11 104 226 229 91 148 136 10 234 81 120 171 169 131 54 235 207 59 211 127 77 24 204 157 197 253 233 237 199 174 3 72 33 142 5 218 73 26 111 135 205 112 166 233 98 13 15 33 27 131 103 119 191 23 179 123 179 24 99 136 111 206 103 0 0 0 0 0 24 236 146 150 122 80 138 70 55 218 171 50 71 53 136 214 55 85 125 93 128 4 0 0 0 1 24 236 146 150 122 80 138 70 55 218 171 50 71 53 136 214 55 85 125 93 128 4 0 0 0 0 96 168 120 24 52 192 139 221 73 242 242 97 74 214 206 178 206 134 205 255 80 249 81 103 62 255 235 105 87 255 215 122 234 6 85 194 142 4 80 39 228 210 83 78 57 126 13 175 79 207 117 247 77 43 53 164 8 185 89 108 206 201 3 63 111 26 179 169 0 252 20 51 5 213 56 133 204 63 19 45 245 58 168 12 87 82 182 175 2 1 111 83 252 59 0 0 0 1 96 168 120 24 52 192 139 221 73 242 242 97 74 214 206 178 206 134 205 255 80 249 81 103 62 255 235 105 87 255 215 122 234 6 85 194 142 4 80 39 228 210 83 78 57 126 13 175 79 207 117 247 77 43 53 164 8 185 89 108 206 201 3 63 111 26 179 169 0 252 20 51 5 213 56 133 204 63 19 45 245 58 168 12 87 82 182 175 2 1 111 83 252 59 0 0 0 0 128 185 132 187 44 241 228 100 105 22 119 238 94 124 126 113 117 10 214 51 133 149 172 201 211 213 121 160 34 164 142 116 97 112 84 155 255 6 108 94 78 4 233 188 142 66 190 97 40 135 40 45 103 104 89 35 225 9 229 254 125 210 134 186 83 219 39 156 96 79 116 202 44 226 193 33 197 237 19 205 187 104 142 222 208 110 38 156 236 173 194 237 92 12 94 102 228 230 145 128 127 23 155 108 123 159 28 189 122 77 188 51 141 193 44 74 135 72 161 176 196 25 238 215 249 1 0 0 0 1 128 185 132 187 44 241 228 100 105 22 119 238 94 124 126 113 117 10 214 51 133 149 172 201 211 213 121 160 34 164 142 116 97 112 84 155 255 6 108 94 78 4 233 188 142 66 190 97 40 135 40 45 103 104 89 35 225 9 229 254 125 210 134 186 83 219 39 156 96 79 116 202 44 226 193 33 197 237 19 205 187 104 142 222 208 110 38 156 236 173 194 237 92 12 94 102 228 230 145 128 127 23 155 108 123 159 28 189 122 77 188 51 141 193 44 74 135 72 161 176 196 25 238 215 249 1 0 0 0 0 128 196 189 1 242 155 244 232 152 101 227 3 217 39 244 236 150 9 178 16 175 212 22 120 54 105 227 225 242 229 156 121 86 139 227 54 127 184 190 41 133 3 17 52 18 138 148 221 246 233 48 84 88 59 192 24 21 252 227 123 179 109 113 77 255 247 152 43 152 181 143 190 106 157 133 109 3 97 155 223 142 24 220 123 209 115 48 134 39 181 47 225 199 64 0 47 19 50 112 64 18 160 79 199 188 82 123 15 244 22 146 43 21 149 157 118 9 188 127 178 30 174 37 125 174 1 17 0 0 1 128 196 189 1 242 155 244 232 152 101 227 3 217 39 244 236 150 9 178 16 175 212 22 120 54 105 227 225 242 229 156 121 86 139 227 54 127 184 190 41 133 3 17 52 18 138 148 221 246 233 48 84 88 59 192 24 21 252 227 123 179 109 113 77 255 247 152 43 152 181 143 190 106 157 133 109 3 97 155 223 142 24 220 123 209 115 48 134 39 181 47 225 199 64 0 47 19 50 112 64 18 160 79 199 188 82 123 15 244 22 146 43 21 149 157 118 9 188 127 178 30 174 37 125 174 1 17 0 0 0 128 125 72 103 215 83 251 97 191 63 231 211 75 247 3 48 39 242 99 75 38 207 10 64 114 118 90 122 122 77 183 190 7 147 103 181 244 49 65 243 162 67 68 8 208 134 116 48 95 95 233 35 252 112 16 102 203 11 124 40 193 161 239 28 210 11 139 204 89 203 38 245 182 150 96 26 18 46 113 77 175 20 177 91 174 135 42 135 219 19 174 215 57 19 213 152 24 76 23 175 160 29 5 177 176 24 219 163 255 97 214 199 54 191 77 15 45 73 191 156 156 85 231 7 0 0 0 0 0 1 128 125 72 103 215 83 251 97 191 63 231 211 75 247 3 48 39 242 99 75 38 207 10 64 114 118 90 122 122 77 183 190 7 147 103 181 244 49 65 243 162 67 68 8 208 134 116 48 95 95 233 35 252 112 16 102 203 11 124 40 193 161 239 28 210 11 139 204 89 203 38 245 182 150 96 26 18 46 113 77 175 20 177 91 174 135 42 135 219 19 174 215 57 19 213 152 24 76 23 175 160 29 5 177 176 24 219 163 255 97 214 199 54 191 77 15 45 73 191 156 156 85 231 7 0 0 0 0 0 0 16 252 17 170 79 122 224 151 223 165 53 141 155 37 87 4 0 1 16 252 17 170 79 122 224 151 223 165 53 141 155 37 87 4 0 0 64 137 35 96 204 136 177 189 143 1 212 169 28 91 106 152 238 147 179 84 155 35 195 77 99 22 143 175 243 178 108 188 125 52 89 146 208 125 21 94 228 98 194 201 165 96 57 144 208 56 103 133 48 45 120 4 182 247 48 112 89 188 153 1 0 1 64 137 35 96 204 136 177 189 143 1 212 169 28 91 106 152 238 147 179 84 155 35 195 77 99 22 143 175 243 178 108 188 125 52 89 146 208 125 21 94 228 98 194 201 165 96 57 144 208 56 103 133 48 45 120 4 182 247 48 112 89 188 153 1 0 0 104 243 59 23 181 19 206 54 217 4 43 183 169 25 245 43 129 181 198 110 56 213 123 240 160 71 185 170 96 174 21 188 158 209 73 67 245 248 18 139 233 181 53 185 30 209 172 198 74 139 145 21 133 168 4 186 236 48 15 19 25 234 227 177 154 240 64 215 74 77 178 193 160 155 223 234 55 201 144 185 140 71 87 18 218 192 168 98 86 67 205 126 50 211 88 59 69 53 208 210 119 1 82 1 0 1 104 243 59 23 181 19 206 54 217 4 43 183 169 25 245 43 129 181 198 110 56 213 123 240 160 71 185 170 96 174 21 188 158 209 73 67 245 248 18 139 233 181 53 185 30 209 172 198 74 139 145 21 133 168 4 186 236 48 15 19 25 234 227 177 154 240 64 215 74 77 178 193 160 155 223 234 55 201 144 185 140 71 87 18 218 192 168 98 86 67 205 126 50 211 88 59 69 53 208 210 119 1 82 1 0 0 104 30 237 199 208 43 126 134 188 221 77 44 64 109 31 47 206 70 172 101 140 66 232 0 138 101 218 81 243 45 157 119 221 30 64 253 209 50 12 45 150 152 200 9 167 220 210 114 70 151 149 141 34 162 151 188 82 189 246 149 204 99 143 240 240 11 119 55 107 27 196 176 61 52 227 44 160 102 215 226 28 36 252 136 5 162 100 95 194 183 2 28 199 117 193 177 41 170 115 62 93 181 186 1 0 1 104 30 237 199 208 43 126 134 188 221 77 44 64 109 31 47 206 70 172 101 140 66 232 0 138 101 218 81 243 45 157 119 221 30 64 253 209 50 12 45 150 152 200 9 167 220 210 114 70 151 149 141 34 162 151 188 82 189 246 149 204 99 143 240 240 11 119 55 107 27 196 176 61 52 227 44 160 102 215 226 28 36 252 136 5 162 100 95 194 183 2 28 199 117 193 177 41 170 115 62 93 181 186 1 0 0 40 53 120 130 161 159 72 98 85 190 182 236 225 240 60 214 46 141 103 182 195 63 222 96 51 133 198 58 90 110 132 208 137 203 153 172 98 79 220 0 0 1 40 53 120 130 161 159 72 98 85 190 182 236 225 240 60 214 46 141 103 182 195 63 222 96 51 133 198 58 90 110 132 208 137 203 153 172 98 79 220 0 0 0 24 118 29 12 161 58 173 221 244 97 16 129 132 213 223 100 52 220 195 7 0 0 0 0 0 1 24 118 29 12 161 58 173 221 244 97 16 129 132 213 223 100 52 220 195 7 0 0 0 0 0 0 8 48 0 0 0 0 0 0 0 1 8 48 0 0 0 0 0 0 0 0 56 231 92 254 163 124 164 150 140 111 46 208 48 245 131 79 191 167 93 72 251 225 197 183 198 127 122 236 47 16 214 74 14 201 193 171 20 118 155 238 33 155 90 192 58 99 154 59 127 53 8 120 227 43 170 1 0 1 56 231 92 254 163 124 164 150 140 111 46 208 48 245 131 79 191 167 93 72 251 225 197 183 198 127 122 236 47 16 214 74 14 201 193 171 20 118 155 238 33 155 90 192 58 99 154 59 127 53 8 120 227 43 170 1 0 0 16 251 177 154 124 124 51 12 184 170 246 21 206 136 0 6 0 1 16 251 177 154 124 124 51 12 184 170 246 21 206 136 0 6 0 0 120 135 228 154 97 97 37 218 64 185 90 19 175 246 80 210 161 113 157 100 67 139 11 67 170 100 55 10 137 62 200 98 216 164 1 43 71 31 156 64 144 57 219 81 105 211 65 2 203 127 45 87 116 177 120 38 220 221 127 219 9 89 68 112 249 96 102 183 83 157 239 104 243 95 199 142 2 33 66 225 186 67 111 177 72 133 48 17 239 26 98 202 8 125 61 65 118 6 55 147 154 167 90 0 162 128 74 17 187 146 174 37 228 190 12 117 100 32 3 0 0 1 120 135 228 154 97 97 37 218 64 185 90 19 175 246 80 210 161 113 157 100 67 139 11 67 170 100 55 10 137 62 200 98 216 164 1 43 71 31 156 64 144 57 219 81 105 211 65 2 203 127 45 87 116 177 120 38 220 221 127 219 9 89 68 112 249 96 102 183 83 157 239 104 243 95 199 142 2 33 66 225 186 67 111 177 72 133 48 17 239 26 98 202 8 125 61 65 118 6 55 147 154 167 90 0 162 128 74 17 187 146 174 37 228 190 12 117 100 32 3 0 0 0 88 26 161 163 242 118 221 0 66 192 252 133 199 57 227 98 231 11 157 63 23 214 37 26 128 100 49 131 94 235 250 249 147 154 51 50 25 98 235 243 5 108 187 118 252 12 79 151 103 7 110 124 8 167 181 214 104 91 65 119 78 66 98 82 217 239 238 114 229 245 1 243 155 98 149 133 248 106 172 101 16 223 244 0 0 0 0 0 0 1 88 26 161 163 242 118 221 0 66 192 252 133 199 57 227 98 231 11 157 63 23 214 37 26 128 100 49 131 94 235 250 249 147 154 51 50 25 98 235 243 5 108 187 118 252 12 79 151 103 7 110 124 8 167 181 214 104 91 65 119 78 66 98 82 217 239 238 114 229 245 1 243 155 98 149 133 248 106 172 101 16 223 244 0 0 0 0 0 0 0 104 51 242 193 71 40 33 244 183 39 87 209 231 123 23 102 244 164 169 195 247 118 193 238 212 202 61 62 28 173 71 226 3 123 32 247 24 21 127 54 196 17 12 180 107 10 66 175 208 88 113 145 18 93 77 231 82 5 172 142 122 173 202 80 213 151 67 189 246 154 57 40 60 62 225 173 49 197 99 197 109 106 160 126 116 179 205 235 122 139 21 129 249 231 216 211 119 4 117 66 52 193 10 0 0 1 104 51 242 193 71 40 33 244 183 39 87 209 231 123 23 102 244 164 169 195 247 118 193 238 212 202 61 62 28 173 71 226 3 123 32 247 24 21 127 54 196 17 12 180 107 10 66 175 208 88 113 145 18 93 77 231 82 5 172 142 122 173 202 80 213 151 67 189 246 154 57 40 60 62 225 173 49 197 99 197 109 106 160 126 116 179 205 235 122 139 21 129 249 231 216 211 119 4 117 66 52 193 10 0 0 0 120 117 133 12 7 22 147 126 60 222 126 15 234 208 110 144 185 13 98 7 11 209 57 121 79 194 58 253 148 206 85 251 165 5 213 112 244 92 244 25 196 40 68 91 10 147 74 13 72 165 3 119 45 32 170 129 46 133 146 166 13 69 50 36 228 124 251 190 233 4 155 225 95 178 231 135 226 223 143 88 24 162 178 240 101 140 125 124 184 151 110 254 193 242 30 230 88 55 219 178 42 54 111 9 248 91 46 181 248 183 164 152 211 7 0 0 0 0 0 0 0 1 120 117 133 12 7 22 147 126 60 222 126 15 234 208 110 144 185 13 98 7 11 209 57 121 79 194 58 253 148 206 85 251 165 5 213 112 244 92 244 25 196 40 68 91 10 147 74 13 72 165 3 119 45 32 170 129 46 133 146 166 13 69 50 36 228 124 251 190 233 4 155 225 95 178 231 135 226 223 143 88 24 162 178 240 101 140 125 124 184 151 110 254 193 242 30 230 88 55 219 178 42 54 111 9 248 91 46 181 248 183 164 152 211 7 0 0 0 0 0 0 0 0 128 63 77 192 16 39 116 41 118 84 43 197 253 236 106 62 1 183 234 241 28 170 49 21 191 231 212 161 33 61 235 39 160 228 125 57 52 78 189 69 47 1 79 177 75 103 238 153 2 38 182 148 88 116 210 38 64 96 188 136 248 75 74 182 169 213 110 205 104 170 28 203 171 146 250 72 188 184 135 129 123 246 18 94 241 239 179 131 133 192 152 204 226 228 3 166 119 222 138 54 116 129 186 64 160 210 30 139 163 195 186 2 85 155 194 170 83 132 36 74 216 27 254 85 0 0 0 0 0 1 128 63 77 192 16 39 116 41 118 84 43 197 253 236 106 62 1 183 234 241 28 170 49 21 191 231 212 161 33 61 235 39 160 228 125 57 52 78 189 69 47 1 79 177 75 103 238 153 2 38 182 148 88 116 210 38 64 96 188 136 248 75 74 182 169 213 110 205 104 170 28 203 171 146 250 72 188 184 135 129 123 246 18 94 241 239 179 131 133 192 152 204 226 228 3 166 119 222 138 54 116 129 186 64 160 210 30 139 163 195 186 2 85 155 194 170 83 132 36 74 216 27 254 85 0 0 0 0 0 0 72 216 172 85 194 158 216 82 110 65 133 85 128 49 103 72 173 54 61 199 26 210 206 103 163 37 220 221 193 233 238 254 54 206 213 124 6 203 165 26 21 241 141 165 246 128 184 43 72 242 66 159 97 79 134 33 147 97 136 247 186 217 103 81 199 29 0 0 0 0 0 0 0 1 72 216 172 85 194 158 216 82 110 65 133 85 128 49 103 72 173 54 61 199 26 210 206 103 163 37 220 221 193 233 238 254 54 206 213 124 6 203 165 26 21 241 141 165 246 128 184 43 72 242 66 159 97 79 134 33 147 97 136 247 186 217 103 81 199 29 0 0 0 0 0 0 0 0 88 198 204 237 247 146 195 97 49 165 23 187 22 34 150 126 136 183 220 165 82 194 13 172 190 161 249 20 192 177 147 243 49 113 56 111 194 238 6 98 97 129 35 110 42 246 44 179 219 221 190 182 94 40 254 25 246 171 109 11 181 1 138 90 3 209 233 133 179 57 67 179 0 223 103 18 74 138 136 231 35 199 161 29 157 1 0 0 0 1 88 198 204 237 247 146 195 97 49 165 23 187 22 34 150 126 136 183 220 165 82 194 13 172 190 161 249 20 192 177 147 243 49 113 56 111 194 238 6 98 97 129 35 110 42 246 44 179 219 221 190 182 94 40 254 25 246 171 109 11 181 1 138 90 3 209 233 133 179 57 67 179 0 223 103 18 74 138 136 231 35 199 161 29 157 1 0 0 0 0 104 200 111 223 113 76 183 17 189 185 203 122 115 218 100 205 191 105 223 132 140 147 126 199 180 195 206 12 73 110 39 71 147 85 229 115 193 236 45 39 98 81 104 24 231 243 122 80 84 171 200 163 28 188 108 159 81 0 102 179 40 112 195 41 169 248 78 181 155 111 130 188 233 129 78 9 71 59 223 40 71 154 214 88 94 144 232 156 144 221 110 76 114 52 34 145 84 178 218 142 15 103 173 3 0 1 104 200 111 223 113 76 183 17 189 185 203 122 115 218 100 205 191 105 223 132 140 147 126 199 180 195 206 12 73 110 39 71 147 85 229 115 193 236 45 39 98 81 104 24 231 243 122 80 84 171 200 163 28 188 108 159 81 0 102 179 40 112 195 41 169 248 78 181 155 111 130 188 233 129 78 9 71 59 223 40 71 154 214 88 94 144 232 156 144 221 110 76 114 52 34 145 84 178 218 142 15 103 173 3 0 0 8 177 137 11 132 66 0 0 0 1 8 177 137 11 132 66 0 0 0 0 48 33 167 44 60 43 5 212 10 233 199 142 141 206 188 38 153 75 245 28 138 78 90 196 228 196 226 63 171 99 123 61 129 93 169 246 14 54 98 199 66 102 119 74 122 163 104 13 0 1 48 33 167 44 60 43 5 212 10 233 199 142 141 206 188 38 153 75 245 28 138 78 90 196 228 196 226 63 171 99 123 61 129 93 169 246 14 54 98 199 66 102 119 74 122 163 104 13 0 0 112 13 142 178 152 223 193 158 172 255 203 197 100 76 79 42 99 97 196 198 42 60 211 249 142 174 154 123 158 254 134 251 235 151 207 55 209 178 137 7 234 137 81 211 255 191 135 78 179 11 30 121 13 152 88 34 61 56 32 249 153 111 6 135 83 62 197 83 191 163 251 20 161 116 248 36 161 123 44 251 45 216 82 212 120 237 125 134 142 89 7 182 228 191 54 121 104 50 110 8 142 248 42 214 76 253 13 190 143 50 0 0 0 1 112 13 142 178 152 223 193 158 172 255 203 197 100 76 79 42 99 97 196 198 42 60 211 249 142 174 154 123 158 254 134 251 235 151 207 55 209 178 137 7 234 137 81 211 255 191 135 78 179 11 30 121 13 152 88 34 61 56 32 249 153 111 6 135 83 62 197 83 191 163 251 20 161 116 248 36 161 123 44 251 45 216 82 212 120 237 125 134 142 89 7 182 228 191 54 121 104 50 110 8 142 248 42 214 76 253 13 190 143 50 0 0 0 0 32 135 115 67 224 57 26 67 50 161 116 97 239 175 143 9 168 232 95 142 29 48 16 121 194 48 241 158 6 0 0 0 0 1 32 135 115 67 224 57 26 67 50 161 116 97 239 175 143 9 168 232 95 142 29 48 16 121 194 48 241 158 6 0 0 0 0 0 120 179 69 194 42 93 120 64 237 75 176 251 199 63 49 12 217 68 117 60 17 14 70 160 57 29 60 226 156 164 120 98 6 241 147 20 139 159 7 106 210 46 18 44 209 147 45 254 121 230 97 80 19 35 222 34 109 179 236 84 205 123 213 217 33 100 118 217 223 98 205 210 213 162 16 151 66 225 173 235 73 110 112 76 172 232 124 30 64 29 119 3 178 184 119 33 176 53 248 40 157 126 127 125 242 209 202 221 233 124 59 53 81 231 151 52 49 122 224 122 27 1 120 179 69 194 42 93 120 64 237 75 176 251 199 63 49 12 217 68 117 60 17 14 70 160 57 29 60 226 156 164 120 98 6 241 147 20 139 159 7 106 210 46 18 44 209 147 45 254 121 230 97 80 19 35 222 34 109 179 236 84 205 123 213 217 33 100 118 217 223 98 205 210 213 162 16 151 66 225 173 235 73 110 112 76 172 232 124 30 64 29 119 3 178 184 119 33 176 53 248 40 157 126 127 125 242 209 202 221 233 124 59 53 81 231 151 52 49 122 224 122 27 0 88 202 249 247 72 190 100 43 14 53 119 130 14 137 197 240 200 81 190 103 225 158 134 179 33 43 177 147 126 191 141 162 245 224 193 132 144 147 134 16 189 234 157 212 246 176 172 112 191 110 66 141 195 94 234 133 171 20 190 248 55 25 132 147 148 135 183 201 74 89 229 183 214 200 16 91 233 10 37 163 27 133 153 134 93 213 152 142 7 1 88 202 249 247 72 190 100 43 14 53 119 130 14 137 197 240 200 81 190 103 225 158 134 179 33 43 177 147 126 191 141 162 245 224 193 132 144 147 134 16 189 234 157 212 246 176 172 112 191 110 66 141 195 94 234 133 171 20 190 248 55 25 132 147 148 135 183 201 74 89 229 183 214 200 16 91 233 10 37 163 27 133 153 134 93 213 152 142 7 0 88 77 103 16 15 148 98 115 149 166 118 218 10 199 232 124 175 175 165 211 217 182 127 122 39 230 51 107 111 80 51 18 145 177 162 46 2 119 80 163 33 253 187 253 121 34 222 134 85 8 230 102 107 120 117 240 151 81 89 38 47 90 107 129 149 16 144 78 38 26 58 78 61 163 182 119 241 129 192 139 249 183 46 39 109 17 15 240 0 1 88 77 103 16 15 148 98 115 149 166 118 218 10 199 232 124 175 175 165 211 217 182 127 122 39 230 51 107 111 80 51 18 145 177 162 46 2 119 80 163 33 253 187 253 121 34 222 134 85 8 230 102 107 120 117 240 151 81 89 38 47 90 107 129 149 16 144 78 38 26 58 78 61 163 182 119 241 129 192 139 249 183 46 39 109 17 15 240 0 0 56 234 213 76 110 121 53 109 162 71 58 96 120 32 67 142 4 161 13 37 85 104 226 206 115 224 160 35 117 179 108 202 225 198 59 157 91 182 20 254 20 5 196 54 221 64 27 198 127 155 96 99 2 0 0 0 0 1 56 234 213 76 110 121 53 109 162 71 58 96 120 32 67 142 4 161 13 37 85 104 226 206 115 224 160 35 117 179 108 202 225 198 59 157 91 182 20 254 20 5 196 54 221 64 27 198 127 155 96 99 2 0 0 0 0 0 104 130 27 80 132 149 206 104 74 186 108 76 162 61 90 101 136 56 238 26 128 103 13 215 175 217 2 94 203 185 103 235 57 73 179 67 251 148 153 157 188 175 176 9 190 11 144 240 204 176 77 140 59 173 23 41 195 49 211 129 99 226 89 41 61 117 216 244 229 187 66 250 141 7 162 242 64 30 74 137 170 157 234 46 180 106 67 91 184 254 133 132 150 83 202 121 109 229 1 0 0 0 0 0 0 1 104 130 27 80 132 149 206 104 74 186 108 76 162 61 90 101 136 56 238 26 128 103 13 215 175 217 2 94 203 185 103 235 57 73 179 67 251 148 153 157 188 175 176 9 190 11 144 240 204 176 77 140 59 173 23 41 195 49 211 129 99 226 89 41 61 117 216 244 229 187 66 250 141 7 162 242 64 30 74 137 170 157 234 46 180 106 67 91 184 254 133 132 150 83 202 121 109 229 1 0 0 0 0 0 0 0 96 180 177 20 52 197 85 168 138 255 101 101 71 208 219 45 169 123 61 167 239 15 8 52 226 172 233 153 47 28 118 122 247 246 33 225 192 78 230 61 188 196 197 48 3 32 37 12 172 242 129 25 220 16 26 252 131 142 114 105 69 201 34 95 85 12 39 146 145 217 235 38 66 245 145 202 77 22 159 59 0 129 139 201 197 42 198 93 48 54 136 29 220 157 47 43 0 1 96 180 177 20 52 197 85 168 138 255 101 101 71 208 219 45 169 123 61 167 239 15 8 52 226 172 233 153 47 28 118 122 247 246 33 225 192 78 230 61 188 196 197 48 3 32 37 12 172 242 129 25 220 16 26 252 131 142 114 105 69 201 34 95 85 12 39 146 145 217 235 38 66 245 145 202 77 22 159 59 0 129 139 201 197 42 198 93 48 54 136 29 220 157 47 43 0 0 96 228 177 197 157 201 233 218 33 173 105 143 149 114 247 135 47 252 136 226 112 224 250 62 15 148 29 202 26 68 127 193 62 109 233 165 67 21 221 99 246 160 113 232 255 240 215 55 219 168 67 172 220 239 70 18 44 75 90 190 126 188 2 138 148 81 54 76 45 139 27 198 140 152 73 84 62 77 207 250 184 202 70 93 74 35 192 212 68 254 66 167 55 43 72 51 1 1 96 228 177 197 157 201 233 218 33 173 105 143 149 114 247 135 47 252 136 226 112 224 250 62 15 148 29 202 26 68 127 193 62 109 233 165 67 21 221 99 246 160 113 232 255 240 215 55 219 168 67 172 220 239 70 18 44 75 90 190 126 188 2 138 148 81 54 76 45 139 27 198 140 152 73 84 62 77 207 250 184 202 70 93 74 35 192 212 68 254 66 167 55 43 72 51 1 0 64 214 194 164 243 67 99 159 221 32 79 138 118 10 246 26 53 220 63 121 128 209 86 55 147 46 21 147 111 73 114 48 231 199 129 181 226 153 2 49 119 72 168 113 113 77 187 140 153 22 15 24 250 59 186 131 64 170 188 226 4 136 0 0 0 1 64 214 194 164 243 67 99 159 221 32 79 138 118 10 246 26 53 220 63 121 128 209 86 55 147 46 21 147 111 73 114 48 231 199 129 181 226 153 2 49 119 72 168 113 113 77 187 140 153 22 15 24 250 59 186 131 64 170 188 226 4 136 0 0 0 0 56 137 1 85 110 191 240 53 229 183 92 119 252 131 102 74 251 188 32 178 3 182 241 244 250 87 89 25 222 123 231 114 153 55 41 42 92 80 171 133 162 143 161 81 69 72 198 206 202 152 186 2 0 0 0 0 0 1 56 137 1 85 110 191 240 53 229 183 92 119 252 131 102 74 251 188 32 178 3 182 241 244 250 87 89 25 222 123 231 114 153 55 41 42 92 80 171 133 162 143 161 81 69 72 198 206 202 152 186 2 0 0 0 0 0 0 56 211 76 143 162 185 129 219 122 124 64 67 106 130 145 59 54 198 182 118 11 1 159 173 227 145 183 65 74 210 107 97 244 37 234 225 245 194 126 48 168 194 239 99 117 113 246 7 68 90 122 30 120 121 204 1 0 1 56 211 76 143 162 185 129 219 122 124 64 67 106 130 145 59 54 198 182 118 11 1 159 173 227 145 183 65 74 210 107 97 244 37 234 225 245 194 126 48 168 194 239 99 117 113 246 7 68 90 122 30 120 121 204 1 0 0 88 105 73 115 54 214 7 115 255 61 66 95 124 249 26 243 37 155 74 9 85 217 163 49 217 173 61 95 67 196 72 63 156 172 27 80 167 165 134 208 52 201 202 92 55 128 155 17 60 176 105 63 30 206 211 19 235 211 182 152 83 135 179 180 37 195 226 138 134 144 171 149 80 65 145 226 242 243 230 43 132 178 250 39 215 0 0 0 0 1 88 105 73 115 54 214 7 115 255 61 66 95 124 249 26 243 37 155 74 9 85 217 163 49 217 173 61 95 67 196 72 63 156 172 27 80 167 165 134 208 52 201 202 92 55 128 155 17 60 176 105 63 30 206 211 19 235 211 182 152 83 135 179 180 37 195 226 138 134 144 171 149 80 65 145 226 242 243 230 43 132 178 250 39 215 0 0 0 0 0 24 238 147 112 201 202 57 233 73 216 169 141 254 73 1 28 115 92 180 201 139 174 21 11 0 1 24 238 147 112 201 202 57 233 73 216 169 141 254 73 1 28 115 92 180 201 139 174 21 11 0 0 24 11 98 186 29 212 176 86 13 53 40 93 147 195 178 153 54 152 222 244 40 193 19 0 0 1 24 11 98 186 29 212 176 86 13 53 40 93 147 195 178 153 54 152 222 244 40 193 19 0 0 0 40 247 180 251 141 141 62 11 228 178 124 25 179 207 78 30 191 6 166 89 240 173 89 181 244 213 201 90 164 248 113 18 220 53 196 159 235 161 36 114 0 1 40 247 180 251 141 141 62 11 228 178 124 25 179 207 78 30 191 6 166 89 240 173 89 181 244 213 201 90 164 248 113 18 220 53 196 159 235 161 36 114 0 0 96 197 219 246 150 141 204 249 197 122 42 147 254 26 80 88 29 210 60 108 233 49 53 58 229 228 74 204 32 164 150 72 227 75 126 222 254 223 216 61 51 43 121 144 51 162 181 207 169 112 177 75 201 49 79 92 41 7 31 62 225 233 82 103 28 12 148 8 127 39 116 68 202 216 227 213 140 255 16 22 227 223 27 82 6 151 211 143 89 62 252 11 0 0 0 0 0 1 96 197 219 246 150 141 204 249 197 122 42 147 254 26 80 88 29 210 60 108 233 49 53 58 229 228 74 204 32 164 150 72 227 75 126 222 254 223 216 61 51 43 121 144 51 162 181 207 169 112 177 75 201 49 79 92 41 7 31 62 225 233 82 103 28 12 148 8 127 39 116 68 202 216 227 213 140 255 16 22 227 223 27 82 6 151 211 143 89 62 252 11 0 0 0 0 0 0 104 84 85 201 229 80 220 110 27 89 135 96 8 25 169 247 170 52 98 214 179 116 102 103 90 190 212 155 200 5 237 5 33 189 15 223 142 50 1 136 100 122 203 43 219 41 31 201 158 108 205 137 41 171 131 15 69 19 41 170 64 244 118 157 0 134 78 207 249 103 223 37 193 0 163 144 187 16 102 223 27 90 215 43 229 11 42 66 58 117 150 42 248 101 141 189 6 240 7 0 242 197 127 1 0 1 104 84 85 201 229 80 220 110 27 89 135 96 8 25 169 247 170 52 98 214 179 116 102 103 90 190 212 155 200 5 237 5 33 189 15 223 142 50 1 136 100 122 203 43 219 41 31 201 158 108 205 137 41 171 131 15 69 19 41 170 64 244 118 157 0 134 78 207 249 103 223 37 193 0 163 144 187 16 102 223 27 90 215 43 229 11 42 66 58 117 150 42 248 101 141 189 6 240 7 0 242 197 127 1 0 0 8 185 243 251 131 7 0 0 0 1 8 185 243 251 131 7 0 0 0 0 48 188 64 12 102 153 116 180 169 232 182 207 120 2 241 87 106 199 3 100 211 214 177 149 40 69 55 14 15 24 136 141 41 198 26 255 238 213 146 192 182 42 0 0 0 0 0 0 0 1 48 188 64 12 102 153 116 180 169 232 182 207 120 2 241 87 106 199 3 100 211 214 177 149 40 69 55 14 15 24 136 141 41 198 26 255 238 213 146 192 182 42 0 0 0 0 0 0 0 0 40 60 69 243 184 98 7 253 248 147 154 234 108 139 170 83 33 71 50 181 137 96 0 97 65 238 127 238 220 145 220 30 197 164 169 50 39 0 0 0 0 1 40 60 69 243 184 98 7 253 248 147 154 234 108 139 170 83 33 71 50 181 137 96 0 97 65 238 127 238 220 145 220 30 197 164 169 50 39 0 0 0 0 0 112 226 167 90 98 229 230 91 40 155 26 167 140 217 74 204 150 223 188 123 34 82 92 87 7 182 125 184 131 72 19 168 23 168 126 18 67 33 218 228 80 219 32 115 52 91 153 74 185 188 251 88 141 206 245 147 186 188 9 11 227 190 147 53 27 159 175 207 126 95 65 244 167 190 77 129 82 251 142 246 254 93 98 112 160 141 225 214 75 62 208 202 45 97 98 146 177 111 133 60 28 249 233 207 10 171 89 174 70 14 94 129 40 1 112 226 167 90 98 229 230 91 40 155 26 167 140 217 74 204 150 223 188 123 34 82 92 87 7 182 125 184 131 72 19 168 23 168 126 18 67 33 218 228 80 219 32 115 52 91 153 74 185 188 251 88 141 206 245 147 186 188 9 11 227 190 147 53 27 159 175 207 126 95 65 244 167 190 77 129 82 251 142 246 254 93 98 112 160 141 225 214 75 62 208 202 45 97 98 146 177 111 133 60 28 249 233 207 10 171 89 174 70 14 94 129 40 0 8 109 138 127 241 182 108 3 0 1 8 109 138 127 241 182 108 3 0 0 24 253 248 186 235 248 125 194 176 203 231 91 182 41 233 0 226 122 118 84 2 0 0 0 0 1 24 253 248 186 235 248 125 194 176 203 231 91 182 41 233 0 226 122 118 84 2 0 0 0 0 0 16 230 16 7 220 125 232 51 204 126 74 73 232 59 0 0 0 1 16 230 16 7 220 125 232 51 204 126 74 73 232 59 0 0 0 0 128 96 188 53 88 57 212 250 97 99 241 119 39 211 59 47 120 144 156 173 166 143 114 227 10 41 16 55 214 158 53 92 82 10 117 44 252 226 154 161 113 202 150 106 200 19 38 79 40 100 2 216 168 103 49 218 150 159 173 218 238 0 59 105 125 25 202 77 232 122 113 96 184 174 146 91 150 158 119 220 235 41 130 173 153 183 164 219 127 2 22 89 184 116 175 152 236 46 180 242 142 205 40 40 121 115 78 145 79 246 133 130 224 161 140 56 114 143 192 138 82 110 74 44 22 99 135 217 2 1 128 96 188 53 88 57 212 250 97 99 241 119 39 211 59 47 120 144 156 173 166 143 114 227 10 41 16 55 214 158 53 92 82 10 117 44 252 226 154 161 113 202 150 106 200 19 38 79 40 100 2 216 168 103 49 218 150 159 173 218 238 0 59 105 125 25 202 77 232 122 113 96 184 174 146 91 150 158 119 220 235 41 130 173 153 183 164 219 127 2 22 89 184 116 175 152 236 46 180 242 142 205 40 40 121 115 78 145 79 246 133 130 224 161 140 56 114 143 192 138 82 110 74 44 22 99 135 217 2 0 112 183 215 158 47 73 44 220 50 163 229 15 148 225 154 78 50 189 136 15 137 135 196 30 145 70 78 206 57 19 181 129 163 193 193 234 155 1 250 142 170 197 218 122 99 180 214 31 196 167 42 38 254 90 90 60 16 232 180 119 19 88 155 128 27 128 25 230 39 205 154 156 158 153 88 120 44 1 136 211 209 30 179 28 159 46 164 62 97 233 105 33 20 253 209 183 59 98 45 110 88 170 73 103 237 172 14 0 0 0 0 0 0 1 112 183 215 158 47 73 44 220 50 163 229 15 148 225 154 78 50 189 136 15 137 135 196 30 145 70 78 206 57 19 181 129 163 193 193 234 155 1 250 142 170 197 218 122 99 180 214 31 196 167 42 38 254 90 90 60 16 232 180 119 19 88 155 128 27 128 25 230 39 205 154 156 158 153 88 120 44 1 136 211 209 30 179 28 159 46 164 62 97 233 105 33 20 253 209 183 59 98 45 110 88 170 73 103 237 172 14 0 0 0 0 0 0 0 112 109 39 198 116 134 109 137 3 154 63 133 155 109 82 108 240 13 83 246 109 126 71 168 5 252 39 139 51 83 180 93 45 15 158 50 208 87 19 218 21 230 235 83 238 84 254 144 65 87 7 55 39 65 75 33 1 137 221 191 101 104 101 15 201 217 163 216 64 237 92 24 199 180 178 166 245 190 146 159 89 122 28 142 102 176 245 112 28 239 140 93 48 144 224 181 154 244 92 174 112 189 17 186 11 61 0 0 0 0 0 0 0 1 112 109 39 198 116 134 109 137 3 154 63 133 155 109 82 108 240 13 83 246 109 126 71 168 5 252 39 139 51 83 180 93 45 15 158 50 208 87 19 218 21 230 235 83 238 84 254 144 65 87 7 55 39 65 75 33 1 137 221 191 101 104 101 15 201 217 163 216 64 237 92 24 199 180 178 166 245 190 146 159 89 122 28 142 102 176 245 112 28 239 140 93 48 144 224 181 154 244 92 174 112 189 17 186 11 61 0 0 0 0 0 0 0 0 96 115 25 74 181 122 105 117 16 23 160 104 186 173 148 142 130 124 69 176 164 120 37 35 164 26 5 203 211 81 114 102 172 157 224 92 119 72 40 156 152 170 218 239 244 122 119 68 255 223 165 182 239 221 222 170 86 17 177 252 123 251 137 160 2 17 88 15 181 45 222 85 1 145 242 26 221 26 143 50 5 231 126 165 15 88 139 246 42 136 0 0 0 0 0 0 0 1 96 115 25 74 181 122 105 117 16 23 160 104 186 173 148 142 130 124 69 176 164 120 37 35 164 26 5 203 211 81 114 102 172 157 224 92 119 72 40 156 152 170 218 239 244 122 119 68 255 223 165 182 239 221 222 170 86 17 177 252 123 251 137 160 2 17 88 15 181 45 222 85 1 145 242 26 221 26 143 50 5 231 126 165 15 88 139 246 42 136 0 0 0 0 0 0 0 0 24 11 96 10 112 174 90 0 74 17 97 66 74 95 235 134 176 1 0 0 0 0 0 0 0 1 24 11 96 10 112 174 90 0 74 17 97 66 74 95 235 134 176 1 0 0 0 0 0 0 0 0 48 154 185 66 152 86 30 237 20 211 200 92 232 231 159 111 104 239 215 186 246 153 131 145 191 158 17 100 149 87 115 114 80 153 175 127 213 20 30 55 123 56 0 0 0 0 0 0 0 1 48 154 185 66 152 86 30 237 20 211 200 92 232 231 159 111 104 239 215 186 246 153 131 145 191 158 17 100 149 87 115 114 80 153 175 127 213 20 30 55 123 56 0 0 0 0 0 0 0 0 104 200 46 197 117 247 255 182 227 22 29 184 198 24 211 143 87 190 175 196 153 250 144 95 50 47 199 87 38 91 196 72 184 66 112 224 205 213 241 213 215 217 50 114 236 249 135 67 151 218 231 131 138 171 95 70 223 55 110 156 24 86 4 116 64 213 4 169 211 115 62 175 39 13 169 242 237 56 166 5 99 183 238 116 46 114 188 183 203 8 57 40 83 132 247 182 225 184 108 0 0 0 0 0 0 1 104 200 46 197 117 247 255 182 227 22 29 184 198 24 211 143 87 190 175 196 153 250 144 95 50 47 199 87 38 91 196 72 184 66 112 224 205 213 241 213 215 217 50 114 236 249 135 67 151 218 231 131 138 171 95 70 223 55 110 156 24 86 4 116 64 213 4 169 211 115 62 175 39 13 169 242 237 56 166 5 99 183 238 116 46 114 188 183 203 8 57 40 83 132 247 182 225 184 108 0 0 0 0 0 0 0 128 94 235 124 73 23 127 111 55 10 111 84 126 170 16 77 106 181 163 73 165 249 170 40 170 90 228 108 176 252 39 45 191 204 225 251 145 26 45 5 233 1 112 57 57 75 136 241 126 114 242 43 156 144 93 196 214 225 123 243 163 118 208 74 233 52 78 129 73 101 32 94 180 49 175 158 209 26 110 42 125 133 11 133 252 19 105 165 220 63 81 214 85 35 166 157 95 220 199 190 78 235 205 161 109 38 86 178 173 75 16 150 107 115 202 87 90 44 122 250 44 242 3 0 0 0 0 0 0 1 128 94 235 124 73 23 127 111 55 10 111 84 126 170 16 77 106 181 163 73 165 249 170 40 170 90 228 108 176 252 39 45 191 204 225 251 145 26 45 5 233 1 112 57 57 75 136 241 126 114 242 43 156 144 93 196 214 225 123 243 163 118 208 74 233 52 78 129 73 101 32 94 180 49 175 158 209 26 110 42 125 133 11 133 252 19 105 165 220 63 81 214 85 35 166 157 95 220 199 190 78 235 205 161 109 38 86 178 173 75 16 150 107 115 202 87 90 44 122 250 44 242 3 0 0 0 0 0 0 0 64 33 38 244 173 112 88 99 122 250 156 144 15 79 132 196 15 41 75 133 177 70 36 29 76 228 221 155 246 69 197 87 207 178 221 150 150 163 43 125 211 170 119 162 199 18 140 88 14 141 156 131 55 86 105 131 87 183 202 138 193 250 146 7 0 1 64 33 38 244 173 112 88 99 122 250 156 144 15 79 132 196 15 41 75 133 177 70 36 29 76 228 221 155 246 69 197 87 207 178 221 150 150 163 43 125 211 170 119 162 199 18 140 88 14 141 156 131 55 86 105 131 87 183 202 138 193 250 146 7 0 0 8 193 65 150 116 8 0 0 0 1 8 193 65 150 116 8 0 0 0 0 88 222 76 87 0 39 117 3 50 43 76 65 78 229 242 96 28 45 68 9 84 77 32 141 102 105 143 7 223 208 38 17 171 1 5 64 101 80 4 202 47 105 247 32 207 194 242 83 135 163 54 216 178 26 17 93 139 73 169 226 217 99 11 82 47 3 157 215 215 153 31 216 121 218 217 197 70 198 39 255 50 228 150 229 67 199 1 0 0 1 88 222 76 87 0 39 117 3 50 43 76 65 78 229 242 96 28 45 68 9 84 77 32 141 102 105 143 7 223 208 38 17 171 1 5 64 101 80 4 202 47 105 247 32 207 194 242 83 135 163 54 216 178 26 17 93 139 73 169 226 217 99 11 82 47 3 157 215 215 153 31 216 121 218 217 197 70 198 39 255 50 228 150 229 67 199 1 0 0 0 64 132 11 227 148 45 72 132 90 43 39 166 76 172 224 159 49 82 126 46 147 149 229 112 96 19 103 129 209 180 204 78 161 218 161 137 155 40 142 2 48 80 224 51 94 209 169 119 94 212 151 125 134 39 145 109 231 4 0 0 0 0 0 0 0 1 64 132 11 227 148 45 72 132 90 43 39 166 76 172 224 159 49 82 126 46 147 149 229 112 96 19 103 129 209 180 204 78 161 218 161 137 155 40 142 2 48 80 224 51 94 209 169 119 94 212 151 125 134 39 145 109 231 4 0 0 0 0 0 0 0 0 24 123 47 118 34 191 206 207 171 213 67 79 77 219 89 68 92 2 0 0 0 0 0 0 0 1 24 123 47 118 34 191 206 207 171 213 67 79 77 219 89 68 92 2 0 0 0 0 0 0 0 0 56 181 219 18 61 30 154 15 167 192 14 196 148 216 66 206 1 98 115 173 137 197 47 49 228 38 188 178 148 202 18 96 2 103 255 202 246 177 221 107 35 180 27 33 72 172 31 69 128 123 0 0 0 0 0 0 0 1 56 181 219 18 61 30 154 15 167 192 14 196 148 216 66 206 1 98 115 173 137 197 47 49 228 38 188 178 148 202 18 96 2 103 255 202 246 177 221 107 35 180 27 33 72 172 31 69 128 123 0 0 0 0 0 0 0 0 32 7 82 250 163 171 151 193 242 222 208 224 252 8 145 119 231 240 219 237 115 112 17 84 150 54 234 247 1 0 0 0 0 1 32 7 82 250 163 171 151 193 242 222 208 224 252 8 145 119 231 240 219 237 115 112 17 84 150 54 234 247 1 0 0 0 0 0 104 106 128 3 1 188 158 131 102 30 13 165 34 56 140 67 110 15 41 20 34 218 85 212 56 208 97 6 198 121 86 231 16 60 41 116 51 112 68 146 225 249 153 79 173 152 178 167 118 161 49 82 252 223 181 39 89 10 249 163 146 32 111 19 91 56 141 207 248 45 150 31 199 164 135 69 61 48 86 28 152 157 46 95 110 240 67 68 230 61 162 195 46 59 109 223 151 104 231 1 0 0 0 0 0 1 104 106 128 3 1 188 158 131 102 30 13 165 34 56 140 67 110 15 41 20 34 218 85 212 56 208 97 6 198 121 86 231 16 60 41 116 51 112 68 146 225 249 153 79 173 152 178 167 118 161 49 82 252 223 181 39 89 10 249 163 146 32 111 19 91 56 141 207 248 45 150 31 199 164 135 69 61 48 86 28 152 157 46 95 110 240 67 68 230 61 162 195 46 59 109 223 151 104 231 1 0 0 0 0 0 0 8 71 170 230 149 60 169 8 0 1 8 71 170 230 149 60 169 8 0 0 104 197 60 13 194 96 169 102 36 193 199 30 151 61 112 84 43 43 191 194 1 161 56 139 53 115 136 32 148 17 113 135 55 123 181 224 91 143 170 42 70 154 95 146 126 90 132 159 105 180 251 18 41 35 80 231 44 31 43 32 145 245 182 101 28 236 119 33 66 1 225 23 219 129 219 214 243 191 203 150 13 208 77 171 34 153 52 224 233 94 147 246 3 95 62 22 212 102 7 164 241 174 21 0 0 1 104 197 60 13 194 96 169 102 36 193 199 30 151 61 112 84 43 43 191 194 1 161 56 139 53 115 136 32 148 17 113 135 55 123 181 224 91 143 170 42 70 154 95 146 126 90 132 159 105 180 251 18 41 35 80 231 44 31 43 32 145 245 182 101 28 236 119 33 66 1 225 23 219 129 219 214 243 191 203 150 13 208 77 171 34 153 52 224 233 94 147 246 3 95 62 22 212 102 7 164 241 174 21 0 0 0 8 255 177 136 137 82 0 0 0 1 8 255 177 136 137 82 0 0 0 0 32 244 28 97 243 182 228 22 188 140 208 197 48 85 163 246 9 179 58 95 58 150 166 115 224 1 0 0 0 0 0 0 0 1 32 244 28 97 243 182 228 22 188 140 208 197 48 85 163 246 9 179 58 95 58 150 166 115 224 1 0 0 0 0 0 0 0 0 56 18 166 152 245 55 183 20 61 65 95 235 22 101 208 144 158 244 134 73 6 107 252 90 131 187 46 111 218 192 193 204 157 69 78 249 68 158 131 231 84 169 155 246 223 255 125 237 56 39 124 83 222 2 0 0 0 1 56 18 166 152 245 55 183 20 61 65 95 235 22 101 208 144 158 244 134 73 6 107 252 90 131 187 46 111 218 192 193 204 157 69 78 249 68 158 131 231 84 169 155 246 223 255 125 237 56 39 124 83 222 2 0 0 0 0 64 125 215 194 190 138 172 44 82 18 4 12 27 37 152 98 142 28 176 36 149 113 6 134 186 247 114 113 24 143 28 126 9 132 211 32 84 48 255 229 143 210 55 139 145 108 151 47 228 54 230 198 125 130 0 191 218 241 25 250 223 160 158 116 0 1 64 125 215 194 190 138 172 44 82 18 4 12 27 37 152 98 142 28 176 36 149 113 6 134 186 247 114 113 24 143 28 126 9 132 211 32 84 48 255 229 143 210 55 139 145 108 151 47 228 54 230 198 125 130 0 191 218 241 25 250 223 160 158 116 0 0 64 3 57 187 171 211 24 69 12 134 135 186 26 223 242 182 51 228 122 123 228 34 89 39 47 189 254 2 149 226 207 2 67 99 42 86 56 191 230 17 56 161 156 156 78 118 244 228 6 251 250 232 155 46 194 10 138 122 135 43 0 0 0 0 0 1 64 3 57 187 171 211 24 69 12 134 135 186 26 223 242 182 51 228 122 123 228 34 89 39 47 189 254 2 149 226 207 2 67 99 42 86 56 191 230 17 56 161 156 156 78 118 244 228 6 251 250 232 155 46 194 10 138 122 135 43 0 0 0 0 0 0 64 172 126 95 38 172 16 35 220 31 69 231 168 50 246 181 132 163 59 105 107 11 195 114 20 55 43 40 50 235 159 196 170 131 133 34 254 126 123 149 223 8 155 192 190 96 9 65 243 130 152 203 23 54 157 5 6 21 0 0 0 0 0 0 0 1 64 172 126 95 38 172 16 35 220 31 69 231 168 50 246 181 132 163 59 105 107 11 195 114 20 55 43 40 50 235 159 196 170 131 133 34 254 126 123 149 223 8 155 192 190 96 9 65 243 130 152 203 23 54 157 5 6 21 0 0 0 0 0 0 0 0 64 2 111 152 136 184 111 221 198 128 165 251 127 213 81 172 8 106 234 51 14 82 18 6 231 152 0 230 43 112 55 155 160 105 77 184 34 204 159 232 23 202 84 150 215 63 252 216 202 135 94 254 143 56 128 190 119 156 93 36 146 106 50 31 0 1 64 2 111 152 136 184 111 221 198 128 165 251 127 213 81 172 8 106 234 51 14 82 18 6 231 152 0 230 43 112 55 155 160 105 77 184 34 204 159 232 23 202 84 150 215 63 252 216 202 135 94 254 143 56 128 190 119 156 93 36 146 106 50 31 0 0 88 67 179 87 45 0 244 146 0 251 216 55 206 169 143 153 155 204 98 242 127 58 228 9 185 140 50 24 85 71 140 103 173 214 208 88 197 18 88 42 237 5 249 171 151 55 8 19 64 247 14 51 205 117 38 200 199 107 98 33 41 209 251 142 166 190 178 246 165 231 178 156 209 134 137 201 40 51 114 105 214 176 192 40 0 0 0 0 0 1 88 67 179 87 45 0 244 146 0 251 216 55 206 169 143 153 155 204 98 242 127 58 228 9 185 140 50 24 85 71 140 103 173 214 208 88 197 18 88 42 237 5 249 171 151 55 8 19 64 247 14 51 205 117 38 200 199 107 98 33 41 209 251 142 166 190 178 246 165 231 178 156 209 134 137 201 40 51 114 105 214 176 192 40 0 0 0 0 0 0 104 210 223 181 52 158 133 105 60 206 60 97 88 35 84 39 241 68 117 46 200 25 178 180 2 135 170 228 237 78 95 141 220 192 61 243 38 81 141 157 147 134 105 20 141 231 139 98 217 141 233 206 38 63 88 41 115 146 165 44 212 80 120 9 35 155 237 10 49 241 130 64 144 5 183 157 196 6 21 107 70 41 197 111 109 215 116 229 241 167 89 202 52 203 220 160 217 246 30 235 144 235 19 0 0 1 104 210 223 181 52 158 133 105 60 206 60 97 88 35 84 39 241 68 117 46 200 25 178 180 2 135 170 228 237 78 95 141 220 192 61 243 38 81 141 157 147 134 105 20 141 231 139 98 217 141 233 206 38 63 88 41 115 146 165 44 212 80 120 9 35 155 237 10 49 241 130 64 144 5 183 157 196 6 21 107 70 41 197 111 109 215 116 229 241 167 89 202 52 203 220 160 217 246 30 235 144 235 19 0 0 0 96 152 150 20 214 127 232 198 173 9 79 27 3 184 211 18 63 222 243 206 88 162 250 92 190 84 152 234 94 69 155 44 142 240 190 37 73 181 195 210 164 18 87 93 129 136 94 136 136 217 218 51 29 223 183 84 208 218 2 84 239 77 91 212 169 82 20 75 248 125 91 121 11 45 39 139 41 225 254 195 35 239 16 190 22 173 227 229 119 204 69 22 0 0 0 0 0 1 96 152 150 20 214 127 232 198 173 9 79 27 3 184 211 18 63 222 243 206 88 162 250 92 190 84 152 234 94 69 155 44 142 240 190 37 73 181 195 210 164 18 87 93 129 136 94 136 136 217 218 51 29 223 183 84 208 218 2 84 239 77 91 212 169 82 20 75 248 125 91 121 11 45 39 139 41 225 254 195 35 239 16 190 22 173 227 229 119 204 69 22 0 0 0 0 0 0 120 44 138 21 104 121 166 168 12 110 50 53 151 231 148 52 129 170 198 240 95 34 68 28 124 55 201 57 159 127 63 21 5 63 2 162 178 197 92 197 192 93 104 136 44 43 255 49 242 182 132 190 94 80 205 87 26 3 171 184 215 205 47 219 227 179 185 205 230 127 65 231 66 123 92 125 163 244 195 94 188 196 160 223 181 5 166 64 111 85 190 120 122 41 201 0 186 192 106 199 252 164 20 92 37 80 149 48 19 150 123 103 189 229 79 223 27 244 74 0 0 1 120 44 138 21 104 121 166 168 12 110 50 53 151 231 148 52 129 170 198 240 95 34 68 28 124 55 201 57 159 127 63 21 5 63 2 162 178 197 92 197 192 93 104 136 44 43 255 49 242 182 132 190 94 80 205 87 26 3 171 184 215 205 47 219 227 179 185 205 230 127 65 231 66 123 92 125 163 244 195 94 188 196 160 223 181 5 166 64 111 85 190 120 122 41 201 0 186 192 106 199 252 164 20 92 37 80 149 48 19 150 123 103 189 229 79 223 27 244 74 0 0 0 104 245 181 98 66 108 43 27 238 39 17 236 216 168 31 46 226 159 160 142 67 146 30 10 164 14 213 242 136 234 225 199 106 255 33 115 237 228 171 8 216 45 122 202 182 141 16 25 154 11 32 53 253 203 2 153 173 247 193 28 139 204 11 42 191 71 206 216 60 1 99 141 204 17 235 245 239 210 176 83 155 175 144 26 254 215 45 202 84 103 74 45 94 174 24 228 158 37 0 0 0 0 0 0 0 1 104 245 181 98 66 108 43 27 238 39 17 236 216 168 31 46 226 159 160 142 67 146 30 10 164 14 213 242 136 234 225 199 106 255 33 115 237 228 171 8 216 45 122 202 182 141 16 25 154 11 32 53 253 203 2 153 173 247 193 28 139 204 11 42 191 71 206 216 60 1 99 141 204 17 235 245 239 210 176 83 155 175 144 26 254 215 45 202 84 103 74 45 94 174 24 228 158 37 0 0 0 0 0 0 0 0 104 57 246 11 97 62 119 196 46 75 16 79 108 49 113 219 104 188 179 248 78 58 245 127 216 140 166 196 171 132 59 25 253 51 249 216 140 222 121 230 30 172 32 207 74 205 85 44 90 36 173 79 87 194 82 25 79 135 112 132 221 164 76 173 137 126 195 194 92 248 173 9 87 209 223 59 125 95 65 85 163 122 135 111 167 236 33 52 80 27 61 178 237 205 251 204 39 240 191 179 209 167 168 143 7 1 104 57 246 11 97 62 119 196 46 75 16 79 108 49 113 219 104 188 179 248 78 58 245 127 216 140 166 196 171 132 59 25 253 51 249 216 140 222 121 230 30 172 32 207 74 205 85 44 90 36 173 79 87 194 82 25 79 135 112 132 221 164 76 173 137 126 195 194 92 248 173 9 87 209 223 59 125 95 65 85 163 122 135 111 167 236 33 52 80 27 61 178 237 205 251 204 39 240 191 179 209 167 168 143 7 0 40 163 89 48 170 102 43 220 156 66 109 77 113 21 188 67 203 215 226 3 205 170 236 98 121 244 145 200 70 209 174 177 8 139 184 149 27 0 0 0 0 1 40 163 89 48 170 102 43 220 156 66 109 77 113 21 188 67 203 215 226 3 205 170 236 98 121 244 145 200 70 209 174 177 8 139 184 149 27 0 0 0 0 0 96 53 9 22 111 90 93 185 232 66 232 61 190 77 71 90 216 56 212 22 125 84 142 129 138 224 63 243 92 90 116 216 187 231 68 78 132 78 241 87 154 62 85 115 206 103 51 246 75 206 191 127 30 122 123 36 8 228 202 50 139 177 122 8 243 137 70 204 22 54 249 70 184 115 203 134 211 234 65 106 138 66 20 24 187 65 57 199 142 254 18 13 0 0 0 0 0 1 96 53 9 22 111 90 93 185 232 66 232 61 190 77 71 90 216 56 212 22 125 84 142 129 138 224 63 243 92 90 116 216 187 231 68 78 132 78 241 87 154 62 85 115 206 103 51 246 75 206 191 127 30 122 123 36 8 228 202 50 139 177 122 8 243 137 70 204 22 54 249 70 184 115 203 134 211 234 65 106 138 66 20 24 187 65 57 199 142 254 18 13 0 0 0 0 0 0 88 149 88 176 69 223 36 37 144 73 234 120 8 99 221 137 178 30 189 44 46 85 157 48 42 245 113 38 233 244 178 224 211 47 14 147 125 42 18 227 2 75 4 61 200 33 227 150 10 58 244 38 21 49 115 166 218 124 93 108 5 73 235 24 7 87 152 177 21 225 23 170 204 54 120 154 213 94 174 62 0 72 37 253 148 145 218 243 1 1 88 149 88 176 69 223 36 37 144 73 234 120 8 99 221 137 178 30 189 44 46 85 157 48 42 245 113 38 233 244 178 224 211 47 14 147 125 42 18 227 2 75 4 61 200 33 227 150 10 58 244 38 21 49 115 166 218 124 93 108 5 73 235 24 7 87 152 177 21 225 23 170 204 54 120 154 213 94 174 62 0 72 37 253 148 145 218 243 1 0 8 30 0 0 0 0 0 0 0 1 8 30 0 0 0 0 0 0 0 0 88 155 231 228 201 142 243 71 208 249 176 228 44 166 218 152 155 74 36 194 74 148 67 125 239 134 32 23 215 211 53 175 202 69 44 53 118 45 165 95 123 12 108 231 154 213 28 20 163 249 156 33 65 206 61 154 174 104 60 98 109 32 78 242 212 129 149 248 201 134 148 123 181 199 217 155 194 96 140 22 149 241 60 138 83 0 0 0 0 1 88 155 231 228 201 142 243 71 208 249 176 228 44 166 218 152 155 74 36 194 74 148 67 125 239 134 32 23 215 211 53 175 202 69 44 53 118 45 165 95 123 12 108 231 154 213 28 20 163 249 156 33 65 206 61 154 174 104 60 98 109 32 78 242 212 129 149 248 201 134 148 123 181 199 217 155 194 96 140 22 149 241 60 138 83 0 0 0 0 0 96 144 67 10 47 192 191 82 221 35 118 53 159 135 152 112 38 73 15 23 69 58 219 225 247 78 102 170 227 6 163 149 12 249 225 137 246 239 39 40 234 163 207 114 112 115 115 194 219 16 202 159 189 202 35 212 109 38 217 132 76 179 231 7 209 218 188 27 208 113 230 164 84 51 101 32 180 123 194 122 68 150 119 65 252 204 137 177 46 234 227 67 1 0 0 0 0 1 96 144 67 10 47 192 191 82 221 35 118 53 159 135 152 112 38 73 15 23 69 58 219 225 247 78 102 170 227 6 163 149 12 249 225 137 246 239 39 40 234 163 207 114 112 115 115 194 219 16 202 159 189 202 35 212 109 38 217 132 76 179 231 7 209 218 188 27 208 113 230 164 84 51 101 32 180 123 194 122 68 150 119 65 252 204 137 177 46 234 227 67 1 0 0 0 0 0 24 72 56 22 141 170 58 90 163 187 180 242 135 44 169 146 74 211 248 249 78 94 0 0 0 1 24 72 56 22 141 170 58 90 163 187 180 242 135 44 169 146 74 211 248 249 78 94 0 0 0 0 88 212 210 42 73 12 25 196 31 47 75 120 243 73 247 127 147 72 96 165 96 14 69 196 39 172 6 5 194 11 134 119 124 92 255 174 158 25 36 41 88 174 179 156 60 218 178 156 41 175 187 120 209 98 0 19 182 231 198 178 95 52 119 23 97 47 127 143 101 176 216 52 159 106 61 182 27 146 186 142 96 231 29 27 0 0 0 0 0 1 88 212 210 42 73 12 25 196 31 47 75 120 243 73 247 127 147 72 96 165 96 14 69 196 39 172 6 5 194 11 134 119 124 92 255 174 158 25 36 41 88 174 179 156 60 218 178 156 41 175 187 120 209 98 0 19 182 231 198 178 95 52 119 23 97 47 127 143 101 176 216 52 159 106 61 182 27 146 186 142 96 231 29 27 0 0 0 0 0 0 16 202 192 8 50 72 83 78 188 175 88 50 125 131 102 195 3 1 16 202 192 8 50 72 83 78 188 175 88 50 125 131 102 195 3 0 64 129 235 99 25 168 162 143 14 181 191 24 1 54 4 85 204 63 111 78 71 241 253 45 225 56 177 121 166 226 7 163 1 182 155 9 74 40 35 9 9 175 144 171 35 224 162 163 133 97 35 188 126 220 236 73 96 97 129 14 0 0 0 0 0 1 64 129 235 99 25 168 162 143 14 181 191 24 1 54 4 85 204 63 111 78 71 241 253 45 225 56 177 121 166 226 7 163 1 182 155 9 74 40 35 9 9 175 144 171 35 224 162 163 133 97 35 188 126 220 236 73 96 97 129 14 0 0 0 0 0 0 64 108 92 234 131 231 188 232 51 18 198 215 40 15 157 152 141 79 144 203 196 249 187 115 41 230 177 33 50 91 32 10 169 73 162 155 234 98 212 245 92 106 18 104 75 83 194 149 253 23 63 13 64 214 243 154 201 132 100 31 187 255 119 206 203 1 64 108 92 234 131 231 188 232 51 18 198 215 40 15 157 152 141 79 144 203 196 249 187 115 41 230 177 33 50 91 32 10 169 73 162 155 234 98 212 245 92 106 18 104 75 83 194 149 253 23 63 13 64 214 243 154 201 132 100 31 187 255 119 206 203 0 104 234 116 169 65 23 182 136 224 163 211 105 192 204 31 82 240 175 46 102 159 95 158 50 9 145 106 22 60 50 33 177 26 225 82 114 86 212 7 154 44 212 126 161 171 72 116 119 246 52 229 38 173 55 41 107 40 184 253 98 215 24 91 66 142 30 173 123 90 125 69 86 227 60 60 95 206 124 147 44 60 155 141 241 90 83 7 53 206 71 46 134 127 122 180 31 53 82 214 176 0 0 0 0 0 1 104 234 116 169 65 23 182 136 224 163 211 105 192 204 31 82 240 175 46 102 159 95 158 50 9 145 106 22 60 50 33 177 26 225 82 114 86 212 7 154 44 212 126 161 171 72 116 119 246 52 229 38 173 55 41 107 40 184 253 98 215 24 91 66 142 30 173 123 90 125 69 86 227 60 60 95 206 124 147 44 60 155 141 241 90 83 7 53 206 71 46 134 127 122 180 31 53 82 214 176 0 0 0 0 0 0 128 246 224 179 231 248 85 24 201 210 110 165 232 153 136 96 155 10 189 255 115 232 19 11 61 42 152 98 194 221 200 42 3 215 220 12 102 106 69 77 69 216 253 146 196 230 240 63 118 205 224 76 129 107 174 183 121 74 199 99 224 180 49 180 47 34 35 35 224 247 193 61 42 51 142 16 105 58 239 223 3 189 5 85 19 221 249 251 255 86 9 113 209 31 184 51 28 17 30 9 254 164 62 237 123 73 56 8 110 166 164 217 88 106 22 85 183 98 156 139 221 73 253 52 0 0 0 0 0 1 128 246 224 179 231 248 85 24 201 210 110 165 232 153 136 96 155 10 189 255 115 232 19 11 61 42 152 98 194 221 200 42 3 215 220 12 102 106 69 77 69 216 253 146 196 230 240 63 118 205 224 76 129 107 174 183 121 74 199 99 224 180 49 180 47 34 35 35 224 247 193 61 42 51 142 16 105 58 239 223 3 189 5 85 19 221 249 251 255 86 9 113 209 31 184 51 28 17 30 9 254 164 62 237 123 73 56 8 110 166 164 217 88 106 22 85 183 98 156 139 221 73 253 52 0 0 0 0 0 0 80 114 71 65 89 237 36 19 196 155 136 82 8 202 243 70 78 29 120 129 104 2 108 32 185 184 120 36 214 143 191 219 217 92 173 243 221 253 134 71 240 107 182 126 78 197 54 130 17 174 97 201 95 84 153 156 87 239 78 186 103 226 240 168 109 214 167 102 253 22 173 79 216 165 16 0 0 0 0 0 0 1 80 114 71 65 89 237 36 19 196 155 136 82 8 202 243 70 78 29 120 129 104 2 108 32 185 184 120 36 214 143 191 219 217 92 173 243 221 253 134 71 240 107 182 126 78 197 54 130 17 174 97 201 95 84 153 156 87 239 78 186 103 226 240 168 109 214 167 102 253 22 173 79 216 165 16 0 0 0 0 0 0 0 48 205 174 153 159 175 148 18 158 235 107 21 147 172 130 150 6 109 216 1 3 85 18 35 218 2 59 66 219 110 2 146 243 32 186 68 69 178 58 234 207 205 114 206 3 0 0 0 0 1 48 205 174 153 159 175 148 18 158 235 107 21 147 172 130 150 6 109 216 1 3 85 18 35 218 2 59 66 219 110 2 146 243 32 186 68 69 178 58 234 207 205 114 206 3 0 0 0 0 0 120 6 227 111 143 56 164 39 218 18 125 60 7 225 195 8 232 184 177 163 16 21 29 165 72 172 201 28 230 132 0 86 23 246 125 104 127 83 109 13 113 149 216 245 166 173 128 120 168 110 19 178 216 69 212 66 94 179 133 240 181 66 121 14 166 89 77 60 143 152 41 85 140 62 121 51 44 123 188 123 173 52 74 2 31 233 7 229 187 139 234 225 45 79 247 235 210 113 240 84 200 66 137 125 254 189 83 79 17 221 213 32 54 4 0 0 0 0 0 0 0 1 120 6 227 111 143 56 164 39 218 18 125 60 7 225 195 8 232 184 177 163 16 21 29 165 72 172 201 28 230 132 0 86 23 246 125 104 127 83 109 13 113 149 216 245 166 173 128 120 168 110 19 178 216 69 212 66 94 179 133 240 181 66 121 14 166 89 77 60 143 152 41 85 140 62 121 51 44 123 188 123 173 52 74 2 31 233 7 229 187 139 234 225 45 79 247 235 210 113 240 84 200 66 137 125 254 189 83 79 17 221 213 32 54 4 0 0 0 0 0 0 0 0 80 180 196 94 156 54 195 58 2 39 205 18 27 183 204 87 155 155 103 140 143 118 225 162 141 198 191 103 246 251 35 33 200 114 204 108 157 138 202 183 109 135 225 247 167 85 247 149 166 13 150 140 115 191 119 88 74 150 209 45 234 64 143 177 65 18 230 195 62 134 19 33 86 117 177 249 0 0 0 0 0 1 80 180 196 94 156 54 195 58 2 39 205 18 27 183 204 87 155 155 103 140 143 118 225 162 141 198 191 103 246 251 35 33 200 114 204 108 157 138 202 183 109 135 225 247 167 85 247 149 166 13 150 140 115 191 119 88 74 150 209 45 234 64 143 177 65 18 230 195 62 134 19 33 86 117 177 249 0 0 0 0 0 0 104 77 194 158 250 209 247 60 209 53 237 237 50 69 209 78 167 168 156 255 102 176 89 29 124 236 2 92 64 171 213 222 61 154 151 17 221 163 26 188 48 218 181 25 207 24 78 174 96 77 4 92 36 81 77 82 53 226 55 109 24 229 73 137 228 213 186 236 231 140 148 101 63 106 130 255 94 160 246 229 63 254 107 254 48 15 56 43 131 180 38 166 178 234 233 86 61 2 85 154 172 81 81 66 9 1 104 77 194 158 250 209 247 60 209 53 237 237 50 69 209 78 167 168 156 255 102 176 89 29 124 236 2 92 64 171 213 222 61 154 151 17 221 163 26 188 48 218 181 25 207 24 78 174 96 77 4 92 36 81 77 82 53 226 55 109 24 229 73 137 228 213 186 236 231 140 148 101 63 106 130 255 94 160 246 229 63 254 107 254 48 15 56 43 131 180 38 166 178 234 233 86 61 2 85 154 172 81 81 66 9 0 32 159 255 244 214 47 170 4 34 47 46 170 236 221 0 119 135 29 199 192 21 169 211 135 216 147 25 112 187 63 0 0 0 1 32 159 255 244 214 47 170 4 34 47 46 170 236 221 0 119 135 29 199 192 21 169 211 135 216 147 25 112 187 63 0 0 0 0 8 136 102 2 0 0 0 0 0 1 8 136 102 2 0 0 0 0 0 0 104 182 114 42 214 204 210 88 197 7 199 39 124 27 200 142 13 162 188 42 112 118 92 202 215 78 160 112 52 72 100 65 30 205 199 86 182 35 211 245 70 139 86 183 94 139 115 30 32 188 225 10 237 169 169 192 188 84 209 158 78 210 48 148 84 141 6 11 247 62 239 52 100 249 186 173 138 163 134 212 20 243 14 250 162 155 177 89 175 243 3 44 202 80 198 163 43 3 0 0 0 0 0 0 0 1 104 182 114 42 214 204 210 88 197 7 199 39 124 27 200 142 13 162 188 42 112 118 92 202 215 78 160 112 52 72 100 65 30 205 199 86 182 35 211 245 70 139 86 183 94 139 115 30 32 188 225 10 237 169 169 192 188 84 209 158 78 210 48 148 84 141 6 11 247 62 239 52 100 249 186 173 138 163 134 212 20 243 14 250 162 155 177 89 175 243 3 44 202 80 198 163 43 3 0 0 0 0 0 0 0 0 112 99 120 242 101 168 63 63 168 132 177 224 65 190 4 179 252 98 42 247 140 190 31 23 0 117 179 116 199 98 202 211 102 139 65 63 177 51 13 22 232 149 208 247 101 128 25 173 165 160 191 102 145 173 51 230 242 244 7 170 233 242 115 73 120 62 67 64 36 3 41 74 159 24 59 71 166 190 104 193 40 86 159 53 253 65 67 111 21 48 43 46 214 182 41 210 212 59 110 156 33 239 225 212 27 107 0 0 0 0 0 0 0 1 112 99 120 242 101 168 63 63 168 132 177 224 65 190 4 179 252 98 42 247 140 190 31 23 0 117 179 116 199 98 202 211 102 139 65 63 177 51 13 22 232 149 208 247 101 128 25 173 165 160 191 102 145 173 51 230 242 244 7 170 233 242 115 73 120 62 67 64 36 3 41 74 159 24 59 71 166 190 104 193 40 86 159 53 253 65 67 111 21 48 43 46 214 182 41 210 212 59 110 156 33 239 225 212 27 107 0 0 0 0 0 0 0 0 40 182 35 41 118 252 144 79 94 31 128 26 169 129 98 79 185 77 204 158 170 99 105 83 166 57 204 35 71 231 68 17 161 7 0 0 0 0 0 0 0 1 40 182 35 41 118 252 144 79 94 31 128 26 169 129 98 79 185 77 204 158 170 99 105 83 166 57 204 35 71 231 68 17 161 7 0 0 0 0 0 0 0 0 112 19 121 68 172 165 141 93 53 202 225 143 125 21 127 168 150 223 142 78 163 244 135 194 197 17 161 238 159 225 207 232 231 141 188 186 185 170 238 141 145 164 234 7 144 31 97 144 227 0 100 164 181 137 33 28 59 136 10 218 56 168 254 166 106 145 203 39 49 163 15 174 143 31 5 178 130 153 84 87 87 61 221 163 29 252 65 53 122 68 235 160 127 229 67 219 215 172 22 9 124 37 73 237 104 38 0 0 0 0 0 0 0 1 112 19 121 68 172 165 141 93 53 202 225 143 125 21 127 168 150 223 142 78 163 244 135 194 197 17 161 238 159 225 207 232 231 141 188 186 185 170 238 141 145 164 234 7 144 31 97 144 227 0 100 164 181 137 33 28 59 136 10 218 56 168 254 166 106 145 203 39 49 163 15 174 143 31 5 178 130 153 84 87 87 61 221 163 29 252 65 53 122 68 235 160 127 229 67 219 215 172 22 9 124 37 73 237 104 38 0 0 0 0 0 0 0 0 72 131 157 197 45 185 223 236 53 246 15 184 5 182 184 23 147 3 15 46 179 218 118 209 114 37 235 220 187 201 154 47 207 166 122 35 26 91 3 127 154 179 249 232 233 237 129 34 68 202 138 161 0 13 77 112 252 203 92 187 188 230 39 55 132 247 0 0 0 0 0 0 0 1 72 131 157 197 45 185 223 236 53 246 15 184 5 182 184 23 147 3 15 46 179 218 118 209 114 37 235 220 187 201 154 47 207 166 122 35 26 91 3 127 154 179 249 232 233 237 129 34 68 202 138 161 0 13 77 112 252 203 92 187 188 230 39 55 132 247 0 0 0 0 0 0 0 0 128 215 194 0 199 219 223 102 242 204 248 124 17 112 73 119 161 49 131 84 207 207 67 43 12 67 150 210 126 148 3 13 241 16 225 134 108 33 87 2 157 76 211 58 133 210 144 225 220 56 131 147 199 231 84 32 218 43 221 252 165 30 119 252 165 229 211 167 197 150 182 197 108 234 8 252 127 239 35 237 26 80 187 183 139 105 103 168 55 42 221 202 112 37 234 50 199 248 234 249 61 133 62 20 172 135 114 63 241 161 127 1 136 155 71 88 83 222 156 240 240 1 0 0 0 0 0 0 0 1 128 215 194 0 199 219 223 102 242 204 248 124 17 112 73 119 161 49 131 84 207 207 67 43 12 67 150 210 126 148 3 13 241 16 225 134 108 33 87 2 157 76 211 58 133 210 144 225 220 56 131 147 199 231 84 32 218 43 221 252 165 30 119 252 165 229 211 167 197 150 182 197 108 234 8 252 127 239 35 237 26 80 187 183 139 105 103 168 55 42 221 202 112 37 234 50 199 248 234 249 61 133 62 20 172 135 114 63 241 161 127 1 136 155 71 88 83 222 156 240 240 1 0 0 0 0 0 0 0 0 96 77 228 31 76 241 138 249 4 98 9 115 184 112 82 183 229 236 138 162 82 102 251 28 188 12 113 181 158 79 211 194 251 196 166 73 83 83 80 42 120 93 243 152 162 232 39 205 85 189 126 54 242 156 193 86 191 44 44 252 55 14 21 27 116 194 191 250 7 74 203 105 99 89 106 178 14 2 236 178 68 170 192 252 120 41 130 72 87 206 11 0 0 0 0 0 0 1 96 77 228 31 76 241 138 249 4 98 9 115 184 112 82 183 229 236 138 162 82 102 251 28 188 12 113 181 158 79 211 194 251 196 166 73 83 83 80 42 120 93 243 152 162 232 39 205 85 189 126 54 242 156 193 86 191 44 44 252 55 14 21 27 116 194 191 250 7 74 203 105 99 89 106 178 14 2 236 178 68 170 192 252 120 41 130 72 87 206 11 0 0 0 0 0 0 0 56 134 225 44 69 119 64 234 84 89 109 244 85 126 103 94 170 253 103 245 228 230 48 38 166 108 164 43 22 74 31 25 224 196 60 126 145 211 177 41 97 248 197 232 65 242 142 255 87 64 104 166 218 221 0 0 0 1 56 134 225 44 69 119 64 234 84 89 109 244 85 126 103 94 170 253 103 245 228 230 48 38 166 108 164 43 22 74 31 25 224 196 60 126 145 211 177 41 97 248 197 232 65 242 142 255 87 64 104 166 218 221 0 0 0 0 120 229 172 191 36 121 40 254 104 25 228 24 190 128 20 169 193 240 145 60 136 35 241 68 254 62 193 45 112 102 236 245 29 64 94 62 47 36 42 252 13 28 27 219 9 245 94 181 136 19 177 1 212 5 30 243 157 117 94 95 128 151 156 4 203 11 190 27 0 62 198 137 167 143 73 204 232 2 248 129 253 159 82 186 78 87 59 101 197 100 160 249 30 152 93 125 199 107 24 125 64 176 236 44 0 171 123 140 55 132 181 2 66 228 115 0 0 0 0 0 0 1 120 229 172 191 36 121 40 254 104 25 228 24 190 128 20 169 193 240 145 60 136 35 241 68 254 62 193 45 112 102 236 245 29 64 94 62 47 36 42 252 13 28 27 219 9 245 94 181 136 19 177 1 212 5 30 243 157 117 94 95 128 151 156 4 203 11 190 27 0 62 198 137 167 143 73 204 232 2 248 129 253 159 82 186 78 87 59 101 197 100 160 249 30 152 93 125 199 107 24 125 64 176 236 44 0 171 123 140 55 132 181 2 66 228 115 0 0 0 0 0 0 0 56 242 178 209 149 127 105 215 100 20 77 91 129 188 44 67 89 61 245 2 145 100 176 98 45 200 226 215 226 171 178 81 56 196 210 25 211 24 236 80 114 182 153 187 70 254 227 193 36 163 1 237 117 87 122 2 0 1 56 242 178 209 149 127 105 215 100 20 77 91 129 188 44 67 89 61 245 2 145 100 176 98 45 200 226 215 226 171 178 81 56 196 210 25 211 24 236 80 114 182 153 187 70 254 227 193 36 163 1 237 117 87 122 2 0 0 128 134 51 146 212 174 146 101 32 54 80 14 156 174 236 212 195 81 90 58 116 149 201 205 7 130 14 255 190 241 205 207 249 221 121 67 167 233 3 91 49 79 77 255 115 246 112 74 5 197 106 119 29 238 202 62 53 27 223 236 152 234 237 36 19 234 248 83 103 87 80 106 110 27 202 134 182 123 143 10 59 147 105 206 20 112 193 190 220 192 38 172 241 167 90 129 71 185 246 137 86 12 195 102 17 186 107 173 97 103 140 196 114 119 155 196 217 44 13 55 170 195 147 93 0 0 0 0 0 1 128 134 51 146 212 174 146 101 32 54 80 14 156 174 236 212 195 81 90 58 116 149 201 205 7 130 14 255 190 241 205 207 249 221 121 67 167 233 3 91 49 79 77 255 115 246 112 74 5 197 106 119 29 238 202 62 53 27 223 236 152 234 237 36 19 234 248 83 103 87 80 106 110 27 202 134 182 123 143 10 59 147 105 206 20 112 193 190 220 192 38 172 241 167 90 129 71 185 246 137 86 12 195 102 17 186 107 173 97 103 140 196 114 119 155 196 217 44 13 55 170 195 147 93 0 0 0 0 0 0 80 252 151 248 45 49 178 79 128 161 10 102 252 132 63 0 196 234 37 213 196 19 233 200 48 79 135 72 224 67 120 56 21 130 243 118 44 119 71 20 190 181 163 216 126 133 133 98 134 74 16 85 129 28 141 49 184 195 10 187 170 152 61 100 174 129 141 139 49 17 137 166 184 197 148 14 0 0 0 0 0 1 80 252 151 248 45 49 178 79 128 161 10 102 252 132 63 0 196 234 37 213 196 19 233 200 48 79 135 72 224 67 120 56 21 130 243 118 44 119 71 20 190 181 163 216 126 133 133 98 134 74 16 85 129 28 141 49 184 195 10 187 170 152 61 100 174 129 141 139 49 17 137 166 184 197 148 14 0 0 0 0 0 0 72 201 189 132 146 184 73 235 58 191 160 218 55 99 221 69 240 85 82 95 206 66 232 212 65 234 63 77 180 226 245 185 90 39 91 117 118 212 95 63 202 231 49 115 110 103 125 28 251 84 217 64 21 37 74 176 91 16 243 99 51 19 229 146 28 76 167 138 98 3 86 2 0 1 72 201 189 132 146 184 73 235 58 191 160 218 55 99 221 69 240 85 82 95 206 66 232 212 65 234 63 77 180 226 245 185 90 39 91 117 118 212 95 63 202 231 49 115 110 103 125 28 251 84 217 64 21 37 74 176 91 16 243 99 51 19 229 146 28 76 167 138 98 3 86 2 0 0 24 4 127 113 119 170 147 209 114 124 184 151 70 216 77 57 33 8 170 193 201 10 0 0 0 1 24 4 127 113 119 170 147 209 114 124 184 151 70 216 77 57 33 8 170 193 201 10 0 0 0 0 24 221 119 146 70 38 139 89 31 158 39 212 71 222 63 236 44 183 75 0 0 0 0 0 0 1 24 221 119 146 70 38 139 89 31 158 39 212 71 222 63 236 44 183 75 0 0 0 0 0 0 0 104 15 190 40 142 118 234 227 167 165 244 200 26 49 57 37 9 217 227 141 192 139 18 100 130 160 53 103 125 170 120 113 53 121 232 23 248 218 111 12 114 85 152 168 69 138 153 228 55 175 99 6 29 234 191 118 238 18 250 139 127 248 148 96 36 236 164 252 127 71 230 13 95 200 86 106 201 201 168 74 148 207 42 56 34 173 114 89 220 58 197 209 56 194 93 253 36 57 2 0 0 0 0 0 0 1 104 15 190 40 142 118 234 227 167 165 244 200 26 49 57 37 9 217 227 141 192 139 18 100 130 160 53 103 125 170 120 113 53 121 232 23 248 218 111 12 114 85 152 168 69 138 153 228 55 175 99 6 29 234 191 118 238 18 250 139 127 248 148 96 36 236 164 252 127 71 230 13 95 200 86 106 201 201 168 74 148 207 42 56 34 173 114 89 220 58 197 209 56 194 93 253 36 57 2 0 0 0 0 0 0 0 24 241 138 87 82 7 150 25 154 252 91 216 29 106 84 123 71 145 238 230 5 0 0 0 0 1 24 241 138 87 82 7 150 25 154 252 91 216 29 106 84 123 71 145 238 230 5 0 0 0 0 0 32 151 63 193 99 4 229 248 206 122 164 94 141 132 110 0 199 239 244 9 150 62 180 68 138 132 112 26 31 217 46 0 0 1 32 151 63 193 99 4 229 248 206 122 164 94 141 132 110 0 199 239 244 9 150 62 180 68 138 132 112 26 31 217 46 0 0 0 40 151 219 5 222 229 79 21 136 176 12 133 59 166 175 203 218 102 58 176 141 26 127 152 21 81 49 214 17 132 22 14 243 177 3 0 0 0 0 0 0 1 40 151 219 5 222 229 79 21 136 176 12 133 59 166 175 203 218 102 58 176 141 26 127 152 21 81 49 214 17 132 22 14 243 177 3 0 0 0 0 0 0 0 104 6 168 179 178 70 132 236 140 85 20 22 237 179 132 40 18 248 209 250 75 115 245 45 67 206 107 231 237 102 198 61 0 53 181 149 233 167 119 49 80 107 58 194 191 82 80 182 33 90 50 185 65 82 236 47 123 143 42 21 75 76 220 97 26 140 95 213 177 133 178 200 249 254 187 252 127 168 64 33 103 133 36 183 203 53 160 28 249 121 153 43 163 187 30 115 14 218 222 176 173 69 117 99 12 1 104 6 168 179 178 70 132 236 140 85 20 22 237 179 132 40 18 248 209 250 75 115 245 45 67 206 107 231 237 102 198 61 0 53 181 149 233 167 119 49 80 107 58 194 191 82 80 182 33 90 50 185 65 82 236 47 123 143 42 21 75 76 220 97 26 140 95 213 177 133 178 200 249 254 187 252 127 168 64 33 103 133 36 183 203 53 160 28 249 121 153 43 163 187 30 115 14 218 222 176 173 69 117 99 12 0 112 2 212 34 173 196 82 79 56 112 170 220 63 200 109 239 119 47 163 110 174 76 171 32 84 196 96 74 147 73 116 212 7 81 2 123 170 250 193 70 154 132 132 185 57 39 161 95 139 69 234 233 243 142 195 223 169 214 193 142 130 202 53 250 215 1 232 72 89 42 138 164 214 96 81 207 117 204 208 64 159 221 205 19 127 120 90 20 23 72 45 155 78 40 43 86 112 83 186 201 240 77 86 191 92 249 160 247 61 0 0 0 0 1 112 2 212 34 173 196 82 79 56 112 170 220 63 200 109 239 119 47 163 110 174 76 171 32 84 196 96 74 147 73 116 212 7 81 2 123 170 250 193 70 154 132 132 185 57 39 161 95 139 69 234 233 243 142 195 223 169 214 193 142 130 202 53 250 215 1 232 72 89 42 138 164 214 96 81 207 117 204 208 64 159 221 205 19 127 120 90 20 23 72 45 155 78 40 43 86 112 83 186 201 240 77 86 191 92 249 160 247 61 0 0 0 0 0 128 102 251 156 92 43 108 29 62 40 215 42 15 198 118 248 50 157 25 129 219 206 70 124 249 193 82 122 51 209 211 166 198 129 204 78 210 123 124 106 191 69 198 115 9 187 105 170 16 189 25 66 30 61 214 177 166 27 0 66 226 174 106 52 23 197 236 68 43 88 169 245 109 62 252 144 219 129 154 127 116 74 210 197 53 171 56 209 150 200 215 71 80 187 84 179 235 71 14 27 0 159 145 132 91 170 69 4 77 60 185 156 0 93 72 67 68 185 235 189 29 178 144 42 227 35 59 27 0 1 128 102 251 156 92 43 108 29 62 40 215 42 15 198 118 248 50 157 25 129 219 206 70 124 249 193 82 122 51 209 211 166 198 129 204 78 210 123 124 106 191 69 198 115 9 187 105 170 16 189 25 66 30 61 214 177 166 27 0 66 226 174 106 52 23 197 236 68 43 88 169 245 109 62 252 144 219 129 154 127 116 74 210 197 53 171 56 209 150 200 215 71 80 187 84 179 235 71 14 27 0 159 145 132 91 170 69 4 77 60 185 156 0 93 72 67 68 185 235 189 29 178 144 42 227 35 59 27 0 0 40 22 179 130 104 210 45 171 95 5 140 87 49 187 173 206 147 141 26 50 138 30 228 117 173 59 57 138 187 138 30 79 102 10 0 0 0 0 0 0 0 1 40 22 179 130 104 210 45 171 95 5 140 87 49 187 173 206 147 141 26 50 138 30 228 117 173 59 57 138 187 138 30 79 102 10 0 0 0 0 0 0 0 0 48 245 222 165 23 160 186 7 2 211 238 67 132 133 157 254 89 199 178 45 73 151 206 197 254 6 172 31 88 199 204 161 72 65 160 25 246 142 223 123 52 172 12 6 0 0 0 0 0 1 48 245 222 165 23 160 186 7 2 211 238 67 132 133 157 254 89 199 178 45 73 151 206 197 254 6 172 31 88 199 204 161 72 65 160 25 246 142 223 123 52 172 12 6 0 0 0 0 0 0 112 222 47 68 13 28 124 145 191 235 84 137 87 165 230 34 132 42 90 242 140 248 118 51 137 4 68 91 156 194 220 89 46 217 200 72 50 124 24 209 194 179 150 236 12 223 90 150 72 220 112 234 137 123 179 108 65 16 250 73 68 13 219 174 119 68 216 117 5 143 105 238 147 162 128 99 201 30 204 31 130 46 147 73 191 185 192 73 212 83 18 90 106 146 126 18 59 63 194 86 25 42 52 82 92 6 0 0 0 0 0 0 0 1 112 222 47 68 13 28 124 145 191 235 84 137 87 165 230 34 132 42 90 242 140 248 118 51 137 4 68 91 156 194 220 89 46 217 200 72 50 124 24 209 194 179 150 236 12 223 90 150 72 220 112 234 137 123 179 108 65 16 250 73 68 13 219 174 119 68 216 117 5 143 105 238 147 162 128 99 201 30 204 31 130 46 147 73 191 185 192 73 212 83 18 90 106 146 126 18 59 63 194 86 25 42 52 82 92 6 0 0 0 0 0 0 0 0 40 74 204 182 19 172 57 74 106 161 11 250 172 174 63 33 117 146 108 133 108 20 20 28 215 14 216 35 120 250 72 181 31 75 237 185 64 125 38 30 0 1 40 74 204 182 19 172 57 74 106 161 11 250 172 174 63 33 117 146 108 133 108 20 20 28 215 14 216 35 120 250 72 181 31 75 237 185 64 125 38 30 0 0 32 39 90 158 132 213 173 24 145 199 200 240 251 85 122 152 148 224 56 26 234 37 58 180 82 137 37 60 8 144 85 118 5 1 32 39 90 158 132 213 173 24 145 199 200 240 251 85 122 152 148 224 56 26 234 37 58 180 82 137 37 60 8 144 85 118 5 0 8 138 84 0 0 0 0 0 0 1 8 138 84 0 0 0 0 0 0 0 120 6 116 242 108 248 14 140 127 243 249 231 147 68 151 120 38 231 8 34 6 106 4 211 91 3 66 139 242 76 75 130 178 43 63 174 27 78 5 184 165 84 187 23 158 140 41 71 59 22 178 59 239 6 145 6 103 216 172 37 75 231 145 41 56 213 208 27 181 52 16 183 237 193 209 238 106 47 104 214 15 82 217 35 168 104 64 76 104 111 95 151 127 241 27 86 63 95 186 251 237 14 164 119 230 211 234 83 245 143 10 244 120 135 32 125 144 92 8 189 0 1 120 6 116 242 108 248 14 140 127 243 249 231 147 68 151 120 38 231 8 34 6 106 4 211 91 3 66 139 242 76 75 130 178 43 63 174 27 78 5 184 165 84 187 23 158 140 41 71 59 22 178 59 239 6 145 6 103 216 172 37 75 231 145 41 56 213 208 27 181 52 16 183 237 193 209 238 106 47 104 214 15 82 217 35 168 104 64 76 104 111 95 151 127 241 27 86 63 95 186 251 237 14 164 119 230 211 234 83 245 143 10 244 120 135 32 125 144 92 8 189 0 0 32 169 164 216 5 23 138 199 97 227 119 26 63 15 87 131 107 175 132 108 223 46 17 101 176 195 214 100 232 0 0 0 0 1 32 169 164 216 5 23 138 199 97 227 119 26 63 15 87 131 107 175 132 108 223 46 17 101 176 195 214 100 232 0 0 0 0 0 48 8 170 244 92 198 184 32 64 24 118 241 85 66 189 103 28 33 244 60 230 74 7 243 100 2 1 93 74 149 165 150 65 102 220 228 186 83 101 123 141 123 109 182 122 105 0 0 0 1 48 8 170 244 92 198 184 32 64 24 118 241 85 66 189 103 28 33 244 60 230 74 7 243 100 2 1 93 74 149 165 150 65 102 220 228 186 83 101 123 141 123 109 182 122 105 0 0 0 0 120 12 158 20 122 77 167 176 86 158 51 230 99 136 241 101 17 244 121 59 87 103 26 111 205 53 244 235 242 229 169 15 224 95 241 248 47 71 217 197 177 238 46 133 175 43 178 246 61 15 216 239 68 140 164 169 9 17 109 185 231 2 170 188 140 250 123 194 232 88 232 26 60 214 152 106 181 39 234 136 137 58 62 209 190 251 104 89 19 70 178 56 124 109 18 185 167 142 60 123 228 26 54 187 187 148 203 130 114 248 49 111 198 191 107 86 222 3 0 0 0 1 120 12 158 20 122 77 167 176 86 158 51 230 99 136 241 101 17 244 121 59 87 103 26 111 205 53 244 235 242 229 169 15 224 95 241 248 47 71 217 197 177 238 46 133 175 43 178 246 61 15 216 239 68 140 164 169 9 17 109 185 231 2 170 188 140 250 123 194 232 88 232 26 60 214 152 106 181 39 234 136 137 58 62 209 190 251 104 89 19 70 178 56 124 109 18 185 167 142 60 123 228 26 54 187 187 148 203 130 114 248 49 111 198 191 107 86 222 3 0 0 0 0 32 105 179 233 126 169 174 183 251 227 117 195 127 211 122 235 34 108 161 29 184 19 156 152 225 139 6 0 0 0 0 0 0 1 32 105 179 233 126 169 174 183 251 227 117 195 127 211 122 235 34 108 161 29 184 19 156 152 225 139 6 0 0 0 0 0 0 0 112 107 214 160 47 12 148 181 229 136 85 57 117 58 49 175 91 20 92 201 244 247 222 130 215 158 98 242 146 190 210 201 180 77 219 243 130 159 138 227 73 54 255 186 170 144 106 170 66 197 143 127 162 210 122 37 99 171 90 242 115 145 250 57 97 176 167 16 225 132 49 247 59 22 25 236 36 64 252 125 139 145 215 22 92 228 240 79 244 183 178 12 93 194 169 217 159 169 69 179 171 96 5 35 137 33 198 85 237 12 0 0 0 1 112 107 214 160 47 12 148 181 229 136 85 57 117 58 49 175 91 20 92 201 244 247 222 130 215 158 98 242 146 190 210 201 180 77 219 243 130 159 138 227 73 54 255 186 170 144 106 170 66 197 143 127 162 210 122 37 99 171 90 242 115 145 250 57 97 176 167 16 225 132 49 247 59 22 25 236 36 64 252 125 139 145 215 22 92 228 240 79 244 183 178 12 93 194 169 217 159 169 69 179 171 96 5 35 137 33 198 85 237 12 0 0 0 0 40 151 236 140 234 49 95 40 136 48 181 242 198 107 168 119 133 33 148 222 230 48 187 177 235 54 92 147 200 220 8 9 80 3 0 0 0 0 0 0 0 1 40 151 236 140 234 49 95 40 136 48 181 242 198 107 168 119 133 33 148 222 230 48 187 177 235 54 92 147 200 220 8 9 80 3 0 0 0 0 0 0 0 0 128 86 110 24 37 97 222 163 92 216 221 199 229 79 95 24 16 74 176 194 98 40 169 140 19 1 205 231 70 185 36 255 18 60 202 214 208 120 214 232 112 172 228 176 230 94 127 136 74 11 44 237 249 68 118 244 151 238 132 77 38 186 252 14 206 146 197 57 245 192 244 29 199 74 59 195 148 69 151 165 29 107 182 98 147 191 148 189 200 184 33 221 44 102 236 230 236 155 131 213 212 11 163 71 97 118 61 218 110 71 189 129 17 181 221 250 137 80 48 231 83 123 104 6 0 0 0 0 0 1 128 86 110 24 37 97 222 163 92 216 221 199 229 79 95 24 16 74 176 194 98 40 169 140 19 1 205 231 70 185 36 255 18 60 202 214 208 120 214 232 112 172 228 176 230 94 127 136 74 11 44 237 249 68 118 244 151 238 132 77 38 186 252 14 206 146 197 57 245 192 244 29 199 74 59 195 148 69 151 165 29 107 182 98 147 191 148 189 200 184 33 221 44 102 236 230 236 155 131 213 212 11 163 71 97 118 61 218 110 71 189 129 17 181 221 250 137 80 48 231 83 123 104 6 0 0 0 0 0 0 80 243 176 186 126 186 98 210 179 162 140 92 40 240 184 134 105 0 157 103 36 223 108 115 65 73 109 222 11 169 151 183 215 249 45 86 167 172 26 95 222 130 112 5 193 174 61 230 154 13 242 26 53 125 184 23 119 6 116 85 81 153 220 146 138 224 238 242 57 50 24 89 106 223 20 181 86 96 139 192 0 1 80 243 176 186 126 186 98 210 179 162 140 92 40 240 184 134 105 0 157 103 36 223 108 115 65 73 109 222 11 169 151 183 215 249 45 86 167 172 26 95 222 130 112 5 193 174 61 230 154 13 242 26 53 125 184 23 119 6 116 85 81 153 220 146 138 224 238 242 57 50 24 89 106 223 20 181 86 96 139 192 0 0 104 118 189 65 124 187 124 164 181 40 78 215 14 181 239 248 104 169 212 147 203 95 26 103 54 4 23 49 26 46 240 31 57 71 166 134 221 134 146 219 246 49 7 96 225 138 247 198 120 76 183 208 201 100 120 240 147 60 217 93 237 131 48 5 244 23 233 221 83 229 102 159 120 118 222 134 200 86 131 193 55 124 183 137 148 160 79 166 91 219 240 18 236 83 72 210 216 101 108 113 68 0 0 0 0 1 104 118 189 65 124 187 124 164 181 40 78 215 14 181 239 248 104 169 212 147 203 95 26 103 54 4 23 49 26 46 240 31 57 71 166 134 221 134 146 219 246 49 7 96 225 138 247 198 120 76 183 208 201 100 120 240 147 60 217 93 237 131 48 5 244 23 233 221 83 229 102 159 120 118 222 134 200 86 131 193 55 124 183 137 148 160 79 166 91 219 240 18 236 83 72 210 216 101 108 113 68 0 0 0 0 0 64 6 22 71 2 163 86 17 242 164 39 109 95 160 109 98 241 37 105 112 221 113 19 63 140 96 143 87 147 41 36 27 242 55 158 16 197 226 52 235 172 133 128 179 181 251 150 32 196 95 149 76 252 69 10 230 30 27 76 224 226 22 0 0 0 1 64 6 22 71 2 163 86 17 242 164 39 109 95 160 109 98 241 37 105 112 221 113 19 63 140 96 143 87 147 41 36 27 242 55 158 16 197 226 52 235 172 133 128 179 181 251 150 32 196 95 149 76 252 69 10 230 30 27 76 224 226 22 0 0 0 0 128 30 130 103 205 32 243 152 123 79 104 19 33 177 209 230 129 178 23 223 13 94 146 223 35 144 45 101 240 232 191 92 122 248 142 90 70 70 227 195 145 191 197 239 106 26 240 233 128 67 75 182 93 107 72 57 103 203 190 221 242 163 253 180 159 146 253 103 81 208 252 1 223 226 217 70 222 240 174 35 247 131 232 230 20 50 149 109 33 236 254 14 141 202 198 2 116 168 2 254 234 211 168 142 232 27 76 165 171 140 74 161 29 242 180 17 221 182 28 140 165 153 167 81 47 103 223 10 0 1 128 30 130 103 205 32 243 152 123 79 104 19 33 177 209 230 129 178 23 223 13 94 146 223 35 144 45 101 240 232 191 92 122 248 142 90 70 70 227 195 145 191 197 239 106 26 240 233 128 67 75 182 93 107 72 57 103 203 190 221 242 163 253 180 159 146 253 103 81 208 252 1 223 226 217 70 222 240 174 35 247 131 232 230 20 50 149 109 33 236 254 14 141 202 198 2 116 168 2 254 234 211 168 142 232 27 76 165 171 140 74 161 29 242 180 17 221 182 28 140 165 153 167 81 47 103 223 10 0 0 48 150 89 14 218 228 227 23 162 153 39 113 34 98 183 194 25 93 68 57 205 28 17 6 69 82 191 227 207 100 5 188 188 211 209 220 205 0 146 180 251 104 31 119 91 104 1 0 0 1 48 150 89 14 218 228 227 23 162 153 39 113 34 98 183 194 25 93 68 57 205 28 17 6 69 82 191 227 207 100 5 188 188 211 209 220 205 0 146 180 251 104 31 119 91 104 1 0 0 0 16 3 75 50 16 21 240 211 149 188 0 0 0 0 0 0 0 1 16 3 75 50 16 21 240 211 149 188 0 0 0 0 0 0 0 0 112 9 115 108 68 232 102 178 176 69 243 217 106 209 14 224 172 167 195 216 60 119 98 115 232 110 47 157 119 32 78 224 248 168 59 100 46 75 172 15 39 92 41 128 82 192 201 101 82 196 22 185 109 161 212 23 243 181 215 188 245 6 226 125 224 129 249 88 9 231 215 83 203 0 1 5 225 190 75 41 64 109 105 106 37 227 156 251 13 180 250 104 241 34 187 224 79 84 147 11 127 35 64 121 111 143 12 0 0 0 0 0 0 1 112 9 115 108 68 232 102 178 176 69 243 217 106 209 14 224 172 167 195 216 60 119 98 115 232 110 47 157 119 32 78 224 248 168 59 100 46 75 172 15 39 92 41 128 82 192 201 101 82 196 22 185 109 161 212 23 243 181 215 188 245 6 226 125 224 129 249 88 9 231 215 83 203 0 1 5 225 190 75 41 64 109 105 106 37 227 156 251 13 180 250 104 241 34 187 224 79 84 147 11 127 35 64 121 111 143 12 0 0 0 0 0 0 0 104 240 35 102 147 107 156 95 120 67 253 248 209 46 242 211 131 200 126 89 191 255 206 143 125 130 26 163 12 32 199 40 52 166 9 162 113 48 113 189 72 74 18 54 6 99 229 23 115 221 174 124 195 235 108 45 255 154 244 4 181 164 158 200 138 77 6 47 98 56 178 18 75 69 235 225 139 243 201 174 122 249 136 131 59 94 43 192 187 209 135 159 123 162 213 155 59 184 180 92 174 163 38 0 0 1 104 240 35 102 147 107 156 95 120 67 253 248 209 46 242 211 131 200 126 89 191 255 206 143 125 130 26 163 12 32 199 40 52 166 9 162 113 48 113 189 72 74 18 54 6 99 229 23 115 221 174 124 195 235 108 45 255 154 244 4 181 164 158 200 138 77 6 47 98 56 178 18 75 69 235 225 139 243 201 174 122 249 136 131 59 94 43 192 187 209 135 159 123 162 213 155 59 184 180 92 174 163 38 0 0 0 80 34 44 18 251 194 132 188 93 116 144 0 196 15 253 248 161 78 252 35 178 201 70 179 45 245 2 116 179 119 55 186 117 38 191 38 14 139 33 131 60 35 40 0 31 70 182 70 55 167 178 147 137 65 30 203 93 63 183 214 107 14 138 249 141 189 54 170 164 36 100 151 195 142 247 0 1 0 0 0 0 1 80 34 44 18 251 194 132 188 93 116 144 0 196 15 253 248 161 78 252 35 178 201 70 179 45 245 2 116 179 119 55 186 117 38 191 38 14 139 33 131 60 35 40 0 31 70 182 70 55 167 178 147 137 65 30 203 93 63 183 214 107 14 138 249 141 189 54 170 164 36 100 151 195 142 247 0 1 0 0 0 0 0 80 79 161 242 148 36 174 71 109 70 137 27 172 124 50 231 16 178 199 67 3 78 176 12 53 168 39 253 247 13 21 191 128 38 67 12 15 248 234 73 154 95 171 123 99 52 42 32 229 121 208 121 181 151 154 103 80 7 41 152 206 129 106 69 208 252 39 163 130 241 51 69 244 247 1 5 121 0 0 0 0 1 80 79 161 242 148 36 174 71 109 70 137 27 172 124 50 231 16 178 199 67 3 78 176 12 53 168 39 253 247 13 21 191 128 38 67 12 15 248 234 73 154 95 171 123 99 52 42 32 229 121 208 121 181 151 154 103 80 7 41 152 206 129 106 69 208 252 39 163 130 241 51 69 244 247 1 5 121 0 0 0 0 0 72 100 73 185 231 4 112 172 84 227 126 234 51 137 221 166 192 16 157 41 74 141 121 176 14 135 245 170 38 223 239 224 207 235 164 137 197 183 43 64 0 12 216 240 6 61 23 238 237 201 225 110 75 253 193 88 168 185 218 43 229 167 97 130 102 214 215 134 90 204 214 6 0 1 72 100 73 185 231 4 112 172 84 227 126 234 51 137 221 166 192 16 157 41 74 141 121 176 14 135 245 170 38 223 239 224 207 235 164 137 197 183 43 64 0 12 216 240 6 61 23 238 237 201 225 110 75 253 193 88 168 185 218 43 229 167 97 130 102 214 215 134 90 204 214 6 0 0 96 219 203 221 208 224 159 230 219 11 100 135 13 4 127 208 103 80 48 213 73 245 143 157 122 152 178 240 239 253 126 244 30 239 102 14 87 67 14 70 171 224 149 9 84 107 219 85 124 178 61 180 47 218 225 163 193 116 189 130 11 146 64 142 109 98 176 49 26 100 226 15 127 68 213 132 163 70 52 46 10 247 185 6 76 76 180 190 205 124 250 143 171 106 50 0 0 1 96 219 203 221 208 224 159 230 219 11 100 135 13 4 127 208 103 80 48 213 73 245 143 157 122 152 178 240 239 253 126 244 30 239 102 14 87 67 14 70 171 224 149 9 84 107 219 85 124 178 61 180 47 218 225 163 193 116 189 130 11 146 64 142 109 98 176 49 26 100 226 15 127 68 213 132 163 70 52 46 10 247 185 6 76 76 180 190 205 124 250 143 171 106 50 0 0 0 120 217 116 20 196 181 6 137 250 178 207 36 29 215 183 251 28 156 129 254 149 110 35 250 145 188 199 148 182 206 23 143 174 147 1 195 119 32 158 253 47 241 245 160 161 23 172 143 224 166 48 241 224 180 60 40 55 163 113 65 217 210 254 250 75 125 222 20 146 22 127 207 180 19 232 245 117 4 55 117 208 11 134 81 103 44 211 65 174 30 21 186 123 156 224 41 168 144 253 5 228 247 219 192 43 85 242 13 199 36 248 50 226 239 233 47 12 212 3 0 0 1 120 217 116 20 196 181 6 137 250 178 207 36 29 215 183 251 28 156 129 254 149 110 35 250 145 188 199 148 182 206 23 143 174 147 1 195 119 32 158 253 47 241 245 160 161 23 172 143 224 166 48 241 224 180 60 40 55 163 113 65 217 210 254 250 75 125 222 20 146 22 127 207 180 19 232 245 117 4 55 117 208 11 134 81 103 44 211 65 174 30 21 186 123 156 224 41 168 144 253 5 228 247 219 192 43 85 242 13 199 36 248 50 226 239 233 47 12 212 3 0 0 0 96 94 102 6 123 33 254 222 92 46 211 170 116 91 71 221 6 87 3 144 77 231 38 4 248 202 135 81 159 100 30 21 111 114 225 52 100 98 124 212 26 0 192 179 224 123 152 186 35 198 14 32 169 2 28 91 12 93 226 2 56 176 203 77 155 47 63 21 131 158 27 252 110 108 46 2 205 114 62 224 151 97 97 251 197 34 255 29 36 247 1 0 0 0 0 0 0 1 96 94 102 6 123 33 254 222 92 46 211 170 116 91 71 221 6 87 3 144 77 231 38 4 248 202 135 81 159 100 30 21 111 114 225 52 100 98 124 212 26 0 192 179 224 123 152 186 35 198 14 32 169 2 28 91 12 93 226 2 56 176 203 77 155 47 63 21 131 158 27 252 110 108 46 2 205 114 62 224 151 97 97 251 197 34 255 29 36 247 1 0 0 0 0 0 0 0 40 213 155 45 217 157 63 158 214 179 178 45 31 167 171 88 99 135 205 98 19 102 250 247 155 144 144 184 108 185 216 134 183 188 174 39 244 81 0 0 0 1 40 213 155 45 217 157 63 158 214 179 178 45 31 167 171 88 99 135 205 98 19 102 250 247 155 144 144 184 108 185 216 134 183 188 174 39 244 81 0 0 0 0 88 143 221 144 99 71 55 91 51 132 189 170 46 209 246 137 32 255 61 37 105 68 54 129 75 74 69 209 169 194 207 43 51 79 37 156 64 84 31 147 49 63 100 147 137 157 156 108 126 196 246 233 144 88 124 237 160 146 162 62 111 128 118 225 95 72 29 227 189 100 72 148 6 238 216 74 124 168 129 102 216 225 99 39 71 85 27 125 1 1 88 143 221 144 99 71 55 91 51 132 189 170 46 209 246 137 32 255 61 37 105 68 54 129 75 74 69 209 169 194 207 43 51 79 37 156 64 84 31 147 49 63 100 147 137 157 156 108 126 196 246 233 144 88 124 237 160 146 162 62 111 128 118 225 95 72 29 227 189 100 72 148 6 238 216 74 124 168 129 102 216 225 99 39 71 85 27 125 1 0 104 154 59 8 214 250 135 152 185 224 10 174 79 58 146 203 236 143 30 28 53 247 75 23 46 61 14 153 250 130 43 106 99 3 114 97 134 236 14 79 134 253 241 239 191 59 197 179 112 33 255 64 2 35 190 107 61 57 182 11 43 73 118 122 234 246 107 208 63 148 121 113 255 201 200 66 134 64 61 39 183 76 142 5 123 90 113 163 171 46 238 92 52 235 152 239 73 131 0 0 0 0 0 0 0 1 104 154 59 8 214 250 135 152 185 224 10 174 79 58 146 203 236 143 30 28 53 247 75 23 46 61 14 153 250 130 43 106 99 3 114 97 134 236 14 79 134 253 241 239 191 59 197 179 112 33 255 64 2 35 190 107 61 57 182 11 43 73 118 122 234 246 107 208 63 148 121 113 255 201 200 66 134 64 61 39 183 76 142 5 123 90 113 163 171 46 238 92 52 235 152 239 73 131 0 0 0 0 0 0 0 0 56 1 38 134 41 29 170 88 160 233 145 132 85 205 36 47 50 209 38 92 196 100 126 18 43 149 60 250 154 84 98 23 80 203 61 86 37 43 121 198 250 148 214 237 218 106 31 30 52 22 223 4 0 0 0 0 0 1 56 1 38 134 41 29 170 88 160 233 145 132 85 205 36 47 50 209 38 92 196 100 126 18 43 149 60 250 154 84 98 23 80 203 61 86 37 43 121 198 250 148 214 237 218 106 31 30 52 22 223 4 0 0 0 0 0 0 104 215 110 214 250 112 196 210 135 44 106 41 81 231 208 226 187 180 124 169 6 101 223 131 248 7 59 123 141 245 45 155 111 191 45 243 237 47 248 47 233 222 27 53 116 18 174 176 121 70 241 49 29 54 248 100 119 186 7 84 242 46 154 182 14 231 49 213 37 52 160 79 242 253 165 71 241 87 50 98 158 58 249 163 206 75 138 146 172 232 178 183 137 30 153 204 59 17 0 0 0 0 0 0 0 1 104 215 110 214 250 112 196 210 135 44 106 41 81 231 208 226 187 180 124 169 6 101 223 131 248 7 59 123 141 245 45 155 111 191 45 243 237 47 248 47 233 222 27 53 116 18 174 176 121 70 241 49 29 54 248 100 119 186 7 84 242 46 154 182 14 231 49 213 37 52 160 79 242 253 165 71 241 87 50 98 158 58 249 163 206 75 138 146 172 232 178 183 137 30 153 204 59 17 0 0 0 0 0 0 0 0 72 226 229 244 239 100 207 243 201 63 193 44 114 73 253 9 63 199 34 184 12 34 181 93 167 70 38 119 43 136 85 61 200 200 27 101 128 179 178 146 168 152 45 163 217 123 227 167 40 116 43 26 248 220 216 17 126 35 228 188 102 203 130 134 149 10 8 144 5 253 158 4 186 1 72 226 229 244 239 100 207 243 201 63 193 44 114 73 253 9 63 199 34 184 12 34 181 93 167 70 38 119 43 136 85 61 200 200 27 101 128 179 178 146 168 152 45 163 217 123 227 167 40 116 43 26 248 220 216 17 126 35 228 188 102 203 130 134 149 10 8 144 5 253 158 4 186 0 56 94 1 134 237 212 63 41 32 13 66 189 152 40 150 138 20 124 116 62 140 23 229 83 230 85 61 202 206 29 102 39 28 182 37 173 34 29 120 65 193 196 145 186 204 173 159 132 183 115 0 0 0 0 0 0 0 1 56 94 1 134 237 212 63 41 32 13 66 189 152 40 150 138 20 124 116 62 140 23 229 83 230 85 61 202 206 29 102 39 28 182 37 173 34 29 120 65 193 196 145 186 204 173 159 132 183 115 0 0 0 0 0 0 0 0 32 172 92 233 22 126 43 253 105 39 155 94 185 44 226 60 168 170 203 19 17 108 152 224 242 209 228 43 0 0 0 0 0 1 32 172 92 233 22 126 43 253 105 39 155 94 185 44 226 60 168 170 203 19 17 108 152 224 242 209 228 43 0 0 0 0 0 0 80 76 207 112 0 53 15 20 52 176 51 179 204 201 221 199 215 198 47 180 117 63 178 218 237 224 7 238 83 244 101 132 225 169 14 209 41 140 228 33 125 131 46 213 26 149 30 9 194 107 82 49 220 69 57 63 176 58 107 164 112 122 14 78 212 162 39 156 86 247 229 146 165 114 0 0 0 0 0 0 0 1 80 76 207 112 0 53 15 20 52 176 51 179 204 201 221 199 215 198 47 180 117 63 178 218 237 224 7 238 83 244 101 132 225 169 14 209 41 140 228 33 125 131 46 213 26 149 30 9 194 107 82 49 220 69 57 63 176 58 107 164 112 122 14 78 212 162 39 156 86 247 229 146 165 114 0 0 0 0 0 0 0 0 72 251 218 113 128 106 254 150 82 225 107 92 157 216 88 77 244 99 157 1 98 151 72 130 185 194 141 147 195 242 231 156 213 157 138 94 239 99 178 106 231 226 192 202 146 27 248 176 225 209 153 7 186 7 50 120 183 212 126 50 190 105 134 94 43 155 64 125 6 0 0 0 0 1 72 251 218 113 128 106 254 150 82 225 107 92 157 216 88 77 244 99 157 1 98 151 72 130 185 194 141 147 195 242 231 156 213 157 138 94 239 99 178 106 231 226 192 202 146 27 248 176 225 209 153 7 186 7 50 120 183 212 126 50 190 105 134 94 43 155 64 125 6 0 0 0 0 0 16 209 108 141 185 23 199 10 211 38 178 0 0 0 0 0 0 1 16 209 108 141 185 23 199 10 211 38 178 0 0 0 0 0 0 0 56 154 210 229 202 23 25 195 186 179 6 6 199 170 59 41 215 172 79 12 201 40 201 127 61 38 143 15 80 87 105 227 146 32 219 224 101 136 180 226 214 34 112 110 89 114 34 177 212 74 212 106 6 0 0 0 0 1 56 154 210 229 202 23 25 195 186 179 6 6 199 170 59 41 215 172 79 12 201 40 201 127 61 38 143 15 80 87 105 227 146 32 219 224 101 136 180 226 214 34 112 110 89 114 34 177 212 74 212 106 6 0 0 0 0 0 8 100 135 7 25 201 86 188 2 1 8 100 135 7 25 201 86 188 2 0 48 109 14 55 6 23 219 83 134 16 29 117 179 205 24 254 117 81 245 228 115 29 245 23 120 19 143 171 136 217 234 105 176 54 200 15 132 252 117 219 34 127 228 168 111 203 2 0 0 1 48 109 14 55 6 23 219 83 134 16 29 117 179 205 24 254 117 81 245 228 115 29 245 23 120 19 143 171 136 217 234 105 176 54 200 15 132 252 117 219 34 127 228 168 111 203 2 0 0 0 72 189 190 26 27 18 245 206 184 37 205 141 131 212 0 127 17 122 35 32 152 79 200 69 20 74 161 75 208 251 152 129 241 33 169 49 200 168 98 138 154 1 201 2 137 248 97 109 91 51 92 185 150 229 58 56 137 252 73 190 235 237 144 130 251 152 190 194 0 0 0 0 0 1 72 189 190 26 27 18 245 206 184 37 205 141 131 212 0 127 17 122 35 32 152 79 200 69 20 74 161 75 208 251 152 129 241 33 169 49 200 168 98 138 154 1 201 2 137 248 97 109 91 51 92 185 150 229 58 56 137 252 73 190 235 237 144 130 251 152 190 194 0 0 0 0 0 0 80 207 251 128 22 249 241 160 213 177 156 81 63 226 211 104 180 224 253 194 155 185 4 55 89 47 114 245 7 150 248 180 92 51 125 222 246 36 165 153 246 217 229 236 207 71 52 111 220 127 235 87 138 209 205 186 72 20 6 162 209 199 59 28 143 29 40 129 110 196 31 138 191 210 255 29 45 0 0 0 0 1 80 207 251 128 22 249 241 160 213 177 156 81 63 226 211 104 180 224 253 194 155 185 4 55 89 47 114 245 7 150 248 180 92 51 125 222 246 36 165 153 246 217 229 236 207 71 52 111 220 127 235 87 138 209 205 186 72 20 6 162 209 199 59 28 143 29 40 129 110 196 31 138 191 210 255 29 45 0 0 0 0 0 104 34 105 251 242 196 29 25 191 13 57 197 24 56 214 71 179 84 16 80 235 205 101 211 115 134 253 214 216 165 198 158 63 242 99 11 173 46 16 134 146 11 55 237 102 192 144 220 243 114 208 229 213 0 218 193 226 110 51 184 76 183 51 12 136 3 140 173 50 245 19 16 15 166 7 51 67 86 66 36 164 78 174 152 214 177 106 255 43 110 199 185 127 79 12 140 96 198 60 160 102 0 0 0 0 1 104 34 105 251 242 196 29 25 191 13 57 197 24 56 214 71 179 84 16 80 235 205 101 211 115 134 253 214 216 165 198 158 63 242 99 11 173 46 16 134 146 11 55 237 102 192 144 220 243 114 208 229 213 0 218 193 226 110 51 184 76 183 51 12 136 3 140 173 50 245 19 16 15 166 7 51 67 86 66 36 164 78 174 152 214 177 106 255 43 110 199 185 127 79 12 140 96 198 60 160 102 0 0 0 0 0 48 151 50 240 113 2 240 195 92 196 249 19 127 144 80 105 89 196 158 41 252 36 228 125 87 223 38 175 180 160 171 217 8 107 79 15 49 18 96 89 233 92 36 110 25 144 127 0 0 1 48 151 50 240 113 2 240 195 92 196 249 19 127 144 80 105 89 196 158 41 252 36 228 125 87 223 38 175 180 160 171 217 8 107 79 15 49 18 96 89 233 92 36 110 25 144 127 0 0 0 120 220 111 204 84 44 130 217 213 198 206 117 146 194 10 147 26 202 239 193 244 37 205 135 142 56 32 249 87 168 225 194 69 224 42 44 177 94 77 94 53 91 119 184 126 54 91 178 96 62 34 235 141 251 16 10 187 157 41 198 141 167 60 123 73 194 190 232 21 131 122 95 94 19 80 131 0 80 156 191 71 14 30 148 74 123 179 226 24 229 233 126 54 51 237 55 92 191 74 239 104 108 155 8 161 36 74 77 55 133 160 139 207 243 154 53 85 221 49 167 10 1 120 220 111 204 84 44 130 217 213 198 206 117 146 194 10 147 26 202 239 193 244 37 205 135 142 56 32 249 87 168 225 194 69 224 42 44 177 94 77 94 53 91 119 184 126 54 91 178 96 62 34 235 141 251 16 10 187 157 41 198 141 167 60 123 73 194 190 232 21 131 122 95 94 19 80 131 0 80 156 191 71 14 30 148 74 123 179 226 24 229 233 126 54 51 237 55 92 191 74 239 104 108 155 8 161 36 74 77 55 133 160 139 207 243 154 53 85 221 49 167 10 0 128 66 181 48 69 164 115 164 70 89 243 215 101 175 87 235 67 90 105 180 75 47 179 125 207 87 227 224 42 29 17 96 44 75 24 133 40 113 24 135 93 121 59 20 187 166 95 86 53 166 161 86 99 27 119 194 156 39 207 117 76 162 208 78 38 249 64 104 247 119 216 98 220 191 85 93 88 71 67 153 91 210 137 198 13 84 67 129 197 58 103 183 253 111 51 7 9 158 89 134 12 78 19 173 133 159 221 103 18 198 238 156 111 121 141 61 104 245 244 206 7 118 23 61 26 0 0 0 0 1 128 66 181 48 69 164 115 164 70 89 243 215 101 175 87 235 67 90 105 180 75 47 179 125 207 87 227 224 42 29 17 96 44 75 24 133 40 113 24 135 93 121 59 20 187 166 95 86 53 166 161 86 99 27 119 194 156 39 207 117 76 162 208 78 38 249 64 104 247 119 216 98 220 191 85 93 88 71 67 153 91 210 137 198 13 84 67 129 197 58 103 183 253 111 51 7 9 158 89 134 12 78 19 173 133 159 221 103 18 198 238 156 111 121 141 61 104 245 244 206 7 118 23 61 26 0 0 0 0 0 24 53 158 199 70 207 47 204 168 124 200 230 150 58 31 240 105 24 0 0 0 0 0 0 0 1 24 53 158 199 70 207 47 204 168 124 200 230 150 58 31 240 105 24 0 0 0 0 0 0 0 0 24 44 216 57 222 28 184 85 185 207 83 175 57 221 190 218 247 150 5 9 117 0 0 0 0 1 24 44 216 57 222 28 184 85 185 207 83 175 57 221 190 218 247 150 5 9 117 0 0 0 0 0 80 175 96 135 121 157 156 226 243 56 243 161 244 255 180 122 46 138 241 238 214 239 108 19 34 52 247 13 21 71 51 38 3 155 181 28 151 11 194 1 127 89 168 237 141 215 157 75 68 132 79 117 113 7 76 199 243 237 109 44 236 225 116 106 60 77 216 199 25 21 97 116 178 189 0 0 0 0 0 0 0 1 80 175 96 135 121 157 156 226 243 56 243 161 244 255 180 122 46 138 241 238 214 239 108 19 34 52 247 13 21 71 51 38 3 155 181 28 151 11 194 1 127 89 168 237 141 215 157 75 68 132 79 117 113 7 76 199 243 237 109 44 236 225 116 106 60 77 216 199 25 21 97 116 178 189 0 0 0 0 0 0 0 0 56 202 229 137 148 154 5 233 137 136 40 13 16 169 117 12 152 29 203 90 68 73 225 131 236 45 230 124 112 148 9 55 131 227 132 115 213 238 10 238 61 255 35 176 204 139 43 31 180 151 38 28 0 0 0 0 0 1 56 202 229 137 148 154 5 233 137 136 40 13 16 169 117 12 152 29 203 90 68 73 225 131 236 45 230 124 112 148 9 55 131 227 132 115 213 238 10 238 61 255 35 176 204 139 43 31 180 151 38 28 0 0 0 0 0 0 64 235 98 102 1 125 196 43 138 213 140 187 232 56 154 133 53 67 83 164 240 80 16 61 51 160 252 62 34 180 200 255 184 169 84 36 69 72 6 78 7 150 152 1 13 250 97 34 132 97 157 173 219 115 157 86 128 104 9 243 111 0 0 0 0 1 64 235 98 102 1 125 196 43 138 213 140 187 232 56 154 133 53 67 83 164 240 80 16 61 51 160 252 62 34 180 200 255 184 169 84 36 69 72 6 78 7 150 152 1 13 250 97 34 132 97 157 173 219 115 157 86 128 104 9 243 111 0 0 0 0 0 56 110 238 199 119 170 141 33 211 193 225 211 65 71 230 113 169 249 100 145 146 90 130 63 193 239 121 202 133 82 133 133 53 185 111 84 99 172 253 212 36 243 170 231 244 134 94 195 226 84 11 0 0 0 0 0 0 1 56 110 238 199 119 170 141 33 211 193 225 211 65 71 230 113 169 249 100 145 146 90 130 63 193 239 121 202 133 82 133 133 53 185 111 84 99 172 253 212 36 243 170 231 244 134 94 195 226 84 11 0 0 0 0 0 0 0 8 106 26 0 0 0 0 0 0 1 8 106 26 0 0 0 0 0 0 0 96 55 152 73 157 134 83 107 104 157 196 53 164 2 160 29 214 41 144 154 185 26 161 178 109 113 19 105 96 157 167 54 34 103 42 200 114 164 164 104 227 67 103 2 210 8 116 188 135 174 40 62 91 190 166 226 195 250 41 221 152 30 57 61 233 241 101 130 10 63 191 169 19 148 16 188 139 65 132 105 232 99 49 96 137 153 204 114 212 66 194 182 129 146 0 0 0 1 96 55 152 73 157 134 83 107 104 157 196 53 164 2 160 29 214 41 144 154 185 26 161 178 109 113 19 105 96 157 167 54 34 103 42 200 114 164 164 104 227 67 103 2 210 8 116 188 135 174 40 62 91 190 166 226 195 250 41 221 152 30 57 61 233 241 101 130 10 63 191 169 19 148 16 188 139 65 132 105 232 99 49 96 137 153 204 114 212 66 194 182 129 146 0 0 0 0 48 215 234 168 32 222 91 186 69 25 72 240 30 59 198 171 46 112 186 148 235 6 205 150 234 108 20 173 83 144 129 239 167 253 152 161 53 229 15 251 248 211 51 238 4 0 0 0 0 1 48 215 234 168 32 222 91 186 69 25 72 240 30 59 198 171 46 112 186 148 235 6 205 150 234 108 20 173 83 144 129 239 167 253 152 161 53 229 15 251 248 211 51 238 4 0 0 0 0 0 56 189 135 39 96 175 218 106 164 199 43 5 248 111 65 179 200 109 31 254 255 126 80 190 92 65 237 178 43 23 153 58 10 9 97 226 246 198 243 117 174 24 218 33 231 128 164 157 128 151 190 0 0 0 0 0 0 1 56 189 135 39 96 175 218 106 164 199 43 5 248 111 65 179 200 109 31 254 255 126 80 190 92 65 237 178 43 23 153 58 10 9 97 226 246 198 243 117 174 24 218 33 231 128 164 157 128 151 190 0 0 0 0 0 0 0 24 239 56 183 78 45 154 165 142 40 239 207 3 167 77 151 86 239 3 11 209 79 0 0 0 1 24 239 56 183 78 45 154 165 142 40 239 207 3 167 77 151 86 239 3 11 209 79 0 0 0 0 120 130 184 128 68 207 249 83 80 33 163 142 32 202 202 145 151 232 83 195 182 58 116 163 243 175 189 47 35 208 19 5 175 59 26 2 94 105 183 66 152 203 200 32 2 26 199 8 181 211 38 92 194 207 149 100 136 89 145 224 231 176 230 123 222 97 24 81 114 242 42 179 218 87 154 251 235 53 36 114 72 81 186 89 13 87 192 22 111 97 8 245 31 80 244 208 101 196 210 93 76 175 182 133 13 74 7 144 34 186 229 253 42 25 120 196 253 145 203 34 0 1 120 130 184 128 68 207 249 83 80 33 163 142 32 202 202 145 151 232 83 195 182 58 116 163 243 175 189 47 35 208 19 5 175 59 26 2 94 105 183 66 152 203 200 32 2 26 199 8 181 211 38 92 194 207 149 100 136 89 145 224 231 176 230 123 222 97 24 81 114 242 42 179 218 87 154 251 235 53 36 114 72 81 186 89 13 87 192 22 111 97 8 245 31 80 244 208 101 196 210 93 76 175 182 133 13 74 7 144 34 186 229 253 42 25 120 196 253 145 203 34 0 0 104 177 43 20 0 140 140 47 23 231 84 40 77 91 102 55 158 233 117 153 218 25 252 97 80 128 163 220 227 30 148 92 31 92 123 175 218 18 184 223 122 242 27 52 233 221 142 227 84 175 165 149 51 30 52 3 112 242 251 194 123 45 37 79 48 197 65 154 217 117 129 115 239 202 140 4 219 13 126 27 135 146 152 96 151 82 124 223 118 24 195 194 175 191 121 134 29 81 56 114 151 40 33 0 0 1 104 177 43 20 0 140 140 47 23 231 84 40 77 91 102 55 158 233 117 153 218 25 252 97 80 128 163 220 227 30 148 92 31 92 123 175 218 18 184 223 122 242 27 52 233 221 142 227 84 175 165 149 51 30 52 3 112 242 251 194 123 45 37 79 48 197 65 154 217 117 129 115 239 202 140 4 219 13 126 27 135 146 152 96 151 82 124 223 118 24 195 194 175 191 121 134 29 81 56 114 151 40 33 0 0 0 56 226 202 173 6 149 116 30 177 236 7 160 65 73 122 165 121 36 223 128 217 110 236 2 31 124 183 89 207 252 6 59 84 137 76 50 38 76 184 223 208 6 130 201 233 242 76 37 234 218 223 126 70 103 75 198 17 1 56 226 202 173 6 149 116 30 177 236 7 160 65 73 122 165 121 36 223 128 217 110 236 2 31 124 183 89 207 252 6 59 84 137 76 50 38 76 184 223 208 6 130 201 233 242 76 37 234 218 223 126 70 103 75 198 17 0 40 143 226 94 34 87 62 30 33 239 85 79 57 245 111 192 126 163 234 125 86 103 149 210 150 242 12 158 215 135 158 29 55 151 47 136 29 80 31 37 252 1 40 143 226 94 34 87 62 30 33 239 85 79 57 245 111 192 126 163 234 125 86 103 149 210 150 242 12 158 215 135 158 29 55 151 47 136 29 80 31 37 252 0 112 181 27 23 157 82 76 57 33 149 24 89 155 221 152 127 94 66 164 208 210 148 182 78 234 184 210 234 72 255 16 100 229 47 58 156 105 247 59 66 253 245 169 65 48 79 130 122 51 190 191 81 1 34 200 63 2 65 127 95 41 111 129 132 49 253 173 167 197 104 55 130 14 224 162 119 109 66 142 188 11 186 58 39 173 207 179 212 181 61 158 3 218 40 241 226 184 47 0 88 220 135 180 224 61 164 169 34 189 151 91 0 0 1 112 181 27 23 157 82 76 57 33 149 24 89 155 221 152 127 94 66 164 208 210 148 182 78 234 184 210 234 72 255 16 100 229 47 58 156 105 247 59 66 253 245 169 65 48 79 130 122 51 190 191 81 1 34 200 63 2 65 127 95 41 111 129 132 49 253 173 167 197 104 55 130 14 224 162 119 109 66 142 188 11 186 58 39 173 207 179 212 181 61 158 3 218 40 241 226 184 47 0 88 220 135 180 224 61 164 169 34 189 151 91 0 0 0 72 245 37 28 124 5 215 158 136 244 187 142 156 141 44 84 13 112 140 11 136 159 80 12 232 82 107 30 135 75 126 13 223 106 21 218 151 253 45 223 202 227 61 206 171 121 209 68 8 191 131 100 178 102 54 84 51 65 145 226 154 248 80 115 68 154 209 63 76 0 0 0 0 1 72 245 37 28 124 5 215 158 136 244 187 142 156 141 44 84 13 112 140 11 136 159 80 12 232 82 107 30 135 75 126 13 223 106 21 218 151 253 45 223 202 227 61 206 171 121 209 68 8 191 131 100 178 102 54 84 51 65 145 226 154 248 80 115 68 154 209 63 76 0 0 0 0 0 80 135 137 38 34 14 3 46 79 186 179 131 28 57 25 247 29 19 45 197 193 203 121 109 165 119 101 172 185 115 171 154 177 182 27 155 85 37 5 182 213 87 183 42 234 134 15 60 0 46 192 218 165 41 22 150 148 218 236 133 178 67 163 140 233 134 213 210 71 193 23 166 26 63 204 170 123 79 127 246 26 1 80 135 137 38 34 14 3 46 79 186 179 131 28 57 25 247 29 19 45 197 193 203 121 109 165 119 101 172 185 115 171 154 177 182 27 155 85 37 5 182 213 87 183 42 234 134 15 60 0 46 192 218 165 41 22 150 148 218 236 133 178 67 163 140 233 134 213 210 71 193 23 166 26 63 204 170 123 79 127 246 26 0 24 161 11 98 151 34 241 111 106 193 28 3 100 220 97 185 34 185 14 129 244 209 10 0 0 1 24 161 11 98 151 34 241 111 106 193 28 3 100 220 97 185 34 185 14 129 244 209 10 0 0 0 16 130 229 241 126 185 171 21 95 192 161 17 185 7 19 79 20 1 16 130 229 241 126 185 171 21 95 192 161 17 185 7 19 79 20 0 80 9 13 228 66 211 156 80 135 182 180 214 181 47 183 227 46 41 12 246 131 232 90 158 5 19 60 63 252 117 169 61 164 189 193 27 141 183 254 18 152 59 130 30 176 181 167 165 190 60 186 198 100 145 152 47 75 69 203 253 237 35 74 191 49 205 55 93 241 175 147 35 169 57 234 147 255 216 2 0 0 1 80 9 13 228 66 211 156 80 135 182 180 214 181 47 183 227 46 41 12 246 131 232 90 158 5 19 60 63 252 117 169 61 164 189 193 27 141 183 254 18 152 59 130 30 176 181 167 165 190 60 186 198 100 145 152 47 75 69 203 253 237 35 74 191 49 205 55 93 241 175 147 35 169 57 234 147 255 216 2 0 0 0 64 141 139 202 76 43 47 180 136 161 170 209 0 136 207 136 36 208 145 71 130 83 221 226 101 19 151 187 159 109 224 255 62 88 129 165 22 98 27 176 90 80 16 65 129 69 250 183 187 147 190 130 199 5 11 138 101 83 65 161 2 6 0 0 0 1 64 141 139 202 76 43 47 180 136 161 170 209 0 136 207 136 36 208 145 71 130 83 221 226 101 19 151 187 159 109 224 255 62 88 129 165 22 98 27 176 90 80 16 65 129 69 250 183 187 147 190 130 199 5 11 138 101 83 65 161 2 6 0 0 0 0 40 187 72 171 67 22 57 200 41 156 125 20 118 214 230 17 121 132 100 6 245 170 66 142 117 245 148 173 113 251 22 92 19 155 30 0 0 0 0 0 0 1 40 187 72 171 67 22 57 200 41 156 125 20 118 214 230 17 121 132 100 6 245 170 66 142 117 245 148 173 113 251 22 92 19 155 30 0 0 0 0 0 0 0 48 101 58 72 216 138 4 45 140 222 69 239 13 13 50 235 67 209 36 214 49 165 77 35 96 140 27 164 215 181 180 73 146 42 130 29 96 159 153 232 94 77 175 255 20 0 0 0 0 1 48 101 58 72 216 138 4 45 140 222 69 239 13 13 50 235 67 209 36 214 49 165 77 35 96 140 27 164 215 181 180 73 146 42 130 29 96 159 153 232 94 77 175 255 20 0 0 0 0 0 88 219 224 155 211 221 151 19 144 234 158 11 45 122 35 132 149 62 141 108 208 26 84 49 255 193 206 21 192 119 23 25 107 230 224 23 255 211 84 131 200 163 22 3 191 95 246 22 164 37 9 116 62 212 138 8 160 64 31 218 139 106 242 89 216 218 255 147 91 71 129 205 194 18 209 161 119 85 170 226 225 162 83 212 20 0 0 0 0 1 88 219 224 155 211 221 151 19 144 234 158 11 45 122 35 132 149 62 141 108 208 26 84 49 255 193 206 21 192 119 23 25 107 230 224 23 255 211 84 131 200 163 22 3 191 95 246 22 164 37 9 116 62 212 138 8 160 64 31 218 139 106 242 89 216 218 255 147 91 71 129 205 194 18 209 161 119 85 170 226 225 162 83 212 20 0 0 0 0 0 72 14 156 116 249 212 16 111 35 17 9 212 224 210 14 154 158 72 254 112 138 10 30 123 27 209 114 67 151 154 58 185 70 230 39 91 161 175 96 144 42 108 176 175 129 131 222 206 150 81 39 184 66 31 183 226 159 121 73 128 206 177 92 204 53 155 0 167 103 0 0 0 0 1 72 14 156 116 249 212 16 111 35 17 9 212 224 210 14 154 158 72 254 112 138 10 30 123 27 209 114 67 151 154 58 185 70 230 39 91 161 175 96 144 42 108 176 175 129 131 222 206 150 81 39 184 66 31 183 226 159 121 73 128 206 177 92 204 53 155 0 167 103 0 0 0 0 0 96 24 127 183 77 135 143 95 88 89 95 188 40 117 29 239 121 158 197 98 117 88 96 129 197 2 191 220 182 209 38 73 53 151 197 255 5 2 62 107 10 40 43 253 32 105 98 219 212 155 202 52 7 137 199 16 43 208 83 186 41 89 60 249 93 40 107 182 175 147 127 53 185 207 74 51 82 246 167 59 57 221 250 206 122 32 222 85 116 2 0 0 0 0 0 0 0 1 96 24 127 183 77 135 143 95 88 89 95 188 40 117 29 239 121 158 197 98 117 88 96 129 197 2 191 220 182 209 38 73 53 151 197 255 5 2 62 107 10 40 43 253 32 105 98 219 212 155 202 52 7 137 199 16 43 208 83 186 41 89 60 249 93 40 107 182 175 147 127 53 185 207 74 51 82 246 167 59 57 221 250 206 122 32 222 85 116 2 0 0 0 0 0 0 0 0 96 147 237 31 71 216 196 26 132 246 73 163 25 96 43 245 7 209 8 5 54 169 7 250 78 177 89 40 0 243 40 2 158 24 11 198 234 171 172 170 64 188 187 101 123 162 237 222 202 89 40 19 173 38 211 166 45 226 3 80 235 195 110 200 92 16 163 19 117 163 211 172 5 18 87 238 191 193 83 143 189 110 113 70 107 147 246 94 49 35 15 198 45 0 0 0 0 1 96 147 237 31 71 216 196 26 132 246 73 163 25 96 43 245 7 209 8 5 54 169 7 250 78 177 89 40 0 243 40 2 158 24 11 198 234 171 172 170 64 188 187 101 123 162 237 222 202 89 40 19 173 38 211 166 45 226 3 80 235 195 110 200 92 16 163 19 117 163 211 172 5 18 87 238 191 193 83 143 189 110 113 70 107 147 246 94 49 35 15 198 45 0 0 0 0 0 96 64 61 164 44 87 227 172 18 31 65 156 146 28 18 93 184 64 206 182 188 247 38 246 148 197 40 179 134 87 253 99 200 144 207 105 35 236 191 211 141 2 166 22 69 97 111 181 148 114 108 196 62 4 205 40 5 94 207 78 159 83 52 193 205 124 45 112 37 168 234 114 146 238 213 231 94 67 171 153 42 253 122 194 188 137 165 213 50 253 178 210 172 158 19 49 97 1 96 64 61 164 44 87 227 172 18 31 65 156 146 28 18 93 184 64 206 182 188 247 38 246 148 197 40 179 134 87 253 99 200 144 207 105 35 236 191 211 141 2 166 22 69 97 111 181 148 114 108 196 62 4 205 40 5 94 207 78 159 83 52 193 205 124 45 112 37 168 234 114 146 238 213 231 94 67 171 153 42 253 122 194 188 137 165 213 50 253 178 210 172 158 19 49 97 0 128 18 25 43 69 203 163 208 25 129 70 179 87 12 27 80 85 159 26 23 217 250 145 72 121 50 16 37 139 240 158 153 146 201 8 164 249 47 152 57 202 235 15 58 45 34 201 248 69 113 190 138 170 65 10 208 146 132 110 25 228 113 14 229 109 123 49 220 88 192 96 240 71 116 139 193 10 198 27 240 251 107 253 255 213 42 221 24 113 228 220 232 119 71 248 233 220 92 90 99 190 197 160 163 32 110 191 182 102 164 156 66 22 63 71 173 246 104 8 68 245 41 178 81 182 144 193 28 0 1 128 18 25 43 69 203 163 208 25 129 70 179 87 12 27 80 85 159 26 23 217 250 145 72 121 50 16 37 139 240 158 153 146 201 8 164 249 47 152 57 202 235 15 58 45 34 201 248 69 113 190 138 170 65 10 208 146 132 110 25 228 113 14 229 109 123 49 220 88 192 96 240 71 116 139 193 10 198 27 240 251 107 253 255 213 42 221 24 113 228 220 232 119 71 248 233 220 92 90 99 190 197 160 163 32 110 191 182 102 164 156 66 22 63 71 173 246 104 8 68 245 41 178 81 182 144 193 28 0 0 64 106 111 228 235 51 226 122 218 7 64 133 195 240 189 43 175 243 131 132 104 152 3 70 2 1 203 253 95 8 193 163 40 223 43 68 152 88 4 207 245 179 156 172 179 217 24 72 255 34 91 50 116 117 25 16 159 79 126 0 0 0 0 0 0 1 64 106 111 228 235 51 226 122 218 7 64 133 195 240 189 43 175 243 131 132 104 152 3 70 2 1 203 253 95 8 193 163 40 223 43 68 152 88 4 207 245 179 156 172 179 217 24 72 255 34 91 50 116 117 25 16 159 79 126 0 0 0 0 0 0 0 96 242 78 165 200 211 109 6 120 204 217 25 19 113 152 179 73 130 49 149 173 66 167 106 162 150 87 123 191 217 234 1 44 116 181 9 66 210 127 251 186 48 185 108 188 94 122 96 63 201 235 22 186 67 42 225 10 180 91 176 96 61 82 61 81 28 92 254 57 197 179 147 78 166 147 71 129 176 7 57 241 168 104 58 31 131 207 114 100 228 122 222 33 1 0 0 0 1 96 242 78 165 200 211 109 6 120 204 217 25 19 113 152 179 73 130 49 149 173 66 167 106 162 150 87 123 191 217 234 1 44 116 181 9 66 210 127 251 186 48 185 108 188 94 122 96 63 201 235 22 186 67 42 225 10 180 91 176 96 61 82 61 81 28 92 254 57 197 179 147 78 166 147 71 129 176 7 57 241 168 104 58 31 131 207 114 100 228 122 222 33 1 0 0 0 0 16 97 77 106 250 36 19 39 116 255 76 19 0 0 0 0 0 1 16 97 77 106 250 36 19 39 116 255 76 19 0 0 0 0 0 0 120 111 83 184 168 71 100 200 47 99 200 7 122 64 223 9 88 127 36 176 17 86 69 21 128 134 171 205 233 96 184 231 129 34 199 145 56 105 1 143 43 41 220 152 215 178 124 68 220 20 206 108 104 17 70 117 37 42 80 169 70 134 89 10 29 153 175 13 143 30 175 166 31 179 51 111 40 201 178 167 176 195 238 36 55 237 111 116 105 132 211 219 6 26 164 101 240 113 151 131 108 247 150 189 114 192 163 218 28 145 0 191 98 2 111 27 49 39 0 0 0 1 120 111 83 184 168 71 100 200 47 99 200 7 122 64 223 9 88 127 36 176 17 86 69 21 128 134 171 205 233 96 184 231 129 34 199 145 56 105 1 143 43 41 220 152 215 178 124 68 220 20 206 108 104 17 70 117 37 42 80 169 70 134 89 10 29 153 175 13 143 30 175 166 31 179 51 111 40 201 178 167 176 195 238 36 55 237 111 116 105 132 211 219 6 26 164 101 240 113 151 131 108 247 150 189 114 192 163 218 28 145 0 191 98 2 111 27 49 39 0 0 0 0 32 81 112 148 108 23 32 68 197 136 108 75 125 74 153 138 193 143 46 240 12 147 141 114 195 168 154 52 204 254 27 0 0 1 32 81 112 148 108 23 32 68 197 136 108 75 125 74 153 138 193 143 46 240 12 147 141 114 195 168 154 52 204 254 27 0 0 0 72 229 45 84 95 24 25 32 216 165 111 25 116 164 115 152 232 97 207 181 82 250 83 172 4 143 100 89 243 176 103 143 89 97 174 71 138 98 227 83 33 167 157 210 208 119 156 79 89 223 158 79 207 126 107 230 151 179 67 137 75 82 190 93 51 33 0 0 0 0 0 0 0 1 72 229 45 84 95 24 25 32 216 165 111 25 116 164 115 152 232 97 207 181 82 250 83 172 4 143 100 89 243 176 103 143 89 97 174 71 138 98 227 83 33 167 157 210 208 119 156 79 89 223 158 79 207 126 107 230 151 179 67 137 75 82 190 93 51 33 0 0 0 0 0 0 0 0 120 221 101 250 13 148 219 147 8 203 24 156 18 193 222 45 207 235 157 11 245 111 54 46 193 242 190 64 24 32 5 137 205 125 176 100 17 201 24 239 205 106 167 230 189 153 124 31 64 237 182 168 183 7 51 170 88 147 80 176 116 117 47 23 224 52 179 41 43 139 109 178 28 245 173 29 90 7 170 105 16 115 2 213 39 87 247 94 160 195 0 33 49 96 68 43 87 69 180 255 100 174 99 176 29 24 104 158 236 125 224 97 89 243 65 242 94 178 0 0 0 1 120 221 101 250 13 148 219 147 8 203 24 156 18 193 222 45 207 235 157 11 245 111 54 46 193 242 190 64 24 32 5 137 205 125 176 100 17 201 24 239 205 106 167 230 189 153 124 31 64 237 182 168 183 7 51 170 88 147 80 176 116 117 47 23 224 52 179 41 43 139 109 178 28 245 173 29 90 7 170 105 16 115 2 213 39 87 247 94 160 195 0 33 49 96 68 43 87 69 180 255 100 174 99 176 29 24 104 158 236 125 224 97 89 243 65 242 94 178 0 0 0 0 72 184 253 189 224 206 45 217 58 19 82 204 156 74 148 217 108 38 0 212 209 189 122 237 87 236 106 6 235 35 39 176 243 21 191 101 210 52 159 254 224 228 116 193 110 127 138 238 156 91 101 182 243 43 212 2 192 249 29 46 143 26 92 106 122 73 98 4 82 141 13 112 16 1 72 184 253 189 224 206 45 217 58 19 82 204 156 74 148 217 108 38 0 212 209 189 122 237 87 236 106 6 235 35 39 176 243 21 191 101 210 52 159 254 224 228 116 193 110 127 138 238 156 91 101 182 243 43 212 2 192 249 29 46 143 26 92 106 122 73 98 4 82 141 13 112 16 0 24 141 65 210 229 224 235 23 20 177 164 60 252 191 64 31 44 84 216 95 0 0 0 0 0 1 24 141 65 210 229 224 235 23 20 177 164 60 252 191 64 31 44 84 216 95 0 0 0 0 0 0 72 48 154 41 124 74 158 181 70 130 132 240 230 198 88 167 2 237 114 242 9 139 158 87 188 104 154 110 210 176 38 252 92 77 243 54 213 93 179 111 60 173 65 242 154 5 78 138 79 93 20 212 247 205 148 243 182 244 13 15 150 159 207 103 38 24 0 0 0 0 0 0 0 1 72 48 154 41 124 74 158 181 70 130 132 240 230 198 88 167 2 237 114 242 9 139 158 87 188 104 154 110 210 176 38 252 92 77 243 54 213 93 179 111 60 173 65 242 154 5 78 138 79 93 20 212 247 205 148 243 182 244 13 15 150 159 207 103 38 24 0 0 0 0 0 0 0 0 112 78 251 44 163 60 65 61 73 160 130 160 8 28 61 196 90 12 152 7 115 142 7 114 17 198 170 252 19 236 254 162 201 32 45 18 43 189 44 46 90 207 184 59 237 162 203 126 224 42 136 170 154 0 222 28 154 135 82 229 44 204 68 59 154 17 125 179 36 205 42 28 134 10 215 115 12 32 14 56 173 76 9 183 175 169 7 152 168 55 94 109 58 166 129 180 156 71 14 106 140 11 108 205 121 170 23 0 0 0 0 0 0 1 112 78 251 44 163 60 65 61 73 160 130 160 8 28 61 196 90 12 152 7 115 142 7 114 17 198 170 252 19 236 254 162 201 32 45 18 43 189 44 46 90 207 184 59 237 162 203 126 224 42 136 170 154 0 222 28 154 135 82 229 44 204 68 59 154 17 125 179 36 205 42 28 134 10 215 115 12 32 14 56 173 76 9 183 175 169 7 152 168 55 94 109 58 166 129 180 156 71 14 106 140 11 108 205 121 170 23 0 0 0 0 0 0 0 64 99 133 203 247 192 63 4 144 228 175 21 211 17 186 191 58 203 241 243 89 132 220 36 39 238 217 164 218 253 0 222 143 219 114 227 127 56 66 234 167 126 143 213 130 213 113 84 86 215 204 56 188 57 9 152 64 225 239 108 6 0 0 0 0 1 64 99 133 203 247 192 63 4 144 228 175 21 211 17 186 191 58 203 241 243 89 132 220 36 39 238 217 164 218 253 0 222 143 219 114 227 127 56 66 234 167 126 143 213 130 213 113 84 86 215 204 56 188 57 9 152 64 225 239 108 6 0 0 0 0 0 72 77 228 188 235 97 138 100 91 238 49 139 79 56 188 11 184 173 83 39 221 20 245 96 38 125 60 181 72 3 128 43 118 106 90 15 200 8 233 181 34 5 7 174 190 71 134 170 210 207 164 152 232 51 89 112 82 165 188 21 114 191 123 230 238 197 193 95 140 244 0 0 0 1 72 77 228 188 235 97 138 100 91 238 49 139 79 56 188 11 184 173 83 39 221 20 245 96 38 125 60 181 72 3 128 43 118 106 90 15 200 8 233 181 34 5 7 174 190 71 134 170 210 207 164 152 232 51 89 112 82 165 188 21 114 191 123 230 238 197 193 95 140 244 0 0 0 0 72 200 145 197 200 104 129 137 228 214 164 61 15 232 3 217 235 218 189 116 152 154 227 248 233 253 158 5 97 255 64 215 227 139 23 14 251 106 37 121 16 114 173 198 111 218 117 222 246 94 169 123 172 250 61 68 19 205 181 67 85 17 104 14 254 137 136 84 247 78 166 0 0 1 72 200 145 197 200 104 129 137 228 214 164 61 15 232 3 217 235 218 189 116 152 154 227 248 233 253 158 5 97 255 64 215 227 139 23 14 251 106 37 121 16 114 173 198 111 218 117 222 246 94 169 123 172 250 61 68 19 205 181 67 85 17 104 14 254 137 136 84 247 78 166 0 0 0 128 191 181 108 55 139 94 198 152 77 78 82 43 3 109 236 227 118 234 47 173 167 61 164 86 55 233 192 147 235 37 168 97 183 33 155 177 136 201 235 222 168 48 190 137 110 204 183 228 175 147 199 33 208 144 139 202 91 20 77 67 243 128 152 254 108 127 176 61 57 40 166 158 31 208 193 11 83 26 80 21 170 235 14 210 177 151 96 197 239 137 246 114 65 165 208 148 237 25 245 124 152 104 92 83 194 136 203 136 100 251 64 2 205 220 145 219 198 171 222 38 134 250 16 34 65 224 146 28 1 128 191 181 108 55 139 94 198 152 77 78 82 43 3 109 236 227 118 234 47 173 167 61 164 86 55 233 192 147 235 37 168 97 183 33 155 177 136 201 235 222 168 48 190 137 110 204 183 228 175 147 199 33 208 144 139 202 91 20 77 67 243 128 152 254 108 127 176 61 57 40 166 158 31 208 193 11 83 26 80 21 170 235 14 210 177 151 96 197 239 137 246 114 65 165 208 148 237 25 245 124 152 104 92 83 194 136 203 136 100 251 64 2 205 220 145 219 198 171 222 38 134 250 16 34 65 224 146 28 0 64 63 224 19 125 187 26 164 208 55 163 27 59 187 247 242 95 30 57 122 111 64 134 84 248 151 190 15 136 136 161 61 28 228 22 27 68 11 3 140 252 156 29 4 41 11 48 15 96 244 213 20 233 6 76 130 58 119 15 0 0 0 0 0 0 1 64 63 224 19 125 187 26 164 208 55 163 27 59 187 247 242 95 30 57 122 111 64 134 84 248 151 190 15 136 136 161 61 28 228 22 27 68 11 3 140 252 156 29 4 41 11 48 15 96 244 213 20 233 6 76 130 58 119 15 0 0 0 0 0 0 0 16 199 42 98 80 178 185 90 221 165 35 3 0 0 0 0 0 1 16 199 42 98 80 178 185 90 221 165 35 3 0 0 0 0 0 0 112 211 92 224 84 192 161 220 29 37 84 220 160 179 136 96 15 250 25 26 167 119 216 78 12 23 28 94 80 65 148 105 37 226 205 178 88 179 130 190 233 252 123 197 227 186 157 58 116 47 213 216 8 19 202 72 179 134 248 62 205 139 137 198 65 155 154 205 249 99 56 187 14 119 158 233 203 37 34 208 100 56 19 122 70 223 132 177 96 84 56 150 254 49 2 204 7 119 253 28 226 37 130 47 153 193 3 66 88 188 3 0 0 1 112 211 92 224 84 192 161 220 29 37 84 220 160 179 136 96 15 250 25 26 167 119 216 78 12 23 28 94 80 65 148 105 37 226 205 178 88 179 130 190 233 252 123 197 227 186 157 58 116 47 213 216 8 19 202 72 179 134 248 62 205 139 137 198 65 155 154 205 249 99 56 187 14 119 158 233 203 37 34 208 100 56 19 122 70 223 132 177 96 84 56 150 254 49 2 204 7 119 253 28 226 37 130 47 153 193 3 66 88 188 3 0 0 0 64 140 122 119 39 180 83 252 77 149 191 129 134 12 141 62 96 133 98 170 229 37 197 136 97 68 58 105 144 236 92 39 65 44 221 243 133 48 202 183 51 237 155 98 163 154 52 14 169 35 49 67 177 150 145 49 75 8 0 0 0 0 0 0 0 1 64 140 122 119 39 180 83 252 77 149 191 129 134 12 141 62 96 133 98 170 229 37 197 136 97 68 58 105 144 236 92 39 65 44 221 243 133 48 202 183 51 237 155 98 163 154 52 14 169 35 49 67 177 150 145 49 75 8 0 0 0 0 0 0 0 0 80 9 61 184 172 233 13 43 45 30 119 185 68 107 159 107 243 178 49 80 0 96 120 155 240 156 53 48 213 202 121 253 151 95 14 88 52 193 70 56 174 121 49 216 9 237 188 33 131 0 202 142 97 27 187 215 252 182 119 74 239 189 124 236 151 198 110 105 243 51 188 18 131 2 91 205 73 28 4 0 0 1 80 9 61 184 172 233 13 43 45 30 119 185 68 107 159 107 243 178 49 80 0 96 120 155 240 156 53 48 213 202 121 253 151 95 14 88 52 193 70 56 174 121 49 216 9 237 188 33 131 0 202 142 97 27 187 215 252 182 119 74 239 189 124 236 151 198 110 105 243 51 188 18 131 2 91 205 73 28 4 0 0 0 16 137 77 210 245 248 194 39 160 111 226 179 107 25 44 0 0 1 16 137 77 210 245 248 194 39 160 111 226 179 107 25 44 0 0 0 64 90 160 7 65 4 255 208 168 205 179 4 240 248 31 206 47 175 22 191 41 103 114 135 198 218 147 111 186 210 117 127 71 122 113 161 142 45 56 90 182 5 196 124 208 246 99 179 100 179 27 123 2 247 71 97 127 214 218 135 188 45 50 128 224 1 64 90 160 7 65 4 255 208 168 205 179 4 240 248 31 206 47 175 22 191 41 103 114 135 198 218 147 111 186 210 117 127 71 122 113 161 142 45 56 90 182 5 196 124 208 246 99 179 100 179 27 123 2 247 71 97 127 214 218 135 188 45 50 128 224 0 128 32 154 212 74 8 112 124 62 201 195 129 67 76 87 211 0 54 149 15 2 59 137 176 18 143 114 152 101 173 81 166 31 220 98 29 15 12 143 193 186 10 214 32 46 186 56 227 96 71 41 12 224 186 32 190 104 219 81 226 245 30 187 162 67 12 238 66 40 214 182 170 73 67 29 245 229 231 140 16 172 204 90 196 85 159 37 247 5 72 91 26 80 132 221 105 222 230 137 161 192 217 213 175 8 134 107 130 255 104 27 119 215 213 254 251 29 13 165 7 158 123 144 75 0 0 0 0 0 1 128 32 154 212 74 8 112 124 62 201 195 129 67 76 87 211 0 54 149 15 2 59 137 176 18 143 114 152 101 173 81 166 31 220 98 29 15 12 143 193 186 10 214 32 46 186 56 227 96 71 41 12 224 186 32 190 104 219 81 226 245 30 187 162 67 12 238 66 40 214 182 170 73 67 29 245 229 231 140 16 172 204 90 196 85 159 37 247 5 72 91 26 80 132 221 105 222 230 137 161 192 217 213 175 8 134 107 130 255 104 27 119 215 213 254 251 29 13 165 7 158 123 144 75 0 0 0 0 0 0 128 239 164 224 84 239 190 177 240 167 255 153 207 198 235 157 218 101 209 117 110 57 158 113 160 68 242 223 109 247 33 237 229 57 186 145 95 59 2 2 106 153 109 194 24 239 241 188 61 245 211 125 238 32 54 37 170 29 197 209 243 122 188 213 28 57 75 147 38 170 70 103 138 223 146 28 2 3 91 146 155 55 185 226 218 164 234 79 158 254 61 31 183 119 148 157 226 56 110 177 236 227 71 43 83 82 161 247 161 196 1 164 120 80 136 191 208 140 164 14 207 160 41 164 244 119 14 0 0 1 128 239 164 224 84 239 190 177 240 167 255 153 207 198 235 157 218 101 209 117 110 57 158 113 160 68 242 223 109 247 33 237 229 57 186 145 95 59 2 2 106 153 109 194 24 239 241 188 61 245 211 125 238 32 54 37 170 29 197 209 243 122 188 213 28 57 75 147 38 170 70 103 138 223 146 28 2 3 91 146 155 55 185 226 218 164 234 79 158 254 61 31 183 119 148 157 226 56 110 177 236 227 71 43 83 82 161 247 161 196 1 164 120 80 136 191 208 140 164 14 207 160 41 164 244 119 14 0 0 0 8 117 0 0 0 0 0 0 0 1 8 117 0 0 0 0 0 0 0 0 8 167 54 193 64 7 0 0 0 1 8 167 54 193 64 7 0 0 0 0 104 163 255 64 83 203 87 36 149 94 156 52 123 63 158 204 53 182 225 176 27 17 88 255 208 169 246 109 207 8 64 136 93 175 10 180 61 49 204 55 239 115 146 100 212 148 94 230 159 166 203 181 245 53 40 149 146 56 136 42 224 170 147 35 157 91 64 177 60 196 240 153 231 11 78 17 76 195 177 43 46 180 131 25 83 109 63 119 225 27 57 57 188 91 199 152 23 5 174 91 1 0 0 0 0 1 104 163 255 64 83 203 87 36 149 94 156 52 123 63 158 204 53 182 225 176 27 17 88 255 208 169 246 109 207 8 64 136 93 175 10 180 61 49 204 55 239 115 146 100 212 148 94 230 159 166 203 181 245 53 40 149 146 56 136 42 224 170 147 35 157 91 64 177 60 196 240 153 231 11 78 17 76 195 177 43 46 180 131 25 83 109 63 119 225 27 57 57 188 91 199 152 23 5 174 91 1 0 0 0 0 0 128 208 138 109 225 227 64 152 153 2 96 34 145 164 157 131 115 155 183 104 200 193 145 244 83 249 93 179 164 174 212 200 81 147 54 91 88 194 241 160 176 132 66 20 118 17 178 241 133 189 166 164 150 50 53 47 1 210 38 252 20 112 90 129 36 107 137 165 239 174 138 211 103 99 134 246 76 212 170 81 144 177 228 153 120 20 106 60 41 27 26 142 218 209 123 220 154 21 104 181 204 11 114 252 113 18 117 199 212 53 240 129 51 13 132 82 236 158 244 158 200 100 104 97 216 25 1 0 0 1 128 208 138 109 225 227 64 152 153 2 96 34 145 164 157 131 115 155 183 104 200 193 145 244 83 249 93 179 164 174 212 200 81 147 54 91 88 194 241 160 176 132 66 20 118 17 178 241 133 189 166 164 150 50 53 47 1 210 38 252 20 112 90 129 36 107 137 165 239 174 138 211 103 99 134 246 76 212 170 81 144 177 228 153 120 20 106 60 41 27 26 142 218 209 123 220 154 21 104 181 204 11 114 252 113 18 117 199 212 53 240 129 51 13 132 82 236 158 244 158 200 100 104 97 216 25 1 0 0 0 112 88 85 211 200 39 154 110 112 105 110 167 223 36 85 108 22 191 129 29 63 186 205 74 174 242 107 26 190 218 113 172 16 57 224 133 51 114 134 142 127 13 144 200 97 128 128 218 245 64 148 11 69 93 180 151 220 172 202 66 76 33 187 244 229 35 36 242 82 235 185 65 36 190 117 245 110 49 206 180 71 37 57 255 79 12 219 105 17 123 252 191 204 128 157 112 79 129 176 184 68 206 60 102 245 5 0 0 0 0 0 0 0 1 112 88 85 211 200 39 154 110 112 105 110 167 223 36 85 108 22 191 129 29 63 186 205 74 174 242 107 26 190 218 113 172 16 57 224 133 51 114 134 142 127 13 144 200 97 128 128 218 245 64 148 11 69 93 180 151 220 172 202 66 76 33 187 244 229 35 36 242 82 235 185 65 36 190 117 245 110 49 206 180 71 37 57 255 79 12 219 105 17 123 252 191 204 128 157 112 79 129 176 184 68 206 60 102 245 5 0 0 0 0 0 0 0 0 48 148 74 37 131 247 53 39 99 216 223 47 18 9 18 136 179 193 37 55 33 91 7 244 148 62 42 57 238 215 181 93 98 8 101 69 225 214 132 204 75 52 125 56 24 213 200 8 0 1 48 148 74 37 131 247 53 39 99 216 223 47 18 9 18 136 179 193 37 55 33 91 7 244 148 62 42 57 238 215 181 93 98 8 101 69 225 214 132 204 75 52 125 56 24 213 200 8 0 0 112 64 220 239 97 7 93 87 27 105 63 207 167 21 133 15 227 58 185 168 161 239 33 193 128 172 161 15 59 239 186 103 81 115 178 232 138 149 139 198 145 252 165 58 125 110 48 134 211 40 242 174 206 78 255 94 75 31 44 237 250 204 57 72 109 14 12 198 119 229 200 254 145 184 208 143 78 161 97 105 128 146 153 84 125 239 129 93 98 110 23 17 170 158 50 181 141 42 47 152 191 196 3 192 174 110 71 240 178 232 63 60 2 1 112 64 220 239 97 7 93 87 27 105 63 207 167 21 133 15 227 58 185 168 161 239 33 193 128 172 161 15 59 239 186 103 81 115 178 232 138 149 139 198 145 252 165 58 125 110 48 134 211 40 242 174 206 78 255 94 75 31 44 237 250 204 57 72 109 14 12 198 119 229 200 254 145 184 208 143 78 161 97 105 128 146 153 84 125 239 129 93 98 110 23 17 170 158 50 181 141 42 47 152 191 196 3 192 174 110 71 240 178 232 63 60 2 0 88 246 113 176 137 13 123 106 26 224 128 91 228 193 243 252 242 15 62 220 212 178 30 202 11 111 66 230 161 177 241 60 253 100 208 201 117 225 216 68 197 128 174 145 95 149 128 91 24 175 176 25 111 104 124 66 50 242 232 64 14 195 239 251 14 206 116 190 242 168 216 235 100 161 227 42 119 101 187 234 141 57 76 100 11 246 212 179 0 1 88 246 113 176 137 13 123 106 26 224 128 91 228 193 243 252 242 15 62 220 212 178 30 202 11 111 66 230 161 177 241 60 253 100 208 201 117 225 216 68 197 128 174 145 95 149 128 91 24 175 176 25 111 104 124 66 50 242 232 64 14 195 239 251 14 206 116 190 242 168 216 235 100 161 227 42 119 101 187 234 141 57 76 100 11 246 212 179 0 0 16 55 56 172 187 58 164 70 156 120 82 181 1 0 0 0 0 1 16 55 56 172 187 58 164 70 156 120 82 181 1 0 0 0 0 0 48 220 172 17 9 205 156 24 242 134 168 180 223 153 206 236 236 90 205 11 224 120 98 214 90 123 243 129 201 165 220 225 6 36 19 55 134 83 178 129 164 32 109 15 112 3 0 0 0 1 48 220 172 17 9 205 156 24 242 134 168 180 223 153 206 236 236 90 205 11 224 120 98 214 90 123 243 129 201 165 220 225 6 36 19 55 134 83 178 129 164 32 109 15 112 3 0 0 0 0 56 193 141 127 34 209 21 199 67 68 204 143 241 45 80 225 214 45 100 21 48 33 106 113 2 148 20 23 159 40 68 202 237 170 200 232 238 164 242 236 171 136 93 52 242 83 251 122 237 48 94 107 2 0 0 0 0 1 56 193 141 127 34 209 21 199 67 68 204 143 241 45 80 225 214 45 100 21 48 33 106 113 2 148 20 23 159 40 68 202 237 170 200 232 238 164 242 236 171 136 93 52 242 83 251 122 237 48 94 107 2 0 0 0 0 0 112 207 93 175 32 64 88 139 55 246 244 132 171 62 72 184 11 242 187 171 224 39 148 96 224 166 191 87 37 46 103 39 90 112 54 172 23 47 108 13 198 12 169 216 111 103 124 235 201 195 16 145 148 127 191 56 185 218 102 131 173 6 53 96 126 92 36 77 124 130 17 196 69 227 95 129 211 148 22 209 224 108 6 158 123 117 167 143 244 183 183 224 114 73 162 213 215 117 83 229 22 1 63 246 155 62 220 132 1 179 0 0 0 1 112 207 93 175 32 64 88 139 55 246 244 132 171 62 72 184 11 242 187 171 224 39 148 96 224 166 191 87 37 46 103 39 90 112 54 172 23 47 108 13 198 12 169 216 111 103 124 235 201 195 16 145 148 127 191 56 185 218 102 131 173 6 53 96 126 92 36 77 124 130 17 196 69 227 95 129 211 148 22 209 224 108 6 158 123 117 167 143 244 183 183 224 114 73 162 213 215 117 83 229 22 1 63 246 155 62 220 132 1 179 0 0 0 0 40 28 191 13 194 165 182 248 57 186 139 244 112 207 96 200 175 106 69 10 84 43 142 147 3 182 157 30 118 79 126 104 103 178 4 0 0 0 0 0 0 1 40 28 191 13 194 165 182 248 57 186 139 244 112 207 96 200 175 106 69 10 84 43 142 147 3 182 157 30 118 79 126 104 103 178 4 0 0 0 0 0 0 0 8 212 78 222 60 176 142 1 0 1 8 212 78 222 60 176 142 1 0 0 104 145 100 67 42 119 254 160 245 196 55 20 64 100 33 63 183 247 83 171 250 148 186 67 236 130 147 92 200 183 110 211 65 19 126 207 82 103 84 16 52 82 16 73 99 33 53 16 184 44 239 234 154 184 25 81 99 110 127 146 231 156 136 36 208 247 98 178 87 0 213 166 40 147 186 233 193 12 80 213 75 67 53 102 157 20 22 155 226 99 40 237 217 91 216 187 183 209 192 42 100 71 58 1 0 1 104 145 100 67 42 119 254 160 245 196 55 20 64 100 33 63 183 247 83 171 250 148 186 67 236 130 147 92 200 183 110 211 65 19 126 207 82 103 84 16 52 82 16 73 99 33 53 16 184 44 239 234 154 184 25 81 99 110 127 146 231 156 136 36 208 247 98 178 87 0 213 166 40 147 186 233 193 12 80 213 75 67 53 102 157 20 22 155 226 99 40 237 217 91 216 187 183 209 192 42 100 71 58 1 0 0 88 125 231 30 134 199 198 64 150 204 149 136 212 55 251 17 236 75 172 60 103 13 112 161 248 228 121 4 183 230 238 235 81 68 11 65 213 88 3 234 7 110 178 57 19 166 16 98 54 80 226 89 131 81 212 59 162 55 8 27 204 124 98 217 79 46 181 86 195 56 99 31 161 60 165 222 210 115 82 149 178 121 38 60 117 25 0 0 0 1 88 125 231 30 134 199 198 64 150 204 149 136 212 55 251 17 236 75 172 60 103 13 112 161 248 228 121 4 183 230 238 235 81 68 11 65 213 88 3 234 7 110 178 57 19 166 16 98 54 80 226 89 131 81 212 59 162 55 8 27 204 124 98 217 79 46 181 86 195 56 99 31 161 60 165 222 210 115 82 149 178 121 38 60 117 25 0 0 0 0 56 55 79 115 254 18 45 144 84 54 237 229 99 113 73 136 188 244 213 254 183 151 168 225 91 201 252 214 57 183 27 164 26 210 240 237 171 92 108 203 191 175 120 3 12 116 19 67 245 233 249 115 5 240 214 35 0 1 56 55 79 115 254 18 45 144 84 54 237 229 99 113 73 136 188 244 213 254 183 151 168 225 91 201 252 214 57 183 27 164 26 210 240 237 171 92 108 203 191 175 120 3 12 116 19 67 245 233 249 115 5 240 214 35 0 0 96 149 115 162 199 81 74 3 202 108 176 213 7 202 56 50 54 238 173 104 162 72 222 19 198 247 157 194 69 205 163 168 225 51 180 210 187 109 152 138 75 137 178 226 20 227 183 17 221 228 33 75 27 234 181 159 148 112 168 204 13 44 22 165 143 41 73 80 229 106 191 38 16 134 93 174 157 141 69 61 203 130 122 44 39 131 2 164 80 62 160 63 47 120 166 28 140 1 96 149 115 162 199 81 74 3 202 108 176 213 7 202 56 50 54 238 173 104 162 72 222 19 198 247 157 194 69 205 163 168 225 51 180 210 187 109 152 138 75 137 178 226 20 227 183 17 221 228 33 75 27 234 181 159 148 112 168 204 13 44 22 165 143 41 73 80 229 106 191 38 16 134 93 174 157 141 69 61 203 130 122 44 39 131 2 164 80 62 160 63 47 120 166 28 140 0 120 177 73 66 225 183 251 124 47 179 14 57 160 213 173 196 252 133 171 44 98 102 65 108 221 64 128 144 3 168 15 10 125 144 93 198 204 237 212 228 129 58 93 188 102 216 32 20 56 110 5 186 118 149 188 145 246 98 31 144 172 117 122 179 94 110 54 137 100 169 159 233 64 176 40 159 107 80 248 222 131 122 156 155 179 205 124 225 233 168 165 4 29 207 254 20 155 7 94 221 210 178 187 38 94 68 88 18 166 136 0 118 237 105 249 139 19 14 0 0 0 1 120 177 73 66 225 183 251 124 47 179 14 57 160 213 173 196 252 133 171 44 98 102 65 108 221 64 128 144 3 168 15 10 125 144 93 198 204 237 212 228 129 58 93 188 102 216 32 20 56 110 5 186 118 149 188 145 246 98 31 144 172 117 122 179 94 110 54 137 100 169 159 233 64 176 40 159 107 80 248 222 131 122 156 155 179 205 124 225 233 168 165 4 29 207 254 20 155 7 94 221 210 178 187 38 94 68 88 18 166 136 0 118 237 105 249 139 19 14 0 0 0 0 24 144 98 85 217 149 150 223 122 8 206 59 47 131 103 65 155 173 0 0 0 0 0 0 0 1 24 144 98 85 217 149 150 223 122 8 206 59 47 131 103 65 155 173 0 0 0 0 0 0 0 0 24 220 124 42 149 85 78 138 33 185 250 196 15 48 72 171 163 134 2 88 6 85 142 130 2 1 24 220 124 42 149 85 78 138 33 185 250 196 15 48 72 171 163 134 2 88 6 85 142 130 2 0 128 212 122 169 156 54 138 107 16 121 38 59 69 203 193 117 75 63 180 179 47 63 118 224 1 181 147 133 85 37 60 119 246 102 174 58 174 167 181 225 245 128 208 200 176 210 149 71 173 107 114 230 170 178 95 214 144 188 159 164 164 189 64 23 6 49 14 195 137 72 104 1 156 208 120 58 123 105 78 15 149 254 83 83 82 154 175 59 38 12 161 82 182 68 227 130 172 160 38 178 36 70 164 50 135 65 11 243 87 239 25 151 184 247 104 210 135 241 219 1 53 174 119 60 149 230 43 0 0 1 128 212 122 169 156 54 138 107 16 121 38 59 69 203 193 117 75 63 180 179 47 63 118 224 1 181 147 133 85 37 60 119 246 102 174 58 174 167 181 225 245 128 208 200 176 210 149 71 173 107 114 230 170 178 95 214 144 188 159 164 164 189 64 23 6 49 14 195 137 72 104 1 156 208 120 58 123 105 78 15 149 254 83 83 82 154 175 59 38 12 161 82 182 68 227 130 172 160 38 178 36 70 164 50 135 65 11 243 87 239 25 151 184 247 104 210 135 241 219 1 53 174 119 60 149 230 43 0 0 0 40 100 188 84 92 121 120 255 45 117 214 25 143 9 160 32 125 250 37 133 240 255 252 20 126 29 171 3 237 205 240 235 36 208 143 0 0 0 0 0 0 1 40 100 188 84 92 121 120 255 45 117 214 25 143 9 160 32 125 250 37 133 240 255 252 20 126 29 171 3 237 205 240 235 36 208 143 0 0 0 0 0 0 0 16 204 130 239 246 187 158 93 86 47 108 73 1 13 0 0 0 1 16 204 130 239 246 187 158 93 86 47 108 73 1 13 0 0 0 0 24 202 131 231 76 126 186 127 132 23 187 208 204 73 5 178 40 150 139 35 0 0 0 0 0 1 24 202 131 231 76 126 186 127 132 23 187 208 204 73 5 178 40 150 139 35 0 0 0 0 0 0 40 107 133 121 0 139 12 135 132 162 235 102 36 43 184 250 87 59 67 137 202 96 199 100 109 243 118 70 114 158 224 173 101 40 37 48 74 1 0 0 0 1 40 107 133 121 0 139 12 135 132 162 235 102 36 43 184 250 87 59 67 137 202 96 199 100 109 243 118 70 114 158 224 173 101 40 37 48 74 1 0 0 0 0 24 102 233 199 173 120 192 172 230 96 54 194 151 124 92 161 206 20 63 0 0 0 0 0 0 1 24 102 233 199 173 120 192 172 230 96 54 194 151 124 92 161 206 20 63 0 0 0 0 0 0 0 104 100 11 95 76 33 185 232 209 233 63 34 185 176 109 189 253 110 207 211 238 172 100 29 184 164 214 167 6 238 105 2 20 159 93 77 69 163 157 21 207 95 133 129 211 104 170 34 230 70 233 190 110 110 143 167 140 190 151 103 146 32 227 27 255 248 240 157 241 20 32 236 100 44 139 162 28 213 191 101 140 119 176 40 84 199 138 241 56 14 243 128 9 9 244 235 30 65 225 224 112 146 250 26 0 1 104 100 11 95 76 33 185 232 209 233 63 34 185 176 109 189 253 110 207 211 238 172 100 29 184 164 214 167 6 238 105 2 20 159 93 77 69 163 157 21 207 95 133 129 211 104 170 34 230 70 233 190 110 110 143 167 140 190 151 103 146 32 227 27 255 248 240 157 241 20 32 236 100 44 139 162 28 213 191 101 140 119 176 40 84 199 138 241 56 14 243 128 9 9 244 235 30 65 225 224 112 146 250 26 0 0 112 182 231 30 134 177 100 37 122 104 11 71 195 133 25 28 169 0 181 147 130 44 177 101 57 112 42 199 21 101 103 140 223 42 216 201 189 53 195 100 237 238 71 248 113 40 44 240 38 199 64 195 184 81 25 41 68 92 218 4 53 122 241 204 51 58 42 144 93 242 88 103 109 196 188 0 52 79 84 246 121 89 177 54 12 27 96 80 73 210 243 157 157 69 16 99 156 41 206 86 47 228 138 204 240 83 60 157 254 252 73 192 5 1 112 182 231 30 134 177 100 37 122 104 11 71 195 133 25 28 169 0 181 147 130 44 177 101 57 112 42 199 21 101 103 140 223 42 216 201 189 53 195 100 237 238 71 248 113 40 44 240 38 199 64 195 184 81 25 41 68 92 218 4 53 122 241 204 51 58 42 144 93 242 88 103 109 196 188 0 52 79 84 246 121 89 177 54 12 27 96 80 73 210 243 157 157 69 16 99 156 41 206 86 47 228 138 204 240 83 60 157 254 252 73 192 5 0 16 197 213 123 115 98 52 254 70 238 15 1 0 0 0 0 0 1 16 197 213 123 115 98 52 254 70 238 15 1 0 0 0 0 0 0 80 210 145 122 99 89 37 131 47 52 147 113 130 64 191 58 127 124 89 27 75 1 37 219 223 7 191 140 168 223 254 58 21 31 33 247 253 167 137 36 155 41 0 231 239 197 12 2 35 195 249 194 240 216 58 92 5 213 221 245 127 195 161 21 118 66 85 175 221 8 222 64 201 103 150 0 0 0 0 0 0 1 80 210 145 122 99 89 37 131 47 52 147 113 130 64 191 58 127 124 89 27 75 1 37 219 223 7 191 140 168 223 254 58 21 31 33 247 253 167 137 36 155 41 0 231 239 197 12 2 35 195 249 194 240 216 58 92 5 213 221 245 127 195 161 21 118 66 85 175 221 8 222 64 201 103 150 0 0 0 0 0 0 0 88 102 17 96 82 154 52 112 87 18 167 167 218 54 218 124 208 194 201 83 97 231 176 221 100 220 46 62 248 6 192 115 8 87 141 125 98 123 239 88 101 67 173 98 197 3 232 107 94 225 39 234 38 220 115 81 68 201 24 107 126 207 211 147 102 232 111 120 175 151 194 198 220 102 170 182 69 63 31 181 226 6 0 0 0 0 0 0 0 1 88 102 17 96 82 154 52 112 87 18 167 167 218 54 218 124 208 194 201 83 97 231 176 221 100 220 46 62 248 6 192 115 8 87 141 125 98 123 239 88 101 67 173 98 197 3 232 107 94 225 39 234 38 220 115 81 68 201 24 107 126 207 211 147 102 232 111 120 175 151 194 198 220 102 170 182 69 63 31 181 226 6 0 0 0 0 0 0 0 0 72 145 142 130 152 168 95 187 252 167 72 111 60 173 234 4 233 25 77 201 212 221 165 137 12 169 149 226 137 232 12 31 136 171 31 255 243 138 160 179 185 30 246 120 97 97 100 77 175 51 130 43 32 46 143 163 120 150 96 104 169 233 159 139 198 126 120 21 227 79 54 10 0 1 72 145 142 130 152 168 95 187 252 167 72 111 60 173 234 4 233 25 77 201 212 221 165 137 12 169 149 226 137 232 12 31 136 171 31 255 243 138 160 179 185 30 246 120 97 97 100 77 175 51 130 43 32 46 143 163 120 150 96 104 169 233 159 139 198 126 120 21 227 79 54 10 0 0 8 209 5 0 0 0 0 0 0 1 8 209 5 0 0 0 0 0 0 0 24 69 29 214 123 179 196 196 154 251 96 42 73 71 146 179 99 47 210 101 0 0 0 0 0 1 24 69 29 214 123 179 196 196 154 251 96 42 73 71 146 179 99 47 210 101 0 0 0 0 0 0 88 205 231 92 64 63 136 90 54 204 92 82 240 111 88 87 211 205 64 177 174 111 246 250 90 188 132 108 77 132 226 209 192 221 34 204 124 101 65 183 13 73 28 188 123 178 61 12 115 7 113 85 201 249 122 39 164 5 195 152 12 24 213 221 225 91 183 40 236 164 234 105 15 207 109 160 192 144 206 42 56 17 71 51 153 182 149 229 1 1 88 205 231 92 64 63 136 90 54 204 92 82 240 111 88 87 211 205 64 177 174 111 246 250 90 188 132 108 77 132 226 209 192 221 34 204 124 101 65 183 13 73 28 188 123 178 61 12 115 7 113 85 201 249 122 39 164 5 195 152 12 24 213 221 225 91 183 40 236 164 234 105 15 207 109 160 192 144 206 42 56 17 71 51 153 182 149 229 1 0 112 75 185 2 45 158 234 42 220 77 129 40 207 111 250 118 209 102 233 123 133 227 197 44 57 196 23 50 237 189 56 114 42 117 188 70 201 140 176 85 119 26 80 196 78 38 152 73 81 60 72 29 44 30 96 127 77 209 43 84 19 238 161 199 121 222 254 69 226 80 194 175 85 135 165 209 175 199 237 223 219 141 82 63 115 118 194 96 58 8 45 138 219 118 118 250 164 228 179 178 255 210 12 129 255 206 164 214 156 233 1 0 0 1 112 75 185 2 45 158 234 42 220 77 129 40 207 111 250 118 209 102 233 123 133 227 197 44 57 196 23 50 237 189 56 114 42 117 188 70 201 140 176 85 119 26 80 196 78 38 152 73 81 60 72 29 44 30 96 127 77 209 43 84 19 238 161 199 121 222 254 69 226 80 194 175 85 135 165 209 175 199 237 223 219 141 82 63 115 118 194 96 58 8 45 138 219 118 118 250 164 228 179 178 255 210 12 129 255 206 164 214 156 233 1 0 0 0 72 170 113 192 138 104 174 124 39 73 93 28 193 169 216 164 220 91 84 152 21 86 210 138 141 248 203 166 85 144 162 254 201 183 85 193 224 116 40 113 190 178 244 129 164 250 249 19 14 209 96 142 161 190 213 129 69 159 67 19 1 205 41 215 144 51 30 49 29 6 0 0 0 1 72 170 113 192 138 104 174 124 39 73 93 28 193 169 216 164 220 91 84 152 21 86 210 138 141 248 203 166 85 144 162 254 201 183 85 193 224 116 40 113 190 178 244 129 164 250 249 19 14 209 96 142 161 190 213 129 69 159 67 19 1 205 41 215 144 51 30 49 29 6 0 0 0 0 80 187 125 249 0 237 185 92 151 185 34 111 175 129 204 191 155 242 60 103 220 201 34 29 144 204 63 230 124 192 11 86 89 46 248 84 65 216 118 216 186 101 34 52 12 183 171 200 31 196 236 206 37 26 50 4 49 58 103 122 211 219 34 244 124 191 195 111 184 185 248 253 224 239 127 121 202 148 98 106 14 1 80 187 125 249 0 237 185 92 151 185 34 111 175 129 204 191 155 242 60 103 220 201 34 29 144 204 63 230 124 192 11 86 89 46 248 84 65 216 118 216 186 101 34 52 12 183 171 200 31 196 236 206 37 26 50 4 49 58 103 122 211 219 34 244 124 191 195 111 184 185 248 253 224 239 127 121 202 148 98 106 14 0 64 139 102 172 114 149 72 104 165 114 58 106 15 225 235 97 205 254 36 224 45 49 116 146 137 86 251 107 88 136 139 83 17 137 15 7 72 222 67 112 165 159 252 189 213 77 46 142 192 37 63 205 124 221 187 30 104 5 0 0 0 0 0 0 0 1 64 139 102 172 114 149 72 104 165 114 58 106 15 225 235 97 205 254 36 224 45 49 116 146 137 86 251 107 88 136 139 83 17 137 15 7 72 222 67 112 165 159 252 189 213 77 46 142 192 37 63 205 124 221 187 30 104 5 0 0 0 0 0 0 0 0 48 193 117 186 128 69 247 91 107 62 131 175 40 131 137 103 76 253 5 75 34 122 71 127 130 217 242 2 7 156 145 247 63 191 243 59 172 98 22 239 18 159 250 155 96 146 0 0 0 1 48 193 117 186 128 69 247 91 107 62 131 175 40 131 137 103 76 253 5 75 34 122 71 127 130 217 242 2 7 156 145 247 63 191 243 59 172 98 22 239 18 159 250 155 96 146 0 0 0 0 32 47 51 76 163 249 78 98 148 84 63 232 105 55 224 47 211 142 180 28 84 89 211 77 14 249 46 0 0 0 0 0 0 1 32 47 51 76 163 249 78 98 148 84 63 232 105 55 224 47 211 142 180 28 84 89 211 77 14 249 46 0 0 0 0 0 0 0 72 201 214 155 246 50 22 166 239 223 78 244 233 195 105 89 119 99 157 184 116 51 233 12 83 167 255 76 111 102 220 89 20 93 143 234 73 99 250 59 120 26 217 181 201 39 66 23 209 115 214 70 225 241 60 167 247 136 252 1 227 55 151 13 131 195 45 0 0 0 0 0 0 1 72 201 214 155 246 50 22 166 239 223 78 244 233 195 105 89 119 99 157 184 116 51 233 12 83 167 255 76 111 102 220 89 20 93 143 234 73 99 250 59 120 26 217 181 201 39 66 23 209 115 214 70 225 241 60 167 247 136 252 1 227 55 151 13 131 195 45 0 0 0 0 0 0 0 24 23 30 33 8 157 238 224 164 246 31 43 191 176 252 7 205 45 242 0 0 0 0 0 0 1 24 23 30 33 8 157 238 224 164 246 31 43 191 176 252 7 205 45 242 0 0 0 0 0 0 0 56 54 228 32 91 115 93 129 151 246 253 217 44 135 61 82 191 178 138 66 53 138 127 124 132 49 110 155 83 6 68 149 49 137 123 196 184 39 167 125 47 74 249 193 203 43 79 83 101 134 133 9 11 0 0 0 0 1 56 54 228 32 91 115 93 129 151 246 253 217 44 135 61 82 191 178 138 66 53 138 127 124 132 49 110 155 83 6 68 149 49 137 123 196 184 39 167 125 47 74 249 193 203 43 79 83 101 134 133 9 11 0 0 0 0 0 56 77 188 100 119 111 50 9 100 13 63 121 125 142 166 34 201 103 64 166 45 83 205 159 233 137 246 116 27 220 206 160 89 216 10 52 203 22 78 211 51 23 240 179 183 83 170 242 111 240 0 0 0 0 0 0 0 1 56 77 188 100 119 111 50 9 100 13 63 121 125 142 166 34 201 103 64 166 45 83 205 159 233 137 246 116 27 220 206 160 89 216 10 52 203 22 78 211 51 23 240 179 183 83 170 242 111 240 0 0 0 0 0 0 0 0 16 183 62 167 189 129 14 105 162 209 89 0 0 0 0 0 0 1 16 183 62 167 189 129 14 105 162 209 89 0 0 0 0 0 0 0 104 118 204 239 47 128 120 188 223 1 55 39 227 110 234 226 46 9 49 105 96 118 213 142 45 148 25 46 222 99 148 85 221 31 128 11 140 49 253 179 116 86 166 9 89 85 77 43 213 244 104 94 141 180 94 152 53 231 238 203 17 49 2 219 158 139 90 32 173 163 68 117 8 23 52 205 75 107 41 4 131 110 118 52 89 83 200 125 45 226 180 48 90 244 16 175 35 209 5 0 0 0 0 0 0 1 104 118 204 239 47 128 120 188 223 1 55 39 227 110 234 226 46 9 49 105 96 118 213 142 45 148 25 46 222 99 148 85 221 31 128 11 140 49 253 179 116 86 166 9 89 85 77 43 213 244 104 94 141 180 94 152 53 231 238 203 17 49 2 219 158 139 90 32 173 163 68 117 8 23 52 205 75 107 41 4 131 110 118 52 89 83 200 125 45 226 180 48 90 244 16 175 35 209 5 0 0 0 0 0 0 0 32 141 129 3 16 248 10 239 222 142 76 62 151 42 178 39 242 64 15 167 154 168 11 249 175 85 5 12 3 103 49 42 0 1 32 141 129 3 16 248 10 239 222 142 76 62 151 42 178 39 242 64 15 167 154 168 11 249 175 85 5 12 3 103 49 42 0 0 8 123 78 196 123 153 10 0 0 1 8 123 78 196 123 153 10 0 0 0 16 144 212 195 123 171 191 34 243 189 164 67 38 150 212 224 39 1 16 144 212 195 123 171 191 34 243 189 164 67 38 150 212 224 39 0 32 187 134 178 60 106 197 246 170 105 173 38 215 230 126 251 232 114 84 137 220 128 251 54 111 198 172 1 114 19 30 189 175 1 32 187 134 178 60 106 197 246 170 105 173 38 215 230 126 251 232 114 84 137 220 128 251 54 111 198 172 1 114 19 30 189 175 0 24 143 215 216 189 149 84 197 67 202 64 106 120 162 162 86 42 64 51 134 144 124 43 171 16 1 24 143 215 216 189 149 84 197 67 202 64 106 120 162 162 86 42 64 51 134 144 124 43 171 16 0 72 139 212 65 201 234 213 89 222 141 127 253 158 87 57 57 116 99 73 197 165 146 10 238 243 162 67 87 231 145 147 216 148 210 201 209 126 220 255 168 121 230 233 9 201 51 185 90 86 120 23 45 86 96 77 163 130 157 206 192 50 201 33 37 54 59 0 0 0 0 0 0 0 1 72 139 212 65 201 234 213 89 222 141 127 253 158 87 57 57 116 99 73 197 165 146 10 238 243 162 67 87 231 145 147 216 148 210 201 209 126 220 255 168 121 230 233 9 201 51 185 90 86 120 23 45 86 96 77 163 130 157 206 192 50 201 33 37 54 59 0 0 0 0 0 0 0 0 32 23 231 42 113 193 81 226 51 220 131 214 166 146 8 75 191 48 0 176 34 36 39 225 46 186 62 45 29 56 240 98 0 1 32 23 231 42 113 193 81 226 51 220 131 214 166 146 8 75 191 48 0 176 34 36 39 225 46 186 62 45 29 56 240 98 0 0 112 227 163 90 90 118 151 96 241 208 91 153 230 68 148 109 36 156 59 108 3 56 117 211 213 19 39 240 123 158 82 0 37 126 14 223 103 223 22 131 216 204 69 250 101 220 238 12 18 77 151 114 103 62 43 207 60 13 44 63 145 155 196 15 104 68 124 226 214 9 255 2 209 143 177 56 5 128 66 245 24 171 251 123 103 175 179 158 169 79 76 238 144 42 92 164 86 181 59 182 45 185 118 125 221 29 2 0 0 0 0 0 0 1 112 227 163 90 90 118 151 96 241 208 91 153 230 68 148 109 36 156 59 108 3 56 117 211 213 19 39 240 123 158 82 0 37 126 14 223 103 223 22 131 216 204 69 250 101 220 238 12 18 77 151 114 103 62 43 207 60 13 44 63 145 155 196 15 104 68 124 226 214 9 255 2 209 143 177 56 5 128 66 245 24 171 251 123 103 175 179 158 169 79 76 238 144 42 92 164 86 181 59 182 45 185 118 125 221 29 2 0 0 0 0 0 0 0 56 21 205 7 125 176 60 227 180 194 177 238 254 236 214 253 45 120 92 88 238 119 13 43 164 250 120 212 254 127 151 28 105 87 83 93 136 139 49 151 198 102 118 229 122 40 245 156 201 162 113 68 119 67 16 0 0 1 56 21 205 7 125 176 60 227 180 194 177 238 254 236 214 253 45 120 92 88 238 119 13 43 164 250 120 212 254 127 151 28 105 87 83 93 136 139 49 151 198 102 118 229 122 40 245 156 201 162 113 68 119 67 16 0 0 0 128 109 98 40 183 212 31 133 44 220 177 117 246 95 158 65 148 190 211 252 136 162 225 177 247 115 56 178 10 194 128 11 57 161 119 91 128 227 125 160 201 170 74 199 20 117 57 205 164 167 39 140 51 104 152 111 244 236 125 79 209 50 96 221 6 70 174 222 210 141 0 0 38 91 25 23 175 171 151 185 223 189 29 181 4 186 136 186 187 211 92 240 132 239 86 157 142 233 42 105 221 144 98 224 139 152 138 40 2 75 65 232 64 78 37 25 85 43 247 17 170 71 235 54 68 95 61 0 0 1 128 109 98 40 183 212 31 133 44 220 177 117 246 95 158 65 148 190 211 252 136 162 225 177 247 115 56 178 10 194 128 11 57 161 119 91 128 227 125 160 201 170 74 199 20 117 57 205 164 167 39 140 51 104 152 111 244 236 125 79 209 50 96 221 6 70 174 222 210 141 0 0 38 91 25 23 175 171 151 185 223 189 29 181 4 186 136 186 187 211 92 240 132 239 86 157 142 233 42 105 221 144 98 224 139 152 138 40 2 75 65 232 64 78 37 25 85 43 247 17 170 71 235 54 68 95 61 0 0 0 8 84 104 15 69 62 160 26 0 1 8 84 104 15 69 62 160 26 0 0 112 219 65 187 13 190 48 46 122 32 188 62 55 54 62 116 201 244 243 89 151 14 43 21 29 19 142 33 75 56 94 48 19 170 145 179 161 25 76 133 125 215 133 4 159 74 89 201 157 226 92 172 10 213 88 179 123 109 36 223 242 66 12 21 230 200 219 144 151 19 8 235 54 85 254 74 95 63 248 92 164 209 97 251 119 65 142 10 170 247 216 222 98 38 21 72 54 73 122 224 248 221 198 101 236 254 0 0 0 0 0 0 0 1 112 219 65 187 13 190 48 46 122 32 188 62 55 54 62 116 201 244 243 89 151 14 43 21 29 19 142 33 75 56 94 48 19 170 145 179 161 25 76 133 125 215 133 4 159 74 89 201 157 226 92 172 10 213 88 179 123 109 36 223 242 66 12 21 230 200 219 144 151 19 8 235 54 85 254 74 95 63 248 92 164 209 97 251 119 65 142 10 170 247 216 222 98 38 21 72 54 73 122 224 248 221 198 101 236 254 0 0 0 0 0 0 0 0 120 173 131 100 228 57 121 99 67 36 188 26 116 195 11 33 238 99 149 244 192 69 122 152 142 206 32 93 57 158 59 204 109 129 133 85 46 84 246 35 199 170 91 5 153 166 135 136 100 219 159 177 96 71 252 20 164 194 225 242 95 219 102 176 247 177 135 49 219 166 200 159 163 69 215 174 34 15 87 114 111 202 124 88 204 39 19 12 146 233 34 22 85 241 111 63 103 250 222 19 62 55 235 240 190 151 122 115 229 120 69 13 175 97 196 211 28 0 0 0 0 1 120 173 131 100 228 57 121 99 67 36 188 26 116 195 11 33 238 99 149 244 192 69 122 152 142 206 32 93 57 158 59 204 109 129 133 85 46 84 246 35 199 170 91 5 153 166 135 136 100 219 159 177 96 71 252 20 164 194 225 242 95 219 102 176 247 177 135 49 219 166 200 159 163 69 215 174 34 15 87 114 111 202 124 88 204 39 19 12 146 233 34 22 85 241 111 63 103 250 222 19 62 55 235 240 190 151 122 115 229 120 69 13 175 97 196 211 28 0 0 0 0 0 40 243 42 248 54 150 57 118 223 89 213 123 0 145 11 121 246 65 78 171 9 235 26 93 69 20 253 245 14 109 46 33 35 29 254 140 52 122 13 60 0 1 40 243 42 248 54 150 57 118 223 89 213 123 0 145 11 121 246 65 78 171 9 235 26 93 69 20 253 245 14 109 46 33 35 29 254 140 52 122 13 60 0 0 128 203 79 238 32 121 29 119 220 119 105 16 43 194 81 73 221 217 2 148 227 212 111 94 30 4 186 210 125 205 136 245 32 214 39 108 83 11 185 216 199 221 176 13 218 150 42 152 40 224 210 120 250 254 120 131 79 250 21 126 178 2 237 252 78 209 43 98 114 190 99 82 138 216 142 31 167 59 58 104 199 119 105 205 151 40 188 42 120 215 171 111 159 24 71 230 74 3 175 149 59 28 47 26 232 212 124 173 155 1 51 182 82 59 115 81 68 151 198 197 107 41 0 0 0 0 0 0 0 1 128 203 79 238 32 121 29 119 220 119 105 16 43 194 81 73 221 217 2 148 227 212 111 94 30 4 186 210 125 205 136 245 32 214 39 108 83 11 185 216 199 221 176 13 218 150 42 152 40 224 210 120 250 254 120 131 79 250 21 126 178 2 237 252 78 209 43 98 114 190 99 82 138 216 142 31 167 59 58 104 199 119 105 205 151 40 188 42 120 215 171 111 159 24 71 230 74 3 175 149 59 28 47 26 232 212 124 173 155 1 51 182 82 59 115 81 68 151 198 197 107 41 0 0 0 0 0 0 0 0 8 70 47 94 78 85 213 4 0 1 8 70 47 94 78 85 213 4 0 0 64 168 239 3 109 249 109 253 64 147 102 173 10 159 193 47 134 235 24 116 111 234 17 218 47 133 118 130 4 234 130 216 79 86 7 158 19 179 226 92 28 11 213 95 197 165 161 196 126 158 172 83 45 60 0 243 82 11 125 51 88 204 253 201 0 1 64 168 239 3 109 249 109 253 64 147 102 173 10 159 193 47 134 235 24 116 111 234 17 218 47 133 118 130 4 234 130 216 79 86 7 158 19 179 226 92 28 11 213 95 197 165 161 196 126 158 172 83 45 60 0 243 82 11 125 51 88 204 253 201 0 0 32 91 8 155 0 244 185 150 213 21 51 193 238 33 114 252 243 203 63 197 56 17 152 0 158 202 81 224 155 176 168 48 8 1 32 91 8 155 0 244 185 150 213 21 51 193 238 33 114 252 243 203 63 197 56 17 152 0 158 202 81 224 155 176 168 48 8 0 64 237 110 141 244 234 81 71 9 84 235 128 228 166 210 171 84 207 172 13 18 245 134 71 141 15 168 153 177 38 185 201 244 241 170 222 1 133 147 146 102 43 229 200 175 199 75 172 190 162 84 189 67 156 147 154 31 13 207 129 50 200 231 74 0 1 64 237 110 141 244 234 81 71 9 84 235 128 228 166 210 171 84 207 172 13 18 245 134 71 141 15 168 153 177 38 185 201 244 241 170 222 1 133 147 146 102 43 229 200 175 199 75 172 190 162 84 189 67 156 147 154 31 13 207 129 50 200 231 74 0 0 72 87 52 91 18 47 239 64 167 1 198 52 25 230 164 41 73 76 171 61 96 213 30 252 201 4 21 212 155 40 229 150 154 204 69 5 231 234 118 236 96 115 165 148 146 43 62 108 172 9 72 82 112 145 170 221 58 127 30 73 27 88 182 208 159 212 102 122 105 69 67 0 0 1 72 87 52 91 18 47 239 64 167 1 198 52 25 230 164 41 73 76 171 61 96 213 30 252 201 4 21 212 155 40 229 150 154 204 69 5 231 234 118 236 96 115 165 148 146 43 62 108 172 9 72 82 112 145 170 221 58 127 30 73 27 88 182 208 159 212 102 122 105 69 67 0 0 0 48 64 172 114 48 214 193 164 216 67 60 29 158 200 157 119 130 148 115 28 173 33 19 100 127 6 67 27 159 246 211 0 250 103 226 195 106 155 248 97 202 123 209 221 13 0 0 0 0 1 48 64 172 114 48 214 193 164 216 67 60 29 158 200 157 119 130 148 115 28 173 33 19 100 127 6 67 27 159 246 211 0 250 103 226 195 106 155 248 97 202 123 209 221 13 0 0 0 0 0 120 81 252 110 197 13 166 231 72 130 41 106 65 232 254 107 124 243 255 107 207 47 194 183 40 150 50 4 210 204 224 43 196 247 122 120 215 166 135 245 209 137 61 188 138 187 74 103 184 183 141 129 116 149 165 53 145 106 74 23 238 142 63 216 57 144 68 13 165 129 66 25 38 206 230 110 91 93 226 41 154 75 235 92 163 186 140 230 191 218 201 127 59 108 139 3 252 44 100 3 234 46 162 34 110 218 167 38 61 218 67 214 231 20 40 0 0 0 0 0 0 1 120 81 252 110 197 13 166 231 72 130 41 106 65 232 254 107 124 243 255 107 207 47 194 183 40 150 50 4 210 204 224 43 196 247 122 120 215 166 135 245 209 137 61 188 138 187 74 103 184 183 141 129 116 149 165 53 145 106 74 23 238 142 63 216 57 144 68 13 165 129 66 25 38 206 230 110 91 93 226 41 154 75 235 92 163 186 140 230 191 218 201 127 59 108 139 3 252 44 100 3 234 46 162 34 110 218 167 38 61 218 67 214 231 20 40 0 0 0 0 0 0 0 120 243 247 18 11 29 244 71 100 171 9 7 235 135 165 185 174 82 125 144 46 101 141 39 25 219 161 166 142 138 73 193 151 231 217 184 5 47 234 106 36 39 20 133 77 81 241 34 12 59 55 212 158 163 139 77 54 232 111 133 109 11 226 82 170 77 232 17 218 114 50 113 152 83 202 219 168 218 132 34 241 173 58 247 200 6 151 173 6 185 4 118 166 131 92 255 162 247 111 148 166 68 56 169 253 254 48 168 30 109 251 179 213 140 46 219 3 0 0 0 0 1 120 243 247 18 11 29 244 71 100 171 9 7 235 135 165 185 174 82 125 144 46 101 141 39 25 219 161 166 142 138 73 193 151 231 217 184 5 47 234 106 36 39 20 133 77 81 241 34 12 59 55 212 158 163 139 77 54 232 111 133 109 11 226 82 170 77 232 17 218 114 50 113 152 83 202 219 168 218 132 34 241 173 58 247 200 6 151 173 6 185 4 118 166 131 92 255 162 247 111 148 166 68 56 169 253 254 48 168 30 109 251 179 213 140 46 219 3 0 0 0 0 0 48 170 134 196 251 187 25 104 34 95 69 85 184 199 0 89 253 150 101 212 7 202 243 18 178 248 98 105 134 18 215 189 22 99 238 235 78 124 3 142 134 188 8 188 178 2 0 0 0 1 48 170 134 196 251 187 25 104 34 95 69 85 184 199 0 89 253 150 101 212 7 202 243 18 178 248 98 105 134 18 215 189 22 99 238 235 78 124 3 142 134 188 8 188 178 2 0 0 0 0 48 200 105 57 90 124 53 229 14 158 143 66 34 150 228 210 143 188 213 175 175 21 92 123 213 52 223 97 128 64 234 169 31 165 1 230 126 33 17 32 28 25 238 131 159 125 84 120 8 1 48 200 105 57 90 124 53 229 14 158 143 66 34 150 228 210 143 188 213 175 175 21 92 123 213 52 223 97 128 64 234 169 31 165 1 230 126 33 17 32 28 25 238 131 159 125 84 120 8 0 8 236 26 245 49 19 0 0 0 1 8 236 26 245 49 19 0 0 0 0 16 134 207 199 26 175 188 103 160 76 140 48 55 30 189 7 0 1 16 134 207 199 26 175 188 103 160 76 140 48 55 30 189 7 0 0 24 7 216 8 30 195 251 90 24 198 179 171 59 27 243 102 163 205 126 247 84 4 0 0 0 1 24 7 216 8 30 195 251 90 24 198 179 171 59 27 243 102 163 205 126 247 84 4 0 0 0 0 104 89 190 73 217 127 252 160 134 16 114 94 182 255 223 176 58 217 71 107 33 21 118 140 226 166 128 254 219 248 19 33 93 9 225 89 44 103 188 91 203 146 155 17 20 40 125 153 23 87 125 86 166 25 181 17 220 165 143 13 245 94 144 64 231 41 17 165 224 79 44 34 246 169 187 130 155 57 121 213 161 21 178 163 44 75 169 37 6 67 200 63 171 50 214 213 230 10 148 179 25 0 0 0 0 1 104 89 190 73 217 127 252 160 134 16 114 94 182 255 223 176 58 217 71 107 33 21 118 140 226 166 128 254 219 248 19 33 93 9 225 89 44 103 188 91 203 146 155 17 20 40 125 153 23 87 125 86 166 25 181 17 220 165 143 13 245 94 144 64 231 41 17 165 224 79 44 34 246 169 187 130 155 57 121 213 161 21 178 163 44 75 169 37 6 67 200 63 171 50 214 213 230 10 148 179 25 0 0 0 0 0 120 239 141 241 165 45 224 229 17 155 67 37 181 127 150 115 133 137 72 239 12 3 103 142 204 53 108 13 4 11 96 213 15 192 155 67 147 30 66 19 222 160 17 202 156 77 143 151 241 100 236 128 33 207 105 116 196 68 142 109 237 94 29 86 196 190 96 158 51 78 107 53 2 158 62 195 101 125 181 245 191 185 105 37 77 113 109 85 110 93 152 188 115 136 136 93 10 235 225 51 77 110 7 74 32 118 44 157 117 193 127 80 54 2 0 0 0 0 0 0 0 1 120 239 141 241 165 45 224 229 17 155 67 37 181 127 150 115 133 137 72 239 12 3 103 142 204 53 108 13 4 11 96 213 15 192 155 67 147 30 66 19 222 160 17 202 156 77 143 151 241 100 236 128 33 207 105 116 196 68 142 109 237 94 29 86 196 190 96 158 51 78 107 53 2 158 62 195 101 125 181 245 191 185 105 37 77 113 109 85 110 93 152 188 115 136 136 93 10 235 225 51 77 110 7 74 32 118 44 157 117 193 127 80 54 2 0 0 0 0 0 0 0 0 56 161 103 132 41 228 199 245 93 101 166 142 168 205 96 95 52 143 127 100 173 175 132 102 181 237 4 42 52 30 10 219 202 27 68 79 23 201 116 89 53 50 85 239 183 254 11 165 100 129 247 0 0 0 0 0 0 1 56 161 103 132 41 228 199 245 93 101 166 142 168 205 96 95 52 143 127 100 173 175 132 102 181 237 4 42 52 30 10 219 202 27 68 79 23 201 116 89 53 50 85 239 183 254 11 165 100 129 247 0 0 0 0 0 0 0 32 255 251 221 115 146 46 163 229 176 14 203 138 27 28 41 62 22 109 49 16 185 119 54 172 191 85 184 0 0 0 0 0 1 32 255 251 221 115 146 46 163 229 176 14 203 138 27 28 41 62 22 109 49 16 185 119 54 172 191 85 184 0 0 0 0 0 0 32 247 33 196 253 43 205 187 127 110 212 213 12 214 143 22 252 209 96 90 89 50 103 47 68 146 216 72 215 61 226 134 3 1 32 247 33 196 253 43 205 187 127 110 212 213 12 214 143 22 252 209 96 90 89 50 103 47 68 146 216 72 215 61 226 134 3 0 40 59 97 19 31 78 83 69 133 60 42 103 67 71 156 83 145 176 67 103 93 114 176 15 117 43 90 82 152 45 121 12 17 76 244 53 1 0 0 0 0 1 40 59 97 19 31 78 83 69 133 60 42 103 67 71 156 83 145 176 67 103 93 114 176 15 117 43 90 82 152 45 121 12 17 76 244 53 1 0 0 0 0 0 56 219 241 133 51 75 86 155 36 83 56 69 111 93 54 193 19 54 88 242 30 144 132 66 61 131 189 217 126 87 64 134 162 139 199 3 85 234 160 230 114 164 25 154 94 87 76 241 251 243 147 109 83 0 0 0 0 1 56 219 241 133 51 75 86 155 36 83 56 69 111 93 54 193 19 54 88 242 30 144 132 66 61 131 189 217 126 87 64 134 162 139 199 3 85 234 160 230 114 164 25 154 94 87 76 241 251 243 147 109 83 0 0 0 0 0 64 43 137 16 132 202 104 91 201 107 180 196 200 93 138 129 13 78 33 73 134 236 116 150 83 184 197 132 23 82 3 247 20 140 181 22 152 27 60 63 98 254 172 152 20 58 101 176 236 139 225 217 61 37 39 22 240 147 101 158 189 117 172 129 3 1 64 43 137 16 132 202 104 91 201 107 180 196 200 93 138 129 13 78 33 73 134 236 116 150 83 184 197 132 23 82 3 247 20 140 181 22 152 27 60 63 98 254 172 152 20 58 101 176 236 139 225 217 61 37 39 22 240 147 101 158 189 117 172 129 3 0 16 174 250 80 27 225 76 117 105 139 6 48 23 21 0 0 0 1 16 174 250 80 27 225 76 117 105 139 6 48 23 21 0 0 0 0 32 79 208 51 133 78 86 8 203 246 180 251 28 21 185 125 159 144 112 64 104 31 37 123 126 115 170 223 1 66 0 0 0 1 32 79 208 51 133 78 86 8 203 246 180 251 28 21 185 125 159 144 112 64 104 31 37 123 126 115 170 223 1 66 0 0 0 0 24 59 170 196 192 162 161 183 242 120 40 171 157 254 236 242 64 223 1 0 0 0 0 0 0 1 24 59 170 196 192 162 161 183 242 120 40 171 157 254 236 242 64 223 1 0 0 0 0 0 0 0 64 158 138 13 99 212 72 79 220 230 16 119 150 64 148 121 100 5 104 182 189 57 158 100 143 129 122 146 11 169 192 52 74 169 74 4 0 229 160 168 226 62 202 182 250 171 51 251 90 159 122 13 111 16 28 141 139 1 41 229 97 17 73 120 0 1 64 158 138 13 99 212 72 79 220 230 16 119 150 64 148 121 100 5 104 182 189 57 158 100 143 129 122 146 11 169 192 52 74 169 74 4 0 229 160 168 226 62 202 182 250 171 51 251 90 159 122 13 111 16 28 141 139 1 41 229 97 17 73 120 0 0 128 54 211 84 85 147 162 152 160 127 96 156 128 144 183 140 26 170 242 255 112 211 16 24 233 93 177 189 62 26 230 8 18 162 102 53 79 255 93 127 37 173 116 119 61 21 221 30 71 51 18 217 197 225 89 208 228 54 16 14 158 40 254 222 6 144 144 95 30 116 51 208 187 221 207 73 40 215 178 180 184 67 243 230 235 85 174 4 118 231 32 148 73 211 37 140 151 196 184 12 41 14 98 78 190 103 107 141 66 52 100 222 58 141 135 84 85 90 76 97 21 18 0 0 0 0 0 0 0 1 128 54 211 84 85 147 162 152 160 127 96 156 128 144 183 140 26 170 242 255 112 211 16 24 233 93 177 189 62 26 230 8 18 162 102 53 79 255 93 127 37 173 116 119 61 21 221 30 71 51 18 217 197 225 89 208 228 54 16 14 158 40 254 222 6 144 144 95 30 116 51 208 187 221 207 73 40 215 178 180 184 67 243 230 235 85 174 4 118 231 32 148 73 211 37 140 151 196 184 12 41 14 98 78 190 103 107 141 66 52 100 222 58 141 135 84 85 90 76 97 21 18 0 0 0 0 0 0 0 0 128 94 236 109 194 205 86 41 192 155 21 79 52 203 207 37 42 40 126 224 32 228 152 22 204 190 205 68 99 253 159 127 249 241 8 5 27 151 203 115 75 236 216 195 28 184 201 166 85 152 106 8 201 248 148 93 54 156 87 135 56 251 121 202 96 173 198 190 134 110 223 180 127 230 136 159 180 9 44 207 255 43 80 213 238 43 117 135 78 121 149 22 24 198 179 157 59 238 245 168 85 45 36 70 88 161 109 52 49 133 96 74 209 106 244 99 200 247 185 127 197 240 97 2 0 0 0 0 0 1 128 94 236 109 194 205 86 41 192 155 21 79 52 203 207 37 42 40 126 224 32 228 152 22 204 190 205 68 99 253 159 127 249 241 8 5 27 151 203 115 75 236 216 195 28 184 201 166 85 152 106 8 201 248 148 93 54 156 87 135 56 251 121 202 96 173 198 190 134 110 223 180 127 230 136 159 180 9 44 207 255 43 80 213 238 43 117 135 78 121 149 22 24 198 179 157 59 238 245 168 85 45 36 70 88 161 109 52 49 133 96 74 209 106 244 99 200 247 185 127 197 240 97 2 0 0 0 0 0 0 128 14 202 151 114 198 177 79 116 173 42 198 179 37 189 161 34 90 109 151 134 15 53 12 218 203 186 227 104 124 114 146 230 193 76 40 120 134 85 85 179 206 122 201 169 68 255 199 58 19 184 117 183 58 105 131 49 120 224 207 113 249 249 52 245 213 117 133 240 15 235 167 111 253 250 71 98 115 41 241 120 23 72 80 150 152 182 145 130 4 69 103 219 252 177 172 87 76 137 67 198 105 98 131 12 8 87 204 104 138 42 101 155 161 225 254 112 96 164 148 113 139 130 6 0 0 0 0 0 1 128 14 202 151 114 198 177 79 116 173 42 198 179 37 189 161 34 90 109 151 134 15 53 12 218 203 186 227 104 124 114 146 230 193 76 40 120 134 85 85 179 206 122 201 169 68 255 199 58 19 184 117 183 58 105 131 49 120 224 207 113 249 249 52 245 213 117 133 240 15 235 167 111 253 250 71 98 115 41 241 120 23 72 80 150 152 182 145 130 4 69 103 219 252 177 172 87 76 137 67 198 105 98 131 12 8 87 204 104 138 42 101 155 161 225 254 112 96 164 148 113 139 130 6 0 0 0 0 0 0 88 222 236 36 90 191 241 183 85 110 108 88 240 111 232 78 103 27 70 144 224 71 76 230 109 75 89 21 251 126 142 18 121 105 170 253 72 64 73 2 238 74 157 109 22 80 12 236 206 45 90 23 64 23 14 190 116 110 37 81 228 238 254 84 202 140 111 243 20 88 246 161 13 249 31 162 155 221 13 64 215 171 161 29 14 0 0 0 0 1 88 222 236 36 90 191 241 183 85 110 108 88 240 111 232 78 103 27 70 144 224 71 76 230 109 75 89 21 251 126 142 18 121 105 170 253 72 64 73 2 238 74 157 109 22 80 12 236 206 45 90 23 64 23 14 190 116 110 37 81 228 238 254 84 202 140 111 243 20 88 246 161 13 249 31 162 155 221 13 64 215 171 161 29 14 0 0 0 0 0 80 69 2 96 19 137 241 75 149 54 240 119 4 53 193 106 38 190 90 56 134 205 201 129 251 62 99 112 152 118 97 184 216 164 110 226 53 156 74 62 42 32 199 114 107 27 36 188 14 59 253 131 97 129 87 74 48 164 130 23 116 217 134 169 80 29 241 90 26 86 7 137 144 117 50 0 0 0 0 0 0 1 80 69 2 96 19 137 241 75 149 54 240 119 4 53 193 106 38 190 90 56 134 205 201 129 251 62 99 112 152 118 97 184 216 164 110 226 53 156 74 62 42 32 199 114 107 27 36 188 14 59 253 131 97 129 87 74 48 164 130 23 116 217 134 169 80 29 241 90 26 86 7 137 144 117 50 0 0 0 0 0 0 0 104 60 2 183 139 129 88 99 244 170 89 0 177 28 40 203 18 239 70 82 138 113 96 148 242 156 70 22 152 221 31 149 38 127 107 45 254 28 166 210 227 215 191 161 12 230 95 230 64 209 16 253 82 63 212 15 119 73 178 25 88 182 249 227 148 207 62 209 192 72 37 56 62 203 161 110 196 250 228 14 19 181 87 35 11 15 255 155 107 206 61 54 223 191 92 51 188 42 0 0 0 0 0 0 0 1 104 60 2 183 139 129 88 99 244 170 89 0 177 28 40 203 18 239 70 82 138 113 96 148 242 156 70 22 152 221 31 149 38 127 107 45 254 28 166 210 227 215 191 161 12 230 95 230 64 209 16 253 82 63 212 15 119 73 178 25 88 182 249 227 148 207 62 209 192 72 37 56 62 203 161 110 196 250 228 14 19 181 87 35 11 15 255 155 107 206 61 54 223 191 92 51 188 42 0 0 0 0 0 0 0 0 8 161 145 84 161 51 102 34 163 1 8 161 145 84 161 51 102 34 163 0 56 160 51 60 244 243 228 49 105 198 184 5 130 241 114 177 248 245 101 241 141 249 87 160 252 119 173 82 11 10 104 49 95 69 254 101 134 79 46 129 192 118 64 243 147 3 51 61 70 176 159 167 235 86 145 44 55 1 56 160 51 60 244 243 228 49 105 198 184 5 130 241 114 177 248 245 101 241 141 249 87 160 252 119 173 82 11 10 104 49 95 69 254 101 134 79 46 129 192 118 64 243 147 3 51 61 70 176 159 167 235 86 145 44 55 0 32 180 181 48 71 211 35 86 174 153 231 246 211 154 205 97 74 237 0 199 183 8 131 127 228 121 26 229 18 39 183 3 0 1 32 180 181 48 71 211 35 86 174 153 231 246 211 154 205 97 74 237 0 199 183 8 131 127 228 121 26 229 18 39 183 3 0 0 72 235 208 249 69 198 27 28 175 48 201 165 210 55 86 150 90 198 36 230 165 54 20 213 19 85 189 110 233 79 254 190 153 19 131 115 116 152 36 49 241 5 53 57 191 108 36 43 245 224 105 242 219 194 163 217 52 122 224 205 161 21 47 142 100 254 80 178 115 134 181 158 0 1 72 235 208 249 69 198 27 28 175 48 201 165 210 55 86 150 90 198 36 230 165 54 20 213 19 85 189 110 233 79 254 190 153 19 131 115 116 152 36 49 241 5 53 57 191 108 36 43 245 224 105 242 219 194 163 217 52 122 224 205 161 21 47 142 100 254 80 178 115 134 181 158 0 0 48 24 216 31 31 121 32 6 35 230 132 116 1 93 231 239 114 29 239 68 226 187 220 209 191 89 111 162 77 90 222 196 5 16 190 98 88 179 228 211 83 191 201 156 101 38 6 0 0 1 48 24 216 31 31 121 32 6 35 230 132 116 1 93 231 239 114 29 239 68 226 187 220 209 191 89 111 162 77 90 222 196 5 16 190 98 88 179 228 211 83 191 201 156 101 38 6 0 0 0 8 120 9 155 198 227 119 139 0 1 8 120 9 155 198 227 119 139 0 0 112 67 233 173 239 2 147 31 164 67 28 157 14 181 143 121 205 94 47 18 212 89 86 192 240 97 248 17 119 22 163 109 127 226 138 109 233 234 45 230 169 33 186 2 126 255 20 183 106 178 83 140 195 205 223 184 177 109 237 177 147 165 5 252 192 192 124 61 142 140 69 133 239 214 170 94 162 222 231 95 68 100 116 183 60 109 34 233 105 48 238 47 153 181 219 232 176 110 180 54 190 173 160 203 79 0 3 0 0 0 0 0 0 1 112 67 233 173 239 2 147 31 164 67 28 157 14 181 143 121 205 94 47 18 212 89 86 192 240 97 248 17 119 22 163 109 127 226 138 109 233 234 45 230 169 33 186 2 126 255 20 183 106 178 83 140 195 205 223 184 177 109 237 177 147 165 5 252 192 192 124 61 142 140 69 133 239 214 170 94 162 222 231 95 68 100 116 183 60 109 34 233 105 48 238 47 153 181 219 232 176 110 180 54 190 173 160 203 79 0 3 0 0 0 0 0 0 0 48 113 179 208 89 229 97 41 83 34 181 248 69 45 117 67 182 227 176 114 161 166 167 142 142 47 25 191 4 182 213 77 37 61 119 165 249 59 176 118 228 161 1 0 0 0 0 0 0 1 48 113 179 208 89 229 97 41 83 34 181 248 69 45 117 67 182 227 176 114 161 166 167 142 142 47 25 191 4 182 213 77 37 61 119 165 249 59 176 118 228 161 1 0 0 0 0 0 0 0 8 205 230 1 0 0 0 0 0 1 8 205 230 1 0 0 0 0 0 0 56 77 166 237 60 159 113 214 225 225 196 126 16 105 189 104 42 252 167 15 186 63 111 11 23 250 53 128 208 225 81 238 136 75 225 4 178 227 11 107 243 121 83 238 164 31 105 2 177 163 135 105 60 0 0 0 0 1 56 77 166 237 60 159 113 214 225 225 196 126 16 105 189 104 42 252 167 15 186 63 111 11 23 250 53 128 208 225 81 238 136 75 225 4 178 227 11 107 243 121 83 238 164 31 105 2 177 163 135 105 60 0 0 0 0 0 8 7 177 200 9 87 48 0 0 1 8 7 177 200 9 87 48 0 0 0 120 95 0 17 198 196 3 168 29 232 224 109 67 23 135 235 50 52 214 192 80 146 255 65 119 139 83 153 210 130 123 45 5 148 58 19 42 240 226 164 159 61 91 236 215 59 183 160 255 155 79 104 47 81 69 79 205 46 250 193 179 14 221 169 205 128 237 109 128 36 7 21 98 118 172 243 166 158 151 127 232 156 225 22 108 82 127 8 238 182 238 200 235 199 229 34 2 128 5 166 74 164 159 85 41 32 254 62 100 188 86 40 138 142 240 122 56 2 0 0 0 1 120 95 0 17 198 196 3 168 29 232 224 109 67 23 135 235 50 52 214 192 80 146 255 65 119 139 83 153 210 130 123 45 5 148 58 19 42 240 226 164 159 61 91 236 215 59 183 160 255 155 79 104 47 81 69 79 205 46 250 193 179 14 221 169 205 128 237 109 128 36 7 21 98 118 172 243 166 158 151 127 232 156 225 22 108 82 127 8 238 182 238 200 235 199 229 34 2 128 5 166 74 164 159 85 41 32 254 62 100 188 86 40 138 142 240 122 56 2 0 0 0 0 24 52 171 120 247 245 238 38 189 200 10 21 246 79 73 111 224 107 101 199 80 238 49 0 0 1 24 52 171 120 247 245 238 38 189 200 10 21 246 79 73 111 224 107 101 199 80 238 49 0 0 0 104 57 158 161 115 39 26 101 249 18 39 40 1 93 199 25 128 79 244 212 44 60 231 196 18 52 157 210 236 197 32 195 30 224 115 47 62 183 108 27 196 234 161 196 225 103 21 202 150 178 236 60 175 217 66 254 151 71 126 230 34 45 143 24 111 88 165 51 57 138 241 251 139 79 160 192 71 182 96 28 48 193 182 46 229 150 230 46 13 249 26 35 98 104 138 125 230 36 173 131 138 29 153 37 15 1 104 57 158 161 115 39 26 101 249 18 39 40 1 93 199 25 128 79 244 212 44 60 231 196 18 52 157 210 236 197 32 195 30 224 115 47 62 183 108 27 196 234 161 196 225 103 21 202 150 178 236 60 175 217 66 254 151 71 126 230 34 45 143 24 111 88 165 51 57 138 241 251 139 79 160 192 71 182 96 28 48 193 182 46 229 150 230 46 13 249 26 35 98 104 138 125 230 36 173 131 138 29 153 37 15 0 88 201 67 176 170 12 214 223 113 151 240 121 127 115 67 246 173 119 207 202 219 102 176 87 124 64 46 160 253 231 56 131 2 167 194 119 80 227 152 34 209 118 189 9 5 175 115 207 20 15 201 85 82 139 3 122 200 232 151 18 106 251 0 202 255 146 176 226 219 69 250 238 111 233 251 3 57 189 253 30 108 224 253 116 0 0 0 0 0 1 88 201 67 176 170 12 214 223 113 151 240 121 127 115 67 246 173 119 207 202 219 102 176 87 124 64 46 160 253 231 56 131 2 167 194 119 80 227 152 34 209 118 189 9 5 175 115 207 20 15 201 85 82 139 3 122 200 232 151 18 106 251 0 202 255 146 176 226 219 69 250 238 111 233 251 3 57 189 253 30 108 224 253 116 0 0 0 0 0 0 40 216 207 22 26 220 111 75 102 80 113 167 57 132 171 148 110 197 33 103 213 177 123 206 218 242 178 9 228 125 117 218 221 76 2 0 0 0 0 0 0 1 40 216 207 22 26 220 111 75 102 80 113 167 57 132 171 148 110 197 33 103 213 177 123 206 218 242 178 9 228 125 117 218 221 76 2 0 0 0 0 0 0 0 96 209 38 226 122 66 37 110 32 0 244 215 135 36 169 50 93 130 191 147 142 209 240 154 14 39 115 83 99 104 166 126 171 89 95 133 0 168 235 114 121 112 237 201 242 105 25 68 88 53 63 4 70 8 16 14 139 78 16 28 216 131 240 108 136 129 244 99 100 247 236 64 222 120 6 100 242 25 164 196 251 190 21 202 16 243 72 23 21 27 253 232 129 65 12 0 0 1 96 209 38 226 122 66 37 110 32 0 244 215 135 36 169 50 93 130 191 147 142 209 240 154 14 39 115 83 99 104 166 126 171 89 95 133 0 168 235 114 121 112 237 201 242 105 25 68 88 53 63 4 70 8 16 14 139 78 16 28 216 131 240 108 136 129 244 99 100 247 236 64 222 120 6 100 242 25 164 196 251 190 21 202 16 243 72 23 21 27 253 232 129 65 12 0 0 0 24 137 7 71 104 123 1 230 162 84 85 84 78 76 1 146 149 3 0 0 0 0 0 0 0 1 24 137 7 71 104 123 1 230 162 84 85 84 78 76 1 146 149 3 0 0 0 0 0 0 0 0 88 17 135 189 91 189 22 119 161 7 236 246 162 42 137 207 149 58 10 147 68 241 83 242 92 176 9 168 195 250 98 204 19 131 82 40 2 115 30 134 119 85 234 171 51 248 6 232 13 126 100 100 208 191 92 68 52 56 79 102 83 41 100 249 214 204 9 147 69 246 254 24 120 21 121 111 194 137 125 190 39 201 58 31 0 0 0 0 0 1 88 17 135 189 91 189 22 119 161 7 236 246 162 42 137 207 149 58 10 147 68 241 83 242 92 176 9 168 195 250 98 204 19 131 82 40 2 115 30 134 119 85 234 171 51 248 6 232 13 126 100 100 208 191 92 68 52 56 79 102 83 41 100 249 214 204 9 147 69 246 254 24 120 21 121 111 194 137 125 190 39 201 58 31 0 0 0 0 0 0 64 174 140 149 163 3 107 111 4 34 250 106 21 208 102 247 217 125 106 201 189 50 165 180 247 173 193 91 219 22 221 135 48 75 167 217 77 123 120 130 238 30 6 129 157 63 162 58 79 199 175 93 130 164 195 209 241 206 111 166 90 218 65 223 2 1 64 174 140 149 163 3 107 111 4 34 250 106 21 208 102 247 217 125 106 201 189 50 165 180 247 173 193 91 219 22 221 135 48 75 167 217 77 123 120 130 238 30 6 129 157 63 162 58 79 199 175 93 130 164 195 209 241 206 111 166 90 218 65 223 2 0 64 94 39 245 99 17 252 182 140 162 112 156 230 137 46 180 2 25 35 78 204 212 30 138 67 63 147 188 132 251 223 228 122 221 52 247 47 60 130 213 221 67 57 251 17 236 100 5 136 157 85 85 137 180 82 210 206 141 57 0 0 0 0 0 0 1 64 94 39 245 99 17 252 182 140 162 112 156 230 137 46 180 2 25 35 78 204 212 30 138 67 63 147 188 132 251 223 228 122 221 52 247 47 60 130 213 221 67 57 251 17 236 100 5 136 157 85 85 137 180 82 210 206 141 57 0 0 0 0 0 0 0 56 130 153 165 204 195 100 32 242 200 177 22 23 48 222 90 173 238 62 11 195 207 31 94 106 111 19 23 102 123 154 11 25 69 140 143 38 27 47 211 73 199 58 157 241 52 98 114 254 14 0 0 0 0 0 0 0 1 56 130 153 165 204 195 100 32 242 200 177 22 23 48 222 90 173 238 62 11 195 207 31 94 106 111 19 23 102 123 154 11 25 69 140 143 38 27 47 211 73 199 58 157 241 52 98 114 254 14 0 0 0 0 0 0 0 0 72 242 139 53 248 243 242 47 139 119 188 176 74 227 81 33 108 130 169 69 136 245 21 31 87 103 135 189 216 110 191 185 187 15 111 235 113 59 97 210 163 3 82 39 248 57 165 173 26 7 64 153 147 109 165 237 85 23 91 144 96 82 212 163 110 172 233 196 20 189 194 1 0 1 72 242 139 53 248 243 242 47 139 119 188 176 74 227 81 33 108 130 169 69 136 245 21 31 87 103 135 189 216 110 191 185 187 15 111 235 113 59 97 210 163 3 82 39 248 57 165 173 26 7 64 153 147 109 165 237 85 23 91 144 96 82 212 163 110 172 233 196 20 189 194 1 0 0 96 63 196 195 103 33 69 53 0 35 106 115 86 145 225 79 206 13 41 97 138 221 49 15 101 120 43 207 2 164 87 76 203 63 18 204 117 208 102 150 11 45 65 74 88 87 11 31 221 40 244 204 108 35 1 221 236 192 33 114 34 255 16 27 102 160 251 229 204 178 67 44 210 45 249 116 212 232 9 246 165 134 232 228 248 94 170 234 243 13 232 1 125 0 0 0 0 1 96 63 196 195 103 33 69 53 0 35 106 115 86 145 225 79 206 13 41 97 138 221 49 15 101 120 43 207 2 164 87 76 203 63 18 204 117 208 102 150 11 45 65 74 88 87 11 31 221 40 244 204 108 35 1 221 236 192 33 114 34 255 16 27 102 160 251 229 204 178 67 44 210 45 249 116 212 232 9 246 165 134 232 228 248 94 170 234 243 13 232 1 125 0 0 0 0 0 40 179 181 131 162 149 183 138 252 30 154 1 146 137 121 52 190 246 1 224 28 36 102 79 202 159 212 210 252 214 150 156 61 194 235 164 133 239 142 0 0 1 40 179 181 131 162 149 183 138 252 30 154 1 146 137 121 52 190 246 1 224 28 36 102 79 202 159 212 210 252 214 150 156 61 194 235 164 133 239 142 0 0 0 40 60 58 79 249 6 113 81 42 62 163 64 45 148 17 196 92 207 75 88 80 225 216 133 32 64 220 110 107 147 131 21 223 245 83 192 232 107 0 0 0 1 40 60 58 79 249 6 113 81 42 62 163 64 45 148 17 196 92 207 75 88 80 225 216 133 32 64 220 110 107 147 131 21 223 245 83 192 232 107 0 0 0 0 96 12 165 17 255 148 106 77 76 190 146 244 60 246 21 69 4 108 6 135 121 71 44 77 148 210 123 228 244 192 7 178 234 75 27 35 56 139 157 89 246 205 166 104 142 71 22 111 74 215 198 253 47 185 250 203 223 186 72 48 140 56 78 5 248 174 81 223 135 55 86 65 183 39 125 199 89 36 113 114 101 100 241 34 118 182 139 64 184 93 41 222 250 83 8 126 2 1 96 12 165 17 255 148 106 77 76 190 146 244 60 246 21 69 4 108 6 135 121 71 44 77 148 210 123 228 244 192 7 178 234 75 27 35 56 139 157 89 246 205 166 104 142 71 22 111 74 215 198 253 47 185 250 203 223 186 72 48 140 56 78 5 248 174 81 223 135 55 86 65 183 39 125 199 89 36 113 114 101 100 241 34 118 182 139 64 184 93 41 222 250 83 8 126 2 0 80 194 39 168 144 47 63 164 168 230 144 217 13 24 96 155 100 12 59 177 151 216 92 228 192 145 88 206 81 45 221 226 39 93 88 12 250 68 153 137 36 20 58 0 113 35 195 22 121 71 66 8 241 39 201 196 133 230 128 125 7 217 82 221 87 57 93 151 146 24 13 11 157 51 151 229 8 102 193 170 254 1 80 194 39 168 144 47 63 164 168 230 144 217 13 24 96 155 100 12 59 177 151 216 92 228 192 145 88 206 81 45 221 226 39 93 88 12 250 68 153 137 36 20 58 0 113 35 195 22 121 71 66 8 241 39 201 196 133 230 128 125 7 217 82 221 87 57 93 151 146 24 13 11 157 51 151 229 8 102 193 170 254 0 32 115 165 0 181 114 222 7 59 3 124 183 26 196 172 167 125 136 168 200 232 107 92 130 217 10 0 0 0 0 0 0 0 1 32 115 165 0 181 114 222 7 59 3 124 183 26 196 172 167 125 136 168 200 232 107 92 130 217 10 0 0 0 0 0 0 0 0 104 236 68 87 125 155 29 32 62 230 30 136 150 217 197 37 30 35 255 242 108 93 176 111 33 250 237 114 238 160 77 113 171 147 43 61 144 12 84 87 115 160 128 222 109 180 248 55 195 181 75 255 203 79 219 130 244 94 36 238 156 212 175 171 162 174 87 117 209 113 175 106 193 36 21 66 244 243 166 248 81 121 94 110 189 10 52 188 102 198 136 150 183 191 180 96 29 51 207 65 251 163 177 216 188 1 104 236 68 87 125 155 29 32 62 230 30 136 150 217 197 37 30 35 255 242 108 93 176 111 33 250 237 114 238 160 77 113 171 147 43 61 144 12 84 87 115 160 128 222 109 180 248 55 195 181 75 255 203 79 219 130 244 94 36 238 156 212 175 171 162 174 87 117 209 113 175 106 193 36 21 66 244 243 166 248 81 121 94 110 189 10 52 188 102 198 136 150 183 191 180 96 29 51 207 65 251 163 177 216 188 0 88 199 62 219 38 224 64 98 122 250 132 90 246 191 177 175 129 238 74 103 140 144 205 156 27 249 53 223 251 192 95 121 104 139 113 181 72 177 157 33 140 244 253 143 104 230 164 205 233 17 33 203 84 40 89 149 26 16 144 238 213 168 166 242 186 189 255 169 165 234 16 127 90 100 62 217 16 139 41 102 89 93 97 62 95 147 122 238 237 1 88 199 62 219 38 224 64 98 122 250 132 90 246 191 177 175 129 238 74 103 140 144 205 156 27 249 53 223 251 192 95 121 104 139 113 181 72 177 157 33 140 244 253 143 104 230 164 205 233 17 33 203 84 40 89 149 26 16 144 238 213 168 166 242 186 189 255 169 165 234 16 127 90 100 62 217 16 139 41 102 89 93 97 62 95 147 122 238 237 0 48 45 84 26 33 30 184 117 77 114 45 211 193 64 207 224 237 136 114 3 145 150 20 213 238 240 36 201 64 122 69 244 22 129 142 201 1 185 151 174 233 1 0 0 0 0 0 0 0 1 48 45 84 26 33 30 184 117 77 114 45 211 193 64 207 224 237 136 114 3 145 150 20 213 238 240 36 201 64 122 69 244 22 129 142 201 1 185 151 174 233 1 0 0 0 0 0 0 0 0 24 118 96 110 163 151 234 7 30 202 198 169 47 210 145 198 195 223 20 211 133 162 187 75 48 1 24 118 96 110 163 151 234 7 30 202 198 169 47 210 145 198 195 223 20 211 133 162 187 75 48 0 56 166 132 83 15 114 76 5 198 105 107 64 21 201 37 152 38 123 234 29 114 185 178 23 194 54 124 93 52 128 139 153 108 32 85 243 44 247 113 25 108 194 143 136 29 222 174 212 74 73 19 0 0 0 0 0 0 1 56 166 132 83 15 114 76 5 198 105 107 64 21 201 37 152 38 123 234 29 114 185 178 23 194 54 124 93 52 128 139 153 108 32 85 243 44 247 113 25 108 194 143 136 29 222 174 212 74 73 19 0 0 0 0 0 0 0 48 123 248 179 54 119 191 224 218 82 168 17 9 213 235 78 184 70 111 32 105 157 160 212 123 240 230 248 188 30 46 115 251 167 248 212 75 179 20 91 203 47 80 142 34 152 174 246 1 1 48 123 248 179 54 119 191 224 218 82 168 17 9 213 235 78 184 70 111 32 105 157 160 212 123 240 230 248 188 30 46 115 251 167 248 212 75 179 20 91 203 47 80 142 34 152 174 246 1 0 48 156 96 100 244 230 81 145 6 56 18 242 19 211 56 11 208 136 192 193 247 21 84 210 245 251 22 164 190 142 62 191 235 148 86 107 108 228 229 161 113 8 169 132 37 3 0 0 0 1 48 156 96 100 244 230 81 145 6 56 18 242 19 211 56 11 208 136 192 193 247 21 84 210 245 251 22 164 190 142 62 191 235 148 86 107 108 228 229 161 113 8 169 132 37 3 0 0 0 0 88 253 53 33 48 131 189 25 65 204 174 99 186 204 72 230 129 192 106 8 141 23 186 143 8 176 75 97 190 2 190 127 52 92 22 252 200 15 45 98 21 11 157 128 28 145 217 54 150 99 213 145 99 58 65 64 149 218 156 253 58 0 9 210 203 145 96 237 185 130 70 116 6 209 240 157 58 59 8 33 55 1 0 0 0 0 0 0 0 1 88 253 53 33 48 131 189 25 65 204 174 99 186 204 72 230 129 192 106 8 141 23 186 143 8 176 75 97 190 2 190 127 52 92 22 252 200 15 45 98 21 11 157 128 28 145 217 54 150 99 213 145 99 58 65 64 149 218 156 253 58 0 9 210 203 145 96 237 185 130 70 116 6 209 240 157 58 59 8 33 55 1 0 0 0 0 0 0 0 0 112 140 139 49 207 205 64 240 199 59 87 85 34 45 23 247 226 20 175 76 118 24 188 97 163 249 238 130 105 219 76 167 90 29 31 159 229 181 73 152 183 74 134 209 139 34 200 210 113 231 227 99 224 196 220 80 243 62 167 195 5 201 123 178 100 95 190 235 171 32 64 54 178 111 83 175 134 22 73 175 164 79 39 170 74 102 74 233 210 216 226 3 131 100 81 201 127 195 224 208 29 109 171 156 77 11 0 0 0 0 0 0 0 1 112 140 139 49 207 205 64 240 199 59 87 85 34 45 23 247 226 20 175 76 118 24 188 97 163 249 238 130 105 219 76 167 90 29 31 159 229 181 73 152 183 74 134 209 139 34 200 210 113 231 227 99 224 196 220 80 243 62 167 195 5 201 123 178 100 95 190 235 171 32 64 54 178 111 83 175 134 22 73 175 164 79 39 170 74 102 74 233 210 216 226 3 131 100 81 201 127 195 224 208 29 109 171 156 77 11 0 0 0 0 0 0 0 0 104 222 231 217 128 82 99 10 214 110 228 128 78 114 45 119 81 180 185 243 203 206 92 162 40 82 46 54 187 93 28 152 69 4 123 103 77 208 204 181 235 42 147 170 143 2 139 154 218 144 51 223 215 163 89 75 72 123 205 0 240 64 100 207 207 158 197 65 249 187 175 80 167 154 152 209 32 55 42 171 219 232 238 66 244 61 205 209 141 94 43 111 8 205 151 59 230 205 24 205 241 0 0 0 0 1 104 222 231 217 128 82 99 10 214 110 228 128 78 114 45 119 81 180 185 243 203 206 92 162 40 82 46 54 187 93 28 152 69 4 123 103 77 208 204 181 235 42 147 170 143 2 139 154 218 144 51 223 215 163 89 75 72 123 205 0 240 64 100 207 207 158 197 65 249 187 175 80 167 154 152 209 32 55 42 171 219 232 238 66 244 61 205 209 141 94 43 111 8 205 151 59 230 205 24 205 241 0 0 0 0 0 88 207 251 142 39 144 108 252 57 106 73 11 186 19 131 187 69 26 149 177 211 238 136 251 62 89 7 238 7 115 168 92 155 211 100 253 171 162 138 116 33 152 91 134 33 55 71 164 201 152 4 49 26 55 186 161 250 57 85 28 39 171 17 196 138 245 10 0 73 155 144 183 97 4 3 242 240 169 248 22 116 210 225 61 191 6 115 0 0 1 88 207 251 142 39 144 108 252 57 106 73 11 186 19 131 187 69 26 149 177 211 238 136 251 62 89 7 238 7 115 168 92 155 211 100 253 171 162 138 116 33 152 91 134 33 55 71 164 201 152 4 49 26 55 186 161 250 57 85 28 39 171 17 196 138 245 10 0 73 155 144 183 97 4 3 242 240 169 248 22 116 210 225 61 191 6 115 0 0 0 16 137 130 140 24 236 12 214 199 10 105 31 0 0 0 0 0 1 16 137 130 140 24 236 12 214 199 10 105 31 0 0 0 0 0 0 56 108 175 196 156 55 213 72 113 207 244 180 56 88 213 35 165 75 248 211 20 212 57 60 188 217 211 48 37 134 141 243 246 161 245 39 195 123 248 138 183 15 28 111 146 50 155 93 170 4 0 0 0 0 0 0 0 1 56 108 175 196 156 55 213 72 113 207 244 180 56 88 213 35 165 75 248 211 20 212 57 60 188 217 211 48 37 134 141 243 246 161 245 39 195 123 248 138 183 15 28 111 146 50 155 93 170 4 0 0 0 0 0 0 0 0 120 112 113 30 136 233 190 54 137 121 169 50 162 49 32 173 179 18 162 50 40 203 206 65 185 66 186 230 219 176 80 103 123 27 250 226 122 23 191 77 80 214 47 76 55 89 65 20 139 103 231 246 32 248 93 179 33 222 25 246 60 212 174 114 116 72 105 47 23 51 143 138 172 27 39 246 135 133 254 162 107 108 22 2 166 141 243 6 251 77 176 135 206 2 231 124 148 132 69 84 79 111 64 235 234 76 164 46 49 159 31 188 209 182 60 173 197 202 76 16 0 1 120 112 113 30 136 233 190 54 137 121 169 50 162 49 32 173 179 18 162 50 40 203 206 65 185 66 186 230 219 176 80 103 123 27 250 226 122 23 191 77 80 214 47 76 55 89 65 20 139 103 231 246 32 248 93 179 33 222 25 246 60 212 174 114 116 72 105 47 23 51 143 138 172 27 39 246 135 133 254 162 107 108 22 2 166 141 243 6 251 77 176 135 206 2 231 124 148 132 69 84 79 111 64 235 234 76 164 46 49 159 31 188 209 182 60 173 197 202 76 16 0 0 64 47 160 84 82 9 238 207 219 151 156 134 131 89 62 11 68 11 147 237 99 121 15 73 200 84 95 87 214 232 187 96 240 53 52 195 55 200 190 88 28 76 29 80 151 156 97 63 20 181 127 200 147 98 254 76 151 61 118 77 0 0 0 0 0 1 64 47 160 84 82 9 238 207 219 151 156 134 131 89 62 11 68 11 147 237 99 121 15 73 200 84 95 87 214 232 187 96 240 53 52 195 55 200 190 88 28 76 29 80 151 156 97 63 20 181 127 200 147 98 254 76 151 61 118 77 0 0 0 0 0 0 104 238 56 196 120 62 80 239 58 25 190 123 255 60 22 240 193 64 200 155 205 65 125 162 46 114 82 168 130 71 226 104 252 45 143 77 84 254 194 132 208 96 195 7 173 173 156 202 242 175 234 16 37 97 18 174 179 230 94 208 69 94 78 160 223 97 151 58 36 237 203 214 110 180 89 134 104 29 12 23 140 193 36 70 29 183 50 17 167 28 12 196 65 172 236 156 91 251 73 127 1 0 0 0 0 1 104 238 56 196 120 62 80 239 58 25 190 123 255 60 22 240 193 64 200 155 205 65 125 162 46 114 82 168 130 71 226 104 252 45 143 77 84 254 194 132 208 96 195 7 173 173 156 202 242 175 234 16 37 97 18 174 179 230 94 208 69 94 78 160 223 97 151 58 36 237 203 214 110 180 89 134 104 29 12 23 140 193 36 70 29 183 50 17 167 28 12 196 65 172 236 156 91 251 73 127 1 0 0 0 0 0 40 149 114 1 116 102 17 2 174 6 173 97 185 176 52 172 147 84 122 233 135 57 32 185 232 151 166 16 42 84 99 130 237 14 101 51 119 173 115 53 0 1 40 149 114 1 116 102 17 2 174 6 173 97 185 176 52 172 147 84 122 233 135 57 32 185 232 151 166 16 42 84 99 130 237 14 101 51 119 173 115 53 0 0 64 242 217 97 202 37 38 150 206 207 10 52 100 102 27 105 39 214 77 170 228 242 244 122 45 230 139 116 113 248 171 76 193 78 80 198 37 181 97 228 185 29 21 241 62 210 131 193 6 1 89 93 123 149 252 254 234 21 49 121 54 70 123 12 0 1 64 242 217 97 202 37 38 150 206 207 10 52 100 102 27 105 39 214 77 170 228 242 244 122 45 230 139 116 113 248 171 76 193 78 80 198 37 181 97 228 185 29 21 241 62 210 131 193 6 1 89 93 123 149 252 254 234 21 49 121 54 70 123 12 0 0 120 126 216 172 15 25 129 241 98 17 2 168 135 214 24 154 85 56 125 146 150 225 161 82 46 26 201 64 204 132 245 111 192 88 211 123 3 119 58 58 245 118 104 138 91 147 19 185 226 101 33 139 62 235 15 91 204 29 220 53 8 11 61 142 142 93 77 162 71 38 142 116 213 43 79 225 85 174 86 234 214 249 189 86 69 229 181 99 122 154 144 192 66 13 218 96 118 124 80 14 168 5 230 111 79 37 76 42 49 185 18 80 157 188 50 80 199 22 0 0 0 1 120 126 216 172 15 25 129 241 98 17 2 168 135 214 24 154 85 56 125 146 150 225 161 82 46 26 201 64 204 132 245 111 192 88 211 123 3 119 58 58 245 118 104 138 91 147 19 185 226 101 33 139 62 235 15 91 204 29 220 53 8 11 61 142 142 93 77 162 71 38 142 116 213 43 79 225 85 174 86 234 214 249 189 86 69 229 181 99 122 154 144 192 66 13 218 96 118 124 80 14 168 5 230 111 79 37 76 42 49 185 18 80 157 188 50 80 199 22 0 0 0 0 56 243 53 196 121 165 92 144 118 3 3 222 84 206 144 5 157 57 16 134 139 198 69 129 221 11 133 183 218 71 108 13 56 83 246 113 103 6 198 202 227 68 93 146 59 161 12 248 177 166 51 150 47 96 161 239 236 1 56 243 53 196 121 165 92 144 118 3 3 222 84 206 144 5 157 57 16 134 139 198 69 129 221 11 133 183 218 71 108 13 56 83 246 113 103 6 198 202 227 68 93 146 59 161 12 248 177 166 51 150 47 96 161 239 236 0 64 153 28 132 11 210 222 158 84 204 251 210 22 227 11 36 206 23 140 161 60 159 143 123 206 191 31 7 46 144 178 243 58 169 39 112 174 47 119 109 7 130 69 51 2 125 253 241 144 64 234 96 3 245 113 8 190 14 182 65 46 222 249 3 0 1 64 153 28 132 11 210 222 158 84 204 251 210 22 227 11 36 206 23 140 161 60 159 143 123 206 191 31 7 46 144 178 243 58 169 39 112 174 47 119 109 7 130 69 51 2 125 253 241 144 64 234 96 3 245 113 8 190 14 182 65 46 222 249 3 0 0 64 98 185 79 194 105 170 12 86 252 124 124 192 23 205 211 77 162 50 205 89 40 158 46 179 237 22 171 26 56 121 32 6 69 111 60 114 251 180 204 199 96 135 46 64 144 243 102 201 99 166 113 208 152 168 179 161 1 6 0 0 0 0 0 0 1 64 98 185 79 194 105 170 12 86 252 124 124 192 23 205 211 77 162 50 205 89 40 158 46 179 237 22 171 26 56 121 32 6 69 111 60 114 251 180 204 199 96 135 46 64 144 243 102 201 99 166 113 208 152 168 179 161 1 6 0 0 0 0 0 0 0 104 142 26 227 150 238 69 151 6 3 30 46 190 46 96 134 217 131 85 161 92 34 208 158 197 175 196 117 64 216 114 195 81 101 252 52 106 185 71 47 193 32 27 53 120 25 14 193 3 5 106 149 116 208 152 66 126 218 195 178 209 4 241 87 44 185 217 57 224 49 139 77 191 217 218 19 215 78 14 143 87 180 5 177 20 62 54 52 235 79 31 44 20 98 23 221 250 34 0 0 0 0 0 0 0 1 104 142 26 227 150 238 69 151 6 3 30 46 190 46 96 134 217 131 85 161 92 34 208 158 197 175 196 117 64 216 114 195 81 101 252 52 106 185 71 47 193 32 27 53 120 25 14 193 3 5 106 149 116 208 152 66 126 218 195 178 209 4 241 87 44 185 217 57 224 49 139 77 191 217 218 19 215 78 14 143 87 180 5 177 20 62 54 52 235 79 31 44 20 98 23 221 250 34 0 0 0 0 0 0 0 0 40 32 168 235 44 56 166 243 210 154 91 226 40 229 249 145 209 125 211 169 133 252 161 224 125 81 253 117 254 153 178 166 34 26 180 249 135 33 222 152 13 1 40 32 168 235 44 56 166 243 210 154 91 226 40 229 249 145 209 125 211 169 133 252 161 224 125 81 253 117 254 153 178 166 34 26 180 249 135 33 222 152 13 0 16 114 51 72 217 92 64 168 124 50 132 58 208 128 106 1 0 1 16 114 51 72 217 92 64 168 124 50 132 58 208 128 106 1 0 0 72 69 4 0 153 42 90 20 74 230 90 168 97 72 101 100 19 28 241 147 219 3 93 60 246 145 183 55 230 232 224 115 211 143 158 209 214 247 84 89 209 186 139 133 34 124 5 207 184 125 115 201 88 222 241 97 109 108 6 13 211 125 187 117 94 222 2 0 0 0 0 0 0 1 72 69 4 0 153 42 90 20 74 230 90 168 97 72 101 100 19 28 241 147 219 3 93 60 246 145 183 55 230 232 224 115 211 143 158 209 214 247 84 89 209 186 139 133 34 124 5 207 184 125 115 201 88 222 241 97 109 108 6 13 211 125 187 117 94 222 2 0 0 0 0 0 0 0 56 153 84 205 104 19 159 225 153 148 74 194 235 72 23 144 76 152 243 229 1 90 189 92 32 175 52 88 183 242 20 84 239 175 56 99 222 31 211 114 93 122 135 65 160 226 51 48 207 12 116 28 0 0 0 0 0 1 56 153 84 205 104 19 159 225 153 148 74 194 235 72 23 144 76 152 243 229 1 90 189 92 32 175 52 88 183 242 20 84 239 175 56 99 222 31 211 114 93 122 135 65 160 226 51 48 207 12 116 28 0 0 0 0 0 0 72 245 53 109 105 191 82 1 66 103 122 80 160 241 193 52 254 117 182 127 138 99 142 106 221 128 239 15 222 14 129 176 110 43 113 122 176 232 88 250 58 0 161 215 14 126 59 139 23 140 13 122 239 14 189 40 72 35 18 82 213 254 53 121 213 234 12 0 0 0 0 0 0 1 72 245 53 109 105 191 82 1 66 103 122 80 160 241 193 52 254 117 182 127 138 99 142 106 221 128 239 15 222 14 129 176 110 43 113 122 176 232 88 250 58 0 161 215 14 126 59 139 23 140 13 122 239 14 189 40 72 35 18 82 213 254 53 121 213 234 12 0 0 0 0 0 0 0 112 159 8 16 9 71 195 199 198 21 242 159 80 249 120 17 254 76 140 121 166 78 213 92 89 178 160 20 177 8 14 182 122 65 115 133 119 121 16 112 118 105 211 205 62 12 236 55 80 1 131 163 0 83 205 178 80 88 102 233 133 195 61 239 174 246 227 234 216 85 176 76 5 36 121 112 51 212 181 246 245 241 105 195 137 147 72 56 237 179 190 73 134 142 177 146 141 8 159 112 222 16 234 231 234 198 20 89 52 189 194 119 1 1 112 159 8 16 9 71 195 199 198 21 242 159 80 249 120 17 254 76 140 121 166 78 213 92 89 178 160 20 177 8 14 182 122 65 115 133 119 121 16 112 118 105 211 205 62 12 236 55 80 1 131 163 0 83 205 178 80 88 102 233 133 195 61 239 174 246 227 234 216 85 176 76 5 36 121 112 51 212 181 246 245 241 105 195 137 147 72 56 237 179 190 73 134 142 177 146 141 8 159 112 222 16 234 231 234 198 20 89 52 189 194 119 1 0 112 80 214 13 177 215 159 125 169 151 12 42 72 121 18 76 208 238 240 149 68 234 73 20 164 91 171 220 52 255 98 21 228 111 4 175 56 163 222 123 128 30 97 59 67 228 49 187 237 223 220 86 109 144 229 187 251 70 7 146 195 116 106 122 232 185 78 78 58 225 39 134 160 118 235 208 242 69 148 226 101 73 25 136 159 25 99 137 101 248 54 26 247 229 7 34 61 19 28 201 190 36 74 102 133 25 0 0 0 0 0 0 0 1 112 80 214 13 177 215 159 125 169 151 12 42 72 121 18 76 208 238 240 149 68 234 73 20 164 91 171 220 52 255 98 21 228 111 4 175 56 163 222 123 128 30 97 59 67 228 49 187 237 223 220 86 109 144 229 187 251 70 7 146 195 116 106 122 232 185 78 78 58 225 39 134 160 118 235 208 242 69 148 226 101 73 25 136 159 25 99 137 101 248 54 26 247 229 7 34 61 19 28 201 190 36 74 102 133 25 0 0 0 0 0 0 0 0 48 214 54 94 179 164 240 155 40 191 186 107 180 206 48 82 137 213 91 241 62 39 183 229 184 237 121 223 179 199 117 185 240 244 56 38 125 32 5 140 166 122 78 243 77 252 116 1 0 1 48 214 54 94 179 164 240 155 40 191 186 107 180 206 48 82 137 213 91 241 62 39 183 229 184 237 121 223 179 199 117 185 240 244 56 38 125 32 5 140 166 122 78 243 77 252 116 1 0 0 104 54 55 200 109 82 156 202 152 175 66 36 193 252 78 5 135 125 117 139 57 40 153 71 77 232 6 37 188 28 77 2 71 137 173 143 223 127 105 125 144 234 178 168 38 38 22 213 12 86 146 58 86 128 124 44 36 53 34 45 2 168 71 121 160 250 8 153 10 51 71 123 250 225 95 140 177 159 103 47 148 120 154 141 97 250 155 186 25 61 104 158 48 167 246 20 132 6 84 93 66 112 47 0 0 1 104 54 55 200 109 82 156 202 152 175 66 36 193 252 78 5 135 125 117 139 57 40 153 71 77 232 6 37 188 28 77 2 71 137 173 143 223 127 105 125 144 234 178 168 38 38 22 213 12 86 146 58 86 128 124 44 36 53 34 45 2 168 71 121 160 250 8 153 10 51 71 123 250 225 95 140 177 159 103 47 148 120 154 141 97 250 155 186 25 61 104 158 48 167 246 20 132 6 84 93 66 112 47 0 0 0 120 6 90 182 206 193 58 216 170 220 9 22 52 156 242 120 157 30 209 26 98 51 196 178 88 228 65 154 229 210 70 170 198 64 16 247 102 16 21 58 87 235 200 244 76 203 136 132 209 76 195 94 143 2 113 149 235 158 1 227 205 1 208 16 81 131 189 40 241 92 36 170 156 224 56 199 188 154 79 125 102 121 78 97 150 233 11 79 62 109 25 212 226 161 220 35 23 232 13 90 56 183 223 124 31 159 158 14 223 62 85 83 193 110 187 158 93 203 8 0 0 1 120 6 90 182 206 193 58 216 170 220 9 22 52 156 242 120 157 30 209 26 98 51 196 178 88 228 65 154 229 210 70 170 198 64 16 247 102 16 21 58 87 235 200 244 76 203 136 132 209 76 195 94 143 2 113 149 235 158 1 227 205 1 208 16 81 131 189 40 241 92 36 170 156 224 56 199 188 154 79 125 102 121 78 97 150 233 11 79 62 109 25 212 226 161 220 35 23 232 13 90 56 183 223 124 31 159 158 14 223 62 85 83 193 110 187 158 93 203 8 0 0 0 88 47 45 238 181 215 239 242 99 34 179 237 146 38 184 178 32 39 156 91 232 37 68 223 154 247 174 99 147 112 220 68 13 168 71 188 111 58 166 58 109 244 156 76 173 12 217 7 247 229 168 222 84 82 81 171 9 74 74 20 144 71 106 164 117 234 163 235 12 58 184 167 68 145 254 103 0 233 175 219 91 115 45 23 0 0 0 0 0 1 88 47 45 238 181 215 239 242 99 34 179 237 146 38 184 178 32 39 156 91 232 37 68 223 154 247 174 99 147 112 220 68 13 168 71 188 111 58 166 58 109 244 156 76 173 12 217 7 247 229 168 222 84 82 81 171 9 74 74 20 144 71 106 164 117 234 163 235 12 58 184 167 68 145 254 103 0 233 175 219 91 115 45 23 0 0 0 0 0 0 72 40 180 241 104 90 252 242 234 235 240 236 39 250 255 76 167 29 116 156 87 88 207 205 175 125 89 77 12 21 97 61 253 152 65 25 101 5 139 108 225 153 138 24 18 112 100 115 211 39 249 92 242 104 78 15 126 214 21 35 238 183 248 195 174 170 41 249 203 160 8 0 0 1 72 40 180 241 104 90 252 242 234 235 240 236 39 250 255 76 167 29 116 156 87 88 207 205 175 125 89 77 12 21 97 61 253 152 65 25 101 5 139 108 225 153 138 24 18 112 100 115 211 39 249 92 242 104 78 15 126 214 21 35 238 183 248 195 174 170 41 249 203 160 8 0 0 0 56 22 27 151 194 115 92 119 11 236 51 137 144 137 103 129 95 89 105 130 240 243 170 243 35 191 215 206 102 95 172 26 80 149 177 248 238 54 111 45 244 22 23 22 224 158 95 94 118 19 0 0 0 0 0 0 0 1 56 22 27 151 194 115 92 119 11 236 51 137 144 137 103 129 95 89 105 130 240 243 170 243 35 191 215 206 102 95 172 26 80 149 177 248 238 54 111 45 244 22 23 22 224 158 95 94 118 19 0 0 0 0 0 0 0 0 24 156 43 16 56 55 4 61 155 177 58 74 163 225 4 11 131 179 24 1 0 0 0 0 0 1 24 156 43 16 56 55 4 61 155 177 58 74 163 225 4 11 131 179 24 1 0 0 0 0 0 0 104 73 76 101 151 31 35 209 56 36 69 31 173 147 81 94 123 172 22 210 79 45 203 20 140 58 218 46 34 183 138 96 94 97 161 218 71 10 21 254 228 117 64 245 83 14 74 129 103 121 90 57 125 205 210 39 213 162 107 185 36 194 249 86 241 82 226 200 210 202 80 195 105 63 67 249 109 65 100 248 77 32 184 210 162 76 62 215 70 139 167 97 35 196 73 132 172 243 85 144 160 14 20 22 193 1 104 73 76 101 151 31 35 209 56 36 69 31 173 147 81 94 123 172 22 210 79 45 203 20 140 58 218 46 34 183 138 96 94 97 161 218 71 10 21 254 228 117 64 245 83 14 74 129 103 121 90 57 125 205 210 39 213 162 107 185 36 194 249 86 241 82 226 200 210 202 80 195 105 63 67 249 109 65 100 248 77 32 184 210 162 76 62 215 70 139 167 97 35 196 73 132 172 243 85 144 160 14 20 22 193 0 32 126 1 30 104 79 113 99 127 177 76 179 201 53 24 182 29 192 54 96 132 91 248 133 211 86 2 0 0 0 0 0 0 1 32 126 1 30 104 79 113 99 127 177 76 179 201 53 24 182 29 192 54 96 132 91 248 133 211 86 2 0 0 0 0 0 0 0 72 92 159 45 128 70 93 245 63 92 118 241 226 212 23 182 127 131 42 229 253 64 210 240 253 132 150 70 236 28 94 44 2 105 246 1 151 224 138 233 135 254 20 25 124 118 13 182 172 20 197 252 20 174 143 186 57 51 58 222 119 36 51 0 104 163 78 183 107 2 0 0 0 1 72 92 159 45 128 70 93 245 63 92 118 241 226 212 23 182 127 131 42 229 253 64 210 240 253 132 150 70 236 28 94 44 2 105 246 1 151 224 138 233 135 254 20 25 124 118 13 182 172 20 197 252 20 174 143 186 57 51 58 222 119 36 51 0 104 163 78 183 107 2 0 0 0 0 128 74 103 198 93 113 70 83 77 90 199 193 206 145 183 35 249 192 236 161 64 7 17 137 53 0 187 116 255 249 232 191 215 71 6 51 192 57 52 156 221 118 241 145 238 148 141 72 31 162 90 235 117 210 45 34 240 215 118 239 161 128 10 59 244 108 240 132 108 62 94 40 142 165 219 48 78 211 95 143 5 181 44 128 205 117 175 172 46 236 144 98 44 44 86 152 86 44 46 101 89 209 229 168 49 93 54 154 211 126 167 37 43 164 36 251 17 187 90 218 47 68 10 0 0 0 0 0 0 1 128 74 103 198 93 113 70 83 77 90 199 193 206 145 183 35 249 192 236 161 64 7 17 137 53 0 187 116 255 249 232 191 215 71 6 51 192 57 52 156 221 118 241 145 238 148 141 72 31 162 90 235 117 210 45 34 240 215 118 239 161 128 10 59 244 108 240 132 108 62 94 40 142 165 219 48 78 211 95 143 5 181 44 128 205 117 175 172 46 236 144 98 44 44 86 152 86 44 46 101 89 209 229 168 49 93 54 154 211 126 167 37 43 164 36 251 17 187 90 218 47 68 10 0 0 0 0 0 0 0 48 5 35 182 112 113 188 253 125 124 37 72 205 161 238 42 235 141 207 222 101 115 216 55 107 133 114 20 89 39 233 135 120 225 238 214 101 146 108 76 33 35 58 202 67 65 1 0 0 1 48 5 35 182 112 113 188 253 125 124 37 72 205 161 238 42 235 141 207 222 101 115 216 55 107 133 114 20 89 39 233 135 120 225 238 214 101 146 108 76 33 35 58 202 67 65 1 0 0 0 128 104 135 234 221 147 43 69 249 95 82 22 184 215 149 229 138 106 92 255 169 236 121 106 240 235 221 243 154 22 155 148 218 188 88 136 234 72 234 250 14 92 227 117 188 12 118 41 224 174 244 46 222 46 196 200 235 191 13 185 217 77 182 148 203 3 127 173 173 34 254 84 187 72 234 176 92 208 9 125 82 232 207 39 192 114 153 168 166 210 148 43 5 225 117 107 205 99 179 177 46 90 12 119 11 225 27 124 151 136 98 153 156 122 129 197 79 159 225 89 237 180 211 34 198 224 232 1 0 1 128 104 135 234 221 147 43 69 249 95 82 22 184 215 149 229 138 106 92 255 169 236 121 106 240 235 221 243 154 22 155 148 218 188 88 136 234 72 234 250 14 92 227 117 188 12 118 41 224 174 244 46 222 46 196 200 235 191 13 185 217 77 182 148 203 3 127 173 173 34 254 84 187 72 234 176 92 208 9 125 82 232 207 39 192 114 153 168 166 210 148 43 5 225 117 107 205 99 179 177 46 90 12 119 11 225 27 124 151 136 98 153 156 122 129 197 79 159 225 89 237 180 211 34 198 224 232 1 0 0 128 30 16 152 189 248 187 194 106 86 218 107 172 24 210 165 36 4 181 124 54 238 59 132 56 110 109 236 68 95 102 145 133 240 159 128 36 169 4 207 140 229 186 242 94 18 174 89 159 26 138 112 65 245 118 85 137 113 110 126 144 76 37 227 235 138 77 233 26 84 155 51 80 31 201 113 46 222 200 95 96 232 140 13 80 38 36 30 104 180 121 216 89 15 185 161 136 55 32 42 160 149 50 168 225 1 104 50 30 10 3 96 136 60 23 224 146 203 81 219 70 1 0 0 0 0 0 0 0 1 128 30 16 152 189 248 187 194 106 86 218 107 172 24 210 165 36 4 181 124 54 238 59 132 56 110 109 236 68 95 102 145 133 240 159 128 36 169 4 207 140 229 186 242 94 18 174 89 159 26 138 112 65 245 118 85 137 113 110 126 144 76 37 227 235 138 77 233 26 84 155 51 80 31 201 113 46 222 200 95 96 232 140 13 80 38 36 30 104 180 121 216 89 15 185 161 136 55 32 42 160 149 50 168 225 1 104 50 30 10 3 96 136 60 23 224 146 203 81 219 70 1 0 0 0 0 0 0 0 0 32 31 3 148 175 154 99 152 211 246 153 40 92 93 24 93 5 168 109 224 21 185 107 37 219 63 153 164 130 241 93 111 0 1 32 31 3 148 175 154 99 152 211 246 153 40 92 93 24 93 5 168 109 224 21 185 107 37 219 63 153 164 130 241 93 111 0 0 112 73 246 239 200 138 198 5 244 5 61 186 215 203 39 176 220 88 141 123 23 70 239 91 228 24 9 208 86 173 30 190 190 160 205 169 222 186 254 3 42 110 229 120 37 181 245 217 107 172 221 147 223 37 33 9 82 153 101 228 62 236 28 113 251 178 124 157 88 255 13 110 233 60 45 129 160 39 244 17 113 220 114 236 12 12 23 203 127 173 99 182 203 235 40 81 17 163 180 158 157 229 232 88 42 248 234 216 11 207 20 25 51 1 112 73 246 239 200 138 198 5 244 5 61 186 215 203 39 176 220 88 141 123 23 70 239 91 228 24 9 208 86 173 30 190 190 160 205 169 222 186 254 3 42 110 229 120 37 181 245 217 107 172 221 147 223 37 33 9 82 153 101 228 62 236 28 113 251 178 124 157 88 255 13 110 233 60 45 129 160 39 244 17 113 220 114 236 12 12 23 203 127 173 99 182 203 235 40 81 17 163 180 158 157 229 232 88 42 248 234 216 11 207 20 25 51 0 8 39 132 6 0 0 0 0 0 1 8 39 132 6 0 0 0 0 0 0 72 220 180 23 131 143 83 213 131 208 206 205 120 25 87 192 44 119 67 69 124 227 114 112 253 61 85 176 134 4 56 189 104 188 137 70 0 24 85 129 75 88 245 68 129 51 145 7 213 104 238 115 223 7 147 12 4 53 239 245 119 158 197 135 154 106 50 38 170 151 176 21 0 1 72 220 180 23 131 143 83 213 131 208 206 205 120 25 87 192 44 119 67 69 124 227 114 112 253 61 85 176 134 4 56 189 104 188 137 70 0 24 85 129 75 88 245 68 129 51 145 7 213 104 238 115 223 7 147 12 4 53 239 245 119 158 197 135 154 106 50 38 170 151 176 21 0 0 56 53 186 59 167 241 59 136 87 128 215 201 225 137 253 171 55 175 94 153 156 167 180 232 139 32 51 246 11 119 98 59 201 174 243 8 69 82 213 30 147 100 60 26 207 249 44 53 34 200 114 0 0 0 0 0 0 1 56 53 186 59 167 241 59 136 87 128 215 201 225 137 253 171 55 175 94 153 156 167 180 232 139 32 51 246 11 119 98 59 201 174 243 8 69 82 213 30 147 100 60 26 207 249 44 53 34 200 114 0 0 0 0 0 0 0 80 174 62 24 34 239 200 187 235 239 204 93 34 151 115 205 129 228 152 167 94 171 72 91 21 73 128 43 106 226 191 23 128 76 125 32 132 209 72 252 64 195 197 154 199 15 13 192 133 198 108 88 181 61 227 187 44 34 215 108 151 40 54 253 218 203 218 197 100 1 207 108 14 183 168 181 1 75 68 203 52 1 80 174 62 24 34 239 200 187 235 239 204 93 34 151 115 205 129 228 152 167 94 171 72 91 21 73 128 43 106 226 191 23 128 76 125 32 132 209 72 252 64 195 197 154 199 15 13 192 133 198 108 88 181 61 227 187 44 34 215 108 151 40 54 253 218 203 218 197 100 1 207 108 14 183 168 181 1 75 68 203 52 0 104 178 153 248 14 228 148 99 29 41 180 54 4 212 37 168 181 45 110 40 79 241 192 17 133 242 242 158 27 85 230 33 102 187 163 67 188 94 83 9 227 224 31 154 239 89 44 152 114 79 160 147 226 52 244 38 46 88 71 34 217 114 156 13 83 85 223 134 253 133 126 56 188 90 85 65 29 106 94 50 165 88 56 132 55 180 80 212 40 199 4 162 37 213 90 184 228 101 203 7 49 0 0 0 0 1 104 178 153 248 14 228 148 99 29 41 180 54 4 212 37 168 181 45 110 40 79 241 192 17 133 242 242 158 27 85 230 33 102 187 163 67 188 94 83 9 227 224 31 154 239 89 44 152 114 79 160 147 226 52 244 38 46 88 71 34 217 114 156 13 83 85 223 134 253 133 126 56 188 90 85 65 29 106 94 50 165 88 56 132 55 180 80 212 40 199 4 162 37 213 90 184 228 101 203 7 49 0 0 0 0 0 80 38 182 96 145 194 1 121 109 64 49 154 66 199 208 229 235 239 165 41 198 204 230 234 178 15 29 203 140 160 143 49 211 78 57 102 214 114 58 133 221 75 184 224 8 199 190 6 247 208 197 161 3 41 23 120 225 80 183 58 134 227 154 146 238 63 175 177 103 131 253 150 250 82 57 2 3 0 0 0 0 1 80 38 182 96 145 194 1 121 109 64 49 154 66 199 208 229 235 239 165 41 198 204 230 234 178 15 29 203 140 160 143 49 211 78 57 102 214 114 58 133 221 75 184 224 8 199 190 6 247 208 197 161 3 41 23 120 225 80 183 58 134 227 154 146 238 63 175 177 103 131 253 150 250 82 57 2 3 0 0 0 0 0 64 248 119 27 143 213 236 116 221 199 155 29 196 80 96 187 63 97 42 122 209 144 117 56 28 149 170 177 209 56 44 150 204 131 187 222 85 190 214 23 67 242 17 199 67 116 180 19 62 92 46 154 222 244 151 104 165 83 192 191 210 45 2 0 0 1 64 248 119 27 143 213 236 116 221 199 155 29 196 80 96 187 63 97 42 122 209 144 117 56 28 149 170 177 209 56 44 150 204 131 187 222 85 190 214 23 67 242 17 199 67 116 180 19 62 92 46 154 222 244 151 104 165 83 192 191 210 45 2 0 0 0 32 75 182 65 120 225 60 231 204 95 201 188 204 81 75 120 231 176 122 123 44 181 212 75 241 199 197 22 0 0 0 0 0 1 32 75 182 65 120 225 60 231 204 95 201 188 204 81 75 120 231 176 122 123 44 181 212 75 241 199 197 22 0 0 0 0 0 0 72 223 250 238 211 74 58 16 147 125 7 190 218 142 15 49 69 24 56 233 70 213 49 22 223 242 236 38 167 130 195 39 254 92 251 3 205 152 4 121 107 79 85 199 20 69 53 93 242 156 125 37 228 96 255 30 188 96 67 150 203 206 75 217 143 153 171 129 99 51 5 0 0 1 72 223 250 238 211 74 58 16 147 125 7 190 218 142 15 49 69 24 56 233 70 213 49 22 223 242 236 38 167 130 195 39 254 92 251 3 205 152 4 121 107 79 85 199 20 69 53 93 242 156 125 37 228 96 255 30 188 96 67 150 203 206 75 217 143 153 171 129 99 51 5 0 0 0 40 108 135 124 124 29 149 22 174 63 189 26 9 249 247 17 17 89 247 0 255 90 36 201 133 122 164 9 110 235 211 222 139 25 132 124 219 40 148 57 0 1 40 108 135 124 124 29 149 22 174 63 189 26 9 249 247 17 17 89 247 0 255 90 36 201 133 122 164 9 110 235 211 222 139 25 132 124 219 40 148 57 0 0 8 221 214 2 0 0 0 0 0 1 8 221 214 2 0 0 0 0 0 0 64 147 243 38 63 33 71 153 12 98 251 245 150 131 176 144 216 39 46 89 50 223 16 34 113 69 13 67 16 135 235 91 48 79 129 250 166 204 227 58 148 218 46 57 182 34 191 165 85 34 220 7 11 186 11 50 182 83 77 72 179 7 0 0 0 1 64 147 243 38 63 33 71 153 12 98 251 245 150 131 176 144 216 39 46 89 50 223 16 34 113 69 13 67 16 135 235 91 48 79 129 250 166 204 227 58 148 218 46 57 182 34 191 165 85 34 220 7 11 186 11 50 182 83 77 72 179 7 0 0 0 0 120 233 246 77 131 243 68 158 180 136 87 207 157 192 121 128 83 72 237 157 134 56 179 201 1 58 190 146 20 153 238 215 88 195 223 67 97 118 17 130 145 223 169 2 15 100 207 216 142 60 64 52 15 48 69 172 151 212 137 218 247 204 232 97 61 38 179 246 161 46 207 132 202 4 168 89 164 121 208 120 93 104 32 129 66 68 235 47 162 233 166 150 103 24 240 136 140 27 137 9 61 79 35 201 200 190 255 32 23 133 194 43 148 11 47 84 2 0 0 0 0 1 120 233 246 77 131 243 68 158 180 136 87 207 157 192 121 128 83 72 237 157 134 56 179 201 1 58 190 146 20 153 238 215 88 195 223 67 97 118 17 130 145 223 169 2 15 100 207 216 142 60 64 52 15 48 69 172 151 212 137 218 247 204 232 97 61 38 179 246 161 46 207 132 202 4 168 89 164 121 208 120 93 104 32 129 66 68 235 47 162 233 166 150 103 24 240 136 140 27 137 9 61 79 35 201 200 190 255 32 23 133 194 43 148 11 47 84 2 0 0 0 0 0 32 158 132 247 73 243 86 76 181 117 114 74 0 73 167 54 232 186 178 119 62 251 36 87 106 243 46 78 254 30 13 0 0 1 32 158 132 247 73 243 86 76 181 117 114 74 0 73 167 54 232 186 178 119 62 251 36 87 106 243 46 78 254 30 13 0 0 0 32 187 109 237 12 177 145 13 138 110 36 103 212 219 254 32 2 199 207 206 58 33 91 157 82 142 0 0 0 0 0 0 0 1 32 187 109 237 12 177 145 13 138 110 36 103 212 219 254 32 2 199 207 206 58 33 91 157 82 142 0 0 0 0 0 0 0 0 112 191 156 137 40 227 120 81 180 191 249 128 101 54 189 222 126 135 44 172 229 198 254 122 200 254 68 241 155 189 52 134 12 32 127 165 213 33 74 112 219 180 120 124 62 203 145 126 182 239 201 194 229 70 199 78 71 165 89 3 82 85 207 202 83 229 239 95 208 222 39 184 4 206 170 105 230 130 175 81 36 41 97 157 125 234 216 239 63 206 58 107 124 78 26 131 144 70 157 163 62 27 234 177 215 202 140 179 217 0 0 0 0 1 112 191 156 137 40 227 120 81 180 191 249 128 101 54 189 222 126 135 44 172 229 198 254 122 200 254 68 241 155 189 52 134 12 32 127 165 213 33 74 112 219 180 120 124 62 203 145 126 182 239 201 194 229 70 199 78 71 165 89 3 82 85 207 202 83 229 239 95 208 222 39 184 4 206 170 105 230 130 175 81 36 41 97 157 125 234 216 239 63 206 58 107 124 78 26 131 144 70 157 163 62 27 234 177 215 202 140 179 217 0 0 0 0 0 120 255 98 44 67 145 156 67 69 207 144 154 245 114 32 23 127 211 123 148 182 146 150 170 172 74 232 254 188 127 136 34 39 122 230 35 121 2 76 118 160 187 17 37 250 134 176 133 100 139 227 15 230 54 106 167 246 167 233 207 141 247 103 135 96 18 251 188 166 202 113 88 34 38 81 212 236 236 142 153 242 1 12 51 124 236 57 28 83 109 124 63 127 190 114 111 5 105 32 46 141 46 195 82 228 121 27 143 106 94 116 99 98 35 8 0 0 0 0 0 0 1 120 255 98 44 67 145 156 67 69 207 144 154 245 114 32 23 127 211 123 148 182 146 150 170 172 74 232 254 188 127 136 34 39 122 230 35 121 2 76 118 160 187 17 37 250 134 176 133 100 139 227 15 230 54 106 167 246 167 233 207 141 247 103 135 96 18 251 188 166 202 113 88 34 38 81 212 236 236 142 153 242 1 12 51 124 236 57 28 83 109 124 63 127 190 114 111 5 105 32 46 141 46 195 82 228 121 27 143 106 94 116 99 98 35 8 0 0 0 0 0 0 0 32 232 106 75 132 234 67 145 119 175 2 68 218 133 30 27 34 7 172 120 42 19 45 118 178 216 1 0 0 0 0 0 0 1 32 232 106 75 132 234 67 145 119 175 2 68 218 133 30 27 34 7 172 120 42 19 45 118 178 216 1 0 0 0 0 0 0 0 64 129 215 181 185 15 177 200 177 68 80 119 183 36 206 190 141 54 145 230 111 190 97 150 77 141 67 185 87 206 214 237 78 15 79 202 150 147 74 113 9 154 9 23 173 146 190 131 137 247 142 224 174 235 35 57 206 3 0 0 0 0 0 0 0 1 64 129 215 181 185 15 177 200 177 68 80 119 183 36 206 190 141 54 145 230 111 190 97 150 77 141 67 185 87 206 214 237 78 15 79 202 150 147 74 113 9 154 9 23 173 146 190 131 137 247 142 224 174 235 35 57 206 3 0 0 0 0 0 0 0 0 32 115 158 93 203 145 117 229 203 77 183 195 60 46 1 188 230 187 238 14 154 176 183 66 57 250 253 70 58 37 0 0 0 1 32 115 158 93 203 145 117 229 203 77 183 195 60 46 1 188 230 187 238 14 154 176 183 66 57 250 253 70 58 37 0 0 0 0 24 81 129 71 67 43 121 89 51 236 18 78 211 96 141 172 26 113 13 214 3 0 0 0 0 1 24 81 129 71 67 43 121 89 51 236 18 78 211 96 141 172 26 113 13 214 3 0 0 0 0 0 24 184 13 246 1 153 149 55 198 59 23 173 215 119 87 65 163 114 196 32 40 213 121 0 0 1 24 184 13 246 1 153 149 55 198 59 23 173 215 119 87 65 163 114 196 32 40 213 121 0 0 0 32 56 51 141 41 47 230 78 216 176 139 28 23 160 170 28 45 110 124 64 37 171 195 108 121 74 182 76 40 76 153 115 0 1 32 56 51 141 41 47 230 78 216 176 139 28 23 160 170 28 45 110 124 64 37 171 195 108 121 74 182 76 40 76 153 115 0 0 32 206 242 236 149 72 96 46 45 248 108 12 136 166 194 52 138 152 63 46 130 98 126 192 209 228 24 24 197 243 7 0 0 1 32 206 242 236 149 72 96 46 45 248 108 12 136 166 194 52 138 152 63 46 130 98 126 192 209 228 24 24 197 243 7 0 0 0 104 163 224 244 5 84 160 193 30 20 248 69 99 186 48 205 24 55 21 110 164 203 99 211 59 80 177 211 86 41 161 229 184 106 19 96 95 57 76 140 135 150 249 39 235 242 249 52 35 6 105 190 17 117 228 226 214 214 171 123 84 78 178 176 91 241 160 229 1 232 67 196 8 201 235 118 130 80 124 105 29 101 75 30 179 181 153 56 118 147 86 245 65 10 214 206 110 133 122 248 252 15 53 12 0 1 104 163 224 244 5 84 160 193 30 20 248 69 99 186 48 205 24 55 21 110 164 203 99 211 59 80 177 211 86 41 161 229 184 106 19 96 95 57 76 140 135 150 249 39 235 242 249 52 35 6 105 190 17 117 228 226 214 214 171 123 84 78 178 176 91 241 160 229 1 232 67 196 8 201 235 118 130 80 124 105 29 101 75 30 179 181 153 56 118 147 86 245 65 10 214 206 110 133 122 248 252 15 53 12 0 0 56 255 163 247 43 209 230 164 208 61 194 65 9 8 102 145 97 240 236 201 123 138 71 245 15 204 218 185 57 76 20 213 174 59 153 22 62 121 255 64 38 76 67 69 50 49 114 127 89 242 171 78 13 84 189 144 206 1 56 255 163 247 43 209 230 164 208 61 194 65 9 8 102 145 97 240 236 201 123 138 71 245 15 204 218 185 57 76 20 213 174 59 153 22 62 121 255 64 38 76 67 69 50 49 114 127 89 242 171 78 13 84 189 144 206 0 64 119 123 244 71 66 212 59 231 215 217 150 174 254 235 5 68 31 31 6 176 61 197 15 162 18 140 92 194 120 2 15 65 53 175 46 99 56 24 73 7 37 185 106 245 175 110 29 253 204 28 202 76 47 79 71 204 251 4 48 167 1 0 0 0 1 64 119 123 244 71 66 212 59 231 215 217 150 174 254 235 5 68 31 31 6 176 61 197 15 162 18 140 92 194 120 2 15 65 53 175 46 99 56 24 73 7 37 185 106 245 175 110 29 253 204 28 202 76 47 79 71 204 251 4 48 167 1 0 0 0 0 40 75 92 25 115 221 208 198 30 142 204 73 223 50 228 83 175 70 246 95 204 121 169 116 174 231 117 55 245 122 146 164 239 74 119 247 71 4 100 3 243 1 40 75 92 25 115 221 208 198 30 142 204 73 223 50 228 83 175 70 246 95 204 121 169 116 174 231 117 55 245 122 146 164 239 74 119 247 71 4 100 3 243 0 16 34 19 120 45 63 194 247 76 181 223 195 16 0 0 0 0 1 16 34 19 120 45 63 194 247 76 181 223 195 16 0 0 0 0 0 120 11 156 157 89 152 7 19 248 49 41 66 116 237 10 201 152 231 23 143 156 186 202 203 178 43 1 204 30 223 30 82 205 180 255 123 84 194 132 200 55 172 127 23 130 112 165 163 165 42 122 249 39 165 158 69 42 153 176 150 166 240 46 132 80 211 8 120 35 97 238 127 32 91 232 38 236 223 213 67 53 103 162 194 187 151 60 152 119 172 25 69 23 189 153 199 219 236 157 195 152 26 202 31 27 199 10 79 34 126 168 67 114 24 246 235 163 169 176 2 0 1 120 11 156 157 89 152 7 19 248 49 41 66 116 237 10 201 152 231 23 143 156 186 202 203 178 43 1 204 30 223 30 82 205 180 255 123 84 194 132 200 55 172 127 23 130 112 165 163 165 42 122 249 39 165 158 69 42 153 176 150 166 240 46 132 80 211 8 120 35 97 238 127 32 91 232 38 236 223 213 67 53 103 162 194 187 151 60 152 119 172 25 69 23 189 153 199 219 236 157 195 152 26 202 31 27 199 10 79 34 126 168 67 114 24 246 235 163 169 176 2 0 0 88 85 223 220 13 86 122 92 125 254 224 25 165 190 213 4 132 224 45 245 246 242 4 21 101 215 192 193 89 76 244 92 59 156 26 236 182 254 202 196 35 75 32 109 229 252 167 15 126 64 249 191 76 96 115 179 17 42 165 113 135 249 231 21 159 208 162 179 200 212 213 61 123 49 118 34 59 181 1 182 39 112 251 16 0 0 0 0 0 1 88 85 223 220 13 86 122 92 125 254 224 25 165 190 213 4 132 224 45 245 246 242 4 21 101 215 192 193 89 76 244 92 59 156 26 236 182 254 202 196 35 75 32 109 229 252 167 15 126 64 249 191 76 96 115 179 17 42 165 113 135 249 231 21 159 208 162 179 200 212 213 61 123 49 118 34 59 181 1 182 39 112 251 16 0 0 0 0 0 0 56 241 153 124 222 255 91 80 137 188 25 206 200 154 27 122 16 125 75 240 248 246 78 65 142 23 205 193 163 87 157 134 225 91 123 69 215 210 244 123 101 159 224 170 194 255 111 207 183 177 8 44 102 228 238 181 2 1 56 241 153 124 222 255 91 80 137 188 25 206 200 154 27 122 16 125 75 240 248 246 78 65 142 23 205 193 163 87 157 134 225 91 123 69 215 210 244 123 101 159 224 170 194 255 111 207 183 177 8 44 102 228 238 181 2 0 88 108 208 238 121 156 133 32 223 68 75 136 121 125 29 189 121 101 228 164 37 65 109 220 250 136 48 233 198 101 96 135 47 117 233 2 196 191 211 238 100 182 234 243 0 91 97 184 199 182 220 252 38 146 252 212 245 32 52 172 255 55 60 67 104 138 139 119 31 23 22 151 0 79 220 46 31 165 72 73 119 91 0 0 0 0 0 0 0 1 88 108 208 238 121 156 133 32 223 68 75 136 121 125 29 189 121 101 228 164 37 65 109 220 250 136 48 233 198 101 96 135 47 117 233 2 196 191 211 238 100 182 234 243 0 91 97 184 199 182 220 252 38 146 252 212 245 32 52 172 255 55 60 67 104 138 139 119 31 23 22 151 0 79 220 46 31 165 72 73 119 91 0 0 0 0 0 0 0 0 24 213 179 45 133 224 12 22 86 217 206 37 101 183 225 74 147 210 205 0 173 128 31 240 53 1 24 213 179 45 133 224 12 22 86 217 206 37 101 183 225 74 147 210 205 0 173 128 31 240 53 0 80 90 55 247 101 97 91 255 60 228 172 4 69 150 197 105 130 9 216 50 222 145 121 93 91 122 8 47 193 246 47 193 9 162 74 30 3 151 221 91 204 206 19 231 186 13 155 24 132 70 140 134 148 236 198 3 189 248 97 75 45 121 50 215 87 150 150 229 138 138 91 126 104 37 101 138 0 0 0 0 0 1 80 90 55 247 101 97 91 255 60 228 172 4 69 150 197 105 130 9 216 50 222 145 121 93 91 122 8 47 193 246 47 193 9 162 74 30 3 151 221 91 204 206 19 231 186 13 155 24 132 70 140 134 148 236 198 3 189 248 97 75 45 121 50 215 87 150 150 229 138 138 91 126 104 37 101 138 0 0 0 0 0 0 120 115 168 21 247 112 94 184 201 248 149 252 240 29 141 154 150 50 97 41 31 56 85 247 163 55 145 23 152 45 131 53 22 104 104 156 123 120 164 40 242 48 192 145 28 44 4 132 15 113 134 148 171 248 224 123 182 163 113 254 55 6 161 136 98 198 188 165 53 144 141 184 125 14 170 160 0 214 41 35 209 54 31 123 30 107 49 216 97 58 154 19 33 192 193 123 112 203 64 156 187 211 15 178 212 189 77 250 84 218 228 148 93 53 115 124 112 0 0 0 0 1 120 115 168 21 247 112 94 184 201 248 149 252 240 29 141 154 150 50 97 41 31 56 85 247 163 55 145 23 152 45 131 53 22 104 104 156 123 120 164 40 242 48 192 145 28 44 4 132 15 113 134 148 171 248 224 123 182 163 113 254 55 6 161 136 98 198 188 165 53 144 141 184 125 14 170 160 0 214 41 35 209 54 31 123 30 107 49 216 97 58 154 19 33 192 193 123 112 203 64 156 187 211 15 178 212 189 77 250 84 218 228 148 93 53 115 124 112 0 0 0 0 0 96 124 82 249 217 103 152 210 105 101 179 152 26 43 32 241 184 13 170 187 237 6 89 158 142 202 72 9 130 229 186 22 231 141 253 32 147 157 150 169 239 239 208 239 192 162 97 2 190 76 255 147 85 133 38 206 102 92 234 167 23 138 70 25 133 14 226 134 237 118 29 40 218 196 187 239 239 178 225 158 55 21 189 63 14 233 211 32 249 204 188 227 125 20 0 0 0 1 96 124 82 249 217 103 152 210 105 101 179 152 26 43 32 241 184 13 170 187 237 6 89 158 142 202 72 9 130 229 186 22 231 141 253 32 147 157 150 169 239 239 208 239 192 162 97 2 190 76 255 147 85 133 38 206 102 92 234 167 23 138 70 25 133 14 226 134 237 118 29 40 218 196 187 239 239 178 225 158 55 21 189 63 14 233 211 32 249 204 188 227 125 20 0 0 0 0 128 177 60 161 102 138 146 247 69 176 188 18 92 242 96 135 152 103 107 37 160 86 206 146 191 253 129 245 98 150 12 55 16 198 207 141 173 254 8 189 100 126 62 201 64 132 146 143 251 54 46 248 170 236 238 107 85 4 232 188 238 154 172 221 156 205 139 30 154 186 201 53 77 80 85 0 164 126 169 125 95 209 214 94 114 253 109 143 69 147 26 150 229 49 67 202 41 185 188 58 222 135 170 143 147 169 56 199 253 208 108 79 241 186 223 39 47 118 166 2 119 183 150 198 249 52 6 0 0 1 128 177 60 161 102 138 146 247 69 176 188 18 92 242 96 135 152 103 107 37 160 86 206 146 191 253 129 245 98 150 12 55 16 198 207 141 173 254 8 189 100 126 62 201 64 132 146 143 251 54 46 248 170 236 238 107 85 4 232 188 238 154 172 221 156 205 139 30 154 186 201 53 77 80 85 0 164 126 169 125 95 209 214 94 114 253 109 143 69 147 26 150 229 49 67 202 41 185 188 58 222 135 170 143 147 169 56 199 253 208 108 79 241 186 223 39 47 118 166 2 119 183 150 198 249 52 6 0 0 0 48 121 50 208 121 198 113 59 191 8 122 194 42 131 235 44 67 197 194 251 149 183 60 30 84 243 193 92 233 207 81 221 84 214 60 215 107 83 0 178 5 171 252 181 246 155 13 0 0 1 48 121 50 208 121 198 113 59 191 8 122 194 42 131 235 44 67 197 194 251 149 183 60 30 84 243 193 92 233 207 81 221 84 214 60 215 107 83 0 178 5 171 252 181 246 155 13 0 0 0 56 166 53 117 196 161 229 248 189 4 118 22 159 55 250 249 52 240 65 18 192 100 153 107 30 88 36 106 130 0 220 222 225 150 0 193 132 255 124 153 51 146 110 36 253 172 218 35 80 8 122 3 16 206 124 33 42 1 56 166 53 117 196 161 229 248 189 4 118 22 159 55 250 249 52 240 65 18 192 100 153 107 30 88 36 106 130 0 220 222 225 150 0 193 132 255 124 153 51 146 110 36 253 172 218 35 80 8 122 3 16 206 124 33 42 0 88 106 68 182 59 178 196 127 243 157 52 191 25 43 145 111 238 141 79 101 131 239 1 63 142 28 0 132 32 245 126 60 32 214 17 147 90 227 5 98 15 248 217 212 142 124 197 131 140 236 233 147 37 78 121 156 176 23 194 249 199 210 9 238 29 123 193 74 93 96 82 46 195 174 189 189 138 161 169 130 51 227 225 203 252 54 230 59 1 1 88 106 68 182 59 178 196 127 243 157 52 191 25 43 145 111 238 141 79 101 131 239 1 63 142 28 0 132 32 245 126 60 32 214 17 147 90 227 5 98 15 248 217 212 142 124 197 131 140 236 233 147 37 78 121 156 176 23 194 249 199 210 9 238 29 123 193 74 93 96 82 46 195 174 189 189 138 161 169 130 51 227 225 203 252 54 230 59 1 0 16 91 51 80 52 153 106 15 96 178 33 98 180 208 107 15 0 1 16 91 51 80 52 153 106 15 96 178 33 98 180 208 107 15 0 0 96 146 234 254 250 136 181 23 108 220 189 235 39 183 250 50 211 23 108 166 159 135 169 94 214 225 32 1 13 78 240 181 132 87 93 98 20 18 115 26 247 31 145 41 94 224 210 84 160 74 211 209 64 225 64 180 241 208 245 103 182 102 43 178 61 140 91 159 243 48 233 2 13 121 164 43 215 31 105 2 197 114 135 82 116 240 53 2 223 62 194 1 0 0 0 0 0 1 96 146 234 254 250 136 181 23 108 220 189 235 39 183 250 50 211 23 108 166 159 135 169 94 214 225 32 1 13 78 240 181 132 87 93 98 20 18 115 26 247 31 145 41 94 224 210 84 160 74 211 209 64 225 64 180 241 208 245 103 182 102 43 178 61 140 91 159 243 48 233 2 13 121 164 43 215 31 105 2 197 114 135 82 116 240 53 2 223 62 194 1 0 0 0 0 0 0 40 185 152 217 29 34 198 116 253 71 146 190 251 229 82 88 248 120 47 21 213 170 170 112 236 72 88 154 181 235 239 69 222 48 2 0 0 0 0 0 0 1 40 185 152 217 29 34 198 116 253 71 146 190 251 229 82 88 248 120 47 21 213 170 170 112 236 72 88 154 181 235 239 69 222 48 2 0 0 0 0 0 0 0 24 29 136 104 174 70 11 214 125 207 165 237 74 237 199 33 28 122 6 213 243 25 0 0 0 1 24 29 136 104 174 70 11 214 125 207 165 237 74 237 199 33 28 122 6 213 243 25 0 0 0 0 56 208 160 113 38 148 89 13 191 95 94 203 140 7 30 57 94 69 180 223 237 240 172 171 247 162 165 245 245 5 100 24 96 24 245 62 100 128 18 89 116 205 89 200 251 14 195 113 223 134 107 202 24 7 0 0 0 1 56 208 160 113 38 148 89 13 191 95 94 203 140 7 30 57 94 69 180 223 237 240 172 171 247 162 165 245 245 5 100 24 96 24 245 62 100 128 18 89 116 205 89 200 251 14 195 113 223 134 107 202 24 7 0 0 0 0 24 164 26 119 125 80 143 88 12 173 143 157 18 207 147 18 133 102 5 0 0 0 0 0 0 1 24 164 26 119 125 80 143 88 12 173 143 157 18 207 147 18 133 102 5 0 0 0 0 0 0 0 80 240 91 93 80 200 2 55 132 40 130 206 143 31 138 22 6 196 227 42 127 4 69 60 97 99 42 199 161 115 16 243 173 96 104 227 89 184 61 55 91 197 16 30 116 69 157 9 62 186 27 47 108 196 231 54 53 86 238 78 204 233 137 113 247 34 18 212 144 7 152 39 169 110 99 156 198 1 0 0 0 1 80 240 91 93 80 200 2 55 132 40 130 206 143 31 138 22 6 196 227 42 127 4 69 60 97 99 42 199 161 115 16 243 173 96 104 227 89 184 61 55 91 197 16 30 116 69 157 9 62 186 27 47 108 196 231 54 53 86 238 78 204 233 137 113 247 34 18 212 144 7 152 39 169 110 99 156 198 1 0 0 0 0 64 164 36 243 234 38 238 24 36 226 207 250 29 63 195 44 89 189 228 110 154 71 14 125 43 159 59 53 176 232 184 148 203 158 152 210 156 44 195 201 57 165 81 190 91 35 122 171 243 195 109 195 142 67 89 184 14 18 25 0 0 0 0 0 0 1 64 164 36 243 234 38 238 24 36 226 207 250 29 63 195 44 89 189 228 110 154 71 14 125 43 159 59 53 176 232 184 148 203 158 152 210 156 44 195 201 57 165 81 190 91 35 122 171 243 195 109 195 142 67 89 184 14 18 25 0 0 0 0 0 0 0 40 168 114 107 133 10 23 139 104 205 120 166 131 193 1 223 63 29 201 98 120 19 62 117 38 159 115 66 105 171 210 74 142 248 0 0 0 0 0 0 0 1 40 168 114 107 133 10 23 139 104 205 120 166 131 193 1 223 63 29 201 98 120 19 62 117 38 159 115 66 105 171 210 74 142 248 0 0 0 0 0 0 0 0 8 188 118 208 125 103 29 0 0 1 8 188 118 208 125 103 29 0 0 0 80 93 36 106 167 48 129 182 121 19 12 119 143 58 46 98 169 218 191 211 74 102 51 142 112 70 65 240 134 104 65 202 183 210 160 25 144 232 17 193 129 249 86 192 216 157 46 31 9 89 42 0 255 32 223 228 36 241 177 228 240 221 30 38 173 183 42 128 15 55 48 187 131 109 78 5 178 203 7 0 0 1 80 93 36 106 167 48 129 182 121 19 12 119 143 58 46 98 169 218 191 211 74 102 51 142 112 70 65 240 134 104 65 202 183 210 160 25 144 232 17 193 129 249 86 192 216 157 46 31 9 89 42 0 255 32 223 228 36 241 177 228 240 221 30 38 173 183 42 128 15 55 48 187 131 109 78 5 178 203 7 0 0 0 104 209 253 145 149 140 101 72 59 80 61 95 87 223 103 111 142 120 156 200 160 119 178 162 183 243 3 59 250 14 151 250 48 55 97 183 44 47 166 154 9 238 68 13 148 84 67 106 86 157 132 235 187 35 17 121 154 165 226 136 96 27 177 250 145 13 38 0 109 173 58 16 189 45 0 156 64 166 8 87 150 211 191 66 117 148 187 227 116 144 40 22 160 105 172 245 89 17 98 157 251 122 154 0 0 1 104 209 253 145 149 140 101 72 59 80 61 95 87 223 103 111 142 120 156 200 160 119 178 162 183 243 3 59 250 14 151 250 48 55 97 183 44 47 166 154 9 238 68 13 148 84 67 106 86 157 132 235 187 35 17 121 154 165 226 136 96 27 177 250 145 13 38 0 109 173 58 16 189 45 0 156 64 166 8 87 150 211 191 66 117 148 187 227 116 144 40 22 160 105 172 245 89 17 98 157 251 122 154 0 0 0 96 48 216 197 206 211 163 26 178 30 38 25 126 254 218 154 197 147 60 114 177 112 98 153 149 94 247 85 223 187 252 210 64 20 63 98 66 201 175 4 146 53 51 161 164 120 186 172 160 189 77 68 186 110 221 45 4 254 96 67 66 66 64 145 122 236 241 192 130 240 110 229 191 58 172 70 147 64 128 67 77 37 143 90 168 105 183 130 40 128 162 204 0 0 0 0 0 1 96 48 216 197 206 211 163 26 178 30 38 25 126 254 218 154 197 147 60 114 177 112 98 153 149 94 247 85 223 187 252 210 64 20 63 98 66 201 175 4 146 53 51 161 164 120 186 172 160 189 77 68 186 110 221 45 4 254 96 67 66 66 64 145 122 236 241 192 130 240 110 229 191 58 172 70 147 64 128 67 77 37 143 90 168 105 183 130 40 128 162 204 0 0 0 0 0 0 24 176 183 71 106 140 200 146 60 201 141 49 175 206 219 24 51 141 203 213 202 124 18 0 0 1 24 176 183 71 106 140 200 146 60 201 141 49 175 206 219 24 51 141 203 213 202 124 18 0 0 0 32 97 221 208 156 227 180 222 58 51 5 156 2 70 25 102 197 16 16 222 115 157 90 121 207 16 211 217 208 2 0 0 0 1 32 97 221 208 156 227 180 222 58 51 5 156 2 70 25 102 197 16 16 222 115 157 90 121 207 16 211 217 208 2 0 0 0 0 112 178 156 236 219 98 243 32 106 184 211 76 115 58 138 184 11 243 158 111 214 180 249 75 209 228 102 1 198 201 169 202 134 82 247 29 60 251 130 101 5 79 254 236 4 3 154 24 213 80 110 237 105 114 57 175 148 37 189 215 96 26 164 159 215 189 91 213 117 182 250 78 196 91 184 197 122 91 11 110 49 145 65 35 242 27 150 116 151 97 138 84 129 122 101 163 101 143 206 236 240 17 99 91 63 34 187 4 0 0 0 0 0 1 112 178 156 236 219 98 243 32 106 184 211 76 115 58 138 184 11 243 158 111 214 180 249 75 209 228 102 1 198 201 169 202 134 82 247 29 60 251 130 101 5 79 254 236 4 3 154 24 213 80 110 237 105 114 57 175 148 37 189 215 96 26 164 159 215 189 91 213 117 182 250 78 196 91 184 197 122 91 11 110 49 145 65 35 242 27 150 116 151 97 138 84 129 122 101 163 101 143 206 236 240 17 99 91 63 34 187 4 0 0 0 0 0 0 16 191 50 248 33 176 205 97 154 211 182 118 170 186 32 76 1 1 16 191 50 248 33 176 205 97 154 211 182 118 170 186 32 76 1 0 48 234 193 100 178 9 208 13 92 237 227 179 241 244 131 30 214 22 128 221 109 129 32 221 92 143 17 196 16 142 53 151 122 200 63 163 198 197 112 127 42 47 2 0 0 0 0 0 0 1 48 234 193 100 178 9 208 13 92 237 227 179 241 244 131 30 214 22 128 221 109 129 32 221 92 143 17 196 16 142 53 151 122 200 63 163 198 197 112 127 42 47 2 0 0 0 0 0 0 0 40 165 3 177 221 137 96 40 2 95 239 12 147 159 69 92 8 226 226 89 13 220 87 111 111 4 46 185 191 135 108 64 28 98 137 121 69 157 147 3 0 1 40 165 3 177 221 137 96 40 2 95 239 12 147 159 69 92 8 226 226 89 13 220 87 111 111 4 46 185 191 135 108 64 28 98 137 121 69 157 147 3 0 0 88 117 70 136 141 37 22 10 38 199 136 67 121 78 100 165 189 58 199 68 147 53 35 88 254 145 48 3 64 111 49 252 79 215 24 85 125 88 7 197 53 75 129 196 177 222 97 246 145 156 189 140 144 166 41 155 175 68 115 133 179 126 64 86 56 38 73 200 37 103 6 154 47 83 59 156 31 165 8 192 161 64 77 224 85 1 0 0 0 1 88 117 70 136 141 37 22 10 38 199 136 67 121 78 100 165 189 58 199 68 147 53 35 88 254 145 48 3 64 111 49 252 79 215 24 85 125 88 7 197 53 75 129 196 177 222 97 246 145 156 189 140 144 166 41 155 175 68 115 133 179 126 64 86 56 38 73 200 37 103 6 154 47 83 59 156 31 165 8 192 161 64 77 224 85 1 0 0 0 0 48 217 185 213 61 101 246 30 87 9 40 115 28 155 141 207 255 17 194 181 7 208 69 15 189 18 161 29 215 47 247 4 172 133 64 239 27 206 90 55 197 113 0 0 0 0 0 0 0 1 48 217 185 213 61 101 246 30 87 9 40 115 28 155 141 207 255 17 194 181 7 208 69 15 189 18 161 29 215 47 247 4 172 133 64 239 27 206 90 55 197 113 0 0 0 0 0 0 0 0 56 148 182 61 42 123 22 99 146 228 21 87 117 190 75 48 0 97 189 188 28 85 193 232 154 144 129 19 107 255 92 192 179 73 21 211 208 243 243 72 10 53 231 255 190 241 19 69 17 2 153 53 8 39 246 0 0 1 56 148 182 61 42 123 22 99 146 228 21 87 117 190 75 48 0 97 189 188 28 85 193 232 154 144 129 19 107 255 92 192 179 73 21 211 208 243 243 72 10 53 231 255 190 241 19 69 17 2 153 53 8 39 246 0 0 0 56 211 66 149 196 5 244 108 154 21 75 148 133 24 12 252 29 159 127 240 191 48 35 202 86 177 34 52 193 54 229 170 58 106 119 182 50 240 221 151 21 237 110 249 225 73 237 49 54 255 10 114 182 126 107 8 0 1 56 211 66 149 196 5 244 108 154 21 75 148 133 24 12 252 29 159 127 240 191 48 35 202 86 177 34 52 193 54 229 170 58 106 119 182 50 240 221 151 21 237 110 249 225 73 237 49 54 255 10 114 182 126 107 8 0 0 104 225 214 120 250 248 166 189 72 25 10 51 38 36 179 73 86 127 210 96 225 42 108 183 54 154 102 128 235 61 79 169 19 33 27 197 27 140 126 108 68 180 57 222 96 50 135 137 200 40 109 22 3 187 139 78 175 226 173 222 38 56 155 201 55 29 54 110 130 125 243 53 89 135 235 66 91 26 131 150 14 181 180 220 56 68 157 222 65 169 237 15 194 167 35 49 59 236 93 240 247 1 0 0 0 1 104 225 214 120 250 248 166 189 72 25 10 51 38 36 179 73 86 127 210 96 225 42 108 183 54 154 102 128 235 61 79 169 19 33 27 197 27 140 126 108 68 180 57 222 96 50 135 137 200 40 109 22 3 187 139 78 175 226 173 222 38 56 155 201 55 29 54 110 130 125 243 53 89 135 235 66 91 26 131 150 14 181 180 220 56 68 157 222 65 169 237 15 194 167 35 49 59 236 93 240 247 1 0 0 0 0 72 250 13 100 76 198 39 97 190 132 34 30 132 205 55 142 174 37 28 5 136 138 69 4 127 203 225 200 100 221 206 243 94 81 111 236 255 188 143 231 143 35 187 81 173 188 250 232 196 70 175 70 188 195 241 113 46 158 102 170 214 243 177 164 189 186 2 0 0 0 0 0 0 1 72 250 13 100 76 198 39 97 190 132 34 30 132 205 55 142 174 37 28 5 136 138 69 4 127 203 225 200 100 221 206 243 94 81 111 236 255 188 143 231 143 35 187 81 173 188 250 232 196 70 175 70 188 195 241 113 46 158 102 170 214 243 177 164 189 186 2 0 0 0 0 0 0 0 16 252 62 17 105 107 27 138 254 209 166 253 232 14 173 53 0 1 16 252 62 17 105 107 27 138 254 209 166 253 232 14 173 53 0 0 16 248 20 114 16 45 167 199 205 247 93 60 1 0 0 0 0 1 16 248 20 114 16 45 167 199 205 247 93 60 1 0 0 0 0 0 128 68 85 139 65 128 103 40 178 143 96 39 160 16 180 192 162 49 134 53 77 80 87 249 241 72 43 118 116 184 230 72 29 217 203 233 243 99 73 223 120 79 37 252 19 42 245 193 177 160 241 111 129 21 196 151 106 142 158 95 161 24 140 154 174 72 129 49 87 117 19 229 253 93 146 82 164 63 11 89 51 145 182 224 167 87 85 133 130 24 56 22 86 126 37 63 50 11 25 59 22 7 198 60 94 176 166 72 203 118 45 191 236 253 8 4 237 208 247 95 191 61 131 45 100 233 41 140 1 1 128 68 85 139 65 128 103 40 178 143 96 39 160 16 180 192 162 49 134 53 77 80 87 249 241 72 43 118 116 184 230 72 29 217 203 233 243 99 73 223 120 79 37 252 19 42 245 193 177 160 241 111 129 21 196 151 106 142 158 95 161 24 140 154 174 72 129 49 87 117 19 229 253 93 146 82 164 63 11 89 51 145 182 224 167 87 85 133 130 24 56 22 86 126 37 63 50 11 25 59 22 7 198 60 94 176 166 72 203 118 45 191 236 253 8 4 237 208 247 95 191 61 131 45 100 233 41 140 1 0 40 171 175 7 24 85 197 52 53 222 109 116 70 7 33 47 129 85 73 230 121 23 188 153 132 54 221 247 177 60 250 118 199 113 48 0 0 0 0 0 0 1 40 171 175 7 24 85 197 52 53 222 109 116 70 7 33 47 129 85 73 230 121 23 188 153 132 54 221 247 177 60 250 118 199 113 48 0 0 0 0 0 0 0 24 93 217 212 50 244 177 120 129 193 148 208 62 51 48 197 29 12 127 5 133 232 174 163 14 1 24 93 217 212 50 244 177 120 129 193 148 208 62 51 48 197 29 12 127 5 133 232 174 163 14 0 104 61 140 155 145 23 121 180 150 193 253 181 78 221 177 28 155 147 231 109 135 40 213 10 176 7 92 102 36 228 91 74 59 128 90 66 174 228 143 117 219 65 92 198 227 147 31 210 199 101 130 185 96 20 234 102 37 117 134 38 231 28 208 231 74 69 32 133 140 236 129 186 142 89 0 72 223 168 63 132 85 4 58 183 202 56 212 86 111 8 7 182 11 108 42 143 34 30 250 94 6 24 226 5 0 1 104 61 140 155 145 23 121 180 150 193 253 181 78 221 177 28 155 147 231 109 135 40 213 10 176 7 92 102 36 228 91 74 59 128 90 66 174 228 143 117 219 65 92 198 227 147 31 210 199 101 130 185 96 20 234 102 37 117 134 38 231 28 208 231 74 69 32 133 140 236 129 186 142 89 0 72 223 168 63 132 85 4 58 183 202 56 212 86 111 8 7 182 11 108 42 143 34 30 250 94 6 24 226 5 0 0 104 69 203 211 226 232 194 190 174 38 42 219 202 126 170 213 67 251 214 240 5 57 56 204 220 229 22 83 177 58 244 203 158 220 19 118 48 28 104 202 235 222 18 48 27 53 30 213 133 250 43 151 110 53 51 81 104 66 224 80 32 48 197 127 8 196 143 211 86 42 231 40 1 196 225 20 87 198 99 207 33 242 133 186 174 87 131 82 161 85 98 41 79 235 6 54 208 79 63 0 0 0 0 0 0 1 104 69 203 211 226 232 194 190 174 38 42 219 202 126 170 213 67 251 214 240 5 57 56 204 220 229 22 83 177 58 244 203 158 220 19 118 48 28 104 202 235 222 18 48 27 53 30 213 133 250 43 151 110 53 51 81 104 66 224 80 32 48 197 127 8 196 143 211 86 42 231 40 1 196 225 20 87 198 99 207 33 242 133 186 174 87 131 82 161 85 98 41 79 235 6 54 208 79 63 0 0 0 0 0 0 0 8 106 133 253 254 0 0 0 0 1 8 106 133 253 254 0 0 0 0 0 40 52 160 46 168 248 117 14 87 213 169 244 54 52 54 90 204 139 227 70 129 237 255 102 107 43 17 92 104 188 166 27 224 59 206 1 0 0 0 0 0 1 40 52 160 46 168 248 117 14 87 213 169 244 54 52 54 90 204 139 227 70 129 237 255 102 107 43 17 92 104 188 166 27 224 59 206 1 0 0 0 0 0 0 120 181 140 78 163 1 144 166 35 223 120 26 62 194 182 189 188 203 150 222 242 105 153 199 190 59 209 251 150 143 51 233 52 50 171 137 94 76 60 155 162 163 194 72 102 39 206 211 44 149 8 71 7 3 14 238 150 49 199 209 147 173 71 223 95 145 84 45 137 227 252 43 100 85 213 9 217 99 70 100 168 88 110 229 244 46 8 112 7 141 228 169 214 105 143 254 11 226 135 101 6 67 255 70 224 194 81 96 193 178 170 189 80 169 153 245 174 120 167 5 0 1 120 181 140 78 163 1 144 166 35 223 120 26 62 194 182 189 188 203 150 222 242 105 153 199 190 59 209 251 150 143 51 233 52 50 171 137 94 76 60 155 162 163 194 72 102 39 206 211 44 149 8 71 7 3 14 238 150 49 199 209 147 173 71 223 95 145 84 45 137 227 252 43 100 85 213 9 217 99 70 100 168 88 110 229 244 46 8 112 7 141 228 169 214 105 143 254 11 226 135 101 6 67 255 70 224 194 81 96 193 178 170 189 80 169 153 245 174 120 167 5 0 0 32 19 169 230 106 158 164 68 252 228 52 75 229 81 25 134 88 61 171 29 148 225 103 206 90 122 156 116 158 229 80 62 7 1 32 19 169 230 106 158 164 68 252 228 52 75 229 81 25 134 88 61 171 29 148 225 103 206 90 122 156 116 158 229 80 62 7 0 96 44 24 45 150 1 57 124 51 120 88 192 53 82 3 14 197 181 78 62 96 149 139 236 70 23 91 206 58 4 12 63 75 51 192 197 2 242 185 178 73 152 109 161 60 142 161 171 63 201 195 243 198 2 124 119 14 189 184 21 26 90 196 117 3 207 78 196 78 191 210 218 232 185 4 72 102 10 124 94 142 17 14 238 243 191 213 250 160 226 11 56 213 156 15 0 0 1 96 44 24 45 150 1 57 124 51 120 88 192 53 82 3 14 197 181 78 62 96 149 139 236 70 23 91 206 58 4 12 63 75 51 192 197 2 242 185 178 73 152 109 161 60 142 161 171 63 201 195 243 198 2 124 119 14 189 184 21 26 90 196 117 3 207 78 196 78 191 210 218 232 185 4 72 102 10 124 94 142 17 14 238 243 191 213 250 160 226 11 56 213 156 15 0 0 0 16 5 128 98 100 111 201 242 99 239 114 208 3 48 1 0 0 1 16 5 128 98 100 111 201 242 99 239 114 208 3 48 1 0 0 0 64 55 164 28 11 235 113 86 122 52 237 225 241 179 197 83 95 114 107 69 13 182 58 173 152 229 230 108 171 135 2 108 102 81 246 165 202 47 238 229 240 109 119 151 6 36 92 18 67 160 204 138 149 79 36 130 164 116 48 77 57 61 42 21 0 1 64 55 164 28 11 235 113 86 122 52 237 225 241 179 197 83 95 114 107 69 13 182 58 173 152 229 230 108 171 135 2 108 102 81 246 165 202 47 238 229 240 109 119 151 6 36 92 18 67 160 204 138 149 79 36 130 164 116 48 77 57 61 42 21 0 0 48 94 61 43 8 236 81 175 216 38 46 240 164 24 125 150 38 110 153 168 221 238 46 195 146 161 141 191 230 139 251 175 57 243 39 106 55 170 158 83 212 72 98 28 253 2 0 0 0 1 48 94 61 43 8 236 81 175 216 38 46 240 164 24 125 150 38 110 153 168 221 238 46 195 146 161 141 191 230 139 251 175 57 243 39 106 55 170 158 83 212 72 98 28 253 2 0 0 0 0 80 48 94 140 165 180 105 31 16 145 182 147 88 246 146 184 137 158 100 218 254 225 130 175 24 164 19 172 15 135 152 163 48 137 131 182 181 101 168 51 195 131 251 4 29 231 230 96 29 58 177 144 95 60 187 109 242 143 92 252 239 108 72 4 59 210 46 232 34 139 28 238 105 211 76 0 0 0 0 0 0 1 80 48 94 140 165 180 105 31 16 145 182 147 88 246 146 184 137 158 100 218 254 225 130 175 24 164 19 172 15 135 152 163 48 137 131 182 181 101 168 51 195 131 251 4 29 231 230 96 29 58 177 144 95 60 187 109 242 143 92 252 239 108 72 4 59 210 46 232 34 139 28 238 105 211 76 0 0 0 0 0 0 0 40 234 82 61 126 225 47 95 67 86 217 19 160 166 207 107 2 63 101 138 71 14 205 171 155 149 191 239 138 12 202 149 100 120 202 78 69 3 0 0 0 1 40 234 82 61 126 225 47 95 67 86 217 19 160 166 207 107 2 63 101 138 71 14 205 171 155 149 191 239 138 12 202 149 100 120 202 78 69 3 0 0 0 0 32 254 34 44 189 14 4 206 100 120 172 67 182 70 62 43 236 232 71 120 86 45 165 252 19 123 77 145 98 252 22 8 0 1 32 254 34 44 189 14 4 206 100 120 172 67 182 70 62 43 236 232 71 120 86 45 165 252 19 123 77 145 98 252 22 8 0 0 128 133 133 183 97 16 40 176 80 73 78 7 25 246 204 110 33 191 19 111 253 42 125 217 152 191 133 9 231 196 126 215 115 228 86 114 230 179 150 254 155 22 188 36 125 187 206 19 227 235 11 176 130 143 111 209 43 29 89 113 147 102 119 48 191 43 79 47 89 120 0 227 25 169 53 18 37 83 52 60 241 101 240 255 139 61 119 189 13 92 89 30 29 252 1 22 209 105 170 119 94 158 16 175 58 110 238 74 117 112 41 56 246 67 154 141 63 25 112 206 160 3 84 134 50 0 0 0 0 1 128 133 133 183 97 16 40 176 80 73 78 7 25 246 204 110 33 191 19 111 253 42 125 217 152 191 133 9 231 196 126 215 115 228 86 114 230 179 150 254 155 22 188 36 125 187 206 19 227 235 11 176 130 143 111 209 43 29 89 113 147 102 119 48 191 43 79 47 89 120 0 227 25 169 53 18 37 83 52 60 241 101 240 255 139 61 119 189 13 92 89 30 29 252 1 22 209 105 170 119 94 158 16 175 58 110 238 74 117 112 41 56 246 67 154 141 63 25 112 206 160 3 84 134 50 0 0 0 0 0 64 242 208 163 166 217 157 45 88 172 11 229 109 23 46 229 250 139 217 234 229 172 253 211 253 11 8 225 163 20 87 100 148 249 249 188 166 122 64 131 225 233 55 241 36 232 11 174 172 83 153 87 165 3 39 84 162 67 204 110 0 0 0 0 0 1 64 242 208 163 166 217 157 45 88 172 11 229 109 23 46 229 250 139 217 234 229 172 253 211 253 11 8 225 163 20 87 100 148 249 249 188 166 122 64 131 225 233 55 241 36 232 11 174 172 83 153 87 165 3 39 84 162 67 204 110 0 0 0 0 0 0 32 62 99 60 181 249 169 105 74 220 130 197 142 213 226 245 78 96 45 105 171 176 157 17 155 32 93 59 15 0 0 0 0 1 32 62 99 60 181 249 169 105 74 220 130 197 142 213 226 245 78 96 45 105 171 176 157 17 155 32 93 59 15 0 0 0 0


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int128_serial32.txt
================================================
22 serialization::archive 10 0 0 0 0 0 16 37 8 254 63 21 239 57 20 229 108 249 176 89 1 0 0 1 16 37 8 254 63 21 239 57 20 229 108 249 176 89 1 0 0 0 4 44 53 2 0 1 4 44 53 2 0 0 16 255 227 23 91 116 215 6 77 105 216 187 1 221 183 7 0 1 16 255 227 23 91 116 215 6 77 105 216 187 1 221 183 7 0 0 16 215 97 73 133 223 240 209 70 227 76 76 44 42 9 0 0 1 16 215 97 73 133 223 240 209 70 227 76 76 44 42 9 0 0 0 4 26 205 1 0 1 4 26 205 1 0 0 16 171 248 220 122 202 115 96 223 240 82 153 66 149 194 43 14 1 16 171 248 220 122 202 115 96 223 240 82 153 66 149 194 43 14 0 16 73 169 70 111 188 124 78 80 182 195 40 65 247 218 58 0 1 16 73 169 70 111 188 124 78 80 182 195 40 65 247 218 58 0 0 4 55 1 42 59 1 4 55 1 42 59 0 12 112 146 42 85 255 28 14 50 168 228 0 0 1 12 112 146 42 85 255 28 14 50 168 228 0 0 0 8 3 132 142 0 89 0 0 0 1 8 3 132 142 0 89 0 0 0 0 4 59 31 0 0 1 4 59 31 0 0 0 12 128 184 17 143 213 41 148 184 91 0 0 0 1 12 128 184 17 143 213 41 148 184 91 0 0 0 0 8 52 43 163 205 58 0 0 0 1 8 52 43 163 205 58 0 0 0 0 4 7 136 199 3 1 4 7 136 199 3 0 12 103 144 142 223 219 161 68 75 104 0 0 0 1 12 103 144 142 223 219 161 68 75 104 0 0 0 0 16 231 211 175 248 223 4 118 100 4 104 73 218 45 121 30 164 1 16 231 211 175 248 223 4 118 100 4 104 73 218 45 121 30 164 0 16 64 136 51 28 35 115 186 14 0 15 31 170 194 137 96 1 1 16 64 136 51 28 35 115 186 14 0 15 31 170 194 137 96 1 0 16 6 253 75 10 176 96 217 180 15 153 73 162 221 96 13 175 1 16 6 253 75 10 176 96 217 180 15 153 73 162 221 96 13 175 0 16 9 195 227 5 98 90 197 22 123 173 13 24 184 217 65 14 1 16 9 195 227 5 98 90 197 22 123 173 13 24 184 217 65 14 0 16 36 207 83 207 252 162 46 155 216 62 210 211 118 157 254 13 1 16 36 207 83 207 252 162 46 155 216 62 210 211 118 157 254 13 0 4 48 115 9 0 1 4 48 115 9 0 0 12 18 132 205 178 240 43 208 33 177 56 170 10 1 12 18 132 205 178 240 43 208 33 177 56 170 10 0 16 0 134 168 204 110 75 199 196 245 20 142 108 179 194 4 27 1 16 0 134 168 204 110 75 199 196 245 20 142 108 179 194 4 27 0 16 137 40 185 28 226 228 143 223 62 177 68 144 87 133 253 16 1 16 137 40 185 28 226 228 143 223 62 177 68 144 87 133 253 16 0 16 241 205 249 80 146 210 1 55 43 173 109 143 84 117 209 0 1 16 241 205 249 80 146 210 1 55 43 173 109 143 84 117 209 0 0 4 171 208 0 0 1 4 171 208 0 0 0 8 131 223 243 126 121 98 88 88 1 8 131 223 243 126 121 98 88 88 0 16 34 183 141 118 51 30 229 127 23 141 157 166 11 0 0 0 1 16 34 183 141 118 51 30 229 127 23 141 157 166 11 0 0 0 0 16 58 245 156 2 19 251 183 255 219 45 27 253 9 0 0 0 1 16 58 245 156 2 19 251 183 255 219 45 27 253 9 0 0 0 0 8 153 44 205 37 255 0 0 0 1 8 153 44 205 37 255 0 0 0 0 4 246 238 8 0 1 4 246 238 8 0 0 4 7 0 0 0 1 4 7 0 0 0 0 8 8 53 135 13 104 37 51 0 1 8 8 53 135 13 104 37 51 0 0 4 89 148 1 0 1 4 89 148 1 0 0 16 220 42 79 160 82 149 191 194 119 33 248 143 15 159 45 0 1 16 220 42 79 160 82 149 191 194 119 33 248 143 15 159 45 0 0 12 85 100 42 49 80 139 191 189 106 176 0 0 1 12 85 100 42 49 80 139 191 189 106 176 0 0 0 16 244 148 210 156 57 140 123 241 227 171 90 25 5 0 0 0 1 16 244 148 210 156 57 140 123 241 227 171 90 25 5 0 0 0 0 16 11 118 127 38 199 175 117 18 23 63 204 177 158 199 1 0 1 16 11 118 127 38 199 175 117 18 23 63 204 177 158 199 1 0 0 16 133 146 81 4 4 226 254 92 139 68 104 13 103 27 212 5 1 16 133 146 81 4 4 226 254 92 139 68 104 13 103 27 212 5 0 12 32 198 99 47 231 25 151 81 1 0 0 0 1 12 32 198 99 47 231 25 151 81 1 0 0 0 0 12 137 233 68 65 94 40 65 221 33 159 2 0 1 12 137 233 68 65 94 40 65 221 33 159 2 0 0 16 83 34 240 62 72 73 173 41 206 111 192 80 37 0 0 0 1 16 83 34 240 62 72 73 173 41 206 111 192 80 37 0 0 0 0 4 97 0 0 0 1 4 97 0 0 0 0 8 138 189 92 247 169 147 0 0 1 8 138 189 92 247 169 147 0 0 0 16 161 190 61 94 114 107 106 245 122 129 25 170 59 22 0 0 1 16 161 190 61 94 114 107 106 245 122 129 25 170 59 22 0 0 0 4 2 130 235 26 1 4 2 130 235 26 0 16 109 53 53 179 152 230 103 254 224 148 134 9 132 15 236 0 1 16 109 53 53 179 152 230 103 254 224 148 134 9 132 15 236 0 0 12 213 70 114 188 144 14 234 210 9 163 24 0 1 12 213 70 114 188 144 14 234 210 9 163 24 0 0 12 33 107 225 17 111 28 212 164 73 197 193 0 1 12 33 107 225 17 111 28 212 164 73 197 193 0 0 8 146 173 184 73 148 56 4 0 1 8 146 173 184 73 148 56 4 0 0 12 44 163 145 53 213 144 139 110 48 114 127 219 1 12 44 163 145 53 213 144 139 110 48 114 127 219 0 12 173 188 229 221 105 34 146 117 254 239 166 51 1 12 173 188 229 221 105 34 146 117 254 239 166 51 0 12 4 69 232 58 38 108 238 203 253 199 77 145 1 12 4 69 232 58 38 108 238 203 253 199 77 145 0 8 107 215 91 159 76 215 198 33 1 8 107 215 91 159 76 215 198 33 0 8 11 77 137 244 167 98 1 0 1 8 11 77 137 244 167 98 1 0 0 8 186 129 52 47 127 178 152 0 1 8 186 129 52 47 127 178 152 0 0 12 201 180 214 22 110 46 55 229 64 200 26 0 1 12 201 180 214 22 110 46 55 229 64 200 26 0 0 4 208 223 215 0 1 4 208 223 215 0 0 4 64 29 111 0 1 4 64 29 111 0 0 8 189 214 205 206 195 1 0 0 1 8 189 214 205 206 195 1 0 0 0 12 186 181 125 189 118 38 122 114 34 230 100 1 1 12 186 181 125 189 118 38 122 114 34 230 100 1 0 16 48 214 190 50 128 72 169 213 65 189 101 126 93 0 0 0 1 16 48 214 190 50 128 72 169 213 65 189 101 126 93 0 0 0 0 4 30 0 0 0 1 4 30 0 0 0 0 8 13 245 224 15 53 1 0 0 1 8 13 245 224 15 53 1 0 0 0 8 202 238 193 147 15 0 0 0 1 8 202 238 193 147 15 0 0 0 0 16 128 116 52 14 187 110 131 0 144 16 182 41 228 82 0 0 1 16 128 116 52 14 187 110 131 0 144 16 182 41 228 82 0 0 0 4 100 0 0 0 1 4 100 0 0 0 0 4 89 180 24 0 1 4 89 180 24 0 0 4 34 124 0 0 1 4 34 124 0 0 0 16 250 39 95 39 67 1 167 94 233 155 216 3 100 183 116 118 1 16 250 39 95 39 67 1 167 94 233 155 216 3 100 183 116 118 0 16 128 143 58 104 102 58 4 109 40 213 225 112 135 3 0 0 1 16 128 143 58 104 102 58 4 109 40 213 225 112 135 3 0 0 0 16 182 167 174 164 204 91 160 188 128 28 213 237 236 1 0 0 1 16 182 167 174 164 204 91 160 188 128 28 213 237 236 1 0 0 0 12 198 204 232 165 163 187 202 201 158 244 103 2 1 12 198 204 232 165 163 187 202 201 158 244 103 2 0 4 52 41 2 0 1 4 52 41 2 0 0 8 95 141 198 19 2 2 0 0 1 8 95 141 198 19 2 2 0 0 0 16 254 2 20 231 85 24 126 151 177 138 78 145 2 0 0 0 1 16 254 2 20 231 85 24 126 151 177 138 78 145 2 0 0 0 0 16 127 34 155 130 248 106 222 183 31 216 113 190 213 220 134 3 1 16 127 34 155 130 248 106 222 183 31 216 113 190 213 220 134 3 0 8 185 223 116 102 248 10 180 190 1 8 185 223 116 102 248 10 180 190 0 4 28 0 0 0 1 4 28 0 0 0 0 12 152 5 232 129 30 191 73 187 48 122 16 0 1 12 152 5 232 129 30 191 73 187 48 122 16 0 0 8 22 174 151 82 172 15 209 0 1 8 22 174 151 82 172 15 209 0 0 4 167 181 0 0 1 4 167 181 0 0 0 8 34 164 28 2 70 207 0 0 1 8 34 164 28 2 70 207 0 0 0 4 73 175 2 31 1 4 73 175 2 31 0 16 191 123 4 56 221 89 117 10 45 163 68 188 6 0 0 0 1 16 191 123 4 56 221 89 117 10 45 163 68 188 6 0 0 0 0 4 32 0 0 0 1 4 32 0 0 0 0 16 153 114 240 104 169 142 230 72 169 205 183 45 29 0 0 0 1 16 153 114 240 104 169 142 230 72 169 205 183 45 29 0 0 0 0 4 104 0 0 0 1 4 104 0 0 0 0 4 250 4 201 0 1 4 250 4 201 0 0 8 235 69 188 51 63 136 32 0 1 8 235 69 188 51 63 136 32 0 0 8 194 197 163 82 68 56 132 186 1 8 194 197 163 82 68 56 132 186 0 8 209 149 168 103 172 0 245 13 1 8 209 149 168 103 172 0 245 13 0 8 95 103 181 13 108 192 162 0 1 8 95 103 181 13 108 192 162 0 0 8 203 201 28 164 225 153 81 140 1 8 203 201 28 164 225 153 81 140 0 12 61 213 68 146 15 4 91 15 163 73 1 0 1 12 61 213 68 146 15 4 91 15 163 73 1 0 0 16 94 145 165 53 103 5 192 143 85 206 43 169 47 0 0 0 1 16 94 145 165 53 103 5 192 143 85 206 43 169 47 0 0 0 0 12 50 151 92 208 203 159 144 76 92 251 123 11 1 12 50 151 92 208 203 159 144 76 92 251 123 11 0 16 190 5 157 205 191 246 224 1 231 37 151 216 251 10 66 0 1 16 190 5 157 205 191 246 224 1 231 37 151 216 251 10 66 0 0 12 77 149 133 65 141 196 79 8 138 249 60 120 1 12 77 149 133 65 141 196 79 8 138 249 60 120 0 16 220 86 90 254 157 201 65 199 11 135 199 91 106 0 0 0 1 16 220 86 90 254 157 201 65 199 11 135 199 91 106 0 0 0 0 8 204 151 79 174 7 0 0 0 1 8 204 151 79 174 7 0 0 0 0 12 24 141 202 136 150 117 206 49 76 1 63 7 1 12 24 141 202 136 150 117 206 49 76 1 63 7 0 12 119 133 5 211 186 190 56 29 220 201 21 0 1 12 119 133 5 211 186 190 56 29 220 201 21 0 0 4 7 0 0 0 1 4 7 0 0 0 0 12 72 15 156 17 9 105 177 79 67 146 0 0 1 12 72 15 156 17 9 105 177 79 67 146 0 0 0 12 249 168 160 82 66 6 134 143 40 37 107 13 1 12 249 168 160 82 66 6 134 143 40 37 107 13 0 4 4 185 65 0 1 4 4 185 65 0 0 12 12 112 73 235 143 130 15 35 185 148 4 0 1 12 12 112 73 235 143 130 15 35 185 148 4 0 0 4 245 60 0 0 1 4 245 60 0 0 0 8 42 49 128 144 182 3 210 10 1 8 42 49 128 144 182 3 210 10 0 12 213 148 0 33 85 171 97 185 1 0 0 0 1 12 213 148 0 33 85 171 97 185 1 0 0 0 0 16 54 54 252 21 199 151 88 16 3 233 15 10 1 0 0 0 1 16 54 54 252 21 199 151 88 16 3 233 15 10 1 0 0 0 0 16 34 61 250 8 165 194 32 79 231 214 230 190 194 240 114 7 1 16 34 61 250 8 165 194 32 79 231 214 230 190 194 240 114 7 0 12 104 245 221 84 173 227 229 31 19 5 0 0 1 12 104 245 221 84 173 227 229 31 19 5 0 0 0 8 240 84 253 169 3 21 0 0 1 8 240 84 253 169 3 21 0 0 0 16 178 134 22 38 169 249 193 201 236 162 74 212 159 200 1 0 1 16 178 134 22 38 169 249 193 201 236 162 74 212 159 200 1 0 0 12 188 15 207 107 111 126 74 110 184 12 0 0 1 12 188 15 207 107 111 126 74 110 184 12 0 0 0 16 135 53 52 188 239 136 188 128 108 91 237 149 155 0 0 0 1 16 135 53 52 188 239 136 188 128 108 91 237 149 155 0 0 0 0 4 214 243 150 104 1 4 214 243 150 104 0 4 28 0 0 0 1 4 28 0 0 0 0 16 176 32 111 181 139 147 85 223 223 124 248 32 1 0 0 0 1 16 176 32 111 181 139 147 85 223 223 124 248 32 1 0 0 0 0 16 220 111 201 142 140 206 56 69 169 37 41 8 209 2 0 0 1 16 220 111 201 142 140 206 56 69 169 37 41 8 209 2 0 0 0 8 49 22 111 81 3 0 0 0 1 8 49 22 111 81 3 0 0 0 0 16 12 25 137 51 170 194 60 198 250 154 97 254 184 1 0 0 1 16 12 25 137 51 170 194 60 198 250 154 97 254 184 1 0 0 0 12 69 58 72 167 111 230 201 95 3 0 0 0 1 12 69 58 72 167 111 230 201 95 3 0 0 0 0 16 125 163 188 25 216 18 75 50 70 157 149 113 247 26 143 0 1 16 125 163 188 25 216 18 75 50 70 157 149 113 247 26 143 0 0 12 178 36 11 168 110 204 18 55 17 174 31 2 1 12 178 36 11 168 110 204 18 55 17 174 31 2 0 8 54 253 119 216 234 173 18 0 1 8 54 253 119 216 234 173 18 0 0 16 58 138 90 25 198 44 141 36 21 50 150 6 116 188 7 0 1 16 58 138 90 25 198 44 141 36 21 50 150 6 116 188 7 0 0 8 48 232 209 253 50 174 219 0 1 8 48 232 209 253 50 174 219 0 0 16 98 231 108 128 132 248 24 45 51 233 172 99 10 48 164 6 1 16 98 231 108 128 132 248 24 45 51 233 172 99 10 48 164 6 0 12 63 148 202 142 42 126 95 240 217 3 0 0 1 12 63 148 202 142 42 126 95 240 217 3 0 0 0 12 211 178 116 92 43 40 217 152 60 0 0 0 1 12 211 178 116 92 43 40 217 152 60 0 0 0 0 4 173 137 40 0 1 4 173 137 40 0 0 4 205 61 6 0 1 4 205 61 6 0 0 16 88 56 246 47 152 18 79 21 156 80 31 84 2 0 0 0 1 16 88 56 246 47 152 18 79 21 156 80 31 84 2 0 0 0 0 4 47 61 12 0 1 4 47 61 12 0 0 4 160 13 53 81 1 4 160 13 53 81 0 8 32 187 228 46 5 0 0 0 1 8 32 187 228 46 5 0 0 0 0 16 182 2 196 123 7 142 61 89 72 17 68 180 113 1 0 0 1 16 182 2 196 123 7 142 61 89 72 17 68 180 113 1 0 0 0 16 120 38 117 243 129 114 66 195 74 148 250 9 85 2 0 0 1 16 120 38 117 243 129 114 66 195 74 148 250 9 85 2 0 0 0 16 233 65 214 75 155 124 3 9 180 156 12 179 244 180 184 111 1 16 233 65 214 75 155 124 3 9 180 156 12 179 244 180 184 111 0 8 23 43 78 31 7 0 0 0 1 8 23 43 78 31 7 0 0 0 0 8 229 205 68 230 125 8 0 0 1 8 229 205 68 230 125 8 0 0 0 16 141 13 91 38 76 112 200 170 250 212 26 1 124 1 0 0 1 16 141 13 91 38 76 112 200 170 250 212 26 1 124 1 0 0 0 8 41 127 133 106 252 0 0 0 1 8 41 127 133 106 252 0 0 0 0 8 60 152 174 163 1 0 0 0 1 8 60 152 174 163 1 0 0 0 0 4 15 0 0 0 1 4 15 0 0 0 0 16 24 134 100 43 20 248 31 252 145 239 220 39 16 158 117 0 1 16 24 134 100 43 20 248 31 252 145 239 220 39 16 158 117 0 0 4 175 72 124 35 1 4 175 72 124 35 0 8 244 49 63 40 249 6 0 0 1 8 244 49 63 40 249 6 0 0 0 16 200 70 212 56 217 96 254 3 156 68 43 183 192 143 8 0 1 16 200 70 212 56 217 96 254 3 156 68 43 183 192 143 8 0 0 4 219 122 30 5 1 4 219 122 30 5 0 16 152 26 100 200 15 32 129 3 69 217 98 106 201 17 0 0 1 16 152 26 100 200 15 32 129 3 69 217 98 106 201 17 0 0 0 4 220 43 90 166 1 4 220 43 90 166 0 16 1 74 237 23 159 49 174 181 39 193 105 137 206 197 208 2 1 16 1 74 237 23 159 49 174 181 39 193 105 137 206 197 208 2 0 12 2 162 116 55 83 71 3 224 58 31 0 0 1 12 2 162 116 55 83 71 3 224 58 31 0 0 0 16 219 109 251 155 10 110 246 132 227 114 221 29 13 0 0 0 1 16 219 109 251 155 10 110 246 132 227 114 221 29 13 0 0 0 0 8 142 91 8 37 228 217 181 55 1 8 142 91 8 37 228 217 181 55 0 16 189 154 57 63 85 92 144 161 46 212 177 53 47 4 29 90 1 16 189 154 57 63 85 92 144 161 46 212 177 53 47 4 29 90 0 8 14 190 95 210 115 71 0 0 1 8 14 190 95 210 115 71 0 0 0 4 47 2 0 0 1 4 47 2 0 0 0 16 174 101 211 131 68 66 216 221 166 22 253 95 142 0 0 0 1 16 174 101 211 131 68 66 216 221 166 22 253 95 142 0 0 0 0 16 198 1 17 204 40 96 166 196 65 117 215 34 58 0 0 0 1 16 198 1 17 204 40 96 166 196 65 117 215 34 58 0 0 0 0 12 155 139 7 253 130 3 210 83 54 12 0 0 1 12 155 139 7 253 130 3 210 83 54 12 0 0 0 12 164 44 176 210 229 112 131 132 31 15 0 0 1 12 164 44 176 210 229 112 131 132 31 15 0 0 0 12 197 192 242 64 16 33 210 29 215 0 0 0 1 12 197 192 242 64 16 33 210 29 215 0 0 0 0 12 247 202 39 209 87 88 199 30 93 71 125 42 1 12 247 202 39 209 87 88 199 30 93 71 125 42 0 16 4 91 228 117 233 235 177 229 123 87 8 196 42 243 50 0 1 16 4 91 228 117 233 235 177 229 123 87 8 196 42 243 50 0 0 12 177 254 109 38 43 208 254 238 71 49 150 0 1 12 177 254 109 38 43 208 254 238 71 49 150 0 0 8 66 45 234 248 31 0 0 0 1 8 66 45 234 248 31 0 0 0 0 12 105 210 161 233 29 116 129 70 143 74 88 0 1 12 105 210 161 233 29 116 129 70 143 74 88 0 0 16 43 147 216 50 132 234 9 232 69 151 33 92 3 0 0 0 1 16 43 147 216 50 132 234 9 232 69 151 33 92 3 0 0 0 0 8 205 117 182 80 150 98 9 0 1 8 205 117 182 80 150 98 9 0 0 16 58 110 227 57 169 95 102 122 66 27 229 232 1 0 0 0 1 16 58 110 227 57 169 95 102 122 66 27 229 232 1 0 0 0 0 12 230 26 192 136 251 74 228 31 223 1 0 0 1 12 230 26 192 136 251 74 228 31 223 1 0 0 0 8 27 77 126 125 205 208 0 0 1 8 27 77 126 125 205 208 0 0 0 4 105 207 185 22 1 4 105 207 185 22 0 12 177 81 106 231 133 43 4 174 118 0 0 0 1 12 177 81 106 231 133 43 4 174 118 0 0 0 0 12 151 193 51 229 154 159 106 17 13 0 0 0 1 12 151 193 51 229 154 159 106 17 13 0 0 0 0 4 9 5 0 0 1 4 9 5 0 0 0 8 154 3 91 22 110 99 13 0 1 8 154 3 91 22 110 99 13 0 0 4 46 0 0 0 1 4 46 0 0 0 0 8 165 178 204 139 226 102 0 0 1 8 165 178 204 139 226 102 0 0 0 12 255 166 141 198 137 1 215 240 13 0 0 0 1 12 255 166 141 198 137 1 215 240 13 0 0 0 0 12 240 214 172 107 207 30 49 24 165 26 0 0 1 12 240 214 172 107 207 30 49 24 165 26 0 0 0 16 169 62 163 160 84 45 148 118 196 244 39 206 4 0 0 0 1 16 169 62 163 160 84 45 148 118 196 244 39 206 4 0 0 0 0 8 51 45 245 18 221 94 0 0 1 8 51 45 245 18 221 94 0 0 0 16 56 138 53 228 133 56 250 127 145 126 56 71 96 42 205 0 1 16 56 138 53 228 133 56 250 127 145 126 56 71 96 42 205 0 0 16 96 10 238 153 254 99 179 181 215 150 183 141 204 183 59 15 1 16 96 10 238 153 254 99 179 181 215 150 183 141 204 183 59 15 0 4 234 122 2 0 1 4 234 122 2 0 0 4 171 166 2 0 1 4 171 166 2 0 0 12 70 249 164 0 38 67 121 141 34 1 0 0 1 12 70 249 164 0 38 67 121 141 34 1 0 0 0 8 114 2 113 130 156 93 2 0 1 8 114 2 113 130 156 93 2 0 0 8 128 254 47 66 253 230 215 9 1 8 128 254 47 66 253 230 215 9 0 8 128 118 25 126 97 184 0 0 1 8 128 118 25 126 97 184 0 0 0 4 6 0 0 0 1 4 6 0 0 0 0 12 98 121 37 228 245 254 160 122 192 239 13 51 1 12 98 121 37 228 245 254 160 122 192 239 13 51 0 8 32 22 37 123 21 27 0 0 1 8 32 22 37 123 21 27 0 0 0 8 128 162 228 118 64 127 3 0 1 8 128 162 228 118 64 127 3 0 0 4 166 181 11 0 1 4 166 181 11 0 0 16 28 166 115 28 45 10 239 211 13 246 240 137 229 3 80 0 1 16 28 166 115 28 45 10 239 211 13 246 240 137 229 3 80 0 0 16 234 15 55 214 194 155 139 231 81 180 44 125 14 0 0 0 1 16 234 15 55 214 194 155 139 231 81 180 44 125 14 0 0 0 0 8 177 167 106 207 184 208 150 0 1 8 177 167 106 207 184 208 150 0 0 8 13 195 217 57 88 2 0 0 1 8 13 195 217 57 88 2 0 0 0 16 54 96 61 217 136 240 218 168 74 235 61 179 94 124 0 0 1 16 54 96 61 217 136 240 218 168 74 235 61 179 94 124 0 0 0 8 133 19 3 202 163 74 201 191 1 8 133 19 3 202 163 74 201 191 0 12 76 246 211 13 154 46 92 228 43 105 0 0 1 12 76 246 211 13 154 46 92 228 43 105 0 0 0 4 238 231 7 0 1 4 238 231 7 0 0 4 121 5 0 0 1 4 121 5 0 0 0 12 254 32 157 147 246 229 100 39 232 13 0 0 1 12 254 32 157 147 246 229 100 39 232 13 0 0 0 8 148 204 30 203 96 118 103 26 1 8 148 204 30 203 96 118 103 26 0 8 86 94 188 134 7 0 0 0 1 8 86 94 188 134 7 0 0 0 0 8 190 236 210 228 178 0 0 0 1 8 190 236 210 228 178 0 0 0 0 12 159 29 240 26 162 129 48 140 42 98 6 0 1 12 159 29 240 26 162 129 48 140 42 98 6 0 0 12 201 94 127 117 141 245 104 70 17 0 0 0 1 12 201 94 127 117 141 245 104 70 17 0 0 0 0 12 186 185 167 145 50 174 180 1 50 29 53 1 1 12 186 185 167 145 50 174 180 1 50 29 53 1 0 12 104 112 112 189 66 154 31 214 228 234 171 7 1 12 104 112 112 189 66 154 31 214 228 234 171 7 0 12 165 159 159 174 251 240 214 4 220 88 34 125 1 12 165 159 159 174 251 240 214 4 220 88 34 125 0 16 231 72 142 22 2 169 79 36 221 251 129 37 230 30 25 38 1 16 231 72 142 22 2 169 79 36 221 251 129 37 230 30 25 38 0 8 95 25 73 135 187 21 41 2 1 8 95 25 73 135 187 21 41 2 0 12 203 77 25 62 42 39 26 203 12 34 248 30 1 12 203 77 25 62 42 39 26 203 12 34 248 30 0 4 19 6 0 0 1 4 19 6 0 0 0 16 68 151 207 206 205 132 15 184 12 208 217 190 252 148 29 0 1 16 68 151 207 206 205 132 15 184 12 208 217 190 252 148 29 0 0 4 172 170 222 106 1 4 172 170 222 106 0 12 255 209 208 122 18 160 62 50 2 0 0 0 1 12 255 209 208 122 18 160 62 50 2 0 0 0 0 16 71 17 98 35 48 147 54 205 13 239 235 222 162 130 39 0 1 16 71 17 98 35 48 147 54 205 13 239 235 222 162 130 39 0 0 12 123 91 181 63 20 138 251 142 208 1 0 0 1 12 123 91 181 63 20 138 251 142 208 1 0 0 0 4 223 195 7 0 1 4 223 195 7 0 0 12 46 37 83 84 120 104 86 18 1 0 0 0 1 12 46 37 83 84 120 104 86 18 1 0 0 0 0 16 11 123 221 123 22 39 126 107 97 71 79 173 196 6 0 0 1 16 11 123 221 123 22 39 126 107 97 71 79 173 196 6 0 0 0 8 53 164 236 57 255 127 20 4 1 8 53 164 236 57 255 127 20 4 0 12 35 197 22 114 86 55 189 134 3 0 0 0 1 12 35 197 22 114 86 55 189 134 3 0 0 0 0 12 77 141 58 157 14 215 57 68 1 0 0 0 1 12 77 141 58 157 14 215 57 68 1 0 0 0 0 16 102 255 109 147 11 143 27 213 47 176 30 89 64 94 213 66 1 16 102 255 109 147 11 143 27 213 47 176 30 89 64 94 213 66 0 8 190 247 33 10 138 0 6 6 1 8 190 247 33 10 138 0 6 6 0 4 110 2 0 0 1 4 110 2 0 0 0 16 223 83 113 107 137 221 86 37 48 2 144 161 169 28 0 0 1 16 223 83 113 107 137 221 86 37 48 2 144 161 169 28 0 0 0 8 189 254 123 237 246 176 128 2 1 8 189 254 123 237 246 176 128 2 0 12 243 132 245 46 238 29 255 200 206 118 0 0 1 12 243 132 245 46 238 29 255 200 206 118 0 0 0 4 239 125 0 0 1 4 239 125 0 0 0 12 127 161 236 25 121 208 120 214 1 0 0 0 1 12 127 161 236 25 121 208 120 214 1 0 0 0 0 16 228 98 93 251 246 45 27 244 12 210 234 8 62 105 184 6 1 16 228 98 93 251 246 45 27 244 12 210 234 8 62 105 184 6 0 16 113 250 216 245 216 14 84 151 148 66 63 170 143 150 213 62 1 16 113 250 216 245 216 14 84 151 148 66 63 170 143 150 213 62 0 4 7 0 0 0 1 4 7 0 0 0 0 4 97 0 0 0 1 4 97 0 0 0 0 16 82 196 148 115 94 248 196 4 103 173 17 224 1 0 0 0 1 16 82 196 148 115 94 248 196 4 103 173 17 224 1 0 0 0 0 16 185 187 181 2 210 30 161 158 53 90 42 42 63 15 50 26 1 16 185 187 181 2 210 30 161 158 53 90 42 42 63 15 50 26 0 16 92 251 45 61 79 154 189 99 62 231 106 244 104 0 0 0 1 16 92 251 45 61 79 154 189 99 62 231 106 244 104 0 0 0 0 8 200 11 39 38 1 71 0 0 1 8 200 11 39 38 1 71 0 0 0 16 78 168 146 148 101 102 80 36 225 226 239 154 140 83 0 0 1 16 78 168 146 148 101 102 80 36 225 226 239 154 140 83 0 0 0 12 245 138 45 63 143 110 236 183 77 53 123 0 1 12 245 138 45 63 143 110 236 183 77 53 123 0 0 4 243 27 0 0 1 4 243 27 0 0 0 8 2 242 30 180 34 49 0 0 1 8 2 242 30 180 34 49 0 0 0 8 153 218 239 31 13 11 23 0 1 8 153 218 239 31 13 11 23 0 0 16 114 73 75 167 80 26 136 206 243 161 150 47 210 18 0 0 1 16 114 73 75 167 80 26 136 206 243 161 150 47 210 18 0 0 0 8 152 52 243 192 4 0 0 0 1 8 152 52 243 192 4 0 0 0 0 4 129 0 0 0 1 4 129 0 0 0 0 16 18 75 75 202 113 21 113 107 89 238 2 38 55 0 0 0 1 16 18 75 75 202 113 21 113 107 89 238 2 38 55 0 0 0 0 12 248 15 6 162 79 31 165 111 116 213 2 0 1 12 248 15 6 162 79 31 165 111 116 213 2 0 0 8 131 38 69 53 220 0 194 1 1 8 131 38 69 53 220 0 194 1 0 16 74 116 239 154 166 169 107 46 39 173 51 0 1 0 0 0 1 16 74 116 239 154 166 169 107 46 39 173 51 0 1 0 0 0 0 16 216 204 156 85 182 172 130 76 251 193 13 135 156 80 17 0 1 16 216 204 156 85 182 172 130 76 251 193 13 135 156 80 17 0 0 4 230 159 4 0 1 4 230 159 4 0 0 4 240 94 116 1 1 4 240 94 116 1 0 16 186 26 109 17 247 224 109 236 131 235 91 201 8 59 206 53 1 16 186 26 109 17 247 224 109 236 131 235 91 201 8 59 206 53 0 8 213 56 129 36 10 0 0 0 1 8 213 56 129 36 10 0 0 0 0 4 150 105 0 0 1 4 150 105 0 0 0 4 24 96 0 0 1 4 24 96 0 0 0 8 125 198 15 213 57 0 0 0 1 8 125 198 15 213 57 0 0 0 0 4 72 171 5 0 1 4 72 171 5 0 0 16 125 217 106 251 35 137 192 207 157 60 119 110 60 0 0 0 1 16 125 217 106 251 35 137 192 207 157 60 119 110 60 0 0 0 0 16 40 33 166 229 75 32 114 134 8 182 91 119 101 246 0 0 1 16 40 33 166 229 75 32 114 134 8 182 91 119 101 246 0 0 0 4 50 6 0 0 1 4 50 6 0 0 0 12 46 7 188 46 21 139 235 139 174 6 0 0 1 12 46 7 188 46 21 139 235 139 174 6 0 0 0 12 122 184 52 227 177 59 175 38 160 93 2 0 1 12 122 184 52 227 177 59 175 38 160 93 2 0 0 12 51 236 9 239 42 71 1 118 244 0 0 0 1 12 51 236 9 239 42 71 1 118 244 0 0 0 0 4 9 0 0 0 1 4 9 0 0 0 0 4 112 253 24 0 1 4 112 253 24 0 0 12 170 155 98 70 194 229 34 226 165 82 10 0 1 12 170 155 98 70 194 229 34 226 165 82 10 0 0 16 141 162 219 102 243 250 189 2 52 69 45 8 37 48 0 0 1 16 141 162 219 102 243 250 189 2 52 69 45 8 37 48 0 0 0 12 114 76 220 134 106 96 50 45 46 0 0 0 1 12 114 76 220 134 106 96 50 45 46 0 0 0 0 12 83 216 166 163 69 55 198 40 4 192 0 0 1 12 83 216 166 163 69 55 198 40 4 192 0 0 0 8 33 162 20 8 117 90 28 1 1 8 33 162 20 8 117 90 28 1 0 8 196 49 182 125 208 15 0 0 1 8 196 49 182 125 208 15 0 0 0 4 133 3 165 3 1 4 133 3 165 3 0 12 35 198 36 50 11 227 67 35 5 0 0 0 1 12 35 198 36 50 11 227 67 35 5 0 0 0 0 4 217 58 6 0 1 4 217 58 6 0 0 8 27 199 198 6 169 98 3 0 1 8 27 199 198 6 169 98 3 0 0 8 208 172 62 88 120 203 5 0 1 8 208 172 62 88 120 203 5 0 0 4 90 8 0 0 1 4 90 8 0 0 0 16 72 150 61 92 250 232 245 163 67 167 172 175 2 0 0 0 1 16 72 150 61 92 250 232 245 163 67 167 172 175 2 0 0 0 0 4 109 255 102 254 1 4 109 255 102 254 0 4 36 0 0 0 1 4 36 0 0 0 0 4 235 105 3 0 1 4 235 105 3 0 0 8 157 43 115 210 3 0 0 0 1 8 157 43 115 210 3 0 0 0 0 4 227 128 137 1 1 4 227 128 137 1 0 12 21 49 26 107 236 12 129 206 3 0 0 0 1 12 21 49 26 107 236 12 129 206 3 0 0 0 0 8 129 32 189 16 1 0 0 0 1 8 129 32 189 16 1 0 0 0 0 16 146 130 114 247 111 207 165 146 3 137 7 108 202 3 0 0 1 16 146 130 114 247 111 207 165 146 3 137 7 108 202 3 0 0 0 8 39 239 53 138 178 87 103 0 1 8 39 239 53 138 178 87 103 0 0 16 93 101 243 102 175 163 130 167 97 174 190 36 53 183 138 34 1 16 93 101 243 102 175 163 130 167 97 174 190 36 53 183 138 34 0 4 248 0 0 0 1 4 248 0 0 0 0 16 62 103 144 183 253 247 47 175 131 2 146 108 70 0 0 0 1 16 62 103 144 183 253 247 47 175 131 2 146 108 70 0 0 0 0 16 242 249 139 183 120 173 114 251 225 239 132 139 200 207 5 0 1 16 242 249 139 183 120 173 114 251 225 239 132 139 200 207 5 0 0 8 155 82 241 50 32 1 0 0 1 8 155 82 241 50 32 1 0 0 0 16 60 134 203 255 253 239 75 71 228 52 78 20 210 216 164 3 1 16 60 134 203 255 253 239 75 71 228 52 78 20 210 216 164 3 0 4 240 0 0 0 1 4 240 0 0 0 0 8 74 91 152 79 191 112 95 219 1 8 74 91 152 79 191 112 95 219 0 4 225 143 234 246 1 4 225 143 234 246 0 8 59 117 218 172 152 176 204 177 1 8 59 117 218 172 152 176 204 177 0 12 24 92 218 89 248 53 68 137 80 0 0 0 1 12 24 92 218 89 248 53 68 137 80 0 0 0 0 8 135 175 3 193 49 7 0 0 1 8 135 175 3 193 49 7 0 0 0 16 84 36 200 56 126 134 172 99 144 135 104 167 75 161 1 0 1 16 84 36 200 56 126 134 172 99 144 135 104 167 75 161 1 0 0 16 32 97 136 27 224 36 111 146 219 92 164 16 135 119 12 0 1 16 32 97 136 27 224 36 111 146 219 92 164 16 135 119 12 0 0 8 150 186 205 101 122 21 0 0 1 8 150 186 205 101 122 21 0 0 0 8 61 0 74 249 72 64 1 0 1 8 61 0 74 249 72 64 1 0 0 4 5 0 0 0 1 4 5 0 0 0 0 4 85 231 0 0 1 4 85 231 0 0 0 4 7 53 39 0 1 4 7 53 39 0 0 16 184 113 56 241 136 99 250 169 41 38 17 218 6 0 0 0 1 16 184 113 56 241 136 99 250 169 41 38 17 218 6 0 0 0 0 16 76 17 162 144 32 230 52 94 118 23 68 114 229 89 0 0 1 16 76 17 162 144 32 230 52 94 118 23 68 114 229 89 0 0 0 8 89 183 34 241 180 158 11 0 1 8 89 183 34 241 180 158 11 0 0 4 71 186 244 17 1 4 71 186 244 17 0 4 63 193 206 147 1 4 63 193 206 147 0 8 65 67 174 89 21 0 0 0 1 8 65 67 174 89 21 0 0 0 0 8 24 124 240 73 208 51 10 0 1 8 24 124 240 73 208 51 10 0 0 8 127 149 228 141 130 187 206 212 1 8 127 149 228 141 130 187 206 212 0 4 150 21 0 0 1 4 150 21 0 0 0 4 36 148 234 13 1 4 36 148 234 13 0 4 22 10 2 0 1 4 22 10 2 0 0 8 112 48 196 1 161 60 78 227 1 8 112 48 196 1 161 60 78 227 0 16 141 191 62 222 54 255 93 191 23 154 244 121 104 127 150 0 1 16 141 191 62 222 54 255 93 191 23 154 244 121 104 127 150 0 0 16 1 239 62 155 92 171 183 88 243 250 73 64 154 209 61 6 1 16 1 239 62 155 92 171 183 88 243 250 73 64 154 209 61 6 0 16 226 241 36 137 89 204 106 60 252 68 23 9 46 14 188 7 1 16 226 241 36 137 89 204 106 60 252 68 23 9 46 14 188 7 0 12 168 243 51 12 205 84 127 124 104 103 17 0 1 12 168 243 51 12 205 84 127 124 104 103 17 0 0 12 199 246 222 200 216 155 75 134 115 5 0 0 1 12 199 246 222 200 216 155 75 134 115 5 0 0 0 12 205 246 227 212 19 202 146 146 12 32 222 104 1 12 205 246 227 212 19 202 146 146 12 32 222 104 0 4 231 2 0 0 1 4 231 2 0 0 0 8 112 223 182 198 202 220 170 0 1 8 112 223 182 198 202 220 170 0 0 4 0 212 75 197 1 4 0 212 75 197 0 12 138 108 72 105 190 154 118 34 30 0 0 0 1 12 138 108 72 105 190 154 118 34 30 0 0 0 0 8 48 85 228 16 168 11 0 0 1 8 48 85 228 16 168 11 0 0 0 4 62 1 0 0 1 4 62 1 0 0 0 16 6 102 249 196 237 58 2 184 77 192 3 21 141 0 0 0 1 16 6 102 249 196 237 58 2 184 77 192 3 21 141 0 0 0 0 8 8 78 34 173 18 4 0 0 1 8 8 78 34 173 18 4 0 0 0 4 7 0 0 0 1 4 7 0 0 0 0 8 239 135 16 50 170 2 57 0 1 8 239 135 16 50 170 2 57 0 0 4 183 0 0 0 1 4 183 0 0 0 0 16 177 22 53 249 155 145 101 251 26 74 122 154 45 100 11 0 1 16 177 22 53 249 155 145 101 251 26 74 122 154 45 100 11 0 0 4 80 56 225 0 1 4 80 56 225 0 0 16 76 235 10 21 204 158 27 14 68 131 188 49 79 0 0 0 1 16 76 235 10 21 204 158 27 14 68 131 188 49 79 0 0 0 0 12 251 170 198 48 126 70 130 132 60 154 11 0 1 12 251 170 198 48 126 70 130 132 60 154 11 0 0 8 191 30 191 254 3 0 0 0 1 8 191 30 191 254 3 0 0 0 0 12 54 216 58 148 106 237 238 143 196 75 61 50 1 12 54 216 58 148 106 237 238 143 196 75 61 50 0 4 179 134 5 0 1 4 179 134 5 0 0 12 241 40 126 116 35 208 214 118 64 224 2 0 1 12 241 40 126 116 35 208 214 118 64 224 2 0 0 8 192 249 163 87 76 23 44 169 1 8 192 249 163 87 76 23 44 169 0 8 20 54 151 190 175 212 60 7 1 8 20 54 151 190 175 212 60 7 0 8 216 96 161 160 23 138 1 0 1 8 216 96 161 160 23 138 1 0 0 12 229 209 203 219 86 233 187 99 117 0 0 0 1 12 229 209 203 219 86 233 187 99 117 0 0 0 0 12 245 229 198 81 226 138 11 41 33 213 8 22 1 12 245 229 198 81 226 138 11 41 33 213 8 22 0 8 123 178 141 23 108 0 0 0 1 8 123 178 141 23 108 0 0 0 0 8 209 241 222 253 33 0 0 0 1 8 209 241 222 253 33 0 0 0 0 12 220 85 110 10 15 95 4 6 252 132 103 77 1 12 220 85 110 10 15 95 4 6 252 132 103 77 0 12 189 132 98 150 159 168 163 157 176 8 1 0 1 12 189 132 98 150 159 168 163 157 176 8 1 0 0 4 226 130 140 1 1 4 226 130 140 1 0 16 143 231 15 168 10 112 155 62 246 19 188 101 111 0 0 0 1 16 143 231 15 168 10 112 155 62 246 19 188 101 111 0 0 0 0 12 90 83 73 223 21 149 198 225 16 118 121 1 1 12 90 83 73 223 21 149 198 225 16 118 121 1 0 8 250 107 147 104 78 3 0 0 1 8 250 107 147 104 78 3 0 0 0 4 112 132 221 2 1 4 112 132 221 2 0 8 233 38 129 60 112 9 2 0 1 8 233 38 129 60 112 9 2 0 0 8 31 200 44 22 247 29 0 0 1 8 31 200 44 22 247 29 0 0 0 8 64 140 226 178 63 3 0 0 1 8 64 140 226 178 63 3 0 0 0 12 102 203 87 33 78 209 7 212 252 71 0 0 1 12 102 203 87 33 78 209 7 212 252 71 0 0 0 16 124 235 50 2 230 251 163 236 12 65 16 16 124 0 0 0 1 16 124 235 50 2 230 251 163 236 12 65 16 16 124 0 0 0 0 16 150 159 188 85 64 141 109 45 11 90 81 64 1 0 0 0 1 16 150 159 188 85 64 141 109 45 11 90 81 64 1 0 0 0 0 12 167 59 70 31 206 169 7 64 31 128 72 0 1 12 167 59 70 31 206 169 7 64 31 128 72 0 0 4 44 3 0 0 1 4 44 3 0 0 0 8 245 254 182 131 34 27 3 0 1 8 245 254 182 131 34 27 3 0 0 16 127 105 58 125 131 87 50 215 211 128 179 128 247 65 82 0 1 16 127 105 58 125 131 87 50 215 211 128 179 128 247 65 82 0 0 8 201 118 45 227 189 189 136 2 1 8 201 118 45 227 189 189 136 2 0 16 73 205 21 184 2 160 55 216 156 146 207 246 12 0 0 0 1 16 73 205 21 184 2 160 55 216 156 146 207 246 12 0 0 0 0 8 88 131 129 83 59 1 0 0 1 8 88 131 129 83 59 1 0 0 0 8 118 58 124 202 93 158 94 84 1 8 118 58 124 202 93 158 94 84 0 16 114 144 11 78 137 113 34 58 211 201 128 28 24 49 27 0 1 16 114 144 11 78 137 113 34 58 211 201 128 28 24 49 27 0 0 8 227 62 145 88 15 34 21 0 1 8 227 62 145 88 15 34 21 0 0 8 144 79 175 34 58 184 155 52 1 8 144 79 175 34 58 184 155 52 0 8 169 92 48 156 119 52 152 6 1 8 169 92 48 156 119 52 152 6 0 16 64 241 66 116 157 84 90 13 43 150 240 179 1 0 0 0 1 16 64 241 66 116 157 84 90 13 43 150 240 179 1 0 0 0 0 8 249 36 108 106 67 0 0 0 1 8 249 36 108 106 67 0 0 0 0 4 24 219 0 0 1 4 24 219 0 0 0 12 132 220 144 75 157 31 158 221 3 0 0 0 1 12 132 220 144 75 157 31 158 221 3 0 0 0 0 8 22 51 150 54 80 88 15 0 1 8 22 51 150 54 80 88 15 0 0 12 254 143 211 239 187 165 87 122 3 0 0 0 1 12 254 143 211 239 187 165 87 122 3 0 0 0 0 16 90 132 24 254 5 211 89 38 55 116 158 144 100 66 0 0 1 16 90 132 24 254 5 211 89 38 55 116 158 144 100 66 0 0 0 16 119 186 36 149 246 36 59 35 232 254 155 141 203 2 0 0 1 16 119 186 36 149 246 36 59 35 232 254 155 141 203 2 0 0 0 8 203 46 49 133 154 163 0 0 1 8 203 46 49 133 154 163 0 0 0 16 173 84 223 120 95 131 253 29 244 109 99 100 18 0 0 0 1 16 173 84 223 120 95 131 253 29 244 109 99 100 18 0 0 0 0 16 163 90 76 225 185 170 229 28 217 73 104 176 75 142 57 0 1 16 163 90 76 225 185 170 229 28 217 73 104 176 75 142 57 0 0 12 253 112 155 58 247 162 195 140 168 20 3 0 1 12 253 112 155 58 247 162 195 140 168 20 3 0 0 12 249 122 124 0 146 109 174 30 4 0 0 0 1 12 249 122 124 0 146 109 174 30 4 0 0 0 0 8 144 2 45 119 93 56 2 0 1 8 144 2 45 119 93 56 2 0 0 4 45 33 10 0 1 4 45 33 10 0 0 16 186 27 85 177 145 135 52 106 165 148 53 70 246 1 0 0 1 16 186 27 85 177 145 135 52 106 165 148 53 70 246 1 0 0 0 4 68 52 17 4 1 4 68 52 17 4 0 12 241 159 13 20 11 64 214 104 47 0 0 0 1 12 241 159 13 20 11 64 214 104 47 0 0 0 0 16 32 95 224 178 8 58 144 200 201 145 83 22 116 60 79 2 1 16 32 95 224 178 8 58 144 200 201 145 83 22 116 60 79 2 0 8 215 108 179 124 111 116 0 0 1 8 215 108 179 124 111 116 0 0 0 16 72 135 153 119 46 195 147 13 252 2 59 0 117 125 64 77 1 16 72 135 153 119 46 195 147 13 252 2 59 0 117 125 64 77 0 16 93 46 81 15 142 242 250 221 79 61 178 228 143 87 244 0 1 16 93 46 81 15 142 242 250 221 79 61 178 228 143 87 244 0 0 4 139 93 95 57 1 4 139 93 95 57 0 16 76 36 152 198 40 178 106 21 207 164 31 24 28 10 1 0 1 16 76 36 152 198 40 178 106 21 207 164 31 24 28 10 1 0 0 4 19 0 0 0 1 4 19 0 0 0 0 12 9 25 202 138 170 88 179 0 75 0 0 0 1 12 9 25 202 138 170 88 179 0 75 0 0 0 0 8 169 231 136 224 45 30 2 0 1 8 169 231 136 224 45 30 2 0 0 12 54 251 180 193 77 7 254 217 190 81 0 0 1 12 54 251 180 193 77 7 254 217 190 81 0 0 0 16 167 75 62 7 42 70 13 12 21 5 163 135 11 0 0 0 1 16 167 75 62 7 42 70 13 12 21 5 163 135 11 0 0 0 0 12 138 166 227 194 104 244 199 0 232 12 0 0 1 12 138 166 227 194 104 244 199 0 232 12 0 0 0 8 203 27 84 77 12 139 18 28 1 8 203 27 84 77 12 139 18 28 0 4 159 124 135 1 1 4 159 124 135 1 0 12 211 117 92 112 68 205 243 46 127 0 0 0 1 12 211 117 92 112 68 205 243 46 127 0 0 0 0 8 173 148 132 161 87 0 0 0 1 8 173 148 132 161 87 0 0 0 0 4 9 0 0 0 1 4 9 0 0 0 0 8 133 26 216 191 172 89 213 40 1 8 133 26 216 191 172 89 213 40 0 16 211 26 153 111 42 16 37 94 105 14 57 163 225 193 0 0 1 16 211 26 153 111 42 16 37 94 105 14 57 163 225 193 0 0 0 4 128 164 207 191 1 4 128 164 207 191 0 4 133 171 31 6 1 4 133 171 31 6 0 16 58 142 105 140 176 184 239 208 55 131 225 185 144 11 0 0 1 16 58 142 105 140 176 184 239 208 55 131 225 185 144 11 0 0 0 16 69 153 92 71 249 203 122 156 39 73 222 95 210 32 1 0 1 16 69 153 92 71 249 203 122 156 39 73 222 95 210 32 1 0 0 4 230 66 104 5 1 4 230 66 104 5 0 8 161 45 37 11 195 19 140 0 1 8 161 45 37 11 195 19 140 0 0 4 234 74 122 82 1 4 234 74 122 82 0 4 177 246 13 0 1 4 177 246 13 0 0 4 49 224 136 0 1 4 49 224 136 0 0 8 125 71 166 1 1 0 0 0 1 8 125 71 166 1 1 0 0 0 0 4 141 121 130 15 1 4 141 121 130 15 0 16 86 207 74 133 184 161 240 207 34 130 144 107 83 0 0 0 1 16 86 207 74 133 184 161 240 207 34 130 144 107 83 0 0 0 0 8 35 48 213 98 222 69 132 0 1 8 35 48 213 98 222 69 132 0 0 8 182 209 82 82 113 25 178 59 1 8 182 209 82 82 113 25 178 59 0 8 180 86 59 54 31 2 0 0 1 8 180 86 59 54 31 2 0 0 0 4 45 45 0 0 1 4 45 45 0 0 0 16 21 185 217 174 9 133 26 231 15 65 115 190 75 64 49 0 1 16 21 185 217 174 9 133 26 231 15 65 115 190 75 64 49 0 0 12 165 110 209 80 73 74 135 193 159 99 14 0 1 12 165 110 209 80 73 74 135 193 159 99 14 0 0 8 212 39 10 198 84 40 188 1 1 8 212 39 10 198 84 40 188 1 0 12 229 117 144 57 201 122 60 120 207 235 3 0 1 12 229 117 144 57 201 122 60 120 207 235 3 0 0 4 219 123 115 0 1 4 219 123 115 0 0 12 191 142 53 119 168 100 219 47 160 3 0 0 1 12 191 142 53 119 168 100 219 47 160 3 0 0 0 16 227 12 18 159 53 213 206 140 179 189 209 125 126 174 21 0 1 16 227 12 18 159 53 213 206 140 179 189 209 125 126 174 21 0 0 12 108 182 247 254 150 50 85 5 140 125 196 22 1 12 108 182 247 254 150 50 85 5 140 125 196 22 0 16 92 126 28 210 248 52 158 233 246 129 152 227 129 228 4 25 1 16 92 126 28 210 248 52 158 233 246 129 152 227 129 228 4 25 0 8 211 136 158 83 43 95 0 0 1 8 211 136 158 83 43 95 0 0 0 8 83 253 195 70 35 14 7 1 1 8 83 253 195 70 35 14 7 1 0 12 105 111 185 175 206 124 63 83 199 79 41 0 1 12 105 111 185 175 206 124 63 83 199 79 41 0 0 4 6 50 0 0 1 4 6 50 0 0 0 12 183 89 151 17 18 108 172 173 36 98 141 13 1 12 183 89 151 17 18 108 172 173 36 98 141 13 0 8 218 149 242 52 5 0 0 0 1 8 218 149 242 52 5 0 0 0 0 4 84 210 0 0 1 4 84 210 0 0 0 8 227 16 100 125 154 10 22 0 1 8 227 16 100 125 154 10 22 0 0 4 99 11 2 0 1 4 99 11 2 0 0 12 59 200 146 111 178 201 210 58 7 10 0 0 1 12 59 200 146 111 178 201 210 58 7 10 0 0 0 8 245 98 135 241 52 234 83 2 1 8 245 98 135 241 52 234 83 2 0 8 111 24 151 152 13 0 0 0 1 8 111 24 151 152 13 0 0 0 0 4 214 0 0 0 1 4 214 0 0 0 0 12 107 171 142 230 68 214 222 6 143 20 0 0 1 12 107 171 142 230 68 214 222 6 143 20 0 0 0 16 31 138 93 248 13 219 151 196 232 112 179 55 114 0 0 0 1 16 31 138 93 248 13 219 151 196 232 112 179 55 114 0 0 0 0 12 126 160 35 63 198 30 3 106 28 63 3 6 1 12 126 160 35 63 198 30 3 106 28 63 3 6 0 4 104 8 59 0 1 4 104 8 59 0 0 4 211 64 154 42 1 4 211 64 154 42 0 16 190 175 183 140 51 33 188 44 220 15 129 79 197 5 0 0 1 16 190 175 183 140 51 33 188 44 220 15 129 79 197 5 0 0 0 4 58 149 0 0 1 4 58 149 0 0 0 8 168 78 159 61 141 1 0 0 1 8 168 78 159 61 141 1 0 0 0 8 50 34 114 75 132 0 0 0 1 8 50 34 114 75 132 0 0 0 0 12 228 96 210 155 189 131 157 123 187 84 8 0 1 12 228 96 210 155 189 131 157 123 187 84 8 0 0 8 105 43 140 252 152 3 0 0 1 8 105 43 140 252 152 3 0 0 0 8 93 153 83 251 251 19 6 0 1 8 93 153 83 251 251 19 6 0 0 8 59 202 65 95 133 34 100 0 1 8 59 202 65 95 133 34 100 0 0 16 175 130 225 146 216 107 99 14 39 177 93 74 28 0 0 0 1 16 175 130 225 146 216 107 99 14 39 177 93 74 28 0 0 0 0 12 60 102 67 81 214 180 246 82 1 0 0 0 1 12 60 102 67 81 214 180 246 82 1 0 0 0 0 4 29 156 0 0 1 4 29 156 0 0 0 4 144 22 0 0 1 4 144 22 0 0 0 16 126 85 237 254 119 29 6 190 202 60 208 130 101 7 221 121 1 16 126 85 237 254 119 29 6 190 202 60 208 130 101 7 221 121 0 8 109 138 127 241 6 0 0 0 1 8 109 138 127 241 6 0 0 0 0 4 104 29 47 0 1 4 104 29 47 0 0 16 105 197 115 163 120 218 156 57 157 204 105 245 2 0 0 0 1 16 105 197 115 163 120 218 156 57 157 204 105 245 2 0 0 0 0 16 43 62 73 147 228 196 140 60 148 83 16 164 4 0 0 0 1 16 43 62 73 147 228 196 140 60 148 83 16 164 4 0 0 0 0 4 31 0 0 0 1 4 31 0 0 0 0 8 241 157 192 68 3 0 0 0 1 8 241 157 192 68 3 0 0 0 0 16 108 147 5 178 33 167 30 134 205 25 105 66 48 22 245 0 1 16 108 147 5 178 33 167 30 134 205 25 105 66 48 22 245 0 0 8 129 42 147 65 1 0 0 0 1 8 129 42 147 65 1 0 0 0 0 12 246 130 162 45 151 113 85 86 26 158 229 111 1 12 246 130 162 45 151 113 85 86 26 158 229 111 0 4 169 64 0 0 1 4 169 64 0 0 0 8 239 189 219 253 42 82 213 153 1 8 239 189 219 253 42 82 213 153 0 8 3 41 244 12 23 4 0 0 1 8 3 41 244 12 23 4 0 0 0 12 45 29 75 228 251 90 142 140 229 6 0 0 1 12 45 29 75 228 251 90 142 140 229 6 0 0 0 8 46 253 114 12 61 0 0 0 1 8 46 253 114 12 61 0 0 0 0 4 182 105 196 214 1 4 182 105 196 214 0 16 85 197 138 192 105 13 137 11 199 237 60 146 247 3 63 24 1 16 85 197 138 192 105 13 137 11 199 237 60 146 247 3 63 24 0 8 62 83 233 195 226 186 158 9 1 8 62 83 233 195 226 186 158 9 0 4 255 213 102 22 1 4 255 213 102 22


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int128_serial64.txt
================================================
22 serialization::archive 10 0 0 0 0 0 16 37 8 254 63 21 239 57 20 229 108 249 176 89 1 0 0 1 16 37 8 254 63 21 239 57 20 229 108 249 176 89 1 0 0 0 8 44 53 2 0 0 0 0 0 1 8 44 53 2 0 0 0 0 0 0 16 255 227 23 91 116 215 6 77 105 216 187 1 221 183 7 0 1 16 255 227 23 91 116 215 6 77 105 216 187 1 221 183 7 0 0 16 215 97 73 133 223 240 209 70 227 76 76 44 42 9 0 0 1 16 215 97 73 133 223 240 209 70 227 76 76 44 42 9 0 0 0 8 26 205 1 0 0 0 0 0 1 8 26 205 1 0 0 0 0 0 0 16 171 248 220 122 202 115 96 223 240 82 153 66 149 194 43 14 1 16 171 248 220 122 202 115 96 223 240 82 153 66 149 194 43 14 0 16 73 169 70 111 188 124 78 80 182 195 40 65 247 218 58 0 1 16 73 169 70 111 188 124 78 80 182 195 40 65 247 218 58 0 0 8 55 1 42 59 0 0 0 0 1 8 55 1 42 59 0 0 0 0 0 16 112 146 42 85 255 28 14 50 168 228 0 0 0 0 0 0 1 16 112 146 42 85 255 28 14 50 168 228 0 0 0 0 0 0 0 8 3 132 142 0 89 0 0 0 1 8 3 132 142 0 89 0 0 0 0 8 59 31 0 0 0 0 0 0 1 8 59 31 0 0 0 0 0 0 0 16 128 184 17 143 213 41 148 184 91 0 0 0 0 0 0 0 1 16 128 184 17 143 213 41 148 184 91 0 0 0 0 0 0 0 0 8 52 43 163 205 58 0 0 0 1 8 52 43 163 205 58 0 0 0 0 8 7 136 199 3 0 0 0 0 1 8 7 136 199 3 0 0 0 0 0 16 103 144 142 223 219 161 68 75 104 0 0 0 0 0 0 0 1 16 103 144 142 223 219 161 68 75 104 0 0 0 0 0 0 0 0 16 231 211 175 248 223 4 118 100 4 104 73 218 45 121 30 164 1 16 231 211 175 248 223 4 118 100 4 104 73 218 45 121 30 164 0 16 64 136 51 28 35 115 186 14 0 15 31 170 194 137 96 1 1 16 64 136 51 28 35 115 186 14 0 15 31 170 194 137 96 1 0 16 6 253 75 10 176 96 217 180 15 153 73 162 221 96 13 175 1 16 6 253 75 10 176 96 217 180 15 153 73 162 221 96 13 175 0 16 9 195 227 5 98 90 197 22 123 173 13 24 184 217 65 14 1 16 9 195 227 5 98 90 197 22 123 173 13 24 184 217 65 14 0 16 36 207 83 207 252 162 46 155 216 62 210 211 118 157 254 13 1 16 36 207 83 207 252 162 46 155 216 62 210 211 118 157 254 13 0 8 48 115 9 0 0 0 0 0 1 8 48 115 9 0 0 0 0 0 0 16 18 132 205 178 240 43 208 33 177 56 170 10 0 0 0 0 1 16 18 132 205 178 240 43 208 33 177 56 170 10 0 0 0 0 0 16 0 134 168 204 110 75 199 196 245 20 142 108 179 194 4 27 1 16 0 134 168 204 110 75 199 196 245 20 142 108 179 194 4 27 0 16 137 40 185 28 226 228 143 223 62 177 68 144 87 133 253 16 1 16 137 40 185 28 226 228 143 223 62 177 68 144 87 133 253 16 0 16 241 205 249 80 146 210 1 55 43 173 109 143 84 117 209 0 1 16 241 205 249 80 146 210 1 55 43 173 109 143 84 117 209 0 0 8 171 208 0 0 0 0 0 0 1 8 171 208 0 0 0 0 0 0 0 8 131 223 243 126 121 98 88 88 1 8 131 223 243 126 121 98 88 88 0 16 34 183 141 118 51 30 229 127 23 141 157 166 11 0 0 0 1 16 34 183 141 118 51 30 229 127 23 141 157 166 11 0 0 0 0 16 58 245 156 2 19 251 183 255 219 45 27 253 9 0 0 0 1 16 58 245 156 2 19 251 183 255 219 45 27 253 9 0 0 0 0 8 153 44 205 37 255 0 0 0 1 8 153 44 205 37 255 0 0 0 0 8 246 238 8 0 0 0 0 0 1 8 246 238 8 0 0 0 0 0 0 8 7 0 0 0 0 0 0 0 1 8 7 0 0 0 0 0 0 0 0 8 8 53 135 13 104 37 51 0 1 8 8 53 135 13 104 37 51 0 0 8 89 148 1 0 0 0 0 0 1 8 89 148 1 0 0 0 0 0 0 16 220 42 79 160 82 149 191 194 119 33 248 143 15 159 45 0 1 16 220 42 79 160 82 149 191 194 119 33 248 143 15 159 45 0 0 16 85 100 42 49 80 139 191 189 106 176 0 0 0 0 0 0 1 16 85 100 42 49 80 139 191 189 106 176 0 0 0 0 0 0 0 16 244 148 210 156 57 140 123 241 227 171 90 25 5 0 0 0 1 16 244 148 210 156 57 140 123 241 227 171 90 25 5 0 0 0 0 16 11 118 127 38 199 175 117 18 23 63 204 177 158 199 1 0 1 16 11 118 127 38 199 175 117 18 23 63 204 177 158 199 1 0 0 16 133 146 81 4 4 226 254 92 139 68 104 13 103 27 212 5 1 16 133 146 81 4 4 226 254 92 139 68 104 13 103 27 212 5 0 16 32 198 99 47 231 25 151 81 1 0 0 0 0 0 0 0 1 16 32 198 99 47 231 25 151 81 1 0 0 0 0 0 0 0 0 16 137 233 68 65 94 40 65 221 33 159 2 0 0 0 0 0 1 16 137 233 68 65 94 40 65 221 33 159 2 0 0 0 0 0 0 16 83 34 240 62 72 73 173 41 206 111 192 80 37 0 0 0 1 16 83 34 240 62 72 73 173 41 206 111 192 80 37 0 0 0 0 8 97 0 0 0 0 0 0 0 1 8 97 0 0 0 0 0 0 0 0 8 138 189 92 247 169 147 0 0 1 8 138 189 92 247 169 147 0 0 0 16 161 190 61 94 114 107 106 245 122 129 25 170 59 22 0 0 1 16 161 190 61 94 114 107 106 245 122 129 25 170 59 22 0 0 0 8 2 130 235 26 0 0 0 0 1 8 2 130 235 26 0 0 0 0 0 16 109 53 53 179 152 230 103 254 224 148 134 9 132 15 236 0 1 16 109 53 53 179 152 230 103 254 224 148 134 9 132 15 236 0 0 16 213 70 114 188 144 14 234 210 9 163 24 0 0 0 0 0 1 16 213 70 114 188 144 14 234 210 9 163 24 0 0 0 0 0 0 16 33 107 225 17 111 28 212 164 73 197 193 0 0 0 0 0 1 16 33 107 225 17 111 28 212 164 73 197 193 0 0 0 0 0 0 8 146 173 184 73 148 56 4 0 1 8 146 173 184 73 148 56 4 0 0 16 44 163 145 53 213 144 139 110 48 114 127 219 0 0 0 0 1 16 44 163 145 53 213 144 139 110 48 114 127 219 0 0 0 0 0 16 173 188 229 221 105 34 146 117 254 239 166 51 0 0 0 0 1 16 173 188 229 221 105 34 146 117 254 239 166 51 0 0 0 0 0 16 4 69 232 58 38 108 238 203 253 199 77 145 0 0 0 0 1 16 4 69 232 58 38 108 238 203 253 199 77 145 0 0 0 0 0 8 107 215 91 159 76 215 198 33 1 8 107 215 91 159 76 215 198 33 0 8 11 77 137 244 167 98 1 0 1 8 11 77 137 244 167 98 1 0 0 8 186 129 52 47 127 178 152 0 1 8 186 129 52 47 127 178 152 0 0 16 201 180 214 22 110 46 55 229 64 200 26 0 0 0 0 0 1 16 201 180 214 22 110 46 55 229 64 200 26 0 0 0 0 0 0 8 208 223 215 0 0 0 0 0 1 8 208 223 215 0 0 0 0 0 0 8 64 29 111 0 0 0 0 0 1 8 64 29 111 0 0 0 0 0 0 8 189 214 205 206 195 1 0 0 1 8 189 214 205 206 195 1 0 0 0 16 186 181 125 189 118 38 122 114 34 230 100 1 0 0 0 0 1 16 186 181 125 189 118 38 122 114 34 230 100 1 0 0 0 0 0 16 48 214 190 50 128 72 169 213 65 189 101 126 93 0 0 0 1 16 48 214 190 50 128 72 169 213 65 189 101 126 93 0 0 0 0 8 30 0 0 0 0 0 0 0 1 8 30 0 0 0 0 0 0 0 0 8 13 245 224 15 53 1 0 0 1 8 13 245 224 15 53 1 0 0 0 8 202 238 193 147 15 0 0 0 1 8 202 238 193 147 15 0 0 0 0 16 128 116 52 14 187 110 131 0 144 16 182 41 228 82 0 0 1 16 128 116 52 14 187 110 131 0 144 16 182 41 228 82 0 0 0 8 100 0 0 0 0 0 0 0 1 8 100 0 0 0 0 0 0 0 0 8 89 180 24 0 0 0 0 0 1 8 89 180 24 0 0 0 0 0 0 8 34 124 0 0 0 0 0 0 1 8 34 124 0 0 0 0 0 0 0 16 250 39 95 39 67 1 167 94 233 155 216 3 100 183 116 118 1 16 250 39 95 39 67 1 167 94 233 155 216 3 100 183 116 118 0 16 128 143 58 104 102 58 4 109 40 213 225 112 135 3 0 0 1 16 128 143 58 104 102 58 4 109 40 213 225 112 135 3 0 0 0 16 182 167 174 164 204 91 160 188 128 28 213 237 236 1 0 0 1 16 182 167 174 164 204 91 160 188 128 28 213 237 236 1 0 0 0 16 198 204 232 165 163 187 202 201 158 244 103 2 0 0 0 0 1 16 198 204 232 165 163 187 202 201 158 244 103 2 0 0 0 0 0 8 52 41 2 0 0 0 0 0 1 8 52 41 2 0 0 0 0 0 0 8 95 141 198 19 2 2 0 0 1 8 95 141 198 19 2 2 0 0 0 16 254 2 20 231 85 24 126 151 177 138 78 145 2 0 0 0 1 16 254 2 20 231 85 24 126 151 177 138 78 145 2 0 0 0 0 16 127 34 155 130 248 106 222 183 31 216 113 190 213 220 134 3 1 16 127 34 155 130 248 106 222 183 31 216 113 190 213 220 134 3 0 8 185 223 116 102 248 10 180 190 1 8 185 223 116 102 248 10 180 190 0 8 28 0 0 0 0 0 0 0 1 8 28 0 0 0 0 0 0 0 0 16 152 5 232 129 30 191 73 187 48 122 16 0 0 0 0 0 1 16 152 5 232 129 30 191 73 187 48 122 16 0 0 0 0 0 0 8 22 174 151 82 172 15 209 0 1 8 22 174 151 82 172 15 209 0 0 8 167 181 0 0 0 0 0 0 1 8 167 181 0 0 0 0 0 0 0 8 34 164 28 2 70 207 0 0 1 8 34 164 28 2 70 207 0 0 0 8 73 175 2 31 0 0 0 0 1 8 73 175 2 31 0 0 0 0 0 16 191 123 4 56 221 89 117 10 45 163 68 188 6 0 0 0 1 16 191 123 4 56 221 89 117 10 45 163 68 188 6 0 0 0 0 8 32 0 0 0 0 0 0 0 1 8 32 0 0 0 0 0 0 0 0 16 153 114 240 104 169 142 230 72 169 205 183 45 29 0 0 0 1 16 153 114 240 104 169 142 230 72 169 205 183 45 29 0 0 0 0 8 104 0 0 0 0 0 0 0 1 8 104 0 0 0 0 0 0 0 0 8 250 4 201 0 0 0 0 0 1 8 250 4 201 0 0 0 0 0 0 8 235 69 188 51 63 136 32 0 1 8 235 69 188 51 63 136 32 0 0 8 194 197 163 82 68 56 132 186 1 8 194 197 163 82 68 56 132 186 0 8 209 149 168 103 172 0 245 13 1 8 209 149 168 103 172 0 245 13 0 8 95 103 181 13 108 192 162 0 1 8 95 103 181 13 108 192 162 0 0 8 203 201 28 164 225 153 81 140 1 8 203 201 28 164 225 153 81 140 0 16 61 213 68 146 15 4 91 15 163 73 1 0 0 0 0 0 1 16 61 213 68 146 15 4 91 15 163 73 1 0 0 0 0 0 0 16 94 145 165 53 103 5 192 143 85 206 43 169 47 0 0 0 1 16 94 145 165 53 103 5 192 143 85 206 43 169 47 0 0 0 0 16 50 151 92 208 203 159 144 76 92 251 123 11 0 0 0 0 1 16 50 151 92 208 203 159 144 76 92 251 123 11 0 0 0 0 0 16 190 5 157 205 191 246 224 1 231 37 151 216 251 10 66 0 1 16 190 5 157 205 191 246 224 1 231 37 151 216 251 10 66 0 0 16 77 149 133 65 141 196 79 8 138 249 60 120 0 0 0 0 1 16 77 149 133 65 141 196 79 8 138 249 60 120 0 0 0 0 0 16 220 86 90 254 157 201 65 199 11 135 199 91 106 0 0 0 1 16 220 86 90 254 157 201 65 199 11 135 199 91 106 0 0 0 0 8 204 151 79 174 7 0 0 0 1 8 204 151 79 174 7 0 0 0 0 16 24 141 202 136 150 117 206 49 76 1 63 7 0 0 0 0 1 16 24 141 202 136 150 117 206 49 76 1 63 7 0 0 0 0 0 16 119 133 5 211 186 190 56 29 220 201 21 0 0 0 0 0 1 16 119 133 5 211 186 190 56 29 220 201 21 0 0 0 0 0 0 8 7 0 0 0 0 0 0 0 1 8 7 0 0 0 0 0 0 0 0 16 72 15 156 17 9 105 177 79 67 146 0 0 0 0 0 0 1 16 72 15 156 17 9 105 177 79 67 146 0 0 0 0 0 0 0 16 249 168 160 82 66 6 134 143 40 37 107 13 0 0 0 0 1 16 249 168 160 82 66 6 134 143 40 37 107 13 0 0 0 0 0 8 4 185 65 0 0 0 0 0 1 8 4 185 65 0 0 0 0 0 0 16 12 112 73 235 143 130 15 35 185 148 4 0 0 0 0 0 1 16 12 112 73 235 143 130 15 35 185 148 4 0 0 0 0 0 0 8 245 60 0 0 0 0 0 0 1 8 245 60 0 0 0 0 0 0 0 8 42 49 128 144 182 3 210 10 1 8 42 49 128 144 182 3 210 10 0 16 213 148 0 33 85 171 97 185 1 0 0 0 0 0 0 0 1 16 213 148 0 33 85 171 97 185 1 0 0 0 0 0 0 0 0 16 54 54 252 21 199 151 88 16 3 233 15 10 1 0 0 0 1 16 54 54 252 21 199 151 88 16 3 233 15 10 1 0 0 0 0 16 34 61 250 8 165 194 32 79 231 214 230 190 194 240 114 7 1 16 34 61 250 8 165 194 32 79 231 214 230 190 194 240 114 7 0 16 104 245 221 84 173 227 229 31 19 5 0 0 0 0 0 0 1 16 104 245 221 84 173 227 229 31 19 5 0 0 0 0 0 0 0 8 240 84 253 169 3 21 0 0 1 8 240 84 253 169 3 21 0 0 0 16 178 134 22 38 169 249 193 201 236 162 74 212 159 200 1 0 1 16 178 134 22 38 169 249 193 201 236 162 74 212 159 200 1 0 0 16 188 15 207 107 111 126 74 110 184 12 0 0 0 0 0 0 1 16 188 15 207 107 111 126 74 110 184 12 0 0 0 0 0 0 0 16 135 53 52 188 239 136 188 128 108 91 237 149 155 0 0 0 1 16 135 53 52 188 239 136 188 128 108 91 237 149 155 0 0 0 0 8 214 243 150 104 0 0 0 0 1 8 214 243 150 104 0 0 0 0 0 8 28 0 0 0 0 0 0 0 1 8 28 0 0 0 0 0 0 0 0 16 176 32 111 181 139 147 85 223 223 124 248 32 1 0 0 0 1 16 176 32 111 181 139 147 85 223 223 124 248 32 1 0 0 0 0 16 220 111 201 142 140 206 56 69 169 37 41 8 209 2 0 0 1 16 220 111 201 142 140 206 56 69 169 37 41 8 209 2 0 0 0 8 49 22 111 81 3 0 0 0 1 8 49 22 111 81 3 0 0 0 0 16 12 25 137 51 170 194 60 198 250 154 97 254 184 1 0 0 1 16 12 25 137 51 170 194 60 198 250 154 97 254 184 1 0 0 0 16 69 58 72 167 111 230 201 95 3 0 0 0 0 0 0 0 1 16 69 58 72 167 111 230 201 95 3 0 0 0 0 0 0 0 0 16 125 163 188 25 216 18 75 50 70 157 149 113 247 26 143 0 1 16 125 163 188 25 216 18 75 50 70 157 149 113 247 26 143 0 0 16 178 36 11 168 110 204 18 55 17 174 31 2 0 0 0 0 1 16 178 36 11 168 110 204 18 55 17 174 31 2 0 0 0 0 0 8 54 253 119 216 234 173 18 0 1 8 54 253 119 216 234 173 18 0 0 16 58 138 90 25 198 44 141 36 21 50 150 6 116 188 7 0 1 16 58 138 90 25 198 44 141 36 21 50 150 6 116 188 7 0 0 8 48 232 209 253 50 174 219 0 1 8 48 232 209 253 50 174 219 0 0 16 98 231 108 128 132 248 24 45 51 233 172 99 10 48 164 6 1 16 98 231 108 128 132 248 24 45 51 233 172 99 10 48 164 6 0 16 63 148 202 142 42 126 95 240 217 3 0 0 0 0 0 0 1 16 63 148 202 142 42 126 95 240 217 3 0 0 0 0 0 0 0 16 211 178 116 92 43 40 217 152 60 0 0 0 0 0 0 0 1 16 211 178 116 92 43 40 217 152 60 0 0 0 0 0 0 0 0 8 173 137 40 0 0 0 0 0 1 8 173 137 40 0 0 0 0 0 0 8 205 61 6 0 0 0 0 0 1 8 205 61 6 0 0 0 0 0 0 16 88 56 246 47 152 18 79 21 156 80 31 84 2 0 0 0 1 16 88 56 246 47 152 18 79 21 156 80 31 84 2 0 0 0 0 8 47 61 12 0 0 0 0 0 1 8 47 61 12 0 0 0 0 0 0 8 160 13 53 81 0 0 0 0 1 8 160 13 53 81 0 0 0 0 0 8 32 187 228 46 5 0 0 0 1 8 32 187 228 46 5 0 0 0 0 16 182 2 196 123 7 142 61 89 72 17 68 180 113 1 0 0 1 16 182 2 196 123 7 142 61 89 72 17 68 180 113 1 0 0 0 16 120 38 117 243 129 114 66 195 74 148 250 9 85 2 0 0 1 16 120 38 117 243 129 114 66 195 74 148 250 9 85 2 0 0 0 16 233 65 214 75 155 124 3 9 180 156 12 179 244 180 184 111 1 16 233 65 214 75 155 124 3 9 180 156 12 179 244 180 184 111 0 8 23 43 78 31 7 0 0 0 1 8 23 43 78 31 7 0 0 0 0 8 229 205 68 230 125 8 0 0 1 8 229 205 68 230 125 8 0 0 0 16 141 13 91 38 76 112 200 170 250 212 26 1 124 1 0 0 1 16 141 13 91 38 76 112 200 170 250 212 26 1 124 1 0 0 0 8 41 127 133 106 252 0 0 0 1 8 41 127 133 106 252 0 0 0 0 8 60 152 174 163 1 0 0 0 1 8 60 152 174 163 1 0 0 0 0 8 15 0 0 0 0 0 0 0 1 8 15 0 0 0 0 0 0 0 0 16 24 134 100 43 20 248 31 252 145 239 220 39 16 158 117 0 1 16 24 134 100 43 20 248 31 252 145 239 220 39 16 158 117 0 0 8 175 72 124 35 0 0 0 0 1 8 175 72 124 35 0 0 0 0 0 8 244 49 63 40 249 6 0 0 1 8 244 49 63 40 249 6 0 0 0 16 200 70 212 56 217 96 254 3 156 68 43 183 192 143 8 0 1 16 200 70 212 56 217 96 254 3 156 68 43 183 192 143 8 0 0 8 219 122 30 5 0 0 0 0 1 8 219 122 30 5 0 0 0 0 0 16 152 26 100 200 15 32 129 3 69 217 98 106 201 17 0 0 1 16 152 26 100 200 15 32 129 3 69 217 98 106 201 17 0 0 0 8 220 43 90 166 0 0 0 0 1 8 220 43 90 166 0 0 0 0 0 16 1 74 237 23 159 49 174 181 39 193 105 137 206 197 208 2 1 16 1 74 237 23 159 49 174 181 39 193 105 137 206 197 208 2 0 16 2 162 116 55 83 71 3 224 58 31 0 0 0 0 0 0 1 16 2 162 116 55 83 71 3 224 58 31 0 0 0 0 0 0 0 16 219 109 251 155 10 110 246 132 227 114 221 29 13 0 0 0 1 16 219 109 251 155 10 110 246 132 227 114 221 29 13 0 0 0 0 8 142 91 8 37 228 217 181 55 1 8 142 91 8 37 228 217 181 55 0 16 189 154 57 63 85 92 144 161 46 212 177 53 47 4 29 90 1 16 189 154 57 63 85 92 144 161 46 212 177 53 47 4 29 90 0 8 14 190 95 210 115 71 0 0 1 8 14 190 95 210 115 71 0 0 0 8 47 2 0 0 0 0 0 0 1 8 47 2 0 0 0 0 0 0 0 16 174 101 211 131 68 66 216 221 166 22 253 95 142 0 0 0 1 16 174 101 211 131 68 66 216 221 166 22 253 95 142 0 0 0 0 16 198 1 17 204 40 96 166 196 65 117 215 34 58 0 0 0 1 16 198 1 17 204 40 96 166 196 65 117 215 34 58 0 0 0 0 16 155 139 7 253 130 3 210 83 54 12 0 0 0 0 0 0 1 16 155 139 7 253 130 3 210 83 54 12 0 0 0 0 0 0 0 16 164 44 176 210 229 112 131 132 31 15 0 0 0 0 0 0 1 16 164 44 176 210 229 112 131 132 31 15 0 0 0 0 0 0 0 16 197 192 242 64 16 33 210 29 215 0 0 0 0 0 0 0 1 16 197 192 242 64 16 33 210 29 215 0 0 0 0 0 0 0 0 16 247 202 39 209 87 88 199 30 93 71 125 42 0 0 0 0 1 16 247 202 39 209 87 88 199 30 93 71 125 42 0 0 0 0 0 16 4 91 228 117 233 235 177 229 123 87 8 196 42 243 50 0 1 16 4 91 228 117 233 235 177 229 123 87 8 196 42 243 50 0 0 16 177 254 109 38 43 208 254 238 71 49 150 0 0 0 0 0 1 16 177 254 109 38 43 208 254 238 71 49 150 0 0 0 0 0 0 8 66 45 234 248 31 0 0 0 1 8 66 45 234 248 31 0 0 0 0 16 105 210 161 233 29 116 129 70 143 74 88 0 0 0 0 0 1 16 105 210 161 233 29 116 129 70 143 74 88 0 0 0 0 0 0 16 43 147 216 50 132 234 9 232 69 151 33 92 3 0 0 0 1 16 43 147 216 50 132 234 9 232 69 151 33 92 3 0 0 0 0 8 205 117 182 80 150 98 9 0 1 8 205 117 182 80 150 98 9 0 0 16 58 110 227 57 169 95 102 122 66 27 229 232 1 0 0 0 1 16 58 110 227 57 169 95 102 122 66 27 229 232 1 0 0 0 0 16 230 26 192 136 251 74 228 31 223 1 0 0 0 0 0 0 1 16 230 26 192 136 251 74 228 31 223 1 0 0 0 0 0 0 0 8 27 77 126 125 205 208 0 0 1 8 27 77 126 125 205 208 0 0 0 8 105 207 185 22 0 0 0 0 1 8 105 207 185 22 0 0 0 0 0 16 177 81 106 231 133 43 4 174 118 0 0 0 0 0 0 0 1 16 177 81 106 231 133 43 4 174 118 0 0 0 0 0 0 0 0 16 151 193 51 229 154 159 106 17 13 0 0 0 0 0 0 0 1 16 151 193 51 229 154 159 106 17 13 0 0 0 0 0 0 0 0 8 9 5 0 0 0 0 0 0 1 8 9 5 0 0 0 0 0 0 0 8 154 3 91 22 110 99 13 0 1 8 154 3 91 22 110 99 13 0 0 8 46 0 0 0 0 0 0 0 1 8 46 0 0 0 0 0 0 0 0 8 165 178 204 139 226 102 0 0 1 8 165 178 204 139 226 102 0 0 0 16 255 166 141 198 137 1 215 240 13 0 0 0 0 0 0 0 1 16 255 166 141 198 137 1 215 240 13 0 0 0 0 0 0 0 0 16 240 214 172 107 207 30 49 24 165 26 0 0 0 0 0 0 1 16 240 214 172 107 207 30 49 24 165 26 0 0 0 0 0 0 0 16 169 62 163 160 84 45 148 118 196 244 39 206 4 0 0 0 1 16 169 62 163 160 84 45 148 118 196 244 39 206 4 0 0 0 0 8 51 45 245 18 221 94 0 0 1 8 51 45 245 18 221 94 0 0 0 16 56 138 53 228 133 56 250 127 145 126 56 71 96 42 205 0 1 16 56 138 53 228 133 56 250 127 145 126 56 71 96 42 205 0 0 16 96 10 238 153 254 99 179 181 215 150 183 141 204 183 59 15 1 16 96 10 238 153 254 99 179 181 215 150 183 141 204 183 59 15 0 8 234 122 2 0 0 0 0 0 1 8 234 122 2 0 0 0 0 0 0 8 171 166 2 0 0 0 0 0 1 8 171 166 2 0 0 0 0 0 0 16 70 249 164 0 38 67 121 141 34 1 0 0 0 0 0 0 1 16 70 249 164 0 38 67 121 141 34 1 0 0 0 0 0 0 0 8 114 2 113 130 156 93 2 0 1 8 114 2 113 130 156 93 2 0 0 8 128 254 47 66 253 230 215 9 1 8 128 254 47 66 253 230 215 9 0 8 128 118 25 126 97 184 0 0 1 8 128 118 25 126 97 184 0 0 0 8 6 0 0 0 0 0 0 0 1 8 6 0 0 0 0 0 0 0 0 16 98 121 37 228 245 254 160 122 192 239 13 51 0 0 0 0 1 16 98 121 37 228 245 254 160 122 192 239 13 51 0 0 0 0 0 8 32 22 37 123 21 27 0 0 1 8 32 22 37 123 21 27 0 0 0 8 128 162 228 118 64 127 3 0 1 8 128 162 228 118 64 127 3 0 0 8 166 181 11 0 0 0 0 0 1 8 166 181 11 0 0 0 0 0 0 16 28 166 115 28 45 10 239 211 13 246 240 137 229 3 80 0 1 16 28 166 115 28 45 10 239 211 13 246 240 137 229 3 80 0 0 16 234 15 55 214 194 155 139 231 81 180 44 125 14 0 0 0 1 16 234 15 55 214 194 155 139 231 81 180 44 125 14 0 0 0 0 8 177 167 106 207 184 208 150 0 1 8 177 167 106 207 184 208 150 0 0 8 13 195 217 57 88 2 0 0 1 8 13 195 217 57 88 2 0 0 0 16 54 96 61 217 136 240 218 168 74 235 61 179 94 124 0 0 1 16 54 96 61 217 136 240 218 168 74 235 61 179 94 124 0 0 0 8 133 19 3 202 163 74 201 191 1 8 133 19 3 202 163 74 201 191 0 16 76 246 211 13 154 46 92 228 43 105 0 0 0 0 0 0 1 16 76 246 211 13 154 46 92 228 43 105 0 0 0 0 0 0 0 8 238 231 7 0 0 0 0 0 1 8 238 231 7 0 0 0 0 0 0 8 121 5 0 0 0 0 0 0 1 8 121 5 0 0 0 0 0 0 0 16 254 32 157 147 246 229 100 39 232 13 0 0 0 0 0 0 1 16 254 32 157 147 246 229 100 39 232 13 0 0 0 0 0 0 0 8 148 204 30 203 96 118 103 26 1 8 148 204 30 203 96 118 103 26 0 8 86 94 188 134 7 0 0 0 1 8 86 94 188 134 7 0 0 0 0 8 190 236 210 228 178 0 0 0 1 8 190 236 210 228 178 0 0 0 0 16 159 29 240 26 162 129 48 140 42 98 6 0 0 0 0 0 1 16 159 29 240 26 162 129 48 140 42 98 6 0 0 0 0 0 0 16 201 94 127 117 141 245 104 70 17 0 0 0 0 0 0 0 1 16 201 94 127 117 141 245 104 70 17 0 0 0 0 0 0 0 0 16 186 185 167 145 50 174 180 1 50 29 53 1 0 0 0 0 1 16 186 185 167 145 50 174 180 1 50 29 53 1 0 0 0 0 0 16 104 112 112 189 66 154 31 214 228 234 171 7 0 0 0 0 1 16 104 112 112 189 66 154 31 214 228 234 171 7 0 0 0 0 0 16 165 159 159 174 251 240 214 4 220 88 34 125 0 0 0 0 1 16 165 159 159 174 251 240 214 4 220 88 34 125 0 0 0 0 0 16 231 72 142 22 2 169 79 36 221 251 129 37 230 30 25 38 1 16 231 72 142 22 2 169 79 36 221 251 129 37 230 30 25 38 0 8 95 25 73 135 187 21 41 2 1 8 95 25 73 135 187 21 41 2 0 16 203 77 25 62 42 39 26 203 12 34 248 30 0 0 0 0 1 16 203 77 25 62 42 39 26 203 12 34 248 30 0 0 0 0 0 8 19 6 0 0 0 0 0 0 1 8 19 6 0 0 0 0 0 0 0 16 68 151 207 206 205 132 15 184 12 208 217 190 252 148 29 0 1 16 68 151 207 206 205 132 15 184 12 208 217 190 252 148 29 0 0 8 172 170 222 106 0 0 0 0 1 8 172 170 222 106 0 0 0 0 0 16 255 209 208 122 18 160 62 50 2 0 0 0 0 0 0 0 1 16 255 209 208 122 18 160 62 50 2 0 0 0 0 0 0 0 0 16 71 17 98 35 48 147 54 205 13 239 235 222 162 130 39 0 1 16 71 17 98 35 48 147 54 205 13 239 235 222 162 130 39 0 0 16 123 91 181 63 20 138 251 142 208 1 0 0 0 0 0 0 1 16 123 91 181 63 20 138 251 142 208 1 0 0 0 0 0 0 0 8 223 195 7 0 0 0 0 0 1 8 223 195 7 0 0 0 0 0 0 16 46 37 83 84 120 104 86 18 1 0 0 0 0 0 0 0 1 16 46 37 83 84 120 104 86 18 1 0 0 0 0 0 0 0 0 16 11 123 221 123 22 39 126 107 97 71 79 173 196 6 0 0 1 16 11 123 221 123 22 39 126 107 97 71 79 173 196 6 0 0 0 8 53 164 236 57 255 127 20 4 1 8 53 164 236 57 255 127 20 4 0 16 35 197 22 114 86 55 189 134 3 0 0 0 0 0 0 0 1 16 35 197 22 114 86 55 189 134 3 0 0 0 0 0 0 0 0 16 77 141 58 157 14 215 57 68 1 0 0 0 0 0 0 0 1 16 77 141 58 157 14 215 57 68 1 0 0 0 0 0 0 0 0 16 102 255 109 147 11 143 27 213 47 176 30 89 64 94 213 66 1 16 102 255 109 147 11 143 27 213 47 176 30 89 64 94 213 66 0 8 190 247 33 10 138 0 6 6 1 8 190 247 33 10 138 0 6 6 0 8 110 2 0 0 0 0 0 0 1 8 110 2 0 0 0 0 0 0 0 16 223 83 113 107 137 221 86 37 48 2 144 161 169 28 0 0 1 16 223 83 113 107 137 221 86 37 48 2 144 161 169 28 0 0 0 8 189 254 123 237 246 176 128 2 1 8 189 254 123 237 246 176 128 2 0 16 243 132 245 46 238 29 255 200 206 118 0 0 0 0 0 0 1 16 243 132 245 46 238 29 255 200 206 118 0 0 0 0 0 0 0 8 239 125 0 0 0 0 0 0 1 8 239 125 0 0 0 0 0 0 0 16 127 161 236 25 121 208 120 214 1 0 0 0 0 0 0 0 1 16 127 161 236 25 121 208 120 214 1 0 0 0 0 0 0 0 0 16 228 98 93 251 246 45 27 244 12 210 234 8 62 105 184 6 1 16 228 98 93 251 246 45 27 244 12 210 234 8 62 105 184 6 0 16 113 250 216 245 216 14 84 151 148 66 63 170 143 150 213 62 1 16 113 250 216 245 216 14 84 151 148 66 63 170 143 150 213 62 0 8 7 0 0 0 0 0 0 0 1 8 7 0 0 0 0 0 0 0 0 8 97 0 0 0 0 0 0 0 1 8 97 0 0 0 0 0 0 0 0 16 82 196 148 115 94 248 196 4 103 173 17 224 1 0 0 0 1 16 82 196 148 115 94 248 196 4 103 173 17 224 1 0 0 0 0 16 185 187 181 2 210 30 161 158 53 90 42 42 63 15 50 26 1 16 185 187 181 2 210 30 161 158 53 90 42 42 63 15 50 26 0 16 92 251 45 61 79 154 189 99 62 231 106 244 104 0 0 0 1 16 92 251 45 61 79 154 189 99 62 231 106 244 104 0 0 0 0 8 200 11 39 38 1 71 0 0 1 8 200 11 39 38 1 71 0 0 0 16 78 168 146 148 101 102 80 36 225 226 239 154 140 83 0 0 1 16 78 168 146 148 101 102 80 36 225 226 239 154 140 83 0 0 0 16 245 138 45 63 143 110 236 183 77 53 123 0 0 0 0 0 1 16 245 138 45 63 143 110 236 183 77 53 123 0 0 0 0 0 0 8 243 27 0 0 0 0 0 0 1 8 243 27 0 0 0 0 0 0 0 8 2 242 30 180 34 49 0 0 1 8 2 242 30 180 34 49 0 0 0 8 153 218 239 31 13 11 23 0 1 8 153 218 239 31 13 11 23 0 0 16 114 73 75 167 80 26 136 206 243 161 150 47 210 18 0 0 1 16 114 73 75 167 80 26 136 206 243 161 150 47 210 18 0 0 0 8 152 52 243 192 4 0 0 0 1 8 152 52 243 192 4 0 0 0 0 8 129 0 0 0 0 0 0 0 1 8 129 0 0 0 0 0 0 0 0 16 18 75 75 202 113 21 113 107 89 238 2 38 55 0 0 0 1 16 18 75 75 202 113 21 113 107 89 238 2 38 55 0 0 0 0 16 248 15 6 162 79 31 165 111 116 213 2 0 0 0 0 0 1 16 248 15 6 162 79 31 165 111 116 213 2 0 0 0 0 0 0 8 131 38 69 53 220 0 194 1 1 8 131 38 69 53 220 0 194 1 0 16 74 116 239 154 166 169 107 46 39 173 51 0 1 0 0 0 1 16 74 116 239 154 166 169 107 46 39 173 51 0 1 0 0 0 0 16 216 204 156 85 182 172 130 76 251 193 13 135 156 80 17 0 1 16 216 204 156 85 182 172 130 76 251 193 13 135 156 80 17 0 0 8 230 159 4 0 0 0 0 0 1 8 230 159 4 0 0 0 0 0 0 8 240 94 116 1 0 0 0 0 1 8 240 94 116 1 0 0 0 0 0 16 186 26 109 17 247 224 109 236 131 235 91 201 8 59 206 53 1 16 186 26 109 17 247 224 109 236 131 235 91 201 8 59 206 53 0 8 213 56 129 36 10 0 0 0 1 8 213 56 129 36 10 0 0 0 0 8 150 105 0 0 0 0 0 0 1 8 150 105 0 0 0 0 0 0 0 8 24 96 0 0 0 0 0 0 1 8 24 96 0 0 0 0 0 0 0 8 125 198 15 213 57 0 0 0 1 8 125 198 15 213 57 0 0 0 0 8 72 171 5 0 0 0 0 0 1 8 72 171 5 0 0 0 0 0 0 16 125 217 106 251 35 137 192 207 157 60 119 110 60 0 0 0 1 16 125 217 106 251 35 137 192 207 157 60 119 110 60 0 0 0 0 16 40 33 166 229 75 32 114 134 8 182 91 119 101 246 0 0 1 16 40 33 166 229 75 32 114 134 8 182 91 119 101 246 0 0 0 8 50 6 0 0 0 0 0 0 1 8 50 6 0 0 0 0 0 0 0 16 46 7 188 46 21 139 235 139 174 6 0 0 0 0 0 0 1 16 46 7 188 46 21 139 235 139 174 6 0 0 0 0 0 0 0 16 122 184 52 227 177 59 175 38 160 93 2 0 0 0 0 0 1 16 122 184 52 227 177 59 175 38 160 93 2 0 0 0 0 0 0 16 51 236 9 239 42 71 1 118 244 0 0 0 0 0 0 0 1 16 51 236 9 239 42 71 1 118 244 0 0 0 0 0 0 0 0 8 9 0 0 0 0 0 0 0 1 8 9 0 0 0 0 0 0 0 0 8 112 253 24 0 0 0 0 0 1 8 112 253 24 0 0 0 0 0 0 16 170 155 98 70 194 229 34 226 165 82 10 0 0 0 0 0 1 16 170 155 98 70 194 229 34 226 165 82 10 0 0 0 0 0 0 16 141 162 219 102 243 250 189 2 52 69 45 8 37 48 0 0 1 16 141 162 219 102 243 250 189 2 52 69 45 8 37 48 0 0 0 16 114 76 220 134 106 96 50 45 46 0 0 0 0 0 0 0 1 16 114 76 220 134 106 96 50 45 46 0 0 0 0 0 0 0 0 16 83 216 166 163 69 55 198 40 4 192 0 0 0 0 0 0 1 16 83 216 166 163 69 55 198 40 4 192 0 0 0 0 0 0 0 8 33 162 20 8 117 90 28 1 1 8 33 162 20 8 117 90 28 1 0 8 196 49 182 125 208 15 0 0 1 8 196 49 182 125 208 15 0 0 0 8 133 3 165 3 0 0 0 0 1 8 133 3 165 3 0 0 0 0 0 16 35 198 36 50 11 227 67 35 5 0 0 0 0 0 0 0 1 16 35 198 36 50 11 227 67 35 5 0 0 0 0 0 0 0 0 8 217 58 6 0 0 0 0 0 1 8 217 58 6 0 0 0 0 0 0 8 27 199 198 6 169 98 3 0 1 8 27 199 198 6 169 98 3 0 0 8 208 172 62 88 120 203 5 0 1 8 208 172 62 88 120 203 5 0 0 8 90 8 0 0 0 0 0 0 1 8 90 8 0 0 0 0 0 0 0 16 72 150 61 92 250 232 245 163 67 167 172 175 2 0 0 0 1 16 72 150 61 92 250 232 245 163 67 167 172 175 2 0 0 0 0 8 109 255 102 254 0 0 0 0 1 8 109 255 102 254 0 0 0 0 0 8 36 0 0 0 0 0 0 0 1 8 36 0 0 0 0 0 0 0 0 8 235 105 3 0 0 0 0 0 1 8 235 105 3 0 0 0 0 0 0 8 157 43 115 210 3 0 0 0 1 8 157 43 115 210 3 0 0 0 0 8 227 128 137 1 0 0 0 0 1 8 227 128 137 1 0 0 0 0 0 16 21 49 26 107 236 12 129 206 3 0 0 0 0 0 0 0 1 16 21 49 26 107 236 12 129 206 3 0 0 0 0 0 0 0 0 8 129 32 189 16 1 0 0 0 1 8 129 32 189 16 1 0 0 0 0 16 146 130 114 247 111 207 165 146 3 137 7 108 202 3 0 0 1 16 146 130 114 247 111 207 165 146 3 137 7 108 202 3 0 0 0 8 39 239 53 138 178 87 103 0 1 8 39 239 53 138 178 87 103 0 0 16 93 101 243 102 175 163 130 167 97 174 190 36 53 183 138 34 1 16 93 101 243 102 175 163 130 167 97 174 190 36 53 183 138 34 0 8 248 0 0 0 0 0 0 0 1 8 248 0 0 0 0 0 0 0 0 16 62 103 144 183 253 247 47 175 131 2 146 108 70 0 0 0 1 16 62 103 144 183 253 247 47 175 131 2 146 108 70 0 0 0 0 16 242 249 139 183 120 173 114 251 225 239 132 139 200 207 5 0 1 16 242 249 139 183 120 173 114 251 225 239 132 139 200 207 5 0 0 8 155 82 241 50 32 1 0 0 1 8 155 82 241 50 32 1 0 0 0 16 60 134 203 255 253 239 75 71 228 52 78 20 210 216 164 3 1 16 60 134 203 255 253 239 75 71 228 52 78 20 210 216 164 3 0 8 240 0 0 0 0 0 0 0 1 8 240 0 0 0 0 0 0 0 0 8 74 91 152 79 191 112 95 219 1 8 74 91 152 79 191 112 95 219 0 8 225 143 234 246 0 0 0 0 1 8 225 143 234 246 0 0 0 0 0 8 59 117 218 172 152 176 204 177 1 8 59 117 218 172 152 176 204 177 0 16 24 92 218 89 248 53 68 137 80 0 0 0 0 0 0 0 1 16 24 92 218 89 248 53 68 137 80 0 0 0 0 0 0 0 0 8 135 175 3 193 49 7 0 0 1 8 135 175 3 193 49 7 0 0 0 16 84 36 200 56 126 134 172 99 144 135 104 167 75 161 1 0 1 16 84 36 200 56 126 134 172 99 144 135 104 167 75 161 1 0 0 16 32 97 136 27 224 36 111 146 219 92 164 16 135 119 12 0 1 16 32 97 136 27 224 36 111 146 219 92 164 16 135 119 12 0 0 8 150 186 205 101 122 21 0 0 1 8 150 186 205 101 122 21 0 0 0 8 61 0 74 249 72 64 1 0 1 8 61 0 74 249 72 64 1 0 0 8 5 0 0 0 0 0 0 0 1 8 5 0 0 0 0 0 0 0 0 8 85 231 0 0 0 0 0 0 1 8 85 231 0 0 0 0 0 0 0 8 7 53 39 0 0 0 0 0 1 8 7 53 39 0 0 0 0 0 0 16 184 113 56 241 136 99 250 169 41 38 17 218 6 0 0 0 1 16 184 113 56 241 136 99 250 169 41 38 17 218 6 0 0 0 0 16 76 17 162 144 32 230 52 94 118 23 68 114 229 89 0 0 1 16 76 17 162 144 32 230 52 94 118 23 68 114 229 89 0 0 0 8 89 183 34 241 180 158 11 0 1 8 89 183 34 241 180 158 11 0 0 8 71 186 244 17 0 0 0 0 1 8 71 186 244 17 0 0 0 0 0 8 63 193 206 147 0 0 0 0 1 8 63 193 206 147 0 0 0 0 0 8 65 67 174 89 21 0 0 0 1 8 65 67 174 89 21 0 0 0 0 8 24 124 240 73 208 51 10 0 1 8 24 124 240 73 208 51 10 0 0 8 127 149 228 141 130 187 206 212 1 8 127 149 228 141 130 187 206 212 0 8 150 21 0 0 0 0 0 0 1 8 150 21 0 0 0 0 0 0 0 8 36 148 234 13 0 0 0 0 1 8 36 148 234 13 0 0 0 0 0 8 22 10 2 0 0 0 0 0 1 8 22 10 2 0 0 0 0 0 0 8 112 48 196 1 161 60 78 227 1 8 112 48 196 1 161 60 78 227 0 16 141 191 62 222 54 255 93 191 23 154 244 121 104 127 150 0 1 16 141 191 62 222 54 255 93 191 23 154 244 121 104 127 150 0 0 16 1 239 62 155 92 171 183 88 243 250 73 64 154 209 61 6 1 16 1 239 62 155 92 171 183 88 243 250 73 64 154 209 61 6 0 16 226 241 36 137 89 204 106 60 252 68 23 9 46 14 188 7 1 16 226 241 36 137 89 204 106 60 252 68 23 9 46 14 188 7 0 16 168 243 51 12 205 84 127 124 104 103 17 0 0 0 0 0 1 16 168 243 51 12 205 84 127 124 104 103 17 0 0 0 0 0 0 16 199 246 222 200 216 155 75 134 115 5 0 0 0 0 0 0 1 16 199 246 222 200 216 155 75 134 115 5 0 0 0 0 0 0 0 16 205 246 227 212 19 202 146 146 12 32 222 104 0 0 0 0 1 16 205 246 227 212 19 202 146 146 12 32 222 104 0 0 0 0 0 8 231 2 0 0 0 0 0 0 1 8 231 2 0 0 0 0 0 0 0 8 112 223 182 198 202 220 170 0 1 8 112 223 182 198 202 220 170 0 0 8 0 212 75 197 0 0 0 0 1 8 0 212 75 197 0 0 0 0 0 16 138 108 72 105 190 154 118 34 30 0 0 0 0 0 0 0 1 16 138 108 72 105 190 154 118 34 30 0 0 0 0 0 0 0 0 8 48 85 228 16 168 11 0 0 1 8 48 85 228 16 168 11 0 0 0 8 62 1 0 0 0 0 0 0 1 8 62 1 0 0 0 0 0 0 0 16 6 102 249 196 237 58 2 184 77 192 3 21 141 0 0 0 1 16 6 102 249 196 237 58 2 184 77 192 3 21 141 0 0 0 0 8 8 78 34 173 18 4 0 0 1 8 8 78 34 173 18 4 0 0 0 8 7 0 0 0 0 0 0 0 1 8 7 0 0 0 0 0 0 0 0 8 239 135 16 50 170 2 57 0 1 8 239 135 16 50 170 2 57 0 0 8 183 0 0 0 0 0 0 0 1 8 183 0 0 0 0 0 0 0 0 16 177 22 53 249 155 145 101 251 26 74 122 154 45 100 11 0 1 16 177 22 53 249 155 145 101 251 26 74 122 154 45 100 11 0 0 8 80 56 225 0 0 0 0 0 1 8 80 56 225 0 0 0 0 0 0 16 76 235 10 21 204 158 27 14 68 131 188 49 79 0 0 0 1 16 76 235 10 21 204 158 27 14 68 131 188 49 79 0 0 0 0 16 251 170 198 48 126 70 130 132 60 154 11 0 0 0 0 0 1 16 251 170 198 48 126 70 130 132 60 154 11 0 0 0 0 0 0 8 191 30 191 254 3 0 0 0 1 8 191 30 191 254 3 0 0 0 0 16 54 216 58 148 106 237 238 143 196 75 61 50 0 0 0 0 1 16 54 216 58 148 106 237 238 143 196 75 61 50 0 0 0 0 0 8 179 134 5 0 0 0 0 0 1 8 179 134 5 0 0 0 0 0 0 16 241 40 126 116 35 208 214 118 64 224 2 0 0 0 0 0 1 16 241 40 126 116 35 208 214 118 64 224 2 0 0 0 0 0 0 8 192 249 163 87 76 23 44 169 1 8 192 249 163 87 76 23 44 169 0 8 20 54 151 190 175 212 60 7 1 8 20 54 151 190 175 212 60 7 0 8 216 96 161 160 23 138 1 0 1 8 216 96 161 160 23 138 1 0 0 16 229 209 203 219 86 233 187 99 117 0 0 0 0 0 0 0 1 16 229 209 203 219 86 233 187 99 117 0 0 0 0 0 0 0 0 16 245 229 198 81 226 138 11 41 33 213 8 22 0 0 0 0 1 16 245 229 198 81 226 138 11 41 33 213 8 22 0 0 0 0 0 8 123 178 141 23 108 0 0 0 1 8 123 178 141 23 108 0 0 0 0 8 209 241 222 253 33 0 0 0 1 8 209 241 222 253 33 0 0 0 0 16 220 85 110 10 15 95 4 6 252 132 103 77 0 0 0 0 1 16 220 85 110 10 15 95 4 6 252 132 103 77 0 0 0 0 0 16 189 132 98 150 159 168 163 157 176 8 1 0 0 0 0 0 1 16 189 132 98 150 159 168 163 157 176 8 1 0 0 0 0 0 0 8 226 130 140 1 0 0 0 0 1 8 226 130 140 1 0 0 0 0 0 16 143 231 15 168 10 112 155 62 246 19 188 101 111 0 0 0 1 16 143 231 15 168 10 112 155 62 246 19 188 101 111 0 0 0 0 16 90 83 73 223 21 149 198 225 16 118 121 1 0 0 0 0 1 16 90 83 73 223 21 149 198 225 16 118 121 1 0 0 0 0 0 8 250 107 147 104 78 3 0 0 1 8 250 107 147 104 78 3 0 0 0 8 112 132 221 2 0 0 0 0 1 8 112 132 221 2 0 0 0 0 0 8 233 38 129 60 112 9 2 0 1 8 233 38 129 60 112 9 2 0 0 8 31 200 44 22 247 29 0 0 1 8 31 200 44 22 247 29 0 0 0 8 64 140 226 178 63 3 0 0 1 8 64 140 226 178 63 3 0 0 0 16 102 203 87 33 78 209 7 212 252 71 0 0 0 0 0 0 1 16 102 203 87 33 78 209 7 212 252 71 0 0 0 0 0 0 0 16 124 235 50 2 230 251 163 236 12 65 16 16 124 0 0 0 1 16 124 235 50 2 230 251 163 236 12 65 16 16 124 0 0 0 0 16 150 159 188 85 64 141 109 45 11 90 81 64 1 0 0 0 1 16 150 159 188 85 64 141 109 45 11 90 81 64 1 0 0 0 0 16 167 59 70 31 206 169 7 64 31 128 72 0 0 0 0 0 1 16 167 59 70 31 206 169 7 64 31 128 72 0 0 0 0 0 0 8 44 3 0 0 0 0 0 0 1 8 44 3 0 0 0 0 0 0 0 8 245 254 182 131 34 27 3 0 1 8 245 254 182 131 34 27 3 0 0 16 127 105 58 125 131 87 50 215 211 128 179 128 247 65 82 0 1 16 127 105 58 125 131 87 50 215 211 128 179 128 247 65 82 0 0 8 201 118 45 227 189 189 136 2 1 8 201 118 45 227 189 189 136 2 0 16 73 205 21 184 2 160 55 216 156 146 207 246 12 0 0 0 1 16 73 205 21 184 2 160 55 216 156 146 207 246 12 0 0 0 0 8 88 131 129 83 59 1 0 0 1 8 88 131 129 83 59 1 0 0 0 8 118 58 124 202 93 158 94 84 1 8 118 58 124 202 93 158 94 84 0 16 114 144 11 78 137 113 34 58 211 201 128 28 24 49 27 0 1 16 114 144 11 78 137 113 34 58 211 201 128 28 24 49 27 0 0 8 227 62 145 88 15 34 21 0 1 8 227 62 145 88 15 34 21 0 0 8 144 79 175 34 58 184 155 52 1 8 144 79 175 34 58 184 155 52 0 8 169 92 48 156 119 52 152 6 1 8 169 92 48 156 119 52 152 6 0 16 64 241 66 116 157 84 90 13 43 150 240 179 1 0 0 0 1 16 64 241 66 116 157 84 90 13 43 150 240 179 1 0 0 0 0 8 249 36 108 106 67 0 0 0 1 8 249 36 108 106 67 0 0 0 0 8 24 219 0 0 0 0 0 0 1 8 24 219 0 0 0 0 0 0 0 16 132 220 144 75 157 31 158 221 3 0 0 0 0 0 0 0 1 16 132 220 144 75 157 31 158 221 3 0 0 0 0 0 0 0 0 8 22 51 150 54 80 88 15 0 1 8 22 51 150 54 80 88 15 0 0 16 254 143 211 239 187 165 87 122 3 0 0 0 0 0 0 0 1 16 254 143 211 239 187 165 87 122 3 0 0 0 0 0 0 0 0 16 90 132 24 254 5 211 89 38 55 116 158 144 100 66 0 0 1 16 90 132 24 254 5 211 89 38 55 116 158 144 100 66 0 0 0 16 119 186 36 149 246 36 59 35 232 254 155 141 203 2 0 0 1 16 119 186 36 149 246 36 59 35 232 254 155 141 203 2 0 0 0 8 203 46 49 133 154 163 0 0 1 8 203 46 49 133 154 163 0 0 0 16 173 84 223 120 95 131 253 29 244 109 99 100 18 0 0 0 1 16 173 84 223 120 95 131 253 29 244 109 99 100 18 0 0 0 0 16 163 90 76 225 185 170 229 28 217 73 104 176 75 142 57 0 1 16 163 90 76 225 185 170 229 28 217 73 104 176 75 142 57 0 0 16 253 112 155 58 247 162 195 140 168 20 3 0 0 0 0 0 1 16 253 112 155 58 247 162 195 140 168 20 3 0 0 0 0 0 0 16 249 122 124 0 146 109 174 30 4 0 0 0 0 0 0 0 1 16 249 122 124 0 146 109 174 30 4 0 0 0 0 0 0 0 0 8 144 2 45 119 93 56 2 0 1 8 144 2 45 119 93 56 2 0 0 8 45 33 10 0 0 0 0 0 1 8 45 33 10 0 0 0 0 0 0 16 186 27 85 177 145 135 52 106 165 148 53 70 246 1 0 0 1 16 186 27 85 177 145 135 52 106 165 148 53 70 246 1 0 0 0 8 68 52 17 4 0 0 0 0 1 8 68 52 17 4 0 0 0 0 0 16 241 159 13 20 11 64 214 104 47 0 0 0 0 0 0 0 1 16 241 159 13 20 11 64 214 104 47 0 0 0 0 0 0 0 0 16 32 95 224 178 8 58 144 200 201 145 83 22 116 60 79 2 1 16 32 95 224 178 8 58 144 200 201 145 83 22 116 60 79 2 0 8 215 108 179 124 111 116 0 0 1 8 215 108 179 124 111 116 0 0 0 16 72 135 153 119 46 195 147 13 252 2 59 0 117 125 64 77 1 16 72 135 153 119 46 195 147 13 252 2 59 0 117 125 64 77 0 16 93 46 81 15 142 242 250 221 79 61 178 228 143 87 244 0 1 16 93 46 81 15 142 242 250 221 79 61 178 228 143 87 244 0 0 8 139 93 95 57 0 0 0 0 1 8 139 93 95 57 0 0 0 0 0 16 76 36 152 198 40 178 106 21 207 164 31 24 28 10 1 0 1 16 76 36 152 198 40 178 106 21 207 164 31 24 28 10 1 0 0 8 19 0 0 0 0 0 0 0 1 8 19 0 0 0 0 0 0 0 0 16 9 25 202 138 170 88 179 0 75 0 0 0 0 0 0 0 1 16 9 25 202 138 170 88 179 0 75 0 0 0 0 0 0 0 0 8 169 231 136 224 45 30 2 0 1 8 169 231 136 224 45 30 2 0 0 16 54 251 180 193 77 7 254 217 190 81 0 0 0 0 0 0 1 16 54 251 180 193 77 7 254 217 190 81 0 0 0 0 0 0 0 16 167 75 62 7 42 70 13 12 21 5 163 135 11 0 0 0 1 16 167 75 62 7 42 70 13 12 21 5 163 135 11 0 0 0 0 16 138 166 227 194 104 244 199 0 232 12 0 0 0 0 0 0 1 16 138 166 227 194 104 244 199 0 232 12 0 0 0 0 0 0 0 8 203 27 84 77 12 139 18 28 1 8 203 27 84 77 12 139 18 28 0 8 159 124 135 1 0 0 0 0 1 8 159 124 135 1 0 0 0 0 0 16 211 117 92 112 68 205 243 46 127 0 0 0 0 0 0 0 1 16 211 117 92 112 68 205 243 46 127 0 0 0 0 0 0 0 0 8 173 148 132 161 87 0 0 0 1 8 173 148 132 161 87 0 0 0 0 8 9 0 0 0 0 0 0 0 1 8 9 0 0 0 0 0 0 0 0 8 133 26 216 191 172 89 213 40 1 8 133 26 216 191 172 89 213 40 0 16 211 26 153 111 42 16 37 94 105 14 57 163 225 193 0 0 1 16 211 26 153 111 42 16 37 94 105 14 57 163 225 193 0 0 0 8 128 164 207 191 0 0 0 0 1 8 128 164 207 191 0 0 0 0 0 8 133 171 31 6 0 0 0 0 1 8 133 171 31 6 0 0 0 0 0 16 58 142 105 140 176 184 239 208 55 131 225 185 144 11 0 0 1 16 58 142 105 140 176 184 239 208 55 131 225 185 144 11 0 0 0 16 69 153 92 71 249 203 122 156 39 73 222 95 210 32 1 0 1 16 69 153 92 71 249 203 122 156 39 73 222 95 210 32 1 0 0 8 230 66 104 5 0 0 0 0 1 8 230 66 104 5 0 0 0 0 0 8 161 45 37 11 195 19 140 0 1 8 161 45 37 11 195 19 140 0 0 8 234 74 122 82 0 0 0 0 1 8 234 74 122 82 0 0 0 0 0 8 177 246 13 0 0 0 0 0 1 8 177 246 13 0 0 0 0 0 0 8 49 224 136 0 0 0 0 0 1 8 49 224 136 0 0 0 0 0 0 8 125 71 166 1 1 0 0 0 1 8 125 71 166 1 1 0 0 0 0 8 141 121 130 15 0 0 0 0 1 8 141 121 130 15 0 0 0 0 0 16 86 207 74 133 184 161 240 207 34 130 144 107 83 0 0 0 1 16 86 207 74 133 184 161 240 207 34 130 144 107 83 0 0 0 0 8 35 48 213 98 222 69 132 0 1 8 35 48 213 98 222 69 132 0 0 8 182 209 82 82 113 25 178 59 1 8 182 209 82 82 113 25 178 59 0 8 180 86 59 54 31 2 0 0 1 8 180 86 59 54 31 2 0 0 0 8 45 45 0 0 0 0 0 0 1 8 45 45 0 0 0 0 0 0 0 16 21 185 217 174 9 133 26 231 15 65 115 190 75 64 49 0 1 16 21 185 217 174 9 133 26 231 15 65 115 190 75 64 49 0 0 16 165 110 209 80 73 74 135 193 159 99 14 0 0 0 0 0 1 16 165 110 209 80 73 74 135 193 159 99 14 0 0 0 0 0 0 8 212 39 10 198 84 40 188 1 1 8 212 39 10 198 84 40 188 1 0 16 229 117 144 57 201 122 60 120 207 235 3 0 0 0 0 0 1 16 229 117 144 57 201 122 60 120 207 235 3 0 0 0 0 0 0 8 219 123 115 0 0 0 0 0 1 8 219 123 115 0 0 0 0 0 0 16 191 142 53 119 168 100 219 47 160 3 0 0 0 0 0 0 1 16 191 142 53 119 168 100 219 47 160 3 0 0 0 0 0 0 0 16 227 12 18 159 53 213 206 140 179 189 209 125 126 174 21 0 1 16 227 12 18 159 53 213 206 140 179 189 209 125 126 174 21 0 0 16 108 182 247 254 150 50 85 5 140 125 196 22 0 0 0 0 1 16 108 182 247 254 150 50 85 5 140 125 196 22 0 0 0 0 0 16 92 126 28 210 248 52 158 233 246 129 152 227 129 228 4 25 1 16 92 126 28 210 248 52 158 233 246 129 152 227 129 228 4 25 0 8 211 136 158 83 43 95 0 0 1 8 211 136 158 83 43 95 0 0 0 8 83 253 195 70 35 14 7 1 1 8 83 253 195 70 35 14 7 1 0 16 105 111 185 175 206 124 63 83 199 79 41 0 0 0 0 0 1 16 105 111 185 175 206 124 63 83 199 79 41 0 0 0 0 0 0 8 6 50 0 0 0 0 0 0 1 8 6 50 0 0 0 0 0 0 0 16 183 89 151 17 18 108 172 173 36 98 141 13 0 0 0 0 1 16 183 89 151 17 18 108 172 173 36 98 141 13 0 0 0 0 0 8 218 149 242 52 5 0 0 0 1 8 218 149 242 52 5 0 0 0 0 8 84 210 0 0 0 0 0 0 1 8 84 210 0 0 0 0 0 0 0 8 227 16 100 125 154 10 22 0 1 8 227 16 100 125 154 10 22 0 0 8 99 11 2 0 0 0 0 0 1 8 99 11 2 0 0 0 0 0 0 16 59 200 146 111 178 201 210 58 7 10 0 0 0 0 0 0 1 16 59 200 146 111 178 201 210 58 7 10 0 0 0 0 0 0 0 8 245 98 135 241 52 234 83 2 1 8 245 98 135 241 52 234 83 2 0 8 111 24 151 152 13 0 0 0 1 8 111 24 151 152 13 0 0 0 0 8 214 0 0 0 0 0 0 0 1 8 214 0 0 0 0 0 0 0 0 16 107 171 142 230 68 214 222 6 143 20 0 0 0 0 0 0 1 16 107 171 142 230 68 214 222 6 143 20 0 0 0 0 0 0 0 16 31 138 93 248 13 219 151 196 232 112 179 55 114 0 0 0 1 16 31 138 93 248 13 219 151 196 232 112 179 55 114 0 0 0 0 16 126 160 35 63 198 30 3 106 28 63 3 6 0 0 0 0 1 16 126 160 35 63 198 30 3 106 28 63 3 6 0 0 0 0 0 8 104 8 59 0 0 0 0 0 1 8 104 8 59 0 0 0 0 0 0 8 211 64 154 42 0 0 0 0 1 8 211 64 154 42 0 0 0 0 0 16 190 175 183 140 51 33 188 44 220 15 129 79 197 5 0 0 1 16 190 175 183 140 51 33 188 44 220 15 129 79 197 5 0 0 0 8 58 149 0 0 0 0 0 0 1 8 58 149 0 0 0 0 0 0 0 8 168 78 159 61 141 1 0 0 1 8 168 78 159 61 141 1 0 0 0 8 50 34 114 75 132 0 0 0 1 8 50 34 114 75 132 0 0 0 0 16 228 96 210 155 189 131 157 123 187 84 8 0 0 0 0 0 1 16 228 96 210 155 189 131 157 123 187 84 8 0 0 0 0 0 0 8 105 43 140 252 152 3 0 0 1 8 105 43 140 252 152 3 0 0 0 8 93 153 83 251 251 19 6 0 1 8 93 153 83 251 251 19 6 0 0 8 59 202 65 95 133 34 100 0 1 8 59 202 65 95 133 34 100 0 0 16 175 130 225 146 216 107 99 14 39 177 93 74 28 0 0 0 1 16 175 130 225 146 216 107 99 14 39 177 93 74 28 0 0 0 0 16 60 102 67 81 214 180 246 82 1 0 0 0 0 0 0 0 1 16 60 102 67 81 214 180 246 82 1 0 0 0 0 0 0 0 0 8 29 156 0 0 0 0 0 0 1 8 29 156 0 0 0 0 0 0 0 8 144 22 0 0 0 0 0 0 1 8 144 22 0 0 0 0 0 0 0 16 126 85 237 254 119 29 6 190 202 60 208 130 101 7 221 121 1 16 126 85 237 254 119 29 6 190 202 60 208 130 101 7 221 121 0 8 109 138 127 241 6 0 0 0 1 8 109 138 127 241 6 0 0 0 0 8 104 29 47 0 0 0 0 0 1 8 104 29 47 0 0 0 0 0 0 16 105 197 115 163 120 218 156 57 157 204 105 245 2 0 0 0 1 16 105 197 115 163 120 218 156 57 157 204 105 245 2 0 0 0 0 16 43 62 73 147 228 196 140 60 148 83 16 164 4 0 0 0 1 16 43 62 73 147 228 196 140 60 148 83 16 164 4 0 0 0 0 8 31 0 0 0 0 0 0 0 1 8 31 0 0 0 0 0 0 0 0 8 241 157 192 68 3 0 0 0 1 8 241 157 192 68 3 0 0 0 0 16 108 147 5 178 33 167 30 134 205 25 105 66 48 22 245 0 1 16 108 147 5 178 33 167 30 134 205 25 105 66 48 22 245 0 0 8 129 42 147 65 1 0 0 0 1 8 129 42 147 65 1 0 0 0 0 16 246 130 162 45 151 113 85 86 26 158 229 111 0 0 0 0 1 16 246 130 162 45 151 113 85 86 26 158 229 111 0 0 0 0 0 8 169 64 0 0 0 0 0 0 1 8 169 64 0 0 0 0 0 0 0 8 239 189 219 253 42 82 213 153 1 8 239 189 219 253 42 82 213 153 0 8 3 41 244 12 23 4 0 0 1 8 3 41 244 12 23 4 0 0 0 16 45 29 75 228 251 90 142 140 229 6 0 0 0 0 0 0 1 16 45 29 75 228 251 90 142 140 229 6 0 0 0 0 0 0 0 8 46 253 114 12 61 0 0 0 1 8 46 253 114 12 61 0 0 0 0 8 182 105 196 214 0 0 0 0 1 8 182 105 196 214 0 0 0 0 0 16 85 197 138 192 105 13 137 11 199 237 60 146 247 3 63 24 1 16 85 197 138 192 105 13 137 11 199 237 60 146 247 3 63 24 0 8 62 83 233 195 226 186 158 9 1 8 62 83 233 195 226 186 158 9 0 8 255 213 102 22 0 0 0 0 1 8 255 213 102 22 0 0 0 0


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int64_serial32.txt
================================================
22 serialization::archive 10 0 0 0 0 0 8 154 227 28 82 91 187 17 0 1 8 154 227 28 82 91 187 17 0 0 4 238 2 0 0 1 4 238 2 0 0 0 8 179 21 191 74 120 31 195 5 1 8 179 21 191 74 120 31 195 5 0 8 38 72 203 241 222 183 7 0 1 8 38 72 203 241 222 183 7 0 0 4 225 3 0 0 1 4 225 3 0 0 0 8 242 170 246 107 183 113 31 11 1 8 242 170 246 107 183 113 31 11 0 8 159 2 53 187 36 166 22 4 1 8 159 2 53 187 36 166 22 4 0 4 26 205 0 0 1 4 26 205 0 0 0 8 177 10 45 114 95 1 0 0 1 8 177 10 45 114 95 1 0 0 0 4 231 42 31 0 1 4 231 42 31 0 0 4 228 0 0 0 1 4 228 0 0 0 0 8 161 235 183 0 9 0 0 0 1 8 161 235 183 0 9 0 0 0 0 4 161 84 9 0 1 4 161 84 9 0 0 4 17 21 0 0 1 4 17 21 0 0 0 8 132 60 177 2 3 0 0 0 1 8 132 60 177 2 3 0 0 0 0 8 112 146 42 85 255 28 14 50 1 8 112 146 42 85 255 28 14 50 0 8 56 155 123 75 170 217 61 52 1 8 56 155 123 75 170 217 61 52 0 8 128 184 17 143 213 41 148 184 1 8 128 184 17 143 213 41 148 184 0 8 211 92 36 214 185 177 216 48 1 8 211 92 36 214 185 177 216 48 0 8 103 144 142 223 219 161 68 11 1 8 103 144 142 223 219 161 68 11 0 4 136 9 0 0 1 4 136 9 0 0 0 8 110 109 102 36 76 159 0 0 1 8 110 109 102 36 76 159 0 0 0 8 212 44 7 134 98 246 52 74 1 8 212 44 7 134 98 246 52 74 0 8 5 18 148 245 212 213 152 2 1 8 5 18 148 245 212 213 152 2 0 8 215 29 169 9 145 141 144 10 1 8 215 29 169 9 145 141 144 10 0 4 205 0 0 0 1 4 205 0 0 0 0 8 242 218 75 187 1 0 0 0 1 8 242 218 75 187 1 0 0 0 0 8 196 242 164 7 110 253 8 0 1 8 196 242 164 7 110 253 8 0 0 8 87 7 181 132 51 102 13 0 1 8 87 7 181 132 51 102 13 0 0 4 18 228 18 0 1 4 18 228 18 0 0 4 190 5 0 0 1 4 190 5 0 0 0 4 7 0 0 0 1 4 7 0 0 0 0 4 89 137 26 12 1 4 89 137 26 12 0 4 130 0 0 0 1 4 130 0 0 0 0 8 128 249 218 245 47 115 9 1 1 8 128 249 218 245 47 115 9 1 0 8 162 100 122 44 193 2 0 0 1 8 162 100 122 44 193 2 0 0 0 8 101 75 177 242 99 85 12 0 1 8 101 75 177 242 99 85 12 0 0 8 240 219 82 212 216 69 123 0 1 8 240 219 82 212 216 69 123 0 0 8 0 241 147 64 173 200 15 13 1 8 0 241 147 64 173 200 15 13 0 8 123 176 87 114 3 0 0 0 1 8 123 176 87 114 3 0 0 0 0 8 199 125 85 138 128 0 0 0 1 8 199 125 85 138 128 0 0 0 0 8 212 151 16 161 84 117 1 0 1 8 212 151 16 161 84 117 1 0 0 4 6 0 0 0 1 4 6 0 0 0 0 4 3 195 58 0 1 4 3 195 58 0 0 8 97 114 34 212 170 208 45 0 1 8 97 114 34 212 170 208 45 0 0 4 146 232 0 0 1 4 146 232 0 0 0 8 133 179 117 190 9 133 28 13 1 8 133 179 117 190 9 133 28 13 0 8 73 171 130 38 191 22 0 0 1 8 73 171 130 38 191 22 0 0 0 8 18 152 190 20 249 26 0 0 1 8 18 152 190 20 249 26 0 0 0 4 252 198 62 5 1 4 252 198 62 5 0 8 73 97 191 10 234 239 1 0 1 8 73 97 191 10 234 239 1 0 0 8 153 44 205 37 255 196 0 0 1 8 153 44 205 37 255 196 0 0 0 8 81 132 37 54 246 238 0 0 1 8 81 132 37 54 246 238 0 0 0 4 8 53 135 13 1 4 8 53 135 13 0 4 89 148 169 6 1 4 89 148 169 6 0 4 17 159 173 20 1 4 17 159 173 20 0 8 201 182 183 82 169 6 0 0 1 8 201 182 183 82 169 6 0 0 0 4 182 0 0 0 1 4 182 0 0 0 0 4 108 16 0 0 1 4 108 16 0 0 0 4 39 236 0 0 1 4 39 236 0 0 0 8 181 1 156 121 15 32 0 0 1 8 181 1 156 121 15 32 0 0 0 8 29 56 214 10 51 145 14 0 1 8 29 56 214 10 51 145 14 0 0 4 6 0 0 0 1 4 6 0 0 0 0 4 161 199 49 0 1 4 161 199 49 0 0 4 248 149 1 0 1 4 248 149 1 0 0 8 180 167 79 137 212 132 35 1 1 8 180 167 79 137 212 132 35 1 0 4 8 0 0 0 1 4 8 0 0 0 0 4 195 6 0 0 1 4 195 6 0 0 0 4 82 1 0 0 1 4 82 1 0 0 0 8 33 248 118 22 198 96 57 183 1 8 33 248 118 22 198 96 57 183 0 8 94 181 212 144 197 233 13 0 1 8 94 181 212 144 197 233 13 0 0 8 102 74 34 111 163 102 6 0 1 8 102 74 34 111 163 102 6 0 0 8 26 210 173 182 38 49 0 0 1 8 26 210 173 182 38 49 0 0 0 4 86 0 0 0 1 4 86 0 0 0 0 4 143 140 20 0 1 4 143 140 20 0 0 8 73 116 37 159 96 31 0 0 1 8 73 116 37 159 96 31 0 0 0 8 8 37 96 156 51 81 22 12 1 8 8 37 96 156 51 81 22 12 0 4 237 236 131 159 1 4 237 236 131 159 0 4 10 0 0 0 1 4 10 0 0 0 0 8 130 141 0 7 2 2 0 0 1 8 130 141 0 7 2 2 0 0 0 4 109 195 74 15 1 4 109 195 74 15 0 4 230 2 0 0 1 4 230 2 0 0 0 4 106 192 15 1 1 4 106 192 15 1 0 4 10 163 0 0 1 4 10 163 0 0 0 8 203 163 89 123 164 84 3 0 1 8 203 163 89 123 164 84 3 0 0 4 10 0 0 0 1 4 10 0 0 0 0 8 215 165 31 197 2 167 7 0 1 8 215 165 31 197 2 167 7 0 0 4 21 0 0 0 1 4 21 0 0 0 0 4 39 38 0 0 1 4 39 38 0 0 0 4 57 137 152 9 1 4 57 137 152 9 0 8 5 3 11 74 1 0 0 0 1 8 5 3 11 74 1 0 0 0 0 4 160 216 17 103 1 4 160 216 17 103 0 4 29 8 124 52 1 4 29 8 124 52 0 8 154 188 176 41 1 0 0 0 1 8 154 188 176 41 1 0 0 0 0 8 76 178 160 131 39 5 0 0 1 8 76 178 160 131 39 5 0 0 0 8 184 146 71 183 150 91 6 0 1 8 184 146 71 183 150 91 6 0 0 8 171 6 120 246 94 47 0 0 1 8 171 6 120 246 94 47 0 0 0 8 146 132 93 2 22 222 211 5 1 8 146 132 93 2 22 222 211 5 0 8 204 2 222 46 179 175 0 0 1 8 204 2 222 46 179 175 0 0 0 8 9 148 45 199 56 52 13 0 1 8 9 148 45 199 56 52 13 0 0 4 241 190 12 0 1 4 241 190 12 0 0 8 88 52 207 19 120 43 0 0 1 8 88 52 207 19 120 43 0 0 0 8 132 70 133 92 64 29 0 0 1 8 132 70 133 92 64 29 0 0 0 4 1 0 0 0 1 4 1 0 0 0 0 8 153 12 223 211 34 6 0 0 1 8 153 12 223 211 34 6 0 0 0 8 140 14 165 245 82 66 0 0 1 8 140 14 165 245 82 66 0 0 0 4 221 15 0 0 1 4 221 15 0 0 0 8 50 119 85 166 157 1 0 0 1 8 50 119 85 166 157 1 0 0 0 4 30 3 0 0 1 4 30 3 0 0 0 4 13 245 224 15 1 4 13 245 224 15 0 8 202 238 193 147 1 0 0 0 1 8 202 238 193 147 1 0 0 0 0 8 91 182 236 7 230 82 3 0 1 8 91 182 236 7 230 82 3 0 0 8 63 175 86 139 154 53 6 37 1 8 63 175 86 139 154 53 6 37 0 8 201 71 17 19 25 0 0 0 1 8 201 71 17 19 25 0 0 0 0 4 14 211 37 0 1 4 14 211 37 0 0 8 202 176 13 183 153 3 12 1 1 8 202 176 13 183 153 3 12 1 0 8 34 164 43 13 117 0 0 0 1 8 34 164 43 13 117 0 0 0 0 8 55 100 235 195 135 199 4 0 1 8 55 100 235 195 135 199 4 0 0 4 77 59 0 0 1 4 77 59 0 0 0 4 6 0 0 0 1 4 6 0 0 0 0 8 91 176 44 141 237 201 1 0 1 8 91 176 44 141 237 201 1 0 0 8 91 247 129 23 149 242 13 0 1 8 91 247 129 23 149 242 13 0 0 4 159 244 3 0 1 4 159 244 3 0 0 8 39 216 128 123 225 164 26 0 1 8 39 216 128 123 225 164 26 0 0 8 206 236 127 202 3 0 0 0 1 8 206 236 127 202 3 0 0 0 0 8 227 22 89 80 97 163 24 23 1 8 227 22 89 80 97 163 24 23 0 8 6 163 204 40 124 57 0 0 1 8 6 163 204 40 124 57 0 0 0 4 72 96 82 7 1 4 72 96 82 7 0 8 205 145 127 61 215 220 134 3 1 8 205 145 127 61 215 220 134 3 0 4 187 177 86 19 1 4 187 177 86 19 0 8 195 158 155 140 132 204 144 36 1 8 195 158 155 140 132 204 144 36 0 8 141 29 202 70 15 0 0 0 1 8 141 29 202 70 15 0 0 0 0 8 80 57 26 165 1 0 0 0 1 8 80 57 26 165 1 0 0 0 0 4 232 14 0 0 1 4 232 14 0 0 0 4 172 7 0 0 1 4 172 7 0 0 0 8 229 247 251 162 193 189 0 0 1 8 229 247 251 162 193 189 0 0 0 4 70 15 0 0 1 4 70 15 0 0 0 4 104 115 1 0 1 4 104 115 1 0 0 4 73 175 2 0 1 4 73 175 2 0 0 8 139 107 110 161 47 228 20 0 1 8 139 107 110 161 47 228 20 0 0 8 52 16 150 150 195 76 61 0 1 8 52 16 150 150 195 76 61 0 0 8 3 233 1 255 93 196 239 229 1 8 3 233 1 255 93 196 239 229 0 4 210 243 2 0 1 4 210 243 2 0 0 4 136 103 92 0 1 4 136 103 92 0 0 8 146 79 153 7 104 181 15 0 1 8 146 79 153 7 104 181 15 0 0 4 63 136 0 0 1 4 63 136 0 0 0 4 42 206 0 0 1 4 42 206 0 0 0 4 0 0 0 0 0 4 0 0 0 0 0 8 10 253 104 129 179 201 249 12 1 8 10 253 104 129 179 201 249 12 0 4 173 0 0 0 1 4 173 0 0 0 0 4 126 150 157 0 1 4 126 150 157 0 0 8 95 103 181 13 108 192 162 0 1 8 95 103 181 13 108 192 162 0 0 4 8 34 0 0 1 4 8 34 0 0 0 8 195 39 2 201 240 221 6 0 1 8 195 39 2 201 240 221 6 0 0 4 164 73 1 0 1 4 164 73 1 0 0 8 24 150 136 250 66 244 117 28 1 8 24 150 136 250 66 244 117 28 0 8 188 211 235 56 103 1 0 0 1 8 188 211 235 56 103 1 0 0 0 8 147 116 238 204 203 134 5 0 1 8 147 116 238 204 203 134 5 0 0 4 212 155 224 212 1 4 212 155 224 212 0 8 162 39 186 255 226 48 217 253 1 8 162 39 186 255 226 48 217 253 0 4 96 45 87 0 1 4 96 45 87 0 0 4 43 0 0 0 1 4 43 0 0 0 0 8 21 190 140 128 8 199 26 0 1 8 21 190 140 128 8 199 26 0 0 8 223 96 39 236 140 66 12 0 1 8 223 96 39 236 140 66 12 0 0 8 168 80 9 35 78 0 0 0 1 8 168 80 9 35 78 0 0 0 0 8 88 244 56 44 112 0 0 0 1 8 88 244 56 44 112 0 0 0 0 8 57 42 143 22 20 0 0 0 1 8 57 42 143 22 20 0 0 0 0 8 203 139 139 233 47 120 0 0 1 8 203 139 139 233 47 120 0 0 0 8 151 136 78 80 220 201 21 3 1 8 151 136 78 80 220 201 21 3 0 8 41 214 136 67 14 14 0 0 1 8 41 214 136 67 14 14 0 0 0 4 68 146 0 0 1 4 68 146 0 0 0 8 4 125 187 175 144 13 0 0 1 8 4 125 187 175 144 13 0 0 0 8 107 43 241 204 40 37 1 0 1 8 107 43 241 204 40 37 1 0 0 4 100 212 145 7 1 4 100 212 145 7 0 8 181 219 82 238 3 185 1 0 1 8 181 219 82 238 3 185 1 0 0 8 83 219 52 188 1 0 0 0 1 8 83 219 52 188 1 0 0 0 0 4 245 60 150 2 1 4 245 60 150 2 0 4 182 3 0 0 1 4 182 3 0 0 0 8 35 242 99 17 31 0 0 0 1 8 35 242 99 17 31 0 0 0 0 8 210 109 74 20 3 0 0 0 1 8 210 109 74 20 3 0 0 0 0 4 113 0 0 0 1 4 113 0 0 0 0 4 215 146 221 1 1 4 215 146 221 1 0 4 33 0 0 0 1 4 33 0 0 0 0 4 241 68 169 0 1 4 241 68 169 0 0 8 109 184 204 61 3 0 0 0 1 8 109 184 204 61 3 0 0 0 0 8 181 132 45 203 59 0 0 0 1 8 181 132 45 203 59 0 0 0 0 8 193 232 39 3 20 5 2 0 1 8 193 232 39 3 20 5 2 0 0 4 41 222 5 0 1 4 41 222 5 0 0 8 240 84 253 169 3 245 134 14 1 8 240 84 253 169 3 245 134 14 0 8 53 101 132 186 140 107 194 48 1 8 53 101 132 186 140 107 194 48 0 4 231 3 0 0 1 4 231 3 0 0 0 4 185 12 0 0 1 4 185 12 0 0 0 8 3 35 9 8 33 0 0 0 1 8 3 35 9 8 33 0 0 0 0 4 156 36 211 5 1 4 156 36 211 5 0 4 92 228 169 22 1 4 92 228 169 22 0 4 127 62 177 0 1 4 127 62 177 0 0 4 2 0 0 0 1 4 2 0 0 0 0 8 164 101 187 91 120 0 0 0 1 8 164 101 187 91 120 0 0 0 0 4 33 58 42 0 1 4 33 58 42 0 0 4 65 43 119 4 1 4 65 43 119 4 0 4 171 27 0 0 1 4 171 27 0 0 0 8 151 115 89 236 58 107 231 6 1 8 151 115 89 236 58 107 231 6 0 8 53 244 97 77 30 194 11 0 1 8 53 244 97 77 30 194 11 0 0 4 227 66 108 47 1 4 227 66 108 47 0 4 67 137 26 0 1 4 67 137 26 0 0 8 70 250 222 204 115 159 137 0 1 8 70 250 222 204 115 159 137 0 0 8 164 93 158 196 7 0 0 0 1 8 164 93 158 196 7 0 0 0 0 8 113 106 97 177 105 0 0 0 1 8 113 106 97 177 105 0 0 0 0 4 38 28 0 0 1 4 38 28 0 0 0 4 144 3 0 0 1 4 144 3 0 0 0 8 55 211 179 66 249 0 0 0 1 8 55 211 179 66 249 0 0 0 0 4 70 208 8 215 1 4 70 208 8 215 0 4 17 174 7 0 1 4 17 174 7 0 0 4 145 40 82 0 1 4 145 40 82 0 0 8 185 14 149 132 50 7 0 0 1 8 185 14 149 132 50 7 0 0 0 4 84 17 37 245 1 4 84 17 37 245 0 8 218 94 35 43 115 7 0 0 1 8 218 94 35 43 115 7 0 0 0 8 170 8 238 147 136 37 0 0 1 8 170 8 238 147 136 37 0 0 0 8 169 153 246 116 99 150 1 0 1 8 169 153 246 116 99 150 1 0 0 8 110 23 17 63 97 104 44 241 1 8 110 23 17 63 97 104 44 241 0 4 219 131 208 47 1 4 219 131 208 47 0 8 100 16 250 222 223 5 0 0 1 8 100 16 250 222 223 5 0 0 0 4 189 0 0 0 1 4 189 0 0 0 0 8 22 198 182 249 164 1 85 6 1 8 22 198 182 249 164 1 85 6 0 4 173 137 0 0 1 4 173 137 0 0 0 4 111 190 230 246 1 4 111 190 230 246 0 8 51 99 110 105 78 69 86 3 1 8 51 99 110 105 78 69 86 3 0 8 104 165 202 140 7 0 0 0 1 8 104 165 202 140 7 0 0 0 0 4 136 13 0 0 1 4 136 13 0 0 0 8 5 138 36 135 3 0 0 0 1 8 5 138 36 135 3 0 0 0 0 8 39 105 124 108 77 96 30 0 1 8 39 105 124 108 77 96 30 0 0 4 78 159 129 13 1 4 78 159 129 13 0 8 223 6 27 79 8 0 0 0 1 8 223 6 27 79 8 0 0 0 0 8 203 6 61 205 13 0 0 0 1 8 203 6 61 205 13 0 0 0 0 8 111 62 45 160 194 14 103 96 1 8 111 62 45 160 194 14 103 96 0 4 82 143 196 30 1 4 82 143 196 30 0 4 54 0 0 0 1 4 54 0 0 0 0 8 37 180 24 111 34 94 97 0 1 8 37 180 24 111 34 94 97 0 0 4 94 61 200 42 1 4 94 61 200 42 0 8 229 205 68 230 125 0 0 0 1 8 229 205 68 230 125 0 0 0 0 4 125 1 0 0 1 4 125 1 0 0 0 4 70 69 227 171 1 4 70 69 227 171 0 8 121 93 176 157 92 133 17 34 1 8 121 93 176 157 92 133 17 34 0 8 211 207 179 76 229 87 229 73 1 8 211 207 179 76 229 87 229 73 0 4 0 0 0 0 0 4 0 0 0 0 0 4 3 0 0 0 1 4 3 0 0 0 0 8 101 90 156 136 105 177 2 0 1 8 101 90 156 136 105 177 2 0 0 8 163 122 187 139 155 245 97 88 1 8 163 122 187 139 155 245 97 88 0 8 31 100 188 227 193 143 8 0 1 8 31 100 188 227 193 143 8 0 0 4 85 153 46 1 1 4 85 153 46 1 0 8 221 254 215 194 253 123 70 0 1 8 221 254 215 194 253 123 70 0 0 8 215 60 213 115 201 17 0 0 1 8 215 60 213 115 201 17 0 0 0 4 245 0 0 0 1 4 245 0 0 0 0 4 182 69 1 0 1 4 182 69 1 0 0 4 16 115 202 1 1 4 16 115 202 1 0 8 229 38 172 10 236 158 36 0 1 8 229 38 172 10 236 158 36 0 0 4 152 18 4 0 1 4 152 18 4 0 0 4 29 0 0 0 1 4 29 0 0 0 0 8 164 28 2 236 150 2 6 0 1 8 164 28 2 236 150 2 6 0 0 8 199 130 156 17 201 5 0 0 1 8 199 130 156 17 201 5 0 0 0 4 13 53 72 26 1 4 13 53 72 26 0 8 238 224 211 162 10 18 0 0 1 8 238 224 211 162 10 18 0 0 0 8 120 226 140 214 213 131 23 1 1 8 120 226 140 214 213 131 23 1 0 4 127 6 0 0 1 4 127 6 0 0 0 4 191 27 0 0 1 4 191 27 0 0 0 8 27 167 239 216 56 139 31 36 1 8 27 167 239 216 56 139 31 36 0 4 82 31 0 0 1 4 82 31 0 0 0 4 244 0 0 0 1 4 244 0 0 0 0 4 116 7 0 0 1 4 116 7 0 0 0 4 130 5 6 0 1 4 130 5 6 0 0 4 47 2 0 0 1 4 47 2 0 0 0 8 196 55 144 21 143 144 9 0 1 8 196 55 144 21 143 144 9 0 0 8 234 45 67 110 61 33 47 0 1 8 234 45 67 110 61 33 47 0 0 4 124 0 0 0 1 4 124 0 0 0 0 8 105 213 125 231 51 0 0 0 1 8 105 213 125 231 51 0 0 0 0 8 11 175 154 185 42 1 0 0 1 8 11 175 154 185 42 1 0 0 0 8 101 255 202 218 14 0 0 0 1 8 101 255 202 218 14 0 0 0 0 4 0 0 0 0 0 4 0 0 0 0 0 4 37 7 0 0 1 4 37 7 0 0 0 8 47 33 204 49 169 12 0 0 1 8 47 33 204 49 169 12 0 0 0 8 237 178 210 116 191 60 18 0 1 8 237 178 210 116 191 60 18 0 0 8 226 16 6 156 2 0 0 0 1 8 226 16 6 156 2 0 0 0 0 8 21 186 33 53 89 1 0 0 1 8 21 186 33 53 89 1 0 0 0 4 43 243 242 11 1 4 43 243 242 11 0 4 253 48 225 0 1 4 253 48 225 0 0 4 98 116 0 0 1 4 98 116 0 0 0 4 180 159 4 1 1 4 180 159 4 1 0 4 187 2 0 0 1 4 187 2 0 0 0 4 36 0 3 2 1 4 36 0 3 2 0 4 160 47 250 0 1 4 160 47 250 0 0 4 98 0 0 0 1 4 98 0 0 0 0 8 174 190 217 68 144 74 0 0 1 8 174 190 217 68 144 74 0 0 0 4 23 145 1 0 1 4 23 145 1 0 0 4 13 0 0 0 1 4 13 0 0 0 0 4 44 1 0 0 1 4 44 1 0 0 0 4 245 250 2 0 1 4 245 250 2 0 0 4 65 32 0 0 1 4 65 32 0 0 0 8 205 117 182 80 2 0 0 0 1 8 205 117 182 80 2 0 0 0 0 4 186 246 0 0 1 4 186 246 0 0 0 8 234 122 75 99 110 255 9 0 1 8 234 122 75 99 110 255 9 0 0 4 222 223 37 8 1 4 222 223 37 8 0 8 230 26 192 136 251 74 228 31 1 8 230 26 192 136 251 74 228 31 0 4 14 0 0 0 1 4 14 0 0 0 0 8 128 177 66 193 232 29 55 0 1 8 128 177 66 193 232 29 55 0 0 8 253 35 145 164 119 248 140 2 1 8 253 35 145 164 119 248 140 2 0 4 174 117 27 0 1 4 174 117 27 0 0 8 8 228 105 75 109 68 255 25 1 8 8 228 105 75 109 68 255 25 0 4 31 0 0 0 1 4 31 0 0 0 0 8 101 158 131 43 1 0 0 0 1 8 101 158 131 43 1 0 0 0 0 4 8 103 0 0 1 4 8 103 0 0 0 4 181 252 244 53 1 4 181 252 244 53 0 8 39 186 76 130 8 0 0 0 1 8 39 186 76 130 8 0 0 0 0 4 231 168 14 0 1 4 231 168 14 0 0 8 111 30 175 61 55 124 64 1 1 8 111 30 175 61 55 124 64 1 0 8 74 60 189 200 26 84 16 2 1 8 74 60 189 200 26 84 16 2 0 4 103 99 236 0 1 4 103 99 236 0 0 4 248 30 237 0 1 4 248 30 237 0 0 4 15 0 0 0 1 4 15 0 0 0 0 4 39 0 0 0 1 4 39 0 0 0 0 4 221 30 0 0 1 4 221 30 0 0 0 8 83 158 61 244 15 140 7 0 1 8 83 158 61 244 15 140 7 0 0 8 21 183 50 199 183 253 159 0 1 8 21 183 50 199 183 253 159 0 0 4 176 107 53 5 1 4 176 107 53 5 0 4 53 53 0 0 1 4 53 53 0 0 0 4 162 140 0 0 1 4 162 140 0 0 0 4 126 253 1 0 1 4 126 253 1 0 0 4 233 141 234 3 1 4 233 141 234 3 0 8 178 136 48 203 1 0 0 0 1 8 178 136 48 203 1 0 0 0 0 4 171 0 0 0 1 4 171 0 0 0 0 4 35 241 0 0 1 4 35 241 0 0 0 4 107 5 0 0 1 4 107 5 0 0 0 8 15 48 198 223 1 0 0 0 1 8 15 48 198 223 1 0 0 0 0 8 203 94 65 224 14 96 19 27 1 8 203 94 65 224 14 96 19 27 0 8 187 120 141 217 244 218 89 38 1 8 187 120 141 217 244 218 89 38 0 8 185 95 188 66 117 96 49 6 1 8 185 95 188 66 117 96 49 6 0 8 181 238 174 109 232 4 0 0 1 8 181 238 174 109 232 4 0 0 0 8 241 227 21 206 37 0 0 0 1 8 241 227 21 206 37 0 0 0 0 8 11 46 148 129 54 81 1 0 1 8 11 46 148 129 54 81 1 0 0 4 1 0 0 0 1 4 1 0 0 0 0 4 166 181 139 21 1 4 166 181 139 21 0 4 231 3 0 0 1 4 231 3 0 0 0 8 58 0 224 93 1 0 0 0 1 8 58 0 224 93 1 0 0 0 0 4 61 170 163 0 1 4 61 170 163 0 0 4 16 0 0 0 1 4 16 0 0 0 0 8 19 80 184 100 0 136 17 0 1 8 19 80 184 100 0 136 17 0 0 4 141 166 59 0 1 4 141 166 59 0 0 4 1 0 0 0 1 4 1 0 0 0 0 4 106 120 1 0 1 4 106 120 1 0 0 4 24 0 0 0 1 4 24 0 0 0 0 8 250 206 237 235 100 45 220 2 1 8 250 206 237 235 100 45 220 2 0 4 104 0 0 0 1 4 104 0 0 0 0 8 45 124 107 88 59 188 20 0 1 8 45 124 107 88 59 188 20 0 0 8 133 86 244 174 225 3 0 0 1 8 133 86 244 174 225 3 0 0 0 4 10 106 7 0 1 4 10 106 7 0 0 8 198 151 96 192 44 105 0 0 1 8 198 151 96 192 44 105 0 0 0 4 18 6 0 0 1 4 18 6 0 0 0 8 139 29 156 22 238 7 0 0 1 8 139 29 156 22 238 7 0 0 0 4 223 115 28 171 1 4 223 115 28 171 0 4 221 148 185 62 1 4 221 148 185 62 0 4 61 47 108 1 1 4 61 47 108 1 0 8 87 157 178 141 10 0 0 0 1 8 87 157 178 141 10 0 0 0 0 8 86 94 188 134 23 82 0 0 1 8 86 94 188 134 23 82 0 0 0 4 179 64 23 0 1 4 179 64 23 0 0 4 113 45 10 0 1 4 113 45 10 0 0 8 204 227 150 219 42 98 0 0 1 8 204 227 150 219 42 98 0 0 0 8 72 207 3 4 107 1 0 0 1 8 72 207 3 4 107 1 0 0 0 4 242 22 0 0 1 4 242 22 0 0 0 8 43 248 193 8 8 37 19 0 1 8 43 248 193 8 8 37 19 0 0 8 135 156 114 210 151 8 0 0 1 8 135 156 114 210 151 8 0 0 0 4 126 63 25 0 1 4 126 63 25 0 0 4 94 41 0 0 1 4 94 41 0 0 0 4 132 46 67 3 1 4 132 46 67 3 0 4 12 53 213 1 1 4 12 53 213 1 0 4 224 181 149 0 1 4 224 181 149 0 0 8 214 73 249 129 122 0 0 0 1 8 214 73 249 129 122 0 0 0 0 8 141 160 27 51 90 159 14 0 1 8 141 160 27 51 90 159 14 0 0 8 123 185 72 150 135 30 2 0 1 8 123 185 72 150 135 30 2 0 0 8 132 79 251 109 16 13 0 0 1 8 132 79 251 109 16 13 0 0 0 4 187 0 0 0 1 4 187 0 0 0 0 4 26 47 114 1 1 4 26 47 114 1 0 8 36 142 132 192 11 54 198 0 1 8 36 142 132 192 11 54 198 0 0 4 167 191 148 125 1 4 167 191 148 125 0 8 234 206 244 113 18 198 0 0 1 8 234 206 244 113 18 198 0 0 0 4 3 143 18 0 1 4 3 143 18 0 0 4 62 157 58 195 1 4 62 157 58 195 0 8 172 170 222 106 83 163 194 4 1 8 172 170 222 106 83 163 194 4 0 4 88 220 20 57 1 4 88 220 20 57 0 8 167 245 187 129 1 0 0 0 1 8 167 245 187 129 1 0 0 0 0 4 164 130 167 36 1 4 164 130 167 36 0 8 61 130 34 172 248 118 0 0 1 8 61 130 34 172 248 118 0 0 0 4 40 22 12 0 1 4 40 22 12 0 0 4 209 1 0 0 1 4 209 1 0 0 0 8 170 133 218 207 1 0 0 0 1 8 170 133 218 207 1 0 0 0 0 4 223 195 71 3 1 4 223 195 71 3 0 8 197 87 218 147 1 0 0 0 1 8 197 87 218 147 1 0 0 0 0 8 210 1 234 57 242 124 45 0 1 8 210 1 234 57 242 124 45 0 0 8 119 110 205 24 176 195 21 0 1 8 119 110 205 24 176 195 21 0 0 4 71 104 194 0 1 4 71 104 194 0 0 8 53 164 236 57 255 127 4 0 1 8 53 164 236 57 255 127 4 0 0 8 218 132 146 91 132 77 213 4 1 8 218 132 146 91 132 77 213 4 0 8 133 79 247 151 252 1 0 0 1 8 133 79 247 151 252 1 0 0 0 8 203 243 153 55 2 0 0 0 1 8 203 243 153 55 2 0 0 0 0 4 197 193 53 2 1 4 197 193 53 2 0 4 84 5 0 0 1 4 84 5 0 0 0 8 177 187 206 97 141 85 1 0 1 8 177 187 206 97 141 85 1 0 0 4 166 94 0 0 1 4 166 94 0 0 0 8 190 247 33 10 10 0 0 0 1 8 190 247 33 10 10 0 0 0 0 8 61 186 120 114 110 34 74 14 1 8 61 186 120 114 110 34 74 14 0 4 48 152 216 0 1 4 48 152 216 0 0 8 157 24 37 230 113 32 156 61 1 8 157 24 37 230 113 32 156 61 0 8 26 71 250 167 179 175 252 27 1 8 26 71 250 167 179 175 252 27 0 4 138 11 1 0 1 4 138 11 1 0 0 8 64 228 47 79 174 153 235 1 1 8 64 228 47 79 174 153 235 1 0 4 12 0 0 0 1 4 12 0 0 0 0 8 227 20 33 239 16 0 0 0 1 8 227 20 33 239 16 0 0 0 0 4 89 117 39 6 1 4 89 117 39 6 0 8 56 143 170 210 159 0 0 0 1 8 56 143 170 210 159 0 0 0 0 8 83 94 139 170 42 227 7 0 1 8 83 94 139 170 42 227 7 0 0 8 158 24 234 182 90 0 0 0 1 8 158 24 234 182 90 0 0 0 0 4 184 250 218 70 1 4 184 250 218 70 0 4 199 13 0 0 1 4 199 13 0 0 0 8 162 245 210 10 15 0 0 0 1 8 162 245 210 10 15 0 0 0 0 4 163 218 24 0 1 4 163 218 24 0 0 4 14 0 0 0 1 4 14 0 0 0 0 4 167 97 145 202 1 4 167 97 145 202 0 8 207 69 56 26 219 188 172 2 1 8 207 69 56 26 219 188 172 2 0 4 19 245 0 0 1 4 19 245 0 0 0 4 101 116 0 0 1 4 101 116 0 0 0 8 144 67 225 251 217 0 96 0 1 8 144 67 225 251 217 0 96 0 0 8 141 129 40 88 123 180 46 1 1 8 141 129 40 88 123 180 46 1 0 4 83 65 0 0 1 4 83 65 0 0 0 4 1 71 241 42 1 4 1 71 241 42 0 4 201 82 0 0 1 4 201 82 0 0 0 4 143 3 0 0 1 4 143 3 0 0 0 4 140 29 0 0 1 4 140 29 0 0 0 4 209 38 0 0 1 4 209 38 0 0 0 4 34 69 0 0 1 4 34 69 0 0 0 8 221 163 103 107 78 53 11 0 1 8 221 163 103 107 78 53 11 0 0 4 210 46 149 42 1 4 210 46 149 42 0 4 48 85 36 205 1 4 48 85 36 205 0 4 37 35 35 0 1 4 37 35 35 0 0 4 13 0 0 0 1 4 13 0 0 0 0 8 46 173 250 215 165 229 166 2 1 8 46 173 250 215 165 229 166 2 0 8 67 188 30 254 109 2 0 0 1 8 67 188 30 254 109 2 0 0 0 4 137 152 11 16 1 4 137 152 11 16 0 8 152 52 243 192 36 1 0 0 1 8 152 52 243 192 36 1 0 0 0 4 129 59 0 0 1 4 129 59 0 0 0 8 201 94 53 127 56 0 0 0 1 8 201 94 53 127 56 0 0 0 0 8 73 236 21 75 203 154 66 5 1 8 73 236 21 75 203 154 66 5 0 8 196 244 167 127 116 213 0 0 1 8 196 244 167 127 116 213 0 0 0 8 63 43 243 86 100 247 101 30 1 8 63 43 243 86 100 247 101 30 0 4 179 18 79 0 1 4 179 18 79 0 0 4 62 229 32 2 1 4 62 229 32 2 0 8 191 161 29 68 10 28 0 0 1 8 191 161 29 68 10 28 0 0 0 4 157 0 0 0 1 4 157 0 0 0 0 8 177 110 144 211 209 51 0 0 1 8 177 110 144 211 209 51 0 0 0 4 38 140 6 0 1 4 38 140 6 0 0 4 230 31 0 0 1 4 230 31 0 0 0 4 240 94 116 15 1 4 240 94 116 15 0 4 182 7 0 0 1 4 182 7 0 0 0 8 1 177 12 133 96 0 0 0 1 8 1 177 12 133 96 0 0 0 0 4 240 7 185 0 1 4 240 7 185 0 0 4 243 73 7 0 1 4 243 73 7 0 0 4 26 0 0 0 1 4 26 0 0 0 0 8 103 9 1 204 46 0 0 0 1 8 103 9 1 204 46 0 0 0 0 8 98 214 177 103 24 96 0 0 1 8 98 214 177 103 24 96 0 0 0 8 81 174 115 76 247 124 0 0 1 8 81 174 115 76 247 124 0 0 0 4 61 12 0 0 1 4 61 12 0 0 0 4 85 161 0 0 1 4 85 161 0 0 0 8 101 4 40 150 22 103 32 0 1 8 101 4 40 150 22 103 32 0 0 4 103 2 0 0 1 4 103 2 0 0 0 4 60 153 25 0 1 4 60 153 25 0 0 4 143 111 7 0 1 4 143 111 7 0 0 8 80 120 24 232 225 5 0 0 1 8 80 120 24 232 225 5 0 0 0 4 174 134 41 0 1 4 174 134 41 0 0 4 113 152 62 21 1 4 113 152 62 21 0 4 241 24 81 31 1 4 241 24 81 31 0 8 82 153 37 103 160 93 6 0 1 8 82 153 37 103 160 93 6 0 0 8 40 224 161 201 3 0 0 0 1 8 40 224 161 201 3 0 0 0 0 4 19 3 0 0 1 4 19 3 0 0 0 4 82 0 0 0 1 4 82 0 0 0 0 8 64 200 218 23 94 23 70 119 1 8 64 200 218 23 94 23 70 119 0 4 15 139 7 0 1 4 15 139 7 0 0 4 18 20 0 0 1 4 18 20 0 0 0 8 128 37 176 212 38 112 1 0 1 8 128 37 176 212 38 112 1 0 0 8 13 125 43 146 204 213 0 0 1 8 13 125 43 146 204 213 0 0 0 4 14 0 0 0 1 4 14 0 0 0 0 4 70 145 5 0 1 4 70 145 5 0 0 8 186 122 94 51 73 69 56 8 1 8 186 122 94 51 73 69 56 8 0 4 77 183 3 0 1 4 77 183 3 0 0 8 217 138 24 241 155 207 0 0 1 8 217 138 24 241 155 207 0 0 0 4 150 0 0 0 1 4 150 0 0 0 0 4 196 49 182 125 1 4 196 49 182 125 0 4 133 3 165 0 1 4 133 3 165 0 0 8 0 245 2 102 53 0 0 0 1 8 0 245 2 102 53 0 0 0 0 4 35 187 7 0 1 4 35 187 7 0 0 4 217 58 0 0 1 4 217 58 0 0 0 8 93 4 23 102 114 100 3 1 1 8 93 4 23 102 114 100 3 1 0 4 18 224 241 10 1 4 18 224 241 10 0 4 100 120 0 0 1 4 100 120 0 0


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/serial_txts/cpp_int64_serial64.txt
================================================
22 serialization::archive 10 0 0 0 0 0 8 154 227 28 82 91 187 17 0 1 8 154 227 28 82 91 187 17 0 0 8 238 2 0 0 0 0 0 0 1 8 238 2 0 0 0 0 0 0 0 8 179 21 191 74 120 31 195 5 1 8 179 21 191 74 120 31 195 5 0 8 38 72 203 241 222 183 7 0 1 8 38 72 203 241 222 183 7 0 0 8 225 3 0 0 0 0 0 0 1 8 225 3 0 0 0 0 0 0 0 8 242 170 246 107 183 113 31 11 1 8 242 170 246 107 183 113 31 11 0 8 159 2 53 187 36 166 22 4 1 8 159 2 53 187 36 166 22 4 0 8 26 205 0 0 0 0 0 0 1 8 26 205 0 0 0 0 0 0 0 8 177 10 45 114 95 1 0 0 1 8 177 10 45 114 95 1 0 0 0 8 231 42 31 0 0 0 0 0 1 8 231 42 31 0 0 0 0 0 0 8 228 0 0 0 0 0 0 0 1 8 228 0 0 0 0 0 0 0 0 8 161 235 183 0 9 0 0 0 1 8 161 235 183 0 9 0 0 0 0 8 161 84 9 0 0 0 0 0 1 8 161 84 9 0 0 0 0 0 0 8 17 21 0 0 0 0 0 0 1 8 17 21 0 0 0 0 0 0 0 8 132 60 177 2 3 0 0 0 1 8 132 60 177 2 3 0 0 0 0 8 112 146 42 85 255 28 14 50 1 8 112 146 42 85 255 28 14 50 0 8 56 155 123 75 170 217 61 52 1 8 56 155 123 75 170 217 61 52 0 8 128 184 17 143 213 41 148 184 1 8 128 184 17 143 213 41 148 184 0 8 211 92 36 214 185 177 216 48 1 8 211 92 36 214 185 177 216 48 0 8 103 144 142 223 219 161 68 11 1 8 103 144 142 223 219 161 68 11 0 8 136 9 0 0 0 0 0 0 1 8 136 9 0 0 0 0 0 0 0 8 110 109 102 36 76 159 0 0 1 8 110 109 102 36 76 159 0 0 0 8 212 44 7 134 98 246 52 74 1 8 212 44 7 134 98 246 52 74 0 8 5 18 148 245 212 213 152 2 1 8 5 18 148 245 212 213 152 2 0 8 215 29 169 9 145 141 144 10 1 8 215 29 169 9 145 141 144 10 0 8 205 0 0 0 0 0 0 0 1 8 205 0 0 0 0 0 0 0 0 8 242 218 75 187 1 0 0 0 1 8 242 218 75 187 1 0 0 0 0 8 196 242 164 7 110 253 8 0 1 8 196 242 164 7 110 253 8 0 0 8 87 7 181 132 51 102 13 0 1 8 87 7 181 132 51 102 13 0 0 8 18 228 18 0 0 0 0 0 1 8 18 228 18 0 0 0 0 0 0 8 190 5 0 0 0 0 0 0 1 8 190 5 0 0 0 0 0 0 0 8 7 0 0 0 0 0 0 0 1 8 7 0 0 0 0 0 0 0 0 8 89 137 26 12 0 0 0 0 1 8 89 137 26 12 0 0 0 0 0 8 130 0 0 0 0 0 0 0 1 8 130 0 0 0 0 0 0 0 0 8 128 249 218 245 47 115 9 1 1 8 128 249 218 245 47 115 9 1 0 8 162 100 122 44 193 2 0 0 1 8 162 100 122 44 193 2 0 0 0 8 101 75 177 242 99 85 12 0 1 8 101 75 177 242 99 85 12 0 0 8 240 219 82 212 216 69 123 0 1 8 240 219 82 212 216 69 123 0 0 8 0 241 147 64 173 200 15 13 1 8 0 241 147 64 173 200 15 13 0 8 123 176 87 114 3 0 0 0 1 8 123 176 87 114 3 0 0 0 0 8 199 125 85 138 128 0 0 0 1 8 199 125 85 138 128 0 0 0 0 8 212 151 16 161 84 117 1 0 1 8 212 151 16 161 84 117 1 0 0 8 6 0 0 0 0 0 0 0 1 8 6 0 0 0 0 0 0 0 0 8 3 195 58 0 0 0 0 0 1 8 3 195 58 0 0 0 0 0 0 8 97 114 34 212 170 208 45 0 1 8 97 114 34 212 170 208 45 0 0 8 146 232 0 0 0 0 0 0 1 8 146 232 0 0 0 0 0 0 0 8 133 179 117 190 9 133 28 13 1 8 133 179 117 190 9 133 28 13 0 8 73 171 130 38 191 22 0 0 1 8 73 171 130 38 191 22 0 0 0 8 18 152 190 20 249 26 0 0 1 8 18 152 190 20 249 26 0 0 0 8 252 198 62 5 0 0 0 0 1 8 252 198 62 5 0 0 0 0 0 8 73 97 191 10 234 239 1 0 1 8 73 97 191 10 234 239 1 0 0 8 153 44 205 37 255 196 0 0 1 8 153 44 205 37 255 196 0 0 0 8 81 132 37 54 246 238 0 0 1 8 81 132 37 54 246 238 0 0 0 8 8 53 135 13 0 0 0 0 1 8 8 53 135 13 0 0 0 0 0 8 89 148 169 6 0 0 0 0 1 8 89 148 169 6 0 0 0 0 0 8 17 159 173 20 0 0 0 0 1 8 17 159 173 20 0 0 0 0 0 8 201 182 183 82 169 6 0 0 1 8 201 182 183 82 169 6 0 0 0 8 182 0 0 0 0 0 0 0 1 8 182 0 0 0 0 0 0 0 0 8 108 16 0 0 0 0 0 0 1 8 108 16 0 0 0 0 0 0 0 8 39 236 0 0 0 0 0 0 1 8 39 236 0 0 0 0 0 0 0 8 181 1 156 121 15 32 0 0 1 8 181 1 156 121 15 32 0 0 0 8 29 56 214 10 51 145 14 0 1 8 29 56 214 10 51 145 14 0 0 8 6 0 0 0 0 0 0 0 1 8 6 0 0 0 0 0 0 0 0 8 161 199 49 0 0 0 0 0 1 8 161 199 49 0 0 0 0 0 0 8 248 149 1 0 0 0 0 0 1 8 248 149 1 0 0 0 0 0 0 8 180 167 79 137 212 132 35 1 1 8 180 167 79 137 212 132 35 1 0 8 8 0 0 0 0 0 0 0 1 8 8 0 0 0 0 0 0 0 0 8 195 6 0 0 0 0 0 0 1 8 195 6 0 0 0 0 0 0 0 8 82 1 0 0 0 0 0 0 1 8 82 1 0 0 0 0 0 0 0 8 33 248 118 22 198 96 57 183 1 8 33 248 118 22 198 96 57 183 0 8 94 181 212 144 197 233 13 0 1 8 94 181 212 144 197 233 13 0 0 8 102 74 34 111 163 102 6 0 1 8 102 74 34 111 163 102 6 0 0 8 26 210 173 182 38 49 0 0 1 8 26 210 173 182 38 49 0 0 0 8 86 0 0 0 0 0 0 0 1 8 86 0 0 0 0 0 0 0 0 8 143 140 20 0 0 0 0 0 1 8 143 140 20 0 0 0 0 0 0 8 73 116 37 159 96 31 0 0 1 8 73 116 37 159 96 31 0 0 0 8 8 37 96 156 51 81 22 12 1 8 8 37 96 156 51 81 22 12 0 8 237 236 131 159 0 0 0 0 1 8 237 236 131 159 0 0 0 0 0 8 10 0 0 0 0 0 0 0 1 8 10 0 0 0 0 0 0 0 0 8 130 141 0 7 2 2 0 0 1 8 130 141 0 7 2 2 0 0 0 8 109 195 74 15 0 0 0 0 1 8 109 195 74 15 0 0 0 0 0 8 230 2 0 0 0 0 0 0 1 8 230 2 0 0 0 0 0 0 0 8 106 192 15 1 0 0 0 0 1 8 106 192 15 1 0 0 0 0 0 8 10 163 0 0 0 0 0 0 1 8 10 163 0 0 0 0 0 0 0 8 203 163 89 123 164 84 3 0 1 8 203 163 89 123 164 84 3 0 0 8 10 0 0 0 0 0 0 0 1 8 10 0 0 0 0 0 0 0 0 8 215 165 31 197 2 167 7 0 1 8 215 165 31 197 2 167 7 0 0 8 21 0 0 0 0 0 0 0 1 8 21 0 0 0 0 0 0 0 0 8 39 38 0 0 0 0 0 0 1 8 39 38 0 0 0 0 0 0 0 8 57 137 152 9 0 0 0 0 1 8 57 137 152 9 0 0 0 0 0 8 5 3 11 74 1 0 0 0 1 8 5 3 11 74 1 0 0 0 0 8 160 216 17 103 0 0 0 0 1 8 160 216 17 103 0 0 0 0 0 8 29 8 124 52 0 0 0 0 1 8 29 8 124 52 0 0 0 0 0 8 154 188 176 41 1 0 0 0 1 8 154 188 176 41 1 0 0 0 0 8 76 178 160 131 39 5 0 0 1 8 76 178 160 131 39 5 0 0 0 8 184 146 71 183 150 91 6 0 1 8 184 146 71 183 150 91 6 0 0 8 171 6 120 246 94 47 0 0 1 8 171 6 120 246 94 47 0 0 0 8 146 132 93 2 22 222 211 5 1 8 146 132 93 2 22 222 211 5 0 8 204 2 222 46 179 175 0 0 1 8 204 2 222 46 179 175 0 0 0 8 9 148 45 199 56 52 13 0 1 8 9 148 45 199 56 52 13 0 0 8 241 190 12 0 0 0 0 0 1 8 241 190 12 0 0 0 0 0 0 8 88 52 207 19 120 43 0 0 1 8 88 52 207 19 120 43 0 0 0 8 132 70 133 92 64 29 0 0 1 8 132 70 133 92 64 29 0 0 0 8 1 0 0 0 0 0 0 0 1 8 1 0 0 0 0 0 0 0 0 8 153 12 223 211 34 6 0 0 1 8 153 12 223 211 34 6 0 0 0 8 140 14 165 245 82 66 0 0 1 8 140 14 165 245 82 66 0 0 0 8 221 15 0 0 0 0 0 0 1 8 221 15 0 0 0 0 0 0 0 8 50 119 85 166 157 1 0 0 1 8 50 119 85 166 157 1 0 0 0 8 30 3 0 0 0 0 0 0 1 8 30 3 0 0 0 0 0 0 0 8 13 245 224 15 0 0 0 0 1 8 13 245 224 15 0 0 0 0 0 8 202 238 193 147 1 0 0 0 1 8 202 238 193 147 1 0 0 0 0 8 91 182 236 7 230 82 3 0 1 8 91 182 236 7 230 82 3 0 0 8 63 175 86 139 154 53 6 37 1 8 63 175 86 139 154 53 6 37 0 8 201 71 17 19 25 0 0 0 1 8 201 71 17 19 25 0 0 0 0 8 14 211 37 0 0 0 0 0 1 8 14 211 37 0 0 0 0 0 0 8 202 176 13 183 153 3 12 1 1 8 202 176 13 183 153 3 12 1 0 8 34 164 43 13 117 0 0 0 1 8 34 164 43 13 117 0 0 0 0 8 55 100 235 195 135 199 4 0 1 8 55 100 235 195 135 199 4 0 0 8 77 59 0 0 0 0 0 0 1 8 77 59 0 0 0 0 0 0 0 8 6 0 0 0 0 0 0 0 1 8 6 0 0 0 0 0 0 0 0 8 91 176 44 141 237 201 1 0 1 8 91 176 44 141 237 201 1 0 0 8 91 247 129 23 149 242 13 0 1 8 91 247 129 23 149 242 13 0 0 8 159 244 3 0 0 0 0 0 1 8 159 244 3 0 0 0 0 0 0 8 39 216 128 123 225 164 26 0 1 8 39 216 128 123 225 164 26 0 0 8 206 236 127 202 3 0 0 0 1 8 206 236 127 202 3 0 0 0 0 8 227 22 89 80 97 163 24 23 1 8 227 22 89 80 97 163 24 23 0 8 6 163 204 40 124 57 0 0 1 8 6 163 204 40 124 57 0 0 0 8 72 96 82 7 0 0 0 0 1 8 72 96 82 7 0 0 0 0 0 8 205 145 127 61 215 220 134 3 1 8 205 145 127 61 215 220 134 3 0 8 187 177 86 19 0 0 0 0 1 8 187 177 86 19 0 0 0 0 0 8 195 158 155 140 132 204 144 36 1 8 195 158 155 140 132 204 144 36 0 8 141 29 202 70 15 0 0 0 1 8 141 29 202 70 15 0 0 0 0 8 80 57 26 165 1 0 0 0 1 8 80 57 26 165 1 0 0 0 0 8 232 14 0 0 0 0 0 0 1 8 232 14 0 0 0 0 0 0 0 8 172 7 0 0 0 0 0 0 1 8 172 7 0 0 0 0 0 0 0 8 229 247 251 162 193 189 0 0 1 8 229 247 251 162 193 189 0 0 0 8 70 15 0 0 0 0 0 0 1 8 70 15 0 0 0 0 0 0 0 8 104 115 1 0 0 0 0 0 1 8 104 115 1 0 0 0 0 0 0 8 73 175 2 0 0 0 0 0 1 8 73 175 2 0 0 0 0 0 0 8 139 107 110 161 47 228 20 0 1 8 139 107 110 161 47 228 20 0 0 8 52 16 150 150 195 76 61 0 1 8 52 16 150 150 195 76 61 0 0 8 3 233 1 255 93 196 239 229 1 8 3 233 1 255 93 196 239 229 0 8 210 243 2 0 0 0 0 0 1 8 210 243 2 0 0 0 0 0 0 8 136 103 92 0 0 0 0 0 1 8 136 103 92 0 0 0 0 0 0 8 146 79 153 7 104 181 15 0 1 8 146 79 153 7 104 181 15 0 0 8 63 136 0 0 0 0 0 0 1 8 63 136 0 0 0 0 0 0 0 8 42 206 0 0 0 0 0 0 1 8 42 206 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 8 10 253 104 129 179 201 249 12 1 8 10 253 104 129 179 201 249 12 0 8 173 0 0 0 0 0 0 0 1 8 173 0 0 0 0 0 0 0 0 8 126 150 157 0 0 0 0 0 1 8 126 150 157 0 0 0 0 0 0 8 95 103 181 13 108 192 162 0 1 8 95 103 181 13 108 192 162 0 0 8 8 34 0 0 0 0 0 0 1 8 8 34 0 0 0 0 0 0 0 8 195 39 2 201 240 221 6 0 1 8 195 39 2 201 240 221 6 0 0 8 164 73 1 0 0 0 0 0 1 8 164 73 1 0 0 0 0 0 0 8 24 150 136 250 66 244 117 28 1 8 24 150 136 250 66 244 117 28 0 8 188 211 235 56 103 1 0 0 1 8 188 211 235 56 103 1 0 0 0 8 147 116 238 204 203 134 5 0 1 8 147 116 238 204 203 134 5 0 0 8 212 155 224 212 0 0 0 0 1 8 212 155 224 212 0 0 0 0 0 8 162 39 186 255 226 48 217 253 1 8 162 39 186 255 226 48 217 253 0 8 96 45 87 0 0 0 0 0 1 8 96 45 87 0 0 0 0 0 0 8 43 0 0 0 0 0 0 0 1 8 43 0 0 0 0 0 0 0 0 8 21 190 140 128 8 199 26 0 1 8 21 190 140 128 8 199 26 0 0 8 223 96 39 236 140 66 12 0 1 8 223 96 39 236 140 66 12 0 0 8 168 80 9 35 78 0 0 0 1 8 168 80 9 35 78 0 0 0 0 8 88 244 56 44 112 0 0 0 1 8 88 244 56 44 112 0 0 0 0 8 57 42 143 22 20 0 0 0 1 8 57 42 143 22 20 0 0 0 0 8 203 139 139 233 47 120 0 0 1 8 203 139 139 233 47 120 0 0 0 8 151 136 78 80 220 201 21 3 1 8 151 136 78 80 220 201 21 3 0 8 41 214 136 67 14 14 0 0 1 8 41 214 136 67 14 14 0 0 0 8 68 146 0 0 0 0 0 0 1 8 68 146 0 0 0 0 0 0 0 8 4 125 187 175 144 13 0 0 1 8 4 125 187 175 144 13 0 0 0 8 107 43 241 204 40 37 1 0 1 8 107 43 241 204 40 37 1 0 0 8 100 212 145 7 0 0 0 0 1 8 100 212 145 7 0 0 0 0 0 8 181 219 82 238 3 185 1 0 1 8 181 219 82 238 3 185 1 0 0 8 83 219 52 188 1 0 0 0 1 8 83 219 52 188 1 0 0 0 0 8 245 60 150 2 0 0 0 0 1 8 245 60 150 2 0 0 0 0 0 8 182 3 0 0 0 0 0 0 1 8 182 3 0 0 0 0 0 0 0 8 35 242 99 17 31 0 0 0 1 8 35 242 99 17 31 0 0 0 0 8 210 109 74 20 3 0 0 0 1 8 210 109 74 20 3 0 0 0 0 8 113 0 0 0 0 0 0 0 1 8 113 0 0 0 0 0 0 0 0 8 215 146 221 1 0 0 0 0 1 8 215 146 221 1 0 0 0 0 0 8 33 0 0 0 0 0 0 0 1 8 33 0 0 0 0 0 0 0 0 8 241 68 169 0 0 0 0 0 1 8 241 68 169 0 0 0 0 0 0 8 109 184 204 61 3 0 0 0 1 8 109 184 204 61 3 0 0 0 0 8 181 132 45 203 59 0 0 0 1 8 181 132 45 203 59 0 0 0 0 8 193 232 39 3 20 5 2 0 1 8 193 232 39 3 20 5 2 0 0 8 41 222 5 0 0 0 0 0 1 8 41 222 5 0 0 0 0 0 0 8 240 84 253 169 3 245 134 14 1 8 240 84 253 169 3 245 134 14 0 8 53 101 132 186 140 107 194 48 1 8 53 101 132 186 140 107 194 48 0 8 231 3 0 0 0 0 0 0 1 8 231 3 0 0 0 0 0 0 0 8 185 12 0 0 0 0 0 0 1 8 185 12 0 0 0 0 0 0 0 8 3 35 9 8 33 0 0 0 1 8 3 35 9 8 33 0 0 0 0 8 156 36 211 5 0 0 0 0 1 8 156 36 211 5 0 0 0 0 0 8 92 228 169 22 0 0 0 0 1 8 92 228 169 22 0 0 0 0 0 8 127 62 177 0 0 0 0 0 1 8 127 62 177 0 0 0 0 0 0 8 2 0 0 0 0 0 0 0 1 8 2 0 0 0 0 0 0 0 0 8 164 101 187 91 120 0 0 0 1 8 164 101 187 91 120 0 0 0 0 8 33 58 42 0 0 0 0 0 1 8 33 58 42 0 0 0 0 0 0 8 65 43 119 4 0 0 0 0 1 8 65 43 119 4 0 0 0 0 0 8 171 27 0 0 0 0 0 0 1 8 171 27 0 0 0 0 0 0 0 8 151 115 89 236 58 107 231 6 1 8 151 115 89 236 58 107 231 6 0 8 53 244 97 77 30 194 11 0 1 8 53 244 97 77 30 194 11 0 0 8 227 66 108 47 0 0 0 0 1 8 227 66 108 47 0 0 0 0 0 8 67 137 26 0 0 0 0 0 1 8 67 137 26 0 0 0 0 0 0 8 70 250 222 204 115 159 137 0 1 8 70 250 222 204 115 159 137 0 0 8 164 93 158 196 7 0 0 0 1 8 164 93 158 196 7 0 0 0 0 8 113 106 97 177 105 0 0 0 1 8 113 106 97 177 105 0 0 0 0 8 38 28 0 0 0 0 0 0 1 8 38 28 0 0 0 0 0 0 0 8 144 3 0 0 0 0 0 0 1 8 144 3 0 0 0 0 0 0 0 8 55 211 179 66 249 0 0 0 1 8 55 211 179 66 249 0 0 0 0 8 70 208 8 215 0 0 0 0 1 8 70 208 8 215 0 0 0 0 0 8 17 174 7 0 0 0 0 0 1 8 17 174 7 0 0 0 0 0 0 8 145 40 82 0 0 0 0 0 1 8 145 40 82 0 0 0 0 0 0 8 185 14 149 132 50 7 0 0 1 8 185 14 149 132 50 7 0 0 0 8 84 17 37 245 0 0 0 0 1 8 84 17 37 245 0 0 0 0 0 8 218 94 35 43 115 7 0 0 1 8 218 94 35 43 115 7 0 0 0 8 170 8 238 147 136 37 0 0 1 8 170 8 238 147 136 37 0 0 0 8 169 153 246 116 99 150 1 0 1 8 169 153 246 116 99 150 1 0 0 8 110 23 17 63 97 104 44 241 1 8 110 23 17 63 97 104 44 241 0 8 219 131 208 47 0 0 0 0 1 8 219 131 208 47 0 0 0 0 0 8 100 16 250 222 223 5 0 0 1 8 100 16 250 222 223 5 0 0 0 8 189 0 0 0 0 0 0 0 1 8 189 0 0 0 0 0 0 0 0 8 22 198 182 249 164 1 85 6 1 8 22 198 182 249 164 1 85 6 0 8 173 137 0 0 0 0 0 0 1 8 173 137 0 0 0 0 0 0 0 8 111 190 230 246 0 0 0 0 1 8 111 190 230 246 0 0 0 0 0 8 51 99 110 105 78 69 86 3 1 8 51 99 110 105 78 69 86 3 0 8 104 165 202 140 7 0 0 0 1 8 104 165 202 140 7 0 0 0 0 8 136 13 0 0 0 0 0 0 1 8 136 13 0 0 0 0 0 0 0 8 5 138 36 135 3 0 0 0 1 8 5 138 36 135 3 0 0 0 0 8 39 105 124 108 77 96 30 0 1 8 39 105 124 108 77 96 30 0 0 8 78 159 129 13 0 0 0 0 1 8 78 159 129 13 0 0 0 0 0 8 223 6 27 79 8 0 0 0 1 8 223 6 27 79 8 0 0 0 0 8 203 6 61 205 13 0 0 0 1 8 203 6 61 205 13 0 0 0 0 8 111 62 45 160 194 14 103 96 1 8 111 62 45 160 194 14 103 96 0 8 82 143 196 30 0 0 0 0 1 8 82 143 196 30 0 0 0 0 0 8 54 0 0 0 0 0 0 0 1 8 54 0 0 0 0 0 0 0 0 8 37 180 24 111 34 94 97 0 1 8 37 180 24 111 34 94 97 0 0 8 94 61 200 42 0 0 0 0 1 8 94 61 200 42 0 0 0 0 0 8 229 205 68 230 125 0 0 0 1 8 229 205 68 230 125 0 0 0 0 8 125 1 0 0 0 0 0 0 1 8 125 1 0 0 0 0 0 0 0 8 70 69 227 171 0 0 0 0 1 8 70 69 227 171 0 0 0 0 0 8 121 93 176 157 92 133 17 34 1 8 121 93 176 157 92 133 17 34 0 8 211 207 179 76 229 87 229 73 1 8 211 207 179 76 229 87 229 73 0 8 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 8 3 0 0 0 0 0 0 0 1 8 3 0 0 0 0 0 0 0 0 8 101 90 156 136 105 177 2 0 1 8 101 90 156 136 105 177 2 0 0 8 163 122 187 139 155 245 97 88 1 8 163 122 187 139 155 245 97 88 0 8 31 100 188 227 193 143 8 0 1 8 31 100 188 227 193 143 8 0 0 8 85 153 46 1 0 0 0 0 1 8 85 153 46 1 0 0 0 0 0 8 221 254 215 194 253 123 70 0 1 8 221 254 215 194 253 123 70 0 0 8 215 60 213 115 201 17 0 0 1 8 215 60 213 115 201 17 0 0 0 8 245 0 0 0 0 0 0 0 1 8 245 0 0 0 0 0 0 0 0 8 182 69 1 0 0 0 0 0 1 8 182 69 1 0 0 0 0 0 0 8 16 115 202 1 0 0 0 0 1 8 16 115 202 1 0 0 0 0 0 8 229 38 172 10 236 158 36 0 1 8 229 38 172 10 236 158 36 0 0 8 152 18 4 0 0 0 0 0 1 8 152 18 4 0 0 0 0 0 0 8 29 0 0 0 0 0 0 0 1 8 29 0 0 0 0 0 0 0 0 8 164 28 2 236 150 2 6 0 1 8 164 28 2 236 150 2 6 0 0 8 199 130 156 17 201 5 0 0 1 8 199 130 156 17 201 5 0 0 0 8 13 53 72 26 0 0 0 0 1 8 13 53 72 26 0 0 0 0 0 8 238 224 211 162 10 18 0 0 1 8 238 224 211 162 10 18 0 0 0 8 120 226 140 214 213 131 23 1 1 8 120 226 140 214 213 131 23 1 0 8 127 6 0 0 0 0 0 0 1 8 127 6 0 0 0 0 0 0 0 8 191 27 0 0 0 0 0 0 1 8 191 27 0 0 0 0 0 0 0 8 27 167 239 216 56 139 31 36 1 8 27 167 239 216 56 139 31 36 0 8 82 31 0 0 0 0 0 0 1 8 82 31 0 0 0 0 0 0 0 8 244 0 0 0 0 0 0 0 1 8 244 0 0 0 0 0 0 0 0 8 116 7 0 0 0 0 0 0 1 8 116 7 0 0 0 0 0 0 0 8 130 5 6 0 0 0 0 0 1 8 130 5 6 0 0 0 0 0 0 8 47 2 0 0 0 0 0 0 1 8 47 2 0 0 0 0 0 0 0 8 196 55 144 21 143 144 9 0 1 8 196 55 144 21 143 144 9 0 0 8 234 45 67 110 61 33 47 0 1 8 234 45 67 110 61 33 47 0 0 8 124 0 0 0 0 0 0 0 1 8 124 0 0 0 0 0 0 0 0 8 105 213 125 231 51 0 0 0 1 8 105 213 125 231 51 0 0 0 0 8 11 175 154 185 42 1 0 0 1 8 11 175 154 185 42 1 0 0 0 8 101 255 202 218 14 0 0 0 1 8 101 255 202 218 14 0 0 0 0 8 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 8 37 7 0 0 0 0 0 0 1 8 37 7 0 0 0 0 0 0 0 8 47 33 204 49 169 12 0 0 1 8 47 33 204 49 169 12 0 0 0 8 237 178 210 116 191 60 18 0 1 8 237 178 210 116 191 60 18 0 0 8 226 16 6 156 2 0 0 0 1 8 226 16 6 156 2 0 0 0 0 8 21 186 33 53 89 1 0 0 1 8 21 186 33 53 89 1 0 0 0 8 43 243 242 11 0 0 0 0 1 8 43 243 242 11 0 0 0 0 0 8 253 48 225 0 0 0 0 0 1 8 253 48 225 0 0 0 0 0 0 8 98 116 0 0 0 0 0 0 1 8 98 116 0 0 0 0 0 0 0 8 180 159 4 1 0 0 0 0 1 8 180 159 4 1 0 0 0 0 0 8 187 2 0 0 0 0 0 0 1 8 187 2 0 0 0 0 0 0 0 8 36 0 3 2 0 0 0 0 1 8 36 0 3 2 0 0 0 0 0 8 160 47 250 0 0 0 0 0 1 8 160 47 250 0 0 0 0 0 0 8 98 0 0 0 0 0 0 0 1 8 98 0 0 0 0 0 0 0 0 8 174 190 217 68 144 74 0 0 1 8 174 190 217 68 144 74 0 0 0 8 23 145 1 0 0 0 0 0 1 8 23 145 1 0 0 0 0 0 0 8 13 0 0 0 0 0 0 0 1 8 13 0 0 0 0 0 0 0 0 8 44 1 0 0 0 0 0 0 1 8 44 1 0 0 0 0 0 0 0 8 245 250 2 0 0 0 0 0 1 8 245 250 2 0 0 0 0 0 0 8 65 32 0 0 0 0 0 0 1 8 65 32 0 0 0 0 0 0 0 8 205 117 182 80 2 0 0 0 1 8 205 117 182 80 2 0 0 0 0 8 186 246 0 0 0 0 0 0 1 8 186 246 0 0 0 0 0 0 0 8 234 122 75 99 110 255 9 0 1 8 234 122 75 99 110 255 9 0 0 8 222 223 37 8 0 0 0 0 1 8 222 223 37 8 0 0 0 0 0 8 230 26 192 136 251 74 228 31 1 8 230 26 192 136 251 74 228 31 0 8 14 0 0 0 0 0 0 0 1 8 14 0 0 0 0 0 0 0 0 8 128 177 66 193 232 29 55 0 1 8 128 177 66 193 232 29 55 0 0 8 253 35 145 164 119 248 140 2 1 8 253 35 145 164 119 248 140 2 0 8 174 117 27 0 0 0 0 0 1 8 174 117 27 0 0 0 0 0 0 8 8 228 105 75 109 68 255 25 1 8 8 228 105 75 109 68 255 25 0 8 31 0 0 0 0 0 0 0 1 8 31 0 0 0 0 0 0 0 0 8 101 158 131 43 1 0 0 0 1 8 101 158 131 43 1 0 0 0 0 8 8 103 0 0 0 0 0 0 1 8 8 103 0 0 0 0 0 0 0 8 181 252 244 53 0 0 0 0 1 8 181 252 244 53 0 0 0 0 0 8 39 186 76 130 8 0 0 0 1 8 39 186 76 130 8 0 0 0 0 8 231 168 14 0 0 0 0 0 1 8 231 168 14 0 0 0 0 0 0 8 111 30 175 61 55 124 64 1 1 8 111 30 175 61 55 124 64 1 0 8 74 60 189 200 26 84 16 2 1 8 74 60 189 200 26 84 16 2 0 8 103 99 236 0 0 0 0 0 1 8 103 99 236 0 0 0 0 0 0 8 248 30 237 0 0 0 0 0 1 8 248 30 237 0 0 0 0 0 0 8 15 0 0 0 0 0 0 0 1 8 15 0 0 0 0 0 0 0 0 8 39 0 0 0 0 0 0 0 1 8 39 0 0 0 0 0 0 0 0 8 221 30 0 0 0 0 0 0 1 8 221 30 0 0 0 0 0 0 0 8 83 158 61 244 15 140 7 0 1 8 83 158 61 244 15 140 7 0 0 8 21 183 50 199 183 253 159 0 1 8 21 183 50 199 183 253 159 0 0 8 176 107 53 5 0 0 0 0 1 8 176 107 53 5 0 0 0 0 0 8 53 53 0 0 0 0 0 0 1 8 53 53 0 0 0 0 0 0 0 8 162 140 0 0 0 0 0 0 1 8 162 140 0 0 0 0 0 0 0 8 126 253 1 0 0 0 0 0 1 8 126 253 1 0 0 0 0 0 0 8 233 141 234 3 0 0 0 0 1 8 233 141 234 3 0 0 0 0 0 8 178 136 48 203 1 0 0 0 1 8 178 136 48 203 1 0 0 0 0 8 171 0 0 0 0 0 0 0 1 8 171 0 0 0 0 0 0 0 0 8 35 241 0 0 0 0 0 0 1 8 35 241 0 0 0 0 0 0 0 8 107 5 0 0 0 0 0 0 1 8 107 5 0 0 0 0 0 0 0 8 15 48 198 223 1 0 0 0 1 8 15 48 198 223 1 0 0 0 0 8 203 94 65 224 14 96 19 27 1 8 203 94 65 224 14 96 19 27 0 8 187 120 141 217 244 218 89 38 1 8 187 120 141 217 244 218 89 38 0 8 185 95 188 66 117 96 49 6 1 8 185 95 188 66 117 96 49 6 0 8 181 238 174 109 232 4 0 0 1 8 181 238 174 109 232 4 0 0 0 8 241 227 21 206 37 0 0 0 1 8 241 227 21 206 37 0 0 0 0 8 11 46 148 129 54 81 1 0 1 8 11 46 148 129 54 81 1 0 0 8 1 0 0 0 0 0 0 0 1 8 1 0 0 0 0 0 0 0 0 8 166 181 139 21 0 0 0 0 1 8 166 181 139 21 0 0 0 0 0 8 231 3 0 0 0 0 0 0 1 8 231 3 0 0 0 0 0 0 0 8 58 0 224 93 1 0 0 0 1 8 58 0 224 93 1 0 0 0 0 8 61 170 163 0 0 0 0 0 1 8 61 170 163 0 0 0 0 0 0 8 16 0 0 0 0 0 0 0 1 8 16 0 0 0 0 0 0 0 0 8 19 80 184 100 0 136 17 0 1 8 19 80 184 100 0 136 17 0 0 8 141 166 59 0 0 0 0 0 1 8 141 166 59 0 0 0 0 0 0 8 1 0 0 0 0 0 0 0 1 8 1 0 0 0 0 0 0 0 0 8 106 120 1 0 0 0 0 0 1 8 106 120 1 0 0 0 0 0 0 8 24 0 0 0 0 0 0 0 1 8 24 0 0 0 0 0 0 0 0 8 250 206 237 235 100 45 220 2 1 8 250 206 237 235 100 45 220 2 0 8 104 0 0 0 0 0 0 0 1 8 104 0 0 0 0 0 0 0 0 8 45 124 107 88 59 188 20 0 1 8 45 124 107 88 59 188 20 0 0 8 133 86 244 174 225 3 0 0 1 8 133 86 244 174 225 3 0 0 0 8 10 106 7 0 0 0 0 0 1 8 10 106 7 0 0 0 0 0 0 8 198 151 96 192 44 105 0 0 1 8 198 151 96 192 44 105 0 0 0 8 18 6 0 0 0 0 0 0 1 8 18 6 0 0 0 0 0 0 0 8 139 29 156 22 238 7 0 0 1 8 139 29 156 22 238 7 0 0 0 8 223 115 28 171 0 0 0 0 1 8 223 115 28 171 0 0 0 0 0 8 221 148 185 62 0 0 0 0 1 8 221 148 185 62 0 0 0 0 0 8 61 47 108 1 0 0 0 0 1 8 61 47 108 1 0 0 0 0 0 8 87 157 178 141 10 0 0 0 1 8 87 157 178 141 10 0 0 0 0 8 86 94 188 134 23 82 0 0 1 8 86 94 188 134 23 82 0 0 0 8 179 64 23 0 0 0 0 0 1 8 179 64 23 0 0 0 0 0 0 8 113 45 10 0 0 0 0 0 1 8 113 45 10 0 0 0 0 0 0 8 204 227 150 219 42 98 0 0 1 8 204 227 150 219 42 98 0 0 0 8 72 207 3 4 107 1 0 0 1 8 72 207 3 4 107 1 0 0 0 8 242 22 0 0 0 0 0 0 1 8 242 22 0 0 0 0 0 0 0 8 43 248 193 8 8 37 19 0 1 8 43 248 193 8 8 37 19 0 0 8 135 156 114 210 151 8 0 0 1 8 135 156 114 210 151 8 0 0 0 8 126 63 25 0 0 0 0 0 1 8 126 63 25 0 0 0 0 0 0 8 94 41 0 0 0 0 0 0 1 8 94 41 0 0 0 0 0 0 0 8 132 46 67 3 0 0 0 0 1 8 132 46 67 3 0 0 0 0 0 8 12 53 213 1 0 0 0 0 1 8 12 53 213 1 0 0 0 0 0 8 224 181 149 0 0 0 0 0 1 8 224 181 149 0 0 0 0 0 0 8 214 73 249 129 122 0 0 0 1 8 214 73 249 129 122 0 0 0 0 8 141 160 27 51 90 159 14 0 1 8 141 160 27 51 90 159 14 0 0 8 123 185 72 150 135 30 2 0 1 8 123 185 72 150 135 30 2 0 0 8 132 79 251 109 16 13 0 0 1 8 132 79 251 109 16 13 0 0 0 8 187 0 0 0 0 0 0 0 1 8 187 0 0 0 0 0 0 0 0 8 26 47 114 1 0 0 0 0 1 8 26 47 114 1 0 0 0 0 0 8 36 142 132 192 11 54 198 0 1 8 36 142 132 192 11 54 198 0 0 8 167 191 148 125 0 0 0 0 1 8 167 191 148 125 0 0 0 0 0 8 234 206 244 113 18 198 0 0 1 8 234 206 244 113 18 198 0 0 0 8 3 143 18 0 0 0 0 0 1 8 3 143 18 0 0 0 0 0 0 8 62 157 58 195 0 0 0 0 1 8 62 157 58 195 0 0 0 0 0 8 172 170 222 106 83 163 194 4 1 8 172 170 222 106 83 163 194 4 0 8 88 220 20 57 0 0 0 0 1 8 88 220 20 57 0 0 0 0 0 8 167 245 187 129 1 0 0 0 1 8 167 245 187 129 1 0 0 0 0 8 164 130 167 36 0 0 0 0 1 8 164 130 167 36 0 0 0 0 0 8 61 130 34 172 248 118 0 0 1 8 61 130 34 172 248 118 0 0 0 8 40 22 12 0 0 0 0 0 1 8 40 22 12 0 0 0 0 0 0 8 209 1 0 0 0 0 0 0 1 8 209 1 0 0 0 0 0 0 0 8 170 133 218 207 1 0 0 0 1 8 170 133 218 207 1 0 0 0 0 8 223 195 71 3 0 0 0 0 1 8 223 195 71 3 0 0 0 0 0 8 197 87 218 147 1 0 0 0 1 8 197 87 218 147 1 0 0 0 0 8 210 1 234 57 242 124 45 0 1 8 210 1 234 57 242 124 45 0 0 8 119 110 205 24 176 195 21 0 1 8 119 110 205 24 176 195 21 0 0 8 71 104 194 0 0 0 0 0 1 8 71 104 194 0 0 0 0 0 0 8 53 164 236 57 255 127 4 0 1 8 53 164 236 57 255 127 4 0 0 8 218 132 146 91 132 77 213 4 1 8 218 132 146 91 132 77 213 4 0 8 133 79 247 151 252 1 0 0 1 8 133 79 247 151 252 1 0 0 0 8 203 243 153 55 2 0 0 0 1 8 203 243 153 55 2 0 0 0 0 8 197 193 53 2 0 0 0 0 1 8 197 193 53 2 0 0 0 0 0 8 84 5 0 0 0 0 0 0 1 8 84 5 0 0 0 0 0 0 0 8 177 187 206 97 141 85 1 0 1 8 177 187 206 97 141 85 1 0 0 8 166 94 0 0 0 0 0 0 1 8 166 94 0 0 0 0 0 0 0 8 190 247 33 10 10 0 0 0 1 8 190 247 33 10 10 0 0 0 0 8 61 186 120 114 110 34 74 14 1 8 61 186 120 114 110 34 74 14 0 8 48 152 216 0 0 0 0 0 1 8 48 152 216 0 0 0 0 0 0 8 157 24 37 230 113 32 156 61 1 8 157 24 37 230 113 32 156 61 0 8 26 71 250 167 179 175 252 27 1 8 26 71 250 167 179 175 252 27 0 8 138 11 1 0 0 0 0 0 1 8 138 11 1 0 0 0 0 0 0 8 64 228 47 79 174 153 235 1 1 8 64 228 47 79 174 153 235 1 0 8 12 0 0 0 0 0 0 0 1 8 12 0 0 0 0 0 0 0 0 8 227 20 33 239 16 0 0 0 1 8 227 20 33 239 16 0 0 0 0 8 89 117 39 6 0 0 0 0 1 8 89 117 39 6 0 0 0 0 0 8 56 143 170 210 159 0 0 0 1 8 56 143 170 210 159 0 0 0 0 8 83 94 139 170 42 227 7 0 1 8 83 94 139 170 42 227 7 0 0 8 158 24 234 182 90 0 0 0 1 8 158 24 234 182 90 0 0 0 0 8 184 250 218 70 0 0 0 0 1 8 184 250 218 70 0 0 0 0 0 8 199 13 0 0 0 0 0 0 1 8 199 13 0 0 0 0 0 0 0 8 162 245 210 10 15 0 0 0 1 8 162 245 210 10 15 0 0 0 0 8 163 218 24 0 0 0 0 0 1 8 163 218 24 0 0 0 0 0 0 8 14 0 0 0 0 0 0 0 1 8 14 0 0 0 0 0 0 0 0 8 167 97 145 202 0 0 0 0 1 8 167 97 145 202 0 0 0 0 0 8 207 69 56 26 219 188 172 2 1 8 207 69 56 26 219 188 172 2 0 8 19 245 0 0 0 0 0 0 1 8 19 245 0 0 0 0 0 0 0 8 101 116 0 0 0 0 0 0 1 8 101 116 0 0 0 0 0 0 0 8 144 67 225 251 217 0 96 0 1 8 144 67 225 251 217 0 96 0 0 8 141 129 40 88 123 180 46 1 1 8 141 129 40 88 123 180 46 1 0 8 83 65 0 0 0 0 0 0 1 8 83 65 0 0 0 0 0 0 0 8 1 71 241 42 0 0 0 0 1 8 1 71 241 42 0 0 0 0 0 8 201 82 0 0 0 0 0 0 1 8 201 82 0 0 0 0 0 0 0 8 143 3 0 0 0 0 0 0 1 8 143 3 0 0 0 0 0 0 0 8 140 29 0 0 0 0 0 0 1 8 140 29 0 0 0 0 0 0 0 8 209 38 0 0 0 0 0 0 1 8 209 38 0 0 0 0 0 0 0 8 34 69 0 0 0 0 0 0 1 8 34 69 0 0 0 0 0 0 0 8 221 163 103 107 78 53 11 0 1 8 221 163 103 107 78 53 11 0 0 8 210 46 149 42 0 0 0 0 1 8 210 46 149 42 0 0 0 0 0 8 48 85 36 205 0 0 0 0 1 8 48 85 36 205 0 0 0 0 0 8 37 35 35 0 0 0 0 0 1 8 37 35 35 0 0 0 0 0 0 8 13 0 0 0 0 0 0 0 1 8 13 0 0 0 0 0 0 0 0 8 46 173 250 215 165 229 166 2 1 8 46 173 250 215 165 229 166 2 0 8 67 188 30 254 109 2 0 0 1 8 67 188 30 254 109 2 0 0 0 8 137 152 11 16 0 0 0 0 1 8 137 152 11 16 0 0 0 0 0 8 152 52 243 192 36 1 0 0 1 8 152 52 243 192 36 1 0 0 0 8 129 59 0 0 0 0 0 0 1 8 129 59 0 0 0 0 0 0 0 8 201 94 53 127 56 0 0 0 1 8 201 94 53 127 56 0 0 0 0 8 73 236 21 75 203 154 66 5 1 8 73 236 21 75 203 154 66 5 0 8 196 244 167 127 116 213 0 0 1 8 196 244 167 127 116 213 0 0 0 8 63 43 243 86 100 247 101 30 1 8 63 43 243 86 100 247 101 30 0 8 179 18 79 0 0 0 0 0 1 8 179 18 79 0 0 0 0 0 0 8 62 229 32 2 0 0 0 0 1 8 62 229 32 2 0 0 0 0 0 8 191 161 29 68 10 28 0 0 1 8 191 161 29 68 10 28 0 0 0 8 157 0 0 0 0 0 0 0 1 8 157 0 0 0 0 0 0 0 0 8 177 110 144 211 209 51 0 0 1 8 177 110 144 211 209 51 0 0 0 8 38 140 6 0 0 0 0 0 1 8 38 140 6 0 0 0 0 0 0 8 230 31 0 0 0 0 0 0 1 8 230 31 0 0 0 0 0 0 0 8 240 94 116 15 0 0 0 0 1 8 240 94 116 15 0 0 0 0 0 8 182 7 0 0 0 0 0 0 1 8 182 7 0 0 0 0 0 0 0 8 1 177 12 133 96 0 0 0 1 8 1 177 12 133 96 0 0 0 0 8 240 7 185 0 0 0 0 0 1 8 240 7 185 0 0 0 0 0 0 8 243 73 7 0 0 0 0 0 1 8 243 73 7 0 0 0 0 0 0 8 26 0 0 0 0 0 0 0 1 8 26 0 0 0 0 0 0 0 0 8 103 9 1 204 46 0 0 0 1 8 103 9 1 204 46 0 0 0 0 8 98 214 177 103 24 96 0 0 1 8 98 214 177 103 24 96 0 0 0 8 81 174 115 76 247 124 0 0 1 8 81 174 115 76 247 124 0 0 0 8 61 12 0 0 0 0 0 0 1 8 61 12 0 0 0 0 0 0 0 8 85 161 0 0 0 0 0 0 1 8 85 161 0 0 0 0 0 0 0 8 101 4 40 150 22 103 32 0 1 8 101 4 40 150 22 103 32 0 0 8 103 2 0 0 0 0 0 0 1 8 103 2 0 0 0 0 0 0 0 8 60 153 25 0 0 0 0 0 1 8 60 153 25 0 0 0 0 0 0 8 143 111 7 0 0 0 0 0 1 8 143 111 7 0 0 0 0 0 0 8 80 120 24 232 225 5 0 0 1 8 80 120 24 232 225 5 0 0 0 8 174 134 41 0 0 0 0 0 1 8 174 134 41 0 0 0 0 0 0 8 113 152 62 21 0 0 0 0 1 8 113 152 62 21 0 0 0 0 0 8 241 24 81 31 0 0 0 0 1 8 241 24 81 31 0 0 0 0 0 8 82 153 37 103 160 93 6 0 1 8 82 153 37 103 160 93 6 0 0 8 40 224 161 201 3 0 0 0 1 8 40 224 161 201 3 0 0 0 0 8 19 3 0 0 0 0 0 0 1 8 19 3 0 0 0 0 0 0 0 8 82 0 0 0 0 0 0 0 1 8 82 0 0 0 0 0 0 0 0 8 64 200 218 23 94 23 70 119 1 8 64 200 218 23 94 23 70 119 0 8 15 139 7 0 0 0 0 0 1 8 15 139 7 0 0 0 0 0 0 8 18 20 0 0 0 0 0 0 1 8 18 20 0 0 0 0 0 0 0 8 128 37 176 212 38 112 1 0 1 8 128 37 176 212 38 112 1 0 0 8 13 125 43 146 204 213 0 0 1 8 13 125 43 146 204 213 0 0 0 8 14 0 0 0 0 0 0 0 1 8 14 0 0 0 0 0 0 0 0 8 70 145 5 0 0 0 0 0 1 8 70 145 5 0 0 0 0 0 0 8 186 122 94 51 73 69 56 8 1 8 186 122 94 51 73 69 56 8 0 8 77 183 3 0 0 0 0 0 1 8 77 183 3 0 0 0 0 0 0 8 217 138 24 241 155 207 0 0 1 8 217 138 24 241 155 207 0 0 0 8 150 0 0 0 0 0 0 0 1 8 150 0 0 0 0 0 0 0 0 8 196 49 182 125 0 0 0 0 1 8 196 49 182 125 0 0 0 0 0 8 133 3 165 0 0 0 0 0 1 8 133 3 165 0 0 0 0 0 0 8 0 245 2 102 53 0 0 0 1 8 0 245 2 102 53 0 0 0 0 8 35 187 7 0 0 0 0 0 1 8 35 187 7 0 0 0 0 0 0 8 217 58 0 0 0 0 0 0 1 8 217 58 0 0 0 0 0 0 0 8 93 4 23 102 114 100 3 1 1 8 93 4 23 102 114 100 3 1 0 8 18 224 241 10 0 0 0 0 1 8 18 224 241 10 0 0 0 0 0 8 100 120 0 0 0 0 0 0 1 8 100 120 0 0 0 0 0 0


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/sincos.ipp
================================================
// Copyright John Maddock 2006.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef SC_
#define SC_(x) static_cast<T>(BOOST_STRINGIZE(x))
#endif
static const boost::array<boost::array<T, 3>, 351> sincos = {{{{SC_(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(1.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00)}},
                                                              {{SC_(1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-45), SC_(1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818790351457308800340787773674912766449462132584452348391040651604302709449379239880726512478831381302725264182410989377719891632824721505923538954718756787336781717738534589892517841597367279244325993758027159471887458619888927468693858915842127431596637785499217667152866164893680003868553832956009253404298979008131545708840033018263781326433505544641583562700173344804674499926293464492880691980275690339365803e-45), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999018181306940454689380845609002744871404956897500110086977690176562578949055656828707980423353194933884755560203023626611533678706648719853431695157198205786802969097792096779337651473648106366274410397508094269252694850980143248502445340096430658555215811691593841493933838124949891785030283170868447315870535323338409489664710335241993056422950940322493204196544853978533985277190092235175175166662055024795932e-01)}},
                                                              {{SC_(2.80259692864963414184745916657983226256052388375303154351413656777958216537172120297327637672424316406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-45), SC_(2.80259692864963414184745916657983226256052388375303154351413656777958216537172120297327637305538709251652726302189399302131595697060675618787128325212834421675595033919045812099830759114965997778797780834590216037028749734324604341671062262121984141170908506261795217328399995070051694207174852643747661007471491085388153950316454056337188894731416167834304541739657820299760902499844561410566938370733275087498466575935335388483418932214377317214724719142755203142240541630547874210971000852044930167e-45), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999996072725227761818757523382436010979485619827590000440347910760706250315796222627314831921695340715627621329535004694534216141863971398843021645158093032804874254958679377217097895883419963322632791960267614868367018464110751226843336329749526804502021446103686642277447920958483566966767779163022051468729743460838565621454431717928897730690691764161059400654765666575293764292473950159219386917758286295006197205e-01)}},
                                                              {{SC_(4.20389539297445121277118874986974839384078582562954731527120485166937324805758180445991456508636474609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-45), SC_(4.20389539297445121277118874986974839384078582562954731527120485166937324805758180445991455270397550462609201269889222644694135477579780213406558097593316173155133239476779615836929419876071343120971532989314549209781635141154879822077216303667702093239942499810993653083491071372581441825986232094472955340205971243975796884028319908471468409203092484306028848922723223269266129671649514061121265458553966701648599990935430386904212713721653207641489661037980396865125821447766865757966623202011002481e-45), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999991163631762464092204427610481024703842644612077500990782799211589063210541500911458371823821746369757456643806982812806123846003228662260328395521200223742443485215609381850897310524629291344568956530530262684105635460612822223837210330705593721872335387821404502143865865987389605653700871033897311375196441706482504472066650591798878127657289137553615069304296604544940870015086975449211081356049236357710750027e-01)}},
                                                              {{SC_(8.40779078594890242554237749973949678768157165125909463054240970333874649611516360891982913017272949218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-45), SC_(8.40779078594890242554237749973949678768157165125909463054240970333874649611516360891982903111361556044623610159113781157553083820638241707252464780746529385241065915814236926695461618692810291645026043369651421342028007962602533874712596930401059391166595777353132351354736336704190050078910834200567500725387522401892079463643692576146069143395731578179123995246777807445028382991342302004768477178958229712964263884786053770003966369485261014589712284700049082525146041017974355650133493523666604208e-45), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999964654527049856368817710441924098815370578448310003963131196846356252842166003645833487295443148286288493466057531853473865963093643770093554970659404333489664430527782442632013409169209372509621725822822280428683194964710409099655027231809772830542963187159283687376144462766563252564386045904505129129380699890638470353691133935782709516334660181819672442049363705097682342862579067086527667395708957625728010687e-01)}},
                                                              {{SC_(1.54142831075729877801610254161890774440828813606416734893277511227877019095444666163530200719833374023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-44), SC_(1.54142831075729877801610254161890774440828813606416734893277511227877019095444666163530194615774084988825358852676130889214423409846990607570847510728532690627712376828124698811004373805554947945445940658982587165803101327925691022042340834793945730630651714551646267709027625314258120286618611628110979879120205714434111724186618983889316034414274293110435526057786113651996476163163956546218796793849755436659001175560988905437079489045957123605234732369555892588189553152777884400882221479823702315e-44), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999881199938139795017415082318689332129439999784597513320524300511364072052835734476273665633558539016419647248757611892421704225588717291067846471845751360789925288829565527986759623768975753575997773800645970067273825398960965781570222907333052180870307750101932061092875046215001474627990763755720004253005726220961181931360340566888859898469699692960128833946501406695399631850637468380933106599429434314849425374e-01)}},
                                                              {{SC_(3.22298646794707926312457804156680710194460246631598627504125705294651949017747938341926783323287963867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-44), SC_(3.22298646794707926312457804156680710194460246631598627504125705294651949017747938341926727524573185742374636484230266362939060576715503172287379160806955106587059721162879947735886748511328881312314826032585123373233873715409532159887503072282395082993219295587670117698205854346930405798097420936363731431238400620602531307113293335307369886473931872251669066838685519427524997065747532725008631793788181680132189938777240459148366970187452325085041054979389568689596347966804174842938247660756550437e-44), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999480617911371500530682467327162452036973222198777558236011198103401604264050442462386521688828475944132820270974357744852187719530274229740373520595807665539873553993080745823439955253622478543514458940785554677862703585578090996659264673716399020742597191730642633179383457364996748943881349656994930909983016269956721448068004898707766137974729184023442461006739874323489203375832554602730784179556189605934184419e-01)}},
                                                              {{SC_(7.42688186092153047589576679143655549578538829194553359031246190461589273823506118787918239831924438476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-44), SC_(7.42688186092153047589576679143655549578538829194553359031246190461589273823506118787917557071567734039333546138139998793069657391277551227141295908889377447469523309572292100019331359631334318174561609698634784357031155321301439148398735485598083156201912789699437880499952454662251467269128292323182720318781277898618615138713234960798201648044045228024517817220298333488925242202864692124191272173879533829613886485347072065635916938540096866697115628808888824427591990485826501618370545748403779575e-44), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999997242071291195737222470795315688710343776523925077809234320331705964284267897340031840718276442954050335356685171447220544117279261490357334686649206295189130909786729091199045220985992676527516309991379539048035055704301070927384372207584878961173246105601002640718234285492270478202155019800902822073363446671078460482683530262882597940421207717144002253386046652555081637431410126935539589794505731025710676379063e-01)}},
                                                              {{SC_(1.05097384824361280319279718746743709846019645640738682881780121291734331201439545111497864127159118652343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-43), SC_(1.05097384824361280319279718746743709846019645640738682881780121291734331201439545111497670652327220720187698420191038233458668371840658344774702748955652055489568668246814974626901822859305738995281066066448198114020751344649620709960208002064198384905117235274182583546441284941429826369890146228651398698659788539187660433894685192269471013358968568537625675802567571975922807099858605616052408037138909868535400231927588666795931021281563837169514777440278854726220318571799562403632573245982136141e-43), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999994477269851540057627767256550640439901652882548438119239249507243164506588438069661482394963882717005084354341383831108371223875714348110550375875361891735468092383465608580594392203699927961133554924574448443357107180124203598756077136385300580115685171857809418195803009471462689144883556767944584573067238540300397625512326425856193876988499074312589335443468863296988797494008557816054949653946346405265614466521e-01)}},
                                                              {{SC_(2.10194769648722560638559437493487419692039291281477365763560242583468662402879090222995728254318237304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-43), SC_(2.10194769648722560638559437493487419692039291281477365763560242583468662402879090222994180455663053847439087361528305867669346974725266758197621991645216443916549345974519799579636871892676112526648444061630875432364581411034670256488408102709411987031842685229809521678287117433846120945714500267214729465233728758289015332663555356907038138247888801679347356008669703897840194824797666053047570787305557626392462396479147321595075220703366096193472213477456408514532068165552987454832784517598469370e-43), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999977909079406160230511069026202561759606611530193752476956998028972658026353752278645929640856627453437091647678270578093867348912670303473993915455915738774094895059219945425455712948260097287167402615818858938341377297396988942875681514508702249864150447882439620069730994781383325744667145025187907937825146056513256418433787478833229590937485750976313958959995857469736815601150524811999423397557967975094145663405e-01)}},
                                                              {{SC_(4.66632388620164084617601951235542071716327226644879751995103738535300430534391580295050516724586486816406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-43), SC_(4.66632388620164084617601951235542071716327226644879751995103738535300430534391580295033582185205789161845419398674547856851973379123930414244575696445912083280274388675828051112459855219307669660923033393959195552402701380143007212075019536866539095886456124694103812914692592186813095161949784665763547067799123307190932094852262291743854239589467068246000091236672783966432440796514865312222994728751652343905850683285452371439099763686518414140487338867024165200326852923049841093249444705198793873e-43), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999891127106945320080050752588736705376045224265406889707434869085988847817081832730078601216698537208723978870828429426132354223033640845300085418977379720396588632501949070635779461038749299328050727369251003094322938028991998378771012224015911587313333701442922100083787345533568931010184906661307603865664516617509537152983462675147192472775815030334087089321785263057861128893065942146589055914769708614295112037282e-01)}},
                                                              {{SC_(1.22333355935556530291641592621209678260766867525819826874392061183578761518475630509783513844013214111328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-42), SC_(1.22333355935556530291641592621209678260766867525819826874392061183578761518475630509753000948705533479418866027375467625129135687610161180897162329185595954402814970753825051091958713527722375174828431644619848284971925661141095511345836491236689334826010659371679330787292070314641713965540731707275304824222335038176768345388241694945900470602965316849261159010127304761857501611899200514651777047976437164422797344832678448893012684055590664977502888862432076111336870979449510638233456440392092154e-42), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999251727501277221791963134483143652946098988395334861400478220036573461731864838683206477730569359918994418110092459071692590420954258112913054863293511313821049032279840033133091972315123462424997068552908251488888835340014765762041910447767748264144555345710012367897821701950047391724289924099438289720106542049969731533631374438421776311556603444490337372131933655486205390154608413468747459621886432625215014782084e-01)}},
                                                              {{SC_(2.57838917435766341049966243325344568155568197305278902003300564235721559214198350673541426658630371093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-42), SC_(2.57838917435766341049966243325344568155568197305278902003300564235721559214198350673255737238966372051888799258963778247990152783376242111381303331610145725745772353945427357361145486695541184381321338742142669770269495102860756614147260496795107861458914054023077958024860025506704682782268721894529111699275425956795744932455234081018984532485402586765516884392364011034682787867594623024532922588091056836292782026784274713857015966608080506950980879305590087445073079381675098230575099138827876112e-42), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999996675954632777603396367790893839693036628622072176372710471667861770267289922831759275580067027867234722228430080471552582226415723987626237690981128512381741567675223648396297701756050725932395149173824330771267008371869876795254391227451236964243860781777838348733979424414018273387935180620881558052018364492093238348499691354984306857440378153948514582513764076650823260920930404915003875414931338093385440488610425e-01)}},
                                                              {{SC_(2.96094365511833847086184060949159278539519348318507782572268528385912855771522345094126649200916290283203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-42), SC_(2.96094365511833847086184060949159278539519348318507782572268528385912855771522345093693996739342932663804846651085820195898433848681112306343912274946090956703290365385602078892224342391181399780345406462574604119522592402659502072571781680123040917209154609109171457264508074993793451528626299861129351462001440897361404823166962990209615925574365137246754984870857324607933605053121269918918153614170251284286175857951281402587778087901842648839202937674178237986130813368757321932975610351978531701e-42), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999995616406335607226943052228668861576216757838002294669012925294791921129051796275883456903694979322501329971375447753971251773961247808436603020996111873404733070017197845470310705625912309526290295374073656496025387323329294558782671483807734805753414994834876374099993858561755751805408888198323439213097646998312370490782535190924653242809107848005183955596913373155062584166537545022162737405001739308072239264970136e-01)}},
                                                              {{SC_(7.55720261810373846349167364268251769599445265254004955708586925501764330892484622381743974983692169189453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-42), SC_(7.55720261810373846349167364268251769599445265254004955708586925501764330892484622374550612448373730191413193303431049794041304644123408793084820745811028793562333348916456519265465336696463122961996291323668438209924140273844864059538944318277976227762678517671975595479579453080897835805446525198108109753026208669175956600936390166668134897501291587095007074691843131333212682512579039986401027805480348350886360241751644496932510052072285282083099768297529183165722660597082513542981408056777981617e-42), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999971444344294463000450108045691914274072389027232540179319088194078035322752282849196194896756803855580175797043645074196213887410097135181896784101900962704236324186319009789568789941181425532234149392153366432424993544410950289613464726947532233749725913910743043679099530150918947846596008589510245917814356607023762433721080260938839286761529865612309642958368349089189032058662245374996383379270059613802426143510423e-01)}},
                                                              {{SC_(1.46589832353019113789331351707958126493228201739702314883506913177711045159767877521517220884561538696289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-41), SC_(1.46589832353019113789331351707958126493228201739702314883506913177711045159767877516267208908427393861721504907325171929472720865773006275638632426304933510409951261954656218026260776426755670372542025774879490868328477422522654282360896480461898264393728557122541481302896883438232050290492523787110495425540325854976498628867329722408191317623181418915019006160748335621352766125413675429734653791931135071630025587791482079495664566178902236522056278966690016735464045305629073387162733493980906882e-41), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999892557105253568753545217864104950667197665245189775644595497906778178128656691096078303466467187938459594167417463818916417117358473643785540714442073012942743717914732037748071998704147219159170063017358513712449206088197946521436940697640711296900126660913421258179104561251733958995998165062617805307831291519562109920870718679948001278826555255838735691382758937227438223290700605918762038729941060805254738926364578e-01)}},
                                                              {{SC_(4.29890342885567381017981761561680470754158758528877508459633408131710108346368315324070863425731658935546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-41), SC_(4.29890342885567381017981761561680470754158758528877508459633408131710108346368315191660548910487698640593276555287590068274126080495796600691159804102586379685177760662635437114892933360460302490297861538787485499296789402780765824215676091815381268645071433103144568224470731467136203368744072106184460077740479824007144285177878600537935639122698858220342265906528947489376413420658288715001310209384236877493329408364270388530486494392325150006115430411152539355170867002025305337772612859827428934e-41), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999999075971465468646533180207192109630863406681770546873997223395847820009758339292966324975612532967466820309355879235997759431321194583616980614121361748306696010139554876844921925965078471560618240863429559876295366367257626963436982144381690256088162065634034183526734308381551083435025308855773105012914069158476743241978619938658527251068183076619854877720409206737387349288732114126976152205371577160652967630617123599e-01)}},
                                                              {{SC_(4.80379126555190540083363738447616148964186596294688371716040578400259281055539872795634437352418899536132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-41), SC_(4.80379126555190540083363738447616148964186596294688371716040578400259281055539872610877338501347601219175270676662869099033699415241762387976667404536927935589076831672632599089820124680009011322734319715118623320805661025510875584717953950495972701008862867740843426026356222430890016125676658201558709582791616384491466268886310743277365390744757660647471861857386539703251775817308401899230677444627869562185725283076582085060518200835494958195542251512378077909637116291984512266293918513338503809e-41), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999998846179473850361154371674922854129986084727096709142870280757393394130581463291168610112704406499060352403499469291720728306994847837600250563158304798680794177527403425268942921796278460653093888122873284053643989868791585401086238273954075339473301544992488839606468292179655865318731156652793808004127813501461466101819147627941309038766551940761100509140381914523658200325453837791357981873672885699155514487958255331e-01)}},
                                                              {{SC_(1.05528984751373323977124227458397004014453966318836649739481298323172386854906790176755748689174652099609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-40), SC_(1.05528984751373323977124227458397004014453966318836649739481298323172386854906789980887504771187332364132636109487217929208679431907543158803628082268875678333496411512923906603472445334327299722485190443927742726521958136503063744853505202494039957387234555933593281644632395449538000337461647675827932577828286596180344814422872806232066066010815495542783741497903180129364783147090148024196900445602757951656729695080517991132336449993528257155261985896406981415684240794679489860063828342392027328e-40), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999994431816688672208233710305042314219151101272516933748775711167580922607168373864227965541361289251010654534999802989928735915119413129451470140853636658987643574157298081896981245127358297596889192754078582247331884307559147751318090642104769338421104440133007218078588778511425272289353063257890140890461661561004041429851910440417566678968240145321910415990690683553710637026739594965677666802372650596926643292041996638e-01)}},
                                                              {{SC_(2.01510923065301669250045085265839809426495508027668597525981690428203627063474812075583031401038169860839843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-40), SC_(2.01510923065301669250045085265839809426495508027668597525981690428203627063474810711802373032594699969810619116841404970861472887256166386048754834748113391268197763832955073628906392784795381155976046065612198436366710288821444973028946646023484366577270255382565430666890873219733228088428497141478307604678164851586001801533760898750558581710818483297283897358606526238189016006778424780680200657251336858863806486367993844372954164133250632883143114958449643914391396931717830204115391769145546484e-40), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999979696673942685035853850543073045777707954868946997951599446982788522244825490912223945146237649836813044005513754448276849194256842083656687070132896763547132020424839753567770743006368670904848300067578350340653279036966460909408461382429991769872604279825699445913799875847014991026905964403318089265513005878651764666517348099896382056900530127079726632856823997344435810758823451691867992445903154064288120383150987671e-01)}},
                                                              {{SC_(7.32504950151904601935173936261887729052525165662936718917887575242562162025627969796914840117096900939941406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-40), SC_(7.32504950151904601935173936261887729052525165662936718917887575242562162025627904291011292837720144593431126597367515998989153198457015902750071695137835990685604892263621831515557060246307131984841519212710373547750063546014290419636943710720132280288244343650374997981943021052969538830344386792052372151384906422960252069039716388381803899141518571399834733857022053723510925721401160619649691446479064067028054989737014742554510760352969761538081403146605616293590611767277714260566785874599515793e-40), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999731718249001477877143168008532640917534029873632032252120957303589649904151885305973799269888934534909136198437925454757554860783321503630302312105520970158621889109299625562988285780953907400410390020639968947017260622162867366315832821549484018469877658751307945502656509972585482311806680315543936811858642849279465528279655411048214732456565842865876212846439566194454456637005298750822183817695104506210394947373953085e-01)}},
                                                              {{SC_(1.33966515396841864169329118502807575007816218088696097856787714955946640149608839465145138092339038848876953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-39), SC_(1.33966515396841864169329118502807575007816218088696097856787714955946640149608799393466769935160071827043264942041685242847448108284494427393761948492846509916986077875292923082077469184325721717857533402797270511306605163459987343262256569264007349244333444115764051413257529668304213835300075569972339881302618317393221832794373332099017592930269066115891486986577472025784928127713471885695681145572611164474622978513975703266720143131891946646092594745882505672457515555881327346483090258133109813e-39), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999999102648637621386587238987552746272043013454101628689499407841187184948605476876334955279870868767750800059575163137784626164589056798852834142555490085645186899015547757002677276114759208540303733026521153564543719479878946956818853456708417790933960103537105155253735839010002786196075719602911681185910630157610492301675225607916036307950416287870173505934149096254870905146725805112841309456550280335897354832252188484699e-01)}},
                                                              {{SC_(2.67704619143998783156097669083538893686233753480866323642779027781619244352739883652247954159975051879882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-39), SC_(2.67704619143998783156097669083538893686233753480866323642779027781619244352739563897984299105902128855302251894710143801990277685086036288881537114672707533483727518555424527302608356036356217986356197792739366250414583736898340317558602513631529933174608625249495997042977955438961972134324708577539931088346231802431204407452780232261732489676314940425767518677852657613399447450394975134408614300034765724426388230494398863554338885318201348491063100048984565134316337355192798205904718373408055959e-39), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999996416711844448328010836543119598472240469572030882370560576310418964309618728328179940611074428491474999154941510527197897854270875982495690413621119770434170978547360806493132985478957649761646330066648315631863124058757356730994348799421077276380735378148156663760085371571182147899917776000626572381366357642100541978640426148495871453988769629317000167837866856830562597160012881170553619814677812429087684105533480604824e-01)}},
                                                              {{SC_(4.98065334862973353780613406637193167431914166341694440226118064331717501247442925205177743919193744659423828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-39), SC_(4.98065334862973353780613406637193167431914166341694440226118064331717501247440865961706082185262300907349748068968430289329142149112388324350697105735066444850117781308977214384632246495516203852364550923245875264911126054830285447794666051901956355872882436639418664467404450121285880935039406673241090924270460939631836024048762290640271473049067456927214532714526797251300223483202814869269567316784928514501511005074814011991880011042729877301864770711496955945630526292405050391715830741638832339e-39), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999987596546110391710994379711623068869451337606096342108625478131918320009488445778250750401876191182731266979269973303293901478710089771515180173918644613342792395295337150147962833559157614103818968508131256797025993480612649131131295014985392720460404345935117219910238516012744511524766168411644949909022868757584567938463480609599435179942543723898381721040096255576605436773910863929161497154264218514163673674788342460421e-01)}},
                                                              {{SC_(6.61322911799904004220047059873593201348655443749046971956789426212155666440217771651077782735228538513183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-39), SC_(6.61322911799904004220047059873593201348655443749046971956789426212155666440212951180267037989278011390446684321888716336223066517279132166898428654774534689211293208975697927510796390180089112434958835354241993947050884854802882807109910568964641743255696216900096606365458624787210152018106794407805871136753532283305154054797825092007339353096964641783328787428804217368758985796365133796747731180160659350716972790789978702678899730892531705668567399746853894977141121012996122009020944132722807189e-39), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999978132600316424819458871898582377151976877276609840945795779220166843198812911241921361184270437776491458291901247500946988256003349588053268643044761577809440194145005106845400574711621718945974528696979467351650861357365416040731658845738292066488483990916744859113297684359767658520832922218399521682790249135386599957375066859000568645217385839964246827971397420685997824501311319875532430117958365665071740834286896688200e-01)}},
                                                              {{SC_(1.54824254492961749846859045383652994857147779383512446982767538392966946703133146456821123138070106506347656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38), SC_(1.54824254492961749846859045383652994857147779383512446982767538392966946703126961085988845194765016677224573150759279990907005138172280344305822762129830974739861817563548607584336183614347338206829196446854499415600946091562886397948974153134147914359866606123722979808726587858809602661796413993286599443541318127541811836618562120619935933142937927283356718969340037803418384915663635421018050240390063399173057203977102865070796348392652096890020237829272597410682790525617612157766125616287252744e-38), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999880147251103493067079197906492851642489951807612675096101071372809763052176814238098234757914806141252740340867410432612444896212338592468868178773649165288944334267569037833785705287027561088840334981533388491347173126442412363399111551633509256874317164512773006907444197207798073824215723487854515014273420120927829877512313201892373536931918844370906211898732256730679347491689855151383360496535317453280786049708294692770e-01)}},
                                                              {{SC_(4.14655650189182261793630321328885828961460755538706729231614042880185722061980868602404370903968811035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38), SC_(4.14655650189182261793630321328885828961460755538706729231614042880185722061862042592989753985866613511536161784732505728534611917389621675815565806216456733797635229753667377166650970990553431464073848921448167545536686761492234778689910956124468888048028352079425119895491432133576643928937349140475648209132764234915780601666168316129135579051679358350888091833066751395602947699623976228467139520969584938853923527081219369788343445865866087636551945529117194090170963755429299772957394707033664947e-38), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999999140303458830932562495970891609851434141169762625227468703921261555172214042553364993994634622966419016883421920787233269568087911528717371496834529990991021120129680362470105835559303793013244274628533900046317008176792327455914771957236528289495804030764115202483608113943926547285214664218148302982221883326127385930775038463435090571400891500003663643560192259356160907398291267541063405411124424549800043463320847909557477e-01)}},
                                                              {{SC_(9.16989984771782597788130033192388394290674988675850299695759145456042116251182960695587098598480224609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38), SC_(9.16989984771782597788130033192388394290674988675850299695759145456042116249897844115270071964291065187070451428162205117773893965556440691457216154310897806331075177813107720146501971323479067623584326457128542356781061897017124711295344504641604649164572504676902618542136026936516116875011868845410581154011041055005068165526312569371383835954064173376238455385938643029758029883725569938873704091787777011093003754252650660888047134772339268203354903543272132734204180304904382006508458834331093434e-38), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999995795646839141229597049600163486950487961160605966971207927639433117443286573917272952598730352586395213231378556612129809781665455673803791882078391445491798305436834690788293112765270306893834416062496422378540679879435567787167675258265803526815917323453636547446953905378952509733862550508155185660036566272965610345657669309817400942905631053083173596575938300954384335741012857888893148639864847391669179906074771423380675e-01)}},
                                                              {{SC_(1.40174284409382375691326091641536902948381353854352365243860788538397821323400194160058163106441497802734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-37), SC_(1.40174284409382375691326091641536902948381353854352365243860788538397821322941150712376691297505221433850032159236497718292753220163294157274980746057268308682402443770033257716345829685049988934416666205697588973059884017465980900504040551091151637072348559801709457371522176034711208838536663456112005139845564302752800851586255173206233829429750479632089286711032500609176606849490519569468727094188589180524908936230012972908141632433602684418792195948582158744208296995186130664849282559534747283e-37), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999990175584995158790521452395330292149934987246293181315818289498140837852990983340598997291574198506644414638962922288593792275112076522551276639205559930026303787875160133236787445628969231440689003816906777605687862518569148148349736607073003542934036846197242745708929670399344795068969975702827824659694309674652879251454493737996840612211561985346098039062629674466776090326736274135796172249813160074647258847047218550681667e-01)}},
                                                              {{SC_(1.94557624033383353951438702124371913986437597061599651205892247320811128119544264336582273244857788085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-37), SC_(1.94557624033383353951438702124371913986437597061599651205892247320811128118316843443667798911811276260782979573655043471811433560953937347381596636250270351757320824484922352524345495092588725917950183456096195479396095297149816723715887520239499660954344948495823620417694122747792675711464880383881647242003709193872670297166532991944589140423445905575281550707206772623747725383628200116441780614927532794556312983397464198282523328334749316987456840895529998261299646887219234662348063597570361594e-37), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999981073665465242325973499850572514928918968773433476252290727706213747142412896890402940728348529719295299594618859825128431836531924921078163936256958737028704143307321875801616577679750689234365062786505605378356205461533046996279728442748616071759347859462543457969102284480550870641847873336874142813399784209309858808036665885184827443870158113940056434388089580250524388193858351108489442281034092467002540157658438751846360e-01)}},
                                                              {{SC_(6.25778729623775298048262176417037819653492494267247379139395559947273151024660364782903343439102172851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-37), SC_(6.25778729623775298048262176417037819653492494267247379139395559947273150983817975401690962877507381485954149692981033327650991617834865104519184119130061428188738093774975277921899654100143262904731856281487753604601557753455546117850172891385055603321634400101181307965562370267510834301717555763528082516451060689486995693578669148903908270920118745103309628202998328094040623530190880768011165490634231906351433112453170352587798690643432435729816389805275266302654200777080302116699928186436416280e-37), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999804200490775226966111214503355373143794475289458519970663519021821882302293192082627747880642626873706396542685764556638857367505201946491497647523599633143848708648597649676052358311232218277829371003261111576758376332700582495048660141665559358151192500767632875806022243667932552701370660858833078445158658650315371959830990489689133490741796408732580215105542936306741728965736925282835297914658845693947125055548101972328355e-01)}},
                                                              {{SC_(1.08239073560602090995217585692806369173691892430234761217807120271122700572163921606261283159255981445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-36), SC_(1.08239073560602090995217585692806369173691892430234761217807120271122700551028985034672156536838775060537851211158634395935548306255588517499841223461589544558196181625229089645208230094515808394044610446532031934838322012297783463544971778652121566632444020332699464984967424106583836820627443079249218431496439763226943699593605710951086552042194684093571682506350566713599585362101737015819290889457768321375371619193837339682475558478823722791771452951524569087148988620542200906995110022069839836e-36), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999999414215147737128469167864887720746679277344361554323001931299657738560350385993270574167093724891580864281120375306410266364949815767159380406106349373771695612577895176379716706515330135955237783460936144953034420281108932351416421393064032426483755702763946710102993202761795407302174421831510588548964721554672431413244801666849243141372241714766821101374200896460046332817068614637339045853629713469603736177193274739125474695e-01)}},
                                                              {{SC_(1.69406069903391450739476895874772531773020353068657868999386494068826181091935723088681697845458984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-36), SC_(1.69406069903391450739476895874772531773020353068657868999386494068826181010907623836633953419580256640864513774823628873707949104515727247109331100403413891290300709523854457848706858116029524709018232091056506435291372700659313907652389536318026768678059554060588900632671169691115979901437413522298032403609565133598996394311329293506372714835392975912718206936295166137569549996347175694398582596884916164647798625653170932974980454711118715400166890733722244368752314502042796902887081917869423252e-36), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999998565079173994362465396001931894411364393220606475206715927476216753773288096464547196783798237465369184337707326956679899579250402430116331781856535753325581983852597538161877588948904446302891805591165493406298635982122739131855419006169860034975915041849599506141381562127259826196852690691935014842448052582785680360758805244541197319297101970723393414590425744716094952004261652430364851834943964098519682976590628698821905236e-01)}},
                                                              {{SC_(4.15747613699065532685928122715139996054660257193228334398574664448888782430913124699145555496215820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-36), SC_(4.15747613699065532685928122715139996054660257193228334398574664448888781233240714882509337727250115653085990578082365934763746608796598027817817403401461047679675712170611380828783971391822261067802809536400457345024480713629655636200059306305344565998169640785290567657819069495209506513879092612549199675733793897404446425995581237641738804282966499303539895482161907154840024757495882276282239646780995340616670801737107926048021853177442090405674446382967308057029828089451182423912906080446301645e-36), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999991357696085176628871090559479687924742457625998376218971921267372616718383844949588137456909796500905937687155045180713696605882356605141845708585115529311992066558444828324343695453901931401333937064875027623092193879640543740281736662900057499119419568523976952025817917330364180443654367979292006373325784480983727857210671247058000389980104063249629948415515037996578331323999224928160405646611251354255937726429113087375434086e-01)}},
                                                              {{SC_(7.28367983015663846905417378314883240316980135196070300998300722783440619423345196992158889770507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-36), SC_(7.28367983015663846905417378314883240316980135196070300998300722783440612983116478321067269269552308077493978289889202693267062792028217262679594799658402831534524488850105100944772764063369876205824531656366687705105223061889202677601008770250436737657307404663067598694505137070363243354865573283915190217134660161868686059432339437177299032222560991940423832159892424897426322085372898507971392663686985246163580637451954849520995735087906076886949281806248923115176051266427223525387444974822188331e-36), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999973474004065884681092335767433370237858027851321456659743937462071520016274972595345712838831068927056324434283196754695183381625754321780334336941984724512744537129286325405215594299982932720024848636604144040397744749234633858822500707447887371424947606546560076781166070773896632315222333445267419206441770719310077458761071140435155108660069240335296609374518753267631061279679348531496176734798021898607900054696705595585834697e-01)}},
                                                              {{SC_(2.12516349467652166437607482766014955572619379291278811395257773014799695943111146334558725357055664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-35), SC_(2.12516349467652166437607482766014955572619379291278811395257773014799679946580917405606737529904973622759508384432023182892335044923493007532938776076021675357752206257108287956169574764984778204026048822274447050733368944371230550045017655124033941820725414467102677098724735986282971546316360184957916240826596403661388999867239776163371097109947879294702830424203436319213220983022808349976076039486046869137974826650175930349065434734116373586647276765562985583562832443119253244361340883240441062e-35), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999774184006044713683773900470805922150932250054980379582662128503096057808845185235527786487472856932618201965360896707252655627980442148963128043654276596608302237896826278499952875156492510369808863542269935941777674888168571205797103443085578125711094779798379963949265068579368931957701357361326476145671210315141516694776450386623526577296405590662971296035440956921410316901837494666387892421775940274748625097808888274273886927e-01)}},
                                                              {{SC_(2.53071076762576381696050568408073626122257552718503248673567740389955815771827474236488342285156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-35), SC_(2.53071076762576381696050568408073626122257552718503248673567740389955788758611653831292769789020166483010759970222136556385108151865059794457635671929591006389256386912362204985190361367849653914692349249660353344507347124549418382882966230813006834337598876272906754108025215894180395623651246082863891038037258220096650540393960954745608563649602644462517562149795780631117951814592950632076254125100378944378612616648449108475867033852063670662261449078443752015576717559948578847287912367450188387e-35), SC_(9.99999999999999999999999999999999999999999999999999999999999999999999679775150531150862612324087422368961581536597039422383152126708901047347940304146276116283666506430133777448923147529348926857835369585229245501288249005852911543348998007660604853568806160045133561007206980521854122283010742632980337999371272670810643167591287325720576566145125174718484145644918457200064131979165887596637731687390351612705444505957008226887752046771682765148512429504692651191887187474974604465117914715417737883e-01)}},
                                                              {{SC_(8.64357296960196048049463886033217008510050159920791504997812301769322118616400985047221183776855468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-35), SC_(8.64357296960196048049463886033217008510050159920791504997812301769321042328005655004380652466252000805353736975177627305689102897263689458460558483905184538823511276614613879037974542294557763642845332403887710155638310471047995839486930032353911469131857519161973191263919662124863592037455099841121434453263204523757117696307125405556392707606083229317021124606853797280595140779847922679683860621633533580470006084570869328567023511427290495777006546862741888593675678753734706727091765908497226790e-35), SC_(9.99999999999999999999999999999999999999999999999999999999999999999996264432315958317318170910958737722004540033486380110083998546410044791571639359001045000390165257415777237093860585996520548881515148587137444154873492144978975716761135704715068314007809110467706034696558926322998865776056244797839299023107292117589896179835013332775610172777676182558538012867578344415855072459321045720088178567198565080237600962243652912204402124151596300356253263256122139223449122695528077428547738849446992392e-01)}},
                                                              {{SC_(9.98056233630547948377202558654806807390245378474739594717134172352501764180487953126430511474609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-35), SC_(9.98056233630547948377202558654806807390245378474739594717134172352500107213774235211520366087753993326665312083888782751842897484262816852301203303461018681653919301907168238595958554638307471117620123755538957953333151205635414773328841023242129782657905930623401544810100924035706284091402411873695041620447824159545092622198222137489682714360461036541587882003436623206649000290867227071217854957074912804962012941175988955433888661010676438557159248028493582668925712339840773429543419954418016701e-35), SC_(9.99999999999999999999999999999999999999999999999999999999999999999995019418772556025452179753936296723190620561787496251708691401075923962934222261393282794216532984558739824698172829691185955595995089041577202174812312947856501006713170529287477350411350868128826538380042853030454395774427817996996972615435833753547763126950693322514112229274794236400050824445172812668516611850872983573938547300630346487402262543251741159012770284460576903327602326016046183371595735415925160127128817835623068688e-01)}},
                                                              {{SC_(2.28583325383040341115984344956726956942648839173021717936437613438727112225024029612541198730468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-34), SC_(2.28583325383040341115984344956726956942648839173021717936437613438725121632406983133997779856371235469800960484094688446211707494308823723702511129954566803322521144774271849538557931309348505755177198991392479394688991152239758824965009950771960366476022856124052233499690226825352494698918049373160506861871032682154872340811445877852985420557422813230494867182881063793147826094622998366088820877495792124626334108720159346279352639830014634233819658689195810426400524416487075106577081762959804327e-34), SC_(9.99999999999999999999999999999999999999999999999999999999999999999973874831678415552645214136320719547515304986065715399671015948522117357521386822474945821385174233689548253591575756766508400490826265582618706311906049075954729995626366958081761228787732882417823878421236061267588485487036165146284349698162478575358442590632990892375447104360565217621089582310412890703562600854348719569212910573217175396813750336931826089876644954945470721952677819309500120155038935270482632452051218728106534190e-01)}},
                                                              {{SC_(5.42623437031930140219487755133755705879730231824934987938484354241808205188135616481304168701171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-34), SC_(5.42623437031930140219487755133755705879730231824934987938484354241781576829753192001504542670578168514322574346362411838697558294055698060256643491044626864706023229351509292462926224529701979980092636352965151156855735493539697229126183525244673254444594932743813340713277981673283478626960530386752618274460408012086120450381392347958398326330449608398379219370083483268351133688476999510593296289238728648271061550800714334372631288774732378360955680765670890145329863879353773268761484500941680668e-34), SC_(9.99999999999999999999999999999999999999999999999999999999999999999852779902791827473069699853002689009383385697232980632967935862458237014302008822313290073227392761021824999598806655046675355022913174279103879824846548509249049870612992964381556241095616833742905956965264034731825567461408179336671461735669309570725949353784032168729737514901374614918492020733323657326776972378228052939461852740662884848942182183850537408756939752311876936201545716136909239650842326963967558877840074472028373156e-01)}},
                                                              {{SC_(1.14767260359023175444419398476720241433534365304121115753874238230025639495579525828361511230468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-33), SC_(1.14767260359023175444419398476720241433534365304121115753874238230000445166746063656515559841089289105607686539825978861594544159895336596964422134771640137572553567078243138888530843580152233779636754650662243824370534098475025420547383932421683776941031164647482102775065775891998610842166179191292338275465136314733106299902048187444411004404558040659067390216180114189607920889347076280704914251579487942983549927641405688544915035199870167862655069055588251673922237588302101782819511491910735654e-33), SC_(9.99999999999999999999999999999999999999999999999999999999999999999341423797484209381329588309288146803267822324076796870775252179426174205035478581780473549580911343948996844459479379323793574583702208105912195692041827294007298447777379983852214659915146476246650306684196241377878426909383663765219628801085832023184448671086794319720603937760883119648546708413620967469776165374332966612650640592032647489688329087738368543536541785457409887376144297548884705846677582389852083943727803618460003560e-01)}},
                                                              {{SC_(2.24638807152062302597056753414010558790018579564078381747074808494346598308766260743141174316406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-33), SC_(2.24638807152062302597056753414010558790018579564078381747074808494157667361269882569441673060651915437664267383350810846419364777111420950445674141352657892653029864814464928712480345882096155199766282054160037261290793618209567223822474205025102444332810773106250060132178243200876493509840693909890022305266515863453984042974449133489686322410570709426572392159303858270564017974265942192514778239674771168343975398653578155273192682439379656676210238904588026596239307200791791903087670175397447691e-33), SC_(9.99999999999999999999999999999999999999999999999999999999999999997476870316064928124336269726622406446098767475833498791397615072417963776006183762747986076321718823234433302205664070428488474365161284533503805124055838617058588428710575226216649561390342676237713905134207296393773422163114041458550176660590328481590273828588141315198970622646050350164026489967133824488059763316031263167042511671805434119993909381688766722661327619081391469360750198917897989810671842667975179843263514510070805364e-01)}},
                                                              {{SC_(4.45455641359219790147891656069310138539319495403506917428904099409692207700572907924652099609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-33), SC_(4.45455641359219790147891656069310138539319495403506917428904099408219006244020355341019923416458691646791783382968221703942437110847236298490017165119347209547953248371396373134888130108963826910897009132512935868074403092848118118664348760003373801795767345559897877338293545883678173435890964691395009506069309003543166240667253840198108859444636305560559966548986023314855939971070573945498737110851520499021749551723015354411711372545551098465273329330533003046029281429836758805400309819773473594e-33), SC_(9.99999999999999999999999999999999999999999999999999999999999999990078463579062307755526600873014625216226284609280745739844840338725476993691131021921643887307732286631053281933853188844559271647726836118909431359129252865878843629812349803224098882677865802701318090937633055526915899392674220081478796481818247514342288829051175946144134849997283314619395790196378587070000606077549331566177326361432397781171544675801887712953061428639817708889966799537670086563002303589097210837017109439496973892e-01)}},
                                                              {{SC_(9.16785088874388950633683172059419126693105638377124253293737332626278657699003815650939941406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-33), SC_(9.16785088874388950633683172059419126693105638377124253293737332613436104518246704921369229928400760527355642289946851996779146737350255733633661964290512225435043234556399487444290802165698462256421277014798059769310983640659437713092187875796959432270158150107717786562565837537819205647372788133354445767003351222939549690095319817221458619710368607102404725417014793188796707925380868001635367674953089171550791669153185795146352256358389658293075151223426432691016855045414346008882486947094640909e-33), SC_(9.99999999999999999999999999999999999999999999999999999999999999957975255040878937656479309884424948105529598925238666019539098203884358858925757483714325117607223046140184112647307315076184737530446206798662621567798660251616524997044561301533332545638798527755946852445727867891941468188937777228366606532547501859733408033893918556168750942201731744749872794943260463802390118755564820664666033161746287816363441616184896748936552044324961750117806166223424101518916285648897331999217064683807662234e-01)}},
                                                              {{SC_(2.02923708991490176840630238442216715768751725200674633498021393052113126032054424285888671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-32), SC_(2.02923708991490176840630238442216715768751725200674633498021393038186461172686811541995622938699502131970339437751250339238625815957020497240862068215740583517496640248330164143489558982862806234162766064849533848215436080242913357931665996587857021941752158058508684563520436602915924175811991614599975795835696422654161032468437709940060988366827698300610082819892290092277729920515375436926078407908932472437573715334908580131664447785618965945457668393933348454041625387066589186615396751622114360e-32), SC_(9.99999999999999999999999999999999999999999999999999999999999999794109841645685043783972015726491288792978131514713708274780330025533629205662944646785839549634108447687840508965230119113963615379532190188313923611545568771941825154090178302130626216188195315323190824517446123383168919123080013332622969893566616492877927920852006877324669233583154264978656000830597138317838869261407433049633324695624794836488665265011978772645136673545407262195618625203203879355393108059137267873193617971618206698e-01)}},
                                                              {{SC_(4.42248951544894130940528341232594713442514066697910501274604300192549999337643384933471679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-32), SC_(4.42248951544894130940528341232594713442514066697910501274604300048388534828291368248000655277014127617817653398762581638618471290886802883726483863468949945059593381263242533391933794414525027070259790107407224559765775467901539274939302993231312884256750489422970198786159487386816526747486926456510926612894986997421618922394129244673415939823811066890368994392267277208762239811855012666341819077599352572997378141194070253849874766309784441344604549424903684138514279694274951881061702927451533603e-32), SC_(9.99999999999999999999999999999999999999999999999999999999999999022079324287209415370398907373981182933279508453789790467938655245533487930528343294733428329788530035987276746814790251459059570475803121922243235079973116073514685919176080150643624530110566284954847483072464101496311828806947357045503519156870663380634223091627304382316385761985476332723633210730619607992350388299054957290493063137783934349241860638349612314464275086378115025201466548731296891098091234203131949150016181066415051698e-01)}},
                                                              {{SC_(8.42781959567806922798262160232246372270599330117093160585906019832691526971757411956787109375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-32), SC_(8.42781959567806922798262160232246372270599330117093160585906018835004232676551216143003605835844772147804482341293060488809656855003982170735014827047357433688375956609359388189092785186417532268577724207998474793422062770690091917194630921025260130856747865767201476228381150045632490922495973100197965054663802088799118777412336195112563548331738071270545429477078683972801812259741537598080482468263547598192155653292206810106055756883930340550445588346208476969664176558588870371296008188404710029e-32), SC_(9.99999999999999999999999999999999999999999999999999999999999996448592843135237286091165040150796849379871624458670791989980554559338381716042829887191705426916341372304104795261882687098993621618405551393901151195570801163017101515947641613510338321872649883018859071285949307351409094849353881167676920664229923088157852833707315319923101074787754717513588395159959367332602241142957127421028949816954472640924253155665536273295336649713952163746432483241108913079712957120243617036879037622622538037e-01)}},
                                                              {{SC_(1.89412859041783001573039493180153157286866659770869884826804963040558504872024059295654296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-31), SC_(1.89412859041783001573039493180153157286866659770869884826804961907957016457841277954170997663148947571036531047064431642805896330034930759416956199694978572815071058666731651254768105525868477310032596108285663712491486474491896466539021451298126209786462442787863272306809927492774070601577999434654525757637079097488311727900888155525874031426502421362589400618004106762210198078372938517086882765433014405633112910490353995497880955390232007103552263077517753158222400047231218622431738026725272418e-31), SC_(9.99999999999999999999999999999999999999999999999999999999999982061384414808821713576182666609878039644939897865544835638329686226491649739125933554321013717333433543099378073396608435514337600944379023047880002410158175418957761934774609458632133813775338538191876152234049430980809741103774734281423982888311235989789454329730656135971743728618766288067162172679182963181306945338676336790805660620388426574235413302344008441196805499833894731982742214073379793623068582638800144759140434822835913240e-01)}},
                                                              {{SC_(3.46050866712583180197896586726244593923755962967554050679908073107071686536073684692382812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-31), SC_(3.46050866712583180197896586726244593923755962967554050679908066200403792541583724962851495560867343528889054708442883895437380069508042546263121005899818228653002696895607035375445728524805997740154069184308371395573413789830700635471324814652145015259054050169279264095836039055979403561200832628862682451061731921571819799737972148041901006837971648529611564412861696678853896181077926408637564058833153119920148214522871342104651385797073097865150211968077592727269349107621909741517960544590382880e-31), SC_(9.99999999999999999999999999999999999999999999999999999999999940124398823734995141596440434464974244751219327466265222844766372889104327611054096738756247812175767192010639298145667851662065738236651240834717361592738914549129079886068280561353392857420537536300576737568342768883135775136819101106849626431205672726699464031722219512428433261205505914094665663811986532588686230507896059311487599466477815387106085624087151762903302249300390003946296093093177327727085105725378839624124939177394646318e-01)}},
                                                              {{SC_(7.12945223095754899355092259734822137087975601614812590223202448669326258823275566101074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-31), SC_(7.12945223095754899355092259734822137087975601614812590223202388272065795852880530528435299296317544556995760601773638283325379911939903571836900644291057434079192040898145963464340595581666825670240485504766212435730089156718952356796619997620039045659579302729635035567455305579146178793297109327080700792525691652378010535659270634655634013027160489309630069697235358853454120303144972828027427254757612960692804314735367184926239135471939473377997839560418095284241361294625201102079699096990572732e-31), SC_(9.99999999999999999999999999999999999999999999999999999999999745854554432472137421356692322531386578841747106553826521261980051976928390485982266924922342534221178591468128649396587806039752619666583832562943361036177992729075795731069740929600978682292406399805423201293360461699738011150346793081043613496064788228338205920715197760196407916778244101828803632524670630307241142534473468033170125491021690127096505836902793573414646811153356864292269712182133970687352333716996429072607598331767709150e-01)}},
                                                              {{SC_(1.00660609334360197519983437147660781896478392508868099364249815153016243129968643188476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(1.00660609334360197519983437147660781896478392508868099364249798153858080936425448600591621973115560627855028065799333409897140200148885265679992467534852739850747222248848665862299107073399715300687099710849976158206422869350105977308451559506740322700159209742272248262592820712485642826574623775858899478336761127748047538148686933386140802062852176507997090596741478401266909560861459265729175839805366572371876499841116246530566431597941796152044187875578150097604630566317951712723436689304568110e-30), SC_(9.99999999999999999999999999999999999999999999999999999999999493372086421765833637980670400207365226394547668810490027357326776425074585947177784858615439332893124808170043124363608559227850238712400015608276209944227241371157871528353635158551830209899099887818354190139598879685295083420474600602830379027159206760470992231414350386011266309174227316415267053139521691420556930484870500945966743591236097202666761572417847833809770025888795274828592890925562550291716301144729756151134542208118283223e-01)}},
                                                              {{SC_(2.69123732824149938499603597762300694489537414332350206969124428724171593785285949707031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(2.69123732824149938499603597762300694489537414332350206969124103857810767495828489737054207251410808681122731739619467712601906527210049295464295960467277692977312706695955670199037202229435671253476370879184247206949097764210253125222013745966690247740273959101002078101052320702153894889859044028323293872207281921255575141740576311042337948417604760956103213467396410826888372613668017898457988437785165324322263668128076427321715842253774774380207618971473886124995752335661990322188081682637137051e-30), SC_(9.99999999999999999999999999999999999999999999999999999999996378620821539778048380463868513259194760492255182104854568796688266675419704926830251200252632342648903096548444973065272476104135551570767481529019631860487682694750175649684483265805174607079594632937085836760739509644610706339030789270993126743782828796190161346910749433340546847615059025085175720807259788804205543021767204242455348546537131091713872864499858332506952229596524693375212327814887803800604671074080458111672965192708371657e-01)}},
                                                              {{SC_(5.30020735520228274850637769744228460379981918842995369800519256386905908584594726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(5.30020735520228274850637769744228460379981918842995369800516774812330799508872620617326099181025241896326476412624958350438975815287228970877366059626972050598486044218179842460188871993307555735477910166154701843990230147811148075605205091149734124143879074762687642121485251530463684000397680784373909121287180220939449768835664018563015958901955939555918594959423810252278527245000330437175671279082182637911185388106902742727326345838543927260707806207862430587227020039893101942369841931004649392e-30), SC_(9.99999999999999999999999999999999999999999999999999999999985953900995929811476056422508436791230644190302525234876496203862361441479979240671670817582863831522397601477746273094063148971169325819181895476334047231053156486905486717389993270360728698723956084136276022973880242228876164041350147859316688277903051550256604857765735403446100822161708518544520756766090021113367159495627025122118690418451701542634453971356787032615030419972024177419316747536463094706047989637284849247688069026501348549e-01)}},
                                                              {{SC_(6.32867200109829532437439231857584752559277676327992301352765025512780994176864624023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-30), SC_(6.32867200109829532437439231857584752559277676327992301352760800903845619423737196357325304747879745252873925358692900533140087584092061056776880998418078436771366792172130615694441224553869516110696285113308449364458806503815478080022339617731335765279640230991043561567239417391539877766804593198543949855172745230422656638678997874589593384074934687600773210894288303473880880254886959958423405253748955161866378820004589056363559043842961556034121326086780978328676846776257244124423169029634234790e-30), SC_(9.99999999999999999999999999999999999999999999999999999999979973955351257249132297739506642628067608253815179906562758766893326508515403412089617957779132649053803366485188789846458854195389563078655816683639618659725133411639581407050701846126217909940232813138092643766517480225563453507972750436168378046481952469724013530977441367994976024552595817659400560646993221229292530320553163338423431159999401088147155330538375065693349415455291381281036874541221154864146711221686283124563061261693337961e-01)}},
                                                              {{SC_(2.08902732172766892127202343465273188850850078629450834455383301246911287307739257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(2.08902732172766892127202343465273188850850078629450834455368106932472518003442533444738013732972172524170504867713481295574699984488179497595556954982281159191426600611772457907280094472444446526906097767318461694106205023057515992153019190053074846913307319672878369674337703391926853006361756591941459322392837227726860734677796478409587068863467227336540796851320837042413120494689218187960655610792406908260360300781784460111226939154153768203634470611331753015040253727623101116831042856283118737e-29), SC_(9.99999999999999999999999999999999999999999999999999999999781798242453766122205539394256558981790035011916738210146764717850083017498869117986917334140105874547601883683652419246819349707324007233935785604229116661629866992858972496907635417802504686787088280017984569335880144104083641246079269870478846963689107325438580421100904625789353960763259740089364026058421956654839479843921798486264811522911491001083265611400386002109215984073917186677818137057726212767013088500337178286110333927786429660e-01)}},
                                                              {{SC_(4.31842364003957104364921550167833797346950293859213498848248491412959992885589599609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(4.31842364003957104364921550167833797346950293859213498848114269172593077298696397899384798838469892604707488011054598848283893536902678591236546102866040861584529410483678727842807847433276833855057760891318416503206022097303343679891225538057159244788369859928195264108640659876740964493397865972409304816791167231373348176915544777281551742557768615955019905703834857959520663077576140020595051789049976167763123526754999503968171424626064916365589309758779241063972711828380772013755486183258900870e-29), SC_(9.99999999999999999999999999999999999999999999999999999999067560863257369066964497297635006156021568522300783335967250349740344844534901319880357791301580333260447029645502188247052834316118747766647184283669573773641111448016551204104749489651931198788083105585218464325948673207669756192754134996490766498322067651248143532506188091467780057358394263396564140986264242252659898448085877812703282546394684396353711386913629178399462666156391453909336437084126881865332207056585053550245704827076211059e-01)}},
                                                              {{SC_(5.86968798787057500194131613525764999377749863741782210269093411625362932682037353515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-29), SC_(5.86968798787057500194131613525764999377749863741782210268756362039026093347106681700963005204298316540799263712160813295023896788923210038131231729359910124024765152092781848816743835790982793322692254018995150489459244698543524531669960364412839353464649104249374340424306627305738083722440141133394562858285415561309401781003468538863799032963287355962286330816653282615903419003646871305120817164223024587131178361020150902537655163124117909209753651581353015255478297486067561986868484183383569950e-29), SC_(9.99999999999999999999999999999999999999999999999999999998277338146252394028444360458490634338533730868520104582523076964233154042946023028494376942979900160655182099281740037312428247080456080860951235873560774799992734471072154703739778110386566354490103567627438668795477210527514123549952245254446118613994019388628262616959375892007364702781185996020488769149346311118578328013836346363736051454653074172300840059947623326863459329086865473983250909431232338050346477348291583646141405082621767203e-01)}},
                                                              {{SC_(1.65997635243685806687162489251543212019385665351167702397106040734797716140747070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(1.65997635243685806687162489251543212019385665351167702396343690649279406622208185685772371642042635555657583382378567496299367580435665007816699412063990899032379692904556199031912037097150817151154762330970404285436867965385550288164480644118405526519591867746797880459162436006007266307611893562468623609119099257581069356747154476895543024656480280895695912472010571599599251032231654652201571896290995321311302562791814134762167132281252046632937215018876055369435169910753443600501786404783549568e-28), SC_(9.99999999999999999999999999999999999999999999999999999986222392546752119877172455733144343422153617716843213233849865061714702604533008336989045404338076431604109019139656871515896458952331043568257115104563145716224299069433954165917783579195574952398453239275963477090613342763588712548617716508144008331395635254149169622982507056455120676580525624478841644805727152863309836112876912207670086636480279108601885879827013844946332071421481944537385339435290404473361071594632126459317753099739416686e-01)}},
                                                              {{SC_(2.25979760396654073712664394284379480891595572134011860043756314553320407867431640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(2.25979760396654073712664394284379480891595572134011860041832968719355876869835044365217455203766587679052924363945885330138781175699004356886326461315878508574607801535429369621662329867639012659170124626841944542706693024456895004571467368859613474653967637621966840269279943579469768147537831957760369296897132611902967456488220425778743950737821192336748172296951691608578178031434568917471992763881726196647605940577327234678663760031433853057319001482300725159609161191240732209972248840097545236e-28), SC_(9.99999999999999999999999999999999999999999999999999999974466573945535407540722564122644653730270335778455508418466529045718513922718886100912534895818253373538618832955035269339985226660671223323808402289012470979235802920473617365901795722590739424739236939849121464098738027239360011902586924503160858852829389284193017042389742359089925155636590521137424815290123425666004266451656277708781560088189215777182758042202386192993769288859261071925760207238131324480206028779549590623894468388349431566e-01)}},
                                                              {{SC_(5.88086945564520119649519587919781243555710122106194859270544839091598987579345703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-28), SC_(5.88086945564520119649519587919781243555710122106194859236646894415357551059141397023458417833062577359029564844162033204609590305835423056545498867121176126632793246793268385945281614118548944015360500160615375605964890179073630375449490595805026103275679829933163846946616206245364280259248011174962758311505159562522228739210437400034854052649377248021474372845818354013318994192752570529497471637831883781636591363767499659621054484652363632372161010655718223400880672351441357302327184778736180752e-28), SC_(9.99999999999999999999999999999999999999999999999999999827076872228296574784938072078042987632777779373212220013320421186320701890213115370714655904269996795936752835087158978849132030314481520851372148162220392252024392951130066198535869599322556283299011074244533964223971169725705069975036856966893929235747080621358676048032547928046779776545537078204166025672077226387013907373034921452470080143973339745452949777298353904218157467268717719840861266286404603250029803805345314117460010988128655782e-01)}},
                                                              {{SC_(1.21036877729163561187004806421015787165206423897645393594757479149848222732543945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(1.21036877729163561187004806421015787165206423897645393565204457912911701264816571244794535317959218134225014169958552523736788409114122297436868181226815279034412881321169642223875674097709647855827604375031824358241944144366445573929416470439005395503117973503734219418534728301453626181057303958103351724877851168203264142250990894413861772049242226503921506225025537467821476224063452800660679037557087017705664155277109587372310479616565458246051267877346509591647754710506255296568393163396173146e-27), SC_(9.99999999999999999999999999999999999999999999999999999267503711478775496588677576535325086227779597221002886707252402490327884747951115784517104936932808165900808724915631123641727203222861050150147651933871354484108448566090657978758580039215062735042774308027967501555759664924302333070164047939619478223553520745268511199171340924464150362396855520866386718959618607407989478385259566952042271426836234189920618059223328393025465752381963814589296901671905473668692059934918608470334521245869322388e-01)}},
                                                              {{SC_(2.86591780197233630096266787463117576092606550441921342553541762754321098327636718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(2.86591780197233630096266787463117576092606550441921342161222222068580800966682544137566943916529202244565026849165917689115339968634607993403360769926559200369755774662937525267563059791287293737522918628091563802893224163219102022651770299219230186791956803248299632691991093629314199684333347897102830548237298315010311044730195485193084923892424338781964874235326160341226843298953815233839005737913847063012077767968705624320802625055333001429140528531401876618817093286023128173313511518783122757e-27), SC_(9.99999999999999999999999999999999999999999999999999995893257576169026285539877760558795157391162603540944407935916752527193049445428999402129117183211740466656201917911860186104101449147091696064423853526679157666560883407610819215488170224094967395802687764835506335828313831539244774700666124123869631956899323558688233804969117908091547146856294231360568401947557943242277643217697037895388293183516766769220683181080990896035663431905961308406527737489186974575173159921544827293300371415469682081e-01)}},
                                                              {{SC_(6.33227430861452581999484454611910693827255339205528628099273191764950752258300781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-27), SC_(6.33227430861452581999484454611910693827255339205528623867446152256841631469412291633417546931889160651496054333610986284102110667946485950432616582676312411355058576717839739682518159345923185634501417664843880718577905491906539705931182725375625919372975202996361570514461776634408433338966339797977448297118474782218211957190056184522273280748144857873967637259418048395430304299989325085162205248868175909572286327797137877060354856008237080835087356877357082257080856918051114008265455655019487099e-27), SC_(9.99999999999999999999999999999999999999999999999999979951151040230214506255192196435889986395782955668070169865274515021265153938340100074828753410630959573723255540421525879853083440370617587321442949822080689241095717596747689845651905140383728830851240780714315821784210013927509314368353073945711513577750238180546786612592987994333639727450312140879771130424423234759366739932350666350848077167008448715281548827725389679678867019894421671713832098020861648755429255119400453235121566672119643836e-01)}},
                                                              {{SC_(1.01701488645048351742362491418610868671324604095573818085540551692247390747070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(1.01701488645048351742362491418610868671324604095573816332343711105452574091957492464881609874155310766863692744462832576724333201541154072346766765699382330455449328670000824693475330729476850648504622116357428393638924348684334202734614590150864624972747190059777114682884495479107547683836964389876682263545801218406797696755174002666675010845868456246670653754593640444430031302545894854186512936706715445970111851394306952403843392018334017630380881701135995898449745556206987272254860458827723014e-26), SC_(9.99999999999999999999999999999999999999999999999999948284036036905505878106539445707420537760789527302038597212359467142829365208706753583480314769727080472930841251769546963351409456940449361362239231140121358175313406601933249214221483709738384955034161941181642229311966635264585411192939606100913693988068970849472839854304825457917976633971331888622416264553414786998678093087237386348505398600997287141943187035373529035889477280544420651863692708964270806259470409468261873182906215372422322967e-01)}},
                                                              {{SC_(1.73240757319454876321712945561046080415745773706248655798844993114471435546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(1.73240757319454876321712945561046080415745773706248647133238368517372669601990330799556402527637951741269169384293128872046197615617540226667834356423933205107188427326680610133548185919626864593914565621395409502576131328917183920809007874826137124733497023570796764712055352074351571474372289601075075459499674205118343075830673541226595909902574436976139978649084117906201588021595106776245227150460713535970276671005189606139692578545494385608927634920188540193618266875767223076936884045301799348e-26), SC_(9.99999999999999999999999999999999999999999999999999849938200016908708476593647714441301333449917232983935589882430679475416544954876348553925397810778869587095531333583024361182841302517003625488202943023609471017988004115329958801794805283413883069329219120736694877350703706015755371121018859116819175362600531729848030448359027909259268091751758805481267322816409703379926304051989443909674842437962170262660244896591208386339631691590295468623127273625017019234604902092688257738783189975410798798e-01)}},
                                                              {{SC_(4.85130351485873938948550752347723088770022059623698851282824762165546417236328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(4.85130351485873938948550752347723088770022059623698660989265579405845396658976637442438125095176181951006434441217066488647145239434103050209020997217669861406942499104808384488564017630082119257664238877191868992490954837514807928987158262879297403583333129860768534505794967430677313206771592868244951747851027162098997296373643704928156139018724130712676417846050295071919943533977576706542066029275753906933389163939680811922115873915597763149085735550761292088164447226954970021899306732669714194e-26), SC_(9.99999999999999999999999999999999999999999999999998823242710335962048381002602975450120082698125730821275809015238732858397978522600912421317625034506185283381041247245315231181192704687177080652677909957736806277323440788586701520356870644612503456121454600655994784709816767064317307696249210126595367499329958169688760532631401384290402120831004217069063591636817019515117344034470106663201743497588043798600260081810421172904526658043913027664092737590681657820960431067605822773898751239148465316e-01)}},
                                                              {{SC_(8.19564111209312229576920614539122222344177948194499094825005158782005310058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-26), SC_(8.19564111209312229576920614539122222344177948194498177343017748383200491809918243048394658985146309801342070172798129317060732100471869081924638003843624841659291147365005979573125412883269496938888583134207844882906967296703010454542313998295672651631067077118755715916679489586784469054418026434594124039687091670610435199200304712425457430048065297796755899235763622284756849628419660523825486359434729527454908615511257896148281635239454700199639016349821193759549082236859911041071907943324237564e-26), SC_(9.99999999999999999999999999999999999999999999999996641573338088450481234573457024398606724972860597787690528561595250368010475731147865565852358362282402377731027222818029922533458270416761219423731258201786579933778187649172980926082987949990044126602969665006020738715662221823288423516963711294782279533044098884502137714956876894483635745762291452505629096708868676483888239131082349750859024725134237454070937690955419743758388472674956943081664624739705487388292808532654231504313310874444108604e-01)}},
                                                              {{SC_(1.86960971309704747834098596399691609741197662053480144095374271273612976074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(1.86960971309704747834098596399691609741197662053479054910462327167331615239418817962503081932931890340451634960464660216606441811761316234081177905303605337200742387367688910565800341036275956637563852160531953554325135475392833468257948608563494113749585234371551757071694130223915334283493584239200027621276364767514754042741892585251741381911793055254059951345608157552222810997419824596284086600442530807235414227929183812497937283829173203837683555094044436168127344942265592102254286969191292399e-25), SC_(9.99999999999999999999999999999999999999999999999982522797603465879073668264091885252923350791268663373238222024647977933941949502217305685050899028063005846531020583588854912080275336499194509169417049847433982967267356038709929706560291564375320329012735750986169796551989634393672397269192191279813362016633847875037003261985025832287816083936612617230687954205533933721331308570516151542799667874668414065625948662726592275792037922673887795272658210791962804009894010101881541472393674935408472853e-01)}},
                                                              {{SC_(2.53078312700865749726688023205126403924331013328696826647501438856124877929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(2.53078312700865749726688023205126403924331013328694125094200048076230080016126218639853303928255377939259690268714396613122787433650320374366030227782619269823933735767013246863110450196910284239084879826785393682811763209776116521693720560912939421095526746825545988905306566110534284089078542855109778438346269505715388785102546321876470210562584375169773147320543891026884940507054819007154856530305963667169008200395231091814305437937091075813019418756767568761605780308796701014080661492368159784e-25), SC_(9.99999999999999999999999999999999999999999999999967975683820241406874948934166653533511172092156534116443975462625617239327288391590664122021589352522847665373016292962519418353924774489444379168931261935483162281553621603433472072728977349555072109712109824679883539871447602535796929172730022419399714416003150322948950527704596047738139301910101594105207474101086184045874651597158224030689372875979961705537903665460088130392611988152756381550782800594641836041649779034851910713684757134469554580e-01)}},
                                                              {{SC_(4.20941306621815835944433538670569070264115829616002883994951844215393066406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-25), SC_(4.20941306621815835944433538670569070264115829615990452785496578506081955278927818933546242324234408087507662277600473802576457412134611750078738527194410669419929668722322908268897559932584917418004310810500892339693081122324922113982951012729749899983238419472551739293314611185990890280330838588407393840465717473935700337993507898010621074737807869345998925750153486451144321089261659824774170196857387514016640452953177352954598344864951502174653356419210290498586955274100732171430477016287905719e-25), SC_(9.99999999999999999999999999999999999999999999999911404208189759211732740935886171809403395266911806078856652711466436054573598817523340373110699177394159623578955057382297355014218133635413780957701638933946157411062927243877093033139217823648280095519300316420682551404000074847744014121081615342707317521112431516941533674300297570189514239618931688209087596074231043314980205424667058883669569048269145955246279078436197081567963182117436875444286563920537464570946709214553473195719248157805826855e-01)}},
                                                              {{SC_(1.44861407368038454520845469252141317524629204882558042299933731555938720703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-24), SC_(1.44861407368038454520845469252141317524629204882507377439558379548241143060497886024742974552920942134169066357766969543557906176014900674357628857983142696780673746415247742955494485041233510432503498990662670897583220950378641223845696741332846886381559562313740385981778631874554601554942505433775616570972824832253816067914468693529837886615045250367325077108821183878776735677428964476732317113820955012707665146207822278999507004827271272406590842128507252382490865908958483246235481037761488907e-24), SC_(9.99999999999999999999999999999999999999999999998950758632767560708027866249151335156844582811589392427860365058124782731991642089310632824187653159631590934407076009545286555100782968710117672092259681922314774131655526310297215642116091062577441465725300669936944717371937199769171206287422313565977915692312983930643989022024956769092957221565563347010333758283732976918733369635806586213023769317382137590042397624049523931052552394023183946141838267360143101307042809763499173544335923553929609545e-01)}},
                                                              {{SC_(3.01299821836738389893191302236946692641450518124202062608674168586730957031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-24), SC_(3.01299821836738389893191302236946692641450518123746188030755122968582984350853696020509762314198657323081151588680108336846788546232411715077963117750110231668656877141980560982390492028458072325781199487427547774731142002830348058895360123183367536673133622884929051386045183595019288409884649664003307670889826073917169193783491732886154383548786467650171746923041854625144214891691798636889671240986472559884025759608696658369677102207417841369481807012979833164166774827934061044684944062744673202e-24), SC_(9.99999999999999999999999999999999999999999999995460920868057485205128768495672594971913871863330321340890939584043333958542050402215331205051475347664198466408074500213177974669224638083289662049237142284601195838742716676332740373469330245058121848911657687577461695268645535074585543539333588005818218743916760513910839394682596564857909507975555965083387737997577009316309396894895609075395636625325378660457230047137085278175267168516376809105349281309907762284048847679978876273402954417505488514e-01)}},
                                                              {{SC_(4.15276102030971139663869209978990740955717697602267435286194086074829101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-24), SC_(4.15276102030971139663869209978990740955717697601073833203741542064934510510526957950581204331883394005715948630901471997927439830104941785824048551884364735290037184153144384976775028148587726371183017979938291113875193364207150284386535169050781429892659177118027944006608871228821244248916843584207889779509611438747449459759079063415836045186956388107365399108205187418470142097577403806506074170019542654504392938836798968994724336717205552118408671854359307226530571092950101315722654561248196480e-24), SC_(9.99999999999999999999999999999999999999999999991377287954098122384541119849606577690137712663052237626484886226624201275179099557875928787292869332016691331690451970323191229894147818897508450900230579748333236740459401315242524613097017574548920324066573787146553420482969984795794990966084403222750515621558455241429579692068429292194601611839618597431386451583256294712361622373650212144590915969048413769735033165732778792781611903036592449421019558254266016509793355137641614746928246864257491767e-01)}},
                                                              {{SC_(1.20493139018354050396364738592701673636220505159144522622227668762207031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(1.20493139018354050396364738592701673636220505156228870501377072546140795785448934637384040780928123818418711832097125695859823774786298584802644665761440524674007808622689693328364348533020413848466175206888319008516841831958103380116912523837504422147239730460369364452006526848629731486262997785608581521207131727962356854878661708837843815080362453410963071299076782169063239102687079062367604358347170690882963033237329507516340046341643171849692271577906500225569305343548250042626451511137175974e-23), SC_(9.99999999999999999999999999999999999999999999927407017247518023542093828750747845440983680844635722123270981180494686023648655779582416049950013567041075891205074926299102616026352240680612367089833234497949938042589987204061624971059683439238296677903567701771646424710727595867914797338473188745190462628716359293458300735139756066056975915457284798104540693807472391874216930264612444057558096322941234802484276390976287104651130487501202428300210798836385845155461653897798462137129023634158590048e-01)}},
                                                              {{SC_(1.99311766155840730007938784094077312725179496055716299451887607574462890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(1.99311766155840730007938784094077312725179496042520139764883300439646816368720456092676944471103322025451567911795284173614337721246228874587063409912507756393062952430611259118958267626461375511088224904898160946614122052834853089132640900055314485320719145583388248429835054532103183976418847870032408144871456509905573547188366856627559148136421454622564586651099490169128108968885059694779125622376422565777874605339289879857280154803293613940677047193724163580178692359761986787333499982011811429e-23), SC_(9.99999999999999999999999999999999999999999999801374099359197308752453603576131047516452927368262379188764120720199355009182464606310796438364009611630012891309259500469404587018398076111559503245120051103061305045948094247341241375812558792771202649745420669737550570148968618631069359581952924771812453743995708795765361659351053384477330821156187950952631834801216235080165212423381265856687853670463014423100331979948561859656233260381056967971933208534465447750912285880093439696195128696304586474e-01)}},
                                                              {{SC_(5.13533303169498441896371390810640406021647663692419882863759994506835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(5.13533303169498441896371390810640406021647663466707913784420626786848577539948342073166036025847669329695284322217298918716071238698651343415598538250431670607803501970517843218886621847266716883178140747653725502209568774513395235783269558998316168037717740076267726591747242174767979952117276381002699472649174616077021164949081299164057659469591297012095580504483012733964983651613576630595686881098039543282200671710571050264000758620846664833057717433853732634155777995430743343236699023074748072e-23), SC_(9.99999999999999999999999999999999999999999998681417732679120007652379550596591905492960756265988856401363474370065856842250691051795682600125230378048035765792891449165989441598706811070177528273711549839200259564336326789936789663320974251530646924695649992972236365657484978287531578871981209060244121480491480455181587957340654196842168225043432465945367410684908910349873995251736646698623346087505106038789446124069111779751785632824564972863033165113004579223400794734193596445597759923144733830e-01)}},
                                                              {{SC_(8.99483690375495720736892890190099236757959033639053814113140106201171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-23), SC_(8.99483690375495720736892890190099236757959032426143668731447440639681167212721719527797171146780064711290139936822813266107297096694010903437273253094169778604003578411890116254167896394141888066597915323804162041623834369780877656788545758984751109328238605945538232424708584063182474390962559554571796521681751272081700883661854119875893085070506261886828332864936080100484756483393062273557319802835697341546617168723437273949322628005639380524256721160529017905511793830342834237004895799326242479e-23), SC_(9.99999999999999999999999999999999999999999995954645453742396734618715458511854104184495562420188515421533916537429226097460026264036467110741766607883632933956617708518701079643688565847361956144214137931960590472723950498992697567682863075293755919249786604882766977536693359519182877477328890563527188345220444160685396409938384931861947484586479429357220482338242240751400752299436874559164364125531924378724032958139179940023509176370945771016673914300929823722007356528898870479147557517389880506e-01)}},
                                                              {{SC_(1.49571864649346833307485258625357804618261070572771131992340087890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(1.49571864649346833307485258625357804618261070015073920275828586139803697397329298876247049292767823930721928664646280396175986573307948574603167029053759708351340408089861830842252368692479328806151926456552410054517442049843084891325733155703329349183805644836512051216479326535756519496287734545419385841272613869470168116766771158038584407332321007611244158281808509334596772913678187565743057031292080255305715499421711913564786019743391589274653289046523695017001553101130979725615147741949041976e-22), SC_(9.99999999999999999999999999999999999999999988814128652658735548876489751653632066463267199996838874546485861024170068076642439321865577096911069193054009247807397756338385789586245178053759530459206338181619982472545153142325507508933237793989645350340818618149342431112261373507784681306094710396664115931177436350260577400393592421996537588766274656159350651739114480607092171421786422551162853697491835876809865771806493320077450117619067382134770625366483400794642466254424303591567538322745697378e-01)}},
                                                              {{SC_(4.00414284431856607422728851794317683765456195033038966357707977294921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(4.00414284431856607422728851794317683765456184333195206973700974720833412827561349111534903317556817980656128133092602553419958729122900514959804969013869789265787235423095621762770597973981276641935386442897542439663060611413606555088682296544134840138357497567048333704772308885787535702653546815581320437704238908588978564235210861558437389754925738927476835434441948940351078398962913317672503714060148888943703109003041746013446735945490894076945108816272231149038872655535603285151831784811543159e-22), SC_(9.99999999999999999999999999999999999999999919834200411462117654908876795301697180266696942853917756660287008811612236377008009142526634798790119600335365087275113255748079314394274449251893378218614737201859271607325227251618933738225971941576528112220435253954268170625581637995387933236258130147349469103017765108522242360528131339039562505036202933980339528694872687238244385449943371413059087702123057738972040998513745694679298693657755065316883784332064415470726309308364222995539698254590438048e-01)}},
                                                              {{SC_(6.02733756338251593561397041623819981204235318728024140000343322753906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-22), SC_(6.02733756338251593561397041623819981204235282233702566913401486791426775103687110889263957618410039087048941273101200938463614468150120827800477838018770842674180469716485597405584815675135794066416744168771828736855620073291330239928662617195730049089107104830809640584583111672877743068233572354141431173358317923356008888890653111138300825081984365317849191686467019463412431488925669936662236278811783071074301446313585328727814832562767268810726343613563857416015442117253317601957010597175231649e-22), SC_(9.99999999999999999999999999999999999999999818356009485190578482546674221374375368594114174739562163693168458498108577433869958984955063014426674897062191529113188079524114052399013805667164356230849740333628262774905524309526854466619324671312571709022034295074629727972637948818437287458343367815594474164798876904156995774092308942455185318540096020442411397041128497181895394926057420958628716609903020544774920207736406633265904254545071924231990748168185969288263033548644250093223918969099078529e-01)}},
                                                              {{SC_(1.65958441830993022957262063472871904679095678147859871387481689453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(1.65958441830993022957262063472871904679095601966837716399153948392276724593103434089562172080458838515273187060992126227997153192115202457915692129454356735235073605400638134357917784912674110778169847461470040894546633501732110449696587200201476723266357619796046417510134449764621599988613996516194544816998146347299996219407734259110701663299055122630130899519332113285313562567033295883655605951290101055589376890732579582152046564923167765874119374947074868067671814401094675259499614273388721205e-21), SC_(9.99999999999999999999999999999999999999998622889779251445258286087621577479547730371095511636431074447800273010019756467107497424395835806730657399701787227830411590271458867465739237101448115269271934522847684554002785566502858274779864682062462477972492848515295469837308173201281626304797879259332255094869310728677490420013760396455577678362901935667125091682248666889454008184912936448873641174478629627505364119977753174642851612726858065476553313586172210586359118094844336594068254853430507605e-01)}},
                                                              {{SC_(2.67824441797191267011934057325206470778766743023879826068878173828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(2.67824441797191267011934057325206470778766422840064870362843454282670987808803755436755298645156076250838104729082319930570856455235081015866539151471601249584165034579417886690930391378085994351144416093816921745155989539888869178642665734024688215770730792957971897714485926300053104010312217702497787762000600178131123822923068207178324331870556717556692047768757211314761404695899857873185399678411750902389980370316784652673933225122309449058964813115616837222131094170241529694767641836586628848e-21), SC_(9.99999999999999999999999999999999999999996413503418801145372469006266796825097449079547965742050312045236434812687615811480409477306286249752257313861368005502632923824453712494844206966792030996008614656490931107917279164562515860009828987762299164627454998237092918265924072060166259081213225845889343552482167314807271969366924784558616790588874124263514421653083849971429085957566186712099445800428991117097329072977627279324265465922751250506427025739354053214371066179711645306025175538222679648e-01)}},
                                                              {{SC_(5.24216989034958268735996849210789783057862223358824849128723144531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(5.24216989034958268735996849210789783057859822414858675259055095569448734151215398339726766096146349230311025214806431942041459877604214955154666281316195630230528893276830669442194807933628997209391753590753098673586783891123345377730826919565725420391992871094492091262542401201132150073945320046259477580799694273254959986871822615719799353804620716184323201856322354973907153381511764701918797819267745133531796918951528706196881213538080733436799921765950225419130205065909600439051039676665358438e-21), SC_(9.99999999999999999999999999999999999999986259827420356122112195185551672366624073250839599194457507453628742642408825539587574321988663070531346665091210332453377213607635910430558804237795524086420616498779687994004617113416213076016284649087888750760030455121073468191914791665942367281561547327106767288655797810569336941648083751909818487275941957413272284668887599357964225376383967099007378119631322072540336535338653135115635982689717806180965476057119726371592548750686453644217463638771365051e-01)}},
                                                              {{SC_(7.84730091257718428828730593965756767715902242343872785568237304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-21), SC_(7.84730091257718428828730593965756767715894188380156124455910983891034423640868297767263887550182849297147132094175148945302076002226638259291036091716141789071639833073009348733004619542248113421569210924255758451199583877546268516634378160445786592474784984436341844165522203578314841448712063415108370957352428729953649018180131244898775199678867336912535166488038811707208498065945628369299057350240961931251506328297565689454548369226193613688346870644768191552015883873931768088354532679931063997e-21), SC_(9.99999999999999999999999999999999999999969209934193732645335964382330379290253067743257178776587771145954358465579435678655286836941465589087619806854778963332640469273241540043384000734386835119884823229777143085980583844451626007518535647962371164606341778086677564382803208102585069159214424081238283097552554678548608898040886644227817986624770310493880047109975878179083799382082128737216670025250465946842362679942603966581060757152365990866172573014876004863001409841826665676884523747998078108e-01)}},
                                                              {{SC_(1.54312352729357272495300072712165473376444424502551555633544921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(1.54312352729357272495300072712165473376438300281922995823465878950244844409842644794531288751261732596721610642491316018434358307548274540483643794160847070741795459748461895642004476272062795755403849847880564677825579599934784750161452649688717239208196143024661915646344740414093963827975105765370910223327211058618438109286320788031834316649009892069350043756814202077019809570433098648537089622715106088352747705828628681809819934794959540948429448184341283146097311426691570520373285761288995802e-20), SC_(9.99999999999999999999999999999999999999880938488975652115669643213631230248126799838296779591231609801204436699360836757494663576140036341768217196428279881453755452963024766965773560507122795822076000780692881366245754195533398857596255693285795829751852318699096142023830350334754364808624892439333710684341795169466561692893207551567117843822386554921700320723066779416814835120422295083102698726676136546837592879162164887645156563225574180182790368161855975114174502212139974273411738602866251571e-01)}},
                                                              {{SC_(4.77518184435850312824695974855959690330564626492559909820556640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(4.77518184435850312824695974855959690330383150786986950012496836930074878631240804035124319738780013645083375077544616898561908312065941430347802463107453041858495671583762741096029923257079257302968047790550769792307128713580082994690133797370824117510373959841609896448673241459037898046030086145115469025705353364577688588250562688270970666695785406307428035312168024680392843053488776735857595501213628466833516667726158422967395113793626911252805964855127321974455583739901636298003420464827010385e-20), SC_(9.99999999999999999999999999999999999998859881917665446220291365201399797968099921727881847815426248931197078614981311072035724421911759715979094472457981523507074663281668078107427532373671551387866380649320442592003200200431377322948753077746077574202454027025945646595207601239042527395341917368022264491271985293624469146381728776687435996883164233298131425702484520495446810290560085866721990974101137184112839486463835447743589853836128729569230456404847333286069284701906153131312047203315148300e-01)}},
                                                              {{SC_(6.23033471350706135997738616127961108759336639195680618286132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-20), SC_(6.23033471350706135997738616127961108758933566957847999289308558170784132778968965056317879231412769917679771449539438348439187932432493322547267013194531309417671787810003677479319468323294595854503684255557491537731045988638721316770431599974491396281662487780560416719890123465165060033082902143555001286051776247690298863659447671949751100979523780429285085076607036433377399469725034990238965854157158763546494845113581705197635768323514084271939558504928218466777087816118281922669032194856920486e-20), SC_(9.99999999999999999999999999999999999998059146467883444182268334649298276434564976929585548792314224542993928933951083639699574277795394564312994424625369164959037371172773384747232025021592402636011483717441355967233675768383537538357257986806020531720706435789906784405523339574569102482506955066894177094965148419682062923055222829644783438538549051815255067258408435937976971922027519308509543595916785909437447704234765230356260327291111447155186396159452978437353554256394464351228571434927304711e-01)}},
                                                              {{SC_(1.33373774787437629268591066100668740546097978949546813964843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(1.33373774787437629268591066100668740545702557632514609637109354894670795671905012891418174238222956443457378985272098537652333132013350163148619347266169535428935790271959785854155452128955268040415297439974798617332131470285817296376813372025095563270334709839436920485315163295216999970532915024196623990234556546750213339892672121031667423931247372788485766146488884304258726675821256736326005518351249552597350782054581090216636090655004539684401347254213062238979175599528628149953908411989598459e-19), SC_(9.99999999999999999999999999999999999991105718099474933284806139857400813352589827517564927043682648978728764758259157548540521229982370103779386138188937766605887502378218907747175575340569525702100714564339935788891685749871866514578306868104810273210249836494289529105147374405359061719026715925340956119852852492996601324880989891212817101225911122299495377327270035416555776310547611050503379101499527525151298272309849046993736994837320252913021267626530928647167494021867650980452641151659034895e-01)}},
                                                              {{SC_(2.72678641362033605222928850375652132242976222187280654907226562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(2.72678641362033605222928850375652132239597113865233767282496812811434547903471145444426860140849165730840154443142045026389042524606225536996273431225195010565142182031866043832827369044609848704703782132802561090043295900410238999861579888039814092986414773412351284654281044246052360633441869568298727826155909328956857265054324941267888898815042029695822947856553640688900715106569954380462969592595043533559140576168918044774278564716729030098230376601726176338392887493576556803716314240985244825e-19), SC_(9.99999999999999999999999999999999999962823179272477727965947093384519089206611732778459619581048522840843983255738245207282856356470053984205037855894718532833271990791091133588186765379675456288234980220490650098675151780551707568969447539905274856216620993281787677779454733403694016219238223636757761450274748937793228503165450442613649588268034562597918498086592965280705305942919433851691464387890013808565426437488525566307607542416920601654752739157313437038398177564522256160039491363191017743e-01)}},
                                                              {{SC_(7.84847163163788824526839738027206294646020978689193725585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-19), SC_(7.84847163163788824526839738027206294565445289627706367397044516728216502661445392300478006248633939386640842420482995279705186836498615499704063686315382015944481417124956438069937893001716889658824383315836128859850145896671561869807159580264109008218390919771400485087005083932708363507903306384325767738641480522946290564444209005855639377332161802587036895543893713301102591999134123077217638518756971205307741607894644129433547698592923260994621866931698355071283092718360372159939763148236356081e-19), SC_(9.99999999999999999999999999999999999692007465236876521225591624733741973580413992094514864951948409477638354994860924045902686945655537440822272877755997184065488715073530826515341419594655069460256313924726013950095489865778611313502990595501567365333328403336978055022497339264912331540809314218388716961805500397317409139244048139568851551974274994613766476680949014369225330326153094075670488566570809659965208296833269543942839437306713455429886097267390826909886913799325068151515675401821307784e-01)}},
                                                              {{SC_(1.59656777006820041215490180164238154247868806123733520507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(1.59656777006820041215490180164238154180040523146025537688153328547760359499813760904753192863253468773626712297698660124388326296138121710134471432406051440808915749048856231483953159574219728203962113030610855651177879388716588720129915042261664035793682631272244330593879603534062436307902756624026615456937074668685614020808807209201572426546153680945500170264414397099342062973442361578952380032313799737733204426677060914568817376985131352291265491571136049590994403151805024530900585006882465838e-18), SC_(9.99999999999999999999999999999999998725485677789726970050441887873791324802821873863599682065675369351546184000866507009103149360549935240237154588525165432757567980472696826283523224052289490749011903664848152710996398754070605570284221534583084155424171763973302026291361113216315086799683804698865388858367703071408534692832158042217078221374921429321228108536764324255608445406900297031772562838405852406675264021549234730524961286458631341099514706834735141229319185038708420515965497634457920545e-01)}},
                                                              {{SC_(3.44953506024823770663434441274830533075146377086639404296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(3.44953506024823770663434441274830532391029287068934228996677746001591898296589668811859099135418230183368869090360366169316970324064915891904038980287950101288861517367153994714618453877419868135863495400888589151982726942060284747289611794798919706164618774056608179851652058360068165608781457601308274531931492985898183893679408914979686066252487633256264623427099975969033776016116820081774952167052659583745697715204840936711313869898247097390719918108455249924815936377403504970454933340960681185e-18), SC_(9.99999999999999999999999999999999994050353934059093527720023368612070391851891406718440574162266209027406523980686123351044050966467299673133404524778194021524254214740402040008906435126427498618501963733597360987556318089420367195395956628391426699039046618616479253844852188916292966502183910384510396500722228980724697185501358054419824202059485672658948142353306536149886006393532789623679836881982922548558194712986003534069955762666111663959634870672560092573427252698709721428977646938742506195e-01)}},
                                                              {{SC_(4.35166485374347011307050170358934337855316698551177978515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(4.35166485374347011307050170358934336481859685873216140703808138876914884948876331316739925647147193023892864511114548238457128487754654556216343738493227753816508527036822424078877053377450262892442522287960679598399216373675467067420960306212074773556400362052082955699418548571551788254097519705082720856063393741663277035047125589079587783198416413169663797774698575716466933356398467157205064339327846149216696847465253262085226226554946659832296405255702874805050585475448565274780032487961906445e-18), SC_(9.99999999999999999999999999999999990531506500346911434918787920899098195107223890450668484205227829549023183287220398482022387187471783874651026967044131244719811336026254678190222733416033489289005400050123232478835262944811994584478096472240564710057918847691506763403668556132046747246126505680179175030370996427156273193469951062786344533187975157358909776771548110773203090274293899180349800394539287346096992143426016937645719411397808886142140406571702228451300533351648334028048315509115370507e-01)}},
                                                              {{SC_(9.24571534386041068466488557220372968004085123538970947265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-18), SC_(9.24571534386041068466488557220372954831521512026783180405754354097886633909666420259426993221137091279535065321898200088264236523724424960040430570024492732801486261174800152674655450605909216450153664375989066460839592611461245370445914423958469134702623836585450775145273632179167068159633632516565206133697650089607101943944658893386809234746268745218644974101782367190994926519199092662771524309633358926212213660561746092502239714663634109325449891669735443584060620900381198034818129697477437067e-18), SC_(9.99999999999999999999999999999999957258373890152083906642579378593893901713675765098318926413104745110870584186071073407804185704163908348012520912780573078297733751798245590050762285702888909088013591367509411470242468260490885859347433147346225932292893244796521699179017915375269683211891843022671906243123097650437828622789131762134264796168556176234658033104766744814914904339713894114835117307900457700205766539066206181496361808280227525595233858167413695522317781531300493715242483817542972307e-01)}},
                                                              {{SC_(2.51782594979259907296692544420579906727652996778488159179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-17), SC_(2.51782594979259907296692544420579880124943902261708085063966052958947147187189514241614449776830904431946870970159260360455691937092075466222889953840855771868704636118588224163624330062909301674972199987289150997146172863151668928438934140556411036253155163667282032912833405760303498275742772716593021336311752096063104868665845591806232654630920833411198402563942100933397822310625608203804916226388547452865994565194163622537436968388997541774348017060507709506033121197774674300740105857149675366e-17), SC_(9.99999999999999999999999999999999683027624327549818611642405259627277734545779576176956905635223388012474302610177483603851865686459231081769991335822870837867041940841659622753593655014713940872093638971093240790482102143812831175709620648245763558424105881217295782262911565235585052686966682126499325038194102297320702415146289036055973821432912093687266500152913802057369103672457993874673452831732722685075424587280286221673083152862430730343082806366094609467948165260813432090271885255078181302e-01)}},
                                                              {{SC_(3.60775684432840075543946767311354051344096660614013671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-17), SC_(3.60775684432840075543946767311353973080369334858269134898134738756735710959677046218904765558906885492364334061087292000344970193513481403662883440148912074435103556813083982898635787234571361755716055018572586190298430906370378661560335191704015720371244055660846998368129007455709209071804971663274582300937117518716033394923135198118931181280814242888345084797455361388619932190727294536114690351832821038660288193236381399279391092707971406328888496938832156195246642052265826811660109189638402499e-17), SC_(9.99999999999999999999999999999999349204527610078975893456674652126360120817771889688340590968406061460125038582488754724017627375833001324771430239571028894899497567383218424464834879205022318861495316028975968435726716609929616209942133436466398134427112551311140669580095176152342696145945467540112296016461483911736978651291905258534879989907261687437286731511535258583610086316346495465395414349916862854388934045881989849797218994179829942041721541151900222125391260679662481266724801598694735986e-01)}},
                                                              {{SC_(6.90295059018608417669704557795284927124157547950744628906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-17), SC_(6.90295059018608417669704557795284378906469154946034628615057275758767580827917168872394030586141560531872074234809560204671436693044343425840391457010301504740137412171139792833213101802925834324490824649737298051601026361059699458213672597472671940024151452085874111882881940096147836064982443543053856840493763963733305482754535226167817708959873515901950734304015397820960143176206034587501435625778875628979453297551205219863495406983015780361797852016321617748926259009982380223123180180635317112e-17), SC_(9.99999999999999999999999999999997617463657472479607266215131600498895145019962619817073610305785121833967037170438681582573928284612137780747419863832305571281883014950124752373550795955181129976650681557447404026625564572824730218895963758905602539829994766072456089977592244417787627088492524928818145775370505461217658955536144756735086815718595245350443425602386634810449310841322556872457206827318110637949603603506259040330724057028251216694224515414944270384104053076948461167522911334233852695e-01)}},
                                                              {{SC_(1.12525415366977613387811096856694348389282822608947753906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(1.12525415366977613387811096856694110923727366543178991248424063936367102797106855871236693745998067792183896492313740966698000926384509124609429426947250949336737827454663845525972326893699060730973692704401099534341951883068691454285910587103533107303005237227528372401263431557132330403274340519948918314428351859975268429373327658293293126940989855765542949901183195688709343608094809310090493938946747815402871007789220671491796635682024533321624753650618068739379453108842797651045201761667915069e-16), SC_(9.99999999999999999999999999999993669015448244579190490716020688404404988716129435608800138080386131101191985387656303059757501675622372081366205214275299789803844591657957023425966901002289779390222862063087950428709151159887731980350511804536405521204092863537711731089301980213111230626506493072162164721222427263528034471459447079943925573395807997966484588698625396806888099131723626070423844207983223693719453345905264650308583103241187401206619743563779615806788459652582739288156225108227298238e-01)}},
                                                              {{SC_(4.28382572030007718194566379565912939142435789108276367187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(4.28382572030007718194566379565899836945234420371503713724232371619461518506013953070308907657022223120432356779587799651917208455464125023945619250322620734440739272636606036542794988782854081250549762246318356169949227702350611711099210997039015438674073645627935319092938030223129482110154686819363861357190498576723741502657507450107991097688652505486877417543163721810816380539353617200530000879082221365523977016071919655819686183525162967504230324883441039688604036630737533267004970821556250520e-16), SC_(9.99999999999999999999999999999908244185990477624499510226321205119721095058075021258431213944274724107301289007609545750918897774273978402826099822688602645967625721552721825145710869947821878494892043502042886386779524528742129041553615891060311231387090458943405060106557011131937219960743403970810197762094709961812604268256488146909044474591554749049806787202591299579515547894789910550353470898790744771998924472207450437412320226664359385981163518398216312240317301698499316137407872077789696500e-01)}},
                                                              {{SC_(5.40562027377591153287639258451235946267843246459960937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-16), SC_(5.40562027377591153287639258451209620238935816537673386849100638573507598699570776586306494386496157492458850686285616875867925541474335159799779780220955316889931213510702441069443159194380992809790714268610391273861815905903687389829176851624715712613059046143861758161875814504643502656660200767189812949905736607262048197843805032721613684327373616908312542190461280141634492118337843627241511563352346923911175072722072966072193177907657314017778251100684093567096339022512256463459212982758053313e-16), SC_(9.99999999999999999999999999999853896347278714196230278468886281830155045973395275720923575499461975468393288308375635985943289405969943879734175052611227437313547948709681018548507712575189908929527549469183969349762222426533435169077447468058380028005061025510296067919339408665667471629938407525632912450465661014944423084708195510683442318106580092132004438775938913243626094924308943984839739704805512183838281324880895887413435530914721449115971797745548216512359146565268873966691648325262937751e-01)}},
                                                              {{SC_(1.19902638233177101512172413322332431562244892120361328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(1.19902638233177101512172413322303701605856504819416313943283595900895124055620076170199817791086158982821414571245272957941067225878881094777635192202973211099821708998113732307880722055342305354709198635269006039158481945297350819140843635049214167947460796264522687764348740281409248135258544749282489911854318186620606384911450658827884693894389423867972448049092242216854615433791135706385760735336705625212816403060778777341209622092144231524514644426177053425586224941858192290734691115813095637e-15), SC_(9.99999999999999999999999999999281167867236192838031095819701787916028865373804359002593710111142773221681390652606310884830906788286803616120473194438083063522759231894313363861617725958310805741867501842807266210988030666684760768277264807533625085500984705089723638296262863615123643927659844348026277776487148412530668062202507750370540981950803485371381729535175337385633187123449179301997596140088990341420027197666179279421047422739289730401845124093351489448033951720102033987005033127759823277e-01)}},
                                                              {{SC_(3.38815974110446074818447925736109027639031410217285156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(3.38815974110446074818447925735460780837077250405121624908912811375492279012837756694433825794177369571316423181623747722330627012456802421253043560253125336775562990091975356520362422074333107111588703197523535255218079359281180279158607447962967751462269796380368108394244242041512896847324483778833671068785773032575465047510854277006905770126219090406640414242106898982323451003943735814733493683579617533872767857670925391333276393152162297673266479295833057475252401519711564655129713657767572827e-15), SC_(9.99999999999999999999999999994260186784379476757981152515209436341728036663980357387443440104175124376831511468547287382319416060748994665608544177190490182579191009837162920485796578048138194041887008869736016572866833834735218013371717851707589665383762610511843580510574079870970128972241540922984155443035750300251011010520308198519163161300610750853200215747579653236184803757849345278234749183060179873847789020021279061575836422283909676225842553638445293397586781889264388759259817414925829082e-01)}},
                                                              {{SC_(4.25116010644745190294457870550104416906833648681640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-15), SC_(4.25116010644745190294457870548823941816346457251046944865032376488142333896402551791579276032444896639851938619033815895833657540967584273977907877502009276953580855032699870807772322822936877320097590315344887937786915492201615767133292963150490357076868487302662214735366771516923521663480453249471739343125382720393628673678394339909114917543444697211149317158220603255176901419974392387577177162511580101616906659855126508349098308950139220756875144978090282917331368796288438131844298023787069363e-15), SC_(9.99999999999999999999999999990963818874674844702748116475486084707856461295907339275469937291571802782088108504905557783890708671134426482936133958851489468696392146303515035649204741944920865406162487979478067491792560183921011153079063283495854040944848891001128521367934055151737110438100017484244794529588617295000506752734482974861081634028579480845943553032127333374137833767657979137594352600945447012794293469082855519756029637064798338827033317993968438364908937482910493816043402620465161846e-01)}},
                                                              {{SC_(1.31341538664973833672178216147585771977901458740234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(1.31341538664973833672178216143809571448147914551861945315022842811990408652297041461885743682766018864667058821901627898580410140220884869293241356915777926528623138687971777326704302793043310182526965205603774385653311969321173331212835547392587296845221807206335638843928749849510457947938612432868241044749076353621407488410073206207551248333799609881930000055823209165036193354244804208920991065276559411758752154294001775378226648844516156477334427467299485263229160154290869729898721568604402964e-14), SC_(9.99999999999999999999999999913747001105585917346448255468667731418020687259389117642182162355936270894492609327035751577975781905511260534442528906521602550843864551447652777416530770961671413078170413492886975664947160713180489434110163702311286988054098578657891174616776498835271527908985423746559334439292604676555187684744172862013311889242392247626156810700173294404002606146758360658265157997396113740487595634539444440222461918086708882309162207691177052462629678972670037494736536100439792893e-01)}},
                                                              {{SC_(1.77789708411153768441437250658054836094379425048828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(1.77789708411153768441437250648688524478645580912315036422418839735129736561800912560835961982067194327873729369871016834742639611520196204396728785664128662482147177652003174719147456642995536688761494047602027150333731314226281909251891742919393899761767420368792123139583925661503462304784697391744091122115805322210363460646928593577702071795280277818846269272559540733486786538784857222816733384344097244591858184250197335472047542795560179495424920330227962994053357077457931707468603426251460959e-14), SC_(9.99999999999999999999999999841954097915384594811735454538004302545016037022517780490173741435795675944555929465406170133641921828986499358904005969797819484344239424979764763194041013420519497310559183944490160788417032999948756260634473243130077692082484694343666135596322405044585526223426948443120980873050098596571808877217666689185784054062839744405474537113202401718707617992954377641581966966545840927315700676622358215732909299904758018931589113524600079145027881524323334695454152651376769920e-01)}},
                                                              {{SC_(5.55649412115402641099137781566241756081581115722656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(5.55649412115402641099137781280317284473213695030346303590402303931988046396190338269482149660999168475038150256800723829505660449059395231364201161042275163348508537606449304494069682810716375693279805579082802414158216642122510822165563995802863552100344122494366921663968851214429922913820743999886335738338311045421972245807345175726774597818626362833446973328909358428881598965762081042586774106378896781546245534530618913971744589459335901893304147242918115216617276790851847223349497418927973733e-14), SC_(9.99999999999999999999999998456268654079037183233581732191235680025315867467018181588237226553648078402104412568966357460261758140705807969848157060264373212772583437857468570864009272459824286929152662453086520176402045732499654604160968831934723473454758968594200776188249690085254846050117019853832573195081897863789261857952979012801346898762681231872848791491800971643317036237879893584845809194076325524610955276649279179513732336594657763035295367706519084046186378639813891200730024664881194352e-01)}},
                                                              {{SC_(9.18614956237767676938688055088277906179428100585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-14), SC_(9.18614956237767676938688053796317258083557235212189163208541269091999669666251862949510205364812241435932602713540901656517151026883360600451742706846201757354337788307438543330054149104803715768067518620042425775420550383928117557120515122638131395055608328341320860695875103112009754385279107344430056107313863250016820433118759295567727218114604325934665604906406791475823429379313212052101226211800542137836625027013187029262562420815009289990239523883555061206469585943421229829445523451696682896e-14), SC_(9.99999999999999999999999995780732810881420878824781237756494428642216774906860674262521495747901019476422529053067054804076342588867228309892313842590968737438559958533351462306136561566035343161310449667786137339299678900922238922396965259978293416064425654849017060386290453490593319953991014716853265314390480621748175217352424683886712175702607549061234175218581612412946946694618730133735506473462495392167916885413468468240891287057630611654063369552363308029777319668075166154464106813717530309e-01)}},
                                                              {{SC_(2.02237261225785003304622478026431053876876831054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(2.02237261225785003304622476647850095873909180892287918519663670291105892549106786498699240038550543980803346111571520530796485649985741199932123859242106953735865135143891664110901496277566279720106785214896873432294102853816490874908943796259151346566606797734844804871424841376931757109413046850801530240143016207449719658356785167896334666388493819143310669816981411875825762085981881153178256115280842466820922870399927388430970328517846034743061348720046367396642901249562006592204193360151806314e-13), SC_(9.99999999999999999999999979550045085946798831307767615967815728269180214484619036252790909403641537946797064418773421399496826527484740300031970118682423523800911121951712600720523023938618836373759218286510508286981245064681398402091026119540125145271144222176557855414254314889883573284827385379124690381427040558491108917124358629047794540691235512374459271544852802999945917447080468309969091217719526175112209317700651086548969987910493118357567850475532204275002096398789155408595057632731154652e-01)}},
                                                              {{SC_(3.34987029435018790479716699337586760520935058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(3.34987029435018790479716693072418709836017910929437771667989352195765848457801327380537239173197201180176080218346985650892495774035295932905608250406042601982574423542358371694291944969185689340470978450488775476762384924785167574380484450959985723643696985669647726067536240145655995029501448315267496689967102955915125920689511406179578883297420325275705419734245616104771318170311735879077910111632963840985257248968295796101579049149898595541297275950413245232396232327962777768734503394067078556e-13), SC_(9.99999999999999999999999943891845055150927223405544616685223412194532018312352112927452321976910999098948049508814822499116849784098962082807247240354662341685818269245714571156296285694028218930934948908556886283919439083377260618552964932511197054219874122814829581002165311372499459672863965236873628437256914247926307351641680837638533400251705920788307072678111781083295027335002395879798438407459058176503673480726665421302397190962673216184108932938297777524721561087126288972933983518946155179e-01)}},
                                                              {{SC_(9.03792015186088981693046662257984280586242675781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-13), SC_(9.03792015186088981693046539215738321788986007042365699492396320316279543704656553385920212950890969400392613697102194394333089009302293356880420539828722393281429459440756798252690496493026357977966088511646078696519216849028481527689534601133226590775882871940037713146444153208116387342034744131483842449184313713683684639667347361681889679947544099071968736411359531118781695435946215982692488955315854459642225183570337034144595721581924901891009381696599056233108436380627927215964786584791618908e-13), SC_(9.99999999999999999999999591579996642934151749028718876204266336384518057312270158991179501722094007867269513312491970576830983231405458466598365896114293073967915021543855661308978854719200666851617736145918857326995797691540025815161748308738637322261149646675082385639820462296143823539613814818378533729566185263398193570914921475394320955027638215702854032556452121005120074292215838023871081463612153498469043881103912304300914513522689206406089987405856445764613561621916375162684097661929892747e-01)}},
                                                              {{SC_(1.22932697008137914451708638807758688926696777343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(1.22932697008137914451708607844192184591614021773791940328070305907562272284382223300433745269608192105599620144790494124731585172304253064904889570512798966856390838847723038950322727570967216489506463988189696586088552862576676302458507583018378239538011152581276602465391085652348792218000095574348738110188831812197308238926987928796802995971775221419386158715740692175212354148929975079049190330152422027211799955068768549451248468523076997234543234379586454572701565848445729465086417448959545618e-12), SC_(9.99999999999999999999999244377600315267972846306889896038052955037247802621151442469870443181687549662547384392242168552551586198987635666377667288491218214785084557964246070182324401939504153389732646676456576169283311877256893335438670498971513103206528391739503987826941965462689634528631382329044690235509449552819606620554284030388025785016998747768833817596505441782759764113304742100788573487452340669666205903502531701419783346606301970952783643261289551845395097138033771960548299748561183193e-01)}},
                                                              {{SC_(1.94194400143787859747135371435433626174926757812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(1.94194400143787859747135249379511403083044871897362511037050124806754061275336835830905725762621394550968235318798300478790638972487568362561464077501190661717588852425709719253847163292958680062291156470483595542128963560564633973633700109207198638475983195243424201811540606422066782547498014390464716148059784336885812875071003684709344804730966630672604654294265898013648377879784197004207883524124056780017570061779067586269124313028463274433436853556491404974636268026606448413073206266966668134e-12), SC_(9.99999999999999999999998114426747639720283878342644563204203169790716021521459251173383061511822722138542525896575482448295370211190274140784860421332669802522548665773047007513535501337737342769293246553594052155484863347990751330806127168505703238439677398058671991000759955784841064858343931841972679048717309792670368465654719670193574986504622561882465200813531019263380321051541831568937340898838311445737284611598359421546001386821750750668783594967103468706500099741033123754869005438685314915e-01)}},
                                                              {{SC_(6.66051588882332623597903875634074211120605468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-12), SC_(6.66051588882332623597898951018257669190239027988790280537744366770877869050933103459259476608886777756579915690814859257345475034216099104871689275489156456302753285073620213598586781180228060589887702362312976118884573130740471011229159680210967244895704144448701015278817840314429220158019791909505966927759104498603516304729831106483512971261087799947245393962528955678079281745145306463990785840496109060362063486482136257417186274670623641839580128843624512912347189142131567768430005910784229570e-12), SC_(9.99999999999999999999977818764047366008251915524084203751590909615251086260955508748261875866517202782687029477624871890438384002334203109091463704378174221182722376822335534340374142555193102169681841196257200130319439394836735580276154595560504229580621565183026575699906092001065134615587575775622899658383438321484961911921543293368782124716382447335465893719947339645128446390223095375192808481543364390062737788287402811325613827202640885016945267219061070038152413660953412231060479866988215583e-01)}},
                                                              {{SC_(1.30501373596381142760947113856673240661621093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(1.30501373596381142760943409660333560692039710197239032057112513034203903698344616901524225376776673636415296454266367127536474789531939842197697151398931051954620168734015505409490467508115402882079987820789347094140079821190591257048602505229613017427675926583289549059019839863887788014562137726446278719219792278561923255388743792279408327291728896923250516571971257379108941833199023548584100079722864916841543005155359097839080114754493639235506419010170504574954807431988824330519664424575231670e-11), SC_(9.99999999999999999999914846957447288773605522779915678255591462117418280286605417598269089175755617808165165915602683165476414345458269433948306260363854177529036902285732309503596434344904848730286616536266179648232912749254260921122177909333891770273234400774813916276696399105771617638759781892253016980274639868069042438911086857998849593859350294868259456585846305237089203682687313371760123762847165326247352229463880572729131913191062641677831432439574962099265732575505785164506006988730385090e-01)}},
                                                              {{SC_(2.30686234004018331233965000137686729431152343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(2.30686234004018331233944539753366059849572649087610511654342255381136041764843262848250444528344180274751100392168733968453303717207105441182806117417443233943716010264058015378484280588583802181389162890492955868058516684358307750210024654293194277914609668768527570567723841110762132081932253661492542191753298326334321162262780851843772980019848390872856649462749403323629021847818806351420968299819163556526351045832094245083900470441925991571680931787416162265425757570563755456357840904233300722e-11), SC_(9.99999999999999999999733919307205216483006651477197259401080960096043483966257192343615939983066359058015411234573217891951462139195543298683130104275658252397201222054956161090902681981646889634021219639651905330486172099952446497605963028200398919937976311851278164684080724300523198038402357061425303530776059374244813248811828979039869539865200596606550574563921484875225783175485587493630243707736284879141253824075634607287034007852277416184589479502402414449884296567587929029951662730558004216e-01)}},
                                                              {{SC_(4.64061566951556869753403589129447937011718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(4.64061566951556869753237027271728267095397991615419284758180707686003398529938108907558659049805544522166142089343687183618822183674180398802623140208567072402203228303956147191175622432634317287818984037751722759314830706093834121136985601634172326524194261532142165832914113607429591085129772083038510981278068584029585870749896926379359591566067146763734165664345664227381459809244090427239355076319156218271945168418909110785694512816165916715703898907302335334394861643407127627549255668241455228e-11), SC_(9.99999999999999999998923234310392328504314665821502918105582647737643019746695356200341919771774449617719049429392209231285890370146966327702937705005002184280017353077487902270647087318848825953575460945669274016393435239996905422988310852251085179190521532751217700605669335225363776810282826832168168254965685159520325099422292341939640480539562839299127143241281660562761636134317866645828326358737604399820142244271880315035259321648287816929497132547280897354649873459775364006169123128552913124e-01)}},
                                                              {{SC_(9.02057872842476626829011365771293640136718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-11), SC_(9.02057872842476626827788012314974142790926916207393567000799536747528665852957940046104517610928340118743826314162253680048717597622179343740006335264696415656819212856065002452706323285773197002877181170513609645226653106034257353908933673379666374178326643605624295953803936894098093825390857002684872623073784374057517550449125474465431745573184934610421148035203590941470464984042723048840309084189771384579997243914014773511588312133450507254488274889474764456105591061347125528289764395734121383e-11), SC_(9.99999999999999999995931457970214531344382763500560740979521450298825780214945541896202189854474216844275983986675930662009739900611201068149959653449557497416940647881320682912193115325791819947936258729341672087252057416024263812703049224805890246943526656060900271910628931812153202546207245286088184201636723675366258575793036560652857802740273426903311938076552797325985907156430651556662087903430650963838535614862310585721428952766908680195035699158214593729978819602348438663666578546511487638e-01)}},
                                                              {{SC_(2.01724303927619530441006645560264587402343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(2.01724303927619530439638527971518402895378308593167368933938083097895914105097853220949809226355195616763949665976607147482734150177406396672952859214765226945452347977564327048328471633932359706066181475253090365189727333367351575060582769461913412620214498488588122674367266769995222789306232098144726082974899810430205404009158930892774244308055687571333194471156431420346649010206696858212297365763691018084631483817683537177298301222874090599257812256350856270478846129594126378216518526591643988e-10), SC_(9.99999999999999999979653652602458691842430650820260993559156474358290259195311093915253527357327361693441729958969689754741626190671808226283208321176357071049612666759270261537258301510936970338807161008051696492329011151441024206711798673439297093922746120664076403362950701801472249600616977394476695828826008527819050665336968791102783867687569984985171685557174424584367761174767539614359167513379500439820659122737961073226213712482343940968286210986638068482869101288889181592269909589057079909e-01)}},
                                                              {{SC_(4.46381376306703714362811297178268432617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(4.46381376306703714347987244476099027009902224539880005072561623010099356540803184148103036001396078252044944026422080138240224768254417146931017323334565624451815099945627590607391027983942120417773378104950239985323999117684804060836017845745179632044457016676450796401932538561014818518845565777874909934983679133832686623486576188630071071148938083208938499085183977246795190669480369085393999940011770378838807632321077683437611646390289967229138020819814603314833128646684632972758168720689991635e-10), SC_(9.99999999999999999900371833443266485913038040997156521730870275068640693475214820902318135015361433760915624397597203846840940746657939286081364605200713758595178692424520434822206960393490736772166491137163017541233795275517139247267410699507649970089369444931075965017855747225029199138401668188234063259525010428970267417033114000305412910864715637928080786514254241357289574781729733996541742322741084600110673688819799600144608849647324443184768061684805422295932405956450624750023427143250924393e-01)}},
                                                              {{SC_(7.89404319689879230281803756952285766601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-10), SC_(7.89404319689879230199816332201782739529240876597684471272919980002777979484632363432465884931581298754425539385458462115986883181108643392276139302735348983421293058202757716484062137411039264846920281186219775313627007944254474745735092011358327265824752737392551192886602710943611890515757652974814780630277463419954569206290620286570655977415225582763091478596449757175244395774820571912306590264730883843056758929601320981726777511322879727946707924970966013671019646025854312852174453387563435502e-10), SC_(9.99999999999999999688420410027479475305362157778906332143894166082169936942731331015607326922677730904125008992719151667796893832292596525226080125485663687387254462074817179973188165868637583981505405306392273710095595133094657390308796486677320683162477145982344545246447461503948259405992813915821707874476148435145178882368552160954920286669801651923953245324424846942116744922945358896352588428998382245435357510599957693421002169153027160299186706875542049015760799819878960550724185779068785498e-01)}},
                                                              {{SC_(1.19753096328167885076254606246948242187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(1.19753096328167885047632011372988366839572495166042379119878396866921535579541590222533938771802127489633885286823687436829092513169438926309539112468485901612826556554647131355737095301585331266627432715950786269002497531271856275268976492286772142534422181109956360070777230825864534228868599188286080749992690194349465150189374099100496968514528603190277672577719059890396520617292399022494599881257249461553031630617968764612470212007400625184399122708879017220672145741500373239998829273594129387e-09), SC_(9.99999999999999999282959795990827170135614551023194240930093260762829569325129878206690247961179210344290146583519020530140477449064663472153477122196148449723990947674581478397862389652720572814459349933259175702680962896596786112183582392780523594102607808197088334429511356009699288389060708476939825983150618719140382258928526048553918913632413879435283278548406386086586092090685080850137974728621832392962549756584863779090254093942057791784312747925080865351451451980136949655068387207234963197e-01)}},
                                                              {{SC_(3.12890779952113007311709225177764892578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(3.12890779952113006801172430787239899843014121180020028987887830642136016563460269227648455367884353405820594949780478791250435270727158941605153451515613224900471744038506348092656973671581305148881839609084002562834453936791618968140360445438617378508144751389050414302328039146499148686500822713769253502370230875150664323494512343222329717689617673865658363215948765288460608585507671188522539091504719171739787225791322428333826762895704700179325887091436326383419834154611514564672051705672679729e-09), SC_(9.99999999999999995104967991047919853288257931434502650824735772704901382256708715021400393451254864039132676058501649583756462483532603552799348051856624202071636323687874357588478927990651820778386282265459606160788426873464937091160667643766602768082383907777101778047612835332747498483430187110019957772023312922681975084585702702709221851139804864228687947667854639696398886738326057666662346670866634585482424442770349811280971220063596816378250127941112472200556139543776950887869805152051636464e-01)}},
                                                              {{SC_(6.54608101058329339139163494110107421875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-09), SC_(6.54608101058329334464042270717554606519400676020573764995976115778693340979388130080022974423866935284325224591960497690969536588939452672365750379157106213853159115223232557801762788904356215610406895778680268668011973801486872457234995334787076786196667120204171752334345220791146072452816721140739938381457912498306668372885313541251070938296534995649585503668002513271906453156430650046287837268495454161895286850464882200938396384912569859073295724940016743865987946354209215048147814054560547411e-09), SC_(9.99999999999999978574411701440404233691911105547524791228756909319836684728278557912715521020318385009945375240636666743026580394412900791259090936132285225037596739865993433693958701211417830265319761760818827268301975142733786084305836633688005769082569801814452087685765102517906826744994947215969543741061484041836019692751063794459856496528591823807106900483324218512086593607216213529777612655991996245466300172132394213898662211942653694107956279418132602626108011683019257953461179914335417569e-01)}},
                                                              {{SC_(1.03735935397253342671319842338562011718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(1.03735935397253340810790893751025841403787815856505363100476894912737720704301244348578436008313475030686333192772334627176325130192577834575419942038167479241334017482987492858923177101199753404916939468489116939860242362829280075273559017235394780006839615093480333418803996300935520495415063145607760188117015493031522213277247229248056357387542181122622768572015076371502931740140691049999730628263261329673265670764049208272952521834722647922384989326854349198917760704695926154462049679427169055e-08), SC_(9.99999999999999946194278536284405354610570430372345844458835181493008418475677210409811435500978199000936738380347156217172881551605742010246289295475642679026543821035644853655390677531816640177832243794051207478874195355431282643488079197260679386719149446309958513855351476668434360361836809340787797843883968024921763591812095900362002068091186310802402564913000326899027361620529514471492425167201427430668102330868055716754719034039207556779437459710875339678788681820457468797439539816776604272e-01)}},
                                                              {{SC_(2.61325965311698382720351219177246093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(2.61325965311698352976552085794674873948977136797189716587867829599558705866806962643405885733038039478988642364563704357082502093947827944797367772608225883166215523823555298418758318630457963482420232556107317667605517036573551347481182888243640081567986906925549623281756915886475451174605904832849770710597096935848251100601457675358153761388535145261895383377176682130933568074601365026003928958385110319127880786379945331696265445429638709206271414191927076865306342505962011449784687607233615452e-08), SC_(9.99999999999999658543699269545087412937067564529648844277884576114957046482837719543260440895585699908131861178001643432695184748185712205336322075891023812779806400255307285635209660964682222600661763324276256706481766722094270367164876479959205752956664985241064867292918583916329838581852654001919326649998662347558813007474950774388834590480461253782550965790984460939938335780491393830813803651547817812540355485622875414796710271358731969408980506856043610689479845560715880583092274528220974819e-01)}},
                                                              {{SC_(4.65380338710019714199006557464599609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(4.65380338710019546213101449129115033161848051306517504163852496999266647986927435990977890722124470233716535035990445228653000823387146271818720426084568211949650343484184758290087581824628001771507825912267378927562049889381022044816039337591261522072635747352493136871116429720337851950673898424910098529686862263347207701376800524528418048828250587804897579251153864192781131793938839620359474075175276829198081705127544868279759961683164164202368688955879018962498808663268299079979752869609245111e-08), SC_(9.99999999999998917105701710736827116732862038891301894759899293767055928392225272595948117206501678573317153059878167175491018649556936748464550872544907856954522933464150470681110854065542390219844974968670264625826027885525059842104573562044746263899791837945122572103192121273049517060613765582028914775681100285591918055756290567968423433583223448698871995491519052440989343536966227231794085271655176660154985346506937216237832680674055765810058625222813752209386455645318051700424429635825604558e-01)}},
                                                              {{SC_(8.22809624878573231399059295654296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-08), SC_(8.22809624878572302974031454935391361372051682957068440610320436801540761922332609590542871910636824146618989600960676006105552258407007206307536028311773758371384227498119341523374370443380937572494475012853690439239638281798715153078626511309309040418220071090995999456749591226290293812387279580872835304139321819307678449632135824464227576504967749390956982614137103459123505807303434260206228565147222591135435434070689816927846520472271632967415936426640676428703540971888279567964898575910715123e-08), SC_(9.99999999999996614921606035909924093917868987200475849137228921444966119154931547433131311747286721713859993964713899333566061563563544320069396737088155497880063790400169176996226259767364154679636076351504706293403513289841547482443607379100708634166577212868961703960806666990381162806668658969679112306754390205132297815473144631413825060452445785272573811906319333663841292964458685149139890735787210705223580744560561707667329507023265309675234477115176492742999823352033168878910390869069602146e-01)}},
                                                              {{SC_(1.44012915370694827288389205932617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(1.44012915370694329490470632120488821960831420625097208452760967773899621810591454782318687404722250729109496920322278038980055717492831906815698784428939225099587980269878692724152957317801702412412993718131255597355895454512166790913978083465076143342113847865164382371389644607523752931911069238459892398036303216120203753683695430935556070669486987607684338788351666960681655650102436765917243152996502890151550049144015760341535686810061218536126158179008438752649028139652964238696677459061310317e-07), SC_(9.99999999999989630140103216562700402577129540528603374109265955230536308597494067119686820392828740053320454263283957034972289792638690212984598029233291446961997991969126997116029008314129347403292717442507305281117023966514614990281472312184568218292849743703025193325667661349717298061440359197461007084458252138139784938458360221184396180949292384861603688190523134947836462720740001267066751287510670926330528553505087996619339798329208819107563086094981065297536727314006650691009272319462255730e-01)}},
                                                              {{SC_(3.73797774955164641141891479492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(3.73797774955155936340127351088274306966945499304687351262224327036485003195399876134404030898541569452698698785128297775253846740013651700738117739570712980936632597600460893639731587793211760397741272305599435232590671004667375647855341661506518793260072662904540036197343969280257117154710542629945909475065608111305917119485608749363342549197465035729619138390679809197242810869893983371298887552954017963591067229750619536979210184968032123026629350132118672624718293514388725210602289794113281992e-07), SC_(9.99999999999930137611719284858340365115221610379236961291415554500435872388131334398788410009604492364643595965830967680631112341724704163694720399722612295634691371226329624623908442837416395690299608196223118613825405185261111911951537848971636572392818714982018974612977857238412841244788826676293170497835913653497769763927232690492490945784008368787039023716182343873542256800681402456564241935627923628431291698833219433246493125751712345703002417251750058512609170411880034738680935556902505563e-01)}},
                                                              {{SC_(7.28307441022479906678199768066406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-07), SC_(7.28307441022415520449044890666796158134075453197296260624638167119898104724468797620569591993934165154251894245847724657348679804318367468423664871917651373448389334331503882422006453094389677135962962131469634391849918422883493755583387914729253820958027791152034299949176207111497843039802381391080335874944849745658182004855872129588827842894857367834326716640912301040886396931562001152712265979590735678629914058813142332537079465290202671615290625230647393466634240383500876112800156132201974042e-07), SC_(9.99999999999734784135675655199435477062371271904158802490932787360232684194206055502603613593047275332698707464520011088631566295631082659933586705030333526358496612387620984644750063897599725203398934908527060541521854556685436158796714198252960674419809228990516232542677961431420440764986615825562613851043943570711111775961182791307437967727617534370632679575032475835782635221622680183128935771393540477464095097827358860337546655974513824038524754934769834274209792801776761029464963487681454638e-01)}},
                                                              {{SC_(1.02601461549056693911552429199218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(1.02601461549038692382672664367980909129797678870667768849146921712212318648724429914717031817788290760089726336692234200973914773135228261464696094871714327427696538664377177507837044850603843659343822132883729646354999890909512098529406876550302701462857600464801392168260146985374253754203891556843366488152159129130730566352444244537417884234639163162077937574407637561014227372724382633431402179130482335521222619551445219770431699554800298663104276019009351056140042392344367285483613919360270842e-06), SC_(9.99999999999473647004399918212790658478585875953442964686116107604076344236801122474185649272934613995743945730939569552300021365101719323998149781972994755931612189643480767690316499261003148488594493744111104485195102515931162213304165502158643932709516860360378708209085284952295320543183629161025237715099530969074626286839526867763366850481056477689318071063989591265436161763207215219865838561800778868728374531420305187030797150900783726793452464152222676753653006247167516863553168502906926078e-01)}},
                                                              {{SC_(2.67831455857958644628524780273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(2.67831455857638435657005412213610982128276604639866069595480496471537739536401609653955476091173984298018333992862711537987312713316036415483747683882706275541677384782394839207289648307083009870715553463423558163889818178051780340013240706740963214040859738404485649136995119403224901763227367017966025598531866420695841491386351905041601360740252046371060654593691975685823280716565708139718098769413838914699445951082858703077317900076440435161320338733864823055555572257326477201841180943482872309e-06), SC_(9.99999999996413315562652461552002296120358356472133278078314440392542844209646953698240203500798998633549867504425862619825808196127841261566653158765476564276301681397741407108125586006528685692276874904550104105313883720338983664992978010697540996668822432388675633251819366000519391363331431034508455570735042351871115290237627556585117202107938696024469549112905592522041283932404634914222293377504740759899590438485366489707037641986399526791217155900620551904585509940641934181648230634413259265e-01)}},
                                                              {{SC_(4.02049954573158174753189086914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-06), SC_(4.02049954572075024260087118468826429814663153315077991718901582426759064739078052407110165549578932460376560288440104449973094159762702982705468081682224630114850462597062111224598235409091240576849433101102274161969329875425199265191158999339698045252297020474662563333717095860445116915074136815808082848855273281504987601523720992152761270084812423792786748728905718724925236891423461782473311868144673066624924040595777536217052283197112160037036137391999739146035325998017752148720000605119897683e-06), SC_(9.99999999991917791701396959419313813401265180623673059179911547500949908302190117148933168329908690893202837285420822052885466203283802841353637437714044074266653743183772093591630593925853924527974309329870487833794885494542924974682749486064402670967310507687630404555758440772082780068787018846191231498609660679588396035862441583962343363796596673788481921721284934251655364564300464315956781078329012607834367762424242617511122928763782421412214474185216401731965589463411912546191521776651138922e-01)}},
                                                              {{SC_(1.03207567008212208747863769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-05), SC_(1.03207567006379964486059135317923765178884637901450818590057242469689597001143337677447826397179538167736031048422475631735874873560436656704544669504022530773567828579863580427738546306049255238803108540550172893695386461067609240342223514481537877261996343209535310475116468606103856887738630617770362994732691906313027170715951153121602930976853364057496740031527741044543252742005164654126014924982764255443579086080334090651228364872564641844143122049086203141303222959691381228360964775537428520e-05), SC_(9.99999999946740990561699687835096311656569291167275749312185252030381383219899994380821659170492794982620386768812474172028293398252431135066349066538792647839668698102255251061620041845986018822889924627257362980746160722257168566939728109073250489334405824801674286788645760845367307942971073221727371765467748461807566364605758791097966471498518756887318016848413147180370466183250281458021428954703658743849818753824375557456108425203304608071735244045207645448919381735548782239335207831536854561e-01)}},
                                                              {{SC_(2.33581158681772649288177490234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-05), SC_(2.33581158660532274536503743158240337737646213456952132594369654562065216097877971320195527157730193358300929564031798828711595676076842939009562163723943297244285734194006007223556382374047257979318721500414262285245856557018249968979311552508909534303598154907496279169019026232123477133854368562792522099489668676299693279861365831493384781972611843978211229882541656295508764994514877851663096566718391379871772045083068385054238623504509574501724078123943242318442223144503041840263886374089552234e-05), SC_(9.99999999727199211556806106904766880124422922887658969070618357584897186718873889930706733533737414920883255973805088255784903870503201137916841892176156804261940743581740668610287436174400116137484876377141991877409180757654824575875337907433838981829262228635400536890633592785954176621124567961998085107372061003574500599157091043708082332975297815142693186921586918415547768897948908381471877202194378061551462589503407388052810183783734976447440624694286163063940147901602691211823597158892680245e-01)}},
                                                              {{SC_(4.86091157654300332069396972656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-05), SC_(4.86091157462873896531559848284582637784557632474682176085172337595134155904033586070379315035888134734726032766408540784812958598806994566663326780124710770377187107108833873767030923227727011909837793256232391518542423335743456454652126193064084872761224599187295590933776831599753105253666406548766772599334972756691975278667198025557000529670435088027588227931051871991509667076507311250562204649129417687068848055773179752252762878812337264258619348030050901842648799759954611402159498056590639155e-05), SC_(9.99999998818576932484137442598201473525328287104259159863210153066825931991341897043829111475228349045483285498413995323186917285933143000076937430579794115233182095826446006806557434845683429950622114857801966123846319338055787024498273217621081374284059134966187810875651505392521771289854146929405808060886179474334346367549605047691775074583245613018760263934687689325536147399232974306541392134063454728398424522096828357018128412581868706236434263323391431032449702295638869342133483754974197517e-01)}},
                                                              {{SC_(1.08591746538877487182617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(1.08591746325455478104821136819967057961442551278838752348343355566286218686113929505011769085392722880098614840019465066786627028957464813242084556927966028282629178723699648064575453887218658547931264605554358563986502073409516676818032454066518754329792331835726580758311211146649657048162622184720605255283044527192625257797088007777099678809069788187552437063489110706836509997536602585770349259033122327371763031488856712166353836833237805897511019879417937250092100019381559125979139968316714978e-04), SC_(9.99999994103916297612061821589739247612479612887786329210914478898502255396074979076847380789538147269506577481185329419865050666328661434508868431416044477700542172646387026146164224487845332693392736684598893846596257736456069469932831303309379700235636614876092375485047676007220108087938935195867325054226395462569755020081184471649585143960785879580745133870280816789767884448864548351682712557998756420520254199770987894208326002729195396286471764230750762925411446123482196587212878858449600175e-01)}},
                                                              {{SC_(1.65569479577243328094482421875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(1.65569478820777002278499230035423603846508955528717361183138764363130759934146907994995145252564658286590588043330672733736568088625032438281790665274851888610402105671884799890946873289097350132844056442855760778504889546783747804632166360961473335056677009872583516249083776988899488413878415770540869751761917785545042821020637486175722597418790478332983352386892602088522806462238312763565226884340025562855038735507337739183687799030444108160429127483514013497187305409079224093423840656368500111e-04), SC_(9.99999986293373747572336229637016911015215548939030428628815886701051084032403634304387592163823574064764141161745510371323667165490842320379672149455810787341804779685538532337126177529898307424160287639638228578303059367219675887486179384440818508994233187183235425117869203130395479376427352212373583179094983956677855049181936352501675476518166852524409114024864211976654505328129329141275749256228504839199221229471272083720991903424231132100498001886103604278094475959343911266474062340673953856e-01)}},
                                                              {{SC_(4.72170533612370491027832031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(4.72170516067693075676085308284046548368287941901283849283802268407085001323603380117712993012887418320098470197820438430800375400461013742422252145872788157889745624950674378630308331446848389037105550082483516085665582028196070194038315998455738351257405359430069565974850464666742859881265494476240853811215470922001980390784076319007787055901806119150667756505054118980239535903669464580996153901994796184051966736242100731906816925205360327063389707705971734665764585696567561507749437887229461456e-04), SC_(9.99999888527495665124586181695612446896055759076554914046210391986508076349569320784929587149658215798725165235431650500548420438784030227751958358265628970993501643962381317805243477469130674237304889359122911251912706271419560285910770631706849781369467753261971106878784188494585647101027739471383693003980737319512703901979613054654768752954440845304999284188711132746818638758530113359491822833435683803246988867483208003823651051032814261010407735099449745359158953284399378090005712210474581903e-01)}},
                                                              {{SC_(9.59456199780106544494628906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-04), SC_(9.59456052574554543206855339368821738303292144129224643533250613815319054198172995757500293034201494560266361040990132903799826087882524386271334883058570222574369362764548554621322985293459036681036350936792370263478263637436635785459960302052069887902457445187820098082690964284699226936748715963376583385063569355193783639233905746245528110402738779975078022638401708272956028719655548309901166652903956254394607665326795020988537856449664481578241990439621439369798643363472829333476806722444683316e-04), SC_(9.99999539721935661078558358877631095592475113333838978294776138905920499993032330139337421241902110329995510935282225042250995091483713765893804389358404607462625442239227727503856365590616276283533013690912228413610654893588156280765066256573917595651391760595965856427674956693283638835311400506664007482874607000520400464981164369338168028152504872866005567199753620315631853218147483048084578609267463623678894563773075053269450532221366890374338890064467167184494935898119563677811132238676494558e-01)}},
                                                              {{SC_(1.10342400148510932922363281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(1.10342377757381395572780813465347362173848474850723949280118058196604746697019572341413318215944145126695958128785386403768383539056318668913049580511267222668786396512987355606357832079330824071633509714763000228154703805420380841226809762285320859255338411857700840437097392670248917342530077492683819354527846578272478059817224126037006797924447420234585794971684867137695895352065956771102354676254811894365161560870498206118533861539197244201894588423238917868029352924008553204725898125797159845e-03), SC_(9.99999391227798240570355499022960361310528390499881018197266455182809171966708398936554453665968911045993870299118374953720723952637206472112388139335340004035264857609225769117609578581537811200358127352219484431189085457465511011367152198078790212367556345107155050267755673291854354611601028709748042046865897310493248610005403267618655965229352763040418269822894976453122559521873062039563482824923611739885583070016982058054313658269935174171343198190502958661221270818484040408653750173203230643e-01)}},
                                                              {{SC_(2.25476175546646118164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(2.25475984495072670616699492058592318073731947935815704559772827343957028999833639178303301437534887758577187984590048560049309194362578427803068644654064353829312571273881404656974876959933956881749270257978577085791157039068158591410681018436713818579999705850717033396103629973591002115994971570790017014579064418272908019539035645369810874787478707942360991938657434252507502080409901856172541073238790283858388760869397761626405870660463300506949260102988070042807416992646493834806872323726803835e-03), SC_(9.99997458025789982445234678521350046147570566747269097297006799068277234530960383891126934577579240030196329864154371255579971284092149965664359210957736971529173205042093081250449736372699216695844500361817207467277119512515305472466332827851429424250625947451636368646391696099091010507514309786281538269045925530297104928415277439273287729077747597056412777599320325937253062039121168242112708605401359148662225387594303232749296186979313529662443155110087020374951036032548173900426505478925101146e-01)}},
                                                              {{SC_(4.22764755785465240478515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(4.22763496440571037285398946467322152879438013077166851167820322096781411803101602967274080802806089831791310107085441630457942728083218628874481058836415036218079015608106582663616413342942237592877795451725218582690701538322377534768805672823178514496056562910114186529938444688600571794798707451517027196106959482213808413198379234771333495250671145504358644814838320906361026604251041524455314777424351345824775387198748093231006179859065418633089177670013556478508726004901466555382091322541680881e-03), SC_(9.99991063511373452677789560050715373145149428952096904697886367712876086292035745304311300137665075775273598372499767812075771242786145874855260095826032408084979781582498496550763382567267778984462635680866130352737905116567138144457106898289831285799702043487961078500270822380587722117890745799126097012166609016750935133471076497871995927122341989914848865983119754151725078374043588790005160728009669720033867672541115407013710341252692207454447790955386571269789604798208580025842831790721417345e-01)}},
                                                              {{SC_(6.12821616232395172119140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(6.12817780483560382808213557329119466062200876361634502126654101855994873417503462171920965026316613028274177950775049233440669665302666581845868636766440489877186411773482813665253370273946003944605695383754736936873840106381068326241720149322296111362109427697762615253610223173961747328543942833277670703533635146996505994275092106592137357930186405512884836781314222643145720639318114729066271317143669053008940304917313235596240875802807154598766141454795653291599739378818168929230008696171347580e-03), SC_(9.99981222542099697541143847070072546971828712330332098329770865072257185985031260314852113919032198468189307863786664906732595418738355515847783722029517753608046646105120123876154838707339506523033413632583032210663688541682592679914200175407756374745025341137154609317405534874067938923193059980542578882066469704789720739170867326643959200096981737568594315302314431892923592597361251855561253029981966969356407795627317125366633329796621808980454701786643444907402366202716161170312320402120775433e-01)}},
                                                              {{SC_(7.17522576451301574707031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-03), SC_(7.17516419661267582836034142174681465204546939240119108133248205295339734270417930084308859916380512773163931881507840068416345388390221086830455795381118700976633134766870842626243909834567744533155267945294716455117405920717282899684428800209181185252677870139843050740709460388726089385203283189938165953927393351322007154426959879457092338736053974861861644896156794783787260212117683134116318158048696031746003526637450133982920320145132406951950929463951376414554776872928379361757042284269550869e-03), SC_(9.99974258178055125266307198014100123003566845596771527056984119690792340007476181043717952620624133322304853462699177805133923671700194459571450679112952110115183754067736732754526085407259235156594925752725123490577463983114254313088597337232878237130488068840714630832409931261169972643381940574573574251462173875076615043890492664417739484346470106699266972677891219384324959207370519061992691189768840015505197742750976116894509011762334997906198598219245703947633571105806140038697463949630336210e-01)}},
                                                              {{SC_(1.08977183699607849121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(1.08975026685868225082099747945941996671381818418315536870193669678296106532928807799250909718485024339364885037800450270269491539718476844275823176938926046293973622562776303659992189903112282273804688777592450861967790592563558839055840320743745743517124801776837401121113421270015723410236272602511202037511553596347924893762020894206394739312687863922968952922066268886484510171475010251450006622524798965971270954932230608474913019167203244840780765530916268329460323782785258474769888609110757044e-02), SC_(9.99940620454828879176449810090714022793966325036551863037524364956170680998552985230627257441664425512623325862947910848780903454899838812983927846862074783892122375682062446356128198011466542914409856704675107268613669808806223468999915731471549560119508428919853126572110247471699299141816274992236135198359087865880841983233018975591367702314503088337980462078592624863043456548876665098346359209814481626968880920471651405777824085084498961422127406379393002743019949466056574181916058099651689932e-01)}},
                                                              {{SC_(1.78531035780906677246093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(1.78521551967464525812118193536998457864178736944932839508966062490920983977913731452860386330129428988643959146499238519533510439272212211988348296443064807083049612254960715004778700987731749155310876701221314643204230414499688327215921624508990886906725847368865040147551794223030969339112865851425188756335235867433293871733996891222497034543953097408857990064751695677356390131257556267672627210868961098841308101435582396237613538685321484883810914108667403775738742025077232461429195116913304281e-02), SC_(9.99840637579225061689220616432075985634795177684838328799799378097519517291013941215385055849958064136044025335614398935312278776881615250387809724005390098759965632553311813973103549298175120350139482524465729389908312417807587194665842630539253758936784938132701160252206934489824287775250794380842975790174460246991944385024354743401221003796973051809502576452212229636093005330964395681987883595479541881975506947710338355137649374464671012035562176747997429673069797136234426619034789230719427497e-01)}},
                                                              {{SC_(2.03086882829666137695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(2.03072922829785412764841050885782924234816249136965856784583938017611790081018736188223687999876856101493286192891127224653907316634100288250902277997512484886751200221909624555006302408389544784101560093067868425111920727574110886210515003659002049664300850730141800851166512616080332122075080697842576939296258415122768607418798187858959383049671689481354903539156410201084805224067944662577370176530609953627594786848538340329423858423683103538089020644057268289846646276221970072536489769025643200e-02), SC_(9.99793785677893519174812779480838655924731734932423234294294069992449425216385970005461481038863544081690554334303539704684132073109604649614262579053784312170241598442533216766228590091484634176673005320023682039710851136366207849186480817732574508774099889801516500622987309336021622394250832627784750051628496869920836260929136480639941940830972794464084948098223215601031017843124234960140768044637617707391949948127367933673498635487224027515795724693469515440840875190922863554670250380512890187e-01)}},
                                                              {{SC_(2.29592248797416687011718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(2.29572078654806901956773962128873725317258199243322324833026864813543563298791582759067345370927013211131751436485373135926303545824205672100408388119836608013942723742698253158825504611525346094396821412403622255927493921481889928668837905973603383651805682086702397751093728776912507758571185200632272001319729003355651579071960733495090546994746963852360611508210301194267977533797137231602723726016493487285942976883227358425348490878104264990630653588736390691329691673892319586298997892103355891e-02), SC_(9.99736448573833438551901374069916160082285485161657935970098520489678155282193702973150207036885608526804424111064981121646464459825539846765219169457812958666384096707176259278198827616355298087054529952352895771688201169993256457977842748577431116383131563229150919282988665267307314378159810855110884585840543438664714574577985254814341262596212481955968518620628040275972941893015178582124863257398330562940280357682968567499337875321971067674002549590662525412105546099814520291879786638677849755e-01)}},
                                                              {{SC_(2.66608446836471557617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(2.66576863716550940523643834663602903343412691027273852843135941288217001883358922665531133518750112173938256664285346400960504583060978937807117359041113160326475215921376215686647943718380783767854304202922439633733916721749843129015530644519528290494433930248285283911310398738720138221726525289062335677459212027783675235985721420722586719469315045658602049763170408429747316938170763162477214635052925244540302524248462164057897716244401861039283114010655031575267508920532761222634789689538511757e-02), SC_(9.99644620731442977071074952503756513594379179610965927674853010103238383122624249337790075531392503903192894317965358160816337306507873045677143717869693639520801697528499751699845748033476777032067833843164251267038735509848519717356813147914406232186302906853746387101025616449658340377064049192334098838427810354558514702289969721445128620523303760656579431646500448912155533543139906061180895870794100250533118584128980041772272673997087854201826597188558589194919728518908452007643217258987134441e-01)}},
                                                              {{SC_(4.33529913425445556640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(4.33394124252182473430409877221967910797867622226492251867897610304826237176234205087236591492775301187860990482272397390755639330607447336901965105997233088160319014424029346223644238916843456763981709289162131537218519445453237404967311695686259903340466092692225153320582089587252645635191955910645798631988546760161387767229889141907691633440411944042639714942724664881391497750867101083989306287989019965318777179382753475304491095052075043277502755738012378861349287761686817900063465721264064751e-02), SC_(9.99060406247108182433110591563949184008590550285525910681138166422995597546698572115332083802970332128616627121897628062691197069398078335651999531708939350394021171461022811848765537950565221073815507985663387023414130658678517161835653671716651889105148592561400980999844972491569135768885981972484556339777089910598305278254049157000511662638183390385938716919090639856781430202246719809307852115859635342924078122187579416517698884917122716280159598299212052892821404132658413827277993111120708503e-01)}},
                                                              {{SC_(4.77492660284042358398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(4.77311234361182370553346707381159993522127668228423471698794041916914462592971898735317849465740734845328633088053944012173225744522673856105790002415848172408214069917931220805129043473864993265296014536251765599619235474270638309161980840862577294567887230574710596674786583672806261330613179024636609581486126381444805459823476722923620864804227936605524668224800326195728143182612430137862837785368173385669325151174313653767933525960762817591648188359244076692216655226984222876231471974326328940e-02), SC_(9.98860220378970765416666292064830637521544621232664286948273469114279815643994118299261220464425608197046745838168231112925313418673671418209258128341850371322883422387259027817868426171842847565005445057442801891309920668960507045036275491752451469501935202560886734381086026356191953555384486093207040581077635167409982151341587820821452812951152750188497181793364081579598815492232851725904672864062658468093007372919440011978305101459486087741869001923855853317522336571059851757312553762759660218e-01)}},
                                                              {{SC_(5.16691207885742187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(5.16461336987755230869002002933674117113628450460422043485783336784426247557022356731909397461110296707780131841951583578912090434140144989808173826842170096882942749374641049049281256365429658426702580621050221660498897060467282826111146984504858071976776010862044802440626983001384950620260121297069950332695775013404688865827055306077429454209895399918940351395258935654650406962823095146186230791842645841873960270123869669412376104542452754845295352322884283271557570532941474399861951518394012477e-02), SC_(9.98665447922360135213521266796851531835766163012102217203454689231482046185392838489821970734399552125784174598237931177178099063321027279880123829101090102291996800001170395479384503634523326119052750469669124649924813326825830131301210568512199084926242430541410903632134473488254399271424441248952830602871668311874043567869499006057808372210726562783173297018290349493718182960580142111841000744070620479569810216657779987098922352077088309252329258306000595216296566049509627139117579193448663272e-01)}},
                                                              {{SC_(5.35675138235092163085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(5.35418990269726278953677792861679455376590654675816169848288105945573655682296899898869189937986681565688296738399075385825415191313522118358129631489596746430113341211856136081029311923254306994352803590375421622780891367234256434768007178556481730242780532291413026293701001237059312098409866323782729969789632460239666058895869272654313586973220036641750017933187081733418154997011863506155998863196409535077692811025064845163939795073047119520932989194866829270668217258257742446996467296239119175e-02), SC_(9.98565603778031935652835648513686708834550710265717769750310667576425570795156384080269125053377701778322103408050072703031273382230423580101177233233637046691140883620617512339519592385040904452381281257315749593686899133043996685159638851121619705365155446292409398769831758909586549766267584554212254610789481269394405823437544863448131217831503558412097043985486772933184380606483570614071708902118307606358672960875898690760212848810279332764698105509738345245083749332937066279013972721999860951e-01)}},
                                                              {{SC_(5.46618700027465820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(5.46346531864185652266299265989588209830477972038596340046745896270965748111117915407412844957783278731133588174240048037524044875999928967753425125705682555219277190276660395984393739754427791927609984222737114058002449717593767347380412781416718720139763763560831069900217749569616097183501956486846275878732672863046892658675036070608869773474008125672567991097462136933844468402615456658577751136172272644508197808001817946107058777720287520148449437408040153565904831296703427837337651292795982606e-02), SC_(9.98506411932942854108042459383510836576611626853085805857841828589727024599578729102555269651786073170459620653723435360146680969297857326420874817490649789865110476564950683767869711247167921681531780596807917980825034133974022054580775539485597880316923766328630105414714347920762036457437458978017894386560496656019128174531675104091105815589303265933653087805554087457116460752142693192884431966173438902253445039424420104100800153312932924952674504484086634204703161803242375829959949079328371875e-01)}},
                                                              {{SC_(6.32438659667968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(6.32017140698571553308044713212277127305580363675994643659056175266603461157186436972772935697186775584447574120250300482955852737095239398524047402605320085802360502734438527396117034710342713540059428441862943107393468247351552313105817924671750521572193181871359324500531838441102862859431500100485751200567575889152186067903542912689055820492041485586215746117964026201886764474679347399259605259899390116183549116857291416283292113855783627598795204602258349944011558929310877634929059670251343108e-02), SC_(9.98000773215447974930857087008764150802722713855075131190757826889154050945553921220661121452365560389264145143901439511281161342450172975749282079997770447047962785911737177061850743521158087304394889557567640376240963884213622716828950326306607973087843641309155595671290107453886169528964221217684412490926872530448945494986971864760658616100419196710271977256795134280916032136610315122731856424655612669204766978915937480231411079284123625076175877311308405119710061909174916588652383642106075950e-01)}},
                                                              {{SC_(6.92570805549621582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(6.92017280684475612902603902770438207229823809705471271479828689022445623726238799386938809349344091646528512687247043332181204378221893753409890952132644020057841217740487449401462724977326326240588555873845938412452043950543296812754149801196579464929877851745061494558924117827686964993369769544684901144441194229164891237169979061294758072061727145767674440485650023105765507606408329089425013899299577165073264823196330995405816916856144211104913426885632286552108251986044868955272626643196292768e-02), SC_(9.97602686861027172603564582943332105673127986071266218353266069809274511253146184206845366224173756081058509215281054336469951237433524652820574411529939841191369181516825328759338555257162658220329035742673409660923162322070338772130378093565233782382859190969874936467078560818088676989913102487523016799437156795510688393525166046823170397107091522702108912971248346576465497475646757504529354235293789719140147756309348702788375506713736572756372750138970931785579136687784786155541123581503410624e-01)}},
                                                              {{SC_(7.68246352672576904296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(7.67490874173009135069880523412697822508457585502890722795865696772047729876064075442195819127967415252174730960637180479582147474309291939932982065599344583920928985188488533311881202528894182053880415621488280876401150191961474589923356376146456592619669462859281190965749024420664637455818648545745030269593390316639260811403394610404759688632573916754271685582926522678938892974475043221360555516845248432643113640807434458674577935765032643325568519227175900369858636214019202303533964419422257850e-02), SC_(9.97050438834772040838901364158313289434451716031250064153596345308272018821197676129084180229236664005399614878677876975471250325523150960303590418697802419593875967006452331656192889917521490087559820130552413382203751563210591862975073872269071197791671987098499838808586255207819747398217977453730543524500812800441363575651210847109655415586570890200280733024493168949243199540216485504542435209304533986390812843525686313059881265579087409955174014924808295795997240217218146624971087121410183716e-01)}},
                                                              {{SC_(8.09251666069030761718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-02), SC_(8.08368672891704041856401399565977462633145541207784105195635281766371350041715608644123439493672541993789745715282339750465069529433973679063356554636481676969838531641729712415794020457592886899793165051838868222012601738089693486666663383926935917522627219438621364751646584726391558914371888319525238524046669167174017862265555593626706190460862728323563184295785235714399851325267663766041999660466314577095673142555868764898118503537742829338293948772872287161730013924554420829079124806859650838e-02), SC_(9.96727345309073504356335470880926838901535446591427240450997135536600995694562006339829380366181693066021072124078607773475760189943037842585673090508596377006890419990768006320611612165829317461737791908612725831462207730332953868156044465579321433828199753603772645372217436238602125419724170481393494192174338226617942337887718845813995926557696166708043078610521363485223670975974379541202944258805434600100105554638957533334813937130562560651036711336483875166644356875980418013651512472303074208e-01)}},
                                                              {{SC_(1.01393043994903564453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.01219403908943933199608683876827266822331896657015119348435515995873251362892581898523969110413473057175484874945707988194700827394492484991666081694502360714551805379172398977994444953795788193400170674845605172617176911610981540681123148867173832535769953275410424339906182339005138130601396483778642126418902955006537169862336104812922619101165500080507365921158621143838037659291114217732698524358330821295373816025579728381376436689358518738815604135961883722908286779990249376227775979659081520e-01), SC_(9.94864127543212840320288377821634845647085414624812202931183041261168843158195990345771004501686363057363117868426992237675460528773854521201920483305361363360248147058939179651726098593741851629897985101915713322985077003831521906997798395547116734574812939319828244003602124162864904183647670159780723265956499501655186584470976880921550426566136335393136640881134844219644797108944868300338025473599742848702293332135126250466031987636207455199516403656090507615110967455528204674521869347233184283e-01)}},
                                                              {{SC_(1.13781422376632690429687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.13536074842449533573056314560680541888587073396780471734416954452266370815229214023167805970244196892487614906848712576035545051060440640696937578458753351149286198659859230491031913382949861842131574007393962925506301352740569195139817573460190730933124402796432541139111274714968331991159010328143533636587905459810458085734253711085152213069238726912858320015971192029698392132381284060402446909062105834221574702578371713280266538027801135387833807187710401803421253961741020954081638053867325880e-01), SC_(9.93533874464967449063569644542184589167411915145555830925800925048382916374957718228156373711609029097586917146755989532376282173266030804470640098835579196241275798250895989878704696330453367858309552789068201155211873250074943597130122033727796915843325644852705268264420421834017375881556371386266487723607694010828247880528072888290694751350895959530491979302529696561595066224369723425657904124135240815273639834011392138971431371570459667652548016159381399021194622625664031635527048346353172978e-01)}},
                                                              {{SC_(1.45697653293609619140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.45182726545119910896301503065513554089811635181347002919360968238106525239849127106083723447884661619491476318996100888058149769236740617553657423543246126224805640578506008942954719919879771041763841262575849284095401812024452055715104953842593111698915775744793562621776046814833194051220589433393977077573901754840253776854446283075046240949980380729523982026872467677407277506741271915544833128497503377061431926327294908631808827940530456038838245220782204713528747800140098835534702697426926175e-01), SC_(9.89404859454877012674104360255215697445250382526116686234430435111636180480363210039694164084560087713657579140601666008513347848135681345012895495404482313374018887800206381904740118067209223511554356762905416336552796599320637752873442358116522801991236920325855007630644300246736916456519031036406469453087853685796047621522776532546594623313211992046640425909727951781150478344661351442954782469918430949839815203310019596602225454055470344982907764565783793045739939149621215477845195650414185624e-01)}},
                                                              {{SC_(1.46310567855834960937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.45789119883467940942452666599838103341359960449718828761719210957523413508589636439490441998945000690046439423719795496860975068959608833118482126752973685992497281683536728240268587587996557081304567902946969692888006023433259944486597453738216622984795412987238720174132836036097378879575428714062852373236946181672074574586946077158989655378857849435203064073233248254743027223599966958610307889622372063348070359540031851175872778387328989367308344217063459104308008467995496716837575470375139856e-01), SC_(9.89315689011148661602733208421699488607704021068618550402008672427204988986372856602489837286757458629350642286967590178573609349566514100296374300421069016400647354574847125419309106253968630534855968665549713372062563646883184246277672032915339186942154941352874559377354486407977863425325175458300408087571803444300804433696034967764795880754888144181773120850915128858590327910126025450201565492100046247582395277159945474527040466390117883445528272059409080559643218070128411416452778883832850860e-01)}},
                                                              {{SC_(1.64792597293853759765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.64047741622927076939215271236654594127897011750093105907421204884321017294953058710221397042344470958585047103860977693513220373332344673343758494866765737962583701512149928490660206619098121564968746371244119245299480844406136712899775942646822323057929571303890179803170552756084664071910161392856844372737036778217074263519383318878308282686738767677049481400503597999505931480065837516222420967161921750298185638735643161192547265245244900149693758408851479162365892639074870266742575198789041130e-01), SC_(9.86452400508213756079085881807272936135605003947860908459482770413651759106178422243846316436626721487369742516524557342814943387245800871775776486342542756619267901007984402634148564481396767251299084570255625415724967480494452602327750220935561537677562719487800489429908078112186638391572916817894043484848106365987479384651955220754065637423636048081167989226482466763849124771027198972951029669062947310139511886934376746339774134623284767012226001205043028480105389214119654265467805704996894917e-01)}},
                                                              {{SC_(1.68696761131286621093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.67897753381640777196490976482953588467508831683372714558795951689672127553712898036662970055721497467147460442678821010944786665039665291723031055582489572136347698523359833632507727947120936709230382289481829907710145607418756967621108259349346466686730159813704577895106354119168392929747217498250651261920149217884008242721599405476228265647737002662434987399937591531877704904771111015714073021213635766515555210055971877789318074905744443808130938693092802702033774758042610910893914411986093307e-01), SC_(9.85804414886339273471656447974713083827165382741323834224259676470752447152375593455603668369541005720264056620625978392433528478869903852378131490186154661428713627385705999552117875818397456421062795844691099250197140896284553382461330648118896559620824983015387112024605313724313404676635578899408594831199173075967069948429971307857666478428419348687818365697811430472301400125955439683148729027958378246677795263283167676059509815153284641866483046913274472527809361657130996884935738437688390849e-01)}},
                                                              {{SC_(1.78496479988098144531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.77550142947830555217390492492207436163564856376397691603471700758805620505094698945847003802998214813652148033430104346445883849635826609851792442417372917393077225504169766027761171289816204119015355122870296588370885941402084021320650235068717288615664162092993878080601955739098755934530077051921941503847930336545118455807353704448177612457787143073152152474912906128361372592953146702018572591695826734837888565690378918416926761365428056068697441293452285112838098535915209651376327087033569747e-01), SC_(9.84111755208322331601783376284031457134510436574988472806865188081776835817350548686113681409314838853209555871734190921300414611852299784524298797341600773458233613284112776255935237880953315784741791795731746499567321404790697016686075710158398361815849761549871491374222001546515259044955559094074496617496483018774261036037936237441724292540322806453448653765063482075390934100259487001653040960036047517057244093701162162170265301510994152643519555751491036603128207767303628421845067766132528336e-01)}},
                                                              {{SC_(1.87774121761322021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.86672607070509018200769158467157136756113545054809133514599006798341838147428337915964255447040875993446601094948338007788867131495492683573549252266794504395930828257199806193163317944026329930030276018177467799947302689747186012618665496659752413411604967342391934340345214204527433151759729624702175254292451837535550647514340490554770316288949909792125071156560813410066946473274599946447062966296654108025847480349640941090560137303957768362702065204305022159912119527935408421499721086175643635e-01), SC_(9.82422178989002337815610061337143809470232196191426172141227152440284416089850158360549098995569868789283179124826053849882848723627305374894506652402723568360198439729964565008020548646418669353974087094974102981683934246429517284904279436821871136249465341395739281782779316039327149652772606504080824861909307024955484203942865858838215635646193223373227875069545714813048165491415661891289071426040111977674591777031031991473152177396063672370564663369651796710946807883420881870357844328037459019e-01)}},
                                                              {{SC_(1.88844919204711914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.87724475007002131192192907909575574869468107940416726140262504902012686677137623390390440018094087947975695782954301767385993337096992265831822959983588134109865279453818899378809773125976208984682808324883167608808274828949288633727230553400197642565185759119997079741072491457720275500904428836491322659017614746144708698514497655273321270625201156908314994126688002285337649091106243420898018671107461537753842230681275281559140984628635324537359567946033168059091609203607550845641421309987051017e-01), SC_(9.82221727250698436817021350854404602400242591298039572591014001362833626919487015527681343503737629906656769473041944230032084140575629753880323082381394405508949229495961813072980287617641885223163912931175425781095733566247409734381851802008224421103956525409424631620202344202770947172844441311566015165775590081462279294150426616367490190370747077080364066702877391332809076163131938938563303607706965846945894566447961844220594229365249133061197350601224127232615735975265049548774049804588028913e-01)}},
                                                              {{SC_(1.90480232238769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.89330463273083171501356047975738454519834711328775668799269418262542693675230211169484065483867752411796711944188561819164685584819239151595903268311841262796101414713826819050365386774822672846563612883606074822171787843588864652239834264812845660497544748008612180548384351041957557898905180261997435462673216754339482806193427627037707093816679505008419641782078097220844921334245843967537368455528797062366592333764784686568744055047958612982535677498760226067950696358916937565635392744576096899e-01), SC_(9.81913425754429586682013889768017532600113847811291666387725000947456131091217295251884688576304598996117091444449076993919438338637549621415126694566727540442457041137575867954992620512786069817600004167654500318167894032291062929699694909648414253182150669496148723694315542902771679739586190635289986724110105904070094436041592234600515389991658872221604551947008209955001901499595025153606756488036807775907625811360112539768038550121486610887551305042579936830908885733477436299200628358975660870e-01)}},
                                                              {{SC_(1.94859266281127929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(1.93628466557083175937744864244790830668053598910620087560855663628326397918747917496701804712300389916375529322287795071844972897988282823779113733963560377794242008202198109920596762933935555585424489154825370240638238205749913867006539156012553835311920193678258151553765976847035445513869442729110946964494746309715218534610352446566786039322618340026036341364523438132919833221181717413668583176811261681042404934548226514142822649044118616453915688888690801607706237459440680955231700292236811361e-01), SC_(9.81074929319240387502184662874193366494892376995268422080911994896932188938843218100678702648454595788195800459189480677724548072115284301366906218387046613476243458332542611925311671611202355995756808329738252593319348185404315688233584739120945457255900313939696248899018740177998528759646883140416866189013968416544572880129678451134992718322404596854003353515915190671579319691512530656126775340885106148417889476553076706646054806482802741567572180944742654675167468422482141054087377709351667607e-01)}},
                                                              {{SC_(2.03215479850769042968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.01819682646920095923757718257761476769301989665491185429289158205603248364522455384939136294409419950738281505041126361431633176654744047644395695093833382944676718163092824428861071634027022690056323106012491255936447757470753147279575163352864381221318443333004723142721489343022119668959646121865064655890154871570932168528973909882911830449156165155241550354768340210585682803959840545783404416670702497182916990422425025622036736615873006366902267886516071073081904058012469598959221005905865613e-01), SC_(9.79422695109877704279630115016162779341438729197653622653511871860857427665621496308005256225301647590150890183023870213973551366446778827045639583831856224791984674969152761667061884727276778725391290362457018194029231238622882731367668907983050807609897703313170541946017503082428616641673224025500577727237921678771503953427745799384234510120079570656146847344758019012266371807613472779375992191550902090841424078371482339253787081150785495461758875501897023881237849778458350386303488036080606616e-01)}},
                                                              {{SC_(2.07936644554138183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.06441432111765598898622696628034638008185695872547628186034653306091137842792921910271809676733557669103553974294053328911326243602782740588214297154717533970165522331160663449357525617459935928199881831844976092566068029955259730825952855266608700751730681501576772094736417834693837749663027914778438343298984135440812456259434671197055417724040905908168521650742559047974895842842429141632802570279876313914803674312694054572490044105458254539298356949176720439807787731898038453066126598813031210e-01), SC_(9.78458959337407914880017857366240707691566796770579819059463425270298886098360523692900979968885125117268896174792597043925346271994102038730825752617956702096517615173232766171688879761539440408643776852196199211523030996935750277368506862219703970756235309064425023141236695239770048877371573690168695503939188151919945120866996252845385595169432390250574335809999951819900409720087947226987798251572790175287245792567131272039006656437435690023152451503423135850418689659516050248598574324279754693e-01)}},
                                                              {{SC_(2.12829470634460449218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.11226371452014391278874870071073310255372702463777968786843878133124112097140473459644588680440461706449482294123265808698739331752009084647828193442025974033968649542432348123746207023993629961625392580147265129400199313735837841793972839204732752322634442996742998985161049855446603805134233954899877102074734231966641527718799921704505666685238290172987528235112149856899544215597311460808399136987719564373629445617240952996587119331927421670252293311525292408359167374526921754803210077087692532e-01), SC_(9.77437169337863700915956028138184587880119521309718402773143822868653160875229416631075342793838257456807094385135358010247340775654046653152968486378214625824585383995774198214703672411773216530432708000905914410924076763688720643025445894500247986983994857940703526076436401941590579776244250215552581924626810062975652107309232328773982583693249830181955081354965661172527831758216391460026530511489630646442106088711356971367646510599128382728363593410702655779358342814182142737020940630712872361e-01)}},
                                                              {{SC_(2.15869307518005371093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.14196640505365112786980685694428344657244963366876302714289501728318645735513153812127852740864750088035328907097365685728621293352830777003662293698178407244178434333281299242679553774479025546337174728441787336469271585023342163534779593199490313523522509388806059835583629329411911994168179200754968369466465053277189853243691400027013334899114643882547886884557705155995062509092370819402521209651344335312028605152197178040025081548811752240491682214361328002239129021416396548559625427548307079e-01), SC_(9.76790560558513680337105210359946000639131660265038803465419549929502333210272302004423538883524995851695890751897479645727458798428416719156047191385293536035128459622583740134790612138039228883962636358032372726838818091247096202590945439186853892215507835182481988301876992478308045540062442385616914635141454198946321492170688154415464432037046812112157612157921692137918708124553009612313024458692547550071702227895302886545623596270022503303566442880581687999337288455147084218206433678719726348e-01)}},
                                                              {{SC_(2.23670959472656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.21810624597241132842120335214517834339392143595694143128274453434000897522756707261372395934316603499717542829693748282161138714986831310993664331890086521601864106048610503690287656926479843414514538641298186870853247769165125831749677090898816822399854510209571926905148166670105459035975836926248520839912108203719166947500998176906261366299289408429302405966781907431722890616467807693626704698773283853361405226169691717078175076647095721409493977986059074455050738153382636134995510720710671481e-01), SC_(9.75089763465795884741527131038743144799709001486249188041326805783918794629379695544082151093155092077802612594232019135110813148686802535895584065956564082709443629066755383612577269625034627767644996066171592038545406563485710108199711112941937879356362448421804832671387840559048718713150354052800343295008040554106973215286388458315674666252648980563396332758055989177687609577120292484105909678934546857037299176307632935036447727717180599996592072426254255769122423991437040773975082976170615027e-01)}},
                                                              {{SC_(2.23940968513488769531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.22073899560262365694286717947505519111283644170664206771039359926910630331073658742969412774825969687561966895608228668933631484783875397376737627105822734327244074926245206170293122854697640440913645377376408795641981619695565686182046225697863421164239415487132576368407789678491873903413263920057530744320682668616303876581465600307577735903297039997271274233170932990376623624909612289532920770987498809066596075937444420611813712211792472789626062389304386432536592499629126767217589494642390982e-01), SC_(9.75029837048127723940822139588475843177309010241646824834890251549637760943126873479985410594784222688808386101184513250743227375486680081269879083496987587993892050541293998127521838902835032687085618894862339570796558908797414825586693093266928416593647501074052462459315194898583715110932923738805350182790175717405384839937757189467422189694843791570712808954321923019264560496148035150316447485360041658090233265738607692675797783748168822650033028609970920677845305526624179703136420672529771980e-01)}},
                                                              {{SC_(2.31657624244689941406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.29591182609749077127085238730170106706857736813427802366752664527336057726814890516348780149683921473939966330426614880926920513363391834821219987707185070310628905127220506682979261182544755412644963119149140529134513151273713405482176072789374585351910363421231659904446435482736921672058606578269611158940183557290963996010971436645314363561578915471036636427166369046120643121839806076708837377175313829976908135486291158992783623234671513494993196428199914265882626510236826919461730552972391764e-01), SC_(9.73287156428079478716002235261840740084659684284952238317074702351111144046965256073574026272435872923902375480127932863055570218099850498058845991144115236244780808787578236004823706045777816872726031536853820091469953621293211418659119493664242846692836341723477399946935585891718727826727210269898806213165073098754356297556028189303673469342497995341189516686033293401960600894424313593735029754214488412768090121108833953441556711975775178389200877887553119192408194268363451687882704343063502236e-01)}},
                                                              {{SC_(2.36419618129730224609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.34223349413056397535012002649904436414830305844190028305435023159273725915625176126070536513473503773761443813896860179566226215030054698884364739340175429059896502302795731430829268126913758185127914230290081466116918621292797533041072984612393204017063572807293439427376418097279461665464082135412905032217137478665683141093696829006176517072236564399362165513731516388562375669839784466484294380256956425812467551879325915966779927314593002321921021618774333412509953834406188378943630420645257043e-01), SC_(9.72182813358541786002433931175590541460042986543364086630592342885383343147001536864805980731828619596937794265961718654901510514211526139141566031421543677149169475559185660751374091780739745412205256535077926002018568915189369879576144325949910721880001449576228384354311343808510925877039105192748773741470732514283534463934140640280674768143828127412493203855945797591134707019619827976778153234830092252653180994683559102578078078112922678991500372142077874616293332485901302909710329044805275133e-01)}},
                                                              {{SC_(2.37086355686187744140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.34871488097739499325182931413505351694220593578761046285919402900396314038981468317698513784728753707678904087823880679901353228605506493220315256494105744645692747607812240920726257071852161205469905087486866758169738695197038438740564489385546672183892154520431462186791739263484418481646858664838898624946550338296059888986041536124862767319780937491163906732148464236988371556330822489239660766950561247285175680759472814930515821542521752960722919969604212826825858521092183886310338748881065702e-01), SC_(9.72026431779894251196781770060370781942232099197921106135120661810632188271447767998922653780711101087245102808499149689925215265153567962454784863549632555036609694179109787570991771070663299652723230727682947164732542496676768999691153749799756038153217247976912922241000804288378011338863184388596886818250778639888527560620930279032479989201300352288270935683655631157863204440552655928070032781156882878658304467502917435388924019356549251639438049985256013104098155541508692246870574344519742925e-01)}},
                                                              {{SC_(2.43917584419250488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.41506091145277088258055644639441358569817962482007100168326311125875063836098620622959651436734701882471449140478713900715909279878500129381183514118262024999806448408272050800309873272930533810785473686208836539208518972638810893445205260384153052201544122370711332024875386229654633135116430009940820660271175620311240007363471390893208722112919297060548435968682520385755428340093566044201493651538792843899162713805017257089805610227242722362452752755712664407437715881745250028492688314820749267e-01), SC_(9.70399303348744740629281777996064222428263418261615513535874548301569309382617106182778792029170310698906217117798672892846704087363302115493606289878448928850470701791100588123422811681772912832747047311027507693577117550759576184158586663998125715627678041983984746242143715742993728038685477261982457848406983044715860265386172457355491196156817728778006847646901469415351803533371713662907224869572879545133363858740762107694657156648981963196682114252505711326234507610327782656200028589799542508e-01)}},
                                                              {{SC_(2.56780028343200683593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.53967476197974948300470152348630856437778853649046907694498691134499701923143127504469744324018390842560373525607438987081112551226067812998235100935619020567790557343921036803399849329868217689750950833215794053798842332077966448743655775706289028308203291243933883217329742193753836170798816464800183920334186820141625424226651537454752528987557134635465607564214599658805078608562467124353038044016403220286947830566599498009540891072458280195284478680372582276803344509618865939427433243186835188e-01), SC_(9.67212758928267564909913781023042850649210074113110150779555204117688346768013381733678013082194846590955208239649965969631661476988930023126634900965028238708450802408191612909963009729559467638514828430744779946263855525266081909443245556093474249189026431060834809707402911975224217225893793806041927048869332697822498929087665975883008669509854597503249122523872773752290855879726093009296214739100119212703964980457607123946633959558534528977914687915954938045274688207897907901409739771736928444e-01)}},
                                                              {{SC_(2.60797739028930664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.57851397011684381653215493513429137796568027542563688065682683181925805410498887334830107315497716941069126625883444139803709878524172956770808697806028611481752384474693564304778209137714825262189628252311617579879431939465205565896109133223548776955538905705145912571038082487099819804976109268792901846106723571853632186612320550153956924085148492263001817363502564890939924812502952221465569860263998509729178129210248318839719688265189638258894020460309734694369100144115339691339084345644936187e-01), SC_(9.66184587467178925054039264094455111955839447116830926670726695111056480734643576588829589093151750938173095092013885475613504226596420519468505671990665350017874837095070411073494200828261854901406233203038856164661310773504995966871525893796073964171780940959271419513681242667294030646037129134794487249645323271597514346135643239350470405850128978217907312787357546601749225176561132483998559247022954834588628902720040609501476406971711684162585915398239747400812327533943923544201497396858592127e-01)}},
                                                              {{SC_(2.80308842658996582031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.76652450296482007185109133379664986610558754140681586207688902695753779035115936420467935545647816866342460857251769261384109822160070822065813412470021999090276003650217199311308412474031531959235881402933414328774518297808848844446010593758203002690435296417019422446348869688663492867691085846932064019691350818883217102844458071500953410615967446227001405852516815294644032584384232982816378360038056258865349197065218045342401352567566701966410085468889024864179205506936222190409656968011900042e-01), SC_(9.60970042064242787586616146107116426197837340865418091095527345944895322898303059643272818932380762260288437483034417861243469274929582394086567541874872298007787708205027386061888638647875009556202948648007162736259944552779661019144892638210622883831588324760346381909877348578780965122436104866880945115333116909739647331839907523858068914185740875256136194033491002352245919072705583433053970894735852186581105174794397321295820740029624593397555262163670489560045281417159094407435052568544583826e-01)}},
                                                              {{SC_(2.82572865486145019531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.78827397517083501471330268973793982020956043056485002311128625203480909125454608266708548153980451085052473210601286247173130026031229525696322745955073475919151565202896009717230846962853493839247625955407998823036775750704244213916449208714368364119934116691972792082838205032077422066968600200507619855517581347340368705484048290481249715689825146802325327892978911844770343056488391346810580610465544218157636626264496716159139173077724718154881144994010887526795536631047147615072038166218903597e-01), SC_(9.60341232267911267381183747437916412664206145164440808035842262775205190353599826199664529625608027776265256698881777090330134881882621301243080560629047040706379584629760415449833531862131285447677178430450969795503445162404785990634547384830535281646944622238215968178098765324782398030728384865653375265992828298473324897027995908029167111445460569023719561109308443466971207024803868610011124698023157985663134329675540970828039088533857954500329172829898440732546662708726879160639308567661975472e-01)}},
                                                              {{SC_(2.94892787933349609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(2.90637267717841491949561104535364579480516629619465233961662088429726507862432828707755088894634084811614033440036389382302935785798227412292625877543660982096842193549591017682122950990682866966335040743620085528472443575918955519317567547115188821596525197289422532447233271171624471539630699450236545660114361779939258247443407627749697559018581819196742844858102033694745403183397812269091094587500437089812851864223611210570999251990567044704396204865960223230481030875348590845729075010947570529e-01), SC_(9.56833307642197273737587591887788902883665572636978591492719689000054294005116111584930889939634837715671167147624840625565369350659889484795889431524480465624414463011497751732807591607039510326250228891745651691444695736686228212611256519708123525260472804829095732402311433573156680016224942389308080982389958686607782516409251583788265789714265801240259587125208043655617146669163064294419760829759381222936837853395161186480505868322168426789639562818842156041662627171754918917363217994882867932e-01)}},
                                                              {{SC_(3.12102079391479492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.07059841753405999831874709749253165600072848512992844635835215773540826519074442226231634868055680476383181767927905664549163235763421873187566026682056186067295416245364237011824046633465852367385333102571562124547765118946951955979688673963059577571404554960876833646916051947025162143308838685134878667283759479195753638922242852116176090313158946224342073520204197762440935994303058357749693323128948419047343584057635944717911926030922197584857079144392533616441138045686008248146167555714269123e-01), SC_(9.51690208829729037576840431988604462673713730884139839166679534444816195557573539853339641864393360660504275727368557568823262838299991557009265270390565138215230359107809334255713836733104929918340210504480125985259471413876980637442771471105254330498206205878359629897338212290265053486914375204242144872790154864198319326981914100262103960665203670552921064019141135434898985176613523157296876279526400987298715110843171312881802185002847789634535539274790806820388986630862009819666177780928476240e-01)}},
                                                              {{SC_(3.15313577651977539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.10114604486452371602244148218816881223891635019324529166287448596151639111642932716934998031321887758081822105206398127173805917178421889838267708823608322091462547482629887325714398579152373118391661733631956935670424908070096598288890186299966082187457854379359428008012221981487666435201267688526933831111640545952633383495730237567915622726814523104107288235805511234197870540243163367745558344313156824938835437324606528773827062481267605862954451462115351447898439272364530965442052891672758788e-01), SC_(9.50699180647701628487396566148787086923240127099513645066330648238578006503678248562865690654153023205128969226084861843000896121071452674247004201594177477295365880682146363659658132961000098514414933707666096881539616427931595066196727129449358218571438918172767600483899976768586022179968871687915301710377855566927304861652670623702239418492743070118830570825034432808087497781397107161393707647233534139257467088129639462402890402094063987132136815195270053434040240225055479367979728606616266096e-01)}},
                                                              {{SC_(3.17886471748352050781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.12559623651764165322212807870515013629324029147733283136368157446606778188930564445609204886499961778113105740877974322135198114141812803765994002806460822966254911867494481580789265715208254959317709157241611034313201797819867973863308003889863252875768021308953698342014871650514004286660121299147145333979151295417317040523136489794647687655750518369731036588972462596472475088750359571516960658510285090228124769299218077291363452482650542774467825115316859673619565065980798986374309452485170930e-01), SC_(9.49898142783039421065638698949823517999068885390741197315225792223882369515799723390096969334365360799651944990990126008736260456275912352502979942152551441391703277100848388597129862238754948539625430194167651244865488557343514835741689946133613892883144839999896471282632969671310466844604095590514416359901407768042119424637583642405348701870119240322957130956609821641725423853445963795969550741785845954269196961410704228281960935161638393923018793106680802489022846850256426254909441722034633798e-01)}},
                                                              {{SC_(3.25856685638427734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.20120507353269781855753495379878039066037854006666100431875056421838413804434799538536796131401377586084756848199762002155463765917890690463278250414769080484724898769887576443647712277040855636736860793283673505250629213435263243010952510656350940830571318488977600380399190797841811306256449264920800681050590486560731400712511724653545521079473607389857426102523810827917591200372568412968363871519210398075893782835325802414254408155013444580413932023311974315726620968068870995641605931014140420e-01), SC_(9.47376831451922908762838282957157442145992857786296235784212495393301704460104847354739924979541258506937517027115869803548217365292294994683305525441088520786504133711569381042592814747227046691642156766413306928961886122517550515083018577582754286916121647946117367658688563677805002026853118734799467123603953437571908546773590375255669559554195262563484850221119526769206964645745371200283122087981568125996313543979605856609804588391661451911736704107832279674007979966459328784100364931584175637e-01)}},
                                                              {{SC_(3.31551074981689453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.25510020620429986937042364685995969898965460442426061833759213271618775572332502534089976614218129638667760054701539234024827232341487900744015042229086883340942475886670748218967768455382802470563754576394285926348980977435867907849404743916110773490924826531389495227209664054616287863263783122017536567084703743906774484377495915058868396046672143731061243453772643054096975342187985727367782927328631174431309715560975124132906098483254874892901622307738985680021770864791926680949697814898232436e-01), SC_(9.45538590685587641765146475422348939326429323171424621391898923841241370861109699620118035342769801759409482544912117998047100210926071569675065306266069361724656534365587037037868110606988888827981568032856808887256355100408672863943230307292336810456098125754092279702826073831888005340499510809313153503087612891627341062875052751636176617417058464678078249954552097871951771955835877730404553836456812938118844431736505209097446001441186653820938292010753906907384093172264239077979415805009120406e-01)}},
                                                              {{SC_(3.34280610084533691406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.28089685607080709228217073013829244980086878681949079724399520487633027638394190434541814538400934905081532180164816420388055285420665732864262317815475564039316355408118701761716444027112107825164951281390900576158191601679471853089452996750018086395127843764080783337257824990676149886920563849748965785244823891473305743274155685943018629644086807243531846369123999673290765390381103557636778684428308305943242684044162534423213607060046023289485555906833555493391103695531498716169793021646257608e-01), SC_(9.44646578461091414178776104696863057321576035366318900946928701896304565272753568134499944857053310401296727371998536245581622116253817033069387105765921559789265574277799055105587127575674744417653448482768341621979927800216571038767329703960510700455029704060654386415669464439544055800082527669571331791333036873476255791772619645842425077726695598719804374966376814363540378984520539528376950546852227736557661595457652530058530010384807128844351046874339155347485472200170675059489215428103783219e-01)}},
                                                              {{SC_(3.35717916488647460937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.29447092824512814936909857333978391523033617107845224299960052310075505573523247423806894791454173014988340319577201412086373605467361183369713001711732687942338004705092653189077698811297143742952310132467187968195376507525259359760053099658177296477700127870263226898313059209834688876407522087440889041166353266203804392232463726842268818252672072718758696114963418808736803405270840450891988650029268928068267593406313414900302848492608154325818062755380535403696499569100684167144016534622448204e-01), SC_(9.44174037468451489365267088035088591308914231862690972249200442949837785950407535409027599648599285502776226478256147933109443887177193380043180048082903797204441059665700123928027068350881895026828260257751054653259489839515100869333027571748111448461762198635703731207762633225551171516871297042884419072089644553053235367393558819799679458992088965895165907796551275946174973771996164630689803536114225907566862466732519042785081005181299097377872608409782965170572073375788770099631685964443078209e-01)}},
                                                              {{SC_(3.45234036445617675781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.38416913937733709520966757813075385353964521900390094265192777781629180976759543154906543836722578297225206900391344879893757491801180228412619362904008080592164773731715770901812124465081132683256968992983463490691796826575296603858671986156353981116073706044250214430461363924565609842848686311030235843992906274408601427805012593167720487267919576241994420803073155263941036332062580595356544207542092603981843801789150431453028466293952942033458196009466273835759200514863565639305138731359336054e-01), SC_(9.40996276486182773958200681776617930878019625164650782459989674721685786733581681932601940668534891638624819666126614999639608538389019139033792924807887873658144072477439537153459888339322514858220157931802931480799204440924867456798681215615902875232401509200568538258491816834661886375031648651053695695008518747665629066305896997139102057691144830863318193139443798505854893484971824361515308653303166230586156475304484860728890612192233269198727803441963654040189339709235023467037077230210136452e-01)}},
                                                              {{SC_(3.65287423133850097656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.57217768507894662568204947843255675807937935600700729302012587696524783357810607397048811065814498967938226837184635262008597624722131769201971396723630579715381213329596400181363335657577351531699109052437321287680445033826034637398775827065362847680483693681794005685257771393744322277497734213843627872895529910124192773346772853342732564856818563872653596038077001555882493740980096900501269614510507341673697089464726073205061497129282810973902529861673474624188173849172105673056093274773828338e-01), SC_(9.34021127096298705697968078480829135151809558383637730911362229182562918575674304188846684078772850195185983871489264274885680433213531999184880930953027049908681630726745658816468630368765358193438388444550380824018487174292352049577694523697545985202828138906216082567906790013271192556165028307746636921068023709736571214708295379075646659675734920359518901568485358630990354123359427090885536764271109786114632830747506518916681775364286220930917538283026948726952104248202947677212055723332125159e-01)}},
                                                              {{SC_(3.76625776290893554687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.67784841593578700750674588555290009506833785198348319721510313441501546058321463219147968315752577898440423256713691448443581574192691647704995440505255700751654076648229558941889912601977821037648184590226948590561121481406700523514552066740175676313066736046455083685677333444270219582696300014573394994875787124404609023528711412221065511192883282687720036086778754443433513428817391919934679127030005160315851412786694335867458231606781752083185163741537531916116786797423415811680704425913470479e-01), SC_(9.29910915246178956526127762996390085290835200613356307328386220167870557042453483854688920463534735704848107614579700250713670021607230520617663103835363172580954471811001208312362172610537525644872697074572921104882182234857955896468720884006442649267334904910635015379373768510723551974327520256221002373202064028482209593021722744220780901469462072704535345501354165333323228964404508546659907713114416707717373662856960688517308985925955799243302609395864738074576882921050328851524967663617819963e-01)}},
                                                              {{SC_(3.81423234939575195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.72241801255514780141645255986938706876112807774978209509387148729169318290725606760700653681913332402962543956038634844559249660919958569216458990534120382717908857425855493941999728044814288058920926074711487206514766810508241197785036696492456712063744278868653038662478625419883184188761197478075666687066372036201467246772272514710952851151273578267666562536774184425760572090907481461965187195084739783731922123489291901533461093513997345050166140627717868911685869010459883198045391385926459228e-01), SC_(9.28135788232546194521132038364809995469390110444963627733003823836878564741627652253894760903734146992929661240763368047921077487071511504258052886480661022417869838293793674031109329225882528098987875042539736745335504700923216449394354443076336899632696517389138146947845556614246814361499391989253510866187677919616513098995303183374067848140596880185394397200828384737411722734422037179383107166780417945465829318245357854600550219827881612091297993125943808294920703332405152597090926176383075193e-01)}},
                                                              {{SC_(3.82642626762390136718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.73373285419486584743972658295685803190680477862822134739166666187839123230941197490101744569617457178315335266166130750832991878909867576156780303116056310420466140082721299101200920702587341679821454021314334846514284242173605432831549954909671972671604204676424139437229520093260765713230589032508436314799966796028238874135487653755383689513250270278030424284694964092242438945526030368678720080221231287652171512279965394603632848669343837316862349798845015377578075793534194003618831109022953953e-01), SC_(9.27681189706387550241935391516788441140986263214363275884321094395171137913622380067740793234692019438631673928581985674669506916341156375623168665333737228363700115091027793798720619125927596016451913658533598902824347300282112219023964174055808582619361609375580562926630694475951148344747973622432995121921328491332370352018238045259859104891643718529474561294212242144058064169023705465099799598255743376952428127753351863671878368910927582778614322123906693275823239648107835571442216049845322932e-01)}},
                                                              {{SC_(3.86262297630310058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(3.76728732695111995209787047749548789524801202873801147414647946480127764915716334061985047622063956465372047461169513840471796315532115359173336743873445306005316281253589057706496674703637936040009863228061656133466646243287601606843215898479726999791238624900548309438738434809614670759249615353685532441359840957459574816765343647633245421595235656600614508712872485696566736853933569217131361140361224346898137318046381744922966597856864444242287465346902114484239349231535780595166779044827033795e-01), SC_(9.26323627012684403552362441816766844353860232235455582510490392971499945546238943437785773235217661433283894687038938985447511929341894290408129096863458949295692036268832967955731447440343561805616333244588222790288419597665737236923593354868829890705441309176814435749719667609906194049295915307431333453326042332981889559360874887602964847967422924588792838807113367272643542930126342757662817756798637736653902160534644351581798443570915292325167093110317648605200947026727695940938373926472433313e-01)}},
                                                              {{SC_(4.14037585258483886718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.02309022358804334757455041997461333566140505078691743879158537946197564687528817873499495932056914664975872822876541937159526309012964625414972273125477031300099908935396987856592915608056201697241267655473404418171750547283488188116580865118519309071287054397095416522184857129278271466239596660565476766442047439665102232580947339905130546605943299522702167491665865861076373670504643374092808500589913972673958794539143899968006744027676954924675483526113359150297838140830328866816034327650573685e-01), SC_(9.15503932557748805795905106327040154624309109701469277166353323330495047580465013025792659440882401238426239102234866148304120914512259428508256188143971352721134308110915372071940331370587398302755815933308805154767044792918730422938424084182623711157576329336501323833302695423872291003776628955935696475315999936581807634223263656320757954433352571965156768392318835020186996543923793469596505462054756265809715842422711159634535912628317197753269865492968844280778333139750719502353805594952751573e-01)}},
                                                              {{SC_(4.15384411811828613281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.03541682109578222980709967440528517225985048739181053234151269824226530297613648513864625533998909524118788668236538749776089110757004324146429534716651136448541877388486900985147623171694083216557078569832275804610942289353672351183249955641829618726108926348664457812212186737762600307260074435150664091951860119867223657528500247305269729397446717578634530181642697357377164502826308277017576726140565738798396384850379134564652651902037517959442379535178746452390200652275134723487656738588814040e-01), SC_(9.14961261912312938531757251963975606171056514942473409705633306647449354976379445925883627419334645798319079684226691906378008685660573351264008078882588903388240223429432390727582752229567332000937331874060395961329538558312773141574847698110453487234957120645662388905771842480604587202066148916563834063955601294103619888302125700623333672970104702059659671918785799250960251049309415162312990259195375210720989849071824171027512824769600511128542169208024958188843927510126581850114332992578859756e-01)}},
                                                              {{SC_(4.17747259140014648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.05702467375339262830292961509995901497692400867284402738762532834250477363835078085965934594517062125768598757766526851922833631754674647828222320869834909184759233249381727184636148778919865878136269359838089231384756518279665084042168764638527443222169694429102756136038221869866520348923978295435720362171281132579960723316488821997782812137875635001430867252792096344762654563157443481314180207819454673446288993477360064344949498458150462068431701395898113402567554058677908621209917529511274949e-01), SC_(9.14005201279271594646377346252649494298094855187886202187175311561295118776486501235354805261697066551835374680825865131418933539899994837700018314030655871117929178075445220795873239047434025597938694394502337464256413558388215077611141956094182176309111001038031202569691323194114312105868329503689334322876507456971856138524924216804206474505999929378281865606690640041390901257392444895055519693226371911181192458524126880247545501940273866502248870119369368065587202123602049180417713932024067610e-01)}},
                                                              {{SC_(4.28758502006530761718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.15742002299706000420350747592552687972223045741113120302870426713056348785134333968622790831264865107728759354826226457922147645004178978906890466302133894988997910046095558992072339508109922275893059300684403843403469208547491053713557851579495826754053336803498111074934352037413097450601064007516266973130955034354985639275464069104775602331875698543320889524438624926558219777388682431329523910340231167389669640360911599413959164117296479251134912579386628245181559149830695067791965265989825212e-01), SC_(9.09482593304473997538693396104501021330804905259321616290965777176758565932026915430359578499551755453855018104008343574872469655100484191283971052910960684234579468489756593689367139584789587966575411667359624750619523168195322985712252979133849950930553365725100676073949846542207245503600835471380015446062680593988976586976478740651122179506841813035927991211507985430856749772714779898018916484970646645074598872686609284387685242249795194138385627188402736027247052002783295346662465818309068700e-01)}},
                                                              {{SC_(4.45544123649597167968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.30948948363146300723121092898082664509638352166588140034727822877235815161424352108919540042044112538762724321500621101449739714554194593913009804814082214319683236683235378672131292239439017243450275920171408813452754685876072458057289815611669924772864816375713651966864094479591019632462077369132936038735863542405984367874267619758481899414566965131924850013983459072412954571431179625787390548119791714022129981306939522139524756766141242804301974521747526987847195165237002774828120929063067044e-01), SC_(9.02376309476649693441524341643113425775341759303426903412911273366445409015974195367557714002958404562092936423592261308595113855232080165919809274780820143580092975184546098062572003695941781094812237267584142325544572854177059090387904225847548546592604087162701961190008072455837295803252923772102729014511396836934627011018807054959294568326023254994571985005643935955842579796563403396030474028550374274698865457770359922325670148823411893173811002205405063320700662280071632096466284915759116824e-01)}},
                                                              {{SC_(4.49747562408447265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.34738213556773642926680214435395136165212079597736426483577114464574954760942735244406621691382502626047930455107796986703456539799434205636585457310894775674965419564259809763663316804513179985632601467299117182000653051524824513608156808552962216189357948272785772516989094473515847766720617268987918246630121096935720033107216651369640459371086215249538380063034041248614589579006572327908496498138487884900261661990149804231843631572049720496487316635858861663215229112020031694962813171109404925e-01), SC_(9.00556875312972708386219971645514750726407028236990166826545850690241517101112402708386772819738278247821223039253372151806624483240868170703439164500972016802825899173423975206096499267656188494467490343061966750639625116172486836412318757879291167804312026689814805881985161435878128369258978791474612039898718575491126104848948833513149233754819803905446108254996077234113802957319405644663301288887608570332657255734673102012379728597740044611750650505636559769166038774171113885058050685760522703e-01)}},
                                                              {{SC_(4.52869653701782226562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.37547710974994897584705187753064697109279998870352465729791285811775949783450984369414186976030231997903936542730772259184602150876951845237393810162537878680147493102334921792973422725128642580343784196916482216571759314951546223891751601357730521264862292717459596414748032496113998107987677978514908760965351653539082846202141162068066229715005699057270713171635519654203034142538854077714450937335807216193587516840434812114463380335247298814001603054089595274484793803913196348729067932487448869e-01), SC_(8.99195196061757399361053971564480269499531017554558188806333532790012165395566350778235469914291403214368025663247285422108383319133726403092839105467674583216419489996730319770017782834530964004420191763527478616501382056309331494135424274941738292844744198027230566152257675219107464838859525235403944781216731525975237957756110906785551166391061485422062979524846055589057024469448090864935182011774817757038151966849853878680226230008627334013666482561987510034815801678655762497740517344098508436e-01)}},
                                                              {{SC_(4.62250471115112304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.45963521312847654864328865321710153834950250932578074080324986865345001347757477980380037307625324316996140869018244797349374314464797111971273640399940359453625448104401592160237931091521134609576373756124867133666878568292268216685175056070883653017465501384214652347965224862323686499134477315926437827890962697836714416129583317366024114625719308608134932258724707861838402087026685949036796896658072984061548484922337651296656540856877253462004253362254138979753923381025363013468060276015659293e-01), SC_(8.95051136895677751924617384872825864034823165128075186190186597441499402594610028026215446231506707482496405049193560314497720776949998204342602626498576594729080138214268311850150450912069884690009285781631057732878261831293268241590115039762894904299669089563069911684151632786373315966907384512964784420116764033039210775638548338742350110429036452439780448368390817796260243838052068698870453925512851854018094826029153391333450112576463179849305395825697902104526169507205246156780703291651512347e-01)}},
                                                              {{SC_(4.74825620651245117187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.57183365940682599975989520970592586820486164181686091846497267559877931718112664415849754810563402264421555205308368211389019514311727090114799160111233458181110518886927325494153150458455801368383321159237832190181397017179788788565348034671792474074784951689636545848238112091715561617887192620879235113630727198916655136944495368600608371090443370159079467076296209058342329613809933283306711620704002298838140270847129213918736992399234035900728679054869995037571067012754502573122858410648385207e-01), SC_(8.89372458482467232515984882706268766316392175186312413450500984156418092064222973341734033663013416063605391090026250094816551319611263513570756366575940855133970988017874843537293831076015304335361026846863787886532344841888477575519000815281674674387373130886802697452616125647564031430432280728588072646726366057290517226076579554292387459886530913543780265990513411010099135364163024190628978406074455036483606737916437326240976630201256303072037744603889453782870568782425202552340165074002154219e-01)}},
                                                              {{SC_(4.75649237632751464843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.57915713053557019712710571041157624420787445280707553767877608145773274376823349750814872550223275249292408134487143378104524868096954725883300351468974464179235940736798953299937073264153740357562860979284897004173565825491677916037847354653853155697330499983418051656375578206854603319061745926619692052275536816848374432279273225818616759602890929640567133790022595885478921907728424755506810023816964299739366390511572287460730643931920759167017258310322725947076324143381556431536551482912904556e-01), SC_(8.88995612890554386936750536483695852513476134588276854940621936209484798254166731221556577381797747107009996077607638797281282169756881823806605504914655485098662478733008167757208013537007605205995390767969085354280041451305854109862952210025061158261775701522354478989910552534967567504369494925409880197034305655329641794883644933639429106847302092581964216122603833735671572473609141321663618765145993837213168005923374608817688486956543652958560596935007260687185222881835947991213367235624530633e-01)}},
                                                              {{SC_(4.98672366142272949218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.78260008103898513541770539979545252964823085593186147977805482371936090051789194883298976044663165847231099537581272151268640403450342975211569193068993143884689281956002319593954584670463486438521537593822985913643621122287101931914945599854160679995190456369532992685427878582889478807139605978076391142750636244370938945332122662246707951249901241678461593975209892588164366223696745448816630911122129541960760185263002196493023080164412082738356264476994025730867735243022611054082301179912362960e-01), SC_(8.78218289862183938423134673320051739785499965734206019255453944263680156104999722243484431478559982894433211165939525740927677802481620209787987469668196432753183348602917650360351196761705324639570894678343806174504972464616029398441977168964174542305616645585564890203491919072688843982057716214127237367286250524167686496351943954136209482432227787458499924910595283308987464828136067964950498523525151712485885751332694062133562868735135666502557385948862113323459244344865735722400659905954097980e-01)}},
                                                              {{SC_(5.05683898925781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.84405858017577105986267760267483916585338576749856882759172895626687414023600023273330690992932111166705419294046737645663748536483800337813273369788242501381982115588238995601497093664158009612529499219498997691419631936695751958404275519240089912385757776444311694253366794224413925157246424719597851079869724407808712512352837701427411197808439056422135011271874004431323584925233546760901701318303123610840709380726059202286895071249175118205548698394421602866816959285749061736352965182903328770e-01), SC_(8.74843394395965551309879575006994293780170209819355112069780111612973176064466490116143405110208953320912424509429632141945615508727433835671823209591595840027117758435836418746698473625487160353463202211263804287657238763845717958427514637781076681465849283293563449319792496466343071382848353682561994442500049737084819031517295595081500622131788600851578430131514229865791059536905654539814085000247420280886316611742047606970990845403989012375369636742595073827358323462326594252382348796306577237e-01)}},
                                                              {{SC_(5.10578632354736328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(4.88682163339641268740830993903499713333103251236996499716006988777878015736524923456957058032463916399381796036990599132100356276535658883546305343337696754464061676188567185777127466524069532800341427586153710719912664955598618474630711138614946373765273877760472582085430071576921952645961698653272413608503453153197806113172393198844347178330076429745969698136022573102889522545090495121172637471356210616480434202516259895560003549541729134784090264648450886179847814571572888679828103974661136166e-01), SC_(8.72461886407474060714407841408344103310566393107946054900278740601639720374550511441120502252902388979754468889400577378186176037091714805093039021955101337802634805647926475922612749821549415482888476878706213592331467661841014901258491776322643364592301082694865914465905995266182295642416483243655610737136004298484481805105164211720159011364859704660695558074043648664464886946042750820472298682202778339382014672269839699188939702066594156121240103071280379589772983226226437628463900506596443992e-01)}},
                                                              {{SC_(5.24975538253784179687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.01191837189188332694214140970173583272072418982091171099990217528322355908701601074843574220620926568587427100106185208424141794463468318550749865198918222933452753894983168862879395093972863777587162854161341623838683267634514499273793634809539888243351153777357711863648802112720860674910650236088326557687244625352269331347752591187431084268052625047310691014416304761150712344502076944589767381122718623738029559779248541968413215734845216817629335238040083726559240958493572045375949676422640901e-01), SC_(8.65336201909365476282264952965879813708728978060751127967654913609217370202756737977950828334691199199976926417238532043794926355532947481142954461407252044813719568757784382743516894146761032400992386509481533113010581110801833850543938490300413179047145173264679839208757360189966101065499739619788796308134610685979722462447024950122740160145465326704016943161732826708923981690332630029591524534742203726563441280505345615124076805639821503843825847147963259968095571638786355692009671769162227729e-01)}},
                                                              {{SC_(5.27489185333251953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.03365401345449383408860333424913780207988550100204590028868870029082008815431504758423586705415291104049317650359215675999850793031199068663273702222642153320423789127546017526321083163725048619710917303499008938706160379552195898338647888596408687619633428569339435377627846917599043895430679468876428984172711517157785079613456068832181981407178101377847554189494406405298668146314781890996229730542960457346820729615088234861697107177030173183731100838582070578677194620296888474892159954565273594e-01), SC_(8.64073650060187094044260451547211688700438767712561600570577794828378726394909204189762941771991578220730402396676955636744871614391751352329593543084586941879928932358923438955814670349084472219097888970353931097795949207204991643980011491931912057515838687636408011057380021854018301724623343646746214428802010107396186526576456932281434816548797579780532292096032569488952258398391121041148784934172900458255768654111061811230940022903378642763134546338073627936701731193377581008095280554682508859e-01)}},
                                                              {{SC_(5.29143571853637695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.04794223638559654714052859357090717999622260784855409808634989078887486144940014927685708982597532834080469457507632961361574662347134140277434796217695714501665325492161428047990334644102887653883512211880498181056340765678114100867222775547658592234983367280978413240569780775952453371822485892673013027626427801396787248830744260539502204944014104375516044504428492436280713415468738598119114927622247476993647376152875728729101947432829638976206820212333445472631237675433182564095978329615664320e-01), SC_(8.63239707022993597136893322506765820034361346112663538463972414791073370154305164478378003111211836597802305631320518420581136473884404652772091008668276365589888289444996661499277415993805087615581532633652799512767943967396863329599519961592029296231874682822172954305207266939493791501493068017981697650940168348078699710912960970725464127937645010065872291814436415764998136905354545811245853507327765948785155015610075015341632933686909091119377821270677144528894661672118438512863633219124320223e-01)}},
                                                              {{SC_(5.34517526626586914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.09425923396651827601926822928735155064088252856426082786526190845964204988316925419044872254542709621420571540784006603826411811003448639408384047769534128208911369114785800703498443321159790230667967132978923969686304217145245447891299325303801607122440580539861470662063751394859981212814864251307909808543755875881980444282277876104151040347175759486733148808186549450553664854348136500863053904875153607921232269445247407180353728071225524914373935912046274984168277951004602019741469779806341241e-01), SC_(8.60514513864506892008571077192207221249060554026029914290576312340240258880637028036909369321348861974704776026746365068619441047096898112000033846266863807610452759734582914614646277049293267980030326298443752183971203489738755455196461434851228175258681960086135023742465121275230985955002403734817537433921953870100053610664908725632388126059875337258857523149249629888488047691276578125376557074285503537637244758876151932277452200896536592707368519003989964434924497304420869045947916636586185059e-01)}},
                                                              {{SC_(5.41940927505493164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.15799772553089175322429546804626528729984402971095986838191671437559838091400764456186303627799843763884537162041166087814106014538813389286133552707573620685136964249044596156941771605153568829089706663067154626220611610688573741181955647188194844164474728375527074823727245043102213030247601723739382886465900641274005163769190452602531242975852118536822257500909949021778880648088059230266333056383840262532179419129696109838728004168475695024970146221363032255275220888680046617773531409243514538e-01), SC_(8.56709165723223411014335237353370281255069331993132041369453793661319800459427331933541840549977376297771348346737288581359391451133900500291090244022962821184927791851021143294497495159928725343129789287753994061178720219940683024896165695812422117725701849685285221767838000418978261631909106043845565174640775546510270806417747477826212960857379830622034161031711153431645404985440073536073344356127003444050336984235043061917702296234719814367574435512053911951724834398066173178051050112431061131e-01)}},
                                                              {{SC_(5.70668697357177734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.40194904999217521625501804690859171039067247880710746234208426075198607183471611383408202308291614394771378315161022120939361683341863245328239311080525400231914759172133604894627749585360351572238809861901598552562064229601453100001108907323135635709408318063048590299037584475217997696082682643246277303267205386540634807765892444596945715402510723540439660292036601740905303050564714747573350134003426478908063404417845734148975182487931433252466861406507785899684486691296993422451783426280298401e-01), SC_(8.41539936433730016393560004906422624915938938115325194490676417499454277363257513351717803741102759502698131899495817149812454909175331973883700436174253569027354446001310497645728117157402769598212946681008744824515769796806799794169428154993163962915010793856563617839979899789147308534322116774551895925642603030657985033808960856990336366381026392080924808370232298262132280338670172394908359719237017432710995566031980474531261480441546418187451593636619852940900815738161505085936768543613021562e-01)}},
                                                              {{SC_(5.72337627410888671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.41598623328850393437633038062021323062155738168341351833436028051969259019802500119843827650904770820919729374704351821359078594634887244323485747368770264507358749265565856367907429518697764687039946840362229092312343189528022703643914914433562134342001022778527431759309937446852858562197449128236170264433346711673981647198294649587638318617209546521551647034779793514294203444340604570797513762817006497651085453358051967836529579122058034836273502520814068448980054745761558457956910656478888369e-01), SC_(8.40637217358530962617166869970573153775954370007516064477940281451417234267504782461385855075871355157179288974185941910150256426691364101853486231269256472771425076245123147503280465557373884684173386719681462663766345749724735744081185615292127240794974750109376937292899249194855048353532646675177599991950894912833572228079283360178968590319455475444665383695538491207634412121327239846638502720531644839511030834497680853242745850920233520996468882127230891627624467473374628176256541247234848953e-01)}},
                                                              {{SC_(5.80943822860717773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.48813165155509844192454069897378255222059800318848971214181522712559752371392694439688950488008279295033778330851407407538523566795739799654146239460178355402348023334155625459433534500603056681526233824629667872588475660174360717409290346777163781004021237411856260793132118482661903922892916677044810015653072554145111411250594554349346047088432220346892733029194947849380035748205871877674526988365095539652382297318895709019317770178368606577779278083479508492404153089849803687769215965281310732e-01), SC_(8.35945039911112263677095616391004433124413495567336752167508906438259743069245990282913973214554571969177304385557106963604907643376708364394277256629360667941308687198759712832908130207745510426514303099747739695715739450579154667857648740171678725754478281782329679391568802376848420455165726573253805090116019404447208067037349934527135867262568590898932612843028746601037322593214456836565075844042126797907841397369397266754100931894716926234857663254549747660361282112980225408873527817007427990e-01)}},
                                                              {{SC_(5.82854509353637695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.50409391298168491596150482570353186473225165074869249579230018842157715680613771764649128192314700378992368535474742002485011421875906957385285657324300726277958078036298364933603213485725269218826700648644800418611737606433714230535321683504247685363594238155126069310747013818822879985570627906886508978408394982831547956257956536544590409045853086713179410800861138484380067373798502293727454801649155059590149624917718627938217373033323795237305120621762948047394416264859542618264254192433551073e-01), SC_(8.34894904745968397122337143288036538697236885805361244093975311074767740052020907304944995451086032530150791095893934644176994383991691599271559032684425891447484026866957350929544470806453316870804998160772266105931932446680136021999620883072198820874483568703347245846148122134149561292328463469229261516928882818387894901878049370770830895114699946795594153739461667478785018799954247645045229378473876480527746725169467194980012963031723208736422455186147677872207396000474362366949139854735598959e-01)}},
                                                              {{SC_(5.88340520858764648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.54981328748038594389409222118296493361406722204316601039080045097561746367256420457135064548526427768164560764497538972461049133429788803032011714631332435608878919210217380233636379382769112156998945046969620193348706178392702708810399735183425378496361615421991110404840318568945206401436743158511187018101434033771663853525624649878863128943966755740362299129646209442115612058642089207004232090022736843462658328519333427718454217482740286302870932210190437836952038240934544486327443980179039611e-01), SC_(8.31862804037457555573106159931804242284656404384485071335994653733473005054884858296577229285204654906976630312250918448628259671755231029989458048999183555644405516193443670517849772686240891945946039525999988429248534398424025093271276531490728880513255793488192330389893779683789326076963100529203447817457355637888154612527551686629330928079288557304750909983330349509528372839396456227835571961111453638045659531283279746393377633392525795321762710545335320001100575629727024680780347585595575401e-01)}},
                                                              {{SC_(5.88480710983276367187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.55097942244132061495531571165679871262724499795417513173083413485055019772427361468552500656487265250806213156009035760042477803381019482502820928713219477595502474314187126251062789023921328177960662028807827415938348104614614375028942563055067804906294650682269671995277955728374031283398921302129002652523268955506602620674798387968196126816730022488639662515652349431661679239799288485652945302886443757790689209020541656411027584022229840977377299248051528161147723320595369228691342415811208773e-01), SC_(8.31784992961720983534359232391305188584063751853626211735857810341353297240324549055333935647771867957433112311280525051166735373970035761464744610858062803351708601490642216194702218471579830292132620536272778346971800827572537398578189594660242145927783320871528142664463408523731435595615813644112256518861511592562839704037855278536568685836654817502765844816585425626008475692953552493348690999667725721103065091643783290643380737951921116821247273152701349225223838419791660101143482872112798004e-01)}},
                                                              {{SC_(5.92362165451049804687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.58322288253439051744557534267506286885060444861732597553964794301319966217038367928168951903535702321312327402000330303180259309249997384870049569392286402372655538202926605727312480426025714746316833966374166956030639926161547076571832803358539092894342194537261846646241645995470185118744157796984447771024032092880613250533078792521101538396462947988540549649727418090597597042369359700302976217046151525960360893745433255209441737159975029418199167071462611499945258530939279452145306487229413816e-01), SC_(8.29624145284745020516215455724407888077213673743160788252677680220684699002053633204757665277322687553558235918282689862240807444306321340921280927942735138774702365689856787083484164468516551522355741319231716986119476001913931681490030833762017164619862117967111307933862130716575515431340977126892141889221627007181268431489962360421173167336434798315226930647680073783873124528566080722281638117951478967706088693998991575443387902213162302286315711337900394259691186938803878903789406657834635069e-01)}},
                                                              {{SC_(5.98107814788818359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.63079775669406341164390113803457426876218890714643705918420902570219293533895083351987901536166942345184372663706747350140651014744113421153546396462631796031006217208526759117477953688062277202759268233614725401418898666007993416469703642358102740447434080477006785791875740627440576182794001744019355766499403487919514669225812073408286318205970784355082471973998831868467854363704446997087804272211009212208588585247986200104642732141375695026387981342821975523123173641969953803066131974996648408e-01), SC_(8.26402544909011658241432585065175399903821756918495896750301886981808712362149771940549292790542650045147545087131705570423534902313068039653779493898450768666898915232115053623498506902881479053281044503339148499487375815668198415204385288141684801981955764702648853853788870503645633524763713779262558003952462666882738272366662792158419831973039867973436791725975558771042770624392035686827655124184929447826740277132618212118727354263466185605275377022580858818482725012031583671742511286356968707e-01)}},
                                                              {{SC_(6.06312751770019531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.69841326954622286372776223794751375442564387527024987387600763171257473846563231383256042951126744237939173335621133174126564140203783722168940160693903369738874220238990420957962570709306595253925042184973848951481282707435821990405340612615847714760791702548764815132941836944307996329168183043964971707047310773157459458933734373488265390996753682505088988425040804909331792833393036337801209481443096681293307113983919326697774171463311972401915096644602844245006893698721334381447170355033646130e-01), SC_(8.21754745708593558893877997210453421259931832482362161541788802678473040052084610746608123448789164569464037819997816728512707321503932270814997135283224942751431111955279774528079707816282945989997447671912075562165513682745655357171785464101630243159881468499507267100858619865385365378153126523299388132186668506319523531631609433771914896664530437720612542897542396620962675976882751729608935582973299418407696895956465945687660264361883010261463103102557157947538917975921761520492381028453930485e-01)}},
                                                              {{SC_(6.13096714019775390625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.75402924758358231334650295925458267187997174384331476102790740464035059881669019648945917495330357832199117443396061757906648148143864565486655997217444390326266423656372581729412495134230605632775775658476278080199106041530764431654018917606633061332458253725936672170985855414138958779244233609811429392906129724813200490019305469102882138282187987758848707647084287856167057475384628960636610699989646566839615230658291641180186325980960769949839830931757500819770067681359981531260310739391528533e-01), SC_(8.17870083925024815995359911687699926394910179663053145399361592982175638714351229731592822367031107979190069836208751007928500526343506812250399499321292994038539333622880839450312630804560038815300432575283087889439566134289676657146439855404820384685674238529876396699346001212546362146669165127918149018730694797820327381382869648762338833184522726914408835689355455865656334360248829227226282107950259754120637101606226726958719637090515583876970735442819938536217801085805639066391598625734381401e-01)}},
                                                              {{SC_(6.18999719619750976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.80220763340469067252319354348809525508566786663639706547474531609835093810520638777589378050103692705699084463851477753313324811311532142563670009162918655521549754866820982915345992530355351938172236029963335866781105855187839277567473661203089423531017328580776713279646844758775417526897324987212907470655814963274474648397065129785999643316638914124658962640072449392408594369804885547288085537425585383679063570894092676237315239702551170852776102535717628402664327422929792503986746762679984372e-01), SC_(8.14459247469511753057400936713432968553335008699570079517618820900093799983757685955255000345600952230461680637343901677229590811516546365848604073614715769779803264305390559219038249596549722583488785915653953746125687426557192475272851289635121215421678870884842323812552055139391315679645514791432234634867654564749569105902510236521494312939601544245500760676880839934466297825827186225790770259383958886091365471907625416746368992933084207679548025720343035493993024080822460847793935966129878775e-01)}},
                                                              {{SC_(6.32641792297363281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.91277340467781572501372257135126124830312635097266844526637989610697084071956468123140510670966119034398211587971327145083152065850053928352251643344115891560584207422020080491324364553802811726723984253955887539864120462372467968010685410707352060877347028135620212231883891826722468377361823617389583423755792541719634023245230960594991594343071526963547302594773264903765030123757196797987522666861964544622436149688806334825780946673830774577772569410218147060834770459214518300816091633699325159e-01), SC_(8.06468292401720597243607373643076850834340099346187496135107605436527121943597944556982323079565414212179242634055279668924865287777492580167307947076770033365812533884726110826320880591592785941005328200888816051713221955488838557889813329320366811437654737145172121579310229169878585583506116077567673630546054503550524440060601659762352169904975997908131574019740393377568381882944867982968248139190044503341642391989065718049393007583854820241850044293966116050194422903385301862216349966179580820e-01)}},
                                                              {{SC_(6.33131504058837890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.91672206560683861698540323502801662910962736425356518288149873999685630240964750179568794247108357160690946288481169713940570547424947615546778155106801267043363321492217167599527333952918788752215773564356918443371916686724984099928777803084887684542012414845624911080183652414153605252840275567461856370803877535932898839635003969989430608143290403589515438067716518748385434785173915278527980007671148142994730359776314173753830353587565828451836432010916756952104014001139911897290974597936505947e-01), SC_(8.06178640242726505993242967926694062895717233265734674638169215030194480752243897660577492537544366232156759749837560312908253286224387082540538400275543585442286943985552382663607758918581064299617916349453746809306887843201069591375384341794492842128432850981297373891467581358275207844126709085873133207125511792634497429296621277890733121173684425000350842660734392317571807218231702881414377327633225177841877645449690103409480881383280862010633511049174847649468719070167967064564429876144436423e-01)}},
                                                              {{SC_(6.34747505187988281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(5.92974219022706010108992855867183734966583628307882658321095701243900911417197558520889489349140573836663955174824380113169379533261839946161834656524007580200253067087554456971500650127473047120600495452949972788383451786221139777272831295410107709155445038220377172969485227970155197636388634511381949187072449999444268403796704613250710106085854068057822684526341487684193917169435620792297081433473836123012367408071501519994617388901764025552905992036717787425425258583171549106370962485524713660e-01), SC_(8.05221445053726746419815971651888518671645149916391855552948789936704566336934637270876559849890401158717510479582527189926061647034445841426220869339477187180352878239905783188709671871951560328539881083404045467288507567247387366383779542043359249431790499020266939594575410939230015987101843244838403909034273579593668568094414648076559519075205679025774159395184845727898759689983721106347949365458892435974166757049922971026861665764014954983365451676686431477740484946958024140265760598858990745e-01)}},
                                                              {{SC_(6.58116579055786132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.11627877491971613071587044772912068167383316357396771437061427662844502897427620466609259658621123319126645682492753359863400100008935248827153601001426080169982697412239718329624276398900680993889862668591190467393604988686920649867296487377076766197467386553383366994250727747880545993652542366387060248701021839633518153831885758282009991740386520264990613788985281594829350408970333117550653195156920397388678526234922066237547328598780847807509003389905942436432182574100702994762454278779126657e-01), SC_(7.91145586775699434706682325152449132619505292885241407040398261444638165675241801795441015121394868129782183647525514379878310240059764779307080503506048518850465060777594888337287672252521112896981531471145120562580244467829046974149957705801022065945453350900334077892966242546656406133204748800658419775649709440059128375286344767464588124626908555642921898233852706827999777042876474714967504251148166304922393615026590743022270142067866633081636388432547812265438968963733102573956969507972985056e-01)}},
                                                              {{SC_(6.68379306793212890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.19714837588306842543058718138740246054926714910382239485238502970856970097538661113589982165067187132619066720539640268281160439445562932670528298393556312197693972629332318849922700175319101493247268865659591171932951208250809708474317514861424683826798638953226526386055915255029526789214936438984393136364358891272530680010418976217414151997197701807740467294311501247213013330492290365626594001647614860954112844174704251515352162101891298939671842185917196856654362819933010462684597327427126850e-01), SC_(7.84827063799980379211779203074982361728059891779214152842305280398556004966511746571802372837688959219310907474890329036726089422113991718114500383303663007778344198446438007989934781619010896796633674747003624402106368817595803358545678907629281002244851037896204259330272863561367660123874616721196035359424902912316359766328561961112087692177004024520170858826342186686483560937099248883139544325049777616232022358653962294978208855164667855551374367419008803669675437191041878513041619215093977207e-01)}},
                                                              {{SC_(6.84049129486083984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.31936353372929666377534172858021669016330116548927716436870689842767426969839532417161302597045406330054939921641169232029932391615578373403572026279946125317776120510795978090743324577846359989163695367113214738203419801342136118452677670008707025764333970967546198963531058683258802446493328460499592380459692702978891403432765465115433277962954729226399518070155783579346510048953263158414792673476160659020329400278821557190918419587562973276289817258986258653326467450495799750000672275655561574e-01), SC_(7.75020287015587588914578411771195074192222224624281637676262362599907293785961779059986129977211025177830784348442168786682183450667953136365155001785832551965132555642589664593887400121769662552071171946634504133253856348488980396076654712434606013146460571880041761226638371907081882080141542409394003245437988920143100898825137908543687996968163501342562315851663970885479616359018385950082689104218686603061204210645171977533827915317644911647373597167897649132335989478522271207287702127764972518e-01)}},
                                                              {{SC_(6.86983585357666015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.34207892130906185138217995521070060980771134595814223028401424268550028414802642147887935516716437745780743991663524914640101336980226910760315195318804657377246841453310597941350572874724965315733117460066200156678788109903386746756862845060984064517563908979315608178603088957964531685560982456412273287353648076897631728915407427856053044019768395890995445141933769258230908993320288843265454369317690853165669480148178407097303779349415564481663937376368058473755523881122097622561160134717532533e-01), SC_(7.73162563474766841048483415887815113128270668467243021121425122543440004967601932517340170925412923140648469189427391493032322424298025129846960002538396012061927491269154650119691626990617439396114342524616971770389759352447109606952151184472001811010660213708603024649577978842970502993544673075017954455152924365371723225635025754836264482382777266251590714034776765873194178131181718759634161918136432931648140234489835301481526824895759034614583345030384106065853342198571446960029902288705166826e-01)}},
                                                              {{SC_(6.94284915924072265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.39836052877330415849557324484442485246960415097675587817729130947796598088679398211918418430782716761499904608212690457611529828373751516280960985062072450410659960845465774665370459640245023079149008857282599337994588698772961300102932470670455964033692741822804798894372704901582184812003971294366565124048223850858405484483918946765658340154449257921292765659570238517273545585244602216656601192100295568929395484656008714082018969371732663016880302660592574145128291454881820236795996282547497677e-01), SC_(7.68511434813014370464071069339832221311083583138535155987163342906384134901657393354802549369389890372582861852791541558171094773595275468892230556500115368424467831259833594084903054252311484213541678484269411902594249145222403876708128400697928924522816288182254355192372916075954493920965124086228091558841373752049897442849725930050350651938100137683579995803849252482883931876266606935457585636549131596716992112380751040967416114021919373289953352841490346808526597399414353552864896082644783968e-01)}},
                                                              {{SC_(7.04085826873779296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.47337314034375267311253727881438908324914118655596903539009237679025823609807063414519572776218793579216891876342705736585205189677473150287545285885407465163607235072015934997648155039523284701130740438070319174804288419720689962870453835500841745307067839463534671761104917869376632808602691603261461941161338330182919616033742212613058331738146514456978322077962906477328825044854350200058603333916688049190257182038575346210285536253744404448592449041637901255073270427164340439531631907267607749e-01), SC_(7.62203648547263658124556003919108631375059729455752347315416115221615289769809363766341996100406708571842804474615990281624544657474722340968058460824215775408209176056732637981834602157220055699450856816394920036523737063558780069515171775820548685613535497845720729171156701201157483359755580485996949045344633845078270826538922382725667656783623857614425595386019791584646719482830027977561461206521773127678313382573998766556014080907045322829632444997663307108065388896464215295338370168272490364e-01)}},
                                                              {{SC_(7.09933280944824218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.51783172382929841429151101014983203627578328333573592510980632952108143767795039762068083754176504537476052511691864448014303053397482545651822053832287705058499414996079783090399120862253899390521463138924593245394562793681032248632866266766895509930032123199410475544972713589449479893108999097158598859942660268342636814309052963446861245270616519908709276995009050713056849385235425190399279180745720917292866069759567084841827333335964523406079209272268782749630319370918462231083124713647708027e-01), SC_(7.58405364035911841501543520471024032415280607540389078760632519463303840329020571045544960761585578507657880881719158444633178745177097217632381274410178922552576393958541137449644629859679438925409830143968442835575512375287556654397959631087638498982572638282648212386560157945725763904932732228614132924703510889158885743657357850286206983294111169997088528262884477065796101760395290581798087463364077999452179153508035671219845061724275612416469431248397257676448236556699979541960793793234354297e-01)}},
                                                              {{SC_(7.12137937545776367187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.53453610421558887191770037954012677520047542608253781911414475633135762082648944605151127271372005391447599439490226146358614114988444338767607370529972443432762056723355412014818413359758533894010829816380996931409136716572396990538773275750459085751647799299686743029739389324120791907775424334541966372901562358441229790779983815872877577111708548355032397661700832814240256454741065353652618317355244351437327924856434997949990497272086397007826557763113495785992334434996013212106563351821012639e-01), SC_(7.56966564008628816064935109195378426911911472438595933112354357748505074207024354053911829385588364448207071677852917245130645012968655730226513657764473316710014319131523151887741595944009634322876870833038475238389767311902965604104789419520464629484339752652742222247350707958785496125375295437037990398818672449792045553554805101541785038921513194543317116169605636216403146997656048107702306109440921721516258305004378318430714899908536008728011634964756998246216104383496283612208246712707809890e-01)}},
                                                              {{SC_(7.28063344955444335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.65425239549281551387975096958780375858851892612581018364517691550986625053067200927521434055711311934858303843505620795647699094991167962072952782940273782031412754829044154523685627551088516306144183410064210956927323855949328679639013060157012524469106990066776143600831038975143469374685791501211129515334810687858924199124184919832544720039523738772834549979678896244138923880641120598453180075472233453229563256798121518710091633983273444804638251096554147694798885058914196854535864381045701914e-01), SC_(7.46464500542913469550304482427483604981998295473097001834850867024888391361681154549551085476420379252215393733043723887519290343750467446615492574133174914266424284911131646002469252866740075071221424899571812395871594617919523849326962762794240599720695713605778048623064419305383185861913597186339664175665315128235844322682700305036708590451177189730578210863235483538381358838871934839801769986818109659779590737181465381969746699020808152545779451579969426999507214595377575535319512818498620621e-01)}},
                                                              {{SC_(7.31353282928466796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.67877455849328415313685511252407361475290664944847974694748374470430525820546311711633036068027917655119375109669456363780879204022992271472046839476884364877059886387610485425570541910060468422158698050147164337450261912118083547208431050535457571356039548539993621937778735874494935537604478209586817246415426357876117341987602497257974902619453111772426625634362317200865655014604545340689911403283456936384775676107431194675840774229025714882598541659398348276336357516196404102890789080014278310e-01), SC_(7.44271256981101194346209628134504606702099618005331278155702255569736794611306017252420167649556829316737944208883220062940525982827062319833178706198085721874692819642620284994022263051778498810953118700480764998742939090561601606284588646002048877898161498445470978169991315741359253391616577330147012226863384211221768778133768652882840183361127105099183092604737447476797351760900482923533200976293883182732697626771002910636171758241902951875407238841238780899997688911332446119841029304425479636e-01)}},
                                                              {{SC_(7.34646558761596679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.70324920178083436441069471678009876567531608055824879276071736344347039103770036213432254310241283901574175309710833116509980678094724076935940860412925232677469144438445914009770303026253831951547428328761003164748593055572657816784981748333393830149829036752582048673452037841744030077018127966629362072622320459806895246918774521500257936723572715328716560257228806009962495784185008529474473181791809299845667764302386566655812206124328554962989512463916225593807471830263098536186790040787445839e-01), SC_(7.42067720217128208561458295260588188538883703614529506403332866542499686401570844168065379119686678412121172275197281466837025752106843152727749804130330019398565607006458973651927655708121078756327411774608433581084836662172963084466807457891491110306028947765023619026441420363688723939400112648843886687616294780578466440795163986186190618677996846555348224767261142760875403983928512707788875476531712495126954048108942578212434188855740383855884084742323564540464861291379994368969288540451950217e-01)}},
                                                              {{SC_(7.35883474349975585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.71242282289650784432824894888486151838207425243821064872578816539245485349169907081030400639140122480003746277774671981965140905966502055045096267484016861019863714535857263392580875083896637853022773890639463141139601546619280185776793076302947369731239294025987092087696578758868930952282914246773195675160183965633100755161279046846470580227563479309239991478236819173709358267985579481202693451305809572478116921859856167569426408004912947211637308584527298655605280783744732163905380489214924919e-01), SC_(7.41238017418548742413842257768684553615834706641899661393734845623817313321543239084972374770481917354445618824230060053347683515049801885699977994522189688560444826046327608254570779006944178830055126966799122232990289767677705366215827296184520130230453169104436487644749130788789590578134797523361818202371818815713878405573658388136437453814494911814556871777282812555049415325042882677170454923162907543967764711047796723580024692887761925274834178826463996678615559173056991061779677528918102368e-01)}},
                                                              {{SC_(7.47545957565307617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.79841113768607340695944112185623754809736842484299646727916304809581417691228956969140207251779386697691577741546714860663854566118219588035062264502499883762054739905424569936729908546433662571248273931646831354089850605147738721655208493575116647047591590318581469421315162634504195730838974528986962257992624940001258430180986204021942332453689279121755873712801504797017002558955812865200707831055953451811123671205439221790845442267042379316447624253844858919397067431005597259087018747582178424e-01), SC_(7.33359434404344109336395962586828145328170625700473318543788063807067543247262286190805164830755305055267618419943813198649946951834556772016494519206476727461835185579311139486423232373044374013136769637717868251379282837922690752383578796965266903327115596677790452452974648347092046946474286910607295726282964624682284028852420742519914706578260046372907466723896662431770421690941601880002968886771614517398489952077636798547497165680848712519474408905758365283290126582236138958173021236321161885e-01)}},
                                                              {{SC_(7.55493879318237304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.85648263319370343052834907809005875626191651889287119446755435146659758692147853953563788614131230147518332897413407029130680747659427336204146141672902830333767903465293143774579343702237822978154183397763786037274035612370601549591566046393421688340945541811271244446471992893685816844422290107339474582031600707672053506093570991627232277511247616242319229764885571613405065990151195420213966833530643133441081048453151568306471387731353145348084761549276605935431818127669747470731171948853979945e-01), SC_(7.27933004477150623008809972442600651954692477743538333356621001503195937504667719700541942845670031454624830343728389907907347912403665447373766506340758222717919268080026986771138260024517905388101442952981872598882504479570588596424852623521866672390156090453185231458894061499369931924249576747238446542346316663662331729519738390267757834504744290361928534954604379267936758410254241823802609817231482104502777287124391370444319867894433306323868979969521772048460043626033860564960537038095938656e-01)}},
                                                              {{SC_(7.58935451507568359375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(6.88149431809074292039011479636345409272821159878239199063155901100467548853254258110502008140002376113188676528706129709315448525290898431272202561536901596271344648580137727722677193046008709171376549247548169720757097475212932378765873167576807240071876899865667566027161620638408264083007728986171521870542890063333655118712811809103286225117916161550631677504773924185458526354318750799710662777478042439728309044909159664046364148985809812258610769136628334650773734441115032126818377546249320163e-01), SC_(7.25568990173124895338125876594655020996196799336506719347548207108773241573013361988843912380042967173319980848965347758554096264013024360802944654983722000331612085095493975827321189492026812256223514482673900792147489176478762598983238564011300475061164502341735461598546965603251492600505243119182301013494029540587474258886399189520179110749622455444080841081454890362686228212962087454598613627230870475322625762519069603723940374929932243553431361246951367793348636809564558449766920116867744525e-01)}},
                                                              {{SC_(7.91057109832763671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.11096917179776834302812515833728935272468647127939295351299971149188833687056624942448454512139136992529960373902017326874914774749603887673330321423898880605971457130146157359406951110300162856514767402201313562337065970349644312236506562094236677034639384877728912352270003473603967918428645637947206690444105732593825279836711281992638418344858231107764502007142454975430695021477350271536707626622731305396784131486382334375539297869210070416933438023276579520520390765443097807298713622715115891e-01), SC_(7.03094001096167514247452987566287284250780249387962704875473628545617541774686956469062454651828607591249279271245274397135059565688145447752251614500578532608639894834789582982265370817785925338408376851087909205953300730678570975044663837957505742441580929432734796231676920571015992517126640510826168319087313544058187812809896079863947088018101287123002496421080180476087162715986713471824224540590420685566491565864250397615116860667256579933004489120091376491629218063464801507664268777067724241e-01)}},
                                                              {{SC_(7.96196222305297851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.14700790241734210718720054373475547331770418031912502525123458538003032746062328257741114689875158887248192521669534885392619195512740041442251588903822310441251190280244808295176115039576094740370089122366345937461478223639891454003139173543796840935464808976223093898587054390970330087960689894004259716945839339645236791663447552549659390532864608528110443354882079183588236749335885717305759587003809538258581826336560351673467159629498055049188564719726195933822175304136939283243967908242494550e-01), SC_(6.99430325642119007199077599804338282359678696992845283199385067785523316357497003279755601846574384248393159269985358143471633926612287125404225155548044445499184262453697237728665071432512161845503412031823157453310693426644414151689312780774754757744034146765706240859362206302826721474463009388112171549014346332567224941063583183938496276118915668883695302262651276382992275711085438741067375802053372839441984732848254301369814425503989712195275586467060144295441465488922768796892003329447608649e-01)}},
                                                              {{SC_(8.20322275161743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.31365654704142739846905019584696358036047306428180059429371468748059482991110982535801827867051266821311376439714397817455993576620879096008137068230869436717130513368495882562650856370559340685959779025910012852712707473599834793447097591460733637138441028399795427998853135945798003850175043219913393539806928792759611776050133706181971114194824150248235517135756254418435225438771834830422404958975726823719539265915396582983003903333187901189190376044100155608302909472752013179273050165726134671e-01), SC_(6.81985541722975717095534445767819481908864976076961739056180221697736132141265585566999326647245602003551277294117508416627907538030876733016883885497005656713622185232867964646776021117768267034928283519921750560161271484197621123938042103057877171133153181306536200901947837955079582005567762647046471690332827928980954613232524604877387625737395340351244820721198289997787185454105134445968462217536369610202581676650929417732788588715743220458135214003687206783391270487189498386364945123860360356e-01)}},
                                                              {{SC_(8.20823192596435546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.31707181381410700775852413944623256358279362863429082318176094644074345198934818511604497924306255057761372148290611474872724768056233841633053057759269625564484451756172360890862732976965251435126007770329830159323039601468508914547084883261046412490538012690073602709905862777673769760539824714203891758844099506177024515786538294725856183082907027976942601097128886158840072184464238575694374237570771730277620705978363177030311651969394642265696664888395046181793221822925825553797830022216861812e-01), SC_(6.81619102369403480554305225830589669749496286393568170235405441280278381355502071404131720011170133029142899451867504224912313601433029599167624590909710073729960213379239331488260793038841494500357027141640185106376120026704091104273895547141376917874461252188333037699289790582218493452933614232800683564196166644334061074582102278060215612103232488660156166325779181387963741004387571863137929241835769518810981154518776634995901657416266901576969346164884723744461577404233270130572283559282001269e-01)}},
                                                              {{SC_(8.20830821990966796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.31712381701167181235940405073972015213017639680082667356112029205671139034521852374354906548574117997188054771119114790417352101300580820315150401962599864229711663045499725615624769701732815805881838686006938070145575222297658526345767913189362679305898973467899416346980968752255458435026841646196804679932576337820885098573186877489399993520726005939470747793237899520526853009339508138223853067623106893392596935713790281374384104322060460403415407546619022310768214665068143293181570925173506030e-01), SC_(6.81613519866797700233561078830285348868909728015824467996873436863083948946792713662365645207291667275891590707518243675662095426503292274413226380893079787669115620493220926707096054723242308983595288942728615386528125187163599085233693989737313878754308845546547871603235046915011224509231019712012001921675566002620394997684099906522793791517970792998530561520243658709327233522695971109704887254996024093751518624146215852953903992457981183041783974253387011361571840065767392160436127405910006494e-01)}},
                                                              {{SC_(8.24585437774658203125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.34266415048580601601171614328189945485523348339167684552882817358872463794947236136970813327323639342718055615553899792751868468349220589184493975245756465487196821811241807511777442736289719722639891858859935335651084759033715948897509352669673287794523647621937969176476233408092160097961004199695909264152719287052279829589065558997590492898837638209347034503953069034794972138475844603380815379547139569854568998577295466205187088165937309792617517840630419328308859176681506271893863528789248027e-01), SC_(6.78861423069322423142287792579947877264054945218311760117309756513802596452752265941644672458371639416650177013219274176072434763072510338862834134080437379766218972620884833863128184168443684900967637836984797742269511801017789421153124594757787251028286436667001509092732247658107436228355788096082272539774666132684178084465292359871687041227303291674144130444761955366487836773097705032915931079300488532047764679474318554807323227573756378123678236220609152577882604414124351048800037673338910072e-01)}},
                                                              {{SC_(8.42336177825927734375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.46200398377393459649680826081175427868749016777479391656946615357401168769244488163885501440054564764625884632208092536154327477843944291217071640186792695307439200754180218113370133302122271947648219228033925537331803886856486078614193043394452297264214446820642087443784861194790324615980733184632898468451644948907519394191384802169154937632223335637190099490677170800235666162943855162453645700761176168292376053760435303585758309036258034104340588553649940846104238991034056185825466741067882072e-01), SC_(6.65721387264536737199053622485047036959155178470601890364581116448749188037417941827507890537685995449185191055999932249913339748939836149314270084339122677529396816057499007557737481859203418779490782222223935147785268990135438875913775527887167257753754804880001533585490387945085868364708189831954961379748257097179336872008456812624559823103794451262576155877557164818892518890148246723174790434123610728214709486034014405859537649796728092585200795147670242992510582392423063209695060045435639049e-01)}},
                                                              {{SC_(8.51732254028320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.52422535846828634329763573162467783775835226181279002075499246862952798511615086223852170067031422097672291727362551514602515232858650334266117329374278299553738913137263989569552544670658051509333142548737955765721640897185016235302271826229961834507496959699946522065996334471687240277709484606165787709519654824887215013969427685512023892851687430587576049452204426229183023498749375591705872255297982552737172334378319347460973591687233240652609574815157682893428262843430032255662299652114089879e-01), SC_(6.58680747820845207658025673099654398208410800146063243277102180468596975359125822183693199476973064425685212001483520724112988866317082004563755687487431948863912142895176713746527538414153195153195902886992468372105263034943619928953111637060748803014031715925157205650185348194095196433146735511127968345957898334184182275252020868195423853786179773905957452209444524740405316126300170571443431668967442839329584782366429851699443487772336859741150158436052721645009323345331192414931319025563193732e-01)}},
                                                              {{SC_(8.53235483169555664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.53411833445184158836140163572064590294752166376711614137854911687483379705773538984310687352928737777394594541765815710911439334046554940997735934546678121569321606032983208295786707007964249587180529897328468589036869105558173786011112106628817264554495698575451649354701607098355116981968314044614012968784188544167980927924327829203173902544581781617093304811705073341251715042320605762563751570423820183200736572716105436344306462925279390306546438823958050135189736037104122213194340265159200889e-01), SC_(6.57548940554819907573257528419300834282085959566971485261554488964967201945618235849231884529358874985523899727532768461452843522892545956567443976145556104320240537755297697336571583884606812992554738345823881726286988930443989691129940518355496639636521178039189177831792417756204567633195849709348605779519669211602867459041809898937701383112387501471360860974137298579481666185065773825441102462503880766351019703882097283156754140486193325603364399157977161246057275078823715656758124740769286135e-01)}},
                                                              {{SC_(8.60631942749023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.58254714672202734054245631300777236683159096097036356652865208302350109743073684152410962467600654933745740571894780398991815718735737674465828290725494858194989836534553160399551271476918168363229478652799066322950631488733954033725999111904414202705936578537002784526606704859598219316245631357166193113310254529311587598217265788825906764456617882297267525625811076294767454761426589134159107671204802876644719093564206549129870218372256457669807937656025972129347553750818546756113960841751027002e-01), SC_(6.51958424807423145724681352366893044913213138350124776252984208258289594390333618059154128345089870962156493775277533940863780236374174323722886635230257339343144735789204877774178934520266472338942566719658189212879424410842064912899039411532389426668819500380572357870722896319650296336689216304697183340394099481481510010815179251484525103064808750250346301956674840478464617935466799014788108180458727627901714888446114618457583761783239371051182986228026484951181476347027474567524391889783918188e-01)}},
                                                              {{SC_(8.71434926986694335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.65253428839936597894596123688310569090389685861623807747906998309584979498111611756491021760688758158177280261057414612992774369589196951533402853137262845408946611167107061628964817744786033131644642061511740789926408393663344035662239704331526547276660565514311115240209165188348550085117827815853949524900086802577414033834083707418722164713516489527969642212160278115195142344168107122012981297994117386544179420772588506796664759651956790125837907264670178332084628624287193563546028447376088112e-01), SC_(6.43729127544124799494617385424141789231958756626700658813041071428586618072421618554123624352683471102337219690582915815457570760436788158308993420812005608224926825196281977060682929608339080881610829922835036163838266204844465833776530324738412004194818792577411893967126443956831812385983415880848530409188330707192180880606478355189200581927593129330039998521115777958744436380095343335367391348225109459340647897714560715485246371205710624833126032500096010272581171199733945341054993950174852275e-01)}},
                                                              {{SC_(8.77896070480346679687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.69396652942502806680163137716408274193626505179261027990589455104514099654445891686820536957953425257143644049015207376709302919117653628962899300992652165756263697434031175190503438476983170969534318764637916846678576909260931266642525950222240920446950471376533409258600518379609175823729377664566681171424703748226617477150106440828466552604008804711774039970531971579418161768254301575392735582891812001284274165621905938490443628338710303566279299515235154679302470794188934092169362981251949139e-01), SC_(6.38771313101076798184916637234037591631630476518693506025388154191480127015986530208615984654102066160223638744973935483082365448593055470002327507056651767849014396832146717236805375433305757070883314307096701064579347870155982807280470443786167533770758312379604707343782359552342226011090633160077523578145167810262263830014035520208938934257324947353709830917635397437518132188605070760628344358879794443634580776390332446040995026564847535658561531518738815456137767206748819904544534640439838368e-01)}},
                                                              {{SC_(8.77901554107666015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.69400155714758174751463956320581356413411030184997329885336980347356484417649575163611155974682960990074706177152082869084220135289675660713031854544651588961152487309343341711683624026191125452489208799790205351785787809081119847466237333627648354936014479460242198409063587836547650641254553229247595634761404167667528762434341974636313629726961805413262922094769725972157142384658932879933860014161454297080776720852052747460337256898405341811175351699528039330897784979131765307939727592470639742e-01), SC_(6.38767094006967357656721511247182362249968335273513367163289737234015746407858671691537030222365046724074960371995585209481034408116108478891455599216861380391587550923462076145935873889833750036290480159091501120762411644650573651648384896795839250531931008594162378543229267022201252857767447467217098240469413303271704255149771366309687473842534080354893076656855938206360596197074473714118186747774946181365116197433273399245150535866789495922270957506694650891577421983522076341204063582668149071e-01)}},
                                                              {{SC_(8.89235734939575195312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.76590483008918075828123704043379132878468331801967725591605673654298358001840206326684419987926629893734512865726422938146342620014396972255648966508116762790571194859893171810810344158133433256238149661062529161655687364822434788153154601343256287361124721577752182527927513604966699736996393440773466561767934321328287581238024121937064696839131096415250977881879528957788874895432846673943989658776895612535263832944224934599638742571023523788882394130859758332145929080625534666910077534518151665e-01), SC_(6.30005731481845588273036576846426690914673384479600856701742059324050612829369196434797628379175419804925394509968380629103231661724961641777260194329213816053275791498400614982137324243094565751574074781317228207243051532251035366786012453342678640581014349843567477661892513532630021150492274687780375569033734871201459611566752431721742424256015626449576318661533280124185966359039977200045726794752617623916091606371771736962437251873603911510569433817985133372013360763397076481029831695401715002e-01)}},
                                                              {{SC_(8.91755342483520507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.78175383462325163583674655043042202728281242225366935117157325225181476656067514837038925992809175658530368266776381307490548251307103630774046387484632672266242289311664765547821562848972071577684296851290420415760629271943958285077554346928275950835563328463912933949018430611596894649981846914368661843356689295600898585202254923488212519552327802028131150621466419842782435111397756440608545404660325234025515092577789467351085455750696722955121922226534931082782879468607373923807792631205949763e-01), SC_(6.28047030542508964660984155843210515427976913195341299397416880066259097497362083346900049795444015853644951521277472704361379055931891605371832291636618616517177726378221958317024446964676152999346744441923607521882244531629771088311460630752446686692856778162970446447509534204791120267039919827654922453565156209163873599425863243716981444860656074593325137604592825588655286932687854692292092466450735118048208393976096856497466171234771756357427282306123858046816566008416672777532403900088297464e-01)}},
                                                              {{SC_(9.24067020416259765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(7.98058916312735347801439586114492791247504356700035350372617300035491325642498738425410757498463680839749405041855752082386106968476536443619420502774520054342166910929880836624789313581722880090984918986108537736057001903701343412875769073471137982084510071548308674144125832580017798601321260141766392193897611981849608390621570191349383770802898779074210023525381294056774082554327936599442711681328763257690606803631608191012883656486022173621194670860849528550383855769646670248938050891350939424e-01), SC_(6.02579427207519654945448773493218643267792147248371754581363473609795758074173708675888611453910760118715338469247983915920902988424878326449772922846334087438143568846425397712506600724800259903626436144750040497543988786284363660844256167811788822919038705711937971087151329191225800553441192050916599960240802588789035166708012627077407281815309268388481235738834736964636229043914244433488779816191329214444784311750898666557245872423964610573173614007380193002623880636557775872455442732077202276e-01)}},
                                                              {{SC_(9.48538780212402343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.12564669864108740704526484207757833147196145725851301659425236068573275909234403133443871501638477787527174514236271369871077558250470471388812341752831884260599506119037378762442877644976065538329194428099200524865474042001514134742196903704060954707513545904884464229614830486230226988888294221877802021182915074325369718722295726897572934557026431305430687003882383920835240558050143374898263910116302593489183653819757258655043164740050711216449209244822863602113590113477874407887852238592732150e-01), SC_(5.82871046877979668715013686472506038570335511014029685667146599013044671091360805600736750567377723257295386279133021341229729624564952052341881681745532136732380301253980032056794607614053910168194823631388805229025653111289051579838992739177878645806958792467024000124031374521011702353300856519556067014730143575223461653982478513321149281707480959361188721812110134045643590586089099302264567372058785685184102186595081293450343022216284635973331409511742034734523393411078859037050754025652927233e-01)}},
                                                              {{SC_(9.59645032882690429687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.18987935959352073875614350221457438487323685041914389690448592513530220519239651037978269508161267490945154670166534406063138841144746365313742048742546862828773094010795667607517794334441680608184241612401077775499508697509903758691830768580413170834939208002045427587221365787355404791692261389870945221206227169987866104028291835384398330045112454088191868853133231019091108422846986286460028278842813913496964587302041301009065202916611122849688878484886520224028920980574386384102219209722855994e-01), SC_(5.73810736003641035253230826727130176962684890290455248696750116766827303422983360120185965011205954543173332229412154060647120027510300901757548306117034351503130130202085092968416847247811715273727937511806279023862537563748813367037827626060355844175390548989122146048668943889392616278176867772582425831898960286338108240256596607770829334879298832455356563498708453483619048063771908372595407532180041349800539325399287092471638125266915313546537055155682234714560615363056319665309958777686371598e-01)}},
                                                              {{SC_(9.65941429138183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.22584617683364992207229334003659891480399795460992886887186049774917024807741696479772302621685034469544288146545476789343680790813545029298766875601266418608150059915090250070496220181822089491578848816421876519641947266567872130828556654782426700108153109976120084697153230120698732412766844108655477561974029439822155046861812169807144463116359326576613037164120983818549053652688252257188181444212785010666711648974487686167965608784209332436955384462327442388935187075011633997680936530506621554e-01), SC_(5.68642723290039340463788908562022024375903444433579040809686968815987000773842985996083775322299516895433513241758088005769979020979884462820837775199929822542884367476097461845417648807912438092370123891315698660843301159976154405357298789332468698532196213669597486274889313498220406935743400370789951032049095520369775978550650161707155538699612971113574623040689344171208145873292268193066088579319566948787164894940602613163719118941837781698170157843766742315044243719982001719645953102362474957e-01)}},
                                                              {{SC_(9.69469547271728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.24585732620709848369504663267842802945713140931526055303694584350216444781433131159335710298075509928061921295637330893161700738598008958933088727135651320082618894171378062680988313516773413479819875937871239017735048917366136188501496487009707095259269151030532083054070871581776644960270094028919341405032530725113303670443168536633275168354421263536701825456258624838606154540730225508037857427911887076941147694286382203323300676505455315912478482796722391610090650659648499187906577186157737056e-01), SC_(5.65737014484970044778411229540371735847367473436622430603910050048311316724172043446931327368976907852993925629246318655379949415439703717508354184841540236193001008856676979113360314219485181368297328528332958098894637359296941591426628297169297310200339047343894978498011481344298400110679380143795548248514001432340911565558270373397329312435370958143775911560520015023284874302778208115584385775213841761140000781186422079463643822755044052498499982835998207187441782548557791825513942412399991580e-01)}},
                                                              {{SC_(9.82646942138671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.31968865865227323980817588534012145072956918174739347526060110784347496214243249811021514168456208338095803368211236101872863267851708520299886585558448598513907571648992356284386513455055507433219573905646545209558087301617308485028877164795043620893577991875789384432613469220875874237363555058119846748704662987579870821230396167878044611649792961253689446672029168473841797727920174931715223197252628290994681792926108830975273333625101578331152586580555117601990196126397627574074208787189349152e-01), SC_(5.54822319514029090084729982333587114741858196394685335721946904277279159971925853766398940004554450358130664133950870452817706012609815744578631545675150846874896545586299851385016742044321351006651189895571335493578725988267159464590787613441298510791278188261138742850430318264030952823330623956793112834295928275420379877586093404930828104809080519247793234083735911543819805565871096192190064772523384701149841800290179816133071704715005293923596635924030624539013903890347671661902299554760202174e-01)}},
                                                              {{SC_(9.83216762542724609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.32284879858217969591237255043980110006686133815776202922271852776856771350332101339010324703843517116138866856908257614411748552627016061940281028219127825108284681787939022381958904898149444831010716290354011402876628197127433048291019572067903577899308097770420413212420988463826311822629338611686362193199071281878095764288618770356886283660840885566136277968760899908196602739182766462957125144855460241264414889900241225376090029495445808532222733058272682759974286930523604972591541938462082738e-01), SC_(5.54348156630282013522625791463277163031019039811554196308380824695427495715350261849345006396636896908970353963418749516078472471112962527026429006539719950884742421763042926231859443073464873027715096369578135064095865745463520613858465435926855006544338822632391199100108760066906871869656435735978048783045865402206282833748844644409629233161318525829336270222617930815810267936525385743714996362448897523286654136619104074977496801222450463284538962297449469961368377755944588348099574260345963541e-01)}},
                                                              {{SC_(9.83610868453979492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.32503287102961641288101560354377842367104556567230972911622477903374953912355915245242240712849108712975196498653679010031326983813457851132151662065430308536699354126045252973333911068809938765074862248868066248950183496391766060621564702255421080483036262188122479946139341381880799016446714332666959121998488663346116132867751565190150997298130863357142937821950846814913958715497586314656834866185822964252264867773407658286314197967136187153405146257556907174702384339683351878110201477329379447e-01), SC_(5.54020105197242658130588336922487025506504893915583522168469404039255366646111382241684933345969643188484322454205747301489360618730048950013527222210645916151377608244930275389952630297948885962678803933526584267017432976830694495613544874392202201421177634556433257628036811829533377199654511854934046963490441917900799491948518218492351408077283977664676923257870328730978442918374816705738155924294226672938193936714425640217827125527711078010078149888140743747761531647128525612808314747478972570e-01)}},
                                                              {{SC_(9.95408296585083007812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01), SC_(8.38981214920497704717899373418671446928483890855060284799740971304882745920908935736943939704589267941989830244373551895255783588073679113590173973114584988190155699825108410121360686195883747719007007893468921218727274807297991363217466038664657137367654723084973463290946256650626836794264683004278211513899268551920312342756266515826259259726512189757872712853305609667619002475912833361518495511938047440818339505567676937465864214207573785916885844608123312547589207580716363920365861285143764375e-01), SC_(5.44160381698746642203232743195166366078139632851608169818655383956057684555190540842709659974600662215781778550742641804821634170960591630073806891722462368887780189280469596950221091518334725610368627400853243854101015413430763147562200343691917920252378433090596199174851325731237602783897610447664865875066758800548339826233645876541728305686639074840192077219628286646161024241998090709536557554219707070398247151276149197837163311776708081751732490183361938952600699049554602049842531852153831782e-01)}},
                                                              {{SC_(1.01810264587402343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.51113478224340112819769419406668343296997137852125085026627601033695221027221680739759228450519239906763483813641409205221569907017649544939651124070200567253311923725255685394557115288147651330781854842724082858086345305489388659275201553064204666324384134840442724180538877542570522337742275387903182943487865040150306562753008760418606812138537167402919354824803373463154562471658910999723607611347855634475155110992237162274694333736177499745794536149613151318943582648699966229652005358496444489e-01), SC_(5.24981758906788806720321221493041546046536853101112224546068011604066251428211928527397002568495685344162019857040043384725024419519787535508177503109959734124106406089378362511958029320766868127672972643210490560131971265057069410667058521515850110288642291074881668261518014868103948599442592327439087184092477973618634763995106587135252254198900232994974891591691575540357713853493587106149036294617662585229941327315258402172912132653620060621681600736287201723171700062195198507667762376876900942e-01)}},
                                                              {{SC_(1.01955366134643554687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.51874338625406898751796376082414397227826831688945988367360783686017719569653498679495095886999187714603428524281489702697040739076723012974936631879646188087684388206213784841749240905322462492964708867774769042085311978421900563215780430747642719614466282351813971497903235599082563973431089320745714074712238730503082382330756857672861429927076360205779930674044202676173396435454508624742394250617203698465375200572249600589644541811730973102448523982739402019880822845906443454298948632220496623e-01), SC_(5.23746227854220998683713255684654580420349623900629957727586767135312869229549505909978296996917115078905829360331882501779993750493598375098975060336863081613594923694881885705251788938200175364653283701562862904858617940803729599936402634714305971022089877816493348526312968794620717565655039815357858048838314590763290686976255039108541835565430327578529839018553312044777610181376111606345346520328973885384006538597494774490276543810336811350585911692458465560280443001411399885568556041662167070e-01)}},
                                                              {{SC_(1.01972961425781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.51966480111774361399069328701995935071372020219143309997787113638393919403968136915121861175835538754600834423963514889305138630433731608710603652954069400606286560468407767107107087190487293833952663977007675506578323630239713581324373245904026958212213991969335770230236066364556367455390182358766586599976713221737360674982019306470673766163584861978662023566581366437871005356906184711866434214164772764320131703274870131106914060711534591606757951979026327161823156723675231577861333842318394569e-01), SC_(5.23596329977544420065144742862516506591535240888055421546339421107981141699964339304232991065563646931999786376875813624393033637311422887716774299128151274880500637675282113944004049643846577609752770470220724898109324739773136018960486589825495016797038063092491896424124930201343699338944844182394014862004848223072687172743460980013255184854002963549706263053554276115375457613032065224733557244235021560239945266210789382637676232772997067729369831317445346394982926087240786066756007065976865199e-01)}},
                                                              {{SC_(1.02203893661499023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.53173359993275510769201141067594417476315071144690812595653997191597262071373310668427274018706715816875602616981734686623449274232164965016889022072766227485090158582077532768757553401295445893372500614520712981163822507310326564305951524928590439452755277457928064464061417996375315127154980021397765697409923057256186808780046527978929918652502064643686968787899776711539456339228100446563066687648856212511031491366882500584309071946065416129844562857212623798449390581588562607486228411763200912e-01), SC_(5.21627470325120732269813404010316165592480428238754867261218888469888255657619814460908558032950507230122405786726087773136456927684474035194236890972080578053974577567271612823522403564086609541956175796055431451651302515819459184551928562294838939499804848508446524019874020648005304158480870967982703639307838393841009588105053700130042111134661167777802421383209221609204503819802214845033946879099849476229349151407266021771468544538449977330323950620579696088984722405789899241692475022421773349e-01)}},
                                                              {{SC_(1.04224300384521484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.63537510869255626006639649621175598735538216049096047128314622918130121205771750109554598476295766551959430732465946275217523612600471370041572597995781971371139574821411627966947779135063872049262142250252738667498080540864312933810890040892588107753549143469963815055751855843122150785220518063256317064976725772586961349152769650156149724984037410207678280018005860017259990329083346957046556900359716959229695808387355551627553590335378265769145941947762744207681462479232274858383582258321146682e-01), SC_(5.04284609443645644137677327061934533419774433045359305110392458573885056024777806215829688978846281239767920668722056849722240308192065029841912755982623384774057517123723890362492952826228273224806621806848022766917062904511082784603260842696460679290869901569222629711739587027262051175653556877760863288406690317492056664849858221206006338415521392424645862165044887535133202678928311297187596359205254783280406914115226610484936105009423715924949584882457354022994692793854393523665552395861099271e-01)}},
                                                              {{SC_(1.04284906387329101562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.63842979002663238449435204701296774479655826106967229981922424457731096065820930075780015601998055141776673434896407704894969355059239868184948033405937550873032643388663428811900936276062506481301207786612350255430669990490729215226235121222349700973545475451464817766888760629083810292716211070263259927244982625803510694487567162546304875630668045246698992365147563968339464619497746621408196495203376801750617431925118103653718805521676962134971750239373249604163366941443887767002203983420837004e-01), SC_(5.03761161293528383227164965192425790682824545017807701791943125349294184971304713651260221666354091350373720273671239823498548250306546674281103764298601227442025581335391701007457061014636915234497930895368532401260152887354212476227233684348573925252957161208187722137191234610043021535983693195925363819124150968863527869550047518806715597667180909668244768170869617482829743029747976901530078386044099961964993287601498583919304961877326655570710119819762322404343568305105919239287745118584466384e-01)}},
                                                              {{SC_(1.04861497879028320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.66733247377868951447252165296997103275902323306825603286025420811951433197464955740899002646743162306607094455479834727516163691620584323734800820553232230642057166947959008797122645834292278918957085530137883249125718201191981410765862667238291809157525861398511128998302707821659666786785287395993637713049198043239268120875487982735366514430906588661471270367651330814997354583032200750284247290948390741087239847195715009409917156323220163532420782083677592580985013545912022698903528995514045046e-01), SC_(4.98771969831719617656313296373814635897071682918217378300535179362133842502217650129347096266351936125121723618551438325664026121428000063243627791654072553877437816025406826832329511867150127042335149389897303965017841207076047913283061462035024660008951807614818673627574045268003412329001964254784115734537224971653343491403923664649208156711189624863323988440483604190657287900352131068098389460854483492037204020251328926921040829359333356258262691810836937317931035145533664735541511268437477996e-01)}},
                                                              {{SC_(1.05866098403930664062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.71700092969493626279546693696551397493991446149794302485855185071559252304129808957656534322985619215530703595370148231144605038244762601499558086066253298201721452458139800924319525215992700207631408178644067538811094757639672162883610186864783317216938583320140927245396624100839223782524205485345890430722933364461184266302104566922918644561789891784216336399824110016096325069780392799828712360498692723629518772477904562878551087979153180016119660661629714428171152595134549244921669357637378530e-01), SC_(4.90039741160832963536753160205593132037374376582430495044622014080102593330940543147968970516476557812862892251484558355747279918010270824195900052852345758671435269294213984729937106474238759954744443173560342611126375754001378758626835355417533327367416358134292679789559890041569110407731964541608547658013533427986766123173276022255728761713441308385331757886687513503928228738633573577685286548823375042623755093322781458210089213265443292059658113438004651530124637994621070590528663737218059825e-01)}},
                                                              {{SC_(1.05906915664672851562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.71900041148086937973555321604330213985140886896008582336879680485951801838536757137680147227689999055281146908629782633626208197037156626351590838519938227644843232798799151269867730701592257371390578792620045627497869615806106292625144081738038149002249083747141778533295159439332365548240034531265935825458152081675135035228276014616438214653329840956584196924947186240548057375341023247779001645921678513017568431415395475877280675923689817306500303008012021121811240038724856466165513133102993682e-01), SC_(4.89683896249370553462585077764343079070425471970774934269762429179697954755140596970515332881771953730866664093747597682883770922465296585756705379891189164474550828309710536478687378551749125798283750925804320256316131484501216766671168200003672179899082617391804064193590636351604598132301058797388847653654852045763239641614760898092478871627214104974166613633239197560113865348299157056473943881709690798686908910527770066800305622871129681295792885174909899848762633358144516547914334749398063424e-01)}},
                                                              {{SC_(1.06404685974121093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.74326730386322818165403183829980231220704758664528761387420793318199623988188287228562182015131457264237017227064746614998591399611548349871711291795824419164529165313313021083410212942383334148070717204428133348646343376310245442559551132343333788773189360881220499349668657349467625660011112074882591775033745941184779921679182973842931373979727864745558701879046424084626658938114080386064766769338228176043903994613285122403749373739641206790074751532744011064257881235735911936010463427099612510e-01), SC_(4.85337788073381287161887688374158104787121431696676269420939153194208236780343659176489818915243470660478303445022418521038772374464737790940191013779627823755948639551012033500994958158596241638089706174311771559123609136179569130774973500169818848750983070485708416951959646979887204315285378894267769462886898693434976876822042800157209311826110363162979732940360749999711522340809800368388340892598573711896105070909259272401472483472934643092264455000104919075952371469577743222764107855405023035e-01)}},
                                                              {{SC_(1.06605577468872070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.75299967790800326957579466517206035726317102716369270128391908288135911852195765828650872928533486235396733613840588300344811474626458612175989430336995298154686296235044268747799901895709710805420255341939263059476701352744184930828290106559184325681355173874783483292064401232914578814995682806788689043618503855229338630525795134718154627642954761554611143112771548418565760470236546269560167412033082374631027328722837121253712518795218699823558584473298010514761381916663250079831145927637145512e-01), SC_(4.83580361869073329096825498101204074277486615445135909310168681314825584186657157743805083975295683484952524011405934900340956505003827546459728857790961378812777211919246155282298673275109441911741584594258370232586494882599141950379291167180634978982484743769885908842514792665575851154827558487433305869590301423981877540440377311878647101784216763854546447711696835968416389178865142487352325329510548680565244359142338882708937974756485549426742727485384836573096307146944816997897987974865088132e-01)}},
                                                              {{SC_(1.08875846862792968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.86052041181556804420157853003809295509020381003159632678330031926155613313697651928224454553461236532769947500220261165833194050244017463159967219713343190888940872924004769898668054614960612067768163625708922335854525564217293571956099993449125025760275399724646641465279235965514468163044857266824825421011134068746859211431142030482654092389788984448661655175218265916522966248599635107890290516032595136634978232855673202716459245381925484723476080448943336886986452613547709008515545495817569844e-01), SC_(4.63585785284662028256719823759376681906286982074268964315510196265728231707894853818039426659059071662329061671114028654510223558493226539111242214193138182512619106471156301700943201023981145277827931214941828831485183952462840898818541019222917041622101466393157750959830184099117253138133262959308462031622066276723882938564922305305898089637006609621812072121630293042477785161605023273181599435075615845484386493659177045916992081830224540648958182405308981792762102370113493840942771604418998517e-01)}},
                                                              {{SC_(1.09043169021606445312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.86826482236921672447449179706708485375043355553691440273593327420168239477132277214344720793711699844640227035419019043695996177843752980965659507636733114075792621556684339379870175681850993461559212924371482017360541975449665834411762915368590952833725617100522956368600899475337046764478577981743840414752227942784520893184527669100141833554190941821310082665045546591131096732242366404075879568232822588962816549825770535262047406532220397884349718398351351345631146467329904338988277781412388604e-01), SC_(4.62102575629358345358193278220239912943762914155557091630440688880915027260681567495686384307691236098241669002192609522100608971538797481822468296643338310413267745080338888521763724449703721181525711685961754882823506150496638839603163061168716786433832063182624298206059756860545859311345810189175501383844100673642551575982167724888306813123033872261489745668071968509975782852008866634876883678069222670357529286372112832471386556313264785227932452858751012982478420628900495737432680259485050530e-01)}},
                                                              {{SC_(1.09919786453247070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.90843227852636417754078023670181836726969888550715979569761582421788842009811166075357104409373200529353797356296194747329117633898284595748884928377534387104217962809520596709461075749050442194320744109543038360303571206655530254972549509191577835061385645662404364751070825063866314122891742192255538291420008446512683265515675475498267033791336724727715086534695038766636105394307515824333179209863613528055367464822768969790970366968860100398720098161704801349229024135958102907283928389323224690e-01), SC_(4.54310844454648379873120607006670548106504273936308344713803781953816202878153053648467912295067031642609621240314406106159323935686078031887375872538432773046877998973015349829044676649690256098999812181013898252995101567265319895403366026693535145332532873655206578590173815426496998031760122181314810388522458497891773842101978471976657558938033312291904330254393742169054653345552739972745892889286687291515486452550371590537891653627022141132791592981991782894148906882988273880648621145756781087e-01)}},
                                                              {{SC_(1.11097049713134765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.96129806525277931549746940258054038497901485655442462001193167615553899642423376679625380957006925609116439219224858033789799075021311265199475814709599907351541682459655081479100637148446800988291544390650139527246523980147599760194178750523378433869006158214829518372397604307862131909717684083204284241198398231089136180930422436840921141120636985652941816392179823567868504597525864700725317377642228825193551884085524027677622962577073184463809485907517350000538374062310077315366255920874398518e-01), SC_(4.43792034467686161435066158920582937499712557756861035727252976848950110688968604315912228708353790253735179591661368667429164980481829903835715257840075598064072824002764782072845168539256496422996300665292347918368805696122560306744840297116277600434841582751477611680800989873578927424627380500046081155735784608784217047984558403352197070648965620223868221536453713383650286042124390749422283505134734861735393518918432668799277981357022864234465981498457298557827308215729393447123815324719923535e-01)}},
                                                              {{SC_(1.11469841003417968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(8.97777993844069867883061833880911622006887326593247884434663254193661888734281508879280574938201245602083449732573669531783925291848639988968125196704553953589366990918944695638753782313321323890118010922221573802474698070006163298230204972483445936716816168920988970067182809681992444702281259138298123085231327090324810628911830766277370721641182158714867679521918526123129893316247010190359472609851512168378609591714336295574522133017233668001470928320744807364031893909492535780311537114396397383e-01), SC_(4.40448264577483885910375157946717295915588861882827699636627088893229732284307726315707187475199224348391643359726102261524390968202594593840733279233687652418354013586574979551135946054471473954056758870692267774395976316275443998231016071492822598582945261015440379122802477725712247192982519270953451354709602577554144286980143085436853223623449058582287231933171646155624518683292834351505770838921143886420194465409487151334011900040856783736776989060019468666458059591569074292685623764135347602e-01)}},
                                                              {{SC_(1.12690067291259765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.03085489385391432138253648320136584881972783327890236915413986443801167844516547603415075150516829537723847711483356329411026561303437978341538137836146631530839907060578165484607455219737967202426787288065430192025756314405129316124792600634387383385213813622327788968426536841277494211116731173272141847162651617309944529541815581022123818705107038152033099618846122887043326857140151945222693743782852899700635161577334205006395214456985256802054905416422768196408511772953988605995576812240623264e-01), SC_(4.29460823430435921006266197584528037733748764494732686246717505687114122156436032393588509554223958375815536774890597205754201803789763800242662124185976046398574571942282147255557615032964621564822171042288133276038438233227333630273947706974237786924602656504453943651543681466245760446369633159753930120725421033471338114511183990802815831071292367895473665758738680222262438292573638438829073833666408315924246288193759142668342008705805569331144834511547498169751495542450410208917334083742163910e-01)}},
                                                              {{SC_(1.13059329986572265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.04665167392049319620345534586690601564567126821677157288179146201232502224038422158590894129258427636693774374991718538331797402862317721599358645680187066039483561196211510383540514756783626943025645617696737318571080217935639578670283051167364957232392205621360119928029038386868026301033816567702186916413945026858945898884444539133885745012029762371205009252452353561358454635292174982169882365306944417833571913181192416199936541473351685186213596148125902968967370404530630558777459028074348239e-01), SC_(4.26123145237987963991613880409153775051796291409747115768848883186503992232882078065961622999098345555682662519292123005912710960263209200406429824415675430100909189286037738185934817050387012187711110624651352320496017247435142334638833769478198107500195021860665003684853075795687835166282633358049322641609672922147273478139866808881821932563138904972039419343160457702042396592530159562619762244687437043963692192588118989577505084607997788618215259359936094268526404135820006637208410406899687037e-01)}},
                                                              {{SC_(1.13203001022338867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.05276449041733672010394121707986473647650308154796820988450667995371427742162893489759701441144972742607911598724960388654184134870687320510532723658273849388688349217111452962357294546426666306484813458191847624209008230503933128657901248687587385339974502942770548704446490212953058721298608200351499874587139421433041834508501966339870189580806151431280630166068971566970973089984628295633880739897314610369766087638070821803684483176989819772942985455660825311309235876553237536013668065305000950e-01), SC_(4.24822964080791397836406140553655164285290555828753133654215241349128224504862552665142530358947448313244621905569067742835864871849030965039778594300582077897713292134045831590878909923650003553010034665210041549470686252200567670421755471525246662755775220033654481207248039696872143349607384217082384877921659747747396282196454772408193679787802467785949018949574031801864194180099340272507112889456095629725679569306278784200415308809374685045388176886359807464124186606204017335800042421388130291e-01)}},
                                                              {{SC_(1.13580036163330078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.06871742614826080426544902188552969097848459806253841312178726501739938755516444211826915772979090536127855767525899082662224114622182815815612343465831726391255607929734082143238153402639236649734531393050939975703605497311019419494134459261321131507417008707207443899646798810350452119841213643499629620414211030084093961027440802732600831753935826276420335421569830325731475827414663734255422792908765523351937064535216247075985814083775165914030572741504380395913744298728644899410010274648288436e-01), SC_(4.21406742289143540056935238939259708541056211496750699572410089673639210208041539522174047279155199117564705822879329351588563719453367242375358674638504791410169798932363623003826047711618787025951475619627355652425326365677533816876071542203043388625599667790949286920973946005101230035741719273016087443767907768947724151049369977302480232422549185276584371407614838897669352323162936830603087635485697835568603231651771815134621466815124052893383759994838547910992828230478070297904246533640163446e-01)}},
                                                              {{SC_(1.13661003112792968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.07212645505078336592546993342034347346036166526424106862079138801101414155005079700969208442578490897700209424599475522246377249297244777909388623975719805155716971165782231768203899326560121668452919809859133801211211307056050647136579966629695848877926282267609793465571254118252280752501521262130777941983150143901874832113135335072344383270934369371992512277950310350747740418237558480525688444233353187647739164143786205662610152386867031750885707697735306042808487292463725715483452131810554418e-01), SC_(4.20672337854151122457419922618285571400958915669271978123671381721041860797076368560676678098491061900075566981882144330319995537031854242613255071424533255100142882239789654494110694602824957866149242812165087773509386357927168585463500271966119408996321033682473168219447765947440866337522704235078470443456337386648514305992195750299860401351353849013577922401633224537989546041958482707453618435788414778552015740127056056170683492826198507074529366220355468791722411059343918696159230187827135461e-01)}},
                                                              {{SC_(1.14259672164916992187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.09714808146786766049489801864942071290026582230688936968489304005176787639966209570341529348132301981885321475662528144306433593266804841044918666299859575282004116334525253416639794749732738787181737628768536940208576836168894664020460269602393048737409067475417277994778388667822250928151297675111015356641185595052735384019315307485456414477227270612916643720272064123936491452009884098169679777105872945543297292672597846182275840226359997441848714050871056195110241872729791036625621656486350379e-01), SC_(4.15233630428045828571165282003422139712498001317957511686008534131679635859864183538546177185653594374218335784773172740834926166657981604452038659779134984969519272193556311849431489541170367150843629073886554832945321793115321801590597547238379687982261245564993552355427076728293723743931166369926846082988125088930254643258317503216425767257590624560371522928955957185570513735646894542449058513305304736526991548661282952311223031495252853637632912517195447976026206965381611747994754319121271858e-01)}},
                                                              {{SC_(1.14562463760375976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.10967928505449442477081422038075435262620844535733183630539949040639580246047111782396326632112072770317601862316282853591194195128025559773450972473683112248038698411251861789551926493885241718374958549513870960222836015685629450659124563614658835942746664146199112693866059530862118589459649124320556609092325828809814480862988576538019654266897227975463670711733609274726111254449385800639664475604251535601588720621597744311853100014972643463460221171955634192568653477510794182842549976291195423e-01), SC_(4.12477191168784935397589542884325027388357689085498131947537129681766142724657274514830840400491483690289714355599661512898778855332753696947337182311118846864698871919209941904729470689913124105484612422836802503073421988240018713959679754944896616022088589357690960812847247905388912400965711338977743333908776275515778687477194087747920739357278304117980029841210676526164619193233342273088978741163549949119443274091275889686142390637733620167209522300374444339487273724884402412259930353569845255e-01)}},
                                                              {{SC_(1.14827489852905273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.12057900143872218067970982922192214668187795116948511672998654720440343998088259815687165872732371544982085414715899103659438900521194591600181946583254530683253869914773758817729876505766650911981273294394246385317544914009845972530946264882254929676362709065143411714714374056356926303562018956394533704359647326639327814904124978641240051251497949310161132673465026917592081480819229359101746014566898516905814766805157596467983977225181854087666156217397312415244373301335833103871561007079773134e-01), SC_(4.10061442695055656241592053545077071469873703766913194109513704590498736621005492180749270920350467016099189629802475477376987392515014862532685086320893762312509118905916882348513232369480296518941886810485931101681991846575827285414850722852677268262077026358236462435033082529712139434835674072710092042900091838274521865048762682145068651151230083599431929738579885687009093402528423886269652027467895932317073488434254279724863916498024223536756341449912881006114760096653887317577800794879031173e-01)}},
                                                              {{SC_(1.16087532043457031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.17152307556783010082604234062507416168862222322805868126512908874350444391624031476519790127724286350630918661654825182157230692102809969014735976181937839485822838860652846031092583424633641391644860770801491068731915330548036706668019531194768932514193867386550118051090351625465136521387253167298769484099254783855080887282648257670532689477740287568441339407697982292779708547695743644950283477211098450598616887397228591108140780640496617665200172077741439182065274301575092569036291761425872831e-01), SC_(3.98536880029023294278086460148693023952159542068516426102352744170696664558788735125994072124366919705847446617560472546619823569017866513210849521064383900291761216761561162785231326739724126611432626880545467591218595745274715036559709822417247333109223675317648292898183991722665201709066965713530805920987744018060213090984936415190464295866173245814907161799185414469513053299582009503693771539080362564920256173007163387568260952162357027452986740446686993641840055667439013164437546688199957800e-01)}},
                                                              {{SC_(1.16834640502929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.20104186328135298496957248515380925598682445083418972994271507128899677334354024738351143080520758708488667415355312255775785270232662089553577967970873736421981804100263026490020568371888346518033676923936168299859080948491538582930383269106320961933704101394993022866629525312057629214437325611043108130115817888749357539683062625350003630331806028055668105891089090457634237162817066604589680759760697303496357583924370788467666847648455530619909598563666998753300878386929067426913186736757889555e-01), SC_(3.91673698761405321464513321854133469209236441434776579154828431768579035949142740619365697318411018051757099441576277596809431746185297594423424182048115058393371137639111683011078346738805323243265590930585823423972969974096869859395067920268358674806993929141535131498160046100298751958510732699978972390385447219959583475405359231842797831501966566056834990709022102530031667881663532298096407254848006625574985191288563471602091514320519928910561533915950755452343557100085313807737796666507723692e-01)}},
                                                              {{SC_(1.16875076293945312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.20262487461150275570854849780709403747997606590129256273406002091397926362725679700314769011519619363170611596478988430829966031422891691220439160070374308583783549778149771561058934629067954429785992714463951215361015537223308002891453548856025459451393659632361923622571301382221566318474633889106056646792104013701242038510237198194757991668351095063614184302113070108687939723485895001025253995763922338162059728474300489054051672986171154008325483425037217675490894835207039218324736935888548623e-01), SC_(3.91301615345268197670216410259475825479249814948784542097263382780490667222684759025749178892955351123015057685619256664176699053210800289407983698386813767660647021867504064472580409883400638687828026689981725185305365366518569508764730815075227525401705234916938878520111673256164342830245867994075805093498516476012702512020012631774741281921364755873559668935956266229855973637764179253709544696893649654956630131135234060288014322494402701900781641804665327126095941387136867878734833794824793014e-01)}},
                                                              {{SC_(1.18831062316894531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.27739769191142907630112261054672408433827074235085526421482402528633827895944923714163948862685153260396240262340145527560063155405527940607146981993573266564290150967731878595488727269617050804601144969687367169963627158725306967711203122929341189833054178990422555120382808115008410479562507472567225958915506070205471388127086879938312382037849559206758820928332307712139310928957998804194412914452576847112033346093713837229781543082521999039397303555891581773141822238740680677363969056621960270e-01), SC_(3.73227706181045574613892029421809688445117154458049890104744406554689644882750279997054135059574163615307509496387105911854259028657360416931236569295709228060537679801566224951288390179021321788619702625697075265845040508785342707672119147499611162773659507482557860755116539100333611957562095234456233834164399613991535254524932170807619064048654686289232544975838193264702607218242419552506465332505750536654755302782459301575073829888035473070859898459854288592606628531015905515215328965859623271e-01)}},
                                                              {{SC_(1.19039630889892578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.28516186454902422464142063253245617835831993322076364693117226547496030344560233063981553692632197906206457496888066502992250708601341632026473576675604009580382753778104608967714567825230081216174626717466594925097943661283821261104432382946816906642439643088433343511790123173750311956101253560175744184353523795540070855594196730896187778475843109146032220509648721592227300000668194085625224264770046743164904530985803854668382032903091457367068937360346739058382131029700969766599027553880587035e-01), SC_(3.71291922200369017368204717159193337291160314265581751304430097275815657042961764795772603591106890014199979261611780010990427181966397890965023529008555433311859263133002971046765531291467046041422198778207159128153061796218688191455896913293767037947336850496541997112417482121395773838067935117340279113670753379915713771543247146237271051406985023946047916102811069959567507384501135518817887548474039934107670070502429665488964979540037453791016826388783962172031111105650673657315136169550774260e-01)}},
                                                              {{SC_(1.19096231460571289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.28726191059670008805902334584454239548550218003865918387783274515713982271365456721907937011819322308247639769464524642436387203203810279099134490238994363363782132621188175076050990311114605791787695124584795868845460986309932894230042170346685242336929156221469507049469718315497437836489677855006366723074385513946845372946221747502328157358391353990910345204305499847252456480752480911497808889323910234417398714462949933866979576468447248893856074487655468996673069831674808380773383597169728443e-01), SC_(3.70766317294056957066417833495763491113348627015635672702274459845001395617942727417604473158835895034446078418116146503438699088887013640040997993396866348083748879658746047274170403869051444308176371618684989522258324871577825963013946350547476759792863601524048307707490592682701522755101838488421372094179515294608847143712947490367777105233444576897531662349328883091349236022669451957605736146691710067849435432231268480058722914653984610289840504861644546434752499763108252506066044223619930146e-01)}},
                                                              {{SC_(1.19279956817626953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.29405814959228531972281872115577848744241330476539424322207732928371094987223836641781173065764693421962834615341501910662796428871653547176129657230584464001961420818793097252905233960596169032065469878813696966372914938789591824236632930918109243800393676264317247373859532812738037382380071974856343972472688501422232135472880038578042720155517847610051178510453262581202097816409643920956443406712243536414770069769104615562719796933834376565411943382368723980627719029012450807053347412219704017e-01), SC_(3.69059386982599663479268899014918242058146304796244059493852041445394639969033313487963675689101031682048803705239313832756670076420320497105412508794711632075221423978497396573301682338629221725782129504408874038643623931958659624156623372278817482189559731742170140152759634226143222489507613263475147517846822391485630459802157747193534639725043070387657299498871201980115247626547063665279931867790323452576604332369833960637356251333916740127183701321319256002780080402637694714766766303212334787e-01)}},
                                                              {{SC_(1.19591951370239257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.30552734832125840052974015459491503538231284518030644709405832601114655819786012336846100936680207777126596479633402462155688943661893846904345931371744036668113498108437433881236484618382378315472957245446601780294109805337925926459035813330580701717675021695222169203288405159988537677776806482266518848385138258917056294589703550831979726470477115328896554634634025613709309896598964607474308036025472101068437690489908562630928075259302077592097964344717678590374147915076540975888821010858519035e-01), SC_(3.66157899950897266341204379353537798419054654796604975177391472417424105792604912894740645390003868771294538477949014951205228558913570580253857432999788735617990786196602185473100952466926540228987836275968822023067591944084939010810167083511169035277797744091307218205228104199829296100195491260033447590647463764333346476157327673006815488595244083055259415907488611696454882856572283242204473890087698344001008271889415271602016935370350130295114514382937056980246894560606589697741512051296983056e-01)}},
                                                              {{SC_(1.19689273834228515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.30908647972181035306415717863675078910016730211025242842074951415346666558517182530606465652617602590503103135667675401127384688452760685047951125160893347618897936414760230294770147124404072822817308689665138567492587093786105929151601743217783170480962687630249977962066929583403767936082548393140331559208424623662293131882909285270562319002202662931897538475959477582192591513214623911397240402575108754598773509233723284574310101952889917315026274370157180256653172508219677050914615205659980002e-01), SC_(3.65252089837424373938727945032862259240929210684074233581248975290379302867642149838224468303772701597352111309102217895680362856214434627802079638333831135765550971400956355746825337558988814224935287422777362046821445133407585196406260734897665635734430246512236439325599322156781662484035732365087377434537435860795506489448259273991060211231949210335294264543504144693688588523172409424441977492672322754209085937265193527550849457330550424215617614405156231791817612582999509373290207256377986403e-01)}},
                                                              {{SC_(1.19715881347656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.31005799517589437870242196814333217476995807649499693529011070735117435783018891960654522070935542030690361671439020630259187276793080845112359698698329519869008736053654931150687543898355294413242013599585226095076607506277217378010263042670261524175168832644995554677688260009151311954304087058469724641996779642466187883365404506690773461791353735112562733576254065327574996637781135584728439660654962080740806431927665418870924715565205976970614881780948820952724574977216025534368393095717906537e-01), SC_(3.65004385267648616527954865992296715275029468728197283298369369930031821727862070318709641875550598883423006447077958239050946694834283128158044911447498221867204751900599261516784488761688784555629755762916704867361218920515635517453763245342455078305608967286538908919851124430404639267094726214081305999445008172503091250993696611411571069568706856976299567635700760301194898486438742662857713008686781080202029537398830440958546777053699027918966553421725537665837567022045705930444634954470244354e-01)}},
                                                              {{SC_(1.20042037963867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.32191331430111339261449895086549029541470003741228205646821040804686851621146871816651400894443737177018463008240204638830453840674110125623289812708169644095629325065149010200905012268466419912209994111447231809810189231643566978559554114551916902520362624563910880568441884854356628502594736765571672265089892468311580935293611112366583177210281808378715470173722388206625207952034210304617334678964865106150827253512547516634051558951374863846101108535417490465431614432426061074316072852256048091e-01), SC_(3.61965912216269772828200120428024811920456259669546381965248128788391743437600116259321455141954281630073977684422263911816649717453219170684896869008765512815585782466216706979121600952302690882562786945071216712298460527846953632063971663355824055031885453974118933514177156551266644969344183771388988187700954591832948468792829626512593460301367220285789086705214738415671060717347435359215246280542287945602204254892492098886152245370062298214430839126574533251827355360921125829063528873727247319e-01)}},
                                                              {{SC_(1.21129655838012695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.36072925273237052589741354103374154582179542921990534420565853190994871061359180376574053467333730868088721976674265695000194820004662799610349094846048824061780209573454597704080611299528119256577646763302585376602803450230153550952519196349901875966598992633061265243075394277854693043396843989237317378406228134060736859005383861136196908476811762891497452579890884383358628813653439329111984377402837232792697651409263740599186857664307725963774301386350428715153756030172114179091681771359927544e-01), SC_(3.51806024067816042923452710343957815012239304381787658203322727361903081924558982395548437902680194552661545970996952914544963432766599983263188021061667602696823019854633628005351974297646059178922893378662728758461925073548375986644842575266392632793345025076736067246775258211147285299896097131511715201194597912854700786474397178696076586495453199254850554056748961865026453531107999621927404659841430395128647175395965884488845322038120983810672480041843000599942586757533592915075486458021630309e-01)}},
                                                              {{SC_(1.21226310729980468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.36412525705292113005181122991624028179942861503165469987226035896376047466885319902303883839379741451140394259347926363975217804886369110016553611927193486731484198489088957178930815051931109152472621108575791931072217293637835723737313994641590019638899944999808902113847285921266332195762292416864655779343136099559172332963707123208361372838218978908059128893432339110061768503598206594598946807980130546308223430908284488119931468633860015472526279070073415117353762389835727974307845340200613643e-01), SC_(3.50901099602488617933961662609194577832551303168379986695120681175473236287005062080455575167049970587669429800258767273667243277503972476292879911386422017336420102780155154909666335311881195241771041240308554984076113094352112043029341814955976936909466185721106124354719414139265857104084452167918558350056175176101945356049631972945089068579910004816914095211003946675102731776786465580977726763772219149762094975256571732700846263127621206586182138024859732939097232892050622642147713701363141822e-01)}},
                                                              {{SC_(1.21460151672363281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.37230515170665959085324305435816580824334060759925311235095988583363681210882971361015639915500438790623872866050950396566896332921324713253658675617981474109530663758689150181212482116443395967805522361320173948366777777549194083587765101013923132282405066334922427013881735709518698558177470965263274689926317431180375953081525097608464790961485003864050369654033804129195503199592098281100081388796893319774893910509480688105560424395937634005187859987536277387268150181832415882844731264499687596e-01), SC_(3.48710426332405618132227540555903517056786716385788196839483490850475902035868776849242484073475814113679351593802158471206518252887259870568005759089726021896451567470580888732652672079444087984700684961404157116233065933905865181127124685548895000573634425733126645685362196697441178043026624272299059779697880380488364435795548619600267324209181423660077472428253880775703087620032376724562736076779072125401913269088489020843657385728969803849312555076792481699941332776210312751607467030287676880e-01)}},
                                                              {{SC_(1.22142696380615234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.39588770085819691865847010275003682328490704428234580843509362105491428163438448710042684284109797054096472724012751496536528244522738064907879573912386102664587700021103931492196502634778712822226419769182878104076466423635618060502830320299773502938148601794567184867686070187290681996430307341965745352810807762976757865055833978860122338848801972274049557920720539604317776324957070543307660085092806429545140437522026377782954574391713807786920755303595104855319858899110269382668643762661454669e-01), SC_(3.42305336108884902887927320575279559613447444606461224929617092896182369164661070824620337813821007909772304866662213350426972631574890823317729042350306113005691776633881243301450523125297179600210819849955453532967854941727134365115369864028598198604524465184765997818343891127520544365161238551649752264818554220850963710321530446994420439978205574105707505176591332458227716523834711613291351686308332571358688396721775880721873257679162552336092352441386034121556519027449256660873800382080061980e-01)}},
                                                              {{SC_(1.22208547592163085937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.39813978559762047755322455989924734422740736531083873105168806262703082104006400399243451104269319997589950335686316330935313067840719316152982821117636452214516953937745633986997164220794471996103513775628249098109014694914685001253018949349415846758651766091317887446106708184940528230682632778052559685259330436735642221324661352012902839478691454369461241349713438471782232386917837439816471075185081605028486721931552758494782311573639335087551525116851545075348233789520484671443269682756137400e-01), SC_(3.41686531346600084300401784614799893004757161767735513566812293919164675411857921077427802420771871729690257003944133859117661387568350609422772611494688750011640503072888589321701691855742721189777588064092740430186592868077940180336134880261857041689621936378609096903010378220341856304235083749800120130002770246847233159418787899794883146762692009200694121724147112767760692147537325878164475152361287321256285655447786743373896368939341494404532390842764544084149054784203820907870728211517025269e-01)}},
                                                              {{SC_(1.23126077651977539062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.42909451828498508606474709375264723308842078821339777686217320508975455062300122709369552657428197799104481963400540519817121209533671060192044819654074230269737951307056021548224854806022284259103862348124304810034465177910057295938738114519751420463405272341889617811534402988525056538384348037656428758340675621634449278436308125862620745919116602430281338222697346377191632713614962700759746388254996582791040894490980209916664531339155045033869279801435861516973847175864623025517486143969820319e-01), SC_(3.33049194042682605175241363784040240910285245708277205252748368685755534290141711394993998500991014686784430027546221468679903420140548619407963172914406334035263949612686570761312298281247646711316376182219248163711930542803235076769721715931348363633226871451602492708928131518862713071147775206684552059843068760118425994684230685879647854670292765541806378318880699327264466824963254196260044211725225547447464973750115240147306146083186263336647077159866504141860017716353241263363657015139726553e-01)}},
                                                              {{SC_(1.23186874389648437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.43111760599709541035588926901094997566502718811144427478325174481620111845861591297173944398313017102652417632855534696066465013105557184226146279067590494633440907772328572170475398014172118282965409195033028893604787232003194956847056575653399955047984495654919094634481779204010157424719276038743419254660219469258610283432010853914432281178805639955141819568197338491600326973895231948028123781044473735801311915011507832384237593541506995096256938240840412181938542889141117184710113419161088416e-01), SC_(3.32475874340554457877202447234475014625989155433126288392599830437752954563599902656557040540286535124631296551395636307213098940140603482531580069603155304081711132781783110299772832553357145878218145112077910478105454877237161308232045592413393717909447388261991731950085718673812733427205738145139181209503016951452142299343473400624768159762695213151270652676435125559371142019981631428959629983259386047734915266850184479686836227393801237648335275044395133503637188941980982471598895745239031016e-01)}},
                                                              {{SC_(1.23285484313964843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.43439156217638164611436012930228382689755438982293909056748709765218557125176035116803710034077451195147383026645041830589413044047646236397156773656436176560487896613910491818283697348760063758826608457400150535252854890989562986838851695706325895734051254961720112330923499814106800806774483808233423741414105583491907454466356027291514010057864404870966322389372113571153221924917442689876389650652168380703427394113468793521455108081660048558837404953698699159745637539714086892947033196599689263e-01), SC_(3.31545711049548839257000706395881987887544852335637955820041950634792349777877146091793726646581794280066231025664093730708988019858153187826134750956235714639167905729537868470957660612761971312259990996222427866783399658798385953978906208383850722176584774703718987266959132557807629489026453894218196169262461930928017614227977721723176068755996006303058069652596783549031021267218301715854961427011462057088981815919420755933964243770657110629374546019598030758679903822363458102609871773705474429e-01)}},
                                                              {{SC_(1.23518657684326171875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.44209667096123697921582138669326176918529476690320250447678223598946323362005245879411974799045920762058832832985133487447485408509583010708288946546618259451679406538212487653483826636128540529638916310113140319036693842701353614311952050475953080822080569346027859301545516626493224857004408304854843429296425792156637522761688106782567403043835154816696955555753046698752637657160792857902429886164915472067084443361250512545205817736097253824127751766134380610996601846700392801742914543911037926e-01), SC_(3.29344962861476388149406913998441912009230904653412583399999352256824561235741071049429170589583463558327490064123206934737081606018173969087932126027338556221875098517159871251691922634325098784219711062126107609916963680928323227478737529546256658245101678834691028532302311092045323468689356548157944765823909411811533495497374371282141490365239488023630772933241701929407601305723704383237378697819408791569514437882779120717260032221738642842405948248710800015826687135545568410720727074739930280e-01)}},
                                                              {{SC_(1.24624252319335937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.47793106505864155710372335631845478492346645144628703595395965467239858524618751432955399079998713862118814340871316979430436352804054698096345310731993977194557526214858749942483204958723187668936619789545938232937082744239886585206968488048066729179235203027526167144649855034638305660874263285668201906999849721073117980803930530336641270842753565877517211243948658335212510450677017982023517654094004127185898571544639567951870938504467089485132320187321443995300412459166829074977205069854128167e-01), SC_(3.18885915744116307991824460697936149035981956507037394874207203343766845897008716157201515632181715607046169386224158869719338499493357779326841073732915200544938143073386213701049092950004898330773411106540232117579844388237617549128045386552657145803158607454717496911937874697588703219813472297898156220846861451173907218251333262291730714466252844502243144054267530253758685787092879456557743676371047799961459103016257328082697210759446844885660824574319820570419954670583966584126272686255168088e-01)}},
                                                              {{SC_(1.25251245498657226562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.49773856565935007970549344512699526547923968348365818675525781601959843817621732366867203995655385937951745643136104129868291132508462687598553162794100451077120644951475808579961073311184381003686892179651005302578996007940600397705098474530493933204289689666095106701306420249614061152905549589374731140175838517402015869865999694639591169784678467636104934359422200801913233216502687786281067467908895843320108471480144038611249749161387634157417449327368632565706141541919713135041484839611347573e-01), SC_(3.12937088539966310827617816863542443537540805689998483350331382819275180168620190928606558064685917571580731924251185390060638335515562473056747532029126629589310820045526353157641807788806385485857586135006880770118838965302001129873513923219007500039161812961582202391858173636142000187506046696434678802335539416687869723789979833360079132724807635630965800159606622528573160421322491440022849488963828968641231754471167254476401435600251010890399418114639079564829480566160639228869800176144301207e-01)}},
                                                              {{SC_(1.26107549667358398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.52418695956686480941850006541690930239761325232741626838515846936884406383023802081370469754681074804545915353145563398074640428884079797524360775772596192826878326965373666553059294324922147137549306798969863433593411183534403373204507899175938685742339242571442474706314723892564187399965843300144380287591834727003669115250840682958587379968031653433460770442328081770634773759114952115757110000204146434560295139713438946949932003331265057495416454532719341146715168794305719687927911827605620710e-01), SC_(3.04792761712224384443187440326485521277019541458374687178938884329401562377594129973298941372783852531469542452088127625467352152764900393544352757876910877738043333639268176601041834046867143684929017539126542262643786563076751353073667362561187662421509245109958895360976584080168450328548225498844675255271705276714092191942776847386252873452858675899976559091285901770662612613531069332059711175867315451004429558937196248454798368082613262854234614462702461791856600415426502994212521285961939653e-01)}},
                                                              {{SC_(1.27270126342773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.55897702698394019729304962915783339726149744494967774619631929617070997603359304132004967665208808726981185438434988592804380773810408457710481407880665329100751305932132573383322495994314169335167702811247724242084676106663770075572223167737313811281221336916721200692951939588598623738309294942523017778375982939758937559540634496752120663904522086416198205632120656934830706622226108996378750114163976746954239093448542669711432898214610113927075962020141106214972505729115311860914979288804790829e-01), SC_(2.93699816097887127043847639571997202640909304251711570871621466393972194728942985403745669049952639981112592351372429654141213093184117782687405526804809341776471067929090431550971880375019669575265668215408329474561215692609890091928351019813993747087345436206926066191226700264499898302760789705916368784748646787652939680945907860790073813947944118519002614505565558758391723561571904176502747834651484436309420341412474883573808977804315917279383947293912390846411905449890347664818172102427869171e-01)}},
                                                              {{SC_(1.27369403839111328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.56188809407302140382519114161585931061089096133538031388986746812799011766912214432553468991963837135206882860816542245983053233993094277539431446743357262977008827009374763284827895016421564230457917470211305717579021833893032138958039974074703001877337239390215038737106172458129186974741460670394259661415574457285603388199508619494741444619649181349790189072222296731305345037121134600074660767206690937687887307524014164116679464591387661354610259197146582254580550754314222778854512940941975451e-01), SC_(2.92750680211414746770844834430161658350022817838677528204616418770016411973049638712003593524209894044712330474774636787107110946674545326257267713468777492693895483352299710997078212274344324361670663764821113729265765705273387211601224326658092724978157805173109712835197097971977685009294324466709071461279772808181639695341825295953726444706286165065694230687880410120205268008012484510459176080990941425970128533715782135699234119402304189387675442401836055216754433030476408800736483624398815316e-01)}},
                                                              {{SC_(1.30864286422729492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.65834124448968758372373106440044548226231466537435973276539535442152788754757669023365222845168257027951609639462431742264781036338666497665199597024074054375228032559150094452571866604853409863786616373043000523609661967136561191379693746836366992799858653529442457581064828032990400456134462903027511889608735806202396605802508740621722399330444196254992207913243456966683022884751737196688975606995192636674990845283225951184164377590119512424796579386202619458608939451290244931218394255282524872e-01), SC_(2.59161038834725172326566408046635655484407996683812930425596593331321052560858900104499556422763595724745722744888885012081379301273496392545730800427206859277815623633316107868525096561220315385068440356778513672994616088760741224012707881466960081026623434606955678671397521489157762162852500111882453963438629697190599563321621932651961872959107980463673537799267563006925080070818207097906067384521865616370172042193402833078119193467872189984306913742687629125585377205706386812697845482831875212e-01)}},
                                                              {{SC_(1.31513595581054687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.67496509157828201912503630642992815986208380087219453489786887511179651968481635751257483296845739295085326766167034119259758101256282104848357585266183737568700627901779263861176788050184045731923724812808611848830295658768104434977347403943462075868578161953644447327877542025293961158175558534004721039058111728107455651102584979006718701806015009635716357761745543071562343687493685180873927341511807385763241403614761872459414672368709060179385863095127929719194061127988356635866834884782068660e-01), SC_(2.52884370350198689836509793238736044053809213320990655336570043176388019869051847476197344301598145790010542007186953761020434865510582748749159053480789974879901690784775151251388330020872601298672488507661166060231571603598086759786500882133991853156299415642748708141774922447253154306852506112676846419230056649032959277813296664662686618019664034010059955597878723714332427869130132431251976307122761466400368086425708093504776300178852667386689097710596288656596635943810817886346084363546615387e-01)}},
                                                              {{SC_(1.31764602661132812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.68128218332560022849151062862300290002816382002147406561122634954071252385092499593221939459869865873066337189640214979139161323980903390581209894104049320132006144228121983278855133934081123751398423334417586315867558772265879539165555345783090329019848075276239846426043655137159253374607313204375273679398119955419857249062342836994545408747733385348346736928923198076278906695111754630162410275969412267739639630188845066288458590745754843970182123421421688608657347772943092724923457373537413777e-01), SC_(2.50455091519863080006567737617454851596080837568745079926261175080989570659578673726466242881105045890267567542084835065570433112497594501436101662253622732503676986129627532303613101872288751267994782026817808674381109734346995384829715512131218462764261510046662595323365526025933703952987521614147369983649867368067869287418530494000899105489059330421493859551233237215950932397638169156132750140846519250994070230478406360849077447064427738507497094901597123294713837766393265188840396610325242108e-01)}},
                                                              {{SC_(1.33635473251342773437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.72644210557293654073542060086406625986306398124088406711769491620100790420760540376060363403161717387226272332636849641619930464925339803944531929266603507465706542065108113136867046044362596304173454484263029807116355953708147595143804202867331365545502212705865645907773286493184357361549950316863558913715091890954079746952857204650313515355050936769164887155762123877636283908302073199934412972530605773747022445848422608312918511410963171951321236003915112872694863002674706748808090242394674013e-01), SC_(2.32299891668892105578430805968784557325686629203513649173751412362396164213323697012298385908705298284670606095798077758105179389153786963623253782758621229155164273749408854178705238465846547675503227965043919867632856632606716985862406879880250070563911690782986211180882566400301852287461686831670836491595633263904306560640539575748724784015673555715408431433094224299347067526371844509941381534872980427669628158743417929463652365941992113826691670812353814751524843826719411056502918081890211682e-01)}},
                                                              {{SC_(1.35868787765502929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.77589214007614615935359180562771861203166061718965339152265847612694400557778882424825354726559526679131378190463366614157230082908624532353686825552961134847897731092392578220212878039351536459454543880630234224638675041433017159708614328391485993736084563916512754386563384570120566452752959876512351316136595224175505892099231154074614562104731051732156166147422341586213471542961144619498740979806752418525675494902597419595759347605843233173004190642974259705891490524545835711058060322698924180e-01), SC_(2.10521563399035850846293344058639880547734577421953544992592199451531878600608929560334781406775399358068856520818402473362854370439100435712010515124940674627273883774342975022165663149085933054914512215716969149912131601383737072603210633382998215613080762106302730395977878722923513835555432768182548632737981806045024087070109825978918059855411453037534752326280434726068704208466819871376329820900372129902093122395293491407971401671172806094740549791747150107306999208279058576893941933708045083e-01)}},
                                                              {{SC_(1.36104679107666015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.78083095805601987454573074803943470621757804524696784103098140449005639638284361358083062934010737831830783063312546836042296335609289925732230060233333451407917686529015877187030416793493427654808030710998148092926731919176988787289326234540198018431288569972368827591092955147419949536865952244750483357798197466999667993829746941833181764203465732330156288972592614004040835500793593364074829607037302415716045363105826526873673616003512747621072743109454493646420480930668081089526755822913748283e-01), SC_(2.08214931499471487580527212737500656418746457639132995511351210615068938343848506033358245359661394041703442281266292810884445455040891225931387155913258751438141035226449517065251786763225847298217846143225641509156212605618483988613037250889126356687450506812452058374859588919863830693505452777076935690791833854447391737572849335367943607136147722227750905412690739098366592762468180904934634565064553997996536850602898143403118093286692072145247502224184666689326027284268178665916305253016113414e-01)}},
                                                              {{SC_(1.37006378173828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.79920780655323574325048032290553442923802914302042449959517032217948051940150581020868536605314435386459203898708604722427631202543713090326644807022874911720884509405045011880194820377740065707611794602426514158781758693026900421398037712389268280235218067448311153013979648678838706874169795220643677990190870933642180225407599463343126098376439581164242726050065349453834012003763877617586777474403726187072521595310016909539569424640310905288009934114205082383526315485778184708537009526195176275e-01), SC_(1.99387220352411812643706162721391972243201742242193475787958496815486029474907430687983391246649586894127152003306028679128609931296024818616213480432671358196302228903498401651517092937484268824835198862075776807808683194099912324765269446453036769957409467627861694009583964690786001732389779565429776808515515017736450229078368649763370096373452237377053728657912280976882682351106748213592796547048629363878065867407923229520949463360810455413121016679444030724292708102255182692318351645333863659e-01)}},
                                                              {{SC_(1.37360334396362304687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.80620384192341085280818940390688592996930713605209325865795280353167597318617674789286503206624638647024427810492949762186006468639432931548924921990375287718613180115266058663420054121130510011093500432590233907644752304593295495326263164317713133789687740999996186308542015177315380533224932052581739319510053805587922178754568124801554813628698943853009281775953423476421434190241967808449688959898443562854457700532916910942532208670140823364856647585716850899032174120857753436343560437861952422e-01), SC_(1.95917488005704498796109337839462311020563464533356224712944059814078278920561867832819886450214797187489939587085888526835962063802556392807082653670784036934320396748454552006182311130900790213674388500137041259099662844726092679222947491447396027724230508542332716957208884897294938245847990852513593101461664259719909071166581138742150607442617905593170491086391650790888740658301124572273285141285519435831995534059396058973595699379902139733254076628925801545908839520914611947748889644366689804e-01)}},
                                                              {{SC_(1.37579011917114257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.81046466700929950246668718727336319603422607523486257737752177468390505792022504803078733499622336237569514186945730764657819229620157949505190809705402556212976287179933461585472651303039684488150298524723737283620337889897920345569054449457671306492176333362444469978214852108745968215759045161643806570983234462686298094463645317631449549682235915973343298000368089574358566062623971987254220397400720855377779653358609132128526401680980996939106354687468832044201823937757703711290958140670326488e-01), SC_(1.93772624933505873954526307542792857908119793419071306140786180506660673347469214081509951677829702334822528190190251019855050074377834646317392219744580866160361489259089532138847887047287371437920827424743971700527942058451956937430528654494731672514873731486172998987543330286127627257355443896756851760672491599793182135160951137115300143519605652789579329580837860650478529356618782397844974277048622432233205547812026760264071970210071830565819625688558008931106124303619620049393235119593562032e-01)}},
                                                              {{SC_(1.38131189346313476562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.82101473951433113616030058028945882827700529777659399626299791888315472122893848203122995186993249918138656191198348734122598050722371471038505795184682249083561762735866757721714072734782810762657563932528073571155752961737106346405934750501112839406941959325824904467073234302652189813381035175894782823019339402643440169650165761026339375821668333766483902789516971596613319142475601840957903445030084283730515297138803998334696043029278369165801886898644339520146169940327705952108934099184965051e-01), SC_(1.88352581247039312796004784885792696475588661060726147078352536060782866764818512994083123827030945328076367388613370055013885867405072819276681817228272086206013317353664827033343035360983767879057064569076498155542057096622655089221516370992457224624603085336876933342215313240050182855613227752921675497848476243136725589964476896553566468837178670329761618580278911807843375144698871715377420530960628384366594660855642419370115116659211832265632273031077713314597591180856207916233946464612619948e-01)}},
                                                              {{SC_(1.39389514923095703125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.84393748984697599494255913228519356500443797238149851639494732303698059390316473854670305205991023687197405840363981298453269251894181637148434103534542073081782734924644439718021321689020417889028131238320809491247476894902458941394325539956411459525912507857369660076279292066105700446665056353874479050722766877388177176029874265985210046842349030812087425559726948928409641894759402387263491889699421786524411665629018248250590827981422167551410817277634443200384399289098727342057754944559471253e-01), SC_(1.75979961813418330463246015346785922996793666199283524740663794915720273003795539409709892289424553224094002289191965889297876634196707865043091465457965056322032412992884309526153698834410862154379415726686609410706343428724975862198717229665810504104156779671263630038970686942846971450207400214891909970201246410306632949413399102387736446279872852586166870223903033833049605211179096732670493723266210161088674326547975842093333122402384746965183213793318184772815360336300118983377180563926983678e-01)}},
                                                              {{SC_(1.40098953247070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.85617435504275879052838351473422384140194868085037483863671989201067225619425571115767482271215770496859292537044150740107974152029149839011472238269874887036032939699625000971850206897702187973275492769390535345807412515353236530010768540682551390483886603019487960710475971398347149061935832649656222349711037952773450481944849281665638872163332303576583218021159726525048956435930017186229181305861378734868720812113308950238852844213779810697871054524548057515433074620560538926975013561664615709e-01), SC_(1.68991925339569339604661496424208240093498383477146418615565299727998626345325844611994811159257205982575484035326636993024412027870667349093871119983265587745698136494573535119564056284191038785903655082458002571428229328620639699045804331852797555083547720368648689121007274958950735582630052300967992220928569101056869705451681433318191980600098912075548588729718304540582582836247993674752298538944618403645465934491911133294241205561058621342699438071895927728838513098621388908181305166539103073e-01)}},
                                                              {{SC_(1.40101575851440429687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.85621867154937990161355741456501379427686529270485157224862649254966022362110443495973438200525536463242664277447890348935691893273536099906456638207162825126576843366652617955303374416503841499587078828970436237045163374727430933757606723294288110511877325710820014268639975529400467350328864739151245994094157058478899664410923370270816718688905971514087797141858843595803287066985538914148795677452085190268952123648657706491750188162484814691673998674800424899515850946008080603852145559474897554e-01), SC_(1.68966076435519353962481075898958477545026123896902065690890676310569504798562202400982815531169410784648901144018478477101528696727403731035179515876213449880962005156426103688847976760828487626389281701587312839145657572681155558686983505422848380769701057226774703457564482651992554580738823901756265324815389555165826073908210955723185833731466146611384227971387719800158982983339977621693099935688345979958646148525722384424484338569211001385904777013357253104499183168338276670653879474853213746e-01)}},
                                                              {{SC_(1.41011095046997070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.87117858586820775624965696236564943727361512341866183156650482788896380417914897793279124473515322346483600167082027894761850185430736258876861651247601475778439302962028949350765397163734219392424137650555626708780329712724024737895212969230465645942701271933175672679085979373625902742228817342906406414815750958280697847446219322689649467627772417102771255292832906277996968684852203671520607993434988730178276813572827981795425969341197977862776742515868746300221678580739692370360137716379880437e-01), SC_(1.59994791349497692096310940926922433291994198883744468744005470409078245893996153539802601598737060687483733389757045235896095957400266180075500992364021539221917108997307230046574125251952304461637030186471062562619523234193692618585774925525419040975961516212188872188853608468781398148788251249659314242448691451141375364682157224189761502490697285106725955016342688708103583146450318454637473677756848148946111691551396903396081866701675441083001752543398185132497315372365608059051895513314949579e-01)}},
                                                              {{SC_(1.42533302307128906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.89438855795183886998786581200513329076368840639634376361595786937211016205369393880525718435864806301335301282401183701106479251675469255403508578069217193848364943684508111845954935570776509998533134936283124529539828304501881046070786528700113675273503484680453633403668330643191207048485739965410736246347483019206275407836155671132435908585093633309518491565179092602495042637961696521026914991832196243209106071985665397845319941148355665755209958322775690891457420342651185239844150245596327947e-01), SC_(1.44950855957173654196257134824365513134133201450079523719697853158105525996193537681649106974620513605006455769791009116959886538550266029282692875824056064287247623191024923923550064333536271085049062725464192365631526069063550184078248236006479591026443959058514786355465785459602357875413912538891346259989738066918341767850367928358981037418135328507988540823626368932440669322691107028465730644797892733370773348508342557416764628129238249741504704236947393363136868043895800163017362575013961290e-01)}},
                                                              {{SC_(1.43252611160278320312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.90455894212278646682286952361698360750484925762077663955915415425200092204173679261660060857165366316201501332320971411870372367383031067911179925113944816094496441312871796921361407697738122633941915991825088653087265030078891572812182705223138859284267087996754061967690677246219005138926423479120522417515704205304515586665318577648865337189846259000229102696099755825093328193052696327092303622758297319344389570129955773532709225183232222424041153368966111478547808896921857325177982548718771158e-01), SC_(1.37830046144356675250872410437156137418445970379445568874986063770412578264945685021936472202077012022182697513678356960442192390943674941380077529122281760664567764993131196070130465793335691254056246930897428264833632852315773233778709341455031931560142964240737564638602823711734409767185825071947764997918950296406844128918029320519728667997040516955426962206122258344354400413540432792749979019261016751931226200374985412506207323213643522455191228802651442335019461635933485240885233775534028203e-01)}},
                                                              {{SC_(1.43575048446655273437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.90895160230121997702288446855581405901760081230384889585645562104421752177021923047531084568450326893227703184655477128300485696702546084083636117118819135371141893757016403129691943032247687888381242423926955796509656359721022387715707166150977984559307365089946156361069068208284576434164645941608103890018860366873703274312413864716472668931881280938821103122161489441182439131879713935704611483556687225869596341238675045956872266915280113063921753191332747400724156543076912116754374874750054973e-01), SC_(1.34635736090091818094528204085818356101807997017845390670155478403606606771620855953189545331098032529074637876125914631803457218671363025531396769111554517612885738927295369006431968049166339715409645435369564404672125253442906034702151099344922917418994177825002810347017671706373141382337224796583178154615455960082217078332717493653904158690181583515356788176235405991881547549149452753027065371587653125663516719462714534171084475796198006533859917606833628107186105787809101967470779035305450920e-01)}},
                                                              {{SC_(1.43626022338867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.90963660568134094400971901498988905319554266361075315281949278115893947953256979043383147606632955045753627672782128846852191033978891970221149746867578886482678747387800642996493640522219736150214876489388752111581525484145661461989583738801301682758872224572425127995699599203450570258361503179471293916821074295053494693378034402025673654196231274987906991244583192913828304407994756526024395389425156962038699675288302931357316631745952940420722432935854198084810119889611812838202854327047087633e-01), SC_(1.34130620789601643297435177545524001954141391748474759563452684046937170171124919131936400073282912787645653259241880684313416126416211409025645824655684246053734081280628162746192535860988794701161895027084056830536993050641113632462258021194830151178607327486814897660784369677235245490434876385754524750500204601522349690543772219788636263128283700192373357633279535557585911804179534914355347076739942876595712160644569672695775037899587969833017668537631078189945084691339552998027255384326844140e-01)}},
                                                              {{SC_(1.43893671035766601562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.91319109575353827009524291495439092992609811853229821159166159151103901148532756099292375393658980856687146260362406220995470141661061317103167670220098478568248794744003136334741272352694999145446914008031920389605991216195136102162640563302102813627231858860137114375389133133397415527784515231042189322930600081954067068979704162550063898754530920501246869992971165629667699438110645545498170415962658239563515234890345521891246987256466209364284808469885035281015898704958784193974691004150021440e-01), SC_(1.31477842204409608143481604778289471096989432741883764052857915784986484318032634024067139351793577350976858922540277282623045875976061356613691647950469635616570216317069615463470059393814873032370292336786402935014974684094100738552918070641543653862350399204902298268031885011842932620245754790505398283832018177439959836755940979102516771954166434909998171784510426184975048758424286402781599100148540714546447711769856438806916702480649813828940835784901933444901276957152379932153447509228696137e-01)}},
                                                              {{SC_(1.43923854827880859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.91358749415694718375338446318520938245933399170216515550162277117477391720337296530042486538615494659392608853197762294151718033779623260069710976312896628717586901774481690096841376459649622902116531379807543817349138434425583628639937086422980602415256616704269488506418530308517347564085682123911519216119823363516075742620608973853091856105663492745369073548016404817781648983470056148620342542897508768583078218568602415975758720531150787539258203631976055122050762021258847803225815586413983594e-01), SC_(1.31178618520511210932639613646562667970910211143447525041763259377225077944033963198139901656474403253313311900854623885170093549689579895346253603161951404971637347127491269985682548787839965097189544180076866803717837988248791973444620625374673968739089275753356956276391050058192244847228373681483681343061322393838820468731882412707831450554284369063204798723878265096994905601911657910504170961317716023507473626505888920988030515505601969581368230219763312001217408116589019985350643427759453027e-01)}},
                                                              {{SC_(1.43961572647094726562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.91408156611675707296664656058223080152485128775574649173021236987320160261145962178762573763867204348773339812210608561100661146497081024184848594028960145235706699880715910562953861200253810695797510258001811213168246891397479444794767683027181509397456942656840768865307567123173491515632186886152415447993081560133963732169955082791633660308902637129969728163244325298495434764536351360777449422859214749223257906073184866030661311732376603554906787343524537507972606605117568102379976898997387556e-01), SC_(1.30804690297554290504989423846664214343871971288892730248455107330480322598111478527291294656586536354347060079501463191824637278899579789830724823242348033342333742371700916702509134210059650531852817443296827350488198919145626370767974551816464494406170646945206485942489762762056106891367852891043967425985347102892606683294114815073381752131566806564187749932742216915803605939012920924230774615714791230728265624437944193225253025470901610417643068522722728430878240416873384568643829313305535027e-01)}},
                                                              {{SC_(1.44733238220214843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.92388003924177313140090027971915918584257628279020219474834338435924744461556664826937218895846315344351959435620232974461413412660625327718605557450020435740353207685195892183491583378240589992265493490175020140561282535656023176931718779705642570303800362770035646009247080796429678251537352734587121374533778369237837973021704239350832647444669642055605296497584322482667084736622674001731471182384738548849145026540595340207684378319043448448375976983562094694763759141523233441297963867807173230e-01), SC_(1.23150516309867875989569500091859949538209314932271743672937839136536501764869171434751888595099441665884508703820137465595390996452770295560950163144838266096299820229745872851223264952301951583171652940286501789832523596307854150203819900567360148429999324024127583351335571985879527474760460123624195719269010080647337703374150788251690634185963743503086320018503677388753932389411896123706087229183305362380691808334014583261378865654194061555906317934047697173152604178316357472971054644931431007e-01)}},
                                                              {{SC_(1.44744920730590820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.92402384223882789932261167425343450246956345459586286370336167352566852171621116458593647705802173528121507646228587446217386261770854494486472079130461840033751569077191235116879649490897128782846926355137884452312288880211033422612152460072911482530288128569393084939527997746297498300862428618077679314338568003724382747131398401869970818675030832582905678960788419233415037831678397997028491476723422057386731673921794812002654045501668179874746043063590611649424932881749747850199999649458980332e-01), SC_(1.23034579638217625029872282272402437662093252013182327996821295956822978452419259217048913138605637521619464291253863182650817791682056273134695984571528196607840573470807701589977902167891230627949542905867599039057826790021360258199521140849548290900785404111420099350972186162756949436658730757354190824081339428667944721803530652607059601295242664233649552435918280060710052841718723858516493198074231988111624685499136821860174842545366428551676343529394855788994773464430657466696951765655081137e-01)}},
                                                              {{SC_(1.45154237747192382812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.92897670924410531455308403067195670028166438299545559217547024316039582474703048515572995385737263658775525140179896272492682727904755237837950242303032893320399392340524679763156054755798499200503708258833780300903783645433313620255464751916379090634079587697883676031786033937972412617753201880865592252516901165029948342610525988212251655766536877387133775131843264659894018569911003548054019687818715867363301061741589797231839706403520055095055989644698443913520699876764791371583654897816260752e-01), SC_(1.18971488487288304308425699210614719866878259676804804262846896571022601257545817282175995659728561527339387857587830788109332577117011986425932901344366978967352649545020809657624889841948708848929261420409010627364470837074847218316673600693253526576654165766705835056357817622597952581949808041989979706804283927703846598812892491431255024889245682296352331155850394323676087358406346137369111543419082047067595620398532071247556766820276593583587556123889897153525352863626314107635487884572998426e-01)}},
                                                              {{SC_(1.45330142974853515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.93105411740343505979941692065212954734817555914074650281588114038233678075276394011281531825927323565721676809068049180242769051762192574807268658746464170597014860395374014702172519273733548176632886082595693891351425720343131787988496468579795432317171238483180139422234210372749213206588283534233831908394582654231750575686783875745511809042593129988278841999995524050769441525637738892576778838033277871692659550467516595634343802643379683228631743812937611330519329616827468576341825528132052336e-01), SC_(1.17224746414922113394680459621138654141515011468565470547501509905431672693738276955358228769564509462137569555299014927161641678112156176912374444048091919642849459540872135016797222796525448414106745029017241368167842038210883973473987358596838846975718240227122399101468532167473154373896203436806908913091121947162452896071564092737961908660984482393247148789843287711178022307994232547371668339453767902590820307947458700379454535785143261333718503831510741892113212862974188905351819040231571308e-01)}},
                                                              {{SC_(1.45588922500610351562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.93405439789757141275202601364355779502679848734651978182155130072168276482638826307412791668860025733070999061755033321901886773799227371917222595289420747085427784871438532344797731199223428339013161791677570085265437560296083277340845904465956638418345392999864987861028929290148714050330685270670948455026609008733297837390643273232248915759554146794901132364794027334453505635161634851655441841286677285556554929761224110017992819251284010541747937525942378738773667656679523684139733660561250454e-01), SC_(1.14654403300175083648655241424713554876591410670899082802706257994408600890374804156744972009245333224858858840058865138728143319116190374735741716940083629338564479621306357085959924901450353848857626798452776676039763227965830495379918013430493486371677347432381790712020223595336542260879737099747022574632060518401383064409905884124848180841992448644395615313940886011062062975865185967646280984788987330078321682531189251440331206378939892631509660362968636990584420084242504975617656278628117103e-01)}},
                                                              {{SC_(1.47166442871093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.95090455929404666006154823168144087189140053255522339316806520598490841109867383633977530535018659423876097071858161130203706649002027525940404478895698367390354260462433431675488818940998152329248038804193093807009906773861589081969360477762624353775906996639062265252175967961550873009581733911335420867297760020697540822045266366770530036973389680212375467050585559942092343814379574239413774425890235854531425676118483749702011351971360190721833433641572164265515387155347107711295271352712743920e-01), SC_(9.89696141156948746533779105739509719701859485070413706167484933115112066336174440361597142496460529005477561627345324008350535949128391226579786599207708363053074301827988346459788334279429737675780235245888898300686596905930790877873637403683928778470682731019204053504784430768910655143803501705308467894729067255148499639765331390047487792750517217890381326189053380138858456505067986074977471820348175139209916889960977991394445595370464003745273811411030937898173471905892363724061478289793119348e-02)}},
                                                              {{SC_(1.48118925094604492187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.95987971581469849835212192761387433880948032799743403113405841762301737272660663272771126085311509092947080459948251558013435279217583393463811660766402644800234944489251699740786371879736855583038422681603128446143622034878159613520219538075200024898473039195144740678733899601210689307500632218154184430050627947647985952105033868309795151096435214211084770689499068527480958647335117598393401054903120640089430217860460804499994297927249386845726766898814799195449319720578659538420256997308211025e-01), SC_(8.94872083877310745992995729453189430370374216494843644464203198739023378590658969785214597002302119076433271051158949450602535037208901054605904460051131565768944344714994340047575313236362345896146244898245040780545731961335279415963661509788420847604974741441811091560365159585870007428861114817117469981394171402847618853548699252957873293345224676542413493010857730777156556972874471318434497632251719969283577188808589709859828953081848004422162716626512357272747440738023351312980295536798316922e-02)}},
                                                              {{SC_(1.48278236389160156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.96129270838430119300051168101128018381711663975084689464093791562764752253731121972874715487882382751179770152493027118683467727036964708520634542103501485669757146226438488081878080926649554606187846378195600014774584360969390987124603322695895627803222154125777080064227842041901715773894330691637378759131986041012989252185848914840073182305921568081447589877312031877944980532384362610432698158884417534261275444275397015596380868316425733585342742440883714085896222445321624407650811982586296636e-01), SC_(8.79003741681315821251280686027308782114586877469765715995387548225892541129646634622181193716483073221684877664769071763743258458728042536681305436365814040903460426066931360249824421763839424383563759428429066149167258244393099606620797760427563923085307430292326673397490669016001630596625436022406452453276617767081117940821836317631747493227941287539612890181193545073004560915169680617098938412078376539261936819313380292445951887013297284686257609312633392205252300434267806647195017089621710655e-02)}},
                                                              {{SC_(1.48932170867919921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.96682778918135881536275990842605733339523038813167252150321614421595525838928211021490885982758765990951313520268744178158346030034831122597669741414660123131649499595170494000918804089933602318505074023337014767210419674606196522230870351450346722685462669386186899171200820043924773724372012377225749522475547961748742969344987224598725348359245989549214445144233239343849591742100654576204916431612729728023490540829084798820588062343315674262313864097725179428828982666540343368732780105039454552e-01), SC_(8.13845084031492640613386104575625537797314524719600723400961398682265346258342553800702435865044529994514493269349360241716452021150170976184564475930349320327294213744778471680231255567737036617811154621323506663548592662785646800499829866106486293702489790533055529549635178889628268927391706714202367178496631902276183977618547547514283224465880040875138298723442763757980830113435205370560834162520016704500157651115626101042762031082967251945734212875798186029500136459910061696644610683824984172e-02)}},
                                                              {{SC_(1.49110269546508789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.96826142879974523863831045963884109600409432642463162064145662688965036053042311506387703651817442121009205293172616437818555258112251730073632334612968938357736365937318953971797778938245108123188897428261195201653763029717278994009284610609918683798387178776970008741366601835926335083641809206050796411321487406184056687220549994528554465293966740994858430339601520279341278775826310640952951225475713531037110335618328239225533137083081585843611982466861028545104133721132301207113669094208158152e-01), SC_(7.96093014102787857311853897169714896003178997833084509746261920212282904923245728708338229611953838785802609515963050682205601178649541846223606669995712553087046533525243208438038611435636700879519384389078441175165514979582616566905525683674375742838422423588917802839236707296641241280017877960271241566981191179744385341858916524101345194801390243168621344421220012275921118083354308199733352187061121123492182523906644632947523518443805234926530481306985017526225224799204564632165926385889633624e-02)}},
                                                              {{SC_(1.49469184875488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), SC_(9.97105451691637836980566977886191495470310625478984302514468734081978317004712365179572388160094873766545892259684126612171730371334431713402903857531243843855031719141960805464286066705907297221591074259625271788178601626673326754719816154765918422856170761025895221537060495081964634143881365727528637573199554544101393148199185537988251924073321046398397270592899501388280072694753480150196648362062195285790390273399747995245778399713979670854796624214784952767383795902013605892666997263955330095e-01), SC_(7.60310344978606994311454252807960986535803469428379193529425796476644344334413001865738243975566508261589698713562091901145249736705485695273728137391377751615494502695150924195446763383201607951069471691560757133118887684442353070862022248337360915742210326532477359739395822627983312298986859616214217003217070111399151039551118513567199164797534425187953687276545896053419230138261452230491054544837629498576689887971671483487696900902095055042924520918068327882892863731988941436799798706418513466e-02)}}}};
//#undef SC_


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/skeleton_backend.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MATH_SKELETON_BACKEND_HPP
#define BOOST_MATH_SKELETON_BACKEND_HPP

#include <boost/multiprecision/number.hpp>
#include <boost/container_hash/hash.hpp>

namespace boost {
namespace multiprecision {
namespace backends {

/*
This header defines one type - skeleton_backend - which declares the minimal
interface to qualify as a backend for class number.  In addition you'll find
optional interfaces declared commented out - you can enable these or not as
needed.

The process of writing a new backend for class number then reduces to a search
and replace to change the name of this class to something meaningful, followed
by "filling in the blanks" of each of the methods.

NOTE: all of the methods shown below are simple declarations, be sure to make them
inline, constexpr and/or noexcept as appropriate - as these annotations propogate
upwards to operations on number<>'s.

If the backend is to be itself a template, thn you will have rather more editing to
do to add all the "template<...>" prefixes to the functions.

*/


struct skeleton_backend
{
   //
   // Each backend need to declare 3 type lists which declare the types
   // with which this can interoperate.  These lists must at least contain
   // the widest type in each category - so "long long" must be the final
   // type in the signed_types list for example.  Any narrower types if not
   // present in the list will get promoted to the next wider type that is
   // in the list whenever mixed arithmetic involving that type is encountered.
   //
   typedef std::tuple</*signed char, short, int, long,*/ long long>                                     signed_types;
   typedef std::tuple</* unsigned char, unsigned short, unsigned, unsigned long,*/ unsigned long long>  unsigned_types;
   typedef std::tuple</*float, double,*/ long double>                                                   float_types;
   //
   // This typedef is only required if this is a floating point type, it is the type
   // which holds the exponent:
   //
   typedef int                                                         exponent_type;

   // We must have a default constructor:
   skeleton_backend();
   skeleton_backend(const skeleton_backend& o);
   skeleton_backend(skeleton_backend&& o);

   // Optional constructors, we can make this type slightly more efficient
   // by providing constructors from any type we can handle natively.
   // These will also cause number<> to be implicitly constructible
   // from these types unless we make such constructors explicit.
   //
   // skeleton_backend(int o);  // If there's an efficient initialisation from int for example.

   //
   // In the absense of converting constructors, operator= takes the strain.
   // In addition to the usual suspects, there must be one operator= for each type
   // listed in signed_types, unsigned_types, and float_types plus a string constructor.
   //
   skeleton_backend& operator=(const skeleton_backend& o);
   skeleton_backend& operator=(skeleton_backend&& o);
   skeleton_backend& operator=(unsigned long long i);
   skeleton_backend& operator=(long long i);
   skeleton_backend& operator=(long double i);
   skeleton_backend& operator=(const char* s);

   void swap(skeleton_backend& o);
   std::string str(std::streamsize digits, std::ios_base::fmtflags f) const;
   void        negate();
   int         compare(const skeleton_backend& o) const;
   //
   // Comparison with arithmetic types, default just constructs a temporary:
   //
   template <class A>
   typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, int>::type compare(A i) const
   {
      skeleton_backend t;
      t = i;  //  Note: construct directly from i if supported.
      return compare(t);
   }
};

//
// Required non-members:
//
void eval_add(skeleton_backend& a, const skeleton_backend& b);
void eval_subtract(skeleton_backend& a, const skeleton_backend& b);
void eval_multiply(skeleton_backend& a, const skeleton_backend& b);
void eval_divide(skeleton_backend& a, const skeleton_backend& b);
//
// Required only for integer types:
//
void eval_modulus(skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_and(skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_or(skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_xor(skeleton_backend& a, const skeleton_backend& b);
void eval_complement(skeleton_backend& a, const skeleton_backend& b);
void eval_left_shift(skeleton_backend& a, unsigned shift);
void eval_right_shift(skeleton_backend& a, unsigned shift);
//
// Conversions: must include at least unsigned long long, long long and long double.
// Everything else is entirely optional:
//
void eval_convert_to(unsigned long long* result, const skeleton_backend& backend);
void eval_convert_to(long long* result, const skeleton_backend& backend);
void eval_convert_to(long double* result, const skeleton_backend& backend);

//void eval_convert_to(unsigned long* result, const skeleton_backend& backend);
//void eval_convert_to(unsigned* result, const skeleton_backend& backend);
//void eval_convert_to(unsigned short* result, const skeleton_backend& backend);
//void eval_convert_to(unsigned char* result, const skeleton_backend& backend);

//void eval_convert_to(char* result, const skeleton_backend& backend);

//void eval_convert_to(long* result, const skeleton_backend& backend);
//void eval_convert_to(int* result, const skeleton_backend& backend);
//void eval_convert_to(short* result, const skeleton_backend& backend);
//void eval_convert_to(signed char* result, const skeleton_backend& backend);

//void eval_convert_to(double* result, const skeleton_backend& backend);
//void eval_convert_to(float* result, const skeleton_backend& backend);

//
// Operations which are required *only* if we have a floating point type:
//
void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type* p_exponent);
void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, int* p_exponent);  // throws a runtime_error if the exponent is too large for an int
void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type exponent);
void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, int exponent);
void eval_floor(skeleton_backend& result, const skeleton_backend& arg);
void eval_ceil(skeleton_backend& result, const skeleton_backend& arg);
void eval_sqrt(skeleton_backend& result, const skeleton_backend& arg);
//
// Operations defined *only* if we have a complex number type, type
// skeleton_real_type is assumed to be the real number type matching
// this type.
//
void eval_conj(skeleton_backend& result, const skeleton_backend& arg);
void eval_proj(skeleton_backend& result, const skeleton_backend& arg);
//void eval_real(skeleton_real_type& result, const skeleton_backend& arg);
//void eval_set_real(skeleton_real_type& result, const skeleton_backend& arg);
//void eval_imag(skeleton_real_type& result, const skeleton_backend& arg);
//void eval_set_real(skeleton_type& result, const skeleton_real_type& arg);
//void eval_set_imag(skeleton_type& result, const skeleton_real_type& arg);

//
// Hashing support, not strictly required, but it is used in our tests:
//
std::size_t hash_value(const skeleton_backend& arg);
//
// We're now into strictly optional requirements, everything that follows is
// nice to have, but can be synthesised from the operators above if required.
// Typically these operations are here to improve performance and reduce the
// number of temporaries created.
//
// assign_components: required number types with 2 seperate components (rationals and complex numbers).
// Type skeleton_component_type is whatever the corresponding backend type for the components is:
//
//void assign_conponents(skeleton_backend& result, skeleton_component_type const& a, skeleton_component_type const& b);
//
// Again for arithmetic types, overload for whatever arithmetic types are directly supported:
//
//void assign_conponents(skeleton_backend& result, double a, double b);
//
// Optional comparison operators:
//
#if 0

bool eval_is_zero(const skeleton_backend& arg);
int eval_get_sign(const skeleton_backend& arg);

bool eval_eq(const skeleton_backend& a, const skeleton_backend& b);
bool eval_eq(const skeleton_backend& a, unsigned long long b);
bool eval_eq(const skeleton_backend& a, unsigned long b);
bool eval_eq(const skeleton_backend& a, unsigned b);
bool eval_eq(const skeleton_backend& a, unsigned short b);
bool eval_eq(const skeleton_backend& a, unsigned char b);
bool eval_eq(const skeleton_backend& a, long long b);
bool eval_eq(const skeleton_backend& a, long b);
bool eval_eq(const skeleton_backend& a, int b);
bool eval_eq(const skeleton_backend& a, short b);
bool eval_eq(const skeleton_backend& a, signed char b);
bool eval_eq(const skeleton_backend& a, char b);
bool eval_eq(const skeleton_backend& a, long double b);
bool eval_eq(const skeleton_backend& a, double b);
bool eval_eq(const skeleton_backend& a, float b);

bool eval_eq(unsigned long long a, const skeleton_backend& b);
bool eval_eq(unsigned long a, const skeleton_backend& b);
bool eval_eq(unsigned a, const skeleton_backend& b);
bool eval_eq(unsigned short a, const skeleton_backend& b);
bool eval_eq(unsigned char a, const skeleton_backend& b);
bool eval_eq(long long a, const skeleton_backend& b);
bool eval_eq(long a, const skeleton_backend& b);
bool eval_eq(int a, const skeleton_backend& b);
bool eval_eq(short a, const skeleton_backend& b);
bool eval_eq(signed char a, const skeleton_backend& b);
bool eval_eq(char a, const skeleton_backend& b);
bool eval_eq(long double a, const skeleton_backend& b);
bool eval_eq(double a, const skeleton_backend& b);
bool eval_eq(float a, const skeleton_backend& b);

bool eval_lt(const skeleton_backend& a, const skeleton_backend& b);
bool eval_lt(const skeleton_backend& a, unsigned long long b);
bool eval_lt(const skeleton_backend& a, unsigned long b);
bool eval_lt(const skeleton_backend& a, unsigned b);
bool eval_lt(const skeleton_backend& a, unsigned short b);
bool eval_lt(const skeleton_backend& a, unsigned char b);
bool eval_lt(const skeleton_backend& a, long long b);
bool eval_lt(const skeleton_backend& a, long b);
bool eval_lt(const skeleton_backend& a, int b);
bool eval_lt(const skeleton_backend& a, short b);
bool eval_lt(const skeleton_backend& a, signed char b);
bool eval_lt(const skeleton_backend& a, char b);
bool eval_lt(const skeleton_backend& a, long double b);
bool eval_lt(const skeleton_backend& a, double b);
bool eval_lt(const skeleton_backend& a, float b);

bool eval_lt(unsigned long long a, const skeleton_backend& b);
bool eval_lt(unsigned long a, const skeleton_backend& b);
bool eval_lt(unsigned a, const skeleton_backend& b);
bool eval_lt(unsigned short a, const skeleton_backend& b);
bool eval_lt(unsigned char a, const skeleton_backend& b);
bool eval_lt(long long a, const skeleton_backend& b);
bool eval_lt(long a, const skeleton_backend& b);
bool eval_lt(int a, const skeleton_backend& b);
bool eval_lt(short a, const skeleton_backend& b);
bool eval_lt(signed char a, const skeleton_backend& b);
bool eval_lt(char a, const skeleton_backend& b);
bool eval_lt(long double a, const skeleton_backend& b);
bool eval_lt(double a, const skeleton_backend& b);
bool eval_lt(float a, const skeleton_backend& b);

bool eval_gt(const skeleton_backend& a, const skeleton_backend& b);
bool eval_gt(const skeleton_backend& a, unsigned long long b);
bool eval_gt(const skeleton_backend& a, unsigned long b);
bool eval_gt(const skeleton_backend& a, unsigned b);
bool eval_gt(const skeleton_backend& a, unsigned short b);
bool eval_gt(const skeleton_backend& a, unsigned char b);
bool eval_gt(const skeleton_backend& a, long long b);
bool eval_gt(const skeleton_backend& a, long b);
bool eval_gt(const skeleton_backend& a, int b);
bool eval_gt(const skeleton_backend& a, short b);
bool eval_gt(const skeleton_backend& a, signed char b);
bool eval_gt(const skeleton_backend& a, char b);
bool eval_gt(const skeleton_backend& a, long double b);
bool eval_gt(const skeleton_backend& a, double b);
bool eval_gt(const skeleton_backend& a, float b);

bool eval_gt(unsigned long long a, const skeleton_backend& b);
bool eval_gt(unsigned long a, const skeleton_backend& b);
bool eval_gt(unsigned a, const skeleton_backend& b);
bool eval_gt(unsigned short a, const skeleton_backend& b);
bool eval_gt(unsigned char a, const skeleton_backend& b);
bool eval_gt(long long a, const skeleton_backend& b);
bool eval_gt(long a, const skeleton_backend& b);
bool eval_gt(int a, const skeleton_backend& b);
bool eval_gt(short a, const skeleton_backend& b);
bool eval_gt(signed char a, const skeleton_backend& b);
bool eval_gt(char a, const skeleton_backend& b);
bool eval_gt(long double a, const skeleton_backend& b);
bool eval_gt(double a, const skeleton_backend& b);
bool eval_gt(float a, const skeleton_backend& b);
#endif

//
// Arithmetic operations, starting with addition:
//
#if 0
void eval_add(skeleton_backend& result, unsigned long long arg);
void eval_add(skeleton_backend& result, unsigned long arg);
void eval_add(skeleton_backend& result, unsigned arg);
void eval_add(skeleton_backend& result, unsigned short arg);
void eval_add(skeleton_backend& result, unsigned char arg);
void eval_add(skeleton_backend& result, char arg);
void eval_add(skeleton_backend& result, long long arg);
void eval_add(skeleton_backend& result, long arg);
void eval_add(skeleton_backend& result, int arg);
void eval_add(skeleton_backend& result, short arg);
void eval_add(skeleton_backend& result, signed char arg);
void eval_add(skeleton_backend& result, long double arg);
void eval_add(skeleton_backend& result, double arg);
void eval_add(skeleton_backend& result, float arg);

void eval_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_add(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_add(skeleton_backend& result, float b, const skeleton_backend& a);
#endif

//
// Subtraction:
//
#if 0
void eval_subtract(skeleton_backend& result, unsigned long long arg);
void eval_subtract(skeleton_backend& result, unsigned long arg);
void eval_subtract(skeleton_backend& result, unsigned arg);
void eval_subtract(skeleton_backend& result, unsigned short arg);
void eval_subtract(skeleton_backend& result, unsigned char arg);
void eval_subtract(skeleton_backend& result, char arg);
void eval_subtract(skeleton_backend& result, long long arg);
void eval_subtract(skeleton_backend& result, long arg);
void eval_subtract(skeleton_backend& result, int arg);
void eval_subtract(skeleton_backend& result, short arg);
void eval_subtract(skeleton_backend& result, signed char arg);
void eval_subtract(skeleton_backend& result, long double arg);
void eval_subtract(skeleton_backend& result, double arg);
void eval_subtract(skeleton_backend& result, float arg);

void eval_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_subtract(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_subtract(skeleton_backend& result, float b, const skeleton_backend& a);
#endif

//
// Multiplication:
//
#if 0
void eval_multiply(skeleton_backend& result, unsigned long long arg);
void eval_multiply(skeleton_backend& result, unsigned long arg);
void eval_multiply(skeleton_backend& result, unsigned arg);
void eval_multiply(skeleton_backend& result, unsigned short arg);
void eval_multiply(skeleton_backend& result, unsigned char arg);
void eval_multiply(skeleton_backend& result, char arg);
void eval_multiply(skeleton_backend& result, long long arg);
void eval_multiply(skeleton_backend& result, long arg);
void eval_multiply(skeleton_backend& result, int arg);
void eval_multiply(skeleton_backend& result, short arg);
void eval_multiply(skeleton_backend& result, signed char arg);
void eval_multiply(skeleton_backend& result, long double arg);
void eval_multiply(skeleton_backend& result, double arg);
void eval_multiply(skeleton_backend& result, float arg);

void eval_multiply(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_multiply(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_multiply(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_multiply(skeleton_backend& result, float b, const skeleton_backend& a);
#endif

//
// Division:
//
#if 0
void eval_divide(skeleton_backend& result, unsigned long long arg);
void eval_divide(skeleton_backend& result, unsigned long arg);
void eval_divide(skeleton_backend& result, unsigned arg);
void eval_divide(skeleton_backend& result, unsigned short arg);
void eval_divide(skeleton_backend& result, unsigned char arg);
void eval_divide(skeleton_backend& result, char arg);
void eval_divide(skeleton_backend& result, long long arg);
void eval_divide(skeleton_backend& result, long arg);
void eval_divide(skeleton_backend& result, int arg);
void eval_divide(skeleton_backend& result, short arg);
void eval_divide(skeleton_backend& result, signed char arg);
void eval_divide(skeleton_backend& result, long double arg);
void eval_divide(skeleton_backend& result, double arg);
void eval_divide(skeleton_backend& result, float arg);

void eval_divide(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_divide(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_divide(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_divide(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// Multiply and add/subtract as one:
//
#if 0
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_multiply_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_multiply_add(skeleton_backend& result, float b, const skeleton_backend& a);

void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_multiply_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_multiply_subtract(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// Increment and decrement:
//
//void eval_increment(skeleton_backend& arg);
//void eval_decrement(skeleton_backend& arg);
//
// abs/fabs:
//
// void eval_abs(skeleton_backend& result, const skeleton_backend& arg);
// void eval_fabs(skeleton_backend& result, const skeleton_backend& arg);
//


//
// Now operations on Integer types, starting with modulus:
//
#if 0
void eval_modulus(skeleton_backend& result, unsigned long long arg);
void eval_modulus(skeleton_backend& result, unsigned long arg);
void eval_modulus(skeleton_backend& result, unsigned arg);
void eval_modulus(skeleton_backend& result, unsigned short arg);
void eval_modulus(skeleton_backend& result, unsigned char arg);
void eval_modulus(skeleton_backend& result, char arg);
void eval_modulus(skeleton_backend& result, long long arg);
void eval_modulus(skeleton_backend& result, long arg);
void eval_modulus(skeleton_backend& result, int arg);
void eval_modulus(skeleton_backend& result, short arg);
void eval_modulus(skeleton_backend& result, signed char arg);
void eval_modulus(skeleton_backend& result, long double arg);
void eval_modulus(skeleton_backend& result, double arg);
void eval_modulus(skeleton_backend& result, float arg);

void eval_modulus(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_modulus(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_modulus(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_modulus(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// bitwise AND:
//
#if 0
void eval_bitwise_and(skeleton_backend& result, unsigned long long arg);
void eval_bitwise_and(skeleton_backend& result, unsigned long arg);
void eval_bitwise_and(skeleton_backend& result, unsigned arg);
void eval_bitwise_and(skeleton_backend& result, unsigned short arg);
void eval_bitwise_and(skeleton_backend& result, unsigned char arg);
void eval_bitwise_and(skeleton_backend& result, char arg);
void eval_bitwise_and(skeleton_backend& result, long long arg);
void eval_bitwise_and(skeleton_backend& result, long arg);
void eval_bitwise_and(skeleton_backend& result, int arg);
void eval_bitwise_and(skeleton_backend& result, short arg);
void eval_bitwise_and(skeleton_backend& result, signed char arg);
void eval_bitwise_and(skeleton_backend& result, long double arg);
void eval_bitwise_and(skeleton_backend& result, double arg);
void eval_bitwise_and(skeleton_backend& result, float arg);

void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_bitwise_and(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_bitwise_and(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// bitwise OR:
//
#if 0
void eval_bitwise_or(skeleton_backend& result, unsigned long long arg);
void eval_bitwise_or(skeleton_backend& result, unsigned long arg);
void eval_bitwise_or(skeleton_backend& result, unsigned arg);
void eval_bitwise_or(skeleton_backend& result, unsigned short arg);
void eval_bitwise_or(skeleton_backend& result, unsigned char arg);
void eval_bitwise_or(skeleton_backend& result, char arg);
void eval_bitwise_or(skeleton_backend& result, long long arg);
void eval_bitwise_or(skeleton_backend& result, long arg);
void eval_bitwise_or(skeleton_backend& result, int arg);
void eval_bitwise_or(skeleton_backend& result, short arg);
void eval_bitwise_or(skeleton_backend& result, signed char arg);
void eval_bitwise_or(skeleton_backend& result, long double arg);
void eval_bitwise_or(skeleton_backend& result, double arg);
void eval_bitwise_or(skeleton_backend& result, float arg);

void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_bitwise_or(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_bitwise_or(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// bitwise XOR:
//
#if 0
void eval_bitwise_xor(skeleton_backend& result, unsigned long long arg);
void eval_bitwise_xor(skeleton_backend& result, unsigned long arg);
void eval_bitwise_xor(skeleton_backend& result, unsigned arg);
void eval_bitwise_xor(skeleton_backend& result, unsigned short arg);
void eval_bitwise_xor(skeleton_backend& result, unsigned char arg);
void eval_bitwise_xor(skeleton_backend& result, char arg);
void eval_bitwise_xor(skeleton_backend& result, long long arg);
void eval_bitwise_xor(skeleton_backend& result, long arg);
void eval_bitwise_xor(skeleton_backend& result, int arg);
void eval_bitwise_xor(skeleton_backend& result, short arg);
void eval_bitwise_xor(skeleton_backend& result, signed char arg);
void eval_bitwise_xor(skeleton_backend& result, long double arg);
void eval_bitwise_xor(skeleton_backend& result, double arg);
void eval_bitwise_xor(skeleton_backend& result, float arg);

void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, float b);

void eval_bitwise_xor(skeleton_backend& result, unsigned long long b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, unsigned long b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, unsigned b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, unsigned short b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, unsigned char b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, long long b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, long b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, int b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, short b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, signed char b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, char b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, long double b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, double b, const skeleton_backend& a);
void eval_bitwise_xor(skeleton_backend& result, float b, const skeleton_backend& a);
#endif
//
// left and right shift:
//
//void eval_left_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift);
//void eval_right_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift);
//
// Quotient and remainder:
//
// void eval_qr(const skeleton_backend& numerator, const skeleton_backend& denominator, skeleton_backend& quotient, skeleteon_backend& remainder);
//
// Misc integer ops:
//
// unsigned long long eval_integer_modulus(const skeleton_backend& arg, unsigned long long modulus);
// unsigned long eval_integer_modulus(const skeleton_backend& arg, unsigned long modulus);
// unsigned eval_integer_modulus(const skeleton_backend& arg, unsigned modulus);
// unsigned short eval_integer_modulus(const skeleton_backend& arg, unsigned short modulus);
// unsigned char eval_integer_modulus(const skeleton_backend& arg, unsigned char modulus);
//
// std::size_t  eval_lsb(const skeleton_backend& arg);
// std::size_t  eval_msb(const skeleton_backend& arg);
// bool  eval_bit_test(const skeleton_backend& arg, std::size_t bit);
// void  eval_bit_set(const skeleton_backend& arg, std::size_t bit);
// void  eval_bit_unset(const skeleton_backend& arg, std::size_t bit);
// void  eval_bit_flip(const skeleton_backend& arg, std::size_t bit);
//
// GCD/LCD:
//
#if 0
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_gcd(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_gcd(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, signed char a, const skeleton_backend& b);
void eval_gcd(skeleton_backend& result, char a, const skeleton_backend& b);

void eval_lcm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_lcm(skeleton_backend& result, const skeleton_backend& a, char b);
void eval_lcm(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, signed char a, const skeleton_backend& b);
void eval_lcm(skeleton_backend& result, char a, const skeleton_backend& b);
#endif
//
// Modular exponentiation:
//
#if 0
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, const skeleton_backend& c);  // a^b % c
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned short c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned char c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, short c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, signed char c);

void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, const skeleton_backend& c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, const skeleton_backend& c);

void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, unsigned long long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, unsigned long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, unsigned c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, unsigned short c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, unsigned char c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, long long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, long c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, int c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, short c);
void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, signed char c);
#endif
//
// Integer sqrt:
//
// void eval_integer_sqrt(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend& remainder);

/*********************************************************************************************

     FLOATING POINT FUNCTIONS

***********************************************************************************************/

#if 0

int eval_fpclassify(const skeleton_backend& arg);
void eval_trunc(skeleton_backend& result, const skeleton_backend& arg);
void eval_round(skeleton_backend& result, const skeleton_backend& arg);
void eval_exp(skeleton_backend& result, const skeleton_backend& arg);
void eval_exp2(skeleton_backend& result, const skeleton_backend& arg);
void eval_log(skeleton_backend& result, const skeleton_backend& arg);
void eval_log10(skeleton_backend& result, const skeleton_backend& arg);
void eval_sin(skeleton_backend& result, const skeleton_backend& arg);
void eval_cos(skeleton_backend& result, const skeleton_backend& arg);
void eval_tan(skeleton_backend& result, const skeleton_backend& arg);
void eval_asin(skeleton_backend& result, const skeleton_backend& arg);
void eval_acos(skeleton_backend& result, const skeleton_backend& arg);
void eval_atan(skeleton_backend& result, const skeleton_backend& arg);
void eval_sinh(skeleton_backend& result, const skeleton_backend& arg);
void eval_cosh(skeleton_backend& result, const skeleton_backend& arg);
void eval_tanh(skeleton_backend& result, const skeleton_backend& arg);
void eval_asinh(skeleton_backend& result, const skeleton_backend& arg);
void eval_acosh(skeleton_backend& result, const skeleton_backend& arg);
void eval_atanh(skeleton_backend& result, const skeleton_backend& arg);
void eval_fmod(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_modf(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_pow(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_atan2(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_scalbn(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e);
void eval_scalbln(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e);
skeleton_type::exponent_type eval_ilogb(const skeleton_backend& arg);

void eval_remquo(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned short b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned char b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long long b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, int b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, short b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, signed char b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long double b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, double b, int* p_n);
void eval_remquo(skeleton_backend& result, const skeleton_backend& a, float b, int* p_n);
void eval_remquo(skeleton_backend& result, unsigned long long a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, unsigned long a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, unsigned a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, unsigned short a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, unsigned char a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, long long a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, long a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, int a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, short a, const skeleton_backend& b, int* p_n);
void eval_remquo(skeleton_backend& result, signed char a, const skeleton_backend& b, int* p_n);

void eval_remainder(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_remainder(skeleton_backend& result, const skeleton_backend& a, float b);
void eval_remainder(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_remainder(skeleton_backend& result, signed char a, const skeleton_backend& b);

void eval_fdim(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_fdim(skeleton_backend& result, const skeleton_backend& a, float b);
void eval_fdim(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_fdim(skeleton_backend& result, signed char a, const skeleton_backend& b);

void eval_fmax(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_fmax(skeleton_backend& result, const skeleton_backend& a, float b);
void eval_fmax(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_fmax(skeleton_backend& result, signed char a, const skeleton_backend& b);

void eval_fmin(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_fmin(skeleton_backend& result, const skeleton_backend& a, float b);
void eval_fmin(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_fmin(skeleton_backend& result, signed char a, const skeleton_backend& b);

void eval_hypot(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long long b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned short b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned char b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long long b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, int b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, short b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, signed char b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long double b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, double b);
void eval_hypot(skeleton_backend& result, const skeleton_backend& a, float b);
void eval_hypot(skeleton_backend& result, unsigned long long a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, unsigned long a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, unsigned a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, unsigned short a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, unsigned char a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, long long a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, long a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, int a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, short a, const skeleton_backend& b);
void eval_hypot(skeleton_backend& result, signed char a, const skeleton_backend& b);

void eval_logb(skeleton_backend& result, const skeleton_backend& arg);
void eval_nearbtint(skeleton_backend& result, const skeleton_backend& arg);
void eval_rint(skeleton_backend& result, const skeleton_backend& arg);
void eval_log2(skeleton_backend& result, const skeleton_backend& arg);
#endif


} // namespace backends

//
// Import the backend into this namespace:
//
using boost::multiprecision::backends::skeleton_backend;
//
// Typedef whatever number's make use of this backend:
//
typedef number<skeleton_backend, et_off> skeleton_number;
//
// Define a category for this number type, one of:
// 
//    number_kind_integer
//    number_kind_floating_point
//    number_kind_rational
//    number_kind_fixed_point
//    number_kind_complex
//
template<>
struct number_category<skeleton_backend > : public std::integral_constant<int, number_kind_floating_point>
{};

//
// These 2 traits classes are required for complex types only:
//
/*
template <expression_template_option ExpressionTemplates>
struct component_type<number<skeleton_backend, ExpressionTemplates> >
{
   typedef number<skeleton_real_type, ExpressionTemplates> type;
};

template <expression_template_option ExpressionTemplates>
struct complex_result_from_scalar<number<skeleton_real_type, ExpressionTemplates> >
{
   typedef number<skeleton_backend, ExpressionTemplates> type;
};
*/

/**************************************************************

OVERLOADABLE FUNCTIONS - FLOATING POINT TYPES ONLY

****************************************************************/

#if 0

template <boost::multiprecision::expression_template_option ExpressionTemplates>
int sign(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
int signbit(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> changesign(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> copysign(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b);

template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> cbrt(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> erf(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> erfc(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> expm1(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> log1p(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> tgamma(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> lgamma(const number<skeleton_backend, ExpressionTemplates>& arg);

template <boost::multiprecision::expression_template_option ExpressionTemplates>
long lrint(const number<skeleton_backend, ExpressionTemplates>& arg);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
long long llrint(const number<skeleton_backend, ExpressionTemplates>& arg);

template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> nextafter(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b);
template <boost::multiprecision::expression_template_option ExpressionTemplates>
number<skeleton_backend, ExpressionTemplates> nexttoward(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b);

#endif

}} // namespace boost::multiprecision

/**********************************************************************************

FLOATING POINT ONLY
Nice to have stuff for better integration with Boost.Math.

***********************************************************************************/

namespace boost {
namespace math {
namespace tools {

#if 0

template <>
int digits<boost::multiprecision::number<boost::multiprecision::skeleton_number> >();

template <>
boost::multiprecision::mpfr_float max_value<boost::multiprecision::skeleton_number>();

template <>
boost::multiprecision::mpfr_float min_value<boost::multiprecision::skeleton_number>();

#endif

} // namespace tools

namespace constants {
namespace detail {

#if 0
template <boost::multiprecision::expression_template_option ExpressionTemplates>
struct constant_pi<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> result_type;
   //
   // Fixed N-digit precision, return reference to internal/cached object:
   //
   template <int N>
   static inline const result_type& get(const std::integral_constant<int, N>&);
   //
   // Variable precision, returns fresh result each time (unless precision is unchanged from last call):
   //
   static inline const result_type  get(const std::integral_constant<int, 0>&);
};
//
// Plus any other constants supported natively by this type....
//
#endif

} // namespace detail
} // namespace constants

}} // namespace boost::math


namespace std {

template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> number_type;

 public:
   static constexpr bool is_specialized = true;
   static number_type(min)();
   static number_type(max)();
   static number_type lowest();
   static constexpr int                digits       = 0;
   static constexpr int                digits10     = 0;
   static constexpr int                max_digits10 = 0;
   static constexpr bool               is_signed    = false;
   static constexpr bool               is_integer   = false;
   static constexpr bool               is_exact     = false;
   static constexpr int                radix        = 2;
   static number_type                        epsilon();
   static number_type                        round_error();
   static constexpr int                min_exponent      = 0;
   static constexpr int                min_exponent10    = 0;
   static constexpr int                max_exponent      = 0;
   static constexpr int                max_exponent10    = 0;
   static constexpr bool               has_infinity      = false;
   static constexpr bool               has_quiet_NaN     = false;
   static constexpr bool               has_signaling_NaN = false;
   static constexpr float_denorm_style has_denorm        = denorm_absent;
   static constexpr bool               has_denorm_loss   = false;
   static number_type                        infinity();
   static number_type                        quiet_NaN();
   static number_type                        signaling_NaN();
   static number_type                        denorm_min();
   static constexpr bool               is_iec559       = false;
   static constexpr bool               is_bounded      = false;
   static constexpr bool               is_modulo       = false;
   static constexpr bool               traps           = false;
   static constexpr bool               tinyness_before = false;
   static constexpr float_round_style  round_style     = round_toward_zero;
};

template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_digits10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_signed;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_integer;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_exact;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::radix;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent10;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_infinity;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_quiet_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_signaling_NaN;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm_loss;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_iec559;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_bounded;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_modulo;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::traps;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::tinyness_before;
template <boost::multiprecision::expression_template_option ExpressionTemplates>
constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::round_style;

} // namespace std

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_constexpr_test_cpp_int.cpp
================================================
//  (C) Copyright John Maddock 2019 - 2021.
//  (C) Copyright Matt Borland 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_MP_STANDALONE

#include "test.hpp"
#include "constexpr_arithmetric_test.hpp"
#include "boost/multiprecision/cpp_int.hpp"

#if !defined(BOOST_MP_NO_CONSTEXPR_DETECTION) && !defined(DISABLE_TESTS)

template <class F, class V>
decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
{
   return f(v);
}

int main()
{
   typedef boost::multiprecision::int256_t  int_backend;
   typedef boost::multiprecision::uint256_t unsigned_backend;

   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_add_subtract(a);
      constexpr unsigned_backend d = test_constexpr_add_subtract(c);

      constexpr long long llv = (long long)b;

      static_assert(b == -108);
      static_assert(d == 554);
      static_assert(llv == -108);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_mul_divide(a);
      constexpr unsigned_backend d = test_constexpr_mul_divide(c);
      static_assert(b == 22);
      static_assert(d == 22);

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_bitwise(a);
      constexpr unsigned_backend d = test_constexpr_bitwise(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 230);
      static_assert(d == 120);
#else
      static_assert(b == 210);
      static_assert(d == 106);
#endif

      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b = test_constexpr_logical(a);
      constexpr unsigned_backend d = test_constexpr_logical(c);
#ifdef BOOST_HAS_INT128
      //static_assert(b == 95);
      //static_assert(d == 95);
#else
      static_assert(b == 82);
      static_assert(d == 82);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
   }
   {
      constexpr int_backend a(22);
      constexpr unsigned_backend c(22);
      constexpr int_backend b      = test_constexpr_compare(a);
      constexpr unsigned_backend d = test_constexpr_compare(c);
#ifdef BOOST_HAS_INT128
      static_assert(b == 95);
      static_assert(d == 95);
#else
      static_assert(b == 95);
      static_assert(d == 95);
#endif
      BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
      BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
   }
   return boost::report_errors();
}
#else
int main() {}
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_constexpr_test_float128.cpp
================================================
//  (C) Copyright John Maddock 2019 - 2021.
//  (C) Copyright Matt Borland 2021.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#define BOOST_MP_STANDALONE

#include "constexpr_arithmetric_test.hpp"
#include <boost/multiprecision/float128.hpp>
#include <iostream>

int main()
{
   using boost::multiprecision::float128;

   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_add_subtract(a);

      constexpr __float128 f128 = (__float128)b;
      static_assert(f128 == -108.0f);

      constexpr int i = (int)b;
      static_assert(i == -108);

      constexpr short s = (short)b;
      static_assert(s == -108);
   }
   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_mul_divide(a);
      static_assert((__float128)b == 0);
   }
   {
      constexpr float128 a(22);
      constexpr float128 b = test_constexpr_compare(a);
      static_assert((__float128)b == 119);
   }
   {
      constexpr float128 a(0);
      static_assert(fpclassify(a) == FP_ZERO);
      constexpr float128 b(1);
      static_assert(fpclassify(b) == FP_NORMAL);
      constexpr float128 c(-1);
      static_assert(fpclassify(c) == FP_NORMAL);
      static_assert(abs(c) >= 0);
      static_assert(fabs(c) >= 0);
      constexpr float128 d(std::numeric_limits<float128>::epsilon());
      static_assert(fpclassify(c) == FP_NORMAL);
      constexpr float128 e((std::numeric_limits<float128>::min)());
      static_assert(fpclassify(e) == FP_NORMAL);
      constexpr float128 f((std::numeric_limits<float128>::max)());
      static_assert(fpclassify(f) == FP_NORMAL);
      constexpr float128 g(std::numeric_limits<float128>::lowest());
      static_assert(fpclassify(g) == FP_NORMAL);
      constexpr float128 h(std::numeric_limits<float128>::round_error());
      static_assert(fpclassify(h) == FP_NORMAL);
      constexpr float128 i(std::numeric_limits<float128>::denorm_min());
      static_assert(fpclassify(i) == FP_SUBNORMAL);
      constexpr float128 j(-std::numeric_limits<float128>::denorm_min());
      static_assert(fpclassify(j) == FP_SUBNORMAL);
      constexpr float128 k(std::numeric_limits<float128>::infinity());
      static_assert(fpclassify(k) == FP_INFINITE);
      static_assert(isinf(k));
      static_assert(!isnan(k));
      constexpr float128 l(-std::numeric_limits<float128>::infinity());
      static_assert(fpclassify(l) == FP_INFINITE);
      static_assert(isinf(l));
      static_assert(!isnan(l));
   }
   std::cout << "Done!" << std::endl;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_complex128.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include <boost/config.hpp>

#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/complex128.hpp>
#endif

#include "test_arithmetic.hpp"

int main()
{
#ifdef BOOST_HAS_FLOAT128
   test<boost::multiprecision::complex128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_cpp_bin_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/cpp_bin_float.hpp>

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> >
{
   using number_type = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>;
   using type = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<((std::numeric_limits<number_type>::digits / 2) > std::numeric_limits<long double>::digits ? Digits / 2 : Digits), DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>;
};

int main()
{
   test<boost::multiprecision::cpp_bin_float_50>();
   //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<21>>>();
   //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<char>>>>();
   //test<boost::multiprecision::cpp_bin_float_quad>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_cpp_dec_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/cpp_dec_float.hpp>

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>>>
{
   using type = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D / 2>>;
};

int main()
{
   test<boost::multiprecision::cpp_dec_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/cpp_int.hpp>

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   using type = boost::multiprecision::int256_t;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   using type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET>;
};

int main()
{
   test<boost::multiprecision::cpp_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_cpp_rational.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/cpp_int.hpp>

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   using type = boost::multiprecision::int256_t;
};
template <>
struct related_type<boost::multiprecision::cpp_rational>
{
   using type = boost::multiprecision::cpp_int;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   using type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET>;
};

int main()
{
   test<boost::multiprecision::cpp_rational>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_float_128.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/float128.hpp>

int main()
{
   test<boost::multiprecision::float128>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_gmp.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>

int main()
{
   test<boost::multiprecision::mpz_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_int512.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 - 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/cpp_int.hpp>

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   using type = boost::multiprecision::int256_t;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   using type = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET>;
};

int main()
{
   test<boost::multiprecision::int512_t>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_mpf_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpf_float::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_mpz_rat.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> > >
{
   typedef boost::multiprecision::mpz_int type;
};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_arithmetic_tommath.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_STANDALONE

#include "test_arithmetic.hpp"
#include <boost/multiprecision/tommath.hpp>

template <>
struct is_twos_complement_integer<boost::multiprecision::tom_int> : public std::integral_constant<bool, false>
{};

int main()
{
   test<boost::multiprecision::tom_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_convert_from_tom_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. 
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_STANDALONE

#ifdef HAS_TOMMATH

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/multiprecision/tommath.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), numerator(t3).str());
   BOOST_CHECK_EQUAL(from.str(), numerator(t4).str());
}
template <class From, class To>
void test_convert_neg_rat(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), numerator(t1).str());
      BOOST_CHECK_EQUAL(from.str(), numerator(t2).str());
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To check(from.str() + ".0");
   BOOST_CHECK_EQUAL(t3, check);
   BOOST_CHECK_EQUAL(t4, check);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   check(from.str() + ".0");
      BOOST_CHECK_EQUAL(t1, check);
      BOOST_CHECK_EQUAL(t2, check);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

template <typename From, typename To>
void test_convert_to_builtin()
{
   const int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);
   
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To t1 = from;
      To t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(t1, t2);
   }
}

int main()
{
   test_convert_to_builtin<tom_int, unsigned long long>();
   test_convert_to_builtin<tom_int, long long>();
   test_convert_to_builtin<tom_int, long>();
   test_convert_to_builtin<tom_int, unsigned>();

   #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
   test_convert_to_builtin<tom_int, long double>();
   #endif
   test_convert_to_builtin<tom_int, double>();
   test_convert_to_builtin<tom_int, float>();

   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/standalone_test_miller_rabin.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012-2021 John Maddock.
//  Copyright 2021 Matt Borland. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/math/special_functions/prime.hpp>
#include <boost/random.hpp>
#include <random>
#include <iostream>
#include <iomanip>
#include "test.hpp"

#define BOOST_MP_STANDALONE
#include <boost/multiprecision/miller_rabin.hpp>

template <class I>
void test()
{
   //
   // Very simple test program to verify that the GMP's Miller-Rabin
   // implementation and this one agree on whether some random numbers
   // are prime or not.  Of course these are probabilistic tests so there's
   // no reason why they should actually agree - except the probability of
   // disagreement for 25 trials is almost infinitely small.
   //
   using namespace boost::random;
   using namespace boost::multiprecision;

   typedef I test_type;

   static const unsigned test_bits =
      std::numeric_limits<test_type>::digits && (std::numeric_limits<test_type>::digits <= 256)
         ? std::numeric_limits<test_type>::digits
         : 128;

   independent_bits_engine<mt11213b, test_bits, test_type> gen;
   //
   // We must use a different generator for the tests and number generation, otherwise
   // we get false positives.  Further we use the same random number engine for the
   // Miller Rabin test as GMP uses internally:
   //
   mt19937 gen2;

   //
   // Begin by testing the primes in our table as all these should return true:
   //
   for (unsigned i = 1; i < boost::math::max_prime; ++i)
   {
      BOOST_TEST(miller_rabin_test(test_type(boost::math::prime(i)), 25, gen));
      BOOST_TEST(mpz_probab_prime_p(mpz_int(boost::math::prime(i)).backend().data(), 25));
   }
   //
   // Now test some random values and compare GMP's native routine with ours.
   //
   for (unsigned i = 0; i < 10000; ++i)
   {
      test_type n              = gen();
      bool      is_prime_boost = miller_rabin_test(n, 25, gen2);
      bool      is_gmp_prime   = mpz_probab_prime_p(mpz_int(n).backend().data(), 25) ? true : false;
      if (is_prime_boost && is_gmp_prime)
      {
         std::cout << "We have a prime: " << std::hex << std::showbase << n << std::endl;
      }
      if (is_prime_boost != is_gmp_prime)
         std::cout << std::hex << std::showbase << "n = " << n << std::endl;
      BOOST_CHECK_EQUAL(is_prime_boost, is_gmp_prime);
   }
}

int main()
{
   using namespace boost::multiprecision;

   test<mpz_int>();
   test<number<gmp_int, et_off> >();
   test<std::uint64_t>();
   test<std::uint32_t>();

   test<cpp_int>();
   test<number<cpp_int_backend<64, 64, unsigned_magnitude, checked, void>, et_off> >();
   test<checked_uint128_t>();
   test<checked_uint1024_t>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/string_data.ipp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

{{
    "1e+08",
    "1.e+08",
    "+1e+08",
    "1.2e+08",
    "+1.2e+08",
    "1.2e+08",
    "123456789.0",
    "123456789.0",
    "+123456789.0",
    "1.2e+08",
    "1.2e+08",
    "+1.2e+08",
    "1.23e+08",
    "+1.23e+08",
    "1.23e+08",
    "123456789.00",
    "123456789.00",
    "+123456789.00",
    "1.23e+08",
    "1.23e+08",
    "+1.23e+08",
    "1.235e+08",
    "+1.235e+08",
    "1.235e+08",
    "123456789.000",
    "123456789.000",
    "+123456789.000",
    "1.235e+08",
    "1.235e+08",
    "+1.235e+08",
    "1.2346e+08",
    "+1.2346e+08",
    "1.2346e+08",
    "123456789.0000",
    "123456789.0000",
    "+123456789.0000",
    "1.2346e+08",
    "1.2346e+08",
    "+1.2346e+08",
    "1.23457e+08",
    "+1.23457e+08",
    "1.23457e+08",
    "123456789.00000",
    "123456789.00000",
    "+123456789.00000",
    "1.23457e+08",
    "1.23457e+08",
    "+1.23457e+08",
    "1.234568e+08",
    "+1.234568e+08",
    "1.234568e+08",
    "123456789.000000",
    "123456789.000000",
    "+123456789.000000",
    "1.234568e+08",
    "1.234568e+08",
    "+1.234568e+08",
    "1.2345679e+08",
    "+1.2345679e+08",
    "1.2345679e+08",
    "123456789.0000000",
    "123456789.0000000",
    "+123456789.0000000",
    "1.2345679e+08",
    "1.2345679e+08",
    "+1.2345679e+08",
    "1.23456789e+08",
    "+1.23456789e+08",
    "1.23456789e+08",
    "123456789.00000000",
    "123456789.00000000",
    "+123456789.00000000",
    "123456789",
    "123456789.",
    "+123456789",
    "1.234567890e+08",
    "+1.234567890e+08",
    "1.234567890e+08",
    "123456789.000000000",
    "123456789.000000000",
    "+123456789.000000000",
    "123456789",
    "123456789.0",
    "+123456789",
    "1.2345678900e+08",
    "+1.2345678900e+08",
    "1.2345678900e+08",
    "123456789.0000000000",
    "123456789.0000000000",
    "+123456789.0000000000",
    "123456789",
    "123456789.00",
    "+123456789",
    "1.23456789000e+08",
    "+1.23456789000e+08",
    "1.23456789000e+08",
    "123456789.00000000000",
    "123456789.00000000000",
    "+123456789.00000000000",
    "123456789",
    "123456789.000",
    "+123456789",
    "1.234567890000e+08",
    "+1.234567890000e+08",
    "1.234567890000e+08",
    "123456789.000000000000",
    "123456789.000000000000",
    "+123456789.000000000000",
    "123456789",
    "123456789.0000",
    "+123456789",
    "1.2345678900000e+08",
    "+1.2345678900000e+08",
    "1.2345678900000e+08",
    "123456789.0000000000000",
    "123456789.0000000000000",
    "+123456789.0000000000000",
}},
    {{
        "-1e+08",
        "-1.e+08",
        "-1e+08",
        "-1.2e+08",
        "-1.2e+08",
        "-1.2e+08",
        "-123456789.0",
        "-123456789.0",
        "-123456789.0",
        "-1.2e+08",
        "-1.2e+08",
        "-1.2e+08",
        "-1.23e+08",
        "-1.23e+08",
        "-1.23e+08",
        "-123456789.00",
        "-123456789.00",
        "-123456789.00",
        "-1.23e+08",
        "-1.23e+08",
        "-1.23e+08",
        "-1.235e+08",
        "-1.235e+08",
        "-1.235e+08",
        "-123456789.000",
        "-123456789.000",
        "-123456789.000",
        "-1.235e+08",
        "-1.235e+08",
        "-1.235e+08",
        "-1.2346e+08",
        "-1.2346e+08",
        "-1.2346e+08",
        "-123456789.0000",
        "-123456789.0000",
        "-123456789.0000",
        "-1.2346e+08",
        "-1.2346e+08",
        "-1.2346e+08",
        "-1.23457e+08",
        "-1.23457e+08",
        "-1.23457e+08",
        "-123456789.00000",
        "-123456789.00000",
        "-123456789.00000",
        "-1.23457e+08",
        "-1.23457e+08",
        "-1.23457e+08",
        "-1.234568e+08",
        "-1.234568e+08",
        "-1.234568e+08",
        "-123456789.000000",
        "-123456789.000000",
        "-123456789.000000",
        "-1.234568e+08",
        "-1.234568e+08",
        "-1.234568e+08",
        "-1.2345679e+08",
        "-1.2345679e+08",
        "-1.2345679e+08",
        "-123456789.0000000",
        "-123456789.0000000",
        "-123456789.0000000",
        "-1.2345679e+08",
        "-1.2345679e+08",
        "-1.2345679e+08",
        "-1.23456789e+08",
        "-1.23456789e+08",
        "-1.23456789e+08",
        "-123456789.00000000",
        "-123456789.00000000",
        "-123456789.00000000",
        "-123456789",
        "-123456789.",
        "-123456789",
        "-1.234567890e+08",
        "-1.234567890e+08",
        "-1.234567890e+08",
        "-123456789.000000000",
        "-123456789.000000000",
        "-123456789.000000000",
        "-123456789",
        "-123456789.0",
        "-123456789",
        "-1.2345678900e+08",
        "-1.2345678900e+08",
        "-1.2345678900e+08",
        "-123456789.0000000000",
        "-123456789.0000000000",
        "-123456789.0000000000",
        "-123456789",
        "-123456789.00",
        "-123456789",
        "-1.23456789000e+08",
        "-1.23456789000e+08",
        "-1.23456789000e+08",
        "-123456789.00000000000",
        "-123456789.00000000000",
        "-123456789.00000000000",
        "-123456789",
        "-123456789.000",
        "-123456789",
        "-1.234567890000e+08",
        "-1.234567890000e+08",
        "-1.234567890000e+08",
        "-123456789.000000000000",
        "-123456789.000000000000",
        "-123456789.000000000000",
        "-123456789",
        "-123456789.0000",
        "-123456789",
        "-1.2345678900000e+08",
        "-1.2345678900000e+08",
        "-1.2345678900000e+08",
        "-123456789.0000000000000",
        "-123456789.0000000000000",
        "-123456789.0000000000000",
    }},
    {{
        "2e+07",
        "2.e+07",
        "+2e+07",
        "1.5e+07",
        "+1.5e+07",
        "1.5e+07",
        "15432098.6",
        "15432098.6",
        "+15432098.6",
        "1.5e+07",
        "1.5e+07",
        "+1.5e+07",
        "1.54e+07",
        "+1.54e+07",
        "1.54e+07",
        "15432098.62",
        "15432098.62",
        "+15432098.62",
        "1.54e+07",
        "1.54e+07",
        "+1.54e+07",
        "1.543e+07",
        "+1.543e+07",
        "1.543e+07",
        "15432098.625",
        "15432098.625",
        "+15432098.625",
        "1.543e+07",
        "1.543e+07",
        "+1.543e+07",
        "1.5432e+07",
        "+1.5432e+07",
        "1.5432e+07",
        "15432098.6250",
        "15432098.6250",
        "+15432098.6250",
        "1.5432e+07",
        "1.5432e+07",
        "+1.5432e+07",
        "1.54321e+07",
        "+1.54321e+07",
        "1.54321e+07",
        "15432098.62500",
        "15432098.62500",
        "+15432098.62500",
        "1.54321e+07",
        "1.54321e+07",
        "+1.54321e+07",
        "1.543210e+07",
        "+1.543210e+07",
        "1.543210e+07",
        "15432098.625000",
        "15432098.625000",
        "+15432098.625000",
        "1.54321e+07",
        "1.543210e+07",
        "+1.54321e+07",
        "1.5432099e+07",
        "+1.5432099e+07",
        "1.5432099e+07",
        "15432098.6250000",
        "15432098.6250000",
        "+15432098.6250000",
        "15432099",
        "15432099.",
        "+15432099",
        "1.54320986e+07",
        "+1.54320986e+07",
        "1.54320986e+07",
        "15432098.62500000",
        "15432098.62500000",
        "+15432098.62500000",
        "15432098.6",
        "15432098.6",
        "+15432098.6",
        "1.543209862e+07",
        "+1.543209862e+07",
        "1.543209862e+07",
        "15432098.625000000",
        "15432098.625000000",
        "+15432098.625000000",
        "15432098.62",
        "15432098.62",
        "+15432098.62",
        "1.5432098625e+07",
        "+1.5432098625e+07",
        "1.5432098625e+07",
        "15432098.6250000000",
        "15432098.6250000000",
        "+15432098.6250000000",
        "15432098.625",
        "15432098.625",
        "+15432098.625",
        "1.54320986250e+07",
        "+1.54320986250e+07",
        "1.54320986250e+07",
        "15432098.62500000000",
        "15432098.62500000000",
        "+15432098.62500000000",
        "15432098.625",
        "15432098.6250",
        "+15432098.625",
        "1.543209862500e+07",
        "+1.543209862500e+07",
        "1.543209862500e+07",
        "15432098.625000000000",
        "15432098.625000000000",
        "+15432098.625000000000",
        "15432098.625",
        "15432098.62500",
        "+15432098.625",
        "1.5432098625000e+07",
        "+1.5432098625000e+07",
        "1.5432098625000e+07",
        "15432098.6250000000000",
        "15432098.6250000000000",
        "+15432098.6250000000000",
    }},
    {{
        "-2e+07",
        "-2.e+07",
        "-2e+07",
        "-1.5e+07",
        "-1.5e+07",
        "-1.5e+07",
        "-15432098.6",
        "-15432098.6",
        "-15432098.6",
        "-1.5e+07",
        "-1.5e+07",
        "-1.5e+07",
        "-1.54e+07",
        "-1.54e+07",
        "-1.54e+07",
        "-15432098.62",
        "-15432098.62",
        "-15432098.62",
        "-1.54e+07",
        "-1.54e+07",
        "-1.54e+07",
        "-1.543e+07",
        "-1.543e+07",
        "-1.543e+07",
        "-15432098.625",
        "-15432098.625",
        "-15432098.625",
        "-1.543e+07",
        "-1.543e+07",
        "-1.543e+07",
        "-1.5432e+07",
        "-1.5432e+07",
        "-1.5432e+07",
        "-15432098.6250",
        "-15432098.6250",
        "-15432098.6250",
        "-1.5432e+07",
        "-1.5432e+07",
        "-1.5432e+07",
        "-1.54321e+07",
        "-1.54321e+07",
        "-1.54321e+07",
        "-15432098.62500",
        "-15432098.62500",
        "-15432098.62500",
        "-1.54321e+07",
        "-1.54321e+07",
        "-1.54321e+07",
        "-1.543210e+07",
        "-1.543210e+07",
        "-1.543210e+07",
        "-15432098.625000",
        "-15432098.625000",
        "-15432098.625000",
        "-1.54321e+07",
        "-1.543210e+07",
        "-1.54321e+07",
        "-1.5432099e+07",
        "-1.5432099e+07",
        "-1.5432099e+07",
        "-15432098.6250000",
        "-15432098.6250000",
        "-15432098.6250000",
        "-15432099",
        "-15432099.",
        "-15432099",
        "-1.54320986e+07",
        "-1.54320986e+07",
        "-1.54320986e+07",
        "-15432098.62500000",
        "-15432098.62500000",
        "-15432098.62500000",
        "-15432098.6",
        "-15432098.6",
        "-15432098.6",
        "-1.543209862e+07",
        "-1.543209862e+07",
        "-1.543209862e+07",
        "-15432098.625000000",
        "-15432098.625000000",
        "-15432098.625000000",
        "-15432098.62",
        "-15432098.62",
        "-15432098.62",
        "-1.5432098625e+07",
        "-1.5432098625e+07",
        "-1.5432098625e+07",
        "-15432098.6250000000",
        "-15432098.6250000000",
        "-15432098.6250000000",
        "-15432098.625",
        "-15432098.625",
        "-15432098.625",
        "-1.54320986250e+07",
        "-1.54320986250e+07",
        "-1.54320986250e+07",
        "-15432098.62500000000",
        "-15432098.62500000000",
        "-15432098.62500000000",
        "-15432098.625",
        "-15432098.6250",
        "-15432098.625",
        "-1.543209862500e+07",
        "-1.543209862500e+07",
        "-1.543209862500e+07",
        "-15432098.625000000000",
        "-15432098.625000000000",
        "-15432098.625000000000",
        "-15432098.625",
        "-15432098.62500",
        "-15432098.625",
        "-1.5432098625000e+07",
        "-1.5432098625000e+07",
        "-1.5432098625000e+07",
        "-15432098.6250000000000",
        "-15432098.6250000000000",
        "-15432098.6250000000000",
    }},
    {{
        "2e+06",
        "2.e+06",
        "+2e+06",
        "1.9e+06",
        "+1.9e+06",
        "1.9e+06",
        "1929012.3",
        "1929012.3",
        "+1929012.3",
        "1.9e+06",
        "1.9e+06",
        "+1.9e+06",
        "1.93e+06",
        "+1.93e+06",
        "1.93e+06",
        "1929012.33",
        "1929012.33",
        "+1929012.33",
        "1.93e+06",
        "1.93e+06",
        "+1.93e+06",
        "1.929e+06",
        "+1.929e+06",
        "1.929e+06",
        "1929012.328",
        "1929012.328",
        "+1929012.328",
        "1.929e+06",
        "1.929e+06",
        "+1.929e+06",
        "1.9290e+06",
        "+1.9290e+06",
        "1.9290e+06",
        "1929012.3281",
        "1929012.3281",
        "+1929012.3281",
        "1.929e+06",
        "1.9290e+06",
        "+1.929e+06",
        "1.92901e+06",
        "+1.92901e+06",
        "1.92901e+06",
        "1929012.32812",
        "1929012.32812",
        "+1929012.32812",
        "1.92901e+06",
        "1.92901e+06",
        "+1.92901e+06",
        "1.929012e+06",
        "+1.929012e+06",
        "1.929012e+06",
        "1929012.328125",
        "1929012.328125",
        "+1929012.328125",
        "1929012",
        "1929012.",
        "+1929012",
        "1.9290123e+06",
        "+1.9290123e+06",
        "1.9290123e+06",
        "1929012.3281250",
        "1929012.3281250",
        "+1929012.3281250",
        "1929012.3",
        "1929012.3",
        "+1929012.3",
        "1.92901233e+06",
        "+1.92901233e+06",
        "1.92901233e+06",
        "1929012.32812500",
        "1929012.32812500",
        "+1929012.32812500",
        "1929012.33",
        "1929012.33",
        "+1929012.33",
        "1.929012328e+06",
        "+1.929012328e+06",
        "1.929012328e+06",
        "1929012.328125000",
        "1929012.328125000",
        "+1929012.328125000",
        "1929012.328",
        "1929012.328",
        "+1929012.328",
        "1.9290123281e+06",
        "+1.9290123281e+06",
        "1.9290123281e+06",
        "1929012.3281250000",
        "1929012.3281250000",
        "+1929012.3281250000",
        "1929012.3281",
        "1929012.3281",
        "+1929012.3281",
        "1.92901232812e+06",
        "+1.92901232812e+06",
        "1.92901232812e+06",
        "1929012.32812500000",
        "1929012.32812500000",
        "+1929012.32812500000",
        "1929012.32812",
        "1929012.32812",
        "+1929012.32812",
        "1.929012328125e+06",
        "+1.929012328125e+06",
        "1.929012328125e+06",
        "1929012.328125000000",
        "1929012.328125000000",
        "+1929012.328125000000",
        "1929012.328125",
        "1929012.328125",
        "+1929012.328125",
        "1.9290123281250e+06",
        "+1.9290123281250e+06",
        "1.9290123281250e+06",
        "1929012.3281250000000",
        "1929012.3281250000000",
        "+1929012.3281250000000",
    }},
    {{
        "-2e+06",
        "-2.e+06",
        "-2e+06",
        "-1.9e+06",
        "-1.9e+06",
        "-1.9e+06",
        "-1929012.3",
        "-1929012.3",
        "-1929012.3",
        "-1.9e+06",
        "-1.9e+06",
        "-1.9e+06",
        "-1.93e+06",
        "-1.93e+06",
        "-1.93e+06",
        "-1929012.33",
        "-1929012.33",
        "-1929012.33",
        "-1.93e+06",
        "-1.93e+06",
        "-1.93e+06",
        "-1.929e+06",
        "-1.929e+06",
        "-1.929e+06",
        "-1929012.328",
        "-1929012.328",
        "-1929012.328",
        "-1.929e+06",
        "-1.929e+06",
        "-1.929e+06",
        "-1.9290e+06",
        "-1.9290e+06",
        "-1.9290e+06",
        "-1929012.3281",
        "-1929012.3281",
        "-1929012.3281",
        "-1.929e+06",
        "-1.9290e+06",
        "-1.929e+06",
        "-1.92901e+06",
        "-1.92901e+06",
        "-1.92901e+06",
        "-1929012.32812",
        "-1929012.32812",
        "-1929012.32812",
        "-1.92901e+06",
        "-1.92901e+06",
        "-1.92901e+06",
        "-1.929012e+06",
        "-1.929012e+06",
        "-1.929012e+06",
        "-1929012.328125",
        "-1929012.328125",
        "-1929012.328125",
        "-1929012",
        "-1929012.",
        "-1929012",
        "-1.9290123e+06",
        "-1.9290123e+06",
        "-1.9290123e+06",
        "-1929012.3281250",
        "-1929012.3281250",
        "-1929012.3281250",
        "-1929012.3",
        "-1929012.3",
        "-1929012.3",
        "-1.92901233e+06",
        "-1.92901233e+06",
        "-1.92901233e+06",
        "-1929012.32812500",
        "-1929012.32812500",
        "-1929012.32812500",
        "-1929012.33",
        "-1929012.33",
        "-1929012.33",
        "-1.929012328e+06",
        "-1.929012328e+06",
        "-1.929012328e+06",
        "-1929012.328125000",
        "-1929012.328125000",
        "-1929012.328125000",
        "-1929012.328",
        "-1929012.328",
        "-1929012.328",
        "-1.9290123281e+06",
        "-1.9290123281e+06",
        "-1.9290123281e+06",
        "-1929012.3281250000",
        "-1929012.3281250000",
        "-1929012.3281250000",
        "-1929012.3281",
        "-1929012.3281",
        "-1929012.3281",
        "-1.92901232812e+06",
        "-1.92901232812e+06",
        "-1.92901232812e+06",
        "-1929012.32812500000",
        "-1929012.32812500000",
        "-1929012.32812500000",
        "-1929012.32812",
        "-1929012.32812",
        "-1929012.32812",
        "-1.929012328125e+06",
        "-1.929012328125e+06",
        "-1.929012328125e+06",
        "-1929012.328125000000",
        "-1929012.328125000000",
        "-1929012.328125000000",
        "-1929012.328125",
        "-1929012.328125",
        "-1929012.328125",
        "-1.9290123281250e+06",
        "-1.9290123281250e+06",
        "-1.9290123281250e+06",
        "-1929012.3281250000000",
        "-1929012.3281250000000",
        "-1929012.3281250000000",
    }},
    {{
        "2e+05",
        "2.e+05",
        "+2e+05",
        "2.4e+05",
        "+2.4e+05",
        "2.4e+05",
        "241126.5",
        "241126.5",
        "+241126.5",
        "2.4e+05",
        "2.4e+05",
        "+2.4e+05",
        "2.41e+05",
        "+2.41e+05",
        "2.41e+05",
        "241126.54",
        "241126.54",
        "+241126.54",
        "2.41e+05",
        "2.41e+05",
        "+2.41e+05",
        "2.411e+05",
        "+2.411e+05",
        "2.411e+05",
        "241126.541",
        "241126.541",
        "+241126.541",
        "2.411e+05",
        "2.411e+05",
        "+2.411e+05",
        "2.4113e+05",
        "+2.4113e+05",
        "2.4113e+05",
        "241126.5410",
        "241126.5410",
        "+241126.5410",
        "2.4113e+05",
        "2.4113e+05",
        "+2.4113e+05",
        "2.41127e+05",
        "+2.41127e+05",
        "2.41127e+05",
        "241126.54102",
        "241126.54102",
        "+241126.54102",
        "241127",
        "241127.",
        "+241127",
        "2.411265e+05",
        "+2.411265e+05",
        "2.411265e+05",
        "241126.541016",
        "241126.541016",
        "+241126.541016",
        "241126.5",
        "241126.5",
        "+241126.5",
        "2.4112654e+05",
        "+2.4112654e+05",
        "2.4112654e+05",
        "241126.5410156",
        "241126.5410156",
        "+241126.5410156",
        "241126.54",
        "241126.54",
        "+241126.54",
        "2.41126541e+05",
        "+2.41126541e+05",
        "2.41126541e+05",
        "241126.54101562",
        "241126.54101562",
        "+241126.54101562",
        "241126.541",
        "241126.541",
        "+241126.541",
        "2.411265410e+05",
        "+2.411265410e+05",
        "2.411265410e+05",
        "241126.541015625",
        "241126.541015625",
        "+241126.541015625",
        "241126.541",
        "241126.5410",
        "+241126.541",
        "2.4112654102e+05",
        "+2.4112654102e+05",
        "2.4112654102e+05",
        "241126.5410156250",
        "241126.5410156250",
        "+241126.5410156250",
        "241126.54102",
        "241126.54102",
        "+241126.54102",
        "2.41126541016e+05",
        "+2.41126541016e+05",
        "2.41126541016e+05",
        "241126.54101562500",
        "241126.54101562500",
        "+241126.54101562500",
        "241126.541016",
        "241126.541016",
        "+241126.541016",
        "2.411265410156e+05",
        "+2.411265410156e+05",
        "2.411265410156e+05",
        "241126.541015625000",
        "241126.541015625000",
        "+241126.541015625000",
        "241126.5410156",
        "241126.5410156",
        "+241126.5410156",
        "2.4112654101562e+05",
        "+2.4112654101562e+05",
        "2.4112654101562e+05",
        "241126.5410156250000",
        "241126.5410156250000",
        "+241126.5410156250000",
    }},
    {{
        "-2e+05",
        "-2.e+05",
        "-2e+05",
        "-2.4e+05",
        "-2.4e+05",
        "-2.4e+05",
        "-241126.5",
        "-241126.5",
        "-241126.5",
        "-2.4e+05",
        "-2.4e+05",
        "-2.4e+05",
        "-2.41e+05",
        "-2.41e+05",
        "-2.41e+05",
        "-241126.54",
        "-241126.54",
        "-241126.54",
        "-2.41e+05",
        "-2.41e+05",
        "-2.41e+05",
        "-2.411e+05",
        "-2.411e+05",
        "-2.411e+05",
        "-241126.541",
        "-241126.541",
        "-241126.541",
        "-2.411e+05",
        "-2.411e+05",
        "-2.411e+05",
        "-2.4113e+05",
        "-2.4113e+05",
        "-2.4113e+05",
        "-241126.5410",
        "-241126.5410",
        "-241126.5410",
        "-2.4113e+05",
        "-2.4113e+05",
        "-2.4113e+05",
        "-2.41127e+05",
        "-2.41127e+05",
        "-2.41127e+05",
        "-241126.54102",
        "-241126.54102",
        "-241126.54102",
        "-241127",
        "-241127.",
        "-241127",
        "-2.411265e+05",
        "-2.411265e+05",
        "-2.411265e+05",
        "-241126.541016",
        "-241126.541016",
        "-241126.541016",
        "-241126.5",
        "-241126.5",
        "-241126.5",
        "-2.4112654e+05",
        "-2.4112654e+05",
        "-2.4112654e+05",
        "-241126.5410156",
        "-241126.5410156",
        "-241126.5410156",
        "-241126.54",
        "-241126.54",
        "-241126.54",
        "-2.41126541e+05",
        "-2.41126541e+05",
        "-2.41126541e+05",
        "-241126.54101562",
        "-241126.54101562",
        "-241126.54101562",
        "-241126.541",
        "-241126.541",
        "-241126.541",
        "-2.411265410e+05",
        "-2.411265410e+05",
        "-2.411265410e+05",
        "-241126.541015625",
        "-241126.541015625",
        "-241126.541015625",
        "-241126.541",
        "-241126.5410",
        "-241126.541",
        "-2.4112654102e+05",
        "-2.4112654102e+05",
        "-2.4112654102e+05",
        "-241126.5410156250",
        "-241126.5410156250",
        "-241126.5410156250",
        "-241126.54102",
        "-241126.54102",
        "-241126.54102",
        "-2.41126541016e+05",
        "-2.41126541016e+05",
        "-2.41126541016e+05",
        "-241126.54101562500",
        "-241126.54101562500",
        "-241126.54101562500",
        "-241126.541016",
        "-241126.541016",
        "-241126.541016",
        "-2.411265410156e+05",
        "-2.411265410156e+05",
        "-2.411265410156e+05",
        "-241126.541015625000",
        "-241126.541015625000",
        "-241126.541015625000",
        "-241126.5410156",
        "-241126.5410156",
        "-241126.5410156",
        "-2.4112654101562e+05",
        "-2.4112654101562e+05",
        "-2.4112654101562e+05",
        "-241126.5410156250000",
        "-241126.5410156250000",
        "-241126.5410156250000",
    }},
    {{
        "3e+04",
        "3.e+04",
        "+3e+04",
        "3.0e+04",
        "+3.0e+04",
        "3.0e+04",
        "30140.8",
        "30140.8",
        "+30140.8",
        "3e+04",
        "3.0e+04",
        "+3e+04",
        "3.01e+04",
        "+3.01e+04",
        "3.01e+04",
        "30140.82",
        "30140.82",
        "+30140.82",
        "3.01e+04",
        "3.01e+04",
        "+3.01e+04",
        "3.014e+04",
        "+3.014e+04",
        "3.014e+04",
        "30140.818",
        "30140.818",
        "+30140.818",
        "3.014e+04",
        "3.014e+04",
        "+3.014e+04",
        "3.0141e+04",
        "+3.0141e+04",
        "3.0141e+04",
        "30140.8176",
        "30140.8176",
        "+30140.8176",
        "30141",
        "30141.",
        "+30141",
        "3.01408e+04",
        "+3.01408e+04",
        "3.01408e+04",
        "30140.81763",
        "30140.81763",
        "+30140.81763",
        "30140.8",
        "30140.8",
        "+30140.8",
        "3.014082e+04",
        "+3.014082e+04",
        "3.014082e+04",
        "30140.817627",
        "30140.817627",
        "+30140.817627",
        "30140.82",
        "30140.82",
        "+30140.82",
        "3.0140818e+04",
        "+3.0140818e+04",
        "3.0140818e+04",
        "30140.8176270",
        "30140.8176270",
        "+30140.8176270",
        "30140.818",
        "30140.818",
        "+30140.818",
        "3.01408176e+04",
        "+3.01408176e+04",
        "3.01408176e+04",
        "30140.81762695",
        "30140.81762695",
        "+30140.81762695",
        "30140.8176",
        "30140.8176",
        "+30140.8176",
        "3.014081763e+04",
        "+3.014081763e+04",
        "3.014081763e+04",
        "30140.817626953",
        "30140.817626953",
        "+30140.817626953",
        "30140.81763",
        "30140.81763",
        "+30140.81763",
        "3.0140817627e+04",
        "+3.0140817627e+04",
        "3.0140817627e+04",
        "30140.8176269531",
        "30140.8176269531",
        "+30140.8176269531",
        "30140.817627",
        "30140.817627",
        "+30140.817627",
        "3.01408176270e+04",
        "+3.01408176270e+04",
        "3.01408176270e+04",
        "30140.81762695312",
        "30140.81762695312",
        "+30140.81762695312",
        "30140.817627",
        "30140.8176270",
        "+30140.817627",
        "3.014081762695e+04",
        "+3.014081762695e+04",
        "3.014081762695e+04",
        "30140.817626953125",
        "30140.817626953125",
        "+30140.817626953125",
        "30140.81762695",
        "30140.81762695",
        "+30140.81762695",
        "3.0140817626953e+04",
        "+3.0140817626953e+04",
        "3.0140817626953e+04",
        "30140.8176269531250",
        "30140.8176269531250",
        "+30140.8176269531250",
    }},
    {{
        "-3e+04",
        "-3.e+04",
        "-3e+04",
        "-3.0e+04",
        "-3.0e+04",
        "-3.0e+04",
        "-30140.8",
        "-30140.8",
        "-30140.8",
        "-3e+04",
        "-3.0e+04",
        "-3e+04",
        "-3.01e+04",
        "-3.01e+04",
        "-3.01e+04",
        "-30140.82",
        "-30140.82",
        "-30140.82",
        "-3.01e+04",
        "-3.01e+04",
        "-3.01e+04",
        "-3.014e+04",
        "-3.014e+04",
        "-3.014e+04",
        "-30140.818",
        "-30140.818",
        "-30140.818",
        "-3.014e+04",
        "-3.014e+04",
        "-3.014e+04",
        "-3.0141e+04",
        "-3.0141e+04",
        "-3.0141e+04",
        "-30140.8176",
        "-30140.8176",
        "-30140.8176",
        "-30141",
        "-30141.",
        "-30141",
        "-3.01408e+04",
        "-3.01408e+04",
        "-3.01408e+04",
        "-30140.81763",
        "-30140.81763",
        "-30140.81763",
        "-30140.8",
        "-30140.8",
        "-30140.8",
        "-3.014082e+04",
        "-3.014082e+04",
        "-3.014082e+04",
        "-30140.817627",
        "-30140.817627",
        "-30140.817627",
        "-30140.82",
        "-30140.82",
        "-30140.82",
        "-3.0140818e+04",
        "-3.0140818e+04",
        "-3.0140818e+04",
        "-30140.8176270",
        "-30140.8176270",
        "-30140.8176270",
        "-30140.818",
        "-30140.818",
        "-30140.818",
        "-3.01408176e+04",
        "-3.01408176e+04",
        "-3.01408176e+04",
        "-30140.81762695",
        "-30140.81762695",
        "-30140.81762695",
        "-30140.8176",
        "-30140.8176",
        "-30140.8176",
        "-3.014081763e+04",
        "-3.014081763e+04",
        "-3.014081763e+04",
        "-30140.817626953",
        "-30140.817626953",
        "-30140.817626953",
        "-30140.81763",
        "-30140.81763",
        "-30140.81763",
        "-3.0140817627e+04",
        "-3.0140817627e+04",
        "-3.0140817627e+04",
        "-30140.8176269531",
        "-30140.8176269531",
        "-30140.8176269531",
        "-30140.817627",
        "-30140.817627",
        "-30140.817627",
        "-3.01408176270e+04",
        "-3.01408176270e+04",
        "-3.01408176270e+04",
        "-30140.81762695312",
        "-30140.81762695312",
        "-30140.81762695312",
        "-30140.817627",
        "-30140.8176270",
        "-30140.817627",
        "-3.014081762695e+04",
        "-3.014081762695e+04",
        "-3.014081762695e+04",
        "-30140.817626953125",
        "-30140.817626953125",
        "-30140.817626953125",
        "-30140.81762695",
        "-30140.81762695",
        "-30140.81762695",
        "-3.0140817626953e+04",
        "-3.0140817626953e+04",
        "-3.0140817626953e+04",
        "-30140.8176269531250",
        "-30140.8176269531250",
        "-30140.8176269531250",
    }},
    {{
        "4e+03",
        "4.e+03",
        "+4e+03",
        "3.8e+03",
        "+3.8e+03",
        "3.8e+03",
        "3767.6",
        "3767.6",
        "+3767.6",
        "3.8e+03",
        "3.8e+03",
        "+3.8e+03",
        "3.77e+03",
        "+3.77e+03",
        "3.77e+03",
        "3767.60",
        "3767.60",
        "+3767.60",
        "3.77e+03",
        "3.77e+03",
        "+3.77e+03",
        "3.768e+03",
        "+3.768e+03",
        "3.768e+03",
        "3767.602",
        "3767.602",
        "+3767.602",
        "3768",
        "3768.",
        "+3768",
        "3.7676e+03",
        "+3.7676e+03",
        "3.7676e+03",
        "3767.6022",
        "3767.6022",
        "+3767.6022",
        "3767.6",
        "3767.6",
        "+3767.6",
        "3.76760e+03",
        "+3.76760e+03",
        "3.76760e+03",
        "3767.60220",
        "3767.60220",
        "+3767.60220",
        "3767.6",
        "3767.60",
        "+3767.6",
        "3.767602e+03",
        "+3.767602e+03",
        "3.767602e+03",
        "3767.602203",
        "3767.602203",
        "+3767.602203",
        "3767.602",
        "3767.602",
        "+3767.602",
        "3.7676022e+03",
        "+3.7676022e+03",
        "3.7676022e+03",
        "3767.6022034",
        "3767.6022034",
        "+3767.6022034",
        "3767.6022",
        "3767.6022",
        "+3767.6022",
        "3.76760220e+03",
        "+3.76760220e+03",
        "3.76760220e+03",
        "3767.60220337",
        "3767.60220337",
        "+3767.60220337",
        "3767.6022",
        "3767.60220",
        "+3767.6022",
        "3.767602203e+03",
        "+3.767602203e+03",
        "3.767602203e+03",
        "3767.602203369",
        "3767.602203369",
        "+3767.602203369",
        "3767.602203",
        "3767.602203",
        "+3767.602203",
        "3.7676022034e+03",
        "+3.7676022034e+03",
        "3.7676022034e+03",
        "3767.6022033691",
        "3767.6022033691",
        "+3767.6022033691",
        "3767.6022034",
        "3767.6022034",
        "+3767.6022034",
        "3.76760220337e+03",
        "+3.76760220337e+03",
        "3.76760220337e+03",
        "3767.60220336914",
        "3767.60220336914",
        "+3767.60220336914",
        "3767.60220337",
        "3767.60220337",
        "+3767.60220337",
        "3.767602203369e+03",
        "+3.767602203369e+03",
        "3.767602203369e+03",
        "3767.602203369141",
        "3767.602203369141",
        "+3767.602203369141",
        "3767.602203369",
        "3767.602203369",
        "+3767.602203369",
        "3.7676022033691e+03",
        "+3.7676022033691e+03",
        "3.7676022033691e+03",
        "3767.6022033691406",
        "3767.6022033691406",
        "+3767.6022033691406",
    }},
    {{
        "-4e+03",
        "-4.e+03",
        "-4e+03",
        "-3.8e+03",
        "-3.8e+03",
        "-3.8e+03",
        "-3767.6",
        "-3767.6",
        "-3767.6",
        "-3.8e+03",
        "-3.8e+03",
        "-3.8e+03",
        "-3.77e+03",
        "-3.77e+03",
        "-3.77e+03",
        "-3767.60",
        "-3767.60",
        "-3767.60",
        "-3.77e+03",
        "-3.77e+03",
        "-3.77e+03",
        "-3.768e+03",
        "-3.768e+03",
        "-3.768e+03",
        "-3767.602",
        "-3767.602",
        "-3767.602",
        "-3768",
        "-3768.",
        "-3768",
        "-3.7676e+03",
        "-3.7676e+03",
        "-3.7676e+03",
        "-3767.6022",
        "-3767.6022",
        "-3767.6022",
        "-3767.6",
        "-3767.6",
        "-3767.6",
        "-3.76760e+03",
        "-3.76760e+03",
        "-3.76760e+03",
        "-3767.60220",
        "-3767.60220",
        "-3767.60220",
        "-3767.6",
        "-3767.60",
        "-3767.6",
        "-3.767602e+03",
        "-3.767602e+03",
        "-3.767602e+03",
        "-3767.602203",
        "-3767.602203",
        "-3767.602203",
        "-3767.602",
        "-3767.602",
        "-3767.602",
        "-3.7676022e+03",
        "-3.7676022e+03",
        "-3.7676022e+03",
        "-3767.6022034",
        "-3767.6022034",
        "-3767.6022034",
        "-3767.6022",
        "-3767.6022",
        "-3767.6022",
        "-3.76760220e+03",
        "-3.76760220e+03",
        "-3.76760220e+03",
        "-3767.60220337",
        "-3767.60220337",
        "-3767.60220337",
        "-3767.6022",
        "-3767.60220",
        "-3767.6022",
        "-3.767602203e+03",
        "-3.767602203e+03",
        "-3.767602203e+03",
        "-3767.602203369",
        "-3767.602203369",
        "-3767.602203369",
        "-3767.602203",
        "-3767.602203",
        "-3767.602203",
        "-3.7676022034e+03",
        "-3.7676022034e+03",
        "-3.7676022034e+03",
        "-3767.6022033691",
        "-3767.6022033691",
        "-3767.6022033691",
        "-3767.6022034",
        "-3767.6022034",
        "-3767.6022034",
        "-3.76760220337e+03",
        "-3.76760220337e+03",
        "-3.76760220337e+03",
        "-3767.60220336914",
        "-3767.60220336914",
        "-3767.60220336914",
        "-3767.60220337",
        "-3767.60220337",
        "-3767.60220337",
        "-3.767602203369e+03",
        "-3.767602203369e+03",
        "-3.767602203369e+03",
        "-3767.602203369141",
        "-3767.602203369141",
        "-3767.602203369141",
        "-3767.602203369",
        "-3767.602203369",
        "-3767.602203369",
        "-3.7676022033691e+03",
        "-3.7676022033691e+03",
        "-3.7676022033691e+03",
        "-3767.6022033691406",
        "-3767.6022033691406",
        "-3767.6022033691406",
    }},
    {{
        "5e+02",
        "5.e+02",
        "+5e+02",
        "4.7e+02",
        "+4.7e+02",
        "4.7e+02",
        "471.0",
        "471.0",
        "+471.0",
        "4.7e+02",
        "4.7e+02",
        "+4.7e+02",
        "4.71e+02",
        "+4.71e+02",
        "4.71e+02",
        "470.95",
        "470.95",
        "+470.95",
        "471",
        "471.",
        "+471",
        "4.710e+02",
        "+4.710e+02",
        "4.710e+02",
        "470.950",
        "470.950",
        "+470.950",
        "471",
        "471.0",
        "+471",
        "4.7095e+02",
        "+4.7095e+02",
        "4.7095e+02",
        "470.9503",
        "470.9503",
        "+470.9503",
        "470.95",
        "470.95",
        "+470.95",
        "4.70950e+02",
        "+4.70950e+02",
        "4.70950e+02",
        "470.95028",
        "470.95028",
        "+470.95028",
        "470.95",
        "470.950",
        "+470.95",
        "4.709503e+02",
        "+4.709503e+02",
        "4.709503e+02",
        "470.950275",
        "470.950275",
        "+470.950275",
        "470.9503",
        "470.9503",
        "+470.9503",
        "4.7095028e+02",
        "+4.7095028e+02",
        "4.7095028e+02",
        "470.9502754",
        "470.9502754",
        "+470.9502754",
        "470.95028",
        "470.95028",
        "+470.95028",
        "4.70950275e+02",
        "+4.70950275e+02",
        "4.70950275e+02",
        "470.95027542",
        "470.95027542",
        "+470.95027542",
        "470.950275",
        "470.950275",
        "+470.950275",
        "4.709502754e+02",
        "+4.709502754e+02",
        "4.709502754e+02",
        "470.950275421",
        "470.950275421",
        "+470.950275421",
        "470.9502754",
        "470.9502754",
        "+470.9502754",
        "4.7095027542e+02",
        "+4.7095027542e+02",
        "4.7095027542e+02",
        "470.9502754211",
        "470.9502754211",
        "+470.9502754211",
        "470.95027542",
        "470.95027542",
        "+470.95027542",
        "4.70950275421e+02",
        "+4.70950275421e+02",
        "4.70950275421e+02",
        "470.95027542114",
        "470.95027542114",
        "+470.95027542114",
        "470.950275421",
        "470.950275421",
        "+470.950275421",
        "4.709502754211e+02",
        "+4.709502754211e+02",
        "4.709502754211e+02",
        "470.950275421143",
        "470.950275421143",
        "+470.950275421143",
        "470.9502754211",
        "470.9502754211",
        "+470.9502754211",
        "4.7095027542114e+02",
        "+4.7095027542114e+02",
        "4.7095027542114e+02",
        "470.9502754211426",
        "470.9502754211426",
        "+470.9502754211426",
    }},
    {{
        "-5e+02",
        "-5.e+02",
        "-5e+02",
        "-4.7e+02",
        "-4.7e+02",
        "-4.7e+02",
        "-471.0",
        "-471.0",
        "-471.0",
        "-4.7e+02",
        "-4.7e+02",
        "-4.7e+02",
        "-4.71e+02",
        "-4.71e+02",
        "-4.71e+02",
        "-470.95",
        "-470.95",
        "-470.95",
        "-471",
        "-471.",
        "-471",
        "-4.710e+02",
        "-4.710e+02",
        "-4.710e+02",
        "-470.950",
        "-470.950",
        "-470.950",
        "-471",
        "-471.0",
        "-471",
        "-4.7095e+02",
        "-4.7095e+02",
        "-4.7095e+02",
        "-470.9503",
        "-470.9503",
        "-470.9503",
        "-470.95",
        "-470.95",
        "-470.95",
        "-4.70950e+02",
        "-4.70950e+02",
        "-4.70950e+02",
        "-470.95028",
        "-470.95028",
        "-470.95028",
        "-470.95",
        "-470.950",
        "-470.95",
        "-4.709503e+02",
        "-4.709503e+02",
        "-4.709503e+02",
        "-470.950275",
        "-470.950275",
        "-470.950275",
        "-470.9503",
        "-470.9503",
        "-470.9503",
        "-4.7095028e+02",
        "-4.7095028e+02",
        "-4.7095028e+02",
        "-470.9502754",
        "-470.9502754",
        "-470.9502754",
        "-470.95028",
        "-470.95028",
        "-470.95028",
        "-4.70950275e+02",
        "-4.70950275e+02",
        "-4.70950275e+02",
        "-470.95027542",
        "-470.95027542",
        "-470.95027542",
        "-470.950275",
        "-470.950275",
        "-470.950275",
        "-4.709502754e+02",
        "-4.709502754e+02",
        "-4.709502754e+02",
        "-470.950275421",
        "-470.950275421",
        "-470.950275421",
        "-470.9502754",
        "-470.9502754",
        "-470.9502754",
        "-4.7095027542e+02",
        "-4.7095027542e+02",
        "-4.7095027542e+02",
        "-470.9502754211",
        "-470.9502754211",
        "-470.9502754211",
        "-470.95027542",
        "-470.95027542",
        "-470.95027542",
        "-4.70950275421e+02",
        "-4.70950275421e+02",
        "-4.70950275421e+02",
        "-470.95027542114",
        "-470.95027542114",
        "-470.95027542114",
        "-470.950275421",
        "-470.950275421",
        "-470.950275421",
        "-4.709502754211e+02",
        "-4.709502754211e+02",
        "-4.709502754211e+02",
        "-470.950275421143",
        "-470.950275421143",
        "-470.950275421143",
        "-470.9502754211",
        "-470.9502754211",
        "-470.9502754211",
        "-4.7095027542114e+02",
        "-4.7095027542114e+02",
        "-4.7095027542114e+02",
        "-470.9502754211426",
        "-470.9502754211426",
        "-470.9502754211426",
    }},
    {{
        "6e+01",
        "6.e+01",
        "+6e+01",
        "5.9e+01",
        "+5.9e+01",
        "5.9e+01",
        "58.9",
        "58.9",
        "+58.9",
        "59",
        "59.",
        "+59",
        "5.89e+01",
        "+5.89e+01",
        "5.89e+01",
        "58.87",
        "58.87",
        "+58.87",
        "58.9",
        "58.9",
        "+58.9",
        "5.887e+01",
        "+5.887e+01",
        "5.887e+01",
        "58.869",
        "58.869",
        "+58.869",
        "58.87",
        "58.87",
        "+58.87",
        "5.8869e+01",
        "+5.8869e+01",
        "5.8869e+01",
        "58.8688",
        "58.8688",
        "+58.8688",
        "58.869",
        "58.869",
        "+58.869",
        "5.88688e+01",
        "+5.88688e+01",
        "5.88688e+01",
        "58.86878",
        "58.86878",
        "+58.86878",
        "58.8688",
        "58.8688",
        "+58.8688",
        "5.886878e+01",
        "+5.886878e+01",
        "5.886878e+01",
        "58.868784",
        "58.868784",
        "+58.868784",
        "58.86878",
        "58.86878",
        "+58.86878",
        "5.8868784e+01",
        "+5.8868784e+01",
        "5.8868784e+01",
        "58.8687844",
        "58.8687844",
        "+58.8687844",
        "58.868784",
        "58.868784",
        "+58.868784",
        "5.88687844e+01",
        "+5.88687844e+01",
        "5.88687844e+01",
        "58.86878443",
        "58.86878443",
        "+58.86878443",
        "58.8687844",
        "58.8687844",
        "+58.8687844",
        "5.886878443e+01",
        "+5.886878443e+01",
        "5.886878443e+01",
        "58.868784428",
        "58.868784428",
        "+58.868784428",
        "58.86878443",
        "58.86878443",
        "+58.86878443",
        "5.8868784428e+01",
        "+5.8868784428e+01",
        "5.8868784428e+01",
        "58.8687844276",
        "58.8687844276",
        "+58.8687844276",
        "58.868784428",
        "58.868784428",
        "+58.868784428",
        "5.88687844276e+01",
        "+5.88687844276e+01",
        "5.88687844276e+01",
        "58.86878442764",
        "58.86878442764",
        "+58.86878442764",
        "58.8687844276",
        "58.8687844276",
        "+58.8687844276",
        "5.886878442764e+01",
        "+5.886878442764e+01",
        "5.886878442764e+01",
        "58.868784427643",
        "58.868784427643",
        "+58.868784427643",
        "58.86878442764",
        "58.86878442764",
        "+58.86878442764",
        "5.8868784427643e+01",
        "+5.8868784427643e+01",
        "5.8868784427643e+01",
        "58.8687844276428",
        "58.8687844276428",
        "+58.8687844276428",
    }},
    {{
        "-6e+01",
        "-6.e+01",
        "-6e+01",
        "-5.9e+01",
        "-5.9e+01",
        "-5.9e+01",
        "-58.9",
        "-58.9",
        "-58.9",
        "-59",
        "-59.",
        "-59",
        "-5.89e+01",
        "-5.89e+01",
        "-5.89e+01",
        "-58.87",
        "-58.87",
        "-58.87",
        "-58.9",
        "-58.9",
        "-58.9",
        "-5.887e+01",
        "-5.887e+01",
        "-5.887e+01",
        "-58.869",
        "-58.869",
        "-58.869",
        "-58.87",
        "-58.87",
        "-58.87",
        "-5.8869e+01",
        "-5.8869e+01",
        "-5.8869e+01",
        "-58.8688",
        "-58.8688",
        "-58.8688",
        "-58.869",
        "-58.869",
        "-58.869",
        "-5.88688e+01",
        "-5.88688e+01",
        "-5.88688e+01",
        "-58.86878",
        "-58.86878",
        "-58.86878",
        "-58.8688",
        "-58.8688",
        "-58.8688",
        "-5.886878e+01",
        "-5.886878e+01",
        "-5.886878e+01",
        "-58.868784",
        "-58.868784",
        "-58.868784",
        "-58.86878",
        "-58.86878",
        "-58.86878",
        "-5.8868784e+01",
        "-5.8868784e+01",
        "-5.8868784e+01",
        "-58.8687844",
        "-58.8687844",
        "-58.8687844",
        "-58.868784",
        "-58.868784",
        "-58.868784",
        "-5.88687844e+01",
        "-5.88687844e+01",
        "-5.88687844e+01",
        "-58.86878443",
        "-58.86878443",
        "-58.86878443",
        "-58.8687844",
        "-58.8687844",
        "-58.8687844",
        "-5.886878443e+01",
        "-5.886878443e+01",
        "-5.886878443e+01",
        "-58.868784428",
        "-58.868784428",
        "-58.868784428",
        "-58.86878443",
        "-58.86878443",
        "-58.86878443",
        "-5.8868784428e+01",
        "-5.8868784428e+01",
        "-5.8868784428e+01",
        "-58.8687844276",
        "-58.8687844276",
        "-58.8687844276",
        "-58.868784428",
        "-58.868784428",
        "-58.868784428",
        "-5.88687844276e+01",
        "-5.88687844276e+01",
        "-5.88687844276e+01",
        "-58.86878442764",
        "-58.86878442764",
        "-58.86878442764",
        "-58.8687844276",
        "-58.8687844276",
        "-58.8687844276",
        "-5.886878442764e+01",
        "-5.886878442764e+01",
        "-5.886878442764e+01",
        "-58.868784427643",
        "-58.868784427643",
        "-58.868784427643",
        "-58.86878442764",
        "-58.86878442764",
        "-58.86878442764",
        "-5.8868784427643e+01",
        "-5.8868784427643e+01",
        "-5.8868784427643e+01",
        "-58.8687844276428",
        "-58.8687844276428",
        "-58.8687844276428",
    }},
    {{
        "7",
        "7.",
        "+7",
        "7.4e+00",
        "+7.4e+00",
        "7.4e+00",
        "7.4",
        "7.4",
        "+7.4",
        "7.4",
        "7.4",
        "+7.4",
        "7.36e+00",
        "+7.36e+00",
        "7.36e+00",
        "7.36",
        "7.36",
        "+7.36",
        "7.36",
        "7.36",
        "+7.36",
        "7.359e+00",
        "+7.359e+00",
        "7.359e+00",
        "7.359",
        "7.359",
        "+7.359",
        "7.359",
        "7.359",
        "+7.359",
        "7.3586e+00",
        "+7.3586e+00",
        "7.3586e+00",
        "7.3586",
        "7.3586",
        "+7.3586",
        "7.3586",
        "7.3586",
        "+7.3586",
        "7.35860e+00",
        "+7.35860e+00",
        "7.35860e+00",
        "7.35860",
        "7.35860",
        "+7.35860",
        "7.3586",
        "7.35860",
        "+7.3586",
        "7.358598e+00",
        "+7.358598e+00",
        "7.358598e+00",
        "7.358598",
        "7.358598",
        "+7.358598",
        "7.358598",
        "7.358598",
        "+7.358598",
        "7.3585981e+00",
        "+7.3585981e+00",
        "7.3585981e+00",
        "7.3585981",
        "7.3585981",
        "+7.3585981",
        "7.3585981",
        "7.3585981",
        "+7.3585981",
        "7.35859805e+00",
        "+7.35859805e+00",
        "7.35859805e+00",
        "7.35859805",
        "7.35859805",
        "+7.35859805",
        "7.35859805",
        "7.35859805",
        "+7.35859805",
        "7.358598053e+00",
        "+7.358598053e+00",
        "7.358598053e+00",
        "7.358598053",
        "7.358598053",
        "+7.358598053",
        "7.358598053",
        "7.358598053",
        "+7.358598053",
        "7.3585980535e+00",
        "+7.3585980535e+00",
        "7.3585980535e+00",
        "7.3585980535",
        "7.3585980535",
        "+7.3585980535",
        "7.3585980535",
        "7.3585980535",
        "+7.3585980535",
        "7.35859805346e+00",
        "+7.35859805346e+00",
        "7.35859805346e+00",
        "7.35859805346",
        "7.35859805346",
        "+7.35859805346",
        "7.35859805346",
        "7.35859805346",
        "+7.35859805346",
        "7.358598053455e+00",
        "+7.358598053455e+00",
        "7.358598053455e+00",
        "7.358598053455",
        "7.358598053455",
        "+7.358598053455",
        "7.358598053455",
        "7.358598053455",
        "+7.358598053455",
        "7.3585980534554e+00",
        "+7.3585980534554e+00",
        "7.3585980534554e+00",
        "7.3585980534554",
        "7.3585980534554",
        "+7.3585980534554",
    }},
    {{
        "-7",
        "-7.",
        "-7",
        "-7.4e+00",
        "-7.4e+00",
        "-7.4e+00",
        "-7.4",
        "-7.4",
        "-7.4",
        "-7.4",
        "-7.4",
        "-7.4",
        "-7.36e+00",
        "-7.36e+00",
        "-7.36e+00",
        "-7.36",
        "-7.36",
        "-7.36",
        "-7.36",
        "-7.36",
        "-7.36",
        "-7.359e+00",
        "-7.359e+00",
        "-7.359e+00",
        "-7.359",
        "-7.359",
        "-7.359",
        "-7.359",
        "-7.359",
        "-7.359",
        "-7.3586e+00",
        "-7.3586e+00",
        "-7.3586e+00",
        "-7.3586",
        "-7.3586",
        "-7.3586",
        "-7.3586",
        "-7.3586",
        "-7.3586",
        "-7.35860e+00",
        "-7.35860e+00",
        "-7.35860e+00",
        "-7.35860",
        "-7.35860",
        "-7.35860",
        "-7.3586",
        "-7.35860",
        "-7.3586",
        "-7.358598e+00",
        "-7.358598e+00",
        "-7.358598e+00",
        "-7.358598",
        "-7.358598",
        "-7.358598",
        "-7.358598",
        "-7.358598",
        "-7.358598",
        "-7.3585981e+00",
        "-7.3585981e+00",
        "-7.3585981e+00",
        "-7.3585981",
        "-7.3585981",
        "-7.3585981",
        "-7.3585981",
        "-7.3585981",
        "-7.3585981",
        "-7.35859805e+00",
        "-7.35859805e+00",
        "-7.35859805e+00",
        "-7.35859805",
        "-7.35859805",
        "-7.35859805",
        "-7.35859805",
        "-7.35859805",
        "-7.35859805",
        "-7.358598053e+00",
        "-7.358598053e+00",
        "-7.358598053e+00",
        "-7.358598053",
        "-7.358598053",
        "-7.358598053",
        "-7.358598053",
        "-7.358598053",
        "-7.358598053",
        "-7.3585980535e+00",
        "-7.3585980535e+00",
        "-7.3585980535e+00",
        "-7.3585980535",
        "-7.3585980535",
        "-7.3585980535",
        "-7.3585980535",
        "-7.3585980535",
        "-7.3585980535",
        "-7.35859805346e+00",
        "-7.35859805346e+00",
        "-7.35859805346e+00",
        "-7.35859805346",
        "-7.35859805346",
        "-7.35859805346",
        "-7.35859805346",
        "-7.35859805346",
        "-7.35859805346",
        "-7.358598053455e+00",
        "-7.358598053455e+00",
        "-7.358598053455e+00",
        "-7.358598053455",
        "-7.358598053455",
        "-7.358598053455",
        "-7.358598053455",
        "-7.358598053455",
        "-7.358598053455",
        "-7.3585980534554e+00",
        "-7.3585980534554e+00",
        "-7.3585980534554e+00",
        "-7.3585980534554",
        "-7.3585980534554",
        "-7.3585980534554",
    }},
    {{
        "0.9",
        "0.9",
        "+0.9",
        "9.2e-01",
        "+9.2e-01",
        "9.2e-01",
        "0.9",
        "0.9",
        "+0.9",
        "0.92",
        "0.92",
        "+0.92",
        "9.20e-01",
        "+9.20e-01",
        "9.20e-01",
        "0.92",
        "0.92",
        "+0.92",
        "0.92",
        "0.920",
        "+0.92",
        "9.198e-01",
        "+9.198e-01",
        "9.198e-01",
        "0.920",
        "0.920",
        "+0.920",
        "0.9198",
        "0.9198",
        "+0.9198",
        "9.1982e-01",
        "+9.1982e-01",
        "9.1982e-01",
        "0.9198",
        "0.9198",
        "+0.9198",
        "0.91982",
        "0.91982",
        "+0.91982",
        "9.19825e-01",
        "+9.19825e-01",
        "9.19825e-01",
        "0.91982",
        "0.91982",
        "+0.91982",
        "0.919825",
        "0.919825",
        "+0.919825",
        "9.198248e-01",
        "+9.198248e-01",
        "9.198248e-01",
        "0.919825",
        "0.919825",
        "+0.919825",
        "0.9198248",
        "0.9198248",
        "+0.9198248",
        "9.1982476e-01",
        "+9.1982476e-01",
        "9.1982476e-01",
        "0.9198248",
        "0.9198248",
        "+0.9198248",
        "0.91982476",
        "0.91982476",
        "+0.91982476",
        "9.19824757e-01",
        "+9.19824757e-01",
        "9.19824757e-01",
        "0.91982476",
        "0.91982476",
        "+0.91982476",
        "0.919824757",
        "0.919824757",
        "+0.919824757",
        "9.198247567e-01",
        "+9.198247567e-01",
        "9.198247567e-01",
        "0.919824757",
        "0.919824757",
        "+0.919824757",
        "0.9198247567",
        "0.9198247567",
        "+0.9198247567",
        "9.1982475668e-01",
        "+9.1982475668e-01",
        "9.1982475668e-01",
        "0.9198247567",
        "0.9198247567",
        "+0.9198247567",
        "0.91982475668",
        "0.91982475668",
        "+0.91982475668",
        "9.19824756682e-01",
        "+9.19824756682e-01",
        "9.19824756682e-01",
        "0.91982475668",
        "0.91982475668",
        "+0.91982475668",
        "0.919824756682",
        "0.919824756682",
        "+0.919824756682",
        "9.198247566819e-01",
        "+9.198247566819e-01",
        "9.198247566819e-01",
        "0.919824756682",
        "0.919824756682",
        "+0.919824756682",
        "0.9198247566819",
        "0.9198247566819",
        "+0.9198247566819",
        "9.1982475668192e-01",
        "+9.1982475668192e-01",
        "9.1982475668192e-01",
        "0.9198247566819",
        "0.9198247566819",
        "+0.9198247566819",
    }},
    {{
        "-0.9",
        "-0.9",
        "-0.9",
        "-9.2e-01",
        "-9.2e-01",
        "-9.2e-01",
        "-0.9",
        "-0.9",
        "-0.9",
        "-0.92",
        "-0.92",
        "-0.92",
        "-9.20e-01",
        "-9.20e-01",
        "-9.20e-01",
        "-0.92",
        "-0.92",
        "-0.92",
        "-0.92",
        "-0.920",
        "-0.92",
        "-9.198e-01",
        "-9.198e-01",
        "-9.198e-01",
        "-0.920",
        "-0.920",
        "-0.920",
        "-0.9198",
        "-0.9198",
        "-0.9198",
        "-9.1982e-01",
        "-9.1982e-01",
        "-9.1982e-01",
        "-0.9198",
        "-0.9198",
        "-0.9198",
        "-0.91982",
        "-0.91982",
        "-0.91982",
        "-9.19825e-01",
        "-9.19825e-01",
        "-9.19825e-01",
        "-0.91982",
        "-0.91982",
        "-0.91982",
        "-0.919825",
        "-0.919825",
        "-0.919825",
        "-9.198248e-01",
        "-9.198248e-01",
        "-9.198248e-01",
        "-0.919825",
        "-0.919825",
        "-0.919825",
        "-0.9198248",
        "-0.9198248",
        "-0.9198248",
        "-9.1982476e-01",
        "-9.1982476e-01",
        "-9.1982476e-01",
        "-0.9198248",
        "-0.9198248",
        "-0.9198248",
        "-0.91982476",
        "-0.91982476",
        "-0.91982476",
        "-9.19824757e-01",
        "-9.19824757e-01",
        "-9.19824757e-01",
        "-0.91982476",
        "-0.91982476",
        "-0.91982476",
        "-0.919824757",
        "-0.919824757",
        "-0.919824757",
        "-9.198247567e-01",
        "-9.198247567e-01",
        "-9.198247567e-01",
        "-0.919824757",
        "-0.919824757",
        "-0.919824757",
        "-0.9198247567",
        "-0.9198247567",
        "-0.9198247567",
        "-9.1982475668e-01",
        "-9.1982475668e-01",
        "-9.1982475668e-01",
        "-0.9198247567",
        "-0.9198247567",
        "-0.9198247567",
        "-0.91982475668",
        "-0.91982475668",
        "-0.91982475668",
        "-9.19824756682e-01",
        "-9.19824756682e-01",
        "-9.19824756682e-01",
        "-0.91982475668",
        "-0.91982475668",
        "-0.91982475668",
        "-0.919824756682",
        "-0.919824756682",
        "-0.919824756682",
        "-9.198247566819e-01",
        "-9.198247566819e-01",
        "-9.198247566819e-01",
        "-0.919824756682",
        "-0.919824756682",
        "-0.919824756682",
        "-0.9198247566819",
        "-0.9198247566819",
        "-0.9198247566819",
        "-9.1982475668192e-01",
        "-9.1982475668192e-01",
        "-9.1982475668192e-01",
        "-0.9198247566819",
        "-0.9198247566819",
        "-0.9198247566819",
    }},
    {{
        "0.1",
        "0.1",
        "+0.1",
        "1.1e-01",
        "+1.1e-01",
        "1.1e-01",
        "0.1",
        "0.1",
        "+0.1",
        "0.11",
        "0.11",
        "+0.11",
        "1.15e-01",
        "+1.15e-01",
        "1.15e-01",
        "0.11",
        "0.11",
        "+0.11",
        "0.115",
        "0.115",
        "+0.115",
        "1.150e-01",
        "+1.150e-01",
        "1.150e-01",
        "0.115",
        "0.115",
        "+0.115",
        "0.115",
        "0.1150",
        "+0.115",
        "1.1498e-01",
        "+1.1498e-01",
        "1.1498e-01",
        "0.1150",
        "0.1150",
        "+0.1150",
        "0.11498",
        "0.11498",
        "+0.11498",
        "1.14978e-01",
        "+1.14978e-01",
        "1.14978e-01",
        "0.11498",
        "0.11498",
        "+0.11498",
        "0.114978",
        "0.114978",
        "+0.114978",
        "1.149781e-01",
        "+1.149781e-01",
        "1.149781e-01",
        "0.114978",
        "0.114978",
        "+0.114978",
        "0.1149781",
        "0.1149781",
        "+0.1149781",
        "1.1497809e-01",
        "+1.1497809e-01",
        "1.1497809e-01",
        "0.1149781",
        "0.1149781",
        "+0.1149781",
        "0.11497809",
        "0.11497809",
        "+0.11497809",
        "1.14978095e-01",
        "+1.14978095e-01",
        "1.14978095e-01",
        "0.11497809",
        "0.11497809",
        "+0.11497809",
        "0.114978095",
        "0.114978095",
        "+0.114978095",
        "1.149780946e-01",
        "+1.149780946e-01",
        "1.149780946e-01",
        "0.114978095",
        "0.114978095",
        "+0.114978095",
        "0.1149780946",
        "0.1149780946",
        "+0.1149780946",
        "1.1497809459e-01",
        "+1.1497809459e-01",
        "1.1497809459e-01",
        "0.1149780946",
        "0.1149780946",
        "+0.1149780946",
        "0.11497809459",
        "0.11497809459",
        "+0.11497809459",
        "1.14978094585e-01",
        "+1.14978094585e-01",
        "1.14978094585e-01",
        "0.11497809459",
        "0.11497809459",
        "+0.11497809459",
        "0.114978094585",
        "0.114978094585",
        "+0.114978094585",
        "1.149780945852e-01",
        "+1.149780945852e-01",
        "1.149780945852e-01",
        "0.114978094585",
        "0.114978094585",
        "+0.114978094585",
        "0.1149780945852",
        "0.1149780945852",
        "+0.1149780945852",
        "1.1497809458524e-01",
        "+1.1497809458524e-01",
        "1.1497809458524e-01",
        "0.1149780945852",
        "0.1149780945852",
        "+0.1149780945852",
    }},
    {{
        "-0.1",
        "-0.1",
        "-0.1",
        "-1.1e-01",
        "-1.1e-01",
        "-1.1e-01",
        "-0.1",
        "-0.1",
        "-0.1",
        "-0.11",
        "-0.11",
        "-0.11",
        "-1.15e-01",
        "-1.15e-01",
        "-1.15e-01",
        "-0.11",
        "-0.11",
        "-0.11",
        "-0.115",
        "-0.115",
        "-0.115",
        "-1.150e-01",
        "-1.150e-01",
        "-1.150e-01",
        "-0.115",
        "-0.115",
        "-0.115",
        "-0.115",
        "-0.1150",
        "-0.115",
        "-1.1498e-01",
        "-1.1498e-01",
        "-1.1498e-01",
        "-0.1150",
        "-0.1150",
        "-0.1150",
        "-0.11498",
        "-0.11498",
        "-0.11498",
        "-1.14978e-01",
        "-1.14978e-01",
        "-1.14978e-01",
        "-0.11498",
        "-0.11498",
        "-0.11498",
        "-0.114978",
        "-0.114978",
        "-0.114978",
        "-1.149781e-01",
        "-1.149781e-01",
        "-1.149781e-01",
        "-0.114978",
        "-0.114978",
        "-0.114978",
        "-0.1149781",
        "-0.1149781",
        "-0.1149781",
        "-1.1497809e-01",
        "-1.1497809e-01",
        "-1.1497809e-01",
        "-0.1149781",
        "-0.1149781",
        "-0.1149781",
        "-0.11497809",
        "-0.11497809",
        "-0.11497809",
        "-1.14978095e-01",
        "-1.14978095e-01",
        "-1.14978095e-01",
        "-0.11497809",
        "-0.11497809",
        "-0.11497809",
        "-0.114978095",
        "-0.114978095",
        "-0.114978095",
        "-1.149780946e-01",
        "-1.149780946e-01",
        "-1.149780946e-01",
        "-0.114978095",
        "-0.114978095",
        "-0.114978095",
        "-0.1149780946",
        "-0.1149780946",
        "-0.1149780946",
        "-1.1497809459e-01",
        "-1.1497809459e-01",
        "-1.1497809459e-01",
        "-0.1149780946",
        "-0.1149780946",
        "-0.1149780946",
        "-0.11497809459",
        "-0.11497809459",
        "-0.11497809459",
        "-1.14978094585e-01",
        "-1.14978094585e-01",
        "-1.14978094585e-01",
        "-0.11497809459",
        "-0.11497809459",
        "-0.11497809459",
        "-0.114978094585",
        "-0.114978094585",
        "-0.114978094585",
        "-1.149780945852e-01",
        "-1.149780945852e-01",
        "-1.149780945852e-01",
        "-0.114978094585",
        "-0.114978094585",
        "-0.114978094585",
        "-0.1149780945852",
        "-0.1149780945852",
        "-0.1149780945852",
        "-1.1497809458524e-01",
        "-1.1497809458524e-01",
        "-1.1497809458524e-01",
        "-0.1149780945852",
        "-0.1149780945852",
        "-0.1149780945852",
    }},
    {{
        "0.01",
        "0.01",
        "+0.01",
        "1.4e-02",
        "+1.4e-02",
        "1.4e-02",
        "0.0",
        "0.0",
        "+0.0",
        "0.014",
        "0.014",
        "+0.014",
        "1.44e-02",
        "+1.44e-02",
        "1.44e-02",
        "0.01",
        "0.01",
        "+0.01",
        "0.0144",
        "0.0144",
        "+0.0144",
        "1.437e-02",
        "+1.437e-02",
        "1.437e-02",
        "0.014",
        "0.014",
        "+0.014",
        "0.01437",
        "0.01437",
        "+0.01437",
        "1.4372e-02",
        "+1.4372e-02",
        "1.4372e-02",
        "0.0144",
        "0.0144",
        "+0.0144",
        "0.014372",
        "0.014372",
        "+0.014372",
        "1.43723e-02",
        "+1.43723e-02",
        "1.43723e-02",
        "0.01437",
        "0.01437",
        "+0.01437",
        "0.0143723",
        "0.0143723",
        "+0.0143723",
        "1.437226e-02",
        "+1.437226e-02",
        "1.437226e-02",
        "0.014372",
        "0.014372",
        "+0.014372",
        "0.01437226",
        "0.01437226",
        "+0.01437226",
        "1.4372262e-02",
        "+1.4372262e-02",
        "1.4372262e-02",
        "0.0143723",
        "0.0143723",
        "+0.0143723",
        "0.014372262",
        "0.014372262",
        "+0.014372262",
        "1.43722618e-02",
        "+1.43722618e-02",
        "1.43722618e-02",
        "0.01437226",
        "0.01437226",
        "+0.01437226",
        "0.0143722618",
        "0.0143722618",
        "+0.0143722618",
        "1.437226182e-02",
        "+1.437226182e-02",
        "1.437226182e-02",
        "0.014372262",
        "0.014372262",
        "+0.014372262",
        "0.01437226182",
        "0.01437226182",
        "+0.01437226182",
        "1.4372261823e-02",
        "+1.4372261823e-02",
        "1.4372261823e-02",
        "0.0143722618",
        "0.0143722618",
        "+0.0143722618",
        "0.014372261823",
        "0.014372261823",
        "+0.014372261823",
        "1.43722618232e-02",
        "+1.43722618232e-02",
        "1.43722618232e-02",
        "0.01437226182",
        "0.01437226182",
        "+0.01437226182",
        "0.0143722618232",
        "0.0143722618232",
        "+0.0143722618232",
        "1.437226182315e-02",
        "+1.437226182315e-02",
        "1.437226182315e-02",
        "0.014372261823",
        "0.014372261823",
        "+0.014372261823",
        "0.01437226182315",
        "0.01437226182315",
        "+0.01437226182315",
        "1.4372261823155e-02",
        "+1.4372261823155e-02",
        "1.4372261823155e-02",
        "0.0143722618232",
        "0.0143722618232",
        "+0.0143722618232",
    }},
    {{
        "-0.01",
        "-0.01",
        "-0.01",
        "-1.4e-02",
        "-1.4e-02",
        "-1.4e-02",
        "-0.0",
        "-0.0",
        "-0.0",
        "-0.014",
        "-0.014",
        "-0.014",
        "-1.44e-02",
        "-1.44e-02",
        "-1.44e-02",
        "-0.01",
        "-0.01",
        "-0.01",
        "-0.0144",
        "-0.0144",
        "-0.0144",
        "-1.437e-02",
        "-1.437e-02",
        "-1.437e-02",
        "-0.014",
        "-0.014",
        "-0.014",
        "-0.01437",
        "-0.01437",
        "-0.01437",
        "-1.4372e-02",
        "-1.4372e-02",
        "-1.4372e-02",
        "-0.0144",
        "-0.0144",
        "-0.0144",
        "-0.014372",
        "-0.014372",
        "-0.014372",
        "-1.43723e-02",
        "-1.43723e-02",
        "-1.43723e-02",
        "-0.01437",
        "-0.01437",
        "-0.01437",
        "-0.0143723",
        "-0.0143723",
        "-0.0143723",
        "-1.437226e-02",
        "-1.437226e-02",
        "-1.437226e-02",
        "-0.014372",
        "-0.014372",
        "-0.014372",
        "-0.01437226",
        "-0.01437226",
        "-0.01437226",
        "-1.4372262e-02",
        "-1.4372262e-02",
        "-1.4372262e-02",
        "-0.0143723",
        "-0.0143723",
        "-0.0143723",
        "-0.014372262",
        "-0.014372262",
        "-0.014372262",
        "-1.43722618e-02",
        "-1.43722618e-02",
        "-1.43722618e-02",
        "-0.01437226",
        "-0.01437226",
        "-0.01437226",
        "-0.0143722618",
        "-0.0143722618",
        "-0.0143722618",
        "-1.437226182e-02",
        "-1.437226182e-02",
        "-1.437226182e-02",
        "-0.014372262",
        "-0.014372262",
        "-0.014372262",
        "-0.01437226182",
        "-0.01437226182",
        "-0.01437226182",
        "-1.4372261823e-02",
        "-1.4372261823e-02",
        "-1.4372261823e-02",
        "-0.0143722618",
        "-0.0143722618",
        "-0.0143722618",
        "-0.014372261823",
        "-0.014372261823",
        "-0.014372261823",
        "-1.43722618232e-02",
        "-1.43722618232e-02",
        "-1.43722618232e-02",
        "-0.01437226182",
        "-0.01437226182",
        "-0.01437226182",
        "-0.0143722618232",
        "-0.0143722618232",
        "-0.0143722618232",
        "-1.437226182315e-02",
        "-1.437226182315e-02",
        "-1.437226182315e-02",
        "-0.014372261823",
        "-0.014372261823",
        "-0.014372261823",
        "-0.01437226182315",
        "-0.01437226182315",
        "-0.01437226182315",
        "-1.4372261823155e-02",
        "-1.4372261823155e-02",
        "-1.4372261823155e-02",
        "-0.0143722618232",
        "-0.0143722618232",
        "-0.0143722618232",
    }},
    {{
        "0.002",
        "0.002",
        "+0.002",
        "1.8e-03",
        "+1.8e-03",
        "1.8e-03",
        "0.0",
        "0.0",
        "+0.0",
        "0.0018",
        "0.0018",
        "+0.0018",
        "1.80e-03",
        "+1.80e-03",
        "1.80e-03",
        "0.00",
        "0.00",
        "+0.00",
        "0.0018",
        "0.00180",
        "+0.0018",
        "1.797e-03",
        "+1.797e-03",
        "1.797e-03",
        "0.002",
        "0.002",
        "+0.002",
        "0.001797",
        "0.001797",
        "+0.001797",
        "1.7965e-03",
        "+1.7965e-03",
        "1.7965e-03",
        "0.0018",
        "0.0018",
        "+0.0018",
        "0.0017965",
        "0.0017965",
        "+0.0017965",
        "1.79653e-03",
        "+1.79653e-03",
        "1.79653e-03",
        "0.00180",
        "0.00180",
        "+0.00180",
        "0.00179653",
        "0.00179653",
        "+0.00179653",
        "1.796533e-03",
        "+1.796533e-03",
        "1.796533e-03",
        "0.001797",
        "0.001797",
        "+0.001797",
        "0.001796533",
        "0.001796533",
        "+0.001796533",
        "1.7965327e-03",
        "+1.7965327e-03",
        "1.7965327e-03",
        "0.0017965",
        "0.0017965",
        "+0.0017965",
        "0.0017965327",
        "0.0017965327",
        "+0.0017965327",
        "1.79653273e-03",
        "+1.79653273e-03",
        "1.79653273e-03",
        "0.00179653",
        "0.00179653",
        "+0.00179653",
        "0.00179653273",
        "0.00179653273",
        "+0.00179653273",
        "1.796532728e-03",
        "+1.796532728e-03",
        "1.796532728e-03",
        "0.001796533",
        "0.001796533",
        "+0.001796533",
        "0.001796532728",
        "0.001796532728",
        "+0.001796532728",
        "1.7965327279e-03",
        "+1.7965327279e-03",
        "1.7965327279e-03",
        "0.0017965327",
        "0.0017965327",
        "+0.0017965327",
        "0.0017965327279",
        "0.0017965327279",
        "+0.0017965327279",
        "1.79653272789e-03",
        "+1.79653272789e-03",
        "1.79653272789e-03",
        "0.00179653273",
        "0.00179653273",
        "+0.00179653273",
        "0.00179653272789",
        "0.00179653272789",
        "+0.00179653272789",
        "1.796532727894e-03",
        "+1.796532727894e-03",
        "1.796532727894e-03",
        "0.001796532728",
        "0.001796532728",
        "+0.001796532728",
        "0.001796532727894",
        "0.001796532727894",
        "+0.001796532727894",
        "1.7965327278944e-03",
        "+1.7965327278944e-03",
        "1.7965327278944e-03",
        "0.0017965327279",
        "0.0017965327279",
        "+0.0017965327279",
    }},
    {{
        "-0.002",
        "-0.002",
        "-0.002",
        "-1.8e-03",
        "-1.8e-03",
        "-1.8e-03",
        "-0.0",
        "-0.0",
        "-0.0",
        "-0.0018",
        "-0.0018",
        "-0.0018",
        "-1.80e-03",
        "-1.80e-03",
        "-1.80e-03",
        "-0.00",
        "-0.00",
        "-0.00",
        "-0.0018",
        "-0.00180",
        "-0.0018",
        "-1.797e-03",
        "-1.797e-03",
        "-1.797e-03",
        "-0.002",
        "-0.002",
        "-0.002",
        "-0.001797",
        "-0.001797",
        "-0.001797",
        "-1.7965e-03",
        "-1.7965e-03",
        "-1.7965e-03",
        "-0.0018",
        "-0.0018",
        "-0.0018",
        "-0.0017965",
        "-0.0017965",
        "-0.0017965",
        "-1.79653e-03",
        "-1.79653e-03",
        "-1.79653e-03",
        "-0.00180",
        "-0.00180",
        "-0.00180",
        "-0.00179653",
        "-0.00179653",
        "-0.00179653",
        "-1.796533e-03",
        "-1.796533e-03",
        "-1.796533e-03",
        "-0.001797",
        "-0.001797",
        "-0.001797",
        "-0.001796533",
        "-0.001796533",
        "-0.001796533",
        "-1.7965327e-03",
        "-1.7965327e-03",
        "-1.7965327e-03",
        "-0.0017965",
        "-0.0017965",
        "-0.0017965",
        "-0.0017965327",
        "-0.0017965327",
        "-0.0017965327",
        "-1.79653273e-03",
        "-1.79653273e-03",
        "-1.79653273e-03",
        "-0.00179653",
        "-0.00179653",
        "-0.00179653",
        "-0.00179653273",
        "-0.00179653273",
        "-0.00179653273",
        "-1.796532728e-03",
        "-1.796532728e-03",
        "-1.796532728e-03",
        "-0.001796533",
        "-0.001796533",
        "-0.001796533",
        "-0.001796532728",
        "-0.001796532728",
        "-0.001796532728",
        "-1.7965327279e-03",
        "-1.7965327279e-03",
        "-1.7965327279e-03",
        "-0.0017965327",
        "-0.0017965327",
        "-0.0017965327",
        "-0.0017965327279",
        "-0.0017965327279",
        "-0.0017965327279",
        "-1.79653272789e-03",
        "-1.79653272789e-03",
        "-1.79653272789e-03",
        "-0.00179653273",
        "-0.00179653273",
        "-0.00179653273",
        "-0.00179653272789",
        "-0.00179653272789",
        "-0.00179653272789",
        "-1.796532727894e-03",
        "-1.796532727894e-03",
        "-1.796532727894e-03",
        "-0.001796532728",
        "-0.001796532728",
        "-0.001796532728",
        "-0.001796532727894",
        "-0.001796532727894",
        "-0.001796532727894",
        "-1.7965327278944e-03",
        "-1.7965327278944e-03",
        "-1.7965327278944e-03",
        "-0.0017965327279",
        "-0.0017965327279",
        "-0.0017965327279",
    }},
    {{
        "0.0002",
        "0.0002",
        "+0.0002",
        "2.2e-04",
        "+2.2e-04",
        "2.2e-04",
        "0.0",
        "0.0",
        "+0.0",
        "0.00022",
        "0.00022",
        "+0.00022",
        "2.25e-04",
        "+2.25e-04",
        "2.25e-04",
        "0.00",
        "0.00",
        "+0.00",
        "0.000225",
        "0.000225",
        "+0.000225",
        "2.246e-04",
        "+2.246e-04",
        "2.246e-04",
        "0.000",
        "0.000",
        "+0.000",
        "0.0002246",
        "0.0002246",
        "+0.0002246",
        "2.2457e-04",
        "+2.2457e-04",
        "2.2457e-04",
        "0.0002",
        "0.0002",
        "+0.0002",
        "0.00022457",
        "0.00022457",
        "+0.00022457",
        "2.24567e-04",
        "+2.24567e-04",
        "2.24567e-04",
        "0.00022",
        "0.00022",
        "+0.00022",
        "0.000224567",
        "0.000224567",
        "+0.000224567",
        "2.245666e-04",
        "+2.245666e-04",
        "2.245666e-04",
        "0.000225",
        "0.000225",
        "+0.000225",
        "0.0002245666",
        "0.0002245666",
        "+0.0002245666",
        "2.2456659e-04",
        "+2.2456659e-04",
        "2.2456659e-04",
        "0.0002246",
        "0.0002246",
        "+0.0002246",
        "0.00022456659",
        "0.00022456659",
        "+0.00022456659",
        "2.24566591e-04",
        "+2.24566591e-04",
        "2.24566591e-04",
        "0.00022457",
        "0.00022457",
        "+0.00022457",
        "0.000224566591",
        "0.000224566591",
        "+0.000224566591",
        "2.245665910e-04",
        "+2.245665910e-04",
        "2.245665910e-04",
        "0.000224567",
        "0.000224567",
        "+0.000224567",
        "0.000224566591",
        "0.0002245665910",
        "+0.000224566591",
        "2.2456659099e-04",
        "+2.2456659099e-04",
        "2.2456659099e-04",
        "0.0002245666",
        "0.0002245666",
        "+0.0002245666",
        "0.00022456659099",
        "0.00022456659099",
        "+0.00022456659099",
        "2.24566590987e-04",
        "+2.24566590987e-04",
        "2.24566590987e-04",
        "0.00022456659",
        "0.00022456659",
        "+0.00022456659",
        "0.000224566590987",
        "0.000224566590987",
        "+0.000224566590987",
        "2.245665909868e-04",
        "+2.245665909868e-04",
        "2.245665909868e-04",
        "0.000224566591",
        "0.000224566591",
        "+0.000224566591",
        "0.0002245665909868",
        "0.0002245665909868",
        "+0.0002245665909868",
        "2.2456659098680e-04",
        "+2.2456659098680e-04",
        "2.2456659098680e-04",
        "0.0002245665910",
        "0.0002245665910",
        "+0.0002245665910",
    }},
    {{
        "-0.0002",
        "-0.0002",
        "-0.0002",
        "-2.2e-04",
        "-2.2e-04",
        "-2.2e-04",
        "-0.0",
        "-0.0",
        "-0.0",
        "-0.00022",
        "-0.00022",
        "-0.00022",
        "-2.25e-04",
        "-2.25e-04",
        "-2.25e-04",
        "-0.00",
        "-0.00",
        "-0.00",
        "-0.000225",
        "-0.000225",
        "-0.000225",
        "-2.246e-04",
        "-2.246e-04",
        "-2.246e-04",
        "-0.000",
        "-0.000",
        "-0.000",
        "-0.0002246",
        "-0.0002246",
        "-0.0002246",
        "-2.2457e-04",
        "-2.2457e-04",
        "-2.2457e-04",
        "-0.0002",
        "-0.0002",
        "-0.0002",
        "-0.00022457",
        "-0.00022457",
        "-0.00022457",
        "-2.24567e-04",
        "-2.24567e-04",
        "-2.24567e-04",
        "-0.00022",
        "-0.00022",
        "-0.00022",
        "-0.000224567",
        "-0.000224567",
        "-0.000224567",
        "-2.245666e-04",
        "-2.245666e-04",
        "-2.245666e-04",
        "-0.000225",
        "-0.000225",
        "-0.000225",
        "-0.0002245666",
        "-0.0002245666",
        "-0.0002245666",
        "-2.2456659e-04",
        "-2.2456659e-04",
        "-2.2456659e-04",
        "-0.0002246",
        "-0.0002246",
        "-0.0002246",
        "-0.00022456659",
        "-0.00022456659",
        "-0.00022456659",
        "-2.24566591e-04",
        "-2.24566591e-04",
        "-2.24566591e-04",
        "-0.00022457",
        "-0.00022457",
        "-0.00022457",
        "-0.000224566591",
        "-0.000224566591",
        "-0.000224566591",
        "-2.245665910e-04",
        "-2.245665910e-04",
        "-2.245665910e-04",
        "-0.000224567",
        "-0.000224567",
        "-0.000224567",
        "-0.000224566591",
        "-0.0002245665910",
        "-0.000224566591",
        "-2.2456659099e-04",
        "-2.2456659099e-04",
        "-2.2456659099e-04",
        "-0.0002245666",
        "-0.0002245666",
        "-0.0002245666",
        "-0.00022456659099",
        "-0.00022456659099",
        "-0.00022456659099",
        "-2.24566590987e-04",
        "-2.24566590987e-04",
        "-2.24566590987e-04",
        "-0.00022456659",
        "-0.00022456659",
        "-0.00022456659",
        "-0.000224566590987",
        "-0.000224566590987",
        "-0.000224566590987",
        "-2.245665909868e-04",
        "-2.245665909868e-04",
        "-2.245665909868e-04",
        "-0.000224566591",
        "-0.000224566591",
        "-0.000224566591",
        "-0.0002245665909868",
        "-0.0002245665909868",
        "-0.0002245665909868",
        "-2.2456659098680e-04",
        "-2.2456659098680e-04",
        "-2.2456659098680e-04",
        "-0.0002245665910",
        "-0.0002245665910",
        "-0.0002245665910",
    }},
    {{
        "3e-05",
        "3.e-05",
        "+3e-05",
        "2.8e-05",
        "+2.8e-05",
        "2.8e-05",
        "0.0",
        "0.0",
        "+0.0",
        "2.8e-05",
        "2.8e-05",
        "+2.8e-05",
        "2.81e-05",
        "+2.81e-05",
        "2.81e-05",
        "0.00",
        "0.00",
        "+0.00",
        "2.81e-05",
        "2.81e-05",
        "+2.81e-05",
        "2.807e-05",
        "+2.807e-05",
        "2.807e-05",
        "0.000",
        "0.000",
        "+0.000",
        "2.807e-05",
        "2.807e-05",
        "+2.807e-05",
        "2.8071e-05",
        "+2.8071e-05",
        "2.8071e-05",
        "0.0000",
        "0.0000",
        "+0.0000",
        "2.8071e-05",
        "2.8071e-05",
        "+2.8071e-05",
        "2.80708e-05",
        "+2.80708e-05",
        "2.80708e-05",
        "0.00003",
        "0.00003",
        "+0.00003",
        "2.80708e-05",
        "2.80708e-05",
        "+2.80708e-05",
        "2.807082e-05",
        "+2.807082e-05",
        "2.807082e-05",
        "0.000028",
        "0.000028",
        "+0.000028",
        "2.807082e-05",
        "2.807082e-05",
        "+2.807082e-05",
        "2.8070824e-05",
        "+2.8070824e-05",
        "2.8070824e-05",
        "0.0000281",
        "0.0000281",
        "+0.0000281",
        "2.8070824e-05",
        "2.8070824e-05",
        "+2.8070824e-05",
        "2.80708239e-05",
        "+2.80708239e-05",
        "2.80708239e-05",
        "0.00002807",
        "0.00002807",
        "+0.00002807",
        "2.80708239e-05",
        "2.80708239e-05",
        "+2.80708239e-05",
        "2.807082387e-05",
        "+2.807082387e-05",
        "2.807082387e-05",
        "0.000028071",
        "0.000028071",
        "+0.000028071",
        "2.807082387e-05",
        "2.807082387e-05",
        "+2.807082387e-05",
        "2.8070823873e-05",
        "+2.8070823873e-05",
        "2.8070823873e-05",
        "0.0000280708",
        "0.0000280708",
        "+0.0000280708",
        "2.8070823873e-05",
        "2.8070823873e-05",
        "+2.8070823873e-05",
        "2.80708238733e-05",
        "+2.80708238733e-05",
        "2.80708238733e-05",
        "0.00002807082",
        "0.00002807082",
        "+0.00002807082",
        "2.80708238733e-05",
        "2.80708238733e-05",
        "+2.80708238733e-05",
        "2.807082387335e-05",
        "+2.807082387335e-05",
        "2.807082387335e-05",
        "0.000028070824",
        "0.000028070824",
        "+0.000028070824",
        "2.807082387335e-05",
        "2.807082387335e-05",
        "+2.807082387335e-05",
        "2.8070823873350e-05",
        "+2.8070823873350e-05",
        "2.8070823873350e-05",
        "0.0000280708239",
        "0.0000280708239",
        "+0.0000280708239",
    }},
    {{
        "-3e-05",
        "-3.e-05",
        "-3e-05",
        "-2.8e-05",
        "-2.8e-05",
        "-2.8e-05",
        "-0.0",
        "-0.0",
        "-0.0",
        "-2.8e-05",
        "-2.8e-05",
        "-2.8e-05",
        "-2.81e-05",
        "-2.81e-05",
        "-2.81e-05",
        "-0.00",
        "-0.00",
        "-0.00",
        "-2.81e-05",
        "-2.81e-05",
        "-2.81e-05",
        "-2.807e-05",
        "-2.807e-05",
        "-2.807e-05",
        "-0.000",
        "-0.000",
        "-0.000",
        "-2.807e-05",
        "-2.807e-05",
        "-2.807e-05",
        "-2.8071e-05",
        "-2.8071e-05",
        "-2.8071e-05",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-2.8071e-05",
        "-2.8071e-05",
        "-2.8071e-05",
        "-2.80708e-05",
        "-2.80708e-05",
        "-2.80708e-05",
        "-0.00003",
        "-0.00003",
        "-0.00003",
        "-2.80708e-05",
        "-2.80708e-05",
        "-2.80708e-05",
        "-2.807082e-05",
        "-2.807082e-05",
        "-2.807082e-05",
        "-0.000028",
        "-0.000028",
        "-0.000028",
        "-2.807082e-05",
        "-2.807082e-05",
        "-2.807082e-05",
        "-2.8070824e-05",
        "-2.8070824e-05",
        "-2.8070824e-05",
        "-0.0000281",
        "-0.0000281",
        "-0.0000281",
        "-2.8070824e-05",
        "-2.8070824e-05",
        "-2.8070824e-05",
        "-2.80708239e-05",
        "-2.80708239e-05",
        "-2.80708239e-05",
        "-0.00002807",
        "-0.00002807",
        "-0.00002807",
        "-2.80708239e-05",
        "-2.80708239e-05",
        "-2.80708239e-05",
        "-2.807082387e-05",
        "-2.807082387e-05",
        "-2.807082387e-05",
        "-0.000028071",
        "-0.000028071",
        "-0.000028071",
        "-2.807082387e-05",
        "-2.807082387e-05",
        "-2.807082387e-05",
        "-2.8070823873e-05",
        "-2.8070823873e-05",
        "-2.8070823873e-05",
        "-0.0000280708",
        "-0.0000280708",
        "-0.0000280708",
        "-2.8070823873e-05",
        "-2.8070823873e-05",
        "-2.8070823873e-05",
        "-2.80708238733e-05",
        "-2.80708238733e-05",
        "-2.80708238733e-05",
        "-0.00002807082",
        "-0.00002807082",
        "-0.00002807082",
        "-2.80708238733e-05",
        "-2.80708238733e-05",
        "-2.80708238733e-05",
        "-2.807082387335e-05",
        "-2.807082387335e-05",
        "-2.807082387335e-05",
        "-0.000028070824",
        "-0.000028070824",
        "-0.000028070824",
        "-2.807082387335e-05",
        "-2.807082387335e-05",
        "-2.807082387335e-05",
        "-2.8070823873350e-05",
        "-2.8070823873350e-05",
        "-2.8070823873350e-05",
        "-0.0000280708239",
        "-0.0000280708239",
        "-0.0000280708239",
    }},
    {{
        "4e-06",
        "4.e-06",
        "+4e-06",
        "3.5e-06",
        "+3.5e-06",
        "3.5e-06",
        "0.0",
        "0.0",
        "+0.0",
        "3.5e-06",
        "3.5e-06",
        "+3.5e-06",
        "3.51e-06",
        "+3.51e-06",
        "3.51e-06",
        "0.00",
        "0.00",
        "+0.00",
        "3.51e-06",
        "3.51e-06",
        "+3.51e-06",
        "3.509e-06",
        "+3.509e-06",
        "3.509e-06",
        "0.000",
        "0.000",
        "+0.000",
        "3.509e-06",
        "3.509e-06",
        "+3.509e-06",
        "3.5089e-06",
        "+3.5089e-06",
        "3.5089e-06",
        "0.0000",
        "0.0000",
        "+0.0000",
        "3.5089e-06",
        "3.5089e-06",
        "+3.5089e-06",
        "3.50885e-06",
        "+3.50885e-06",
        "3.50885e-06",
        "0.00000",
        "0.00000",
        "+0.00000",
        "3.50885e-06",
        "3.50885e-06",
        "+3.50885e-06",
        "3.508853e-06",
        "+3.508853e-06",
        "3.508853e-06",
        "0.000004",
        "0.000004",
        "+0.000004",
        "3.508853e-06",
        "3.508853e-06",
        "+3.508853e-06",
        "3.5088530e-06",
        "+3.5088530e-06",
        "3.5088530e-06",
        "0.0000035",
        "0.0000035",
        "+0.0000035",
        "3.508853e-06",
        "3.5088530e-06",
        "+3.508853e-06",
        "3.50885298e-06",
        "+3.50885298e-06",
        "3.50885298e-06",
        "0.00000351",
        "0.00000351",
        "+0.00000351",
        "3.50885298e-06",
        "3.50885298e-06",
        "+3.50885298e-06",
        "3.508852984e-06",
        "+3.508852984e-06",
        "3.508852984e-06",
        "0.000003509",
        "0.000003509",
        "+0.000003509",
        "3.508852984e-06",
        "3.508852984e-06",
        "+3.508852984e-06",
        "3.5088529842e-06",
        "+3.5088529842e-06",
        "3.5088529842e-06",
        "0.0000035089",
        "0.0000035089",
        "+0.0000035089",
        "3.5088529842e-06",
        "3.5088529842e-06",
        "+3.5088529842e-06",
        "3.50885298417e-06",
        "+3.50885298417e-06",
        "3.50885298417e-06",
        "0.00000350885",
        "0.00000350885",
        "+0.00000350885",
        "3.50885298417e-06",
        "3.50885298417e-06",
        "+3.50885298417e-06",
        "3.508852984169e-06",
        "+3.508852984169e-06",
        "3.508852984169e-06",
        "0.000003508853",
        "0.000003508853",
        "+0.000003508853",
        "3.508852984169e-06",
        "3.508852984169e-06",
        "+3.508852984169e-06",
        "3.5088529841687e-06",
        "+3.5088529841687e-06",
        "3.5088529841687e-06",
        "0.0000035088530",
        "0.0000035088530",
        "+0.0000035088530",
    }},
    {{
        "-4e-06",
        "-4.e-06",
        "-4e-06",
        "-3.5e-06",
        "-3.5e-06",
        "-3.5e-06",
        "-0.0",
        "-0.0",
        "-0.0",
        "-3.5e-06",
        "-3.5e-06",
        "-3.5e-06",
        "-3.51e-06",
        "-3.51e-06",
        "-3.51e-06",
        "-0.00",
        "-0.00",
        "-0.00",
        "-3.51e-06",
        "-3.51e-06",
        "-3.51e-06",
        "-3.509e-06",
        "-3.509e-06",
        "-3.509e-06",
        "-0.000",
        "-0.000",
        "-0.000",
        "-3.509e-06",
        "-3.509e-06",
        "-3.509e-06",
        "-3.5089e-06",
        "-3.5089e-06",
        "-3.5089e-06",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-3.5089e-06",
        "-3.5089e-06",
        "-3.5089e-06",
        "-3.50885e-06",
        "-3.50885e-06",
        "-3.50885e-06",
        "-0.00000",
        "-0.00000",
        "-0.00000",
        "-3.50885e-06",
        "-3.50885e-06",
        "-3.50885e-06",
        "-3.508853e-06",
        "-3.508853e-06",
        "-3.508853e-06",
        "-0.000004",
        "-0.000004",
        "-0.000004",
        "-3.508853e-06",
        "-3.508853e-06",
        "-3.508853e-06",
        "-3.5088530e-06",
        "-3.5088530e-06",
        "-3.5088530e-06",
        "-0.0000035",
        "-0.0000035",
        "-0.0000035",
        "-3.508853e-06",
        "-3.5088530e-06",
        "-3.508853e-06",
        "-3.50885298e-06",
        "-3.50885298e-06",
        "-3.50885298e-06",
        "-0.00000351",
        "-0.00000351",
        "-0.00000351",
        "-3.50885298e-06",
        "-3.50885298e-06",
        "-3.50885298e-06",
        "-3.508852984e-06",
        "-3.508852984e-06",
        "-3.508852984e-06",
        "-0.000003509",
        "-0.000003509",
        "-0.000003509",
        "-3.508852984e-06",
        "-3.508852984e-06",
        "-3.508852984e-06",
        "-3.5088529842e-06",
        "-3.5088529842e-06",
        "-3.5088529842e-06",
        "-0.0000035089",
        "-0.0000035089",
        "-0.0000035089",
        "-3.5088529842e-06",
        "-3.5088529842e-06",
        "-3.5088529842e-06",
        "-3.50885298417e-06",
        "-3.50885298417e-06",
        "-3.50885298417e-06",
        "-0.00000350885",
        "-0.00000350885",
        "-0.00000350885",
        "-3.50885298417e-06",
        "-3.50885298417e-06",
        "-3.50885298417e-06",
        "-3.508852984169e-06",
        "-3.508852984169e-06",
        "-3.508852984169e-06",
        "-0.000003508853",
        "-0.000003508853",
        "-0.000003508853",
        "-3.508852984169e-06",
        "-3.508852984169e-06",
        "-3.508852984169e-06",
        "-3.5088529841687e-06",
        "-3.5088529841687e-06",
        "-3.5088529841687e-06",
        "-0.0000035088530",
        "-0.0000035088530",
        "-0.0000035088530",
    }},
    {{
        "4e-07",
        "4.e-07",
        "+4e-07",
        "4.4e-07",
        "+4.4e-07",
        "4.4e-07",
        "0.0",
        "0.0",
        "+0.0",
        "4.4e-07",
        "4.4e-07",
        "+4.4e-07",
        "4.39e-07",
        "+4.39e-07",
        "4.39e-07",
        "0.00",
        "0.00",
        "+0.00",
        "4.39e-07",
        "4.39e-07",
        "+4.39e-07",
        "4.386e-07",
        "+4.386e-07",
        "4.386e-07",
        "0.000",
        "0.000",
        "+0.000",
        "4.386e-07",
        "4.386e-07",
        "+4.386e-07",
        "4.3861e-07",
        "+4.3861e-07",
        "4.3861e-07",
        "0.0000",
        "0.0000",
        "+0.0000",
        "4.3861e-07",
        "4.3861e-07",
        "+4.3861e-07",
        "4.38607e-07",
        "+4.38607e-07",
        "4.38607e-07",
        "0.00000",
        "0.00000",
        "+0.00000",
        "4.38607e-07",
        "4.38607e-07",
        "+4.38607e-07",
        "4.386066e-07",
        "+4.386066e-07",
        "4.386066e-07",
        "0.000000",
        "0.000000",
        "+0.000000",
        "4.386066e-07",
        "4.386066e-07",
        "+4.386066e-07",
        "4.3860662e-07",
        "+4.3860662e-07",
        "4.3860662e-07",
        "0.0000004",
        "0.0000004",
        "+0.0000004",
        "4.3860662e-07",
        "4.3860662e-07",
        "+4.3860662e-07",
        "4.38606623e-07",
        "+4.38606623e-07",
        "4.38606623e-07",
        "0.00000044",
        "0.00000044",
        "+0.00000044",
        "4.38606623e-07",
        "4.38606623e-07",
        "+4.38606623e-07",
        "4.386066230e-07",
        "+4.386066230e-07",
        "4.386066230e-07",
        "0.000000439",
        "0.000000439",
        "+0.000000439",
        "4.38606623e-07",
        "4.386066230e-07",
        "+4.38606623e-07",
        "4.3860662302e-07",
        "+4.3860662302e-07",
        "4.3860662302e-07",
        "0.0000004386",
        "0.0000004386",
        "+0.0000004386",
        "4.3860662302e-07",
        "4.3860662302e-07",
        "+4.3860662302e-07",
        "4.38606623021e-07",
        "+4.38606623021e-07",
        "4.38606623021e-07",
        "0.00000043861",
        "0.00000043861",
        "+0.00000043861",
        "4.38606623021e-07",
        "4.38606623021e-07",
        "+4.38606623021e-07",
        "4.386066230211e-07",
        "+4.386066230211e-07",
        "4.386066230211e-07",
        "0.000000438607",
        "0.000000438607",
        "+0.000000438607",
        "4.386066230211e-07",
        "4.386066230211e-07",
        "+4.386066230211e-07",
        "4.3860662302109e-07",
        "+4.3860662302109e-07",
        "4.3860662302109e-07",
        "0.0000004386066",
        "0.0000004386066",
        "+0.0000004386066",
    }},
    {{
        "-4e-07",
        "-4.e-07",
        "-4e-07",
        "-4.4e-07",
        "-4.4e-07",
        "-4.4e-07",
        "-0.0",
        "-0.0",
        "-0.0",
        "-4.4e-07",
        "-4.4e-07",
        "-4.4e-07",
        "-4.39e-07",
        "-4.39e-07",
        "-4.39e-07",
        "-0.00",
        "-0.00",
        "-0.00",
        "-4.39e-07",
        "-4.39e-07",
        "-4.39e-07",
        "-4.386e-07",
        "-4.386e-07",
        "-4.386e-07",
        "-0.000",
        "-0.000",
        "-0.000",
        "-4.386e-07",
        "-4.386e-07",
        "-4.386e-07",
        "-4.3861e-07",
        "-4.3861e-07",
        "-4.3861e-07",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-4.3861e-07",
        "-4.3861e-07",
        "-4.3861e-07",
        "-4.38607e-07",
        "-4.38607e-07",
        "-4.38607e-07",
        "-0.00000",
        "-0.00000",
        "-0.00000",
        "-4.38607e-07",
        "-4.38607e-07",
        "-4.38607e-07",
        "-4.386066e-07",
        "-4.386066e-07",
        "-4.386066e-07",
        "-0.000000",
        "-0.000000",
        "-0.000000",
        "-4.386066e-07",
        "-4.386066e-07",
        "-4.386066e-07",
        "-4.3860662e-07",
        "-4.3860662e-07",
        "-4.3860662e-07",
        "-0.0000004",
        "-0.0000004",
        "-0.0000004",
        "-4.3860662e-07",
        "-4.3860662e-07",
        "-4.3860662e-07",
        "-4.38606623e-07",
        "-4.38606623e-07",
        "-4.38606623e-07",
        "-0.00000044",
        "-0.00000044",
        "-0.00000044",
        "-4.38606623e-07",
        "-4.38606623e-07",
        "-4.38606623e-07",
        "-4.386066230e-07",
        "-4.386066230e-07",
        "-4.386066230e-07",
        "-0.000000439",
        "-0.000000439",
        "-0.000000439",
        "-4.38606623e-07",
        "-4.386066230e-07",
        "-4.38606623e-07",
        "-4.3860662302e-07",
        "-4.3860662302e-07",
        "-4.3860662302e-07",
        "-0.0000004386",
        "-0.0000004386",
        "-0.0000004386",
        "-4.3860662302e-07",
        "-4.3860662302e-07",
        "-4.3860662302e-07",
        "-4.38606623021e-07",
        "-4.38606623021e-07",
        "-4.38606623021e-07",
        "-0.00000043861",
        "-0.00000043861",
        "-0.00000043861",
        "-4.38606623021e-07",
        "-4.38606623021e-07",
        "-4.38606623021e-07",
        "-4.386066230211e-07",
        "-4.386066230211e-07",
        "-4.386066230211e-07",
        "-0.000000438607",
        "-0.000000438607",
        "-0.000000438607",
        "-4.386066230211e-07",
        "-4.386066230211e-07",
        "-4.386066230211e-07",
        "-4.3860662302109e-07",
        "-4.3860662302109e-07",
        "-4.3860662302109e-07",
        "-0.0000004386066",
        "-0.0000004386066",
        "-0.0000004386066",
    }},
    {{
        "5e-08",
        "5.e-08",
        "+5e-08",
        "5.5e-08",
        "+5.5e-08",
        "5.5e-08",
        "0.0",
        "0.0",
        "+0.0",
        "5.5e-08",
        "5.5e-08",
        "+5.5e-08",
        "5.48e-08",
        "+5.48e-08",
        "5.48e-08",
        "0.00",
        "0.00",
        "+0.00",
        "5.48e-08",
        "5.48e-08",
        "+5.48e-08",
        "5.483e-08",
        "+5.483e-08",
        "5.483e-08",
        "0.000",
        "0.000",
        "+0.000",
        "5.483e-08",
        "5.483e-08",
        "+5.483e-08",
        "5.4826e-08",
        "+5.4826e-08",
        "5.4826e-08",
        "0.0000",
        "0.0000",
        "+0.0000",
        "5.4826e-08",
        "5.4826e-08",
        "+5.4826e-08",
        "5.48258e-08",
        "+5.48258e-08",
        "5.48258e-08",
        "0.00000",
        "0.00000",
        "+0.00000",
        "5.48258e-08",
        "5.48258e-08",
        "+5.48258e-08",
        "5.482583e-08",
        "+5.482583e-08",
        "5.482583e-08",
        "0.000000",
        "0.000000",
        "+0.000000",
        "5.482583e-08",
        "5.482583e-08",
        "+5.482583e-08",
        "5.4825828e-08",
        "+5.4825828e-08",
        "5.4825828e-08",
        "0.0000001",
        "0.0000001",
        "+0.0000001",
        "5.4825828e-08",
        "5.4825828e-08",
        "+5.4825828e-08",
        "5.48258279e-08",
        "+5.48258279e-08",
        "5.48258279e-08",
        "0.00000005",
        "0.00000005",
        "+0.00000005",
        "5.48258279e-08",
        "5.48258279e-08",
        "+5.48258279e-08",
        "5.482582788e-08",
        "+5.482582788e-08",
        "5.482582788e-08",
        "0.000000055",
        "0.000000055",
        "+0.000000055",
        "5.482582788e-08",
        "5.482582788e-08",
        "+5.482582788e-08",
        "5.4825827878e-08",
        "+5.4825827878e-08",
        "5.4825827878e-08",
        "0.0000000548",
        "0.0000000548",
        "+0.0000000548",
        "5.4825827878e-08",
        "5.4825827878e-08",
        "+5.4825827878e-08",
        "5.48258278776e-08",
        "+5.48258278776e-08",
        "5.48258278776e-08",
        "0.00000005483",
        "0.00000005483",
        "+0.00000005483",
        "5.48258278776e-08",
        "5.48258278776e-08",
        "+5.48258278776e-08",
        "5.482582787764e-08",
        "+5.482582787764e-08",
        "5.482582787764e-08",
        "0.000000054826",
        "0.000000054826",
        "+0.000000054826",
        "5.482582787764e-08",
        "5.482582787764e-08",
        "+5.482582787764e-08",
        "5.4825827877636e-08",
        "+5.4825827877636e-08",
        "5.4825827877636e-08",
        "0.0000000548258",
        "0.0000000548258",
        "+0.0000000548258",
    }},
    {{
        "-5e-08",
        "-5.e-08",
        "-5e-08",
        "-5.5e-08",
        "-5.5e-08",
        "-5.5e-08",
        "-0.0",
        "-0.0",
        "-0.0",
        "-5.5e-08",
        "-5.5e-08",
        "-5.5e-08",
        "-5.48e-08",
        "-5.48e-08",
        "-5.48e-08",
        "-0.00",
        "-0.00",
        "-0.00",
        "-5.48e-08",
        "-5.48e-08",
        "-5.48e-08",
        "-5.483e-08",
        "-5.483e-08",
        "-5.483e-08",
        "-0.000",
        "-0.000",
        "-0.000",
        "-5.483e-08",
        "-5.483e-08",
        "-5.483e-08",
        "-5.4826e-08",
        "-5.4826e-08",
        "-5.4826e-08",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-5.4826e-08",
        "-5.4826e-08",
        "-5.4826e-08",
        "-5.48258e-08",
        "-5.48258e-08",
        "-5.48258e-08",
        "-0.00000",
        "-0.00000",
        "-0.00000",
        "-5.48258e-08",
        "-5.48258e-08",
        "-5.48258e-08",
        "-5.482583e-08",
        "-5.482583e-08",
        "-5.482583e-08",
        "-0.000000",
        "-0.000000",
        "-0.000000",
        "-5.482583e-08",
        "-5.482583e-08",
        "-5.482583e-08",
        "-5.4825828e-08",
        "-5.4825828e-08",
        "-5.4825828e-08",
        "-0.0000001",
        "-0.0000001",
        "-0.0000001",
        "-5.4825828e-08",
        "-5.4825828e-08",
        "-5.4825828e-08",
        "-5.48258279e-08",
        "-5.48258279e-08",
        "-5.48258279e-08",
        "-0.00000005",
        "-0.00000005",
        "-0.00000005",
        "-5.48258279e-08",
        "-5.48258279e-08",
        "-5.48258279e-08",
        "-5.482582788e-08",
        "-5.482582788e-08",
        "-5.482582788e-08",
        "-0.000000055",
        "-0.000000055",
        "-0.000000055",
        "-5.482582788e-08",
        "-5.482582788e-08",
        "-5.482582788e-08",
        "-5.4825827878e-08",
        "-5.4825827878e-08",
        "-5.4825827878e-08",
        "-0.0000000548",
        "-0.0000000548",
        "-0.0000000548",
        "-5.4825827878e-08",
        "-5.4825827878e-08",
        "-5.4825827878e-08",
        "-5.48258278776e-08",
        "-5.48258278776e-08",
        "-5.48258278776e-08",
        "-0.00000005483",
        "-0.00000005483",
        "-0.00000005483",
        "-5.48258278776e-08",
        "-5.48258278776e-08",
        "-5.48258278776e-08",
        "-5.482582787764e-08",
        "-5.482582787764e-08",
        "-5.482582787764e-08",
        "-0.000000054826",
        "-0.000000054826",
        "-0.000000054826",
        "-5.482582787764e-08",
        "-5.482582787764e-08",
        "-5.482582787764e-08",
        "-5.4825827877636e-08",
        "-5.4825827877636e-08",
        "-5.4825827877636e-08",
        "-0.0000000548258",
        "-0.0000000548258",
        "-0.0000000548258",
    }},
    {{
        "7e-09",
        "7.e-09",
        "+7e-09",
        "6.9e-09",
        "+6.9e-09",
        "6.9e-09",
        "0.0",
        "0.0",
        "+0.0",
        "6.9e-09",
        "6.9e-09",
        "+6.9e-09",
        "6.85e-09",
        "+6.85e-09",
        "6.85e-09",
        "0.00",
        "0.00",
        "+0.00",
        "6.85e-09",
        "6.85e-09",
        "+6.85e-09",
        "6.853e-09",
        "+6.853e-09",
        "6.853e-09",
        "0.000",
        "0.000",
        "+0.000",
        "6.853e-09",
        "6.853e-09",
        "+6.853e-09",
        "6.8532e-09",
        "+6.8532e-09",
        "6.8532e-09",
        "0.0000",
        "0.0000",
        "+0.0000",
        "6.8532e-09",
        "6.8532e-09",
        "+6.8532e-09",
        "6.85323e-09",
        "+6.85323e-09",
        "6.85323e-09",
        "0.00000",
        "0.00000",
        "+0.00000",
        "6.85323e-09",
        "6.85323e-09",
        "+6.85323e-09",
        "6.853228e-09",
        "+6.853228e-09",
        "6.853228e-09",
        "0.000000",
        "0.000000",
        "+0.000000",
        "6.853228e-09",
        "6.853228e-09",
        "+6.853228e-09",
        "6.8532285e-09",
        "+6.8532285e-09",
        "6.8532285e-09",
        "0.0000000",
        "0.0000000",
        "+0.0000000",
        "6.8532285e-09",
        "6.8532285e-09",
        "+6.8532285e-09",
        "6.85322848e-09",
        "+6.85322848e-09",
        "6.85322848e-09",
        "0.00000001",
        "0.00000001",
        "+0.00000001",
        "6.85322848e-09",
        "6.85322848e-09",
        "+6.85322848e-09",
        "6.853228485e-09",
        "+6.853228485e-09",
        "6.853228485e-09",
        "0.000000007",
        "0.000000007",
        "+0.000000007",
        "6.853228485e-09",
        "6.853228485e-09",
        "+6.853228485e-09",
        "6.8532284847e-09",
        "+6.8532284847e-09",
        "6.8532284847e-09",
        "0.0000000069",
        "0.0000000069",
        "+0.0000000069",
        "6.8532284847e-09",
        "6.8532284847e-09",
        "+6.8532284847e-09",
        "6.85322848470e-09",
        "+6.85322848470e-09",
        "6.85322848470e-09",
        "0.00000000685",
        "0.00000000685",
        "+0.00000000685",
        "6.8532284847e-09",
        "6.85322848470e-09",
        "+6.8532284847e-09",
        "6.853228484704e-09",
        "+6.853228484704e-09",
        "6.853228484704e-09",
        "0.000000006853",
        "0.000000006853",
        "+0.000000006853",
        "6.853228484704e-09",
        "6.853228484704e-09",
        "+6.853228484704e-09",
        "6.8532284847045e-09",
        "+6.8532284847045e-09",
        "6.8532284847045e-09",
        "0.0000000068532",
        "0.0000000068532",
        "+0.0000000068532",
    }},
    {{
        "-7e-09",
        "-7.e-09",
        "-7e-09",
        "-6.9e-09",
        "-6.9e-09",
        "-6.9e-09",
        "-0.0",
        "-0.0",
        "-0.0",
        "-6.9e-09",
        "-6.9e-09",
        "-6.9e-09",
        "-6.85e-09",
        "-6.85e-09",
        "-6.85e-09",
        "-0.00",
        "-0.00",
        "-0.00",
        "-6.85e-09",
        "-6.85e-09",
        "-6.85e-09",
        "-6.853e-09",
        "-6.853e-09",
        "-6.853e-09",
        "-0.000",
        "-0.000",
        "-0.000",
        "-6.853e-09",
        "-6.853e-09",
        "-6.853e-09",
        "-6.8532e-09",
        "-6.8532e-09",
        "-6.8532e-09",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-6.8532e-09",
        "-6.8532e-09",
        "-6.8532e-09",
        "-6.85323e-09",
        "-6.85323e-09",
        "-6.85323e-09",
        "-0.00000",
        "-0.00000",
        "-0.00000",
        "-6.85323e-09",
        "-6.85323e-09",
        "-6.85323e-09",
        "-6.853228e-09",
        "-6.853228e-09",
        "-6.853228e-09",
        "-0.000000",
        "-0.000000",
        "-0.000000",
        "-6.853228e-09",
        "-6.853228e-09",
        "-6.853228e-09",
        "-6.8532285e-09",
        "-6.8532285e-09",
        "-6.8532285e-09",
        "-0.0000000",
        "-0.0000000",
        "-0.0000000",
        "-6.8532285e-09",
        "-6.8532285e-09",
        "-6.8532285e-09",
        "-6.85322848e-09",
        "-6.85322848e-09",
        "-6.85322848e-09",
        "-0.00000001",
        "-0.00000001",
        "-0.00000001",
        "-6.85322848e-09",
        "-6.85322848e-09",
        "-6.85322848e-09",
        "-6.853228485e-09",
        "-6.853228485e-09",
        "-6.853228485e-09",
        "-0.000000007",
        "-0.000000007",
        "-0.000000007",
        "-6.853228485e-09",
        "-6.853228485e-09",
        "-6.853228485e-09",
        "-6.8532284847e-09",
        "-6.8532284847e-09",
        "-6.8532284847e-09",
        "-0.0000000069",
        "-0.0000000069",
        "-0.0000000069",
        "-6.8532284847e-09",
        "-6.8532284847e-09",
        "-6.8532284847e-09",
        "-6.85322848470e-09",
        "-6.85322848470e-09",
        "-6.85322848470e-09",
        "-0.00000000685",
        "-0.00000000685",
        "-0.00000000685",
        "-6.8532284847e-09",
        "-6.85322848470e-09",
        "-6.8532284847e-09",
        "-6.853228484704e-09",
        "-6.853228484704e-09",
        "-6.853228484704e-09",
        "-0.000000006853",
        "-0.000000006853",
        "-0.000000006853",
        "-6.853228484704e-09",
        "-6.853228484704e-09",
        "-6.853228484704e-09",
        "-6.8532284847045e-09",
        "-6.8532284847045e-09",
        "-6.8532284847045e-09",
        "-0.0000000068532",
        "-0.0000000068532",
        "-0.0000000068532",
    }},
    {{
        "9e-10",
        "9.e-10",
        "+9e-10",
        "8.6e-10",
        "+8.6e-10",
        "8.6e-10",
        "0.0",
        "0.0",
        "+0.0",
        "8.6e-10",
        "8.6e-10",
        "+8.6e-10",
        "8.57e-10",
        "+8.57e-10",
        "8.57e-10",
        "0.00",
        "0.00",
        "+0.00",
        "8.57e-10",
        "8.57e-10",
        "+8.57e-10",
        "8.567e-10",
        "+8.567e-10",
        "8.567e-10",
        "0.000",
        "0.000",
        "+0.000",
        "8.567e-10",
        "8.567e-10",
        "+8.567e-10",
        "8.5665e-10",
        "+8.5665e-10",
        "8.5665e-10",
        "0.0000",
        "0.0000",
        "+0.0000",
        "8.5665e-10",
        "8.5665e-10",
        "+8.5665e-10",
        "8.56654e-10",
        "+8.56654e-10",
        "8.56654e-10",
        "0.00000",
        "0.00000",
        "+0.00000",
        "8.56654e-10",
        "8.56654e-10",
        "+8.56654e-10",
        "8.566536e-10",
        "+8.566536e-10",
        "8.566536e-10",
        "0.000000",
        "0.000000",
        "+0.000000",
        "8.566536e-10",
        "8.566536e-10",
        "+8.566536e-10",
        "8.5665356e-10",
        "+8.5665356e-10",
        "8.5665356e-10",
        "0.0000000",
        "0.0000000",
        "+0.0000000",
        "8.5665356e-10",
        "8.5665356e-10",
        "+8.5665356e-10",
        "8.56653561e-10",
        "+8.56653561e-10",
        "8.56653561e-10",
        "0.00000000",
        "0.00000000",
        "+0.00000000",
        "8.56653561e-10",
        "8.56653561e-10",
        "+8.56653561e-10",
        "8.566535606e-10",
        "+8.566535606e-10",
        "8.566535606e-10",
        "0.000000001",
        "0.000000001",
        "+0.000000001",
        "8.566535606e-10",
        "8.566535606e-10",
        "+8.566535606e-10",
        "8.5665356059e-10",
        "+8.5665356059e-10",
        "8.5665356059e-10",
        "0.0000000009",
        "0.0000000009",
        "+0.0000000009",
        "8.5665356059e-10",
        "8.5665356059e-10",
        "+8.5665356059e-10",
        "8.56653560588e-10",
        "+8.56653560588e-10",
        "8.56653560588e-10",
        "0.00000000086",
        "0.00000000086",
        "+0.00000000086",
        "8.56653560588e-10",
        "8.56653560588e-10",
        "+8.56653560588e-10",
        "8.566535605881e-10",
        "+8.566535605881e-10",
        "8.566535605881e-10",
        "0.000000000857",
        "0.000000000857",
        "+0.000000000857",
        "8.566535605881e-10",
        "8.566535605881e-10",
        "+8.566535605881e-10",
        "8.5665356058806e-10",
        "+8.5665356058806e-10",
        "8.5665356058806e-10",
        "0.0000000008567",
        "0.0000000008567",
        "+0.0000000008567",
    }},
    {{
        "-9e-10",
        "-9.e-10",
        "-9e-10",
        "-8.6e-10",
        "-8.6e-10",
        "-8.6e-10",
        "-0.0",
        "-0.0",
        "-0.0",
        "-8.6e-10",
        "-8.6e-10",
        "-8.6e-10",
        "-8.57e-10",
        "-8.57e-10",
        "-8.57e-10",
        "-0.00",
        "-0.00",
        "-0.00",
        "-8.57e-10",
        "-8.57e-10",
        "-8.57e-10",
        "-8.567e-10",
        "-8.567e-10",
        "-8.567e-10",
        "-0.000",
        "-0.000",
        "-0.000",
        "-8.567e-10",
        "-8.567e-10",
        "-8.567e-10",
        "-8.5665e-10",
        "-8.5665e-10",
        "-8.5665e-10",
        "-0.0000",
        "-0.0000",
        "-0.0000",
        "-8.5665e-10",
        "-8.5665e-10",
        "-8.5665e-10",
        "-8.56654e-10",
        "-8.56654e-10",
        "-8.56654e-10",
        "-0.00000",
        "-0.00000",
        "-0.00000",
        "-8.56654e-10",
        "-8.56654e-10",
        "-8.56654e-10",
        "-8.566536e-10",
        "-8.566536e-10",
        "-8.566536e-10",
        "-0.000000",
        "-0.000000",
        "-0.000000",
        "-8.566536e-10",
        "-8.566536e-10",
        "-8.566536e-10",
        "-8.5665356e-10",
        "-8.5665356e-10",
        "-8.5665356e-10",
        "-0.0000000",
        "-0.0000000",
        "-0.0000000",
        "-8.5665356e-10",
        "-8.5665356e-10",
        "-8.5665356e-10",
        "-8.56653561e-10",
        "-8.56653561e-10",
        "-8.56653561e-10",
        "-0.00000000",
        "-0.00000000",
        "-0.00000000",
        "-8.56653561e-10",
        "-8.56653561e-10",
        "-8.56653561e-10",
        "-8.566535606e-10",
        "-8.566535606e-10",
        "-8.566535606e-10",
        "-0.000000001",
        "-0.000000001",
        "-0.000000001",
        "-8.566535606e-10",
        "-8.566535606e-10",
        "-8.566535606e-10",
        "-8.5665356059e-10",
        "-8.5665356059e-10",
        "-8.5665356059e-10",
        "-0.0000000009",
        "-0.0000000009",
        "-0.0000000009",
        "-8.5665356059e-10",
        "-8.5665356059e-10",
        "-8.5665356059e-10",
        "-8.56653560588e-10",
        "-8.56653560588e-10",
        "-8.56653560588e-10",
        "-0.00000000086",
        "-0.00000000086",
        "-0.00000000086",
        "-8.56653560588e-10",
        "-8.56653560588e-10",
        "-8.56653560588e-10",
        "-8.566535605881e-10",
        "-8.566535605881e-10",
        "-8.566535605881e-10",
        "-0.000000000857",
        "-0.000000000857",
        "-0.000000000857",
        "-8.566535605881e-10",
        "-8.566535605881e-10",
        "-8.566535605881e-10",
        "-8.5665356058806e-10",
        "-8.5665356058806e-10",
        "-8.5665356058806e-10",
        "-0.0000000008567",
        "-0.0000000008567",
        "-0.0000000008567",
    }},


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifndef BOOST_MULTIPRECISION_TEST_HPP
#define BOOST_MULTIPRECISION_TEST_HPP

#include <limits>
#include <cmath>
#include <typeinfo>

#include <boost/detail/lightweight_test.hpp>
#include <boost/current_function.hpp>
#include <boost/multiprecision/number.hpp>
#include <boost/multiprecision/detail/standalone_config.hpp>

namespace detail {

template <class T>
inline typename std::enable_if<!(boost::multiprecision::detail::is_unsigned<T>::value || boost::multiprecision::is_unsigned_number<T>::value), T>::type
abs(const T& a)
{
   return a < 0 ? -a : a;
}

template <class T>
inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value || boost::multiprecision::is_unsigned_number<T>::value, T>::type
abs(const T& a)
{
   return a;
}

} // namespace detail

template <class T>
typename std::enable_if<boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_integer, T>::type relative_error(T a, T b)
{
   return a > b ? a - b : b - a;
}

template <class T>
typename std::enable_if<!((boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_integer) || boost::multiprecision::is_interval_number<T>::value), T>::type relative_error(T a, T b)
{
   using ::detail::abs;
   using std::abs;

   T min_val = (std::numeric_limits<T>::min)();
   T max_val = (std::numeric_limits<T>::max)();

   if ((a != 0) && (b != 0))
   {
      if (a == b)
         return 0;

      // TODO: use isfinite:
      if (abs(b) >= max_val)
      {
         if (abs(a) >= max_val)
            return 0; // one infinity is as good as another!
      }
      // If the result is denormalised, treat all denorms as equivalent:
      if ((a < min_val) && (a > 0))
         a = min_val;
      else if ((a > -min_val) && (a < 0))
         a = -min_val;
      if ((b < min_val) && (b > 0))
         b = min_val;
      else if ((b > -min_val) && (b < 0))
         b = -min_val;

      return (std::max)(abs(T((a - b) / a)), abs(T((a - b) / b))) / std::numeric_limits<T>::epsilon();
   }

   // Handle special case where one or both are zero:
   if (min_val == 0)
      return abs(T(a - b));
   if (abs(a) < min_val)
      a = min_val;
   if (abs(b) < min_val)
      b = min_val;

   return (std::max)(abs(T((a - b) / a)), abs(T((a - b) / b))) / std::numeric_limits<T>::epsilon();
}

template <class T>
typename std::enable_if<boost::multiprecision::is_interval_number<T>::value, T>::type relative_error(T a, T b)
{
   typename boost::multiprecision::component_type<T>::type am = median(a);
   typename boost::multiprecision::component_type<T>::type bm = median(b);
   return relative_error<typename boost::multiprecision::component_type<T>::type>(am, bm);
}

template <class T, class U>
typename std::conditional<std::is_convertible<T, U>::value, U, T>::type
relative_error(T a, U b)
{
   typedef typename std::conditional<std::is_convertible<T, U>::value, U, T>::type cast_type;
   return relative_error<cast_type>(static_cast<cast_type>(a), static_cast<cast_type>(b));
}

enum
{
   warn_on_fail,
   error_on_fail,
   abort_on_fail
};

template <class T>
inline T epsilon_of(const T&)
{
   static_assert(std::numeric_limits<T>::is_specialized, "No numeric_limits support");
   return std::numeric_limits<T>::is_integer ? static_cast<T>(1) : std::numeric_limits<T>::epsilon();
}

template <class T>
inline int digits_of(const T&)
{
   return std::numeric_limits<T>::is_specialized ? std::numeric_limits<T>::digits10 + 3 : std::numeric_limits<long double>::digits10 + 3;
}

inline std::ostream& report_where(const char* file, int line, const char* function)
{
   if (function)
      BOOST_LIGHTWEIGHT_TEST_OSTREAM << "In function: " << function << std::endl;
   BOOST_LIGHTWEIGHT_TEST_OSTREAM << file << ":" << line;
   return BOOST_LIGHTWEIGHT_TEST_OSTREAM;
}

#define BOOST_MP_REPORT_WHERE report_where(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION)

inline void report_severity(int severity)
{
   if (severity == error_on_fail)
      ++boost::detail::test_errors();
   else if (severity == abort_on_fail)
   {
      ++boost::detail::test_errors();
      abort();
   }
}

#define BOOST_MP_REPORT_SEVERITY(severity) report_severity(severity)

template <class E>
void report_unexpected_exception(const E& e, int severity, const char* file, int line, const char* function)
{
   report_where(file, line, function) << " Unexpected exception of type " << typeid(e).name() << std::endl;
   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Errot message was: " << e.what() << std::endl;
   BOOST_MP_REPORT_SEVERITY(severity);
}

#ifdef BOOST_HAS_INT128

std::ostream& operator<<(std::ostream& os, boost::int128_type val)
{
   std::stringstream ss;
   ss << std::hex << "0x" << static_cast<std::uint64_t>(static_cast<boost::uint128_type>(val) >> 64) << static_cast<std::uint64_t>(val);
   return os << ss.str();
}

std::ostream& operator<<(std::ostream& os, boost::uint128_type val)
{
   std::stringstream ss;
   ss << std::hex << "0x" << static_cast<std::uint64_t>(val >> 64) << static_cast<std::uint64_t>(val);
   return os << ss.str();
}

#endif
#if defined(BOOST_HAS_FLOAT128) && !defined(BOOST_MP_HAVE_CSTDFLOAT)
std::ostream& operator<<(std::ostream& os, __float128 f)
{
   return os << static_cast<long double>(f);
}
#endif

#ifndef BOOST_NO_EXCEPTIONS
#define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)                                       \
   catch (const std::exception& e)                                                          \
   {                                                                                        \
      report_unexpected_exception(e, severity, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
   }                                                                                        \
   catch (...)                                                                              \
   {                                                                                        \
      std::cout << "Exception of unknown type was thrown" << std::endl;                     \
      report_severity(severity);                                                            \
   }
#define BOOST_MP_TEST_TRY try
#else
#define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
#define BOOST_MP_TEST_TRY
#endif

#define BOOST_CHECK_IMP(x, severity)                                                        \
   BOOST_MP_TEST_TRY                                                                             \
   {                                                                                        \
      if (x)                                                                                \
      {                                                                                     \
      }                                                                                     \
      else                                                                                  \
      {                                                                                     \
         BOOST_MP_REPORT_WHERE << " Failed predicate: " << BOOST_STRINGIZE(x) << std::endl; \
         BOOST_MP_REPORT_SEVERITY(severity);                                                \
      }                                                                                     \
   }                                                                                        \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_CHECK(x) BOOST_CHECK_IMP(x, error_on_fail)
#define BOOST_WARN(x) BOOST_CHECK_IMP(x, warn_on_fail)
#define BOOST_REQUIRE(x) BOOST_CHECK_IMP(x, abort_on_fail)

#define BOOST_CLOSE_IMP(x, y, tol, severity)                                                \
   BOOST_MP_TEST_TRY                                                                             \
   {                                                                                        \
      if (relative_error(x, y) > tol)                                                       \
      {                                                                                     \
         BOOST_MP_REPORT_WHERE << " Failed check for closeness: \n"                         \
                               << std::setprecision(digits_of(x)) << std::scientific        \
                               << "Value of LHS was: " << x << "\n"                         \
                               << "Value of RHS was: " << y << "\n"                         \
                               << std::setprecision(5) << std::fixed                        \
                               << "Relative error was: " << relative_error(x, y) << "eps\n" \
                               << "Tolerance was: " << tol << "eps" << std::endl;           \
         BOOST_MP_REPORT_SEVERITY(severity);                                                \
      }                                                                                     \
   }                                                                                        \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_EQUAL_IMP(x, y, severity)                                              \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!((x) == (y)))                                                             \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for equality: \n"                   \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << (x) << "\n"                \
                               << "Value of RHS was: " << (y) << "\n"                \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_NE_IMP(x, y, severity)                                                 \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!(x != y))                                                                 \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for non-equality: \n"               \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << x << "\n"                  \
                               << "Value of RHS was: " << y << "\n"                  \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_LT_IMP(x, y, severity)                                                 \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!(x < y))                                                                  \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for less than: \n"                  \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << x << "\n"                  \
                               << "Value of RHS was: " << y << "\n"                  \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_GT_IMP(x, y, severity)                                                 \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!(x > y))                                                                  \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for greater than: \n"               \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << x << "\n"                  \
                               << "Value of RHS was: " << y << "\n"                  \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_LE_IMP(x, y, severity)                                                 \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!(x <= y))                                                                 \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for less-than-equal-to: \n"         \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << x << "\n"                  \
                               << "Value of RHS was: " << y << "\n"                  \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#define BOOST_GE_IMP(x, y, severity)                                                 \
   BOOST_MP_TEST_TRY                                                                      \
   {                                                                                 \
      if (!(x >= y))                                                                 \
      {                                                                              \
         BOOST_MP_REPORT_WHERE << " Failed check for greater-than-equal-to \n"       \
                               << std::setprecision(digits_of(x)) << std::scientific \
                               << "Value of LHS was: " << x << "\n"                  \
                               << "Value of RHS was: " << y << "\n"                  \
                               << std::setprecision(3) << std::endl;                 \
         BOOST_MP_REPORT_SEVERITY(severity);                                         \
      }                                                                              \
   }                                                                                 \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)

#ifndef BOOST_NO_EXCEPTIONS
#define BOOST_MT_CHECK_THROW_IMP(x, E, severity)                                                                   \
   BOOST_MP_TEST_TRY                                                                                                    \
   {                                                                                                               \
      x;                                                                                                           \
      BOOST_MP_REPORT_WHERE << " Expected exception not thrown in expression " << BOOST_STRINGIZE(x) << std::endl; \
      BOOST_MP_REPORT_SEVERITY(severity);                                                                          \
   }                                                                                                               \
   catch (const E&) {}                                                                                             \
   BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity)
#else
#define BOOST_MT_CHECK_THROW_IMP(x, E, severity)
#endif

#define BOOST_CHECK_CLOSE(x, y, tol) BOOST_CLOSE_IMP(x, y, ((tol / (100 * epsilon_of(x)))), error_on_fail)
#define BOOST_WARN_CLOSE(x, y, tol) BOOST_CLOSE_IMP(x, y, (tol / (100 * epsilon_of(x))), warn_on_fail)
#define BOOST_REQUIRE_CLOSE(x, y, tol) BOOST_CLOSE_IMP(x, y, (tol / (100 * epsilon_of(x))), abort_on_fail)

#define BOOST_CHECK_CLOSE_FRACTION(x, y, tol) BOOST_CLOSE_IMP(x, y, ((tol / (epsilon_of(x)))), error_on_fail)
#define BOOST_WARN_CLOSE_FRACTION(x, y, tol) BOOST_CLOSE_IMP(x, y, (tol / (epsilon_of(x))), warn_on_fail)
#define BOOST_REQUIRE_CLOSE_FRACTION(x, y, tol) BOOST_CLOSE_IMP(x, y, (tol / (epsilon_of(x))), abort_on_fail)

#define BOOST_CHECK_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, error_on_fail)
#define BOOST_WARN_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_EQUAL(x, y) BOOST_EQUAL_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_NE(x, y) BOOST_NE_IMP(x, y, error_on_fail)
#define BOOST_WARN_NE(x, y) BOOST_NE_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_NE(x, y) BOOST_NE_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_LT(x, y) BOOST_LT_IMP(x, y, error_on_fail)
#define BOOST_WARN_LT(x, y) BOOST_LT_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_LT(x, y) BOOST_LT_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_GT(x, y) BOOST_GT_IMP(x, y, error_on_fail)
#define BOOST_WARN_GT(x, y) BOOST_GT_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_GT(x, y) BOOST_GT_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_LE(x, y) BOOST_LE_IMP(x, y, error_on_fail)
#define BOOST_WARN_LE(x, y) BOOST_LE_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_LE(x, y) BOOST_LE_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_GE(x, y) BOOST_GE_IMP(x, y, error_on_fail)
#define BOOST_WARN_GE(x, y) BOOST_GE_IMP(x, y, warn_on_fail)
#define BOOST_REQUIRE_GE(x, y) BOOST_GE_IMP(x, y, abort_on_fail)

#define BOOST_CHECK_THROW(x, E) BOOST_MT_CHECK_THROW_IMP(x, E, error_on_fail)
#define BOOST_WARN_THROW(x, E) BOOST_MT_CHECK_THROW_IMP(x, E, warn_on_fail)
#define BOOST_REQUIRE_THROW(x, E) BOOST_MT_CHECK_THROW_IMP(x, E, abort_on_fail)

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_acos.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   //
   // Test with some exact binary values as input - this tests our code
   // rather than the test data:
   //
   static const boost::array<boost::array<T, 2>, 13> exact_data =
       {{
           {{0.5, static_cast<T>("1.04719755119659774615421446109316762806572313312503527365831486410260546876206966620934494178070568932738269550442743555")}},
           {{0.25, static_cast<T>("1.31811607165281796574566425464604046984639096659071471685354851741333314266208327690226867044304393238598144034722708676")}},
           {{0.75, static_cast<T>("0.722734247813415611178377352641333362025218486424440267626754132583707381914630264964827610939101303690078815991333621490")}},
           {{1 - std::ldexp(1.0, -20), static_cast<T>("0.00138106804176241718210883847756746694048570648553426714212025111150044290934710742282266738617709904634187850607042604204")}},
           {{std::ldexp(1.0, -20), static_cast<T>("1.57079537312058021283676140197495835299636605165647561806789944133748780804448843729970624018104090863783682329820313127")}},
           {{1, static_cast<T>("0")}},

           {{0, static_cast<T>("1.57079632679489661923132169163975144209858469968755291048747229615390820314310449931401741267105853399107404325664115332")}},

           {{-0.5, static_cast<T>("2.09439510239319549230842892218633525613144626625007054731662972820521093752413933241868988356141137865476539100885487110")}},
           {{-0.25, static_cast<T>("1.82347658193697527271697912863346241435077843278439110412139607489448326362412572172576615489907313559616664616605521989")}},
           {{-0.75, static_cast<T>("2.41885840577637762728426603063816952217195091295066555334819045972410902437157873366320721440301576429206927052194868516")}},
           {{-1 + std::ldexp(1.0, -20), static_cast<T>("3.14021158554803082128053454480193541725668369288957155383282434119631596337686189120521215795593996893580620800721188061")}},
           {{-std::ldexp(1.0, -20), static_cast<T>("1.57079728046921302562588198130454453120080334771863020290704515097032859824172056132832858516107615934431126321507917538")}},
           {{-1, static_cast<T>("3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230665")}},
       }};
   unsigned max_err = 0;
   for (unsigned k = 0; k < exact_data.size(); k++)
   {
      T        val = acos(exact_data[k][0]);
      T        e   = relative_error(val, exact_data[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
#ifdef TEST_CPP_BIN_FLOAT
   BOOST_TEST(max_err < 320);
#else
   BOOST_TEST(max_err < 60);
#endif
   BOOST_TEST(asin(T(0)) == 0);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_adapt_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/exception/all.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
void test_neg(const T& x, const std::integral_constant<bool, true>&)
{
   T val = -x;
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      T val2;
      {
         std::stringstream             ss;
         boost::archive::text_oarchive oa(ss);
         oa << static_cast<const T&>(val);
         boost::archive::text_iarchive ia(ss);
         ia >> val2;
         BOOST_CHECK_EQUAL(val, val2);
      }
      {
         std::stringstream ss;
         {
            boost::archive::xml_oarchive oa(ss);
            oa << boost::serialization::make_nvp("value", static_cast<const T&>(val));
         }
         boost::archive::xml_iarchive ia(ss);
         ia >> boost::serialization::make_nvp("value", val2);
         BOOST_CHECK_EQUAL(val, val2);
      }
      {
         std::stringstream               ss;
         boost::archive::binary_oarchive ob(ss);
         ob << static_cast<const T&>(val);
         boost::archive::binary_iarchive ib(ss);
         ib >> val2;
         BOOST_CHECK_EQUAL(val, val2);
      }
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const boost::exception& e)
   {
      std::cout << "Caught boost::exception with:\n";
      std::cout << diagnostic_information(e);
   }
   catch (const std::exception& e)
   {
      std::cout << "Caught std::exception with:\n";
      std::cout << e.what() << std::endl;
   }
#endif
}
template <class T>
void test_neg(const T&, const std::integral_constant<bool, false>&) {}

template <class T>
void test()
{
   using namespace boost::multiprecision;

   boost::random::mt19937 gen;
   boost::uniform_int<>   d(3, std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : 3000);
   timer                  tim;

   while (true)
   {
      T val = generate_random<T>(d(gen));
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val2;
         {
            std::stringstream             ss;
            boost::archive::text_oarchive oa(ss);
            oa << static_cast<const T&>(val);
            boost::archive::text_iarchive ia(ss);
            ia >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss;
            {
               boost::archive::xml_oarchive oa(ss);
               oa << boost::serialization::make_nvp("value", static_cast<const T&>(val));
            }
            boost::archive::xml_iarchive ia(ss);
            ia >> boost::serialization::make_nvp("value", val2);
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream               ss;
            boost::archive::binary_oarchive ob(ss);
            ob << static_cast<const T&>(val);
            boost::archive::binary_iarchive ib(ss);
            ib >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
      test_neg(val, std::integral_constant<bool, std::numeric_limits<T>::is_signed>());
      //
      // Check to see if test is taking too long.
      // Tests run on the compiler farm time out after 300 seconds,
      // so don't get too close to that:
      //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 30)
#else
      if (tim.elapsed() > 10)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }
   }
}

int main()
{
   using namespace boost::multiprecision;
   test<number<logged_adaptor<cpp_int_backend<> > > >();
   test<number<debug_adaptor<cpp_int_backend<> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef TEST_VLD
#include <vld.h>
#endif

#include <functional>
#include <numeric>
#include <type_traits>
#include <typeinfo>
#include <iostream>
#include <iomanip>
#include "test.hpp"
#include <boost/multiprecision/detail/standalone_config.hpp>

#ifndef BOOST_MP_STANDALONE
#include <boost/integer/common_factor_rt.hpp>
#include <boost/lexical_cast.hpp>
#endif

#ifdef BOOST_MP_MATH_AVAILABLE
#include <boost/math/special_functions/pow.hpp>
#endif

template <class T>
struct is_boost_rational : public std::integral_constant<bool, false>
{};
template <class T>
struct is_checked_cpp_int : public std::integral_constant<bool, false>
{};

#ifdef BOOST_MSVC
// warning C4127: conditional expression is constant
#pragma warning(disable : 4127)
#endif

//
// This works around some platforms which have missing typeinfo
// for boost::int128_type and/or __float128:
//
template <class T>
inline const char* name_of()
{
   return typeid(T).name();
}
#ifdef BOOST_HAS_INT128
template <>
inline const char* name_of<boost::int128_type>()
{
   return "boost::int128_type";
}
template <>
inline const char* name_of<boost::uint128_type>()
{
   return "boost::uint128_type";
}
#endif
#ifdef BOOST_HAS_FLOAT128
template <>
inline const char* name_of<__float128>()
{
   return "__float128";
}
#endif

#ifndef BOOST_MP_STANDALONE
template <class Target, class Source>
Target checked_lexical_cast(const Source& val)
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      return boost::lexical_cast<Target>(val);
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (...)
   {
      std::cerr << "Error in lexical cast\nSource type = " << name_of<Source>() << " \"" << val << "\"\n";
      std::cerr << "Target type = " << name_of<Target>() << std::endl;
      throw;
   }
#endif
}
#endif

bool isfloat(float) { return true; }
bool isfloat(double) { return true; }
bool isfloat(long double) { return true; }
template <class T>
bool isfloat(T) { return false; }

namespace detail {

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type
abs(boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> const& v)
{
   typedef typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type result_type;
   return v < 0 ? result_type(-v) : result_type(v);
}

} // namespace detail

template <class T>
struct is_twos_complement_integer : public std::integral_constant<bool, true>
{};

template <class T>
struct related_type
{
   typedef T type;
};

template <class Real, class Val>
void test_comparisons(Val, Val, const std::integral_constant<bool, false>&)
{}

int normalize_compare_result(int r)
{
   return r > 0 ? 1 : r < 0 ? -1 : 0;
}

enum unscoped_enum
{
   one = 1,
   two = 2,
   three = 3,
};

enum struct scoped_enum
{
   four = 4,
   five = 5,
   six = 6,
};

template <class Real>
typename std::enable_if<boost::multiprecision::is_number<Real>::value>::type test_enum_conversions()
{
   Real r1(one);
   BOOST_CHECK_EQUAL(r1, 1);
   Real r2(scoped_enum::four);
   BOOST_CHECK_EQUAL(r2, 4);
   r1 = two;
   BOOST_CHECK_EQUAL(r1, 2);
   r1.assign(scoped_enum::five);
   BOOST_CHECK_EQUAL(r1, 5);

   r1.assign(two);

   BOOST_CHECK_EQUAL(static_cast<unscoped_enum>(r1), two);
   BOOST_CHECK(static_cast<scoped_enum>(r2) == scoped_enum::four);
}

template <class Real>
typename std::enable_if<!boost::multiprecision::is_number<Real>::value>::type test_enum_conversions()
{}

template <class Real, class Val>
typename std::enable_if<boost::multiprecision::number_category<Real>::value != boost::multiprecision::number_kind_complex>::type
test_comparisons(Val a, Val b, const std::integral_constant<bool, true>&)
{
   Real r1(a);
   Real r2(b);
   Real z(1);

   int cr = a < b ? -1 : a > b ? 1 : 0;

   BOOST_CHECK_EQUAL(r1 == r2, a == b);
   BOOST_CHECK_EQUAL(r1 != r2, a != b);
   BOOST_CHECK_EQUAL(r1 <= r2, a <= b);
   BOOST_CHECK_EQUAL(r1 < r2, a < b);
   BOOST_CHECK_EQUAL(r1 >= r2, a >= b);
   BOOST_CHECK_EQUAL(r1 > r2, a > b);

   BOOST_CHECK_EQUAL(r1 == b, a == b);
   BOOST_CHECK_EQUAL(r1 != b, a != b);
   BOOST_CHECK_EQUAL(r1 <= b, a <= b);
   BOOST_CHECK_EQUAL(r1 < b, a < b);
   BOOST_CHECK_EQUAL(r1 >= b, a >= b);
   BOOST_CHECK_EQUAL(r1 > b, a > b);

   BOOST_CHECK_EQUAL(a == r2, a == b);
   BOOST_CHECK_EQUAL(a != r2, a != b);
   BOOST_CHECK_EQUAL(a <= r2, a <= b);
   BOOST_CHECK_EQUAL(a < r2, a < b);
   BOOST_CHECK_EQUAL(a >= r2, a >= b);
   BOOST_CHECK_EQUAL(a > r2, a > b);

   BOOST_CHECK_EQUAL(r1 * z == r2, a == b);
   BOOST_CHECK_EQUAL(r1 * z != r2, a != b);
   BOOST_CHECK_EQUAL(r1 * z <= r2, a <= b);
   BOOST_CHECK_EQUAL(r1 * z < r2, a < b);
   BOOST_CHECK_EQUAL(r1 * z >= r2, a >= b);
   BOOST_CHECK_EQUAL(r1 * z > r2, a > b);

   BOOST_CHECK_EQUAL(r1 == r2 * z, a == b);
   BOOST_CHECK_EQUAL(r1 != r2 * z, a != b);
   BOOST_CHECK_EQUAL(r1 <= r2 * z, a <= b);
   BOOST_CHECK_EQUAL(r1 < r2 * z, a < b);
   BOOST_CHECK_EQUAL(r1 >= r2 * z, a >= b);
   BOOST_CHECK_EQUAL(r1 > r2 * z, a > b);

   BOOST_CHECK_EQUAL(r1 * z == r2 * z, a == b);
   BOOST_CHECK_EQUAL(r1 * z != r2 * z, a != b);
   BOOST_CHECK_EQUAL(r1 * z <= r2 * z, a <= b);
   BOOST_CHECK_EQUAL(r1 * z < r2 * z, a < b);
   BOOST_CHECK_EQUAL(r1 * z >= r2 * z, a >= b);
   BOOST_CHECK_EQUAL(r1 * z > r2 * z, a > b);

   BOOST_CHECK_EQUAL(r1 * z == b, a == b);
   BOOST_CHECK_EQUAL(r1 * z != b, a != b);
   BOOST_CHECK_EQUAL(r1 * z <= b, a <= b);
   BOOST_CHECK_EQUAL(r1 * z < b, a < b);
   BOOST_CHECK_EQUAL(r1 * z >= b, a >= b);
   BOOST_CHECK_EQUAL(r1 * z > b, a > b);

   BOOST_CHECK_EQUAL(a == r2 * z, a == b);
   BOOST_CHECK_EQUAL(a != r2 * z, a != b);
   BOOST_CHECK_EQUAL(a <= r2 * z, a <= b);
   BOOST_CHECK_EQUAL(a < r2 * z, a < b);
   BOOST_CHECK_EQUAL(a >= r2 * z, a >= b);
   BOOST_CHECK_EQUAL(a > r2 * z, a > b);

   BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(r2)), cr);
   BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(r1)), -cr);
   BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(b)), cr);
   BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(a)), -cr);
}

template <class Real, class Val>
typename std::enable_if<boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex>::type
test_comparisons(Val a, Val b, const std::integral_constant<bool, true>&)
{
   Real r1(a);
   Real r2(b);
   Real z(1);

   int cr = a < b ? -1 : a > b ? 1 : 0;
   (void)cr;

   BOOST_CHECK_EQUAL(r1 == r2, a == b);
   BOOST_CHECK_EQUAL(r1 != r2, a != b);

   BOOST_CHECK_EQUAL(r1 == b, a == b);
   BOOST_CHECK_EQUAL(r1 != b, a != b);

   BOOST_CHECK_EQUAL(a == r2, a == b);
   BOOST_CHECK_EQUAL(a != r2, a != b);

   BOOST_CHECK_EQUAL(r1 * z == r2, a == b);
   BOOST_CHECK_EQUAL(r1 * z != r2, a != b);

   BOOST_CHECK_EQUAL(r1 == r2 * z, a == b);
   BOOST_CHECK_EQUAL(r1 != r2 * z, a != b);

   BOOST_CHECK_EQUAL(r1 * z == r2 * z, a == b);
   BOOST_CHECK_EQUAL(r1 * z != r2 * z, a != b);

   BOOST_CHECK_EQUAL(r1 * z == b, a == b);
   BOOST_CHECK_EQUAL(r1 * z != b, a != b);

   BOOST_CHECK_EQUAL(a == r2 * z, a == b);
   BOOST_CHECK_EQUAL(a != r2 * z, a != b);

   if (r1 == r2)
   {
      BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(r2)), 0);
      BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(r1)), 0);
      BOOST_CHECK_EQUAL(normalize_compare_result(r1.compare(b)), 0);
      BOOST_CHECK_EQUAL(normalize_compare_result(r2.compare(a)), 0);
   }
   else
   {
      BOOST_CHECK_NE(normalize_compare_result(r1.compare(r2)), 0);
      BOOST_CHECK_NE(normalize_compare_result(r2.compare(r1)), 0);
      BOOST_CHECK_NE(normalize_compare_result(r1.compare(b)), 0);
      BOOST_CHECK_NE(normalize_compare_result(r2.compare(a)), 0);
   }
}

template <class Real, class Exp>
void test_conditional(Real v, Exp e)
{
   //
   // Verify that Exp is usable in Boolean contexts, and has the same value as v:
   //
   if (e)
   {
      BOOST_CHECK(v);
   }
   else
   {
      BOOST_CHECK(!v);
   }
   if (!e)
   {
      BOOST_CHECK(!v);
   }
   else
   {
      BOOST_CHECK(v);
   }
}

template <class Real>
void test_complement(Real a, Real b, Real c, const std::integral_constant<bool, true>&)
{
   int i         = 1020304;
   int j         = 56789123;
   int sign_mask = ~0;
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed)
   {
      BOOST_CHECK_EQUAL(~a, (~i & sign_mask));
      c = a & ~b;
      BOOST_CHECK_EQUAL(c, (i & (~j & sign_mask)));
      c = ~(a | b);
      BOOST_CHECK_EQUAL(c, (~(i | j) & sign_mask));
   }
   else
   {
      BOOST_CHECK_EQUAL((~a & a), 0);
   }
}

template <class Real>
void test_complement(Real, Real, Real, const std::integral_constant<bool, false>&)
{
}

template <class Real, class T>
void test_integer_ops(const T&) {}

template <class Real>
void test_rational(const std::integral_constant<bool, true>&)
{
   Real a(2);
   a /= 3;
   BOOST_CHECK_EQUAL(numerator(a), 2);
   BOOST_CHECK_EQUAL(denominator(a), 3);
   Real b(4);
   b /= 6;
   BOOST_CHECK_EQUAL(a, b);

   //
   // Check IO code:
   //
   std::stringstream ss;
   ss << a;
   ss >> b;
   BOOST_CHECK_EQUAL(a, b);
}
template <class Real>
void test_rational_signed(const std::integral_constant<bool, true>&)
{
   Real three = -3;
   BOOST_CHECK_EQUAL(static_cast<std::int16_t>(three), -3);
   BOOST_CHECK_EQUAL(static_cast<std::int32_t>(three), -3);
   BOOST_CHECK_EQUAL(static_cast<std::int64_t>(three), -3);
}
template <class Real>
void test_rational_signed(const std::integral_constant<bool, false>&)
{
}

template <class Real>
void test_rational(const std::integral_constant<bool, false>&)
{
   typedef typename Real::value_type value_type;
   Real a(2);
   a /= 3;
   BOOST_CHECK_EQUAL(numerator(a), 2);
   BOOST_CHECK_EQUAL(denominator(a), 3);
   Real b(4);
   b /= 6;
   BOOST_CHECK_EQUAL(a, b);

#ifndef BOOST_NO_EXCEPTIONS
   BOOST_CHECK_THROW(Real(a / 0), std::overflow_error);
   BOOST_CHECK_THROW(Real("3.14"), std::runtime_error);
   //
   // Check construction/assignment from zero denominator:
   //
   BOOST_CHECK_THROW(Real(5, 0), std::overflow_error);
   BOOST_CHECK_THROW(Real(value_type(5), value_type(0)), std::overflow_error);
   BOOST_CHECK_THROW(Real("5", "0"), std::overflow_error);
   BOOST_CHECK_THROW(Real(1).assign(5, 0), std::overflow_error);
   BOOST_CHECK_THROW(Real(1).assign(value_type(5), value_type(0)), std::overflow_error);
   BOOST_CHECK_THROW(Real(1).assign("5", "0"), std::overflow_error);
#endif
   b = Real("2/3");
   BOOST_CHECK_EQUAL(a, b);
   //
   // Check IO code:
   //
   std::stringstream ss;
   ss << a;
   ss >> b;
   BOOST_CHECK_EQUAL(a, b);
   //
   // Conversion to integer, see https://github.com/boostorg/multiprecision/issues/342.
   //
   Real three(10, 3);
   BOOST_CHECK_EQUAL(static_cast<std::uint16_t>(three), 3);
   BOOST_CHECK_EQUAL(static_cast<std::uint32_t>(three), 3);
   BOOST_CHECK_EQUAL(static_cast<std::uint64_t>(three), 3);
   test_rational_signed<Real>(std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());
   //
   // Verify normalization:
   //
   {
      Real c(20, 6);
      BOOST_CHECK_EQUAL(numerator(c), 10);
      BOOST_CHECK_EQUAL(denominator(c), 3);
      c.assign(15, 6);
      BOOST_CHECK_EQUAL(numerator(c), 5);
      BOOST_CHECK_EQUAL(denominator(c), 2);
   }
   {
      typename Real::value_type v1(20), v2(6);
      Real                      c(v1, v2);
      BOOST_CHECK_EQUAL(numerator(c), 10);
      BOOST_CHECK_EQUAL(denominator(c), 3);
      v1 = 15;
      v2 = 6;
      c.assign(v1, v2);
      BOOST_CHECK_EQUAL(numerator(c), 5);
      BOOST_CHECK_EQUAL(denominator(c), 2);
   }
   {
      Real c("20", "6");
      BOOST_CHECK_EQUAL(numerator(c), 10);
      BOOST_CHECK_EQUAL(denominator(c), 3);
      c.assign("15", "6");
      BOOST_CHECK_EQUAL(numerator(c), 5);
      BOOST_CHECK_EQUAL(denominator(c), 2);
   }
   //
   // Verify normalization of negative denominator:
   //
   BOOST_IF_CONSTEXPR(std::numeric_limits<value_type>::is_signed)
   {
      {
         Real c(20, -6);
         BOOST_CHECK_EQUAL(numerator(c), -10);
         BOOST_CHECK_EQUAL(denominator(c), 3);
         c.assign(15, -6);
         BOOST_CHECK_EQUAL(numerator(c), -5);
         BOOST_CHECK_EQUAL(denominator(c), 2);
      }
      {
         typename Real::value_type v1(20), v2(-6);
         Real                      c(v1, v2);
         BOOST_CHECK_EQUAL(numerator(c), -10);
         BOOST_CHECK_EQUAL(denominator(c), 3);
         v1 = 15;
         v2 = -6;
         c.assign(v1, v2);
         BOOST_CHECK_EQUAL(numerator(c), -5);
         BOOST_CHECK_EQUAL(denominator(c), 2);
      }
      {
         Real c("20", "-6");
         BOOST_CHECK_EQUAL(numerator(c), -10);
         BOOST_CHECK_EQUAL(denominator(c), 3);
         c.assign("15", "-6");
         BOOST_CHECK_EQUAL(numerator(c), -5);
         BOOST_CHECK_EQUAL(denominator(c), 2);
      }
   }
}

template <class Real>
void test_integer_ops(const std::integral_constant<int, boost::multiprecision::number_kind_rational>&)
{
   test_rational<Real>(is_boost_rational<Real>());
}

template <class Real>
void test_signed_integer_ops(const std::integral_constant<bool, true>&)
{
   Real a(20);
   Real b(7);
   Real c(5);
   BOOST_CHECK_EQUAL(-a % c, 0);
   BOOST_CHECK_EQUAL(-a % b, -20 % 7);
   BOOST_CHECK_EQUAL(-a % -b, -20 % -7);
   BOOST_CHECK_EQUAL(a % -b, 20 % -7);
   BOOST_CHECK_EQUAL(-a % 7, -20 % 7);
   BOOST_CHECK_EQUAL(-a % -7, -20 % -7);
   BOOST_CHECK_EQUAL(a % -7, 20 % -7);
   BOOST_CHECK_EQUAL(-a % 7u, -20 % 7);
   BOOST_CHECK_EQUAL(-a % a, 0);
   BOOST_CHECK_EQUAL(-a % 5, 0);
   BOOST_CHECK_EQUAL(-a % -5, 0);
   BOOST_CHECK_EQUAL(a % -5, 0);

   b = -b;
   BOOST_CHECK_EQUAL(a % b, 20 % -7);
   a = -a;
   BOOST_CHECK_EQUAL(a % b, -20 % -7);
   BOOST_CHECK_EQUAL(a % -7, -20 % -7);
   b = 7;
   BOOST_CHECK_EQUAL(a % b, -20 % 7);
   BOOST_CHECK_EQUAL(a % 7, -20 % 7);
   BOOST_CHECK_EQUAL(a % 7u, -20 % 7);

   a = 20;
   a %= b;
   BOOST_CHECK_EQUAL(a, 20 % 7);
   a = -20;
   a %= b;
   BOOST_CHECK_EQUAL(a, -20 % 7);
   a = 20;
   a %= -b;
   BOOST_CHECK_EQUAL(a, 20 % -7);
   a = -20;
   a %= -b;
   BOOST_CHECK_EQUAL(a, -20 % -7);
   a = 5;
   a %= b - a;
   BOOST_CHECK_EQUAL(a, 5 % (7 - 5));
   a = -20;
   a %= 7;
   BOOST_CHECK_EQUAL(a, -20 % 7);
   a = 20;
   a %= -7;
   BOOST_CHECK_EQUAL(a, 20 % -7);
   a = -20;
   a %= -7;
   BOOST_CHECK_EQUAL(a, -20 % -7);
#ifndef BOOST_NO_LONG_LONG
   a = -20;
   a %= 7uLL;
   BOOST_CHECK_EQUAL(a, -20 % 7);
   a = 20;
   a %= -7LL;
   BOOST_CHECK_EQUAL(a, 20 % -7);
   a = -20;
   a %= -7LL;
   BOOST_CHECK_EQUAL(a, -20 % -7);
#endif
   a = 400;
   b = 45;
   #ifndef BOOST_MP_STANDALONE
   BOOST_CHECK_EQUAL(gcd(a, -45), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, -45), boost::integer::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(-400, b), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(-400, b), boost::integer::lcm(400, 45));
   #elif __cpp_lib_gcd_lcm >= 201606L
   BOOST_CHECK_EQUAL(gcd(a, -45), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, -45), std::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(-400, b), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(-400, b), std::lcm(400, 45));
   #endif

   a = -20;
   BOOST_CHECK_EQUAL(abs(a), 20);
   BOOST_CHECK_EQUAL(abs(-a), 20);
   BOOST_CHECK_EQUAL(abs(+a), 20);
   a = 20;
   BOOST_CHECK_EQUAL(abs(a), 20);
   BOOST_CHECK_EQUAL(abs(-a), 20);
   BOOST_CHECK_EQUAL(abs(+a), 20);
   a = -400;
   b = 45;
   #ifndef BOOST_MP_STANDALONE
   BOOST_CHECK_EQUAL(gcd(a, b), boost::integer::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(a, b), boost::integer::lcm(-400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45), boost::integer::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45), boost::integer::lcm(-400, 45));
   BOOST_CHECK_EQUAL(gcd(-400, b), boost::integer::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(-400, b), boost::integer::lcm(-400, 45));
   #elif __cpp_lib_gcd_lcm >= 201606L
   BOOST_CHECK_EQUAL(gcd(a, b), std::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(a, b), std::lcm(-400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45), std::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45), std::lcm(-400, 45));
   BOOST_CHECK_EQUAL(gcd(-400, b), std::gcd(-400, 45));
   BOOST_CHECK_EQUAL(lcm(-400, b), std::lcm(-400, 45));
   #endif

   Real r;
   divide_qr(a, b, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   BOOST_CHECK_EQUAL(integer_modulus(a, 57), abs(a % 57));
   b = -57;
   divide_qr(a, b, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   BOOST_CHECK_EQUAL(integer_modulus(a, -57), abs(a % -57));
   a = 458;
   divide_qr(a, b, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   BOOST_CHECK_EQUAL(integer_modulus(a, -57), abs(a % -57));
#ifndef TEST_CHECKED_INT
   if (is_checked_cpp_int<Real>::value)
   {
      a = -1;
#ifndef BOOST_NO_EXCEPTIONS
      BOOST_CHECK_THROW(a << 2, std::range_error);
      BOOST_CHECK_THROW(a >> 2, std::range_error);
      BOOST_CHECK_THROW(a <<= 2, std::range_error);
      BOOST_CHECK_THROW(a >>= 2, std::range_error);
#endif
   }
   else
   {
      a = -1;
      BOOST_CHECK_EQUAL(a << 10, -1024);
      a = -23;
      BOOST_CHECK_EQUAL(a << 10, -23552);
      a = -23456;
      BOOST_CHECK_EQUAL(a >> 10, -23);
      a = -3;
      BOOST_CHECK_EQUAL(a >> 10, -1);
   }
#endif
}
template <class Real>
void test_signed_integer_ops(const std::integral_constant<bool, false>&)
{
}

template <class Real>
inline Real negate_if_signed(Real r, const std::integral_constant<bool, true>&)
{
   return -r;
}
template <class Real>
inline Real negate_if_signed(Real r, const std::integral_constant<bool, false>&)
{
   return r;
}

template <class Real, class Int>
void test_integer_overflow()
{
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::digits > std::numeric_limits<Int>::digits)
   {
      Real m((std::numeric_limits<Int>::max)());
      Int  r;
      ++m;
      if (is_checked_cpp_int<Real>::value)
      {
         BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
      }
      else if (boost::multiprecision::detail::is_signed<Int>::value)
      {
         r = m.template convert_to<Int>();
         BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::max)());
      }
      else
      {
         r = m.template convert_to<Int>();
         BOOST_CHECK_EQUAL(r, 0);
      }
      // Again with much larger value:
      m = 1u;
      m <<= (std::min)(std::numeric_limits<Real>::digits - 1, 1000);
      if (is_checked_cpp_int<Real>::value)
      {
         BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
      }
      else if (boost::multiprecision::detail::is_signed<Int>::value && boost::multiprecision::detail::is_integral<Int>::value)
      {
         r = m.template convert_to<Int>();
         BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::max)());
      }
      else
      {
         r = m.template convert_to<Int>();
         BOOST_CHECK_EQUAL(r, 0);
      }

      BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed && (boost::multiprecision::detail::is_signed<Int>::value))
      {
         m = (std::numeric_limits<Int>::min)();
         --m;
         if (is_checked_cpp_int<Real>::value)
         {
            BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
         }
         else
         {
            r = m.template convert_to<Int>();
            BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::min)());
         }
         // Again with much larger value:
         m = 2u;
         m = pow(m, (std::min)(std::numeric_limits<Real>::digits - 1, 1000));
         ++m;
         m = negate_if_signed(m, std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());
         if (is_checked_cpp_int<Real>::value)
         {
            BOOST_CHECK_THROW(m.template convert_to<Int>(), std::overflow_error);
         }
         else
         {
            r = m.template convert_to<Int>();
            BOOST_CHECK_EQUAL(r, (std::numeric_limits<Int>::min)());
         }
      }
      else BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed && !boost::multiprecision::detail::is_signed<Int>::value)
      {
         // signed to unsigned converison with overflow, it's really not clear what should happen here!
         #if 0
         m = (std::numeric_limits<Int>::max)();
         ++m;
         m = negate_if_signed(m, std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());
         BOOST_CHECK_THROW(m.template convert_to<Int>(), std::range_error);
         // Again with much larger value:
         m = 2u;
         m = pow(m, (std::min)(std::numeric_limits<Real>::digits - 1, 1000));
         m = negate_if_signed(m, std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());
         BOOST_CHECK_THROW(m.template convert_to<Int>(), std::range_error);
         #endif
      }
   }
}

template <class Real, class Int>
void test_integer_round_trip()
{
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::digits >= std::numeric_limits<Int>::digits)
   {
      Real m((std::numeric_limits<Int>::max)());
      Int  r = m.template convert_to<Int>();
      BOOST_CHECK_EQUAL(m, r);
      BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed && (std::numeric_limits<Real>::digits > std::numeric_limits<Int>::digits))
      {
         m = (std::numeric_limits<Int>::min)();
         r = m.template convert_to<Int>();
         BOOST_CHECK_EQUAL(m, r);
      }
   }
   test_integer_overflow<Real, Int>();
}

template <class Real>
void test_integer_ops(const std::integral_constant<int, boost::multiprecision::number_kind_integer>&)
{
   test_signed_integer_ops<Real>(std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());

   Real a(20);
   Real b(7);
   Real c(5);
   BOOST_CHECK_EQUAL(a % b, 20 % 7);
   BOOST_CHECK_EQUAL(a % 7, 20 % 7);
   BOOST_CHECK_EQUAL(a % 7u, 20 % 7);
   BOOST_CHECK_EQUAL(a % a, 0);
   BOOST_CHECK_EQUAL(a % c, 0);
   BOOST_CHECK_EQUAL(a % 5, 0);
   a = a % (b + 0);
   BOOST_CHECK_EQUAL(a, 20 % 7);
   a = 20;
   c = (a + 2) % (a - 1);
   BOOST_CHECK_EQUAL(c, 22 % 19);
   c = 5;
   a = b % (a - 15);
   BOOST_CHECK_EQUAL(a, 7 % 5);
   a = 20;

   a = 20;
   a %= 7;
   BOOST_CHECK_EQUAL(a, 20 % 7);
#ifndef BOOST_NO_LONG_LONG
   a = 20;
   a %= 7uLL;
   BOOST_CHECK_EQUAL(a, 20 % 7);
#endif
   a = 20;
   ++a;
   BOOST_CHECK_EQUAL(a, 21);
   --a;
   BOOST_CHECK_EQUAL(a, 20);
   BOOST_CHECK_EQUAL(a++, 20);
   BOOST_CHECK_EQUAL(a, 21);
   BOOST_CHECK_EQUAL(a--, 21);
   BOOST_CHECK_EQUAL(a, 20);
   a = 2000;
   a <<= 20;
   BOOST_CHECK_EQUAL(a, 2000L << 20);
   a >>= 20;
   BOOST_CHECK_EQUAL(a, 2000);
   a <<= 20u;
   BOOST_CHECK_EQUAL(a, 2000L << 20);
   a >>= 20u;
   BOOST_CHECK_EQUAL(a, 2000);
#ifndef BOOST_NO_EXCEPTIONS
   BOOST_CHECK_THROW(a <<= -20, std::out_of_range);
   BOOST_CHECK_THROW(a >>= -20, std::out_of_range);
   BOOST_CHECK_THROW(Real(a << -20), std::out_of_range);
   BOOST_CHECK_THROW(Real(a >> -20), std::out_of_range);
#endif
#ifndef BOOST_NO_LONG_LONG
   if (sizeof(long long) > sizeof(std::size_t))
   {
      // extreme values should trigger an exception:
#ifndef BOOST_NO_EXCEPTIONS
      BOOST_CHECK_THROW(a >>= (1uLL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
      BOOST_CHECK_THROW(a <<= (1uLL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
      BOOST_CHECK_THROW(a >>= -(1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
      BOOST_CHECK_THROW(a <<= -(1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
      BOOST_CHECK_THROW(a >>= (1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
      BOOST_CHECK_THROW(a <<= (1LL << (sizeof(long long) * CHAR_BIT - 2)), std::out_of_range);
#endif
      // Unless they fit within range:
      a = 2000L;
      a <<= 20uLL;
      BOOST_CHECK_EQUAL(a, (2000L << 20));
      a = 2000;
      a <<= 20LL;
      BOOST_CHECK_EQUAL(a, (2000L << 20));

#ifndef BOOST_NO_EXCEPTIONS
      BOOST_CHECK_THROW(Real(a >> (1uLL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
      BOOST_CHECK_THROW(Real(a <<= (1uLL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
      BOOST_CHECK_THROW(Real(a >>= -(1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
      BOOST_CHECK_THROW(Real(a <<= -(1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
      BOOST_CHECK_THROW(Real(a >>= (1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
      BOOST_CHECK_THROW(Real(a <<= (1LL << (sizeof(long long) * CHAR_BIT - 2))), std::out_of_range);
#endif
      // Unless they fit within range:
      a = 2000L;
      BOOST_CHECK_EQUAL(Real(a << 20uLL), (2000L << 20));
      a = 2000;
      BOOST_CHECK_EQUAL(Real(a << 20LL), (2000L << 20));
   }
#endif
   a = 20;
   b = a << 20;
   BOOST_CHECK_EQUAL(b, (20 << 20));
   b = a >> 2;
   BOOST_CHECK_EQUAL(b, (20 >> 2));
   b = (a + 2) << 10;
   BOOST_CHECK_EQUAL(b, (22 << 10));
   b = (a + 3) >> 3;
   BOOST_CHECK_EQUAL(b, (23 >> 3));
   //
   // Bit fiddling:
   //
   int i = 1020304;
   int j = 56789123;
   int k = 4523187;
   a     = i;
   b     = j;
   c     = a;
   c &= b;
   BOOST_CHECK_EQUAL(c, (i & j));
   c = a;
   c &= j;
   BOOST_CHECK_EQUAL(c, (i & j));
   c = a;
   c &= a + b;
   BOOST_CHECK_EQUAL(c, (i & (i + j)));
   BOOST_CHECK_EQUAL((a & b), (i & j));
   c = k;
   a = a & (b + k);
   BOOST_CHECK_EQUAL(a, (i & (j + k)));
   a = i;
   a = (b + k) & a;
   BOOST_CHECK_EQUAL(a, (i & (j + k)));
   a = i;
   c = a & b & k;
   BOOST_CHECK_EQUAL(c, (i & j & k));
   c = a;
   c &= (c + b);
   BOOST_CHECK_EQUAL(c, (i & (i + j)));
   c = a & (b | 1);
   BOOST_CHECK_EQUAL(c, (i & (j | 1)));

   test_complement<Real>(a, b, c, typename is_twos_complement_integer<Real>::type());

   a = i;
   b = j;
   c = a;
   c |= b;
   BOOST_CHECK_EQUAL(c, (i | j));
   c = a;
   c |= j;
   BOOST_CHECK_EQUAL(c, (i | j));
   c = a;
   c |= a + b;
   BOOST_CHECK_EQUAL(c, (i | (i + j)));
   BOOST_CHECK_EQUAL((a | b), (i | j));
   c = k;
   a = a | (b + k);
   BOOST_CHECK_EQUAL(a, (i | (j + k)));
   a = i;
   a = (b + k) | a;
   BOOST_CHECK_EQUAL(a, (i | (j + k)));
   a = i;
   c = a | b | k;
   BOOST_CHECK_EQUAL(c, (i | j | k));
   c = a;
   c |= (c + b);
   BOOST_CHECK_EQUAL(c, (i | (i + j)));
   c = a | (b | 1);
   BOOST_CHECK_EQUAL(c, (i | (j | 1)));

   a = i;
   b = j;
   c = a;
   c ^= b;
   BOOST_CHECK_EQUAL(c, (i ^ j));
   c = a;
   c ^= j;
   BOOST_CHECK_EQUAL(c, (i ^ j));
   c = a;
   c ^= a + b;
   BOOST_CHECK_EQUAL(c, (i ^ (i + j)));
   BOOST_CHECK_EQUAL((a ^ b), (i ^ j));
   c = k;
   a = a ^ (b + k);
   BOOST_CHECK_EQUAL(a, (i ^ (j + k)));
   a = i;
   a = (b + k) ^ a;
   BOOST_CHECK_EQUAL(a, (i ^ (j + k)));
   a = i;
   c = a ^ b ^ k;
   BOOST_CHECK_EQUAL(c, (i ^ j ^ k));
   c = a;
   c ^= (c + b);
   BOOST_CHECK_EQUAL(c, (i ^ (i + j)));
   c = a ^ (b | 1);
   BOOST_CHECK_EQUAL(c, (i ^ (j | 1)));

   a = i;
   b = j;
   c = k;
   //
   // Non-member functions:
   //
   a = 400;
   b = 45;
   #ifndef BOOST_MP_STANDALONE
   BOOST_CHECK_EQUAL(gcd(a, b), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, b), boost::integer::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45), boost::integer::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45u), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45u), boost::integer::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(400, b), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(400, b), boost::integer::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(400u, b), boost::integer::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(400u, b), boost::integer::lcm(400, 45));
   #elif __cpp_lib_gcd_lcm >= 201606L
   BOOST_CHECK_EQUAL(gcd(a, b), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, b), std::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45), std::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(a, 45u), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(a, 45u), std::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(400, b), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(400, b), std::lcm(400, 45));
   BOOST_CHECK_EQUAL(gcd(400u, b), std::gcd(400, 45));
   BOOST_CHECK_EQUAL(lcm(400u, b), std::lcm(400, 45));
   #endif

   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_bounded)
   {
      // Fixed precision integer:
      a = (std::numeric_limits<Real>::max)() - 1;
      b = (std::numeric_limits<Real>::max)() / 35;
      Real div = gcd(a, b);
      BOOST_CHECK_EQUAL(a % div, 0);
      BOOST_CHECK_EQUAL(b % div, 0);
   }

   //
   // Conditionals involving 2 arg functions:
   //
   test_conditional(Real(gcd(a, b)), gcd(a, b));

   Real r;
   divide_qr(a, b, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   divide_qr(a + 0, b, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   divide_qr(a, b + 0, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   divide_qr(a + 0, b + 0, c, r);
   BOOST_CHECK_EQUAL(c, a / b);
   BOOST_CHECK_EQUAL(r, a % b);
   BOOST_CHECK_EQUAL(integer_modulus(a, 57), a % 57);
   for (i = 0; i < 20; ++i)
   {
      if (std::numeric_limits<Real>::is_specialized && (!std::numeric_limits<Real>::is_bounded || ((int)i * 17 < std::numeric_limits<Real>::digits)))
      {
         BOOST_CHECK_EQUAL(lsb(Real(1) << (i * 17)), static_cast<unsigned>(i * 17));
         BOOST_CHECK_EQUAL(msb(Real(1) << (i * 17)), static_cast<unsigned>(i * 17));
         BOOST_CHECK(bit_test(Real(1) << (i * 17), i * 17));
         BOOST_CHECK(!bit_test(Real(1) << (i * 17), i * 17 + 1));
         if (i)
         {
            BOOST_CHECK(!bit_test(Real(1) << (i * 17), i * 17 - 1));
         }
         Real zero(0);
         BOOST_CHECK(bit_test(bit_set(zero, i * 17), i * 17));
         zero = 0;
         BOOST_CHECK_EQUAL(bit_flip(zero, i * 17), Real(1) << i * 17);
         zero = Real(1) << i * 17;
         BOOST_CHECK_EQUAL(bit_flip(zero, i * 17), 0);
         zero = Real(1) << i * 17;
         BOOST_CHECK_EQUAL(bit_unset(zero, i * 17), 0);
      }
   }
   //
   // pow, powm:
   //
   BOOST_CHECK_EQUAL(pow(Real(3), 4u), 81);
   BOOST_CHECK_EQUAL(pow(Real(3) + Real(0), 4u), 81);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4), Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4), 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4), Real(13) + 0), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), Real(4) + 0, Real(13) + 0), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3), 4 + 0, Real(13) + 0), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4), Real(13) + 0), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, Real(4) + 0, Real(13) + 0), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, Real(13)), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, 13), 81 % 13);
   BOOST_CHECK_EQUAL(powm(Real(3) + 0, 4 + 0, Real(13) + 0), 81 % 13);
   //
   // Conditionals involving 3 arg functions:
   //
   test_conditional(Real(powm(Real(3), Real(4), Real(13))), powm(Real(3), Real(4), Real(13)));

#ifndef BOOST_NO_EXCEPTIONS
   //
   // Things that are expected errors:
   //
   BOOST_CHECK_THROW(Real("3.14"), std::runtime_error);
   BOOST_CHECK_THROW(Real("3L"), std::runtime_error);
   BOOST_CHECK_THROW(Real(Real(20) / 0u), std::overflow_error);
#endif
   //
   // Extra tests added for full coverage:
   //
   a = 20;
   b = 7;
   c = 20 % b;
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = 20 % (b + 0);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = a & 10;
   BOOST_CHECK_EQUAL(c, (20 & 10));
   c = 10 & a;
   BOOST_CHECK_EQUAL(c, (20 & 10));
   c = (a + 0) & (b + 0);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = 10 & (a + 0);
   BOOST_CHECK_EQUAL(c, (20 & 10));
   c = 10 | a;
   BOOST_CHECK_EQUAL(c, (20 | 10));
   c = (a + 0) | (b + 0);
   BOOST_CHECK(c == (20 | 7))
   c = 20 | (b + 0);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = a ^ 7;
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = 20 ^ b;
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = (a + 0) ^ (b + 0);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = 20 ^ (b + 0);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   //
   // RValue ref tests:
   //
   c = Real(20) % b;
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = a % Real(7);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = Real(20) % Real(7);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = Real(20) % 7;
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = 20 % Real(7);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = Real(20) % (b * 1);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = (a * 1 + 0) % Real(7);
   BOOST_CHECK_EQUAL(c, (20 % 7));
   c = Real(20) >> 2;
   BOOST_CHECK_EQUAL(c, (20 >> 2));
   c = Real(20) & b;
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = a & Real(7);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = Real(20) & Real(7);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = Real(20) & 7;
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = 20 & Real(7);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = Real(20) & (b * 1 + 0);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = (a * 1 + 0) & Real(7);
   BOOST_CHECK_EQUAL(c, (20 & 7));
   c = Real(20) | b;
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = a | Real(7);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = Real(20) | Real(7);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = Real(20) | 7;
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = 20 | Real(7);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = Real(20) | (b * 1 + 0);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = (a * 1 + 0) | Real(7);
   BOOST_CHECK_EQUAL(c, (20 | 7));
   c = Real(20) ^ b;
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = a ^ Real(7);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = Real(20) ^ Real(7);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = Real(20) ^ 7;
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = 20 ^ Real(7);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = Real(20) ^ (b * 1 + 0);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));
   c = (a * 1 + 0) ^ Real(7);
   BOOST_CHECK_EQUAL(c, (20 ^ 7));

   //
   // Round tripping of built in integers:
   //
   test_integer_round_trip<Real, short>();
   test_integer_round_trip<Real, unsigned short>();
   test_integer_round_trip<Real, int>();
   test_integer_round_trip<Real, unsigned int>();
   test_integer_round_trip<Real, long>();
   test_integer_round_trip<Real, unsigned long>();
#ifndef BOOST_NO_LONG_LONG
   test_integer_round_trip<Real, long long>();
   test_integer_round_trip<Real, unsigned long long>();
#endif
}

template <class Real, class T>
void test_float_funcs(const T&) {}

template <class Real>
void test_float_funcs(const std::integral_constant<bool, true>&)
{
   if (boost::multiprecision::is_interval_number<Real>::value)
      return;
   //
   // Test variable reuse in function calls, see https://svn.boost.org/trac/boost/ticket/8326
   //
   Real a(2), b(10), c, d;
   a = pow(a, b);
   BOOST_CHECK_EQUAL(a, 1024);
   a = 2;
   b = pow(a, b);
   BOOST_CHECK_EQUAL(b, 1024);
   b = 10;
   a = pow(a, 10);
   BOOST_CHECK_EQUAL(a, 1024);
   a = -2;
   a = abs(a);
   BOOST_CHECK_EQUAL(a, 2);
   a = -2;
   a = fabs(a);
   BOOST_CHECK_EQUAL(a, 2);
   a = 2.5;
   a = floor(a);
   BOOST_CHECK_EQUAL(a, 2);
   a = 2.5;
   a = ceil(a);
   BOOST_CHECK_EQUAL(a, 3);
   a = 2.5;
   a = trunc(a);
   BOOST_CHECK_EQUAL(a, 2);
   a = 2.25;
   a = round(a);
   BOOST_CHECK_EQUAL(a, 2);
   a = 2;
   a = ldexp(a, 1);
   BOOST_CHECK_EQUAL(a, 4);
   int i;
   a = frexp(a, &i);
   BOOST_CHECK_EQUAL(a, 0.5);

   Real tol = std::numeric_limits<Real>::epsilon() * 3;
   a        = 4;
   a        = sqrt(a);
   BOOST_CHECK_CLOSE_FRACTION(a, 2, tol);
   a = 3;
   a = exp(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(exp(Real(3))), tol);
   a = 3;
   a = log(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(log(Real(3))), tol);
   a = 3;
   a = log10(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(log10(Real(3))), tol);

   a = 0.5;
   a = sin(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(sin(Real(0.5))), tol);
   a = 0.5;
   a = cos(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(cos(Real(0.5))), tol);
   a = 0.5;
   a = tan(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(tan(Real(0.5))), tol);
   a = 0.5;
   a = asin(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(asin(Real(0.5))), tol);
   a = 0.5;
   a = acos(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(acos(Real(0.5))), tol);
   a = 0.5;
   a = atan(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(atan(Real(0.5))), tol);
   a = 0.5;
   a = sinh(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(sinh(Real(0.5))), tol);
   a = 0.5;
   a = cosh(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(cosh(Real(0.5))), tol);
   a = 0.5;
   a = tanh(a);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(tanh(Real(0.5))), tol);
   // fmod, need to check all the sign permutations:
   a = 4;
   b = 2;
   a = fmod(a, b);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(Real(4), Real(2))), tol);
   a = 4;
   b = fmod(a, b);
   BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(Real(4), Real(2))), tol);
   a = 4;
   b = 2;
   a = fmod(-a, b);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(-Real(4), Real(2))), tol);
   a = 4;
   b = fmod(-a, b);
   BOOST_CHECK_CLOSE_FRACTION(b, Real(-fmod(Real(4), Real(2))), tol);
   a = 4;
   b = 2;
   a = fmod(a, -b);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(Real(4), -Real(2))), tol);
   a = 4;
   b = fmod(a, -b);
   BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(Real(4), -Real(2))), tol);
   a = 4;
   b = 2;
   a = fmod(-a, -b);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(fmod(-Real(4), -Real(2))), tol);
   a = 4;
   b = fmod(-a, -b);
   BOOST_CHECK_CLOSE_FRACTION(b, Real(fmod(-Real(4), -Real(2))), tol);
   // modf:
   a = 5;
   a /= 2;
   b = modf(a, &c);
   BOOST_CHECK_EQUAL(b + c, a);
   BOOST_CHECK_EQUAL(b > 0, a > 0);
   BOOST_CHECK_EQUAL(c > 0, a > 0);
   a = -a;
   b = modf(a, &c);
   BOOST_CHECK_EQUAL(b + c, a);
   BOOST_CHECK_EQUAL(b > 0, a > 0);
   BOOST_CHECK_EQUAL(c > 0, a > 0);
   b = modf(a, &c);
   c = 0;
   modf(a, &c);
   BOOST_CHECK_EQUAL(b + c, a);
   BOOST_CHECK_EQUAL(b > 0, a > 0);
   BOOST_CHECK_EQUAL(c > 0, a > 0);
   a = -a;
   b = modf(a, &c);
   c = 0;
   modf(a, &c);
   BOOST_CHECK_EQUAL(b + c, a);
   BOOST_CHECK_EQUAL(b > 0, a > 0);
   BOOST_CHECK_EQUAL(c > 0, a > 0);

   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_infinity)
   {
      a = std::numeric_limits<Real>::infinity();
      b = modf(a, &c);
      BOOST_CHECK_EQUAL(a, c);
      BOOST_CHECK_EQUAL(b, 0);
      a = -std::numeric_limits<Real>::infinity();
      b = modf(a, &c);
      BOOST_CHECK_EQUAL(a, c);
      BOOST_CHECK_EQUAL(b, 0);
   }
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_quiet_NaN)
   {
      a = std::numeric_limits<Real>::quiet_NaN();
      b = modf(a, &c);
      #ifndef BOOST_MP_STANDALONE
      BOOST_CHECK((boost::math::isnan)(b));
      BOOST_CHECK((boost::math::isnan)(c));
      #endif
   }

   a = 4;
   b = 2;
   a = atan2(a, b);
   BOOST_CHECK_CLOSE_FRACTION(a, Real(atan2(Real(4), Real(2))), tol);
   a = 4;
   b = atan2(a, b);
   BOOST_CHECK_CLOSE_FRACTION(b, Real(atan2(Real(4), Real(2))), tol);

   // fma:
   a = 2;
   b = 4;
   c = 6;
   BOOST_CHECK_EQUAL(fma(a, b, c), 14);
   BOOST_CHECK_EQUAL(fma(a, 4, c), 14);
   BOOST_CHECK_EQUAL(fma(a, b, 6), 14);
   BOOST_CHECK_EQUAL(fma(a, 4, 6), 14);
   BOOST_CHECK_EQUAL(fma(a + 0, b, c), 14);
   BOOST_CHECK_EQUAL(fma(a - 0, 4, c), 14);
   BOOST_CHECK_EQUAL(fma(a * 1, b, 6), 14);
   BOOST_CHECK_EQUAL(fma(a / 1, 4, 6), 14);
   BOOST_CHECK_EQUAL(fma(2, b, c), 14);
   BOOST_CHECK_EQUAL(fma(2, b, 6), 14);
   BOOST_CHECK_EQUAL(fma(2, b * 1, c), 14);
   BOOST_CHECK_EQUAL(fma(2, b + 0, 6), 14);
   BOOST_CHECK_EQUAL(fma(2, 4, c), 14);
   BOOST_CHECK_EQUAL(fma(2, 4, c + 0), 14);

   // Default construct, for consistency with native floats, default constructed values are zero:
   Real zero;
   BOOST_CHECK_EQUAL(zero, 0);

   //
   // Complex number functions on scalars:
   //
   #ifdef BOOST_MP_MATH_AVAILABLE
   a = 40;
   BOOST_CHECK_EQUAL(Real(arg(a)), 0);
   BOOST_CHECK_EQUAL(Real(arg(a + 0)), 0);
   a - 20;
   BOOST_CHECK_EQUAL(Real(arg(a)), 0);
   BOOST_CHECK_EQUAL(Real(arg(a - 20)), 0);
   #endif
}

template <class T, class U>
void compare_NaNs(const T& a, const U& b)
{
   BOOST_CHECK_EQUAL(a == b, false);
   BOOST_CHECK_EQUAL(a != b, true);
   BOOST_CHECK_EQUAL(a <= b, false);
   BOOST_CHECK_EQUAL(a >= b, false);
   BOOST_CHECK_EQUAL(a > b, false);
   BOOST_CHECK_EQUAL(a < b, false);
   //
   // Again where LHS may be an expression template:
   //
   BOOST_CHECK_EQUAL(1 * a == b, false);
   BOOST_CHECK_EQUAL(1 * a != b, true);
   BOOST_CHECK_EQUAL(1 * a <= b, false);
   BOOST_CHECK_EQUAL(1 * a >= b, false);
   BOOST_CHECK_EQUAL(1 * a > b, false);
   BOOST_CHECK_EQUAL(1 * a < b, false);
   //
   // Again where RHS may be an expression template:
   //
   BOOST_CHECK_EQUAL(a == b * 1, false);
   BOOST_CHECK_EQUAL(a != b * 1, true);
   BOOST_CHECK_EQUAL(a <= b * 1, false);
   BOOST_CHECK_EQUAL(a >= b * 1, false);
   BOOST_CHECK_EQUAL(a > b * 1, false);
   BOOST_CHECK_EQUAL(a < b * 1, false);
   //
   // Again where LHS and RHS may be an expression templates:
   //
   BOOST_CHECK_EQUAL(1 * a == b * 1, false);
   BOOST_CHECK_EQUAL(1 * a != b * 1, true);
   BOOST_CHECK_EQUAL(1 * a <= b * 1, false);
   BOOST_CHECK_EQUAL(1 * a >= b * 1, false);
   BOOST_CHECK_EQUAL(1 * a > b * 1, false);
   BOOST_CHECK_EQUAL(1 * a < b * 1, false);
}

template <class Real, class T>
void test_float_ops(const T&) {}

template <class Real>
void test_float_ops(const std::integral_constant<int, boost::multiprecision::number_kind_floating_point>&)
{
   BOOST_CHECK_EQUAL(abs(Real(2)), 2);
   BOOST_CHECK_EQUAL(abs(Real(-2)), 2);
   BOOST_CHECK_EQUAL(fabs(Real(2)), 2);
   BOOST_CHECK_EQUAL(fabs(Real(-2)), 2);
   BOOST_CHECK_EQUAL(floor(Real(5) / 2), 2);
   BOOST_CHECK_EQUAL(ceil(Real(5) / 2), 3);
   BOOST_CHECK_EQUAL(floor(Real(-5) / 2), -3);
   BOOST_CHECK_EQUAL(ceil(Real(-5) / 2), -2);
   BOOST_CHECK_EQUAL(trunc(Real(5) / 2), 2);
   BOOST_CHECK_EQUAL(trunc(Real(-5) / 2), -2);
   //
   // ldexp and frexp, these pretty much have to be implemented by each backend:
   //
   typedef typename Real::backend_type::exponent_type e_type;
   BOOST_CHECK_EQUAL(ldexp(Real(2), 5), 64);
   BOOST_CHECK_EQUAL(ldexp(Real(2), -5), Real(2) / 32);
   Real   v(512);
   e_type exponent;
   Real   r = frexp(v, &exponent);
   BOOST_CHECK_EQUAL(r, 0.5);
   BOOST_CHECK_EQUAL(exponent, 10);
   BOOST_CHECK_EQUAL(v, 512);
   v = 1 / v;
   r = frexp(v, &exponent);
   BOOST_CHECK_EQUAL(r, 0.5);
   BOOST_CHECK_EQUAL(exponent, -8);
   BOOST_CHECK_EQUAL(ldexp(Real(2), e_type(5)), 64);
   BOOST_CHECK_EQUAL(ldexp(Real(2), e_type(-5)), Real(2) / 32);
   v = 512;
   e_type exp2;
   r = frexp(v, &exp2);
   BOOST_CHECK_EQUAL(r, 0.5);
   BOOST_CHECK_EQUAL(exp2, 10);
   BOOST_CHECK_EQUAL(v, 512);
   v = 1 / v;
   r = frexp(v, &exp2);
   BOOST_CHECK_EQUAL(r, 0.5);
   BOOST_CHECK_EQUAL(exp2, -8);
   //
   // scalbn and logb, these are the same as ldexp and frexp unless the radix is
   // something other than 2:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_specialized && std::numeric_limits<Real>::radix)
   {
      BOOST_CHECK_EQUAL(scalbn(Real(2), 5), 2 * pow(double(std::numeric_limits<Real>::radix), 5));
      BOOST_CHECK_EQUAL(scalbn(Real(2), -5), Real(2) / pow(double(std::numeric_limits<Real>::radix), 5));
      v        = 512;
      exponent = ilogb(v);
      r        = scalbn(v, -exponent);
      BOOST_CHECK(r >= 1);
      BOOST_CHECK(r < std::numeric_limits<Real>::radix);
      BOOST_CHECK_EQUAL(exponent, logb(v));
      BOOST_CHECK_EQUAL(v, scalbn(r, exponent));
      v        = 1 / v;
      exponent = ilogb(v);
      r        = scalbn(v, -exponent);
      BOOST_CHECK(r >= 1);
      BOOST_CHECK(r < std::numeric_limits<Real>::radix);
      BOOST_CHECK_EQUAL(exponent, logb(v));
      BOOST_CHECK_EQUAL(v, scalbn(r, exponent));
   }
   //
   // pow and exponent:
   //
   #ifndef BOOST_MP_STANDALONE
   v = 3.25;
   r = pow(v, 0);
   BOOST_CHECK_EQUAL(r, 1);
   r = pow(v, 1);
   BOOST_CHECK_EQUAL(r, 3.25);
   r = pow(v, 2);
   BOOST_CHECK_EQUAL(r, boost::math::pow<2>(3.25));
   r = pow(v, 3);
   BOOST_CHECK_EQUAL(r, boost::math::pow<3>(3.25));
   r = pow(v, 4);
   BOOST_CHECK_EQUAL(r, boost::math::pow<4>(3.25));
   r = pow(v, 5);
   BOOST_CHECK_EQUAL(r, boost::math::pow<5>(3.25));
   r = pow(v, 6);
   BOOST_CHECK_EQUAL(r, boost::math::pow<6>(3.25));
   r = pow(v, 25);
   BOOST_CHECK_EQUAL(r, boost::math::pow<25>(Real(3.25)));
   #endif

#ifndef BOOST_NO_EXCEPTIONS
   //
   // Things that are expected errors:
   //
   BOOST_CHECK_THROW(Real("3.14L"), std::runtime_error);
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_specialized)
   {
      BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_infinity)
      {
         #ifndef BOOST_MP_STANDALONE
         BOOST_CHECK((boost::math::isinf)(Real(20) / 0u));
         #endif
      }
      else
      {
         BOOST_CHECK_THROW(r = Real(Real(20) / 0u), std::overflow_error);
      }
   }
#endif
   //
   // Comparisons of NaN's should always fail:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_quiet_NaN)
   {
      r = v = std::numeric_limits<Real>::quiet_NaN();
      compare_NaNs(r, v);
      v = 0;
      compare_NaNs(r, v);
      r.swap(v);
      compare_NaNs(r, v);
      //
      // Conmpare NaN to int:
      //
      compare_NaNs(v, 0);
      compare_NaNs(0, v);
      //
      // Compare to floats:
      //
      compare_NaNs(v, 0.5);
      compare_NaNs(0.5, v);
      BOOST_IF_CONSTEXPR (std::numeric_limits<double>::has_quiet_NaN)
      {
         compare_NaNs(r, std::numeric_limits<double>::quiet_NaN());
         compare_NaNs(std::numeric_limits<double>::quiet_NaN(), r);
      }
   }

   //
   // Operations involving NaN's as one argument:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_quiet_NaN)
   {
      #ifndef BOOST_MP_STANDALONE
      v = 20.25;
      r = std::numeric_limits<Real>::quiet_NaN();
      BOOST_CHECK((boost::math::isnan)(v + r));
      BOOST_CHECK((boost::math::isnan)(r + v));
      BOOST_CHECK((boost::math::isnan)(r - v));
      BOOST_CHECK((boost::math::isnan)(v - r));
      BOOST_CHECK((boost::math::isnan)(r * v));
      BOOST_CHECK((boost::math::isnan)(v * r));
      BOOST_CHECK((boost::math::isnan)(r / v));
      BOOST_CHECK((boost::math::isnan)(v / r));
      Real t = v;
      BOOST_CHECK((boost::math::isnan)(t += r));
      t = r;
      BOOST_CHECK((boost::math::isnan)(t += v));
      t = r;
      BOOST_CHECK((boost::math::isnan)(t -= v));
      t = v;
      BOOST_CHECK((boost::math::isnan)(t -= r));
      t = r;
      BOOST_CHECK((boost::math::isnan)(t *= v));
      t = v;
      BOOST_CHECK((boost::math::isnan)(t *= r));
      t = r;
      BOOST_CHECK((boost::math::isnan)(t /= v));
      t = v;
      BOOST_CHECK((boost::math::isnan)(t /= r));
      #endif
   }
   //
   // Operations involving infinities as one argument:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_infinity)
   {
      v = 20.25;
      r = std::numeric_limits<Real>::infinity();

      #ifndef BOOST_MP_STANDALONE
      BOOST_CHECK((boost::math::isinf)(v + r));
      BOOST_CHECK((boost::math::isinf)(r + v));
      BOOST_CHECK((boost::math::isinf)(r - v));
      BOOST_CHECK((boost::math::isinf)(v - r));
      BOOST_CHECK((boost::math::isinf)(r * v));
      BOOST_CHECK((boost::math::isinf)(v * r));
      BOOST_CHECK((boost::math::isinf)(r / v));
      #endif

      BOOST_CHECK_LT(v - r, 0);
      BOOST_CHECK_EQUAL(v / r, 0);
      #ifndef BOOST_MP_STANDALONE
      Real t = v;
      BOOST_CHECK((boost::math::isinf)(t += r));
      t = r;
      BOOST_CHECK((boost::math::isinf)(t += v));
      t = r;
      BOOST_CHECK((boost::math::isinf)(t -= v));
      t = v;
      BOOST_CHECK((boost::math::isinf)(t -= r));
      t = v;
      BOOST_CHECK(t -= r < 0);
      t = r;
      BOOST_CHECK((boost::math::isinf)(t *= v));
      t = v;
      BOOST_CHECK((boost::math::isinf)(t *= r));
      t = r;
      BOOST_CHECK((boost::math::isinf)(t /= v));
      t = v;
      BOOST_CHECK((t /= r) == 0);
      #endif
   }
   //
   // Operations that should produce NaN as a result:
   //
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_quiet_NaN)
   {
      v = r  = 0;
      Real t = v / r;

      #ifndef BOOST_MP_STANDALONE
      BOOST_CHECK((boost::math::isnan)(t));
      v /= r;
      BOOST_CHECK((boost::math::isnan)(v));
      t = v / 0;
      BOOST_CHECK((boost::math::isnan)(v));
      #endif

      BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_infinity)
      {
         #ifndef BOOST_MP_STANDALONE
         v = 0;
         r = std::numeric_limits<Real>::infinity();
         t = v * r;
         if (!boost::multiprecision::is_interval_number<Real>::value)
         {
            BOOST_CHECK((boost::math::isnan)(t));
            t = r * 0;
            BOOST_CHECK((boost::math::isnan)(t));
         }
         v = r;
         t = r / v;
         BOOST_CHECK((boost::math::isnan)(t));
         #endif
      }
   }

   test_float_funcs<Real>(std::integral_constant<bool, std::numeric_limits<Real>::is_specialized>());
}

template <class T>
struct lexical_cast_target_type
{
   typedef typename std::conditional<
       boost::multiprecision::detail::is_signed<T>::value && boost::multiprecision::detail::is_integral<T>::value,
       std::intmax_t,
       typename std::conditional<
           boost::multiprecision::detail::is_unsigned<T>::value,
           std::uintmax_t,
           T>::type>::type type;
};

template <class Real, class Num>
void test_negative_mixed_minmax(std::integral_constant<bool, true> const&)
{
   if (!std::numeric_limits<Real>::is_bounded || (std::numeric_limits<Real>::digits >= std::numeric_limits<Num>::digits))
   {
      Real mx1((std::numeric_limits<Num>::max)() - 1);
      ++mx1;
      Real mx2((std::numeric_limits<Num>::max)());
      BOOST_CHECK_EQUAL(mx1, mx2);
      mx1 = (std::numeric_limits<Num>::max)() - 1;
      ++mx1;
      mx2 = (std::numeric_limits<Num>::max)();
      BOOST_CHECK_EQUAL(mx1, mx2);

      if (!std::numeric_limits<Real>::is_bounded || (std::numeric_limits<Real>::digits > std::numeric_limits<Num>::digits))
      {
         Real mx3((std::numeric_limits<Num>::min)() + 1);
         --mx3;
         Real mx4((std::numeric_limits<Num>::min)());
         BOOST_CHECK_EQUAL(mx3, mx4);
         mx3 = (std::numeric_limits<Num>::min)() + 1;
         --mx3;
         mx4 = (std::numeric_limits<Num>::min)();
         BOOST_CHECK_EQUAL(mx3, mx4);
      }
   }
}
template <class Real, class Num>
void test_negative_mixed_minmax(std::integral_constant<bool, false> const&)
{
}

template <class Real, class Num>
void test_negative_mixed_numeric_limits(std::integral_constant<bool, true> const&)
{
   #ifndef BOOST_MP_STANDALONE
   typedef typename lexical_cast_target_type<Num>::type target_type;
#if defined(TEST_MPFR)
   Num tol = 10 * std::numeric_limits<Num>::epsilon();
#else
   Num tol = 0;
#endif
   static const int        left_shift      = std::numeric_limits<Num>::digits - 1;
   Num                     n1              = -static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
   Num                     n2              = -1;
   Num                     n3              = 0;
   Num                     n4              = -20;
   std::ios_base::fmtflags f               = std::is_floating_point<Num>::value ? std::ios_base::scientific : std::ios_base::fmtflags(0);
   int                     digits_to_print = std::is_floating_point<Num>::value && std::numeric_limits<Num>::is_specialized
                             ? std::numeric_limits<Num>::digits10 + 5
                             : 0;
   BOOST_IF_CONSTEXPR (std::numeric_limits<target_type>::digits <= std::numeric_limits<Real>::digits)
   {
      BOOST_CHECK_CLOSE(n1, checked_lexical_cast<target_type>(Real(n1).str(digits_to_print, f)), tol);
   }
   BOOST_CHECK_CLOSE(n2, checked_lexical_cast<target_type>(Real(n2).str(digits_to_print, f)), 0);
   BOOST_CHECK_CLOSE(n3, checked_lexical_cast<target_type>(Real(n3).str(digits_to_print, f)), 0);
   BOOST_CHECK_CLOSE(n4, checked_lexical_cast<target_type>(Real(n4).str(digits_to_print, f)), 0);
   #endif
}

template <class Real, class Num>
void test_negative_mixed_numeric_limits(std::integral_constant<bool, false> const&) {}

template <class Real, class Num>
void test_negative_mixed(std::integral_constant<bool, true> const&)
{
   typedef typename std::conditional<
       std::is_convertible<Num, Real>::value,
       typename std::conditional<boost::multiprecision::detail::is_integral<Num>::value && (sizeof(Num) < sizeof(int)), int, Num>::type,
       Real>::type cast_type;
   typedef typename std::conditional<
       std::is_convertible<Num, Real>::value,
       Num,
       Real>::type simple_cast_type;
   std::cout << "Testing mixed arithmetic with type: " << name_of<Real>() << " and " << name_of<Num>() << std::endl;
   static const int left_shift = std::numeric_limits<Num>::digits - 1;
   Num              n1         = -static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
   Num              n2         = -1;
   Num              n3         = 0;
   Num              n4         = -20;
   Num              n5         = -8;

   test_comparisons<Real>(n1, n2, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n1, n3, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n3, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n2, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n1, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n3, n3, std::is_convertible<Num, Real>());

   // Default construct:
   BOOST_CHECK_EQUAL(Real(n1), static_cast<cast_type>(n1));
   BOOST_CHECK_EQUAL(Real(n2), static_cast<cast_type>(n2));
   BOOST_CHECK_EQUAL(Real(n3), static_cast<cast_type>(n3));
   BOOST_CHECK_EQUAL(Real(n4), static_cast<cast_type>(n4));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n1), Real(n1));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n2), Real(n2));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n3), Real(n3));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n4), Real(n4));
   BOOST_CHECK_EQUAL(Real(n1).template convert_to<Num>(), n1);
   BOOST_CHECK_EQUAL(Real(n2).template convert_to<Num>(), n2);
   BOOST_CHECK_EQUAL(Real(n3).template convert_to<Num>(), n3);
   BOOST_CHECK_EQUAL(Real(n4).template convert_to<Num>(), n4);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1)), n1);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2)), n2);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3)), n3);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4)), n4);
   // Conversions when source is an expression template:
   BOOST_CHECK_EQUAL((Real(n1) + 0).template convert_to<Num>(), n1);
   BOOST_CHECK_EQUAL((Real(n2) + 0).template convert_to<Num>(), n2);
   BOOST_CHECK_EQUAL((Real(n3) + 0).template convert_to<Num>(), n3);
   BOOST_CHECK_EQUAL((Real(n4) + 0).template convert_to<Num>(), n4);
   BOOST_CHECK_EQUAL(static_cast<Num>((Real(n1) + 0)), n1);
   BOOST_CHECK_EQUAL(static_cast<Num>((Real(n2) + 0)), n2);
   BOOST_CHECK_EQUAL(static_cast<Num>((Real(n3) + 0)), n3);
   BOOST_CHECK_EQUAL(static_cast<Num>((Real(n4) + 0)), n4);
   test_negative_mixed_numeric_limits<Real, Num>(std::integral_constant<bool, std::numeric_limits<Real>::is_specialized && std::numeric_limits<Num>::is_specialized>());
   // Assignment:
   Real r(0);
   BOOST_CHECK(r != static_cast<cast_type>(n1));
   r = static_cast<simple_cast_type>(n1);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1));
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2));
   r = static_cast<simple_cast_type>(n3);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n3));
   r = static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
   // Addition:
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r + static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 + n4));
   BOOST_CHECK_EQUAL(Real(r + static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 + n4));
   r += static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 + n4));
   // subtraction:
   r = static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r - static_cast<simple_cast_type>(n5), static_cast<cast_type>(n4 - n5));
   BOOST_CHECK_EQUAL(Real(r - static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n4 - n5));
   r -= static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
   // Multiplication:
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r * static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 * n4));
   BOOST_CHECK_EQUAL(Real(r * static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 * n4));
   r *= static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 * n4));
   // Division:
   r = static_cast<simple_cast_type>(n1);
   BOOST_CHECK_EQUAL(r / static_cast<simple_cast_type>(n5), static_cast<cast_type>(n1 / n5));
   BOOST_CHECK_EQUAL(Real(r / static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n1 / n5));
   r /= static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1 / n5));
   //
   // Extra cases for full coverage:
   //
   r = Real(n4) + static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
   r = static_cast<simple_cast_type>(n4) + Real(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
   r = Real(n4) - static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
   r = static_cast<simple_cast_type>(n4) - Real(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
   r = static_cast<simple_cast_type>(n4) * Real(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 * n5));
   r = static_cast<cast_type>(Num(4) * n4) / Real(4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));

   Real a, b, c;
   a = 20;
   b = 30;
   c = -a + b;
   BOOST_CHECK_EQUAL(c, 10);
   c = b + -a;
   BOOST_CHECK_EQUAL(c, 10);
   n4 = 30;
   c  = -a + static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, 10);
   c = static_cast<cast_type>(n4) + -a;
   BOOST_CHECK_EQUAL(c, 10);
   c = -a + -b;
   BOOST_CHECK_EQUAL(c, -50);
   n4 = 4;
   c  = -(a + b) + static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, -50 + 4);
   n4 = 50;
   c  = (a + b) - static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, 0);
   c = (a + b) - static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, 0);
   c = a - -(b + static_cast<cast_type>(n4));
   BOOST_CHECK_EQUAL(c, 20 - -(30 + 50));
   c = -(b + static_cast<cast_type>(n4)) - a;
   BOOST_CHECK_EQUAL(c, -(30 + 50) - 20);
   c = a - -b;
   BOOST_CHECK_EQUAL(c, 50);
   c = -a - b;
   BOOST_CHECK_EQUAL(c, -50);
   c = -a - static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, -20 - 50);
   c = static_cast<cast_type>(n4) - -a;
   BOOST_CHECK_EQUAL(c, 50 + 20);
   c = -(a + b) - Real(n4);
   BOOST_CHECK_EQUAL(c, -(20 + 30) - 50);
   c = static_cast<cast_type>(n4) - (a + b);
   BOOST_CHECK_EQUAL(c, 0);
   c = (a + b) * static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, 50 * 50);
   c = static_cast<cast_type>(n4) * (a + b);
   BOOST_CHECK_EQUAL(c, 50 * 50);
   c = a * -(b + static_cast<cast_type>(n4));
   BOOST_CHECK_EQUAL(c, 20 * -(30 + 50));
   c = -(b + static_cast<cast_type>(n4)) * a;
   BOOST_CHECK_EQUAL(c, 20 * -(30 + 50));
   c = a * -b;
   BOOST_CHECK_EQUAL(c, 20 * -30);
   c = -a * b;
   BOOST_CHECK_EQUAL(c, 20 * -30);
   c = -a * static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, -20 * 50);
   c = static_cast<cast_type>(n4) * -a;
   BOOST_CHECK_EQUAL(c, -20 * 50);
   c = -(a + b) + a;
   BOOST_CHECK(-50 + 20);
   c = static_cast<cast_type>(n4) - (a + b);
   BOOST_CHECK_EQUAL(c, 0);
   Real d = 10;
   c      = (a + b) / d;
   BOOST_CHECK_EQUAL(c, 5);
   c = (a + b) / (d + 0);
   BOOST_CHECK_EQUAL(c, 5);
   c = (a + b) / static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, 1);
   c = static_cast<cast_type>(n4) / (a + b);
   BOOST_CHECK_EQUAL(c, 1);
   d = 50;
   c = d / -(a + b);
   BOOST_CHECK_EQUAL(c, -1);
   c = -(a + b) / d;
   BOOST_CHECK_EQUAL(c, -1);
   d = 2;
   c = a / -d;
   BOOST_CHECK_EQUAL(c, 20 / -2);
   c = -a / d;
   BOOST_CHECK_EQUAL(c, 20 / -2);
   d = 50;
   c = -d / static_cast<cast_type>(n4);
   BOOST_CHECK_EQUAL(c, -1);
   c = static_cast<cast_type>(n4) / -d;
   BOOST_CHECK_EQUAL(c, -1);
   c = static_cast<cast_type>(n4) + a;
   BOOST_CHECK_EQUAL(c, 70);
   c = static_cast<cast_type>(n4) - a;
   BOOST_CHECK_EQUAL(c, 30);
   c = static_cast<cast_type>(n4) * a;
   BOOST_CHECK_EQUAL(c, 50 * 20);

   n1 = -2;
   n2 = -3;
   n3 = -4;
   a  = static_cast<cast_type>(n1);
   b  = static_cast<cast_type>(n2);
   c  = static_cast<cast_type>(n3);
   d  = a + b * c;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = static_cast<cast_type>(n1) + b * c;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = a + static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = a + b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = static_cast<cast_type>(n1) + static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = static_cast<cast_type>(n1) + b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   a += static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(a, -2 + -3 * -4);
   a = static_cast<cast_type>(n1);
   a += b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(a, -2 + -3 * -4);
   a = static_cast<cast_type>(n1);

   d = b * c + a;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = b * c + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = static_cast<cast_type>(n2) * c + a;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = b * static_cast<cast_type>(n3) + a;
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = static_cast<cast_type>(n2) * c + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);
   d = b * static_cast<cast_type>(n3) + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -2 + -3 * -4);

   a = -20;
   d = a - b * c;
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   n1 = -20;
   d  = static_cast<cast_type>(n1) - b * c;
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   d = a - static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   d = a - b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   d = static_cast<cast_type>(n1) - static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   d = static_cast<cast_type>(n1) - b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, -20 - -3 * -4);
   a -= static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(a, -20 - -3 * -4);
   a = static_cast<cast_type>(n1);
   a -= b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(a, -20 - -3 * -4);

   a = -2;
   d = b * c - a;
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   n1 = -2;
   d  = b * c - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   d = static_cast<cast_type>(n2) * c - a;
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   d = b * static_cast<cast_type>(n3) - a;
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   d = static_cast<cast_type>(n2) * c - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   d = b * static_cast<cast_type>(n3) - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -3 * -4 - -2);
   //
   // Conversion from min and max values:
   //
   test_negative_mixed_minmax<Real, Num>(std::integral_constant<bool, std::numeric_limits<Real>::is_integer && std::numeric_limits<Num>::is_integer > ());
   //
   // RValue ref overloads:
   //
   a  = 2;
   n1 = 3;
   d  = -a + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 1);
   d = static_cast<cast_type>(n1) + -a;
   BOOST_CHECK_EQUAL(d, 1);
   d = -a - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -5);
   d = static_cast<cast_type>(n1) - -a;
   BOOST_CHECK_EQUAL(d, 5);
   d = -a * static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, -6);
   d = static_cast<cast_type>(n1) * -a;
   BOOST_CHECK_EQUAL(d, -6);
   n1 = 4;
   d  = -static_cast<cast_type>(n1) / a;
   BOOST_CHECK_EQUAL(d, -2);
   d = static_cast<cast_type>(n1) / -a;
   BOOST_CHECK_EQUAL(d, -2);
}

template <class Real, class Num>
void test_negative_mixed(std::integral_constant<bool, false> const&)
{
}

template <class Real, class Num>
void test_mixed(const std::integral_constant<bool, false>&)
{
}

template <class Real>
inline bool check_is_nan(const Real& val, const std::integral_constant<bool, true>&)
{
   #ifndef BOOST_MP_STANDALONE
   return (boost::math::isnan)(val);
   #else
   return true; // Avoids warnings. This functionality is never used in standalone mode
   #endif
}
template <class Real>
inline bool check_is_nan(const Real&, const std::integral_constant<bool, false>&)
{
   return false;
}
template <class Real>
inline Real negate_value(const Real& val, const std::integral_constant<bool, true>&)
{
   return -val;
}
template <class Real>
inline Real negate_value(const Real& val, const std::integral_constant<bool, false>&)
{
   return val;
}

template <class Real, class Num>
void test_mixed_numeric_limits(const std::integral_constant<bool, true>&)
{
   #ifndef BOOST_MP_STANDALONE
   typedef typename lexical_cast_target_type<Num>::type target_type;
#if defined(TEST_MPFR)
   Num tol = 10 * std::numeric_limits<Num>::epsilon();
#else
   Num tol = 0;
#endif

   Real d;
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_infinity && std::numeric_limits<Num>::has_infinity)
   {
      d = static_cast<Real>(std::numeric_limits<Num>::infinity());
      BOOST_CHECK_GT(d, (std::numeric_limits<Real>::max)());
      d = static_cast<Real>(negate_value(std::numeric_limits<Num>::infinity(), std::integral_constant<bool, std::numeric_limits<Num>::is_signed>()));
      BOOST_CHECK_LT(d, negate_value((std::numeric_limits<Real>::max)(), std::integral_constant<bool, std::numeric_limits<Real>::is_signed>()));
   }
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::has_quiet_NaN && std::numeric_limits<Num>::has_quiet_NaN)
   {
      #ifndef BOOST_MP_STANDALONE
      d = static_cast<Real>(std::numeric_limits<Num>::quiet_NaN());
      BOOST_CHECK(check_is_nan(d, std::integral_constant<bool, std::numeric_limits<Real>::has_quiet_NaN>()));
      d = static_cast<Real>(negate_value(std::numeric_limits<Num>::quiet_NaN(), std::integral_constant<bool, std::numeric_limits<Num>::is_signed>()));
      BOOST_CHECK(check_is_nan(d, std::integral_constant<bool, std::numeric_limits<Real>::has_quiet_NaN>()));
      #endif
   }

   static const int left_shift = std::numeric_limits<Num>::digits - 1;
   Num              n1         = static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
   Num              n2         = 1;
   Num              n3         = 0;
   Num              n4         = 20;

   std::ios_base::fmtflags f               = std::is_floating_point<Num>::value ? std::ios_base::scientific : std::ios_base::fmtflags(0);
   int                     digits_to_print = std::is_floating_point<Num>::value && std::numeric_limits<Num>::is_specialized
                             ? std::numeric_limits<Num>::digits10 + 5
                             : 0;
   BOOST_IF_CONSTEXPR (std::numeric_limits<target_type>::digits <= std::numeric_limits<Real>::digits)
   {
      BOOST_CHECK_CLOSE(n1, checked_lexical_cast<target_type>(Real(n1).str(digits_to_print, f)), tol);
   }
   BOOST_CHECK_CLOSE(n2, checked_lexical_cast<target_type>(Real(n2).str(digits_to_print, f)), 0);
   BOOST_CHECK_CLOSE(n3, checked_lexical_cast<target_type>(Real(n3).str(digits_to_print, f)), 0);
   BOOST_CHECK_CLOSE(n4, checked_lexical_cast<target_type>(Real(n4).str(digits_to_print, f)), 0);
   #endif // BOOST_MP_STANDALONE
}
template <class Real, class Num>
void test_mixed_numeric_limits(const std::integral_constant<bool, false>&)
{
}

template <class Num>
struct is_definitely_unsigned_int
    : public std::integral_constant<bool, std::numeric_limits<Num>::is_specialized && !std::numeric_limits<Num>::is_signed>
{};
#ifdef BOOST_HAS_INT128
template <>
struct is_definitely_unsigned_int<boost::uint128_type>
    : public std::true_type
{};
#endif

template <class Real, class Num>
void test_mixed_rational(const std::true_type&)
{
   Real rat(2, 3);
   Num  zero(0);
   BOOST_CHECK_EQUAL(rat * zero, zero);
   rat *= zero;
   BOOST_CHECK_EQUAL(rat, zero);
   rat = Real(2, 3);
#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
   BOOST_IF_CONSTEXPR(std::is_floating_point<Num>::value)
   {
      Real rat2;
      Num  f = 0.5f;
      rat2   = rat * f;
      BOOST_CHECK_EQUAL(rat2, rat * Real(1, 2));
      rat2   = f * rat;
      BOOST_CHECK_EQUAL(rat2, rat * Real(1, 2));
      rat2   = rat / f;
      BOOST_CHECK_EQUAL(rat2, rat / Real(1, 2));
      rat2   = f / rat;
      BOOST_CHECK_EQUAL(rat2, Real(1, 2) / rat);
      rat2 = rat + f;
      BOOST_CHECK_EQUAL(rat2, rat + Real(1, 2));
      rat2 = f + rat;
      BOOST_CHECK_EQUAL(rat2, rat + Real(1, 2));
      rat2 = rat - f;
      BOOST_CHECK_EQUAL(rat2, rat - Real(1, 2));
      f    = 1.5f;
      rat2 = f - rat;
      BOOST_CHECK_EQUAL(rat2, Real(3, 2) - rat);
   }
#endif
}
template <class Real, class Num>
void test_mixed_rational(const std::false_type&)
{
}

template <class Real, class Num>
void test_mixed(const std::integral_constant<bool, true>&)
{
   typedef typename std::conditional<
       std::is_convertible<Num, Real>::value,
       typename std::conditional<boost::multiprecision::detail::is_integral<Num>::value && (sizeof(Num) < sizeof(int)), int, Num>::type,
       Real>::type cast_type;
   typedef typename std::conditional<
       std::is_convertible<Num, Real>::value,
       Num,
       Real>::type simple_cast_type;

   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_specialized && std::numeric_limits<Real>::is_bounded && std::numeric_limits<Real>::digits < std::numeric_limits<Num>::digits)
      return;

   std::cout << "Testing mixed arithmetic with type: " << name_of<Real>() << " and " << name_of<Num>() << std::endl;
   static const int left_shift = std::numeric_limits<Num>::digits - 1;
   Num              n1         = static_cast<Num>(1uLL << ((left_shift < 63) && (left_shift > 0) ? left_shift : 10));
   Num              n2         = 1;
   Num              n3         = 0;
   Num              n4         = 20;
   Num              n5         = 8;

   test_comparisons<Real>(n1, n2, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n1, n3, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n1, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n3, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n2, n1, std::is_convertible<Num, Real>());
   test_comparisons<Real>(n3, n3, std::is_convertible<Num, Real>());

   // Default construct:
   BOOST_CHECK_EQUAL(Real(n1), static_cast<cast_type>(n1));
   BOOST_CHECK_EQUAL(Real(n2), static_cast<cast_type>(n2));
   BOOST_CHECK_EQUAL(Real(n3), static_cast<cast_type>(n3));
   BOOST_CHECK_EQUAL(Real(n4), static_cast<cast_type>(n4));
   BOOST_CHECK_EQUAL(Real(n1).template convert_to<Num>(), n1);
   BOOST_CHECK_EQUAL(Real(n2).template convert_to<Num>(), n2);
   BOOST_CHECK_EQUAL(Real(n3).template convert_to<Num>(), n3);
   BOOST_CHECK_EQUAL(Real(n4).template convert_to<Num>(), n4);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1)), n1);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2)), n2);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3)), n3);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4)), n4);
   // Again with expression templates:
   BOOST_CHECK_EQUAL((Real(n1) + 0).template convert_to<Num>(), n1);
   BOOST_CHECK_EQUAL((Real(n2) + 0).template convert_to<Num>(), n2);
   BOOST_CHECK_EQUAL((Real(n3) + 0).template convert_to<Num>(), n3);
   BOOST_CHECK_EQUAL((Real(n4) + 0).template convert_to<Num>(), n4);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n1) + 0), n1);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n2) + 0), n2);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n3) + 0), n3);
   BOOST_CHECK_EQUAL(static_cast<Num>(Real(n4) + 0), n4);
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n1), Real(n1));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n2), Real(n2));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n3), Real(n3));
   BOOST_CHECK_EQUAL(static_cast<cast_type>(n4), Real(n4));
   // Assignment:
   Real r(0);
   BOOST_CHECK(r != static_cast<cast_type>(n1));
   r = static_cast<simple_cast_type>(n1);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1));
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2));
   r = static_cast<simple_cast_type>(n3);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n3));
   r = static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));
   // Addition:
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r + static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 + n4));
   BOOST_CHECK_EQUAL(Real(r + static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 + n4));
   r += static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 + n4));
   // subtraction:
   r = static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r - static_cast<simple_cast_type>(n5), static_cast<cast_type>(n4 - n5));
   BOOST_CHECK_EQUAL(Real(r - static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n4 - n5));
   r -= static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
   // Multiplication:
   r = static_cast<simple_cast_type>(n2);
   BOOST_CHECK_EQUAL(r * static_cast<simple_cast_type>(n4), static_cast<cast_type>(n2 * n4));
   BOOST_CHECK_EQUAL(Real(r * static_cast<simple_cast_type>(n4)), static_cast<cast_type>(n2 * n4));
   r *= static_cast<simple_cast_type>(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n2 * n4));
   // Division:
   r = static_cast<simple_cast_type>(n1);
   BOOST_CHECK_EQUAL(r / static_cast<simple_cast_type>(n5), static_cast<cast_type>(n1 / n5));
   BOOST_CHECK_EQUAL(Real(r / static_cast<simple_cast_type>(n5)), static_cast<cast_type>(n1 / n5));
   r /= static_cast<simple_cast_type>(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n1 / n5));
   //
   // special cases for full coverage:
   //
   r = static_cast<simple_cast_type>(n5) + Real(n4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 + n5));
   r = static_cast<simple_cast_type>(n4) - Real(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 - n5));
   r = static_cast<simple_cast_type>(n4) * Real(n5);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4 * n5));
   r = static_cast<cast_type>(Num(4) * n4) / Real(4);
   BOOST_CHECK_EQUAL(r, static_cast<cast_type>(n4));

   typedef std::integral_constant<bool,
       (!std::numeric_limits<Num>::is_specialized || std::numeric_limits<Num>::is_signed)
      && (!std::numeric_limits<Real>::is_specialized || std::numeric_limits<Real>::is_signed)
      && !is_definitely_unsigned_int<Num>::value>
       signed_tag;

   test_negative_mixed<Real, Num>(signed_tag());

   n1 = 2;
   n2 = 3;
   n3 = 4;
   Real a(n1), b(n2), c(n3), d;
   d = a + b * c;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = static_cast<cast_type>(n1) + b * c;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = a + static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = a + b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = static_cast<cast_type>(n1) + static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = static_cast<cast_type>(n1) + b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   a += static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(a, 2 + 3 * 4);
   a = static_cast<cast_type>(n1);
   a += b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(a, 2 + 3 * 4);
   a = static_cast<cast_type>(n1);

   d = b * c + a;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = b * c + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = static_cast<cast_type>(n2) * c + a;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = b * static_cast<cast_type>(n3) + a;
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = static_cast<cast_type>(n2) * c + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);
   d = b * static_cast<cast_type>(n3) + static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 2 + 3 * 4);

   a = 20;
   d = a - b * c;
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   n1 = 20;
   d  = static_cast<cast_type>(n1) - b * c;
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   d = a - static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   d = a - b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   d = static_cast<cast_type>(n1) - static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   d = static_cast<cast_type>(n1) - b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(d, 20 - 3 * 4);
   a -= static_cast<cast_type>(n2) * c;
   BOOST_CHECK_EQUAL(a, 20 - 3 * 4);
   a = static_cast<cast_type>(n1);
   a -= b * static_cast<cast_type>(n3);
   BOOST_CHECK_EQUAL(a, 20 - 3 * 4);

   a = 2;
   d = b * c - a;
   BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
   n1 = 2;
   d  = b * c - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
   d = static_cast<cast_type>(n2) * c - a;
   BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
   d = b * static_cast<cast_type>(n3) - a;
   BOOST_CHECK_EQUAL(d, 3 * 4 - a);
   d = static_cast<cast_type>(n2) * c - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 3 * 4 - 2);
   d = b * static_cast<cast_type>(n3) - static_cast<cast_type>(n1);
   BOOST_CHECK_EQUAL(d, 3 * 4 - 2);

   test_mixed_numeric_limits<Real, Num>(std::integral_constant < bool, std::numeric_limits<Real>::is_specialized && std::numeric_limits<Num>::is_specialized > ());
   test_mixed_rational<Real, Num>(std::integral_constant<bool, boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_rational>());
}

template <class Real>
typename std::enable_if<boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex>::type test_members(Real)
{
   //
   // Test sign and zero functions:
   //
   Real a = 20;
   Real b = 30;
   BOOST_CHECK(!a.is_zero());
   a = -20;
   BOOST_CHECK(!a.is_zero());
   a = 0;
   BOOST_CHECK(a.is_zero());

   a = 20;
   b = 30;
   a.swap(b);
   BOOST_CHECK_EQUAL(a, 30);
   BOOST_CHECK_EQUAL(b, 20);

   Real c(2, 3);

   BOOST_CHECK_EQUAL(a.real(), 30);
   BOOST_CHECK_EQUAL(a.imag(), 0);
   BOOST_CHECK_EQUAL(c.real(), 2);
   BOOST_CHECK_EQUAL(c.imag(), 3);

   //
   // try some more 2-argument constructors:
   //
   {
      Real d(40.5, 2);
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
   {
      Real d("40.5", "2");
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
   {
      Real d("40.5", std::string("2"));
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   {
      std::string      sx("40.550"), sy("222");
      std::string_view vx(sx.c_str(), 4), vy(sy.c_str(), 1);
      Real             d(vx, vy);
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
#endif
   {
      typename Real::value_type x(40.5), y(2);
      Real                      d(x, y);
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
#ifdef TEST_MPC
   {
      typename Real::value_type x(40.5), y(2);
      Real                      d(x.backend().data(), y.backend().data());
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
#endif
   {
      typename Real::value_type x(40.5);
      Real                      d(x, 2);
      BOOST_CHECK_EQUAL(d.real(), 40.5);
      BOOST_CHECK_EQUAL(d.imag(), 2);
   }
   {
      typename Real::value_type x(40.5);
      Real                      d(2, x);
      BOOST_CHECK_EQUAL(d.imag(), 40.5);
      BOOST_CHECK_EQUAL(d.real(), 2);
   }
   {
      typename Real::value_type x(real(a) * real(b) + imag(a) * imag(b)), y(imag(a) * real(b) - real(a) * imag(b));
      Real                      d(real(a) * real(b) + imag(a) * imag(b), imag(a) * real(b) - real(a) * imag(b));
      Real                      e(x, y);
      BOOST_CHECK_EQUAL(d, e);
   }
   //
   // real and imag setters:
   //
   c.real(4);
   BOOST_CHECK_EQUAL(real(c), 4);
   c.imag(-55);
   BOOST_CHECK_EQUAL(imag(c), -55);
   typename Real::value_type z(20);
   c.real(z);
   BOOST_CHECK_EQUAL(real(c), 20);
   c.real(21L);
   BOOST_CHECK_EQUAL(real(c), 21);
   c.real(22L);
   BOOST_CHECK_EQUAL(real(c), 22);
   c.real(23UL);
   BOOST_CHECK_EQUAL(real(c), 23);
   c.real(24U);
   BOOST_CHECK_EQUAL(real(c), 24);
   c.real(25.0f);
   BOOST_CHECK_EQUAL(real(c), 25);
   c.real(26.0);
   BOOST_CHECK_EQUAL(real(c), 26);
   c.real(27.0L);
   BOOST_CHECK_EQUAL(real(c), 27);
#if defined(BOOST_HAS_LONG_LONG)
   c.real(28LL);
   BOOST_CHECK_EQUAL(real(c), 28);
   c.real(29ULL);
   BOOST_CHECK_EQUAL(real(c), 29);
#endif
   c.imag(z);
   BOOST_CHECK_EQUAL(imag(c), 20);
   c.imag(21L);
   BOOST_CHECK_EQUAL(imag(c), 21);
   c.imag(22L);
   BOOST_CHECK_EQUAL(imag(c), 22);
   c.imag(23UL);
   BOOST_CHECK_EQUAL(imag(c), 23);
   c.imag(24U);
   BOOST_CHECK_EQUAL(imag(c), 24);
   c.imag(25.0f);
   BOOST_CHECK_EQUAL(imag(c), 25);
   c.imag(26.0);
   BOOST_CHECK_EQUAL(imag(c), 26);
   c.imag(27.0L);
   BOOST_CHECK_EQUAL(imag(c), 27);
#if defined(BOOST_HAS_LONG_LONG)
   c.imag(28LL);
   BOOST_CHECK_EQUAL(imag(c), 28);
   c.imag(29ULL);
   BOOST_CHECK_EQUAL(imag(c), 29);
#endif

   c.real(2).imag(3);

   BOOST_CHECK_EQUAL(real(a), 30);
   BOOST_CHECK_EQUAL(imag(a), 0);
   BOOST_CHECK_EQUAL(real(c), 2);
   BOOST_CHECK_EQUAL(imag(c), 3);
   BOOST_CHECK_EQUAL(real(a + 0), 30);
   BOOST_CHECK_EQUAL(imag(a + 0), 0);
   BOOST_CHECK_EQUAL(real(c + 0), 2);
   BOOST_CHECK_EQUAL(imag(c + 0), 3);

   // string construction:
   a = Real("2");
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), 0);
   a = Real("(2)");
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), 0);
   a = Real("(,2)");
   BOOST_CHECK_EQUAL(real(a), 0);
   BOOST_CHECK_EQUAL(imag(a), 2);
   a = Real("(2,3)");
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), 3);

   typedef typename boost::multiprecision::component_type<Real>::type real_type;

   real_type r(3);
   real_type tol = std::numeric_limits<real_type>::epsilon() * 30;

   a = r;
   BOOST_CHECK_EQUAL(real(a), 3);
   BOOST_CHECK_EQUAL(imag(a), 0);

   a += r;
   BOOST_CHECK_EQUAL(real(a), 6);
   BOOST_CHECK_EQUAL(imag(a), 0);

   a *= r;
   BOOST_CHECK_EQUAL(real(a), 18);
   BOOST_CHECK_EQUAL(imag(a), 0);

   a = a / r;
   BOOST_CHECK_EQUAL(real(a), 6);
   BOOST_CHECK_EQUAL(imag(a), 0);
   a = a - r;
   BOOST_CHECK_EQUAL(real(a), 3);
   BOOST_CHECK_EQUAL(imag(a), 0);
   a = r + a;
   BOOST_CHECK_EQUAL(real(a), 6);
   BOOST_CHECK_EQUAL(imag(a), 0);

   r = abs(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), r, tol);
   r = arg(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.98279372324732906798571061101466601449687745363162855676142508831798807154979603538970653437281731110816513970201"), r, tol);
   r = norm(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type(13), r, tol);
   a = conj(c);
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), -3);
   a = proj(c);
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), 3);
   a = polar(real_type(3), real_type(-10));
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
   a = polar(real_type(3) + 0, real_type(-10));
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
   a = polar(real_type(3), real_type(-10) + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
   a = polar(real_type(3) + 0, real_type(-10) + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
   a = polar(3, real_type(-10));
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);
   a = polar(3.0, real_type(-10) + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-2.517214587229357356776591843472194503559790495399505640507861193146377760598812305202801138281266416782353163216"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.63206333266810944021424298555413184505092903874867167472255203785027162892148027712122702168494964847488147271478"), imag(a), tol);

   a = polar(real_type(3));
   BOOST_CHECK_EQUAL(3, real(a));
   BOOST_CHECK_EQUAL(0, imag(a));
   a = polar(real_type(3) + 0);
   BOOST_CHECK_EQUAL(3, real(a));
   BOOST_CHECK_EQUAL(0, imag(a));

   r = abs(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), r, tol);
   r = arg(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.98279372324732906798571061101466601449687745363162855676142508831798807154979603538970653437281731110816513970201"), r, tol);
   r = norm(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type(13), r, tol);
   a = conj(c + 0);
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), -3);
   a = proj(c + 0);
   BOOST_CHECK_EQUAL(real(a), 2);
   BOOST_CHECK_EQUAL(imag(a), 3);

   a = exp(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-7.3151100949011025174865361510507893218698794489446322367845159660828327860599907104337742108443234172141249777"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.0427436562359044141015039404625521939183300604422348975424523449538886779880818796291971422701951470533151185"), imag(a), tol);

   a = log(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744384629096046"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.9827937232473290679857106110146660144968774536316285567614250883179880715497960353897065343728173111081651397020"), imag(a), tol);

   a = log10(c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.426821890855466638944275673291166123449562356934437957244904971730668088711719757900679614536803436424488603794"), imag(a), tol);

   a = exp(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-7.3151100949011025174865361510507893218698794489446322367845159660828327860599907104337742108443234172141249777"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.0427436562359044141015039404625521939183300604422348975424523449538886779880818796291971422701951470533151185"), imag(a), tol);

   a = log(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744384629096046"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.9827937232473290679857106110146660144968774536316285567614250883179880715497960353897065343728173111081651397020"), imag(a), tol);

   a = log10(c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.426821890855466638944275673291166123449562356934437957244904971730668088711719757900679614536803436424488603794"), imag(a), tol);

   // Powers where one arg is an integer.
   b = Real(5, -2);
   a = pow(c, b);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3053.8558566606567369633610140423321260211388217942246293871310470377722279440084474789529228008638668934381183"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("3097.9975862915005132449772136982559285192410496951232473245540634244845290672745578327467396750607773968246915"), imag(a), tol);
   a = pow(c, 3);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(3, c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
   a = pow(c + 0, b);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3053.8558566606567369633610140423321260211388217942246293871310470377722279440084474789529228008638668934381183"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("3097.9975862915005132449772136982559285192410496951232473245540634244845290672745578327467396750607773968246915"), imag(a), tol);
   a = pow(c + 0, 3);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(3, c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);

   r = 3;
   // Powers where one arg is a real_type.
   a = pow(c, r);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(r, c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
   a = pow(c + 0, r);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(r, c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
   a = pow(c, r + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(r + 0, c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);

   // Powers where one arg is an float.
   a = pow(c, 3.0);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(3.0, c);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);
   a = pow(c + 0, 3.0);
   BOOST_CHECK_CLOSE_FRACTION(real_type(-46), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type(9), imag(a), tol);
   a = pow(3.0, c + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-8.8931513442797186948734782808862447235385767991868219480917324534839621090167050538805196124711247247992169338"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.3826999557878897572499699021550296885662132089951379549068064961882821777067532977546360861176011175070188118"), imag(a), tol * 3);

   a = c;
   a = sqrt(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.674149228035540040448039300849051821674708677883920366727287836003399240343274891876712629708287692163156802065"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.8959774761298381247157337552900434410433241995549314932449006989874470582160955817053273057885402621549320588976"), imag(a), tol);
   a = c;
   a = sin(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("9.154499146911429573467299544609832559158860568765182977899828142590020335321896403936690014669532606510294425039"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-4.168906959966564350754813058853754843573565604758055889965478710592666260138453299795649308385497563475115931624"), imag(a), tol);
   a = c;
   a = cos(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-4.1896256909688072301325550196159737286219454041279210357407905058369727912162626993926269783331491034500484583"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-9.1092278937553365979791972627788621213326202389201695649104967309554222940748568716960841549279996556547993373"), imag(a), tol);
   a = c;
   a = tan(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-0.0037640256415042482927512211303226908396306202016580864328644932511249097100916559688254811519914564480500042311"), real(a), tol * 5);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.0032386273536098014463585978219272598077897241071003399272426939850671219193120708438426543945017427085738411"), imag(a), tol);
   a = c;
   a = asin(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.5706527843210994007102838796856696501828032450960401365302732598209740064262509342420347149436326252483895113827"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
   a = c;
   a = acos(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
   a = c;
   a = atan(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.409921049596575522530619384460420782588207051908724814771070766475530084440199227135813201495737846771570458568"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.2290726829685387662958818029420027678625253049770656169479919704951963414344907622560676377741902308144912055002"), imag(a), tol);
   a = c;
   a = sqrt(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.674149228035540040448039300849051821674708677883920366727287836003399240343274891876712629708287692163156802065"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.8959774761298381247157337552900434410433241995549314932449006989874470582160955817053273057885402621549320588976"), imag(a), tol);
   a = c;
   a = sin(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("9.154499146911429573467299544609832559158860568765182977899828142590020335321896403936690014669532606510294425039"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-4.168906959966564350754813058853754843573565604758055889965478710592666260138453299795649308385497563475115931624"), imag(a), tol);
   a = c;
   a = cos(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-4.1896256909688072301325550196159737286219454041279210357407905058369727912162626993926269783331491034500484583"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-9.1092278937553365979791972627788621213326202389201695649104967309554222940748568716960841549279996556547993373"), imag(a), tol);
   a = c;
   a = tan(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-0.0037640256415042482927512211303226908396306202016580864328644932511249097100916559688254811519914564480500042311"), real(a), tol * 5);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.0032386273536098014463585978219272598077897241071003399272426939850671219193120708438426543945017427085738411"), imag(a), tol);
   a = c;
   a = asin(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.5706527843210994007102838796856696501828032450960401365302732598209740064262509342420347149436326252483895113827"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
   a = c;
   a = acos(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), imag(a), tol);
   a = c;
   a = atan(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.409921049596575522530619384460420782588207051908724814771070766475530084440199227135813201495737846771570458568"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.2290726829685387662958818029420027678625253049770656169479919704951963414344907622560676377741902308144912055002"), imag(a), tol);

   a = c;
   a = sinh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3.5905645899857799520125654477948167931949136757293015099986213974178826801534614215227593814301490087307920223"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.53092108624851980526704009066067655967277345095149103008706855371803528753067068552935673000832252607835087747"), imag(a), tol);
   a = c;
   a = cosh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3.7245455049153225654739707032559725286749657732153307267858945686649501059065292889110148294141744084833329553"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.51182256998738460883446384980187563424555660949074386745538379123585339045741119409984041226187262097496424111"), imag(a), tol);
   a = c;
   a = tanh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.965385879022133124278480269394560685879729650005757773636908240066639772853967550095754361348005358178253777920"), real(a), tol * 5);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-0.00988437503832249372031403430350121097961813353467039031861010606115560355679254344335582852193041894874685555114"), imag(a), tol);
   a = c;
   a = asinh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.968637925793096291788665095245498189520731012682010573842811017352748255492485345887875752070076230641308014923"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.9646585044076027920454110594995323555197773725073316527132580297155508786089335572049608301897631767195194427315"), imag(a), tol);
   a = c;
   a = acosh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), imag(a), tol);
   a = c;
   a = atanh(a);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.1469466662255297520474327851547159424423449403442452953891851939502023996823900422792744078835711416939934387775"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.338972522294493561124193575909144241084316172544492778582005751793809271060233646663717270678614587712809117131"), imag(a), tol);
   a = c;
   a = sinh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3.5905645899857799520125654477948167931949136757293015099986213974178826801534614215227593814301490087307920223"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.53092108624851980526704009066067655967277345095149103008706855371803528753067068552935673000832252607835087747"), imag(a), tol);
   a = c;
   a = cosh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-3.7245455049153225654739707032559725286749657732153307267858945686649501059065292889110148294141744084833329553"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.51182256998738460883446384980187563424555660949074386745538379123585339045741119409984041226187262097496424111"), imag(a), tol);
   a = c;
   a = tanh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.965385879022133124278480269394560685879729650005757773636908240066639772853967550095754361348005358178253777920"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("-0.00988437503832249372031403430350121097961813353467039031861010606115560355679254344335582852193041894874685555114"), imag(a), tol);
   a = c;
   a = asinh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.968637925793096291788665095245498189520731012682010573842811017352748255492485345887875752070076230641308014923"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.9646585044076027920454110594995323555197773725073316527132580297155508786089335572049608301897631767195194427315"), imag(a), tol);
   a = c;
   a = acosh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.983387029916535432347076902894039565014248302909345356125267430944752731616095111727103650117987412058949254132"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.000143542473797218521037811954081791915781454591512773957199036332934196716853565071982697727425908742684531873"), imag(a), tol);
   a = c;
   a = atanh(a + 0);
   BOOST_CHECK_CLOSE_FRACTION(real_type("0.1469466662255297520474327851547159424423449403442452953891851939502023996823900422792744078835711416939934387775"), real(a), tol);
   BOOST_CHECK_CLOSE_FRACTION(real_type("1.338972522294493561124193575909144241084316172544492778582005751793809271060233646663717270678614587712809117131"), imag(a), tol);
}

template <class Real>
typename std::enable_if<boost::multiprecision::number_category<Real>::value != boost::multiprecision::number_kind_complex>::type test_members(Real)
{
   //
   // Test sign and zero functions:
   //
   Real a = 20;
   Real b = 30;
   BOOST_CHECK(a.sign() > 0);
   BOOST_CHECK(!a.is_zero());
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed)
   {
      a = -20;
      BOOST_CHECK(a.sign() < 0);
      BOOST_CHECK(!a.is_zero());
   }
   a = 0;
   BOOST_CHECK_EQUAL(a.sign(), 0);
   BOOST_CHECK(a.is_zero());

   a = 20;
   b = 30;
   a.swap(b);
   BOOST_CHECK_EQUAL(a, 30);
   BOOST_CHECK_EQUAL(b, 20);
   //
   // Test complex number functions which are also overloaded for scalar type:
   //
   BOOST_CHECK_EQUAL(real(a), a);
   BOOST_CHECK_EQUAL(imag(a), 0);
   BOOST_CHECK_EQUAL(real(a + 0), a);
   BOOST_CHECK_EQUAL(imag(a + 2), 0);
   BOOST_CHECK_EQUAL(norm(a), a * a);
   BOOST_CHECK_EQUAL(norm(a * 1), a * a);
   BOOST_CHECK_EQUAL(conj(a), a);
   BOOST_CHECK_EQUAL(conj(a * 1), a);
   BOOST_CHECK_EQUAL(proj(a), a);
   BOOST_CHECK_EQUAL(proj(a * 1), a);
   BOOST_CHECK_EQUAL(a.real(), a);
   BOOST_CHECK_EQUAL(a.imag(), 0);
   a.real(55);
   BOOST_CHECK_EQUAL(a, 55);
}

template <class Real>
void test_members(boost::rational<Real>)
{
}

template <class Real>
void test_signed_ops(const std::integral_constant<bool, true>&)
{
   Real a(8);
   Real b(64);
   Real c(500);
   Real d(1024);
   Real ac;
   BOOST_CHECK_EQUAL(-a, -8);
   ac = a;
   ac = ac - b;
   BOOST_CHECK_EQUAL(ac, 8 - 64);
   ac = a;
   ac -= a + b;
   BOOST_CHECK_EQUAL(ac, -64);
   ac = a;
   ac -= b - a;
   BOOST_CHECK_EQUAL(ac, 16 - 64);
   ac = -a;
   BOOST_CHECK_EQUAL(ac, -8);
   ac = a;
   ac -= -a;
   BOOST_CHECK_EQUAL(ac, 16);
   ac = a;
   ac += -a;
   BOOST_CHECK_EQUAL(ac, 0);
   ac = b;
   ac /= -a;
   BOOST_CHECK_EQUAL(ac, -8);
   ac = a;
   ac *= -a;
   BOOST_CHECK_EQUAL(ac, -64);
   ac = a + -b;
   BOOST_CHECK_EQUAL(ac, 8 - 64);
   ac = -a + b;
   BOOST_CHECK_EQUAL(ac, -8 + 64);
   ac = -a + -b;
   BOOST_CHECK_EQUAL(ac, -72);
   ac = a + -+-b; // lots of unary operators!!
   BOOST_CHECK_EQUAL(ac, 72);
   test_conditional(Real(-a), -a);

   //
   // RValue ref tests:
   //
   a = 3;
   b = 4;
   c = Real(20) + -(a + b);
   BOOST_CHECK_EQUAL(c, 13);
   c = Real(20) + -a;
   BOOST_CHECK_EQUAL(c, 17);
   c = -a + Real(20);
   BOOST_CHECK_EQUAL(c, 17);
   c = -a + b;
   BOOST_CHECK_EQUAL(c, 1);
   c = b + -a;
   BOOST_CHECK_EQUAL(c, 1);
   a = 2;
   b = 3;
   c = Real(10) - a;
   BOOST_CHECK_EQUAL(c, 8);
   c = a - Real(2);
   BOOST_CHECK_EQUAL(c, 0);
   c = Real(3) - Real(2);
   BOOST_CHECK_EQUAL(c, 1);
   a = 20;
   c = a - (a + b);
   BOOST_CHECK_EQUAL(c, -3);
   a = 2;
   c = (a * b) - (a + b);
   BOOST_CHECK_EQUAL(c, 1);
   c = Real(20) - -(a + b);
   BOOST_CHECK_EQUAL(c, 25);
   c = Real(20) - (-a);
   BOOST_CHECK_EQUAL(c, 22);
   c = (-b) - Real(-5);
   BOOST_CHECK_EQUAL(c, 2);
   c = (-b) - a;
   BOOST_CHECK_EQUAL(c, -5);
   c = b - (-a);
   BOOST_CHECK_EQUAL(c, 5);
   c = Real(3) * -(a + b);
   BOOST_CHECK_EQUAL(c, -15);
   c = -(a + b) * Real(3);
   BOOST_CHECK_EQUAL(c, -15);
   c = Real(2) * -a;
   BOOST_CHECK_EQUAL(c, -4);
   c = -a * Real(2);
   BOOST_CHECK_EQUAL(c, -4);
   c = -a * b;
   BOOST_CHECK_EQUAL(c, -6);
   a = 2;
   b = 4;
   c = Real(4) / -a;
   BOOST_CHECK_EQUAL(c, -2);
   c = -b / Real(2);
   BOOST_CHECK_EQUAL(c, -2);
   c = Real(4) / -(2 * a);
   BOOST_CHECK_EQUAL(c, -1);
   c = b / -(2 * a);
   BOOST_CHECK_EQUAL(c, -1);
   c = -(2 * a) / Real(2);
   BOOST_CHECK_EQUAL(c, -2);
}
template <class Real>
void test_signed_ops(const std::integral_constant<bool, false>&)
{
}

template <class Real>
void test_basic_conditionals(Real a, Real b)
{
   if (a)
   {
      BOOST_ERROR("Unexpected non-zero result");
   }
   if (!a)
   {
   }
   else
   {
      BOOST_ERROR("Unexpected zero result");
   }
   b = 2;
   if (!b)
   {
      BOOST_ERROR("Unexpected zero result");
   }
   if (b)
   {
   }
   else
   {
      BOOST_ERROR("Unexpected non-zero result");
   }
   if (a && b)
   {
      BOOST_ERROR("Unexpected zero result");
   }
   if (!(a || b))
   {
      BOOST_ERROR("Unexpected zero result");
   }
   if (a + b)
   {
   }
   else
   {
      BOOST_ERROR("Unexpected zero result");
   }
   if (b - 2)
   {
      BOOST_ERROR("Unexpected non-zero result");
   }
}

template <class T>
typename std::enable_if<boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_complex>::type
test_relationals(T a, T b)
{
   BOOST_CHECK_EQUAL((a == b), false);
   BOOST_CHECK_EQUAL((a != b), true);

   BOOST_CHECK_EQUAL((a + b == b), false);
   BOOST_CHECK_EQUAL((a + b != b), true);

   BOOST_CHECK_EQUAL((a == b + a), false);
   BOOST_CHECK_EQUAL((a != b + a), true);

   BOOST_CHECK_EQUAL((a + b == b + a), true);
   BOOST_CHECK_EQUAL((a + b != b + a), false);

   BOOST_CHECK_EQUAL((8 == b + a), false);
   BOOST_CHECK_EQUAL((8 != b + a), true);
   BOOST_CHECK_EQUAL((800 == b + a), false);
   BOOST_CHECK_EQUAL((800 != b + a), true);
   BOOST_CHECK_EQUAL((72 == b + a), true);
   BOOST_CHECK_EQUAL((72 != b + a), false);

   BOOST_CHECK_EQUAL((b + a == 8), false);
   BOOST_CHECK_EQUAL((b + a != 8), true);
   BOOST_CHECK_EQUAL((b + a == 800), false);
   BOOST_CHECK_EQUAL((b + a != 800), true);
   BOOST_CHECK_EQUAL((b + a == 72), true);
   BOOST_CHECK_EQUAL((b + a != 72), false);
}

template <class T>
typename std::enable_if<boost::multiprecision::number_category<T>::value != boost::multiprecision::number_kind_complex>::type
test_relationals(T a, T b)
{
   BOOST_CHECK_EQUAL((a == b), false);
   BOOST_CHECK_EQUAL((a != b), true);
   BOOST_CHECK_EQUAL((a <= b), true);
   BOOST_CHECK_EQUAL((a < b), true);
   BOOST_CHECK_EQUAL((a >= b), false);
   BOOST_CHECK_EQUAL((a > b), false);

   BOOST_CHECK_EQUAL((a + b == b), false);
   BOOST_CHECK_EQUAL((a + b != b), true);
   BOOST_CHECK_EQUAL((a + b >= b), true);
   BOOST_CHECK_EQUAL((a + b > b), true);
   BOOST_CHECK_EQUAL((a + b <= b), false);
   BOOST_CHECK_EQUAL((a + b < b), false);

   BOOST_CHECK_EQUAL((a == b + a), false);
   BOOST_CHECK_EQUAL((a != b + a), true);
   BOOST_CHECK_EQUAL((a <= b + a), true);
   BOOST_CHECK_EQUAL((a < b + a), true);
   BOOST_CHECK_EQUAL((a >= b + a), false);
   BOOST_CHECK_EQUAL((a > b + a), false);

   BOOST_CHECK_EQUAL((a + b == b + a), true);
   BOOST_CHECK_EQUAL((a + b != b + a), false);
   BOOST_CHECK_EQUAL((a + b <= b + a), true);
   BOOST_CHECK_EQUAL((a + b < b + a), false);
   BOOST_CHECK_EQUAL((a + b >= b + a), true);
   BOOST_CHECK_EQUAL((a + b > b + a), false);

   BOOST_CHECK_EQUAL((8 == b + a), false);
   BOOST_CHECK_EQUAL((8 != b + a), true);
   BOOST_CHECK_EQUAL((8 <= b + a), true);
   BOOST_CHECK_EQUAL((8 < b + a), true);
   BOOST_CHECK_EQUAL((8 >= b + a), false);
   BOOST_CHECK_EQUAL((8 > b + a), false);
   BOOST_CHECK_EQUAL((800 == b + a), false);
   BOOST_CHECK_EQUAL((800 != b + a), true);
   BOOST_CHECK_EQUAL((800 >= b + a), true);
   BOOST_CHECK_EQUAL((800 > b + a), true);
   BOOST_CHECK_EQUAL((800 <= b + a), false);
   BOOST_CHECK_EQUAL((800 < b + a), false);
   BOOST_CHECK_EQUAL((72 == b + a), true);
   BOOST_CHECK_EQUAL((72 != b + a), false);
   BOOST_CHECK_EQUAL((72 <= b + a), true);
   BOOST_CHECK_EQUAL((72 < b + a), false);
   BOOST_CHECK_EQUAL((72 >= b + a), true);
   BOOST_CHECK_EQUAL((72 > b + a), false);

   BOOST_CHECK_EQUAL((b + a == 8), false);
   BOOST_CHECK_EQUAL((b + a != 8), true);
   BOOST_CHECK_EQUAL((b + a >= 8), true);
   BOOST_CHECK_EQUAL((b + a > 8), true);
   BOOST_CHECK_EQUAL((b + a <= 8), false);
   BOOST_CHECK_EQUAL((b + a < 8), false);
   BOOST_CHECK_EQUAL((b + a == 800), false);
   BOOST_CHECK_EQUAL((b + a != 800), true);
   BOOST_CHECK_EQUAL((b + a <= 800), true);
   BOOST_CHECK_EQUAL((b + a < 800), true);
   BOOST_CHECK_EQUAL((b + a >= 800), false);
   BOOST_CHECK_EQUAL((b + a > 800), false);
   BOOST_CHECK_EQUAL((b + a == 72), true);
   BOOST_CHECK_EQUAL((b + a != 72), false);
   BOOST_CHECK_EQUAL((b + a >= 72), true);
   BOOST_CHECK_EQUAL((b + a > 72), false);
   BOOST_CHECK_EQUAL((b + a <= 72), true);
   BOOST_CHECK_EQUAL((b + a < 72), false);

   T c;
   //
   // min and max overloads:
   //
#if !defined(min) && !defined(max)
   //   using std::max;
   //   using std::min;
   // This works, but still causes complaints from inspect.exe, so use brackets to prevent macrosubstitution,
   // and to explicitly specify type T seems necessary, for reasons unclear.
   a = 2;
   b = 5;
   c = 6;
   BOOST_CHECK_EQUAL((std::min<T>)(a, b), a);
   BOOST_CHECK_EQUAL((std::min<T>)(b, a), a);
   BOOST_CHECK_EQUAL((std::max<T>)(a, b), b);
   BOOST_CHECK_EQUAL((std::max<T>)(b, a), b);
   BOOST_CHECK_EQUAL((std::min<T>)(a, b + c), a);
   BOOST_CHECK_EQUAL((std::min<T>)(b + c, a), a);
   BOOST_CHECK_EQUAL((std::min<T>)(a, c - b), 1);
   BOOST_CHECK_EQUAL((std::min<T>)(c - b, a), 1);
   BOOST_CHECK_EQUAL((std::max<T>)(a, b + c), 11);
   BOOST_CHECK_EQUAL((std::max<T>)(b + c, a), 11);
   BOOST_CHECK_EQUAL((std::max<T>)(a, c - b), a);
   BOOST_CHECK_EQUAL((std::max<T>)(c - b, a), a);
   BOOST_CHECK_EQUAL((std::min<T>)(a + b, b + c), 7);
   BOOST_CHECK_EQUAL((std::min<T>)(b + c, a + b), 7);
   BOOST_CHECK_EQUAL((std::max<T>)(a + b, b + c), 11);
   BOOST_CHECK_EQUAL((std::max<T>)(b + c, a + b), 11);
   BOOST_CHECK_EQUAL((std::min<T>)(a + b, c - a), 4);
   BOOST_CHECK_EQUAL((std::min<T>)(c - a, a + b), 4);
   BOOST_CHECK_EQUAL((std::max<T>)(a + b, c - a), 7);
   BOOST_CHECK_EQUAL((std::max<T>)(c - a, a + b), 7);

   long l1(2), l2(3), l3;
   l3 = (std::min)(l1, l2) + (std::max)(l1, l2) + (std::max<long>)(l1, l2) + (std::min<long>)(l1, l2);
   BOOST_CHECK_EQUAL(l3, 10);

#endif
}

template <class T>
const T& self(const T& a) { return a; }

template <class Real>
void test()
{
#if !defined(NO_MIXED_OPS) && !defined(SLOW_COMPILER)
   boost::multiprecision::is_number<Real> tag;
   test_mixed<Real, unsigned char>(tag);
   test_mixed<Real, signed char>(tag);
   test_mixed<Real, char>(tag);
   test_mixed<Real, short>(tag);
   test_mixed<Real, unsigned short>(tag);
   test_mixed<Real, int>(tag);
   test_mixed<Real, unsigned int>(tag);
   test_mixed<Real, long>(tag);
   test_mixed<Real, unsigned long>(tag);
#ifdef BOOST_HAS_LONG_LONG
   test_mixed<Real, long long>(tag);
   test_mixed<Real, unsigned long long>(tag);
#endif
#if defined(BOOST_HAS_INT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<Real, boost::int128_type>::value)
   {
      test_mixed<Real, boost::int128_type>(tag);
      test_mixed<Real, boost::uint128_type>(tag);
   }
#endif
   test_mixed<Real, float>(tag);
   test_mixed<Real, double>(tag);
   test_mixed<Real, long double>(tag);
#if defined(BOOST_HAS_FLOAT128) && !defined(BOOST_NO_CXX17_IF_CONSTEXPR)
   if constexpr (std::is_constructible<Real, __float128>::value)
      test_mixed<Real, __float128>(tag);
#endif

   typedef typename related_type<Real>::type                                                                      related_type;
   std::integral_constant<bool, boost::multiprecision::is_number<Real>::value && !std::is_same<related_type, Real>::value> tag2;

   test_mixed<Real, related_type>(tag2);

   std::integral_constant<bool, boost::multiprecision::is_number<Real>::value && (boost::multiprecision::number_category<Real>::value == boost::multiprecision::number_kind_complex)> complex_tag;
   test_mixed<Real, std::complex<float> >(complex_tag);
   test_mixed<Real, std::complex<double> >(complex_tag);
   test_mixed<Real, std::complex<long double> >(complex_tag);

   test_enum_conversions<Real>();

#endif
#ifndef MIXED_OPS_ONLY
   //
   // Integer only functions:
   //
   test_integer_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
   //
   // Real number only functions:
   //
   test_float_ops<Real>(typename boost::multiprecision::number_category<Real>::type());
   //
   // Test basic arithmetic:
   //
   Real a(8);
   Real b(64);
   Real c(500);
   Real d(1024);
   BOOST_CHECK_EQUAL(a + b, 72);
   a += b;
   BOOST_CHECK_EQUAL(a, 72);
   BOOST_CHECK_EQUAL(a - b, 8);
   a -= b;
   BOOST_CHECK_EQUAL(a, 8);
   BOOST_CHECK_EQUAL(a * b, 8 * 64L);
   a *= b;
   BOOST_CHECK_EQUAL(a, 8 * 64L);
   BOOST_CHECK_EQUAL(a / b, 8);
   a /= b;
   BOOST_CHECK_EQUAL(a, 8);
   Real ac(a);
   BOOST_CHECK_EQUAL(ac, a);
   ac = a * c;
   BOOST_CHECK_EQUAL(ac, 8 * 500L);
   ac = 8 * 500L;
   ac = ac + b + c;
   BOOST_CHECK_EQUAL(ac, 8 * 500L + 64 + 500);
   ac = a;
   ac = b + c + ac;
   BOOST_CHECK_EQUAL(ac, 8 + 64 + 500);
   ac = ac - b + c;
   BOOST_CHECK_EQUAL(ac, 8 + 64 + 500 - 64 + 500);
   ac = a;
   ac = b + c - ac;
   BOOST_CHECK_EQUAL(ac, -8 + 64 + 500);
   ac = a;
   ac = ac * b;
   BOOST_CHECK_EQUAL(ac, 8 * 64);
   ac = a;
   ac *= b * ac;
   BOOST_CHECK_EQUAL(ac, 8 * 8 * 64);
   ac = b;
   ac = ac / a;
   BOOST_CHECK_EQUAL(ac, 64 / 8);
   ac = b;
   ac /= ac / a;
   BOOST_CHECK_EQUAL(ac, 64 / (64 / 8));
   ac = a;
   ac = b + ac * a;
   BOOST_CHECK_EQUAL(ac, 64 * 2);
   ac = a;
   ac = b - ac * a;
   BOOST_CHECK_EQUAL(ac, 0);
   ac = a;
   ac = b * (ac + a);
   BOOST_CHECK_EQUAL(ac, 64 * (16));
   ac = a;
   ac = b / (ac * 1);
   BOOST_CHECK_EQUAL(ac, 64 / 8);
   ac = a;
   ac = ac + b;
   BOOST_CHECK_EQUAL(ac, 8 + 64);
   ac = a;
   ac = a + ac;
   BOOST_CHECK_EQUAL(ac, 16);
   ac = a;
   ac = a - ac;
   BOOST_CHECK_EQUAL(ac, 0);
   ac = a;
   ac += a + b;
   BOOST_CHECK_EQUAL(ac, 80);
   ac = a;
   ac += b + a;
   BOOST_CHECK_EQUAL(ac, 80);
   ac = +a;
   BOOST_CHECK_EQUAL(ac, 8);
   ac = 8;
   ac = a * ac;
   BOOST_CHECK_EQUAL(ac, 8 * 8);
   ac = a;
   ac = a;
   ac += +a;
   BOOST_CHECK_EQUAL(ac, 16);
   ac = a;
   ac += b - a;
   BOOST_CHECK_EQUAL(ac, 8 + 64 - 8);
   ac = a;
   ac += b * c;
   BOOST_CHECK_EQUAL(ac, 8 + 64 * 500);
   ac = a;
   ac = a;
   ac -= +a;
   BOOST_CHECK_EQUAL(ac, 0);
   ac = a;
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed || is_twos_complement_integer<Real>::value)
   {
      ac = a;
      ac -= c - b;
      BOOST_CHECK_EQUAL(ac, 8 - (500 - 64));
      ac = a;
      ac -= b * c;
      BOOST_CHECK_EQUAL(ac, 8 - 500 * 64);
   }
   ac = a;
   ac += ac * b;
   BOOST_CHECK_EQUAL(ac, 8 + 8 * 64);
   BOOST_IF_CONSTEXPR (std::numeric_limits<Real>::is_signed || is_twos_complement_integer<Real>::value)
   {
      ac = a;
      ac -= ac * b;
      BOOST_CHECK_EQUAL(ac, 8 - 8 * 64);
   }
   ac = a * 8;
   ac *= +a;
   BOOST_CHECK_EQUAL(ac, 64 * 8);
   ac = a;
   ac *= b * c;
   BOOST_CHECK_EQUAL(ac, 8 * 64 * 500);
   ac = a;
   ac *= b / a;
   BOOST_CHECK_EQUAL(ac, 8 * 64 / 8);
   ac = a;
   ac *= b + c;
   BOOST_CHECK_EQUAL(ac, 8 * (64 + 500));
   ac = b;
   ac /= +a;
   BOOST_CHECK_EQUAL(ac, 8);
   ac = b;
   ac /= b / a;
   BOOST_CHECK_EQUAL(ac, 64 / (64 / 8));
   ac = b;
   ac /= a + Real(0);
   BOOST_CHECK_EQUAL(ac, 8);
   //
   // simple tests with immediate values, these calls can be optimised in many backends:
   //
   ac = a + b;
   BOOST_CHECK_EQUAL(ac, 72);
   ac = a + +b;
   BOOST_CHECK_EQUAL(ac, 72);
   ac = +a + b;
   BOOST_CHECK_EQUAL(ac, 72);
   ac = +a + +b;
   BOOST_CHECK_EQUAL(ac, 72);
   ac = a;
   ac = b / ac;
   BOOST_CHECK_EQUAL(ac, b / a);
   //
   // Comparisons:
   //
   test_relationals(a, b);
   test_members(a);
   //
   // Use in Boolean context:
   //
   a = 0;
   b = 2;
   test_basic_conditionals(a, b);
   //
   // Test iostreams:
   //
   std::stringstream ss;
   a = 20;
   b = 2;
   ss << a;
   ss >> c;
   BOOST_CHECK_EQUAL(a, c);
   ss.clear();
   ss << a + b;
   ss >> c;
   BOOST_CHECK_EQUAL(c, 22);
   BOOST_CHECK_EQUAL(c, a + b);
   //
   // More cases for complete code coverage:
   //
   a = 20;
   b = 30;
   swap(a, b);
   BOOST_CHECK_EQUAL(a, 30);
   BOOST_CHECK_EQUAL(b, 20);
   a = 20;
   b = 30;
   std::swap(a, b);
   BOOST_CHECK_EQUAL(a, 30);
   BOOST_CHECK_EQUAL(b, 20);
   a = 20;
   b = 30;
   a = a + b * 2;
   BOOST_CHECK_EQUAL(a, 20 + 30 * 2);
   a = 100;
   a = a - b * 2;
   BOOST_CHECK_EQUAL(a, 100 - 30 * 2);
   a = 20;
   a = a * (b + 2);
   BOOST_CHECK_EQUAL(a, 20 * (32));
   a = 20;
   a = (b + 2) * a;
   BOOST_CHECK_EQUAL(a, 20 * (32));
   a = 90;
   b = 2;
   a = a / (b + 0);
   BOOST_CHECK_EQUAL(a, 45);
   a = 20;
   b = 30;
   c = (a * b) + 22;
   BOOST_CHECK_EQUAL(c, 20 * 30 + 22);
   c = 22 + (a * b);
   BOOST_CHECK_EQUAL(c, 20 * 30 + 22);
   c  = 10;
   ac = a + b * c;
   BOOST_CHECK_EQUAL(ac, 20 + 30 * 10);
   ac = b * c + a;
   BOOST_CHECK_EQUAL(ac, 20 + 30 * 10);
   a = a + b * c;
   BOOST_CHECK_EQUAL(a, 20 + 30 * 10);
   a = 20;
   b = a + b * c;
   BOOST_CHECK_EQUAL(b, 20 + 30 * 10);
   b = 30;
   c = a + b * c;
   BOOST_CHECK_EQUAL(c, 20 + 30 * 10);
   c = 10;
   c = a + b / c;
   BOOST_CHECK_EQUAL(c, 20 + 30 / 10);
   //
   // Additional tests for rvalue ref overloads:
   //
   a = 3;
   b = 4;
   c = Real(2) + a;
   BOOST_CHECK_EQUAL(c, 5);
   c = a + Real(2);
   BOOST_CHECK_EQUAL(c, 5);
   c = Real(3) + Real(2);
   BOOST_CHECK_EQUAL(c, 5);
   c = Real(2) + (a + b);
   BOOST_CHECK_EQUAL(c, 9);
   c = (a + b) + Real(2);
   BOOST_CHECK_EQUAL(c, 9);
   c = (a + b) + (a + b);
   BOOST_CHECK_EQUAL(c, 14);
   c = a * Real(4);
   BOOST_CHECK_EQUAL(c, 12);
   c = Real(3) * Real(4);
   BOOST_CHECK_EQUAL(c, 12);
   c = (a + b) * (a + b);
   BOOST_CHECK_EQUAL(c, 49);
   a = 2;
   c = b / Real(2);
   BOOST_CHECK_EQUAL(c, 2);
   c = Real(4) / a;
   BOOST_CHECK_EQUAL(c, 2);
   c = Real(4) / Real(2);
   BOOST_CHECK_EQUAL(c, 2);
   //
   // Test conditionals:
   //
   a = 20;
   test_conditional(a, +a);
   test_conditional(a, (a + 0));

   test_signed_ops<Real>(std::integral_constant<bool, std::numeric_limits<Real>::is_signed>());
   //
   // Test hashing:
   //
   std::hash<Real> hasher;
   std::size_t       s = hasher(a);
   BOOST_CHECK_NE(s, 0);
   std::hash<Real> hasher2;
   s = hasher2(a);
   BOOST_CHECK_NE(s, 0);

   //
   // Test move:
   //
   Real m(static_cast<Real&&>(a));
   BOOST_CHECK_EQUAL(m, 20);
   // Move from already moved from object:
   Real m2(static_cast<Real&&>(a));
   // assign from moved from object
   // (may result in "a" being left in valid state as implementation artifact):
   c = static_cast<Real&&>(a);
   // assignment to moved-from objects:
   c = static_cast<Real&&>(m);
   BOOST_CHECK_EQUAL(c, 20);
   m2 = c;
   BOOST_CHECK_EQUAL(c, 20);
   // Destructor of "a" checks destruction of moved-from-object...
   Real m3(static_cast<Real&&>(a));
#ifndef BOOST_MP_NOT_TESTING_NUMBER
   //
   // string and string_view:
   //
   {
      std::string s1("2");
      Real        x(s1);
      BOOST_CHECK_EQUAL(x, 2);
      s1 = "3";
      x.assign(s1);
      BOOST_CHECK_EQUAL(x, 3);
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
      s1 = "20";
      std::string_view v(s1.c_str(), 1);
      Real             y(v);
      BOOST_CHECK_EQUAL(y, 2);
      std::string_view v2(s1.c_str(), 2);
      y.assign(v2);
      BOOST_CHECK_EQUAL(y, 20);
#endif
   }
#endif
   //
   // Bug cases, self assignment first:
   //
   a = 20;
   a = self(a);
   BOOST_CHECK_EQUAL(a, 20);

   a = 2;
   a = a * a * a;
   BOOST_CHECK_EQUAL(a, 8);
   a = 2;
   a = a + a + a;
   BOOST_CHECK_EQUAL(a, 6);
   a = 2;
   a = a - a + a;
   BOOST_CHECK_EQUAL(a, 2);
   a = 2;
   a = a + a - a;
   BOOST_CHECK_EQUAL(a, 2);
   a = 2;
   a = a * a - a;
   BOOST_CHECK_EQUAL(a, 2);
   a = 2;
   a = a + a * a;
   BOOST_CHECK_EQUAL(a, 6);
   a = 2;
   a = (a + a) * a;
   BOOST_CHECK_EQUAL(a, 8);
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_ab_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "../performance/arithmetic_backend.hpp"

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<double> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_ab_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "../performance/arithmetic_backend.hpp"

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<int> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_ab_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "../performance/arithmetic_backend.hpp"

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::arithmetic_backend<unsigned int> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_backend_concept.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>

#include "test_arithmetic.hpp"

int main()
{
   //
   // Orininal Mingw32 has issues with long double that break this, mingw64 is fine (and supported):
   //
#if !(defined(CI_SUPPRESS_KNOWN_ISSUES) && defined(__MINGW32__) && !defined(_WIN64) && BOOST_WORKAROUND(BOOST_GCC, <= 50300))
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_complex128.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/config.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/complex128.hpp>
#endif

#include "libs/multiprecision/test/test_arithmetic.hpp"

int main()
{
#ifdef BOOST_HAS_FLOAT128
   test<boost::multiprecision::complex128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_complex_adaptor.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define NO_MIXED_OPS

#include <boost/multiprecision/cpp_complex.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::cpp_complex_50>();
   test<boost::multiprecision::number<boost::multiprecision::complex_adaptor<boost::multiprecision::cpp_bin_float<50> >, boost::multiprecision::et_on> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_complex_adaptor_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define MIXED_OPS_ONLY

#include <boost/multiprecision/cpp_complex.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::cpp_complex_50>();
   test<boost::multiprecision::number<boost::multiprecision::complex_adaptor<boost::multiprecision::cpp_bin_float<50> >, boost::multiprecision::et_on> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>                                                                                                            number_type;
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<((std::numeric_limits<number_type>::digits / 2) > std::numeric_limits<long double>::digits ? Digits / 2 : Digits), DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> type;
};

int main()
{
   test<boost::multiprecision::cpp_bin_float_50>();
   //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<21> > >();
   //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<char> > > >();
   //test<boost::multiprecision::cpp_bin_float_quad>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define NO_MIXED_OPS

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>                                                                                                            number_type;
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<((std::numeric_limits<number_type>::digits / 2) > std::numeric_limits<long double>::digits ? Digits / 2 : Digits), DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> type;
};

int main()
{
   //test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
   //test<boost::multiprecision::cpp_bin_float_quad>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_2m.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define MIXED_OPS_ONLY

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

#ifndef _WIN64 // object file too large
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>                                                                                                            number_type;
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<((std::numeric_limits<number_type>::digits / 2) > std::numeric_limits<long double>::digits ? Digits / 2 : Digits), DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> type;
};
#endif

int main()
{
   //test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
   //test<boost::multiprecision::cpp_bin_float_quad>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinExponent, Exponent MaxExponent, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET>                                                                                                            number_type;
   typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<((std::numeric_limits<number_type>::digits / 2) > std::numeric_limits<long double>::digits ? Digits / 2 : Digits), DigitBase, Allocator, Exponent, MinExponent, MaxExponent>, ET> type;
};

int main()
{
   //test<boost::multiprecision::cpp_bin_float_50>();
   //test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<1000, boost::multiprecision::digit_base_10, std::allocator<char> > > >();
   test<boost::multiprecision::cpp_bin_float_quad>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#if defined(__GNUC__) && defined(_WIN32)
//
// Without this, our object files get to big!
//
#define SLOW_COMPILER
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

using namespace boost::multiprecision;

typedef number<cpp_bin_float<500>, et_on> cpp_bin_float_500_et_s;

template <>
struct related_type<cpp_bin_float_500_et_s>
{
   typedef number<cpp_bin_float<500, digit_base_10, std::allocator<char> >, et_on> type;
};

int main()
{
   test<cpp_bin_float_500_et_s>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_bin_float_5.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "libs/multiprecision/test/test_arithmetic.hpp"

using namespace boost::multiprecision;

typedef number<cpp_bin_float<500>, et_off> cpp_bin_float_500_et_s;

template <>
struct related_type<cpp_bin_float_500_et_s>
{
   typedef number<cpp_bin_float<500, digit_base_10, std::allocator<char> >, et_off> type;
};

int main()
{
   test<cpp_bin_float_500_et_s>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_complex_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_complex.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::cpp_complex_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_complex_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_complex.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::cpp_complex_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_dec_float_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::cpp_dec_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_dec_float_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100, long long>, boost::multiprecision::et_off> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_dec_float_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define NO_MIXED_OPS

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100, long long, std::allocator<char> >, boost::multiprecision::et_on> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_dec_float_3m.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define MIXED_OPS_ONLY

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100, long long, std::allocator<char> >, boost::multiprecision::et_on> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::cpp_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_10.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::checked_cpp_rational>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_11.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<0, 0, boost::multiprecision::signed_magnitude, boost::multiprecision::checked>, boost::multiprecision::et_off> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_12.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<500, 500, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_13.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_14.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_15.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<31, 31, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_16.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_17.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

template <>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > > : public std::integral_constant<bool, true>
{};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_18.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<31, 31, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_19.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::int128_t::backend_type> > >
{
   typedef boost::multiprecision::int128_t type;
};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::int128_t::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::int512_t>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_20.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<4096> > type;
};

int main()
{
   test<boost::multiprecision::cpp_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_21.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::uint128_t::backend_type> > >
{
   typedef boost::multiprecision::uint128_t type;
};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::uint128_t::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_22.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint256_t::backend_type> > >
{
   typedef boost::multiprecision::checked_uint256_t type;
};

template <>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint256_t::backend_type> > > : public std::false_type
{};

template <>
struct is_checked_cpp_int<boost::multiprecision::checked_uint256_t> : public std::integral_constant<bool, true>
{};
template <>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint256_t::backend_type> > > : public std::integral_constant<bool, true>
{};



int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint256_t::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_23.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_int256_t::backend_type> > >
{
   typedef boost::multiprecision::checked_int256_t type;
};

template <>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_int256_t::backend_type> > > : public std::false_type
{};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_int256_t::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_3.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::uint1024_t>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_4.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define TEST_CHECKED_INT

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

template <>
struct is_checked_cpp_int<boost::multiprecision::checked_cpp_int> : public std::integral_constant<bool, true>
{};

int main()
{
   test<boost::multiprecision::checked_cpp_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_5.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::checked_int512_t>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_6.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

template <>
struct is_checked_cpp_int<boost::multiprecision::checked_uint1024_t> : public std::integral_constant<bool, true>
{};

int main()
{
   test<boost::multiprecision::checked_uint1024_t>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_7.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <>
struct related_type<boost::multiprecision::cpp_rational>
{
   typedef boost::multiprecision::cpp_int type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::cpp_rational>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_8.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>, boost::multiprecision::et_off> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_9.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<500, 500, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_br.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#define BOOST_MP_NOT_TESTING_NUMBER

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::cpp_int>
{
   typedef boost::multiprecision::int256_t type;
};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ET>
struct related_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ET> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits / 2, MaxBits / 2, SignType, Checked, Allocator>, ET> type;
};

int main()
{
   test<boost::rational<boost::multiprecision::cpp_int> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::cpp_int::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_int_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct is_twos_complement_integer<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ExpressionTemplates> > : public std::integral_constant<bool, false>
{};

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::cpp_int::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_rat_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::cpp_rational::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_cpp_rat_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::cpp_rational::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_dbg_adptr1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define NO_MIXED_OPS

#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::cpp_dec_float<50> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_dbg_adptr1m.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define MIXED_OPS_ONLY

#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::cpp_dec_float<50> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_dbg_adptr2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::cpp_int_backend<> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_float_128.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/float128.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::float128>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_logged_1.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_dec_float<50> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_logged_2.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_int_backend<> > > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpc.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpc.hpp>
#define TEST_MPC

#include "libs/multiprecision/test/test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D> > type;
};

int main()
{
   test<boost::multiprecision::mpc_complex_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpc_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpc.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpc_complex_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpc_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpc.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpc_complex_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpf.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::gmp_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::gmp_float<D / 2> > type;
};
template <>
struct related_type<boost::multiprecision::mpf_float>
{
   typedef boost::multiprecision::mpz_int type;
};

int main()
{
   boost::multiprecision::mpf_float::default_precision(1000);
   BOOST_CHECK_EQUAL(boost::multiprecision::mpf_float::default_precision(), 1000);
   test<boost::multiprecision::mpf_float>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpf_50.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>

#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::gmp_float<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::gmp_float<D / 2> > type;
};
template <>
struct related_type<boost::multiprecision::mpf_float>
{
   typedef boost::multiprecision::mpz_int type;
};

int main()
{
   test<boost::multiprecision::mpf_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpf_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpf_float::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpf_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpf_float::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfi_50.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfi.hpp>
#define TEST_MPFR
#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::mpfi_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfi_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpfi.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpfi_float_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfi_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpfi.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpfi_float_50::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfr.hpp>
#define TEST_MPFR
#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::mpfr_float>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr_50.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfr.hpp>
#define TEST_MPFR
#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::mpfr_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr_50_mixed.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfr.hpp>
#define TEST_MPFR
#include "test_arithmetic.hpp"

template <>
struct related_type<boost::multiprecision::static_mpfr_float_50>
{
   typedef boost::multiprecision::mpfr_float_50 type;
};

int main()
{
   test<boost::multiprecision::static_mpfr_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr_50_static.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfr.hpp>
#define TEST_MPFR
#include "test_arithmetic.hpp"

template <unsigned D>
struct related_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D / 2> > type;
};

int main()
{
   test<boost::multiprecision::static_mpfr_float_50>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpfr_float::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpfr_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpfr_float::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpq.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>

#include "test_arithmetic.hpp"

template <>
struct related_type<boost::multiprecision::mpq_rational>
{
   typedef boost::multiprecision::mpz_int type;
};

int main()
{
   test<boost::multiprecision::mpq_rational>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpq_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpq_rational::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpq_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpq_rational::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpz.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::mpz_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpz_br.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>

#define NO_MIXED_OPS
#define BOOST_MP_NOT_TESTING_NUMBER

#include "test_arithmetic.hpp"
#include <boost/rational.hpp>

template <class T>
struct is_boost_rational<boost::rational<T> > : public std::integral_constant<bool, true>
{};

namespace boost { namespace multiprecision {

template <>
struct number_category<rational<mpz_int> > : public std::integral_constant<int, number_kind_rational>
{};

}} // namespace boost::multiprecision

int main()
{
   test<boost::rational<boost::multiprecision::mpz_int> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpz_dbg_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<typename boost::multiprecision::mpz_int::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpz_logged_adptr.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<typename boost::multiprecision::mpz_int::backend_type> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_mpz_rat.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>

#include "test_arithmetic.hpp"

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> > >
{
   typedef boost::multiprecision::mpz_int type;
};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_skeleton.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "skeleton_backend.hpp"
#include "test_arithmetic.hpp"

int main()
{
   test<boost::multiprecision::skeleton_number>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_tommath.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/tommath.hpp>

#include "test_arithmetic.hpp"

template <>
struct is_twos_complement_integer<boost::multiprecision::tom_int> : public std::integral_constant<bool, false>
{};

int main()
{
   test<boost::multiprecision::tom_int>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_tommath_br.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/tommath.hpp>

#define NO_MIXED_OPS
#define BOOST_MP_NOT_TESTING_NUMBER

#include "test_arithmetic.hpp"

#include <boost/rational.hpp>

template <class T>
struct is_boost_rational<boost::rational<T> > : public std::integral_constant<bool, true>
{};

namespace boost { namespace multiprecision {

template <>
struct number_category<rational<tom_int> > : public std::integral_constant<int, number_kind_rational>
{};

}} // namespace boost::multiprecision

int main()
{
   test<boost::rational<boost::multiprecision::tom_int> >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_arithmetic_tommath_rat.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/tommath.hpp>

#include "test_arithmetic.hpp"

template <>
struct is_twos_complement_integer<boost::multiprecision::tom_int> : public std::integral_constant<bool, false>
{};

template <>
struct related_type<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::tommath_int> > >
{
   typedef boost::multiprecision::number<boost::multiprecision::tommath_int> type;
};


int main()
{
   test<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::tommath_int> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_asin.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   //
   // Test with some exact binary values as input - this tests our code
   // rather than the test data:
   //
   static const boost::array<boost::array<T, 2>, 6> exact_data =
       {{
           {{0.5, static_cast<T>("0.523598775598298873077107230546583814032861566562517636829157432051302734381034833104672470890352844663691347752213717775")}},
           {{0.25, static_cast<T>("0.252680255142078653485657436993710972252193733096838193633923778740575060481021222411748742228014601605092602909414066566")}},
           {{0.75, static_cast<T>("0.848062078981481008052944338998418080073366213263112642860718163570200821228474234349189801731957230300995227265307531834")}},
           {{std::ldexp(1.0, -20), static_cast<T>("9.53674316406394560289664793089102218648031077292419572854816420395098616062014311172490017625353237219958438022056661501e-7")}},
           {{1 - std::ldexp(1.0, -20), static_cast<T>("1.56941525875313420204921285316218397515809899320201864334535204504240776023375739189119474528488143494473216475057072728")}},
           {{1, static_cast<T>("1.57079632679489661923132169163975144209858469968755291048747229615390820314310449931401741267105853399107404325664115332354692230477529111586267970406424055872514205135096926055277982231147447746519098221440548783296672306423782411689339158263560095457282428346173017430522716332410669680363012457064")}},
       }};
   unsigned max_err = 0;
   for (unsigned k = 0; k < exact_data.size(); k++)
   {
      T        val = asin(exact_data[k][0]);
      T        e   = relative_error(val, exact_data[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = asin(-exact_data[k][0]);
      e   = relative_error(val, T(-exact_data[k][1]));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);
   BOOST_TEST(asin(T(0)) == 0);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_assume_uniform_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else
      return (std::numeric_limits<Other>::max)();
}

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::assume_uniform_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   T a(big_a);
   BOOST_CHECK_EQUAL(a.precision(), 10);
   T b(std::move(big_d));
   BOOST_CHECK_EQUAL(a.precision(), 10);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = big_b;
      BOOST_CHECK_EQUAL(a.precision(), 10);
      b = std::move(big_c);
      BOOST_CHECK_EQUAL(a.precision(), 10);

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_EQUAL(cc.precision(), 10);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a);
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a, big_b);
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa.precision(10);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
      }
   }
}

template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::assume_uniform_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 100);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);

      T::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 35);
      T dd(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(dd.precision(), 20);
      aa = cp1;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa = std::move(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      aa = bb + cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa = cp3 * bb;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa += cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa -= cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa *= cp4;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa /= cp4;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa -= bb * cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa.precision(35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_atan.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T atan2_def(T y, T x)
{
   T t;
   t.backend() = boost::multiprecision::default_ops::get_constant_pi<typename T::backend_type>();
   T t2;
   if (x)
      t2 = atan(y / x);
   else
      t2 = y.sign() * t / 2;
   return t2 + (t / 2) * (1 - x.sign()) * T(y.sign() + 0.5).sign();
}

template <class T>
struct is_mpfr_type : public std::integral_constant<bool, false>
{};

#ifdef TEST_MPFR_50
template <unsigned Digits10>
struct is_mpfr_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10> > > : public std::integral_constant<bool, true>
{};
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 51u> data =
       {{
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-101",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668666666666666667e-97",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666667e-93",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666667e-89",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668666666666666666666666666666666666666666666666666666666666666667e-85",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666666666666666666666666666666666666666666666666666667e-81",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-77",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-73",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-69",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238e-65",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238e-61",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238e-57",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238095238095238095238095238e-53",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666668666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238095238095238095238095238095238096349206349206349e-49",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238095238095238095238095238206349206349206349206349206349206349206349206349e-45",
           "9.999999999999999999999999999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238095238095238095249206349206349206349206349206349206349206349206349206349206349206349206349206349e-41",
           "9.99999999999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666666666666666666666523809523809523809523809523809523809523809523809523809523809523809523809634920634920634920634920634920634920634920634920634920634920634920634920544011544011544011544011544011544011544e-37",
           "9.999999999999999999999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666666666666666666686666666666666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095238095238206349206349206349206349206349206349206349206349206349206349206340115440115440115440115440115440115440115440115440115440115440116209346209346209e-33",
           "9.999999999999999999999999999999999999999999999999999999966666666666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666666666665238095238095238095238095238095238095238095238095238095249206349206349206349206349206349206349206349206349206349115440115440115440115440115440115440115440115440115440116209346209346209346209346209346209346209346209346209346202679543e-29",
           "9.99999999999999999999999999999999999999999999999666666666666666666666666666666666666666666666666866666666666666666666666666666666666666666666666523809523809523809523809523809523809523809523809634920634920634920634920634920634920634920634920544011544011544011544011544011544011544011544011620934620934620934620934620934620934620934620934554267954267954267954267954267954267954267954268013091483679719e-25",
           "9.999999999999999999999999999999999999999666666666666666666666666666666666666666686666666666666666666666666666666666666665238095238095238095238095238095238095238206349206349206349206349206349206349206340115440115440115440115440115440115440116209346209346209346209346209346209346209279542679542679542679542679542679542679548561895620719150130914836797189738366208428128459088211410192834341441152586663e-21",
           "9.999999999999999999999999999999966666666666666666666666666666666866666666666666666666666666666665238095238095238095238095238095249206349206349206349206349206349115440115440115440115440115440116209346209346209346209346209346202679542679542679542679542679542738366208954444248561895620719149604599047323505527839893164970569113274066834438351466215243304983108499463325146458811824271509689681318218133e-17",
           "9.999999999999999999999996666666666666666666666668666666666666666666666665238095238095238095238096349206349206349206349205440115440115440115440116209346209346209346209345542679542679542679542680130914836797189738366208428128459088211410192834817631628777139613052925311641589740930163598087002528653948764327011735444703713649735994600714288656350334489593033695272837185114343249547095046272603174268e-13",
           "9.999999999999999666666666666666686666666666666665238095238095238206349206349206340115440115440116209346209346209279542679542679548561895620719149604599047323505575458940784018179051162265592202726621494746410579611835097095566286199717626418813764642659343446728207455753397291482030056516178836684094391777365260695851470017381944166954115569576329193296454393446430574957840819236721213626802085619e-9",
           "0.00009999999966666666866666665238095249206349115440116209346202679542738366208428128463850116128619335776637836253560167434464812879197215298894881707269927081030999737549925482008672363799937606915962379247584324159094536421375755997513179578610677454920512897850953612762990732913046921088456079984429888220262137400213929962691532176198436788640624698990926490105259050461938357510947570244880435664081",
           "0.78539816339744830961566084581987572104929234984377645524373614807695410157155224965700870633552926699553702162832057666177346115238764555793133985203212027936257102567548463027638991115573723873259549110720274391648336153211891205844669579131780047728641214173086508715261358166205334840181506228531843114675165157889704372038023024070731352292884109197314759000283263263720511663034603673798537790236",
           "1.5706963267952299525626550249873704896065212085331517483940102693584808194810202180293789115097723406333076648941055516492022741759833189628737308869915412879148320539754700057326930986734751013960313584219296445913757777000240665569182597868494941800236191544832206381775972559949762275927455637707925634113006817837919481411335451596526426779712759369563859151046126747697908496855825977735219514481",
           "1.5707963167948966192313220249730847754318980330208862438222342009158129649367552929648110725556184185509578339104318071142673796252326115673007840833450909541260947278453938016119958041324233151995987794877839930865561434524027270213271053829179745357590596408023867275770197075707094053216000680544580256094089113804288267449089904640326828789035666143699659867092108718279796583028512542392495421779",
           "1.5707963267938966192313216916397514424319180330208862438208054294872415364764378326474936031472490101815502336217205184029120016698547471043186681600526965471042074304163483259318452680435202095109230279463923963492870040904012032740805456738144599352893425202988524603439218707929425378295371082108281620406379082813613862672159901100496534463976107550806601465567059619048829495421806391510160463001",
           "1.5707963267948965192313216916397514420985846996878862438208056294872415364764378306473507460043918673244073765899887723711659699238229101634817272120007484952330785592874771970616254211570733230640365810600043257395046296021443620234312981206088055277773974880349347475097997796620171523611445056144296707974573126845590321623615288317089359131170138395627805178532322154433252386274406088878525130896",
           "1.5707963267948966192213216916397514420985846996875529104874726294872415364764378326473507460043918673044073765899744866568802556381086244491974416088261453206299039561128740224575416159622681282588417758651991386266175167241223840014532761425201608391327088433455208280958809539778973505942839152244275827508237604782514078980809178018719474972957865632271450490908284680846718670522639450168825443945",
           "1.5707963267948966192313206916397514420985846996875529104874722961539082034764378326473507460043918673244073765899744866566802556381086244491960130373975738920584753846844454510289702985019506679413814584048816783091570881436029034819727566620006803196521893628268096302936831517800951527920861130266253182819592915368594665061395258604800061112367475630116742454513973110064559653064241192080164878504",
           "1.5707963267948966192313216915397514420985846996875529104874722961539082031431044993143507460043918673244073765899744866568802556381086244491940130373975738920584753846843025938861131556448078107985386012620245354520143421118568717359410106302546485736203322199696666822417350998320432047401380610785733702300121487566396862863593060802602258914565277827918940256045031718123167711672299800138772937113",
           "1.5707963267948966192313216916397414420985846996875529104874722961539082031431044993140174126710588673244073765899744866568802556381086244491960130373975738920584553846843025938861131556448078107985243155477388211663000563975725860216552963445403628593347290453664920790671319252288686015654237753642876559442969539514448810915541112750654206966513329776061797398902251498342947931452519580358553156893",
           "1.5707963267948966192313216916397514410985846996875529104874722961539082031431044993140174126710585339910740435899744866568802556381086244491960130373975738920584753846843025938861129556448078107985243155477388211663000563975711574502267249159689342879063004739379206504957033538002971729941063150468273384839794936339845636311255398464939921252227615490256602593707446303537753126257714385553358352607",
           "1.5707963267948966192313216916397514420984846996875529104874722961539082031431044993140174126710585339910740432566411533238802556381086244491960130373975738920584753846843025938861131556448078107985243135477388211663000563975711574502267249159689342879061576167950635076385604966574543158512491721896844813411223507768417064883795081004622460934767298029939142275136017732109181697686285814124786923127",
           "1.5707963267948966192313216916397514420985846896875529104874722961539082031431044993140174126710585339910740432566411533235469223047756244491960130373975738920584753846843025938861131556448078107985243155477388211663000563775711574502267249159689342879061576167950635076385604966574400301369634579039701956268380650625559922026652223861765318077624440887081999419104271700363149951654539782378755175984",
           "1.5707963267948966192313216916397514420985846996865529104874722961539082031431044993140174126710585339910740432566411533235469223047752911158626800373975738920584753846843025938861131556448078107985243155477388211663000563975711574502267249157689342879061576167950635076385604966574400301369634579039701956268366364911274207740937938147481032363338726601367713704818557414648864237368825496664469462809",
           "1.5707963267948966192313216916397514420985846996875528104874722961539082031431044993140174126710585339910740432566411533235469223047752911158626797040642405590584753846843025938861131556448078107985243155477388211663000563975711574502267249159689342879061576167930635076385604966574400301369634579039701956268366364911274207740937938147479603791910155172796285133390128843220292808797396925235898034238",
           "1.5707963267948966192313216916397514420985846996875529104774722961539082031431044993140174126710585339910740432566411533235469223047752911158626797040642405587251420513513025938861131556448078107985243155477388211663000563975711574502267249159689342879061576167950635076385604966574200301369634579039701956268366364911274207740937938147479603791910155172796285133389985986077435665940254068093055177095",
           "1.570796326794896619231321691639751442098584699687552910487471296153908203143104499314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552780155644807810798524315547738821166300056397571157450226724915968934287906157616795063507638560496657440030136963457903969995626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296053908203143104499314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477798524315547738821166300056397571157450226724915968934287906157616795063507638560496657440030136963457903970195626836636491127418774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153898203143104499314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214738821166300056397571157450226724915968934287906157616795063507638560496657440030136963457903970195626836636491127420774093793814747960359191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908202143104499314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832967056397571157450226724915968934287906157616795063507638560496657440030136963457903970195626836636491127420774093793814747960379191015517279628513138998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143004499314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824450226724915968934287906157616795063507638560496657440030136963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566592025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104489314017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582968934287906157616795063507638560496657440030136963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104499313017412671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582635600954573157616795063507638560496657440030136963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104499314017312671058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582635600954572824283461730507638560496657440030136963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104499314017412661058533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582635600954572824283461730174305227163657440030136963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104499314017412671057533991074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582635600954572824283461730174305227163324106696803963457903970195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
           "1.570796326794896619231321691639751442098584699687552910487472296153908203143104499314017412671058533891074043256641153323546922304775291115862679704064240558725142051350969260552779822311474477465190982214405487832966723064237824116893391582635600954572824283461730174305227163324106696803630124570637195626836636491127420774093793814747960379191015517279628513338998598607743566594025406809304089138",
       }};

   T arg = static_cast<T>("1e-100");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = atan(arg);
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = atan(-arg);
      e   = relative_error(val, T(-T(data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      arg *= 10000;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 10);
   BOOST_TEST(atan(T(0)) == 0);

   //
   // And again, but test all the phases of atan2:
   //
   arg = static_cast<T>("1e-100");
   unsigned err;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T val = atan2(arg, 1);
      T e   = relative_error(val, atan2_def(arg, T(1)));
      err   = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = atan2(-arg, 1);
      e   = relative_error(val, atan2_def(T(-arg), T(1)));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = atan2(arg, -1);
      e   = relative_error(val, atan2_def(arg, T(-1)));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = atan2(-arg, -1);
      e   = relative_error(val, atan2_def(T(-arg), T(-1)));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      arg *= 10000;
   }
   //
   // special cases:
   //
   err = relative_error(T(atan2(T(0), T(1))), atan2_def(T(0), T(1))).template convert_to<unsigned>();
   if (err > max_err)
      max_err = err;
   if (!boost::multiprecision::is_interval_number<T>::value)
   {
      // We don't test this with intervals as [-0,0] leads to strange behaviour in atan2...
      err = relative_error(T(atan2(T(0), T(-1))), atan2_def(T(0), T(-1))).template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }

   T pi;
   pi.backend() = boost::multiprecision::default_ops::get_constant_pi<typename T::backend_type>();

   err = relative_error(T(atan2(T(1), T(0))), T(pi / 2)).template convert_to<unsigned>();
   if (err > max_err)
      max_err = err;

   err = relative_error(T(atan2(T(-1), T(0))), T(pi / -2)).template convert_to<unsigned>();
   if (err > max_err)
      max_err = err;

   T mv = (std::numeric_limits<T>::max)();
   err  = relative_error(T(atan2(mv, T(1))), T(pi / 2)).template convert_to<unsigned>();
   if (err > max_err)
      max_err = err;
   err = relative_error(T(atan2(-mv, T(1))), T(pi / -2)).template convert_to<unsigned>();
   if (err > max_err)
      max_err = err;

   if (std::numeric_limits<T>::has_infinity)
   {
      mv  = (std::numeric_limits<T>::infinity)();
      err = relative_error(T(atan2(mv, T(1))), T(pi / 2)).template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      err = relative_error(T(atan2(-mv, T(1))), T(pi / -2)).template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }

   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 2000);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_checked_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class Number>
void test_signed_overflow(Number a, Number b, const std::integral_constant<bool, true>&)
{
   a = -a;
   BOOST_CHECK_THROW(Number(a * b), std::overflow_error);
   ++a;
   BOOST_CHECK(Number(a * b) >= (std::numeric_limits<Number>::min)());
}
template <class Number>
void test_signed_overflow(Number, Number, const std::integral_constant<bool, false>&)
{
}

template <class Number>
void test()
{
   using namespace boost::multiprecision;
   typedef Number test_type;

   if (std::numeric_limits<test_type>::is_bounded)
   {
      test_type val = (std::numeric_limits<test_type>::max)();
#ifndef BOOST_NO_EXCEPTIONS
      BOOST_CHECK_THROW(++val, std::overflow_error);
      val = (std::numeric_limits<test_type>::max)();
      BOOST_CHECK_THROW(test_type(1 + val), std::overflow_error);
      BOOST_CHECK_THROW(test_type(val + 1), std::overflow_error);
      BOOST_CHECK_THROW(test_type(2 * val), std::overflow_error);
      val /= 2;
      val += 1;
      BOOST_CHECK_THROW(test_type(2 * val), std::overflow_error);

      if (std::numeric_limits<test_type>::is_signed)
      {
         val = (std::numeric_limits<test_type>::min)();
         BOOST_CHECK_THROW(--val, std::overflow_error);
         val = (std::numeric_limits<test_type>::min)();
         BOOST_CHECK_THROW(test_type(val - 1), std::overflow_error);
         BOOST_CHECK_THROW(test_type(2 * val), std::overflow_error);
         val /= 2;
         val -= 1;
         BOOST_CHECK_THROW(test_type(2 * val), std::overflow_error);
      }
      else
      {
         val = (std::numeric_limits<test_type>::min)();
         BOOST_CHECK_THROW(--val, std::range_error);
         val = (std::numeric_limits<test_type>::min)();
         BOOST_CHECK_THROW(test_type(val - 1), std::range_error);
      }
#endif
      //
      // Test overflow in random values:
      //
      for (unsigned bits = 30; bits < std::numeric_limits<test_type>::digits; bits += 30)
      {
         for (unsigned i = 0; i < 100; ++i)
         {
            val            = static_cast<test_type>(generate_random<cpp_int>(bits));
            test_type val2 = 1 + (std::numeric_limits<test_type>::max)() / val;
            BOOST_CHECK_THROW(test_type(val2 * val), std::overflow_error);
            test_signed_overflow(val2, val, std::integral_constant<bool, std::numeric_limits<test_type>::is_signed>());
            --val2;
            BOOST_CHECK(cpp_int(val2) * cpp_int(val) <= cpp_int((std::numeric_limits<test_type>::max)()));
            BOOST_CHECK(val2 * val <= (std::numeric_limits<test_type>::max)());
            val2 = (std::numeric_limits<test_type>::max)() - val;
            ++val2;
            BOOST_CHECK_THROW(test_type(val2 + val), std::overflow_error);
            BOOST_CHECK((val2 - 1) + val == (std::numeric_limits<test_type>::max)());
            if (std::numeric_limits<test_type>::is_signed)
            {
               val2 = (std::numeric_limits<test_type>::min)() + val;
               --val2;
               BOOST_CHECK_THROW(test_type(val2 - val), std::overflow_error);
               ++val2;
               BOOST_CHECK(val2 - val == (std::numeric_limits<test_type>::min)());
            }
            unsigned shift = std::numeric_limits<test_type>::digits - msb(val);
            BOOST_CHECK_THROW((val << shift) > 0, std::overflow_error);
         }
      }
   }

#ifndef BOOST_NO_EXCEPTIONS
   if (std::numeric_limits<test_type>::is_signed)
   {
      test_type a = -1;
      test_type b = 1;
      BOOST_CHECK_THROW(test_type(a | b), std::range_error);
      BOOST_CHECK_THROW(test_type(a & b), std::range_error);
      BOOST_CHECK_THROW(test_type(a ^ b), std::range_error);
   }
   else
   {
      // Constructing from a negative value is not allowed:
      BOOST_CHECK_THROW(test_type(-2), std::range_error);
      BOOST_CHECK_THROW(test_type("-2"), std::range_error);
   }
   if (std::numeric_limits<test_type>::digits < std::numeric_limits<long long>::digits)
   {
      long long llm = (std::numeric_limits<long long>::max)();
      test_type t;
      BOOST_CHECK_THROW(t = llm, std::range_error);
      BOOST_CHECK_THROW(t = static_cast<test_type>(llm), std::range_error);
      unsigned long long ullm = (std::numeric_limits<unsigned long long>::max)();
      BOOST_CHECK_THROW(t = ullm, std::range_error);
      BOOST_CHECK_THROW(t = static_cast<test_type>(ullm), std::range_error);

      static const checked_uint512_t big = (std::numeric_limits<checked_uint512_t>::max)();
      BOOST_CHECK_THROW(t = static_cast<test_type>(big), std::range_error);
   }
   //
   // String errors:
   //
   BOOST_CHECK_THROW(test_type("12A"), std::runtime_error);
   BOOST_CHECK_THROW(test_type("0658"), std::runtime_error);

   if (std::numeric_limits<test_type>::is_signed)
   {
      BOOST_CHECK_THROW(test_type(-2).str(0, std::ios_base::hex), std::runtime_error);
      BOOST_CHECK_THROW(test_type(-2).str(0, std::ios_base::oct), std::runtime_error);
   }
#endif
}

int main()
{
   using namespace boost::multiprecision;

   test<number<cpp_int_backend<0, 0, signed_magnitude, checked> > >();
   test<checked_int512_t>();
   test<checked_uint512_t>();
   test<number<cpp_int_backend<32, 32, signed_magnitude, checked, void> > >();
   test<number<cpp_int_backend<32, 32, unsigned_magnitude, checked, void> > >();

   //
   // We also need to test type with "odd" bit counts in order to ensure full code coverage:
   //
   test<number<cpp_int_backend<528, 528, signed_magnitude, checked, void> > >();
   test<number<cpp_int_backend<528, 528, unsigned_magnitude, checked, void> > >();
   test<number<cpp_int_backend<48, 48, signed_magnitude, checked, void> > >();
   test<number<cpp_int_backend<48, 48, unsigned_magnitude, checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_checked_mixed_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

template <class T, class U>
void check_result_type(const T&, const U&)
{
   BOOST_CHECK(0);
}

void check_result_type(const boost::multiprecision::checked_int1024_t&, const boost::multiprecision::checked_int1024_t&) {}

int main()
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      typedef boost::multiprecision::checked_int1024_t                                                                                                                                                    big_type;
      typedef boost::multiprecision::checked_int512_t                                                                                                                                                     small_type;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void>, boost::multiprecision::et_off> little_type;

      big_type    big_val    = (big_type(1) << 1000) + 1;
      small_type  small_val  = 1;
      little_type little_val = 1;

      check_result_type(big_val, big_val + small_val);
      check_result_type(big_val, big_val - small_val);
      check_result_type(big_val, big_val * small_val);
      check_result_type(big_val, big_val / small_val);
      check_result_type(big_val, big_val | small_val);
      check_result_type(big_val, big_val & small_val);
      check_result_type(big_val, big_val ^ small_val);
      check_result_type(big_val, small_val + big_val);
      check_result_type(big_val, small_val - big_val);
      check_result_type(big_val, small_val * big_val);
      check_result_type(big_val, small_val / big_val);
      check_result_type(big_val, small_val | big_val);
      check_result_type(big_val, small_val & big_val);
      check_result_type(big_val, small_val ^ big_val);

      check_result_type(big_val, big_val + little_val);
      check_result_type(big_val, big_val - little_val);
      check_result_type(big_val, big_val * little_val);
      check_result_type(big_val, big_val / little_val);
      check_result_type(big_val, big_val | little_val);
      check_result_type(big_val, big_val & little_val);
      check_result_type(big_val, big_val ^ little_val);
      check_result_type(big_val, little_val + big_val);
      check_result_type(big_val, little_val - big_val);
      check_result_type(big_val, little_val * big_val);
      check_result_type(big_val, little_val / big_val);
      check_result_type(big_val, little_val | big_val);
      check_result_type(big_val, little_val & big_val);
      check_result_type(big_val, little_val ^ big_val);

      BOOST_CHECK_EQUAL(big_val == small_val, false);
      BOOST_CHECK_EQUAL(big_val <= small_val, false);
      BOOST_CHECK_EQUAL(big_val >= small_val, true);
      BOOST_CHECK_EQUAL(big_val < small_val, false);
      BOOST_CHECK_EQUAL(big_val > small_val, true);
      BOOST_CHECK_EQUAL(big_val != small_val, true);
      BOOST_CHECK_EQUAL(small_val == big_val, false);
      BOOST_CHECK_EQUAL(small_val <= big_val, true);
      BOOST_CHECK_EQUAL(small_val >= big_val, false);
      BOOST_CHECK_EQUAL(small_val < big_val, true);
      BOOST_CHECK_EQUAL(small_val > big_val, false);
      BOOST_CHECK_EQUAL(small_val != big_val, true);

      BOOST_CHECK_EQUAL(big_val == little_val, false);
      BOOST_CHECK_EQUAL(big_val <= little_val, false);
      BOOST_CHECK_EQUAL(big_val >= little_val, true);
      BOOST_CHECK_EQUAL(big_val < little_val, false);
      BOOST_CHECK_EQUAL(big_val > little_val, true);
      BOOST_CHECK_EQUAL(big_val != little_val, true);
      BOOST_CHECK_EQUAL(little_val == big_val, false);
      BOOST_CHECK_EQUAL(little_val <= big_val, true);
      BOOST_CHECK_EQUAL(little_val >= big_val, false);
      BOOST_CHECK_EQUAL(little_val < big_val, true);
      BOOST_CHECK_EQUAL(little_val > big_val, false);
      BOOST_CHECK_EQUAL(little_val != big_val, true);
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const std::exception& e)
   {
      std::cout << "Failed with unexpected exception: " << e.what() << std::endl;
      return 1;
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_complex.cpp
================================================

///////////////////////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2016.
//  Distributed under the Boost Software License,
//  Version 1.0. (See accompanying file LICENSE_1_0.txt
//  or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <string>

#include <boost/lexical_cast.hpp>
#ifdef TEST_MPC
#include <boost/multiprecision/mpc.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/complex_adaptor.hpp>
#ifdef BOOST_HAS_FLOAT128
#include <boost/multiprecision/complex128.hpp>
#endif

#include "test.hpp"

namespace local {
template <typename complex_type>
void test()
{

   typedef typename complex_type::value_type float_type;

   const std::string str_tol("0." + std::string(std::size_t(std::numeric_limits<float_type>::digits10 - 2), char('0')) + std::string(std::size_t(2U), char('9')));

   const float_type tol = boost::lexical_cast<float_type>(str_tol.c_str());

   std::cout << "Testing with tolerance: " << tol << std::endl;

   const complex_type z1(float_type(12U) / 10U, float_type(34U) / 10U);
   const complex_type z2(float_type(56U) / 10U, float_type(78U) / 10U);
   const complex_type i(float_type(0U), float_type(1U));

   // See also, for example, numerical evaluation at Wolfram's Alpha.

   const complex_type result_01 = z1 / z2;                      // N[((12/10) + ((34 I)/10)) / ((56/10) + ((78 I)/10)), 100]
   const complex_type result_02 = complex_type(z1) /= z2;       // Same as above.
   const complex_type result_03 = z1 / (i * z2);                // N[((12/10) + ((34 I)/10)) / ((-78/10) + ((56 I)/10)), 100]
   const complex_type result_04 = complex_type(z1) /= (i * z2); // Same as above.
   const complex_type result_05 = z1.real() / z2;               // N[((12/10) / ((56/10) + ((78 I)/10)), 100]
   const complex_type result_06 = z1.real() / (i * z2);         // N[((12/10) / ((-78/10) + ((56 I)/10)), 100]
   const complex_type result_07 = sqrt(z1);                     // N[Sqrt[(12/10) + ((34 I)/10)], 100]
   const complex_type result_08 = sqrt(-z1);                    // N[Sqrt[(-12/10) - ((34 I)/10)], 100]
   const complex_type result_09 = sin(z1);                      // N[Sin[(12/10) + ((34 I)/10)], 100]
   const complex_type result_10 = sinh(z1);                     // N[Sinh[(12/10) + ((34 I)/10)], 100]
   const complex_type result_11 = cosh(z1);                     // N[Cosh[(12/10) + ((34 I)/10)], 100]
   const complex_type result_12 = log(z1);                      // N[Log[(12/10) + ((34 I)/10)], 100]
   const complex_type result_13 = asin(z1);                     // N[ArcSin[(12/10) + ((34 I)/10)], 100]
   const complex_type result_14 = acos(z1);                     // N[ArcCos[(12/10) + ((34 I)/10)], 100]
   const complex_type result_15 = atan(z1);                     // N[ArcTan[(12/10) + ((34 I)/10)], 100]
   const complex_type result_16 = acosh(z1);                    // N[ArcCosh[(12/10) + ((34 I)/10)], 100]
   const complex_type result_17 = atanh(z1);                    // N[ArcTanh[(12/10) + ((34 I)/10)], 100]
   const complex_type result_18 = exp(z1);                      // N[Exp[(12/10) + ((34 I)/10)], 100]
   const complex_type result_19 = pow(z1, 5);                   // N[((12/10) + ((34 I)/10)) ^ 5, 100]
   const complex_type result_20 = pow(z1, z2);                  // N[((12/10) + ((34 I)/10)) ^ ((56/10) + ((78 I)/10)), 100]
   const complex_type result_21 = pow(z1.real(), z2);           // N[(12/10)^((56/10) + ((78 I)/10)), 100]
   const complex_type result_22 = cos(z1);
   const complex_type result_23 = asinh(z1);
   const complex_type result_24 = tanh(z1);
   const complex_type result_25 = log10(z1);
   const complex_type result_26 = tan(z1);

   const complex_type control_01(boost::lexical_cast<float_type>("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast<float_type>("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"));
   const complex_type control_02(boost::lexical_cast<float_type>("+0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"), boost::lexical_cast<float_type>("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"));
   const complex_type control_03(boost::lexical_cast<float_type>("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast<float_type>("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"));
   const complex_type control_04(boost::lexical_cast<float_type>("+0.1049891540130151843817787418655097613882863340563991323210412147505422993492407809110629067245119306"), boost::lexical_cast<float_type>("-0.3605206073752711496746203904555314533622559652928416485900216919739696312364425162689804772234273319"));
   const complex_type control_05(boost::lexical_cast<float_type>("+0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421"), boost::lexical_cast<float_type>("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800"));
   const complex_type control_06(boost::lexical_cast<float_type>("-0.10151843817787418655097613882863340563991323210412147505422993492407809110629067245119305856832971800"), boost::lexical_cast<float_type>("-0.07288503253796095444685466377440347071583514099783080260303687635574837310195227765726681127982646421"));
   const complex_type control_07(boost::lexical_cast<float_type>("+1.5500889128472581416161256546038815669761567486848749301860666965618993040312647033986371788677357208"), boost::lexical_cast<float_type>("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395"));
   const complex_type control_08(boost::lexical_cast<float_type>("+1.096711282759503047577277387056220643003106823143745046422869808875853261131777962620301480493467395"), boost::lexical_cast<float_type>("-1.550088912847258141616125654603881566976156748684874930186066696561899304031264703398637178867735721"));
   const complex_type control_09(boost::lexical_cast<float_type>("+13.97940880601799793712580492576613541257396172944193599059708688128463118206190268215536541838594224"), boost::lexical_cast<float_type>("+5.42281547246340124509840716106599160358961329374827042575715571177243361237429170135167564889390308"));
   const complex_type control_10(boost::lexical_cast<float_type>("-1.459344510181031985739679928789446132188487461323488604725673812272622166868694452733557505015403343"), boost::lexical_cast<float_type>("-0.462696919065088203665190427736980818788403809123239459086853242811288735966522197819049006036217659"));
   const complex_type control_11(boost::lexical_cast<float_type>("-1.750538529873144139045226521462954860931070703406867443705575327698120127693949444003491179539803540"), boost::lexical_cast<float_type>("-0.385729418228941114585783287542904778761684113049496885765699906882071623161614865310950661528173196"));
   const complex_type control_12(boost::lexical_cast<float_type>("+1.282474678730768368026743720782659302402633972380103558209522755331732333662205089699787331720244744"), boost::lexical_cast<float_type>("+1.231503712340851938048420309342408065643217837171236736591653326549432606404929552637127722999523972"));
   const complex_type control_13(boost::lexical_cast<float_type>("+0.327743052014525194927829972510958755346463574500092232271394201982853487105798907461836716106793827"), boost::lexical_cast<float_type>("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"));
   const complex_type control_14(boost::lexical_cast<float_type>("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707"), boost::lexical_cast<float_type>("-1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"));
   const complex_type control_15(boost::lexical_cast<float_type>("+1.472098546869956240046296809042356295374792147793626859728627826033391218153982606447668498652414512"), boost::lexical_cast<float_type>("+0.265217990171315665670057272294610940896446740868740866767584213220467425714221740314551620202361000"));
   const complex_type control_16(boost::lexical_cast<float_type>("+1.990465064891068704855135027843677587369707826516050430927052768488360486375325411568355926052994795"), boost::lexical_cast<float_type>("+1.243053274780371424303491719128792686752121125187460678216078094171054716037305591852180696564264707"));
   const complex_type control_17(boost::lexical_cast<float_type>("+0.0865690591794584441708728351688739957204743888691393886743981396542994588169512931672375066385325971"), boost::lexical_cast<float_type>("+1.3130218230654070842957152910299990808349983340931830855923498117237087784015805687823303378344863815"));
   const complex_type control_18(boost::lexical_cast<float_type>("-3.209883040054176124784906450252400993119558164730356048431249139970742294562643896737048684555206883"), boost::lexical_cast<float_type>("-0.848426337294029318250973715279885597550087922172736344852553149693360359128137063129999667564390855"));
   const complex_type control_19(boost::lexical_cast<float_type>("+604.5331200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), boost::lexical_cast<float_type>("-76.3721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
   const complex_type control_20(boost::lexical_cast<float_type>("-0.03277613870122620601990858385164868868755535963372013573012556184586155243067581560513902047571175876"), boost::lexical_cast<float_type>("-0.08229096285844296094766104540456274850393339107196281307901532754610012233461478959682645571793968423"));
   const complex_type control_21(boost::lexical_cast<float_type>("+0.411234943477464115466545795217592784968613499972731227382657362718492707513495252941835813107553442"), boost::lexical_cast<float_type>("+2.745341999926603737618437066482640101524732307796305942046035072295581269096378050886721641340275877"));
   const complex_type control_22(boost::lexical_cast<float_type>("+5.434908535625768828356755041961059164496984604872689362797531800548498933607521437636349622508613554091586385714"), boost::lexical_cast<float_type>("-13.94830361398843812562310928749334812612948167559995042721295554487075295893311479161719058895913730856339351903"));
   const complex_type control_23(boost::lexical_cast<float_type>("1.960545624274756532757863147926614306606344023611895252748744677291286163242757958621205801565261867742512464966"), boost::lexical_cast<float_type>("1.218868916639890129907167289780557894460959308403278313426586722860313100564201336738382323265397208095855244598"));
   const complex_type control_24(boost::lexical_cast<float_type>("0.850596957549373767077286649475619401136709177565015571227494818854489310955671601843121766190907188858336389856"), boost::lexical_cast<float_type>("0.0768887100657045933256083080177585250084258780189064853743639639730289473609169028321092839605973770873615254969"));
   const complex_type control_25(boost::lexical_cast<float_type>("0.556971676153418384603252578971164215414864594193534135900595487498776545815097120403823727129449829836488977743"), boost::lexical_cast<float_type>("0.534835266713001566463607491752731752251883431441322590506193641481222966948925488019132991641807563958917938106"));
   const complex_type control_26(boost::lexical_cast<float_type>("0.001507101875805783093387404217890750536099188330196632424994845319829605048223792684300657269522163036773069001022"), boost::lexical_cast<float_type>("1.001642796989141044331404504473463720289288872859072985897399123485040632782581390249339681901758734269277005380"));

   BOOST_CHECK_CLOSE_FRACTION(result_01.real(), control_01.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_01.imag(), control_01.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_02.real(), control_02.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_02.imag(), control_02.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_03.real(), control_03.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_03.imag(), control_03.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_04.real(), control_04.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_04.imag(), control_04.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_05.real(), control_05.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_05.imag(), control_05.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_06.real(), control_06.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_06.imag(), control_06.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_07.real(), control_07.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_07.imag(), control_07.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_08.real(), control_08.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_08.imag(), control_08.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_09.real(), control_09.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_09.imag(), control_09.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_10.real(), control_10.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_10.imag(), control_10.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_11.real(), control_11.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_11.imag(), control_11.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_12.real(), control_12.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_12.imag(), control_12.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_13.real(), control_13.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_13.imag(), control_13.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_14.real(), control_14.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_14.imag(), control_14.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_15.real(), control_15.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_15.imag(), control_15.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_16.real(), control_16.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_16.imag(), control_16.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_17.real(), control_17.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_17.imag(), control_17.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_18.real(), control_18.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_18.imag(), control_18.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_19.real(), control_19.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_19.imag(), control_19.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_20.real(), control_20.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_20.imag(), control_20.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_21.real(), control_21.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_21.imag(), control_21.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_22.real(), control_22.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_22.imag(), control_22.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_23.real(), control_23.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_23.imag(), control_23.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_24.real(), control_24.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_24.imag(), control_24.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_25.real(), control_25.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_25.imag(), control_25.imag(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_26.real(), control_26.real(), tol);
   BOOST_CHECK_CLOSE_FRACTION(result_26.imag(), control_26.imag(), tol);

   BOOST_CHECK_CLOSE_FRACTION(abs(z1), boost::lexical_cast<float_type>("3.60555127546398929311922126747049594625129657384524621271045305622716694829301044520461908201849071767351418202406"), tol)
}
} // namespace local

int main()
{
   //local::test<std::complex<double> >();
#ifdef TEST_MPC
   local::test<boost::multiprecision::mpc_complex_50>();
   local::test<boost::multiprecision::mpc_complex_100>();
#endif
   local::test<boost::multiprecision::number<boost::multiprecision::complex_adaptor<boost::multiprecision::cpp_bin_float<50> >, boost::multiprecision::et_on> >();
   local::test<boost::multiprecision::number<boost::multiprecision::complex_adaptor<boost::multiprecision::cpp_bin_float<50> >, boost::multiprecision::et_off> >();
#ifdef BOOST_HAS_FLOAT128
   local::test<boost::multiprecision::complex128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_complex_signed_zero.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/sign.hpp>
#include <complex>

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_DOUBLE) && !defined(TEST_MPC)
#define TEST_CPP_BIN_FLOAT
#define TEST_DOUBLE
#define TEST_MPC
#endif


#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_complex.hpp>
#endif
#ifdef TEST_MPC
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
void test()
{
   using std::real;
   using std::imag;
   using std::signbit;
   using std::isnan;

   using value_type = typename T::value_type;

   T result;
   //
   // Muliply the permutations which give at least one zero:
   //
   static constexpr std::array<std::array<double, 6>, 256> mul_data = 
   { {
      {{+0.000, +0.000, +0.000, +0.000, +0.000, +0.000}},
      {{+0.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
      {{+0.000, +0.000, +0.000, +2.000, +0.000, +0.000}},
      {{+0.000, +0.000, +0.000, -2.000, +0.000, +0.000}},
      {{+0.000, +0.000, -0.000, +0.000, -0.000, +0.000}},
      {{+0.000, +0.000, -0.000, -0.000, +0.000, -0.000}},
      {{+0.000, +0.000, -0.000, +2.000, -0.000, +0.000}},
      {{+0.000, +0.000, -0.000, -2.000, +0.000, -0.000}},
      {{+0.000, +0.000, +2.000, +0.000, +0.000, +0.000}},
      {{+0.000, +0.000, +2.000, -0.000, +0.000, +0.000}},
      {{+0.000, +0.000, +2.000, +2.000, +0.000, +0.000}},
      {{+0.000, +0.000, +2.000, -2.000, +0.000, +0.000}},
      {{+0.000, +0.000, -2.000, +0.000, -0.000, +0.000}},
      {{+0.000, +0.000, -2.000, -0.000, +0.000, -0.000}},
      {{+0.000, +0.000, -2.000, +2.000, -0.000, +0.000}},
      {{+0.000, +0.000, -2.000, -2.000, +0.000, -0.000}},
      {{+0.000, -0.000, +0.000, +0.000, +0.000, +0.000}},
      {{+0.000, -0.000, +0.000, -0.000, +0.000, -0.000}},
      {{+0.000, -0.000, +0.000, +2.000, +0.000, +0.000}},
      {{+0.000, -0.000, +0.000, -2.000, +0.000, -0.000}},
      {{+0.000, -0.000, -0.000, +0.000, +0.000, +0.000}},
      {{+0.000, -0.000, -0.000, -0.000, -0.000, +0.000}},
      {{+0.000, -0.000, -0.000, +2.000, +0.000, +0.000}},
      {{+0.000, -0.000, -0.000, -2.000, -0.000, +0.000}},
      {{+0.000, -0.000, +2.000, +0.000, +0.000, +0.000}},
      {{+0.000, -0.000, +2.000, -0.000, +0.000, -0.000}},
      {{+0.000, -0.000, +2.000, +2.000, +0.000, +0.000}},
      {{+0.000, -0.000, +2.000, -2.000, +0.000, -0.000}},
      {{+0.000, -0.000, -2.000, +0.000, +0.000, +0.000}},
      {{+0.000, -0.000, -2.000, -0.000, -0.000, +0.000}},
      {{+0.000, -0.000, -2.000, +2.000, +0.000, +0.000}},
      {{+0.000, -0.000, -2.000, -2.000, -0.000, +0.000}},
      {{+0.000, +2.000, +0.000, +0.000, +0.000, +0.000}},
      {{+0.000, +2.000, +0.000, -0.000, +0.000, +0.000}},
      {{+0.000, +2.000, +0.000, +2.000, -4.000, +0.000}},
      {{+0.000, +2.000, +0.000, -2.000, +4.000, +0.000}},
      {{+0.000, +2.000, -0.000, +0.000, -0.000, +0.000}},
      {{+0.000, +2.000, -0.000, -0.000, +0.000, -0.000}},
      {{+0.000, +2.000, -0.000, +2.000, -4.000, +0.000}},
      {{+0.000, +2.000, -0.000, -2.000, +4.000, -0.000}},
      {{+0.000, +2.000, +2.000, +0.000, +0.000, +4.000}},
      {{+0.000, +2.000, +2.000, -0.000, +0.000, +4.000}},
      {{+0.000, +2.000, +2.000, +2.000, -4.000, +4.000}},
      {{+0.000, +2.000, +2.000, -2.000, +4.000, +4.000}},
      {{+0.000, +2.000, -2.000, +0.000, -0.000, -4.000}},
      {{+0.000, +2.000, -2.000, -0.000, +0.000, -4.000}},
      {{+0.000, +2.000, -2.000, +2.000, -4.000, -4.000}},
      {{+0.000, +2.000, -2.000, -2.000, +4.000, -4.000}},
      {{+0.000, -2.000, +0.000, +0.000, +0.000, +0.000}},
      {{+0.000, -2.000, +0.000, -0.000, +0.000, -0.000}},
      {{+0.000, -2.000, +0.000, +2.000, +4.000, +0.000}},
      {{+0.000, -2.000, +0.000, -2.000, -4.000, -0.000}},
      {{+0.000, -2.000, -0.000, +0.000, +0.000, +0.000}},
      {{+0.000, -2.000, -0.000, -0.000, -0.000, +0.000}},
      {{+0.000, -2.000, -0.000, +2.000, +4.000, +0.000}},
      {{+0.000, -2.000, -0.000, -2.000, -4.000, +0.000}},
      {{+0.000, -2.000, +2.000, +0.000, +0.000, -4.000}},
      {{+0.000, -2.000, +2.000, -0.000, +0.000, -4.000}},
      {{+0.000, -2.000, +2.000, +2.000, +4.000, -4.000}},
      {{+0.000, -2.000, +2.000, -2.000, -4.000, -4.000}},
      {{+0.000, -2.000, -2.000, +0.000, +0.000, +4.000}},
      {{+0.000, -2.000, -2.000, -0.000, -0.000, +4.000}},
      {{+0.000, -2.000, -2.000, +2.000, +4.000, +4.000}},
      {{+0.000, -2.000, -2.000, -2.000, -4.000, +4.000}},
      {{-0.000, +0.000, +0.000, +0.000, -0.000, +0.000}},
      {{-0.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
      {{-0.000, +0.000, +0.000, +2.000, -0.000, +0.000}},
      {{-0.000, +0.000, +0.000, -2.000, +0.000, +0.000}},
      {{-0.000, +0.000, -0.000, +0.000, +0.000, -0.000}},
      {{-0.000, +0.000, -0.000, -0.000, +0.000, +0.000}},
      {{-0.000, +0.000, -0.000, +2.000, +0.000, -0.000}},
      {{-0.000, +0.000, -0.000, -2.000, +0.000, +0.000}},
      {{-0.000, +0.000, +2.000, +0.000, -0.000, +0.000}},
      {{-0.000, +0.000, +2.000, -0.000, +0.000, +0.000}},
      {{-0.000, +0.000, +2.000, +2.000, -0.000, +0.000}},
      {{-0.000, +0.000, +2.000, -2.000, +0.000, +0.000}},
      {{-0.000, +0.000, -2.000, +0.000, +0.000, -0.000}},
      {{-0.000, +0.000, -2.000, -0.000, +0.000, +0.000}},
      {{-0.000, +0.000, -2.000, +2.000, +0.000, -0.000}},
      {{-0.000, +0.000, -2.000, -2.000, +0.000, +0.000}},
      {{-0.000, -0.000, +0.000, +0.000, +0.000, -0.000}},
      {{-0.000, -0.000, +0.000, -0.000, -0.000, +0.000}},
      {{-0.000, -0.000, +0.000, +2.000, +0.000, -0.000}},
      {{-0.000, -0.000, +0.000, -2.000, -0.000, +0.000}},
      {{-0.000, -0.000, -0.000, +0.000, +0.000, +0.000}},
      {{-0.000, -0.000, -0.000, -0.000, +0.000, +0.000}},
      {{-0.000, -0.000, -0.000, +2.000, +0.000, +0.000}},
      {{-0.000, -0.000, -0.000, -2.000, +0.000, +0.000}},
      {{-0.000, -0.000, +2.000, +0.000, +0.000, -0.000}},
      {{-0.000, -0.000, +2.000, -0.000, -0.000, +0.000}},
      {{-0.000, -0.000, +2.000, +2.000, +0.000, -0.000}},
      {{-0.000, -0.000, +2.000, -2.000, -0.000, +0.000}},
      {{-0.000, -0.000, -2.000, +0.000, +0.000, +0.000}},
      {{-0.000, -0.000, -2.000, -0.000, +0.000, +0.000}},
      {{-0.000, -0.000, -2.000, +2.000, +0.000, +0.000}},
      {{-0.000, -0.000, -2.000, -2.000, +0.000, +0.000}},
      {{-0.000, +2.000, +0.000, +0.000, -0.000, +0.000}},
      {{-0.000, +2.000, +0.000, -0.000, +0.000, +0.000}},
      {{-0.000, +2.000, +0.000, +2.000, -4.000, +0.000}},
      {{-0.000, +2.000, +0.000, -2.000, +4.000, +0.000}},
      {{-0.000, +2.000, -0.000, +0.000, +0.000, -0.000}},
      {{-0.000, +2.000, -0.000, -0.000, +0.000, +0.000}},
      {{-0.000, +2.000, -0.000, +2.000, -4.000, -0.000}},
      {{-0.000, +2.000, -0.000, -2.000, +4.000, +0.000}},
      {{-0.000, +2.000, +2.000, +0.000, -0.000, +4.000}},
      {{-0.000, +2.000, +2.000, -0.000, +0.000, +4.000}},
      {{-0.000, +2.000, +2.000, +2.000, -4.000, +4.000}},
      {{-0.000, +2.000, +2.000, -2.000, +4.000, +4.000}},
      {{-0.000, +2.000, -2.000, +0.000, +0.000, -4.000}},
      {{-0.000, +2.000, -2.000, -0.000, +0.000, -4.000}},
      {{-0.000, +2.000, -2.000, +2.000, -4.000, -4.000}},
      {{-0.000, +2.000, -2.000, -2.000, +4.000, -4.000}},
      {{-0.000, -2.000, +0.000, +0.000, +0.000, -0.000}},
      {{-0.000, -2.000, +0.000, -0.000, -0.000, +0.000}},
      {{-0.000, -2.000, +0.000, +2.000, +4.000, -0.000}},
      {{-0.000, -2.000, +0.000, -2.000, -4.000, +0.000}},
      {{-0.000, -2.000, -0.000, +0.000, +0.000, +0.000}},
      {{-0.000, -2.000, -0.000, -0.000, +0.000, +0.000}},
      {{-0.000, -2.000, -0.000, +2.000, +4.000, +0.000}},
      {{-0.000, -2.000, -0.000, -2.000, -4.000, +0.000}},
      {{-0.000, -2.000, +2.000, +0.000, +0.000, -4.000}},
      {{-0.000, -2.000, +2.000, -0.000, -0.000, -4.000}},
      {{-0.000, -2.000, +2.000, +2.000, +4.000, -4.000}},
      {{-0.000, -2.000, +2.000, -2.000, -4.000, -4.000}},
      {{-0.000, -2.000, -2.000, +0.000, +0.000, +4.000}},
      {{-0.000, -2.000, -2.000, -0.000, +0.000, +4.000}},
      {{-0.000, -2.000, -2.000, +2.000, +4.000, +4.000}},
      {{-0.000, -2.000, -2.000, -2.000, -4.000, +4.000}},
      {{+2.000, +0.000, +0.000, +0.000, +0.000, +0.000}},
      {{+2.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
      {{+2.000, +0.000, +0.000, +2.000, +0.000, +4.000}},
      {{+2.000, +0.000, +0.000, -2.000, +0.000, -4.000}},
      {{+2.000, +0.000, -0.000, +0.000, -0.000, +0.000}},
      {{+2.000, +0.000, -0.000, -0.000, +0.000, -0.000}},
      {{+2.000, +0.000, -0.000, +2.000, -0.000, +4.000}},
      {{+2.000, +0.000, -0.000, -2.000, +0.000, -4.000}},
      {{+2.000, +0.000, +2.000, +0.000, +4.000, +0.000}},
      {{+2.000, +0.000, +2.000, -0.000, +4.000, +0.000}},
      {{+2.000, +0.000, +2.000, +2.000, +4.000, +4.000}},
      {{+2.000, +0.000, +2.000, -2.000, +4.000, -4.000}},
      {{+2.000, +0.000, -2.000, +0.000, -4.000, +0.000}},
      {{+2.000, +0.000, -2.000, -0.000, -4.000, -0.000}},
      {{+2.000, +0.000, -2.000, +2.000, -4.000, +4.000}},
      {{+2.000, +0.000, -2.000, -2.000, -4.000, -4.000}},
      {{+2.000, -0.000, +0.000, +0.000, +0.000, +0.000}},
      {{+2.000, -0.000, +0.000, -0.000, +0.000, -0.000}},
      {{+2.000, -0.000, +0.000, +2.000, +0.000, +4.000}},
      {{+2.000, -0.000, +0.000, -2.000, +0.000, -4.000}},
      {{+2.000, -0.000, -0.000, +0.000, +0.000, +0.000}},
      {{+2.000, -0.000, -0.000, -0.000, -0.000, +0.000}},
      {{+2.000, -0.000, -0.000, +2.000, +0.000, +4.000}},
      {{+2.000, -0.000, -0.000, -2.000, -0.000, -4.000}},
      {{+2.000, -0.000, +2.000, +0.000, +4.000, +0.000}},
      {{+2.000, -0.000, +2.000, -0.000, +4.000, -0.000}},
      {{+2.000, -0.000, +2.000, +2.000, +4.000, +4.000}},
      {{+2.000, -0.000, +2.000, -2.000, +4.000, -4.000}},
      {{+2.000, -0.000, -2.000, +0.000, -4.000, +0.000}},
      {{+2.000, -0.000, -2.000, -0.000, -4.000, +0.000}},
      {{+2.000, -0.000, -2.000, +2.000, -4.000, +4.000}},
      {{+2.000, -0.000, -2.000, -2.000, -4.000, -4.000}},
      {{+2.000, +2.000, +0.000, +0.000, +0.000, +0.000}},
      {{+2.000, +2.000, +0.000, -0.000, +0.000, +0.000}},
      {{+2.000, +2.000, +0.000, +2.000, -4.000, +4.000}},
      {{+2.000, +2.000, +0.000, -2.000, +4.000, -4.000}},
      {{+2.000, +2.000, -0.000, +0.000, -0.000, +0.000}},
      {{+2.000, +2.000, -0.000, -0.000, +0.000, -0.000}},
      {{+2.000, +2.000, -0.000, +2.000, -4.000, +4.000}},
      {{+2.000, +2.000, -0.000, -2.000, +4.000, -4.000}},
      {{+2.000, +2.000, +2.000, +0.000, +4.000, +4.000}},
      {{+2.000, +2.000, +2.000, -0.000, +4.000, +4.000}},
      {{+2.000, +2.000, +2.000, +2.000, +0.000, +8.000}},
      {{+2.000, +2.000, +2.000, -2.000, +8.000, +0.000}},
      {{+2.000, +2.000, -2.000, +0.000, -4.000, -4.000}},
      {{+2.000, +2.000, -2.000, -0.000, -4.000, -4.000}},
      {{+2.000, +2.000, -2.000, +2.000, -8.000, +0.000}},
      {{+2.000, +2.000, -2.000, -2.000, +0.000, -8.000}},
      {{+2.000, -2.000, +0.000, +0.000, +0.000, +0.000}},
      {{+2.000, -2.000, +0.000, -0.000, +0.000, -0.000}},
      {{+2.000, -2.000, +0.000, +2.000, +4.000, +4.000}},
      {{+2.000, -2.000, +0.000, -2.000, -4.000, -4.000}},
      {{+2.000, -2.000, -0.000, +0.000, +0.000, +0.000}},
      {{+2.000, -2.000, -0.000, -0.000, -0.000, +0.000}},
      {{+2.000, -2.000, -0.000, +2.000, +4.000, +4.000}},
      {{+2.000, -2.000, -0.000, -2.000, -4.000, -4.000}},
      {{+2.000, -2.000, +2.000, +0.000, +4.000, -4.000}},
      {{+2.000, -2.000, +2.000, -0.000, +4.000, -4.000}},
      {{+2.000, -2.000, +2.000, +2.000, +8.000, +0.000}},
      {{+2.000, -2.000, +2.000, -2.000, +0.000, -8.000}},
      {{+2.000, -2.000, -2.000, +0.000, -4.000, +4.000}},
      {{+2.000, -2.000, -2.000, -0.000, -4.000, +4.000}},
      {{+2.000, -2.000, -2.000, +2.000, +0.000, +8.000}},
      {{+2.000, -2.000, -2.000, -2.000, -8.000, +0.000}},
      {{-2.000, +0.000, +0.000, +0.000, -0.000, +0.000}},
      {{-2.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
      {{-2.000, +0.000, +0.000, +2.000, -0.000, -4.000}},
      {{-2.000, +0.000, +0.000, -2.000, +0.000, +4.000}},
      {{-2.000, +0.000, -0.000, +0.000, +0.000, -0.000}},
      {{-2.000, +0.000, -0.000, -0.000, +0.000, +0.000}},
      {{-2.000, +0.000, -0.000, +2.000, +0.000, -4.000}},
      {{-2.000, +0.000, -0.000, -2.000, +0.000, +4.000}},
      {{-2.000, +0.000, +2.000, +0.000, -4.000, +0.000}},
      {{-2.000, +0.000, +2.000, -0.000, -4.000, +0.000}},
      {{-2.000, +0.000, +2.000, +2.000, -4.000, -4.000}},
      {{-2.000, +0.000, +2.000, -2.000, -4.000, +4.000}},
      {{-2.000, +0.000, -2.000, +0.000, +4.000, -0.000}},
      {{-2.000, +0.000, -2.000, -0.000, +4.000, +0.000}},
      {{-2.000, +0.000, -2.000, +2.000, +4.000, -4.000}},
      {{-2.000, +0.000, -2.000, -2.000, +4.000, +4.000}},
      {{-2.000, -0.000, +0.000, +0.000, +0.000, -0.000}},
      {{-2.000, -0.000, +0.000, -0.000, -0.000, +0.000}},
      {{-2.000, -0.000, +0.000, +2.000, +0.000, -4.000}},
      {{-2.000, -0.000, +0.000, -2.000, -0.000, +4.000}},
      {{-2.000, -0.000, -0.000, +0.000, +0.000, +0.000}},
      {{-2.000, -0.000, -0.000, -0.000, +0.000, +0.000}},
      {{-2.000, -0.000, -0.000, +2.000, +0.000, -4.000}},
      {{-2.000, -0.000, -0.000, -2.000, +0.000, +4.000}},
      {{-2.000, -0.000, +2.000, +0.000, -4.000, -0.000}},
      {{-2.000, -0.000, +2.000, -0.000, -4.000, +0.000}},
      {{-2.000, -0.000, +2.000, +2.000, -4.000, -4.000}},
      {{-2.000, -0.000, +2.000, -2.000, -4.000, +4.000}},
      {{-2.000, -0.000, -2.000, +0.000, +4.000, +0.000}},
      {{-2.000, -0.000, -2.000, -0.000, +4.000, +0.000}},
      {{-2.000, -0.000, -2.000, +2.000, +4.000, -4.000}},
      {{-2.000, -0.000, -2.000, -2.000, +4.000, +4.000}},
      {{-2.000, +2.000, +0.000, +0.000, -0.000, +0.000}},
      {{-2.000, +2.000, +0.000, -0.000, +0.000, +0.000}},
      {{-2.000, +2.000, +0.000, +2.000, -4.000, -4.000}},
      {{-2.000, +2.000, +0.000, -2.000, +4.000, +4.000}},
      {{-2.000, +2.000, -0.000, +0.000, +0.000, -0.000}},
      {{-2.000, +2.000, -0.000, -0.000, +0.000, +0.000}},
      {{-2.000, +2.000, -0.000, +2.000, -4.000, -4.000}},
      {{-2.000, +2.000, -0.000, -2.000, +4.000, +4.000}},
      {{-2.000, +2.000, +2.000, +0.000, -4.000, +4.000}},
      {{-2.000, +2.000, +2.000, -0.000, -4.000, +4.000}},
      {{-2.000, +2.000, +2.000, +2.000, -8.000, +0.000}},
      {{-2.000, +2.000, +2.000, -2.000, +0.000, +8.000}},
      {{-2.000, +2.000, -2.000, +0.000, +4.000, -4.000}},
      {{-2.000, +2.000, -2.000, -0.000, +4.000, -4.000}},
      {{-2.000, +2.000, -2.000, +2.000, +0.000, -8.000}},
      {{-2.000, +2.000, -2.000, -2.000, +8.000, +0.000}},
      {{-2.000, -2.000, +0.000, +0.000, +0.000, -0.000}},
      {{-2.000, -2.000, +0.000, -0.000, -0.000, +0.000}},
      {{-2.000, -2.000, +0.000, +2.000, +4.000, -4.000}},
      {{-2.000, -2.000, +0.000, -2.000, -4.000, +4.000}},
      {{-2.000, -2.000, -0.000, +0.000, +0.000, +0.000}},
      {{-2.000, -2.000, -0.000, -0.000, +0.000, +0.000}},
      {{-2.000, -2.000, -0.000, +2.000, +4.000, -4.000}},
      {{-2.000, -2.000, -0.000, -2.000, -4.000, +4.000}},
      {{-2.000, -2.000, +2.000, +0.000, -4.000, -4.000}},
      {{-2.000, -2.000, +2.000, -0.000, -4.000, -4.000}},
      {{-2.000, -2.000, +2.000, +2.000, +0.000, -8.000}},
      {{-2.000, -2.000, +2.000, -2.000, -8.000, +0.000}},
      {{-2.000, -2.000, -2.000, +0.000, +4.000, +4.000}},
      {{-2.000, -2.000, -2.000, -0.000, +4.000, +4.000}},
      {{-2.000, -2.000, -2.000, +2.000, +8.000, +0.000}},
      {{-2.000, -2.000, -2.000, -2.000, +0.000, +8.000}},
   }};

   for (unsigned i = 0; i < mul_data.size(); ++i)
   {
      result = T(mul_data[i][0], mul_data[i][1]) * T(mul_data[i][2], mul_data[i][3]);
      BOOST_TEST(result.real() == mul_data[i][4]);
      BOOST_TEST(result.imag() == mul_data[i][5]);
      BOOST_TEST((bool)signbit(result.real()) == signbit(mul_data[i][4]));
      BOOST_TEST((bool)signbit(result.imag()) == signbit(mul_data[i][5]));
   }

   //
   // Divide the permutations which give at least one zero:
   //
   static constexpr std::array<std::array<double, 6>, 256> div_data = 
   { {
      {{ +0.000, +0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, +0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, +0.000, +0.000, +2.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, +0.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, +0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, +0.000, -0.000, +2.000, +0.000, -0.000 }},
      {{ +0.000, +0.000, -0.000, -2.000, -0.000, +0.000 }},
      {{ +0.000, +0.000, +2.000, +0.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, +2.000, -0.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, +2.000, +2.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, +2.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, +0.000, -2.000, +0.000, +0.000, -0.000 }},
      {{ +0.000, +0.000, -2.000, -0.000, -0.000, +0.000 }},
      {{ +0.000, +0.000, -2.000, +2.000, +0.000, -0.000 }},
      {{ +0.000, +0.000, -2.000, -2.000, -0.000, +0.000 }},
      {{ +0.000, -0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, -0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, -0.000, +0.000, +2.000, +0.000, -0.000 }},
      {{ +0.000, -0.000, +0.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, -0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, -0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +0.000, -0.000, -0.000, +2.000, -0.000, +0.000 }},
      {{ +0.000, -0.000, -0.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, -0.000, +2.000, +0.000, +0.000, -0.000 }},
      {{ +0.000, -0.000, +2.000, -0.000, +0.000, +0.000 }},
      {{ +0.000, -0.000, +2.000, +2.000, +0.000, -0.000 }},
      {{ +0.000, -0.000, +2.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, -0.000, -2.000, +0.000, -0.000, +0.000 }},
      {{ +0.000, -0.000, -2.000, -0.000, +0.000, +0.000 }},
      {{ +0.000, -0.000, -2.000, +2.000, -0.000, +0.000 }},
      {{ +0.000, -0.000, -2.000, -2.000, +0.000, +0.000 }},
      {{ +0.000, +2.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ +0.000, +2.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ +0.000, +2.000, +0.000, +2.000, +1.000, +0.000 }},
      {{ +0.000, +2.000, +0.000, -2.000, -1.000, +0.000 }},
      {{ +0.000, +2.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ +0.000, +2.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ +0.000, +2.000, -0.000, +2.000, +1.000, -0.000 }},
      {{ +0.000, +2.000, -0.000, -2.000, -1.000, +0.000 }},
      {{ +0.000, +2.000, +2.000, +0.000, +0.000, +1.000 }},
      {{ +0.000, +2.000, +2.000, -0.000, +0.000, +1.000 }},
      {{ +0.000, +2.000, +2.000, +2.000, +0.500, +0.500 }},
      {{ +0.000, +2.000, +2.000, -2.000, -0.500, +0.500 }},
      {{ +0.000, +2.000, -2.000, +0.000, +0.000, -1.000 }},
      {{ +0.000, +2.000, -2.000, -0.000, -0.000, -1.000 }},
      {{ +0.000, +2.000, -2.000, +2.000, +0.500, -0.500 }},
      {{ +0.000, +2.000, -2.000, -2.000, -0.500, -0.500 }},
      {{ +0.000, -2.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ +0.000, -2.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ +0.000, -2.000, +0.000, +2.000, -1.000, -0.000 }},
      {{ +0.000, -2.000, +0.000, -2.000, +1.000, +0.000 }},
      {{ +0.000, -2.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ +0.000, -2.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ +0.000, -2.000, -0.000, +2.000, -1.000, +0.000 }},
      {{ +0.000, -2.000, -0.000, -2.000, +1.000, +0.000 }},
      {{ +0.000, -2.000, +2.000, +0.000, +0.000, -1.000 }},
      {{ +0.000, -2.000, +2.000, -0.000, +0.000, -1.000 }},
      {{ +0.000, -2.000, +2.000, +2.000, -0.500, -0.500 }},
      {{ +0.000, -2.000, +2.000, -2.000, +0.500, -0.500 }},
      {{ +0.000, -2.000, -2.000, +0.000, -0.000, +1.000 }},
      {{ +0.000, -2.000, -2.000, -0.000, +0.000, +1.000 }},
      {{ +0.000, -2.000, -2.000, +2.000, -0.500, +0.500 }},
      {{ +0.000, -2.000, -2.000, -2.000, +0.500, +0.500 }},
      {{ -0.000, +0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, +0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, +0.000, +0.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, +0.000, -2.000, -0.000, +0.000 }},
      {{ -0.000, +0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, +0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, +0.000, -0.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, -0.000, -2.000, +0.000, -0.000 }},
      {{ -0.000, +0.000, +2.000, +0.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, +2.000, -0.000, -0.000, +0.000 }},
      {{ -0.000, +0.000, +2.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, +2.000, -2.000, -0.000, +0.000 }},
      {{ -0.000, +0.000, -2.000, +0.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, -2.000, -0.000, +0.000, -0.000 }},
      {{ -0.000, +0.000, -2.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, +0.000, -2.000, -2.000, +0.000, -0.000 }},
      {{ -0.000, -0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, -0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, -0.000, +0.000, +2.000, -0.000, +0.000 }},
      {{ -0.000, -0.000, +0.000, -2.000, +0.000, -0.000 }},
      {{ -0.000, -0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, -0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -0.000, -0.000, -0.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, -0.000, -0.000, -2.000, +0.000, +0.000 }},
      {{ -0.000, -0.000, +2.000, +0.000, -0.000, +0.000 }},
      {{ -0.000, -0.000, +2.000, -0.000, +0.000, -0.000 }},
      {{ -0.000, -0.000, +2.000, +2.000, -0.000, +0.000 }},
      {{ -0.000, -0.000, +2.000, -2.000, +0.000, -0.000 }},
      {{ -0.000, -0.000, -2.000, +0.000, +0.000, +0.000 }},
      {{ -0.000, -0.000, -2.000, -0.000, +0.000, +0.000 }},
      {{ -0.000, -0.000, -2.000, +2.000, +0.000, +0.000 }},
      {{ -0.000, -0.000, -2.000, -2.000, +0.000, +0.000 }},
      {{ -0.000, +2.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ -0.000, +2.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ -0.000, +2.000, +0.000, +2.000, +1.000, +0.000 }},
      {{ -0.000, +2.000, +0.000, -2.000, -1.000, +0.000 }},
      {{ -0.000, +2.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ -0.000, +2.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ -0.000, +2.000, -0.000, +2.000, +1.000, +0.000 }},
      {{ -0.000, +2.000, -0.000, -2.000, -1.000, -0.000 }},
      {{ -0.000, +2.000, +2.000, +0.000, +0.000, +1.000 }},
      {{ -0.000, +2.000, +2.000, -0.000, -0.000, +1.000 }},
      {{ -0.000, +2.000, +2.000, +2.000, +0.500, +0.500 }},
      {{ -0.000, +2.000, +2.000, -2.000, -0.500, +0.500 }},
      {{ -0.000, +2.000, -2.000, +0.000, +0.000, -1.000 }},
      {{ -0.000, +2.000, -2.000, -0.000, +0.000, -1.000 }},
      {{ -0.000, +2.000, -2.000, +2.000, +0.500, -0.500 }},
      {{ -0.000, +2.000, -2.000, -2.000, -0.500, -0.500 }},
      {{ -0.000, -2.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ -0.000, -2.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity() }},
      {{ -0.000, -2.000, +0.000, +2.000, -1.000, +0.000 }},
      {{ -0.000, -2.000, +0.000, -2.000, +1.000, -0.000 }},
      {{ -0.000, -2.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ -0.000, -2.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity() }},
      {{ -0.000, -2.000, -0.000, +2.000, -1.000, +0.000 }},
      {{ -0.000, -2.000, -0.000, -2.000, +1.000, +0.000 }},
      {{ -0.000, -2.000, +2.000, +0.000, -0.000, -1.000 }},
      {{ -0.000, -2.000, +2.000, -0.000, +0.000, -1.000 }},
      {{ -0.000, -2.000, +2.000, +2.000, -0.500, -0.500 }},
      {{ -0.000, -2.000, +2.000, -2.000, +0.500, -0.500 }},
      {{ -0.000, -2.000, -2.000, +0.000, +0.000, +1.000 }},
      {{ -0.000, -2.000, -2.000, -0.000, +0.000, +1.000 }},
      {{ -0.000, -2.000, -2.000, +2.000, -0.500, +0.500 }},
      {{ -0.000, -2.000, -2.000, -2.000, +0.500, +0.500 }},
      {{ +2.000, +0.000, +0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, +0.000, +0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, +0.000, +0.000, +2.000, +0.000, -1.000 }},
      {{ +2.000, +0.000, +0.000, -2.000, +0.000, +1.000 }},
      {{ +2.000, +0.000, -0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, +0.000, -0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, +0.000, -0.000, +2.000, +0.000, -1.000 }},
      {{ +2.000, +0.000, -0.000, -2.000, -0.000, +1.000 }},
      {{ +2.000, +0.000, +2.000, +0.000, +1.000, +0.000 }},
      {{ +2.000, +0.000, +2.000, -0.000, +1.000, +0.000 }},
      {{ +2.000, +0.000, +2.000, +2.000, +0.500, -0.500 }},
      {{ +2.000, +0.000, +2.000, -2.000, +0.500, +0.500 }},
      {{ +2.000, +0.000, -2.000, +0.000, -1.000, -0.000 }},
      {{ +2.000, +0.000, -2.000, -0.000, -1.000, +0.000 }},
      {{ +2.000, +0.000, -2.000, +2.000, -0.500, -0.500 }},
      {{ +2.000, +0.000, -2.000, -2.000, -0.500, +0.500 }},
      {{ +2.000, -0.000, +0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, -0.000, +0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, -0.000, +0.000, +2.000, +0.000, -1.000 }},
      {{ +2.000, -0.000, +0.000, -2.000, +0.000, +1.000 }},
      {{ +2.000, -0.000, -0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, -0.000, -0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ +2.000, -0.000, -0.000, +2.000, -0.000, -1.000 }},
      {{ +2.000, -0.000, -0.000, -2.000, +0.000, +1.000 }},
      {{ +2.000, -0.000, +2.000, +0.000, +1.000, -0.000 }},
      {{ +2.000, -0.000, +2.000, -0.000, +1.000, +0.000 }},
      {{ +2.000, -0.000, +2.000, +2.000, +0.500, -0.500 }},
      {{ +2.000, -0.000, +2.000, -2.000, +0.500, +0.500 }},
      {{ +2.000, -0.000, -2.000, +0.000, -1.000, +0.000 }},
      {{ +2.000, -0.000, -2.000, -0.000, -1.000, +0.000 }},
      {{ +2.000, -0.000, -2.000, +2.000, -0.500, -0.500 }},
      {{ +2.000, -0.000, -2.000, -2.000, -0.500, +0.500 }},
      {{ +2.000, +2.000, +0.000, +0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ +2.000, +2.000, +0.000, -0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ +2.000, +2.000, +0.000, +2.000, +1.000, -1.000 }},
      {{ +2.000, +2.000, +0.000, -2.000, -1.000, +1.000 }},
      {{ +2.000, +2.000, -0.000, +0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ +2.000, +2.000, -0.000, -0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ +2.000, +2.000, -0.000, +2.000, +1.000, -1.000 }},
      {{ +2.000, +2.000, -0.000, -2.000, -1.000, +1.000 }},
      {{ +2.000, +2.000, +2.000, +0.000, +1.000, +1.000 }},
      {{ +2.000, +2.000, +2.000, -0.000, +1.000, +1.000 }},
      {{ +2.000, +2.000, +2.000, +2.000, +1.000, +0.000 }},
      {{ +2.000, +2.000, +2.000, -2.000, +0.000, +1.000 }},
      {{ +2.000, +2.000, -2.000, +0.000, -1.000, -1.000 }},
      {{ +2.000, +2.000, -2.000, -0.000, -1.000, -1.000 }},
      {{ +2.000, +2.000, -2.000, +2.000, +0.000, -1.000 }},
      {{ +2.000, +2.000, -2.000, -2.000, -1.000, +0.000 }},
      {{ +2.000, -2.000, +0.000, +0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ +2.000, -2.000, +0.000, -0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ +2.000, -2.000, +0.000, +2.000, -1.000, -1.000 }},
      {{ +2.000, -2.000, +0.000, -2.000, +1.000, +1.000 }},
      {{ +2.000, -2.000, -0.000, +0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ +2.000, -2.000, -0.000, -0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ +2.000, -2.000, -0.000, +2.000, -1.000, -1.000 }},
      {{ +2.000, -2.000, -0.000, -2.000, +1.000, +1.000 }},
      {{ +2.000, -2.000, +2.000, +0.000, +1.000, -1.000 }},
      {{ +2.000, -2.000, +2.000, -0.000, +1.000, -1.000 }},
      {{ +2.000, -2.000, +2.000, +2.000, +0.000, -1.000 }},
      {{ +2.000, -2.000, +2.000, -2.000, +1.000, +0.000 }},
      {{ +2.000, -2.000, -2.000, +0.000, -1.000, +1.000 }},
      {{ +2.000, -2.000, -2.000, -0.000, -1.000, +1.000 }},
      {{ +2.000, -2.000, -2.000, +2.000, -1.000, +0.000 }},
      {{ +2.000, -2.000, -2.000, -2.000, +0.000, +1.000 }},
      {{ -2.000, +0.000, +0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, +0.000, +0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, +0.000, +0.000, +2.000, +0.000, +1.000 }},
      {{ -2.000, +0.000, +0.000, -2.000, -0.000, -1.000 }},
      {{ -2.000, +0.000, -0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, +0.000, -0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, +0.000, -0.000, +2.000, +0.000, +1.000 }},
      {{ -2.000, +0.000, -0.000, -2.000, +0.000, -1.000 }},
      {{ -2.000, +0.000, +2.000, +0.000, -1.000, +0.000 }},
      {{ -2.000, +0.000, +2.000, -0.000, -1.000, +0.000 }},
      {{ -2.000, +0.000, +2.000, +2.000, -0.500, +0.500 }},
      {{ -2.000, +0.000, +2.000, -2.000, -0.500, -0.500 }},
      {{ -2.000, +0.000, -2.000, +0.000, +1.000, +0.000 }},
      {{ -2.000, +0.000, -2.000, -0.000, +1.000, -0.000 }},
      {{ -2.000, +0.000, -2.000, +2.000, +0.500, +0.500 }},
      {{ -2.000, +0.000, -2.000, -2.000, +0.500, -0.500 }},
      {{ -2.000, -0.000, +0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, -0.000, +0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, -0.000, +0.000, +2.000, -0.000, +1.000 }},
      {{ -2.000, -0.000, +0.000, -2.000, +0.000, -1.000 }},
      {{ -2.000, -0.000, -0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, -0.000, -0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN() }},
      {{ -2.000, -0.000, -0.000, +2.000, +0.000, +1.000 }},
      {{ -2.000, -0.000, -0.000, -2.000, +0.000, -1.000 }},
      {{ -2.000, -0.000, +2.000, +0.000, -1.000, +0.000 }},
      {{ -2.000, -0.000, +2.000, -0.000, -1.000, -0.000 }},
      {{ -2.000, -0.000, +2.000, +2.000, -0.500, +0.500 }},
      {{ -2.000, -0.000, +2.000, -2.000, -0.500, -0.500 }},
      {{ -2.000, -0.000, -2.000, +0.000, +1.000, +0.000 }},
      {{ -2.000, -0.000, -2.000, -0.000, +1.000, +0.000 }},
      {{ -2.000, -0.000, -2.000, +2.000, +0.500, +0.500 }},
      {{ -2.000, -0.000, -2.000, -2.000, +0.500, -0.500 }},
      {{ -2.000, +2.000, +0.000, +0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ -2.000, +2.000, +0.000, -0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ -2.000, +2.000, +0.000, +2.000, +1.000, +1.000 }},
      {{ -2.000, +2.000, +0.000, -2.000, -1.000, -1.000 }},
      {{ -2.000, +2.000, -0.000, +0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ -2.000, +2.000, -0.000, -0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ -2.000, +2.000, -0.000, +2.000, +1.000, +1.000 }},
      {{ -2.000, +2.000, -0.000, -2.000, -1.000, -1.000 }},
      {{ -2.000, +2.000, +2.000, +0.000, -1.000, +1.000 }},
      {{ -2.000, +2.000, +2.000, -0.000, -1.000, +1.000 }},
      {{ -2.000, +2.000, +2.000, +2.000, +0.000, +1.000 }},
      {{ -2.000, +2.000, +2.000, -2.000, -1.000, +0.000 }},
      {{ -2.000, +2.000, -2.000, +0.000, +1.000, -1.000 }},
      {{ -2.000, +2.000, -2.000, -0.000, +1.000, -1.000 }},
      {{ -2.000, +2.000, -2.000, +2.000, +1.000, +0.000 }},
      {{ -2.000, +2.000, -2.000, -2.000, +0.000, -1.000 }},
      {{ -2.000, -2.000, +0.000, +0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ -2.000, -2.000, +0.000, -0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity() }},
      {{ -2.000, -2.000, +0.000, +2.000, -1.000, +1.000 }},
      {{ -2.000, -2.000, +0.000, -2.000, +1.000, -1.000 }},
      {{ -2.000, -2.000, -0.000, +0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ -2.000, -2.000, -0.000, -0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity() }},
      {{ -2.000, -2.000, -0.000, +2.000, -1.000, +1.000 }},
      {{ -2.000, -2.000, -0.000, -2.000, +1.000, -1.000 }},
      {{ -2.000, -2.000, +2.000, +0.000, -1.000, -1.000 }},
      {{ -2.000, -2.000, +2.000, -0.000, -1.000, -1.000 }},
      {{ -2.000, -2.000, +2.000, +2.000, -1.000, +0.000 }},
      {{ -2.000, -2.000, +2.000, -2.000, +0.000, -1.000 }},
      {{ -2.000, -2.000, -2.000, +0.000, +1.000, +1.000 }},
      {{ -2.000, -2.000, -2.000, -0.000, +1.000, +1.000 }},
      {{ -2.000, -2.000, -2.000, +2.000, +0.000, +1.000 }},
      {{ -2.000, -2.000, -2.000, -2.000, +1.000, +0.000 }},   
   }};

   for (unsigned i = 0; i < div_data.size(); ++i)
   {
      if (!(isnan)(div_data[i][4]) && !(isnan)(div_data[i][5]))
      {
         result = T(div_data[i][0], div_data[i][1]) / T(div_data[i][2], div_data[i][3]);
         BOOST_TEST(result.real() == div_data[i][4]);
         BOOST_TEST(result.imag() == div_data[i][5]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(div_data[i][4]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(div_data[i][5]));
      }
   }


   //
   // Add the permutations:
   //
   static constexpr std::array<std::array<double, 6>, 256> add_data =
   { {
       {{+0.000, +0.000, +0.000, +0.000, +0.000, +0.000}},
       {{+0.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
       {{+0.000, +0.000, +0.000, +2.000, +0.000, +2.000}},
       {{+0.000, +0.000, +0.000, -2.000, +0.000, -2.000}},
       {{+0.000, +0.000, -0.000, +0.000, +0.000, +0.000}},
       {{+0.000, +0.000, -0.000, -0.000, +0.000, +0.000}},
       {{+0.000, +0.000, -0.000, +2.000, +0.000, +2.000}},
       {{+0.000, +0.000, -0.000, -2.000, +0.000, -2.000}},
       {{+0.000, +0.000, +2.000, +0.000, +2.000, +0.000}},
       {{+0.000, +0.000, +2.000, -0.000, +2.000, +0.000}},
       {{+0.000, +0.000, +2.000, +2.000, +2.000, +2.000}},
       {{+0.000, +0.000, +2.000, -2.000, +2.000, -2.000}},
       {{+0.000, +0.000, -2.000, +0.000, -2.000, +0.000}},
       {{+0.000, +0.000, -2.000, -0.000, -2.000, +0.000}},
       {{+0.000, +0.000, -2.000, +2.000, -2.000, +2.000}},
       {{+0.000, +0.000, -2.000, -2.000, -2.000, -2.000}},
       {{+0.000, -0.000, +0.000, +0.000, +0.000, +0.000}},
       {{+0.000, -0.000, +0.000, -0.000, +0.000, -0.000}},
       {{+0.000, -0.000, +0.000, +2.000, +0.000, +2.000}},
       {{+0.000, -0.000, +0.000, -2.000, +0.000, -2.000}},
       {{+0.000, -0.000, -0.000, +0.000, +0.000, +0.000}},
       {{+0.000, -0.000, -0.000, -0.000, +0.000, -0.000}},
       {{+0.000, -0.000, -0.000, +2.000, +0.000, +2.000}},
       {{+0.000, -0.000, -0.000, -2.000, +0.000, -2.000}},
       {{+0.000, -0.000, +2.000, +0.000, +2.000, +0.000}},
       {{+0.000, -0.000, +2.000, -0.000, +2.000, -0.000}},
       {{+0.000, -0.000, +2.000, +2.000, +2.000, +2.000}},
       {{+0.000, -0.000, +2.000, -2.000, +2.000, -2.000}},
       {{+0.000, -0.000, -2.000, +0.000, -2.000, +0.000}},
       {{+0.000, -0.000, -2.000, -0.000, -2.000, -0.000}},
       {{+0.000, -0.000, -2.000, +2.000, -2.000, +2.000}},
       {{+0.000, -0.000, -2.000, -2.000, -2.000, -2.000}},
       {{+0.000, +2.000, +0.000, +0.000, +0.000, +2.000}},
       {{+0.000, +2.000, +0.000, -0.000, +0.000, +2.000}},
       {{+0.000, +2.000, +0.000, +2.000, +0.000, +4.000}},
       {{+0.000, +2.000, +0.000, -2.000, +0.000, +0.000}},
       {{+0.000, +2.000, -0.000, +0.000, +0.000, +2.000}},
       {{+0.000, +2.000, -0.000, -0.000, +0.000, +2.000}},
       {{+0.000, +2.000, -0.000, +2.000, +0.000, +4.000}},
       {{+0.000, +2.000, -0.000, -2.000, +0.000, +0.000}},
       {{+0.000, +2.000, +2.000, +0.000, +2.000, +2.000}},
       {{+0.000, +2.000, +2.000, -0.000, +2.000, +2.000}},
       {{+0.000, +2.000, +2.000, +2.000, +2.000, +4.000}},
       {{+0.000, +2.000, +2.000, -2.000, +2.000, +0.000}},
       {{+0.000, +2.000, -2.000, +0.000, -2.000, +2.000}},
       {{+0.000, +2.000, -2.000, -0.000, -2.000, +2.000}},
       {{+0.000, +2.000, -2.000, +2.000, -2.000, +4.000}},
       {{+0.000, +2.000, -2.000, -2.000, -2.000, +0.000}},
       {{+0.000, -2.000, +0.000, +0.000, +0.000, -2.000}},
       {{+0.000, -2.000, +0.000, -0.000, +0.000, -2.000}},
       {{+0.000, -2.000, +0.000, +2.000, +0.000, +0.000}},
       {{+0.000, -2.000, +0.000, -2.000, +0.000, -4.000}},
       {{+0.000, -2.000, -0.000, +0.000, +0.000, -2.000}},
       {{+0.000, -2.000, -0.000, -0.000, +0.000, -2.000}},
       {{+0.000, -2.000, -0.000, +2.000, +0.000, +0.000}},
       {{+0.000, -2.000, -0.000, -2.000, +0.000, -4.000}},
       {{+0.000, -2.000, +2.000, +0.000, +2.000, -2.000}},
       {{+0.000, -2.000, +2.000, -0.000, +2.000, -2.000}},
       {{+0.000, -2.000, +2.000, +2.000, +2.000, +0.000}},
       {{+0.000, -2.000, +2.000, -2.000, +2.000, -4.000}},
       {{+0.000, -2.000, -2.000, +0.000, -2.000, -2.000}},
       {{+0.000, -2.000, -2.000, -0.000, -2.000, -2.000}},
       {{+0.000, -2.000, -2.000, +2.000, -2.000, +0.000}},
       {{+0.000, -2.000, -2.000, -2.000, -2.000, -4.000}},
       {{-0.000, +0.000, +0.000, +0.000, +0.000, +0.000}},
       {{-0.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
       {{-0.000, +0.000, +0.000, +2.000, +0.000, +2.000}},
       {{-0.000, +0.000, +0.000, -2.000, +0.000, -2.000}},
       {{-0.000, +0.000, -0.000, +0.000, -0.000, +0.000}},
       {{-0.000, +0.000, -0.000, -0.000, -0.000, +0.000}},
       {{-0.000, +0.000, -0.000, +2.000, -0.000, +2.000}},
       {{-0.000, +0.000, -0.000, -2.000, -0.000, -2.000}},
       {{-0.000, +0.000, +2.000, +0.000, +2.000, +0.000}},
       {{-0.000, +0.000, +2.000, -0.000, +2.000, +0.000}},
       {{-0.000, +0.000, +2.000, +2.000, +2.000, +2.000}},
       {{-0.000, +0.000, +2.000, -2.000, +2.000, -2.000}},
       {{-0.000, +0.000, -2.000, +0.000, -2.000, +0.000}},
       {{-0.000, +0.000, -2.000, -0.000, -2.000, +0.000}},
       {{-0.000, +0.000, -2.000, +2.000, -2.000, +2.000}},
       {{-0.000, +0.000, -2.000, -2.000, -2.000, -2.000}},
       {{-0.000, -0.000, +0.000, +0.000, +0.000, +0.000}},
       {{-0.000, -0.000, +0.000, -0.000, +0.000, -0.000}},
       {{-0.000, -0.000, +0.000, +2.000, +0.000, +2.000}},
       {{-0.000, -0.000, +0.000, -2.000, +0.000, -2.000}},
       {{-0.000, -0.000, -0.000, +0.000, -0.000, +0.000}},
       {{-0.000, -0.000, -0.000, -0.000, -0.000, -0.000}},
       {{-0.000, -0.000, -0.000, +2.000, -0.000, +2.000}},
       {{-0.000, -0.000, -0.000, -2.000, -0.000, -2.000}},
       {{-0.000, -0.000, +2.000, +0.000, +2.000, +0.000}},
       {{-0.000, -0.000, +2.000, -0.000, +2.000, -0.000}},
       {{-0.000, -0.000, +2.000, +2.000, +2.000, +2.000}},
       {{-0.000, -0.000, +2.000, -2.000, +2.000, -2.000}},
       {{-0.000, -0.000, -2.000, +0.000, -2.000, +0.000}},
       {{-0.000, -0.000, -2.000, -0.000, -2.000, -0.000}},
       {{-0.000, -0.000, -2.000, +2.000, -2.000, +2.000}},
       {{-0.000, -0.000, -2.000, -2.000, -2.000, -2.000}},
       {{-0.000, +2.000, +0.000, +0.000, +0.000, +2.000}},
       {{-0.000, +2.000, +0.000, -0.000, +0.000, +2.000}},
       {{-0.000, +2.000, +0.000, +2.000, +0.000, +4.000}},
       {{-0.000, +2.000, +0.000, -2.000, +0.000, +0.000}},
       {{-0.000, +2.000, -0.000, +0.000, -0.000, +2.000}},
       {{-0.000, +2.000, -0.000, -0.000, -0.000, +2.000}},
       {{-0.000, +2.000, -0.000, +2.000, -0.000, +4.000}},
       {{-0.000, +2.000, -0.000, -2.000, -0.000, +0.000}},
       {{-0.000, +2.000, +2.000, +0.000, +2.000, +2.000}},
       {{-0.000, +2.000, +2.000, -0.000, +2.000, +2.000}},
       {{-0.000, +2.000, +2.000, +2.000, +2.000, +4.000}},
       {{-0.000, +2.000, +2.000, -2.000, +2.000, +0.000}},
       {{-0.000, +2.000, -2.000, +0.000, -2.000, +2.000}},
       {{-0.000, +2.000, -2.000, -0.000, -2.000, +2.000}},
       {{-0.000, +2.000, -2.000, +2.000, -2.000, +4.000}},
       {{-0.000, +2.000, -2.000, -2.000, -2.000, +0.000}},
       {{-0.000, -2.000, +0.000, +0.000, +0.000, -2.000}},
       {{-0.000, -2.000, +0.000, -0.000, +0.000, -2.000}},
       {{-0.000, -2.000, +0.000, +2.000, +0.000, +0.000}},
       {{-0.000, -2.000, +0.000, -2.000, +0.000, -4.000}},
       {{-0.000, -2.000, -0.000, +0.000, -0.000, -2.000}},
       {{-0.000, -2.000, -0.000, -0.000, -0.000, -2.000}},
       {{-0.000, -2.000, -0.000, +2.000, -0.000, +0.000}},
       {{-0.000, -2.000, -0.000, -2.000, -0.000, -4.000}},
       {{-0.000, -2.000, +2.000, +0.000, +2.000, -2.000}},
       {{-0.000, -2.000, +2.000, -0.000, +2.000, -2.000}},
       {{-0.000, -2.000, +2.000, +2.000, +2.000, +0.000}},
       {{-0.000, -2.000, +2.000, -2.000, +2.000, -4.000}},
       {{-0.000, -2.000, -2.000, +0.000, -2.000, -2.000}},
       {{-0.000, -2.000, -2.000, -0.000, -2.000, -2.000}},
       {{-0.000, -2.000, -2.000, +2.000, -2.000, +0.000}},
       {{-0.000, -2.000, -2.000, -2.000, -2.000, -4.000}},
       {{+2.000, +0.000, +0.000, +0.000, +2.000, +0.000}},
       {{+2.000, +0.000, +0.000, -0.000, +2.000, +0.000}},
       {{+2.000, +0.000, +0.000, +2.000, +2.000, +2.000}},
       {{+2.000, +0.000, +0.000, -2.000, +2.000, -2.000}},
       {{+2.000, +0.000, -0.000, +0.000, +2.000, +0.000}},
       {{+2.000, +0.000, -0.000, -0.000, +2.000, +0.000}},
       {{+2.000, +0.000, -0.000, +2.000, +2.000, +2.000}},
       {{+2.000, +0.000, -0.000, -2.000, +2.000, -2.000}},
       {{+2.000, +0.000, +2.000, +0.000, +4.000, +0.000}},
       {{+2.000, +0.000, +2.000, -0.000, +4.000, +0.000}},
       {{+2.000, +0.000, +2.000, +2.000, +4.000, +2.000}},
       {{+2.000, +0.000, +2.000, -2.000, +4.000, -2.000}},
       {{+2.000, +0.000, -2.000, +0.000, +0.000, +0.000}},
       {{+2.000, +0.000, -2.000, -0.000, +0.000, +0.000}},
       {{+2.000, +0.000, -2.000, +2.000, +0.000, +2.000}},
       {{+2.000, +0.000, -2.000, -2.000, +0.000, -2.000}},
       {{+2.000, -0.000, +0.000, +0.000, +2.000, +0.000}},
       {{+2.000, -0.000, +0.000, -0.000, +2.000, -0.000}},
       {{+2.000, -0.000, +0.000, +2.000, +2.000, +2.000}},
       {{+2.000, -0.000, +0.000, -2.000, +2.000, -2.000}},
       {{+2.000, -0.000, -0.000, +0.000, +2.000, +0.000}},
       {{+2.000, -0.000, -0.000, -0.000, +2.000, -0.000}},
       {{+2.000, -0.000, -0.000, +2.000, +2.000, +2.000}},
       {{+2.000, -0.000, -0.000, -2.000, +2.000, -2.000}},
       {{+2.000, -0.000, +2.000, +0.000, +4.000, +0.000}},
       {{+2.000, -0.000, +2.000, -0.000, +4.000, -0.000}},
       {{+2.000, -0.000, +2.000, +2.000, +4.000, +2.000}},
       {{+2.000, -0.000, +2.000, -2.000, +4.000, -2.000}},
       {{+2.000, -0.000, -2.000, +0.000, +0.000, +0.000}},
       {{+2.000, -0.000, -2.000, -0.000, +0.000, -0.000}},
       {{+2.000, -0.000, -2.000, +2.000, +0.000, +2.000}},
       {{+2.000, -0.000, -2.000, -2.000, +0.000, -2.000}},
       {{+2.000, +2.000, +0.000, +0.000, +2.000, +2.000}},
       {{+2.000, +2.000, +0.000, -0.000, +2.000, +2.000}},
       {{+2.000, +2.000, +0.000, +2.000, +2.000, +4.000}},
       {{+2.000, +2.000, +0.000, -2.000, +2.000, +0.000}},
       {{+2.000, +2.000, -0.000, +0.000, +2.000, +2.000}},
       {{+2.000, +2.000, -0.000, -0.000, +2.000, +2.000}},
       {{+2.000, +2.000, -0.000, +2.000, +2.000, +4.000}},
       {{+2.000, +2.000, -0.000, -2.000, +2.000, +0.000}},
       {{+2.000, +2.000, +2.000, +0.000, +4.000, +2.000}},
       {{+2.000, +2.000, +2.000, -0.000, +4.000, +2.000}},
       {{+2.000, +2.000, +2.000, +2.000, +4.000, +4.000}},
       {{+2.000, +2.000, +2.000, -2.000, +4.000, +0.000}},
       {{+2.000, +2.000, -2.000, +0.000, +0.000, +2.000}},
       {{+2.000, +2.000, -2.000, -0.000, +0.000, +2.000}},
       {{+2.000, +2.000, -2.000, +2.000, +0.000, +4.000}},
       {{+2.000, +2.000, -2.000, -2.000, +0.000, +0.000}},
       {{+2.000, -2.000, +0.000, +0.000, +2.000, -2.000}},
       {{+2.000, -2.000, +0.000, -0.000, +2.000, -2.000}},
       {{+2.000, -2.000, +0.000, +2.000, +2.000, +0.000}},
       {{+2.000, -2.000, +0.000, -2.000, +2.000, -4.000}},
       {{+2.000, -2.000, -0.000, +0.000, +2.000, -2.000}},
       {{+2.000, -2.000, -0.000, -0.000, +2.000, -2.000}},
       {{+2.000, -2.000, -0.000, +2.000, +2.000, +0.000}},
       {{+2.000, -2.000, -0.000, -2.000, +2.000, -4.000}},
       {{+2.000, -2.000, +2.000, +0.000, +4.000, -2.000}},
       {{+2.000, -2.000, +2.000, -0.000, +4.000, -2.000}},
       {{+2.000, -2.000, +2.000, +2.000, +4.000, +0.000}},
       {{+2.000, -2.000, +2.000, -2.000, +4.000, -4.000}},
       {{+2.000, -2.000, -2.000, +0.000, +0.000, -2.000}},
       {{+2.000, -2.000, -2.000, -0.000, +0.000, -2.000}},
       {{+2.000, -2.000, -2.000, +2.000, +0.000, +0.000}},
       {{+2.000, -2.000, -2.000, -2.000, +0.000, -4.000}},
       {{-2.000, +0.000, +0.000, +0.000, -2.000, +0.000}},
       {{-2.000, +0.000, +0.000, -0.000, -2.000, +0.000}},
       {{-2.000, +0.000, +0.000, +2.000, -2.000, +2.000}},
       {{-2.000, +0.000, +0.000, -2.000, -2.000, -2.000}},
       {{-2.000, +0.000, -0.000, +0.000, -2.000, +0.000}},
       {{-2.000, +0.000, -0.000, -0.000, -2.000, +0.000}},
       {{-2.000, +0.000, -0.000, +2.000, -2.000, +2.000}},
       {{-2.000, +0.000, -0.000, -2.000, -2.000, -2.000}},
       {{-2.000, +0.000, +2.000, +0.000, +0.000, +0.000}},
       {{-2.000, +0.000, +2.000, -0.000, +0.000, +0.000}},
       {{-2.000, +0.000, +2.000, +2.000, +0.000, +2.000}},
       {{-2.000, +0.000, +2.000, -2.000, +0.000, -2.000}},
       {{-2.000, +0.000, -2.000, +0.000, -4.000, +0.000}},
       {{-2.000, +0.000, -2.000, -0.000, -4.000, +0.000}},
       {{-2.000, +0.000, -2.000, +2.000, -4.000, +2.000}},
       {{-2.000, +0.000, -2.000, -2.000, -4.000, -2.000}},
       {{-2.000, -0.000, +0.000, +0.000, -2.000, +0.000}},
       {{-2.000, -0.000, +0.000, -0.000, -2.000, -0.000}},
       {{-2.000, -0.000, +0.000, +2.000, -2.000, +2.000}},
       {{-2.000, -0.000, +0.000, -2.000, -2.000, -2.000}},
       {{-2.000, -0.000, -0.000, +0.000, -2.000, +0.000}},
       {{-2.000, -0.000, -0.000, -0.000, -2.000, -0.000}},
       {{-2.000, -0.000, -0.000, +2.000, -2.000, +2.000}},
       {{-2.000, -0.000, -0.000, -2.000, -2.000, -2.000}},
       {{-2.000, -0.000, +2.000, +0.000, +0.000, +0.000}},
       {{-2.000, -0.000, +2.000, -0.000, +0.000, -0.000}},
       {{-2.000, -0.000, +2.000, +2.000, +0.000, +2.000}},
       {{-2.000, -0.000, +2.000, -2.000, +0.000, -2.000}},
       {{-2.000, -0.000, -2.000, +0.000, -4.000, +0.000}},
       {{-2.000, -0.000, -2.000, -0.000, -4.000, -0.000}},
       {{-2.000, -0.000, -2.000, +2.000, -4.000, +2.000}},
       {{-2.000, -0.000, -2.000, -2.000, -4.000, -2.000}},
       {{-2.000, +2.000, +0.000, +0.000, -2.000, +2.000}},
       {{-2.000, +2.000, +0.000, -0.000, -2.000, +2.000}},
       {{-2.000, +2.000, +0.000, +2.000, -2.000, +4.000}},
       {{-2.000, +2.000, +0.000, -2.000, -2.000, +0.000}},
       {{-2.000, +2.000, -0.000, +0.000, -2.000, +2.000}},
       {{-2.000, +2.000, -0.000, -0.000, -2.000, +2.000}},
       {{-2.000, +2.000, -0.000, +2.000, -2.000, +4.000}},
       {{-2.000, +2.000, -0.000, -2.000, -2.000, +0.000}},
       {{-2.000, +2.000, +2.000, +0.000, +0.000, +2.000}},
       {{-2.000, +2.000, +2.000, -0.000, +0.000, +2.000}},
       {{-2.000, +2.000, +2.000, +2.000, +0.000, +4.000}},
       {{-2.000, +2.000, +2.000, -2.000, +0.000, +0.000}},
       {{-2.000, +2.000, -2.000, +0.000, -4.000, +2.000}},
       {{-2.000, +2.000, -2.000, -0.000, -4.000, +2.000}},
       {{-2.000, +2.000, -2.000, +2.000, -4.000, +4.000}},
       {{-2.000, +2.000, -2.000, -2.000, -4.000, +0.000}},
       {{-2.000, -2.000, +0.000, +0.000, -2.000, -2.000}},
       {{-2.000, -2.000, +0.000, -0.000, -2.000, -2.000}},
       {{-2.000, -2.000, +0.000, +2.000, -2.000, +0.000}},
       {{-2.000, -2.000, +0.000, -2.000, -2.000, -4.000}},
       {{-2.000, -2.000, -0.000, +0.000, -2.000, -2.000}},
       {{-2.000, -2.000, -0.000, -0.000, -2.000, -2.000}},
       {{-2.000, -2.000, -0.000, +2.000, -2.000, +0.000}},
       {{-2.000, -2.000, -0.000, -2.000, -2.000, -4.000}},
       {{-2.000, -2.000, +2.000, +0.000, +0.000, -2.000}},
       {{-2.000, -2.000, +2.000, -0.000, +0.000, -2.000}},
       {{-2.000, -2.000, +2.000, +2.000, +0.000, +0.000}},
       {{-2.000, -2.000, +2.000, -2.000, +0.000, -4.000}},
       {{-2.000, -2.000, -2.000, +0.000, -4.000, -2.000}},
       {{-2.000, -2.000, -2.000, -0.000, -4.000, -2.000}},
       {{-2.000, -2.000, -2.000, +2.000, -4.000, +0.000}},
       {{-2.000, -2.000, -2.000, -2.000, -4.000, -4.000}},
    }};
   for (unsigned i = 0; i < add_data.size(); ++i)
   {
      if (!(isnan)(add_data[i][4]) && !(isnan)(add_data[i][5]))
      {
         result = T(add_data[i][0], add_data[i][1]) + T(add_data[i][2], add_data[i][3]);
         BOOST_TEST(result.real() == add_data[i][4]);
         BOOST_TEST(result.imag() == add_data[i][5]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(add_data[i][4]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(add_data[i][5]));
      }
   }

   //
   // Subtract the permutations:
   //
   static constexpr std::array<std::array<double, 6>, 256> sub_data =
   { {
       {{+0.000, +0.000, +0.000, +0.000, +0.000, +0.000}},
       {{+0.000, +0.000, +0.000, -0.000, +0.000, +0.000}},
       {{+0.000, +0.000, +0.000, +2.000, +0.000, -2.000}},
       {{+0.000, +0.000, +0.000, -2.000, +0.000, +2.000}},
       {{+0.000, +0.000, -0.000, +0.000, +0.000, +0.000}},
       {{+0.000, +0.000, -0.000, -0.000, +0.000, +0.000}},
       {{+0.000, +0.000, -0.000, +2.000, +0.000, -2.000}},
       {{+0.000, +0.000, -0.000, -2.000, +0.000, +2.000}},
       {{+0.000, +0.000, +2.000, +0.000, -2.000, +0.000}},
       {{+0.000, +0.000, +2.000, -0.000, -2.000, +0.000}},
       {{+0.000, +0.000, +2.000, +2.000, -2.000, -2.000}},
       {{+0.000, +0.000, +2.000, -2.000, -2.000, +2.000}},
       {{+0.000, +0.000, -2.000, +0.000, +2.000, +0.000}},
       {{+0.000, +0.000, -2.000, -0.000, +2.000, +0.000}},
       {{+0.000, +0.000, -2.000, +2.000, +2.000, -2.000}},
       {{+0.000, +0.000, -2.000, -2.000, +2.000, +2.000}},
       {{+0.000, -0.000, +0.000, +0.000, +0.000, -0.000}},
       {{+0.000, -0.000, +0.000, -0.000, +0.000, +0.000}},
       {{+0.000, -0.000, +0.000, +2.000, +0.000, -2.000}},
       {{+0.000, -0.000, +0.000, -2.000, +0.000, +2.000}},
       {{+0.000, -0.000, -0.000, +0.000, +0.000, -0.000}},
       {{+0.000, -0.000, -0.000, -0.000, +0.000, +0.000}},
       {{+0.000, -0.000, -0.000, +2.000, +0.000, -2.000}},
       {{+0.000, -0.000, -0.000, -2.000, +0.000, +2.000}},
       {{+0.000, -0.000, +2.000, +0.000, -2.000, -0.000}},
       {{+0.000, -0.000, +2.000, -0.000, -2.000, +0.000}},
       {{+0.000, -0.000, +2.000, +2.000, -2.000, -2.000}},
       {{+0.000, -0.000, +2.000, -2.000, -2.000, +2.000}},
       {{+0.000, -0.000, -2.000, +0.000, +2.000, -0.000}},
       {{+0.000, -0.000, -2.000, -0.000, +2.000, +0.000}},
       {{+0.000, -0.000, -2.000, +2.000, +2.000, -2.000}},
       {{+0.000, -0.000, -2.000, -2.000, +2.000, +2.000}},
       {{+0.000, +2.000, +0.000, +0.000, +0.000, +2.000}},
       {{+0.000, +2.000, +0.000, -0.000, +0.000, +2.000}},
       {{+0.000, +2.000, +0.000, +2.000, +0.000, +0.000}},
       {{+0.000, +2.000, +0.000, -2.000, +0.000, +4.000}},
       {{+0.000, +2.000, -0.000, +0.000, +0.000, +2.000}},
       {{+0.000, +2.000, -0.000, -0.000, +0.000, +2.000}},
       {{+0.000, +2.000, -0.000, +2.000, +0.000, +0.000}},
       {{+0.000, +2.000, -0.000, -2.000, +0.000, +4.000}},
       {{+0.000, +2.000, +2.000, +0.000, -2.000, +2.000}},
       {{+0.000, +2.000, +2.000, -0.000, -2.000, +2.000}},
       {{+0.000, +2.000, +2.000, +2.000, -2.000, +0.000}},
       {{+0.000, +2.000, +2.000, -2.000, -2.000, +4.000}},
       {{+0.000, +2.000, -2.000, +0.000, +2.000, +2.000}},
       {{+0.000, +2.000, -2.000, -0.000, +2.000, +2.000}},
       {{+0.000, +2.000, -2.000, +2.000, +2.000, +0.000}},
       {{+0.000, +2.000, -2.000, -2.000, +2.000, +4.000}},
       {{+0.000, -2.000, +0.000, +0.000, +0.000, -2.000}},
       {{+0.000, -2.000, +0.000, -0.000, +0.000, -2.000}},
       {{+0.000, -2.000, +0.000, +2.000, +0.000, -4.000}},
       {{+0.000, -2.000, +0.000, -2.000, +0.000, +0.000}},
       {{+0.000, -2.000, -0.000, +0.000, +0.000, -2.000}},
       {{+0.000, -2.000, -0.000, -0.000, +0.000, -2.000}},
       {{+0.000, -2.000, -0.000, +2.000, +0.000, -4.000}},
       {{+0.000, -2.000, -0.000, -2.000, +0.000, +0.000}},
       {{+0.000, -2.000, +2.000, +0.000, -2.000, -2.000}},
       {{+0.000, -2.000, +2.000, -0.000, -2.000, -2.000}},
       {{+0.000, -2.000, +2.000, +2.000, -2.000, -4.000}},
       {{+0.000, -2.000, +2.000, -2.000, -2.000, +0.000}},
       {{+0.000, -2.000, -2.000, +0.000, +2.000, -2.000}},
       {{+0.000, -2.000, -2.000, -0.000, +2.000, -2.000}},
       {{+0.000, -2.000, -2.000, +2.000, +2.000, -4.000}},
       {{+0.000, -2.000, -2.000, -2.000, +2.000, +0.000}},
       {{-0.000, +0.000, +0.000, +0.000, -0.000, +0.000}},
       {{-0.000, +0.000, +0.000, -0.000, -0.000, +0.000}},
       {{-0.000, +0.000, +0.000, +2.000, -0.000, -2.000}},
       {{-0.000, +0.000, +0.000, -2.000, -0.000, +2.000}},
       {{-0.000, +0.000, -0.000, +0.000, +0.000, +0.000}},
       {{-0.000, +0.000, -0.000, -0.000, +0.000, +0.000}},
       {{-0.000, +0.000, -0.000, +2.000, +0.000, -2.000}},
       {{-0.000, +0.000, -0.000, -2.000, +0.000, +2.000}},
       {{-0.000, +0.000, +2.000, +0.000, -2.000, +0.000}},
       {{-0.000, +0.000, +2.000, -0.000, -2.000, +0.000}},
       {{-0.000, +0.000, +2.000, +2.000, -2.000, -2.000}},
       {{-0.000, +0.000, +2.000, -2.000, -2.000, +2.000}},
       {{-0.000, +0.000, -2.000, +0.000, +2.000, +0.000}},
       {{-0.000, +0.000, -2.000, -0.000, +2.000, +0.000}},
       {{-0.000, +0.000, -2.000, +2.000, +2.000, -2.000}},
       {{-0.000, +0.000, -2.000, -2.000, +2.000, +2.000}},
       {{-0.000, -0.000, +0.000, +0.000, -0.000, -0.000}},
       {{-0.000, -0.000, +0.000, -0.000, -0.000, +0.000}},
       {{-0.000, -0.000, +0.000, +2.000, -0.000, -2.000}},
       {{-0.000, -0.000, +0.000, -2.000, -0.000, +2.000}},
       {{-0.000, -0.000, -0.000, +0.000, +0.000, -0.000}},
       {{-0.000, -0.000, -0.000, -0.000, +0.000, +0.000}},
       {{-0.000, -0.000, -0.000, +2.000, +0.000, -2.000}},
       {{-0.000, -0.000, -0.000, -2.000, +0.000, +2.000}},
       {{-0.000, -0.000, +2.000, +0.000, -2.000, -0.000}},
       {{-0.000, -0.000, +2.000, -0.000, -2.000, +0.000}},
       {{-0.000, -0.000, +2.000, +2.000, -2.000, -2.000}},
       {{-0.000, -0.000, +2.000, -2.000, -2.000, +2.000}},
       {{-0.000, -0.000, -2.000, +0.000, +2.000, -0.000}},
       {{-0.000, -0.000, -2.000, -0.000, +2.000, +0.000}},
       {{-0.000, -0.000, -2.000, +2.000, +2.000, -2.000}},
       {{-0.000, -0.000, -2.000, -2.000, +2.000, +2.000}},
       {{-0.000, +2.000, +0.000, +0.000, -0.000, +2.000}},
       {{-0.000, +2.000, +0.000, -0.000, -0.000, +2.000}},
       {{-0.000, +2.000, +0.000, +2.000, -0.000, +0.000}},
       {{-0.000, +2.000, +0.000, -2.000, -0.000, +4.000}},
       {{-0.000, +2.000, -0.000, +0.000, +0.000, +2.000}},
       {{-0.000, +2.000, -0.000, -0.000, +0.000, +2.000}},
       {{-0.000, +2.000, -0.000, +2.000, +0.000, +0.000}},
       {{-0.000, +2.000, -0.000, -2.000, +0.000, +4.000}},
       {{-0.000, +2.000, +2.000, +0.000, -2.000, +2.000}},
       {{-0.000, +2.000, +2.000, -0.000, -2.000, +2.000}},
       {{-0.000, +2.000, +2.000, +2.000, -2.000, +0.000}},
       {{-0.000, +2.000, +2.000, -2.000, -2.000, +4.000}},
       {{-0.000, +2.000, -2.000, +0.000, +2.000, +2.000}},
       {{-0.000, +2.000, -2.000, -0.000, +2.000, +2.000}},
       {{-0.000, +2.000, -2.000, +2.000, +2.000, +0.000}},
       {{-0.000, +2.000, -2.000, -2.000, +2.000, +4.000}},
       {{-0.000, -2.000, +0.000, +0.000, -0.000, -2.000}},
       {{-0.000, -2.000, +0.000, -0.000, -0.000, -2.000}},
       {{-0.000, -2.000, +0.000, +2.000, -0.000, -4.000}},
       {{-0.000, -2.000, +0.000, -2.000, -0.000, +0.000}},
       {{-0.000, -2.000, -0.000, +0.000, +0.000, -2.000}},
       {{-0.000, -2.000, -0.000, -0.000, +0.000, -2.000}},
       {{-0.000, -2.000, -0.000, +2.000, +0.000, -4.000}},
       {{-0.000, -2.000, -0.000, -2.000, +0.000, +0.000}},
       {{-0.000, -2.000, +2.000, +0.000, -2.000, -2.000}},
       {{-0.000, -2.000, +2.000, -0.000, -2.000, -2.000}},
       {{-0.000, -2.000, +2.000, +2.000, -2.000, -4.000}},
       {{-0.000, -2.000, +2.000, -2.000, -2.000, +0.000}},
       {{-0.000, -2.000, -2.000, +0.000, +2.000, -2.000}},
       {{-0.000, -2.000, -2.000, -0.000, +2.000, -2.000}},
       {{-0.000, -2.000, -2.000, +2.000, +2.000, -4.000}},
       {{-0.000, -2.000, -2.000, -2.000, +2.000, +0.000}},
       {{+2.000, +0.000, +0.000, +0.000, +2.000, +0.000}},
       {{+2.000, +0.000, +0.000, -0.000, +2.000, +0.000}},
       {{+2.000, +0.000, +0.000, +2.000, +2.000, -2.000}},
       {{+2.000, +0.000, +0.000, -2.000, +2.000, +2.000}},
       {{+2.000, +0.000, -0.000, +0.000, +2.000, +0.000}},
       {{+2.000, +0.000, -0.000, -0.000, +2.000, +0.000}},
       {{+2.000, +0.000, -0.000, +2.000, +2.000, -2.000}},
       {{+2.000, +0.000, -0.000, -2.000, +2.000, +2.000}},
       {{+2.000, +0.000, +2.000, +0.000, +0.000, +0.000}},
       {{+2.000, +0.000, +2.000, -0.000, +0.000, +0.000}},
       {{+2.000, +0.000, +2.000, +2.000, +0.000, -2.000}},
       {{+2.000, +0.000, +2.000, -2.000, +0.000, +2.000}},
       {{+2.000, +0.000, -2.000, +0.000, +4.000, +0.000}},
       {{+2.000, +0.000, -2.000, -0.000, +4.000, +0.000}},
       {{+2.000, +0.000, -2.000, +2.000, +4.000, -2.000}},
       {{+2.000, +0.000, -2.000, -2.000, +4.000, +2.000}},
       {{+2.000, -0.000, +0.000, +0.000, +2.000, -0.000}},
       {{+2.000, -0.000, +0.000, -0.000, +2.000, +0.000}},
       {{+2.000, -0.000, +0.000, +2.000, +2.000, -2.000}},
       {{+2.000, -0.000, +0.000, -2.000, +2.000, +2.000}},
       {{+2.000, -0.000, -0.000, +0.000, +2.000, -0.000}},
       {{+2.000, -0.000, -0.000, -0.000, +2.000, +0.000}},
       {{+2.000, -0.000, -0.000, +2.000, +2.000, -2.000}},
       {{+2.000, -0.000, -0.000, -2.000, +2.000, +2.000}},
       {{+2.000, -0.000, +2.000, +0.000, +0.000, -0.000}},
       {{+2.000, -0.000, +2.000, -0.000, +0.000, +0.000}},
       {{+2.000, -0.000, +2.000, +2.000, +0.000, -2.000}},
       {{+2.000, -0.000, +2.000, -2.000, +0.000, +2.000}},
       {{+2.000, -0.000, -2.000, +0.000, +4.000, -0.000}},
       {{+2.000, -0.000, -2.000, -0.000, +4.000, +0.000}},
       {{+2.000, -0.000, -2.000, +2.000, +4.000, -2.000}},
       {{+2.000, -0.000, -2.000, -2.000, +4.000, +2.000}},
       {{+2.000, +2.000, +0.000, +0.000, +2.000, +2.000}},
       {{+2.000, +2.000, +0.000, -0.000, +2.000, +2.000}},
       {{+2.000, +2.000, +0.000, +2.000, +2.000, +0.000}},
       {{+2.000, +2.000, +0.000, -2.000, +2.000, +4.000}},
       {{+2.000, +2.000, -0.000, +0.000, +2.000, +2.000}},
       {{+2.000, +2.000, -0.000, -0.000, +2.000, +2.000}},
       {{+2.000, +2.000, -0.000, +2.000, +2.000, +0.000}},
       {{+2.000, +2.000, -0.000, -2.000, +2.000, +4.000}},
       {{+2.000, +2.000, +2.000, +0.000, +0.000, +2.000}},
       {{+2.000, +2.000, +2.000, -0.000, +0.000, +2.000}},
       {{+2.000, +2.000, +2.000, +2.000, +0.000, +0.000}},
       {{+2.000, +2.000, +2.000, -2.000, +0.000, +4.000}},
       {{+2.000, +2.000, -2.000, +0.000, +4.000, +2.000}},
       {{+2.000, +2.000, -2.000, -0.000, +4.000, +2.000}},
       {{+2.000, +2.000, -2.000, +2.000, +4.000, +0.000}},
       {{+2.000, +2.000, -2.000, -2.000, +4.000, +4.000}},
       {{+2.000, -2.000, +0.000, +0.000, +2.000, -2.000}},
       {{+2.000, -2.000, +0.000, -0.000, +2.000, -2.000}},
       {{+2.000, -2.000, +0.000, +2.000, +2.000, -4.000}},
       {{+2.000, -2.000, +0.000, -2.000, +2.000, +0.000}},
       {{+2.000, -2.000, -0.000, +0.000, +2.000, -2.000}},
       {{+2.000, -2.000, -0.000, -0.000, +2.000, -2.000}},
       {{+2.000, -2.000, -0.000, +2.000, +2.000, -4.000}},
       {{+2.000, -2.000, -0.000, -2.000, +2.000, +0.000}},
       {{+2.000, -2.000, +2.000, +0.000, +0.000, -2.000}},
       {{+2.000, -2.000, +2.000, -0.000, +0.000, -2.000}},
       {{+2.000, -2.000, +2.000, +2.000, +0.000, -4.000}},
       {{+2.000, -2.000, +2.000, -2.000, +0.000, +0.000}},
       {{+2.000, -2.000, -2.000, +0.000, +4.000, -2.000}},
       {{+2.000, -2.000, -2.000, -0.000, +4.000, -2.000}},
       {{+2.000, -2.000, -2.000, +2.000, +4.000, -4.000}},
       {{+2.000, -2.000, -2.000, -2.000, +4.000, +0.000}},
       {{-2.000, +0.000, +0.000, +0.000, -2.000, +0.000}},
       {{-2.000, +0.000, +0.000, -0.000, -2.000, +0.000}},
       {{-2.000, +0.000, +0.000, +2.000, -2.000, -2.000}},
       {{-2.000, +0.000, +0.000, -2.000, -2.000, +2.000}},
       {{-2.000, +0.000, -0.000, +0.000, -2.000, +0.000}},
       {{-2.000, +0.000, -0.000, -0.000, -2.000, +0.000}},
       {{-2.000, +0.000, -0.000, +2.000, -2.000, -2.000}},
       {{-2.000, +0.000, -0.000, -2.000, -2.000, +2.000}},
       {{-2.000, +0.000, +2.000, +0.000, -4.000, +0.000}},
       {{-2.000, +0.000, +2.000, -0.000, -4.000, +0.000}},
       {{-2.000, +0.000, +2.000, +2.000, -4.000, -2.000}},
       {{-2.000, +0.000, +2.000, -2.000, -4.000, +2.000}},
       {{-2.000, +0.000, -2.000, +0.000, +0.000, +0.000}},
       {{-2.000, +0.000, -2.000, -0.000, +0.000, +0.000}},
       {{-2.000, +0.000, -2.000, +2.000, +0.000, -2.000}},
       {{-2.000, +0.000, -2.000, -2.000, +0.000, +2.000}},
       {{-2.000, -0.000, +0.000, +0.000, -2.000, -0.000}},
       {{-2.000, -0.000, +0.000, -0.000, -2.000, +0.000}},
       {{-2.000, -0.000, +0.000, +2.000, -2.000, -2.000}},
       {{-2.000, -0.000, +0.000, -2.000, -2.000, +2.000}},
       {{-2.000, -0.000, -0.000, +0.000, -2.000, -0.000}},
       {{-2.000, -0.000, -0.000, -0.000, -2.000, +0.000}},
       {{-2.000, -0.000, -0.000, +2.000, -2.000, -2.000}},
       {{-2.000, -0.000, -0.000, -2.000, -2.000, +2.000}},
       {{-2.000, -0.000, +2.000, +0.000, -4.000, -0.000}},
       {{-2.000, -0.000, +2.000, -0.000, -4.000, +0.000}},
       {{-2.000, -0.000, +2.000, +2.000, -4.000, -2.000}},
       {{-2.000, -0.000, +2.000, -2.000, -4.000, +2.000}},
       {{-2.000, -0.000, -2.000, +0.000, +0.000, -0.000}},
       {{-2.000, -0.000, -2.000, -0.000, +0.000, +0.000}},
       {{-2.000, -0.000, -2.000, +2.000, +0.000, -2.000}},
       {{-2.000, -0.000, -2.000, -2.000, +0.000, +2.000}},
       {{-2.000, +2.000, +0.000, +0.000, -2.000, +2.000}},
       {{-2.000, +2.000, +0.000, -0.000, -2.000, +2.000}},
       {{-2.000, +2.000, +0.000, +2.000, -2.000, +0.000}},
       {{-2.000, +2.000, +0.000, -2.000, -2.000, +4.000}},
       {{-2.000, +2.000, -0.000, +0.000, -2.000, +2.000}},
       {{-2.000, +2.000, -0.000, -0.000, -2.000, +2.000}},
       {{-2.000, +2.000, -0.000, +2.000, -2.000, +0.000}},
       {{-2.000, +2.000, -0.000, -2.000, -2.000, +4.000}},
       {{-2.000, +2.000, +2.000, +0.000, -4.000, +2.000}},
       {{-2.000, +2.000, +2.000, -0.000, -4.000, +2.000}},
       {{-2.000, +2.000, +2.000, +2.000, -4.000, +0.000}},
       {{-2.000, +2.000, +2.000, -2.000, -4.000, +4.000}},
       {{-2.000, +2.000, -2.000, +0.000, +0.000, +2.000}},
       {{-2.000, +2.000, -2.000, -0.000, +0.000, +2.000}},
       {{-2.000, +2.000, -2.000, +2.000, +0.000, +0.000}},
       {{-2.000, +2.000, -2.000, -2.000, +0.000, +4.000}},
       {{-2.000, -2.000, +0.000, +0.000, -2.000, -2.000}},
       {{-2.000, -2.000, +0.000, -0.000, -2.000, -2.000}},
       {{-2.000, -2.000, +0.000, +2.000, -2.000, -4.000}},
       {{-2.000, -2.000, +0.000, -2.000, -2.000, +0.000}},
       {{-2.000, -2.000, -0.000, +0.000, -2.000, -2.000}},
       {{-2.000, -2.000, -0.000, -0.000, -2.000, -2.000}},
       {{-2.000, -2.000, -0.000, +2.000, -2.000, -4.000}},
       {{-2.000, -2.000, -0.000, -2.000, -2.000, +0.000}},
       {{-2.000, -2.000, +2.000, +0.000, -4.000, -2.000}},
       {{-2.000, -2.000, +2.000, -0.000, -4.000, -2.000}},
       {{-2.000, -2.000, +2.000, +2.000, -4.000, -4.000}},
       {{-2.000, -2.000, +2.000, -2.000, -4.000, +0.000}},
       {{-2.000, -2.000, -2.000, +0.000, +0.000, -2.000}},
       {{-2.000, -2.000, -2.000, -0.000, +0.000, -2.000}},
       {{-2.000, -2.000, -2.000, +2.000, +0.000, -4.000}},
       {{-2.000, -2.000, -2.000, -2.000, +0.000, +0.000}},
   }};
   for (unsigned i = 0; i < sub_data.size(); ++i)
   {
      if (!(isnan)(sub_data[i][4]) && !(isnan)(sub_data[i][5]))
      {
         result = T(sub_data[i][0], sub_data[i][1]) - T(sub_data[i][2], sub_data[i][3]);
         BOOST_TEST(result.real() == sub_data[i][4]);
         BOOST_TEST(result.imag() == sub_data[i][5]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(sub_data[i][4]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(sub_data[i][5]));
      }
   }

   //
   // Multiplication by scalar:
   //
   static constexpr std::array<std::array<double, 5>, 64> scalar_mul_data =
       {{
           {{+0.000, +0.000, +0.000, +0.000, +0.000}},
           {{+0.000, +0.000, -0.000, -0.000, -0.000}},
           {{+0.000, +0.000, +2.000, +0.000, +0.000}},
           {{+0.000, +0.000, -2.000, -0.000, -0.000}},
           {{+0.000, -0.000, +0.000, +0.000, -0.000}},
           {{+0.000, -0.000, -0.000, -0.000, +0.000}},
           {{+0.000, -0.000, +2.000, +0.000, -0.000}},
           {{+0.000, -0.000, -2.000, -0.000, +0.000}},
           {{+0.000, +2.000, +0.000, +0.000, +0.000}},
           {{+0.000, +2.000, -0.000, -0.000, -0.000}},
           {{+0.000, +2.000, +2.000, +0.000, +4.000}},
           {{+0.000, +2.000, -2.000, -0.000, -4.000}},
           {{+0.000, -2.000, +0.000, +0.000, -0.000}},
           {{+0.000, -2.000, -0.000, -0.000, +0.000}},
           {{+0.000, -2.000, +2.000, +0.000, -4.000}},
           {{+0.000, -2.000, -2.000, -0.000, +4.000}},
           {{-0.000, +0.000, +0.000, -0.000, +0.000}},
           {{-0.000, +0.000, -0.000, +0.000, -0.000}},
           {{-0.000, +0.000, +2.000, -0.000, +0.000}},
           {{-0.000, +0.000, -2.000, +0.000, -0.000}},
           {{-0.000, -0.000, +0.000, -0.000, -0.000}},
           {{-0.000, -0.000, -0.000, +0.000, +0.000}},
           {{-0.000, -0.000, +2.000, -0.000, -0.000}},
           {{-0.000, -0.000, -2.000, +0.000, +0.000}},
           {{-0.000, +2.000, +0.000, -0.000, +0.000}},
           {{-0.000, +2.000, -0.000, +0.000, -0.000}},
           {{-0.000, +2.000, +2.000, -0.000, +4.000}},
           {{-0.000, +2.000, -2.000, +0.000, -4.000}},
           {{-0.000, -2.000, +0.000, -0.000, -0.000}},
           {{-0.000, -2.000, -0.000, +0.000, +0.000}},
           {{-0.000, -2.000, +2.000, -0.000, -4.000}},
           {{-0.000, -2.000, -2.000, +0.000, +4.000}},
           {{+2.000, +0.000, +0.000, +0.000, +0.000}},
           {{+2.000, +0.000, -0.000, -0.000, -0.000}},
           {{+2.000, +0.000, +2.000, +4.000, +0.000}},
           {{+2.000, +0.000, -2.000, -4.000, -0.000}},
           {{+2.000, -0.000, +0.000, +0.000, -0.000}},
           {{+2.000, -0.000, -0.000, -0.000, +0.000}},
           {{+2.000, -0.000, +2.000, +4.000, -0.000}},
           {{+2.000, -0.000, -2.000, -4.000, +0.000}},
           {{+2.000, +2.000, +0.000, +0.000, +0.000}},
           {{+2.000, +2.000, -0.000, -0.000, -0.000}},
           {{+2.000, +2.000, +2.000, +4.000, +4.000}},
           {{+2.000, +2.000, -2.000, -4.000, -4.000}},
           {{+2.000, -2.000, +0.000, +0.000, -0.000}},
           {{+2.000, -2.000, -0.000, -0.000, +0.000}},
           {{+2.000, -2.000, +2.000, +4.000, -4.000}},
           {{+2.000, -2.000, -2.000, -4.000, +4.000}},
           {{-2.000, +0.000, +0.000, -0.000, +0.000}},
           {{-2.000, +0.000, -0.000, +0.000, -0.000}},
           {{-2.000, +0.000, +2.000, -4.000, +0.000}},
           {{-2.000, +0.000, -2.000, +4.000, -0.000}},
           {{-2.000, -0.000, +0.000, -0.000, -0.000}},
           {{-2.000, -0.000, -0.000, +0.000, +0.000}},
           {{-2.000, -0.000, +2.000, -4.000, -0.000}},
           {{-2.000, -0.000, -2.000, +4.000, +0.000}},
           {{-2.000, +2.000, +0.000, -0.000, +0.000}},
           {{-2.000, +2.000, -0.000, +0.000, -0.000}},
           {{-2.000, +2.000, +2.000, -4.000, +4.000}},
           {{-2.000, +2.000, -2.000, +4.000, -4.000}},
           {{-2.000, -2.000, +0.000, -0.000, -0.000}},
           {{-2.000, -2.000, -0.000, +0.000, +0.000}},
           {{-2.000, -2.000, +2.000, -4.000, -4.000}},
           {{-2.000, -2.000, -2.000, +4.000, +4.000}},
       }};
   for (unsigned i = 0; i < scalar_mul_data.size(); ++i)
   {
      if (!(isnan)(scalar_mul_data[i][3]) && !(isnan)(scalar_mul_data[i][4]))
      {
         result = T(scalar_mul_data[i][0], scalar_mul_data[i][1]) * value_type(scalar_mul_data[i][2]);
         BOOST_TEST(result.real() == scalar_mul_data[i][3]);
         BOOST_TEST(result.imag() == scalar_mul_data[i][4]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(scalar_mul_data[i][3]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(scalar_mul_data[i][4]));
      }
   }
   //
   // Division by scalar:
   //
   static constexpr std::array<std::array<double, 5>, 64> scalar_div_data =
       {{
           {{+0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{+0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{+0.000, +0.000, +2.000, +0.000, +0.000}},
           {{+0.000, +0.000, -2.000, -0.000, -0.000}},
           {{+0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{+0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{+0.000, -0.000, +2.000, +0.000, -0.000}},
           {{+0.000, -0.000, -2.000, -0.000, +0.000}},
           {{+0.000, +2.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity()}},
           {{+0.000, +2.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()}},
           {{+0.000, +2.000, +2.000, +0.000, +1.000}},
           {{+0.000, +2.000, -2.000, -0.000, -1.000}},
           {{+0.000, -2.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()}},
           {{+0.000, -2.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity()}},
           {{+0.000, -2.000, +2.000, +0.000, -1.000}},
           {{+0.000, -2.000, -2.000, -0.000, +1.000}},
           {{-0.000, +0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{-0.000, +0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{-0.000, +0.000, +2.000, -0.000, +0.000}},
           {{-0.000, +0.000, -2.000, +0.000, -0.000}},
           {{-0.000, -0.000, +0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{-0.000, -0.000, -0.000, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()}},
           {{-0.000, -0.000, +2.000, -0.000, -0.000}},
           {{-0.000, -0.000, -2.000, +0.000, +0.000}},
           {{-0.000, +2.000, +0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity()}},
           {{-0.000, +2.000, -0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()}},
           {{-0.000, +2.000, +2.000, -0.000, +1.000}},
           {{-0.000, +2.000, -2.000, +0.000, -1.000}},
           {{-0.000, -2.000, +0.000, std::numeric_limits<double>::quiet_NaN(), -std::numeric_limits<double>::infinity()}},
           {{-0.000, -2.000, -0.000, std::numeric_limits<double>::quiet_NaN(), +std::numeric_limits<double>::infinity()}},
           {{-0.000, -2.000, +2.000, -0.000, -1.000}},
           {{-0.000, -2.000, -2.000, +0.000, +1.000}},
           {{+2.000, +0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{+2.000, +0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{+2.000, +0.000, +2.000, +1.000, +0.000}},
           {{+2.000, +0.000, -2.000, -1.000, -0.000}},
           {{+2.000, -0.000, +0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{+2.000, -0.000, -0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{+2.000, -0.000, +2.000, +1.000, -0.000}},
           {{+2.000, -0.000, -2.000, -1.000, +0.000}},
           {{+2.000, +2.000, +0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity()}},
           {{+2.000, +2.000, -0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()}},
           {{+2.000, +2.000, +2.000, +1.000, +1.000}},
           {{+2.000, +2.000, -2.000, -1.000, -1.000}},
           {{+2.000, -2.000, +0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()}},
           {{+2.000, -2.000, -0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity()}},
           {{+2.000, -2.000, +2.000, +1.000, -1.000}},
           {{+2.000, -2.000, -2.000, -1.000, +1.000}},
           {{-2.000, +0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{-2.000, +0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{-2.000, +0.000, +2.000, -1.000, +0.000}},
           {{-2.000, +0.000, -2.000, +1.000, -0.000}},
           {{-2.000, -0.000, +0.000, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{-2.000, -0.000, -0.000, +std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}},
           {{-2.000, -0.000, +2.000, -1.000, -0.000}},
           {{-2.000, -0.000, -2.000, +1.000, +0.000}},
           {{-2.000, +2.000, +0.000, -std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity()}},
           {{-2.000, +2.000, -0.000, +std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()}},
           {{-2.000, +2.000, +2.000, -1.000, +1.000}},
           {{-2.000, +2.000, -2.000, +1.000, -1.000}},
           {{-2.000, -2.000, +0.000, -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()}},
           {{-2.000, -2.000, -0.000, +std::numeric_limits<double>::infinity(), +std::numeric_limits<double>::infinity()}},
           {{-2.000, -2.000, +2.000, -1.000, -1.000}},
           {{-2.000, -2.000, -2.000, +1.000, +1.000}},
       }};
   for (unsigned i = 0; i < scalar_div_data.size(); ++i)
   {
      if (!(isnan)(scalar_div_data[i][3]) && !(isnan)(scalar_div_data[i][4]))
      {
         result = T(scalar_div_data[i][0], scalar_div_data[i][1]) / value_type(scalar_div_data[i][2]);
         BOOST_TEST(result.real() == scalar_div_data[i][3]);
         BOOST_TEST(result.imag() == scalar_div_data[i][4]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(scalar_div_data[i][3]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(scalar_div_data[i][4]));
      }
   }


   //
   // Addition of scalar:
   //
   static constexpr std::array<std::array<double, 5>, 64> scalar_add_data =
   {{
           {{+0.000, +0.000, +0.000, +0.000, +0.000}},
           {{+0.000, +0.000, -0.000, +0.000, +0.000}},
           {{+0.000, +0.000, +2.000, +2.000, +0.000}},
           {{+0.000, +0.000, -2.000, -2.000, +0.000}},
           {{+0.000, -0.000, +0.000, +0.000, -0.000}},
           {{+0.000, -0.000, -0.000, +0.000, -0.000}},
           {{+0.000, -0.000, +2.000, +2.000, -0.000}},
           {{+0.000, -0.000, -2.000, -2.000, -0.000}},
           {{+0.000, +2.000, +0.000, +0.000, +2.000}},
           {{+0.000, +2.000, -0.000, +0.000, +2.000}},
           {{+0.000, +2.000, +2.000, +2.000, +2.000}},
           {{+0.000, +2.000, -2.000, -2.000, +2.000}},
           {{+0.000, -2.000, +0.000, +0.000, -2.000}},
           {{+0.000, -2.000, -0.000, +0.000, -2.000}},
           {{+0.000, -2.000, +2.000, +2.000, -2.000}},
           {{+0.000, -2.000, -2.000, -2.000, -2.000}},
           {{-0.000, +0.000, +0.000, +0.000, +0.000}},
           {{-0.000, +0.000, -0.000, -0.000, +0.000}},
           {{-0.000, +0.000, +2.000, +2.000, +0.000}},
           {{-0.000, +0.000, -2.000, -2.000, +0.000}},
           {{-0.000, -0.000, +0.000, +0.000, -0.000}},
           {{-0.000, -0.000, -0.000, -0.000, -0.000}},
           {{-0.000, -0.000, +2.000, +2.000, -0.000}},
           {{-0.000, -0.000, -2.000, -2.000, -0.000}},
           {{-0.000, +2.000, +0.000, +0.000, +2.000}},
           {{-0.000, +2.000, -0.000, -0.000, +2.000}},
           {{-0.000, +2.000, +2.000, +2.000, +2.000}},
           {{-0.000, +2.000, -2.000, -2.000, +2.000}},
           {{-0.000, -2.000, +0.000, +0.000, -2.000}},
           {{-0.000, -2.000, -0.000, -0.000, -2.000}},
           {{-0.000, -2.000, +2.000, +2.000, -2.000}},
           {{-0.000, -2.000, -2.000, -2.000, -2.000}},
           {{+2.000, +0.000, +0.000, +2.000, +0.000}},
           {{+2.000, +0.000, -0.000, +2.000, +0.000}},
           {{+2.000, +0.000, +2.000, +4.000, +0.000}},
           {{+2.000, +0.000, -2.000, +0.000, +0.000}},
           {{+2.000, -0.000, +0.000, +2.000, -0.000}},
           {{+2.000, -0.000, -0.000, +2.000, -0.000}},
           {{+2.000, -0.000, +2.000, +4.000, -0.000}},
           {{+2.000, -0.000, -2.000, +0.000, -0.000}},
           {{+2.000, +2.000, +0.000, +2.000, +2.000}},
           {{+2.000, +2.000, -0.000, +2.000, +2.000}},
           {{+2.000, +2.000, +2.000, +4.000, +2.000}},
           {{+2.000, +2.000, -2.000, +0.000, +2.000}},
           {{+2.000, -2.000, +0.000, +2.000, -2.000}},
           {{+2.000, -2.000, -0.000, +2.000, -2.000}},
           {{+2.000, -2.000, +2.000, +4.000, -2.000}},
           {{+2.000, -2.000, -2.000, +0.000, -2.000}},
           {{-2.000, +0.000, +0.000, -2.000, +0.000}},
           {{-2.000, +0.000, -0.000, -2.000, +0.000}},
           {{-2.000, +0.000, +2.000, +0.000, +0.000}},
           {{-2.000, +0.000, -2.000, -4.000, +0.000}},
           {{-2.000, -0.000, +0.000, -2.000, -0.000}},
           {{-2.000, -0.000, -0.000, -2.000, -0.000}},
           {{-2.000, -0.000, +2.000, +0.000, -0.000}},
           {{-2.000, -0.000, -2.000, -4.000, -0.000}},
           {{-2.000, +2.000, +0.000, -2.000, +2.000}},
           {{-2.000, +2.000, -0.000, -2.000, +2.000}},
           {{-2.000, +2.000, +2.000, +0.000, +2.000}},
           {{-2.000, +2.000, -2.000, -4.000, +2.000}},
           {{-2.000, -2.000, +0.000, -2.000, -2.000}},
           {{-2.000, -2.000, -0.000, -2.000, -2.000}},
           {{-2.000, -2.000, +2.000, +0.000, -2.000}},
           {{-2.000, -2.000, -2.000, -4.000, -2.000}},
       }};
   for (unsigned i = 0; i < scalar_add_data.size(); ++i)
   {
      if (!(isnan)(scalar_add_data[i][3]) && !(isnan)(scalar_add_data[i][4]))
      {
         result = T(scalar_add_data[i][0], scalar_add_data[i][1]) + value_type(scalar_add_data[i][2]);
         BOOST_TEST(result.real() == scalar_add_data[i][3]);
         BOOST_TEST(result.imag() == scalar_add_data[i][4]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(scalar_add_data[i][3]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(scalar_add_data[i][4]));
      }
   }
   //
   // Subtraction of scalar:
   //
   static constexpr std::array<std::array<double, 5>, 64> scalar_sub_data =
   {{
           {{+0.000, +0.000, +0.000, +0.000, +0.000}},
           {{+0.000, +0.000, -0.000, +0.000, +0.000}},
           {{+0.000, +0.000, +2.000, -2.000, +0.000}},
           {{+0.000, +0.000, -2.000, +2.000, +0.000}},
           {{+0.000, -0.000, +0.000, +0.000, -0.000}},
           {{+0.000, -0.000, -0.000, +0.000, -0.000}},
           {{+0.000, -0.000, +2.000, -2.000, -0.000}},
           {{+0.000, -0.000, -2.000, +2.000, -0.000}},
           {{+0.000, +2.000, +0.000, +0.000, +2.000}},
           {{+0.000, +2.000, -0.000, +0.000, +2.000}},
           {{+0.000, +2.000, +2.000, -2.000, +2.000}},
           {{+0.000, +2.000, -2.000, +2.000, +2.000}},
           {{+0.000, -2.000, +0.000, +0.000, -2.000}},
           {{+0.000, -2.000, -0.000, +0.000, -2.000}},
           {{+0.000, -2.000, +2.000, -2.000, -2.000}},
           {{+0.000, -2.000, -2.000, +2.000, -2.000}},
           {{-0.000, +0.000, +0.000, -0.000, +0.000}},
           {{-0.000, +0.000, -0.000, +0.000, +0.000}},
           {{-0.000, +0.000, +2.000, -2.000, +0.000}},
           {{-0.000, +0.000, -2.000, +2.000, +0.000}},
           {{-0.000, -0.000, +0.000, -0.000, -0.000}},
           {{-0.000, -0.000, -0.000, +0.000, -0.000}},
           {{-0.000, -0.000, +2.000, -2.000, -0.000}},
           {{-0.000, -0.000, -2.000, +2.000, -0.000}},
           {{-0.000, +2.000, +0.000, -0.000, +2.000}},
           {{-0.000, +2.000, -0.000, +0.000, +2.000}},
           {{-0.000, +2.000, +2.000, -2.000, +2.000}},
           {{-0.000, +2.000, -2.000, +2.000, +2.000}},
           {{-0.000, -2.000, +0.000, -0.000, -2.000}},
           {{-0.000, -2.000, -0.000, +0.000, -2.000}},
           {{-0.000, -2.000, +2.000, -2.000, -2.000}},
           {{-0.000, -2.000, -2.000, +2.000, -2.000}},
           {{+2.000, +0.000, +0.000, +2.000, +0.000}},
           {{+2.000, +0.000, -0.000, +2.000, +0.000}},
           {{+2.000, +0.000, +2.000, +0.000, +0.000}},
           {{+2.000, +0.000, -2.000, +4.000, +0.000}},
           {{+2.000, -0.000, +0.000, +2.000, -0.000}},
           {{+2.000, -0.000, -0.000, +2.000, -0.000}},
           {{+2.000, -0.000, +2.000, +0.000, -0.000}},
           {{+2.000, -0.000, -2.000, +4.000, -0.000}},
           {{+2.000, +2.000, +0.000, +2.000, +2.000}},
           {{+2.000, +2.000, -0.000, +2.000, +2.000}},
           {{+2.000, +2.000, +2.000, +0.000, +2.000}},
           {{+2.000, +2.000, -2.000, +4.000, +2.000}},
           {{+2.000, -2.000, +0.000, +2.000, -2.000}},
           {{+2.000, -2.000, -0.000, +2.000, -2.000}},
           {{+2.000, -2.000, +2.000, +0.000, -2.000}},
           {{+2.000, -2.000, -2.000, +4.000, -2.000}},
           {{-2.000, +0.000, +0.000, -2.000, +0.000}},
           {{-2.000, +0.000, -0.000, -2.000, +0.000}},
           {{-2.000, +0.000, +2.000, -4.000, +0.000}},
           {{-2.000, +0.000, -2.000, +0.000, +0.000}},
           {{-2.000, -0.000, +0.000, -2.000, -0.000}},
           {{-2.000, -0.000, -0.000, -2.000, -0.000}},
           {{-2.000, -0.000, +2.000, -4.000, -0.000}},
           {{-2.000, -0.000, -2.000, +0.000, -0.000}},
           {{-2.000, +2.000, +0.000, -2.000, +2.000}},
           {{-2.000, +2.000, -0.000, -2.000, +2.000}},
           {{-2.000, +2.000, +2.000, -4.000, +2.000}},
           {{-2.000, +2.000, -2.000, +0.000, +2.000}},
           {{-2.000, -2.000, +0.000, -2.000, -2.000}},
           {{-2.000, -2.000, -0.000, -2.000, -2.000}},
           {{-2.000, -2.000, +2.000, -4.000, -2.000}},
           {{-2.000, -2.000, -2.000, +0.000, -2.000}},
       }};
   for (unsigned i = 0; i < scalar_sub_data.size(); ++i)
   {
      if (!(isnan)(scalar_sub_data[i][3]) && !(isnan)(scalar_sub_data[i][4]))
      {
         result = T(scalar_sub_data[i][0], scalar_sub_data[i][1]) - value_type(scalar_sub_data[i][2]);
         BOOST_TEST(result.real() == scalar_sub_data[i][3]);
         BOOST_TEST(result.imag() == scalar_sub_data[i][4]);
         BOOST_TEST((bool)signbit(result.real()) == signbit(scalar_sub_data[i][3]));
         BOOST_TEST((bool)signbit(result.imag()) == signbit(scalar_sub_data[i][4]));
      }
   }
}

int main()
{
#ifdef TEST_DOUBLE
   //
   // This does not actually pass these tests:
   // 
   //test<std::complex<double>>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_complex_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_complex_50::backend_type, boost::multiprecision::et_on> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex_50>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_constants.cpp
================================================
// Copyright John Maddock 2012.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_MPF_50) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50)
#define TEST_MPF_50
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFR_50

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#include "test.hpp"

static const char* ln2 =
    "0.693147180559945309417232121458176568075500134360255254120680009493393621969694"
    "71560586332699641868754200148102057068573368552023575813055703267075163507596193"
    "07275708283714351903070386238916734711233501153644979552391204751726815749320651"
    "55524734139525882950453007095326366642654104239157814952043740430385500801944170"
    "64167151864471283996817178454695702627163106454615025720740248163777338963855069"
    "52606683411372738737229289564935470257626520988596932019650585547647033067936544"
    "32547632744951250406069438147104689946506220167720424524529612687946546193165174"
    "68139267250410380254625965686914419287160829380317271436778265487756648508567407"
    "76484514644399404614226031930967354025744460703080960850474866385231381816767514"
    "38667476647890881437141985494231519973548803751658612753529166100071053558249879"
    "41472950929311389715599820565439287170007218085761025236889213244971389320378439"
    "35308877482597017155910708823683627589842589185353024363421436706118923678919237"
    "23146723217205340164925687274778234453534764811494186423867767744060695626573796"
    "00867076257199184734022651462837904883062033061144630073719489002743643965002580"
    "93651944304119115060809487930678651588709006052034684297361938412896525565396860"
    "22194122924207574321757489097706752687115817051137009158942665478595964890653058"
    "46025866838294002283300538207400567705304678700184162404418833232798386349001563"
    "12188956065055315127219939833203075140842609147900126516824344389357247278820548"
    "62715527418772430024897945401961872339808608316648114909306675193393128904316413"
    "70681397776498176974868903887789991296503619270710889264105230924783917373501229"
    "84242049956893599220660220465494151061391878857442455775102068370308666194808964"
    "12186807790208181588580001688115973056186676199187395200766719214592236720602539"
    "59543654165531129517598994005600036651356756905124592682574394648316833262490180"
    "38242408242314523061409638057007025513877026817851630690255137032340538021450190"
    "15374029509942262995779647427138157363801729873940704242179972266962979939312706"
    "93574724049338653087975872169964512944649188377115670167859880498183889678413493"
    "83140140731664727653276359192335112333893387095132090592721854713289754707978913"
    "84445466676192702885533423429899321803769154973340267546758873236778342916191810"
    "43011609169526554785973289176354555674286387746398710191243175425588830120677921"
    "02803412068797591430812833072303008834947057924965910058600123415617574132724659"
    "43068435465211135021544341539955381856522750221424566440006276183303206472725721"
    "97515290827856842132079598863896727711955221881904660395700977470651261950527893"
    "22960889314056254334425523920620303439417773579455921259019925591148440242390125"
    "54259003129537051922061506434583787873002035414421785758013236451660709914383145"
    "00498589668857722214865288216941812704886075897220321666312837832915676307498729"
    "85746389282693735098407780493950049339987626475507031622161390348452994249172483"
    "73406136622638349368111684167056925214751383930638455371862687797328895558871634"
    "429756244755392366369488877823890174981027";
static const char* pi =
    "3.141592653589793238462643383279502884197169399375105820974944592307816406286208"
    "99862803482534211706798214808651328230664709384460955058223172535940812848111745"
    "02841027019385211055596446229489549303819644288109756659334461284756482337867831"
    "65271201909145648566923460348610454326648213393607260249141273724587006606315588"
    "17488152092096282925409171536436789259036001133053054882046652138414695194151160"
    "94330572703657595919530921861173819326117931051185480744623799627495673518857527"
    "24891227938183011949129833673362440656643086021394946395224737190702179860943702"
    "77053921717629317675238467481846766940513200056812714526356082778577134275778960"
    "91736371787214684409012249534301465495853710507922796892589235420199561121290219"
    "60864034418159813629774771309960518707211349999998372978049951059731732816096318"
    "59502445945534690830264252230825334468503526193118817101000313783875288658753320"
    "83814206171776691473035982534904287554687311595628638823537875937519577818577805"
    "32171226806613001927876611195909216420198938095257201065485863278865936153381827"
    "96823030195203530185296899577362259941389124972177528347913151557485724245415069"
    "59508295331168617278558890750983817546374649393192550604009277016711390098488240"
    "12858361603563707660104710181942955596198946767837449448255379774726847104047534"
    "64620804668425906949129331367702898915210475216205696602405803815019351125338243"
    "00355876402474964732639141992726042699227967823547816360093417216412199245863150"
    "30286182974555706749838505494588586926995690927210797509302955321165344987202755"
    "96023648066549911988183479775356636980742654252786255181841757467289097777279380"
    "00816470600161452491921732172147723501414419735685481613611573525521334757418494"
    "68438523323907394143334547762416862518983569485562099219222184272550254256887671"
    "79049460165346680498862723279178608578438382796797668145410095388378636095068006"
    "42251252051173929848960841284886269456042419652850222106611863067442786220391949"
    "45047123713786960956364371917287467764657573962413890865832645995813390478027590"
    "09946576407895126946839835259570982582262052248940772671947826848260147699090264"
    "01363944374553050682034962524517493996514314298091906592509372216964615157098583"
    "87410597885959772975498930161753928468138268683868942774155991855925245953959431"
    "04997252468084598727364469584865383673622262609912460805124388439045124413654976"
    "27807977156914359977001296160894416948685558484063534220722258284886481584560285"
    "06016842739452267467678895252138522549954666727823986456596116354886230577456498"
    "03559363456817432411251507606947945109659609402522887971089314566913686722874894"
    "05601015033086179286809208747609178249385890097149096759852613655497818931297848"
    "21682998948722658804857564014270477555132379641451523746234364542858444795265867"
    "82105114135473573952311342716610213596953623144295248493718711014576540359027993"
    "44037420073105785390621983874478084784896833214457138687519435064302184531910484"
    "81005370614680674919278191197939952061419663428754440643745123718192179998391015"
    "91956181467514269123974894090718649423196";
static const char* e =
    "2.718281828459045235360287471352662497757247093699959574966967627724076630353547"
    "59457138217852516642742746639193200305992181741359662904357290033429526059563073"
    "81323286279434907632338298807531952510190115738341879307021540891499348841675092"
    "44761460668082264800168477411853742345442437107539077744992069551702761838606261"
    "33138458300075204493382656029760673711320070932870912744374704723069697720931014"
    "16928368190255151086574637721112523897844250569536967707854499699679468644549059"
    "87931636889230098793127736178215424999229576351482208269895193668033182528869398"
    "49646510582093923982948879332036250944311730123819706841614039701983767932068328"
    "23764648042953118023287825098194558153017567173613320698112509961818815930416903"
    "51598888519345807273866738589422879228499892086805825749279610484198444363463244"
    "96848756023362482704197862320900216099023530436994184914631409343173814364054625"
    "31520961836908887070167683964243781405927145635490613031072085103837505101157477"
    "04171898610687396965521267154688957035035402123407849819334321068170121005627880"
    "23519303322474501585390473041995777709350366041699732972508868769664035557071622"
    "68447162560798826517871341951246652010305921236677194325278675398558944896970964"
    "09754591856956380236370162112047742722836489613422516445078182442352948636372141"
    "74023889344124796357437026375529444833799801612549227850925778256209262264832627"
    "79333865664816277251640191059004916449982893150566047258027786318641551956532442"
    "58698294695930801915298721172556347546396447910145904090586298496791287406870504"
    "89585867174798546677575732056812884592054133405392200011378630094556068816674001"
    "69842055804033637953764520304024322566135278369511778838638744396625322498506549"
    "95886234281899707733276171783928034946501434558897071942586398772754710962953741"
    "52111513683506275260232648472870392076431005958411661205452970302364725492966693"
    "81151373227536450988890313602057248176585118063036442812314965507047510254465011"
    "72721155519486685080036853228183152196003735625279449515828418829478761085263981"
    "39559900673764829224437528718462457803619298197139914756448826260390338144182326"
    "25150974827987779964373089970388867782271383605772978824125611907176639465070633"
    "04527954661855096666185664709711344474016070462621568071748187784437143698821855"
    "96709591025968620023537185887485696522000503117343920732113908032936344797273559"
    "55277349071783793421637012050054513263835440001863239914907054797780566978533580"
    "48966906295119432473099587655236812859041383241160722602998330535370876138939639"
    "17795745401613722361878936526053815584158718692553860616477983402543512843961294"
    "60352913325942794904337299085731580290958631382683291477116396337092400316894586"
    "36060645845925126994655724839186564209752685082307544254599376917041977780085362"
    "73094171016343490769642372229435236612557250881477922315197477806056967253801718"
    "07763603462459278778465850656050780844211529697521890874019660906651803516501792"
    "50461950136658543663271254963990854914420001457476081930221206602433009641270489"
    "43903971771951806990869986066365832322787";

template <class T>
inline bool is_mpfr(const T&)
{
   return false;
}
#if defined(TEST_MPFR_50)
template <unsigned N, boost::multiprecision::expression_template_option ET>
inline bool is_mpfr(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<N>, ET>&)
{
   return true;
}
#endif

template <class T>
void test()
{
   typedef typename T::backend_type backend_type;
   T                                num, expect;
   num.backend() = boost::multiprecision::default_ops::get_constant_pi<backend_type>();
   expect        = static_cast<T>(pi);
   BOOST_CHECK_CLOSE_FRACTION(num, expect, std::numeric_limits<T>::epsilon() * (is_mpfr(num) ? 1200 : 2));
   num.backend() = boost::multiprecision::default_ops::get_constant_ln2<backend_type>();
   expect        = static_cast<T>(ln2);
   BOOST_CHECK_CLOSE_FRACTION(num, expect, std::numeric_limits<T>::epsilon() * (is_mpfr(num) ? 30 : 1));
   num.backend() = boost::multiprecision::default_ops::get_constant_e<backend_type>();
   expect        = static_cast<T>(e);
   BOOST_CHECK_CLOSE_FRACTION(num, expect, std::numeric_limits<T>::epsilon() * (is_mpfr(num) ? 2 : 1));
}

int main()
{
#ifdef TEST_MPFR_50
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<2000> > >();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<2000> > >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<2000> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_constexpr.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#if defined(HAVE_FLOAT128)
#include <boost/multiprecision/float128.hpp>
#endif

template <class T>
void silence_unused(const T&) {}

template <class T>
void test1()
{
   constexpr T i1 = 2u;
   constexpr T i2;
   constexpr T i3 = -3;
   constexpr T i4(i1);

   silence_unused(i1);
   silence_unused(i2);
   silence_unused(i3);
   silence_unused(i4);
}
template <class T>
void test2()
{
   constexpr T i1 = 2u;
   constexpr T i2;
   constexpr T i3 = -3;

   silence_unused(i1);
   silence_unused(i2);
   silence_unused(i3);
}
template <class T>
void test3()
{
   constexpr T i1 = 2u;
   constexpr T i2;

   silence_unused(i1);
   silence_unused(i2);
}

using namespace boost::multiprecision;

template void test1<number<cpp_int_backend<64, 64, unsigned_magnitude, unchecked, void>, et_off> >();
template void test1<number<cpp_int_backend<64, 64, signed_magnitude, unchecked, void>, et_off> >();
template void test3<number<cpp_int_backend<2048, 2048, unsigned_magnitude, unchecked, void>, et_off> >();
template void test2<number<cpp_int_backend<2048, 2048, signed_magnitude, unchecked, void>, et_off> >();

#if defined(HAVE_FLOAT128)
template void test1<float128>();
#endif



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_cpp_int_2_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// Simple test that cpp_int -> double conversion has less than 0.5ulp error
// and rounds to even in case of ties.
// See https://github.com/boostorg/multiprecision/issues/360.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class From, class To>
void test_convert()
{
   boost::random::mt19937 gen;
   boost::random::uniform_int_distribution<> d(20, (std::min)(200, std::numeric_limits<To>::max_exponent - 2));

   for (unsigned i = 0; i < 10000; ++i)
   {
      int  bits = d(gen);
      From from = generate_random<From>(bits);
      To   t1(from);
      From b(t1);
      std::size_t m = msb(from);
      if (m >= std::numeric_limits<To>::digits)
      {
         // For error <= 1ulp
         // Note msb(from) returns one less than the number of bits in from:
         From max_error = (From(1) << (m - std::numeric_limits<To>::digits));
         BOOST_TEST_GE(max_error, abs(b - from));
         if (max_error < abs(b - from))
            // debugging help:
            std::cout << from << std::endl
                      << b << std::endl
                      << abs(b - from) << std::endl;
         if (max_error == abs(b - from))
         {
            // Check we rounded to even in case of tie:
            BOOST_TEST_GT(lsb(b), (1 + msb(from) - std::numeric_limits<To>::digits));
            if (lsb(b) <= (1 + msb(from) - std::numeric_limits<To>::digits))
            {
               // debugging help:
               std::cout << from << std::endl
                         << b << std::endl
                         << abs(b - from) << std::endl;
            }
         }
      }
      else
      {
         BOOST_TEST_EQ(b, from);
      }
   }
}

int main()
{
   test_convert<cpp_int, float>();
   test_convert<cpp_int, double>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_cpp_bin_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   //
   // Our aim is to fill up the mantissa of T with random bits,
   // the main loop simply multiplies by the largest random value
   // we produce and then adds the next random value.  It stops
   // when the next random value is too small to change the result,
   // and so "val" and "prev_val" end up with the same value.
   //
   // We start with an arbitrary value in "prev_val" - anything you
   // like as long as it's a value that our generator can not produce.
   //
   // At the end we ditch the current exponent, and replace with our own
   // randomly generated one.
   //
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(t3), from);
   BOOST_CHECK_EQUAL(From(t4), from);
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(t1), from);
      BOOST_CHECK_EQUAL(From(t2), from);
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(from.str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(from.str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<cpp_bin_float_50, cpp_int>();
   test_convert<cpp_bin_float_50, int128_t>();
   test_convert<cpp_bin_float_50, uint128_t>();
   test_convert<cpp_bin_float_quad, checked_int1024_t>();
   test_convert<cpp_bin_float_quad, checked_uint1024_t>();

   test_convert<cpp_bin_float_50, cpp_rational>();

   test_convert<cpp_bin_float_50, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<cpp_bin_float_50, mpz_int>();
   test_convert<cpp_bin_float_50, mpq_rational>();
   test_convert<cpp_bin_float_50, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<cpp_bin_float_50, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<cpp_bin_float_50, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<cpp_bin_float_50, tom_int>();
   test_convert<cpp_bin_float_50, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<cpp_bin_float_50, float128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_cpp_dec_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To   t3(from);
   To   t4  = from.template convert_to<To>();
   From tol = std::numeric_limits<From>::epsilon();
   BOOST_CHECK_CLOSE_FRACTION(From(t3), from, tol);
   BOOST_CHECK_CLOSE_FRACTION(From(t4), from, tol);
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2  = from.template convert_to<To>();
      From tol = std::numeric_limits<From>::epsilon();
      BOOST_CHECK_CLOSE_FRACTION(From(t1), from, tol);
      BOOST_CHECK_CLOSE_FRACTION(From(t2), from, tol);
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(from.str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(from.str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<cpp_dec_float_50, cpp_int>();
   test_convert<cpp_dec_float_50, int128_t>();
   test_convert<cpp_dec_float_50, uint128_t>();

   test_convert<cpp_dec_float_50, cpp_rational>();

   test_convert<cpp_dec_float_50, cpp_bin_float_50>();

#if defined(HAS_GMP)
   test_convert<cpp_dec_float_50, mpz_int>();
   test_convert<cpp_dec_float_50, mpq_rational>();
   test_convert<cpp_dec_float_50, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<cpp_dec_float_50, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<cpp_dec_float_50, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<cpp_dec_float_50, tom_int>();
   test_convert<cpp_dec_float_50, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<cpp_dec_float_50, float128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), numerator(t3).str());
   BOOST_CHECK_EQUAL(from.str(), numerator(t4).str());
}
template <class From, class To>
void test_convert_neg_rat(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), numerator(t1).str());
      BOOST_CHECK_EQUAL(from.str(), numerator(t2).str());
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To check(from.str() + ".0");
   BOOST_CHECK_EQUAL(t3, check);
   BOOST_CHECK_EQUAL(t4, check);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   check(from.str() + ".0");
      BOOST_CHECK_EQUAL(t1, check);
      BOOST_CHECK_EQUAL(t2, check);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<cpp_int, int128_t>();
   test_convert<int128_t, cpp_int>();

   test_convert<cpp_int, cpp_rational>();
   test_convert<int128_t, cpp_rational>();
   test_convert<uint128_t, cpp_rational>();

   test_convert<cpp_int, cpp_bin_float_50>();
   test_convert<int128_t, cpp_bin_float_50>();
   test_convert<uint128_t, cpp_bin_float_50>();

   test_convert<cpp_int, cpp_dec_float_50>();
   test_convert<int128_t, cpp_dec_float_50>();
   test_convert<uint128_t, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<cpp_int, mpz_int>();
   test_convert<int128_t, mpz_int>();
   test_convert<uint128_t, mpz_int>();

   test_convert<cpp_int, mpq_rational>();
   test_convert<int128_t, mpq_rational>();
   test_convert<uint128_t, mpq_rational>();

   test_convert<cpp_int, mpf_float_50>();
   test_convert<int128_t, mpf_float_50>();
   test_convert<uint128_t, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<cpp_int, mpfr_float_50>();
   test_convert<int128_t, mpfr_float_50>();
   test_convert<uint128_t, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<cpp_int, mpfi_float_50>();
   test_convert<int128_t, mpfi_float_50>();
   test_convert<uint128_t, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<cpp_int, tom_int>();
   test_convert<int128_t, tom_int>();
   test_convert<uint128_t, tom_int>();

   test_convert<cpp_int, tom_rational>();
   test_convert<int128_t, tom_rational>();
   test_convert<uint128_t, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<cpp_int, float128>();
   test_convert<int128_t, float128>();
   test_convert<uint128_t, float128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_cpp_rational.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random_int(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
T generate_random(unsigned bits_wanted)
{
   typedef typename component_type<T>::type int_type;
   T                                        val(generate_random_int<int_type>(bits_wanted), generate_random_int<int_type>(bits_wanted));
   return val;
}

template <class From, class To>
void test_convert_neg_val(From from, const std::integral_constant<bool, true>&)
{
   from                                       = -from;
   typename component_type<From>::type answer = numerator(from) / denominator(from);
   To                                  t3(from);
   To                                  t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(answer.str(), t3.str());
   BOOST_CHECK_EQUAL(answer.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From                                from   = generate_random<From>(bits_wanted);
      typename component_type<From>::type answer = numerator(from) / denominator(from);
      To                                  t1(from);
      To                                  t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(answer.str(), t1.str());
      BOOST_CHECK_EQUAL(answer.str(), t2.str());
      test_convert_neg_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float_val(From from, To const& tol, const std::integral_constant<bool, true>&)
{
   from      = -from;
   To answer = To(numerator(from)) / To(denominator(from));
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_CLOSE_FRACTION(answer, t3, tol);
   BOOST_CHECK_CLOSE_FRACTION(answer, t4, tol);
}
template <class From, class To>
void test_convert_neg_float_val(From const&, To const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from   = generate_random<From>(bits_wanted);
      To   answer = To(numerator(from)) / To(denominator(from));
      To   t1(from);
      To   t2  = from.template convert_to<To>();
      To   tol = std::numeric_limits<To>::is_specialized ? std::numeric_limits<To>::epsilon() : ldexp(To(1), 1 - bits_wanted);
      tol *= 2;
      BOOST_CHECK_CLOSE_FRACTION(answer, t1, tol);
      BOOST_CHECK_CLOSE_FRACTION(answer, t2, tol);
      test_convert_neg_float_val<From, To>(from, tol, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat_val(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_rat_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_rat_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<cpp_rational, cpp_int>();
   test_convert<cpp_rational, int128_t>();
   test_convert<cpp_rational, uint128_t>();

   test_convert<cpp_rational, cpp_bin_float_50>();

   test_convert<cpp_rational, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<cpp_rational, mpz_int>();
   test_convert<cpp_rational, mpq_rational>();
   test_convert<cpp_rational, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<cpp_rational, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<cpp_rational, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<cpp_rational, tom_int>();
   test_convert<cpp_rational, tom_rational>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_float128.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#ifdef HAS_FLOAT128

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(t3), from);
   BOOST_CHECK_EQUAL(From(t4), from);
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(t1), from);
      BOOST_CHECK_EQUAL(From(t2), from);
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(from.str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(from.str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   //
   // Some basic sanity checks first:
   //
   BOOST_CHECK_EQUAL(std::numeric_limits<float128>::epsilon(), float128("1.92592994438723585305597794258492732e-34"));
   BOOST_CHECK_EQUAL((std::numeric_limits<float128>::min)(), float128("3.36210314311209350626267781732175260e-4932"));
   BOOST_CHECK_EQUAL((std::numeric_limits<float128>::max)(), float128("1.18973149535723176508575932662800702e4932"));
   BOOST_CHECK_EQUAL((std::numeric_limits<float128>::denorm_min)(), float128("6.475175119438025110924438958227646552e-4966"));
   BOOST_CHECK((boost::math::isinf)((std::numeric_limits<float128>::infinity)()));
   BOOST_CHECK((std::numeric_limits<float128>::infinity)() > 0);
   BOOST_CHECK((boost::math::isnan)((std::numeric_limits<float128>::quiet_NaN)()));

   test_convert<float128, cpp_int>();
   test_convert<float128, int128_t>();
   test_convert<float128, uint128_t>();

   test_convert<float128, cpp_rational>();

   test_convert<float128, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<float128, mpz_int>();
   test_convert<float128, mpq_rational>();
   test_convert<float128, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<float128, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<float128, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<float128, tom_int>();
   test_convert<float128, tom_rational>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_gmp_rational.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(HAS_GMP)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"
#include <boost/multiprecision/gmp.hpp>

#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random_int(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
T generate_random(unsigned bits_wanted)
{
   typedef typename component_type<T>::type int_type;
   T                                        val(generate_random_int<int_type>(bits_wanted), generate_random_int<int_type>(bits_wanted));
   return val;
}

template <class From, class To>
void test_convert_neg_val(From from, const std::integral_constant<bool, true>&)
{
   from                                       = -from;
   typename component_type<From>::type answer = numerator(from) / denominator(from);
   To                                  t3(from);
   To                                  t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(answer.str(), t3.str());
   BOOST_CHECK_EQUAL(answer.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From                                from   = generate_random<From>(bits_wanted);
      typename component_type<From>::type answer = numerator(from) / denominator(from);
      To                                  t1(from);
      To                                  t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(answer.str(), t1.str());
      BOOST_CHECK_EQUAL(answer.str(), t2.str());
      test_convert_neg_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float_val(From from, To const& tol, const std::integral_constant<bool, true>&)
{
   from      = -from;
   To answer = To(numerator(from)) / To(denominator(from));
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_CLOSE_FRACTION(answer, t3, tol);
   BOOST_CHECK_CLOSE_FRACTION(answer, t4, tol);
}
template <class From, class To>
void test_convert_neg_float_val(From const&, To const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from   = generate_random<From>(bits_wanted);
      To   answer = To(numerator(from)) / To(denominator(from));
      To   t1(from);
      To   t2  = from.template convert_to<To>();
      To   tol = std::numeric_limits<To>::is_specialized ? std::numeric_limits<To>::epsilon() : ldexp(To(1), 1 - bits_wanted);
      tol *= 2;
      BOOST_CHECK_CLOSE_FRACTION(answer, t1, tol);
      BOOST_CHECK_CLOSE_FRACTION(answer, t2, tol);
      test_convert_neg_float_val<From, To>(from, tol, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat_val(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_rat_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_rat_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<mpq_rational, cpp_int>();
   test_convert<mpq_rational, int128_t>();
   test_convert<mpq_rational, uint128_t>();
   test_convert<mpq_rational, cpp_rational>();

   test_convert<mpq_rational, cpp_bin_float_50>();

   test_convert<mpq_rational, cpp_dec_float_50>();

   test_convert<mpq_rational, mpz_int>();
   test_convert<mpq_rational, mpf_float_50>();
#if defined(HAS_MPFR)
   test_convert<mpq_rational, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<mpq_rational, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<mpq_rational, tom_int>();
   test_convert<mpq_rational, tom_rational>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_mpf_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(HAS_GMP)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To   t3(from);
   To   t4  = from.template convert_to<To>();
   From tol = std::numeric_limits<From>::epsilon();
   BOOST_CHECK_CLOSE_FRACTION(From(t3), from, tol);
   BOOST_CHECK_CLOSE_FRACTION(From(t4), from, tol);
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2  = from.template convert_to<To>();
      From tol = std::numeric_limits<From>::epsilon();
      BOOST_CHECK_CLOSE_FRACTION(From(t1), from, tol);
      BOOST_CHECK_CLOSE_FRACTION(From(t2), from, tol);
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(from.str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(from.str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<mpf_float_50, cpp_int>();
   test_convert<mpf_float_50, int128_t>();
   test_convert<mpf_float_50, uint128_t>();

   test_convert<mpf_float_50, cpp_rational>();

   test_convert<mpf_float_50, cpp_dec_float_50>();

   test_convert<mpf_float_50, mpz_int>();
   test_convert<mpf_float_50, mpq_rational>();
#if defined(HAS_MPFR)
   test_convert<mpf_float_50, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<mpf_float_50, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<mpf_float_50, tom_int>();
   test_convert<mpf_float_50, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<mpf_float_50, float128>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_mpfi_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(HAS_MPFI)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val           = gen();
   T                             prev_val      = -1;
   int                           digits_so_far = 0;
   while (digits_so_far < std::numeric_limits<T>::digits)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
      digits_so_far += std::numeric_limits<boost::random::mt19937::result_type>::digits;
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(t3), median(from));
   BOOST_CHECK_EQUAL(From(t4), median(from));
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(t1), median(from));
      BOOST_CHECK_EQUAL(From(t2), median(from));
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(median(from).str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(median(from).str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   try
   {
      test_convert<mpfi_float_50, cpp_int>();
      test_convert<mpfi_float_50, int128_t>();
      test_convert<mpfi_float_50, uint128_t>();

      test_convert<mpfi_float_50, cpp_rational>();

      test_convert<mpfi_float_50, cpp_dec_float_50>();

#if defined(HAS_GMP)
      test_convert<mpfi_float_50, mpz_int>();
      test_convert<mpfi_float_50, mpq_rational>();
      test_convert<mpfi_float_50, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
      test_convert<mpfi_float_50, mpfr_float_50>();
#endif
#ifdef HAS_TOMMATH
      test_convert<mpfi_float_50, tom_int>();
      test_convert<mpfi_float_50, tom_rational>();
#endif
#ifdef HAS_FLOAT128
      test_convert<mpfi_float_50, float128>();
#endif
   }
   catch (...)
   {
      return 1;
   }
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_mpfr_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(HAS_MPFR)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t3));
   BOOST_CHECK_EQUAL(From(trunc(from)), From(t4));
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_integer> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t1));
      BOOST_CHECK_EQUAL(From(trunc(from)), From(t2));
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(From(t3), from);
   BOOST_CHECK_EQUAL(From(t4), from);
}
template <class From, class To>
void test_convert_rat_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_rational> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(From(t1), from);
      BOOST_CHECK_EQUAL(From(t2), from);
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To answer(from.str());
   To tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
   BOOST_CHECK_CLOSE_FRACTION(t3, answer, tol);
   BOOST_CHECK_CLOSE_FRACTION(t4, answer, tol);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_floating_point> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>();
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   answer(from.str());
      To   tol = (std::max)(std::numeric_limits<To>::epsilon(), To(std::numeric_limits<From>::epsilon())) * 2;
      BOOST_CHECK_CLOSE_FRACTION(t1, answer, tol);
      BOOST_CHECK_CLOSE_FRACTION(t2, answer, tol);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<mpfr_float_50, cpp_int>();
   test_convert<mpfr_float_50, int128_t>();
   test_convert<mpfr_float_50, uint128_t>();

   test_convert<mpfr_float_50, cpp_rational>();

   test_convert<mpfr_float_50, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<mpfr_float_50, mpz_int>();
   test_convert<mpfr_float_50, mpq_rational>();
   test_convert<mpfr_float_50, mpf_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<mpfr_float_50, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<mpfr_float_50, tom_int>();
   test_convert<mpfr_float_50, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<mpfr_float_50, float128>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_mpz_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(HAS_GMP)

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/multiprecision/gmp.hpp>
#include "test.hpp"

#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), numerator(t3).str());
   BOOST_CHECK_EQUAL(from.str(), numerator(t4).str());
}
template <class From, class To>
void test_convert_neg_rat(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), numerator(t1).str());
      BOOST_CHECK_EQUAL(from.str(), numerator(t2).str());
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To check(from.str() + ".0");
   BOOST_CHECK_EQUAL(t3, check);
   BOOST_CHECK_EQUAL(t4, check);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   check(from.str() + ".0");
      BOOST_CHECK_EQUAL(t1, check);
      BOOST_CHECK_EQUAL(t2, check);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{

   test_convert<mpz_int, cpp_int>();
   test_convert<mpz_int, int128_t>();
   test_convert<mpz_int, uint128_t>();
   test_convert<mpz_int, cpp_rational>();

   test_convert<mpz_int, cpp_dec_float_50>();
   test_convert<mpz_int, cpp_bin_float_50>();
   test_convert<mpz_int, mpq_rational>();
   test_convert<mpz_int, mpf_float_50>();

#if defined(HAS_MPFR)
   test_convert<mpz_int, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<mpz_int, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<mpz_int, tom_int>();

   test_convert<mpz_int, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<mpz_int, float128>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_tom_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#ifdef HAS_TOMMATH

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/multiprecision/tommath.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class From, class To>
void test_convert_neg_int(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_int(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_int<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), numerator(t3).str());
   BOOST_CHECK_EQUAL(from.str(), numerator(t4).str());
}
template <class From, class To>
void test_convert_neg_rat(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), numerator(t1).str());
      BOOST_CHECK_EQUAL(from.str(), numerator(t2).str());
      test_convert_neg_rat<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   To check(from.str() + ".0");
   BOOST_CHECK_EQUAL(t3, check);
   BOOST_CHECK_EQUAL(t4, check);
}
template <class From, class To>
void test_convert_neg_float(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_integer> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      To   check(from.str() + ".0");
      BOOST_CHECK_EQUAL(t1, check);
      BOOST_CHECK_EQUAL(t2, check);
      test_convert_neg_float<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<tom_int, cpp_int>();
   test_convert<tom_int, int128_t>();
   test_convert<tom_int, uint128_t>();

   test_convert<tom_int, cpp_dec_float_50>();

   test_convert<tom_int, cpp_rational>();

   test_convert<tom_int, cpp_bin_float_50>();

#if defined(HAS_GMP)
   test_convert<tom_int, mpz_int>();

   test_convert<tom_int, mpq_rational>();

   test_convert<tom_int, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<tom_int, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<tom_int, mpfi_float_50>();
#endif
#ifdef HAS_TOMMATH
   test_convert<tom_int, tom_int>();

   test_convert<tom_int, tom_rational>();
#endif
#ifdef HAS_FLOAT128
   test_convert<tom_int, float128>();
#endif
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_convert_from_tom_rational.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#ifdef HAS_TOMMATH
#include <boost/multiprecision/tommath.hpp>

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"

#if defined(HAS_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(HAS_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(HAS_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef HAS_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

using namespace boost::multiprecision;

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
T generate_random_int(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
T generate_random(unsigned bits_wanted)
{
   typedef typename component_type<T>::type int_type;
   T                                        val(generate_random_int<int_type>(bits_wanted), generate_random_int<int_type>(bits_wanted));
   return val;
}

template <class From, class To>
void test_convert_neg_val(From from, const std::integral_constant<bool, true>&)
{
   from                                       = -from;
   typename component_type<From>::type answer = numerator(from) / denominator(from);
   To                                  t3(from);
   To                                  t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(answer.str(), t3.str());
   BOOST_CHECK_EQUAL(answer.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_integer> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From                                from   = generate_random<From>(bits_wanted);
      typename component_type<From>::type answer = numerator(from) / denominator(from);
      To                                  t1(from);
      To                                  t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(answer.str(), t1.str());
      BOOST_CHECK_EQUAL(answer.str(), t2.str());
      test_convert_neg_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_float_val(From from, To const& tol, const std::integral_constant<bool, true>&)
{
   from      = -from;
   To answer = To(numerator(from)) / To(denominator(from));
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_CLOSE_FRACTION(answer, t3, tol);
   BOOST_CHECK_CLOSE_FRACTION(answer, t4, tol);
}
template <class From, class To>
void test_convert_neg_float_val(From const&, To const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_floating_point> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from   = generate_random<From>(bits_wanted);
      To   answer = To(numerator(from)) / To(denominator(from));
      To   t1(from);
      To   t2  = from.template convert_to<To>();
      To   tol = std::numeric_limits<To>::is_specialized ? std::numeric_limits<To>::epsilon() : ldexp(To(1), 1 - bits_wanted);
      tol *= 2;
      BOOST_CHECK_CLOSE_FRACTION(answer, t1, tol);
      BOOST_CHECK_CLOSE_FRACTION(answer, t2, tol);
      test_convert_neg_float_val<From, To>(from, tol, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert_neg_rat_val(From from, const std::integral_constant<bool, true>&)
{
   from = -from;
   To t3(from);
   To t4 = from.template convert_to<To>();
   BOOST_CHECK_EQUAL(from.str(), t3.str());
   BOOST_CHECK_EQUAL(from.str(), t4.str());
}
template <class From, class To>
void test_convert_neg_rat_val(From const&, const std::integral_constant<bool, false>&)
{
}

template <class From, class To>
void test_convert_imp(std::integral_constant<int, number_kind_rational> const&, std::integral_constant<int, number_kind_rational> const&)
{
   int bits_wanted = (std::min)((std::min)(std::numeric_limits<From>::digits, std::numeric_limits<To>::digits), 2000);

   for (unsigned i = 0; i < 100; ++i)
   {
      From from = generate_random<From>(bits_wanted);
      To   t1(from);
      To   t2 = from.template convert_to<To>();
      BOOST_CHECK_EQUAL(from.str(), t1.str());
      BOOST_CHECK_EQUAL(from.str(), t2.str());
      test_convert_neg_rat_val<From, To>(from, std::integral_constant<bool, std::numeric_limits<From>::is_signed && std::numeric_limits<To>::is_signed > ());
   }
}

template <class From, class To>
void test_convert()
{
   test_convert_imp<From, To>(typename number_category<From>::type(), typename number_category<To>::type());
}

int main()
{
   test_convert<tom_rational, cpp_int>();
   test_convert<tom_rational, int128_t>();
   test_convert<tom_rational, uint128_t>();
   test_convert<tom_rational, cpp_rational>();

   test_convert<tom_rational, cpp_bin_float_50>();

   test_convert<tom_rational, cpp_dec_float_50>();

#if defined(HAS_GMP)
   test_convert<tom_rational, mpz_int>();
   test_convert<tom_rational, mpq_rational>();
   test_convert<tom_rational, mpf_float_50>();
#endif
#if defined(HAS_MPFR)
   test_convert<tom_rational, mpfr_float_50>();
#endif
#if defined(HAS_MPFI)
   test_convert<tom_rational, mpfi_float_50>();
#endif
   test_convert<tom_rational, tom_int>();
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cos.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
struct has_poor_large_value_support
{
   static const bool value = false;
};
#ifdef TEST_CPP_DEC_FLOAT
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif
#ifdef TEST_CPP_BIN_FLOAT
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif

template <class T>
void test()
{
   std::cout << "Testing type " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 101u> data =
       {{
           "-2.37609908807915949996042688873953402912174184373388399043229539427530802169622688886435380890546981798452174137747437590e-1",
           "8.03406366226813589517543567844755380935198206635917017883860879215939165740799963435747185200486086864198723786516760875e-1",
           "8.60219386510802105228997694366289682807721120146423711696179175800635220710279361583231346318224971127450760223168489952e-1",
           "-1.36768951513839774357595871594675554406872039078811749027554673949684004409484639336417431285061889554892096426752261915e-1",
           "-9.66210139195431691033548069227792927999642647449593184440815029076272297050360196975341458076547426373476590671462150981e-1",
           "-6.12007278553856790723803948280976098970972124581361775428331444376106018942231526074915731012122426588769327127413045994e-1",
           "4.91927698740873688392439262912409276430264703350691359723802294639643655296838880236042651349290074585311025856549893171e-1",
           "9.93232596718899824059271235487971663771012607519717340071654721877802691370866768064059943491135925674950430467047724563e-1",
           "2.77789911520199551017947550534057049374212876971194676010301098598339529915403722848373365985645657342475739669568931563e-1",
           "-7.77955945956221239101360662190442739163791527953499629555756394261998892874934847131138921705713935365505245406994428077e-1",
           "-8.80676278306736581575818642341143682410874043182925227659938804267878718513212454821032629378618345485453587099696563832e-1",
           "9.54652155963865007116798560589970996367213754762169439269792747771200843006278637115722685610960738675814993576019945344e-2",
           "9.54658201427917718824191302196929158303422390793460018465335986921801519149657723689322277773550748806000948225466432438e-1",
           "6.44358700620889799575033272322899136331490664925359198096632560532437137894857803619177106562399406351419810452110265174e-1",
           "-4.55304635273050571206400777159475409897339683148730716647371922365967582339285347105376503917296765204188604297021364549e-1",
           "-9.97202532932553753622481171186283382950122646390227670693679248197349800205205290898290539070732778341271049474946533154e-1",
           "-3.17489525058325500707686194437148362752290391406825231198381521862930317513649081353670386166519524315810546189268634469e-1",
           "7.51160186640147504067744846462384089742696250681200524524912647858645140367792164416711871535116761744380912486921554617e-1",
           "8.99610194168373157174515848193119670768490559799348397680196213249921436405001710937402190319584272526657508442591319630e-1",
           "-5.39963892484342940823660554048696208293700871414984387094529796385334086703752106515008832585578915389731907422242902573e-2",
           "-9.41455348900839346761557896365239742769987576963330061702397697388879776230596944312519157729410022380228287314835345969e-1",
           "-6.75595816763857390859268297670835380459024839344154743310231115864242050771191159334664874097564054770066166961642073448e-1",
           "4.17894201894880415042381733708896725748531223743344790054523182948440843948904650988733732381978194392219295696279423635e-1",
           "9.99447981389824371458566861195586395552622718284098766856978062347139060489410032781030191080200904443096549587568037683e-1",
           "3.56640095868759075150409032448421838265699043643228482503057299699740924345262819242042067863780263400092250418388628640e-1",
           "-7.23065426868134142613141384486526262450487633432466529798821958977732347646832059032382447792655111641456570392189752211e-1",
           "-9.16988391192434436877664999042786024703848714036221388727578305299843547352325574309860356272561772723624753484063972217e-1",
           "1.24341855683226931265962750806821531283439413068694552738675989282017066737438591268502070364982899342633928417210588531e-2",
           "9.26624413643579136646620112107410908114766812511471130116341925013001661546817531064974089666536893346764523464250445838e-1",
           "7.05664607841658050248613256866289182754229289446384595719719495272020558391145537620968819401219414243210529013148958366e-1",
           "-3.79761093422301890838671114556341706055562482358183402807224298533060188038450560241345615647754569347252101282386222173e-1",
           "-9.99965058979463689113370264378210962384824970050865061898892508056811665771886385589295806419278045318841717598003331419e-1",
           "-3.95173919871548266286836251448043149039940610894391718791244019288314418437411707835924620250473697245151743147215758686e-1",
           "6.93720251624319621941983929806434090162802383400620564454074825718151625795576680427510026452063593762417421561201654156e-1",
           "9.32780816819880202610269817418700102084277332259524791943833699964920012022753227823298655560837271746316929623378078695e-1",
           "2.91495208658083070508005579692813621670878962971611104453227900103973434149303469066898102622556226584993895360896300290e-2",
           "-9.10191043170480685360743788297835112117551819731152897291272407935139876953384666161532187572493791297095784055525159185e-1",
           "-7.34513075127503122343910106816656237074878218180284276449954797048122379869002663646507706411949095015624141821039453971e-1",
           "3.40971254411713599427147477626159847871020791931107106418841144080445813896332252160005593096670674809345703079384115052e-1",
           "9.98752871506016936810666998588493462933191829230756181478046320353377054175122206889047094521687205093218701141334147081e-1",
           "4.33024359542714849537532946954507232835434973891665238942502273464321666207117525270650546741831354943253652514490075246e-1",
           "-6.63175408268187738636594884921931867786416057472876635147295424128144233911929585327601381618059327766986981109409782838e-1",
           "-9.46960160806563725719808910991708075372282242401645009270517113290439792088443109178772446465191984149998211903724560065e-1",
           "-7.06828182905581345108929510344440443421290640066613022421187316650733628538705972455891575947230299102119854983197703150e-2",
           "8.92183656127948379886438402777950080111433733329436790239129260607557296960582455582584117031260710927499215646838011844e-1",
           "7.62091330231640362984555508176991632755732840163230620595759320390970951235395195394649584713540498911356433919369698423e-1",
           "-3.01591765120371930643555588643712101466544136366607065361801475091335195383846047491935017919396438040414024941341524187e-1",
           "-9.95813515236177554177387795413035497724212540625760091518605741283184405719984044075159457509720410668598540884613985023e-1",
           "-4.70125959152223022135690700550251564040118601846181392455764893020377582359429013073566263451488554529709131439092909247e-1",
           "6.31483718775865440843182928017874708719203714677143270278178885379757350754752477512514449375355491054871712891789652146e-1",
           "1.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
           "3.87481045630097871028201331640164477694000480353342897357083794605539506785023570062767753819472037935010414476627195076e-1",
           "-6.99716878554812023132822640034166338740077082416915046841339368979161296335086955803240899441098534898926193252558848693e-1",
           "-9.29735101124991407032113033015438177585645722877060262785796302722011806301680288369763295777635760805579255008366302180e-1",
           "-2.07925797310208845709174899248298159909010721767168338004516304026594885686024530923209628704670627250569637267490913462e-2",
           "9.13621640053945104047985280883096238900189007462190433514805702721127019097915088259906184736442916334750420359005079959e-1",
           "7.28814716527795995795780587639833705107995825167970668466246348938821997240383021826681253777014938636567626203524137506e-1",
           "-3.48817863192357573536083313907744269588018702862402502601699983054718835012048372083235768555953613790431700360695537918e-1",
           "-9.99135337256258278958854200595331742602280601557283993231562055717063052179292021052372510863057206152466386086657442382e-1",
           "-4.25474147219713305654097901385832164424798803616095278869643928816776198489330071073326518019520590535564717523756486665e-1",
           "6.69409002349720857726983952566596052122726437391092096671257338244059819036586172017092390651026654050631669646310910927e-1",
           "9.44240747589054266930136705015787520728797286842746645573763175559132491628984502333043316023599487896169049499868916865e-1",
           "6.23417820549832676844933182722733277887833220127638406914080428946880981800946578131712749910941183940944526141109771339e-2",
           "-8.95928229794837090592434136137683839101829890460754766346170956577979909285084363961363023377587044303560652568203578379e-1",
           "-7.56652196635835430995109388017590459596111729342964992503572530290981857981790620732129221157071082788019187787999930361e-1",
           "3.09551461133309219674309651201007026752336319933918953736299690287371505733386433918863300129026763968979930342098019300e-1",
           "9.96542844308353945757715814452637400116215448012622700698887257177706625278927018059066920597035660000571997275705962011e-1",
           "4.62731465522276407764000677957978862104808823938378826581864482071733508960062598574638347814740748458034065235894523010e-1",
           "-6.37943500095315456672541800050589670140910744260281868746767523730582697622604545933849801882909439609368258115114388202e-1",
           "-9.57113494461990955768932962010819183910065445494138937651443249061391692258872250121438832853873660881630205561168895590e-1",
           "-1.03783175146302830356973378710923690121182237844646430783773333188328606275124873219756415071202025673009660963930966273e-1",
           "8.76685468012988943166112725030293740012198666616661362437433807594683780986916439696374569274720383546275206733493672834e-1",
           "7.83181178815072182812568575402104911406191663934571600092749188502783771503475038116599065276589122015600004250624262132e-1",
           "-2.69749743842835294071354429049113807280228918034124159074991560056663623624511602063409428877143567459307323934051784210e-1",
           "-9.92227004420417932443416371636723983768124774541445787394585828303853075015733744933294181104002649816119116502663362907e-1",
           "-4.99188570507651271652464431008309802023236218596632956064119419694573621896525872847587264755853127438644874992889777436e-1",
           "6.05374785886620830935500306718810628353011877048386199574451402773468315797082901705593423724389976967865835641164117478e-1",
           "9.68331080574540181354402420018944004334504868848934676984951546671476956051983469715128604348963016773169794077158289730e-1",
           "1.45045093347669933436797325432376656017480150281100519869038554695618054318368975927557872948037203212941966706926758604e-1",
           "-8.55926631706799584065153976496431313099942493164544290051315786450857575707615522517293656706329757352795226750189755758e-1",
           "-8.08355785820466703104647317116964786017731181599256098405978700298563758509572188640629418770593008092680980412866065299e-1",
           "2.29481541445091823694157468006983283649885473964756916206813927875661041834620526229807744443043682778028709792615798955e-1",
           "9.86195281084368344446227722442335005500018635181693920385626820970119467136148305491035657795704047666385553672680209923e-1",
           "5.34782415974986828906369231191245075731384342252264783019973387059318216570499447505623911253042567598873910043381675873e-1",
           "-5.71759181631212640256161075896307515511612057247572886814941945052483422285718810088660759708176904381865453799197101481e-1",
           "-9.77874107069129472007009478090869879295520839405452365411822873037906082086100232576241983901051327761231156641104065497e-1",
           "-1.86056181372276495846711248156316208757691570931906856005697361080864028851991674077024223201008430626166447144444086146e-1",
           "8.33687619660983803179149188531271900120055171980951416163724579833511897001564116810390933587615557717585362295882429826e-1",
           "8.32132482562487183916482822112362004641509381783438374175226355792137053285527706239574867923387554339582561002247202518e-1",
           "-1.88816490768820368180947188938258919466912959009058295775702554895970560887437777994365295452696990115940651570073217522e-1",
           "-9.78458105113103660973458641126689066610890753079836635611789969774219913050456840122278188955139015473252491612410972950e-1",
           "-5.69451448580118869157805059117807250106203230622762838051154208713065707949727035884250775206017528612930773233017928006e-1",
           "5.37154819650306918873973169624898539483418364490295996462663218848771864764982600193558748568095521886456306061269765631e-1",
           "9.85726070946814004698231423834505649751779161578718404221294527194525251740198034173542003704080544827976936213857653517e-1",
           "2.26745517700332138489400566746499809209783385009289423848083137846668382711005704387134606000570923556980021574851618566e-1",
           "-8.10006890365888881023982873786181048364505748637138923322482323010218991062084191379116946709356002103893071903481540337e-1",
           "-8.54470151393449484710948210543666267680196067632693416660536443330720708402601669617638569732848938319544250428600991723e-1",
           "1.47824914922605209542648603104533928946885824995208478684499907657728115943168395067575842431291755277452367320596435067e-1",
           "9.69028856602232134498324179654622883463820270279077886397861028881882684131282848087869087883519707948141915733221980948e-1",
           "6.03135714281336943093251136556365407562473924416812270469171432809743173719168209727199952532489544254928975940518615351e-1",
           "-5.01621542149055350065079347615664213658089623368745676779267390227688581807037821041573344917735076902116221444127518632e-1",
       }};

   std::uintmax_t max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      static const T euler_gamma = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");
      T              val         = cos(euler_gamma * ((100 * k) - 5000));
      T              e           = relative_error(val, T(data[k]));
      unsigned       err         = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = cos(-euler_gamma * ((100 * k) - 5000));
      e   = relative_error(val, T(data[k]));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 5000000000ULL);

   static const boost::array<const char*, 51u> near_one =
       {{
           "0.001103662615143147017601393734232421549156847219973314118949247990939859507971857976111288683988415478257878902917354105871236439563170045857810738102729287303674642020538722348587741395785016549139854168605590336633274890874911975139498047488076101124170425114828336211817830671418321600962996502656221412102902998671173649312277667706874059520046508702908872747388744526457997404065469953155187340837",
           "0.0030157041572432190019717764776322147049224887913331212054173669461673516770769148735558540290915754514269097799280330158745508542936966046640795712691698490758472574837678659161855207596563250546269614348515005196657786359646020537231301121492728577410212550350070502426482802490452572415879214994201864402901595309726458026672888041860289772080407882673424767232857435141510615538430445535588448032261",
           "0.0049277346741750694119109616231402901360500185022482787362616412856233338679208830974124749830793778323997684640684587346403570647040211088376986993615001420565608501262335822815041623056442245053684626079448221530207757672939048030945164948521320401574074802966260975904478775314730002799895049652983052125151436511589335123254582883803928373794668948878049089088843407672795237410750365571990834236348",
           "0.0068397471757112108044544339281399968563253858411528016363900245610068161564091499398024110635089866212789583403491711476788985949178019078796740862827299289838108117219486357027460681238178010067475221327133396780718266880540272936860185783976937569903778160170225166328920201699827472893824363838439627437187765159770262282930293057633886299749088561182830982345936603553661004526800797082995898813903",
           "0.008751734671690018552720976028788304981263251327799787402847843531098338033456389098956160956160597460869666211569183483587979772678557230743050583975270977754518475970489741156524119378847305446845331098526962579804361960647344836744631465315238254178161716870409320747176674142306881908614436607977326507761331050644035013756409444911127742401762647885817361924274132830920030936589562922803846509607",
           "0.010663690172041286306192948782895990881227033104763005629047563262531418373465237876680529005058533981010793759446966868628480908709812402179047774888094761104238131843239037167212206469894485599085717216855637620318723457013401360290343196462723174177342294339229792213396006286331141933952648238459364417067676760977202812721209681621184724443514062993874571816382775241753902032787099435678672474841",
           "0.012575606686811781116778815864446643746718166744927923785139233710240017201737625088406861185781739628293213436323314376708933534933748436720721568462267317026688561438144113855290140925120435317506169856461386623828941531577425811393721991195661429557079268566156800689149725770186985872449679872155877537432897653904213375816262709009448220490217917537801655330411526526290708967440087145630462068976",
           "0.014487477226190798137230457835664944872810802211308342685055637400305474021552028493778559102552025380880477103065187688337931713540557562373991431880251553620947836940726544553647739994157300967262941976933375115946629204615918888689039777423610894099269527633757403818072000860056651445780074486612843419789636984117740884711882675016016919064788076097669389652323393864660933705259163296837955978748",
           "0.016399294800535714798489384358524900105286836154421890562438917862501411947245037986455919696365301666112414890097246479762149456962809638588245466988584093380263545543023411087203351948681559905336010066900667101787138862856447778428938265451537422367650992162004154495705878092019403922006152498705687706013973674800621422751806347308220226407830977673540994341535381202679482907460136241543505771361",
           "0.018311052420397544372537858201001145083914223029622271478159852925692124442640247100336262041440360412392318902558295108452513123454103504516607498763863728284797202978975409264141138861738184468257576157204552383675442780049333490201800526935793000727771598103735596829143729912656158790924063286176336412427525710457367751437348230246446466833498557166002214984255422115833828533909144072330080184872",
           "0.020222743096546488827333191237246591760639730704704148795009602627175281013458865557238240830203973690492882935553111519759474835556686812553430134442713057622274348510526931333124437928482001301214776111358848026164688447150395879262705323533149853785508106018564787140458587165768350143018847840661371060583295055600185059031740386698369796694993301139380463919242175430688496936048982929502368583755",
           "0.022134359839997490880406060727014362125793630864951833270601574861700025448109186301755833862830343973100181180995751924514611578149687732808840212399134735559355116816700346196685057916461444889179117142807858883574426062415931319905031345377305247124198345242221848293630112578508459623098934259229893301963120289071135120089672338617200639338087265986570094025605269870532431816151660553037324591448",
           "0.024045895662035785157706623778569329505432699504171659064296747761761946910295074291838826981712792368282349553905175996858645967280135417577488810651594776626562252686758463813820791031580579721782251705600570838044158357396828391251385978824608388341556751951593319015721256942139947235672567093309227673005475237474351604086627391812539914665025071874865132198040631867741985556198082915821590691115",
           "0.025957343574242448364285479040344211549214421772336408904791690210449825580868841229728937909141136116652894475476991471494524501035809956288247010861464302066154254736425460468024350571584780489213056428098560686376999562953811729945811217829999284678155635497607933780499844559793793320393174691097636750027421158473345884329284455326733063073401001936304522649050748641723222539485352644237494855455",
           "0.027868696588519948373400137317728007608587427701668964330844960393232962659347088604492706251530487148805683505883152882204177723404307465324383408418716579280515871949790204586171885981761699066301009410176801635003961167315448162116236938093263170474354430610732127054993766008385425707409224417795873645410443727472246508894027549288331903202127478347028519320691939639175445464091747341289465807076",
           "0.029779947717117692140641616959423088975059158964671307393654571763491553590582559015283533532986018614029995854278748039155177088839414450454409571267110720713374288363670804692289394770804051182510495900322915294613479146430103948686457060129295537542317247965142780968717375277053102667416124807987527429828758851341378395347636356414345553353015296944031211364374602764176767114282660874356057979248",
           "0.03169108997265757234968007548831539092664261419258315028339932724609641378752993073240305448323210275610250474048387518003293691429670190316839718892647475151605557113852966925288722557261748981001717642661075734993748510506277165730472207647763678204813714194082852502621623007244214605646094787730992510318924772328958129857640953691466395972638014259980360897599169526022683004620965496473543834477",
           "0.033602116368159512696233026049065446239504816931754722314316906991719894135599777826750609185018647633748023602662568553364455253741994701511752478506175671449029859193583332380924298164350627023797218098539441228986492601142199774579432202424360114528105854714450548265654769162069979862894518829365029262734944196495563243510942310738160350648115273816371164862001848102516957052031698646996790510953",
           "0.035513019917067011716864665791693591701266221069066142988726516832036728613300457006403299601385922973285573124147669717618486570986860008564309641657943172757912451506572783449830586163814477502720341010870119231030511664725149033496023356743601581035789746158436049009960920433265660001864258067191594425969638702851317416487965304378219676062220223886417078628342731900948906319081697480745936074075",
           "0.037423793633272685069230163289099410548201460485083250584815890545695501760634737348027106921155349564805321222282824709072582234185849564440670000847571561359324629877368620222775856068569278590582843550096096627510109210574429458414697641703261368397349100700647508781941466979105505468662952228018391181441110331804231754679360190526351574820397399161022517352576803713854137820941977691824804918229",
           "0.039334430531143806170384413477273936914540782490679532559795199052084263353981243128408259086619593938946158294175465792633584421592350011455198124846778194417281005620258982615227234871780679327289232072858751285307955384102986030326321993554199425677956531006546270705693578070953933490084008156062047268010604414954653769711129551190023978078265436680151306319349753427763894284339669614362603225399",
           "0.041244923625547845099780771389235760645292527949481044094490883777921290140650504322516472637184803214130714431279474404434513167088543202171922178874118967991301744186858054508473413647148744260057423931033177973119110921967581379650616945061418716237102199971097086754171168500651650526166023618723542873290120298640370217463634503988257867984189842393302366909916756244585593509804376197012137137735",
           "0.043155265931878005673591620105503250213648422568500347993529171942176855000247082147052189275394127432389966427668413127665366489709229602926384588361071126297040547180622989395253518259197742053810419372452372506534313264090033740095357809571640645325965973975968081307185286025492280541542290934505383760407808393490207181258819590768103829347539943429968533891105456889889207923129412409325200337396",
           "0.045065450466078760596989313842010956972889269629840996618541471076456145341576346037140737554087089598232657340541865108389258265511462307708855932308284610805209084413460614598570062354088931179587984702006847566162492414964136182928014974554852612762940578089297583097434972291633301329615187665009664697057933900728259220674217919826618275818024987757805509580781060051826778978395144370327934582031",
           "0.046975470244671384601033063916347240271496301008030038885300525267985292259051299166038486168462131096926077920611254966322965395673221324506213593415263189667393727124978454125104192236004303056348320706091018781990803164595039969574510002737990997634364247271320535459089400357647302806652831431190979518269432197656547265417669309719787317687585776029758282182901563328846367691507505917911626458378",
           "0.048885318284779485470814703449342779874157141188272539012461507790598796169844054420701400747288103863351008593834375336008952419161297787680355981672505884405645257094616683497040471721980241679616912483788844007649447969703512155758482444019770785766752697959554691538291379700303132353876869628124563105576278585509058450081192711918856522653293896204836307264696289474219755720645459588331890558889",
           "0.050794987604154532871523976044438688478988546522275702591135165295075684834775069782087540212155311599924632216878717363279038406203747968637573994688146329296755023729170505930935028107359530042909822369245609091696704070694133386183688825674952803613566914142157159664703170379754943610785780639205752343103591085978554489192416588288410803225066825839880971435465232206429722600557780654218330146221",
           "0.052704471221201384879102044313723519214541830844294339002006150295000261803629777930668202713875629368914012613840180174156598399096984605842000917709330893871365961242812860633022132663435078869433262371062200555333508565564704972551921154864927879748108180002977668648111714062992755985320189721615088748697314805428967770533095416911693326757965362169171309026356339280576158225848771071227224373815",
           "0.054613762155003812122160305957618147686113745063989650607179163157398820817715079449268802189362998719256947035541552524839497119721884536865240705017403409053301625152685151644761334409897199810093505097528650897729279062117617766845257388412635800174656504897022571125534403010151970450307624961920347280823962725005822339087173498538012712497715370388872960900453285934131578336748483622553313648565",
           "0.056522853425350019441850338124226420404372628229474954730316461224029279793449121148941830155705856364290655296696008865349058650396297667951745639266344993911111272076019522476315254920931469406381088740392436352997178777214659473302034620137440843681809428909274912969436139312159105442160243076856936138443854294531618433726198293972487505166088883354213979143973990964298454127970039847456893860203",
           "0.058431738052758164976379864942430396555977098734986011309321413104802080798824039565461521608355122102022725461220269967251619843394860641070621951433765763369761658916816880868188275032453137184211673934079277285593935159478757148621410070196500221526968060556586710920750728824112282461003224923995158937905479480579208549847478185757177039153501786271361921802927586114942206193581554801605680183774",
           "0.060340409058501876576879058406717550375449897922866349024612531373677724965692896763451690034750214807393086060232183962741893455630800282528706094634312497867863194252914455062127544671909424505367559503649890477570116767021509485710626043408265846213906257952113003324887350087083283630715857354116849013376841533857321740197047217435805280085872071354373524395263864933170034771001607559366437835689",
           "0.06224885946463576546133123915706193746686049729742751789281333411875145041642253752249398319274836506892916659694331849766284472811963607782488993959669913942440995816339529777656740297867471191540909520680122909159182411803441391065468297111274482089347737322313334144161837035757661055283810143238846811496286086926075008068489724098160672664550444107807861952850135669761489736449089327971794824585",
           "0.064157082294020937013292141108273585068933185681722806586173136512969086561151000586083228827704474922133659368208499428517560937267711287558275856325851735527047525549135602809953924346232393575354505341516408877034795144989051337120442048812961016500803766780090428411925756071299228254760633032932651170483895163866111455935100454818941073761804284777739005007991141161823471943803047351369535073521",
           "0.066065070570350498632132342303164932774411476452581548988386145454309844170784631219900687545375669726062411278210148833761887075889382631711319762066717518842787273543143969874177059386003262516941215168234997245420735913778365997498382320917159517052861653706668051150014889560865161606396037665048820655743861710636504450723955435275019348223982732095398949832565423361714391500479155224225613768011",
           "0.067972817318175064541548243754498015429928588516517183822313264446879635682093113384264993280408482780193047687370305892309106748875519486540879020142902362307237689684697063792225838111742241714789823601251998299331254097504567214769822096812914869886418586879378868131071702869283011709161582762527864014863950459121468893761825841337802563429112718615110803469902519051203360473993644451463303576859",
           "0.069880315562928257463098098362562671709183706398122146969098129179472379455539984270317889382725678551314678030902515782188203802362460214070192378666311369730755912670660970378408284876465192356340335277225457776091515934608751710356445501169982098020701963512215973413220903547301855847279762573955110834619967590588317288171580291576756417265600792610005176888567344924086299458709493921684370833814",
           "0.071787558330952207061531053207739391124226218288071373402959685303573894071937999096931283415397385296306228484128726125223568292760110763075739612174182840148193517540379302896938375357744754831885570482299802985278525692833941172622048860945698352794727105726197891701070706523197225463566498764869186174536278875440544967870368440256565084805804998877012238900798874720340885805165811704445925369809",
           "0.07369453864952304506868897057861922170414313661538863465614770246556638808351254050794164760581857499175318127117745597595046399453737415234966090460819383278338184265518294393589316067434296307320873514873375534499000895507092920123162793722742278902956263178675873980121089525814840115300730124457959632013360479776554262210801798434607194598511786777350540581826836696200671400628870250659962729555",
           "0.075601249546876396992772935963040077834759122887264324876826746597298507042570795315940378957369646666545616927930046677179646722187557860442506025110541968257406052679604681892086517951648112201767029044637142334937786145563391280677987040697732028896674786378870229133792190093646530752257521390201161387698590619925316803401938362974478273195688740273778224688121208296858072701246429755713258468481",
           "0.077507684052232870319778844857360483087988665809157375994805235390695227945273826842335916971262245322463861698987988491433092759415620685754813456247989287157909601376742141647886684380473379403067343977633347655683745871434202230624968375294472571053679501320680048739346844244553807193670436672857163839591129928936603341033670518982144557944158002407590669543043048232580344768659176122645763500513",
           "0.079413835195823539113919284592789131508074280056913456617148863190077260584186476150168101766032692499585019572300009477107342325731806003539645749720998260074894005503243715777788187754550286488316966320623707403846973934258796072434720381188302956748572794547906591019552569722211941807674118070825610462581312695693650893380241875873254675082431417454526920871842555422162216221640850141209989864308",
           "0.081319696008915424923862092389736899811819511475112310887916890436246797704730704673729056088324784096921353721791055102563812592375189346816348952621603248827528923433998597558478366712658235656924601774921095079356565867874041683517103417362062033545480747089630436317004907748679995334911923789802669273406449877710501792905734235548100216242648355048174292232350538531258791292074224222773259366265",
           "0.083225259523836973901629476483826882570495097409722948211156651871411915926347698443317606324912095013846386144848076019334983060323996364575622231284156371311209803383868297666027142776492604713451401116304951916037351315288808149328656282592946622481248077426878390562084748274992526750980236994304445617883874613002677387890383751048690275480465558930319669630406765794141303531112767626885032234711",
           "0.085130518774003530041015433371012162123590338565297712899451572274044870858132401685294989726432756808251618198809497117031428754224182463768189333992610411750324249283786647605964593556580841488686189374310703328490638378071341189999989736919850819640255203388192531225871093915262442913255553964348789674386732423763999398384843950222967487918049677831350991752153610543052586794779289758903475438463",
           "0.087035466793942804442393380943589773874807384137701777807755858606555806090045313793349743667697666495784828540247587627381581545620918795107877715086227932192756144780086856515641298195558204484728115519445514732755572178929839231921546119143469647706999890259163924570037168105911942268212237224359201159897493303064534985539474450028748960081579369980283792804593122976296597796047722827878891322393",
           "0.088940096619320340510800454481897179643787714504988904779549430422905882044782054375828906100456879992313640144934242418129400679706865644316664458061953684856607341811667576418163339843372041295322709797007871604740491453013916791024918954258557372755707588171502529270934617054742841996068375532958173787119651672031238405892943090742861150287144368470297356054911834742041692715934237148148936307154",
           "0.090844401286964974994199780075024285173534240616972938308566124002318176156233343333797652771250228033597767340846476094210813299723066344955542455246897302945908336756464582189829335315055318509171623072382573656172991307091055717376996812421994002305994837615827430425975713541786272473174908117299253875064746541808768776888139494200307162476704515967971265236163183394620211890252072718610942571965",
           "0.092748373834894294768837248013614869545920040757666771889792264347367335922283987944081370356939214799510822558638935486112190359701790662792925773186897671244831971450474952036618937833706899006048469791213129922302798462311426294239282200248625552430083292818594731518350634587677158329361662244008606299358410273467156168469937529868888478684257396004386633746334360279683178784117372066095688934486",
           "0.094652007302340089278624856973167138217258137565762699413364163993950641989798336903224059425798872308451866930780842878435503832366316245159154044350517727312654980455290163514021860802028251981954724580292247887851185639950862672925642859475325430465650514258094310141033116303195908372018392349011340787373492402788283020594141795669947097771918542864972570255253465754192708165241608041715996375567",
           "0.09655529472977379853549858833033074225823562054271495313739665642376685099661084023094270272485976247900824483810911634635819558334630910267353320029261330296977292720266655308513559530586843550229208517388789783011887450865488554143475302590353915732321663418057567573042594801866258948380684000769091353165879953111046260532796891917772727185993569684246844052518121013717183610828519193371796413317",
       }};

   T half_pi = static_cast<T>("1.57079632679489661923132169163975144209858469968755291048747229615390820314310449931401741267105853399107404325664115332354692230477529111586267970406424055872514205135096926055277982231147447746519098221440548783296672306423782411689339158263560095457282428346173017430522716332410669680363012457064");

   max_err = 0;
   for (unsigned k = 0; k < near_one.size(); k++)
   {
      static const T euler_gamma = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");
      T              val         = cos(half_pi - (euler_gamma + k) / 523);
      T              e           = relative_error(val, T(near_one[k]));
      unsigned       err         = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = cos(-half_pi + (euler_gamma + k) / 523);
      e   = relative_error(val, T(near_one[k]));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
#if defined(BOOST_INTEL) && defined(TEST_FLOAT128)
   BOOST_TEST(max_err < 8000);
#else
   BOOST_TEST(max_err < 750);
#endif

   //
   // Test with some exact binary values as input - this tests our code
   // rather than the test data:
   //
   static const boost::array<boost::array<T, 2>, 8> exact_data =
       {{{{0.5, static_cast<T>("0.877582561890372716116281582603829651991645197109744052997610868315950763274213947405794184084682258355478400593109053993")}},
         {{0.25, static_cast<T>("0.968912421710644784144595449494189199804134190287442831148128124288942561184523327264655202799685025510352709626116202617")}},
         {{0.75, static_cast<T>("0.731688868873820886311838753000084543840541276050772482507683220220750082501569499540967562610201174960122884908227300721")}},
         {{std::ldexp(1.0, -20), static_cast<T>("0.99999999999954525264911357034690133684385823577463126432241468890539365027135494672267164697779879113636143901797362388")}},
         {{2, static_cast<T>("-0.416146836547142386997568229500762189766000771075544890755149973781964936124079169074531777860169140367366791365215728559")}},
         {{5, static_cast<T>("0.283662185463226264466639171513557308334422592252215944930359066586151456767382702286176981668344573238827368717546699737")}},
         {{10, static_cast<T>("-0.839071529076452452258863947824064834519930165133168546835953731048792586866270768400933712760422138927451054405350243624")}},
         {{8.5, static_cast<T>("-0.60201190268482361534842652295699870029606776360435523539636606145572515876770619546025351418378467287262574566665150299")}}}};
   max_err = 0;
   for (unsigned k = 0; k < exact_data.size(); k++)
   {
      T        val = cos(exact_data[k][0]);
      T        e   = relative_error(val, exact_data[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = cos(-exact_data[k][0]);
      e   = relative_error(val, exact_data[k][1]);
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);

   BOOST_TEST(cos(T(0)) == 1);
#if defined(BOOST_INTEL) && defined(TEST_FLOAT128)
   BOOST_TEST(fabs(cos(half_pi)) < 4 * std::numeric_limits<T>::epsilon());
#else
   BOOST_TEST(fabs(cos(half_pi)) < std::numeric_limits<T>::epsilon());
#endif

#include "sincos.ipp"
   max_err = 0;
   for (unsigned k = 0; k < sincos.size(); k++)
   {
      T        val = cos(sincos[k][0]);
      T        e   = relative_error(val, sincos[k][2]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);

   if (has_poor_large_value_support<T>::value)
   {
      T bug_value = 12 / std::numeric_limits<T>::epsilon();
      for (unsigned i = 0; i < 20; ++i, bug_value *= 1.1)
      {
         BOOST_TEST(cos(bug_value) == 1);
      }
   }
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cos_near_half_pi.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_MPFR_50)
#define TEST_MPF_50
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT
#define TEST_MPFR_50

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/mpfr.hpp>

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<1000> > mpfr_float_1000;

   for (int n = -20; n <= 20; ++n)
   {
      std::cout << "Testing n = " << n << std::endl;
      T boundary = boost::math::constants::half_pi<T>() * n;
      T val      = boundary;
      for (unsigned i = 0; i < 200; ++i)
      {
         mpfr_float_1000 comparison(val);
         comparison = cos(comparison);
         T found = cos(val);
         T expected = T(comparison);
         BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20);
         //std::cout << std::setprecision(10) << val << std::endl;
         //std::cout << std::setprecision(50) << found << std::endl;
         //std::cout << std::setprecision(50) << comparison << std::endl;
         //std::cout << std::setprecision(50) << expected << std::endl;
         val = boost::math::float_next(val);
      }
      val = boundary;
      for (unsigned i = 0; i < 200; ++i)
      {
         val = boost::math::float_prior(val);
         mpfr_float_1000 comparison(val);
         comparison = cos(comparison);
         T found = cos(val);
         T expected = T(comparison);
         BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20);
      }
   }
}

int main()
{
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
   boost::multiprecision::mpf_float::default_precision(50);
   test<boost::multiprecision::mpf_float>();
   boost::multiprecision::mpf_float::default_precision(100);
   test<boost::multiprecision::mpf_float>();
#endif
#ifdef TEST_MPFR_50
   boost::multiprecision::mpfr_float::default_precision(50);
   test<boost::multiprecision::mpfr_float>();
   boost::multiprecision::mpfr_float::default_precision(100);
   test<boost::multiprecision::mpfr_float>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::cpp_bin_float_quad>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cosh.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 51u> data =
       {{
           "1.0560191127459844751259038114395241283965590525302917878166464679729562764239266483419824023679041866569431842053263976225991679105269492268050148624443706785607467750929028856273183654547152707568642275917435773104050171284580773949313906303074811586096214771879801872225500237540725592288167903987152007171391207680034517664218965133028298959753155835975555361514087618679892905973726581183754237665",
           "6.0577917650974496023981039346694689204850927958941226507775366589415588030232830758139222010716099059155799853188868489737439396141346120898610181630988217093945337280471788812956307352429914669334599644412036010014302812555700905490062030666482387008384856645533100266205122930455496234252478878949675888122615795451076521244771554025667181070733415815608287241160724578541982548132473721865287585003",
           "383.32956577005424506758441449272199796616394738942294350035763341369127219359132618750028176886177362785452836065735889720098699937365992620246167965376788963171659530350198190156275836547285437366012371175910490835823389352716981464503672749829183569550509561579181434088407652213421105693358960196044447948190823567291153397039759820680087749250557665869797605969680417240900163183563482342795870741",
           "180470.88335034971169904627554690213669106779370247753503772451628313223853228134148123711258586005038324156900626143047383382773083164188515409766952843294484598668304799186411411329575367546332731190431166613267871177008493921416649792646568096789971466064344922873643120446759328638447781504932928745974584136039698220604099816877847080168890581112550484205291341188894903342677757367415636409890558",
           "6.2781497954189513287619297175142770025826052476955600323495790530946900406209789437212923381830889846578651793922971071825731424267985994598149826652782605981764572599129753631344305259620294513472869937699509893247230674850025066547664563263958672029867981296029855675095947587305949634130736118694040608573981560192569935477462121110619100122692626135788198431038121227062383110684489973794745342204e8",
           "1.613783114750852113223226710244634574082654363427931747177970610142560035434819323665197978270795707611590961019502906079030261920109649748962125930850198625621792763842224096823299250338750953491004408731082880660125641628213970297576817341593254767125933119462446651783267917469179893016103516988279473907996009458208097272806046395206212403180775656514566222835047724943633607736647735739948551096e13",
           "3.0651210048650948869531196671342477415226643123350617715268971834881834615138925908518703584506447138436613632341330640449725016173384960626760387649747643297918807083363913015806893683786389067836005832038060734248371426886808175554210317756018846109627572546314172492701544345965940408777570519312837860014177872754358662463423939942202520475422342889660750666147940146262635303938752019875745307992e18",
           "4.3016893602106215864771434464025735547192956887050537014696231526954713331351791376069506688795159316625154458115179050297716224800318064110052445970764898870599885508391064218065806885129697936678362276766771902589638957537168339190488273555753876162633237990462617955892238424402124353124736879474651977422350856642986446591941163073842974714357745162365700428610167249762162775568692443158879770006e24",
           "4.4608685929681360001024935791890661655506049487122331222491789277138083092507844933483858468341107613657448783043064935174812965310544903547535217357996429824403225005261842368679242972243707736489629610256554995236901040773902962370130989883960298987808008001651650799892267761089302132749037069497452309074389846493140222931714618697738906019885122076310868220596765753447232222740129365498326869428e31",
           "3.4181315955816806472569357441100390029536003312981931954091744304974491527743601285017456624487264929971022746516079644284683284072159616291298593217459064246713801084801182706805865477209408120733740982340972570739267039630582468876075574706187115643861449939429503730606743466086010115127464706315791765264572070452800816054590653675962889901898843712936126341807733200610910325052666512334161414655e39",
           "1.935294628272790810141453021278524976364077691905248015888165919062516673344977091262644262832934899971824373171672037249361491844419302323587942915162859665992916625636813244576210109931852761921719987632855596663907494303248513195744818730879742963301327852160193919379798462926667740594397712731448572837824802330973561570848397758210619453310032286208701226098998940360395267237151018055781640126e48",
           "8.0964449511890098565841496436016431651692307764702784234901741408135381374668439020986470675941110923614446905696411023621632714191313583360826598468217983223558130595633054971338824192327248896500337050246640453410159732184419096917171044075711156867804851018388576371530520943696439917673720450911725466781235347212700849702742625663288687644090935756560022610000629006347244369388824818661974220426e57",
           "2.5028257092625174549175008952222569141816383637904981644379473858250736896174216539673733521627607209322019413420937570273676341726636307131078699799472622998437404149614292337267153201903296102921815263736653035269935857816159086496594269187082442244280898258397047045746728729079796167987895368614037770286371191530575814695859433478185016171380286325273493350193132538052551497175771289873181595171e68",
           "5.7168370213792649967466315312864179662895170192695050789061362839510836418124645968032989149068311018994324517420345278843446068634292140996241291031113395887832891095928020095581695527354104986223411349657526888924224926675682032043363279774947976053895819671003276400297758359779703605970507328706064692923481168676751999124073697599262277247814864401196929320497117521176016017349797292609303756215e79",
           "9.6487261169670031207955841899729386502708125098394777808615183927342163909284025992243201020435915122698808649711566042372911206942311277943247994427354130507790526857797833309691667380623792736661655695464087154725768656507603378053220212067894914686147301550764045337512361478831034999674296837635744344039906734109560908793921568633128400104314078575159786136202769893309913175064586488844295321363e91",
           "1.2032977660238608232537005158851668311089986235965463249220377778638489972355974848209035082333822309902237165042868213438627625544096344578102199846440476859557339736747791529782018329078191477783605471526120466881600981869890379917878811691555316448842731085218988710571211956972016424649758226606500603194972966032036214213759991156778846329137084961334557845326183588274571457361004704490747798678e105",
           "1.1088306081278288754492401130897590262404571813281460605683836139669281218442501421935533170636990866165181664561596333701204545493730707210930818738817252706131805203538144119244917164949716209095542194899833868499263375700313934257155601275526921302332118009966650991624878227108265079219497366770219141098050965023005919495048022616553249266192057652205987267068584616625670961423579715954410508985e119",
           "7.5499880591625965663868042832675300901799245732418501707646792135512053284835138294796976048691668315442427834949618514094329533376442442492757936744857569785450769927581802961191319878260712808001736830227501518832554201816224207300614310712430470538022948957433004829725273067921443635526965673971412049693552004259820173389681647135125678701502084190660111860351299407405357314966388044340723077086e133",
           "3.7985363580067976240250330165300706958269826851549371732460220923459822809007918495780412109700378352703982899561570150646963751463572075768540297484136809462018052149545042828665345287117150392150513078663739946623681053685054650372595872914400423446635806806461783139586204378680585507446218544068845246753010850565341852111017728985713047360191412931479535524815646071456825031827933342626130249175e149",
           "1.4121319341572581270215359848706630542776633675711529687593487346259283960708095601494823112486631023721124235640943167173029348028743563902367757599140008654691320430919753414890689949599421028277624880392344132646738394546195638261279687543208503932172926275294218429086816560213399180179494004109164546844899632385177835442946174689070525154077366030192931540897742543089509897490703511310531249977e166",
           "3.8790307719997974510664339744260233373881096199933152202662556556779783775106563986911859526413282055258612522499767709123313205863879946518297779104337686883587019222829967005608205535314284003183828513113021722123872387036435113517356676447376715595408179555267871947671679098986651665719279348025058713817796876795915844151719103197410787508530261619841035613531488383930867055908047961915279983259e183",
           "7.8733605373835840397434523264038598405672829925651165847065668324385430746087633348848905637835428739401439679896923081980364912472282573695612463537585283007941057172128277340402716645674443632827653710173742423648839359547777694778576675604645880219833375227941998426325886558435214355022240854563558864080627758653439429917072753785194675103766900514602432580639079224631229479607396935864512990879e201",
           "1.1808262995038900942517891457926200063018079695348469762725520377876370005771518954251015338402886097689762895044056273430051256244413916763438966705458118354189107806216991150264176024521937328179762640422127608560103802431672144866013216405157197709788484197720057702118788168789816074560208078260433548283881535909071116553897893659656781376448427981358955547508806938614921874867135186509274509121e221",
           "1.3085817499987842655130548827168955655838432140245228169691892267707778790498773914833199368916114043966197329562444577848635313938483757629541576533880917215885485474416704968999200090496252044959849927443732134176975867869986011315975625868009065373046224716063168977788103866885720471095547385342868632018951910603936835789387464412366605713487321530237148912677199033012777178113821791621549557963e241",
           "1.0715308148006899161903881353829644069217121138682658034413051575604561649576261428568888094218620444635013220705511245290719605273316790249367622122178650529000528086055415007045458486410501636380119413632657994999412652188430063128470336817401482172580366374079331295129200936246446347832380606353293858222758687479612927181530236387227215663399410099251455256898414199913458340065553949424990477448e262",
           "6.483319651006309502237640505955012384293570932602353784849377890534620180296272226076424490097577093511886503973590409376477611667988893542117173598716788837179265384921201772013611631892729250835822804494742316330406688475091973437669111728949960922002370308207819760146543720499389938855072810566961589413895110830251224194598788696990065693705615156654866578134664648091752361824241438921952031149e283",
           "2.8985391304542768293172709775230767981477721528885408305355619530690119426207269563049756824939397157221877775531212262059946098575425050827283362457005503261796116156917077778477251551070762614233325253060283603452216492681531839154649232080928787066338399915850327381614672456102374248950210248266796072457623370079195574322846594267768883120374288952014885152055438195794090975578878933873824774214e306",
           "9.57524433627083921372674145950563946532138741951042299439035158875449060589509856903496678820625880407684156184675763001790613289835869844325821965070261880894138207436003366195024403902162467929095155787852409710735775347490909311196315332711680552044467458169615366116872469435840608534489425322247278926672059747911266981024366989976214521515026692183039600169984107883592297128416659318858313127e329",
           "2.3372734503362369375381009524197350830316472034721759761797536237738670471009423543542251572488229045699598160834162677357730620072441755506075897500940629883044875771104686291523502165266242030847074909362622098365719455332359938746138629161304717385265309980898079489959955157644566232440805137701071311495653330606071611331941246434767948905863368638163788562679785940566685500460815077065003612487e354",
           "4.2155879126937199240969909448599186868484717887298729605150033299123534992857332918168135230843738695925698383815575417820480732378749635394939513838137876524333991937836847074991505476867647762082587225838063325020413513077128321581439429001485977751765798011101092072613053687422983352140468569171564773941232256057064161142341661775359191159220450305300322654184921617310753474842253496677498824723e379",
           "5.6181811613375701248970224378256740494692066242437602652469740512738297599235414593999616891945156186827736326184687322137498447792007445397397290336810468925670064733464757082986791232916898141597610692740388799796632396708149027243436859752526805112778790645096555770227809873695589969805678601106157556386974221647669590827712353133603091803570183764883405340587430017053183637835511899658145649708e405",
           "5.532511069282205350923830187073466127274584467195468607886763750877294392993663821432158885753563495238131394373865428654052604326264330104646257659760161386620716716703631608643312613245804625511813964275109451513736558514977338129201153666764317441936156609643185133981728847167450887861106642311329612564652645663234240748195490808151911497393974690166034839217817023634217121406163178148652748479e432",
           "4.0256666306761331240653217136731531623017017695713942917027851762705346357330788586411431378972009980532310757689380174461664677676028378924382554201434975574729861177781849023768222381429947872325368088023224591306630434887529215459580760863075907686248521168590309636468448648513752893851767315693469638980874648457114335557202115472595647478331668869318302753802858726588719006447471192697846325955e460",
           "2.1644237346681663424601781769159797919834245365230735589058796985974745594485988855971413936820871935714602237643458356241187573307428309041919648027960168541647193436225977495680484218384107820095589356463058222584008532497069179993678533431131233629312850771528970443634604290143149079209513868130585713006080733488491160321145735562062411305931183571279530201672366980412430529846635995189699318073e489",
           "8.5987580981195983662047247216936066485731760315371506386077056691409579856014763032619539539935299716110411688793466397984311640631361934500807639285587334983206556915704635831992012926186843826981296831658998834850783404713050829093753126189556625095994621605300047199962332098857236359801681157419606676412198783092816364336047306243999363335004760439115355072350465422891365411868472688286678516314e518",
           "2.5241673163187127276134610716954724162270290228773641734420864618245211926017624829840685860130579257772126398622324109858115624706486522844752512951837805396709793171502497523431473021570806024043139443284538862368635312799539108264084028032731295487282188616820261689634926427135060887942797635147693849950058672753458576476491733064455826768562371858057444914175251596852571637211466017938478085247e549",
           "5.475067911823387661325942057081957044927796274441278042805014835144678321092623034147031518807063234976073102574257079170283458172046752719724152941316842521196069804425876507927418423409523739261726681120662097159943049401039490818332686968135012747332468921142470970507219403290422458185430415836291605355383658657658638112408092789126678938878667507151950931633694006471359998448912249374833586727e580",
           "8.7750549689950256776639468724574158629603320014390275681028674550826357080136422399476213432791376656222763800628593282303459051561266270006921840049305819767639184391149913915312831894296821356222752594264134130151457242713539248421883837353442181724530706933220158507240760325182068001553294949268596178418634164323874971937997072367419479635154591248667559627811893588163238012665671798461211917208e612",
           "1.0392000158337773273751156576416024664653679689973856373456304843339302977923254238376497044027728158058903302390909588333829463843362779584402914847447592731182614369968957680281500946805571235013941407979569788567794900810257154433592958167545186687137810101848000107335074486050959387974516414654638879740966175786016492797845169374594168995878543584318334800124941205910589727264397237600733483158e646",
           "9.0936326753636727240574546678839170665019169110943878894933093211555976995701468041449327370073681898690638466136204694745206283652338526673125958055131610409923286526192661778126811265116493171283319361595267283588121098349703951929669281966675596890266483864217591555707552765565756842701056144290075867893520379419521775913047964393758374891516340929062076304350159966063972713118995033247759001609e679",
           "5.8798281636930489964162009429009257867906792508058801627042121953599912951265315933723440185825519080102988056836911095299854840387008575164090793635997912930561430335216151607097220208013034399895832350235280120270626904356196935166701773768680311063264380891331021514518757839220818506905997847228783439015252768055166165941582030353226255576433910936297965207260585437762430381969160714956727596198e714",
           "2.8091881292911108404345975896815558958477835260737794579417284512413473388968057587088555041266297486841923628702282019643659456724373332519583025947015025975126598748630623031951723754960589046233996595466021913942587558326660593063197905288573353559106884645285531497626940379800500474282446929237914568534665868703742731713632349090897884403966643055728471509474896855575286123275564417626861566706e750",
           "9.917129372597671132067673866739246238179742417231064062960232866725337575281938597212073697168000155027158148165861617400080837699968785505107579831803685516054837447325150388867488754170677228096524224392410232206238263933144338637103531441623303187445874039234973380151391274490746625993568552049954630793219419614845431626975962881182662815760423226111647056071831411664335144052772436215105801395e786",
           "2.5869027163543111121878679987081647715187872826677398475096738640583659800068967379551376322170347537454918190603891312949716382621902484616361664158953484778255247083652726854621059785392022847887382779010079407502679229021085320675903109573769331277413372272363218896397965662581357886739691376204316908974081821980432178065394228926767529685562155837452626029223937027004015040825450642409597700449e824",
           "4.9861251931207080923785686798881789193813879610842675205361210155894774686328710893906543682447029206928934967525495260314937837003448878215156341411477636831113484416124080974502217578408248150338565305116223944900839866528622960352723938548713319425798453345402992146078868053263606234074443024155243450623634720912438841022969909473424559262711669905282193529250216454066716533180418518228387188393e862",
           "7.1012569014339068241101751233953234216522840280342406520909288232012799547871960723719836516359548198842749536961644100550279020276709043358260853581760590386456213180291689322352732545965831405519844109680619067101311180959399339922706596098526969148981173519865139508665631317310424178378833370605922449094745510812618563813537347841030916512147874232760564378443782164868016244561788356251308121716e901",
           "7.4730215360486642135431754747074885377840195683583018254892502245011973712084221116813364423492802080799768174534590613188275471080608467087354983850284805514875889145266688973752185071777341375422809910165581997555433091939959406569831183459872344778707098094941193489061532160249775856426569696127193453339548371679229676272663084782830276508737129506676031759345288056484158647796152349867328841634e941",
           "5.8109375364209112227579654658730977030869454388607076903639465992296616832002964138000947668837140543325908222688655359602408511410663722770167244801973012245657865182739637159804595049180263175014778215232564251739259624759589953677661356104554831551073263668188283861123521688445132164147762321111597028523130093864153999974376790494383016372210442340324038686843345053322425194077414241243050491297e982",
           "3.33875955701899627718146291382268063073604182131575843695486667154496711979350813988644889979275310892951143249901398447859083674739840084454465850475774696325142148671937407108540250845900941142800157345665761403930889797424808979569550325271558518404559007551625637761142662107757913763221912282957681784053564387104062317729788737215450574233690655931888608424916152893688106181220341997128198692e1024",
           "1.4174672877823334709610117319768830739080734407353905145632612088824955720198734996604261250019291955883620333545750761619015467840567122066622229379056280064206319780047687015558007624774062399477328822231085767309831266032616053065858739373818651687128093335640388513396191118537181280334430292439188737524362269789272308905723812818882228503013875816702686587035844437102478263525616196832018321602e1067",
           "4.4466189016791091516801723880812533528438597080549410911235655611382010503145789286158745555771483577943662768773465284793798720178177605712848440200402906836390133865748188969184005230383247111166918721449908133920663776952786683837038180436264738937354101153867171804315769471050303182129269442292354388037298125177941217926845803005587166270803697433886463469168814941555804311717400657004050157245e1110",
       }};

   T eg = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      const T  x   = eg + k;
      T        val = boost::multiprecision::cosh(x * x);
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         std::cout << x * x << std::endl;
         max_err = err;
      }
      val = boost::multiprecision::cosh(-x * x);
      e   = relative_error(val, T(data[k]));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         std::cout << x * x << std::endl;
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 2000);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float.cpp
================================================
// Copyright John Maddock 2013.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "libs/multiprecision/test/test.hpp"
#include <iostream>
#include <iomanip>

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

using namespace boost::multiprecision;
#ifdef TEST_MPFR
typedef number<mpfr_float_backend<35> > good_type;
#else
typedef double good_type;
#endif
typedef number<cpp_bin_float<std::numeric_limits<good_type>::digits, digit_base_2>, et_off> test_type;

void test_special_cases()
{
#if !defined(BOOST_CI_ASAN_BUILD) && !defined(BOOST_CI_USAN_BUID)
   test_type max_val     = (std::numeric_limits<test_type>::max)();
   test_type min_val     = (std::numeric_limits<test_type>::min)();
   test_type eps         = std::numeric_limits<test_type>::epsilon();
   test_type inf_val     = (std::numeric_limits<test_type>::infinity)();
   test_type nan_val     = (std::numeric_limits<test_type>::quiet_NaN)();
   test_type half        = 0.5;
   test_type one_point_5 = 1.5;

   BOOST_CHECK((boost::math::isnormal)(max_val));
   BOOST_CHECK((boost::math::isnormal)(-max_val));
   BOOST_CHECK((boost::math::isnormal)(min_val));
   BOOST_CHECK((boost::math::isnormal)(-min_val));
   BOOST_CHECK((boost::math::isinf)(inf_val));
   BOOST_CHECK((boost::math::isinf)(-inf_val));
   BOOST_CHECK((boost::math::isnan)(nan_val));
   BOOST_CHECK((boost::math::isnan)(-nan_val));

   if (std::numeric_limits<test_type>::has_denorm)
      min_val = std::numeric_limits<test_type>::denorm_min();

   // Adding epsilon will increment 1.0:
   BOOST_CHECK(test_type(1) + eps != test_type(1));
   BOOST_CHECK(test_type(1) + eps / 2 == test_type(1));
   // But it's not the smallest value that will do that:
   test_type small = 1 + eps;
   small           = ldexp(small, -std::numeric_limits<test_type>::digits);
   BOOST_CHECK(test_type(1) + small != test_type(1));
   // And if we increment 1.0 first, then an even smaller
   // addition will round up:
   test_type one_next = test_type(1) + eps;
   BOOST_CHECK(one_next + eps / 2 != one_next);

   // Overflow:
   BOOST_CHECK_EQUAL(max_val + max_val * eps, inf_val);
   BOOST_CHECK_EQUAL(-max_val - max_val * eps, -inf_val);
   BOOST_CHECK_EQUAL(max_val * 2, inf_val);
   BOOST_CHECK_EQUAL(max_val * -2, -inf_val);
   BOOST_CHECK_EQUAL(max_val / half, inf_val);
   BOOST_CHECK_EQUAL(max_val / -half, -inf_val);
   BOOST_CHECK_EQUAL(max_val / min_val, inf_val);
   BOOST_CHECK_EQUAL(max_val / -min_val, -inf_val);
   // Underflow:
   BOOST_CHECK_EQUAL(min_val * 2 - one_point_5 * min_val, 0);
   BOOST_CHECK_EQUAL(-min_val * 2 + one_point_5 * min_val, 0);
   BOOST_CHECK_EQUAL(min_val / 2, 0);
   BOOST_CHECK_EQUAL(min_val / max_val, 0);
   BOOST_CHECK_EQUAL(min_val * half, 0);
   BOOST_CHECK_EQUAL(min_val - min_val, 0);
   BOOST_CHECK_EQUAL(max_val - max_val, 0);
   BOOST_CHECK_EQUAL(-min_val + min_val, 0);
   BOOST_CHECK_EQUAL(-max_val + max_val, 0);
   // Things which should not over/underflow:
   BOOST_CHECK_EQUAL((min_val * 2) / 2, min_val);
   BOOST_CHECK_EQUAL((max_val / 2) * 2, max_val);
   BOOST_CHECK_GE((min_val * 2.0000001) / 1.9999999999999999, min_val);
   BOOST_CHECK_LE((max_val / 2.0000001) * 1.9999999999999999, max_val);
   BOOST_CHECK_EQUAL(min_val * 2 - min_val, min_val);
   BOOST_CHECK_EQUAL(max_val / 2 + max_val / 2, max_val);
   // Things involving zero:
   BOOST_CHECK_EQUAL(max_val + 0, max_val);
   BOOST_CHECK_EQUAL(max_val - 0, max_val);
   BOOST_CHECK_EQUAL(0 + max_val, max_val);
   BOOST_CHECK_EQUAL(0 - max_val, -max_val);
   BOOST_CHECK_EQUAL(max_val * 0, 0);
   BOOST_CHECK_EQUAL(0 * max_val, 0);
   BOOST_CHECK_EQUAL(max_val / 0, inf_val);
   BOOST_CHECK_EQUAL(0 / max_val, 0);
   BOOST_CHECK_EQUAL(-max_val / 0, -inf_val);
   BOOST_CHECK_EQUAL(0 / -max_val, 0);
   // Things involving infinity:
   BOOST_CHECK_EQUAL(inf_val + 2, inf_val);
   BOOST_CHECK_EQUAL(inf_val - 2, inf_val);
   BOOST_CHECK_EQUAL(inf_val + -2, inf_val);
   BOOST_CHECK_EQUAL(inf_val - -2, inf_val);
   BOOST_CHECK_EQUAL(-inf_val + 2, -inf_val);
   BOOST_CHECK_EQUAL(-inf_val - 2, -inf_val);
   BOOST_CHECK_EQUAL(-inf_val + -2, -inf_val);
   BOOST_CHECK_EQUAL(-inf_val - -2, -inf_val);

   BOOST_CHECK_EQUAL(2 + inf_val, inf_val);
   BOOST_CHECK_EQUAL(2 - inf_val, -inf_val);
   BOOST_CHECK_EQUAL(-2 + inf_val, inf_val);
   BOOST_CHECK_EQUAL(-2 - inf_val, -inf_val);
   BOOST_CHECK_EQUAL(2 + (-inf_val), -inf_val);
   BOOST_CHECK_EQUAL(2 - (-inf_val), inf_val);
   BOOST_CHECK_EQUAL(-2 + (-inf_val), -inf_val);
   BOOST_CHECK_EQUAL(-2 - (-inf_val), inf_val);

   BOOST_CHECK_EQUAL(sqrt(inf_val), inf_val);
   BOOST_CHECK(boost::math::isnan(sqrt(-inf_val)));

   BOOST_CHECK_EQUAL(inf_val + test_type(2), inf_val);
   BOOST_CHECK_EQUAL(inf_val - test_type(2), inf_val);
   BOOST_CHECK_EQUAL(inf_val + test_type(-2), inf_val);
   BOOST_CHECK_EQUAL(inf_val - test_type(-2), inf_val);
   BOOST_CHECK_EQUAL(-inf_val + test_type(2), -inf_val);
   BOOST_CHECK_EQUAL(-inf_val - test_type(2), -inf_val);
   BOOST_CHECK_EQUAL(-inf_val + test_type(-2), -inf_val);
   BOOST_CHECK_EQUAL(-inf_val - test_type(-2), -inf_val);

   BOOST_CHECK_EQUAL(test_type(2) + inf_val, inf_val);
   BOOST_CHECK_EQUAL(test_type(2) - inf_val, -inf_val);
   BOOST_CHECK_EQUAL(test_type(-2) + inf_val, inf_val);
   BOOST_CHECK_EQUAL(test_type(-2) - inf_val, -inf_val);
   BOOST_CHECK_EQUAL(test_type(2) + (-inf_val), -inf_val);
   BOOST_CHECK_EQUAL(test_type(2) - (-inf_val), inf_val);
   BOOST_CHECK_EQUAL(test_type(-2) + (-inf_val), -inf_val);
   BOOST_CHECK_EQUAL(test_type(-2) - (-inf_val), inf_val);

   BOOST_CHECK((boost::math::isnan)(inf_val - inf_val));
   BOOST_CHECK_EQUAL(inf_val * 2, inf_val);
   BOOST_CHECK_EQUAL(-inf_val * 2, -inf_val);
   BOOST_CHECK_EQUAL(inf_val * -2, -inf_val);
   BOOST_CHECK_EQUAL(-inf_val * -2, inf_val);
   BOOST_CHECK_EQUAL(inf_val * test_type(-2), -inf_val);
   BOOST_CHECK_EQUAL(-inf_val * test_type(-2), inf_val);
   BOOST_CHECK((boost::math::isnan)(inf_val * 0));
   BOOST_CHECK((boost::math::isnan)(-inf_val * 0));
   BOOST_CHECK_EQUAL(inf_val / 2, inf_val);
   BOOST_CHECK_EQUAL(-inf_val / 2, -inf_val);
   BOOST_CHECK_EQUAL(inf_val / -2, -inf_val);
   BOOST_CHECK_EQUAL(-inf_val / -2, inf_val);
   BOOST_CHECK_EQUAL(inf_val / test_type(-2), -inf_val);
   BOOST_CHECK_EQUAL(-inf_val / test_type(-2), inf_val);
   BOOST_CHECK_EQUAL(inf_val / 0, inf_val);
   BOOST_CHECK_EQUAL(-inf_val / 0, -inf_val);
   BOOST_CHECK((boost::math::isnan)(inf_val / inf_val));
   BOOST_CHECK((boost::math::isnan)(-inf_val / inf_val));
   // Things involving nan:
   BOOST_CHECK((boost::math::isnan)(nan_val + 2));
   BOOST_CHECK((boost::math::isnan)(nan_val - 2));
   BOOST_CHECK((boost::math::isnan)(nan_val + 0));
   BOOST_CHECK((boost::math::isnan)(nan_val - 0));
   BOOST_CHECK((boost::math::isnan)(nan_val + inf_val));
   BOOST_CHECK((boost::math::isnan)(nan_val - inf_val));
   BOOST_CHECK((boost::math::isnan)(nan_val + nan_val));
   BOOST_CHECK((boost::math::isnan)(nan_val - nan_val));
   BOOST_CHECK((boost::math::isnan)(2 + nan_val));
   BOOST_CHECK((boost::math::isnan)(2 - nan_val));
   BOOST_CHECK((boost::math::isnan)(0 - nan_val));
   BOOST_CHECK((boost::math::isnan)(0 - nan_val));
   BOOST_CHECK((boost::math::isnan)(inf_val + nan_val));
   BOOST_CHECK((boost::math::isnan)(inf_val - nan_val));
   BOOST_CHECK((boost::math::isnan)(nan_val * 2));
   BOOST_CHECK((boost::math::isnan)(nan_val / 2));
   BOOST_CHECK((boost::math::isnan)(nan_val * 0));
   BOOST_CHECK((boost::math::isnan)(nan_val / 0));
   BOOST_CHECK((boost::math::isnan)(nan_val * inf_val));
   BOOST_CHECK((boost::math::isnan)(nan_val / inf_val));
   BOOST_CHECK((boost::math::isnan)(nan_val * nan_val));
   BOOST_CHECK((boost::math::isnan)(nan_val / nan_val));
   BOOST_CHECK((boost::math::isnan)(2 * nan_val));
   BOOST_CHECK((boost::math::isnan)(2 / nan_val));
   BOOST_CHECK((boost::math::isnan)(0 / nan_val));
   BOOST_CHECK((boost::math::isnan)(0 / nan_val));
   BOOST_CHECK((boost::math::isnan)(inf_val * nan_val));
   BOOST_CHECK((boost::math::isnan)(inf_val / nan_val));
   // Corner cases:
   BOOST_CHECK_EQUAL((max_val * half) / half, max_val);
   BOOST_CHECK_EQUAL((max_val / 2) * 2, max_val);
   BOOST_CHECK_EQUAL((min_val / half) * half, min_val);
   BOOST_CHECK_EQUAL((min_val * 2) / 2, min_val);
   BOOST_CHECK_EQUAL(max_val + min_val, max_val);
   BOOST_CHECK_EQUAL(min_val + max_val, max_val);
   BOOST_CHECK_EQUAL(max_val - min_val, max_val);
   BOOST_CHECK_EQUAL(min_val - max_val, -max_val);
   // Signed zeros:
   BOOST_CHECK(boost::math::signbit(min_val * -min_val));
   BOOST_CHECK(boost::math::signbit(min_val * min_val) == 0);
   BOOST_CHECK(boost::math::signbit(-min_val * -min_val) == 0);
   BOOST_CHECK(boost::math::signbit(-min_val * min_val));
   BOOST_CHECK(boost::math::signbit(min_val / max_val) == 0);
   BOOST_CHECK(boost::math::signbit(min_val / -max_val));
   BOOST_CHECK(boost::math::signbit(-min_val / -max_val) == 0);
   BOOST_CHECK(boost::math::signbit(-min_val / max_val));
   BOOST_CHECK(boost::math::signbit(min_val / 2) == 0);
   BOOST_CHECK(boost::math::signbit(min_val / -2));
   BOOST_CHECK(boost::math::signbit(-min_val / -2) == 0);
   BOOST_CHECK(boost::math::signbit(-min_val / 2));
   test_type neg_zero = min_val * -min_val;
   test_type zero     = 0;
   // Arithmetic involving signed zero:
   BOOST_CHECK_EQUAL(-neg_zero, 0);
   BOOST_CHECK(!boost::math::signbit(-neg_zero));
   BOOST_CHECK_EQUAL(neg_zero + 2, 2);
   BOOST_CHECK_EQUAL(neg_zero + test_type(2), 2);
   BOOST_CHECK_EQUAL(2 + neg_zero, 2);
   BOOST_CHECK_EQUAL(test_type(2) + neg_zero, 2);
   BOOST_CHECK_EQUAL(neg_zero + -2, -2);
   BOOST_CHECK_EQUAL(neg_zero + test_type(-2), -2);
   BOOST_CHECK_EQUAL(-2 + neg_zero, -2);
   BOOST_CHECK_EQUAL(test_type(-2) + neg_zero, -2);
   BOOST_CHECK_EQUAL(neg_zero - 2, -2);
   BOOST_CHECK_EQUAL(neg_zero - test_type(2), -2);
   BOOST_CHECK_EQUAL(2 - neg_zero, 2);
   BOOST_CHECK_EQUAL(test_type(2) - neg_zero, 2);
   BOOST_CHECK_EQUAL(neg_zero - -2, 2);
   BOOST_CHECK_EQUAL(neg_zero - test_type(-2), 2);
   BOOST_CHECK_EQUAL(-2 - neg_zero, -2);
   BOOST_CHECK_EQUAL(test_type(-2) - neg_zero, -2);
   BOOST_CHECK(!boost::math::signbit(test_type(2) + test_type(-2)));
   BOOST_CHECK(!boost::math::signbit(test_type(2) - test_type(2)));
   BOOST_CHECK(!boost::math::signbit(test_type(-2) - test_type(-2)));
   BOOST_CHECK(!boost::math::signbit(test_type(-2) + test_type(2)));
   BOOST_CHECK(!boost::math::signbit(zero + zero));
   BOOST_CHECK(!boost::math::signbit(zero - zero));
   BOOST_CHECK(!boost::math::signbit(neg_zero + zero));
   BOOST_CHECK(!boost::math::signbit(zero + neg_zero));
   BOOST_CHECK(boost::math::signbit(neg_zero + neg_zero));
   BOOST_CHECK(boost::math::signbit(neg_zero - zero));
   BOOST_CHECK(!boost::math::signbit(zero - neg_zero));
   BOOST_CHECK(!boost::math::signbit(neg_zero - neg_zero));
   small = 0.25;
   BOOST_CHECK(!boost::math::signbit(floor(small)));
   BOOST_CHECK(!boost::math::signbit(round(small)));
   BOOST_CHECK(!boost::math::signbit(trunc(small)));
   small = -small;
   BOOST_CHECK(boost::math::signbit(ceil(small)));
   BOOST_CHECK(boost::math::signbit(round(small)));
   BOOST_CHECK(boost::math::signbit(trunc(small)));

   BOOST_CHECK_EQUAL(neg_zero * 2, 0);
   BOOST_CHECK_EQUAL(neg_zero * test_type(2), 0);
   BOOST_CHECK_EQUAL(2 * neg_zero, 0);
   BOOST_CHECK_EQUAL(test_type(2) * neg_zero, 0);
   BOOST_CHECK_EQUAL(neg_zero * -2, 0);
   BOOST_CHECK_EQUAL(neg_zero * test_type(-2), 0);
   BOOST_CHECK_EQUAL(-2 * neg_zero, 0);
   BOOST_CHECK_EQUAL(test_type(-2) * neg_zero, 0);
   BOOST_CHECK(boost::math::signbit(neg_zero * 2));
   BOOST_CHECK(boost::math::signbit(neg_zero * test_type(2)));
   BOOST_CHECK(boost::math::signbit(2 * neg_zero));
   BOOST_CHECK(boost::math::signbit(test_type(2) * neg_zero));
   BOOST_CHECK(!boost::math::signbit(neg_zero * -2));
   BOOST_CHECK(!boost::math::signbit(neg_zero * test_type(-2)));
   BOOST_CHECK(!boost::math::signbit(-2 * neg_zero));
   BOOST_CHECK(!boost::math::signbit(test_type(-2) * neg_zero));

   BOOST_CHECK_EQUAL(neg_zero / 2, 0);
   BOOST_CHECK_EQUAL(neg_zero / test_type(2), 0);
   BOOST_CHECK_EQUAL(2 / neg_zero, -inf_val);
   BOOST_CHECK_EQUAL(test_type(2) / neg_zero, -inf_val);
   BOOST_CHECK_EQUAL(neg_zero / -2, 0);
   BOOST_CHECK_EQUAL(neg_zero / test_type(-2), 0);
   BOOST_CHECK_EQUAL(-2 / neg_zero, inf_val);
   BOOST_CHECK_EQUAL(test_type(-2) / neg_zero, inf_val);
   BOOST_CHECK(boost::math::signbit(neg_zero / 2));
   BOOST_CHECK(boost::math::signbit(neg_zero / test_type(2)));
   BOOST_CHECK(boost::math::signbit(2 / neg_zero));
   BOOST_CHECK(boost::math::signbit(test_type(2) / neg_zero));
   BOOST_CHECK(!boost::math::signbit(neg_zero / -2));
   BOOST_CHECK(!boost::math::signbit(neg_zero / test_type(-2)));
   BOOST_CHECK(!boost::math::signbit(-2 / neg_zero));
   BOOST_CHECK(!boost::math::signbit(test_type(-2) / neg_zero));

   BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<double>()));
   BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<float>()));
   BOOST_CHECK(boost::math::signbit(neg_zero.convert_to<long double>()));
   BOOST_CHECK(!boost::math::signbit(zero.convert_to<double>()));
   BOOST_CHECK(!boost::math::signbit(zero.convert_to<float>()));
   BOOST_CHECK(!boost::math::signbit(zero.convert_to<long double>()));

   // Conversions to other types of special values:
   if (std::numeric_limits<float>::has_infinity)
   {
      BOOST_CHECK_EQUAL(inf_val.convert_to<float>(), std::numeric_limits<float>::infinity());
      BOOST_CHECK_EQUAL((-inf_val).convert_to<float>(), -std::numeric_limits<float>::infinity());
   }
   if (std::numeric_limits<float>::has_quiet_NaN)
   {
      BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<float>()));
   }
   if (std::numeric_limits<double>::has_infinity)
   {
      BOOST_CHECK_EQUAL(inf_val.convert_to<double>(), std::numeric_limits<double>::infinity());
      BOOST_CHECK_EQUAL((-inf_val).convert_to<double>(), -std::numeric_limits<double>::infinity());
   }
   if (std::numeric_limits<double>::has_quiet_NaN)
   {
      BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<double>()));
   }
   if (std::numeric_limits<long double>::has_infinity)
   {
      BOOST_CHECK_EQUAL(inf_val.convert_to<long double>(), std::numeric_limits<long double>::infinity());
      BOOST_CHECK_EQUAL((-inf_val).convert_to<long double>(), -std::numeric_limits<long double>::infinity());
   }
   if (std::numeric_limits<long double>::has_quiet_NaN)
   {
      BOOST_CHECK((boost::math::isnan)(nan_val.convert_to<long double>()));
   }
   //
   // Bug https://svn.boost.org/trac/boost/attachment/ticket/12580
   //
   using std::ldexp;
   test_type a(1);
   test_type b = ldexp(test_type(0.99), -std::numeric_limits<test_type>::digits);
   good_type ga(1);
   good_type gb = ldexp(good_type(0.99), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   a  = a + ldexp(a, -20);
   ga = ga + ldexp(ga, -20);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   a  = 1;
   a  = boost::math::float_prior(a);
   ga = 1;
   ga = boost::math::float_prior(ga);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.5), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.5), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(1), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.50000000001), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(0.50000000001), -std::numeric_limits<good_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   a = boost::math::float_next(test_type(1));
   ga = boost::math::float_next(good_type(1));
   b  = ldexp(boost::math::float_prior(test_type(1)), -std::numeric_limits<test_type>::digits);
   gb = ldexp(boost::math::float_prior(good_type(1)), -std::numeric_limits<test_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b = ldexp(b, -1);
   gb = ldexp(gb, -1);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   a = 1.75;  // even mantissa, not a power of 2
   ga = 1.75;
   b  = ldexp(test_type(1), -std::numeric_limits<test_type>::digits);
   gb = ldexp(good_type(1), -std::numeric_limits<test_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
   b = ldexp(b, -1);
   gb = ldexp(gb, -1);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(boost::math::float_prior(test_type(1)), -std::numeric_limits<test_type>::digits);
   gb = ldexp(boost::math::float_prior(good_type(1)), -std::numeric_limits<test_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(b, -1);
   gb = ldexp(gb, -1);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(test_type(0.75), -std::numeric_limits<test_type>::digits);  // even mantissa not a power of 2.
   gb = ldexp(good_type(0.75), -std::numeric_limits<test_type>::digits);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));

   b  = ldexp(b, -1);
   gb = ldexp(gb, -1);
   BOOST_CHECK_EQUAL(good_type(test_type(a - b)), good_type(ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - a)), good_type(gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + b)), good_type(ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + a)), good_type(gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(a - -b)), good_type(ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b - -a)), good_type(gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(a + -b)), good_type(ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(b + -a)), good_type(gb + -ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - b)), good_type(-ga - gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - a)), good_type(-gb - ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + b)), good_type(-ga + gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + a)), good_type(-gb + ga));

   BOOST_CHECK_EQUAL(good_type(test_type(-a - -b)), good_type(-ga - -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b - -a)), good_type(-gb - -ga));
   BOOST_CHECK_EQUAL(good_type(test_type(-a + -b)), good_type(-ga + -gb));
   BOOST_CHECK_EQUAL(good_type(test_type(-b + -a)), good_type(-gb + -ga));
   #endif
}

int main()
{
   // compile times are too long for CI when ASAN is enabled, prune things down a bit:
#if !defined(BOOST_CI_ASAN_BUILD) && !defined(BOOST_CI_USAN_BUID)
   test_special_cases();
#endif
   unsigned error_count = 0;
   for (unsigned i = 0; i < 100000; ++i)
   {
      good_type a = generate_random<good_type>();
      good_type b = generate_random<good_type>();
      test_type ta(a);
      test_type tb(b);
      BOOST_CHECK_EQUAL(test_type(a * b), ta * tb);
      BOOST_CHECK_EQUAL(test_type(-a * b), -ta * tb);
      BOOST_CHECK_EQUAL(test_type(a * -b), ta * -tb);
      BOOST_CHECK_EQUAL(test_type(-a * -b), -ta * -tb);

      BOOST_CHECK_EQUAL(test_type(a + b), ta + tb);
      BOOST_CHECK_EQUAL(test_type(-a + b), -ta + tb);
      BOOST_CHECK_EQUAL(test_type(a + -b), ta + -tb);
      BOOST_CHECK_EQUAL(test_type(-a + -b), -ta + -tb);

      BOOST_CHECK_EQUAL(test_type(a - b), ta - tb);
      BOOST_CHECK_EQUAL(test_type(-a - b), -ta - tb);
      BOOST_CHECK_EQUAL(test_type(a - -b), ta - -tb);
      BOOST_CHECK_EQUAL(test_type(-a - -b), -ta - -tb);

      BOOST_CHECK_EQUAL(test_type(a / b), ta / tb);
      BOOST_CHECK_EQUAL(test_type(-a / b), -ta / tb);
      BOOST_CHECK_EQUAL(test_type(a / -b), ta / -tb);
      BOOST_CHECK_EQUAL(test_type(-a / -b), -ta / -tb);

      BOOST_CHECK_EQUAL(test_type(sqrt(a)), sqrt(ta));
      BOOST_CHECK_EQUAL(test_type(floor(a)), floor(ta));
      BOOST_CHECK_EQUAL(test_type(floor(-a)), floor(-ta));
      BOOST_CHECK_EQUAL(test_type(ceil(a)), ceil(ta));
      BOOST_CHECK_EQUAL(test_type(ceil(-a)), ceil(-ta));

#ifdef TEST_MPFR
      //
      // Conversions:
      //
      BOOST_CHECK_EQUAL(a.convert_to<double>(), ta.convert_to<double>());
      BOOST_CHECK_EQUAL(a.convert_to<float>(), ta.convert_to<float>());
      BOOST_CHECK_EQUAL(b.convert_to<double>(), tb.convert_to<double>());
      BOOST_CHECK_EQUAL(b.convert_to<float>(), tb.convert_to<float>());
#else
      BOOST_CHECK_EQUAL(a, ta.convert_to<double>());
      BOOST_CHECK_EQUAL(static_cast<float>(a), ta.convert_to<float>());
      BOOST_CHECK_EQUAL(b, tb.convert_to<double>());
      BOOST_CHECK_EQUAL(static_cast<float>(b), tb.convert_to<float>());
#endif

      static boost::random::mt19937 i_gen;

      int si = i_gen();
      BOOST_CHECK_EQUAL(test_type(a * si), ta * si);
      BOOST_CHECK_EQUAL(test_type(-a * si), -ta * si);
      BOOST_CHECK_EQUAL(test_type(-a * -si), -ta * -si);
      BOOST_CHECK_EQUAL(test_type(a * -si), ta * -si);
      unsigned ui = std::abs(si);
      BOOST_CHECK_EQUAL(test_type(a * ui), ta * ui);
      BOOST_CHECK_EQUAL(test_type(-a * ui), -ta * ui);

      // Divide:
      BOOST_CHECK_EQUAL(test_type(a / si), ta / si);
      BOOST_CHECK_EQUAL(test_type(-a / si), -ta / si);
      BOOST_CHECK_EQUAL(test_type(-a / -si), -ta / -si);
      BOOST_CHECK_EQUAL(test_type(a / -si), ta / -si);
      BOOST_CHECK_EQUAL(test_type(a / ui), ta / ui);
      BOOST_CHECK_EQUAL(test_type(-a / ui), -ta / ui);
      // Error reporting:
      if ((unsigned)boost::detail::test_errors() != error_count)
      {
         error_count = boost::detail::test_errors();
         std::cout << std::setprecision(std::numeric_limits<test_type>::max_digits10) << std::scientific;
         std::cout << "a (mpfr) = " << a << std::endl;
         std::cout << "a (test) = " << ta << std::endl;
         std::cout << "b (mpfr) = " << b << std::endl;
         std::cout << "b (test) = " << tb << std::endl;
         std::cout << "si       = " << si << std::endl;
         std::cout << "ui       = " << ui << std::endl;
      }
   }
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float_conv.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <cstdint>

template <class T>
T generate_random()
{
   typedef int                   e_type;
   static boost::random::mt19937 gen;
   T                             val      = gen();
   T                             prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(-20, 20);
   return ldexp(val, ui(gen));
}

template <class T>
void check_round(const T& val, bool check_extended = false)
{
   double d1    = val.template convert_to<double>();
   double d2    = boost::math::nextafter(d1, d1 < val ? DBL_MAX : -DBL_MAX);
   T      diff1 = abs(d1 - val);
   T      diff2 = abs(d2 - val);
   if (diff2 < diff1)
   {
      // Some debugging code here...
      std::cout << val.str() << std::endl;
      std::cout << std::setprecision(18);
      std::cout << d1 << std::endl;
      std::cout << d2 << std::endl;
      std::cout << diff1 << std::endl;
      std::cout << diff2 << std::endl;
      d1 = val.template convert_to<double>();
   }
   BOOST_CHECK(diff2 >= diff1);
   BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(d1));

   float f1 = val.template convert_to<float>();
   float f2 = boost::math::nextafter(f1, f1 < val ? FLT_MAX : -FLT_MAX);
   BOOST_CHECK(((abs(f1 - val) <= abs(f2 - val))));
   BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(f1));

#if !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)

   if (check_extended)
   {
      //
      // We should check long double as well:
      //
      long double l1 = val.template convert_to<long double>();
      long double l2 = boost::math::nextafter(d1, d1 < val ? LDBL_MAX : -LDBL_MAX);
      diff1          = abs(l1 - val);
      diff2          = abs(l2 - val);
      if (diff2 < diff1)
      {
         // Some debugging code here...
         std::cout << val.str() << std::endl;
         std::cout << std::setprecision(18);
         std::cout << l1 << std::endl;
         std::cout << l2 << std::endl;
         std::cout << diff1 << std::endl;
         std::cout << diff2 << std::endl;
         l1 = val.template convert_to<long double>();
      }
      BOOST_CHECK(diff2 >= diff1);
      BOOST_CHECK_EQUAL(boost::math::signbit(val), boost::math::signbit(l1));
   }

#endif
}

int main()
{
   using namespace boost::multiprecision;

   cpp_int          i(20);
   cpp_bin_float_50 f50(i);
   BOOST_CHECK_EQUAL(f50, 20);
   f50 = i.convert_to<cpp_bin_float_50>();
   BOOST_CHECK_EQUAL(f50, 20);

   int1024_t         i1024(45);
   cpp_bin_float_100 f100(i1024);
   BOOST_CHECK_EQUAL(f100, 45);
   f100 = i1024.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100, 45);

   uint1024_t        ui1024(55);
   cpp_bin_float_100 f100b(ui1024);
   BOOST_CHECK_EQUAL(f100b, 55);
   f100b = ui1024.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100b, 55);

   typedef number<cpp_int_backend<32, 32>, et_off> i32_t;
   i32_t                                           i32(67);
   cpp_bin_float_100                               f100c(i32);
   BOOST_CHECK_EQUAL(f100c, 67);
   f100c = i32.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100c, 67);

   typedef number<cpp_int_backend<32, 32, unsigned_magnitude>, et_off> ui32_t;
   ui32_t                                                              ui32(98);
   cpp_bin_float_100                                                   f100d(ui32);
   BOOST_CHECK_EQUAL(f100d, 98);
   f100d = ui32.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100d, 98);

   typedef number<cpp_int_backend<64, 64>, et_off> i64_t;
   i64_t                                           i64(67);
   cpp_bin_float_100                               f100e(i64);
   BOOST_CHECK_EQUAL(f100e, 67);
   f100e = i64.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100e, 67);

   typedef number<cpp_int_backend<64, 64, unsigned_magnitude>, et_off> ui64_t;
   ui64_t                                                              ui64(98);
   cpp_bin_float_100                                                   f100f(ui64);
   BOOST_CHECK_EQUAL(f100f, 98);
   f100f = ui64.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100f, 98);

   typedef number<cpp_int_backend<128, 128>, et_off> i128_t;
   i128_t                                            i128(67);
   cpp_bin_float_100                                 f100g(i128);
   BOOST_CHECK_EQUAL(f100g, 67);
   f100g = i128.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100g, 67);

   typedef number<cpp_int_backend<128, 128, unsigned_magnitude>, et_off> ui128_t;
   ui128_t                                                               ui128(98);
   cpp_bin_float_100                                                     f100h(ui128);
   BOOST_CHECK_EQUAL(f100h, 98);
   f100h = ui128.convert_to<cpp_bin_float_100>();
   BOOST_CHECK_EQUAL(f100h, 98);

   cpp_bin_float_quad q = (std::numeric_limits<float>::min)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), (std::numeric_limits<float>::min)());
   q = (std::numeric_limits<float>::max)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), (std::numeric_limits<float>::max)());
   q = (std::numeric_limits<float>::denorm_min)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), (std::numeric_limits<float>::denorm_min)());
   // See https://svn.boost.org/trac/boost/ticket/12512:
   boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<128, boost::multiprecision::backends::digit_base_2, void, std::int64_t> > ext_float("1e-646456978");
   BOOST_CHECK_EQUAL(ext_float.convert_to<float>(), 0);

   q = -(std::numeric_limits<float>::min)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), -(std::numeric_limits<float>::min)());
   q = -(std::numeric_limits<float>::max)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), -(std::numeric_limits<float>::max)());
   q = -(std::numeric_limits<float>::denorm_min)();
   BOOST_CHECK_EQUAL(q.convert_to<float>(), -(std::numeric_limits<float>::denorm_min)());
   // See https://svn.boost.org/trac/boost/ticket/12512:
   ext_float = boost::multiprecision::number<boost::multiprecision::backends::cpp_bin_float<128, boost::multiprecision::backends::digit_base_2, void, std::int64_t> >("-1e-646456978");
   BOOST_CHECK_EQUAL(ext_float.convert_to<float>(), 0);
   ext_float = (std::numeric_limits<double>::max)();
   ext_float *= 16;
   if (std::numeric_limits<double>::has_infinity)
   {
      BOOST_CHECK_EQUAL(ext_float.convert_to<double>(), std::numeric_limits<double>::infinity());
   }
   else
   {
      BOOST_CHECK_EQUAL(ext_float.convert_to<double>(), (std::numeric_limits<double>::max)());
   }
   ext_float = -ext_float;
   if (std::numeric_limits<double>::has_infinity)
   {
      BOOST_CHECK_EQUAL(ext_float.convert_to<double>(), -std::numeric_limits<double>::infinity());
   }
   else
   {
      BOOST_CHECK_EQUAL(ext_float.convert_to<double>(), -(std::numeric_limits<double>::max)());
   }
   //
   // Check for double rounding when the result would be a denorm.
   // See https://svn.boost.org/trac/boost/ticket/12527
   //
   cpp_bin_float_50 r1 = ldexp(cpp_bin_float_50(0x8000000000000bffull), -63 - 1023);
   check_round(r1);
   r1 = -r1;
   check_round(r1);

   r1 = ldexp(cpp_bin_float_50(0x8000017f), -31 - 127);
   check_round(r1);
   r1 = -r1;
   check_round(r1);
   //
   // Check conversion to signed zero works OK:
   //
   r1 = -ldexp(cpp_bin_float_50(1), -3000);
   check_round(r1);
   r1 = 0;
   r1 = -r1;
   BOOST_CHECK(boost::math::signbit(r1));
   check_round(r1);
   //
   // Check boundary as the exponent drops below what a double can cope with
   // but we will be rounding up:
   //
   r1 = 3;
   r1 = ldexp(r1, std::numeric_limits<double>::min_exponent);
   do
   {
      check_round(r1);
      check_round(boost::math::float_next(r1));
      check_round(boost::math::float_prior(r1));
      r1 = ldexp(r1, -1);
   } while (ilogb(r1) > std::numeric_limits<double>::min_exponent - 5 - std::numeric_limits<double>::digits);
   r1 = -3;
   r1 = ldexp(r1, std::numeric_limits<double>::min_exponent);
   do
   {
      check_round(r1);
      check_round(boost::math::float_next(r1));
      check_round(boost::math::float_prior(r1));
      r1 = ldexp(r1, -1);
   } while (ilogb(r1) > std::numeric_limits<double>::min_exponent - 5 - std::numeric_limits<double>::digits);
   //
   // Again when not rounding up:
   //
   r1 = 1;
   r1 = ldexp(r1, std::numeric_limits<double>::min_exponent);
   do
   {
      check_round(r1);
      check_round(boost::math::float_next(r1));
      check_round(boost::math::float_prior(r1));
      r1 = ldexp(r1, -1);
   } while (ilogb(r1) > std::numeric_limits<double>::min_exponent - 5 - std::numeric_limits<double>::digits);
   r1 = -1;
   r1 = ldexp(r1, std::numeric_limits<double>::min_exponent);
   do
   {
      check_round(r1);
      check_round(boost::math::float_next(r1));
      check_round(boost::math::float_prior(r1));
      r1 = ldexp(r1, -1);
   } while (ilogb(r1) > std::numeric_limits<double>::min_exponent - 5 - std::numeric_limits<double>::digits);
   //
   // Test random conversions:
   //
   for (unsigned j = 0; j < 10000; ++j)
   {
      check_round(generate_random<cpp_bin_float_50>(), true);
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float_io.cpp
================================================
// Copyright John Maddock 2013.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/chrono.hpp>
#include "test.hpp"
#include <boost/array.hpp>
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

void print_flags(std::ios_base::fmtflags f)
{
   std::cout << "Formatting flags were: ";
   if (f & std::ios_base::scientific)
      std::cout << "scientific ";
   if (f & std::ios_base::fixed)
      std::cout << "fixed ";
   if (f & std::ios_base::showpoint)
      std::cout << "showpoint ";
   if (f & std::ios_base::showpos)
      std::cout << "showpos ";
   std::cout << std::endl;
}

template <class T>
void test()
{
   typedef T                                mp_t;
   boost::array<std::ios_base::fmtflags, 9> f =
       {{std::ios_base::fmtflags(0), std::ios_base::showpoint, std::ios_base::showpos, std::ios_base::scientific, std::ios_base::scientific | std::ios_base::showpos,
         std::ios_base::scientific | std::ios_base::showpoint, std::ios_base::fixed, std::ios_base::fixed | std::ios_base::showpoint,
         std::ios_base::fixed | std::ios_base::showpos}};

   boost::array<boost::array<const char*, 13 * 9>, 40> string_data = {{
#include "libs/multiprecision/test/string_data.ipp"
   }};

   double num   = 123456789.0;
   double denom = 1;
   double val   = num;
   for (unsigned j = 0; j < 40; ++j)
   {
      unsigned col = 0;
      for (unsigned prec = 1; prec < 14; ++prec)
      {
         for (unsigned i = 0; i < f.size(); ++i, ++col)
         {
            std::stringstream ss;
            ss.precision(prec);
            ss.flags(f[i]);
            ss << mp_t(val);
            const char* expect = string_data[j][col];
            if (ss.str() != expect)
            {
               std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
               print_flags(f[i]);
               std::cout << "Precision is: " << prec << std::endl;
               std::cout << "Got:      " << ss.str() << std::endl;
               std::cout << "Expected: " << expect << std::endl;
               ++boost::detail::test_errors();
               mp_t(val).str(prec, f[i]); // for debugging
            }
         }
      }
      num = -num;
      if (j & 1)
         denom *= 8;
      val = num / denom;
   }

   boost::array<const char*, 13 * 9> zeros =
       {{"0", "0.", "+0", "0.0e+00", "+0.0e+00", "0.0e+00", "0.0", "0.0", "+0.0", "0", "0.0", "+0", "0.00e+00", "+0.00e+00", "0.00e+00", "0.00", "0.00", "+0.00", "0", "0.00", "+0", "0.000e+00", "+0.000e+00", "0.000e+00", "0.000", "0.000", "+0.000", "0", "0.000", "+0", "0.0000e+00", "+0.0000e+00", "0.0000e+00", "0.0000", "0.0000", "+0.0000", "0", "0.0000", "+0", "0.00000e+00", "+0.00000e+00", "0.00000e+00", "0.00000", "0.00000", "+0.00000", "0", "0.00000", "+0", "0.000000e+00", "+0.000000e+00", "0.000000e+00", "0.000000", "0.000000", "+0.000000", "0", "0.000000", "+0", "0.0000000e+00", "+0.0000000e+00", "0.0000000e+00", "0.0000000", "0.0000000", "+0.0000000", "0", "0.0000000", "+0", "0.00000000e+00", "+0.00000000e+00", "0.00000000e+00", "0.00000000", "0.00000000", "+0.00000000", "0", "0.00000000", "+0", "0.000000000e+00", "+0.000000000e+00", "0.000000000e+00", "0.000000000", "0.000000000", "+0.000000000", "0", "0.000000000", "+0", "0.0000000000e+00", "+0.0000000000e+00", "0.0000000000e+00", "0.0000000000", "0.0000000000", "+0.0000000000", "0", "0.0000000000", "+0", "0.00000000000e+00", "+0.00000000000e+00", "0.00000000000e+00", "0.00000000000", "0.00000000000", "+0.00000000000", "0", "0.00000000000", "+0", "0.000000000000e+00", "+0.000000000000e+00", "0.000000000000e+00", "0.000000000000", "0.000000000000", "+0.000000000000", "0", "0.000000000000", "+0", "0.0000000000000e+00", "+0.0000000000000e+00", "0.0000000000000e+00", "0.0000000000000", "0.0000000000000", "+0.0000000000000"}};

   unsigned col = 0;
   val          = 0;
   for (unsigned prec = 1; prec < 14; ++prec)
   {
      for (unsigned i = 0; i < f.size(); ++i, ++col)
      {
         std::stringstream ss;
         ss.precision(prec);
         ss.flags(f[i]);
         ss << mp_t(val);
         const char* expect = zeros[col];
         if (ss.str() != expect)
         {
            std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
            print_flags(f[i]);
            std::cout << "Precision is: " << prec << std::endl;
            std::cout << "Got:      " << ss.str() << std::endl;
            std::cout << "Expected: " << expect << std::endl;
            ++boost::detail::test_errors();
            mp_t(val).str(prec, f[i]); // for debugging
         }
      }
   }

   if (std::numeric_limits<mp_t>::has_infinity)
   {
      T val = std::numeric_limits<T>::infinity();
      BOOST_CHECK_EQUAL(val.str(), "inf");
      BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "+inf");
      val = -val;
      BOOST_CHECK_EQUAL(val.str(), "-inf");
      BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "-inf");

      val = static_cast<T>("inf");
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      val = static_cast<T>("+inf");
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      val = static_cast<T>("-inf");
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<mp_t>::has_quiet_NaN)
   {
      T val = std::numeric_limits<T>::quiet_NaN();
      BOOST_CHECK_EQUAL(val.str(), "nan");
      val = static_cast<T>("nan");
      BOOST_CHECK((boost::math::isnan)(val));
   }
   //
   // Min and max values:
   //
   T t((std::numeric_limits<T>::max)().str(std::numeric_limits<T>::max_digits10, std::ios_base::scientific));
   BOOST_CHECK_EQUAL(t, (std::numeric_limits<T>::max)());
   t = T((std::numeric_limits<T>::min)().str(std::numeric_limits<T>::max_digits10, std::ios_base::scientific));
   BOOST_CHECK_EQUAL(t, (std::numeric_limits<T>::min)());
   t = T((std::numeric_limits<T>::lowest)().str(std::numeric_limits<T>::max_digits10, std::ios_base::scientific));
   BOOST_CHECK_EQUAL(t, (std::numeric_limits<T>::lowest)());
}

template <class T>
T generate_random()
{
   typedef typename T::backend_type::exponent_type e_type;
   static boost::random::mt19937                   gen;
   T                                               val      = gen();
   T                                               prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(0, std::numeric_limits<T>::max_exponent);
   return ldexp(val, ui(gen));
}

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f)
{
   std::stringstream ss;
   ss << std::setprecision(std::numeric_limits<T>::max_digits10);
   ss.flags(f);
   ss << val;
   T new_val = static_cast<T>(ss.str());
   BOOST_CHECK_EQUAL(new_val, val);
   new_val = static_cast<T>(val.str(0, f));
   BOOST_CHECK_EQUAL(new_val, val);
}

template <class T>
void do_round_trip(const T& val)
{
   do_round_trip(val, std::ios_base::fmtflags(0));
   do_round_trip(val, std::ios_base::fmtflags(std::ios_base::scientific));
   if ((fabs(val) > 1) && (fabs(val) < 1e100))
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::fixed));

   static int error_count = 0;

   if (error_count != boost::detail::test_errors())
   {
      error_count = boost::detail::test_errors();
      std::cout << "Errors occurred while testing value....";
      if (val.backend().sign())
         std::cout << "-";
      std::cout << boost::multiprecision::cpp_int(val.backend().bits()) << "e" << val.backend().exponent() << std::endl;
   }
}

template <class T>
void test_round_trip()
{
   std::cout << "Testing type " << typeid(T).name() << std::endl;
   std::cout << "digits = " << std::numeric_limits<T>::digits << std::endl;
   std::cout << "digits10 = " << std::numeric_limits<T>::digits10 << std::endl;
   std::cout << "max_digits10 = " << std::numeric_limits<T>::max_digits10 << std::endl;

   stopwatch<boost::chrono::high_resolution_clock> w;

#ifndef CI_SUPPRESS_KNOWN_ISSUES
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 200)
#else
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 50)
#endif
   {
      T val = generate_random<T>();
      do_round_trip(val);
      do_round_trip(T(-val));
      do_round_trip(T(1 / val));
      do_round_trip(T(-1 / val));

      if (boost::detail::test_errors() > 200)
         break; // escape if there are too many errors.
   }

   std::cout << "Execution time = " << boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() << "s" << std::endl;
}

#if !defined(TEST1) && !defined(TEST2)
#define TEST1
#define TEST2
#endif

int main()
{
   using namespace boost::multiprecision;
#ifdef TEST1
   test<number<cpp_bin_float<113, digit_base_2> > >();
   test_round_trip<number<cpp_bin_float<113, digit_base_2> > >();
#endif
#ifdef TEST2
   test<number<cpp_bin_float<53, digit_base_2> > >();
   test_round_trip<number<cpp_bin_float<53, digit_base_2> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float_round.cpp
================================================
// Copyright John Maddock 2016.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

//
// This file takes way too long to run to be part of the main regression test suite,
// but is useful in probing for errors in cpp_bin_float's rounding code.
// It cycles through every single value of type float, and rounds those numbers
// plus some closely related ones and compares the results to those produced by MPFR.
//
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/mpfr.hpp>
#include <boost/math/special_functions/next.hpp>
#include "test.hpp"

using namespace boost::multiprecision;

typedef number<mpfr_float_backend<35> >                                                     good_type;
typedef number<cpp_bin_float<std::numeric_limits<good_type>::digits, digit_base_2>, et_off> test_type;

int main()
{
   float f = (std::numeric_limits<float>::max)();

   do
   {
      float     fr1, fr2;
      good_type gf(f), gf2(f);
      test_type tf(f), tf2(f);
      fr1 = gf.convert_to<float>();
      fr2 = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);
      // next represenation:
      gf = boost::math::float_next(gf2);
      tf = boost::math::float_next(tf2);
      BOOST_CHECK_NE(gf, gf2);
      BOOST_CHECK_NE(tf, tf2);
      fr1 = gf.convert_to<float>();
      fr2 = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);
      // previous representation:
      gf = boost::math::float_prior(gf2);
      tf = boost::math::float_prior(tf2);
      BOOST_CHECK_NE(gf, gf2);
      BOOST_CHECK_NE(tf, tf2);
      fr1 = gf.convert_to<float>();
      fr2 = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);

      // Create ands test ties:
      int e;
      std::frexp(f, &e);
      float extra = std::ldexp(1.0f, e - std::numeric_limits<float>::digits - 1);
      gf          = gf2 += extra;
      tf          = tf2 += extra;
      fr1         = gf.convert_to<float>();
      fr2         = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);
      // next represenation:
      gf = boost::math::float_next(gf2);
      tf = boost::math::float_next(tf2);
      BOOST_CHECK_NE(gf, gf2);
      BOOST_CHECK_NE(tf, tf2);
      fr1 = gf.convert_to<float>();
      fr2 = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);
      // previous representation:
      gf = boost::math::float_prior(gf2);
      tf = boost::math::float_prior(tf2);
      BOOST_CHECK_NE(gf, gf2);
      BOOST_CHECK_NE(tf, tf2);
      fr1 = gf.convert_to<float>();
      fr2 = tf.convert_to<float>();
      BOOST_CHECK_EQUAL(fr1, fr2);

      f = boost::math::float_prior(f);
   } while (f);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>
#include "test_float_serial.hpp"

#if !defined(TEST1) && !defined(TEST2)
#define TEST1
#define TEST2
#endif

int main()
{
   using namespace boost::multiprecision;
#ifdef TEST1
   test<cpp_bin_float_50>();
#endif
#ifdef TEST2
   test<cpp_bin_float_quad>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_bin_float_tgamma.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2021.
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_bin_float.hpp>

namespace local
{
  template<typename T> constexpr T (max)(T a, T b) { return a > b ? a : b; }

  template<class T>
  void test()
  {
     // N[Gamma[5/2], 120]
     const T control_tgamma_2_and_half("1.32934038817913702047362561250585888709816209209179034616035584238968346344327413603121299255390849906217011771821192800");

     // N[Gamma[500/2], 120]
     const T control_tgamma_2_fifty   ("1.29314250436364309292832582080974738839793748706951226669917697084512949902204448379552716614841127978037140294127577317E490");

     const T tgamma_2_and_half = boost::math::tgamma(T(T(5)   / 2));
     const T tgamma_2_fifty    = boost::math::tgamma(T(T(500) / 2));

     BOOST_CHECK_CLOSE_FRACTION(tgamma_2_and_half, control_tgamma_2_and_half, T(std::numeric_limits<T>::epsilon() * T(1.0E6)));
     BOOST_CHECK_CLOSE_FRACTION(tgamma_2_fifty   , control_tgamma_2_fifty,    T(std::numeric_limits<T>::epsilon() * T(1.0E6)));
  }
}

int main()
{
   using big_float_type_016 = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<(local::max)((int) (std::numeric_limits<double>::digits + 1), 16)>>;
   using big_float_type_035 = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<(local::max)((int) (std::numeric_limits<double>::digits + 1), 35)>>;
   using big_float_type_105 = boost::multiprecision::number<boost::multiprecision::cpp_bin_float<105>>;

   local::test<big_float_type_016>();
   local::test<big_float_type_035>();
   local::test<big_float_type_105>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_dec_float_conv.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_dec_float.hpp>

int main()
{
   using namespace boost::multiprecision;
   //
   // Test interconversions between different precisions:
   //
   cpp_dec_float_50  f1(2);
   cpp_dec_float_100 f2(3);

   cpp_dec_float_100 f3 = f1; // implicit conversion OK
   BOOST_TEST(f3 == 2);
   cpp_dec_float_50 f4(f2); // explicit conversion OK
   BOOST_TEST(f4 == 3);

   f2 = f1;
   BOOST_TEST(f2 == 2);
   f2 = 4;
   f1 = static_cast<cpp_dec_float_50>(f2);
   BOOST_TEST(f1 == 4);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_dec_float_round.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 Christopher Kormanyos. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

// Test case for ticket:
// #8065: Multiprecision rounding issue

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include "test.hpp"
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/special_functions/round.hpp>

template <int N>
static bool round_test_imp()
{
   typedef boost::multiprecision::cpp_dec_float<N>                                       mp_backend_type;
   typedef boost::multiprecision::number<mp_backend_type, boost::multiprecision::et_off> mp_type;

   const mp_type original_digits(1.0F);

   const mp_type scale = pow(mp_type(10), N);

   mp_type these_digits = original_digits * scale;

   these_digits = boost::math::round(these_digits);
   these_digits /= scale;

   const std::string result = these_digits.str();

   return (result == original_digits.str());
}

template <int N>
struct round_test
{
   static bool test()
   {
      return (round_test_imp<N>() && round_test<N - 1>::test());
   }
};

template <>
struct round_test<0>
{
   static bool test()
   {
      return round_test_imp<0>();
   }
};

int main()
{
   //
   // Test cpp_dec_float rounding with boost::math::round() at various precisions:
   //
   const bool round_test_result = round_test<40>::test();

   BOOST_CHECK_EQUAL(round_test_result, true);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_dec_float_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test_float_serial.hpp"

#if !defined(TEST1) && !defined(TEST2)
#define TEST1
#define TEST2
#endif

int main()
{
   using namespace boost::multiprecision;
#ifdef TEST1
   test<cpp_dec_float_50>();
#endif
#ifdef TEST2
   test<number<cpp_dec_float<100, std::int64_t, std::allocator<char> > > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_dec_float_tgamma.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2021.
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_dec_float.hpp>

namespace local
{
  template<typename T> constexpr T (max)(T a, T b) { return a > b ? a : b; }

  template<class T>
  void test()
  {
     // N[Gamma[5/2], 120]
     const T control_tgamma_2_and_half("1.32934038817913702047362561250585888709816209209179034616035584238968346344327413603121299255390849906217011771821192800");

     // N[Gamma[500/2], 120]
     const T control_tgamma_2_fifty   ("1.29314250436364309292832582080974738839793748706951226669917697084512949902204448379552716614841127978037140294127577317E490");

     const T tgamma_2_and_half = boost::math::tgamma(T(T(5)   / 2));
     const T tgamma_2_fifty    = boost::math::tgamma(T(T(500) / 2));

     BOOST_CHECK_CLOSE_FRACTION(tgamma_2_and_half, control_tgamma_2_and_half, T(std::numeric_limits<T>::epsilon() * T(1.0E6)));
     BOOST_CHECK_CLOSE_FRACTION(tgamma_2_fifty   , control_tgamma_2_fifty,    T(std::numeric_limits<T>::epsilon() * T(1.0E6)));
  }
}

int main()
{
   using big_float_type_016 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<(local::max)((int) (std::numeric_limits<double>::digits + 1), 16)>>;
   using big_float_type_035 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<(local::max)((int) (std::numeric_limits<double>::digits + 1), 35)>>;
   using big_float_type_105 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<105>>;

   local::test<big_float_type_016>();
   local::test<big_float_type_035>();
   local::test<big_float_type_105>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

//
// This ensures all our code gets tested, even though it may
// not be the fastest configuration in normal use:
//
#define BOOST_MP_USE_LIMB_SHIFT

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#ifdef _MSC_VER
#pragma warning(disable : 4127) //  Conditional expression is constant
#endif

#if !defined(TEST1) && !defined(TEST2) && !defined(TEST3) && !defined(TEST4) && !defined(TEST5) && !defined(TEST6)
#define TEST1
#define TEST2
#define TEST3
#define TEST4
#define TEST5
#define TEST6
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
struct is_checked_cpp_int : public std::integral_constant<bool, false>
{};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <class Number>
struct tester
{
   typedef Number                                         test_type;
   typedef typename test_type::backend_type::checked_type checked;

   unsigned     last_error_count;
   timer tim;

   boost::multiprecision::mpz_int a, b, c, d;
   int                            si;
   unsigned                       ui;
   boost::multiprecision::double_limb_type large_ui;
   test_type                      a1, b1, c1, d1;

   void t1()
   {
      using namespace boost::multiprecision;
      BOOST_CHECK_EQUAL(a.str(), a1.str());
      BOOST_CHECK_EQUAL(b.str(), b1.str());
      BOOST_CHECK_EQUAL(c.str(), c1.str());
      BOOST_CHECK_EQUAL(d.str(), d1.str());
      BOOST_CHECK_EQUAL(mpz_int(a + b).str(), test_type(a1 + b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) += b).str(), (test_type(a1) += b1).str());
      BOOST_CHECK_EQUAL((mpz_int(b) += a).str(), (test_type(b1) += a1).str());
      BOOST_CHECK_EQUAL(mpz_int(a - b).str(), test_type(a1 - b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) -= b).str(), (test_type(a1) -= b1).str());
      BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) + b).str(), test_type(test_type(-a1) + b1).str());
      BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) - b).str(), test_type(test_type(-a1) - b1).str());
      BOOST_CHECK_EQUAL(mpz_int(c * d).str(), test_type(c1 * d1).str());
      BOOST_CHECK_EQUAL((mpz_int(c) *= d).str(), (test_type(c1) *= d1).str());
      BOOST_CHECK_EQUAL((mpz_int(d) *= c).str(), (test_type(d1) *= c1).str());
      BOOST_CHECK_EQUAL(mpz_int(c * -d).str(), test_type(c1 * -d1).str());
      BOOST_CHECK_EQUAL(mpz_int(-c * d).str(), test_type(-c1 * d1).str());
      BOOST_CHECK_EQUAL((mpz_int(c) *= -d).str(), (test_type(c1) *= -d1).str());
      BOOST_CHECK_EQUAL((mpz_int(-d) *= c).str(), (test_type(-d1) *= c1).str());
      BOOST_CHECK_EQUAL(mpz_int(b * c).str(), test_type(b1 * c1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / b).str(), test_type(a1 / b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= b).str(), (test_type(a1) /= b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / -b).str(), test_type(a1 / -b1).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / b).str(), test_type(-a1 / b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= -b).str(), (test_type(a1) /= -b1).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) /= b).str(), (test_type(-a1) /= b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / d).str(), test_type(a1 / d1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % b).str(), test_type(a1 % b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= b).str(), (test_type(a1) %= b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % -b).str(), test_type(a1 % -b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= -b).str(), (test_type(a1) %= -b1).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % b).str(), test_type(-a1 % b1).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) %= b).str(), (test_type(-a1) %= b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % d).str(), test_type(a1 % d1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= d).str(), (test_type(a1) %= d1).str());

      if (!std::numeric_limits<test_type>::is_bounded)
      {
         test_type p = a1 * b1;
         test_type r;
         divide_qr(p, b1, p, r);
         BOOST_CHECK_EQUAL(p, a1);
         BOOST_CHECK_EQUAL(r, test_type(0));

         p = a1 * d1;
         divide_qr(p, d1, p, r);
         BOOST_CHECK_EQUAL(p, a1);
         BOOST_CHECK_EQUAL(r, test_type(0));

         divide_qr(p, test_type(1), p, r);
         BOOST_CHECK_EQUAL(p, a1);
         BOOST_CHECK_EQUAL(r, test_type(0));
      }
   }

   void t2()
   {
      using namespace boost::multiprecision;
      // bitwise ops:
      BOOST_CHECK_EQUAL(mpz_int(a | b).str(), test_type(a1 | b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) |= b).str(), (test_type(a1) |= b1).str());
      if (!is_checked_cpp_int<test_type>::value)
      {
         BOOST_CHECK_EQUAL(mpz_int(-a | b).str(), test_type(-a1 | b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) |= b).str(), (test_type(-a1) |= b1).str());
         BOOST_CHECK_EQUAL(mpz_int(a | -b).str(), test_type(a1 | -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(a) |= -b).str(), (test_type(a1) |= -b1).str());
         BOOST_CHECK_EQUAL(mpz_int(-a | -b).str(), test_type(-a1 | -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) |= -b).str(), (test_type(-a1) |= -b1).str());
      }
      BOOST_CHECK_EQUAL(mpz_int(a & b).str(), test_type(a1 & b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) &= b).str(), (test_type(a1) &= b1).str());
      if (!is_checked_cpp_int<test_type>::value)
      {
         BOOST_CHECK_EQUAL(mpz_int(-a & b).str(), test_type(-a1 & b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) &= b).str(), (test_type(-a1) &= b1).str());
         BOOST_CHECK_EQUAL(mpz_int(a & -b).str(), test_type(a1 & -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(a) &= -b).str(), (test_type(a1) &= -b1).str());
         BOOST_CHECK_EQUAL(mpz_int(-a & -b).str(), test_type(-a1 & -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) &= -b).str(), (test_type(-a1) &= -b1).str());
      }
      BOOST_CHECK_EQUAL(mpz_int(a ^ b).str(), test_type(a1 ^ b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) ^= b).str(), (test_type(a1) ^= b1).str());
      if (!is_checked_cpp_int<test_type>::value)
      {
         BOOST_CHECK_EQUAL(mpz_int(-a ^ b).str(), test_type(-a1 ^ b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) ^= b).str(), (test_type(-a1) ^= b1).str());
         BOOST_CHECK_EQUAL(mpz_int(a ^ -b).str(), test_type(a1 ^ -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(a) ^= -b).str(), (test_type(a1) ^= -b1).str());
         BOOST_CHECK_EQUAL(mpz_int(-a ^ -b).str(), test_type(-a1 ^ -b1).str());
         BOOST_CHECK_EQUAL((mpz_int(-a) ^= -b).str(), (test_type(-a1) ^= -b1).str());
      }
      // Shift ops:
      for (unsigned i = 0; i < 128; ++i)
      {
         if (!std::numeric_limits<test_type>::is_bounded)
         {
            BOOST_CHECK_EQUAL(mpz_int(a << i).str(), test_type(a1 << i).str());
            BOOST_CHECK_EQUAL(mpz_int(-a << i).str(), test_type(-a1 << i).str());
         }
         else if (!is_checked_cpp_int<test_type>::value)
         {
            test_type t1(mpz_int(a << i).str());
            test_type t2 = a1 << i;
            BOOST_CHECK_EQUAL(t1, t2);
            t1 = test_type(mpz_int(-a << i).str());
            t2 = -a1 << i;
            BOOST_CHECK_EQUAL(t1, t2);
         }
         BOOST_CHECK_EQUAL(mpz_int(a >> i).str(), test_type(a1 >> i).str());
         if (!is_checked_cpp_int<test_type>::value)
         {
            BOOST_CHECK_EQUAL(mpz_int(-a >> i).str(), test_type(-a1 >> i).str());
         }
      }
      // gcd/lcm
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, b)).str(), test_type(gcd(a1, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, d)).str(), test_type(lcm(c1, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, b)).str(), test_type(gcd(-a1, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, d)).str(), test_type(lcm(-c1, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, -b)).str(), test_type(gcd(-a1, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, -d)).str(), test_type(lcm(-c1, -d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, -b)).str(), test_type(gcd(a1, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, -b)).str(), test_type(gcd(-a1, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, -d)).str(), test_type(lcm(c1, -d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, -d)).str(), test_type(lcm(-c1, -d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(mpz_int(0), b)).str(), test_type(gcd(test_type(0), b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(mpz_int(0), -b)).str(), test_type(gcd(test_type(0), -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, mpz_int(0))).str(), test_type(gcd(a1, test_type(0))).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, mpz_int(0))).str(), test_type(gcd(a1, test_type(0))).str());
      // Integer sqrt:
      mpz_int   r;
      test_type r1;
      BOOST_CHECK_EQUAL(sqrt(a, r).str(), sqrt(a1, r1).str());
      BOOST_CHECK_EQUAL(r.str(), r1.str());
   }

   void t3()
   {
      using namespace boost::multiprecision;
      // Now check operations involving signed integers:
      BOOST_CHECK_EQUAL(mpz_int(a + si).str(), test_type(a1 + si).str());
      BOOST_CHECK_EQUAL(mpz_int(a + -si).str(), test_type(a1 + -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a + si).str(), test_type(-a1 + si).str());
      BOOST_CHECK_EQUAL(mpz_int(si + a).str(), test_type(si + a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) += si).str(), (test_type(a1) += si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) += -si).str(), (test_type(a1) += -si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) += si).str(), (test_type(-a1) += si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) += -si).str(), (test_type(-a1) += -si).str());
      BOOST_CHECK_EQUAL(mpz_int(a - si).str(), test_type(a1 - si).str());
      BOOST_CHECK_EQUAL(mpz_int(a - -si).str(), test_type(a1 - -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a - si).str(), test_type(-a1 - si).str());
      BOOST_CHECK_EQUAL(mpz_int(si - a).str(), test_type(si - a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) -= si).str(), (test_type(a1) -= si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) -= -si).str(), (test_type(a1) -= -si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) -= si).str(), (test_type(-a1) -= si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) -= -si).str(), (test_type(-a1) -= -si).str());
      BOOST_CHECK_EQUAL(mpz_int(b * si).str(), test_type(b1 * si).str());
      BOOST_CHECK_EQUAL(mpz_int(b * -si).str(), test_type(b1 * -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-b * si).str(), test_type(-b1 * si).str());
      BOOST_CHECK_EQUAL(mpz_int(si * b).str(), test_type(si * b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) *= si).str(), (test_type(a1) *= si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) *= -si).str(), (test_type(a1) *= -si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) *= si).str(), (test_type(-a1) *= si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) *= -si).str(), (test_type(-a1) *= -si).str());
      BOOST_CHECK_EQUAL(mpz_int(a / si).str(), test_type(a1 / si).str());
      BOOST_CHECK_EQUAL(mpz_int(a / -si).str(), test_type(a1 / -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / si).str(), test_type(-a1 / si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= si).str(), (test_type(a1) /= si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= -si).str(), (test_type(a1) /= -si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) /= si).str(), (test_type(-a1) /= si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) /= -si).str(), (test_type(-a1) /= -si).str());
      BOOST_CHECK_EQUAL(mpz_int(a % si).str(), test_type(a1 % si).str());
      BOOST_CHECK_EQUAL(mpz_int(a % -si).str(), test_type(a1 % -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % si).str(), test_type(-a1 % si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= si).str(), (test_type(a1) %= si).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= -si).str(), (test_type(a1) %= -si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) %= si).str(), (test_type(-a1) %= si).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) %= -si).str(), (test_type(-a1) %= -si).str());
      if ((si > 0) || !is_checked_cpp_int<test_type>::value)
      {
         BOOST_CHECK_EQUAL(mpz_int(a | si).str(), test_type(a1 | si).str());
         BOOST_CHECK_EQUAL((mpz_int(a) |= si).str(), (test_type(a1) |= si).str());
         BOOST_CHECK_EQUAL(mpz_int(a & si).str(), test_type(a1 & si).str());
         BOOST_CHECK_EQUAL((mpz_int(a) &= si).str(), (test_type(a1) &= si).str());
         BOOST_CHECK_EQUAL(mpz_int(a ^ si).str(), test_type(a1 ^ si).str());
         BOOST_CHECK_EQUAL((mpz_int(a) ^= si).str(), (test_type(a1) ^= si).str());
         BOOST_CHECK_EQUAL(mpz_int(si | a).str(), test_type(si | a1).str());
         BOOST_CHECK_EQUAL(mpz_int(si & a).str(), test_type(si & a1).str());
         BOOST_CHECK_EQUAL(mpz_int(si ^ a).str(), test_type(si ^ a1).str());
      }
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, si)).str(), test_type(gcd(a1, si)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(si, b)).str(), test_type(gcd(si, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, si)).str(), test_type(lcm(c1, si)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(si, d)).str(), test_type(lcm(si, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, si)).str(), test_type(gcd(-a1, si)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-si, b)).str(), test_type(gcd(-si, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, si)).str(), test_type(lcm(-c1, si)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-si, d)).str(), test_type(lcm(-si, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, -si)).str(), test_type(gcd(-a1, -si)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-si, -b)).str(), test_type(gcd(-si, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, -si)).str(), test_type(lcm(-c1, -si)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-si, -d)).str(), test_type(lcm(-si, -d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, -si)).str(), test_type(gcd(a1, -si)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(si, -b)).str(), test_type(gcd(si, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, -si)).str(), test_type(lcm(c1, -si)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(si, -d)).str(), test_type(lcm(si, -d1)).str());
   }

   void t4()
   {
      using namespace boost::multiprecision;
      // Now check operations involving unsigned integers:
      BOOST_CHECK_EQUAL(mpz_int(a + ui).str(), test_type(a1 + ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a + ui).str(), test_type(-a1 + ui).str());
      BOOST_CHECK_EQUAL(mpz_int(ui + a).str(), test_type(ui + a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) += ui).str(), (test_type(a1) += ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) += ui).str(), (test_type(-a1) += ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a - ui).str(), test_type(a1 - ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a - ui).str(), test_type(-a1 - ui).str());
      BOOST_CHECK_EQUAL(mpz_int(ui - a).str(), test_type(ui - a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) -= ui).str(), (test_type(a1) -= ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) -= ui).str(), (test_type(-a1) -= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(b * ui).str(), test_type(b1 * ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-b * ui).str(), test_type(-b1 * ui).str());
      BOOST_CHECK_EQUAL(mpz_int(ui * b).str(), test_type(ui * b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) *= ui).str(), (test_type(a1) *= ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) *= ui).str(), (test_type(-a1) *= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a / ui).str(), test_type(a1 / ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / ui).str(), test_type(-a1 / ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= ui).str(), (test_type(a1) /= ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) /= ui).str(), (test_type(-a1) /= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a % ui).str(), test_type(a1 % ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % ui).str(), test_type(-a1 % ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= ui).str(), (test_type(a1) %= ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) %= ui).str(), (test_type(-a1) %= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a | ui).str(), test_type(a1 | ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) |= ui).str(), (test_type(a1) |= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a & ui).str(), test_type(a1 & ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) &= ui).str(), (test_type(a1) &= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a ^ ui).str(), test_type(a1 ^ ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) ^= ui).str(), (test_type(a1) ^= ui).str());
      BOOST_CHECK_EQUAL(mpz_int(ui | a).str(), test_type(ui | a1).str());
      BOOST_CHECK_EQUAL(mpz_int(ui & a).str(), test_type(ui & a1).str());
      BOOST_CHECK_EQUAL(mpz_int(ui ^ a).str(), test_type(ui ^ a1).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, ui)).str(), test_type(gcd(a1, ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(ui, b)).str(), test_type(gcd(ui, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, ui)).str(), test_type(lcm(c1, ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(ui, d)).str(), test_type(lcm(ui, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, ui)).str(), test_type(gcd(-a1, ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, ui)).str(), test_type(lcm(-c1, ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(ui, -b)).str(), test_type(gcd(ui, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(ui, -d)).str(), test_type(lcm(ui, -d1)).str());

      if (std::numeric_limits<test_type>::is_modulo && checked::value)
      {
         static mpz_int m = mpz_int(1) << std::numeric_limits<test_type>::digits;
         mpz_int        t(a);
         test_type      t1(a1);
         for (unsigned i = 0; i < 10; ++i)
         {
            t *= a;
            t %= m;
            t += a;
            t %= m;
            t1 *= a1;
            t1 += a1;
         }
         BOOST_CHECK_EQUAL(t.str(), t1.str());
      }
   }
   void t4_large()
   {
      using namespace boost::multiprecision;
      // Now check operations involving unsigned integers:
      BOOST_CHECK_EQUAL(mpz_int(a + large_ui).str(), test_type(a1 + large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a + large_ui).str(), test_type(-a1 + large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui + a).str(), test_type(large_ui + a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) += large_ui).str(), (test_type(a1) += large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) += large_ui).str(), (test_type(-a1) += large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a - large_ui).str(), test_type(a1 - large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a - large_ui).str(), test_type(-a1 - large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui - a).str(), test_type(large_ui - a1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) -= large_ui).str(), (test_type(a1) -= large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) -= large_ui).str(), (test_type(-a1) -= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(b * large_ui).str(), test_type(b1 * large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-b * large_ui).str(), test_type(-b1 * large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui * b).str(), test_type(large_ui * b1).str());
      BOOST_CHECK_EQUAL((mpz_int(a) *= large_ui).str(), (test_type(a1) *= large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) *= large_ui).str(), (test_type(-a1) *= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a / large_ui).str(), test_type(a1 / large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / large_ui).str(), test_type(-a1 / large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) /= large_ui).str(), (test_type(a1) /= large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) /= large_ui).str(), (test_type(-a1) /= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a % large_ui).str(), test_type(a1 % large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % large_ui).str(), test_type(-a1 % large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) %= large_ui).str(), (test_type(a1) %= large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(-a) %= large_ui).str(), (test_type(-a1) %= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a | large_ui).str(), test_type(a1 | large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) |= large_ui).str(), (test_type(a1) |= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a & large_ui).str(), test_type(a1 & large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) &= large_ui).str(), (test_type(a1) &= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(a ^ large_ui).str(), test_type(a1 ^ large_ui).str());
      BOOST_CHECK_EQUAL((mpz_int(a) ^= large_ui).str(), (test_type(a1) ^= large_ui).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui | a).str(), test_type(large_ui | a1).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui & a).str(), test_type(large_ui & a1).str());
      BOOST_CHECK_EQUAL(mpz_int(large_ui ^ a).str(), test_type(large_ui ^ a1).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, large_ui)).str(), test_type(gcd(a1, large_ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(large_ui, b)).str(), test_type(gcd(large_ui, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(c, large_ui)).str(), test_type(gcd(c1, large_ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, large_ui)).str(), test_type(lcm(c1, large_ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(large_ui, d)).str(), test_type(lcm(large_ui, d1)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(-a, large_ui)).str(), test_type(gcd(-a1, large_ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(-c, large_ui)).str(), test_type(lcm(-c1, large_ui)).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(large_ui, -b)).str(), test_type(gcd(large_ui, -b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(large_ui, -d)).str(), test_type(lcm(large_ui, -d1)).str());
   }

   void t5()
   {
      using namespace boost::multiprecision;
      //
      // Now integer functions:
      //
      mpz_int   z1, z2;
      test_type t1, t2;
      divide_qr(a, b, z1, z2);
      divide_qr(a1, b1, t1, t2);
      BOOST_CHECK_EQUAL(z1.str(), t1.str());
      BOOST_CHECK_EQUAL(z2.str(), t2.str());
      BOOST_CHECK_EQUAL(integer_modulus(a, si), integer_modulus(a1, si));
      BOOST_CHECK_EQUAL(integer_modulus(a, ui), integer_modulus(a1, ui));
      BOOST_CHECK_EQUAL(mpz_int(integer_modulus(a, large_ui)).str(), test_type(integer_modulus(a1, large_ui)).str());
      BOOST_CHECK_EQUAL(lsb(a), lsb(a1));
      BOOST_CHECK_EQUAL(msb(a), msb(a1));

      for (unsigned i = 0; i < 1000; i += 13)
      {
         BOOST_CHECK_EQUAL(bit_test(a, i), bit_test(a1, i));
      }
      if (!std::numeric_limits<test_type>::is_modulo)
      {
         // We have to take care that our powers don't grow too large, otherwise this takes "forever",
         // also don't test for modulo types, as these may give a different result from arbitrary
         // precision types:
         BOOST_CHECK_EQUAL(mpz_int(pow(d, ui % 19)).str(), test_type(pow(d1, ui % 19)).str());
         BOOST_CHECK_EQUAL(mpz_int(powm(a, b, c)).str(), test_type(powm(a1, b1, c1)).str());
         BOOST_CHECK_EQUAL(mpz_int(powm(a, b, ui)).str(), test_type(powm(a1, b1, ui)).str());
         BOOST_CHECK_EQUAL(mpz_int(powm(a, ui, c)).str(), test_type(powm(a1, ui, c1)).str());
      }
      BOOST_CHECK_EQUAL(lsb(a), lsb(a1));
      BOOST_CHECK_EQUAL(msb(a), msb(a1));
   }

   static void test_bug_cases()
   {
      if (!std::numeric_limits<test_type>::is_bounded)
      {
         // https://svn.boost.org/trac/boost/ticket/7878
         test_type a("0x1000000000000000000000000000000000000000000000000000000000000000");
         test_type b = 0xFFFFFFFF;
         test_type c = a * b + b; // quotient has 1 in the final place
         test_type q, r;
         divide_qr(c, b, q, r);
         BOOST_CHECK_EQUAL(a + 1, q);
         BOOST_CHECK_EQUAL(r, 0);

         b = static_cast<test_type>("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
         c = a * b + b; // quotient has 1 in the final place
         divide_qr(c, b, q, r);
         BOOST_CHECK_EQUAL(a + 1, q);
         BOOST_CHECK_EQUAL(r, 0);
         //
         // Not a bug, but test some other special cases that don't otherwise occur through
         // random testing:
         //
         c = a * b; // quotient has zero in the final place
         divide_qr(c, b, q, r);
         BOOST_CHECK_EQUAL(q, a);
         BOOST_CHECK_EQUAL(r, 0);
         divide_qr(c, a, q, r);
         BOOST_CHECK_EQUAL(q, b);
         BOOST_CHECK_EQUAL(r, 0);
         ++c;
         divide_qr(c, b, q, r);
         BOOST_CHECK_EQUAL(q, a);
         BOOST_CHECK_EQUAL(r, 1);
      }
      // Bug https://svn.boost.org/trac/boost/ticket/8126:
      test_type a("-4294967296");
      test_type b("4294967296");
      test_type c("-1");
      a = (a / b);
      BOOST_CHECK_EQUAL(a, -1);
      a = -4294967296;
      a = (a / b) * c;
      BOOST_CHECK_EQUAL(a, 1);
      a = -23;
      b = 23;
      a = (a / b) * c;
      BOOST_CHECK_EQUAL(a, 1);
      a = -23;
      a = (a / b) / c;
      BOOST_CHECK_EQUAL(a, 1);
      a = test_type("-26607734784073568386365259775");
      b = test_type("8589934592");
      a = a / b;
      BOOST_CHECK_EQUAL(a, test_type("-3097548007973652377"));
      // Bug https://svn.boost.org/trac/boost/ticket/8133:
      a           = test_type("0x12345600012434ffffffffffffffffffffffff");
      unsigned ui = 0xffffffff;
      a           = a - ui;
      BOOST_CHECK_EQUAL(a, test_type("0x12345600012434ffffffffffffffff00000000"));
      a = test_type("0x12345600012434ffffffffffffffffffffffff");
#ifndef BOOST_NO_LONG_LONG
      unsigned long long ull = 0xffffffffffffffffuLL;
      a                      = a - ull;
      BOOST_CHECK_EQUAL(a, test_type("0x12345600012434ffffffff0000000000000000"));
#endif
      //
      // Now check that things which should be zero really are
      // https://svn.boost.org/trac/boost/ticket/8145:
      //
      a = -1;
      a += 1;
      BOOST_CHECK_EQUAL(a, 0);
      a = 1;
      a += -1;
      BOOST_CHECK_EQUAL(a, 0);
      a = -1;
      a += test_type(1);
      BOOST_CHECK_EQUAL(a, 0);
      a = 1;
      a += test_type(-1);
      BOOST_CHECK_EQUAL(a, 0);
      a = test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
      a -= test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
      BOOST_CHECK_EQUAL(a, 0);
      a = -test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
      a += test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
      BOOST_CHECK_EQUAL(a, 0);
      a = 2;
      a *= 0;
      BOOST_CHECK_EQUAL(a, 0);
      a = -2;
      a *= 0;
      BOOST_CHECK_EQUAL(a, 0);
      a = 2;
      a *= test_type(0);
      BOOST_CHECK_EQUAL(a, 0);
      a = -2;
      a *= test_type(0);
      BOOST_CHECK_EQUAL(a, 0);
      a = -2;
      a /= 50;
      BOOST_CHECK_EQUAL(a, 0);
      a = -test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
      a /= (1 + test_type("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));
      BOOST_CHECK_EQUAL(a, 0);
      // https://svn.boost.org/trac/boost/ticket/8160
      a = 1;
      a = 0 / test_type(1);
      BOOST_CHECK_EQUAL(a, 0);
      a = 1;
      a = 0 % test_type(25);
      BOOST_CHECK_EQUAL(a, 0);
#if !defined(TEST2) && !defined(TEST6)
      // https://svn.boost.org/trac/boost/ticket/11364
      a           = 0xfffffffeu;
      b           = -2;
      c           = a ^ b;
      test_type d = ~(a ^ ~b);
      BOOST_CHECK_EQUAL(c, d);
#endif
#if defined(TEST2) || defined(TEST3) || defined(TEST6)
      // https://svn.boost.org/trac/boost/ticket/11648
      a = (std::numeric_limits<test_type>::max)() - 69;
      b = a / 139;
      ++b;
      c           = a / b;
      test_type r = a % b;
      BOOST_CHECK(r < b);
      BOOST_CHECK_EQUAL(a - c * b, r);
#endif
      for (ui = 0; ui < 1000; ++ui)
      {
         boost::multiprecision::mpz_int t;
         boost::multiprecision::mpz_int s1 = sqrt(boost::multiprecision::mpz_int(ui), t);
         a                                 = sqrt(test_type(ui), b);
         BOOST_CHECK_EQUAL(a.str(), s1.str());
         BOOST_CHECK_EQUAL(b.str(), t.str());
         a = sqrt(test_type(ui) + test_type(0));
         BOOST_CHECK_EQUAL(a.str(), s1.str());
         a = sqrt(test_type(ui) * test_type(1));
         BOOST_CHECK_EQUAL(a.str(), s1.str());
         a = sqrt(test_type(ui) * 1, b);
         BOOST_CHECK_EQUAL(a.str(), s1.str());
         BOOST_CHECK_EQUAL(b.str(), t.str());
      }
      a = -1;
      ++a;
      BOOST_CHECK_EQUAL(a, 0);
      ++--a;
      BOOST_CHECK_EQUAL(a, 0);
      --++a;
      BOOST_CHECK_EQUAL(a, 0);

      {
         typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<> >                                                                                            bigint;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> >   u64;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<128, 128, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u128;
         typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u256;
         typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >   s256;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u160;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >   s160;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 512, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > u512;
         //typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 512, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >   s512;

         {
            u256   a = 14;
            bigint b = bigint("115792089237316195423570985008687907853269984665640564039457584007913129639948");
            // to fix cast `a` to dev::bigint
            BOOST_CHECK(a < b);
         }
         {
            u256            a      = 1;
            std::uint64_t amount = 1;
            u256            b      = a << amount;
            BOOST_CHECK_EQUAL(b, 2);

            u256 high_bit = u256(0);
            bit_set(high_bit, 255);
            BOOST_CHECK_EQUAL(a << 255, high_bit);
            BOOST_CHECK_EQUAL(a << std::uint64_t(256), 0);
            BOOST_CHECK_EQUAL(a << 0, a);

            u256 c = 3;
            BOOST_CHECK_EQUAL(c, 3);
            BOOST_CHECK_EQUAL(c << std::uint64_t(256), 0);
            BOOST_CHECK_EQUAL(c << 0, c);

            // Bug workaround:
            BOOST_CHECK_EQUAL(static_cast<u256>(bigint(u256(3)) << 255), u256(1) << 255);
         }
         {
            BOOST_CHECK_EQUAL(u256(3) << 255, u256(1) << 255);

            u256            a      = 1;
            std::uint64_t amount = 1;
            u256            b      = a >> amount;
            BOOST_CHECK_EQUAL(b, 0);
            BOOST_CHECK_EQUAL(a >> 255, 0);
            BOOST_CHECK_EQUAL(a >> std::uint64_t(256), 0);
            BOOST_CHECK_EQUAL(a >> std::uint64_t(-1), 0);

            u256 h;
            bit_set(h, 255);
            BOOST_CHECK_EQUAL(h >> 0, u256(1) << 255);
            BOOST_CHECK_EQUAL(h >> 1, u256(1) << 254);
            BOOST_CHECK_EQUAL(h >> 2, u256(1) << 253);
            BOOST_CHECK_EQUAL(h >> 254, u256(1) << 1);
            BOOST_CHECK_EQUAL(h >> 255, u256(1) << 0);
            BOOST_CHECK_EQUAL(h >> 256, 0);
            BOOST_CHECK_EQUAL(h >> std::uint64_t(-1), 0);

            u256 g;
            bit_set(g, 255);
            bit_set(g, 254);
            BOOST_CHECK_EQUAL(g >> 255, 1);
            BOOST_CHECK_EQUAL(g >> 254, 3);
            BOOST_CHECK_EQUAL(g >> 253, 3 << 1);
            BOOST_CHECK_EQUAL(g >> 252, 3 << 2);
            BOOST_CHECK_EQUAL(g >> 251, 3 << 3);
            BOOST_CHECK_EQUAL(g >> 0, u256(3) << 254);
            BOOST_CHECK_EQUAL(g >> 1, u256(3) << 253);
            BOOST_CHECK_EQUAL(g >> 2, u256(3) << 252);
            BOOST_CHECK_EQUAL(g >> 3, u256(3) << 251);
            BOOST_CHECK_EQUAL(g >> 100, u256(3) << 154);
            BOOST_CHECK_EQUAL(g >> 256, 0);
            BOOST_CHECK_EQUAL(g >> 257, 0);
            BOOST_CHECK_EQUAL(g >> std::uint32_t(-1), 0);
            BOOST_CHECK_EQUAL(g >> std::uint64_t(-1), 0);
            BOOST_CHECK_EQUAL(g >> std::uint16_t(-1), 0);
            BOOST_CHECK_EQUAL(g >> (std::uint16_t(-1) - 1), 0);
         }
         {
            s256     a      = 1;
            uint64_t amount = 1;
            s256     b      = a >> amount;
            BOOST_CHECK_EQUAL(b, 0);
            BOOST_CHECK_EQUAL(a >> 255, 0);
            BOOST_CHECK_EQUAL(a >> std::uint64_t(256), 0);
            BOOST_CHECK_EQUAL(a >> std::uint64_t(-1), 0);

            s256 n = -1;
            BOOST_CHECK_EQUAL(n >> 0, n);
            BOOST_CHECK_EQUAL(n >> 1, n);
            BOOST_CHECK_EQUAL(n >> 2, n);
            BOOST_CHECK_EQUAL(n >> 254, n);
            BOOST_CHECK_EQUAL(n >> 255, n);
            BOOST_CHECK_EQUAL(n >> 256, n);
            BOOST_CHECK_EQUAL(n >> 257, n);
            BOOST_CHECK_EQUAL(n >> ~std::uint64_t(0), n);

            // Test min value. This actually -(2^256-1), not -(2^255) as in C.
            s256 h = (std::numeric_limits<s256>::min)();
            BOOST_CHECK_LT(h, 0);
            BOOST_CHECK_EQUAL(h >> 0, h);
            BOOST_CHECK_EQUAL(h >> 256, -1);

            // Test EVM min value.
            s256 g = s256(-1) << 255;
            BOOST_CHECK_LT(g, 0);
            BOOST_CHECK_EQUAL(static_cast<u256>(g), u256(1) << 255);
            BOOST_CHECK_EQUAL(g >> 0, g);
            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 1), u256(0b11) << 254);
            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 2), u256(0b111) << 253);
            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 3), u256(0b1111) << 252);

            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 255), ~u256(0));
            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 254), ~u256(0b1));
            BOOST_CHECK_EQUAL(static_cast<u256>(g >> 253), ~u256(0b11));

            // Test shifting more that one bit.
            s256 k = s256(0b111) << 252;
            BOOST_CHECK_EQUAL(k, u256(0b111) << 252);
            BOOST_CHECK_EQUAL(k >> 1, u256(0b111) << 251);
            BOOST_CHECK_EQUAL(k >> 2, u256(0b111) << 250);
            BOOST_CHECK_EQUAL(k >> 252, 0b111);
            BOOST_CHECK_EQUAL(k >> 253, 0b11);
            BOOST_CHECK_EQUAL(k >> 254, 0b1);
            BOOST_CHECK_EQUAL(k >> 255, 0);
            BOOST_CHECK_EQUAL(k >> 256, 0);
            BOOST_CHECK_EQUAL(k >> ~std::uint32_t(0), 0);

            // Division equivalence.

            // Built-in type:
            if (std::numeric_limits<std::int64_t>::is_specialized)
            {
               std::int64_t d = (std::numeric_limits<std::int64_t>::min)();
               BOOST_CHECK_EQUAL(d >> 1, d / 2);
               int64_t e = d + 1;
               BOOST_CHECK_EQUAL(e >> 1, e / 2 - 1);

               // Boost type:
               BOOST_CHECK_EQUAL(h >> 1, h / 2 - 1);
            }
         }
      }
   }

   void test()
   {
      using namespace boost::multiprecision;

      test_bug_cases();

      last_error_count = 0;

      BOOST_CHECK_EQUAL(Number(), 0);

      for (int i = 0; i < 10000; ++i)
      {
         a = generate_random<mpz_int>(1000);
         b = generate_random<mpz_int>(512);
         c = generate_random<mpz_int>(256);
         d = generate_random<mpz_int>(32);

         si = d.convert_to<int>();
         ui = si;
         large_ui = c.convert_to<boost::multiprecision::double_limb_type>();

         a1 = static_cast<test_type>(a.str());
         b1 = static_cast<test_type>(b.str());
         c1 = static_cast<test_type>(c.str());
         d1 = static_cast<test_type>(d.str());

         t1();
         t2();
#ifndef SLOW_COMPILER
         t3();
         t4();
         t4_large();
         t5();
#endif

         if (last_error_count != (unsigned)boost::detail::test_errors())
         {
            last_error_count = boost::detail::test_errors();
            std::cout << std::hex << std::showbase;

            std::cout << "a    = " << a << std::endl;
            std::cout << "a1   = " << a1 << std::endl;
            std::cout << "b    = " << b << std::endl;
            std::cout << "b1   = " << b1 << std::endl;
            std::cout << "c    = " << c << std::endl;
            std::cout << "c1   = " << c1 << std::endl;
            std::cout << "d    = " << d << std::endl;
            std::cout << "d1   = " << d1 << std::endl;
            std::cout << "a + b   = " << a + b << std::endl;
            std::cout << "a1 + b1 = " << a1 + b1 << std::endl;
            std::cout << std::dec;
            std::cout << "a - b   = " << a - b << std::endl;
            std::cout << "a1 - b1 = " << a1 - b1 << std::endl;
            std::cout << "-a + b   = " << mpz_int(-a) + b << std::endl;
            std::cout << "-a1 + b1 = " << test_type(-a1) + b1 << std::endl;
            std::cout << "-a - b   = " << mpz_int(-a) - b << std::endl;
            std::cout << "-a1 - b1 = " << test_type(-a1) - b1 << std::endl;
            std::cout << "c*d    = " << c * d << std::endl;
            std::cout << "c1*d1  = " << c1 * d1 << std::endl;
            std::cout << "b*c    = " << b * c << std::endl;
            std::cout << "b1*c1  = " << b1 * c1 << std::endl;
            std::cout << "a/b    = " << a / b << std::endl;
            std::cout << "a1/b1  = " << a1 / b1 << std::endl;
            std::cout << "a/d    = " << a / d << std::endl;
            std::cout << "a1/d1  = " << a1 / d1 << std::endl;
            std::cout << "a%b    = " << a % b << std::endl;
            std::cout << "a1%b1  = " << a1 % b1 << std::endl;
            std::cout << "a%d    = " << a % d << std::endl;
            std::cout << "a1%d1  = " << a1 % d1 << std::endl;
         }

         //
         // Check to see if test is taking too long.
         // Tests run on the compiler farm time out after 300 seconds,
         // so don't get too close to that:
         //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
         if (tim.elapsed() > 200)
#else
         if (tim.elapsed() > 25)
#endif
         {
            std::cout << "Timeout reached, aborting tests now....\n";
            break;
         }
      }
   }
};

int main()
{
   using namespace boost::multiprecision;

#ifdef TEST1
   tester<cpp_int> t1;
   t1.test();
#endif
#ifdef TEST2
   tester<number<cpp_int_backend<2048, 2048, signed_magnitude, checked, void> > > t2;
   t2.test();
#endif
#ifdef TEST3
   // Unchecked test verifies modulo arithmetic:
   tester<number<cpp_int_backend<2048, 2048, signed_magnitude, unchecked, void> > > t3;
   t3.test();
#endif
#ifdef TEST4
   tester<number<cpp_int_backend<0, 2048, signed_magnitude, unchecked, std::allocator<char> > > > t4;
   t4.test();
#endif
#ifdef TEST5
   tester<number<cpp_int_backend<0, 2048, signed_magnitude, unchecked> > > t5;
   t5.test();
#endif
#ifdef TEST6
   tester<number<cpp_int_backend<2048, 2048, signed_magnitude, checked, void> > > t6;
   t6.test();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_conv.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_int.hpp>

int main()
{
   using namespace boost::multiprecision;
   //
   // Test interconversions between different precisions:
   //
   cpp_int                                                           i1(2);
   int128_t                                                          i2(3);
   int256_t                                                          i3(4);
   number<cpp_int_backend<32, 32, signed_magnitude, checked, void> > i4(5);

   i1 = i3;
   BOOST_TEST(i1 == 4);
   i1 = i4;
   BOOST_TEST(i1 == 5);

   i3 = -1234567;
   i4 = -5677334;
   i1 = i3;
   BOOST_TEST(i1 == -1234567);
   i1 = i4;
   BOOST_TEST(i1 == -5677334);

   i3 = i2;
   BOOST_TEST(i3 == 3);

   i3 = -1234567;

   uint128_t i5(i3);
   BOOST_TEST(i5 == -1234567);

   int128_t i6(i4);
   BOOST_TEST(i6 == -5677334);

   number<cpp_int_backend<32, 32, signed_magnitude, unchecked, void>, et_off> i7(i3);
   BOOST_TEST(i7 == -1234567);

   int256_t i8(i6);
   BOOST_TEST(i8 == -5677334);

   i7.assign(4.0);
   BOOST_TEST(i7 == 4);

   number<cpp_int_backend<30, 30, signed_magnitude, checked, void>, et_off> i9(-5677334);
   i7 = i9;
   BOOST_TEST(i7 == -5677334);
   i7 = number<cpp_int_backend<32, 32, signed_magnitude, checked, void>, et_off>(i9);
   BOOST_TEST(i7 == -5677334);

   i9 = static_cast<number<cpp_int_backend<30, 30, signed_magnitude, checked, void>, et_off> >(i7);
   BOOST_TEST(i9 == -5677334);

   ++i9;
   i7 = i9;
   BOOST_TEST(i7 == 1 - 5677334);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_deserial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

#include <iostream>
#include <iomanip>
#include <fstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/exception/all.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>

boost::filesystem::path root;

template <class T>
void test64()
{
   using namespace boost::multiprecision;

   const char* text_array[] = {
       "4991075498124186",
       "-4991075498124186",
       "750",
       "-750",
       "415210192158791091",
       "-415210192158791091",
       "2172493004228646",
       "-2172493004228646",
       "993",
       "-993",
       "801484291299519218",
       "-801484291299519218",
       "294605502329193119",
       "-294605502329193119",
       "52506",
       "-52506",
       "1509449075377",
       "-1509449075377",
       "2042599",
       "-2042599",
       "228",
       "-228",
       "38666759073",
       "-38666759073",
       "611489",
       "-611489",
       "5393",
       "-5393",
       "12930071684",
       "-12930071684",
       "3606852234541437552",
       "-3606852234541437552",
       "3764404188985662264",
       "-3764404188985662264",
       "13300301596736993408",
       "-13300301596736993408",
       "3519758520509816019",
       "-3519758520509816019",
       "811951798554103911",
       "-811951798554103911",
       "2440",
       "-2440",
       "175149377023342",
       "-175149377023342",
       "5347169560611466452",
       "-5347169560611466452",
       "187134495165780485",
       "-187134495165780485",
       "761263991097466327",
       "-761263991097466327",
       "205",
       "-205",
       "7437277938",
       "-7437277938",
       "2530448830165700",
       "-2530448830165700",
       "3771546153060183",
       "-3771546153060183",
       "1238034",
       "-1238034",
       "1470",
       "-1470",
       "7",
       "-7",
       "203065689",
       "-203065689",
       "130",
       "-130",
       "74717518653749632",
       "-74717518653749632",
       "3028698162338",
       "-3028698162338",
       "3471587482356581",
       "-3471587482356581",
       "34698219712863216",
       "-34698219712863216",
       "941191493582057728",
       "-941191493582057728",
       "14803251323",
       "-14803251323",
       "552076672455",
       "-552076672455",
       "410481316632532",
       "-410481316632532",
       "6",
       "-6",
       "3851011",
       "-3851011",
       "12895806074024545",
       "-12895806074024545",
       "59538",
       "-59538",
       "944776298737546117",
       "-944776298737546117",
       "25010240662345",
       "-25010240662345",
       "29657097213970",
       "-29657097213970",
       "88000252",
       "-88000252",
       "545263458410825",
       "-545263458410825",
       "216600129907865",
       "-216600129907865",
       "262741237793873",
       "-262741237793873",
       "226964744",
       "-226964744",
       "111776857",
       "-111776857",
       "346922769",
       "-346922769",
       "7324307011273",
       "-7324307011273",
       "182",
       "-182",
       "4204",
       "-4204",
       "60455",
       "-60455",
       "35250836865461",
       "-35250836865461",
       "4100298085120029",
       "-4100298085120029",
       "6",
       "-6",
       "3262369",
       "-3262369",
       "103928",
       "-103928",
       "82055266594432948",
       "-82055266594432948",
       "8",
       "-8",
       "1731",
       "-1731",
       "338",
       "-338",
       "13202690186510006305",
       "-13202690186510006305",
       "3916209444926814",
       "-3916209444926814",
       "1801701990484582",
       "-1801701990484582",
       "54042343363098",
       "-54042343363098",
       "86",
       "-86",
       "1346703",
       "-1346703",
       "34499847353417",
       "-34499847353417",
       "870972860051498248",
       "-870972860051498248",
       "2676223213",
       "-2676223213",
       "10",
       "-10",
       "2207730666882",
       "-2207730666882",
       "256557933",
       "-256557933",
       "742",
       "-742",
       "17809514",
       "-17809514",
       "41738",
       "-41738",
       "937490350973899",
       "-937490350973899",
       "10",
       "-10",
       "2153955175933399",
       "-2153955175933399",
       "21",
       "-21",
       "9767",
       "-9767",
       "160991545",
       "-160991545",
       "5537202949",
       "-5537202949",
       "1729222816",
       "-1729222816",
       "880543773",
       "-880543773",
       "4994415770",
       "-4994415770",
       "5667270210124",
       "-5667270210124",
       "1789552738407096",
       "-1789552738407096",
       "52084908492459",
       "-52084908492459",
       "419923376385918098",
       "-419923376385918098",
       "193184120308428",
       "-193184120308428",
       "3716593161704457",
       "-3716593161704457",
       "835313",
       "-835313",
       "47794728416344",
       "-47794728416344",
       "32162267350660",
       "-32162267350660",
       "1",
       "-1",
       "6746653265049",
       "-6746653265049",
       "72924075986572",
       "-72924075986572",
       "4061",
       "-4061",
       "1776612112178",
       "-1776612112178",
       "798",
       "-798",
       "266401037",
       "-266401037",
       "6773927626",
       "-6773927626",
       "935572859041371",
       "-935572859041371",
       "2667878767142547263",
       "-2667878767142547263",
       "107694081993",
       "-107694081993",
       "2478862",
       "-2478862",
       "75439252494463178",
       "-75439252494463178",
       "502732137506",
       "-502732137506",
       "1345285828338743",
       "-1345285828338743",
       "15181",
       "-15181",
       "6",
       "-6",
       "503497089658971",
       "-503497089658971",
       "3925896855680859",
       "-3925896855680859",
       "259231",
       "-259231",
       "7499637741115431",
       "-7499637741115431",
       "16282283214",
       "-16282283214",
       "1664259700668569315",
       "-1664259700668569315",
       "63205423227654",
       "-63205423227654",
       "122839112",
       "-122839112",
       "254133246000861645",
       "-254133246000861645",
       "324448699",
       "-324448699",
       "2634830651678498499",
       "-2634830651678498499",
       "65612160397",
       "-65612160397",
       "7064926544",
       "-7064926544",
       "3816",
       "-3816",
       "1964",
       "-1964",
       "208639360759781",
       "-208639360759781",
       "3910",
       "-3910",
       "95080",
       "-95080",
       "175945",
       "-175945",
       "5880392757177227",
       "-5880392757177227",
       "17254376508100660",
       "-17254376508100660",
       "16568677462108662019",
       "-16568677462108662019",
       "193490",
       "-193490",
       "6055816",
       "-6055816",
       "4421583059373970",
       "-4421583059373970",
       "34879",
       "-34879",
       "52778",
       "-52778",
       "0",
       "0",
       "935000170463558922",
       "-935000170463558922",
       "173",
       "-173",
       "10327678",
       "-10327678",
       "45810516546119519",
       "-45810516546119519",
       "8712",
       "-8712",
       "1932876094515139",
       "-1932876094515139",
       "84388",
       "-84388",
       "2050813773845403160",
       "-2050813773845403160",
       "1542848238524",
       "-1542848238524",
       "1555584758215827",
       "-1555584758215827",
       "3571489748",
       "-3571489748",
       "18291705113053112226",
       "-18291705113053112226",
       "5713248",
       "-5713248",
       "43",
       "-43",
       "7537188724850197",
       "-7537188724850197",
       "3450872745386207",
       "-3450872745386207",
       "335595262120",
       "-335595262120",
       "481778267224",
       "-481778267224",
       "86277827129",
       "-86277827129",
       "132147177032651",
       "-132147177032651",
       "222305704702019735",
       "-222305704702019735",
       "15454425372201",
       "-15454425372201",
       "37444",
       "-37444",
       "14915074751748",
       "-14915074751748",
       "322332143987563",
       "-322332143987563",
       "126997604",
       "-126997604",
       "484901511158709",
       "-484901511158709",
       "7452547923",
       "-7452547923",
       "43400437",
       "-43400437",
       "950",
       "-950",
       "133435748899",
       "-133435748899",
       "13225323986",
       "-13225323986",
       "113",
       "-113",
       "31298263",
       "-31298263",
       "33",
       "-33",
       "11093233",
       "-11093233",
       "13921728621",
       "-13921728621",
       "256811828405",
       "-256811828405",
       "568533463853249",
       "-568533463853249",
       "384553",
       "-384553",
       "1046793359495877872",
       "-1046793359495877872",
       "3513488911471240501",
       "-3513488911471240501",
       "999",
       "-999",
       "3257",
       "-3257",
       "141868737283",
       "-141868737283",
       "97723548",
       "-97723548",
       "380232796",
       "-380232796",
       "11615871",
       "-11615871",
       "2",
       "-2",
       "516935083428",
       "-516935083428",
       "2767393",
       "-2767393",
       "74918721",
       "-74918721",
       "7083",
       "-7083",
       "497484184665289623",
       "-497484184665289623",
       "3309660146889781",
       "-3309660146889781",
       "795624163",
       "-795624163",
       "1739075",
       "-1739075",
       "38737391516580422",
       "-38737391516580422",
       "33363484068",
       "-33363484068",
       "453947517553",
       "-453947517553",
       "7206",
       "-7206",
       "912",
       "-912",
       "1070565937975",
       "-1070565937975",
       "3607679046",
       "-3607679046",
       "503313",
       "-503313",
       "5384337",
       "-5384337",
       "7913554120377",
       "-7913554120377",
       "4112847188",
       "-4112847188",
       "8191226371802",
       "-8191226371802",
       "41268527630506",
       "-41268527630506",
       "446828884957609",
       "-446828884957609",
       "17378379828995102574",
       "-17378379828995102574",
       "802194395",
       "-802194395",
       "6459076776036",
       "-6459076776036",
       "189",
       "-189",
       "456272745323742742",
       "-456272745323742742",
       "35245",
       "-35245",
       "4142317167",
       "-4142317167",
       "240455833189507891",
       "-240455833189507891",
       "32426861928",
       "-32426861928",
       "3464",
       "-3464",
       "15152220677",
       "-15152220677",
       "8550134950160679",
       "-8550134950160679",
       "226598734",
       "-226598734",
       "35686909663",
       "-35686909663",
       "59277903563",
       "-59277903563",
       "6946537179316043375",
       "-6946537179316043375",
       "516198226",
       "-516198226",
       "54",
       "-54",
       "27406574726722597",
       "-27406574726722597",
       "717765982",
       "-717765982",
       "540734180837",
       "-540734180837",
       "381",
       "-381",
       "2883798342",
       "-2883798342",
       "2454889904722697593",
       "-2454889904722697593",
       "5324758776781459411",
       "-5324758776781459411",
       "0",
       "0",
       "3",
       "-3",
       "758016775051877",
       "-758016775051877",
       "6368641396491647651",
       "-6368641396491647651",
       "2409862725919775",
       "-2409862725919775",
       "19831125",
       "-19831125",
       "19839578195623645",
       "-19839578195623645",
       "19556929453271",
       "-19556929453271",
       "245",
       "-245",
       "83382",
       "-83382",
       "30044944",
       "-30044944",
       "10307835790108389",
       "-10307835790108389",
       "266904",
       "-266904",
       "29",
       "-29",
       "1691697088175268",
       "-1691697088175268",
       "6361142035143",
       "-6361142035143",
       "440939789",
       "-440939789",
       "19836890767598",
       "-19836890767598",
       "78676472953102968",
       "-78676472953102968",
       "1663",
       "-1663",
       "7103",
       "-7103",
       "2602952185917450011",
       "-2602952185917450011",
       "8018",
       "-8018",
       "244",
       "-244",
       "1908",
       "-1908",
       "394626",
       "-394626",
       "559",
       "-559",
       "2692219006891972",
       "-2692219006891972",
       "13265871632018922",
       "-13265871632018922",
       "124",
       "-124",
       "222927115625",
       "-222927115625",
       "1283014176523",
       "-1283014176523",
       "63800278885",
       "-63800278885",
       "0",
       "0",
       "1829",
       "-1829",
       "13920824467759",
       "-13920824467759",
       "5133342577177325",
       "-5133342577177325",
       "11207577826",
       "-11207577826",
       "1482655119893",
       "-1482655119893",
       "200471339",
       "-200471339",
       "14758141",
       "-14758141",
       "29794",
       "-29794",
       "17080244",
       "-17080244",
       "699",
       "-699",
       "33751076",
       "-33751076",
       "16396192",
       "-16396192",
       "98",
       "-98",
       "81983490866862",
       "-81983490866862",
       "102679",
       "-102679",
       "13",
       "-13",
       "300",
       "-300",
       "195317",
       "-195317",
       "8257",
       "-8257",
       "9944069581",
       "-9944069581",
       "63162",
       "-63162",
       "2814124367772394",
       "-2814124367772394",
       "136699870",
       "-136699870",
       "2298044154057333478",
       "-2298044154057333478",
       "14",
       "-14",
       "15514009231077760",
       "-15514009231077760",
       "183794877561119741",
       "-183794877561119741",
       "1799598",
       "-1799598",
       "1873291206216770568",
       "-1873291206216770568",
       "31",
       "-31",
       "5025013349",
       "-5025013349",
       "26376",
       "-26376",
       "905247925",
       "-905247925",
       "36545804839",
       "-36545804839",
       "960743",
       "-960743",
       "90208569247342191",
       "-90208569247342191",
       "148711261716954186",
       "-148711261716954186",
       "15491943",
       "-15491943",
       "15539960",
       "-15539960",
       "15",
       "-15",
       "39",
       "-39",
       "7901",
       "-7901",
       "2124324987051603",
       "-2124324987051603",
       "45033487059826453",
       "-45033487059826453",
       "87387056",
       "-87387056",
       "13621",
       "-13621",
       "36002",
       "-36002",
       "130430",
       "-130430",
       "65703401",
       "-65703401",
       "7703922866",
       "-7703922866",
       "171",
       "-171",
       "61731",
       "-61731",
       "1387",
       "-1387",
       "8049274895",
       "-8049274895",
       "1951008680589745867",
       "-1951008680589745867",
       "2763480591525312699",
       "-2763480591525312699",
       "446243894833471417",
       "-446243894833471417",
       "5396319104693",
       "-5396319104693",
       "162371331057",
       "-162371331057",
       "370769520766475",
       "-370769520766475",
       "1",
       "-1",
       "361477542",
       "-361477542",
       "999",
       "-999",
       "5869928506",
       "-5869928506",
       "10725949",
       "-10725949",
       "16",
       "-16",
       "4934609875259411",
       "-4934609875259411",
       "3909261",
       "-3909261",
       "1",
       "-1",
       "96362",
       "-96362",
       "24",
       "-24",
       "206089594430410490",
       "-206089594430410490",
       "104",
       "-104",
       "5836462606744621",
       "-5836462606744621",
       "4267837773445",
       "-4267837773445",
       "485898",
       "-485898",
       "115640927033286",
       "-115640927033286",
       "1554",
       "-1554",
       "8719162940811",
       "-8719162940811",
       "2870768607",
       "-2870768607",
       "1052349661",
       "-1052349661",
       "23867197",
       "-23867197",
       "45326966103",
       "-45326966103",
       "90260998217302",
       "-90260998217302",
       "1523891",
       "-1523891",
       "666993",
       "-666993",
       "107936212247500",
       "-107936212247500",
       "1559140486984",
       "-1559140486984",
       "5874",
       "-5874",
       "5388740994398251",
       "-5388740994398251",
       "9448163810439",
       "-9448163810439",
       "1654654",
       "-1654654",
       "10590",
       "-10590",
       "54734468",
       "-54734468",
       "30749964",
       "-30749964",
       "9811424",
       "-9811424",
       "526166608342",
       "-526166608342",
       "4115859427270797",
       "-4115859427270797",
       "596517644188027",
       "-596517644188027",
       "14364215824260",
       "-14364215824260",
       "187",
       "-187",
       "24260378",
       "-24260378",
       "55791469491162660",
       "-55791469491162660",
       "2106900391",
       "-2106900391",
       "217782523580138",
       "-217782523580138",
       "1216259",
       "-1216259",
       "3275398462",
       "-3275398462",
       "343016100304169644",
       "-343016100304169644",
       "957668440",
       "-957668440",
       "6471546279",
       "-6471546279",
       "614957732",
       "-614957732",
       "130810411909693",
       "-130810411909693",
       "792104",
       "-792104",
       "465",
       "-465",
       "7782172074",
       "-7782172074",
       "55034847",
       "-55034847",
       "6775527365",
       "-6775527365",
       "12803753747546578",
       "-12803753747546578",
       "6126135608700535",
       "-6126135608700535",
       "12740679",
       "-12740679",
       "1266634072040501",
       "-1266634072040501",
       "348269777058432218",
       "-348269777058432218",
       "2184392953733",
       "-2184392953733",
       "9522770891",
       "-9522770891",
       "37077445",
       "-37077445",
       "1364",
       "-1364",
       "375540696398769",
       "-375540696398769",
       "24230",
       "-24230",
       "43119671230",
       "-43119671230",
       "1029673322569841213",
       "-1029673322569841213",
       "14194736",
       "-14194736",
       "4439459006245050525",
       "-4439459006245050525",
       "2016679919307343642",
       "-2016679919307343642",
       "68490",
       "-68490",
       "138373187496830016",
       "-138373187496830016",
       "12",
       "-12",
       "72731399395",
       "-72731399395",
       "103249241",
       "-103249241",
       "686434193208",
       "-686434193208",
       "2220097226366547",
       "-2220097226366547",
       "389615851678",
       "-389615851678",
       "1188756152",
       "-1188756152",
       "3527",
       "-3527",
       "64606107042",
       "-64606107042",
       "1628835",
       "-1628835",
       "14",
       "-14",
       "3398525351",
       "-3398525351",
       "192736533293843919",
       "-192736533293843919",
       "62739",
       "-62739",
       "29797",
       "-29797",
       "27022533997970320",
       "-27022533997970320",
       "85203884819644813",
       "-85203884819644813",
       "16723",
       "-16723",
       "720455425",
       "-720455425",
       "21193",
       "-21193",
       "911",
       "-911",
       "7564",
       "-7564",
       "9937",
       "-9937",
       "17698",
       "-17698",
       "3154835669492701",
       "-3154835669492701",
       "714419922",
       "-714419922",
       "3441710384",
       "-3441710384",
       "2302757",
       "-2302757",
       "13",
       "-13",
       "191092534665719086",
       "-191092534665719086",
       "2671438117955",
       "-2671438117955",
       "269195401",
       "-269195401",
       "1257367614616",
       "-1257367614616",
       "15233",
       "-15233",
       "242652372681",
       "-242652372681",
       "379035516581309513",
       "-379035516581309513",
       "234696334636228",
       "-234696334636228",
       "2190428804113181503",
       "-2190428804113181503",
       "5182131",
       "-5182131",
       "35710270",
       "-35710270",
       "30830418043327",
       "-30830418043327",
       "157",
       "-157",
       "56976290639537",
       "-56976290639537",
       "429094",
       "-429094",
       "8166",
       "-8166",
       "259284720",
       "-259284720",
       "1974",
       "-1974",
       "414549061889",
       "-414549061889",
       "12126192",
       "-12126192",
       "477683",
       "-477683",
       "26",
       "-26",
       "200991115623",
       "-200991115623",
       "105657935189602",
       "-105657935189602",
       "137401581416017",
       "-137401581416017",
       "3133",
       "-3133",
       "41301",
       "-41301",
       "9120545960887397",
       "-9120545960887397",
       "615",
       "-615",
       "1677628",
       "-1677628",
       "487311",
       "-487311",
       "6467819698256",
       "-6467819698256",
       "2721454",
       "-2721454",
       "356423793",
       "-356423793",
       "525408497",
       "-525408497",
       "1791793366931794",
       "-1791793366931794",
       "16267730984",
       "-16267730984",
       "787",
       "-787",
       "82",
       "-82",
       "8594582631777749056",
       "-8594582631777749056",
       "494351",
       "-494351",
       "5138",
       "-5138",
       "404787056092544",
       "-404787056092544",
       "235074602368269",
       "-235074602368269",
       "14",
       "-14",
       "364870",
       "-364870",
       "592299531695979194",
       "-592299531695979194",
       "243533",
       "-243533",
       "228268671797977",
       "-228268671797977",
       "150",
       "-150",
       "2109092292",
       "-2109092292",
       "10814341",
       "-10814341",
       "229344736512",
       "-229344736512",
       "506659",
       "-506659",
       "15065",
       "-15065",
       "73012461469893725",
       "-73012461469893725",
       "183623698",
       "-183623698",
       "30820",
       "-30820"};

   boost::filesystem::ifstream is(root / "cpp_int64_serial64.txt");
   std::cout << "Testing cpp_int64_serial64.txt with T=" << typeid(T).name() << std::endl;
   //is.peek();
   BOOST_CHECK(is.good());
   //char c = is.peek();
   //std::size_t s;
   //is >> s;
   boost::archive::text_iarchive ia(is);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
      T val;
      ia >> val;
      BOOST_CHECK_EQUAL(val, T(text_array[i]));
   }

   boost::filesystem::ifstream is2(root / "cpp_int64_serial32.txt");
   std::cout << "Testing cpp_int64_serial32.txt with T=" << typeid(T).name() << std::endl;
   //is2.peek();
   BOOST_CHECK(is2.good());
   boost::archive::text_iarchive ia2(is2);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
      T val;
      ia2 >> val;
      BOOST_CHECK_EQUAL(val, T(text_array[i]));
   }
}

template <class T>
void test128()
{
   using namespace boost::multiprecision;

   const char* text_array[] = {
       "27388486965920179246162874599461",
       "-27388486965920179246162874599461",
       "144684",
       "-144684",
       "40075268927703813213972787292005375",
       "-40075268927703813213972787292005375",
       "185882978840350932616815972016599",
       "-185882978840350932616815972016599",
       "118042",
       "-118042",
       "18836407318976510834104635573348923563",
       "-18836407318976510834104635573348923563",
       "305594372610563985628870243265194313",
       "-305594372610563985628870243265194313",
       "992608567",
       "-992608567",
       "1079802217950896854831728",
       "-1079802217950896854831728",
       "382261429251",
       "-382261429251",
       "7995",
       "-7995",
       "1691954012304306190464",
       "-1691954012304306190464",
       "252558125876",
       "-252558125876",
       "63408135",
       "-63408135",
       "1923885021482774859879",
       "-1923885021482774859879",
       "218151618018868077912122028563473880039",
       "-218151618018868077912122028563473880039",
       "1830482607233486577967554117978261568",
       "-1830482607233486577967554117978261568",
       "232684363792492642717810801641182199046",
       "-232684363792492642717810801641182199046",
       "18951107105103656564987041230801322761",
       "-18951107105103656564987041230801322761",
       "18602001100058210837668227206289280804",
       "-18602001100058210837668227206289280804",
       "619312",
       "-619312",
       "3300635207581175104869860370",
       "-3300635207581175104869860370",
       "35913874076527213864347472731883210240",
       "-35913874076527213864347472731883210240",
       "22584003535744275158325315387889625225",
       "-22584003535744275158325315387889625225",
       "1087569784912004503372385117646999025",
       "-1087569784912004503372385117646999025",
       "53419",
       "-53419",
       "6365946347248672643",
       "-6365946347248672643",
       "923074766928095495451885549346",
       "-923074766928095495451885549346",
       "791386027675064089452885112122",
       "-791386027675064089452885112122",
       "1095850863769",
       "-1095850863769",
       "585462",
       "-585462",
       "7",
       "-7",
       "14396352646034696",
       "-14396352646034696",
       "103513",
       "-103513",
       "236879494739813627852695329647307484",
       "-236879494739813627852695329647307484",
       "833105528657041028703317",
       "-833105528657041028703317",
       "403987552870100762517310706932",
       "-403987552870100762517310706932",
       "9241069445104304081394313010837003",
       "-9241069445104304081394313010837003",
       "7747462702643357490732429745555870341",
       "-7747462702643357490732429745555870341",
       "24325940392988231200",
       "-24325940392988231200",
       "3169332595628505508931977",
       "-3169332595628505508931977",
       "2956433455556566120076606972499",
       "-2956433455556566120076606972499",
       "97",
       "-97",
       "162358208806282",
       "-162358208806282",
       "450940116154946927404473774882465",
       "-450940116154946927404473774882465",
       "451641858",
       "-451641858",
       "1225696755823790187144596188382442861",
       "-1225696755823790187144596188382442861",
       "29784146626131423063590613",
       "-29784146626131423063590613",
       "234254347872215512272431905",
       "-234254347872215512272431905",
       "1188109449997714",
       "-1188109449997714",
       "67931289973154010244863599404",
       "-67931289973154010244863599404",
       "15985550526478899202524298413",
       "-15985550526478899202524298413",
       "44969358144856504665069077764",
       "-44969358144856504665069077764",
       "2433869372731414379",
       "-2433869372731414379",
       "389948478409995",
       "-389948478409995",
       "42980455782580666",
       "-42980455782580666",
       "32377741714896213765436617",
       "-32377741714896213765436617",
       "14147536",
       "-14147536",
       "7281984",
       "-7281984",
       "1940499846845",
       "-1940499846845",
       "431464371512114469628917178",
       "-431464371512114469628917178",
       "7407337220313553496076208494128",
       "-7407337220313553496076208494128",
       "30",
       "-30",
       "1327411295501",
       "-1327411295501",
       "66903469770",
       "-66903469770",
       "1681234517540805320612830262883456",
       "-1681234517540805320612830262883456",
       "100",
       "-100",
       "1619033",
       "-1619033",
       "31778",
       "-31778",
       "157454929543174151967897543014505981946",
       "-157454929543174151967897543014505981946",
       "71577966086399886868276034834304",
       "-71577966086399886868276034834304",
       "39053861540146327519720396203958",
       "-39053861540146327519720396203958",
       "744644565611021440442223814",
       "-744644565611021440442223814",
       "141620",
       "-141620",
       "2207944969567",
       "-2207944969567",
       "203426602629118177589459157758",
       "-203426602629118177589459157758",
       "4687930831049614526662210561259545215",
       "-4687930831049614526662210561259545215",
       "13741620425001328569",
       "-13741620425001328569",
       "28",
       "-28",
       "19919840763987597711639960",
       "-19919840763987597711639960",
       "58845502926990870",
       "-58845502926990870",
       "46503",
       "-46503",
       "227899590091810",
       "-227899590091810",
       "520269641",
       "-520269641",
       "533635134464326491653819104191",
       "-533635134464326491653819104191",
       "32",
       "-32",
       "2311765742988497575052179436185",
       "-2311765742988497575052179436185",
       "104",
       "-104",
       "13174010",
       "-13174010",
       "9157004287034859",
       "-9157004287034859",
       "13439929054075798978",
       "-13439929054075798978",
       "1005710832260650449",
       "-1005710832260650449",
       "45810516546119519",
       "-45810516546119519",
       "10111031832823515595",
       "-10111031832823515595",
       "1556666498630726306813245",
       "-1556666498630726306813245",
       "3776079563026301615061583892830",
       "-3776079563026301615061583892830",
       "3554220000452135447940601650",
       "-3554220000452135447940601650",
       "342914370059615129601458555955512766",
       "-342914370059615129601458555955512766",
       "37211915143242116097464702285",
       "-37211915143242116097464702285",
       "8426589576380612848355737491164",
       "-8426589576380612848355737491164",
       "32989222860",
       "-32989222860",
       "2242563523293104833112476952",
       "-2242563523293104833112476952",
       "26340698264302762867393911",
       "-26340698264302762867393911",
       "7",
       "-7",
       "690707180838394286313288",
       "-690707180838394286313288",
       "4152835666147840816597477625",
       "-4152835666147840816597477625",
       "4307204",
       "-4307204",
       "5538028691958331075031052",
       "-5538028691958331075031052",
       "15605",
       "-15605",
       "779689768131768618",
       "-779689768131768618",
       "31804890425581409493",
       "-31804890425581409493",
       "82342246867680606750756320822",
       "-82342246867680606750756320822",
       "9901401020017005286056280532528545058",
       "-9901401020017005286056280532528545058",
       "23964619045267142735208",
       "-23964619045267142735208",
       "23105481037040",
       "-23105481037040",
       "9261441758156913859636303647639218",
       "-9261441758156913859636303647639218",
       "60070546007507763924924",
       "-60070546007507763924924",
       "12326765403330476150347768542599",
       "-12326765403330476150347768542599",
       "1754723286",
       "-1754723286",
       "28",
       "-28",
       "89432086134972543173032616112",
       "-89432086134972543173032616112",
       "57126030796671809943615335657436",
       "-57126030796671809943615335657436",
       "14251136561",
       "-14251136561",
       "34939118696445841694152507070732",
       "-34939118696445841694152507070732",
       "62242533492272937541",
       "-62242533492272937541",
       "743045397928995080970748460370011005",
       "-743045397928995080970748460370011005",
       "657268729381871210499613874",
       "-657268729381871210499613874",
       "5257773746486582",
       "-5257773746486582",
       "40168363520567402312420813782551098",
       "-40168363520567402312420813782551098",
       "61834553929623600",
       "-61834553929623600",
       "8827879038299859860036523950621910882",
       "-8827879038299859860036523950621910882",
       "18187363614017047925823",
       "-18187363614017047925823",
       "1117818522952984212179",
       "-1117818522952984212179",
       "2656685",
       "-2656685",
       "409037",
       "-409037",
       "184490923222475885977498171480",
       "-184490923222475885977498171480",
       "802095",
       "-802095",
       "1362431392",
       "-1362431392",
       "22261578528",
       "-22261578528",
       "29290981558101942713268861928118",
       "-29290981558101942713268861928118",
       "47302301317848473766508256110200",
       "-47302301317848473766508256110200",
       "148503360374909444835237781907560612329",
       "-148503360374909444835237781907560612329",
       "30589987607",
       "-30589987607",
       "9336827203045",
       "-9336827203045",
       "30107043678267266207220294684045",
       "-30107043678267266207220294684045",
       "1084118892329",
       "-1084118892329",
       "7041095740",
       "-7041095740",
       "15",
       "-15",
       "610704633153562426576938052064937496",
       "-610704633153562426576938052064937496",
       "595347631",
       "-595347631",
       "7667191853556",
       "-7667191853556",
       "44454027936868155101947565993903816",
       "-44454027936868155101947565993903816",
       "85883611",
       "-85883611",
       "360758748839243518516454792370840",
       "-360758748839243518516454792370840",
       "2790927324",
       "-2790927324",
       "3742465736365768915898498156617091585",
       "-3742465736365768915898498156617091585",
       "147479413949146319856130",
       "-147479413949146319856130",
       "1039208893123161146877445631451",
       "-1039208893123161146877445631451",
       "4014354216767740814",
       "-4014354216767740814",
       "119781181099519678732165162824065718973",
       "-119781181099519678732165162824065718973",
       "78562776301070",
       "-78562776301070",
       "559",
       "-559",
       "11280106118161133960100664534446",
       "-11280106118161133960100664534446",
       "4606016388942561437580270830022",
       "-4606016388942561437580270830022",
       "57670561868327441370011",
       "-57670561868327441370011",
       "71416894909097014471844",
       "-71416894909097014471844",
       "3968198792173455589573",
       "-3968198792173455589573",
       "13149823145733642608775252727",
       "-13149823145733642608775252727",
       "264546856712400799367073649733688068",
       "-264546856712400799367073649733688068",
       "181571595840115131057831601",
       "-181571595840115131057831601",
       "137320082754",
       "-137320082754",
       "106737570210691788059038313",
       "-106737570210691788059038313",
       "266197717365288449213562655531",
       "-266197717365288449213562655531",
       "2641672529147341",
       "-2641672529147341",
       "151305657535708132064629059130",
       "-151305657535708132064629059130",
       "8838288455460932557542",
       "-8838288455460932557542",
       "229580992302363",
       "-229580992302363",
       "381276009",
       "-381276009",
       "2189254995814346543537",
       "-2189254995814346543537",
       "241062663892019429783",
       "-241062663892019429783",
       "1289",
       "-1289",
       "3768499169854362",
       "-3768499169854362",
       "46",
       "-46",
       "113123194090149",
       "-113123194090149",
       "257162014338572986111",
       "-257162014338572986111",
       "125826984535179834218224",
       "-125826984535179834218224",
       "380714866068747567944322727593",
       "-380714866068747567944322727593",
       "104303598841139",
       "-104303598841139",
       "1065280345148327648773363223393307192",
       "-1065280345148327648773363223393307192",
       "20248493338789246233167313227932895840",
       "-20248493338789246233167313227932895840",
       "162538",
       "-162538",
       "173739",
       "-173739",
       "5359750034437798426950",
       "-5359750034437798426950",
       "665876738146930",
       "-665876738146930",
       "709289441745698432",
       "-709289441745698432",
       "202728866936448",
       "-202728866936448",
       "6",
       "-6",
       "15800583732744199482624014690",
       "-15800583732744199482624014690",
       "29779074291232",
       "-29779074291232",
       "984339779461760",
       "-984339779461760",
       "767398",
       "-767398",
       "415462781851563431292700828131108380",
       "-415462781851563431292700828131108380",
       "1147933945700269690596156182506",
       "-1147933945700269690596156182506",
       "42450738679031729",
       "-42450738679031729",
       "2577950950157",
       "-2577950950157",
       "2522521710801514347400568661434422",
       "-2522521710801514347400568661434422",
       "13819658998892401541",
       "-13819658998892401541",
       "496658145774859954943564",
       "-496658145774859954943564",
       "518126",
       "-518126",
       "1401",
       "-1401",
       "65673247548918355271934",
       "-65673247548918355271934",
       "1902619525684055188",
       "-1902619525684055188",
       "32325262934",
       "-32325262934",
       "768343207102",
       "-768343207102",
       "7717131697976593508998559",
       "-7717131697976593508998559",
       "318668224221205716681",
       "-318668224221205716681",
       "373695949349041942234118586",
       "-373695949349041942234118586",
       "2374230638947377832537387112",
       "-2374230638947377832537387112",
       "38727149332417950712342749093",
       "-38727149332417950712342749093",
       "50641097967663747879422486643603294439",
       "-50641097967663747879422486643603294439",
       "155679557293775199",
       "-155679557293775199",
       "9584524694361179551000251851",
       "-9584524694361179551000251851",
       "1555",
       "-1555",
       "153598430081275298827470966254180164",
       "-153598430081275298827470966254180164",
       "1792977580",
       "-1792977580",
       "40513995299101921791",
       "-40513995299101921791",
       "205149194684558953622782831493255495",
       "-205149194684558953622782831493255495",
       "8569592230593344920443",
       "-8569592230593344920443",
       "508895",
       "-508895",
       "19768102480409470254",
       "-19768102480409470254",
       "137276814223629775094893592279819",
       "-137276814223629775094893592279819",
       "294000609851122741",
       "-294000609851122741",
       "65049209437230122275",
       "-65049209437230122275",
       "23362940999728532813",
       "-23362940999728532813",
       "88836918597358775734007849873044275046",
       "-88836918597358775734007849873044275046",
       "434035006963316670",
       "-434035006963316670",
       "622",
       "-622",
       "581347029549389573249184843256799",
       "-581347029549389573249184843256799",
       "180338559687589565",
       "-180338559687589565",
       "561053757585637776917747",
       "-561053757585637776917747",
       "32239",
       "-32239",
       "33901075413575967103",
       "-33901075413575967103",
       "8932885164594123487128517542485517028",
       "-8932885164594123487128517542485517028",
       "83521148713289418108751633969571232369",
       "-83521148713289418108751633969571232369",
       "7",
       "-7",
       "97",
       "-97",
       "148574175322938930280707441746",
       "-148574175322938930280707441746",
       "34819851973902418549646788688822516665",
       "-34819851973902418549646788688822516665",
       "8315372482034321202893445528412",
       "-8315372482034321202893445528412",
       "78070260632520",
       "-78070260632520",
       "1694579890551276986736768820881486",
       "-1694579890551276986736768820881486",
       "148949594888574520284515061",
       "-148949594888574520284515061",
       "7155",
       "-7155",
       "54025120576002",
       "-54025120576002",
       "6486075462638233",
       "-6486075462638233",
       "381736014892858568664127676041586",
       "-381736014892858568664127676041586",
       "20417033368",
       "-20417033368",
       "129",
       "-129",
       "4369312912082114047863415327506",
       "-4369312912082114047863415327506",
       "3425863567263779336359928",
       "-3425863567263779336359928",
       "126664685306324611",
       "-126664685306324611",
       "79290635423234192686030222410",
       "-79290635423234192686030222410",
       "89904040753844842469288403271470296",
       "-89904040753844842469288403271470296",
       "303078",
       "-303078",
       "24403696",
       "-24403696",
       "71519894287768242731407528483177175738",
       "-71519894287768242731407528483177175738",
       "43562121429",
       "-43562121429",
       "27030",
       "-27030",
       "24600",
       "-24600",
       "248387716733",
       "-248387716733",
       "371528",
       "-371528",
       "4787877250361840261744279869821",
       "-4787877250361840261744279869821",
       "4997511746500297909058528782721320",
       "-4997511746500297909058528782721320",
       "1586",
       "-1586",
       "31554014671157226899246",
       "-31554014671157226899246",
       "2859985988700258455304314",
       "-2859985988700258455304314",
       "4509508709806307404851",
       "-4509508709806307404851",
       "9",
       "-9",
       "1637744",
       "-1637744",
       "12479552255352789077760938",
       "-12479552255352789077760938",
       "976489633596851129859012248183437",
       "-976489633596851129859012248183437",
       "851806998881827048562",
       "-851806998881827048562",
       "906771089783845862955091",
       "-906771089783845862955091",
       "80038352079069729",
       "-80038352079069729",
       "17388136706500",
       "-17388136706500",
       "61145989",
       "-61145989",
       "94774844620540266019",
       "-94774844620540266019",
       "408281",
       "-408281",
       "952903032817435",
       "-952903032817435",
       "1631092620569808",
       "-1631092620569808",
       "2138",
       "-2138",
       "212824926871186875960728065608",
       "-212824926871186875960728065608",
       "4268162925",
       "-4268162925",
       "36",
       "-36",
       "223723",
       "-223723",
       "16415665053",
       "-16415665053",
       "25788643",
       "-25788643",
       "70220421074486178069",
       "-70220421074486178069",
       "4575797377",
       "-4575797377",
       "76884751129407965501107148587666",
       "-76884751129407965501107148587666",
       "29088346935783207",
       "-29088346935783207",
       "45914004714587007155631909758206960989",
       "-45914004714587007155631909758206960989",
       "248",
       "-248",
       "5579572272102752655174722938686",
       "-5579572272102752655174722938686",
       "30175831892260274369581289965353458",
       "-30175831892260274369581289965353458",
       "1237805257371",
       "-1237805257371",
       "4843618316827222290521953980935538236",
       "-4843618316827222290521953980935538236",
       "240",
       "-240",
       "15807477184070179658",
       "-15807477184070179658",
       "4142567393",
       "-4142567393",
       "12811809209743734075",
       "-12811809209743734075",
       "1485630615919152225304",
       "-1485630615919152225304",
       "7910273036167",
       "-7910273036167",
       "8463758727276424785250829495444564",
       "-8463758727276424785250829495444564",
       "64731869997654405671780238192304416",
       "-64731869997654405671780238192304416",
       "23615438174870",
       "-23615438174870",
       "352157140910141",
       "-352157140910141",
       "5",
       "-5",
       "59221",
       "-59221",
       "2569479",
       "-2569479",
       "542857439184063766884246909368",
       "-542857439184063766884246909368",
       "1823313067549638501383110895210828",
       "-1823313067549638501383110895210828",
       "3270724720703321",
       "-3270724720703321",
       "301251143",
       "-301251143",
       "2479800639",
       "-2479800639",
       "91698905921",
       "-91698905921",
       "2871719453817880",
       "-2871719453817880",
       "15334399950643828095",
       "-15334399950643828095",
       "5526",
       "-5526",
       "233477156",
       "-233477156",
       "133654",
       "-133654",
       "16379095557010108528",
       "-16379095557010108528",
       "781428672272181160786182179076882317",
       "-781428672272181160786182179076882317",
       "8296349327720787412560043280221269761",
       "-8296349327720787412560043280221269761",
       "10281035380942381640132947771350381026",
       "-10281035380942381640132947771350381026",
       "21040070113550157615461288",
       "-21040070113550157615461288",
       "25742884982404545443527",
       "-25742884982404545443527",
       "32454973901024441799985592013",
       "-32454973901024441799985592013",
       "743",
       "-743",
       "48093509516189552",
       "-48093509516189552",
       "3310081024",
       "-3310081024",
       "555885664598428773514",
       "-555885664598428773514",
       "12816465810736",
       "-12816465810736",
       "318",
       "-318",
       "11177674634623001920713776522758",
       "-11177674634623001920713776522758",
       "4478260629000",
       "-4478260629000",
       "7",
       "-7",
       "16047003680147439",
       "-16047003680147439",
       "183",
       "-183",
       "59147119480091828181670682607031985",
       "-59147119480091828181670682607031985",
       "14760016",
       "-14760016",
       "6274417502047620562218369346380",
       "-6274417502047620562218369346380",
       "14026544807038936634796795",
       "-14026544807038936634796795",
       "17158839999",
       "-17158839999",
       "15548352769483287520249305142",
       "-15548352769483287520249305142",
       "362163",
       "-362163",
       "3476850886273368477018353",
       "-3476850886273368477018353",
       "12190143908040407488",
       "-12190143908040407488",
       "521525508150081044",
       "-521525508150081044",
       "433309060522200",
       "-433309060522200",
       "2165455650813681324517",
       "-2165455650813681324517",
       "6819348098387524497126647285",
       "-6819348098387524497126647285",
       "464251630203",
       "-464251630203",
       "145993167313",
       "-145993167313",
       "23955493117052698447116654044",
       "-23955493117052698447116654044",
       "1249962737542647752328381",
       "-1249962737542647752328381",
       "25985762",
       "-25985762",
       "8825811397396758414408048174991",
       "-8825811397396758414408048174991",
       "456322584656453621447742298",
       "-456322584656453621447742298",
       "3635296824314",
       "-3635296824314",
       "48071792",
       "-48071792",
       "573327609505513",
       "-573327609505513",
       "32947066161183",
       "-32947066161183",
       "3572119014464",
       "-3572119014464",
       "339951878200713991932774",
       "-339951878200713991932774",
       "9829263561931267281756747918204",
       "-9829263561931267281756747918204",
       "99133551353390277845579505558",
       "-99133551353390277845579505558",
       "87647698384969946179713959",
       "-87647698384969946179713959",
       "812",
       "-812",
       "874259982778101",
       "-874259982778101",
       "427106308211321596930989851275848063",
       "-427106308211321596930989851275848063",
       "182604408166381257",
       "-182604408166381257",
       "1027122202590661838104329309513",
       "-1027122202590661838104329309513",
       "1354315694936",
       "-1354315694936",
       "6079470672663034486",
       "-6079470672663034486",
       "141187763548195492188625309258190962",
       "-141187763548195492188625309258190962",
       "5948423816691427",
       "-5948423816691427",
       "3790826071191932816",
       "-3790826071191932816",
       "475187449013755049",
       "-475187449013755049",
       "134916830618137216019136180544",
       "-134916830618137216019136180544",
       "289548281081",
       "-289548281081",
       "56088",
       "-56088",
       "71309468310269123716",
       "-71309468310269123716",
       "4319226187100950",
       "-4319226187100950",
       "64155929243330777086",
       "-64155929243330777086",
       "1346606607492942300949980881912922",
       "-1346606607492942300949980881912922",
       "56691962171349121239043134503543",
       "-56691962171349121239043134503543",
       "179884054884043",
       "-179884054884043",
       "1457175629136147646463304750253",
       "-1457175629136147646463304750253",
       "298847019807831033427383443102915235",
       "-298847019807831033427383443102915235",
       "3724333984635632125440253",
       "-3724333984635632125440253",
       "75997801235764509433",
       "-75997801235764509433",
       "624924035973776",
       "-624924035973776",
       "663853",
       "-663853",
       "39794266307878236329712249281466",
       "-39794266307878236329712249281466",
       "68236356",
       "-68236356",
       "874551267305634766833",
       "-874551267305634766833",
       "3069873585346853407835416677633253152",
       "-3069873585346853407835416677633253152",
       "128022182325463",
       "-128022182325463",
       "102685407245351562527197662841526650696",
       "-102685407245351562527197662841526650696",
       "1268696403523315749290280644252872285",
       "-1268696403523315749290280644252872285",
       "962551179",
       "-962551179",
       "5397346809016967977013332103668812",
       "-5397346809016967977013332103668812",
       "19",
       "-19",
       "1383556287038543763721",
       "-1383556287038543763721",
       "596132342851497",
       "-596132342851497",
       "386032274487026935724854",
       "-386032274487026935724854",
       "913487342891468949707909122983",
       "-913487342891468949707909122983",
       "60948098701787507435146",
       "-60948098701787507435146",
       "2022832067596000203",
       "-2022832067596000203",
       "25656479",
       "-25656479",
       "2346119770800025007571",
       "-2346119770800025007571",
       "376371975341",
       "-376371975341",
       "9",
       "-9",
       "2942356530044344965",
       "-2942356530044344965",
       "3932381905103911287794534670998227",
       "-3932381905103911287794534670998227",
       "3218056320",
       "-3218056320",
       "102738821",
       "-102738821",
       "234572888397008437041293767052858",
       "-234572888397008437041293767052858",
       "5858001549782605027037905592031557",
       "-5858001549782605027037905592031557",
       "90718950",
       "-90718950",
       "39428225166028193",
       "-39428225166028193",
       "1383746282",
       "-1383746282",
       "915121",
       "-915121",
       "8970289",
       "-8970289",
       "4322641789",
       "-4322641789",
       "260209037",
       "-260209037",
       "6609227084602664174553003642710",
       "-6609227084602664174553003642710",
       "37231518369001507",
       "-37231518369001507",
       "4301528568595403190",
       "-4301528568595403190",
       "2333077100212",
       "-2333077100212",
       "11565",
       "-11565",
       "255726621336514413017008354182674709",
       "-255726621336514413017008354182674709",
       "17395422733913073065750181",
       "-17395422733913073065750181",
       "125019234224449492",
       "-125019234224449492",
       "4740360722276299853297125",
       "-4740360722276299853297125",
       "7568347",
       "-7568347",
       "17122026961016863428287",
       "-17122026961016863428287",
       "112577394987931131505768113032531171",
       "-112577394987931131505768113032531171",
       "7046212555452856822490707564",
       "-7046212555452856822490707564",
       "33256103762317100748101545285090311772",
       "-33256103762317100748101545285090311772",
       "104639691131091",
       "-104639691131091",
       "74043463548796243",
       "-74043463548796243",
       "49942702457067622169669481",
       "-49942702457067622169669481",
       "12806",
       "-12806",
       "4194227136755752775246633399",
       "-4194227136755752775246633399",
       "22363149786",
       "-22363149786",
       "53844",
       "-53844",
       "6204108132585699",
       "-6204108132585699",
       "133987",
       "-133987",
       "47357030709179941308475",
       "-47357030709179941308475",
       "167735124254221045",
       "-167735124254221045",
       "58394613871",
       "-58394613871",
       "214",
       "-214",
       "97085709128533841718123",
       "-97085709128533841718123",
       "9049249133086876221572990732831",
       "-9049249133086876221572990732831",
       "1860834869623152381150863486",
       "-1860834869623152381150863486",
       "3868776",
       "-3868776",
       "714752211",
       "-714752211",
       "117044601375672047600456567336894",
       "-117044601375672047600456567336894",
       "38202",
       "-38202",
       "1706135867048",
       "-1706135867048",
       "568201454130",
       "-568201454130",
       "10071543790040355676774628",
       "-10071543790040355676774628",
       "3955606956905",
       "-3955606956905",
       "1710822834542941",
       "-1710822834542941",
       "28185453895207483",
       "-28185453895207483",
       "2241403707806732425937134125743",
       "-2241403707806732425937134125743",
       "24424908461669836348",
       "-24424908461669836348",
       "39965",
       "-39965",
       "5776",
       "-5776",
       "161984235115107451958835599550261843326",
       "-161984235115107451958835599550261843326",
       "29821471341",
       "-29821471341",
       "3087720",
       "-3087720",
       "234408055908870511236228564329",
       "-234408055908870511236228564329",
       "367687929171771055426419375659",
       "-367687929171771055426419375659",
       "31",
       "-31",
       "14038375921",
       "-14038375921",
       "1272562766857183500104765994611086188",
       "-1272562766857183500104765994611086188",
       "5395131009",
       "-5395131009",
       "34630426722601695384252351222",
       "-34630426722601695384252351222",
       "16553",
       "-16553",
       "11084856402443484655",
       "-11084856402443484655",
       "4497048086787",
       "-4497048086787",
       "32568631422747274845485",
       "-32568631422747274845485",
       "262201867566",
       "-262201867566",
       "3603196342",
       "-3603196342",
       "32228667062769096924274427075075163477",
       "-32228667062769096924274427075075163477",
       "693196875773858622",
       "-693196875773858622",
       "375838207",
       "-375838207",
   };

   boost::filesystem::ifstream is(root / "cpp_int128_serial64.txt");
   std::cout << "Testing cpp_int128_serial64.txt with T=" << typeid(T).name() << std::endl;
   //is.peek();
   BOOST_CHECK(is.good());
   boost::archive::text_iarchive ia(is);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val;
         ia >> val;
         BOOST_CHECK_EQUAL(val, T(text_array[i]));
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
   }

   boost::filesystem::ifstream is2(root / "cpp_int128_serial32.txt");
   std::cout << "Testing cpp_int128_serial32.txt with T=" << typeid(T).name() << std::endl;
   //is2.peek();
   BOOST_CHECK(is2.good());
   boost::archive::text_iarchive ia2(is2);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val;
         ia2 >> val;
         BOOST_CHECK_EQUAL(val, T(text_array[i]));
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
   }
}

template <class T>
void test1024()
{
   using namespace boost::multiprecision;

   const char* text_array[] = {
       "199116592524695642085302184291534972104821103496846288349049702743455488423756865233534697793799569802866670981662356904270988544309072648691983459024063468708849163858558300444260495432655880504371186304007206097685833870163932928823469130199562442992",
       "-199116592524695642085302184291534972104821103496846288349049702743455488423756865233534697793799569802866670981662356904270988544309072648691983459024063468708849163858558300444260495432655880504371186304007206097685833870163932928823469130199562442992",
       "900593985907599133309438051698408853499625",
       "-900593985907599133309438051698408853499625",
       "1999874529133918706984995533406759076286565612920872635155416162504047196283513226624804224664215451103787410646351770677862238993331622942206185777454355265435238628326337253875004975201674224657309748975788962678417182798452737039836018579998386385843839364431684621083773420995",
       "-1999874529133918706984995533406759076286565612920872635155416162504047196283513226624804224664215451103787410646351770677862238993331622942206185777454355265435238628326337253875004975201674224657309748975788962678417182798452737039836018579998386385843839364431684621083773420995",
       "3984622917724894533997006216154563211907361459910318973090457115167740283771041468834030135879776466911564784436671674308756100400008317797390250537451443539509892669634431827675333761787371583170220547281395030543315815109821053621124047969069733480692532",
       "-3984622917724894533997006216154563211907361459910318973090457115167740283771041468834030135879776466911564784436671674308756100400008317797390250537451443539509892669634431827675333761787371583170220547281395030543315815109821053621124047969069733480692532",
       "3232318919913083002600961037970380935109",
       "-3232318919913083002600961037970380935109",
       "31063287987662242043295268121189412701158946907681323476663158129071217086758046387444487305432940821201595312001091888440038537739012180871591529361766112029121819690067004102150186222757899576567650712850787690098182019345491656562683693940513570929164008316791512277994247388861874767036310283032",
       "-31063287987662242043295268121189412701158946907681323476663158129071217086758046387444487305432940821201595312001091888440038537739012180871591529361766112029121819690067004102150186222757899576567650712850787690098182019345491656562683693940513570929164008316791512277994247388861874767036310283032",
       "551891699448873731005410917251662274314405815829594429768196331539904618164780043996715480720882109933893638976491102937306842056459564612366897777250359518885611699552940726261111066137661097166708199216229508773692203174236076409923801944639195246263554709054412966237162836449108",
       "-551891699448873731005410917251662274314405815829594429768196331539904618164780043996715480720882109933893638976491102937306842056459564612366897777250359518885611699552940726261111066137661097166708199216229508773692203174236076409923801944639195246263554709054412966237162836449108",
       "335366696367917734077308183957523963605452915968160245855756922088011",
       "-335366696367917734077308183957523963605452915968160245855756922088011",
       "516747586835313993425742202038941743391184401954870801073750702371672555461045948927255871449025485037535181895965683819085832663856528858925035833888106053116851498798112586463619731478072279623",
       "-516747586835313993425742202038941743391184401954870801073750702371672555461045948927255871449025485037535181895965683819085832663856528858925035833888106053116851498798112586463619731478072279623",
       "266698476906140000185555171296233707414383217616977634049828438937252114299738535337312010987594",
       "-266698476906140000185555171296233707414383217616977634049828438937252114299738535337312010987594",
       "1742740128166122778815789893503",
       "-1742740128166122778815789893503",
       "9724178186350731882862121812371154796147496227432585250532513144071077406366937493221094046638206862261142165156227060439590867019554905722401562859987295808994814401942",
       "-9724178186350731882862121812371154796147496227432585250532513144071077406366937493221094046638206862261142165156227060439590867019554905722401562859987295808994814401942",
       "78669120642064259414462176059292690866387576703089703385165678245138348243792107699164",
       "-78669120642064259414462176059292690866387576703089703385165678245138348243792107699164",
       "20818242466417733255855534640058104588616172091806661117670",
       "-20818242466417733255855534640058104588616172091806661117670",
       "4285795302257142023279557595265352619153550443850366091691013701573116876759469534501053640452948548428208657312557380072256478428969426137868124810140942586250078976271",
       "-4285795302257142023279557595265352619153550443850366091691013701573116876759469534501053640452948548428208657312557380072256478428969426137868124810140942586250078976271",
       "582604000062572804923757892130426287093735944713405746172610139142407500801888662008036220641936720421041737454101798928020195070207248743108048751731809924563484418793905813766932871306262995484219521766924610729803972858084042961494083239630079092513694133586118612073236719306830956983397633251414977754",
       "-582604000062572804923757892130426287093735944713405746172610139142407500801888662008036220641936720421041737454101798928020195070207248743108048751731809924563484418793905813766932871306262995484219521766924610729803972858084042961494083239630079092513694133586118612073236719306830956983397633251414977754",
       "15244715246682897475794438496539784661328456725495852276384174914973848673559621029178770197754207946620279120766931180917955631763555863913554513123775304647102553401018292948818112379521732233018874991323186887132286586138108436833252904592044083624364585617172057137372527454560587256796482346",
       "-15244715246682897475794438496539784661328456725495852276384174914973848673559621029178770197754207946620279120766931180917955631763555863913554513123775304647102553401018292948818112379521732233018874991323186887132286586138108436833252904592044083624364585617172057137372527454560587256796482346",
       "2162895251469736394155373749298870491019042810468937007114239114834965434324532372477043450771464135064045267665496385710799863273304844467062688237563757141742551576106360777697871874341148850361709074093167368004234386954371485929893986000482110508651966963502456247924228172005161782355542551339301544053",
       "-2162895251469736394155373749298870491019042810468937007114239114834965434324532372477043450771464135064045267665496385710799863273304844467062688237563757141742551576106360777697871874341148850361709074093167368004234386954371485929893986000482110508651966963502456247924228172005161782355542551339301544053",
       "1598979420051373213779067102428825857258960753077031910510837547866117340690938015398588975672437163347616966444506118889316096334851198017036793976867532695462600493286904022181865571035930456030653116939922200581824528814030699118802949188745959300411809512397337408237271478944565611123755566305",
       "-1598979420051373213779067102428825857258960753077031910510837547866117340690938015398588975672437163347616966444506118889316096334851198017036793976867532695462600493286904022181865571035930456030653116939922200581824528814030699118802949188745959300411809512397337408237271478944565611123755566305",
       "16972265575362228409871949532650408574482631199000565615577589612763707133618421955651468786564593364791708076161039592041831568321621510957105628787468779948579969928175938436896904310402554255504042135507367561049409553354413837219069382497010795375231533129182910408442845936728120354915635936898",
       "-16972265575362228409871949532650408574482631199000565615577589612763707133618421955651468786564593364791708076161039592041831568321621510957105628787468779948579969928175938436896904310402554255504042135507367561049409553354413837219069382497010795375231533129182910408442845936728120354915635936898",
       "6578842255326490592104075020940649831283616551660",
       "-6578842255326490592104075020940649831283616551660",
       "21683239365736925204171059844091235529220850759783534345105279221261364632686763920546656745741380892718845596049305277834093327836699551790128153290026473154694088594033146472697265593756340629571314831536187835497879992488",
       "-21683239365736925204171059844091235529220850759783534345105279221261364632686763920546656745741380892718845596049305277834093327836699551790128153290026473154694088594033146472697265593756340629571314831536187835497879992488",
       "82705023096235991529043144815694768432078642064433253929157769869969882959684824083733064475507849892985247689495254462302557886989778499312762640233348268023648079139590178633699092745191633841431797230103981800388019961016410936969661694491101422518397720383375579079432440889617406834440612316345",
       "-82705023096235991529043144815694768432078642064433253929157769869969882959684824083733064475507849892985247689495254462302557886989778499312762640233348268023648079139590178633699092745191633841431797230103981800388019961016410936969661694491101422518397720383375579079432440889617406834440612316345",
       "182226847821689839702269917063301483274601928154240894497051272590070015871573462612330908644446070144310876769617182637134479859518870301265103824148955731473219622377635930380500965073993471768564617573332989796817488809960475386339256946590978228792909775228312826022751099327081513175259103822462404",
       "-182226847821689839702269917063301483274601928154240894497051272590070015871573462612330908644446070144310876769617182637134479859518870301265103824148955731473219622377635930380500965073993471768564617573332989796817488809960475386339256946590978228792909775228312826022751099327081513175259103822462404",
       "5047815496286192631875136121482961684854345143375644371655857541129061222585290469283326779682311519927896776754142231238721306654582346292285270137340078762804088754913299932236143865279819208519978638432654788640663782736369734346995034407838300134017424349501474133378173964391719130592921725",
       "-5047815496286192631875136121482961684854345143375644371655857541129061222585290469283326779682311519927896776754142231238721306654582346292285270137340078762804088754913299932236143865279819208519978638432654788640663782736369734346995034407838300134017424349501474133378173964391719130592921725",
       "22536736652558441743601984420319740",
       "-22536736652558441743601984420319740",
       "327447539579270438292704828441807528233522606163188888154105354488483374541037700785580710347093169240568594799687437260325328617564586900214241043337",
       "-327447539579270438292704828441807528233522606163188888154105354488483374541037700785580710347093169240568594799687437260325328617564586900214241043337",
       "576979741896869527546425470124797714231020028752356356333225775983321871157857129520067018389689110139112275805449955044770978296650876883361429976430221447982628049254445385786013507310850518003697984237866336100952912645415854388908568224414707",
       "-576979741896869527546425470124797714231020028752356356333225775983321871157857129520067018389689110139112275805449955044770978296650876883361429976430221447982628049254445385786013507310850518003697984237866336100952912645415854388908568224414707",
       "755708508440402225863498155833596268190934339616501653733913066972752009318647339364141109604780235018474569114884922495929398288656171192074004071372424004589137926220537255429717898046520571796147507616408370836807000016827363741604261172604190",
       "-755708508440402225863498155833596268190934339616501653733913066972752009318647339364141109604780235018474569114884922495929398288656171192074004071372424004589137926220537255429717898046520571796147507616408370836807000016827363741604261172604190",
       "28048724901616569597172899970128263950954786552499389660847160202213362969018987235256727605",
       "-28048724901616569597172899970128263950954786552499389660847160202213362969018987235256727605",
       "173167043910755577166191737374818499849624950",
       "-173167043910755577166191737374818499849624950",
       "48",
       "-48",
       "18463009925253820920449684292621801312807473363997541122773157125946854399091765241363833326106601909427978296931833223183788301543",
       "-18463009925253820920449684292621801312807473363997541122773157125946854399091765241363833326106601909427978296931833223183788301543",
       "31164619961775222493397145731379707",
       "-31164619961775222493397145731379707",
       "1816096570786800455898299961483294949815377533170208282553387279497784999672154364831631933541855425071102266426105906939977630773287626616160771806315066360322795263086589842632991562964241768039371149116395673886243340566387264938743398973079853460222114803451321466708714785006727",
       "-1816096570786800455898299961483294949815377533170208282553387279497784999672154364831631933541855425071102266426105906939977630773287626616160771806315066360322795263086589842632991562964241768039371149116395673886243340566387264938743398973079853460222114803451321466708714785006727",
       "286006007227658140199584887789816189451349886507993355022297173895214040208905643298365570365441499922605759964419143497079708873231260957597650186760056343574600947950687835678669676590667783184666",
       "-286006007227658140199584887789816189451349886507993355022297173895214040208905643298365570365441499922605759964419143497079708873231260957597650186760056343574600947950687835678669676590667783184666",
       "18358404935882372210070601728050732884947257854425817110955248936260198050228809460271322586740505320746909919918679627100695097433534409202108416481259416338560209999440019558569552164395624923489329323411399738280552853025588689733098861097523",
       "-18358404935882372210070601728050732884947257854425817110955248936260198050228809460271322586740505320746909919918679627100695097433534409202108416481259416338560209999440019558569552164395624923489329323411399738280552853025588689733098861097523",
       "4134722455319345214940599980631794346657332870755359010455452155626594269008814501180484509879573967565890465226873255542092192607602138135728673418643645201766135430371744351074472506612976620427027592918016747144700651239945277040717933887512645490432181939225775342965",
       "-4134722455319345214940599980631794346657332870755359010455452155626594269008814501180484509879573967565890465226873255542092192607602138135728673418643645201766135430371744351074472506612976620427027592918016747144700651239945277040717933887512645490432181939225775342965",
       "54920807074733793884577529077249631831162657302693894027178095216669108940322624411834499900757281913727092273510264248215928273287884179463378853565331877701638585020489866284361829333257710807106023052404897652297092714031250456279772808462426750654556160069174238558295987347555132735561420095",
       "-54920807074733793884577529077249631831162657302693894027178095216669108940322624411834499900757281913727092273510264248215928273287884179463378853565331877701638585020489866284361829333257710807106023052404897652297092714031250456279772808462426750654556160069174238558295987347555132735561420095",
       "399265560197794252401617167580850085282220794173216714093253564006986475971645145366672323528680289510504223856530994241334812625576574784650620927403732184",
       "-399265560197794252401617167580850085282220794173216714093253564006986475971645145366672323528680289510504223856530994241334812625576574784650620927403732184",
       "31621966437344909804014117858935966136505781977117316516659445266533686603282356943749115958158394083237531612132476116831423261618528802877894233115470068483988764082981116838784931515017818535550110918",
       "-31621966437344909804014117858935966136505781977117316516659445266533686603282356943749115958158394083237531612132476116831423261618528802877894233115470068483988764082981116838784931515017818535550110918",
       "1606985215548409716503362538444761880543201213399618535731027289265156579177336621807120077949866098802813413615868269176538634784089984273973440941833767736805385007543715097934592673987261460898859324638806817938705575451364443949120235151257544",
       "-1606985215548409716503362538444761880543201213399618535731027289265156579177336621807120077949866098802813413615868269176538634784089984273973440941833767736805385007543715097934592673987261460898859324638806817938705575451364443949120235151257544",
       "285683190193",
       "-285683190193",
       "8061697887583266465310973659826347597097558972448901485453524610917952084739066859639084715521710210973596165921",
       "-8061697887583266465310973659826347597097558972448901485453524610917952084739066859639084715521710210973596165921",
       "6219223289787909965098172528033914428025426344931365048240610134846930087708486382224526942350364117413020461482722657384885935391455080562169318712277658961972965925941924792948343565934378704158420349097774074011993945850670748056251470218258676908828627471885",
       "-6219223289787909965098172528033914428025426344931365048240610134846930087708486382224526942350364117413020461482722657384885935391455080562169318712277658961972965925941924792948343565934378704158420349097774074011993945850670748056251470218258676908828627471885",
       "697258758163542187076749918900636966609908531786609361940000240519",
       "-697258758163542187076749918900636966609908531786609361940000240519",
       "1046098084657831111818175325887422175023162118504873435909952452494852374571808810176243062515313047215471029884493246457829292480590847793716267629027995295229796393654811459791589585169546388254745922345946744655803804613032804268083425871981695717315478983498539611218241664930157839795",
       "-1046098084657831111818175325887422175023162118504873435909952452494852374571808810176243062515313047215471029884493246457829292480590847793716267629027995295229796393654811459791589585169546388254745922345946744655803804613032804268083425871981695717315478983498539611218241664930157839795",
       "2484434366380099043156299869169661345741558449531766681226478781813341982338634464499146134940119727735818398667362505498484418919464161091166892386016324225384189876252889149071097656823108497551033588357003722",
       "-2484434366380099043156299869169661345741558449531766681226478781813341982338634464499146134940119727735818398667362505498484418919464161091166892386016324225384189876252889149071097656823108497551033588357003722",
       "308286676308193197031410043742676292328591745213481644733897249474373496522533072738438449939815750248898922885290011346375849968712988888608255565930075126704466104946675008196710396726585487442780152614905677",
       "-308286676308193197031410043742676292328591745213481644733897249474373496522533072738438449939815750248898922885290011346375849968712988888608255565930075126704466104946675008196710396726585487442780152614905677",
       "1578729146192540123786163537348004400750916878495381648015362308555564957146975794392752284685500828245809393902172165166570",
       "-1578729146192540123786163537348004400750916878495381648015362308555564957146975794392752284685500828245809393902172165166570",
       "753635193017654981561112585877756433926946338453536513833144933556077262395793429496030381482043731560006145122148417766008778064151654898372617208349138764363280371778703526306929669285807019015087056633479893959366709941765720251266",
       "-753635193017654981561112585877756433926946338453536513833144933556077262395793429496030381482043731560006145122148417766008778064151654898372617208349138764363280371778703526306929669285807019015087056633479893959366709941765720251266",
       "1023056796494340203037740397557237363844811192683830278749294166121707658052654599305485368530300819052987687826810994785603794931372101763295285975973124930171986523205085256147491724466952116413750593896486505408297359237231028",
       "-1023056796494340203037740397557237363844811192683830278749294166121707658052654599305485368530300819052987687826810994785603794931372101763295285975973124930171986523205085256147491724466952116413750593896486505408297359237231028",
       "7279368955234841237989689629914561920962002431310686381873314222568640123479287155739276546923764190325442924090937031964044572030997024902955450149096922769606827151526955803170246823486172000556133026264782831784752812128580068",
       "-7279368955234841237989689629914561920962002431310686381873314222568640123479287155739276546923764190325442924090937031964044572030997024902955450149096922769606827151526955803170246823486172000556133026264782831784752812128580068",
       "424617380576309116241807458648692744450386557212868763669113075114477578778872841574527732081207492431831870311301491048670446826911900920994644694",
       "-424617380576309116241807458648692744450386557212868763669113075114477578778872841574527732081207492431831870311301491048670446826911900920994644694",
       "7046686003127119093099476961562427444038611347486414217752094860417190797774076723407713585872307944642824878964077822345",
       "-7046686003127119093099476961562427444038611347486414217752094860417190797774076723407713585872307944642824878964077822345",
       "19949119701600514825288852843654302777880460105733015351003691242645123465142555331932685718332487926262997425529449487067278953683",
       "-19949119701600514825288852843654302777880460105733015351003691242645123465142555331932685718332487926262997425529449487067278953683",
       "16469140092633375339743693580164888653727421730589027379476942842394844761208703483677054585417793177811566576822391363212778421263249183342676114446881502895872964885316569671443951931393367071689754985",
       "-16469140092633375339743693580164888653727421730589027379476942842394844761208703483677054585417793177811566576822391363212778421263249183342676114446881502895872964885316569671443951931393367071689754985",
       "1061702816480363701187846694728343109042150409401045998",
       "-1061702816480363701187846694728343109042150409401045998",
       "7391047600385760425390763210856013417540808412389899",
       "-7391047600385760425390763210856013417540808412389899",
       "3720217478561502591416009227591582869882982470098168796813426264578076670286029029195560760567",
       "-3720217478561502591416009227591582869882982470098168796813426264578076670286029029195560760567",
       "66106892589637039037744676327200772291368517688108041167197715930935273497569759111332854815299471155925869011997907566713674005971100914739364454164984587128896600583993354569858550495377843782520710717979164977585093",
       "-66106892589637039037744676327200772291368517688108041167197715930935273497569759111332854815299471155925869011997907566713674005971100914739364454164984587128896600583993354569858550495377843782520710717979164977585093",
       "655105381318829622535325161492573443039473032159228692157069475333288969363672255837498503071757247193471076794288004751047135238604867298249068617214132553959376152373616588040808707670098140225261882200984527500899566180951300745344526414599508",
       "-655105381318829622535325161492573443039473032159228692157069475333288969363672255837498503071757247193471076794288004751047135238604867298249068617214132553959376152373616588040808707670098140225261882200984527500899566180951300745344526414599508",
       "32279098297",
       "-32279098297",
       "91236285260894969491370094562444170610185292123928049180398654028165920269699400153752501142438076",
       "-91236285260894969491370094562444170610185292123928049180398654028165920269699400153752501142438076",
       "76148543022827828542260034575767140554118312303651220784462009876431985956698652362044",
       "-76148543022827828542260034575767140554118312303651220784462009876431985956698652362044",
       "83588868584829923837376678742649596503169974719002042708417338297148455364317505115231903770625036463360146776147319869172298475847924715607135999201658410499586149882123548133278995113231076277183588359228055211291455848766205373827838498451914146847385535315038611426",
       "-83588868584829923837376678742649596503169974719002042708417338297148455364317505115231903770625036463360146776147319869172298475847924715607135999201658410499586149882123548133278995113231076277183588359228055211291455848766205373827838498451914146847385535315038611426",
       "963957921647213",
       "-963957921647213",
       "13301565202923219609572812103802050473736468733",
       "-13301565202923219609572812103802050473736468733",
       "4746350713999103687568954691814",
       "-4746350713999103687568954691814",
       "2001142907044963200442678450863815898813903676660733058871895239756077633074421909013654237542517301596550011117510574893770558703407744684777702961205416292826384730912647565673208707968211244040320246494312087239093502776249390829799552970184550131203169359608726456455152480928583576591394902496106626144",
       "-2001142907044963200442678450863815898813903676660733058871895239756077633074421909013654237542517301596550011117510574893770558703407744684777702961205416292826384730912647565673208707968211244040320246494312087239093502776249390829799552970184550131203169359608726456455152480928583576591394902496106626144",
       "107594281614292318387817778890700162347725421105656330924973717308436245329157596183845769858366750239404646287651057292302740816759738471158092800874582432179112119211566698620828469639621669897519755264598100204713172616980523260714264267451063089420215",
       "-107594281614292318387817778890700162347725421105656330924973717308436245329157596183845769858366750239404646287651057292302740816759738471158092800874582432179112119211566698620828469639621669897519755264598100204713172616980523260714264267451063089420215",
       "1748285028280968559027056769483145164710362048627307365465656148480028444958644903475995728328069875726460568057080202853997524099097288749318318801615657840242878599655077486108729249226195564937733374638566648902211364103190286203200478747078106163053",
       "-1748285028280968559027056769483145164710362048627307365465656148480028444958644903475995728328069875726460568057080202853997524099097288749318318801615657840242878599655077486108729249226195564937733374638566648902211364103190286203200478747078106163053",
       "11460180193889065606722132385926501525431980106546682247601052575855000134486061731618687473242633808411918689848577390823351808790715520481001965421879800810352399655561482898353748786253207752078326991084961012083",
       "-11460180193889065606722132385926501525431980106546682247601052575855000134486061731618687473242633808411918689848577390823351808790715520481001965421879800810352399655561482898353748786253207752078326991084961012083",
       "574927035874041759213679385423821561867",
       "-574927035874041759213679385423821561867",
       "120643345454198941508563017089006360092589256126170227342940319190269214269775023269721267117406618",
       "-120643345454198941508563017089006360092589256126170227342940319190269214269775023269721267117406618",
       "43211052397169822368769320044098366176065820670381470825125490923898893035078574715878390619044493658716106759475917845349930472007385257270090791727486873231922936861573077702054193955871675235660795444516942345577520753954381850029768",
       "-43211052397169822368769320044098366176065820670381470825125490923898893035078574715878390619044493658716106759475917845349930472007385257270090791727486873231922936861573077702054193955871675235660795444516942345577520753954381850029768",
       "9844479373748707013063227964029459596247847016794211846228318515960354387966950301750833297921955723417061013994092483915173465284502461089399372968661262420490350455873655690633576331503541999665999411319072898423762904939498903689838493823091884957816736065194017711554932378966207638596446",
       "-9844479373748707013063227964029459596247847016794211846228318515960354387966950301750833297921955723417061013994092483915173465284502461089399372968661262420490350455873655690633576331503541999665999411319072898423762904939498903689838493823091884957816736065194017711554932378966207638596446",
       "1549569662025720311251404569332722105893198679127923795355656951920288528581705427103792360667449800130523485559533763978458224547356178202688985769505",
       "-1549569662025720311251404569332722105893198679127923795355656951920288528581705427103792360667449800130523485559533763978458224547356178202688985769505",
       "36315742657",
       "-36315742657",
       "8921164792041877158829344493852966827789686565858639796763485931102357440731861058782552324538917399828752311227018705861210803742330995498617328892413590387831390338234562492080836551321361310716484078814",
       "-8921164792041877158829344493852966827789686565858639796763485931102357440731861058782552324538917399828752311227018705861210803742330995498617328892413590387831390338234562492080836551321361310716484078814",
       "3564428449813842615037566955460603551635405941961408429533479906924825068973042239756262262787799344453371579266807953907224412476869508",
       "-3564428449813842615037566955460603551635405941961408429533479906924825068973042239756262262787799344453371579266807953907224412476869508",
       "803208608149818042371281509635155439483",
       "-803208608149818042371281509635155439483",
       "4866189324296232234061833332746205890326919472641667725283106186358795590420827732306960443344464312769726502055107509",
       "-4866189324296232234061833332746205890326919472641667725283106186358795590420827732306960443344464312769726502055107509",
       "207298564235033398879052037508717471071493511497187540585110196743",
       "-207298564235033398879052037508717471071493511497187540585110196743",
       "193717918520883498325012985935003601959305178471191450716579245791510632312265720137365047580022087853055977679260908512014775411818562756581294466392949427067700253919565514470785071872659525583000795812531290669561365815697655594188906",
       "-193717918520883498325012985935003601959305178471191450716579245791510632312265720137365047580022087853055977679260908512014775411818562756581294466392949427067700253919565514470785071872659525583000795812531290669561365815697655594188906",
       "2437877491739207",
       "-2437877491739207",
       "37013774102202564305419053038604891745828779816673570038156288209445014156533018002446399548329104265253840467051874818175306349349752734572291264362672503100264435752942371629071789078883405034467875813374259058124047248097835249024123072756933",
       "-37013774102202564305419053038604891745828779816673570038156288209445014156533018002446399548329104265253840467051874818175306349349752734572291264362672503100264435752942371629071789078883405034467875813374259058124047248097835249024123072756933",
       "354494755327",
       "-354494755327",
       "11780642893082070770985419994433169541426957824422257433844",
       "-11780642893082070770985419994433169541426957824422257433844",
       "485430660154648600595640793061533874664308049695155979729256186778257302321647241550949220266916178753497849914452979205318162",
       "-485430660154648600595640793061533874664308049695155979729256186778257302321647241550949220266916178753497849914452979205318162",
       "23858852603627264837843140314865296322097028936336850188878465502728409524610276592851077626292364546252755103916928846389671162429425418906991891502973",
       "-23858852603627264837843140314865296322097028936336850188878465502728409524610276592851077626292364546252755103916928846389671162429425418906991891502973",
       "2073475025890625790912875485180905813499103080617022204722722710095631077512485124044881139986135538169181486312704584071614904004373594716419",
       "-2073475025890625790912875485180905813499103080617022204722722710095631077512485124044881139986135538169181486312704584071614904004373594716419",
       "15280710757061816529388583850582811170979066299366854920512818520549969116440063183787310498271091672343434592650388724950511822972092076",
       "-15280710757061816529388583850582811170979066299366854920512818520549969116440063183787310498271091672343434592650388724950511822972092076",
       "6382485371693619169022055595031229091762638736860010414889365673981891166426242136610234221929171470107008843300114050380584829581671837693187024514818",
       "-6382485371693619169022055595031229091762638736860010414889365673981891166426242136610234221929171470107008843300114050380584829581671837693187024514818",
       "12185224224701673175361331319115762816895575796767843658049699617134858039026831564288739190981827007791493862865956911735574421879562096311558676154252796632277351699205162505700258194809563580445507",
       "-12185224224701673175361331319115762816895575796767843658049699617134858039026831564288739190981827007791493862865956911735574421879562096311558676154252796632277351699205162505700258194809563580445507",
       "34003980273948488873087243030302546934071096333462110121575903766367670827215796429777573314114296018716373089777559546454127470648315079633590832262220530391541976999162677539194732289306375110039265026554808460597438607169664283497662076280786",
       "-34003980273948488873087243030302546934071096333462110121575903766367670827215796429777573314114296018716373089777559546454127470648315079633590832262220530391541976999162677539194732289306375110039265026554808460597438607169664283497662076280786",
       "122848198938353223588037911092014612429998780961520627899382186456109045142826399845219049519395028055840868305519753136489752495357572137972700299899629238691174342998161949671331013802430679284465951931850871392212632",
       "-122848198938353223588037911092014612429998780961520627899382186456109045142826399845219049519395028055840868305519753136489752495357572137972700299899629238691174342998161949671331013802430679284465951931850871392212632",
       "43537967438743700082839955990027575248714598937547106788531846714509188167960975769453819977500278194590313507781727399526395127656584060420218121352097776308452702567298202679209230473699619650828718821287113120498048345913575657082695406163703126042367182026511481872506111256791596",
       "-43537967438743700082839955990027575248714598937547106788531846714509188167960975769453819977500278194590313507781727399526395127656584060420218121352097776308452702567298202679209230473699619650828718821287113120498048345913575657082695406163703126042367182026511481872506111256791596",
       "58406767675650075287505789516356411545831826432139397101494864325157903449602707567656548116973052773130530151058837990354645940288559829449340220508188691146281802100553666536211206823508084744153463134410959296949868335640749454837",
       "-58406767675650075287505789516356411545831826432139397101494864325157903449602707567656548116973052773130530151058837990354645940288559829449340220508188691146281802100553666536211206823508084744153463134410959296949868335640749454837",
       "845873210129906374353022076245969947869460127750482252356111232286849327159845231580563758295137285209548293776383830614553566014483472912208993044958366148170162204310293796785477227702675371216304957228188615867576567406231041038281756292397397561",
       "-845873210129906374353022076245969947869460127750482252356111232286849327159845231580563758295137285209548293776383830614553566014483472912208993044958366148170162204310293796785477227702675371216304957228188615867576567406231041038281756292397397561",
       "53588224463377221082233930622411910641801456988689291134720826079004949443094787414435",
       "-53588224463377221082233930622411910641801456988689291134720826079004949443094787414435",
       "72112722851930798700228005210608826370783262851441860040831117968729809788108346159403319971018904246301591088717098607465649205797470097967252119620134427778008686902310907006410363397508152328805949858597088819284277",
       "-72112722851930798700228005210608826370783262851441860040831117968729809788108346159403319971018904246301591088717098607465649205797470097967252119620134427778008686902310907006410363397508152328805949858597088819284277",
       "641918660703774309882129738043218549030513645540611429936046631082566036061356980177384685321883957675631751681520848096394297317163463488891570190724496654177980091225725954578443264041706056677969812886935701",
       "-641918660703774309882129738043218549030513645540611429936046631082566036061356980177384685321883957675631751681520848096394297317163463488891570190724496654177980091225725954578443264041706056677969812886935701",
       "30",
       "-30",
       "6394573041749544637932142063252660876011988517352129759808021807615786602503160259195561963658103141713195046053277921040817887800559226509891982140334607813922841396821838502087774297750475588617168795",
       "-6394573041749544637932142063252660876011988517352129759808021807615786602503160259195561963658103141713195046053277921040817887800559226509891982140334607813922841396821838502087774297750475588617168795",
       "1786466222561817425577249373742981037566301146961591730677121116610853649457567467081637483584212899635954801237845898555279493690732411882920175456222801107258417531725553455448259056866349458253419178431317512242742160",
       "-1786466222561817425577249373742981037566301146961591730677121116610853649457567467081637483584212899635954801237845898555279493690732411882920175456222801107258417531725553455448259056866349458253419178431317512242742160",
       "137832029750529182794342751962197941412491800492104",
       "-137832029750529182794342751962197941412491800492104",
       "8108038128324706368474080686463548136481517039342729533539080912561382244733668445971779623479147878923993970600643926905142316004585446689923640217524203592135814813370649929971097550423245537858260",
       "-8108038128324706368474080686463548136481517039342729533539080912561382244733668445971779623479147878923993970600643926905142316004585446689923640217524203592135814813370649929971097550423245537858260",
       "5002261098184392173934780113066967242",
       "-5002261098184392173934780113066967242",
       "690951335667913995812417540653386648776452918801140879728454196755039750563977820072442505506359908874725801630758561609054355988759175228289",
       "-690951335667913995812417540653386648776452918801140879728454196755039750563977820072442505506359908874725801630758561609054355988759175228289",
       "10674213497798883899476403327832261239905267095517429500221095458852845305968864392299051608409658803957443554649236067724400487971044164121242198029786220",
       "-10674213497798883899476403327832261239905267095517429500221095458852845305968864392299051608409658803957443554649236067724400487971044164121242198029786220",
       "17992446102498398809906415490084711513529803098403245836231064924343042871622653363618957583240979467823413823373231710836844132776133330230504849252207785917957852664671150869449421757327447929003162434828411052366071580989788644644058346",
       "-17992446102498398809906415490084711513529803098403245836231064924343042871622653363618957583240979467823413823373231710836844132776133330230504849252207785917957852664671150869449421757327447929003162434828411052366071580989788644644058346",
       "33842687090178160518628086932775600899160163731425276680317104716407292755478424345380082755988441733647290183079908808136196734777398636133355822624652625917768049717031860506349867723992592655421369270624555109106177714680336653018611913032875963068852500326353648887921416851020395037162987766",
       "-33842687090178160518628086932775600899160163731425276680317104716407292755478424345380082755988441733647290183079908808136196734777398636133355822624652625917768049717031860506349867723992592655421369270624555109106177714680336653018611913032875963068852500326353648887921416851020395037162987766",
       "1054083826397869852970042065169251590328234555837539271102624160027471295945233271106117930450857346874100524858325086710499923040919634021718345296558298025504382070214470223730",
       "-1054083826397869852970042065169251590328234555837539271102624160027471295945233271106117930450857346874100524858325086710499923040919634021718345296558298025504382070214470223730",
       "136407237437852413879681494779911076041207111591826209650287776324941155126675066585977968663006698647245",
       "-136407237437852413879681494779911076041207111591826209650287776324941155126675066585977968663006698647245",
       "2224879942826211211569920900726660211869323323310097306306571308813333981073744504097938050565302837264530253763057896699924896596092066791400879438413472679293844669326318441711505238433328261842523388469632517312478257062414756535170295711651910005290949014898120581894",
       "-2224879942826211211569920900726660211869323323310097306306571308813333981073744504097938050565302837264530253763057896699924896596092066791400879438413472679293844669326318441711505238433328261842523388469632517312478257062414756535170295711651910005290949014898120581894",
       "4047288308565310307500509489225346109923522467464514519968591592559230455772855713422415453581291554663695129034041054508221015627588797163542760075301595269083019308332323602089140",
       "-4047288308565310307500509489225346109923522467464514519968591592559230455772855713422415453581291554663695129034041054508221015627588797163542760075301595269083019308332323602089140",
       "1035816948031741587849086409216542916935656696246164119153928232713320856714123588940050533131790722677035036233284471386922732645880058503610308346951059222695446014860710224009856786160873437306753478940623814638264314179274958950671363159961289293",
       "-1035816948031741587849086409216542916935656696246164119153928232713320856714123588940050533131790722677035036233284471386922732645880058503610308346951059222695446014860710224009856786160873437306753478940623814638264314179274958950671363159961289293",
       "1718216153801609870534260896130470102834028900689159827595233108230047",
       "-1718216153801609870534260896130470102834028900689159827595233108230047",
       "157320",
       "-157320",
       "4922208547816973044459635133646703969879372571533096054296883386644122380530951726299847426987732042397595779976830474678726947018304354845591378517358359470056483109237714380888286233563680472388849805778688479350769638569123934902",
       "-4922208547816973044459635133646703969879372571533096054296883386644122380530951726299847426987732042397595779976830474678726947018304354845591378517358359470056483109237714380888286233563680472388849805778688479350769638569123934902",
       "3067476257285335874566823333688543442128450810079871657467124491543338509419265027748695014643813306181544035536165512867635982606378678645467114585754422748255288790715628747169903578478381870157776988838327310364853622786578500012302428307039672498275",
       "-3067476257285335874566823333688543442128450810079871657467124491543338509419265027748695014643813306181544035536165512867635982606378678645467114585754422748255288790715628747169903578478381870157776988838327310364853622786578500012302428307039672498275",
       "883397505237211649947418585007890070022882946801242047716792933816916920312758",
       "-883397505237211649947418585007890070022882946801242047716792933816916920312758",
       "1100016596294277930396702074837291475694950629762363744759571589030108139933298189695770187024515803626715526690351811923084433342467648792302262756272887683638924910835436501074742486120762849764143752164258427412169550392618539176353678199434066032915",
       "-1100016596294277930396702074837291475694950629762363744759571589030108139933298189695770187024515803626715526690351811923084433342467648792302262756272887683638924910835436501074742486120762849764143752164258427412169550392618539176353678199434066032915",
       "3318653243827753930075076609367167950215271547197165956541578677095035789105230285577300537970253024380004869448887191421072498566168883197146749684037295491",
       "-3318653243827753930075076609367167950215271547197165956541578677095035789105230285577300537970253024380004869448887191421072498566168883197146749684037295491",
       "18917325422442253597680054225840324956976833511185836470606776355469702018395215498115502098244359450586779118546945991879765584863693947599352077215049091215099400154668038964846442469328921458041398569034401548536622210828439622386945359553017072968575829651399459030775837160233158886103",
       "-18917325422442253597680054225840324956976833511185836470606776355469702018395215498115502098244359450586779118546945991879765584863693947599352077215049091215099400154668038964846442469328921458041398569034401548536622210828439622386945359553017072968575829651399459030775837160233158886103",
       "254366786216910043665990950804997231945088908428747001184159373059058493118875749329803453882635522927040165937386417763335659992218458086511885522609981363333096153519757022667758401739961262948319999739472528794701",
       "-254366786216910043665990950804997231945088908428747001184159373059058493118875749329803453882635522927040165937386417763335659992218458086511885522609981363333096153519757022667758401739961262948319999739472528794701",
       "37544442396527426899195446849672655465276344502770712178079384432684510232491164260359865664795991038222782506894463672347582854",
       "-37544442396527426899195446849672655465276344502770712178079384432684510232491164260359865664795991038222782506894463672347582854",
       "15673578372504731899692149900135775418224632075238646337867467957107034530818946478167665455128984412394389268797819166734444989508179006505772666514111230952795610254140089645092544526629237404643329919824803563866840859270664303879742294839213766102351871211663636813556965",
       "-15673578372504731899692149900135775418224632075238646337867467957107034530818946478167665455128984412394389268797819166734444989508179006505772666514111230952795610254140089645092544526629237404643329919824803563866840859270664303879742294839213766102351871211663636813556965",
       "27481560151479303283253590172063634693210359375791056643367262359056676411581745877899312410880682306069203702180378974272137310962",
       "-27481560151479303283253590172063634693210359375791056643367262359056676411581745877899312410880682306069203702180378974272137310962",
       "59764850084546321076270115679381459961266663920938595034931337715038895288728780241940147905268936247355365797839452044959717373177405268037975305459371499345817108953258614141073965011536848191412758145014880201415800076045236677519189441266640929126443802253464497061850704733496580039504966534",
       "-59764850084546321076270115679381459961266663920938595034931337715038895288728780241940147905268936247355365797839452044959717373177405268037975305459371499345817108953258614141073965011536848191412758145014880201415800076045236677519189441266640929126443802253464497061850704733496580039504966534",
       "236346389410506959600114343181511587020869234266420558654132661642154355113727359542557485608210379840787154866691122790684707204957449484562815548156526563035046035495563526969340",
       "-236346389410506959600114343181511587020869234266420558654132661642154355113727359542557485608210379840787154866691122790684707204957449484562815548156526563035046035495563526969340",
       "8815935276532889936007554615797399527468399687615548740700254897861864429815615560728972825692565852981716178182277189313249729477257089767951370396136769451014576455113",
       "-8815935276532889936007554615797399527468399687615548740700254897861864429815615560728972825692565852981716178182277189313249729477257089767951370396136769451014576455113",
       "15766842373922966734945972936934487778733908393732",
       "-15766842373922966734945972936934487778733908393732",
       "6595752830737826074851600247398704243439581",
       "-6595752830737826074851600247398704243439581",
       "883607119507167020680444599092885224088612050268051636998275726360170767104266391951078564780752590643878108107048593830807317310688757872408858062530074042278525133611486569437859217448040432508288719355266779546627635013182590336527",
       "-883607119507167020680444599092885224088612050268051636998275726360170767104266391951078564780752590643878108107048593830807317310688757872408858062530074042278525133611486569437859217448040432508288719355266779546627635013182590336527",
       "33694907409791755762655404952802940988899691249",
       "-33694907409791755762655404952802940988899691249",
       "323333915936767999634844119809319135460509879311229599308354939953168279",
       "-323333915936767999634844119809319135460509879311229599308354939953168279",
       "109533461242727456317187321637480456637352670377446387229311720642342270936669079",
       "-109533461242727456317187321637480456637352670377446387229311720642342270936669079",
       "1385911310557366456440256909064094890695543397784942861180089270740259394708721160036253862597269877264942393141524860354011688095362554758164667579347793400229024555480224078270156224230580104617746710199310164986752840215359839845498564497854670854",
       "-1385911310557366456440256909064094890695543397784942861180089270740259394708721160036253862597269877264942393141524860354011688095362554758164667579347793400229024555480224078270156224230580104617746710199310164986752840215359839845498564497854670854",
       "29774115054799535833930768716897017350284486426186383584162324318962025027678962428276603554895692141466695531519088683268104074739324371129542465293986416152097350166384444454811692728264434003142202934260616565733198831279676615440572524973775003086833767426",
       "-29774115054799535833930768716897017350284486426186383584162324318962025027678962428276603554895692141466695531519088683268104074739324371129542465293986416152097350166384444454811692728264434003142202934260616565733198831279676615440572524973775003086833767426",
       "74696367101640724890251441072354635571976155536130046140237438589798381789554793148406818355661257862104683281722318017709028012486180422540427675980472782459468162926394976288225872264456693023891477557259759177462765826175659413065496505969367440547828089465241517425279607801825661125137502490209352550",
       "-74696367101640724890251441072354635571976155536130046140237438589798381789554793148406818355661257862104683281722318017709028012486180422540427675980472782459468162926394976288225872264456693023891477557259759177462765826175659413065496505969367440547828089465241517425279607801825661125137502490209352550",
       "1204196594639385922414846449687106633371016123988162000948048507502126642148118",
       "-1204196594639385922414846449687106633371016123988162000948048507502126642148118",
       "846833858170919771038203149272750341572762713657689308208261686002409383861625765452744323828942233333",
       "-846833858170919771038203149272750341572762713657689308208261686002409383861625765452744323828942233333",
       "182161452241374047273456867899515861555380897442569148219001470598361338903885535593714631480225974535244035939079461012689178031931288032512442603044979036705163872936026346865633839654342088060028594652808131903888369770826412770233292335398149959646",
       "-182161452241374047273456867899515861555380897442569148219001470598361338903885535593714631480225974535244035939079461012689178031931288032512442603044979036705163872936026346865633839654342088060028594652808131903888369770826412770233292335398149959646",
       "982677520230623904675071524585093908331832014895485448777250229533226440326748097093798644810",
       "-982677520230623904675071524585093908331832014895485448777250229533226440326748097093798644810",
       "2470642728099219780778259687407342337194729387462688122808418202258274933287",
       "-2470642728099219780778259687407342337194729387462688122808418202258274933287",
       "21642",
       "-21642",
       "28109476527429648692470007325789564480573483619310804793750563939329019602047743826734114282192488430735600284398989680911911960943283501628534649887574302741936678165842670818369902783900366003306472118461382044113045381589251197206074842928328220219584087542112389580462137108895790086",
       "-28109476527429648692470007325789564480573483619310804793750563939329019602047743826734114282192488430735600284398989680911911960943283501628534649887574302741936678165842670818369902783900366003306472118461382044113045381589251197206074842928328220219584087542112389580462137108895790086",
       "24473934394139795039432356490797923225705279667816043556538102097065",
       "-24473934394139795039432356490797923225705279667816043556538102097065",
       "967666937415492520370655115944840613051857445576119169258498049770608556022671644163127742796054969198094856",
       "-967666937415492520370655115944840613051857445576119169258498049770608556022671644163127742796054969198094856",
       "8777670436928270404636672844045971126192291209566648012730356503650458463860437163044293866063131499188106079322582985846405009457295181485284286775546965040263973340573887093705724765371051485505998527923498980801571623582212444207027545811844533625560957194790459778850062900748",
       "-8777670436928270404636672844045971126192291209566648012730356503650458463860437163044293866063131499188106079322582985846405009457295181485284286775546965040263973340573887093705724765371051485505998527923498980801571623582212444207027545811844533625560957194790459778850062900748",
       "10519677007822794739900735125229787943972331835720269482799977",
       "-10519677007822794739900735125229787943972331835720269482799977",
       "1590072871278743537180333082100146324295480429097445157011611168462260468069742799519303496051313133424632939883615906533434106640128123864165917007171699524724790769928823375793283671051479570198286895253998686473352852617282646423776591164499455695311138248299",
       "-1590072871278743537180333082100146324295480429097445157011611168462260468069742799519303496051313133424632939883615906533434106640128123864165917007171699524724790769928823375793283671051479570198286895253998686473352852617282646423776591164499455695311138248299",
       "383577258388475022706431955525247573599499248581278423720457780337892379126935",
       "-383577258388475022706431955525247573599499248581278423720457780337892379126935",
       "4092674502161259843824589343985242161447501042778080381002610852870457757982768392530808942900298511043488661625193784801456963642409098266685508736530379429664593489447947572985105744943017018734265426997872693998175650632205202701888817395372790067319643794599452089403576233527127077671169622",
       "-4092674502161259843824589343985242161447501042778080381002610852870457757982768392530808942900298511043488661625193784801456963642409098266685508736530379429664593489447947572985105744943017018734265426997872693998175650632205202701888817395372790067319643794599452089403576233527127077671169622",
       "13404427613900927247182634952369430867149749267930075884187025351198408344520192279603454195813154024830997527858376982434391797362547445527455503408360391999256823815839930266546427915841779",
       "-13404427613900927247182634952369430867149749267930075884187025351198408344520192279603454195813154024830997527858376982434391797362547445527455503408360391999256823815839930266546427915841779",
       "1782731694176936358469465341561020425473553201468123279175729849215977910638614519237563454448377541145186523281923996935231617014737050458102419525422740666362815640052502503060273650753054955785368306923652680382227789211754118567371586934",
       "-1782731694176936358469465341561020425473553201468123279175729849215977910638614519237563454448377541145186523281923996935231617014737050458102419525422740666362815640052502503060273650753054955785368306923652680382227789211754118567371586934",
       "71445070949104597011738157784103420085714634511010244724089831548057084941763190363056184849082451693612273802898122477866754965092090652561708550",
       "-71445070949104597011738157784103420085714634511010244724089831548057084941763190363056184849082451693612273802898122477866754965092090652561708550",
       "29824403422520048745171796949849941396331286906646046322404644703962912292598789686250791183932008392905170486032131129329348882564734443795544653928497362304776093305233881623231624358963434097033411434801644527775046832916455013625115699965097251269229855092992005057236242615322851235046388965677957662",
       "-29824403422520048745171796949849941396331286906646046322404644703962912292598789686250791183932008392905170486032131129329348882564734443795544653928497362304776093305233881623231624358963434097033411434801644527775046832916455013625115699965097251269229855092992005057236242615322851235046388965677957662",
       "3305915750647269729664177438631754300633043385617699516297426765949911376314744190602062381040796872234391958",
       "-3305915750647269729664177438631754300633043385617699516297426765949911376314744190602062381040796872234391958",
       "3478784122562389625603",
       "-3478784122562389625603",
       "92086546733522598295324541515522297712847163647680019382995445215746554554174953976307228051786981849535290733112403050554954140651771516865900059530798935625857134201153825877196274813040051834092674214044263432436343855130586740109759258782054166065929",
       "-92086546733522598295324541515522297712847163647680019382995445215746554554174953976307228051786981849535290733112403050554954140651771516865900059530798935625857134201153825877196274813040051834092674214044263432436343855130586740109759258782054166065929",
       "65957872354116509297400621319564903702253130516097675674670945971981309842410416012915540911950348439255536201700835793048055599890677253563036692899622137331645054971331690373584438379720134181489517623643988341292887235850459604282122921452528",
       "-65957872354116509297400621319564903702253130516097675674670945971981309842410416012915540911950348439255536201700835793048055599890677253563036692899622137331645054971331690373584438379720134181489517623643988341292887235850459604282122921452528",
       "4165190074711498372705686642027748628010631591673700346085849569414502903758312031393196903476997644869669022781414821544378466903717692187198478658086148256293129853045819435002914",
       "-4165190074711498372705686642027748628010631591673700346085849569414502903758312031393196903476997644869669022781414821544378466903717692187198478658086148256293129853045819435002914",
       "502172553703744753908380772164642649304217792528090440716191580724484473328235664927817984771636372875409898830005825976063650593238541433729038373056225370315599153406133185392320847",
       "-502172553703744753908380772164642649304217792528090440716191580724484473328235664927817984771636372875409898830005825976063650593238541433729038373056225370315599153406133185392320847",
       "25810339190726741831136349797818105994358611764887668315197822821632935574011575463532742868091838388104842551381619490991039627647851601302773448573544037953054558472548",
       "-25810339190726741831136349797818105994358611764887668315197822821632935574011575463532742868091838388104842551381619490991039627647851601302773448573544037953054558472548",
       "4665422938667922731390545239525991067478667357298476881860826251089436662146540827982134227087684685030991914103761128873483160892760746361799786480055617662181625815248230938316973880302906675299954379007760370823224832674779",
       "-4665422938667922731390545239525991067478667357298476881860826251089436662146540827982134227087684685030991914103761128873483160892760746361799786480055617662181625815248230938316973880302906675299954379007760370823224832674779",
       "2223735597830224864049890057834039493638098960775167604145066375240100821674008194961337124741661084219067145508494176034464042665143434078149689607318313818865277681569064932224810481504434495675653041063465302100041302802648038458370477008560806359234416742985635022084248641500377",
       "-2223735597830224864049890057834039493638098960775167604145066375240100821674008194961337124741661084219067145508494176034464042665143434078149689607318313818865277681569064932224810481504434495675653041063465302100041302802648038458370477008560806359234416742985635022084248641500377",
       "42345447563490737654515925924136916105150662665879987625806652403110474948139404742355256883201223238547442445427767854602327889485658289780295383306283583160293766253974742903668207523228749309062814526339073599070",
       "-42345447563490737654515925924136916105150662665879987625806652403110474948139404742355256883201223238547442445427767854602327889485658289780295383306283583160293766253974742903668207523228749309062814526339073599070",
       "40757494492054593189505181124883370961902335356122875708839948469462201920152164929215445",
       "-40757494492054593189505181124883370961902335356122875708839948469462201920152164929215445",
       "489422217562968312762274110453276604934633603473056760608254327080440181671628006090249666021287247215269380617364913734802444913151007354363389984204873709403053283740243705411640696405073698784366581571968399",
       "-489422217562968312762274110453276604934633603473056760608254327080440181671628006090249666021287247215269380617364913734802444913151007354363389984204873709403053283740243705411640696405073698784366581571968399",
       "203828256280853345400063519072625079280180030947163985710628295241982787474897521472368518281000277120011930353824152022905149681658066777399408021281560972784695745183483128330447721487075906552349941557379095078354083487747855104922",
       "-203828256280853345400063519072625079280180030947163985710628295241982787474897521472368518281000277120011930353824152022905149681658066777399408021281560972784695745183483128330447721487075906552349941557379095078354083487747855104922",
       "12579256107866823853770946314828592500732374403508913980712874463292391864755987195690537357503818366347747743186695890433",
       "-12579256107866823853770946314828592500732374403508913980712874463292391864755987195690537357503818366347747743186695890433",
       "26755461309842501536357032592700549777692476999989333013567704060006230872678556198949194222172481328325450314710024939575841488411640806870121381285742075565712411648904027990740378131995279017965737335010708563099143288460848557783",
       "-26755461309842501536357032592700549777692476999989333013567704060006230872678556198949194222172481328325450314710024939575841488411640806870121381285742075565712411648904027990740378131995279017965737335010708563099143288460848557783",
       "179718434482969588987690660522936295504619795328517541448501507443327040584026830018965223706205351139318424383916072860628585971720095475736018979361135523338248920218527202",
       "-179718434482969588987690660522936295504619795328517541448501507443327040584026830018965223706205351139318424383916072860628585971720095475736018979361135523338248920218527202",
       "4559476727415984415667742638506394832394804942241662737080235712002719322907465863068712531182175979070036317680566622",
       "-4559476727415984415667742638506394832394804942241662737080235712002719322907465863068712531182175979070036317680566622",
       "18056873734891410248496182290389914805111823879862689239017282732",
       "-18056873734891410248496182290389914805111823879862689239017282732",
       "28355632329442976457768532159881703427555635510700435885472670967222653884076177077876502624372493819303621756857250806505170393973261606631093857830885883244831587318220509004",
       "-28355632329442976457768532159881703427555635510700435885472670967222653884076177077876502624372493819303621756857250806505170393973261606631093857830885883244831587318220509004",
       "1459732654931833317515433139762665712773308964783227471709926780387231673576225461320924899820938949422193790260955695331912805657904286897274122419209888368548603",
       "-1459732654931833317515433139762665712773308964783227471709926780387231673576225461320924899820938949422193790260955695331912805657904286897274122419209888368548603",
       "841297417411594292128977",
       "-841297417411594292128977",
       "4242195673983737600970155103235752981938372024288592013363272064075708471058134960551862070710453189027317281773782487650970",
       "-4242195673983737600970155103235752981938372024288592013363272064075708471058134960551862070710453189027317281773782487650970",
       "197127905405798244",
       "-197127905405798244",
       "6563407470658357675196420807382675727943443587151170499642011999875762151944659352887984041897388778521562733",
       "-6563407470658357675196420807382675727943443587151170499642011999875762151944659352887984041897388778521562733",
       "171120862433529862507872013528755671195868254123500416552655719933624587064946914905766882327146949422149531556848478731913777486790475986722345662117903207153341",
       "-171120862433529862507872013528755671195868254123500416552655719933624587064946914905766882327146949422149531556848478731913777486790475986722345662117903207153341",
       "187214460763227398586269742130045771591887383985328887736156741862960369193610822715922978601952519088940029424980096549841026833488303831185375087247455968007157419452960145311595471",
       "-187214460763227398586269742130045771591887383985328887736156741862960369193610822715922978601952519088940029424980096549841026833488303831185375087247455968007157419452960145311595471",
       "2673090487374081993731207525489391145288488762290600450482603424170240599600446740180718555900667741328318482506598059839151491967628487386391045037818794920023261735737921639708995039726148095626857322210114264941784225627483927045402749218",
       "-2673090487374081993731207525489391145288488762290600450482603424170240599600446740180718555900667741328318482506598059839151491967628487386391045037818794920023261735737921639708995039726148095626857322210114264941784225627483927045402749218",
       "299586874531112789052013025908546379682766040499696938471256503832571345345612339844529913907580250563145642647",
       "-299586874531112789052013025908546379682766040499696938471256503832571345345612339844529913907580250563145642647",
       "405538475580851874887939920459327617092961192248480802208813876830531489658564864824178266672271683879464330412787024584249226414349424728066961849584546083679996737251131765131648932944495100981642907933045304884221229278087094810231012513599884296417415741723145516546902774087770992604",
       "-405538475580851874887939920459327617092961192248480802208813876830531489658564864824178266672271683879464330412787024584249226414349424728066961849584546083679996737251131765131648932944495100981642907933045304884221229278087094810231012513599884296417415741723145516546902774087770992604",
       "4289997525579508886804910999084475469759259557183118236485054735737485047460566798688052482933027075995626140181076328124548622067825535609834113884951451721787266314523910215228638324453588589604475728750868849529649579405314779527171490876426202137784122981787297800640695809335850632264276817218",
       "-4289997525579508886804910999084475469759259557183118236485054735737485047460566798688052482933027075995626140181076328124548622067825535609834113884951451721787266314523910215228638324453588589604475728750868849529649579405314779527171490876426202137784122981787297800640695809335850632264276817218",
       "8307592530302620538620421474950064873013",
       "-8307592530302620538620421474950064873013",
       "668153113826415803744690433659063449914674108460",
       "-668153113826415803744690433659063449914674108460",
       "46917857009025361535384034419352878543368877134948287044907072634745489626203425426919312434872888667388137952819558853009128820322712955326948275185023832843664510785316937903",
       "-46917857009025361535384034419352878543368877134948287044907072634745489626203425426919312434872888667388137952819558853009128820322712955326948275185023832843664510785316937903",
       "72692276728923532198738657661593229541714898424777445103294553106601965453652630548922019551752677856073619742879036073418",
       "-72692276728923532198738657661593229541714898424777445103294553106601965453652630548922019551752677856073619742879036073418",
       "1365147498021014007274145395277247416653740352472059016216427940658523565320578614021663036729154339063385098348763260722534882240886880631939819",
       "-1365147498021014007274145395277247416653740352472059016216427940658523565320578614021663036729154339063385098348763260722534882240886880631939819",
       "114300720014386070718720229683003272046146186775381997423967458204765959963431901037954797839956346151530366909939183214",
       "-114300720014386070718720229683003272046146186775381997423967458204765959963431901037954797839956346151530366909939183214",
       "6762",
       "-6762",
       "52958329794842511544564431607079502085929565913139912125121000214082684350382689340216127453430020886928460043472604757294523852724883994706799227072659732722150629405334684502120793494615254736603105282342926917766772004919",
       "-52958329794842511544564431607079502085929565913139912125121000214082684350382689340216127453430020886928460043472604757294523852724883994706799227072659732722150629405334684502120793494615254736603105282342926917766772004919",
       "176688206756700071063559027466389453920766491733115376426152125336429137613213551729990793300311032785623",
       "-176688206756700071063559027466389453920766491733115376426152125336429137613213551729990793300311032785623",
       "1922483080110348257033411950111656752298655371856953617086529843662865561409994291993287457671153478029077149725149857725",
       "-1922483080110348257033411950111656752298655371856953617086529843662865561409994291993287457671153478029077149725149857725",
       "116652054071220139544336382432735630060274666911983",
       "-116652054071220139544336382432735630060274666911983",
       "5174104538080339543938990263794928249064915674657896129852899608936285960971761863486556625630466310050160624211680012958157394810117796321101931191821302341708281726643201876685372393200977149042032383466554582623637450297592330981838876150680862436764327264788138788126029954523641986",
       "-5174104538080339543938990263794928249064915674657896129852899608936285960971761863486556625630466310050160624211680012958157394810117796321101931191821302341708281726643201876685372393200977149042032383466554582623637450297592330981838876150680862436764327264788138788126029954523641986",
       "56602051214329308908684928399837460067357624824927409574521689818931407829513021195830603280968596169697964984976489620035360483629559652883726214824557656337088813049173231800245733072858891481768028465352155733037356970930661713472640527903665",
       "-56602051214329308908684928399837460067357624824927409574521689818931407829513021195830603280968596169697964984976489620035360483629559652883726214824557656337088813049173231800245733072858891481768028465352155733037356970930661713472640527903665",
       "50465855132621952642877529162542254312895872248149199085828932352785530557943935823716975491349313488156548806716473058702726383127266",
       "-50465855132621952642877529162542254312895872248149199085828932352785530557943935823716975491349313488156548806716473058702726383127266",
       "2103822150383069790413887708626272542825699206757181614299988243654634518589287733034323781018255",
       "-2103822150383069790413887708626272542825699206757181614299988243654634518589287733034323781018255",
       "2884145868221566190464654384898336516944031094549949335240745089189320393412625205715458573411537464678090067152741985416827426839574623518965109414118185662809105887512018969132683541056905460490486376635525002751775036410408309529607280059108670794204594780445621",
       "-2884145868221566190464654384898336516944031094549949335240745089189320393412625205715458573411537464678090067152741985416827426839574623518965109414118185662809105887512018969132683541056905460490486376635525002751775036410408309529607280059108670794204594780445621",
       "17151949587338385537174755341574689039375819189521363664160085642631581896638291949680521029535105884955679278095750173056302788876858996886433270550139444896998901",
       "-17151949587338385537174755341574689039375819189521363664160085642631581896638291949680521029535105884955679278095750173056302788876858996886433270550139444896998901",
       "480533356849702776352763749832742587425919427139102525668442168835109831060078665166920712330431373189225474215620302495581803094913110624590177406888394624128938633526464614177040468306987399",
       "-480533356849702776352763749832742587425919427139102525668442168835109831060078665166920712330431373189225474215620302495581803094913110624590177406888394624128938633526464614177040468306987399",
       "4048293905596052205036948911452380394795846231788449",
       "-4048293905596052205036948911452380394795846231788449",
       "26995137345178218227830930364666340738",
       "-26995137345178218227830930364666340738",
       "774397441571262230984201650112220858044164538606555323635490088358801192583611522683260312754942754317572391764052135170163899209038840031703432786259696586141227827701639190998818229513",
       "-774397441571262230984201650112220858044164538606555323635490088358801192583611522683260312754942754317572391764052135170163899209038840031703432786259696586141227827701639190998818229513",
       "18762561208181880394479657197069746737270753294648933008217092757003616838536799737540224936022419848244051559923181261528435902887894811151076237",
       "-18762561208181880394479657197069746737270753294648933008217092757003616838536799737540224936022419848244051559923181261528435902887894811151076237",
       "907239775827042770755661550314761787115062100342977397902609610238855670466824379",
       "-907239775827042770755661550314761787115062100342977397902609610238855670466824379",
       "752510106807455900379909618532778973994453687695730898309343615105390212836204453042377052183212876905061",
       "-752510106807455900379909618532778973994453687695730898309343615105390212836204453042377052183212876905061",
       "1594387591422875707361322970839625151131381378174641793551465510142159417127028702651513859466122585110982922292801583543059620610053622982905425511766811223211156471041084636387606630303692709955363035",
       "-1594387591422875707361322970839625151131381378174641793551465510142159417127028702651513859466122585110982922292801583543059620610053622982905425511766811223211156471041084636387606630303692709955363035",
       "23316150037708287470080374296114607254763375473373018965703611900047553929551418522455587001961482391010828529091929849671267100179126145618520750402550331537136654",
       "-23316150037708287470080374296114607254763375473373018965703611900047553929551418522455587001961482391010828529091929849671267100179126145618520750402550331537136654",
       "206570606519236414660405117101821960086150934143523942248291980694989781221204732295572458288359135192620910534498754440751275665591490740002481374496819362873621178489882031204314197626575326338703982006151642904",
       "-206570606519236414660405117101821960086150934143523942248291980694989781221204732295572458288359135192620910534498754440751275665591490740002481374496819362873621178489882031204314197626575326338703982006151642904",
       "64632739363686102310668199833121081452653123828159756435580680576799270035485260582762183515021072594277553694799435773660728228989363057503956061322371391729597055325808343868799201699918264379213943162952380242502610323",
       "-64632739363686102310668199833121081452653123828159756435580680576799270035485260582762183515021072594277553694799435773660728228989363057503956061322371391729597055325808343868799201699918264379213943162952380242502610323",
       "589421411734420159501267976455896411309276255208891167201590523330271039604417032437154142085688410405533459836702131617092573518938815446609802434772431958960872071215171855513041280388698254907927340515117391166070141683457342784",
       "-589421411734420159501267976455896411309276255208891167201590523330271039604417032437154142085688410405533459836702131617092573518938815446609802434772431958960872071215171855513041280388698254907927340515117391166070141683457342784",
       "78879805619934569024599381571707822806614963415349200270284875054237164864359624372158647647863797008340316828012300755667110314855460503179181117097385701319739187114139718329827695009617428401620773545555394848573360317456047893463046622890050301003010952433178967879125505419476694805185008787411114258",
       "-78879805619934569024599381571707822806614963415349200270284875054237164864359624372158647647863797008340316828012300755667110314855460503179181117097385701319739187114139718329827695009617428401620773545555394848573360317456047893463046622890050301003010952433178967879125505419476694805185008787411114258",
       "23502781763641178064404023959903165549857567200280242514656186491195674181432757323176594593508102253721487854615955222259753262265267416938",
       "-23502781763641178064404023959903165549857567200280242514656186491195674181432757323176594593508102253721487854615955222259753262265267416938",
       "409297139610776763506123895143481451963282099839420969098705456374184360544846067009871040867462673178544358986308342020083146065020599826820240081787171394155098100110040672410422987400472449240126519719022700797622570738",
       "-409297139610776763506123895143481451963282099839420969098705456374184360544846067009871040867462673178544358986308342020083146065020599826820240081787171394155098100110040672410422987400472449240126519719022700797622570738",
       "23333202714794325323697505",
       "-23333202714794325323697505",
       "88926553698672071141130629238070206100425021951043909308812007686747474756572535280975280230894876905612920792259781652532353624660383165526934048092970256374163978700915230573599950689593884285235239417830600259906139092309559397593337924686035082341037174504874298230037865321327",
       "-88926553698672071141130629238070206100425021951043909308812007686747474756572535280975280230894876905612920792259781652532353624660383165526934048092970256374163978700915230573599950689593884285235239417830600259906139092309559397593337924686035082341037174504874298230037865321327",
       "193216483164388919875865726156220378900478525465101761599275916110098513",
       "-193216483164388919875865726156220378900478525465101761599275916110098513",
       "445147927105811334112201187535182947887817402193430490222008844342623483790016955826328140200646698573333197769902932812101243075968229955686369555029175781",
       "-445147927105811334112201187535182947887817402193430490222008844342623483790016955826328140200646698573333197769902932812101243075968229955686369555029175781",
       "404724915427015100236245877077487335897861954733139220931559056131326351438847042320598819539736832267015136080413912317007525653866157576085879981310860858916082141809558153661155248226776118160741627797764071433035028151035984348656570943456141740411122305727778772350559929918941",
       "-404724915427015100236245877077487335897861954733139220931559056131326351438847042320598819539736832267015136080413912317007525653866157576085879981310860858916082141809558153661155248226776118160741627797764071433035028151035984348656570943456141740411122305727778772350559929918941",
       "15881033668267446564985922502808887168130126414945171534501886241573767046656582600501857191275522198094812554481448361027945717673462595782212036129626347287630493102505400",
       "-15881033668267446564985922502808887168130126414945171534501886241573767046656582600501857191275522198094812554481448361027945717673462595782212036129626347287630493102505400",
       "2137415689988797072560582676089346590053122445",
       "-2137415689988797072560582676089346590053122445",
       "323798850186148580554863589187091135845440166774430133093440314556959379021941132307127400322225854705093073925068652013957143959242670668925116774275979824",
       "-323798850186148580554863589187091135845440166774430133093440314556959379021941132307127400322225854705093073925068652013957143959242670668925116774275979824",
       "173508106063459544226297157276274728721118210069318517925122848577242175434996938459695476331454013223646557993405407002578179119005445994337106614223750746479653994536225606203430489837348181146905602085037927766933972128185498665420530967676198121700174",
       "-173508106063459544226297157276274728721118210069318517925122848577242175434996938459695476331454013223646557993405407002578179119005445994337106614223750746479653994536225606203430489837348181146905602085037927766933972128185498665420530967676198121700174",
       "78355099355274385235041105626642472390321765441120677546321753788293394435411913702107288104186287888107050196021354011143759436476044341380451",
       "-78355099355274385235041105626642472390321765441120677546321753788293394435411913702107288104186287888107050196021354011143759436476044341380451",
       "14082584100725485095810331470851521352703939751219746773401724408039845947212432002741091564650266209598267452042246073901010147451656273871799778680203026839107331149",
       "-14082584100725485095810331470851521352703939751219746773401724408039845947212432002741091564650266209598267452042246073901010147451656273871799778680203026839107331149",
       "2451726111242013614644472867015070800954350593117210091845723358334627905121894871023262409519589588967063261046514660829821816464168656627289239433694932574140916666824",
       "-2451726111242013614644472867015070800954350593117210091845723358334627905121894871023262409519589588967063261046514660829821816464168656627289239433694932574140916666824",
       "20065158625055757494521923831526555875918181556943569250588125153526936260221797604217490757723244157360646025073105062346371489195519447915244240862375631489025063124997553195851549786517441567063889510370756857238499576234680378947724748027600877684623953611544337343413268969959530489689129071097842283967",
       "-20065158625055757494521923831526555875918181556943569250588125153526936260221797604217490757723244157360646025073105062346371489195519447915244240862375631489025063124997553195851549786517441567063889510370756857238499576234680378947724748027600877684623953611544337343413268969959530489689129071097842283967",
       "2877720628966736569525036642910772915862211025917410379176852591593786965122381483084242795700755306144132542301154682139822037092615315519",
       "-2877720628966736569525036642910772915862211025917410379176852591593786965122381483084242795700755306144132542301154682139822037092615315519",
       "3795119948781692972575431",
       "-3795119948781692972575431",
       "117633423107664842386614454295318823031546808284886498133093442797780366695865088951102734835036375188027702346663647830425172733187275067584200082224814835976110754843437513016147344252016745713239843138800215136235719850541984478206795380204540097476184957279443",
       "-117633423107664842386614454295318823031546808284886498133093442797780366695865088951102734835036375188027702346663647830425172733187275067584200082224814835976110754843437513016147344252016745713239843138800215136235719850541984478206795380204540097476184957279443",
       "6028200577464886742220964264433220606667469744201474633845587044124944417457573648621749660231277732832613157240821087790368844691241612",
       "-6028200577464886742220964264433220606667469744201474633845587044124944417457573648621749660231277732832613157240821087790368844691241612",
       "1117820580139700758941594748763781946255037110167582749384133756752449839190401944216912957650664993553129645500059553210763046702311000117537213965255288711420760932554622971299296197897",
       "-1117820580139700758941594748763781946255037110167582749384133756752449839190401944216912957650664993553129645500059553210763046702311000117537213965255288711420760932554622971299296197897",
       "894440058986616656162159749909897",
       "-894440058986616656162159749909897",
       "11758059164722075820822351813564721682251718268398125058702252593271794825804844012676212580269973081943948588059900469592179919885984813401833621636489306",
       "-11758059164722075820822351813564721682251718268398125058702252593271794825804844012676212580269973081943948588059900469592179919885984813401833621636489306",
       "48260623373995703142149825869126942692445720237750683695954821352777035904885960923027672480964040682023869233942201916828693522743832886088998972188767776078279426029402097202986260065462533610836932273188567823090315418748142243190815560532101505961513910649086153182477090526300312187507612192",
       "-48260623373995703142149825869126942692445720237750683695954821352777035904885960923027672480964040682023869233942201916828693522743832886088998972188767776078279426029402097202986260065462533610836932273188567823090315418748142243190815560532101505961513910649086153182477090526300312187507612192",
       "155032044456958560653742313851007803134963800248495609164183285804227615140653638264588439258316691251377924988538500569549816017742093617863981847156274851353234781166567436349214058632603830394495548221403249818520855020397602702298881144444526972675887598504476681959777521420493375210129749627151599",
       "-155032044456958560653742313851007803134963800248495609164183285804227615140653638264588439258316691251377924988538500569549816017742093617863981847156274851353234781166567436349214058632603830394495548221403249818520855020397602702298881144444526972675887598504476681959777521420493375210129749627151599",
       "117",
       "-117",
       "31151175335",
       "-31151175335",
       "35374964788462894211615124919986334396217303170433399786403229831899783789349053619411986131305536842776505623498475004759495592581325624956208728845327562674600497034793430703900584828213353358028973193115581365893453195729236094397513635",
       "-35374964788462894211615124919986334396217303170433399786403229831899783789349053619411986131305536842776505623498475004759495592581325624956208728845327562674600497034793430703900584828213353358028973193115581365893453195729236094397513635",
       "11796859242834559349330645424007719279425086069437451547961817738176345052586077262730615110965711332407717403184353050831388270460861280643450803074302303211224953369570563468013937668078037503909168201005260137906679740236981824660385730820591421051254923150011711560287985553001992949325890751138512",
       "-11796859242834559349330645424007719279425086069437451547961817738176345052586077262730615110965711332407717403184353050831388270460861280643450803074302303211224953369570563468013937668078037503909168201005260137906679740236981824660385730820591421051254923150011711560287985553001992949325890751138512",
       "170647522893580509002975714845089353418304318223993041052613489603839464032767136346831417604396147862171608710351258359424720597066331032122844389758062085194297618983116731697591466836398130208912823480520907032976237477074428855652406620425725105496",
       "-170647522893580509002975714845089353418304318223993041052613489603839464032767136346831417604396147862171608710351258359424720597066331032122844389758062085194297618983116731697591466836398130208912823480520907032976237477074428855652406620425725105496",
       "5281478654865951520041163170269381080147277352244478257096792252048711710697114547916527006005288159091362187924",
       "-5281478654865951520041163170269381080147277352244478257096792252048711710697114547916527006005288159091362187924",
       "4612981530909908953399866319425198830164041651329116814589068706471983209837216442140437916749761739590696654721694691453248631167747384468652625616153898389404331335686814768720227658621123619760490072200457566243849427676890450504279708348832752925128591526859889728",
       "-4612981530909908953399866319425198830164041651329116814589068706471983209837216442140437916749761739590696654721694691453248631167747384468652625616153898389404331335686814768720227658621123619760490072200457566243849427676890450504279708348832752925128591526859889728",
       "230942413272730226530444519509994205060147713549648054777582719550812782352234600742222169014506643621109087605680440174002739494059492224354791764876753787909937534165450961813280650662325436679754051868455414",
       "-230942413272730226530444519509994205060147713549648054777582719550812782352234600742222169014506643621109087605680440174002739494059492224354791764876753787909937534165450961813280650662325436679754051868455414",
       "528690042093345595850504247",
       "-528690042093345595850504247",
       "31537765402865704303346035013066893813209666897703115111579537190812318360668479310525622135277986713283804",
       "-31537765402865704303346035013066893813209666897703115111579537190812318360668479310525622135277986713283804",
       "1599362772260782365940237955777469665833441883265981514825058091831969039328944925726126036206151420504388513842915084045761",
       "-1599362772260782365940237955777469665833441883265981514825058091831969039328944925726126036206151420504388513842915084045761",
       "22018294718309903690696646065850459504307668740106965970119563766751726997751841635147532383629353261767951801681466624415627829013290232821085001690020179707527003163210966668639431417007076432036482650137410011799888860384641536214437778644612376970907784011215",
       "-22018294718309903690696646065850459504307668740106965970119563766751726997751841635147532383629353261767951801681466624415627829013290232821085001690020179707527003163210966668639431417007076432036482650137410011799888860384641536214437778644612376970907784011215",
       "139228864110515195216553853606798559408959520596931103855825362443397424774758172",
       "-139228864110515195216553853606798559408959520596931103855825362443397424774758172",
       "438362563301076",
       "-438362563301076",
       "536477710240446158400855952047098861739032777002422842180036166459742934651199360607978321612514452622744911025658574877961214107174719449789017540265828279486524590338437269953368890994755662873267173870955360800125978287820421262971848425170065",
       "-536477710240446158400855952047098861739032777002422842180036166459742934651199360607978321612514452622744911025658574877961214107174719449789017540265828279486524590338437269953368890994755662873267173870955360800125978287820421262971848425170065",
       "498862087303189047484286815556440094292974761004818123941676688570935488959257235857771896260779999415327140115975996793571922312686472323161351487622438079274047587863856806852283080757914159158900221821",
       "-498862087303189047484286815556440094292974761004818123941676688570935488959257235857771896260779999415327140115975996793571922312686472323161351487622438079274047587863856806852283080757914159158900221821",
       "397485490350112467732556257997195088092587231213238688938663359508903507782996482344687130558398493814503644541315765003280501133111",
       "-397485490350112467732556257997195088092587231213238688938663359508903507782996482344687130558398493814503644541315765003280501133111",
       "849712043650971777004742171643106324862754090831744200814795006972518085972931752076874433562783731671435108431684162545599206785950669723461026526402295759448129538027792947274880743875232398841880484354651333627643180878756213653",
       "-849712043650971777004742171643106324862754090831744200814795006972518085972931752076874433562783731671435108431684162545599206785950669723461026526402295759448129538027792947274880743875232398841880484354651333627643180878756213653",
       "31939357424827970804026114453315327769012263471221072258182242042519626638563054352273477096407109171097657867287701617587164195568409977479696410846577473709461543239341493963739506308939662837999529461859333741861608567355869490150265338213466190360633042086859245316851129010609",
       "-31939357424827970804026114453315327769012263471221072258182242042519626638563054352273477096407109171097657867287701617587164195568409977479696410846577473709461543239341493963739506308939662837999529461859333741861608567355869490150265338213466190360633042086859245316851129010609",
       "59075219415446517463799317419672630289040",
       "-59075219415446517463799317419672630289040",
       "61544636348619846793635535253831658039274289566061329628",
       "-61544636348619846793635535253831658039274289566061329628",
       "470399936237982365631161793432085070263103572484796818885564848815758149943921811891860946060341559711899471195599373649384438242044515090831782134530922053677106020022279456123296157017910183495235140194390296804039743799564279602012304465862001339612585603213921336997140271860031180936085302533520084",
       "-470399936237982365631161793432085070263103572484796818885564848815758149943921811891860946060341559711899471195599373649384438242044515090831782134530922053677106020022279456123296157017910183495235140194390296804039743799564279602012304465862001339612585603213921336997140271860031180936085302533520084",
       "4263018257494613144043214865050835432323223259669979976818528797978364036590648420",
       "-4263018257494613144043214865050835432323223259669979976818528797978364036590648420",
       "1030364360168890027890816549580",
       "-1030364360168890027890816549580",
       "792685786141580556314148491833336274593743818",
       "-792685786141580556314148491833336274593743818",
       "641446086312126555467875106303989084781624843543297958597183735580271101775752996685163",
       "-641446086312126555467875106303989084781624843543297958597183735580271101775752996685163",
       "5495154319842093167496249323058689957423462",
       "-5495154319842093167496249323058689957423462",
       "11789599234651983989010071854908355935861398361186377696491616773407893531669446332781833177934487486443699554324479061335467496521890118734937498733191672611144989167953103344991959519028482263752023000602387955366518706202210024461852086754020196",
       "-11789599234651983989010071854908355935861398361186377696491616773407893531669446332781833177934487486443699554324479061335467496521890118734937498733191672611144989167953103344991959519028482263752023000602387955366518706202210024461852086754020196",
       "11868320247536683221143642841170454891656934116545619261841381472878070159790790558172360288429121201484338870667354265884102674537478716958516286215910855456088033052883980008436942265685062267471783017549551768359416886934474316919451518061351858590202914987178911670",
       "-11868320247536683221143642841170454891656934116545619261841381472878070159790790558172360288429121201484338870667354265884102674537478716958516286215910855456088033052883980008436942265685062267471783017549551768359416886934474316919451518061351858590202914987178911670",
       "1284156757531040914593221",
       "-1284156757531040914593221",
       "9523156885736314276851029956129745152608513178870686801769759111308470996123088771851122858908132203444859152976097503444227519069060806081448518797562327844612222984531692130770",
       "-9523156885736314276851029956129745152608513178870686801769759111308470996123088771851122858908132203444859152976097503444227519069060806081448518797562327844612222984531692130770",
       "31415032545650652773467205308921957370624743383488073117109921420678201637023554362493982589097031342230335705038785983149366806922747914694551472092848890719761600241693293020110370962350805350",
       "-31415032545650652773467205308921957370624743383488073117109921420678201637023554362493982589097031342230335705038785983149366806922747914694551472092848890719761600241693293020110370962350805350",
       "38540294830367981299370153716758943624066595675817723365819908936210186285351422767835324962411068698716556932780434832522209505361628036446058246936860795564022909013649",
       "-38540294830367981299370153716758943624066595675817723365819908936210186285351422767835324962411068698716556932780434832522209505361628036446058246936860795564022909013649",
       "1489",
       "-1489",
       "2270684970894467473228397152522666196967234885",
       "-2270684970894467473228397152522666196967234885",
       "623594270429426955031234189496487600662597646571928622449980935215346797035198838197888222869632091525558748378610334926140669245375114542239425712378426359715133474059991644743953906535538195465100677512751053",
       "-623594270429426955031234189496487600662597646571928622449980935215346797035198838197888222869632091525558748378610334926140669245375114542239425712378426359715133474059991644743953906535538195465100677512751053",
       "60223901057086672916139687208371207252559034742838976658538850201068490068101652675647609676435807962967919811849514616239086913537412970210091632651259826174103338368751134965303230126211398438698151879240977404460468186851886617548182773561840252412981638510923",
       "-60223901057086672916139687208371207252559034742838976658538850201068490068101652675647609676435807962967919811849514616239086913537412970210091632651259826174103338368751134965303230126211398438698151879240977404460468186851886617548182773561840252412981638510923",
       "352083164097278474078005845682075986531119761078051415723391468152762696096016941577257179144242535089572306180818322625093102190964224730315213843217203692079968682",
       "-352083164097278474078005845682075986531119761078051415723391468152762696096016941577257179144242535089572306180818322625093102190964224730315213843217203692079968682",
       "256914715526573594304760664453685512541013676570328830117752884150636769825195172277797835580253224279327546275273345112399482552434310216245805227544453571042746897560531287112979681556135355",
       "-256914715526573594304760664453685512541013676570328830117752884150636769825195172277797835580253224279327546275273345112399482552434310216245805227544453571042746897560531287112979681556135355",
       "3929812712463085187666519605941080752665430680003082969619532219612559124276337233356486033607557565841182562299051203553436156356748939",
       "-3929812712463085187666519605941080752665430680003082969619532219612559124276337233356486033607557565841182562299051203553436156356748939",
       "1342865274232326934240128816495975896816628726930390134403022164244814040962732527145178443776536620876592577",
       "-1342865274232326934240128816495975896816628726930390134403022164244814040962732527145178443776536620876592577",
       "75482499101235806844482700363651520608393572186840116071510831",
       "-75482499101235806844482700363651520608393572186840116071510831",
       "157079333706470320589362721287335446436100673921262275021919536009571391130921654202277262407403872423297032197476611916298599850639905615780935087993369908937",
       "-157079333706470320589362721287335446436100673921262275021919536009571391130921654202277262407403872423297032197476611916298599850639905615780935087993369908937",
       "21096758435207806377330934948465784354053655",
       "-21096758435207806377330934948465784354053655",
       "7296202760566732448484088809683111106213594240238214600327977304983210800704941723091693567279115428088283219305211898160182",
       "-7296202760566732448484088809683111106213594240238214600327977304983210800704941723091693567279115428088283219305211898160182",
       "9473711847689244707278408760608984165904137893454069938633516224794155238069623008814110071678551847797982066773376077",
       "-9473711847689244707278408760608984165904137893454069938633516224794155238069623008814110071678551847797982066773376077",
       "424157689387860814675639",
       "-424157689387860814675639",
       "2311915845008175998603844058297620909349923283750536586587937434312377733844702049651807722475434283757267961177665307169760829875889028168476878787006491399930630338344642910500797043234542368361571429181649829252175786093011520179318",
       "-2311915845008175998603844058297620909349923283750536586587937434312377733844702049651807722475434283757267961177665307169760829875889028168476878787006491399930630338344642910500797043234542368361571429181649829252175786093011520179318",
       "74548539487073557220326968093479867500276859338046876248826540472060313997",
       "-74548539487073557220326968093479867500276859338046876248826540472060313997",
       "11654322736763",
       "-11654322736763",
       "53007278098826078101002711940372616336",
       "-53007278098826078101002711940372616336",
       "79488890173950413261690334491844393856301694056413503617980571504653230048955",
       "-79488890173950413261690334491844393856301694056413503617980571504653230048955",
       "408713674815985937940894525901270256192656939969702057871",
       "-408713674815985937940894525901270256192656939969702057871",
       "793896474068238367668141234719022911425186020423846578406386752245064555357695445408188930726837363615519065571656957027286833070564842125230923415365473419",
       "-793896474068238367668141234719022911425186020423846578406386752245064555357695445408188930726837363615519065571656957027286833070564842125230923415365473419",
       "174808944301193943551146900431326706416195767876909997906726651518289372951",
       "-174808944301193943551146900431326706416195767876909997906726651518289372951",
       "15518425275704712437859509478557555507942868590674242179846381629609574039655947926978374551659365245896461352380663149726832850553382303285336261869176813113104452944002526144559297701143263522625331250816271032050756743914895178056748128568613436826595",
       "-15518425275704712437859509478557555507942868590674242179846381629609574039655947926978374551659365245896461352380663149726832850553382303285336261869176813113104452944002526144559297701143263522625331250816271032050756743914895178056748128568613436826595",
       "704584697906407199708590092378103021972791431202757824957775774072784740246334320005088181512002963310761780580704786814454975765",
       "-704584697906407199708590092378103021972791431202757824957775774072784740246334320005088181512002963310761780580704786814454975765",
       "657607704878895067543343694899228430336912631528241927302696775319590907402199923852512833112461947631065129028125536463067298383212071017877117414800369576545371975736320978897530313093703317591926126573581594016017999087405971954224745504107290022634832416486976440197266126685274050284770811156390509",
       "-657607704878895067543343694899228430336912631528241927302696775319590907402199923852512833112461947631065129028125536463067298383212071017877117414800369576545371975736320978897530313093703317591926126573581594016017999087405971954224745504107290022634832416486976440197266126685274050284770811156390509",
       "7494538701531220",
       "-7494538701531220",
       "7300727560805294687539012803042995909238449713032452769229667883869087209620881400305875438962218813943386360970483979638425963787311826059269116699436735359914333529525984293006337531416122388956292154685035813667508959604499191395591577891525195678171",
       "-7300727560805294687539012803042995909238449713032452769229667883869087209620881400305875438962218813943386360970483979638425963787311826059269116699436735359914333529525984293006337531416122388956292154685035813667508959604499191395591577891525195678171",
       "255504587698518445312717922712930691081197792561411090916056798257637114731417865482714584651043811829851492818242972929470506766333616107450122580899272969326648134119416080989201012163771767787520485155594757300555185954280304839051723173371630921394024027714555984796981691309",
       "-255504587698518445312717922712930691081197792561411090916056798257637114731417865482714584651043811829851492818242972929470506766333616107450122580899272969326648134119416080989201012163771767787520485155594757300555185954280304839051723173371630921394024027714555984796981691309",
       "1957270404535432491577732407654814296272924990076105665080976425316855184394075979033347631859",
       "-1957270404535432491577732407654814296272924990076105665080976425316855184394075979033347631859",
       "403660520770889026052145363858883993968408567876919963129339377184354008618147803968877043087318952555532301757740363864562971760902711427500126603597011858241477379568684342423222828785569617251693287873736233651273385183220731182322820758659074766543835657767799241434709242669340338048971",
       "-403660520770889026052145363858883993968408567876919963129339377184354008618147803968877043087318952555532301757740363864562971760902711427500126603597011858241477379568684342423222828785569617251693287873736233651273385183220731182322820758659074766543835657767799241434709242669340338048971",
       "1360462270574406",
       "-1360462270574406",
       "41324796834060083364741632465744604155931640433410301186397363904266930128665463361513275697352082859944863112972305377171961651196393476069297383272360",
       "-41324796834060083364741632465744604155931640433410301186397363904266930128665463361513275697352082859944863112972305377171961651196393476069297383272360",
       "3704475702528052685702177087226789799951985298635254026584051739803799717979",
       "-3704475702528052685702177087226789799951985298635254026584051739803799717979",
       "15324664249401045013727127578266722880923015582445744082290396086739217665923549238159714472241913755511109729288179218537980252473553017573593867710189",
       "-15324664249401045013727127578266722880923015582445744082290396086739217665923549238159714472241913755511109729288179218537980252473553017573593867710189",
       "991713895885660445361195566630120268552033337199519129194545503121325658310309321599773356998546067469176345858459212673467904704287664190684736527585420239571896710231",
       "-991713895885660445361195566630120268552033337199519129194545503121325658310309321599773356998546067469176345858459212673467904704287664190684736527585420239571896710231",
       "496917928889709928816019707237559067993121139550552680620307451932907944813916325593269613319259002416192",
       "-496917928889709928816019707237559067993121139550552680620307451932907944813916325593269613319259002416192",
       "5420780319939699155212032775979062279900280911343420051629512809105059842240345509925762577052334971725879572674586223682520124367213762780782010484201065072155930114824432335178466411605479995327050114745584339793378334895820002004268553531081904844570983717097867410603089",
       "-5420780319939699155212032775979062279900280911343420051629512809105059842240345509925762577052334971725879572674586223682520124367213762780782010484201065072155930114824432335178466411605479995327050114745584339793378334895820002004268553531081904844570983717097867410603089",
       "34178515956045799076849256172156569827315750483663840127186371829050429609564171778221768139311136758783705861242122641003313096493057103420927909105632095530710317446888521007163646123762242884609239534269531565599291518871943322912836596141732912619557997670259415580841015283",
       "-34178515956045799076849256172156569827315750483663840127186371829050429609564171778221768139311136758783705861242122641003313096493057103420927909105632095530710317446888521007163646123762242884609239534269531565599291518871943322912836596141732912619557997670259415580841015283",
       "24753103731553244306801885710094553322976800783421479907592940309642834383335499833992007826858595009726122",
       "-24753103731553244306801885710094553322976800783421479907592940309642834383335499833992007826858595009726122",
       "1303658351822779358400767265190404914258468501671414115714852481575404440331055726991532424857235529818287464081864",
       "-1303658351822779358400767265190404914258468501671414115714852481575404440331055726991532424857235529818287464081864",
       "82442525420",
       "-82442525420",
       "40181847350075911374014072545070982",
       "-40181847350075911374014072545070982",
       "6331081104259962585725418329411543440752124680199",
       "-6331081104259962585725418329411543440752124680199",
       "669444625991257897062056995037426293652388602030282843269573026219936289974215349592874907406715089995765108583608936617284270069188005340481379259012388729065198804182112491651898040335690016003489264765600281922569438256615076042625367641",
       "-669444625991257897062056995037426293652388602030282843269573026219936289974215349592874907406715089995765108583608936617284270069188005340481379259012388729065198804182112491651898040335690016003489264765600281922569438256615076042625367641",
       "1168675103592556804163240443883135991575851814861660107303310966160744170850036726911375287483597293098658196142018318809369957616827451967868069658172182991177709289250815148540710360498467949152008438530805196222119517692659923705203865993818359838900924606163081858543",
       "-1168675103592556804163240443883135991575851814861660107303310966160744170850036726911375287483597293098658196142018318809369957616827451967868069658172182991177709289250815148540710360498467949152008438530805196222119517692659923705203865993818359838900924606163081858543",
       "2496566005249030514809106685776267657051598627391700353125416989638685021308242404184826752692976528990582207413089494945",
       "-2496566005249030514809106685776267657051598627391700353125416989638685021308242404184826752692976528990582207413089494945",
       "75831002519613645538052701409851076434071446092420445852577692671",
       "-75831002519613645538052701409851076434071446092420445852577692671",
       "1595257514333333836407007696922732712451830781457969960247677871324618039799",
       "-1595257514333333836407007696922732712451830781457969960247677871324618039799",
       "2352103706291595728734823852677068972089963637096939637892631185119057636184628093243",
       "-2352103706291595728734823852677068972089963637096939637892631185119057636184628093243",
       "55150603036064305927003551612930888862894407146543079948823875920053285006001048840253371944560550042245523051895932284432859",
       "-55150603036064305927003551612930888862894407146543079948823875920053285006001048840253371944560550042245523051895932284432859",
       "183652285344198865127020235735671716726282119574663849914811753120306798386549535194663979983946501785937569600701888628541389188176220321121981286091051",
       "-183652285344198865127020235735671716726282119574663849914811753120306798386549535194663979983946501785937569600701888628541389188176220321121981286091051",
       "1670967627370678916184944999086",
       "-1670967627370678916184944999086",
       "1779553803107116970428487453385844908445190212603430402358107740295247",
       "-1779553803107116970428487453385844908445190212603430402358107740295247",
       "163081585689520939847508610298505981110843",
       "-163081585689520939847508610298505981110843",
       "24608823059620600828775541561806855624217762717902459681958610060078155650689789569089307408156194776319918700684027035605476736967141308737778808097438",
       "-24608823059620600828775541561806855624217762717902459681958610060078155650689789569089307408156194776319918700684027035605476736967141308737778808097438",
       "176229540909991348680999108287461921475890812511086227972678364382149132437628380310728470828832129727355735848528049467023561657293359463509078809812981500824290722272220174525789664137788219060477887820838690954729061422727025173596051655147380497411055372159528861310774057097642760262454",
       "-176229540909991348680999108287461921475890812511086227972678364382149132437628380310728470828832129727355735848528049467023561657293359463509078809812981500824290722272220174525789664137788219060477887820838690954729061422727025173596051655147380497411055372159528861310774057097642760262454",
       "1521679829312851456536026361859335013780557838686738466687399128709926436847394871570976840503705308125705873792672378389916115357657382793749503126640771533338992032259981620506047817865492352874670892991966609760209061301594191537869902100817987599206558753487441796712670736855202929172147294",
       "-1521679829312851456536026361859335013780557838686738466687399128709926436847394871570976840503705308125705873792672378389916115357657382793749503126640771533338992032259981620506047817865492352874670892991966609760209061301594191537869902100817987599206558753487441796712670736855202929172147294",
       "4157696366999482544605875019162016856282588665242578471972156413342580075270416675018859586511300869507848273592737229363773252760313860357749814761595582127449880857952033970115380383676900743584438652262171904692777471245621134891056589732734422433379524779439127971588536170244050150621694478",
       "-4157696366999482544605875019162016856282588665242578471972156413342580075270416675018859586511300869507848273592737229363773252760313860357749814761595582127449880857952033970115380383676900743584438652262171904692777471245621134891056589732734422433379524779439127971588536170244050150621694478",
       "1080490672913509861800536351320773525291317691569674170377657976498332490333353859955175522548201462648648619481614475899104059632553936657464424434357970937863187647621979084401315431140833788114037982",
       "-1080490672913509861800536351320773525291317691569674170377657976498332490333353859955175522548201462648648619481614475899104059632553936657464424434357970937863187647621979084401315431140833788114037982",
       "3194906436319924706167835645658948826079202290534790460576542221669512825113141647211107781595153842508704176837984748167835595231049849647151228364465638129922085890581512323653",
       "-3194906436319924706167835645658948826079202290534790460576542221669512825113141647211107781595153842508704176837984748167835595231049849647151228364465638129922085890581512323653",
       "66347107100300795802324266184385521196001191250641925506321442631467978776436571080979857829987956896197464196707824641007632965810482791998323932299431716570622215408517414037865201951734572676314196738287234254247520531646927798844",
       "-66347107100300795802324266184385521196001191250641925506321442631467978776436571080979857829987956896197464196707824641007632965810482791998323932299431716570622215408517414037865201951734572676314196738287234254247520531646927798844",
       "11755070349326455201",
       "-11755070349326455201",
       "156651043578414506824194498430628709042640792209942834690006663445469241908219457011408374641207896652700963717365255757469753081082784",
       "-156651043578414506824194498430628709042640792209942834690006663445469241908219457011408374641207896652700963717365255757469753081082784",
       "6564614203586776498688508944538260136293893809517937442849470545503761844",
       "-6564614203586776498688508944538260136293893809517937442849470545503761844",
       "598962115054858410821731842471416988283668169539322479066058751789827287104304434155465947780173527582423899421590786844022599493768874809775192652719882115272582161354987",
       "-598962115054858410821731842471416988283668169539322479066058751789827287104304434155465947780173527582423899421590786844022599493768874809775192652719882115272582161354987",
       "14443508661606107679701498958114275550218690763128482677663411487796540412372251008043398613017374358807500824",
       "-14443508661606107679701498958114275550218690763128482677663411487796540412372251008043398613017374358807500824",
       "39256841936111992",
       "-39256841936111992",
       "22003604980409010500616552575366573651583935479333537954768716122155414073009794841075971673796002258058407019824164705801672155808939681382770846685292342660131406075122591374505200827365481659521834044185780365112968118493953141135082476859603163146563",
       "-22003604980409010500616552575366573651583935479333537954768716122155414073009794841075971673796002258058407019824164705801672155808939681382770846685292342660131406075122591374505200827365481659521834044185780365112968118493953141135082476859603163146563",
       "892612825794032675237656399315067134384177542558409873295423125742291209107349193521326932311978865",
       "-892612825794032675237656399315067134384177542558409873295423125742291209107349193521326932311978865",
       "124621",
       "-124621",
       "39935862547719441432334200243323687785328282085889753818085154826607463592957499184719152632875679930608636031007549318604365",
       "-39935862547719441432334200243323687785328282085889753818085154826607463592957499184719152632875679930608636031007549318604365",
       "53150384435463",
       "-53150384435463",
       "5038617365140462881167623487900113792134127235018266576334866703847563260548724132738580936393867769669999269123356358833922994762144381270134211004782972194957315491988474542647182488355728455727224128393875804308265676177706683756178477181259888932449640561270717525443984031839",
       "-5038617365140462881167623487900113792134127235018266576334866703847563260548724132738580936393867769669999269123356358833922994762144381270134211004782972194957315491988474542647182488355728455727224128393875804308265676177706683756178477181259888932449640561270717525443984031839",
       "18681375094308610932506726878974665535026964461038388",
       "-18681375094308610932506726878974665535026964461038388",
       "1694490961016050821118863403337160606621945374045986683635096733891067660467665114977365173029439236924493435715113229950328428294138767438612886428848619529462540214870987656585503501640006260787493433146977269874730836153316545758154447988098965049",
       "-1694490961016050821118863403337160606621945374045986683635096733891067660467665114977365173029439236924493435715113229950328428294138767438612886428848619529462540214870987656585503501640006260787493433146977269874730836153316545758154447988098965049",
       "34981000632270288897102343437813403379909519445061202916917950066646896121823399718762441640573618996405513221104482936830650441434933771175014497076492252938974657476531072878259814088155492254761929",
       "-34981000632270288897102343437813403379909519445061202916917950066646896121823399718762441640573618996405513221104482936830650441434933771175014497076492252938974657476531072878259814088155492254761929",
       "68186095594637277569008966718516358384203015123161693897355580993692840848969688",
       "-68186095594637277569008966718516358384203015123161693897355580993692840848969688",
       "1134126702908819566229008255313053760389444389322516415435539141233919754193425951992416106929842896080872524876962976885893778825250951315557865558643443244064361902243653517585491772912650759627537475187929799073482588432081",
       "-1134126702908819566229008255313053760389444389322516415435539141233919754193425951992416106929842896080872524876962976885893778825250951315557865558643443244064361902243653517585491772912650759627537475187929799073482588432081",
       "1219660173804105678519644769228717229961",
       "-1219660173804105678519644769228717229961",
       "9337788234986472797155798668633720432652335098955723216110827539222560791046580758896359512684081023719629520191135356937552064341414985563338865755044029781700472823138498290646709782655770432472849",
       "-9337788234986472797155798668633720432652335098955723216110827539222560791046580758896359512684081023719629520191135356937552064341414985563338865755044029781700472823138498290646709782655770432472849",
       "150424008592708034173259810113475930440810989335879628469427925370034758050373228994166602606657381400670968588175849346743433462784970176019171026242734",
       "-150424008592708034173259810113475930440810989335879628469427925370034758050373228994166602606657381400670968588175849346743433462784970176019171026242734",
       "10709102135708711290774115917568703434210917471089837954174155027939142290457621570052339242896415391737492196297186964273273691467020576606",
       "-10709102135708711290774115917568703434210917471089837954174155027939142290457621570052339242896415391737492196297186964273273691467020576606",
       "590791035282122817187786741012881114662078084344037620155645055415644697693432897703240908766855757699902350106663298",
       "-590791035282122817187786741012881114662078084344037620155645055415644697693432897703240908766855757699902350106663298",
       "6644806769073273664533505828539666955754832084759883392732355768142191452695685189350231701935219212931529500767858294148963537439795792593286239876735316935797953104882",
       "-6644806769073273664533505828539666955754832084759883392732355768142191452695685189350231701935219212931529500767858294148963537439795792593286239876735316935797953104882",
       "176511387805688073718855394072841750443509085589889404547084544683339270522709736525152936011885659232618530216217042113370236595468110548243408426032715706575057369503893468170961068580632412998988853143083945510800966719",
       "-176511387805688073718855394072841750443509085589889404547084544683339270522709736525152936011885659232618530216217042113370236595468110548243408426032715706575057369503893468170961068580632412998988853143083945510800966719",
       "18197814169943971748763655537459580789924675680558018542859068281859940671016292870607058355",
       "-18197814169943971748763655537459580789924675680558018542859068281859940671016292870607058355",
       "53665744969332986906645019910160121106654070883148709396576439910412784742262054480460348",
       "-53665744969332986906645019910160121106654070883148709396576439910412784742262054480460348",
       "15114701057818447666738431676226302502804615316350076959331191793491140183426763779197478527183420304400143976231566802442732838190730866504640269901006105030291550705062305121857555495397899088813125248050183715824996357342602508",
       "-15114701057818447666738431676226302502804615316350076959331191793491140183426763779197478527183420304400143976231566802442732838190730866504640269901006105030291550705062305121857555495397899088813125248050183715824996357342602508",
       "4538684087847049584760102928758931951663047136365690317969652570682351595540576228149035948547456528545997589204036236408244581413584178489307193893093917026883317801237483886776457347545442242",
       "-4538684087847049584760102928758931951663047136365690317969652570682351595540576228149035948547456528545997589204036236408244581413584178489307193893093917026883317801237483886776457347545442242",
       "68104327977018907402564677909296985240865850899633815987571",
       "-68104327977018907402564677909296985240865850899633815987571",
       "21126389218307474702937983111939394337442364463717300558898463056361786715220551813192286109604739592089468027639535160949266165405455186969313451687709111127347596851523580180558147019220445717949314588542773729044755127625855190216933115799293871340",
       "-21126389218307474702937983111939394337442364463717300558898463056361786715220551813192286109604739592089468027639535160949266165405455186969313451687709111127347596851523580180558147019220445717949314588542773729044755127625855190216933115799293871340",
       "78222020599461507025837080263377239508386033815939450849751163859949403589369059725826445373571398499131861482443466775202688633343807807754044978711136865112845737811903231211872791854642958065042325855161499335",
       "-78222020599461507025837080263377239508386033815939450849751163859949403589369059725826445373571398499131861482443466775202688633343807807754044978711136865112845737811903231211872791854642958065042325855161499335",
       "4085759411276713693098232266986821269735231020974977020052575836176404619187789208196423060444205",
       "-4085759411276713693098232266986821269735231020974977020052575836176404619187789208196423060444205",
       "1184210350766462097978915832676647869625660103053116596342",
       "-1184210350766462097978915832676647869625660103053116596342",
       "194539222104802835983292205414714434524058762756885327380706701321718655745439492716048166059927935241719149428879885478",
       "-194539222104802835983292205414714434524058762756885327380706701321718655745439492716048166059927935241719149428879885478",
       "302225946492334746161844140625842416406247812604200025274581247745184222647724964120371508273766497009905662425211",
       "-302225946492334746161844140625842416406247812604200025274581247745184222647724964120371508273766497009905662425211",
       "28866482602752218187265274692665814018194886187165103251546083935605515506785082873738653268219928502362268",
       "-28866482602752218187265274692665814018194886187165103251546083935605515506785082873738653268219928502362268",
       "5544952079050015240077157700940320243659550435014574041421348665396935579816611507888574593385073797911479160663545693602347256422370826097076074812916781822541849687962368590784552937977886205",
       "-5544952079050015240077157700940320243659550435014574041421348665396935579816611507888574593385073797911479160663545693602347256422370826097076074812916781822541849687962368590784552937977886205",
       "323710452268087591982845307319501376132372316351918100708894690678941776259635618528227710164786257540427054071430282571860354523279847215012107332817795823639212909924515178824923234673149086462596636590350327539723310798213754665082582892561015344012",
       "-323710452268087591982845307319501376132372316351918100708894690678941776259635618528227710164786257540427054071430282571860354523279847215012107332817795823639212909924515178824923234673149086462596636590350327539723310798213754665082582892561015344012",
       "6298178214804809482382903740893261997309254126083786539013344521457218202089579665480198608566443109151164759409311083172285986019510870966646266562147239668466233708302275847273212515270194723859620577435475775917236877537636439092304144350",
       "-6298178214804809482382903740893261997309254126083786539013344521457218202089579665480198608566443109151164759409311083172285986019510870966646266562147239668466233708302275847273212515270194723859620577435475775917236877537636439092304144350",
       "577024710470352032965427500450059067959437337861971906117178872729996600387523062943239129117535935908310731558466601208272240830153365070900204066680943610473920336450708951789975218349225167580113063050191",
       "-577024710470352032965427500450059067959437337861971906117178872729996600387523062943239129117535935908310731558466601208272240830153365070900204066680943610473920336450708951789975218349225167580113063050191",
       "37972747755906620986262153",
       "-37972747755906620986262153",
       "183829698115229455555876942979003514516640128880295179243921716692283845612914437405435307612733660894727800824835948",
       "-183829698115229455555876942979003514516640128880295179243921716692283845612914437405435307612733660894727800824835948",
       "2423832959667360118257064702737609023425800632192836723430775336591100757144072935869557583342500327350488117394557246526227000890820814931134670064874494870718496008517213657614840456624436847012780602721278103167235601948187645617975091973272873241569047573971620372584048698612150640",
       "-2423832959667360118257064702737609023425800632192836723430775336591100757144072935869557583342500327350488117394557246526227000890820814931134670064874494870718496008517213657614840456624436847012780602721278103167235601948187645617975091973272873241569047573971620372584048698612150640",
       "3689827013849535585619411952203826247332426367647260820678883970327796902123440577075450728217270007491470250603087878349241859733492652613679",
       "-3689827013849535585619411952203826247332426367647260820678883970327796902123440577075450728217270007491470250603087878349241859733492652613679",
       "38998054937697595881540875647042048333681659113425435564641134367164935592905762620334835531916327661633470289669510511757807865630506235328273222918421117111281556873070254844441312814372799410820410797988722601761642743512387994633124078",
       "-38998054937697595881540875647042048333681659113425435564641134367164935592905762620334835531916327661633470289669510511757807865630506235328273222918421117111281556873070254844441312814372799410820410797988722601761642743512387994633124078",
       "1742133972499057105001733325633478018605566678002165515479191311988758932166961086848659714709",
       "-1742133972499057105001733325633478018605566678002165515479191311988758932166961086848659714709",
       "2553559760939673132290078919768155422943752579897989356503182382672252331377594911957598202962666902881961594758670198463065653145968650999812730247666",
       "-2553559760939673132290078919768155422943752579897989356503182382672252331377594911957598202962666902881961594758670198463065653145968650999812730247666",
       "51684745772714675394936241781816223514919452679364520537119434050698905337439734233644472369565180889405426257288782419010082579894095799847229362421193687113981266355014802762308095739808334529392234853485537967988890313769779739241401223407407962126345943032536670110549434751102",
       "-51684745772714675394936241781816223514919452679364520537119434050698905337439734233644472369565180889405426257288782419010082579894095799847229362421193687113981266355014802762308095739808334529392234853485537967988890313769779739241401223407407962126345943032536670110549434751102",
       "672712112462360351910518120594120040601436948606148058222300198559244738922266341042360305651450642724475561271288385956130680220169715",
       "-672712112462360351910518120594120040601436948606148058222300198559244738922266341042360305651450642724475561271288385956130680220169715",
       "813447070819324251037079581265526580292907576372477729204338404955584410222478934593619630935314222063003252993694281837026881675600656782635846343833",
       "-813447070819324251037079581265526580292907576372477729204338404955584410222478934593619630935314222063003252993694281837026881675600656782635846343833",
       "1117610225194419065337568894513493776564803226432743080986022521406296090276409739149656072953983798754546991402130235309864912523411568994",
       "-1117610225194419065337568894513493776564803226432743080986022521406296090276409739149656072953983798754546991402130235309864912523411568994",
       "54306983641232120685850754812687679873466315381427348676538013927626387380179070467333206768501131364932160162454016646002006230714059820560113529334910854401021111543333022008153795820172235468858146103351502311717114025204496145038",
       "-54306983641232120685850754812687679873466315381427348676538013927626387380179070467333206768501131364932160162454016646002006230714059820560113529334910854401021111543333022008153795820172235468858146103351502311717114025204496145038",
       "113450443712297816016750119935548807386514765087946158026225637996838314569438356054721778395168",
       "-113450443712297816016750119935548807386514765087946158026225637996838314569438356054721778395168",
       "7352437924947754601546368441398130",
       "-7352437924947754601546368441398130",
       "9846278286558101102640461230277730613939270868227307780570935600269093778822376992893008780014141741647103776048800092788896154696011762350215865588521108549",
       "-9846278286558101102640461230277730613939270868227307780570935600269093778822376992893008780014141741647103776048800092788896154696011762350215865588521108549",
       "73473583275712621559167315389071668112406649781987949641633299346855217310106910560443921944813054763213555679810164708505",
       "-73473583275712621559167315389071668112406649781987949641633299346855217310106910560443921944813054763213555679810164708505",
       "44337393529749818041445106472308772039346354808448275796454672077580119659002042203928900642842510640740800196651911559238276834896411685658708100385336014325",
       "-44337393529749818041445106472308772039346354808448275796454672077580119659002042203928900642842510640740800196651911559238276834896411685658708100385336014325",
       "3029057656526271554842230678161240050706458471766453329711413581607557927250588221517218424325311508555983065479955684772259815134067055583713776773155106422220131994155338255582516687249210697344355756374535219768311432253647445765860280496088041768667890441415297183",
       "-3029057656526271554842230678161240050706458471766453329711413581607557927250588221517218424325311508555983065479955684772259815134067055583713776773155106422220131994155338255582516687249210697344355756374535219768311432253647445765860280496088041768667890441415297183",
       "730896103566527607730753327836819245922931354292181064204035921357800084090450560460429017252539616543803713640582458341962589048267291080308369681271304618861351862971290465709198912575367354463123427808437784040240907793877567792057788579265909741136",
       "-730896103566527607730753327836819245922931354292181064204035921357800084090450560460429017252539616543803713640582458341962589048267291080308369681271304618861351862971290465709198912575367354463123427808437784040240907793877567792057788579265909741136",
       "875972480821342956908137350797672986141068914679963791517259506036957992167704898826150763674879737404204136150",
       "-875972480821342956908137350797672986141068914679963791517259506036957992167704898826150763674879737404204136150",
       "80978095866121182143792129768500985270760294511412625411940522384234727394805988434574920055266468176140927390504528795674710202014688877516082928870193399763361133821060656660414289111945500870045554749239179606901392281466574470956468260058934",
       "-80978095866121182143792129768500985270760294511412625411940522384234727394805988434574920055266468176140927390504528795674710202014688877516082928870193399763361133821060656660414289111945500870045554749239179606901392281466574470956468260058934",
       "5108366192611283244622529332098588886037670912044545212175942213533408183226647011059305581499429284848730575416013640342256910485443191764062474694987448384264155646101960915742145430768592056025304400156363995432483639209748602875976799644331086294285921358845745557709942066403846",
       "-5108366192611283244622529332098588886037670912044545212175942213533408183226647011059305581499429284848730575416013640342256910485443191764062474694987448384264155646101960915742145430768592056025304400156363995432483639209748602875976799644331086294285921358845745557709942066403846",
       "6930180124964356147220207591422279016208371685360099598238746492283122379172191493127595009844321810224523734815981086376030176488602168657385920504832784693281301596520980175713179280297526196841775",
       "-6930180124964356147220207591422279016208371685360099598238746492283122379172191493127595009844321810224523734815981086376030176488602168657385920504832784693281301596520980175713179280297526196841775",
       "127195984139760103169058839514903174746000769823723851981181127452175305070890259297605399965306923149188386831728624922603033165495625460062407066507409867399121450024",
       "-127195984139760103169058839514903174746000769823723851981181127452175305070890259297605399965306923149188386831728624922603033165495625460062407066507409867399121450024",
       "766856719860424381068595879781443086540018712198126893034614346925577170838696737465130140374926102571846639744916246",
       "-766856719860424381068595879781443086540018712198126893034614346925577170838696737465130140374926102571846639744916246",
       "24452524790653436824651691432192056396622748",
       "-24452524790653436824651691432192056396622748",
       "21600696784921267417096322615448095147085787610512586576154030214298480866233496998058741115961394009177458631301020467184235259516317585587331608708009650567889604390408691257559911506849475326601795863368339333809604283115447728657967640020590611529",
       "-21600696784921267417096322615448095147085787610512586576154030214298480866233496998058741115961394009177458631301020467184235259516317585587331608708009650567889604390408691257559911506849475326601795863368339333809604283115447728657967640020590611529",
       "3758893374497950117544956548495424355416942972081749559738750",
       "-3758893374497950117544956548495424355416942972081749559738750",
       "139402452879531227967305026093373374931960661729048047992046850704933112027363474989587334281949398194424695097699435389253833391313981068405251271500306551642365788",
       "-139402452879531227967305026093373374931960661729048047992046850704933112027363474989587334281949398194424695097699435389253833391313981068405251271500306551642365788",
       "25612506870374484873779089622294846964717659760278221279975070009760319283018786412097109135597197982352674303356191527475964885419517878154272980015867348900662204209918494643594136945278141027429152743583659050244679551461363259179124592558207169009059175419818764353589040423929215554316106",
       "-25612506870374484873779089622294846964717659760278221279975070009760319283018786412097109135597197982352674303356191527475964885419517878154272980015867348900662204209918494643594136945278141027429152743583659050244679551461363259179124592558207169009059175419818764353589040423929215554316106",
       "2947281537862409310348470927599528845929360328199550369835553099926787046871370053629653311891644595607839493",
       "-2947281537862409310348470927599528845929360328199550369835553099926787046871370053629653311891644595607839493",
       "5238370098473928109261593022401423141534005322972191017431019829640519389374820628584873426299810704519554264840639788753962805520465217577654353515132848032321812308255870691241084866912560646162061587045231920247690379479011365117594385434098375615768143923448693726900625714250700557084631365841487720",
       "-5238370098473928109261593022401423141534005322972191017431019829640519389374820628584873426299810704519554264840639788753962805520465217577654353515132848032321812308255870691241084866912560646162061587045231920247690379479011365117594385434098375615768143923448693726900625714250700557084631365841487720",
       "12442661493742591574470274906943075194519541250480406451734421223577085372382129292566795701869646895013888531785728273885219518563236237522720693500170071741905622101669444727271767185013757679737024246566421692125582577245793910930758790508707497799356723763185459314157218014300646936606",
       "-12442661493742591574470274906943075194519541250480406451734421223577085372382129292566795701869646895013888531785728273885219518563236237522720693500170071741905622101669444727271767185013757679737024246566421692125582577245793910930758790508707497799356723763185459314157218014300646936606",
       "196768397706108832434401218046908395079672619951322343962935515221968814879",
       "-196768397706108832434401218046908395079672619951322343962935515221968814879",
       "105448359738523054755775683879539460376932545724741416465977687344195271654833613392218097960778272870252224864512166575087075095234145517359783987574090392012176562600550144885565709822164722304408771214923078090216303447672907406306494260347265557611811281654313383497",
       "-105448359738523054755775683879539460376932545724741416465977687344195271654833613392218097960778272870252224864512166575087075095234145517359783987574090392012176562600550144885565709822164722304408771214923078090216303447672907406306494260347265557611811281654313383497",
       "427047",
       "-427047",
       "81856543863229949865307411717645038275510945758537814749232160844289351485471852172626662270166132792505150910334705532703104971400349296170150117058939300885252778996956",
       "-81856543863229949865307411717645038275510945758537814749232160844289351485471852172626662270166132792505150910334705532703104971400349296170150117058939300885252778996956",
       "1157793815124456718861516590400363995161915570086903147642852686851669744820819994596924330213342515606147016987948857909",
       "-1157793815124456718861516590400363995161915570086903147642852686851669744820819994596924330213342515606147016987948857909",
       "940896637988538567397975357071445094467989790092928263312671948706628805236843480432542018263224679720038185333011214261501267693681777878339707753984890375587248023646920869739576148750778030",
       "-940896637988538567397975357071445094467989790092928263312671948706628805236843480432542018263224679720038185333011214261501267693681777878339707753984890375587248023646920869739576148750778030",
       "1277092697774915455425325818506548913089778045288703511320462361515661192684081707471069783269077123507880082821996357021946680618631451261991566032521034200533398597806696743013088727321199529921154950435385831032453193119895011784079743410",
       "-1277092697774915455425325818506548913089778045288703511320462361515661192684081707471069783269077123507880082821996357021946680618631451261991566032521034200533398597806696743013088727321199529921154950435385831032453193119895011784079743410",
       "12484594365439504824667126116411560379532608011162188261784732952579595718551939216912931261112627180909253846258363935011877417495984302385508560070358584377699655038250487243650598",
       "-12484594365439504824667126116411560379532608011162188261784732952579595718551939216912931261112627180909253846258363935011877417495984302385508560070358584377699655038250487243650598",
       "1741383885783666349682975645698617932237500743715841391107227784204719855585223522172382200426887024717924383874873388819696857115564677905327552504",
       "-1741383885783666349682975645698617932237500743715841391107227784204719855585223522172382200426887024717924383874873388819696857115564677905327552504",
       "9368096919796958094889245340222417626105947858557433047800723019",
       "-9368096919796958094889245340222417626105947858557433047800723019",
       "76669478098694609561491577319843969528266563067895013521486786451595735010640930020326448743208375914951894083260394091483935932234283855098968632145970697415601093343",
       "-76669478098694609561491577319843969528266563067895013521486786451595735010640930020326448743208375914951894083260394091483935932234283855098968632145970697415601093343",
       "1876639712516985144893922794716264029310990922149953750634405350881578456885688177463809312620",
       "-1876639712516985144893922794716264029310990922149953750634405350881578456885688177463809312620",
       "186077",
       "-186077",
       "24038469015057796648084289920894727399732658423825146209930020877671076098132117966877846149087015358546337692428012385515366055633105998821389203",
       "-24038469015057796648084289920894727399732658423825146209930020877671076098132117966877846149087015358546337692428012385515366055633105998821389203",
       "20641259550745643346234485579665129143463532482322387615585139677830682894079763990366000612134891527828252798370386444670430513385825695220928137556290078834398139256712344468615779923734232143070994661634892049806652900001420233970754048793898042171067992448201191787158435561",
       "-20641259550745643346234485579665129143463532482322387615585139677830682894079763990366000612134891527828252798370386444670430513385825695220928137556290078834398139256712344468615779923734232143070994661634892049806652900001420233970754048793898042171067992448201191787158435561",
       "90558282393161622936261650596857143828421884875124973816361813844395166",
       "-90558282393161622936261650596857143828421884875124973816361813844395166",
       "893374152282726891992085958120127485743572202276100990922171",
       "-893374152282726891992085958120127485743572202276100990922171",
       "104601387324033669002784175389856736439866138446091862232274237956270168921868535320405566731385430625654533746364405250312870593863224985439702639684142355791792905233795969344981850689932028254291726954427057743196839190399880526778270712454970430735459654847",
       "-104601387324033669002784175389856736439866138446091862232274237956270168921868535320405566731385430625654533746364405250312870593863224985439702639684142355791792905233795969344981850689932028254291726954427057743196839190399880526778270712454970430735459654847",
       "1100640547822452822259608780637373041065326977053681954192776181527618577050122442455730624660403304296015412329954372289398853654524721225006003581004995451247487399511260858844108588935136691954558538445962684147337611140312567681054887671734241832035049841922672004195071",
       "-1100640547822452822259608780637373041065326977053681954192776181527618577050122442455730624660403304296015412329954372289398853654524721225006003581004995451247487399511260858844108588935136691954558538445962684147337611140312567681054887671734241832035049841922672004195071",
       "2967167885422023119778255262377939967247041745814218496240360",
       "-2967167885422023119778255262377939967247041745814218496240360",
       "2766027933722171046554231292404911532459570636916540872038932307272865118512724883948205112046666709093487559219830075352753072061667201",
       "-2766027933722171046554231292404911532459570636916540872038932307272865118512724883948205112046666709093487559219830075352753072061667201",
       "1003655344057107767912014692725976261732681876044961311820943946784371",
       "-1003655344057107767912014692725976261732681876044961311820943946784371",
       "21900502732037517315370094764239443613058564433",
       "-21900502732037517315370094764239443613058564433",
       "45583003657081227658306304711498324162428223935090104",
       "-45583003657081227658306304711498324162428223935090104",
       "204245432840569041148483982796093177932369679988233999329901019356075995960",
       "-204245432840569041148483982796093177932369679988233999329901019356075995960",
       "54884247902140437035368361407902527545416356458607442580170745253262030",
       "-54884247902140437035368361407902527545416356458607442580170745253262030",
       "5334518155628744158007803052398794311169463840470474113725097881874982744596886959948255678621385420985539108742608260405936297075345765000664456806209794363451383928857878909914356480954702762980348813177584480927161733854397043441077512115118243",
       "-5334518155628744158007803052398794311169463840470474113725097881874982744596886959948255678621385420985539108742608260405936297075345765000664456806209794363451383928857878909914356480954702762980348813177584480927161733854397043441077512115118243",
       "586483295964769639990961973863221490702912450472376751506581704396550840803536849728609056194074161983174132325139036388003751640146943",
       "-586483295964769639990961973863221490702912450472376751506581704396550840803536849728609056194074161983174132325139036388003751640146943",
       "5160489070412055213478248749143153314027313193274772183541029614946527505345515388990899156035333461408310459047357741425430914259324755065994103",
       "-5160489070412055213478248749143153314027313193274772183541029614946527505345515388990899156035333461408310459047357741425430914259324755065994103",
       "2027629455583867858236950998133711110883394281732352207813586603417947074456218393483520509566027",
       "-2027629455583867858236950998133711110883394281732352207813586603417947074456218393483520509566027",
       "5188557124098846103707325218",
       "-5188557124098846103707325218",
       "400020709349724273938863924454731823809936035083490166372176005731818513778095755824243823423942457408986667759613017098976884623086030827980554523509430858361367786615095252152639811158705182507617454882805400018345969632806081496172562211701111188286396198492796040003060705842273291",
       "-400020709349724273938863924454731823809936035083490166372176005731818513778095755824243823423942457408986667759613017098976884623086030827980554523509430858361367786615095252152639811158705182507617454882805400018345969632806081496172562211701111188286396198492796040003060705842273291",
       "5077741618469045793277646564358992920960476333244601450034145830501181786188670069707891777075377020328052369395749044352605314330803964782636667529924732654192256597972743806214879074858492363595605",
       "-5077741618469045793277646564358992920960476333244601450034145830501181786188670069707891777075377020328052369395749044352605314330803964782636667529924732654192256597972743806214879074858492363595605",
       "7696189909584112429236607890412659528293987626026266720440261172438548134466224807156242301070086176781584925647653568383958946454001",
       "-7696189909584112429236607890412659528293987626026266720440261172438548134466224807156242301070086176781584925647653568383958946454001",
       "417308020029030078568441933098093721107857721939799845259428192907357371830765301672126412079562811182564973992528737210195074535804805307396531464692210817793443042424312992541689337630019211372",
       "-417308020029030078568441933098093721107857721939799845259428192907357371830765301672126412079562811182564973992528737210195074535804805307396531464692210817793443042424312992541689337630019211372",
       "1322555438304138854190608504305314090997872332525802468309",
       "-1322555438304138854190608504305314090997872332525802468309",
       "2243252463390097730206022598597097545362441865345445435367208364900608574068701725911900977005694987837525981666534993121316833074810732688679185645071871012387337549509711648733018",
       "-2243252463390097730206022598597097545362441865345445435367208364900608574068701725911900977005694987837525981666534993121316833074810732688679185645071871012387337549509711648733018",
       "996999631246356886686476319402220462702895536107891846414650166937411337235327374798687258137003461594493394303654723633588050290355700009203863700819430055925538137094125943576776423062708423296431824562515335853105906638174471031706521164070138118239692600817313403027773040755",
       "-996999631246356886686476319402220462702895536107891846414650166937411337235327374798687258137003461594493394303654723633588050290355700009203863700819430055925538137094125943576776423062708423296431824562515335853105906638174471031706521164070138118239692600817313403027773040755",
       "7407232727584141857860413969133193973271286288996885370643743601041844697247425570485073230177615935516189249509933008589795827697527731537095440446937896691012576063103682886965547257404970422133160836803032660735755375228",
       "-7407232727584141857860413969133193973271286288996885370643743601041844697247425570485073230177615935516189249509933008589795827697527731537095440446937896691012576063103682886965547257404970422133160836803032660735755375228",
       "66507856432274251794176455954413617080912111625650403908424515766595169565610373272262880697471290673940957493067336542878127434500093321175322023848113318710961186458831481208336221616883931621941707175292010516439902743884847403671155360181449053131615233540637713255704186616742945621336873834200241",
       "-66507856432274251794176455954413617080912111625650403908424515766595169565610373272262880697471290673940957493067336542878127434500093321175322023848113318710961186458831481208336221616883931621941707175292010516439902743884847403671155360181449053131615233540637713255704186616742945621336873834200241",
       "31961863828553380988033812855214593359459211110640445946699728653449149746905536006308298520671497324063634041",
       "-31961863828553380988033812855214593359459211110640445946699728653449149746905536006308298520671497324063634041",
       "119618377523937755424839832529346904290447125277702998330825686745624714380165535983701718800753406524499580430492483313401840673306022",
       "-119618377523937755424839832529346904290447125277702998330825686745624714380165535983701718800753406524499580430492483313401840673306022",
       "405681915481957710524110670648088015005969944212725894176433228902381563426021784100141533714164168640878972504794623170560976727288628780986689105062652396339731589340681696758070055865849332874664598654305386",
       "-405681915481957710524110670648088015005969944212725894176433228902381563426021784100141533714164168640878972504794623170560976727288628780986689105062652396339731589340681696758070055865849332874664598654305386",
       "80071205989351736846133464673563483",
       "-80071205989351736846133464673563483",
       "9700773864531435625616214899914065324460851600463291968860331922457988802290698665249481817160070262860115617949877440060186269123630022169856579023685715276196199558700467573542360702057439871151548632003937134635666",
       "-9700773864531435625616214899914065324460851600463291968860331922457988802290698665249481817160070262860115617949877440060186269123630022169856579023685715276196199558700467573542360702057439871151548632003937134635666",
       "64944106993602113652248278796057650905995695388886180354923002182559697540323513",
       "-64944106993602113652248278796057650905995695388886180354923002182559697540323513",
       "37929576313535611121803978435959309812321783154717",
       "-37929576313535611121803978435959309812321783154717",
       "1201000338412478811264460901269015663629403940922465995711563366282532392888117164309460791962587700786925689531323402454933712",
       "-1201000338412478811264460901269015663629403940922465995711563366282532392888117164309460791962587700786925689531323402454933712",
       "470447114867440006531646544662395180489380",
       "-470447114867440006531646544662395180489380",
       "1886414975033222890759454788368278722523410826550821944244006726465034055937087351501071112805393425149681091697659539390880213755450593178650888546158680682861726300055346238147353584",
       "-1886414975033222890759454788368278722523410826550821944244006726465034055937087351501071112805393425149681091697659539390880213755450593178650888546158680682861726300055346238147353584",
       "4664892726074011412424061191534682518434402852534244066439859284421669515547644494221267860310050082413903960265959420616932209365599069348",
       "-4664892726074011412424061191534682518434402852534244066439859284421669515547644494221267860310050082413903960265959420616932209365599069348",
       "28780798756024002725983431800204693077146606485161761312577563898465001036018344",
       "-28780798756024002725983431800204693077146606485161761312577563898465001036018344",
       "32330329650876",
       "-32330329650876",
       "2119979291121167235646126537631495326938621591198105160016067466298282031395514388037592761773940160529230271536093864046314956321286102399202685013097514391108059946817681956440747156573",
       "-2119979291121167235646126537631495326938621591198105160016067466298282031395514388037592761773940160529230271536093864046314956321286102399202685013097514391108059946817681956440747156573",
       "263699852555513851494126759556555000194041870735492675256368970869569739794241286439438865360257448383332427174288750874993061959293095843277366404592822430413842608440069138162513296663098194916628650623285377787520407274835441660863529425698257",
       "-263699852555513851494126759556555000194041870735492675256368970869569739794241286439438865360257448383332427174288750874993061959293095843277366404592822430413842608440069138162513296663098194916628650623285377787520407274835441660863529425698257",
       "1128694221447083514833565943172494061961392351570236661606778701297263608082693757967704225149730415407045688293665284383612835316877341572601586213504558102647155013466806252198360829785603030320627697854353131933390896",
       "-1128694221447083514833565943172494061961392351570236661606778701297263608082693757967704225149730415407045688293665284383612835316877341572601586213504558102647155013466806252198360829785603030320627697854353131933390896",
       "6916983731776108089130775823204431120044571113273264",
       "-6916983731776108089130775823204431120044571113273264",
       "75914457793044064895413508037682032379902701971013411488690441608545",
       "-75914457793044064895413508037682032379902701971013411488690441608545",
       "8879499247714081140479921556021160510154213025912153490299817518668111141293995912780879974244590421191162074944570118497100570991099380592606670090324723096261264086252974733149488230484359814997329229447712203652808121303397231512080257394400660537777330",
       "-8879499247714081140479921556021160510154213025912153490299817518668111141293995912780879974244590421191162074944570118497100570991099380592606670090324723096261264086252974733149488230484359814997329229447712203652808121303397231512080257394400660537777330",
       "1724506383335075569722951957439066815",
       "-1724506383335075569722951957439066815",
       "1194371342067583821224146035467746385145120448082902327311395191487125759843115454058224224089457130",
       "-1194371342067583821224146035467746385145120448082902327311395191487125759843115454058224224089457130",
       "116571209611185337284731713897921002952811284109399364843701582086430272601727355870457693093",
       "-116571209611185337284731713897921002952811284109399364843701582086430272601727355870457693093",
       "26168929789567416417896877953711683735315284288420053745760833960409035809279614614583672230970848586995471196762264833662013726559369765619103011658619869727814614782931489481458661981043479676591818357",
       "-26168929789567416417896877953711683735315284288420053745760833960409035809279614614583672230970848586995471196762264833662013726559369765619103011658619869727814614782931489481458661981043479676591818357",
       "243012047985288247713378637185988647187985010392388570351653505841125573018162558460717652828862937",
       "-243012047985288247713378637185988647187985010392388570351653505841125573018162558460717652828862937",
       "10664054546419657059895154308389295209775305216580625182685797954089483388356503442301133821162999463846286618424679215827037042324",
       "-10664054546419657059895154308389295209775305216580625182685797954089483388356503442301133821162999463846286618424679215827037042324",
       "93382430984727342024648229617198660330774557968214720265565362040755873830899272200516094884487181897372100083086702655979998495443",
       "-93382430984727342024648229617198660330774557968214720265565362040755873830899272200516094884487181897372100083086702655979998495443",
       "13126062810625043063456380164790384012915764511630796458248365510538114092330596186281347044586364215270683612292866613952971844005196715563009674494624957852022027173471052976928718844001264455268592601375542242160924315548654836823549859553",
       "-13126062810625043063456380164790384012915764511630796458248365510538114092330596186281347044586364215270683612292866613952971844005196715563009674494624957852022027173471052976928718844001264455268592601375542242160924315548654836823549859553",
       "9368582362765814557187196024001227849888168077472266659772600971697428366492708926906258905590833059706396684592884687526358204703256054330603971127944678906",
       "-9368582362765814557187196024001227849888168077472266659772600971697428366492708926906258905590833059706396684592884687526358204703256054330603971127944678906",
       "278701771665221100457912961846034172",
       "-278701771665221100457912961846034172",
       "382464310254920012603200760",
       "-382464310254920012603200760",
       "1086701652931645659413181704075891369501487115000150234704055924790606399915277424771761502385407750848874457084738431566772206432850777390818546802908541311070886519070558468667864533850452989704316665227997074954119733405730362633188789872620053510199052652185571293239445061650299573526583634686290646340",
       "-1086701652931645659413181704075891369501487115000150234704055924790606399915277424771761502385407750848874457084738431566772206432850777390818546802908541311070886519070558468667864533850452989704316665227997074954119733405730362633188789872620053510199052652185571293239445061650299573526583634686290646340",
       "1436027919103852779047018224513001412434295916624702899496423156978055321701822379",
       "-1436027919103852779047018224513001412434295916624702899496423156978055321701822379",
       "358956740433261819154697401028765647885314537021358004573",
       "-358956740433261819154697401028765647885314537021358004573",
       "2570919810686260443090976956907911580117431201667893432876299852175711324820817103455438469322058313607578962386364736310503021461418759938196980029731001153192509640082331671491566785848363799371983266719541295357316341488191889371987260280114237",
       "-2570919810686260443090976956907911580117431201667893432876299852175711324820817103455438469322058313607578962386364736310503021461418759938196980029731001153192509640082331671491566785848363799371983266719541295357316341488191889371987260280114237",
       "25162923422743354542149586612896418135445747897968173426132346622460254031452425686287824478617146278670264713886155228992283141903843330748647605337845897726364270262270221388553425764365596646869122752625837519793121116201637138123589",
       "-25162923422743354542149586612896418135445747897968173426132346622460254031452425686287824478617146278670264713886155228992283141903843330748647605337845897726364270262270221388553425764365596646869122752625837519793121116201637138123589",
       "4278027626",
       "-4278027626",
       "13701895078474585475247137503379489809369496012756504256009512583880126487325483060",
       "-13701895078474585475247137503379489809369496012756504256009512583880126487325483060",
       "840786904525379769789300537711189060152537247097220818494507832789559514433741881148404020369408737305833463880040532404710981950433015449671738772090021173041178316879389133142755654332186395733035047829330146580877246938698632854141466195209370012956133251007728880713807067719044277",
       "-840786904525379769789300537711189060152537247097220818494507832789559514433741881148404020369408737305833463880040532404710981950433015449671738772090021173041178316879389133142755654332186395733035047829330146580877246938698632854141466195209370012956133251007728880713807067719044277",
       "3276292788321967735809171244238550320799741743618059640716169790896705284371",
       "-3276292788321967735809171244238550320799741743618059640716169790896705284371",
       "1444750318330952168038880813831551223482419869563017466378766743222046493652050967605113492030925684948366811229446235163057029451862026449099533578455062305802501669339640305034074716552601620379378463996993533643594750826540",
       "-1444750318330952168038880813831551223482419869563017466378766743222046493652050967605113492030925684948366811229446235163057029451862026449099533578455062305802501669339640305034074716552601620379378463996993533643594750826540",
       "24086541858702055427502392901637",
       "-24086541858702055427502392901637",
       "4330081338691920762224608526717824389301173480290111106078901689480766861452007892469366598230052182293662205113692558414456231710116801557663552676919",
       "-4330081338691920762224608526717824389301173480290111106078901689480766861452007892469366598230052182293662205113692558414456231710116801557663552676919",
       "27418448940760548112970686808757044592831257648000991603843244426565505080207854209562533723933529598541150",
       "-27418448940760548112970686808757044592831257648000991603843244426565505080207854209562533723933529598541150",
       "4864349348505372641735591623253935562079434294533303015906939805788562228545435455999490952132421630107381486091394263343039603335970384360527032450993718152333512135859319365168",
       "-4864349348505372641735591623253935562079434294533303015906939805788562228545435455999490952132421630107381486091394263343039603335970384360527032450993718152333512135859319365168",
       "1626611771502100547320818336906281142864525046004643066115702536679123387159152005305066",
       "-1626611771502100547320818336906281142864525046004643066115702536679123387159152005305066",
       "14293419224795219525714860242008460020503397376158988250120766700936504062",
       "-14293419224795219525714860242008460020503397376158988250120766700936504062",
       "8260753138917023233566421292298962764237807151943318525543970544500632597376493524337437826032865212814429643010352970402898369401423576606526232369458199913160215970566401517084565439231237176671986172844275163759328663201716196906130863901168073596480102005930047541965611641872232312988889482629",
       "-8260753138917023233566421292298962764237807151943318525543970544500632597376493524337437826032865212814429643010352970402898369401423576606526232369458199913160215970566401517084565439231237176671986172844275163759328663201716196906130863901168073596480102005930047541965611641872232312988889482629",
       "5277758874516137277732773354886538661032533122667342258245153872341673598212237223809452902009488931372563068631458175710208259076234089320690",
       "-5277758874516137277732773354886538661032533122667342258245153872341673598212237223809452902009488931372563068631458175710208259076234089320690",
       "1604105217156493424796219158328988017738562338480346273566670218046",
       "-1604105217156493424796219158328988017738562338480346273566670218046",
   };

   boost::filesystem::ifstream is(root / "cpp_int1024_serial64.txt");
   std::cout << "Testing cpp_int1024_serial64.txt with T=" << typeid(T).name() << std::endl;
   //is.peek();
   BOOST_CHECK(is.good());
   boost::archive::text_iarchive ia(is);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val;
         ia >> val;
         BOOST_CHECK_EQUAL(val, T(text_array[i]));
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
   }

   boost::filesystem::ifstream is2(root / "cpp_int1024_serial32.txt");
   std::cout << "Testing cpp_int1024_serial32.txt with T=" << typeid(T).name() << std::endl;
   //is2.peek();
   BOOST_CHECK(is2.good());
   boost::archive::text_iarchive ia2(is2);
   for (unsigned i = 0; i < sizeof(text_array) / sizeof(text_array[0]); ++i)
   {
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val;
         ia2 >> val;
         BOOST_CHECK_EQUAL(val, T(text_array[i]));
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
   }
}

int main(int argc, char const* argv[])
{
   if (argc == 2)
   {
      root = argv[1];
      std::cout << "Setting root directory to " << argv[1] << std::endl;
   }
   using namespace boost::multiprecision;
   test64<cpp_int>();
   test64<number<cpp_int_backend<64, 64> > >();
   test128<cpp_int>();
   test128<number<cpp_int_backend<128, 128> > >();
   test1024<cpp_int>();
   test1024<number<cpp_int_backend<1024, 1024> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_import_export.cpp
================================================
// Copyright John Maddock 2015.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif
template <class T>
struct unchecked_type
{
   typedef T type;
};

template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct unchecked_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::unchecked, Allocator>, ExpressionTemplates> type;
};

template <class T>
T generate_random()
{
   typedef typename unchecked_type<T>::type unchecked_T;

   static const unsigned limbs = std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits / std::numeric_limits<unsigned>::digits + 3 : 20;

   static boost::random::uniform_int_distribution<unsigned> ui(0, limbs);
   static boost::random::mt19937                            gen;
   unchecked_T                                              val = gen();
   unsigned                                                 lim = ui(gen);
   for (unsigned i = 0; i < lim; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   return val;
}

template <class T>
void test_round_trip_neg(T val, const std::integral_constant<bool, true>&)
{
   // Try some negative values:
   std::vector<unsigned char> cv;
   T                          newval;
   val = -val;
   export_bits(val, std::back_inserter(cv), 8, false);
   import_bits(newval, cv.begin(), cv.end(), 8, false);
   BOOST_CHECK_EQUAL(-val, newval);
}

template <class T>
void test_round_trip_neg(const T&, const std::integral_constant<bool, false>&)
{
}

template <class T>
void test_round_trip(T val)
{
   std::vector<unsigned char> cv;
   export_bits(val, std::back_inserter(cv), 8);
   T newval;
   import_bits(newval, cv.begin(), cv.end());
   BOOST_CHECK_EQUAL(val, newval);
   // Should get the same value if we reverse the bytes:
   std::reverse(cv.begin(), cv.end());
   newval = 0;
   import_bits(newval, cv.begin(), cv.end(), 8, false);
   BOOST_CHECK_EQUAL(val, newval);
   // Also try importing via pointers as these may memcpy:
   newval = 0;
   import_bits(newval, &cv[0], &cv[0] + cv.size(), 8, false);
   BOOST_CHECK_EQUAL(val, newval);

   cv.clear();
   export_bits(val, std::back_inserter(cv), 8, false);
   import_bits(newval, cv.begin(), cv.end(), 8, false);
   BOOST_CHECK_EQUAL(val, newval);
   std::reverse(cv.begin(), cv.end());
   newval = 0;
   import_bits(newval, cv.begin(), cv.end(), 8, true);
   BOOST_CHECK_EQUAL(val, newval);

   std::vector<std::uintmax_t> bv;
   export_bits(val, std::back_inserter(bv), std::numeric_limits<std::uintmax_t>::digits);
   import_bits(newval, bv.begin(), bv.end());
   BOOST_CHECK_EQUAL(val, newval);
   // Should get the same value if we reverse the values:
   std::reverse(bv.begin(), bv.end());
   newval = 0;
   import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<std::uintmax_t>::digits, false);
   BOOST_CHECK_EQUAL(val, newval);
   // Also try importing via pointers as these may memcpy:
   newval = 0;
   import_bits(newval, &bv[0], &bv[0] + bv.size(), std::numeric_limits<std::uintmax_t>::digits, false);
   BOOST_CHECK_EQUAL(val, newval);

   bv.clear();
   export_bits(val, std::back_inserter(bv), std::numeric_limits<std::uintmax_t>::digits, false);
   import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<std::uintmax_t>::digits, false);
   BOOST_CHECK_EQUAL(val, newval);
   //
   // Try with an unconventional number of bits, to model some machine with guard bits:
   //
   bv.clear();
   export_bits(val, std::back_inserter(bv), std::numeric_limits<std::uintmax_t>::digits - 3);
   import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<std::uintmax_t>::digits - 3);
   BOOST_CHECK_EQUAL(val, newval);

   bv.clear();
   export_bits(val, std::back_inserter(bv), std::numeric_limits<std::uintmax_t>::digits - 3, false);
   import_bits(newval, bv.begin(), bv.end(), std::numeric_limits<std::uintmax_t>::digits - 3, false);
   BOOST_CHECK_EQUAL(val, newval);

   cv.clear();
   export_bits(val, std::back_inserter(cv), 6);
   import_bits(newval, cv.begin(), cv.end(), 6);
   BOOST_CHECK_EQUAL(val, newval);

   cv.clear();
   export_bits(val, std::back_inserter(cv), 6, false);
   import_bits(newval, cv.begin(), cv.end(), 6, false);
   BOOST_CHECK_EQUAL(val, newval);

   test_round_trip_neg(val, std::integral_constant<bool, std::numeric_limits<T>::is_signed>());
}

template <class T>
void test_round_trip()
{
   std::cout << std::hex;
   std::cerr << std::hex;
   for (unsigned i = 0; i < 1000; ++i)
   {
      T val = generate_random<T>();
      test_round_trip(val);
   }
   //
   // Bug cases.
   // See https://github.com/boostorg/multiprecision/issues/21
   T bug(1);
   bug << std::numeric_limits<T>::digits - 1;
   --bug;
   test_round_trip(bug);
}

int main()
{
   test_round_trip<boost::multiprecision::cpp_int>();
   test_round_trip<boost::multiprecision::checked_int1024_t>();
   test_round_trip<boost::multiprecision::checked_uint512_t>();
   test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > >();
   test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<23, 23, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_karatsuba.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

//
// This ensures all our code gets tested, even though it may
// not be the fastest configuration in normal use:
//
#define BOOST_MP_USE_LIMB_SHIFT

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#ifdef _MSC_VER
#pragma warning(disable : 4127) //  Conditional expression is constant
#endif

#ifndef TEST
#define TEST 0
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
struct is_checked_cpp_int : public std::integral_constant<bool, false>
{};
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, class Allocator, boost::multiprecision::expression_template_option ET>
struct is_checked_cpp_int<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::checked, Allocator>, ET> > : public std::integral_constant<bool, true>
{};

template <class N>
typename std::enable_if<boost::multiprecision::backends::is_fixed_precision<typename N::backend_type>::value && !is_checked_cpp_int<N>::value>::type test(const N&)
{
   using namespace boost::multiprecision;

   static unsigned last_error_count = 0;

   timer tim;

   do
   {
      // Test modular arithmetic by filling all the bits of our test type:
      mpz_int f = generate_random<mpz_int>(std::numeric_limits<N>::digits + 2);
      mpz_int g = generate_random<mpz_int>(std::numeric_limits<N>::digits + 2);
      mpz_int mask(1);
      mask <<= std::numeric_limits<N>::digits;
      --mask;
      f &= mask;
      g &= mask;
      mpz_int r = (f * g) & mask;

      N f1(f);
      N g1(g);
      N r1 = f1 * g1;
      BOOST_CHECK_EQUAL(r1.str(), r.str());

      if (last_error_count != (unsigned)boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;
         std::cout << f1 << std::endl;
         std::cout << f << std::endl;
         std::cout << g1 << std::endl;
         std::cout << g << std::endl;
         std::cout << r1 << std::endl;
         std::cout << r << std::endl;
      }

      static boost::random::mt19937             gen;
      boost::random::uniform_int_distribution<> d(12, std::numeric_limits<N>::digits);
      f = generate_random<mpz_int>(d(gen));
      g = generate_random<mpz_int>(d(gen));
      r = (f * g) & mask;

      f1 = N(f);
      g1 = N(g);
      r1 = f1 * g1;
      BOOST_CHECK_EQUAL(r1.str(), r.str());

      if (last_error_count != (unsigned)boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;
         std::cout << f1 << std::endl;
         std::cout << f << std::endl;
         std::cout << g1 << std::endl;
         std::cout << g << std::endl;
         std::cout << r1 << std::endl;
         std::cout << r << std::endl;
      }

#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 200)
#else
      if (tim.elapsed() > 25)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }

   } while (true);
   //
   // Special cases:
   //
   mpz_int mask;
   if (std::numeric_limits<N>::is_bounded)
      mask = mpz_int((std::numeric_limits<N>::max)());
   mpz_int a, b;
   N       x, y;

   unsigned upper_limit = std::numeric_limits<N>::is_bounded ? std::numeric_limits<N>::digits - 1 : 8192 * 2;
   for (unsigned i = 1024; i < upper_limit; i *= 2)
   {
      a = 1;
      a <<= i;
      --a;
      x = 1;
      x <<= i;
      --x;

      b = a * a;
      if (std::numeric_limits<N>::is_bounded)
         b &= mask;
      y = x * x;

      BOOST_CHECK_EQUAL(y.str(), b.str());

      if (last_error_count != (unsigned)boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;
         std::cout << a << std::endl;
         std::cout << x << std::endl;
         std::cout << b << std::endl;
         std::cout << y << std::endl;
      }
   }
}
template <class N>
typename std::enable_if<!(boost::multiprecision::backends::is_fixed_precision<typename N::backend_type>::value && !is_checked_cpp_int<N>::value)>::type test(const N&)
{
   using namespace boost::multiprecision;

   static unsigned last_error_count = 0;

   timer tim;

   mpz_int mask;
   if (std::numeric_limits<N>::is_bounded)
      mask = mpz_int((std::numeric_limits<N>::max)());
   do
   {
      // Test modular arithmetic by filling all the bits of our test type:
      static boost::random::mt19937             gen;
      boost::random::uniform_int_distribution<> d(12, std::numeric_limits<N>::is_bounded ? std::numeric_limits<N>::digits : 100000);
      mpz_int                                   f = generate_random<mpz_int>(d(gen));
      mpz_int                                   g = generate_random<mpz_int>(d(gen));
      mpz_int                                   r = f * g;
      if (std::numeric_limits<N>::is_bounded)
         r &= mask;

      N f1(f);
      N g1(g);
      N r1 = f1 * g1;
      BOOST_CHECK_EQUAL(r1.str(), r.str());

      if (last_error_count != (unsigned)boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;
         std::cout << f1 << std::endl;
         std::cout << f << std::endl;
         std::cout << g1 << std::endl;
         std::cout << g << std::endl;
         std::cout << r1 << std::endl;
         std::cout << r << std::endl;
      }

#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 200)
#else
      if (tim.elapsed() > 25)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }

   } while (true);
   //
   // Special cases:
   //
   mpz_int a, b;
   N       x, y;

   unsigned upper_limit = std::numeric_limits<N>::is_bounded ? std::numeric_limits<N>::digits - 1 : 8192 * 2;
   for (unsigned i = 1024; i < upper_limit; i *= 2)
   {
      a = 1;
      a <<= i;
      --a;
      x = 1;
      x <<= i;
      --x;

      b = a * a;
      if (std::numeric_limits<N>::is_bounded)
         b &= mask;
      y = x * x;

      BOOST_CHECK_EQUAL(y.str(), b.str());

      if (last_error_count != (unsigned)boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;
         std::cout << a << std::endl;
         std::cout << x << std::endl;
         std::cout << b << std::endl;
         std::cout << y << std::endl;
      }
   }
}

int main()
{
   using namespace boost::multiprecision;

#if (TEST == 1) || (TEST == 0)
   test(cpp_int());
#endif
#if (TEST == 2) || (TEST == 0)
   test(number<cpp_int_backend<8192, 8192, signed_magnitude, unchecked, void> >());
#endif
#if (TEST == 3) || (TEST == 0)
   test(number<cpp_int_backend<8192, 8192, signed_magnitude, unchecked, std::allocator<char> > >());
#endif
#if (TEST == 4) || (TEST == 0)
   test(number<cpp_int_backend<8192, 8192, unsigned_magnitude, unchecked> >());
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_left_shift.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare results of truncated left shift to gmp, see:
// https://svn.boost.org/trac/boost/ticket/12790
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

#if !defined(TEST1) && !defined(TEST2) && !defined(TEST3)
#define TEST1
#define TEST2
#define TEST3
#endif

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
void test_value(const T& val)
{
   boost::multiprecision::mpz_int z(val.str()), mask(1);
   mask <<= std::numeric_limits<T>::digits;
   --mask;

   for (unsigned i = 0; i <= std::numeric_limits<T>::digits + 2; ++i)
   {
      BOOST_CHECK_EQUAL((val << i).str(), boost::multiprecision::mpz_int(((z << i) & mask)).str());
   }
}

void test(const std::integral_constant<int, 200>&) {}

template <int N>
void test(std::integral_constant<int, N> const&)
{
   test(std::integral_constant<int, N + 4>());

   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N, N, boost::multiprecision::unsigned_magnitude>, boost::multiprecision::et_off> mp_type;

   std::cout << "Running tests for precision: " << N << std::endl;

   mp_type mp(-1);
   test_value(mp);

   for (unsigned i = 0; i < 1000; ++i)
      test_value(generate_random<mp_type>(std::numeric_limits<mp_type>::digits));
}

int main()
{
   test(std::integral_constant<int, 24>());
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_lit.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

#if !(BOOST_WORKAROUND(BOOST_MSVC, <= 1900) && defined(CI_SUPPRESS_KNOWN_ISSUES)) && defined(BOOST_MP_USER_DEFINED_LITERALS)

using namespace boost::multiprecision;

template <class T>
void test_literal(T val, const char* p)
{
   BOOST_CHECK_EQUAL(val, cpp_int(p));
}

#define TEST_LITERAL(x)                                      \
   {                                                         \
      constexpr auto val1       = BOOST_JOIN(x, _cppi);      \
      constexpr int1024_t val2  = BOOST_JOIN(x, _cppi1024);  \
      constexpr auto      val3  = BOOST_JOIN(x, _cppui);     \
      constexpr uint1024_t val4 = BOOST_JOIN(x, _cppui1024); \
      test_literal(val1, BOOST_STRINGIZE(x));                \
      test_literal(val2, BOOST_STRINGIZE(x));                \
      test_literal(val3, BOOST_STRINGIZE(x));                \
      test_literal(val4, BOOST_STRINGIZE(x));                \
      /* Negative values: */                                 \
      constexpr auto val5      = -BOOST_JOIN(x, _cppi);      \
      constexpr int1024_t val6 = -BOOST_JOIN(x, _cppi1024);  \
      constexpr auto      val7 = -val1;                      \
      constexpr int1024_t val8 = -val2;                      \
      BOOST_CHECK_EQUAL(val5, -cpp_int(val1));               \
      BOOST_CHECK_EQUAL(val6, -cpp_int(val1));               \
      BOOST_CHECK_EQUAL(val7, -cpp_int(val1));               \
      BOOST_CHECK_EQUAL(val8, -cpp_int(val1));               \
   }

int main()
{
   using namespace boost::multiprecision::literals;
   TEST_LITERAL(0x0);
   TEST_LITERAL(0x00000);
   TEST_LITERAL(0x10000000);
   TEST_LITERAL(0x1234500000000123450000000123345000678000000456000000567000000fefabc00000000000000);
   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_int_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/exception/all.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class T>
void test_neg(const T& x, const std::integral_constant<bool, true>&)
{
   T val = -x;
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      std::stringstream             ss;
      boost::archive::text_oarchive oa(ss);
      oa << static_cast<const T&>(val);
      boost::archive::text_iarchive ia(ss);
      T                             val2;
      ia >> val2;
      BOOST_CHECK_EQUAL(val, val2);

      ss.clear();
      boost::archive::binary_oarchive ob(ss);
      ob << static_cast<const T&>(val);
      boost::archive::binary_iarchive ib(ss);
      ib >> val2;
      BOOST_CHECK_EQUAL(val, val2);
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const boost::exception& e)
   {
      std::cout << "Caught boost::exception with:\n";
      std::cout << diagnostic_information(e);
   }
   catch (const std::exception& e)
   {
      std::cout << "Caught std::exception with:\n";
      std::cout << e.what() << std::endl;
   }
#endif
}
template <class T>
void test_neg(const T&, const std::integral_constant<bool, false>&) {}

template <class T>
void test()
{
   using namespace boost::multiprecision;

   boost::random::mt19937 gen;
   boost::uniform_int<>   d(3, std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : 3000);
   timer                  tim;

   while (true)
   {
      T val = generate_random<T>(d(gen));
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         T val2;
         {
            std::stringstream             ss;
            boost::archive::text_oarchive oa(ss);
            oa << static_cast<const T&>(val);
            boost::archive::text_iarchive ia(ss);
            ia >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream               ss;
            boost::archive::binary_oarchive ob(ss);
            ob << static_cast<const T&>(val);
            boost::archive::binary_iarchive ib(ss);
            ib >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss;
            {
               boost::archive::xml_oarchive oc(ss);
               oc << boost::serialization::make_nvp("value", static_cast<const T&>(val));
            }
            boost::archive::xml_iarchive ic(ss);
            ic >> boost::serialization::make_nvp("value", val2);
            BOOST_CHECK_EQUAL(val, val2);
         }

#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
      test_neg(val, std::integral_constant<bool, std::numeric_limits<T>::is_signed>());
      //
      // Check to see if test is taking too long.
      // Tests run on the compiler farm time out after 300 seconds,
      // so don't get too close to that:
      //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 150)
#else
      if (tim.elapsed() > 25)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }
   }
}

#if !defined(TEST1) && !defined(TEST2) && !defined(TEST3) && !defined(TEST4)
#define TEST1
#define TEST2
#define TEST3
#define TEST4
#endif

int main()
{
   using namespace boost::multiprecision;
#ifdef TEST1
   test<cpp_int>();
#endif
#ifdef TEST2
   test<number<cpp_int_backend<61, 61, unsigned_magnitude, unchecked, void> > >();
#endif
#ifdef TEST3
   test<number<cpp_int_backend<120, 120, signed_magnitude, unchecked, void> > >();
#endif
#ifdef TEST4
   test<int1024_t>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_rat_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/exception/all.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   if (!val)
      val = 1;
   return val;
}

template <class T>
void test_neg(const T& x, const std::integral_constant<bool, true>&)
{
   T val = -x;
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      T val2;
      {
         std::stringstream             ss;
         boost::archive::text_oarchive oa(ss);
         oa << static_cast<const T&>(val);
         boost::archive::text_iarchive ia(ss);
         ia >> val2;
         BOOST_CHECK_EQUAL(val, val2);
      }
      {
         std::stringstream               ss;
         boost::archive::binary_oarchive ob(ss);
         ob << static_cast<const T&>(val);
         boost::archive::binary_iarchive ib(ss);
         ib >> val2;
         BOOST_CHECK_EQUAL(val, val2);
      }
      {
         std::stringstream ss;
         {
            boost::archive::xml_oarchive ob(ss);
            ob << boost::serialization::make_nvp("value", static_cast<const T&>(val));
         }
         boost::archive::xml_iarchive ib(ss);
         ib >> boost::serialization::make_nvp("value", val2);
         BOOST_CHECK_EQUAL(val, val2);
      }
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const boost::exception& e)
   {
      std::cout << "Caught boost::exception with:\n";
      std::cout << diagnostic_information(e);
   }
   catch (const std::exception& e)
   {
      std::cout << "Caught std::exception with:\n";
      std::cout << e.what() << std::endl;
   }
#endif
}
template <class T>
void test_neg(const T&, const std::integral_constant<bool, false>&) {}

template <class T>
void test()
{
   using namespace boost::multiprecision;

   boost::random::mt19937 gen;
   boost::uniform_int<>   d(3, std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : 3000);
   timer                  tim;

   while (true)
   {
      T val(generate_random<typename component_type<T>::type>(d(gen)), generate_random<typename component_type<T>::type>(d(gen)));
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         std::stringstream             ss;
         boost::archive::text_oarchive oa(ss);
         oa << static_cast<const T&>(val);
         boost::archive::text_iarchive ia(ss);
         T                             val2;
         ia >> val2;
         BOOST_CHECK_EQUAL(val, val2);

         ss.clear();
         boost::archive::binary_oarchive ob(ss);
         ob << static_cast<const T&>(val);
         boost::archive::binary_iarchive ib(ss);
         ib >> val2;
         BOOST_CHECK_EQUAL(val, val2);
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
      }
#endif
      test_neg(val, std::integral_constant<bool, std::numeric_limits<T>::is_signed>());

      //
      // Check to see if test is taking too long.
      // Tests run on the compiler farm time out after 300 seconds,
      // so don't get too close to that:
      //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 150)
#else
      if (tim.elapsed() > 25)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }
   }
}

int main()
{
   using namespace boost::multiprecision;
   test<cpp_rational>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_cpp_rational.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock.
//  Copyright 2022 Christopher Kormanyos.
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <random>

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#ifdef _MSC_VER
#pragma warning(disable : 4127) //  Conditional expression is constant
#endif

#if !defined(TEST1) && !defined(TEST2) && !defined(TEST3) && !defined(TEST4) && !defined(TEST5) && !defined(TEST6)
#define TEST1
#define TEST2
#define TEST3
#define TEST4
#define TEST5
#define TEST6
#endif

namespace local_random
{

using generator_type = std::mt19937;
using random_type    = typename generator_type::result_type;

generator_type& my_generator()
{
  static generator_type generator_instance;

  return generator_instance;
}

template <class T>
T generate_random(unsigned bits_wanted)
{
   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (my_generator().max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (my_generator().max)();
      val += my_generator()();
   }
   val %= max_val;
   return val;
}

}

template <class Number>
struct tester
{
   using test_type  = Number;
   using checked    = typename test_type::backend_type::checked_type;
   using timer_type = boost::multiprecision::test_detail::timer_template<int, std::chrono::high_resolution_clock>;

   unsigned   last_error_count;
   timer_type tim;

   boost::multiprecision::mpz_int a, b, c, d;
   int                            si;
   unsigned                       ui;
   boost::multiprecision::double_limb_type large_ui;
   test_type                      a1, b1, c1, d1;

   static constexpr int double_limb_type_digit_counter()
   {
      return static_cast<int>(sizeof(boost::multiprecision::double_limb_type)) * 8;
   }

   void t1()
   {
      //
      // Arithmetic, non-mixed:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());

      // positive x, y:
      z = x + y;
      z1 = x1 + y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x - y;
      z1 = x1 - y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x * y;
      z1 = x1 * y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x / y;
      z1 = x1 / y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      
      // negative y:
      y = -y;
      y1 = -y1;
      BOOST_CHECK(y < 0);
      z  = x + y;
      z1 = x1 + y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - y;
      z1 = x1 - y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * y;
      z1 = x1 * y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / y;
      z1 = x1 / y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      
      // negative x:
      x.swap(y);
      x1.swap(y1);
      BOOST_CHECK(x < 0);
      z  = x + y;
      z1 = x1 + y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - y;
      z1 = x1 - y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * y;
      z1 = x1 * y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / y;
      z1 = x1 / y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // negative x, y:
      y = -y;
      y1 = -y1;
      BOOST_CHECK(x < 0);
      BOOST_CHECK(y < 0);
      z  = x + y;
      z1 = x1 + y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - y;
      z1 = x1 - y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * y;
      z1 = x1 * y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / y;
      z1 = x1 / y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Inplace, negative x, y:
      BOOST_CHECK(x < 0);
      BOOST_CHECK(y < 0);
      z = x;
      z += y;
      z1 = x1;
      z1 += y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z -= y;
      z1 = x1;
      z1 -= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= y;
      z1 = x1;
      z1 *= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= z;
      z1 = x1;
      z1 *= z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z /= y;
      z1 = x1;
      z1 /= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Inplace, negative x:
      y  = -y;
      y1 = -y1;
      BOOST_CHECK(x < 0);
      z = x;
      z += y;
      z1 = x1;
      z1 += y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z -= y;
      z1 = x1;
      z1 -= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= y;
      z1 = x1;
      z1 *= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= z;
      z1 = x1;
      z1 *= z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z /= y;
      z1 = x1;
      z1 /= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Inplace, negative y:
      x.swap(y);
      x1.swap(y1);
      BOOST_CHECK(y < 0);
      z = x;
      z += y;
      z1 = x1;
      z1 += y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z -= y;
      z1 = x1;
      z1 -= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= y;
      z1 = x1;
      z1 *= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= z;
      z1 = x1;
      z1 *= z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z /= y;
      z1 = x1;
      z1 /= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Inplace, positive x, y:
      y = -y;
      y1 = -y1;
      BOOST_CHECK(x > 0);
      BOOST_CHECK(y > 0);
      z = x;
      z += y;
      z1 = x1;
      z1 += y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z -= y;
      z1 = x1;
      z1 -= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= y;
      z1 = x1;
      z1 *= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z *= z;
      z1 = x1;
      z1 *= z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z /= y;
      z1 = x1;
      z1 /= y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      BOOST_CHECK_EQUAL((x == y), (x1 == y1));
      BOOST_CHECK_EQUAL((x != y), (x1 != y1));
      BOOST_CHECK_EQUAL((x <= y), (x1 <= y1));
      BOOST_CHECK_EQUAL((x >= y), (x1 >= y1));
      BOOST_CHECK_EQUAL((x < y), (x1 < y1));
      BOOST_CHECK_EQUAL((x > y), (x1 > y1));

      z = x;
      z1 = x1;
      BOOST_CHECK_EQUAL((x == z), (x1 == z1));
      BOOST_CHECK_EQUAL((x != z), (x1 != z1));
      BOOST_CHECK_EQUAL((x <= z), (x1 <= z1));
      BOOST_CHECK_EQUAL((x >= z), (x1 >= z1));
      BOOST_CHECK_EQUAL((x < z), (x1 < z1));
      BOOST_CHECK_EQUAL((x > z), (x1 > z1));
   }

   void t2()
   {
      //
      // Mixed with signed integer:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());

      // Both positive:
      z = x + si;
      z1 = x1 + si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x - si;
      z1 = x1 - si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x * si;
      z1 = x1 * si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x / si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si + x;
      z1 = si + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si - x;
      z1 = si - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si * x;
      z1 = si * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si / x;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x = -x;
      x1 = -x1;
      z  = x + si;
      z1 = x1 + si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - si;
      z1 = x1 - si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * si;
      z1 = x1 * si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si + x;
      z1 = si + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si - x;
      z1 = si - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si * x;
      z1 = si * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si / x;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x and si both negative:
      z  = x + si;
      z1 = x1 + si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - si;
      z1 = x1 - si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * si;
      z1 = x1 * si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si + x;
      z1 = si + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si - x;
      z1 = si - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si * x;
      z1 = si * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si / x;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // si negative:
      x = -x;
      x1 = -x1;
      z  = x + si;
      z1 = x1 + si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - si;
      z1 = x1 - si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * si;
      z1 = x1 * si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si + x;
      z1 = si + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si - x;
      z1 = si - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si * x;
      z1 = si * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = si / x;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      si = -si;
      // Inplace:
      z = x;
      z1 = x1;
      z += si;
      z1 += si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = x;
      z1 = x1;
      z -= si;
      z1 -= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= si;
      z1 *= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // si negative:
      si = -si;
      z  = x;
      z1 = x1;
      z += si;
      z1 += si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= si;
      z1 -= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= si;
      z1 *= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Both negative:
      x  = -x;
      x1 = -x1;
      z  = x;
      z1 = x1;
      z += si;
      z1 += si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= si;
      z1 -= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= si;
      z1 *= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      si = -si;
      z  = x;
      z1 = x1;
      z += si;
      z1 += si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= si;
      z1 -= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= si;
      z1 *= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      BOOST_CHECK_EQUAL((x == si), (x1 == si));
      BOOST_CHECK_EQUAL((x != si), (x1 != si));
      BOOST_CHECK_EQUAL((x <= si), (x1 <= si));
      BOOST_CHECK_EQUAL((x >= si), (x1 >= si));
      BOOST_CHECK_EQUAL((x < si), (x1 < si));
      BOOST_CHECK_EQUAL((x > si), (x1 > si));

      z = si;
      z1 = si;
      BOOST_CHECK_EQUAL((x == si), (x1 == si));
      BOOST_CHECK_EQUAL((x != si), (x1 != si));
      BOOST_CHECK_EQUAL((x <= si), (x1 <= si));
      BOOST_CHECK_EQUAL((x >= si), (x1 >= si));
      BOOST_CHECK_EQUAL((x < si), (x1 < si));
      BOOST_CHECK_EQUAL((x > si), (x1 > si));
   }

   void t3()
   {
      //
      // Mixed with unsigned integer:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());

      // Both positive:
      z  = x + ui;
      z1 = x1 + ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - ui;
      z1 = x1 - ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * ui;
      z1 = x1 * ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / ui;
      z1 = x1 / ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui + x;
      z1 = ui + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui - x;
      z1 = ui - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui * x;
      z1 = ui * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui / x;
      z1 = ui / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x  = -x;
      x1 = -x1;
      z  = x + ui;
      z1 = x1 + ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - ui;
      z1 = x1 - ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * ui;
      z1 = x1 * ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / ui;
      z1 = x1 / ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui + x;
      z1 = ui + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui - x;
      z1 = ui - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui * x;
      z1 = ui * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = ui / x;
      z1 = ui / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      x = -x;
      x1 = -x1;
      // Inplace:
      z  = x;
      z1 = x1;
      z += ui;
      z1 += ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= ui;
      z1 -= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= ui;
      z1 *= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= ui;
      z1 /= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x  = -x;
      x1 = -x1;
      z  = x;
      z1 = x1;
      z += ui;
      z1 += ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= ui;
      z1 -= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= ui;
      z1 *= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= ui;
      z1 /= ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      x = -x;
      x1 = -x1;

      BOOST_CHECK_EQUAL((x == ui), (x1 == ui));
      BOOST_CHECK_EQUAL((x != ui), (x1 != ui));
      BOOST_CHECK_EQUAL((x <= ui), (x1 <= ui));
      BOOST_CHECK_EQUAL((x >= ui), (x1 >= ui));
      BOOST_CHECK_EQUAL((x < ui), (x1 < ui));
      BOOST_CHECK_EQUAL((x > ui), (x1 > ui));

      z  = ui;
      z1 = ui;
      BOOST_CHECK_EQUAL((x == ui), (x1 == ui));
      BOOST_CHECK_EQUAL((x != ui), (x1 != ui));
      BOOST_CHECK_EQUAL((x <= ui), (x1 <= ui));
      BOOST_CHECK_EQUAL((x >= ui), (x1 >= ui));
      BOOST_CHECK_EQUAL((x < ui), (x1 < ui));
      BOOST_CHECK_EQUAL((x > ui), (x1 > ui));
   }

   void t4()
   {
      //
      // Mixed with unsigned long integer:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());

      // Both positive:
      z  = x + large_ui;
      z1 = x1 + large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - large_ui;
      z1 = x1 - large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * large_ui;
      z1 = x1 * large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / large_ui;
      z1 = x1 / large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui + x;
      z1 = large_ui + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui - x;
      z1 = large_ui - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui * x;
      z1 = large_ui * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui / x;
      z1 = large_ui / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x  = -x;
      x1 = -x1;
      z  = x + large_ui;
      z1 = x1 + large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - large_ui;
      z1 = x1 - large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * large_ui;
      z1 = x1 * large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / large_ui;
      z1 = x1 / large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui + x;
      z1 = large_ui + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui - x;
      z1 = large_ui - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui * x;
      z1 = large_ui * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = large_ui / x;
      z1 = large_ui / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      x  = -x;
      x1 = -x1;
      // Inplace:
      z  = x;
      z1 = x1;
      z += large_ui;
      z1 += large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= large_ui;
      z1 -= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= large_ui;
      z1 *= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= large_ui;
      z1 /= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x  = -x;
      x1 = -x1;
      z  = x;
      z1 = x1;
      z += large_ui;
      z1 += large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= large_ui;
      z1 -= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= large_ui;
      z1 *= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= large_ui;
      z1 /= large_ui;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      x  = -x;
      x1 = -x1;

      BOOST_CHECK_EQUAL((x == large_ui), (x1 == large_ui));
      BOOST_CHECK_EQUAL((x != large_ui), (x1 != large_ui));
      BOOST_CHECK_EQUAL((x <= large_ui), (x1 <= large_ui));
      BOOST_CHECK_EQUAL((x >= large_ui), (x1 >= large_ui));
      BOOST_CHECK_EQUAL((x < large_ui), (x1 < large_ui));
      BOOST_CHECK_EQUAL((x > large_ui), (x1 > large_ui));

      z  = large_ui;
      z1 = large_ui;
      BOOST_CHECK_EQUAL((x == large_ui), (x1 == large_ui));
      BOOST_CHECK_EQUAL((x != large_ui), (x1 != large_ui));
      BOOST_CHECK_EQUAL((x <= large_ui), (x1 <= large_ui));
      BOOST_CHECK_EQUAL((x >= large_ui), (x1 >= large_ui));
      BOOST_CHECK_EQUAL((x < large_ui), (x1 < large_ui));
      BOOST_CHECK_EQUAL((x > large_ui), (x1 > large_ui));
   }

   void t5()
   {
      //
      // Special cases:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());

      BOOST_CHECK_EQUAL(x1 * 0, 0);
      BOOST_CHECK_EQUAL(x1 * 1, x1);
      BOOST_CHECK_EQUAL(x1 * -1, -x1);

      z = x * y;
      z1 = x1;
      x1 = x1 * y1;
      BOOST_CHECK_EQUAL(z.str(), x1.str());
      x1 = z1;

      x1 = y1 * x1;
      BOOST_CHECK_EQUAL(z.str(), x1.str());
      x1 = z1;

      z = x * si;
      x1 = x1 * si;
      BOOST_CHECK_EQUAL(z.str(), x1.str());
      x1 = z1;

      x1 = si * x1;
      BOOST_CHECK_EQUAL(z.str(), x1.str());
      x1 = z1;

      z1 = x1;
      z1 *= 0;
      BOOST_CHECK_EQUAL(z1, 0);
      z1 = x1;
      z1 *= 1;
      BOOST_CHECK_EQUAL(z1, x1);
      z1 = x1;
      z1 *= -1;
      BOOST_CHECK_EQUAL(z1, -x1);

      z1 = x1 / x1;
      BOOST_CHECK_EQUAL(z1, 1);
      z1 = x1 / -x1;
      BOOST_CHECK_EQUAL(z1, -1);
      z = x / y;
      z1 = x1;
      z1 = z1 / y1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z1 = y1;
      z1 = x1 / z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      z = x / si;
      z1 = x1;
      z1 = z1 / si;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z = si / x;
      z1 = x1;
      z1 = si / z1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      BOOST_CHECK_THROW(z1 = x1 / 0, std::overflow_error);
      z1= x1;
      BOOST_CHECK_THROW(z1 /= 0, std::overflow_error);
      z1 = x1;
      z1 /= 1;
      BOOST_CHECK_EQUAL(z1, x1);
      z1 /= -1;
      BOOST_CHECK_EQUAL(z1, -x1);
      z1 = x1 / 1;
      BOOST_CHECK_EQUAL(z1, x1);
      z1 = x1 / -1;
      BOOST_CHECK_EQUAL(z1, -x1);

      z1 = 0;
      BOOST_CHECK_EQUAL(z1 * si, 0);
      BOOST_CHECK_EQUAL(z1 / si, 0);
      BOOST_CHECK_EQUAL(z1 + si, si);
      BOOST_CHECK_EQUAL(z1 - si, -si);
      z1 *= si;
      BOOST_CHECK_EQUAL(z1, 0);
      z1 /= si;
      BOOST_CHECK_EQUAL(z1, 0);
      z1 += si;
      BOOST_CHECK_EQUAL(z1, si);
      z1 = 0;
      z1 -= si;
      BOOST_CHECK_EQUAL(z1, -si);

      z1 = si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z1, 1);
      z1 = si;
      z1 /= -si;
      BOOST_CHECK_EQUAL(z1, -1);
      z1 = -si;
      z1 /= si;
      BOOST_CHECK_EQUAL(z1, -1);
      z1 = -si;
      z1 /= -si;
      BOOST_CHECK_EQUAL(z1, 1);

      x1 = si;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z1, 1);
      x1 = si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z1, 1);
      x1 = -si;
      z1 = si / x1;
      BOOST_CHECK_EQUAL(z1, -1);
      x1 = -si;
      z1 = x1 / si;
      BOOST_CHECK_EQUAL(z1, -1);
      x1 = -si;
      z1 = -si / x1;
      BOOST_CHECK_EQUAL(z1, 1);
      x1 = -si;
      z1 = x1 / -si;
      BOOST_CHECK_EQUAL(z1, 1);
      x1 = si;
      z1 = -si / x1;
      BOOST_CHECK_EQUAL(z1, -1);
      x1 = si;
      z1 = x1 / -si;
      BOOST_CHECK_EQUAL(z1, -1);
   }

   void t6()
   {
      //
      // Mixed with signed integer:
      //
      boost::multiprecision::mpq_rational x(a, b), y(c, d), z;
      boost::multiprecision::cpp_rational x1(a1, b1), y1(c1, d1), z1;

      boost::multiprecision::mpz_int bi = local_random::generate_random<boost::multiprecision::mpz_int>(1000);
      boost::multiprecision::cpp_int bi1(bi.str());

      BOOST_CHECK_EQUAL(x.str(), x1.str());
      BOOST_CHECK_EQUAL(y.str(), y1.str());
      BOOST_CHECK_EQUAL(bi.str(), bi1.str());

      // Both positive:
      z  = x + bi;
      z1 = x1 + bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - bi;
      z1 = x1 - bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * bi;
      z1 = x1 * bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / bi;
      z1 = x1 / bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi + x;
      z1 = bi1 + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi - x;
      z1 = bi1 - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi * x;
      z1 = bi1 * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi / x;
      z1 = bi1 / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      x  = -x;
      x1 = -x1;
      z  = x + bi;
      z1 = x1 + bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - bi;
      z1 = x1 - bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * bi;
      z1 = x1 * bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / bi;
      z1 = x1 / bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi + x;
      z1 = bi1 + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi - x;
      z1 = bi1 - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi * x;
      z1 = bi1 * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi / x;
      z1 = bi1 / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x and bi both negative:
      z  = x + bi;
      z1 = x1 + bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - bi;
      z1 = x1 - bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * bi;
      z1 = x1 * bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / bi;
      z1 = x1 / bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi + x;
      z1 = bi1 + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi - x;
      z1 = bi1 - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi * x;
      z1 = bi1 * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi / x;
      z1 = bi1 / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // bi negative:
      x  = -x;
      x1 = -x1;
      z  = x + bi;
      z1 = x1 + bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x - bi;
      z1 = x1 - bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x * bi;
      z1 = x1 * bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x / bi;
      z1 = x1 / bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi + x;
      z1 = bi1 + x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi - x;
      z1 = bi1 - x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi * x;
      z1 = bi1 * x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = bi / x;
      z1 = bi1 / x1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      bi = -bi;
      bi1 = -bi1;
      // Inplace:
      z  = x;
      z1 = x1;
      z += bi;
      z1 += bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= bi;
      z1 -= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= bi;
      z1 *= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= bi;
      z1 /= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // bi negative:
      bi = -bi;
      bi1 = -bi1;
      z  = x;
      z1 = x1;
      z += bi;
      z1 += bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= bi;
      z1 -= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= bi;
      z1 *= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= bi;
      z1 /= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // Both negative:
      x  = -x;
      x1 = -x1;
      z  = x;
      z1 = x1;
      z += bi;
      z1 += bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= bi;
      z1 -= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= bi;
      z1 *= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= bi;
      z1 /= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      // x negative:
      bi = -bi;
      bi1 = -bi1;
      z  = x;
      z1 = x1;
      z += bi;
      z1 += bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z -= bi;
      z1 -= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z *= bi;
      z1 *= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());
      z  = x;
      z1 = x1;
      z /= bi;
      z1 /= bi1;
      BOOST_CHECK_EQUAL(z.str(), z1.str());

      BOOST_CHECK_EQUAL((x == bi), (x1 == bi1));
      BOOST_CHECK_EQUAL((x != bi), (x1 != bi1));
      BOOST_CHECK_EQUAL((x <= bi), (x1 <= bi1));
      BOOST_CHECK_EQUAL((x >= bi), (x1 >= bi1));
      BOOST_CHECK_EQUAL((x < bi), (x1 < bi1));
      BOOST_CHECK_EQUAL((x > bi), (x1 > bi1));

      z  = bi;
      z1 = bi1;
      BOOST_CHECK_EQUAL((x == bi), (x1 == bi1));
      BOOST_CHECK_EQUAL((x != bi), (x1 != bi1));
      BOOST_CHECK_EQUAL((x <= bi), (x1 <= bi1));
      BOOST_CHECK_EQUAL((x >= bi), (x1 >= bi1));
      BOOST_CHECK_EQUAL((x < bi), (x1 < bi1));
      BOOST_CHECK_EQUAL((x > bi), (x1 > bi1));
   }

   void test()
   {
      using namespace boost::multiprecision;

      last_error_count = 0;

      BOOST_CHECK_EQUAL(Number(), 0);

      constexpr auto ilim = 10000;

      constexpr auto large_ui_digits_to_get = double_limb_type_digit_counter();

      // Ensure at compile-time that the amount of digits to get for large_ui is OK.
      static_assert(large_ui_digits_to_get >= std::numeric_limits<unsigned>::digits,
                    "Error: Ensure that the amount of digits to get for large_ui is really correct.");

      for (auto i = 0; i < ilim; ++i)
      {
         a = local_random::generate_random<mpz_int>(1000);
         b = local_random::generate_random<mpz_int>(1000);
         c = local_random::generate_random<mpz_int>(1000);
         d = local_random::generate_random<mpz_int>(1000);

         si = local_random::generate_random<int>
              (
                 static_cast<unsigned>(std::numeric_limits<int>::digits - 2)
              );

         ui = local_random::generate_random<unsigned>
              (
                 static_cast<unsigned>(std::numeric_limits<unsigned>::digits - 2)
              );

         large_ui =
              local_random::generate_random<boost::multiprecision::double_limb_type>
              (
                 static_cast<unsigned>(large_ui_digits_to_get - 2)
              );

         const auto a_represented_as_string = a.str();
         const auto b_represented_as_string = b.str();
         const auto c_represented_as_string = c.str();
         const auto d_represented_as_string = d.str();

         a1 = static_cast<test_type>(a_represented_as_string);
         b1 = static_cast<test_type>(b_represented_as_string);
         c1 = static_cast<test_type>(c_represented_as_string);
         d1 = static_cast<test_type>(d_represented_as_string);

         #if defined(TEST1)
         t1();
         #endif

         #if defined(TEST2)
         t2();
         #endif

         #if defined(TEST3)
         t3();
         #endif

         #if defined(TEST4)
         t4();
         #endif

         #if defined(TEST5)
         t5();
         #endif

         #if defined(TEST6)
         t6();
         #endif

         if (last_error_count != static_cast<unsigned>(boost::detail::test_errors()))
         {
            last_error_count = boost::detail::test_errors();
            std::cout << std::hex << std::showbase;

            std::cout << "a    = " << a << std::endl;
            std::cout << "a1   = " << a1 << std::endl;
            std::cout << "b    = " << b << std::endl;
            std::cout << "b1   = " << b1 << std::endl;
            std::cout << "c    = " << c << std::endl;
            std::cout << "c1   = " << c1 << std::endl;
            std::cout << "d    = " << d << std::endl;
            std::cout << "d1   = " << d1 << std::endl;
            std::cout << "a + b   = " << a + b << std::endl;
            std::cout << "a1 + b1 = " << a1 + b1 << std::endl;
            std::cout << std::dec;
            std::cout << "a - b   = " << a - b << std::endl;
            std::cout << "a1 - b1 = " << a1 - b1 << std::endl;
            std::cout << "-a + b   = " << mpz_int(-a) + b << std::endl;
            std::cout << "-a1 + b1 = " << test_type(-a1) + b1 << std::endl;
            std::cout << "-a - b   = " << mpz_int(-a) - b << std::endl;
            std::cout << "-a1 - b1 = " << test_type(-a1) - b1 << std::endl;
            std::cout << "c*d    = " << c * d << std::endl;
            std::cout << "c1*d1  = " << c1 * d1 << std::endl;
            std::cout << "b*c    = " << b * c << std::endl;
            std::cout << "b1*c1  = " << b1 * c1 << std::endl;
            std::cout << "a/b    = " << a / b << std::endl;
            std::cout << "a1/b1  = " << a1 / b1 << std::endl;
            std::cout << "a/d    = " << a / d << std::endl;
            std::cout << "a1/d1  = " << a1 / d1 << std::endl;
            std::cout << "a%b    = " << a % b << std::endl;
            std::cout << "a1%b1  = " << a1 % b1 << std::endl;
            std::cout << "a%d    = " << a % d << std::endl;
            std::cout << "a1%d1  = " << a1 % d1 << std::endl;
         }

         //
         // Check to see if test is taking too long.
         // Tests run on the compiler farm time out after 300 seconds,
         // so don't get too close to that:
         //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
         if (tim.elapsed() > timer_type::seconds(180))
#else
         if (tim.elapsed() > timer_type::seconds(20))
#endif
         {
            std::cout << "Timeout reached, aborting tests now....\n";
            std::cout << "Loop count reached is i: " << i << "\n";
            break;
         }
      }
   }
};

int main()
{
   using namespace boost::multiprecision;

   tester<cpp_int> t1;
   t1.test();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop.cpp
================================================
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <iostream>
#include <Eigen/Dense>

#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/mpc.hpp>

#include "test.hpp"

using namespace Eigen;

namespace Eigen {
template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates>
struct NumTraits<boost::multiprecision::number<Backend, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<Backend, ExpressionTemplates>                          self_type;
   typedef typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type Real;
   typedef self_type                                                                            NonInteger; // Not correct but we can't do much better??
   typedef double                                                                               Literal;
   typedef self_type                                                                            Nested;
   enum
   {
      IsComplex             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex,
      IsInteger             = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer,
      ReadCost              = 1,
      AddCost               = 4,
      MulCost               = 8,
      IsSigned              = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true,
      RequireInitialization = 1,
   };
   static Real epsilon()
   {
      return std::numeric_limits<Real>::epsilon();
   }
   static Real dummy_precision()
   {
      return sqrt(epsilon());
   }
   static Real highest()
   {
      return (std::numeric_limits<Real>::max)();
   }
   static Real lowest()
   {
      return (std::numeric_limits<Real>::min)();
   }
   static int digits10_imp(const std::integral_constant<bool, true>&)
   {
      return std::numeric_limits<Real>::digits10;
   }
   template <bool B>
   static int digits10_imp(const std::integral_constant<bool, B>&)
   {
      return Real::default_precision();
   }
   static int digits10()
   {
      return digits10_imp(std::integral_constant<bool, std::numeric_limits<Real>::digits10 && (std::numeric_limits<Real>::digits10 != INT_MAX) ? true : false > ());
   }
};

#define BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(A)                                                                                                                                                                       \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                              \
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, A, BinaryOp>                                                                                                           \
   {                                                                                                                                                                                                               \
      static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported."); \
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;                                                                                                                              \
   };                                                                                                                                                                                                              \
   template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>                                                                                              \
   struct ScalarBinaryOpTraits<A, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>                                                                                                           \
   {                                                                                                                                                                                                               \
      static_assert(boost::multiprecision::is_compatible_arithmetic_type<A, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported."); \
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;                                                                                                                              \
   };

BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(float)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long double)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(signed char)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned short)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned int)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(long)
BOOST_MP_EIGEN_SCALAR_TRAITS_DECL(unsigned long)
#if 0
   template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class Backend2, boost::multiprecision::expression_template_option ExpressionTemplates2, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2>, BinaryOp>
   {
      static_assert(
         boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value
         || boost::multiprecision::is_compatible_arithmetic_type<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::value, "Interoperability with this arithmetic type is not supported.");
      typedef typename std::conditional<std::is_convertible<boost::multiprecision::number<Backend2, ExpressionTemplates2>, boost::multiprecision::number<Backend, ExpressionTemplates> >::value,
         boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >::type ReturnType;
   };

   template<unsigned D, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on>, boost::multiprecision::mpfr_float, BinaryOp>
   {
      typedef boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<D>, boost::multiprecision::et_on> ReturnType;
   };

   template<typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::mpfr_float, boost::multiprecision::mpc_complex, BinaryOp>
   {
      typedef boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<0>, boost::multiprecision::et_on> ReturnType;
   };

   template<class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
   struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
   {
      typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
   };
#endif
template <class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, class tag, class Arg1, class Arg2, class Arg3, class Arg4, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::number<Backend, ExpressionTemplates>, boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, BinaryOp>
{
   static_assert(std::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
};

template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Backend, boost::multiprecision::expression_template_option ExpressionTemplates, typename BinaryOp>
struct ScalarBinaryOpTraits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::number<Backend, ExpressionTemplates>, BinaryOp>
{
   static_assert(std::is_convertible<typename boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type, boost::multiprecision::number<Backend, ExpressionTemplates> >::value, "Interoperability with this arithmetic type is not supported.");
   typedef boost::multiprecision::number<Backend, ExpressionTemplates> ReturnType;
};

} // namespace Eigen

template <class T>
struct related_number
{
   typedef T type;
};
/*
template <>
struct related_number<boost::multiprecision::cpp_bin_float_50>
{
   typedef boost::multiprecision::cpp_bin_float_quad type;
};
template <>
struct related_number<boost::multiprecision::cpp_dec_float_100>
{
   typedef boost::multiprecision::cpp_dec_float_50 type;
};*/

template <class Num>
void example1()
{
   // expected results first:
   Matrix<Num, 2, 2> r1, r2;
   r1 << 3, 5, 4, 8;
   r2 << -1, -1, 2, 0;
   Matrix<Num, 3, 1> r3;
   r3 << -1, -4, -6;

   Matrix<Num, 2, 2> a;
   a << 1, 2, 3, 4;
   Matrix<Num, Dynamic, Dynamic> b(2, 2);
   b << 2, 3, 1, 4;
   std::cout << "a + b =\n"
             << a + b << std::endl;
   BOOST_CHECK_EQUAL(a + b, r1);
   std::cout << "a - b =\n"
             << a - b << std::endl;
   BOOST_CHECK_EQUAL(a - b, r2);
   std::cout << "Doing a += b;" << std::endl;
   a += b;
   std::cout << "Now a =\n"
             << a << std::endl;
   Matrix<Num, 3, 1> v(1, 2, 3);
   Matrix<Num, 3, 1> w(1, 0, 0);
   std::cout << "-v + w - v =\n"
             << -v + w - v << std::endl;
   BOOST_CHECK_EQUAL(-v + w - v, r3);
}

template <class Num>
void example2()
{
   Matrix<Num, 2, 2> a;
   a << 1, 2, 3, 4;
   Matrix<Num, 3, 1> v(1, 2, 3);
   std::cout << "a * 2.5 =\n"
             << a * 2.5 << std::endl;
   std::cout << "0.1 * v =\n"
             << 0.1 * v << std::endl;
   std::cout << "Doing v *= 2;" << std::endl;
   v *= 2;
   std::cout << "Now v =\n"
             << v << std::endl;
   Num n(4);
   std::cout << "Doing v *= Num;" << std::endl;
   v *= n;
   std::cout << "Now v =\n"
             << v << std::endl;
   typedef typename related_number<Num>::type related_type;
   related_type                               r(6);
   std::cout << "Doing v *= RelatedType;" << std::endl;
   v *= r;
   std::cout << "Now v =\n"
             << v << std::endl;
   std::cout << "RelatedType * v =\n"
             << r * v << std::endl;
   std::cout << "Doing v *= RelatedType^2;" << std::endl;
   v *= r * r;
   std::cout << "Now v =\n"
             << v << std::endl;
   std::cout << "RelatedType^2 * v =\n"
             << r * r * v << std::endl;

   static_assert(std::is_same<typename Eigen::ScalarBinaryOpTraits<Num, related_type, Eigen::internal::scalar_product_op<Num, related_type> >::ReturnType, Num>::value, "Incorrect type.");
}

template <class Num>
void example3()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> a = Matrix<Num, Dynamic, Dynamic>::Random(2, 2);
   cout << "Here is the matrix a\n"
        << a << endl;
   cout << "Here is the matrix a^T\n"
        << a.transpose() << endl;
   cout << "Here is the conjugate of a\n"
        << a.conjugate() << endl;
   cout << "Here is the matrix a^*\n"
        << a.adjoint() << endl;
}

template <class Num>
void example4()
{
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   Matrix<Num, 2, 1> u(-1, 1), v(2, 0);
   std::cout << "Here is mat*mat:\n"
             << mat * mat << std::endl;
   std::cout << "Here is mat*u:\n"
             << mat * u << std::endl;
   std::cout << "Here is u^T*mat:\n"
             << u.transpose() * mat << std::endl;
   std::cout << "Here is u^T*v:\n"
             << u.transpose() * v << std::endl;
   std::cout << "Here is u*v^T:\n"
             << u * v.transpose() << std::endl;
   std::cout << "Let's multiply mat by itself" << std::endl;
   mat = mat * mat;
   std::cout << "Now mat is mat:\n"
             << mat << std::endl;
}

template <class Num>
void example5()
{
   using namespace std;
   Matrix<Num, 3, 1> v(1, 2, 3);
   Matrix<Num, 3, 1> w(0, 1, 2);
   cout << "Dot product: " << v.dot(w) << endl;
   Num dp = v.adjoint() * w; // automatic conversion of the inner product to a scalar
   cout << "Dot product via a matrix product: " << dp << endl;
   cout << "Cross product:\n"
        << v.cross(w) << endl;
}

template <class Num>
void example6()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;
}

template <class Num>
void example7()
{
   using namespace std;

   Array<Num, Dynamic, Dynamic> m(2, 2);

   // assign some values coefficient by coefficient
   m(0, 0) = 1.0;
   m(0, 1) = 2.0;
   m(1, 0) = 3.0;
   m(1, 1) = m(0, 1) + m(1, 0);

   // print values to standard output
   cout << m << endl
        << endl;

   // using the comma-initializer is also allowed
   m << 1.0, 2.0,
       3.0, 4.0;

   // print values to standard output
   cout << m << endl;
}

template <class Num>
void example8()
{
   using namespace std;
   Array<Num, Dynamic, Dynamic> a(3, 3);
   Array<Num, Dynamic, Dynamic> b(3, 3);
   a << 1, 2, 3,
       4, 5, 6,
       7, 8, 9;
   b << 1, 2, 3,
       1, 2, 3,
       1, 2, 3;

   // Adding two arrays
   cout << "a + b = " << endl
        << a + b << endl
        << endl;
   // Subtracting a scalar from an array
   cout << "a - 2 = " << endl
        << a - 2 << endl;
}

template <class Num>
void example9()
{
   using namespace std;
   Array<Num, Dynamic, Dynamic> a(2, 2);
   Array<Num, Dynamic, Dynamic> b(2, 2);
   a << 1, 2,
       3, 4;
   b << 5, 6,
       7, 8;
   cout << "a * b = " << endl
        << a * b << endl;
}

template <class Num>
void example10()
{
   using namespace std;
   Array<Num, Dynamic, 1> a = Array<Num, Dynamic, 1>::Random(5);
   a *= 2;
   cout << "a =" << endl
        << a << endl;
   cout << "a.abs() =" << endl
        << a.abs() << endl;
   cout << "a.abs().sqrt() =" << endl
        << a.abs().sqrt() << endl;
   cout << "a.min(a.abs().sqrt()) =" << endl
        << (a.min)(a.abs().sqrt()) << endl;
}

template <class Num>
void example11()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(2, 2);
   Matrix<Num, Dynamic, Dynamic> n(2, 2);
   Matrix<Num, Dynamic, Dynamic> result(2, 2);
   m << 1, 2,
       3, 4;
   n << 5, 6,
       7, 8;
   result = m * n;
   cout << "-- Matrix m*n: --" << endl
        << result << endl
        << endl;
   result = m.array() * n.array();
   cout << "-- Array m*n: --" << endl
        << result << endl
        << endl;
   result = m.cwiseProduct(n);
   cout << "-- With cwiseProduct: --" << endl
        << result << endl
        << endl;
   result = m.array() + 4;
   cout << "-- Array m + 4: --" << endl
        << result << endl
        << endl;
}

template <class Num>
void example12()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(2, 2);
   Matrix<Num, Dynamic, Dynamic> n(2, 2);
   Matrix<Num, Dynamic, Dynamic> result(2, 2);
   m << 1, 2,
       3, 4;
   n << 5, 6,
       7, 8;

   result = (m.array() + 4).matrix() * m;
   cout << "-- Combination 1: --" << endl
        << result << endl
        << endl;
   result = (m.array() * n.array()).matrix() * m;
   cout << "-- Combination 2: --" << endl
        << result << endl
        << endl;
}

template <class Num>
void example13()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> m(4, 4);
   m << 1, 2, 3, 4,
       5, 6, 7, 8,
       9, 10, 11, 12,
       13, 14, 15, 16;
   cout << "Block in the middle" << endl;
   cout << m.template block<2, 2>(1, 1) << endl
        << endl;
   for (int i = 1; i <= 3; ++i)
   {
      cout << "Block of size " << i << "x" << i << endl;
      cout << m.block(0, 0, i, i) << endl
           << endl;
   }
}

template <class Num>
void example14()
{
   using namespace std;
   Array<Num, 2, 2> m;
   m << 1, 2,
       3, 4;
   Array<Num, 4, 4> a = Array<Num, 4, 4>::Constant(0.6);
   cout << "Here is the array a:" << endl
        << a << endl
        << endl;
   a.template block<2, 2>(1, 1) = m;
   cout << "Here is now a with m copied into its central 2x2 block:" << endl
        << a << endl
        << endl;
   a.block(0, 0, 2, 3) = a.block(2, 1, 2, 3);
   cout << "Here is now a with bottom-right 2x3 block copied into top-left 2x2 block:" << endl
        << a << endl
        << endl;
}

template <class Num>
void example15()
{
   using namespace std;
   Eigen::Matrix<Num, Dynamic, Dynamic> m(3, 3);
   m << 1, 2, 3,
       4, 5, 6,
       7, 8, 9;
   cout << "Here is the matrix m:" << endl
        << m << endl;
   cout << "2nd Row: " << m.row(1) << endl;
   m.col(2) += 3 * m.col(0);
   cout << "After adding 3 times the first column into the third column, the matrix m is:\n";
   cout << m << endl;
}

template <class Num>
void example16()
{
   using namespace std;
   Matrix<Num, 4, 4> m;
   m << 1, 2, 3, 4,
       5, 6, 7, 8,
       9, 10, 11, 12,
       13, 14, 15, 16;
   cout << "m.leftCols(2) =" << endl
        << m.leftCols(2) << endl
        << endl;
   cout << "m.bottomRows<2>() =" << endl
        << m.template bottomRows<2>() << endl
        << endl;
   m.topLeftCorner(1, 3) = m.bottomRightCorner(3, 1).transpose();
   cout << "After assignment, m = " << endl
        << m << endl;
}

template <class Num>
void example17()
{
   using namespace std;
   Array<Num, Dynamic, 1> v(6);
   v << 1, 2, 3, 4, 5, 6;
   cout << "v.head(3) =" << endl
        << v.head(3) << endl
        << endl;
   cout << "v.tail<3>() = " << endl
        << v.template tail<3>() << endl
        << endl;
   v.segment(1, 4) *= 2;
   cout << "after 'v.segment(1,4) *= 2', v =" << endl
        << v << endl;
}

template <class Num>
void example18()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;

   BOOST_CHECK_EQUAL(mat.sum(), 10);
   BOOST_CHECK_EQUAL(mat.prod(), 24);
   BOOST_CHECK_EQUAL(mat.mean(), Num(5) / 2);
   BOOST_CHECK_EQUAL(mat.minCoeff(), 1);
   BOOST_CHECK_EQUAL(mat.maxCoeff(), 4);
   BOOST_CHECK_EQUAL(mat.trace(), 5);
}

template <class Num>
void example18a()
{
   using namespace std;
   Matrix<Num, 2, 2> mat;
   mat << 1, 2,
       3, 4;
   cout << "Here is mat.sum():       " << mat.sum() << endl;
   cout << "Here is mat.prod():      " << mat.prod() << endl;
   cout << "Here is mat.mean():      " << mat.mean() << endl;
   //cout << "Here is mat.minCoeff():  " << mat.minCoeff() << endl;
   //cout << "Here is mat.maxCoeff():  " << mat.maxCoeff() << endl;
   cout << "Here is mat.trace():     " << mat.trace() << endl;
}

template <class Num>
void example19()
{
   using namespace std;
   Matrix<Num, Dynamic, 1>       v(2);
   Matrix<Num, Dynamic, Dynamic> m(2, 2), n(2, 2);

   v << -1,
       2;

   m << 1, -2,
       -3, 4;
   cout << "v.squaredNorm() = " << v.squaredNorm() << endl;
   cout << "v.norm() = " << v.norm() << endl;
   cout << "v.lpNorm<1>() = " << v.template lpNorm<1>() << endl;
   cout << "v.lpNorm<Infinity>() = " << v.template lpNorm<Infinity>() << endl;
   cout << endl;
   cout << "m.squaredNorm() = " << m.squaredNorm() << endl;
   cout << "m.norm() = " << m.norm() << endl;
   cout << "m.lpNorm<1>() = " << m.template lpNorm<1>() << endl;
   cout << "m.lpNorm<Infinity>() = " << m.template lpNorm<Infinity>() << endl;
}

template <class Num>
void example20()
{
   using namespace std;
   Matrix<Num, 3, 3> A;
   Matrix<Num, 3, 1> b;
   A << 1, 2, 3, 4, 5, 6, 7, 8, 10;
   b << 3, 3, 4;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "Here is the vector b:\n"
        << b << endl;
   Matrix<Num, 3, 1> x = A.colPivHouseholderQr().solve(b);
   cout << "The solution is:\n"
        << x << endl;
}

template <class Num>
void example21()
{
   using namespace std;
   Matrix<Num, 2, 2> A, b;
   A << 2, -1, -1, 3;
   b << 1, 2, 3, 1;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "Here is the right hand side b:\n"
        << b << endl;
   Matrix<Num, 2, 2> x = A.ldlt().solve(b);
   cout << "The solution is:\n"
        << x << endl;
}

template <class Num>
void example22()
{
   using namespace std;
   Matrix<Num, Dynamic, Dynamic> A              = Matrix<Num, Dynamic, Dynamic>::Random(100, 100);
   Matrix<Num, Dynamic, Dynamic> b              = Matrix<Num, Dynamic, Dynamic>::Random(100, 50);
   Matrix<Num, Dynamic, Dynamic> x              = A.fullPivLu().solve(b);
   Matrix<Num, Dynamic, Dynamic> axmb           = A * x - b;
   double                        relative_error = static_cast<double>(abs(axmb.norm() / b.norm())); // norm() is L2 norm
   cout << "norm1 = " << axmb.norm() << endl;
   cout << "norm2 = " << b.norm() << endl;
   cout << "The relative error is:\n"
        << relative_error << endl;
}

template <class Num>
void example23()
{
   using namespace std;
   Matrix<Num, 2, 2> A;
   A << 1, 2, 2, 3;
   cout << "Here is the matrix A:\n"
        << A << endl;
   SelfAdjointEigenSolver<Matrix<Num, 2, 2> > eigensolver(A);
   if (eigensolver.info() != Success)
   {
      std::cout << "Eigenvalue solver failed!" << endl;
   }
   else
   {
      cout << "The eigenvalues of A are:\n"
           << eigensolver.eigenvalues() << endl;
      cout << "Here's a matrix whose columns are eigenvectors of A \n"
           << "corresponding to these eigenvalues:\n"
           << eigensolver.eigenvectors() << endl;
   }
}

template <class Num>
void example24()
{
   using namespace std;
   Matrix<Num, 3, 3> A;
   A << 1, 2, 1,
       2, 1, 0,
       -1, 1, 2;
   cout << "Here is the matrix A:\n"
        << A << endl;
   cout << "The determinant of A is " << A.determinant() << endl;
   cout << "The inverse of A is:\n"
        << A.inverse() << endl;
}

template <class Num>
void test_integer_type()
{
   example1<Num>();
   //example2<Num>();
   example18<Num>();
}

template <class Num>
void test_float_type()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example1<Num>();
   example2<Num>();
   example4<Num>();
   example5<Num>();
   example6<Num>();
   example7<Num>();
   example8<Num>();
   example9<Num>();
   example10<Num>();
   example11<Num>();
   example12<Num>();
   example13<Num>();
   example14<Num>();
   example15<Num>();
   example16<Num>();
   example17<Num>();
   example18<Num>();
   example19<Num>();
   example20<Num>();
   example21<Num>();
   example22<Num>();
   example23<Num>();
   example24<Num>();
}

template <class Num>
void test_complex_type()
{
   std::cout << "Epsilon    = " << Eigen::NumTraits<Num>::epsilon() << std::endl;
   std::cout << "Dummy Prec = " << Eigen::NumTraits<Num>::dummy_precision() << std::endl;
   std::cout << "Highest    = " << Eigen::NumTraits<Num>::highest() << std::endl;
   std::cout << "Lowest     = " << Eigen::NumTraits<Num>::lowest() << std::endl;
   std::cout << "Digits10   = " << Eigen::NumTraits<Num>::digits10() << std::endl;

   example1<Num>();
   example2<Num>();
   example3<Num>();
   example4<Num>();
   example5<Num>();
   example7<Num>();
   example8<Num>();
   example9<Num>();
   example11<Num>();
   example12<Num>();
   example13<Num>();
   example14<Num>();
   example15<Num>();
   example16<Num>();
   example17<Num>();
   example18a<Num>();
   example19<Num>();
   example20<Num>();
   example21<Num>();
   example22<Num>();
   // example23<Num>();  //requires comparisons.
   example24<Num>();
}

namespace boost {
namespace multiprecision {

template <unsigned D>
inline void log_postfix_event(const mpc_complex_backend<D>& val, const char* event_description)
{
   if (mpfr_nan_p(mpc_realref(val.data())))
   {
      std::cout << "Found a NaN! " << event_description << std::endl;
   }
}

}
} // namespace boost::multiprecision

int main()
{
   using namespace boost::multiprecision;
   test_complex_type<mpc_complex>();
#if 0
   test_integer_type<int>();

   test_float_type<double>();
   test_complex_type<std::complex<double> >();

   test_float_type<boost::multiprecision::cpp_dec_float_100>();
   test_float_type<boost::multiprecision::cpp_bin_float_50>();
   test_float_type<boost::multiprecision::mpfr_float>();

   test_integer_type<boost::multiprecision::int256_t>();
   test_integer_type<boost::multiprecision::cpp_int>();
   test_integer_type<boost::multiprecision::cpp_rational>();
   test_integer_type<boost::multiprecision::mpz_int>();
   test_integer_type<boost::multiprecision::mpq_rational>();

#endif
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_bin_float_1.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type<double>();
   test_float_type<boost::multiprecision::cpp_bin_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_bin_float_2.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_2<double>();
   test_float_type_2<boost::multiprecision::cpp_bin_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_bin_float_3.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_3<double>();
   test_float_type_3<boost::multiprecision::cpp_bin_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_dec_float.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "eigen.hpp"

template <>
struct related_number<boost::multiprecision::cpp_dec_float_100>
{
   typedef boost::multiprecision::cpp_dec_float_50 type;
};

int main()
{
   using namespace boost::multiprecision;
   test_float_type<double>();
   test_float_type<boost::multiprecision::cpp_dec_float_100>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_dec_float_2.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "eigen.hpp"

template <>
struct related_number<boost::multiprecision::cpp_dec_float_100>
{
   typedef boost::multiprecision::cpp_dec_float_50 type;
};

int main()
{
   using namespace boost::multiprecision;
   //test_float_type_2<double>();
   test_float_type_2<boost::multiprecision::cpp_dec_float_100>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_dec_float_3.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>

#include "eigen.hpp"

template <>
struct related_number<boost::multiprecision::cpp_dec_float_100>
{
   typedef boost::multiprecision::cpp_dec_float_50 type;
};

int main()
{
   using namespace boost::multiprecision;
   //test_float_type_2<double>();
   test_float_type_3<boost::multiprecision::cpp_dec_float_100>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_integer_type<int>();
   test_integer_type<boost::multiprecision::int256_t>();
   test_integer_type<boost::multiprecision::cpp_int>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_gmp.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/gmp.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_integer_type<boost::multiprecision::mpz_int>();
   test_integer_type<boost::multiprecision::mpq_rational>();

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_gmp_2.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/gmp.hpp>

#include "eigen.hpp"

int main()
{
   test_float_type<boost::multiprecision::mpf_float_50>();
   test_float_type<boost::multiprecision::mpf_float>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpc.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpc.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_complex_type<mpc_complex>();
   test_complex_type<mpc_complex_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_1.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type<boost::multiprecision::mpfr_float>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_2.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_2<boost::multiprecision::mpfr_float>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_3.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_3<boost::multiprecision::mpfr_float>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_4.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type<boost::multiprecision::mpfr_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_5.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_2<boost::multiprecision::mpfr_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_eigen_interop_mpfr_6.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2018 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>

#include "eigen.hpp"

int main()
{
   using namespace boost::multiprecision;
   test_float_type_3<boost::multiprecision::mpfr_float_50>();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_exp.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#pragma warning(disable : 4127)
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 51u> data =
       {{
           "1.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
           "9.47747587596218770242116751705184563668845029215054154915126374673142219159548534317576897266130328412495991561490384353e76",
           "8.98225489794452370997623936390755615068333094834545092387689795875746440121970819499035111276893290879203289092353747850e153",
           "8.51291041070124257524798251795398355552294928156627848633073113916721592074889256105483993631579761345100284245144410506e230",
           "8.06809030516483860484254925989129017112482132468761563276276594763374886826841745433660192438855214332469192411759402790e307",
           "7.64651312322841630493169711336894888932951818957138997327518186691187347879142222644283389432604713409023263917264358401e384",
           "7.24696436606255985380192585665173794455118215150711210905481870053193336336731228464367470327868286988180495111406609690e461",
           "6.86829299533155197480610865771404565313986987801060270120621935139741577246731459024227828759564450034267891072352816870e538",
           "6.50940811722948585242669672360741252715012399316164518226061001845519670701239429603657927628755169479689062519606799624e615",
           "6.16927583978348964454665652571294215251327375137123272041877979478545511090085756858225302357977159539777447847855503405e692",
           "5.84691629437043896753869572004324228849833391140408095171257918435296982661233664069534601413835876272500275725690968474e769",
           "5.54140081286660645835370762406928689330724181979654545550204201113926269281603301564114980528619942840737770415885783439e846",
           "5.25184925229805200184933663459660562493261505058724212670923083643709964294855282715531768162298567379648573804433968486e923",
           "4.97742745928448409225535325233998957076879979440190164347796593390995994951755710667491911026476108957070504003155645761e1000",
           "4.71734486697204622371883518659702954552385115723942808636490157561056417525827884479573988899517566587636669779645610803e1077",
           "4.47085221753216236037602345430121605512330975424643767098987010800161616413051148037751552110081034066081309007796182114e1154",
           "4.23723940366531198300986713567588008777043812458400705569721660157434941774066620870256745107265536124077734836797938268e1231",
           "4.01583342289144005397455901781647949754375366066998182220342540048111140676724909947493787596336610499122085983712119281e1308",
           "3.80599643873362813900306284477369187319506389058898599816705625750135796510808933786432614186155972485637939057212164098e1385",
           "3.60712394320959592074309301816510372687695286650188776957291994751966018917404878612237961367128638199290387601511358836e1462",
           "3.41864301533745457066062991907289263038319874930395315315257927161138360206596116102724713069518697248463965164712972907e1539",
           "3.24001067063873569456703204286462007769933831045558617578289414699244767403736057931834775727420762410328297596596814910e1616",
           "3.07071229688386868087623659761166306563170839771162347830514606977592027644137144160294469813988158463967740978461420862e1693",
           "2.91026017157373047094077218552378456052150304677863670611408570458991015300131731261787644801415538043027268185097710615e1770",
           "2.75819205688636078700279174380111581147323147951670302427494196210176478494486073721584055059489736040565979466551070179e1847",
           "2.61406986804110104534167739704643351039975992759905579635058824027507742375380077276380178376470686987855503581867681046e1924",
           "2.47747841124391945459619002346303925269640785743990333362087223895627681769816204236257960940497519376881830373722711456e2001",
           "2.34802418757813746316913800667907927718925648696508255347624141597281474683823345136640610924639820192825966082309575303e2078",
           "2.22533425939475124828943430510333464605535146852848680647615867629953075390889821397228584866395924176189346073006180260e2155",
           "2.10905517593659363154553947631071808925462553114068144748077359132255993441363479041540672158497404660986163617828972963e2232",
           "1.99885195510122536266653916064141606295420554580140619900425370702471778604391774578696867899999534265169574306808906810e2309",
           "1.89440711840917173277691572886942144916664047407963356271198286654087884646102070148271284410118233470318337745546895603e2386",
           "1.79541977639739687088375911648976940254141946934175300605485966288703931992861387257771264702798405630917098672594899744e2463",
           "1.70160476180317540861346545791118106171203487587101437710693054174454895160403997508137760007058856854991413121389834429e2540",
           "1.61269180804119796097157014527479883521656118500417752963675677684343588976915851637637232001139108420659882326614772004e2617",
           "1.52842477060722969066998464046690349841548269556677423378408183476489015878816585045578141383463708674469365281537792914e2694",
           "1.44856088916530600122626623629347336702026699647293500058111037526381692645547938577338582002157148103479049071921438452e2771",
           "1.37287008819265239873777879432333192404914357037749380145412895230166352318128978403808382142784030558123748263528360645e2848",
           "1.30113431416759441771790128053911040907207490879890145597562380328956450092799014856149474809345424672958343296615764490e2925",
           "1.23314690739099822369963411660419632130352733806319401863570442920347696015409870236230656305563674376063778482449716744e3002",
           "1.16871200663155636468514484039368694043851858077879103221831997264419096417014996945143145495038265243932745953706526253e3079",
           "1.10764398487979357804590117089134596938734185016144401218934115168561552640448889215089150481162977776214124397487013110e3156",
           "1.04976691458528698318220729857405616816444374000182094405930946710168752954926612218474430081526312018810817657409158490e3233",
           "9.94914060836531582868347569174220216007647278536863127198023584205669825317884219144692385409156165042162234017403353704e3309",
           "9.42927401023380446961314339401657458785389811652244742482194123119943160577946366372207045050095290781679375214307398844e3386",
           "8.93657169598281164656322298275337750103095739790107943666668184304335665562867744740310577868880098719252549186849812451e3463",
           "8.46961426624835911826517103631490619655296714141872141145089865045804196205328364155921945616925875458926717336478525196e3540",
           "8.02705648870740089929294815816002943860908317454595055392168733404583122074223427054310572378841634984243492063192095337e3617",
           "7.60762342267101369970765191988545810374824800500875923752736467467657167098026707905341603949108433696304383346239333297e3694",
           "7.21010674617694221027190468649359000420209460539838589305387835463807416706224777302997789297329446308541513638035437482e3771",
           "6.83336127500041943234365059231968669406267422759442985746460610830503287734479988530512309065240678799786759250323660701e3848",
       }};

   T pi = static_cast<T>("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = exp(sqrt((pi * (100 * k)) * (100 * k)));
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = exp(-sqrt((pi * (100 * k)) * (100 * k)));
      e   = relative_error(val, T(1 / T(data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
#if defined(BOOST_INTEL) && defined(TEST_FLOAT128)
   BOOST_TEST(max_err < 40000);
#elif defined(TEST_CPP_BIN_FLOAT)
   BOOST_TEST(max_err < 6200);
#else
   BOOST_TEST(max_err < 5000);
#endif

   static const boost::array<boost::array<T, 2>, 12> exact_data =
       {{
           {{std::ldexp(1.0, -50), static_cast<T>("1.00000000000000088817841970012562676935794497867573073630970950828771105957980924149923657574337470594698012676100224953")}},
           {{std::ldexp(1.0, -20), static_cast<T>("1.00000095367477115374544678824955687428365188553281789775169686343569285229334215539516690752571791280462887427635269562")}},
           {{std::ldexp(1.0, -10), static_cast<T>("1.00097703949241653524284529261160650646585162918174419940186408264916250428896869173656853690882467186075613761065459261")}},
           {{0.25, static_cast<T>("1.28402541668774148407342056806243645833628086528146308921750729687220776586723800275330641943955356890166283174967968731")}},
           {{0.5, static_cast<T>("1.64872127070012814684865078781416357165377610071014801157507931164066102119421560863277652005636664300286663775630779700")}},
           {{0.75, static_cast<T>("2.11700001661267466854536981983709561013449158470240342177913303081098453336401282000279156026661579821888590471901551426")}},
           {{10, static_cast<T>("22026.4657948067165169579006452842443663535126185567810742354263552252028185707925751991209681645258954515555010924578367")}},
           {{10.5, static_cast<T>("36315.5026742466377389120269013166179689315579671275857607480190550842856628099187749764427758174866310742771977376827512")}},
           {{25, static_cast<T>("7.20048993373858725241613514661261579152235338133952787362213864472320593107782569745000325654258093194727871848859163684e10")}},
           {{31.25, static_cast<T>("3.72994612957188849046766396046821396700589012875701157893019118883826370993674081486706667149871508642909416337810227575e13")}},
           {{static_cast<T>("65.8489821531948043946370515385267739671725127642242491414646009018723940871209979825570160646597753164901406969542"), static_cast<T>("39614081257132168796771975168.0")}},
           {{static_cast<T>("65.15583497263485908521981941706859739909701262986399388734392089237900046515130326695115273766335662894813921593"), static_cast<T>("19807040628566084398385987584.0")}},
       }};

   max_err = 0;
   for (unsigned k = 0; k < exact_data.size(); k++)
   {
      T        val = exp(exact_data[k][0]);
      T        e   = relative_error(val, exact_data[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = exp(-exact_data[k][0]);
      e   = relative_error(val, T(1 / exact_data[k][1]));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 60);

   BOOST_TEST(exp(T(0)) == 1);

   if (!boost::multiprecision::is_interval_number<T>::value)
   {
      T bug_case = -1.05 * log((std::numeric_limits<T>::max)());
      for (unsigned i = 0; bug_case > -20 / std::numeric_limits<T>::epsilon(); ++i, bug_case *= 1.05)
      {
         if (std::numeric_limits<T>::has_infinity)
         {
            BOOST_CHECK_EQUAL(exp(bug_case), 0);
         }
         else
         {
            BOOST_CHECK_LE(exp(bug_case), (std::numeric_limits<T>::min)());
         }
      }
      bug_case = log((std::numeric_limits<T>::max)()) / -1.0005;
      for (unsigned i = 0; i < 20; ++i, bug_case /= 1.05)
      {
         BOOST_CHECK_GE(exp(bug_case), (std::numeric_limits<T>::min)());
      }
   }
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPILER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_fixed_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/fixed_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

int main()
{
   using namespace boost::multiprecision;
   typedef number<fixed_int<1024, true> > packed_type;
   unsigned                               last_error_count = 0;
   for (int i = 0; i < 1000; ++i)
   {
      mpz_int a = generate_random<mpz_int>(1000);
      mpz_int b = generate_random<mpz_int>(512);
      mpz_int c = generate_random<mpz_int>(256);
      mpz_int d = generate_random<mpz_int>(32);

      int si = d.convert_to<int>();

      packed_type a1 = a.str();
      packed_type b1 = b.str();
      packed_type c1 = c.str();
      packed_type d1 = d.str();

      BOOST_CHECK_EQUAL(a.str(), a1.str());
      BOOST_CHECK_EQUAL(b.str(), b1.str());
      BOOST_CHECK_EQUAL(c.str(), c1.str());
      BOOST_CHECK_EQUAL(d.str(), d1.str());
      BOOST_CHECK_EQUAL(mpz_int(a + b).str(), packed_type(a1 + b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a - b).str(), packed_type(a1 - b1).str());
      BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) + b).str(), packed_type(packed_type(-a1) + b1).str());
      BOOST_CHECK_EQUAL(mpz_int(mpz_int(-a) - b).str(), packed_type(packed_type(-a1) - b1).str());
      BOOST_CHECK_EQUAL(mpz_int(c * d).str(), packed_type(c1 * d1).str());
      BOOST_CHECK_EQUAL(mpz_int(c * -d).str(), packed_type(c1 * -d1).str());
      BOOST_CHECK_EQUAL(mpz_int(-c * d).str(), packed_type(-c1 * d1).str());
      BOOST_CHECK_EQUAL(mpz_int(b * c).str(), packed_type(b1 * c1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / b).str(), packed_type(a1 / b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / -b).str(), packed_type(a1 / -b1).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / b).str(), packed_type(-a1 / b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / d).str(), packed_type(a1 / d1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % b).str(), packed_type(a1 % b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % -b).str(), packed_type(a1 % -b1).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % b).str(), packed_type(-a1 % b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a % d).str(), packed_type(a1 % d1).str());
      // bitwise ops:
      BOOST_CHECK_EQUAL(mpz_int(a | b).str(), packed_type(a1 | b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a & b).str(), packed_type(a1 & b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a ^ b).str(), packed_type(a1 ^ b1).str());
      // Now check operations involving integers:
      BOOST_CHECK_EQUAL(mpz_int(a + si).str(), packed_type(a1 + si).str());
      BOOST_CHECK_EQUAL(mpz_int(a + -si).str(), packed_type(a1 + -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a + si).str(), packed_type(-a1 + si).str());
      BOOST_CHECK_EQUAL(mpz_int(si + a).str(), packed_type(si + a1).str());
      BOOST_CHECK_EQUAL(mpz_int(a - si).str(), packed_type(a1 - si).str());
      BOOST_CHECK_EQUAL(mpz_int(a - -si).str(), packed_type(a1 - -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a - si).str(), packed_type(-a1 - si).str());
      BOOST_CHECK_EQUAL(mpz_int(si - a).str(), packed_type(si - a1).str());
      BOOST_CHECK_EQUAL(mpz_int(b * si).str(), packed_type(b1 * si).str());
      BOOST_CHECK_EQUAL(mpz_int(b * -si).str(), packed_type(b1 * -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-b * si).str(), packed_type(-b1 * si).str());
      BOOST_CHECK_EQUAL(mpz_int(si * b).str(), packed_type(si * b1).str());
      BOOST_CHECK_EQUAL(mpz_int(a / si).str(), packed_type(a1 / si).str());
      BOOST_CHECK_EQUAL(mpz_int(a / -si).str(), packed_type(a1 / -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a / si).str(), packed_type(-a1 / si).str());
      BOOST_CHECK_EQUAL(mpz_int(a % si).str(), packed_type(a1 % si).str());
      BOOST_CHECK_EQUAL(mpz_int(a % -si).str(), packed_type(a1 % -si).str());
      BOOST_CHECK_EQUAL(mpz_int(-a % si).str(), packed_type(-a1 % si).str());
      BOOST_CHECK_EQUAL(mpz_int(a | si).str(), packed_type(a1 | si).str());
      BOOST_CHECK_EQUAL(mpz_int(a & si).str(), packed_type(a1 & si).str());
      BOOST_CHECK_EQUAL(mpz_int(a ^ si).str(), packed_type(a1 ^ si).str());
      BOOST_CHECK_EQUAL(mpz_int(si | a).str(), packed_type(si | a1).str());
      BOOST_CHECK_EQUAL(mpz_int(si & a).str(), packed_type(si & a1).str());
      BOOST_CHECK_EQUAL(mpz_int(si ^ a).str(), packed_type(si ^ a1).str());
      BOOST_CHECK_EQUAL(mpz_int(gcd(a, b)).str(), packed_type(gcd(a1, b1)).str());
      BOOST_CHECK_EQUAL(mpz_int(lcm(c, d)).str(), packed_type(lcm(c1, d1)).str());

      if (last_error_count != boost::detail::test_errors())
      {
         last_error_count = boost::detail::test_errors();
         std::cout << std::hex << std::showbase;

         std::cout << "a    = " << a << std::endl;
         std::cout << "a1   = " << a1 << std::endl;
         std::cout << "b    = " << b << std::endl;
         std::cout << "b1   = " << b1 << std::endl;
         std::cout << "c    = " << c << std::endl;
         std::cout << "c1   = " << c1 << std::endl;
         std::cout << "d    = " << d << std::endl;
         std::cout << "d1   = " << d1 << std::endl;
         std::cout << "a + b   = " << a + b << std::endl;
         std::cout << "a1 + b1 = " << a1 + b1 << std::endl;
         std::cout << std::dec;
         std::cout << "a - b   = " << a - b << std::endl;
         std::cout << "a1 - b1 = " << a1 - b1 << std::endl;
         std::cout << "-a + b   = " << mpz_int(-a) + b << std::endl;
         std::cout << "-a1 + b1 = " << packed_type(-a1) + b1 << std::endl;
         std::cout << "-a - b   = " << mpz_int(-a) - b << std::endl;
         std::cout << "-a1 - b1 = " << packed_type(-a1) - b1 << std::endl;
         std::cout << "c*d    = " << c * d << std::endl;
         std::cout << "c1*d1  = " << c1 * d1 << std::endl;
         std::cout << "b*c    = " << b * c << std::endl;
         std::cout << "b1*c1  = " << b1 * c1 << std::endl;
         std::cout << "a/b    = " << a / b << std::endl;
         std::cout << "a1/b1  = " << a1 / b1 << std::endl;
         std::cout << "a/d    = " << a / d << std::endl;
         std::cout << "a1/d1  = " << a1 / d1 << std::endl;
         std::cout << "a%b    = " << a % b << std::endl;
         std::cout << "a1%b1  = " << a1 % b1 << std::endl;
         std::cout << "a%d    = " << a % d << std::endl;
         std::cout << "a1%d1  = " << a1 % d1 << std::endl;
      }
   }
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_fixed_zero_precision_io.cpp
================================================
// Copyright John Maddock 2022.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif
#define BOOST_CHRONO_HEADER_ONLY

#ifdef TEST_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPF
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/chrono.hpp>
#include "test.hpp"
#include <boost/array.hpp>
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

#if defined(TEST_MPF)
template <unsigned N, boost::multiprecision::expression_template_option ET>
bool has_bad_bankers_rounding(const boost::multiprecision::number<boost::multiprecision::gmp_float<N>, ET>&)
{
   return true;
}
#endif
template <class T>
bool has_bad_bankers_rounding(const T&)
{
   return false;
}

bool is_bankers_rounding_error(const std::string& s, const std::string& expect)
{
   // This check isn't foolproof: that would require *much* more sophisticated code!!!
   std::string::size_type l = expect.size();
   if (l != s.size())
      return false;
   std::string::size_type len = s.find('e');
   if (len == std::string::npos)
      len = l - 1;
   else
      --len;
   for (unsigned i = 0; i < len; ++i)
   {
      char c1 = s[i];
      char c2 = expect[i];
      if (c1 != c2)
         return false;
   }
   if (s[len] != expect[len] + 1)
      return false;
   return true;
}

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

template <class T>
struct exponent_type
{
   typedef int type;
};
template <class T, boost::multiprecision::expression_template_option ET>
struct exponent_type<boost::multiprecision::number<T, ET> >
{
   typedef typename T::exponent_type type;
};

template <class T>
T generate_random_float()
{
   BOOST_MATH_STD_USING
   typedef typename exponent_type<T>::type e_type;
   static boost::random::mt19937           gen;
   T                                       val      = gen();
   T                                       prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static const int                                       max_exponent_value = (std::min)(static_cast<int>(std::numeric_limits<T>::max_exponent - std::numeric_limits<T>::digits - 20), 40);
   static boost::random::uniform_int_distribution<e_type> ui(0, max_exponent_value);
   return ldexp(val, ui(gen));
}

template <class Float>
void test_fixed_io()
{
   std::cout << "Testing type " << typeid(Float).name() << std::endl;
   std::cout << "digits = " << std::numeric_limits<Float>::digits << std::endl;
   std::cout << "digits10 = " << std::numeric_limits<Float>::digits10 << std::endl;
   std::cout << "max_digits10 = " << std::numeric_limits<Float>::max_digits10 << std::endl;

   stopwatch<boost::chrono::high_resolution_clock> w;

   int count = 0;

#ifndef CI_SUPPRESS_KNOWN_ISSUES
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 200)
#else
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 50)
#endif
   {
      double val = generate_random_float<double>();
      Float  f(val);
#ifdef BOOST_MSVC
      if (val > 0.5 && val < 1)
         val = 1;
#endif
      std::stringstream ss1, ss2;
      ss1 << std::fixed << std::setprecision(0) << val;
      ss2 << std::fixed << std::setprecision(0) << f;
      if (ss1.str() != ss2.str())
      {
         if (has_bad_bankers_rounding(Float()) && is_bankers_rounding_error(ss2.str(), ss1.str()))
         {
            std::cout << "Ignoring bankers-rounding error with GMP mp_f.\n";
         }
         else
         {
            std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
            std::cout << "Got:      " << ss2.str() << std::endl;
            std::cout << "Expected: " << ss1.str() << std::endl;
            ++boost::detail::test_errors();
            Float(val).str(0, std::ios_base::fixed);
         }
      }
      ++count;
      if (boost::detail::test_errors() > 100)
         break;
   }

   std::cout << "Execution time = " << boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() << "s" << std::endl;
   std::cout << "Total values tested: " << count << std::endl;
}


int main()
{
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1920)
   std::cout << "MSVC prior to 14.2 does not perform bankers rounding for double IO, as a result all our test cases are incorrect, so there's nothing we can productively test here." << std::endl;
#else
   using namespace boost::multiprecision;
#ifdef TEST_BIN_FLOAT
   test_fixed_io<number<cpp_bin_float<113, digit_base_2, void, std::int16_t> > >();
#endif
#ifdef TEST_DEC_FLOAT
   test_fixed_io<cpp_dec_float_50>();
#endif
#ifdef TEST_MPFR
   test_fixed_io<boost::multiprecision::mpfr_float_50>();
#endif
#ifdef TEST_MPF
   test_fixed_io<boost::multiprecision::mpf_float_50>();
#endif
#ifdef TEST_FLOAT128
   test_fixed_io<boost::multiprecision::float128>();
#endif
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_float128_serial.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/float128.hpp>
#include "test_float_serial.hpp"

int main()
{
   using namespace boost::multiprecision;
   test<float128>();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_float_conversions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/math/constants/constants.hpp>

int main()
{
   using namespace boost::multiprecision;

   static_assert((std::is_convertible<float, cpp_bin_float_single>::value), "Error check");
   static_assert(!(std::is_convertible<double, cpp_bin_float_single>::value), "Error check");
   static_assert(!(std::is_convertible<long double, cpp_bin_float_single>::value), "Error check");

   cpp_bin_float_single s = boost::math::constants::pi<cpp_bin_float_single>();
   std::cout << s << std::endl;

   typedef number<backends::cpp_bin_float<11, backends::digit_base_2, void, boost::int8_t, -14, 15>, et_off> cpp_bin_float_half;

   static_assert(!(std::is_convertible<float, cpp_bin_float_half>::value), "Error check");
   static_assert(!(std::is_convertible<double, cpp_bin_float_half>::value), "Error check");
   static_assert(!(std::is_convertible<long double, cpp_bin_float_half>::value), "Error check");
#ifdef BOOST_HAS_FLOAT128
   static_assert(!(std::is_convertible<__float128, cpp_bin_float_half>::value), "Error check");
#endif

   cpp_bin_float_half hs = boost::math::constants::pi<cpp_bin_float_half>();
   std::cout << hs << std::endl;

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_float_io.cpp
================================================
// Copyright John Maddock 2011.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_MPF_50) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128)
#define TEST_MPF_50
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_FLOAT128

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"
#include <boost/array.hpp>
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

#if defined(TEST_MPF_50)
template <unsigned N, boost::multiprecision::expression_template_option ET>
bool has_bad_bankers_rounding(const boost::multiprecision::number<boost::multiprecision::gmp_float<N>, ET>&)
{
   return true;
}
#endif
#if defined(TEST_FLOAT128) && defined(BOOST_INTEL)
bool has_bad_bankers_rounding(const boost::multiprecision::float128&)
{
   return true;
}
#endif
template <class T>
bool has_bad_bankers_rounding(const T&)
{
   return false;
}

bool is_bankers_rounding_error(const std::string& s, const char* expect)
{
   // This check isn't foolproof: that would require *much* more sophisticated code!!!
   std::string::size_type l = std::strlen(expect);
   if (l != s.size())
      return false;
   std::string::size_type len = s.find('e');
   if (len == std::string::npos)
      len = l - 1;
   else
      --len;
   if (s.compare(0, len, expect, len))
      return false;
   if (s[len] != expect[len] + 1)
      return false;
   return true;
}

void print_flags(std::ios_base::fmtflags f)
{
   std::cout << "Formatting flags were: ";
   if (f & std::ios_base::scientific)
      std::cout << "scientific ";
   if (f & std::ios_base::fixed)
      std::cout << "fixed ";
   if (f & std::ios_base::showpoint)
      std::cout << "showpoint ";
   if (f & std::ios_base::showpos)
      std::cout << "showpos ";
   std::cout << std::endl;
}

template <class T>
void test()
{
   typedef T                                mp_t;
   boost::array<std::ios_base::fmtflags, 9> f =
       {{std::ios_base::fmtflags(0), std::ios_base::showpoint, std::ios_base::showpos, std::ios_base::scientific, std::ios_base::scientific | std::ios_base::showpos,
         std::ios_base::scientific | std::ios_base::showpoint, std::ios_base::fixed, std::ios_base::fixed | std::ios_base::showpoint,
         std::ios_base::fixed | std::ios_base::showpos}};

   boost::array<boost::array<const char*, 13 * 9>, 40> string_data = {{
#include "libs/multiprecision/test/string_data.ipp"
   }};

   double num   = 123456789.0;
   double denom = 1;
   double val   = num;
   for (unsigned j = 0; j < 40; ++j)
   {
      unsigned col = 0;
      for (unsigned prec = 1; prec < 14; ++prec)
      {
         for (unsigned i = 0; i < f.size(); ++i, ++col)
         {
            std::stringstream ss;
            ss.precision(prec);
            ss.flags(f[i]);
            ss << mp_t(val);
            const char* expect = string_data[j][col];
            if (ss.str() != expect)
            {
               if (has_bad_bankers_rounding(mp_t()) && is_bankers_rounding_error(ss.str(), expect))
               {
                  std::cout << "Ignoring bankers-rounding error with GMP mp_f.\n";
               }
               else
               {
                  std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
                  print_flags(f[i]);
                  std::cout << "Precision is: " << prec << std::endl;
                  std::cout << "Got:      " << ss.str() << std::endl;
                  std::cout << "Expected: " << expect << std::endl;
                  ++boost::detail::test_errors();
                  mp_t(val).str(prec, f[i]); // for debugging
               }
            }
         }
      }
      num = -num;
      if (j & 1)
         denom *= 8;
      val = num / denom;
   }

   boost::array<const char*, 13 * 9> zeros =
       {{"0", "0.", "+0", "0.0e+00", "+0.0e+00", "0.0e+00", "0.0", "0.0", "+0.0", "0", "0.0", "+0", "0.00e+00", "+0.00e+00", "0.00e+00", "0.00", "0.00", "+0.00", "0", "0.00", "+0", "0.000e+00", "+0.000e+00", "0.000e+00", "0.000", "0.000", "+0.000", "0", "0.000", "+0", "0.0000e+00", "+0.0000e+00", "0.0000e+00", "0.0000", "0.0000", "+0.0000", "0", "0.0000", "+0", "0.00000e+00", "+0.00000e+00", "0.00000e+00", "0.00000", "0.00000", "+0.00000", "0", "0.00000", "+0", "0.000000e+00", "+0.000000e+00", "0.000000e+00", "0.000000", "0.000000", "+0.000000", "0", "0.000000", "+0", "0.0000000e+00", "+0.0000000e+00", "0.0000000e+00", "0.0000000", "0.0000000", "+0.0000000", "0", "0.0000000", "+0", "0.00000000e+00", "+0.00000000e+00", "0.00000000e+00", "0.00000000", "0.00000000", "+0.00000000", "0", "0.00000000", "+0", "0.000000000e+00", "+0.000000000e+00", "0.000000000e+00", "0.000000000", "0.000000000", "+0.000000000", "0", "0.000000000", "+0", "0.0000000000e+00", "+0.0000000000e+00", "0.0000000000e+00", "0.0000000000", "0.0000000000", "+0.0000000000", "0", "0.0000000000", "+0", "0.00000000000e+00", "+0.00000000000e+00", "0.00000000000e+00", "0.00000000000", "0.00000000000", "+0.00000000000", "0", "0.00000000000", "+0", "0.000000000000e+00", "+0.000000000000e+00", "0.000000000000e+00", "0.000000000000", "0.000000000000", "+0.000000000000", "0", "0.000000000000", "+0", "0.0000000000000e+00", "+0.0000000000000e+00", "0.0000000000000e+00", "0.0000000000000", "0.0000000000000", "+0.0000000000000"}};

   unsigned col = 0;
   val          = 0;
   for (unsigned prec = 1; prec < 14; ++prec)
   {
      for (unsigned i = 0; i < f.size(); ++i, ++col)
      {
         std::stringstream ss;
         ss.precision(prec);
         ss.flags(f[i]);
         ss << mp_t(val);
         const char* expect = zeros[col];
         if (ss.str() != expect)
         {
            std::cout << std::setprecision(20) << "Testing value " << val << std::endl;
            print_flags(f[i]);
            std::cout << "Precision is: " << prec << std::endl;
            std::cout << "Got:      " << ss.str() << std::endl;
            std::cout << "Expected: " << expect << std::endl;
            ++boost::detail::test_errors();
            mp_t(val).str(prec, f[i]); // for debugging
         }
      }
   }

   if (std::numeric_limits<mp_t>::has_infinity)
   {
      T val = std::numeric_limits<T>::infinity();
      BOOST_CHECK_EQUAL(val.str(), "inf");
      BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "+inf");
      val = -val;
      BOOST_CHECK_EQUAL(val.str(), "-inf");
      BOOST_CHECK_EQUAL(val.str(0, std::ios_base::showpos), "-inf");

      val = static_cast<T>("inf");
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      val = static_cast<T>("+inf");
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      val = static_cast<T>("-inf");
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<mp_t>::has_quiet_NaN)
   {
      T val = std::numeric_limits<T>::quiet_NaN();
      BOOST_CHECK_EQUAL(val.str(), "nan");
      val = static_cast<T>("nan");
      BOOST_CHECK((boost::math::isnan)(val));
   }
   //
   // Bug cases:
   //
   // https://github.com/boostorg/multiprecision/issues/113
   //
   {
      T val("99.9809");
      BOOST_CHECK_EQUAL(val.str(3, std::ios_base::fixed), "99.981");
   }
}

template <class T>
T generate_random()
{
   typedef typename T::backend_type::exponent_type e_type;
   static boost::random::mt19937                   gen;
   T                                               val      = gen();
   T                                               prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(0, std::numeric_limits<T>::max_exponent - 10);
   return ldexp(val, ui(gen));
}

template <class T>
struct max_digits10_proxy
{
   static const unsigned value = std::numeric_limits<T>::digits10 + 5;
};
#ifdef TEST_CPP_DEC_FLOAT
template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >
{
   static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<D>, ET> >::max_digits10;
};
#endif
#ifdef TEST_MPF_50
template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >
{
   static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<D>, ET> >::max_digits10;
};
#endif
#ifdef TEST_MPFR_50
template <unsigned D, boost::multiprecision::expression_template_option ET>
struct max_digits10_proxy<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >
{
   static const unsigned value = std::numeric_limits<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<D>, ET> >::max_digits10;
};
#endif

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f)
{
   std::stringstream ss;
   ss << std::setprecision(std::numeric_limits<T>::max_digits10);
   ss.flags(f);
   ss << val;
   T new_val = static_cast<T>(ss.str());
   BOOST_CHECK_EQUAL(new_val, val);
   new_val = static_cast<T>(val.str(f & std::ios_base::fixed ? std::numeric_limits<T>::max_digits10 : 0, f));
   BOOST_CHECK_EQUAL(new_val, val);
}

template <class T>
void do_round_trip(const T& val)
{
   do_round_trip(val, std::ios_base::fmtflags(0));
   do_round_trip(val, std::ios_base::fmtflags(std::ios_base::scientific));
   if ((fabs(val) > 1) && (fabs(val) < 1e100))
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::fixed));
}

template <class T>
void test_round_trip()
{
   for (unsigned i = 0; i < 1000; ++i)
   {
      T val = generate_random<T>();
      do_round_trip(val);
      do_round_trip(T(-val));
      do_round_trip(T(1 / val));
      do_round_trip(T(-1 / val));
   }
}

template<typename T>
void test_to_string()
{
   using std::to_string;
   T x0{"23.43"};
   BOOST_CHECK_EQUAL(to_string(x0), "23.430000");

   T x1{"1e-9"};
   BOOST_CHECK_EQUAL(to_string(x1), "0.000000");

   T x2{"123456789"};
   BOOST_CHECK_EQUAL(to_string(x2), "123456789.000000");
}

#ifdef TEST_FLOAT128
void test_hexadecimal_floating_point()
{
   using boost::multiprecision::float128;

   float128 x = 0x1p+0Q;

   std::string s = x.str(0, std::ios_base::fmtflags(std::ios_base::fixed | std::ios_base::scientific));
   BOOST_CHECK_EQUAL(s, "0x1p+0");

   s = x.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
   BOOST_CHECK_EQUAL(s, "0x1p+0");

   x = -1;
   s = x.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
   BOOST_CHECK_EQUAL(s, "-0x1p+0");

   // hexadecimal representation of pi; test a round trip:
   float128 pi1 = 0x1.921fb54442d18469898cc51701b8p+1Q;
   s            = pi1.str(0, std::ios_base::fmtflags(std::ios_base::floatfield));
   float128 pi2(s);
   BOOST_CHECK_EQUAL(pi1, pi2);
}
#endif

int main()
{
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();

   test_round_trip<boost::multiprecision::mpfr_float_50>();
   test_round_trip<boost::multiprecision::mpfr_float_100>();

   test_to_string<boost::multiprecision::mpfr_float_50>();
   test_to_string<boost::multiprecision::mpfr_float_100>();

#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();

   test_round_trip<boost::multiprecision::mpfr_float_50>();
   test_round_trip<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();

   // cpp_dec_float has extra guard digits that messes this up:
   test_round_trip<boost::multiprecision::cpp_dec_float_50>();
   test_round_trip<boost::multiprecision::cpp_dec_float_100>();

   test_to_string<boost::multiprecision::cpp_dec_float_50>();
   test_to_string<boost::multiprecision::cpp_dec_float_100>();

#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
   /*
   // I can't get this to work with mpf_t - mpf_str appears
   // not to actually print enough decimal digits:
   test_round_trip<boost::multiprecision::mpf_float_50>();
   test_round_trip<boost::multiprecision::mpf_float_100>();
   */
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
   test_hexadecimal_floating_point();
   test_to_string<boost::multiprecision::float128>();
#ifndef BOOST_INTEL
   test_round_trip<boost::multiprecision::float128>();
#endif
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_float_serial.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2013 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "timer.hpp"
#include "test.hpp"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/exception/all.hpp>

#ifndef BOOST_MP_TEST_FLOAT_SERIAL_HPP
#define BOOST_MP_TEST_FLOAT_SERIAL_HPP

template <class T>
T generate_random(unsigned /*bits_wanted*/)
{
   typedef typename T::backend_type::exponent_type e_type;
   static boost::random::mt19937                   gen;
   T                                               val      = gen();
   T                                               prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static boost::random::uniform_int_distribution<e_type> ui(std::numeric_limits<T>::min_exponent + 1, std::numeric_limits<T>::max_exponent - 1);
   return ldexp(val, ui(gen));
}

template <class T>
void test()
{
   timer tim;

   while (true)
   {
      T           val     = generate_random<T>(boost::math::tools::digits<T>());
      int         test_id = 0;
      std::string stream_contents;
#ifndef BOOST_NO_EXCEPTIONS
      try
      {
#endif
         test_id = 0;
         {
            std::stringstream             ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            boost::archive::text_oarchive oa(ss);
            oa << static_cast<const T&>(val);
            stream_contents = ss.str();
            boost::archive::text_iarchive ia(ss);
            T                             val2;
            ia >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            {
               boost::archive::xml_oarchive oa(ss);
               oa << boost::serialization::make_nvp("value", static_cast<const T&>(val));
               stream_contents = ss.str();
            }
            boost::archive::xml_iarchive ia(ss);
            T                            val2;
            ia >> boost::serialization::make_nvp("value", val2);
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            ++test_id;
            boost::archive::binary_oarchive ba(ss);
            ba << static_cast<const T&>(val);
            stream_contents = ss.str();
            boost::archive::binary_iarchive ib(ss);
            T                               val2;
            ib >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            val = -val;
            ++test_id;
            boost::archive::text_oarchive oa2(ss);
            oa2 << static_cast<const T&>(val);
            stream_contents = ss.str();
            boost::archive::text_iarchive ia2(ss);
            T                             val2;
            ia2 >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            ++test_id;
            {
               boost::archive::xml_oarchive oa2(ss);
               oa2 << boost::serialization::make_nvp("value", static_cast<const T&>(val));
               stream_contents = ss.str();
            }
            boost::archive::xml_iarchive ia2(ss);
            T                            val2;
            ia2 >> boost::serialization::make_nvp("value", val2);
            BOOST_CHECK_EQUAL(val, val2);
         }
         {
            std::stringstream ss(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
            ++test_id;
            boost::archive::binary_oarchive ba2(ss);
            ba2 << static_cast<const T&>(val);
            stream_contents = ss.str();
            boost::archive::binary_iarchive ib2(ss);
            T                               val2;
            ib2 >> val2;
            BOOST_CHECK_EQUAL(val, val2);
         }
#ifndef BOOST_NO_EXCEPTIONS
      }
      catch (const boost::exception& e)
      {
         std::cout << "Caught boost::exception with:\n";
         std::cout << diagnostic_information(e);
         std::cout << "Failed test ID = " << test_id << std::endl;
         std::cout << "Stream contents were: \n"
                   << stream_contents << std::endl;
         ++boost::detail::test_errors();
         break;
      }
      catch (const std::exception& e)
      {
         std::cout << "Caught std::exception with:\n";
         std::cout << e.what() << std::endl;
         std::cout << "Failed test ID = " << test_id << std::endl;
         std::cout << "Stream contents were: \n"
                   << stream_contents << std::endl;
         ++boost::detail::test_errors();
         break;
      }
#endif
      //
      // Check to see if test is taking too long.
      // Tests run on the compiler farm time out after 300 seconds,
      // so don't get too close to that:
      //
#ifndef CI_SUPPRESS_KNOWN_ISSUES
      if (tim.elapsed() > 150)
#else
      if (tim.elapsed() > 25)
#endif
      {
         std::cout << "Timeout reached, aborting tests now....\n";
         break;
      }
   }
}

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_fpclassify.cpp
================================================
//  Copyright John Maddock 2006.
//  Copyright Paul A. Bristow 2007
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <cmath>
#include <math.h>
#include <boost/limits.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR_50
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPFI_50
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

#ifdef _MSC_VER
#pragma warning(disable : 4127) //  conditional expression is constant
#endif

const char* method_name(const boost::math::detail::native_tag&)
{
   return "Native";
}

const char* method_name(const boost::math::detail::generic_tag<true>&)
{
   return "Generic (with numeric limits)";
}

const char* method_name(const boost::math::detail::generic_tag<false>&)
{
   return "Generic (without numeric limits)";
}

const char* method_name(const boost::math::detail::ieee_tag&)
{
   return "IEEE std";
}

const char* method_name(const boost::math::detail::ieee_copy_all_bits_tag&)
{
   return "IEEE std, copy all bits";
}

const char* method_name(const boost::math::detail::ieee_copy_leading_bits_tag&)
{
   return "IEEE std, copy leading bits";
}

template <class T>
void test()
{
   T t = 2;
   T u = 2;
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_NORMAL);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_NORMAL);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), true);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), true);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
   if (std::numeric_limits<T>::is_specialized)
   {
      t = (std::numeric_limits<T>::max)();
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_NORMAL);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_NORMAL);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
      t = (std::numeric_limits<T>::min)();
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_NORMAL);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_NORMAL);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
   }
   if (std::numeric_limits<T>::has_denorm)
   {
      t = (std::numeric_limits<T>::min)();
      t /= 2;
      if (t != 0)
      {
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_SUBNORMAL);
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_SUBNORMAL);
         BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
         BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
         BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
      }
      t = std::numeric_limits<T>::denorm_min();
      if ((t != 0) && (t < (std::numeric_limits<T>::min)()))
      {
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_SUBNORMAL);
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_SUBNORMAL);
         BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
         BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
         BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
         BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
         BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
      }
   }
   else
   {
      std::cout << "Denormalised forms not tested" << std::endl;
   }
   t = 0;
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_ZERO);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_ZERO);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
   t /= -u; // create minus zero if it exists
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_ZERO);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_ZERO);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), true);
   BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), true);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
   BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
   BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
   // infinity:
   if (std::numeric_limits<T>::has_infinity)
   {
      // At least one std::numeric_limits<T>::infinity)() returns zero
      // (Compaq true64 cxx), hence the check.
      t = (std::numeric_limits<T>::infinity)();
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
#if !defined(BOOST_BORLANDC) && !(defined(__DECCXX) && !defined(_IEEE_FP))
      // divide by zero on Borland triggers a C++ exception :-(
      // divide by zero on Compaq CXX triggers a C style signal :-(
      t = 2;
      u = 0;
      t /= u;
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
      t = -2;
      t /= u;
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_INFINITE);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (::boost::math::fpclassify)(t + 0));
#else
      std::cout << "Infinities from divide by zero not tested" << std::endl;
#endif
   }
   else
   {
      std::cout << "Infinity not tested" << std::endl;
   }
#ifndef BOOST_BORLANDC
   // NaN's:
   // Note that Borland throws an exception if we even try to obtain a Nan
   // by calling std::numeric_limits<T>::quiet_NaN() !!!!!!!
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      t = std::numeric_limits<T>::quiet_NaN();
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_NAN);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_NAN);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
   }
   else
   {
      std::cout << "Quiet NaN's not tested" << std::endl;
   }
   if (std::numeric_limits<T>::has_signaling_NaN)
   {
      t = std::numeric_limits<T>::signaling_NaN();
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(t), (int)FP_NAN);
      BOOST_CHECK_EQUAL((::boost::math::fpclassify)(-t), (int)FP_NAN);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isfinite)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isinf)(-t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnan)(-t), true);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(t), false);
      BOOST_CHECK_EQUAL((::boost::math::isnormal)(-t), false);
   }
   else
   {
      std::cout << "Signaling NaN's not tested" << std::endl;
   }
#endif
   //
   // Try sign manipulation functions as well:
   //
   T one(1), minus_one(-1), zero(0);
   BOOST_CHECK((::boost::math::sign)(one) > 0);
   BOOST_CHECK((::boost::math::sign)(minus_one) < 0);
   BOOST_CHECK((::boost::math::sign)(zero) == 0);
   BOOST_CHECK((::boost::math::sign)(one + 2) > 0);
   BOOST_CHECK((::boost::math::sign)(minus_one - 30) < 0);
   BOOST_CHECK((::boost::math::sign)(-zero) == 0);

   BOOST_CHECK((::boost::math::signbit)(one) == 0);
   BOOST_CHECK((::boost::math::signbit)(minus_one) > 0);
   BOOST_CHECK((::boost::math::signbit)(zero) == 0);
   BOOST_CHECK((::boost::math::signbit)(one + 2) == 0);
   BOOST_CHECK((::boost::math::signbit)(minus_one - 30) > 0);
   //BOOST_CHECK((::boost::math::signbit)(-zero) == 0);

   BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(one)) > 0);
   BOOST_CHECK_EQUAL(boost::math::changesign(one), minus_one);
   BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(minus_one)) == 0);
   BOOST_CHECK_EQUAL(boost::math::changesign(minus_one), one);
   //BOOST_CHECK((::boost::math::signbit)(zero) == 0);
   BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(one + 2)) > 0);
   BOOST_CHECK_EQUAL(boost::math::changesign(one + 2), -3);
   BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(minus_one - 30)) == 0);
   BOOST_CHECK_EQUAL(boost::math::changesign(minus_one - 30), 31);
   //BOOST_CHECK((::boost::math::signbit)(-zero) == 0);

   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(one, one)) == 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(one, one), one);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(one, minus_one)) > 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(one, minus_one), minus_one);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(minus_one, one)) == 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(minus_one, one), one);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(minus_one, minus_one)) > 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(minus_one, minus_one), minus_one);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(one + 1, one + 2)) == 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(one + 1, one + 2), 2);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(one + 30, minus_one - 20)) > 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(one + 30, minus_one - 20), -31);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(minus_one + 2, one + 2)) == 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(minus_one - 2, one + 2), 3);
   BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(minus_one - 20, minus_one - 30)) > 0);
   BOOST_CHECK_EQUAL(boost::math::copysign(minus_one - 20, minus_one - 30), -21);

   // Things involving signed zero, need to detect it first:
   T neg_zero_test = -(std::numeric_limits<T>::min)();
   neg_zero_test /= (std::numeric_limits<T>::max)();
   if (std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0))
   {
#ifndef TEST_MPFI_50
      // Note that testing this with mpfi is in the "too difficult" drawer at present.
      std::cout << neg_zero_test << std::endl;
      BOOST_CHECK_EQUAL(neg_zero_test, 0);
      BOOST_CHECK((::boost::math::sign)(neg_zero_test) == 0);
      // We got -INF, so we have a signed zero:
      BOOST_CHECK((::boost::math::signbit)(neg_zero_test) > 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(zero)) > 0);
      BOOST_CHECK_EQUAL(boost::math::changesign(zero), 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::changesign(neg_zero_test)) == 0);
      BOOST_CHECK_EQUAL(boost::math::changesign(neg_zero_test), 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(zero, one)) == 0);
      BOOST_CHECK_EQUAL(boost::math::copysign(zero, one), 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(zero, minus_one)) > 0);
      BOOST_CHECK_EQUAL(boost::math::copysign(zero, minus_one), 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(neg_zero_test, one)) == 0);
      BOOST_CHECK_EQUAL(boost::math::copysign(neg_zero_test, one), 0);
      BOOST_CHECK((::boost::math::signbit)(boost::math::copysign(neg_zero_test, minus_one)) > 0);
      BOOST_CHECK_EQUAL(boost::math::copysign(neg_zero_test, minus_one), 0);
#endif
   }
}

int main()
{
   BOOST_MATH_CONTROL_FP;
   // start by printing some information:
#ifdef isnan
   std::cout << "Platform has isnan macro." << std::endl;
#endif
#ifdef fpclassify
   std::cout << "Platform has fpclassify macro." << std::endl;
#endif
#ifdef BOOST_HAS_FPCLASSIFY
   std::cout << "Platform has FP_NORMAL macro." << std::endl;
#endif
   std::cout << "FP_ZERO: " << (int)FP_ZERO << std::endl;
   std::cout << "FP_NORMAL: " << (int)FP_NORMAL << std::endl;
   std::cout << "FP_INFINITE: " << (int)FP_INFINITE << std::endl;
   std::cout << "FP_NAN: " << (int)FP_NAN << std::endl;
   std::cout << "FP_SUBNORMAL: " << (int)FP_SUBNORMAL << std::endl;

#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#endif
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_gcd.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#define BOOST_MP_GCD_DEBUG

#include "test.hpp"
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random.hpp>
#include <map>
#include <tuple>
//
// clang in c++14 mode only has a problem with this file: it's an order of instantiation
// issue caused by us using cpp_int within the gcd algorithm as an error check.
// Just exclude that combination from testing for now as it's purely a testing issue
// and we have other compilers that cover this sanity check...
//
#if !(defined(__clang__) && (__cplusplus > 201300))

using boost::multiprecision::cpp_int;

std::tuple<std::vector<cpp_int>, std::vector<cpp_int>, std::vector<cpp_int> >& get_test_vector(std::size_t bits)
{
   static std::map<std::size_t, std::tuple<std::vector<cpp_int>, std::vector<cpp_int>, std::vector<cpp_int> > > data;

   std::tuple<std::vector<cpp_int>, std::vector<cpp_int>, std::vector<cpp_int> >& result = data[bits];

   if (std::get<0>(result).size() == 0)
   {
      boost::random::mt19937                     mt;
      boost::random::uniform_int_distribution<cpp_int> ui(cpp_int(1) << (bits - 1), cpp_int(1) << bits);

      std::vector<cpp_int>& a = std::get<0>(result);
      std::vector<cpp_int>& b = std::get<1>(result);
      std::vector<cpp_int>& c = std::get<2>(result);

      for (unsigned i = 0; i < 1000; ++i)
      {
         a.push_back(ui(mt));
         b.push_back(ui(mt));
         if (b.back() > a.back())
            b.back().swap(a.back());
         c.push_back(0);
      }
   }
   return result;
}

std::vector<cpp_int>& get_test_vector_a(std::size_t bits)
{
   return std::get<0>(get_test_vector(bits));
}
std::vector<cpp_int>& get_test_vector_b(std::size_t bits)
{
   return std::get<1>(get_test_vector(bits));
}
std::vector<cpp_int>& get_test_vector_c(std::size_t bits)
{
   return std::get<2>(get_test_vector(bits));
}

cpp_int gcd_euler(cpp_int u, cpp_int v)
{
   while (v)
   {
      cpp_int t(v);
      v = u % v;
      u = t;
   }
   return u;
}

namespace boost {
namespace multiprecision {
namespace backends {

std::size_t total_lehmer_gcd_calls      = 0;
std::size_t total_lehmer_gcd_bits_saved = 0;
std::size_t total_lehmer_gcd_cycles     = 0;

}}}


int main()
{
   using boost::multiprecision::backends::total_lehmer_gcd_calls;
   using boost::multiprecision::backends::total_lehmer_gcd_bits_saved;
   using boost::multiprecision::backends::total_lehmer_gcd_cycles;

   unsigned bits = 2048;

   std::vector<cpp_int>& a = get_test_vector_a(bits);
   std::vector<cpp_int>& b = get_test_vector_b(bits);
   std::vector<cpp_int>& c = get_test_vector_c(bits);

   for (unsigned i = 0; i < a.size(); ++i)
   {
      c[i] = gcd(a[i], b[i]);
      cpp_int t = gcd_euler(a[i], b[i]);
      BOOST_CHECK_EQUAL(t, c[i]);
   }

   float average_bits_saved_per_lehmer_call = static_cast<float>(total_lehmer_gcd_bits_saved) / total_lehmer_gcd_calls;
   float average_number_of_euler_cycles_saved = static_cast<float>(total_lehmer_gcd_cycles) / total_lehmer_gcd_calls;

   std::cout << "Average number of bits saved per Lehmer call:           " << average_bits_saved_per_lehmer_call << std::endl;
   std::cout << "Average number of Euclid cycles saved per Lehmer call:  " << average_number_of_euler_cycles_saved << std::endl;

#ifndef BOOST_HAS_INT128
   BOOST_CHECK_GT(average_bits_saved_per_lehmer_call, 30);
#else
   BOOST_CHECK_GT(average_bits_saved_per_lehmer_call, 62);
#endif

   return boost::report_errors();
}

#else

int main() { return 0; }

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_generic_conv.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/random.hpp>

#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif

int main()
{
   using namespace boost::multiprecision;
   using namespace boost::random;

   independent_bits_engine<mt11213b, 1024, cpp_int> gen;
   mt11213b                                         small_gen;

   for (unsigned i = 0; i < 100; ++i)
   {
      cpp_int c = gen();
      //
      // Integer to integer conversions first:
      //
#ifdef TEST_GMP
      mpz_int z(c);
      cpp_int t(z);
      BOOST_CHECK_EQUAL(t, c);
      z.assign(-c);
      t.assign(-z);
      BOOST_CHECK_EQUAL(t, c);
#endif
#ifdef TEST_TOMMATH
      tom_int tom(c);
      cpp_int t2(tom);
      BOOST_CHECK_EQUAL(t2, c);
      tom.assign(-c);
      t2.assign(-tom);
      BOOST_CHECK_EQUAL(t2, c);
#endif
      //
      // Now integer to float:
      //
      typedef number<cpp_dec_float<500> > dec_float_500;
      dec_float_500                       df(c);
      dec_float_500                       df2(c.str());
      BOOST_CHECK_EQUAL(df, df2);
      df.assign(-c);
      df2 = -df2;
      BOOST_CHECK_EQUAL(df, df2);
#ifdef TEST_GMP
      typedef number<gmp_float<500> > mpf_type;
      mpf_type                        mpf(c);
      mpf_type                        mpf2(c.str());
      BOOST_CHECK_EQUAL(mpf, mpf2);
      mpf.assign(-c);
      mpf2 = -mpf2;
      BOOST_CHECK_EQUAL(mpf, mpf2);
#endif
#ifdef TEST_MPFR
      typedef number<mpfr_float_backend<500> > mpfr_type;
      mpfr_type                                mpfr(c);
      mpfr_type                                mpfr2(c.str());
      BOOST_CHECK_EQUAL(mpfr, mpfr2);
      mpfr.assign(-c);
      mpfr2 = -mpfr2;
      BOOST_CHECK_EQUAL(mpfr, mpfr2);
#endif
      //
      // Now float to float:
      //
      df.assign(c);
      df /= dec_float_500(gen());
      dec_float_500 tol("1e-500");
#ifdef TEST_GMP
      mpf.assign(df);
      mpf2 = static_cast<mpf_type>(df.str());
      BOOST_CHECK_EQUAL(mpf, mpf2);
      df.assign(mpf);
      df2 = static_cast<dec_float_500>(mpf.str());
      BOOST_CHECK(fabs((df - df2) / df) < tol);
#endif
#ifdef TEST_MPFR
      mpfr.assign(df);
      mpfr2 = static_cast<mpfr_type>(df.str());
      BOOST_CHECK_EQUAL(mpfr, mpfr2);
      df.assign(mpfr);
      df2 = static_cast<dec_float_500>(mpfr.str());
      BOOST_CHECK(fabs((df - df2) / df) < tol);
#endif
      //
      // Rational to rational conversions:
      //
      cpp_rational cppr(c, gen()), cppr2, cppr3;
#ifdef TEST_GMP
      mpq_rational mpq(cppr);
      cppr2.assign(mpq);
      BOOST_CHECK_EQUAL(cppr, cppr2);
#endif
#ifdef TEST_TOMMATH
      tom_rational tr(cppr);
      cppr3.assign(tr);
      BOOST_CHECK_EQUAL(cppr, cppr3);
#endif
      //
      // Integer to rational conversions:
      //
#ifdef TEST_GMP
      mpq.assign(c);
      mpq_rational mpq2 = static_cast<mpq_rational>(c.str());
      BOOST_CHECK_EQUAL(mpq, mpq2);
#endif
#ifdef TEST_TOMMATH
      tr.assign(c);
      tom_rational tr2 = static_cast<tom_rational>(c.str());
      BOOST_CHECK_EQUAL(tr, tr2);
#endif
      //
      // Rational to float:
      //
      df.assign(cppr);
      df2.assign(numerator(cppr));
      df2 /= dec_float_500(denominator(cppr));
      BOOST_CHECK(fabs(df - df2) / df2 < tol);
      //
      // Float to rational:
      //
      static const int                                       max_range = std::numeric_limits<double>::digits >= std::numeric_limits<int>::digits ? (std::numeric_limits<int>::max)() : (1 << (std::numeric_limits<double>::digits - 1)) - 1;
      static const int                                       min_range = std::numeric_limits<double>::digits >= std::numeric_limits<int>::digits ? (std::numeric_limits<int>::min)() : -(1 << (std::numeric_limits<double>::digits - 1)) + 1;
      static const boost::random::uniform_int_distribution<> i_val_dist(min_range, max_range);
      static const boost::random::uniform_int_distribution<> i_exp_dist(std::numeric_limits<double>::min_exponent, std::numeric_limits<double>::max_exponent - 2 - std::numeric_limits<int>::digits);
      int                                                    iv   = i_val_dist(small_gen);
      int                                                    eval = i_exp_dist(small_gen);
      double                                                 dv   = iv;
      dv                                                          = ldexp(dv, eval);
      cppr                                                        = dv;
      cppr2                                                       = iv;
      cpp_int cppi                                                = 1;
      cppi <<= abs(eval);
      if (eval < 0)
         cppr2 /= cppi;
      else
         cppr2 *= cppi;
      BOOST_CHECK_EQUAL(cppr, cppr2);
      //
      // Again but with bigger numbers:
      //
      cpp_int                      cppi2 = gen();
      number<cpp_bin_float<1030> > cppbf(cppi2);
      cppbf = ldexp(cppbf, eval);
      cppr.assign(cppbf);
      cppr2 = cppi2;
      if (eval < 0)
         cppr2 /= cppi;
      else
         cppr2 *= cppi;
      BOOST_CHECK_EQUAL(cppr, cppr2);
      //
      // MSVC will compile either the code above, or
      // the code below, but not both in the same file.
      // Other compilers including Intel in msvc-compatibity
      // mode have no such difficulty.  Indeed the fact that
      // the presence of the code below causes the code above to
      // fail to compile strongly suggests a compiler bug.
      //
#if !defined(BOOST_MSVC)
      //
      // Again but with bigger base 10 numbers:
      //
      number<cpp_dec_float<std::numeric_limits<int1024_t>::digits10 + 3> > cppdec2(cppi2);
      cppdec2 = scalbn(cppdec2, eval);
      cppr.assign(cppdec2);
      cppr2 = cppi2;
      cppi  = 10;
      cppi  = pow(cppi, abs(eval));
      if (eval < 0)
         cppr2 /= cppi;
      else
         cppr2 *= cppi;
      BOOST_CHECK_EQUAL(cppr, cppr2);
#endif
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_gmp_conversions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/gmp.hpp>

int main()
{
   using namespace boost::multiprecision;
   //
   // Test interconversions between GMP supported backends:
   //
   mpf_t mpf;
   mpz_t mpz;
   mpq_t mpq;
   mpf_init2(mpf, 100);
   mpf_set_ui(mpf, 2u);
   mpz_init(mpz);
   mpz_set_ui(mpz, 2u);
   mpq_init(mpq);
   mpq_set_ui(mpq, 2u, 1u);

   BOOST_TEST(mpf_float(mpf) == 2);
   BOOST_TEST(mpf_float_50(mpf) == 2);
   BOOST_TEST(mpf_float(mpz) == 2);
   BOOST_TEST(mpf_float_50(mpz) == 2);
   BOOST_TEST(mpf_float(mpq) == 2);
   BOOST_TEST(mpf_float_50(mpq) == 2);

   mpf_float    f0;
   mpf_float_50 f50;
   f0 = mpf;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpz;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpq;
   BOOST_TEST(f0 == 2);

   f50 = mpf;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpz;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpq;
   BOOST_TEST(f50 == 2);

   f50 = 4;
   f0  = f50;
   BOOST_TEST(f0 == 4);
   f0  = 3;
   f50 = f0;
   BOOST_TEST(f50 == 3);
   f50 = 4;
   BOOST_TEST(mpf_float(f50) == 4);
   BOOST_TEST(mpf_float_50(f0) == 3);

   mpz_int      iz(2);
   mpq_rational rat(2);
   f50 = iz;
   BOOST_TEST(f50 == 2);
   f0 = iz;
   BOOST_TEST(f0 == 2);
   BOOST_TEST(mpf_float(iz) == 2);
   BOOST_TEST(mpf_float_50(iz) == 2);
   BOOST_TEST(mpf_float(rat) == 2);
   BOOST_TEST(mpf_float_50(rat) == 2);

   BOOST_TEST(mpz_int(mpf) == 2);
   BOOST_TEST(mpz_int(mpz) == 2);
   BOOST_TEST(mpz_int(mpq) == 2);
   iz = 3;
   iz = mpz_int(mpf); // explicit conversion only
   BOOST_TEST(iz == 2);
   iz = 3;
   iz = mpz;
   BOOST_TEST(iz == 2);
   iz = 4;
   iz = mpz_int(mpq); // explicit conversion only
   BOOST_TEST(iz == 2);
   f0  = 2;
   f50 = 2;

   BOOST_TEST(mpz_int(f0) == 2);
   BOOST_TEST(mpz_int(f50) == 2);
   rat = 2;
   BOOST_TEST(mpz_int(rat) == 2);
   iz = 3;
   iz = static_cast<mpz_int>(f0);
   BOOST_TEST(iz == 2);
   iz = 3;
   iz = static_cast<mpz_int>(f50);
   BOOST_TEST(iz == 2);
   iz = 3;
   iz = static_cast<mpz_int>(rat);
   BOOST_TEST(iz == 2);

   BOOST_TEST(mpq_rational(mpz) == 2);
   BOOST_TEST(mpq_rational(mpq) == 2);
   BOOST_TEST(mpq_rational(iz) == 2);
   rat = 3;
   rat = mpz;
   BOOST_TEST(rat == 2);
   rat = 3;
   rat = mpq;
   BOOST_TEST(rat == 2);
   rat = 3;
   rat = iz;
   BOOST_TEST(rat == 2);

   iz = numerator(rat);
   BOOST_TEST(iz == 2);
   iz = denominator(rat);
   BOOST_TEST(iz == 1);
   //
   // Conversion to floating point types
   // see https://github.com/boostorg/multiprecision/issues/178
   //
   rat = 3;
   rat /= 4;
   BOOST_TEST(rat.convert_to<float>() == 0.75);
   BOOST_TEST(rat.convert_to<double>() == 0.75);
   BOOST_TEST(rat.convert_to<long double>() == 0.75);
#ifdef BOOST_HAS_FLOAT128
   BOOST_TEST(rat.convert_to<__float128>() == 0.75);
#endif

   //
   // Conversions involving precision only,
   // note that mpf_t precisions are only approximate:
   //
   mpf_float::default_precision(30);
   f50 = 2;
   mpf_float_100 f100(3);
   mpf_float     f0a(4);
   mpf_float     f0b(f100);
   BOOST_TEST(f0a.precision() >= 30);
   BOOST_TEST(f0b.precision() >= 100);
   f0a = f100;
   BOOST_TEST(f0a == 3);
   BOOST_TEST(f0a.precision() >= 100);

   f100 = f50;
   BOOST_TEST(f100 == 2);

   mpf_clear(mpf);
   mpz_clear(mpz);
   mpq_clear(mpq);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_hash.cpp
================================================
// Copyright John Maddock 2015.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#include <boost/multiprecision/logged_adaptor.hpp>

#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPFI
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif

#include <boost/functional/hash.hpp>

#include "test.hpp"
#include <functional> // std::hash
#include <iostream>
#include <iomanip>

template <class T>
void test()
{
   T           val = 23;
   std::size_t t1  = boost::hash<T>()(val);
   BOOST_CHECK(t1);

   std::size_t t2 = std::hash<T>()(val);
   BOOST_CHECK_EQUAL(t1, t2);
   val            = -23;
   std::size_t t3 = boost::hash<T>()(val);
   BOOST_CHECK_NE(t1, t3);
   t2 = std::hash<T>()(val);
   BOOST_CHECK_EQUAL(t3, t2);
}

int main()
{
   test<boost::multiprecision::cpp_int>();
   test<boost::multiprecision::checked_int1024_t>();
   //test<boost::multiprecision::checked_uint512_t >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<64, 64, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> > >();

   test<boost::multiprecision::cpp_bin_float_100>();
   test<boost::multiprecision::cpp_dec_float_100>();

   test<boost::multiprecision::cpp_rational>();

   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::cpp_int::backend_type> > >();

   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::cpp_int::backend_type> > >();

#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_GMP
   test<boost::multiprecision::mpz_int>();
   test<boost::multiprecision::mpq_rational>();
   test<boost::multiprecision::mpf_float>();
#endif

#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float_50>();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float_50>();
#endif

#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>();
   test<boost::multiprecision::tom_rational>();
#endif

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_int_io.cpp
================================================
// Copyright John Maddock 2011.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_MPZ) && !defined(TEST_TOMMATH) && !defined(TEST_CPP_INT)
#define TEST_TOMMATH
#define TEST_MPZ
#define TEST_CPP_INT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPZ)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#endif

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include "test.hpp"
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class T>
struct unchecked_type
{
   typedef T type;
};

#ifdef TEST_CPP_INT
template <std::size_t MinBits, std::size_t MaxBits, boost::multiprecision::cpp_integer_type SignType, boost::multiprecision::cpp_int_check_type Checked, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct unchecked_type<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates> >
{
   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<MinBits, MaxBits, SignType, boost::multiprecision::unchecked, Allocator>, ExpressionTemplates> type;
};
#endif

template <class T>
T generate_random()
{
   typedef typename unchecked_type<T>::type unchecked_T;

   static const unsigned limbs = std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits / std::numeric_limits<unsigned>::digits + 3 : 20;

   static boost::random::uniform_int_distribution<unsigned> ui(0, limbs);
   static boost::random::mt19937                            gen;
   unchecked_T                                              val = gen();
   unsigned                                                 lim = ui(gen);
   for (unsigned i = 0; i < lim; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   return val;
}

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f)
{
   std::stringstream ss;
   ss << std::setprecision(std::numeric_limits<T>::max_digits10);
   ss.flags(f);
   ss << val;
   T new_val = static_cast<T>(ss.str());
   BOOST_CHECK_EQUAL(new_val, val);
   new_val = static_cast<T>(val.str(0, f));
   BOOST_CHECK_EQUAL(new_val, val);
   ss >> new_val;
   BOOST_CHECK_EQUAL(new_val, val);
}

template <class T>
void do_round_trip(const T& val)
{
   do_round_trip(val, std::ios_base::fmtflags(0));
   if (val >= 0)
   {
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::showbase | std::ios_base::hex));
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::showbase | std::ios_base::oct));
   }
}

template <class T>
void negative_round_trip(T val, const std::integral_constant<bool, true>&)
{
   do_round_trip(T(-val));
}
template <class T>
void negative_round_trip(T, const std::integral_constant<bool, false>&)
{
}

template <class T>
void negative_spots(const std::integral_constant<bool, true>&)
{
   BOOST_CHECK_EQUAL(T(-1002).str(), "-1002");
   if (!std::numeric_limits<T>::is_modulo)
   {
#ifndef BOOST_NO_EXCEPTIONS
      BOOST_CHECK_THROW(T(-2).str(0, std::ios_base::oct), std::runtime_error);
      BOOST_CHECK_THROW(T(-2).str(0, std::ios_base::hex), std::runtime_error);
#endif
   }
}
template <class T>
void negative_spots(const std::integral_constant<bool, false>&)
{
}

template <class T>
void test_round_trip()
{
   for (unsigned i = 0; i < 1000; ++i)
   {
      T val = generate_random<T>();
      do_round_trip(val);
      negative_round_trip(val, std::integral_constant<bool, std::numeric_limits<T>::is_signed>());
   }

   BOOST_CHECK_EQUAL(T(1002).str(), "1002");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::showpos), "+1002");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::oct), "1752");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::oct | std::ios_base::showbase), "01752");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::hex), "3ea");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::hex | std::ios_base::showbase), "0x3ea");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::hex | std::ios_base::uppercase), "3EA");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::hex | std::ios_base::showbase | std::ios_base::uppercase), "0X3EA");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::dec), "1002");
   BOOST_CHECK_EQUAL(T(1002).str(0, std::ios_base::dec | std::ios_base::showbase), "1002");

   negative_spots<T>(std::integral_constant<bool, std::numeric_limits<T>::is_signed>());
}

int main()
{
#ifdef TEST_MPZ
   test_round_trip<boost::multiprecision::mpz_int>();
#endif
#ifdef TEST_TOMMATH
   test_round_trip<boost::multiprecision::tom_int>();
#endif
#ifdef TEST_CPP_INT
   test_round_trip<boost::multiprecision::cpp_int>();
   test_round_trip<boost::multiprecision::checked_int1024_t>();
   test_round_trip<boost::multiprecision::checked_uint512_t>();
   test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> > >();
   test_round_trip<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_int_sqrt.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

using Integer = boost::multiprecision::cpp_int;

void check_sqrt(const Integer& s, const Integer& r, const Integer& v) {
   BOOST_CHECK_EQUAL(s * s + r, v);
   BOOST_CHECK_GE(r, Integer(0));
   BOOST_CHECK_LE(s * s, v);
   BOOST_CHECK_GT((s + 1) * (s + 1), v);
}

template<typename I>
void check(const I& v) {
   I r;
   I s = boost::multiprecision::sqrt(v, r);
   check_sqrt(Integer(s), Integer(r), Integer(v));
}

void check_types(const Integer& v) {
   using namespace boost::multiprecision;
   size_t bits = 0;
   if (v > 0) {
      bits = msb(v);
   }
   if (bits < 32) {
      check(static_cast<uint32_t>(v));
   }
   if (bits < 64) {
      check(static_cast<uint64_t>(v));
   }
   if (bits < 128) {
      check(uint128_t(v));
   }
   if (bits < 256) {
      check(uint256_t(v));
   }
   if (bits < 512) {
      check(uint512_t(v));
   }
   check(v);
}

void check_near(const Integer& v) {
   check_types(v);
   for (size_t j = 0; j < 8; j++) {
      check_types(v - Integer(1 << j));
      check_types(v - Integer(1 << j) - 1);
      check_types(v - Integer(1 << j) + 1);
      check_types(v + Integer(1 << j));
      check_types(v + Integer(1 << j) - 1);
      check_types(v + Integer(1 << j) + 1);
   }
}

void test_first() {
   for (size_t i = 0; i < (1 << 16); i++) {
      check_types(Integer(i));
   }
}

void test_perfect() {
   for (size_t i = 256; i < (1 << 14); i++) {
      check_near(Integer(i) * Integer(i));
   }
}

void test_powers() {
   for (size_t i = 24; i < 2048; i++) {
      check_near(Integer(i) << i);
   }
}

void test_big() {
   for (size_t bits = 128; bits <= 2048; bits *= 2) {
      Integer i = Integer(1) << bits;
      Integer s = (i >> 8);
      Integer step = (i - s) / (1 << 8);
      for (Integer j = s; j <= i; j += step) {
         check_near(j);
      }
   }
}

int main()
{
   using namespace boost::multiprecision;

   test_first();
   test_perfect();
   test_powers();
   test_big();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_log.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR_50
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPFI_50
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 101> data =
       {{
           "-2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806",
           "10.355073440919378699690477472036470469315794905372650461119520557405966250191554948388847794306923706128373152780234988638443954821327953543032075228882306893901540038156503265416950932549208174713640840670002321534598356631953006304821201484830902632165858733357596733427094375150860310219829690440417223992885533566388118595248523193740778052893647271700612136670114224280374211626787106078693643289",
           "11.741365414719872359995630593475834957852130639032528348910839621576752378207582766840832626901446337859064321328454096088656817987112409176281442608184950888327275070356290649885618053367245169005379545357345645235094776018156840041023694466493107510640907700621694994008944652785168884717808235919056023540605910031676977750466679901495978099025342154131430098841939052890393197699093697421676686108",
           "12.552295188839391064403078983058501313786961042419051509346988474726615643710688192053158471717695991904853941837387256340073310064341282022830248452137946273986542713154937759697687656073485311102053666502633006429446632794099471395918827441203897096147814416727830805903830888831170139661499031930347916453836121200110772307492771615813954882033814741470466415076136175748560866462690250372712624427",
           "13.12765917900902322346243585913156826327069465639834188399662474212182724479008698347907678965083909936781641397385483495362268256360763444317213586059490467781653518008717313901614800566992248144716374322429987750723867821114358979404591879648104388637035609754399283274014767545593886580941165664957384975221949645055255781874944374229417864853289321901220692566918330756199433299461690335766708584",
           "13.573946210017730027239177097297058651455670148127333215055495986565964988037166389618503523561570994165268599045375753512400565200059790703280760252213714757212213525833556727462647729566258301490115414864748436290794191111843775262434063842232241185107471214859854864335150887423144285468856056851239653315249148749701603523173627966758652109489308872414194066451074827802642589890222384815709071028",
           "13.938589284701101831675037903832444894846690407420628610481163937380536465305805316181768586604603341197033655576371082304146219991693253987043452241307224478718013872459287813264283001906622959681872321576087143975972033651747378310838673897181549722528073649569290162541997276292708638316653324605571398691171391912961431088832002969546541039753774950645926800096854799942237644831671997679785482847",
           "14.246890620897408672445451566098178524763429935510610216690355229695078778430708804421870639655370744549370273426124295240527401708361100923871708589722651960428863955835558634640426846383161118062310502176054546468600516588908689567134867002953229862887953032595529925511011383644740837050282379317993152702704798000312156694502691021267028423979454580574052732764336948692001989411724963233511159783",
           "14.51395339092117324610526432755496036199337959182144260442491096061930765841595850793460014941610881052330595683873016973224744403781498772061971443926277312865243350174522677227134957935047605429941424114476598970997223505479765426888886686275495180653025817201214478249415383537946915840293549927935267010481189550187682053892807264533011114305883442850485847010726074555176479027986850883182954118",
           "14.749519451795537716462643672888549370666057639128212044001868590062813335472483708120056955187220713486931180221186191741860718823347399129280491176499608998857949407351247432513825095161942372289203657231256344909997480732110798704027258108845584594081552703009126596026870753341888414903979390651641367952487019992866762344920748102417282166652161104367292712971759633790964534907923779335451109079",
           "14.960240475644662390024535772058360495972689995692264619118050620984863397335883147741001175137837088856196207660064061839685086120444324885420172384357780225067863432546453923434326358834374021700709153791633034800554630092122384413882780201869241166113270104158152592921242256738530713688528178980864650875690860545577283508963373084295388766350046816560200649161822618828666606722223620871032632611",
           "15.150860829728925816270269964092673433542841210964830162793225770535551518840933315190406262273098573795238063523955485390896001670839635976377071048140363687808579387495186737492639543519534774851635101169579614712607935494886581440494071142193798729857001548284675533558490478467589884332536443679208006567281631805562767928329937083844501800478013385969649342207304490375728237042482944784544838254",
           "15.324883579506436493570233597448883519693351814374549397498489035148221882270042436654099306811313261346823941672888447313628931256927773946985727814886420570056552118783468127543676769633344136209500636666830026098080195180498059221494203817961212365532443050015541947762494604799890429565189588245725920948145579035449699519788465993549043152027361890729572024195346130030456992216388648768722394836",
           "15.484968991583560712862164152602532972505596882865402498065644250737301955125596006515274461619204302558285733320299957799185995441209009451408808376560872924206710117585718578727591708553957297729203457443101522435265312291388453827953066056871634785359329503731609907767433693085428240202927311226115616775436485821324503901092891486358733365244513748729928672060637178808283856096451123227237766837",
           "15.633184933296400322886411216914351313442169047575854720677392808712745585778888867637029115450088924031428350724038141381219620588274493330817678181565157141965018413952386880843987389414299029950277357119925470077396582940505069596480801954154029286187951921181728705116872415271634077604874063371227144842898712603028462623610688275714711124501733417572553751110494225479183571648948845731888607993",
           "15.771170674177108994750017157264759379388540187789301748807798065200414118407271774235601089093934343495795521812477515931432709195503245641975701807702026215615357450518151317247119115864533992757135781852491298348627270712291588580073932563653614422839620206266586292520948221873093053975823776289996754936187304352159896156876771015468496811587576227636095095473566772184717633945339405330371627545",
           "15.900247714739125237305645451417508966665591345786220672552302840334525160137723176098165167253830541655084109190400464710649206788771240950251243759258268060695212680017248831015574286848979270728739089100870231114250075432989803029255029492399141798408644860336753530942734586654467728627658977642688053752033223720047083446705808444218983029996407752310091763448795485193086044050699179075227514085",
           "16.021496956952197922992283502641894579962626483154818954043789565712934054541190510263229676242727892630672492409948339732534439120465067507199758379167701667321617794907607307728874859663168072318224068053703928672394393376652024298292046951118253912008558176064907492479298408285769067404165601995001682495873893492451380569168665052480684672167775365328449822100602627386235888117607629689989295358",
           "16.135813783442291449575041100809653925479234724736343542177079039059170241908162244448865517513646317913575323823536275208044355623776985732503939829900060864487127004364547143183319169525031486430688761890355067541570726092642869160866842639424318480923069734468346837396224375681293323049896437786794370196393419740684520457519876260717581058279975484300455393801884203407282602155622048760192869731",
           "16.243948224975912162101874242338089698927747514172297963501304802721456885123447742525917146000081948350317670558217990170315910524955950657647628011646020228669505156094231753926456488583104510177838897523717492728937537629972877557426292386450904986250829454391823373783104867874948543639133365724217397301073161382317429508046689262594057712721480553629716238053162259132557499326959178271755311819",
           "16.346534812891312020017737390565972522861639520956794183631801030677318559517349930264816297286373068267542772472219372292428845683416042271115312027071601889325060155482892443418582095080544516697369324049179348198348320350032057951783059238791085449471373733253488008998200818236407442435705194113745206455080467406424910471012832247972967952311217374959559350158619575075500673005632848486334892081",
           "16.444115140490340128500589643685615592593325439192231430163649023292793816677629077048173396104592590442505550803932707806677495894373323443853064668488945973357469342360809555842080876327526869093152265593359032627507962690981132695345232937664935403696772586286371082469152648334224734697834132478315542287352614722743239776066558016553826776123247656549922477370984130115175375533899599151832866777",
           "16.537155171118865136534989063582757364253199496897225305411818162632163606557745471767961160436879104964882723479325928591604518246962419687548390063992529356693298596378658322800277364077966826234091623459656551097008920549618056923279473982070326894236928331513682937597704431571923632859325944958271156630648510192786810276479282782233678225160061893949554276261365074478039201200141096034185340788",
           "16.626058695701082390621404187251773798561764113151150041596109882112467488919141098521165822165293765039118029510544981683905860141438867442019067534265891760023149100317968826679154566584457042877767867250357368225093921585968539417839705388349710086788853906351301543791493808667435475597486845630653110450254081800953162013336880338884388603160347478448669890791767227275369657780841518987171046251",
           "16.711177924047687436041681081297469757517395732698719962499711839818824068470368594816509809165130772248099176990649818696451892735033114399817499272685517472929769530848678764490613732856699010061350335113220658748043901782349324603111802594973838523650919828685995473213566914734286172266839140529583990377667556754261878256224596588519392559788652514828861263680954096492024398529162625680677258884",
           "16.792821912654942574589969785414406627855177803111176492774370259331640542125643510644899208865670120639893723574191986313708664152776559897034386961403215067476041927571306948209653637016541256814370701598681758297129259567548154765775910932763810160923332344469835976310776610418278334876476195529920021337399751846302536974621623453741347064741080510495703994896565552519309503521053051550623483165",
           "16.871263338577273117049933407315211807184894736082799946337588399915643695388836578819581481279897851015095335198849942961931601540668917787952832251688896660707943869197097893837964754891796695592066084995854170120209827918603483811654385230282025426754327077293929504883381435192439219366582495078959939830875435944938000044089717015334115741229281828493468876793032191535756728196375330663180727281",
           "16.946743994200631806033476403925371852051109645526740171061759524387799979304956484613870531865187139791227191840781754383935422487885452369507952721547705027535773654885832127821314459521240798742974634464887793874048016231828535132695506414037947185201173465247385982934992490469404967587724592554548395276895353595409898385619478502390678687463962622836411208115179925881515699871702165077675857036",
           "17.019479282236065828727803356580529388797042464710975507911282243104151862598751845439937481303609237769338953879291798328663979939210753132559510492288100384177867237190989151135211416672909332732482371326996189543048703303285313799031214641216166381411885795576234361808712082618702464622338883787915216150436372783047860816587095332458688921705641277515576461385290501276378977328383137813013202605",
           "17.089661921583428533920885090473894674921519340994685086552627218992626938319872359613748323826158856027837200411438668460410538403836237956276065714403575420148736981655027235218177614075251822388622713232585428029969533906061654341819894513492491624632974192525592636008127939368987600981961744622054023981036109865947530952316809705151315101400446930619393266624895135955182323721805890693892489067",
           "17.157465024686670167940702199808038440453826682770881229464136716214305217066325160993039686330328188786987064692354236198505670650108871009195717920051441546822338399371747349503874711833721760676087218038457960626001087951737722106836691584985009357268276351001658789309901363541541142239028890280836555429745898638761562947010206765922958485242984359891337645169887782296197402533921841201821435322",
           "17.223044670108153088406971612680579462250390145455205711423224535559905829397735171751863831903325186673310251936245608147861310604382786127429364616442074955520795624793164764110780962566943990430036624945190166480864873260501647262851147587875798742974124100786387378932173276365815649310057053480347330487890156980245097594505867694166591312545929965230291418670445516669557156689966248314016354044",
           "17.286542066533530981819924644041556546839394128235306235416269038138274222049809140847092268150839206354707638710275634022335650694777681817694798501418812448888688173373947001904190184008892957674606496333161081431327984331509197841574297574788702287443502123119313877415278877304866456565176360773848651195816021879148876985173267277031263646152871873014441183590471141901167533828621963866651938359",
           "17.348085383681499172852340212837946913681349503319833895379599364916346996678774115472356552172467728498192423708290186696353892633802275272186862935888864564436104200250553583802585096479988444811879111645109656880728153108808638274341978968354895482288870990505393394330150686285205409461910256828313237800771316014620729111128197408712519655232673726993167731090657784157432284844410962540306871812",
           "17.407791309811451413991402934776587727274692304168979758129844486195147501475844430031581045491342304862802756719012802717759227086944920237646742600183730387935914237410099970497154963215669635477250725760034883360834134873909027143784365748082991457136260982918509631214089379283854791699127985575276751950639814381413022404340898037317031344649130788109442934133748721229332612763230675387867060167",
           "17.465766383402858316731575043043871754932551869660069657366289253587674381952187793692876332186097637634087898052217367730831337525450143144735163993701984235559102178727289467801811444923511321849112339058962832869205150513708620081533545907748750224381419445198858131583714181742840318906599828122743306582674187117835956409356596804579817623463035229848008072471150460106195548408352347746742847561",
           "17.522108137193897711249955720342223562404817078270264273905715197834637314555104238731504974899534359198079882854402652102198388084110484760619705504323190957788898675675472299192322756141627162323541713415099172067523105704142354142286507565791349450889277448545966302507723270185283899864397011417078910276215036241179611950839739662625626455044878609357243901835302874736030320059872773022839076998",
           "17.576906085439158795399613853863097303860835367703382634217979275105020336999327656009595436350031662565840865227976662242781789960872250051998481804897622287887086985238091438506085053631982050247194140738539987379268409303934286420729479452837709138518786355198810012076646196653084861659638299340083440855659993917810136693887499673110592919880225890667600561450738971059427382635508450091570097859",
           "17.630242579482716539323837128846626753956194314343736063283695118187974605321998609676585457221722093540967455603842712855190915316171267768551204188316976169082878976713161041600921069589708836776259260899700342542761959107817464710887483018031112156977258240064220687983570300417350906046032596793701224117336432612122346984445322343505811317200044404325245524587348610225714892960184376194438742903",
           "17.682193552177642930469311075041540632454794315173833851548924954045201903733019976720709429894183669091622069055829864963447674638381460850277690319942206492046322144914184638283615681017449686491773099947404077379395563267125512703092895031616346899622091168324459335139948282486097513426616067084251033517363717148785943762510534333490466778398817865864252996839848563898275763467374270388303474531",
           "17.732829168042892302590066897013224260526349617442757064898532827287653373154374250085440081248759495538523122114463120786358068331952209807684385821625688206899889794184992102701935895298679767555036775735985597715341448247873700759325978422207409167388561946150223833135803435044691082980471455256218231653367433009869225710546713847446382266908465706428817510556416763430212167661925983678317689559",
           "17.782214393127773091907390576928321922818609345162469668288248606737448584265787291899115365824350981071781548351963523796289812496283393676088371363622146243894946956855177324929267339605228930435844698103907214217720043808120931206339233299438914243909015437719067832873971853535761149326746352476616918607787268605165583917095714007024394600276277913067861955743579281638075879563801550521361400101",
           "17.830409496196797333256263738087407756305793204876426547866274663003566432384680240879632999625725708300091127739268764655234592101254713785942646078437589939733647676861210608435791914827456291767449764007558390614584486670558546409061408823289149666666818024559557140308187730981247373784664587280435856629009596287509432264978977660915985852234235063815941899607957940727152099219426925372856581083",
           "17.877470490934232288852811743259662703350866532641876235327240424382634438025700311951299570329496669487738366928514133455422447732866797861412283887178678146519925852345567722230587799483201967913067391020608007825990349366451164476805546339769760220805534987675878347990806759564468339408725207557557011408435539499579334714364702076041798486860978860009676392441269681660376828431489832998763783258",
           "17.923449527306267869903426070004616586122783729793624019886904269965872168854615384174781325332961537402467089754136043237824345234828497017675462013908498436584882632257634259557543282397560432131425953734774375224901224027834174376390115551172850840545446370919691863863162138436779349056977625063368614038926314141157758995633570593909444840439875814859101692914284555504462737973961801589348562421",
           "17.968395238938123096275003449517382823058653367901994410453731720353712579214128295617333869516953666517153266184450063833611730223713367177888956257642697863674682557764474491249664869634869467450632518845976225157445436929203774807794710993549169067538180609230496568688211520386012533845072853251411123534511690847284034061828924979836346301147669327210040586682352268581578885354613616677879192008",
           "18.012353052308072938755867264876761138384940766536728123219303502872235608220456049765985905816906980541771912193578395286636524639567005562096644259687421270993689984646487799760867557580378976263785987858028882916593402367582926712749625025395229096162602944095765767003293442756802839571379406129666952518296572179431801499117577022831811590456125422748646995266409456422225586206021840322692382857",
           "18.055365462686668331727160748231009519565746647193730385530909331597852334952578425145279427250887034166658709337134491235522678908221793937220809954557808901763389178392831492051282059480629151432246720826269576988663211852119754955967569929315382922357289706041278636253185833298598511399638105081736687620508948263244525471222947804257016135464845038301780535378180021273347494295813215232102999649",
           "18.097472281022918092839876166164329437973263728374666387409900363304423095913608188979786368122872685324785740303523457754035383735336598870745063200445496969465305638435393742921093080855121166597064087151732410717510776813994536867846471600876935467557239720329955864393503091522335217308468551898804050931884864074974187930869095426636541733964836470414482229854405996155347764481217202728996408614",
           "18.138710855372574931023279730094645378686287349356676919424498204049762635832652703081045863264164065707461503608812437952726945167389204858679677978907656542126675434222486013764292798698974541262372833651362936600851261171024940667498778746253799866490414715539561648775214507198558445051277115507846030240001071535504590488750762226492938922487331198045407471864288427126708589240674067562104543957",
           "18.179116269955114571377487963612019905652085216126618591531831326851631273535837433851652060806307371522002942828348086254592323263632131183438294055667010855067061587674644272103122258118876651912890486407250279668447142712674562099014392095571206458285314302909409592642841502932705416119595372330139185232535836986175505626716905102551635720868328845059106716603941432470493828723765413424721976223",
           "18.218721524498032554193215680552580137491683034589488437319060302272592206508827557611431375182704552154497537575444766904464774327453349109721410510507102426285778233008253433639863695380913463970388673098705619991229471182831382051550803100625573309055088036785775202381313835883262855970305798706681563291905495590616431781211404743717763365778127660253455212146746026811363929209719531660648504082",
           "18.25755769616561915104320634671335949819923250838247367135480870103002754055972575277617781066800125225275977232426410882766773084485826986957597205108505829168630501177398318211279559799848433615486396320080576991739828304477785924273653352846964138446264644904849824507615174857436913763769835408524950658917536946876135419383532210821743200063786350760207420579200676223678007228393958258720083932",
           "18.295654086063005239961930900603578763176327716162022442528659338478895027684612801134718048445578078864512023650622689532231640803798279071247213212940626166721703242773412064293396910008891332614727995930235839898502680907757808722725076622433926254807390507349193089487065273859422711581690536923283818694448490391002663699373577479984089586448960986922914070154319198856799480586814831572660049059",
           "18.333038352045729366070360053860247416881993539906325936417001019639836810235521744851872438194534698737793818113182566661284551265375926400252096198917463166081789346386579278436021220544269108158036360716265068681920333271695665204550361645092770414267870574761534021576748772414710332296686656677922105572480136623006540318287771752403257225484193416375374630295739694584359181669584822144217946089",
           "18.369736629342788833545154829965612197972030184654204521583836723612431388284128470120361520079152081604731214550025504583810749093225662462708297813392905679444268263153178673045591535099590243771860299493196201337328463166245762316637806913270164277457975112426005180292583426915918675383435395598215385153247994877265654873384456838948090969392401887506081626510459117637684719849016393221041720966",
           "18.405773640310900146133080088261946202976690317466294344672811637024889157611521518848738302063682147953709444704912322724498748005402509152494514057803322060491136048741666988817114427555111210963923209356023892097003244960804568051496345885676927757469123572277620624446804627512970828422692616021227425852662243212443997074981005547833762050079432581680067106949297497692327125068990077901522226957",
           "18.441172794474399698182030074721740031645602552534420544604120821167467838337449892992771747357276011553142091110875268371883702350672621604391781630952792517951394285585851496086739721764180588422789463043949353454011941863375479066641639870318143091000764755109263681792932398864353035859720611512874738125344871434992639512151401272538083058455878170262156351968871089395179837425273523581266914745",
           "18.47595627986464597709414934346663732189241252367556916529377819718435871713823800089497791390570676646849082185155969226893554048129639509679051447135722658187695404706235925157146425104283059827944524324932672824661552843990966903508121362067629390223781365207266998003720499319458536728358620338853555386727837290179454339519141841532839938596761951045619471589862830891354308681626977577420483375",
           "18.510145146551442627414905806735913567003712650812295077443330836708330498077617580007887630002806998527489958357928811323358164284670780912045286972377274734553167811143903532773133805470585887337986897779623231393980154689146471547983633489101760043708991315746940120025902341173853793429617026275691215584867628750464940410772709161351434979639911956946479201132978330304672548030931942250342827294",
           "18.54375938315397840777373858913955248239941847920328667581513228848814216209238117867823746808674105485439472281080229047484288277191323337476914908731578203036561093352990739771860442165984753982600021729206737097284114048195126812337180690412756158211962923840645830361425158816448002373708570542607328640280411811505735178290827333249222248570577590327817428193141575383830773736064963674654660788",
           "18.576817987027647186937851258336640937668818840595786321214115700990580993937301728456982569596955182509352640277092493549853424411966677818012248002654715239100874590037738307469713048325570874520232570867464224788639656453937494219294174471955373301736672685268384577575584576576899158917424074434177408506824723823546414342198182263466224674661649356568188397290822447447185825387180657594093708751",
           "18.609339028743835443520046961477709286939310853034399826433866146117641838882532805452792636721283076369348347017617290496488517658040508081002292362699460963188796636919359563770588812590411785597112719721757265655201721601867128800954165396591923271771796713301912904158675092529178443570927414653982088273331584295588174225100793199329706639345162173054259175639620324704962515101988919574683797276",
           "18.641339711410638424722499047013449967887089663871032284600678326435618587023360889502435665997102476809993062067289899429492640057255987173558009597289702007868879986681400023832856533473923548707096670227832737339287908558274044368146372966754230837592655179154123960009424338853507410779228164259856997555111697864450713171508666161000757176178710802248263025585993364498172063037657704404452535503",
           "18.672836425322050368486113163967894536152542145032787472779137579977190277914128508177973702344749215422866489255932015284354044054928123475206880037062819389112504714106095639732288437854189846017324055713142277768438434138800721340366655917386856186887417022606078557020556496094324427190459240576788558291551699271849591355480496655647717244614207638067307680084952591605729876523430439516165337322",
           "18.703844798370253311556748128890196309240890383998201893987314003630502067675284072677315790931434159739316058047067634433988116165753705089479010402482501330164866808933095532965233351834719435836698735379881853925522288987702030512098787246242665060494288818182785084700362957305908534097737840396555283267034806128689898134337131513408714563437722088348519474128730338455257510535561818243515295123",
           "18.734379742609172948695846511449581634565683544125106511957075355113091757584835040550323433523983103087395353257534872811737536865777209110758107808331702363999663358869296693765232701087487872606287651215678117982769333263424530048349886338191672000649776344735688777038908317935895545479771750928675097454702913124841960320021274672197296187088995346243239131294305233657221950357770047779041168948",
           "18.764455497316603659697964676682244441947566581055018250974850982088974686459881812049067093753928158863642280317022246479491132048354932411165733919156970301233277913734990931824860100667882748928084034147822613522025142522120240087012670818451468498896073922908905983528384054249374818979283244638542138214163225714979901542761366770616662189716515808719831023436094002277345660650710470976214503432",
           "18.794085668866182740204823781307373749785233327862921970091261536522099678420128101122831261188800902247301052497120590553831148856384993334702795779266689462427228385943774192181671843132138022659399715350825905060669445319905454600530058604054055511420322690455781203696250448217551628254838303648547201462249630753150471851402187751539728462449395082445265630322991793425964521071134426892761087686",
           "18.82328326768867946516209716586995768024335839807194833176766112965627616145648993732694510000805245875257813926012495009414082293067923695618654400188454857448056930551075037023425200611189368317293241290052197494133870263300149851324237139757643613913686228545143709137199633423670636305032456696459165988858650794045361585281861601603030153235699981659298052458840307661288883784791255308752353561",
           "18.852060742573912900871064645288864648159675216435305629278797553184221367993840166607573470069267053513735624040087819326415506386854437946403720812228284865900153407303755694944652909440890918000505344963394853809579466102995490946923404655914747241389209313457700354163158136320973199396402856713949800424774426208733366034958384913000571799639761622099679737940788622933241370717844146251711932128",
           "18.880430012539655701065719740012642650514689061888847292472446317260576484360479108374318422256748212928421929786176000015552730066213309405093412502424231235041703778572229968621812094224953783751727048234887878221529796434400738059144871066371011576734445290684672478932371976691435646196856591582073749970279840730554499319160664075936135140351358832332481792115613668240634181554442075595951874232",
           "18.908402496471717232311467781165733233171140941896760455553034330908971709296619686804159498334964006649119069488646486948675866965781697617293443993292894960273992948681816600748607581132058645469709895004815813032481899164996133398853203604094641445335770040577643758444125343960451089873183667195183097301272165939070294009329717796749663916249651314647264543061678516229808974080105230884519025421",
           "18.935989140719681524355183827184271883117018713616424044375161718824065979531438908152091359516789236304421957752893530968312896089478807820652680723918795442056690234785900341761515097938048245785367391810983836804772037480360220145546699221066508593371664219887047644628393373836620900288539062774663891696384999640649150431067240627749142322666676970274474792135970231868616050929898319819448939034",
           "18.963200444815204167404888798469665227431788358892299847438551435971105813566329353339851076750530262901184430318825907802984559086828099838800823075902608236275943927671387049630228757166718632225359114181378374769186216486342164672374303171089906235756037703334480067642792992542669516647312965086899057259968955796081732571906843773036664256360263051447703790357359429377002031207739864979999279347",
           "18.990046485464088033353325238570094871523592746407402454864447659438418650897352188003827603659585905257296788261872980663015351591030286798753545075312871886708540373690732957230479307213846083134185408782477823043603415914158563765104431367119681516469558190435321626296408405773925785846797696565762444462069369032104851518168840362055319574446706630124442642806832354006488607879109906061011225994",
           "19.016536938949335590921908878972071081608578803308502271146163132935001206102423418117835863551157682291011036313549071538079474102791095379250735204641651869626255407971202952320707788423726057706822543117840676308428340234652209177652929619836857962138281947043694787969753375808877555756525156889419987622193160096718082756877689454214937644538436622120458515758071395625444960838247998451767464267",
           "19.042681102069820040323211057777714109150558076228575985448688497208727928412122242888431932498284067180966108960090928128416538326586163291672353531766027111567123306015724614143020205136706498507055346813817986209642505418179828757157587146552894936306186818734849750397304488535715134906592464324381660408650130874094490704788761416060096501351661608424222204094369103147551037672603814369634649173",
           "19.068487911727958175697030382906549671323284692477975980792892280404995909757933182996822232452584791269433004172376138676679805214029937405307084300414313959313789831600985178255638111559270519906326622715617717964168412002699242926437873012736620082535900009120622005729068876661407020205549742970102634687260159098231611555026386636952356914915597529253373429394903680674472796958663494038067669179",
           "19.093965963269656159901801532857652686731313095114787279282350143184060615248880952958892345276101741792959203039945279273255821413683057071718873479055914318955623580559627285483449590741119271240498698177664589148961791164562328382134513604070535948997556425774535241433839196056647337630745324677877037589790564832932809741759428622931327986353687891898499439791429917840804474313864245639140963876",
           "19.119123527670705331793258647026174473061813878914781070641605073424527485626683566355878191198143709838509389044950724156590593262994411423265514055870555330957166471517671117689943118929441254707396532385048466111853801352620946858612646592880180562600210076019427990165200479741063391057955342589569972650353707736819649707138135073772494722116787681314798945037658461538374603477221825614061123586",
           "19.143968567655614969812922707872905228504499895574401195919290684664632292543319151929670686365568982588326143748358606442800755409560708661213139514248609009613770051771501624762852458893105259920477327438788243371302722213272226600736522283567127277667156871770413468147870394343816746792945999572244176333552811712447483231232773171106511438260175071145300046115843401710072061507331123043607901766",
           "19.168508752827482780609154136923082745746771414212427034681109262302000645968087085215520638009496537393752178754873475983837687377025695010556483691979309217953419255985001727184619660158435191823702770674175581797631578786818852604111682506864006199186805540809913091091561814668081471402749434233431033452441548505582706019452955567976154397574205270457372773342241946969622998755580434262211071558",
           "19.192751473880834042563713562225153433521577940186973776803866639536641104273721851582869330116346851241224039623128541122821371810756925681002641212419779923811384320279466454221232217629041792882431116499214977303106306157966687858071257893713340199820635963233697984370035461108601863346164084264967404520613456100656965925875472210769471793070984755357524002396981276686789870757739219539841324669",
           "19.216703855963329593992083348877341510356872855419154524286060224198192164950344042194924570763041352943159776496534086655621090662648765929073480563926604513272233491262353914647091955902924297702861031248271549558718609763974479507490837350364617085882753391176792131259310397149374028556893735115741447201974608383790314541221313482249282941830681505989160209022143487123591182161037084387107577471",
           "19.240372771246783136336288622974117018573581443774444767997147210768023102387819846722491865244820295698055584478151667485670300985795814036287612086238394489310685917822308982062485897587424683040075624404469719368214374255580054164790522993745386564072906888203344350441788631572056395846260169628655731587443716443908470481602481327796867951175756539602824534024677208143458306390998693538144276002",
           "19.263764850762979509196317705761686108092922892356892210254799469999751475179529646750512177469718303426094538082717842694993912366018532429385996195100165328675330327321101942399890523238950583083919577089467043577581159099371618262297126999910295820866611740582812686480215151994304295620401944519281853807987442610790122820927006439539980791908595120476521299636624843377591628005484740938263373595",
           "19.286886495555294522450851525927489255646333848651043717882790718796769943763203547772413744395083720600670009266257171342692898145198064660758379840502214228374875168690401725272168814130387964227940171355345107459707413634435078254467165459318134413588306046635342334572072865760417877208230914828250259039270224031775041480686581149991980042698893384296012208438178584526032640636530664689171174514",
           "19.309743887193036513569909003754932688390195189494409126081957694707453295769725463252527373922995550848707616892717734716346726926003376949988744940329952938435722400261306789658518736487435455592323288866363564460056999876237001095092480820045715217327131479089102764865100373961878408215166685028270522348153253852064527393390794401890890932406298166622224431486187051653736399833197687524233000392",
           "19.332342997691718269365647851051829244300572144237799985690236148794296859647334840581772744190077146167636205171422529047782401411481872480699008041273574144705390909628455554205882856537701103044535844002047328262877230706418721410147702147287802942241134713881576962004492246225067150128745210304021219616585555420191917418786300056829952680702638022710700076784220324428140020802898115083347702904",
           "19.354689598879088211883278917315015191222443867565368209411861608347893184500809153071123456883339348988675265028178228103174790923741638364554293709103213239495123865898742141584076941660965692453426480770865774436380303703020587851939728834028918714275983773159730132531253761589283704592841895713231304417993106469276962707965968679020792759185611101812841427933459395519877074670185732532077876915",
           "19.376789271243668798743209719830951710660724013826759987563467708214368337563307069810449676142525612003499201086112645501159094078378318648014400550345870757023544381773094826620272453238529286555419097429861755219673554476395943490245768513403194721941361801918811127988057063915654267554707302094460700078255016831241731287084620030531370389406858605301314913503432729894455360413554796057743624785",
           "19.398647412299738536733101983020344760416543000933452586938357216391679714568872063480206587627849607725892049860100424409512218327903976557192129920072602449053963631370720893361294311430877864798057636106390383386608343478253049758287190639090148001663846660919016228401517981946486814580501445191763231914170223651871543954569563229752867364010807484149328122287932691728836607206296504503654291916",
           "19.420269244500125639443026886412358511499173347101740173789245348545649777799992933455717128782979425999232096035698012165274922488616903998818326535687811364645463339885951676665882203155018792792505473796600843314336576346118972683035247786115152970665197263535031125663311669153219106967873840911780618890220192918885584791820817380351857621444438732170662912318105800373867459654881916254806601924",
           "19.441659822725832764853886827062860938003360575287073851586808019473777348197590834815623551815029267586554639358825375063360984210103069003729612683914916394217674289812465439813541316938870999354861402160375582810342455043995730819816948505547453029096197833928688735935982538915244747599958654970407704104602569366784225221531104839626781845870092648147888203880688567605208831444945817857785153427",
           "19.462824041379362514202453738329145059871795167945778128620896576209292571177865023083134487492542931078517939464890630420523665550799939651548618906955780515811541533057671943504991862669514142328738958049297858093270685582461594213632344682911288013670395835728596839923778216755784200501989248577166652556656745561631320914185098036550279972269808563352717494278133064808018424486494613581670904697",
           "19.483766641106643718481178395114340475919752681994355643610181441860832131581914604665304968112958314746911243491535376957183544987386808635080341126118126364286470448001964590403332961518317007864293940732767763315935539659300785943459751426720740528037173390794501709108627539732588206226415399674048608843262175783293190807110169521287571898125826758063922707869247389042070537305271065057452360137",
           "19.504492215170652185153425611551614568097792837031617515988255748353971463776213613651972980845739009653411602074763823583486335276886222365741099356087975815479321535979397651959714956358141934399110351847826398926624666313434326948757230737160647513320407575743953348133831681915668076630219831345596329489041495050445409516995558844346940248424949708046529076568535423815692145534030368195098701895",
           "19.52500521549816144973266072401605164852396136071234571245810367391072812166019661923143396972741343266046339927362413412251126099193801965681827360699083448218860273549526903661234475357554150017778848244185893299525191263899191588797634058235164494448438674653809951435022502560679429105527325418829543863756825670476364629140951247734867887985343458291386040322597855003211338820555010939867273248",
           "19.545309958419535630089123088329455125777373731767323301911891787605488456921558805681207304272616222501167615837357366396904683096528060072684210523189673108467018417135186800678628444987751206147451054525963839562634340820804697604369657105969423354842149829173951943549166420900709500398322624130365195674097282456714104812933002700523506427441210494461469512180706693823193924457440917371176532034",
           "19.565410630120075532420489068555321524954362381908007338302983473268528473151341321768804731192210840056455228388636731122203200610869021021871133154865620432257415783302175345843898977949742849569372169004904667621738405749986270376895267386643049526766451459390277406632576412790748533372863644721976845168460840162066672290292749672668879524315410824251032084115058493720402881895485689493165441193",
       }};

   T pi    = static_cast<T>("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609");
   T tenth = 1;
   tenth /= 10;
   T logten = log(T(10));

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = boost::multiprecision::log(tenth + pi * (100 * k) * (100 * k));
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;

      val = boost::multiprecision::log(1 / (tenth + pi * (100 * k) * (100 * k)));
      e   = relative_error(val, T(-T(data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }

      val = boost::multiprecision::log10(tenth + pi * (100 * k) * (100 * k));
      e   = relative_error(val, T(T(data[k]) / logten));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;

      val = boost::multiprecision::log10(1 / (tenth + pi * (100 * k) * (100 * k)));
      e   = relative_error(val, T(-T(data[k]) / logten));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
#if defined(BOOST_INTEL) && defined(TEST_FLOAT128)
   BOOST_TEST(max_err < 20);
#else
   BOOST_TEST(max_err < 10);
#endif
   BOOST_TEST(log(T(1)) == 0);
   //
   // Some tricky special cases:
   //
   BOOST_CHECK((boost::math::isfinite)(log((std::numeric_limits<T>::max)())));
   BOOST_CHECK((boost::math::isfinite)(log((std::numeric_limits<T>::min)())));
   BOOST_CHECK((boost::math::isfinite)(log10((std::numeric_limits<T>::max)())));
   BOOST_CHECK((boost::math::isfinite)(log10((std::numeric_limits<T>::min)())));
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_miller_rabin.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
#include <boost/math/special_functions/prime.hpp>
#include <boost/random.hpp>
#include <random>
#include <iostream>
#include <iomanip>
#include "test.hpp"

template <class I>
void test()
{
   //
   // Very simple test program to verify that the GMP's Miller-Rabin
   // implementation and this one agree on whether some random numbers
   // are prime or not.  Of course these are probabilistic tests so there's
   // no reason why they should actually agree - except the probability of
   // disagreement for 25 trials is almost infinitely small.
   //
   using namespace boost::random;
   using namespace boost::multiprecision;

   typedef I test_type;

   static const unsigned test_bits =
      std::numeric_limits<test_type>::digits && (std::numeric_limits<test_type>::digits <= 256)
         ? std::numeric_limits<test_type>::digits
         : 128;

   independent_bits_engine<mt11213b, test_bits, test_type> gen;
   //
   // We must use a different generator for the tests and number generation, otherwise
   // we get false positives.  Further we use the same random number engine for the
   // Miller Rabin test as GMP uses internally:
   //
   mt19937 gen2;

   //
   // Begin by testing the primes in our table as all these should return true:
   //
   for (unsigned i = 1; i < boost::math::max_prime; ++i)
   {
      BOOST_TEST(miller_rabin_test(test_type(boost::math::prime(i)), 25, gen));
      BOOST_TEST(mpz_probab_prime_p(mpz_int(boost::math::prime(i)).backend().data(), 25));
   }
   //
   // Now test some random values and compare GMP's native routine with ours.
   //
   for (unsigned i = 0; i < 10000; ++i)
   {
      test_type n              = gen();
      bool      is_prime_boost = miller_rabin_test(n, 25, gen2);
      bool      is_gmp_prime   = mpz_probab_prime_p(mpz_int(n).backend().data(), 25) ? true : false;
      if (is_prime_boost && is_gmp_prime)
      {
         std::cout << "We have a prime: " << std::hex << std::showbase << n << std::endl;
      }
      if (is_prime_boost != is_gmp_prime)
         std::cout << std::hex << std::showbase << "n = " << n << std::endl;
      BOOST_CHECK_EQUAL(is_prime_boost, is_gmp_prime);
   }
}

int main()
{
   using namespace boost::multiprecision;

   test<mpz_int>();
   test<number<gmp_int, et_off> >();
   test<std::uint64_t>();
   test<std::uint32_t>();

   test<cpp_int>();
   test<number<cpp_int_backend<64, 64, unsigned_magnitude, checked, void>, et_off> >();
   test<checked_uint128_t>();
   test<checked_uint1024_t>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed.hpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_MATH_TEST_MIXED_HPP
#define BOOST_MATH_TEST_MIXED_HPP

#include "test.hpp"

template <class Big, class Small>
void test_floats(const std::integral_constant<bool, true>)
{
   Big big_val = boost::math::constants::pi<Big>();
   Small small   = boost::math::constants::pi<Small>();
   Small small2   = boost::math::constants::e<Small>();
   Big r;

   r = big_val + small;
   BOOST_CHECK_EQUAL(r, big_val + Big(small));
   r = small + big_val;
   BOOST_CHECK_EQUAL(r, big_val + Big(small));
   r = small + small;
   BOOST_CHECK_EQUAL(r, Small(small + small));

   r = big_val - small;
   BOOST_CHECK_EQUAL(r, big_val - Big(small));
   r = small - big_val;
   BOOST_CHECK_EQUAL(r, Big(small) - big_val);
   r = small - small2;
   BOOST_CHECK_EQUAL(r, Small(small - small2));

   r = big_val * small;
   BOOST_CHECK_EQUAL(r, big_val * Big(small));
   r = small * big_val;
   BOOST_CHECK_EQUAL(r, Big(small) * big_val);
   r = small * small2;
   BOOST_CHECK_EQUAL(r, Small(small * small2));

   r = big_val / small;
   BOOST_CHECK_EQUAL(r, big_val / Big(small));
   r = small / big_val;
   BOOST_CHECK_EQUAL(r, Big(small) / big_val);
   r = small / small2;
   BOOST_CHECK_EQUAL(r, Small(small / small2));

}

template <class Big, class Small>
void test_floats(const std::integral_constant<bool, false>){}

template <class Big, class Small>
void test()
{
   Big big_val = 1;
   big_val += std::numeric_limits<Big>::epsilon();
   Small small_val = 1;

   BOOST_CHECK_EQUAL(big_val == small_val, false);
   BOOST_CHECK_EQUAL(big_val <= small_val, false);
   BOOST_CHECK_EQUAL(big_val >= small_val, true);
   BOOST_CHECK_EQUAL(big_val < small_val, false);
   BOOST_CHECK_EQUAL(big_val > small_val, true);
   BOOST_CHECK_EQUAL(big_val != small_val, true);
   BOOST_CHECK_EQUAL(small_val == big_val, false);
   BOOST_CHECK_EQUAL(small_val <= big_val, true);
   BOOST_CHECK_EQUAL(small_val >= big_val, false);
   BOOST_CHECK_EQUAL(small_val < big_val, true);
   BOOST_CHECK_EQUAL(small_val > big_val, false);
   BOOST_CHECK_EQUAL(small_val != big_val, true);
   // Again with expression templates, on one the other, or both args:
   BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val <= small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val >= small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val < small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val > small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 <= big_val, true);
   BOOST_CHECK_EQUAL(small_val * 1 >= big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 < big_val, true);
   BOOST_CHECK_EQUAL(small_val * 1 > big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 <= small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 >= small_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 < small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 > small_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
   BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val <= big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val >= big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val < big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val > big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);

   BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
   BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
   BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
   BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
   BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
   BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
   BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
   BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
   // Again with expression templates, on one the other, or both args:
   BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
   BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
   BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
   BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
   BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
   BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
   BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
   BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
   BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
   BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
   BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
   BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));

   big_val = 1;
   big_val -= std::numeric_limits<Big>::epsilon();

   BOOST_CHECK_EQUAL(big_val == small_val, false);
   BOOST_CHECK_EQUAL(big_val <= small_val, true);
   BOOST_CHECK_EQUAL(big_val >= small_val, false);
   BOOST_CHECK_EQUAL(big_val < small_val, true);
   BOOST_CHECK_EQUAL(big_val > small_val, false);
   BOOST_CHECK_EQUAL(big_val != small_val, true);
   BOOST_CHECK_EQUAL(small_val == big_val, false);
   BOOST_CHECK_EQUAL(small_val <= big_val, false);
   BOOST_CHECK_EQUAL(small_val >= big_val, true);
   BOOST_CHECK_EQUAL(small_val < big_val, false);
   BOOST_CHECK_EQUAL(small_val > big_val, true);
   BOOST_CHECK_EQUAL(small_val != big_val, true);
   // Again with expression templates, on one the other, or both args:
   BOOST_CHECK_EQUAL(big_val == small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val <= small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val >= small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val < small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val > small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val != small_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 == big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 <= big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 >= big_val, true);
   BOOST_CHECK_EQUAL(small_val * 1 < big_val, false);
   BOOST_CHECK_EQUAL(small_val * 1 > big_val, true);
   BOOST_CHECK_EQUAL(small_val * 1 != big_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 == small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 <= small_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 >= small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 < small_val, true);
   BOOST_CHECK_EQUAL(big_val * 1 > small_val, false);
   BOOST_CHECK_EQUAL(big_val * 1 != small_val, true);
   BOOST_CHECK_EQUAL(small_val == big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val <= big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val >= big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val < big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val > big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val != big_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 == small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 <= small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 >= small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 < small_val * 1, true);
   BOOST_CHECK_EQUAL(big_val * 1 > small_val * 1, false);
   BOOST_CHECK_EQUAL(big_val * 1 != small_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 == big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 <= big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 >= big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 < big_val * 1, false);
   BOOST_CHECK_EQUAL(small_val * 1 > big_val * 1, true);
   BOOST_CHECK_EQUAL(small_val * 1 != big_val * 1, true);

   BOOST_CHECK_EQUAL(small_val + big_val, Big(small_val) + big_val);
   BOOST_CHECK_EQUAL(small_val - big_val, Big(small_val) - big_val);
   BOOST_CHECK_EQUAL(small_val * big_val, Big(small_val) * big_val);
   BOOST_CHECK_EQUAL(small_val / big_val, Big(small_val) / big_val);
   BOOST_CHECK_EQUAL(big_val + small_val, big_val + Big(small_val));
   BOOST_CHECK_EQUAL(big_val - small_val, big_val - Big(small_val));
   BOOST_CHECK_EQUAL(big_val * small_val, big_val * Big(small_val));
   BOOST_CHECK_EQUAL(big_val / small_val, big_val / Big(small_val));
   // Again with expression templates, on one the other, or both args:
   BOOST_CHECK_EQUAL(small_val + (big_val * 1), Big(small_val) + (big_val * 1));
   BOOST_CHECK_EQUAL(small_val - (big_val * 1), Big(small_val) - (big_val * 1));
   BOOST_CHECK_EQUAL(small_val * (big_val * 1), Big(small_val) * (big_val * 1));
   BOOST_CHECK_EQUAL(small_val / (big_val * 1), Big(small_val) / (big_val * 1));
   BOOST_CHECK_EQUAL((big_val * 1) + small_val, (big_val * 1) + Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) - small_val, (big_val * 1) - Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) * small_val, (big_val * 1) * Big(small_val));
   BOOST_CHECK_EQUAL((big_val * 1) / small_val, (big_val * 1) / Big(small_val));
   BOOST_CHECK_EQUAL((small_val * 1) + big_val, Big((small_val * 1)) + big_val);
   BOOST_CHECK_EQUAL((small_val * 1) - big_val, Big((small_val * 1)) - big_val);
   BOOST_CHECK_EQUAL((small_val * 1) * big_val, Big((small_val * 1)) * big_val);
   BOOST_CHECK_EQUAL((small_val * 1) / big_val, Big((small_val * 1)) / big_val);
   BOOST_CHECK_EQUAL(big_val + (small_val * 1), big_val + Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val - (small_val * 1), big_val - Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val * (small_val * 1), big_val * Big((small_val * 1)));
   BOOST_CHECK_EQUAL(big_val / (small_val * 1), big_val / Big((small_val * 1)));
   BOOST_CHECK_EQUAL((small_val * 1) + (big_val * 1), Big((small_val * 1)) + (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) - (big_val * 1), Big((small_val * 1)) - (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) * (big_val * 1), Big((small_val * 1)) * (big_val * 1));
   BOOST_CHECK_EQUAL((small_val * 1) / (big_val * 1), Big((small_val * 1)) / (big_val * 1));
   BOOST_CHECK_EQUAL((big_val * 1) + (small_val * 1), (big_val * 1) + Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) - (small_val * 1), (big_val * 1) - Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) * (small_val * 1), (big_val * 1) * Big((small_val * 1)));
   BOOST_CHECK_EQUAL((big_val * 1) / (small_val * 1), (big_val * 1) / Big((small_val * 1)));

   test_floats<Big, Small>(std::integral_constant<bool, boost::multiprecision::number_category<Big>::value == boost::multiprecision::number_kind_floating_point>());
}

#endif // BOOST_MATH_TEST_MIXED_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_cpp_bin_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_bin_float.hpp>
#include "test_mixed.hpp"

int main()
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on>  big_type1;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<50>, boost::multiprecision::et_on>   small_type1;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_off> big_type2;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<50>, boost::multiprecision::et_off>  small_type2;

      test<big_type1, small_type1>();
      test<big_type2, small_type2>();
      test<big_type1, small_type2>();
      test<big_type2, small_type1>();

      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100, boost::multiprecision::digit_base_10, std::allocator<char> >, boost::multiprecision::et_on> big_type1a;

      test<big_type1, big_type1a>();
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const std::exception& e)
   {
      std::cout << "Failed with unexpected exception: " << e.what() << std::endl;
      return 1;
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_cpp_dec_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test_mixed.hpp"

int main()
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_on>  big_type1;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on>   small_type1;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>, boost::multiprecision::et_off> big_type2;
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off>  small_type2;

      test<big_type1, small_type1>();
      test<big_type2, small_type2>();
      test<big_type1, small_type2>();
      test<big_type2, small_type1>();
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const std::exception& e)
   {
      std::cout << "Failed with unexpected exception: " << e.what() << std::endl;
      return 1;
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

template <class Number, class BigNumber>
void test()
{
   using namespace boost::multiprecision;
   typedef Number test_type;

   test_type h = (std::numeric_limits<test_type>::max)();
   test_type l = (std::numeric_limits<test_type>::max)();
   BigNumber r;

   add(r, h, h);
   BOOST_CHECK_EQUAL(r, cpp_int(h) + cpp_int(h));

   multiply(r, h, h);
   BOOST_CHECK_EQUAL(r, cpp_int(h) * cpp_int(h));

   if (std::numeric_limits<test_type>::is_signed)
   {
      subtract(r, l, h);
      BOOST_CHECK_EQUAL(r, cpp_int(l) - cpp_int(h));
      subtract(r, h, l);
      BOOST_CHECK_EQUAL(r, cpp_int(h) - cpp_int(l));
      multiply(r, l, l);
      BOOST_CHECK_EQUAL(r, cpp_int(l) * cpp_int(l));
   }

   //
   // Try again with integer types as the source:
   //
   enum
   {
      max_digits = std::numeric_limits<test_type>::is_signed ? std::numeric_limits<long long>::digits : std::numeric_limits<unsigned long long>::digits
   };
   enum
   {
      require_digits = std::numeric_limits<test_type>::digits <= 2 * max_digits ? std::numeric_limits<test_type>::digits / 2 : max_digits
   };

   using uint_least = typename boost::multiprecision::detail::uint_t<require_digits>::least;
   using int_least = typename boost::multiprecision::detail::int_t<require_digits>::least;
   using i_type = typename std::conditional<std::numeric_limits<test_type>::is_signed, int_least, uint_least>::type;

   i_type ih = (std::numeric_limits<i_type>::max)();
   i_type il = (std::numeric_limits<i_type>::max)();

   add(r, ih, ih);
   BOOST_CHECK_EQUAL(r, cpp_int(ih) + cpp_int(ih));

   multiply(r, ih, ih);
   BOOST_CHECK_EQUAL(r, cpp_int(ih) * cpp_int(ih));

   if (std::numeric_limits<test_type>::is_signed)
   {
      subtract(r, il, ih);
      BOOST_CHECK_EQUAL(r, cpp_int(il) - cpp_int(ih));
      subtract(r, ih, il);
      BOOST_CHECK_EQUAL(r, cpp_int(ih) - cpp_int(il));
      multiply(r, il, il);
      BOOST_CHECK_EQUAL(r, cpp_int(il) * cpp_int(il));
   }
}

void test_rational_mixed()
{
   using namespace boost::multiprecision;
   cpp_int      a(2);
   cpp_rational r(10);

   BOOST_CHECK_EQUAL(a + -r, -8);
   BOOST_CHECK_EQUAL(-r + a, -8);
   BOOST_CHECK_EQUAL(-a + r, 8);
   BOOST_CHECK_EQUAL(r + -a, 8);

   BOOST_CHECK_EQUAL(a - -r, 12);
   BOOST_CHECK_EQUAL(-r - a, -12);
   BOOST_CHECK_EQUAL(-a - r, -12);
   BOOST_CHECK_EQUAL(r - -a, 12);

   BOOST_CHECK_EQUAL(a * -r, -20);
   BOOST_CHECK_EQUAL(-r * a, -20);
   BOOST_CHECK_EQUAL(-a * r, -20);
   BOOST_CHECK_EQUAL(r * -a, -20);

   BOOST_CHECK_EQUAL(a / -r, cpp_rational(-2, 10));
   BOOST_CHECK_EQUAL(-r / a, -5);
   BOOST_CHECK_EQUAL(cpp_rational(-a / r), cpp_rational(-2, 10));
   BOOST_CHECK_EQUAL(r / -a, -5);
}

int main()
{
   using namespace boost::multiprecision;

   test_rational_mixed();

   test<checked_int512_t, checked_int1024_t>();
   test<checked_int256_t, checked_int512_t>();
   test<number<cpp_int_backend<64, 64, signed_magnitude, checked, void>, et_off>, checked_int128_t>();
   test<std::int64_t, checked_int128_t>();
   test<number<cpp_int_backend<4096, 4096, signed_magnitude, checked, void>, et_off>, cpp_int>();
   test<number<cpp_int_backend<4096> >, cpp_int>();

   test<checked_uint512_t, checked_uint1024_t>();
   test<checked_uint256_t, checked_uint512_t>();
   test<number<cpp_int_backend<64, 64, unsigned_magnitude, checked, void>, et_off>, checked_uint128_t>();
   test<std::uint64_t, checked_int128_t>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR
#include <boost/multiprecision/mpfr.hpp>
#endif
#include <boost/multiprecision/cpp_dec_float.hpp>
#include "test.hpp"

template <class Number, class BigNumber>
void test()
{
   using namespace boost::multiprecision;
   typedef Number test_type;

   test_type a = 1;
   a /= 3;
   test_type b = -a;

   BigNumber r;
   BOOST_CHECK_EQUAL(add(r, a, a), BigNumber(a) + BigNumber(a));
   BOOST_CHECK_EQUAL(subtract(r, a, b), BigNumber(a) - BigNumber(b));
   BOOST_CHECK_EQUAL(subtract(r, b, a), BigNumber(b) - BigNumber(a));
   BOOST_CHECK_EQUAL(multiply(r, a, a), BigNumber(a) * BigNumber(a));
}

int main()
{
   using namespace boost::multiprecision;

   test<cpp_dec_float_50, cpp_dec_float_100>();

#ifdef TEST_GMP
   test<mpf_float_50, mpf_float_100>();
#endif
#ifdef TEST_MPFR
   test<mpfr_float_50, mpfr_float_100>();
#endif

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_move_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2020 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"

#ifdef __clang__
#if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)
// memory sanitizer is incompatible with this test:
# define DISABLE_THIS_TEST
#endif
#endif
#ifdef BOOST_CI_ASAN_BUILD
#define DISABLE_THIS_TEST
#endif

#ifndef DISABLE_THIS_TEST

unsigned alloc_count = 0;
void* operator new(std::size_t count)
{
   ++alloc_count;
   return std::malloc(count);
}
void* operator new[](std::size_t count)
{
   ++alloc_count;
   return std::malloc(count);
}
void operator delete(void* p)noexcept
{
   return std::free(p);
}
void operator delete(void* p, std::size_t)
{
   return ::operator delete(p);
}
void operator delete[](void* p)noexcept
{
   return std::free(p);
}
void operator delete[](void* p, std::size_t)
{
   return ::operator delete[](p);
}



template <class From, class To>
void test_one(From val)
{
   From copy(val);
   To   target(val);
   alloc_count = 0;
   To   moved(std::move(copy));
   BOOST_CHECK_EQUAL(alloc_count, 0);
   BOOST_CHECK_EQUAL(moved, target);
   copy = val;
   moved = 0;
   BOOST_CHECK_EQUAL(copy, val);
   BOOST_CHECK_EQUAL(moved, 0);
   alloc_count = 0;
   moved = std::move(copy);
   BOOST_CHECK_EQUAL(alloc_count, 0);
   BOOST_CHECK_EQUAL(moved, target);
}

template <class From, class To>
void test()
{
   From val(10);
   From limit = pow(From(2), 1000);

   while (val < limit)
   {
      test_one<From, To>(val);
      test_one<From, To>(-val);
      val *= 100;
      val /= 3;
   }
}

template <class From, class To>
void test_operations()
{
   From a = From(1) << 150;
   From b = From(1) << 149;
   {
      alloc_count = 0;
      To c        = a * b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a * b);
   }
   {
      alloc_count = 0;
      To c;
      multiply(c, a, b);
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a * b);
   }
   {
      alloc_count = 0;
      To c        = a + b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a + b);
   }
   {
      alloc_count = 0;
      To c;
      add(c, a, b);
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a + b);
   }
   {
      alloc_count = 0;
      To c        = -a;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, -a);
   }
   {
      alloc_count = 0;
      To c        = a - b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a - b);
   }
   {
      alloc_count = 0;
      To c;
      subtract(c, a, b);
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a - b);
   }
   {
      alloc_count = 0;
      To c        = a / b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a / b);
   }
   {
      alloc_count = 0;
      To c        = a % b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a % b);
   }
   {
      alloc_count = 0;
      To c        = a << 1;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a << 1);
   }
   {
      alloc_count = 0;
      To c        = a >> 1;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a >> 1);
   }
   {
      alloc_count = 0;
      To c        = a | b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a | b);
   }
   {
      alloc_count = 0;
      To c        = a & b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a & b);
   }
   {
      alloc_count = 0;
      To c        = a ^ b;
      BOOST_CHECK_EQUAL(alloc_count, 0);
      BOOST_CHECK_EQUAL(c, a ^ b);
   }
   {
      alloc_count = 0;
      To c        = gcd(a, b);
      BOOST_CHECK_EQUAL(c, gcd(a, b));
   }
   {
      alloc_count = 0;
      To c        = lcm(a, b);
      BOOST_CHECK_EQUAL(c, lcm(a, b));
   }
   {
      alloc_count = 0;
      To c        = pow(a, 2);
      BOOST_CHECK_EQUAL(c, pow(a, 2));
   }
   {
      alloc_count = 0;
      To c        = powm(a, b, 2);
      BOOST_CHECK_EQUAL(c, powm(a, b, 2));
   }
   {
      alloc_count = 0;
      To c        = sqrt(a);
      BOOST_CHECK_EQUAL(c, sqrt(a));
   }
}

int main()
{
   using namespace boost::multiprecision;
   //
   // Our "From" type has the MinBits argument as small as possible,
   // should it be larger than the default used in cpp_int then we
   // may get allocations causing the tests above to fail since the
   // internal cache in type From is larger than that of cpp_int and so
   // allocation may be needed even on a move.
   //
   test<number<cpp_int_backend<sizeof(limb_type) * CHAR_BIT * 2> >, cpp_int>();

   typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512> > To;
   test_operations<cpp_int, To>();

   return boost::report_errors();
}

#else
int main(){ return 0; }
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_mpf_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/gmp.hpp>
#include "test_mixed.hpp"

int main()
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      typedef boost::multiprecision::number<boost::multiprecision::gmp_float<100>, boost::multiprecision::et_on>  big_type1;
      typedef boost::multiprecision::number<boost::multiprecision::gmp_float<50>, boost::multiprecision::et_on>   small_type1;
      typedef boost::multiprecision::number<boost::multiprecision::gmp_float<100>, boost::multiprecision::et_off> big_type2;
      typedef boost::multiprecision::number<boost::multiprecision::gmp_float<50>, boost::multiprecision::et_off>  small_type2;

      test<big_type1, small_type1>();
      test<big_type2, small_type2>();
      test<big_type1, small_type2>();
      test<big_type2, small_type1>();
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const std::exception& e)
   {
      std::cout << "Failed with unexpected exception: " << e.what() << std::endl;
      return 1;
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mixed_mpfr_float.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/mpfr.hpp>
#include "test_mixed.hpp"

int main()
{
#ifndef BOOST_NO_EXCEPTIONS
   try
   {
#endif
      typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<100>, boost::multiprecision::et_on>  big_type1;
      typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<50>, boost::multiprecision::et_on>   small_type1;
      typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<100>, boost::multiprecision::et_off> big_type2;
      typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<50>, boost::multiprecision::et_off>  small_type2;

      test<big_type1, small_type1>();
      test<big_type2, small_type2>();
      test<big_type1, small_type2>();
      test<big_type2, small_type1>();
#ifndef BOOST_NO_EXCEPTIONS
   }
   catch (const std::exception& e)
   {
      std::cout << "Failed with unexpected exception: " << e.what() << std::endl;
      return 1;
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_move.cpp
================================================
// Copyright John Maddock 2012.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/config.hpp>
#include <vector>

#if !defined(TEST_GMP) && !defined(TEST_MPFR) && !defined(TEST_TOMMATH) && !defined(TEST_CPP_INT) && !defined(TEST_MPC)
#define TEST_GMP
#define TEST_MPFR
#define TEST_TOMMATH
#define TEST_CPP_INT
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_GMP)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#endif
#ifdef TEST_MPC
#include <boost/multiprecision/mpc.hpp>
#endif

#include "test.hpp"

unsigned allocation_count = 0;

void* (*alloc_func_ptr)(size_t);
void* (*realloc_func_ptr)(void*, size_t, size_t);
void (*free_func_ptr)(void*, size_t);

void* alloc_func(size_t n)
{
   ++allocation_count;
   return (*alloc_func_ptr)(n);
}

void free_func(void* p, size_t n)
{
   (*free_func_ptr)(p, n);
}

void* realloc_func(void* p, size_t old, size_t n)
{
   ++allocation_count;
   return (*realloc_func_ptr)(p, old, n);
}

template <class T>
void do_something(const T&)
{
}

template <class T>
void test_std_lib()
{
   std::vector<T> v;
   for (unsigned i = 0; i < 100; ++i)
      v.insert(v.begin(), i);

   T a(2), b(3);
   std::swap(a, b);
   BOOST_TEST(a == 3);
   BOOST_TEST(b == 2);
}

template <class T, class A>
void test_move_and_assign(T x, A val)
{
   // move away from x, then assign val to x.
   T z(x);
   T y(std::move(x));
   x.assign(val);
   BOOST_CHECK_EQUAL(x, T(val));
   BOOST_CHECK_EQUAL(z, y);
}

template <class T>
void test_move_and_assign()
{
   T x(23);
   test_move_and_assign(x, static_cast<short>(2));
   test_move_and_assign(x, static_cast<int>(2));
   test_move_and_assign(x, static_cast<long>(2));
   test_move_and_assign(x, static_cast<long long>(2));
   test_move_and_assign(x, static_cast<unsigned short>(2));
   test_move_and_assign(x, static_cast<unsigned int>(2));
   test_move_and_assign(x, static_cast<unsigned long>(2));
   test_move_and_assign(x, static_cast<unsigned long long>(2));
   test_move_and_assign(x, static_cast<float>(2));
   test_move_and_assign(x, static_cast<double>(2));
   test_move_and_assign(x, static_cast<long double>(2));
   test_move_and_assign(x, x);
   test_move_and_assign(x, "23");
}

int main()
{
#if defined(TEST_MPFR) || defined(TEST_GMP)
#if defined(MPFR_VERSION) && (MPFR_VERSION_MAJOR > 3)
   mpfr_mp_memory_cleanup();
#endif
   mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
   mp_set_memory_functions(&alloc_func, &realloc_func, &free_func);
#endif

   using namespace boost::multiprecision;

#ifdef TEST_MPFR
   {
      test_std_lib<mpfr_float_50>();
      mpfr_float_50 a = 2;
      if (allocation_count)
      {
         //
         // We can only conduct meaningful tests if we're actually using our custom allocators,
         // there are some situations where mpfr-4.x doesn't call them even though we've
         // done everything requested to make them work....
         //
         allocation_count = 0;
         mpfr_float_50 b  = std::move(a);
         BOOST_TEST(allocation_count == 0);
         //
         // Move assign - we rely on knowledge of the internals to make this test work!!
         //
         mpfr_float_50 c(3);
         do_something(b);
         do_something(c);
         const void* p = b.backend().data()[0]._mpfr_d;
         BOOST_TEST(c.backend().data()[0]._mpfr_d != p);
         c = std::move(b);
         BOOST_TEST(c.backend().data()[0]._mpfr_d == p);
         BOOST_TEST(b.backend().data()[0]._mpfr_d != p);
         //
         // Again with variable precision, this we can test more easily:
         //
         mpfr_float d, e;
         d.precision(100);
         e.precision(1000);
         d                = 2;
         e                = 3;
         allocation_count = 0;
         BOOST_TEST(d == 2);
         d = std::move(e);
         BOOST_TEST(allocation_count == 0);
         BOOST_TEST(d == 3);
         e = 2;
         BOOST_TEST(e == 2);
         d = std::move(e);
         e = d;
         BOOST_TEST(e == d);

         test_move_and_assign<mpfr_float>();
         test_move_and_assign<mpfr_float_50>();
      }
   }
#endif
#ifdef TEST_MPC
   {
      test_std_lib<mpc_complex_50>();
      mpc_complex_50 a = 2;
      if (allocation_count)
      {
         //
         // We can only conduct meaningful tests if we're actually using our custom allocators,
         // there are some situations where mpfr-4.x doesn't call them even though we've
         // done everything requested to make them work....
         //
         allocation_count = 0;
         mpc_complex_50 b = std::move(a);
         BOOST_TEST(allocation_count == 0);
         //
         // Move assign - we rely on knowledge of the internals to make this test work!!
         //
         mpc_complex_50 c(3);
         do_something(b);
         do_something(c);
         //
         // Again with variable precision, this we can test more easily:
         //
         mpc_complex d, e;
         d.precision(100);
         e.precision(1000);
         d                = 2;
         e                = 3;
         allocation_count = 0;
         BOOST_TEST(d == 2);
         d = std::move(e);
         BOOST_TEST(allocation_count == 0);
         BOOST_TEST(d == 3);
         e = 2;
         BOOST_TEST(e == 2);
         d = std::move(e);
         e = d;
         BOOST_TEST(e == d);

         test_move_and_assign<mpc_complex>();
         test_move_and_assign<mpc_complex_50>();
      }
   }
#endif
#ifdef TEST_GMP
   {
      test_std_lib<mpf_float_50>();
      mpf_float_50 a = 2;
      BOOST_TEST(allocation_count); // sanity check that we are tracking allocations
      allocation_count = 0;
      mpf_float_50 b   = std::move(a);
      BOOST_TEST(allocation_count == 0);
      //
      // Move assign: this requires knowledge of the internals to test!!
      //
      mpf_float_50 c(3);
      do_something(b);
      do_something(c);
      const void* p = b.backend().data()[0]._mp_d;
      BOOST_TEST(c.backend().data()[0]._mp_d != p);
      c = std::move(b);
      BOOST_TEST(c.backend().data()[0]._mp_d == p);
      BOOST_TEST(b.backend().data()[0]._mp_d != p);
      //
      // Again with variable precision, this we can test more easily:
      //
      mpf_float d, e;
      d.precision(100);
      e.precision(1000);
      d                = 2;
      e                = 3;
      allocation_count = 0;
      BOOST_TEST(d == 2);
      d = std::move(e);
      BOOST_TEST(allocation_count == 0);
      BOOST_TEST(d == 3);
      e = 2;
      BOOST_TEST(e == 2);
      d = std::move(e);
      e = d;
      BOOST_TEST(e == d);

      test_move_and_assign<mpf_float>();
      test_move_and_assign<mpf_float_50>();
   }
   {
      test_std_lib<mpz_int>();
      mpz_int a = 2;
      BOOST_TEST(allocation_count); // sanity check that we are tracking allocations
      allocation_count = 0;
      mpz_int b        = std::move(a);
      BOOST_TEST(allocation_count == 0);

      //
      // Move assign:
      //
      mpz_int d, e;
      d = 2;
      d <<= 1000;
      e                = 3;
      allocation_count = 0;
      e                = std::move(d);
      BOOST_TEST(allocation_count == 0);
      e = 2;
      BOOST_TEST(e == 2);
      d = std::move(e);
      e = d;
      BOOST_TEST(e == d);

      test_move_and_assign<mpz_int>();
   }
   {
      test_std_lib<mpq_rational>();
      mpq_rational a = 2;
      BOOST_TEST(allocation_count); // sanity check that we are tracking allocations
      allocation_count = 0;
      mpq_rational b   = std::move(a);
      BOOST_TEST(allocation_count == 0);

      //
      // Move assign:
      //
      mpq_rational d, e;
      d                = mpz_int(2) << 1000;
      e                = 3;
      allocation_count = 0;
      e                = std::move(d);
      BOOST_TEST(allocation_count == 0);
      d = 2;
      BOOST_TEST(d == 2);
      d = std::move(e);
      e = d;
      BOOST_TEST(e == d);

      test_move_and_assign<mpq_rational>();
   }
#endif
#ifdef TEST_TOMMATH
   {
      test_std_lib<tom_int>();
      tom_int     a = 2;
      void const* p = a.backend().data().dp;
      tom_int     b = std::move(a);
      BOOST_TEST(b.backend().data().dp == p);
      // We can't test this, as it will assert inside data():
      //BOOST_TEST(a.backend().data().dp == 0);

      //
      // Move assign:
      //
      tom_int d, e;
      d = 2;
      d <<= 1000;
      e = 3;
      p = d.backend().data().dp;
      BOOST_TEST(p != e.backend().data().dp);
      e = std::move(d);
      BOOST_TEST(e.backend().data().dp == p);
      d = 2;
      BOOST_TEST(d == 2);
      d = std::move(e);
      e = d;
      BOOST_TEST(e == d);

      test_move_and_assign<tom_int>();
   }
#endif
#ifdef TEST_CPP_INT
   {
      test_std_lib<cpp_int>();
      cpp_int a = 2;
      a <<= 1000; // Force dynamic allocation.
      void const* p = a.backend().limbs();
      cpp_int     b = std::move(a);
      BOOST_TEST(b.backend().limbs() == p);

      //
      // Move assign:
      //
      cpp_int d, e;
      d = 2;
      d <<= 1000;
      e = 3;
      e <<= 1000;
      p = d.backend().limbs();
      BOOST_TEST(p != e.backend().limbs());
      e = std::move(d);
      BOOST_TEST(e.backend().limbs() == p);
      d = 2;
      BOOST_TEST(d == 2);
      d = std::move(e);
      e = d;
      BOOST_TEST(e == d);

      test_move_and_assign<cpp_int>();
      test_move_and_assign<int512_t>();
   }
#endif
   return boost::report_errors();
}



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpc_conversions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/mpc.hpp>
#include <boost/multiprecision/gmp.hpp>

int main()
{
   using namespace boost::multiprecision;
   //
   // Test interconversions between GMP supported backends:
   //
   mpf_t  mpf;
   mpz_t  mpz;
   mpq_t  mpq;
   mpfr_t mpfr;
   mpf_init2(mpf, 100);
   mpf_set_ui(mpf, 2u);
   mpz_init(mpz);
   mpz_set_ui(mpz, 2u);
   mpq_init(mpq);
   mpq_set_ui(mpq, 2u, 1u);
   mpfr_init(mpfr);
   mpfr_set_ui(mpfr, 2u, GMP_RNDN);

   BOOST_TEST(mpc_complex(mpf) == 2);
   BOOST_TEST(mpc_complex_50(mpf) == 2);
   BOOST_TEST(mpc_complex(mpz) == 2);
   BOOST_TEST(mpc_complex_50(mpz) == 2);
   BOOST_TEST(mpc_complex(mpq) == 2);
   BOOST_TEST(mpc_complex_50(mpq) == 2);
   BOOST_TEST(mpc_complex(mpfr) == 2);
   BOOST_TEST(mpc_complex_50(mpfr) == 2);

   mpc_complex    f0;
   mpc_complex_50 f50;
   f0 = mpf;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpz;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpq;
   BOOST_TEST(f0 == 2);
   f0 = mpfr;
   BOOST_TEST(f0 == 2);

   f50 = mpf;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpz;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpq;
   BOOST_TEST(f50 == 2);
   f50 = mpfr;
   BOOST_TEST(f50 == 2);

   f50 = 4;
   f0  = f50;
   BOOST_TEST(f0 == 4);
   f0  = 3;
   f50 = f0;
   BOOST_TEST(f50 == 3);
   f50 = 4;
   BOOST_TEST(mpc_complex(f50) == 4);
   BOOST_TEST(mpc_complex_50(f0) == 3);

   mpz_int      iz(2);
   mpq_rational rat(2);
   mpf_float    gf(2);
   f50 = 3;
   f50 = iz;
   BOOST_TEST(f50 == 2);
   f50 = 3;
   f0  = iz;
   BOOST_TEST(f0 == 2);
   f50 = 3;
   f0  = gf;
   BOOST_TEST(f0 == 2);
   BOOST_TEST(mpc_complex(iz) == 2);
   BOOST_TEST(mpc_complex_50(iz) == 2);
   BOOST_TEST(mpc_complex(rat) == 2);
   BOOST_TEST(mpc_complex_50(rat) == 2);
   BOOST_TEST(mpc_complex(gf) == 2);
   BOOST_TEST(mpc_complex_50(gf) == 2);

   //
   // Conversions involving precision only:
   //
   mpc_complex::default_precision(30);
   f50 = 2;
   mpc_complex_100 f100(3);
   mpc_complex     f0a(4);
   mpc_complex     f0b(f100);
   BOOST_TEST(f0a.precision() == 30);
   BOOST_TEST(f0b.precision() == 100);
   f0a = f100;
   BOOST_TEST(f0a == 3);
   BOOST_TEST(f0a.precision() == 100); // precision preserved on assignment

   f100 = f50;
   BOOST_TEST(f100 == 2);

   f50 = static_cast<mpc_complex_50>(f100);

   mpf_clear(mpf);
   mpz_clear(mpz);
   mpq_clear(mpq);
   mpfr_clear(mpfr);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpc_overloads.cpp
================================================
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#include <type_traits>
#include "test.hpp"
#include <boost/multiprecision/mpc.hpp>
#include <boost/math/constants/constants.hpp>

using boost::multiprecision::mpc_complex_100;

template <class Complex>
void test_overloads()
{
   typedef typename Complex::value_type Real;
   Complex                              ya = {5.2, 7.4};
   Complex                              yb = {8.2, 7.3};
   Real                                 h  = 0.0001;
   auto                                 I0 = (ya + yb) * h;
   Complex                              I1 = I0 / 2 + yb * h;

   //I1 = I0;  // not supposed to work.

   Complex                      z{2, 3};
   typename Complex::value_type theta = 0.2;
   int                          n     = 2;
   using std::sin;
   Complex arg = z * sin(theta) - n * theta;

   using std::exp;
   Real    v    = 0.2;
   Real    cotv = 7.8;
   Real    cscv = 8.2;
   Complex den  = z + v * cscv * exp(-v * cotv);

   boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<100> > a = 2;
   boost::multiprecision::number<boost::multiprecision::backends::mpc_complex_backend<100> > b = 3;
   /*
  if (a <= b) {
    b = a;
  }*/
}

template <class F, class Real>
typename std::result_of_t<F(Real)> some_functional(F f, Real a, Real b)
{
   if (a <= -boost::math::tools::max_value<Real>())
   {
      return f(a);
   }

   return f(b);
}

template <class Complex>
void test_functional()
{
   typedef typename Complex::value_type Real;
   auto                                 f      = [](Real x) -> Complex { Complex z(x, 3); return z; };
   Real                                 a      = 0;
   Real                                 b      = 1;
   Complex                              result = some_functional(f, a, b);
}

int main()
{
   test_overloads<mpc_complex_100>();
   test_functional<mpc_complex_100>();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpf_precisions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include "test.hpp"

#include <boost/multiprecision/gmp.hpp>

template <class T>
T make_rvalue_copy(const T a)
{
   return a;
}

int main()
{
   using namespace boost::multiprecision;
   //
   // Test change of default precision:
   //
   mpf_float::default_precision(100);
   mpf_float a("0.1");
   BOOST_CHECK_GE(a.precision(), 100);
   mpf_float::default_precision(20);
   {
      // test assignment from lvalue:
      mpf_float b(2);
      BOOST_CHECK_GE(b.precision(), 20);
      b = a;
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   {
      // test assignment from rvalue:
      mpf_float b(2);
      BOOST_CHECK_GE(b.precision(), 20);
      b = make_rvalue_copy(a);
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   mpf_float::default_precision(20);
   {
      // test construct from lvalue:
      mpf_float b(a);
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   {
      // test construct from rvalue:
      mpf_float b(make_rvalue_copy(a));
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   {
      mpf_float f150(2, 150);
      BOOST_CHECK_GE(f150.precision(), 150);
   }
   {
      mpf_float f150("1.2", 150);
      BOOST_CHECK_GE(f150.precision(), 150);
   }
   //
   // From https://github.com/boostorg/multiprecision/issues/65
   //
   {
      mpf_float a(2);
      a.precision(100);
      BOOST_CHECK_EQUAL(a, 2);
      BOOST_CHECK_GE(a.precision(), 100);
   }

   //
   // string_view with explicit precision:
   //
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   {
      std::string      s("222");
      std::string_view v(s.c_str(), 1);
      mpf_float        f(v, 100);
      BOOST_CHECK_EQUAL(f, 2);
      BOOST_CHECK_GE(f.precision(), 100);
   }
#endif
   // Swap:
   {
      mpf_float x(2, 100); // 100 digits precision.
      mpf_float y(3, 50);  // 50 digits precision.
      swap(x, y);
      BOOST_CHECK_EQUAL(x, 3);
      BOOST_CHECK_EQUAL(y, 2);
      BOOST_CHECK_GE(x.precision(), 50);
      BOOST_CHECK_GE(y.precision(), 100);
      x.swap(y);
      BOOST_CHECK_EQUAL(x, 2);
      BOOST_CHECK_EQUAL(y, 3);
      BOOST_CHECK_GE(x.precision(), 100);
      BOOST_CHECK_GE(y.precision(), 50);
      x = std::move(mpf_float(y));
      BOOST_CHECK_EQUAL(x, y);
      BOOST_CHECK_EQUAL(x.precision(), y.precision());
   }
   {
      mpf_float c(4), d(8), e(9), f;
      f = (c + d) * d / e;
      mpf_float g((c + d) * d / e);
   }
   {
      mpf_float::default_precision(100);
      mpf_float f1;
      f1 = 3;
      BOOST_CHECK_GE(f1.precision(), 100);
      f1 = 3.5;
      BOOST_CHECK_GE(f1.precision(), 100);
      mpf_float f2(3.5);
      BOOST_CHECK_GE(f2.precision(), 100);
      mpf_float f3("5.1");
      BOOST_CHECK_GE(f3.precision(), 100);

      mpf_float::default_precision(50);
      mpf_float f4(f3, 50);
      BOOST_CHECK_GE(f4.precision(), 50);
      f4.assign(f1, f4.precision());
      BOOST_CHECK_GE(f4.precision(), 50);
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpfi.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "test.hpp"
#include <boost/multiprecision/mpfi.hpp>
#include <boost/multiprecision/random.hpp>

using namespace boost::multiprecision;
using namespace boost::random;

void test_exp()
{
   std::cout << "Testing exp\n";

   mpfr_float_50 val = 1.25;

   for (unsigned i = 0; i < 2000; ++i)
   {
      mpfr_float_100 a(val);
      mpfr_float_100 b  = exp(a);
      mpfi_float_50  in = val;
      in                = exp(in);
      BOOST_CHECK((boost::math::isfinite)(in));
      BOOST_CHECK(lower(in) <= b);
      BOOST_CHECK(upper(in) >= b);
      b  = log(a);
      in = val;
      in = log(in);
      BOOST_CHECK((boost::math::isfinite)(in));
      BOOST_CHECK(lower(in) <= b);
      BOOST_CHECK(upper(in) >= b);
      val *= 1.01;
   }
   val = 1;
   for (unsigned i = 0; i < 2000; ++i)
   {
      mpfr_float_100 a(val);
      mpfr_float_100 b  = exp(a);
      mpfi_float_50  in = val;
      in                = exp(in);
      BOOST_CHECK((boost::math::isfinite)(in));
      BOOST_CHECK(lower(in) <= b);
      BOOST_CHECK(upper(in) >= b);
      b  = log(a);
      in = val;
      in = log(in);
      BOOST_CHECK((boost::math::isfinite)(in));
      BOOST_CHECK(lower(in) <= b);
      BOOST_CHECK(upper(in) >= b);
      val /= 1.01;
   }
}

void test_pow()
{
   std::cout << "Testing pow function\n";

   mt19937                                  gen;
   uniform_real_distribution<mpfr_float_50> dist1(0, 400);

   for (unsigned i = 0; i < 5000; ++i)
   {
      mpfr_float_50 base, p;
      base = dist1(gen);
      p    = dist1(gen);
      mpfr_float_100 a, b, r;
      a = base;
      b = p;
      r = pow(a, b);
      mpfi_float_50 ai, bi, ri;
      ai = base;
      bi = p;
      ri = pow(ai, bi);
      BOOST_CHECK((boost::math::isfinite)(ri));
      BOOST_CHECK(lower(ri) <= r);
      BOOST_CHECK(upper(ri) >= r);
   }
}

void test_trig()
{
   std::cout << "Testing trig functions\n";

   mt19937                                  gen;
   uniform_real_distribution<mpfr_float_50> dist1(-1.57079632679, 1.57079632679);
   uniform_real_distribution<mpfr_float_50> dist2(-1, 1);

   for (unsigned i = 0; i < 5000; ++i)
   {
      mpfr_float_50 val;
      val               = dist1(gen);
      mpfr_float_100 a  = val;
      mpfr_float_100 b  = sin(a);
      mpfi_float_50  a2 = val;
      mpfi_float_50  b2 = sin(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = cos(a);
      b2 = cos(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = tan(a);
      b2 = tan(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
   }
   for (unsigned i = 0; i < 5000; ++i)
   {
      mpfr_float_50 val;
      val               = dist2(gen);
      mpfr_float_100 a  = val;
      mpfr_float_100 b  = asin(a);
      mpfi_float_50  a2 = val;
      mpfi_float_50  b2 = asin(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = acos(a);
      b2 = acos(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = atan(a);
      b2 = atan(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
   }
}

void test_hyp()
{
   std::cout << "Testing hyperbolic trig functions\n";

   mt19937                                  gen;
   uniform_real_distribution<mpfr_float_50> dist1(-10, 10);
   uniform_real_distribution<mpfr_float_50> dist2(-1, 1);

   for (unsigned i = 0; i < 5000; ++i)
   {
      mpfr_float_50 val;
      val               = dist1(gen);
      mpfr_float_100 a  = val;
      mpfr_float_100 b  = sinh(a);
      mpfi_float_50  a2 = val;
      mpfi_float_50  b2 = sinh(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = cosh(a);
      b2 = cosh(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
      b  = tanh(a);
      b2 = tanh(a2);
      BOOST_CHECK((boost::math::isfinite)(b2));
      BOOST_CHECK(lower(b2) <= b);
      BOOST_CHECK(upper(b2) >= b);
   }
}

void test_intervals()
{
   mpfi_float_50 a(1, 2);
   mpfi_float_50 b(1.5, 2.5);
   BOOST_CHECK_EQUAL(lower(a), 1);
   BOOST_CHECK_EQUAL(upper(a), 2);
   BOOST_CHECK_EQUAL(median(a), 1.5);
   BOOST_CHECK_EQUAL(width(a), 1);
   mpfi_float_50 r = intersect(a, b);
   BOOST_CHECK_EQUAL(lower(r), 1.5);
   BOOST_CHECK_EQUAL(upper(r), 2);
   r = hull(a, b);
   BOOST_CHECK_EQUAL(lower(r), 1);
   BOOST_CHECK_EQUAL(upper(r), 2.5);
   BOOST_CHECK(overlap(a, b));
   BOOST_CHECK(in(mpfr_float_50(1.5), a));
   BOOST_CHECK(in(mpfr_float_50(1), a));
   BOOST_CHECK(in(mpfr_float_50(2), a));
   BOOST_CHECK(!zero_in(a));
   b = mpfi_float_50(1.5, 1.75);
   BOOST_CHECK(subset(b, a));
   BOOST_CHECK(proper_subset(b, a));
   BOOST_CHECK(!empty(a));
   BOOST_CHECK(!singleton(a));
   b = mpfi_float_50(5, 6);
   r = intersect(a, b);
   BOOST_CHECK(empty(r));
}

#ifdef TEST_SPECIAL
#include "math/table_type.hpp"
#include <boost/math/special_functions.hpp>

#define T mpfi_float_50

typedef number<mpfi_float_backend<25> > mpfi_float_25;

void test_log1p_expm1()
{
#include "../../math/test/log1p_expm1_data.ipp"

   std::cout << std::setprecision(std::numeric_limits<mpfi_float_25>::max_digits10);
   std::cout << "Testing log1p and expm1\n";

   for (unsigned i = 0; i < log1p_expm1_data.size(); ++i)
   {
      mpfi_float_25 in(log1p_expm1_data[i][0]);
      mpfi_float_25 out = boost::math::log1p(in);
      mpfi_float_25 expected(log1p_expm1_data[i][1]);
      if (!subset(expected, out))
      {
         std::cout << in << std::endl;
         std::cout << out << std::endl;
         std::cout << expected << std::endl;
         BOOST_CHECK(lower(out) <= lower(expected));
         BOOST_CHECK(upper(out) >= upper(expected));
      }
      out      = boost::math::expm1(in);
      expected = mpfi_float_25(log1p_expm1_data[i][2]);
      if (!subset(expected, out))
      {
         std::cout << in << std::endl;
         std::cout << out << std::endl;
         std::cout << expected << std::endl;
         BOOST_CHECK(lower(out) <= lower(expected));
         BOOST_CHECK(upper(out) >= upper(expected));
      }
   }
}

void test_bessel()
{
#include "../../math/test/bessel_i_int_data.ipp"
#include "../../math/test/bessel_i_data.ipp"

   std::cout << std::setprecision(std::numeric_limits<mpfi_float_25>::max_digits10);
   std::cout << "Testing Bessel Functions\n";

   for (unsigned i = 0; i < bessel_i_int_data.size(); ++i)
   {
      int           v = boost::lexical_cast<int>(static_cast<const char*>(bessel_i_int_data[i][0]));
      mpfi_float_25 in(bessel_i_int_data[i][1]);
      mpfi_float_25 out = boost::math::cyl_bessel_i(v, in);
      mpfi_float_25 expected(bessel_i_int_data[i][2]);
      if (!subset(expected, out))
      {
         std::cout << in << std::endl;
         std::cout << out << std::endl;
         std::cout << expected << std::endl;
         BOOST_CHECK(lower(out) <= lower(expected));
         BOOST_CHECK(upper(out) >= upper(expected));
      }
   }
}

#endif

int main()
{
#ifdef TEST_SPECIAL
   test_log1p_expm1();
   test_bessel();
#endif
   test_intervals();
   test_exp();
   test_pow();
   test_trig();
   test_hyp();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpfi_precisions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include "test.hpp"

#include <boost/multiprecision/mpfi.hpp>

template <class T>
T make_rvalue_copy(const T a)
{
   return a;
}

int main()
{
   using namespace boost::multiprecision;
   //
   // Test change of default precision:
   //
   mpfi_float::default_precision(100);
   mpfi_float a("0.1");
   BOOST_CHECK_EQUAL(a.precision(), 100);
   mpfi_float::default_precision(20);
   {
      // test assignment from lvalue:
      mpfi_float b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = a;
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   {
      // test assignment from rvalue:
      mpfi_float b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = make_rvalue_copy(a);
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   mpfi_float::default_precision(20);
   {
      // test construct from lvalue:
      mpfi_float b(a);
      BOOST_CHECK_EQUAL(b.precision(), 100);
   }
   {
      // test construct from rvalue:
      mpfi_float b(make_rvalue_copy(a));
      BOOST_CHECK_EQUAL(b.precision(), 100);
   }
   {
      mpfi_float f150(2, 2, 150);
      BOOST_CHECK_EQUAL(f150.precision(), 150);
   }
   {
      mpfi_float f150("1.2", "1.2", 150);
      BOOST_CHECK_EQUAL(f150.precision(), 150);
   }
   //
   // From https://github.com/boostorg/multiprecision/issues/65
   //
   {
      mpfi_float a(2);
      a.precision(100);
      BOOST_CHECK_EQUAL(a, 2);
      BOOST_CHECK_EQUAL(a.precision(), 100);
   }

   //
   // string_view with explicit precision:
   //
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   {
      std::string      s("222");
      std::string_view v(s.c_str(), 1);
      mpfi_float       f(v, v, 100);
      BOOST_CHECK_EQUAL(f, 2);
      BOOST_CHECK_EQUAL(f.precision(), 100);
   }
#endif
   // Swap:
   {
      mpfi_float x(2, 2, 100); // 100 digits precision.
      mpfi_float y(3, 3, 50);  // 50 digits precision.
      swap(x, y);
      BOOST_CHECK_EQUAL(x, 3);
      BOOST_CHECK_EQUAL(y, 2);
      BOOST_CHECK_EQUAL(x.precision(), 50);
      BOOST_CHECK_EQUAL(y.precision(), 100);
      x.swap(y);
      BOOST_CHECK_EQUAL(x, 2);
      BOOST_CHECK_EQUAL(y, 3);
      BOOST_CHECK_EQUAL(x.precision(), 100);
      BOOST_CHECK_EQUAL(y.precision(), 50);
      x = std::move(mpfi_float(y));
      BOOST_CHECK_EQUAL(x, y);
      BOOST_CHECK_EQUAL(x.precision(), y.precision());
   }
   {
      mpfi_float c(4), d(8), e(9), f;
      f = (c + d) * d / e;
      mpfi_float g((c + d) * d / e);
   }
   {
      mpfi_float::default_precision(100);
      mpfi_float f1;
      f1 = 3;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      f1 = 3.5;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      mpfi_float f2(3.5);
      BOOST_CHECK_EQUAL(f2.precision(), 100);
      mpfi_float f3("5.1");
      BOOST_CHECK_EQUAL(f3.precision(), 100);

      mpfi_float::default_precision(50);
      mpfi_float f4(f3, 50);
      BOOST_CHECK_EQUAL(f4.precision(), 50);
      f4.assign(f1, f4.precision());
      BOOST_CHECK_EQUAL(f4.precision(), 50);
   }
   {
      //
      // Check additional non-member functions,
      // see https://github.com/boostorg/multiprecision/issues/91
      //
      mpfi_float::default_precision(100);
      mpfi_float f1;
      f1 = 3;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      mpfi_float::default_precision(20);
      BOOST_CHECK_EQUAL(lower(f1).precision(), 100);
      BOOST_CHECK_EQUAL(upper(f1).precision(), 100);
      BOOST_CHECK_EQUAL(median(f1).precision(), 100);
      BOOST_CHECK_EQUAL(width(f1).precision(), 100);
      BOOST_CHECK_EQUAL(intersect(f1, f1).precision(), 100);
      BOOST_CHECK_EQUAL(hull(f1, f1).precision(), 100);

      BOOST_CHECK_EQUAL(asinh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(acosh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(atanh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(log1p(f1).precision(), 100);
      BOOST_CHECK_EQUAL(expm1(f1).precision(), 100);
      BOOST_CHECK_EQUAL(cbrt(f1).precision(), 100);
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpfr_conversions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/gmp.hpp>

int main()
{
   using namespace boost::multiprecision;
   //
   // Test interconversions between GMP supported backends:
   //
   mpf_t  mpf;
   mpz_t  mpz;
   mpq_t  mpq;
   mpfr_t mpfr;
   mpf_init2(mpf, 100);
   mpf_set_ui(mpf, 2u);
   mpz_init(mpz);
   mpz_set_ui(mpz, 2u);
   mpq_init(mpq);
   mpq_set_ui(mpq, 2u, 1u);
   mpfr_init(mpfr);
   mpfr_set_ui(mpfr, 2u, GMP_RNDN);

   BOOST_TEST(mpfr_float(mpf) == 2);
   BOOST_TEST(mpfr_float_50(mpf) == 2);
   BOOST_TEST(mpfr_float(mpz) == 2);
   BOOST_TEST(mpfr_float_50(mpz) == 2);
   BOOST_TEST(mpfr_float(mpq) == 2);
   BOOST_TEST(mpfr_float_50(mpq) == 2);
   BOOST_TEST(mpfr_float(mpfr) == 2);
   BOOST_TEST(mpfr_float_50(mpfr) == 2);

   mpfr_float    f0;
   mpfr_float_50 f50;
   f0 = mpf;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpz;
   BOOST_TEST(f0 == 2);
   f0 = 0;
   f0 = mpq;
   BOOST_TEST(f0 == 2);
   f0 = mpfr;
   BOOST_TEST(f0 == 2);

   f50 = mpf;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpz;
   BOOST_TEST(f50 == 2);
   f50 = 0;
   f50 = mpq;
   BOOST_TEST(f50 == 2);
   f50 = mpfr;
   BOOST_TEST(f50 == 2);

   f50 = 4;
   f0  = f50;
   BOOST_TEST(f0 == 4);
   f0  = 3;
   f50 = f0;
   BOOST_TEST(f50 == 3);
   f50 = 4;
   BOOST_TEST(mpfr_float(f50) == 4);
   BOOST_TEST(mpfr_float_50(f0) == 3);

   mpz_int      iz(2);
   mpq_rational rat(2);
   mpf_float    gf(2);
   f50 = 3;
   f50 = iz;
   BOOST_TEST(f50 == 2);
   f50 = 3;
   f0  = iz;
   BOOST_TEST(f0 == 2);
   f50 = 3;
   f0  = gf;
   BOOST_TEST(f0 == 2);
   BOOST_TEST(mpfr_float(iz) == 2);
   BOOST_TEST(mpfr_float_50(iz) == 2);
   BOOST_TEST(mpfr_float(rat) == 2);
   BOOST_TEST(mpfr_float_50(rat) == 2);
   BOOST_TEST(mpfr_float(gf) == 2);
   BOOST_TEST(mpfr_float_50(gf) == 2);

   //
   // Conversions involving precision only:
   //
   mpfr_float::default_precision(30);
   f50 = 2;
   mpfr_float_100 f100(3);
   mpfr_float     f0a(4);
   mpfr_float     f0b(f100);
   BOOST_TEST(f0a.precision() == 30);
   BOOST_TEST(f0b.precision() == 100);
   f0a = f100;
   BOOST_TEST(f0a == 3);
   BOOST_TEST(f0a.precision() == 100); // precision preserved on assignment

   f100 = f50;
   BOOST_TEST(f100 == 2);

   f50 = static_cast<mpfr_float_50>(f100);

   mpf_clear(mpf);
   mpz_clear(mpz);
   mpq_clear(mpq);
   mpfr_clear(mpfr);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_mpfr_mpc_precisions.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include "test.hpp"

#include <boost/multiprecision/mpfr.hpp>
#include <boost/multiprecision/mpc.hpp>

template <class T>
T make_rvalue_copy(const T a)
{
   return a;
}

int main()
{
   using namespace boost::multiprecision;
   //
   // Test change of default precision:
   //
   mpfr_float::default_precision(100);
   mpfr_float a("0.1");
   BOOST_CHECK_EQUAL(a.precision(), 100);
   mpfr_float::default_precision(20);
   {
      // test assignment from lvalue:
      mpfr_float b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = a;
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   {
      // test assignment from rvalue:
      mpfr_float b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = make_rvalue_copy(a);
      BOOST_CHECK_EQUAL(b.precision(), a.precision());
   }
   mpfr_float::default_precision(20);
   {
      // test construct from lvalue:
      mpfr_float b(a);
      BOOST_CHECK_EQUAL(b.precision(), 100);
   }
   {
      // test construct from rvalue:
      mpfr_float b(make_rvalue_copy(a));
      BOOST_CHECK_EQUAL(b.precision(), 100);
   }
   mpc_complex::default_precision(100);
   mpc_complex ca("0.1");
   BOOST_CHECK_EQUAL(ca.precision(), 100);
   mpc_complex::default_precision(20);
   {
      // test assignment from lvalue:
      mpc_complex b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = ca;
      BOOST_CHECK_EQUAL(b.precision(), ca.precision());
   }
   {
      // test assignment from rvalue:
      mpc_complex b(2);
      BOOST_CHECK_EQUAL(b.precision(), 20);
      b = make_rvalue_copy(ca);
      BOOST_CHECK_EQUAL(b.precision(), ca.precision());
   }
   {
      // test construct from lvalue:
      mpc_complex b(ca);
      BOOST_CHECK_EQUAL(b.precision(), ca.precision());
   }
   {
      // test construct from rvalue:
      mpc_complex b(make_rvalue_copy(ca));
      BOOST_CHECK_EQUAL(b.precision(), ca.precision());
   }
   // real and imaginary:
   BOOST_CHECK_EQUAL(ca.real().precision(), 100);
   BOOST_CHECK_EQUAL(ca.imag().precision(), 100);
   BOOST_CHECK_EQUAL(real(ca).precision(), 100);
   BOOST_CHECK_EQUAL(imag(ca).precision(), 100);

   //
   // Construction at specific precision:
   //
   {
      mpfr_float f150(mpfr_float(), 150u);
      BOOST_CHECK_EQUAL(f150.precision(), 150);
      mpc_complex f150c(mpc_complex(), 150u);
      BOOST_CHECK_EQUAL(f150c.precision(), 150);
      mpc_complex f150cc(mpfr_float(), mpfr_float(), 150u);
      BOOST_CHECK_EQUAL(f150cc.precision(), 150);
   }
   {
      mpfr_float f150(2, 150);
      BOOST_CHECK_EQUAL(f150.precision(), 150);
   }
   {
      mpfr_float f150("1.2", 150);
      BOOST_CHECK_EQUAL(f150.precision(), 150);
   }
   //
   // Copying precision:
   //
   {
      mpc_complex c(ca.backend().data());
      BOOST_CHECK_EQUAL(c.precision(), 100);
      mpc_complex_100 c100(2);
      mpc_complex     d(c100);
      BOOST_CHECK_EQUAL(d.precision(), 100);
      mpfr_float_100 f100(2);
      mpc_complex    e(f100);
      BOOST_CHECK_EQUAL(d.precision(), 100);
   }
   //
   // Check that the overloads for precision don't mess up 2-arg
   // construction:
   //
   {
      mpc_complex c(2, 3u);
      BOOST_CHECK_EQUAL(c.real(), 2);
      BOOST_CHECK_EQUAL(c.imag(), 3);
   }
   //
   // 3-arg complex number construction with 3rd arg a precision:
   //
   {
      mpc_complex c(2, 3, 100);
      BOOST_CHECK_EQUAL(c.precision(), 100);
      mpfr_float_50 x(2), y(3);
      mpc_complex   z(x, y, 100);
      BOOST_CHECK_EQUAL(c.precision(), 100);
   }
   //
   // From https://github.com/boostorg/multiprecision/issues/65
   //
   {
      mpfr_float a(2);
      a.precision(100);
      BOOST_CHECK_EQUAL(a, 2);
      BOOST_CHECK_EQUAL(a.precision(), 100);
   }
   {
      mpc_complex a(2, 3);
      a.precision(100);
      BOOST_CHECK_EQUAL(a.real(), 2);
      BOOST_CHECK_EQUAL(a.imag(), 3);
      BOOST_CHECK_EQUAL(a.precision(), 100);
   }
   {
      mpc_complex::default_precision(1000);
      mpfr_float::default_precision(1000);
      mpc_complex a("1.324719827394086120398419082734980126734089612309871092830981236748901273498071240986123094861246981263481263489016238947147129807419028748901273409127349087124612576129076541203975704195690418570914657910465091256016501650916509165097164509164509761409561097561097650791650971465097165097162059761209561029756019265019726509126509172650971625097162450971309756104975610274650917825018740981274098127409182375701465172340923847120836540491320467127043127893281461230951097260126309812374091265091824981231236409851274",
                    "-0.80743891267394610982659071452346156102764312401571972642394120395608291471029347812645125986123123904123471209381289471230512983491286102875870192091283712396550981723409812740981263471230498715096104897123094710923879065981740928740981271801391209238470129560941870129387409812883437894183883841283700483832883218128438938184289148239164079329657861209381892037483468937489237419236509823723705612893489712412306531274812364980127304981648712483248732");
      mpc_complex::default_precision(40);
      mpfr_float::default_precision(40);
      BOOST_CHECK_EQUAL(a, a);
   }

   //
   // string_view with explicit precision:
   //
#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
   {
      std::string      s("222");
      std::string_view v(s.c_str(), 1);
      mpfr_float       f(v, 100);
      BOOST_CHECK_EQUAL(f, 2);
      BOOST_CHECK_EQUAL(f.precision(), 100);
   }
   {
      std::string      x("222"), y("333");
      std::string_view vx(x.c_str(), 1), vy(y.c_str(), 1);
      mpc_complex      c(vx, vy, 100);
      BOOST_CHECK_EQUAL(c.real(), 2);
      BOOST_CHECK_EQUAL(c.imag(), 3);
      BOOST_CHECK_EQUAL(c.precision(), 100);
   }
#endif
   {
      mpc_complex::default_precision(100);
      mpfr_float::default_precision(100);
      mpfr_float a(1);
      mpfr_float b(2);

      mpc_complex::default_precision(50);
      mpfr_float::default_precision(50);

      mpc_complex z(a, b);

      BOOST_CHECK_EQUAL(z.precision(), 100);
   }
   // Swap:
   {
      mpfr_float x(2, 100); // 100 digits precision.
      mpfr_float y(3, 50);  // 50 digits precision.
      swap(x, y);
      BOOST_CHECK_EQUAL(x, 3);
      BOOST_CHECK_EQUAL(y, 2);
      BOOST_CHECK_EQUAL(x.precision(), 50);
      BOOST_CHECK_EQUAL(y.precision(), 100);
      x.swap(y);
      BOOST_CHECK_EQUAL(x, 2);
      BOOST_CHECK_EQUAL(y, 3);
      BOOST_CHECK_EQUAL(x.precision(), 100);
      BOOST_CHECK_EQUAL(y.precision(), 50);
      x = std::move(mpfr_float(y));
      BOOST_CHECK_EQUAL(x, y);
      BOOST_CHECK_EQUAL(x.precision(), y.precision());
   }
   {
      mpc_complex x(2, 3, 100); // 100 digits precision.
      mpc_complex y(3, 4, 50);  // 50 digits precision.
      swap(x, y);
      BOOST_CHECK_EQUAL(x.real(), 3);
      BOOST_CHECK_EQUAL(x.imag(), 4);
      BOOST_CHECK_EQUAL(y.real(), 2);
      BOOST_CHECK_EQUAL(y.imag(), 3);
      BOOST_CHECK_EQUAL(x.precision(), 50);
      BOOST_CHECK_EQUAL(y.precision(), 100);
      x.swap(y);
      BOOST_CHECK_EQUAL(x.real(), 2);
      BOOST_CHECK_EQUAL(x.imag(), 3);
      BOOST_CHECK_EQUAL(y.real(), 3);
      BOOST_CHECK_EQUAL(y.imag(), 4);
      BOOST_CHECK_EQUAL(x.precision(), 100);
      BOOST_CHECK_EQUAL(y.precision(), 50);
      x = std::move(mpc_complex(y));
      BOOST_CHECK_EQUAL(x, y);
      BOOST_CHECK_EQUAL(x.precision(), y.precision());
   }
   {
      mpfr_float c(4), d(8), e(9), f;
      f = (c + d) * d / e;
      mpfr_float g((c + d) * d / e);
   }
   {
      mpfr_float::default_precision(100);
      mpfr_float f1;
      f1 = 3;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      f1 = 3.5;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      mpfr_float f2(3.5);
      BOOST_CHECK_EQUAL(f2.precision(), 100);
      mpfr_float f3("5.1");
      BOOST_CHECK_EQUAL(f3.precision(), 100);

      mpfr_float::default_precision(50);
      mpfr_float f4(f3, 50);
      BOOST_CHECK_EQUAL(f4.precision(), 50);
      f4.assign(f1, f4.precision());
      BOOST_CHECK_EQUAL(f4.precision(), 50);
   }
   {
      //
      // Overloads of Math lib functions, discovered while fixing
      // https://github.com/boostorg/multiprecision/issues/91
      //
      mpfr_float::default_precision(100);
      mpfr_float f1;
      f1 = 3;
      BOOST_CHECK_EQUAL(f1.precision(), 100);
      mpfr_float::default_precision(20);
      BOOST_CHECK_EQUAL(asinh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(acosh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(atanh(f1).precision(), 100);
      BOOST_CHECK_EQUAL(cbrt(f1).precision(), 100);
      BOOST_CHECK_EQUAL(erf(f1).precision(), 100);
      BOOST_CHECK_EQUAL(erfc(f1).precision(), 100);
      BOOST_CHECK_EQUAL(expm1(f1).precision(), 100);
      BOOST_CHECK_EQUAL(lgamma(f1).precision(), 100);
      BOOST_CHECK_EQUAL(tgamma(f1).precision(), 100);
      BOOST_CHECK_EQUAL(log1p(f1).precision(), 100);
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_native_integer.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2012 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Compare arithmetic results using fixed_int to GMP results.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/integer.hpp>
#include "test.hpp"

#ifdef BOOST_MSVC
#pragma warning(disable : 4146)
#endif

template <class I, class H>
void test()
{
   using namespace boost::multiprecision;

   I i(0);

#ifndef BOOST_NO_EXCEPTIONS
   BOOST_CHECK_THROW(lsb(i), std::domain_error);
#endif
   BOOST_CHECK(bit_test(bit_set(i, 0), 0));
   BOOST_CHECK_EQUAL(bit_set(i, 0), 1);
   BOOST_CHECK_EQUAL(bit_unset(i, 0), 0);
   BOOST_CHECK_EQUAL(bit_flip(bit_set(i, 0), 0), 0);

   unsigned max_index = (std::numeric_limits<I>::digits) - 1;
   BOOST_CHECK(bit_test(bit_set(i, max_index), max_index));
   BOOST_CHECK_EQUAL(bit_unset(i, max_index), 0);
   BOOST_CHECK_EQUAL(bit_flip(bit_set(i, max_index), max_index), 0);
   i = 0;
   bit_set(i, max_index);
   BOOST_CHECK_EQUAL(lsb(i), max_index);
   BOOST_CHECK_EQUAL(msb(i), max_index);
   bit_set(i, max_index / 2);
   BOOST_CHECK_EQUAL(lsb(i), max_index / 2);
   BOOST_CHECK_EQUAL(msb(i), max_index);

#ifndef BOOST_NO_EXCEPTIONS
   if (std::numeric_limits<I>::is_signed)
   {
      i = static_cast<I>(-1);
      BOOST_CHECK_THROW(lsb(i), std::domain_error);
   }
#endif
   H mx = (std::numeric_limits<H>::max)();

   BOOST_CHECK_EQUAL(multiply(i, mx, mx), static_cast<I>(mx) * static_cast<I>(mx));
   BOOST_CHECK_EQUAL(add(i, mx, mx), static_cast<I>(mx) + static_cast<I>(mx));
   if (std::numeric_limits<I>::is_signed)
   {
      BOOST_CHECK_EQUAL(subtract(i, mx, static_cast<H>(-mx)), static_cast<I>(mx) - static_cast<I>(-mx));
      BOOST_CHECK_EQUAL(add(i, static_cast<H>(-mx), static_cast<H>(-mx)), static_cast<I>(-mx) + static_cast<I>(-mx));
   }

   i   = (std::numeric_limits<I>::max)();
   I j = 12345;
   I r, q;
   divide_qr(i, j, q, r);
   BOOST_CHECK_EQUAL(q, i / j);
   BOOST_CHECK_EQUAL(r, i % j);
   BOOST_CHECK_EQUAL(integer_modulus(i, j), i % j);
   I p = 456;
   BOOST_CHECK_EQUAL(powm(i, p, j), pow(cpp_int(i), static_cast<unsigned>(p)) % j);

   for (I i = 0; i < (2 < 8) - 1; ++i)
   {
      I j = i * i;
      I s, r;
      s = sqrt(j, r);
      BOOST_CHECK_EQUAL(s, i);
      BOOST_CHECK(r == 0);
      j += 3;
      s = sqrt(i, r);
      BOOST_CHECK_EQUAL(s, i);
      BOOST_CHECK(r == 3);
   }
}

int main()
{
   using namespace boost::multiprecision;

   test<std::int16_t, boost::int8_t>();
   test<std::int32_t, std::int16_t>();
   test<std::int64_t, std::int32_t>();
   test<std::uint16_t, boost::uint8_t>();
   test<std::uint32_t, std::uint16_t>();
   test<std::uint64_t, std::uint32_t>();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_cpp_bin_float.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::cpp_bin_float_100>::value, "is_nothrow_move_constructible test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::cpp_bin_float_100>::value, "is_nothrow_move_assignable test");

//
// Construct:
//
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::cpp_bin_float_100>::value, "is_nothrow_default_constructible test");
//
// Copy construct:
//
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::cpp_bin_float_100>::value, "is_nothrow_copy_constructible test");
//
// Assign:
//
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::cpp_bin_float_100>::value, "is_nothrow_copy_assignable test");



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_cpp_dec_float.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_dec_float.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::cpp_dec_float_100>::value, "is_nothrow_move_constructible test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::cpp_dec_float_100>::value, "is_nothrow_move_assignable test");
//
// Construct:
//
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::cpp_dec_float_100>::value, "is_nothrow_constructible test");
//
// Copy construct:
//
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::cpp_dec_float_100>::value, "is_nothrow_copy_constructible test");
//
// Assign:
//
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::cpp_dec_float_100>::value, "is_nothrow_copy_assignable test");



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Construct:
//
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Copy construct:
//
static_assert(!std::is_nothrow_copy_constructible<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Assign:
//
static_assert(!std::is_nothrow_copy_assignable<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Construct from int:
//
static_assert(noexcept(boost::multiprecision::cpp_int(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int128_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int128_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint128_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(!noexcept(boost::multiprecision::checked_uint128_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int512_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int512_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint512_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
static_assert(!noexcept(boost::multiprecision::checked_uint512_t(std::declval<boost::multiprecision::signed_limb_type>())), "noexcept test");
//
// Construct from unsigned int:
//
static_assert(noexcept(boost::multiprecision::cpp_int(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int128_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int128_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint128_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_uint128_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int512_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int512_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint512_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_uint512_t(std::declval<boost::multiprecision::limb_type>())), "noexcept test");
//
// Assign from int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_int>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int128_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int128_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint128_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(!noexcept(std::declval<boost::multiprecision::checked_uint128_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int512_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int512_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint512_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
static_assert(!noexcept(std::declval<boost::multiprecision::checked_uint512_t>() = std::declval<boost::multiprecision::signed_limb_type>()), "noexcept test");
//
// Assign from unsigned int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_int>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int128_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int128_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint128_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_uint128_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int512_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int512_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint512_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_uint512_t>() = std::declval<boost::multiprecision::limb_type>()), "noexcept test");

#if defined(BOOST_LITTLE_ENDIAN) && !defined(BOOST_MP_TEST_NO_LE)
//
// We can also nothrow construct from a double_limb_type (or smaller obviously) as long as double_limb_type is smaller than the type
// in question (so don't test 128-bit integers in case double_limb_type is __int128).
//
// Construct from int:
//
static_assert(noexcept(boost::multiprecision::cpp_int(std::declval<boost::multiprecision::signed_double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int512_t(std::declval<boost::multiprecision::signed_double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int512_t(std::declval<boost::multiprecision::signed_double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint512_t(std::declval<boost::multiprecision::signed_double_limb_type>())), "noexcept test");
static_assert(!noexcept(boost::multiprecision::checked_uint512_t(std::declval<boost::multiprecision::signed_double_limb_type>())), "noexcept test");
//
// Construct from unsigned int:
//
static_assert(noexcept(boost::multiprecision::cpp_int(std::declval<boost::multiprecision::double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::int512_t(std::declval<boost::multiprecision::double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_int512_t(std::declval<boost::multiprecision::double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::uint512_t(std::declval<boost::multiprecision::double_limb_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::checked_uint512_t(std::declval<boost::multiprecision::double_limb_type>())), "noexcept test");
//
// Assign from int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_int>() = std::declval<boost::multiprecision::signed_double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()), "noexcept test");
static_assert(!noexcept(std::declval<boost::multiprecision::checked_uint512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()), "noexcept test");
//
// Assign from unsigned int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_int>() = std::declval<boost::multiprecision::double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::int512_t>() = std::declval<boost::multiprecision::double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_int512_t>() = std::declval<boost::multiprecision::double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::uint512_t>() = std::declval<boost::multiprecision::double_limb_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::checked_uint512_t>() = std::declval<boost::multiprecision::double_limb_type>()), "noexcept test");

#endif // little endian

typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> >     checked_int32_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> >   checked_uint32_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >   unchecked_int32_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<32, 32, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > unchecked_uint32_t;

//
// Construct from int:
//
static_assert(noexcept(unchecked_int32_t(std::declval<std::int32_t>())), "noexcept test");
static_assert(noexcept(checked_int32_t(std::declval<std::int32_t>())), "noexcept test");
static_assert(noexcept(unchecked_uint32_t(std::declval<std::int32_t>())), "noexcept test");
static_assert(!noexcept(checked_uint32_t(std::declval<std::int32_t>())), "noexcept test");
//
// Construct from unsigned int:
//
static_assert(noexcept(unchecked_int32_t(std::declval<std::uint32_t>())), "noexcept test");
static_assert(noexcept(checked_int32_t(std::declval<std::uint32_t>())), "noexcept test");
static_assert(noexcept(unchecked_uint32_t(std::declval<std::uint32_t>())), "noexcept test");
static_assert(noexcept(checked_uint32_t(std::declval<std::uint32_t>())), "noexcept test");
//
// Assign from int:
//
static_assert(noexcept(std::declval<unchecked_int32_t>() = std::declval<std::int32_t>()), "noexcept test");
static_assert(noexcept(std::declval<checked_int32_t>() = std::declval<std::int32_t>()), "noexcept test");
static_assert(noexcept(std::declval<unchecked_uint32_t>() = std::declval<std::int32_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_uint32_t>() = std::declval<std::int32_t>()), "noexcept test");
//
// Assign from unsigned int:
//
static_assert(noexcept(std::declval<unchecked_int32_t>() = std::declval<std::uint32_t>()), "noexcept test");
static_assert(noexcept(std::declval<checked_int32_t>() = std::declval<std::uint32_t>()), "noexcept test");
static_assert(noexcept(std::declval<unchecked_uint32_t>() = std::declval<std::uint32_t>()), "noexcept test");
static_assert(noexcept(std::declval<checked_uint32_t>() = std::declval<std::uint32_t>()), "noexcept test");

//
// And finally some things which should *not* be noexcept:
//
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<30, 30, boost::multiprecision::signed_magnitude, boost::multiprecision::checked, void> >     checked_int30_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<30, 30, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> >   checked_uint30_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<30, 30, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >   unchecked_int30_t;
typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<30, 30, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> > unchecked_uint30_t;

//
// Construct from int:
//
static_assert(!noexcept(checked_int30_t(std::declval<std::int32_t>())), "noexcept test");
static_assert(!noexcept(checked_uint30_t(std::declval<std::int32_t>())), "noexcept test");
static_assert(!noexcept(checked_int32_t(std::declval<std::int64_t>())), "noexcept test");
static_assert(!noexcept(checked_uint32_t(std::declval<std::int64_t>())), "noexcept test");
//
// Construct from unsigned int:
//
static_assert(!noexcept(checked_int30_t(std::declval<std::uint32_t>())), "noexcept test");
static_assert(!noexcept(checked_uint30_t(std::declval<std::uint32_t>())), "noexcept test");
static_assert(!noexcept(checked_int32_t(std::declval<std::uint64_t>())), "noexcept test");
static_assert(!noexcept(checked_uint32_t(std::declval<std::uint64_t>())), "noexcept test");
//
// Assign from int:
//
static_assert(!noexcept(std::declval<checked_int30_t>() = std::declval<std::int32_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_uint30_t>() = std::declval<std::int32_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_int32_t>() = std::declval<std::int64_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_uint32_t>() = std::declval<std::int64_t>()), "noexcept test");
//
// Assign from unsigned int:
//
static_assert(!noexcept(std::declval<checked_int30_t>() = std::declval<std::uint32_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_uint30_t>() = std::declval<std::uint32_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_int32_t>() = std::declval<std::uint64_t>()), "noexcept test");
static_assert(!noexcept(std::declval<checked_uint32_t>() = std::declval<std::uint64_t>()), "noexcept test");

//
// Check regular construct/assign as well, see https://github.com/boostorg/multiprecision/issues/383
//
//
// Move assign:
//
static_assert(std::is_move_assignable<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_move_assignable<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Construct:
//
static_assert(std::is_default_constructible<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_default_constructible<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Copy construct:
//
static_assert(std::is_copy_constructible<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_copy_constructible<boost::multiprecision::checked_uint512_t>::value, "noexcept test");
//
// Assign:
//
static_assert(std::is_copy_assignable<boost::multiprecision::cpp_int>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::int128_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::checked_int128_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::uint128_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::checked_uint128_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::int512_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::checked_int512_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::uint512_t>::value, "noexcept test");
static_assert(std::is_copy_assignable<boost::multiprecision::checked_uint512_t>::value, "noexcept test");


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_cpp_rational.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/cpp_int.hpp>
#include <type_traits>

typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::int128_t::backend_type> >  rat128_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::uint128_t::backend_type> > urat128_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::int512_t::backend_type> >  rat512_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::uint512_t::backend_type> > urat512_t;

typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_int128_t::backend_type> >  checked_rat128_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint128_t::backend_type> > checked_urat128_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_int512_t::backend_type> >  checked_rat512_t;
typedef boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::checked_uint512_t::backend_type> > checked_urat512_t;

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::cpp_rational>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<rat128_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<checked_rat128_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<urat128_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<checked_urat128_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<rat512_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<checked_rat512_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<urat512_t>::value, "is_nothrow_move_constructible test");
static_assert(std::is_nothrow_move_constructible<checked_urat512_t>::value, "is_nothrow_move_constructible test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::cpp_rational>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<rat128_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<checked_rat128_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<urat128_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<checked_urat128_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<rat512_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<checked_rat512_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<urat512_t>::value, "is_nothrow_move_assignable test");
static_assert(std::is_nothrow_move_assignable<checked_urat512_t>::value, "is_nothrow_move_assignable test");

#if 0
//
// Everything below could/should be made to work, given modifications to Boost.Rational
//


//
// Construct:
//
#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR
static_assert(boost::has_nothrow_constructor<boost::multiprecision::cpp_rational>::value);
static_assert(boost::has_nothrow_constructor<rat128_t>::value);
static_assert(boost::has_nothrow_constructor<checked_rat128_t>::value);
static_assert(boost::has_nothrow_constructor<urat128_t>::value);
static_assert(boost::has_nothrow_constructor<checked_urat128_t>::value);
static_assert(boost::has_nothrow_constructor<rat512_t>::value);
static_assert(boost::has_nothrow_constructor<checked_rat512_t>::value);
static_assert(boost::has_nothrow_constructor<urat512_t>::value);
static_assert(boost::has_nothrow_constructor<checked_urat512_t>::value);
#endif
//
// Copy construct:
//
#ifdef BOOST_HAS_NOTHROW_COPY
static_assert(!boost::has_nothrow_copy<boost::multiprecision::cpp_rational>::value);
static_assert(boost::has_nothrow_copy<rat128_t>::value);
static_assert(boost::has_nothrow_copy<checked_rat128_t>::value);
static_assert(boost::has_nothrow_copy<urat128_t>::value);
static_assert(boost::has_nothrow_copy<checked_urat128_t>::value);
static_assert(boost::has_nothrow_copy<rat512_t>::value);
static_assert(boost::has_nothrow_copy<checked_rat512_t>::value);
static_assert(boost::has_nothrow_copy<urat512_t>::value);
static_assert(boost::has_nothrow_copy<checked_urat512_t>::value);
#endif
//
// Assign:
//
#ifdef BOOST_HAS_NOTHROW_ASSIGN
static_assert(!boost::has_nothrow_assign<boost::multiprecision::cpp_rational>::value);
static_assert(boost::has_nothrow_assign<rat128_t>::value);
static_assert(boost::has_nothrow_assign<checked_rat128_t>::value);
static_assert(boost::has_nothrow_assign<urat128_t>::value);
static_assert(boost::has_nothrow_assign<checked_urat128_t>::value);
static_assert(boost::has_nothrow_assign<rat512_t>::value);
static_assert(boost::has_nothrow_assign<checked_rat512_t>::value);
static_assert(boost::has_nothrow_assign<urat512_t>::value);
static_assert(boost::has_nothrow_assign<checked_urat512_t>::value);
#endif
//
// Construct from int:
//
static_assert(noexcept(boost::multiprecision::cpp_rational(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(rat128_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(checked_rat128_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(urat128_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(!noexcept(checked_urat128_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(rat512_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(checked_rat512_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(noexcept(urat512_t(std::declval<boost::multiprecision::signed_limb_type>())));
static_assert(!noexcept(checked_urat512_t(std::declval<boost::multiprecision::signed_limb_type>())));
//
// Construct from unsigned int:
//
static_assert(noexcept(boost::multiprecision::cpp_rational(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(rat128_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(checked_rat128_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(urat128_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(checked_urat128_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(rat512_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(checked_rat512_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(urat512_t(std::declval<boost::multiprecision::limb_type>())));
static_assert(noexcept(checked_urat512_t(std::declval<boost::multiprecision::limb_type>())));
//
// Assign from int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_rational>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<rat128_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<checked_rat128_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<urat128_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(!noexcept(std::declval<checked_urat128_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<rat512_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<checked_rat512_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(noexcept(std::declval<urat512_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
static_assert(!noexcept(std::declval<checked_urat512_t>() = std::declval<boost::multiprecision::signed_limb_type>()));
//
// Assign from unsigned int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_rational>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<rat128_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<checked_rat128_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<urat128_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<checked_urat128_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<rat512_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<checked_rat512_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<urat512_t>() = std::declval<boost::multiprecision::limb_type>()));
static_assert(noexcept(std::declval<checked_urat512_t>() = std::declval<boost::multiprecision::limb_type>()));

#if defined(BOOST_LITTLE_ENDIAN)
//
// Construct from int:
//
static_assert(noexcept(boost::multiprecision::cpp_rational(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(rat128_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(checked_rat128_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(urat128_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(!noexcept(checked_urat128_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(rat512_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(checked_rat512_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(noexcept(urat512_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
static_assert(!noexcept(checked_urat512_t(std::declval<boost::multiprecision::signed_double_limb_type>())));
//
// Construct from unsigned int:
//
static_assert(noexcept(boost::multiprecision::cpp_rational(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(rat128_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(checked_rat128_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(urat128_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(checked_urat128_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(rat512_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(checked_rat512_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(urat512_t(std::declval<boost::multiprecision::double_limb_type>())));
static_assert(noexcept(checked_urat512_t(std::declval<boost::multiprecision::double_limb_type>())));
//
// Assign from int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_rational>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<rat128_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<checked_rat128_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<urat128_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(!noexcept(std::declval<checked_urat128_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<rat512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<checked_rat512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(noexcept(std::declval<urat512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
static_assert(!noexcept(std::declval<checked_urat512_t>() = std::declval<boost::multiprecision::signed_double_limb_type>()));
//
// Assign from unsigned int:
//
static_assert(noexcept(std::declval<boost::multiprecision::cpp_rational>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<rat128_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<checked_rat128_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<urat128_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<checked_urat128_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<rat512_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<checked_rat512_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<urat512_t>() = std::declval<boost::multiprecision::double_limb_type>()));
static_assert(noexcept(std::declval<checked_urat512_t>() = std::declval<boost::multiprecision::double_limb_type>()));

#endif
#endif // little endian


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_float128.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/float128.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::float128>::value, "noexcept test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::float128>::value, "noexcept test");
//
// Construct:
//
static_assert(std::is_nothrow_default_constructible<boost::multiprecision::float128>::value, "noexcept test");
//
// Copy construct:
//
static_assert(std::is_nothrow_copy_constructible<boost::multiprecision::float128>::value, "noexcept test");
//
// Assign:
//
static_assert(std::is_nothrow_copy_assignable<boost::multiprecision::float128>::value, "noexcept test");

static_assert(noexcept(boost::multiprecision::float128()), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<const boost::multiprecision::float128&>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<boost::multiprecision::float128>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<const float128_type&>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<float128_type>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<const double&>())), "noexcept test");
static_assert(noexcept(boost::multiprecision::float128(std::declval<double>())), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<const boost::multiprecision::float128&>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<boost::multiprecision::float128>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<const float128_type&>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<float128_type>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<const double&>()), "noexcept test");
static_assert(noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<double>()), "noexcept test");

struct any_convert
{
   template <class T>
   operator T() const; // Can throw!
};

static_assert(!noexcept(boost::multiprecision::float128(std::declval<const any_convert&>())), "noexcept test");
static_assert(!noexcept(boost::multiprecision::float128(std::declval<any_convert>())), "noexcept test");
static_assert(!noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<const any_convert&>()), "noexcept test");
static_assert(!noexcept(std::declval<boost::multiprecision::float128&>() = std::declval<any_convert>()), "noexcept test");



================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_gmp.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/gmp.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::mpz_int>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::mpq_rational>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::mpf_float>::value, "noexcept test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::mpz_int>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::mpq_rational>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::mpf_float>::value, "noexcept test");


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_nothrow_mpfr.cpp
================================================
///////////////////////////////////////////////////////////////////////////////
//  Copyright 2015 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/multiprecision/mpfr.hpp>
#include <type_traits>

//
// Move construct:
//
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::mpfr_float>::value, "noexcept test");
static_assert(std::is_nothrow_move_constructible<boost::multiprecision::mpfr_float_100>::value, "noexcept test");
//
// Move assign:
//
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::mpfr_float>::value, "noexcept test");
static_assert(std::is_nothrow_move_assignable<boost::multiprecision::mpfr_float_100>::value, "noexcept test");


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_numeric_limits.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_MPZ) &&         \
    !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPQ) && \
    !defined(TEST_TOMMATH) && !defined(TEST_CPP_INT) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPF
#define TEST_BACKEND
#define TEST_MPZ
#define TEST_MPFR
#define TEST_MPFR_50
#define TEST_CPP_DEC_FLOAT
#define TEST_MPQ
#define TEST_TOMMATH
#define TEST_CPP_INT
#define TEST_MPFI_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50) || defined(TEST_MPF) || defined(TEST_MPZ) || defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_MPFR) || defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

#define PRINT(x) \
   std::cout << BOOST_STRINGIZE(x) << " = " << std::numeric_limits<Number>::x << std::endl;

template <class Number>
void test_specific(const std::integral_constant<int, boost::multiprecision::number_kind_floating_point>&)
{
   Number minv, maxv;
   minv = (std::numeric_limits<Number>::min)();
   maxv = (std::numeric_limits<Number>::max)();
   BOOST_CHECK((boost::math::isnormal)(minv));
   BOOST_CHECK((boost::math::isnormal)(maxv));
   BOOST_CHECK((boost::math::isnormal)(log(minv)));
   BOOST_CHECK((boost::math::isnormal)(log(maxv)));
   BOOST_CHECK((boost::math::isnormal)(sqrt(minv)));
   BOOST_CHECK((boost::math::isnormal)(sqrt(maxv)));

   if (std::numeric_limits<Number>::is_specialized)
   {
      if (std::numeric_limits<Number>::has_quiet_NaN)
      {
         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::quiet_NaN()));
         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::quiet_NaN()));
         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::quiet_NaN()));
         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::quiet_NaN()));
         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::quiet_NaN()));
      }
      if (std::numeric_limits<Number>::has_signaling_NaN)
      {
         BOOST_TEST((boost::math::isnan)(std::numeric_limits<Number>::signaling_NaN()));
         BOOST_TEST(FP_NAN == (boost::math::fpclassify)(std::numeric_limits<Number>::signaling_NaN()));
         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::signaling_NaN()));
         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::signaling_NaN()));
         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::signaling_NaN()));
      }
      if (std::numeric_limits<Number>::has_infinity)
      {
         BOOST_TEST((boost::math::isinf)(std::numeric_limits<Number>::infinity()));
         BOOST_TEST(FP_INFINITE == (boost::math::fpclassify)(std::numeric_limits<Number>::infinity()));
         BOOST_TEST(!(boost::math::isfinite)(std::numeric_limits<Number>::infinity()));
         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::infinity()));
         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::infinity()));
      }
      if (std::numeric_limits<Number>::has_denorm == std::denorm_present)
      {
         BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)(std::numeric_limits<Number>::denorm_min()));
         BOOST_TEST(FP_SUBNORMAL == (boost::math::fpclassify)((std::numeric_limits<Number>::min)() / 2));
         BOOST_TEST((boost::math::isfinite)(std::numeric_limits<Number>::denorm_min()));
         BOOST_TEST(!(boost::math::isnormal)(std::numeric_limits<Number>::denorm_min()));
         BOOST_TEST(!(boost::math::isinf)(std::numeric_limits<Number>::denorm_min()));
         BOOST_TEST(!(boost::math::isnan)(std::numeric_limits<Number>::denorm_min()));
         BOOST_TEST(0 == std::numeric_limits<Number>::denorm_min() / 2);
         BOOST_TEST(0 != (std::numeric_limits<Number>::min)() / 2);
         BOOST_TEST(0 != std::numeric_limits<Number>::denorm_min());
      }
   }
   Number n = 0;
   BOOST_TEST((boost::math::fpclassify)(n) == FP_ZERO);
   BOOST_TEST((boost::math::isfinite)(n));
   BOOST_TEST(!(boost::math::isnormal)(n));
   BOOST_TEST(!(boost::math::isinf)(n));
   BOOST_TEST(!(boost::math::isnan)(n));
   n = 2;
   BOOST_TEST((boost::math::fpclassify)(n) == FP_NORMAL);
   BOOST_TEST((boost::math::isfinite)(n));
   BOOST_TEST((boost::math::isnormal)(n));
   BOOST_TEST(!(boost::math::isinf)(n));
   BOOST_TEST(!(boost::math::isnan)(n));

   if (std::numeric_limits<Number>::round_style == std::round_to_nearest)
   {
      BOOST_CHECK_EQUAL(std::numeric_limits<Number>::round_error(), 0.5);
   }
   else if (std::numeric_limits<Number>::round_style != std::round_indeterminate)
   {
      // Round error is 1.0:
      BOOST_CHECK_EQUAL(std::numeric_limits<Number>::round_error(), 1);
   }
   else
   {
      // Round error is presumably somewhere between 0.5 and 1:
      BOOST_CHECK((std::numeric_limits<Number>::round_error() <= 1) && (std::numeric_limits<Number>::round_error() >= 0.5));
   }
}

template <class Number>
void test_specific(const std::integral_constant<int, boost::multiprecision::number_kind_integer>&)
{
   if (std::numeric_limits<Number>::is_modulo)
   {
      if (!std::numeric_limits<Number>::is_signed)
      {
         BOOST_TEST(1 + (std::numeric_limits<Number>::max)() == 0);
         BOOST_TEST(--Number(0) == (std::numeric_limits<Number>::max)());
      }
   }
}

template <class Number, class T>
void test_specific(const T&)
{
}

template <class Number>
void test()
{
   typedef typename std::conditional<
       std::numeric_limits<Number>::is_specialized,
       typename boost::multiprecision::number_category<Number>::type,
       std::integral_constant<int, 500> // not a number type
       >::type fp_test_type;

   test_specific<Number>(fp_test_type());

   //
   // Note really a test just yet, but we can at least print out all the values:
   //
   std::cout << "numeric_limits values for type " << typeid(Number).name() << std::endl;

   PRINT(is_specialized);
   if (std::numeric_limits<Number>::is_integer)
   {
      std::cout << std::hex << std::showbase;
   }
   std::cout << "max()"
             << " = " << (std::numeric_limits<Number>::max)() << std::endl;
   if (std::numeric_limits<Number>::is_integer)
   {
      std::cout << std::dec;
   }
   std::cout << "max()"
             << " = " << (std::numeric_limits<Number>::max)() << std::endl;
   std::cout << "min()"
             << " = " << (std::numeric_limits<Number>::min)() << std::endl;
   PRINT(lowest());
   PRINT(digits);
   PRINT(digits10);
   PRINT(max_digits10);
   PRINT(is_signed);
   PRINT(is_integer);
   PRINT(is_exact);
   PRINT(radix);
   PRINT(epsilon());
   PRINT(round_error());
   PRINT(min_exponent);
   PRINT(min_exponent10);
   PRINT(max_exponent);
   PRINT(max_exponent10);
   PRINT(has_infinity);
   PRINT(has_quiet_NaN);
   PRINT(has_signaling_NaN);
   PRINT(has_denorm);
   PRINT(has_denorm_loss);
   PRINT(infinity());
   PRINT(quiet_NaN());
   PRINT(signaling_NaN());
   PRINT(denorm_min());
   PRINT(is_iec559);
   PRINT(is_bounded);
   PRINT(is_modulo);
   PRINT(traps);
   PRINT(tinyness_before);
   PRINT(round_style);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
#endif
#ifdef TEST_MPF
   boost::multiprecision::mpf_float::default_precision(1000);
   /*
   boost::multiprecision::mpf_float r;
   r.precision(50);
   BOOST_TEST(r.precision() >= 50);
   */
   BOOST_TEST(boost::multiprecision::mpf_float::default_precision() == 1000);
   test<boost::multiprecision::mpf_float>();
#endif
#ifdef TEST_MPZ
   test<boost::multiprecision::mpz_int>();
#endif
#ifdef TEST_MPQ
   test<boost::multiprecision::mpq_rational>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float>();
#endif
#ifdef TEST_TOMMATH
   test<boost::multiprecision::tom_int>();
#endif
#ifdef TEST_CPP_INT
   test<boost::multiprecision::cpp_int>();
   test<boost::multiprecision::int256_t>();
   test<boost::multiprecision::uint512_t>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<200, 200, boost::multiprecision::unsigned_magnitude, boost::multiprecision::checked, void> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<70, 70, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> > >();
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_optional_compat.cpp
================================================
/*
 *  (c) Copyright Andrey Semashev 2018.
 *
 *  Use, modification and distribution are subject to the
 *  Boost Software License, Version 1.0. (See accompanying file
 *  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
/*
 * The test verifies that Boost.Multiprecision does not cause conflict with Boost.Optional
 * because of its restricted conversion constructors and operators. See comments in:
 *
 * https://github.com/boostorg/integer/pull/11
 */

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/optional/optional.hpp>
#include <boost/core/lightweight_test.hpp>

inline boost::optional<boost::multiprecision::int128_t> foo()
{
   return boost::optional<boost::multiprecision::int128_t>(10);
}

int main()
{
   boost::optional<boost::multiprecision::int128_t> num = foo();
   BOOST_TEST(!!num);
   BOOST_TEST(*num == 10);

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_pow.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
//#  define TEST_MPF
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<boost::array<const char*, 3>, 702> data =
       {{
           {{"9.85291419463953934609889984130859375e4", "8.4167086266170372255146503448486328125e2", "8.66781019918879108354226292713799369912745098619466567318041467361236175866573114777000418440761829061824953361563557580935951901405814080757565313129904800947783606850513184296612628910656615168927761935861462770335134108408073175949783551491164949747086136599355880600420490275164555515512645668845e4202"}},
           {{"1.652914355109703592461301013827323913574218750e1", "4.936528947862250937816952500725165009498596191406250e-2", "1.14852190138491736562279120519668390081141778746743826681517181158751264571350304943298501284647564489716027476004029804110782430201351750715968215799574772058637701195873519618784612525011353325208230847515250406858209757415407239793739704829281917272032288615255140733409015874140869835291148547238"}},
           {{"2.95673953882856110908505797851830720901489257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.3091550971799097169423475861549377441406250e2", "9.16137091634529046709182958669115589757019722367818747705232600776240821857227718551873067599347313641575272826830417174591636547915061517391300131065931465784194067711359196329143298499263726513131614582697830908424187934868152998838921216586737465291051289708299364409624364999366486746226077050764e249"}},
           {{"6.085814876798215132883140832120716368081048130989074707031250e-5", "7.65778516457987279864028096199035644531250e2", "5.27056224622668410282266686919173718609676411389459024877282902746284033954589536288634973757568176464096389580016576960309487231057438455595655805167665817497028295657665023126747065443986739792258870082022889306909488139458069146748438042701949551909468708242176394539901613782225328586614222105675e-3229"}},
           {{"2.722646144868545725614694674732163548469543457031250e-1", "4.8695443455590336004346063702996616484597325325012207031250e-4", "9.99366682241962146368589809577120011723198308450433185299366732500677873637460155970547267099719914327909694930518383012498797681761846242526638144261306834523078708261122471803832490341687603813336927181436827534082878781252668704774445437548691251936499670077735883150461534069270846997649139259014e-1"}},
           {{"1.15866069758449596882599053060403093695640563964843750e-1", "4.91253262757665787319183436920866370201110839843750e-1", "3.46868982488456565751167443881314840659743514173491612010770748877346398177489343237604160804413931931718223750314831998907846386274396179552445359933868165880372381338724806279781831953896898649659594755834925976964179275873971118494605322798850925802574178528777014182338769959249415096934378557388e-1"}},
           {{"4.72825938314130529761314392089843750e5", "1.228931327397812367507867747917771339416503906250e1", "5.47245157077269889091085696140795527282280334677569169487973419233796250189843816560261965111196061138868370890204338231535198008079068304184762140493830719955323588998399173073261634891767823614143691840392792367527470000847416054709559319143615840412839768396194451923527439592939735228732869467965e69"}},
           {{"1.2955657225533417658880352973937988281250e4", "1.81521083299418428680382930906489491462707519531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.91729899451736210436889587963352494969987265352294254442114149825297350300933403119961677078224257818567229354512108221647637427508041941647518586565006416113534560289731038664091154857692367872604020422463457596747145816854139701847749519264660326361171185139298113322096978245544144264234481020815e7"}},
           {{"1.7430590914513759344117715954780578613281250e3", "1.5572745970949500304847390452778199687600135803222656250e-2", "1.12324923143821767715038683964417533829057341785931080679952341815408539775130405061465897612861320390765996927155081774925717154208894105154455487856335006846587865128269477586014136390788140643457017602926503892493119037260205017744346004538379559837051387829449807650507431889923695496342461088404"}},
           {{"5.947230963297863581829005852341651916503906250e1", "2.4796058491402149168147950319962546927854418754577636718750e-4", "1.00101355895664265703253905800820834352012946978175213925289823900262226487475877307647753894219794796436589570196875943062842928843129407133278574235943906905626144071246066853301987332156463703818534415183682692042219695734377740067313312425523058170350486981674302932951851973390826740834796342180"}},
           {{"1.6890881194976660012148708678303421493183122947812080383300781250e-6", "7.315835005101905608171364292502403259277343750e1", "5.06485337562137503941405427253471002412719863672407294570575625371322654317127374055512455786988091092329605000808871766177184698431732837248355728401235010135527651826220232715652024742668291949645619992685612328535253252695622896976648954823150769316159100729259724133493553742448044299816541989455e-423"}},
           {{"4.72470471679805708838453814912838879536138847470283508300781250e-6", "1.9315009754541449638054473325610160827636718750e1", "1.36613880262643802742756290736395850668317512466586871167321608424137867570108690626258507320043808302565319397131444616166042735793688809613906106252620462557968555895414582976985576875374557668514391264049547180886976991031038592004458693177738810104222966751846844587127740341157319952915743398285e-103"}},
           {{"5.4204233294109713248154491793684428557753562927246093750e-3", "2.5117484913880550045917061652289703488349914550781250e-2", "8.77171703127754502681310204125715941650801721154976863870699221072355335125966565182666925044598746890911836338141033359039531496488403405876863230608143768785806156629534985369811294999635059473513624761915818310578096052710097713441725036078711101258417410421951107958524860020565804089659046743943e-1"}},
           {{"1.0381492965649719018017549387877807021141052246093750e-1", "4.02775539432865528274851918411059159552678465843200683593750e-5", "9.99908769642175788386137778958539300137602918424410284952085874015336769726750047569734816766197409755257562872230833189101650544474710424482558254479079319860825174137124403380959665595507587367668848404286717760343524270837960434045414179621713212480893218438355518348995643697164109731552178914851e-1"}},
           {{"3.826356416302296565845608711242675781250e3", "3.046966451443047785296869278681697323918342590332031250e-3", "1.02545504718938094372102791727911930176506035001600018053644429991055918696319033730794852043021666923875675436795843500904336366408589219201909169612259476814126333181168932741070039124737361896932592045285182764869916877379718622220890978571031406624988992549594836404906978120992311725853941493659"}},
           {{"1.3367248690647914877160928881494328379631042480468750e-1", "1.207016212032306157198036089539527893066406250e1", "2.82608741435940656086722594561546646099634760918110959565977761208896418216166536561903222226214939613599640463597249764023513875896636280664458251642404729724932181291845871312202787897768372355186920789243514016890287945724482698867187289280837997988218972650355222505584789955736058952829050123955e-11"}},
           {{"7.8880385490801472769817337393760681152343750e2", "1.46278561425722486433187441434711217880249023437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.72840141730863663391876877521764355960382145920572562742914162972208384723706307292705275033115082012368548682595775882643927894139786449383322664316773126131611883398659050539189893838100041408464889082404113404032943316931275847874983317572290683797208861989532362102600980996636385789799495020849e4"}},
           {{"6.0290844501169942759588593617081642150878906250e1", "2.73159824509963122807221225230023264884948730468750e-1", "3.06403097260563050081855800637166449495962164712719263330810086375883439970326530663445685346228862337912240907582664457942174627433334293660419014781254710335542481599007896808711916825623070383641755045318205803207383228319360990374222920104547227487223738392731388028498147565624523546346417715655"}},
           {{"5.2188207927001606378780707018449902534484863281250e-1", "1.00797343550563134328967862529680132865905761718750e-1", "9.36552325485277806964373331313098838333278330423455390715861973295876349888773267892681165876113176797510574847645252615081953879524429911159719101193921387688552351634752458416166446355778230365755243829643708299147847893065939954861919388676503519612640610354931769525373202729617723199328630093636e-1"}},
           {{"6.21172003041995424155174987390637397766113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "8.6091943502081919400601914271753400953457457944750785827636718750e-7", "1.00000157241706535645559625081132898066253320364132991765749046567536915342813631920409642832019004224458248512335711478395060579077427182783938451114029622700384959716532968625901664719629811957905865676402174328291417935322613778738659214041802729741480722967793087943757739011593472415850478420639"}},
           {{"8.933489431168359015678070988997205859050154685974121093750e-4", "4.1532229397912578860996291041374206542968750e2", "4.91021563983953636397848520840523223624643742835964326188016961937573012460753870407293657436708430593126320103796954182972032017026192445957161066771807675200884423939605981304732630092257312925408813941089831976477439943114677798839623996214029155361569909503935179401196449493080818512569086682097e-1267"}},
           {{"5.55105519395504379644989967346191406250e4", "2.205612949903890118719118618173524737358093261718750e-1", "1.11282177288045201072507504088709286277978249266318510332909847928909226338145185595245293917086320817076726850666066198249106037631163063795831697507293260413136608221812252367908447186422344164553977681855896096040438700902356349275031836676568495994537852124264298684105398360497193752327260914137e1"}},
           {{"2.64139377644600310476863391784263512818142771720886230468750e-5", "7.78537344498752810831310178230069141136482357978820800781250e-5", "9.99179632299559171314926709030763809736309139005374052895886931807671532458904052556141342139885810036321222015645710865315806166952058325774560966552187527103940189373824279065702873017246336399071137612269219545181070886990906061668084063703411460250321467244169857420435253409159030432098292621067e-1"}},
           {{"1.04207364225271594477817416191101074218750e4", "9.490963248606765212400659947888925671577453613281250e-4", "1.00881927761618177965011845644574187803759898330801723609976606642566910129111150781463974721119043760111173993259232795682413324213317011846206782754096089290427628991647487342082014619699610677423897602146820644840945077548746946762791624180147374361784328110343084702444523109612274014821745626982"}},
           {{"3.3151932056626380942998544298916385741904377937316894531250e-4", "5.69130350190431280252290058285780105507001280784606933593750e-5", "9.99544126695324189746630737456946723361046661345027805407888971023026631339988056392642825478722792254481831582440796961181158845762815786131168245934078509438401554967954057934563178474479427510608187860234090448388699710858468168174057416883471915845617321874136073232354461932587707630236256378020e-1"}},
           {{"1.88337177923367888807137937590141518739983439445495605468750e-4", "4.32540268863411711208755150437355041503906250e2", "5.75229630554212330195665922771148699451829771147200356624805857657236782065140481467338634818457146889580617522654929450001033313425457042558128784684181381335537144806647956114444609625124141647264003246426211941949785732284342909061255617831919446477154897012961652269654460432165747451828975060062e-1612"}},
           {{"3.9545929052570905071206652792170643806457519531250e-1", "2.677916713784273921835146770042968000780092552304267883300781250e-6", "9.99997515679857005761440503886095927815406391244413835291624899797364615653895949902813000744851723242602512239539568754651988070279277456656779917196036522934849059282355864096704432345340316634144618927930200708582994637711792811242475638942101629267185320507818308058050356385241284795438747530570e-1"}},
           {{"4.18765706320910169324633898213505744934082031250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.16291806714740175721090054139494895935058593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.21448401185251170746394861880464242649255630391558005989017991140563422704674077045117022763467561974222030061746655113958910240758539727055748249625892285904547489203480154655618632992990390332430221914382681227157928848406067945057161854616129785541408035327136685741399621377579757754012545382969e1"}},
           {{"1.28834086985551640736069600734481355175375938415527343750e-3", "3.5070592325596103289164773286756826564669609069824218750e-3", "9.76932835372685523370171735287063726416767225734834615849134547109660778793799398169080725972094573408844765674179657286895933198717192952354877012591779343412877647689917686841315165602494901218010719779271020694334581849406783713948998204010537229621398578990055098138781426451663477493080600789821e-1"}},
           {{"2.097206120446792887435094598913565278053283691406250e-2", "4.58040082173553630973117378744063898921012878417968750e-2", "8.37769288971832154015429547694831033608424622845142547611771987181607855769209591840464089347717993026475816138178319620101164703046235086673631394869476080594839931563796671833715053698127488579638544943331524253087769152813629459325853986427109398088052746438762088357925061124187186100435982047033e-1"}},
           {{"2.86348409095251425380765364359092473023338243365287780761718750e-6", "1.661473408152986941388462582835927605628967285156250e-1", "1.19957610695947876947018322120150143406142221469373757924519795345150006977773403730313023369079301615734601162566867121616810596830759956044509310651071485457850172811241087990683705383118703983140409701647142571470333867908682196499347683237058377349085352136214854181401946343510795949868835711429e-1"}},
           {{"1.43297873345568077638745307922363281250e5", "1.41681240009364082165985165850941029930254444479942321777343750e-5", "1.00016822776212044529668140515271000711944889104836686684000447554242511520504646895662976301872271981369559245931879055379226726537073846553544561947637792091890791964244339592472180091648456672557297620691698497967178088487062658421331764320606009571740080394934111049676474128724114098218934644280"}},
           {{"3.60098653144944158555063040694221854209899902343750e-1", "2.03376339210932499668160744477063417434692382812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.25275538744154336055615419863736730746930928726962752118772852620054361808569416481449220736645770958820155429279907622983889720952174836443567087662689941130263300184594808723215176724531461369529244321399979413684112346655770810116945662086924599874483949305102682382993398648882273436739947930631e-1"}},
           {{"5.295402011714999248107038631872001133160665631294250488281250e-5", "4.561361486960971434179157313337782397866249084472656250e-3", "9.56082033932816309081231125453071826327896674917466727856568147854623107132514590973229074834141556000908164346345063684708226886531162257152516511661460364047957606893852284251293056880030888612998267350454535860387161852393199580592248818623376237183284153405740445167284591706260229351268548628924e-1"}},
           {{"1.44301800298425852986383688403293490409851074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.143083929538946623763462362433074304135516285896301269531250e-6", "1.00000261963485792416853927136569198682383793838454319729684734973539039182323306199235318171814360855994012568229358281529883676852371448365509202038288834881570383584403906835594533516647281713968932211752518665238323196577224701747937440185305151190908616249351775361542696295892178890063882257116"}},
           {{"6.228038096295846273720009378394024679437279701232910156250e-4", "3.25094187232484732597015408828156068921089172363281250e-2", "7.86658469541403998034943500870243069476823132486007751990824694615782893644279173776512596334159142603325455113617967643461939139102971978114976150505918018758878971981207590718138194009315889095960072548673588879789986017926322494375432269097377546556386620403909103214427884440798206932883636297352e-1"}},
           {{"9.8555361955851549282670021057128906250e2", "2.19375835372379413001908687874674797058105468750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.69327012293708811121144971175263370083910101169553278058859848877086709080419562447585355719348842415619132355236627485649548952876411849102018675375354238273102815474095986357261970461229247085634624604985094330242448976955585994530902647027597520370418448678147789523361182103563378206595110636366e6"}},
           {{"3.5879392216430850207076197477817913750186562538146972656250e-4", "6.9182884453136028746200736350147053599357604980468750e-2", "5.77635990889125108309690852819112724262223736693646969131631611067612444282401471024845889526676870050656945639578159737127915466435929600368572355785708484463627825178182883323088006398240693308602881027224033181200011330121428663774743869527395379215026638702157803494202819893449358544841576526785e-1"}},
           {{"4.961468486142577603459358215332031250e3", "5.36919182658175953015700088144512847065925598144531250e-2", "1.57915370211935194723362359441601671775858730114448762856923579370262681814508708674839371719677055754578289843591415190008400693094242195743768201495967775525358591358166609121796030602701836084062498854380733868656008519376928763241674707747769169741392588580100945268376807756367217092609019332523"}},
           {{"4.24495621335822494657116776828331694559892639517784118652343750e-6", "2.412731330413380170796244783559814095497131347656250e-1", "5.05650148888948869811331120941963319541414375806822687983830138205938420862200064078576598469877831249406211581526927963122105281131255004573845222711684347603254852806653766035434125383812586900316395999300527269121533046942253679078218107723668449508163238533047093749711627477323541829484653131292e-2"}},
           {{"4.4864042703223833814263343811035156250e5", "1.57545512531989570200255390552968037809478119015693664550781250e-6", "1.00002050314697607659431018359659361183713303212753613120902527904331498111603138394334757418054814218670389608976827498549914166555768752494414195237102560486571709642923543196007200071132086884670852209514113439317507321835737223329599950365222037362534859303381396326717532288233329927808913598785"}},
           {{"6.497495709023816743865609169006347656250e3", "1.67233186866778105184039304731413722038269042968750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.37780724079840208711014533649991541109470796504084314835156759344214993302863952807171583660778803863957191115559320339273255056520571556246744533838811694006166732957726755945662570959533321672076547914911635593118101608294069731654269467619949055336628326621660012876406202543146880009002104821553e6"}},
           {{"6.0967436711242051217141124652698636054992675781250e-2", "1.5704484143598296556551541236501634557498618960380554199218750e-6", "9.99995606813099499267634389464438683850041060806908350269346321155672893761130577244819124593817984249660934044363638948086248241297434338993626965911693249278796597285537898160766381999495115463474497883772569241592760426493272254012575287314033420480717621539078495596903806489817283498263020744184e-1"}},
           {{"7.575034551306392138769751909421756863594055175781250e-2", "1.25659927896368083096931278497265793703263625502586364746093750e-5", "9.99967576340235983529748322865757677186118554170023614050204881657758768441183672920424294568610952334609747551908015545068832481235294176033402023954402315837530793201944548984799957607361928025651266738940647431602585783131780321746876553060340085541214977820888348264644079307051095179685852079945e-1"}},
           {{"7.230949225422644496830137939014093717560172080993652343750e-4", "1.59957635240683257102367598179171181982383131980895996093750e-4", "9.98843860017333489092110505899347130551976013147438321970353479326257793437223848104429707854561661175450570835038515201752789245106905767296900600611401551754756721658819816241278926439311942572630487380703760937536160330693843537976099522621025621041857521661138411993182809798954282325807746896512e-1"}},
           {{"2.22347866336470469832420349121093750e4", "2.67574314969844628819828358246013522148132324218750e-1", "1.45597650920700334896440864288586774552136744768533970151074149218272851829624764505239431335468131476208480181217427109189696065749387968903474055278714181692867425657254225967806378137696550459591101296481511902742572646395696145586249150843548288850238158312747067673295059110101209836587291678717e1"}},
           {{"1.6196975420412198717889928900603990769013762474060058593750e-5", "4.98433649539913870007978857756825163960456848144531250e-2", "5.77061455335439039778043359172467746025200146785630273407892949860314031306268447375871357416922980298986141833641561954857127992214135487677696097641048847861017455164355255934271546462888696419881919311556223441720520985938735112636787538160901409982382930452852563601752376961873325250302513132303e-1"}},
           {{"1.1078580283775937842527525845071068033576011657714843750e-2", "1.18652221207551884308087353225857896177330985665321350097656250e-5", "9.99946575396258084502018839446238846584110705812867877643924485585779113197512036317728340100285410504878437697437320927763146715271389949541429089452281046460116468251613835907291530307473134875676645637754443536935426771393775580503285493873005924313301673550096584687732186248324962291699197441007e-1"}},
           {{"4.0090085615093388029042675846369547798531129956245422363281250e-6", "1.5153243776850145379609183238223124590149382129311561584472656250e-6", "9.99981169291887424157759932262067246066753044936086128253970315838989839817149914187581608688565806547274970455207936904774502513857569845689591879527047150474914557088218340646463900082270385606124499095033110795779754466447281328092278318076549095302554108789079991538595665731579745334006426859960e-1"}},
           {{"1.19021350263737038868705475636033952469006180763244628906250e-4", "1.68290288542928294646117137745022773742675781250e1", "9.04852417540620009944566041453719467211390230149498516011819535440728246929538100576552383464173953438153608848998091884909329517100819960017904887302473398843345408874822800579053111675353115760245493436345787702548498655314405766561270926511701674435330529881522800583133171192665005622617374333010e-67"}},
           {{"3.242762654672085015491664328202148226409917697310447692871093750e-6", "4.4540895454217880808367446832107816589996218681335449218750e-4", "9.94386254687686946963322383552185492075977337531973213930838015838274376322044860137122810561067818353529641305366066211688682157075369267213623551618566522232634253178245524174116891287095569137130501326353904791232655125453161983083517758472031555434930112729665552915867163490039363051308443099856e-1"}},
           {{"6.15810616566200508259498747065663337707519531250e-1", "3.16615056291079111083774932922096922993659973144531250e-2", "9.84767212442093730437806115126470445228033445461780019945996712538430276008229376762120777978183512697217805509135802054380845495119030204478634136438561790634012659775242132306345870420149133737299397362388964674004273429551607587049902912378874846355087545159480302396357641147726629312485985544367e-1"}},
           {{"4.986398000750906066969037055969238281250e4", "1.7761072017031686345574573171468557575281010940670967102050781250e-6", "1.00001921243238237193183827489311170506446717993399056537282384027062526108337893488664380391849139457202726524784919352515463921911589077429652463880766791641171380378763553978844617450998857121720620679684506344842701809891676387117033562056914974016308650056416678855410514380179891286420315463385"}},
           {{"1.3982947813147638953523710370063781738281250e3", "3.4349953058313833706427509184777591144666075706481933593750e-5", "1.00024882796344591385461239880845260384691776851307067376321212831043330119768926261152601978474535337925904198175128520020096443925386965960197623129024285407478015708065567539370247164906581380771634920314388644089046167410745320267558557473972499677590220735439622489041126850128421653983634543138"}},
           {{"5.53823542724402595460730935883475467562675476074218750e-2", "3.895135030254805045060728652117632009321823716163635253906250e-5", "9.99887300842861835164017418113429559930804468019069798605482088141983665217815479503166341320807290829070352700865762573462007338287440579346738382811838185553843038382146930720875234411175792603385681200743384496310942148612050283753172718455515566946341846284557394785250850393323918755270713010620e-1"}},
           {{"1.4112136137383384630084037780761718750e5", "9.9875418797880222143703576875850558280944824218750e-1", "1.39052029796505087174799036572060834290339669936231503015871931355721722463161747207749930806516332386763841930651054884331973674982367750538370231486178766251016302345689298357523496706436693633349722362506875465430935461687316908940273568043577086452494403668755303085058972545116855832701160169233e5"}},
           {{"2.896681342684133284243533368318423981691012158989906311035156250e-6", "1.1586534546002158485578092950163409113883972167968750e-1", "2.28205556117411408113652874564375329933423424935399606070975188165013549346043442272013469493594176280229509402715241333520310808546934629428072668916547032154136142048364995378685732366063433675907163954131129548865718748066808278449447269502355535592014434886553141414017802588692926998785625006881e-1"}},
           {{"6.80370452266789652639999985694885253906250e3", "2.55585667546695538554502036276971921324729919433593750e-3", "1.02281231404359612151527353897929180348478744328820333025332541070807332704656155540376559985312945856024293947964716753864592850899748540597581561259020876390111605898100116321942106603048757052249826147692127068934907088939143183343054183800841834132202006495897859489577613318023621649632711626369"}},
           {{"4.625041131443131210351782378609186707763001322746276855468750e-5", "1.52163427846739888679716834474220377160236239433288574218750e-4", "9.98482342652643471998471847918276729621115291527655407478347392440646810723671728307137559792389469491363165496772939188998042052370839020230988405367662374022902953797332354477989367493245470167443057076807839721016298819277997067517609396627866901281229526562169916899579412733467953808761281274902e-1"}},
           {{"4.5082293215957577103836229071021080017089843750e1", "1.06839470475542444583005874392256373539566993713378906250e-3", "1.00407725957483558818239220892424948692876561612077691060007144800995480352451729509031292920021843587131856132257906499443064130817064638818765366250131236399994854411601609832821870319397908684888708832193783247348840517389795509100198832759307607589651546707827898198086014636944156848700425178047"}},
           {{"2.97403319008989266980513832550059305503964424133300781250e-3", "3.864747748818575523443996644346043467521667480468750e-1", "1.05563040619657475424023632617553458144221260647471757349470769600263284068856263065983919485584722356671096360406091314847188039821446085937501687228128412834520625095444394738723676139779119999762553228944695777339743845083698817002881418226410778165865331625883646946752393289471811888730325566680e-1"}},
           {{"2.383250807842116500978590920567512512207031250e2", "1.66302465811868707690202029425563523545861244201660156250e-3", "1.00914434741735633383477956146627482536171366958054332840551181784200344603582400731522959980543848217816660950109678863255860871237640121402147335369863635255623422637578873942180607947824451388135749116333642343887949089848641558138185462358132315292011403950110303162349396320495083970574820485984"}},
           {{"1.71423190201370800878066802397370338439941406250e1", "5.22776453453089651191021403064951300621032714843750e-1", "4.41715373496456388539324810858409600194977863833255435782643057881295200486872481370727134110261522844531904021514609023835218872201273620577170073750362820523072032985530745444647038907617563505404059737966630343043214665700476103118304785807103469358517871674775523305518419709923690374745267779192"}},
           {{"2.24202183750390773639082908630371093750e5", "2.8860613713892332640731375192899577086791396141052246093750e-4", "1.00356204426464651318381353366766656275190463831503522239513652128295092897680949875433153708401966246976000272332294389517143726474038495934684353460128449357504408039179941027444904612222505017810534008770086553370099204575810832664720970035523251219105643922854038752127247330051903230606763080754"}},
           {{"6.682549242769675323927458521211519837379455566406250e-2", "4.37453434835288135218434035778045654296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.23884289615444976971058885660437787480627352137562427420631247881049437291942148842029267007686370097695430731343288589752635360722257432905786816202418979845289181427172830309982121527477449228884669859681103900842455539708329644639171581286590973017189366587396069226010533102477610964537380565038e-6"}},
           {{"7.08735989603501259637141629355028271675109863281250e-1", "4.931705772743737270502606406807899475097656250e1", "4.22994581178880428430588361219833883540463488675474104323353907511764504539625188516288826354093370529125373667749527512470360034116957923611728143647053700596011110669882224710437210488847861184277118067955181730553186100384807049379684590737156995709498402541295775367296456895644229479101255193586e-8"}},
           {{"2.320149423239581665256991982460021972656250e3", "4.4481031013119287642609833710594102740287780761718750e-2", "1.41156739924941071144222113991630683194620198146427652318978812945951687592217439817665385168004660248141475796965481088709894832854582569992290051260681221672250427616673943995167609515610097891251991676291118804434690243303234426750763059520585143335380969303297852505455054177640936866538646738978"}},
           {{"5.53282998141260031843557953834533691406250e3", "3.8412160262591260107001289725303649902343750e2", "5.58373770974866315239700400474362989477383658235694014601763955308120813900734144800418886820772189374330395186134971653113939250757648994415649668842051891937875262317539557069792723676293862948593761228728392700591159530165592758768030540795599964339740660316188438257430600649159884119157424191581e1437"}},
           {{"1.85718777739859418943524360656738281250e5", "5.22760764621501818278162532216413183050462976098060607910156250e-7", "1.00000634214788464577855189457084479231510812185767194037441581727975561469887723538341241488476848396809344125019310357146729535769441778199276860378224675705997700022744347653159656289098028240954603207536444605258988369343538458427994444681579339406242882282677673848923548267602318784029338545299"}},
           {{"2.26509465497761368624196620658040046691894531250e1", "1.03762510179397637877229954028734937310218811035156250e-2", "1.03290580019042823129797947218377400320349309579887379648069219653044521496312022139633395975447973076157177628011296170468228189168841156259900536323684747126636993787966799478738521263932697630770091216225209592893137197359045523997671979624680066252774430678393930591603773849047796785558663064178"}},
           {{"3.00476295219746433740048985328030539676547050476074218750e-3", "8.0240930815382398577639833092689514160156250e1", "4.14136997855533491337740509094908136487500777275671775674006769752964040924959289897651192452522290539206601428332553008348132654735739834724305690164751538343877568881013821199733121651153278576916744941958595422652696891642421407236449964345890318648778746090208231400439749942969896805715062234843e-203"}},
           {{"9.7079889666732196928933262825012207031250e3", "4.44245980458260469880826804001117125153541564941406250e-3", "1.04162803810086699019811359451605453492327199203637588333443087016790236547076001612983024940969264195708947484110311219661303765376669460085704437741732903824466154100734799424439147057676949660911617676769474501254927589549167841876728171722481679869607753266592648983928705022178056753619502736504"}},
           {{"4.66389224589813756668976729713449458358809351921081542968750e-5", "8.41598683219974930125317769125103950500488281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.53382042139791789590459891074340066702060120383660058981707324170432197791546635984529280576877432127625617337120709804544743161881268886942872653531280982977576133511801284796672543413476367564502976743587063883733930418435751755822485352709171649159924126024328941448624940766411726855902924670549e-37"}},
           {{"3.5980841563362578328089114165777573361992835998535156250e-3", "3.89106070923696201191432919586077332496643066406250e-1", "1.11957324795765157901703029938063916662894000731995996196921601505519523032651152137148283098242267387419838627536448762986353433569901640648734154364900058234967711292575255307936095926242393050569604396410567616604312846123878721000606629431359673384574670669906697802557686478096291498804903738631e-1"}},
           {{"8.29546112810515936034083672723227209644392132759094238281250e-5", "2.58324466499312066503080131951719522476196289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.86659658288740565122000959721270284304946720479579271651550103638161205367495371607443353257219806398111103943515458202894485596325631197266478165244814107159447017816960534609382148164169335790367935277372018345236031109996214855557877416239874683021494253068006756484498147004540748744410389570461e-11"}},
           {{"8.633345938915559791837495140498504042625427246093750e-2", "1.53080323158965114771490334533154964447021484375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.35233729973545869852697007160756749812975339497681040282999017995032382608550729201580422775220111291799102420635253476809267746237352183450521514570985348430714476644398637263228584608977432119909919809882847191196859131282077491115028311403034792745466352775458252803189617423439193439791933123479e-2"}},
           {{"4.96802530016260956990947761369170621037483215332031250e-2", "7.025196835724334398776136367814615368843078613281250e-3", "9.79130174131074712614824707606461473196424333567411409743609116414751816130489331857231684597817414740294362613028844768413127008896909984819847802879905875872491406317289520166024819440680050252863090346899246519659384416734528764367429297819383807550500609868490474715994290375146313368129823880737e-1"}},
           {{"1.24702033554851823282660916447639465332031250e1", "1.710705957554977231852011421153747505741193890571594238281250e-5", "1.00004316789477874277620263489613820769653924396429221925198065527832144152145855155330213971456389989525794479500052652310504867952437063466242776820964127214900733034755428153463014611408545155223418498794841462940237893200540509678171081868776875097700422657888013910264387140255547155547751726595"}},
           {{"8.14130989781463318757936953318221640074625611305236816406250e-6", "5.476743603534721671621809946373105049133300781250e-1", "1.63199095965818056903859668356569903606584619352293451010588563431807635376986054905897873784109387681218165026966672415089273447045333707684197569751029547891913778442699838628510300753325723159251992398807517774034918042863197611983714480066975243968618918488213538490759809651966026386013669113012e-3"}},
           {{"9.4831604756264176181446146074449643492698669433593750e-2", "5.873187053422951808476226709387901792069897055625915527343750e-6", "9.99986164907695049446699147999970503354260553000953839878275159076458261755428730763560216631851642537174133195419034054495238529976374508256949441111167727864128507860277033299044051865971449902820004978297018651282279654117307535005136847959876138249613275046667240315151303933181873427450473536424e-1"}},
           {{"6.724396223986286655338595608100149547681212425231933593750e-4", "7.25371945127648842799317208118736743927001953125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.74287216286274945633266572714083322962101975717027023442493643122162512912802620909159732325958549010615659395950026917825109006470507725724883444926417334797999132724229966674370457592343778072797597317430071335665732334697884217471229705559230148495486170835726019893708870900510074940623722192258e-24"}},
           {{"2.30442309265876887366175651550292968750e5", "5.100776150045996035209405761179368710145354270935058593750e-6", "1.00006298512189780533426621327292231284630240394286315128868176668180396156679505765231684868863847590833570938788465357619602169740491681317033999860409913654411707265663879954547321897801703570651803262843624273611588702980486012373865440788314427239276089286730821085936329475836740228791493079509"}},
           {{"5.67608898683707252530439291149377822875976562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.0768302191256316291401162743568420410156250e2", "1.67068196412266823466861212116241893055807436102731155140415238019317223182255528301301262470626159261154640191153443230288813541880287940859066915763205210708548641176944414442344483827370453800486623574896474317715521007693847769491979549043149389934860292588058888100428936865217794693086764880012e458"}},
           {{"2.8133724660645658150315284729003906250e5", "6.7634484407087152105231275811547675402835011482238769531250e-5", "1.00084899099059737772913859365556118027581054407285954758329055990529529377511066455820790791091871502993434775634942750452313898053395589443975739777882392931281046995883876066279980856281434476038018812014179817821871586805042023183706725376177160577170143175806815414662475357051404586743878413781"}},
           {{"3.3498352383764867443161072912971576442942023277282714843750e-4", "3.208520821056923266745286582590779289603233337402343750e-3", "9.74653990782509243550836183201075823369159155519692846798314436930630346572690178245424014813711682670551067058906680367646181984756645025448347553573937829174199564122446362713993201587207768412845129431576839987405545810458778769778400165994012026984577717831659943902405397254874487260228557294263e-1"}},
           {{"1.173650036641017777583329007029533386230468750e2", "3.780534896009259959726023225812241435050964355468750e-1", "6.05893503437891990856263354837986270829833882333366791751057714437977103925035624856886729661425365010268503431934637684230477655839134293793513971115798026793973457123299079643692631311303731259185411381265912635677151301389868547814580071368806352687212447229499485791883769033890017890187866384697"}},
           {{"6.35473191480731591582298278808593750e5", "8.153326462586494471906917169690132141113281250e1", "1.39785593586175436998336047723152633390674636830187065022507274459265394076960202352145842758484227495355755965560336623550772098175134115092702375767668586879200691996181864401350579269221993542974245130770033239773182375358583651870979382999043883377805409110023459275245515025837447884289450716490e473"}},
           {{"1.20953010742292040959000587463378906250e5", "1.81528620999166889760090271010994911193847656250e-1", "8.36836082188852137389175804388074236213762814888145199618983165421342520318145120542719392963440700570926350816427711317556249274733873103430368341047528787950522843632555485443202700694068291761260828423023146529348899979040923182831897371799138328552240635790031739904574931369069808189107688786563"}},
           {{"5.028268644236564069438522039945382857695221900939941406250e-4", "1.49148497614115050149963259684682270744815468788146972656250e-5", "9.99886724184991506266822294352662914256716265702852450641368490227402118731911016182228523518485801671330942930187800995820804252420406598640376923122551567922827288661396415930336442260706727249870079649992447995120206397679683465259479974096061438201134430443691684817587750638183840953282722156209e-1"}},
           {{"1.7762360570648558178927234330046758259413763880729675292968750e-5", "7.16881559843790408872998831668610364431515336036682128906250e-5", "9.99216151571584206550599285631558723279674057106881165894202136106399680298454020164284514110193651012658901118782805914666290560642145072003861919887611842296547047036059520963486973019219177746829500434614825844519776793639037139709040279058532565912742721673028532604681375807832044191447365386410e-1"}},
           {{"5.4447075299350728982972213998436927795410156250e1", "7.8942499435862384474802203038201753315661335363984107971191406250e-7", "1.00000315551756552929413349733123431754994533967419962917545562731445729245526256276165331606875912022797791137395975129631042701829381104269734643785979371368397149024305719491289967486350643357572991392648348784068298353851347894101762457227438358667841811859357203913787202416700523836489423208926"}},
           {{"3.479528655391823122045025229454040527343750e2", "1.706470553795544006780993129268608754500746726989746093750e-3", "1.01003641035516199003729871729172100472722683758579980406598003587323081240911466133797745466321375213116846128724578817241014105529656120259049841543565831847323023771528373536119517374544673647922841984354734790648175557634969225996223997613913923117328699599574593399806697328078695200917124733876"}},
           {{"4.8968324713172875495281743951636599376797676086425781250e-3", "1.965286254903626561628751656662927871366264298558235168457031250e-6", "9.99989546369402488423594127072150976413227845609208465040224219805251052465526350038203035493184013561718362361567469358800995276604754108514280603768744650567983276404672018483263585666869718723877857972643772304671740644914409892158811218430582592069739462405196179208350796857344173822141379782399e-1"}},
           {{"1.46846575134083542901741736841358942911028861999511718750e-6", "1.13961295777929194628086406737565994262695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.25155431004176641664360564432608271749851863826540763464893400702786658931519008803678187122457752047812131114041410952546777155616546380522319343918668230249104290662019435519965989945104554644065424460926764956490748710036580200886547368376656130754697653950693222962392418484839778727280176131769e-7"}},
           {{"4.922583286355184384319727541878819465637207031250e-1", "2.167012857499329633870210898294317303225398063659667968750e-4", "9.99846424401823072211356827414998110501335375349159811161820098061831954942111055007312660415928636319873898347702590642507419097876493991759663677610295879480797600223758201686500279349159643821096880668703139199785910150322740521690695804135686666464835791331742866153491003010427701847514162106732e-1"}},
           {{"2.088918420244419849041150882840156555175781250e1", "1.3745112355220467925676075537921860814094543457031250e-1", "1.51853459491101499462028153198307960464036529321862426769066486207166171296494170498179583135034855145454026518293079000045567402865046530341818676848400774327944796661350087157800975247279219703171839848135584471839442165788564723636737356977396947188532339857132058951624239309379955278406455872013"}},
           {{"6.59693951898326247373915975913405418395996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "8.5839050428511724441515973182958987308666110038757324218750e-5", "1.00016195756688330761491474273615136423552556614577036197755742996689336001512360595235890000441982158893267294826116899101351409093661584157256387065246323209052057870928088601548025462625595893993027794606583868972654751596093207938303600634384394989635869479864226583469214082919105133232859648980"}},
           {{"4.721903022822039201855659484863281250e4", "1.3687261479564427624211475631454959511756896972656250e-1", "4.36273289377674003549552956596428296006868194528902491172931330043916572933784595495824585583342079403134944318241053700848989680616524963231553615168899405338957973320487490472555612135391925458093520067531657179731576065041675903036737870428047782297012296101361469066116145701281560378942697624754"}},
           {{"4.820349777574789310388703178489322453970089554786682128906250e-5", "1.201141639511502318474200912135074759135022759437561035156250e-4", "9.98806768192609411674337267672424056960083232464271360229113542018960233572696008296128150338304172594110837781004501757127999427554595909914289685513812993265024374119615672800606621652602006481141937435665444874495693840170640030665928027259502446424921700891997624978473239252852217099622859393453e-1"}},
           {{"9.54197957425642506734675407642498612403869628906250e-1", "3.34304142023469919031697372702183201909065246582031250e-4", "9.99984326565139803772938990236401058117431661922045573846220380640349699832779123098058540753008622857674232899802697126593866411818203678224123515319186907350469596960547397261912465753250671926347546302198056587430826863955515669743258039245240360599418185587449465990312391796474083173534248199413e-1"}},
           {{"6.409606992637384337285766378045082092285156250e1", "1.0081673204983155756053747609257698059082031250e2", "1.44157504422123306075307680246115279780269010737951173392922320903011026254261224810748434749033392788723902179648854339741924679540874536758451693815806813776859218948113244848659597589114467756894234559650445795659560796369660440795499707193716216403592941616722628011042403021580672267269382135734e182"}},
           {{"1.22311589009840382402671821182593703269958496093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.1046934915771231197623158948317723115906119346618652343750e-4", "1.00004238976442526402787977257335501538186147626008780569692886964327726967250839556988250363044075945205489441982444641281650300897861533023502296756146804366735904879346020295258735438264424281840920414740589412010520817925020516062766522452589181209496869654998063536725728358771467633669371863258"}},
           {{"6.3929111843020800733938813209533691406250e3", "1.28391975830675164615968242287635803222656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.69505481296349945509651870173004703548467117826619443587513918127052944692060859604078331125022112009253571107992368448403956917792261351644585277417570509975725723863004283151424512684410008159602519982839123505049564570077423370661622862250195728714873045142974264003278199036815752137105673556433e4"}},
           {{"9.8319065323364611685974523425102233886718750e1", "4.16849063361153184814611449837684631347656250e2", "4.25770980590636267172342833096299211879468172398651157530921609762966193936659345808702337762714296668889853763786019297633422123145533613492472992798929637639386760407400078511978818609469799050619387136981965857651597610392961103496543359101531210986834447630570812748220097342632073167798940478519e830"}},
           {{"5.473175005590576347458409145474433898925781250e1", "1.2556940190600926476882648330501979216933250427246093750e-2", "1.05154283217149739996322394073132732110285973177101672144476243536792403202554641841303821681674178605013975392578098758039213562899690576014988268448654777051869934823936115258309781471880324840875908371004233345043851515355481534420805940488435409518654838065662552503310797307929345306698760361427"}},
           {{"6.4912383638254911311094019765732809901237487792968750e-2", "1.850202617176646691099506369937444105744361877441406250e-2", "9.50660946670306311914365279482095005173354041210571854577128244379583503141132158648667793122314902465794942399303782457347308120094047863238127874892080844189140303644281120192942849585627941033052970332875969503978268193734299765207776684899260119431935484734340685682552324678913617232469193989216e-1"}},
           {{"2.2469270547648281062189101753290287888376042246818542480468750e-5", "3.52982695718321792810456827282905578613281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.90763013958916250310703922628537395346144248614383500040096138375431039104002049367585390738671354254176978486242291556216285278163895739264649656370403930009408842065500683071987767757954595210907449882232438368368764844630512751091553559176805208777768953085505825846870225770460080538105432353809e-17"}},
           {{"1.03776311938838771311566233634948730468750e4", "3.67758461032731062689826728728803573176264762878417968750e-3", "1.03459301282359622046275858130909175858605738103500377882461906122638713902728757596922241637837677972497613038491667511030599129584893938038824302224512570610802632172627579650514542361582967805126424931338365938119495726516045340017819117717607391845493489250022446019685368890472485823905828290701"}},
           {{"5.444635317520329920171207049861550331115722656250e-2", "2.08467925444702359527582302689552307128906250e2", "3.09056011709343327076534816446309237286970058275834540830372719698670511928227959632093780315386474610345825780828956917908117330975173563693122316666283875774232598613235043753932040992980072681882395580571647274880789017536786697004043527146342091119566202577901703268215449281872604307112909919335e-264"}},
           {{"4.321410913909301143576158210635185241699218750e1", "1.79962553627032728620349644188536331057548522949218750e-2", "1.07012654071632775332556853428357456635166481137753650401618414453228087751942869456669180112375507267782856652222749904765639096915852769878278766680206962666525967341796532563009425557062229126958039051450556007688280632610398536337196273409572525834486954342631282999563123455233960154445776600968"}},
           {{"8.8519539520932943865716424625134095549583435058593750e-2", "2.3201497260401708899735240265727043151855468750e1", "3.71305713463862717236321613646893663926389070764619904563621824742856237889605485601780242185666715109642520925666586793175066523791156636682971412268154170045092095602942426637119803498838588967096817482914325839210531169438704998222940708453881877588305201012231120626503012557840854056737490425114e-25"}},
           {{"5.118003582399178455139554522190792340552434325218200683593750e-5", "2.53194625802088957300384208792820572853088378906250e-2", "7.78675898815841251401603750577856756795950441245444722873452268896478608982683458941926503132911522781757532432483294128491039729829837206496101278313685758061174666050134299787052246310316361371623036791254936884792176693736621135978412809784428098496835040268753660201880757384305210529998116341854e-1"}},
           {{"2.3274146614903198568291564640730939572677016258239746093750e-4", "5.386407398328963954184378515321895974921062588691711425781250e-5", "9.99549497162550438458304414161333920701781715268855145062033883882900750111819551249273252859663946257284929221986573479403421187776431235203160677411657816941834327558315579342010850796902138914924928940560282841455433144115320935123004884062392612303227832917659972351800421646517607120651251528968e-1"}},
           {{"2.888209173418870195746421813964843750e5", "3.7267907937487687597410968010080978274345397949218750e-3", "1.04797427152199505899776613380207153019163891696040089708565511495563600355422445163531206665239877024907641710076156338867860992891601417074486301976244681251883409289427117509266966735400170413169626794460003914944960446253186507533452481416547111722260834345331494363350198444447590272333886931493"}},
           {{"9.1176907448884685436496511101722717285156250e2", "6.3428728361785488232271745800971984863281250e2", "2.61412399451200792430940441597911814328017657658519351363425803166936981320098511499093754150499459010245435176020174953699548406222107608392288974835149178057255386825625780361600243592099112823611022187187648569904297395013151014275208089987059198137284635106672418842688183845527005332642735224166e1877"}},
           {{"2.99902079785064756833889987319707870483398437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.684975926456249788534802469541773461969569325447082519531250e-6", "1.00001063692844088210456002419855074011148005470079145471634788112628295771788190807123424233524759763995207569368229563514564551401717941193555837507092120724642714186373549513618453183103215293207086254916107790393722326161402579919794484826396299503609272588338890824693538523484869461094064640920"}},
           {{"7.728544599046511575579643249511718750e5", "4.4897834852120803786346137087548413546755909919738769531250e-4", "1.00610574384563796400321310101756992783528974702739913146260646865660943239706104030906315422031586966995536370399679280585793557349882649609015460449277306668457058524687099432479479161198093426061867258598346229732606275929747805949435342506588647203249401335413541148238532118555631296171613732580"}},
           {{"9.2977037287730581738287582993507385253906250e1", "8.3526187246175812375903468876003898913040757179260253906250e-5", "1.00037864179461996490975401602514900577512361928909810135170262283211442500106334885446423595314421485481346967556782507370070595069946883492382064486384013379235733594798086474310298773717536986583185147038897974675666723220012717870637206407697176312759927758943687773764377471241445265488722941855"}},
           {{"1.0859392704197159673640271648764610290527343750e2", "2.5420532850914867237235306163256609579548239707946777343750e-4", "1.00119232709184950657347355900529943667776581936561333029642844322931651851922987396688070423513516427393233449332830940932893802869470044377136541346608056612546712420915411514501773616973022311857494372432610405714927103499401270099666054931681878021711299630772502630342850129330691538468637467235"}},
           {{"6.089552101270304992794990539550781250e5", "3.93997641600216752522101160138845443725585937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.18201219777662049133348544929685038145294798461233898669466368271726917449741209374562376908881805268589020897308399041338055306698995074087125055703556791502100679603522120055594862139867723186128435543540272128120797808148788656196331354569711892744404054200303870971480027638854018077003767037387e22"}},
           {{"4.17002058199641822966441395692527294158935546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.276387753247702787221320996913220824353629723191261291503906250e-6", "1.00000325050709508111108865304342178215954684414490544574201155545551225580135488259163273316494247157849444894518301320733204512003009459708444645141220074915996395890189435364804366091830247042355490183040883445209891891864651638351487974364904897430627412415757188029347485931227191708441175016047"}},
           {{"7.67550081598081896869234519442670716671273112297058105468750e-5", "3.093588605415642511786700197262689471244812011718750e-1", "5.33361058888703312937877266409714100834748582910004102998779521040115944440359724219966898465717158230452195981198500825979353396690326287544928081118745655488492150353523103453131904616559184005975246310430624687681784477200062656846973772093687820868635241069192671298954998139357716654945366635020e-2"}},
           {{"9.119288514356249943375587463378906250e5", "7.77150273145831363419411275117454351857304573059082031250e-4", "1.01072215443565297495212875757828431150173416786594077990011283253611684077171961857977658555772993227256701225998130851047810587496804030395055038866276482446366864045774522304245866613460132889356389785400787106849829332460233953000396006079677394660376277801825929937944079178448460996666434091599"}},
           {{"5.4142012264591812709113582968711853027343750e1", "1.8952259288250325680938446204493175173411145806312561035156250e-5", "1.00007565289778675652984140979321399062757791371437603651125252179594586538728496280877795475718254343845999376499222253067347916841829323365254311918387151598991472092918535912843066893311920458448486904240767256448921472261918689220109607027673999114234655407258002618927723100761498362332050377153"}},
           {{"8.0087992188598966514234689384466037154197692871093750e-2", "9.651251454841747090540593490004539489746093750e1", "1.51542106881981491731489464208722559455080283729538316329978070693260585378415308395373558536702307332302792317627310748549719761801156867236663991267318247059438589418271824484275577584765219427298744283723772247523591169183694405713456066811755471408195734266771535080425449850856084868376311119689e-106"}},
           {{"1.09156997362350409730424871668219566345214843750e1", "8.10878062686337663933500152779743075370788574218750e-3", "1.01957066747628902940966302510092960488528925253540221172663471275503400990771789589916604068584334436432589666410671717466013196522730609847023637947764642131621149159485396625786863911618319465245064605684158683676154002669412578226202367577007287146331656090836085181386754790207143710478024828107"}},
           {{"5.27981737437816178726279758848249912261962890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.41970852096179633861083857482299208641052246093750e-1", "3.43686253241293502543031164235680564280493113934425702290586259672655229919415634458697404687915141160074152506872313697917935113169212018685900336128740210227144508079482606408290248099236632255964024354639101204012497824568760884660053718968331056137812934970479251589590682389747704367113989950745"}},
           {{"2.9763242468503051441075513139367103576660156250e1", "9.124583619162003742530941963195800781250e2", "4.69742603562041824153926447786929280716116286355510132564473072728789802885515779796188477871744149730979853211785348379587523589298115735526488355106077778856284664084128422453984824424076757383964141778964343798745285559893404942252682634909106936299245602255752362338032501973165524906979409622054e1344"}},
           {{"8.1227700762963667511940002441406250e5", "4.92673741168140821855558897368609905242919921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.30484996489149406381687564563779425178418692009670007244171321324888859123491778857160269626310259110411696125879945417306210294026918965107428093516365217530286177050990880067424193779915234192484015646474192080157981645949288654940510168136275269591421630149209078542082633232345605476593203338075e29"}},
           {{"6.75063843580995381898901541717350482940673828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.02748489106749621435632491284195566549897193908691406250e-3", "1.00196404947416174365030420006016203648060565955934806957206111637856432455172895201651727892958586584412299635092294986305134023877029915464080887124975616815060819276759381700802994334432976763795102196206567937500407359464356440088544622676160266170981561234435498384331071158546292310523236254753"}},
           {{"3.5017444416405400261282920837402343750e4", "7.802827554512200072811545226159068988636136054992675781250e-4", "1.00819798888901128629632317940565742032581044787310510298394051237610722547925779466083057852335930819436022531750188258730486171674268778076637531078630844955462136795806889121317307097195981029957098770479755079052235805500969330960373439119072852284817639069793570751583988153638659438922106591664"}},
           {{"1.2656495085348353768495144322514533996582031250e1", "1.553526777035119332782617251886847498099086806178092956542968750e-6", "1.00000394312365539989563625486331626137964273811834798695005780013495760538177217100805072673596190622159320905648378255454000218262505715454699578920413495174693604468418384665870032433868756106543653906692751058614669494849726609491390952522788637204327400613561970408136313418894648226391505731573"}},
           {{"2.15745882397261681817646206127392360940575599670410156250e-3", "2.37905683348865193416088459343882277607917785644531250e-2", "8.64117851649613850769514625497977880278916078343037571542452910699608639199334716242087257033679813405503457913766626678856765747940796988239184619492044398845847330875248279377691256718144764352787323595310916665202454075432835782224634142882556904024349917556799442289975480861859420905292552431968e-1"}},
           {{"1.041453721678808896911050396738573908805847167968750e-1", "8.37802182325172850596572970971465110778808593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.88526852493738132239113873166539203263138672058127955706951262195153797473038707601101237196070886256644090185553908945280688151557324839521372121066434881841798255953853902832020964805296391060444306684398308798244411237112095640393380398474592654522034844007881900667824504043884214270458892007901e-9"}},
           {{"3.07012551115110277066833077697083353996276855468750e-1", "2.688791941473964719477862672647461295127868652343750e-1", "7.27959056811329343392664000245431816256252125501370190635108304735068414726869009253945094404747463601079257760616120868020903017002340732110943618640264478113302579667971697324950504699622151612181100300886867598913337113652973737056690812163582367071363756081204514554722838161602803979904270771466e-1"}},
           {{"3.8785555274741909670410677790641784667968750e1", "3.6812395300311884227539849234744906425476074218750e-2", "1.14414942990692656452341784125767590353064260907248467847740571016135049928321189261126610028098851785915087403250818786340815261171401002033061136458109120291157079359913768807250954139969052510045722307049663169894534742927788300920701107994896596920105547258658675585904959114220585301112702429345"}},
           {{"7.2600458186699787233031599953392287716269493103027343750e-3", "3.0641341074503714025922818109393119812011718750e-1", "2.21086963011262781557962916039162488992600789192717542131434452153601149170623279185807445011140592247466432290015786700658875253434281122713288249913633617033214856219833669907164464033302015146556043425711342744639683355773156696931162767677537366527811567871143970446954952970890842842464186617910e-1"}},
           {{"4.11288422352877880427968193544074892997741699218750e-2", "2.51736412939929010690320865251123905181884765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.24565288563751822331299972603179488550349468370067144446751898852644002616709216207408151506565589257442807820798232055968358812640290558093447292295273379034573533601586226697268290915360691120466719143962043078879323957769794563236709847407432551615445562560818926972156677354022231138620495943375e-4"}},
           {{"3.834137867264226078987121582031250e5", "5.00384576840691153165607829578220844268798828125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "8.70586881100241909365086281828106615321437784717557599878404325717613404517722842063862151116432421295729131945352592123500947115034261116251456345076603582494211858526398683989440066160175940760838173788310914276938532934671434380694237696835717084352874743706871899256563045584501545107582617433574e27"}},
           {{"1.45287638810286156079709662947152537526562809944152832031250e-5", "2.12685751933480298196330049442792642366839572787284851074218750e-6", "9.99976308406201382296511195677454028213966050559386949061001176100458674306535766658075727649858861936143578824990999294178518894376297296437371242014351633015801209221765213206140971726863151455918302666401442029878834264175629251102478211077868646609228275473662440136138981614575523961652841689231e-1"}},
           {{"1.060607787842173799219835927942767739295959472656250e-1", "3.6653855504344872232036500747653917642310261726379394531250e-6", "9.99991775850777769594805464682102392095766388724998006545282885743063065509840288039071353911521871815954556155694843177720505424196812072094678443706799908575637539974472545844157811962504294140635183658965312242832638263593804028788156476482121148602286677141129409544764834011834242854688050032534e-1"}},
           {{"5.8808637709003045920819197078799334121868014335632324218750e-5", "2.2895041482392727849592972688697045668959617614746093750e-4", "9.97772228399557115917897595553123200059617745525398631036747902716221825268917059130877148214691312502174434355597848183024102187672671321353149180399633699090375168044589993636218162674313714376215322688591337150653523844732601246528148296899452660176207080310884559549441104143585753370139662688312e-1"}},
           {{"1.82088437442942030486392468446865677833557128906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.18170819309718790101129681779923430440248921513557434082031250e-6", "1.00000130754723378331003328108523077660890480086159377400421770916129060299296337133805493313328717117334983973342138421022906982702012383037259191961910456959250943670084798790257349266900179703918444391347033677458675178576414635996649806132816647233201959427396166295868642002149628537093670669003"}},
           {{"1.81790864213692415773948596324771642684936523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "4.11112317505943991591266239993274211883544921875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.16716616089260899158634927691311476940264689424270830038830803482761816779192664467113169986590716888439242048069862364270415910055880132349242712046577768880635878273030333655678293456983297487516817843334720432032181949191565525929129951842591644277698817197191950932369312197425519306770280944742e1"}},
           {{"3.1168221364156203344464302062988281250e5", "2.94098588905476396315741283160605235025286674499511718750e-3", "1.03790338780611240821364394096187689009151442337723127625883997000112224823851501188946812750320424873330954741819494803462494193607811995436113951374495986635400485180461374008937550605117989616259238001766980179462154007176099462553721961527948038831707776585902099492828100272597482214965326918683"}},
           {{"1.390878641265953438721503232500253943726420402526855468750e-3", "3.3010272380812644144043588312342762947082519531250e-1", "1.14022877396721831842223346046335424470246823884137406233750859143164782910052273120452909159294424816461360814736670369100321052363875210113861850087708357854957657313512898387152990311841659387594066789695419982631901574195401313785030478101180804642923588217360853722001240454059693137169086797197e-1"}},
           {{"2.70245297975474845853308125676051076879957690834999084472656250e-6", "2.27192418381639527069637551903724670410156250e2", "8.66297652134236153231549630311782646457435806521553869102045806271290140313907532572617601088189845177879703715370369231877915346831429034626669722739550299919960838955152823532091259662956246982857242736145549200749997723311019597549168518852317671248226020048798842889139150504890040937192852486477e-1266"}},
           {{"1.249171446812304111517732962965965270996093750e2", "1.151409165552330193804664304479956626892089843750e1", "1.38260599513773427745927397841453042338248242456988517458147773019568704658853879515960004076402277283883489795069346406439823839016514254977654510204974986928186171239215823810556312920621087546486393810430469767985081698483192169492133075210737954383435371131440185644678524564816434215238704654516e24"}},
           {{"3.118362310192143922904506325721740722656250e3", "2.07745884054014173791813391289906576275825500488281250e-2", "1.18191130436089764539875276066824383600066278177797976268794231640866698789531115667856789828761726794355968881132857750694814866048339710833375629295256557712732385065863487440162509225900966765667937759713986800012768351783498265785505802770202831716066805035224331887004845557896771449008224340669"}},
           {{"1.490792061643138310955691849812865257263183593750e1", "9.4237360550309404061408713459968566894531250e2", "6.27012834121533023666785182346229437241289754499051958039863912420351581912036946871768101343922573098899177777951053704877386501476998681242293961635818871027535060307630949907397555951449420495765047830618356183657814571149049220337636474144629773918060565875711712572574729922979876342390263324772e1105"}},
           {{"6.6662061859632616494727996858671303925802931189537048339843750e-7", "9.21273515382789454086776004260173067450523376464843750e-3", "8.7720486288821936974478857366077028717039276900173868840215586570851328800318849625174063894064299296365776744832842535347287057849725364966061157585147600109227112263672943360146015080190661943495120908398140804149413536576847081616293061568452054226035633596561472067627264621732339446631526745150e-1"}},
           {{"1.380789864323115345712267298949882388114929199218750e-1", "5.93562727297856326913461089134216308593750e2", "4.09060418138444387424424059062331178711979043905828333720448765913252697584689444873629369083510366476460104106313375773568706388071930121668811178870306890980290075045537520987441428335324653171796426529164093528427568372203611999068229147036397950044150945977202609787933363721956655499688121770967e-511"}},
           {{"2.1677105043294141069054603576660156250e3", "1.114162712132173898085807373092848138185217976570129394531250e-4", "1.00085620226622470905732844417905757963463091991631468675045664887604696934739150514381777470211904644648980514762573227291787791600677422794047913591269830095072415283470532919592193733010388187339828883232881043401853930198928232094973120867346831075681954343729371567448461485192448773328157967492"}},
           {{"8.66129276411148731409928025470890133874490857124328613281250e-5", "2.63230476162026535980054120500426506623625755310058593750e-3", "9.75677926316087201992937434104172212635183402081845367050961907386982900528845357336855433020027701890844425355924313158894887243517734179729721860852203216211626732274220956786288208809210677612308603888585509873354794360927290410971415768734554863757722931375046183502833124862440220040682623894401e-1"}},
           {{"3.350575803404289660855641663772530591813847422599792480468750e-5", "3.16747650803829827736990409903228282928466796875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.69762726818915994102636669640248641695258916516178220951615332541358403169898089796085534108216181605452622185779736827460245748311614902401628390881069582094010945399117381574868399439034359201699565625835678615787458358138834274021214751543009200113868243044350923559610553355961511493945076046223e-15"}},
           {{"6.533819307718820648678281770571629749611020088195800781250e-5", "5.88128239916411388321648701094090938568115234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.44239576906295172295161064728901353975092629051590219076800377900713837403284136783431262977433666893756151770251819781412876948522321366628456614260642901179077056688683539196520237460889892611407142177331136348438247424975172992629120895139251739138531630904163246094893508737465346231066931419052e-25"}},
           {{"9.58824111169796669855713844299316406250e4", "4.767758882233408712636446580290794372558593750e1", "3.29079715270199960942963556473318847100392035825806894633874834481890517355918139252275167622132083673533042352315135079499274198112245747602316235108479674713674202663546893395644195003527204518806401402778881498713093151993690595544754136969841959488665417573929913679381495568123074940059218587082e237"}},
           {{"9.8046254480724974803007576440450066002085804939270019531250e-5", "1.9238006181862110643976393475895747542381286621093750e-1", "1.69367957215417366534795032414092044927898150798664469523819577887485052498975506353682229088031835479896261249192998498541269057857290594440231095317424708287026045610877468508170913712129807960043309223866462243177903185979844369471346406937023243553333556543631914530281862882346915332974736594434e-1"}},
           {{"4.22715824828159014714401564560830593109130859375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.73237473383745509636355563998222351074218750e2", "2.85142181625610748727512967615608623642319089823180852116567338775155480625397140714648406228861247464456116191851444571000366236244452154069748412545940070600491678946250810802096421175871317523376451483012224450957973158915531091130907648484702974041033736125577265886371493322366154555363836169078e108"}},
           {{"6.9664712703758069345383319159736856818199157714843750e-2", "3.57526947921747250802582129836082458496093750e2", "2.21776552625627356590336877317582904052748969026951170943346144361121751863809186842688158978930311760773848599440472082708351294025960471667864592532594991999006914698692274398613842119283225752843571850040859177332114176284555447226936581391382855150937157990431287391269415649433263516860035782138e-414"}},
           {{"8.870316572117269515729276463389396667480468750e1", "1.340709584692019973317655967548489570617675781250e1", "1.30679204065692425620221532321916410120280977665891018935099692677903142836365793713310074103183167526509810778546217793360039724544105606790669360053805611269103519872268834740224972933178750433774433912507891375768945267742879488012985036171398185645729556921004734943776799979369402749984084043452e26"}},
           {{"1.38894800193875870772397540520159964216873049736022949218750e-4", "8.2883437025022566047027794411405920982360839843750e-1", "6.35222056499059860815119534190744388049132560559707635179974362835024292102863415735162094842301916959003527949486946878329851243593307281685479130665725517616797588026104563060365221513904192277451172225341242860418605162130720263571624685346061029050164764398879401328940031001593736913742594656342e-4"}},
           {{"1.09816947397275884975090254336294037784682586789131164550781250e-5", "5.58183945899629990446480509724835883389459922909736633300781250e-6", "9.99936261439304212269593793274631621066678586897953594510473482514688267255174393243589871913940083113695300948318689338051222055912287552167309726448706279958229666015743107592418824002439360290161725288760084420735569321637244499982204153705684126108823317986930400592132185032791247608619277879575e-1"}},
           {{"2.3109699651686566035380110406549647450447082519531250e-1", "8.05549814372709782617221208056434988975524902343750e-1", "3.07259003265165794231974650932471010325197411080114721904301457157547097334313567798534807882346741414784333355642286915364891740931795753032224983168581398136163731017251242792429565442336378918505638415347606482959367519064678452374991852143987534832456623394400259546622175052847902597251732867983e-1"}},
           {{"8.496704164419041638289797901961719617247581481933593750e-3", "5.06998079666728116224327926886417117202654480934143066406250e-5", "9.99758288631873273226282145885741739757443924805027385096536700548341955223394388330738555808413815209906793614975662061712919602993250011794563507497959691981853673962928960543216580974445772540799559436678586781978389593065105455927885069982188267742598791601651598840088278986439446428992363728811e-1"}},
           {{"1.5731138538713305024430155754089355468750e4", "3.280717754969959891160960485656516993913101032376289367675781250e-6", "1.00003170338187821543987107336746662729109295981087069294808638827112958850528655867141095917778641007871411889107729782401763128246612168904257048743190385169980528080025389670873111442583914650963121405799362630066123464254273948242629742051351814124726982856264616340030151043214382406894418159834"}},
           {{"2.39202138047558889866195386275649070739746093750e1", "5.4911818191854854376288130879402160644531250e2", "1.27339014094927962826314328575939814304054781018385168289190485168514741352754753149678911930165646861374735328175462043586928267957865268734389479790773849220996848074070389175534751472812216991107745875007249116250242613067032470443930894251972922681126465003519414999032823440924453088711434009253e757"}},
           {{"1.64634850170019781216979026794433593750e4", "1.580523129961241765584212259909691056236624717712402343750e-3", "1.01546348252503362826107105198333600916123885616351929759095090370675683807853397698537671019348523544289454424258903395372242729481623263158900841743559291226322042608326721672299094222138476822715326186152957264351608036142453170432188932360709929281850323115131827188070509946087921486355921396837"}},
           {{"1.29984771123733180422585298252613483782624825835227966308593750e-5", "5.486733068536071497578454625454469351097941398620605468750e-5", "9.99382895797564405052408771210317692764125583490813721738650031785719409851796983570805688722349822979681595897622086712994137349075757656980372150545265412692073900115244181782170626388308672797472118433651575906690160786295103594530704832482562910548180219532761382129979082146445301288761331520852e-1"}},
           {{"3.344994107622141221725087234517559409141540527343750e-1", "5.7036284170717499364400282502174377441406250e2", "5.40485852822901975442109716898610918193900542520961776863305069906497895793489542547982159745108266280524490077140951661552295048439266934614559790866489193897427949324691009938697269495988925070011169411841665487299534902136008055662912091113639828368592572760704050198717640286295766255031666140310e-272"}},
           {{"4.5876926668516091467608930543065071105957031250e1", "6.940088848410982599879126553332753246650099754333496093750e-4", "1.00265878013514519296809865295705868217393246867225559245606227172893223522667583594724300322356488286875380629025637162385262938162022625886814529504008804417980773476428819488610083450291142913844379562656183905757559036430981251862699509205398028210683848825112302095809741897956564300820095580866"}},
           {{"1.83659034529005538161072763614356517791748046875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "4.28717719818835121259326115250587463378906250e2", "1.53726930767980134628351414040002163694004937538301878071492381306637265403593248974390687238745936146996356402451151949754817939176416474547668969917407094657482938942615901000965138448816198787619804034435155352704149778316444976717855180409986287616695020212770570197624985971189801426264668362739e113"}},
           {{"8.6965619711067474297341850508757943316595628857612609863281250e-6", "1.5347053247153283339621054892631946131587028503417968750e-2", "8.36245700894899388555856775460955394048641742342223378203581109445790321544636857502869379407622931929904915591813410010543421311751441003345169506628319334514393326009523930245673734273160199057057608984977895920935149203153332718973184503752228376603699406900321208889195409621350940486281346111426e-1"}},
           {{"4.77866412699338716230101908877259120345115661621093750e-2", "1.16847487332184418740155251725809648633003234863281250e-1", "7.00939095440309291336847802488312895385004430053772751642212203497067924870860269568166321148643247526572505972984054880543549485653717067216843154655077419087852705718322510631592242331848706588637404925586365121042986696317386544833327481602868949385627978856713298735650783856235081147982296346628e-1"}},
           {{"1.5496379919649280054727569222450256347656250e3", "2.11204960957075971172969275357900187373161315917968750e-2", "1.16782897318171377990330689886402903355059628193684114132825684051875757607797689933491076299185969963004000061078683006351157287011440524301691431503915118755080894616168235485089522630543579349054155603272650786560006738889360398191602249883148592535791585897969899944427735543027279681332101510149"}},
           {{"2.4700067947116121649742126464843750e5", "1.524990827307894439290869570413633482530713081359863281250e-3", "1.01911645804528060285295007365522901933244353571254108413776362642912835636609229733378877024828901273387523484327765744744502840827542422973162779826478327376782490303695679704814420712110588844007646988152318154340574171527693080085147287526207828218450010980129801914952299876654249129807403026665"}},
           {{"3.037235491867054356165955830704206164227798581123352050781250e-5", "4.511103232652476435760036110877990722656250e1", "1.62158625261315621796784260963880908165199570383258880752909601743905724906716730454255511124675934144867399204404978430279501754463613692043192608111413253272638040513583589571469911855611383025946828382761211165356334768347578605666178294674917101334371471550226399719868797818976469869780054171828e-204"}},
           {{"1.79856395286417303225334762828424572944641113281250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.3205911557676336696770177936421930553478887304663658142089843750e-6", "1.00000077517217823836935248077849892691299847903424265238524662417641027601052147271170002075034613200815926835872160958521395863660559755851166354980024967551112970300127247095245969854003499125350435566412954660499861774431261483707515396163088724936940160199016889915664585852452649068941190636190"}},
           {{"4.4135593735414602178934728726744651794433593750e-1", "3.4264101814415937496960395947098731994628906250e1", "6.74548555036519520791276201322845305843766995125882533366758793048355043544777974793130718057932582612619627280143295972890756755586060864163343519807569602024123450673829021330095007485505005460893008699595178496760510808546265795771516348135206769564722897763853591915237047669941031110007831969575e-13"}},
           {{"5.6917199182992317219031974673271179199218750e2", "4.980431025421458990365408681100234389305114746093750e-1", "2.35629700595091638395832213480888201727086153567756638562745744247364577078732772888391063571800696941049290536498639573875131887930844892410621248852158649248884548273739508794634953342193256645662324249539648039244590505104994015484168576899587920875428234320711411322714373060714140422162212909132e1"}},
           {{"5.76954356011381364402468285845770878950133919715881347656250e-5", "5.2511187291456451475823996588587760925292968750e-1", "5.94463304445870155806025859667737584217029774659090091223865132706141204011793568374081383686497430278169952431756767677964164234313821914580067310902314296078439102264644178954457549643252195734243656729528702645014237867821529512634908260975861471735012585206572278726071364924835281322609605715766e-3"}},
           {{"1.0512376808920871428367285749239101733110146597027778625488281250e-6", "1.803264129332194443122716620564460754394531250e2", "9.01096635654174895730364890004274506998670967372315294988820585742497849923309225303695080415166238118944235696360277258545630995713146996451284285658251097270549397299546887024456736142173128664145649440632706184379221313274424739352233838868194748496986549948050292922466160812395403732938083994855e-1079"}},
           {{"1.281632386074353924243496294366195797920227050781250e-1", "1.1652410215525389958202140405774116516113281250e2", "1.07879719574926016494490747415323778012199705593394831943581938296777477488312425323506097154699459156568032482136467971947677672762383992541647262353219851774496336332221673599562229050781431336707003943210680119687255794953033119424826346843688505841414943672869216307940977860809662475253945553141e-104"}},
           {{"7.872022514530490298056975007057189941406250e2", "6.397605722050214716034588491311296820640563964843750e-2", "1.53207555977032989055018208938771579303277505887799197079806149426805566503858217166434829573392590992745607709024458374528640995879305116834709101892580164791296787623750765678369128997876794757719509455355831607218534572758406336319858307548393197701741434159035106328532033366541994641153056109739"}},
           {{"1.854131908725732955645071342587471008300781250e2", "5.69406846692120716113549860892817378044128417968750e-1", "1.95656735368615067592522859512955039643574891198504549379998394284320814651945584264960315505975008311532240586619468218955713277820799989277348072854744621874725681637220043518336051308494199906438625737004480910828551371454866506648373987268921256736551339157313351536645840751017335445520822528269e1"}},
           {{"3.99959450842199415454558675264706835150718688964843750e-3", "2.8670957835011812164793809643015265464782714843750e-1", "2.05340685717906270754605609530501932449443307474519553599524954021671059012176997891604734383935653924096296837478833892286774229478680952581431502458132810484806788952807655375243507984165689501659897282979828575230799553474262829100370309746639962529485962944150334131789310986002849666502428526895e-1"}},
           {{"1.84674139572777286713578526189394324319437146186828613281250e-4", "2.255716592993170510617062518576858565211296081542968750e-2", "8.23722070622293990830799081708429380180065314114356604329745073190591014971022286949735867992102290979570786194665670044964971913376468986554402193499702945966888241927569660743521069322430532256408138686743620372490125687831732257527068587575688326301178711197108267406944507908002982504230542257301e-1"}},
           {{"3.584739111909031635150313377380371093750e4", "7.602453022229758516914444044232368469238281250e1", "1.78031144785764416938612223102409855040299356306284612439958299013225825622202999580381834230141933121841779061836895061770649393695477680433223418771879979265527918578121214616513115300315506936777567650603403724811526574832706041635294702581230395655527148395841553708668562384577527922279281988840e346"}},
           {{"3.71269374692093090395417220861418172717094421386718750e-2", "5.327041985305960299741309671439637440926162526011466979980468750e-7", "9.99998245586875139489901271639028340713779059130027015276766418411283294006537627833255021572845938748168207820412482122290518617722205438714506223415635135045747382101925106285222804464701875561904552995223695133038388901912278020591663993121292169965721308487953050363811103359158918910384771899011e-1"}},
           {{"1.70108553436059684038639261416392400860786437988281250e-2", "5.1660750468378145586548222389922102593118324875831604003906250e-6", "9.99978954129792622644650032269094574319631975777438486754903659150962464082118122945419410503323172656817200054190506282421527117453082829189458035945776425795407971906137471812197621061779135748565507246203908206485915975691199432826508885650310574999400116127525787480206412253878273855862615753183e-1"}},
           {{"2.09225836667166789993643760681152343750e5", "6.8566937448334350224676825291680870577692985534667968750e-4", "1.00843563284699754528712961596450017035453860350588570410059871012011253379813933654529429045301434484839481489237559065322374683637748571974104032389976926103159187339564349254244671809494052575105796625285810628759847430784136996879048594191371809811836063684074535025913318716848524590469577859424"}},
           {{"1.21714727542868383913798879802925512194633483886718750e-1", "7.04024274981674075615800667549137870082631707191467285156250e-5", "9.99851738180285989619013743122680620229360476738383672375457223596142024538032582334141363701685216531955627726353087504478019029760906182307020379318817894422274668875967247480704625723584657033632048027924110460864147683431850155444025526123837240535234902995892523890236573378473187948012001689440e-1"}},
           {{"5.077368207710659725115376339488193480065092444419860839843750e-5", "3.97089812664133678943301219987915828824043273925781250e-3", "9.61496103531524292145269969904333508188364139708137329208759077302004651060803860997069231846146525416244529356233531058823752839075298907756560474430217361656059248345442657322781131236619023757967452575027788503647455091630937116588678330308533380860226144011143233073363114955647590755520397783133e-1"}},
           {{"1.05107095024027863416904438054189085960388183593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.03411347779367872590228216722607612609863281250e1", "2.75435618440696236423847758785039217191601787351549036022831398969378880644344551767328463505949691251600586393797511528994909897140379260738080763330267660481025359227717949542759648019166102411005065795694130304853332521480946507674204615568889856249883941530835820527992056685661760535222848429821"}},
           {{"6.049918012597592072501773152737314376281574368476867675781250e-5", "8.188377133726698957616463303565979003906250e2", "8.65759593884760895858132938458504295554865358684199156580525629386190771627069601339728387260476959873950047671147626130674714736942807728977752816985626622779230687686049014608462755984076183185977629942323400832151270339085974963175219245006492664764899739861651980200882059489983917901390447959952e-3455"}},
           {{"6.5174474814096265617990866303443908691406250e2", "5.077102163366880004926814939913981561403488740324974060058593750e-7", "1.00000328979143507415685697811442096253363291297955720636385496027164054688294193762566482130745852122932064218776073663482596744861678935376393042841878114830402198126626873661961854660156517253426476105318520395463096676472118157780746408448524800033381676594338617857965937768629354079942055143731"}},
           {{"4.6388449163862754964782197930617257952690124511718750e-3", "1.588924357889719374270498519763350486755371093750e1", "8.33715260820791317269987064747412391800309849955602033217225409481400578667858265909262657939940738177907804353137088637745857746470695800199690029742037073210058760217313184489359114691758908649867287570270285365266943814797806817843515342646282514312200010453327035336204860831498248439822619093280e-38"}},
           {{"1.4905828579579060615481478357935429812641814351081848144531250e-5", "1.7031751825887083903743324242441303795203566551208496093750e-4", "9.98108922622050827087546461298822670842973092479525322691759952475540660272868395330655428828449033553950251437644999243615808527145214868010990354809843842150796169597464947831412602935689456012651060606674408759590837715937317107067113406559618224088301687347090716482594166112826991011166298362788e-1"}},
           {{"7.50315265219419380571252986555919051170349121093750e-1", "6.0622251774968738402549206512048840522766113281250e-1", "8.40175419689520964937445314051307565108961445693694723005043311860973648366068520257018285775532813235354539177271941463790001972938524250513944002301467776271129144936307452041012641877576914077850978415809262774052418002232753061586235460151777159128199018488311311211799819289180487350061980646390e-1"}},
           {{"4.268470367888721342733426844517907738918438553810119628906250e-5", "3.258430440221719658457424917408218334458069875836372375488281250e-6", "9.99967215285852515192073395540137950482554540502668958238310575910483321879481952698928091493628164541705483350832773369892703138436296385686888980010809861693571807457349075609182274750398269557656870778473684116326560067055000556274923680535552295628380182973673412404308833575096574012516864815095e-1"}},
           {{"2.62667296496937296979012899100780487060546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.98943432793326180699211569447015790501609444618225097656250e-7", "1.00000067498249093796554190906335150484537007905333805853084798522029363004660855846859261868482180160316566139837296027351379815963628562093199672797915615284584800543052123602981811247334355647141931097257473080865200634384690696676990980451941954802180365065774462909125574737179287520936788897430"}},
           {{"6.70966669446914210084287333302199840545654296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.1631038456329054128768341058730584336444735527038574218750e-6", "1.00001744257181843369125556914164986065767377720999640888705793438430385027106235014113094055738186706162642114104415940235112867181288621050157885040444050793876376258047873939583048138039901310315757778797936384132441774545886210926930901727852204521859059543099653693673834002390277355781829097039"}},
           {{"7.41203371899830177426338195800781250e5", "1.080452434978750069676303735555222829134436324238777160644531250e-6", "1.00001460353450390109753320201848917579634289514937879484407258848004890744776169944597998175250117503923620359242409184317540187082543653993640048666001395047165769964336795615132413269257911431079896523695358479509374941248440346987424514128254145411471716437568325046246372300034330801593929796699"}},
           {{"1.6915925563799362407735316082835197448730468750e1", "6.180263869277183297334943290479714050889015197753906250e-3", "1.01763302348245649415440222014057755125288511751974439494118531238495212343084716356590900135150471489029857630623786718849006602487868725615880115082270216521029606377055101314827010471252021762724425333126829904634616800319752383603387644619737656819562990847546393907303039685961266007323499371276"}},
           {{"4.71460529249768889314964326331391930580139160156250e-1", "3.65188827816496541345259174704551696777343750e2", "5.57039862156640741370099717884062397571736028728524050580037613318788846117662035095375103738860527021001943141141148597120492387251375648252287053831107964249223144395667696166786054472499439767489130687268705183565392558321079668035341534647161063188715235627145576677691259556611945549071489064974e-120"}},
           {{"6.649823635178329084283177508041262626647949218750e-1", "2.0412485989929366955730749566555459750816226005554199218750e-4", "9.99916721594674747376600569188805403610749202879145587384797447934876298553391460440217614450811626491475153827239769211949770987067539929764774811195211928780393852025574440532735397207179531706592529705918782911567387089221968997852275611755107175151890770337885129722749288992344581262036121822096e-1"}},
           {{"1.1689344174400408519431948661804199218750e4", "8.15678606859390242789231706410646438598632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.51388885705521092082676462955313303770964042418254877907252507964234420916080103781270109330079123766686738994000772870583969928581773756873588657991143050640555136731739608625215812170605441235916882843841833089297543893622016574335981753027769495373907938555110085958780955474425308783814139862813e33"}},
           {{"9.764006258263712920153487573315942427143454551696777343750e-4", "1.864429866329895268961536203278228640556335449218750e-1", "2.74623224798347601232565592691979711045580692330641567994756260200814740060669606546590062265074708542429821154943403107394779336685935160305728814542562226163058396994725320974264154815235226634053969860486205541938719842224052325659161610602552591765080618174794519808159266445853952938084827117419e-1"}},
           {{"1.87868482843651634084380930289626121520996093750e1", "7.1692987273281232774024829268455505371093750e1", "2.12028119371494031430335044645564708556145176065304647173808454044697019950167941050283479818252925468559303066000892193796628006878431527857608384081735638513924751307741786259324802053021768713537078672257166368405154064404708746524318561350343547073960189134086007775921344634528456932868446419630e91"}},
           {{"6.1095693489192053675651550292968750e4", "8.61245994668030334651120938360691070556640625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.657007928541288294811583817545569607832014464676038743964777536498999871997260503817641545878415793384542051422692777345680017433348671458013853303440317187339805594208064853234977344701458031672246519856148886015816160733326713509830759728307312465258659896898040851868954253501173778760212364320e41"}},
           {{"5.12940713132187653400251292623579502105712890625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.285644350198942550142847118799238614883506670594215393066406250e-6", "1.00000373701282973747520930655159796229096921541589463952802693848825441766023480118817224366828254246104620872707491850843628745742807472462411859435943238658855518813616022964453910564185237673973654468864102738810104394810487407665604967406614750596030541491730666890517480494969397423025082726828"}},
           {{"5.9691952797515383295377452976815391139098210260272026062011718750e-7", "1.5718058210615070579467891787039945938886376097798347473144531250e-6", "9.99977473944483761872828387581066184030968843746303338716635967128051482967926885604187120298468309076374477372898167140591203610593108721399453839682426096478159671434202750765691646383078954275710747248498138805135910075991839124150638583040898450493059066421550145802666193053679045930003027645237e-1"}},
           {{"3.686062142486083992309886525617912411689758300781250e-1", "1.49260037966346908013329231046384393266635015606880187988281250e-5", "9.9998510356549311348447592218399988108920778960674235069856751667182339392598123994325942355644458229974167672565122670312318271933327236417417637712072186685889850127900657063502042279027378895935315299539289874632736786085798675859434221092674392826093829832333880551302119483318252762377651960870e-1"}},
           {{"2.75108139709647048221086151897907257080078125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "4.503704308271892386983381584286689758300781250e1", "6.22207684654158090072166193557643641149481975652647701708530399277363664695064351610680468504557225898194931419933867113331640493326162327026706800979963281990313857552256767561246682453632232432467037080629483164984556210425989798928121976072588554960434306958147259366170108308967342505596481568498e19"}},
           {{"1.811624556732920154900057241320610046386718750e1", "2.552600004410090513530875999670399778551654890179634094238281250e-6", "1.00000739442221122260724005033635770725844741914207974197964181739354726511926916714698090584379202017604302885037125163720681613028683344989131816590462063741786918631523895090976438946284620031268598318287495015673164204411596879025777677083658398098322196424671094954029116891354161564494388093193"}},
           {{"8.96493500879970817152297968277707695960998535156250e-1", "8.5687515754119067423744127154350280761718750e2", "2.18186472758714615747935532618938695169587522725634994323764763361322541875338494379271005378981383706775962465651100098009942121578720737172235160080858098630748438403135919432305006360154000115695658966205609995229485314131439314904570801339124033312271333615588491334684665719513845178970476180503e-41"}},
           {{"1.2661287980897948171610245537976879859343171119689941406250e-4", "4.90879340262861951771355961682274937629699707031250e-3", "9.56902896481771879143877379682638527882901861190229819789042792546979238367054331337767498254741605069110970147845996240165269976456347023401814558426675219095881612725781553874494895757386564444732770552998856125193687086542254594118439921159929235553297916239134941949770234940282427408194492643353e-1"}},
           {{"1.051797461093969659464905652690447368513559922575950622558593750e-6", "6.5937410071820754323135282959356118226423859596252441406250e-5", "9.99092782662380324729163640655313848714756101648128347661760755472309885143398472302956067855710190800993042892779094559399021527010697359107101541167758299014549008387517426503427862359734988159027154498990787998696863714462719474369182220777439814743092111459144669908819231194636468040015004769487e-1"}},
           {{"2.26677931802150922635519236791878938674926757812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.01284500605095928449372877366840839385986328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.04799524981909743425238268974274974124170089470250115095198088233403741098790024678291238778471336000887693628348108623078030852501843027636021269414992355439834109447548416843301419510567977485938290387496561912410461657784176868621026947292962832450377901755820567805673466030070278228671530695195e1"}},
           {{"1.47645383833588006439185846829786896705627441406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "8.3477044596248651942005380988121032714843750e2", "1.81864953170833366001029957686457080479745389229343183507996187270256012032168347753440691289295163599099444007484206082939466510290612710007371495952373847856242772883552123786185299979765598455416935895627334117098932505280856391911876837712397381549095944110724452719067485663398985307194410072346e141"}},
           {{"6.8369046056257509746956202434375882148742675781250e-1", "3.83530767198103986204138493576465407386422157287597656250e-3", "9.98542687144721504190991783229244229904437024428948393594123834827455412276977464755147963505927618995184986289919531376928027005710396398910486083058794955925781790662773364003988254537015097017811287414007455159323257827799204950099119284414629154584347927772687791013118617040392415483793228615528e-1"}},
           {{"1.002053539055872133367586229724111035466194152832031250e-3", "4.21472319667746432969579473137855529785156250e2", "9.08953646324319429602818744612054042909432561532126770140572825180403651664408870454180981154606920328617475099247353850589948028434533205453640961164641456021776839621300753911422835934782850338468313312210488559936609343534193099022841479411388023651172446221865345603921529386692401675022261632417e-1265"}},
           {{"5.1523280283123824574431637302041053771972656250e1", "3.605102571810556155718074933247407898306846618652343750e-3", "1.01431289853951002532506377614168990948051280337886607436878494527645645147723859636940385995419356184615086203041458176935646525562258868511947236909026624331932959131571326296466151873473074426347666272446566573176007728397599624815497760954111152173140369195400219514948443921717606923360226206339"}},
           {{"1.50327863210486480966210365295410156250e5", "3.2592870520402448164531961083412170410156250e2", "2.21705224525603686559675227491858310594380597690754424568785114801297385692314088399732454361300955075549296567427255869777962816305497530312793581969492733775461667703068826501146498955373099052386164214730524062952781381010426318671419140310052915928431939434595652675036589780009141539593357125642e1687"}},
           {{"2.5210395048109605952227352254624292982043698430061340332031250e-5", "3.0457256960016615724914923468702454556478187441825866699218750e-5", "9.99677562816744661723525153627124442052964231793875730324917063167910023632186323828596851920875156111103787347156093646859907405739307639598484356543171131155872282222202848608366838457688692164646235280817749009555765844448651859985081286265963272205351701235959915053427147246220456364075290757788e-1"}},
           {{"6.69572868673203203115917858667671680450439453125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.1676327121801987523122545731268928648205474019050598144531250e-6", "1.00001172763619213033390863469162514923787137097731257478379858496528955583730797624990721270466292542630978166836841730894536953419182253636303821927335171827673847960943549331513055995583023583227615832251837950408037083523512010882821232754743304332778547391577736073428707081283889265580574098969"}},
           {{"3.90611154895943855080986395478248596191406250e2", "2.09392819734250876240189143118186620995402336120605468750e-3", "1.01257436238989364436740053785780748984877719711041249303794530677616720891994615335093220833940115128861191606642103642393403535957041953141054150817528925853538686389534782202437853737346681413564667163289005149907512827692491679645604032151505662903966426036149340526908388743360309704155643902314"}},
           {{"1.857389689084788551554083824157714843750e4", "7.3490044908232137962911245665509341051802039146423339843750e-6", "1.00007223974053029723271350039259412141636069806425386754509098025549121050837680692710943206684686658573776447604596802766176331791002163659401284496154417281082333498905606330772551902793976098371405853098920109852460783688567109865594724989116482969799710457089092798143235841330467446343910216945"}},
           {{"1.7607061517663445556536316871643066406250e4", "4.74889370868937987779645482078194618225097656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.45316765019878240189602403680427223818770335223288608146347951094991305163036799974448576646914163732716464031107846083674367407256925355345653200850687798959392811940414372053909694215614805160729642095127896071955737496902022738055554549005006428357198315347861922794020063710653902271293794797134e20"}},
           {{"8.59257176966675461152189718916361016454175114631652832031250e-5", "9.236406780605612709678098326548933982849121093750e-1", "1.75626791055079856222412335079669380796397627500002019826921615591957724636638189051537678939438100683331885757581588353701345439775420172078880839292692181866988352748585676000159933320197094086021294353349620582341779917757035411891306338495037492064154895428084541796948375617939605049956389592963e-4"}},
           {{"1.1837336674405312878085791417070993247762089595198631286621093750e-6", "1.6732627760162928912601384978664498248690506443381309509277343750e-6", "9.99977165516365318634154013098062676051482936340600676508115018286371174310194281664961388300484701624347701999911368618575116158865905431420415090042447533719781066713262060337264603666364847020671540664275635449461141562032657119830142469510330575908700332922190579477083626027776803818572001718803e-1"}},
           {{"2.7929704683754344451962481343798572197556495666503906250e-3", "2.9713508936206637842114552938710403395816683769226074218750e-4", "9.98254178388410952430693242810343707992963411946313883778028696826023938537768767830025754426281554000607392763511414140886618834915773502093937010404359418681811029932841236322654028803608283276794373781000755359892344545988755782370138251235941283542297935477464591913844965660089628462450619495872e-1"}},
           {{"3.38113855762533148663351312279701232910156250e1", "3.093016660149662663478742352651806868379935622215270996093750e-5", "1.00010890478594524709067739908022368917088132812449962876399165997211946438304504899291487317819472340328330375585022333633583894340550549675803507677712058170618442005704437605073252304959372965881786681685588681179433355904579852317919540925268445449423495866437480095339165546614783853750408452453"}},
           {{"2.06425930083115716229258396197110414505004882812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.22320068732874709382940636714920401573181152343750e-1", "1.56994381329744106645164401249639056164129850194015191524774235721349310749300345652229762055800940290782810800288250321003967654939060262541583665184611869025848444849240326580936044484294913651408991979990620894378054306407392449503735235963890733618686812461995281192108663576402590588669671991241"}},
           {{"1.340876954053071834493948699673637747764587402343750e-1", "1.4827341861663803634918679108523065224289894104003906250e-3", "9.97025233069613645577452155667707700431529405119046003459330154763708616924139333978711947517286910376855122315920165412886432318792826535847675162918439845483335638190760733366507881163660357422897573743052858674336878106847554903297760383077263299654131223242076136517464708165444087161451001347315e-1"}},
           {{"1.1379582983750003677414497360587120056152343750e2", "2.035002012363793124196179040730214637733297422528266906738281250e-6", "1.00000963457189792748049744783509653303667431326364869818483704842948351380610875652979437988682746278703117572921123081696661945181740330111308085604188704279357002138744426600265673193487995475006875655840336689027158444662492494587307695412667171074545903613666004574014189607190377465209019809696"}},
           {{"1.4373394351522417568614575777985464810626581311225891113281250e-5", "2.32214836393443135875713778659701347351074218750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.69028929542482647910462333162857910188985784876407542387662931701295222184216133407420608557785163630976401541135533394749225188544894532723554319205860877128881077879568220494222775086397987960274421371074192662130785663013334009285908262792624635778476059436229937151198221859566242280319019160525e-12"}},
           {{"1.4004427278933599154697731137275695800781250e2", "3.53744104780148727051880541694117709994316101074218750e-3", "1.01763558978681810389405573088195138451898513946030420888756116873548356901540068272802595421797514887115185086583712361722645481445016465906573909064890341678510048829617311165144452645678278211232399208153808746476971992206798944801345917584439323122735213774632862994806449009371980892407850308879"}},
           {{"3.3377061563606758021194309549173340201377868652343750e-2", "5.1634069105928119824966415762901306152343750e1", "5.74932879103617263287699269441230578657539752277509100498121992886363492927534654879230172186557771810338441534937330485904491247273189306610489852019997049552119104082607943340924820476508529648819831797793990936006114678588935819382061714015089476930073162215255275726210879447826384500950556498380e-77"}},
           {{"4.28996264268685627030208706855773925781250e3", "5.5584348273515146732215441716107307001948356628417968750e-3", "1.04758858160148749573207693865097611258682532053580644741708378607626299571741454781489071163331961478583318303704887429698138745438016282037356465726871543404600493318018423949357845164509841052287336032095968547544265578409278441961772371247405527391823186341452132702680834735192488255543508774968"}},
           {{"1.2811034459606310265122885994060197845101356506347656250e-2", "3.43418931353877687762121695413952693343162536621093750e-2", "8.61015280162581259611603041281312219714750672075712379519625520748837900282815093599469657102449329452585522609992906027038154076071639645146113938200595344162570525215006263974571317023675884323716943933613404725430584249433688012398115002318410911938391274174242791011414117839535968615208469771466e-1"}},
           {{"5.1667251794698457190158080720721045508980751037597656250e-3", "1.8038118503281862947023109211563962617219658568501472473144531250e-6", "9.99990502044552423124036840709042864832582112050272720529614683113869481837430803897286965523406403026476324601866776220157395635334324411401951420003880457537783083750584239021034205680737146324172685990190142433894632845319189846259349630351570776916287281796804645673831673367339618359511691534945e-1"}},
           {{"1.27899907316783210262656211853027343750e5", "5.2253602409032748332684548131510382518172264099121093750e-4", "1.00616341899333551359328361392752162344577264467244472586370749414301840554961173829121346442368844768868155278219296270614015234651325697529392935793355916715136924941286676982861345063267744784667777743656327428634674404454023683239192093835032100591051537658643852513812450455406749057692109035777"}},
           {{"7.11730850188353797420859336853027343750e4", "9.60788079495505627572460305430013249861076474189758300781250e-5", "1.00107405241322382059953913596876333435454811871669131165966566428674069591664017854016649566117750922070455790150785398980453750449040916943909541516125417685189264145037334413362116738563574347465747605135946915752491452923545893529316360034715492483804067411471432361687478500733144787639791290510"}},
           {{"7.253438265676650189561769366264343261718750e2", "3.29954091776851328177144750952720642089843750e2", "7.04970290589109038711395049954355776776342381310886782453562200726034000844667284742622588171082170563883520775218082400856123793786048177341878726458251943347876583569178437736653743701492064380769184875657546923031668880530296652280260428229230807500261114316496980898463695380987245993698126306466e943"}},
           {{"1.05425305597257192857796326279640197753906250e1", "9.4121156168923067464326948083908064290881156921386718750e-4", "1.00221940552517387456904940935153668768677803438018028587024892341085297549561710698873774378670329922261139925263482590967131460066291169951663366614190003024630959832086281000186573153943388176622129526851339850140935108594752581778544126368342198113455082270613501744317697800189856112116044092035"}},
           {{"2.06616686835977376654471804329205042449757456779479980468750e-4", "1.69516133890853029630996218202199088409543037414550781250e-3", "9.85720096393058346372084885893839606320554663169456270644249004310463500725457211657627998908535169742871675934174757999843761965159654941281377745862394591058408452525449223020548106433276286869407305925521861569746775217097838170535894284575048909646530082294345563168457886536304399266956794807072e-1"}},
           {{"3.64402451110348510332492821817140793427824974060058593750e-4", "3.20455824353290882888778412507235771045088768005371093750e-3", "9.74947852438644348963594070779458486239729374924703758041706549021145269914102751629698949629550481353884433142728878758835488685283460683679637491539837448325034596988851330419929610091798061933767303224300754233414005420110971299300889653323675957445130038468323617573447274322484402694978713617040e-1"}},
           {{"9.2924091843635910401401692415568334126874106004834175109863281250e-7", "1.10041539819032330171921785222366452217102050781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.30375096076042540689175588676000039497925847630595558133397707131285132566953633275113891277016515974090275087097707081223643727147456085023753621384884096242056199349318008502416132788061805089253485591443085259511013177192516510953942353610198267062490629651968866334656113567343023162640866499116e-7"}},
           {{"4.70374294317859518955657338601383798959432169795036315917968750e-6", "1.29316103610866321105277165770530700683593750e2", "1.15122965827666394521150958097124834553922749706241413675626621322918765539817839286128014659593143570942315119838489669350005299860384297452971974330427527438060831168176929743817135707477251203472467806027668891154074309800997369457141925072379579611854152032663703570089179850821080592817602489379e-689"}},
           {{"7.90111168678090834346927628928369813365861773490905761718750e-6", "2.50142935632569063386654306668788194656372070312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.72554973148662694166759157160166169303284736393781157514352684466477860400705537599392645875431865905681445772161441577785663278326674184262006684080907675404076284363331862467589217294540329968481020258307213288969704999028809892457240851077890832023610976308448700744934847296072460694151132193050e-13"}},
           {{"2.1947022453851494638854546792572364211082458496093750e-3", "4.5540294660816549310311529552564024925231933593750e-1", "6.15537644035230762511257501642891052274838428807882763659106583075479589103986905326616108567723817554261320425463998387402938492727716723367633134645452074625478383896044161060182209094299460842378984988424538062120485203568234956869861031978112571715328186447068917826940102237728367749115256994036e-2"}},
           {{"9.5937575276791223601383085117788596107857301831245422363281250e-7", "4.7060044781868145946646109223365783691406250e2", "8.34074971005352694977724271428304704379730503069979006543824421982543154474277701862893673330086806692863058917258547615336829675716810145864841475235135109391399496144355613620559781473891279309689200469472005874869702401500915898827498117462493418903426151104912981808366378491461635507492430973906e-2833"}},
           {{"2.2073016502121220128174172714352607727050781250e1", "1.0681513883705921275427130900936845137039199471473693847656250e-5", "1.00003305295163452281794976529673484400203041012190269638476184821369788032078572490628055955783906515975070132315405678121749687518303529356301281556543290455691541229667405975677836660331331546866945589821129205572181796808319706436826468956587053252695087454167269382499127173288396374118362076812"}},
           {{"1.857807898420785932103171944618225097656250e3", "1.30823413709633314283564686775207519531250e2", "4.59033859659617126254628613087390514142443448071790104857905386498498208916927300817260750485505223182216712213534955208892328370772179606978553650153083374335774046910050899642665243305280141884413167811281876091816572586748238812963621916941228650345907682195313189327181720960131248296641667634950e427"}},
           {{"1.28002693604745983830747735332522552198497578501701354980468750e-5", "8.28203848010336862728308915393427014350891113281250e-1", "8.86706798756547273034023259748332998697114154360428093064398895642136945343512222443801509462788398508116083101485126653725181025691107909977090006260480711914768000641955268595050193784354949171562687163857371073429271907026305099383798868693635018067191669439164014101281294813574568021616736489720e-5"}},
           {{"2.0022337970233214377024921759584685787558555603027343750e-3", "3.62365481395694466471013583941385149955749511718750e-1", "1.0523546079739996170682601256693200584550474946824826454017096763153491367530797919426756788342306442393933513442225888083878538329106122737524305933086973617593454993892855732284108545200057872375959005456512921309099752780291866382542273850296660218802026761451051971279229272132557960744013745380e-1"}},
           {{"1.469752780871477591687415675814065707527333870530128479003906250e-6", "5.86458989513311337860024252677249023690819740295410156250e-4", "9.92154549068701501199366439766982295808371482320630816324433379463381296202639580495789257638722760912167367897485745357403740992265341544963450873213458100774396760614353635868165234585261876587876465994053070011062897736386668244554072898747895651881702386350638799402464850863950102149208151366166e-1"}},
           {{"1.69869769328567166155607992550358176231384277343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.0945166435334793483824533666393108433112502098083496093750e-4", "1.00005799594795372584357977768556944656253178249587480331145989344864034282666379944361611058467140259982713730781408566683105999320504528967383185252941819780496432948156779669264240460517640856647134097150209519411486934323027426354907715934579141058953345456267906766103552413735697517517849566921"}},
           {{"3.151839759293328825151547789573669433593750e3", "1.023840290841496539209209970522351795807480812072753906250e-3", "1.00828189958217090945616829239889322422890752450091752768664294850744665096849748731214361917701488824218313674215416049035608435896320044761285630475680013499593324921963112908846599652343142683769107300940314664453753090942709855630290654440762603604322610449245678270429752911593206005276375357381"}},
           {{"3.55087476619042874403930909465998411178588867187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.9895693178775673004565760493278503417968750e1", "9.32018908151418417859876732852718049962350652342105850490583184901223805273843023839695354873994074279947349253543933474250055215956442663452932535132575000870445343325403706967004656960749057879238157659107219147411710899538754744145348815414311088777452109665676822468399972746650501593917415911950e43"}},
           {{"1.267754887968159891897812485694885253906250e3", "1.00502285798295979898919760842090909136459231376647949218750e-4", "1.00071834700218288240776940900136375146363527699090847426981092022769405513480212911323057036382071349683106853880233005923304991341200308955960878969600681793506999384869035120625501911973134511693383019876699301926591009688967553141397068289179934328294897849913598948019612426308123680588484240861"}},
           {{"8.1522004810576163436053320765495300292968750e2", "5.7502531130550421992198018017461436102166771888732910156250e-5", "1.00038554010810039170759525901230037332621377704113376782308969416671995519944631372963790226541075839243378526551356024850278824940678165140037685990966568856425831851096416371162933528342527414028064433797747326021549595783932074419350022816349807211737168691836224208314746714465025589975731455428"}},
           {{"2.65027968976974648285249713808298110961914062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.003165491246268459235579939559102058410644531250e1", "1.76325996094662828651112161237788953415887952374670102134300653855113287125254830377423982732034899162480399742930099350206403828614662703257591959653574878666923823464038672614887656376458325931158457664475267311806542914278433869759036943522883194636568041344283954333960707999807543121267715345128e4"}},
           {{"3.651827512952488177688792347908020019531250e3", "1.675564512656399074330693110823631286621093750e1", "4.92218138915478317609234268428449378609898504811886050861657038624663939529613919692032879990877291035109701590929770282532279774612429349026418707716959296859399988519535881353467118924067126621065164445440389423581971051504964356883522778929468170495170856030672143818408689238481847643503940756672e59"}},
           {{"3.0606423484740545451834869972174146823817864060401916503906250e-6", "2.20328027949478477687250688177300617098808288574218750e-2", "7.55974238261708442675674596584944622380379860666888634356645875331625278958028151760326676909826129760886331850336797218123658397234427228603106790759796963957806080469839015421053939928057033567772138680185158581228274260396763090865346625773393191666291620910582819221973998350912562080963747333068e-1"}},
           {{"2.04040793254407122731208801269531250e5", "2.86284726793166655056666058953851461410522460937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.58821325525680163465105847555152044190569200388116750112228338962598195492329497459385020613020256287552717930952139248724578086838832538138376726496296560875204247514233017557960719338882649967806582509446295835645176351140001109236587197833843059204085625918013701386357232953416141714287393580849e15"}},
           {{"3.02716069476693064643768593668937683105468750e2", "6.040399597266724041055852012505056336522102355957031250e-3", "1.03510986044313446578771317219744132510998690381352607017246273580247626695630046904160285453167383058665284858123740052884532347981837364373948718495188424769656549948930405672217230120189497151355681193015659186537151773454794215525893522934864014682466868462268390720016762737891468184834184088104"}},
           {{"4.4755257017978976818994851782917976379394531250e1", "4.42494522046174552087904885411262512207031250e1", "1.11929646387532568976168597828914488086907276576025509760458985730962224619833220482536328707584889009590311478709195034015122056954215000823555978179815671349373291996702460104546989380293121918158085134301955237814810326108959984625471199876172816491246653847194071812034535823558646590118729075911e73"}},
           {{"7.8992094491693660529563203454017639160156250e2", "1.043723953933383654657518491148948669433593750e2", "2.67759107384668464385278885844815795751161179367906982405379998416580527424480738041217566954239691080320039512890036456504748798096287871747642118148076943027438116523332662829876900574449886819108021138850402281937549768122792675121441618853423616832699349260369305453263152392638804725787763327554e302"}},
           {{"2.548011737897549686127085522002744255587458610534667968750e-4", "5.159276612773364134589826335286488756537437438964843750e-3", "9.58205367007949169809279999461100360912902896399937272021332641770690450812544971532999275755132753113048328902348279538087441845456071781043743985319802898282971020600433571724744632298362925010469603804610543751544460798372376992115798540860563907814359172789945116001784572399034814979737998689779e-1"}},
           {{"1.899287505000893725082278251647949218750e4", "5.41078495521190028227920265635475516319274902343750e-1", "2.06563424507714690167714042623337538555278963530996591844954713364193688715643758076458567982650781640747670966188519005031306885869355129425908043628325745338231076914378682618756362764508582923824741998110533664940173863055464267380496758389944654061554957122449256611900453680459384297799878623896e2"}},
           {{"2.910204774159799723243224889301927760243415832519531250e-2", "3.10728022839575198851824744394889421528205275535583496093750e-5", "9.99890103192413085441074667861315652249320196657611339570482857071941674209639709864703891665811884603908304481549592842627180817065779143546842079140388383757073035382383336415119892457712538117493661547669850819233137331852231641783994865993482070326235283184181541427573679758103030801595943776744e-1"}},
           {{"3.148720015370035980595275759696960449218750e3", "3.43125111933481261039524667921796208247542381286621093750e-3", "1.02802334347014804115203210525086340106221839607209085819487247743041255274944512485633547164774253058201682853956553615818500164452268935135547407521495805328007119673698391733155607980906430692803512122247717040507439060960157575458288088753689807084410223837216910150868125550872659514690258206478"}},
           {{"7.5756156366840954807448382801737807312747463583946228027343750e-6", "5.5077687409354258996074804599629715085029602050781250e-2", "5.22360322691615293009344442522576915365414410103567546362459956848539698481031529793394942148327475172323264893580159766513287240943753652400314434832413344966940876720610075372213401767379175382193046077868122711719538872402153088637192089166340900530573304907112834730373371836607562222448960151481e-1"}},
           {{"2.627455089699745616194093145168153569102287292480468750e-2", "1.541165243980346986063523218035697937011718750e2", "2.65627927121210139869453772647172972010233396005753285235163657937204725700240182301143436917519389589272478600896823141333467649759723515447005854045233682059842082604402664004516169590843725236432591088329366055949159027684989904142732333954835416376354569871287255391194720780011944013876616447352e-244"}},
           {{"4.808176103728658290492603555321693420410156250e1", "3.8367829196169225269841263070702552795410156250e1", "3.41928564331678515981471338829811408659000181192686008443981749115702769340722053174798292070290561882896008338642826088125297911559295342634515669888076588557229523820060662923011009955171952757056636448724507715649589034168433634032429475749149003931613573665241664071010924406015748971161354696738e64"}},
           {{"3.205378732913250132696703076362609863281250e3", "9.12063633247133534681996835935535727912792935967445373535156250e-7", "1.00000736273879463173771441699203291296246037525214803383466819484064993717806192280443913585501602480713195981402804796752564583674811227808842648414027111557663920686825861938638104671353044668858964832448138218436863850713355695690765716750462185486284733337309942715764828383697583139810455212638"}},
           {{"3.6191217634682889062180954908853891538456082344055175781250e-4", "4.522771028821393922078608618164707877440378069877624511718750e-5", "9.99641674908429772727741716066692522684337586976236285526703123104244360091941899419901468194625324926731894302874406101537005325420303987745335631550541398216024526757166654981325659490102941309976706722307972204026369136295841549401634445497494285259254938938876164197916350437289297642860805084296e-1"}},
           {{"5.477271508647585385176626004977151751518249511718750e-2", "3.5462262102851867034622457275361284700920805335044860839843750e-6", "9.99989699815221047195237797415460745692681672883768835967449812852073485700626675461871958759788593113792388910307095890907937872017129700062714402629139690850899327106043179965950904385626167111246937006767223675683130961170323257583625795510235931710927527056466356951973276658601609644129515473818e-1"}},
           {{"3.15637438341709639644250273704528808593750e3", "4.72407848923734441370925196679309010505676269531250e-1", "4.49825547286670319702380922050187415294618434375837006137892453203122331928047047306492172079078511814726958266726273319242885369558258257128888847286538356045014816657847217085941522774109065130033471139571270092091883178037417387674630454737070888538218688730956097543661382768897165490297639608102e1"}},
           {{"3.4350329493606416508555412292480468750e5", "1.27250150145350989297488020213222625898197293281555175781250e-4", "1.00162336779090582285668555617540990956375149416793870895822616882369079038963730293631724525621870732184904017056404166569755879690536542415147024291651047693012257723344966042105272046767388935297934745863474716190137901174215179659999117641456704254362366255369408392878120515423933846401645588741"}},
           {{"1.0507424512953348312294110655784606933593750e3", "1.445127440723827295281436744467384869494708254933357238769531250e-6", "1.00001005416673874970641874885661095503816717227379033676876612730865335989893449582345456543451081149107465171659175604293715962189257810117721711365871006508720993220186972724366817623975260748578680835030711473739357905906032894783455531711583331359705157662673931729626022752940417931688341732378"}},
           {{"8.1865791008610611827547853813769052067073062062263488769531250e-6", "5.695354392083072300745349991757393581792712211608886718750e-4", "9.93351224746448996937113594504910401882994345207771800323049779691276470148213924723483955246436042747455629177564845224233210837232201105509371449087604601761437328836060853287056217115691403748052298316839138971392756481564106383080155540424716692745736592178985310629391299501759133150627938918074e-1"}},
           {{"6.947962131099967922343019210984493838623166084289550781250e-4", "4.0103218964951963698695180937647819519042968750e1", "2.23006490342279217571806140077665886981099414044595093418295957860943720284086984665743578056568297229139299500245761284073691802977046208070538242215508979634862568996291341587581554469156573033924350089621252836592701785348565193758908337598409016657851371246098654329684058361927838809573986193758e-127"}},
           {{"1.10592794589664117665961384773254394531250e3", "3.2526082185098381671650713542476296424865722656250e-1", "9.77248676688621920044634297401786442645385941311525110002800741928600473067163385046961591455772161080604895545524410628330763921136911631698147157554500689676133210576592147935248743333122279013651774018515939625427205237675732186795164784795174668611013924030393724917154265078516887725307445272803"}},
           {{"1.253916421410064036988038504993880906113190576434135437011718750e-6", "7.335796045204858728538965806365013122558593750e-1", "4.68392795308248572652843135364969720382138943730339914636303299072150410868121378543408470390954010868594468316840003936924097765196715356527524435528061810352989069642830612407823386666008449194429503821925534277567874494596141278120854458833913072506701454712189004957264318701887957792196559450829e-5"}},
           {{"1.4312473954279103516284976649330928921699523925781250e-1", "6.20942048850905869983307638904079794883728027343750e-1", "2.99052723424150661886931649071103918452644460542298398165637531920915224385808227208964029010419121462212498905692527594903577506198009266794868206489817939747878141799591393368960481067737790483228614343187263432824490432996787531286395390254093241449602142598445964130129975312810018929887788198701e-1"}},
           {{"3.43751575420593244447609038161317585036158561706542968750e-3", "1.512066870517058703171642264351248741149902343750e1", "5.57663597564430277353448388417312985615626273703902768815220625590828356254147933705830400685411299593103143556639123246778758775852967467852603984265071153374722320323459885871194691907711626373620710017973655475923376123554952810313797438555025227910644691182176423627488188876492434022067149277036e-38"}},
           {{"2.1747239559097812774610125607921418122714385390281677246093750e-5", "2.91971825175046888034557923674583435058593750e2", "4.50169709235325052632986882192448754882997090613648358141414144591089112598426944965520244801106015239482741658118850562377407270011579313225688643981938806077750575133252661340927273680933994486522267294226372481412223764992202845720067257372057887189374997685336348698935086839444322249450808054944e-1362"}},
           {{"5.6185681578075793003940532899243009978818008676171302795410156250e-7", "1.298760937531341988493416295114002423360943794250488281250e-3", "9.81481816351315594384727007893186507859436644672331091167617928065788693663352781510746621160037607384076966766971591864898782687655354341611390803359295084395315487119152362491516158659729010541073082819881189326119491997777097209681555255784910126963441436697354364542857530552913114970532656768045e-1"}},
           {{"2.69252008622562698292313143610954284667968750e2", "1.153305143347518879615165587892988696694374084472656250e-2", "1.06666279730568497198113724274678005155752498157046477782004178363192374164474721840040331312046115275560496984877594971350062701246211629447728806246316863840490103633689163217579393790965785864180257773316151663393300617519826348688668218517932804149442470238145344903593621930871763066878050548745"}},
           {{"3.16092590727489834989683004096150398254394531250e1", "3.48064997212848559193787423282628878951072692871093750e-2", "1.12772520348616005115304677929962056919100702599904589876944000234727659228749834981600423100421009690523247572724398560756474248595294433046382239886297029833469577515642633205214954504439619606667497183510745512915018311469959758235733226013623764492488909973197069967553629996698907871574676780407"}},
           {{"1.1141752247844277428842629795724405994405969977378845214843750e-5", "2.0751562277949120449704878410557284951210021972656250e-1", "9.37919294955190238371406645550683331410621638917073656116684574199081255090910984115004225393137968138900076398279876623105976571541314203892497339063273916638860131717065142379547629145053297558185567155580289078804833133323155623898592227362901992618266649001082738287327625009340169715002810953003e-2"}},
           {{"1.548186783606525160350564362943259766325354576110839843750e-4", "5.6206047199489783281964316863366093457443639636039733886718750e-6", "9.99950690212005897959136097299917160482075781519044088208212676575453006587694459400083447882136665068803314657182010357110987268971672741796887858729353234727108572424227132082469362733286450718291677866426969142840900462763239110268260519434037322501413834614893396154343681850902784948541773957467e-1"}},
           {{"2.28067710108071286176367742370985070010647177696228027343750e-4", "4.22516467629786623624865704584863124182447791099548339843750e-5", "9.99645746030268443121474912265456530387059240825775542503945117534294341852612112033263023994402497137577664903179947031417093395690539107266054577344864123860512144985801819409282408928976825661093887120497669159146596001826170808186934642139325551337232119779982282458342982953928951761806573163414e-1"}},
           {{"2.207390838128851555666187778115272521972656250e2", "1.6363542834888315915869635985835373048757901415228843688964843750e-6", "1.00000883141260854728883702175584015782702915499431300231183450474406119123947650012070542489465023521252692179702983050986429423066780728766911719282820886407479657520041375764406817735028802434658714254220988205387649994799335160542734586791578044041036401530550092162441750788372567864862832251789"}},
           {{"2.11115639194152252336444952618421666556969285011291503906250e-4", "4.9161117879115010964596876874566078186035156250e1", "2.03851749220927707096105838017357917405034340382528308320810037826391303266735158295669708446462859180309945589089175400795292926848603356140832744578280150360981737396616217244331933441226205091493168502347016694353942358220609837333188158011389094568440922575728826317171755408132992139505746448351e-181"}},
           {{"2.38633916347037029481725767254829406738281250e2", "2.4735015620527917690196773037314414978027343750e1", "6.50492562190358454748346649100342667975057580840217621906828483604765156733043048058740688210262627421835218492853562454601684989325985386603026971417507963657922417960947826930994787046883004260577743222590669257927836671693436821127356903028204248621426323317746936948905014560414890048500518981483e58"}},
           {{"4.1649649013569605901508019485390832414850592613220214843750e-5", "3.075261121906532935099676251411437988281250e1", "1.95708970459274514353705613356165057031575229424640773311770967490560575262481854947938662630918869775857057855329254545872812061129308665775656748897011265399787487814796202063476887242748791769330372489092700441649278984973352735989854637536188114328280137258357850310518955976767163293227505459553e-135"}},
           {{"5.60807874972006062050389196826927218353375792503356933593750e-5", "2.702445063506279812962085351557561807567253708839416503906250e-5", "9.99735500279497094553640363695299701240525058593455541261394700469821111611056791299453732067954961427582921898800842237144105286658409494042658058247679724238096009700396852983653186891371272750369926281385138909360300419604531575348226930671075101518323161673992501032516753200240811209353821343888e-1"}},
           {{"5.00853676861336616008002486921668605646118521690368652343750e-6", "4.006455503457152644841698929667472839355468750e1", "4.42868005311869594653291738037482789532744928595938052618021862026535850449639612018073258671047578104461913132613998217526422325806836712765473733283115693708797988431341752008408657974271055896785613419004497755473106128411938210880970972796033569804407750025332012993610194266901383355037197031359e-213"}},
           {{"5.353231678137881681323051452636718750e5", "3.62778514750403147104407253209501504898071289062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.05603230256580909333512613256181086069213372778044080861620436376260245170503316441303581724403388552683668422287401763124771418367914789920284987220255387646685601968642931765033670724000770308127910918065433865509022691461489073952236533017504964013454255542118759406756885123664390687006240095440e20"}},
           {{"3.229767642669518004638895547486754367128014564514160156250e-5", "1.890503050233357953402446582913398742675781250e2", "1.01732691727954660011725367716319147371899471036670702622303272300897410300692262400537048572027256759129565470020582895602617924506137374758437886475976576037363655165839084170315722377939735400391371695808916328159137254265306017499308291350722410467152148965233006027461767679652965168830636324127e-849"}},
           {{"1.090489414238134486367926001548767089843750e3", "4.65254774353689448673776496434584259986877441406250e-1", "2.58980988503590960516637371738014660727349100194484396379725478994088734700803526572947540745308063381145664972855458934861597057007568531182327714420486870282357356343021375166932444789575430439279485545025094851301007569967666444995213425647227644871269194317170084391746473828083433195180432304317e1"}},
           {{"2.447434794350212996505433693528175354003906250e2", "4.8299511254984222805020088742367079248651862144470214843750e-4", "1.00266010667859458204491495940561046268243246346579041029260554228176172232635197593622622290922199036969298596977304010218474771392718302157017833152484401953670784025973565870850532277945591072432075029519001358625355897190571211275599240174542923282378185576537237233948130696870807231732661924935"}},
           {{"1.51488749663457274436950683593750e4", "1.02354275702668705760531309145733303012093529105186462402343750e-6", "1.00000985234516448019885473896561732145157443536520866911511897918118736186775473199587722487758817093449012349451559620294147840372481518705271731392645893056248771116553702829600792931868987911801336627246125357506584399976395776801325943965572049289654345210028541577738692060413098304903948601150"}},
           {{"2.67331385687573711007480881107767345383763313293457031250e-3", "4.37764930215238656785459170350804924964904785156250e-1", "7.47571438862309533743624874136133366541454712127562663177399504286662183346894197246880043192629661657584457838166576178504996182224295507635623850476949534360416194135273172780271343507597813231256012656614579448387095352094197763495149376101171772035626900389244626161777607049448871411562278802652e-2"}},
           {{"1.018085344443409034909109323052689433097839355468750e-2", "2.7221184783694063469283719314262270927429199218750e-2", "8.82611384964605354323505795669056920339301763307089989948479130915805719954810517867370884785746904749334148062069679398152101779177523464996450923425943206891878509254410570738031307822715129842441609577961369156460374327926946469260053825787159767563643637983753386908235973617270978178126680100594e-1"}},
           {{"1.00731276656660706514401226741028949618339538574218750e-1", "5.18228984435489814508457584452116861939430236816406250e-3", "9.88175560346904726742930639398687086396036352224271818500936901685374885901648764892385495076288151387225190990418969616688304224966648010000551417499596854632379457426863173605879611399961688292945890600044144991480340984880181190619092493192482621545694847376381337620163394916517599662918605010835e-1"}},
           {{"9.8780468779964552975339509011121208459371700882911682128906250e-7", "8.4829576004481441486859694123268127441406250e2", "5.06922896545426989764243576324057040501874322165012440675766666713649225255160119756183042369835830558457195704471707778294936068250116736974227601059618844500705991834404101497665868066256287785153513125539305523985206318973305432078184236844170690028706643163133079135912179653756316354134757605909e-5095"}},
           {{"4.41825747491548099787905812263488769531250e1", "7.7982746222263199520341458992334082722663879394531250e-2", "1.34369652134197483793288072833308732535658609465509415675669768410932243039179437886058214288267645007975345260332874670014492568423533076540783205684921434471069515293441857790677592200203989418352589897685209311617733829289352336172155226574531882652742067029068005584363117523423189997997484568014"}},
           {{"1.5296844845662072032155265333130955696105957031250e-1", "1.634608212615425469138932812462883248372236266732215881347656250e-6", "9.99996930989216600191785450269008898634303181250066938686025190496179003638914112281154344493820093586185759774048968741774280050131382009162499732926045936023057461223555387483027406180587409400576483490119308402153097647327397891029914779646839934539999749442740222968027612552511977099477561837845e-1"}},
           {{"1.5459068196982534573180601000785827636718750e3", "5.8071194443214402269859419902786612510681152343750e-2", "1.53179160234960851931903141810390484338949709737193408192930930410912781308171727424842710235568081208824229115859793069399719735722193263870374052840504012604354910230724690998586625239385836126384899034476217672957422789468436133936022499041037971795682906772214055897416212584774512114169944288303"}},
           {{"1.06149875426708788185223286681946319731650874018669128417968750e-5", "7.825390041638166649384800166444620117545127868652343750e-3", "9.14272969225465289903926091127128136862591595250320697667906487225773277795209213908946435749298160698748843670986774816760975159538180372090105486573778335998950914987159909756145213525174507361115992516851061441846585401483368166991251261491681595295047033029078105940961946982855869715287402727788e-1"}},
           {{"1.7094285962280424476245066500723623903468251228332519531250e-4", "1.450141513690568874708763935643673903541639447212219238281250e-5", "9.99874220008245006855542326558513156408919554643242887993818629193137080289456989925446796371679686209603602304321606023129900225876158421172053263787015124593801332165057745276555467837973732533352070833078756655605565367486807321355073518225701436176826535604183999704696382097767183866284922545237e-1"}},
           {{"6.8916512912179988745164926911002112319692969322204589843750e-5", "5.0330071326271585974154731957241892814636230468750e-1", "8.0431310666453857009883974778955214813162656180917019674667856365061641342629676408687942955216557038170696029057610396511938999928187929291101943535550497469155161289193841088940635225677546354860358907449034170591377521605530181623881365718072538006198487060738937169647737729128339219664578636910e-3"}},
           {{"4.27946433404347626492381095886230468750e4", "6.700893693973940896599361671803762874333187937736511230468750e-6", "1.00007146201085226752984788738357625307865767014027631803309640949680577376696724418376175136252913773532105485594068985474036691750060444806287575074228772867146937453568465581121950409526897590340390497454647087617789150538474509489560078795836109491866150406233412810302502603589419003168433407796"}},
           {{"5.40162932367991470775092643918924295576289296150207519531250e-5", "8.23362153160343446245406084926798939704895019531250e-1", "3.06423742747299574139652654980590788059822860773454214351500321781043318590458743790589432652553137712034307825892416077869655718345307052092676953436188880309769835515354046500269913785918625489459139881331406660934866445646807527177908193314853725313276753369974838311556362819425625446719126859340e-4"}},
           {{"6.98480482930233392835361883044242858886718750e1", "4.824235502562374379789678080499015777604654431343078613281250e-5", "1.00020487356414235503163915728935712973913169358041240146118411664231468676920896629650395007895636986611826729763726166983962518312776000911959157822099221405201493001705233813919293314432879950393142137203274049451871519519207057550355386892818843802770417350657588091700213982000763521441126819299"}},
           {{"1.011744866879515029722824692726135253906250e3", "2.80096038819214743220697982906131073832511901855468750e-2", "1.21386628363111930567875501391228231832773971221469956618940994372919354601446271218977478634940587702534597215097311823723977361204234536761437991482874205192547888855528921579052205936359371957155208181288324241439984156409711039174371275245144079425493549183603159162251977135775037801563222969321"}},
           {{"4.585276426770756863504630018724128603935241699218750e-3", "3.2042680303031754671105879594961152179166674613952636718750e-4", "9.98276019906690498641979219227000354726256121309260540509550375256349346398739094196651394582546860191649946783658447448964727247382391275461932541094336719168645988397711787831199214881092736264632640564846015317413042211277375865471754751928875230345189863352333606975129830522964976988522205012182e-1"}},
           {{"7.605178759788278064490896213101223111152648925781250e-2", "4.478670111360627537067102821310982108116149902343750e-2", "8.91022318181765750138709868330053023824369950588567785742389327678334961200987486582852651651749970246817747258718976307116965890616698349626417133054222982034680094324870404036435780314465221090580409266996951521555820905007542674615310907131989836681135988524628981589839950536317534105789412104573e-1"}},
           {{"8.7444178759210960467018400321670412722596665844321250915527343750e-7", "9.167217375397957368141077516554560133954510092735290527343750e-6", "9.99872128426369981492114383609632051952305521589536821086005990494116094292173923739983506376030713210025133335713606540746004193037337306885070775500980783374129579854971973151969528024543815880504327167057351706595072153954661171897742253459693134310482723707663819212838281958152922341896338434956e-1"}},
           {{"1.91138738236028468236327171325683593750e5", "1.41870493681337528357744304230436682701110839843750e-1", "5.61393719165089070084284302313399424679983675134163509852591590498735859530953368982681984829992497504960254661066913076235623948356021050016415986014420596315994017260378613566207333104954408470522228787617243604128057260092817202582188202107977088110567991555379686212833460754614025473450009263444"}},
           {{"3.9593580509452585829421877861022949218750e3", "9.6634279823755485708258738952736166538670659065246582031250e-5", "1.00080082312808327988582209522378397852005304579172107085124537382297137225033557828343923139785908077173538670582197264674005612125502043965115623737220659926592486850580770115661984729610019606048664824477525628872443957605574420631353398611478369946179434030057548832782863477926163435959118485879"}},
           {{"9.527494822481512651290991300356836291030049324035644531250e-4", "7.36644237252481737243670067982748150825500488281250e-2", "5.99043290744436080750367189311776962864514898582236218043546095145053426015403970275978470316955018068268507145854768132371105755976745328665490014149700831691054362640281890694866429566348288921720874015164835895723114083232661342953621394611916380955923119767515256749281015210664840084139488728470e-1"}},
           {{"2.484228956307928110188928960688770075648790225386619567871093750e-6", "9.5599312498941491078596754960017278790473937988281250e-2", "2.91195173359063670429359403048505978785219394151399979472770021116863735850753993687072273831783588580026886709426140199445066463954822741869299289627867228462101496659941594784834735871174181621098355725481647468654367330416914560339262972917390166297854884128515599346578674725441419457079115897184e-1"}},
           {{"4.9491118980876490240916609764099121093750e2", "3.004862775930479124042449257103726267814636230468750e-1", "6.45161540440045450223953783783894469144373503171768310299316311211396701039652476264548018632004490940551121650475174226555299061745541449779441170912616150358121670452871969103360706271231784736206842228875578338918267487091360709713844820843854370488212897734417544669039756642667411365232861750622"}},
           {{"5.86830898821921187469285996485268697142601013183593750e-2", "5.157145004755338615898274667870282428339123725891113281250e-4", "9.98538706799650092346821769070662036641738082636479009372539733284347573229317564170016552698886694627816395005478215973507005929122925461962335439146679105934195547032542346569150966461707254588652749552262131982196536881226818665443124490222705261425197752741794319954946333545210933092733146260794e-1"}},
           {{"7.83501026710203586844727396965026855468750e3", "3.3878804079488164524569526747654890641570091247558593750e-3", "1.03084303369653734759444079184018763110189145271757350290747789171120440011979438908956047437954061198621891331998729346005011749200857634828740000563446280260144290233886419978479827799434112209614567540357757105949708290107985650241181647155069956615108211465282807906696708079090952998142539773200"}},
           {{"7.24040157384670202134202554589137434959411621093750e-1", "3.2139750306174955096771839180291863158345222473144531250e-3", "9.98962718742601158545306104847042012373529894592940838744141601234699871358047935296869274717524339141323620050266212255881930805755665793284647269071772742030623661802389270250239007055699061760303889999391509361560603832488400525248124730452423718749922363976939807153833465852271516354356322016570e-1"}},
           {{"2.3773749185601933398004348418908193707466125488281250e-1", "4.166703987089275251776143704773858189582824707031250e-1", "5.49589428217805567802447379970866851398217501608629580197067814528656191899243702632356211673360505654178344944705028006574948563210523891802606219873940153904076904718577079606890006710252221715434732369471615966209956056482424699085238332051063676105524207191799310422842401999054890360978090765282e-1"}},
           {{"3.0164787400072270884265890344977378845214843750e1", "1.92136460953186087863286957144737243652343750e1", "2.67051217459346602496477010560417251705712700254048639078839264060325224717762633346441800378240849611262512392424682983226473649608304764571881449403455973384432668551726106109236708017847884189936294979084049530151497877322166267026808199785689058092334141134841250691148642129989881676444005953065e28"}},
           {{"2.6354055582639710278436417922875989461317658424377441406250e-4", "4.228204328677160894756070774747058749198913574218750e-1", "3.06662853666315384518454771688957273896640018166337060934230580664851581626370131366235045252515485872195142490483479220526746937459904335480861408290098145258297721984393013560504944686230699800648442282165588666276252945193146150539010418085408269547841393316042913883904363908615604194055289620194e-2"}},
           {{"2.26046063075346914672536513535305857658386230468750e-2", "1.3627038921997222664650450951739912852644920349121093750e-2", "9.49669691356986597021713215820093379236513850713669538194655152931335203737791678558428932820631859896635045077055245394317491407809178976243739664980597540207413635355482092381212167318467695663002155241642388129246468412919845420697165678187848016391630764936016535264450983179524692369001196616367e-1"}},
           {{"7.443698646524410378333413973450660705566406250e-2", "7.9213801433691943820747383142588660120964050292968750e-2", "8.14010675669123183496921521116811427733135459824631474903189627969592690975861278168724266785431509343760131532834105760648359541103464859507378780843287835638142981311936553660415847409900494706845746029735940277531884780112929935900839635096070137371899495277565868989524061668633390669303733877713e-1"}},
           {{"2.587073658438795997760450973146362230181694030761718750e-2", "1.947141104726958928949898108839988708496093750e2", "8.94285469588168562425042075510651649105332456874498432065780910860149873485515925490595348642217083245456881656394030092730262652761300876175697759058061470631341983801941103052127203347591729319027059625352617883993869442078699806792081819748879905962225386908139580991345038356748418452094703929970e-310"}},
           {{"5.98084615325454649337189039215445518493652343750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.54141705573080567892238490479428492108127102255821228027343750e-7", "1.00000134883014846657688131845485191611848674206835683154280061306464539283951337684813473177431132125670490032207511582839375165363167348982592154407605611359695341748966890300250815981718309647127029989133813099179248600056821756358657145575917892530126627067999467459186401635829661375435200555943"}},
           {{"6.95026071869872530406553323700791224837303161621093750e-4", "7.3122523971193590860973010592260834528133273124694824218750e-6", "9.99946829922765932774347186827261089119719545372876939189761602548364480617029835514052044796339343249676137993597737045638155557799285710458997819509839368231591299591459306098956962406996519241338464726435617191918273092870466980318418139849371272285377732672340181070589663937610591450209282798517e-1"}},
           {{"2.240734448249001586894735282839974388480186462402343750e-2", "5.72011372485644930879419844949040907522430643439292907714843750e-6", "9.99978273147710365618565727465750018434266860028552780634511158239820481200127637360576082082285493761515451879661983436902590331857062933298024957408602175417434650700857480478630047039957552639826605254005583176460691229891227955796802817287827361621819443402008175782397464338976239485836367013797e-1"}},
           {{"1.026963361521984101701332470213401393266394734382629394531250e-4", "2.11791001950321867638993289517657103715464472770690917968750e-4", "9.98056858099165538580460452287541225753365554206313892868475688098072267264713973803329319240088967254425048329384938932204820454762680502689447633583472338302047491675207245782389326788006117820440333632657775030341985234164850042741621548603372080092391251779877542034296864156086357253603371919108e-1"}},
           {{"8.6703705286307886090924057498341426253318786621093750e-3", "1.52133920341677693691129213959811750100925564765930175781250e-4", "9.99277952718489198651035604747543743540115676651768417733688848831717723612326298765655588890670608573536137096893609251918929861039853578444897886108139617036413401117695629638378951997111811960041138307910848973294872108144596558607179052633028242671568000242144929604511881481654385461936722413631e-1"}},
           {{"2.52535597921406917976128170266747474670410156250e1", "1.67545906951556844433071091771125793457031250e2", "8.98282264364143312494924261974141234695472294090992155155562018911995536275433125782292778674260525238398016330461123980463532873852775335243553615531641077025771609462191107211129184970987736565747180479720790198029098762244705019025351383419378700872375798060833692002857187730789356240125924455777e234"}},
           {{"2.616405991228279162896797060966491699218750e3", "1.04737226836765842108434299007058143615722656250e1", "6.25310610377006493866619672909110501466370730517133791833746014957247005356303121141646462034804208859942897670276612700251850886627624409691966399085604959689485003780186276442904234165384933316935452289326908453230024435075360037297385764282630607352032826861327915100978947458904222670931759368924e35"}},
           {{"2.820025944394430328365785953792510554194450378417968750e-2", "5.2890336039443846876881294427619195630541071295738220214843750e-6", "9.99981126663120663978315445418195178347518855090095327320928958000002380082757914082726230053423120527749961157170801907113926659877545130473348116514066094356797962151622116993547396704816898570832090901788549840104993042307779674567777216024811187461718618588120530554820575895739988590245022632269e-1"}},
           {{"1.05597237376428054744792461860924959182739257812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.74456803510535429779793048510327935218811035156250e-1", "1.05450439582280470237419243848514333965208787934652393730167951372955494178606431812200728304139567804628971230701860498398849175230634941866518705534394558725303044357497118657164159909944927143807152603979711611331658711835035945317940163428557910521645089962892594811777021284923659424445609434015"}},
           {{"1.9223890780950902978929661912843585014343261718750e-1", "1.08349612860076613971363479471676782850408926606178283691406250e-5", "9.99982133131096723846335477747571205458555360592772378989843831769539959961315480174186773210831188200236203659966289556452394505676789152783853641019895730138295352465651299769502538786481056285110475730395967855975688507419189456451422446526295567348482093213471867865722148473015661603656725132323e-1"}},
           {{"1.0463193386008525267243385314941406250e6", "7.4762865805834757826353609289071755483746528625488281250e-3", "1.10918690854877106790971565776367526216180983995819057803660864422406143847654780992569076690586240873186597255294638451033694659817944978005382660886521706741399259776875547778479274738700590433170032223482808245749786294093246294856718197278358866518098957741521257199802713807166809120449267805013"}},
           {{"6.36259548895734333359697210141803225269541144371032714843750e-6", "1.228097727883958611982961883768439292907714843750e1", "1.52598782338450286286135450458954573598472802663327374811636800203700927786701774385033841837545251692421774984587119423266677067201879737268514092791650544542213882071172025510515697098553107823303332247548034598510867132891098061561608401432719775239528846321974734634143406918807796517003534735158e-64"}},
           {{"2.130622669214181965626972448113463087793206796050071716308593750e-6", "2.38534614031968601466360269114375114440917968750e1", "5.19098455118066498520013706754490677591984461696830181149035955535619874262474066374087254218809585126187088590005269981305550987677753928730521021427525334082765124171365549957770314171493849134109885501003714622689267145862269434956103582260650590467252136804225198053437675495933201621005291059680e-136"}},
           {{"1.402904015919878020213218405842781066894531250e2", "1.13722689335705595681247359607368707656860351562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.76476316747050528850692000246200519522360470716902181350858525854503943786512297020242024222896565430817144786078487939900580658865175044648134728561580288938753166434593435107710997858417174150763109875175878816362192204521588377137231081824131646740939989148534654273494711671253618986609286323224e2"}},
           {{"4.372017573127668583765625953674316406250e4", "5.5089836882907093240646645426750183105468750e2", "3.50016375413563777673770541325000240347503109832508653488647336857427144256430628344920480322962866090482161278435394130795573385145704869750655237320185554045574687208211132875092396633526114578443250901360527371315672281676871350085960576744972765455104647558784495896122434499365424664074824652372e2556"}},
           {{"2.826577182614404106300587393718615203397348523139953613281250e-5", "1.0106583572245043299792435775863452818157384172081947326660156250e-6", "9.99989414562934374733570123984537478193847375990023521202992404597564318809152441993727777418090556514104681985844118458823465596529403699968559686663737740106923387493303105200565503166558779713221587331443491180025140468746214432126679720477339697928392369627582889524402889778083449486287091857918e-1"}},
           {{"1.8213158806543649700926401635570073267444968223571777343750e-6", "4.6651819945007291789984549268410773947834968566894531250e-3", "9.40207373373989750079079577094631199620167306803671706440022399491116271902378455342284164919251165911009699545436187010204381502830971843813249510091499154307328869929569251004649662529059388775244320275509563520973233815719214546857449027774185623555318990471004404713606927167122651605783870374832e-1"}},
           {{"1.46755915364810964092612266540527343750e5", "7.890436978365517006750451400876045227050781250e1", "4.64484232464543513497888195163429809804134777698713994865506287396508104602871734408178720046618390944324170991778876210342419644694461221793882529660281950244593440074231456401876196827229747637594809904497759425267031152839358279700896103069795279548051852526590187125738047135851503597639320208298e407"}},
           {{"8.3043328767694905400276184082031250e5", "2.526375713999676198007193761441158130764961242675781250e-3", "1.03503345548731106338710812130725055986503423501253010837510324365889248445099107670056377581266593900575457325985155519568071726317821696776190852210129272438899726884098324950090040468317646989831449979292183766681690581501814228892321721246601040936202160676525600474705308542633568308584316650080"}},
           {{"8.810761098079578951001167297363281250e5", "7.333727906319231770737587794428691267967224121093750e-2", "2.72892191263152309368418398483858745615162148917317277888912958706672096823639413941816735201743610855503568372158123380568416223942437204395543055191166267974357638190306465483077702922759360128463612732981531386413914170095452050612671264384868877433570747466951378322325020744405691770060335633788"}},
           {{"7.53729022560753492143703624606132507324218750e1", "1.44997674051331170439263495985926510911667719483375549316406250e-6", "1.00000626746844722828444925305995099577313805301524404103686494009081743532235207019307339151083010194102029079910572707461595043287395038108777455456317947638812268175715959797135803525856300281211049078122806988241700281453385528141559419083370029575853474851945010647429584718991721854559935746944"}},
           {{"9.29196125311857485939981415867805480957031250e1", "2.8736407594167267740004056975067214807495474815368652343750e-4", "1.00130310607123242618493657884019907082179077698498276221909900016213891825242765534255421206798520599892641330780794108614272121210817595736511473642012182311222406630247676600611837624670300497417793849558413334183751618128852678982366003027694097779362865347129226028454653385495003448455051752341"}},
           {{"1.43727353532569850358413532376289367675781250e1", "2.29608176142756548188117449171841144561767578125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "4.54783993491495810650470280449947427623348347028981499281421336796280567779408506141109574684107695839213640033321254129078108321583824176685378348816016878194065833488610016432724082665467588150668096361892027109844713789484964974482948538692616206482165899790288506924374902752205806598101379280087e2"}},
           {{"2.70759640224985531631318735890090465545654296875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "7.3053673155641374314939184841932728886604309082031250e-2", "1.07547877767428083419096142604570911700485352561609679581466039671852713698452759329634869067401784752327384511745999840407965753203664746748858043080448574928987130431330974864221970333531951352649388383982665219131905566066113253186390249711325528920747650049981618690921655600270254173866304929129"}},
           {{"4.86911459659213416298687016059432153269881382584571838378906250e-6", "4.644152955186586773095314129022881388664245605468750e-1", "3.4101267379164705515949071061179798401970959719776627431996781118094045712804741707881326020834426423441290104362376100384993102590570489653592904886896014643278015566215567423158647343389452934468386848973834157280506928166240077741426052002687656557079088494350099594841014879134383100929203824540e-3"}},
           {{"7.848546904342432184442657217005034908652305603027343750e-3", "1.462948744347492002759736351436004042625427246093750e-2", "9.31540724563669307320322491667157973956200661651434919571593303846115863894103669513415833366999982869469042192760040827577397824232012793869428364179080549290195624467934132481201575233560543620306283174662613044511585064238810137330925608875093333350849757044686376810419383361338035393598016327803e-1"}},
           {{"3.721202627829229459166526794433593750e4", "3.94908530795382262112980242818593978881835937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.12206584334504219728846621264973553250302703946785171831645645721830894010675262018545815052840050758849380777393422282576480781495344500008748097426459462508969278927821357065182790433439566919608820582252667225317461885443234193297904549706413625058399088149505555110903375380342716569207812657836e18"}},
           {{"2.37172835747338208930989900125041458522900938987731933593750e-4", "6.407577645033786170603029574976972071453928947448730468750e-5", "9.99465320336479719185464362393617871174305860472162937262848024567759736497677820188393809529906684006391677099787283285239332531375600773760223206100883246634220752238455329498878968166316454533321577818353913376078773928516840980584615525022113173652501922620733886925072518116022140332545581471584e-1"}},
           {{"3.53605103337158652720972895622253417968750e2", "2.8458247691311680682701990008354187011718750e2", "1.83532969791885885135620378353794410619553188299174712267165316998085251325072529407513466403156971688912550231810700054288873685181499788137652636209514628912399831379317778239395084315052983947372535292000124065735878003968456173427606734312841500343489942261612441073694733682134245803236657004841e725"}},
           {{"8.3104808982436933329331421593799689162551658228039741516113281250e-7", "4.155393517188396557138219122862210497260093688964843750e-3", "9.43482075927723057531497663442495255886217925614713738709933378320005101165593393456330280592636199704470243210249220699112677280162135519833702952111992891673206729843009842099688221317242192847449764385413153153282253151503752131156497992327652425308884952829049613144312048128169217759285595530627e-1"}},
           {{"1.1466602000178882008185610175132751464843750e3", "3.3412765154888893448514863848686218261718750e2", "1.74479451169065114507177142090694649425184490446641781570460948781576584635840991601731927655494758023459925015377386019778946251375096661299820054396659345784163916943122911769409035509491324432205386045800229510005976694475685559497072577311014446199955236237444975977941360792089045512126998703937e1022"}},
           {{"1.592844639464667579886736348271369934082031250e2", "2.373685961415714085198658267472637817263603210449218750e-2", "1.12790541394790276732931574594592716168427963234746835691403175587826006982488095536822241070760245600803352183137207993347315747261870544496930500337717553335079860285134922718636682581363247953489931749833309595523465412068635376914524529775388476847978990731073661981262435307448746968442209991247"}},
           {{"1.010374635480884575322590990253956988453865051269531250e-3", "3.8335008475018355511565459892153739929199218750e1", "1.46827959515471898774763024079995706113716782750728469166998382738205474672874505408339070961454993286360763402251395607969974201963555866889613983970569781895238062738547839409015372756811222082668539050479266568911339662981230077013588037391296361362960017408451588351832195207411208108858157498757e-115"}},
           {{"1.66695565004290529032004997134208679199218750e1", "8.71804015666434395370743004605174064636230468750e-1", "1.16219309185108283690353246115834277672387666007297244563945515894098174972467389980428784832971321037184548414733298149740082669071577857913503517445753714679820984984835536300423998074680014379718142053804437180632038614386541542054507333387434066222641647278889877313111291185910035634611028423893e1"}},
           {{"1.2846460229611635440960526466369628906250e4", "2.3245763842937037679803324863314628601074218750e1", "3.24945391385140670639469572823424256394544549042741674612450176003078448450232834405677926416541827735839125915448795224664876170676948629996836691342006517593947756961464160491430339434651171508096026536520981556090838358776179831242252299597098299062165399439487062435923683313278394249407345431587e95"}},
           {{"1.04339649065651030425752598951305571972625330090522766113281250e-5", "1.573485708305823038699600147083401679992675781250e1", "4.13059686908080605126564483508274490473647130063580548021629986277623406548383789633827569651948273474979014022501027829260141472868965231700274633764760142846471542740886183449424861759202613481741450387488820213753956013540876031520080117102079251759436887925675362188501650887210343405664270909838e-79"}},
           {{"5.98527292754746476077798433834686875343322753906250e-1", "5.92842618905841398438405498438896756852045655250549316406250e-5", "9.99969570850103897852254602475534171540024098089888531491644885537022647868647455296214377097624078476427734613966180360314627711193584708132475074727707481960045949327090840155765239976195485323033627665295521041657350135494380406033384926325020170964497589858453537791112107981125863527921983931294e-1"}},
           {{"1.201708216294719881386821036528544937027618288993835449218750e-5", "1.83573171858579975435077358270063996315002441406250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.28605001646404799122123246583375017811401439409264242217956456924187147921073178601773640157007541107990624712528914809901097933653148466740296742087373566926721281981068789281547799916665066119657434350735735616423796448248252402292977828214490771898387468010213868209841336736006316556313401379158e-10"}},
           {{"1.790278581302762177074328064918518066406250e3", "1.03754584982387711988849332556128501892089843750e1", "5.63044664995037750836987820374386953646551425036186940515842751543311970070428773125366390621088048509415536569966741084563251083225715464442813762547476523458275835451374563942157742199280762833831415410370539590912680755089996665637460577287883121257390441169299493248423283996313182295602073608455e33"}},
           {{"7.710751773353188842641259270749287679791450500488281250e-3", "2.641820563533838139846920967102050781250e2", "6.43972399050369154988520798910605088410360743083682368257478281007222478749780386934407011016164443028717189065642983648339942330570417348717676304330188520673656075843370307967688074309785894752170432378373350782687762813282030251151752809306457995236444306078641839344649086096494148698382826630683e-559"}},
           {{"1.225859617238612845540046691894531250e5", "1.01372669446815572924860959780346547631779685616493225097656250e-5", "1.00011878102928302779143036441761880708224532433147368168056931216968198406137164127175122694955536795144107173837990207593653143943257391177552069467355860858316175819319731322452047752960070552385154812027281420138955970684262089648831370958477699568344849874652831370849460274952408206982772881433"}},
           {{"5.82595149644963838930777910718461498618125915527343750e-2", "4.8505876863872399547749844628263815593527397140860557556152343750e-7", "9.99998621052671820010209082288722125377109323080442152434584440919377662337625060557131747020218413297035621822998191924210038600199853200536989949496907248450515440309961142400248274163420688419892365590086355187405743025995286488853302886303794885670413483577122364857720736276931131470386157699818e-1"}},
           {{"9.01125395544224438992841896833851933479309082031250e-2", "8.218060702910854331548762274906039237976074218750e-1", "1.38368157061396129371090614663532617206257134398324144105974743560347038187851945959992361814602150755480311739774866352614225040566667708793196627370259194113771020229764238603211377558658426209396490633521450588911944454397547213176293597692411663128824894095155297793732492904564527595779976674988e-1"}},
           {{"4.409654394722450909682720521232113242149353027343750e-1", "1.024539904317003369271787960315123200416564941406250e-1", "9.19534075097294910062427312364961024864527797483767863624171403928319226867976521096128692940847528103007338680691678979870596291215052686966371603169090630798213135736273205172476019108353742027081191692977102801637543740660392501627319952653856947188066651067307484842658131091249553304134437847486e-1"}},
           {{"1.93717944386320728433759086328791454434394836425781250e-2", "7.08574263216941169218898721737787127494812011718750e-2", "7.56194064144518235667018224449588679976819296337783156090494451036523029483949448332763991177580492553296509263765798810431727918219796862387760870580577134565230417714219352767669331762365217747400655499790736729474440290141888015988952364748907315410294417222286566628219298383793200309754712308589e-1"}},
           {{"3.6647989268164383247494697570800781250e2", "7.71145011595037033202970633283257484436035156250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.92304236247268349096312573893392045307545699411902317264880124837981164329935084560551082257778103184407170649203234984204658334295355705120603551098245781624244872037069412927213696722873101986921044921101077821551960590243440000669839151585453297946266135519928259442687204452169702512081165606273e19"}},
           {{"1.32708985351551091298460960388183593750e5", "6.56531833894015816668887630669360078172758221626281738281250e-5", "1.00077473925602097877583679698815018000110220247989590351745049914772258652489667683543311902850183669682134777670514222872443151397469262756195899010288195180434965887160900063533882057343026426147190468334739066751949659071732450855977621834587152702675615140712006936143437739732339126497413250346"}},
           {{"3.5277504526489622094231890514492988586425781250e1", "2.2020744129417768597534177388297393918037414550781250e-1", "2.19164668712694362712251058826210564533792000244902438405631163228898011483361552530774835675890492313952004188178746361986328169935055931569379688204574777223286241370824460769287348812931304022631646073013552253933784290828875633916987679684918077103703055564642008994164871305721849760321403415697"}},
           {{"5.2672115056769689545035362243652343750e2", "4.0259402110544599204255966640175756765529513359069824218750e-4", "1.00252610964243996116042029581448234570507107619387893463104238190901401098561255564385433004137657583567661490188312636640964083001255112695679226528406143723662756570159800308402030438165398677929717369572388554610405821138849352686065896479954227526563362385890018562652478441542017212666618852941"}},
           {{"2.85382232656423795447153679560869932174682617187500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.216220843310176213947215728694573044776916503906250e-1", "1.13603045090195516704596534175318401579207918841598587146324536013529784552205952203801294482696233870522877138037982641276177183524409958004888324787356863626406890600708780844863240402886258989044381114275612277702992295412653204859730899096318397139691123133990243168861782693287239971524166152533"}},
           {{"3.9338169463328451214145786707376828417181968688964843750e-3", "1.02640519319720624480396509170532226562500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.39863675434390989723351064011214037513398262547140577736762821607782111942948883337093856726075063500818067573716198405459606323946322650536233861891286348318106161892821504014313663700097828008365436512713907896457061009150442887680100088324705807016079909429412724343222986472982422270499720872159e-3"}},
           {{"1.9072397321581938740564510226249694824218750e3", "5.1298095404607061765026032595926608337322250008583068847656250e-6", "1.00003874831722429751496737922917004435479965257235816453591525868492670813319281541168275796018004391940278219820598993631669244673032352035813333397881915928790424205764915135090114218540888704442481908590391442502493189810976009897523082978954781479402200004590037271385433077485827559023806478611"}},
           {{"2.083523763392070122790755704045295715332031250e2", "5.7732837226565194486916851590585508802178082987666130065917968750e-7", "1.00000308249415661310193935943862153702303875909245307529450912006821815453371252563642757366042171762708256721399309832054533722706035892679765533583739735266608823632317266441068592608135365434098808509810551746075126687287986572543900322800829577692516676548344312574211742425657072976921014511642"}},
           {{"9.71724513689399464055895805358886718750e3", "1.5360000160986392791703791793622713157674297690391540527343750e-5", "1.00014104020491665960642725547509974756116986496973147973056122194845971531406444606607453003866992922578566310810305178136382912507500272971783788119308610688740112803511843108270710764262658648334376396166426766278251188688321297859103006142315969456950763638190401996565523343208463418705191958244"}},
           {{"1.398026293941192073040993837373946462321327999234199523925781250e-6", "3.51936644048749802671238740003900602459907531738281250e-2", "6.22241870897130620142553713444278896319414844301127628403550478555392596780554049192378201563747768162180873879073883732945738916895322915439456198565943172406197196260279982663959045275534018807122490359500452521705604768928620538202140216274727339329295923594705918674314862791990908520063913560002e-1"}},
           {{"1.827650077322046442973579871704714605584740638732910156250e-3", "4.8431895026975723794748773798346519470214843750e1", "2.44507161334831975914976330209249902713146345349963201960249788428960802366282255229864854849664361912073985037641790912699757539023105844864929631975643935921225809946412808629805438733741027621604921419911409131275740749522537202228860884159853851509071131465735369871648912668689687943767400944117e-133"}},
           {{"2.4987224228926152136409655213356018066406250e1", "4.7047570824358175833879158744821324944496154785156250e-2", "1.16348084392128872602170011561254935010976642009637548196335495165701186585536416597718806964461847864028617635977334329848073696152520245124091137376311572172062522206250814543168673719325221226847866492589752767830775399781911226358430095279351842770613889036173222279808875420192058143269430231674"}},
           {{"9.7372871127818103271014948951744827354559674859046936035156250e-7", "6.491316379063438724017487402306869626045227050781250e-2", "4.07165047632947683093273589058329846367047057355046748020009102510780065766705586588667687646255828190502946698129852184038457736930348397388946238687402139213354445146888181529201139114650892414118512134805367250310852437034078342906915160983796227481872425495472151960083249503055095175373933146792e-1"}},
           {{"4.4155834567063219006644025910190975992009043693542480468750e-4", "4.025802670302487543466107844380985625321045517921447753906250e-6", "9.99968900351231822950433739312428495072856038776486153703336951900488129027691896751286362525813536862927182360156159008954621569331770038862723809677808006540779343891491372231781933232571078612298233285052166498857617406809139173150092488738015228536389093793575323664246229233166651636689627818170e-1"}},
           {{"1.694399654820086253970146117353579029440879821777343750e-3", "2.7072429437320841283387551357009215280413627624511718750e-3", "9.82874963902734961145255850699575978876746826231267390332055952052622176060893943203741788304684214781121351119738947541263489494899175563981247061980860747331222509426652450764505228926170316851952179492921780437496906593243321687842665376169899786546461700589626075813241454757704572169462564574837e-1"}},
           {{"1.033763461817003553733229637145996093750e4", "1.289890172095206274938128387930191820487380027770996093750e-3", "1.01199452382152846374481951076631164582584661608322894290555407864227990207508639820617740715279797178581146570337346215682655494757376897027306747771093102874076785395996716253897920655609144243672317898938847395985100637001354712944101351050038536687079382428227717980685264632621156939159222226580"}},
           {{"3.112833052343313977594618791044922545552253723144531250e-2", "4.01353477046427009958251552745878143468871712684631347656250e-6", "9.99986074588519454560640521673442935641990554362956049271045530697088039943872329332770296441408515271037076808977915428133116228156704302455915102356256867263136007644093137679299480159178566422686424390921886424606676712277018147908640199369062110318937373042728100659267805929813035245614797996696e-1"}},
           {{"5.28149186098080924978148686932399868965148925781250e-1", "9.1665797514525820588460192084312438964843750e2", "7.28853014056156731737794697397317103994217559431541111572375406126519183769444357872853226505354592130101907012445487770770781129901235873025553849331106253792412404560306141938477978026852566898693906386886543485615404988699045603447639500571979436388663669239796393481965967462640474331680310932353e-255"}},
           {{"2.2225059936295621376700637483736500144004821777343750e-1", "4.642048948494684736942872405052185058593750e2", "6.32843078440077439221637641999286892206805235377727400014747144482178933184733036820827184969102097810334387052048590277206436733653974464975608297721942370810634826788083279979408768576378602999295622590369226553818034587114239802440932660296228167167346743576531361276267309223102513376997022773121e-304"}},
           {{"2.6440159763177344575524330139160156250e5", "2.48515468216955248692556779133155941963195800781250e-1", "2.22595558957063988125039996231413212457799685089809815878697787456948885300739760428233740293311835672030485009491199517382307607053064251483492857230753137256332086797523013500249415836024187602707789116720162609479623122987122977570646771495383250532455162474303561808394969890452286012410188771582e1"}},
           {{"1.09582116879168154355284059420228004455566406250e1", "5.1206272980605938016651634825393557548522949218750e-1", "3.40731230607113577867418131365007953849097556433032366687124266265609534681297061468250410931194577479128955229993084028648709681104213544161468193428670594705798621530529153971465865443890890717329532471903443507290510241292018220973611927868861647858691705199882686680328023542042496509604517393163"}},
           {{"2.8765032923235537509754067286849021911621093750e1", "3.296369943075922037678537890315055847167968750e1", "1.22908880787878338117870181426636174855444573322349359087228723914632875946311491878034980145023441888073390972797385266938998183475968716718276000295270333868881283934630328911650991709812223171518435502540229986453603655260898220094106548795285001784222894626512051690586979041086530161063766088286e48"}},
           {{"5.4319233558115521650136447995294020074652507901191711425781250e-6", "7.054908153364996056941191304723304256185656413435935974121093750e-7", "9.99991447218133598413920881391105179265568552579320617946001886143605253717825160221002770761833078341617996929941439664383856515269642825892255570319730959451798678974258583863414985420861854967974576953145352608585972242996479479728931155364675877878808323939895254383920003458645959690646207544957e-1"}},
           {{"4.2445062073765684948489784744651842629536986351013183593750e-4", "2.426176577767188979883883348520612344145774841308593750e-2", "8.28295177297287815001307142572162153750668927480049029937221930255174310738192949066940496577252702629998657734311395912708887847618250337367575924375521236807234588840327753338387239581722861162855798729933237542178055913633273793008757291901196363208416962469352000552707123078294608807586649015685e-1"}},
           {{"1.307332736315109170122106263534078607335686683654785156250e-3", "5.28858724063975630660591753517962843034183606505393981933593750e-6", "9.99964885633207072968580726334787422174518544602461721143383625224899368056665861649907581709049484723249000855383620986446956783244965088674964206494776757278305799759524067667215395257158003498553463221431113016348494389058271382782227321845047125985119505752219731349818937084514014330356212827292e-1"}},
           {{"5.05693319148356598344284940083070978289470076560974121093750e-5", "3.71295988486159203589842547899024793878197669982910156250e-3", "9.63937121881680868303835544307084885674388908256423717510775350630463810161245157254316013064889945722190309457613724784742119883122943867724213022530021363225255978426044946346577578461808416905152263622045415849140604671011655772958990313726815312540544848648362428160986497782665450731113127323529e-1"}},
           {{"4.844239692035090411081910133361816406250e4", "3.984134589118280486697010189800494117662310600280761718750e-4", "1.00430738669558002031403659131744896728312485313631409231096866927631637993851247415735380222493024677897434245013356617271278547792035688620287749522586547267897264556329014249359221662180556496497208175354676304526200770138492165863545577626683932270268515447259703077574615595169323328662157853185"}},
           {{"3.7078480365654198358527082746149972081184387207031250e-2", "5.5250170899286410453044027235591784119606018066406250e-2", "8.33573197351168666887962631201029384882638323647836131662987813863879776215233605661322116050262224430353678691583537529582375506359810080440891529163886160078411813398386404062767305381544566179454141780145518165423921596307439563187082576279320332050551415851387221311994490392675793780232895364275e-1"}},
           {{"9.716555147724156995536759495735168457031250e2", "4.591663841877569041116657899692654609680175781250e-1", "2.35377653844658353569031679679735299370922232948810544763027212743048187579990164187893014793934410534408779634667801500692064187926463087757507629287841868368096408503740782370080191376158895711024144836742418575636184986247750729343991462010937031402061673932392367262371858670977341473615463130359e1"}},
           {{"2.192645859365482010616688057780265808105468750e2", "6.96729316179001942387419288316152687912108376622200012207031250e-6", "1.00003755636032301823537943813016356575902489314188145066916221494580392625081472816947024292161874513732270899683702071327371665141574567958235034154797657204764921080200596842458370044167411926333595258330617813605034939486089552138840272033589961004832483480269032835319807553392086565465392533307"}},
           {{"3.079132493049849261801398370153037831187248229980468750e-3", "5.05463804011641570923529798164963722229003906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.01796919571840276681288861157787148204747502682382876961304668410493347723226232435621763407251840958497596600197906374696494268910490419389807332560043086656936398322936521311486726743408171670806339766715147358441693728848925652781609216889389399280179459317545232154188799226490332505068768929180e-13"}},
           {{"2.72793625008602248271927237510681152343750e2", "3.45107876494454290927649253717390820384025573730468750e-2", "1.21356364414706225993709314217781803611734556534595777181951409142649823132949473277169982486320740015805393683502787636048469072138860871755431959907851351864995912275227191432009279405103766593019141570051245200073079914866268809278471723253071227068595740039873872137154853304817823898235004618070"}},
           {{"7.23608622250063859837609925307333469390869140625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "9.31713845716947162145515903830528259277343750e1", "1.20546015073919711264373148066122758661068546232444031541084969085534241548251886930568813690809866385000095984750691172127616802373754602142656508934912781801862005537086317665378844206989588374435568687107987862008034665185792976330120721552229886514045101504253350965371418298181204870517230728955e80"}},
           {{"2.570723035364298993954434990882873535156250e3", "2.69790274993758974475532852466130862012505531311035156250e-3", "1.02140974620888944930305959435799702728843289682449376214925750857783066006891649041158724227299321084257799199351924992147805951706584524451302681812312203333848599297059927350897068391576429287666840858314350106940048605718179391844174140189607359928083054157216235380992076831905704302805940691484"}},
           {{"6.270713787727346643805503845214843750e5", "9.7721370519921515454195293237660280283307656645774841308593750e-6", "1.00013045496457016358902387902369248820481792505684604793782357003458740283012026953971512527832247937686018956926918760579827820618149654974789601261789353438501933209142889274324701479760186259188286221595702693452369288516143444427753506877231697874469255361407264955531595418134590240336559943863"}},
           {{"1.22109376852135853575020973948994651436805725097656250e-1", "2.11543635047828820815521422282756702770711854100227355957031250e-6", "9.99995551589729160336804918676630911396340574056049766519068518427735361038006808700598379055737548489964622176597729664945550621782605173209704608243388212974829930345797712949588621847644770093271093043600103623962707878170666514346008821208975619634087411931268385031450753049330763535153583731711e-1"}},
           {{"1.529009903540106893315986269499262562021613121032714843750e-3", "4.07910792856703210418345406651496887207031250e2", "3.09437152552687759915144210042422837004776738858769798785362828201158918075365450163702134968526881164477730298716543350719085306748967317190021537573795780001155496528795641888775374745803795044275135632851107711558035622505495812638847592959079891240357223230602055612544312975892640303394964825816e-1149"}},
           {{"3.3357488035001949810975929722189903259277343750e1", "2.224099109229280202271183952689170837402343750e1", "7.53927322890034742368017335227292720005783821228941858003370629012694382557138392281089806659775813675293365836774015539525201899124038456550795641920581579865504101847353382339574548922971435920120403286201070202878099356466592276232925556211910029587973272230882852354333961947656943741233580547242e33"}},
           {{"2.938860932228841704727528849616646766662597656250e-1", "2.8315213921096252973688689458242606633575633168220520019531250e-5", "9.99965326837122789351065801513643019379691746234431978717545032882563543159129029000520238088911519893688798595680083260598269929340163335960195938697476035130411906261845669886681524297055544969116053569875568029319976030656002722062158836225698022385486930605555120535915405105091329811282147529892e-1"}},
           {{"1.0536390034124033263651654124259948730468750e3", "4.51733416318811920042719521006802096962928771972656250e-2", "1.36944656525417845173858897538026176879580880507614615066496128471220543538723767528991906038383446820702565624708556443997649629495841259671527437077527127938789704415913380536996498286764720566639200198900869760387706475703380674649201567096875423075710829719565752777057995176317511826228555593581"}},
           {{"7.04420993592731428016920358636809851304860785603523254394531250e-7", "1.8351438488835314366554030129918828606605529785156250e-1", "7.42999851704960956730922360017793140547106959683768718211070193339741510527923658661871542385815054985958418322575081567325471819065963185600217971978825670497003073742499873659741487280818814513977323524960437583297927902838999554519027556228317521167236540123085211060151247184818776639943050911394e-2"}},
           {{"1.364533448228305205702781677246093750e5", "3.64161706602405751964646185570018133148550987243652343750e-3", "1.04399795038635921897857958256316651977445152567453727222518284598769789391999595233661749274120961391885225992798836625746470159354169324537076101684572935560321844745400772917299981122731280255675880379891143456808614768985468915540339803333726839718219814716863124296189939533443325484535601906033"}},
           {{"2.96565824250737205147743225097656250e3", "2.516110448737411964259536034660413861274719238281250e-1", "7.47522068392867838732450708572135930567101005550555468267204809080882851453167258980507378379243415338266777301093835073449659828508711197010120745211201439735694186362327003324753635700543968787946652069972776477402704033680932298818937199049452926851734709666219333409709557278942834445272506685923"}},
           {{"3.49571885007329983636736869812011718750e4", "4.0503044287507061760322812915546819567680358886718750e-4", "1.00424637003637001346519445137047903985527298734444205998841513031143713650570988838061609722582515075163633719319500702266902153041674931227041528924269656845803454259997891649918404783522081199789884938037449889035577760958358376931686006190221056227385652828889051574541455553647177469994824093880"}},
           {{"3.48704350707848789170384407043457031250e2", "5.94470451369696548105103772741131251677870750427246093750e-4", "1.00348622623956426654419790365515385008204532308719120294458056691444071691627567637464093877906643804041743573926720499607391861016395825332249134843376717727039444569339034648222083969616342813466476442089528251404075917497087087133158228565604726619218594367232783173627524996497743616209681950686"}},
           {{"1.568663540524837252121415076544508337974548339843750e-1", "2.923824443941481013298222535468084970489144325256347656250e-4", "9.99458548775941655985641049562781270043468152203580071617312952591624765716886645437516907451083025631663787001723138256606416990037410952933773901687094742927210507959414283830075225958048767485241813607677989510714884949211624158456814965576504829085206941026015695802504061055800475236320588403791e-1"}},
           {{"3.02555496695998127343329997529508545994758605957031250e-2", "7.43476200926107111399687710218131542205810546875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.07162439112148019358772224877510168973399161717373536875684406796915754460308189843582561832996734392043166689610197386058626738901780367190433337506557349349095623450517180395264699151519926104197461968535179024894054340573408793813826035189319052898390671701445304365679647915192850527101155372317e-12"}},
           {{"1.1330105736971599981188774108886718750e4", "1.63391498739915612750661644270167016657069325447082519531250e-4", "1.00152645922689671305334533143447522531808487470636607472600090062282095427316474560067944838274073843864628772883486893974636361201579261003896147984190781801313303984627253458134496161410984325183430174864002871499528387099093919980953756534711057395376377803880481128200568335684903772454493560544"}},
           {{"2.0028908021549927070736885070800781250e4", "8.6391933296204024372855201363563537597656250e2", "1.92699766759603617897105296135509926340232009672802063778499835631207758035200425882438232730073541633716557508264570905405926283429555595877466543065569320408150504538307810614249593452939955155496934950121411097262064539453295031460705244148452908856502571794692573823194011760644101511653087442625e3716"}},
           {{"1.32507839540064445080225219442127126967534422874450683593750e-4", "1.518878628834884239040547981858253479003906250e2", "1.03647722584318600030967144335207527953463651392633257231597431308252840118498779108498324584815641015064709374407448575779770810144009458027431983385495055750280990347720737478088901276233575808268895728220588756650828610378844764861577519796740508015409537773234457412772265295624580311112182954835e-589"}},
           {{"3.5760343141490902318935241055442020297050476074218750e-2", "5.25925527701659852259155614184749083506176248192787170410156250e-6", "9.99982482017295343923291140868824543861889706024267738325920940955163642168596277387382324596268313941030962899361898533933991225186157467591500415565798572470081783136017764613428509329263882432996891459823007909353566621634663513526224023265569627278594547455316883257611223218894909706813593928661e-1"}},
           {{"6.37895215316995745524764060974121093750e3", "1.3360686442100041778149877025327896262751892209053039550781250e-5", "1.00011705660623425091805720617137318115223118739797033368829524572193511821979599497313069101487866374165387923697805554918674050522785359139471078208862147954503878603840716656103170817064574728416607854591674468869938491395161398773239010400175784333016262331344116781579064223044329496394945074676"}},
           {{"7.381043432400802295489938842365518212318420410156250e-2", "2.785260961407158135936038001467807134758913889527320861816406250e-6", "9.99992740925564330652806516420746938988010148239633275154076421571630454719695668630175026322867662102076692387029189869547293172340508820534949790931051258505036554857756821592275590340005422029182367955076901146714768419205676755504470790282646601620852828276821380880075367804416790635127471984294e-1"}},
           {{"2.2460666646297293482348322868347167968750e4", "3.5622485300151595311035634949803352355957031250e1", "1.01973918494886267810001894567464669163247766970377570638787946610322435627850446066260492108701967988500602281478606685233882133420407449502588207373547970434356681888963673609480451591224779378429762251379481389292664486026843607177275521955621777327928762357765933587555111806380884809909558908126e155"}},
           {{"9.008001827101250191809356238081818446516990661621093750e-4", "9.6443272576535524209795369188213953748345375061035156250e-4", "9.93259995118943779913113450886803213157300236441759177808360979990670369813799397673229074691051859756881735508284831070803950318509897851789286938821324800564473083981421925321740139076048924264684734691750703913517330543410997193207195299362629750503027996358069377923999788650279477370768077765657e-1"}},
           {{"9.4182003413893980905413627624511718750e4", "7.774193002886642601045527611880459062376758083701133728027343750e-7", "1.00000890381075384949081595209139696411199492416870417459364082687864113657489926105641478106668362778068330268736600393352152923274282322515415108939987073582719187381060734722668227714154297709452559911296248629890116220184188866083605360898785001127921221360852853375996265543887873427220880943937"}},
           {{"3.7369273199951797900797423324092960683628916740417480468750e-5", "5.54122149350758519403825630433857440948486328125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.92632813942166735469252865298175146289395053013193471532530902730842579927583105349449489218906918310069151271847219223504300355763614013961247019308729802033635205970100220700085021558381217246935232153985446384879850169504304149149649141113162707552300166988589633450196697040655835196191118606631e-25"}},
           {{"1.3620738122341888645672192126312438631430268287658691406250e-4", "2.62468618182947011518990620970726013183593750e2", "2.23349312978912488484797519539255018773821880984944037182332190114599517402131412348320914129812507474815113624208263309735483442308554370722059051755362465566371079854655405434396337539491832247301779055162543337811300162664812836135792078898777055591459214033387458633919871456241380657515870584905e-1015"}},
           {{"4.9943935269132489338517189025878906250e4", "3.826691408876888544909888878464698791503906250e1", "6.25800762575108176129137940894321369236803059535403474287787709049193999989553876351149791249607106743078893765328229169808063556877194151113548299740103775991789375636892691914854010648529483996498522632062568652379746122433944483375027665116468292026500341138320088041194003298397510386237462266236e179"}},
           {{"6.485392961276647838531062006950378417968750e1", "4.190817698307106042854286442889133468270301818847656250e-3", "1.01763841928646063179945311430619776672100366204545937731495139936077193534063748395270846081233643612207997993464082794803985613863394615181696471224069637239381759785944556677466232970035407360811317566511537057177507901702757204703329800142152099723806486139061978862458791045685416916469263617024"}},
           {{"1.261853587411265742446175863733515143394470214843750e-3", "4.1870787456376986138129048242717544781044125556945800781250e-4", "9.97208954505633083962348848418154736485944843062550245347612203304547965531131555025237286475690843458460809325029245321285039436520603179307117618768371875438665250167675789128497710216048233584274468422162333906486838232593986287174975031846178589748114260487176217087771250070897293526267935699686e-1"}},
           {{"4.35488942342848749831318855285644531250e4", "4.98678835531215099763358011841773986816406250e2", "2.28936120581079817550967747499324146341809782859497306106568788729215792440868081012592482836115918565108733027645928062811796100015424546044055914594061783213133483941275372186699846142681689537346156745852091720729474664315028859269079769914368203114147150204153490030106741528606576208240181832379e2313"}},
           {{"9.5207914036902785426264017587527632713317871093750e-1", "1.08107909706786978198955750940513098612427711486816406250e-3", "9.99946912731466247972527890006754510895764819973853843000662583785640845446566388520861934833991540886888853432324685563515222422612660717906957938307798158191679485565611171204322088502967506340693425660800080176478497228519680488062210430869030836704176100634086409155754383655120084467598988079204e-1"}},
           {{"1.0409068401303045448003103956580162048339843750e1", "1.936739214855335831089178100228309631347656250e2", "1.11210338662691592819619664979726597449100163292683513479170961681889868927958630114518483290408310841588879531996056535646660865328863109763975044243074863201932805945130071457158971557983161341534770079019284360491414192422030250649176833692020314068650401152520803465262499102820988511235853988648e197"}},
           {{"1.971498010271299783369158831192180514335632324218750e-1", "5.08739590531112617632913952547824010252952575683593750e-3", "9.91773157361409781701715493663763866515090466561690289420891165770114164193580683686846646130438934752909209919079027125210567061374829822112866779201464446464651026659338435230202216580437945262368984290532688736997482187636274012593325315635831427955296981578931251003363149110123293975764983649974e-1"}},
           {{"2.79971511541740710526937618851661682128906250e2", "5.787218752022283210778574868982104817405343055725097656250e-4", "1.00326623969490901566461359485954800182836515927200276988639325398663724684484176518830065683294723102506600723636309590040090118084917994679575687454329398419185701984750026134555302778342008308134679599723649132979721129657717437355628051914400727321111879908949789141417261266151891576137055521720"}},
           {{"6.471802775221924264315020991489291191101074218750e-2", "3.54396046637904049703138298355042934417724609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "6.11393159288848940315388484390073955173736785149894558116032886653088516351969818186256818732041463123159800744120590173108691581334056179094211775690837141959813271450679799058611736101514220405786918675156348944553549256908731766892776136986705072991002327432436231317606705791658862062772822668961e-5"}},
           {{"4.6847849382473068544641137123107910156250e3", "8.085034584903098675567889586091041564941406250e1", "5.97762155395492793734284548790084346203097684458052431296538227291993735975496781864258983550151454075639982388971649044469779839674940147551147838593024539580668837295332526092577626791361518961708496544368414553255175123291725694241746786254191457634438577633532650001615818789185478534006606741407e296"}},
           {{"1.5439145955192981607417834766238229349255561828613281250e-2", "9.3029150204543831215175941906636580824851989746093750e-3", "9.61942064374907006758472323953419672912600288860094391695046538452658427001421356899386802781741233841276963853691331000772213773371503948038327239870459585412114416103967368390201886001946927622637207918880459451317082626408706757400699845882572764664471363683650469561537447695573432201521718527705e-1"}},
           {{"6.48003875925739691865601344034075736999511718750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.261210824526329004127700450510474183829501271247863769531250e-5", "1.00006094496769763278820872383817879036100529479018908630432836412716347076273911182394224909321200839758060396148281450949863621182268008379068612869939290370399199699187329868380547441347229000962054100848350577521278040241049817698210922858722233509600098748764436396006044192563867258556456726002"}},
           {{"1.02255146268133501052943756803870201110839843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5.8993269109875526301500769932317780330777168273925781250e-3", "1.00013156917767091552599892235129254853484398955770015153844565825349128084659104946293310766324345122756751921898192510410177121820174080396618577123202206891707775599129806431636068338328182197155856712217515198962725685962829886150997851437588418591804207516238583892908865355284748545102405714042"}},
           {{"2.81888129121324254811042919754981994628906250e2", "4.073526023631882098108292211691150441765785217285156250e-3", "1.02324693289074461806065314601130588099455748535483252525100029761881094483032981058215632709470546862166291555062468221229877852679809354657976457141823806639541535849041446001105725715917762334478759524935613974359759936992996718201195710259035985781666122257084622777055529931477121573215140197696"}},
           {{"2.0718540452792653982008741486708913726033642888069152832031250e-5", "5.35292300705978618680092040449380874633789062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "8.48850440195174823298359540121818302112603372945421421598869878434979555804675505735326375593302973038814914197710751833892726619856756218734694899102028024355384042325664532283875944124268902285546831042825514027899847395159917919088321233227951525026080119430650746383889735094027434636578283016912e-26"}},
           {{"4.31935286049695476781606906513388821622356772422790527343750e-5", "2.674460276028911646364547016752055696997558698058128356933593750e-6", "9.99973122517169758868298611393816315674468708382437784046013092517874934197350186005397961789565235843871109955511656116413964407693637441952651815512224774438246717669200447114406421198392169132912944363201879586414171509537947822165122722681222879324770937027844102716000158168894762456660415032672e-1"}},
           {{"5.6072865956525586847219652653073751480405917391180992126464843750e-7", "6.380308531301886202031017902847054301673779264092445373535156250e-7", "9.99990816207746297627000228090032149940299388165914304992280548917955938225443662692605137525666097388080408339273626056667955459490552137971306327684500228508064672496432612203803093818358636762048072433804065084080756285538210846111127149390742779965190790248566867146590543170273767758612958658971e-1"}},
           {{"4.943658727909295636307462906700038729468360543251037597656250e-5", "6.081072865861608534032711759209632873535156250e1", "1.41889634080305711655291544430541860422410170311666966191109605478799772032330347327796646352426019590688459329571978188218768772574725991603534645626444629132445446486278236532522655245444099755490849273965885852698636839519891473821647868673766453693048753250768728056307822453273785810806442880557e-262"}},
           {{"4.578630412410618737339973449707031250e5", "1.279961392849584456143929855898022651672363281250e1", "2.85252911535679891073378835901479886089967576299789401385670015780551662533990060451545346245206661914640102653229509656129118798311517873586006356564037704026911300448200277564257378774264510533411693099418541902845247573044373703549276907520323049567611007543654341177174512295005876331502328496351e72"}},
           {{"2.08423524510303792567356140352785587310791015625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.35070210371325316600632504560053348541259765625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.69650994818884808551478851790421398330849110943521821889862054443832715742450095948994740658527477301306542925058870703929885411081233767845292798598894899925369153906803097693018622562446710881324699679389099964263723003154543262693904642747226514772235244787350437914151428906711221635213885798789"}},
           {{"7.0350735533994179782268929557176306843757629394531250e-2", "8.66736311094788106856867671012878417968750e2", "7.68909935340978860422757035820741960584342288164122209394216788923406587897458745269054408633969378408300698489680800368145152233150125878615072546588959342193206959268161227822392820692595901101440058139059566058188384350410226233241151749648406111214064140648607944967440645591239738930953785109368e-1000"}},
           {{"4.44777561798017704859375953674316406250e4", "4.37314005329937316446375916711986064910888671875000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.12314549862845492717877595964768115546325186339715764453604920761210996544623734651949041265076846799054130789000520895961692269440989421981634150513113011053879079524507516981642085862682964932699084859566571367826867471772759871670601934760070910316789800074922999274803369631048113774053097073929e20"}},
           {{"4.78949184649386006640270352363586425781250e3", "1.791833511743041071895277127623558044433593750e2", "2.79637132177375382162263956935980813855595791264327736518378404210637984016731507340572257630052502643907564502937056932274446805895054500000116906646009851736492937513833076602489625307279653461589071484812740516746714953908730424736460829219077432204380475346934742691432944334479643432469277088306e659"}},
           {{"6.22325830215437599690631031990051269531250e3", "2.25225952793516384642380501190928043797612190246582031250e-3", "1.01987069469372759270453628912642728954230513534833089604954661995171725801656380902963421144934906141234552439696120736550210382743489449329697576830407056888118360526079463661066722214220114165138840831176499526985462507289995825151030297233511088604059436353741508088143154130210563278515547311543"}},
           {{"9.1240044070163778613946625739572482416406273841857910156250e-5", "2.34400553054916376341521022652614192338660359382629394531250e-4", "9.97821977486950583166084719161557689663568325790003522306021158417755185644936647878316368235185593329253132043532554677812935724747863173935255764658313396824835230126055857216828346612262350441572667853382236006603976105644273478945602579828808105896550462847104108659412377316272488653010471184196e-1"}},
           {{"1.33795627811531119277788093313574790954589843750e1", "1.4818381285251529879158291502783129089948488399386405944824218750e-6", "1.00000384349299045776862801360403732363545774843774701655200272080627739941386437175886379606902727479191090187794979610761904053274682140855025508483613322969568848488035529156236560186742600966591613965074184599845133474883618868818832890976311295886503114503738779326119140373893527826165039256344"}},
           {{"7.0693904131002636859193444252014160156250e3", "7.520701131772273129172390326857566833496093750e1", "3.16601617096668251300410633861451144300904853213668949893514704576723535839139585890152639279492333481781656085682222252609689619088940700517823681224990153082715763605916833922234577262387169239662906567674441665483003247288718595609022710170750805174093013421029787059183231600348513197446175716344e289"}},
           {{"1.4680947481997885795124147989554330706596374511718750e-1", "6.551502580580362278261929986911127343773841857910156250e-3", "9.87508829078291473496350060709599928627355203095913409392108636898471105714839831302147923025254259824329731513966469918955762532776229610929533035120642195606951641982085398951090528368050382553009140996960228822308531093162518295270230167711636888797942089811261515649759631850124542086583338696866e-1"}},
           {{"2.13403424835757107302924850955605506896972656250e1", "6.748819597020269678289139392290962859988212585449218750e-3", "1.02087023232278898673025082821180943357336233310089987611387411667231521549575677239762600896132782138671932320359043850059141855317509884880628897347559802452573752440941620827448739200875424446592178873469737214134752340014718109265906882735838254335143242217171430272779729156476847140495477447567"}},
           {{"7.9523384475269076610004503891104832291603088378906250e-3", "2.848516784813468483150700194528326392173767089843750e-1", "2.52320441273088937482705455163451804728010853035570734024869989669472225400000323970014547943529070869582874785761555559916107563529628329435884632549334664560080647778917243975126257892837384804686623525333256233581024540617818741704180357848449262419278792476592443919338009722004675820379508226554e-1"}},
           {{"4.86469155616132400629658683044453937327489256858825683593750e-5", "5.2287743444463866127058793153992155566811561584472656250e-3", "9.49398596693121402232511551773946216238940594887656584112333721649128338309222255715733045830942439483758414668436262063880698192055748811167639524982228502529443333539688201437948685066022343441584667892362197265423697997073104183476242310932155094648160217817878533689247152065556146288540676206268e-1"}},
           {{"9.97061023610679164619341463549062609672546386718750e-2", "5.8806435521089213125378591939806938171386718750e1", "1.31339250305317586137103280435203540286641209041963686984564977317675267872546421630007855518104235103746292194256810045376453068069833982650717834727768128915903290190711155087191155109113681049655966851631090461344965018352997694452739029417934674832819743056725077543693812469593253205921308221308e-59"}},
           {{"9.250672288777586627084303927404107525944709777832031250e-3", "6.580410957004390049007724883267655968666076660156250e-2", "7.3479441170322764076883455903714667808123745049715180864128469285725740507392126144584630714483987624811982136825764300996419478406647597069868650694836325508907243957328574154916156467594981153576656803869050960269309839419957622805799157028500973756402769602128058256241358541254395091132685326210e-1"}},
           {{"1.2714451115926221973495557904243469238281250e3", "6.1883631944992800733018611936131492257118225097656250e-2", "1.55634262177085310455272777009125596103461766420555774353254576944288801886851836915203973701385795773437574206488784269131348804974222211728133676956373754063980028710578189114584286886146802067657659439377822750677886486205610448378645450751753499248735236114037268909383185086028320044219137753422"}},
           {{"1.422058718410514757124474272131919860839843750e2", "2.49175822061007323782177991233766078948974609375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.31499443769464065089935605375459683035642863575091614297392875457512297919442473147075015935528487370816930373009973708163470195938036050657595355692444453780282744702410807810566482106290630446087507470829783752836539009991223629616484834464198297022741851935670638283977884632514115384409382379451e5"}},
           {{"1.7983084647168379888171330094337463378906250e2", "5.15740741801222002740900940409574104705825448036193847656250e-5", "1.00026780930725147708425182905646433452420215464014520968261578887024273841780021979940791064143678705875846798937060716374571767664452465951073901977576420551043883735274454852404885141087100496560513919957329201186421887438051030917217421635429456043545707951122601188323754670287140035060211268236"}},
           {{"1.416174937472059980336780427023768424987792968750e1", "8.06659473408631241819755075539433164522051811218261718750e-4", "1.00214037426842670551611147350147052752193345171802567422360034056719592273707967867550926051192650203531759829732673928643729296057128383914827597014066465351929167430158631190618779931772000386360976972135737607634338444086468691888473748375182457345550820744493891034677687786078596412978684852640"}},
           {{"3.036204456962959472021701401445170631632208824157714843750e-4", "1.777555595293553447611145656992448493838310241699218750e-2", "8.65907453809699509460147409829901675941527854788885630333979265214696163822247505595008528776776735251807610239492515526114770917079309768787319965003601255566849812163333057688474056980168539317656182802355025321396669769362336327872219770789870937515083196007462468888621524361865732646086424336453e-1"}},
           {{"1.8815079698449000716209411621093750e4", "1.96075222779542400530772283673286437988281250e2", "1.33268783679377583213014321394305562443708551652324893198731298378098553656636607906131354129802125769805603337990709647117721910862833606977379369954861887407787985331605230823250624512728814254652735899657072127956911865541366861599183456838203731048557393074731179271410020592240238165188774584943e838"}},
           {{"8.89727582886910006720881938235834240913391113281250e-1", "1.041279960771747739589621062350488500669598579406738281250e-3", "9.9987834430235824472224814411122243776265486577981177293571821321821517441659311658576556678112989769575007643432909365063217328716826322973493501036244864951726160136161783061801068077323413577888781728469725649419290963386640028890564993827733767871754809898250945769328951487990853772174957746180e-1"}},
           {{"1.83083205221824460440238624414632795378565788269042968750e-5", "8.5130581526808327907929196953773498535156250e1", "5.08759465190948202575969824985581134108808966132826957045953621966485495100532942367792704772987024490520063202480279983957515910756497430137889290866515761789926914423548570454774810411630371091100113544891279153106437138536746735808516608107152208446229082973737250416694137957514739571766896873306e-404"}},
           {{"3.346653408259039663751391313617489231546642258763313293457031250e-6", "3.7868598858803215989610180258750915527343750e2", "3.52212078787830927194297643296251781134291925779877466674871728836105722487573580131785145484495276918545575844013070305855330551951353365366550132397674036846629030890995284036782751533644901503503905390007269189142085867922573306793968734446410118933272999821289312420310855129959801669881803865858e-2074"}},
           {{"5.3392773503090527415166147151559528083453187718987464904785156250e-7", "6.207661898675727671229399029506623719498747959733009338378906250e-7", "9.99991034310800110010707678195555035460840436574922962233018600570397473321611757701145927433415065972844383465094874922585959664097551124468322387734536918015102243687653110114625528443011692213994065730522520240541725522418247328328568974843758308408263849244150678651666777627782107985602066092068e-1"}},
           {{"2.19994195074324068173154955729842185974121093750e1", "3.06707480325778616969678580517211230471730232238769531250e-3", "1.00952545862365855685219042115608145190455235613268820530406120489310419092421063376518661644406509494089174786391890344365290616699827245940846567812410266752069452669091303167176618868615804832415636793311353407444727299687139263635273616648724056070625009496090575286667611858626054037393426920940"}},
           {{"9.494261316265068537459392850053063739323988556861877441406250e-6", "3.33658593189578134285966370953246951103210449218750e-1", "2.10953513637051167906362488703903898283324995313357160919327331939686921714903739192273840983847338772103005796728222224591772689334463276313863779738778665022741134644128703431090827473653846081611135627094959784765932765625500258444912393296945910143335619574776807349923037475968356403544804516261e-2"}},
           {{"1.58204381201744226359551248606294393539428710937500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "1.699670888752343416014042865036515195242827758193016052246093750e-6", "1.00000077966919198536118506000604021848342587459233214812502825319036185927111842640720441778472762148840769009480654434988580516960635247026640481971290957649218368276357248615028690535272593446475039055115505472342603119011692356413204456935489635677140077206818440909527541341514742179392759484948"}},
           {{"7.89159836081502775182242026552614788670325651764869689941406250e-7", "4.816961061463680380256846547126770019531250e2", "1.94147359401180853490618926342983857830809890106752620847948172427377774972592621604834694930262822082783398795004418901297871494637794539318032606545630879764294273346094400196886499691750495365869112152459387957968585556903274684614177896724684391146995388586545846815713970966406314356957705636188e-2940"}},
           {{"1.289097083842133870348334312438964843750e5", "6.9303987741382092058195496520056622102856636047363281250e-3", "1.08496647090160629262865176257751429047729744058064486558757367783712447981236338124011887293782800275409466363098994983981904989007840757365461380428739706364354348918768376442904733609028311603151255847131247523710764847675936168535507206845244124708518371354311381017836653040028826211975497871572"}},
           {{"1.88979339146257488413205294364161090925335884094238281250e-3", "1.507462797900369366743689170107245445251464843750e1", "8.76918423991144038304021445193438173201942067819279237648900596695575024236585474624026460405210909663314261583560910578839787952809598740673148266220449752385049510413309645447866767727463403580780664879153239139760411591518829772808581212853680494395035365090735562853954119264286528501466090236373e-42"}},
           {{"8.41517212362860789198748534545302391052246093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "3.64690954096749919699504971504211425781250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.36385641555849335879047779054573450503531219143280186506059811952516602814802026798922317458022305556248077861115239238036534162971730930403784483407045473794360984711531633071954017599185535725837014265828161774595330813847033913388549400091383297967089159291617295023155265969142242902513558326176e3"}},
           {{"7.794539153729454028507461771368980407714843750e1", "1.375701859744113164651935221627354621887207031250e1", "1.06022076559461302576262215724290203547920286581395364873074659478022575993646868223512587189711310741927159850526321306597320278985726000202501743927791980296512242522543006053260060771089791556404973296770985910119125940674256012428243689156025466514102435785983398909290409351186888763744330929933e26"}},
           {{"1.53996830801468109712004661560058593750e5", "1.5575394558063157535165998979209689423441886901855468750e-2", "1.20447431374301175187511662239775886280442123057569989101048717965641664163683965122530380365781626549245733448495292659434928101251174655724999866929500920292760069066534315397658186379331270528348085084759405281722204998903474609597521346801285181467380964556686904383585877178604246579963496131145"}},
           {{"1.58292085642406949773430824279785156250e5", "2.39839658341223938009534322191029787063598632812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.95369184630899349835322600435195771430552393938403392920497743251505007693757163085390208500076347439614593692001276141903681987497427879862172599262551403341684739246319058993775975522937386429303489479759146923528741632009619169067978673180741577543638362298805900307916877489621750277562246056785e12"}},
           {{"1.3400796278978785267099738121032714843750e4", "1.930784873528596304326221400060603627935051918029785156250e-3", "1.01851774851557016267678896947673493426952146980838508956199625705868791978344101642179134412654468177801448310465798049263061832294449615311708734175434429497593168411288076223275335865898358255932555661831601275564405349791579099870920484601878548075981946266790952650050188664408833668093366337128"}},
           {{"6.575650904605106461531249806284904479980468750e1", "2.95349579102368409166956553235650062561035156250e1", "4.92883670959819008737323351550818895693909971573197862669756297233542900030950953480711710193053129535412775508169382249001427538228339649766961919628309117712145393012207284297044617755253176225355208718450804357511545954540599873761726532747435308616642768909463909723766874135347528684022648860560e53"}},
           {{"7.73401481707858096115160151384770870208740234375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "2.491481202776960799383232370018959045410156250e2", "2.21022119284238444262099118632640694751857489911985882302778583637174384391251394588072250813144879442061174245455228341031066580984347413608919792407019123272438031870871777573323381609534176617167457318208979616222032754767955294734636001910121462806120247278470491361024670390806812831433737112379e221"}},
           {{"1.109788988632283901134001347088542388519272208213806152343750e-5", "1.3221937740391638271830743178725242614746093750e1", "3.07947867569658321194458380597181231565685445537647073748124994390202466909582021155440785847623999110729024670271166064504654713592331835440877924887265726281088902886492996205474623955394661696347608605548560131153946508949187941058346142181719469523416895370937975489878692955467549849494731965625e-66"}},
           {{"6.01388538493091151515557157836155965924263000488281250e-2", "2.600229311077009085274511224206150927784619852900505065917968750e-6", "9.99992690524283092045041727666257712294170472055655983655789156306985603524706361035867762480294454684826579379760817381252880474747063748101481751389649370586878847928039436815138481244723824252557644191693486953238362877605577315573573222917218930477592061427550313462645068276263623663297863327092e-1"}},
           {{"2.155348014323840710737556491949362680315971374511718750e-2", "4.0581281467163221599037115083774551749229431152343750e-2", "8.55799445393602464144976083125961944702079982479924287374752573999342183140040918969698718557087349720031284500593972794455976395816766982409031253828819168807248785638632014800512514311905184872890032777260194266023572565329278809193542262172193713145497824126566400120337339261082686915643720103934e-1"}},
           // Integer exponents:
           {{"1.250e-01", "0.0e+00", "1.0e+00"}},
           {{"-1.250e-01", "0.0e+00", "1.0e+00"}},
           {{"7.50e-01", "0.0e+00", "1.0e+00"}},
           {{"-7.50e-01", "0.0e+00", "1.0e+00"}},
           {{"1.0e+00", "0.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "0.0e+00", "1.0e+00"}},
           {{"1.250e+00", "0.0e+00", "1.0e+00"}},
           {{"-1.250e+00", "0.0e+00", "1.0e+00"}},
           {{"5.5250e+01", "0.0e+00", "1.0e+00"}},
           {{"-5.5250e+01", "0.0e+00", "1.0e+00"}},
           {{"1.250e-01", "1.0e+00", "1.250e-01"}},
           {{"-1.250e-01", "1.0e+00", "-1.250e-01"}},
           {{"7.50e-01", "1.0e+00", "7.50e-01"}},
           {{"-7.50e-01", "1.0e+00", "-7.50e-01"}},
           {{"1.0e+00", "1.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "1.0e+00", "-1.0e+00"}},
           {{"1.250e+00", "1.0e+00", "1.250e+00"}},
           {{"-1.250e+00", "1.0e+00", "-1.250e+00"}},
           {{"5.5250e+01", "1.0e+00", "5.5250e+01"}},
           {{"-5.5250e+01", "1.0e+00", "-5.5250e+01"}},
           {{"1.250e-01", "2.0e+00", "1.56250e-02"}},
           {{"-1.250e-01", "2.0e+00", "1.56250e-02"}},
           {{"7.50e-01", "2.0e+00", "5.6250e-01"}},
           {{"-7.50e-01", "2.0e+00", "5.6250e-01"}},
           {{"1.0e+00", "2.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "2.0e+00", "1.0e+00"}},
           {{"1.250e+00", "2.0e+00", "1.56250e+00"}},
           {{"-1.250e+00", "2.0e+00", "1.56250e+00"}},
           {{"5.5250e+01", "2.0e+00", "3.05256250e+03"}},
           {{"-5.5250e+01", "2.0e+00", "3.05256250e+03"}},
           {{"1.250e-01", "3.0e+00", "1.9531250e-03"}},
           {{"-1.250e-01", "3.0e+00", "-1.9531250e-03"}},
           {{"7.50e-01", "3.0e+00", "4.218750e-01"}},
           {{"-7.50e-01", "3.0e+00", "-4.218750e-01"}},
           {{"1.0e+00", "3.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "3.0e+00", "-1.0e+00"}},
           {{"1.250e+00", "3.0e+00", "1.9531250e+00"}},
           {{"-1.250e+00", "3.0e+00", "-1.9531250e+00"}},
           {{"5.5250e+01", "3.0e+00", "1.686540781250e+05"}},
           {{"-5.5250e+01", "3.0e+00", "-1.686540781250e+05"}},
           {{"1.250e-01", "4.0e+00", "2.441406250e-04"}},
           {{"-1.250e-01", "4.0e+00", "2.441406250e-04"}},
           {{"7.50e-01", "4.0e+00", "3.16406250e-01"}},
           {{"-7.50e-01", "4.0e+00", "3.16406250e-01"}},
           {{"1.0e+00", "4.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "4.0e+00", "1.0e+00"}},
           {{"1.250e+00", "4.0e+00", "2.441406250e+00"}},
           {{"-1.250e+00", "4.0e+00", "2.441406250e+00"}},
           {{"5.5250e+01", "4.0e+00", "9.318137816406250e+06"}},
           {{"-5.5250e+01", "4.0e+00", "9.318137816406250e+06"}},
           {{"1.250e-01", "5.0e+00", "3.05175781250e-05"}},
           {{"-1.250e-01", "5.0e+00", "-3.05175781250e-05"}},
           {{"7.50e-01", "5.0e+00", "2.3730468750e-01"}},
           {{"-7.50e-01", "5.0e+00", "-2.3730468750e-01"}},
           {{"1.0e+00", "5.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "5.0e+00", "-1.0e+00"}},
           {{"1.250e+00", "5.0e+00", "3.05175781250e+00"}},
           {{"-1.250e+00", "5.0e+00", "-3.05175781250e+00"}},
           {{"5.5250e+01", "5.0e+00", "5.1482711435644531250e+08"}},
           {{"-5.5250e+01", "5.0e+00", "-5.1482711435644531250e+08"}},
           {{"1.250e-01", "6.0e+00", "3.8146972656250e-06"}},
           {{"-1.250e-01", "6.0e+00", "3.8146972656250e-06"}},
           {{"7.50e-01", "6.0e+00", "1.779785156250e-01"}},
           {{"-7.50e-01", "6.0e+00", "1.779785156250e-01"}},
           {{"1.0e+00", "6.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "6.0e+00", "1.0e+00"}},
           {{"1.250e+00", "6.0e+00", "3.8146972656250e+00"}},
           {{"-1.250e+00", "6.0e+00", "3.8146972656250e+00"}},
           {{"5.5250e+01", "6.0e+00", "2.84441980681936035156250e+10"}},
           {{"-5.5250e+01", "6.0e+00", "2.84441980681936035156250e+10"}},
           {{"1.250e-01", "7.0e+00", "4.768371582031250e-07"}},
           {{"-1.250e-01", "7.0e+00", "-4.768371582031250e-07"}},
           {{"7.50e-01", "7.0e+00", "1.33483886718750e-01"}},
           {{"-7.50e-01", "7.0e+00", "-1.33483886718750e-01"}},
           {{"1.0e+00", "7.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "7.0e+00", "-1.0e+00"}},
           {{"1.250e+00", "7.0e+00", "4.768371582031250e+00"}},
           {{"-1.250e+00", "7.0e+00", "-4.768371582031250e+00"}},
           {{"5.5250e+01", "7.0e+00", "1.571541943267696594238281250e+12"}},
           {{"-5.5250e+01", "7.0e+00", "-1.571541943267696594238281250e+12"}},
           {{"1.250e-01", "8.0e+00", "5.96046447753906250e-08"}},
           {{"-1.250e-01", "8.0e+00", "5.96046447753906250e-08"}},
           {{"7.50e-01", "8.0e+00", "1.0011291503906250e-01"}},
           {{"-7.50e-01", "8.0e+00", "1.0011291503906250e-01"}},
           {{"1.0e+00", "8.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "8.0e+00", "1.0e+00"}},
           {{"1.250e+00", "8.0e+00", "5.96046447753906250e+00"}},
           {{"-1.250e+00", "8.0e+00", "5.96046447753906250e+00"}},
           {{"5.5250e+01", "8.0e+00", "8.682769236554023683166503906250e+13"}},
           {{"-5.5250e+01", "8.0e+00", "8.682769236554023683166503906250e+13"}},
           {{"1.250e-01", "9.0e+00", "7.4505805969238281250e-09"}},
           {{"-1.250e-01", "9.0e+00", "-7.4505805969238281250e-09"}},
           {{"7.50e-01", "9.0e+00", "7.50846862792968750e-02"}},
           {{"-7.50e-01", "9.0e+00", "-7.50846862792968750e-02"}},
           {{"1.0e+00", "9.0e+00", "1.0e+00"}},
           {{"-1.0e+00", "9.0e+00", "-1.0e+00"}},
           {{"1.250e+00", "9.0e+00", "7.4505805969238281250e+00"}},
           {{"-1.250e+00", "9.0e+00", "-7.4505805969238281250e+00"}},
           {{"5.5250e+01", "9.0e+00", "4.7972300031960980849494934082031250e+15"}},
           {{"-5.5250e+01", "9.0e+00", "-4.7972300031960980849494934082031250e+15"}},
           {{"1.250e-01", "1.0e+01", "9.313225746154785156250e-10"}},
           {{"-1.250e-01", "1.0e+01", "9.313225746154785156250e-10"}},
           {{"7.50e-01", "1.0e+01", "5.6313514709472656250e-02"}},
           {{"-7.50e-01", "1.0e+01", "5.6313514709472656250e-02"}},
           {{"1.0e+00", "1.0e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.0e+01", "1.0e+00"}},
           {{"1.250e+00", "1.0e+01", "9.313225746154785156250e+00"}},
           {{"-1.250e+00", "1.0e+01", "9.313225746154785156250e+00"}},
           {{"5.5250e+01", "1.0e+01", "2.65046957676584419193459510803222656250e+17"}},
           {{"-5.5250e+01", "1.0e+01", "2.65046957676584419193459510803222656250e+17"}},
           {{"1.250e-01", "1.10e+01", "1.164153218269348144531250e-10"}},
           {{"-1.250e-01", "1.10e+01", "-1.164153218269348144531250e-10"}},
           {{"7.50e-01", "1.10e+01", "4.223513603210449218750e-02"}},
           {{"-7.50e-01", "1.10e+01", "-4.223513603210449218750e-02"}},
           {{"1.0e+00", "1.10e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.10e+01", "-1.0e+00"}},
           {{"1.250e+00", "1.10e+01", "1.164153218269348144531250e+01"}},
           {{"-1.250e+00", "1.10e+01", "-1.164153218269348144531250e+01"}},
           {{"5.5250e+01", "1.10e+01", "1.464384441163128916043863797187805175781250e+19"}},
           {{"-5.5250e+01", "1.10e+01", "-1.464384441163128916043863797187805175781250e+19"}},
           {{"1.250e-01", "1.20e+01", "1.45519152283668518066406250e-11"}},
           {{"-1.250e-01", "1.20e+01", "1.45519152283668518066406250e-11"}},
           {{"7.50e-01", "1.20e+01", "3.16763520240783691406250e-02"}},
           {{"-7.50e-01", "1.20e+01", "3.16763520240783691406250e-02"}},
           {{"1.0e+00", "1.20e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.20e+01", "1.0e+00"}},
           {{"1.250e+00", "1.20e+01", "1.45519152283668518066406250e+01"}},
           {{"-1.250e+00", "1.20e+01", "1.45519152283668518066406250e+01"}},
           {{"5.5250e+01", "1.20e+01", "8.090724037426287261142347479462623596191406250e+20"}},
           {{"-5.5250e+01", "1.20e+01", "8.090724037426287261142347479462623596191406250e+20"}},
           {{"1.250e-01", "1.30e+01", "1.8189894035458564758300781250e-12"}},
           {{"-1.250e-01", "1.30e+01", "-1.8189894035458564758300781250e-12"}},
           {{"7.50e-01", "1.30e+01", "2.3757264018058776855468750e-02"}},
           {{"-7.50e-01", "1.30e+01", "-2.3757264018058776855468750e-02"}},
           {{"1.0e+00", "1.30e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.30e+01", "-1.0e+00"}},
           {{"1.250e+00", "1.30e+01", "1.8189894035458564758300781250e+01"}},
           {{"-1.250e+00", "1.30e+01", "-1.8189894035458564758300781250e+01"}},
           {{"5.5250e+01", "1.30e+01", "4.4701250306780237117811469824030995368957519531250e+22"}},
           {{"-5.5250e+01", "1.30e+01", "-4.4701250306780237117811469824030995368957519531250e+22"}},
           {{"1.250e-01", "1.40e+01", "2.273736754432320594787597656250e-13"}},
           {{"-1.250e-01", "1.40e+01", "2.273736754432320594787597656250e-13"}},
           {{"7.50e-01", "1.40e+01", "1.781794801354408264160156250e-02"}},
           {{"-7.50e-01", "1.40e+01", "1.781794801354408264160156250e-02"}},
           {{"1.0e+00", "1.40e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.40e+01", "1.0e+00"}},
           {{"1.250e+00", "1.40e+01", "2.273736754432320594787597656250e+01"}},
           {{"-1.250e+00", "1.40e+01", "2.273736754432320594787597656250e+01"}},
           {{"5.5250e+01", "1.40e+01", "2.46974407944960810075908370777771249413490295410156250e+24"}},
           {{"-5.5250e+01", "1.40e+01", "2.46974407944960810075908370777771249413490295410156250e+24"}},
           {{"1.250e-01", "1.50e+01", "2.84217094304040074348449707031250e-14"}},
           {{"-1.250e-01", "1.50e+01", "-2.84217094304040074348449707031250e-14"}},
           {{"7.50e-01", "1.50e+01", "1.33634610101580619812011718750e-02"}},
           {{"-7.50e-01", "1.50e+01", "-1.33634610101580619812011718750e-02"}},
           {{"1.0e+00", "1.50e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.50e+01", "-1.0e+00"}},
           {{"1.250e+00", "1.50e+01", "2.84217094304040074348449707031250e+01"}},
           {{"-1.250e+00", "1.50e+01", "-2.84217094304040074348449707031250e+01"}},
           {{"5.5250e+01", "1.50e+01", "1.364533603895908475669393748547186153009533882141113281250e+26"}},
           {{"-5.5250e+01", "1.50e+01", "-1.364533603895908475669393748547186153009533882141113281250e+26"}},
           {{"1.250e-01", "1.60e+01", "3.5527136788005009293556213378906250e-15"}},
           {{"-1.250e-01", "1.60e+01", "3.5527136788005009293556213378906250e-15"}},
           {{"7.50e-01", "1.60e+01", "1.0022595757618546485900878906250e-02"}},
           {{"-7.50e-01", "1.60e+01", "1.0022595757618546485900878906250e-02"}},
           {{"1.0e+00", "1.60e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.60e+01", "1.0e+00"}},
           {{"1.250e+00", "1.60e+01", "3.5527136788005009293556213378906250e+01"}},
           {{"-1.250e+00", "1.60e+01", "3.5527136788005009293556213378906250e+01"}},
           {{"5.5250e+01", "1.60e+01", "7.539048161524894328073400460723203495377674698829650878906250e+27"}},
           {{"-5.5250e+01", "1.60e+01", "7.539048161524894328073400460723203495377674698829650878906250e+27"}},
           {{"1.250e-01", "1.70e+01", "4.440892098500626161694526672363281250e-16"}},
           {{"-1.250e-01", "1.70e+01", "-4.440892098500626161694526672363281250e-16"}},
           {{"7.50e-01", "1.70e+01", "7.51694681821390986442565917968750e-03"}},
           {{"-7.50e-01", "1.70e+01", "-7.51694681821390986442565917968750e-03"}},
           {{"1.0e+00", "1.70e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.70e+01", "-1.0e+00"}},
           {{"1.250e+00", "1.70e+01", "4.440892098500626161694526672363281250e+01"}},
           {{"-1.250e+00", "1.70e+01", "-4.440892098500626161694526672363281250e+01"}},
           {{"5.5250e+01", "1.70e+01", "4.1653241092425041162605537545495699311961652711033821105957031250e+29"}},
           {{"-5.5250e+01", "1.70e+01", "-4.1653241092425041162605537545495699311961652711033821105957031250e+29"}},
           {{"1.250e-01", "1.80e+01", "5.55111512312578270211815834045410156250e-17"}},
           {{"-1.250e-01", "1.80e+01", "5.55111512312578270211815834045410156250e-17"}},
           {{"7.50e-01", "1.80e+01", "5.6377101136604323983192443847656250e-03"}},
           {{"-7.50e-01", "1.80e+01", "5.6377101136604323983192443847656250e-03"}},
           {{"1.0e+00", "1.80e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.80e+01", "1.0e+00"}},
           {{"1.250e+00", "1.80e+01", "5.55111512312578270211815834045410156250e+01"}},
           {{"-1.250e+00", "1.80e+01", "5.55111512312578270211815834045410156250e+01"}},
           {{"5.5250e+01", "1.80e+01", "2.30134157035648352423395594938863738698588131228461861610412597656250e+31"}},
           {{"-5.5250e+01", "1.80e+01", "2.30134157035648352423395594938863738698588131228461861610412597656250e+31"}},
           {{"1.250e-01", "1.90e+01", "6.9388939039072283776476979255676269531250e-18"}},
           {{"-1.250e-01", "1.90e+01", "-6.9388939039072283776476979255676269531250e-18"}},
           {{"7.50e-01", "1.90e+01", "4.228282585245324298739433288574218750e-03"}},
           {{"-7.50e-01", "1.90e+01", "-4.228282585245324298739433288574218750e-03"}},
           {{"1.0e+00", "1.90e+01", "1.0e+00"}},
           {{"-1.0e+00", "1.90e+01", "-1.0e+00"}},
           {{"1.250e+00", "1.90e+01", "6.9388939039072283776476979255676269531250e+01"}},
           {{"-1.250e+00", "1.90e+01", "-6.9388939039072283776476979255676269531250e+01"}},
           {{"5.5250e+01", "1.90e+01", "1.271491217621957147139260662037222156309699425037251785397529602050781250e+33"}},
           {{"-5.5250e+01", "1.90e+01", "-1.271491217621957147139260662037222156309699425037251785397529602050781250e+33"}},
           {{
               "-1",
               "18446744073709551615",
               "-1",
           }},
           {{
               "-1",
               "18446744073709551614",
               "1",
           }},
       }};

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = pow(T(data[k][0]), T(data[k][1]));
      T        e   = relative_error(val, T(data[k][2]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = pow(T(data[k][0]), -T(data[k][1]));
      e   = relative_error(val, T(1 / T(data[k][2])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
   //
   // Special cases come last:
   //
   BOOST_CHECK_EQUAL(pow(T(0), T(0)), 1);
   BOOST_CHECK_EQUAL(pow(T(0), 0), 1);
   BOOST_CHECK_EQUAL(pow(T(0), T(2)), 0);
   BOOST_CHECK_EQUAL(pow(T(0), 2), 0);
   BOOST_CHECK_EQUAL(pow(T(1), T(0)), 1);
   BOOST_CHECK_EQUAL(pow(T(1), 0), 1);
   BOOST_CHECK_EQUAL(pow(T(1), T(2)), 1);
   BOOST_CHECK_EQUAL(pow(T(1), 2), 1);

   if (!boost::multiprecision::is_interval_number<T>::value)
   {
      T bug_case = -1.05 * log((std::numeric_limits<T>::max)()) / log(T(1.01));

      for (unsigned i = 0; i < 100; ++i, bug_case *= 1.05)
      {
         if (std::numeric_limits<T>::has_infinity)
         {
            BOOST_CHECK_EQUAL(pow(T(1.01), bug_case), 0);
         }
         else
         {
            BOOST_CHECK_LE(pow(T(1.01), bug_case), (std::numeric_limits<T>::min)());
         }
      }
   }
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_preserve_all_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else if constexpr (std::numeric_limits<Other>::is_integer)
   {
      return (std::numeric_limits<Other>::max)();
   }
   else
   {
      using std::ldexp;
      return ldexp(Other(1) / 3, 30);
   }
}

template <class T>
unsigned precision_of(const T&)
{
   return std::numeric_limits<T>::min_exponent ? std::numeric_limits<T>::digits10 : 1 + std::numeric_limits<T>::digits10;
}

template <class Backend, boost::multiprecision::expression_template_option ET>
typename std::enable_if<boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<Backend, ET> >::value, unsigned>::type 
   precision_of(const boost::multiprecision::number<Backend, ET>& val)
{
   return val.precision();
}
template <class Backend, boost::multiprecision::expression_template_option ET>
typename std::enable_if<!boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<Backend, ET> >::value &&
    std::numeric_limits<boost::multiprecision::number<Backend, ET>>::is_integer 
   && !std::numeric_limits<boost::multiprecision::number<Backend, ET>>::is_bounded, unsigned>::type 
   precision_of(const boost::multiprecision::number<Backend, ET>& val)
{
   return 1 + boost::multiprecision::detail::digits2_2_10(1 + msb(val) - lsb(val));
}
template <class Backend, boost::multiprecision::expression_template_option ET>
typename std::enable_if<!boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<Backend, ET> >::value &&
    !std::numeric_limits<boost::multiprecision::number<Backend, ET>>::is_integer 
   && std::numeric_limits<boost::multiprecision::number<Backend, ET>>::is_exact, unsigned>::type 
   precision_of(const boost::multiprecision::number<Backend, ET>& val)
{
   return (std::max)(precision_of(numerator(val)), precision_of(denominator(val)));
}

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_all_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   unsigned target_precision;
   if constexpr (std::is_integral_v<Other>)
   {
      if constexpr (std::is_unsigned_v<Other>)
      {
         using backend_t = typename T::backend_type;
         using smallest_unsigned = std::tuple_element_t<0, typename backend_t::unsigned_types>;
         target_precision        = (std::max)(T::thread_default_precision(), (std::max)(precision_of(big_a), precision_of(smallest_unsigned(0))));
      }
      else
      {
         using backend_t = typename T::backend_type;
         using smallest_signed = std::tuple_element_t<0, typename backend_t::signed_types>;
         target_precision        = (std::max)(T::thread_default_precision(), (std::max)(precision_of(big_a), precision_of(smallest_signed(0))));
      }
   }
   else if constexpr (std::is_floating_point_v<Other>)
   {
      using backend_t         = typename T::backend_type;
      using smallest_float = std::tuple_element_t<0, typename backend_t::float_types>;
      target_precision        = (std::max)(T::thread_default_precision(), (std::max)(precision_of(big_a), precision_of(smallest_float(0))));
   }
   else
      target_precision = (std::max)(T::thread_default_precision(), precision_of(big_a));

   T a(big_a);
   // We don't guarentee equivalent decimal precision, only that we can round trip (same number of bits):
   BOOST_CHECK_LE(std::abs((int)a.precision() - (int)target_precision), 2);
   if constexpr(!std::numeric_limits<Other>::is_exact || std::numeric_limits<Other>::is_integer)
   {
      BOOST_CHECK_EQUAL(static_cast<Other>(a), big_a);
   }
   else
   {
      // Other is a rational - we can't round trip!
      T r = static_cast<T>(static_cast<Other>(a));
      if constexpr ((boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_floating_point) && std::is_same_v<T, typename T::value_type>)
      {// doesn't work for intervals:
         BOOST_CHECK_EQUAL(r, a);
      }
   }
   T b(std::move(big_d));
   BOOST_CHECK_LE(std::abs((int)b.precision() - (int)target_precision), 2);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = new_value<T>();
      BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
      a = big_b;
      BOOST_CHECK_LE(std::abs((int)a.precision() - (int)target_precision), 2);
      if constexpr (!std::numeric_limits<Other>::is_exact || std::numeric_limits<Other>::is_integer)
      {
         BOOST_CHECK_EQUAL(static_cast<Other>(a), big_b);
      }
      else
      {
         // Other is a rational - we can't round trip!
         T r = static_cast<T>(static_cast<Other>(a));
         BOOST_CHECK_EQUAL(r, a);
      }
      b = new_value<T>();
      BOOST_CHECK_EQUAL(b.precision(), T::thread_default_precision());
      b = std::move(big_c);
      BOOST_CHECK_LE(std::abs((int)b.precision() - (int)target_precision), 2);
      b = new_value<T>();
      BOOST_CHECK_EQUAL(b.precision(), T::thread_default_precision());

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = new_value<T>();
         BOOST_CHECK_EQUAL(a.precision(), T::thread_default_precision());
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_LE(std::abs((int)cc.precision() - (int)target_precision), 2);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a);
      BOOST_CHECK_LE(std::abs((int)aa.precision() - (int)target_precision), 2);
      aa.assign(big_a, big_b);
      BOOST_CHECK_LE(std::abs((int)aa.precision() - (int)target_precision), 2);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), T::thread_default_precision());
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), T::thread_default_precision());
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      }
   }
}


template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_all_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 100);
   b = new_value<T>();
   BOOST_CHECK_EQUAL(b.precision(), 35);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);

      component_t::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 100);
      T dd(cp1, cp2, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      if constexpr (std::is_assignable_v<T, component_t>)
      {
         aa = cp1;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = std::move(cp1);
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 100);
      bb = new_value<T>();
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      if constexpr (boost::multiprecision::is_compatible_arithmetic_type<component_t, T>::value)
      {
         aa = bb + cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = cp3 * bb;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa += cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa -= cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa *= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa /= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa -= bb * cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   // cpp_dec_float has guard digits which breaks our tests:
   //test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
#if !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#endif
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_preserve_component_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else
      return (std::numeric_limits<Other>::max)();
}

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_component_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   unsigned target_precision;
   if constexpr (std::is_same<Other, typename T::value_type>::value)
      target_precision = Other::thread_default_precision();
   else
      target_precision = T::thread_default_precision();

   T a(big_a);
   BOOST_CHECK_EQUAL(a.precision(), target_precision);
   T b(std::move(big_d));
   BOOST_CHECK_EQUAL(b.precision(), target_precision);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = big_b;
      BOOST_CHECK_EQUAL(a.precision(), target_precision);
      b = std::move(big_c);
      BOOST_CHECK_EQUAL(b.precision(), target_precision);

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_EQUAL(cc.precision(), target_precision);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      aa.assign(big_a);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      aa.assign(big_a, big_b);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      }
   }
}


template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_component_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 100);
   b = new_value<T>();
   BOOST_CHECK_EQUAL(b.precision(), 35);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);

      component_t::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 100);
      T dd(cp1, cp2, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      if constexpr (std::is_assignable_v<T, component_t>)
      {
         aa = cp1;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = std::move(cp1);
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 100);
      bb = new_value<T>();
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      if constexpr (boost::multiprecision::is_compatible_arithmetic_type<component_t, T>::value)
      {
         aa = bb + cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = cp3 * bb;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa += cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa -= cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa *= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa /= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa -= bb * cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_preserve_related_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else
      return (std::numeric_limits<Other>::max)();
}

template <class T, class U>
struct is_related_type : public std::false_type {};

template <>
struct is_related_type<boost::multiprecision::mpf_float, boost::multiprecision::mpf_float_100> : public std::true_type
{};
template <>
struct is_related_type<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>, boost::multiprecision::mpf_float_100> : public std::true_type
{};

#if defined(TEST_MPFR)
template <>
struct is_related_type<boost::multiprecision::mpfr_float, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
template <>
struct is_related_type<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off>, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
#endif
#if defined(TEST_MPFI)
template <>
struct is_related_type<boost::multiprecision::mpfi_float, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
template <>
struct is_related_type<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off>, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
#endif
#if defined(TEST_MPC)
template <>
struct is_related_type<boost::multiprecision::mpc_complex, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
template <>
struct is_related_type<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off>, boost::multiprecision::mpfr_float_100> : public std::true_type
{};
#endif

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_related_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   unsigned target_precision;
   if constexpr (is_related_type<T, Other>::value)
      target_precision = std::numeric_limits<Other>::digits10;
   else
      target_precision = T::thread_default_precision();

   T a(big_a);
   BOOST_CHECK_EQUAL(a.precision(), target_precision);
   T b(std::move(big_d));
   BOOST_CHECK_EQUAL(b.precision(), target_precision);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = big_b;
      BOOST_CHECK_EQUAL(a.precision(), target_precision);
      b = std::move(big_c);
      BOOST_CHECK_EQUAL(b.precision(), target_precision);

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_EQUAL(cc.precision(), target_precision);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      aa.assign(big_a, big_b);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), T::thread_default_precision());
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      }
   }
}


template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_related_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 100);
   b = new_value<T>();
   BOOST_CHECK_EQUAL(b.precision(), 35);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);

      component_t::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 100);
      T dd(cp1, cp2, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      if constexpr (std::is_assignable_v<T, component_t>)
      {
         aa = cp1;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = std::move(cp1);
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 100);
      bb = new_value<T>();
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      if constexpr (boost::multiprecision::is_compatible_arithmetic_type<component_t, T>::value)
      {
         aa = bb + cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = cp3 * bb;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa += cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa -= cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa *= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         aa /= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa -= bb * cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 100);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_preserve_source_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else
      return (std::numeric_limits<Other>::max)();
}

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   unsigned target_precision;
   if constexpr (std::is_same<Other, typename T::value_type>::value)
      target_precision = Other::thread_default_precision();
   else
      target_precision = T::thread_default_precision();

   T a(big_a);
   BOOST_CHECK_EQUAL(a.precision(), target_precision);
   T b(std::move(big_d));
   BOOST_CHECK_EQUAL(b.precision(), target_precision);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = big_b;
      BOOST_CHECK_EQUAL(a.precision(), target_precision);
      b = std::move(big_c);
      BOOST_CHECK_EQUAL(b.precision(), target_precision);

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), target_precision);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_EQUAL(cc.precision(), target_precision);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      aa.assign(big_a);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      aa.assign(big_a, big_b);
      BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa = new_value<T>();
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), target_precision);
      }
   }
}


template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 100);
   b = new_value<T>();
   BOOST_CHECK_EQUAL(b.precision(), 35);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 100);
   a = new_value<T>();
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);
      BOOST_CHECK_EQUAL(cp3.precision(), 100);
      BOOST_CHECK_EQUAL(cp4.precision(), 100);

      component_t::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 35);
      T dd(cp1, cp2, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);

      if constexpr (std::is_assignable_v<T, component_t>)
      {
         aa = cp1;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = std::move(cp1);
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      if constexpr (boost::multiprecision::is_compatible_arithmetic_type<component_t, T>::value)
      {
         aa = bb + cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = cp3 * bb;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa += cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = new_value<T>();
         aa -= cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa *= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa = new_value<T>();
         aa /= cp4;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
         aa -= bb * cp3;
         BOOST_CHECK_EQUAL(aa.precision(), 35);
      }
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 100);
      aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   if constexpr (boost::multiprecision::number_category<T>::value == boost::multiprecision::number_kind_complex)
   {
      T aa(1, 2, 75);
      BOOST_CHECK_EQUAL(aa.precision(), 75);
      BOOST_CHECK_EQUAL(aa.real().precision(), 75);
      BOOST_CHECK_EQUAL(aa.imag().precision(), 75);
      BOOST_CHECK_EQUAL(real(aa).precision(), 75);
      BOOST_CHECK_EQUAL(imag(aa).precision(), 75);
      BOOST_CHECK_EQUAL(abs(aa).precision(), 75);
      BOOST_CHECK_EQUAL(arg(aa).precision(), 75);
      BOOST_CHECK_EQUAL(norm(aa).precision(), 75);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_preserve_target_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF) && !defined(TEST_MPFR) && !defined(TEST_MPFI) && !defined(TEST_MPC)
#define TEST_MPF
#define TEST_MPFR
#define TEST_MPFI
#define TEST_MPC

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

#if defined(TEST_MPFR)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI)
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_MPC)
#include <boost/multiprecision/mpc.hpp>
#endif

template <class T>
T new_value()
{
   return T("0.1");
}

template <class Other>
Other make_other_big_value()
{
   if constexpr (std::numeric_limits<Other>::is_integer && !std::numeric_limits<Other>::is_bounded)
      return (Other(1) << 1000) + 1;
   else if constexpr (!std::numeric_limits<Other>::is_integer && std::numeric_limits<Other>::is_exact && (std::numeric_limits<Other>::max_exponent == std::numeric_limits<Other>::min_exponent))
   {
      using value_type = typename Other::value_type;
      return Other(1) / ((value_type(1) << 1000) + 1);
   }
   else
      return (std::numeric_limits<Other>::max)();
}

template <class T, class Other>
void test_mixed()
{
   T::thread_default_precision(10);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_target_precision);
   Other big_a(make_other_big_value<Other>()), big_b(make_other_big_value<Other>()), big_c(make_other_big_value<Other>()), big_d(make_other_big_value<Other>());

   T a(big_a);
   BOOST_CHECK_EQUAL(a.precision(), 10);
   T b(std::move(big_d));
   BOOST_CHECK_EQUAL(a.precision(), 10);
   if constexpr (std::is_assignable_v<T, Other>)
   {
      a = big_b;
      BOOST_CHECK_EQUAL(a.precision(), 10);
      b = std::move(big_c);
      BOOST_CHECK_EQUAL(a.precision(), 10);

      if constexpr (!std::is_assignable_v<Other, T>)
      {
         a = b + big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b * big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b - big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a = b / big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a += big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a -= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a *= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
         a /= big_a;
         BOOST_CHECK_EQUAL(a.precision(), 10);
      }
   }
   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      T cc(big_a, big_b);
      BOOST_CHECK_EQUAL(cc.precision(), 10);
      T dd(big_a, big_b, 55);
      BOOST_CHECK_EQUAL(dd.precision(), 55);
      T aa = new_value<T>();
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a);
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      aa.assign(big_a, big_b);
      BOOST_CHECK_EQUAL(aa.precision(), 10);
      if constexpr (0 && std::is_constructible_v<T, Other, Other, int>)
      {
         aa.assign(big_a, big_b, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
   }
   else
   {
      if constexpr (std::is_constructible_v<T, Other, int>)
      {
         T aa(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
         aa.precision(10);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a, 55);
         BOOST_CHECK_EQUAL(aa.precision(), 55);
      }
      else
      {
         T aa;
         BOOST_CHECK_EQUAL(aa.precision(), 10);
         aa.assign(big_a);
         BOOST_CHECK_EQUAL(aa.precision(), 10);
      }
   }
}

template <class T>
void test()
{
   T::thread_default_precision(100);
   T::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_target_precision);

   T hp1("0.1"), hp2("0.3"), hp3("0.11"), hp4("0.1231");

   BOOST_CHECK_EQUAL(hp1.precision(), 100);
   BOOST_CHECK_EQUAL(hp2.precision(), 100);

   T::thread_default_precision(35);

   T a(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp1;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = std::move(hp1);
   BOOST_CHECK_EQUAL(a.precision(), 35);
   T b(std::move(hp2));
   BOOST_CHECK_EQUAL(b.precision(), 35);

   a = b + hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a = hp3 * b;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a += hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a *= hp4;
   BOOST_CHECK_EQUAL(a.precision(), 35);
   a -= b * hp3;
   BOOST_CHECK_EQUAL(a.precision(), 35);

   if constexpr (!std::is_same_v<T, typename T::value_type>)
   {
      //
      // If we have a component type: ie we are an interval or a complex number, then
      // operations involving the component type should match those of T:
      //
      using component_t = typename T::value_type;
      component_t::thread_default_precision(100);
      component_t::thread_default_variable_precision_options(boost::multiprecision::variable_precision_options::preserve_source_precision);

      component_t cp1("0.1"), cp2("0.3"), cp3("0.11"), cp4("0.1231");

      BOOST_CHECK_EQUAL(cp1.precision(), 100);
      BOOST_CHECK_EQUAL(cp2.precision(), 100);

      T::thread_default_precision(35);

      T aa(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      T cc(cp1, cp2);
      BOOST_CHECK_EQUAL(cc.precision(), 35);
      T dd(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(dd.precision(), 20);
      aa = cp1;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa = std::move(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      T bb(std::move(cp2));
      BOOST_CHECK_EQUAL(bb.precision(), 35);

      aa = bb + cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa = cp3 * bb;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa += cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa -= cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa *= cp4;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa /= cp4;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa -= bb * cp3;
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      
      aa.assign(cp1);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(cp1, cp2, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }
   else
   {
      T aa(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
      aa.precision(35);
      aa.assign(hp4);
      BOOST_CHECK_EQUAL(aa.precision(), 35);
      aa.assign(hp4, 20);
      BOOST_CHECK_EQUAL(aa.precision(), 20);
   }

   test_mixed<T, char>();
   test_mixed<T, unsigned char>();
   test_mixed<T, signed char>();
   test_mixed<T, short>();
   test_mixed<T, unsigned short>();
   test_mixed<T, int>();
   test_mixed<T, unsigned int>();
   test_mixed<T, long>();
   test_mixed<T, unsigned long>();
   test_mixed<T, long long>();
   test_mixed<T, unsigned long long>();
   test_mixed<T, float>();
   test_mixed<T, double>();
   test_mixed<T, long double>();
   //
   // Test with other compatible multiprecision types:
   //
   test_mixed<T, boost::multiprecision::mpz_int>();
   test_mixed<T, boost::multiprecision::cpp_int>();
   test_mixed<T, boost::multiprecision::mpq_rational>();
   test_mixed<T, boost::multiprecision::cpp_rational>();
   test_mixed<T, boost::multiprecision::cpp_bin_float_100>();
   test_mixed<T, boost::multiprecision::cpp_dec_float_100>();
   test_mixed<T, boost::multiprecision::mpf_float_100>();
#if defined(TEST_MPFR) || defined(TEST_MPC) || defined(TEST_MPFI)
   test_mixed<T, boost::multiprecision::mpfr_float_100>();
#endif
}

int main()
{
#ifdef TEST_MPF
   test<boost::multiprecision::mpf_float>();
   test<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>>();
#endif
#ifdef TEST_MPFR
   test<boost::multiprecision::mpfr_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPFI
   test<boost::multiprecision::mpfi_float>();
   test<boost::multiprecision::number<boost::multiprecision::mpfi_float_backend<0>, boost::multiprecision::et_off> >();
#endif
#ifdef TEST_MPC
   test<boost::multiprecision::mpc_complex>();
   test<boost::multiprecision::number<boost::multiprecision::mpc_complex_backend<0>, boost::multiprecision::et_off> >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_rat_float_interconv.cpp
================================================
// Copyright John Maddock 2013.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if defined(TEST1) || defined(TEST2) || defined(TEST3) || defined(TEST4)
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#else
#include <boost/multiprecision/mpfr.hpp>
#endif
#include <boost/math/special_functions/next.hpp>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/chrono.hpp>
#include "test.hpp"
#include <boost/array.hpp>
#include <iostream>
#include <iomanip>

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

template <class Clock>
struct stopwatch
{
   typedef typename Clock::duration duration;
   stopwatch()
   {
      m_start = Clock::now();
   }
   duration elapsed()
   {
      return Clock::now() - m_start;
   }
   void reset()
   {
      m_start = Clock::now();
   }

 private:
   typename Clock::time_point m_start;
};

template <class T>
struct exponent_type
{
   typedef int type;
};
template <class T, boost::multiprecision::expression_template_option ET>
struct exponent_type<boost::multiprecision::number<T, ET> >
{
   typedef typename T::exponent_type type;
};

template <class T>
T generate_random_float()
{
   BOOST_MATH_STD_USING
   typedef typename exponent_type<T>::type e_type;
   static boost::random::mt19937           gen;
   T                                       val      = gen();
   T                                       prev_val = -1;
   while (val != prev_val)
   {
      val *= (gen.max)();
      prev_val = val;
      val += gen();
   }
   e_type e;
   val = frexp(val, &e);

   static const int                                       max_exponent_value = (std::min)(static_cast<int>(std::numeric_limits<T>::max_exponent - std::numeric_limits<T>::digits - 20), 2000);
   static boost::random::uniform_int_distribution<e_type> ui(0, max_exponent_value);
   return ldexp(val, ui(gen));
}

template <class Float, class Rat>
void do_round_trip(const Float& val)
{
   BOOST_MATH_STD_USING
   Rat   rat(val);
   Float new_f(rat);
   BOOST_CHECK_EQUAL(val, new_f);
   //
   // Try adding or subtracting an insignificant amount
   // (0.25ulp) from rat and check that it rounds to the same value:
   //
   typename exponent_type<Float>::type e;
   Float                               t = frexp(val, &e);
   (void)t; // warning suppression
   e -= std::numeric_limits<Float>::digits + 2;
   BOOST_MP_ASSERT(val == (val + ldexp(Float(1), e)));
   Rat                                                               delta, rounded;
   typedef typename boost::multiprecision::component_type<Rat>::type i_type;
   i_type                                                            i(1);
   i <<= (e < 0 ? -e : e);
   if (e > 0)
      delta.assign(i);
   else
      delta = Rat(i_type(1), i);
   rounded = rat + delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);
   rounded = rat - delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);

   delta /= 2;
   rounded = rat + delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);
   rounded = rat - delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);

   delta /= 2;
   rounded = rat + delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);
   rounded = rat - delta;
   new_f   = static_cast<Float>(rounded);
   BOOST_CHECK_EQUAL(val, new_f);
}

template <class Float, class Rat>
void test_round_trip()
{
   std::cout << "Testing types " << typeid(Float).name() << " <<==>> " << typeid(Rat).name() << std::endl;
   std::cout << "digits = " << std::numeric_limits<Float>::digits << std::endl;
   std::cout << "digits10 = " << std::numeric_limits<Float>::digits10 << std::endl;
   std::cout << "max_digits10 = " << std::numeric_limits<Float>::max_digits10 << std::endl;

   stopwatch<boost::chrono::high_resolution_clock> w;

   int count = 0;

#ifndef CI_SUPPRESS_KNOWN_ISSUES
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 200)
#else
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 50)
#endif
   {
      Float val = generate_random_float<Float>();
      do_round_trip<Float, Rat>(val);
      do_round_trip<Float, Rat>(Float(-val));
      do_round_trip<Float, Rat>(Float(1 / val));
      do_round_trip<Float, Rat>(Float(-1 / val));
      count += 4;
      if (boost::detail::test_errors() > 100)
         break;
   }

   std::cout << "Execution time = " << boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() << "s" << std::endl;
   std::cout << "Total values tested: " << count << std::endl;
}

template <class Int>
Int generate_random_int()
{
   static boost::random::mt19937                                                       gen;
   static boost::random::uniform_int_distribution<boost::random::mt19937::result_type> d(1, 20);

   int lim;
   Int cppi(0);

   lim = d(gen);

   for (int i = 0; i < lim; ++i)
   {
      cppi *= (gen.max)();
      cppi += gen();
   }
   return cppi;
}

template <class Float, class Rat>
void test_random_rationals()
{
   std::cout << "Testing types " << typeid(Float).name() << " <<==>> " << typeid(Rat).name() << std::endl;
   std::cout << "digits = " << std::numeric_limits<Float>::digits << std::endl;
   std::cout << "digits10 = " << std::numeric_limits<Float>::digits10 << std::endl;
   std::cout << "max_digits10 = " << std::numeric_limits<Float>::max_digits10 << std::endl;

   typedef typename boost::multiprecision::component_type<Rat>::type i_type;
   stopwatch<boost::chrono::high_resolution_clock>                   w;

   int count = 0;

#ifndef CI_SUPPRESS_KNOWN_ISSUES
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 200)
#else
   while (boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() < 50)
#endif
   {
      Rat   rat(generate_random_int<i_type>(), generate_random_int<i_type>());
      Float f(rat);
      Rat   new_rat(f); // rounded value
      int   c = new_rat.compare(rat);
      if (c < 0)
      {
         // If f was rounded down, next float up must be above the original value:
         f = boost::math::float_next(f);
         new_rat.assign(f);
         BOOST_CHECK(new_rat >= rat);
      }
      else if (c > 0)
      {
         // If f was rounded up, next float down must be below the original value:
         f = boost::math::float_prior(f);
         new_rat.assign(f);
         BOOST_CHECK(new_rat <= rat);
      }
      else
      {
         // Values were equal... nothing to test.
      }
      if (boost::detail::test_errors() > 100)
         break;
   }

   std::cout << "Execution time = " << boost::chrono::duration_cast<boost::chrono::duration<double> >(w.elapsed()).count() << "s" << std::endl;
   std::cout << "Total values tested: " << count << std::endl;
}

#if defined(TEST2)

void double_spot_tests()
{
   boost::multiprecision::cpp_rational rat = 1;
   boost::multiprecision::cpp_rational twiddle(boost::multiprecision::cpp_int(1), boost::multiprecision::cpp_int(boost::multiprecision::cpp_int(1) << 54));
   rat += boost::multiprecision::cpp_rational(boost::multiprecision::cpp_int(1), boost::multiprecision::cpp_int(boost::multiprecision::cpp_int(1) << 50));

   double d = rat.convert_to<double>();

   rat += twiddle;
   BOOST_CHECK_EQUAL(d, rat.convert_to<double>());
   rat += twiddle;
   // tie: round to even rounds down
   BOOST_CHECK_EQUAL(d, rat.convert_to<double>());
   rat += twiddle;
   BOOST_CHECK_NE(d, rat.convert_to<double>());
   rat -= twiddle;
   BOOST_CHECK_EQUAL(d, rat.convert_to<double>());
   rat += boost::multiprecision::cpp_rational(boost::multiprecision::cpp_int(1), boost::multiprecision::cpp_int(boost::multiprecision::cpp_int(1) << 52));
   // tie, but last bit is now a 1 so we round up:
   BOOST_CHECK_NE(d, rat.convert_to<double>());
}

#endif

int main()
{
   using namespace boost::multiprecision;
#if defined(TEST1) && !defined(BOOST_MSVC)
   test_round_trip<number<cpp_bin_float<113, digit_base_2, void, std::int16_t> >, cpp_rational>();
#elif defined(TEST2)
   double_spot_tests();
   test_round_trip<double, cpp_rational>();
#elif defined(TEST3) && !defined(BOOST_MSVC)
   test_random_rationals<number<cpp_bin_float<113, digit_base_2, void, std::int16_t> >, cpp_rational>();
#elif defined(TEST4)
   test_random_rationals<double, cpp_rational>();
#elif defined(TEST5)
   // This does not work: gmp does not correctly round integer to float or
   // rational to float conversions:
   test_round_trip<double, mpq_rational>();
#elif defined(TEST6)
   test_round_trip<mpfr_float_100, mpq_rational>();
#elif defined(TEST7)
   test_random_rationals<mpfr_float_100, mpq_rational>();
#elif defined(TEST8)
   test_random_rationals<double, mpq_rational>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_rational_io.cpp
================================================
// Copyright John Maddock 2011.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_MPQ) && !defined(TEST_TOMMATH) && !defined(TEST_CPP_INT)
#define TEST_MPQ
#define TEST_TOMMATH
#define TEST_CPP_INT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPQ)
#include <boost/multiprecision/gmp.hpp>
#include <boost/multiprecision/rational_adaptor.hpp>
#endif
#if defined(TEST_TOMMATH)
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#endif

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/rational.hpp>
#include "test.hpp"
#include <iostream>
#include <iomanip>

template <class T>
T generate_random()
{
   typedef typename boost::multiprecision::component_type<T>::type int_type;
   static boost::random::uniform_int_distribution<unsigned>        ui(0, 20);
   static boost::random::mt19937                                   gen;
   int_type                                                        val = int_type(gen());
   unsigned                                                        lim = ui(gen);
   for (unsigned i = 0; i < lim; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   int_type denom = int_type(gen());
   lim            = ui(gen);
   for (unsigned i = 0; i < lim; ++i)
   {
      denom *= (gen.max)();
      denom += gen();
   }
   return T(val, denom);
}

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f, const std::integral_constant<bool, true>&)
{
   std::stringstream ss;
   ss << std::setprecision(std::numeric_limits<T>::max_digits10);
   ss.flags(f);
   ss << val;
   T new_val = static_cast<T>(ss.str());
   BOOST_CHECK_EQUAL(new_val, val);
   new_val = static_cast<T>(val.str(0, f));
   BOOST_CHECK_EQUAL(new_val, val);
}

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f, const std::integral_constant<bool, false>&)
{
   std::stringstream ss;
   ss << std::setprecision(std::numeric_limits<T>::digits10 + 4);
   ss.flags(f);
   ss << val;
   T new_val;
   ss >> new_val;
   BOOST_CHECK_EQUAL(new_val, val);
}

template <class T>
struct is_number : public std::integral_constant<bool, false>
{};
template <class T>
struct is_number<boost::multiprecision::number<T> > : public std::integral_constant<bool, true>
{};

template <class T>
void do_round_trip(const T& val, std::ios_base::fmtflags f)
{
   do_round_trip(val, f, is_number<T>());
}

template <class T>
void do_round_trip(const T& val)
{
   do_round_trip(val, std::ios_base::fmtflags(0));
   if (val >= 0)
   {
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::showbase | std::ios_base::hex));
      do_round_trip(val, std::ios_base::fmtflags(std::ios_base::showbase | std::ios_base::oct));
   }
}

template <class T>
void test_round_trip()
{
   for (unsigned i = 0; i < 1000; ++i)
   {
      T val = generate_random<T>();
      do_round_trip(val);
      do_round_trip(T(-val));
   }
}

int main()
{
#ifdef TEST_MPQ
   test_round_trip<boost::multiprecision::mpq_rational>();
   test_round_trip<boost::rational<boost::multiprecision::mpz_int> >();
   test_round_trip<boost::multiprecision::number<boost::multiprecision::rational_adaptor<boost::multiprecision::gmp_int> > >();
#endif
#ifdef TEST_TOMMATH
   test_round_trip<boost::rational<boost::multiprecision::tom_int> >();
   test_round_trip<boost::multiprecision::tom_rational>();
#endif
#ifdef TEST_CPP_INT
   test_round_trip<boost::rational<boost::multiprecision::cpp_int> >();
   test_round_trip<boost::multiprecision::cpp_rational>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_roots_10k_digits.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2021.
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <cmath>

#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/detail/lightweight_test.hpp>
#include "test.hpp"

#if defined(TEST_CPP_DEC_FLOAT)
#include <boost/multiprecision/cpp_dec_float.hpp>
#elif defined(TEST_CPP_BIN_FLOAT)
#include <boost/multiprecision/cpp_bin_float.hpp>
#else
#error ERROR!!: Backend type must be specified as cpp_dec_float or cpp_bin_float
#endif

#if defined(TEST_CPP_DEC_FLOAT)
using big_float_type =
   boost::multiprecision::number<boost::multiprecision::cpp_dec_float<10001, std::int32_t, std::allocator<void>>,
                                 boost::multiprecision::et_off>;
#elif defined(TEST_CPP_BIN_FLOAT)
using big_float_type =
   boost::multiprecision::number<boost::multiprecision::cpp_bin_float<10001>,
                                 boost::multiprecision::et_off>;
#endif

static const std::string str_control_sqrt_pi
{
   // N[Sqrt[Pi], 10003]
   "1."
   "77245385090551602729816748334114518279754945612238712821380778985291128459103218137495065673854466541622682362428257066623615286572442260252509370960278706846203769865310512284992517302895082622893209537926796280017463901535147972051670019018523401858544697449491264031392177552590621640541933250090639840761373347747515343366798978936585183640879545116516173876005906739343179133280985484624818490205465485219561325156164746751504273876105610799612710721006037204448367236529661370809432349883166842"
   "42138457096091204204277857780686947665700052183056851254133966369446541815107166938833219429293570622688652244205421499480499207564863988748385059306402182140292858112330649789452036211490789622873894032459781985131348712665125062932600446563821096750268124969305954204615607619522173915250702077927580990543329006622230676144696612481887430699788352050614644438541853079735742571791856359597499599522638492422038891039664064472939728413450430021405642334330392617561341763363200170376541634763206692"
   "76541812835762490326904508485320134192435989730871193799482938730111262561658818884785977875963761363218634246546641333954355703201522654193952186030497310513829498439659165614245955421226615102478536098095510395600789402188099613382854025016800745802729119366425192820510001936350073914643295493433951928853735459200563766502880540575532123189009126322819150914980836695624483100852221923973646324842863261145766932425371577377894414090544573595351225626391080239236909732127905807617134603914574791"
   "87979412485021844514581134188888041322095533218464670972749102856526270784545326222784880098238583630075495095476406237708338835722543662156748132766838424497242087451616183320507799148018466681423669365190284546385761482785703777438837629747998273770543158368241099868322850380552635536972229313380526442841037231204396700430761245413831179227827536371559839837688453702784298570709051122384053677901338541458531620807304313806973998743669316601381707927205604195488285806309311163629704786781402696"
   "32729627012261359858977545052894831130166840015320748519824024633375558517135680193412289759807195687402505715021417837925436430303659282112509258806189031170745431279039535536606826110011889657420487275939199769955383521150866962555964413705038292449535903106362345305647171162168587254586874400296117579217231905540571986817275884190896496579066965156017283514829038565511698072107953309161308435985243894654406821655003275379960238665037988864815211865799958571865637751133159747535960434137766451"
   "19143460134292508116324806409073773212629335747472967679341271602966512080989809057799660305102181625557978907487076211076238026267854297015027109153504985351492390832484280828987595575678848892608420885521269510357370208661259115541320440373560864338837123962064293902378666311632616788841922798194995240394245784220443030420430420710969273392946085104969289739161855607837870336428902342932718872968029721581659426129728366395905041130374745743509749058016326916537576909810974856253778503428799421"
   "92237718584431832793731298006587036861923010217454505203084553303861950660236433411532059741224264265354216558150036472691946382544124557259473900719227187097960549897246028226024291050774020812375674807627637743706345046314773769480331683570762058749578173350996762873387396702968819066142614457371322822803935444608377601058646738943855776887203971767059273166300903112608144884308624114292247965454026163755158658735198437217550552729506415043576875838149359401055659121503770441973880370568097143"
   "46316360543413650766999757621198118425874225208140436406211723091974394552459677817421914643335067146364622594792319497003496602563521033780660380527031652454546473640620830298273494336728477353020224705290099569815670586403988563683495649528828785196447555742560145992685258185630853805815521997029234802948217957003929547687673787467561474545052585171167541520282662279997703869334225001229773162123949246270758331680646407392937845782141854983327867648187925679501328451126001547882983039709412279"
   "55902739831214814542270184266024781981043333772958400258388865676834533309029610949987493741347827363468214661024873730434936857350647979436639913666636603319139931587665621516162917711861823216570008465885793874989357083653900514427893078319984999817593256144124629695956174126257098794338275338500025352194488355589261749748777846288722492925959751808959292006560416637867369908737627136240495219624777863935793728863172669947043866416226163725769669214230953364155781068802438762255656909570411119"
   "29329419336352138037692136273833819830244199702433009694861871085709025954822085641199104101975680270188980749875221764846725695738526974653312988267258169188864563262749529655208476443369725290231293888886172298365388606288519962105545717369008144991518103776264256672840522144402197474662350151152362302177635204375528607776725412022934171898265399118147904685922433784252070116245217876908741620845115578154869546824111382745732829225060159722322499657545023166289561501837132083717115348063673894"
   "84784931733912365683566355325605210062481299782871796389101124979761290941248031177301331861287374931225016243776603184702614422553084037673001012318502465258727480230169728594169868719593244190651723315464820772603457688308424446360645013191255421752939510434522411080231562909169615412193930561011909418881134283861918284802421983092749258272200999073585007397309735049927566442729112512571291910898288904993996164103611931626599002802954273008381997697092303742727834454911765521727836256287601109"
   "32255166208473363670412549865951932837423711585439714475260616254908137088745696670626628429325335237376819359653018249154079718880795628014895902440140901732999360367466419259926341267462502903084686933106760552768358294991902944382941262207244383387383548710992639420375250818632065102216297040032248061383121651896089049818986478224426012401989866131191974000724370814801426098855240714118230250496450467294859726495929559243052613611357840645183272467390330059195315273771949648585941670957079135"
   "71208139601650594925038121644613819126162372924247652609612531066175456224775667644691793111255733602951238632893409556672518588271987281331623238463434788117754723046679700987197077876381886561795342566290582176594347588749226787782077620870028951701108941253050356669850986454100131214591137167354223024474855215031201885575271538221316878310661190616431479234818598289682964444446955675311396049275406706727731378970529259539526600249211331795365053974029709734540190671438970125900686013617665195"
   "72687973099508055015643127762385528631050133875254380128109439190154705505999016058166069149685688494423898119657391772817914836040519357475938801038970500508903809193141729096407992797218919755568891010603646639884446522998359060486644235315895267693359444400323126004223165102112972082074042502545061418356462067134650264595901028481832509792442369881199067775187248038964466592173037308569206019569002906903553691216483666182982442288272244187675860189834556893273733860435288050615748230733969445"
   "78474186530443308066397549429129132930287814868929519508417573058826618191732980441004823285545754081618814817035570021561095057968747348503333241797516372109425551635208880511652501824782287983124319365126912208588242222571057432428595460772815216094389152993482877724386484010334934164007837418595795609461194089041646498368598284869636334697311192787059989803426741803667268274124973752207354967929168154574421280242660244525949811268984027714993375818153211296815116998257206433839865521131667998"
   "74512421646225811715024003745050832887130969530089731910093749817808392479440994244361969834871331949567903534204867346327056330005149544805112071035184999837985308493647201573304757781804018320982970610322298262945817088234849408510513828178436106441430254484968445676566840061568603570598998353863859883837419232118812833359937727090858195866745019480954611611719835213422118817496211290873149331743041280454519097165935298512044878386738845240577474305934119341688461016838983599740017586415986514"
   "51965095819944262457264453202270514559808838737526755650009008351031467134854677665539462037409247069039645130697247550595241566609004807391855534514872365159293944313924460101335463214967481524634943153469869484903659475912163559450595979781245452991730567329359129587659197544325565931786590196906663660605545155793513382316688065094804799038912675532718180916008233951288936444383999718074935106457889746868054217381258669110448983865029170831101859533263398090772529353443250670518769803568857168"
   "81835780060242683956246672119403771630768027385648763921020087919307224817553753988989799661812800625463458080710413482016553607229817002580132804265299140542713714123053939394621458358275171332093085623946345810925244720567080038158311521284798948447278515121112424067234765368019140869005781922146420504119187767393112983163459560389549526407730300520215721662742451140651602410469652635646458070101544719747869732605487813151166471073804854444267443665951138325602700664792462223823426368037830362"
   "27148019393536469444732501183428218507918036245748038005705684585804838509534865536011973735674935924281652500573775492013522068651524096611313931230523448030488329336880235249613516999100262182701401504389238091694167813318978739897687026397995882771057905474944084757566412920735280686916139219650606013122253782257621358161138006091059023485172621478918566759728124236443373302790962384533760569520986820661689101431363706295375429013500518704424423442146446635034690739595018396356194261104794702"
   "87456163704731907717663415135937863802506788792267061610451079193210848607297617511818706631398952702233269765053328557068418415112262788617649292213008542622876443659388901497338772639102584246387768685926405110265670628494557418283207462950444098917779203101595858810344307567330365427189853237793572718692349471296873907788505052029451976937216634259196159341629632641232237930653691385003947028744939958011043046386152534477079048794401892421173982979396566405475605645350343613825952457743905288"
   "66"
};

static const std::string str_control_pisot
{
   // Consider a fascinating near-integer number with a lot of zeros,
   // a so-called, Pisot number.

   // N[((2/(27 + 3 Sqrt[69]))^(1/3) + (1/3) ((27 + 3 Sqrt[69])/2)^(1/3))^30000, 10003]
   // The exact page at Wolftam Alpha that can calculate this number is:
   // https://www.wolframalpha.com/input/?i=N%5B%28%282%2F%2827+%2B+3+Sqrt%5B69%5D%29%29%5E%281%2F3%29+%2B+%281%2F3%29+%28%2827+%2B+3+Sqrt%5B69%5D%29%2F2%29%5E%281%2F3%29%29%5E30000%2C+10003%5D

   "5."
   "04316596065665493215059469242757481077610274680893503167844467712875718226486210610398076581934068275385782540821330947870035477787176694685987718254576565515786375180403084108087720197360263045377599299252600787464343711547834066265665424226316713797047087646002867659572088255372994141399119295425729390551598734162316493172898778929854821816913956381635362412821599451025319364903651110221515233814364527904893091337135424027258899192161986823235528295581059873200107875550497563219302434498746973"
   "20814894295138750508150895446761509382533298841076293708877836604655306868577285538664595048264681443930199901657433773640659222556791170905179712854907731191277888814410873665970386217401864110691757499520236594196403021789595612659015207824257477907567818590472521187834397950104895326861429034026538474079051464877355002168754758452522250419043608706810782792271044572273623687966932417337841611669591984103046776829649194090438705230027320037702374804434310323316910942614411443802983487519201990"
   "59562790511888049750265002682883521913896858496289686123578807667253851478579344449553914415375194372851217961223158428624231899492121175279814486360858048056575120864817906982359465546791033345570306144306889182376593558188718231183977511187240921162728629126713811608658037408930071516876158725341127622968866605210362611399728215256794224599912431852531227205445323135206226637942724364187507359956181911218068991795777326796261608752343775804668422381361446090681588594231684449905631308569143981"
   "61104641435976464505827310532042357277805504151076128744133166097040034356155594355699310372567007362846011243924380051721179466481515865177147916094265318673753576167289982789156765819918501461470394696987900055057821804367427737785530796529257310070440503552865770656588911341336781719293479609751349965199241672156885820419323697826495675216785846761301665051497508373554704845376808917106579182046296637409148513289873712928793514345917581372183082138176837444493669698475749155502722721819149673"
   "73068945254294933017249747634880287892338097288098981994162698166278766445393167015463543161066099447878202204982468188542002904684676309826229889306798208587300602722354767354500448057391481009249110193387058874499065448114445643788142392205726681802780327973470136681753346929095906271088971584210825489831313413876761278854904865782491262488363942031887926523248561357047739970904671044807781324238352577584241803357451705736527054197950691951908858510985383906254985074673094196111657808386987133"
   "10344086360548451070819222570296482527242703056995074918767257414142822271890334717277643954342541859509907472906259527629621846811719367901786024179895120064929613306517810763374494997293082055502432076618464586027616119815676773736360189991491957175057346133494837930827478266538261093888716461076377076699523221210638410121119502728028192147321213391939138517117401805454360045347532235299958021923292027677884065299422286086252105068056807793476844454728320229479895050738642250650424537785366800"
   "82426933681881662317694955672636170867065177268568641882560696136399378938092363061534206649910677121667830726528065065115430787822086187067816894109743170406015960678013961777060204838325510730464182561678677866776664114588829507728845970964346546857260085067375205588321834061968066477136954754650582659722182787527038013350885360773847158970095196369406644986845955931896822762457057294441289666846719625035790435931009430361335058057283719525424750533492243401220689154316788170873900888499149058"
   "82791350768045506828033944542308221148888187376496354399413641511521268300533409275323047144881568429552172625312395819678941865586820107952918459296302076757812530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
   "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000130894"
   "81144651747951236035489454929072510241720588227917512706315775959573028069494819317749753909502880822522513852251922077408850982456907715693706849952685092996714802140486783196224591724342709356982736044367860439732958936561891275647223613057765646621093148215162220607946164242694428625785134442405595081929385908408997293032313197351343122456184929825694410538985099005649944281269485885003854631983177652291928247833224724739470073685255628874084632409328244867790072740306641208410784729145026418"
   "39979089421596194425472165578935561066171415528986970540137110968042622101039687541512504650792127611653419022003559870999707092195268658469247447023020525845219500954469609653377662845171315396632622078093863467489530686087070384206729526376552079363297449193397802413100986722167407526420829915123927261615512384940124596832534371123301398663197780250502055058559468959359270528574014858166221903008468713118704341049404460009686327493935610433214782810024753045226307991672445787675574109694262312"
   "11145499426482553852623279261922068531320965208068159173874513535948741238646443865707546944537551630947807901099480889585312592101994045117110058723564574602784905031701397065185758292341410282766048237930128673558313294127312232986141003880964672012780620154659135043376705292119911497020913371656546652080631096962434428853407463428964047028385461450774375621283530438935701361719555114064935507016351711366822390479821669249539058602250563907802883915793827509214138670896771346930036795134153954"
   "12614845274332289375572914965666103280434189995736578368489983718312997135507213909760008434894911666727883219968251092951782420006186638047586450238092418753928237145956209661039483486342922895231063933556593966455655337130545768190919525316022134436605220904112976181830667719194987401487083318674802988854162959819380836946082331599524262746254371194008455335100511575399853393989205829635294039833907532465672925195976719223986566158148447432642878876393174990625370999994436703961567355244807342"
   "69520641509898359015919277259612693573103507245475766862906920585023739066501517668430030086321626352865287081845785302216800971241480075909946702545978734966313183497339950198090782159728060732277203943611763413586858764551979183951623117755116853112134485823173566471719295417944467155436759146240378961164970793485454582634507950507263335329774425734366159044434769283194752971059777295937298636851773307465268720002428067710554915705131921586485915706058588546940127798302503433978964008455133493"
   "81377493873988568454747394555631322019995974349284897738681796214043648315850753309356488047165462695097002375464907491747011057687497039054057966902781968701738366805404618496287646992501561538984505139538837143696192930809348816477556056131508918563803091019843961483373516766792142628561297000391741657862041350478818272826493800507083056161770890242060904410455232572423354649059801137081343658420929866819323305436461528792337009143429528398908615401610285467879096995482235819088087170007172084"
   "19200822408181677356654363526604525957125493746470602005173044123902131293500348212963003814048430419681143694193562181860541774246853516513052798389919270163992446463727779357701165620885423995382643338114200119079737025997410561889640258558778992205266673912623015354974700417348049919786128796213631654305377502373403534621197573237204087833472227750274081961941830295476410425392309508980002436399077209866428844044550242714253720047714826171774213541484239371095511846919312369075331533699620236"
   "82029292972878352449179621419103939233902274750203384387435157086116363044339285082959598074623165693670827043027578937417097999903630537953141651179848326672037726918504834056001686619269163272418061895808182857874697372932191591163332075685243434819720224387476770995163639439295727754087687364735109641505765032061100086727178993910597551270640961004749914285104529318068253424299184344438067191184804803834191597230187778600478472083276828758014931933417546242450249754712385119736481807160467673"
   "70904104094257523331122117513138127146204955443643419997609850963761672445279987087328471556603601094954443309436688190549302755292682697985196968743116624708516670254571842252732826810514201166286267256453342635852209107896954083931866292261343402422275337258151166893091264000780411251304831871670820972593920181986511958104229235575222334489531671074281201465449355239054615343692684276140882286660146413938639484415391107647591465166673502924457584083168747424556139933572957677237294159113337504"
   "42E3663"
};

template <class T>
const T& test_control_value_sqrt_pi() { return T(); }

template <>
const big_float_type& test_control_value_sqrt_pi<big_float_type>()
{
  static const big_float_type val(str_control_sqrt_pi);

  return val;
}

template <class T>
const T& test_control_value_pisot() { return T(); }

template <>
const big_float_type& test_control_value_pisot<big_float_type>()
{
  static const big_float_type val(str_control_pisot);

  return val;
}

template <class T>
bool test_sqrt_pi(const T tol = std::numeric_limits<T>::epsilon() * 1000000U)
{
   using std::fabs;
   using std::sqrt;

   const T sqrt_pi = sqrt(boost::math::constants::pi<T>());

   const T closeness = fabs(1 - fabs(sqrt_pi / test_control_value_sqrt_pi<T>()));

   const bool result_is_ok = (closeness < tol);

   return result_is_ok;
}

template <class T>
bool test_pisot(const T tol = std::numeric_limits<T>::epsilon() * 1000000U)
{
   using std::cbrt;
   using std::fabs;
   using std::pow;
   using std::sqrt;

   const T term  = T(27U) + (sqrt(T(69)) * 3U);

   const T pisot = pow(cbrt(2 / term) + (cbrt(term / 2) / 3), 30000U);

   const T closeness = fabs(1 - fabs(pisot / test_control_value_pisot<T>()));

   const bool result_is_ok = (closeness < tol);

   return result_is_ok;
}

template <class T>
bool test_sqrt_pi_modify_one_digit_to_fail(const T tol = std::numeric_limits<T>::epsilon() * 1000000U)
{
   using std::fabs;
   using std::sqrt;

   const T sqrt_pi = sqrt(boost::math::constants::pi<T>());

   std::string str_wrong(str_control_sqrt_pi);

   // We will now purposefully modify the string at position 9502.
   // This is the character '8' at the beginning of the final complete
   // line of the initialization of the string str_control_sqrt_pi.
   if(str_wrong[9502U] == (char) '8')
   {
     str_wrong[9502U] = (char) '9';
   }

   const T control(str_wrong);

   const T closeness = fabs(1 - fabs(sqrt_pi / control));

   // Ensure that the answer is wrong (which is the correct behavior).
   const bool wrong_result_is_ok = (closeness > tol);

   return wrong_result_is_ok;
}

int main()
{
    #if defined(TEST_CPP_DEC_FLOAT)
    const big_float_type local_tol = std::numeric_limits<big_float_type>::epsilon() * 100U;
    #elif defined(TEST_CPP_BIN_FLOAT)
    const big_float_type local_tol = std::numeric_limits<big_float_type>::epsilon() * 1000000U;
    #endif

   {
      const bool result_sqrt_pi_is_ok = test_sqrt_pi<big_float_type>(local_tol);
      BOOST_CHECK_EQUAL(result_sqrt_pi_is_ok, true);
   }

   {
      const bool result_pisot_is_ok = test_pisot<big_float_type>(local_tol);
      BOOST_CHECK_EQUAL(result_pisot_is_ok, true);
   }

   {
      const bool result_sqrt_pi_modify_one_digit_to_fail_is_ok = test_sqrt_pi_modify_one_digit_to_fail<big_float_type>(local_tol);
      BOOST_CHECK_EQUAL(result_sqrt_pi_modify_one_digit_to_fail_is_ok, true);
   }

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_round.cpp
================================================
//  (C) Copyright John Maddock 2007.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/round.hpp>
#include <boost/math/special_functions/trunc.hpp>
#include <boost/math/special_functions/modf.hpp>
#include <boost/math/special_functions/sign.hpp>
#include <boost/random/mersenne_twister.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR_50
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPFI_50
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif

#ifdef BOOST_MSVC
#pragma warning(disable : 4127)
#endif

boost::mt19937 rng;

template <class T>
T get_random()
{
   //
   // Fill all the bits in T with random values,
   // likewise set the exponent to a random value
   // that will still fit inside a T, and always
   // have a remainder as well as an integer part.
   //
   int bits     = boost::math::tools::digits<T>();
   int shift    = 0;
   int exponent = rng() % (bits - 4);
   T   result   = 0;
   while (bits > 0)
   {
      result += ldexp(static_cast<T>(rng()), shift);
      shift += std::numeric_limits<int>::digits;
      bits -= std::numeric_limits<int>::digits;
   }
   return rng() & 1u ? T(-ldexp(frexp(result, &bits), exponent)) : T(ldexp(frexp(result, &bits), exponent));
}

template <class T, class U>
typename std::enable_if<!boost::multiprecision::is_interval_number<T>::value>::type check_within_half(T a, U u)
{
   BOOST_MATH_STD_USING
   if (fabs(a - u) > 0.5f)
   {
      BOOST_ERROR("Rounded result differed by more than 0.5 from the original");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
   if ((fabs(a - u) == 0.5f) && (fabs(static_cast<T>(u)) < fabs(a)))
   {
      BOOST_ERROR("Rounded result was towards zero with boost::round");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
}
template <class T, class U>
typename std::enable_if<boost::multiprecision::is_interval_number<T>::value>::type check_within_half(T a, U u)
{
   BOOST_MATH_STD_USING
   if (upper(T(fabs(a - u))) > 0.5f)
   {
      BOOST_ERROR("Rounded result differed by more than 0.5 from the original");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
   if ((upper(T(fabs(a - u))) == 0.5f) && (fabs(static_cast<T>(u)) < fabs(a)))
   {
      BOOST_ERROR("Rounded result was towards zero with boost::round");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
}

//
// We may not have an abs overload for long long so provide a fall back:
//
inline unsigned safe_abs(int const& v)
{
   return v < 0 ? static_cast<unsigned>(1u) + static_cast<unsigned>(-(v + 1)) : v;
}
inline unsigned long safe_abs(long const& v)
{
   return v < 0 ? static_cast<unsigned long>(1u) + static_cast<unsigned long>(-(v + 1)) : v;
}
inline unsigned long long safe_abs(long long const& v)
{
   return v < 0 ? static_cast<unsigned long long>(1u) + static_cast<unsigned long long>(-(v + 1)) : v;
}
template <class T>
inline typename std::enable_if<!boost::multiprecision::detail::is_integral<T>::value, T>::type safe_abs(T const& v)
{
   return v < 0 ? -v : v;
}

template <class T, class U>
void check_trunc_result(T a, U u)
{
   BOOST_MATH_STD_USING
   if (fabs(a - u) >= 1)
   {
      BOOST_ERROR("Rounded result differed by more than 1 from the original");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
   if (abs(a) < safe_abs(u))
   {
      BOOST_ERROR("Truncated result had larger absolute value than the original");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
   if (fabs(static_cast<T>(u)) > fabs(a))
   {
      BOOST_ERROR("Rounded result was away from zero with boost::trunc");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << u << std::endl;
   }
}

template <class T, class U>
void check_modf_result(T a, T fract, U ipart)
{
   BOOST_MATH_STD_USING
   if (fract + ipart != a)
   {
      BOOST_ERROR("Fractional and integer results do not add up to the original value");
      std::cerr << "Values were: " << std::setprecision(35) << " "
                << std::left << a << ipart << " " << fract << std::endl;
   }
   if ((boost::math::sign(a) != boost::math::sign(fract)) && boost::math::sign(fract))
   {
      BOOST_ERROR("Original and fractional parts have differing signs");
      std::cerr << "Values were: " << std::setprecision(35) << " "
                << std::left << a << ipart << " " << fract << std::endl;
   }
   if ((boost::math::sign(a) != boost::math::sign(ipart)) && boost::math::sign(ipart))
   {
      BOOST_ERROR("Original and integer parts have differing signs");
      std::cerr << "Values were: " << std::setprecision(35) << " "
                << std::left << a << ipart << " " << ipart << std::endl;
   }
   if (fabs(a - ipart) >= 1)
   {
      BOOST_ERROR("Rounded result differed by more than 1 from the original");
      std::cerr << "Values were: " << std::setprecision(35) << std::setw(40)
                << std::left << a << ipart << std::endl;
   }
}

template <class T>
void test()
{
   BOOST_MATH_STD_USING

   for (int i = 0; i < 1000; ++i)
   {
      T arg = get_random<T>();
      T r   = round(arg);
      check_within_half(arg, r);
      BOOST_TEST(r == round(arg + 0));
      r = trunc(arg);
      check_trunc_result(arg, r);
      BOOST_TEST(r == trunc(arg + 0));
      T frac = modf(arg, &r);
      check_modf_result(arg, frac, r);

      if (abs(r) < (std::numeric_limits<int>::max)())
      {
         int i = iround(arg);
         check_within_half(arg, i);
         BOOST_TEST(i == iround(arg + 0));
         i = itrunc(arg);
         check_trunc_result(arg, i);
         BOOST_TEST(i == itrunc(arg + 0));
         r = modf(arg, &i);
         check_modf_result(arg, r, i);
      }
      if (abs(r) < (std::numeric_limits<long>::max)())
      {
         long l = lround(arg);
         check_within_half(arg, l);
         BOOST_TEST(l == lround(arg + 0));
         l = ltrunc(arg);
         check_trunc_result(arg, l);
         BOOST_TEST(l == ltrunc(arg + 0));
         r = modf(arg, &l);
         check_modf_result(arg, r, l);
      }

#ifdef BOOST_HAS_LONG_LONG
      if (abs(r) < (std::numeric_limits<long long>::max)())
      {
         long long ll = llround(arg);
         check_within_half(arg, ll);
         BOOST_TEST(ll == llround(arg + 0));
         ll = lltrunc(arg);
         check_trunc_result(arg, ll);
         BOOST_TEST(ll == lltrunc(arg + 0));
         r = modf(arg, &ll);
         check_modf_result(arg, r, ll);
      }
#endif
   }
   //
   // Test boundary cases:
   //
   if (std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
   {
      int si = iround(static_cast<T>((std::numeric_limits<int>::max)()));
      check_within_half(static_cast<T>((std::numeric_limits<int>::max)()), si);
      BOOST_TEST(si == iround(static_cast<T>((std::numeric_limits<int>::max)()) + 0));
      si = iround(static_cast<T>((std::numeric_limits<int>::min)()));
      check_within_half(static_cast<T>((std::numeric_limits<int>::min)()), si);
      BOOST_TEST(si == iround(static_cast<T>((std::numeric_limits<int>::min)()) + 0));
      si = itrunc(static_cast<T>((std::numeric_limits<int>::max)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<int>::max)()), si);
      BOOST_TEST(si == itrunc(static_cast<T>((std::numeric_limits<int>::max)()) + 0));
      si = itrunc(static_cast<T>((std::numeric_limits<int>::min)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<int>::min)()), si);
      BOOST_TEST(si == itrunc(static_cast<T>((std::numeric_limits<int>::min)()) + 0));

      si = iround(static_cast<T>((std::numeric_limits<int>::max)() - 1));
      check_within_half(static_cast<T>((std::numeric_limits<int>::max)() - 1), si);
      si = iround(static_cast<T>((std::numeric_limits<int>::min)() + 1));
      check_within_half(static_cast<T>((std::numeric_limits<int>::min)() + 1), si);
      si = itrunc(static_cast<T>((std::numeric_limits<int>::max)() - 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<int>::max)() - 1), si);
      si = itrunc(static_cast<T>((std::numeric_limits<int>::min)() + 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<int>::min)() + 1), si);
   }
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
   {
      long k = lround(static_cast<T>((std::numeric_limits<long>::max)()));
      check_within_half(static_cast<T>((std::numeric_limits<long>::max)()), k);
      BOOST_TEST(k == lround(static_cast<T>((std::numeric_limits<long>::max)()) + 0));
      k = lround(static_cast<T>((std::numeric_limits<long>::min)()));
      check_within_half(static_cast<T>((std::numeric_limits<long>::min)()), k);
      BOOST_TEST(k == lround(static_cast<T>((std::numeric_limits<long>::min)()) + 0));
      k = ltrunc(static_cast<T>((std::numeric_limits<long>::max)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<long>::max)()), k);
      BOOST_TEST(k == ltrunc(static_cast<T>((std::numeric_limits<long>::max)()) + 0));
      k = ltrunc(static_cast<T>((std::numeric_limits<long>::min)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<long>::min)()), k);
      BOOST_TEST(k == ltrunc(static_cast<T>((std::numeric_limits<long>::min)()) + 0));

      k = lround(static_cast<T>((std::numeric_limits<long>::max)() - 1));
      check_within_half(static_cast<T>((std::numeric_limits<long>::max)() - 1), k);
      k = lround(static_cast<T>((std::numeric_limits<long>::min)() + 1));
      check_within_half(static_cast<T>((std::numeric_limits<long>::min)() + 1), k);
      k = ltrunc(static_cast<T>((std::numeric_limits<long>::max)() - 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<long>::max)() - 1), k);
      k = ltrunc(static_cast<T>((std::numeric_limits<long>::min)() + 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<long>::min)() + 1), k);
   }
#ifndef BOOST_NO_LONG_LONG
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long long>::digits)
   {
      long long j = llround(static_cast<T>((std::numeric_limits<long long>::max)()));
      check_within_half(static_cast<T>((std::numeric_limits<long long>::max)()), j);
      BOOST_TEST(j == llround(static_cast<T>((std::numeric_limits<long long>::max)()) + 0));
      j = llround(static_cast<T>((std::numeric_limits<long long>::min)()));
      check_within_half(static_cast<T>((std::numeric_limits<long long>::min)()), j);
      BOOST_TEST(j == llround(static_cast<T>((std::numeric_limits<long long>::min)()) + 0));
      j = lltrunc(static_cast<T>((std::numeric_limits<long long>::max)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<long long>::max)()), j);
      BOOST_TEST(j == lltrunc(static_cast<T>((std::numeric_limits<long long>::max)()) + 0));
      j = lltrunc(static_cast<T>((std::numeric_limits<long long>::min)()));
      check_trunc_result(static_cast<T>((std::numeric_limits<long long>::min)()), j);
      BOOST_TEST(j == lltrunc(static_cast<T>((std::numeric_limits<long long>::min)()) + 0));

      j = llround(static_cast<T>((std::numeric_limits<long long>::max)() - 1));
      check_within_half(static_cast<T>((std::numeric_limits<long long>::max)() - 1), j);
      j = llround(static_cast<T>((std::numeric_limits<long long>::min)() + 1));
      check_within_half(static_cast<T>((std::numeric_limits<long long>::min)() + 1), j);
      j = lltrunc(static_cast<T>((std::numeric_limits<long long>::max)() - 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<long long>::max)() - 1), j);
      j = lltrunc(static_cast<T>((std::numeric_limits<long long>::min)() + 1));
      check_trunc_result(static_cast<T>((std::numeric_limits<long long>::min)() + 1), j);
   }
#endif
   //
   // Finish off by testing the error handlers:
   //
   T result;
#ifndef BOOST_NO_EXCEPTIONS
   BOOST_CHECK_THROW(result = static_cast<T>(iround(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(iround(static_cast<T>(-1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(lround(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(lround(static_cast<T>(-1e20))), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
   BOOST_CHECK_THROW(result = static_cast<T>(llround(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(llround(static_cast<T>(-1e20))), boost::math::rounding_error);
#endif
   if (std::numeric_limits<T>::has_infinity)
   {
      BOOST_CHECK_EQUAL(static_cast<T>(round(std::numeric_limits<T>::infinity())), std::numeric_limits<T>::infinity()); // See C99 Annex F.
      BOOST_CHECK_THROW(result = static_cast<T>(iround(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(iround(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lround(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lround(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
      BOOST_CHECK_THROW(result = static_cast<T>(llround(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(llround(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
#endif
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      BOOST_CHECK((boost::multiprecision::isnan)(round(std::numeric_limits<T>::quiet_NaN())));
      BOOST_CHECK_THROW(result = static_cast<T>(iround(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lround(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
      BOOST_CHECK_THROW(result = static_cast<T>(llround(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
#endif
   }
   BOOST_CHECK_THROW(result = static_cast<T>(itrunc(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(itrunc(static_cast<T>(-1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(static_cast<T>(-1e20))), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
   BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(static_cast<T>(1e20))), boost::math::rounding_error);
   BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(static_cast<T>(-1e20))), boost::math::rounding_error);
#endif
   if (std::numeric_limits<T>::has_infinity)
   {
      BOOST_CHECK_EQUAL(static_cast<T>(trunc(std::numeric_limits<T>::infinity())), std::numeric_limits<T>::infinity());
      BOOST_CHECK_EQUAL(static_cast<T>(trunc(-std::numeric_limits<T>::infinity())), -std::numeric_limits<T>::infinity());
      BOOST_CHECK_THROW(result = static_cast<T>(itrunc(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(itrunc(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
      BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(std::numeric_limits<T>::infinity())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(-std::numeric_limits<T>::infinity())), boost::math::rounding_error);
#endif
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      BOOST_CHECK((boost::multiprecision::isnan)(trunc(std::numeric_limits<T>::quiet_NaN())));
      BOOST_CHECK_THROW(result = static_cast<T>(itrunc(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
#ifdef BOOST_HAS_LONG_LONG
      BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(std::numeric_limits<T>::quiet_NaN())), boost::math::rounding_error);
#endif
   }
   if (std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(itrunc(static_cast<T>((std::numeric_limits<int>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(itrunc(static_cast<T>((std::numeric_limits<int>::min)()) - 1)), boost::math::rounding_error);
   }
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(static_cast<T>((std::numeric_limits<long>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(ltrunc(static_cast<T>((std::numeric_limits<long>::min)()) - 1)), boost::math::rounding_error);
   }
#ifndef BOOST_NO_LONG_LONG
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long long>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(static_cast<T>((std::numeric_limits<long long>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lltrunc(static_cast<T>((std::numeric_limits<long long>::min)()) - 1)), boost::math::rounding_error);
   }
#endif
   if (std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(iround(static_cast<T>((std::numeric_limits<int>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(iround(static_cast<T>((std::numeric_limits<int>::min)()) - 1)), boost::math::rounding_error);
   }
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(lround(static_cast<T>((std::numeric_limits<long>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(lround(static_cast<T>((std::numeric_limits<long>::min)()) - 1)), boost::math::rounding_error);
   }
#ifndef BOOST_NO_LONG_LONG
   if (std::numeric_limits<T>::digits >= std::numeric_limits<long long>::digits)
   {
      BOOST_CHECK_THROW(result = static_cast<T>(llround(static_cast<T>((std::numeric_limits<long long>::max)()) + 1)), boost::math::rounding_error);
      BOOST_CHECK_THROW(result = static_cast<T>(llround(static_cast<T>((std::numeric_limits<long long>::min)()) - 1)), boost::math::rounding_error);
   }
#endif
#endif
}

int main()
{
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
#endif
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::cpp_bin_float_100>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_sf_import_c99.cpp
================================================
//  (C) Copyright John Maddock 2016.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifdef _MSC_VER
#pragma warning(disable : 4127) // conditional expression is constant
#endif

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) \
         && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) \
         && !defined(TEST_CPP_DEC_FLOAT_2) && !defined(TEST_CPP_DEC_FLOAT_3) && !defined(TEST_CPP_DEC_FLOAT_4) \
         && !defined(TEST_CPP_DEC_FLOAT_5) && !defined(TEST_CPP_DEC_FLOAT_6) && !defined(TEST_CPP_BIN_FLOAT_2) && !defined(TEST_CPP_BIN_FLOAT_3)\
         && !defined(TEST_MPFI_DEBUG_ADAPTOR) && !defined(TEST_MPFR_DEBUG_ADAPTOR) && !defined(TEST_MPFI_LOGGED_ADAPTOR) && !defined(TEST_MPFR_LOGGED_ADAPTOR)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_CPP_DEC_FLOAT
#define TEST_CPP_DEC_FLOAT_2
#define TEST_CPP_DEC_FLOAT_3
#define TEST_CPP_DEC_FLOAT_4
#define TEST_CPP_DEC_FLOAT_5
#define TEST_CPP_DEC_FLOAT_6
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT
#define TEST_CPP_BIN_FLOAT_2
#define TEST_CPP_BIN_FLOAT_3
#define TEST_MPFI_DEBUG_ADAPTOR
#define TEST_MPFR_DEBUG_ADAPTOR
#define TEST_MPFI_LOGGED_ADAPTOR
#define TEST_MPFR_LOGGED_ADAPTOR

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_MPFR_50
#include <boost/multiprecision/mpfr.hpp>
#endif
#ifdef TEST_MPFI_50
#include <boost/multiprecision/mpfi.hpp>
#endif
#if defined(TEST_CPP_DEC_FLOAT) || defined(TEST_CPP_DEC_FLOAT_2) || defined(TEST_CPP_DEC_FLOAT_3) || defined(TEST_CPP_DEC_FLOAT_4) || defined(TEST_CPP_DEC_FLOAT_5) || defined(TEST_CPP_DEC_FLOAT_6)
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#if defined(TEST_CPP_BIN_FLOAT) || defined(TEST_CPP_BIN_FLOAT_2) || defined(TEST_CPP_BIN_FLOAT_3)
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/debug_adaptor.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_MPFI_DEBUG_ADAPTOR
#  include <boost/multiprecision/mpfi.hpp>
#  include <boost/multiprecision/debug_adaptor.hpp>
#endif
#ifdef TEST_MPFR_DEBUG_ADAPTOR
#  include <boost/multiprecision/mpfr.hpp>
#  include <boost/multiprecision/debug_adaptor.hpp>
#endif
#ifdef TEST_MPFI_LOGGED_ADAPTOR
#  include <boost/multiprecision/mpfi.hpp>
#  include <boost/multiprecision/logged_adaptor.hpp>
#endif
#ifdef TEST_MPFR_LOGGED_ADAPTOR
#  include <boost/multiprecision/mpfr.hpp>
#  include <boost/multiprecision/logged_adaptor.hpp>
#endif

#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include "test.hpp"

#ifdef signbit
#undef signbit
#endif
#ifdef sign
#undef sign
#endif
#ifdef changesign
#undef changesign
#endif
#ifdef copysign
#undef copysign
#endif
#ifdef fpclassify
#undef fpclassify
#endif
#ifdef isinf
#undef isinf
#endif
#ifdef isnan
#undef isnan
#endif
#ifdef isnormal
#undef isnormal
#endif

#ifdef MPFR_VERSION_MAJOR
#define BOOST_MPFR_VERSION MPFR_VERSION_MAJOR * 10000 + MPFR_VERSION_MINOR * 100 + MPFR_VERSION_PATCHLEVEL
#endif

template <class T, class U>
void test_less(T a, U b)
{
   BOOST_CHECK(a < b);
   BOOST_CHECK(a <= b);
   BOOST_CHECK(!(a > b));
   BOOST_CHECK(!(a >= b));
   BOOST_CHECK(!(a == b));
   BOOST_CHECK((a != b));

   BOOST_CHECK(b > a);
   BOOST_CHECK(b >= a);
   BOOST_CHECK(!(b < a));
   BOOST_CHECK(!(b <= a));
   BOOST_CHECK(!(b == a));
   BOOST_CHECK((b != a));

   BOOST_CHECK(isless(a, b));
   BOOST_CHECK(islessequal(a, b));
   BOOST_CHECK(!isgreater(a, b));
   BOOST_CHECK(!isgreaterequal(a, b));
   BOOST_CHECK(islessgreater(a, b));

   BOOST_CHECK(!isless(b, a));
   BOOST_CHECK(!islessequal(b, a));
   BOOST_CHECK(isgreater(b, a));
   BOOST_CHECK(isgreaterequal(b, a));
   BOOST_CHECK(islessgreater(b, a));
}
template <class T, class U>
void test_equal(T a, U b)
{
   BOOST_CHECK(!(a < b));
   BOOST_CHECK(a <= b);
   BOOST_CHECK(!(a > b));
   BOOST_CHECK((a >= b));
   BOOST_CHECK((a == b));
   BOOST_CHECK(!(a != b));

   BOOST_CHECK(!(b > a));
   BOOST_CHECK(b >= a);
   BOOST_CHECK(!(b < a));
   BOOST_CHECK((b <= a));
   BOOST_CHECK((b == a));
   BOOST_CHECK(!(b != a));

   BOOST_CHECK(!isless(a, b));
   BOOST_CHECK(islessequal(a, b));
   BOOST_CHECK(!isgreater(a, b));
   BOOST_CHECK(isgreaterequal(a, b));
   BOOST_CHECK(!islessgreater(a, b));

   BOOST_CHECK(!isless(b, a));
   BOOST_CHECK(islessequal(b, a));
   BOOST_CHECK(!isgreater(b, a));
   BOOST_CHECK(isgreaterequal(b, a));
   BOOST_CHECK(!islessgreater(b, a));
}
template <class T, class U>
void test_unordered(T a, U b)
{
   BOOST_CHECK(!(a < b));
   BOOST_CHECK(!(a <= b));
   BOOST_CHECK(!(a > b));
   BOOST_CHECK(!(a >= b));
   BOOST_CHECK(!(a == b));
   BOOST_CHECK((a != b));

   BOOST_CHECK(!(b > a));
   BOOST_CHECK(!(b >= a));
   BOOST_CHECK(!(b < a));
   BOOST_CHECK(!(b <= a));
   BOOST_CHECK(!(b == a));
   BOOST_CHECK((b != a));

   BOOST_CHECK(!isless(a, b));
   BOOST_CHECK(!islessequal(a, b));
   BOOST_CHECK(!isgreater(a, b));
   BOOST_CHECK(!isgreaterequal(a, b));
   BOOST_CHECK(!islessgreater(a, b));

   BOOST_CHECK(!isless(b, a));
   BOOST_CHECK(!islessequal(b, a));
   BOOST_CHECK(!isgreater(b, a));
   BOOST_CHECK(!isgreaterequal(b, a));
   BOOST_CHECK(!islessgreater(b, a));
}

template <class T>
void test()
{
   //
   // Basic sanity checks for C99 functions which are just imported versions
   // from Boost.Math.  These should still be found via ADL so no using declarations here...
   //
   T val = 2;
   BOOST_CHECK(signbit(val) == 0);
   BOOST_CHECK(signbit(val + 2) == 0);
   val = -val;
   BOOST_CHECK(signbit(val));
   BOOST_CHECK(signbit(val * 2));

   val = 2;
   BOOST_CHECK_EQUAL(sign(val), 1);
   BOOST_CHECK_EQUAL(sign(val + 2), 1);
   val = -val;
   BOOST_CHECK_EQUAL(sign(val), -1);
   BOOST_CHECK_EQUAL(sign(val * 2), -1);
   val = 0;
   BOOST_CHECK_EQUAL(sign(val), 0);
   BOOST_CHECK_EQUAL(sign(val * 2), 0);

   val = 2;
   BOOST_CHECK_EQUAL(changesign(val), -2);
   BOOST_CHECK_EQUAL(changesign(val * 2), -4);
   val = -2;
   BOOST_CHECK_EQUAL(changesign(val), 2);
   BOOST_CHECK_EQUAL(changesign(val * 2), 4);
   val = 0;
   BOOST_CHECK_EQUAL(changesign(val), 0);
   BOOST_CHECK_EQUAL(changesign(val * 2), 0);
   // Things involving signed zero, need to detect it first:
   T neg_zero_test = -(std::numeric_limits<T>::min)();
   neg_zero_test /= (std::numeric_limits<T>::max)();
   T    one(1);
   bool test_signed_zero = !boost::multiprecision::is_interval_number<T>::value && std::numeric_limits<T>::has_infinity && (one / neg_zero_test < 0);
   if (test_signed_zero)
   {
      BOOST_CHECK(signbit(changesign(val)));
      BOOST_CHECK(signbit(changesign(val * 2)));
   }

   T s = 2;
   val = 3;
   BOOST_CHECK_EQUAL(copysign(val, s), 3);
   BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
   BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
   BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
   s = -2;
   BOOST_CHECK_EQUAL(copysign(val, s), -3);
   BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
   BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
   BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
   val = -3;
   BOOST_CHECK_EQUAL(copysign(val, s), -3);
   BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
   BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
   BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
   s = 0;
   BOOST_CHECK_EQUAL(copysign(val, s), 3);
   // Things involving signed zero, need to detect it first:
   if (test_signed_zero)
   {
      BOOST_CHECK_EQUAL(copysign(val, s * -2), -3);
   }
   BOOST_CHECK_EQUAL(copysign(-2 * val, s), 6);
   BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), 6);
   // Things involving signed zero, need to detect it first:
   if (test_signed_zero)
   {
      s = changesign(s);
      if (signbit(s))
      {
         BOOST_CHECK_EQUAL(copysign(val, s), -3);
         BOOST_CHECK_EQUAL(copysign(val, s * -2), 3);
         BOOST_CHECK_EQUAL(copysign(-2 * val, s), -6);
         BOOST_CHECK_EQUAL(copysign(-2 * val, 2 * s), -6);
      }
   }

   val = 3;
   BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
   BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
   BOOST_CHECK(!isinf(val));
   BOOST_CHECK(!isinf(val + 2));
   BOOST_CHECK(!isnan(val));
   BOOST_CHECK(!isnan(val + 2));
   BOOST_CHECK(isnormal(val));
   BOOST_CHECK(isnormal(val + 2));
   val = -3;
   BOOST_CHECK_EQUAL(fpclassify(val), FP_NORMAL);
   BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NORMAL);
   BOOST_CHECK(!isinf(val));
   BOOST_CHECK(!isinf(val + 2));
   BOOST_CHECK(!isnan(val));
   BOOST_CHECK(!isnan(val + 2));
   BOOST_CHECK(isnormal(val));
   BOOST_CHECK(isnormal(val + 2));
   val = 0;
   BOOST_CHECK_EQUAL(fpclassify(val), FP_ZERO);
   BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_ZERO);
   BOOST_CHECK(!isinf(val));
   BOOST_CHECK(!isinf(val + 2));
   BOOST_CHECK(!isnan(val));
   BOOST_CHECK(!isnan(val + 2));
   BOOST_CHECK(!isnormal(val));
   BOOST_CHECK(!isnormal(val * 2));
   BOOST_CHECK(!isnormal(val * -2));
   if (std::numeric_limits<T>::has_infinity)
   {
      val = std::numeric_limits<T>::infinity();
      BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
      BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
      BOOST_CHECK(isinf(val));
      BOOST_CHECK(isinf(val + 2));
      BOOST_CHECK(!isnan(val));
      BOOST_CHECK(!isnan(val + 2));
      BOOST_CHECK(!isnormal(val));
      BOOST_CHECK(!isnormal(val + 2));
      val = -val;
      BOOST_CHECK_EQUAL(fpclassify(val), FP_INFINITE);
      BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_INFINITE);
      BOOST_CHECK(isinf(val));
      BOOST_CHECK(isinf(val + 2));
      BOOST_CHECK(!isnan(val));
      BOOST_CHECK(!isnan(val + 2));
      BOOST_CHECK(!isnormal(val));
      BOOST_CHECK(!isnormal(val + 2));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      val = std::numeric_limits<T>::quiet_NaN();
      BOOST_CHECK_EQUAL(fpclassify(val), FP_NAN);
      BOOST_CHECK_EQUAL(fpclassify(val * 3), FP_NAN);
      BOOST_CHECK(!isinf(val));
      BOOST_CHECK(!isinf(val + 2));
      BOOST_CHECK(isnan(val));
      BOOST_CHECK(isnan(val + 2));
      BOOST_CHECK(!isnormal(val));
      BOOST_CHECK(!isnormal(val + 2));
   }
   s   = 8 * std::numeric_limits<T>::epsilon();
   val = 2.5;
   BOOST_CHECK_CLOSE_FRACTION(asinh(val), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
   BOOST_CHECK_CLOSE_FRACTION(asinh(val + T(0)), T("1.6472311463710957106248586104436196635044144301932365282203100930843983757633104078778420255069424907777006132075516484778755360595913172299093829522950397895699619540523579875476513967578478619028438291006578604823887119907434"), s);
   BOOST_CHECK_CLOSE_FRACTION(acosh(val), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
   BOOST_CHECK_CLOSE_FRACTION(acosh(val + T(0)), T("1.5667992369724110786640568625804834938620823510926588639329459980122148134693922696279968499622201141051039184050936311066453565386393240356562374302417843319480223211857615778787272615171906055455922537080327062362258846337050"), s);
   val = 0.5;
   BOOST_CHECK_CLOSE_FRACTION(atanh(val), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
   BOOST_CHECK_CLOSE_FRACTION(atanh(val + T(0)), T("0.5493061443340548456976226184612628523237452789113747258673471668187471466093044834368078774068660443939850145329789328711840021129652599105264009353836387053015813845916906835896868494221804799518712851583979557605727959588753"), s);
   val = 55.25;
   BOOST_CHECK_CLOSE_FRACTION(cbrt(val), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
   BOOST_CHECK_CLOSE_FRACTION(cbrt(val + T(0)), T("3.8087058015466360309383876359583281382991983919300128125378938779672144843676192684301168479657279498120767424724024965319869248797423276064015643361426189576415670917818313417529572608229017809069355688606687557031643655896118"), s);
   if (!boost::multiprecision::is_interval_number<T>::value)
   {
      val = 2.75;
      BOOST_CHECK_CLOSE_FRACTION(erf(val), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
      BOOST_CHECK_CLOSE_FRACTION(erf(val + T(0)), T("0.9998993780778803631630956080249130432349352621422640655161095794654526422025908961447328296681056892975214344779300734620255391682713519265048496199034963706976420982849598189071465666866369396765001072187538732800143945532487"), s);
      BOOST_CHECK_CLOSE_FRACTION(erfc(val), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
      BOOST_CHECK_CLOSE_FRACTION(erfc(val + T(0)), T("0.0001006219221196368369043919750869567650647378577359344838904205345473577974091038552671703318943107024785655220699265379744608317286480734951503800965036293023579017150401810928534333133630603234998927812461267199856054467512"), s);
   }
   val = 0.125;
   BOOST_CHECK_CLOSE_FRACTION(expm1(val), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);
   BOOST_CHECK_CLOSE_FRACTION(expm1(val + T(0)), T("0.1331484530668263168290072278117938725655031317451816259128200360788235778800483865139399907949417285732315270156473075657048210452584733998785564025916995261162759280700397984729320345630340659469435372721057879969170503978449"), s);

   val = 20;
   s   = 2;
   BOOST_CHECK_EQUAL(fdim(val, s), 18);
   BOOST_CHECK_EQUAL(fdim(s, val), 0);
   BOOST_CHECK_EQUAL(fdim(val, s * 2), 16);
   BOOST_CHECK_EQUAL(fdim(s * 2, val), 0);
   BOOST_CHECK_EQUAL(fdim(val, 2), 18);
   BOOST_CHECK_EQUAL(fdim(2, val), 0);

   BOOST_CHECK_EQUAL(fmax(val, s), val);
   BOOST_CHECK_EQUAL(fmax(s, val), val);
   BOOST_CHECK_EQUAL(fmax(val * 2, s), val * 2);
   BOOST_CHECK_EQUAL(fmax(val, s * 2), val);
   BOOST_CHECK_EQUAL(fmax(val * 2, s * 2), val * 2);
   BOOST_CHECK_EQUAL(fmin(val, s), s);
   BOOST_CHECK_EQUAL(fmin(s, val), s);
   BOOST_CHECK_EQUAL(fmin(val * 2, s), s);
   BOOST_CHECK_EQUAL(fmin(val, s * 2), s * 2);
   BOOST_CHECK_EQUAL(fmin(val * 2, s * 2), s * 2);

   BOOST_CHECK_EQUAL(fmax(val, 2), val);
   BOOST_CHECK_EQUAL(fmax(val, 2.0), val);
   BOOST_CHECK_EQUAL(fmax(20, s), val);
   BOOST_CHECK_EQUAL(fmax(20.0, s), val);
   BOOST_CHECK_EQUAL(fmin(val, 2), s);
   BOOST_CHECK_EQUAL(fmin(val, 2.0), s);
   BOOST_CHECK_EQUAL(fmin(20, s), s);
   BOOST_CHECK_EQUAL(fmin(20.0, s), s);
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<T>::quiet_NaN()), val);
      BOOST_CHECK_EQUAL(fmax(std::numeric_limits<T>::quiet_NaN(), val), val);
      BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<T>::quiet_NaN()), val);
      BOOST_CHECK_EQUAL(fmin(std::numeric_limits<T>::quiet_NaN(), val), val);
   }
   if (std::numeric_limits<double>::has_quiet_NaN)
   {
      BOOST_CHECK_EQUAL(fmax(val, std::numeric_limits<double>::quiet_NaN()), val);
      BOOST_CHECK_EQUAL(fmax(std::numeric_limits<double>::quiet_NaN(), val), val);
      BOOST_CHECK_EQUAL(fmin(val, std::numeric_limits<double>::quiet_NaN()), val);
      BOOST_CHECK_EQUAL(fmin(std::numeric_limits<double>::quiet_NaN(), val), val);
   }

   test_less(s, val);
   test_less(2, val);
   test_less(s, 20);
   test_less(s + 0, val);
   test_less(s, val * 1);
   test_less(s * 1, val * 1);
   test_less(s * 1, 20);
   test_less(s + 2, val * 2);

   test_equal(val, val);
   test_equal(20, val);
   test_equal(val, 20);
   test_equal(val + 0, val);
   test_equal(val, val * 1);
   test_equal(val * 1, val * 1);
   test_equal(val * 1, 20);
   test_equal(val * 20, val * 20);

   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      s = std::numeric_limits<T>::quiet_NaN();
      test_unordered(s, val);
      test_unordered(s, 20);
      test_unordered(s + 0, val);
      test_unordered(s, val * 1);
      test_unordered(s * 1, val * 1);
      test_unordered(s * 1, 20);
      test_unordered(s + 2, val * 2);
      if (std::numeric_limits<double>::has_quiet_NaN)
      {
         double n = std::numeric_limits<double>::quiet_NaN();
         test_unordered(n, val);
      }
   }

   T tol = 8 * std::numeric_limits<T>::epsilon();
   s     = 2;
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(val * 1, 2.0)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(20, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(hypot(20.0, s * 1)), T("20.099751242241780540438529825519152373890046940052754581145656594656982463103940762472355384907904704732599006530"), tol);

   BOOST_CHECK_CLOSE_FRACTION(lgamma(val), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);
   BOOST_CHECK_CLOSE_FRACTION(lgamma(val + 0), T("39.339884187199494036224652394567381081691457206897853119937969989377572554993874476249340525204204720861169039582"), tol);

   BOOST_CHECK_EQUAL(lrint(val), 20);
   BOOST_CHECK_EQUAL(lrint(val * 2), 40);
   BOOST_CHECK_EQUAL(llrint(val), 20);
   BOOST_CHECK_EQUAL(llrint(val * 2), 40);

   val = 0.125;
   BOOST_CHECK_CLOSE_FRACTION(log1p(val), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
   BOOST_CHECK_CLOSE_FRACTION(log1p(val + 0), T("0.117783035656383454538794109470521705068480712564733141107348638794807720528133786929641528638208114949935615070"), tol);
   val = 20;
   BOOST_CHECK_CLOSE_FRACTION(T(log2(val)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(log2(val + 0)), T("4.321928094887362347870319429489390175864831393024580612054756395815934776608625215850139743359370155099657371710"), tol);

   BOOST_CHECK_EQUAL(T(nearbyint(val)), 20);
   BOOST_CHECK_EQUAL(T(nearbyint(val + 0.25)), 20);
   BOOST_CHECK_EQUAL(T(rint(val)), 20);
   BOOST_CHECK_EQUAL(T(rint(val + 0.25)), 20);

   BOOST_CHECK_GT(nextafter(val, T(200)), val);
   BOOST_CHECK_GT(nextafter(val + 0, T(200)), val);
   BOOST_CHECK_GT(nextafter(val + 0, T(200) + 1), val);
   BOOST_CHECK_GT(nextafter(val, T(200) + 1), val);

   BOOST_CHECK_GT(nexttoward(val, T(200)), val);
   BOOST_CHECK_GT(nexttoward(val + 0, T(200)), val);
   BOOST_CHECK_GT(nexttoward(val + 0, T(200) + 1), val);
   BOOST_CHECK_GT(nexttoward(val, T(200) + 1), val);

   val = 21;
   s   = 5;
   BOOST_CHECK_EQUAL(T(remainder(val, s)), 1);
   BOOST_CHECK_EQUAL(T(remainder(val, 5)), 1);
   BOOST_CHECK_EQUAL(T(remainder(21, s)), 1);
   BOOST_CHECK_EQUAL(T(remainder(val * 1, s)), 1);
   BOOST_CHECK_EQUAL(T(remainder(val * 1, s * 1)), 1);
   BOOST_CHECK_EQUAL(T(remainder(val, s * 1)), 1);
   BOOST_CHECK_EQUAL(T(remainder(val * 1, 5)), 1);
   BOOST_CHECK_EQUAL(T(remainder(21, s * 1)), 1);
   int i(0);
   BOOST_CHECK_EQUAL(T(remquo(val, s, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(val, 5, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(21, s, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(val * 1, s, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(val * 1, s * 1, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(val, s * 1, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(val * 1, 5, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i = 0;
   BOOST_CHECK_EQUAL(T(remquo(21, s * 1, &i)), 1);
   BOOST_CHECK_EQUAL(i, 4);
   i   = 0;
   val = 5.25;
   tol = 3000;
   BOOST_CHECK_CLOSE_FRACTION(tgamma(val), T("35.211611852799685705225257690531248115026311138908448314086859575901217653313145619623624570033258659272301335544"), tol);
   BOOST_CHECK_CLOSE_FRACTION(tgamma(val + 1), T("184.86096222719834995243260287528905260388813347926935364895601277348139267989401450302402899267460796117958201160"), tol);

   BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T("38.054627680087074134959999057935229289375106958842157216608071191022933383261349115865003025220405558913196632792"), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T("76.109255360174148269919998115870458578750213917684314433216142382045866766522698231730006050440811117826393265585"), tol);
   val = 15;
   BOOST_CHECK_CLOSE_FRACTION(T(exp2(val)), T(32768uL), tol);
   BOOST_CHECK_CLOSE_FRACTION(T(exp2(val + 1)), T(65536uL), tol);

   i = fpclassify(val) + isgreaterequal(val, s) + islessequal(val, s) + isnan(val) + isunordered(val, s) + isfinite(val) + isinf(val) + islessgreater(val, s) + isnormal(val) + signbit(val) + isgreater(val, s) + isless(val, s);
}

template <class T>
void test_poison()
{
   // use these macros as proxies for determining C99 support:
#if defined(FP_ILOGB0) && defined(FP_INFINITE)
   //
   // These tests verify that our function overloads for Boost.Multiprecision
   // don't do anything nasty to the std:: overloads for built in types:
   //
   using namespace std;
   using namespace boost::multiprecision;
   //using namespace boost::math;

   T   a(2), b(0.3f), c(4), result(0);
   int i;

   result += abs(a);
   result += cosh(a);
   result += fmod(a, b);
   result += logb(a);
   result += remquo(a, b, &i);
   result += acos(b);
   result += erf(a);
   result += frexp(a, &i);
   result += lrint(a);
   result += rint(a);
   result += acosh(b);
   result += erfc(b);
   result += hypot(a, b);
   result += lround(c);
   result += round(c);
   result += asin(b);
   result += exp2(a);
   result += ilogb(b);
   result += modf(a, &b);
   result += scalbln(a, i);
   result += asinh(b);
   result += exp(b);
   result += ldexp(a, i);
   result += scalbn(a, i);
   result += atan(b);
   result += expm1(a);
   result += lgamma(a);
   result += sin(b);
   result += atan2(a, c);
   result += fabs(a);
   result += llrint(a);
   result += sinh(b);
   result += atanh(b);
   result += fdim(a, b);
   result += llround(a);
   result += nearbyint(a);
   result += sqrt(b);
   result += cbrt(a);
   result += floor(b);
   result += log(a);
   result += nextafter(a, b);
   result += tan(b);
   result += ceil(b);
   result += fma(a, b, c);
   result += log10(a);
   result += nexttoward(a, b);
   result += tanh(a);
   result += copysign(a, b);
   result += fmax(a, b);
   result += log1p(a);
   result += pow(a, b);
   result += tgamma(a);
   result += cos(b);
   result += fmin(a, b);
   result += log2(a);
   result += remainder(a, b);
   result += trunc(b);
   result += (min)(a, b);
   result += (max)(a, b);

#if !BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 60000)

   i = fpclassify(a) + isgreaterequal(a, b) + islessequal(a, b) + isnan(a) + isunordered(a, b) + isfinite(a) + isinf(a) + islessgreater(a, b) + isnormal(a) + signbit(a) + isgreater(a, b) + isless(a, b);
#endif
#endif
}

template <class T>
bool type_sets_errno(const T&)
{
   return true;
}
#ifdef TEST_MPFR_50
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType>, ExpressionTemplates>&)
{
   return false;
}
#endif
#ifdef TEST_MPFR_DEBUG_ADAPTOR
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>&)
{
   return false;
}
#endif
#ifdef TEST_MPFI_DEBUG_ADAPTOR
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>&)
{
   return false;
}
#endif
#ifdef TEST_MPFR_LOGGED_ADAPTOR
template <unsigned Digits10, boost::multiprecision::mpfr_allocation_type AllocateType, boost::multiprecision::expression_template_option ExpressionTemplates>
bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<Digits10, AllocateType> >, ExpressionTemplates>&)
{
   return false;
}
#endif
#ifdef TEST_MPFI_LOGGED_ADAPTOR
template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
bool type_sets_errno(const boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<Digits10> >, ExpressionTemplates>&)
{
   return false;
}
#endif
#ifdef TEST_FLOAT128
bool type_sets_errno(const boost::multiprecision::float128&)
{
   return false;
}
#endif

template <class T>
typename std::enable_if<std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
{
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      BOOST_CHECK(isnan(val));
   }
   else
   {
      BOOST_CHECK_EQUAL(val, 0);
   }
   if (type_sets_errno(val))
      BOOST_CHECK_EQUAL(errno, EDOM);
   errno = 0;
}

template <class T>
typename std::enable_if<!std::numeric_limits<T>::is_specialized>::type check_invalid(const T& val)
{
   check_invalid(static_cast<typename T::result_type>(val));
}

template <class T>
void check_erange(const T& val)
{
   if (type_sets_errno(val))
      BOOST_CHECK_EQUAL(errno, ERANGE);
   errno = 0;
}

template <class T>
void test_c99_appendix_F()
{
   //
   // Tests conformance to non-normative appendix F.9.1 of C99, basically how to handle
   // special cases, infinities and NaN's.
   //
   errno = 0;
   T tol = std::numeric_limits<T>::epsilon();
   // F.9.1.1:
   T arg = 1;
   T val = acos(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = 2;
   check_invalid(acos(arg));
   arg = -2;
   check_invalid(acos(arg));
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(acos(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(acos(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(acos(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(acos(arg));
   }
   // F.9.1.2:
   arg = 0;
   val = asin(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = asin(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   arg = 2;
   check_invalid(asin(arg));
   arg = -2;
   check_invalid(asin(arg));
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(asin(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(asin(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(asin(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(asin(arg));
   }
   // F.9.1.3:
   arg = 0;
   val = atan(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = atan(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = atan(arg);
      BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
      arg = -std::numeric_limits<T>::infinity();
      val = atan(arg);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(asin(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(asin(arg));
   }
   // F.9.1.4:
   arg    = 0;
   T arg2 = 0;
   val    = atan2(arg, arg2);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   arg2 = -arg2;
   if (signbit(arg2))
   {
      arg = 0;
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
      BOOST_CHECK(signbit(val) == 0);
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
      BOOST_CHECK(signbit(val));
   }
   arg  = 0;
   arg2 = -2;
   val  = atan2(arg, arg2);
   BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
   arg = -arg;
   if (signbit(arg))
   {
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
   }
   arg  = 0;
   arg2 = 2;
   val  = atan2(arg, arg2);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   arg  = -2;
   arg2 = 0;
   val  = atan2(arg, arg2);
   BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
   arg2 = -arg2;
   if (signbit(arg2))
   {
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
   }
   arg  = 2;
   arg2 = 0;
   val  = atan2(arg, arg2);
   BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
   arg2 = -arg2;
   if (signbit(arg2))
   {
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg  = 2;
      arg2 = -std::numeric_limits<T>::infinity();
      val  = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, boost::math::constants::pi<T>());
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::pi<T>());
      arg  = 2;
      arg2 = std::numeric_limits<T>::infinity();
      val  = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = -arg;
      if (signbit(-T(0)))
      {
         val = atan2(arg, arg2);
         BOOST_CHECK_EQUAL(val, 0);
         BOOST_CHECK(signbit(val));
      }
      arg  = std::numeric_limits<T>::infinity();
      arg2 = 2;
      val  = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
      arg  = std::numeric_limits<T>::infinity();
      arg2 = -2;
      val  = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, boost::math::constants::half_pi<T>());
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_EQUAL(val, -boost::math::constants::half_pi<T>());
      arg  = std::numeric_limits<T>::infinity();
      arg2 = -std::numeric_limits<T>::infinity();
      val  = atan2(arg, arg2);
      BOOST_CHECK_CLOSE_FRACTION(val, boost::math::constants::three_quarters_pi<T>(), tol);
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_CLOSE_FRACTION(val, -boost::math::constants::three_quarters_pi<T>(), tol);
      arg  = std::numeric_limits<T>::infinity();
      arg2 = std::numeric_limits<T>::infinity();
      val  = atan2(arg, arg2);
      BOOST_CHECK_CLOSE_FRACTION(val, ldexp(boost::math::constants::pi<T>(), -2), tol);
      arg = -arg;
      val = atan2(arg, arg2);
      BOOST_CHECK_CLOSE_FRACTION(val, -ldexp(boost::math::constants::pi<T>(), -2), tol);
      if (std::numeric_limits<T>::has_quiet_NaN)
      {
         arg  = std::numeric_limits<T>::quiet_NaN();
         arg2 = 2;
         check_invalid(atan2(arg, arg2));
         std::swap(arg, arg2);
         check_invalid(atan2(arg, arg2));
         arg = std::numeric_limits<T>::quiet_NaN();
         check_invalid(atan2(arg, arg2));
      }
   }
   // F.9.1.5:
   arg = 0;
   val = cos(arg);
   BOOST_CHECK_EQUAL(val, 1);
   arg = -arg;
   BOOST_CHECK_EQUAL(val, 1);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(cos(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(cos(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(cos(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(cos(arg));
   }
   // F.9.1.6:
   arg = 0;
   val = sin(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = sin(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(sin(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(sin(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(sin(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(sin(arg));
   }
   // F.9.1.7:
   arg = 0;
   val = tan(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = tan(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(tan(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(tan(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(tan(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(tan(arg));
   }
   // F.9.2.1:
   arg = 1;
   val = acosh(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   check_invalid(acosh(arg));
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = acosh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());

      arg = -std::numeric_limits<T>::infinity();
      check_invalid(acosh(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(acosh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(acosh(arg));
   }
   // F.9.2.2:
   arg = 0;
   val = asinh(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = asinh(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = asinh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());

      arg = -std::numeric_limits<T>::infinity();
      val = asinh(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(asinh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(asinh(arg));
   }
   // F.9.2.3:
   arg = 0;
   val = atanh(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = atanh(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   arg = 2;
   check_invalid(atanh(arg));
   arg = -3;
   check_invalid(atanh(arg));

   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 1;
      val = atanh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      BOOST_CHECK(signbit(val) == 0);
      check_erange(val);
      arg = -arg;
      val = atanh(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      BOOST_CHECK(signbit(val));
      check_erange(val);

      arg = std::numeric_limits<T>::infinity();
      check_invalid(atanh(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(atanh(arg));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(atanh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(atanh(arg));
   }
   // F.9.2.4:
   arg = 0;
   val = cosh(arg);
   BOOST_CHECK_EQUAL(val, 1);
   arg = -arg;
   if (signbit(arg))
   {
      val = cosh(arg);
      BOOST_CHECK_EQUAL(val, 1);
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = (std::numeric_limits<T>::max)();
      val = cosh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = cosh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = std::numeric_limits<T>::infinity();
      val = cosh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = cosh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(cosh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(cosh(arg));
   }
   // F.9.2.5:
   arg = 0;
   val = sinh(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = sinh(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = (std::numeric_limits<T>::max)();
      val = sinh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = sinh(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      arg = std::numeric_limits<T>::infinity();
      val = sinh(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = sinh(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(sinh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(sinh(arg));
   }
   // F.9.2.6:
   arg = 0;
   val = tanh(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = tanh(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   arg = (std::numeric_limits<T>::max)();
   val = tanh(arg);
   BOOST_CHECK_EQUAL(val, 1);
   arg = -arg;
   val = tanh(arg);
   BOOST_CHECK_EQUAL(val, -1);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = tanh(arg);
      BOOST_CHECK_EQUAL(val, 1);
      arg = -arg;
      val = tanh(arg);
      BOOST_CHECK_EQUAL(val, -1);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(tanh(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(tanh(arg));
   }
   // F.9.3.1:
   arg = 0;
   val = exp(arg);
   BOOST_CHECK_EQUAL(val, 1);
   arg = -arg;
   if (signbit(arg))
   {
      val = exp(arg);
      BOOST_CHECK_EQUAL(val, 1);
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = exp(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = exp(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = (std::numeric_limits<T>::max)();
      val = exp(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = exp(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(exp(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(exp(arg));
   }
   // F.9.3.2:
   arg = 0;
   val = exp2(arg);
   BOOST_CHECK_EQUAL(val, 1);
   arg = -arg;
   if (signbit(arg))
   {
      val = exp2(arg);
      BOOST_CHECK_EQUAL(val, 1);
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = exp2(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = exp2(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = (std::numeric_limits<T>::max)();
      val = exp2(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = exp2(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(exp2(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(exp2(arg));
   }
   // F.9.3.3:
   arg = 0;
   val = expm1(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = expm1(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = expm1(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = expm1(arg);
      BOOST_CHECK_EQUAL(val, -1);
      arg = (std::numeric_limits<T>::max)();
      val = expm1(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = expm1(arg);
      BOOST_CHECK_EQUAL(val, -1);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(expm1(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(expm1(arg));
   }
   // F.9.3.4:
   arg = 0;
   int ival;
   val = frexp(arg, &ival);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK_EQUAL(ival, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = frexp(arg, &ival);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = frexp(arg, &ival);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = frexp(arg, &ival);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      val = frexp(arg, &ival);
      BOOST_CHECK(isnan(val));
   }
   // F.9.3.5:
   typename T::backend_type::exponent_type eval;
   typename T::backend_type::exponent_type fp_ilogb0 = (std::numeric_limits<typename T::backend_type::exponent_type>::min)();
   typename T::backend_type::exponent_type fp_ilogbnan =
#ifdef FP_ILOGBNAN
       FP_ILOGBNAN < 0 ? (std::numeric_limits<typename T::backend_type::exponent_type>::min)() : (std::numeric_limits<typename T::backend_type::exponent_type>::max)();
#else
       INT_MAX;
#endif

   arg  = 0;
   eval = ilogb(arg);
   BOOST_CHECK_EQUAL(eval, fp_ilogb0);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg  = std::numeric_limits<T>::infinity();
      eval = ilogb(arg);
      BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
      arg  = -arg;
      eval = ilogb(arg);
      BOOST_CHECK_EQUAL(eval, (std::numeric_limits<typename T::backend_type::exponent_type>::max)());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg  = std::numeric_limits<T>::quiet_NaN();
      eval = ilogb(arg);
      BOOST_CHECK_EQUAL(eval, fp_ilogbnan);
   }
   // F.9.3.7:
   arg = 1;
   val = log(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 0;
      val = log(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = log(arg);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg = -1;
      check_invalid(log(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(log(arg));
      arg = std::numeric_limits<T>::infinity();
      val = log(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(log(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(log(arg));
   }
   // F.9.3.8:
   arg = 1;
   val = log10(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 0;
      val = log10(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = log10(arg);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg = -1;
      check_invalid(log10(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(log10(arg));
      arg = std::numeric_limits<T>::infinity();
      val = log10(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(log10(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(log10(arg));
   }
   // F.9.3.9:
   arg = 0;
   val = log1p(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = log1p(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = -1;
      val = log1p(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -2;
      check_invalid(log1p(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(log1p(arg));
      arg = std::numeric_limits<T>::infinity();
      val = log1p(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(log1p(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(log1p(arg));
   }
   // F.9.3.10:
   arg = 1;
   val = log2(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 0;
      val = log2(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = log2(arg);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg = -1;
      check_invalid(log2(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(log2(arg));
      arg = std::numeric_limits<T>::infinity();
      val = log2(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(log2(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(log2(arg));
   }
   // F.9.3.11:
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 0;
      val = logb(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = logb(arg);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg = std::numeric_limits<T>::infinity();
      val = logb(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -std::numeric_limits<T>::infinity();
      val = logb(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(logb(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(logb(arg));
   }
   // F.9.3.13:
   arg = 0;
   val = scalbn(arg, 2);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = scalbn(arg, 2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = scalbn(arg, -100);
      BOOST_CHECK_EQUAL(val, arg);
      arg = -arg;
      val = scalbn(arg, -100);
      BOOST_CHECK_EQUAL(val, arg);
   }
   // F.9.4.1:
   arg = 0;
   val = cbrt(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = cbrt(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
#if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
   //
   // This test fails with early implementations of libquadmath - not our issue!
   //
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = cbrt(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -std::numeric_limits<T>::infinity();
      val = cbrt(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
#endif
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(cbrt(arg));
      arg = -std::numeric_limits<T>::quiet_NaN();
      check_invalid(cbrt(arg));
   }
   // F.9.4.2:
   arg = 0;
   val = fabs(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = fabs(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = fabs(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -std::numeric_limits<T>::infinity();
      val = fabs(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   // F.9.4.3:
   arg  = 2;
   arg2 = 0;
   val  = hypot(arg, arg2);
   BOOST_CHECK_EQUAL(val, arg);
   arg2 = -arg2;
   val  = hypot(arg, arg2);
   BOOST_CHECK_EQUAL(val, arg);
   if (std::numeric_limits<T>::has_infinity)
   {
      arg  = std::numeric_limits<T>::infinity();
      arg2 = 2;
      val  = hypot(arg, arg2);
      BOOST_CHECK_EQUAL(val, arg);
      arg = -arg;
      val = hypot(arg, arg2);
      BOOST_CHECK_EQUAL(val, -arg);
      arg2 = std::numeric_limits<T>::quiet_NaN();
      val  = hypot(arg, arg2);
      BOOST_CHECK_EQUAL(val, -arg);
      arg = -arg;
      val = hypot(arg, arg2);
      BOOST_CHECK_EQUAL(val, arg);
   }
   // F.9.4.4:
   if (std::numeric_limits<T>::has_infinity)
   {
      arg  = 0;
      arg2 = -3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = pow(arg, arg2);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg  = 0;
      arg2 = -2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = pow(arg, arg2);
         BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg  = 0;
      arg2 = 3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = -arg;
      if (signbit(arg))
      {
         val = pow(arg, arg2);
         BOOST_CHECK_EQUAL(val, 0);
         BOOST_CHECK(signbit(val));
      }
      arg  = 0;
      arg2 = 2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = -arg;
      if (signbit(arg))
      {
         val = pow(arg, arg2);
         BOOST_CHECK_EQUAL(val, 0);
         BOOST_CHECK(signbit(val) == 0);
      }
      arg  = -1;
      arg2 = std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = -std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg  = 1;
      arg2 = 0;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = -std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = std::numeric_limits<T>::quiet_NaN();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg  = 0;
      arg2 = 0;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = -arg2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg = std::numeric_limits<T>::infinity();
      val = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = -arg2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg = std::numeric_limits<T>::quiet_NaN();
      val = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
      arg2 = -arg2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 1);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg  = -2.5;
      arg2 = 2.5;
      check_invalid(pow(arg, arg2));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg  = 0.5;
      arg2 = -std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -0.25;
      val = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg  = 2.5;
      arg2 = -std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      arg = -arg;
      val = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      arg  = 2.5;
      arg2 = std::numeric_limits<T>::infinity();
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg  = -std::numeric_limits<T>::infinity();
      arg2 = -3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      if (signbit(-T(0)))
         BOOST_CHECK(signbit(val));
      arg2 = -2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg2 = -2.5;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg2 = 3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
      arg2 = 2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg2 = 2.5;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg  = -arg; // +INF
      arg2 = -2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg2 = -3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg2 = -3.5;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg2 = 2;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg2 = 3;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg2 = 3.5;
      val  = pow(arg, arg2);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   // F.9.4.5:
   arg = 0;
   val = sqrt(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = sqrt(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
#if !(defined(TEST_FLOAT128) && defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION < 40800))
   //
   // This test fails with early implementations of libquadmath - not our issue!
   //
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = sqrt(arg);
      BOOST_CHECK_EQUAL(val, arg);
      arg = -arg;
      check_invalid(sqrt(arg));
   }
#endif
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(sqrt(arg));
   }
   // F.9.5.1:
   arg = 0;
   val = erf(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = erf(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = erf(arg);
      BOOST_CHECK_EQUAL(val, 1);
      arg = -arg;
      val = erf(arg);
      BOOST_CHECK_EQUAL(val, -1);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(erf(arg));
   }
   // F.9.5.2:
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = erfc(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val) == 0);
      arg = -arg;
      val = erfc(arg);
      BOOST_CHECK_EQUAL(val, 2);
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(erfc(arg));
   }
   // F.9.5.3:
   arg = 1;
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = 2;
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
#if !defined(BOOST_MPFR_VERSION) || (BOOST_MPFR_VERSION > 30103)
   arg = 0;
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   check_erange(val);
   arg = -1;
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   check_erange(val);
   arg = -2;
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   check_erange(val);
   arg = -std::numeric_limits<T>::infinity();
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
#endif
   arg = std::numeric_limits<T>::infinity();
   val = lgamma(arg);
   BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(lgamma(arg));
   }
   // F.9.5.4:
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = 0;
      val = tgamma(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      check_erange(val);
      arg = -arg;
      if (signbit(arg))
      {
         val = tgamma(arg);
         BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
         check_erange(val);
      }
      arg = -1;
      check_invalid(tgamma(arg));
      arg = -std::numeric_limits<T>::infinity();
      check_invalid(tgamma(arg));
      arg = std::numeric_limits<T>::infinity();
      val = tgamma(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(tgamma(arg));
   }
   // F.9.6.1:
   arg = 0;
   val = ceil(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = ceil(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = ceil(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = ceil(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(ceil(arg));
   }
   // F.9.6.2:
   arg = 0;
   val = floor(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = floor(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = floor(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = floor(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(floor(arg));
   }
   // F.9.6.3:
   arg = 0;
   val = nearbyint(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = nearbyint(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = nearbyint(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = nearbyint(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(nearbyint(arg));
   }
   // F.9.6.4:
   arg = 0;
   val = rint(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = rint(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = rint(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = rint(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(rint(arg));
   }
   // F.9.6.6:
   arg = 0;
   val = round(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = round(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = round(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = round(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(round(arg));
   }
   // F.9.6.8:
   arg = 0;
   val = trunc(arg);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = trunc(arg);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      val = trunc(arg);
      BOOST_CHECK_EQUAL(val, std::numeric_limits<T>::infinity());
      arg = -arg;
      val = trunc(arg);
      BOOST_CHECK_EQUAL(val, -std::numeric_limits<T>::infinity());
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg = std::numeric_limits<T>::quiet_NaN();
      check_invalid(trunc(arg));
   }
   // F.9.7.1:
   arg  = 0;
   arg2 = 2;
   val  = fmod(arg, arg2);
   BOOST_CHECK_EQUAL(val, 0);
   BOOST_CHECK(signbit(val) == 0);
   arg = -arg;
   if (signbit(arg))
   {
      val = fmod(arg, arg2);
      BOOST_CHECK_EQUAL(val, 0);
      BOOST_CHECK(signbit(val));
   }
   if (std::numeric_limits<T>::has_infinity)
   {
      arg = std::numeric_limits<T>::infinity();
      check_invalid(fmod(arg, arg2));
      arg = -arg;
      check_invalid(fmod(arg, arg2));
      arg  = 2;
      arg2 = 0;
      check_invalid(fmod(arg, arg2));
      check_invalid(fmod(arg, -arg2));
   }
   if (std::numeric_limits<T>::has_quiet_NaN)
   {
      arg  = std::numeric_limits<T>::quiet_NaN();
      arg2 = 2;
      check_invalid(fmod(arg, arg2));
      swap(arg, arg2);
      check_invalid(fmod(arg, arg2));
      check_invalid(fmod(arg2, arg2));
   }
   //
   // Bugs:
   //
   int sign = 0;
   boost::math::lgamma(T(0.000001), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(0.5), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(0.9), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(1.1), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(1.9), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(2.1), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(20), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(-0.0000000000001), &sign);
   BOOST_CHECK_EQUAL(sign, -1);
   sign = 0;
   boost::math::lgamma(T(-0.5), &sign);
   BOOST_CHECK_EQUAL(sign, -1);
   sign = 0;
   boost::math::lgamma(T(-1.5), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
   sign = 0;
   boost::math::lgamma(T(-2.5), &sign);
   BOOST_CHECK_EQUAL(sign, -1);
   sign = 0;
   boost::math::lgamma(T(-3.5), &sign);
   BOOST_CHECK_EQUAL(sign, 1);
}

template <class T>
void test_c99_appendix_F_tgammaq_addon_for_float128()
{
#if defined(TEST_FLOAT128)
  // Special tests of tgamma for positive and negative
  // real values in the neighborhood of the origin.

   // At Wolfram Alpha: N[Gamma[1/3], 201]
   const T tgamma_third
   (
     "2."
     "67893853470774763365569294097467764412868937795730"
     "11009504283275904176101677438195409828890411887894"
     "19159049200072263335719084569504472259977713367708"
     "46976816728982305000321834255032224715694181755545"
   );

   // Create a string such as "1e-84", where 84 exemplifies (digits10*5 + 5)/6
   // and the exponent varies depending on the value of digits10 for the type.
   // Consider, for instance digits10=100. In this case n_exp=(100*5 + 5)/6 = 84.

   const int n_exp =(std::max)(((std::numeric_limits<T>::digits10 * 5) + 5) / 6, 1);

   const T tgamma_tol("1e-" + boost::lexical_cast<std::string>(n_exp));

   // Check tgamma(1/3 - n) for n in 0...24.
   for(int n = 0; n < 25; ++n)
   {
      const T tgamma_val = tgamma(T((T(1) / T(3)) - T(n)));

      T tgamma_control(tgamma_third);

      for(unsigned int k = 0U; k < static_cast<unsigned int>(n); ++k)
      {
         tgamma_control *= -3;
         tgamma_control /= ((3U * (k + 1U)) - 1U);
      }

      BOOST_CHECK_CLOSE_FRACTION(tgamma_val, tgamma_control, tgamma_tol);
   }

   // Check tgamma(1/3 + n) for n in 0...24.
   for(unsigned int n = 0U; n < 25U; ++n)
   {
      const T tgamma_val = tgamma(T((T(1) / T(3)) + T(n)));

      T tgamma_control(tgamma_third);

      for(unsigned int k = 0U; k < n; ++k)
      {
         tgamma_control /= 3;
         tgamma_control *= ((3U * (k + 1U)) - 2U);
      }

      BOOST_CHECK_CLOSE_FRACTION(tgamma_val, tgamma_control, tgamma_tol);
   }
#endif
}

int main()
{
   test_poison<float>();
   test_poison<double>();
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   std::cout << "Testing MPFR: " << MPFR_VERSION_STRING << std::endl;
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
   test_c99_appendix_F<boost::multiprecision::mpfr_float_50>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
   test<boost::multiprecision::cpp_dec_float_100>();
#endif
   test_c99_appendix_F<boost::multiprecision::cpp_dec_float_50>();
#endif
#ifdef TEST_CPP_DEC_FLOAT_2
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
#endif
#endif
#ifdef TEST_CPP_DEC_FLOAT_3
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
#endif
#endif
#ifdef TEST_CPP_DEC_FLOAT_4
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
#if !(defined(__GNUC__) && defined(_WIN32)) // Object file too large otherwise
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
#endif
#endif
#ifdef TEST_CPP_DEC_FLOAT_5
   #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long > > >();
   #else
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   #endif
#endif
#ifdef TEST_CPP_DEC_FLOAT_6
   #if defined(__MINGW32__) || defined(__MINGW64__) // Weak workaround just to, let's say, get green
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long > > >();
   #else
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   #endif
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
#endif
#ifdef TEST_CPP_BIN_FLOAT_2
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
#ifdef TEST_CPP_BIN_FLOAT_3
   test_c99_appendix_F<boost::multiprecision::cpp_bin_float_50>();
   test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<100>, boost::multiprecision::et_on> >();
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
   test_c99_appendix_F<boost::multiprecision::float128>();
   test_c99_appendix_F_tgammaq_addon_for_float128<boost::multiprecision::float128>();
#endif
#ifdef TEST_MPFI_DEBUG_ADAPTOR
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
   //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
#endif
#ifdef TEST_MPFR_DEBUG_ADAPTOR
   test<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
   test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
#endif
#ifdef TEST_MPFI_LOGGED_ADAPTOR
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
   //test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfi_float_backend<50> > > >();
#endif
#ifdef TEST_MPFR_LOGGED_ADAPTOR
   test<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
   test_c99_appendix_F<boost::multiprecision::number<boost::multiprecision::logged_adaptor<boost::multiprecision::mpfr_float_backend<50> > > >();
#endif

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_signed_zero.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#include <boost/detail/lightweight_test.hpp>
#include <boost/math/special_functions/sign.hpp>

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#if !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_DOUBLE) && !defined(TEST_MPFR_FLOAT)
#define TEST_CPP_BIN_FLOAT
#define TEST_DOUBLE
#define TEST_MPFR_FLOAT
#endif


#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif
#ifdef TEST_MPFR_FLOAT
#include <boost/multiprecision/mpfr.hpp>
#endif

template <class T>
struct extract_value_type
{
   typedef typename T::value_type type;
};
template <>
struct extract_value_type<double>
{
   typedef double type;
};

template <class T>
void test()
{
   using value_type = typename extract_value_type<T>::type;

   using std::real;
   using std::signbit;

   T mp_zero{0};
   T mp_m_zero{-mp_zero};
   T mp_finite{2};
   T mp_m_finite{-2};
   T mp_big{!std::is_same<T, value_type>::value ? std::numeric_limits<value_type>::has_infinity ? std::numeric_limits<value_type>::infinity() : (std::numeric_limits<value_type>::max)() : std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity()
                                                                                                                                                                                                     : (std::numeric_limits<T>::max)()};
   T mp_m_big{-mp_big};
   T mp_small{!std::is_same<T, value_type>::value ? (std::numeric_limits<value_type>::min)() : (std::numeric_limits<T>::min)()};
   T mp_m_small{-mp_small};

   T result;
   //
   // Multiplications:
   //
   result = mp_zero * mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero * mp_m_finite;
   BOOST_TEST(signbit(result));
   result = mp_m_zero * mp_finite;
   BOOST_TEST(signbit(result));
   result = mp_m_zero * mp_m_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero * -mp_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero * mp_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero * -mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_small * mp_small;
   BOOST_TEST(signbit(result) == 0);
   result = mp_small * mp_m_small;
   BOOST_TEST(signbit(result));
   result = mp_m_small * mp_m_small;
   BOOST_TEST(signbit(result) == 0);
   result = mp_small * -mp_small;
   BOOST_TEST(signbit(result));
   result = -mp_small * -mp_small;
   BOOST_TEST(signbit(result) == 0);
   //
   // Divisions:
   //
   result = mp_zero / mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero / mp_m_finite;
   BOOST_TEST(signbit(result));
   result = mp_m_zero / mp_finite;
   BOOST_TEST(signbit(result));
   result = mp_m_zero / mp_m_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero / -mp_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero / mp_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero / -mp_finite;
   BOOST_TEST(signbit(result) == 0);

   result = mp_small / mp_big;
   BOOST_TEST(signbit(result) == 0);
   result = mp_small / mp_m_big;
   BOOST_TEST(signbit(result));
   result = mp_m_small / mp_big;
   BOOST_TEST(signbit(result));
   result = mp_m_small / mp_m_big;
   BOOST_TEST(signbit(result) == 0);
   result = mp_small / -mp_big;
   BOOST_TEST(signbit(result));
   result = -mp_small / mp_big;
   BOOST_TEST(signbit(result));
   result = -mp_small / -mp_big;
   BOOST_TEST(signbit(result) == 0);
   //
   // Additions:
   //
   result = mp_zero + mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero + mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero + mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero + mp_m_zero;
   BOOST_TEST(signbit(result));
   //
   // Subtractions:
   //
   result = mp_zero - mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero - mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero - mp_zero;
   BOOST_TEST(signbit(result));
   result = mp_m_zero - mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite - mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite + mp_m_finite;
   BOOST_TEST(signbit(result) == 0);

   //
   // Over again for one arg an integer:
   //
   int i_zero{0};
   int i_finite{2};
   int i_m_finite{-2};
   result = i_zero * mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = i_zero * mp_m_finite;
   BOOST_TEST(signbit(result));
   result = i_zero * -mp_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero * i_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero * i_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero * i_m_finite;
   BOOST_TEST(signbit(result));
   //
   // Divisions:
   //
   result = i_zero / mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = i_zero / mp_m_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero / i_m_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero / i_finite;
   BOOST_TEST(signbit(result));
   //
   // Additions:
   //
   result = mp_zero + i_zero;
   BOOST_TEST(signbit(result) == 0);
#ifndef TEST_MPFR_FLOAT
   //
   // There appears to be a bug in mpfr_add_ui here:
   //
   result = i_zero + mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
#endif
   //
   // Subtractions:
   //
   result = mp_zero - i_zero;
   BOOST_TEST(signbit(result) == 0);
   result = i_zero - mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero - i_zero;
   BOOST_TEST(signbit(result));
   result = i_finite - mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = i_finite + mp_m_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite - i_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite + i_m_finite;
   BOOST_TEST(signbit(result) == 0);
   //
   // Over again for one arg a float:
   //
   float f_zero{0};
   float f_m_zero{-f_zero};
   float f_finite{2};
   float f_m_finite{-2};
   result = f_zero * mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = f_zero * mp_m_finite;
   BOOST_TEST(signbit(result));
   result = f_zero * -mp_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero * f_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero * f_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero * f_m_finite;
   BOOST_TEST(signbit(result));
   //
   // Divisions:
   //
   result = f_zero / mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = f_zero / mp_m_finite;
   BOOST_TEST(signbit(result));
   result = mp_zero / f_m_finite;
   BOOST_TEST(signbit(result));
   result = -mp_zero / f_finite;
   BOOST_TEST(signbit(result));
   //
   // Additions:
   //
   result = f_zero + mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_zero + mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_m_zero + mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_m_zero + mp_m_zero;
   BOOST_TEST(signbit(result));
   //
   // Subtractions:
   //
   result = f_zero - mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_zero - mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_m_zero - mp_zero;
   BOOST_TEST(signbit(result));
   result = f_m_zero - mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero - f_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_zero - f_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero - f_zero;
   BOOST_TEST(signbit(result));
   result = mp_m_zero - f_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = f_finite - mp_finite;
   BOOST_TEST(signbit(result) == 0);
   result = f_finite + mp_m_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite - f_finite;
   BOOST_TEST(signbit(result) == 0);
   result = mp_finite + f_m_finite;
   BOOST_TEST(signbit(result) == 0);
   //
   // Special cases:
   //
   result = mp_m_zero * mp_m_zero;
   BOOST_TEST(signbit(result) == 0);
   result = mp_m_zero + mp_m_zero;
   BOOST_TEST(signbit(result));
   result = mp_zero + mp_zero;
   BOOST_TEST(signbit(result) == 0);
   result = abs(mp_m_zero);
   BOOST_TEST(signbit(result) == 0);
   result = fabs(mp_m_zero);
   BOOST_TEST(signbit(result) == 0);
   result = sqrt(mp_m_zero);
   BOOST_TEST(signbit(result));
}

int main()
{
#ifdef TEST_DOUBLE
   test<double>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, boost::long_long_type>, boost::multiprecision::et_on>>();
#endif
#ifdef TEST_MPFR_FLOAT
   test<boost::multiprecision::mpfr_float_50>();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_sin.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
struct has_poor_large_value_support
{
   static const bool value = false;
};
#ifdef TEST_CPP_DEC_FLOAT
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif
#ifdef TEST_CPP_BIN_FLOAT
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 101u> data =
       {{
           "-9.71360659712083391437631022096936715962104815777147739346439739644168480837178969413799829610404829247283169084501281105e-1",
           "-5.95431113317256105006804890684659010940293672390817519158205264611725147142085353698349092164137652363446368483953564682e-1",
           "5.09924118934356013545988500545586843463766955556781588535384546070893806324487181574368899833574915659357543038822935347e-1",
           "9.90602974910637417521410554344955057938063175873799034495811832851567842600306335485818201417146475654562543760051881571e-1",
           "2.57755634110962773819397192502372718147953063328591480930319110437537556577887190430547163274290595074462686853519200826e-1",
           "-7.90852129665907861812449876176102241731921451584589870529143390612597378289323905030142878920134443274067663564142249906e-1",
           "-8.70636054394434218558219672958497111094237434037462776135170928197514857325641761722162169311905082223410873872693125021e-1",
           "1.16142192225871586802402588799179588339908282696987123538816621894316618250692422106879105583060486278819650782761165055e-1",
           "9.60641850565339311654365605083646127348817546384991780755200411966145627086231307074524787693440076802209868233548778731e-1",
           "6.28318825240308217440049590303028869715272770671179428040549526344092598897275498972932981684079339892035243316790587027e-1",
           "-4.73718579778960595001132927360485548840577209745936881040433718918629103032639945353908537818475936329314134212199346978e-1",
           "-9.95432766494621395340223548609251497842694553405493731879049259799325119533316838972006879914623359183523219011870805961e-1",
           "-2.97704078652633309130390182393607392013126109733352620573058826659738026681661456497779386104992235762190242017128767206e-1",
           "7.64723391125286889782047394187107836056829439952009227196240883193721606229047061163517791688110517783506991004016374431e-1",
           "8.90335717074674250432504838435892622513509178529392798127561987551398090841490265311069534613651712468228001675091153605e-1",
           "-7.47469618974513669394515485690188234127771130501791709462887130373371023385813212165673231177548426835629029005547008861e-2",
           "-9.48261778982069330544079494960981900232314056127899219497335245577354566418258722147558010380033694835705634428764954401e-1",
           "-6.60119969404606610211922488494059074732492583049845598285779387022002845776084527598443564095143849120847643366330179739e-1",
           "4.36693827009658961576344650626557410722590226545637608661764593658572210930294024902150766064738444736422263939746970132e-1",
           "9.98541130824430070642243744636010968399851408459030982248969144276197147611376115185206245742327729890090526273555800490e-1",
           "3.37137695943362070360548307779555944485385294617304662646987679063953108310365389494460188124285214040163147170304540339e-1",
           "-7.37272196933518190054375156317136276073182897209685319124536092629865074949247291797880288692223977281455156619510259042e-1",
           "-9.08495699506960201290293288218820500948312195353635174830883006841931398581001427066173033535720385301624330783999899511e-1",
           "3.32224697427099307204044509056982627738295866011152619834749776109067529453431741767996787924292629814505731320175556430e-2",
           "9.34241854135599266375493853147210486293657026766576383005045752264274587199837314096798394557243705656211732557069413970e-1",
           "6.90779551281016826784976005137338585011513089446563025258584317423906941741640583083551185645679047405447557105684226754e-1",
           "-3.98913888475082839741071010629509607776766095858433376450534753556286110518195743624946499527251336022805096741714382999e-1",
           "-9.99922692526403520897313527841668431397204867244750030781062964701898557028332255650446046614062333174844253917288331438e-1",
           "-3.75988292423704532504216998833472116186771022412627192871974303806891208635376610998425108046077306043945435504842144332e-1",
           "7.08546019140379445669962535829318394094758212505515423960726677977484727061149949358051741627739138448760095710063342839e-1",
           "9.25084597170819667485373176055260044057716794391569156042799693611964098948722923916237050181882167134906470192542857299e-1",
           "8.35947487571472125423673177137150279693224632368449469153892167972732129345714981936363891382927399742266512920038864004e-3",
           "-9.18606321039298722214219289469027246078943851192917449117591801249272620492502932760495762195965214412326830491755901723e-1",
           "-7.20244550473164405555518647469765134103488938825118543602681358279149452868549672550326500728323814331193184035259160414e-1",
           "3.60444097985855629825697367385029316833790934188475151408740160657889784929257301330229580694580194294034115152177674537e-1",
           "9.99575062430677992414643463029115424067356090568060307410717467085018957489304987413609313388961297483138454662118061646e-1",
           "4.14188682766963304833862149212585018360876819555612195218295874225032162838027842720351664698295767693697842043579048219e-1",
           "-6.78594534657286312316409269272929566493548786915986771929001823358451551885758307761400157853363173388867780400090112946e-1",
           "-9.40073722462713282312837596921874850901167502371739429501407718251639587081137893231736511487958940802467918593519005653e-1",
           "-4.99269632411748222821310824324558181913141458235676771744322439351386139493233963671531219603373207564905654915871172017e-2",
           "9.01382218619061521491363679812206948759377256420255657634443270431495336446996377562469573885297156497163691224107230524e-1",
           "7.48464012406957686684753003872919309910943477238245908909177973105841950470333390670719219379167068809799710776770734833e-1",
           "-3.21350982331168500558883709193541886146178412146971245706190880193067020283050714591560922441331235332970961845050217575e-1",
           "-9.97498841702838239659412520756556451623238132913559678626409839807628110807613195403956929948379909495726426243705794281e-1",
           "-4.51672806064485973599605876288778011355969815150135195358334589946828629430271875346142404286368814526016297993583170592e-1",
           "6.47469539349743367777844577149239337681085253251300560380374646379682072633705733561446355539618404778987844138766238618e-1",
           "9.53437154306238691456130012770111782377503876017231780889420296856266641153714110120975772709549811845909173386912105405e-1",
           "9.14081116365893107669584386407698218216480671014671832303147213716318806206478591012619084058741626713939006968851852873e-2",
           "-8.82599332954202005638662236444958997569939600897565089251125658458817750203393016337212996488633688567918453254294067039e-1",
           "-7.75389136447631492669594511701990356678047393586968390929688701894781023967621486245394406725747074772996680491766725244e-1",
           "0",
           "9.21877670451674413245307018032333288624288893879527153976730741889055419244554390143014969580425598422296522787223865492e-1",
           "7.14420247379307162288182477560228852605155250738051326022559557923361829606843109334201812861061126243914893718333771523e-1",
           "-3.68229061503980158220203193441625324286779814470455045264018328963975686564161509474566417124652588774892207244798533238e-1",
           "-9.99783810945210864429782835782052003838999970584938136857974918523615732378678641269300999292060748749245257644847852880e-1",
           "-4.06565491434208630299086167510578859920684132980243005899494321151205958987020300473732138517681916554185382528057861016e-1",
           "6.84710967469127345624707128760638003100107237269026812211460044517359789036617753689648451870956943571853410785082804567e-1",
           "9.37190534692875414284475879207349713030454322911019395907169592096165438597133651606167760904128838721803617281109050826e-1",
           "4.15761692057244148543310701200534576325308397337003695681679007540324069366547327722258885686349619359915993749152386902e-2",
           "-9.04970579658619470380865991258110513843850446973806499697900678159194774744593408797468966041695053471205276923200577190e-1",
           "-7.42894062146919717307486895770712177633720181625852464705801879158549930143011385755502810839808877188169347497140463278e-1",
           "3.29255843672460745277513964057060067396377984587222455665841087186879420769340447084849343957766905952270152874052907066e-1",
           "9.98054859318969984153930327705164465077718593220578997216979734167429154849012382322757855259404199572095265136279871773e-1",
           "4.44198837297768694342150710437773511448850303134514239359160353596186338967438818161771076138440975975069051604632938785e-1",
           "-6.53817599431343721060913145888825198919543068369083977787231740776950274433927919565042681494795499030972133972973154991e-1",
           "-9.50882691455803790808811011811129940528171185220498569922200361836899859377942311459807744784166538095896117442350480286e-1",
           "-8.30804396823694462619418608693397504202900045660409997788297791645107264729830105800672434941805906654953509298579082883e-2",
           "8.86498500176738212245618093138553877114943127333459437678466772704535139826656179981455385901664422134192971441152486596e-1",
           "7.70083171278361495868782270594413506070341191348346709317329019377797940394556787220273230008072684372906392335068211595e-1",
           "-2.89713235318575682157337623325710322388267200178020040738121279630672170355171163891332847251952971324782327373734923025e-1",
           "-9.94599945986602107902462030221489305674036413322184167100620086215068494963807086265519051279456167270901961176645890910e-1",
           "-4.81064018790479216363003919039401079745827607566793090566247167201506427394383426836725220489510187378030886775425254046e-1",
           "6.21793567954698234151923123976248746751871911018984490371928031737872104124834908200003970971778452547150523318639635937e-1",
           "9.62930462544790791995256817531759605974030310743258985429278608944994805716203043054967792555227147404499205611680348343e-1",
           "1.24441037037160425420824052419427892644210865386492893504553391973646623439822770473194845274620957661128504291608680469e-1",
           "-8.66493376243885476034533210550037276824055111358129259572484897399197578809821587005093985112028866251515011805996119334e-1",
           "-7.95940555954229526911811786010975888490876487056728372525209250018208474961217211282867562886053609351620626802054272020e-1",
           "2.49669618482792917975718339302754781070461300705127317300546100189317933291972223791458678771914034385073586648459580423e-1",
           "9.89425045617789945796335206411736550560149597573171983909624851636680028232543261568285131480585113303281176722731984359e-1",
           "5.17097284014384149171097163430722725596083616428334032893201431916692899725128152827282357887267679461332587145165393473e-1",
           "-5.88694253013035419947972745515246684318073372460957150709985237608958241550865774225576562359889367149484593966586261944e-1",
           "-9.73313013442224866478107643999632554759604190263325143130961313777287157745245701134838602677190253924612391775436901182e-1",
           "-1.65586435334914172055850479429458408174448669771862313204835451683387762284114799645762688524058144409210946183564694437e-1",
           "8.44989803230758608979729460217254170202748876564967551526138387646760352687916491884649142029664716335759879232648284164e-1",
           "8.20421500340164168068753907367027481963552257850283600606773656660614708517253273174848291641569969886126754639035754147e-1",
           "-2.09194241612317592929856274655591551278574667482924447651723415490434554354833563537792618079275726893013991849104465053e-1",
           "-9.82539107299636472172005507105476251789057582568202763534005396813858490465264145708502581273803767931004018272989858624e-1",
           "-5.52236319725534543207688775430217404447704139560595336544456138148662731976576062425879410116209671353021251780801885578e-1",
           "5.54576894095302137473562870411642498454159878739464625116831971740997730359915227524075717328436463081497500485416831879e-1",
           "9.82012389338213987427432686899213579991770436451929205950504261612336440523069987734051927060071228336651935114247230018e-1",
           "2.06445480789661722781085666935934466710665000093111315471318244086154187788240397407764949071589419997001126229699279918e-1",
           "-8.22024967814241172490083350373664443948382772873119098939533117836179462362265599942085298240078400862839510315401568501e-1",
           "-8.43483668915081157881609334416452212500481988371373212797897630926101856989377353686006695443683562952698091745372956064e-1",
           "1.68357099807987317797633647903674089665368628422558854222230995142941489911909308417314277825877040168111682241442337249e-1",
           "9.73954039060780508698548127540108987785881109985102169990241290387386676882934112332475075476604334818263785540220696343e-1",
           "5.86420359093869515237687266954561200160006212641211187483350874672859136679499954407470935299385535928011115437979374327e-1",
           "-5.19500491219840443397382144913775579016253538466887540765306393159738082663675375499840773403952929977354698339617261390e-1",
           "-9.89013546180296021750901758474634735102493497248279924875522015911873550276888689676425102442986261848126775556194306727e-1",
           "-2.46947514812703938169894550153319655995779907820829748198209521180129269232387596803077057086642606505827139155491603712e-1",
           "7.97638583669534812597149574893980942155226403291812660315816507318428697361476484505958849067790885048775312980075497096e-1",
           "8.65087179683067252708187359165577777305998628817518314353161876891989239932835217904989326717355654871984067712207255166e-1",
       }};

   std::uintmax_t max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      static const T euler_gamma = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");
      T              val         = sin(euler_gamma * ((100 * k) - 5000));
      T              e           = relative_error(val, T(data[k]));
      unsigned       err         = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = sin(-euler_gamma * ((100 * k) - 5000));
      e   = relative_error(val, T(-T(data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 5000000000uLL);

   static const boost::array<const char*, 51u> small_data =
       {{
           "0.010890646307437399028563191160252839599929232814970922208664909237494716181484215717644776933044418903207919912063594159099133490979634344811936925144447725948305353257042599564404885434349760121009797816724142318243738364307036155852011004353462651092012819894667485840322627440332163428546845499107471983896711023161969130462687924045508477090891879273259947713367290982391204265694893491531721581439",
           "0.029754394000520972141380267705677256353702996169858414168445272181777338962866552847084800544086743338130195210005002660881957584567978770485056322086472328896988088721899728258224129935989180857437073412730903070983582129359565450458299328041955729258476583848159389714290107649243089149974776893563078190705561325124542669960182002956940545214147678093802442811362846262655415145897575707676223535749",
           "0.04860754948595027759689273751438643634234576398271158524070718139962965653841137425728738193533514318422431877217110239554743968609870039776938201724688048349972662394084789924867267405853696017478160702683117974766657840965270625814482422398422216605490620054574252910928068433847115132429726072853170339113804838625536981361490008602432476302086066307320875870985443111858828925332085101376920451257",
           "0.067443401266329792365583268418977022587089806595860818790246293104463576184436096833111903064801552379988362224633198052490234517656318474005568709048710308123967082103235230201516378834855764348740505470176912466587139988300259624310153055247378188811239571439869254255368050758213303082097176168650573121101094016896349982672715603054645687782535250201448606757920212668324401846105554332382154705308",
           "0.086255244004175604199645786226683865650130764638142939010554245919172299560583634262067769465886944689883333394099120765964771092069938753689253686543017871063587988437235057514131760587649504670117933814486942187589706655157340717185354058186603027300571692666150552274324933749082047517987509942119060274537912867956274549119040817359639741746006374702951412541338483858389306953539029174581171144916",
           "0.10503638090893519164596691292161072193010174143933600597680115817738720676321226654184308409972393036413684625874294713490753271261380987552528236660688624108474124469034444076627315674234385578608111398112242272762722849083801773818689342174907858373883192220827687618321085007917387951532673599267211035785307947515638810735621964273183425401191468313574763898720597251843424536611952986478638938787",
           "0.12378012612096459891996422671239906394195356627713556749926735466337892925173796651675302282473738808218327028589606894825728784823540605065317506645900565980161901287116410208049542818796994171203890952761651470187834173644651508025088970034800067245131759655003164127161058084682831906406941473650395873577925901419536540828468001386512234321890242266327761400155849351025221609783793228816606096155",
           "0.14247980709161433833827358255114404185333478069639957369769805221957506649654851981837061160249376538785737485777248817812720592537597263252706422066438137522011148566625861552209380620325080441618503257506798981598559897331754555335688284111417797211888381141445522536739542765207936516297907076923899840216864191777039028622886076254231994264908278499537587536902686114072117102531777746791366147472",
           "0.16112876695857673825462942280040873226725445145336882995544646098546697397681955191516861690559627281570477802647683153249828731761062718487424104325152088763220776831248566486363299448443795266104568555186977695939803420793575204146124697832793773870449082377964029658283741910741804550762511379894890589132658450368609377005630322641674351408014813725947288936865021810537922503050280596331958949813",
           "0.17972036691564914131189073707203611766536704952071818203835281740755093560444625679032703078557333645546302532200674729781663838075105196332695024246509042831095553050804767663788014113177991938252225120228302734228632787082072480689719322299247090887229731260135165819595797392665106642595359433094386743214852929965104946276195924300495453775467378376551444126292108291215861133471208854009513721707",
           "0.19824798857606934571352609051549058593435535174283382080060738672122306773474119459815363636791069253463660528114022041674780565798655265640072669329819802234483545444085426470661233958030668844326674768815456315879868376252722369574694411591080512527683145774214215193268992508938562109669843137270238454905091555179756374512457742554641355319960601765568460966738628365652972463731882673979926092423",
           "0.2167050363285819704223187876642169717474346025766606244643176750460657731203611217470241676182041675112171974414875203007374497968642376196256262296063879827128970901451226217571636202438144440234868076467587220541438440149682254317134405302648426790500751310485432990930185087578150399032543990173811106465656404530116032387260432178319507278340110997943206401370789106214680733463126804159766688178",
           "0.23508493968539701289801441539326267060915175918342580386836036980227948313782327655061004506711767031388143537081826986030990557707922203603349984851809173788402101756510017046639631528282698404857654444279509591873678208318484036337040837844539190863615310872984455261973647897667843302241773795592355085118273592671348602240382153223466391512738221253451636183066773121830262978729780866153048605159",
           "0.2533811556212047542679161173582151227103672187769971543582388259784795155332622779547839459016647290250036005712168909799523370471647322112833886051217950625710683025675691585734514265087749450457714578451290681140064635291501640395753290532318406110106892218388811781561305402570000283806458134435822529043797962340420841850011846648265787470508569124672250211852546600514370101687713861131209463861",
           "0.27158717090241435065755609312085387589073221253701701142877476904254125053252466469600403650634482409879186635717002370089097070045821182432642232618427944489732133359996899812980722107011126957850576210476679069162561257167921627603536603943342268770727524690332400255408587654094512383349857596775777725888982277559281982571487656535560758087235441872907962373375423740325723506626374882319859924962",
           "0.28969650440578692965912855479777150523900698183973110358010443581781966348171378962307935462457921708108325003566673849851640304571019200113280406744551445148200341554501141174444530008329262826786160080931309057528673711507934822659456861163197618813727062179453555460400169858233923358238607875306523866767536243361049306545596678120228677505849040202788510059415993219975440657979707947898632705847",
           "0.30770270942563778634443222550824378057595253208974144909939396933701715445493088586920897452838893301853350676955400357197838773823140696209649573828382477454711986806154497998912926265388494228459988323524548750870702083339285969468391846533348589851520262990720843670148790211009236063622194282315540801467216625666505663699480592080398449845511909092071640909885054719301078547683325662349532658001",
           "0.32559937596878634249263192973385963275552570142977727375619908690982968889531407133936548327912894149757305868454394002531385820341045863161146695151908269553629121372700695833373968533510661265854738947940689721812230819575490874211279007289828369964583273676393398981064015459284982970048174649094549631109312941188691838118955683939990881732219088392629316401227525790752712758279892546851835776728",
           "0.34338013303643689435259984865624959352259286039436985939426483729323987764837568376066164703227630278807584950278626035763399164177429894322425866236150336898079573258157833074772287354310049676029566569737995054499018518699450946056626536479822852758163848528920078247789349605898976290484284018984355696648190967701849464571286257873661615051036433297599097073117151941857301740816310919312668936753",
           "0.36103865089217782674224266392907326208964452822379102503439414768728197653534265911503054023760783622236800804794470785631737993143180071550223728801984904852623160397230839644629077782630949486339104760008566935013234195735777070582106661423219379374522941522832331186147905332977726043795737008218909226025962294880541867964419424128310806148008435847967256901208159302482322730929744194185143496647",
           "0.37856864331529191294683302986737462527422720295203122486985051910813389831630458742420433021640718832999264813674938157273375290592788753133996741859965258034273428657399863159488519434113093863042179261649202584979828347495161391780592433454809420632605178105958049630938532568156789806946629309375790343585791884755866400295470651281289167454617624179556306285775538273640784278475358303871406797294",
           "0.3959638698385755489557710011250921602780605301308457595569865098132061251227321128681128349835212212508810246299921462519655630208347321575504292305860152320513799100372630595769065936291506594220617567642210250680560302662459931036815131767702563357378794733903424219866581554015722958062178902473414883933807190920961687912191470152974845756609418554739641361171541363409996648143043979357302190703",
           "0.41321813796987028521091431473013916161596830805293649687424341688961507413716621591649879163383882641673238540682782626959358955002216003316726344623613626809950993449214457071292961126188761860214007662067345193545393653191742497646193189677890657992964660139924463087072704096969748995358605459064076775540679952182100013584273877612509536257834358450242426357122974687246428904315337788603554112487",
           "0.43032530539651581726649227346608528709372859200683817125277384462849187532000288969537766724897319030479860713591459932866508254904869456423088312945970943686450425589907227275358186473310644458353392107693439475272544181726520566221333846008220008702070460626739342310039148106649726719665728169819714333172605016313499067227953767878741853545763313707499816244740855778447731454065384788859848319503",
           "0.44727928217193967651655712666040617006236300257644793444619887007723922383970962870988815495150987337761018019128790177957898245520422485269324604484642139354461290347689315448558082058132330317789105861674569680430563377440355102600184370927625450804550114009478901349833826102470780452480255838220723171955252412104006070322080932915859579006653276371401264439817338080069936810866666557553662506811",
           "0.46407403288360522126660904671571257203469668709200603873826642103612288853249598361813813213381052968904786566929537791978751985511297321991996818974870946807510786919602279514706154473236597480481149516597293844121405001964448599792635426082163120478756812832932606227610137817312140031064078333902425335570730565173883252754294319888872518149175050583958244086010074110878967984441526026195572046031",
           "0.48070357880154616464768530714893198018226307768872832018696934136162055774617690112915494983829868655926209174893609677823844628976682666861087174925649829592164380174433963170047900751735818142724368678683601091750819984658303806035572915499999180599872513173096429390456178642478189724903758698238722978406369084171804020040246631229610021517925007543961283845124822740019511921386188934760298241688",
           "0.49716200000672278683141570737786924159326600032981923078600441023882683095816876734389429898823686013764499093454507915253215528870989821318738227798745591597923864925733083640574132559603114206682739488541451077277291582357627881380008066440685837422009543184722898767087492264154499861112499590934108906196324393034778681622285346845867860458748417916763883649390228287689107774312170267691257606116",
           "0.51344343749844216224309565441486087365890516381683759696704839526386373494321578458551193514743669178342420835082611868891019193801223760604220552152028015878259509179672236586872004169442377393342941368136686044214656339879518691219516228434732537186028321245942076903928921929607502848888640267094590400556200402256089794954485061564115688273804254406706725374971267431122825004095102239220991848356",
           "0.52954209528009218542956877037980380998240467111773187487177084701668417706002935457309027480414979338624119758863233287969233845786459113619958146654397106933375312089626001011352424174223416515118670901639015699899005014886945323983797633471828049323917701068414699189471811508040323789047713536270617216249222074877291822920747392986535291960399633972613345908694327479738445245500914715996152461985",
           "0.54545224242244689926647810432697721723945987179773365856990386707254353534614807468692870318816991084937065603191754270239773531928848863926268254420020634174904439920465735399587679402503040251639815041072160696029528969373711375024524059535996077596844557011786411865071706766713049961515353664484996577751962474564968659755104983468313555304855249829815310291744255989014492588353749587481644931913",
           "0.56116821510380861353700162760755101727268623115746212675907859515911800480855365905235006799852352328451502804871577600277181740574994973635138803211912076695967558806493981733454148905054449991651227073996616835900542604367257843601995979944175684600136575098939764120745952964355353589317556067474680987527548079297833539998258342242865222215681747969549869015697939554127499557081626950060916329896",
           "0.57668441862626054773920164705882295031880435874490231795930393597704964539534854834250638055542815083463738683146430082379073149079998953871974990605030531115748567904948229002538680465351816034414085890696196467615521969543006224204433997063527288514443404935419253943724579872472854300703798475966107579038880496698051818375532546368197809806544115496171522444187250876233927302975709248591908972346",
           "0.59199532940731223634617420193837196766186356068263223313261061480558639436412180991021350240470913092271149633483820904350945127229180169976070379470147429711011056203078210298313829635000565303787641997857930629432231274870246836108452732993007541125359738273485061324228778750531830069944570036169084871305329515261365955383178502917713214334808810726412625844210978481512366368025275438632291862785",
           "0.60709549694622869462483067245797028399468956070763942538530335526853282815406226053099893555611232739741099281199863420254333016184720313024881100010161759837083928797224725640021095785125988238992410296927225409984765886863313873892022531648958451940083661715815760806237878803609330649695132473889046508160482887768573723088361332267243452286610176948724186843039692112797106039213976473403724518188",
           "0.62197954576434335539696684219824327976988998993669475584026026679831221725774460365328908947620452777457191790806959938899059379387140391128845696987642418506611453321626607869801717870254836897328796165084605948086983949944714226464644755644542238083403302661596239269476252222614109836597348873471190787660391585694078779921390758232910639208518119325492789999941075221166054973249356136808607130253",
           "0.6366421773186640485920116318191204083389644098160828009666722635549477083039305904975813615643101060893999315509501318081025137289051787335454356108133761354485193083183997634369795655283340428506642872565827559825155045924936470784378552800563136355526499002558162019410271880717338646318471375684163442601830537613691628498474632262547856029932241457937391840960919415488213025664314613747543749464",
           "0.65107817188809080279752785471799265973958362274943758073000075578938519480042543196041314945170036193559782763524413154927612489597355144799562963417455961310886431794132437757357185377007718709790504976900339191552944965308823754898079933186431693664015814010551367365293786806527034958873669211570906132849013497458819941168651227792824572805777219160376304646562062564773441718051418178414899683019",
           "0.6652823904315739978766556052897347198651017349760138699519597733553278561013395851136458951983261597283585391502588949649092379467069209284755289821255744166256794329589771465045421874634188329764638118238723545310838064785644468083837991172367935880462068347034222894524074808990476036821633127927532229213401486467496527893691588255513769781016943243185567913995336109327864083859254466073492381187",
           "0.67924977641755138662041086036801948989088186294785002709809874961811116536667286127777672928127306388394020078452402417993836722984523906631302047812425809759286220237826357465064765092612104224837992075711035615650942777454297235908308024053950635657488001916036801234116581671119069849133344664024677517075723660642709275823456343659009540444032487248071553674961012055521740306092600444870718199652",
           "0.69297535762401272778114932738244728669670875114228232862389083194872888693112134130021641463393969624412179768291914405554577080353247136859984307940401373940521815913274464950964347624918449081645304540343160683388727015489772202472645406318288749244334156857814927405528763108558137488794292057315715995191324964500528600378291562277858608403425720078390497455476055579003286296442406491998525563297",
           "0.70645424790855122905182233963742667718470686911515869065744744473731249895412640632516625097411541437953942564566468313798077366853928608154168668667806938130662439220702019172328936889436324187304262248463334787504456805683070026006307765178787997020889111556678907849442591478755800698808480163225125777511828352357189284217101098738405458071150544253514248561787426067001460586251699075230390564367",
           "0.71968164894777168289159927814596788937422432901416956306230349431557362414856173295064125294878325237342190029914430775648665560145040598898117000971783978541799092281781000633902779626437866517288284324732827083065703448279654800632624171861777710582293639879819116932680545313562525074940809403693475624332169458744562386580074420532959714281903926902622613852892104465683714186704831143197300465955",
           "0.73265285194543608674851404628602868786755398311878599262050209465658337331457767882450516660833910207846986678480603058221329185506983962144302950162737505562091432645466997334653618075359372680522922578429510783107155224742867979206003853893418268095936450823867623873015528453108944563276576646508412198497923383466470895808777876544429706485835161864475122029711660543090876323595451165397047981956",
           "0.74536323930873866831066285008063416514858255428941319323031554151661731879818806472410911187787504167842137286019020264008471692607030872105020489874402631524823767448432915438225335869622093354538021006314536198469136634364850042715775621307965524560308901397550829610851125072518884822515926626213581949190024268711827023522012804341871590177804438418738255381261594827085100659777173578154500251787",
           "0.75780828629211358196731753685850074775187628883294491833833279769413437275246840580617185041212744084038976069700142887035937511309419495512390089087847775651833369173386038513330257480188204696687136231267595399438343156895032682495327740328291738325217778497473260463740600852973600297913238958828132336080624048815574113414592522918778477418427876829087439774857073733879539765547872800792711360592",
           "0.76998356260799010064124325420889481428942836988785464918451704687709959533402569414853910266075223008145347866420469852220997470992987183595134711278161994827010482478666523199914707457365681979989417199177427808129308850228595726632468139527316915481709465938257650120793934685421343443942356060396291075752713480402305699120964704579260218579751719693291565685728074939857101460901984240449471777639",
           "0.78188473400392189344901888012886357289691591193533323711550248487573232160560048524966536928562079994581390209192526509899176077393862245482807165569409036943146775931090958041945317489351020506180957959482939768275851398130892970557450783138983566392455270904228057175489097967314871299150832712632639718878702471658606369540854496281803565819545728647765960328269135853132407415684491934581417388002",
           "0.79350756380552895006859336306152006552993066088382163294295016384877329185292344719536879395060919553184640006473875955257330264813115929942877156894433233876161573894628944452740080653935089289153173836334040374431360850336851424574668632837338016740333716530963434291489645017931035529052587483629111178971917421121398732580060101294617212337648611654041575132820234403350225337355214099696493406567",
           "0.80484791442470288298134387731514331459831415420391927496917008531718727007136925375073869996549995938671025493755987802316807560672754205522916341547950527416285009447065632296220924964603370109747266700136618832767813938243784759073035555035361911772169687111972294262096081393656654067512785827139608367560009298721819281091010743363153063005841441400130721362346287552727162527118465104052539630019",
           "0.81590174883253870457705586780548750833668862852238889952372206236774966573191832400412494946116015154305873210759963247859431688393192829248700535837612167242633896627292821666890819736549652534738107012873094812825219601489880060491958385552979476621004236099490018887651186347086675381603801017940808290855340870383683075409122477045713172106217670870448929077822708030574128623585863036730829850118",
       }};

   max_err = 0;
   for (unsigned k = 0; k < small_data.size(); k++)
   {
      static const T euler_gamma = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");
      T              val         = sin((euler_gamma + k) / 53);
      T              e           = relative_error(val, T(small_data[k]));
      unsigned       err         = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = sin(-(euler_gamma + k) / 53);
      e   = relative_error(val, T(-T(small_data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);

   //
   // Test with some exact binary values as input - this tests our code
   // rather than the test data:
   //
   static const boost::array<boost::array<T, 2>, 9> exact_data =
       {{{{0.5, static_cast<T>("0.479425538604203000273287935215571388081803367940600675188616613125535000287814832209631274684348269086132091084505717418")}},
         {{0.25, static_cast<T>("0.247403959254522929596848704849389195893390980386965810676544830494398136043486821690984848527973792338327197752176516138")}},
         {{0.75, static_cast<T>("0.681638760023334166733241952779893935338382394659229909213625262151100388887003782753145274849781911981438190343146876189")}},
         {{std::ldexp(1.0, -20), static_cast<T>("9.53674316406105439710335272649306549801506698739838753888815787489707114648106832493113326022411646219016312547902694921e-7")}},
         {{2, static_cast<T>("0.909297426825681695396019865911744842702254971447890268378973011530967301540783544620126688924959380309967896742399486261")}},
         {{5, static_cast<T>("-0.958924274663138468893154406155993973352461543964601778131672454235102558086559603076995955429532866596530638461663378937")}},
         {{10, static_cast<T>("-0.544021110889369813404747661851377281683643012916223891574184012616757209640493425707075673894983216158293824238262832286")}},
         {{0, 0}},
         {{static_cast<T>("1.57079632679489661923132169163975144209858469968755291048747229615390820314310449931401741267105853399107404325664115332354692230477529111586267970406424055872514205135096926055277982231147447746519098221440548783296672306423782411689339158263560095457282428346173017430522716332410669680363012457064"), 1}}}};
   max_err = 0;
   for (unsigned k = 0; k < exact_data.size(); k++)
   {
      T        val = sin(exact_data[k][0]);
      T        e   = relative_error(val, exact_data[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);

#include "sincos.ipp"
   max_err = 0;
   for (unsigned k = 0; k < sincos.size(); k++)
   {
      T        val = sin(sincos[k][0]);
      T        e   = relative_error(val, sincos[k][1]);
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 20);

   if (has_poor_large_value_support<T>::value)
   {
      T bug_value = 12 / std::numeric_limits<T>::epsilon();
      for (unsigned i = 0; i < 20; ++i, bug_value *= 1.1)
      {
         BOOST_TEST(sin(bug_value) == 0);
      }
   }
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_sin_near_half_pi.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT) && !defined(TEST_MPFR_50)
#define TEST_MPF_50
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT
#define TEST_MPFR_50

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/mpfr.hpp>

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<1000> > mpfr_float_1000;

   for (int n = 0; n <= 20; ++n)
   {
      std::cout << "Testing n = " << n << std::endl;
      T boundary = boost::math::constants::half_pi<T>() * n;
      T val      = boundary;
      if((n == 0) && ((std::numeric_limits<T>::min_exponent <= std::numeric_limits<mpfr_float_1000>::min_exponent) || (!std::numeric_limits<T>::is_specialized)))
         continue;
      for (unsigned i = 0; i < 200; ++i)
      {
         mpfr_float_1000 comparison(val);
         comparison = sin(comparison);
         T found = sin(val);
         T expected = T(comparison);
         BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20);
         val = boost::math::float_next(val);
      }
      val = boundary;
      for (unsigned i = 0; i < 200; ++i)
      {
         val = boost::math::float_prior(val);
         mpfr_float_1000 comparison(val);
         comparison = sin(comparison);
         T found = sin(val);
         T expected = T(comparison);
         BOOST_CHECK_LE(boost::math::epsilon_difference(found, expected), 20);
      }
   }
}

int main()
{
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
   boost::multiprecision::mpf_float::default_precision(50);
   test<boost::multiprecision::mpf_float>();
   boost::multiprecision::mpf_float::default_precision(100);
   test<boost::multiprecision::mpf_float>();
#endif
#ifdef TEST_MPFR_50
   boost::multiprecision::mpfr_float::default_precision(50);
   test<boost::multiprecision::mpfr_float>();
   boost::multiprecision::mpfr_float::default_precision(100);
   test<boost::multiprecision::mpfr_float>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::cpp_bin_float_quad>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_sinh.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 51u> data =
       {{
           "0.33937643772780730649735035088117439284797964277099188367427256402032493952288848579083622213428182842627923924487560393743204013166230906610274533504451302298480596207257724471359936027198954417317381228420986152562253196896619001418292769103034561794393400788635610424360775622370491149170501475453034747306600304507650361914904138327962144190354572359428689767990353722392457982930942617983634601752",
           "5.9746833446871871874685235810964396457491766537010251792063372398172074828151074989468673672535421045923659313715467371148678693662985453590831122722616951299822923837410906027605763677066945998696776562438704017846907508677186762421899376364636371743116519071733413775650991880222096045615827530741679305666041641331859757012015389431793705875600863391408448065773828563483223117178640044499399723744",
           "383.32826140718915582837967448860824902040431804683461630967288341613741467095168380744762629948507973653220772087887989292128183196493611623766470283358542341824134250511562240487252437079958429586344329111208041197054162309164204144237855212391474938076935722386012246677813568519769393617755607372817372398764101401294149353978426057544810680225593132066193858006901125069663362991172745649465725272",
           "180470.88334757918167934673473709881208559849920820465419382707969109187448281704429118605409224039018180517847684905660962429505828088398660499158213746722168139372781263849989865384042531846290813274318773753295025006473736660333640052386121946183935053629928496714560749082485275242374067168149435272169334475060524974384307351757201698786200303374802146857634893509516262245925287553380389076772488",
           "6.2781497954189513207977998975338639259302378413658035459603622432839117790845430762753614618299222131433987986511235061633658516824123179660244932375967566163895461895213509376427850290780942550513918615228886566287592461085762554208269169000672149592375451149457664991726947185145469263932975075681560662428417041932848357447220175607720561540370653825438750168143857523868718856189519864027430308779e8",
           "1.6137831147508521132232267071463247985636947830692243664921522457394294988129666666745854084767325882717254318322908201512400243137564101564235450151960593110176457803621675408660678871179456625850704076654060872094257085919134755925910859520026379969099492921728083639989029675808598278170215911879751320574053132699172028082102336989338403081942130794464992491330850160862146024982135931859868176809e13",
           "3.065121004865094886953119667134247741359538615435533822684602797608029400610449009335078883525336625519599034934744634528257351124420564267197918749480389135525897886434344884370577475363556341414615470556433033106705280531443046669163916446454890662947185057748542735928453570069226294801221403438864013368364219717148075652123561545773399076318560221173734215703610924057158101731263882232550297741e18",
           "4.3016893602106215864771434464025735547192956887049374680649926707919814241961779812200280749930256501997849507695395125441756421661413154730888574483309057229943886742437071251707738990393977398403536175642762242808350076543018009682725019125106175929448866428526984370017465117236484653179596869643117790492866002064306593104169410537341890174831622159415936125041593936992634719906123727028419057537e24",
           "4.4608685929681360001024935791890661655506049487122331222491789265929503651540405036031990380918459104583255735620288691363060079360758406339887417913286769718423759522832754263499878135869223253358698774066131403822428286318351390574838877307934317251880890827523325360658275060099119902102399714992704146743744108968362755624325107486994088414126705458507082103811086372240878942983212662081104875997e31",
           "3.4181315955816806472569357441100390029536003312981931954091744304974491527743599822230006760631204302243855667216955365986192324833652299336285826148922073950348547795494738267861098328516497599288314822606511466743212319770180141969147554023326883651348621187276823849839283609071336923316655316828855943689100621619083822127788284160652232283630351386798636794979234576432977468152969056493038423561e39",
           "1.9352946282727908101414530212785249763640776919052480158881659190625166733449770912626442628329346416132299268886589920690636914906717492301836773331460154604580407945460359957380672599434023197425489039882987443681919056322268437224184910074985583829184831034293865504101338027818555871946080687710035062238789949143319550108801094190098446234092310048150477274502060870736716324117412815209633124145e48",
           "8.0964449511890098565841496436016431651692307764702784234901741408135381374668439020986470675941110923614446905696410406066640351065195237123718468440597743167713019447544827353458477844468727834630038609140168354634397475741840053079910210908251252223665806813131724262334693137656218010287981601097259534068903471812189212459231851835393208367369054618963204727992168556204168791513644815218096463093e57",
           "2.5028257092625174549175008952222569141816383637904981644379473858250736896174216539673733521627607209322019413420937570273676341726636306931304501320694017061891400181233108050930610234076339285157392030024769366663118692571469493256243952018705693924919037621083041696227375589264811876761430035546270312014570431860268644276406457398485042029556392894799022733858611415899182421526634018060028309384e68",
           "5.7168370213792649967466315312864179662895170192695050789061362839510836418124645968032989149068311018994324517420345278843446068634292140996241291031113395887824145000873531937856827299256489358571593850210528248202703396455363364446996158929674989959483681393263782486430231288067231095140919741928337466492665857902913114664767450432510739209971738097074002526312039248809036478310948111740897528204e79",
           "9.6487261169670031207955841899729386502708125098394777808615183927342163909284025992243201020435915122698808649711566042372911206942311277943247994427354130507790526857797833309691667375441761513692598664419973302444660838882173718713387158013802112502169254860961105745895124415352002289485483908952674562396552790441656755711709645516914188860464353624992313010889765422981069429049436524222321550149e91",
           "1.2032977660238608232537005158851668311089986235965463249220377778638489972355974848209035082333822309902237165042868213438627625544096344578102199846440476859557339736747791529782018329078191477783605471526120462726353510147373798347292650122930289404816748193194907382572774906323766342758092979989633448828636445074016110331338699464788279882402189027828261039788079556739180915346692779065476431369e105",
           "1.1088306081278288754492401130897590262404571813281460605683836139669281218442501421935533170636990866165181664561596333701204545493730707210930818738817252706131805203538144119244917164949716209095542194899833868499263375700313934257155600824601418042452138211549248837967344874095248283887929145923103153332810091693393888809653081365270947112297406471162377655179657693898463736926911943490619163092e119",
           "7.5499880591625965663868042832675300901799245732418501707646792135512053284835138294796976048691668315442427834949618514094329533376442442492757936744857569785450769927581802961191319878260712808001736830227501518832554201816224207300614310712430470538022948957433004823102746037654096845266998518623332118892916505020627868405618942429551700207476696585635930562973459491424179233918050890206232214765e133",
           "3.798536358006797624025033016530070695826982685154937173246022092345982280900791849578041210970037835270398289956157015064696375146357207576854029748413680946201805214954504282866534528711715039215051307866373994662368105368505465037259587291440042344663580680646178313958620437868058550744621854406871361710599007951099013146571208384054250556080476992977623024059268095813712424244902009427293468485e149",
           "1.4121319341572581270215359848706630542776633675711529687593487346259283960708095601494823112486631023721124235640943167173029348028743563902367757599140008654691320430919753414890689949599421028277624880392344132646738394546195638261279687543208503932172926275294218429086816560213399180179494004109164546844899632385177835442946174653663068675983237955855108059376913611877439522917217336109804190399e166",
           "3.8790307719997974510664339744260233373881096199933152202662556556779783775106563986911859526413282055258612522499767709123313205863879946518297779104337686883587019222829967005608205535314284003183828513113021722123872387036435113517356676447376715595408179555267871947671679098986651665719279348025058713817796876795915844151719103197410787508530261619841035613531487094949084263218956635085585632719e183",
           "7.8733605373835840397434523264038598405672829925651165847065668324385430746087633348848905637835428739401439679896923081980364912472282573695612463537585283007941057172128277340402716645674443632827653710173742423648839359547777694778576675604645880219833375227941998426325886558435214355022240854563558864080627758653439429917072753785194675103766900514602432580639079224631229479607396935864512990879e201",
           "1.1808262995038900942517891457926200063018079695348469762725520377876370005771518954251015338402886097689762895044056273430051256244413916763438966705458118354189107806216991150264176024521937328179762640422127608560103802431672144866013216405157197709788484197720057702118788168789816074560208078260433548283881535909071116553897893659656781376448427981358955547508806938614921874867135186509274509121e221",
           "1.3085817499987842655130548827168955655838432140245228169691892267707778790498773914833199368916114043966197329562444577848635313938483757629541576533880917215885485474416704968999200090496252044959849927443732134176975867869986011315975625868009065373046224716063168977788103866885720471095547385342868632018951910603936835789387464412366605713487321530237148912677199033012777178113821791621549557963e241",
           "1.0715308148006899161903881353829644069217121138682658034413051575604561649576261428568888094218620444635013220705511245290719605273316790249367622122178650529000528086055415007045458486410501636380119413632657994999412652188430063128470336817401482172580366374079331295129200936246446347832380606353293858222758687479612927181530236387227215663399410099251455256898414199913458340065553949424990477448e262",
           "6.483319651006309502237640505955012384293570932602353784849377890534620180296272226076424490097577093511886503973590409376477611667988893542117173598716788837179265384921201772013611631892729250835822804494742316330406688475091973437669111728949960922002370308207819760146543720499389938855072810566961589413895110830251224194598788696990065693705615156654866578134664648091752361824241438921952031149e283",
           "2.8985391304542768293172709775230767981477721528885408305355619530690119426207269563049756824939397157221877775531212262059946098575425050827283362457005503261796116156917077778477251551070762614233325253060283603452216492681531839154649232080928787066338399915850327381614672456102374248950210248266796072457623370079195574322846594267768883120374288952014885152055438195794090975578878933873824774214e306",
           "9.57524433627083921372674145950563946532138741951042299439035158875449060589509856903496678820625880407684156184675763001790613289835869844325821965070261880894138207436003366195024403902162467929095155787852409710735775347490909311196315332711680552044467458169615366116872469435840608534489425322247278926672059747911266981024366989976214521515026692183039600169984107883592297128416659318858313127e329",
           "2.3372734503362369375381009524197350830316472034721759761797536237738670471009423543542251572488229045699598160834162677357730620072441755506075897500940629883044875771104686291523502165266242030847074909362622098365719455332359938746138629161304717385265309980898079489959955157644566232440805137701071311495653330606071611331941246434767948905863368638163788562679785940566685500460815077065003612487e354",
           "4.2155879126937199240969909448599186868484717887298729605150033299123534992857332918168135230843738695925698383815575417820480732378749635394939513838137876524333991937836847074991505476867647762082587225838063325020413513077128321581439429001485977751765798011101092072613053687422983352140468569171564773941232256057064161142341661775359191159220450305300322654184921617310753474842253496677498824723e379",
           "5.6181811613375701248970224378256740494692066242437602652469740512738297599235414593999616891945156186827736326184687322137498447792007445397397290336810468925670064733464757082986791232916898141597610692740388799796632396708149027243436859752526805112778790645096555770227809873695589969805678601106157556386974221647669590827712353133603091803570183764883405340587430017053183637835511899658145649708e405",
           "5.532511069282205350923830187073466127274584467195468607886763750877294392993663821432158885753563495238131394373865428654052604326264330104646257659760161386620716716703631608643312613245804625511813964275109451513736558514977338129201153666764317441936156609643185133981728847167450887861106642311329612564652645663234240748195490808151911497393974690166034839217817023634217121406163178148652748479e432",
           "4.0256666306761331240653217136731531623017017695713942917027851762705346357330788586411431378972009980532310757689380174461664677676028378924382554201434975574729861177781849023768222381429947872325368088023224591306630434887529215459580760863075907686248521168590309636468448648513752893851767315693469638980874648457114335557202115472595647478331668869318302753802858726588719006447471192697846325955e460",
           "2.1644237346681663424601781769159797919834245365230735589058796985974745594485988855971413936820871935714602237643458356241187573307428309041919648027960168541647193436225977495680484218384107820095589356463058222584008532497069179993678533431131233629312850771528970443634604290143149079209513868130585713006080733488491160321145735562062411305931183571279530201672366980412430529846635995189699318073e489",
           "8.5987580981195983662047247216936066485731760315371506386077056691409579856014763032619539539935299716110411688793466397984311640631361934500807639285587334983206556915704635831992012926186843826981296831658998834850783404713050829093753126189556625095994621605300047199962332098857236359801681157419606676412198783092816364336047306243999363335004760439115355072350465422891365411868472688286678516314e518",
           "2.5241673163187127276134610716954724162270290228773641734420864618245211926017624829840685860130579257772126398622324109858115624706486522844752512951837805396709793171502497523431473021570806024043139443284538862368635312799539108264084028032731295487282188616820261689634926427135060887942797635147693849950058672753458576476491733064455826768562371858057444914175251596852571637211466017938478085247e549",
           "5.475067911823387661325942057081957044927796274441278042805014835144678321092623034147031518807063234976073102574257079170283458172046752719724152941316842521196069804425876507927418423409523739261726681120662097159943049401039490818332686968135012747332468921142470970507219403290422458185430415836291605355383658657658638112408092789126678938878667507151950931633694006471359998448912249374833586727e580",
           "8.7750549689950256776639468724574158629603320014390275681028674550826357080136422399476213432791376656222763800628593282303459051561266270006921840049305819767639184391149913915312831894296821356222752594264134130151457242713539248421883837353442181724530706933220158507240760325182068001553294949268596178418634164323874971937997072367419479635154591248667559627811893588163238012665671798461211917208e612",
           "1.0392000158337773273751156576416024664653679689973856373456304843339302977923254238376497044027728158058903302390909588333829463843362779584402914847447592731182614369968957680281500946805571235013941407979569788567794900810257154433592958167545186687137810101848000107335074486050959387974516414654638879740966175786016492797845169374594168995878543584318334800124941205910589727264397237600733483158e646",
           "9.0936326753636727240574546678839170665019169110943878894933093211555976995701468041449327370073681898690638466136204694745206283652338526673125958055131610409923286526192661778126811265116493171283319361595267283588121098349703951929669281966675596890266483864217591555707552765565756842701056144290075867893520379419521775913047964393758374891516340929062076304350159966063972713118995033247759001609e679",
           "5.8798281636930489964162009429009257867906792508058801627042121953599912951265315933723440185825519080102988056836911095299854840387008575164090793635997912930561430335216151607097220208013034399895832350235280120270626904356196935166701773768680311063264380891331021514518757839220818506905997847228783439015252768055166165941582030353226255576433910936297965207260585437762430381969160714956727596198e714",
           "2.8091881292911108404345975896815558958477835260737794579417284512413473388968057587088555041266297486841923628702282019643659456724373332519583025947015025975126598748630623031951723754960589046233996595466021913942587558326660593063197905288573353559106884645285531497626940379800500474282446929237914568534665868703742731713632349090897884403966643055728471509474896855575286123275564417626861566706e750",
           "9.917129372597671132067673866739246238179742417231064062960232866725337575281938597212073697168000155027158148165861617400080837699968785505107579831803685516054837447325150388867488754170677228096524224392410232206238263933144338637103531441623303187445874039234973380151391274490746625993568552049954630793219419614845431626975962881182662815760423226111647056071831411664335144052772436215105801395e786",
           "2.5869027163543111121878679987081647715187872826677398475096738640583659800068967379551376322170347537454918190603891312949716382621902484616361664158953484778255247083652726854621059785392022847887382779010079407502679229021085320675903109573769331277413372272363218896397965662581357886739691376204316908974081821980432178065394228926767529685562155837452626029223937027004015040825450642409597700449e824",
           "4.9861251931207080923785686798881789193813879610842675205361210155894774686328710893906543682447029206928934967525495260314937837003448878215156341411477636831113484416124080974502217578408248150338565305116223944900839866528622960352723938548713319425798453345402992146078868053263606234074443024155243450623634720912438841022969909473424559262711669905282193529250216454066716533180418518228387188393e862",
           "7.1012569014339068241101751233953234216522840280342406520909288232012799547871960723719836516359548198842749536961644100550279020276709043358260853581760590386456213180291689322352732545965831405519844109680619067101311180959399339922706596098526969148981173519865139508665631317310424178378833370605922449094745510812618563813537347841030916512147874232760564378443782164868016244561788356251308121716e901",
           "7.4730215360486642135431754747074885377840195683583018254892502245011973712084221116813364423492802080799768174534590613188275471080608467087354983850284805514875889145266688973752185071777341375422809910165581997555433091939959406569831183459872344778707098094941193489061532160249775856426569696127193453339548371679229676272663084782830276508737129506676031759345288056484158647796152349867328841634e941",
           "5.8109375364209112227579654658730977030869454388607076903639465992296616832002964138000947668837140543325908222688655359602408511410663722770167244801973012245657865182739637159804595049180263175014778215232564251739259624759589953677661356104554831551073263668188283861123521688445132164147762321111597028523130093864153999974376790494383016372210442340324038686843345053322425194077414241243050491297e982",
           "3.33875955701899627718146291382268063073604182131575843695486667154496711979350813988644889979275310892951143249901398447859083674739840084454465850475774696325142148671937407108540250845900941142800157345665761403930889797424808979569550325271558518404559007551625637761142662107757913763221912282957681784053564387104062317729788737215450574233690655931888608424916152893688106181220341997128198692e1024",
           "1.4174672877823334709610117319768830739080734407353905145632612088824955720198734996604261250019291955883620333545750761619015467840567122066622229379056280064206319780047687015558007624774062399477328822231085767309831266032616053065858739373818651687128093335640388513396191118537181280334430292439188737524362269789272308905723812818882228503013875816702686587035844437102478263525616196832018321602e1067",
           "4.4466189016791091516801723880812533528438597080549410911235655611382010503145789286158745555771483577943662768773465284793798720178177605712848440200402906836390133865748188969184005230383247111166918721449908133920663776952786683837038180436264738937354101153867171804315769471050303182129269442292354388037298125177941217926845803005587166270803697433886463469168814941555804311717400657004050157245e1110",
       }};

   T eg = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      const T  x   = eg + k;
      T        val = boost::multiprecision::sinh(x * x);
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
      val = boost::multiprecision::sinh(-x * x);
      e   = relative_error(val, T(-T(data[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }

   boost::array<const char*, 50> small_values =
       {{
           "8.223167319358299807036616344469138485821440027829633696917375433348917938654659351596020080036406671343718039863220496616e-01",
           "2.526123168081683079141251505420579055197542874276608074880949653019810769068593790606537020961198741487692473633089323967e-01",
           "8.342981744595282037256218647969712476322487890550784823763249893556153270975172951404094950587944959561849750490537201329e-02",
           "2.778135016068299789938671680845480653984976507019542653788637161116587306168290886761259072846829249121589698206609261524e-02",
           "9.259391565199916442789400306996794489540862711193761818262415211084389468754315525525896238827358889826875006042447587516e-03",
           "3.086424653287772358219607529932097884435043040527155440187640095572710676452654803730003577747633690318001961509535020849e-03",
           "1.028806765851002064810061084014826478832745077469708149635730407866217436751337520417458090265791086156438275231514030381e-03",
           "3.429355348425226988441198390119109217716503769838753365112550442738406326637684639052252898314646892490045395290022292013e-04",
           "1.143118429558603374406653541544292690548937361618336125287018361332072426474632105217297150810234138626767253281422813482e-04",
           "3.810394757818873406266877296641684693312194735341898368873067089928172619067423751257049691985638480762032673977695116880e-05",
           "1.270131585666421832817527834137477593266387525701388601975733237436369505733715799310429349744168792375082834509467436523e-05",
           "4.233771952120219947940459634636576539101577724347428305072378100562649548884420218224692461748739725090626754420296122389e-06",
           "1.411257317369659013704209000288436132710449162963127340562961271337242582661013580874165903770246169179192268836124421074e-06",
           "4.704191057897475365825409916786898392364235667906752767514580467152163619657508910797742266406961516358439252434955007668e-07",
           "1.568063685965773714045928492719360014894368531987759414833778466374819836545157375950693756664550256136222396871173634254e-07",
           "5.226878953219226673524993193392503058475862017726848548717100658392470633650387274004511940515056405069137033934323251644e-08",
           "1.742292984406408185991240874995689487745140228031202510923711784729440494088066989430128101759261047316736074663327672115e-08",
           "5.807643281354693692124967044009687283114597355717062156493618245876910131607338183944830908381903728560328284173507220743e-09",
           "1.935881093784897887701686451485601671131342930785061493703969418728524594573922282309665275558709040519461560600768780392e-09",
           "6.452936979282992955422916851920785543106383715381924626175995859924351552325880931187614903984801793287071578640505194508e-10",
           "2.150978993094330985008279519046512957825521218238790792201835497215534851989750722105234826300738623838446309250309905466e-10",
           "7.169929976981103283311786261663531258230547972690500493476881079295129579131280734024784107219045379345460886663104148486e-11",
           "2.389976658993701094435441884684454421835327948893136184573938864819002944442339456827931472237274353903634036758669394620e-11",
           "7.966588863312336981450798799860506345287566898810744342680146925029151178981033890759916168189916177504592939240995619757e-12",
           "2.655529621104112327150241298135440075805848488054800577703768668100658036999584228451100239039042920681377381394421710121e-12",
           "8.851765403680374423834128412864530361591097252230621965426275532533242581680245794741067906285298655116802944992368126680e-13",
           "2.950588467893458141278042461784956914687338675140497707333871358819185395356569206661450997145748756956497959702280685427e-13",
           "9.835294892978193804260141412430145318398649753331401112621871794012928366988233744354238387090649589382104704221708773516e-14",
           "3.278431630992731268086713799445120869198593899364655036314007566906378666339665297288092596796135684816883503781385164489e-14",
           "1.092810543664243756028904599641030626636532928735904320784337625844108091213506619051042206148385975354700234586478575025e-14",
           "3.642701812214145853429681998738987398752764686754626492252324567456938623579239392678142797020213493844816454129960310753e-15",
           "1.214233937404715284476560666243942169089106312534317920490462975351305354471020532764015606315872085933262687299655265697e-15",
           "4.047446458015717614921868887478923169619805517194433471908835726595116905187672132801369948377551282604828733616045843751e-16",
           "1.349148819338572538307289629159608313551890152969010184597042496758528297346351553643241208769191557898925543369605617734e-16",
           "4.497162731128575127690965430532015584807024576774799020494128293451281927637267192489558050090835454302448780391749096414e-17",
           "1.499054243709525042563655143510671412452985626833998379862387948592418229228808284088934491020852037924756758483008288052e-17",
           "4.996847479031750141878850478368904541825005460277179305602161748681654262243578435201096986093377131577325573917436618470e-18",
           "1.665615826343916713959616826122968174447164290616980189746184851537351248309665330601503343215376981550822569162631313560e-18",
           "5.552052754479722379865389420409893912541965834349657578615232567585047309856390957625702896178052275806406957076143469634e-19",
           "1.850684251493240793288463140136631304096139902769381795814754672989850701401641374814254071564872119933498619234778448524e-19",
           "6.168947504977469310961543800455437680289164351695283493312025632359317744715643192414807145394613572397590534364339391526e-20",
           "2.056315834992489770320514600151812560095228784236601072113743484455321300338926430301421880927367590178440922006775473367e-20",
           "6.854386116641632567735048667172708533650333231531203539518552950777817440179277823487619201513258000884052637516041835420e-21",
           "2.284795372213877522578349555724236177883428507451482660054557452824460619777642844796449091646418601791047308814504431261e-21",
           "7.615984574046258408594498519080787259611422468149787192854095139994568043598766360557598146279482678180281335390895949036e-22",
           "2.538661524682086136198166173026929086537140604567639372655275057673980680372673609490963070062819520295998328327889923353e-22",
           "8.462205082273620453993887243423096955123801934429554813185698344472203995997708879527322555715697860578416576045982358004e-23",
           "2.820735027424540151331295747807698985041267308484077168753311108116374235508697904826049959781116012127075951788533527897e-23",
           "9.402450091415133837770985826025663283470891027171945709804152456669015193736201020401750153196590359525341207466344738924e-24",
           "3.134150030471711279256995275341887761156963675682933328476437810109959425395050019306074135780459168092270327572635795510e-24",
       }};

   max_err = 0;
   T v     = 0.75;
   for (unsigned k = 0; k < small_values.size(); ++k)
   {
      T        val = boost::multiprecision::sinh(v);
      T        e   = relative_error(val, T(small_values[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = boost::multiprecision::sinh(-v);
      e   = relative_error(val, T(-T(small_values[k])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      v /= 3;
   }

   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 2000);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_sqrt.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   static const boost::array<const char*, 101u> data =
       {{
           "0",
           "1.77245385090551602729816748334114518279754945612238712821380778985291128459103218137495065673854466541622682362428257066623615286572442260252509370960278706846203769865310512284992517302895082622893209537926796280017463901535147972051670019018523401858544697449491264031392177552590621640541933250090639840761373347747515343366798978936585183640879545116516173876005906739343179133280985484624818490205465485219561325156164746751504273876105610799612710721006037204448367236529661370809432349883166842421384570960912042042778577806869476657000521830568512541339663694465418151071669388332194292935706226886522442054214994804992075648639887483850593064021821402928581123306497894520362114907896228738940324597819851313487126651250629326004465638210967502681249693059542046156076195221739152507020779275809905433290066222306761446966124818874306997883520506146444385418530797357425717918563595974995995226384924220388910396640644729397284134504300214056423343303926175613417633632001703765416347632066927654181283576249032690450848532013419243598973087119379948293873011126256165881888478597787596376136",
           "2.50662827463100050241576528481104525300698674060993831662992357634229365460784197494659583837805726611600997266520387964486632361812673618095785565596614793191343548045812373113732780431301993880264715023446550489842580232941386277966868361303367582384418115607849009560004137515027529165146122584386186492069906092666409118801573969725237770253874824784863348864259750658951309573876342725192688040202857185924973630809978452538550099964101929825864558813716963467480152897452330473583474775619896089188931497718648548480469365216002979523919601823809165790411297975297712884880166754700558630196824142164233836361751921305615135984170982837036342343558097687424487526178010922324284883919536725153974582825630336511862808790203551930088145604026487771415650048376723275094136806424717481635184471307383168191953698843723340165605500555063029823385865249561125896634362311039438867484401970215424844692673432572876116452243380115662703163531763018031226825617668891776095502388960424467990521700581770868994182958846287294933254842394882655811767896697230383860684402997328870793925904767307522570843",
           "3.06998012383946546543865487466779458212212931325292345360920786339428774168895114940961908166467541760759370742449261902703454294050994162164179758776674921695210543321431976582792749695268039936031183310664759907107096641183589015949857072626264281130269822115622663836956231385381805315027562932655928781117811850728886383553772535550181070778545447895443834405205758132853217474114166659516983365541988620856642054467498643554872029717170398214071471942791253118514487638811304670059307541182798357443181785843119089299569008318867284816553359946310778010700675312493633986577498099096587006610844378385188518085716548910095121883158502955712612589941408660542373794977570528185247073824741671612893506514342410201362222059007498227945177352958046758148141756202994673600560820713848287574799339070054752116909136251765469324207685490757710781971553227808407026035595494277776874273936176792674139758867775825077183338566625556426910971465911191049352588901212917090887839548860059100937478465817844825147395110789153650851340493729565322385491250242078198566481445683133486898404370694024388072677",
           "3.54490770181103205459633496668229036559509891224477425642761557970582256918206436274990131347708933083245364724856514133247230573144884520505018741920557413692407539730621024569985034605790165245786419075853592560034927803070295944103340038037046803717089394898982528062784355105181243281083866500181279681522746695495030686733597957873170367281759090233032347752011813478686358266561970969249636980410930970439122650312329493503008547752211221599225421442012074408896734473059322741618864699766333684842769141921824084085557155613738953314001043661137025082679327388930836302143338776664388585871412453773044884108429989609984151297279774967701186128043642805857162246612995789040724229815792457477880649195639702626974253302501258652008931276421935005362499386119084092312152390443478305014041558551619810866580132444613522893932249637748613995767041012292888770837061594714851435837127191949991990452769848440777820793281289458794568269008600428112846686607852351226835267264003407530832695264133855308362567152498065380901697064026838487197946174238759896587746022252512331763776957195575192752273",
           "3.96332729760601101334502876512018303152235975639619479270725806219673871802657165722877418785963403123274056479329535362288655768235647487599476465537517349983459959396942125116402730874711739662452418728544662333652033991382097872017643021546533893998444782653493302314148486254376557154660429700133894837513481248619445021033294987995072089685196890751303705448870314051631971912137432499217943513505107459328579034234471969034380444279483175756904340168935694146646969758408612915912693951504143726276325727089094957428376128777490747011483653095038326498799910297470352498638922548951534285262912166233490129232297588127154122989932582549543207430381783967345221251717788180706706197608063733887726205509696294918128904282730298886608490931339746624769514837195042182809390984886538469878790432756760740967852006981627342718373868089930899834470763073879097175124340898791818850834951894187606842759251386865815997713188572196024482151907891258713869124247005410786490332294268446455782911914942752568277824622418634516620092362780994044583559067632108995042187023154200764184950878131638370936876",
           "4.34160752734960595617808776374477460723265336870727556185727396662220923171777437150069768940869308257867815441035461967651472282081172615279256504443662226606580627885152042042903335792297058916252842051925089290836831715454034263505813680769125291515266958692652530407528011558306762163905143207811598688431871170088962518292286615299738096190444738533203161905492043851016820053962091086343470680514156330656554108208679889001485483033545415301817702473378043508312559202170115728182897990337699623761986171416615021158179762123766012269021534563660979972864906653441725316241881374716900480598276640840394699718984639649897058274667150152948516142801074260038108590401332448730361188129358652703927446859710621067457990618378017703891730724396666299819790072397688972686459430503026856861736069218065420528347106866972580915029753621255304587561985717307629932540410639210302482882847873727015801634901755832519840544096758977294231047035556754992897011888753217953080197537610448726652746992121685068257440261763964980703424121083058605934982281210054435774069392790646709404966217005552197344493",
           "4.68947209983475140722248849561783002846415813208241069816339837584532567997445983205028355189765592648498726557587869684603896433394456735512692292415879610033794342501630732934996209978740746985164578019897211786300244708711916089199260058311084265831293902281791295846169702839730909351250374703986364508165540235333505281067384239291594323539816814423865582516577000094943855922812941268841597446572000848645702560088494072507948045804364964153467630734509663721026050762887316466331441449595084971862668493255933265611225629677595775797966272446890047531313544059153687362017301654537115283160575298256857111770084802622759507512748413868494678293024737576577634559012937002405564693237564782661478500575417457048864770102766387138956802222948987452086048547098754786648793023622941962569186040944009281487954082049335826413270469685003200962898734900372045181956983558503256265211391593721293841419380653006415407706145131700572194167555007645631927616801157793244790467083152103173240943823769137606544644820547634530641496507929783339735192083140914072272339899107017006649210880028740845785609",
           "5.01325654926200100483153056962209050601397348121987663325984715268458730921568394989319167675611453223201994533040775928973264723625347236191571131193229586382687096091624746227465560862603987760529430046893100979685160465882772555933736722606735164768836231215698019120008275030055058330292245168772372984139812185332818237603147939450475540507749649569726697728519501317902619147752685450385376080405714371849947261619956905077100199928203859651729117627433926934960305794904660947166949551239792178377862995437297096960938730432005959047839203647618331580822595950595425769760333509401117260393648284328467672723503842611230271968341965674072684687116195374848975052356021844648569767839073450307949165651260673023725617580407103860176291208052975542831300096753446550188273612849434963270368942614766336383907397687446680331211001110126059646771730499122251793268724622078877734968803940430849689385346865145752232904486760231325406327063526036062453651235337783552191004777920848935981043401163541737988365917692574589866509684789765311623535793394460767721368805994657741587851809534615045141685",
           "5.31736155271654808189450245002343554839264836836716138464142336955873385377309654412485197021563399624868047087284771199870845859717326780757528112880836120538611309595931536854977551908685247868679628613780388840052391704605443916155010057055570205575634092348473792094176532657771864921625799750271919522284120043242546030100396936809755550922638635349548521628017720218029537399842956453874455470616396455658683975468494240254512821628316832398838132163018111613345101709588984112428297049649500527264153712882736126128335733420608429971001565491705537624018991083396254453215008164996582878807118680659567326162644984414976226945919662451551779192065464208785743369919493683561086344723688686216820973793459553940461379953751887978013396914632902508043749079178626138468228585665217457521062337827429716299870198666920284340898374456622920993650561518439333156255592392072277153755690787924987985679154772661166731189921934188191852403512900642169270029911778526840252900896005111296249042896200782962543850728747098071352545596040257730796919261358139844881619033378768497645665435793362789128409",
           "5.60499121639792869931128243386880089385432377521078326495835339365228337765188797433638433752458537394171467057445629904555420755398315175666449466777454516186127276489666213119783783503829250827797595051437870440938931280680358959301715436419833364761665112542860561623096658225538557287000997305661352632293104827706037023135997795899396723258283708659284220534304000728311717413345472853792896822724499122866947121737000944102509490771269197783584170349935127887498647119562411695900883847124507613781432804229894058444676290534036738474342530360927632101836180145945813951643250885687876144098262191352431818136969137533863587873139725102593606754797723773610593636883665209271759639631465381618953021812982067002849796433240989364353192362974216155114226322430340671719312492223369487631048057665757861195096925695551107847621963544401115555199917577802008717751423237289036673475431186363543556380872803928482717387196307480474684969943012499128760245113496312609854517190311704797289830560651678579059756085781560282375298034806741180400732788584921019507521738918616603376508365622727087150932",
           "5.87856438167412823505442087789707097199843492103867437517314210715732455817816855246687780176492612349299503748836474526021467611461493586217913925495851405816296682706960791383913340375739628111898270614813266755200083564799407766788027485532332352024027224698199060815938197172865670956402289304658624389748945536687871488565787601288863899811544146566179125054361345491299666333144296548463580152591320203647485383402648565396566035890953872530543987300700877916661520962595410666627445873003711787722452859856569260494472375128936533790154715039734447084354515787738062350432618897439009684320850395595213875985248081961123885179420668160222435104348738172793787396737481265016580386986993101160673821650068377182350730255005754757604683510524357896861879706617761317908260663342673848298530050583191985919675390877532981022238129601627016291632330926779809631293070560375804444455958596407594955858475081851191996245268822870776361657887467004531332263395611291120089229481068789229695018187723686024313640325575962035428327239557079268995825494033666401736558372076816062703768818475224366442780",
           "6.13996024767893093087730974933558916424425862650584690721841572678857548337790229881923816332935083521518741484898523805406908588101988324328359517553349843390421086642863953165585499390536079872062366621329519814214193282367178031899714145252528562260539644231245327673912462770763610630055125865311857562235623701457772767107545071100362141557090895790887668810411516265706434948228333319033966731083977241713284108934997287109744059434340796428142943885582506237028975277622609340118615082365596714886363571686238178599138016637734569633106719892621556021401350624987267973154996198193174013221688756770377036171433097820190243766317005911425225179882817321084747589955141056370494147649483343225787013028684820402724444118014996455890354705916093516296283512405989347201121641427696575149598678140109504233818272503530938648415370981515421563943106455616814052071190988555553748547872353585348279517735551650154366677133251112853821942931822382098705177802425834181775679097720118201874956931635689650294790221578307301702680987459130644770982500484156397132962891366266973796808741388048776145354",
           "6.39067324283344282612593456066836977441869915362953508565729525367923342752058036792717988019560288813706968456779323116609349360225813396901702110619796078057334552019514797946669652098699860634363540091309264934180808145340898043417996593792792270890934539784162252743214627553825160296688912049057995757459733133778428381528832147374042143201083422723391419017423476330077549613969668943960552183346770788992856348755201584958184758568943497685412776464637452851023132948222137176500877587016169499594616364239121570837276604948806785595382545249190023683014214186698190428219840682236280784558646634466507658233281348215201532077497422563499058676631131322841280086826370841460898715011137512038685864392079526912553523177019272440755510704279946872616455555313590656257840391404433847924673482299505689689769822347893968864046186358674105429643912021090605610906309627700793415194628412350783590691473324467581637253579290246840759262280795786394666829277098636383739586574194509405681992353099095656288666217128758044223382834658781601679058686559406948665993762673723079305381020139309264407402",
           "6.63191504395654222093463225517095044257167358492883535520176025342395774211712657468200830942121109644363941340107615485128085049415855416468332623498613542536495098385995084442339062608583978638604918143347913056760626947758803721255941289939544782980624105947726287394246015934530636662452762740891034120692720860989191872617116876270993379145692068344563800080161568845297279023268580882621139265056001709415926357601143767499984660052292050156852098465716279953503805000122483365981348049448669145674005237424902758331184292667285733831838736385479377968893647208473593030642721808734551034183742049017463013327984017500270415348903044357529006803230836576763451403141885042163557880315832238470993889819388689962997828261446921618788229788339158160824684571810429272556119989956914418082964164895325888955223056217505031535326694543563995771654860377141087298652099371042888622930700365091746883791244230649741108473410207660026523417093735663777713562847430184433298925557785602803469943746593977417910571201562354064143775475359422531818578919533441219169564634992179085747739421396934533170253",
           "6.86468424647826745014070025117717964024823451584566770298700199608686799810550334183271384036184024738713075357138304363500729701192009148330990514337822154917664169841019331985106373480242557119822580196465316734207821863081970176402541887949909079651180860550135778414330866329785285584237686124445664832783599634024854488870218943262246632754953077685614238917113547631797236909830439953169012672877303232625810370072296875077876422022480554261365112845624378648826827015798512264531843127157809664230543124721508342792582642801227649598361094857362199437229919720183995231808663615464777549808840564458629976163064258768399634097749419103019327558046204392219063653339901570969874642832022669018679996962548734797438261313737916279431144129292768130662584134756962916924264725125780137451698441993315631510366262043104603857813311015159104411207656587159892683007990478175317339407414253752547566811439103970532316615414849940518882874013736359501398823560697095317586441184708051608329999378177452455843424936412317738990534790002839870054268627101977849744783551897006721190846394315014179836658",
           "7.08981540362206410919266993336458073119019782448954851285523115941164513836412872549980262695417866166490729449713028266494461146289769041010037483841114827384815079461242049139970069211580330491572838151707185120069855606140591888206680076074093607434178789797965056125568710210362486562167733000362559363045493390990061373467195915746340734563518180466064695504023626957372716533123941938499273960821861940878245300624658987006017095504422443198450842884024148817793468946118645483237729399532667369685538283843648168171114311227477906628002087322274050165358654777861672604286677553328777171742824907546089768216859979219968302594559549935402372256087285611714324493225991578081448459631584914955761298391279405253948506605002517304017862552843870010724998772238168184624304780886956610028083117103239621733160264889227045787864499275497227991534082024585777541674123189429702871674254383899983980905539696881555641586562578917589136538017200856225693373215704702453670534528006815061665390528267710616725134304996130761803394128053676974395892348477519793175492044505024663527553914391150385504545",
           "7.30801444381621929576410414169825272457257572273051004511973439898925887398217614148081823016200949202834301901341123741998769012029715026961550074765354322325117408706019312795809700115432061001422232366558866090103569420172751971374783210350559722862260759626145820691043338967446065368729759698186882375361190232710825561214648603121419802078232806394885971508914082308000592725279784010670779537521209568997392415395010518735400320816396054990550737425086661554419518324971399666539322809263579915158239535250650034449433728950585403021312904469201906868572755498527768200566105436948987083446413896510763908286033307148367944294928994814851182637242369700047960905551015550891703778083820346244133873451184266447103836670847395501001367479270898875772403881434563877248062713559640372882766006167571899610660259996723172304669594755157014583499099899215181509673430723657636479581940652958938443019241663200400679385786760329883423015546482354218805580324551932049528493376425537320109696781135375077474891741199783559527857010245972108769520093587637938249980386334004821761518122012885593787752",
           "7.51988482389300150724729585443313575902096022182981494988977072902688096382352592483978751513417179834802991799561163893459897085438020854287356696789844379574030644137437119341198341293905981640794145070339651469527740698824158833900605083910102747153254346823547028680012412545082587495438367753158559476209718277999227356404721909175713310761624474354590046592779251976853928721629028175578064120608571557774920892429935357615650299892305789477593676441150890402440458692356991420750424326859688267566794493155945645441408095648008938571758805471427497371233893925893138654640500264101675890590472426492701509085255763916845407952512948511109027030674293062273462578534032766972854651758610175461923748476891009535588426370610655790264436812079463314246950145130169825282410419274152444905553413922149504575861096531170020496816501665189089470157595748683377689903086933118316602453205910646274534078020297718628349356730140346988109490595289054093680476853006675328286507166881273403971565101745312606982548876538861884799764527184647967435303690091691151582053208991986612381777714301922567712528",
           "7.72594721818665232400474478573212164113820580488963719814529844615257171391366083837598391841280737832475169393182272541886671862529201489762301217381727573506969107619318907033743713523584964748522235434860386240308259592226625308659565532071953554996921178294803994916620561170523298903408385287659414301910401193614716492481152548641726819012461794117027835912991336708840836650710281453954679059886797070453447940199379600879845764678851272615250256962113900000364647452410778972648375707943133926939195015381201426487954498462993056064744870715359730063675217952027028557542103700913113678148959057734510658771520791956879881016752781141774540974358264943959912543543231872348745595316009779251124673800869204892703157616225827295653493619371958957677652500482852408284671621135986394278188285088465620289846607059129785050607459357597788813170941394726408533348925805369815717709891710786025165701419078226562572328981485933748567540138562641027503508306197019193198804817270177795577482266694943462207325431350513542160949582976461379550638607760760045294712529920901600994240565773585313185966",
           "7.92665459521202202669005753024036606304471951279238958541451612439347743605314331445754837571926806246548112958659070724577311536471294975198952931075034699966919918793884250232805461749423479324904837457089324667304067982764195744035286043093067787996889565306986604628296972508753114309320859400267789675026962497238890042066589975990144179370393781502607410897740628103263943824274864998435887027010214918657158068468943938068760888558966351513808680337871388293293939516817225831825387903008287452552651454178189914856752257554981494022967306190076652997599820594940704997277845097903068570525824332466980258464595176254308245979865165099086414860763567934690442503435576361413412395216127467775452411019392589836257808565460597773216981862679493249539029674390084365618781969773076939757580865513521481935704013963254685436747736179861799668941526147758194350248681797583637701669903788375213685518502773731631995426377144392048964303815782517427738248494010821572980664588536892911565823829885505136555649244837269033240184725561988089167118135264217990084374046308401528369901756263276741873753",
           "8.12240393759049993775056085790344905374064693901884539671441829845338578772903259406144188243219398035169276840513008383162269420554517811059936012081975520344394583550625149140104890709858952675303897227339074601057818074118589698571155136079180679720382723235231538458633009534010518571057778133890494075838487054606092393806209145857916456072372240571169803355429160587649756506023316970860684505132706954885924145348134169632738593180936266392964765757145617588713808060798434336980045883860242149289652316891255507207532033909817967022156020135008789172223827513417867030366597530330645580768779589871599830015247516272684746457878444123615590973536303130500232072733480785298450742941376024222195955073652956648240243919431159576650278660779563988680861574614265500071902828098808112054130736935301171188377689518808421589113550324566036499684989624896195759485888011688106014339156094756792157734665908674538715149602342862415095116193802949560661722409343540501008020488626114518430540516030303410754550714099923563850234789351977675338732716128448507828986158960243138593921163553099984790877",
           "8.31354547584695967940566378712267275288624539467359186240950261388420109063530469298372814586792322543394723656678356561805557643176058539909258806409526952143256265316829288574367192300134911326662579540672482872991356622029261017993364337446668505438648868283461277399259103747660496390168344220787056266691284920945026070198958124599742654165567628853365640939746555309453490999458540074120276825684247685153740702582674467303878126564742370625497947819552642763989933468008133993752611603522750223144711829552595043853200184607806501342069297514482919782863001913353586468996478801683403541333200250999752731449803793607515150980663437341133381305911283161078249341037269510562017916894714417589792091216017912110414165892331827272726552875986295229205099562827308056238370455191631964062828836731217300323551683849308479366652512262425881556198411502851577353998426212961146886854599036602811970862235743112454698389727605325232872049778977783694191972600155385422071256805381015864689257913905946358386236370406339271062529911829230871245337410607604318231151206871615890518289557823950960924210",
           "8.50039005178969681405606694066857144339871874464321576831825225912653747873113563539576206921739603496466768191005963101509608216565231580166435976841183722328004091691395570837807106693569643325702021135074219386315687196397182977310724857959339705673410615655661738050498092907663921364482163693412990352699674010982361328463115845819153103736613515518538534444209396391044515527047534370066166976494484027905402462724778219101349242704419346472667550031765101749789603575074461809215731212887738126264415774177469700439565715044625979289026800701352092929127409916129794527211068956300531815748065200493298365734410099333662178356881545890691882401846675346795963611125059579096807842008824231421616080054119488676338739204001665175181321425845571967990452486774866455322197409200481385043451140315730188098217149173808292210439135828385844496694628703028478095465983540068867270220327383626367373083798876294946716176284955504565982296829544751335108774407823029718852800476212574258039209896227934401044333736396538381519446030490401670705477490565602459130058989097840050168516571928831986962913",
           "8.68321505469921191235617552748954921446530673741455112371454793324441846343554874300139537881738616515735630882070923935302944564162345230558513008887324453213161255770304084085806671584594117832505684103850178581673663430908068527011627361538250583030533917385305060815056023116613524327810286415623197376863742340177925036584573230599476192380889477066406323810984087702033640107924182172686941361028312661313108216417359778002970966067090830603635404946756087016625118404340231456365795980675399247523972342833230042316359524247532024538043069127321959945729813306883450632483762749433800961196553281680789399437969279299794116549334300305897032285602148520076217180802664897460722376258717305407854893719421242134915981236756035407783461448793332599639580144795377945372918861006053713723472138436130841056694213733945161830059507242510609175123971434615259865080821278420604965765695747454031603269803511665039681088193517954588462094071113509985794023777506435906160395075220897453305493984243370136514880523527929961406848242166117211869964562420108871548138785581293418809932434011104394688986",
           "8.86226925452758013649083741670572591398774728061193564106903894926455642295516090687475328369272332708113411812141285333118076432862211301262546854801393534231018849326552561424962586514475413114466047689633981400087319507675739860258350095092617009292723487247456320156960887762953108202709666250453199203806866738737576716833994894682925918204397725582580869380029533696715895666404927423124092451027327426097806625780823733757521369380528053998063553605030186022241836182648306854047161749415834212106922854804560210213892889034347383285002609152842562706698318472327090755358346941660971464678531134432612210271074974024960378243199437419252965320109107014642905616532489472601810574539481143694701622989099256567435633256253146630022328191054837513406248465297710230780380976108695762535103896379049527166450331111533807234830624094371534989417602530732221927092653986787128589592817979874979976131924621101944551983203223646986420672521501070282116716519630878067088168160008518827081738160334638270906417881245163452254242660067096217994865435596899741469365055631280829409442392988937981880682",
           "9.03777677270990269726949426172862835196387072970673604230446563698972563128792797577778210699007499500445574250898762044933778750351774122552995617564832932129894429850247153326323323596747185514513829114667599621242841895828094634599104752390660626316359597361160805506977060785864672892966797271805786612860244448725471833865343085096665002696889160030343332226214610521511200144375391579536397373156980251473081426535067176615086187889982851260244145348339114794114481076655003899438879933457078775812975837503314934547103980296764470525861438620896571785240248887907778823513254337650341006992728965834432443948838718849505116031704247005966435163013464172640987633315418180257980416126510536269126886862377598402609093638096342316879109441931256004415158100347181648434500606990925357893191947800032622820087068319734681796146574385134374500536260087114364120328174363307505811192446227573869975931538764994397186624871438876822552201130556306754697296734741569342977980309931897617697257730057945805570021974106384510091603635687409774141632668637120038927426728226929784072977105651339473101367",
           "9.20994037151839639631596462400338374636638793975877036082762359018286322506685344822885724499402625282278112227347785708110362882152982486492539276330024765085631629964295929748378249085804119808093549931994279721321289923550767047849571217878792843390809466346867991510868694156145415945082688797967786343353435552186659150661317606650543212335636343686331503215617274398559652422342499978550950096625965862569926163402495930664616089151511194642214415828373759355543462916433914010177922623548395072329545357529357267898707024956601854449660079838932334032102025937480901959732494297289761019832533135155565554257149646730285365649475508867137837769824225981627121384932711584555741221474225014838680519543027230604086666177022494683835532058874140274444425268608984020801682462141544862724398017210164256350727408755296407972623056472273132345914659683425221078106786482833330622821808530378022419276603327475231550015699876669280732914397733573148057766703638751272663518646580177302812435397453534475442185332367460952554021481188695967156473750726234595699444337049400460695213112082073164218031",
           "9.37894419966950281444497699123566005692831626416482139632679675169065135994891966410056710379531185296997453115175739369207792866788913471025384584831759220067588685003261465869992419957481493970329156039794423572600489417423832178398520116622168531662587804563582591692339405679461818702500749407972729016331080470667010562134768478583188647079633628847731165033154000189887711845625882537683194893144001697291405120176988145015896091608729928306935261469019327442052101525774632932662882899190169943725336986511866531222451259355191551595932544893780095062627088118307374724034603309074230566321150596513714223540169605245519015025496827736989356586049475153155269118025874004811129386475129565322957001150834914097729540205532774277913604445897974904172097094197509573297586047245883925138372081888018562975908164098671652826540939370006401925797469800744090363913967117006512530422783187442587682838761306012830815412290263401144388335110015291263855233602315586489580934166304206346481887647538275213089289641095269061282993015859566679470384166281828144544679798214034013298421760057481691571217",
           "9.54495610016641218053318050888027529952710202531153199575774210745792169686775867122286336893013980770883110393522762476818358876088129524710547725582400752350379006684967820956995284778747313445279111803934019554639715103722176378053227974233654201464826899178346960385701319012743023002834221825212678330062853593931422954382790959273783367681208829081125750296573583945273785727616528225035230730367043489573228646448365807546311686441424497747445818035366984113867781703025697773957490231025374107987159920796065423503962296590063470579872505263841733246548152591941651333013912614638133883335123920373070975004252305213546254181990284206802141740422901313199964786740911915995115427439794642825914605300283815175742959582878011011823566253034650282755730842497543625168601556462908567644285914941630229285900004349592874758990965409149767611455899099763319215107166406191621967564685710927764812630422088568711352107239482256315420275932243379732104022438119314824626037473517483829358567542790510299355289069031782291584296420055747908391149240325877115257851162524812619999740512151814664737655",
           "9.70812956277849627020013008432023090142391629970752953381907255677408677683608283777972133699852226057384221251532058096143107203837634058545789370004650021408813594346758795590127624936380909477521162346782666694927945494282229717053636144889370566148233104188061190841182087686652430168640066046228725465172358875908141846376474355637636250095973439621439980693326786799959495956257525100473767694685408934461084692899974993028686930219291782447513786152395692604500383372485738542065647909407318214440351068221656470065118040045018410800167501279347597149519022186563837419966281229875188530501814945342053480368694378460223735611289594593646472862387163956627509412278526670700766402504793826839677765281076427340901353768173748184477638624215647772178191872811543334258915265427131978394362810703976093768885428630849932102391562462424663355002600929871388002261215265969294828417306845017134019844876207436524153517810279329274165301203983428519852972984397790790147707779427760025639355001932966608597649497333189984495365421369654196836993842047830874262598283161232047618963368717192374581237",
           "9.86860538583256911820721127887475338860580572014113804764764567126280797502596779665406841324694419448453464475175038076268453561722477590781196193451866802150809759490712608888093911291954287843130175265867101964469755453143964084226755674039351003953563412948117884754289084798586264882426396661496381950383124624978217697985543751868445611832757526512148116901823991753587937386414616186527759915861182575983960867544511432164162055576224548617161606250500799648602173880407153261952724142638011741327947253437647196929757560958075420545787575757761080599830662321444781770561880447820833072140574469797429581558718245198502380676502327269925525873736136551448095090807729668471638614047172598418830416390391932045518785962567615347617805861430300764479148941742520703366317243140861995853488523921623877514753981220597859917397820846973107706661150411207144792858833362409021546109104485305007696344300462841655088641041139133938632803072811438751371559900802700904742289494188612587210415338399019832109459618353269954649298194490921810882187710461971651611477483705188781040460993037832290727754",
           "10.0265130985240020096630611392441810120279469624397532665196943053691746184313678997863833535122290644640398906608155185794652944725069447238314226238645917276537419218324949245493112172520797552105886009378620195937032093176554511186747344521347032953767246243139603824001655006011011666058449033754474596827962437066563647520629587890095108101549929913945339545703900263580523829550537090077075216081142874369989452323991381015420039985640771930345823525486785386992061158980932189433389910247958435675572599087459419392187746086401191809567840729523666316164519190119085153952066701880223452078729656865693534544700768522246054393668393134814536937423239074969795010471204368929713953567814690061589833130252134604745123516081420772035258241610595108566260019350689310037654722569886992654073788522953267276781479537489336066242200222025211929354346099824450358653744924415775546993760788086169937877069373029150446580897352046265081265412705207212490730247067556710438200955584169787196208680232708347597673183538514917973301936957953062324707158678892153544273761198931548317570361906923009028337",
           "10.1819721846243116158211195253926465666143347779815073047979911288728454119358550456874471060202706503091805338588626998024526166707650425773136658258074400903070578475129191134262714581830920726995815514653824789384673555040322558822640155690142138250981661144460598431698331929864441089428405069965236237150722105664811612049206741649626761309984600129580251270318577455853101292940548425839036066861121228690420716119923444705834233799961792271274742610225908970795751081615038981535248648458311885095799828145600663740483135495656806225462943772037314913924014868167062651948437081797920497967655996219852832742745294377907352391106793565373082008386931837077219804533025205245429016269305924868300059131465990367513110617768155977075582917392828200481639719171646996937843435515414397834073681939587838302796801187221313907962667869992989319909211964361393188990384040622902615977028693735275429763987359474700539603288721055646644016768647749162193038655134281042688011723482785471924105498640148127126652745316007086053077591814555887669601195725983108276147651242913586147914229810924624624361",
           "10.3350931404633683691947436472707444709708693615480182604123950370334349544443021679231379500921649218800863593926760528756661011078126321844492668291462478393476503125536591219070509735210428947761875792828673301887541398513337078226608138436426593790404989932058023039769630384800611394806279966525193241106630459881453504032664228967399745528185257298594581458987077801324925958107100694837096169968690367946833033746754352596262639045628825434791015203759110279895685375377254959267384242428992179590079538654788434703331515082118259553412887391533698850248031662366010669929529784194795489078820235616519309873494295540734349932360576182477685064907138632368679604675882383935711506161826635113153997912713265877050477273997328780264216580134895532814312026671290109568535316587756940503116601114428904476514966934012890148992229020985082631236739332830184773141236150086303025054599442020885304151228567409725486746114685532611428843970696553723054870710919524255238928541738356450696516302034137957025179252274911492305284875580251537498242752152958407117066303014561567387290966125697410459079",
           "10.4859783938191844505415935988555812169983910386669556187311537807971601489415184480294324534243750962935064587431065554132339655732601450466677346771766404683525586939467074949776376839516117900277707447519492965025773007813570350841194233890993183787851607015508682597768217867560501711087754801339252398186169563368609851974003387177803015256072875765438214167126280799321733391301521412815249368328101551446918784488181577223454487520647934057527710710187315407383842241034812304414618212426764289725514443697625658320934830119552552349454613146318727307440539214183275364282577270889732517818803743197835075972826771689559984211698450313448053374104683526842305753510193148049529361498811259623906343956382898276922773672099874559380274456904526382655867821184634279087424431765532414870700646132525635436192820560367779661664927428988733468931949806424994253052465407314901679252685856376776344476864227019344231976962348967817311235507614203388405955265951309377513783090550287722753128747261754207014515315881341170594023794216162541770211605362973081229737656368414853828067103315720270750873",
           "10.6347231054330961637890049000468710967852967367343227692828467391174677075461930882497039404312679924973609417456954239974169171943465356151505622576167224107722261919186307370995510381737049573735925722756077768010478340921088783231002011411114041115126818469694758418835306531554372984325159950054383904456824008648509206020079387361951110184527727069909704325603544043605907479968591290774891094123279291131736795093698848050902564325663366479767626432603622322669020341917796822485659409929900105452830742576547225225667146684121685994200313098341107524803798216679250890643001632999316575761423736131913465232528996882995245389183932490310355838413092841757148673983898736712217268944737737243364194758691910788092275990750377595602679382926580501608749815835725227693645717133043491504212467565485943259974039733384056868179674891324584198730112303687866631251118478414455430751138157584997597135830954532233346237984386837638370480702580128433854005982355705368050580179201022259249808579240156592508770145749419614270509119208051546159383852271627968976323806675753699529133087158672557825682",
           "10.7814158709708600973470860025697540134833131069132002021875135200480437122785122611113481677522707878078270440052147356092727695527920302171183192478655274869472668345393510398722323555179529207792958553208776624344340893028683838808544904189559530608618288330229561660785494464076778823090275262667649435818366046674470097351430635081878043122218079020162033184280808128488592626175069016310564044843363282384351603178223984429085151346774445891706273636784622362866483557972819012892787057761108736681050757369877123799164633273904139629258646240624506200184033024483531204256854941841214015611888414080581230610166978791113905519323893487804024647095097676311979368148451812686908830353037070405782315727089541764339584093637958422138796375184575441595432133925090181949043536072178753049486872204759334059020258970699357154378751215836144836352430031659044940188023466979385706234766354871873384990411026120082971281373943799958524209806200235642459562870710282507653952117525804197309040193746636407624935115304309270078857483676519373602411048897743124249850703751765985347181558029527375643215",
           "10.9261393381382494183949485187745355142392643001293200037804399336898503279246222062168613731063277954463829865410973870577192080366472062964040509440033278743615823412810808078908898807870613199997974098405643999383690286991545964650196935814017029950722564391559018285106664794338502744786047104831103687602494259961816398342935032870065474763913436754495569767978627808003615457573685732588153239217166014299098858554629191013913370517654023841228586351241202877223367260494855558385058038046339898004510183855157527283289679410125378588229499416948431610345648489884658061910043475079418189307489137285545541133794341838958556245644032832230955632382851912531436083565766604594268028883405369333102861811110938475059430428576302304134018133552423994855168237965050769662481212059909922125002130317511819126236377187306085364203705624983640591322488295607424619160166746461204981597459574970519980426620414393119798825541827904061106147335114790118012457207318406183818422346913078125642646008877987007918624713747892824771389677121777686596898164466209882065864762628266271132718624356253452793196",
           "11.0689707511584805117811434659236005479075122572654030261378132541766399464801053452268915436339505264869099960261186473580786841783940799119071862844203935756997737196827013181251824477181865522696656125604284386736805412679099995442756521262882968085901005737598504818120062960533623452879232321601862728439436565082413065419068437974996041360159534876356676912365960559399896203071153029799663110896121451617844812242705440244059051070332217484066565235938948140400311999208370258263622580614733135218175221722605324220534894428960790855444760163600390939087544087363052520657480331091788922029648714976820617337239621908921583216442263332160508780261589523500129489988435510612958327244523134689294673236630152564918827636287844901928132768223334355784295928691382783374669003085509906226346278070859886444582772115212199422165986886962139084337282264595688658520928296714120909731973712859435413818042451694188522026870751629872095477433593107333415373943667221266057108367464732484461448541683512088757459353259534085109191456436195932802460979824143610395941363551604400219577421540555259221554",
           "11.2099824327958573986225648677376017877086475504215665299167067873045667553037759486727686750491707478834293411489125980911084151079663035133289893355490903237225455297933242623956756700765850165559519010287574088187786256136071791860343087283966672952333022508572112324619331645107711457400199461132270526458620965541207404627199559179879344651656741731856844106860800145662343482669094570758579364544899824573389424347400188820501898154253839556716834069987025577499729423912482339180176769424901522756286560845978811688935258106807347694868506072185526420367236029189162790328650177137575228819652438270486363627393827506772717574627945020518721350959544754722118727376733041854351927926293076323790604362596413400569959286648197872870638472594843231022845264486068134343862498444673897526209611533151572239019385139110221569524392708880223111039983515560401743550284647457807334695086237272708711276174560785696543477439261496094936993988602499825752049022699262521970903438062340959457966112130335715811951217156312056475059606961348236080146557716984203901504347783723320675301673124545417430186",
           "11.3492422124642983926102856582985015285395067466832927043380356548562390804853608284602050743042816031793047600978062552284631473271698301080420930678002935270860213755533376410950434831683129266708417862791056849585318715091316511224772804579306952692391203428022706911552905897215022011255923056920968598357445951686767158007175858503283841137547847702169068881757041416256682026875119665861386894957609106355261396135163282225259885976498039746087649186814655905823222925759171803884806349350968882196634773164961078791229532476208824156202390581863307496926197095334795614010135645721792945689410813947143894261828309379674182914788493173415091362063280686801906811659162851572848118095721313328315435166989609801810101070813864563570801067282282192253552931615123833493584040857696592187534301264584146553957310718712255292573453576205261351861700915480639583301267167270018138941290820062263217901164511455735107338870881079416882936221444752202024321144178837275657426737380444900404799010786716522164241960362132578101367581203971478969200704781556667157536062389987737624943537002727294733986",
           "11.4868138076131153078093551672152110823792896720438206208589815428358866831391271502916151740432833498923733353034882653574261402114885623063517466286983135609311347428616058487641764580040391132399123735354188924995726084316672645564644522404101010145113496826905661533851564869311026284567807835770793084267376582965078917724760751368098985709220493218989081195410084107253702771346532326060479533778255009456352092653858186317227040032545274297836762746748179412232929420302325855877594918256439049163258491252026402004889017462470314144712637559338394573924897045814379676299403438700340396558709369818377199922811836650582080165464955651223303653264959752987238908036388800978603698543078745746928727371682109974731915482666302457811317513367974821492659153756397368790555646602353958513206947086398520237613898204615597814371058763275824648368925762130837683909032578524176198944131412130278847693768941107158139354113448426375117837953121182384305427053092552066260458822741364621133976801759853058864467919702658753108948232787444346415009083332605651415456404729714544798893173653905698148137",
           "11.6227571644752653007277348109508691363662508507756756751036701167061120453681652358829612013449512186720692331837632298664953191556594884903747923711091159798037951823211201052540116242903833376452779227088949634320335447650281101165924512030256613650508677820241405437704762762206782047959767675141661427645411489541320052642562158115270383536284327256491550000081996990946292465147038958140512483013436893674439652156220554266153922101105181022227884639488325310071375913459006514297537440977563220662148148970327960819157453757205132071390336936162228686072898193957868554143074268366176486204705456695741921244062641977969446800006474326691825663289023526630549872030867738441378997270522928994756399267446297804673669222384728768703789276705361232508520458717382592703150193394825544156320863346704391789739396085519417964187584947528508961792799045137827190950383493042007176116232841260864577432961637844272929218361324891683925506702245396833672138534821860627603036634022415963773401638269124800251684954328516467828750283529560003793822429188759689400075614871516086231035596052689743737025",
           "11.7571287633482564701088417557941419439968698420773487503462842143146491163563371049337556035298522469859900749767294905204293522292298717243582785099170281163259336541392158276782668075147925622379654122962653351040016712959881553357605497106466470404805444939639812163187639434573134191280457860931724877949789107337574297713157520257772779962308829313235825010872269098259933266628859309692716030518264040729497076680529713079313207178190774506108797460140175583332304192519082133325489174600742357544490571971313852098894475025787306758030943007946889416870903157547612470086523779487801936864170079119042775197049616392224777035884133632044487020869747634558757479347496253003316077397398620232134764330013675436470146051001150951520936702104871579372375941323552263581652132668534769659706010116638397183935078175506596204447625920325403258326466185355961926258614112075160888891191719281518991171695016370238399249053764574155272331577493400906266452679122258224017845896213757845939003637544737204862728065115192407085665447911415853799165098806733280347311674415363212540753763695044873288556",
           "11.8899818928180330400350862953605490945670792691885843781217741865902161540797149716863225635789020936982216943798860608686596730470694246279842939661255204995037987819082637534920819262413521898735725618563398700095610197414629361605292906463960168199533434796047990694244545876312967146398128910040168451254044374585833506309988496398521626905559067225391111634661094215489591573641229749765383054051532237798573710270341590710314133283844952727071302050680708243994090927522583874773808185451243117882897718126728487228512838633247224103445095928511497949639973089241105749591676764685460285578873649870047038769689276438146236896979774764862962229114535190203566375515336454212011859282419120166317861652908888475438671284819089665982547279401923987430854451158512654842817295465961540963637129827028222290355602094488202815512160426979269950341228922163729152537302269637545655250485568256282052827775416059744799313956571658807344645572367377614160737274101623235947099688280533936734873574482825770483347386725590354986027708834298213375067720289632698512656106946260229255485263439491511281063",
           "12.0213668967023250475121483705231298685008638313363655540949682389613264866896132906306098642187026618532213215211701448267391188368047667853571572694775536356753264174403972755252732243831827044176139209024924394250581368618462046261557956041495153611139167826243672443648055383775943303041688490663671373136155053510360540267843423005332353653056262845689595224998209096627100780784418138991680078849703487894125005007545215782339870314429009558182449825490593249314052067759681658697789673578678949212809806351598964422253804794344853941490798950989758297119239095904492398955585999875857616109880042018712293986158989479506589338238909339482879806698524858243147005443655293460070165320341112926446082098108538465624611435423462989443724332948895564374322613862644840100579844319808606840135928070026153435302458230552287194862404115544729553555860135767866296645359954013075856567898559441124011177102556776336026301858215217613058011231118563314739369153408486077998475470304773205610152830759374129202640779824926230644346880253659061205608241669503029250691241581669322113673069664040300361434",
           "12.1513313969589473215460257145568651201497518877897922428050262513288347242121973389754626809925134955645428561432377800707082867615886711829398230527046072149152117757833141185434477765869902183850205483276767851442668275870416792912369988091698336520343468857746751071883637173754271209585483303314697136442637145609733795560874016392837967424129624669796698075496202528858880383635774883501185883268804218639948489991597161620364526639036982352505612319544441359778240876504358105343789015081880171993801331134760442658432233574812308195804501595367608510691945957205786397773541197798945975331217200866768614798768369352312293373100870145040568859670724160372893783528980570376945737242122861351956826347861801637766043000626205823928280244639867984099618586640713739887577174825475613963518050410729443551908819114265689677577478145683280934590715455378138742260694148005560374430740814239204990726910962840148903954657341678891978442315098243895522200158153790667123362932646639672146391300060334021960329885543548050873714607049607780426796959929658969497274971918388832149882433776112378434610",
           "12.2799204953578618617546194986711783284885172530116938144368314535771509667558045976384763266587016704303748296979704761081381717620397664865671903510669968678084217328572790633117099878107215974412473324265903962842838656473435606379942829050505712452107928846249065534782492554152722126011025173062371512447124740291554553421509014220072428311418179158177533762082303253141286989645666663806793346216795448342656821786999457421948811886868159285628588777116501247405795055524521868023723016473119342977272714337247635719827603327546913926621343978524311204280270124997453594630999239638634802644337751354075407234286619564038048753263401182285045035976563464216949517991028211274098829529896668645157402605736964080544888823602999291178070941183218703259256702481197869440224328285539315029919735628021900846763654500706187729683074196303084312788621291123362810414238197711110749709574470717069655903547110330030873335426650222570764388586364476419741035560485166836355135819544023640374991386327137930058958044315661460340536197491826128954196500096831279426592578273253394759361748277609755229071",
           "12.4071769563386121910871723833880162795828461928567098974966545289703789921372252696246545971698126579135877653699779946636530700600709582176756559672195094792342638905717358599494762112026557836025246676548757396012224731074603580436169013312966381300981288214643884821974524286813435148379353275063447888532961343423260740356759285255609628548615681581561321713204134717540225393296689839237372943143825839653692927609315322726052991713273927559728897504704226043113857065570762959566602644918216789694969199672638429429945004464808633659900365281397958778937764586125792705750168571832536005054994358820565709437950496363494452954047921238695415144815274982050006786314548526164253480435527360117258227218473895919440988655875440528203125946747677251876874785141679432309253336655217406754914545493066933803303046355614733012876287373212014898518464354302511069792971558150198002542994517182497196658469446954272237277648451310578098894153010149839496340312748322929392343542401192635791443342446849357926898503374322883315593972409393470519281160983565963805711107788379316117321935018451317463295",
           "12.5331413731550025120788264240552262650349337030496915831496178817114682730392098747329791918902863305800498633260193982243316180906336809047892782798307396595671774022906186556866390215650996940132357511723275244921290116470693138983434180651683791192209057803924504780002068757513764582573061292193093246034953046333204559400786984862618885126937412392431674432129875329475654786938171362596344020101428592962486815404989226269275049982050964912932279406858481733740076448726165236791737387809948044594465748859324274240234682608001489761959800911904582895205648987648856442440083377350279315098412071082116918180875960652807567992085491418518171171779048843712243763089005461162142441959768362576987291412815168255931404395101775965044072802013243885707825024188361637547068403212358740817592235653691584095976849421861670082802750277531514911692932624780562948317181155519719433742200985107712422346336716286438058226121690057831351581765881509015613412808834445888047751194480212233995260850290885434497091479423143647466627421197441327905883948348615191930342201498664435396962952383653761285421",
           "12.6578523191369022687748451647920884211351618089655179455231284731368243638831930092692097344570437079901479457687357718509226590879392775115842265975597049724341563061418697031268607830263630749575108233222183077768581512869483056352211926808706010251598533367951222352547093385705143351301673698003798847470899037622815846893505998436154809431208770604783851594929676185652397778605631719747005946930957513095696933347983859316339644080864356270066190757023433598780191812725848826161342208170182063208964958296027351135838121377963924650053695239000481943588371643194130257120532938135164021072988780496867855135805902766925269096358874433009794964404505124093744345096904976475426376615294176138495927979455477696384319750513407338903997493563537351640190122018222196334825106936172049588584462292486129117684021653955548443028996098787136328122645959968477838803895341464736220878601918003630919411584046348014738162733741711244046308733521756823739827300238391611818552174369697043280135230378038036669764857912765848567411839492389221128518450325850349211951118365174902595493189143091128924607",
           "12.7813464856668856522518691213367395488373983072590701713145905073584668550411607358543597603912057762741393691355864623321869872045162679380340422123959215611466910403902959589333930419739972126872708018261852986836161629068179608683599318758558454178186907956832450548642925510765032059337782409811599151491946626755685676305766429474808428640216684544678283803484695266015509922793933788792110436669354157798571269751040316991636951713788699537082555292927490570204626589644427435300175517403233899918923272847824314167455320989761357119076509049838004736602842837339638085643968136447256156911729326893301531646656269643040306415499484512699811735326226264568256017365274168292179743002227502407737172878415905382510704635403854488151102140855989374523291111062718131251568078280886769584934696459901137937953964469578793772809237271734821085928782404218121122181261925540158683038925682470156718138294664893516327450715858049368151852456159157278933365855419727276747917314838901881136398470619819131257733243425751608844676566931756320335811737311881389733198752534744615861076204027861852881480",
           "12.9036588082705845248371543632003751697456908407741692410784368848786088725089065725375873804520087666996942746345726834840639975755506362717246534706442221166298621207504273622834658505486588760226060303402875348318760592759886407055350301443543632102422510097863033684320708847504885397025676888805608608575632588352908208382177260510976770708247524111302977184221988730373831487689478022518795416243743368791870779402875990432576302206741559354874008433704301896418503322037242979413682693250947191295393881165307605408058206874512520008288998516843589530555818279993680055875466221805842339665434759158713770816962051147931208116808824595295514375045899970471981704078070597035475020898965145851209954427460157152268663408082085125094326139800815655980081696754509782998928240270234248524845103756193355528876937225771208802709529190373396585475974586241329821820837801569449366833520227139445910446436020810058939318594350345270816751238237726135838608689569520523122450244404454913108932211269247818789816060744177821446724166244434311897023559474757455995497570838056986157112960941696803729504",
           "13.0248225820488178685342632912343238216979601061218266855718218998666276951533231145020930682260792477360344632310638590295441684624351784583776951333098667981974188365545612612871000737689117674875852615577526787251049514636210279051744104230737587454580087607795759122258403467492028649171542962343479606529561351026688755487685984589921428857133421559960948571647613155305046016188627325903041204154246899196966232462603966700445644910063624590545310742013413052493767760651034718454869397101309887128595851424984506347453928637129803680706460369098293991859471996032517594872564412415070144179482992252118409915695391894969117482400145045884554842840322278011432577120399734619108356438807595811178234057913186320237397185513405311167519217318999889945937021719306691805937829150908057058520820765419626158504132060091774274508926086376591376268595715192288979762123191763090744864854362118104740490470526749755952163229027693188269314110667026497869103566625965385924059261283134617995824097636505520477232078529189494211027236324917581780494684363016330732220817837194012821489865101665659203348",
           "13.1448695675323697034354136539313425180677406990253396231413553532158284729201772491011000710677650219054903693738656249197132353617817043139899355573740668204032909567434296038746304150062741309218977952141761472466065644454165057415693463642194136073230607947203262919479440729879071393287017368357538247791027372780044529165958694345741149609916405379143996738502906726395310549057499135876771945647726253389292849661459433071570826833703064597528372476669325238379807256995707509496936873280377426680968490544204144850652418667102858872780887677263338414336218554299503848227359603371483052714037382060524446989585125868194539667288699342590529933341716843693870456228542919094333819496744852442099842703290379050058483746581999303382422470703068869484513287507363016362925163918396245228476769779932001778978178333151597445957345163009522871315976591629005355442432626542153837481717190476686292454901373614541009740405739756345322959707818426567664529141400786956674079108340389783956916039981285613130422619726646882192158229279130067633381058950064006933912115038270746168224845260024281286513",
           "13.2638300879130844418692645103419008851433471698576707104035205068479154842342531493640166188424221928872788268021523097025617009883171083293666524699722708507299019677199016888467812521716795727720983628669582611352125389551760744251188257987908956596124821189545257478849203186906127332490552548178206824138544172197838374523423375254198675829138413668912760016032313769059455804653716176524227853011200341883185271520228753499996932010458410031370419693143255990700761000024496673196269609889733829134801047484980551666236858533457146766367747277095875593778729441694718606128544361746910206836748409803492602665596803500054083069780608871505801360646167315352690280628377008432711576063166447694198777963877737992599565652289384323757645957667831632164936914362085854511223997991382883616592832979065177791044611243501006307065338908712799154330972075428217459730419874208577724586140073018349376758248846129948221694682041532005304683418747132755542712569486036886659785111557120560693988749318795483582114240312470812828755095071884506363715783906688243833912926998435817149547884279386906634051",
           "13.3817331184947121778387694156683631366934609178535869224734646839530858830882778845431320165557527082867167385741007241233972349668341335799303120558949874914731632596672292536486840252369343075578062661394846729290886120806335230931470676125584836958188275362750631959355148413735909208659653125785489545299880650571571989789816736276472548899331360413686815340230072317761139617108693201596677053371411718241422778714572140731264458353536124425397143067303995240635567710414918725517399711583125030933885900593041624549493909270279061801044266813541511476059360070953132414715897099793064187618904913446179695444823627572975718616435530412231897626821211591630120456854888471296525545355847536852618755937846705639827645780754110681069739162703086029559215644121294709889120500305321671981859220528418810561091642459738043327836329007402390418543140043048855442197107222952090170835732458531444797752568765756885481280298531950424829111511736236703060978513393719587267334516212509718247535160103206224947196863863264871876290808068433102976710291998849009357718081807090905471789659277124839575212",
           "13.4986063691111464245935803057163445333446588880954505218387843221811866477814509702726201994868384090085699517429739877130502525078353243003832198065078057206125867558943180721358516952593492926100016791442634700742497189485375590347895515367419024810678201127613962063650779588258427129303547853247317558007027886497918350521735648476962160113303483169507138322563300579235728423638552959320773585796896051727660519635215799533389594349417041464679040078438099479890297375500511781991113346083206493978277223781060900609203238286306467871141396991230768088662632124270257464480586088316850690383023345309392492732989705825016919526022563362954082266181904414071139631058950012713540527049102477938879051900769524120919579312018938311603558253092272074870766079137716555254983943200583248719785173513772917080626726235739995775731701263869010544645677727292023394850886826745691463821983518385802531448450511994014078687762847948523441279737079750421003933691499255395954393282954286628119050279442723264746413216878905804503870657461514746916596067609999603045774298320322180133249625717533859092149",
           "13.6144763601762444379926521651240108493489429948062675392899749011656367981822455178853834668853591318227100171777478230478862293910435061059034482102617694499353623610929608083252219728860071814777496237554962825789860436664713007380885823257620705055571016537859083323332155283573726935538232458058826315899029704394102678491521465094178345832292296568693637792747393915301530583743993444025896838065118897343043328452916631236017814449542928117422626902025859794220329730506629124433815526321617718341415931415683837830843770074490481176348422362162861812661346849873918814224705384024355691424864367748319171681413896659635516678441852608440834144162761248958567982479001381585906063881204351628751599665209292094281446522809539191841105420891950899912208472122984294731662074195162813392306707005283151329632622622723286645815527491117005404146816741085203466335075802165744347567892995323123529815454414242781188328567365653543913086263285794736485546877191137857066664712691746005042143722635223400766012268118857311779477233465292274708583508374133748593182509627918787117455241091542819813359",
           "13.7293684929565349002814005023543592804964690316913354059740039921737359962110066836654276807236804947742615071427660872700145940238401829666198102867564430983532833968203866397021274696048511423964516039293063346841564372616394035280508377589981815930236172110027155682866173265957057116847537224889132966556719926804970897774043788652449326550990615537122847783422709526359447381966087990633802534575460646525162074014459375015575284404496110852273022569124875729765365403159702452906368625431561932846108624944301668558516528560245529919672218971472439887445983944036799046361732723092955509961768112891725995232612851753679926819549883820603865511609240878443812730667980314193974928566404533803735999392509746959487652262747583255886228825858553626132516826951392583384852945025156027490339688398663126302073252408620920771562662203031820882241531317431978536601598095635063467881482850750509513362287820794106463323082969988103776574802747271900279764712139419063517288236941610321665999875635490491168684987282463547798106958000567974010853725420395569948956710379401344238169278863002835967332",
           "13.8433071145943080802284382623942725643459634316370295832402490811584690521837914916840395377602432304386346321516022467700817063042586192089471811215559491096430603765490105342479464734028031685014017988597008866099563434747509151656359907403458022227708855288944495192855866834164923404580317751114810233440974813740088485452355904551218828581183511828392819322800423143611251652965268254587551056785058961962030307952250857929384076417852708688910729480334385710261322295627380646587526400594088017012104793668923859704481465512725231143313046840031532848517753228102569245860823651766421422437423742518931925679240338180398466042655884199628267998290371715502966743259677385997995351151244386978277483823663420757491844034607904266068469818830496093618976553620949696221798505339106720245367168877405376645269053274617909080172273096809275302452571198400347118006550023013802032386296495237116432503947861118574507348019315687686050292633217476405553408632695073744388341821217781854190838168727859124017786167368413748894627539001773837225674001211236781270826204317868935713403376698315709386501",
           "13.9563155783525897163028298734019451091984537120228258009450472188267318438067135063202368534135430885083946298549306330756477989556178368665622436754180093476324880937959506547854538083370019416256575776948316707917842310903894619857591393548227911657101468449311608259623964684665016119377046647048049581386101096936670413063222259162339202191273628263372563875815041957309547200658623166127371954284217563921132238888463255849732942787630189806285692737078454631222616459782467155377806421107402656800251572053070998411099760060179547316216902478018563990476197410484317348357273331772258891407220597320756586444959820203436442764666649896682610015685305787123195940452350461973507211933252869415122355860564522872963830841829314900168567809701229312807570848373079796018588703327116777837136272491150569217486925114594308036945621245791848046986349492932929571328689798094081442393417715210813349185572333277619344160965594558435011430506853671006276522611925991500789685436288350432338677840599188216306552667639876278614865474090999682755277088033035543967117665417559338997296158961230538684255",
           "14.0684162995042542216674654868534900853924743962472320944901951275359770399233794961508506556929677794549617967276360905381168930018337020653807687724763883010138302750489219880498862993622224095549373405969163535890073412613574826759778017493325279749388170684537388753850910851919272805375112411195909352449662070600051584320215271787478297061945044327159674754973100028483156776843882380652479233971600254593710768026548221752384413741309489246040289220352899116307815228866194939899432434878525491558800547976779979683367688903278732739389881734067014259394063217746106208605190496361134584948172589477057133531025440786827852253824524160548403487907421272973290367703881100721669407971269434798443550172625237114659431030829916141687040666884696235625814564129626435994637907086882588770755812283202784446386224614800747923981140905500960288869620470111613554587095067550976879563417478116388152425814195901924622311843539510171658250266502293689578285040347337973437140124945630951972283147130741281963393446164290359192448952378935001920557624942274221681701969732105101994763264008622253735683",
           "14.1796308072441282183853398667291614623803956489790970257104623188232902767282574509996052539083573233298145889942605653298892229257953808202007496768222965476963015892248409827994013842316066098314567630341437024013971121228118377641336015214818721486835757959593011225113742042072497312433546600072511872609098678198012274693439183149268146912703636093212939100804725391474543306624788387699854792164372388175649060124931797401203419100884488639690168576804829763558693789223729096647545879906533473937107656768729633634222862245495581325600417464454810033071730955572334520857335510665755434348564981509217953643371995843993660518911909987080474451217457122342864898645198315616289691926316982991152259678255881050789701321000503460803572510568774002144999754447633636924860956177391322005616623420647924346632052977845409157572899855099445598306816404917155508334824637885940574334850876779996796181107939376311128317312515783517827307603440171245138674643140940490734106905601363012333078105653542123345026860999226152360678825610735394879178469695503958635098408901004932705510782878230077100909",
           "14.2899797929645988880465370254439290463492686909646365784756651098966688981604710380521849261282420820080718993444184921140050946072295733777832552069831871497137709875484943005092844538329601721866028257517525127400112068229653107318786632214087321828354194286744189213884282476820178532929026410946336549250316411573632399544976436381304928255592757344082191936540818455775028244579956105065883479913799108021321113869783952904182528280242051379454218665561448727584030626615636178822706926814162499131369332023155252856087861647757703882420420084149242345266216149260241941567215880661724399293386262636274265942504563029111804888220594251821006906781849767633589028769011495517300679816156698760917682079890665846007154923427386849193920295060178471954901369186035029069580960675884569751521212531321426347035716993287569668349433572526231363707210075671937119893845403234179825305216364116472043430327447622673443562491607514186170086950732726413599236608453920182597620790203604341499252603323429275866821091530657037950087409657380807571921060480257877831704466578263052537696771142883837667113",
           "14.3994831552013127711282056937351191001504093681728491932833832593979434994003430971466998201017992112805329010979828688660650916169722207860723532331591812462512916668982966008728885975214700393366748922112781560669442805260850747279232150993153692443149737581771637951619052246592314537389589547596925358885851353137852240888588511143973759301432800806312328067688373837578111007355067907342413561415117098106229593114120795475094598890952936412656420669510625019084604237747484641036400610081271857751008108979431957256358635365498727651936976456111883065483148617986465457792466402273815217241817163501352405823111497054361243886482686577961223780674009485714921257768842405600740516816638273826990939617065159558546972545307457270500896948955482426026947281134410487716638801651876698608693876104397820386663227664888754028406305427233767301780066332483940467863387166158701953351518332400189178702153049021261024299343478982543905250789402003398874430729393561464367541193884402280665307850918818544192856877565661864230591257923543269259287766045586392906627455350388206936516877511705006505488",
           "14.5081600415254637821968107724614159379846815250015966632796986302946639359084284397562134794977873371225673488011687447300524372638777391491271044047013009672846765153462292968052361902815148016221806543555516416870983561046485697445468525590089690561736144515682350187091487327533880302736617743526917603555494921673130404909292620569107730648244440333842777280190694749887082191823918012255416939347228605499563575333082299453802606427072078361952092566154166904748856523531473204373911618483373304549076618565708179979210316820872299882348744668938414281930060202535519438925657354409407529756410826043868530687455675261372284869586600498214736517437102860130625263737648428644588668437974421283838793145810608177937448518286819323950509354081962798121406813386052183361387375237142429814580328643754914782720125219937145864600464244591497580867134545593652723923600055555437968222771839658325503488203860238775496018875409219820657867877489532429308420073127288519458470515585824162233002589242653827817278322155993680288963941768325132608929167231803325441134141466079523533004874074960297398614",
           "14.6160288876324385915282082833965054491451514454610200902394687979785177479643522829616364603240189840566860380268224748399753802405943005392310014953070864465023481741203862559161940023086412200284446473311773218020713884034550394274956642070111944572452151925229164138208667793489213073745951939637376475072238046542165112242929720624283960415646561278977194301782816461600118545055956802134155907504241913799478483079002103747080064163279210998110147485017332310883903664994279933307864561852715983031647907050130006889886745790117080604262580893840381373714551099705553640113221087389797416689282779302152781657206661429673588858985798962970236527448473940009592181110203110178340755616764069248826774690236853289420767334169479100200273495854179775154480776286912775449612542711928074576553201233514379922132051999344634460933918951031402916699819979843036301934686144731527295916388130591787688603848332640080135877157352065976684603109296470843761116064910386409905698675285107464021939356227075015494978348239956711905571402049194421753904018717527587649996077266800964352303624402577118757550",
           "14.7231074538527950476608918508913485210193928960438010156179716284477839899656296406728660773561791479300392640548844362423376122815685515054605750659875846934795898267446279294839998923205284269250511553190404067373365705229426342396747030473106863384763359235329631176350397962888021561481413516660292977014970409803172385929807914633372249932127302974588451306885951998924516950174494016508742886729576894104195203891310671564861400064652564905406159871623321437476286879872259083518836208723342177364371256650666793948295098750435124566209886842002880143316847324199429697285209003531473719741904014483758049310397090719533728097260541450500261317080346355382466832396046849587639939461239781658290728113330095841108422751523386313998448194981539672857289889090299694644812449713503451035671101363587351933041787935726164774892898031020620075494054191750748238175302842601156452243294124366476294688491666489019848361123258726182091191116324806207133930412068583323189688687308435693004227410778794481033787991938082837748996778982096020946799825701362360467247804846582233346459021849435486394414",
           "14.8294128592903342463108620791209811162154136750542777284601531691224280305317915513146089525434202545204740516997954296244402311661887141413394532911541491603071708609940180070016261017915762557510278422457087524038813467378351272004581598457324467747373030877616178977537315248779792746942842469899245159612381076176060345997493587854288545462033896684057639832634271247921538572263389626921342927751757718681583536839938535751092658431596624136867197010308317749181005637423090876543873298238850113918296817041690209369633579425326504751223838947047626606883955090485790288429021610217101252189548742578539077253367329082514118063765427191960206852366367930126992346062168587627226173914689723039724555064028133389228017987680521282524145956765953246086551097796047782148791998851951221419883319817993999053278752506962511065678830257218401748568500747333591882058597483002531463654177181720203177842917132707292556291289892843397045703928170161651798774202385266858024628481292908429107158745626477532254897607152843489836358490936853541807395474017791353789095258403694863885903856428866385139618",
           "14.9349616137730772518742205278502213908354666769768829412154208873914099415699826430905240500055519452566108757946045864392050766773281378318859154769239371884763198843033880284347786378856604370045769280031694584512791649322990279975840486835965869228399135416024953621164643532400693170358493033550812154255730604795122027373166382306083361422620489180286334685541856384068029463428651261328445748342560926139564774421725776053820917605563776256951832599871875185183132937072360851486597203051765984337363986545459745401275505488192448731938753525598111844098064910555199796449249197864727749286292996338718305630998619908744286323602224649686053449748987583874785327499948813912602137839272202488683363930706928086605262922617223633664247999608682512707009348695830289960455591428363355858586332036652696876145134314146004076987087103822970399358514255536649174532275760391584685618135079679840634515711782148326692482011033477006288036228152078965813370535741600755067904328039271925962758975702936379448509324264036066209770450856159966672496255612322665295729865499903170425957082810506551820498",
           "15.0397696477860030144945917088662715180419204436596298997795414580537619276470518496795750302683435966960598359912232778691979417087604170857471339357968875914806128827487423868239668258781196328158829014067930293905548139764831766780121016782020549430650869364709405736002482509016517499087673550631711895241943655599845471280944381835142662152324894870918009318555850395370785744325805635115612824121714311554984178485987071523130059978461157895518735288230178080488091738471398284150084865371937653513358898631189129088281619129601787714351761094285499474246778785178627730928100052820335178118094485298540301817051152783369081590502589702221805406134858612454692515706806553394570930351722035092384749695378201907117685274122131158052887362415892662849390029026033965056482083854830488981110682784429900915172219306234004099363300333037817894031519149736675537980617386623663320490641182129254906815604059543725669871346028069397621898119057810818736095370601335065657301433376254680794313020349062521396509775307772376959952905436929593487060738018338230316410641798397322476355542860384513542506",
           "15.1438523405392099196696941526680757548021305645205291142290551070202545969870806060651771792665589490055461678011089894664863226391200155446121001161264758488222957146306674042780025430540877651260123695207749882929804823786072408198311834035741094722904703994169074927527266054117152533255107532619942528281884626828101541096773239563535294095652383393617113444649817226044992144468812474731988014146393516008194986121551417317503118242518823714684606734325443399645596959933855453707336231367089097896345978026922587762215370241399967794400041904056720435869378522780399983882254234030896553717060098405070969432588607227990450595751600391582489120049548888787130887917656163272514952919890907132626716845497133112466950843147056634292546916486178521992255691504244921986125000809530997425200716615625657674011024011250858696591746091527644535689099940477872177573673286692409322089652390467243801596188075140733650997142370201841877916119994009448748653226635048181819256281784782880874622975340845523108222703652277923638344521781640569055426282343260980758922970221905010015543051560514662433274",
           "15.2472245463115253370040636354083283666887786708714985639777668988830176955007183975627913778852644689341469297550544080185597077331715777153346360021007242495125392214774851264280715894226066393672643745253857483137929607374086675166192281961765358804770989187738591443219457532796617012663647789609431774075740567432008038961013943937307134814420860312306044163504297043835283963554752015900991148417739158394289066018572722217110593352847089201745718938357549727957979705487561467680940950578965108092971745951832261598491593612429568718722411875570411732507363965110669584642166670193068764600247928278340651032872526563501469069542627171043818450750969393729921266850657068206236571831577209919077311206015198636883915870987141318717046234082051220681758363352349761727350749598802358775860890853785340760259057433823505166593652654890358333190798767847250596060513312651361844271657521510045055877766996925314299833842766830666961654150747864536564429858555272922415110649733857674682620223561453248275694304210618254529601023775975491296511721889498789622849848564452286751061016082497088131584",
           "15.3499006191973273271932743733389729106106465662646172680460393169714387084447557470480954083233770880379685371224630951351727147025497081082089879388337460847605271660715988291396374847634019968015591655332379953553548320591794507974928536313132140565134911057811331918478115692690902657513781466327964390558905925364443191776886267775090535389272723947721917202602879066426608737057083329758491682770994310428321027233749321777436014858585199107035735971395626559257243819405652335029653770591399178721590892921559544649784504159433642408276679973155389005350337656246816993288749049548293503305422189192594259042858274455047560941579251477856306294970704330271186897488785264092623536912370835806446753257171205100681111029503749113972588676479023379074070878101497336800280410356924143787399669535027376058454568125882734662103842745378855390985776613904203513017797747138888437136968088396337069879433887912538591669283312778213455485732955595524676294450606458545443919774430029550468739232908922412573697555394576825425670246864782661192745625121039099283240722841566743449202185347012194036339",
           "15.4518944363733046480094895714642432822764116097792743962905968923051434278273216767519678368256147566495033878636454508377334372505840297952460243476345514701393821523863781406748742704716992949704447086972077248061651918445325061731913106414390710999384235658960798983324112234104659780681677057531882860382080238722943298496230509728345363802492358823405567182598267341768167330142056290790935811977359414090689588039875920175969152935770254523050051392422780000072929490482155794529675141588626785387839003076240285297590899692598611212948974143071946012735043590405405711508420740182622735629791811546902131754304158391375976203350556228354908194871652988791982508708646374469749119063201955850224934760173840978540631523245165459130698723874391791535530500096570481656934324227197278855637657017693124057969321411825957010121491871519557762634188278945281706669785161073963143541978342157205033140283815645312514465796297186749713508027712528205500701661239403838639760963454035559115496453338988692441465086270102708432189916595292275910127721552152009058942505984180320198848113154717062637193",
           "15.5532194199919290973914478271101509782761473427556110871326128562635425877948922439065276333739001292422317859939226322742544533781551368669476914135913677167870569871992237487074670090250710391585542749455379676350917711973517231870663274531838871780463639607198142971742006771650734656927254936190760891498433170178096075966621078837969943641749478412326387664953246784721461426256026142642356786959544769333983224947181138296945030840334549653119000316260143077956508210419522473362562194412180815212162799927642323378945617932239804210721035735661553698229406968222610664812153679540697776845028123042956550110363507444357710659863250974690713371372128989567244046052322175878868097778138345843971318806979435481065172044184336853266870505659167792988132948583467977404968694959221486656240243417746389624264522689502159242881137811206933660406168854853625265097649099854630342455703384775379760129637369884518317406075014753125436006487026676158299533450354777908097205026564092618416813042451075357865075958584347010560603909401672674530473016380690156057342486458799820056849296157803970758151",
           "15.6538885577994285336615322473375966991656095021435737363246099636760165366202196502339470259559417674183944684300887447920118633727001251716571523443596918848444675379732072543560564133448336770198458947224033362634921875944735296488201053135882187385898631210771646381454433721775116899072292857866394011427204808403618078909248941183413487233021402017272788966706121586469579730897499975748868490518551337318808652816220884250194097501134581362589451191335370815112714612837896607752466579681001969484402775834313370422194201064429923758665189369487888128968954146148578820551889951620171166054882708759173934381781451338459291737123198762967272009330015190135251071755806152473036989743744301736751164450587318893784207514998879026913548107957822584996296731105979982593758231329776234669559571495246544966721659816165141685360821041442768655874261766471614879723279695129605131434774277154659938308116466122952625429526707433155213455467498548671879756157972690042396634723002326783535035168700456971324492035298595293576869795744389366846556161860716979752870417581809090754427851499367674362389",
           "15.7539144225679246209830112311867562489275000482982979660467978944730262881956936027247186896733459505337734582610770093614470487327551772081823931905589550005108629069012648755348782514228521197088346998693251351381154586496257153314478419466512135062477857636559546187276312380852109985976404783376323163746995587475215213229589580070616867837675337919606283901588189302295510731616001258677000217918798250564696325480908966629389997769717889909303798070409227548291667767301493099723866749466998823232247966469030308331085073105913646005885136696884725098040065704027444469765094470600930146845779530531161938075234915622678545819344667609350674211649145259963974499132458151510972295814587234589477382477724361318542752546281937647008728052174217050786598039517009852677136114528982242252373617954020044735443912957185708403871758652762532215592658585695740093871059422733899587935643096714258513937804831673775551390957596911031295963904326636986587614829199748400378284270489821119258092593559132400132757457303025648114989713809051372859786312670557557455024113430415444733469786577609605818156",
           "15.8533091904240440533801150604807321260894390255847791708290322487869548721062866289150967514385361249309622591731814144915462307294258995039790586215006939993383983758776850046561092349884695864980967491417864933460813596552839148807057208618613557599377913061397320925659394501750622861864171880053557935005392499447778008413317995198028835874078756300521482179548125620652788764854972999687177405402042983731431613693788787613752177711793270302761736067574277658658787903363445166365077580601657490510530290835637982971350451510996298804593461238015330599519964118988140999455569019580613714105164866493396051692919035250861649195973033019817282972152713586938088500687115272282682479043225493555090482203878517967251561713092119554643396372535898649907805934878016873123756393954615387951516173102704296387140802792650937087349547235972359933788305229551638870049736359516727540333980757675042737103700554746326399085275428878409792860763156503485547649698802164314596132917707378582313164765977101027311129848967453806648036945112397617833423627052843598016874809261680305673980351252655348374751",
           "15.9520846581496442456835073500703066451779451051014841539242701086762015613192896323745559106469019887460414126185431359961253757915198034227258433864250836161583392878779461056493265572605574360603888584134116652015717511381633174846503017116671061672690227704542137628252959797331559476487739925081575856685236012972763809030119081042926665276791590604864556488405316065408861219952886936162336641184918936697605192640548272076353846488495049719651439648905433484003530512876695233728489114894850158179246113864820837838500720026182528991300469647511661287205697325018876335964502449498974863642135604197870197848793495324492868083775898735465533757619639262635723010975848105068325903417106605865046292138037866182138413986125566393404019074389870752413124723753587841540468575699565237256318701348228914889961059600076085302269512336986876298095168455531799946876677717621683146126707236377496395703746431798350019356976580256457555721053870192650781008973533558052075870268801533388874712868860234888763155218624129421405763678812077319239075778407441953464485710013630549293699630738008836738523",
           "16.0502522595242423047658196757944506380174575705759839278253230321445250829639481910961471931453116564538738497439478557175108609739886591120839569490500534822875304849736326488209685631259797055597162087990625950864597269364766964393819102203843223113243118426671582284256752979792222658121065967489791739897901556464359571005944335246989093673473307922127953030743811956112527855213800208534921642131401366328104759081292508449281353427532625724955074014554055167375410461346511957866858023371199864971286184642392511378752324547642788064420065819699737323404789938130114304157002506318247766787276624518432056105705328622750000206435275106450682964574301892472715679021266368586162764998585907621481532861299023329709215002403001723015543872591121222930217538067739593739604698257682609428654874555491602494919829715215979019400567591170934142751177256545981785724618392334660345395676518512531709484372866958613593771143352725257746445919068135186009397759278633269127719426191365945433194069995854695522773330552489914970861258642696680947645047295192118341734641074275298677776747132725952692040",
           "16.1478230807732358804057911156359975578643269683364195005563293802325983679008984974142648714564442396471730040316476902098875094502600153583773509818474040254222873787323736489817652011370386406266250541511480202000072979598788155627873931210965950356003142252258291831141254744970185472236595284729309004225710563295709356523567610266397233789715267714804425396668330717742603267969954704057766975076430627334443597598422164729733865234176455146920250925398679022857258803104782468690438474584298601058258695871408692587584948563444892617899745726543714797413684357745555329038056593572733989924153298466060559153513812177648291034169614177512283257755959087939669505720323242559668932499003542818847651691092512987952257177634187849222278857431112238824103335198289105119122009380272498965826349738709572199722545419521302521285254070487073289909851344138939360922891594389079867498143873584750623589649101531017564978708138390620735321513779148712154176474583208544330503651654716904907116042682578169464107303714557388993154579350605533888231564568424188460142954331592433579506586890005695885131",
           "16.2448078751809998755011217158068981074812938780376907934288365969067715754580651881228837648643879607033855368102601676632453884110903562211987202416395104068878916710125029828020978141971790535060779445467814920211563614823717939714231027215836135944076544647046307691726601906802103714211555626778098815167697410921218478761241829171583291214474448114233960671085832117529951301204663394172136901026541390977184829069626833926547718636187253278592953151429123517742761612159686867396009176772048429857930463378251101441506406781963593404431204027001757834444765502683573406073319506066129116153755917974319966003049503254536949291575688824723118194707260626100046414546696157059690148588275204844439191014730591329648048783886231915330055732155912797736172314922853100014380565619761622410826147387060234237675537903761684317822710064913207299936997924979239151897177602337621202867831218951358431546933181734907743029920468572483019023238760589912132344481868708100201604097725222903686108103206060682150910142819984712770046957870395535067746543225689701565797231792048627718784232710619996958175",
           "16.3412170769233839606963694201612486691212128081356542739834914529370956581095536199949227667563196669751881720330847867749383217493562824508538192834810436530795251403748280815986888683090444963568544342830253998350516075153587022434123870840098964485733650438270480924257439534833868943235183119239136909416092084248849001763157362588633568969048428387870886333191418072195613026763062715704979389513606318621766300613512341969898200938319702408657590012474789777007123467808768282135872999150490149110158277006503250724953661837621574840115483372782860303277647284047119064007533593648396594330123081102605014990883472685835045389875767425672113541605338848610128464772662573977617761213414690520480262408650017838431407962017900140324046253143316145470737963355177005851379248147035370433387833420553321888460391167558380062662113254804107448975955978227341116496076743206260952106365143827443135137267145015186532545755133066280336384345677654367847031873202744469936264238113240447117511360963000412145400308169673233984915808549522819952866570114619293558801485679439444177553637843192666077022",
           "16.4370608141699779533272474043612773161336096733770488551072483958825670966030102770671692026351162758060426915952129701085867802729318106406251695179863885464546615845148228047143539122431375925160247632834389582278394024330480487104411090951724620355644351152169170545009407362559853715960254174609992367516445002937337915452344034027633137804671869009243012191216273628143810422653645542449220632441502889291380255597379975105906010494299091436098925393391453500383425028779847395212818216089937829167091842984754080301999529208965785570901563511025237838322249140592553123941513540557406487062630678801556860907709013663182736461628834763074768624936750014768974286417533180445348738169351441886657201423938621061945983927061958409374247097943865562851972717122204967234909902165207404812597672553085816768537588350650139595857211821910608937442187518672584714044022382415383735643991420907608195400673486843199910879900829598881279040861315931094524028380978241183376771806462591007552168307790120399348941306657109189741410463773559051033330925696056841916167522766228211393262242421521807262490",
           "16.5323489215027158446880825763336276539766654254272088764809875681257710901986514691251337281589597719030480979213983912333851607240138763154510692762929645134059390271108447868644173448984649545846075027064353386413401987057840078259547584916364797582515654545908036217306641693761885158675919161061304000673810487248591975444958643217446048240102727684132123680636339276356809494454912918773518940016680535088516253123764670882202459282812565757616402645579638779334204722728987624467180608880772319027534713555789150175287611585325048568498467487723808179090257348438123807077849594237725002857165318916587733119054901238012585296647106745143265490190013740659650259863719019289349488568359299562334530428982968033376892598005685239623058868742620448370226790430347712128643558758014939672725409586893221245647244200231825250935867451601474997763673733348363862073700502793354719022161931458435920378330557182605440069878979638381549353114629450034341931427150761577849342839121295284737993268351881523490532278330519022627550209271545051013287036978208888323804801374289519895876593198148288412392",
           "16.6270909516939193588113275742453455057724907893471837248190052277684021812706093859674562917358464508678944731335671312361111528635211707981851761281905390428651253063365857714873438460026982265332515908134496574598271324405852203598672867489333701087729773656692255479851820749532099278033668844157411253338256984189005214039791624919948530833113525770673128187949311061890698199891708014824055365136849537030748140516534893460775625312948474125099589563910528552797986693601626798750522320704550044628942365910519008770640036921561300268413859502896583956572600382670717293799295760336680708266640050199950546289960758721503030196132687468226676261182256632215649868207453902112403583378942883517958418243203582422082833178466365454545310575197259045841019912565461611247674091038326392812565767346243460064710336769861695873330502452485176311239682300570315470799685242592229377370919807320562394172447148622490939677945521065046574409955795556738838394520031077084414251361076203172937851582781189271677247274081267854212505982365846174249067482121520863646230241374323178103657911564790192184842",
           "16.7212961868837069596057427052330107838993265239842708646860851842703326371466460550285293861073853336430183927150625107744808082403658130218547877377223408626609338367841882539006706085525641360251738080907390644127125042595230279880637143368202331046893342048365464875596596339640431519843405480605327189233621288814329341353255673008710460439879747397502025941747471573127868412038250150005699065690619898644879967858901930028888717317423009915633225475656314991246247179300655948036458387420845855288877301555946710757857081888614708196039221016144384209347600898967572348354997689536324424925550167367649124956548098079407104673133738019223267238283865985764961736835718647168600253346670325018729936886914389649147361585260144938350502362779387053821926782839707071611980639055740818753798912061341260095450383120266085280004484309135011098574017285860156410583019562874766816141902023632532127548071497727038984896353454326117060152368514028177470621582059370306418123530554777252590192842881894048535435254976906742189935635359698594705800588739642243011198473083262224352068070947521888133964",
           "16.8149736491937860979338473016064026815629713256323497948750601809568501329556639230091530125737561218251440117233688971366626226619494552699934840033236354855838182946899863935935135051148775248339278515431361132281679384204107687790514630925950009428499533762858168486928997467661567186100299191698405789687931448311811106940799338769819016977485112597785266160291200218493515224003641856137869046817349736860084136521100283230752847231380759335075251104980538366249594135868723508770265154137352284134429841268968217533402887160211021542302759108278289630550854043783744185492975265706362843229478657405729545441090741260159076361941917530778082026439317132083178091065099562781527891889439614485685906543894620100854938929972296809305957708892264846534267896729102201515793747667010846289314417299727358358529077708665332354286589063320334666559975273340602615325426971186711002042629355909063066914261841178544815216158892244142405490982903749738628073534048893782956355157093511439186949168195503573717926825734468084712589410442022354120219836575476305852256521675584981012952509686818126145279",
           "16.9081321108119800703237241338254436690744863062204119333243683660599775226753565893209713389767766163161342358021127981271381134650847016286405604432987298022336098638563576267935354939301846494369816655337783246226209880075011315863553918585959135040655522896546602388719639509065495093614444330145112109456097752772698468793609700122810958534616000768715917714125275538225625413748533473685169190832331617113246579894504494307284312332165945233891016849490928121382853036960384597592081111721835630475340517447933339362704327966786541965781642013462403621512902647219230788448655730199762241068447349463838875501396349840327689919737332595302012041802495467706531267072999713901403393223067607382639770962103669304655143862584052038284208763832029931753811022041122025100304848953045363327544205876760304756720535938198106981928743202962212743831014622551526319592553193580573329441708624935281603762989949456873712545791427861490109968314910368234559629841124132807220595321318685022115111820471491845170412521830502033004342105561816928208532788908700951934092518100776316736470776442731692226738",
           "17.0007801035793936281121338813371428867974374892864315366365045182530749574622712707915241384347920699293353638201192620301921643313046316033287195368236744465600818338279114167561421338713928665140404227014843877263137439279436595462144971591867941134682123131132347610099618581532784272896432738682598070539934802196472265692623169163830620747322703103707706888841879278208903105409506874013233395298896805581080492544955643820269848540883869294533510006353020349957920715014892361843146242577547625252883154835493940087913143008925195857805360140270418585825481983225958905442213791260106363149613040098659673146882019866732435671376309178138376480369335069359192722225011915819361568401764846284323216010823897735267747840800333035036264285169114393598090497354973291064439481840096277008690228063146037619643429834761658442087827165677168899338925740605695619093196708013773454044065476725273474616759775258989343235256991100913196459365908950267021754881564605943770560095242514851607841979245586880208866747279307676303889206098080334141095498113120491826011797819568010033703314385766397392583",
           "17.0929259281098732308568909665181706090496358902951216052253094189082758184705768795728909606854105818308409911054301261308877905438819451701225816708775064163858458811220345957117443399486918793485162274149097723524277233813071363121925271943987039923392571390254618731212423397735256468820990712184553680703600120940437674047217109360209678344268629771031575160683542930850707582417669810552350662093148256275597877537621451125081219588556687019419120479317429823172107590283143446497248490970649768152464725806707130059311761908605648006129152794658287289985756220544649174887465478997809837771313116429454050449336877009922282134713999375548742678240072088620118531202157406755008724496781361076606758611169943346574996481406674965729735501106625955985540926899693816341047327437159278090340558983247348348622180363741547423011416478126650485047347378185921229539834418983942666680991963426108094492973587943493986808103947127419030775318104983559336517699874867642430990267257306908318775712545165790980870833770357342634597715966182879292691159156387989718754333799048530940386842225448232251458",
           "17.1845776624693504399278552427660121759014355872173486225007203824024372840436910407549731315312720641661312015514244338979423498353490793511266853712442843525886341505446387699669856777170226001440090937353259650728051196433419270760984455065871632331371517893432279015787092579337531691612539497018543844203336945831070057415570861416522661341142055293762783441277787020381532046055783982924019170148071336852167967942723659657524174803803803905087308384416784431284819770363195053820968301578868801810080541678810607866404802296225462621786603189632403039176608470841164659717593262258932759900746120866956926679585397696382726469136456383993490336779413736927110713121992182458332821162549136160976369409523883489900369202140222731089221360463387016825261552399416009215359001253955577936829021948708246676341112942870776695271407974775582902477226815721865733052145151608560413760572173015439460907252134033256691370749495569198954137521453923556632774376333569072404958969821817487022660731421354245851272428708325787898296874181411803997899332362008586913072670711064770984500148015011826261837",
           "17.2757431704407540851904450153949790380186687458654220684915230386503275825407063160604517288734546119505644391694970728295669021023983949819859759900830880079629779705059154865670128635551815720536815841099639525614851417689538084914680867424196821634089586241442130192038834512446570011888290802100133594182555986337723487386416534433468263224465623305274641330130540795411919391711267934371941107593205550581646424497484790190474300721785629523248847972136552642048161447129520586107875881613551369904113055686380180469790846706208691893855593511420750973530511165283555627597887745887134627634145517416050748158800890514425554639321377870923909855121500878983383395887478657227223962509627436500904372492098670589675883214674156834456454663362930882283624845127465731275714349781314030602882871329526710766294672136474269162102821374407938659858184740917810129868058466378108500499655709083903249046674366509191153761430075951411439469754773409282874508134728609913829574500910503209081050228705417132900939410588699788540167873020190018123072161219964179184690554184874930100756126982018853834025",
           "17.3664301093984238247123510549790984289306134748291022474290958664888369268710974860027907576347723303147126176414184787060588912832469046111702601777464890642632251154060816817161334316918823566501136820770035716334732686181613705402325472307650116606106783477061012163011204623322704865562057283124639475372748468035585007316914646119895238476177895413281264762196817540406728021584836434537388272205662532262621643283471955600594193213418166120727080989351217403325023680868046291273159196135079849504794468566646008463271904849506404907608613825464391989145962661376690126496752549886760192239310656336157879887593855859958823309866860061179406457120429704015243436160532979492144475251743461081570978743884248426983196247351207081556692289758666519927916028959075589074583772201210742744694427687226168211338842746789032366011901448502121835024794286923051973016164255684120993153139149490806320653960702333007936217638703590917692418814222701997158804755501287181232079015044179490661098796848674027302976104705585992281369648433223442373992912484021774309627757116258683761986486802220878937797",
           "17.4566459378143413191692225015426086274031136235582935243632385313858201877701704036484032520749642131133778450955342272025602510829158221972777670586061661701347328186526764805212080639525455982292015938346325289124302844332447725669617702921917808500525274187600536620801147819163613587837238728871997225991025080525180442534466864555824862414662339955733621810264862776187374419901285240431490175974449378317927398381519709919509933689563116335690204265534027606560764875449531405967998639356231702870487782798115026659692007825259723146752469612698767331463901780062493519689225278109283378310274389559679038834170680206517259537270404175432248633893701903077868034694197984698018454399995348712691476944938462701653906803877183551688371651410557476681964972950883316889946306025542494264115645449898893118484226513921500673490556592825150254681189771557834158711489644867165103165017573599086205249218767497287654393905135560681295542932352259490763907188060867843701402082704725079265886683176519491584308173914664681606671056250177292407244890772315688524722948557271250549147036005452988137053",
           "17.5463979224170035169103569936773167710489071842695682164094650343960555822548938246261708686464008628120698086564271575140642653268871532667049895917630355233940483632068661179612946301911395716185300516412585342889806163058970394576807852912357307669092680925494306692002896260519270415602285809070330544448934264866486383161101778807666439177712377349404344204981825461265916701713439907634881628142000030147481541566984916776985069974871350878105191169601874427236107028216631331508432342933927262432252048403053983936328555651202085666743721276666416053287908582708399019416116728290391041137776899514963685453226344913930595188919687985925439640490668381197141268324607645626999418743675707607782207977941235558303966153142486351061701922818541439990955033863706292565895764497302237144629129915168217734367589190606338115923850388544120876370105674692788127644053617727607207239081379150797391284871402801013281516570366080963892214472234112621858777932368224243266851672272297127593365190407239608295928071192401106453278389676417859068237527688061268702479082098130209555748133337115265799590",
           "17.6356931450223847051632626336912129159953047631160231255194263214719736745345056574006334052947783704789851124650942357806440283438448075865374177648755421744889004812088237415174002112721888433569481184443980026560025069439822330036408245659699705607208167409459718244781459151859701286920686791397587316924683661006361446569736280386659169943463243969853737516308403647389899899943288964539074045777396061094245615020794569618969810767286161759163196190210263374998456288778623199988233761901113536316735857956970778148341712538680960137046414511920334125306354736321418705129785669231702905296255118678564162795574424588337165553826200448066730531304621451838136219021244379504974116096097930348202146495020513154705219076501726427281405053157307369058563911985328395372478199002802154489559015174957595775902617263259894306671438880488104887489699278033942889387921168112741333336787578922278486757542524555357598873580646861232908497366240101359399679018683387336026768844320636768908505456317105807294092097672788610628498171867123780698747648210099920520967511623044818811130645542567309932834",
           "17.7245385090551602729816748334114518279754945612238712821380778985291128459103218137495065673854466541622682362428257066623615286572442260252509370960278706846203769865310512284992517302895082622893209537926796280017463901535147972051670019018523401858544697449491264031392177552590621640541933250090639840761373347747515343366798978936585183640879545116516173876005906739343179133280985484624818490205465485219561325156164746751504273876105610799612710721006037204448367236529661370809432349883166842421384570960912042042778577806869476657000521830568512541339663694465418151071669388332194292935706226886522442054214994804992075648639887483850593064021821402928581123306497894520362114907896228738940324597819851313487126651250629326004465638210967502681249693059542046156076195221739152507020779275809905433290066222306761446966124818874306997883520506146444385418530797357425717918563595974995995226384924220388910396640644729397284134504300214056423343303926175613417633632001703765416347632066927654181283576249032690450848532013419243598973087119379948293873011126256165881888478597787596376136",
       }};

   T pi = static_cast<T>("3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019893809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913152");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = sqrt(pi * k);
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;
#if defined(BOOST_INTEL) && defined(TEST_FLOAT128)
   BOOST_TEST(max_err < 30);
#else
   BOOST_TEST(max_err < 20);
#endif
   //
   // Some tricky special cases:
   //
   BOOST_CHECK((boost::math::isfinite)(sqrt((std::numeric_limits<T>::max)())));
   BOOST_CHECK((boost::math::isfinite)(sqrt((std::numeric_limits<T>::min)())));
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
   // Check up to 1000 multiprecision digits.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<500> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_tan.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_MPFR_50
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
struct has_poor_large_value_support
{
   static const bool value = false;
};
#ifdef TEST_CPP_DEC_FLOAT
template <unsigned Digits10, class ExponentType, class Allocator, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<Digits10, ExponentType, Allocator>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif
#ifdef TEST_CPP_BIN_FLOAT
template <unsigned Digits, boost::multiprecision::backends::digit_base_type DigitBase, class Allocator, class Exponent, Exponent MinE, Exponent MaxE, boost::multiprecision::expression_template_option ExpressionTemplates>
struct has_poor_large_value_support<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>, ExpressionTemplates> >
{
   static const bool value = true;
};
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<boost::array<const char*, 2>, 500> data =
       {{
           {{"0", "0"}},
           {{"0.03125", "0.03126017650125595642059651621507489147877835880393069701338513042228140662868270178810496567920444849"}},
           {{"0.0625", "0.06258150756627501465828481747745378814263718044751609194477198396918772026898277636891147279909599223"}},
           {{"0.09375", "0.09402562724573195576489755283678159034525247904824579838425258406126459673745015890895186868431790389"}},
           {{"0.125", "0.1256551365751309677926782186297740007586657638922255426688666139272557034809288714758416649081949452"}},
           {{"0.15625", "0.1575341073252716106852257741724104906661974475121544257009051769486388715993896887955248205741956572"}},
           {{"0.1875", "0.1897286107180591328910833700730338162710122536010363055257273177325079653665703027537671734777793159"}},
           {{"0.21875", "0.2223072805534313308722888175879995822319104918387718270273535559005416973923742249393961682186904743"}},
           {{"0.25", "0.2553419212210362665044822364904736782042016388008226217404756502588831981346542579493165026310550454"}},
           {{"0.28125", "0.2889081724405147260015884454642448286982056723714186732378896291489603033944207768995735063901118923"}},
           {{"0.3125", "0.3230862443517455201183006557179619743037036164759656335249943943470835620899848486165999610265179128"}},
           {{"0.34375", "0.3579617388480169983883959631794471406375375900948760280972554801967920011385682070576100261097824193"}},
           {{"0.375", "0.3936265759256327582294137871012180981856966444080712949818309739116951585799388015457993878787997269"}},
           {{"0.40625", "0.4301800474642300490203296054472752679963181652078151755042924196261397876727827800621729454863519218"}},
           {{"0.4375", "0.467730025452391799921342706961992620413738282701114114727311802060193364671415150855360089743973883"}},
           {{"0.46875", "0.5063943574962298120708227547071771387085972911587370796115595547436950963394141008177411206688111652"}},
           {{"0.5", "0.5463024898437905132551794657802853832975517201797912461640913859329075105180258157151806482706562186"}},
           {{"0.53125", "0.5875973675914432213941588631578976924522062928763012976297627647411436985181631978010052165746790249"}},
           {{"0.5625", "0.630437673835884766852611429299775209903293946951939898251650513745196222165381994293674222073197888"}},
           {{"0.59375", "0.6750004851442429076631779494777229128864061685897319107997999948317524157945835559284790797708856594"}},
           {{"0.625", "0.7214844409909044199895178832795946807605892812145963657590722733756611374332889471678213489198161525"}},
           {{"0.65625", "0.770113551344208705005983660052773240245517035179766333813336659352553100285016757206110401160028615"}},
           {{"0.6875", "0.8211418015898941219114239653747117008753716453086877023306268412086961091026737960147423436480371207"}},
           {{"0.71875", "0.874858760554482349539671907932155532231782257040588572549027780010892786023906162883923961511720127"}},
           {{"0.75", "0.9315964599440724611652027565739364281886913399722189970823760758473440872606463942290222395451727347"}},
           {{"0.78125", "0.9917378983632686802568573899299023689572109767948642785884455151680071204845003794305054375396567381"}},
           {{"0.8125", "1.055727639411919906905928322585893795895648561782414602487481288436493656539800004691156074588329712"}},
           {{"0.84375", "1.124085134704560944131255965236688143403009777898521429483610660496648114350313475950507899270640935"}},
           {{"0.875", "1.197421629234347972339226617276609445975806623418086002265951386950959459751336541541255052511392263"}},
           {{"0.90625", "1.276461828982383445402617843263224436254612963462020761243811395954456362359102470162910199798207331"}},
           {{"0.9375", "1.362071976376228231137266640571127531383954502011184315622281795551984309995647087587519913956728759"}},
           {{"0.96875", "1.455296662469072910283351203225910848640458285194500237036240390915811463257413817682188441906818248"}},
           {{"1", "1.557407724654902230506974807458360173087250772381520038383946605698861397151727289555099965202242984"}},
           {{"1.03125", "1.669970130353601668362228999287655840466243330137306547430306024592587314737242276409239980979443174"}},
           {{"1.0625", "1.794932157265411111412512666640647365321540790157497713363548060626019826336277151761592643681562889"}},
           {{"1.09375", "1.934751011916103924218794082343652203808222523749686394781135509079848569244264225172363092871198012"}},
           {{"1.125", "2.092571276372179004423733981234886782259941716148720572913991515339894408382371607574079035650497628"}},
           {{"1.15625", "2.272484060247449371554848155118626331407879143446651944395567708418983252993702557436552564850427597"}},
           {{"1.1875", "2.479912917556758792437515574454698934001624072586467858166295252178386457324268836053055868956236971"}},
           {{"1.21875", "2.722205296368710926927932441765877991142333599010908457349133016162381084884183783877142234320889929"}},
           {{"1.25", "3.009569673862831288157563894386243931391637699606062181047618417194668052548525026087449023543493348"}},
           {{"1.28125", "3.356619539863437446801254212059537717694035906934171604782430676182834617443082960603002796648697006"}},
           {{"1.3125", "3.785038166535876194630450975067081020082611278470578710038656250838244608554256510046862645943214168"}},
           {{"1.34375", "4.328443997051826678273102914917348524900160978527585314859991445919675557868173766988955991311583481"}},
           {{"1.375", "5.04191525648136332110647205436422898660842030191113551461354742130497045161358084541551547909572374"}},
           {{"1.40625", "6.02236781523945747670227618692239447637023828129226996489330674807031833318199939459376428890858723"}},
           {{"1.4375", "7.457597366497314807346683309400119820853357043059007743950216525315136075258562571085388447049580691"}},
           {{"1.46875", "9.765431722939984318153137075537986427219225446494026346174651506537333303940271000197727980305021618"}},
           {{"1.5", "14.10141994717171938764608365198775644565954357723586186612326758608969627041415526864870292630944229"}},
           {{"1.53125", "25.27361509038201021888564593774203447137999639112919943365223977030408052066444435679945642193151117"}},
           {{"1.5625", "120.5325057225426126499709994255564804478992494692406282802019970839232698437518852292295322760051977"}},
           {{"1.59375", "-43.55836040673973128976461522014256814059799632626649998645431997677346427573993827534701436489680689"}},
           {{"1.625", "-18.43086276236962258434966752738448975654856844592479276671012332110139541995382323486170528839748939"}},
           {{"1.65625", "-11.67374867215481348216513536293945130766869617358776549669176281104274968860961548954064974733991076"}},
           {{"1.6875", "-8.529773993911653209272999783778324026196719414411590092375294867302897481134537117581472896391856125"}},
           {{"1.71875", "-6.709482397820695376442251396240149572345307174060614879543507453718786710576833294867753884694537068"}},
           {{"1.75", "-5.520379922509330168089935698420205500301122430036809938027371836902288281994865833387763391132527793"}},
           {{"1.78125", "-4.681280325336429567316481395066494078522124421106252324368679821712511116596067067167862140573504461"}},
           {{"1.8125", "-4.056414052170035671394695838412072312925972547334020477371203912084804008892977770267448199074447777"}},
           {{"1.84375", "-3.572185661861125859870109039981697499670205624150737204067785923886464814599307447743073100872203818"}},
           {{"1.875", "-3.185238919501229169914672833591055563068190813252958079987355697225012578404488535638528315769681186"}},
           {{"1.90625", "-2.868371726567042158384165205507273428429609298347592604875428057959086996590505442480814626239318494"}},
           {{"1.9375", "-2.603652912010850547260718033703880538638622594696262109914178307203938532760442947667909676035790898"}},
           {{"1.96875", "-2.378782114044268462754557076702009514149544247914950239975234530609231791907385965883627186285245033"}},
           {{"2", "-2.185039863261518991643306102313682543432017746227663164562955869966773747209194182319743542104728548"}},
           {{"2.03125", "-2.016072402071886080344963601799448100479409508905552305715636690184075224937451135890591580854847922"}},
           {{"2.0625", "-1.86713988123437020407782794323860043132451055327769468817959958079457004467338400013589662215485346"}},
           {{"2.09375", "-1.734634103946532053863260773540976834775727590591832428183425859927779370855756294581920109583545138"}},
           {{"2.125", "-1.615759423973460045704218998135983105718634789435135146363364502252797531256854000679335498343468236"}},
           {{"2.15625", "-1.508315836353881219959349807787957061590021089263168744744644715237923771519750208817662219357365791"}},
           {{"2.1875", "-1.410548011813148830578875195416796900655621273730614063607851296345238287109255775298602026828637775"}},
           {{"2.21875", "-1.321038011883972941371242354544773427461451983076687172335288474134737150563349929598365091185906691"}},
           {{"2.25", "-1.238627616224096475286573358483115818987811679840895892063010057942989763968416082248247538779346115"}},
           {{"2.28125", "-1.162361144121629479886631062456510653121514437736910570208484412489182649570861593071569298439919991"}},
           {{"2.3125", "-1.091442725473163592445273166049218471062020679322657236270267019564600575624640388147984118518979059"}},
           {{"2.34375", "-1.025203931548868392935198625444103909279764848147237361743751176005185409221197679274034521026108332"}},
           {{"2.375", "-0.9630789471610371325783309326887526239686440615099207880230611368370468000350460791927023591069451265"}},
           {{"2.40625", "-0.9045853091742213054875350240709441597937968403208608690036487459318455608785453421438664490396695609"}},
           {{"2.4375", "-0.8493088059488314622450104194218363224080665638942044768228802750401486144919082454646163741529209686"}},
           {{"2.46875", "-0.7968915235352686521345041809817019192899787435677815043081356746793473472915009329509869865385574704"}},
           {{"2.5", "-0.747022297238660279355352687825274557904116956883011279066593089700271855760843718388592769933778409"}},
           {{"2.53125", "-0.699429020084844342139783831016239425344370000759297142831905446726651787263273111657622358057530982"}},
           {{"2.5625", "-0.653872397910572369605836837404416068498526729423046632151562590225826018439381877458767572737519508"}},
           {{"2.59375", "-0.6101408409895599924272199138429116429964861640554001463611527892708422318404310839955568952517348978"}},
           {{"2.625", "-0.5680462555551780726648895974757705443146437970424414412380682777625097984947690751561280498460825515"}},
           {{"2.65625", "-0.5274205529869757121326571336563206310413652365485599902702063856643631953989601868253259786432770197"}},
           {{"2.6875", "-0.4881127351190876547388242189029165584838796506348536005759885166591812246270986452391896414818116207"}},
           {{"2.71875", "-0.4499864448356251166356611982487791354890745233650543094554613558499691453012194865420102877343872536"}},
           {{"2.75", "-0.412917894484932487763966873261129123736255820362062889934249403216388494265361969753200463293305801"}},
           {{"2.78125", "-0.3767941025635464453019403649599866905758314392515266200296815335892123350214817069316692446879993786"}},
           {{"2.8125", "-0.3415113829599005939054709337126887266408130303329754956325710946559071503247227755879401227074384719"}},
           {{"2.84375", "-0.3069740418053874743538801719778118186539092328300496832334808000582741898558068313989599567333495833"}},
           {{"2.875", "-0.2730932453907306446782089914481699536905769611886147850801712661656164014954781669815730570254890551"}},
           {{"2.90625", "-0.2397860292133634315864717364763276794949749917725083450148739709007738169658284872978100162537831057"}},
           {{"2.9375", "-0.2069744234334290889140606202259876249518274239071734165293810142417092926391409078539182667795178826"}},
           {{"2.96875", "-0.1745846741378176862031217701953393007964354401947395498383109594878301292911980508212117939922029155"}},
           {{"3", "-0.1425465430742778052956354105339134932260922849018046476332389766888585952215385380591060583477669114"}},
           {{"3.03125", "-0.1107926710961848652307179061543482824777047419183290635786540267776792824053626901819122659270065422"}},
           {{"3.0625", "-0.07925799258597813975964847855303205226643624625818783981886842299834648957527837719024324414633813629"}},
           {{"3.09375", "-0.04787918970239737242913390208792864526960233706882073548585416320272138422285616307162127608218497512"}},
           {{"3.125", "-0.01659417649935840190191646601956655481659118246051776036792478758448298530865094236374141834995963483"}},
           {{"3.15625", "0.01465839615112051363829193218735346545420611046761168233490628016451488745447998876530695315188732072"}},
           {{"3.1875", "0.04593962329265888212191655478619122278727029224118607262776824432506068644004151566997697327162767079"}},
           {{"3.21875", "0.07731082437922182842323045510047455560710445548270932232603347976675416898602720984389229982663062937"}},
           {{"3.25", "0.1088340255133297195139603974000083015109646348076838424061656004036607221464457317348103204356071731"}},
           {{"3.28125", "0.1405724535178196442425946789234394740490046721659763531803771463602023716095051057689530418533761391"}},
           {{"3.3125", "0.172591050272744891901962315250310519786980119755314731828011976218754514667360156546007027602360458"}},
           {{"3.34375", "0.2049570163396922924222670027465798026391019465616329916778651389384367221289434591672530287680469817"}},
           {{"3.375", "0.237740393762143806988724415397077124401764815151774813277613941354927085310634989951327775643776322"}},
           {{"3.40625", "0.2710146991120596316784994914008470605846614604634004480958302230976152416477575814862222371539690966"}},
           {{"3.4375", "0.3048576194048116313509686061976383012732471442214687629070980813100980504220010433668547826451536192"}},
           {{"3.46875", "0.33935178550149794902043849733017382894738729159656755127388089028458110314950118486374283672385814"}},
           {{"3.5", "0.3745856401585946663305125799891473884508822842892592306930231225774355972615263725457922224498281269"}},
           {{"3.53125", "0.4106544211005646795132687105613188412302653916099336518744517138690111552283413041415216571077234329"}},
           {{"3.5625", "0.447661283553583556404846819303519593092219301719424669894622854440119111664920988209774876249304265"}},
           {{"3.59375", "0.4857185918149514991806435613800961704649349211376530235980832426061445834319868210377502054789684188"}},
           {{"3.625", "0.5249494159434426029201266393240939090334746308513972623727472919160131375298663507047002581644827389"}},
           {{"3.65625", "0.5654892779403682511970427653303379875705726194565986095362182202060326386665976843463927284690694492"}},
           {{"3.6875", "0.6074882023842700195137806696254362966726637333828709216522375901698082716779542882925451551904376524"}},
           {{"3.71875", "0.6511131401046877694771154604832169765858772246556092408841970307496747807017677126165226354908150626"}},
           {{"3.75", "0.6965508511114601330600221624003410002384063251948773727536766307711270568580190864635818668189622464"}},
           {{"3.78125", "0.7440113559767865266278722337979770721544668975249127911732590346704528413537145792818180362367062195"}},
           {{"3.8125", "0.7937320950520845038640709755691971987193904745863880210276991068348251595048327258835950484424829585"}},
           {{"3.84375", "0.8459829748791345210684014414635237310065611239815471815195561711011715779741435605360151278986068963"}},
           {{"3.875", "0.9010725345768489830226429310383860542057548011724428357500976339946729939388193110037885928433616767"}},
           {{"3.90625", "0.9593555370605378999830231072930600308342084750238673386763085477722047681353378531697620720257631096"}},
           {{"3.9375", "1.021242388200347736200680021836703924511025898807046899043703227626470466798902950286611342705663006"}},
           {{"3.96875", "1.087210922446937924973630130633474302114867753655250594086911814333271884554141747835703519160797518"}},
           {{"4", "1.157821282349577583137342418267323923119762767367142130084857189358985762063503791325897570132020188"}},
           {{"4.03125", "1.233734886297294089608083483431716940428204649552146125435266924766182484146724296986257289579785258"}},
           {{"4.0625", "1.315738861236497278595002752513023767487817470172494220905161864739955592222079472915707284820672627"}},
           {{"4.09375", "1.404777873409928816791398747372142291632709052730067982243952454765008272213717678329031865335794425"}},
           {{"4.125", "1.501996112821481350670183703711495663471610930233216088609964712367465201389736354667815373825067405"}},
           {{"4.15625", "1.608793425833300449400383022559449738336897468383397721431496100147808519893555398680197430417094739"}},
           {{"4.1875", "1.726901492741173774258474522465444605840834193796631414995320087774658896048364103982815258692096685"}},
           {{"4.21875", "1.858488933532261262387603943116424040560957193049648082245398381173590809878153982869279424951736518"}},
           {{"4.25", "2.006309027858059435312199733843025004203991000201116744630971025635743461495678364523854925961565933"}},
           {{"4.28125", "2.173911671176453464233801926617652208987805422324233358984523813313677124319401603031463553334586795"}},
           {{"4.3125", "2.365954706436810886261405424430153147538433069393544616996159851851045098884294543485330531184033036"}},
           {{"4.34375", "2.58867360110912318951821732893635523217217883697807084314676743075156168098379747192932679404932885"}},
           {{"4.375", "2.850612135014197347464512007371469511624647336547380863597026522958389351638925329325864211361675359"}},
           {{"4.40625", "3.163800603288976619542297558662099459127776345948257172928079751633780670148333702513937775996967237"}},
           {{"4.4375", "3.545737656638732611056781822478653525618506322500845353570490033964184425114602742381228738013800916"}},
           {{"4.46875", "4.022897320897881433471367965265766624497222626661161034375557752511167850308209715183529923181209519"}},
           {{"4.5", "4.63733205455118446831908669495962673002033167604849908135592490784364853630436659035964429989580423"}},
           {{"4.53125", "5.460110732358225081268571201584576241967507554680233568022847841671382048904153089722943992228366072"}},
           {{"4.5625", "6.621566538917184779658822397475662809951450423939232173471067230932326374886115835513736745573657993"}},
           {{"4.59375", "8.389349373172668043480112406855801804399985563752529469857319424831372393351619823015010870227400011"}},
           {{"4.625", "11.41394586984414667039249686700424655784704375419079662399301751232175345550471908433956600220150528"}},
           {{"4.65625", "17.794217921195291872116110930917322871062931030345133311457707064544221956249568351463091932558272"}},
           {{"4.6875", "40.17012705640036449304190879290789586501901676251470634007061519017512737181345480527620292167336129"}},
           {{"4.71875", "-157.2053810419425516610333761767147984621064081691004376958977511691902151494982722512124394464246881"}},
           {{"4.75", "-26.57541423100021444925624133456621507049828719711987551420375127874685894467704404079281767156965171"}},
           {{"4.78125", "-14.49904303397407169401387138739025359024482851876427547784737429808056788404653273313794074954104547"}},
           {{"4.8125", "-9.955517692663199659497301146983549868138803040917546840671025802878897403111578981570237166977305366"}},
           {{"4.84375", "-7.568770928466597669950125714728032038595443682400782384350047230172533622281584347829485301888539665"}},
           {{"4.875", "-6.095345265174791895543529207308251915058396610943153120402963827367536675687235397631104150517714925"}},
           {{"4.90625", "-5.093551747761417849838605582864480592041118085930024194611183352044275362666663197560756285563557591"}},
           {{"4.9375", "-4.366960809832423113382187614785174399552256061595826665894310062349100292377458713017173941901099366"}},
           {{"4.96875", "-3.814918596744426621193354615307784649480559936141816068738250826073519922812423391628708426424484949"}},
           {{"5", "-3.380515006246585636982705879447343908709569208285459877176820980918346010201206056831791856009410428"}},
           {{"5.03125", "-3.029148102302771164961521436423971160566131129828714146460894246137584114582867735365596418294127015"}},
           {{"5.0625", "-2.73856823245603647865430226656274757425295307326689315789016177502179223572750955725123296691662252"}},
           {{"5.09375", "-2.493817050876063510228483889992811590654110757263765873027034424090589388194896708294715609776449821"}},
           {{"5.125", "-2.284466361999853132376034939699606124682746442696980078901017290742647881722505799438755300967817548"}},
           {{"5.15625", "-2.103023353734157432798966856819893312894278382156270431204069828145019096032929826221618815522735662"}},
           {{"5.1875", "-1.94396519241478443283285298645374010314101176847753574637302261542129293949555826361500398886874374"}},
           {{"5.21875", "-1.803131092461690600361529359360266463729989122374270260332052248390551413451160551386405337128358437"}},
           {{"5.25", "-1.677326406624389127684834446781355734878514221167662440011355600468562011653802826535309338734910053"}},
           {{"5.28125", "-1.564057206075927617852462348582481289639348906743456817576975327632362277790709160010002260498590699"}},
           {{"5.3125", "-1.461347784441303570775301256747389266430752496556055422309798378517676612642129660840051802732712867"}},
           {{"5.34375", "-1.36761235448791393113713404156603997628029078648313063442112198771680848353561063900933679869893461"}},
           {{"5.375", "-1.281563046345464215429873432637423222317866003116950751512613373376845314748305445490135781753417754"}},
           {{"5.40625", "-1.202142762311081825673780483344209940977316276937937096782702116019344314429792428912212274465011549"}},
           {{"5.4375", "-1.128475389186388730418668294914420100814289081230956940736485357975544285270667364906582995184004442"}},
           {{"5.46875", "-1.059828347715565927266867602143137996921061876523369816266086983272908895834550263458873978282357056"}},
           {{"5.5", "-0.9955840522138850177019161740702867286905993509040201421089147368547994233084178348523042915084083077"}},
           {{"5.53125", "-0.9352178996735373313249149491276249977722839556692437323635652451207536878974422360418217978053551773"}},
           {{"5.5625", "-0.8782811077026627420028846442823333510762218192932291958379466783448865095622083395150126065512344446"}},
           {{"5.59375", "-0.8243871973186229222115460053416379931615277523370335469512772188350449840600638037662602397836368723"}},
           {{"5.625", "-0.7732012463758734614771474685457909254527078194270700631060606366411896649393019485319264721701600447"}},
           {{"5.65625", "-0.7244312708999757737148502388902211557937330882505616499576249426224616653330080051888518816616123148"}},
           {{"5.6875", "-0.6778212563139696041943536024958433042316769928076303165171422834039846729764625273526488517789737417"}},
           {{"5.71875", "-0.6331454792161440424929262529011204753164261484247750443857435235991899745283883164285814469564729784"}},
           {{"5.75", "-0.5902038468644901054170195032663081108054249240846444267071062035473153343668376567479794165486184472"}},
           {{"5.78125", "-0.5488180452487470465583585186996023704202388711137425402809495353782052794835324270116435144444853907"}},
           {{"5.8125", "-0.5088283340526268433264568968479225952416460593340160732760808861658301198202358775409378607410253813"}},
           {{"5.84375", "-0.4700908624280941936361204610007198415053847982327139590868905985009927783431252538270334618349713453"}},
           {{"5.875", "-0.4324754064907757695440115128522408464584984965503283137576460100497915888775090560945910034482914049"}},
           {{"5.90625", "-0.3958634500577715728387322802090283590444850041488349012771936138475077409268246305105488709941047507"}},
           {{"5.9375", "-0.3601465460097104261765989532960199175446047549989388477273964911510226366930877544365028188123550406"}},
           {{"5.96875", "-0.3252249079465421281971924062604461228563045080514509080291865924060718896122952297947720584304400305"}},
           {{"6", "-0.2910061913847491570536995888681755428311555709123391316088271933046559131122021519996248059475229616"}},
           {{"6.03125", "-0.2574044312501190948926553260844066507272665964422420930835303888833069876363053415593229084989769505"}},
           {{"6.0625", "-0.2243391083295019990486082083153394557139168759436924449745473819036543999446390847474833972561431122"}},
           {{"6.09375", "-0.1917343220126000636733861789852210342976612418141698349764104452472624060435608559813294673409175422"}},
           {{"6.125", "-0.1595180503486741129487427411798597329274963598657430717585348638114328150730071113710855848882228728"}},
           {{"6.15625", "-0.1276214813658537291522157530092700353508309312306960197241502999632222071779029887930485312029959035"}},
           {{"6.1875", "-0.09597840190639155007190320592294119000151190572960121328263061886000450929267149036536453259308092125"}},
           {{"6.21875", "-0.06452463203653075216342354397349405171379838323909874171208799994716724111404978040328803565744248937"}},
           {{"6.25", "-0.03319749448301144438419631194317525127766038457693080701966081495473675499225984399367237591921526005"}},
           {{"6.28125", "-0.001935309595765553843691829525274435788517976054625627169224279956186864996201309127614969112751901202"}},
           {{"6.3125", "0.02932309291350979792274199376680897224174579057648744678958323756547521586508413864276599103614351545"}},
           {{"6.34375", "0.06063885372047505801221326406404454670246033034497805406862823133882341608599003383282431176702261307"}},
           {{"6.375", "0.09207356314350050835492397132807778236841887606137324897895572241559097713132233298612222140840431269"}},
           {{"6.40625", "0.1236897479096077296070838372979705928368188283231838414804934929274025398571452124588393065510099759"}},
           {{"6.4375", "0.1555513736514298191439929689618245053471522825437403514671018199418895089031472964835239198291348668"}},
           {{"6.46875", "0.1877243718114725376401948692378642961122451437059168414418744613043681130520375192781612678122611322"}},
           {{"6.5", "0.220277200345896811825735903245910395013134783433298671312565971040207859095962733489570927809983752"}},
           {{"6.53125", "0.253281448628424489171015810263074415662213222146436493340123226398154356922736152388141063544543841"}},
           {{"6.5625", "0.2868124983022992902396435016696204994189572656467726352599962917225918966603261177449285587256173481"}},
           {{"6.59375", "0.3209502535782458942725336084114371332732723992168430541003499245591367871623197594684565991267905584"}},
           {{"6.625", "0.3557799567143647005420612267605866339037398845912245431900523492992941964222774204935357299525662811"}},
           {{"6.65625", "0.3913931072527633586303310805574337028074307951034635414359349547707586122479246892158861767238081689"}},
           {{"6.6875", "0.4278885071761893999613016206982314187458164558702387841850210320754507932238151571774989545334487634"}},
           {{"6.71875", "0.4653734586819128141559933341200671578345456984030117446615279672146457039797505409854792515433603876"}},
           {{"6.75", "0.5039651470083475548132524571742890116543823430974166616625221219450482100216791892806202009417424483"}},
           {{"6.78125", "0.5437922480355643338730870787135605883829637094412174029296025101763018004204025974330398781596165429"}},
           {{"6.8125", "0.5849968096716556782374159174641655681779685895667304240747256104820508784969531169383146463204412289"}},
           {{"6.84375", "0.6277364679474334892591612082171255002710958195004825881252644517358490289176441185242244713866378973"}},
           {{"6.875", "0.6721870741034611638659173114401257239025537597591200195749563598359978601937626091399638175089362186"}},
           {{"6.90625", "0.7185458288995548400076077740862700950460682676000352992576300205153430366069275776925317595307700138"}},
           {{"6.9375", "0.7670350464671162556530262845461572442649216262010355745804068537455730294466119988902478588983034749"}},
           {{"6.96875", "0.8179067044246350052260597321820256016080683284701549230268748786223049718597359248253027839270497755"}},
           {{"7", "0.8714479827243187364564508896003135663222034245984200644480154523301674476556679351044748556811165168"}},
           {{"7.03125", "0.927988055100702558366453168987743089267307369461721117972360539733706484657902890137954063374826404"}},
           {{"7.0625", "0.9879064802291251594676053789880311203133455080943572829265181459625625927973428370265184881799942024"}},
           {{"7.09375", "1.0516436537462216418830263449985522705286903110788757629051396054699693751826899237943523838887297"}},
           {{"7.125", "1.119713940340697920929231941973033073135897434271449197914919579212768620587877263960959541708252549"}},
           {{"7.15625", "1.192722326901007588684149485242155872646533354464514409876904886587006629927655098723914331692457874"}},
           {{"7.1875", "1.271385753083766195102512866837447084316821755807112034055075019301218550802923593730276046614253933"}},
           {{"7.21875", "1.356560730687106090381626490498188582130942795512557181635747233593968595718598671759051546605979157"}},
           {{"7.25", "1.449279530126825400966804908182545262594041927922324311633865090981669827371184783228521282728877249"}},
           {{"7.28125", "1.550798206734497978345598394969907597227586253061565831974177990152095709794984147425013361851865459"}},
           {{"7.3125", "1.662661250535958572647253880444919849918733690439628459569418630367100238120581497993662350014826086"}},
           {{"7.34375", "1.78678998697496418766617671089138013384203233815466866101103271149031802024685694556034074365409757"}},
           {{"7.375", "1.925605576103531021088436315604614476223254075602410795428544750301783382496712246458936951616523844"}},
           {{"7.40625", "2.082203514638078116771326575602059859463528643293617740928645387731580498162533103205305011512631601"}},
           {{"7.4375", "2.26060669237264261355866723509904048590096081733761353611694012356866351200745710198451308329107618"}},
           {{"7.46875", "2.466141609729379985621243345839389610788373993111041429799962056660510586368685947727836988290301937"}},
           {{"7.5", "2.706013866772690776762802272387995008883446304522264964682388787620940583840910641036913840080466461"}},
           {{"7.53125", "2.990217991868365275378986251269668199642886675694545360724616292050097614350992705530127905271866877"}},
           {{"7.5625", "3.333032524336291185691514966848310245587002670642998146766838315216031204958906362527023258344720302"}},
           {{"7.59375", "3.755592314437586774843968169016218401146579356484719112952387050721790775719524338750656820475167322"}},
           {{"7.625", "4.290567124941375634141691032410770755182292184491365711713765284134592087921445364428118108025228059"}},
           {{"7.65625", "4.991276730757292357917427430609014256293569739250152073504758948209194194425629988371488577185989884"}},
           {{"7.6875", "5.9510718925579227833281678276540391546652969268664831508775318977823975271243707799244732578159289"}},
           {{"7.71875", "7.349587230185289251288167334999299680627536804325241700547934306594013397091284138506685042660382893"}},
           {{"7.75", "9.582397403456211211397313849974932847186773522851876679318331037683816539880381009086487008735246101"}},
           {{"7.78125", "13.72492306901017608779850845108579464520662673186624419937919970195919428249551440291202224739747059"}},
           {{"7.8125", "24.09322543772519084215097143980037097594901385135011887012038200799428585198794379628997732285582328"}},
           {{"7.84375", "97.73268930511967729279698949083284985794762903146492273796908122393941623833579266193628175149777252"}},
           {{"7.875", "-47.57043136522765090736927872199715977332175052521738553413789183297556632881030788665564177584345509"}},
           {{"7.90625", "-19.11460505409424788533123395282424237931209756369617281068252559403871558997768678144456749005346186"}},
           {{"7.9375", "-11.94556191307435573940630678240021478719574633441063345522218692801937432207824662871635357235633214"}},
           {{"7.96875", "-8.674912622365588398920385347547421582720453172032529527100491584226967033946983107374195473719464544"}},
           {{"8", "-6.799711455220378699925262759608633364881412661473712848121891484119304982720857546088989511220313601"}},
           {{"8.03125", "-5.581950808689684669549294209348398629337304002995630540331278821921778288507014685935916701606576575"}},
           {{"8.0625", "-4.726032195156837427410372612416284237028321048638455837876262548466898310633589798461547191163836986"}},
           {{"8.09375", "-4.090461187975555242897409987452358342061343516721018283559611963305885456193756951211377465919516297"}},
           {{"8.125", "-3.599001897974260972151248247566727216299014591900000335282979733754229851045581086180509810930082767"}},
           {{"8.15625", "-3.206943184854794792051938572955176223102804950834430935020353335808782541779058955201736266932317623"}},
           {{"8.1875", "-2.886329592416760158849088002905458575851623094189615497250550481681316568867901585210424096370674517"}},
           {{"8.21875", "-2.618783945156319374614290552008768448544289531418583013216952580114253625700948540561589098351543348"}},
           {{"8.25", "-2.391728174447109499408796092049518207948088283366738019362364536579358984891061627461448588900266354"}},
           {{"8.28125", "-2.196262571237231366422169733787602194377870425422442983742466664711276453593062387209663908411122531"}},
           {{"8.3125", "-2.025912262702788461190762240682190168816613310552683831653429045356666462021227127736084042613847923"}},
           {{"8.34375", "-1.875853575963005310284960792984729880727224645450131943927210730483841090952411053279594957173517387"}},
           {{"8.375", "-1.74241880761627240539700340437602803932808901813845968268891377391077356174950266498464542879686652"}},
           {{"8.40625", "-1.622769124048113033597644536164719722449235338830292053581380926565132897863391794369515824501033615"}},
           {{"8.4375", "-1.514672563181530134110926429438194143845293739750523302549165608155316405124742878421871789886842147"}},
           {{"8.46875", "-1.416349739641873214089748540260482127074454913435673678582846741597865860350934848935327297727726336"}},
           {{"8.5", "-1.326364327785606923837177509628989183019847616858933039728626565320594601352898256466729337047543442"}},
           {{"8.53125", "-1.243543859514378322699255610900405730249411506966951588519354941299030591219071989214839064576899506"}},
           {{"8.5625", "-1.166921477042600182902656425322990210134485019242760863805503078706720819497128002394896106356209544"}},
           {{"8.59375", "-1.095692443843841888393214442111438580869887527193049760552789795233066505667689248095554577112371625"}},
           {{"8.625", "-1.029181226242794530622671562005776602295969084821805226400002870767989174122034536280082461534287795"}},
           {{"8.65625", "-0.9668162629797675117200288525867759956705289684684092618655305272884560415249588622588640534660859208"}},
           {{"8.6875", "-0.9081104046373177832576347663891532295331575111187881417687389316634049160994876797510769206182893432"}},
           {{"8.71875", "-0.8526455881926773939956486059670750827771160223765816890633669305249823793389660138647216198961396045"}},
           {{"8.75", "-0.8000607122131663748996935033554250873516322431753295881939448427095672520914736920285067785494755945"}},
           {{"8.78125", "-0.7500419570576314664068876238355166376078921127752475362685197014336164568978380363973382424380027378"}},
           {{"8.8125", "-0.7023149914660190721137439943663886714896255005161995584377885528996116609571672651781263426423264383"}},
           {{"8.84375", "-0.6566386479456336287953742502996364274330999062289317807304964691314686325574451710087769117377447232"}},
           {{"8.875", "-0.6127997515327654285376783646363991279819055057055158641281938301880811035156798875165049539694804864"}},
           {{"8.90625", "-0.5706088613603129182915651449940477497513792905530365057563881633464714239146849295760180740616051507"}},
           {{"8.9375", "-0.529896739873168003806242065594283411489762262385879653776325422716635759568492302090915293632301029"}},
           {{"8.96875", "-0.4905114059515517049978410600006085544703557897386518199219966407731976599471950962402695227799723485"}},
           {{"9", "-0.4523156594418098405903708757987855343087169256619843288072463344895615552699928891423222740611696987"}},
           {{"9.03125", "-0.4151849883541607117552210974950947708368354992200219503945689498048994961045141832240492234717107402"}},
           {{"9.0625", "-0.3790057881989822857530457874776947516302198077664862408128815699029163107706671425087481058924528226"}},
           {{"9.09375", "-0.3436738369929040836550521796260295565231979408984456062837271050291411394204206333260572683795806063"}},
           {{"9.125", "-0.3090929803907614767471346771315481283472474354946281905565967857578879461207205702332049986857635056"}},
           {{"9.15625", "-0.2751739899376987485248300510983424723605373451217689431344224438486165931202115441514245211478398115"}},
           {{"9.1875", "-0.2418335641420615678638155264698574025131647248333694816193249713183100110082265076470052022707012095"}},
           {{"9.21875", "-0.2089934473583106794872121428783074116994340488341375724854578952783525682316496422613143306038638671"}},
           {{"9.25", "-0.1765796456511299761112751840598406521389487242985432214413528930195762314982591148356765022144220392"}},
           {{"9.28125", "-0.144521722122150591814619269577170465800891448238859437753351534510505894724788264050561053752147101"}},
           {{"9.3125", "-0.1127521567973819422597203631074129348120757432615503831725905368424112610292538623181492998345439551"}},
           {{"9.34375", "-0.08120575823178342176032872038448411443172784451696952348584885928982452335749552547386985037617069992"}},
           {{"9.375", "-0.0498191155899860392003104787951054631853528180570175470879940653716436714322811615959161544657494618"}},
           {{"9.40625", "-0.01853008118625405320915271202115144102822290582324439033642733950763784110773883754760179758258022532"}},
           {{"9.4375", "0.01272272563027105977935573889462983744829956962204063464126832673322950722546841176709360279348538747"}},
           {{"9.46875", "0.04400040173584953885682440835958114627885199630660893827828903912727543614728912707303196060753625141"}},
           {{"9.5", "0.07536423875739405740654014205323665789342966267450384287846707728875924157814476147945907817392192786"}},
           {{"9.53125", "0.1068762048461025163674352287858142449224256724379234993543813605972685100190359293029737215855453465"}},
           {{"9.5625", "0.1385994377761661718602480104778901941178589868631124656851160671189176086579048746331765092114253163"}},
           {{"9.59375", "0.1705987577719601866335639057437200427987763331813918550294340474134857881430332967127222805799022305"}},
           {{"9.625", "0.2029412090417411123603662227278784038776298381618810811646084653751029723759416476460088872408054991"}},
           {{"9.65625", "0.2356966398441474632357392833080328068352054698543206659897268100728097017667724684606559049124154157"}},
           {{"9.6875", "0.268938332074403309291166325486527607211725274017137932139784676368590535825858340593417854926297648"}},
           {{"9.71875", "0.3027436928841933821970886411755473788376234496119460628913545818204169198969541686968930178216130025"}},
           {{"9.75", "0.3371950228159297335621484819773554194812863370480952763499236064163820830033268339692324715894157813"}},
           {{"9.78125", "0.3723803774359345699506506000690612357176932379964207743390433297005778841484733220050565284302113607"}},
           {{"9.8125", "0.4083945426204256871181400863951603330453056915705065091908373104020696107020950522244595815242992"}},
           {{"9.84375", "0.4453401476523343154827952361952568691359033281221121303793343966901885521315031273219697042193257942"}},
           {{"9.875", "0.4833289453490298299990038076226424305503958067355696981733291906588949898848660168661363237230401676"}},
           {{"9.90625", "0.5224832948561672053074357426518017813969502851835052528668887798173320745102979706674984553747785107"}},
           {{"9.9375", "0.5629378909036186388354128640753191217895638800506841967942363059454826038558876839732857927717227769"}},
           {{"9.96875", "0.6048417937509008993401606503437317082375426212574423350794174057182764889826011397690814642006452007"}},
           {{"10", "0.6483608274590866712591249330098086768168743429837249756336279673958556003746239008717172062971522862"}},
           {{"10.03125", "0.6936804314743542712398847790886887683057558913351293442530262309817850224201884209136086813403394689"}},
           {{"10.0625", "0.7410090731101333158449425961247175839017373828496178608167740610459452518219259199024083200316084101"}},
           {{"10.09375", "0.7905823581871925973468103245168030277845433796367670128316098222165598426689171297882306893568062531"}},
           {{"10.125", "0.8426680163689236497241316220032744251657095955743734411730267063148126128540903336099720150350195161"}},
           {{"10.15625", "0.8975719901861101829801016952033465293839624897512338971033212391126217276476390113488747550991133784"}},
           {{"10.1875", "0.9556459274758633915064588099748061258315512098776637126437164255246444193412583209025710708854064641"}},
           {{"10.21875", "1.017296473311965646505591388794303117791831049823203228782533350726187433458132860834038283268836837"}},
           {{"10.25", "1.082996890215945275135930985916637983213229101767681562664207604721345006616414244816945101012068962"}},
           {{"10.28125", "1.153301720414501166084164165377670663086784905305525053523750216145961391216299317767459210812275763"}},
           {{"10.3125", "1.228865465058231603544476514726969780448778330773071834149679410133713041325810373844792660869193974"}},
           {{"10.34375", "1.310466629156747359552320115718026861262813059499884349607868463460206624928464716803324337065850131"}},
           {{"10.375", "1.399039024262115717131604647733708995170160567832938194238903453989697561972061091597355404503662754"}},
           {{"10.40625", "1.49571302349195916111981867105861656396166182988283681852423319036111614206596318006249059781485835"}},
           {{"10.4375", "1.601870670512520509271426433671643695090231605946938642547694243879213679699085414650549829075718711"}},
           {{"10.46875", "1.719220395521651499721208794808194478968865549194510942718291121399341439043920644901884496910696737"}},
           {{"10.5", "1.849899993421927279907583573513910565419553685959044018741794327382830123593588324994882461965573398"}},
           {{"10.53125", "1.996621179417850643664093294309064624983038139124591902589207528735600835709855269195187933895652101"}},
           {{"10.5625", "2.162876723677546330469959787105963848827689014945066557592989408260164364548287694286197662196239537"}},
           {{"10.59375", "2.3532442330793790868766441879841993750130572630209439743618231460831573709883106394866434440837641"}},
           {{"10.625", "2.573843631271674362526537866893410697197766596999920083319154750577002457483161716337803596844925106"}},
           {{"10.65625", "2.833047421190427952095570132770964879184235914846751261896726812931990128759669900544999535061769791"}},
           {{"10.6875", "3.142623220176844496098570587446827716363816198180813628746017544330426339542323699691642256030772053"}},
           {{"10.71875", "3.519650155321593637030342256680131753850278370827948246193900683195030354927519452141570420409057437"}},
           {{"10.75", "3.989898450288877172272878730129464264004901452428968181149190336688176169073686050444717716156454253"}},
           {{"10.78125", "4.594165609870243515783279467995060486532380531283432068617070247011706442921648714627407953983920726"}},
           {{"10.8125", "5.401101953070107889048337369479695723086844105989269027204537226522869955593746957868263836003479647"}},
           {{"10.84375", "6.535875415517406207251199308597767679104658091064327476058394143828942638073632382427758536504917985"}},
           {{"10.875", "8.253411766339305537723460693388679535974907155823982004597806731192500887738499761977958603336992426"}},
           {{"10.90625", "11.16537284500979684723686544686940420453225367789354062936636940962591367864691678374577954865828186"}},
           {{"10.9375", "17.1999620041711094734838984205883317149769089588687370821690524219299315809266573264745104659869829"}},
           {{"10.96875", "37.27070620721793879698276661020742630154681506539144657714408230209752760393928366701053772541231071"}},
           {{"11", "-225.9508464541951420257954832034531539516575098851311946310945881123661134104031654779989090875181672"}},
           {{"11.03125", "-28.01838123473997016830887833476199550560697066011986939559933525309909705318537405182199378012840027"}},
           {{"11.0625", "-14.91962506867234581945151895985710289930225918712794589354339983163930894702818997439864076091931126"}},
           {{"11.09375", "-10.15307233756673521728139815893864848321827456537331024001764086854554203725293661816927668294489745"}},
           {{"11.125", "-7.683249828520493578856827081745572284486853920128557099054138395954224416767780846216824234128741871"}},
           {{"11.15625", "-6.170065007339837672004969274368706522165797321914087418607341946608032746141308987068347258026539261"}},
           {{"11.1875", "-5.146216397928971013498356330072590228022047015189051411856482418633925739244947714746552179251733944"}},
           {{"11.21875", "-4.406134215367990783634732996136714284665546485639321948525683144032506137127272195504713779988841399"}},
           {{"11.25", "-3.845243526046256589195292015214843119217023542577367989034898325348687250589462590349993156554307721"}},
           {{"11.28125", "-3.404725196340913894767892653680241020178288686778598191582702368768260415894176917496336011269246961"}},
           {{"11.3125", "-3.048957435167265586183006322737827462691340358802500561060757089057213237102895081676386924312658609"}},
           {{"11.34375", "-2.755105539085522466956356685286240136460553349428076133380205505661678601069631697225730693586354901"}},
           {{"11.375", "-2.507856046343293846165268336837981024254374791359792671451310995149841786950224129840033693800933455"}},
           {{"11.40625", "-2.296555085357014688557714000971300925194148838031073606034513705752180239656706450912207637184212202"}},
           {{"11.4375", "-2.113560858723099424307258719446955475134681339177645144130883477669849838830392714536871823793018366"}},
           {{"11.46875", "-1.953248965442351814769641861822757418968218808226145477990020040801933787597505710461744957513141637"}},
           {{"11.5", "-1.811387450326824859772397320474032833639713335926721521705076560469479148263546424971811321096648723"}},
           {{"11.53125", "-1.684730597525019137697751820797269016453098562968854704274935631922618587469362028272636692210544871"}},
           {{"11.5625", "-1.570747064811472615228088301480862011854346986220267355439332676174065617757164643849543074172144195"}},
           {{"11.59375", "-1.467433230574720919411941987695161181959171583863783447843463212366085434611122065381627004242638947"}},
           {{"11.625", "-1.373182138457896453349468046455100980035443259553659899722906361390876088856423969181083376455705666"}},
           {{"11.65625", "-1.286689630920366616376314221177221139006716016538511655589760746532540573609680625603641074608188434"}},
           {{"11.6875", "-1.206885914221201720054271911345572193315238450358663840449617121968073512366326525649980278803416278"}},
           {{"11.71875", "-1.132884861825656481798873135046969210301345541577298019300751660619960162890235612177970957925478595"}},
           {{"11.75", "-1.063945912486004409710559363045985530861938320222047288703751234746510874929602501339045816423036172"}},
           {{"11.78125", "-0.9994450559333915167440624304322053019403928948191033206551515159313846021422418864273459645373449009"}},
           {{"11.8125", "-0.9388524723222944773205643428254523492068640072627707382490811032852295370278108292005146916272238994"}},
           {{"11.84375", "-0.881715108900528303919177723946502416645736801861050134491985441499235913287446780705353461545417442"}},
           {{"11.875", "-0.8276429652929236471146892695710241706925495072977152657326004944101623406458452837545349486881138268"}},
           {{"11.90625", "-0.7762981960095720820932228114020179373213795483270746275212139165301756520252573166217954465331159458"}},
           {{"11.9375", "-0.7273863753138267917778418153001732955258816548283145725251801363629114248343367970028832122142992284"}},
           {{"11.96875", "-0.6806494377457210277597470928336025589584620324058462321470850608946457200573674297093242265437051282"}},
           {{"12", "-0.6358599286615807924609379429390076061509587586686860914514606814656551214484123291399643068894751555"}},
           {{"12.03125", "-0.5928162873294508906897144974924364212100987037074180867630829726623330818215300743873013630492129075"}},
           {{"12.0625", "-0.5513389500434250704976885869765975030435162971228425993732710884431519725994082993307502135366704687"}},
           {{"12.09375", "-0.5112671090040856778211886692327830312529713244160725823950417285454010972749346501560988873183882094"}},
           {{"12.125", "-0.472455998959126666328373026314261347130558625459848565935809588092219192527888607849005967299526205"}},
           {{"12.15625", "-0.4347746110466813389220145482909141465629503223075144609806539759358566301078783883593960376790796208"}},
           {{"12.1875", "-0.3981037542382981122358374348325646108510087325306228562334315140437947730049798142715674391074029588"}},
           {{"12.21875", "-0.3623344008952777173267729097645609415931859827734307762367947830110639831467043405387353622176899024"}},
           {{"12.25", "-0.3273662654331959909797507119051924955282853934206185144087221653583658953364484322496982215172064596"}},
           {{"12.28125", "-0.2931065748149348906573126400315634011327627839945547849105543140713203189089283254450491988430709458"}},
           {{"12.3125", "-0.2594689972120933396662267471796226223140842016040887149108653318448105627021634377488137220685751418"}},
           {{"12.34375", "-0.2263727011714726746425617255174464360665584672063083345910005855017649693977414015628137560181413471"}},
           {{"12.375", "-0.1937415223592955920421472499371716132396126974936842056246045191659136204224066400221303821918510103"}},
           {{"12.40625", "-0.1615032187034938758288345646836288312549849485871893783750506125037934982810946747034471565118071181"}},
           {{"12.4375", "-0.1295887977200466002615144930375243133915724779506460096421464176334192279649808190617654665646655393"}},
           {{"12.46875", "-0.09793190214949804406939767223801097423536917158984066549241688209747906679339832186909184479038423885"}},
           {{"12.5", "-0.06646824186327419610199266949441387194390610792357612079517505380578030434009894147743014400122005453"}},
           {{"12.53125", "-0.03513506141616282076636047393093268566965509833708523530838721391339373252314877573835767237228949322"}},
           {{"12.5625", "-0.003870633688692445796420680716701608075985971581256241161345780831826430572573689071744247468488929075"}},
           {{"12.59375", "0.02738622916941998236655243276631287278486472025157424329703232697741123275406245628528750156873296529"}},
           {{"12.625", "0.05869665578128338112635128913606850911677921227526205464651894469274626817414600063862113806671147531"}},
           {{"12.65625", "0.09012219459725165729474121609816933257302657281344601700769732387220992191083677289387048548334265912"}},
           {{"12.6875", "0.1217252999603408610668897042413571531127645503736599822403036205555496676066474076056000689949341066"}},
           {{"12.71875", "0.1535698333828775342772949638706552097777256705040011551078273258533143177119249497623834514512966756"}},
           {{"12.75", "0.1857215886751401902594186441708939448272141506734588329272148156845153012668419405756499880982943312"}},
           {{"12.78125", "0.2182488502657797346752690950871572837813792443000041521932413723748578742375061893600646885986149118"}},
           {{"12.8125", "0.2512229950428828425999138094132092852018197118941615412720196242900796512859843472371170313836583775"}},
           {{"12.84375", "0.2847191493692259054394416502657415422614131291273802036428533121457701035912610846112501083132620008"}},
           {{"12.875", "0.3188169146481101964165914224483354040480603343474688683709071564169780696806924149291320418944830542"}},
           {{"12.90625", "0.3536011770209831976646321735648611242564793780159081807119024532891168112397727872069370118132852613"}},
           {{"12.9375", "0.389163019575800390066324389631248715515481435421443727622672043630746566664120384677948936473787333"}},
           {{"12.96875", "0.4256007589819842824595519481972026675555296385735056063290277948532474177383987445148843331908874667"}},
           {{"13", "0.4630211329364895955117902835081206683532120959519440470950206693928302579327807145125758116501924079"}},
           {{"13.03125", "0.5015406704601738993466207755375547536965260852964643732753893793547109382261801451895601761930463122"}},
           {{"13.0625", "0.5412872842615681585626378992160244527886510964571032692368478641312818490839188830849928560962861538"}},
           {{"13.09375", "0.5824021335357886328662589223215248727421699777193264549116653046243519880397055116969487363618353957"}},
           {{"13.125", "0.6250418172930577232327055575810817395750497037126950514585195397519699819130820731538599564259401139"}},
           {{"13.15625", "0.6693809734298055686754246761212833674742679018564325405072602539903766997859347462285344333571366362"}},
           {{"13.1875", "0.7156153783773706463324211230116191534127258818669295732823217991324981875804470761472072117982861964"}},
           {{"13.21875", "0.7639656678174816067986696149135126827704120185065555912507382354963651332883430075609034401555571502"}},
           {{"13.25", "0.8146818327614344736464451806034453710444224291621571573625236805118070729970340362557654528804594448"}},
           {{"13.28125", "0.8680486902251570873258425734584921956065820604675624643643164481487468794096033758920520511975882962"}},
           {{"13.3125", "0.9243925880092635749600582006440809362226783655074073519865821148035556209179629462013383469424274175"}},
           {{"13.34375", "0.984089684751991735962930471741445607987192320278600727525448404432994693600540790050738561865588772"}},
           {{"13.375", "1.04757625822842897028900134354672689006793126569323519874122370449523706721491998653522405351511"}},
           {{"13.40625", "1.115361649708918497565229580465214098442269312226313131576538895853120727413355048723361997440716611"}},
           {{"13.4375", "1.188044669282090096413968423531415025467187597047077575491037309801518019505454161493737933958668965"}},
           {{"13.46875", "1.266334595496805761839284321117713547689424188079416196364317291844437171872585239983180116380091394"}},
           {{"13.5", "1.351078347287010480371085577712699470101212829099407611657174914155576868564657173832374341089513584"}},
           {{"13.53125", "1.443296057137394170028536177718664041051292527024487177527337760724543655637891131854085251072201818"}},
           {{"13.5625", "1.544228244055125768572769325179666059641117940456933228593668266762756226316757718141030898582889678"}},
           {{"13.59375", "1.65539925635608625536146268504299540984757874423396346584219270902415141849546774423536235044651061"}},
           {{"13.625", "1.778703933748487611100295794480392286774372855795510955005500225382241572963111907877924106343034439"}},
           {{"13.65625", "1.916528050760659646742064707886848214342582893475968412683323141359371632373241621750396872855231387"}},
           {{"13.6875", "2.071918975654530318165994049833557729201414960634819277207514404216213840009455116234485076356302166"}},
           {{"13.71875", "2.248832798150414958768559692131859458258869348641929756045263587943996112471489439485863476093034658"}},
           {{"13.75", "2.452501131436276534259505261160229408535827308333544989748716942417182101185885609613251793631088723"}},
           {{"13.78125", "2.689991141885544485574819071146851902487462547699495662222675009146133600868249015967786252574495347"}},
           {{"13.8125", "2.971088997454883061146937345921981294715821069297105784485484470539822403438727250351950923586461683"}},
           {{"13.84375", "3.309747852278236334086030022253642441335045150382837946015733966046635972988597769925369044448793434"}},
           {{"13.875", "3.726571412380592611642200928513525816649689030739311675986112325390668863787780356510815096395312152"}},
           {{"13.90625", "4.253314099623669334835259848593744934346239237141072606237802004691075608138259425654524049734148683"}},
           {{"13.9375", "4.941607147834976432334070015221138910450692007921150173618524899066416996751652602822476062787651509"}},
           {{"13.96875", "5.881399525150031955799636707531603412059246766703476508448423108137501182284498677930575806202198028"}},
           {{"14", "7.244606616094805116868776904419943839744730261240134752545587919443539234559937291680749763590851956"}},
           {{"14.03125", "9.406028188605279696133223875198323737712453281000019998207973537233195589286463672078393783342949057"}},
           {{"14.0625", "13.36790967265482265511197119971831749461310263946778620293662813338523575832270133240885318460296722"}},
           {{"14.09375", "23.0180098105772480411418077991835591801343058014965291845911306402355660736744079654039102037142972"}},
           {{"14.125", "82.18587088008837479889498738727608856213126524631858084352266182200806013924238364295643998983071042"}},
           {{"14.15625", "-52.39613928846073424250555787725052081495348867793023995281290229927733884543365803704289494278819236"}},
           {{"14.1875", "-19.85087749437963381473636677142019044036915990708056158011806608744982156130940528545579140382954901"}},
           {{"14.21875", "-12.23024032878110918179097238079573616977352169397336130087278904329232109578073694396971060087189843"}},
           {{"14.25", "-8.825007825823643194479070661167279551172813025945214108644920017576189426949178857879125100439566237"}},
           {{"14.28125", "-6.892346926954325909059194856822673062063097995636142714599547668355292064875194893124728097012275365"}},
           {{"14.3125", "-5.644866498825540128381929944705578552248933555730964244899773528736917184084590171390597212873718595"}},
           {{"14.34375", "-4.771610252795610046024685797665514766422880378783577882983742818079026166693261845053770481989424557"}},
           {{"14.375", "-4.125051680440956814255997242162117938555651270642110578618995113301257483035180159821309310658332941"}},
           {{"14.40625", "-3.626194314229776036712561256911661725676439848577743170654748551410882288678506147976699754338337632"}},
           {{"14.4375", "-3.228918544653384166822369480885301355908586468628448310353628937744136710166892378083809771029038072"}},
           {{"14.46875", "-2.904489208401961365438740405970863838028715766433251544998958231462070708355920879083964796103033733"}},
           {{"14.5", "-2.634069132503832833409607035052858278935807513368801311481801280408668028920599740332367971681453643"}},
           {{"14.53125", "-2.404794639925577553244012746285864594559572350297129379452932406519481483010765023196033751578709703"}},
           {{"14.5625", "-2.207581089523679545128355853946391835592464237094323506839360879131859583353800754571132350944473674"}},
           {{"14.59375", "-2.035829586659772321235017007716845648434117124540496962900856683971781311984497273615528750368081422"}},
           {{"14.625", "-1.884630768865435904935595378906947231717012177189752377379403964925875302521199447518722408719775981"}},
           {{"14.65625", "-1.750256190835124208623312849116061326812165846025415986783560739453729962659158203940996884358758139"}},
           {{"14.6875", "-1.629822991609989147184189043054819627629510818289435539398133590083260226275976603564527843030512624"}},
           {{"14.71875", "-1.521066667289361457373930052890176846963182405346389200320517277799503677666772192617687500257521097"}},
           {{"14.75", "-1.42218336083774197380789085745137021789867848279597800468450871698744869740438289092755542692570482"}},
           {{"14.78125", "-1.331718058572613129017722401996663023341875099157808098995252549045562547044521935057437210333349552"}},
           {{"14.8125", "-1.248483823169844883793467308858957913772012915051151771810074084965259104516379708093866536649015936"}},
           {{"14.84375", "-1.171502454280969620050113939757468091964527953537892858826299161314598145955301346129774398985079725"}},
           {{"14.875", "-1.09996022360423379094065298284739111500559223495806048377446355428125902586706149601540328954397664"}},
           {{"14.90625", "-1.033174396383465269461739738697259215672589493553897443441659340076220701053186730617856132398548093"}},
           {{"14.9375", "-0.9705675907155131163149460322607739770705545946870992276893226926978460501228871025636381103213358614"}},
           {{"14.96875", "-0.9116479124475490508064737825953723368462225788875404013990634500526165327350899245784037598875471869"}},
           {{"15", "-0.8559934009085187640261927782380296049897864414742962979687446281783012594486541122545103129259226012"}},
           {{"15.03125", "-0.8032397302332296612432159755337281904284459733163994877022298441144059785603187789136637043263789466"}},
           {{"15.0625", "-0.7530703960754939484978446924032015414437125508200990314934869704250553438069278960228507610120908637"}},
           {{"15.09375", "-0.7052088187318415299725928408540094093554358958059088325375638362095004704432693353838375709463129551"}},
           {{"15.125", "-0.659411937622644225218300893404169827076548649885412227383887901950221923526355502978543776575055119"}},
           {{"15.15625", "-0.6154649762727536414801474029122625793755198617269250343988631456453788448149731706979351529235579577"}},
           {{"15.1875", "-0.5731771332183040948793178896118867037269598773610412277642977614409075169432893108977656087532808068"}},
           {{"15.21875", "-0.5323780107028691176788965668440942781647156607765742951342412648358988559400799809724920990286528734"}},
           {{"15.25", "-0.4929146351866012621666401573415074523464609163340854530825224584649245974424596583470196176643838565"}},
           {{"15.28125", "-0.4546489554738299415350063572461193751006928326854122963028434583535719327916356408447934270192962049"}},
           {{"15.3125", "-0.4174557284251085623680148206370333657407709127949181945517726979253617292255491330234726669774559159"}},
           {{"15.34375", "-0.3812207207302419203446046603506711987787377766806738457878506795815713138223264722913354548269137032"}},
           {{"15.375", "-0.3458391695028422582485004568448026536356203654713446806415710694635885346246660520826948870993463705"}},
           {{"15.40625", "-0.311214455551825073642663079591570618837743590849903018274057606911872122304533000910107606645650336"}},
           {{"15.4375", "-0.2772569518534830079599506190692912755868921271423525814120233867695893487373304945292237740353757468"}},
           {{"15.46875", "-0.2438830165543173054192587099181568413614402066070223778896735213919894343566763962867244846621486138"}},
           {{"15.5", "-0.2110141052012553133863173741408514435037061655011970687100846880180438182550528565062101594891245018"}},
           {{"15.53125", "-0.1785759811388596991279739233477573236616687666102227187311862264495771634608666297275574790232136991"}},
           {{"15.5625", "-0.1464980063716879847555275878278898667317766571375499828106145375100216949704230935552550931052323183"}},
           {{"15.59375", "-0.1147124978452713735943481847220917786442201384229215777788278473922030662630912256721375261600875605"}},
       }};

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      T        val = tan(T(data[k][0]));
      T        e   = relative_error(val, T(data[k][1]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
      val = tan(-T(data[k][0]));
      e   = relative_error(val, T(-T(data[k][1])));
      err = e.template convert_to<unsigned>();
      if (err > max_err)
      {
         max_err = err;
      }
   }
   std::cout << "Max error was: " << max_err << std::endl;

   if (has_poor_large_value_support<T>::value)
   {
      T bug_value = 12 / std::numeric_limits<T>::epsilon();
      for (unsigned i = 0; i < 20; ++i, bug_value *= 1.1)
      {
         BOOST_TEST(tan(bug_value) == 0);
      }
   }
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
   // Check low multiprecision digit counts.
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<9> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<18> > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_tanh.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Christopher Kormanyos 2002 - 2011.
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//
// This work is based on an earlier work:
// "Algorithm 910: A Portable C++ Multiple-Precision System for Special-Function Calculations",
// in ACM TOMS, {VOL 37, ISSUE 4, (February 2011)} (C) ACM, 2011. http://doi.acm.org/10.1145/1916461.1916469

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPF) && !defined(TEST_BACKEND) && !defined(TEST_CPP_DEC_FLOAT) && !defined(TEST_MPFR) && !defined(TEST_MPFR_50) && !defined(TEST_MPFI_50) && !defined(TEST_FLOAT128) && !defined(TEST_CPP_BIN_FLOAT)
#define TEST_MPF_50
#define TEST_MPFR_50
#define TEST_MPFI_50
#define TEST_BACKEND
#define TEST_CPP_DEC_FLOAT
#define TEST_FLOAT128
#define TEST_CPP_BIN_FLOAT

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif
#if defined(TEST_MPFR_50)
#include <boost/multiprecision/mpfr.hpp>
#endif
#if defined(TEST_MPFI_50)
#include <boost/multiprecision/mpfi.hpp>
#endif
#ifdef TEST_BACKEND
#include <boost/multiprecision/concepts/mp_number_archetypes.hpp>
#endif
#ifdef TEST_CPP_DEC_FLOAT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#endif
#ifdef TEST_CPP_BIN_FLOAT
#include <boost/multiprecision/cpp_bin_float.hpp>
#endif

template <class T>
void test()
{
   std::cout << "Testing type: " << typeid(T).name() << std::endl;
   static const boost::array<const char*, 51u> data =
       {{
           "0.32137338579537729992840434899278935725496267444911714908205287462634251052210833615032073534299473485492692600156322137421801432333125051088723502425037485776412801577568405892077585206768190530859883094571475323319480739773193974206966728764224286661945738178210577326172938196062277314761537881936346874075881338768208490193827960565412814349738654540520356903367084438822830345189856017860672463017",
           "0.98628073997374759901559180515206275902189609982907214282364143439537215491113710345866034807991101303183938339561499559327886956280789743287824488269072297413440935381715378233031399015496124706604318545539544610760151756970229801074280545428642122005982857974921606264103186878499260552388713716032507770319550435738767597150644370033277228635793175246197730488375240713357827246166262087899961098648",
           "0.99999659728082161113542951278514830809677661658635225532792520501703544628367875293677270218317428676793098034276042396396797568103263882451732810190507733063467333056356770774002596898762991629653041854653269824642873291146068535300466473399592751219449187768646625229500705182676930009096545254478199838990703077597971823456671241141900968900216742636822174010867343154474773040184900973368250708724",
           "0.9999999999846483268200051609594321550129159997920576480976206867496512752486590660437091205989616108531910897733432934135954788151766561209164605337537937873588006552145390152387235783207736999759875845070169747521389728857476525437483543080651125798739562649414879487621858466223255239845627205850217328574865852922872737234283038190096982410137471391847466112651349436875974689271288261759782261321",
           "0.9999999999999999987314527242099750648171958211319474558707792311593804963057878814487720997303512134007272111464990650500302215773762906820778949397525329109311974741708703536680512747226155618703318739024344621256722269608969415280035337052044425138281821760268269187377517243951584969175035549994883451471918693502477485385682884154959809285569290940740978684264145737164182111806308430952867505356",
           "0.9999999999999999999999999980800953069847308586840237590563929855339557065536765765234844240789584487443451033349994294426525006157530320529970966048109743850154174651033567146346966529198814047607015842020039899630884318521543225160212193994911746894335846264878066530266737005606770102869237101848445559941638381625615207320468184414917265299980278164193202897754476112968080358662232635784904263624",
           "0.9999999999999999999999999999999999999467800140220866754762922747687784133233134010432889959570821554455247528344437918197518545105332713456859236726383195243056599177018396579766073961540714510399202497404647103138524118065391185503678895059096790300665805648569647351935897874460587855127436472608470703384261586158923066272124216158518232588330799027603391275039552776308636189531809031683723259525",
           "0.9999999999999999999999999999999999999999999999999729795912960133359928587562229512337339217831178574875626619226954752643039860388090399659478676726654102118545764943682017611574275691203710439707807193180604656837503862242700430179591666329131728631752773789406064618682879167351725013888294859467540832310795515139677375807407622028485242969471516812171475098378942187864794497220152019202351747432",
           "0.9999999999999999999999999999999999999999999999999999999999999997487354938310440650220692519525261552411539996830587326435051159231522052011310872619940247463640019105467860778515384738650636054646551611609757125760437266415865214306396520500343113189907306851418957620080971645943305760132385139924583154317156560414548076370893360020924960120441059315311380109752919823616149973862196846266297710225",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999572050575304159358359221596743379014313563214857593401545331495211888415913558896516895286943572966865708195832339959764445194449615969154689769557903166971249521898883489362426386924297872088925852892350150865941427355319827260914834268754732102528105919811851193667193380541054520023003326858641189063542651960743457613",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998665016733514821204959171836698281165918083005790816030823236096080522860514417075411055633676502699904415882389102672678124683084429720879962355892225321369091298491658349178472270952759208443767848312111069127329160464884932271685986610697222434145553035947750809388321614695213754318979469071722942883",
           "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999992372516628147584832950728021842198359205201519966391076994594773600474674435473005118571751514446148292787696117866094991476340344341061706866751156257825144909115117822189019766805825304055482958970512463798453229341693148012213183553546720540880444569824125592343803193018989122964",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999920180539244323143459416025663362517256166793900312667214543096238752838226369161775531456005541374878274529461511286842988937830155704737448202558382612829022464635400289328916240002670783433827234852858267621807568393874737879853500598862298495727481132883728328",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998470116425957155787153557938061034698436461173594805292722874130433614266475136267606498346730583487791266503943659174886554170377537630914770998114573340081594827150737005158607830579000912020838690230498119348251553312722575955142752845289",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999462931048083476382670449719737943481963930626760625326765703815392249622625483433043363664396638162612437367800102332819699131841317348173451308570776544874933173719394861336636728378134900422312720743996219523365098",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999996546783689748726752364896615532860288057097437452774779386074906915819380531729493071959232887620213723607155628959529584572083388979892309086717786559916703004365603135284141639480887703759",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999593332381019647939423999969519583099837564321056588766269967853479478603122899456262904869063959564274215899007623362296377022418464303752396325625838280378647335",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999122842714667567128203355585346559126606029196080721845292399104475997315344844970601651757832506169948906646054332493537761143729664",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999965347272050374435790597917065458623422102880662825928396981295898014081371503733411536311258910851858",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999974926240515037403282500845454464621558236030794140169313830052413917",
           "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999667705192725716176070161727364499",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
           "1.",
       }};

   T eg = static_cast<T>("5.77215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749514631447249807082480960504014486542836224173997644923536253500333742937337737673942792595258247094916008735203948165670853233151776611528621199501507984793745085705740029921354786146694029604325421519e-1");

   unsigned max_err = 0;
   for (unsigned k = 0; k < data.size(); k++)
   {
      const T  x   = eg + k;
      T        val = boost::multiprecision::tanh(x * x);
      T        e   = relative_error(val, T(data[k]));
      unsigned err = e.template convert_to<unsigned>();
      if (err > max_err)
         max_err = err;
   }
   std::cout << "Max error was: " << max_err << std::endl;
   BOOST_TEST(max_err < 100);
}

int main()
{
#ifdef TEST_BACKEND
   test<boost::multiprecision::number<boost::multiprecision::concepts::number_backend_float_architype> >();
#endif
#ifdef TEST_MPF_50
   test<boost::multiprecision::mpf_float_50>();
   test<boost::multiprecision::mpf_float_100>();
#endif
#ifdef TEST_MPFR_50
   test<boost::multiprecision::mpfr_float_50>();
   test<boost::multiprecision::mpfr_float_100>();
#endif
#ifdef TEST_MPFI_50
   test<boost::multiprecision::mpfi_float_50>();
   test<boost::multiprecision::mpfi_float_100>();
#endif
#ifdef TEST_CPP_DEC_FLOAT
   test<boost::multiprecision::cpp_dec_float_50>();
   test<boost::multiprecision::cpp_dec_float_100>();
#ifndef SLOW_COMPLER
   // Some "peculiar" digit counts which stress our code:
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<65> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<64> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<63> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<62> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<61, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<60, long long> > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<59, long long, std::allocator<char> > > >();
   test<boost::multiprecision::number<boost::multiprecision::cpp_dec_float<58, long long, std::allocator<char> > > >();
#endif
#endif
#ifdef TEST_FLOAT128
   test<boost::multiprecision::float128>();
#endif
#ifdef TEST_CPP_BIN_FLOAT
   test<boost::multiprecision::cpp_bin_float_50>();
   test<boost::multiprecision::number<boost::multiprecision::cpp_bin_float<35, boost::multiprecision::digit_base_10, std::allocator<char>, long long> > >();
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_test.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2011 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include "test.hpp"
#include <boost/multiprecision/cpp_dec_float.hpp>

void proc_that_throws()
{
   throw std::runtime_error("");
}

int main()
{
   boost::multiprecision::cpp_dec_float_50 a1(1), a2(1), b(3), c(-2);

   BOOST_WARN(a1);
   BOOST_WARN(a1 == b);
   BOOST_CHECK(a1);
   BOOST_CHECK(a1 == b);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   boost::multiprecision::cpp_dec_float_50 a_tol = a1 + a1 * 100 * std::numeric_limits<boost::multiprecision::cpp_dec_float_50>::epsilon();
   boost::multiprecision::cpp_dec_float_50 tol   = 100 * std::numeric_limits<boost::multiprecision::cpp_dec_float_50>::epsilon();

   BOOST_CHECK_CLOSE(a1, a_tol, tol * 102); // Passes
   BOOST_WARN_CLOSE(a1, a_tol, tol * 98);   // fails
   BOOST_CHECK_CLOSE(a1, a_tol, tol * 98);  // fails
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_CLOSE_FRACTION(a1, a_tol, tol * 1.02); // Passes
   BOOST_WARN_CLOSE_FRACTION(a1, a_tol, tol * 0.98);  // fails
   BOOST_CHECK_CLOSE_FRACTION(a1, a_tol, tol * 0.98); // fails
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_EQUAL(a1, a2);
   BOOST_WARN_EQUAL(a1, b);
   BOOST_CHECK_EQUAL(a1, b);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_NE(a1, b);
   BOOST_WARN_NE(a1, a2);
   BOOST_CHECK_NE(a1, a2);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_GT(a1, c);
   BOOST_WARN_GT(a1, a2);
   BOOST_CHECK_GT(a1, a2);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_LT(a1, b);
   BOOST_WARN_LT(a1, a2);
   BOOST_CHECK_LT(a1, a2);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_GE(a1, a2);
   BOOST_CHECK_GE(a1, c);
   BOOST_WARN_GE(a1, b);
   BOOST_CHECK_GE(a1, b);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   BOOST_CHECK_LE(a1, a2);
   BOOST_CHECK_LE(a1, b);
   BOOST_WARN_LE(a1, c);
   BOOST_CHECK_LE(a1, c);
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

#ifndef BOOST_NO_EXCEPTIONS
   BOOST_CHECK_THROW(proc_that_throws(), std::runtime_error);
   BOOST_CHECK_THROW(a1 + b + c, std::runtime_error);
#endif
   BOOST_CHECK(boost::detail::test_errors() == 1);
   --boost::detail::test_errors();

   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_threaded_precision.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2021 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <thread>
#include <boost/detail/lightweight_test.hpp>
#include <boost/array.hpp>
#include <boost/math/special_functions/relative_difference.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <boost/math/quadrature/tanh_sinh.hpp>
#include "test.hpp"

#if !defined(TEST_MPF_50) && !defined(TEST_MPFR_50)
#define TEST_MPF_50
#define TEST_MPFR_50

#ifdef _MSC_VER
#pragma message("CAUTION!!: No backend type specified so testing everything.... this will take some time!!")
#endif
#ifdef __GNUC__
#pragma warning "CAUTION!!: No backend type specified so testing everything.... this will take some time!!"
#endif

#endif

#include <boost/multiprecision/mpfr.hpp>

#if defined(TEST_MPF_50)
#include <boost/multiprecision/gmp.hpp>
#endif

template <class T>
void thread_test_proc(unsigned digits)
{
   typedef boost::multiprecision::number<boost::multiprecision::mpfr_float_backend<1000> > mpfr_float_1000;

   if (!mpfr_buildopt_tls_p())
      return;

   T::thread_default_precision(digits);

   T result, value;

   value = boost::math::constants::pi<T>();
   result.assign(boost::math::constants::pi<mpfr_float_1000>().str());
   BOOST_CHECK_LE(boost::math::epsilon_difference(value, result), 20);
   BOOST_CHECK_EQUAL(value.precision(), digits);

   for (unsigned i = 20; i < 500; ++i)
   {
      T arg(i);
      arg /= 3;
      value = boost::math::tgamma(arg);
      BOOST_CHECK_EQUAL(value.precision(), digits);
      result.assign(boost::math::tgamma(mpfr_float_1000(arg)).str());
      BOOST_CHECK_LE(boost::math::epsilon_difference(value, result), 800);
   }

   //
   // Try tanh_sinh integration:
   //
   using namespace boost::math::constants;
   boost::math::quadrature::tanh_sinh<T> integrator;
   T                                     tol = 500;
   // Example 1:
   auto f1         = [](const T& t) { return static_cast<T>(t * boost::math::log1p(t)); };
   T Q          = integrator.integrate(f1, (T)0, (T)1);
   T Q_expected = half<T>() * half<T>();
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);

   // Example 2:
   auto f2    = [](const T& t) { return static_cast<T>(t * t * atan(t)); };
   Q          = integrator.integrate(f2, (T)0, (T)1);
   Q_expected = (pi<T>() - 2 + 2 * ln_two<T>()) / 12;
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);

   // Example 3:
   auto f3    = [](const T& t) { return static_cast<T>(exp(t) * cos(t)); };
   Q          = integrator.integrate(f3, (T)0, half_pi<T>());
   Q_expected = boost::math::expm1(half_pi<T>()) * half<T>();
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);

   // Example 4:
   auto f4    = [](T x) -> T { T t0 = sqrt(x*x + 2); return atan(t0)/(t0*(x*x+1)); };
   Q          = integrator.integrate(f4, (T)0, (T)1);
   Q_expected = 5 * pi<T>() * pi<T>() / 96;
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);

   // Example 5:
   auto f5    = [](const T& t)->T { return sqrt(t) * log(t); };
   Q          = integrator.integrate(f5, (T)0, (T)1);
   Q_expected = -4 / (T)9;
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);

   // Example 6:
   auto f6    = [](const T& t)->T { return sqrt(1 - t * t); };
   Q          = integrator.integrate(f6, (T)0, (T)1);
   Q_expected = pi<T>() / 4;
   BOOST_CHECK_EQUAL(Q.precision(), digits);
   BOOST_CHECK_EQUAL(Q_expected.precision(), digits);
   BOOST_CHECK_LE(boost::math::epsilon_difference(Q, Q_expected), tol);
}

int main()
{
#ifdef TEST_MPF_50
   {
      std::thread t1(thread_test_proc<boost::multiprecision::mpf_float>, 35);
      std::thread t2(thread_test_proc<boost::multiprecision::mpf_float>, 55);
      std::thread t3(thread_test_proc<boost::multiprecision::mpf_float>, 75);
      std::thread t4(thread_test_proc<boost::multiprecision::mpf_float>, 105);
      std::thread t5(thread_test_proc<boost::multiprecision::mpf_float>, 305);

      t1.join();
      t2.join();
      t3.join();
      t4.join();
      t5.join();
   }
#endif
#ifdef TEST_MPFR_50
   {
      std::thread t1(thread_test_proc<boost::multiprecision::mpfr_float>, 35);
      std::thread t2(thread_test_proc<boost::multiprecision::mpfr_float>, 55);
      std::thread t3(thread_test_proc<boost::multiprecision::mpfr_float>, 75);
      std::thread t4(thread_test_proc<boost::multiprecision::mpfr_float>, 105);
      std::thread t5(thread_test_proc<boost::multiprecision::mpfr_float>, 305);

      t1.join();
      t2.join();
      t3.join();
      t4.join();
      t5.join();
   }
#endif
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_trailing_io_delim.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2022 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).

#ifdef TEST_CPP_INT
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/multiprecision/cpp_complex.hpp>
#endif
#ifdef TEST_GMP
#include <boost/multiprecision/gmp.hpp>
#endif
#ifdef TEST_TOMMATH
#include <boost/multiprecision/tommath.hpp>
#endif
#ifdef TEST_FLOAT128
#include <boost/multiprecision/float128.hpp>
#include <boost/multiprecision/complex128.hpp>
#endif
#ifdef TEST_MPC
#include <boost/multiprecision/mpc.hpp>
#endif
#ifdef TEST_MPFI
#include <boost/multiprecision/mpfi.hpp>
#endif

#include <sstream>
#include "test.hpp"

template <class T>
void test_integer()
{
   std::istringstream iss("123#");
   T                  val;
   iss >> val;
   BOOST_CHECK_EQUAL(val, 123);
}

template <class T>
void test_rational()
{
   {
      std::istringstream iss("123#");
      T                  val;
      iss >> val;
      BOOST_CHECK_EQUAL(val, 123);
   }
   {
      std::istringstream iss("123/23#");
      T                  val;
      iss >> val;
      BOOST_CHECK_EQUAL(val, T(123, 23));
   }
}

template <class T>
void test_float()
{
   std::istringstream iss("123.0#");
   T                  val;
   iss >> val;
   BOOST_CHECK_EQUAL(val, 123.0);
}

template <class T>
void test_complex()
{
   {
      std::istringstream iss("123.0#");
      T                  val;
      iss >> val;
      BOOST_CHECK_EQUAL(val, 123.0);
   }
   {
      std::istringstream iss("(123.0,23.0)#");
      T                  val;
      iss >> val;
      BOOST_CHECK_EQUAL(val, T(123.0, 23.0));
   }
}

template <class T>
void test_interval()
{
   {
      std::istringstream iss("123.0#");
      T                  val;
      iss >> val;
      BOOST_CHECK_EQUAL(val, 123.0);
   }
   {
      std::istringstream iss("{123.0,124.0}#");
      T                  val;
      iss >> val;
      std::cout << val << std::endl;
      BOOST_CHECK_EQUAL(val, T(123.0, 124.0));
   }
}


int main()
{
#ifdef TEST_CPP_INT
   test_integer<boost::multiprecision::cpp_int>();
   test_rational<boost::multiprecision::cpp_rational>();
   test_float<boost::multiprecision::cpp_bin_float_50>();
   test_complex<boost::multiprecision::cpp_complex_50>();
#endif
#ifdef TEST_GMP
   test_integer<boost::multiprecision::mpz_int>();
   test_rational<boost::multiprecision::mpq_rational>();
   test_float<boost::multiprecision::mpf_float_50>();
#endif
#ifdef TEST_TOMMATH
   test_integer<boost::multiprecision::tom_int>();
   test_rational<boost::multiprecision::tom_rational>();
#endif
#ifdef TEST_FLOAT128
   test_float<boost::multiprecision::float128>();
   test_complex<boost::multiprecision::complex128>();
#endif
#ifdef TEST_MPC
   test_float<boost::multiprecision::mpfr_float_50>();
   test_complex<boost::multiprecision::mpc_complex_50>();
#endif
#ifdef TEST_MPFI
   test_interval<boost::multiprecision::mpfi_float_50>();
#endif
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/test_unchecked_cpp_int.cpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright 2017 John Maddock. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

//
// Check results of truncated overflow.
//

#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#endif

#include <boost/multiprecision/cpp_int.hpp>
#include "test.hpp"
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>

template <class T>
T generate_random(unsigned bits_wanted)
{
   static boost::random::mt19937               gen;
   typedef boost::random::mt19937::result_type random_type;

   T        max_val;
   unsigned digits;
   if (std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
   {
      max_val = (std::numeric_limits<T>::max)();
      digits  = std::numeric_limits<T>::digits;
   }
   else
   {
      max_val = T(1) << bits_wanted;
      digits  = bits_wanted;
   }

   unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
   while ((random_type(1) << bits_per_r_val) > (gen.max)())
      --bits_per_r_val;

   unsigned terms_needed = digits / bits_per_r_val + 1;

   T val = 0;
   for (unsigned i = 0; i < terms_needed; ++i)
   {
      val *= (gen.max)();
      val += gen();
   }
   val %= max_val;
   return val;
}

template <class Number>
void test()
{
   using namespace boost::multiprecision;
   typedef Number test_type;

   for (unsigned i = 30; i < std::numeric_limits<test_type>::digits; ++i)
   {
      for (unsigned j = std::numeric_limits<test_type>::digits - i - 1; j < std::numeric_limits<test_type>::digits; ++j)
      {
         for (unsigned k = 0; k < 10; ++k)
         {
            test_type a = static_cast<test_type>(generate_random<cpp_int>(i));
            test_type b = static_cast<test_type>(generate_random<cpp_int>(j));
            test_type c = static_cast<test_type>(cpp_int(a) * cpp_int(b));
            test_type d = a * b;
            BOOST_CHECK_EQUAL(c, d);

            if ((k == 0) && (j == 0))
            {
               for (unsigned s = 1; s < std::numeric_limits<test_type>::digits; ++s)
                  BOOST_CHECK_EQUAL(a << s, test_type(cpp_int(a) << s));
            }
         }
      }
   }
}

int main()
{
   using namespace boost::multiprecision;

   test<int512_t>();
   test<uint512_t>();

   //
   // We also need to test type with "odd" bit counts in order to ensure full code coverage:
   //
   test<number<cpp_int_backend<528, 528, signed_magnitude, unchecked, void> > >();
   test<number<cpp_int_backend<528, 528, unsigned_magnitude, unchecked, void> > >();
   test<number<cpp_int_backend<48, 48, signed_magnitude, unchecked, void> > >();
   test<number<cpp_int_backend<48, 48, unsigned_magnitude, unchecked, void> > >();
   return boost::report_errors();
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/timer.hpp
================================================
///////////////////////////////////////////////////////////////
//  Copyright Beman Dawes 1994-99.
//  Copyright 2020 John Maddock.
//  Copyright 2022 Christopher Kormanyos.
//  Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_MP_TIMER_HPP
#define BOOST_MP_TIMER_HPP

#include <chrono>

// This file now reflects the 2022 work-over. We have replaced the
// original timer facility (which had been based on std::clock())
// with C++11's equivalent <chrono> counterparts.

namespace boost { namespace multiprecision { namespace test_detail {

template <class ClockType = std::chrono::high_resolution_clock>
struct stopwatch;

template <class ResultType,
          class ClockType = std::chrono::high_resolution_clock>
class timer_template;

template <class ClockType>
struct stopwatch
{
private:
   using clock_type = ClockType;

public:
   using duration_type = typename clock_type::duration;

   stopwatch() : m_start(clock_type::now()) { }

   stopwatch(const stopwatch& other) : m_start(other.m_start) { }
   stopwatch(stopwatch&& other) noexcept : m_start(other.m_start) { }

   auto operator=(const stopwatch& other) -> stopwatch&
   {
      if(this != &other)
      {
         m_start = other.m_start;
      }

      return *this;
   }

   auto operator=(stopwatch&& other) noexcept -> stopwatch&
   {
      m_start = other.m_start;

      return *this;
   }

   ~stopwatch() { }

   auto elapsed() const -> duration_type
   {
      return (clock_type::now() - m_start);
   }

   auto elapsed_max() const -> duration_type
   {
      return (std::chrono::time_point<clock_type>::max)() - m_start;
   }

   static constexpr auto elapsed_min() -> duration_type
   {
      return (std::chrono::time_point<clock_type>::min)() -  std::chrono::time_point<clock_type>();
   }

   void reset()
   {
      m_start = clock_type::now();
   }

private:
   typename clock_type::time_point m_start;
};


template <class ResultType,
          class ClockType>
class timer_template : public stopwatch<ClockType>
{
private:
   using clock_type      = ClockType;
   using base_class_type = stopwatch<clock_type>;

public:
   using result_type = ResultType;

   timer_template() { }

   ~timer_template() { }

   void restart() { base_class_type::reset(); }

   auto elapsed() const -> result_type
   {
      // Return the elapsed time in seconds.
      return std::chrono::duration_cast<std::chrono::duration<result_type>>(base_class_type::elapsed()).count();
   }

   auto elapsed_max() const -> result_type
   {
      return std::chrono::duration_cast<std::chrono::duration<result_type>>(base_class_type::elapsed_max()).count();
   }

   static constexpr auto elapsed_min() -> result_type
   {
      return std::chrono::duration_cast<std::chrono::duration<result_type>>(base_class_type::elapsed_min()).count();
   }

   static constexpr result_type seconds(result_type s) { return static_cast<result_type>(s * static_cast<result_type>(1)); }

};

} // namespace test_detail
} // namespace multiprecision
} // namespace boost

// TODO: Might prefer to have the relatively common
// name "timer" to be shielded with a namespace.

using timer = boost::multiprecision::test_detail::timer_template<double, std::chrono::high_resolution_clock>;

#endif // BOOST_MP_TIMER_HPP


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/common/init.hpp
================================================
/*
 * Copyright (c) 2004 Michael Stevens
 * Use, modification and distribution are subject to the
 * Boost Software License, Version 1.0. (See accompanying file
 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

/*
 * Default construct test when possible
 */

template <class E>
struct default_construct
{
   static void test() {}
};
template <class VC>
struct default_construct<boost::numeric::ublas::vector_container<VC> >
{
   static void test()
   {
      VC default_constuct;
      initialize_vector(default_constuct);
      std::cout << "default construct = " << default_constuct << std::endl;
   }
};
template <class MC>
struct default_construct<boost::numeric::ublas::matrix_container<MC> >
{
   static void test()
   {
      MC default_constuct;
      initialize_vector(default_constuct);
      std::cout << "default construct = " << default_constuct << std::endl;
   }
};

/*
 * Initialise test values in vector/matrix
 */

template <class V>
void initialize_vector(V& v)
{
   typename V::size_type size = v.size();
   for (typename V::size_type i = 0; i < size; ++i)
      v[i] = typename V::value_type(i + 1.f);
}

template <class M>
void initialize_matrix_impl(M& m, ublas::packed_proxy_tag)
{
   typename M::size_type size1 = m.size1();
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
   for (typename M::iterator1 i = m.begin1(); i != m.end1(); ++i)
      for (typename M::iterator2 j = i.begin(); j != i.end(); ++j)
         *j = typename M::value_type(i.index1() * size1 + j.index2() + 1.f);
#else
   for (typename M::iterator1 i = m.begin1(); i != m.end1(); ++i)
      for (typename M::iterator2 j = ublas::begin(i, ublas::iterator1_tag()); j != ublas::end(i, ublas::iterator1_tag()); ++j)
         *j = typename M::value_type(i.index1() * size1 + j.index2() + 1.f);
#endif
}

template <class M>
void initialize_matrix_impl(M& m, ublas::sparse_proxy_tag)
{
   typename M::size_type size1 = m.size1();
   typename M::size_type size2 = m.size2();
   for (typename M::size_type i = 0; i < size1; ++i)
      for (typename M::size_type j = 0; j < size2; ++j)
         m(i, j) = typename M::value_type(i * size1 + j + 1.f);
}

template <class M>
void initialize_matrix(M& m)
{
   initialize_matrix_impl(m, typename M::storage_category());
}

template <class M>
void initialize_matrix(M& m, ublas::lower_tag)
{
   typename M::size_type size1 = m.size1();
   typename M::size_type size2 = m.size2();
   for (typename M::size_type i = 0; i < size1; ++i)
   {
      typename M::size_type j = 0;
      for (; j <= i; ++j)
         m(i, j) = i * size1 + j + 1.f;
      for (; j < size2; ++j)
         m(i, j) = 0.f;
   }
}
template <class M>
void initialize_matrix(M& m, ublas::upper_tag)
{
   typename M::size_type size1 = m.size1();
   typename M::size_type size2 = m.size2();
   for (typename M::size_type i = 0; i < size1; ++i)
   {
      typename M::size_type j = 0;
      for (; j < i; ++j)
         m(i, j) = 0.f;
      for (; j < size2; ++j)
         m(i, j) = i * size1 + j + 1.f;
   }
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/common/testhelper.hpp
================================================
// Copyright 2008 Gunter Winkler <guwi17@gmx.de>
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef _HPP_TESTHELPER_
#define _HPP_TESTHELPER_

#include <utility>

static unsigned _success_counter = 0;
static unsigned _fail_counter    = 0;

static inline void assertTrue(const char* message, bool condition)
{
#ifndef NOMESSAGES
   std::cout << message;
#endif
   if (condition)
   {
      ++_success_counter;
      std::cout << "1\n"; // success
   }
   else
   {
      ++_fail_counter;
      std::cout << "0\n"; // failed
   }
}

template <class T>
void assertEquals(const char* message, T expected, T actual)
{
#ifndef NOMESSAGES
   std::cout << message;
#endif
   if (expected == actual)
   {
      ++_success_counter;
      std::cout << "1\n"; // success
   }
   else
   {
#ifndef NOMESSAGES
      std::cout << " expected " << expected << " actual " << actual << " ";
#endif
      ++_fail_counter;
      std::cout << "0\n"; // failed
   }
}

static std::pair<unsigned, unsigned> getResults()
{
   return std::make_pair(_success_counter, _fail_counter);
}

template <class M1, class M2>
bool compare(const boost::numeric::ublas::matrix_expression<M1>& m1,
             const boost::numeric::ublas::matrix_expression<M2>& m2)
{
   size_t size1 = (std::min)(m1().size1(), m2().size1());
   size_t size2 = (std::min)(m1().size2(), m2().size2());
   for (size_t i = 0; i < size1; ++i)
   {
      for (size_t j = 0; j < size2; ++j)
      {
         if (m1()(i, j) != m2()(i, j))
            return false;
      }
   }
   return true;
}

template <class M1, class M2>
bool compare(const boost::numeric::ublas::vector_expression<M1>& m1,
             const boost::numeric::ublas::vector_expression<M2>& m2)
{
   size_t size = (std::min)(m1().size(), m2().size());
   for (size_t i = 0; i < size; ++i)
   {
      if (m1()(i) != m2()(i))
         return false;
   }
   return true;
}

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test1.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test1.hpp"

int main()
{
   test_vector();
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test1.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST1_H
#define TEST1_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

void test_vector();
void test_matrix_vector();
void test_matrix();

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test11.cpp
================================================
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test1.hpp"

// Test vector expression templates
template <class V, int N>
struct test_my_vector
{
   typedef typename V::value_type                             value_type;
   typedef typename V::size_type                              size_type;
   typedef typename ublas::type_traits<value_type>::real_type real_type;

   template <class VP>
   void test_container_with(VP& v1) const
   {
      // Container type tests in addition to expression types
      // Insert and erase
      v1.insert_element(0, 55);
      v1.erase_element(1);
      v1.clear();
   }

   template <class VP>
   void test_expression_with(VP& v1, VP& v2, VP& v3) const
   {
      // Expression type tests
      value_type t;
      size_type  i;
      real_type  n;

      // Default Construct
      default_construct<VP>::test();

      // Copy and swap
      initialize_vector(v1);
      initialize_vector(v2);
      v1 = v2;
      std::cout << "v1 = v2 = " << v1 << std::endl;
      v1.assign_temporary(v2);
      std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
      v1.swap(v2);
      std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;

      // Zero assignment
      v1 = ublas::zero_vector<>(v1.size());
      std::cout << "v1.zero_vector = " << v1 << std::endl;
      v1 = v2;

#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      // Project range and slice
      initialize_vector(v1);
      initialize_vector(v2);
      project(v1, ublas::range(0, 1))     = project(v2, ublas::range(0, 1));
      project(v1, ublas::range(0, 1))     = project(v2, ublas::slice(0, 1, 1));
      project(v1, ublas::slice(2, -1, 2)) = project(v2, ublas::slice(0, 1, 2));
      project(v1, ublas::slice(2, -1, 2)) = project(v2, ublas::range(0, 2));
      std::cout << "v1 = range/slice " << v1 << std::endl;
#endif

      // Unary vector operations resulting in a vector
      initialize_vector(v1);
      v2 = -v1;
      std::cout << "- v1 = " << v2 << std::endl;
      v2 = ublas::conj(v1);
      std::cout << "conj (v1) = " << v2 << std::endl;

      // Binary vector operations resulting in a vector
      initialize_vector(v1);
      initialize_vector(v2);
      v3 = v1 + v2;
      std::cout << "v1 + v2 = " << v3 << std::endl;
      v3 = v1 - v2;
      std::cout << "v1 - v2 = " << v3 << std::endl;
      v3 = ublas::element_prod(v1, v2);
      std::cout << "element_prod (v1, v2) = " << v3 << std::endl;

      // Scaling a vector
      t = N;
      initialize_vector(v1);
      v2 = value_type(1.) * v1;
      std::cout << "1. * v1 = " << v2 << std::endl;
      v2 = t * v1;
      std::cout << "N * v1 = " << v2 << std::endl;
      initialize_vector(v1);
      v2 = v1 * value_type(1.);
      std::cout << "v1 * 1. = " << v2 << std::endl;
      v2 = v1 * t;
      std::cout << "v1 * value_type(N) = " << v2 << std::endl;
      // test interop with integer
      v2 = v1 * N;

      std::cout << "v1 * N = " << v2 << std::endl;

      // Some assignments
      initialize_vector(v1);
      initialize_vector(v2);
      v2 += v1;
      std::cout << "v2 += v1 = " << v2 << std::endl;
      v2 -= v1;
      std::cout << "v2 -= v1 = " << v2 << std::endl;
      v2 = v2 + v1;
      std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
      v2 = v2 - v1;
      std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
      v1 *= value_type(1.);
      std::cout << "v1 *= 1. = " << v1 << std::endl;
      v1 *= t;
      std::cout << "v1 *= value_type(N) = " << v1 << std::endl;
      // test interop with integer
      v1 *= N;
      std::cout << "v1 *= N = " << v1 << std::endl;

      // Unary vector operations resulting in a scalar
      initialize_vector(v1);
      t = ublas::sum(v1);
      std::cout << "sum (v1) = " << t << std::endl;
      n = ublas::norm_1(v1);
      std::cout << "norm_1 (v1) = " << n << std::endl;
      n = ublas::norm_2(v1);
      std::cout << "norm_2 (v1) = " << n << std::endl;
      n = ublas::norm_inf(v1);
      std::cout << "norm_inf (v1) = " << n << std::endl;

      i = ublas::index_norm_inf(v1);
      std::cout << "index_norm_inf (v1) = " << i << std::endl;

      // Binary vector operations resulting in a scalar
      initialize_vector(v1);
      initialize_vector(v2);
      t = ublas::inner_prod(v1, v2);
      std::cout << "inner_prod (v1, v2) = " << t << std::endl;

      // Scalar and Binary vector expression resulting in a vector
      initialize_vector(v1);
      initialize_vector(v2);
      v1 = v1 * ublas::inner_prod(v1, v2);
      std::cout << "v1 * inner_prod (v1, v2) = " << v1 << std::endl;
   }

   void operator()() const
   {
      V v1(N), v2(N), v3(N);
      test_expression_with(v1, v2, v3);
      test_container_with(v1);

#ifdef USE_RANGE
      ublas::vector_range<V> vr1(v1, ublas::range(0, N)),
          vr2(v2, ublas::range(0, N)),
          vr3(v3, ublas::range(0, N));
      test_expression_with(vr1, vr2, vr3);
#endif

#ifdef USE_SLICE
      ublas::vector_slice<V> vs1(v1, ublas::slice(0, 1, N)),
          vs2(v2, ublas::slice(0, 1, N)),
          vs3(v3, ublas::slice(0, 1, N));
      test_expression_with(vs1, vs2, vs3);
#endif
   }
};

// Test vector
void test_vector()
{
   std::cout << "test_vector" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_vector<ublas::vector<double, ublas::bounded_array<double, 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<double, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_vector<ublas::vector<double, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_BOUNDED_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded" << std::endl;
   test_my_vector<ublas::bounded_vector<mp_test_type, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded" << std::endl;
   test_my_vector<ublas::bounded_vector<double, 3>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded" << std::endl;
   test_my_vector<ublas::bounded_vector<std::complex<mp_test_type>, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded" << std::endl;
   test_my_vector<ublas::bounded_vector<std::complex<double>, 3>, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test12.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test1.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v1 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v1 << std::endl;
            v1 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v1 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         m1 = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N);
         M m1(N, N);
         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, 0), mr2(m1, 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 0), mc2(m1, 1);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_MATRIX
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::matrix<double, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_BOUNDED_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded" << std::endl;
   test_my_matrix_vector<ublas::bounded_vector<mp_test_type, 3>,
                         ublas::bounded_matrix<mp_test_type, 3, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded" << std::endl;
   test_my_matrix_vector<ublas::bounded_vector<double, 3>,
                         ublas::bounded_matrix<double, 3, 3>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded" << std::endl;
   test_my_matrix_vector<ublas::bounded_vector<std::complex<mp_test_type>, 3>,
                         ublas::bounded_matrix<std::complex<mp_test_type>, 3, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded" << std::endl;
   test_my_matrix_vector<ublas::bounded_vector<std::complex<double>, 3>,
                         ublas::bounded_matrix<std::complex<double>, 3, 3>, 3>()();
#endif
#endif
#endif

#ifdef USE_VECTOR_OF_VECTOR
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::bounded_array<ublas::bounded_array<mp_test_type, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::vector_of_vector<double, ublas::row_major, ublas::bounded_array<ublas::bounded_array<double, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<std::complex<mp_test_type>, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::vector_of_vector<std::complex<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<std::complex<double>, 3>, 3 + 1> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::vector_of_vector<double, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::vector_of_vector<std::complex<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<std::complex<double> > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::vector_of_vector<mp_test_type, ublas::row_major, std::vector<std::vector<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::vector_of_vector<double, ublas::row_major, std::vector<std::vector<double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, std::vector<std::vector<std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::vector_of_vector<std::complex<double>, ublas::row_major, std::vector<std::vector<std::complex<double> > > >, 3>()();
#endif
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test13.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test1.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class VP>
   void test_container_with(VP& v1) const
   {
      // Container type tests in addition to expression types
      // Insert and erase
      v1.insert_element(0, 0, 55);
      v1.erase_element(1, 1);
      v1.clear();
   }

   template <class MP>
   void test_expression_with(MP& m1, MP& m2, MP& m3) const
   {
      value_type t;

      // Default Construct
      default_construct<MP>::test();

      // Copy and swap
      initialize_matrix(m1);
      initialize_matrix(m2);
      m1 = m2;
      std::cout << "m1 = m2 = " << m1 << std::endl;
      m1.assign_temporary(m2);
      std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
      m1.swap(m2);
      std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

      // Zero assignment
      m1 = ublas::zero_matrix<>(m1.size1(), m1.size2());
      std::cout << "m1.zero_matrix = " << m1 << std::endl;
      m1 = m2;

#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      // Project range and slice
      initialize_matrix(m1);
      initialize_matrix(m2);
      project(m1, ublas::range(0, 1), ublas::range(0, 1))         = project(m2, ublas::range(0, 1), ublas::range(0, 1));
      project(m1, ublas::range(0, 1), ublas::range(0, 1))         = project(m2, ublas::slice(0, 1, 1), ublas::slice(0, 1, 1));
      project(m1, ublas::slice(2, -1, 2), ublas::slice(2, -1, 2)) = project(m2, ublas::slice(0, 1, 2), ublas::slice(0, 1, 2));
      project(m1, ublas::slice(2, -1, 2), ublas::slice(2, -1, 2)) = project(m2, ublas::range(0, 2), ublas::range(0, 2));
      std::cout << "m1 = range/slice " << m1 << std::endl;
#endif

      // Unary matrix operations resulting in a matrix
      initialize_matrix(m1);
      m2 = -m1;
      std::cout << "- m1 = " << m2 << std::endl;
      m2 = ublas::conj(m1);
      std::cout << "conj (m1) = " << m2 << std::endl;

      // Binary matrix operations resulting in a matrix
      initialize_matrix(m1);
      initialize_matrix(m2);
      m3 = m1 + m2;
      std::cout << "m1 + m2 = " << m3 << std::endl;
      m3 = m1 - m2;
      std::cout << "m1 - m2 = " << m3 << std::endl;
      m3 = ublas::element_prod(m1, m2);
      std::cout << "element_prod (m1, m2) = " << m3 << std::endl;

      // Scaling a matrix
      t = N;
      initialize_matrix(m1);
      m2 = value_type(1.) * m1;
      std::cout << "1. * m1 = " << m2 << std::endl;
      m2 = t * m1;
      std::cout << "N * m1 = " << m2 << std::endl;
      initialize_matrix(m1);
      m2 = m1 * value_type(1.);
      std::cout << "m1 * 1. = " << m2 << std::endl;
      m2 = m1 * t;
      std::cout << "m1 * N = " << m2 << std::endl;

      // Some assignments
      initialize_matrix(m1);
      initialize_matrix(m2);
      m2 += m1;
      std::cout << "m2 += m1 = " << m2 << std::endl;
      m2 -= m1;
      std::cout << "m2 -= m1 = " << m2 << std::endl;
      m2 = m2 + m1;
      std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
      m2 = m2 - m1;
      std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
      m1 *= value_type(1.);
      std::cout << "m1 *= 1. = " << m1 << std::endl;
      m1 *= t;
      std::cout << "m1 *= N = " << m1 << std::endl;

      // Transpose
      initialize_matrix(m1);
      m2 = ublas::trans(m1);
      std::cout << "trans (m1) = " << m2 << std::endl;

      // Hermitean
      initialize_matrix(m1);
      m2 = ublas::herm(m1);
      std::cout << "herm (m1) = " << m2 << std::endl;

      // Matrix multiplication
      initialize_matrix(m1);
      initialize_matrix(m2);
      m3 = ublas::prod(m1, m2);
      std::cout << "prod (m1, m2) = " << m3 << std::endl;
   }

   void operator()() const
   {
      M m1(N, N), m2(N, N), m3(N, N);
      test_expression_with(m1, m2, m3);
      test_container_with(m1);

#ifdef USE_RANGE
      ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
          mr2(m2, ublas::range(0, N), ublas::range(0, N)),
          mr3(m3, ublas::range(0, N), ublas::range(0, N));
      test_expression_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
      ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
          ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
          ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
      test_expression_with(ms1, ms2, ms3);
#endif
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_MATRIX
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<double, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_BOUNDED_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded" << std::endl;
   test_my_matrix<ublas::bounded_matrix<mp_test_type, 3, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded" << std::endl;
   test_my_matrix<ublas::bounded_matrix<double, 3, 3>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded" << std::endl;
   test_my_matrix<ublas::bounded_matrix<std::complex<mp_test_type>, 3, 3>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded" << std::endl;
   test_my_matrix<ublas::bounded_matrix<std::complex<double>, 3, 3>, 3>()();
#endif
#endif
#endif

#ifdef USE_VECTOR_OF_VECTOR
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::bounded_array<ublas::bounded_array<mp_test_type, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<double, ublas::row_major, ublas::bounded_array<ublas::bounded_array<double, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<std::complex<mp_test_type>, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<std::complex<double>, 3>, 3 + 1> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<double, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<std::complex<double> > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, std::vector<std::vector<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<double, ublas::row_major, std::vector<std::vector<double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<mp_test_type>, ublas::row_major, std::vector<std::vector<std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<std::complex<double>, ublas::row_major, std::vector<std::vector<std::complex<double> > > >, 3>()();
#endif
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test2.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test2.hpp"

int main()
{
#ifdef USE_FLOAT
   std::cout << "mp_test_type" << std::endl;
   test_blas_1<ublas::vector<mp_test_type>, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "double" << std::endl;
   test_blas_1<ublas::vector<double>, 3>().test();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>" << std::endl;
   test_blas_1<ublas::vector<std::complex<mp_test_type> >, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>" << std::endl;
   test_blas_1<ublas::vector<std::complex<double> >, 3>().test();
#endif
#endif

   std::cout << "test_blas_2" << std::endl;

#ifdef USE_FLOAT
   std::cout << "mp_test_type" << std::endl;
   test_blas_2<ublas::vector<mp_test_type>, ublas::matrix<mp_test_type>, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "double" << std::endl;
   test_blas_2<ublas::vector<double>, ublas::matrix<double>, 3>().test();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>" << std::endl;
   test_blas_2<ublas::vector<std::complex<mp_test_type> >, ublas::matrix<std::complex<mp_test_type> >, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>" << std::endl;
   test_blas_2<ublas::vector<std::complex<double> >, ublas::matrix<std::complex<double> >, 3>().test();
#endif
#endif

   std::cout << "test_blas_3" << std::endl;

#ifdef USE_FLOAT
   std::cout << "mp_test_type" << std::endl;
   test_blas_3<ublas::matrix<mp_test_type>, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "double" << std::endl;
   test_blas_3<ublas::matrix<double>, 3>().test();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>" << std::endl;
   test_blas_3<ublas::matrix<std::complex<mp_test_type> >, 3>().test();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>" << std::endl;
   test_blas_3<ublas::matrix<std::complex<double> >, 3>().test();
#endif
#endif

   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test2.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST2_H
#define TEST2_H
#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100 4018)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/triangular.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/numeric/ublas/blas.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

template <class V, int N>
struct test_blas_1
{
   typedef typename V::value_type                             value_type;
   typedef typename ublas::type_traits<value_type>::real_type real_type;

   void test();
};

template <class V, class M, int N>
struct test_blas_2
{
   typedef typename V::value_type value_type;

   void test();
};

template <class M, int N>
struct test_blas_3
{
   typedef typename M::value_type value_type;

   void test();
};

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test21.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test2.hpp"

template <class V, int N>
void test_blas_1<V, N>::test()
{
   {
      value_type t;
      real_type  n;
      V          v1(N), v2(N);

      // _asum
      initialize_vector(v1);
      n = ublas::blas_1::asum(v1);
      std::cout << "asum (v1) = " << n << std::endl;

      // _amax
      initialize_vector(v1);
      n = ublas::blas_1::amax(v1);
      std::cout << "amax (v1) = " << n << std::endl;

      // _nrm2
      initialize_vector(v1);
      n = ublas::blas_1::nrm2(v1);
      std::cout << "nrm2 (v1) = " << n << std::endl;

      // _dot
      // _dotu
      // _dotc
      initialize_vector(v1);
      initialize_vector(v2);
      t = ublas::blas_1::dot(v1, v2);
      std::cout << "dot (v1, v2) = " << t << std::endl;
      t = ublas::blas_1::dot(ublas::conj(v1), v2);
      std::cout << "dot (conj (v1), v2) = " << t << std::endl;

      // _copy
      initialize_vector(v2);
      ublas::blas_1::copy(v1, v2);
      std::cout << "copy (v1, v2) = " << v1 << std::endl;

      // _swap
      initialize_vector(v1);
      initialize_vector(v2);
      ublas::blas_1::swap(v1, v2);
      std::cout << "swap (v1, v2) = " << v1 << " " << v2 << std::endl;

      // _scal
      // csscal
      // zdscal
      initialize_vector(v1);
      ublas::blas_1::scal(v1, value_type(1));
      std::cout << "scal (v1, 1) = " << v1 << std::endl;

      // _axpy
      initialize_vector(v1);
      initialize_vector(v2);
      ublas::blas_1::axpy(v1, value_type(1), v2);
      std::cout << "axpy (v1, 1, v2) = " << v1 << std::endl;

      // _rot
      initialize_vector(v1);
      initialize_vector(v2);
      ublas::blas_1::rot(value_type(1), v1, value_type(1), v2);
      std::cout << "rot (1, v1, 1, v2) = " << v1 << " " << v2 << std::endl;
   }
}

#ifdef USE_FLOAT
template struct test_blas_1<ublas::vector<mp_test_type>, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_1<ublas::vector<double>, 3>;
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
template struct test_blas_1<ublas::vector<std::complex<mp_test_type> >, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_1<ublas::vector<std::complex<double> >, 3>;
#endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test22.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test2.hpp"

template <class V, class M, int N>
void test_blas_2<V, M, N>::test()
{
   {
      V v1(N), v2(N);
      M m(N, N);

      // _t_mv
      initialize_vector(v1);
      initialize_matrix(m);
      ublas::blas_2::tmv(v1, m);
      std::cout << "tmv (v1, m) = " << v1 << std::endl;
      initialize_vector(v1);
      initialize_matrix(m);
      ublas::blas_2::tmv(v1, ublas::trans(m));
      std::cout << "tmv (v1, trans (m)) = " << v1 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_vector(v1);
      initialize_matrix(m);
      ublas::blas_2::tmv(v1, ublas::herm(m));
      std::cout << "tmv (v1, herm (m)) = " << v1 << std::endl;
#endif

      // _t_sv
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::lower_tag());
      ublas::blas_2::tsv(v1, m, ublas::lower_tag());
      std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod(m, v1) - v2 << std::endl;
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::upper_tag());
      ublas::blas_2::tsv(v1, ublas::trans(m), ublas::lower_tag());
      std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod(ublas::trans(m), v1) - v2 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::upper_tag());
      ublas::blas_2::tsv(v1, ublas::herm(m), ublas::lower_tag());
      std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod(ublas::herm(m), v1) - v2 << std::endl;
#endif
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::upper_tag());
      ublas::blas_2::tsv(v1, m, ublas::upper_tag());
      std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod(m, v1) - v2 << std::endl;
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::lower_tag());
      ublas::blas_2::tsv(v1, ublas::trans(m), ublas::upper_tag());
      std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod(ublas::trans(m), v1) - v2 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m, ublas::lower_tag());
      ublas::blas_2::tsv(v1, ublas::herm(m), ublas::upper_tag());
      std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod(ublas::herm(m), v1) - v2 << std::endl;
#endif

      // _g_mv
      // _s_mv
      // _h_mv
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m);
      ublas::blas_2::gmv(v1, value_type(1), value_type(1), m, v2);
      std::cout << "gmv (v1, 1, 1, m, v2) = " << v1 << std::endl;
      ublas::blas_2::gmv(v1, value_type(1), value_type(1), ublas::trans(m), v2);
      std::cout << "gmv (v1, 1, 1, trans (m), v2) = " << v1 << std::endl;
#ifdef USE_STD_COMPLEX
      ublas::blas_2::gmv(v1, value_type(1), value_type(1), ublas::herm(m), v2);
      std::cout << "gmv (v1, 1, 1, herm (m), v2) = " << v1 << std::endl;
#endif

      // _g_r
      // _g_ru
      // _g_rc
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m);
      ublas::blas_2::gr(m, value_type(1), v1, v2);
      std::cout << "gr (m, 1, v1, v2) = " << m << std::endl;
      ublas::blas_2::gr(m, value_type(1), v1, ublas::conj(v2));
      std::cout << "gr (m, 1, v1, conj (v2)) = " << m << std::endl;

      // _s_r
      initialize_vector(v1);
      initialize_matrix(m);
      ublas::blas_2::sr(m, value_type(1), v1);
      std::cout << "sr (m, 1, v1) = " << m << std::endl;

#ifdef USE_STD_COMPLEX
      // _h_r
      initialize_vector(v1);
      initialize_matrix(m);
      ublas::blas_2::hr(m, value_type(1), v1);
      std::cout << "hr (m, 1, v1) = " << m << std::endl;
#endif

      // _s_r2
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m);
      ublas::blas_2::sr2(m, value_type(1), v1, v2);
      std::cout << "sr2 (m, 1, v1, v2) = " << m << std::endl;

#ifdef USE_STD_COMPLEX
      // _h_r2
      initialize_vector(v1);
      initialize_vector(v2);
      initialize_matrix(m);
      ublas::blas_2::hr2(m, value_type(1), v1, v2);
      std::cout << "hr2 (m, 1, v1, v2) = " << m << std::endl;
#endif
   }
}

#ifdef USE_FLOAT
template struct test_blas_2<ublas::vector<mp_test_type>, ublas::matrix<mp_test_type>, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_2<ublas::vector<double>, ublas::matrix<double>, 3>;
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
template struct test_blas_2<ublas::vector<std::complex<mp_test_type> >, ublas::matrix<std::complex<mp_test_type> >, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_2<ublas::vector<std::complex<double> >, ublas::matrix<std::complex<double> >, 3>;
#endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test23.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test2.hpp"

template <class M, int N>
void test_blas_3<M, N>::test()
{
   {
      M m1(N, N), m2(N, N), m3(N, N);

      // _t_mm
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), m2, m1);
      std::cout << "tmm (m1, 1, m2, m1) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), m2, ublas::trans(m1));
      std::cout << "tmm (m1, 1, m2, trans (m1)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::trans(m2), m1);
      std::cout << "tmm (m1, 1, trans (m2), m1) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::trans(m2), ublas::trans(m1));
      std::cout << "tmm (m1, 1, trans (m2), trans (m1)) = " << m1 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), m2, ublas::herm(m1));
      std::cout << "tmm (m1, 1, m2, herm (m1)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::herm(m2), m1);
      std::cout << "tmm (m1, 1, herm (m2), m1) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::trans(m2), ublas::herm(m1));
      std::cout << "tmm (m1, 1, trans (m2), herm (m1)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::herm(m2), ublas::trans(m1));
      std::cout << "tmm (m1, 1, herm (m2), trans (m1)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::tmm(m1, value_type(1), ublas::herm(m2), ublas::herm(m1));
      std::cout << "tmm (m1, 1, herm (m2), herm (m1)) = " << m1 << std::endl;
#endif

      // _t_sm
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::lower_tag());
      initialize_matrix(m3);
      ublas::blas_3::tsm(m1, value_type(1), m2, ublas::lower_tag());
      std::cout << "tsm (m1, 1, m2) = " << m1 << " " << ublas::prod(m2, m1) - value_type(1) * m3 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::upper_tag());
      ublas::blas_3::tsm(m1, value_type(1), ublas::trans(m2), ublas::lower_tag());
      std::cout << "tsm (m1, 1, trans (m2)) = " << m1 << " " << ublas::prod(ublas::trans(m2), m1) - value_type(1) * m3 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::upper_tag());
      ublas::blas_3::tsm(m1, value_type(1), ublas::herm(m2), ublas::lower_tag());
      std::cout << "tsm (m1, 1, herm (m2)) = " << m1 << " " << ublas::prod(ublas::herm(m2), m1) - value_type(1) * m3 << std::endl;
#endif
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::upper_tag());
      ublas::blas_3::tsm(m1, value_type(1), m2, ublas::upper_tag());
      std::cout << "tsm (m1, 1, m2) = " << m1 << " " << ublas::prod(m2, m1) - value_type(1) * m3 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::lower_tag());
      ublas::blas_3::tsm(m1, value_type(1), ublas::trans(m2), ublas::upper_tag());
      std::cout << "tsm (m1, 1, trans (m2)) = " << m1 << " " << ublas::prod(ublas::trans(m2), m1) - value_type(1) * m3 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_matrix(m1);
      initialize_matrix(m2, ublas::lower_tag());
      ublas::blas_3::tsm(m1, value_type(1), ublas::herm(m2), ublas::upper_tag());
      std::cout << "tsm (m1, 1, herm (m2)) = " << m1 << " " << ublas::prod(ublas::herm(m2), m1) - value_type(1) * m3 << std::endl;
#endif

      // _g_mm
      // _s_mm
      // _h_mm
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), m2, m3);
      std::cout << "gmm (m1, 1, 1, m2, m3) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::trans(m2), m3);
      std::cout << "gmm (m1, 1, 1, trans (m2), m3) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), m2, ublas::trans(m3));
      std::cout << "gmm (m1, 1, 1, m2, trans (m3)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::trans(m2), ublas::trans(m3));
      std::cout << "gmm (m1, 1, 1, trans (m2), trans (m3)) = " << m1 << std::endl;
#ifdef USE_STD_COMPLEX
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::herm(m2), m3);
      std::cout << "gmm (m1, 1, 1, herm (m2), m3) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), m2, ublas::herm(m3));
      std::cout << "gmm (m1, 1, 1, m2, herm (m3)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::herm(m2), ublas::trans(m3));
      std::cout << "gmm (m1, 1, 1, herm (m2), trans (m3)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::trans(m2), ublas::herm(m3));
      std::cout << "gmm (m1, 1, 1, trans (m2), herm (m3)) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::gmm(m1, value_type(1), value_type(1), ublas::herm(m2), ublas::herm(m3));
      std::cout << "gmm (m1, 1, 1, herm (m2), herm (m3)) = " << m1 << std::endl;
#endif

      // s_rk
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::srk(m1, value_type(1), value_type(1), m2);
      std::cout << "srk (m1, 1, 1, m2) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::srk(m1, value_type(1), value_type(1), ublas::trans(m2));
      std::cout << "srk (m1, 1, 1, trans (m2)) = " << m1 << std::endl;

#ifdef USE_STD_COMPLEX
      // h_rk
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::hrk(m1, value_type(1), value_type(1), m2);
      std::cout << "hrk (m1, 1, 1, m2) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      ublas::blas_3::hrk(m1, value_type(1), value_type(1), ublas::herm(m2));
      std::cout << "hrk (m1, 1, 1, herm (m2)) = " << m1 << std::endl;
#endif

      // s_r2k
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::sr2k(m1, value_type(1), value_type(1), m2, m3);
      std::cout << "sr2k (m1, 1, 1, m2, m3) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::sr2k(m1, value_type(1), value_type(1), ublas::trans(m2), ublas::trans(m3));
      std::cout << "sr2k (m1, 1, 1, trans (m2), trans (m3)) = " << m1 << std::endl;

#ifdef USE_STD_COMPLEX
      // h_r2k
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::hr2k(m1, value_type(1), value_type(1), m2, m3);
      std::cout << "hr2k (m1, 1, 1, m2, m3) = " << m1 << std::endl;
      initialize_matrix(m1);
      initialize_matrix(m2);
      initialize_matrix(m3);
      ublas::blas_3::hr2k(m1, value_type(1), value_type(1), ublas::herm(m2), ublas::herm(m3));
      std::cout << "hr2k (m1, 1, 1, herm (m2), herm (m3)) = " << m1 << std::endl;
#endif
   }
}

#ifdef USE_FLOAT
template struct test_blas_3<ublas::matrix<mp_test_type>, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_3<ublas::matrix<double>, 3>;
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
template struct test_blas_3<ublas::matrix<std::complex<mp_test_type> >, 3>;
#endif

#ifdef USE_DOUBLE
template struct test_blas_3<ublas::matrix<std::complex<double> >, 3>;
#endif
#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test3.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test3.hpp"

int main()
{
   test_vector();
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test3.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST3_H
#define TEST3_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
#include <boost/numeric/ublas/vector_of_vector.hpp>
#endif
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

void test_vector();
void test_matrix_vector();
void test_matrix();

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test31.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test3.hpp"

// Test vector expression templates
template <class V, int N>
struct test_my_vector
{
   typedef typename V::value_type                             value_type;
   typedef typename V::size_type                              size_type;
   typedef typename ublas::type_traits<value_type>::real_type real_type;

   template <class VP>
   void test_with(VP& v1, VP& v2, VP& v3) const
   {
      {
         value_type t;
         size_type  i;
         real_type  n;

         // Default Construct
         default_construct<VP>::test();

         // Copy and swap
         initialize_vector(v1);
         initialize_vector(v2);
         v1 = v2;
         std::cout << "v1 = v2 = " << v1 << std::endl;
         v1.assign_temporary(v2);
         std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
         v1.swap(v2);
         std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;

         // Zero assignment
         v1 = ublas::zero_vector<>(v1.size());
         std::cout << "v1.zero_vector = " << v1 << std::endl;
         v1 = v2;

#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
         // Project range and slice
         initialize_vector(v1);
         initialize_vector(v2);
         project(v1, ublas::range(0, 1))     = project(v2, ublas::range(0, 1));
         project(v1, ublas::range(0, 1))     = project(v2, ublas::slice(0, 1, 1));
         project(v1, ublas::slice(2, -1, 2)) = project(v2, ublas::slice(0, 1, 2));
         project(v1, ublas::slice(2, -1, 2)) = project(v2, ublas::range(0, 2));
         std::cout << "v1 = range/slice " << v1 << std::endl;
#endif

         // Unary vector operations resulting in a vector
         initialize_vector(v1);
         v2 = -v1;
         std::cout << "- v1 = " << v2 << std::endl;
         v2 = ublas::conj(v1);
         std::cout << "conj (v1) = " << v2 << std::endl;

         // Binary vector operations resulting in a vector
         initialize_vector(v1);
         initialize_vector(v2);
         initialize_vector(v3);
         v3 = v1 + v2;
         std::cout << "v1 + v2 = " << v3 << std::endl;

         v3 = v1 - v2;
         std::cout << "v1 - v2 = " << v3 << std::endl;

         // Scaling a vector
         t = N;
         initialize_vector(v1);
         v2 = value_type(1.) * v1;
         std::cout << "1. * v1 = " << v2 << std::endl;
         v2 = t * v1;
         std::cout << "N * v1 = " << v2 << std::endl;
         initialize_vector(v1);
         v2 = v1 * value_type(1.);
         std::cout << "v1 * 1. = " << v2 << std::endl;
         v2 = v1 * t;
         std::cout << "v1 * N = " << v2 << std::endl;

         // Some assignments
         initialize_vector(v1);
         initialize_vector(v2);
         v2 += v1;
         std::cout << "v2 += v1 = " << v2 << std::endl;
         v2 -= v1;
         std::cout << "v2 -= v1 = " << v2 << std::endl;
         v2 = v2 + v1;
         std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
         v2 = v2 - v1;
         std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
         v1 *= value_type(1.);
         std::cout << "v1 *= 1. = " << v1 << std::endl;
         v1 *= t;
         std::cout << "v1 *= N = " << v1 << std::endl;

         // Unary vector operations resulting in a scalar
         initialize_vector(v1);
         t = ublas::sum(v1);
         std::cout << "sum (v1) = " << t << std::endl;
         n = ublas::norm_1(v1);
         std::cout << "norm_1 (v1) = " << n << std::endl;
         n = ublas::norm_2(v1);
         std::cout << "norm_2 (v1) = " << n << std::endl;
         n = ublas::norm_inf(v1);
         std::cout << "norm_inf (v1) = " << n << std::endl;

         i = ublas::index_norm_inf(v1);
         std::cout << "index_norm_inf (v1) = " << i << std::endl;

         // Binary vector operations resulting in a scalar
         initialize_vector(v1);
         initialize_vector(v2);
         t = ublas::inner_prod(v1, v2);
         std::cout << "inner_prod (v1, v2) = " << t << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N, N), v2(N, N), v3(N, N);
         test_with(v1, v2, v3);

#ifdef USE_RANGE
         ublas::vector_range<V> vr1(v1, ublas::range(0, N)),
             vr2(v2, ublas::range(0, N)),
             vr3(v3, ublas::range(0, N));
         test_with(vr1, vr2, vr3);
#endif

#ifdef USE_SLICE
         ublas::vector_slice<V> vs1(v1, ublas::slice(0, 1, N)),
             vs2(v2, ublas::slice(0, 1, N)),
             vs3(v3, ublas::slice(0, 1, N));
         test_with(vs1, vs2, vs3);
#endif
      }
   }
};

// Test vector
void test_vector()
{
   std::cout << "test_vector" << std::endl;

#ifdef USE_SPARSE_VECTOR
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, map_array" << std::endl;
   test_my_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, map_array" << std::endl;
   test_my_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, map_array" << std::endl;
   test_my_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, map_array" << std::endl;
   test_my_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::map" << std::endl;
   test_my_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::map" << std::endl;
   test_my_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::map" << std::endl;
   test_my_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::map" << std::endl;
   test_my_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_COMPRESSED_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type compressed" << std::endl;
   test_my_vector<ublas::compressed_vector<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double compressed" << std::endl;
   test_my_vector<ublas::compressed_vector<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> compressed" << std::endl;
   test_my_vector<ublas::compressed_vector<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> compressed" << std::endl;
   test_my_vector<ublas::compressed_vector<std::complex<double> >, 3>()();
#endif
#endif
#endif

#ifdef USE_COORDINATE_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type coordinate" << std::endl;
   test_my_vector<ublas::coordinate_vector<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double coordinate" << std::endl;
   test_my_vector<ublas::coordinate_vector<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> coordinate" << std::endl;
   test_my_vector<ublas::coordinate_vector<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> coordinate" << std::endl;
   test_my_vector<ublas::coordinate_vector<std::complex<double> >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test32.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test3.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v1 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v1 << std::endl;
            v1 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v1 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         m1 = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N, N), v2(N, N);
         M m1(N, N, N * N);

         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, 0), mr2(m1, N - 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 0), mc2(m1, N - 1);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_SPARSE_MATRIX
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
                         ublas::mapped_matrix<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
                         ublas::mapped_matrix<double, ublas::row_major, ublas::map_array<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
                         ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
                         ublas::mapped_matrix<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
                         ublas::mapped_matrix<mp_test_type, ublas::row_major, std::map<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
                         ublas::mapped_matrix<double, ublas::row_major, std::map<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
                         ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
                         ublas::mapped_matrix<std::complex<double>, ublas::row_major, std::map<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_SPARSE_VECTOR_OF_SPARSE_VECTOR
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
                         ublas::mapped_vector<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
                         ublas::mapped_vector<double, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
                         ublas::mapped_vector<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>,mapped_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
                         ublas::mapped_vector<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<double> > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
                         ublas::mapped_vector<mp_test_type, ublas::row_major, std::map<std::size_t, std::map<std::size_t, mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
                         ublas::mapped_vector<double, ublas::row_major, std::map<std::size_t, std::map<std::size_t, double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
                         ublas::mapped_vector<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, mapped_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
                         ublas::mapped_vector<std::complex<double>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<double> > > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
                         ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
                         ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, ublas::map_array<std::size_t, ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
                         ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
                         ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, ublas::map_array<std::size_t, ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
                         ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
                         ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
                         ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
                         ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
                         ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
                         ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, std::map<std::size_t, ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
                         ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, std::map<std::size_t, double> > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
                         ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, std::map<std::size_t, ublas::mapped_vector<double, std::map<std::size_t, double> > > > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
                         ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
                         ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
                         ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > >, 3>()();
   test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
                         ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_COMPRESSED_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type compressed" << std::endl;
   test_my_matrix_vector<ublas::compressed_vector<mp_test_type>,
                         ublas::compressed_matrix<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double compressed" << std::endl;
   test_my_matrix_vector<ublas::compressed_vector<double>,
                         ublas::compressed_matrix<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> compressed" << std::endl;
   test_my_matrix_vector<ublas::compressed_vector<std::complex<mp_test_type> >,
                         ublas::compressed_matrix<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> compressed" << std::endl;
   test_my_matrix_vector<ublas::compressed_vector<std::complex<double> >,
                         ublas::compressed_matrix<std::complex<double> >, 3>()();
#endif
#endif
#endif

#ifdef USE_COORDINATE_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type coordinate" << std::endl;
   test_my_matrix_vector<ublas::coordinate_vector<mp_test_type>,
                         ublas::coordinate_matrix<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double coordinate" << std::endl;
   test_my_matrix_vector<ublas::coordinate_vector<double>,
                         ublas::coordinate_matrix<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> coordinate" << std::endl;
   test_my_matrix_vector<ublas::coordinate_vector<std::complex<mp_test_type> >,
                         ublas::coordinate_matrix<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> coordinate" << std::endl;
   test_my_matrix_vector<ublas::coordinate_vector<std::complex<double> >,
                         ublas::coordinate_matrix<std::complex<double> >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test33.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test3.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class MP>
   void test_with(MP& m1, MP& m2, MP& m3) const
   {
      {
         value_type t;

         // Default Construct
         default_construct<MP>::test();

         // Copy and swap
         initialize_matrix(m1);
         initialize_matrix(m2);
         m1 = m2;
         std::cout << "m1 = m2 = " << m1 << std::endl;
         m1.assign_temporary(m2);
         std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
         m1.swap(m2);
         std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

         // Zero assignment
         m1 = ublas::zero_matrix<>(m1.size1(), m1.size2());
         std::cout << "m1.zero_matrix = " << m1 << std::endl;
         m1 = m2;

#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
         // Project range and slice
         initialize_matrix(m1);
         initialize_matrix(m2);
         project(m1, ublas::range(0, 1), ublas::range(0, 1))         = project(m2, ublas::range(0, 1), ublas::range(0, 1));
         project(m1, ublas::range(0, 1), ublas::range(0, 1))         = project(m2, ublas::slice(0, 1, 1), ublas::slice(0, 1, 1));
         project(m1, ublas::slice(2, -1, 2), ublas::slice(2, -1, 2)) = project(m2, ublas::slice(0, 1, 2), ublas::slice(0, 1, 2));
         project(m1, ublas::slice(2, -1, 2), ublas::slice(2, -1, 2)) = project(m2, ublas::range(0, 2), ublas::range(0, 2));
         std::cout << "m1 = range/slice " << m1 << std::endl;
#endif

         // Unary matrix operations resulting in a matrix
         initialize_matrix(m1);
         m2 = -m1;
         std::cout << "- m1 = " << m2 << std::endl;
         m2 = ublas::conj(m1);
         std::cout << "conj (m1) = " << m2 << std::endl;

         // Binary matrix operations resulting in a matrix
         initialize_matrix(m1);
         initialize_matrix(m2);
         initialize_matrix(m3);
         m3 = m1 + m2;
         std::cout << "m1 + m2 = " << m3 << std::endl;
         m3 = m1 - m2;
         std::cout << "m1 - m2 = " << m3 << std::endl;

         // Scaling a matrix
         t = N;
         initialize_matrix(m1);
         m2 = value_type(1.) * m1;
         std::cout << "1. * m1 = " << m2 << std::endl;
         m2 = t * m1;
         std::cout << "N * m1 = " << m2 << std::endl;
         initialize_matrix(m1);
         m2 = m1 * value_type(1.);
         std::cout << "m1 * 1. = " << m2 << std::endl;
         m2 = m1 * t;
         std::cout << "m1 * N = " << m2 << std::endl;

         // Some assignments
         initialize_matrix(m1);
         initialize_matrix(m2);
         m2 += m1;
         std::cout << "m2 += m1 = " << m2 << std::endl;
         m2 -= m1;
         std::cout << "m2 -= m1 = " << m2 << std::endl;
         m2 = m2 + m1;
         std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
         m2 = m2 - m1;
         std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
         m1 *= value_type(1.);
         std::cout << "m1 *= 1. = " << m1 << std::endl;
         m1 *= t;
         std::cout << "m1 *= N = " << m1 << std::endl;

         // Transpose
         initialize_matrix(m1);
         m2 = ublas::trans(m1);
         std::cout << "trans (m1) = " << m2 << std::endl;

         // Hermitean
         initialize_matrix(m1);
         m2 = ublas::herm(m1);
         std::cout << "herm (m1) = " << m2 << std::endl;

         // Matrix multiplication
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = ublas::prod(m1, m2);
         std::cout << "prod (m1, m2) = " << m3 << std::endl;
      }
   }
   void operator()() const
   {
      {
         M m1(N, N, N * N), m2(N, N, N * N), m3(N, N, N * N);
         test_with(m1, m2, m3);

#ifdef USE_RANGE
         ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mr2(m2, ublas::range(0, N), ublas::range(0, N)),
             mr3(m3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_SPARSE_MATRIX
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_matrix map_array" << std::endl;
   test_my_matrix<ublas::mapped_matrix<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_matrix map_array" << std::endl;
   test_my_matrix<ublas::mapped_matrix<double, ublas::row_major, ublas::map_array<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_matrix map_array" << std::endl;
   test_my_matrix<ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, mapped_matrix map_array" << std::endl;
   test_my_matrix<ublas::mapped_matrix<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_matrix std::map" << std::endl;
   test_my_matrix<ublas::mapped_matrix<mp_test_type, ublas::row_major, std::map<std::size_t, mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_matrix std::map" << std::endl;
   test_my_matrix<ublas::mapped_matrix<double, ublas::row_major, std::map<std::size_t, double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_matrix std::map" << std::endl;
   test_my_matrix<ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, mapped_matrix std::map" << std::endl;
   test_my_matrix<ublas::mapped_matrix<std::complex<double>, ublas::row_major, std::map<std::size_t, std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_SPARSE_VECTOR_OF_SPARSE_VECTOR
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_vector_of_mapped_vector map_array" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_vector_of_mapped_vector map_array" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<double, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_vector_of_mapped_vector map_array" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, mapped_vector_of_mapped_vectormap_array" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<double> > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, mapped_vector_of_mapped_vector std::map" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<mp_test_type, ublas::row_major, std::map<std::size_t, std::map<std::size_t, mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, mapped_vector_of_mapped_vector std::map" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<double, ublas::row_major, std::map<std::size_t, std::map<std::size_t, double> > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, mapped_vector_of_mapped_vector std::map" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, mapped_vector_of_mapped_vector std::map" << std::endl;
   test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<double>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<double> > > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
#ifdef USE_MAP_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type,generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, ublas::map_array<std::size_t, ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, ublas::map_array<std::size_t, ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, generalized_vector_of_vector map_array" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_MAP
#ifdef USE_FLOAT
   std::cout << "mp_test_type, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, std::map<std::size_t, ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, std::map<std::size_t, double> > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, std::map<std::size_t, ublas::mapped_vector<double, std::map<std::size_t, double> > > > >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, generalized_vector_of_vector std::map" << std::endl;
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > >, 3>()();
   test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_COMPRESSED_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type compressed_matrix" << std::endl;
   test_my_matrix<ublas::compressed_matrix<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double compressed_matrix" << std::endl;
   test_my_matrix<ublas::compressed_matrix<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> compressed_matrix" << std::endl;
   test_my_matrix<ublas::compressed_matrix<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> compressed_matrix" << std::endl;
   test_my_matrix<ublas::compressed_matrix<std::complex<double> >, 3>()();
#endif
#endif
#endif

#ifdef USE_COORDINATE_MATRIX
#ifdef USE_FLOAT
   std::cout << "mp_test_type coordinate_matrix" << std::endl;
   test_my_matrix<ublas::coordinate_matrix<mp_test_type>, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double coordinate_matrix" << std::endl;
   test_my_matrix<ublas::coordinate_matrix<double>, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type> coordinate_matrix" << std::endl;
   test_my_matrix<ublas::coordinate_matrix<std::complex<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double> coordinate_matrix" << std::endl;
   test_my_matrix<ublas::coordinate_matrix<std::complex<double> >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test4.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test4.hpp"

int main()
{
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test4.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST4_H
#define TEST4_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/banded.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

//#define USE_BANDED
#define USE_DIAGONAL

void test_matrix_vector();
void test_matrix();

// FIXME slice are failing in assignment to zero elements
#undef USE_SLICE

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test42.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test4.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
#ifndef USE_DIAGONAL
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v2 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v2 << std::endl;
            v2 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v2 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         v1(0)     = 0;
         v1(N - 1) = 0;
         m1        = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
#else
      (void)v1;  // warning suppression
      (void)v2;  // warning suppression
      (void)m1;  // warning suppression
#endif
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N);
#ifdef USE_BANDED
         M m1(N, N, 1, 1);
#endif
#ifdef USE_DIAGONAL
         M m1(N, N);
#endif
         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, 1), mr2(m1, 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 1), mc2(m1, 1);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }

   void operator()(int) const
   {
#ifdef USE_ADAPTOR
      {
#ifdef USE_BANDED
         V                        v1(N), v2(N);
         M                        m1(N, N, 1, 1);
         ublas::banded_adaptor<M> bam1(m1, 1, 1);
         test_with(v1, v2, bam1);

         ublas::matrix_row<ublas::banded_adaptor<M> > mr1(bam1, 1), mr2(bam1, 1);
         test_with(mr1, mr2, bam1);

         ublas::matrix_column<ublas::banded_adaptor<M> > mc1(bam1, 1), mc2(bam1, 1);
         test_with(mc1, mc2, bam1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<ublas::banded_adaptor<M> > mvr1(bam1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(bam1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, bam1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<ublas::banded_adaptor<M> > mvs1(bam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(bam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, bam1);
#endif
#endif
#ifdef USE_DIAGONAL
         V                          v1(N), v2(N);
         M                          m1(N, N);
         ublas::diagonal_adaptor<M> dam1(m1);
         test_with(v1, v2, dam1);

         ublas::matrix_row<ublas::diagonal_adaptor<M> > mr1(dam1, 1), mr2(dam1, 1);
         test_with(mr1, mr2, dam1);

         ublas::matrix_column<ublas::diagonal_adaptor<M> > mc1(dam1, 1), mc2(dam1, 1);
         test_with(mc1, mc2, dam1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<ublas::diagonal_adaptor<M> > mvr1(dam1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(dam1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, dam1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<ublas::diagonal_adaptor<M> > mvs1(dam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(dam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, dam1);
#endif
#endif
      }
#endif
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_BANDED
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif
#endif

#ifdef USE_DIAGONAL
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test43.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test4.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class MP>
   void test_with(MP& m1, MP& m2, MP& m3) const
   {
      {
         value_type t;

         // Default Construct
         default_construct<MP>::test();

         // Copy and swap
         initialize_matrix(m1);
         initialize_matrix(m2);
         m1 = m2;
         std::cout << "m1 = m2 = " << m1 << std::endl;
         m1.assign_temporary(m2);
         std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
         m1.swap(m2);
         std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

         // Zero assignment
         m1 = ublas::zero_matrix<>(m1.size1(), m1.size2());
         std::cout << "m1.zero_matrix = " << m1 << std::endl;
         m1 = m2;

         // Unary matrix operations resulting in a matrix
         initialize_matrix(m1);
         m2 = -m1;
         std::cout << "- m1 = " << m2 << std::endl;
         m2 = ublas::conj(m1);
         std::cout << "conj (m1) = " << m2 << std::endl;

         // Binary matrix operations resulting in a matrix
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = m1 + m2;
         std::cout << "m1 + m2 = " << m3 << std::endl;
         m3 = m1 - m2;
         std::cout << "m1 - m2 = " << m3 << std::endl;

         // Scaling a matrix
         t = N;
         initialize_matrix(m1);
         m2 = value_type(1.) * m1;
         std::cout << "1. * m1 = " << m2 << std::endl;
         m2 = t * m1;
         std::cout << "N * m1 = " << m2 << std::endl;
         initialize_matrix(m1);
         m2 = m1 * value_type(1.);
         std::cout << "m1 * 1. = " << m2 << std::endl;
         m2 = m1 * t;
         std::cout << "m1 * N = " << m2 << std::endl;

         // Some assignments
         initialize_matrix(m1);
         initialize_matrix(m2);
         m2 += m1;
         std::cout << "m2 += m1 = " << m2 << std::endl;
         m2 -= m1;
         std::cout << "m2 -= m1 = " << m2 << std::endl;
         m2 = m2 + m1;
         std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
         m2 = m2 - m1;
         std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
         m1 *= value_type(1.);
         std::cout << "m1 *= 1. = " << m1 << std::endl;
         m1 *= t;
         std::cout << "m1 *= N = " << m1 << std::endl;

         // Transpose
         initialize_matrix(m1);
         m2 = ublas::trans(m1);
         std::cout << "trans (m1) = " << m2 << std::endl;

         // Hermitean
         initialize_matrix(m1);
         m2 = ublas::herm(m1);
         std::cout << "herm (m1) = " << m2 << std::endl;

         // Matrix multiplication
         initialize_matrix(m1);
         initialize_matrix(m2);
         // Banded times banded isn't banded
         std::cout << "prod (m1, m2) = " << ublas::prod(m1, m2) << std::endl;
      }
   }
   void operator()() const
   {
      {
#ifdef USE_BANDED
         M m1(N, N, 1, 1), m2(N, N, 1, 1), m3(N, N, 1, 1);
#endif
#ifdef USE_DIAGONAL
         M m1(N, N), m2(N, N), m3(N, N);
#endif
         test_with(m1, m2, m3);

#ifdef USE_RANGE
         ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mr2(m2, ublas::range(0, N), ublas::range(0, N)),
             mr3(m3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }

#ifdef USE_ADAPTOR
      {
#ifdef USE_BANDED
         M                        m1(N, N, 1, 1), m2(N, N, 1, 1), m3(N, N, 1, 1);
         ublas::banded_adaptor<M> bam1(m1, 1, 1), bam2(m2, 1, 1), bam3(m3, 1, 1);
         test_with(bam1, bam2, bam3);

#ifdef USE_RANGE
         ublas::matrix_range<ublas::banded_adaptor<M> > mr1(bam1, ublas::range(0, N), ublas::range(0, N)),
             mr2(bam2, ublas::range(0, N), ublas::range(0, N)),
             mr3(bam3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<ublas::banded_adaptor<M> > ms1(bam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(bam2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(bam3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
#endif
#ifdef USE_DIAGONAL
         M                          m1(N, N), m2(N, N), m3(N, N);
         ublas::diagonal_adaptor<M> dam1(m1), dam2(m2), dam3(m3);
         test_with(dam1, dam2, dam3);

#ifdef USE_RANGE
         ublas::matrix_range<ublas::diagonal_adaptor<M> > mr1(dam1, ublas::range(0, N), ublas::range(0, N)),
             mr2(dam2, ublas::range(0, N), ublas::range(0, N)),
             mr3(dam3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<ublas::diagonal_adaptor<M> > ms1(dam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(dam2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(dam3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
#endif
      }
#endif
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_BANDED
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif

#ifdef USE_DIAGONAL
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test5.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test5.hpp"

int main()
{
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test5.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST5_H
#define TEST5_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/triangular.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

void test_matrix_vector();
void test_matrix();

// FIXME slice are failing in assignment to zero elements
#undef USE_SLICE

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test52.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test5.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v2 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v2 << std::endl;
            v2 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v2 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         v1(0)     = 0;
         v2(N - 1) = 0;
         m1        = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N);
         M m1(N, N);
         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, N - 1), mr2(m1, N - 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 0), mc2(m1, 0);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }

   void operator()(int) const
   {
#ifdef USE_ADAPTOR
      {
         V                            v1(N), v2(N);
         M                            m1(N, N);
         ublas::triangular_adaptor<M> tam1(m1);
         test_with(v1, v2, tam1);

         ublas::matrix_row<ublas::triangular_adaptor<M> > mr1(tam1, N - 1), mr2(tam1, N - 1);
         test_with(mr1, mr2, tam1);

         ublas::matrix_column<ublas::triangular_adaptor<M> > mc1(tam1, 0), mc2(tam1, 0);
         test_with(mc1, mc2, tam1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<ublas::triangular_adaptor<M> > mvr1(tam1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(tam1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, tam1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<ublas::triangular_adaptor<M> > mvs1(tam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(tam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, tam1);
#endif
      }
#endif
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()(0);

   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test53.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test5.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class MP>
   void test_with(MP& m1, MP& m2, MP& m3) const
   {
      {
         value_type t;

         // Default Construct
         default_construct<MP>::test();

         // Copy and swap
         initialize_matrix(m1);
         initialize_matrix(m2);
         m1 = m2;
         std::cout << "m1 = m2 = " << m1 << std::endl;
         m1.assign_temporary(m2);
         std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
         m1.swap(m2);
         std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

         // Zero assignment
         m1 = ublas::zero_matrix<>(m1.size1(), m1.size2());
         std::cout << "m1.zero_matrix = " << m1 << std::endl;
         m1 = m2;

         // Unary matrix operations resulting in a matrix
         initialize_matrix(m1);
         m2 = -m1;
         std::cout << "- m1 = " << m2 << std::endl;
         m2 = ublas::conj(m1);
         std::cout << "conj (m1) = " << m2 << std::endl;

         // Binary matrix operations resulting in a matrix
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = m1 + m2;
         std::cout << "m1 + m2 = " << m3 << std::endl;
         m3 = m1 - m2;
         std::cout << "m1 - m2 = " << m3 << std::endl;

         // Scaling a matrix
         t = N;
         initialize_matrix(m1);
         m2 = value_type(1.) * m1;
         std::cout << "1. * m1 = " << m2 << std::endl;
         m2 = t * m1;
         std::cout << "N * m1 = " << m2 << std::endl;
         initialize_matrix(m1);
         m2 = m1 * value_type(1.);
         std::cout << "m1 * 1. = " << m2 << std::endl;
         m2 = m1 * t;
         std::cout << "m1 * N = " << m2 << std::endl;

         // Some assignments
         initialize_matrix(m1);
         initialize_matrix(m2);
         m2 += m1;
         std::cout << "m2 += m1 = " << m2 << std::endl;
         m2 -= m1;
         std::cout << "m2 -= m1 = " << m2 << std::endl;
         m2 = m2 + m1;
         std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
         m2 = m2 - m1;
         std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
         m1 *= value_type(1.);
         std::cout << "m1 *= 1. = " << m1 << std::endl;
         m1 *= t;
         std::cout << "m1 *= N = " << m1 << std::endl;

         // Transpose
         initialize_matrix(m1);
         // Transpose of a triangular isn't triangular of the same kind
         std::cout << "trans (m1) = " << ublas::trans(m1) << std::endl;

         // Hermitian
         initialize_matrix(m1);
         // Hermitian of a triangular isn't hermitian of the same kind
         std::cout << "herm (m1) = " << ublas::herm(m1) << std::endl;

         // Matrix multiplication
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = ublas::prod(m1, m2);
         std::cout << "prod (m1, m2) = " << m3 << std::endl;
      }
   }
   void operator()() const
   {
      {
         M m1(N, N), m2(N, N), m3(N, N);
         test_with(m1, m2, m3);

#ifdef USE_RANGE
         ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mr2(m2, ublas::range(0, N), ublas::range(0, N)),
             mr3(m3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }

#ifdef USE_ADAPTOR
      {
         M                            m1(N, N), m2(N, N), m3(N, N);
         ublas::triangular_adaptor<M> tam1(m1), tam2(m2), tam3(m3);
         test_with(tam1, tam2, tam3);

#ifdef USE_RANGE
         ublas::matrix_range<ublas::triangular_adaptor<M> > mr1(tam1, ublas::range(0, N), ublas::range(0, N)),
             mr2(tam2, ublas::range(0, N), ublas::range(0, N)),
             mr3(tam3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<ublas::triangular_adaptor<M> > ms1(tam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(tam2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(tam3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }
#endif
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test6.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test6.hpp"

int main()
{
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test6.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST6_H
#define TEST6_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996 4127 4100)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_BOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/symmetric.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

void test_matrix_vector();
void test_matrix();

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test62.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test6.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v2 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v2 << std::endl;
            v2 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v2 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         v1(0)     = 0;
         v1(N - 1) = 0;
         v2(0)     = 0;
         v2(N - 1) = 0;
         m1        = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N);
         M m1(N, N);
         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, N - 1), mr2(m1, N - 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 0), mc2(m1, 0);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }

   void operator()(int) const
   {
#ifdef USE_ADAPTOR
      {
         V                           v1(N), v2(N);
         M                           m1(N, N);
         ublas::symmetric_adaptor<M> tam1(m1);
         test_with(v1, v2, tam1);

         ublas::matrix_row<ublas::symmetric_adaptor<M> > mr1(tam1, N - 1), mr2(tam1, N - 1);
         test_with(mr1, mr2, tam1);

         ublas::matrix_column<ublas::symmetric_adaptor<M> > mc1(tam1, 0), mc2(tam1, 0);
         test_with(mc1, mc2, tam1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<ublas::symmetric_adaptor<M> > mvr1(tam1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(tam1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, tam1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<ublas::symmetric_adaptor<M> > mvs1(tam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(tam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, tam1);
#endif
      }
#endif
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()();
   test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
                         ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()();
   test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
                         ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()(0);
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
                         ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()(0);
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
   test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
                         ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()(0);
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test63.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test6.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class MP>
   void test_with(MP& m1, MP& m2, MP& m3) const
   {
      {
         value_type t;

         // Default Construct
         default_construct<MP>::test();

         // Copy and swap
         initialize_matrix(m1);
         initialize_matrix(m2);
         m1 = m2;
         std::cout << "m1 = m2 = " << m1 << std::endl;
         m1.assign_temporary(m2);
         std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
         m1.swap(m2);
         std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

         // Zero assignment
         m1 = ublas::zero_matrix<>(m1.size1(), m1.size2());
         std::cout << "m1.zero_matrix = " << m1 << std::endl;
         m1 = m2;

         // Unary matrix operations resulting in a matrix
         initialize_matrix(m1);
         m2 = -m1;
         std::cout << "- m1 = " << m2 << std::endl;
         m2 = ublas::conj(m1);
         std::cout << "conj (m1) = " << m2 << std::endl;

         // Binary matrix operations resulting in a matrix
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = m1 + m2;
         std::cout << "m1 + m2 = " << m3 << std::endl;
         m3 = m1 - m2;
         std::cout << "m1 - m2 = " << m3 << std::endl;

         // Scaling a matrix
         t = N;
         initialize_matrix(m1);
         m2 = value_type(1.) * m1;
         std::cout << "1. * m1 = " << m2 << std::endl;
         m2 = t * m1;
         std::cout << "N * m1 = " << m2 << std::endl;
         initialize_matrix(m1);
         m2 = m1 * value_type(1.);
         std::cout << "m1 * 1. = " << m2 << std::endl;
         m2 = m1 * t;
         std::cout << "m1 * N = " << m2 << std::endl;

         // Some assignments
         initialize_matrix(m1);
         initialize_matrix(m2);
         m2 += m1;
         std::cout << "m2 += m1 = " << m2 << std::endl;
         m2 -= m1;
         std::cout << "m2 -= m1 = " << m2 << std::endl;
         m2 = m2 + m1;
         std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
         m2 = m2 - m1;
         std::cout << "m2 = m1 - m1 = " << m2 << std::endl;
         m1 *= value_type(1.);
         std::cout << "m1 *= 1. = " << m1 << std::endl;
         m1 *= t;
         std::cout << "m1 *= N = " << m1 << std::endl;

         // Transpose
         initialize_matrix(m1);
         m2 = ublas::trans(m1);
         std::cout << "trans (m1) = " << m2 << std::endl;

         // Hermitean
         initialize_matrix(m1);
         m2 = ublas::herm(m1);
         std::cout << "herm (m1) = " << m2 << std::endl;

         // Matrix multiplication
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = ublas::prod(m1, m2);
         std::cout << "prod (m1, m2) = " << m3 << std::endl;
      }
   }
   void operator()() const
   {
      {
         M m1(N, N), m2(N, N), m3(N, N);
         test_with(m1, m2, m3);

#ifdef USE_RANGE
         ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mr2(m2, ublas::range(0, N), ublas::range(0, N)),
             mr3(m3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }

#ifdef USE_ADAPTOR
      {
         M                           m1(N, N), m2(N, N), m3(N, N);
         ublas::symmetric_adaptor<M> sam1(m1), sam2(m2), sam3(m3);
         test_with(sam1, sam2, sam3);

#ifdef USE_RANGE
         ublas::matrix_range<ublas::symmetric_adaptor<M> > mr1(sam1, ublas::range(0, N), ublas::range(0, N)),
             mr2(sam2, ublas::range(0, N), ublas::range(0, N)),
             mr3(sam3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<ublas::symmetric_adaptor<M> > ms1(sam1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(sam2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(sam3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }
#endif
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, bounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, bounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3>()();
#endif
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "mp_test_type, unbounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, unbounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "mp_test_type, std::vector" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "double, std::vector" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3>()();
#endif

#ifdef USE_STD_COMPLEX
#ifdef USE_FLOAT
   std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "std::complex<double>, std::vector" << std::endl;
   test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test7.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include <iostream>

#include <boost/numeric/interval.hpp>
#include <boost/numeric/interval/io.hpp>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

#include "test7.hpp"

// this testcase requires fix of task #2473

int main()
{
   test_vector();
   test_matrix_vector();
   test_matrix();
   return 0;
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test7.hpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef TEST7_H
#define TEST7_H

#ifdef _MSC_VER
#pragma warning(disable : 4800 4996)
#endif

#include <boost/multiprecision/cpp_dec_float.hpp>

#ifdef TEST_ET
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_on> mp_test_type;
#else
typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>, boost::multiprecision::et_off> mp_test_type;
#endif
//typedef double mp_test_type;

#define USE_RANGE
#define USE_SLICE
#define USE_FLOAT
#define USE_UNBOUNDED_ARRAY
#define USE_BOUNDED_ARRAY
#define USE_STD_VECTOR
#define USE_BOUNDED_VECTOR USE_MATRIX
#define USE_UNBOUNDED_ARRAY
#define USE_MAP_ARRAY
#define USE_STD_MAP
#define USE_MAPPED_VECTOR
#define USE_COMPRESSED_VECTOR
#define USE_COORDINATE_VECTOR
#define USE_MAPPED_MATRIX
#define USE_COMPRESSED_MATRIX
#define USE_COORDINATE_MATRIX

#include <iostream>

#include <boost/numeric/interval.hpp>
#include <boost/numeric/interval/io.hpp>

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>

namespace ublas = boost::numeric::ublas;

#include "common/init.hpp"

void test_vector();
void test_matrix_vector();
void test_matrix();

#endif


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test71.cpp
================================================
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

//
// This file fails to compile - appears to be a known uBlas issue :-(
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test7.hpp"

// Test vector expression templates
template <class V, int N>
struct test_my_vector
{
   typedef typename V::value_type                             value_type;
   typedef typename V::size_type                              size_type;
   typedef typename ublas::type_traits<value_type>::real_type real_type;

   template <class VP>
   void test_with(VP& v1, VP& v2, VP& v3) const
   {
      {
         value_type t;
         size_type  i;
         real_type  n;

         // Copy and swap
         initialize_vector(v1);
         initialize_vector(v2);
         v1 = v2;
         std::cout << "v1 = v2 = " << v1 << std::endl;
         v1.assign_temporary(v2);
         std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
         v1.swap(v2);
         std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;

         // Zero assignment
         v1 = ublas::zero_vector<value_type>(v1.size());
         std::cout << "v1.zero_vector = " << v1 << std::endl;
         v1 = v2;

         // Unary vector operations resulting in a vector
         initialize_vector(v1);
         v2 = -v1;
         std::cout << "- v1 = " << v2 << std::endl;
         v2 = ublas::conj(v1);
         std::cout << "conj (v1) = " << v2 << std::endl;

         // Binary vector operations resulting in a vector
         initialize_vector(v1);
         initialize_vector(v2);
         v3 = v1 + v2;
         std::cout << "v1 + v2 = " << v3 << std::endl;

         v3 = v1 - v2;
         std::cout << "v1 - v2 = " << v3 << std::endl;

         // Scaling a vector
         t = value_type(N);
         initialize_vector(v1);
         v2 = value_type(1.) * v1;
         std::cout << "1. * v1 = " << v2 << std::endl;
         //            v2 = t * v1;
         std::cout << "N * v1 = " << v2 << std::endl;
         initialize_vector(v1);
         //            v2 = v1 * value_type (1.);
         std::cout << "v1 * 1. = " << v2 << std::endl;
         //            v2 = v1 * t;
         std::cout << "v1 * N = " << v2 << std::endl;

         // Some assignments
         initialize_vector(v1);
         initialize_vector(v2);
         v2 += v1;
         std::cout << "v2 += v1 = " << v2 << std::endl;
         v2 -= v1;
         std::cout << "v2 -= v1 = " << v2 << std::endl;
         v2 = v2 + v1;
         std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
         v2 = v2 - v1;
         std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
         v1 *= value_type(1.);
         std::cout << "v1 *= 1. = " << v1 << std::endl;
         v1 *= t;
         std::cout << "v1 *= N = " << v1 << std::endl;

         // Unary vector operations resulting in a scalar
         initialize_vector(v1);
         t = ublas::sum(v1);
         std::cout << "sum (v1) = " << t << std::endl;
         n = ublas::norm_1(v1);
         std::cout << "norm_1 (v1) = " << n << std::endl;
         n = ublas::norm_2(v1);
         std::cout << "norm_2 (v1) = " << n << std::endl;
         n = ublas::norm_inf(v1);
         std::cout << "norm_inf (v1) = " << n << std::endl;

         i = ublas::index_norm_inf(v1);
         std::cout << "index_norm_inf (v1) = " << i << std::endl;

         // Binary vector operations resulting in a scalar
         initialize_vector(v1);
         initialize_vector(v2);
         t = ublas::inner_prod(v1, v2);
         std::cout << "inner_prod (v1, v2) = " << t << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N), v3(N);
         test_with(v1, v2, v3);

#ifdef USE_RANGE
         ublas::vector_range<V> vr1(v1, ublas::range(0, N)),
             vr2(v2, ublas::range(0, N)),
             vr3(v3, ublas::range(0, N));
         test_with(vr1, vr2, vr3);
#endif

#ifdef USE_SLICE
         ublas::vector_slice<V> vs1(v1, ublas::slice(0, 1, N)),
             vs2(v2, ublas::slice(0, 1, N)),
             vs3(v3, ublas::slice(0, 1, N));
         test_with(vs1, vs2, vs3);
#endif
      }
   }
};

// Test vector
void test_vector()
{
   std::cout << "test_vector" << std::endl;

#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >, 3>()();
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >, 3>()();
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
   test_my_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >, 3>()();
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test72.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test7.hpp"

// Test matrix & vector expression templates
template <class V, class M, int N>
struct test_my_matrix_vector
{
   typedef typename V::value_type value_type;

   template <class VP, class MP>
   void test_with(VP& v1, VP& v2, MP& m1) const
   {
      {
         // Rows and columns
         initialize_matrix(m1);
         for (int i = 0; i < N; ++i)
         {
            v1 = ublas::row(m1, i);
            std::cout << "row (m, " << i << ") = " << v1 << std::endl;
            v1 = ublas::column(m1, i);
            std::cout << "column (m, " << i << ") = " << v1 << std::endl;
         }

         // Outer product
         initialize_vector(v1);
         initialize_vector(v2);
         m1 = ublas::outer_prod(v1, v2);
         std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;

         // Matrix vector product
         initialize_matrix(m1);
         initialize_vector(v1);
         v2 = ublas::prod(m1, v1);
         std::cout << "prod (m1, v1) = " << v2 << std::endl;
         v2 = ublas::prod(v1, m1);
         std::cout << "prod (v1, m1) = " << v2 << std::endl;
      }
   }
   void operator()() const
   {
      {
         V v1(N), v2(N);
         M m1(N, N);
         test_with(v1, v2, m1);

         ublas::matrix_row<M> mr1(m1, 0), mr2(m1, 1);
         test_with(mr1, mr2, m1);

         ublas::matrix_column<M> mc1(m1, 0), mc2(m1, 1);
         test_with(mc1, mc2, m1);

#ifdef USE_RANGE
         ublas::matrix_vector_range<M> mvr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mvr2(m1, ublas::range(0, N), ublas::range(0, N));
         test_with(mvr1, mvr2, m1);
#endif

#ifdef USE_SLICE
         ublas::matrix_vector_slice<M> mvs1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             mvs2(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(mvs1, mvs2, m1);
#endif
      }
   }
};

// Test matrix & vector
void test_matrix_vector()
{
   std::cout << "test_matrix_vector" << std::endl;

#ifdef USE_MATRIX
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >,
                         ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >,
                         ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<double>, 3 * 3> >, 3>()();
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >,
                         ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >,
                         ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<double> > >, 3>()();
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >,
                         ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >,
                         ublas::matrix<boost::numeric::interval<double>, ublas::row_major, std::vector<boost::numeric::interval<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_VECTOR_OF_VECTOR
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >,
                         ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >,
                         ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<double>, 3>, 3 + 1> >, 3>()();
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >,
                         ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >,
                         ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<double> > > >, 3>()();
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >,
                         ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
   test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >,
                         ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<double> > > >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/test/ublas_interop/test73.cpp
================================================
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#if defined(__GNUC__) && (__GNUC__ >= 9)
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif

#include "test7.hpp"

// Test matrix expression templates
template <class M, int N>
struct test_my_matrix
{
   typedef typename M::value_type value_type;

   template <class MP>
   void test_with(MP& m1, MP& m2, MP& m3) const
   {
      {
         value_type t;

         // Copy and swap
         initialize_matrix(m1);
         initialize_matrix(m2);
         m1 = m2;
         std::cout << "m1 = m2 = " << m1 << std::endl;
         m1.assign_temporary(m2);
         std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
         m1.swap(m2);
         std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;

         // Zero assignment
         m1 = ublas::zero_matrix<value_type>(m1.size1(), m1.size2());
         std::cout << "m1.zero_matrix = " << m1 << std::endl;
         m1 = m2;

         // Unary matrix operations resulting in a matrix
         initialize_matrix(m1);
         m2 = -m1;
         std::cout << "- m1 = " << m2 << std::endl;
         m2 = ublas::conj(m1);
         std::cout << "conj (m1) = " << m2 << std::endl;

         // Binary matrix operations resulting in a matrix
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = m1 + m2;
         std::cout << "m1 + m2 = " << m3 << std::endl;
         m3 = m1 - m2;
         std::cout << "m1 - m2 = " << m3 << std::endl;

         // Scaling a matrix
         t = N;
         initialize_matrix(m1);
         m2 = value_type(1.) * m1;
         std::cout << "1. * m1 = " << m2 << std::endl;
         m2 = t * m1;
         std::cout << "N * m1 = " << m2 << std::endl;
         initialize_matrix(m1);
         m2 = m1 * value_type(1.);
         std::cout << "m1 * 1. = " << m2 << std::endl;
         m2 = m1 * t;
         std::cout << "m1 * N = " << m2 << std::endl;

         // Some assignments
         initialize_matrix(m1);
         initialize_matrix(m2);
         m2 += m1;
         std::cout << "m2 += m1 = " << m2 << std::endl;
         m2 -= m1;
         std::cout << "m2 -= m1 = " << m2 << std::endl;
         m2 = m2 + m1;
         std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
         m2 = m2 - m1;
         std::cout << "m2 = m1 - m1 = " << m2 << std::endl;
         m1 *= value_type(1.);
         std::cout << "m1 *= 1. = " << m1 << std::endl;
         m1 *= t;
         std::cout << "m1 *= N = " << m1 << std::endl;

         // Transpose
         initialize_matrix(m1);
         m2 = ublas::trans(m1);
         std::cout << "trans (m1) = " << m2 << std::endl;

         // Hermitean
         initialize_matrix(m1);
         m2 = ublas::herm(m1);
         std::cout << "herm (m1) = " << m2 << std::endl;

         // Matrix multiplication
         initialize_matrix(m1);
         initialize_matrix(m2);
         m3 = ublas::prod(m1, m2);
         std::cout << "prod (m1, m2) = " << m3 << std::endl;
      }
   }
   void operator()() const
   {
      {
         M m1(N, N), m2(N, N), m3(N, N);
         test_with(m1, m2, m3);

#ifdef USE_RANGE
         ublas::matrix_range<M> mr1(m1, ublas::range(0, N), ublas::range(0, N)),
             mr2(m2, ublas::range(0, N), ublas::range(0, N)),
             mr3(m3, ublas::range(0, N), ublas::range(0, N));
         test_with(mr1, mr2, mr3);
#endif

#ifdef USE_SLICE
         ublas::matrix_slice<M> ms1(m1, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms2(m2, ublas::slice(0, 1, N), ublas::slice(0, 1, N)),
             ms3(m3, ublas::slice(0, 1, N), ublas::slice(0, 1, N));
         test_with(ms1, ms2, ms3);
#endif
      }
   }
};

// Test matrix
void test_matrix()
{
   std::cout << "test_matrix" << std::endl;

#ifdef USE_MATRIX
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3 * 3> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<double>, 3 * 3> >, 3>()();
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<double> > >, 3>()();
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<boost::numeric::interval<mp_test_type> > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
   test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, std::vector<boost::numeric::interval<double> > >, 3>()();
#endif
#endif
#endif

#ifdef USE_VECTOR_OF_VECTOR
#ifdef USE_BOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3>, 3 + 1> >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<double>, 3>, 3 + 1> >, 3>()();
#endif
#endif

#ifdef USE_UNBOUNDED_ARRAY
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<double> > > >, 3>()();
#endif
#endif

#ifdef USE_STD_VECTOR
#ifdef USE_FLOAT
   std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<mp_test_type> > > >, 3>()();
#endif

#ifdef USE_DOUBLE
   std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
   test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<double> > > >, 3>()();
#endif
#endif
#endif
}


================================================
FILE: examples/libraries/multiprecision-Boost_1_81_0/tools/sincos.cpp
================================================
// Copyright John Maddock 2013.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

//[special_data_example

#include <boost/multiprecision/mpfr.hpp>
#include <boost/math/tools/test_data.hpp>
#include <boost/test/included/prg_exec_monitor.hpp>
#include <boost/math/tools/tuple.hpp>
#include <fstream>

using namespace boost::math::tools;
using namespace boost::math;
using namespace std;
using namespace boost::multiprecision;

typedef number<mpfr_float_backend<1000> > mp_type;


boost::math::tuple<mp_type, mp_type, mp_type> generate(mp_type a)
{
   mp_type ts, tc;
   ts = sin(a);
   tc = cos(a);
   return boost::math::make_tuple(a, ts, tc);
}

int cpp_main(int argc, char*argv [])
{
   parameter_info<mp_type> arg1, arg2;
   test_data<mp_type> data;

   bool cont;
   std::string line;

   if(argc < 1)
      return 1;

   do{
      //
      // User interface which prompts for 
      // range of input parameters:
      //
      if(0 == get_user_parameter_info(arg1, "a"))
         return 1;
      arg1.type |= dummy_param;

      data.insert(&generate, arg1);

      std::cout << "Any more data [y/n]?";
      std::getline(std::cin, line);
      boost::algorithm::trim(line);
      cont = (line == "y");
   }while(cont);
   //
   // Just need to write the results to a file:
   //
   std::cout << "Enter name of test data file [default=sincos.ipp]";
   std::getline(std::cin, line);
   boost::algorithm::trim(line);
   if(line == "")
      line = "sincos.ipp";
   std::ofstream ofs(line.c_str());
   line.erase(line.find('.'));
   ofs << std::scientific << std::setprecision(500);
   write_code(ofs, data, line.c_str());

   return 0;
}

//]



================================================
FILE: examples/libraries/rapidcsv/.travis.yml
================================================
language:
  - cpp

sudo:
  - false

os:
  - linux
  - osx

dist:
  - xenial

script:
  - mkdir -p build
  - cd build
  - cmake ..
  - make
  - ctest -C unit --output-on-failure
  - ctest -C perf --verbose



================================================
FILE: examples/libraries/rapidcsv/CMakeLists.txt
================================================
# Project
cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
project(rapidcsv VERSION 1.0 LANGUAGES CXX)
set (CMAKE_CXX_STANDARD 11)
if(MSVC)
  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
  else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
  endif()
else()
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -Wpedantic -Wshadow -Wpointer-arith \
                       -Wcast-qual -Wno-missing-braces -Wswitch-default -Wcast-align -Wunreachable-code \
                       -Wundef -Wuninitialized")
endif()

include(CheckIncludeFileCXX)
check_include_file_cxx(codecvt HAS_CODECVT)
if(HAS_CODECVT)
  add_definitions(-DHAS_CODECVT)
endif()

# Ccache
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
  message(STATUS "Found ccache")
  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
endif()

# Test init
include(CTest)
enable_testing()
include_directories("src")
set(LIB_HEADERS "src/rapidcsv.h")
set(TEST_HEADERS "tests/unittest.h")

# Test macro add_perf_test
macro (add_perf_test testname)
  add_executable(${testname} tests/${testname}.cpp)
  add_test(NAME ${testname} CONFIGURATIONS perf Release COMMAND "${PROJECT_BINARY_DIR}/${testname}")
endmacro (add_perf_test)

# Test macro add_unit_test
macro (add_unit_test testname)
  add_executable(${testname} tests/${testname}.cpp)
  add_test(NAME ${testname} CONFIGURATIONS unit Debug COMMAND "${PROJECT_BINARY_DIR}/${testname}")
endmacro (add_unit_test)

# Unit tests
if(1)
  add_unit_test(test001)
  add_unit_test(test002)
  add_unit_test(test003)
  add_unit_test(test004)
  add_unit_test(test005)
  add_unit_test(test006)
  add_unit_test(test007)
  add_unit_test(test008)
  add_unit_test(test009)
  add_unit_test(test010)
  add_unit_test(test011)
  add_unit_test(test012)
  add_unit_test(test013)
  add_unit_test(test014)
  add_unit_test(test015)
  add_unit_test(test016)
  add_unit_test(test017)
  add_unit_test(test018)
  add_unit_test(test019)
  add_unit_test(test020)
  add_unit_test(test021)
  add_unit_test(test022)
  add_unit_test(test023)
  add_unit_test(test024)
  add_unit_test(test025)
  add_unit_test(test026)
  add_unit_test(test027)
  add_unit_test(test028)
  add_unit_test(test029)
  add_unit_test(test030)
  add_unit_test(test031)
  add_unit_test(test032)
  add_unit_test(test033)
  add_unit_test(test034)
  add_unit_test(test035)
  add_unit_test(test036)
  add_unit_test(test037)
  add_unit_test(test038)
  add_unit_test(test039)
  add_executable(test040 tests/test040.cpp tests/test040b.cpp)
  add_test(NAME text040 CONFIGURATIONS unit COMMAND "${PROJECT_BINARY_DIR}/test040")
  add_unit_test(test041)
  add_unit_test(test042)
  add_unit_test(test043)
  add_unit_test(test044)
  add_unit_test(test045)
  add_unit_test(test046)
  add_unit_test(test047)
  add_unit_test(test048)
  add_unit_test(test049)
  add_unit_test(test050)
  add_unit_test(test051)
  add_unit_test(test052)
  add_unit_test(test053)
  add_unit_test(test054)
  add_unit_test(test055)
  add_unit_test(test056)
  if (HAS_CODECVT)
    add_unit_test(test057)
    add_unit_test(test058)
    add_unit_test(test059)
    add_unit_test(test060)
  endif()
  add_unit_test(test061)
  add_unit_test(test062)
  add_unit_test(test063)
  add_unit_test(test064)
  add_unit_test(test065)
  add_unit_test(test066)
endif()
  
# perf tests
add_perf_test(ptest001)
add_perf_test(ptest002)

# Examples
add_executable(ex001 examples/ex001.cpp)
add_executable(ex002 examples/ex002.cpp)
add_executable(ex003 examples/ex003.cpp)
add_executable(ex004 examples/ex004.cpp)
add_executable(ex005 examples/ex005.cpp)
add_executable(ex006 examples/ex006.cpp)
add_executable(ex007 examples/ex007.cpp)
add_executable(ex008 examples/ex008.cpp)
add_executable(ex009 examples/ex009.cpp)



================================================
FILE: examples/libraries/rapidcsv/LICENSE
================================================
BSD 3-Clause License

Copyright (c) 2017, Kristofer Berggren
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: examples/libraries/rapidcsv/README.md
================================================
Rapidcsv
========

| **Linux + Mac** | **Windows** |
|-----------------|-------------|
| [![Build status](https://travis-ci.com/d99kris/rapidcsv.svg?branch=master)](https://travis-ci.com/d99kris/rapidcsv) | [![Build status](https://ci.appveyor.com/api/projects/status/yyc65as5ln6m6i8l/branch/master?svg=true)](https://ci.appveyor.com/project/d99kris/rapidcsv/branch/master) |

Rapidcsv is a C++ header-only library for CSV parsing. While the name
admittedly was inspired by the rapidjson project, the objectives are not the
same. The goal of rapidcsv is to be an easy-to-use CSV library enabling rapid
development. For optimal performance (be it CPU or memory usage) a CSV parser
implemented for the specific use-case is likely to be more performant.

Example Usage
=============
Here is a simple example reading a CSV file and getting 'Close' column as a
vector of floats.

[colhdr.csv](examples/colhdr.csv) content:
```
    Open,High,Low,Close,Volume,Adj Close
    64.529999,64.800003,64.139999,64.620003,21705200,64.620003
    64.419998,64.730003,64.190002,64.620003,20235200,64.620003
    64.330002,64.389999,64.050003,64.360001,19259700,64.360001
    64.610001,64.949997,64.449997,64.489998,19384900,64.489998
    64.470001,64.690002,64.300003,64.620003,21234600,64.620003
```

[ex001.cpp](examples/ex001.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/colhdr.csv");

      std::vector<float> col = doc.GetColumn<float>("Close");
      std::cout << "Read " << col.size() << " values." << std::endl;
    }
```

Refer to section [More Examples](#more-examples) below for more examples.
The [tests](tests/) directory also contains many simple usage examples.

Supported Platforms
===================
Rapidcsv is implemented using C++11 with the intention of being portable. It's
been tested on:
- macOS Catalina 10.15
- Ubuntu 20.04 LTS
- Windows 10 / Visual Studio 2015

Installation
============
Simply copy
[src/rapidcsv.h](https://raw.githubusercontent.com/d99kris/rapidcsv/master/src/rapidcsv.h)
to your project/include directory and include it. 

More Examples
=============

Several of the following examples are also provided in the `examples/`
directory and can be executed directly under Linux and macOS. Example running
ex001.cpp:

```
    ./examples/ex001.cpp
```


Reading a File with Column and Row Headers
------------------------------------------
By default rapidcsv treats the first row as column headers, and the first
column is treated as data. This allows accessing columns using their labels,
but not rows or cells (only using indices). In order to treat the first column
as row headers one needs to use LabelParams and set pRowNameIdx to 0.

### Column and Row Headers
[colrowhdr.csv](examples/colrowhdr.csv) content:
```
    Date,Open,High,Low,Close,Volume,Adj Close
    2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
    2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
    2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
    2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
    2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003
```

[ex002.cpp](examples/ex002.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

      std::vector<float> close = doc.GetRow<float>("2017-02-22");
      std::cout << "Read " << close.size() << " values." << std::endl;

      long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
      std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
    }
```

### Row Headers Only
[rowhdr.csv](examples/rowhdr.csv) content:
```
    2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
    2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
    2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
    2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
    2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003
```

[ex003.cpp](examples/ex003.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/rowhdr.csv", rapidcsv::LabelParams(-1, 0));

      std::vector<std::string> row = doc.GetRow<std::string>("2017-02-22");
      std::cout << "Read " << row.size() << " values." << std::endl;
    }
```

### No Headers
[nohdr.csv](examples/nohdr.csv) content:
```
    64.529999,64.800003,64.139999,64.620003,21705200,64.620003
    64.419998,64.730003,64.190002,64.620003,20235200,64.620003
    64.330002,64.389999,64.050003,64.360001,19259700,64.360001
    64.610001,64.949997,64.449997,64.489998,19384900,64.489998
    64.470001,64.690002,64.300003,64.620003,21234600,64.620003
```

[ex004.cpp](examples/ex004.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/nohdr.csv", rapidcsv::LabelParams(-1, -1));

      std::vector<float> close = doc.GetColumn<float>(5);
      std::cout << "Read " << close.size() << " values." << std::endl;

      long long volume = doc.GetCell<long long>(4, 2);
      std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
    }
```

Reading a File with Custom Separator
------------------------------------
For reading of files with custom separator (i.e. not comma), one need to
specify the SeparatorParams argument. The following example reads a file using
semi-colon as separator.

[semi.csv](examples/semi.csv) content:
```
    Date;Open;High;Low;Close;Volume;Adj Close
    2017-02-24;64.529999;64.800003;64.139999;64.620003;21705200;64.620003
    2017-02-23;64.419998;64.730003;64.190002;64.620003;20235200;64.620003
    2017-02-22;64.330002;64.389999;64.050003;64.360001;19259700;64.360001
    2017-02-21;64.610001;64.949997;64.449997;64.489998;19384900;64.489998
    2017-02-17;64.470001;64.690002;64.300003;64.620003;21234600;64.620003
```

[ex005.cpp](examples/ex005.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/semi.csv", rapidcsv::LabelParams(0, 0),
                             rapidcsv::SeparatorParams(';'));

      std::vector<float> close = doc.GetColumn<float>("Close");
      std::cout << "Read " << close.size() << " values." << std::endl;

      long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
      std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
    }
```

Supported Get/Set Data Types
----------------------------
The internal cell representation in the Document class is using std::string
and when other types are requested, standard conversion routines are used.
All standard conversions are relatively straight-forward, with the
exception of `char` for which rapidcsv interprets the cell's (first) byte
as a character. The following example illustrates the supported data types.

[colrowhdr.csv](examples/colrowhdr.csv) content:
```
    Date,Open,High,Low,Close,Volume,Adj Close
    2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
    2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
    2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
    2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
    2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003
```

[ex006.cpp](examples/ex006.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

      std::cout << doc.GetCell<std::string>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<int>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<long>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<long long>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<unsigned>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<unsigned long>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<unsigned long long>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<float>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<double>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<long double>("Volume", "2017-02-22") << std::endl;
      std::cout << doc.GetCell<char>("Volume", "2017-02-22") << std::endl;
    }

```

Global Custom Data Type Conversion
----------------------------------
One may override conversion routines (or add new ones) by implementing ToVal()
and/or ToStr(). Below is an example overriding int conversion, to instead provide
two decimal fixed-point numbers. Also see 
[tests/test035.cpp](https://github.com/d99kris/rapidcsv/blob/master/tests/test035.cpp)
for a test overriding ToVal() and ToStr().

[ex008.cpp](examples/ex008.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    namespace rapidcsv
    {
      template<>
      void Converter<int>::ToVal(const std::string& pStr, int& pVal) const
      {
        pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
      }
    }

    int main()
    {
      rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

      std::vector<int> close = doc.GetColumn<int>("Close");
      std::cout << "close[0]  = " << close[0] << std::endl;
      std::cout << "close[1]  = " << close[1] << std::endl;
    }
```

Custom Data Type Conversion Per Call
------------------------------------
It is also possible to override conversions on a per-call basis, enabling more
flexibility. This is illustrated in the following example. Additional conversion
override usage can be found in the test 
[tests/test063.cpp](https://github.com/d99kris/rapidcsv/blob/master/tests/test063.cpp)

[ex009.cpp](examples/ex009.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    void ConvFixPoint(const std::string& pStr, int& pVal)
    {
      pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
    }

    struct MyStruct
    {
      int val = 0;
    };

    void ConvMyStruct(const std::string& pStr, MyStruct& pVal)
    {
      pVal.val = static_cast<int>(roundf(100.0f * std::stof(pStr)));
    }

    int main()
    {
      rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

      std::cout << "regular         = " << doc.GetCell<int>("Close", "2017-02-21") << "\n";
      std::cout << "fixpointfunc    = " << doc.GetCell<int>("Close", "2017-02-21", ConvFixPoint) << "\n";

      auto convFixLambda = [](const std::string& pStr, int& pVal) { pVal = static_cast<int>(roundf(100.0f * stof(pStr))); };
      std::cout << "fixpointlambda  = " << doc.GetCell<int>("Close", "2017-02-21", convFixLambda) << "\n";

      std::cout << "mystruct        = " << doc.GetCell<MyStruct>("Close", "2017-02-21", ConvMyStruct).val << "\n";
    }
```

Reading CSV Data from a Stream or String
----------------------------------------
In addition to specifying a filename, rapidcsv supports constructing a Document
from a stream and, indirectly through stringstream, from a string. Here is a
simple example reading CSV data from a string:

[ex007.cpp](examples/ex007.cpp) content:
```cpp
    #include <iostream>
    #include <vector>
    #include "rapidcsv.h"

    int main()
    {
      const std::string& csv =
        "Date,Open,High,Low,Close,Volume,Adj Close\n"
        "2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003\n"
        "2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003\n"
        "2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001\n"
        "2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998\n"
        "2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003\n"
        ;

      std::stringstream sstream(csv);
      rapidcsv::Document doc(sstream, rapidcsv::LabelParams(0, 0));

      std::vector<float> close = doc.GetColumn<float>("Close");
      std::cout << "Read " << close.size() << " values." << std::endl;

      long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
      std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
    }
```

Reading a File with Invalid Numbers (e.g. Empty Cells) as Numeric Data
-----------------------------------------------------------------------
By default rapidcsv throws an exception if one tries to access non-numeric
data as a numeric data type, as it basically propagates the underlying
conversion routines' exceptions to the calling application.

The reason for this is to ensure data correctness. If one wants to be able
to read data with invalid numbers as numeric data types, one can use
ConverterParams to configure the converter to default to a numeric value.
The value is configurable and by default it's
std::numeric_limits<long double>::signaling_NaN() for float types, and 0 for
integer types. Example:

```cpp
    rapidcsv::Document doc("file.csv", rapidcsv::LabelParams(),
                           rapidcsv::SeparatorParams(),
                           rapidcsv::ConverterParams(true));
```

Check if a Column Exists
------------------------
Rapidcsv provides the methods GetColumnNames() and GetRowNames() to retrieve
the column and row names. To check whether a particular column name exists
one can for example do:

```cpp
    rapidcsv::Document doc("file.csv");
    std::vector<std::string> columnNames = doc.GetColumnNames();
    bool columnExists =
      (std::find(columnNames.begin(), columnNames.end(), "A") != columnNames.end());
```

UTF-16 and UTF-8
----------------
Rapidcsv's preferred encoding for non-ASCII text is UTF-8. UTF-16 LE and
UTF-16 BE can be read and written by rapidcsv on systems where codecvt header
is present. Define HAS_CODECVT before including rapidcsv.h in order to enable
the functionality. Rapidcsv unit tests automatically detects the presence of
codecvt and sets HAS_CODECVT as needed, see [CMakeLists.txt](CMakeLists.txt)
for reference. When enabled, the UTF-16 encoding of any loaded file is
automatically detected.

API Documentation
=================
The following classes makes up the Rapidcsv interface:
 - [class rapidcsv::Document](doc/rapidcsv_Document.md)
 - [class rapidcsv::SeparatorParams](doc/rapidcsv_SeparatorParams.md)
 - [class rapidcsv::LabelParams](doc/rapidcsv_LabelParams.md)
 - [class rapidcsv::ConverterParams](doc/rapidcsv_ConverterParams.md)
 - [class rapidcsv::no_converter](doc/rapidcsv_no_converter.md)
 - [class rapidcsv::Converter< T >](doc/rapidcsv_Converter.md)

Technical Details
=================
Rapidcsv uses cmake for its tests. Commands to build and execute the test suite:

    mkdir -p build && cd build && cmake .. && make && ctest -C unit --output-on-failure && ctest -C perf --verbose ; cd -

Rapidcsv uses [doxyman2md](https://github.com/d99kris/doxyman2md) to generate
its API documentation:

    doxyman2md src doc

Rapidcsv uses Uncrustify to ensure consistent code formatting:

    uncrustify -c uncrustify.cfg --no-backup src/rapidcsv.h

Alternatives
============
There are many CSV parsers for C++, for example:
- [CSV Parser](https://github.com/AriaFallah/csv-parser)
- [CSVparser](https://github.com/MyBoon/CSVparser)
- [Fast C++ CSV Parser](https://github.com/ben-strasser/fast-cpp-csv-parser)
- [Vince's CSV Parser](https://github.com/vincentlaucsb/csv-parser)

License
=======
Rapidcsv is distributed under the BSD 3-Clause license. See
[LICENSE](https://github.com/d99kris/rapidcsv/blob/master/LICENSE) file.

Contributions
=============
Bugs, PRs, etc are welcome on the GitHub project page
https://github.com/d99kris/rapidcsv

Keywords
========
c++, c++11, csv parser, comma separated values, single header library.



================================================
FILE: examples/libraries/rapidcsv/appveyor.yml
================================================
# Specify version format
version: "{build}"

# Operating system (build VM template)
os: Visual Studio 2015

# build platform, i.e. Win32 (instead of x86), x64, Any CPU. This setting is optional.
platform: 
  - x64

# specify custom environment variables
environment:
  MSVC_DEFAULT_OPTIONS: ON

# build configuration, i.e. Debug, Release, etc.
configuration:
  - Debug
  - Release

# scripts that are called at very beginning, before repo cloning
init:
  - cmd: cmake --version
  - cmd: msbuild /version

# clone directory
clone_folder: C:\projects\rapidcsv

# scripts to run before build
before_build:
  - cmd: cd C:\projects\rapidcsv
  - cmd: md build
  - cmd: cd build
  - cmd: if "%platform%"=="Win32" set CMAKE_GENERATOR_NAME=Visual Studio 14 2015
  - cmd: if "%platform%"=="x64"   set CMAKE_GENERATOR_NAME=Visual Studio 14 2015 Win64
  - cmd: cmake -G "%CMAKE_GENERATOR_NAME%" -DCMAKE_BUILD_TYPE=%configuration% ..

build:
  project: C:\projects\rapidcsv\build\rapidcsv.sln  # path to Visual Studio solution or project
  parallel: true                                    # enable MSBuild parallel builds
  verbosity: quiet                                  # MSBuild verb level (quiet|minimal|normal|detailed)

test_script:
  - cmd: cd C:\projects\rapidcsv\build
  - cmd: if "%configuration%"=="Debug"    ctest -C Debug   --output-on-failure
  - cmd: if "%configuration%"=="Release"  ctest -C Release --verbose



================================================
FILE: examples/libraries/rapidcsv/doc/README.md
================================================
# API Documentation
 - [class rapidcsv::Document](rapidcsv_Document.md)
 - [class rapidcsv::no_converter](rapidcsv_no_converter.md)
 - [class rapidcsv::Converter< T >](rapidcsv_Converter.md)
 - [class rapidcsv::SeparatorParams](rapidcsv_SeparatorParams.md)
 - [class rapidcsv::LabelParams](rapidcsv_LabelParams.md)
 - [class rapidcsv::ConverterParams](rapidcsv_ConverterParams.md)


================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_Converter.md
================================================
## class rapidcsv::Converter< T >

Class providing conversion to/from numerical datatypes and strings. Only intended for rapidcsv internal usage, but exposed externally to allow specialization for custom datatype conversions.  

---

```c++
template<typename T> Converter (const ConverterParams & pConverterParams)
```
Constructor. 

**Parameters**
- `pConverterParams` specifies how conversion of non-numerical values to numerical datatype shall be handled. 

---

```c++
template<typename T> void ToStr (const T & pVal, std::string & pStr)
```
Converts numerical value to string representation. 

**Parameters**
- `pVal` numerical value 
- `pStr` output string 

---

```c++
template<> void Converter< std::string >::ToStr (const std::string & pVal, std::string & pStr)
```
Specialized implementation handling string to string conversion. 

**Parameters**
- `pVal` string 
- `pStr` string 

---

```c++
template<typename T> void ToVal (const std::string & pStr, T & pVal)
```
Converts string holding a numerical value to numerical datatype representation. 

**Parameters**
- `pVal` numerical value 
- `pStr` output string 

---

```c++
template<> void Converter< std::string >::ToVal (const std::string & pStr, std::string & pVal)
```
Specialized implementation handling string to string conversion. 

**Parameters**
- `pVal` string 
- `pStr` string 

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_ConverterParams.md
================================================
## class rapidcsv::ConverterParams

Datastructure holding parameters controlling how invalid numbers (including empty strings) should be handled.  

---

```c++
ConverterParams (const bool pHasDefaultConverter = false, const long double pDefaultFloat = std::numeric_limits<long double>::signaling_NaN(), const long long pDefaultInteger = 0)
```
Constructor. 

**Parameters**
- `pHasDefaultConverter` specifies if conversion of non-numerical strings shall be converted to a default numerical value, instead of causing an exception to be thrown (default). 
- `pDefaultFloat` floating-point default value to represent invalid numbers. 
- `pDefaultInteger` integer default value to represent invalid numbers. 

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_Document.md
================================================
## class rapidcsv::Document

Class representing a CSV document.  

---

```c++
Document (const std::string & pPath = std::string(), const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams())
```
Constructor. 

**Parameters**
- `pPath` specifies the path of an existing CSV-file to populate the Document data with. 
- `pLabelParams` specifies which row and column should be treated as labels. 
- `pSeparatorParams` specifies which field and row separators should be used. 
- `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 

---

```c++
Document (std::istream & pStream, const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams())
```
Constructor. 

**Parameters**
- `pStream` specifies an input stream to read CSV data from. 
- `pLabelParams` specifies which row and column should be treated as labels. 
- `pSeparatorParams` specifies which field and row separators should be used. 
- `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 

---

```c++
Document (const Document & pDocument)
```
Copy constructor. 

**Parameters**
- `pDocument` specifies the Document instance to copy. 

---

```c++
template<typename T > T GetCell (const size_t pColumnIdx, const size_t pRowIdx)
```
Get cell by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pRowIdx` zero-based row index. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const size_t pColumnIdx, const size_t pRowIdx, ConvFunc< T > pToVal)
```
Get cell by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pRowIdx` zero-based row index. 
- `pToVal` conversion function. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const std::string & pColumnName, const std::string & pRowName)
```
Get cell by name. 

**Parameters**
- `pColumnName` column label name. 
- `pRowName` row label name. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const std::string & pColumnName, const std::string & pRowName, ConvFunc< T > pToVal)
```
Get cell by name. 

**Parameters**
- `pColumnName` column label name. 
- `pRowName` row label name. 
- `pToVal` conversion function. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const std::string & pColumnName, const size_t pRowIdx)
```
Get cell by column name and row index. 

**Parameters**
- `pColumnName` column label name. 
- `pRowIdx` zero-based row index. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const std::string & pColumnName, const size_t pRowIdx, ConvFunc< T > pToVal)
```
Get cell by column name and row index. 

**Parameters**
- `pColumnName` column label name. 
- `pRowIdx` zero-based row index. 
- `pToVal` conversion function. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const size_t pColumnIdx, const std::string & pRowName)
```
Get cell by column index and row name. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pRowName` row label name. 

**Returns:**
- cell data. 

---

```c++
template<typename T > T GetCell (const size_t pColumnIdx, const std::string & pRowName, ConvFunc< T > pToVal)
```
Get cell by column index and row name. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pRowName` row label name. 
- `pToVal` conversion function. 

**Returns:**
- cell data. 

---

```c++
template<typename T > std::vector<T> GetColumn (const size_t pColumnIdx)
```
Get column by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 

**Returns:**
- vector of column data. 

---

```c++
template<typename T > std::vector<T> GetColumn (const size_t pColumnIdx, ConvFunc< T > pToVal)
```
Get column by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pToVal` conversion function. 

**Returns:**
- vector of column data. 

---

```c++
template<typename T > std::vector<T> GetColumn (const std::string & pColumnName)
```
Get column by name. 

**Parameters**
- `pColumnName` column label name. 

**Returns:**
- vector of column data. 

---

```c++
template<typename T > std::vector<T> GetColumn (const std::string & pColumnName, ConvFunc< T > pToVal)
```
Get column by name. 

**Parameters**
- `pColumnName` column label name. 
- `pToVal` conversion function. 

**Returns:**
- vector of column data. 

---

```c++
size_t GetColumnCount ()
```
Get number of data columns (excluding label columns). 

**Returns:**
- column count. 

---

```c++
std::string GetColumnName (const ssize_t pColumnIdx)
```
Get column name. 

**Parameters**
- `pColumnIdx` zero-based column index. 

**Returns:**
- column name. 

---

```c++
std::vector<std::string> GetColumnNames ()
```
Get column names. 

**Returns:**
- vector of column names. 

---

```c++
template<typename T > std::vector<T> GetRow (const size_t pRowIdx)
```
Get row by index. 

**Parameters**
- `pRowIdx` zero-based row index. 

**Returns:**
- vector of row data. 

---

```c++
template<typename T > std::vector<T> GetRow (const size_t pRowIdx, ConvFunc< T > pToVal)
```
Get row by index. 

**Parameters**
- `pRowIdx` zero-based row index. 
- `pToVal` conversion function. 

**Returns:**
- vector of row data. 

---

```c++
template<typename T > std::vector<T> GetRow (const std::string & pRowName)
```
Get row by name. 

**Parameters**
- `pRowName` row label name. 

**Returns:**
- vector of row data. 

---

```c++
template<typename T > std::vector<T> GetRow (const std::string & pRowName, ConvFunc< T > pToVal)
```
Get row by name. 

**Parameters**
- `pRowName` row label name. 
- `pToVal` conversion function. 

**Returns:**
- vector of row data. 

---

```c++
size_t GetRowCount ()
```
Get number of data rows (excluding label rows). 

**Returns:**
- row count. 

---

```c++
std::string GetRowName (const ssize_t pRowIdx)
```
Get row name. 

**Parameters**
- `pRowIdx` zero-based column index. 

**Returns:**
- row name. 

---

```c++
std::vector<std::string> GetRowNames ()
```
Get row names. 

**Returns:**
- vector of row names. 

---

```c++
void Load (const std::string & pPath)
```
Read Document data from file. 

**Parameters**
- `pPath` specifies the path of an existing CSV-file to populate the Document data with. 

---

```c++
void RemoveColumn (const size_t pColumnIdx)
```
Remove column by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 

---

```c++
void RemoveColumn (const std::string & pColumnName)
```
Remove column by name. 

**Parameters**
- `pColumnName` column label name. 

---

```c++
void RemoveRow (const size_t pRowIdx)
```
Remove row by index. 

**Parameters**
- `pRowIdx` zero-based row index. 

---

```c++
void RemoveRow (const std::string & pRowName)
```
Remove row by name. 

**Parameters**
- `pRowName` row label name. 

---

```c++
void Save (const std::string & pPath = std::string())
```
Write Document data to file. 

**Parameters**
- `pPath` optionally specifies the path where the CSV-file will be created (if not specified, the original path provided when creating or loading the Document data will be used). 

---

```c++
void Save (std::ostream & pStream)
```
Write Document data to stream. 

**Parameters**
- `pStream` specifies an output stream to write the data to. 

---

```c++
template<typename T > void SetCell (const size_t pColumnIdx, const size_t pRowIdx, const T & pCell)
```
Set cell by index. 

**Parameters**
- `pRowIdx` zero-based row index. 
- `pColumnIdx` zero-based column index. 
- `pCell` cell data. 

---

```c++
template<typename T > void SetCell (const std::string & pColumnName, const std::string & pRowName, const T & pCell)
```
Set cell by name. 

**Parameters**
- `pColumnName` column label name. 
- `pRowName` row label name. 
- `pCell` cell data. 

---

```c++
template<typename T > void SetColumn (const size_t pColumnIdx, const std::vector< T > & pColumn)
```
Set column by index. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pColumn` vector of column data. 

---

```c++
template<typename T > void SetColumn (const std::string & pColumnName, const std::vector< T > & pColumn)
```
Set column by name. 

**Parameters**
- `pColumnName` column label name. 
- `pColumn` vector of column data. 

---

```c++
void SetColumnName (size_t pColumnIdx, const std::string & pColumnName)
```
Set column name. 

**Parameters**
- `pColumnIdx` zero-based column index. 
- `pColumnName` column name. 

---

```c++
template<typename T > void SetRow (const size_t pRowIdx, const std::vector< T > & pRow)
```
Set row by index. 

**Parameters**
- `pRowIdx` zero-based row index. 
- `pRow` vector of row data. 

---

```c++
template<typename T > void SetRow (const std::string & pRowName, const std::vector< T > & pRow)
```
Set row by name. 

**Parameters**
- `pRowName` row label name. 
- `pRow` vector of row data. 

---

```c++
void SetRowName (size_t pRowIdx, const std::string & pRowName)
```
Set row name. 

**Parameters**
- `pRowIdx` zero-based row index. 
- `pRowName` row name. 

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_LabelParams.md
================================================
## class rapidcsv::LabelParams

Datastructure holding parameters controlling which row and column should be treated as labels.  

---

```c++
LabelParams (const int pColumnNameIdx = 0, const int pRowNameIdx = \-1)
```
Constructor. 

**Parameters**
- `pColumnNameIdx` specifies the zero-based row index of the column labels, setting it to -1 prevents column lookup by label name, and gives access to all rows as document data. Default: 0 
- `pRowNameIdx` specifies the zero-based column index of the row labels, setting it to -1 prevents row lookup by label name, and gives access to all columns as document data. Default: -1 

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_SeparatorParams.md
================================================
## class rapidcsv::SeparatorParams

Datastructure holding parameters controlling how the CSV data fields are separated.  

---

```c++
SeparatorParams (const char pSeparator = ',', const bool pTrim = false, const bool pHasCR = sPlatformHasCR, const bool pQuotedLinebreaks = false)
```
Constructor. 

**Parameters**
- `pSeparator` specifies the column separator (default ','). 
- `pTrim` specifies whether to trim leading and trailing spaces from cells read. 
- `pHasCR` specifies whether a new document (i.e. not an existing document read) should use CR/LF instead of only LF (default is to use standard behavior of underlying platforms - CR/LF for Win, and LF for others). 
- `pQuotedLinebreaks` specifies whether to allow line breaks in quoted text. 

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/doc/rapidcsv_no_converter.md
================================================
## class rapidcsv::no_converter

Exception thrown when attempting to access Document data in a datatype which is not supported by the Converter class.  

---

###### API documentation generated using [Doxyman2md](https://github.com/d99kris/doxyman2md)



================================================
FILE: examples/libraries/rapidcsv/examples/colhdr.csv
================================================
Open,High,Low,Close,Volume,Adj Close
64.529999,64.800003,64.139999,64.620003,21705200,64.620003
64.419998,64.730003,64.190002,64.620003,20235200,64.620003
64.330002,64.389999,64.050003,64.360001,19259700,64.360001
64.610001,64.949997,64.449997,64.489998,19384900,64.489998
64.470001,64.690002,64.300003,64.620003,21234600,64.620003


================================================
FILE: examples/libraries/rapidcsv/examples/colrowhdr.csv
================================================
Date,Open,High,Low,Close,Volume,Adj Close
2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003


================================================
FILE: examples/libraries/rapidcsv/examples/ex001.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/colhdr.csv");

  std::vector<float> col = doc.GetColumn<float>("Close");
  std::cout << "Read " << col.size() << " values." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex002.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

  std::vector<float> close = doc.GetRow<float>("2017-02-22");
  std::cout << "Read " << close.size() << " values." << std::endl;

  long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
  std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex003.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/rowhdr.csv", rapidcsv::LabelParams(-1, 0));

  std::vector<std::string> row = doc.GetRow<std::string>("2017-02-22");
  std::cout << "Read " << row.size() << " values." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex004.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/nohdr.csv", rapidcsv::LabelParams(-1, -1));

  std::vector<float> close = doc.GetColumn<float>(5);
  std::cout << "Read " << close.size() << " values." << std::endl;

  long long volume = doc.GetCell<long long>(4, 2);
  std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex005.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/semi.csv", rapidcsv::LabelParams(0, 0),
                         rapidcsv::SeparatorParams(';'));

  std::vector<float> close = doc.GetColumn<float>("Close");
  std::cout << "Read " << close.size() << " values." << std::endl;

  long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
  std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex006.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

  std::cout << doc.GetCell<std::string>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<int>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<long>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<long long>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<unsigned>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<unsigned long>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<unsigned long long>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<float>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<double>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<long double>("Volume", "2017-02-22") << std::endl;
  std::cout << doc.GetCell<char>("Volume", "2017-02-22") << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex007.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

int main()
{
  const std::string& csv =
    "Date,Open,High,Low,Close,Volume,Adj Close\n"
    "2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003\n"
    "2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003\n"
    "2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001\n"
    "2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998\n"
    "2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003\n"
  ;

  std::stringstream sstream(csv);
  rapidcsv::Document doc(sstream, rapidcsv::LabelParams(0, 0));

  std::vector<float> close = doc.GetColumn<float>("Close");
  std::cout << "Read " << close.size() << " values." << std::endl;

  long long volume = doc.GetCell<long long>("Volume", "2017-02-22");
  std::cout << "Volume " << volume << " on 2017-02-22." << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex008.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

namespace rapidcsv
{
  template<>
  void Converter<int>::ToVal(const std::string& pStr, int& pVal) const
  {
    pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
  }
}

int main()
{
  rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

  std::vector<int> close = doc.GetColumn<int>("Close");
  std::cout << "close[0]  = " << close[0] << std::endl;
  std::cout << "close[1]  = " << close[1] << std::endl;
}


================================================
FILE: examples/libraries/rapidcsv/examples/ex009.cpp
================================================
#if 0
TMP=$(mktemp -d)
c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?}
rm -rf ${TMP}
exit ${RV}
#endif

#include <iostream>
#include <vector>
#include "rapidcsv.h"

void ConvFixPoint(const std::string& pStr, int& pVal)
{
  pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
}

struct MyStruct
{
  int val = 0;
};

void ConvMyStruct(const std::string& pStr, MyStruct& pVal)
{
  pVal.val = static_cast<int>(roundf(100.0f * std::stof(pStr)));
}

int main()
{
  rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0));

  std::cout << "regular         = " << doc.GetCell<int>("Close", "2017-02-21") << "\n";
  std::cout << "fixpointfunc    = " << doc.GetCell<int>("Close", "2017-02-21", ConvFixPoint) << "\n";

  auto convFixLambda = [](const std::string& pStr, int& pVal) { pVal = static_cast<int>(roundf(100.0f * stof(pStr))); };
  std::cout << "fixpointlambda  = " << doc.GetCell<int>("Close", "2017-02-21", convFixLambda) << "\n";

  std::cout << "mystruct        = " << doc.GetCell<MyStruct>("Close", "2017-02-21", ConvMyStruct).val << "\n";
}


================================================
FILE: examples/libraries/rapidcsv/examples/nohdr.csv
================================================
64.529999,64.800003,64.139999,64.620003,21705200,64.620003
64.419998,64.730003,64.190002,64.620003,20235200,64.620003
64.330002,64.389999,64.050003,64.360001,19259700,64.360001
64.610001,64.949997,64.449997,64.489998,19384900,64.489998
64.470001,64.690002,64.300003,64.620003,21234600,64.620003


================================================
FILE: examples/libraries/rapidcsv/examples/rowhdr.csv
================================================
2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003


================================================
FILE: examples/libraries/rapidcsv/examples/semi.csv
================================================
Date;Open;High;Low;Close;Volume;Adj Close
2017-02-24;64.529999;64.800003;64.139999;64.620003;21705200;64.620003
2017-02-23;64.419998;64.730003;64.190002;64.620003;20235200;64.620003
2017-02-22;64.330002;64.389999;64.050003;64.360001;19259700;64.360001
2017-02-21;64.610001;64.949997;64.449997;64.489998;19384900;64.489998
2017-02-17;64.470001;64.690002;64.300003;64.620003;21234600;64.620003


================================================
FILE: examples/libraries/rapidcsv/run.sh
================================================
#!/usr/bin/env bash

BUILD="0"
TESTS="0"
EXAMPLES="0"
DOC="0"
SRC="0"
ALL="0"
case "${1%/}" in
  build)
    BUILD="1"
    ;;

  tests)
    TESTS="1"
    ;;

  examples)
    EXAMPLES="1"
    ;;

  doc)
    DOC="1"
    ;;

  src)
    SRC="1"
    ;;

  all)
    BUILD="1"
    TESTS="1"
    EXAMPLES="1"
    DOC="1"
    SRC="1"
    TEST="1"
    ;;

  *)
    echo "usage: run.sh <build|test|examples|gendoc|format|all>"
    echo "  build     - build tests and examples"
    echo "  tests     - perform build and run tests"
    echo "  examples  - run examples"
    echo "  doc       - generate/update API documentation in doc/"
    echo "  src       - reformat source code files using uncrustify"
    echo "  all       - performs all actions above"
    exit 1
    ;;
esac

if [[ "${BUILD}" == "1" ]] || [[ "${TESTS}" == "1" ]]; then
    mkdir -p build && cd build && cmake .. && make
    if [[ "${?}" != "0" ]]; then
        echo "build failed, exiting."
        exit 1
    fi
    cd - > /dev/null
fi

if [[ "${TESTS}" == "1" ]]; then
    cd build && ctest -C unit --output-on-failure && ctest -C perf --verbose
    if [[ "${?}" != "0" ]]; then
        echo "tests failed, exiting."
        exit 1
    fi
    cd - > /dev/null
fi

if [[ "${EXAMPLES}" == "1" ]]; then
    for EXAMPLE in examples/*.cpp; do
      ./${EXAMPLE}
      if [[ "${?}" != "0" ]]; then
          echo "${EXAMPLE} failed, exiting."
          exit 1
      fi
    done
fi

if [[ "${DOC}" == "1" ]]; then
    doxyman2md src doc
    if [[ "${?}" != "0" ]]; then
        echo "doc failed, exiting."
        exit 1
    fi
fi

if [[ "${SRC}" == "1" ]]; then
    TMPDIR=$(mktemp -d)
    for SRC in examples/*.cpp; do
      DST="${TMPDIR}/$(basename ${SRC})"
      printf "\n\n\n\n\n\n"  > ${DST}         # add 6 blank lines
      tail -n +8 ${SRC}     >> ${DST}         # skip header (first 7 lines) 
      head -7 ${SRC}         > ${DST}.header  # store header separately (first 7 lines)
    done
    
    uncrustify -c uncrustify.cfg --replace --no-backup src/rapidcsv.h tests/*.cpp tests/*.h ${TMPDIR}/*.cpp
    if [[ "${?}" != "0" ]]; then
        rm -rf ${TMPDIR}
        echo "src failed, exiting."
        exit 1
    fi

    for DST in examples/*.cpp; do
      SRC="${TMPDIR}/$(basename ${DST})"
      cat ${SRC}.header      > ${DST}.tmp
      cat ${SRC}            >> ${DST}.tmp

      cmp --silent ${DST} ${DST}.tmp
      if [[ "${?}" != "0" ]]; then
          cat ${DST}.tmp > ${DST}
      fi
      rm ${DST}.tmp
    done

    rm -rf ${TMPDIR}
fi

exit 0


================================================
FILE: examples/libraries/rapidcsv/src/rapidcsv.h
================================================
/*
 * rapidcsv.h
 *
 * URL:      https://github.com/d99kris/rapidcsv
 * Version:  7.00
 *
 * Copyright (C) 2017-2020 Kristofer Berggren
 * All rights reserved.
 *
 * rapidcsv is distributed under the BSD 3-Clause license, see LICENSE for details.
 *
 */

#pragma once

#include <algorithm>
#include <cassert>
#include <cmath>
#ifdef HAS_CODECVT
#include <codecvt>
#endif
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>

#if defined(_MSC_VER)
#include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif

namespace rapidcsv
{
#if defined(_MSC_VER)
  static const bool sPlatformHasCR = true;
#else
  static const bool sPlatformHasCR = false;
#endif

  /**
   * @brief     Datastructure holding parameters controlling how invalid numbers (including
   *            empty strings) should be handled.
   */
  struct ConverterParams
  {
    /**
     * @brief   Constructor
     * @param   pHasDefaultConverter  specifies if conversion of non-numerical strings shall be
     *                                converted to a default numerical value, instead of causing
     *                                an exception to be thrown (default).
     * @param   pDefaultFloat         floating-point default value to represent invalid numbers.
     * @param   pDefaultInteger       integer default value to represent invalid numbers.
     */
    explicit ConverterParams(const bool pHasDefaultConverter = false,
                             const long double pDefaultFloat = std::numeric_limits<long double>::signaling_NaN(),
                             const long long pDefaultInteger = 0)
      : mHasDefaultConverter(pHasDefaultConverter)
      , mDefaultFloat(pDefaultFloat)
      , mDefaultInteger(pDefaultInteger)
    {
    }

    /**
     * @brief   specifies if conversion of non-numerical strings shall be converted to a default
     *          numerical value, instead of causing an exception to be thrown (default).
     */
    bool mHasDefaultConverter;

    /**
     * @brief   floating-point default value to represent invalid numbers.
     */
    long double mDefaultFloat;

    /**
     * @brief   integer default value to represent invalid numbers.
     */
    long long mDefaultInteger;
  };

  /**
   * @brief     Exception thrown when attempting to access Document data in a datatype which
   *            is not supported by the Converter class.
   */
  class no_converter : public std::exception
  {
    /**
     * @brief   Provides details about the exception
     * @returns an explanatory string
     */
    virtual const char* what() const throw()
    {
      return "unsupported conversion datatype";
    }
  };

  /**
   * @brief     Class providing conversion to/from numerical datatypes and strings. Only
   *            intended for rapidcsv internal usage, but exposed externally to allow
   *            specialization for custom datatype conversions.
   */
  template<typename T>
  class Converter
  {
  public:
    /**
     * @brief   Constructor
     * @param   pConverterParams      specifies how conversion of non-numerical values to
     *                                numerical datatype shall be handled.
     */
    Converter(const ConverterParams& pConverterParams)
      : mConverterParams(pConverterParams)
    {
    }

    /**
     * @brief   Converts numerical value to string representation.
     * @param   pVal                  numerical value
     * @param   pStr                  output string
     */
    void ToStr(const T& pVal, std::string& pStr) const
    {
      if (typeid(T) == typeid(int) ||
          typeid(T) == typeid(long) ||
          typeid(T) == typeid(long long) ||
          typeid(T) == typeid(unsigned) ||
          typeid(T) == typeid(unsigned long) ||
          typeid(T) == typeid(unsigned long long) ||
          typeid(T) == typeid(float) ||
          typeid(T) == typeid(double) ||
          typeid(T) == typeid(long double) ||
          typeid(T) == typeid(char))
      {
        std::ostringstream out;
        out << pVal;
        pStr = out.str();
      }
      else
      {
        throw no_converter();
      }
    }

    /**
     * @brief   Converts string holding a numerical value to numerical datatype representation.
     * @param   pVal                  numerical value
     * @param   pStr                  output string
     */
    void ToVal(const std::string& pStr, T& pVal) const
    {
      try
      {
        if (typeid(T) == typeid(int))
        {
          pVal = static_cast<T>(std::stoi(pStr));
          return;
        }
        else if (typeid(T) == typeid(long))
        {
          pVal = static_cast<T>(std::stol(pStr));
          return;
        }
        else if (typeid(T) == typeid(long long))
        {
          pVal = static_cast<T>(std::stoll(pStr));
          return;
        }
        else if (typeid(T) == typeid(unsigned))
        {
          pVal = static_cast<T>(std::stoul(pStr));
          return;
        }
        else if (typeid(T) == typeid(unsigned long))
        {
          pVal = static_cast<T>(std::stoul(pStr));
          return;
        }
        else if (typeid(T) == typeid(unsigned long long))
        {
          pVal = static_cast<T>(std::stoull(pStr));
          return;
        }
      }
      catch (...)
      {
        if (!mConverterParams.mHasDefaultConverter)
        {
          throw;
        }
        else
        {
          pVal = static_cast<T>(mConverterParams.mDefaultInteger);
          return;
        }
      }

      try
      {
        if (typeid(T) == typeid(float))
        {
          pVal = static_cast<T>(std::stof(pStr));
          return;
        }
        else if (typeid(T) == typeid(double))
        {
          pVal = static_cast<T>(std::stod(pStr));
          return;
        }
        else if (typeid(T) == typeid(long double))
        {
          pVal = static_cast<T>(std::stold(pStr));
          return;
        }
      }
      catch (...)
      {
        if (!mConverterParams.mHasDefaultConverter)
        {
          throw;
        }
        else
        {
          pVal = static_cast<T>(mConverterParams.mDefaultFloat);
          return;
        }
      }

      if (typeid(T) == typeid(char))
      {
        pVal = static_cast<T>(pStr[0]);
        return;
      }
      else
      {
        throw no_converter();
      }
    }

  private:
    const ConverterParams& mConverterParams;
  };

  /**
   * @brief     Specialized implementation handling string to string conversion.
   * @param     pVal                  string
   * @param     pStr                  string
   */
  template<>
  inline void Converter<std::string>::ToStr(const std::string& pVal, std::string& pStr) const
  {
    pStr = pVal;
  }

  /**
   * @brief     Specialized implementation handling string to string conversion.
   * @param     pVal                  string
   * @param     pStr                  string
   */
  template<>
  inline void Converter<std::string>::ToVal(const std::string& pStr, std::string& pVal) const
  {
    pVal = pStr;
  }

  template<typename T>
  using ConvFunc = std::function<void (const std::string & pStr, T & pVal)>;

  /**
   * @brief     Datastructure holding parameters controlling which row and column should be
   *            treated as labels.
   */
  struct LabelParams
  {
    /**
     * @brief   Constructor
     * @param   pColumnNameIdx        specifies the zero-based row index of the column labels, setting
     *                                it to -1 prevents column lookup by label name, and gives access
     *                                to all rows as document data. Default: 0
     * @param   pRowNameIdx           specifies the zero-based column index of the row labels, setting
     *                                it to -1 prevents row lookup by label name, and gives access
     *                                to all columns as document data. Default: -1
     */
    explicit LabelParams(const int pColumnNameIdx = 0, const int pRowNameIdx = -1)
      : mColumnNameIdx(pColumnNameIdx)
      , mRowNameIdx(pRowNameIdx)
    {
    }

    /**
     * @brief   specifies the zero-based row index of the column labels.
     */
    int mColumnNameIdx;

    /**
     * @brief   specifies the zero-based column index of the row labels.
     */
    int mRowNameIdx;
  };

  /**
   * @brief     Datastructure holding parameters controlling how the CSV data fields are separated.
   */
  struct SeparatorParams
  {
    /**
     * @brief   Constructor
     * @param   pSeparator            specifies the column separator (default ',').
     * @param   pTrim                 specifies whether to trim leading and trailing spaces from
     *                                cells read.
     * @param   pHasCR                specifies whether a new document (i.e. not an existing document read)
     *                                should use CR/LF instead of only LF (default is to use standard
     *                                behavior of underlying platforms - CR/LF for Win, and LF for others).
     * @param   pQuotedLinebreaks     specifies whether to allow line breaks in quoted text.
     */
    explicit SeparatorParams(const char pSeparator = ',', const bool pTrim = false,
                             const bool pHasCR = sPlatformHasCR, const bool pQuotedLinebreaks = false)
      : mSeparator(pSeparator)
      , mTrim(pTrim)
      , mHasCR(pHasCR)
      , mQuotedLinebreaks(pQuotedLinebreaks)
    {
    }

    /**
     * @brief   specifies the column separator.
     */
    char mSeparator;

    /**
     * @brief   specifies whether to trim leading and trailing spaces from cells read.
     */
    bool mTrim;

    /**
     * @brief   specifies whether new documents should use CR/LF instead of LF.
     */
    bool mHasCR;

    /**
     * @brief   specifies whether to allow line breaks in quoted text.
     */
    bool mQuotedLinebreaks;
  };

  /**
   * @brief     Class representing a CSV document.
   */
  class Document
  {
  public:
    /**
     * @brief   Constructor
     * @param   pPath                 specifies the path of an existing CSV-file to populate the Document
     *                                data with.
     * @param   pLabelParams          specifies which row and column should be treated as labels.
     * @param   pSeparatorParams      specifies which field and row separators should be used.
     * @param   pConverterParams      specifies how invalid numbers (including empty strings) should be
     *                                handled.
     */
    explicit Document(const std::string& pPath = std::string(),
                      const LabelParams& pLabelParams = LabelParams(),
                      const SeparatorParams& pSeparatorParams = SeparatorParams(),
                      const ConverterParams& pConverterParams = ConverterParams())
      : mPath(pPath)
      , mLabelParams(pLabelParams)
      , mSeparatorParams(pSeparatorParams)
      , mConverterParams(pConverterParams)
    {
      if (!mPath.empty())
      {
        ReadCsv();
      }
    }

    /**
     * @brief   Constructor
     * @param   pStream               specifies an input stream to read CSV data from.
     * @param   pLabelParams          specifies which row and column should be treated as labels.
     * @param   pSeparatorParams      specifies which field and row separators should be used.
     * @param   pConverterParams      specifies how invalid numbers (including empty strings) should be
     *                                handled.
     */
    explicit Document(std::istream& pStream,
                      const LabelParams& pLabelParams = LabelParams(),
                      const SeparatorParams& pSeparatorParams = SeparatorParams(),
                      const ConverterParams& pConverterParams = ConverterParams())
      : mPath()
      , mLabelParams(pLabelParams)
      , mSeparatorParams(pSeparatorParams)
      , mConverterParams(pConverterParams)
    {
      ReadCsv(pStream);
    }


    /**
     * @brief   Copy constructor
     * @param   pDocument             specifies the Document instance to copy.
     */
    explicit Document(const Document& pDocument)
      : mPath(pDocument.mPath)
      , mLabelParams(pDocument.mLabelParams)
      , mSeparatorParams(pDocument.mSeparatorParams)
      , mConverterParams(pDocument.mConverterParams)
      , mData(pDocument.mData)
      , mColumnNames(pDocument.mColumnNames)
      , mRowNames(pDocument.mRowNames)
    {
    }

    /**
     * @brief   Read Document data from file.
     * @param   pPath                 specifies the path of an existing CSV-file to populate the Document
     *                                data with.
     */
    void Load(const std::string& pPath)
    {
      mPath = pPath;
      ReadCsv();
    }

    /**
     * @brief   Write Document data to file.
     * @param   pPath                 optionally specifies the path where the CSV-file will be created
     *                                (if not specified, the original path provided when creating or
     *                                loading the Document data will be used).
     */
    void Save(const std::string& pPath = std::string())
    {
      if (!pPath.empty())
      {
        mPath = pPath;
      }
      WriteCsv();
    }

    /**
     * @brief   Write Document data to stream.
     * @param   pStream               specifies an output stream to write the data to.
     */
    void Save(std::ostream& pStream)
    {
      WriteCsv(pStream);
    }

    /**
     * @brief   Get column by index.
     * @param   pColumnIdx            zero-based column index.
     * @returns vector of column data.
     */
    template<typename T>
    std::vector<T> GetColumn(const size_t pColumnIdx) const
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      std::vector<T> column;
      Converter<T> converter(mConverterParams);
      for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
      {
        if (std::distance(mData.begin(), itRow) > mLabelParams.mColumnNameIdx)
        {
          T val;
          converter.ToVal(itRow->at(columnIdx), val);
          column.push_back(val);
        }
      }
      return column;
    }

    /**
     * @brief   Get column by index.
     * @param   pColumnIdx            zero-based column index.
     * @param   pToVal                conversion function.
     * @returns vector of column data.
     */
    template<typename T>
    std::vector<T> GetColumn(const size_t pColumnIdx, ConvFunc<T> pToVal) const
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      std::vector<T> column;
      for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
      {
        if (std::distance(mData.begin(), itRow) > mLabelParams.mColumnNameIdx)
        {
          T val;
          pToVal(itRow->at(columnIdx), val);
          column.push_back(val);
        }
      }
      return column;
    }

    /**
     * @brief   Get column by name.
     * @param   pColumnName           column label name.
     * @returns vector of column data.
     */
    template<typename T>
    std::vector<T> GetColumn(const std::string& pColumnName) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }
      return GetColumn<T>(columnIdx);
    }

    /**
     * @brief   Get column by name.
     * @param   pColumnName           column label name.
     * @param   pToVal                conversion function.
     * @returns vector of column data.
     */
    template<typename T>
    std::vector<T> GetColumn(const std::string& pColumnName, ConvFunc<T> pToVal) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }
      return GetColumn<T>(columnIdx, pToVal);
    }

    /**
     * @brief   Set column by index.
     * @param   pColumnIdx            zero-based column index.
     * @param   pColumn               vector of column data.
     */
    template<typename T>
    void SetColumn(const size_t pColumnIdx, const std::vector<T>& pColumn)
    {
      const size_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);

      while (pColumn.size() + (mLabelParams.mColumnNameIdx + 1) > GetDataRowCount())
      {
        std::vector<std::string> row;
        row.resize(GetDataColumnCount());
        mData.push_back(row);
      }

      if ((columnIdx + 1) > GetDataColumnCount())
      {
        for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
        {
          itRow->resize(columnIdx + 1 + (mLabelParams.mRowNameIdx + 1));
        }
      }

      Converter<T> converter(mConverterParams);
      for (auto itRow = pColumn.begin(); itRow != pColumn.end(); ++itRow)
      {
        std::string str;
        converter.ToStr(*itRow, str);
        mData.at(std::distance(pColumn.begin(), itRow) + (mLabelParams.mColumnNameIdx + 1)).at(columnIdx) = str;
      }
    }

    /**
     * @brief   Set column by name.
     * @param   pColumnName           column label name.
     * @param   pColumn               vector of column data.
     */
    template<typename T>
    void SetColumn(const std::string& pColumnName, const std::vector<T>& pColumn)
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }
      SetColumn<T>(columnIdx, pColumn);
    }

    /**
     * @brief   Remove column by index.
     * @param   pColumnIdx            zero-based column index.
     */
    void RemoveColumn(const size_t pColumnIdx)
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
      {
        itRow->erase(itRow->begin() + columnIdx);
      }
    }

    /**
     * @brief   Remove column by name.
     * @param   pColumnName           column label name.
     */
    void RemoveColumn(const std::string& pColumnName)
    {
      ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      RemoveColumn(columnIdx);
    }

    /**
     * @brief   Get number of data columns (excluding label columns).
     * @returns column count.
     */
    size_t GetColumnCount() const
    {
      const ssize_t count = static_cast<ssize_t>((mData.size() > 0) ? mData.at(0).size() : 0) -
        (mLabelParams.mRowNameIdx + 1);
      return (count >= 0) ? count : 0;
    }

    /**
     * @brief   Get row by index.
     * @param   pRowIdx               zero-based row index.
     * @returns vector of row data.
     */
    template<typename T>
    std::vector<T> GetRow(const size_t pRowIdx) const
    {
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);
      std::vector<T> row;
      Converter<T> converter(mConverterParams);
      for (auto itCol = mData.at(rowIdx).begin(); itCol != mData.at(rowIdx).end(); ++itCol)
      {
        if (std::distance(mData.at(rowIdx).begin(), itCol) > mLabelParams.mRowNameIdx)
        {
          T val;
          converter.ToVal(*itCol, val);
          row.push_back(val);
        }
      }
      return row;
    }

    /**
     * @brief   Get row by index.
     * @param   pRowIdx               zero-based row index.
     * @param   pToVal                conversion function.
     * @returns vector of row data.
     */
    template<typename T>
    std::vector<T> GetRow(const size_t pRowIdx, ConvFunc<T> pToVal) const
    {
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);
      std::vector<T> row;
      Converter<T> converter(mConverterParams);
      for (auto itCol = mData.at(rowIdx).begin(); itCol != mData.at(rowIdx).end(); ++itCol)
      {
        if (std::distance(mData.at(rowIdx).begin(), itCol) > mLabelParams.mRowNameIdx)
        {
          T val;
          pToVal(*itCol, val);
          row.push_back(val);
        }
      }
      return row;
    }

    /**
     * @brief   Get row by name.
     * @param   pRowName              row label name.
     * @returns vector of row data.
     */
    template<typename T>
    std::vector<T> GetRow(const std::string& pRowName) const
    {
      ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }
      return GetRow<T>(rowIdx);
    }

    /**
     * @brief   Get row by name.
     * @param   pRowName              row label name.
     * @param   pToVal                conversion function.
     * @returns vector of row data.
     */
    template<typename T>
    std::vector<T> GetRow(const std::string& pRowName, ConvFunc<T> pToVal) const
    {
      ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }
      return GetRow<T>(rowIdx, pToVal);
    }

    /**
     * @brief   Set row by index.
     * @param   pRowIdx               zero-based row index.
     * @param   pRow                  vector of row data.
     */
    template<typename T>
    void SetRow(const size_t pRowIdx, const std::vector<T>& pRow)
    {
      const size_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);

      while ((rowIdx + 1) > GetDataRowCount())
      {
        std::vector<std::string> row;
        row.resize(GetDataColumnCount());
        mData.push_back(row);
      }

      if (pRow.size() > GetDataColumnCount())
      {
        for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
        {
          itRow->resize(pRow.size() + (mLabelParams.mRowNameIdx + 1));
        }
      }

      Converter<T> converter(mConverterParams);
      for (auto itCol = pRow.begin(); itCol != pRow.end(); ++itCol)
      {
        std::string str;
        converter.ToStr(*itCol, str);
        mData.at(rowIdx).at(std::distance(pRow.begin(), itCol) + (mLabelParams.mRowNameIdx + 1)) = str;
      }
    }

    /**
     * @brief   Set row by name.
     * @param   pRowName              row label name.
     * @param   pRow                  vector of row data.
     */
    template<typename T>
    void SetRow(const std::string& pRowName, const std::vector<T>& pRow)
    {
      ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }
      return SetRow<T>(rowIdx, pRow);
    }

    /**
     * @brief   Remove row by index.
     * @param   pRowIdx               zero-based row index.
     */
    void RemoveRow(const size_t pRowIdx)
    {
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);
      mData.erase(mData.begin() + rowIdx);
    }

    /**
     * @brief   Remove row by name.
     * @param   pRowName              row label name.
     */
    void RemoveRow(const std::string& pRowName)
    {
      ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      RemoveRow(rowIdx);
    }

    /**
     * @brief   Get number of data rows (excluding label rows).
     * @returns row count.
     */
    size_t GetRowCount() const
    {
      const ssize_t count = static_cast<ssize_t>(mData.size()) - (mLabelParams.mColumnNameIdx + 1);
      return (count >= 0) ? count : 0;
    }

    /**
     * @brief   Get cell by index.
     * @param   pColumnIdx            zero-based column index.
     * @param   pRowIdx               zero-based row index.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const size_t pColumnIdx, const size_t pRowIdx) const
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);

      T val;
      Converter<T> converter(mConverterParams);
      converter.ToVal(mData.at(rowIdx).at(columnIdx), val);
      return val;
    }

    /**
     * @brief   Get cell by index.
     * @param   pColumnIdx            zero-based column index.
     * @param   pRowIdx               zero-based row index.
     * @param   pToVal                conversion function.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const size_t pColumnIdx, const size_t pRowIdx, ConvFunc<T> pToVal) const
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);

      T val;
      pToVal(mData.at(rowIdx).at(columnIdx), val);
      return val;
    }

    /**
     * @brief   Get cell by name.
     * @param   pColumnName           column label name.
     * @param   pRowName              row label name.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const std::string& pColumnName, const std::string& pRowName) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      const ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      return GetCell<T>(columnIdx, rowIdx);
    }

    /**
     * @brief   Get cell by name.
     * @param   pColumnName           column label name.
     * @param   pRowName              row label name.
     * @param   pToVal                conversion function.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const std::string& pColumnName, const std::string& pRowName, ConvFunc<T> pToVal) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      const ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      return GetCell<T>(columnIdx, rowIdx, pToVal);
    }

    /**
     * @brief   Get cell by column name and row index.
     * @param   pColumnName           column label name.
     * @param   pRowIdx               zero-based row index.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const std::string& pColumnName, const size_t pRowIdx) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      return GetCell<T>(columnIdx, pRowIdx);
    }

    /**
     * @brief   Get cell by column name and row index.
     * @param   pColumnName           column label name.
     * @param   pRowIdx               zero-based row index.
     * @param   pToVal                conversion function.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const std::string& pColumnName, const size_t pRowIdx, ConvFunc<T> pToVal) const
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      return GetCell<T>(columnIdx, pRowIdx, pToVal);
    }

    /**
     * @brief   Get cell by column index and row name.
     * @param   pColumnIdx            zero-based column index.
     * @param   pRowName              row label name.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const size_t pColumnIdx, const std::string& pRowName) const
    {
      const ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      return GetCell<T>(pColumnIdx, rowIdx);
    }

    /**
     * @brief   Get cell by column index and row name.
     * @param   pColumnIdx            zero-based column index.
     * @param   pRowName              row label name.
     * @param   pToVal                conversion function.
     * @returns cell data.
     */
    template<typename T>
    T GetCell(const size_t pColumnIdx, const std::string& pRowName, ConvFunc<T> pToVal) const
    {
      const ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      return GetCell<T>(pColumnIdx, rowIdx, pToVal);
    }

    /**
     * @brief   Set cell by index.
     * @param   pRowIdx               zero-based row index.
     * @param   pColumnIdx            zero-based column index.
     * @param   pCell                 cell data.
     */
    template<typename T>
    void SetCell(const size_t pColumnIdx, const size_t pRowIdx, const T& pCell)
    {
      const size_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      const size_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);

      while ((rowIdx + 1) > GetDataRowCount())
      {
        std::vector<std::string> row;
        row.resize(GetDataColumnCount());
        mData.push_back(row);
      }

      if ((columnIdx + 1) > GetDataColumnCount())
      {
        for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
        {
          itRow->resize(columnIdx + 1);
        }
      }

      std::string str;
      Converter<T> converter(mConverterParams);
      converter.ToStr(pCell, str);
      mData.at(rowIdx).at(columnIdx) = str;
    }

    /**
     * @brief   Set cell by name.
     * @param   pColumnName           column label name.
     * @param   pRowName              row label name.
     * @param   pCell                 cell data.
     */
    template<typename T>
    void SetCell(const std::string& pColumnName, const std::string& pRowName, const T& pCell)
    {
      const ssize_t columnIdx = GetColumnIdx(pColumnName);
      if (columnIdx < 0)
      {
        throw std::out_of_range("column not found: " + pColumnName);
      }

      const ssize_t rowIdx = GetRowIdx(pRowName);
      if (rowIdx < 0)
      {
        throw std::out_of_range("row not found: " + pRowName);
      }

      SetCell<T>(columnIdx, rowIdx, pCell);
    }

    /**
     * @brief   Get column name
     * @param   pColumnIdx            zero-based column index.
     * @returns column name.
     */
    std::string GetColumnName(const ssize_t pColumnIdx)
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      if (mLabelParams.mColumnNameIdx < 0)
      {
        throw std::out_of_range("column name row index < 0: " + std::to_string(mLabelParams.mColumnNameIdx));
      }

      return mData.at(mLabelParams.mColumnNameIdx).at(columnIdx);
    }

    /**
     * @brief   Set column name
     * @param   pColumnIdx            zero-based column index.
     * @param   pColumnName           column name.
     */
    void SetColumnName(size_t pColumnIdx, const std::string& pColumnName)
    {
      const ssize_t columnIdx = pColumnIdx + (mLabelParams.mRowNameIdx + 1);
      mColumnNames[pColumnName] = columnIdx;
      if (mLabelParams.mColumnNameIdx < 0)
      {
        throw std::out_of_range("column name row index < 0: " + std::to_string(mLabelParams.mColumnNameIdx));
      }

      mData.at(mLabelParams.mColumnNameIdx).at(columnIdx) = pColumnName;
    }

    /**
     * @brief   Get column names
     * @returns vector of column names.
     */
    std::vector<std::string> GetColumnNames()
    {
      if (mLabelParams.mColumnNameIdx >= 0)
      {
        return std::vector<std::string>(mData.at(mLabelParams.mColumnNameIdx).begin() +
                                        (mLabelParams.mRowNameIdx + 1),
                                        mData.at(mLabelParams.mColumnNameIdx).end());
      }

      return std::vector<std::string>();
    }

    /**
     * @brief   Get row name
     * @param   pRowIdx               zero-based column index.
     * @returns row name.
     */
    std::string GetRowName(const ssize_t pRowIdx)
    {
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);
      if (mLabelParams.mRowNameIdx < 0)
      {
        throw std::out_of_range("row name column index < 0: " + std::to_string(mLabelParams.mRowNameIdx));
      }

      return mData.at(rowIdx).at(mLabelParams.mRowNameIdx);
    }

    /**
     * @brief   Set row name
     * @param   pRowIdx               zero-based row index.
     * @param   pRowName              row name.
     */
    void SetRowName(size_t pRowIdx, const std::string& pRowName)
    {
      const ssize_t rowIdx = pRowIdx + (mLabelParams.mColumnNameIdx + 1);
      mRowNames[pRowName] = rowIdx;
      if (mLabelParams.mRowNameIdx < 0)
      {
        throw std::out_of_range("row name column index < 0: " + std::to_string(mLabelParams.mRowNameIdx));
      }

      mData.at(rowIdx).at(mLabelParams.mRowNameIdx) = pRowName;
    }

    /**
     * @brief   Get row names
     * @returns vector of row names.
     */
    std::vector<std::string> GetRowNames()
    {
      std::vector<std::string> rownames;
      if (mLabelParams.mRowNameIdx >= 0)
      {
        for (auto itRow = mData.begin(); itRow != mData.end(); ++itRow)
        {
          if (std::distance(mData.begin(), itRow) > mLabelParams.mColumnNameIdx)
          {
            rownames.push_back(itRow->at(mLabelParams.mRowNameIdx));
          }
        }
      }
      return rownames;
    }

  private:
    void ReadCsv()
    {
      std::ifstream stream;
      stream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
      stream.open(mPath, std::ios::binary);

#ifdef HAS_CODECVT
      stream.seekg(0, std::ios::end);
      std::streamsize length = stream.tellg();
      stream.seekg(0, std::ios::beg);

      std::vector<char> bom(2, '\0');
      if (length >= 2)
      {
        stream.read(bom.data(), 2);
      }

      static const std::vector<char> bomU16le = { '\xff', '\xfe' };
      static const std::vector<char> bomU16be = { '\xfe', '\xff' };
      if ((bom == bomU16le) || (bom == bomU16be))
      {
        mIsUtf16 = true;
        mIsLE = (bom == bomU16le);

        std::wifstream wstream;
        wstream.exceptions(std::wifstream::failbit | std::wifstream::badbit);
        wstream.open(mPath, std::ios::binary);
        if (mIsLE)
        {
          wstream.imbue(std::locale(wstream.getloc(),
                                    new std::codecvt_utf16<wchar_t, 0x10ffff,
                                                           static_cast<std::codecvt_mode>(std::consume_header |
                                                                                          std::little_endian)>));
        }
        else
        {
          wstream.imbue(std::locale(wstream.getloc(),
                                    new std::codecvt_utf16<wchar_t, 0x10ffff,
                                                           std::consume_header>));
        }
        std::wstringstream wss;
        wss << wstream.rdbuf();
        std::string utf8 = ToString(wss.str());
        std::stringstream ss(utf8);
        ReadCsv(ss);
      }
      else
#endif
      {
        stream.seekg(0, std::ios::beg);
        ReadCsv(stream);
      }
    }

    void ReadCsv(std::istream& pStream)
    {
      pStream.seekg(0, std::ios::end);
      std::streamsize fileLength = pStream.tellg();
      pStream.seekg(0, std::ios::beg);
      const std::streamsize bufLength = 64 * 1024;
      std::vector<char> buffer(bufLength);
      std::vector<std::string> row;
      std::string cell;
      bool quoted = false;
      int cr = 0;
      int lf = 0;

      // check for UTF-8 Byte order mark and skip it when found
      if (std::min(fileLength, bufLength) >= 3)
      {
        pStream.read(buffer.data(), 3);
        if (!std::equal(buffer.begin(), buffer.begin() + 3, "\xEF\xBB\xBF"))
        {
          // file does not start with a UTF-8 Byte order mark
          pStream.seekg(0, std::ios::beg);
        }
        else
        {
          // file did start with a UTF-8 Byte order mark
          fileLength -= 3;
        }
      }

      while (fileLength > 0)
      {
        std::streamsize readLength = std::min(fileLength, bufLength);
        pStream.read(buffer.data(), readLength);
        for (int i = 0; i < readLength; ++i)
        {
          if (buffer[i] == '"')
          {
            if (cell.empty() || cell[0] == '"')
            {
              quoted = !quoted;
            }
            cell += buffer[i];
          }
          else if (buffer[i] == mSeparatorParams.mSeparator)
          {
            if (!quoted)
            {
              row.push_back(mSeparatorParams.mTrim ? Trim(cell) : cell);
              cell.clear();
            }
            else
            {
              cell += buffer[i];
            }
          }
          else if (buffer[i] == '\r')
          {
            if (mSeparatorParams.mQuotedLinebreaks && quoted)
            {
              cell += buffer[i];
            }
            else
            {
              ++cr;
            }
          }
          else if (buffer[i] == '\n')
          {
            if (mSeparatorParams.mQuotedLinebreaks && quoted)
            {
              cell += buffer[i];
            }
            else
            {
              ++lf;
              row.push_back(mSeparatorParams.mTrim ? Trim(cell) : cell);
              cell.clear();
              mData.push_back(row);
              row.clear();
              quoted = false;
            }
          }
          else
          {
            cell += buffer[i];
          }
        }
        fileLength -= readLength;
      }

      // Handle last line without linebreak
      if (!cell.empty() || !row.empty())
      {
        row.push_back(mSeparatorParams.mTrim ? Trim(cell) : cell);
        cell.clear();
        mData.push_back(row);
        row.clear();
      }

      // Assume CR/LF if at least half the linebreaks have CR
      mSeparatorParams.mHasCR = (cr > (lf / 2));

      // Set up column labels
      if ((mLabelParams.mColumnNameIdx >= 0) &&
          (static_cast<ssize_t>(mData.size()) > mLabelParams.mColumnNameIdx))
      {
        int i = 0;
        for (auto& columnName : mData[mLabelParams.mColumnNameIdx])
        {
          mColumnNames[columnName] = i++;
        }
      }

      // Set up row labels
      if ((mLabelParams.mRowNameIdx >= 0) &&
          (static_cast<ssize_t>(mData.size()) >
           (mLabelParams.mColumnNameIdx + 1)))
      {
        int i = 0;
        for (auto& dataRow : mData)
        {
          if (static_cast<ssize_t>(dataRow.size()) > mLabelParams.mRowNameIdx)
          {
            mRowNames[dataRow[mLabelParams.mRowNameIdx]] = i++;
          }
        }
      }
    }

    void WriteCsv() const
    {
#ifdef HAS_CODECVT
      if (mIsUtf16)
      {
        std::stringstream ss;
        WriteCsv(ss);
        std::string utf8 = ss.str();
        std::wstring wstr = ToWString(utf8);

        std::wofstream wstream;
        wstream.exceptions(std::wofstream::failbit | std::wofstream::badbit);
        wstream.open(mPath, std::ios::binary | std::ios::trunc);

        if (mIsLE)
        {
          wstream.imbue(std::locale(wstream.getloc(),
                                    new std::codecvt_utf16<wchar_t, 0x10ffff,
                                                           static_cast<std::codecvt_mode>(std::little_endian)>));
        }
        else
        {
          wstream.imbue(std::locale(wstream.getloc(),
                                    new std::codecvt_utf16<wchar_t, 0x10ffff>));
        }

        wstream << (wchar_t) 0xfeff;
        wstream << wstr;
      }
      else
#endif
      {
        std::ofstream stream;
        stream.exceptions(std::ofstream::failbit | std::ofstream::badbit);
        stream.open(mPath, std::ios::binary | std::ios::trunc);
        WriteCsv(stream);
      }
    }

    void WriteCsv(std::ostream& pStream) const
    {
      for (auto itr = mData.begin(); itr != mData.end(); ++itr)
      {
        for (auto itc = itr->begin(); itc != itr->end(); ++itc)
        {
          if ((std::string::npos == itc->find(mSeparatorParams.mSeparator)) ||
              ((itc->length() >= 2) && ((*itc)[0] == '\"') && ((*itc)[itc->length() - 1] == '\"')))
          {
            pStream << *itc;
          }
          else
          {
            pStream << '"' << *itc << '"';
          }

          if (std::distance(itc, itr->end()) > 1)
          {
            pStream << mSeparatorParams.mSeparator;
          }
        }
        pStream << (mSeparatorParams.mHasCR ? "\r\n" : "\n");
      }
    }

    ssize_t GetColumnIdx(const std::string& pColumnName) const
    {
      if (mLabelParams.mColumnNameIdx >= 0)
      {
        if (mColumnNames.find(pColumnName) != mColumnNames.end())
        {
          return mColumnNames.at(pColumnName) - (mLabelParams.mRowNameIdx + 1);
        }
      }
      return -1;
    }

    ssize_t GetRowIdx(const std::string& pRowName) const
    {
      if (mLabelParams.mRowNameIdx >= 0)
      {
        if (mRowNames.find(pRowName) != mRowNames.end())
        {
          return mRowNames.at(pRowName) - (mLabelParams.mColumnNameIdx + 1);
        }
      }
      return -1;
    }

    size_t GetDataRowCount() const
    {
      return mData.size();
    }

    size_t GetDataColumnCount() const
    {
      return (mData.size() > 0) ? mData.at(0).size() : 0;
    }

#ifdef HAS_CODECVT
#if defined(_MSC_VER)
#pragma warning (disable: 4996)
#endif
    static std::string ToString(const std::wstring& pWStr)
    {
      size_t len = std::wcstombs(nullptr, pWStr.c_str(), 0) + 1;
      char* cstr = new char[len];
      std::wcstombs(cstr, pWStr.c_str(), len);
      std::string str(cstr);
      delete[] cstr;
      return str;
    }

    static std::wstring ToWString(const std::string& pStr)
    {
      size_t len = 1 + mbstowcs(nullptr, pStr.c_str(), 0);
      wchar_t* wcstr = new wchar_t[len];
      std::mbstowcs(wcstr, pStr.c_str(), len);
      std::wstring wstr(wcstr);
      delete[] wcstr;
      return wstr;
    }
#if defined(_MSC_VER)
#pragma warning (default: 4996)
#endif
#endif

    static std::string Trim(const std::string& pStr)
    {
      std::string str = pStr;

      // ltrim
      str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](int ch) { return !isspace(ch); }));

      // rtrim
      str.erase(std::find_if(str.rbegin(), str.rend(), [](int ch) { return !isspace(ch); }).base(), str.end());

      return str;
    }

  private:
    std::string mPath;
    LabelParams mLabelParams;
    SeparatorParams mSeparatorParams;
    ConverterParams mConverterParams;
    std::vector<std::vector<std::string>> mData;
    std::map<std::string, size_t> mColumnNames;
    std::map<std::string, size_t> mRowNames;
#ifdef HAS_CODECVT
    bool mIsUtf16 = false;
    bool mIsLE = false;
#endif
  };
}


================================================
FILE: examples/libraries/rapidcsv/tests/msft.csv
================================================
Date,Open,High,Low,Close,Volume,Adj Close
2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003
2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003
2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001
2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998
2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003
2017-02-16,64.739998,65.239998,64.440002,64.519997,20524700,64.519997
2017-02-15,64.50,64.57,64.160004,64.529999,16917000,64.529999
2017-02-14,64.410004,64.720001,64.019997,64.57,23065900,64.57
2017-02-13,64.239998,64.860001,64.129997,64.720001,22920100,64.33
2017-02-10,64.25,64.300003,63.98,64.00,18170700,63.614338
2017-02-09,63.52,64.440002,63.32,64.059998,22644400,63.673974
2017-02-08,63.57,63.810001,63.220001,63.34,18096400,62.958315
2017-02-07,63.740002,63.779999,63.23,63.43,20277200,63.047773
2017-02-06,63.50,63.650002,63.139999,63.639999,19796400,63.256507
2017-02-03,63.50,63.700001,63.07,63.68,30301800,63.296267
2017-02-02,63.25,63.41,62.75,63.169998,45827000,62.789338
2017-02-01,64.360001,64.620003,63.470001,63.580002,39671500,63.196871
2017-01-31,64.860001,65.150002,64.260002,64.650002,25270500,64.260423
2017-01-30,65.690002,65.790001,64.800003,65.129997,31651400,64.737526
2017-01-27,65.389999,65.910004,64.889999,65.779999,44818000,65.38361
2017-01-26,64.120003,64.540001,63.549999,64.269997,43554600,63.882708
2017-01-25,63.950001,64.099998,63.450001,63.68,23672700,63.296267
2017-01-24,63.200001,63.740002,62.939999,63.52,24672900,63.137231
2017-01-23,62.700001,63.119999,62.57,62.959999,23097600,62.580604
2017-01-20,62.669998,62.82,62.369999,62.740002,30213500,62.361932
2017-01-19,62.240002,62.98,62.200001,62.299999,18451700,61.924581
2017-01-18,62.669998,62.700001,62.119999,62.50,19670100,62.123377
2017-01-17,62.68,62.700001,62.029999,62.529999,20664000,62.153195
2017-01-13,62.619999,62.869999,62.349998,62.700001,19422300,62.322172
2017-01-12,63.060001,63.400002,61.950001,62.610001,20968200,62.232715
2017-01-11,62.610001,63.23,62.43,63.189999,21517300,62.809218
2017-01-10,62.73,63.07,62.279999,62.619999,18593000,62.242653
2017-01-09,62.759998,63.080002,62.540001,62.639999,20256600,62.262533
2017-01-06,62.299999,63.150002,62.040001,62.84,19922900,62.461328
2017-01-05,62.189999,62.66,62.029999,62.299999,24876000,61.924581
2017-01-04,62.48,62.75,62.119999,62.299999,21340000,61.924581
2017-01-03,62.790001,62.84,62.130001,62.580002,20694100,62.202897
2016-12-30,62.959999,62.990002,62.029999,62.139999,25579900,61.765546
2016-12-29,62.860001,63.200001,62.73,62.900002,10250600,62.520968
2016-12-28,63.400002,63.400002,62.830002,62.990002,14653300,62.610426
2016-12-27,63.209999,64.07,63.209999,63.279999,11763200,62.898675
2016-12-23,63.450001,63.540001,62.799999,63.240002,12403800,62.858919
2016-12-22,63.84,64.099998,63.41,63.549999,22176600,63.167049
2016-12-21,63.43,63.700001,63.119999,63.540001,17096300,63.157111
2016-12-20,63.689999,63.799999,63.029999,63.540001,26028400,63.157111
2016-12-19,62.560001,63.77,62.419998,63.619999,34338200,63.236627
2016-12-16,62.950001,62.950001,62.119999,62.299999,42453100,61.924581
2016-12-15,62.700001,63.150002,62.299999,62.580002,27669900,62.202897
2016-12-14,63.00,63.450001,62.529999,62.68,30352700,62.302293
2016-12-13,62.50,63.419998,62.240002,62.98,35718900,62.600484
2016-12-12,61.82,62.299999,61.720001,62.169998,20198100,61.795364
2016-12-09,61.18,61.990002,61.130001,61.970001,27349400,61.596572
2016-12-08,61.299999,61.580002,60.84,61.009998,21220800,60.642354
2016-12-07,60.009998,61.380001,59.799999,61.369999,30809000,61.000185
2016-12-06,60.43,60.459999,59.799999,59.950001,19907000,59.588744
2016-12-05,59.700001,60.59,59.560001,60.220001,23552700,59.857117
2016-12-02,59.080002,59.470001,58.799999,59.25,25515700,58.892961
2016-12-01,60.110001,60.150002,58.939999,59.200001,34542100,58.843263
2016-11-30,60.860001,61.18,60.220001,60.259998,34655400,59.896873
2016-11-29,60.650002,61.41,60.52,61.09,22366700,60.721874
2016-11-28,60.34,61.02,60.209999,60.610001,20732600,60.244767
2016-11-25,60.299999,60.529999,60.130001,60.529999,8409600,60.165247
2016-11-23,61.009998,61.099998,60.25,60.400002,21848900,60.036033
2016-11-22,60.98,61.259998,60.810001,61.119999,23206700,60.751692
2016-11-21,60.50,60.970001,60.419998,60.860001,19652600,60.49326
2016-11-18,60.779999,61.139999,60.299999,60.349998,27686300,59.986331
2016-11-17,60.41,60.950001,59.970001,60.639999,32132700,60.274585
2016-11-16,58.939999,59.66,58.810001,59.650002,27332500,59.290552
2016-11-15,58.330002,59.490002,58.32,58.869999,35904100,58.51525
2016-11-14,59.02,59.080002,57.279999,58.119999,41328400,57.38212
2016-11-11,58.23,59.119999,58.009998,59.02,38767800,58.270695
2016-11-10,60.48,60.490002,57.630001,58.700001,57822400,57.954758
2016-11-09,60.00,60.59,59.200001,60.169998,49632500,59.406093
2016-11-08,60.549999,60.779999,60.150002,60.470001,22935400,59.702287
2016-11-07,59.779999,60.52,59.779999,60.419998,31664800,59.652919
2016-11-04,58.650002,59.279999,58.52,58.709999,28697000,57.964629
2016-11-03,59.529999,59.639999,59.110001,59.209999,21600400,58.458281
2016-11-02,59.82,59.93,59.299999,59.43,22147000,58.67549
2016-11-01,59.970001,60.02,59.25,59.799999,24533000,59.040791
2016-10-31,60.16,60.419998,59.919998,59.919998,26434700,59.159266
2016-10-28,60.009998,60.52,59.580002,59.869999,33574700,59.109902
2016-10-27,60.610001,60.830002,60.09,60.099998,28479900,59.336982
2016-10-26,60.810001,61.200001,60.470001,60.630001,29911600,59.860255
2016-10-25,60.849998,61.369999,60.799999,60.990002,35137200,60.215685
2016-10-24,59.939999,61.00,59.93,61.00,54067000,60.225557
2016-10-21,60.279999,60.450001,59.490002,59.66,80032200,58.902569
2016-10-20,57.50,57.52,56.66,57.25,49455600,56.523166
2016-10-19,57.470001,57.84,57.400002,57.529999,22878400,56.79961
2016-10-18,57.529999,57.950001,57.41,57.66,19149500,56.927961
2016-10-17,57.360001,57.459999,56.869999,57.220001,23830000,56.493548
2016-10-14,57.119999,57.740002,57.119999,57.419998,27402500,56.691006
2016-10-13,56.700001,57.299999,56.32,56.919998,25313700,56.197354
2016-10-12,57.110001,57.27,56.400002,57.110001,22177500,56.384944
2016-10-11,57.889999,58.02,56.889999,57.189999,26497400,56.463926
2016-10-10,57.91,58.389999,57.869999,58.040001,18196500,57.303137
2016-10-07,57.849998,57.98,57.419998,57.799999,20089000,57.066183
2016-10-06,57.740002,57.860001,57.279999,57.740002,16212600,57.006947
2016-10-05,57.290001,57.959999,57.259998,57.639999,16726400,56.908214
2016-10-04,57.27,57.599998,56.970001,57.240002,20085900,56.513295
2016-10-03,57.41,57.549999,57.060001,57.419998,19189500,56.691006
2016-09-30,57.57,57.77,57.34,57.599998,29910800,56.868721
2016-09-29,57.810001,58.169998,57.209999,57.400002,25463500,56.671263
2016-09-28,57.880001,58.060001,57.669998,58.029999,20536400,57.293262
2016-09-27,56.93,58.060001,56.68,57.950001,28065100,57.21428
2016-09-26,57.080002,57.139999,56.830002,56.900002,21688700,56.177611
2016-09-23,57.869999,57.91,57.380001,57.43,19955300,56.700881
2016-09-22,57.919998,58.00,57.630001,57.82,19822200,57.085929
2016-09-21,57.509998,57.849998,57.080002,57.759998,33707300,57.02669
2016-09-20,57.349998,57.349998,56.75,56.810001,17384000,56.088754
2016-09-19,57.27,57.75,56.849998,56.93,20937100,56.207229
2016-09-16,57.630001,57.630001,56.75,57.25,44607000,56.523166
2016-09-15,56.150002,57.349998,55.98,57.189999,26847000,56.463926
2016-09-14,56.389999,56.630001,56.029999,56.259998,24062500,55.545733
2016-09-13,56.50,56.650002,56.049999,56.529999,30130200,55.812306
2016-09-12,56.00,57.209999,55.610001,57.049999,29303000,56.325704
2016-09-09,56.790001,57.52,56.209999,56.209999,35113900,55.496369
2016-09-08,57.630001,57.790001,57.18,57.43,20146100,56.700881
2016-09-07,57.470001,57.84,57.41,57.66,17493400,56.927961
2016-09-06,57.779999,57.799999,57.209999,57.610001,16278400,56.878596
2016-09-02,57.669998,58.189999,57.419998,57.669998,18900500,56.937832
2016-09-01,57.009998,57.82,57.009998,57.59,26075400,56.85885
2016-08-31,57.650002,57.799999,57.299999,57.459999,20860300,56.730499
2016-08-30,57.98,58.189999,57.610001,57.889999,16930200,57.15504
2016-08-29,58.18,58.599998,58.099998,58.099998,16417200,57.362373
2016-08-26,58.279999,58.700001,57.689999,58.029999,20971200,57.293262
2016-08-25,57.880001,58.290001,57.779999,58.169998,18552600,57.431484
2016-08-24,57.799999,58.040001,57.720001,57.950001,18151500,57.21428
2016-08-23,57.900002,58.18,57.849998,57.889999,18732400,57.15504
2016-08-22,57.599998,57.75,57.259998,57.669998,15221900,56.937832
2016-08-19,57.43,57.73,57.200001,57.619999,17271000,56.888468
2016-08-18,57.419998,57.700001,57.27,57.599998,14214300,56.868721
2016-08-17,57.540001,57.68,57.23,57.560001,18856400,56.829232
2016-08-16,57.610001,57.619999,57.27,57.439999,20523500,56.710753
2016-08-15,58.009998,58.50,57.959999,58.119999,19283900,57.026691
2016-08-12,58.029999,58.189999,57.619999,57.939999,21655200,56.850076
2016-08-11,58.029999,58.450001,58.029999,58.299999,18162300,57.203305
2016-08-10,58.16,58.32,57.82,58.02,15756900,56.928573
2016-08-09,58.169998,58.50,58.02,58.200001,16920700,57.105187
2016-08-08,58.060001,58.09,57.779999,58.060001,19473500,56.967822
2016-08-05,57.650002,58.209999,57.450001,57.959999,29335200,56.8697
2016-08-04,56.799999,57.52,56.669998,57.389999,26587700,56.310423
2016-08-03,56.68,57.110001,56.490002,56.970001,22075600,55.898326
2016-08-02,56.849998,56.900002,56.310001,56.580002,35122000,55.515663
2016-08-01,56.599998,56.75,56.139999,56.580002,26003400,55.515663
2016-07-29,56.259998,56.759998,56.049999,56.68,30558700,55.61378
2016-07-28,56.00,56.369999,55.720001,56.209999,37550400,55.15262
2016-07-27,56.610001,56.799999,56.110001,56.189999,32327500,55.132996
2016-07-26,56.52,57.290001,56.509998,56.759998,28079000,55.692273
2016-07-25,56.470001,56.740002,56.259998,56.73,25610600,55.662839
2016-07-22,56.080002,56.630001,55.779999,56.57,32157200,55.505849
2016-07-21,55.98,56.23,55.759998,55.799999,32776700,54.750333
2016-07-20,56.150002,56.84,55.529999,55.91,89893300,54.858264
2016-07-19,53.709999,53.900002,52.93,53.09,53336500,52.091312
2016-07-18,53.700001,54.34,53.549999,53.959999,31433900,52.944945
2016-07-15,53.950001,54.00,53.209999,53.700001,32024400,52.689838
2016-07-14,53.84,53.990002,53.580002,53.740002,24545500,52.729086
2016-07-13,53.560001,53.860001,53.18,53.509998,25356800,52.50341
2016-07-12,52.939999,53.400002,52.790001,53.209999,27317600,52.209054
2016-07-11,52.50,52.830002,52.470001,52.59,22269200,51.600718
2016-07-08,51.73,52.360001,51.549999,52.299999,28391000,51.316172
2016-07-07,51.419998,51.610001,51.07,51.380001,19585200,50.41348
2016-07-06,50.779999,51.540001,50.389999,51.380001,28167500,50.41348
2016-07-05,50.830002,51.279999,50.740002,51.169998,24806400,50.207428
2016-07-01,51.130001,51.720001,51.07,51.16,21400400,50.197618
2016-06-30,50.720001,51.299999,50.50,51.169998,28527800,50.207428
2016-06-29,49.91,50.720001,49.799999,50.540001,31304000,49.589282
2016-06-28,48.919998,49.470001,48.669998,49.439999,38140700,48.509972
2016-06-27,49.099998,49.150002,48.040001,48.43,50216300,47.518973
2016-06-24,49.810001,50.939999,49.52,49.830002,133503000,48.892638
2016-06-23,51.279999,52.060001,51.150002,51.91,29028800,50.933509
2016-06-22,51.080002,51.459999,50.950001,50.990002,28816800,50.030817
2016-06-21,50.200001,51.43,50.16,51.189999,34097800,50.227052
2016-06-20,50.639999,50.830002,50.029999,50.07,35607900,49.128122
2016-06-17,50.41,50.43,49.82,50.130001,45710500,49.186994
2016-06-16,49.52,50.470001,49.509998,50.389999,31188600,49.442102
2016-06-15,49.779999,50.119999,49.689999,49.689999,33757600,48.755269
2016-06-14,49.900002,50.099998,49.57,49.830002,42577100,48.892638
2016-06-13,49.580002,50.720001,49.060001,50.139999,83217800,49.196805
2016-06-10,51.049999,52.049999,51.040001,51.48,25833200,50.511598
2016-06-09,52.00,52.00,51.490002,51.619999,20305700,50.648963
2016-06-08,52.02,52.439999,51.869999,52.040001,21149400,51.061065
2016-06-07,52.240002,52.73,52.099998,52.099998,20866800,51.119934
2016-06-06,51.990002,52.349998,51.889999,52.130001,18243300,51.149372
2016-06-03,52.380001,52.419998,51.599998,51.790001,23081300,50.815768
2016-06-02,52.639999,52.740002,51.84,52.48,22840800,51.492786
2016-06-01,52.439999,52.950001,52.439999,52.849998,25324800,51.855825
2016-05-31,52.259998,53.00,52.080002,53.00,37653100,52.003005
2016-05-27,51.919998,52.32,51.77,52.32,17653700,51.335796
2016-05-26,51.93,51.98,51.360001,51.889999,24335200,50.913885
2016-05-25,51.919998,52.490002,51.790001,52.119999,24040200,51.139558
2016-05-24,50.700001,51.709999,50.400002,51.59,34757900,50.619529
2016-05-23,50.599998,50.68,49.98,50.029999,26118700,49.088873
2016-05-20,50.48,51.220001,50.400002,50.619999,23905800,49.667775
2016-05-19,50.470001,50.619999,49.82,50.32,23842400,49.373419
2016-05-18,50.48,51.139999,50.299999,50.810001,24907500,49.854203
2016-05-17,51.720001,51.73,50.360001,50.509998,27803500,49.559843
2016-05-16,50.799999,51.959999,50.75,51.830002,20032000,50.501787
2016-05-13,51.439999,51.900002,51.040001,51.080002,22592300,49.771007
2016-05-12,51.200001,51.810001,50.919998,51.509998,24102800,50.189984
2016-05-11,51.130001,51.779999,51.00,51.049999,24039100,49.741774
2016-05-10,50.330002,51.099998,50.189999,51.02,22891000,49.712543
2016-05-09,50.490002,50.59,50.00,50.07,17951600,48.786888
2016-05-06,49.919998,50.389999,49.66,50.389999,24715600,49.098687
2016-05-05,49.869999,50.299999,49.73,49.939999,25390700,48.660218
2016-05-04,49.84,50.060001,49.459999,49.869999,24257600,48.592012
2016-05-03,50.34,50.41,49.599998,49.779999,26460200,48.504319
2016-05-02,50.00,50.75,49.779999,50.610001,33114500,49.31305
2016-04-29,49.349998,50.25,49.349998,49.869999,48411700,48.592012
2016-04-28,50.619999,50.77,49.560001,49.900002,43134800,48.621246
2016-04-27,51.48,51.50,50.549999,50.939999,43369300,49.634592
2016-04-26,52.259998,52.349998,51.09,51.439999,33532600,50.121779
2016-04-25,51.779999,52.130001,51.630001,52.110001,33226900,50.774611
2016-04-22,51.91,52.43,50.77,51.779999,126834100,50.453066
2016-04-21,55.799999,56.23,55.419998,55.779999,38909100,54.35056
2016-04-20,56.290001,56.50,55.490002,55.59,36195700,54.165431
2016-04-19,56.630001,56.77,55.68,56.389999,29596800,54.944929
2016-04-18,55.490002,56.59,55.209999,56.459999,23150300,55.013135
2016-04-15,55.299999,55.919998,55.110001,55.650002,28793800,54.223894
2016-04-14,55.220001,55.580002,55.07,55.360001,20877100,53.941325
2016-04-13,55.119999,55.439999,54.889999,55.349998,20818000,53.931579
2016-04-12,54.369999,54.779999,53.759998,54.650002,24944300,53.249521
2016-04-11,54.490002,55.150002,54.299999,54.310001,21414200,52.918234
2016-04-08,54.669998,55.279999,54.32,54.419998,22167200,53.025412
2016-04-07,54.869999,54.91,54.23,54.459999,19225100,53.064387
2016-04-06,54.360001,55.200001,54.209999,55.119999,21188700,53.707474
2016-04-05,55.189999,55.299999,54.459999,54.560001,19272300,53.161827
2016-04-04,55.43,55.66,55.00,55.43,18928800,54.009531
2016-04-01,55.049999,55.610001,54.57,55.57,24399200,54.145943
2016-03-31,54.950001,55.59,54.860001,55.23,26360500,53.814656
2016-03-30,54.93,55.639999,54.900002,55.049999,23008300,53.639268
2016-03-29,53.66,54.860001,53.450001,54.709999,23924300,53.307981
2016-03-28,54.209999,54.290001,53.330002,53.540001,17025100,52.167966
2016-03-24,53.84,54.330002,53.73,54.209999,19950000,52.820794
2016-03-23,54.110001,54.240002,53.740002,53.970001,20129000,52.586946
2016-03-22,53.610001,54.25,53.459999,54.07,23124100,52.684382
2016-03-21,53.25,53.93,52.93,53.860001,23925700,52.479765
2016-03-18,54.919998,54.970001,53.450001,53.490002,67625500,52.119248
2016-03-17,54.209999,55.00,54.00,54.66,28223900,53.259263
2016-03-16,53.450001,54.599998,53.400002,54.349998,31691700,52.957206
2016-03-15,52.75,53.59,52.740002,53.59,21104800,52.216683
2016-03-14,52.709999,53.59,52.630001,53.169998,24083600,51.807445
2016-03-11,53.00,53.07,52.380001,53.07,32275700,51.710009
2016-03-10,52.93,52.939999,51.16,52.049999,38387800,50.716147
2016-03-09,51.889999,52.849998,51.860001,52.84,28251600,51.485903
2016-03-08,50.799999,52.130001,50.599998,51.650002,33835100,50.3264
2016-03-07,51.560001,51.799999,50.580002,51.029999,38407800,49.722286
2016-03-04,52.400002,52.450001,51.709999,52.029999,33034200,50.696659
2016-03-03,52.970001,52.970001,51.779999,52.349998,24427800,51.008458
2016-03-02,52.41,52.959999,52.16,52.950001,29289900,51.593085
2016-03-01,50.970001,52.59,50.919998,52.580002,33024500,51.232568
2016-02-29,51.349998,51.650002,50.66,50.880001,31654000,49.576132
2016-02-26,52.599998,52.68,51.099998,51.299999,35975900,49.985367
2016-02-25,51.73,52.099998,50.610001,52.099998,26939500,50.764865
2016-02-24,50.689999,51.50,50.200001,51.360001,33014500,50.043831
2016-02-23,52.34,52.369999,50.98,51.18,28895300,49.868443
2016-02-22,52.279999,53.00,52.279999,52.650002,25008300,51.300774
2016-02-19,51.970001,52.279999,51.529999,51.82,33559100,50.492042
2016-02-18,52.330002,52.950001,52.099998,52.189999,27176000,50.852559
2016-02-17,51.490002,52.77,51.450001,52.419998,40789000,51.076664
2016-02-16,50.900002,51.09,50.130001,51.09,37291200,49.780749
2016-02-12,50.25,50.68,49.75,50.50,34243300,48.855094
2016-02-11,48.68,50.110001,48.509998,49.689999,48878600,48.071477
2016-02-10,49.889999,50.389999,49.52,49.709999,38237000,48.090826
2016-02-09,49.02,50.240002,48.669998,49.279999,46740500,47.674832
2016-02-08,49.549999,49.57,48.189999,49.41,59290500,47.800598
2016-02-05,51.939999,52.00,49.560001,50.16,62009000,48.526169
2016-02-04,52.099998,52.810001,51.369999,52.00,46987100,50.306236
2016-02-03,53.25,53.389999,51.259998,52.16,57559800,50.461024
2016-02-02,54.169998,54.259998,52.650002,53.00,56313800,51.273663
2016-02-01,54.880001,55.09,54.50,54.709999,44208500,52.927964
2016-01-29,54.73,55.09,54.00,55.09,83611700,53.295587
2016-01-28,51.860001,52.209999,51.25,52.060001,62513800,50.364283
2016-01-27,52.009998,52.200001,51.02,51.220001,36775200,49.551643
2016-01-26,51.790001,52.439999,51.549999,52.169998,28900800,50.470697
2016-01-25,51.939999,52.650002,51.650002,51.790001,34707700,50.103077
2016-01-22,51.41,52.330002,51.259998,52.290001,37555800,50.586791
2016-01-21,51.00,51.580002,50.299999,50.48,40191200,48.835745
2016-01-20,49.98,51.380001,49.099998,50.790001,63273000,49.135649
2016-01-19,51.48,51.68,50.060001,50.560001,43564500,48.913141
2016-01-15,51.310001,51.970001,50.34,50.990002,70739100,49.329136
2016-01-14,52.00,53.419998,51.57,53.110001,52381900,51.380081
2016-01-13,53.799999,54.07,51.299999,51.639999,66883600,49.957961
2016-01-12,52.759998,53.099998,52.060001,52.779999,36095500,51.060828
2016-01-11,52.509998,52.849998,51.459999,52.299999,36943800,50.596463
2016-01-08,52.369999,53.279999,52.150002,52.330002,48754000,50.625489
2016-01-07,52.700001,53.490002,52.07,52.169998,56564900,50.470697
2016-01-06,54.32,54.400002,53.639999,54.049999,39518900,52.289462
2016-01-05,54.93,55.389999,54.540001,55.049999,34079700,53.256889
2016-01-04,54.32,54.799999,53.389999,54.799999,53778000,53.015032
2015-12-31,56.040001,56.189999,55.419998,55.48,26529600,53.672883
2015-12-30,56.470001,56.779999,56.290001,56.310001,21704500,54.47585
2015-12-29,56.290001,56.849998,56.060001,56.549999,27731400,54.708031
2015-12-28,55.349998,55.950001,54.98,55.950001,22458300,54.127576
2015-12-24,55.860001,55.959999,55.43,55.669998,9558500,53.856693
2015-12-23,55.700001,55.880001,55.439999,55.82,27279800,54.001809
2015-12-22,54.990002,55.48,54.50,55.349998,28322200,53.547117
2015-12-21,54.880001,55.349998,54.23,54.830002,37246300,53.044058
2015-12-18,55.77,56.00,54.029999,54.130001,84684200,52.366858
2015-12-17,56.360001,56.790001,55.529999,55.700001,41280900,53.885719
2015-12-16,55.540001,56.25,54.759998,56.130001,37503300,54.301713
2015-12-15,55.66,55.900002,55.09,55.200001,39843000,53.402005
2015-12-14,54.330002,55.209999,53.68,55.139999,46768900,53.343958
2015-12-11,54.709999,55.099998,54.009998,54.060001,39549500,52.299138
2015-12-10,55.389999,55.66,55.009998,55.27,31620700,53.469725
2015-12-09,55.369999,55.869999,54.509998,54.98,36373200,53.18917
2015-12-08,55.470001,56.099998,54.990002,55.790001,32878000,53.972787
2015-12-07,55.790001,55.970001,55.290001,55.810001,30709800,53.992136
2015-12-04,54.119999,56.23,54.099998,55.91,43963700,54.088878
2015-12-03,55.490002,55.77,53.93,54.200001,38627800,52.434577
2015-12-02,55.32,55.959999,55.060001,55.209999,47274900,53.411678
2015-12-01,54.41,55.23,54.299999,55.220001,39952800,53.421354
2015-11-30,54.540001,54.959999,54.00,54.349998,56241400,52.579689
2015-11-27,53.799999,54.080002,53.790001,53.93,9009100,52.173371
2015-11-25,54.09,54.23,53.689999,53.689999,21005100,51.941187
2015-11-24,53.919998,54.439999,53.580002,54.25,24600000,52.482948
2015-11-23,54.25,54.459999,53.75,54.189999,28235900,52.424901
2015-11-20,54.25,54.299999,53.27,54.189999,37147600,52.424901
2015-11-19,53.990002,54.66,53.779999,53.939999,28149200,52.183044
2015-11-18,53.00,53.98,52.98,53.849998,29710000,52.095975
2015-11-17,53.169998,53.529999,52.849998,52.970001,31551300,51.244642
2015-11-16,53.080002,53.889999,52.849998,53.77,32165200,51.670308
2015-11-13,53.07,53.290001,52.529999,52.84,36848200,50.776624
2015-11-12,53.48,53.98,53.189999,53.32,35361100,51.23788
2015-11-11,53.700001,54.200001,53.459999,53.650002,36516300,51.554995
2015-11-10,54.07,54.130001,53.27,53.509998,55283700,51.420459
2015-11-09,54.549999,54.869999,53.560001,54.16,32513100,52.045079
2015-11-06,54.09,54.98,53.959999,54.919998,32851200,52.775399
2015-11-05,54.490002,54.700001,54.00,54.380001,31468500,52.256489
2015-11-04,54.18,54.880001,54.060001,54.400002,37087800,52.275708
2015-11-03,52.93,54.389999,52.900002,54.150002,36596900,52.035471
2015-11-02,52.849998,53.360001,52.619999,53.240002,30285000,51.161006
2015-10-30,53.32,53.990002,52.619999,52.639999,46619800,50.584433
2015-10-29,53.540001,53.830002,53.220001,53.360001,30202100,51.276319
2015-10-28,53.540001,53.98,52.860001,53.98,47000800,51.872107
2015-10-27,53.990002,54.369999,53.580002,53.689999,50999900,51.593431
2015-10-26,52.529999,54.32,52.50,54.25,64633300,52.131564
2015-10-23,52.299999,54.07,52.25,52.869999,135227100,50.805452
2015-10-22,47.529999,48.950001,47.09,48.029999,56637100,46.154451
2015-10-21,47.919998,47.990002,47.110001,47.200001,25144300,45.356864
2015-10-20,47.439999,47.810001,47.02,47.77,30574000,45.904606
2015-10-19,47.419998,47.880001,47.02,47.619999,29387600,45.760461
2015-10-16,47.02,47.540001,46.900002,47.509998,26450300,45.654756
2015-10-15,47.009998,47.029999,46.529999,47.009998,27189400,45.174281
2015-10-14,46.650002,47.099998,46.529999,46.68,24697800,44.857169
2015-10-13,46.560001,47.130001,46.560001,46.889999,19987800,45.058968
2015-10-12,46.98,47.07,46.50,47.00,19769100,45.164673
2015-10-09,47.450001,47.540001,46.919998,47.110001,28600600,45.270378
2015-10-08,46.560001,47.52,46.50,47.450001,33772700,45.597102
2015-10-07,47.099998,47.349998,45.950001,46.799999,27711500,44.972482
2015-10-06,46.330002,47.18,46.220001,46.75,27017200,44.924436
2015-10-05,45.75,46.889999,45.700001,46.630001,34369300,44.809123
2015-10-02,44.27,45.57,43.919998,45.57,41839000,43.790514
2015-10-01,44.75,44.75,43.75,44.610001,28657900,42.868002
2015-09-30,43.880001,44.299999,43.66,44.259998,34958900,42.531667
2015-09-29,43.369999,43.57,43.049999,43.439999,32763600,41.743688
2015-09-28,43.830002,44.09,43.209999,43.290001,27613800,41.599548
2015-09-25,44.48,44.73,43.759998,43.939999,29384600,42.224163
2015-09-24,43.450001,44.130001,43.27,43.91,27905600,42.195336
2015-09-23,43.93,44.169998,43.509998,43.869999,17145200,42.156897
2015-09-22,43.380001,44.049999,43.310001,43.900002,28085900,42.185728
2015-09-21,43.619999,44.470001,43.599998,44.110001,26177200,42.387527
2015-09-18,43.50,43.990002,43.330002,43.48,63143700,41.782127
2015-09-17,44.290001,45.00,44.080002,44.25,32768200,42.522059
2015-09-16,43.970001,44.380001,43.84,44.299999,23372200,42.570106
2015-09-15,43.189999,44.290001,43.080002,43.98,28882200,42.262602
2015-09-14,43.43,43.439999,42.860001,43.040001,23656000,41.35931
2015-09-11,43.139999,43.59,42.939999,43.48,27132500,41.782127
2015-09-10,43.119999,43.790001,42.75,43.290001,31366600,41.599548
2015-09-09,44.209999,44.400002,42.91,43.07,33469500,41.388137
2015-09-08,43.299999,44.00,43.200001,43.889999,32469800,42.176117
2015-09-04,42.810001,43.040001,42.200001,42.610001,37138800,40.946101
2015-09-03,43.41,43.98,43.279999,43.50,28285200,41.801346
2015-09-02,42.360001,43.380001,41.880001,43.360001,37671500,41.666814
2015-09-01,42.169998,42.59,41.66,41.82,49688900,40.186949
2015-08-31,43.560001,43.93,43.099998,43.52,34441700,41.820566
2015-08-28,43.400002,44.150002,43.389999,43.93,28246700,42.214555
2015-08-27,43.23,43.950001,42.93,43.900002,50943200,42.185728
2015-08-26,42.009998,42.84,41.060001,42.709999,63408000,41.042195
2015-08-25,42.57,43.240002,40.389999,40.470001,70616600,38.889668
2015-08-24,40.450001,42.689999,39.720001,41.68,88753700,40.052417
2015-08-21,45.299999,45.48,43.07,43.07,70053100,41.388137
2015-08-20,46.07,46.470001,45.66,45.66,36238200,43.876999
2015-08-19,46.779999,47.080002,46.299999,46.610001,31444000,44.789903
2015-08-18,46.84,47.43,46.700001,47.27,23574100,45.42413
2015-08-17,46.810001,47.450001,46.57,47.32,21099700,45.174282
2015-08-14,46.529999,47.099998,46.52,47.00,21473400,44.868793
2015-08-13,47.060001,47.099998,46.490002,46.73,22627200,44.611036
2015-08-12,46.189999,46.900002,45.709999,46.740002,30181400,44.620584
2015-08-11,46.82,46.939999,45.900002,46.41,29237400,44.305546
2015-08-10,46.950001,47.490002,46.84,47.330002,23079900,45.183831
2015-08-07,46.389999,46.779999,46.259998,46.740002,19163000,44.620584
2015-08-06,47.709999,47.77,46.330002,46.619999,27368000,44.506023
2015-08-05,47.98,48.41,47.540001,47.580002,26959700,45.422495
2015-08-04,46.75,47.709999,46.68,47.540001,33403900,45.384308
2015-08-03,46.98,47.00,46.450001,46.810001,24125900,44.68741
2015-07-31,47.290001,47.369999,46.50,46.700001,31201500,44.582397
2015-07-30,46.259998,47.400002,45.93,46.880001,39777900,44.754235
2015-07-29,45.400002,46.779999,45.259998,46.290001,40945900,44.190989
2015-07-28,45.580002,45.639999,44.790001,45.34,34328900,43.284066
2015-07-27,45.939999,46.009998,45.25,45.349998,39701400,43.293611
2015-07-24,45.91,46.32,45.799999,45.939999,32333200,43.856857
2015-07-23,45.27,46.23,45.099998,46.110001,33934000,44.01915
2015-07-22,45.439999,46.93,45.200001,45.540001,59152400,43.474997
2015-07-21,46.779999,47.330002,46.48,47.279999,42781900,45.136095
2015-07-20,46.650002,47.130001,46.439999,46.919998,30631900,44.792419
2015-07-17,46.549999,46.779999,46.259998,46.619999,29467100,44.506023
2015-07-16,46.009998,46.689999,45.970001,46.66,26271700,44.54421
2015-07-15,45.68,45.889999,45.43,45.759998,26629600,43.685019
2015-07-14,45.450001,45.959999,45.310001,45.619999,22880300,43.551368
2015-07-13,44.98,45.619999,44.950001,45.540001,28178300,43.474997
2015-07-10,45.009998,45.139999,44.57,44.610001,25465800,42.587168
2015-07-09,44.75,45.220001,44.50,44.52,32099800,42.501249
2015-07-08,44.439999,44.900002,44.029999,44.240002,39785900,42.233946
2015-07-07,44.34,44.490002,43.32,44.299999,36435800,42.291223
2015-07-06,43.959999,44.48,43.950001,44.389999,23034000,42.377142
2015-07-02,44.48,44.75,44.060001,44.400002,21752000,42.386691
2015-07-01,44.459999,45.23,44.099998,44.450001,28343900,42.434423
2015-06-30,44.709999,44.720001,43.939999,44.150002,35945400,42.148027
2015-06-29,45.040001,45.23,44.360001,44.369999,34081700,42.358049
2015-06-26,45.650002,46.279999,45.029999,45.259998,49835300,43.207691
2015-06-25,46.029999,46.060001,45.50,45.650002,20616000,43.58001
2015-06-24,45.669998,46.25,45.549999,45.639999,34890900,43.570461
2015-06-23,46.130001,46.279999,45.619999,45.91,25896500,43.828219
2015-06-22,46.330002,46.720001,46.16,46.23,20318100,44.133708
2015-06-19,46.790001,46.830002,45.990002,46.099998,63837000,44.009602
2015-06-18,46.220001,46.799999,46.169998,46.720001,32658300,44.601491
2015-06-17,45.73,46.07,45.360001,45.970001,28704100,43.885499
2015-06-16,45.349998,46.240002,45.299999,45.830002,27070300,43.751848
2015-06-15,45.450001,45.650002,45.02,45.48,33254500,43.417717
2015-06-12,46.220001,46.470001,45.900002,45.970001,23931000,43.885499
2015-06-11,46.66,46.919998,46.130001,46.439999,27347800,44.334185
2015-06-10,45.790001,46.830002,45.689999,46.610001,28417400,44.496478
2015-06-09,45.759998,45.939999,45.459999,45.650002,24406100,43.58001
2015-06-08,46.299999,46.43,45.669998,45.73,22121600,43.656381
2015-06-05,46.310001,46.52,45.84,46.139999,25438100,44.047789
2015-06-04,46.790001,47.16,46.200001,46.360001,27745500,44.257814
2015-06-03,47.369999,47.740002,46.82,46.849998,27955200,44.725593
2015-06-02,46.93,47.349998,46.619999,46.919998,21498300,44.792419
2015-06-01,47.060001,47.77,46.619999,47.23,28837300,45.088363
2015-05-29,47.43,47.57,46.59,46.860001,36519600,44.735142
2015-05-28,47.50,48.02,47.389999,47.450001,19283700,45.298389
2015-05-27,46.82,47.77,46.619999,47.610001,27335600,45.451133
2015-05-26,46.830002,46.880001,46.189999,46.59,29581900,44.477385
2015-05-22,47.299999,47.349998,46.82,46.900002,25720600,44.773329
2015-05-21,47.279999,47.599998,47.009998,47.419998,22410700,45.269746
2015-05-20,47.389999,47.93,47.27,47.580002,25047900,45.422495
2015-05-19,47.560001,47.810001,47.18,47.580002,28574800,45.422495
2015-05-18,47.98,48.220001,47.610001,48.009998,24136500,45.53705
2015-05-15,48.869999,48.91,48.049999,48.299999,28642700,45.812113
2015-05-14,48.029999,48.82,48.029999,48.720001,32980900,46.210482
2015-05-13,48.189999,48.32,47.57,47.630001,34184600,45.176626
2015-05-12,46.849998,47.68,46.419998,47.349998,29928300,44.911046
2015-05-11,47.549999,47.91,47.369999,47.369999,24609400,44.930017
2015-05-08,47.549999,47.98,47.52,47.75,35364900,45.290444
2015-05-07,46.27,47.09,46.16,46.700001,32971700,44.294529
2015-05-06,47.57,47.77,46.02,46.279999,52433000,43.896161
2015-05-05,47.82,48.16,47.310001,47.599998,50369200,45.148169
2015-05-04,48.369999,48.869999,48.18,48.240002,34039500,45.755206
2015-05-01,48.580002,48.880001,48.400002,48.66,38937300,46.153571
2015-04-30,48.700001,49.540001,48.599998,48.639999,64725500,46.134601
2015-04-29,48.720001,49.310001,48.50,49.060001,47804600,46.532969
2015-04-28,47.779999,49.209999,47.700001,49.16,60730800,46.627816
2015-04-27,47.23,48.130001,47.220001,48.029999,59248200,45.55602
2015-04-24,45.66,48.139999,45.650002,47.869999,130933700,45.404262
2015-04-23,42.889999,43.610001,42.799999,43.34,46309500,41.107599
2015-04-22,42.669998,43.130001,42.549999,42.990002,25064300,40.775629
2015-04-21,43.00,43.150002,42.529999,42.639999,26013800,40.443655
2015-04-20,41.73,43.169998,41.68,42.91,46057700,40.699748
2015-04-17,41.669998,41.740002,41.16,41.619999,42387600,39.476193
2015-04-16,41.950001,42.34,41.82,42.16,22509700,39.988379
2015-04-15,41.759998,42.459999,41.68,42.259998,27343600,40.083227
2015-04-14,41.799999,42.029999,41.389999,41.650002,24244400,39.504651
2015-04-13,41.400002,42.060001,41.389999,41.759998,30276700,39.608982
2015-04-10,41.630001,41.950001,41.41,41.720001,28022000,39.571045
2015-04-09,41.25,41.619999,41.25,41.48,25723900,39.343405
2015-04-08,41.459999,41.689999,41.040001,41.419998,24753400,39.286495
2015-04-07,41.610001,41.91,41.310001,41.529999,28809400,39.390829
2015-04-06,40.34,41.779999,40.18,41.549999,39223700,39.409799
2015-04-02,40.66,40.740002,40.119999,40.290001,37487500,38.214702
2015-04-01,40.599998,40.759998,40.310001,40.720001,36865300,38.622554
2015-03-31,40.779999,41.029999,40.540001,40.66,34887200,38.565643
2015-03-30,41.099998,41.540001,40.91,40.959999,35049700,38.85019
2015-03-27,41.119999,41.43,40.830002,40.970001,34401400,38.859676
2015-03-26,41.220001,41.610001,40.919998,41.209999,37495600,39.087312
2015-03-25,42.919998,42.93,41.439999,41.459999,43469900,39.324435
2015-03-24,42.779999,43.169998,42.75,42.900002,25513300,40.690264
2015-03-23,42.880001,43.130001,42.779999,42.860001,26246100,40.652324
2015-03-20,42.560001,42.98,42.490002,42.880001,71904500,40.671294
2015-03-19,42.259998,42.59,42.220001,42.290001,33879100,40.111684
2015-03-18,41.43,42.830002,41.330002,42.50,44194800,40.310867
2015-03-17,41.369999,41.830002,41.150002,41.700001,31673400,39.552074
2015-03-16,41.470001,41.639999,41.279999,41.560001,35273500,39.419286
2015-03-13,40.700001,41.470001,40.610001,41.380001,58007700,39.248558
2015-03-12,41.330002,41.650002,40.860001,41.02,59992500,38.9071
2015-03-11,42.310001,42.369999,41.84,41.98,32215300,39.817651
2015-03-10,42.349998,42.709999,42.029999,42.029999,39159700,39.865075
2015-03-09,42.189999,43.130001,42.189999,42.849998,32108000,40.642837
2015-03-06,43.00,43.110001,42.150002,42.360001,36248800,40.178078
2015-03-05,43.07,43.240002,42.82,43.110001,23193500,40.889447
2015-03-04,43.009998,43.209999,42.880001,43.060001,25748700,40.842023
2015-03-03,43.560001,43.830002,43.09,43.279999,31748600,41.050688
2015-03-02,43.669998,44.189999,43.549999,43.880001,31924000,41.619785
2015-02-27,44.130001,44.200001,43.66,43.849998,33807700,41.591328
2015-02-26,43.990002,44.23,43.889999,44.060001,28957300,41.790514
2015-02-25,43.950001,44.09,43.799999,43.990002,29759800,41.72412
2015-02-24,44.150002,44.299999,43.919998,44.09,25271700,41.818967
2015-02-23,43.700001,44.189999,43.650002,44.150002,32518800,41.875878
2015-02-20,43.509998,43.880001,43.290001,43.860001,29721100,41.600815
2015-02-19,43.18,43.529999,43.049999,43.50,27603400,41.259358
2015-02-18,43.630001,43.700001,43.389999,43.529999,27111700,41.287811
2015-02-17,43.970001,44.00,43.189999,43.580002,33695700,41.335239
2015-02-13,43.380001,43.869999,43.150002,43.869999,40264900,41.316268
2015-02-12,42.66,43.09,42.509998,43.09,33268800,40.581674
2015-02-11,42.650002,42.650002,42.209999,42.380001,38262500,39.913005
2015-02-10,42.740002,42.77,42.18,42.599998,29670700,40.120196
2015-02-09,42.240002,42.740002,42.209999,42.360001,31381100,39.894169
2015-02-06,42.68,42.790001,42.150002,42.41,34616600,39.941257
2015-02-05,42.220001,42.639999,41.860001,42.450001,36548200,39.97893
2015-02-04,41.939999,42.209999,41.360001,41.84,41614800,39.404438
2015-02-03,41.630001,41.93,41.049999,41.599998,52082400,39.178407
2015-02-02,40.59,41.369999,40.23,41.279999,50352500,38.877035
2015-01-30,41.549999,41.580002,40.349998,40.400002,78004900,38.048264
2015-01-29,40.93,42.119999,40.790001,42.009998,63585300,39.564541
2015-01-28,42.740002,42.790001,41.16,41.189999,84507100,38.792274
2015-01-27,42.950001,43.200001,42.110001,42.66,169164000,40.176705
2015-01-26,47.00,47.130001,46.240002,47.009998,42525500,44.273484
2015-01-23,47.360001,47.389999,46.799999,47.18,26211600,44.43359
2015-01-22,46.380001,47.139999,46.080002,47.130001,35898000,44.386501
2015-01-21,45.939999,46.139999,45.48,45.919998,39081100,43.246934
2015-01-20,46.299999,46.650002,45.57,46.389999,36161900,43.689576
2015-01-16,45.310001,46.279999,45.169998,46.240002,35695300,43.54831
2015-01-15,46.220001,46.380001,45.41,45.48,32750800,42.832548
2015-01-14,45.959999,46.240002,45.619999,45.959999,29675300,43.284607
2015-01-13,46.970001,47.91,46.060001,46.360001,35270600,43.661323
2015-01-12,47.419998,47.540001,46.360001,46.599998,23651900,43.887351
2015-01-09,47.610001,47.82,46.900002,47.189999,23944200,44.443006
2015-01-08,46.75,47.75,46.720001,47.59,29645200,44.819723
2015-01-07,45.98,46.459999,45.490002,46.23,29114100,43.53889
2015-01-06,46.380001,46.75,45.540001,45.650002,36447900,42.992654
2015-01-05,46.369999,46.73,46.25,46.330002,39673900,43.633071
2015-01-02,46.66,47.419998,46.540001,46.759998,27913900,44.038037
2014-12-31,46.73,47.439999,46.450001,46.450001,21552500,43.746085
2014-12-30,47.439999,47.619999,46.84,47.02,16384700,44.282904
2014-12-29,47.700001,47.779999,47.259998,47.450001,14439500,44.687873
2014-12-26,48.41,48.41,47.82,47.880001,13197800,45.092843
2014-12-24,48.639999,48.639999,48.080002,48.139999,11437800,45.337706
2014-12-23,48.369999,48.799999,48.130001,48.450001,23648100,45.629662
2014-12-22,47.779999,48.119999,47.709999,47.98,26566000,45.18702
2014-12-19,47.630001,48.099998,47.169998,47.66,64551200,44.885648
2014-12-18,46.580002,47.52,46.34,47.52,40105600,44.753798
2014-12-17,45.049999,45.950001,44.900002,45.740002,34970900,43.077416
2014-12-16,45.900002,46.34,45.130001,45.16,47801400,42.531176
2014-12-15,47.200001,47.669998,46.549999,46.669998,29247800,43.953276
2014-12-12,46.779999,47.73,46.669998,46.950001,34248400,44.216979
2014-12-11,47.080002,47.740002,46.68,47.169998,29060400,44.42417
2014-12-10,47.580002,47.66,46.700001,46.900002,30431800,44.16989
2014-12-09,47.110001,47.919998,47.049999,47.59,24330500,44.819723
2014-12-08,48.259998,48.349998,47.450001,47.700001,26663100,44.92332
2014-12-05,48.82,48.970001,48.380001,48.419998,27313400,45.601406
2014-12-04,48.389999,49.060001,48.200001,48.84,30320400,45.996959
2014-12-03,48.439999,48.50,47.810001,48.080002,23534800,45.281201
2014-12-02,48.84,49.049999,48.200001,48.459999,25773500,45.639078
2014-12-01,47.880001,48.779999,47.709999,48.619999,31191600,45.789764
2014-11-28,47.950001,48.200001,47.610001,47.810001,21534400,45.026918
2014-11-26,47.490002,47.990002,47.279999,47.75,27163600,44.970409
2014-11-25,47.66,47.970001,47.450001,47.470001,28008000,44.706709
2014-11-24,47.990002,48.00,47.389999,47.59,35434200,44.819723
2014-11-21,49.02,49.049999,47.57,47.98,42884800,45.18702
2014-11-20,48.00,48.700001,47.869999,48.700001,21510600,45.865109
2014-11-19,48.66,48.75,47.93,48.220001,26177500,45.413051
2014-11-18,49.130001,49.330002,48.700001,48.740002,23995500,45.902782
2014-11-17,49.41,49.709999,49.139999,49.459999,30318600,46.28891
2014-11-14,49.740002,50.049999,49.389999,49.580002,29081700,46.401219
2014-11-13,48.810001,49.650002,48.709999,49.610001,26210400,46.429294
2014-11-12,48.560001,48.919998,48.52,48.779999,22722100,45.652508
2014-11-11,48.849998,48.950001,48.650002,48.869999,23445200,45.736737
2014-11-10,48.650002,49.150002,48.549999,48.889999,36370100,45.755456
2014-11-07,48.919998,48.919998,48.290001,48.68,28000600,45.55892
2014-11-06,47.860001,48.860001,47.790001,48.700001,33037800,45.577639
2014-11-05,47.799999,47.900002,47.259998,47.860001,22449600,44.791494
2014-11-04,47.299999,47.73,47.25,47.57,21530800,44.520087
2014-11-03,46.889999,47.459999,46.73,47.439999,23130400,44.39842
2014-10-31,46.939999,46.970001,46.48,46.950001,35849700,43.939838
2014-10-30,46.32,46.32,45.77,46.049999,30073900,43.09754
2014-10-29,46.439999,46.700001,46.34,46.619999,30276100,43.630994
2014-10-28,45.860001,46.50,45.77,46.490002,29049800,43.509332
2014-10-27,45.709999,46.099998,45.709999,45.91,30371300,42.966516
2014-10-24,46.830002,46.900002,45.18,46.130001,61076700,43.172412
2014-10-23,44.619999,45.450001,44.529999,45.02,45451900,42.133579
2014-10-22,45.00,45.07,44.23,44.380001,33570900,41.534612
2014-10-21,44.360001,44.98,44.189999,44.880001,36433800,42.002555
2014-10-20,43.060001,44.139999,42.810001,44.080002,34527900,41.253847
2014-10-17,43.200001,43.939999,42.790001,43.630001,40683300,40.832698
2014-10-16,42.529999,43.080002,42.220001,42.740002,49040400,39.99976
2014-10-15,43.00,43.389999,42.099998,43.220001,60218700,40.448985
2014-10-14,43.869999,44.380001,43.560001,43.73,38115700,40.926285
2014-10-13,43.82,44.560001,43.490002,43.650002,37100200,40.851416
2014-10-10,45.599998,46.119999,43.950001,44.029999,51978100,41.20705
2014-10-09,46.50,46.799999,45.740002,45.849998,34422800,42.910362
2014-10-08,45.48,46.889999,45.34,46.779999,33031000,43.780736
2014-10-07,45.860001,45.93,45.419998,45.529999,25723700,42.610879
2014-10-06,46.119999,46.299999,45.919998,46.09,20604000,43.134976
2014-10-03,45.98,46.299999,45.610001,46.09,32453200,43.134976
2014-10-02,45.830002,46.099998,45.639999,45.759998,25119400,42.826132
2014-10-01,46.27,46.529999,45.849998,45.900002,38088400,42.957159
2014-09-30,46.369999,46.48,46.009998,46.360001,33033100,43.387666
2014-09-29,45.98,46.560001,45.759998,46.439999,26091000,43.462535
2014-09-26,45.93,46.619999,45.759998,46.41,27078800,43.434459
2014-09-25,46.880001,47.09,46.029999,46.040001,33077400,43.088182
2014-09-24,46.630001,47.110001,46.34,47.080002,26582700,44.061505
2014-09-23,46.849998,46.98,46.470001,46.560001,33430300,43.574844
2014-09-22,47.299999,47.380001,46.98,47.060001,38686100,44.042786
2014-09-19,46.810001,47.57,46.599998,47.52,202522400,44.473293
2014-09-18,46.59,46.830002,46.459999,46.68,35556600,43.687149
2014-09-17,46.259998,46.689999,46.23,46.52,38311900,43.537407
2014-09-16,46.389999,46.849998,46.290001,46.759998,27910600,43.762018
2014-09-15,46.540001,46.709999,46.099998,46.240002,37667600,43.27536
2014-09-12,46.91,47.02,46.599998,46.700001,38244700,43.705867
2014-09-11,46.740002,47.00,46.470001,47.00,29216400,43.986632
2014-09-10,46.82,46.939999,46.279999,46.84,27302400,43.83689
2014-09-09,46.470001,46.970001,46.419998,46.759998,40302400,43.762018
2014-09-08,46.02,46.799999,45.990002,46.470001,45736700,43.490614
2014-09-05,45.110001,45.93,45.110001,45.91,36939400,42.966516
2014-09-04,44.740002,45.27,44.720001,45.259998,26475500,42.358189
2014-09-03,44.529999,45.110001,44.529999,44.959999,33684500,42.077424
2014-09-02,45.43,45.459999,44.849998,45.09,22976800,42.19909
2014-08-29,45.09,45.439999,44.860001,45.43,21607600,42.517292
2014-08-28,44.75,44.98,44.610001,44.880001,17657600,42.002555
2014-08-27,44.900002,45.00,44.759998,44.869999,21287900,41.993194
2014-08-26,45.310001,45.400002,44.939999,45.009998,14873100,42.124218
2014-08-25,45.400002,45.439999,45.040001,45.169998,16910000,42.273959
2014-08-22,45.349998,45.470001,45.07,45.150002,18294500,42.255245
2014-08-21,44.84,45.25,44.830002,45.220001,22285500,42.320756
2014-08-20,45.34,45.400002,44.900002,44.950001,24770500,42.068067
2014-08-19,44.970001,45.34,44.830002,45.330002,28139500,42.423704
2014-08-18,44.939999,45.110001,44.68,45.110001,26891100,41.955761
2014-08-15,44.580002,44.900002,44.400002,44.790001,41611300,41.658137
2014-08-14,44.080002,44.419998,44.009998,44.27,19313200,41.174497
2014-08-13,43.68,44.18,43.52,44.080002,22889500,40.997783
2014-08-12,43.040001,43.59,43.00,43.52,21431100,40.476939
2014-08-11,43.259998,43.450001,43.02,43.200001,20351600,40.179315
2014-08-08,43.23,43.32,42.91,43.200001,28942700,40.179315
2014-08-07,42.84,43.450001,42.650002,43.23,30314900,40.207216
2014-08-06,42.740002,43.169998,42.209999,42.740002,24634000,39.751481
2014-08-05,43.310001,43.459999,42.830002,43.080002,26266400,40.067707
2014-08-04,42.970001,43.470001,42.810001,43.369999,34277400,40.337426
2014-08-01,43.209999,43.25,42.599998,42.860001,31170300,39.863089
2014-07-31,43.380001,43.689999,43.080002,43.16,31537500,40.142111
2014-07-30,44.07,44.099998,43.290001,43.580002,31921400,40.532745
2014-07-29,43.91,44.09,43.639999,43.889999,27763100,40.821067
2014-07-28,44.360001,44.509998,43.93,43.970001,29684200,40.895474
2014-07-25,44.299999,44.66,44.299999,44.50,26737700,41.388414
2014-07-24,44.93,45.00,44.32,44.400002,30725300,41.295408
2014-07-23,45.450001,45.450001,44.619999,44.869999,52362900,41.732541
2014-07-22,45.00,45.150002,44.59,44.830002,43095800,41.695341
2014-07-21,44.560001,45.16,44.220001,44.84,37604400,41.70464
2014-07-18,44.650002,44.84,44.25,44.689999,43407500,41.565127
2014-07-17,45.450001,45.709999,44.25,44.529999,82180300,41.416315
2014-07-16,42.509998,44.310001,42.48,44.080002,63318000,40.997783
2014-07-15,42.330002,42.470001,42.029999,42.450001,28748700,39.481757
2014-07-14,42.220001,42.450001,42.040001,42.139999,21881100,39.193432
2014-07-11,41.700001,42.09,41.48,42.09,24083000,39.146929
2014-07-10,41.369999,42.00,41.049999,41.689999,21854700,38.774897
2014-07-09,41.98,41.990002,41.529999,41.669998,18445900,38.756295
2014-07-08,41.869999,42.00,41.610001,41.779999,31218200,38.858604
2014-07-07,41.75,42.119999,41.709999,41.990002,21952400,39.053923
2014-07-03,41.91,41.990002,41.560001,41.799999,15969300,38.877206
2014-07-02,41.73,41.900002,41.529999,41.900002,20208100,38.970216
2014-07-01,41.860001,42.150002,41.689999,41.869999,26917000,38.942311
2014-06-30,42.169998,42.209999,41.700001,41.700001,30793100,38.7842
2014-06-27,41.610001,42.290001,41.509998,42.25,74640000,39.295741
2014-06-26,41.93,41.939999,41.43,41.720001,23604400,38.802802
2014-06-25,41.700001,42.049999,41.459999,42.029999,20049100,39.091123
2014-06-24,41.830002,41.939999,41.560001,41.75,26509100,38.830703
2014-06-23,41.73,42.00,41.689999,41.990002,18743900,39.053923
2014-06-20,41.450001,41.830002,41.380001,41.68,47764900,38.765598
2014-06-19,41.57,41.77,41.330002,41.509998,19828200,38.607483
2014-06-18,41.610001,41.740002,41.18,41.650002,27097000,38.737697
2014-06-17,41.290001,41.91,40.34,41.68,22518600,38.765598
2014-06-16,41.040001,41.610001,41.040001,41.50,24205300,38.598184
2014-06-13,41.099998,41.57,40.860001,41.23,26310000,38.347063
2014-06-12,40.810001,40.880001,40.290001,40.580002,29818900,37.742515
2014-06-11,40.93,41.07,40.77,40.860001,18040000,38.002935
2014-06-10,41.029999,41.16,40.860001,41.110001,15117700,38.235454
2014-06-09,41.389999,41.48,41.02,41.27,15019200,38.384267
2014-06-06,41.48,41.66,41.240002,41.48,24060500,38.579582
2014-06-05,40.59,41.25,40.400002,41.209999,31865200,38.328461
2014-06-04,40.209999,40.369999,39.860001,40.32,23209000,37.500693
2014-06-03,40.599998,40.68,40.25,40.290001,18068900,37.472792
2014-06-02,40.950001,41.09,40.68,40.790001,18504300,37.93783
2014-05-30,40.450001,40.970001,40.25,40.939999,34567600,38.07734
2014-05-29,40.150002,40.349998,39.91,40.34,19888200,37.519295
2014-05-28,40.139999,40.189999,39.82,40.009998,25711500,37.212368
2014-05-27,40.259998,40.259998,39.810001,40.189999,26160600,37.379782
2014-05-23,40.369999,40.369999,40.00,40.119999,18020000,37.314677
2014-05-22,40.290001,40.349998,39.849998,40.099998,20201800,37.296075
2014-05-21,39.799999,40.349998,39.740002,40.349998,22398700,37.528594
2014-05-20,39.68,39.939999,39.459999,39.68,21320900,36.905444
2014-05-19,39.610001,39.82,39.459999,39.75,24537400,36.97055
2014-05-16,39.669998,39.84,39.27,39.830002,29867100,37.044957
2014-05-15,40.09,40.400002,39.509998,39.599998,37793200,36.831037
2014-05-14,40.299999,40.450001,40.049999,40.240002,18818700,37.426289
2014-05-13,39.919998,40.50,39.849998,40.419998,27004800,37.593699
2014-05-12,39.740002,40.02,39.650002,39.970001,22782600,36.914745
2014-05-09,39.540001,39.849998,39.369999,39.540001,29647600,36.517614
2014-05-08,39.34,39.900002,38.970001,39.639999,32120400,36.609968
2014-05-07,39.220001,39.509998,38.509998,39.419998,41744500,36.406784
2014-05-06,39.290001,39.349998,38.950001,39.060001,27112400,36.074305
2014-05-05,39.52,39.639999,39.299999,39.43,22460900,36.416021
2014-05-02,40.310001,40.34,39.66,39.689999,43416600,36.656146
2014-05-01,40.240002,40.360001,39.950001,40.00,28787400,36.942451
2014-04-30,40.400002,40.50,40.169998,40.400002,35458700,37.311877
2014-04-29,41.099998,41.189999,40.389999,40.509998,29636200,37.413466
2014-04-28,40.139999,41.290001,40.09,40.869999,50610200,37.745948
2014-04-25,40.290001,40.68,39.75,39.91,56876800,36.85933
2014-04-24,39.740002,39.970001,39.299999,39.860001,42381600,36.813153
2014-04-23,39.990002,39.990002,39.470001,39.689999,24602800,36.656146
2014-04-22,39.959999,40.139999,39.830002,39.990002,27056700,36.933217
2014-04-21,40.130001,40.150002,39.790001,39.939999,22221200,36.887036
2014-04-17,40.009998,40.200001,39.509998,40.009998,36688400,36.951685
2014-04-16,40.060001,40.419998,39.91,40.400002,30615800,37.311877
2014-04-15,39.34,39.959999,39.049999,39.75,33968700,36.711561
2014-04-14,39.110001,39.41,38.900002,39.18,32006600,36.185131
2014-04-11,39.00,39.790001,39.00,39.209999,34330200,36.212837
2014-04-10,40.439999,40.689999,39.09,39.360001,45960800,36.351372
2014-04-09,39.93,40.549999,39.880001,40.470001,27398700,37.376526
2014-04-08,39.75,39.93,39.200001,39.82,35918600,36.77621
2014-04-07,39.959999,40.27,39.740002,39.799999,37559600,36.757738
2014-04-04,41.25,41.389999,39.639999,39.869999,51409600,36.822387
2014-04-03,41.290001,41.290001,40.709999,41.009998,30139600,37.875246
2014-04-02,41.439999,41.66,41.169998,41.349998,28666700,38.189257
2014-04-01,41.150002,41.59,41.07,41.419998,32605000,38.253906
2014-03-31,40.43,41.50,40.400002,40.990002,46886300,37.856778
2014-03-28,39.790001,40.639999,39.68,40.299999,43472700,37.219519
2014-03-27,39.740002,39.970001,39.34,39.360001,35369200,36.351372
2014-03-26,40.48,40.709999,39.599998,39.790001,41977500,36.748504
2014-03-25,40.66,40.990002,39.959999,40.34,43193100,37.256462
2014-03-24,40.34,40.639999,39.860001,40.50,46098400,37.404232
2014-03-21,40.720001,40.939999,40.009998,40.16,80721800,37.090221
2014-03-20,39.25,40.650002,39.240002,40.330002,59269800,37.247228
2014-03-19,39.470001,39.549999,38.91,39.27,35597200,36.268252
2014-03-18,38.259998,39.900002,38.220001,39.549999,64063900,36.526848
2014-03-17,37.900002,38.41,37.790001,38.049999,20479600,35.141506
2014-03-14,37.650002,38.139999,37.509998,37.700001,27195600,34.818261
2014-03-13,38.419998,38.450001,37.639999,37.889999,32169700,34.993736
2014-03-12,37.799999,38.43,37.790001,38.27,30494100,35.34469
2014-03-11,37.869999,38.23,37.720001,38.02,25216400,35.1138
2014-03-10,37.990002,38.009998,37.720001,37.82,19006600,34.929087
2014-03-07,38.279999,38.360001,37.689999,37.900002,26591600,35.002974
2014-03-06,38.139999,38.240002,37.889999,38.150002,23582200,35.233864
2014-03-05,38.25,38.27,37.93,38.110001,20520100,35.196921
2014-03-04,38.200001,38.48,38.07,38.41,26802400,35.473988
2014-03-03,37.919998,38.130001,37.490002,37.779999,29717500,34.892144
2014-02-28,37.98,38.459999,37.82,38.310001,41215000,35.381634
2014-02-27,37.450001,37.889999,37.23,37.860001,33903400,34.96603
2014-02-26,37.580002,37.740002,37.189999,37.470001,41041800,34.605842
2014-02-25,37.610001,37.849998,37.349998,37.540001,30736500,34.670491
2014-02-24,37.689999,37.98,37.540001,37.689999,32085100,34.809023
2014-02-21,37.939999,38.349998,37.860001,37.98,38021300,35.076857
2014-02-20,37.57,37.869999,37.400002,37.75,27526100,34.864438
2014-02-19,37.220001,37.75,37.209999,37.509998,29750400,34.642782
2014-02-18,37.630001,37.779999,37.41,37.419998,32834000,34.559661
2014-02-14,37.389999,37.779999,37.330002,37.619999,31407500,34.485778
2014-02-13,37.330002,37.860001,37.330002,37.610001,37635500,34.476613
2014-02-12,37.349998,37.599998,37.299999,37.470001,27051800,34.348277
2014-02-11,36.880001,37.259998,36.860001,37.169998,32141400,34.073268
2014-02-10,36.630001,36.799999,36.290001,36.799999,26767000,33.734094
2014-02-07,36.32,36.59,36.009998,36.560001,33260500,33.514091
2014-02-06,35.799999,36.25,35.689999,36.18,35351800,33.165749
2014-02-05,36.290001,36.470001,35.799999,35.82,55814400,32.835741
2014-02-04,36.970001,37.189999,36.25,36.349998,54697900,33.321584
2014-02-03,37.740002,37.990002,36.43,36.48,64063100,33.440755
2014-01-31,36.950001,37.889999,36.560001,37.84,93162300,34.68745
2014-01-30,36.790001,36.880001,36.23,36.860001,35036300,33.789097
2014-01-29,35.98,36.880001,35.900002,36.66,52745900,33.605759
2014-01-28,36.119999,36.389999,35.75,36.27,36205500,33.248251
2014-01-27,36.869999,36.889999,35.98,36.029999,44420800,33.028245
2014-01-24,37.450001,37.549999,36.529999,36.810001,76395500,33.743263
2014-01-23,36.09,36.130001,35.52,36.060001,43954000,33.055748
2014-01-22,36.259998,36.32,35.75,35.93,21904300,32.936577
2014-01-21,36.82,36.82,36.060001,36.169998,31567300,33.15658
2014-01-17,36.830002,36.830002,36.150002,36.380001,46267500,33.349087
2014-01-16,36.689999,37.00,36.310001,36.889999,38018700,33.816596
2014-01-15,35.900002,36.790001,35.849998,36.759998,44812600,33.697426
2014-01-14,34.73,35.880001,34.630001,35.779999,41623300,32.799073
2014-01-13,35.990002,36.02,34.830002,34.98,45901900,32.065724
2014-01-10,35.900002,36.150002,35.75,36.040001,40548800,33.037414
2014-01-09,35.880001,35.91,35.400002,35.529999,36516300,32.569901
2014-01-08,36.00,36.139999,35.580002,35.759998,59971700,32.780739
2014-01-07,36.330002,36.490002,36.209999,36.41,35802800,33.376587
2014-01-06,36.849998,36.889999,36.110001,36.130001,43603700,33.119916
2014-01-03,37.200001,37.220001,36.599998,36.91,31134800,33.834931
2014-01-02,37.349998,37.400002,37.099998,37.16,30632200,34.064103
2013-12-31,37.400002,37.580002,37.220001,37.41,17503500,34.293274
2013-12-30,37.220001,37.380001,36.900002,37.290001,16290500,34.183273
2013-12-27,37.580002,37.619999,37.169998,37.290001,14563000,34.183273
2013-12-26,37.200001,37.490002,37.169998,37.439999,17612800,34.320774
2013-12-24,36.720001,37.169998,36.639999,37.080002,14243000,33.990769
2013-12-23,36.810001,36.889999,36.549999,36.619999,25128700,33.56909
2013-12-20,36.200001,36.93,36.189999,36.799999,62649100,33.734094
2013-12-19,36.509998,36.549999,36.080002,36.25,34160100,33.229917
2013-12-18,36.360001,36.599998,35.529999,36.580002,63192100,33.532426
2013-12-17,36.939999,37.110001,36.330002,36.52,45687700,33.477423
2013-12-16,36.73,37.00,36.540001,36.889999,31734200,33.816596
2013-12-13,37.419998,37.450001,36.619999,36.689999,40066100,33.633258
2013-12-12,37.639999,37.639999,37.18,37.220001,36012800,34.119105
2013-12-11,38.060001,38.299999,37.389999,37.610001,39853400,34.476613
2013-12-10,38.610001,38.900002,38.02,38.110001,37828600,34.934956
2013-12-09,38.560001,38.869999,38.369999,38.709999,30286000,35.484967
2013-12-06,38.419998,38.549999,37.990002,38.360001,36457300,35.164128
2013-12-05,38.849998,38.880001,37.18,38.00,116305000,34.83412
2013-12-04,38.209999,38.98,38.119999,38.939999,51983600,35.695805
2013-12-03,38.139999,38.490002,38.080002,38.310001,52109800,35.118294
2013-12-02,38.09,38.779999,38.060001,38.450001,42950400,35.24663
2013-11-29,37.82,38.290001,37.82,38.130001,22090400,34.95329
2013-11-27,37.57,37.759998,37.490002,37.599998,26002100,34.467444
2013-11-26,37.57,37.650002,37.349998,37.349998,34465300,34.238272
2013-11-25,37.93,37.950001,37.57,37.639999,30646800,34.504112
2013-11-22,37.529999,37.68,37.330002,37.57,27982000,34.439944
2013-11-21,37.27,37.529999,37.259998,37.400002,23064700,34.284109
2013-11-20,36.919998,37.41,36.860001,37.080002,32229900,33.990769
2013-11-19,36.849998,37.23,36.669998,36.740002,44275000,33.679095
2013-11-18,37.349998,37.580002,37.07,37.200001,53277500,33.844099
2013-11-15,37.950001,38.02,37.720001,37.84,50601300,34.426363
2013-11-14,37.869999,38.130001,37.720001,38.02,46183700,34.590125
2013-11-13,36.98,38.16,36.900002,38.16,44957600,34.717494
2013-11-12,37.380001,37.599998,37.200001,37.360001,31651600,33.989665
2013-11-11,37.689999,37.779999,37.349998,37.59,26872500,34.198916
2013-11-08,37.669998,37.779999,37.34,37.779999,36737800,34.371774
2013-11-07,37.959999,38.009998,37.43,37.50,60437400,34.117035
2013-11-06,37.240002,38.220001,37.060001,38.18,88948800,34.735691
2013-11-05,35.790001,36.709999,35.77,36.639999,51681900,33.334617
2013-11-04,35.59,35.98,35.549999,35.939999,28060700,32.697765
2013-11-01,35.669998,35.689999,35.389999,35.529999,40264600,32.324752
2013-10-31,35.66,35.689999,35.34,35.41,41682300,32.215579
2013-10-30,35.529999,35.790001,35.43,35.540001,36997700,32.333852
2013-10-29,35.630001,35.720001,35.259998,35.52,31702200,32.315656
2013-10-28,35.610001,35.73,35.27,35.57,38383600,32.361144
2013-10-25,35.880001,36.290001,35.470001,35.73,113494000,32.50671
2013-10-24,33.82,34.099998,33.57,33.720001,53209700,30.678039
2013-10-23,34.349998,34.490002,33.669998,33.759998,58600500,30.714428
2013-10-22,35.02,35.099998,34.52,34.580002,40438500,31.460457
2013-10-21,34.98,35.200001,34.91,34.990002,27433500,31.833469
2013-10-18,34.82,34.990002,34.330002,34.959999,41811700,31.806173
2013-10-17,34.450001,34.990002,34.369999,34.919998,31359200,31.769781
2013-10-16,34.599998,34.900002,34.560001,34.639999,35111600,31.515042
2013-10-15,34.669998,34.990002,34.470001,34.490002,47097800,31.378576
2013-10-14,33.900002,34.50,33.779999,34.450001,27757900,31.342183
2013-10-11,33.68,34.139999,33.68,34.130001,30033300,31.051052
2013-10-10,33.310001,33.889999,33.259998,33.759998,42875100,30.714428
2013-10-09,33.07,33.349998,32.959999,33.07,35878600,30.086675
2013-10-08,33.310001,33.330002,32.799999,33.009998,41017600,30.032087
2013-10-07,33.599998,33.709999,33.200001,33.299999,35069300,30.295926
2013-10-04,33.689999,33.990002,33.619999,33.880001,33008100,30.823605
2013-10-03,33.880001,34.00,33.419998,33.860001,38703800,30.805409
2013-10-02,33.360001,34.029999,33.290001,33.919998,46946800,30.859994
2013-10-01,33.349998,33.610001,33.299999,33.580002,36718700,30.550669
2013-09-30,33.00,33.310001,32.700001,33.279999,39839500,30.27773
2013-09-27,32.880001,33.75,32.869999,33.27,55348000,30.268634
2013-09-26,32.639999,33.00,32.59,32.77,28504000,29.81374
2013-09-25,32.490002,32.799999,32.400002,32.509998,28907500,29.577193
2013-09-24,32.869999,32.869999,32.150002,32.450001,40685000,29.522608
2013-09-23,32.540001,32.970001,32.50,32.740002,39826100,29.786447
2013-09-20,33.41,33.48,32.689999,32.790001,102904900,29.831936
2013-09-19,33.48,33.68,33.32,33.639999,42026600,30.605254
2013-09-18,32.990002,33.400002,32.830002,33.32,64099900,30.314122
2013-09-17,33.419998,33.470001,32.900002,32.93,84716500,29.959306
2013-09-16,33.380001,33.50,32.73,32.799999,52839700,29.841032
2013-09-13,32.77,33.07,32.509998,33.029999,40899000,30.050283
2013-09-12,32.720001,32.779999,32.59,32.689999,32860200,29.740955
2013-09-11,32.57,32.93,32.529999,32.740002,39087500,29.786447
2013-09-10,31.90,32.400002,31.790001,32.389999,56881200,29.46802
2013-09-09,31.219999,31.790001,31.200001,31.66,49628500,28.803875
2013-09-06,31.309999,31.389999,31.129999,31.15,75434900,28.339883
2013-09-05,31.10,31.440001,30.950001,31.23,71644900,28.412666
2013-09-04,31.389999,31.469999,31.110001,31.200001,142320600,28.385374
2013-09-03,31.75,32.07,31.290001,31.879999,154507000,29.004028
2013-08-30,33.369999,33.48,33.09,33.400002,42790200,30.386907
2013-08-29,32.93,33.599998,32.799999,33.549999,45284700,30.523373
2013-08-28,33.389999,33.599998,33.00,33.02,44257400,30.041187
2013-08-27,33.52,34.099998,33.150002,33.259998,58522300,30.259534
2013-08-26,34.400002,34.669998,34.029999,34.150002,72786800,31.069248
2013-08-23,35.169998,35.200001,34.00,34.75,225493800,31.615119
2013-08-22,32.189999,32.490002,32.099998,32.389999,31169900,29.46802
2013-08-21,31.610001,32.009998,31.540001,31.610001,37409100,28.758386
2013-08-20,31.440001,31.90,31.370001,31.620001,22979600,28.767485
2013-08-19,31.76,31.969999,31.379999,31.389999,27902500,28.558232
2013-08-16,31.790001,31.99,31.66,31.799999,32866300,28.931245
2013-08-15,32.00,32.18,30.84,31.790001,33338000,28.922148
2013-08-14,32.139999,33.360001,31.700001,32.349998,48519600,29.431627
2013-08-13,32.509998,32.549999,32.209999,32.23,39464100,29.322454
2013-08-12,32.459999,32.970001,32.459999,32.869999,25493700,29.695464
2013-08-09,32.77,32.900002,32.470001,32.700001,26800700,29.541884
2013-08-08,32.240002,33.07,32.049999,32.889999,59034400,29.713533
2013-08-07,31.540001,32.099998,31.25,32.060001,38078600,28.963695
2013-08-06,31.549999,31.67,31.379999,31.58,36331500,28.530052
2013-08-05,31.90,32.00,31.639999,31.700001,30984000,28.638463
2013-08-02,31.690001,31.90,31.57,31.889999,29199900,28.810112
2013-08-01,32.060001,32.09,31.60,31.67,42557900,28.61136
2013-07-31,31.969999,32.049999,31.709999,31.84,43898400,28.764941
2013-07-30,31.780001,32.119999,31.549999,31.85,45799500,28.773976
2013-07-29,31.469999,31.60,31.40,31.540001,28870700,28.493916
2013-07-26,31.26,31.620001,31.209999,31.620001,38633600,28.566189
2013-07-25,31.620001,31.65,31.25,31.389999,63213000,28.358401
2013-07-24,32.040001,32.189999,31.889999,31.959999,52803100,28.873351
2013-07-23,31.91,32.040001,31.709999,31.82,65810400,28.746873
2013-07-22,31.700001,32.009998,31.60,32.009998,79040700,28.918521
2013-07-19,32.400002,32.669998,31.02,31.40,248428500,28.367435
2013-07-18,35.720001,35.889999,35.220001,35.439999,49547100,32.017257
2013-07-17,36.34,36.389999,35.490002,35.740002,37285100,32.288287
2013-07-16,36.009998,36.43,35.959999,36.27,36378500,32.767099
2013-07-15,35.66,36.220001,35.580002,36.169998,34142600,32.676755
2013-07-12,35.580002,35.73,35.279999,35.669998,35501200,32.225044
2013-07-11,35.00,35.77,34.900002,35.689999,53638300,32.243113
2013-07-10,34.34,34.810001,34.32,34.700001,29658800,31.348727
2013-07-09,34.580002,34.599998,34.139999,34.349998,25318500,31.032528
2013-07-08,34.349998,34.59,33.98,34.330002,32396900,31.014462
2013-07-05,34.09,34.240002,33.580002,34.209999,26085900,30.906049
2013-07-03,33.66,34.369999,33.599998,34.009998,15994400,30.725364
2013-07-02,34.41,34.439999,33.630001,33.939999,37630000,30.662125
2013-07-01,34.75,34.990002,34.330002,34.360001,31055400,31.041564
2013-06-28,34.380001,34.790001,34.34,34.540001,65545500,31.20418
2013-06-27,34.52,34.779999,34.50,34.619999,28993100,31.276452
2013-06-26,34.119999,34.48,33.889999,34.349998,48665900,31.032528
2013-06-25,34.080002,34.380001,33.459999,33.669998,44073400,30.418201
2013-06-24,32.939999,34.200001,32.57,33.720001,56109000,30.463375
2013-06-21,33.66,33.73,33.049999,33.27,85338500,30.056834
2013-06-20,34.259998,34.330002,33.369999,33.490002,54493700,30.255588
2013-06-19,34.959999,35.09,34.59,34.59,30816200,31.249351
2013-06-18,34.970001,35.169998,34.900002,34.98,28616500,31.601684
2013-06-17,34.689999,35.16,34.630001,35.00,49670100,31.619753
2013-06-14,34.549999,34.689999,34.25,34.400002,53192600,31.077702
2013-06-13,34.990002,35.02,34.59,34.720001,45654900,31.366796
2013-06-12,35.139999,35.27,34.849998,35.00,37372700,31.619753
2013-06-11,35.049999,35.18,34.68,34.84,39435900,31.475206
2013-06-10,35.509998,35.650002,35.139999,35.470001,35994500,32.044362
2013-06-07,35.25,35.779999,35.060001,35.669998,40757300,32.225044
2013-06-06,34.84,35.110001,34.490002,34.959999,37618500,31.583616
2013-06-05,34.599998,34.889999,34.43,34.779999,46025100,31.420999
2013-06-04,35.619999,35.740002,34.77,34.990002,65529500,31.610721
2013-06-03,34.919998,35.630001,34.830002,35.59,51252600,32.152772
2013-05-31,34.82,35.279999,34.790001,34.900002,56165700,31.529412
2013-05-30,34.849998,35.25,34.810001,35.029999,51131000,31.646855
2013-05-29,34.740002,35.02,34.57,34.880001,38412200,31.511344
2013-05-28,34.419998,35.18,34.41,35.02,48212100,31.637822
2013-05-24,33.919998,34.279999,33.900002,34.27,33174400,30.960256
2013-05-23,34.23,34.549999,33.900002,34.150002,51102700,30.851846
2013-05-22,34.790001,34.84,34.360001,34.610001,66047500,31.267419
2013-05-21,35.099998,35.27,34.720001,34.849998,48702400,31.484239
2013-05-20,34.73,35.099998,34.68,35.080002,54020800,31.692029
2013-05-17,34.130001,34.869999,34.099998,34.869999,60666700,31.502307
2013-05-16,33.639999,34.150002,33.549999,34.080002,59382900,30.788607
2013-05-15,33.450001,33.900002,33.43,33.849998,46303900,30.580817
2013-05-14,32.860001,33.529999,32.799999,33.529999,56870100,30.291723
2013-05-13,32.610001,33.07,32.549999,33.029999,36027600,29.632225
2013-05-10,32.669998,32.720001,32.32,32.689999,36394900,29.3272
2013-05-09,32.849998,33.00,32.59,32.66,46417800,29.300287
2013-05-08,33.07,33.240002,32.650002,32.990002,51595700,29.596342
2013-05-07,33.650002,33.790001,33.240002,33.310001,43078300,29.883424
2013-05-06,33.419998,33.91,33.25,33.75,40978300,30.27816
2013-05-03,33.23,33.52,33.080002,33.490002,46784600,30.044908
2013-05-02,32.630001,33.169998,32.389999,33.16,46059500,29.748853
2013-05-01,32.93,33.080002,32.599998,32.720001,54330900,29.354117
2013-04-30,32.560001,33.110001,32.279999,33.099998,75165200,29.695024
2013-04-29,31.799999,32.68,31.77,32.610001,59116400,29.255432
2013-04-26,31.90,31.98,31.450001,31.790001,47799300,28.519785
2013-04-25,31.709999,32.84,31.540001,31.940001,110700200,28.654354
2013-04-24,30.620001,31.92,30.60,31.76,90946600,28.49287
2013-04-23,30.700001,30.90,30.379999,30.60,59126900,27.452199
2013-04-22,30.299999,31.18,30.27,30.83,137904000,27.658538
2013-04-19,29.620001,30.24,29.610001,29.77,99790700,26.70758
2013-04-18,28.950001,28.98,28.50,28.790001,56906600,25.828393
2013-04-17,28.85,29.040001,28.60,28.83,52840700,25.864277
2013-04-16,28.90,29.139999,28.700001,28.969999,52797300,25.989875
2013-04-15,28.65,28.98,28.51,28.690001,56332900,25.738679
2013-04-12,28.85,29.02,28.66,28.790001,62886300,25.828393
2013-04-11,29.10,29.200001,28.73,28.940001,130923200,25.962962
2013-04-10,29.57,30.32,29.52,30.280001,71116700,27.165117
2013-04-09,28.73,29.82,28.68,29.610001,77733800,26.56404
2013-04-08,28.73,28.73,28.469999,28.59,34759500,25.648966
2013-04-05,28.219999,28.780001,28.110001,28.700001,50927300,25.747651
2013-04-04,28.389999,28.610001,28.27,28.60,45263200,25.657937
2013-04-03,28.75,28.950001,28.540001,28.559999,35062800,25.622051
2013-04-02,28.59,28.85,28.52,28.799999,28456500,25.837363
2013-04-01,28.639999,28.66,28.360001,28.610001,29201100,25.666909
2013-03-28,28.32,28.66,28.26,28.610001,55453800,25.666909
2013-03-27,28.139999,28.450001,28.08,28.370001,36047400,25.451598
2013-03-26,28.24,28.34,28.110001,28.16,27824300,25.263199
2013-03-25,28.299999,28.35,27.959999,28.16,44154000,25.263199
2013-03-22,28.190001,28.34,28.10,28.25,28720900,25.343941
2013-03-21,28.110001,28.360001,28.049999,28.110001,34233200,25.218344
2013-03-20,28.34,28.49,28.18,28.32,35447800,25.40674
2013-03-19,28.120001,28.219999,28.030001,28.18,51901600,25.281143
2013-03-18,27.879999,28.280001,27.809999,28.10,44809400,25.209372
2013-03-15,28.030001,28.16,27.98,28.040001,92710300,25.155545
2013-03-14,28.00,28.16,27.93,28.139999,55914800,25.245256
2013-03-13,27.870001,28.02,27.75,27.92,29093400,25.047888
2013-03-12,27.84,27.950001,27.639999,27.91,39255200,25.038917
2013-03-11,27.940001,27.969999,27.67,27.870001,36627500,25.003032
2013-03-08,28.25,28.33,27.959999,28.00,37667800,25.119659
2013-03-07,28.110001,28.280001,28.01,28.139999,29196700,25.245256
2013-03-06,28.209999,28.23,27.780001,28.09,51448500,25.200401
2013-03-05,28.290001,28.540001,28.16,28.35,41432200,25.433655
2013-03-04,27.85,28.15,27.700001,28.15,38157500,25.254228
2013-03-01,27.719999,27.98,27.52,27.950001,34849700,25.074803
2013-02-28,27.879999,27.969999,27.74,27.799999,35840200,24.940232
2013-02-27,27.42,28.00,27.33,27.809999,36394700,24.949203
2013-02-26,27.379999,27.60,27.34,27.370001,49923300,24.554467
2013-02-25,27.969999,28.049999,27.370001,27.370001,48011800,24.554467
2013-02-22,27.68,27.76,27.48,27.76,31425900,24.904348
2013-02-21,27.74,27.74,27.23,27.49,49078500,24.662122
2013-02-20,28.129999,28.200001,27.83,27.870001,44110200,25.003032
2013-02-19,27.879999,28.09,27.799999,28.049999,38781400,25.164515
2013-02-15,28.040001,28.16,27.879999,28.01,49650900,24.92229
2013-02-14,27.92,28.059999,27.870001,28.040001,32663200,24.948984
2013-02-13,27.93,28.110001,27.879999,28.030001,41715600,24.940086
2013-02-12,27.879999,28.00,27.75,27.879999,35990900,24.80662
2013-02-11,27.65,27.92,27.50,27.860001,32247700,24.788826
2013-02-08,27.35,27.709999,27.309999,27.549999,33318500,24.512998
2013-02-07,27.35,27.389999,27.10,27.280001,38028300,24.272763
2013-02-06,27.379999,27.540001,27.25,27.34,41889600,24.326148
2013-02-05,27.620001,27.66,27.360001,27.50,35410400,24.46851
2013-02-04,27.870001,28.02,27.42,27.440001,50540000,24.415125
2013-02-01,27.67,28.049999,27.549999,27.93,55565900,24.851109
2013-01-31,27.790001,27.969999,27.40,27.450001,50530000,24.424023
2013-01-30,28.01,28.190001,27.76,27.85,43580500,24.779928
2013-01-29,27.82,28.129999,27.60,28.01,49242600,24.92229
2013-01-28,28.01,28.23,27.76,27.91,56056500,24.833313
2013-01-25,27.58,28.23,27.389999,27.879999,81847700,24.80662
2013-01-24,27.700001,28.07,27.469999,27.629999,101739300,24.584179
2013-01-23,27.200001,27.639999,27.200001,27.610001,50387700,24.566385
2013-01-22,27.299999,27.450001,27.00,27.15,58650600,24.157093
2013-01-18,27.10,27.290001,27.040001,27.25,52167700,24.246069
2013-01-17,27.190001,27.469999,27.059999,27.25,51685900,24.246069
2013-01-16,27.15,27.23,27.01,27.040001,41077400,24.05922
2013-01-15,26.83,27.290001,26.83,27.209999,48244500,24.210478
2013-01-14,26.90,27.08,26.76,26.889999,48324400,23.925754
2013-01-11,26.49,26.93,26.280001,26.83,55512100,23.872368
2013-01-10,26.65,26.98,26.290001,26.459999,71431300,23.543155
2013-01-09,26.719999,26.75,26.559999,26.700001,49047900,23.7567
2013-01-08,26.75,26.790001,26.459999,26.549999,44703100,23.623234
2013-01-07,26.77,26.879999,26.639999,26.690001,37110400,23.747802
2013-01-04,27.27,27.34,26.73,26.74,52521100,23.792289
2013-01-03,27.629999,27.65,27.16,27.25,48294400,24.246069
2013-01-02,27.25,27.73,27.15,27.620001,52899300,24.575283
2012-12-31,26.59,26.77,26.370001,26.709999,42749500,23.765596
2012-12-28,26.709999,26.90,26.549999,26.549999,28239900,23.623234
2012-12-27,26.889999,27.09,26.57,26.959999,39394000,23.988037
2012-12-26,27.030001,27.200001,26.700001,26.860001,31631100,23.899062
2012-12-24,27.200001,27.25,27.00,27.059999,20842400,24.077014
2012-12-21,27.450001,27.49,27.00,27.450001,98776500,24.424023
2012-12-20,27.360001,27.68,27.15,27.68,52607300,24.628668
2012-12-19,27.690001,27.73,27.25,27.309999,53519900,24.299455
2012-12-18,27.25,27.629999,27.139999,27.559999,50486900,24.521896
2012-12-17,26.790001,27.219999,26.68,27.10,42046100,24.112605
2012-12-14,27.110001,27.129999,26.700001,26.809999,42077500,23.854573
2012-12-13,27.32,27.52,26.950001,27.110001,45080100,24.121503
2012-12-12,27.530001,27.620001,27.08,27.24,43966300,24.237171
2012-12-11,27.049999,27.49,27.049999,27.32,52282800,24.308353
2012-12-10,26.559999,26.969999,26.52,26.940001,47031100,23.970243
2012-12-07,26.82,26.82,26.370001,26.459999,46162100,23.543155
2012-12-06,26.809999,26.98,26.610001,26.73,39182300,23.783392
2012-12-05,26.379999,26.93,26.26,26.67,68283800,23.730006
2012-12-04,26.50,26.629999,26.34,26.370001,49777500,23.463078
2012-12-03,26.780001,26.82,26.40,26.43,53173800,23.516463
2012-11-30,27.049999,27.129999,26.49,26.620001,83690200,23.685519
2012-11-29,27.110001,27.360001,26.860001,26.950001,69551400,23.979141
2012-11-28,27.01,27.389999,26.77,27.360001,53018400,24.343944
2012-11-27,27.360001,27.379999,27.040001,27.08,45018600,24.094809
2012-11-26,27.540001,27.58,27.17,27.389999,85198700,24.370636
2012-11-23,27.23,27.77,27.200001,27.700001,57845700,24.646464
2012-11-21,26.709999,27.17,26.67,26.950001,66360300,23.979141
2012-11-20,26.76,26.799999,26.459999,26.709999,47070400,23.765596
2012-11-19,26.799999,26.799999,26.469999,26.73,57179300,23.783392
2012-11-16,26.67,26.700001,26.34,26.52,64083300,23.596542
2012-11-15,26.879999,26.969999,26.629999,26.66,50955600,23.721108
2012-11-14,27.24,27.290001,26.799999,26.84,76086100,23.881266
2012-11-13,27.02,27.299999,26.75,27.09,131689200,24.103707
2012-11-12,28.940001,29.01,28.209999,28.219999,61112300,24.904494
2012-11-09,28.879999,29.190001,28.809999,28.83,43291200,25.442827
2012-11-08,29.120001,29.370001,28.799999,28.809999,49841800,25.425176
2012-11-07,29.530001,29.83,29.049999,29.08,57871800,25.663455
2012-11-06,29.82,30.200001,29.610001,29.860001,43401500,26.351815
2012-11-05,29.620001,29.74,29.33,29.629999,38070800,26.148836
2012-11-02,29.59,29.77,29.33,29.50,57131600,26.03411
2012-11-01,28.84,29.559999,28.82,29.52,72047900,26.051761
2012-10-31,28.549999,28.879999,28.50,28.540001,69464100,25.186899
2012-10-26,27.860001,28.34,27.84,28.209999,57790000,24.895669
2012-10-25,28.190001,28.200001,27.860001,27.879999,54084300,24.60444
2012-10-24,28.16,28.200001,27.870001,27.90,53320400,24.62209
2012-10-23,27.77,28.200001,27.76,28.049999,64414800,24.754467
2012-10-22,28.73,28.83,27.83,28.00,83374000,24.710342
2012-10-19,29.049999,29.08,28.50,28.639999,90470800,25.275149
2012-10-18,29.65,29.73,29.26,29.50,59238500,26.03411
2012-10-17,29.299999,29.639999,29.09,29.59,44206100,26.113536
2012-10-16,29.450001,29.74,29.32,29.49,47739400,26.025285
2012-10-15,29.370001,29.719999,29.25,29.51,42440200,26.042936
2012-10-12,28.969999,29.32,28.799999,29.200001,46464700,25.769357
2012-10-11,29.219999,29.25,28.870001,28.950001,41488500,25.548729
2012-10-10,29.15,29.309999,28.950001,28.98,47227100,25.575203
2012-10-09,29.68,29.74,29.18,29.280001,45121100,25.839958
2012-10-08,29.639999,29.92,29.549999,29.780001,29752000,26.281214
2012-10-05,30.23,30.25,29.74,29.85,41133900,26.34299
2012-10-04,29.969999,30.030001,29.57,30.030001,43634900,26.501842
2012-10-03,29.75,29.99,29.67,29.860001,46655900,26.351815
2012-10-02,29.68,29.889999,29.50,29.66,43338900,26.175312
2012-10-01,29.809999,29.98,29.42,29.49,54042700,26.025285
2012-09-28,30.18,30.26,29.74,29.76,54229300,26.263564
2012-09-27,30.17,30.40,29.889999,30.16,47129900,26.616568
2012-09-26,30.280001,30.60,30.040001,30.17,54672000,26.625393
2012-09-25,30.950001,31.00,30.360001,30.389999,54266400,26.819546
2012-09-24,31.00,31.07,30.639999,30.780001,46825900,27.163726
2012-09-21,31.43,31.610001,31.09,31.190001,102348900,27.525556
2012-09-20,30.950001,31.48,30.91,31.450001,45543000,27.75501
2012-09-19,31.09,31.190001,31.040001,31.049999,48871900,27.402004
2012-09-18,31.10,31.209999,31.030001,31.18,34542700,27.516731
2012-09-17,31.190001,31.26,31.040001,31.209999,36488500,27.543205
2012-09-14,31.01,31.25,30.809999,31.209999,51422800,27.543205
2012-09-13,30.889999,31.18,30.40,30.940001,45047300,27.304928
2012-09-12,30.940001,31.18,30.73,30.780001,32775800,27.163726
2012-09-11,30.690001,30.91,30.610001,30.790001,25191800,27.172552
2012-09-10,30.83,30.90,30.51,30.719999,40524000,27.110775
2012-09-07,31.040001,31.07,30.73,30.950001,42649100,27.313754
2012-09-06,30.50,31.360001,30.459999,31.35,48371700,27.666758
2012-09-05,30.219999,30.530001,30.209999,30.389999,33650000,26.819546
2012-09-04,30.450001,30.66,30.15,30.389999,48556700,26.819546
2012-08-31,30.60,30.959999,30.379999,30.82,36590100,27.199026
2012-08-30,30.530001,30.610001,30.219999,30.32,23982100,26.75777
2012-08-29,30.65,30.75,30.440001,30.65,23346800,27.048999
2012-08-28,30.700001,30.799999,30.52,30.629999,23947900,27.031348
2012-08-27,30.93,30.959999,30.59,30.690001,34691100,27.0843
2012-08-24,30.25,30.629999,30.18,30.559999,22943300,26.969573
2012-08-23,30.389999,30.40,30.08,30.26,28355600,26.70482
2012-08-22,30.59,30.76,30.469999,30.540001,33437400,26.951924
2012-08-21,30.76,30.959999,30.610001,30.799999,28822700,27.181375
2012-08-20,30.82,30.85,30.58,30.74,23737700,27.128425
2012-08-17,30.92,30.92,30.59,30.90,32589900,27.269627
2012-08-16,30.360001,30.940001,30.26,30.780001,35787200,27.163726
2012-08-15,30.110001,30.280001,30.02,30.200001,24351000,26.651869
2012-08-14,30.299999,30.389999,30.01,30.129999,34551400,26.590092
2012-08-13,30.35,30.459999,30.16,30.389999,23049100,26.643044
2012-08-10,30.50,30.620001,30.25,30.42,27810300,26.669346
2012-08-09,30.389999,30.65,30.299999,30.50,24920800,26.739482
2012-08-08,30.209999,30.469999,30.110001,30.33,26257600,26.590442
2012-08-07,30.07,30.35,29.870001,30.26,28002900,26.529073
2012-08-06,30.00,30.110001,29.809999,29.950001,27471800,26.257296
2012-08-03,29.530001,29.940001,29.48,29.75,35859400,26.081954
2012-08-02,29.209999,29.530001,28.969999,29.190001,39520500,25.591
2012-08-01,29.59,29.65,29.209999,29.41,31721800,25.783874
2012-07-31,29.48,29.709999,29.33,29.469999,37620900,25.836476
2012-07-30,29.75,29.82,29.459999,29.639999,28905000,25.985516
2012-07-27,29.48,29.85,29.18,29.76,44242600,26.090721
2012-07-26,29.23,29.50,29.09,29.16,45301400,25.564698
2012-07-25,29.24,29.33,28.780001,28.83,45579500,25.275386
2012-07-24,29.24,29.360001,28.90,29.15,47723300,25.555931
2012-07-23,29.57,29.58,29.01,29.280001,55151900,25.669904
2012-07-20,31.00,31.049999,30.049999,30.120001,64021700,26.406335
2012-07-19,30.51,30.799999,30.379999,30.67,46663200,26.888522
2012-07-18,29.60,30.450001,29.459999,30.450001,41090400,26.695648
2012-07-17,29.639999,29.860001,29.200001,29.66,33771300,26.00305
2012-07-16,29.48,29.530001,29.040001,29.440001,27900600,25.810176
2012-07-13,28.76,29.48,28.719999,29.389999,39085000,25.76634
2012-07-12,29.15,29.18,28.540001,28.629999,63523600,25.100044
2012-07-11,29.709999,29.74,29.110001,29.299999,39184900,25.687436
2012-07-10,30.08,30.219999,29.51,29.74,37534100,26.073187
2012-07-09,30.120001,30.23,29.780001,30.00,30680800,26.30113
2012-07-06,30.610001,30.700001,29.950001,30.190001,38294800,26.467704
2012-07-05,30.59,30.780001,30.379999,30.700001,28801900,26.914824
2012-07-03,30.23,30.76,30.17,30.76,20938100,26.967426
2012-07-02,30.620001,30.620001,30.209999,30.559999,30589100,26.792084
2012-06-29,30.450001,30.690001,30.139999,30.59,55227200,26.818386
2012-06-28,29.98,30.049999,29.42,29.91,45328400,26.222227
2012-06-27,30.190001,30.50,30.030001,30.17,33781700,26.45017
2012-06-26,30.00,30.27,29.940001,30.02,38421300,26.318665
2012-06-25,30.299999,30.32,29.620001,29.870001,42217200,26.187159
2012-06-22,30.299999,30.73,30.030001,30.700001,45098100,26.914824
2012-06-21,30.959999,31.139999,30.059999,30.139999,48456600,26.423868
2012-06-20,30.93,31.049999,30.639999,30.93,36257100,27.116465
2012-06-19,30.190001,31.110001,30.049999,30.700001,75725800,26.914824
2012-06-18,29.99,30.030001,29.709999,29.84,58679900,26.160857
2012-06-15,29.59,30.08,29.49,30.02,62314400,26.318665
2012-06-14,29.33,29.459999,28.879999,29.34,39458900,25.722505
2012-06-13,29.219999,29.440001,29.049999,29.129999,32984600,25.538397
2012-06-12,29.10,29.299999,28.84,29.290001,35337900,25.678671
2012-06-11,29.73,29.809999,28.82,28.90,46361900,25.336755
2012-06-08,29.209999,29.68,29.049999,29.65,42551100,25.994283
2012-06-07,29.639999,29.700001,29.17,29.23,37792800,25.626067
2012-06-06,28.879999,29.370001,28.809999,29.35,46860500,25.731273
2012-06-05,28.51,28.75,28.389999,28.51,45715400,24.994841
2012-06-04,28.620001,28.780001,28.32,28.549999,47926300,25.029908
2012-06-01,28.76,28.959999,28.440001,28.450001,56634300,24.942239
2012-05-31,29.299999,29.42,28.940001,29.190001,39134000,25.591
2012-05-30,29.35,29.48,29.120001,29.34,41585500,25.722505
2012-05-29,29.379999,29.719999,29.219999,29.559999,37758800,25.91538
2012-05-25,29.200001,29.360001,29.01,29.059999,29507200,25.477028
2012-05-24,29.16,29.299999,28.76,29.07,52575000,25.485795
2012-05-23,29.35,29.40,28.639999,29.110001,65171000,25.520864
2012-05-22,29.690001,29.879999,29.50,29.76,39504900,26.090721
2012-05-21,29.10,29.790001,29.059999,29.75,38787900,26.081954
2012-05-18,29.790001,29.809999,29.17,29.27,56205300,25.661136
2012-05-17,29.99,30.209999,29.709999,29.719999,48484000,26.055652
2012-05-16,30.309999,30.32,29.74,29.90,60083700,26.213459
2012-05-15,30.639999,30.799999,30.15,30.209999,61822800,26.485237
2012-05-14,30.82,31.040001,30.639999,30.68,40528900,26.721947
2012-05-11,30.690001,31.540001,30.690001,31.16,43459300,27.140022
2012-05-10,30.860001,31.02,30.450001,30.74,43839200,26.774206
2012-05-09,30.190001,30.83,30.10,30.76,50309300,26.791626
2012-05-08,30.48,30.780001,30.17,30.50,46328300,26.565169
2012-05-07,30.700001,30.860001,30.57,30.65,48641400,26.695817
2012-05-04,31.450001,31.57,30.92,30.98,57927200,26.983243
2012-05-03,31.879999,31.90,31.610001,31.76,31501300,27.662615
2012-05-02,31.85,31.93,31.639999,31.799999,37385300,27.697454
2012-05-01,32.049999,32.34,31.950001,32.009998,43832300,27.880361
2012-04-30,31.98,32.110001,31.92,32.02,35697200,27.889073
2012-04-27,32.119999,32.220001,31.879999,31.98,41419100,27.854232
2012-04-26,32.119999,32.23,31.92,32.110001,40308100,27.967462
2012-04-25,31.92,32.32,31.870001,32.200001,62495500,28.045851
2012-04-24,32.209999,32.52,31.83,31.92,40871100,27.801974
2012-04-23,32.310001,32.50,32.029999,32.119999,61398200,27.97617
2012-04-20,32.150002,32.889999,32.049999,32.419998,106045000,28.237466
2012-04-19,31.129999,31.68,30.940001,31.01,54781200,27.009374
2012-04-18,31.280001,31.309999,31.040001,31.139999,40552900,27.122601
2012-04-17,31.27,31.610001,31.200001,31.440001,34361500,27.383899
2012-04-16,30.99,31.190001,30.77,31.08,38124800,27.070343
2012-04-13,30.889999,31.16,30.719999,30.809999,39749200,26.835175
2012-04-12,30.48,31.040001,30.42,30.98,38304000,26.983243
2012-04-11,30.43,30.530001,30.23,30.35,43014000,26.434521
2012-04-10,31.059999,31.190001,30.299999,30.469999,54131300,26.539039
2012-04-09,31.219999,31.40,30.969999,31.10,31056400,27.087763
2012-04-05,31.15,31.629999,31.049999,31.52,50368600,27.453578
2012-04-04,31.66,31.690001,31.049999,31.209999,49455900,27.18357
2012-04-03,32.16,32.189999,31.66,31.940001,42752100,27.819394
2012-04-02,32.220001,32.459999,31.950001,32.290001,35853600,28.12424
2012-03-30,32.400002,32.41,32.040001,32.259998,31749400,28.098108
2012-03-29,32.060001,32.189999,31.809999,32.119999,37038500,27.97617
2012-03-28,32.52,32.700001,32.040001,32.189999,41344800,28.037139
2012-03-27,32.650002,32.700001,32.400002,32.52,36274900,28.324567
2012-03-26,32.189999,32.610001,32.150002,32.59,36758300,28.385536
2012-03-23,32.099998,32.110001,31.719999,32.009998,35912200,27.880361
2012-03-22,31.809999,32.09,31.790001,32.00,31749500,27.871653
2012-03-21,31.959999,32.150002,31.82,31.91,37928600,27.793263
2012-03-20,32.099998,32.150002,31.74,31.99,41566800,27.862943
2012-03-19,32.540001,32.610001,32.150002,32.200001,44789200,28.045851
2012-03-16,32.91,32.950001,32.50,32.599998,65626400,28.394245
2012-03-15,32.790001,32.939999,32.580002,32.849998,49068300,28.611992
2012-03-14,32.529999,32.880001,32.490002,32.77,41986900,28.542315
2012-03-13,32.240002,32.689999,32.150002,32.669998,48951700,28.455214
2012-03-12,31.969999,32.200001,31.82,32.040001,34073600,27.906493
2012-03-09,32.099998,32.16,31.92,31.99,34628400,27.862943
2012-03-08,32.040001,32.209999,31.90,32.009998,36747400,27.880361
2012-03-07,31.67,31.92,31.530001,31.84,34340400,27.732294
2012-03-06,31.540001,31.98,31.49,31.559999,51932900,27.488417
2012-03-05,32.009998,32.049999,31.620001,31.799999,45240000,27.697454
2012-03-02,32.310001,32.439999,32.00,32.080002,47314200,27.941333
2012-03-01,31.93,32.389999,31.85,32.290001,77344100,28.12424
2012-02-29,31.889999,32.00,31.610001,31.74,59323600,27.645195
2012-02-28,31.41,31.93,31.379999,31.870001,45230600,27.758425
2012-02-27,31.24,31.50,31.10,31.35,34568400,27.30551
2012-02-24,31.48,31.50,31.24,31.48,35575400,27.418738
2012-02-23,31.200001,31.59,31.00,31.370001,35034700,27.32293
2012-02-22,31.450001,31.68,31.18,31.27,49253200,27.235831
2012-02-21,31.18,31.610001,31.15,31.440001,50829900,27.383899
2012-02-17,31.200001,31.32,30.950001,31.25,70036500,27.218411
2012-02-16,30.309999,31.549999,30.299999,31.290001,94705100,27.253251
2012-02-15,30.33,30.389999,30.030001,30.049999,43311300,26.173223
2012-02-14,30.33,30.459999,29.85,30.25,59644000,26.347422
2012-02-13,30.629999,30.77,30.43,30.58,33319800,26.460652
2012-02-10,30.639999,30.799999,30.360001,30.50,44605300,26.391428
2012-02-09,30.68,30.799999,30.48,30.77,50481600,26.625058
2012-02-08,30.26,30.67,30.219999,30.66,49659100,26.529875
2012-02-07,30.15,30.49,30.049999,30.35,39242400,26.261635
2012-02-06,30.040001,30.219999,29.969999,30.200001,28039700,26.131841
2012-02-03,30.139999,30.40,30.09,30.24,41838500,26.166452
2012-02-02,29.90,30.17,29.709999,29.950001,52223300,25.915518
2012-02-01,29.790001,30.049999,29.76,29.889999,67409900,25.863599
2012-01-31,29.66,29.700001,29.23,29.530001,50572400,25.552095
2012-01-30,28.969999,29.620001,28.83,29.610001,51114800,25.621318
2012-01-27,29.450001,29.530001,29.17,29.23,44187700,25.292506
2012-01-26,29.610001,29.700001,29.40,29.50,49102800,25.526135
2012-01-25,29.07,29.65,29.07,29.559999,59231700,25.578053
2012-01-24,29.469999,29.57,29.18,29.34,51703300,25.387689
2012-01-23,29.549999,29.950001,29.35,29.73,76078100,25.725152
2012-01-20,28.82,29.74,28.75,29.709999,165902900,25.707846
2012-01-19,28.16,28.440001,28.030001,28.120001,74053500,24.332032
2012-01-18,28.309999,28.40,27.969999,28.23,64860600,24.427213
2012-01-17,28.40,28.65,28.17,28.26,72395300,24.453173
2012-01-13,27.93,28.25,27.790001,28.25,60196100,24.44452
2012-01-12,27.870001,28.02,27.65,28.00,49370800,24.228196
2012-01-11,27.43,27.98,27.370001,27.719999,65582400,23.985914
2012-01-10,27.93,28.15,27.75,27.84,60014400,24.08975
2012-01-09,28.049999,28.10,27.719999,27.74,59706800,24.00322
2012-01-06,27.530001,28.190001,27.530001,28.110001,99455500,24.323379
2012-01-05,27.379999,27.73,27.290001,27.68,56081400,23.951303
2012-01-04,26.82,27.469999,26.780001,27.40,80516100,23.70902
2012-01-03,26.549999,26.959999,26.389999,26.77,64731500,23.163887
2011-12-30,26.00,26.120001,25.91,25.959999,27395700,22.462998
2011-12-29,25.950001,26.049999,25.860001,26.02,22616900,22.514917
2011-12-28,26.110001,26.15,25.76,25.82,29822500,22.341858
2011-12-27,25.959999,26.139999,25.93,26.040001,21287200,22.532223
2011-12-23,25.91,26.040001,25.73,26.030001,23205800,22.52357
2011-12-22,25.82,25.860001,25.48,25.809999,35794100,22.333205
2011-12-21,26.01,26.190001,25.440001,25.76,64132500,22.289941
2011-12-20,25.860001,26.10,25.809999,26.030001,60767600,22.52357
2011-12-19,26.02,26.120001,25.459999,25.530001,52258300,22.090924
2011-12-16,25.67,26.17,25.629999,26.00,101408100,22.497611
2011-12-15,25.719999,25.879999,25.540001,25.559999,46213900,22.116882
2011-12-14,25.719999,25.860001,25.57,25.59,47926400,22.142841
2011-12-13,25.75,26.10,25.65,25.76,54581100,22.289941
2011-12-12,25.41,25.57,25.290001,25.51,38945900,22.073618
2011-12-09,25.52,25.870001,25.50,25.700001,53788500,22.238024
2011-12-08,25.48,25.719999,25.370001,25.40,60522200,21.978435
2011-12-07,25.67,25.76,25.34,25.60,62667000,22.151494
2011-12-06,25.809999,25.870001,25.610001,25.66,46175300,22.203411
2011-12-05,25.780001,25.799999,25.50,25.700001,56818400,22.238024
2011-12-02,25.59,25.620001,25.16,25.219999,52293800,21.822682
2011-12-01,25.559999,25.629999,25.200001,25.280001,48545400,21.874601
2011-11-30,25.370001,25.59,25.139999,25.58,81350900,22.134188
2011-11-29,24.82,25.040001,24.75,24.84,40917100,21.493871
2011-11-28,24.940001,24.969999,24.690001,24.870001,46766700,21.519831
2011-11-25,24.379999,24.67,24.299999,24.299999,26164600,21.026613
2011-11-23,24.610001,24.790001,24.469999,24.469999,49099700,21.173712
2011-11-22,24.889999,24.959999,24.65,24.790001,49204500,21.450608
2011-11-21,25.24,25.25,24.90,25.00,61882500,21.632318
2011-11-18,25.48,25.50,25.15,25.299999,47626200,21.891905
2011-11-17,26.01,26.040001,25.440001,25.540001,70977500,22.099577
2011-11-16,26.469999,26.51,26.040001,26.07,53262800,22.558181
2011-11-15,26.559999,26.940001,26.40,26.74,43874200,23.137927
2011-11-14,26.879999,27.00,26.65,26.76,34199200,22.982174
2011-11-11,26.58,27.08,26.57,26.91,37903000,23.110997
2011-11-10,26.469999,26.50,26.120001,26.280001,32514400,22.569938
2011-11-09,26.59,26.75,26.059999,26.200001,62950900,22.501232
2011-11-08,27.01,27.200001,26.690001,27.16,47822500,23.325704
2011-11-07,26.209999,26.82,26.129999,26.799999,42589700,23.016526
2011-11-04,26.379999,26.40,26.00,26.25,36549200,22.544173
2011-11-03,26.24,26.59,25.98,26.530001,65836100,22.784644
2011-11-02,26.10,26.200001,25.700001,26.01,53533100,22.338055
2011-11-01,26.190001,26.32,25.860001,25.99,61182600,22.320878
2011-10-31,26.76,27.00,26.620001,26.629999,46799000,22.870526
2011-10-28,27.139999,27.190001,26.790001,26.98,57712100,23.171115
2011-10-27,27.129999,27.40,26.65,27.25,74512400,23.402998
2011-10-26,27.030001,27.059999,26.10,26.59,63029900,22.836173
2011-10-25,27.08,27.23,26.719999,26.809999,53554600,23.025115
2011-10-24,27.059999,27.40,27.040001,27.190001,56897800,23.351469
2011-10-21,27.15,27.190001,26.799999,27.16,76620600,23.325704
2011-10-20,27.26,27.34,26.40,27.040001,76300200,23.222646
2011-10-19,27.370001,27.469999,27.01,27.129999,42880000,23.299938
2011-10-18,26.940001,27.40,26.799999,27.309999,52487900,23.454527
2011-10-17,27.110001,27.42,26.85,26.98,39453300,23.171115
2011-10-14,27.309999,27.50,27.02,27.27,50947700,23.420175
2011-10-13,26.76,27.200001,26.620001,27.18,43823500,23.342881
2011-10-12,27.18,27.309999,26.90,26.959999,52489800,23.153938
2011-10-11,26.860001,27.07,26.719999,27.00,38826200,23.188292
2011-10-10,26.58,26.969999,26.469999,26.940001,41815300,23.136763
2011-10-07,26.34,26.51,26.200001,26.25,52741600,22.544173
2011-10-06,25.90,26.40,25.700001,26.34,55111400,22.621467
2011-10-05,25.42,26.16,25.16,25.889999,94061300,22.234995
2011-10-04,24.299999,25.389999,24.26,25.34,83485400,21.762641
2011-10-03,24.719999,25.34,24.52,24.530001,64592500,21.066993
2011-09-30,25.200001,25.50,24.879999,24.889999,54060500,21.376169
2011-09-29,25.98,26.17,25.09,25.450001,63407300,21.857113
2011-09-28,25.93,26.370001,25.51,25.58,60736200,21.968759
2011-09-27,25.66,25.92,25.450001,25.67,55620700,22.046054
2011-09-26,25.190001,25.52,24.73,25.440001,51057600,21.848524
2011-09-23,24.90,25.15,24.690001,25.059999,64768100,21.52217
2011-09-22,25.299999,25.65,24.60,25.059999,96278300,21.52217
2011-09-21,27.049999,27.059999,25.969999,25.99,72750700,22.320878
2011-09-20,27.309999,27.50,26.93,26.98,49211900,23.171115
2011-09-19,26.799999,27.309999,26.60,27.209999,52324900,23.368644
2011-09-16,27.049999,27.27,26.83,27.120001,89681500,23.291352
2011-09-15,26.73,27.030001,26.309999,26.99,67808300,23.179703
2011-09-14,26.17,26.799999,25.889999,26.50,66739200,22.758879
2011-09-13,25.92,26.190001,25.809999,26.040001,48792300,22.36382
2011-09-12,25.440001,25.93,25.27,25.889999,55046100,22.234995
2011-09-09,26.00,26.18,25.50,25.74,64529200,22.106171
2011-09-08,26.00,26.66,25.950001,26.219999,65811900,22.518407
2011-09-07,25.690001,26.00,25.57,26.00,41961000,22.329466
2011-09-06,25.200001,25.59,25.110001,25.51,54929300,21.908642
2011-09-02,25.780001,26.00,25.66,25.799999,43894400,22.1577
2011-09-01,26.459999,26.860001,26.209999,26.209999,60510800,22.509819
2011-08-31,26.290001,26.709999,26.26,26.60,59300800,22.844762
2011-08-30,25.73,26.43,25.700001,26.23,57341400,22.526996
2011-08-29,25.530001,25.860001,25.370001,25.84,38863200,22.192054
2011-08-26,24.51,25.34,24.42,25.25,71957000,21.685347
2011-08-25,25.08,25.16,24.50,24.57,48192000,21.101345
2011-08-24,24.65,24.93,24.42,24.90,45329700,21.384758
2011-08-23,24.030001,24.75,24.030001,24.719999,59670600,21.230169
2011-08-22,24.42,24.49,23.790001,23.98,54721000,20.594638
2011-08-19,24.41,24.620001,23.91,24.049999,77397900,20.654756
2011-08-18,24.57,25.09,24.030001,24.67,105714200,21.187228
2011-08-17,25.25,25.700001,24.93,25.25,50923700,21.685347
2011-08-16,25.219999,25.59,25.049999,25.35,54251500,21.77123
2011-08-15,25.24,25.58,25.15,25.51,56529400,21.77123
2011-08-12,25.129999,25.34,24.65,25.10,64787100,21.42132
2011-08-11,24.50,25.379999,24.40,25.190001,90690100,21.49813
2011-08-10,24.950001,25.09,24.10,24.200001,127819900,20.653225
2011-08-09,24.709999,25.620001,24.030001,25.58,126268900,21.83097
2011-08-08,25.02,25.60,24.389999,24.48,134257200,20.892187
2011-08-05,25.969999,26.10,25.23,25.68,112071700,21.916315
2011-08-04,26.530001,26.870001,25.93,25.940001,92949500,22.138209
2011-08-03,26.83,27.00,26.48,26.92,64581200,22.974579
2011-08-02,26.98,27.450001,26.76,26.799999,63883100,22.872165
2011-08-01,27.51,27.690001,26.75,27.27,61838400,23.273283
2011-07-29,27.52,27.709999,27.26,27.40,104394800,23.384229
2011-07-28,27.290001,28.07,27.209999,27.719999,83761400,23.657329
2011-07-27,27.879999,27.99,27.200001,27.33,71488700,23.324489
2011-07-26,27.82,28.15,27.780001,28.08,74636500,23.964568
2011-07-25,27.26,28.09,27.190001,27.91,108482400,23.819483
2011-07-22,26.860001,27.549999,26.68,27.530001,76380600,23.495177
2011-07-21,27.040001,27.309999,26.65,27.10,81737400,23.128198
2011-07-20,27.280001,27.35,26.98,27.059999,49795400,23.09406
2011-07-19,26.809999,27.639999,26.780001,27.540001,86730600,23.503712
2011-07-18,26.629999,26.90,26.26,26.59,44501900,22.692944
2011-07-15,26.469999,26.93,26.469999,26.780001,49132400,22.855098
2011-07-14,26.620001,27.01,26.360001,26.469999,46382300,22.590531
2011-07-13,26.60,26.959999,26.51,26.629999,40861800,22.727081
2011-07-12,26.549999,26.790001,26.34,26.540001,47319300,22.650273
2011-07-11,26.620001,26.799999,26.49,26.629999,43999800,22.727081
2011-07-08,26.540001,26.98,26.51,26.92,58320700,22.974579
2011-07-07,26.49,26.879999,26.360001,26.77,51946500,22.846563
2011-07-06,25.969999,26.370001,25.959999,26.33,48744200,22.47105
2011-07-05,26.10,26.15,25.90,26.030001,37805300,22.215019
2011-07-01,25.93,26.17,25.84,26.02,52906200,22.206484
2011-06-30,25.74,26.00,25.66,26.00,52535400,22.189415
2011-06-29,25.709999,25.709999,25.360001,25.620001,66051000,21.865109
2011-06-28,25.299999,25.92,25.16,25.799999,81032100,22.018726
2011-06-27,24.23,25.459999,24.23,25.200001,92044200,21.506664
2011-06-24,24.51,24.540001,24.190001,24.299999,101387200,20.738568
2011-06-23,24.440001,24.65,24.200001,24.629999,59470400,21.020203
2011-06-22,24.60,24.809999,24.59,24.65,44287300,21.037272
2011-06-21,24.52,24.860001,24.40,24.76,49708700,21.131151
2011-06-20,24.17,24.66,24.16,24.469999,54338400,20.883653
2011-06-17,24.219999,24.299999,23.98,24.26,83320400,20.704431
2011-06-16,23.75,24.10,23.65,24.00,57184100,20.482537
2011-06-15,24.00,24.01,23.67,23.74,49410200,20.260642
2011-06-14,24.299999,24.450001,24.190001,24.219999,42894500,20.670293
2011-06-13,23.790001,24.190001,23.700001,24.040001,47572500,20.516675
2011-06-10,24.02,24.02,23.690001,23.709999,49327200,20.235039
2011-06-09,24.01,24.040001,23.82,23.959999,42878700,20.448398
2011-06-08,23.90,24.02,23.860001,23.940001,42205000,20.431331
2011-06-07,24.09,24.17,23.90,24.059999,41112600,20.533743
2011-06-06,23.889999,24.25,23.77,24.01,54778700,20.491071
2011-06-03,24.049999,24.139999,23.84,23.91,60697700,20.405727
2011-06-02,24.49,24.65,24.18,24.219999,51487800,20.670293
2011-06-01,24.99,25.10,24.370001,24.43,74033500,20.849516
2011-05-31,24.959999,25.059999,24.700001,25.01,60196300,21.34451
2011-05-27,24.68,24.90,24.65,24.76,50251000,21.131151
2011-05-26,24.35,25.030001,24.32,24.67,78016600,21.054341
2011-05-25,24.17,24.309999,24.16,24.190001,34904200,20.644691
2011-05-24,24.200001,24.290001,24.040001,24.15,47691800,20.610552
2011-05-23,24.209999,24.25,24.030001,24.17,52692500,20.627621
2011-05-20,24.719999,24.870001,24.440001,24.49,45451500,20.900722
2011-05-19,24.85,24.879999,24.50,24.719999,37783600,21.097012
2011-05-18,24.530001,24.74,24.25,24.690001,53931100,21.07141
2011-05-17,24.40,24.700001,24.27,24.52,82882100,20.926325
2011-05-16,24.959999,25.07,24.50,24.57,91350900,20.832447
2011-05-13,25.280001,25.32,24.950001,25.030001,66812300,21.222473
2011-05-12,25.35,25.389999,25.10,25.32,77400000,21.468358
2011-05-11,25.65,25.66,25.209999,25.360001,78600000,21.502274
2011-05-10,25.379999,25.85,25.25,25.67,120798700,21.765117
2011-05-09,25.799999,25.959999,25.67,25.83,38696400,21.900777
2011-05-06,26.07,26.219999,25.75,25.870001,55993000,21.934693
2011-05-05,26.049999,26.08,25.68,25.790001,55600000,21.866863
2011-05-04,25.85,26.25,25.790001,26.059999,73292300,22.09579
2011-05-03,25.60,25.85,25.49,25.809999,71892900,21.883819
2011-05-02,25.940001,26.00,25.48,25.66,89825600,21.756638
2011-04-29,26.549999,26.639999,25.360001,25.92,319317900,21.977087
2011-04-28,26.459999,26.870001,26.40,26.709999,80200000,22.646912
2011-04-27,26.299999,26.389999,26.129999,26.379999,52689000,22.367112
2011-04-26,25.74,26.440001,25.67,26.190001,69200000,22.206015
2011-04-25,25.559999,25.620001,25.34,25.610001,33525100,21.714244
2011-04-21,25.790001,25.889999,25.360001,25.52,46892300,21.637935
2011-04-20,25.540001,26.00,25.51,25.76,61608600,21.841426
2011-04-19,25.00,25.17,24.870001,25.15,38892400,21.324218
2011-04-18,25.10,25.280001,24.719999,25.08,58045100,21.264866
2011-04-15,25.459999,25.559999,25.18,25.370001,65080400,21.510753
2011-04-14,25.42,25.440001,25.09,25.42,55239900,21.553146
2011-04-13,25.65,25.870001,25.559999,25.629999,38144700,21.731201
2011-04-12,25.83,25.85,25.549999,25.639999,36920400,21.73968
2011-04-11,26.190001,26.25,25.799999,25.98,34286300,22.027959
2011-04-08,26.17,26.280001,25.959999,26.07,39887600,22.104269
2011-04-07,26.190001,26.26,25.969999,26.200001,46134700,22.214494
2011-04-06,25.98,26.309999,25.860001,26.15,65581400,22.172099
2011-04-05,25.82,26.18,25.74,25.780001,73651100,21.858384
2011-04-04,25.450001,25.66,25.41,25.549999,35433700,21.66337
2011-04-01,25.530001,25.530001,25.309999,25.48,63114200,21.604019
2011-03-31,25.60,25.68,25.34,25.389999,63233700,21.527709
2011-03-30,25.60,25.719999,25.50,25.610001,41999300,21.714244
2011-03-29,25.34,25.52,25.299999,25.49,40763500,21.612498
2011-03-28,25.66,25.719999,25.379999,25.41,48973200,21.544667
2011-03-25,25.93,25.950001,25.59,25.620001,57029800,21.722723
2011-03-24,25.60,25.870001,25.50,25.809999,38696700,21.883819
2011-03-23,25.23,25.610001,25.18,25.540001,43969000,21.654893
2011-03-22,25.299999,25.459999,25.23,25.299999,30895600,21.4514
2011-03-21,25.18,25.58,25.15,25.33,46878100,21.476837
2011-03-18,25.059999,25.18,24.799999,24.799999,85486700,21.027459
2011-03-17,25.059999,25.219999,24.75,24.780001,62497000,21.010503
2011-03-16,25.219999,25.280001,24.68,24.790001,100725400,21.018982
2011-03-15,25.08,25.469999,25.00,25.389999,76067300,21.527709
2011-03-14,25.49,25.76,25.35,25.690001,54473400,21.782075
2011-03-11,25.41,25.85,25.360001,25.68,49905800,21.773596
2011-03-10,25.620001,25.709999,25.35,25.41,66549500,21.544667
2011-03-09,25.809999,25.98,25.66,25.889999,39789100,21.95165
2011-03-08,25.77,26.02,25.65,25.91,50549800,21.968608
2011-03-07,26.129999,26.27,25.549999,25.719999,64980400,21.80751
2011-03-04,26.219999,26.24,25.799999,25.950001,70437200,22.002524
2011-03-03,26.26,26.40,26.18,26.200001,68271500,22.214494
2011-03-02,26.110001,26.370001,26.040001,26.08,48658200,22.112748
2011-03-01,26.60,26.780001,26.15,26.16,60055000,22.180578
2011-02-28,26.690001,26.860001,26.51,26.58,51379900,22.536689
2011-02-25,26.91,26.950001,26.50,26.549999,53006300,22.511251
2011-02-24,26.639999,27.059999,26.50,26.77,64494200,22.697786
2011-02-23,26.530001,26.860001,26.43,26.59,60234100,22.545168
2011-02-22,26.780001,27.10,26.52,26.59,60889000,22.545168
2011-02-18,27.129999,27.209999,26.99,27.059999,68667800,22.943671
2011-02-17,26.969999,27.370001,26.91,27.209999,57207300,23.070853
2011-02-16,27.049999,27.07,26.60,27.02,70817900,22.909757
2011-02-15,27.040001,27.33,26.950001,26.959999,44116500,22.858883
2011-02-14,27.209999,27.27,26.950001,27.23,56766200,22.95215
2011-02-11,27.76,27.809999,27.07,27.25,83939700,22.969008
2011-02-10,27.93,27.940001,27.290001,27.50,76672400,23.179733
2011-02-09,28.190001,28.26,27.91,27.969999,52905100,23.575895
2011-02-08,28.10,28.34,28.049999,28.280001,34904200,23.837195
2011-02-07,27.799999,28.34,27.790001,28.200001,68980900,23.769763
2011-02-04,27.700001,27.84,27.51,27.77,40412200,23.407316
2011-02-03,27.969999,27.969999,27.540001,27.65,60340100,23.306168
2011-02-02,27.93,28.110001,27.879999,27.940001,45824000,23.550609
2011-02-01,27.799999,28.059999,27.610001,27.99,62810700,23.592754
2011-01-31,27.77,27.90,27.42,27.73,65029000,23.373599
2011-01-28,28.90,28.93,27.450001,27.75,141249400,23.390458
2011-01-27,28.75,29.459999,28.49,28.870001,146938600,24.334506
2011-01-26,28.51,28.99,28.50,28.780001,74628800,24.258645
2011-01-25,28.139999,28.450001,28.120001,28.450001,42436600,23.980488
2011-01-24,28.02,28.559999,27.99,28.379999,52047800,23.921484
2011-01-21,28.40,28.43,28.02,28.02,58080300,23.618041
2011-01-20,28.50,28.549999,28.129999,28.35,58613600,23.896198
2011-01-19,28.459999,28.68,28.27,28.469999,50005900,23.997345
2011-01-18,28.16,28.74,28.139999,28.66,53322700,24.157496
2011-01-14,28.08,28.379999,27.91,28.299999,62688400,23.854052
2011-01-13,28.33,28.389999,28.01,28.190001,67077600,23.761334
2011-01-12,28.120001,28.59,28.07,28.549999,52631100,24.064777
2011-01-11,28.200001,28.25,28.049999,28.110001,50298900,23.693902
2011-01-10,28.26,28.40,28.040001,28.219999,57573600,23.78662
2011-01-07,28.639999,28.74,28.25,28.60,73762000,24.106923
2011-01-06,28.040001,28.85,27.860001,28.82,88026300,24.29236
2011-01-05,27.90,28.01,27.77,28.00,58998700,23.601183
2011-01-04,27.940001,28.17,27.85,28.09,54405600,23.677044
2011-01-03,28.049999,28.18,27.92,27.98,53443800,23.584324
2010-12-31,27.799999,27.92,27.629999,27.91,24752000,23.525322
2010-12-30,27.92,28.00,27.780001,27.85,20786100,23.474748
2010-12-29,27.940001,28.120001,27.879999,27.969999,19502500,23.575895
2010-12-28,27.969999,28.17,27.959999,28.01,23042200,23.609612
2010-12-27,28.120001,28.200001,27.879999,28.07,21652800,23.660185
2010-12-23,27.969999,28.32,27.959999,28.299999,24902500,23.854052
2010-12-22,28.01,28.40,27.98,28.190001,42252300,23.761334
2010-12-21,27.85,28.139999,27.76,28.07,38153000,23.660185
2010-12-20,27.950001,27.99,27.68,27.809999,52811000,23.441031
2010-12-17,27.92,28.09,27.75,27.90,87456500,23.516892
2010-12-16,27.76,27.99,27.66,27.99,57680200,23.592754
2010-12-15,27.530001,27.99,27.530001,27.85,69634200,23.474748
2010-12-14,27.309999,27.75,27.26,27.620001,64070500,23.280882
2010-12-13,27.27,27.450001,27.17,27.25,47943900,22.969008
2010-12-10,27.190001,27.40,27.110001,27.34,37625800,23.044869
2010-12-09,27.280001,27.34,27.01,27.08,47148300,22.825715
2010-12-08,26.83,27.24,26.799999,27.23,41666800,22.95215
2010-12-07,27.08,27.129999,26.85,26.870001,57860500,22.648707
2010-12-06,26.93,26.98,26.76,26.84,36264200,22.62342
2010-12-03,26.809999,27.059999,26.780001,27.02,52622000,22.775142
2010-12-02,26.24,26.98,26.200001,26.889999,91759200,22.665564
2010-12-01,25.57,26.25,25.559999,26.040001,74123500,21.949101
2010-11-30,25.049999,25.469999,25.00,25.26,75282100,21.291639
2010-11-29,25.190001,25.42,24.93,25.309999,56603600,21.333783
2010-11-26,25.209999,25.41,25.17,25.25,21356500,21.283209
2010-11-24,25.200001,25.459999,25.16,25.370001,56825900,21.384358
2010-11-23,25.57,25.60,25.09,25.120001,69742500,21.173633
2010-11-22,25.65,25.74,25.440001,25.73,53350500,21.687801
2010-11-19,25.799999,25.83,25.60,25.690001,52423200,21.654086
2010-11-18,25.709999,26.08,25.610001,25.84,59514000,21.78052
2010-11-17,25.90,25.91,25.549999,25.57,58299700,21.552937
2010-11-16,26.040001,26.040001,25.65,25.809999,65339200,21.755233
2010-11-15,26.33,26.50,26.17,26.200001,51794600,21.949101
2010-11-12,26.469999,26.52,26.10,26.27,64962200,22.007743
2010-11-11,26.68,26.719999,26.280001,26.68,62073100,22.351222
2010-11-10,27.01,27.08,26.809999,26.940001,52277300,22.569037
2010-11-09,26.809999,27.110001,26.709999,26.950001,58538600,22.577415
2010-11-08,26.68,28.870001,26.58,26.809999,71670800,22.460129
2010-11-05,27.17,27.190001,26.530001,26.85,110953700,22.49364
2010-11-04,27.41,27.43,27.01,27.139999,93599300,22.736587
2010-11-03,27.459999,27.49,26.959999,27.030001,110255300,22.644435
2010-11-02,27.059999,27.42,27.02,27.389999,54402100,22.946025
2010-11-01,26.879999,27.219999,26.700001,26.950001,61912100,22.577415
2010-10-29,27.15,27.200001,26.48,26.67,114193200,22.342844
2010-10-28,26.209999,26.379999,25.92,26.280001,80730300,22.016121
2010-10-27,25.790001,26.110001,25.620001,26.049999,64805500,21.823437
2010-10-26,25.120001,25.969999,25.059999,25.90,69304200,21.697775
2010-10-25,25.24,25.35,25.17,25.190001,50912400,21.102971
2010-10-22,25.52,25.540001,25.27,25.379999,25837900,21.262143
2010-10-21,25.40,25.540001,25.049999,25.42,50032400,21.295654
2010-10-20,25.26,25.40,25.10,25.309999,56283600,21.203501
2010-10-19,25.27,25.370001,24.950001,25.10,66150900,21.027574
2010-10-18,25.59,25.950001,25.450001,25.82,48330500,21.630754
2010-10-15,25.360001,25.549999,25.23,25.540001,68954800,21.396185
2010-10-14,25.290001,25.34,25.00,25.23,51949100,21.136481
2010-10-13,25.02,25.540001,24.889999,25.34,75336500,21.228634
2010-10-12,24.65,24.93,24.43,24.83,50141500,20.80138
2010-10-11,24.74,24.74,24.50,24.59,27587800,20.60032
2010-10-08,24.620001,24.65,24.370001,24.57,41327800,20.583565
2010-10-07,24.620001,24.75,24.280001,24.530001,50096100,20.550055
2010-10-06,24.32,24.540001,24.129999,24.43,50489700,20.46628
2010-10-05,24.059999,24.450001,23.91,24.35,78152900,20.39926
2010-10-04,23.959999,23.99,23.780001,23.91,98143400,20.030648
2010-10-01,24.77,24.82,24.299999,24.379999,62672300,20.424391
2010-09-30,24.610001,24.83,24.360001,24.49,61262700,20.516544
2010-09-29,24.629999,24.66,24.40,24.50,44318900,20.524922
2010-09-28,24.799999,24.90,24.35,24.68,56041200,20.675718
2010-09-27,24.85,24.99,24.59,24.73,43603300,20.717605
2010-09-24,24.639999,24.799999,24.58,24.780001,51948800,20.759493
2010-09-23,24.51,24.59,24.360001,24.43,46201800,20.46628
2010-09-22,24.889999,24.969999,24.360001,24.610001,94299400,20.617075
2010-09-21,25.42,25.42,25.08,25.15,52675700,21.069461
2010-09-20,25.280001,25.52,25.110001,25.43,49838700,21.304032
2010-09-17,25.40,25.530001,25.08,25.219999,70341600,21.128103
2010-09-16,25.059999,25.370001,25.049999,25.33,44548300,21.220256
2010-09-15,25.10,25.219999,24.92,25.120001,56201900,21.044329
2010-09-14,25.040001,25.35,24.889999,25.030001,87160400,20.968931
2010-09-13,24.200001,25.290001,24.09,25.110001,114680400,21.035951
2010-09-10,23.98,24.030001,23.790001,23.85,58284300,19.980384
2010-09-09,24.190001,24.209999,23.99,24.01,46028900,20.114424
2010-09-08,24.07,24.200001,23.74,23.93,65512400,20.047404
2010-09-07,24.10,24.299999,23.92,23.959999,51928700,20.072535
2010-09-03,24.24,24.450001,24.200001,24.290001,64189100,20.348995
2010-09-02,23.879999,23.950001,23.709999,23.940001,48837100,20.055782
2010-09-01,23.67,23.950001,23.540001,23.90,65235900,20.022271
2010-08-31,23.60,23.73,23.32,23.469999,66074600,19.662037
2010-08-30,23.74,23.82,23.60,23.639999,45453100,19.804455
2010-08-27,23.879999,24.02,23.51,23.93,60939400,20.047404
2010-08-26,24.09,24.190001,23.790001,23.82,49105300,19.955251
2010-08-25,24.00,24.219999,23.870001,24.10,47404800,20.189822
2010-08-24,24.09,24.35,24.00,24.040001,66522500,20.139557
2010-08-23,24.440001,24.639999,24.24,24.280001,51643000,20.340617
2010-08-20,24.309999,24.40,24.200001,24.23,49560100,20.298729
2010-08-19,24.620001,24.74,24.209999,24.440001,54064600,20.474657
2010-08-18,24.68,24.950001,24.41,24.82,46818900,20.793003
2010-08-17,24.709999,24.959999,24.60,24.709999,52912600,20.700849
2010-08-16,24.360001,24.610001,24.299999,24.50,40909700,20.416015
2010-08-13,24.35,24.67,24.24,24.40,45263500,20.332684
2010-08-12,24.42,24.68,24.360001,24.49,70240500,20.407682
2010-08-11,24.68,24.90,24.559999,24.860001,76746900,20.716006
2010-08-10,25.33,25.34,24.879999,25.07,87257700,20.890999
2010-08-09,25.549999,25.73,25.370001,25.610001,57096500,21.340986
2010-08-06,25.18,25.559999,25.02,25.549999,55982100,21.290986
2010-08-05,25.49,25.58,25.209999,25.370001,64922100,21.140992
2010-08-04,26.15,26.24,25.440001,25.73,78531900,21.440982
2010-08-03,26.200001,26.35,25.969999,26.16,56877700,21.799304
2010-08-02,25.99,26.379999,25.75,26.33,55044600,21.940966
2010-07-30,25.75,25.84,25.35,25.809999,83534800,21.507646
2010-07-29,26.129999,26.41,25.60,26.030001,69446200,21.690975
2010-07-28,26.07,26.190001,25.83,25.950001,69704800,21.62431
2010-07-27,26.139999,26.24,25.959999,26.16,60672100,21.799304
2010-07-26,25.860001,26.200001,25.799999,26.10,67249900,21.749306
2010-07-23,25.84,26.02,25.25,25.809999,108520100,21.507646
2010-07-22,25.51,25.99,25.469999,25.84,73016400,21.532646
2010-07-21,25.60,25.65,24.98,25.120001,73297300,20.932666
2010-07-20,24.860001,25.48,24.700001,25.48,45530700,21.232655
2010-07-19,24.959999,25.299999,24.91,25.23,38181800,21.024328
2010-07-16,25.51,25.639999,24.879999,24.889999,65064800,20.741004
2010-07-15,25.50,25.59,24.98,25.51,56934700,21.257655
2010-07-14,25.50,25.610001,25.120001,25.440001,72808100,21.199324
2010-07-13,25.139999,25.299999,24.90,25.129999,61928700,20.940997
2010-07-12,24.43,24.889999,24.42,24.83,49854200,20.691006
2010-07-09,24.33,24.41,24.15,24.27,53806100,20.224355
2010-07-08,24.60,24.620001,23.969999,24.41,50758100,20.341017
2010-07-07,23.82,24.32,23.610001,24.299999,79965300,20.249353
2010-07-06,23.700001,24.09,23.58,23.82,73592000,19.849366
2010-07-02,23.360001,23.48,23.049999,23.27,62485100,19.391048
2010-07-01,23.09,23.32,22.73,23.16,92239400,19.299384
2010-06-30,23.299999,23.68,22.950001,23.01,81050500,19.174388
2010-06-29,24.129999,24.200001,23.110001,23.309999,119882100,19.424379
2010-06-28,24.51,24.610001,24.120001,24.309999,73784800,20.257686
2010-06-25,25.049999,25.110001,24.309999,24.530001,156256700,20.441015
2010-06-24,25.459999,25.719999,24.93,25.00,85243400,20.832668
2010-06-23,25.780001,25.780001,25.219999,25.309999,61466200,21.090993
2010-06-22,26.16,26.450001,25.76,25.77,55985400,21.474315
2010-06-21,26.780001,26.889999,25.889999,25.950001,54625300,21.62431
2010-06-18,26.370001,26.530001,26.17,26.440001,52075600,22.03263
2010-06-17,26.559999,26.67,26.040001,26.370001,47995500,21.974299
2010-06-16,26.469999,26.58,26.23,26.32,48698000,21.932633
2010-06-15,25.75,26.65,25.74,26.58,81641500,22.149293
2010-06-14,25.860001,25.959999,25.469999,25.50,50972400,21.249322
2010-06-11,25.040001,25.719999,24.77,25.66,68057700,21.382651
2010-06-10,25.129999,25.15,24.780001,25.00,78930900,20.832668
2010-06-09,25.219999,25.52,24.75,24.790001,87794000,20.657675
2010-06-08,25.25,25.26,24.65,25.110001,87355000,20.924332
2010-06-07,25.82,25.83,25.24,25.290001,80456200,21.074328
2010-06-04,26.10,26.57,25.620001,25.790001,89832200,21.490981
2010-06-03,26.549999,26.93,26.41,26.860001,67837000,22.382619
2010-06-02,26.059999,26.48,25.73,26.459999,65718800,22.049295
2010-06-01,25.530001,26.309999,25.52,25.889999,76152400,21.574311
2010-05-28,25.84,26.120001,25.66,25.799999,67496900,21.499313
2010-05-27,25.73,26.360001,25.73,26.00,136433600,21.665975
2010-05-26,26.23,26.610001,24.559999,25.01,176684100,20.841002
2010-05-25,25.65,26.33,25.379999,26.07,98373600,21.724306
2010-05-24,26.85,26.860001,26.26,26.27,73711700,21.890968
2010-05-21,26.629999,27.110001,26.440001,26.84,117596300,22.365953
2010-05-20,27.65,27.84,27.040001,27.110001,87991100,22.590946
2010-05-19,28.52,28.690001,27.790001,28.24,61746700,23.532582
2010-05-18,28.870001,29.00,28.40,28.60,52690600,23.832573
2010-05-17,29.120001,29.23,28.450001,28.940001,46053300,24.007566
2010-05-14,29.200001,29.209999,28.639999,28.93,63334000,23.999271
2010-05-13,29.26,29.73,29.18,29.24,45188800,24.256435
2010-05-12,28.98,29.58,28.92,29.440001,47146800,24.422348
2010-05-11,28.68,29.65,28.57,28.879999,63789400,23.957791
2010-05-10,29.01,29.48,28.709999,28.940001,86653300,24.007566
2010-05-07,28.93,28.950001,27.32,28.209999,173718100,23.401984
2010-05-06,29.59,29.879999,27.91,28.98,128613000,24.040748
2010-05-05,29.77,30.09,29.690001,29.85,66833800,24.762469
2010-05-04,30.52,30.549999,29.75,30.129999,82085600,24.994746
2010-05-03,30.67,31.059999,30.58,30.860001,43989500,25.600328
2010-04-30,31.07,31.08,30.52,30.540001,63214800,25.334868
2010-04-29,30.93,31.43,30.67,31.00,52665200,25.716467
2010-04-28,30.92,31.00,30.620001,30.91,64557900,25.641806
2010-04-27,30.950001,31.25,30.75,30.85,68730900,25.592032
2010-04-26,31.00,31.280001,30.860001,31.110001,63649300,25.807719
2010-04-23,31.120001,31.58,30.65,30.959999,126766600,25.683283
2010-04-22,31.040001,31.530001,30.90,31.389999,84847600,26.039996
2010-04-21,31.33,31.50,31.23,31.33,55343100,25.990222
2010-04-20,31.219999,31.440001,31.129999,31.360001,52199500,26.01511
2010-04-19,30.77,31.25,30.76,31.040001,64970300,25.74965
2010-04-16,30.790001,30.98,30.60,30.67,88703100,25.442711
2010-04-15,30.82,30.950001,30.709999,30.870001,52745400,25.608624
2010-04-14,30.790001,31.00,30.66,30.82,68941200,25.567145
2010-04-13,30.15,30.50,30.129999,30.450001,41374600,25.260207
2010-04-12,30.25,30.49,30.209999,30.32,37068800,25.152363
2010-04-09,29.950001,30.41,29.90,30.34,54752500,25.168955
2010-04-08,29.32,29.98,29.299999,29.92,63713800,24.820538
2010-04-07,29.16,29.559999,29.139999,29.35,58318800,24.347687
2010-04-06,29.15,29.58,28.98,29.32,47366800,24.3228
2010-04-05,29.129999,29.43,29.030001,29.27,34331200,24.281322
2010-04-01,29.35,29.540001,28.620001,29.16,74768100,24.19007
2010-03-31,29.639999,29.719999,29.17,29.290001,63760000,24.297914
2010-03-30,29.629999,29.860001,29.50,29.77,34954800,24.696104
2010-03-29,29.709999,29.82,29.549999,29.59,33336000,24.546782
2010-03-26,30.09,30.200001,29.59,29.66,55595500,24.604851
2010-03-25,29.83,30.57,29.799999,30.01,73168700,24.895199
2010-03-24,29.719999,29.85,29.60,29.65,33987700,24.596556
2010-03-23,29.59,29.90,29.41,29.879999,42026600,24.787355
2010-03-22,29.50,29.700001,29.389999,29.60,37718200,24.555078
2010-03-19,29.76,29.90,29.35,29.59,81332100,24.546782
2010-03-18,29.629999,29.719999,29.50,29.610001,43845200,24.563374
2010-03-17,29.50,29.870001,29.40,29.629999,50385700,24.579964
2010-03-16,29.42,29.49,29.200001,29.370001,36723500,24.364279
2010-03-15,29.18,29.370001,29.01,29.290001,37512000,24.297914
2010-03-12,29.32,29.379999,29.040001,29.27,31700200,24.281322
2010-03-11,28.889999,29.190001,28.85,29.18,35349700,24.206661
2010-03-10,28.860001,29.110001,28.799999,28.969999,44891400,24.032452
2010-03-09,28.559999,29.110001,28.549999,28.799999,50271600,23.891426
2010-03-08,28.52,28.93,28.50,28.629999,39414500,23.750401
2010-03-05,28.66,28.68,28.42,28.59,56001800,23.717219
2010-03-04,28.459999,28.65,28.27,28.629999,42890600,23.750401
2010-03-03,28.51,28.610001,28.35,28.459999,48442100,23.609375
2010-03-02,29.08,29.299999,28.24,28.459999,93123900,23.609375
2010-03-01,28.77,29.049999,28.530001,29.02,43805400,24.073931
2010-02-26,28.65,28.85,28.51,28.67,40370600,23.783584
2010-02-25,28.27,28.65,28.02,28.60,48735300,23.725515
2010-02-24,28.52,28.790001,28.379999,28.629999,43165900,23.750401
2010-02-23,28.68,28.83,28.09,28.33,52266200,23.501532
2010-02-22,28.84,28.940001,28.65,28.73,36707100,23.833357
2010-02-19,28.790001,28.92,28.690001,28.77,44451800,23.866541
2010-02-18,28.59,29.030001,28.51,28.969999,42856500,24.032452
2010-02-17,28.530001,28.65,28.360001,28.59,45882900,23.717219
2010-02-16,28.129999,28.370001,28.02,28.35,51935600,23.518124
2010-02-12,27.809999,28.059999,27.58,27.93,81117200,23.061864
2010-02-11,27.93,28.40,27.700001,28.120001,65993700,23.218748
2010-02-10,28.030001,28.24,27.84,27.99,48591300,23.111406
2010-02-09,27.969999,28.34,27.75,28.01,59195800,23.12792
2010-02-08,28.01,28.08,27.57,27.719999,52820600,22.888466
2010-02-05,28.00,28.280001,27.57,28.02,80960100,23.136177
2010-02-04,28.379999,28.50,27.809999,27.84,77850000,22.987551
2010-02-03,28.26,28.790001,28.120001,28.629999,61397900,23.639855
2010-02-02,28.370001,28.50,28.139999,28.459999,54413700,23.499485
2010-02-01,28.389999,28.48,27.92,28.41,85931100,23.458201
2010-01-29,29.90,29.92,27.66,28.18,193888500,23.26829
2010-01-28,29.84,29.870001,28.889999,29.16,117513700,24.077477
2010-01-27,29.35,29.82,29.02,29.67,63949500,24.498586
2010-01-26,29.200001,29.85,29.09,29.50,66639900,24.358216
2010-01-25,29.24,29.66,29.10,29.32,63373000,24.20959
2010-01-22,30.00,30.200001,28.84,28.959999,102004600,23.912336
2010-01-21,30.610001,30.719999,30.00,30.01,73086700,24.779325
2010-01-20,30.809999,30.940001,30.309999,30.59,54849500,25.258232
2010-01-19,30.75,31.24,30.68,31.10,46575700,25.67934
2010-01-15,31.08,31.24,30.709999,30.860001,79913200,25.481172
2010-01-14,30.309999,31.10,30.26,30.959999,63228100,25.563741
2010-01-13,30.26,30.52,30.01,30.35,51863500,25.060064
2010-01-12,30.15,30.40,29.91,30.07,65912100,24.828866
2010-01-11,30.709999,30.76,30.120001,30.27,68754700,24.994007
2010-01-08,30.280001,30.879999,30.24,30.66,51197400,25.316031
2010-01-07,30.629999,30.700001,30.190001,30.450001,50559700,25.142634
2010-01-06,30.879999,31.08,30.52,30.77,58182400,25.406859
2010-01-05,30.85,31.10,30.639999,30.959999,49749600,25.563741
2010-01-04,30.620001,31.10,30.59,30.950001,38409100,25.555485
2009-12-31,30.98,30.99,30.48,30.48,31929700,25.167404
2009-12-30,31.15,31.290001,30.799999,30.959999,42006200,25.563741
2009-12-29,31.35,31.50,31.23,31.389999,29716200,25.918793
2009-12-28,31.00,31.18,30.889999,31.17,25384000,25.737139
2009-12-24,30.879999,31.00,30.76,31.00,11083900,25.59677
2009-12-23,30.709999,30.950001,30.690001,30.92,28362700,25.530714
2009-12-22,30.60,30.93,30.540001,30.82,36321000,25.448143
2009-12-21,30.40,30.84,30.370001,30.52,40129100,25.200433
2009-12-18,29.84,30.450001,29.799999,30.360001,94118000,25.068321
2009-12-17,29.950001,29.959999,29.57,29.60,43691200,24.440787
2009-12-16,30.07,30.41,30.040001,30.10,55737800,24.853638
2009-12-15,29.889999,30.209999,29.879999,30.02,49473200,24.787582
2009-12-14,29.91,30.16,29.90,30.110001,34651200,24.861895
2009-12-11,29.969999,30.00,29.790001,29.85,43744200,24.647212
2009-12-10,29.709999,29.959999,29.66,29.870001,45940200,24.663727
2009-12-09,29.469999,29.809999,29.25,29.709999,44713300,24.531613
2009-12-08,29.52,29.74,29.379999,29.57,37402200,24.416015
2009-12-07,29.780001,30.08,29.68,29.790001,38082700,24.597671
2009-12-04,30.049999,30.370001,29.83,29.98,58810700,24.754553
2009-12-03,29.84,30.200001,29.76,29.83,43095200,24.630698
2009-12-02,29.90,29.99,29.65,29.780001,36308600,24.589414
2009-12-01,29.52,30.049999,29.41,30.01,49904200,24.779325
2009-11-30,29.15,29.450001,29.00,29.41,44172000,24.283903
2009-11-27,29.110001,29.389999,28.75,29.219999,29357900,24.127019
2009-11-25,29.809999,29.860001,29.58,29.790001,32033500,24.597671
2009-11-24,29.950001,29.99,29.75,29.91,37341400,24.696754
2009-11-23,29.84,30.01,29.700001,29.940001,41832700,24.721526
2009-11-20,29.66,29.77,29.43,29.620001,42647100,24.457301
2009-11-19,29.99,30.00,29.700001,29.780001,51967700,24.589414
2009-11-18,30.00,30.139999,29.809999,30.110001,59431200,24.861895
2009-11-17,29.50,30.00,29.469999,30.00,75648900,24.771068
2009-11-16,29.610001,29.799999,29.370001,29.540001,54129500,24.283905
2009-11-13,29.469999,29.790001,29.370001,29.629999,53037600,24.357889
2009-11-12,29.01,29.49,29.00,29.360001,55352400,24.135932
2009-11-11,29.08,29.299999,29.02,29.120001,49693400,23.938636
2009-11-10,28.90,29.280001,28.809999,29.01,65881100,23.848208
2009-11-09,28.620001,29.00,28.530001,28.99,57518000,23.831766
2009-11-06,28.379999,28.629999,28.200001,28.52,38908500,23.445394
2009-11-05,28.52,28.74,28.280001,28.469999,52681700,23.40429
2009-11-04,27.690001,28.389999,27.620001,28.059999,63898400,23.067242
2009-11-03,27.639999,27.74,27.43,27.530001,50294800,22.631547
2009-11-02,27.700001,28.049999,27.41,27.879999,62428900,22.919269
2009-10-30,28.030001,28.40,27.66,27.73,73371800,22.795959
2009-10-29,28.07,28.41,27.85,28.219999,65225500,23.198773
2009-10-28,28.24,28.77,27.950001,28.02,73542400,23.03436
2009-10-27,28.73,28.879999,28.440001,28.59,69685800,23.502939
2009-10-26,28.129999,29.02,28.110001,28.68,124149700,23.576925
2009-10-23,29.200001,29.35,27.879999,28.02,281761000,23.03436
2009-10-22,26.559999,26.719999,26.129999,26.59,61600000,21.858802
2009-10-21,26.459999,26.75,26.389999,26.58,61672700,21.850581
2009-10-20,26.42,26.51,25.940001,26.370001,54604700,21.677947
2009-10-19,26.49,26.58,26.25,26.360001,48143200,21.669726
2009-10-16,26.450001,26.629999,26.10,26.50,56500900,21.784816
2009-10-15,25.90,26.709999,25.90,26.709999,65620100,21.957449
2009-10-14,26.139999,26.200001,25.82,25.959999,45365500,21.340898
2009-10-13,25.59,25.940001,25.52,25.809999,37749000,21.217588
2009-10-12,25.66,25.889999,25.549999,25.719999,29145800,21.143602
2009-10-09,25.57,25.790001,25.459999,25.549999,39520000,21.00385
2009-10-08,25.440001,25.90,25.219999,25.67,60521300,21.102499
2009-10-07,24.99,25.18,24.879999,25.10,38472700,20.63392
2009-10-06,24.68,25.209999,24.66,25.110001,48795300,20.642141
2009-10-05,24.98,25.059999,24.52,24.639999,60804900,20.255768
2009-10-02,24.459999,25.09,24.43,24.959999,51219700,20.518829
2009-10-01,25.41,25.469999,24.799999,24.879999,75958100,20.453064
2009-09-30,25.76,25.99,25.379999,25.719999,63533400,21.143602
2009-09-29,25.91,25.959999,25.690001,25.75,39050300,21.168264
2009-09-28,25.60,26.16,25.60,25.83,44358000,21.23403
2009-09-25,25.690001,25.82,25.52,25.549999,50158900,21.00385
2009-09-24,25.92,26.110001,25.66,25.940001,56302900,21.324458
2009-09-23,25.92,26.25,25.639999,25.709999,60599900,21.135381
2009-09-22,25.40,25.82,25.290001,25.77,61376700,21.184706
2009-09-21,25.110001,25.370001,25.10,25.299999,28878700,20.798333
2009-09-18,25.459999,25.48,25.10,25.26,68016500,20.765451
2009-09-17,25.059999,25.379999,25.059999,25.299999,42428800,20.798333
2009-09-16,25.25,25.35,24.950001,25.200001,50055800,20.716127
2009-09-15,24.969999,25.27,24.860001,25.200001,44716600,20.716127
2009-09-14,24.65,25.09,24.639999,25.00,42806800,20.551713
2009-09-11,24.93,25.17,24.809999,24.860001,54303500,20.436624
2009-09-10,24.799999,25.049999,24.65,25.00,46256000,20.551713
2009-09-09,24.74,24.950001,24.67,24.780001,49900300,20.370858
2009-09-08,24.620001,24.84,24.41,24.82,53737100,20.40374
2009-09-04,24.09,24.799999,24.08,24.620001,44999700,20.239327
2009-09-03,23.91,24.139999,23.76,24.110001,34120000,19.820072
2009-09-02,23.82,24.139999,23.780001,23.860001,40771300,19.614555
2009-09-01,24.35,24.74,23.90,24.00,62608500,19.729644
2009-08-31,24.57,24.85,24.290001,24.65,49592800,20.263989
2009-08-28,25.07,25.49,24.610001,24.68,55808000,20.288651
2009-08-27,24.41,24.780001,24.299999,24.690001,45495600,20.296872
2009-08-26,24.59,24.75,24.42,24.549999,41079000,20.181781
2009-08-25,24.60,24.82,24.459999,24.639999,43980300,20.255768
2009-08-24,24.41,24.73,24.280001,24.639999,54180900,20.255768
2009-08-21,23.93,24.42,23.77,24.41,69011400,20.066692
2009-08-20,23.60,23.870001,23.540001,23.67,39505900,19.458362
2009-08-19,23.25,23.719999,23.25,23.65,41821300,19.44192
2009-08-18,23.290001,23.65,23.27,23.58,38878900,19.384375
2009-08-17,23.32,23.60,23.23,23.25,42474400,19.006224
2009-08-14,23.620001,23.799999,23.51,23.690001,46330200,19.365912
2009-08-13,23.629999,23.85,23.40,23.620001,38954500,19.308689
2009-08-12,23.129999,23.90,23.030001,23.530001,61972300,19.235116
2009-08-11,23.32,23.40,23.049999,23.129999,33615800,18.908126
2009-08-10,23.459999,23.549999,23.299999,23.42,35261900,19.145194
2009-08-07,23.75,23.82,23.50,23.559999,46169700,19.259639
2009-08-06,23.93,23.98,23.27,23.459999,59686000,19.177892
2009-08-05,23.84,24.25,23.790001,23.809999,53310300,19.464007
2009-08-04,23.68,23.790001,23.530001,23.77,49218300,19.431309
2009-08-03,23.82,23.860001,23.50,23.83,46902900,19.480357
2009-07-31,23.77,24.07,23.50,23.52,54258200,19.226941
2009-07-30,24.200001,24.43,23.709999,23.809999,67820000,19.464007
2009-07-29,23.73,23.91,23.34,23.799999,73626900,19.455833
2009-07-28,22.99,23.549999,22.90,23.469999,70288400,19.186067
2009-07-27,23.440001,23.450001,22.90,23.110001,80950000,18.891778
2009-07-24,23.610001,23.889999,22.809999,23.450001,215135700,19.169719
2009-07-23,24.93,25.719999,24.84,25.559999,106060500,20.894583
2009-07-22,24.700001,24.90,24.51,24.799999,66192500,20.273305
2009-07-21,24.690001,24.83,24.370001,24.83,52028400,20.297829
2009-07-20,24.440001,24.530001,24.15,24.530001,47798000,20.052588
2009-07-17,24.40,24.450001,24.10,24.290001,52860100,19.856395
2009-07-16,23.93,24.440001,23.860001,24.440001,64555100,19.979016
2009-07-15,23.75,24.120001,23.559999,24.120001,67238700,19.717425
2009-07-14,23.200001,23.219999,22.860001,23.110001,45448700,18.891778
2009-07-13,22.42,23.290001,22.139999,23.23,67584000,18.989874
2009-07-10,22.190001,22.540001,22.15,22.389999,43229200,18.303197
2009-07-09,22.65,22.809999,22.370001,22.440001,46981200,18.344072
2009-07-08,22.309999,22.690001,22.00,22.559999,73023400,18.442167
2009-07-07,23.08,23.139999,22.459999,22.530001,52842500,18.417644
2009-07-06,23.209999,23.280001,22.870001,23.200001,49207700,18.965351
2009-07-02,23.76,24.040001,23.209999,23.370001,65422200,19.104321
2009-07-01,24.049999,24.299999,23.959999,24.040001,54908400,19.652027
2009-06-30,23.969999,24.24,23.629999,23.77,66452400,19.431309
2009-06-29,23.60,24.030001,23.549999,23.860001,62854900,19.504882
2009-06-26,23.57,23.690001,23.32,23.35,65126400,19.087971
2009-06-25,23.43,23.92,23.200001,23.790001,57724300,19.447659
2009-06-24,23.450001,23.75,23.360001,23.469999,54287700,19.186067
2009-06-23,23.379999,23.66,23.209999,23.34,56752700,19.079796
2009-06-22,23.950001,23.950001,23.25,23.280001,71291600,19.030748
2009-06-19,24.040001,24.34,23.75,24.07,115459000,19.67655
2009-06-18,23.620001,23.690001,23.299999,23.50,58852200,19.210592
2009-06-17,23.50,23.82,23.17,23.68,86483100,19.357737
2009-06-16,23.469999,24.110001,23.440001,23.450001,105295600,19.169719
2009-06-15,23.23,23.540001,23.02,23.42,69089600,19.145194
2009-06-12,22.90,23.379999,22.74,23.33,50963500,19.071621
2009-06-11,22.59,23.26,22.57,22.83,65124600,18.662885
2009-06-10,22.17,22.620001,22.120001,22.549999,61297200,18.433993
2009-06-09,22.059999,22.32,21.879999,22.08,50887700,18.049781
2009-06-08,21.98,22.32,21.629999,22.049999,49000600,18.025257
2009-06-05,21.959999,22.309999,21.809999,22.139999,59579200,18.098829
2009-06-04,21.77,21.90,21.58,21.83,42330000,17.845413
2009-06-03,21.309999,21.76,21.290001,21.73,56039600,17.763666
2009-06-02,21.360001,21.98,21.200001,21.40,48935700,17.4939
2009-06-01,21.00,21.50,20.860001,21.40,57317100,17.4939
2009-05-29,20.559999,20.940001,20.299999,20.889999,46134900,17.076989
2009-05-28,20.32,20.629999,20.049999,20.450001,45480800,16.717303
2009-05-27,20.25,20.60,20.07,20.129999,42892900,16.45571
2009-05-26,19.540001,20.450001,19.450001,20.34,44991700,16.62738
2009-05-22,19.93,20.17,19.469999,19.75,37318700,16.145072
2009-05-21,20.139999,20.23,19.51,19.82,58232800,16.202294
2009-05-20,20.41,20.690001,20.219999,20.379999,47450700,16.660078
2009-05-19,20.51,20.74,20.25,20.309999,51368300,16.602855
2009-05-18,20.360001,20.60,20.24,20.60,46073800,16.733652
2009-05-15,20.129999,20.50,19.98,20.219999,61289900,16.424972
2009-05-14,19.83,20.23,19.799999,20.059999,54539500,16.295002
2009-05-13,19.92,20.00,19.67,19.75,49281700,16.043186
2009-05-12,19.51,20.059999,19.469999,19.889999,71966800,16.156909
2009-05-11,19.200001,19.73,19.01,19.32,63762600,15.693891
2009-05-08,19.459999,19.639999,19.139999,19.42,67597600,15.775122
2009-05-07,19.959999,19.99,19.139999,19.32,68727200,15.693891
2009-05-06,20.059999,20.07,19.610001,19.790001,59639100,16.075679
2009-05-05,20.139999,20.24,19.639999,19.790001,66835500,16.075679
2009-05-04,20.370001,20.40,19.98,20.190001,54313400,16.400604
2009-05-01,20.190001,20.35,19.860001,20.24,63224500,16.441219
2009-04-30,20.60,21.10,20.01,20.26,87439900,16.457466
2009-04-29,20.110001,20.889999,20.059999,20.25,79301600,16.449342
2009-04-28,20.25,20.27,19.790001,19.93,76685200,16.189402
2009-04-27,20.549999,20.82,20.280001,20.40,68219600,16.571189
2009-04-24,19.82,21.200001,19.50,20.91,168478500,16.985469
2009-04-23,18.92,18.940001,18.469999,18.92,86116300,15.368966
2009-04-22,18.76,19.190001,18.700001,18.780001,59401000,15.255242
2009-04-21,18.59,19.08,18.57,18.969999,60928300,15.409581
2009-04-20,18.889999,18.950001,18.57,18.610001,62937200,15.117149
2009-04-17,19.690001,19.690001,19.00,19.200001,61398500,15.596414
2009-04-16,19.16,19.780001,18.99,19.76,67688700,16.051309
2009-04-15,19.209999,19.25,18.51,18.83,72725500,15.295857
2009-04-14,19.440001,19.549999,19.00,19.35,63796300,15.718261
2009-04-13,19.690001,19.85,19.370001,19.59,44444700,15.913216
2009-04-09,19.450001,19.700001,19.219999,19.67,55759600,15.978201
2009-04-08,18.969999,19.620001,18.959999,19.190001,56408900,15.588291
2009-04-07,18.76,19.139999,18.629999,18.76,65815200,15.238996
2009-04-06,18.540001,18.76,18.27,18.76,47476100,15.238996
2009-04-03,19.129999,19.15,18.43,18.75,81858400,15.230872
2009-04-02,19.50,19.889999,19.00,19.290001,99082300,15.669522
2009-04-01,18.23,19.360001,18.18,19.309999,96438900,15.685767
2009-03-31,17.83,18.790001,17.780001,18.370001,92423300,14.922194
2009-03-30,17.74,17.76,17.27,17.48,49633000,14.199234
2009-03-27,18.540001,18.620001,18.049999,18.129999,47670400,14.727238
2009-03-26,18.17,18.879999,18.120001,18.83,63775100,15.295857
2009-03-25,17.98,18.309999,17.52,17.879999,73927100,14.524159
2009-03-24,18.040001,18.209999,17.84,17.93,50044100,14.564776
2009-03-23,17.370001,18.59,17.309999,18.33,71600000,14.889701
2009-03-20,17.32,17.65,16.879999,17.059999,81725500,13.858063
2009-03-19,17.370001,17.450001,16.92,17.139999,58994600,13.923048
2009-03-18,17.030001,17.219999,16.60,16.959999,70710700,13.776831
2009-03-17,16.32,16.90,16.26,16.90,62481000,13.728093
2009-03-16,16.82,16.959999,16.24,16.25,67028900,13.200089
2009-03-13,16.98,17.049999,16.18,16.65,82965800,13.525014
2009-03-12,17.01,17.040001,16.48,17.01,93694100,13.817448
2009-03-11,16.629999,17.200001,16.43,17.110001,84522200,13.898679
2009-03-10,15.37,16.620001,15.25,16.48,95184200,13.386921
2009-03-09,15.20,15.74,15.10,15.15,66479100,12.306545
2009-03-06,15.35,15.62,14.87,15.28,92821400,12.412145
2009-03-05,15.86,15.88,15.27,15.27,89708500,12.404023
2009-03-04,16.120001,16.40,15.89,16.120001,69285100,13.094489
2009-03-03,16.030001,16.24,15.64,15.88,80476600,12.899534
2009-03-02,15.96,16.25,15.72,15.79,80602100,12.826425
2009-02-27,16.290001,16.52,16.10,16.15,93428000,13.118858
2009-02-26,17.049999,17.08,16.42,16.42,83219500,13.338183
2009-02-25,17.01,17.24,16.459999,16.959999,105894600,13.776831
2009-02-24,17.030001,17.35,16.360001,17.17,122674500,13.947418
2009-02-23,18.02,18.15,17.16,17.209999,70803400,13.979909
2009-02-20,17.77,18.190001,17.66,18.00,69413800,14.621638
2009-02-19,18.299999,18.379999,17.809999,17.91,49195600,14.548529
2009-02-18,18.219999,18.450001,18.00,18.120001,54946900,14.719116
2009-02-17,18.49,18.50,17.889999,18.09,75853300,14.694746
2009-02-13,19.27,19.469999,19.040001,19.09,47416000,15.401458
2009-02-12,18.969999,19.32,18.540001,19.26,75323200,15.538611
2009-02-11,18.940001,19.49,18.92,19.209999,58599000,15.498271
2009-02-10,19.25,19.799999,18.700001,18.799999,83953200,15.167491
2009-02-09,19.639999,19.77,19.26,19.440001,52196400,15.683832
2009-02-06,19.16,19.93,19.059999,19.66,86746000,15.861324
2009-02-05,18.51,19.139999,18.25,19.040001,75195200,15.36112
2009-02-04,18.540001,19.00,18.50,18.629999,75618000,15.030338
2009-02-03,17.85,18.610001,17.60,18.50,86865100,14.925457
2009-02-02,17.030001,18.129999,17.00,17.83,88871700,14.384914
2009-01-30,17.74,17.790001,17.10,17.10,62370900,13.795963
2009-01-29,17.780001,17.959999,17.559999,17.59,49192800,14.191286
2009-01-28,17.799999,18.309999,17.76,18.040001,64145500,14.554338
2009-01-27,17.780001,17.969999,17.43,17.66,61695000,14.247761
2009-01-26,17.290001,17.809999,17.23,17.629999,92476500,14.223557
2009-01-23,16.969999,17.49,16.75,17.200001,117020600,13.876642
2009-01-22,18.049999,18.18,17.07,17.110001,222436600,13.804031
2009-01-21,18.870001,19.450001,18.459999,19.379999,68340900,15.635424
2009-01-20,19.459999,19.620001,18.370001,18.48,89873000,14.909321
2009-01-16,19.629999,19.91,19.15,19.709999,79634100,15.901662
2009-01-15,19.07,19.299999,18.52,19.24,96169800,15.522475
2009-01-14,19.530001,19.68,19.01,19.09,80257500,15.401458
2009-01-13,19.52,19.99,19.52,19.82,65843500,15.990409
2009-01-12,19.709999,19.790001,19.299999,19.469999,52163500,15.708035
2009-01-09,20.17,20.299999,19.41,19.52,49815300,15.748375
2009-01-08,19.629999,20.190001,19.549999,20.120001,70255400,16.232444
2009-01-07,20.190001,20.290001,19.48,19.51,72709900,15.740307
2009-01-06,20.75,21.00,20.610001,20.76,58083400,16.748784
2009-01-05,20.200001,20.67,20.059999,20.52,61475200,16.555156
2009-01-02,19.530001,20.40,19.370001,20.33,50084000,16.401867
2008-12-31,19.309999,19.68,19.27,19.440001,46419000,15.683832
2008-12-30,19.01,19.49,19.00,19.34,43224100,15.603154
2008-12-29,19.15,19.209999,18.639999,18.959999,58512800,15.296576
2008-12-26,19.200001,19.33,19.09,19.129999,23101000,15.433729
2008-12-24,19.26,19.450001,19.10,19.17,16880400,15.466001
2008-12-23,19.280001,19.57,19.01,19.280001,47511400,15.554747
2008-12-22,19.24,19.290001,18.889999,19.18,58575400,15.474069
2008-12-19,19.42,19.799999,19.110001,19.120001,113530400,15.425662
2008-12-18,19.860001,20.02,18.99,19.299999,80759200,15.570882
2008-12-17,19.809999,20.049999,19.50,19.66,78922700,15.861324
2008-12-16,19.209999,20.18,19.00,20.110001,97688700,16.224376
2008-12-15,19.34,19.440001,18.889999,19.040001,59925900,15.36112
2008-12-12,19.15,19.85,18.700001,19.360001,78112600,15.61929
2008-12-11,20.110001,20.120001,19.309999,19.450001,83564300,15.6919
2008-12-10,20.82,20.959999,20.299999,20.610001,61499000,16.627767
2008-12-09,20.620001,21.25,20.459999,20.60,80484900,16.619699
2008-12-08,20.35,21.25,20.139999,21.01,107225000,16.950479
2008-12-05,18.91,19.98,18.469999,19.870001,91996200,16.030749
2008-12-04,19.40,19.92,18.790001,19.110001,78719200,15.417594
2008-12-03,18.65,19.90,18.60,19.870001,80961500,16.030749
2008-12-02,18.99,19.309999,18.559999,19.15,79689800,15.449865
2008-12-01,19.879999,19.950001,18.60,18.610001,79639900,15.014204
2008-11-28,20.23,20.309999,20.02,20.219999,28650800,16.313121
2008-11-26,19.73,20.68,19.73,20.49,79678300,16.530952
2008-11-25,20.860001,20.93,19.549999,19.99,92948100,16.127561
2008-11-24,19.889999,20.940001,19.870001,20.690001,125289900,16.692309
2008-11-21,18.02,19.700001,17.98,19.68,157231900,15.87746
2008-11-20,18.120001,18.84,17.50,17.530001,139532800,14.14288
2008-11-19,19.629999,19.950001,18.25,18.290001,103010500,14.756034
2008-11-18,19.50,19.66,18.75,19.620001,108966500,15.829053
2008-11-17,19.74,20.24,19.15,19.32,97289000,15.482136
2008-11-14,20.559999,21.34,19.65,20.059999,96624500,16.075137
2008-11-13,20.15,21.25,18.74,21.25,148413700,17.028747
2008-11-12,20.889999,21.00,20.280001,20.299999,90162300,16.267461
2008-11-11,21.290001,21.299999,20.790001,21.200001,78014500,16.98868
2008-11-10,21.85,21.969999,21.190001,21.299999,67106800,17.068814
2008-11-07,21.32,21.540001,21.00,21.50,71256300,17.229085
2008-11-06,21.870001,22.08,20.860001,20.879999,95509700,16.732246
2008-11-05,23.33,23.34,22.049999,22.08,81179700,17.69387
2008-11-04,23.129999,23.66,22.870001,23.530001,72123000,18.855832
2008-11-03,22.48,22.91,22.209999,22.620001,61923500,18.126601
2008-10-31,22.530001,22.91,22.120001,22.33,93055200,17.894208
2008-10-30,23.690001,23.879999,22.389999,22.629999,95323000,18.134613
2008-10-29,23.129999,23.969999,22.700001,23.00,111701800,18.431114
2008-10-28,21.639999,23.209999,21.34,23.10,134088800,18.51125
2008-10-27,21.67,21.959999,21.02,21.18,117683900,16.972653
2008-10-24,21.059999,22.860001,20.950001,21.959999,153919700,17.597707
2008-10-23,21.549999,22.59,20.889999,22.32,154774100,17.886194
2008-10-22,23.040001,23.059999,20.90,21.530001,150054800,17.253126
2008-10-21,24.299999,25.01,23.27,23.360001,100385600,18.719602
2008-10-20,24.200001,24.75,23.01,24.719999,93484300,19.809441
2008-10-17,23.57,25.110001,23.309999,23.93,133673100,19.176373
2008-10-16,22.940001,24.190001,21.309999,24.190001,161147800,19.384725
2008-10-15,23.780001,24.25,22.48,22.66,113280200,18.158654
2008-10-14,25.639999,25.73,23.60,24.10,165674900,19.312603
2008-10-13,22.860001,25.50,22.629999,25.50,144935400,20.434496
2008-10-10,21.790001,22.35,20.65,21.50,228467500,17.229085
2008-10-09,23.77,23.91,22.07,22.299999,131948700,17.870167
2008-10-08,22.90,24.299999,22.50,23.01,171598600,18.439128
2008-10-07,24.98,25.209999,23.139999,23.23,145941200,18.615425
2008-10-06,25.629999,25.99,24.139999,24.91,146374600,19.961698
2008-10-03,26.370001,27.469999,26.24,26.32,114289400,21.091605
2008-10-02,26.18,26.530001,25.700001,26.25,93819800,21.035511
2008-10-01,26.379999,26.99,26.280001,26.48,88957000,21.219822
2008-09-30,25.77,26.690001,25.540001,26.690001,107192700,21.388107
2008-09-29,26.940001,27.66,25.01,25.01,134383100,20.041834
2008-09-26,26.17,27.559999,26.139999,27.40,100744300,21.957066
2008-09-25,25.82,26.879999,25.74,26.610001,96203500,21.323998
2008-09-24,25.58,26.09,25.459999,25.719999,80250300,20.610793
2008-09-23,25.66,26.17,25.34,25.440001,92181300,20.386416
2008-09-22,26.219999,26.32,25.32,25.40,105207700,20.354361
2008-09-19,26.370001,26.40,23.50,25.16,134926100,20.162036
2008-09-18,24.799999,25.35,24.01,25.26,132291300,20.242172
2008-09-17,25.73,25.870001,24.50,24.57,106972100,19.689238
2008-09-16,26.09,26.49,25.52,25.99,111729700,20.827159
2008-09-15,26.92,27.49,26.73,26.82,82349400,21.492282
2008-09-12,27.139999,27.74,26.940001,27.620001,75628500,22.133365
2008-09-11,26.10,27.459999,26.030001,27.34,72913300,21.908986
2008-09-10,26.52,26.860001,26.25,26.440001,75064900,21.187768
2008-09-09,26.200001,26.60,26.049999,26.10,85735700,20.915308
2008-09-08,26.209999,26.33,25.67,26.120001,62110800,20.931336
2008-09-05,26.030001,26.219999,25.629999,25.65,82305200,20.554699
2008-09-04,26.74,26.889999,26.35,26.35,66141900,21.115647
2008-09-03,27.00,27.18,26.84,26.90,57127700,21.55639
2008-09-02,27.67,27.76,27.059999,27.10,66079200,21.716661
2008-08-29,27.68,27.780001,27.290001,27.290001,50735500,21.868919
2008-08-28,27.610001,28.01,27.60,27.940001,48372600,22.389798
2008-08-27,27.34,27.790001,27.129999,27.559999,33975300,22.085283
2008-08-26,27.58,27.719999,27.17,27.27,44774400,21.852891
2008-08-25,27.610001,27.84,27.459999,27.66,51381300,22.165418
2008-08-22,27.23,27.879999,27.219999,27.84,47930400,22.309662
2008-08-21,27.10,27.23,26.860001,27.18,43614200,21.780769
2008-08-20,27.540001,27.58,27.17,27.290001,41497200,21.868919
2008-08-19,27.540001,27.75,27.27,27.32,40332900,21.892958
2008-08-18,27.780001,28.049999,27.549999,27.690001,38078200,22.10131
2008-08-15,27.98,28.15,27.58,27.809999,47267400,22.19709
2008-08-14,27.82,28.280001,27.559999,27.91,49732300,22.276907
2008-08-13,28.07,28.50,27.76,27.91,51165200,22.276907
2008-08-12,27.780001,28.360001,27.58,28.120001,62813000,22.444523
2008-08-11,27.860001,28.40,27.66,27.90,68743800,22.268925
2008-08-08,27.35,28.23,27.190001,28.129999,80814100,22.452504
2008-08-07,26.90,27.75,26.73,27.389999,82565800,21.861859
2008-08-06,26.73,27.16,26.379999,27.02,95550000,21.566537
2008-08-05,25.639999,26.280001,25.50,26.209999,84297600,20.920019
2008-08-04,25.389999,25.549999,25.110001,25.280001,60588300,20.177722
2008-08-01,25.92,25.950001,25.07,25.440001,82720200,20.305429
2008-07-31,25.85,26.280001,25.709999,25.719999,60461000,20.528916
2008-07-30,26.200001,26.49,25.90,26.23,51977700,20.935982
2008-07-29,25.52,26.190001,25.40,26.110001,66368200,20.840203
2008-07-28,26.059999,26.110001,25.34,25.50,59707800,20.353319
2008-07-25,25.639999,26.219999,25.50,26.16,58682300,20.880111
2008-07-24,26.09,26.17,25.440001,25.440001,81092600,20.305429
2008-07-23,25.860001,26.84,25.85,26.43,79408800,21.095617
2008-07-22,25.540001,25.940001,25.48,25.799999,88657200,20.592769
2008-07-21,25.66,26.17,25.530001,25.639999,77575600,20.465062
2008-07-18,26.360001,26.469999,25.110001,25.860001,150277000,20.640661
2008-07-17,27.58,27.91,27.110001,27.52,96526100,21.965622
2008-07-16,26.129999,27.290001,25.92,27.26,82060400,21.758097
2008-07-15,24.93,26.639999,24.93,26.15,92719300,20.872129
2008-07-14,25.48,25.809999,25.07,25.15,51216200,20.073959
2008-07-11,25.16,25.639999,24.870001,25.25,69532600,20.153777
2008-07-10,25.200001,25.67,24.98,25.450001,57830600,20.313411
2008-07-09,25.790001,25.85,25.18,25.23,54255800,20.137813
2008-07-08,25.93,26.200001,25.51,25.85,65553200,20.632679
2008-07-07,26.110001,26.389999,25.450001,26.030001,71527600,20.776349
2008-07-03,25.969999,26.10,25.60,25.98,37074500,20.73644
2008-07-02,26.90,27.00,25.879999,25.879999,84669000,20.656623
2008-07-01,27.27,27.379999,26.440001,26.870001,100327800,21.446812
2008-06-30,27.73,27.98,27.49,27.51,57830500,21.95764
2008-06-27,27.68,27.91,27.459999,27.629999,73450200,22.053419
2008-06-26,28.030001,28.200001,27.75,27.75,67049100,22.1492
2008-06-25,27.809999,28.67,27.76,28.35,64280200,22.628102
2008-06-24,27.92,28.01,27.51,27.73,65218300,22.133236
2008-06-23,28.299999,28.41,27.790001,27.969999,57145300,22.324797
2008-06-20,28.90,28.92,28.10,28.23,97480400,22.532321
2008-06-19,28.549999,29.190001,28.33,28.93,62037800,23.09104
2008-06-18,28.549999,28.860001,28.459999,28.459999,49677800,22.7159
2008-06-17,29.040001,29.120001,28.790001,28.799999,44256700,22.987277
2008-06-16,29.02,29.110001,28.639999,28.93,74718900,23.09104
2008-06-13,28.629999,29.57,28.50,29.07,131969100,23.202783
2008-06-12,27.40,28.549999,27.190001,28.24,113996300,22.540303
2008-06-11,27.85,27.940001,27.110001,27.120001,59330800,21.646354
2008-06-10,27.360001,28.290001,27.32,27.889999,77433900,22.260943
2008-06-09,27.65,27.91,27.299999,27.709999,66787100,22.117273
2008-06-06,27.99,28.17,27.49,27.49,78500800,21.941676
2008-06-05,27.719999,28.299999,27.60,28.299999,76063400,22.588193
2008-06-04,27.280001,27.639999,27.200001,27.540001,79567400,21.981585
2008-06-03,27.91,28.309999,27.27,27.309999,86616700,21.798005
2008-06-02,28.24,28.360001,27.549999,27.799999,77028400,22.189108
2008-05-30,28.379999,28.700001,28.200001,28.32,63399200,22.604156
2008-05-29,28.209999,28.68,28.139999,28.309999,47699200,22.596175
2008-05-28,28.559999,28.57,28.040001,28.18,52318500,22.492413
2008-05-27,28.110001,28.50,28.049999,28.440001,47334500,22.699937
2008-05-23,28.26,28.33,27.950001,28.049999,48890700,22.38865
2008-05-22,28.280001,28.700001,28.18,28.469999,52203100,22.723882
2008-05-21,28.809999,29.049999,28.190001,28.25,60125100,22.548285
2008-05-20,29.299999,29.309999,28.629999,28.76,75767600,22.955351
2008-05-19,29.870001,29.889999,29.309999,29.459999,59615000,23.514069
2008-05-16,30.469999,30.48,29.92,29.99,81538200,23.937099
2008-05-15,29.98,30.530001,29.940001,30.450001,53355800,24.304258
2008-05-14,29.889999,30.26,29.73,29.93,66730400,23.88921
2008-05-13,30.00,30.129999,29.530001,29.780001,70934700,23.769485
2008-05-12,29.40,30.059999,29.35,29.99,64278800,23.849301
2008-05-09,29.209999,29.549999,28.950001,29.389999,51621200,23.372155
2008-05-08,29.280001,29.389999,29.00,29.27,69589900,23.276727
2008-05-07,29.690001,30.139999,29.08,29.209999,88775000,23.229011
2008-05-06,29.00,29.860001,28.93,29.700001,93582000,23.618681
2008-05-05,29.93,30.23,28.99,29.08,119687700,23.125631
2008-05-02,29.59,29.620001,28.860001,29.24,66024200,23.252869
2008-05-01,28.50,29.49,28.48,29.40,71699400,23.380108
2008-04-30,28.74,29.209999,28.51,28.52,74733600,22.680296
2008-04-29,28.799999,28.90,28.450001,28.639999,84428900,22.775724
2008-04-28,29.799999,29.84,28.82,28.99,97473000,23.054059
2008-04-25,30.049999,30.389999,29.60,29.83,145194900,23.722062
2008-04-24,31.629999,32.099998,31.16,31.799999,115416700,25.288688
2008-04-23,30.450001,31.459999,30.299999,31.450001,98351500,25.010354
2008-04-22,30.639999,30.700001,29.969999,30.25,67387500,24.056064
2008-04-21,30.190001,30.60,30.120001,30.42,54411700,24.191255
2008-04-18,30.01,30.10,29.610001,30.00,73658900,23.857253
2008-04-17,29.120001,29.34,28.90,29.219999,48743300,23.236964
2008-04-16,28.57,29.049999,28.379999,28.950001,54107400,23.02225
2008-04-15,28.120001,28.48,28.030001,28.25,34310000,22.46558
2008-04-14,28.24,28.309999,27.93,28.059999,43418100,22.314484
2008-04-11,28.870001,29.01,28.209999,28.280001,54373700,22.489438
2008-04-10,28.83,29.40,28.799999,29.110001,65591600,23.149489
2008-04-09,28.719999,29.040001,28.540001,28.889999,45839300,22.974534
2008-04-08,28.940001,29.00,28.540001,28.75,44733500,22.863201
2008-04-07,29.549999,29.59,29.030001,29.16,44428600,23.18925
2008-04-04,29.129999,29.26,28.74,29.16,43860800,23.18925
2008-04-03,29.00,29.32,28.799999,29.00,38961400,23.062011
2008-04-02,29.57,29.58,29.00,29.16,49499400,23.18925
2008-04-01,28.83,29.540001,28.629999,29.50,65796200,23.459632
2008-03-31,27.879999,28.59,27.84,28.379999,46780600,22.568961
2008-03-28,28.23,28.43,27.83,27.91,49244000,22.195198
2008-03-27,28.48,28.49,28.00,28.049999,47894400,22.306531
2008-03-26,29.030001,29.07,28.379999,28.559999,45868100,22.712105
2008-03-25,29.33,29.370001,28.940001,29.139999,49149000,23.173345
2008-03-24,29.33,29.40,29.059999,29.17,48294700,23.197203
2008-03-20,28.74,29.219999,28.59,29.18,60170200,23.205155
2008-03-19,29.379999,29.59,28.620001,28.620001,61442100,22.75982
2008-03-18,28.67,29.48,28.67,29.42,83695300,23.396013
2008-03-17,27.299999,28.73,27.280001,28.299999,84490100,22.505342
2008-03-14,28.719999,29.01,27.639999,27.959999,105214900,22.234959
2008-03-13,28.540001,28.99,28.16,28.620001,84552200,22.75982
2008-03-12,29.43,29.49,28.540001,28.629999,75993800,22.767771
2008-03-11,28.40,29.34,28.379999,29.280001,98740700,23.28468
2008-03-10,27.83,28.26,27.75,28.049999,72175100,22.306531
2008-03-07,27.34,28.07,27.32,27.870001,77597600,22.163389
2008-03-06,28.059999,28.17,27.50,27.57,91127700,21.924815
2008-03-05,27.75,28.41,27.700001,28.120001,106489800,22.362199
2008-03-04,27.02,27.629999,26.959999,27.59,86925600,21.940721
2008-03-03,27.24,27.389999,26.870001,26.99,76544300,21.463575
2008-02-29,27.690001,27.83,27.02,27.200001,117411400,21.630577
2008-02-28,28.02,28.27,27.799999,27.93,83002900,22.211103
2008-02-27,28.190001,28.68,28.10,28.26,75199500,22.473533
2008-02-26,27.74,28.860001,27.67,28.379999,108923500,22.568961
2008-02-25,27.65,28.24,27.48,27.84,109974300,22.139531
2008-02-22,28.24,28.389999,27.200001,27.68,125705400,22.012293
2008-02-21,28.620001,28.959999,27.959999,28.10,98776500,22.346294
2008-02-20,28.15,28.26,27.92,28.219999,93056200,22.441722
2008-02-19,28.799999,28.84,28.07,28.17,68261200,22.401961
2008-02-15,28.309999,28.639999,28.25,28.42,68166100,22.513295
2008-02-14,28.879999,29.040001,28.459999,28.50,69113500,22.576668
2008-02-13,28.620001,29.049999,28.530001,28.959999,88986200,22.941063
2008-02-12,28.43,28.620001,28.110001,28.34,84365900,22.449922
2008-02-11,28.52,28.610001,27.91,28.209999,156814100,22.34694
2008-02-08,28.290001,29.08,28.24,28.559999,124872000,22.624197
2008-02-07,28.34,28.780001,27.90,28.120001,164964900,22.275646
2008-02-06,29.280001,29.35,28.290001,28.52,138315600,22.592512
2008-02-05,29.91,29.940001,28.889999,29.07,137534100,23.028201
2008-02-04,30.49,30.719999,30.110001,30.190001,119998600,23.915425
2008-02-01,31.059999,33.25,30.25,30.450001,291138900,24.121388
2008-01-31,31.91,32.740002,31.719999,32.599998,103642200,25.824538
2008-01-30,32.560001,32.799999,32.049999,32.200001,106432600,25.507675
2008-01-29,32.849998,32.889999,32.349998,32.599998,68023000,25.824538
2008-01-28,33.02,33.099998,32.419998,32.720001,81019000,25.9196
2008-01-25,34.900002,35.00,32.869999,32.939999,196992300,26.093874
2008-01-24,32.349998,33.360001,32.119999,33.25,155640400,26.339446
2008-01-23,31.48,32.049999,31.040001,31.93,137597400,25.29379
2008-01-22,31.540001,32.529999,31.50,31.959999,108521400,25.317554
2008-01-18,33.16,34.00,32.970001,33.009998,117062000,26.149325
2008-01-17,33.540001,33.799999,32.970001,33.110001,94247800,26.228544
2008-01-16,33.419998,33.650002,32.509998,33.23,120778500,26.323602
2008-01-15,34.029999,34.380001,34.00,34.00,61606200,26.933569
2008-01-14,34.459999,34.57,34.080002,34.389999,52792200,27.242512
2008-01-11,34.139999,34.240002,33.720001,33.91,55187900,26.862274
2008-01-10,34.349998,34.50,33.779999,34.330002,72446000,27.194984
2008-01-09,33.360001,34.540001,33.349998,34.439999,74305500,27.28212
2008-01-08,34.709999,34.709999,33.400002,33.450001,79148300,26.497879
2008-01-07,34.549999,34.799999,34.25,34.610001,80164300,27.416789
2008-01-04,35.189999,35.200001,34.09,34.380001,72090800,27.234592
2008-01-03,35.220001,35.650002,34.860001,35.369999,49599600,28.018832
2008-01-02,35.790001,35.959999,35.00,35.220001,63004200,27.90001
2007-12-31,35.900002,35.990002,35.52,35.599998,35229700,28.20103
2007-12-28,36.099998,36.23,35.669998,36.119999,33447200,28.612955
2007-12-27,36.349998,36.549999,35.939999,35.970001,33311100,28.494132
2007-12-26,36.41,36.639999,36.259998,36.610001,30252400,29.001117
2007-12-24,36.130001,36.720001,36.049999,36.580002,29622600,28.977353
2007-12-21,35.900002,36.060001,35.75,36.060001,83240500,28.565427
2007-12-20,35.290001,35.790001,35.080002,35.52,59345000,28.137658
2007-12-19,34.689999,35.139999,34.380001,34.790001,58469100,27.559379
2007-12-18,34.639999,35.00,34.209999,34.740002,52791800,27.519771
2007-12-17,35.029999,35.130001,34.360001,34.389999,58121200,27.242512
2007-12-14,35.049999,35.84,35.009998,35.310001,71126200,27.971304
2007-12-13,34.48,35.450001,34.279999,35.220001,73913200,27.90001
2007-12-12,34.610001,35.09,33.93,34.470001,63345400,27.305887
2007-12-11,34.73,34.990002,33.93,34.099998,55070700,27.012784
2007-12-10,34.639999,34.950001,34.470001,34.759998,36083500,27.535612
2007-12-07,34.610001,34.700001,34.220001,34.529999,40771000,27.353415
2007-12-06,34.259998,34.610001,33.869999,34.549999,49209700,27.369258
2007-12-05,33.139999,34.52,33.029999,34.150002,84894700,27.052395
2007-12-04,32.740002,33.240002,32.630001,32.77,54801500,25.959208
2007-12-03,33.50,33.639999,32.68,32.919998,61770600,26.07803
2007-11-30,33.919998,34.119999,33.189999,33.599998,71027800,26.616702
2007-11-29,33.580002,33.93,33.310001,33.59,53633600,26.608782
2007-11-28,33.380001,33.889999,32.900002,33.700001,88585000,26.69592
2007-11-27,33.27,33.599998,32.68,33.060001,84178400,26.188936
2007-11-26,34.09,34.369999,32.93,32.970001,80335000,26.117641
2007-11-23,34.360001,34.439999,33.709999,34.110001,33467200,27.020707
2007-11-21,34.400002,34.73,34.18,34.23,89518700,27.115766
2007-11-20,34.23,34.970001,34.099998,34.580002,100009400,27.393025
2007-11-19,33.959999,34.240002,33.869999,33.959999,63026200,26.901882
2007-11-16,33.860001,34.259998,33.709999,34.09,71113800,27.004864
2007-11-15,33.759998,34.099998,33.549999,33.759998,64014100,26.743448
2007-11-14,34.619999,34.75,33.75,33.93,84063100,26.878118
2007-11-13,33.540001,34.669998,33.380001,34.459999,104311500,27.297963
2007-11-12,33.32,33.709999,33.02,33.380001,84865200,26.355289
2007-11-09,34.18,34.540001,33.650002,33.73,125136900,26.631632
2007-11-08,35.599998,35.900002,34.400002,34.740002,133742400,27.429082
2007-11-07,36.040001,36.16,35.450001,35.52,74897800,28.044933
2007-11-06,36.59,36.66,35.869999,36.41,100966700,28.747635
2007-11-05,36.759998,37.099998,36.630001,36.73,75485400,29.000292
2007-11-02,37.220001,37.50,36.419998,37.060001,96389800,29.260846
2007-11-01,36.529999,37.490002,36.360001,37.060001,152078800,29.260846
2007-10-31,35.52,37.00,35.509998,36.810001,185635800,29.063457
2007-10-30,34.369999,35.59,34.349998,35.57,107297300,28.08441
2007-10-29,34.849998,35.290001,34.450001,34.57,114655600,27.294857
2007-10-26,36.009998,36.029999,34.560001,35.029999,288121200,27.658051
2007-10-25,31.57,32.220001,31.49,31.99,169588700,25.257809
2007-10-24,30.85,31.299999,30.50,31.25,77979200,24.67354
2007-10-23,30.709999,31.120001,30.709999,30.90,49956200,24.397196
2007-10-22,30.120001,30.700001,30.120001,30.51,58785100,24.089271
2007-10-19,31.09,31.09,30.110001,30.17,75200200,23.820823
2007-10-18,31.219999,31.23,30.629999,31.16,49208600,24.60248
2007-10-17,30.75,31.23,30.65,31.08,86092400,24.539316
2007-10-16,30.24,30.58,30.23,30.32,56286200,23.939255
2007-10-15,30.10,30.33,30.00,30.040001,47150500,23.718181
2007-10-12,30.030001,30.40,29.950001,30.17,31121100,23.820823
2007-10-11,30.299999,30.629999,29.790001,29.91,50788400,23.615539
2007-10-10,30.040001,30.370001,30.030001,30.23,32251500,23.868195
2007-10-09,30.030001,30.389999,30.00,30.10,63603100,23.765554
2007-10-08,29.66,29.85,29.60,29.84,30265400,23.56027
2007-10-05,29.889999,29.99,29.73,29.84,45012300,23.56027
2007-10-04,29.559999,29.77,29.440001,29.709999,37868000,23.457627
2007-10-03,29.709999,29.85,29.290001,29.450001,37633900,23.252345
2007-10-02,29.700001,29.85,29.57,29.700001,33700900,23.449733
2007-10-01,29.459999,29.790001,29.41,29.77,43875100,23.505002
2007-09-28,29.49,29.690001,29.23,29.459999,45819100,23.260239
2007-09-27,29.700001,29.719999,29.440001,29.49,43407100,23.283926
2007-09-26,29.68,29.85,29.48,29.50,60337000,23.291822
2007-09-25,29.139999,29.559999,29.110001,29.559999,75621000,23.339195
2007-09-24,28.809999,29.610001,28.799999,29.08,104459800,22.960209
2007-09-21,28.690001,28.809999,28.440001,28.65,135636100,22.620701
2007-09-20,28.48,28.58,28.34,28.42,67168900,22.439104
2007-09-19,28.870001,28.91,28.299999,28.67,94242200,22.636493
2007-09-18,28.700001,28.969999,28.27,28.93,77462400,22.841777
2007-09-17,28.790001,28.879999,28.620001,28.73,39536500,22.683866
2007-09-14,28.98,29.110001,28.879999,29.040001,33496600,22.928628
2007-09-13,29.120001,29.26,28.959999,29.16,35288600,23.023374
2007-09-12,28.809999,29.17,28.799999,28.93,42364700,22.841777
2007-09-11,28.629999,28.950001,28.58,28.93,34380800,22.841777
2007-09-10,28.67,28.75,28.41,28.48,37247600,22.486477
2007-09-07,28.620001,28.83,28.32,28.440001,52160900,22.454896
2007-09-06,28.559999,29.01,28.549999,28.91,45430800,22.825985
2007-09-05,28.65,28.73,28.42,28.48,47669800,22.486477
2007-09-04,28.50,29.10,28.48,28.809999,45689600,22.74703
2007-08-31,28.700001,28.92,28.360001,28.73,42511900,22.683866
2007-08-30,28.42,28.93,28.32,28.450001,33690700,22.462792
2007-08-29,28.129999,28.610001,27.82,28.59,45753700,22.573329
2007-08-28,28.299999,28.49,27.91,27.93,43924400,22.052223
2007-08-27,28.610001,28.77,28.40,28.49,32789500,22.494373
2007-08-24,28.209999,28.84,28.07,28.809999,45158900,22.74703
2007-08-23,28.280001,28.33,28.10,28.299999,33886600,22.344357
2007-08-22,28.27,28.32,28.01,28.219999,44763500,22.281193
2007-08-21,28.10,28.32,27.870001,28.07,50786200,22.16276
2007-08-20,28.18,28.49,28.08,28.26,49952000,22.312776
2007-08-17,28.09,28.25,27.82,28.25,76747700,22.30488
2007-08-16,27.879999,28.35,27.51,27.809999,81447400,21.957476
2007-08-15,28.24,28.99,28.049999,28.10,48117700,22.186448
2007-08-14,28.77,28.889999,28.200001,28.27,42944100,22.320672
2007-08-13,28.940001,28.99,28.440001,28.629999,55492300,22.525954
2007-08-10,28.90,29.049999,28.26,28.709999,76576200,22.588898
2007-08-09,29.639999,30.10,28.92,29.299999,72964500,23.053107
2007-08-08,29.719999,30.01,29.209999,30.00,52898600,23.603865
2007-08-07,29.33,29.790001,29.049999,29.549999,49163000,23.249806
2007-08-06,29.049999,29.540001,28.75,29.540001,59530500,23.24194
2007-08-03,29.450001,29.780001,28.90,28.959999,61535500,22.785597
2007-08-02,29.190001,29.790001,29.02,29.52,47938300,23.226203
2007-08-01,28.950001,29.549999,28.82,29.299999,80006300,23.053107
2007-07-31,29.709999,29.719999,28.98,28.99,66554000,22.809201
2007-07-30,29.41,29.49,28.950001,29.40,67499600,23.131787
2007-07-27,29.93,30.00,29.360001,29.389999,69214600,23.123919
2007-07-26,30.24,30.530001,29.51,29.98,87025300,23.588129
2007-07-25,30.99,31.299999,30.370001,30.709999,54950100,24.162489
2007-07-24,31.01,31.48,30.709999,30.799999,59729300,24.233301
2007-07-23,31.360001,31.52,31.120001,31.190001,48910600,24.540152
2007-07-20,31.15,31.200001,30.790001,31.16,98292600,24.516548
2007-07-19,31.049999,31.84,30.93,31.51,121159300,24.791926
2007-07-18,30.51,30.969999,30.50,30.92,64414400,24.327717
2007-07-17,30.02,30.879999,30.01,30.780001,77539600,24.217566
2007-07-16,29.76,30.24,29.719999,30.030001,48023200,23.627469
2007-07-13,29.940001,30.02,29.66,29.82,42173000,23.462241
2007-07-12,29.559999,30.110001,29.440001,30.07,54302400,23.65894
2007-07-11,29.24,29.65,29.209999,29.49,48017000,23.202599
2007-07-10,29.700001,29.99,29.18,29.33,66013500,23.076712
2007-07-09,29.860001,29.950001,29.809999,29.870001,33831400,23.501582
2007-07-06,29.91,30.040001,29.66,29.969999,57541000,23.580261
2007-07-05,30.049999,30.219999,29.83,29.99,47838500,23.595997
2007-07-03,29.790001,30.219999,29.780001,30.02,35202600,23.619601
2007-07-02,29.67,29.799999,29.49,29.74,47316000,23.399298
2007-06-29,29.870001,29.93,29.040001,29.469999,71193900,23.186863
2007-06-28,29.860001,29.969999,29.68,29.83,46055200,23.47011
2007-06-27,29.360001,29.950001,29.360001,29.870001,53468600,23.501582
2007-06-26,29.549999,29.799999,29.50,29.52,48340300,23.226203
2007-06-25,29.469999,29.77,29.379999,29.49,53905800,23.202599
2007-06-22,30.00,30.10,29.450001,29.49,86219900,23.202599
2007-06-21,29.98,30.299999,29.91,30.219999,56564800,23.776959
2007-06-20,30.440001,30.51,29.959999,30.01,46861600,23.611733
2007-06-19,30.48,30.66,30.379999,30.459999,46802600,23.96579
2007-06-18,30.690001,30.719999,30.42,30.51,45412600,24.005131
2007-06-15,30.860001,30.879999,30.43,30.49,100933000,23.989395
2007-06-14,30.35,30.709999,30.299999,30.52,59065700,24.012999
2007-06-13,29.969999,30.41,29.85,30.389999,64435600,23.910715
2007-06-12,29.959999,30.24,29.77,29.85,56981800,23.485846
2007-06-11,29.940001,30.25,29.93,30.02,48467400,23.619601
2007-06-08,29.58,30.059999,29.41,30.049999,61346200,23.643204
2007-06-07,30.02,30.290001,29.59,29.620001,71971400,23.304883
2007-06-06,30.370001,30.530001,30.25,30.290001,38217500,23.832036
2007-06-05,30.620001,30.629999,30.33,30.58,44265000,24.060206
2007-06-04,30.42,30.76,30.40,30.719999,41434500,24.170357
2007-06-01,30.790001,30.90,30.549999,30.59,39469400,24.068074
2007-05-31,31.120001,31.16,30.610001,30.690001,85290500,24.146754
2007-05-30,30.549999,31.129999,30.51,31.110001,57376800,24.477208
2007-05-29,30.49,30.83,30.389999,30.790001,42373100,24.225434
2007-05-25,30.280001,30.66,30.18,30.48,47726500,23.981526
2007-05-24,30.540001,30.799999,29.959999,30.17,64046400,23.73762
2007-05-23,30.84,30.84,30.57,30.58,46322500,24.060206
2007-05-22,30.90,30.93,30.66,30.690001,39999500,24.146754
2007-05-21,30.73,31.16,30.73,31.049999,41836400,24.43
2007-05-18,30.969999,30.99,30.58,30.83,58453000,24.256905
2007-05-17,31.030001,31.139999,30.959999,30.98,41045600,24.374924
2007-05-16,31.00,31.09,30.809999,31.07,45833600,24.445736
2007-05-15,30.90,31.09,30.84,30.90,75013900,24.311981
2007-05-14,30.84,30.99,30.809999,30.969999,70188500,24.288378
2007-05-11,30.57,30.98,30.549999,30.889999,43425300,24.225637
2007-05-10,30.68,30.93,30.530001,30.58,55398600,23.982519
2007-05-09,30.700001,30.93,30.57,30.780001,51735000,24.13937
2007-05-08,30.68,30.940001,30.58,30.75,60551700,24.115842
2007-05-07,30.52,30.76,30.48,30.709999,59889100,24.084471
2007-05-04,30.68,30.700001,30.290001,30.559999,104385900,23.966833
2007-05-03,30.60,31.00,30.530001,30.969999,82036800,24.288378
2007-05-02,30.389999,30.690001,30.299999,30.610001,80686700,24.006047
2007-05-01,29.940001,30.42,29.90,30.40,73539300,23.841353
2007-04-30,30.129999,30.370001,29.940001,29.940001,67788800,23.480596
2007-04-27,30.17,30.74,30.00,30.120001,128298800,23.621762
2007-04-26,29.09,29.35,28.91,29.10,68760300,22.821822
2007-04-25,28.860001,29.00,28.690001,28.99,39475000,22.735553
2007-04-24,28.790001,28.959999,28.59,28.790001,34236700,22.578703
2007-04-23,28.959999,28.99,28.67,28.780001,41739100,22.57086
2007-04-20,28.98,29.10,28.700001,29.02,60311500,22.759081
2007-04-19,28.34,28.889999,28.26,28.690001,43648800,22.500277
2007-04-18,28.610001,28.67,28.360001,28.60,41778400,22.429694
2007-04-17,28.629999,28.889999,28.559999,28.85,33170200,22.625758
2007-04-16,28.60,28.75,28.209999,28.73,30740100,22.531647
2007-04-13,28.43,28.700001,28.10,28.610001,36002900,22.437537
2007-04-12,28.059999,28.620001,28.040001,28.540001,43762100,22.382639
2007-04-11,28.299999,28.57,27.99,28.110001,44050200,22.045409
2007-04-10,28.50,28.639999,28.219999,28.40,38643100,22.272842
2007-04-09,28.58,28.719999,28.389999,28.57,31384600,22.406166
2007-04-05,28.32,28.65,28.299999,28.549999,30131200,22.39048
2007-04-04,28.01,28.780001,27.90,28.50,63244200,22.351268
2007-04-03,27.860001,28.059999,27.75,27.870001,39821300,21.857188
2007-04-02,27.889999,27.93,27.559999,27.74,41977600,21.755234
2007-03-30,27.75,27.950001,27.50,27.870001,47061000,21.857188
2007-03-29,27.84,27.85,27.49,27.75,42629900,21.763077
2007-03-28,27.58,28.00,27.40,27.639999,46947000,21.676808
2007-03-27,28.040001,28.16,27.65,27.719999,58979800,21.739549
2007-03-26,27.940001,28.219999,27.700001,28.219999,47491500,22.131676
2007-03-23,28.219999,28.27,27.799999,28.02,50519800,21.974826
2007-03-22,28.52,28.549999,28.01,28.27,47934900,22.17089
2007-03-21,27.90,28.52,27.559999,28.52,72808200,22.366954
2007-03-20,27.93,28.16,27.76,27.84,47902400,21.83366
2007-03-19,27.34,27.83,27.200001,27.83,49412000,21.825817
2007-03-16,27.35,27.48,27.200001,27.33,65055300,21.43369
2007-03-15,27.32,27.469999,27.200001,27.280001,51757100,21.394478
2007-03-14,26.82,27.40,26.73,27.40,75730300,21.488587
2007-03-13,27.25,27.40,26.709999,26.719999,75169500,20.955294
2007-03-12,27.18,27.48,27.129999,27.440001,36516400,21.519958
2007-03-09,27.42,27.48,27.030001,27.290001,80125000,21.40232
2007-03-08,27.719999,27.85,26.60,27.32,72175200,21.425847
2007-03-07,27.76,27.90,27.549999,27.610001,52044700,21.653282
2007-03-06,27.799999,27.940001,27.65,27.83,49361800,21.825817
2007-03-05,27.49,27.91,27.41,27.549999,56454300,21.606225
2007-03-02,28.02,28.16,27.76,27.76,63254700,21.77092
2007-03-01,27.82,28.33,27.73,28.09,80175700,22.029724
2007-02-28,27.950001,28.25,27.92,28.17,86333300,22.092464
2007-02-27,28.709999,28.969999,27.790001,27.870001,87143300,21.857188
2007-02-26,28.959999,29.09,28.82,29.07,63481900,22.798293
2007-02-23,29.219999,29.280001,28.889999,28.90,63787100,22.66497
2007-02-22,29.309999,29.540001,29.16,29.389999,57754400,23.049255
2007-02-21,28.75,29.389999,28.74,29.35,68604900,23.017885
2007-02-20,28.629999,28.860001,28.469999,28.83,53978200,22.610072
2007-02-16,28.91,28.940001,28.65,28.74,109340300,22.539489
2007-02-15,29.58,29.65,29.219999,29.459999,63858100,23.104152
2007-02-14,29.17,29.690001,29.15,29.40,55588600,23.057098
2007-02-13,29.040001,29.200001,28.959999,29.01,50348100,22.751239
2007-02-12,28.889999,29.09,28.83,28.940001,52774400,22.617916
2007-02-09,29.35,29.40,28.93,28.98,69823100,22.649177
2007-02-08,29.24,29.799999,29.200001,29.26,48749000,22.86801
2007-02-07,29.639999,29.700001,29.25,29.370001,65145500,22.95398
2007-02-06,29.59,29.75,29.219999,29.51,79281100,23.063396
2007-02-05,29.969999,30.02,29.41,29.610001,99102100,23.141551
2007-02-02,30.82,30.84,30.129999,30.190001,60401700,23.594847
2007-02-01,30.84,30.940001,30.370001,30.559999,55355800,23.884018
2007-01-31,30.41,31.10,30.35,30.860001,73968400,24.118482
2007-01-30,30.57,30.639999,30.139999,30.48,61900400,23.821494
2007-01-29,30.65,30.780001,30.34,30.530001,57605900,23.860573
2007-01-26,31.219999,31.23,30.60,30.60,96103700,23.91528
2007-01-25,31.08,31.48,30.450001,30.450001,97378700,23.798049
2007-01-24,30.780001,31.299999,30.65,31.09,58527800,24.298237
2007-01-23,30.629999,30.959999,30.52,30.74,49171200,24.024696
2007-01-22,31.059999,31.120001,30.51,30.719999,56143900,24.009065
2007-01-19,30.73,31.110001,30.690001,31.110001,75826900,24.313869
2007-01-18,31.15,31.370001,30.799999,31.00,56364300,24.227898
2007-01-17,31.26,31.440001,31.01,31.10,58519600,24.306053
2007-01-16,31.26,31.450001,31.030001,31.16,62379600,24.352945
2007-01-12,30.65,31.389999,30.639999,31.209999,103972500,24.392022
2007-01-11,29.76,30.75,29.65,30.700001,99464300,23.993435
2007-01-10,29.799999,29.889999,29.43,29.66,55017400,23.180628
2007-01-09,30.00,30.18,29.73,29.959999,44636600,23.415091
2007-01-08,29.65,30.10,29.530001,29.93,50220200,23.391645
2007-01-05,29.629999,29.75,29.450001,29.639999,44607200,23.164996
2007-01-04,29.700001,29.969999,29.440001,29.809999,45774500,23.297859
2007-01-03,29.91,30.25,29.40,29.860001,76935100,23.336937
2006-12-29,29.860001,30.15,29.83,29.860001,41739800,23.336937
2006-12-28,29.860001,30.030001,29.809999,29.98,26690600,23.430722
2006-12-27,29.99,30.129999,29.91,30.02,31248400,23.461984
2006-12-26,29.530001,30.00,29.40,29.99,37098300,23.438537
2006-12-22,29.83,29.860001,29.620001,29.639999,37971700,23.164996
2006-12-21,30.129999,30.139999,29.889999,29.98,32270500,23.430722
2006-12-20,29.99,30.24,29.969999,30.09,31202100,23.516692
2006-12-19,29.709999,30.17,29.530001,29.99,53822100,23.438537
2006-12-18,30.190001,30.26,29.780001,29.889999,56986800,23.360383
2006-12-15,30.139999,30.23,30.030001,30.190001,102783700,23.594847
2006-12-14,29.540001,30.08,29.52,30.07,85866500,23.501061
2006-12-13,29.60,29.60,29.32,29.549999,46002500,23.094657
2006-12-12,29.559999,29.629999,29.219999,29.43,68529400,23.000873
2006-12-11,29.190001,29.75,29.110001,29.540001,107712000,23.086843
2006-12-08,28.82,29.40,28.799999,29.40,108854900,22.977426
2006-12-07,28.959999,29.07,28.809999,28.85,46831100,22.547577
2006-12-06,29.10,29.129999,28.870001,28.99,48564100,22.656992
2006-12-05,29.360001,29.40,29.030001,29.129999,45606000,22.766408
2006-12-04,29.23,29.52,29.17,29.33,55123400,22.922718
2006-12-01,29.23,29.299999,28.90,29.120001,72257000,22.758594
2006-11-30,29.42,29.57,29.33,29.360001,53297400,22.946165
2006-11-29,29.440001,29.780001,29.43,29.57,58775100,23.110288
2006-11-28,29.34,29.42,29.129999,29.389999,52602300,22.96961
2006-11-27,29.690001,29.74,29.33,29.48,72722100,23.039949
2006-11-24,29.66,29.84,29.639999,29.76,20456700,23.258782
2006-11-22,29.969999,30.00,29.82,29.92,43907200,23.38383
2006-11-21,29.91,30.00,29.790001,29.92,66446600,23.38383
2006-11-20,29.52,30.00,29.50,29.889999,85703800,23.360383
2006-11-17,29.309999,29.540001,29.280001,29.40,49356700,22.977426
2006-11-16,29.139999,29.639999,29.129999,29.469999,64328500,23.032134
2006-11-15,29.129999,29.360001,29.110001,29.120001,63943200,22.758594
2006-11-14,29.280001,29.42,29.07,29.23,63012500,22.844563
2006-11-13,29.190001,29.459999,29.16,29.35,47271800,22.860195
2006-11-10,29.17,29.290001,29.15,29.24,37855100,22.774517
2006-11-09,29.110001,29.40,29.00,29.26,89407500,22.790095
2006-11-08,28.780001,29.23,28.66,28.98,77403300,22.572008
2006-11-07,28.860001,29.07,28.799999,28.950001,56511200,22.548642
2006-11-06,28.77,29.049999,28.76,28.84,60446200,22.462965
2006-11-03,28.85,28.93,28.610001,28.73,41124500,22.377287
2006-11-02,28.709999,28.860001,28.58,28.77,58674400,22.408443
2006-11-01,28.780001,28.99,28.700001,28.809999,75895900,22.439598
2006-10-31,28.66,28.85,28.559999,28.709999,61861700,22.361709
2006-10-30,28.35,28.84,28.32,28.530001,47296800,22.221512
2006-10-27,28.49,28.790001,28.25,28.34,89060100,22.073524
2006-10-26,28.33,28.41,28.040001,28.35,69964200,22.081313
2006-10-25,28.280001,28.459999,28.139999,28.309999,40717100,22.050157
2006-10-24,28.43,28.43,28.129999,28.280001,61409600,22.026791
2006-10-23,28.299999,28.690001,28.18,28.450001,48525000,22.159201
2006-10-20,28.48,28.49,28.17,28.43,48887800,22.143623
2006-10-19,28.35,28.450001,28.120001,28.290001,44730800,22.03458
2006-10-18,28.50,28.700001,28.26,28.52,40630800,22.213723
2006-10-17,28.24,28.51,28.17,28.440001,40122600,22.151412
2006-10-16,28.48,28.60,28.33,28.450001,49744800,22.159201
2006-10-13,28.34,28.690001,28.309999,28.370001,129751900,22.096891
2006-10-12,27.58,28.290001,27.540001,28.219999,120174900,21.980057
2006-10-11,27.459999,27.67,27.42,27.540001,37219600,21.450418
2006-10-10,27.690001,27.75,27.440001,27.690001,34598500,21.56725
2006-10-09,27.799999,27.93,27.620001,27.719999,33366300,21.590616
2006-10-06,27.76,28.00,27.65,27.870001,36452200,21.707449
2006-10-05,27.92,28.110001,27.780001,27.92,81967200,21.746393
2006-10-04,27.389999,27.959999,27.370001,27.940001,82191200,21.761971
2006-10-03,27.370001,27.48,27.209999,27.370001,39386200,21.318008
2006-10-02,27.32,27.49,27.15,27.360001,52908100,21.310219
2006-09-29,27.35,27.42,27.209999,27.35,34283500,21.30243
2006-09-28,27.469999,27.52,27.26,27.40,44179700,21.341374
2006-09-27,27.18,27.469999,27.120001,27.440001,66233900,21.37253
2006-09-26,26.91,27.32,26.879999,27.200001,54766500,21.185598
2006-09-25,26.809999,27.190001,26.790001,26.950001,67903900,20.990878
2006-09-22,26.83,26.85,26.48,26.66,47712500,20.765001
2006-09-21,27.24,27.25,26.85,26.90,58495100,20.951933
2006-09-20,27.01,27.23,26.99,27.18,71676400,21.17002
2006-09-19,26.74,26.940001,26.719999,26.860001,43039100,20.920778
2006-09-18,26.74,27.040001,26.67,26.790001,49135000,20.866257
2006-09-15,26.58,26.940001,26.49,26.85,126057700,20.912989
2006-09-14,25.99,26.50,25.98,26.33,74324500,20.50797
2006-09-13,25.82,26.10,25.82,25.98,37706700,20.235361
2006-09-12,25.90,25.98,25.719999,25.93,52248800,20.196417
2006-09-11,25.43,25.950001,25.42,25.91,55608200,20.180839
2006-09-08,25.530001,25.790001,25.459999,25.60,36866800,19.939386
2006-09-07,25.48,25.700001,25.389999,25.43,51266900,19.806976
2006-09-06,25.51,25.719999,25.51,25.610001,50160400,19.947175
2006-09-05,25.690001,25.959999,25.559999,25.610001,44222400,19.947175
2006-09-01,25.889999,25.969999,25.639999,25.84,31594600,20.126318
2006-08-31,25.870001,25.98,25.68,25.700001,26380500,20.017275
2006-08-30,25.85,25.889999,25.639999,25.799999,30283100,20.095162
2006-08-29,25.92,25.98,25.629999,25.84,42711200,20.126318
2006-08-28,25.84,26.00,25.690001,25.950001,34190900,20.211995
2006-08-25,25.709999,26.00,25.690001,25.85,33115900,20.134107
2006-08-24,25.82,25.860001,25.50,25.74,35933300,20.048429
2006-08-23,25.65,25.950001,25.52,25.67,44648500,19.993908
2006-08-22,26.01,26.25,25.620001,25.620001,89312400,19.954964
2006-08-21,25.66,26.129999,25.559999,26.120001,88398300,20.344405
2006-08-18,25.049999,25.799999,24.98,25.790001,128414800,20.087374
2006-08-17,24.700001,24.75,24.610001,24.700001,45674800,19.238393
2006-08-16,24.610001,24.73,24.469999,24.700001,52373600,19.238393
2006-08-15,24.549999,24.65,24.440001,24.620001,48994500,19.176082
2006-08-14,24.52,24.60,24.35,24.530001,47831900,19.035882
2006-08-11,24.43,24.450001,24.200001,24.43,30255500,18.958279
2006-08-10,24.370001,24.60,24.34,24.459999,31753400,18.981559
2006-08-09,24.49,24.639999,24.34,24.440001,44405700,18.96604
2006-08-08,24.389999,24.52,24.200001,24.34,58171300,18.888437
2006-08-07,24.280001,24.48,24.190001,24.219999,36862400,18.795313
2006-08-04,24.40,24.49,24.15,24.290001,45690400,18.849636
2006-08-03,24.190001,24.48,24.15,24.209999,43155300,18.787553
2006-08-02,24.120001,24.40,24.030001,24.299999,46462000,18.857395
2006-08-01,24.02,24.200001,23.85,23.99,49168700,18.616828
2006-07-31,24.07,24.42,24.01,24.059999,40254400,18.67115
2006-07-28,24.08,24.280001,24.059999,24.25,51705800,18.818595
2006-07-27,24.58,24.60,23.77,23.870001,85386800,18.523706
2006-07-26,24.120001,24.530001,24.10,24.370001,54942100,18.911718
2006-07-25,24.00,24.290001,23.90,24.219999,60075800,18.795313
2006-07-24,24.01,24.110001,23.790001,24.00,59586700,18.624588
2006-07-21,24.08,24.15,23.00,23.870001,175483800,18.523706
2006-07-20,23.440001,23.450001,22.780001,22.85,76605200,17.732161
2006-07-19,22.82,23.459999,22.719999,23.40,82188200,18.158973
2006-07-18,22.59,22.76,22.48,22.74,65047300,17.646797
2006-07-17,22.290001,22.610001,22.26,22.48,37053500,17.445031
2006-07-14,22.280001,22.549999,22.23,22.290001,67499400,17.297587
2006-07-13,22.370001,22.610001,22.25,22.26,73099500,17.274306
2006-07-12,22.790001,22.879999,22.620001,22.639999,77379300,17.569195
2006-07-11,23.370001,23.370001,22.74,23.10,88676300,17.926167
2006-07-10,23.43,23.66,23.379999,23.50,50565100,18.236576
2006-07-07,23.389999,23.549999,23.299999,23.299999,63168800,18.081371
2006-07-06,23.450001,23.610001,23.42,23.48,44775200,18.221055
2006-07-05,23.48,23.52,23.299999,23.35,53093500,18.120173
2006-07-03,23.530001,23.719999,23.450001,23.700001,25711400,18.391782
2006-06-30,23.540001,23.65,23.299999,23.299999,73048800,18.081371
2006-06-29,23.32,23.629999,23.219999,23.469999,121395500,18.213295
2006-06-28,22.959999,23.25,22.91,23.16,71906500,17.972728
2006-06-27,22.889999,23.16,22.84,22.860001,84759100,17.739921
2006-06-26,22.65,22.889999,22.629999,22.82,53644100,17.708879
2006-06-23,22.85,22.870001,22.50,22.50,60532600,17.460552
2006-06-22,23.059999,23.17,22.780001,22.879999,76590600,17.75544
2006-06-21,22.610001,23.15,22.530001,23.08,91660300,17.910646
2006-06-20,22.540001,22.76,22.50,22.559999,90598500,17.507113
2006-06-19,22.139999,22.60,22.120001,22.549999,129640900,17.499352
2006-06-16,21.969999,22.280001,21.790001,22.10,147506500,17.150142
2006-06-15,22.01,22.129999,21.799999,22.07,121577300,17.126861
2006-06-14,21.59,21.940001,21.549999,21.879999,86081500,16.979416
2006-06-13,21.73,22.030001,21.459999,21.51,113175300,16.692288
2006-06-12,21.959999,22.10,21.700001,21.709999,74309700,16.847492
2006-06-09,22.15,22.190001,21.889999,21.92,52573800,17.010458
2006-06-08,22.030001,22.209999,21.969999,22.110001,104126900,17.157903
2006-06-07,22.15,22.389999,22.01,22.040001,73827500,17.103581
2006-06-06,22.549999,22.559999,21.98,22.129999,126601300,17.173422
2006-06-05,22.719999,22.73,22.49,22.50,63914100,17.460552
2006-06-02,22.870001,22.99,22.67,22.76,73935600,17.662318
2006-06-01,22.74,22.84,22.620001,22.82,80230800,17.708879
2006-05-31,23.26,23.35,22.65,22.65,120202000,17.576955
2006-05-30,23.549999,23.76,23.139999,23.15,52497500,17.964967
2006-05-26,23.77,23.879999,23.559999,23.719999,46861600,18.407301
2006-05-25,23.57,23.92,23.540001,23.74,83052700,18.422822
2006-05-24,22.99,23.540001,22.98,23.50,107356700,18.236576
2006-05-23,23.110001,23.379999,22.77,22.790001,79986300,17.6856
2006-05-22,22.48,23.02,22.450001,22.879999,87322300,17.75544
2006-05-19,22.790001,22.90,22.52,22.559999,100071200,17.507113
2006-05-18,22.84,23.139999,22.76,22.83,95476400,17.71664
2006-05-17,22.889999,23.08,22.73,22.73,98598300,17.639037
2006-05-16,23.16,24.00,22.91,23.01,82095100,17.856324
2006-05-15,23.10,23.23,23.030001,23.15,67314800,17.964967
2006-05-12,23.139999,23.370001,23.049999,23.17,83115900,17.910646
2006-05-11,23.709999,23.790001,23.15,23.219999,92916700,17.949296
2006-05-10,23.67,23.790001,23.59,23.77,76563300,18.374453
2006-05-09,23.75,24.00,23.49,23.620001,75345900,18.258501
2006-05-08,23.85,25.00,23.51,23.73,80693500,18.343532
2006-05-05,23.66,23.950001,23.52,23.799999,131604300,18.397642
2006-05-04,23.35,23.67,23.139999,23.440001,171257400,18.119359
2006-05-03,23.99,24.02,23.15,23.17,211527100,17.910646
2006-05-02,24.49,25.00,23.90,24.01,190533500,18.559975
2006-05-01,24.32,25.00,24.09,24.290001,174800900,18.776418
2006-04-28,24.23,24.50,24.00,24.15,591052200,18.668196
2006-04-27,26.969999,27.629999,26.940001,27.25,96509600,21.064528
2006-04-26,27.08,27.23,27.00,27.10,39190000,20.948577
2006-04-25,27.09,27.209999,27.02,27.110001,49222500,20.956307
2006-04-24,27.07,27.25,26.98,27.110001,42318400,20.956307
2006-04-21,27.049999,27.389999,27.00,27.15,58528000,20.987226
2006-04-20,27.049999,27.190001,26.700001,27.030001,45648300,20.894466
2006-04-19,27.110001,27.190001,26.959999,27.030001,45111100,20.894466
2006-04-18,26.940001,27.50,26.82,27.219999,56272700,21.041337
2006-04-17,27.030001,27.049999,26.73,26.84,35796200,20.747594
2006-04-13,27.08,27.200001,27.00,27.07,28160000,20.925386
2006-04-12,27.10,27.200001,26.969999,27.200001,32183000,21.025878
2006-04-11,27.290001,27.32,27.00,27.129999,42953400,20.971766
2006-04-10,27.23,27.440001,27.200001,27.290001,39432000,21.095449
2006-04-07,27.610001,27.719999,27.23,27.25,47249400,21.064528
2006-04-06,27.66,27.719999,27.370001,27.559999,51885500,21.304161
2006-04-05,27.879999,27.940001,27.639999,27.74,41539300,21.443303
2006-04-04,27.60,27.799999,27.469999,27.639999,45470000,21.366001
2006-04-03,27.67,27.73,27.440001,27.559999,57605300,21.304161
2006-03-31,27.299999,27.540001,27.209999,27.209999,62190500,21.033607
2006-03-30,27.030001,27.389999,27.00,27.23,54612000,21.049067
2006-03-29,26.950001,27.200001,26.92,27.02,53150300,20.886736
2006-03-28,27.01,27.209999,26.809999,26.90,58520500,20.793974
2006-03-27,27.01,27.299999,27.00,27.01,59908600,20.879006
2006-03-24,26.709999,27.209999,26.620001,27.01,69157600,20.879006
2006-03-23,27.08,27.10,26.66,26.85,73682900,20.755324
2006-03-22,27.08,27.50,26.799999,27.15,145696100,20.987226
2006-03-21,27.74,28.219999,27.68,27.74,73199600,21.443303
2006-03-20,27.700001,27.99,27.67,27.889999,67094100,21.559254
2006-03-17,27.35,27.66,27.27,27.50,120615000,21.25778
2006-03-16,27.34,27.48,27.219999,27.27,73793700,21.079988
2006-03-15,27.200001,27.450001,27.01,27.360001,57152000,21.149559
2006-03-14,27.040001,27.379999,26.99,27.23,39821800,21.049067
2006-03-13,27.18,27.290001,26.940001,27.110001,40342600,20.956307
2006-03-10,27.059999,27.219999,26.879999,27.17,41297200,21.002687
2006-03-09,27.27,27.42,27.00,27.00,45360700,20.871275
2006-03-08,26.99,27.50,26.969999,27.25,57547400,21.064528
2006-03-07,26.90,27.10,26.809999,27.059999,51613900,20.917655
2006-03-06,26.92,27.15,26.83,26.91,53054100,20.801704
2006-03-03,26.809999,27.16,26.74,26.93,45218800,20.817165
2006-03-02,27.02,27.10,26.90,26.969999,41850300,20.848084
2006-03-01,26.98,27.200001,26.950001,27.139999,53061200,20.979496
2006-02-28,26.950001,27.299999,26.870001,26.870001,65036100,20.770785
2006-02-27,26.75,27.26,26.67,27.049999,51301500,20.909925
2006-02-24,26.59,26.74,26.52,26.629999,44753800,20.585261
2006-02-23,26.73,26.889999,26.540001,26.66,47359100,20.608452
2006-02-22,26.530001,26.860001,26.469999,26.719999,43043100,20.654832
2006-02-21,26.719999,26.719999,26.34,26.540001,50216100,20.515691
2006-02-17,26.67,26.809999,26.559999,26.700001,41513200,20.639373
2006-02-16,26.85,26.90,26.57,26.809999,48868500,20.724403
2006-02-15,26.60,26.93,26.50,26.879999,62808900,20.778513
2006-02-14,26.41,26.68,26.35,26.65,58432900,20.53115
2006-02-13,26.629999,26.700001,26.34,26.389999,46707000,20.330846
2006-02-10,26.620001,26.889999,26.51,26.690001,52127000,20.561967
2006-02-09,26.959999,27.030001,26.65,26.66,52861700,20.538854
2006-02-08,27.01,27.08,26.709999,26.91,51795200,20.731454
2006-02-07,26.950001,27.15,26.809999,26.940001,72159500,20.754566
2006-02-06,27.51,27.540001,27.09,27.17,60170500,20.931758
2006-02-03,27.48,27.700001,27.34,27.540001,75022700,21.216807
2006-02-02,27.969999,27.99,27.549999,27.68,55073400,21.324662
2006-02-01,27.959999,28.07,27.76,28.040001,68448800,21.602006
2006-01-31,27.91,28.379999,27.870001,28.15,94841300,21.686749
2006-01-30,27.82,28.18,27.780001,28.00,103999200,21.57119
2006-01-27,27.23,27.950001,27.190001,27.790001,134520700,21.409406
2006-01-26,26.559999,26.719999,26.309999,26.50,69509300,20.41559
2006-01-25,26.41,26.57,26.23,26.40,59072100,20.33855
2006-01-24,26.34,26.450001,26.219999,26.280001,63040700,20.246103
2006-01-23,26.41,26.530001,26.299999,26.35,47925600,20.300031
2006-01-20,27.01,27.01,26.26,26.41,79165900,20.346254
2006-01-19,26.870001,27.24,26.85,27.02,60367600,20.816198
2006-01-18,26.74,26.98,26.700001,26.83,52376200,20.669822
2006-01-17,26.90,27.190001,26.90,26.99,58566600,20.793086
2006-01-13,27.030001,27.25,27.01,27.190001,41418000,20.947166
2006-01-12,27.25,27.26,26.969999,27.139999,45994800,20.908645
2006-01-11,27.01,27.389999,26.90,27.290001,70120700,21.024207
2006-01-10,26.65,27.02,26.59,27.00,64921900,20.80079
2006-01-09,26.93,27.07,26.76,26.860001,55625000,20.692935
2006-01-06,26.889999,27.00,26.49,26.91,100963000,20.731454
2006-01-05,26.959999,27.129999,26.91,26.99,48245500,20.793086
2006-01-04,26.77,27.08,26.77,26.969999,57975600,20.777677
2006-01-03,26.25,27.00,26.10,26.84,79973000,20.677526
2005-12-30,26.15,26.309999,26.10,26.15,49044600,20.14595
2005-12-29,26.41,26.50,26.26,26.27,34495500,20.238399
2005-12-28,26.51,26.66,26.35,26.389999,35444400,20.330846
2005-12-27,26.68,26.85,26.450001,26.459999,37819000,20.384774
2005-12-23,26.52,26.67,26.440001,26.639999,30689200,20.523446
2005-12-22,26.709999,26.780001,26.42,26.59,91276900,20.484926
2005-12-21,26.870001,26.91,26.709999,26.73,75800900,20.592782
2005-12-20,26.76,26.879999,26.67,26.860001,62960600,20.692935
2005-12-19,26.82,26.870001,26.65,26.83,68680100,20.669822
2005-12-16,26.879999,27.08,26.809999,26.90,88542500,20.72375
2005-12-15,27.08,27.110001,26.809999,26.92,79018100,20.739158
2005-12-14,27.00,27.24,26.85,27.09,65076200,20.870126
2005-12-13,27.290001,27.43,27.00,27.129999,104285500,20.900941
2005-12-12,27.700001,27.75,27.33,27.450001,63757200,21.14747
2005-12-09,27.709999,27.83,27.639999,27.709999,48467000,21.347773
2005-12-08,27.709999,27.809999,27.60,27.690001,63931600,21.332366
2005-12-07,27.67,27.75,27.549999,27.75,55583200,21.37859
2005-12-06,27.90,27.92,27.68,27.690001,65980000,21.332366
2005-12-05,27.93,28.02,27.709999,27.85,47517300,21.45563
2005-12-02,27.82,28.10,27.790001,28.01,42319600,21.578894
2005-12-01,27.73,28.10,27.73,27.889999,61006100,21.486445
2005-11-30,27.68,27.77,27.629999,27.68,55904700,21.324662
2005-11-29,27.790001,27.790001,27.60,27.68,62220400,21.324662
2005-11-28,27.790001,27.85,27.530001,27.75,57517200,21.37859
2005-11-25,27.799999,27.940001,27.469999,27.76,44082500,21.386294
2005-11-23,27.92,28.09,27.74,27.92,70541300,21.509558
2005-11-22,28.059999,28.08,27.860001,27.91,104253300,21.501854
2005-11-21,28.07,28.24,27.84,28.16,65794400,21.694453
2005-11-18,28.120001,28.25,27.90,28.07,75431200,21.625117
2005-11-17,27.85,28.00,27.76,27.969999,91351000,21.548077
2005-11-16,27.48,27.879999,27.440001,27.74,86277000,21.370886
2005-11-15,27.33,27.540001,27.25,27.50,65081000,21.18599
2005-11-14,27.360001,27.440001,27.200001,27.370001,67152200,21.024207
2005-11-11,27.15,27.389999,27.129999,27.280001,51945600,20.955073
2005-11-10,26.940001,27.15,26.639999,27.09,73314800,20.809125
2005-11-09,26.98,27.15,26.940001,26.959999,59562100,20.709265
2005-11-08,26.940001,27.18,26.77,27.049999,60091700,20.778398
2005-11-07,26.719999,27.08,26.700001,27.01,77104800,20.747673
2005-11-04,26.530001,26.709999,26.450001,26.66,57464000,20.478821
2005-11-03,26.60,26.639999,26.25,26.440001,73421600,20.309829
2005-11-02,25.93,26.50,25.93,26.459999,75067100,20.325191
2005-11-01,25.610001,26.10,25.610001,25.959999,71370400,19.941117
2005-10-31,25.610001,25.799999,25.50,25.700001,75122100,19.7414
2005-10-28,25.10,25.60,25.10,25.530001,106559300,19.610815
2005-10-27,25.219999,25.27,24.85,24.85,61566100,19.088474
2005-10-26,24.969999,25.33,24.93,25.110001,58178100,19.288192
2005-10-25,24.950001,25.129999,24.83,25.030001,41310500,19.226741
2005-10-24,24.889999,25.10,24.68,25.10,51868000,19.280511
2005-10-21,24.91,25.00,24.57,24.780001,69431200,19.034704
2005-10-20,25.049999,25.129999,24.74,24.790001,58830600,19.042385
2005-10-19,24.559999,25.09,24.50,25.09,66574500,19.272829
2005-10-18,24.49,24.83,24.450001,24.57,69328200,18.873392
2005-10-17,24.68,24.690001,24.440001,24.530001,46924400,18.842667
2005-10-14,24.709999,24.73,24.50,24.67,53846700,18.950207
2005-10-13,24.309999,24.73,24.27,24.59,70192000,18.888755
2005-10-12,24.49,24.700001,24.27,24.299999,71294400,18.665992
2005-10-11,24.51,24.549999,24.25,24.41,76567300,18.750488
2005-10-10,24.67,24.68,24.35,24.459999,48880900,18.788895
2005-10-07,24.77,24.84,24.52,24.59,50768700,18.888755
2005-10-06,24.66,24.950001,24.530001,24.73,81724600,18.996295
2005-10-05,25.040001,25.049999,24.67,24.67,73684700,18.950207
2005-10-04,25.360001,25.389999,24.75,24.98,151666300,19.188332
2005-10-03,25.709999,25.73,25.440001,25.50,55341300,19.58777
2005-09-30,25.91,25.950001,25.610001,25.73,57644500,19.764443
2005-09-29,25.610001,26.00,25.50,25.940001,66807100,19.925755
2005-09-28,25.389999,25.870001,25.379999,25.67,71019400,19.718355
2005-09-27,25.370001,25.450001,25.299999,25.34,48797900,19.464866
2005-09-26,25.40,25.49,25.209999,25.27,56203700,19.411096
2005-09-23,25.309999,25.540001,25.120001,25.27,66396800,19.411096
2005-09-22,25.49,25.60,25.15,25.34,71314900,19.464866
2005-09-21,25.799999,25.90,25.43,25.49,68281800,19.580088
2005-09-20,26.07,26.219999,25.690001,25.84,61043400,19.84894
2005-09-19,26.09,26.27,25.860001,26.00,61832300,19.971843
2005-09-16,26.34,26.40,25.969999,26.07,187384300,20.025614
2005-09-15,26.370001,26.43,26.219999,26.27,60357200,20.179244
2005-09-14,26.52,26.639999,26.299999,26.309999,54969600,20.209969
2005-09-13,26.540001,26.76,26.370001,26.48,63422900,20.340554
2005-09-12,26.620001,26.75,26.52,26.610001,40550500,20.440414
2005-09-09,26.620001,26.82,26.530001,26.58,41515800,20.417369
2005-09-08,26.799999,26.879999,26.52,26.610001,52552300,20.440414
2005-09-07,26.940001,27.110001,26.82,26.85,44656100,20.624769
2005-09-06,27.059999,27.290001,26.98,27.00,46089000,20.739991
2005-09-02,27.209999,27.27,26.969999,27.02,52047500,20.755355
2005-09-01,27.379999,27.389999,27.15,27.200001,75974500,20.893621
2005-08-31,27.17,27.440001,27.040001,27.379999,65210200,21.031887
2005-08-30,27.059999,27.23,26.959999,27.18,55163200,20.878258
2005-08-29,26.809999,27.23,26.809999,27.15,52307700,20.855213
2005-08-26,27.059999,27.08,26.870001,26.969999,36774600,20.716946
2005-08-25,26.90,27.09,26.85,27.030001,39306300,20.763036
2005-08-24,26.84,27.16,26.780001,26.809999,63645000,20.594043
2005-08-23,26.84,27.07,26.74,26.870001,48296700,20.640133
2005-08-22,26.790001,27.17,26.77,26.91,41691700,20.670858
2005-08-19,26.85,26.91,26.700001,26.719999,36043500,20.524909
2005-08-18,26.889999,27.08,26.799999,26.82,40861900,20.601724
2005-08-17,26.82,27.15,26.66,26.950001,52413100,20.701585
2005-08-16,27.030001,27.139999,26.700001,26.74,46894600,20.540273
2005-08-15,26.98,27.299999,26.690001,27.129999,45976600,20.83985
2005-08-12,27.08,27.139999,26.90,27.049999,52006500,20.716947
2005-08-11,26.98,27.299999,26.889999,27.27,48646800,20.88544
2005-08-10,27.41,27.50,26.85,26.950001,62818800,20.64036
2005-08-09,27.219999,27.51,27.01,27.35,64761800,20.94671
2005-08-08,27.799999,27.84,27.08,27.129999,77207200,20.778217
2005-08-05,27.290001,27.940001,27.25,27.76,82212400,21.260719
2005-08-04,27.16,27.50,27.049999,27.32,91461400,20.923734
2005-08-03,26.76,27.43,26.73,27.25,139422400,20.870122
2005-08-02,25.90,26.90,25.870001,26.809999,137510100,20.533137
2005-08-01,25.809999,26.049999,25.76,25.92,61346800,19.851507
2005-07-29,25.780001,26.00,25.59,25.610001,59524400,19.614086
2005-07-28,25.75,25.85,25.66,25.75,44738700,19.721308
2005-07-27,25.610001,25.799999,25.530001,25.719999,57977300,19.698332
2005-07-26,25.719999,25.74,25.530001,25.540001,51476400,19.560475
2005-07-25,25.690001,25.90,25.65,25.690001,45174600,19.675356
2005-07-22,25.99,26.34,25.629999,25.68,97558900,19.667697
2005-07-21,26.299999,26.48,26.00,26.440001,112932100,20.249763
2005-07-20,26.00,26.23,25.879999,26.190001,71424800,20.058294
2005-07-19,25.790001,26.25,25.75,26.16,113290100,20.035317
2005-07-18,25.709999,25.790001,25.549999,25.549999,39668000,19.568133
2005-07-15,26.040001,26.10,25.75,25.790001,56472800,19.751944
2005-07-14,25.790001,26.10,25.790001,25.969999,69506800,19.889801
2005-07-13,25.530001,25.75,25.48,25.66,44749200,19.652379
2005-07-12,25.24,25.620001,25.200001,25.610001,63384800,19.614086
2005-07-11,25.15,25.379999,25.110001,25.290001,61525400,19.369006
2005-07-08,24.639999,25.120001,24.629999,25.09,56104000,19.21583
2005-07-07,24.58,24.709999,24.50,24.65,80082900,18.878844
2005-07-06,24.969999,25.08,24.690001,24.700001,64214600,18.917139
2005-07-05,24.66,25.190001,24.620001,24.98,61883500,19.131583
2005-07-01,24.85,24.99,24.67,24.709999,69718400,18.924797
2005-06-30,25.059999,25.139999,24.82,24.84,82018200,19.024361
2005-06-29,25.219999,25.32,25.00,25.09,55859900,19.21583
2005-06-28,25.09,25.200001,25.030001,25.07,53058100,19.200512
2005-06-27,25.07,25.25,25.030001,25.049999,61636200,19.185195
2005-06-24,25.219999,25.40,25.040001,25.040001,57970700,19.177537
2005-06-23,25.17,25.620001,25.15,25.309999,105159800,19.384323
2005-06-22,25.110001,25.26,25.030001,25.07,60492700,19.200512
2005-06-21,25.08,25.190001,25.040001,25.15,81084000,19.261782
2005-06-20,24.98,25.280001,24.93,25.110001,50538900,19.231148
2005-06-17,25.27,25.290001,24.92,25.040001,90821300,19.177537
2005-06-16,25.219999,25.23,24.950001,25.040001,65918800,19.177537
2005-06-15,25.40,25.41,25.110001,25.26,50764800,19.346029
2005-06-14,25.309999,25.440001,25.24,25.360001,44243300,19.422617
2005-06-13,25.360001,25.49,25.26,25.309999,49104100,19.384323
2005-06-10,25.49,25.52,25.34,25.43,39459800,19.476228
2005-06-09,25.40,25.610001,25.35,25.51,52767900,19.537498
2005-06-08,25.549999,25.620001,25.34,25.40,45369700,19.453251
2005-06-07,25.33,25.83,25.309999,25.51,54511400,19.537498
2005-06-06,25.379999,25.50,25.309999,25.370001,40756900,19.430276
2005-06-03,25.700001,25.809999,25.34,25.43,79659500,19.476228
2005-06-02,25.709999,25.860001,25.639999,25.790001,27212500,19.751944
2005-06-01,25.73,26.00,25.610001,25.809999,54621000,19.767261
2005-05-31,25.99,26.030001,25.75,25.799999,46131100,19.759602
2005-05-27,25.83,26.09,25.809999,26.07,54978000,19.966389
2005-05-26,25.75,26.00,25.73,25.90,50579200,19.83619
2005-05-25,25.68,25.77,25.50,25.709999,35749000,19.690673
2005-05-24,25.799999,25.879999,25.719999,25.75,61287700,19.721308
2005-05-23,25.74,26.07,25.74,25.85,75421100,19.797896
2005-05-20,25.879999,25.92,25.73,25.74,64444500,19.713649
2005-05-19,25.75,26.049999,25.700001,25.92,52120800,19.851507
2005-05-18,25.50,25.84,25.42,25.700001,71182400,19.683015
2005-05-17,25.309999,25.50,25.25,25.459999,39983200,19.499204
2005-05-16,25.23,25.50,25.190001,25.49,50577300,19.52218
2005-05-13,25.030001,25.379999,24.99,25.299999,77204300,19.315394
2005-05-12,24.84,25.110001,24.83,25.00,74540700,19.086358
2005-05-11,24.889999,24.969999,24.639999,24.91,59463300,19.017647
2005-05-10,25.040001,25.08,24.82,24.90,62235100,19.010012
2005-05-09,25.23,25.33,25.049999,25.110001,61872400,19.170338
2005-05-06,25.33,25.48,25.190001,25.219999,64322600,19.254317
2005-05-05,25.200001,25.33,25.08,25.23,59362300,19.261952
2005-05-04,25.34,25.40,25.110001,25.209999,86864200,19.246683
2005-05-03,25.129999,25.40,25.09,25.360001,67867800,19.361202
2005-05-02,25.23,25.360001,24.950001,25.23,54376700,19.261952
2005-04-29,24.879999,25.299999,24.790001,25.299999,98641200,19.315394
2005-04-28,24.82,24.92,24.440001,24.450001,83623100,18.666459
2005-04-27,24.66,25.15,24.629999,24.99,47732800,19.078723
2005-04-26,24.950001,25.25,24.74,24.76,60464300,18.903129
2005-04-25,25.07,25.280001,24.860001,24.99,75457900,19.078723
2005-04-22,25.049999,25.25,24.780001,24.98,80087500,19.071089
2005-04-21,24.48,25.389999,24.469999,25.280001,93562300,19.300126
2005-04-20,24.66,24.700001,24.299999,24.32,91923500,18.567209
2005-04-19,24.709999,24.799999,24.450001,24.629999,65956200,18.803879
2005-04-18,24.450001,24.84,24.40,24.65,75766400,18.819149
2005-04-15,24.58,24.90,24.41,24.459999,100251600,18.674092
2005-04-14,25.01,25.139999,24.83,24.84,66754400,18.964205
2005-04-13,25.23,25.450001,24.99,25.040001,60929300,19.116897
2005-04-12,24.92,25.35,24.799999,25.32,67517800,19.330663
2005-04-11,25.030001,25.110001,24.860001,24.969999,47791800,19.063454
2005-04-08,25.07,25.25,24.91,24.940001,47956300,19.040551
2005-04-07,24.66,25.129999,24.629999,25.10,77451500,19.162704
2005-04-06,24.469999,24.940001,24.450001,24.67,78020200,18.834418
2005-04-05,24.219999,24.50,24.120001,24.469999,73549600,18.681727
2005-04-04,24.110001,24.26,23.940001,24.23,62196400,18.498498
2005-04-01,24.24,24.35,24.10,24.120001,64619600,18.414519
2005-03-31,24.25,24.309999,24.120001,24.17,62382300,18.452691
2005-03-30,24.040001,24.190001,24.00,24.16,59585700,18.445056
2005-03-29,24.139999,24.24,23.82,23.92,74231700,18.261827
2005-03-28,24.40,24.469999,24.18,24.200001,49802000,18.475595
2005-03-24,24.24,24.469999,24.200001,24.280001,78820900,18.536671
2005-03-23,23.99,24.389999,23.959999,24.18,79293300,18.460326
2005-03-22,24.190001,24.27,23.959999,23.99,102113300,18.315269
2005-03-21,24.35,24.360001,24.15,24.200001,71446200,18.475595
2005-03-18,24.530001,24.91,24.280001,24.309999,135904000,18.559574
2005-03-17,24.639999,24.68,24.530001,24.540001,60573200,18.73517
2005-03-16,24.82,24.969999,24.559999,24.629999,74841400,18.803879
2005-03-15,25.10,25.24,24.889999,24.91,71469400,19.017647
2005-03-14,25.08,25.15,24.959999,25.110001,65550500,19.170338
2005-03-11,25.450001,25.48,25.059999,25.09,60617900,19.155069
2005-03-10,25.43,25.48,25.25,25.43,59132900,19.414644
2005-03-09,25.389999,25.57,25.280001,25.309999,62991800,19.323028
2005-03-08,25.40,25.620001,25.34,25.40,52871800,19.391739
2005-03-07,25.17,25.790001,25.16,25.469999,80407400,19.445181
2005-03-04,25.209999,25.299999,25.129999,25.17,63058200,19.216145
2005-03-03,25.299999,25.309999,25.139999,25.17,52183600,19.216145
2005-03-02,25.190001,25.48,25.16,25.26,67739000,19.284856
2005-03-01,25.190001,25.41,25.129999,25.280001,56394800,19.300126
2005-02-28,25.219999,25.370001,25.129999,25.16,82728000,19.208511
2005-02-25,25.33,25.379999,25.15,25.25,62467700,19.277222
2005-02-24,25.18,25.440001,25.15,25.370001,85236300,19.368837
2005-02-23,25.24,25.35,25.17,25.200001,83689400,19.239049
2005-02-22,25.25,25.49,25.200001,25.23,96419200,19.261952
2005-02-18,25.639999,25.65,25.40,25.48,77091100,19.452816
2005-02-17,25.709999,25.860001,25.60,25.65,67024800,19.582603
2005-02-16,25.870001,25.93,25.67,25.790001,57506600,19.689488
2005-02-15,26.00,26.08,25.860001,25.93,76551600,19.796371
2005-02-14,25.93,26.120001,25.91,26.01,58694000,19.796371
2005-02-11,26.030001,26.120001,25.809999,25.969999,83835900,19.765926
2005-02-10,26.10,26.129999,26.00,26.059999,71796400,19.834425
2005-02-09,26.25,26.309999,26.040001,26.07,77874800,19.842037
2005-02-08,26.190001,26.34,26.16,26.24,61343700,19.971425
2005-02-07,26.27,26.299999,26.059999,26.16,57763400,19.910536
2005-02-04,26.17,26.370001,26.139999,26.32,61246500,20.032313
2005-02-03,26.370001,26.40,26.10,26.18,62545400,19.925759
2005-02-02,26.42,26.50,26.280001,26.459999,79329500,20.138868
2005-02-01,26.25,26.43,26.219999,26.389999,57981700,20.08559
2005-01-31,26.35,26.52,26.16,26.280001,71442100,20.00187
2005-01-28,26.540001,26.65,25.959999,26.18,110466500,19.925759
2005-01-27,25.950001,26.16,25.85,26.110001,93204100,19.872482
2005-01-26,26.07,26.17,25.90,26.01,64974500,19.796371
2005-01-25,25.76,26.190001,25.75,26.02,67580700,19.803982
2005-01-24,25.76,26.00,25.639999,25.67,69010900,19.537595
2005-01-21,25.950001,26.129999,25.639999,25.65,76501000,19.522372
2005-01-20,25.84,26.10,25.74,25.860001,58380100,19.682205
2005-01-19,26.209999,26.26,25.92,25.98,58114100,19.773537
2005-01-18,26.030001,26.35,25.84,26.32,69146400,20.032313
2005-01-14,26.40,26.450001,26.040001,26.120001,92180800,19.880093
2005-01-13,26.68,26.799999,26.16,26.27,89861600,19.994258
2005-01-12,26.77,26.85,26.620001,26.780001,72940600,20.382423
2005-01-11,26.690001,26.82,26.610001,26.73,64712000,20.344367
2005-01-10,26.60,26.860001,26.540001,26.799999,70376600,20.397644
2005-01-07,26.82,26.889999,26.620001,26.67,68723300,20.298701
2005-01-06,26.85,27.059999,26.639999,26.75,76890500,20.359589
2005-01-05,26.84,27.10,26.76,26.780001,72463500,20.382423
2005-01-04,26.870001,27.10,26.66,26.84,109442100,20.428089
2005-01-03,26.799999,26.950001,26.65,26.74,65002900,20.351978
2004-12-31,26.75,26.90,26.68,26.719999,54959500,20.336755
2004-12-30,26.889999,26.940001,26.75,26.76,48355400,20.3672
2004-12-29,26.85,27.00,26.82,26.90,47594900,20.473755
2004-12-28,26.85,27.030001,26.799999,26.950001,55075900,20.511811
2004-12-27,27.01,27.10,26.82,26.85,55958500,20.4357
2004-12-23,26.870001,27.15,26.83,27.01,65801900,20.557477
2004-12-22,26.84,27.15,26.780001,26.969999,63651900,20.527032
2004-12-21,27.00,27.17,26.940001,27.07,94646100,20.603143
2004-12-20,27.01,27.15,26.889999,26.950001,85552800,20.511811
2004-12-17,27.00,27.32,26.799999,26.959999,126184400,20.519421
2004-12-16,27.15,27.280001,27.01,27.16,88997500,20.671642
2004-12-15,27.219999,27.40,27.07,27.110001,106303900,20.633588
2004-12-14,27.049999,27.33,27.040001,27.23,127843200,20.72492
2004-12-13,27.10,27.280001,26.91,27.25,93812500,20.740142
2004-12-10,27.08,27.18,27.040001,27.08,70949200,20.610754
2004-12-09,27.129999,27.360001,26.940001,27.23,83006000,20.72492
2004-12-08,27.01,27.360001,26.91,27.360001,95655000,20.823864
2004-12-07,27.26,27.379999,27.00,27.07,111656000,20.603143
2004-12-06,27.10,27.440001,27.07,27.33,55297400,20.801031
2004-12-03,27.16,27.440001,27.139999,27.23,76498400,20.72492
2004-12-02,27.27,27.40,26.92,27.09,96088300,20.618365
2004-12-01,26.950001,27.280001,26.809999,27.25,99889000,20.740142
2004-11-30,26.75,27.01,26.700001,26.809999,75960400,20.405255
2004-11-29,26.639999,26.950001,26.610001,26.77,67079900,20.374812
2004-11-26,26.559999,26.82,26.549999,26.60,24398700,20.245423
2004-11-24,26.620001,26.73,26.40,26.639999,60069200,20.275867
2004-11-23,26.52,26.700001,26.40,26.530001,70459700,20.192146
2004-11-22,26.75,26.82,26.10,26.65,92410800,20.283478
2004-11-19,27.030001,27.07,26.84,26.860001,85808600,20.443311
2004-11-18,27.129999,27.17,27.00,27.07,63249900,20.603143
2004-11-17,27.25,27.35,27.059999,27.17,58830700,20.679254
2004-11-16,27.33,27.34,27.049999,27.120001,64522600,20.641199
2004-11-15,27.34,27.50,27.200001,27.389999,104468000,20.846697
2004-11-12,30.16,30.200001,29.799999,29.969999,162269000,20.466143
2004-11-11,29.889999,30.08,29.82,29.98,87358900,20.472972
2004-11-10,29.92,30.00,29.690001,29.73,84097700,20.30225
2004-11-09,29.43,29.889999,29.35,29.77,100401000,20.329566
2004-11-08,29.18,29.48,29.129999,29.280001,112802100,19.994952
2004-11-05,29.209999,29.360001,29.030001,29.309999,95337700,20.015437
2004-11-04,28.379999,29.00,28.379999,29.00,87867700,19.803743
2004-11-03,28.65,28.65,28.309999,28.469999,79666700,19.441812
2004-11-02,28.26,28.469999,28.030001,28.24,89417100,19.284748
2004-11-01,28.16,28.280001,27.959999,28.08,72930900,19.175486
2004-10-29,28.120001,28.15,27.799999,27.969999,80010100,19.100368
2004-10-28,28.110001,28.540001,27.90,28.01,63059600,19.127684
2004-10-27,27.860001,28.35,27.58,28.15,72392600,19.223288
2004-10-26,27.709999,27.90,27.629999,27.90,76966600,19.052566
2004-10-25,27.67,27.77,27.549999,27.629999,61529500,18.868186
2004-10-22,28.299999,28.34,27.58,27.74,101912800,18.943304
2004-10-21,28.809999,28.889999,28.469999,28.559999,94988500,19.503272
2004-10-20,28.219999,28.75,28.120001,28.700001,69078100,19.598877
2004-10-19,28.530001,28.59,28.17,28.18,57026500,19.243775
2004-10-18,28.07,28.450001,27.98,28.41,50350700,19.400839
2004-10-15,27.969999,28.24,27.82,27.99,49828500,19.114026
2004-10-14,28.040001,28.16,27.799999,27.799999,41548700,18.984277
2004-10-13,28.190001,28.27,27.940001,28.030001,49500700,19.141342
2004-10-12,27.83,28.16,27.809999,28.030001,56412900,19.141342
2004-10-11,28.200001,28.219999,27.93,28.059999,44691000,19.161828
2004-10-08,28.10,28.33,27.969999,27.99,49556600,19.114026
2004-10-07,28.540001,28.59,28.16,28.17,38401500,19.236946
2004-10-06,28.389999,28.549999,28.23,28.530001,56999600,19.482786
2004-10-05,28.15,28.450001,28.10,28.379999,58017700,19.380352
2004-10-04,28.440001,28.459999,28.07,28.120001,62016200,19.202802
2004-10-01,27.82,28.32,27.780001,28.25,66302800,19.291577
2004-09-30,27.59,27.790001,27.52,27.65,71218000,18.881844
2004-09-29,27.26,27.690001,27.23,27.58,61529300,18.834042
2004-09-28,27.209999,27.360001,27.040001,27.27,62055100,18.622347
2004-09-27,27.17,27.32,27.129999,27.190001,47813600,18.567716
2004-09-24,27.389999,27.459999,27.190001,27.290001,49859800,18.636005
2004-09-23,27.190001,27.389999,27.17,27.35,52155800,18.676978
2004-09-22,27.280001,27.74,27.07,27.120001,68409000,18.519914
2004-09-21,27.450001,27.530001,27.25,27.26,73874400,18.615518
2004-09-20,27.440001,27.65,27.33,27.51,51513600,18.78624
2004-09-17,27.389999,27.530001,27.26,27.51,65283000,18.78624
2004-09-16,27.219999,27.35,27.17,27.26,35951500,18.615518
2004-09-15,27.360001,27.40,27.139999,27.190001,52605700,18.567716
2004-09-14,27.370001,27.51,27.27,27.440001,55920000,18.738438
2004-09-13,27.530001,27.57,26.74,27.25,48239200,18.608689
2004-09-10,27.34,27.51,27.18,27.49,52664500,18.772582
2004-09-09,27.299999,27.469999,27.18,27.280001,56904700,18.629176
2004-09-08,27.299999,27.469999,27.139999,27.26,53278100,18.615518
2004-09-07,27.290001,27.379999,27.16,27.360001,44893400,18.683807
2004-09-03,27.459999,27.620001,27.10,27.110001,46174400,18.513085
2004-09-02,27.40,27.68,27.35,27.620001,42161700,18.861358
2004-09-01,27.23,27.52,27.139999,27.389999,48507500,18.704293
2004-08-31,27.290001,27.32,27.049999,27.299999,52106700,18.642833
2004-08-30,27.299999,27.389999,26.85,27.299999,36679600,18.642833
2004-08-27,27.50,27.65,27.450001,27.459999,33248700,18.752095
2004-08-26,27.459999,27.60,27.389999,27.440001,35465500,18.738438
2004-08-25,27.209999,27.67,27.18,27.549999,53512700,18.813555
2004-08-24,27.40,27.459999,27.09,27.24,40835300,18.60186
2004-08-23,27.27,27.33,27.120001,27.24,39572200,18.60186
2004-08-20,27.129999,27.370001,27.040001,27.200001,46494800,18.519914
2004-08-19,27.35,27.450001,27.01,27.120001,46293000,18.465444
2004-08-18,26.93,27.50,26.889999,27.459999,58844000,18.696942
2004-08-17,27.219999,27.379999,26.98,27.049999,56879700,18.417781
2004-08-16,27.030001,27.200001,26.959999,27.09,54347200,18.445017
2004-08-13,27.01,27.25,26.98,27.02,43333200,18.397356
2004-08-12,27.23,27.309999,26.860001,26.879999,50279700,18.302032
2004-08-11,27.389999,27.51,27.200001,27.41,53097300,18.662898
2004-08-10,27.299999,27.75,27.25,27.719999,57632700,18.87397
2004-08-09,27.26,27.280001,27.10,27.18,51877500,18.506296
2004-08-06,27.379999,27.860001,27.059999,27.139999,75628000,18.47906
2004-08-05,28.16,28.209999,27.52,27.530001,55591700,18.744604
2004-08-04,28.01,28.200001,27.99,28.059999,46217900,19.105469
2004-08-03,28.379999,28.42,28.00,28.07,53990900,19.112278
2004-08-02,28.27,28.549999,28.16,28.52,52267000,19.418674
2004-07-30,28.450001,28.809999,28.33,28.49,59552900,19.398248
2004-07-29,28.780001,28.799999,28.25,28.48,60148400,19.391439
2004-07-28,28.34,28.790001,28.280001,28.58,62718800,19.459527
2004-07-27,28.700001,28.76,28.129999,28.440001,72968400,19.364204
2004-07-26,28.360001,28.709999,28.200001,28.66,72387600,19.513997
2004-07-23,28.379999,28.40,28.02,28.030001,97372700,19.085044
2004-07-22,29.07,29.299999,28.83,29.00,124640700,19.745496
2004-07-21,29.889999,29.889999,28.809999,28.860001,201518000,19.650173
2004-07-20,28.00,28.48,27.85,28.32,89010700,19.282498
2004-07-19,27.620001,28.26,27.60,27.950001,60354500,19.030573
2004-07-16,28.18,28.200001,27.25,27.48,66406300,18.710559
2004-07-15,28.049999,28.200001,27.799999,27.870001,46759700,18.976103
2004-07-14,27.40,28.360001,27.34,28.129999,87656300,19.153131
2004-07-13,27.91,27.950001,27.60,27.60,43274100,18.792266
2004-07-12,27.67,28.00,27.59,27.889999,45757300,18.98972
2004-07-09,27.780001,28.00,27.639999,27.860001,50249300,18.969294
2004-07-08,27.879999,28.15,27.549999,27.639999,59125100,18.8195
2004-07-07,27.67,28.32,27.549999,28.10,66255700,19.132705
2004-07-06,28.32,28.33,27.940001,28.02,69158900,19.078235
2004-07-02,28.620001,28.68,28.40,28.57,36690100,19.452718
2004-07-01,28.700001,28.84,28.26,28.629999,78441400,19.49357
2004-06-30,28.57,28.799999,28.389999,28.559999,83544400,19.445909
2004-06-29,28.18,28.58,28.18,28.50,55371700,19.405057
2004-06-28,28.60,28.75,28.17,28.280001,77024100,19.255264
2004-06-25,28.48,28.629999,28.25,28.57,71136500,19.452718
2004-06-24,28.48,28.65,28.360001,28.389999,65503800,19.330159
2004-06-23,28.200001,28.379999,28.00,28.299999,58558400,19.26888
2004-06-22,28.15,28.35,27.809999,28.290001,98932000,19.262073
2004-06-21,28.219999,28.66,28.120001,28.35,116881700,19.302925
2004-06-18,27.77,28.50,27.700001,28.35,134218700,19.302925
2004-06-17,27.309999,27.92,27.290001,27.77,105427500,18.908015
2004-06-16,27.34,27.50,27.15,27.32,67431100,18.601619
2004-06-15,26.99,27.60,26.969999,27.41,114183400,18.662898
2004-06-14,26.549999,26.90,26.530001,26.90,67377500,18.31565
2004-06-10,26.379999,26.790001,26.379999,26.77,48109200,18.227136
2004-06-09,26.40,26.65,26.40,26.469999,50385500,18.022871
2004-06-08,26.280001,26.65,26.24,26.60,58447700,18.111386
2004-06-07,26.02,26.43,25.969999,26.43,65218600,17.995637
2004-06-04,26.030001,26.24,25.940001,25.950001,48815300,17.668815
2004-06-03,26.049999,26.129999,25.860001,25.889999,45933100,17.627961
2004-06-02,26.120001,26.280001,26.01,26.129999,54020000,17.791372
2004-06-01,26.129999,26.27,25.870001,26.110001,48369500,17.777756
2004-05-28,26.139999,26.35,26.02,26.23,37393000,17.85946
2004-05-27,26.16,26.190001,25.92,26.190001,49071900,17.832226
2004-05-26,25.99,26.15,25.85,26.139999,50306900,17.798181
2004-05-25,25.709999,26.190001,25.60,26.10,66615000,17.770947
2004-05-24,26.049999,26.17,25.74,25.76,56250500,17.539448
2004-05-21,25.969999,26.200001,25.780001,25.889999,57809300,17.627961
2004-05-20,25.75,25.870001,25.59,25.73,52089900,17.519021
2004-05-19,26.030001,26.27,25.620001,25.620001,60052800,17.444125
2004-05-18,25.700001,25.969999,25.639999,25.83,58158600,17.587109
2004-05-17,25.469999,25.790001,25.42,25.540001,55149600,17.389655
2004-05-14,26.00,26.17,25.639999,25.860001,43775300,17.607536
2004-05-13,25.82,26.190001,25.790001,26.10,63861500,17.770947
2004-05-12,25.870001,26.00,25.43,25.940001,64145600,17.662006
2004-05-11,26.09,26.110001,25.790001,25.940001,57917200,17.662006
2004-05-10,25.629999,26.049999,25.620001,25.93,64621400,17.655197
2004-05-07,26.030001,26.379999,25.75,25.780001,68290200,17.553066
2004-05-06,26.16,26.34,26.030001,26.120001,62693900,17.784565
2004-05-05,26.32,26.60,26.25,26.299999,51841700,17.907122
2004-05-04,26.35,26.540001,26.02,26.33,55496400,17.927549
2004-05-03,26.190001,26.52,26.190001,26.35,65916200,17.941167
2004-04-30,26.59,26.75,25.959999,26.129999,66172200,17.791372
2004-04-29,26.51,26.940001,26.309999,26.48,77787300,18.02968
2004-04-28,27.01,27.049999,26.469999,26.559999,72842200,18.084151
2004-04-27,27.16,27.370001,27.129999,27.219999,80716800,18.533531
2004-04-26,27.450001,27.549999,27.10,27.24,89391000,18.547149
2004-04-23,27.40,27.719999,27.34,27.540001,258269000,18.751413
2004-04-22,25.51,25.99,25.469999,25.950001,99207700,17.668815
2004-04-21,25.360001,25.49,25.200001,25.450001,49252000,17.328376
2004-04-20,25.65,25.879999,25.280001,25.33,59902600,17.246669
2004-04-19,25.08,25.60,25.059999,25.530001,44592100,17.382846
2004-04-16,25.33,25.40,25.110001,25.16,51768600,17.13092
2004-04-15,25.530001,25.73,25.10,25.219999,73756900,17.171772
2004-04-14,25.389999,25.68,25.379999,25.51,61079600,17.369228
2004-04-13,25.68,25.77,25.41,25.450001,56971500,17.328376
2004-04-12,25.48,25.74,25.43,25.610001,38786800,17.437316
2004-04-08,25.82,25.85,25.360001,25.48,45294600,17.348801
2004-04-07,25.74,25.780001,25.35,25.59,63268900,17.423698
2004-04-06,25.77,25.90,25.66,25.799999,48992000,17.566682
2004-04-05,25.809999,25.98,25.73,25.950001,53800300,17.668815
2004-04-02,25.48,25.90,25.440001,25.85,98043800,17.600727
2004-04-01,24.950001,25.110001,24.85,25.08,69051900,17.07645
2004-03-31,25.200001,25.200001,24.870001,24.93,70533200,16.974318
2004-03-30,25.209999,25.33,25.030001,25.200001,59010400,17.158156
2004-03-29,25.25,25.40,25.00,25.309999,51881600,17.233052
2004-03-26,25.110001,25.51,25.00,25.030001,61584900,17.042406
2004-03-25,24.60,25.24,24.58,25.190001,85677900,17.151347
2004-03-24,24.379999,24.58,24.18,24.41,97584700,16.620261
2004-03-23,24.65,24.66,24.110001,24.15,91696300,16.443232
2004-03-22,24.48,24.84,24.01,24.50,127605200,16.68154
2004-03-19,24.77,24.940001,24.559999,24.629999,86281600,16.770054
2004-03-18,24.959999,25.030001,24.58,24.889999,123231000,16.947082
2004-03-17,25.25,25.459999,25.110001,25.129999,56241400,17.110493
2004-03-16,25.26,25.370001,25.10,25.18,65453800,17.144538
2004-03-15,25.299999,25.43,25.059999,25.16,68835300,17.13092
2004-03-12,25.379999,25.51,25.23,25.379999,64137100,17.280713
2004-03-11,25.18,25.780001,25.07,25.09,90536300,17.083259
2004-03-10,25.65,25.799999,25.35,25.370001,75155800,17.273905
2004-03-09,25.799999,25.969999,25.540001,25.719999,81111700,17.512212
2004-03-08,26.309999,26.35,25.809999,25.83,69367800,17.587109
2004-03-05,26.23,26.60,26.200001,26.35,59849800,17.941167
2004-03-04,26.33,26.42,26.209999,26.370001,44023200,17.954784
2004-03-03,26.35,26.549999,26.219999,26.370001,54998700,17.954784
2004-03-02,26.610001,26.690001,26.35,26.389999,66331000,17.968401
2004-03-01,26.629999,26.719999,26.50,26.700001,51912300,18.179475
2004-02-27,26.469999,26.620001,26.35,26.530001,58266500,18.063725
2004-02-26,26.59,26.65,26.41,26.50,66602700,18.043298
2004-02-25,26.90,26.99,26.610001,26.700001,64275700,18.179475
2004-02-24,26.610001,26.950001,26.549999,26.879999,55426500,18.302032
2004-02-23,26.73,26.76,26.48,26.610001,50256800,18.118195
2004-02-20,26.66,26.799999,26.50,26.57,57821900,18.090959
2004-02-19,26.92,26.98,26.43,26.459999,61840600,18.016062
2004-02-18,26.90,27.110001,26.74,26.77,50334700,18.227136
2004-02-17,26.719999,27.10,26.59,26.99,43477000,18.376929
2004-02-13,26.98,27.059999,26.50,26.59,67541100,18.104577
2004-02-12,27.09,27.15,26.93,26.950001,44537000,18.349694
2004-02-11,26.969999,27.23,26.85,27.15,51515300,18.485869
2004-02-10,26.870001,27.15,26.82,27.02,37790600,18.397356
2004-02-09,27.190001,27.23,26.85,26.90,48108500,18.31565
2004-02-06,27.030001,27.190001,26.93,27.08,47209600,18.438208
2004-02-05,27.059999,27.17,26.83,26.959999,55527500,18.356502
2004-02-04,27.219999,27.43,27.01,27.01,60648000,18.390547
2004-02-03,27.40,27.549999,27.18,27.290001,47993800,18.581193
2004-02-02,27.610001,27.799999,27.24,27.40,62891800,18.656089
2004-01-30,27.84,27.90,27.549999,27.65,40528700,18.826309
2004-01-29,27.809999,27.950001,27.57,27.91,63748400,19.003338
2004-01-28,28.299999,28.440001,27.469999,27.709999,71336000,18.867161
2004-01-27,28.639999,28.719999,28.219999,28.25,63196200,19.234837
2004-01-26,28.49,28.83,28.32,28.799999,58299600,19.60932
2004-01-23,28.280001,28.76,28.219999,28.48,127259100,19.391439
2004-01-22,28.360001,28.440001,27.940001,28.01,78425200,19.071426
2004-01-21,28.129999,28.299999,27.85,28.299999,53570600,19.26888
2004-01-20,27.98,28.200001,27.93,28.10,63068500,19.132705
2004-01-16,27.709999,27.879999,27.530001,27.809999,63983400,18.93525
2004-01-15,27.549999,27.719999,27.42,27.540001,58504100,18.751413
2004-01-14,27.52,27.73,27.469999,27.700001,43907000,18.860354
2004-01-13,27.549999,27.639999,27.26,27.43,51555900,18.676516
2004-01-12,27.67,27.73,27.35,27.57,55845200,18.771839
2004-01-09,28.030001,28.059999,27.59,27.66,67079900,18.833118
2004-01-08,28.389999,28.48,28.00,28.16,58810800,19.173557
2004-01-07,28.17,28.309999,28.01,28.209999,54298200,19.207601
2004-01-06,28.190001,28.280001,28.07,28.24,46950800,19.228028
2004-01-05,27.73,28.18,27.719999,28.139999,67333700,19.15994
2004-01-02,27.58,27.77,27.33,27.450001,44487700,18.690134
2003-12-31,27.42,27.549999,27.23,27.370001,42198900,18.635664
2003-12-30,27.41,27.549999,27.40,27.52,34406600,18.737795
2003-12-29,27.209999,27.530001,27.16,27.459999,40426700,18.696942
2003-12-26,27.049999,27.25,27.00,27.209999,12076900,18.526722
2003-12-24,27.139999,27.16,27.00,27.040001,19924200,18.410974
2003-12-23,27.17,27.34,27.01,27.15,39609000,18.485869
2003-12-22,27.16,27.43,26.969999,27.18,43894800,18.506296
2003-12-19,27.49,27.549999,27.190001,27.360001,76856400,18.628855
2003-12-18,27.10,27.450001,27.049999,27.40,61177800,18.656089
2003-12-17,27.040001,27.08,26.85,27.040001,53712300,18.410974
2003-12-16,26.83,27.16,26.77,27.059999,73978000,18.42459
2003-12-15,27.049999,27.10,26.68,26.74,88860600,18.206709
2003-12-12,26.690001,26.809999,26.50,26.65,69154100,18.14543
2003-12-11,26.59,26.77,26.280001,26.610001,79309000,18.118195
2003-12-10,26.450001,26.629999,26.379999,26.59,82853700,18.104577
2003-12-09,26.440001,26.610001,26.25,26.379999,103547100,17.961592
2003-12-08,26.120001,26.34,25.809999,26.24,90504000,17.866269
2003-12-05,25.959999,26.48,25.92,25.98,96610900,17.689241
2003-12-04,25.719999,26.23,25.66,26.200001,87202400,17.839035
2003-12-03,25.82,26.07,25.620001,25.67,93121600,17.478168
2003-12-02,25.950001,26.09,25.610001,25.66,85121700,17.47136
2003-12-01,25.90,26.209999,25.50,25.84,101914600,17.593918
2003-11-28,25.50,25.75,25.40,25.709999,33402600,17.505403
2003-11-26,25.610001,25.629999,25.32,25.450001,69758400,17.328376
2003-11-25,25.870001,25.950001,25.379999,25.40,85663800,17.294331
2003-11-24,25.33,25.809999,25.280001,25.73,99463800,17.519021
2003-11-21,25.33,25.379999,25.08,25.110001,70712900,17.096877
2003-11-20,25.17,25.629999,25.08,25.10,106845700,17.090068
2003-11-19,25.290001,25.540001,25.17,25.35,78853300,17.260287
2003-11-18,25.33,25.84,25.120001,25.15,106868300,17.124111
2003-11-17,25.389999,25.440001,24.84,25.15,103900200,17.124111
2003-11-14,25.700001,26.02,25.440001,25.50,83146400,17.362419
2003-11-13,25.860001,25.93,25.450001,25.690001,78949500,17.491786
2003-11-12,25.85,26.139999,25.60,25.98,75877300,17.689241
2003-11-11,26.01,26.08,25.67,25.799999,64990700,17.566682
2003-11-10,26.120001,26.23,26.00,26.00,54579100,17.702859
2003-11-07,26.379999,26.49,26.030001,26.10,57822100,17.770947
2003-11-06,26.26,26.299999,26.00,26.23,68189800,17.85946
2003-11-05,26.15,26.32,26.00,26.10,61514400,17.770947
2003-11-04,26.59,26.620001,26.01,26.07,84026100,17.75052
2003-11-03,26.35,26.75,26.290001,26.68,57772300,18.165857
2003-10-31,26.370001,26.440001,26.110001,26.139999,69623700,17.798181
2003-10-30,27.01,27.040001,25.91,26.120001,98729400,17.784565
2003-10-29,27.16,27.25,26.66,26.74,73551500,18.206709
2003-10-28,27.09,27.219999,26.879999,27.200001,71752600,18.519914
2003-10-27,26.91,27.10,26.82,26.91,65619100,18.322459
2003-10-24,27.27,27.40,26.42,26.610001,210558300,18.118195
2003-10-23,28.719999,29.08,28.10,28.91,67357900,19.684217
2003-10-22,29.030001,29.209999,28.799999,28.889999,48798500,19.670599
2003-10-21,29.35,29.43,29.17,29.35,44166800,19.983804
2003-10-20,28.950001,29.370001,28.799999,29.35,38794500,19.983804
2003-10-17,29.280001,29.290001,28.799999,28.93,49960000,19.697835
2003-10-16,28.91,29.309999,28.799999,29.23,42232500,19.902098
2003-10-15,29.200001,29.26,28.700001,29.07,57242100,19.793157
2003-10-14,28.66,28.77,28.48,28.68,34851300,19.418674
2003-10-13,28.98,29.10,28.50,28.780001,39320300,19.486383
2003-10-10,28.91,29.200001,28.67,28.91,37604700,19.574403
2003-10-09,29.219999,29.35,28.799999,28.940001,62653300,19.594716
2003-10-08,29.360001,29.360001,28.68,28.82,46989100,19.513465
2003-10-07,29.01,29.370001,28.92,29.139999,52356800,19.730131
2003-10-06,29.15,29.299999,28.91,29.190001,34047600,19.763986
2003-10-03,29.16,29.459999,28.93,29.08,57303000,19.689506
2003-10-02,28.450001,28.75,28.190001,28.50,38143600,19.2968
2003-10-01,28.030001,28.629999,27.809999,28.52,58375900,19.310342
2003-09-30,28.59,28.610001,27.75,27.799999,63333700,18.822843
2003-09-29,28.41,28.91,28.10,28.83,47380300,19.520236
2003-09-26,28.27,28.780001,28.139999,28.190001,49864700,19.086905
2003-09-25,28.469999,28.959999,28.219999,28.24,56224500,19.120759
2003-09-24,29.610001,29.700001,28.42,28.459999,66336500,19.269716
2003-09-23,29.120001,29.709999,28.879999,29.60,57827800,20.041589
2003-09-22,29.389999,30.00,28.809999,29.07,65678700,19.682735
2003-09-19,29.76,29.969999,29.52,29.959999,92433800,20.285337
2003-09-18,28.49,29.51,28.42,29.50,67268100,19.97388
2003-09-17,28.76,28.950001,28.469999,28.50,47221600,19.2968
2003-09-16,28.41,28.950001,28.32,28.90,52060600,19.567632
2003-09-15,28.370001,28.610001,28.33,28.360001,41432300,19.202009
2003-09-12,27.48,28.40,27.450001,28.34,55777200,19.188467
2003-09-11,27.66,28.110001,27.59,27.84,37813300,18.849927
2003-09-10,28.030001,28.18,27.48,27.549999,54763500,18.653573
2003-09-09,28.65,28.709999,28.309999,28.370001,44315200,19.20878
2003-09-08,28.389999,28.92,28.34,28.84,46105300,19.527007
2003-09-05,28.23,28.75,28.17,28.379999,64024500,19.215549
2003-09-04,28.10,28.469999,27.99,28.43,59840800,19.249404
2003-09-03,27.42,28.40,27.379999,28.299999,109437800,19.161383
2003-09-02,26.700001,27.299999,26.469999,27.26,74168900,18.45722
2003-08-29,26.459999,26.549999,26.35,26.52,34503000,17.95618
2003-08-28,26.50,26.58,26.24,26.51,46211200,17.949409
2003-08-27,26.51,26.58,26.299999,26.42,30633900,17.888472
2003-08-26,26.309999,26.67,25.959999,26.57,47546000,17.990034
2003-08-25,26.309999,26.540001,26.23,26.50,36132900,17.942638
2003-08-22,26.780001,26.950001,26.209999,26.219999,65846300,17.753055
2003-08-21,26.65,26.73,26.129999,26.24,63802700,17.766597
2003-08-20,26.299999,26.530001,26.00,26.450001,56739300,17.908785
2003-08-19,25.85,26.65,25.77,26.620001,72952900,18.023889
2003-08-18,25.559999,25.83,25.459999,25.700001,45817400,17.400974
2003-08-15,25.610001,25.66,25.43,25.540001,27607900,17.292641
2003-08-14,25.66,25.709999,25.52,25.629999,37338300,17.353578
2003-08-13,25.790001,25.889999,25.50,25.60,39636900,17.333266
2003-08-12,25.709999,25.77,25.450001,25.73,38208400,17.421286
2003-08-11,25.610001,25.99,25.540001,25.610001,36433900,17.340037
2003-08-08,25.879999,25.98,25.50,25.58,33241400,17.319724
2003-08-07,25.719999,25.809999,25.450001,25.709999,44258500,17.407744
2003-08-06,25.540001,26.190001,25.43,25.65,56294900,17.367119
2003-08-05,26.309999,26.540001,25.60,25.66,58825800,17.37389
2003-08-04,26.15,26.41,25.75,26.18,51825600,17.725973
2003-08-01,26.33,26.51,26.120001,26.17,42649700,17.719202
2003-07-31,26.60,26.99,26.309999,26.41,64504800,17.881701
2003-07-30,26.459999,26.57,26.17,26.23,41240300,17.759826
2003-07-29,26.879999,26.90,26.24,26.469999,62391100,17.922325
2003-07-28,26.940001,27.00,26.49,26.610001,52658300,18.017118
2003-07-25,26.280001,26.950001,26.07,26.889999,54173000,18.206699
2003-07-24,26.780001,26.92,25.98,26.00,53556600,17.604098
2003-07-23,26.42,26.65,26.139999,26.450001,49828200,17.908785
2003-07-22,26.280001,26.559999,26.129999,26.379999,51791000,17.861388
2003-07-21,26.870001,26.91,26.00,26.040001,48480800,17.631182
2003-07-18,27.110001,27.23,26.75,26.889999,63388400,18.206699
2003-07-17,27.139999,27.27,26.540001,26.690001,72805000,18.071284
2003-07-16,27.559999,27.620001,27.200001,27.52,49838900,18.633261
2003-07-15,27.469999,27.530001,27.10,27.27,53567600,18.463991
2003-07-14,27.629999,27.809999,27.049999,27.40,60464400,18.552011
2003-07-11,26.950001,27.450001,26.889999,27.309999,50377300,18.491073
2003-07-10,27.25,27.42,26.59,26.91,55350800,18.220241
2003-07-09,27.559999,27.700001,27.25,27.469999,62300700,18.599406
2003-07-08,27.26,27.799999,27.25,27.700001,61896800,18.755136
2003-07-07,27.02,27.549999,26.950001,27.42,88960800,18.565553
2003-07-03,26.690001,26.950001,26.41,26.50,39440900,17.942638
2003-07-02,26.50,26.93,26.450001,26.879999,94069300,18.199928
2003-07-01,25.59,26.200001,25.389999,26.15,60926000,17.70566
2003-06-30,25.940001,26.120001,25.50,25.639999,48073100,17.360349
2003-06-27,25.950001,26.34,25.530001,25.629999,76040300,17.353578
2003-06-26,25.389999,26.51,25.209999,25.75,51758100,17.434828
2003-06-25,25.639999,25.99,25.139999,25.26,60483500,17.103058
2003-06-24,25.65,26.040001,25.52,25.700001,51820300,17.400974
2003-06-23,26.139999,26.24,25.49,25.780001,52584500,17.455141
2003-06-20,26.34,26.379999,26.01,26.33,86048900,17.827535
2003-06-19,26.09,26.389999,26.01,26.07,63626900,17.651493
2003-06-18,25.98,26.43,25.709999,26.07,89957700,17.651493
2003-06-17,25.639999,26.139999,25.530001,25.959999,122213900,17.577014
2003-06-16,24.799999,25.42,24.67,25.389999,69658600,17.191078
2003-06-13,25.200001,25.25,24.49,24.65,55157500,16.690039
2003-06-12,24.969999,25.139999,24.74,24.99,66177700,16.920246
2003-06-11,24.67,24.959999,24.42,24.879999,75768600,16.845767
2003-06-10,23.940001,24.75,23.85,24.68,80655300,16.710352
2003-06-09,23.719999,23.98,23.60,23.75,73610000,16.080666
2003-06-06,24.440001,24.559999,23.65,23.67,119629400,16.0265
2003-06-05,24.469999,24.52,24.01,24.09,115877900,16.310874
2003-06-04,24.99,25.219999,24.74,24.870001,83484600,16.838997
2003-06-03,24.75,24.92,24.57,24.879999,61058200,16.845767
2003-06-02,24.98,25.030001,24.57,24.639999,66310800,16.683268
2003-05-30,24.73,24.91,24.51,24.610001,85096700,16.662956
2003-05-29,24.469999,24.67,24.23,24.40,75451300,16.520769
2003-05-28,24.780001,24.870001,24.299999,24.41,91467000,16.52754
2003-05-27,24.25,24.889999,24.219999,24.790001,68486800,16.784831
2003-05-23,24.200001,24.540001,24.030001,24.219999,76968000,16.398894
2003-05-22,24.200001,24.27,24.040001,24.16,93157100,16.358269
2003-05-21,24.629999,24.709999,23.889999,24.030001,108960900,16.270249
2003-05-20,24.860001,25.00,24.50,24.629999,52677600,16.676497
2003-05-19,25.40,25.540001,24.74,24.76,55336300,16.764518
2003-05-16,25.879999,26.049999,25.41,25.57,60620900,17.312953
2003-05-15,25.85,26.01,25.57,25.790001,45450200,17.461912
2003-05-14,26.08,26.18,25.540001,25.620001,45021000,17.346808
2003-05-13,26.040001,26.200001,25.889999,25.99,44501900,17.597327
2003-05-12,26.15,26.469999,26.059999,26.200001,53900800,17.739515
2003-05-09,25.90,26.50,25.889999,26.360001,58913600,17.847847
2003-05-08,25.75,26.139999,25.709999,25.74,46401400,17.428057
2003-05-07,26.110001,26.35,25.84,25.99,49120000,17.597327
2003-05-06,25.860001,26.50,25.82,26.370001,54299500,17.854618
2003-05-05,26.25,26.389999,25.84,25.860001,50391500,17.509307
2003-05-02,25.65,26.290001,25.559999,26.10,52695400,17.671806
2003-05-01,25.540001,25.950001,25.34,25.719999,42085800,17.414515
2003-04-30,25.73,25.879999,25.25,25.57,55566800,17.312953
2003-04-29,25.950001,26.25,25.68,25.799999,65877300,17.468681
2003-04-28,25.389999,25.940001,25.32,25.74,56287600,17.428057
2003-04-25,25.33,25.639999,25.17,25.219999,53657400,17.075975
2003-04-24,25.48,25.719999,25.32,25.49,51703600,17.258787
2003-04-23,25.75,25.99,25.469999,25.719999,55559300,17.414515
2003-04-22,25.059999,25.799999,25.030001,25.76,58844000,17.441599
2003-04-21,25.610001,25.610001,25.08,25.209999,41557800,17.069204
2003-04-17,24.77,25.540001,24.74,25.50,58356600,17.265558
2003-04-16,25.60,25.74,24.60,24.92,86178700,16.872851
2003-04-15,24.68,24.790001,24.10,24.60,63399000,16.656185
2003-04-14,24.27,24.879999,24.00,24.76,51599600,16.764518
2003-04-11,24.889999,25.18,23.950001,24.200001,71565500,16.385353
2003-04-10,24.709999,24.790001,24.280001,24.59,51608900,16.649414
2003-04-09,25.610001,25.67,24.540001,24.57,76875800,16.635872
2003-04-08,25.309999,25.83,25.200001,25.58,54132100,17.319724
2003-04-07,26.23,26.43,25.17,25.17,65627100,17.042121
2003-04-04,25.76,25.799999,24.93,25.09,55740600,16.987955
2003-04-03,25.99,26.09,25.60,25.73,57394300,17.421286
2003-04-02,25.10,26.00,25.10,25.719999,68282500,17.414515
2003-04-01,24.459999,24.700001,24.25,24.35,49803200,16.486915
2003-03-31,24.25,24.709999,24.01,24.209999,71384000,16.392123
2003-03-28,24.67,25.10,24.60,24.67,39584600,16.703581
2003-03-27,24.940001,25.26,24.59,25.040001,60043300,16.954101
2003-03-26,25.459999,25.620001,25.24,25.25,51673600,17.096287
2003-03-25,25.60,25.75,25.030001,25.49,63595100,17.258787
2003-03-24,25.549999,25.93,25.18,25.290001,61105200,17.123371
2003-03-21,26.75,26.799999,26.030001,26.57,85586800,17.990034
2003-03-20,26.02,26.52,25.67,26.25,71798500,17.773368
2003-03-19,25.98,26.43,25.74,26.32,73652100,17.820764
2003-03-18,25.889999,26.040001,25.50,26.040001,78108800,17.631182
2003-03-17,24.52,25.950001,24.33,25.93,100983800,17.556703
2003-03-14,24.68,24.959999,24.26,24.860001,75451400,16.832226
2003-03-13,23.719999,24.74,23.440001,24.67,80701300,16.703581
2003-03-12,22.809999,23.440001,22.549999,23.389999,72379500,15.836917
2003-03-11,23.059999,23.26,22.76,22.799999,53990700,15.437439
2003-03-10,23.309999,23.459999,22.889999,22.950001,48413600,15.539002
2003-03-07,22.950001,23.790001,22.90,23.559999,66167600,15.952021
2003-03-06,23.17,23.50,23.129999,23.27,54607600,15.755668
2003-03-05,23.07,23.549999,23.049999,23.440001,55415900,15.870772
2003-03-04,23.58,23.66,23.059999,23.07,56605700,15.620251
2003-03-03,24.02,24.120001,23.40,23.540001,50653500,15.93848
2003-02-28,23.74,24.07,23.549999,23.700001,56585400,16.046813
2003-02-27,23.90,24.209999,23.299999,23.58,75434300,15.965563
2003-02-26,24.07,24.469999,23.58,23.610001,57096000,15.985876
2003-02-25,23.540001,24.27,23.379999,24.190001,68113000,16.378582
2003-02-24,24.440001,24.50,23.84,24.07,62403700,16.297332
2003-02-21,24.290001,24.799999,23.700001,24.629999,56853200,16.676497
2003-02-20,24.77,24.870001,24.10,24.139999,50897200,16.344727
2003-02-19,24.82,24.879999,24.17,24.530001,46902700,16.60879
2003-02-18,24.620001,24.99,24.40,24.959999,57415500,16.845767
2003-02-14,47.25,48.50,46.77,48.299999,90446400,16.299089
2003-02-13,46.41,47.119999,46.130001,46.990002,73558200,15.857024
2003-02-12,46.549999,47.099998,46.259998,46.439999,71315200,15.671422
2003-02-11,47.299999,47.669998,46.00,46.439999,84292000,15.671422
2003-02-10,46.799999,47.52,46.540001,47.380001,74081400,15.988631
2003-02-07,47.880001,47.950001,46.41,46.580002,75208000,15.718667
2003-02-06,46.860001,47.619999,46.560001,47.419998,83312000,16.002128
2003-02-05,47.830002,48.529999,46.73,46.959999,101072000,15.846899
2003-02-04,47.799999,47.939999,46.880001,47.32,81854800,15.968383
2003-02-03,47.93,49.099998,47.459999,48.560001,80129800,16.386829
2003-01-31,47.450001,48.349998,47.029999,47.459999,106858400,16.015627
2003-01-30,50.16,50.169998,48.189999,48.240002,87877400,16.278843
2003-01-29,48.73,50.040001,47.93,49.91,106884000,16.842393
2003-01-28,49.689999,49.700001,48.560001,48.82,86151200,16.474566
2003-01-27,49.32,50.599998,48.41,49.169998,114838600,16.592675
2003-01-24,52.029999,52.049999,49.700001,49.849998,103027000,16.822145
2003-01-23,51.950001,52.540001,51.459999,52.279999,71374800,17.642161
2003-01-22,51.59,52.400002,50.91,51.00,86948000,17.210219
2003-01-21,51.869999,52.150002,51.290001,51.330002,86159200,17.32158
2003-01-17,52.939999,53.00,51.310001,51.459999,155876000,17.365448
2003-01-16,56.32,56.650002,55.110001,55.349998,81371000,18.678149
2003-01-15,57.00,57.32,56.189999,56.27,59622600,18.988608
2003-01-14,56.330002,57.00,56.189999,56.970001,54206400,19.224827
2003-01-13,56.52,56.75,55.77,56.389999,60817800,19.029103
2003-01-10,55.099998,56.299999,54.900002,55.919998,67730200,18.870498
2003-01-09,54.720001,55.919998,54.529999,55.810001,61808000,18.833379
2003-01-08,55.369999,55.549999,54.110001,54.240002,64566000,18.303575
2003-01-07,54.919998,56.009998,54.68,55.799999,80517400,18.830004
2003-01-06,54.02,55.23,53.799999,54.77,59456200,18.482425
2003-01-03,53.59,53.799999,52.880001,53.790001,55546800,18.151719
2003-01-02,52.299999,53.75,51.709999,53.720001,67025200,18.128098
2002-12-31,52.740002,52.990002,51.259998,51.700001,58208800,17.446438
2002-12-30,53.009998,53.240002,52.27,52.75,48019600,17.800766
2002-12-27,53.279999,54.00,52.900002,52.970001,40891600,17.875006
2002-12-26,54.029999,54.689999,53.169998,53.389999,37228000,18.016737
2002-12-24,53.540001,54.23,53.52,53.82,18386000,18.161843
2002-12-23,53.049999,54.279999,52.900002,54.00,48798400,18.222585
2002-12-20,53.490002,53.720001,52.950001,53.040001,98294600,17.898628
2002-12-19,53.25,54.75,52.880001,53.110001,82686600,17.92225
2002-12-18,53.84,54.400002,52.790001,53.529999,62709400,18.06398
2002-12-17,54.419998,54.990002,53.779999,54.360001,49549800,18.344069
2002-12-16,53.00,54.549999,52.669998,54.48,60140400,18.384563
2002-12-13,53.68,53.75,52.490002,52.50,65245400,17.716402
2002-12-12,55.00,55.060001,53.689999,54.169998,55242000,18.279952
2002-12-11,53.849998,55.009998,53.580002,54.66,69186200,18.445305
2002-12-10,53.560001,54.48,53.48,54.009998,63730200,18.225959
2002-12-09,55.00,55.220001,53.509998,53.529999,63862800,18.06398
2002-12-06,54.869999,55.740002,54.220001,55.470001,71670200,18.718644
2002-12-05,56.950001,57.09,55.299999,55.34,68435800,18.674775
2002-12-04,56.130001,57.439999,55.82,56.540001,83892000,19.079721
2002-12-03,57.279999,57.349998,56.41,56.709999,58457400,19.137088
2002-12-02,58.650002,58.959999,57.009998,57.689999,63735000,19.467794
2002-11-29,58.43,58.630001,57.68,57.68,28393000,19.46442
2002-11-27,57.599998,58.610001,57.400002,58.080002,55191800,19.599403
2002-11-26,57.639999,58.25,56.779999,56.900002,68650400,19.201206
2002-11-25,58.060001,58.639999,57.57,58.23,61583000,19.65002
2002-11-22,57.450001,58.299999,57.049999,58.220001,70002000,19.646646
2002-11-21,56.98,58.00,56.779999,57.84,82922200,19.518413
2002-11-20,55.009998,56.900002,54.93,56.619999,76435400,19.106717
2002-11-19,55.549999,55.799999,54.310001,54.860001,76403400,18.512796
2002-11-18,56.950001,57.029999,55.740002,55.849998,58086400,18.846876
2002-11-15,56.599998,56.919998,55.669998,56.689999,77533600,19.130339
2002-11-14,55.990002,57.00,55.869999,56.990002,78337000,19.231577
2002-11-13,54.240002,55.93,54.110001,55.360001,107370200,18.681524
2002-11-12,54.099998,55.43,53.900002,54.509998,81398600,18.394686
2002-11-11,55.07,55.099998,53.82,53.860001,58341200,18.175341
2002-11-08,56.00,56.549999,55.009998,55.099998,64522200,18.593785
2002-11-07,56.200001,56.619999,55.50,56.009998,73699600,18.900869
2002-11-06,56.990002,57.099998,55.529999,57.029999,115407000,19.245074
2002-11-05,55.779999,56.799999,55.580002,56.68,76658200,19.126965
2002-11-04,56.75,57.25,55.52,56.099998,139964200,18.93124
2002-11-01,52.43,53.240002,51.900002,53.00,105097800,17.885129
2002-10-31,53.189999,54.07,52.849998,53.470001,105973800,18.043734
2002-10-30,52.200001,53.389999,51.630001,53.110001,94451200,17.92225
2002-10-29,52.150002,52.490002,50.849998,52.07,90517200,17.571296
2002-10-28,53.400002,53.50,51.509998,51.950001,79906600,17.530802
2002-10-25,51.25,52.799999,51.16,52.68,75425800,17.777144
2002-10-24,53.360001,53.369999,50.900002,51.23,95833400,17.287833
2002-10-23,51.43,53.259998,51.43,53.200001,110866600,17.952621
2002-10-22,51.43,51.93,51.029999,51.669998,87159000,17.436313
2002-10-21,51.970001,52.990002,51.360001,52.509998,112378600,17.719776
2002-10-18,52.599998,53.200001,51.139999,53.150002,152817200,17.935748
2002-10-17,52.279999,52.50,50.049999,50.77,182602400,17.132604
2002-10-16,50.389999,51.259998,50.279999,50.41,95437400,17.01112
2002-10-15,51.259998,52.369999,50.650002,52.290001,133374200,17.645537
2002-10-14,48.25,49.330002,47.84,49.290001,76216200,16.633171
2002-10-11,47.360001,48.900002,47.009998,48.869999,108828800,16.491439
2002-10-10,44.00,46.619999,43.25,46.380001,118515000,15.651176
2002-10-09,44.23,45.450001,43.810001,43.990002,123142600,14.844658
2002-10-08,44.75,45.98,44.130001,44.990002,115667600,15.182113
2002-10-07,43.810001,45.060001,43.689999,44.049999,89790000,14.864905
2002-10-04,45.389999,45.57,43.689999,43.77,107120400,14.770417
2002-10-03,45.299999,46.59,44.599998,44.799999,105221400,15.117996
2002-10-02,46.099998,46.810001,45.16,45.610001,103488600,15.391335
2002-10-01,44.32,46.25,43.189999,46.23,110636600,15.600557
2002-09-30,44.869999,45.040001,43.110001,43.740002,115577000,14.760294
2002-09-27,46.040001,47.099998,45.189999,45.25,81011600,15.269851
2002-09-26,47.110001,47.50,45.950001,46.200001,100852200,15.590434
2002-09-25,46.400002,46.959999,45.049999,46.509998,107116600,15.695044
2002-09-24,44.830002,46.48,44.630001,45.639999,104142200,15.401458
2002-09-23,46.599998,46.709999,44.810001,45.23,89783800,15.263102
2002-09-20,47.709999,48.00,47.299999,47.459999,130619200,16.015627
2002-09-19,46.68,47.82,46.59,47.200001,77777600,15.927889
2002-09-18,46.720001,48.240002,46.66,47.75,83951800,16.113489
2002-09-17,48.669998,48.900002,47.209999,47.290001,73343400,15.95826
2002-09-16,47.599998,48.130001,47.049999,47.779999,50166200,16.123613
2002-09-13,46.900002,48.259998,46.849998,47.91,59549200,16.167482
2002-09-12,48.150002,48.299999,47.02,47.150002,63726800,15.911017
2002-09-11,50.23,51.099998,48.529999,48.580002,77443200,16.393578
2002-09-10,48.540001,49.82,48.349998,49.790001,83950000,16.801898
2002-09-09,47.25,48.950001,46.630001,48.700001,81653200,16.434072
2002-09-06,47.75,48.27,47.470001,47.82,69918400,16.137111
2002-09-05,47.50,47.52,45.880001,45.91,90438800,15.492572
2002-09-04,47.450001,48.599998,47.150002,48.209999,80232000,16.268718
2002-09-03,48.52,48.52,47.00,47.02,74452600,15.867147
2002-08-30,50.139999,50.48,49.00,49.080002,58138400,16.562305
2002-08-29,48.889999,51.00,48.52,50.580002,94275600,17.068488
2002-08-28,50.48,50.66,49.299999,49.380001,68875000,16.663542
2002-08-27,52.330002,52.450001,50.650002,50.84,65470200,17.156226
2002-08-26,52.50,52.650002,51.18,52.099998,55652400,17.581419
2002-08-23,52.66,52.849998,51.84,52.220001,57929200,17.621915
2002-08-22,52.849998,53.450001,52.599998,53.23,72517600,17.962744
2002-08-21,51.560001,52.380001,51.150002,52.279999,81203400,17.642161
2002-08-20,51.380001,51.700001,50.75,51.040001,70317600,17.223717
2002-08-19,50.040001,52.049999,49.849998,52.00,79848200,17.547674
2002-08-16,49.43,50.23,48.919998,50.00,69334000,16.872764
2002-08-15,49.959999,50.740002,48.75,49.77,98745600,16.795149
2002-08-14,47.25,49.73,47.209999,49.709999,96706000,16.774901
2002-08-13,47.990002,49.700001,46.919998,47.060001,100122800,15.880646
2002-08-12,47.610001,48.75,47.599998,48.470001,56866600,16.356457
2002-08-09,48.150002,49.150002,47.66,48.119999,69049400,16.238347
2002-08-08,47.110001,49.00,46.41,48.91,88748000,16.504937
2002-08-07,47.00,47.299999,45.16,47.09,86349400,15.890769
2002-08-06,44.900002,47.25,44.84,45.669998,88715800,15.411582
2002-08-05,44.290001,45.169998,43.810001,43.990002,78941600,14.844658
2002-08-02,45.509998,45.849998,43.799999,44.41,85947600,14.986389
2002-08-01,47.580002,48.09,45.50,45.75,92002800,15.438579
2002-07-31,47.610001,48.00,46.360001,47.98,93875600,16.191104
2002-07-30,47.549999,48.830002,47.330002,48.099998,122690600,16.231598
2002-07-29,46.849998,48.299999,46.549999,48.25,112148600,16.282217
2002-07-26,43.740002,45.41,43.68,45.349998,123538000,15.303596
2002-07-25,45.450001,45.709999,42.439999,42.830002,163411400,14.45321
2002-07-24,41.75,46.360001,41.41,46.23,202307800,15.600557
2002-07-23,46.490002,46.799999,42.970001,43.009998,168061600,14.513951
2002-07-22,48.950001,49.990002,45.900002,47.509998,180069800,16.032499
2002-07-19,49.869999,50.889999,48.810001,49.560001,112543400,16.724284
2002-07-18,52.060001,52.740002,50.66,51.110001,91053600,17.247339
2002-07-17,52.52,53.299999,51.169998,52.00,98034800,17.547674
2002-07-16,51.310001,52.799999,50.639999,51.25,97154600,17.294583
2002-07-15,51.389999,51.860001,48.00,51.799999,136965600,17.480183
2002-07-12,53.369999,53.73,51.48,51.860001,95733800,17.500431
2002-07-11,52.040001,53.07,51.25,52.91,129550600,17.854758
2002-07-10,53.689999,54.200001,52.130001,52.240002,90673400,17.628664
2002-07-09,53.310001,54.73,52.970001,53.209999,85277200,17.955995
2002-07-08,54.41,54.93,52.580002,52.919998,63199400,17.858132
2002-07-05,53.09,54.900002,53.049999,54.849998,35673600,18.509421
2002-07-03,51.240002,52.52,50.450001,51.84,80936600,17.493681
2002-07-02,52.380001,52.919998,51.330002,51.439999,82814200,17.358699
2002-07-01,54.119999,54.389999,52.580002,52.66,66473800,17.770395
2002-06-28,54.549999,55.790001,54.00,54.700001,89555600,18.458804
2002-06-27,54.599998,54.939999,52.860001,54.919998,95812400,18.533043
2002-06-26,51.049999,54.389999,51.049999,54.130001,112131400,18.266454
2002-06-25,54.700001,55.00,52.799999,52.950001,84025200,17.868257
2002-06-24,52.09,54.639999,51.849998,54.16,104523200,18.276578
2002-06-21,53.400002,54.549999,52.279999,52.279999,116820000,17.642161
2002-06-20,54.369999,55.099998,53.900002,54.099998,86401200,18.25633
2002-06-19,55.470001,55.939999,54.32,54.360001,81247000,18.344069
2002-06-18,55.529999,56.290001,55.349998,55.990002,77518400,18.894121
2002-06-17,55.66,56.439999,55.369999,55.68,94486600,18.78951
2002-06-14,53.150002,55.549999,53.00,55.25,109433600,18.644404
2002-06-13,54.84,55.48,54.200001,54.220001,79771600,18.296825
2002-06-12,52.580002,55.779999,52.50,55.540001,136198600,18.742266
2002-06-11,53.240002,54.18,52.419998,52.57,74368200,17.740024
2002-06-10,51.650002,53.299999,51.459999,52.82,71825400,17.824387
2002-06-07,49.889999,52.599998,49.860001,51.98,97834400,17.540925
2002-06-06,51.50,52.139999,50.00,51.900002,78703400,17.513929
2002-06-05,50.43,51.75,50.330002,51.66,66969400,17.432939
2002-06-04,49.50,51.23,49.240002,49.98,88008400,16.866014
2002-06-03,50.990002,51.639999,49.169998,49.419998,88439000,16.677039
2002-05-31,52.900002,53.419998,50.880001,50.91,66468000,17.179848
2002-05-30,51.639999,53.360001,51.43,52.639999,63213000,17.763645
2002-05-29,51.650002,52.720001,51.549999,52.049999,45393200,17.564547
2002-05-28,53.59,53.689999,51.75,52.32,49602000,17.65566
2002-05-24,54.139999,54.52,53.040001,53.259998,35982000,17.972867
2002-05-23,53.700001,54.84,53.009998,54.82,51412800,18.499298
2002-05-22,51.869999,53.720001,51.849998,53.689999,54169400,18.117973
2002-05-21,53.950001,54.599998,52.130001,52.189999,63120000,17.61179
2002-05-20,55.50,55.549999,53.50,54.009998,52115800,18.225959
2002-05-17,56.209999,56.400002,55.27,56.029999,54646200,18.907619
2002-05-16,54.709999,56.029999,54.650002,55.740002,53406400,18.809757
2002-05-15,54.490002,56.439999,53.860001,54.75,70412000,18.475676
2002-05-14,54.400002,55.099998,53.98,54.880001,64832400,18.519546
2002-05-13,50.450001,52.91,49.75,52.689999,64819000,17.780518
2002-05-10,52.529999,52.669998,49.990002,50.049999,64408800,16.889636
2002-05-09,54.400002,55.00,51.900002,52.119999,83288200,17.588168
2002-05-08,51.27,54.970001,51.220001,54.970001,101242000,18.549917
2002-05-07,49.18,50.290001,48.349998,49.470001,88385400,16.693913
2002-05-06,49.439999,50.540001,48.369999,48.619999,66299400,16.407075
2002-05-03,51.259998,51.68,49.509998,49.560001,71628000,16.724284
2002-05-02,52.639999,54.07,51.150002,51.209999,79009200,17.281084
2002-05-01,52.16,53.189999,50.66,52.75,76413000,17.800766
2002-04-30,52.099998,53.299999,51.919998,52.259998,77384000,17.635412
2002-04-29,51.470001,52.91,51.439999,52.240002,70246000,17.628664
2002-04-26,54.07,54.450001,51.459999,51.50,62776600,17.378947
2002-04-25,52.900002,54.450001,52.880001,53.73,57290400,18.131472
2002-04-24,53.849998,54.43,53.00,53.02,61220400,17.891879
2002-04-23,55.700001,55.82,53.299999,53.990002,68281400,18.219211
2002-04-22,56.52,56.700001,55.00,55.59,51465200,18.759139
2002-04-19,57.439999,57.98,56.860001,57.200001,104268600,19.302442
2002-04-18,56.790001,57.310001,52.68,56.369999,74794800,19.022353
2002-04-17,57.950001,58.279999,56.419998,56.630001,55158600,19.110092
2002-04-16,56.400002,58.099998,56.360001,57.810001,51921600,19.50829
2002-04-15,56.00,56.75,55.400002,55.689999,47388800,18.792884
2002-04-12,55.150002,56.259998,54.860001,55.93,52297600,18.873874
2002-04-11,55.889999,56.450001,54.50,54.790001,58165800,18.489175
2002-04-10,55.119999,57.110001,55.060001,56.299999,75636400,18.998732
2002-04-09,57.330002,57.43,54.799999,54.869999,63413000,18.51617
2002-04-08,54.299999,57.310001,54.259998,57.220001,73389600,19.309191
2002-04-05,56.889999,57.299999,55.84,55.869999,50166000,18.853626
2002-04-04,55.98,56.970001,55.419998,56.450001,61763800,19.04935
2002-04-03,57.439999,57.610001,55.50,56.330002,76931400,19.008856
2002-04-02,58.900002,59.09,57.110001,57.279999,76509400,19.329438
2002-04-01,59.830002,60.400002,59.200001,60.380001,47010000,20.37555
2002-03-28,59.950001,60.650002,59.66,60.310001,43901200,20.351928
2002-03-27,58.799999,59.880001,58.59,59.439999,47318400,20.058341
2002-03-26,59.099998,60.919998,58.310001,59.080002,69357200,19.936858
2002-03-25,60.48,60.779999,59.150002,59.23,47752400,19.987476
2002-03-22,61.049999,61.139999,60.220001,60.450001,41341400,20.399171
2002-03-21,60.209999,61.59,59.830002,61.360001,46123400,20.706256
2002-03-20,61.400002,62.02,60.099998,60.099998,55235200,20.281061
2002-03-19,62.18,63.00,61.50,62.23,36376400,20.999841
2002-03-18,62.740002,62.990002,61.200001,62.139999,52296800,20.96947
2002-03-15,61.00,62.509998,60.970001,62.490002,69086800,21.087581
2002-03-14,62.139999,62.240002,61.049999,61.220001,51819600,20.659012
2002-03-13,62.080002,63.02,61.950001,62.099998,44387400,20.955972
2002-03-12,62.52,62.799999,61.669998,62.540001,66407200,21.104453
2002-03-11,63.509998,65.00,63.00,64.339996,43718200,21.711871
2002-03-08,63.630001,64.699997,63.169998,63.950001,57701800,21.580265
2002-03-07,63.669998,63.880001,61.860001,62.720001,58079200,21.165195
2002-03-06,62.91,63.700001,62.189999,63.630001,49835400,21.472279
2002-03-05,63.00,63.880001,62.34,63.080002,55926400,21.286679
2002-03-04,61.240002,63.50,60.869999,63.299999,74464200,21.360919
2002-03-01,59.049999,61.419998,58.849998,61.369999,62115600,20.70963
2002-02-28,58.779999,59.700001,58.139999,58.34,68068000,19.687141
2002-02-27,59.07,60.150002,57.990002,58.389999,65750000,19.704013
2002-02-26,59.099998,60.00,57.900002,58.549999,63276200,19.758006
2002-02-25,57.939999,59.889999,57.889999,59.080002,51832200,19.936858
2002-02-22,58.049999,58.75,57.150002,57.990002,71347800,19.569032
2002-02-21,59.720001,60.27,58.009998,58.049999,59398400,19.589278
2002-02-20,59.400002,60.360001,58.799999,59.900002,50492000,20.213571
2002-02-19,59.91,60.139999,58.599998,58.93,52262600,19.886239
2002-02-15,61.700001,62.060001,60.200001,60.23,50179800,20.324931
2002-02-14,62.00,62.990002,61.32,61.68,57267000,20.814241
2002-02-13,60.259998,61.880001,59.950001,61.82,54168600,20.861485
2002-02-12,60.490002,60.849998,60.02,60.139999,44973800,20.29456
2002-02-11,60.009998,61.240002,59.59,61.130001,50899600,20.628641
2002-02-08,60.119999,60.66,58.830002,60.650002,61283000,20.466663
2002-02-07,60.299999,61.610001,59.75,59.799999,63314000,20.179825
2002-02-06,61.610001,61.889999,60.25,60.400002,66103000,20.382299
2002-02-05,60.799999,62.23,60.50,61.150002,66772600,20.63539
2002-02-04,62.400002,62.689999,60.75,61.119999,70308400,20.625266
2002-02-01,64.150002,64.50,62.470001,62.66,63462200,21.144947
2002-01-31,63.060001,63.810001,62.119999,63.709999,69566200,21.499275
2002-01-30,62.450001,62.900002,61.330002,62.849998,66100000,21.209063
2002-01-29,63.900002,64.50,61.990002,62.32,58666000,21.030212
2002-01-28,64.230003,64.400002,62.91,63.82,41622000,21.536395
2002-01-25,64.190002,64.849998,63.509998,63.799999,48981200,21.529646
2002-01-24,64.099998,65.18,63.799999,64.599998,83886000,21.79961
2002-01-23,64.050003,64.709999,63.240002,63.740002,80403000,21.5094
2002-01-22,66.610001,66.629997,64.25,64.459999,76837200,21.752367
2002-01-18,67.099998,67.849998,65.419998,66.099998,107140400,22.305793
2002-01-17,68.529999,70.00,68.400002,69.860001,78958000,23.574626
2002-01-16,68.849998,69.839996,67.849998,67.870003,61955400,22.90309
2002-01-15,68.660004,69.620003,68.50,69.550003,60717400,23.470015
2002-01-14,68.300003,69.040001,67.739998,68.470001,50997800,23.105563
2002-01-11,69.519997,70.32,68.099998,68.610001,72993200,23.152806
2002-01-10,68.480003,69.800003,68.129997,69.279999,50296600,23.378901
2002-01-09,69.720001,70.620003,68.550003,68.709999,76304000,23.186551
2002-01-08,68.690002,69.860001,68.00,69.379997,47736400,23.412646
2002-01-07,69.75,70.019997,68.349998,68.559998,58508800,23.135933
2002-01-04,69.25,69.910004,68.669998,68.900002,52731400,23.250669
2002-01-03,67.110001,69.25,67.089996,69.230003,67590800,23.36203
2002-01-02,66.650002,67.110001,65.510002,67.040001,48124000,22.623002
2001-12-31,67.839996,68.480003,66.25,66.25,43006200,22.356412
2001-12-28,68.230003,68.849998,67.699997,67.870003,28787200,22.90309
2001-12-27,67.980003,68.709999,67.260002,67.849998,32406600,22.89634
2001-12-26,67.419998,69.07,67.389999,67.68,29328000,22.838973
2001-12-24,67.720001,68.029999,67.199997,67.269997,11701600,22.700615
2001-12-21,68.010002,68.019997,67.00,67.540001,84307600,22.791729
2001-12-20,69.150002,69.25,66.620003,66.760002,78585000,22.528515
2001-12-19,68.620003,69.889999,68.449997,69.489998,56996200,23.449766
2001-12-18,68.919998,69.400002,68.599998,69.269997,47255200,23.375526
2001-12-17,67.169998,69.110001,67.160004,68.980003,57079800,23.277666
2001-12-14,66.019997,67.949997,65.93,67.440002,43000600,22.757984
2001-12-13,67.129997,68.239998,66.07,66.269997,53227800,22.36316
2001-12-12,67.160004,67.980003,66.25,67.949997,47884200,22.930085
2001-12-11,67.660004,68.129997,67.07,67.32,54334000,22.717489
2001-12-10,67.519997,68.449997,66.860001,67.059998,38367400,22.62975
2001-12-07,68.25,68.839996,66.550003,67.830002,42334800,22.889592
2001-12-06,67.980003,69.00,67.550003,68.650002,56026200,23.166305
2001-12-05,66.489998,68.169998,65.199997,68.099998,74243000,22.980704
2001-12-04,65.00,66.080002,64.099998,66.00,51005800,22.272048
2001-12-03,63.830002,65.230003,63.799999,64.769997,47211800,21.856977
2001-11-30,64.660004,65.080002,63.93,64.209999,48234200,21.668003
2001-11-29,63.119999,64.900002,62.950001,64.839996,54034400,21.880599
2001-11-28,63.169998,64.120003,62.73,62.799999,54536600,21.192191
2001-11-27,64.790001,65.07,62.75,63.740002,90819000,21.5094
2001-11-26,64.989998,65.709999,64.400002,65.139999,41983600,21.981836
2001-11-23,64.379997,64.809998,63.619999,64.709999,15754600,21.83673
2001-11-21,64.360001,64.599998,63.48,64.050003,50785200,21.614011
2001-11-20,66.449997,67.800003,65.029999,65.400002,65921800,22.069575
2001-11-19,66.25,66.970001,65.699997,66.540001,56005000,22.454274
2001-11-16,66.360001,66.610001,64.949997,65.75,59249000,22.187684
2001-11-15,66.099998,67.050003,65.449997,66.120003,77922000,22.312544
2001-11-14,68.230003,68.339996,65.790001,65.949997,88625600,22.255174
2001-11-13,66.800003,67.949997,66.599998,67.900002,60159600,22.913214
2001-11-12,64.699997,66.440002,63.650002,65.790001,57752800,22.201183
2001-11-09,64.339996,65.650002,63.91,65.209999,48013600,22.005458
2001-11-08,64.459999,66.059998,63.66,64.419998,74227800,21.738868
2001-11-07,64.220001,65.050003,64.029999,64.25,58899000,21.681501
2001-11-06,62.700001,64.940002,62.16,64.779999,68612000,21.860352
2001-11-05,61.860001,64.029999,61.75,63.27,66401600,21.350795
2001-11-02,61.93,63.02,60.509998,61.400002,83360000,20.719754
2001-11-01,60.080002,62.25,59.599998,61.84,109671200,20.868234
2001-10-31,59.299999,60.73,58.099998,58.150002,64700000,19.623025
2001-10-30,58.919998,59.540001,58.189999,58.880001,57395600,19.869367
2001-10-29,62.099998,62.200001,59.540001,59.639999,55129400,20.125832
2001-10-26,62.32,63.630001,62.080002,62.200001,64509400,20.989718
2001-10-25,60.610001,62.599998,59.57,62.560001,75318200,21.111202
2001-10-24,60.50,61.619999,59.619999,61.32,79141400,20.692757
2001-10-23,60.470001,61.439999,59.400002,60.43,80325000,20.392422
2001-10-22,57.900002,60.18,57.470001,60.16,72323600,20.301309
2001-10-19,57.400002,58.009998,55.630001,57.900002,91219600,19.538661
2001-10-18,56.34,57.580002,55.50,56.75,78348000,19.150587
2001-10-17,59.119999,59.299999,55.98,56.029999,73710600,18.907619
2001-10-16,57.869999,58.91,57.209999,58.450001,66169000,19.724261
2001-10-15,55.900002,58.50,55.849998,58.060001,68437000,19.592654
2001-10-12,55.700001,56.639999,54.549999,56.380001,63307000,19.025729
2001-10-11,55.759998,56.84,54.59,56.32,83742600,19.005481
2001-10-10,53.599998,55.75,53.00,55.509998,86349200,18.732142
2001-10-09,57.50,57.57,54.189999,54.560001,99477600,18.41156
2001-10-08,56.799999,58.650002,56.740002,58.040001,60605800,19.585904
2001-10-05,56.16,58.00,54.939999,57.720001,80844400,19.477919
2001-10-04,56.919998,58.400002,56.209999,56.439999,101778000,19.045975
2001-10-03,52.48,56.93,52.400002,56.23,97199200,18.97511
2001-10-02,51.630001,53.549999,51.560001,53.049999,80860800,17.902002
2001-10-01,50.939999,52.50,50.41,51.790001,69999600,17.476809
2001-09-28,49.619999,51.59,48.98,51.169998,116641200,17.267586
2001-09-27,50.099998,50.68,48.00,49.959999,81191200,16.859265
2001-09-26,51.509998,51.799999,49.549999,50.27,58524400,16.963877
2001-09-25,52.27,53.00,50.16,51.299999,84940600,17.311455
2001-09-24,50.650002,52.450001,49.869999,52.009998,85580200,17.551048
2001-09-21,47.919998,50.599998,47.50,49.709999,184976600,16.774901
2001-09-20,52.349998,52.610001,50.669998,50.759998,117983200,17.129229
2001-09-19,54.459999,54.700001,50.599998,53.869999,126950200,18.178715
2001-09-18,53.41,55.00,53.169998,54.32,83182600,18.33057
2001-09-17,54.02,55.099998,52.799999,52.91,127502000,17.854758
2001-09-10,54.919998,57.950001,54.700001,57.580002,84471800,19.430675
2001-09-07,56.110001,57.360001,55.310001,55.400002,89863800,18.695023
2001-09-06,56.560001,58.389999,55.900002,56.02,112356800,18.904245
2001-09-05,56.18,58.389999,55.389999,57.740002,89470600,19.484668
2001-09-04,57.189999,59.080002,56.07,56.099998,67189200,18.93124
2001-08-31,56.849998,58.060001,56.299999,57.049999,57900800,19.251823
2001-08-30,59.040001,59.66,56.52,56.939999,97632000,19.214703
2001-08-29,61.049999,61.299999,59.540001,60.25,48170000,20.33168
2001-08-28,62.34,62.950001,60.580002,60.740002,47422800,20.497034
2001-08-27,61.900002,63.360001,61.57,62.310001,44562800,21.026839
2001-08-24,59.599998,62.279999,59.23,62.049999,63399000,20.939099
2001-08-23,60.669998,61.529999,59.00,59.119999,51813200,19.950355
2001-08-22,61.130001,61.150002,59.080002,60.66,78107200,20.470037
2001-08-21,62.700001,63.200001,60.709999,60.779999,47111800,20.510531
2001-08-20,61.66,62.75,61.099998,62.700001,48371200,21.158446
2001-08-17,63.779999,64.129997,61.50,61.880001,52234200,20.881733
2001-08-16,62.84,64.709999,62.700001,64.620003,43905600,21.806361
2001-08-15,64.709999,65.050003,63.200001,63.200001,39503000,21.327173
2001-08-14,65.75,66.089996,64.449997,64.690002,36481200,21.829982
2001-08-13,65.239998,65.989998,64.75,65.830002,32675400,22.214681
2001-08-10,64.769997,65.860001,62.900002,65.519997,51756400,22.110068
2001-08-09,64.980003,65.550003,64.300003,65.010002,45536200,21.937968
2001-08-08,66.510002,67.239998,64.489998,64.860001,54996400,21.887349
2001-08-07,66.040001,67.050003,65.989998,66.349998,31347800,22.390157
2001-08-06,66.529999,67.120003,65.68,66.129997,27831600,22.315916
2001-08-03,67.300003,67.360001,66.00,66.889999,43260400,22.572383
2001-08-02,67.209999,67.540001,66.260002,67.449997,54198400,22.761357
2001-08-01,66.800003,66.809998,65.760002,66.470001,55679000,22.430652
2001-07-31,66.010002,67.389999,65.849998,66.190002,59031600,22.336165
2001-07-30,65.650002,66.879997,65.540001,65.800003,42196400,22.204558
2001-07-27,66.050003,66.25,65.050003,65.470001,65396000,22.093197
2001-07-26,67.120003,67.32,65.50,66.589996,77974000,22.471145
2001-07-25,66.260002,67.519997,65.610001,67.480003,74065400,22.771483
2001-07-24,67.00,67.989998,65.699997,66.32,67530200,22.380034
2001-07-23,69.239998,69.239998,66.349998,67.089996,79999400,22.639873
2001-07-20,68.029999,69.400002,67.940002,69.18,124203600,23.345156
2001-07-19,71.220001,73.00,71.220001,72.57,76549400,24.489129
2001-07-18,70.599998,71.50,69.870003,70.57,57590800,23.814218
2001-07-17,70.660004,72.010002,70.139999,71.82,63241000,24.236038
2001-07-16,71.449997,72.160004,70.150002,71.18,55990800,24.020066
2001-07-13,71.400002,72.00,70.940002,71.339996,58934600,24.074058
2001-07-12,70.699997,72.050003,70.330002,71.599998,128078000,24.161797
2001-07-11,64.209999,66.75,64.199997,66.50,73822600,22.440776
2001-07-10,65.900002,66.25,64.349998,64.480003,66562600,21.759117
2001-07-09,66.199997,66.910004,65.040001,65.690002,66476600,22.167438
2001-07-06,68.300003,68.400002,65.669998,66.059998,67467800,22.292294
2001-07-05,70.220001,70.720001,68.440002,68.510002,49242600,23.119061
2001-07-03,70.300003,70.800003,69.93,70.470001,28037400,23.780473
2001-07-02,72.050003,73.150002,70.150002,70.599998,72810200,23.824342
2001-06-29,72.599998,73.410004,71.400002,73.00,94283800,24.634235
2001-06-28,71.550003,76.150002,70.529999,72.739998,128975600,24.546496
2001-06-27,69.860001,71.529999,69.360001,71.139999,69199800,24.006568
2001-06-26,67.82,70.209999,67.699997,70.139999,63077000,23.669113
2001-06-25,69.099998,69.809998,67.769997,68.849998,49215600,23.233795
2001-06-22,70.00,70.610001,68.580002,68.830002,51092000,23.227047
2001-06-21,69.150002,70.550003,68.919998,69.839996,69603800,23.567875
2001-06-20,67.139999,69.589996,67.099998,69.410004,64108400,23.422772
2001-06-19,68.209999,68.849998,66.849998,67.32,63457400,22.717489
2001-06-18,67.949997,67.959999,66.010002,66.879997,56846800,22.569008
2001-06-15,67.510002,68.300003,66.400002,68.019997,108354400,22.953707
2001-06-14,70.220001,70.550003,68.400002,68.900002,71972400,23.250669
2001-06-13,72.050003,72.300003,70.639999,70.690002,55302400,23.854714
2001-06-12,71.019997,72.410004,70.809998,72.080002,66714600,24.323777
2001-06-11,72.849998,72.849998,71.510002,72.120003,47345600,24.337275
2001-06-08,73.699997,73.75,72.050003,73.190002,51867000,24.698352
2001-06-07,72.120003,73.730003,72.080002,73.68,66960000,24.863705
2001-06-06,72.889999,73.480003,71.550003,72.360001,80022800,24.418264
2001-06-05,70.760002,73.080002,70.50,72.599998,89454200,24.499252
2001-06-04,70.550003,71.019997,69.800003,70.779999,43736600,23.885084
2001-06-01,69.599998,70.699997,68.699997,70.339996,57587600,23.736603
2001-05-31,69.489998,70.379997,68.400002,69.18,70682600,23.345156
2001-05-30,69.559998,70.580002,68.650002,69.190002,86501800,23.348531
2001-05-29,70.800003,71.75,70.050003,70.339996,71210800,23.736603
2001-05-25,71.660004,71.900002,70.360001,70.910004,52747600,23.928955
2001-05-24,69.940002,71.779999,69.269997,71.720001,80781600,24.202293
2001-05-23,70.389999,71.599998,69.510002,69.699997,93637400,23.520631
2001-05-22,69.449997,70.349998,69.18,70.309998,83455600,23.726479
2001-05-21,68.050003,69.989998,67.75,68.790001,103491600,23.213549
2001-05-18,67.690002,69.199997,67.25,68.089996,90605400,22.977328
2001-05-17,69.099998,70.139999,67.550003,68.169998,106984800,23.004325
2001-05-16,67.699997,69.879997,67.330002,69.160004,91893800,23.338408
2001-05-15,68.739998,69.300003,68.00,68.269997,61385600,23.03807
2001-05-14,69.129997,69.199997,68.300003,68.720001,44968000,23.189927
2001-05-11,69.959999,70.00,68.650002,69.400002,51128800,23.419396
2001-05-10,71.129997,71.239998,69.959999,70.00,64334600,23.621869
2001-05-09,71.239998,71.300003,69.860001,70.400002,76676600,23.756852
2001-05-08,71.75,72.099998,70.75,72.059998,75084000,24.317026
2001-05-07,70.830002,72.150002,70.699997,71.379997,109356200,24.087556
2001-05-04,68.00,71.050003,67.959999,70.75,119538400,23.874961
2001-05-03,69.25,70.18,68.139999,68.529999,66273400,23.125809
2001-05-02,71.00,71.150002,69.349998,69.760002,92864400,23.540881
2001-05-01,67.660004,70.300003,67.599998,70.169998,83702800,23.679236
2001-04-30,68.529999,69.059998,67.68,67.75,74368200,22.862595
2001-04-27,69.529999,69.68,66.209999,67.120003,121572400,22.649999
2001-04-26,70.07,71.00,68.25,69.129997,118737600,23.328282
2001-04-25,67.57,69.790001,67.25,69.690002,76744000,23.517259
2001-04-24,68.199997,69.93,67.139999,67.550003,89176600,22.795105
2001-04-23,68.110001,68.470001,66.900002,68.25,92171200,23.031322
2001-04-20,70.300003,71.099998,68.50,69.00,192919600,23.284414
2001-04-19,65.809998,69.00,65.75,68.040001,159375600,22.960457
2001-04-18,63.389999,66.309998,63.00,65.43,156696400,22.079699
2001-04-17,60.52,62.110001,60.040001,61.48,85149200,20.74675
2001-04-16,61.400002,61.580002,60.119999,60.790001,65857400,20.513906
2001-04-12,59.560001,62.310001,59.349998,62.18,87520000,20.982969
2001-04-11,60.650002,61.50,59.700001,60.040001,109879600,20.260815
2001-04-10,57.950001,60.09,57.779999,59.68,109199400,20.139331
2001-04-09,56.57,57.419998,55.66,57.150002,56295600,19.285569
2001-04-06,56.375,57.1875,55.0625,56.1875,92622000,18.960768
2001-04-05,53.75,57.375,53.50,56.75,113364000,19.150587
2001-04-04,53.375,55.00,51.0625,51.9375,104046600,17.526583
2001-04-03,55.3125,55.3125,52.75,53.375,94187600,18.011675
2001-04-02,54.8125,56.9375,54.625,55.8125,75924000,18.834222
2001-03-30,55.75,56.1875,53.875,54.6875,91201600,18.454585
2001-03-29,55.375,57.1875,54.5625,55.375,86985000,18.686586
2001-03-28,57.375,57.9375,55.375,55.5625,78681600,18.749859
2001-03-27,56.0625,58.5625,55.875,58.25,95135600,19.65677
2001-03-26,57.125,57.50,55.5625,56.0625,63118600,18.918586
2001-03-23,54.9375,57.00,54.375,56.5625,99519600,19.087314
2001-03-22,50.5625,54.0625,50.50,54.00,126363200,18.222585
2001-03-21,52.25,53.25,49.75,50.0625,124988600,16.893855
2001-03-20,54.5625,56.125,52.625,52.6875,91822800,17.779675
2001-03-19,54.50,55.50,53.125,54.3125,61036400,18.328039
2001-03-16,52.50,55.125,52.484299,54.5625,112848800,18.412403
2001-03-15,55.3125,56.078098,53.50,53.6875,71638400,18.11713
2001-03-14,52.50,55.25,52.1875,54.00,90686200,18.222585
2001-03-13,52.1875,54.75,52.00,54.1875,91035600,18.285858
2001-03-12,54.6875,55.00,51.625,51.9375,114376000,17.526583
2001-03-09,57.9375,58.1875,54.875,56.6875,103794400,19.129496
2001-03-08,60.3125,60.5937,58.4375,59.25,54626000,19.994225
2001-03-07,59.875,61.125,59.3125,60.6875,59743600,20.479317
2001-03-06,58.625,60.00,58.375,59.4375,66781800,20.057498
2001-03-05,57.25,58.625,56.5625,57.4375,49383600,19.382587
2001-03-02,57.50,58.125,56.4375,56.6875,79800800,19.129496
2001-03-01,58.5625,59.50,56.25,59.359299,81781600,20.031108
2001-02-28,59.5625,60.078098,58.1875,59.00,84608400,19.909861
2001-02-27,59.375,61.1875,58.671799,59.375,99148600,20.036407
2001-02-26,57.625,59.9375,57.375,59.5625,87936800,20.09968
2001-02-23,54.4375,57.50,54.3125,56.75,92620600,19.150587
2001-02-22,56.3125,56.8125,53.875,55.1875,100816400,18.623313
2001-02-21,55.25,58.0625,55.1875,56.25,63947200,18.981859
2001-02-20,57.375,58.25,55.375,55.875,60730800,18.855313
2001-02-16,57.00,58.25,56.125,57.3125,66958400,19.340405
2001-02-15,59.00,60.1875,57.875,58.8125,65627800,19.846588
2001-02-14,57.625,59.00,56.375,58.375,61728400,19.698952
2001-02-13,59.625,61.0625,58.125,58.1875,76070600,19.635679
2001-02-12,58.8125,59.4375,57.1875,58.75,71289400,19.825497
2001-02-09,61.3125,61.5625,58.50,59.125,100575200,19.952043
2001-02-08,63.75,64.50,62.00,62.25,88041200,21.006591
2001-02-07,62.00,65.0625,61.8125,64.6875,126061800,21.829138
2001-02-06,62.0625,63.8125,61.6875,62.5625,96442000,21.112045
2001-02-05,60.75,62.0625,60.25,61.9375,51399200,20.901136
2001-02-02,62.50,63.375,60.75,60.8125,71100000,20.521499
2001-02-01,60.8125,62.625,60.375,62.375,71792800,21.048773
2001-01-31,63.00,63.75,61.00,61.0625,81898800,20.605863
2001-01-30,64.50,64.75,62.875,63.375,57276800,21.386228
2001-01-29,63.5625,64.625,63.50,64.50,84983800,21.765865
2001-01-26,61.00,64.3125,61.00,64.00,93080000,21.597137
2001-01-25,62.75,64.00,61.5625,61.8125,85657400,20.858954
2001-01-24,61.00,63.4375,60.75,62.9375,110455000,21.238591
2001-01-23,59.75,60.9375,58.9375,60.5625,70295200,20.437135
2001-01-22,60.75,61.00,59.00,60.125,76673000,20.289498
2001-01-19,60.00,61.4375,58.875,61.00,209348800,20.584772
2001-01-18,53.6875,56.1875,52.625,55.50,109788800,18.728768
2001-01-17,53.625,54.875,52.5625,52.9375,72844200,17.864038
2001-01-16,53.375,53.50,51.125,52.5625,68462400,17.737493
2001-01-12,54.875,55.00,52.50,53.50,73712000,18.053857
2001-01-11,53.00,55.75,52.3125,55.00,101854800,18.56004
2001-01-10,51.00,53.8125,50.75,52.875,90230200,17.842948
2001-01-09,50.00,52.625,49.75,51.8125,114965400,17.484401
2001-01-08,48.9375,49.75,46.6875,48.9375,79817600,16.514217
2001-01-05,48.50,49.875,47.5625,49.125,93414600,16.57749
2001-01-04,47.8125,50.50,46.875,48.4375,112397000,16.34549
2001-01-03,43.1875,48.875,43.125,47.9375,135962200,16.176762
2001-01-02,44.125,45.00,42.875,43.375,82413200,14.637122
2000-12-29,43.9375,45.8125,43.00,43.375,99977600,14.637122
2000-12-28,45.125,46.25,43.875,44.5625,77619200,15.037851
2000-12-27,46.125,46.8125,45.00,46.4375,69003800,15.670579
2000-12-26,46.875,48.5625,45.875,46.875,66941600,15.818216
2000-12-22,44.75,47.125,44.75,46.4375,109551800,15.670579
2000-12-21,40.75,45.125,40.3125,43.4375,163173000,14.658213
2000-12-20,42.8125,44.00,41.375,41.50,149037800,14.004394
2000-12-19,47.4375,48.00,44.50,44.8125,120271800,15.122214
2000-12-18,49.00,50.00,47.00,47.8125,107187400,16.13458
2000-12-15,51.046799,52.00,47.75,49.1875,116899800,16.598581
2000-12-14,57.9375,58.734299,55.375,55.50,71201400,18.728768
2000-12-13,60.50,60.50,56.8125,57.25,98360400,19.319314
2000-12-12,57.8125,60.00,56.75,58.375,63106000,19.698952
2000-12-11,55.50,58.75,55.00,58.0625,95576200,19.593497
2000-12-08,54.625,55.875,53.4375,54.4375,120939800,18.370221
2000-12-07,53.4375,54.00,52.25,53.125,145308400,17.927311
2000-12-06,60.00,60.0625,56.0625,56.6875,90560800,19.129496
2000-12-05,59.1875,60.50,58.25,59.875,101734400,20.205134
2000-12-04,57.25,59.00,55.1875,56.4375,80407200,19.045132
2000-12-01,58.0625,60.625,56.0625,56.625,109809800,19.108405
2000-11-30,62.00,62.0625,57.00,57.375,197200800,19.361496
2000-11-29,66.8125,67.125,63.25,65.0625,98280400,21.955684
2000-11-28,69.375,69.75,66.8125,67.00,127446200,22.609503
2000-11-27,71.4375,72.25,70.625,70.6875,85307600,23.85387
2000-11-24,69.00,70.4375,68.50,69.9375,34439200,23.600778
2000-11-22,66.0625,69.50,66.00,68.25,76343200,23.031322
2000-11-21,67.375,69.25,67.375,67.75,59487600,22.862595
2000-11-20,68.125,68.50,65.5625,67.1875,80157200,22.672776
2000-11-17,69.4375,70.00,67.796799,69.0625,106525600,23.305505
2000-11-16,69.4375,71.50,68.9375,68.9375,92128600,23.263323
2000-11-15,69.0625,70.875,68.6875,70.0625,60422200,23.64296
2000-11-14,68.00,69.8125,67.3125,68.8125,84218600,23.221141
2000-11-13,66.6875,68.125,64.406197,66.4375,83364800,22.419685
2000-11-10,69.9375,70.3125,66.8125,67.375,93744400,22.736049
2000-11-09,68.50,71.3125,68.4375,70.875,91058600,23.917142
2000-11-08,71.125,72.375,68.00,69.4375,206149400,23.43205
2000-11-07,69.75,71.875,69.50,70.50,104331200,23.790597
2000-11-06,68.6875,70.125,68.25,69.50,74851400,23.453141
2000-11-03,69.25,69.625,68.0625,68.25,68711000,23.031322
2000-11-02,70.375,70.843697,69.625,70.3125,77985200,23.727324
2000-11-01,68.50,70.0625,68.4375,69.625,81309400,23.495323
2000-10-31,69.00,69.50,68.00,68.875,104474000,23.242232
2000-10-30,67.50,70.125,67.375,69.0625,110057600,23.305505
2000-10-27,64.6875,69.1875,64.625,67.6875,124292400,22.841504
2000-10-26,61.00,65.0625,60.8125,64.4375,114826600,21.744774
2000-10-25,61.9375,63.4375,60.4375,61.25,167603800,20.669135
2000-10-24,62.625,62.9375,60.1875,61.50,94427400,20.753499
2000-10-23,64.625,66.25,60.6875,62.125,185170400,20.964409
2000-10-20,61.3125,66.125,61.125,65.1875,160378600,21.997866
2000-10-19,58.4375,62.1875,58.00,61.875,256993200,20.880045
2000-10-18,49.625,53.25,48.4375,51.75,110536400,17.46331
2000-10-17,51.875,52.4375,50.25,50.4375,81276600,17.0204
2000-10-16,53.50,53.8125,49.5625,50.375,119759000,16.999309
2000-10-13,53.875,54.875,52.125,53.75,104521200,18.138221
2000-10-12,56.3125,56.875,53.8125,54.375,90219600,18.34913
2000-10-11,54.00,56.9375,54.00,55.75,101205800,18.813131
2000-10-10,53.9375,55.5625,53.8125,54.5625,62066200,18.412403
2000-10-09,55.625,55.75,53.00,54.1875,58323600,18.285858
2000-10-06,55.8125,56.75,54.75,55.5625,61794000,18.749859
2000-10-05,55.50,57.25,55.25,55.375,81099400,18.686586
2000-10-04,56.375,56.5625,54.50,55.4375,136453400,18.707677
2000-10-03,59.5625,59.8125,56.50,56.5625,85374000,19.087314
2000-10-02,60.50,60.8125,58.25,59.125,58562400,19.952043
2000-09-29,61.00,61.3125,58.625,60.3125,74053600,20.352771
2000-09-28,60.8125,61.875,60.625,61.3125,52360400,20.690226
2000-09-27,63.4375,63.5625,59.8125,60.625,106155600,20.458226
2000-09-26,60.9375,65.875,60.4375,62.6875,155704800,21.154227
2000-09-25,63.25,63.50,60.4375,61.25,53484200,20.669135
2000-09-22,61.125,63.50,61.00,63.25,84476600,21.344046
2000-09-21,64.00,65.125,63.5625,64.1875,48952200,21.66041
2000-09-20,64.875,65.00,63.1875,64.25,67791400,21.681501
2000-09-19,63.625,65.75,63.375,65.00,79311200,21.934593
2000-09-18,64.25,64.625,62.1875,63.00,69037800,21.259682
2000-09-15,65.4375,65.625,63.3125,64.1875,99915200,21.66041
2000-09-14,68.6875,68.75,65.6875,65.8125,78503000,22.208775
2000-09-13,67.5625,68.75,67.1875,68.25,40744800,23.031322
2000-09-12,68.75,69.3125,67.625,68.125,46781200,22.98914
2000-09-11,69.125,69.6875,68.0625,68.8125,48495200,23.221141
2000-09-08,70.375,70.875,69.1875,69.3125,56709600,23.389869
2000-09-07,70.00,72.0625,69.4375,70.0625,111711200,23.64296
2000-09-06,70.0625,70.6875,69.3125,69.4375,62960800,23.43205
2000-09-05,70.00,70.6875,69.8125,70.125,50755200,23.664051
2000-09-01,70.00,70.625,69.6875,70.1875,37629800,23.685142
2000-08-31,70.875,72.00,69.6875,69.8125,72575400,23.558596
2000-08-30,70.6875,70.9375,69.6875,70.00,53498800,23.621869
2000-08-29,71.1875,72.75,70.875,70.9375,59400200,23.938233
2000-08-28,70.1875,72.125,70.125,71.3125,56421600,24.064779
2000-08-25,70.6875,71.6875,70.5625,70.625,52729400,23.832779
2000-08-24,70.625,71.1875,69.9375,71.125,42405400,24.001506
2000-08-23,70.8125,71.125,70.375,70.75,36726800,23.874961
2000-08-22,70.8125,72.4375,70.218697,71.25,54428200,24.043688
2000-08-21,70.6875,70.8125,70.0625,70.625,34119600,23.832779
2000-08-18,71.125,71.4375,70.00,71.00,54438800,23.959324
2000-08-17,71.125,72.00,70.5625,71.5625,36112800,24.149143
2000-08-16,71.875,72.25,70.5625,71.00,44976200,23.959324
2000-08-15,72.00,73.00,71.50,71.625,40714200,24.170234
2000-08-14,72.3125,73.375,71.375,72.1875,53427000,24.360052
2000-08-11,72.4375,72.6875,71.625,72.4375,35629600,24.444416
2000-08-10,73.8125,74.0625,71.75,72.625,48986000,24.507689
2000-08-09,73.75,74.875,73.125,74.25,63945600,25.056054
2000-08-08,70.0625,74.6875,70.00,74.125,138038800,25.013872
2000-08-07,70.1875,71.125,69.75,70.00,52741800,23.621869
2000-08-04,69.4375,69.875,68.1875,69.125,38107400,23.326596
2000-08-03,68.1875,70.375,68.125,70.25,54543400,23.706233
2000-08-02,68.5625,70.4375,68.50,69.375,48269200,23.41096
2000-08-01,69.9375,70.0625,68.1875,68.6875,47163600,23.178959
2000-07-31,70.1875,71.125,69.25,69.8125,70283800,23.558596
2000-07-28,70.9375,71.8125,69.625,69.6875,75645600,23.516414
2000-07-27,67.875,70.125,67.50,69.375,74337600,23.41096
2000-07-26,69.0625,69.50,67.25,67.8125,85404600,22.883686
2000-07-25,70.8125,71.00,68.375,69.00,64188600,23.284414
2000-07-24,72.0625,72.125,70.00,70.5625,56165600,23.811688
2000-07-21,74.75,75.00,71.875,72.3125,56100600,24.402234
2000-07-20,73.4375,75.25,73.125,74.8125,54690600,25.245873
2000-07-19,76.0625,77.50,72.8125,73.125,139924600,24.676417
2000-07-18,77.625,79.50,77.4375,78.50,70617200,26.490239
2000-07-17,78.25,79.5625,77.50,78.1875,53992800,26.384784
2000-07-14,79.50,79.75,78.4375,78.9375,51180600,26.637876
2000-07-13,78.8125,80.00,77.375,79.9375,80843200,26.975331
2000-07-12,78.25,81.00,77.1875,80.3125,58370200,27.101877
2000-07-11,78.8125,80.50,78.50,79.125,37164800,26.701148
2000-07-10,80.6875,81.3125,79.375,79.4375,52689800,26.806603
2000-07-07,81.265602,82.875,80.5625,82.00,54153200,27.671332
2000-07-06,78.875,81.6875,78.50,80.9375,47873200,27.312786
2000-07-05,79.875,79.875,78.25,78.50,34824400,26.490239
2000-07-03,79.6875,80.0625,79.375,80.00,15734800,26.996422
2000-06-30,77.0625,80.00,76.6875,80.00,52356400,26.996422
2000-06-29,78.25,78.9375,77.0625,77.1875,38449000,26.047329
2000-06-28,79.00,80.0625,78.625,78.9375,37459200,26.637876
2000-06-27,79.25,80.125,78.375,78.8125,31071200,26.595694
2000-06-26,77.50,80.125,77.50,79.50,48287000,26.827694
2000-06-23,79.9375,80.0625,77.00,77.6875,49811600,26.216056
2000-06-22,81.375,82.00,79.3125,79.875,87315200,26.95424
2000-06-21,77.00,82.1875,76.9375,80.6875,160399600,27.228422
2000-06-20,73.875,75.25,73.75,74.9375,62275000,25.288054
2000-06-19,72.5625,73.8125,72.00,73.6875,46604800,24.866235
2000-06-16,72.625,73.125,71.50,72.5625,68710600,24.486598
2000-06-15,70.8125,72.6875,70.625,72.375,65592600,24.423325
2000-06-14,69.8125,71.00,69.50,70.50,79992400,23.790597
2000-06-13,66.75,68.00,66.125,67.875,44289200,22.904777
2000-06-12,69.00,69.00,66.375,66.875,49260600,22.567321
2000-06-09,69.625,69.6875,68.3125,68.8125,35710200,23.221141
2000-06-08,71.5625,72.125,68.25,68.8125,94765600,23.221141
2000-06-07,69.25,70.75,67.125,70.50,76310600,23.790597
2000-06-06,68.1875,69.875,67.8125,69.625,99019000,23.495323
2000-06-05,66.015602,68.375,66.00,66.875,64400000,22.567321
2000-06-02,66.00,66.75,65.00,66.3125,80463200,22.377503
2000-06-01,64.375,66.00,63.8125,64.5625,94507200,21.786956
2000-05-31,63.640598,63.703098,62.0625,62.5625,54968200,21.112045
2000-05-30,62.4375,64.125,62.00,63.375,68536400,21.386228
2000-05-26,62.0625,62.625,60.375,61.4375,55822000,20.732408
2000-05-25,64.5625,64.75,61.125,61.50,94348800,20.753499
2000-05-24,63.125,66.5625,63.00,65.5625,85482400,22.124411
2000-05-23,63.875,65.5625,63.0625,63.1875,57963200,21.322955
2000-05-22,65.125,65.25,62.4375,64.1875,69955000,21.66041
2000-05-19,65.375,65.9375,64.50,65.0625,66578000,21.955684
2000-05-18,68.0625,68.0625,65.875,66.1875,53640400,22.335321
2000-05-17,68.875,69.125,67.25,67.6875,53242000,22.841504
2000-05-16,69.5625,70.625,69.0625,69.50,48410600,23.453141
2000-05-15,69.00,69.4375,68.00,69.375,33899600,23.41096
2000-05-12,68.4375,69.75,68.25,68.8125,37886000,23.221141
2000-05-11,66.625,68.125,65.75,67.875,58390800,22.904777
2000-05-10,67.75,67.875,65.75,66.1875,67740000,22.335321
2000-05-09,70.1875,70.4375,67.50,67.8125,60778400,22.883686
2000-05-08,70.9375,71.375,69.6875,69.8125,36187600,23.558596
2000-05-05,70.25,71.8125,69.875,71.125,36402200,24.001506
2000-05-04,70.3125,71.25,69.3125,70.4375,43317200,23.769506
2000-05-03,70.375,70.8125,68.8125,70.5625,55354800,23.811688
2000-05-02,72.8125,73.50,69.50,69.875,97716200,23.579687
2000-05-01,72.875,74.00,71.6875,73.4375,107811000,24.781872
2000-04-28,70.75,71.00,68.25,69.75,78082600,23.537505
2000-04-27,67.4375,69.9375,67.375,69.8125,77669800,23.558596
2000-04-26,70.00,71.125,67.375,68.00,107091200,22.946959
2000-04-25,68.75,69.50,67.625,69.375,159517400,23.41096
2000-04-24,67.25,68.00,65.00,66.625,313645800,22.482958
2000-04-20,78.625,79.875,77.50,78.9375,52387400,26.637876
2000-04-19,81.4375,81.50,78.125,78.6875,53715400,26.553512
2000-04-18,76.50,81.9375,75.875,80.5625,91794600,27.18624
2000-04-17,74.25,76.00,73.00,75.875,119772200,25.604419
2000-04-14,79.125,79.50,73.25,74.125,151217800,25.013872
2000-04-13,80.875,82.25,79.00,79.25,94316200,26.74333
2000-04-12,82.125,82.25,78.75,79.375,153003800,26.785512
2000-04-11,85.125,86.0625,83.50,83.875,71961800,28.304061
2000-04-10,88.625,88.625,86.00,86.0625,60685400,29.042244
2000-04-07,87.00,89.375,85.00,89.0625,82613600,30.05461
2000-04-06,87.875,88.00,85.265602,86.00,66421400,29.021153
2000-04-05,88.25,88.50,85.875,86.375,82887600,29.147699
2000-04-04,91.5625,92.00,84.9375,88.5625,181244400,29.885883
2000-04-03,94.4375,96.50,90.00,90.875,260118200,30.666248
2000-03-31,106.00,108.25,104.125,106.25,64281400,35.854623
2000-03-30,106.1875,108.625,102.50,103.375,64178400,34.884439
2000-03-29,105.1875,108.9375,105.125,107.1875,64363800,36.170987
2000-03-28,103.625,107.4375,102.375,104.3125,81114400,35.200803
2000-03-27,107.765602,108.25,103.9375,104.0625,111434000,35.116439
2000-03-24,112.625,115.00,109.5625,111.6875,112196800,37.689536
2000-03-23,106.8125,112.875,106.625,111.875,148224000,37.752809
2000-03-22,102.8125,105.625,101.125,103.25,93975800,34.842257
2000-03-21,96.75,103.125,96.50,102.75,81648800,34.673529
2000-03-20,98.75,99.75,96.50,97.375,47773000,32.859707
2000-03-17,95.25,99.50,94.50,99.375,81161600,33.534618
2000-03-16,95.9375,96.6875,93.25,95.375,77300800,32.184797
2000-03-15,94.5625,96.625,93.6875,95.375,53208000,32.184797
2000-03-14,98.625,99.25,95.125,95.125,73489200,32.100433
2000-03-13,97.625,100.25,97.50,98.00,61831800,33.070617
2000-03-10,99.5625,102.50,99.50,101.00,85589000,34.082983
2000-03-09,95.3125,100.00,95.00,100.00,88198800,33.745527
2000-03-08,93.8125,96.1875,91.00,95.5625,94290000,32.248069
2000-03-07,96.125,97.50,91.9375,92.875,135061000,31.341158
2000-03-06,96.00,97.375,90.125,90.625,93609400,30.581884
2000-03-03,94.75,98.875,93.875,96.125,101435200,32.437888
2000-03-02,91.8125,95.375,91.125,93.375,106932600,31.509886
2000-03-01,89.625,94.093697,88.9375,90.8125,106889800,30.645157
2000-02-29,91.75,91.75,88.875,89.375,58437400,30.160065
2000-02-28,90.25,92.125,88.125,91.5625,76131800,30.898248
2000-02-25,94.6875,94.703102,90.50,91.3125,65301400,30.813885
2000-02-24,94.25,95.875,92.00,94.75,69733200,31.973887
2000-02-23,93.50,95.75,92.0625,94.25,75847200,31.805159
2000-02-22,95.125,97.125,92.8125,93.8125,66296200,31.657523
2000-02-18,100.00,100.0625,94.875,95.0625,79063000,32.079342
2000-02-17,98.50,99.6875,97.140602,99.625,80343400,33.618982
2000-02-16,99.25,100.1875,97.125,97.625,65202600,32.944071
2000-02-15,99.75,100.00,98.125,98.5625,71027600,33.260435
2000-02-14,101.234299,101.75,99.0625,99.625,81028600,33.618982
2000-02-11,104.875,104.875,99.125,99.9375,115559000,33.724436
2000-02-10,103.890602,106.5625,102.50,106.00,54527800,35.770259
2000-02-09,109.4375,109.4375,103.875,104.00,55090000,35.095348
2000-02-08,106.4375,110.00,106.4375,109.9375,56229000,37.098989
2000-02-07,106.8125,106.875,104.25,106.625,40005800,35.981168
2000-02-04,104.375,108.00,104.140602,106.5625,55365400,35.960077
2000-02-03,102.0625,104.1875,100.125,103.625,49186000,34.968803
2000-02-02,102.4375,103.9375,100.50,100.8125,49915600,34.01971
2000-02-01,98.50,103.25,97.6875,102.9375,70196600,34.736802
2000-01-31,97.625,98.1875,94.875,97.875,73194200,33.028435
2000-01-28,98.125,100.25,97.25,98.25,58225400,33.154981
2000-01-27,99.890602,101.1875,97.25,98.75,63654800,33.323708
2000-01-26,102.4375,103.50,99.125,99.375,49365000,33.534618
2000-01-25,101.00,103.875,99.5625,102.8125,59823200,34.69462
2000-01-24,103.796799,105.6875,100.8125,101.25,63597600,34.167346
2000-01-21,107.00,107.25,103.25,103.75,68416200,35.010985
2000-01-20,107.0625,109.6875,105.875,106.00,56349800,35.770259
2000-01-19,110.50,111.50,106.00,107.00,97568200,36.107714
2000-01-18,111.8125,116.50,111.75,115.3125,81483600,38.912811
2000-01-14,107.1875,113.9375,105.75,112.25,73416400,37.879354
2000-01-13,104.375,108.625,101.50,107.8125,83144000,36.381897
2000-01-12,108.50,108.875,104.4375,105.8125,66532400,35.706986
2000-01-11,111.50,114.25,108.6875,109.375,46743600,36.90917
2000-01-10,113.4375,113.6875,111.375,112.25,44963600,37.879354
2000-01-07,108.625,112.25,107.3125,111.4375,62013600,37.605172
2000-01-06,112.1875,113.875,108.375,110.00,54976600,37.12008
2000-01-05,111.125,116.375,109.375,113.8125,64059600,38.406628
2000-01-04,113.5625,117.125,112.25,112.625,54119000,38.0059
2000-01-03,117.375,118.625,112.00,116.5625,53228400,39.33463
1999-12-31,117.50,117.75,116.25,116.75,12517600,39.397903
1999-12-30,117.875,119.9375,117.125,117.625,22360000,39.693176
1999-12-29,116.9375,118.375,116.8125,117.9375,17449200,39.798631
1999-12-28,118.75,118.8125,117.0625,117.50,24591000,39.650995
1999-12-27,118.4375,119.25,116.125,119.125,32202200,40.199359
1999-12-23,117.25,119.25,116.75,117.4375,31028400,39.629904
1999-12-22,116.296799,118.00,115.125,117.5625,38565200,39.672085
1999-12-21,112.375,116.625,110.625,115.875,57446000,39.10263
1999-12-20,114.8125,115.00,111.1875,112.75,39433800,38.048082
1999-12-17,116.625,117.125,113.625,115.25,105898800,38.89172
1999-12-16,109.25,115.00,108.9375,113.6875,128660200,38.364446
1999-12-15,98.5625,108.75,98.50,108.4375,155571600,36.592806
1999-12-14,96.1875,101.125,95.3125,98.6875,144116200,33.302617
1999-12-13,93.609299,96.9375,92.75,96.625,52691600,32.606616
1999-12-10,93.375,94.125,92.25,93.875,36836000,31.678614
1999-12-09,92.00,93.3125,91.4375,92.75,46258200,31.298977
1999-12-08,93.125,94.3125,91.6875,91.75,40955800,30.961521
1999-12-07,94.75,94.875,92.875,93.00,56859200,31.38334
1999-12-06,95.25,97.1875,94.75,95.4375,49098200,32.205888
1999-12-03,95.8125,97.125,95.734299,96.125,64100600,32.437888
1999-12-02,93.0625,95.25,92.875,94.8125,55473800,31.994978
1999-12-01,91.0625,93.9375,90.875,93.1875,48864200,31.446613
1999-11-30,89.75,92.875,89.5625,91.046799,64145600,30.724222
1999-11-29,90.125,92.0625,89.50,90.1875,51460200,30.434247
1999-11-26,91.625,93.375,91.00,91.125,28514200,30.750612
1999-11-24,89.5625,92.25,89.50,91.6875,53771000,30.94043
1999-11-23,89.25,91.375,88.375,89.625,70787400,30.244429
1999-11-22,89.625,90.375,88.4375,89.8125,90596600,30.307702
1999-11-19,84.4375,86.5625,84.375,86.00,58226000,29.021153
1999-11-18,84.9375,85.8125,84.50,84.9375,64493200,28.662607
1999-11-17,86.4375,87.0625,85.00,85.00,66819000,28.683698
1999-11-16,86.9375,87.75,85.875,87.3125,59165200,29.464063
1999-11-15,88.25,88.50,86.9375,87.00,47080400,29.358609
1999-11-12,89.75,90.00,87.0625,89.1875,49414200,30.096792
1999-11-11,88.25,90.4375,88.25,89.625,69274600,30.244429
1999-11-10,88.125,89.125,86.4375,87.125,69385400,29.400791
1999-11-09,89.75,89.875,86.4375,88.875,109769800,29.991337
1999-11-08,84.8125,90.75,84.375,89.9375,243819200,30.349884
1999-11-05,91.8125,92.875,90.50,91.5625,70167400,30.898248
1999-11-04,92.3125,92.75,90.3125,91.75,54239400,30.961521
1999-11-03,92.9375,93.50,91.50,92.00,44517000,31.045885
1999-11-02,92.75,94.50,91.9375,92.5625,46349000,31.235704
1999-11-01,93.25,94.1875,92.125,92.375,53261200,31.172431
1999-10-29,91.4375,94.00,91.25,92.5625,79452600,31.235704
1999-10-28,90.00,90.875,89.3125,89.875,70570400,30.328793
1999-10-27,91.50,91.625,89.6875,90.875,54416600,30.666248
1999-10-26,94.375,95.25,92.265602,92.375,52467600,31.172431
1999-10-25,92.00,93.5625,91.125,92.4375,30492200,31.193522
1999-10-22,93.5625,93.875,91.75,92.6875,43650600,31.277886
1999-10-21,90.5625,93.125,90.50,93.0625,60801200,31.404431
1999-10-20,91.5625,92.375,90.25,92.25,88090600,31.130249
1999-10-19,88.25,89.25,85.25,86.3125,69945600,29.126608
1999-10-18,87.1875,88.00,85.0625,87.875,75312800,29.653882
1999-10-15,89.50,89.8125,87.3125,88.0625,73788000,29.717155
1999-10-14,90.875,92.234299,89.6875,90.6875,42737800,30.602975
1999-10-13,92.00,93.125,90.3125,91.0625,38098400,30.729521
1999-10-12,94.00,94.3125,92.375,92.5625,27668600,31.235704
1999-10-11,94.625,95.00,94.125,94.3125,19943800,31.82625
1999-10-08,93.50,95.1875,92.125,94.9375,35697000,32.03716
1999-10-07,93.6875,95.0625,92.6875,93.75,46036400,31.636432
1999-10-06,92.3125,94.00,92.0625,93.6875,35500200,31.615341
1999-10-05,92.75,93.875,89.50,91.8125,43397000,30.982612
1999-10-04,90.50,92.625,90.25,92.5625,29998000,31.235704
1999-10-01,90.1875,90.625,88.3125,89.984299,44239000,30.365676
1999-09-30,90.00,91.6875,88.8125,90.5625,47455400,30.560793
1999-09-29,91.5625,92.125,89.125,89.50,37484400,30.202247
1999-09-28,91.25,92.6875,89.0625,92.125,46000600,31.088067
1999-09-27,92.00,92.9375,90.875,91.4375,34132200,30.856066
1999-09-24,90.1875,91.375,88.875,90.9375,70277000,30.687339
1999-09-23,96.875,96.875,90.015602,91.1875,71073600,30.771703
1999-09-22,94.75,96.625,93.6875,96.0625,48531600,32.416797
1999-09-21,96.5625,96.5625,94.125,94.625,47082800,31.931705
1999-09-20,96.00,97.875,95.00,97.5625,48601800,32.92298
1999-09-17,94.375,96.50,93.8125,96.4375,79773400,32.543343
1999-09-16,92.875,94.0625,90.625,94.00,45796000,31.720796
1999-09-15,95.50,95.75,92.375,92.625,48413800,31.256795
1999-09-14,93.6875,95.5625,93.625,95.0625,40207800,32.079342
1999-09-13,94.50,94.8125,93.375,93.875,27870800,31.678614
1999-09-10,95.0625,95.3125,94.00,95.00,34455000,32.058251
1999-09-09,92.4375,94.140602,91.796799,94.0625,38475200,31.741887
1999-09-08,93.6875,94.6875,92.0625,92.25,42568200,31.130249
1999-09-07,94.875,96.6875,93.75,94.25,47028000,31.805159
1999-09-03,93.75,96.4375,93.50,95.875,52098000,32.353524
1999-09-02,91.50,92.5625,90.6875,91.8125,33340800,30.982612
1999-09-01,92.3125,93.4375,91.625,92.375,36607200,31.172431
1999-08-31,91.8125,93.125,90.125,92.5625,46882800,31.235704
1999-08-30,92.875,93.4375,91.5625,92.25,33300800,31.130249
1999-08-27,95.0625,95.125,92.375,93.25,41948400,31.467704
1999-08-26,95.375,96.375,93.6875,94.625,61246000,31.931705
1999-08-25,93.625,96.00,93.1875,95.3125,81877600,32.163706
1999-08-24,87.0625,93.50,87.0625,92.1875,120450000,31.109158
1999-08-23,84.3125,86.625,83.875,86.4375,60447000,29.16879
1999-08-20,84.00,84.781197,83.0625,83.375,46072800,28.135333
1999-08-19,84.5625,85.125,83.125,83.8125,71478200,28.28297
1999-08-18,84.4375,86.1875,84.0625,85.00,58361200,28.683698
1999-08-17,85.4375,85.50,82.9375,84.5625,51749000,28.536061
1999-08-16,85.0625,85.890602,82.3125,84.3125,57321800,28.451698
1999-08-13,82.9375,85.625,82.75,84.6875,65099800,28.578243
1999-08-12,83.9375,84.1875,81.625,81.75,61062000,27.586969
1999-08-11,84.00,84.6875,82.3125,84.1875,66105200,28.409516
1999-08-10,83.5625,84.0625,81.625,82.9375,62743000,27.987697
1999-08-09,85.625,85.8125,83.6875,83.8125,39333600,28.28297
1999-08-06,86.0625,86.4375,84.9375,85.125,67205800,28.72588
1999-08-05,85.375,86.375,84.75,85.75,76634000,28.93679
1999-08-04,85.125,87.1875,84.75,84.9375,75573400,28.662607
1999-08-03,85.875,86.0625,84.375,84.75,55051200,28.599334
1999-08-02,85.6875,86.9375,84.375,84.8125,48050600,28.620425
1999-07-30,87.625,88.625,85.50,85.8125,51127400,28.957881
1999-07-29,88.6875,88.8125,86.3125,86.9375,57968200,29.337518
1999-07-28,89.1875,90.50,88.375,90.00,62215200,30.370975
1999-07-27,88.8125,89.75,88.00,88.8125,65513000,29.970246
1999-07-26,88.875,89.8125,87.625,87.625,50885000,29.569518
1999-07-23,91.5625,91.75,89.6875,90.25,68833200,30.455338
1999-07-22,94.375,94.50,90.00,91.0625,60904200,30.729521
1999-07-21,93.625,95.3125,93.00,94.6875,54050800,31.952796
1999-07-20,96.4375,96.75,92.3125,93.3125,92287400,31.488795
1999-07-19,100.00,100.75,97.8125,98.375,81181600,33.197162
1999-07-16,95.50,99.875,95.00,99.4375,115369800,33.555709
1999-07-15,95.00,95.25,93.75,94.375,40926200,31.847341
1999-07-14,93.75,95.00,92.50,94.9375,37985200,32.03716
1999-07-13,93.125,94.0625,92.8125,93.625,30845000,31.59425
1999-07-12,93.1875,94.75,92.375,94.1875,43847800,31.784068
1999-07-09,92.375,93.3125,92.25,93.25,33884200,31.467704
1999-07-08,91.8125,93.00,90.6875,92.5625,37790400,31.235704
1999-07-07,90.0625,92.3125,89.875,92.3125,33834600,31.15134
1999-07-06,92.25,92.9375,89.25,89.5625,45419400,30.223338
1999-07-02,90.875,92.125,90.3125,92.00,32094800,31.045885
1999-07-01,89.875,91.50,88.375,91.1875,47737800,30.771703
1999-06-30,87.75,90.25,86.75,90.1875,57610200,30.434247
1999-06-29,86.6875,88.0625,86.00,88.00,38973200,29.696064
1999-06-28,85.50,86.8125,84.9375,86.75,31701000,29.274245
1999-06-25,85.375,86.4375,84.375,84.9375,24933000,28.662607
1999-06-24,85.75,86.25,84.00,84.625,33559000,28.557152
1999-06-23,85.9375,87.375,85.0625,86.00,33942000,29.021153
1999-06-22,88.4375,88.4375,86.25,86.50,38751000,29.189881
1999-06-21,84.875,89.00,84.875,88.9375,56194400,30.012428
1999-06-18,82.3125,85.00,82.125,85.00,69116200,28.683698
1999-06-17,80.6875,83.00,80.50,82.875,44475200,27.966606
1999-06-16,79.0625,81.625,78.9375,81.00,48325200,27.333877
1999-06-15,78.0625,78.875,76.6875,77.6875,36981000,26.216056
1999-06-14,78.75,79.6875,77.4375,77.5625,28369800,26.173875
1999-06-11,80.00,80.50,77.5625,78.125,34543000,26.363693
1999-06-10,81.875,82.3125,79.0625,79.875,35277400,26.95424
1999-06-09,80.125,82.625,80.00,82.3125,53310800,27.776787
1999-06-08,79.875,82.125,79.00,79.375,41516400,26.785512
1999-06-07,79.9375,81.0625,79.1875,80.25,32392200,27.080786
1999-06-04,76.9375,79.6875,76.75,79.5625,35668200,26.848785
1999-06-03,78.375,78.9375,76.125,76.375,32934400,25.773146
1999-06-02,78.0625,78.625,76.25,78.4375,42812600,26.469148
1999-06-01,80.625,80.75,78.4375,78.50,36046400,26.490239
1999-05-28,78.75,80.875,78.125,80.6875,41548000,27.228422
1999-05-27,78.25,79.4375,77.50,78.375,56702200,26.448057
1999-05-26,77.1875,78.50,75.50,78.50,52022800,26.490239
1999-05-25,76.75,79.25,76.125,76.25,50791600,25.730965
1999-05-24,77.875,77.875,76.0625,77.25,38990000,26.06842
1999-05-21,78.50,79.00,77.00,77.5625,56568800,26.173875
1999-05-20,79.5625,80.00,78.375,78.4375,42386200,26.469148
1999-05-19,79.875,79.875,77.25,79.3125,46510800,26.764421
1999-05-18,79.8125,80.25,77.9375,78.6875,63858400,26.553512
1999-05-17,77.375,79.5625,77.00,79.125,66850200,26.701148
1999-05-14,78.875,79.9375,76.625,76.875,84401000,25.941874
1999-05-13,81.125,81.75,79.125,79.125,51737200,26.701148
1999-05-12,80.75,81.00,79.25,80.50,60142600,27.165149
1999-05-11,80.75,81.015602,79.4375,79.875,42786200,26.95424
1999-05-10,79.875,80.50,78.25,79.6875,46218000,26.890967
1999-05-07,79.625,80.375,78.00,79.0625,48011600,26.680057
1999-05-06,80.6875,81.125,77.50,77.9375,74021000,26.30042
1999-05-05,79.125,79.875,76.4375,79.125,67028200,26.701148
1999-05-04,80.50,81.8125,77.75,78.0625,66502200,26.342602
1999-05-03,81.4375,81.50,78.5625,79.875,67180000,26.95424
1999-04-30,82.75,83.75,79.875,81.3125,58558600,27.439332
1999-04-29,82.375,83.6875,80.406197,82.0625,60880600,27.692423
1999-04-28,85.3125,86.50,81.718697,82.125,55963400,27.713514
1999-04-27,88.75,88.75,83.9375,84.00,58665800,28.346243
1999-04-26,87.1875,88.9375,86.75,88.00,48349800,29.696064
1999-04-23,85.00,87.00,83.00,86.00,56592000,29.021153
1999-04-22,85.00,85.25,83.375,84.9375,55096400,28.662607
1999-04-21,82.125,82.50,80.00,82.00,92732800,27.671332
1999-04-20,82.25,84.00,80.00,83.125,108459400,28.05097
1999-04-19,86.875,88.125,80.375,81.00,75389000,27.333877
1999-04-16,89.0625,89.125,85.875,86.625,44774000,29.232063
1999-04-15,87.3125,89.875,83.875,88.875,72594600,29.991337
1999-04-14,90.8125,91.125,85.875,85.875,52944000,28.978972
1999-04-13,93.125,93.125,89.1875,90.125,46746800,30.413156
1999-04-12,91.625,93.625,91.375,93.00,37858800,31.38334
1999-04-09,94.25,95.00,93.00,94.25,31816800,31.805159
1999-04-08,93.25,94.625,91.00,94.5625,38637000,31.910614
1999-04-07,94.875,95.00,91.25,93.3125,46910200,31.488795
1999-04-06,95.1875,95.625,93.25,94.0625,39674800,31.741887
1999-04-05,94.3125,95.015602,93.50,94.9375,39848600,32.03716
1999-04-01,91.25,92.875,90.265602,92.6875,41106000,31.277886
1999-03-31,94.50,94.625,89.125,89.625,58752600,30.244429
1999-03-30,93.375,93.50,92.25,93.00,67502400,31.38334
1999-03-29,90.125,92.625,87.875,92.375,79777000,31.172431
1999-03-26,178.9375,180.375,175.75,178.125,94687600,30.05461
1999-03-25,173.0625,180.0625,172.50,179.9375,109447600,30.360429
1999-03-24,167.00,171.8125,163.125,171.25,82634400,28.894608
1999-03-23,172.6875,174.125,166.25,166.5625,69581200,28.103697
1999-03-22,172.9375,174.9375,172.00,172.8125,55719200,29.158245
1999-03-19,173.875,174.125,169.875,171.1875,91980400,28.884062
1999-03-18,166.4375,172.5625,166.1875,172.4375,56231200,29.094972
1999-03-17,169.0625,169.4375,166.75,167.125,44919600,28.198606
1999-03-16,165.50,170.00,164.25,169.0625,68554000,28.525516
1999-03-15,160.5625,166.00,157.875,165.875,60609600,27.987697
1999-03-12,162.625,162.75,156.8125,160.1875,73395200,27.028058
1999-03-11,161.00,164.5625,159.3125,161.4375,62948400,27.238968
1999-03-10,162.3125,162.50,159.1875,161.375,53114800,27.228422
1999-03-09,159.875,164.75,159.75,161.8125,90129600,27.302241
1999-03-08,155.50,159.234299,155.00,159.00,46726000,26.827694
1999-03-05,154.75,155.375,153.125,154.9375,47302800,26.142238
1999-03-04,151.125,153.50,148.125,152.25,61696400,25.688783
1999-03-03,149.00,150.6875,147.0625,149.625,76798400,25.245873
1999-03-02,151.875,154.125,147.625,148.5625,58569600,25.066599
1999-03-01,149.5625,152.5625,149.50,151.75,58332000,25.604419
1999-02-26,152.375,152.50,149.50,150.125,59273200,25.330236
1999-02-25,152.375,153.75,149.625,153.50,70817200,25.899692
1999-02-24,156.4375,159.375,152.75,152.875,67696800,25.794237
1999-02-23,152.9375,155.625,150.50,155.4375,95106800,26.226602
1999-02-22,148.25,149.00,144.75,148.8125,92514400,25.108781
1999-02-19,147.4375,149.25,145.75,147.75,73085600,24.929508
1999-02-18,150.9375,151.375,143.984299,145.75,117035200,24.592053
1999-02-17,152.9375,154.125,148.50,150.00,101215600,25.309145
1999-02-16,159.75,159.875,154.5625,156.25,73666800,26.363693
1999-02-12,161.6875,163.6875,157.125,157.75,62930400,26.616785
1999-02-11,162.75,163.875,160.375,162.75,60366000,27.460423
1999-02-10,159.875,164.375,158.625,160.625,73694000,27.101877
1999-02-09,164.9375,166.75,159.75,160.0625,77293600,27.006967
1999-02-08,162.5625,165.5625,161.625,165.25,109866800,27.882242
1999-02-05,160.25,161.625,154.875,160.00,127945200,26.996422
1999-02-04,168.125,168.375,158.875,159.0625,89151600,26.83824
1999-02-03,166.375,169.875,166.00,166.8125,73749200,28.145879
1999-02-02,172.50,172.5625,166.25,167.625,91965600,28.28297
1999-02-01,175.4375,175.9375,170.8125,172.9375,81729200,29.179336
1999-01-29,174.75,175.125,170.875,175.00,79571600,29.527336
1999-01-28,171.75,174.0625,169.8125,174.00,78838400,29.358609
1999-01-27,172.50,174.4375,168.50,168.625,98048000,28.451698
1999-01-26,165.50,171.75,164.50,171.5625,120203200,28.947335
1999-01-25,161.6875,163.3125,159.125,161.875,103076400,27.312786
1999-01-22,155.625,160.234299,155.25,156.25,82160000,26.363693
1999-01-21,161.75,163.3125,157.75,158.3125,80077200,26.711694
1999-01-20,166.9375,167.75,162.484299,162.625,125481200,27.439332
1999-01-19,151.375,158.375,150.875,155.625,102741600,26.258238
1999-01-15,142.9375,150.00,141.375,149.75,59344000,25.266964
1999-01-14,145.25,145.5625,141.50,141.75,59214000,23.917142
1999-01-13,136.00,147.75,136.00,143.8125,75346000,24.265143
1999-01-12,148.125,148.125,141.00,142.1875,57907200,23.990961
1999-01-11,150.875,150.9375,144.25,147.50,46463200,24.887326
1999-01-08,152.1875,152.50,147.00,149.875,50244800,25.288054
1999-01-07,149.75,150.625,148.25,150.50,51150400,25.393509
1999-01-06,149.50,151.50,146.75,151.25,69064800,25.520055
1999-01-05,141.875,148.00,141.4375,146.50,64281600,24.718599
1999-01-04,139.609299,145.25,139.375,141.00,69305200,23.790597
1998-12-31,139.1875,140.00,138.00,138.6875,23834400,23.400414
1998-12-30,140.875,143.359299,138.875,139.00,34942800,23.453141
1998-12-29,142.5625,142.5625,139.625,140.50,29651600,23.706233
1998-12-28,143.00,143.625,141.50,142.375,23636400,24.022597
1998-12-24,143.625,144.00,141.50,141.75,13832400,23.917142
1998-12-23,140.375,143.8125,139.375,143.5625,34940000,24.222961
1998-12-22,140.50,140.50,137.375,138.4375,41350000,23.358232
1998-12-21,138.625,142.1875,137.75,140.4375,48112000,23.695687
1998-12-18,135.00,138.25,134.125,137.8125,59648000,23.252777
1998-12-17,134.1875,134.875,132.25,134.375,46963600,22.672776
1998-12-16,132.50,135.125,129.125,133.75,60024000,22.567321
1998-12-15,129.3125,132.00,129.25,131.875,51719600,22.250957
1998-12-14,132.75,133.75,127.6875,127.9375,64077600,21.586592
1998-12-11,131.00,134.6875,130.75,134.00,51728800,22.609503
1998-12-10,133.125,134.625,131.375,131.5625,57015600,22.19823
1998-12-09,132.125,133.8125,130.00,133.625,44781600,22.54623
1998-12-08,132.875,134.25,129.75,131.1875,77585200,22.134957
1998-12-07,127.6875,133.75,126.75,133.5625,89809200,22.535685
1998-12-04,124.9375,127.375,124.00,127.375,44352000,21.491683
1998-12-03,126.875,128.9375,122.00,122.125,51426800,20.605863
1998-12-02,129.1875,129.75,125.50,126.75,65759600,21.386228
1998-12-01,120.25,129.75,120.125,129.50,86330800,21.850229
1998-11-30,129.375,130.265594,121.9375,122.00,70900000,20.584772
1998-11-27,125.125,128.125,124.3125,128.0625,26335600,21.607683
1998-11-25,122.6875,124.375,120.75,124.25,41394000,20.964409
1998-11-24,118.6875,125.0625,118.625,121.6875,101114800,20.532044
1998-11-23,112.50,120.1875,112.50,119.1875,110870400,20.110225
1998-11-20,112.75,113.75,111.25,113.625,48405200,19.171678
1998-11-19,109.0625,112.50,109.0625,111.75,45220800,18.855313
1998-11-18,109.5625,111.0625,109.125,109.75,41691200,18.517858
1998-11-17,109.00,112.375,108.9375,111.875,58744000,18.876404
1998-11-16,111.3125,111.75,107.50,108.8125,42620400,18.359676
1998-11-13,108.4375,110.50,108.375,110.00,28368800,18.56004
1998-11-12,110.25,111.125,108.50,108.75,38526800,18.34913
1998-11-11,113.4375,114.75,110.875,111.0625,63899200,18.739313
1998-11-10,110.125,113.4375,110.0625,112.0625,72075600,18.908041
1998-11-09,109.1875,111.375,108.8125,110.6875,68956800,18.67604
1998-11-06,106.0625,109.75,105.9375,109.3125,74461200,18.44404
1998-11-05,105.3125,107.625,105.25,106.375,76727200,17.948402
1998-11-04,105.8125,107.3125,104.875,105.50,67459600,17.800766
1998-11-03,105.50,106.5625,104.75,105.1875,36546800,17.748038
1998-11-02,106.375,106.875,105.00,105.8125,48388400,17.853493
1998-10-30,107.25,108.1875,105.125,105.875,59322800,17.864038
1998-10-29,105.4375,107.50,105.4375,106.625,52402800,17.990584
1998-10-28,104.875,106.625,104.875,105.6875,56808400,17.832402
1998-10-27,107.75,107.875,105.00,105.4375,65434800,17.79022
1998-10-26,106.8125,108.00,105.6875,107.0625,59678400,18.064403
1998-10-23,109.00,110.00,106.1875,106.375,59882000,17.948402
1998-10-22,106.00,110.125,105.25,110.00,81910800,18.56004
1998-10-21,104.875,106.875,103.0625,106.4375,125377200,17.958948
1998-10-20,103.25,103.375,99.625,100.25,94368400,16.914946
1998-10-19,104.125,104.1875,101.125,102.9375,60177600,17.368401
1998-10-16,106.00,106.50,104.00,105.0625,68620000,17.726947
1998-10-15,100.125,105.625,99.625,105.4375,66253600,17.79022
1998-10-14,95.875,101.375,95.875,100.1875,62403200,16.9044
1998-10-13,99.50,99.75,95.75,96.4375,47995600,16.271671
1998-10-12,99.25,101.00,98.50,99.75,51502800,16.830582
1998-10-09,93.1875,97.00,92.25,96.875,72661600,16.34549
1998-10-08,90.5625,91.875,87.75,91.1875,144719200,15.385851
1998-10-07,97.375,99.75,93.375,94.125,90710400,15.881489
1998-10-06,102.50,103.625,97.375,97.625,76550000,16.472035
1998-10-05,102.50,102.875,96.50,101.1875,114937600,17.073128
1998-10-02,103.375,105.1875,101.00,104.125,65889600,17.568765
1998-10-01,108.0625,109.50,104.00,104.0625,65442400,17.55822
1998-09-30,112.3125,113.5625,110.031197,110.0625,38875600,18.570585
1998-09-29,111.8125,114.00,111.375,112.875,48743200,19.045132
1998-09-28,113.00,114.375,109.75,111.3125,41405200,18.781495
1998-09-25,109.125,113.125,108.625,113.0625,47878400,19.076768
1998-09-24,113.125,114.625,109.00,110.125,63521600,18.581131
1998-09-23,109.625,113.875,108.50,113.625,65263600,19.171678
1998-09-22,108.4375,109.875,106.75,109.1875,43082000,18.422949
1998-09-21,102.50,108.0625,102.375,107.875,45872000,18.201494
1998-09-18,105.75,106.25,104.3125,105.375,47361600,17.779675
1998-09-17,105.3125,106.50,104.8125,104.9375,45178400,17.705856
1998-09-16,107.875,108.50,106.125,108.1875,42886800,18.254221
1998-09-15,105.875,108.4375,105.125,108.3125,49367600,18.275312
1998-09-14,104.9375,107.0625,104.875,106.00,45086800,17.885129
1998-09-11,101.125,104.625,100.125,104.25,58989200,17.589856
1998-09-10,100.00,101.125,98.6875,100.75,60758000,16.999309
1998-09-09,102.25,104.4375,101.625,102.25,65480800,17.252401
1998-09-08,100.00,102.0625,99.0625,101.968697,60625600,17.204937
1998-09-04,99.6875,100.25,96.125,96.625,50890400,16.303308
1998-09-03,98.75,100.75,98.375,99.25,67506800,16.746218
1998-09-02,101.8125,104.25,100.25,100.5625,63438400,16.967673
1998-09-01,95.25,101.75,94.50,101.25,140112400,17.083673
1998-08-31,104.875,106.50,95.75,95.9375,132690400,16.187308
1998-08-28,108.25,109.625,104.75,105.25,72730000,17.758584
1998-08-27,110.5625,112.75,108.50,109.25,74874000,18.433494
1998-08-26,111.25,113.75,110.875,112.5625,44804400,18.992405
1998-08-25,111.375,113.6875,111.125,112.8125,58026800,19.034586
1998-08-24,110.3125,112.00,110.00,110.375,26319200,18.623313
1998-08-21,111.125,111.875,108.75,110.625,59523600,18.665495
1998-08-20,110.125,112.75,109.6875,112.5625,49970400,18.992405
1998-08-19,112.25,112.75,110.25,110.5625,55709600,18.654949
1998-08-18,107.875,111.8125,107.375,111.25,70591200,18.77095
1998-08-17,103.50,107.375,103.00,107.3125,54073200,18.106584
1998-08-14,104.6875,105.0625,103.50,104.25,29566400,17.589856
1998-08-13,104.125,106.00,103.75,103.9375,51193200,17.537129
1998-08-12,104.3125,105.1875,103.00,105.0625,53760000,17.726947
1998-08-11,102.875,104.375,102.00,103.4375,60976400,17.452765
1998-08-10,105.8125,106.3125,104.4375,104.4375,46763200,17.621493
1998-08-07,107.4375,107.50,105.0625,105.875,54972400,17.864038
1998-08-06,103.75,106.9375,103.625,106.875,68308000,18.032766
1998-08-05,104.125,106.25,101.50,104.3125,120208800,17.600402
1998-08-04,108.625,109.625,104.1875,104.50,91412000,17.632038
1998-08-03,109.125,110.875,107.375,108.4375,73566400,18.296403
1998-07-31,112.9375,113.515602,109.9375,109.9375,53705200,18.549495
1998-07-30,111.9375,113.625,110.75,113.4375,72746400,19.140041
1998-07-29,113.25,114.25,110.0625,110.6875,59738000,18.67604
1998-07-28,116.00,116.875,112.00,112.25,78378400,18.939677
1998-07-27,113.125,116.75,110.6875,116.75,58998000,19.698952
1998-07-24,113.75,115.625,112.50,113.8125,60366400,19.203314
1998-07-23,116.3125,117.50,113.00,113.00,51029600,19.066223
1998-07-22,112.00,117.25,111.875,116.75,71654400,19.698952
1998-07-21,116.875,119.00,112.50,112.8125,74605200,19.034586
1998-07-20,118.1875,119.50,116.8125,117.00,45794800,19.741133
1998-07-17,117.50,119.625,115.9375,117.9375,83108400,19.899316
1998-07-16,118.0625,118.875,116.625,117.375,65125200,19.804406
1998-07-15,116.00,118.00,115.625,117.375,48690000,19.804406
1998-07-14,118.25,118.75,115.50,116.50,56972400,19.65677
1998-07-13,114.125,118.25,113.625,117.5625,69223200,19.836043
1998-07-10,111.125,113.25,109.875,113.1875,45396800,19.097859
1998-07-09,110.00,112.00,109.75,111.00,43690000,18.728768
1998-07-08,108.125,110.125,106.75,109.875,41553600,18.538949
1998-07-07,107.8125,108.5625,106.50,107.9375,32422800,18.212039
1998-07-06,106.875,108.0625,105.375,107.8125,35307600,18.190948
1998-07-02,108.8125,109.125,107.125,107.25,27321200,18.096039
1998-07-01,109.125,110.125,107.1875,109.375,53470400,18.454585
1998-06-30,105.25,108.5625,104.625,108.375,77010000,18.285858
1998-06-29,105.50,107.6875,105.25,107.4375,65906000,18.127675
1998-06-26,102.25,104.625,102.00,104.4375,55680400,17.621493
1998-06-25,105.875,106.875,101.375,101.5625,88969600,17.136401
1998-06-24,101.6875,105.125,99.9375,104.9375,105724800,17.705856
1998-06-23,95.8125,100.875,95.25,100.75,124675200,16.999309
1998-06-22,94.75,95.9375,93.6875,95.8125,48969600,16.166217
1998-06-19,92.875,94.75,92.50,94.6875,91226800,15.976398
1998-06-18,90.8125,91.75,90.375,91.1875,39228400,15.385851
1998-06-17,89.9375,92.375,89.75,91.0625,76147600,15.36476
1998-06-16,86.3125,89.9375,85.50,89.875,61138400,15.164396
1998-06-15,84.6875,87.3125,84.5625,85.9375,42846000,14.500031
1998-06-12,84.875,86.125,84.00,85.75,41323600,14.468395
1998-06-11,86.4375,87.125,85.125,85.3125,41271200,14.394576
1998-06-10,86.625,88.375,85.875,86.00,33290400,14.510577
1998-06-09,85.3125,87.5625,85.25,87.0625,35690400,14.68985
1998-06-08,85.625,86.3125,85.00,85.6875,18886400,14.457849
1998-06-05,85.875,86.50,84.75,86.25,34431600,14.552759
1998-06-04,84.6875,86.125,83.625,86.0625,33717600,14.521122
1998-06-03,85.875,86.4375,84.125,84.3125,36010800,14.225849
1998-06-02,84.0625,85.9375,83.875,85.50,38570800,14.426213
1998-06-01,83.875,84.609299,83.125,83.75,42436800,14.13094
1998-05-29,86.375,86.50,84.75,84.8125,34091200,14.310213
1998-05-28,85.75,86.375,85.0625,86.3125,30746800,14.563304
1998-05-27,82.875,86.125,82.875,86.00,58574400,14.510577
1998-05-26,85.3125,86.1875,83.50,83.625,44473600,14.109849
1998-05-22,86.625,86.75,85.4375,85.5625,36129200,14.436758
1998-05-21,85.8125,87.375,85.50,86.375,36680000,14.57385
1998-05-20,86.125,86.875,85.375,85.75,35698800,14.468395
1998-05-19,85.8125,86.9375,85.5625,86.50,52234400,14.594941
1998-05-18,84.50,86.50,84.50,86.0625,80395600,14.521122
1998-05-15,90.125,90.1875,88.75,89.4375,48150800,15.090578
1998-05-14,85.875,91.00,85.8125,88.9375,94774400,15.006214
1998-05-13,88.6875,88.75,86.50,86.9375,80680400,14.668759
1998-05-12,83.25,85.75,83.25,85.6875,64147200,14.457849
1998-05-11,86.125,86.1875,84.0625,84.25,51474400,14.215303
1998-05-08,81.875,86.125,81.875,85.75,96274800,14.468395
1998-05-07,86.1875,86.25,83.1875,83.375,78022000,14.067667
1998-05-06,87.50,87.50,86.00,86.375,48110800,14.57385
1998-05-05,87.625,89.5625,87.00,87.75,50828000,14.80585
1998-05-04,89.1875,89.875,87.9375,88.0625,37899600,14.858577
1998-05-01,90.1875,90.50,88.125,89.625,35996000,15.122214
1998-04-30,91.50,91.625,89.6875,90.125,54473600,15.206578
1998-04-29,90.0625,91.50,89.625,90.50,50061600,15.269851
1998-04-28,92.125,92.25,89.015602,89.875,56668000,15.164396
1998-04-27,89.50,90.531197,88.50,90.3125,58752000,15.238215
1998-04-24,93.50,94.75,91.875,92.125,51436000,15.544033
1998-04-23,97.25,97.375,94.140602,94.50,64215200,15.944762
1998-04-22,96.00,99.125,95.625,98.875,80154000,16.682945
1998-04-21,94.6875,95.00,93.125,94.875,51938400,16.008034
1998-04-20,92.375,95.00,92.1875,94.625,45535200,15.965853
1998-04-17,91.50,92.25,90.3125,92.125,37402800,15.544033
1998-04-16,90.375,92.0625,90.1875,91.6875,39695600,15.470215
1998-04-15,89.25,91.375,88.875,91.375,40498400,15.417488
1998-04-14,88.6875,89.5625,87.50,88.4375,28476800,14.92185
1998-04-13,88.8125,89.00,86.75,88.625,33156400,14.953487
1998-04-09,87.9375,89.625,87.50,89.00,33619200,15.01676
1998-04-08,86.75,89.00,86.625,88.9375,36793200,15.006214
1998-04-07,89.3125,90.625,86.75,87.25,62630800,14.721486
1998-04-06,92.625,92.625,89.0625,89.9375,74232000,15.174942
1998-04-03,92.00,93.0625,91.50,93.00,40987600,15.69167
1998-04-02,90.6875,91.9375,89.875,91.3125,41414800,15.406942
1998-04-01,89.8125,90.625,88.50,90.375,36835600,15.24876
1998-03-31,88.625,89.75,88.50,89.50,38177200,15.101123
1998-03-30,88.0625,88.625,87.125,87.9375,27463200,14.837487
1998-03-27,89.375,89.375,87.5625,87.8125,38924000,14.816396
1998-03-26,88.50,89.5625,87.50,88.25,45441200,14.890214
1998-03-25,90.50,90.9375,87.25,88.8125,124244800,14.985123
1998-03-24,84.1875,85.0625,83.4375,84.9375,32281600,14.331304
1998-03-23,81.1875,84.625,81.0625,83.875,55050000,14.15203
1998-03-20,82.125,83.00,80.50,81.8125,56310000,13.80403
1998-03-19,81.50,82.3125,81.25,82.00,30299200,13.835666
1998-03-18,80.0625,81.8125,79.875,81.75,33887600,13.793484
1998-03-17,81.6875,81.6875,79.6875,80.375,53842400,13.561484
1998-03-16,82.4375,82.75,81.375,82.00,27979600,13.835666
1998-03-13,82.4375,83.00,81.5625,82.375,32542400,13.898939
1998-03-12,82.50,82.625,80.8125,81.875,47962000,13.814575
1998-03-11,82.00,82.00,79.75,80.6875,39838800,13.614211
1998-03-10,81.1875,81.50,79.9375,81.50,47406400,13.751302
1998-03-09,82.50,82.50,79.50,79.593697,52256000,13.429656
1998-03-06,80.3125,82.75,80.25,82.75,51404800,13.962212
1998-03-05,79.25,81.4375,79.25,80.0625,92255600,13.508756
1998-03-04,82.4375,83.8125,81.5625,82.3125,71513600,13.888394
1998-03-03,82.625,84.5625,82.5625,84.50,50753600,14.257485
1998-03-02,85.875,85.875,83.0625,83.3125,50093600,14.057121
1998-02-27,85.5625,86.00,84.5625,84.75,47532400,14.299667
1998-02-26,85.50,85.6875,84.4375,85.50,61388000,14.426213
1998-02-25,83.4375,85.00,83.0625,84.9375,94944400,14.331304
1998-02-24,83.375,84.9375,81.875,82.125,118302000,13.856757
1998-02-23,80.9375,81.6875,79.375,81.625,120803600,13.772393
1998-02-20,155.50,155.75,152.875,155.125,86092000,13.086937
1998-02-19,155.50,156.0625,154.25,154.875,73773600,13.065846
1998-02-18,154.625,156.00,153.75,154.625,76608800,13.044755
1998-02-17,158.50,158.50,153.875,154.375,85673600,13.023664
1998-02-13,158.625,158.75,157.375,157.50,42203200,13.287301
1998-02-12,158.0625,158.9375,156.4375,158.75,76658400,13.392756
1998-02-11,159.375,160.0625,157.0625,158.9375,76460000,13.408574
1998-02-10,157.25,159.50,156.75,159.25,48099200,13.434938
1998-02-09,158.75,158.875,155.625,157.1875,54681600,13.260938
1998-02-06,155.375,158.25,155.125,158.125,50070400,13.340029
1998-02-05,158.125,158.75,154.75,155.4375,67014400,13.113301
1998-02-04,155.875,158.00,155.0625,156.8125,61940800,13.229301
1998-02-03,155.125,156.125,153.8125,155.875,61374400,13.15021
1998-02-02,151.75,155.125,150.50,154.875,98397600,13.065846
1998-01-30,148.625,150.00,147.625,149.1875,50071200,12.586027
1998-01-29,148.9375,150.125,147.50,148.25,73571200,12.506936
1998-01-28,146.25,149.50,145.50,149.00,79387200,12.570209
1998-01-27,142.375,145.875,141.5625,145.1875,97540800,12.248572
1998-01-26,139.875,141.875,138.453094,141.75,74277600,11.958571
1998-01-23,138.75,139.4375,136.703094,138.25,63312000,11.663298
1998-01-22,135.5625,139.875,135.3125,138.625,159139200,11.694934
1998-01-21,137.25,138.4375,135.625,137.00,85567200,11.557843
1998-01-20,134.125,138.00,134.00,137.8125,64956000,11.626389
1998-01-16,132.375,135.375,132.3125,135.25,72943200,11.410206
1998-01-15,130.375,133.00,129.875,132.3125,50622400,11.162388
1998-01-14,132.125,132.50,129.25,131.125,54774400,11.062206
1998-01-13,129.50,132.25,128.125,132.125,66945600,11.146569
1998-01-12,124.625,130.00,124.375,129.50,78393600,10.925114
1998-01-09,130.0625,131.50,125.875,127.00,87534400,10.714205
1998-01-08,128.625,132.125,127.50,130.50,77619200,11.009478
1998-01-07,129.875,131.1875,127.50,129.5625,61492800,10.930387
1998-01-06,129.75,133.00,129.25,131.125,67834400,11.062206
1998-01-05,131.25,133.625,127.875,130.375,80377600,10.998933
1998-01-02,129.625,131.50,129.50,131.125,39748000,11.062206
1997-12-31,131.00,131.50,129.00,129.25,46147200,10.904023
1997-12-30,126.4375,131.00,126.25,130.25,77864800,10.988387
1997-12-29,122.375,126.75,122.125,126.3125,67815200,10.656205
1997-12-26,118.875,120.75,118.75,120.75,32388800,10.186931
1997-12-24,123.75,123.875,118.00,118.9375,88411200,10.034022
1997-12-23,127.0625,128.25,123.00,123.3125,67195200,10.403113
1997-12-22,129.125,130.00,125.875,127.00,59063200,10.714205
1997-12-19,128.75,130.1875,126.25,128.6875,138065600,10.856569
1997-12-18,134.50,134.75,130.375,130.875,98774400,11.041115
1997-12-17,139.875,140.375,135.50,135.625,51472000,11.441843
1997-12-16,135.875,140.375,135.00,139.0625,65401600,11.731843
1997-12-15,136.4375,137.00,133.00,136.125,84305600,11.484025
1997-12-12,137.75,138.50,136.00,136.75,54308000,11.536752
1997-12-11,140.375,141.00,138.875,139.0625,70189600,11.731843
1997-12-10,142.25,143.25,141.00,142.25,66434400,12.000753
1997-12-09,145.00,145.375,143.50,144.3125,51782400,12.174754
1997-12-08,143.50,146.625,143.125,146.125,49952800,12.327663
1997-12-05,142.125,144.75,142.125,143.125,48136000,12.074571
1997-12-04,144.75,145.875,142.25,142.5625,62630400,12.027117
1997-12-03,141.6875,145.0625,141.00,144.6875,57712000,12.20639
1997-12-02,143.5625,144.875,142.00,142.25,50167200,12.000753
1997-12-01,141.9375,144.00,141.625,143.8125,49006400,12.132572
1997-11-28,141.25,142.25,141.125,141.50,17392800,11.93748
1997-11-26,139.00,141.875,138.25,141.5625,63053600,11.942753
1997-11-25,135.875,139.25,135.75,139.00,56463200,11.726571
1997-11-24,137.125,138.125,135.50,135.50,39084000,11.431297
1997-11-21,137.8125,138.00,136.375,137.875,68220800,11.631661
1997-11-20,135.25,137.125,134.875,136.875,53680800,11.547298
1997-11-19,133.625,135.125,133.375,135.0625,31720800,11.394388
1997-11-18,134.9375,135.50,133.75,134.00,36683200,11.304752
1997-11-17,134.50,135.8125,133.4375,134.875,60094400,11.37857
1997-11-14,131.625,133.875,131.375,133.3125,46663200,11.246752
1997-11-13,130.0625,131.625,129.1875,131.5625,60094400,11.099115
1997-11-12,130.125,131.00,129.00,129.1875,45784000,10.898751
1997-11-11,130.4375,131.4375,129.375,130.625,37013600,11.020024
1997-11-10,131.625,132.50,129.75,130.1875,36764800,10.983115
1997-11-07,130.0625,132.00,129.875,131.5625,63628800,11.099115
1997-11-06,133.25,133.50,131.75,132.0625,40266400,11.141297
1997-11-05,134.50,134.625,132.50,133.5625,42512800,11.267842
1997-11-04,134.00,134.9375,133.1875,134.25,49134400,11.325843
1997-11-03,131.625,134.25,131.3125,134.125,67714400,11.315297
1997-10-31,131.00,131.50,129.625,130.00,46808800,10.967296
1997-10-30,129.50,131.375,128.50,128.625,72097600,10.851296
1997-10-29,133.75,135.0625,130.125,130.875,85532800,11.041115
1997-10-28,132.25,135.00,123.50,133.375,160057600,11.252024
1997-10-27,134.875,136.25,128.625,128.875,96795200,10.872387
1997-10-24,136.875,137.25,133.25,135.375,70030400,11.420752
1997-10-23,132.00,137.25,132.00,135.625,66413600,11.441843
1997-10-22,138.375,138.50,135.375,135.6875,55775200,11.447116
1997-10-21,136.125,139.234299,135.3125,138.50,115682400,11.684389
1997-10-20,133.00,135.25,127.50,132.625,154052800,11.188751
1997-10-17,133.125,134.625,130.375,132.25,87720000,11.157115
1997-10-16,136.125,136.625,132.25,133.906204,47327200,11.296839
1997-10-15,135.75,136.00,134.875,135.75,45003200,11.452388
1997-10-14,137.125,137.375,135.375,136.6875,33361600,11.531479
1997-10-13,137.00,137.875,136.5625,136.75,19051200,11.536752
1997-10-10,138.3125,138.75,136.25,136.50,24893600,11.515661
1997-10-09,138.50,139.625,138.125,138.9375,34672800,11.721298
1997-10-08,136.625,139.0625,136.25,139.00,71196800,11.726571
1997-10-07,135.00,137.6875,134.625,136.5625,54548800,11.520934
1997-10-06,135.875,136.25,134.25,135.125,41776800,11.399661
1997-10-03,134.9375,136.25,133.375,134.9375,60284800,11.383843
1997-10-02,133.75,134.625,132.75,133.1875,28831200,11.236206
1997-10-01,132.50,134.50,131.375,133.875,61466400,11.294206
1997-09-30,134.4375,135.75,132.25,132.3125,43892800,11.162388
1997-09-29,133.50,134.75,132.875,134.50,27505600,11.346934
1997-09-26,133.625,133.75,131.625,133.375,36652000,11.252024
1997-09-25,132.875,134.125,132.0625,132.75,39272000,11.199297
1997-09-24,135.625,136.0625,132.125,132.4375,60040000,11.172933
1997-09-23,133.5625,135.50,133.125,135.50,39946400,11.431297
1997-09-22,135.00,135.875,133.1875,133.3125,43251200,11.246752
1997-09-19,132.25,135.25,132.00,135.1875,77435200,11.404934
1997-09-18,134.25,135.125,131.4375,132.25,61077600,11.157115
1997-09-17,136.625,136.75,132.625,133.1875,61609600,11.236206
1997-09-16,131.75,137.00,131.00,136.375,102538400,11.505116
1997-09-15,135.625,137.25,130.625,130.6875,129003200,11.025296
1997-09-12,136.875,138.375,135.625,137.9375,48576000,11.636934
1997-09-11,135.00,137.375,132.875,136.8125,61779200,11.542025
1997-09-10,138.875,139.125,135.0625,135.125,53294400,11.399661
1997-09-09,139.25,140.25,138.375,139.50,39465600,11.768753
1997-09-08,137.75,139.8125,137.75,139.3125,42416000,11.752934
1997-09-05,139.0625,139.6875,136.25,137.3125,48398400,11.584207
1997-09-04,136.00,138.50,135.75,138.1875,44476000,11.658025
1997-09-03,137.625,138.875,136.1875,136.5625,42872800,11.520934
1997-09-02,133.125,137.50,133.00,137.1875,50112800,11.573661
1997-08-29,132.0625,133.875,131.75,132.1875,37857600,11.151842
1997-08-28,133.50,133.75,132.00,132.0625,43641600,11.141297
1997-08-27,135.25,135.3125,133.00,134.5625,49371200,11.352206
1997-08-26,136.00,136.875,134.75,135.00,34327200,11.389115
1997-08-25,137.875,139.00,135.625,136.50,38856800,11.515661
1997-08-22,135.25,137.50,134.125,137.25,72161600,11.578934
1997-08-21,141.625,142.375,137.50,137.875,64412000,11.631661
1997-08-20,139.00,140.6875,137.00,140.5625,51433600,11.858389
1997-08-19,134.75,139.00,134.625,138.8125,91013600,11.710753
1997-08-18,133.00,133.875,131.00,133.875,69969600,11.294206
1997-08-15,135.50,136.00,132.75,132.875,51078400,11.209842
1997-08-14,136.00,136.75,134.125,136.25,45900800,11.49457
1997-08-13,138.125,138.25,134.75,136.0625,66731200,11.478752
1997-08-12,139.375,139.75,135.8125,136.00,60887200,11.473479
1997-08-11,140.00,140.25,136.375,138.25,72696000,11.663298
1997-08-08,142.8125,143.125,140.00,140.00,66815200,11.810935
1997-08-07,144.3125,144.375,142.00,143.9375,43947200,12.143117
1997-08-06,143.3125,144.625,142.25,143.4375,43410400,12.100935
1997-08-05,142.25,144.375,142.00,143.3125,59333600,12.09039
1997-08-04,140.25,142.00,139.4375,141.5625,46312800,11.942753
1997-08-01,141.375,141.8125,139.1875,140.625,58912800,11.863662
1997-07-31,142.00,142.125,140.875,141.375,42240800,11.926935
1997-07-30,140.75,142.00,139.625,141.125,78324000,11.905844
1997-07-29,136.75,140.0625,136.125,139.9375,79061600,11.805662
1997-07-28,139.25,139.375,135.75,137.00,56404000,11.557843
1997-07-25,138.50,142.25,137.25,138.50,90308800,11.684389
1997-07-24,138.375,140.375,135.625,138.00,141855200,11.642207
1997-07-23,145.25,146.875,141.00,141.4375,95556000,11.932208
1997-07-22,136.875,144.8125,136.75,144.125,101384000,12.158935
1997-07-21,140.875,141.00,133.75,135.9375,127223200,11.468207
1997-07-18,145.00,147.375,140.00,140.50,158927200,11.853116
1997-07-17,150.50,150.75,146.50,149.50,131668000,12.612391
1997-07-16,142.375,149.50,140.00,148.4375,111217600,12.522754
1997-07-15,138.0625,139.25,136.625,138.468704,75503200,11.681749
1997-07-14,130.8125,136.00,130.50,135.9375,57424000,11.468207
1997-07-11,130.25,131.0625,128.4375,129.75,38094400,10.946205
1997-07-10,130.50,131.25,128.875,129.875,43780800,10.956751
1997-07-09,132.50,132.625,129.50,130.75,48266400,11.030569
1997-07-08,129.375,131.3125,128.9375,131.25,36007200,11.072751
1997-07-07,130.625,131.75,129.375,129.50,39320000,10.925114
1997-07-03,130.0625,130.0625,128.50,129.5625,28764000,10.930387
1997-07-02,125.625,128.50,124.0625,128.375,53237600,10.830205
1997-07-01,126.4375,126.875,123.25,124.9375,59377600,10.540205
1997-06-30,127.875,128.75,126.1875,126.375,38286400,10.661478
1997-06-27,129.125,130.00,127.25,127.50,38198400,10.756387
1997-06-26,130.125,130.8125,127.875,128.25,37312000,10.81966
1997-06-25,132.875,133.25,129.8125,130.4375,49576000,11.004206
1997-06-24,129.50,132.125,128.375,132.0625,39319200,11.141297
1997-06-23,129.875,131.50,128.00,128.0625,35724800,10.803841
1997-06-20,129.375,131.375,128.50,129.875,64240000,10.956751
1997-06-19,128.375,130.75,128.00,129.3125,65519200,10.909296
1997-06-18,133.25,133.50,130.0625,130.1875,55657600,10.983115
1997-06-17,131.50,134.9375,130.875,134.1875,53191200,11.32057
1997-06-16,129.625,131.375,128.875,131.375,40612800,11.083297
1997-06-13,126.75,130.0625,126.5625,129.625,50116000,10.93566
1997-06-12,126.75,128.125,125.375,127.00,44614400,10.714205
1997-06-11,124.8125,127.375,123.5625,127.00,49056800,10.714205
1997-06-10,125.125,127.0625,123.75,124.8125,53135200,10.529659
1997-06-09,124.875,126.125,122.50,125.125,48200000,10.556023
1997-06-06,121.375,124.3125,121.00,124.0625,35964000,10.466386
1997-06-05,120.265602,121.50,119.50,120.5625,35892000,10.171113
1997-06-04,120.625,122.25,118.25,119.1875,54639200,10.055113
1997-06-03,123.375,123.50,120.625,120.75,41995200,10.186931
1997-06-02,125.00,125.50,123.125,124.375,38939200,10.49275
1997-05-30,117.50,125.625,117.50,124.00,83337600,10.461113
1997-05-29,127.25,129.0625,125.00,125.875,51111200,10.619296
1997-05-28,127.25,127.25,124.875,125.875,52241600,10.619296
1997-05-27,122.75,127.375,122.375,126.625,69036000,10.682568
1997-05-23,121.375,123.00,120.875,122.875,28904800,10.366204
1997-05-22,121.00,121.625,119.75,120.625,33655200,10.176386
1997-05-21,120.625,122.9375,119.75,120.375,76620000,10.155295
1997-05-20,115.875,119.25,115.25,119.125,64876800,10.04984
1997-05-19,116.125,117.125,115.125,115.125,45632000,9.712385
1997-05-16,116.375,117.00,114.875,115.4375,59913600,9.738748
1997-05-15,116.00,117.875,115.875,117.125,41861600,9.881112
1997-05-14,118.375,118.625,115.625,115.875,60744800,9.775657
1997-05-13,118.375,119.25,116.875,117.75,49813600,9.93384
1997-05-12,117.50,118.50,117.00,118.125,42976000,9.965476
1997-05-09,118.00,118.50,115.75,116.75,58392000,9.849476
1997-05-08,115.25,118.125,115.125,116.375,53834400,9.817839
1997-05-07,116.375,119.00,115.125,115.50,70532800,9.744021
1997-05-06,119.375,119.75,116.375,117.3125,74770400,9.89693
1997-05-05,119.625,120.75,115.50,120.1875,111063200,10.139476
1997-05-02,122.00,123.50,118.9375,120.75,96192000,10.186931
1997-05-01,122.00,123.25,119.25,121.00,72325600,10.208022
1997-04-30,118.625,122.625,118.375,121.50,90204000,10.250204
1997-04-29,117.375,119.125,116.50,119.00,73953600,10.039294
1997-04-28,113.75,115.0625,111.625,114.875,67224000,9.691294
1997-04-25,113.50,115.375,113.25,113.625,58566400,9.585839
1997-04-24,116.625,117.875,112.75,114.125,118163200,9.628021
1997-04-23,110.625,115.75,110.375,115.125,102814400,9.712385
1997-04-22,107.625,110.8125,107.50,110.625,82300000,9.332747
1997-04-21,107.00,111.875,106.125,107.625,155695200,9.079656
1997-04-18,104.00,107.625,103.00,107.625,231764000,9.079656
1997-04-17,98.50,100.00,97.50,98.125,71720800,8.2782
1997-04-16,96.625,98.50,96.25,98.25,42710400,8.288745
1997-04-15,97.875,99.00,95.875,97.125,84440000,8.193836
1997-04-14,94.75,97.375,93.375,97.375,59107200,8.214927
1997-04-11,95.50,97.25,94.9375,95.00,60033600,8.014563
1997-04-10,97.75,97.75,95.50,96.75,67913600,8.162199
1997-04-09,99.125,99.25,97.75,98.00,73762400,8.267654
1997-04-08,96.625,98.25,95.50,98.25,53339200,8.288745
1997-04-07,95.625,97.625,95.00,95.875,76511200,8.088381
1997-04-04,93.75,96.75,93.75,94.1875,94964000,7.946017
1997-04-03,91.00,95.375,90.625,95.125,92252800,8.025108
1997-04-02,92.875,93.625,91.00,92.00,63331200,7.761471
1997-04-01,90.125,93.75,89.75,93.25,86680800,7.866926
1997-03-31,93.125,94.50,91.25,91.6875,93825600,7.735108
1997-03-27,95.125,96.125,91.00,93.75,93919200,7.909108
1997-03-26,90.75,94.625,90.625,94.25,81270400,7.95129
1997-03-25,90.625,91.375,88.875,90.3125,89701600,7.619107
1997-03-24,93.125,93.50,87.625,90.125,186269600,7.603289
1997-03-21,96.50,97.125,92.875,94.00,85829600,7.930199
1997-03-20,96.625,97.75,95.375,96.00,81410400,8.098927
1997-03-19,97.75,98.25,94.9375,96.75,111560000,8.162199
1997-03-18,100.625,100.8125,98.875,99.625,59012000,8.404745
1997-03-17,98.50,100.75,98.00,100.50,83958400,8.478564
1997-03-14,99.75,100.25,98.875,99.00,61327200,8.352018
1997-03-13,98.25,100.125,98.00,99.625,45505600,8.404745
1997-03-12,97.75,99.50,97.75,98.75,43234400,8.330927
1997-03-11,99.625,100.5625,98.375,98.375,47577600,8.299291
1997-03-10,97.125,100.125,95.9375,100.00,45997600,8.436382
1997-03-07,98.375,99.50,96.50,96.75,46032000,8.162199
1997-03-06,100.75,100.875,97.734299,97.75,57018400,8.246563
1997-03-05,99.50,101.00,99.25,100.875,46393600,8.5102
1997-03-04,99.25,100.125,98.625,99.125,63920800,8.362563
1997-03-03,97.00,100.125,96.625,99.50,53874400,8.3942
1997-02-28,96.125,98.375,95.4375,97.50,78412000,8.225472
1997-02-27,100.25,100.25,96.00,96.125,56628800,8.109472
1997-02-26,99.50,100.375,98.375,100.25,48849600,8.457473
1997-02-25,100.00,101.015602,98.875,99.50,63941600,8.3942
1997-02-24,94.25,100.25,94.00,100.125,68599200,8.446927
1997-02-21,94.875,95.375,94.00,95.00,61131200,8.014563
1997-02-20,96.875,97.50,95.125,95.25,75395200,8.035654
1997-02-19,97.375,98.125,96.50,97.50,56383200,8.225472
1997-02-18,97.625,97.875,96.25,97.375,52545600,8.214927
1997-02-14,99.375,100.50,97.625,97.875,57395200,8.257109
1997-02-13,100.50,101.125,99.375,100.00,58292000,8.436382
1997-02-12,98.375,100.00,97.50,99.875,72001600,8.425836
1997-02-11,98.25,98.625,95.125,98.50,88834400,8.309836
1997-02-10,100.75,101.50,97.625,97.75,66804800,8.246563
1997-02-07,98.375,100.50,97.50,100.375,62448000,8.468018
1997-02-06,98.25,98.375,96.00,97.125,102122400,8.193836
1997-02-05,103.125,103.50,96.875,98.375,110099200,8.299291
1997-02-04,102.375,103.25,100.50,103.125,56464000,8.700019
1997-02-03,102.625,103.390602,101.125,102.375,60804800,8.636746
1997-01-31,101.875,103.25,100.875,102.00,86516000,8.605109
1997-01-30,98.25,101.25,98.00,101.125,79937600,8.531291
1997-01-29,96.75,97.375,95.75,97.25,48933600,8.204381
1997-01-28,98.375,98.75,94.75,95.625,64656800,8.06729
1997-01-27,96.50,97.390602,95.50,96.125,53263200,8.109472
1997-01-24,95.125,97.75,94.375,95.9375,89817600,8.093654
1997-01-23,98.125,99.75,94.50,94.75,105048000,7.993472
1997-01-22,95.125,98.50,94.625,97.375,129236800,8.214927
1997-01-21,90.625,95.0625,89.625,95.00,114592000,8.014563
1997-01-20,87.00,92.875,86.625,90.75,146220800,7.656016
1997-01-17,85.625,87.75,85.50,87.125,65368800,7.350198
1997-01-16,85.00,87.125,85.00,86.00,58688000,7.255288
1997-01-15,85.625,86.25,84.375,84.625,53058400,7.139288
1997-01-14,84.25,86.625,84.25,85.375,63728000,7.202561
1997-01-13,85.125,85.50,83.50,83.75,50361600,7.06547
1997-01-10,82.00,84.375,81.625,84.25,66556800,7.107652
1997-01-09,83.75,83.75,82.25,82.375,47763200,6.94947
1997-01-08,85.00,85.234299,83.125,83.375,50593600,7.033833
1997-01-07,84.50,85.125,83.375,85.00,36880800,7.170925
1997-01-06,84.625,85.25,83.125,84.375,55948000,7.118197
1997-01-03,82.25,84.75,82.00,84.625,44131200,7.139288
1997-01-02,83.125,83.125,80.75,81.625,54480800,6.886197
1996-12-31,84.00,84.25,82.50,82.625,34367200,6.97056
1996-12-30,85.375,85.625,83.50,83.50,27279200,7.044379
1996-12-27,85.50,85.75,84.015602,84.25,19079200,7.107652
1996-12-26,85.25,86.125,85.125,85.50,27905600,7.213106
1996-12-24,84.125,85.125,83.125,84.875,16246400,7.160379
1996-12-23,84.125,84.75,82.875,83.75,36892800,7.06547
1996-12-20,85.50,85.625,83.375,83.625,90414400,7.054924
1996-12-19,84.00,85.125,83.00,84.875,94609600,7.160379
1996-12-18,81.375,82.75,80.00,82.625,61796800,6.97056
1996-12-17,76.625,80.125,76.375,79.875,68944800,6.73856
1996-12-16,80.25,80.75,76.50,76.75,64883200,6.474923
1996-12-13,81.125,82.00,79.234299,80.00,74532000,6.749105
1996-12-12,85.00,85.25,81.00,81.00,78272800,6.833469
1996-12-11,81.00,83.625,80.125,83.375,113558400,7.033833
1996-12-10,84.375,84.5625,81.75,81.875,125725600,6.907288
1996-12-09,78.375,81.875,78.00,81.75,94718400,6.896742
1996-12-06,149.00,154.50,148.265594,152.875,110238400,6.448559
1996-12-05,153.375,155.375,151.875,153.00,74950400,6.453832
1996-12-04,155.125,155.25,152.125,153.25,102542400,6.464378
1996-12-03,158.375,159.50,154.625,154.6875,77563200,6.525014
1996-12-02,157.50,157.75,155.25,157.75,64502400,6.654196
1996-11-29,155.50,157.125,155.50,156.875,17152000,6.617287
1996-11-27,154.125,155.75,153.75,155.50,44446400,6.559287
1996-11-26,154.00,155.375,152.375,153.75,108238400,6.485469
1996-11-25,151.125,153.625,150.50,153.50,75129600,6.474923
1996-11-22,150.75,152.50,149.375,150.50,94424000,6.348377
1996-11-21,154.50,154.625,150.00,150.375,130718400,6.343105
1996-11-20,156.00,158.00,153.25,153.25,123857600,6.464378
1996-11-19,150.50,155.875,150.25,155.875,104739200,6.575105
1996-11-18,149.375,151.75,148.625,150.375,98585600,6.343105
1996-11-15,150.75,150.875,147.375,149.00,104041600,6.285104
1996-11-14,145.25,149.625,145.25,149.625,114969600,6.311468
1996-11-13,143.625,145.75,143.125,145.00,90409600,6.116377
1996-11-12,144.00,145.875,141.50,141.75,81156800,5.979286
1996-11-11,143.375,144.75,143.00,143.625,38593600,6.058377
1996-11-08,143.375,143.50,141.50,143.50,67369600,6.053104
1996-11-07,144.75,146.125,143.125,143.50,76742400,6.053104
1996-11-06,141.375,144.50,141.00,144.50,71438400,6.095286
1996-11-05,138.50,141.50,138.3125,141.50,86417600,5.96874
1996-11-04,137.25,138.375,136.75,138.00,36006400,5.821103
1996-11-01,137.25,138.75,136.50,137.375,56531200,5.79474
1996-10-31,136.375,137.375,136.125,137.25,37028800,5.789467
1996-10-30,135.375,137.00,134.875,136.25,60526400,5.747285
1996-10-29,136.875,137.375,134.875,135.375,66756800,5.710376
1996-10-28,136.6875,137.625,136.25,136.625,51240000,5.763103
1996-10-25,136.625,137.875,136.125,136.4375,53084800,5.755194
1996-10-24,134.875,137.375,133.875,136.625,81417600,5.763103
1996-10-23,132.625,134.75,131.75,134.50,67443200,5.673467
1996-10-22,133.125,133.375,131.25,132.50,113806400,5.589103
1996-10-21,134.75,136.00,133.50,134.00,71401600,5.652376
1996-10-18,134.00,135.00,133.5625,134.75,69646400,5.684012
1996-10-17,138.25,139.00,135.50,135.50,49097600,5.715649
1996-10-16,138.75,138.9375,137.00,138.00,36427200,5.821103
1996-10-15,138.75,139.125,137.375,138.875,61206400,5.858013
1996-10-14,137.375,138.125,136.375,136.625,36091200,5.763103
1996-10-11,134.625,137.25,134.25,137.125,36523200,5.784194
1996-10-10,133.75,136.125,133.375,133.75,51739200,5.64183
1996-10-09,136.00,136.125,133.25,134.50,64955200,5.673467
1996-10-08,137.75,137.75,135.00,135.375,48465600,5.710376
1996-10-07,136.375,138.125,135.875,137.50,42432000,5.800012
1996-10-04,134.625,136.625,134.25,136.375,45166400,5.752558
1996-10-03,134.75,135.125,133.625,134.00,58294400,5.652376
1996-10-02,132.875,135.75,132.375,134.75,68760000,5.684012
1996-10-01,131.75,133.875,130.875,132.125,69124800,5.573285
1996-09-30,133.50,134.875,131.75,131.875,89574400,5.562739
1996-09-27,132.50,135.25,131.25,134.375,98372800,5.668194
1996-09-26,135.75,136.125,131.75,132.00,92604800,5.568012
1996-09-25,137.50,137.875,135.375,135.625,44067200,5.720921
1996-09-24,137.50,138.375,136.125,136.875,72520000,5.773649
1996-09-23,137.625,138.125,136.25,137.75,46385600,5.810558
1996-09-20,137.00,138.625,135.875,138.125,104849600,5.826376
1996-09-19,136.50,138.25,135.75,137.75,75912000,5.810558
1996-09-18,134.00,137.875,133.25,136.50,86049600,5.757831
1996-09-17,132.875,134.625,132.25,133.875,75624000,5.647103
1996-09-16,131.125,133.125,131.00,131.50,62409600,5.546921
1996-09-13,129.625,131.375,128.875,131.00,80137600,5.52583
1996-09-12,125.50,129.50,125.1875,128.625,95944000,5.425648
1996-09-11,123.9375,125.50,123.625,125.125,36387200,5.278011
1996-09-10,124.75,125.125,123.625,124.375,38904000,5.246375
1996-09-09,122.50,125.00,122.25,124.875,41747200,5.267466
1996-09-06,122.00,122.75,121.625,122.50,41921600,5.167284
1996-09-05,122.75,122.75,121.50,121.50,40372800,5.125102
1996-09-04,123.375,123.625,122.9375,123.375,27126400,5.204193
1996-09-03,122.00,123.375,120.625,123.375,48524800,5.204193
1996-08-30,124.25,124.25,122.50,122.50,28088000,5.167284
1996-08-29,125.25,125.25,123.625,124.125,34182400,5.235829
1996-08-28,125.00,125.75,124.875,125.625,32070400,5.299102
1996-08-27,123.125,124.75,123.00,124.75,28038400,5.262193
1996-08-26,123.375,123.75,122.75,122.875,31944000,5.183102
1996-08-23,124.875,125.00,123.25,123.25,44006400,5.19892
1996-08-22,124.125,125.125,123.50,125.00,50236800,5.272739
1996-08-21,122.50,123.50,121.75,123.50,49345600,5.209466
1996-08-20,123.75,124.125,123.25,123.375,25678400,5.204193
1996-08-19,123.875,124.125,122.25,123.50,43131200,5.209466
1996-08-16,125.125,125.25,123.75,124.25,47598400,5.241102
1996-08-15,124.75,125.75,124.375,125.125,35556800,5.278011
1996-08-14,123.875,125.125,123.75,124.875,52032000,5.267466
1996-08-13,125.00,125.875,123.375,123.50,72508800,5.209466
1996-08-12,124.25,126.125,124.00,125.25,66187200,5.283284
1996-08-09,124.75,125.50,123.875,124.50,44313600,5.251648
1996-08-08,124.125,125.875,123.75,125.25,54379200,5.283284
1996-08-07,124.375,125.125,122.875,124.75,76790400,5.262193
1996-08-06,121.625,124.125,120.875,124.00,67388800,5.230557
1996-08-05,123.50,123.75,121.25,121.75,55072000,5.135647
1996-08-02,122.125,123.875,120.625,123.375,109289600,5.204193
1996-08-01,117.875,120.875,117.375,120.625,96025600,5.088193
1996-07-31,119.00,119.625,117.625,117.875,56320000,4.972193
1996-07-30,117.875,118.75,116.125,118.625,66976000,5.003829
1996-07-29,119.25,119.875,116.75,116.875,56748800,4.930011
1996-07-26,119.50,119.50,118.25,119.125,59304000,5.02492
1996-07-25,116.00,118.75,115.125,118.50,100920000,4.998556
1996-07-24,109.50,115.75,109.50,114.75,192225600,4.840374
1996-07-23,120.00,120.00,110.25,112.125,257678400,4.729647
1996-07-22,121.015602,121.50,117.875,119.75,144475200,5.051284
1996-07-19,117.75,121.625,117.75,120.984299,99208000,5.103349
1996-07-18,117.25,120.00,115.875,119.875,98537600,5.056556
1996-07-17,117.75,118.125,115.625,117.125,126208000,4.940556
1996-07-16,110.25,115.625,107.50,115.375,182100800,4.866738
1996-07-15,112.375,113.75,109.875,110.625,111832000,4.666374
1996-07-12,115.1875,115.1875,110.484299,112.375,139478400,4.740192
1996-07-11,118.25,118.375,113.75,114.50,140915200,4.829829
1996-07-10,120.00,120.00,118.125,119.50,77980800,5.040738
1996-07-09,120.875,121.375,120.00,120.00,35571200,5.061829
1996-07-08,118.50,120.75,118.125,120.3125,64432000,5.075011
1996-07-05,120.125,120.125,118.375,118.375,35331200,4.993283
1996-07-03,121.625,122.875,120.625,121.125,44243200,5.109284
1996-07-02,122.375,122.625,121.25,121.625,38548800,5.130375
1996-07-01,120.25,122.50,120.125,122.3125,47862400,5.159375
1996-06-28,120.50,121.00,119.125,120.125,52000000,5.067102
1996-06-27,120.50,121.00,119.00,119.9375,77582400,5.059193
1996-06-26,121.875,122.00,119.00,120.50,71457600,5.08292
1996-06-25,124.25,124.25,121.375,122.00,41145600,5.146193
1996-06-24,124.00,125.125,123.00,124.125,48102400,5.235829
1996-06-21,122.375,124.125,121.50,123.875,56806400,5.225284
1996-06-20,122.00,122.484299,119.00,121.75,102228800,5.135647
1996-06-19,122.50,123.125,121.375,121.75,73409600,5.135647
1996-06-18,124.50,124.50,122.00,122.375,74585600,5.162011
1996-06-17,123.125,125.00,122.375,124.625,57499200,5.25692
1996-06-14,124.75,125.00,122.875,123.00,55944000,5.188375
1996-06-13,125.125,125.875,123.75,124.625,62577600,5.25692
1996-06-12,122.875,125.375,122.75,125.00,88844800,5.272739
1996-06-11,120.75,123.25,120.625,122.125,65259200,5.151466
1996-06-10,121.00,121.25,119.984299,120.625,45819200,5.088193
1996-06-07,117.625,121.25,117.625,121.25,70198400,5.114556
1996-06-06,121.75,123.00,119.75,119.8125,88136000,5.05392
1996-06-05,118.00,121.25,117.875,120.875,50968000,5.098738
1996-06-04,118.625,118.875,116.25,117.875,65852800,4.972193
1996-06-03,118.75,119.50,118.125,118.375,31684800,4.993283
1996-05-31,118.5625,119.375,118.00,118.75,40259200,5.009102
1996-05-30,117.25,118.25,116.625,118.25,33824000,4.988011
1996-05-29,117.375,118.25,116.625,117.125,33569600,4.940556
1996-05-28,118.75,119.140602,117.125,117.25,43376000,4.945829
1996-05-24,118.50,119.00,118.25,118.50,26443200,4.998556
1996-05-23,116.875,119.125,116.875,118.50,51976000,4.998556
1996-05-22,115.00,117.25,114.625,116.875,45646400,4.930011
1996-05-21,116.75,116.875,115.125,115.125,42113600,4.856192
1996-05-20,117.375,117.875,116.625,116.75,38457600,4.924738
1996-05-17,117.875,118.00,116.375,117.00,35392000,4.935283
1996-05-16,116.00,117.375,115.625,117.125,67092800,4.940556
1996-05-15,119.00,119.75,117.375,117.625,56323200,4.961647
1996-05-14,119.25,120.00,118.234299,119.00,76832000,5.019647
1996-05-13,115.00,118.875,115.00,118.625,95606400,5.003829
1996-05-10,114.375,115.140602,114.125,114.875,43913600,4.845647
1996-05-09,114.25,115.125,113.25,113.50,47776000,4.787647
1996-05-08,112.875,114.375,110.75,114.25,77851200,4.819283
1996-05-07,111.625,113.50,111.625,113.125,47366400,4.771828
1996-05-06,111.00,112.375,109.625,111.75,75852800,4.713828
1996-05-03,112.50,114.50,110.125,110.875,75300800,4.676919
1996-05-02,115.125,115.25,111.125,111.625,87340800,4.708556
1996-05-01,112.875,115.25,112.625,115.125,65014400,4.856192
1996-04-30,112.625,113.25,111.875,113.25,28441600,4.777101
1996-04-29,113.375,113.50,112.00,112.625,34267200,4.750738
1996-04-26,112.75,113.875,112.375,113.50,54296000,4.787647
1996-04-25,111.50,113.75,110.25,112.75,63896000,4.75601
1996-04-24,113.00,113.125,111.25,111.50,69251200,4.703283
1996-04-23,112.75,113.25,111.375,112.625,57139200,4.750738
1996-04-22,110.50,113.375,110.25,112.75,92758400,4.75601
1996-04-19,111.625,112.125,109.50,109.75,169492800,4.629465
1996-04-18,106.00,109.25,105.50,109.00,133958400,4.597828
1996-04-17,105.25,106.00,104.3125,105.9375,62630400,4.468646
1996-04-16,104.25,105.50,104.00,105.25,80116800,4.439646
1996-04-15,101.00,103.625,101.00,103.515602,50102400,4.366486
1996-04-12,101.125,101.625,100.50,101.125,33737600,4.265646
1996-04-11,101.50,102.375,99.625,101.125,62465600,4.265646
1996-04-10,101.50,103.00,101.25,101.625,51910400,4.286737
1996-04-09,104.00,104.00,101.50,101.625,66942400,4.286737
1996-04-08,102.50,103.875,101.875,103.75,73753600,4.376373
1996-04-04,104.625,104.875,103.50,104.375,28961600,4.402737
1996-04-03,104.125,105.125,103.375,104.50,46072000,4.408009
1996-04-02,102.75,105.00,102.625,104.625,54396800,4.413282
1996-04-01,103.140602,103.50,102.125,102.75,31692800,4.334191
1996-03-29,102.375,104.125,102.125,103.125,53508800,4.350009
1996-03-28,101.875,103.50,101.125,102.25,54955200,4.3131
1996-03-27,103.25,104.00,101.125,102.50,52729600,4.323646
1996-03-26,99.375,102.875,98.75,102.75,79899200,4.334191
1996-03-25,101.50,102.375,98.8125,99.875,63379200,4.212918
1996-03-22,101.125,101.4375,99.75,101.125,48046400,4.265646
1996-03-21,104.25,104.375,100.50,100.75,66313600,4.249827
1996-03-20,106.25,106.625,103.734299,104.625,92944000,4.413282
1996-03-19,106.375,107.0625,104.75,106.875,92491200,4.508192
1996-03-18,102.375,105.875,102.375,105.25,119472000,4.439646
1996-03-15,100.00,103.125,99.625,102.375,121721600,4.318373
1996-03-14,101.125,101.875,99.625,99.625,60640000,4.202373
1996-03-13,98.234299,101.00,97.75,100.875,156710400,4.2551
1996-03-12,96.25,96.625,94.75,95.75,76888000,4.038918
1996-03-11,95.125,96.625,95.125,96.50,74592000,4.070554
1996-03-08,95.50,97.50,94.75,95.125,108524800,4.012554
1996-03-07,97.125,97.625,96.625,97.3125,44291200,4.104827
1996-03-06,98.25,98.875,97.00,97.00,44256000,4.091645
1996-03-05,96.00,98.265602,95.75,98.125,57369600,4.1391
1996-03-04,96.00,97.375,95.50,96.25,72564800,4.060009
1996-03-01,98.375,98.625,94.625,95.50,157652800,4.028372
1996-02-29,99.00,100.125,98.5625,98.6875,61723200,4.162827
1996-02-28,100.75,102.00,99.875,100.125,60051200,4.223464
1996-02-27,100.75,100.8125,99.734299,100.125,60958400,4.223464
1996-02-26,103.00,103.25,100.50,100.625,63696000,4.244555
1996-02-23,102.625,103.625,101.875,103.50,102640000,4.365828
1996-02-22,100.00,102.625,100.00,102.50,106500800,4.323646
1996-02-21,97.75,100.125,97.50,99.875,80046400,4.212918
1996-02-20,97.25,98.50,96.875,97.75,64182400,4.123282
1996-02-16,98.75,99.25,97.875,97.875,62206400,4.128554
1996-02-15,98.50,99.125,97.75,98.50,52195200,4.154918
1996-02-14,100.125,100.125,98.375,98.75,80212800,4.165464
1996-02-13,97.75,100.25,97.50,99.625,114513600,4.202373
1996-02-12,99.75,101.125,99.125,99.50,87779200,4.1971
1996-02-09,98.75,100.25,98.50,100.125,122832000,4.223464
1996-02-08,96.625,99.50,95.50,98.875,103924800,4.170736
1996-02-07,96.00,97.125,95.484299,96.875,65555200,4.086372
1996-02-06,96.50,97.50,95.625,96.50,98158400,4.070554
1996-02-05,92.75,97.25,92.75,97.125,126480000,4.096918
1996-02-02,94.00,94.125,92.125,93.00,44686400,3.922918
1996-02-01,92.25,94.25,92.00,94.125,78587200,3.970372
1996-01-31,90.75,92.625,90.125,92.50,68774400,3.901827
1996-01-30,90.875,91.375,90.625,90.8125,45120000,3.830645
1996-01-29,90.75,91.25,89.359299,90.375,39587200,3.81219
1996-01-26,89.125,90.875,89.00,90.50,50881600,3.817463
1996-01-25,91.375,91.625,89.00,89.375,59881600,3.770008
1996-01-24,89.875,92.50,89.50,91.25,92217600,3.849099
1996-01-23,91.375,91.75,89.25,89.50,66473600,3.775281
1996-01-22,91.625,92.75,90.875,92.00,82643200,3.880736
1996-01-19,90.25,93.25,89.625,91.875,227440000,3.875463
1996-01-18,85.50,88.875,85.00,87.625,121331200,3.69619
1996-01-17,84.75,87.50,84.625,84.875,143078400,3.58019
1996-01-16,83.625,86.484299,83.25,86.375,122006400,3.643462
1996-01-15,85.875,85.875,81.875,82.50,84572800,3.480007
1996-01-12,86.50,86.875,83.875,85.75,80544000,3.617099
1996-01-11,83.50,86.875,83.125,86.625,116617600,3.654008
1996-01-10,80.50,83.25,80.484299,82.375,181571200,3.474735
1996-01-09,86.00,86.00,79.875,80.1875,177424000,3.382462
1996-01-08,86.50,87.625,86.125,86.25,11377600,3.63819
1996-01-05,86.25,87.625,86.125,86.375,62083200,3.643462
1996-01-04,87.25,87.50,84.875,87.375,102353600,3.685644
1996-01-03,89.125,90.125,86.75,86.875,62857600,3.664553
1996-01-02,87.875,89.75,87.375,89.75,57779200,3.785826
1995-12-29,87.25,88.75,86.25,87.75,52342400,3.701463
1995-12-28,88.25,88.50,87.25,87.375,49777600,3.685644
1995-12-27,90.375,90.625,88.375,88.875,40539200,3.748917
1995-12-26,90.25,91.25,89.875,90.25,34707200,3.806917
1995-12-22,90.125,90.875,89.125,90.50,36057600,3.817463
1995-12-21,87.75,90.00,87.375,90.00,60593600,3.796372
1995-12-20,91.125,91.375,87.00,87.125,84980800,3.675099
1995-12-19,87.375,91.015602,87.375,90.875,84340800,3.833281
1995-12-18,88.375,89.00,85.375,87.00,99460800,3.669826
1995-12-15,89.125,89.75,87.25,88.375,115470400,3.727826
1995-12-14,92.25,93.50,88.625,88.75,92822400,3.743644
1995-12-13,91.125,92.125,90.50,91.75,39577600,3.87019
1995-12-12,93.00,93.125,91.125,91.375,44739200,3.854372
1995-12-11,94.50,94.75,93.00,93.125,61924800,3.92819
1995-12-08,92.625,94.625,92.234299,94.50,147041600,3.98619
1995-12-07,91.125,92.00,88.859299,90.50,132876800,3.817463
1995-12-06,86.125,91.00,86.00,90.625,145272000,3.822736
1995-12-05,87.875,88.125,85.125,86.00,104528000,3.627644
1995-12-04,86.125,89.625,85.25,87.875,130436800,3.706735
1995-12-01,87.125,87.875,85.875,86.25,96124800,3.63819
1995-11-30,89.50,89.75,86.875,87.125,93512000,3.675099
1995-11-29,91.875,92.50,89.25,89.75,91067200,3.785826
1995-11-28,87.00,91.50,86.50,91.50,86537600,3.859645
1995-11-27,88.625,89.50,87.140602,87.25,79100800,3.680372
1995-11-24,87.625,88.25,87.375,88.00,15014400,3.712008
1995-11-22,88.375,89.50,87.25,87.375,65428800,3.685644
1995-11-21,85.875,88.75,84.25,88.00,130163200,3.712008
1995-11-20,88.375,89.375,85.75,86.00,115296000,3.627644
1995-11-17,90.00,90.625,87.375,87.375,143803200,3.685644
1995-11-16,90.50,91.843697,89.625,89.875,195126400,3.791099
1995-11-15,94.375,94.625,91.875,94.00,108686400,3.965099
1995-11-14,95.875,96.00,93.875,94.00,75657600,3.965099
1995-11-13,96.625,97.25,96.0625,96.3125,59003200,4.062645
1995-11-10,98.50,99.00,96.609299,96.875,60819200,4.086372
1995-11-09,96.50,99.015602,96.00,99.00,99814400,4.176009
1995-11-08,93.875,95.50,93.375,95.25,71280000,4.017827
1995-11-07,96.50,97.375,92.875,93.00,115921600,3.922918
1995-11-06,97.00,98.875,96.875,97.375,87729600,4.107463
1995-11-03,100.00,100.125,98.75,99.50,40635200,4.1971
1995-11-02,98.625,100.375,98.25,100.00,63504000,4.218191
1995-11-01,100.125,101.00,98.25,98.375,72819200,4.149645
1995-10-31,103.00,103.375,99.75,100.00,91958400,4.218191
1995-10-30,99.25,103.375,98.50,102.75,125464000,4.334191
1995-10-27,97.50,100.140602,97.375,100.00,130683200,4.218191
1995-10-26,95.75,98.125,95.375,98.00,82841600,4.133827
1995-10-25,97.625,97.75,95.875,95.875,60211200,4.044191
1995-10-24,96.375,98.125,96.375,97.50,68681600,4.112736
1995-10-23,95.00,97.125,94.50,96.375,93473600,4.065281
1995-10-20,96.50,96.875,94.875,95.50,79984000,4.028372
1995-10-19,95.25,97.00,94.75,96.75,95840000,4.0811
1995-10-18,98.25,98.625,94.875,95.625,294329600,4.033645
1995-10-17,87.25,91.50,86.75,91.125,123140800,3.843826
1995-10-16,85.75,87.375,85.50,86.75,61067200,3.659281
1995-10-13,88.50,88.75,86.00,86.25,68644800,3.63819
1995-10-12,87.00,88.125,86.625,87.625,78700800,3.69619
1995-10-11,85.875,87.375,85.00,86.625,107009600,3.654008
1995-10-10,81.25,84.125,80.375,83.75,157644800,3.532735
1995-10-09,84.875,85.75,82.75,83.125,108614400,3.506371
1995-10-06,87.50,89.00,85.50,85.875,76616000,3.622371
1995-10-05,86.00,87.50,85.00,87.50,101289600,3.690917
1995-10-04,88.125,88.125,85.50,86.125,73473600,3.632917
1995-10-03,88.125,89.25,87.25,88.875,80736000,3.748917
1995-10-02,90.50,90.875,88.125,88.25,67731200,3.722553
1995-09-29,91.625,92.75,90.0625,90.50,95158400,3.817463
1995-09-28,89.00,91.50,88.875,91.50,105510400,3.859645
1995-09-27,88.00,88.75,83.375,88.625,140756800,3.738372
1995-09-26,90.375,91.875,88.125,88.25,76548800,3.722553
1995-09-25,90.50,90.625,88.50,90.234299,57878400,3.806255
1995-09-22,89.875,90.75,89.00,89.75,99899200,3.785826
1995-09-21,91.25,93.0625,90.50,90.625,83836800,3.822736
1995-09-20,93.50,94.625,92.625,93.125,44652800,3.92819
1995-09-19,92.00,94.50,91.50,93.3125,58011200,3.936099
1995-09-18,93.25,93.375,90.875,92.00,76827200,3.880736
1995-09-15,94.75,95.375,92.50,93.4375,88316800,3.941372
1995-09-14,96.125,96.50,94.75,94.875,54230400,4.002009
1995-09-13,96.125,97.00,95.125,96.125,61208000,4.054736
1995-09-12,97.75,97.75,95.625,96.25,71155200,4.060009
1995-09-11,95.375,97.875,95.00,97.625,77408000,4.118009
1995-09-08,93.75,95.625,93.25,95.50,64417600,4.028372
1995-09-07,94.25,96.625,93.25,94.625,93932800,3.991463
1995-09-06,95.25,96.50,93.00,93.50,100265600,3.944008
1995-09-05,90.875,95.125,90.25,95.00,92052800,4.007281
1995-09-01,91.75,92.00,89.375,89.75,80262400,3.785826
1995-08-31,93.375,94.00,91.50,92.50,38764800,3.901827
1995-08-30,92.875,93.75,91.50,93.25,79499200,3.933463
1995-08-29,90.125,91.875,87.00,91.875,163929600,3.875463
1995-08-28,94.375,94.375,89.875,90.0625,112622400,3.799008
1995-08-25,96.375,96.75,94.375,94.375,73489600,3.980918
1995-08-24,98.125,98.125,95.50,96.125,95275200,4.054736
1995-08-23,100.00,100.50,97.50,97.875,111188800,4.128554
1995-08-22,95.125,99.375,94.375,99.3125,94320000,4.189191
1995-08-21,97.50,98.25,94.375,94.50,110491200,3.98619
1995-08-18,99.6875,99.75,97.00,97.125,77502400,4.096918
1995-08-17,98.875,100.75,98.640602,99.125,74564800,4.181282
1995-08-16,98.375,98.875,97.125,98.75,38118400,4.165464
1995-08-15,99.25,99.375,96.875,98.375,63267200,4.149645
1995-08-14,96.875,99.25,95.75,98.75,88872000,4.165464
1995-08-11,94.75,96.625,92.125,96.50,97195200,4.070554
1995-08-10,97.00,97.125,93.875,94.125,71883200,3.970372
1995-08-09,97.75,98.125,96.00,96.50,144384000,4.070554
1995-08-08,94.125,94.875,93.375,93.50,43913600,3.944008
1995-08-07,94.50,95.50,91.75,93.625,64273600,3.949281
1995-08-04,91.375,93.875,91.25,93.875,77705600,3.959827
1995-08-03,88.00,91.375,87.50,91.125,113536000,3.843826
1995-08-02,91.00,92.625,88.00,89.00,129804800,3.75419
1995-08-01,90.75,90.890602,87.875,89.50,166144000,3.775281
1995-07-31,93.125,93.50,90.00,90.50,101435200,3.817463
1995-07-28,96.00,96.00,92.00,92.625,158468800,3.907099
1995-07-27,96.50,97.625,96.25,96.50,52916800,4.070554
1995-07-26,97.625,98.125,94.875,96.00,77470400,4.049463
1995-07-25,95.50,97.625,95.00,96.375,109422400,4.065281
1995-07-24,92.625,93.75,92.125,93.625,94811200,3.949281
1995-07-21,94.00,96.00,91.75,92.00,169257600,3.880736
1995-07-20,95.25,97.375,94.00,96.125,177848000,4.054736
1995-07-19,97.00,98.75,88.50,94.50,305092800,3.98619
1995-07-18,107.00,107.125,101.25,101.875,289624000,4.297282
1995-07-17,107.75,109.25,106.50,109.00,155830400,4.597828
1995-07-14,98.25,103.625,98.00,103.625,89905600,4.3711
1995-07-13,100.125,101.50,98.125,100.125,84811200,4.223464
1995-07-12,96.75,100.00,96.75,99.875,94675200,4.212918
1995-07-11,99.00,99.125,96.50,96.50,78227200,4.070554
1995-07-10,96.00,99.75,95.75,98.875,111982400,4.170736
1995-07-07,92.875,95.625,92.75,95.625,66699200,4.033645
1995-07-06,90.625,93.00,90.375,92.75,47070400,3.912372
1995-07-05,91.625,92.00,90.375,90.6875,48547200,3.825372
1995-07-03,90.875,91.125,90.375,90.9375,16763200,3.835917
1995-06-30,89.625,91.00,89.625,90.375,53342400,3.81219
1995-06-29,88.00,89.75,88.00,89.375,57643200,3.770008
1995-06-28,86.75,89.00,84.875,87.875,107286400,3.706735
1995-06-27,89.50,90.50,86.75,86.875,66004800,3.664553
1995-06-26,91.00,91.125,89.50,89.75,41048000,3.785826
1995-06-23,90.75,92.1875,90.25,91.125,46356800,3.843826
1995-06-22,90.625,92.00,90.625,91.875,46296000,3.875463
1995-06-21,91.875,92.375,90.00,90.50,57224000,3.817463
1995-06-20,90.375,91.375,89.75,91.375,56670400,3.854372
1995-06-19,87.25,89.890602,86.875,89.8125,78982400,3.788463
1995-06-16,85.00,87.50,84.875,87.00,92278400,3.669826
1995-06-15,84.00,85.00,83.875,84.875,43912000,3.58019
1995-06-14,83.375,84.125,82.75,83.8125,43096000,3.535371
1995-06-13,84.125,84.75,83.375,83.875,37691200,3.538008
1995-06-12,84.625,84.75,83.25,83.75,45832000,3.532735
1995-06-09,83.75,85.875,82.625,84.875,81214400,3.58019
1995-06-08,84.125,84.625,83.625,84.125,29320000,3.548553
1995-06-07,82.875,84.75,82.125,84.00,64590400,3.54328
1995-06-06,84.875,86.015602,83.125,83.125,49036800,3.506371
1995-06-05,82.625,85.375,81.75,84.75,55852800,3.574917
1995-06-02,83.75,84.125,82.625,83.125,55556800,3.506371
1995-06-01,85.00,85.625,83.875,84.125,61153600,3.548553
1995-05-31,83.25,84.75,81.00,84.6875,119756800,3.57228
1995-05-30,88.00,88.375,82.625,83.00,99612800,3.501098
1995-05-26,89.1875,89.25,87.00,87.50,52934400,3.690917
1995-05-25,87.875,89.375,87.125,89.25,43440000,3.764735
1995-05-24,89.125,89.50,87.00,87.50,68684800,3.690917
1995-05-23,87.50,88.50,86.031197,88.50,55516800,3.733099
1995-05-22,85.375,87.50,84.00,87.25,91382400,3.680372
1995-05-19,84.25,85.50,84.00,85.375,45190400,3.60128
1995-05-18,85.625,86.75,84.625,84.625,58326400,3.569644
1995-05-17,85.25,86.875,85.125,86.00,66515200,3.627644
1995-05-16,81.50,85.015602,81.50,84.875,86708800,3.58019
1995-05-15,80.625,82.00,79.875,81.3125,35232000,3.429916
1995-05-12,81.375,82.25,80.375,80.75,36192000,3.406189
1995-05-11,79.125,81.50,79.00,81.375,38673600,3.432553
1995-05-10,80.125,80.375,78.875,79.25,38688000,3.342916
1995-05-09,80.00,80.375,79.125,79.8125,36748800,3.366644
1995-05-08,79.875,80.375,79.125,79.875,43988800,3.36928
1995-05-05,81.375,81.625,79.875,80.00,43707200,3.374553
1995-05-04,81.50,83.25,81.00,81.50,66524800,3.437826
1995-05-03,80.25,81.00,80.25,80.875,61566400,3.411462
1995-05-02,82.125,82.25,79.50,79.5625,78099200,3.356098
1995-05-01,81.875,83.75,81.75,82.125,65550400,3.464189
1995-04-28,78.875,82.125,78.625,81.75,92104000,3.448371
1995-04-27,79.625,80.50,76.375,78.625,128844800,3.316553
1995-04-26,79.75,80.25,79.125,79.625,44305600,3.358735
1995-04-25,77.625,80.125,77.625,80.00,69371200,3.374553
1995-04-24,75.375,77.765602,75.125,77.75,68089600,3.279643
1995-04-21,75.625,75.875,74.875,75.00,53555200,3.163643
1995-04-20,76.50,76.875,74.00,75.25,83913600,3.174189
1995-04-19,76.625,77.00,75.50,76.125,59163200,3.211098
1995-04-18,77.375,77.50,76.00,76.75,75609600,3.237462
1995-04-17,75.50,78.125,75.50,77.375,187913600,3.263825
1995-04-13,71.75,72.50,71.125,72.50,32814400,3.058188
1995-04-12,72.125,73.25,70.75,71.625,40430400,3.021279
1995-04-11,71.625,72.140602,71.125,72.125,43624000,3.04237
1995-04-10,69.50,71.25,69.375,70.9375,43169600,2.992279
1995-04-07,70.25,70.75,69.50,69.625,43148800,2.936915
1995-04-06,70.625,70.875,69.4375,70.00,35414400,2.952734
1995-04-05,69.875,70.625,68.75,70.625,65792000,2.979097
1995-04-04,70.25,71.50,69.75,69.875,66689600,2.947461
1995-04-03,71.00,71.375,69.50,70.00,65617600,2.952734
1995-03-31,71.75,72.125,70.50,71.125,63080000,3.000188
1995-03-30,72.50,72.75,70.375,72.125,75011200,3.04237
1995-03-29,73.625,74.00,72.0625,72.25,65763200,3.047643
1995-03-28,72.875,74.00,72.875,73.625,47603200,3.105643
1995-03-27,72.75,73.875,72.625,73.00,61008000,3.079279
1995-03-24,73.25,74.125,73.125,73.875,65683200,3.116189
1995-03-23,71.375,73.25,71.25,72.75,105286400,3.068734
1995-03-22,70.50,71.00,69.875,70.9375,52464000,2.992279
1995-03-21,71.25,71.50,70.375,70.4375,74772800,2.971188
1995-03-20,70.125,71.50,70.00,71.125,37772800,3.000188
1995-03-17,70.50,71.75,69.875,69.9375,59868800,2.950097
1995-03-16,70.00,70.50,69.625,70.125,47510400,2.958006
1995-03-15,71.75,71.875,70.375,70.50,57294400,2.973825
1995-03-14,69.375,72.00,69.25,71.75,78643200,3.026552
1995-03-13,68.625,69.6875,68.25,69.00,34550400,2.910552
1995-03-10,67.875,68.75,66.50,68.5625,44324800,2.892097
1995-03-09,68.50,68.75,66.875,67.875,58238400,2.863097
1995-03-08,65.75,68.625,65.75,68.50,140096000,2.889461
1995-03-07,64.375,66.015602,64.25,65.343697,91750400,2.756322
1995-03-06,63.25,64.375,62.875,64.3125,45156800,2.712824
1995-03-03,63.625,63.875,63.125,63.625,31776000,2.683824
1995-03-02,63.25,63.75,63.125,63.75,26038400,2.689097
1995-03-01,63.125,64.00,62.75,63.25,52032000,2.668006
1995-02-28,61.875,63.25,61.75,63.00,52544000,2.65746
1995-02-27,61.375,62.00,61.125,61.75,28592000,2.604733
1995-02-24,61.375,61.875,61.25,61.25,34177600,2.583642
1995-02-23,61.25,62.125,61.00,61.625,59939200,2.59946
1995-02-22,59.75,62.00,59.625,61.50,60902400,2.594187
1995-02-21,60.50,60.75,59.50,59.75,55392000,2.520369
1995-02-17,60.75,60.875,60.25,60.375,37824000,2.546733
1995-02-16,60.875,61.125,60.25,60.875,56744000,2.567824
1995-02-15,60.125,61.375,59.625,60.75,147001600,2.562551
1995-02-14,62.125,62.25,61.50,61.875,31121600,2.610006
1995-02-13,62.00,62.75,61.625,62.00,38160000,2.615278
1995-02-10,62.00,62.625,61.50,62.00,49862400,2.615278
1995-02-09,62.125,62.50,61.75,61.875,42398400,2.610006
1995-02-08,61.25,62.00,61.00,61.875,49150400,2.610006
1995-02-07,60.75,61.125,60.625,61.00,33152000,2.573096
1995-02-06,60.125,61.125,60.125,60.875,48345600,2.567824
1995-02-03,59.50,60.50,59.25,60.125,60332800,2.536187
1995-02-02,58.75,59.375,58.375,59.00,46312000,2.488733
1995-02-01,59.375,60.75,58.984299,59.125,66705600,2.494005
1995-01-31,59.125,59.75,58.25,59.375,59945600,2.504551
1995-01-30,60.125,60.125,58.875,59.00,55164800,2.488733
1995-01-27,60.125,60.25,59.75,59.875,58376000,2.525642
1995-01-26,60.875,61.00,59.75,59.875,80836800,2.525642
1995-01-25,61.625,62.25,61.00,61.75,52459200,2.604733
1995-01-24,63.00,63.125,62.00,62.015598,36739200,2.615936
1995-01-23,61.00,63.00,60.50,62.8125,53843200,2.649551
1995-01-20,62.875,63.50,61.25,61.625,82388800,2.59946
1995-01-19,64.50,65.00,63.4375,63.50,67108800,2.678551
1995-01-18,64.875,65.25,64.25,65.0625,50504000,2.74446
1995-01-17,64.75,65.125,64.375,64.625,73932800,2.726006
1995-01-16,63.25,64.50,63.00,64.125,74648000,2.704915
1995-01-13,62.00,63.00,61.875,62.75,41307200,2.646915
1995-01-12,61.25,62.125,61.00,61.25,26996800,2.583642
1995-01-11,61.125,61.75,60.75,61.375,31512000,2.588915
1995-01-10,60.625,61.50,60.50,61.00,42184000,2.573096
1995-01-09,60.875,61.00,59.75,60.25,46000000,2.54146
1995-01-06,59.875,61.25,59.75,60.625,46681600,2.557278
1995-01-05,60.875,61.00,59.375,59.625,39824000,2.515096
1995-01-04,60.25,60.75,59.50,60.625,51611200,2.557278
1995-01-03,61.50,61.50,60.125,60.1875,39545600,2.538824
1994-12-30,61.875,61.875,61.125,61.125,20686400,2.578369
1994-12-29,60.875,61.875,60.625,61.8125,23446400,2.607369
1994-12-28,60.75,61.00,60.00,61.00,34961600,2.573096
1994-12-27,61.00,61.625,60.625,60.75,20566400,2.562551
1994-12-23,60.625,61.375,60.375,60.875,19486400,2.567824
1994-12-22,61.50,62.00,60.25,60.625,57355200,2.557278
1994-12-21,60.25,61.625,60.125,61.50,69395200,2.594187
1994-12-20,62.625,62.75,58.75,59.875,253456000,2.525642
1994-12-19,63.375,63.625,62.50,62.625,31507200,2.641642
1994-12-16,63.625,64.25,63.203098,63.375,54020800,2.673278
1994-12-15,63.375,64.125,63.00,63.50,28854400,2.678551
1994-12-14,62.50,63.625,62.50,63.25,33641600,2.668006
1994-12-13,63.375,63.50,62.25,62.75,30219200,2.646915
1994-12-12,63.125,63.50,61.625,63.125,65313600,2.662733
1994-12-09,62.50,63.25,62.25,63.125,79956800,2.662733
1994-12-08,63.125,63.75,62.25,62.50,41934400,2.636369
1994-12-07,63.50,63.875,63.00,63.00,36744000,2.65746
1994-12-06,63.25,64.125,63.00,63.375,38830400,2.673278
1994-12-05,63.375,64.25,63.125,63.3125,38166400,2.670642
1994-12-02,62.75,63.25,62.00,63.25,37715200,2.668006
1994-12-01,62.625,63.4062,62.50,62.5625,43096000,2.639006
1994-11-30,64.25,64.25,62.75,62.875,40934400,2.652188
1994-11-29,63.625,64.375,63.50,64.125,37673600,2.704915
1994-11-28,62.50,63.50,62.25,63.375,43449600,2.673278
1994-11-25,61.75,62.375,61.625,62.25,12563200,2.625824
1994-11-23,61.625,62.0625,61.0625,61.50,87507200,2.594187
1994-11-22,63.25,63.875,61.875,62.00,56358400,2.615278
1994-11-21,64.50,64.75,63.375,63.50,35560000,2.678551
1994-11-18,64.125,64.75,64.00,64.125,25694400,2.704915
1994-11-17,64.625,64.75,63.875,64.25,33232000,2.710188
1994-11-16,64.75,64.875,64.50,64.625,30196800,2.726006
1994-11-15,64.50,65.125,64.25,64.5625,52544000,2.72337
1994-11-14,62.75,64.50,62.75,64.50,48934400,2.720733
1994-11-11,62.25,62.6875,60.75,62.25,132899200,2.625824
1994-11-10,63.50,64.375,63.50,63.6875,24689600,2.68646
1994-11-09,64.25,64.625,63.125,63.75,60206400,2.689097
1994-11-08,61.875,63.875,61.6875,63.625,43328000,2.683824
1994-11-07,61.50,62.00,60.875,61.875,47094400,2.610006
1994-11-04,62.625,63.125,61.3125,61.50,46947200,2.594187
1994-11-03,63.00,63.25,62.375,62.625,63441600,2.641642
1994-11-02,62.75,64.125,62.50,63.00,61408000,2.65746
1994-11-01,62.75,62.875,62.125,62.75,39624000,2.646915
1994-10-31,62.25,63.75,62.00,63.00,59932800,2.65746
1994-10-28,61.625,62.375,61.375,62.125,58414400,2.620551
1994-10-27,61.125,61.625,60.75,61.625,41238400,2.59946
1994-10-26,59.875,61.125,59.75,61.00,97904000,2.573096
1994-10-25,58.75,59.75,58.375,59.6875,44780800,2.517733
1994-10-24,59.50,59.50,58.375,58.875,57145600,2.48346
1994-10-21,59.25,59.625,58.375,59.375,67099200,2.504551
1994-10-20,58.25,59.875,57.875,59.625,136558400,2.515096
1994-10-19,56.625,58.00,56.25,57.625,59488000,2.430733
1994-10-18,55.25,56.75,55.0625,56.625,52686400,2.388551
1994-10-17,56.00,56.25,55.00,55.125,31160000,2.325278
1994-10-14,57.25,57.375,55.1875,55.9375,99878400,2.359551
1994-10-13,56.625,57.75,56.625,57.25,63033600,2.414914
1994-10-12,55.875,56.50,55.75,56.25,27912000,2.372732
1994-10-11,55.125,56.625,55.125,55.8125,55692800,2.354278
1994-10-10,54.375,55.375,54.375,54.75,39480000,2.30946
1994-10-07,54.625,54.875,53.875,54.375,51518400,2.293641
1994-10-06,55.50,55.875,54.25,54.50,40790400,2.298914
1994-10-05,54.875,55.875,54.125,55.50,50985600,2.341096
1994-10-04,56.00,56.125,54.875,55.00,42622400,2.320005
1994-10-03,56.125,56.375,55.50,55.875,28833600,2.356914
1994-09-30,56.50,57.50,56.125,56.125,34608000,2.36746
1994-09-29,56.875,57.25,56.375,56.50,27105600,2.383278
1994-09-28,56.625,57.50,56.50,57.00,33355200,2.404369
1994-09-27,55.50,56.50,54.875,56.50,50585600,2.383278
1994-09-26,56.00,56.00,55.25,55.5625,29921600,2.343732
1994-09-23,56.875,57.50,56.00,56.00,48371200,2.362187
1994-09-22,57.25,57.50,56.625,57.00,44320000,2.404369
1994-09-21,56.3125,57.375,55.00,57.25,82948800,2.414914
1994-09-20,56.875,57.125,55.9375,56.00,40276800,2.362187
1994-09-19,57.125,57.25,56.625,56.875,48350400,2.399096
1994-09-16,58.00,58.125,56.75,56.875,52921600,2.399096
1994-09-15,57.625,58.25,57.375,58.25,40640000,2.457096
1994-09-14,57.75,58.125,57.50,57.625,29968000,2.430733
1994-09-13,56.375,57.875,56.375,57.5625,41134400,2.428096
1994-09-12,57.125,57.125,55.875,56.125,36238400,2.36746
1994-09-09,56.125,57.875,55.875,56.875,60800000,2.399096
1994-09-08,57.00,58.00,57.00,57.9375,28377600,2.443914
1994-09-07,56.25,57.8125,56.125,56.875,43588800,2.399096
1994-09-06,55.875,56.25,55.6875,56.00,28804800,2.362187
1994-09-02,56.50,56.50,55.75,56.00,46964800,2.362187
1994-09-01,57.00,57.00,55.75,56.125,115568000,2.36746
1994-08-31,58.375,59.25,57.75,58.125,60968000,2.451823
1994-08-30,57.00,58.50,56.625,58.375,39851200,2.462369
1994-08-29,57.375,58.125,57.00,57.0625,56625600,2.407005
1994-08-26,56.375,57.75,56.25,56.875,60961600,2.399096
1994-08-25,55.875,56.75,55.75,56.1875,55174400,2.370096
1994-08-24,55.50,56.00,55.50,55.75,35246400,2.351641
1994-08-23,54.625,56.375,54.50,55.50,58363200,2.341096
1994-08-22,55.00,55.00,54.50,54.625,62835200,2.304187
1994-08-19,55.875,56.00,54.75,54.875,74761600,2.314732
1994-08-18,55.875,56.375,55.375,55.50,61276800,2.341096
1994-08-17,55.375,56.25,55.125,55.875,79790400,2.356914
1994-08-16,54.875,55.125,54.00,54.875,56779200,2.314732
1994-08-15,55.50,55.50,54.375,54.4375,36113600,2.296278
1994-08-12,55.375,55.625,54.875,55.25,38088000,2.33055
1994-08-11,53.875,56.00,53.875,55.25,81428800,2.33055
1994-08-10,53.50,54.375,53.25,54.125,48646400,2.283096
1994-08-09,53.00,53.875,52.75,53.50,40198400,2.256732
1994-08-08,52.375,53.00,52.00,53.00,34537600,2.235641
1994-08-05,52.625,52.875,52.25,52.50,31204800,2.21455
1994-08-04,53.50,53.625,52.75,52.75,40192000,2.225096
1994-08-03,53.75,54.00,53.125,53.375,58771200,2.251459
1994-08-02,53.75,54.625,52.625,52.8125,95249600,2.227732
1994-08-01,51.625,53.625,51.50,53.375,83934400,2.251459
1994-07-29,49.875,51.625,49.625,51.50,67064000,2.172368
1994-07-28,49.50,50.25,49.25,49.50,39899200,2.088004
1994-07-27,50.375,50.375,49.50,49.50,29291200,2.088004
1994-07-26,51.125,51.25,49.75,50.375,54308800,2.124914
1994-07-25,50.625,51.625,50.25,51.1875,51513600,2.159186
1994-07-22,48.50,50.75,47.25,50.5625,152916800,2.132823
1994-07-21,48.625,48.875,47.50,47.75,85740800,2.014186
1994-07-20,50.00,50.00,47.875,48.375,112604800,2.04055
1994-07-19,50.625,50.625,49.625,50.125,70126400,2.114368
1994-07-18,51.50,51.75,49.50,50.50,150499200,2.130186
1994-07-15,48.75,49.375,48.00,48.625,45520000,2.051095
1994-07-14,49.375,49.625,48.375,48.75,81446400,2.056368
1994-07-13,48.25,49.50,47.875,49.50,82956800,2.088004
1994-07-12,48.25,48.25,46.875,48.00,83752000,2.024732
1994-07-11,49.625,49.625,47.75,48.375,85406400,2.04055
1994-07-08,49.875,50.875,49.125,49.50,48945600,2.088004
1994-07-07,48.50,50.50,47.9375,50.375,89667200,2.124914
1994-07-06,48.5625,49.00,47.75,48.3125,89254400,2.037913
1994-07-05,50.375,51.00,49.00,49.125,40430400,2.072186
1994-07-01,51.625,51.75,49.859299,50.25,66622400,2.119641
1994-06-30,51.75,52.125,51.00,51.625,40827200,2.177641
1994-06-29,51.375,51.875,50.875,51.375,53435200,2.167096
1994-06-28,52.00,52.75,50.1875,51.3125,99417600,2.164459
1994-06-27,49.75,52.125,49.375,51.875,76161600,2.188187
1994-06-24,50.00,50.375,49.25,49.50,81454400,2.088004
1994-06-23,51.50,52.25,50.00,50.125,85979200,2.114368
1994-06-22,52.75,53.00,51.25,51.50,82924800,2.172368
1994-06-21,52.125,53.375,52.00,52.625,86995200,2.219823
1994-06-20,52.50,53.50,52.375,53.50,45668800,2.256732
1994-06-17,53.50,53.625,52.875,53.00,47622400,2.235641
1994-06-16,54.25,54.25,53.50,53.5625,48478400,2.259369
1994-06-15,53.625,54.625,53.25,54.25,58860800,2.288369
1994-06-14,53.125,54.125,53.00,53.5625,59249600,2.259369
1994-06-13,52.625,53.375,51.875,52.875,56628800,2.230368
1994-06-10,52.25,53.00,51.875,52.5625,53726400,2.217187
1994-06-09,51.875,52.5625,51.75,52.25,79356800,2.204005
1994-06-08,53.625,53.625,51.625,52.00,203835200,2.193459
1994-06-07,54.00,54.25,53.50,53.625,166171200,2.262005
1994-06-06,52.625,54.625,51.75,54.50,764504000,2.298914
1994-06-03,52.50,53.50,52.25,52.875,86841600,2.230368
1994-06-02,53.25,53.375,52.00,52.25,60291200,2.204005
1994-06-01,53.50,53.50,52.375,53.00,100764800,2.235641
1994-05-31,52.25,53.765598,51.875,53.75,76000000,2.267278
1994-05-27,51.75,52.75,51.25,52.375,47544000,2.209277
1994-05-26,52.75,52.75,51.25,52.00,64296000,2.193459
1994-05-25,51.00,52.75,50.25,52.50,86003200,2.21455
1994-05-24,51.25,51.875,50.25,51.125,85144000,2.15655
1994-05-23,49.00,51.00,48.50,50.5625,74947200,2.132823
1994-05-20,98.00,99.25,97.25,97.75,78140800,2.061641
1994-05-19,97.25,99.00,97.00,98.375,89651200,2.074823
1994-05-18,95.25,97.50,94.75,97.0625,96953600,2.047141
1994-05-17,95.00,95.25,93.50,94.625,122464000,1.995732
1994-05-16,96.25,96.75,94.75,95.00,56633600,2.003641
1994-05-13,97.50,97.50,94.50,96.50,179920000,2.035277
1994-05-12,93.50,95.296799,93.25,94.50,58998400,1.993095
1994-05-11,94.00,94.25,92.75,93.50,57433600,1.972004
1994-05-10,93.00,94.50,92.75,94.00,65305600,1.98255
1994-05-09,91.75,93.625,91.625,92.25,47600000,1.945641
1994-05-06,93.25,94.25,90.875,92.50,96403200,1.950913
1994-05-05,95.25,96.25,94.00,94.375,56374400,1.990459
1994-05-04,93.75,95.25,92.75,95.125,68889600,2.006277
1994-05-03,95.25,95.50,93.25,93.50,41929600,1.972004
1994-05-02,92.75,95.5625,92.00,95.50,79260800,2.014186
1994-04-29,92.00,93.50,91.25,92.50,56803200,1.950913
1994-04-28,95.25,95.25,91.75,92.125,141382400,1.943004
1994-04-26,94.50,95.25,94.00,94.9375,113193600,2.002322
1994-04-25,92.00,94.25,91.50,93.75,142745600,1.977277
1994-04-22,92.00,92.75,90.75,91.75,66060800,1.935095
1994-04-21,89.50,91.75,89.25,91.50,141980800,1.929822
1994-04-20,88.50,89.625,87.00,89.50,104732800,1.88764
1994-04-19,87.00,89.50,85.75,88.125,291273600,1.85864
1994-04-18,84.75,85.75,82.25,83.00,78006400,1.750549
1994-04-15,83.50,85.25,83.50,84.875,35241600,1.790095
1994-04-14,84.50,85.25,83.75,84.125,53088000,1.774277
1994-04-13,84.75,85.50,83.00,84.875,69644800,1.790095
1994-04-12,86.75,86.75,84.00,84.75,84969600,1.787458
1994-04-11,87.00,87.25,86.00,87.00,40400000,1.834913
1994-04-08,89.75,90.00,86.75,87.00,118710400,1.834913
1994-04-07,89.25,90.125,88.75,89.75,76630400,1.892913
1994-04-06,87.50,89.25,87.25,89.00,80780800,1.877095
1994-04-05,85.25,87.75,85.00,87.75,101878400,1.850731
1994-04-04,82.50,85.75,82.00,84.50,73996800,1.782186
1994-03-31,83.50,85.75,82.50,84.75,72297600,1.787458
1994-03-30,82.75,85.00,82.50,83.625,86860800,1.763731
1994-03-29,86.50,86.50,82.50,82.50,78339200,1.740004
1994-03-28,87.50,88.00,83.75,86.375,118403200,1.821731
1994-03-25,87.00,89.25,87.00,87.50,102051200,1.845459
1994-03-24,85.75,87.25,85.00,87.25,60166400,1.840186
1994-03-23,85.25,87.50,85.00,86.25,116441600,1.819095
1994-03-22,82.25,85.75,82.25,84.75,89024000,1.787458
1994-03-21,85.00,85.375,83.00,83.25,65078400,1.755822
1994-03-18,84.50,85.00,83.50,84.75,36857600,1.787458
1994-03-17,84.75,85.25,84.50,84.50,30992000,1.782186
1994-03-16,85.00,85.25,84.50,84.75,41286400,1.787458
1994-03-15,84.00,85.25,83.50,84.875,62934400,1.790095
1994-03-14,82.50,84.25,82.25,83.875,69203200,1.769004
1994-03-11,81.00,82.25,80.75,81.75,34857600,1.724186
1994-03-10,81.50,82.25,80.50,80.875,46588800,1.705731
1994-03-09,81.25,81.75,80.00,80.875,37024000,1.705731
1994-03-08,81.25,81.25,79.75,81.00,24723200,1.708367
1994-03-07,81.25,82.25,80.75,81.25,30540800,1.71364
1994-03-04,81.00,81.50,80.50,81.00,25705600,1.708367
1994-03-03,83.00,83.25,80.50,81.00,31564800,1.708367
1994-03-02,81.75,83.00,81.00,82.75,68499200,1.745276
1994-03-01,83.00,83.25,82.25,83.25,48070400,1.755822
1994-02-28,81.25,83.00,81.00,82.50,55494400,1.740004
1994-02-25,80.25,81.25,79.75,81.00,52995200,1.708367
1994-02-24,80.00,80.75,79.25,79.875,82553600,1.68464
1994-02-23,79.75,82.00,78.25,81.00,139462400,1.708367
1994-02-22,80.00,80.25,78.50,79.50,63235200,1.676731
1994-02-18,78.50,80.75,78.50,80.00,79465600,1.687276
1994-02-17,79.00,79.50,78.00,78.625,85017600,1.658276
1994-02-16,80.25,80.25,78.75,78.75,43731200,1.660913
1994-02-15,79.75,80.25,79.25,79.75,28876800,1.682004
1994-02-14,79.00,79.50,78.75,79.125,55270400,1.668822
1994-02-11,79.25,79.50,78.00,78.75,53747200,1.660913
1994-02-10,79.75,80.75,79.00,79.375,66620800,1.674095
1994-02-09,78.50,80.25,78.00,79.625,98585600,1.679367
1994-02-08,80.50,80.50,78.00,78.75,149875200,1.660913
1994-02-07,79.75,81.25,79.50,80.75,118851200,1.703095
1994-02-04,84.00,84.50,81.25,81.25,78217600,1.71364
1994-02-03,84.25,84.50,83.50,84.50,31792000,1.782186
1994-02-02,84.75,85.50,84.00,84.00,40924800,1.77164
1994-02-01,85.00,85.75,84.50,85.125,44003200,1.795368
1994-01-31,85.25,85.875,84.75,85.125,62566400,1.795368
1994-01-28,84.50,85.50,84.25,84.875,41875200,1.790095
1994-01-27,84.00,84.75,83.25,84.25,51129600,1.776913
1994-01-26,85.00,85.00,84.00,84.25,50489600,1.776913
1994-01-25,85.25,85.375,84.00,85.125,70361600,1.795368
1994-01-24,86.00,87.00,85.00,85.25,38374400,1.798004
1994-01-21,86.25,87.00,85.00,86.25,99078400,1.819095
1994-01-20,83.25,86.375,83.25,86.25,145004800,1.819095
1994-01-19,83.75,84.25,82.50,83.25,76563200,1.755822
1994-01-18,85.25,85.50,84.00,84.625,43686400,1.784822
1994-01-17,85.25,86.00,84.50,84.75,30755200,1.787458
1994-01-14,85.50,86.00,84.75,85.625,45216000,1.805913
1994-01-13,84.75,85.50,84.00,85.375,40755200,1.80064
1994-01-12,85.00,85.75,83.75,85.50,39488000,1.803277
1994-01-11,85.00,86.00,84.375,85.25,35360000,1.798004
1994-01-10,85.00,86.50,85.00,85.75,74185600,1.808549
1994-01-07,84.25,85.75,83.25,85.25,70832000,1.798004
1994-01-06,82.625,84.75,82.50,84.625,82006400,1.784822
1994-01-05,80.25,82.50,80.00,82.25,53974400,1.734731
1994-01-04,80.25,80.75,79.25,80.50,45302400,1.697822
1994-01-03,80.50,80.75,79.25,80.125,36646400,1.689913
1993-12-31,81.00,81.50,80.25,80.625,22995200,1.700458
1993-12-30,81.75,82.25,80.75,81.25,25328000,1.71364
1993-12-29,82.75,83.50,80.50,81.50,48988800,1.718913
1993-12-28,80.50,83.00,80.50,82.75,27776000,1.745276
1993-12-27,80.75,81.25,79.75,80.50,24537600,1.697822
1993-12-23,81.00,82.25,80.75,80.875,31820800,1.705731
1993-12-22,82.25,82.50,81.00,81.125,24169600,1.711004
1993-12-21,82.00,82.50,81.50,82.50,31008000,1.740004
1993-12-20,81.00,82.00,80.50,82.00,35462400,1.729458
1993-12-17,80.50,80.50,79.75,80.50,26112000,1.697822
1993-12-16,80.00,81.00,79.75,80.00,29113600,1.687276
1993-12-15,80.00,81.00,79.75,79.75,35219200,1.682004
1993-12-14,81.00,81.50,79.25,80.00,47414400,1.687276
1993-12-13,81.50,82.00,80.75,81.375,20112000,1.716276
1993-12-10,81.25,82.25,80.75,81.875,19916800,1.726822
1993-12-09,83.50,83.50,80.50,81.125,61465600,1.711004
1993-12-08,83.00,83.75,82.25,83.50,105900800,1.761095
1993-12-07,85.00,86.00,85.00,85.50,32780800,1.803277
1993-12-06,85.00,85.50,84.00,84.875,59337600,1.790095
1993-12-03,83.75,86.50,83.50,85.75,114502400,1.808549
1993-12-02,82.00,83.00,81.75,82.875,51936000,1.747913
1993-12-01,80.50,82.25,80.50,81.50,58886400,1.718913
1993-11-30,78.50,80.50,78.25,80.00,44153600,1.687276
1993-11-29,79.00,80.00,79.00,79.50,32105600,1.676731
1993-11-26,79.00,79.25,78.75,79.00,6403200,1.666185
1993-11-24,77.50,79.75,77.50,78.75,32467200,1.660913
1993-11-23,77.75,78.50,77.25,77.375,98256000,1.631913
1993-11-22,79.75,79.75,76.50,77.00,80355200,1.624003
1993-11-19,79.75,80.25,79.50,80.125,38403200,1.689913
1993-11-18,80.75,81.50,80.00,80.25,48438400,1.692549
1993-11-17,82.75,83.00,80.75,80.75,72217600,1.703095
1993-11-16,81.00,82.75,80.50,82.25,47664000,1.734731
1993-11-15,82.00,82.00,80.50,80.50,29244800,1.697822
1993-11-12,81.75,82.50,81.75,81.875,34339200,1.726822
1993-11-11,81.25,82.50,81.00,81.625,31158400,1.721549
1993-11-10,80.00,81.625,79.00,81.375,57177600,1.716276
1993-11-09,79.00,80.00,78.00,78.25,36320000,1.650367
1993-11-08,79.00,79.50,77.75,78.50,28819200,1.65564
1993-11-05,76.25,79.00,76.00,78.75,56432000,1.660913
1993-11-04,78.75,79.00,76.50,76.50,63177600,1.613458
1993-11-03,80.00,80.50,77.75,78.50,56796800,1.65564
1993-11-02,81.25,81.50,79.50,80.25,42422400,1.692549
1993-11-01,80.25,81.50,79.75,80.875,30163200,1.705731
1993-10-29,79.50,80.25,79.25,80.125,39843200,1.689913
1993-10-28,79.75,80.50,78.75,79.00,56009600,1.666185
1993-10-27,79.50,80.50,79.50,79.875,45564800,1.68464
1993-10-26,80.50,80.75,79.25,79.50,66944000,1.676731
1993-10-25,80.50,81.25,79.00,80.50,48553600,1.697822
1993-10-22,79.25,80.75,79.25,80.375,47625600,1.695185
1993-10-21,78.75,80.00,78.00,79.50,127142400,1.676731
1993-10-20,80.50,81.75,79.25,81.00,81590400,1.708367
1993-10-19,82.00,84.00,79.50,80.25,91392000,1.692549
1993-10-18,81.00,83.25,80.75,83.00,67750400,1.750549
1993-10-15,82.25,83.00,80.25,80.75,126425600,1.703095
1993-10-14,83.75,84.00,82.00,82.125,63257600,1.732095
1993-10-13,83.75,84.25,81.25,83.25,62409600,1.755822
1993-10-12,84.25,85.25,82.25,84.25,79296000,1.776913
1993-10-11,84.50,84.75,82.25,84.00,36457600,1.77164
1993-10-08,84.25,84.75,82.25,84.50,38086400,1.782186
1993-10-07,85.00,85.75,83.75,84.125,41596800,1.774277
1993-10-06,83.25,85.50,83.00,84.875,77321600,1.790095
1993-10-05,82.75,84.75,82.50,83.25,86931200,1.755822
1993-10-04,82.50,84.00,82.50,82.625,40505600,1.74264
1993-10-01,82.50,83.25,82.00,82.00,46048000,1.729458
1993-09-30,82.75,83.25,82.25,82.50,38400000,1.740004
1993-09-29,83.75,84.00,80.75,83.00,87529600,1.750549
1993-09-28,82.25,84.25,82.25,84.00,84012800,1.77164
1993-09-27,81.75,82.50,81.25,82.25,73472000,1.734731
1993-09-24,78.50,80.75,78.50,80.00,91481600,1.687276
1993-09-23,77.25,79.25,76.75,78.75,72214400,1.660913
1993-09-22,76.00,78.00,75.25,77.25,72051200,1.629276
1993-09-21,75.50,77.375,74.75,76.00,57846400,1.602913
1993-09-20,76.25,77.75,75.00,75.625,34691200,1.595003
1993-09-17,75.50,76.50,75.25,76.00,25286400,1.602913
1993-09-16,76.75,77.25,75.75,76.00,25641600,1.602913
1993-09-15,75.75,76.75,74.375,76.50,60428800,1.613458
1993-09-14,76.00,76.25,74.25,75.25,57756800,1.587094
1993-09-13,78.50,78.50,76.25,76.375,33481600,1.610822
1993-09-10,77.00,78.25,76.25,78.00,56540800,1.645094
1993-09-09,75.00,76.50,74.50,76.25,29856000,1.608185
1993-09-08,74.00,74.75,73.25,74.50,54777600,1.571276
1993-09-07,75.75,76.25,74.25,74.75,38659200,1.576549
1993-09-03,76.50,76.75,75.25,75.75,26800000,1.59764
1993-09-02,77.25,78.50,76.125,76.625,55497600,1.616094
1993-09-01,75.25,77.25,75.00,76.75,86035200,1.618731
1993-08-31,73.75,75.50,73.50,75.125,93020800,1.584458
1993-08-30,72.50,73.25,71.75,72.625,54012800,1.531731
1993-08-27,72.25,72.50,71.25,71.875,67763200,1.515912
1993-08-26,73.50,73.75,71.50,72.125,136256000,1.521185
1993-08-25,75.00,76.00,72.875,74.25,68800000,1.566003
1993-08-24,76.50,77.00,75.75,75.875,39417600,1.600276
1993-08-23,75.50,78.25,75.50,77.00,59472000,1.624003
1993-08-20,73.50,76.75,73.25,76.25,73683200,1.608185
1993-08-19,77.25,77.875,73.75,74.25,114742400,1.566003
1993-08-18,77.75,79.25,76.50,77.25,66012800,1.629276
1993-08-17,78.00,78.50,76.00,77.25,54272000,1.629276
1993-08-16,75.75,78.25,75.50,77.75,78451200,1.639822
1993-08-13,74.00,75.75,73.00,75.25,61900800,1.587094
1993-08-12,72.50,74.50,72.25,74.00,77366400,1.560731
1993-08-11,71.25,73.00,71.125,72.375,95974400,1.526458
1993-08-10,73.00,73.25,70.375,71.00,192028800,1.497458
1993-08-09,73.25,74.00,72.25,73.00,70876800,1.53964
1993-08-06,74.75,75.875,72.75,73.25,71760000,1.544912
1993-08-05,73.50,75.00,73.25,74.75,67910400,1.576549
1993-08-04,73.25,73.75,71.75,73.00,94416000,1.53964
1993-08-03,73.00,73.25,72.00,73.00,85136000,1.53964
1993-08-02,74.75,75.75,72.25,72.75,148208000,1.534367
1993-07-30,73.00,74.25,72.00,74.00,287936000,1.560731
1993-07-29,78.00,80.75,77.50,79.00,96534400,1.666185
1993-07-28,76.00,79.50,74.75,78.25,113459200,1.650367
1993-07-27,78.50,78.75,75.50,75.50,112220800,1.592367
1993-07-26,78.25,79.25,77.75,78.25,65801600,1.650367
1993-07-23,77.00,78.25,76.75,77.625,92790400,1.637185
1993-07-22,80.75,81.75,76.75,77.625,147584000,1.637185
1993-07-21,78.50,79.00,76.75,79.00,178963200,1.666185
1993-07-20,79.25,80.50,78.00,80.50,74822400,1.697822
1993-07-19,79.50,80.25,78.00,78.75,122435200,1.660913
1993-07-16,83.25,83.25,80.75,81.125,86217600,1.711004
1993-07-15,84.25,84.25,82.75,83.50,34432000,1.761095
1993-07-14,83.00,85.50,82.50,84.25,43491200,1.776913
1993-07-13,84.00,84.00,82.50,82.75,36476800,1.745276
1993-07-12,84.75,84.75,83.50,83.75,26540800,1.766367
1993-07-09,85.00,85.00,83.50,84.625,50000000,1.784822
1993-07-08,84.00,85.50,84.00,84.875,70105600,1.790095
1993-07-07,82.125,84.25,81.25,83.375,182569600,1.758458
1993-07-06,86.75,87.75,85.25,86.00,47721600,1.813822
1993-07-02,87.25,87.50,86.50,87.25,25404800,1.840186
1993-07-01,88.25,88.50,86.50,87.125,57907200,1.837549
1993-06-30,89.25,90.25,87.25,88.00,56422400,1.856004
1993-06-29,90.25,91.75,88.50,89.00,42361600,1.877095
1993-06-28,88.75,90.25,88.50,90.25,52224000,1.903459
1993-06-25,88.50,89.25,86.75,88.50,45484800,1.866549
1993-06-24,88.25,89.50,87.25,88.50,35782400,1.866549
1993-06-23,88.00,89.25,87.75,88.625,33129600,1.869186
1993-06-22,89.25,89.75,87.25,88.00,41062400,1.856004
1993-06-21,88.75,89.25,87.00,88.625,68102400,1.869186
1993-06-18,90.50,91.25,87.00,87.50,75910400,1.845459
1993-06-17,91.50,91.75,90.50,90.875,28083200,1.91664
1993-06-16,92.75,93.25,89.25,91.25,66966400,1.92455
1993-06-15,93.00,93.00,91.50,92.50,42345600,1.950913
1993-06-14,91.00,92.25,90.25,92.25,40489600,1.945641
1993-06-11,91.75,92.50,89.00,89.375,67542400,1.885004
1993-06-10,91.25,92.50,89.50,91.125,56544000,1.921913
1993-06-09,92.75,93.00,90.75,91.00,62480000,1.919277
1993-06-08,93.00,93.25,90.75,92.25,48131200,1.945641
1993-06-07,94.25,95.75,93.00,93.25,52761600,1.966732
1993-06-04,94.00,94.50,93.50,94.00,32652800,1.98255
1993-06-03,95.75,96.00,94.50,94.625,23936000,1.995732
1993-06-02,95.75,97.50,95.25,95.75,70710400,2.019459
1993-06-01,93.00,98.00,92.75,96.25,173088000,2.030004
1993-05-28,93.50,93.75,91.75,92.625,35136000,1.95355
1993-05-27,95.00,95.50,93.00,94.125,95052800,1.985186
1993-05-26,91.50,95.25,91.25,95.25,87484800,2.008913
1993-05-25,91.75,92.00,90.00,91.25,36716800,1.92455
1993-05-24,92.25,94.00,92.00,92.125,64252800,1.943004
1993-05-21,93.50,94.25,92.00,92.50,75500800,1.950913
1993-05-20,92.25,95.25,92.00,94.125,150256000,1.985186
1993-05-19,90.75,93.00,89.50,92.50,181017600,1.950913
1993-05-18,86.75,88.75,86.50,88.50,84185600,1.866549
1993-05-17,85.75,86.625,85.25,86.50,27763200,1.824368
1993-05-14,86.00,86.75,84.75,85.50,49116800,1.803277
1993-05-13,85.75,86.00,84.50,85.75,43708800,1.808549
1993-05-12,87.50,88.00,85.75,86.25,48272000,1.819095
1993-05-11,88.25,88.75,87.25,87.75,38220800,1.850731
1993-05-10,88.50,90.00,88.00,89.125,69091200,1.879731
1993-05-07,87.25,87.75,86.50,87.00,31798400,1.834913
1993-05-06,89.00,89.75,86.75,87.25,47244800,1.840186
1993-05-05,88.00,90.00,87.50,89.25,51868800,1.882368
1993-05-04,86.75,88.50,86.50,88.00,49664000,1.856004
1993-05-03,85.50,87.00,85.00,86.125,38096000,1.816458
1993-04-30,85.00,86.75,85.00,85.50,46825600,1.803277
1993-04-29,85.75,85.75,84.00,85.50,49660800,1.803277
1993-04-28,83.00,86.00,82.75,86.00,55372800,1.813822
1993-04-27,80.50,82.75,80.25,82.50,58208000,1.740004
1993-04-26,81.50,82.50,79.75,80.375,65376000,1.695185
1993-04-23,83.00,83.25,80.75,81.375,89296000,1.716276
1993-04-22,84.50,85.00,82.875,83.25,79872000,1.755822
1993-04-21,86.75,86.75,84.25,84.875,92528000,1.790095
1993-04-20,86.75,87.50,85.00,86.75,46009600,1.82964
1993-04-19,87.00,87.25,85.00,87.00,45673600,1.834913
1993-04-16,87.25,87.75,85.50,87.00,49600000,1.834913
1993-04-15,88.00,89.875,86.00,87.125,109152000,1.837549
1993-04-14,89.00,90.25,87.75,89.00,38592000,1.877095
1993-04-13,90.25,92.25,88.75,88.875,53337600,1.874459
1993-04-12,88.75,91.25,88.50,90.125,48976000,1.900822
1993-04-08,90.00,90.25,88.25,89.00,40185600,1.877095
1993-04-07,90.00,90.50,89.25,90.25,39417600,1.903459
1993-04-06,91.75,93.00,89.25,89.75,55699200,1.892913
1993-04-05,88.75,92.25,88.00,91.50,61187200,1.929822
1993-04-02,91.75,92.00,89.75,89.75,73251200,1.892913
1993-04-01,92.50,94.75,92.50,93.00,100412800,1.961459
1993-03-31,91.25,94.25,90.75,92.50,179660800,1.950913
1993-03-30,88.50,91.25,87.25,91.00,140777600,1.919277
1993-03-29,86.75,88.50,86.75,87.00,48262400,1.834913
1993-03-26,88.00,88.25,86.00,86.625,28380800,1.827004
1993-03-25,86.50,88.25,86.375,87.375,43833600,1.842822
1993-03-24,83.25,86.75,83.00,86.25,50576000,1.819095
1993-03-23,83.50,85.00,83.00,83.125,34409600,1.753186
1993-03-22,83.25,84.00,82.50,83.375,34083200,1.758458
1993-03-19,85.75,85.75,84.00,84.25,45404800,1.776913
1993-03-18,85.75,86.75,85.00,85.25,34406400,1.798004
1993-03-17,86.75,87.50,85.25,85.375,39644800,1.80064
1993-03-16,88.25,88.75,87.00,87.75,36336000,1.850731
1993-03-15,89.25,89.25,87.00,87.625,35347200,1.848095
1993-03-12,86.00,89.25,85.25,89.00,73580800,1.877095
1993-03-11,85.25,87.75,85.00,86.50,57779200,1.824368
1993-03-10,84.50,85.75,83.50,85.00,26592000,1.792731
1993-03-09,84.00,85.00,83.75,84.25,41312000,1.776913
1993-03-08,82.625,84.50,82.00,83.625,48022400,1.763731
1993-03-05,83.50,85.00,82.50,82.75,35724800,1.745276
1993-03-04,84.75,84.75,81.75,83.75,56659200,1.766367
1993-03-03,84.75,85.50,83.50,84.75,42352000,1.787458
1993-03-02,81.75,84.75,81.25,84.625,38380800,1.784822
1993-03-01,83.75,83.75,81.25,81.50,26432000,1.718913
1993-02-26,84.25,85.00,83.00,83.375,29833600,1.758458
1993-02-25,82.50,85.00,82.50,84.375,60806400,1.779549
1993-02-24,79.00,84.00,78.75,83.875,77548800,1.769004
1993-02-23,78.00,80.50,76.75,79.50,105974400,1.676731
1993-02-22,79.75,81.00,76.75,76.75,76256000,1.618731
1993-02-19,81.875,82.00,79.50,79.75,97094400,1.682004
1993-02-18,81.25,82.75,79.00,81.625,138553600,1.721549
1993-02-17,81.00,81.25,77.25,80.25,121913600,1.692549
1993-02-16,82.875,83.75,79.75,80.125,91180800,1.689913
1993-02-12,85.25,85.25,83.25,83.625,34752000,1.763731
1993-02-11,86.25,86.50,84.75,85.25,31635200,1.798004
1993-02-10,84.50,86.25,84.00,85.50,39193600,1.803277
1993-02-09,86.75,87.25,83.50,83.875,64550400,1.769004
1993-02-08,88.50,89.00,85.00,85.75,92665600,1.808549
1993-02-05,84.75,89.50,82.25,89.00,177216000,1.877095
1993-02-04,87.75,87.75,84.50,85.00,124214400,1.792731
1993-02-03,89.50,90.25,88.00,88.375,71728000,1.863913
1993-02-02,87.375,89.50,87.25,89.00,70371200,1.877095
1993-02-01,86.25,88.00,85.50,87.50,42854400,1.845459
1993-01-29,87.50,88.00,85.75,86.50,39424000,1.824368
1993-01-28,86.25,87.125,84.75,87.00,77030400,1.834913
1993-01-27,87.50,87.75,85.50,86.25,64192000,1.819095
1993-01-26,88.50,90.00,87.50,88.00,42345600,1.856004
1993-01-25,89.25,90.25,87.75,88.50,49609600,1.866549
1993-01-22,89.75,90.25,88.75,89.375,49088000,1.885004
1993-01-21,87.75,90.00,86.75,89.50,73363200,1.88764
1993-01-20,88.50,89.00,87.75,88.375,47968000,1.863913
1993-01-19,89.00,89.25,88.25,88.375,52960000,1.863913
1993-01-18,89.50,89.75,88.25,89.25,50611200,1.882368
1993-01-15,87.50,91.00,87.00,89.75,181958400,1.892913
1993-01-14,92.25,94.00,90.50,91.25,121264000,1.92455
1993-01-13,89.50,92.25,88.25,91.25,83696000,1.92455
1993-01-12,89.00,91.25,88.75,89.75,85129600,1.892913
1993-01-11,87.25,89.25,86.25,89.125,58348800,1.879731
1993-01-08,87.25,88.25,86.25,87.125,43977600,1.837549
1993-01-07,89.00,89.875,87.00,87.25,58748800,1.840186
1993-01-06,87.00,89.25,86.75,89.00,87440000,1.877095
1993-01-05,85.00,86.75,84.75,86.50,71529600,1.824368
1993-01-04,85.00,85.75,84.50,85.125,72646400,1.795368
1992-12-31,86.00,86.25,85.25,85.375,30851200,1.80064
1992-12-30,86.75,87.00,85.25,85.875,50860800,1.811186
1992-12-29,87.25,87.50,86.25,86.50,60035200,1.824368
1992-12-28,87.25,87.75,86.00,87.50,45731200,1.845459
1992-12-24,87.25,87.25,86.00,87.25,32723200,1.840186
1992-12-23,88.00,88.25,86.00,87.25,59974400,1.840186
1992-12-22,91.00,91.50,87.00,87.75,56928000,1.850731
1992-12-21,89.75,92.00,89.25,90.50,64928000,1.908731
1992-12-18,89.00,90.25,88.50,90.00,74387200,1.898186
1992-12-17,87.25,90.25,87.00,90.00,51859200,1.898186
1992-12-16,86.50,88.25,85.25,87.00,73792000,1.834913
1992-12-15,87.25,87.75,85.50,86.375,45289600,1.821731
1992-12-14,86.75,88.25,86.50,87.125,51286400,1.837549
1992-12-11,88.50,89.00,85.75,86.375,112934400,1.821731
1992-12-10,90.00,91.75,88.50,89.00,89296000,1.877095
1992-12-09,91.75,93.25,91.25,92.00,26048000,1.940368
1992-12-08,93.75,94.00,91.50,92.50,26908800,1.950913
1992-12-07,92.00,93.50,91.00,93.375,46422400,1.969368
1992-12-04,91.50,92.50,91.25,91.75,23548800,1.935095
1992-12-03,90.75,92.50,90.50,91.625,26048000,1.932459
1992-12-02,93.00,93.50,90.50,90.75,49881600,1.914004
1992-12-01,92.75,93.50,92.00,93.125,33593600,1.964095
1992-11-30,92.50,93.25,91.75,93.125,35251200,1.964095
1992-11-27,91.50,92.50,91.00,91.75,17593600,1.935095
1992-11-25,92.00,92.50,90.25,91.125,53152000,1.921913
1992-11-24,91.25,92.75,89.25,91.50,145513600,1.929822
1992-11-23,90.25,91.75,87.25,88.50,309884800,1.866549
1992-11-20,94.00,95.00,93.75,95.00,41113600,2.003641
1992-11-19,92.25,95.00,92.25,94.00,46857600,1.98255
1992-11-18,90.50,92.50,89.875,92.00,33273600,1.940368
1992-11-17,92.875,94.00,89.25,90.00,56649600,1.898186
1992-11-16,93.00,93.50,92.25,92.75,19312000,1.956186
1992-11-13,93.50,93.75,92.50,93.25,25811200,1.966732
1992-11-12,93.75,94.25,92.00,93.50,46960000,1.972004
1992-11-11,92.75,95.00,92.25,93.75,60748800,1.977277
1992-11-10,92.00,93.25,91.50,92.875,38710400,1.958822
1992-11-09,92.75,92.75,90.50,91.875,54796800,1.937731
1992-11-06,91.75,93.25,91.25,92.75,61155200,1.956186
1992-11-05,89.00,92.25,88.25,91.875,90361600,1.937731
1992-11-04,88.25,89.75,88.00,88.50,23657600,1.866549
1992-11-03,89.50,89.75,87.625,88.25,35267200,1.861277
1992-11-02,89.00,90.00,87.75,89.625,31091200,1.890277
1992-10-30,89.875,90.00,88.50,88.75,24998400,1.871822
1992-10-29,88.75,90.00,88.50,90.00,32774400,1.898186
1992-10-28,88.25,88.75,87.25,88.50,36172800,1.866549
1992-10-27,90.00,90.25,87.50,88.00,49116800,1.856004
1992-10-26,88.50,90.25,87.75,90.00,40121600,1.898186
1992-10-23,90.25,90.25,88.25,88.625,46006400,1.869186
1992-10-22,90.00,90.25,88.25,89.75,49174400,1.892913
1992-10-21,88.25,90.00,87.75,90.00,60396800,1.898186
1992-10-20,88.25,89.75,87.00,87.875,84150400,1.853368
1992-10-19,85.00,88.25,85.00,87.875,83280000,1.853368
1992-10-16,84.75,85.50,83.75,85.375,47644800,1.80064
1992-10-15,83.25,84.75,82.75,84.50,35942400,1.782186
1992-10-14,84.375,85.00,83.00,83.50,47456000,1.761095
1992-10-13,84.75,85.375,83.25,84.25,86643200,1.776913
1992-10-12,83.00,84.00,82.75,83.875,34700800,1.769004
1992-10-09,83.50,83.50,81.50,82.375,40182400,1.737367
1992-10-08,82.25,84.50,81.75,83.375,59532800,1.758458
1992-10-07,82.50,84.25,81.00,81.125,58153600,1.711004
1992-10-06,82.25,83.50,81.25,82.50,74316800,1.740004
1992-10-05,78.50,81.75,75.75,81.75,71347200,1.724186
1992-10-02,79.25,79.75,78.00,78.75,36803200,1.660913
1992-10-01,80.00,81.00,79.50,79.625,47804800,1.679367
1992-09-30,79.75,80.50,78.75,80.50,59843200,1.697822
1992-09-29,77.00,79.00,77.00,78.75,39392000,1.660913
1992-09-28,76.50,78.25,76.25,77.00,52854400,1.624003
1992-09-25,80.25,80.375,76.00,78.75,41817600,1.660913
1992-09-24,79.25,80.50,79.25,80.25,36953600,1.692549
1992-09-23,77.75,79.75,77.50,79.125,37654400,1.668822
1992-09-22,79.00,79.125,77.50,77.75,30777600,1.639822
1992-09-21,78.75,79.50,78.25,79.125,31811200,1.668822
1992-09-18,81.25,81.50,78.375,79.875,71683200,1.68464
1992-09-17,80.50,81.50,80.25,81.125,23590400,1.711004
1992-09-16,79.75,81.75,79.50,80.375,35708800,1.695185
1992-09-15,81.50,81.75,80.00,81.25,44614400,1.71364
1992-09-14,79.75,82.00,79.75,81.75,95100800,1.724186
1992-09-11,78.50,79.25,78.00,78.75,30796800,1.660913
1992-09-10,78.25,79.00,77.50,79.00,53302400,1.666185
1992-09-09,76.75,78.375,76.50,78.125,60982400,1.647731
1992-09-08,76.00,76.875,75.25,76.75,49376000,1.618731
1992-09-04,76.25,76.50,75.50,76.00,28585600,1.602913
1992-09-03,75.75,77.25,75.50,76.625,85296000,1.616094
1992-09-02,74.50,75.75,73.75,75.375,61955200,1.589731
1992-09-01,74.00,74.625,73.25,74.50,30825600,1.571276
1992-08-31,74.25,75.00,73.50,74.50,25651200,1.571276
1992-08-28,73.50,74.50,73.50,74.375,49468800,1.56864
1992-08-27,72.00,74.00,72.00,73.625,88028800,1.552822
1992-08-26,70.25,72.25,70.25,71.625,50016000,1.51064
1992-08-25,68.75,70.75,68.50,70.375,37123200,1.484276
1992-08-24,69.625,70.00,68.75,69.00,42800000,1.455276
1992-08-21,70.50,70.875,69.00,69.75,52710400,1.471094
1992-08-20,69.50,70.75,69.00,70.375,36534400,1.484276
1992-08-19,69.50,70.50,68.75,69.25,27433600,1.460549
1992-08-18,69.00,70.75,68.00,69.50,66313600,1.465821
1992-08-17,70.75,71.00,69.50,69.50,63318400,1.465821
1992-08-14,71.00,71.75,70.75,71.00,33942400,1.497458
1992-08-13,71.25,71.75,70.50,70.875,28227200,1.494821
1992-08-12,71.75,72.50,70.75,71.00,30441600,1.497458
1992-08-11,71.25,71.875,70.00,71.375,33436800,1.505367
1992-08-10,71.00,72.50,70.75,70.875,42067200,1.494821
1992-08-07,71.50,73.75,70.50,70.75,55008000,1.492185
1992-08-06,71.50,72.00,70.25,71.50,3705600,1.508003
1992-08-05,73.75,73.75,71.25,72.00,60150400,1.518549
1992-08-04,74.00,74.50,73.50,73.875,31430400,1.558094
1992-08-03,72.75,74.25,72.00,73.75,31516800,1.555458
1992-07-31,73.50,73.50,72.25,72.75,35312000,1.534367
1992-07-30,73.50,74.50,73.00,73.125,32035200,1.542276
1992-07-29,74.50,74.75,72.00,74.00,145273600,1.560731
1992-07-28,73.50,74.50,72.75,74.00,45363200,1.560731
1992-07-27,72.75,73.50,72.25,73.00,30512000,1.53964
1992-07-24,71.125,73.75,71.00,72.75,76259200,1.534367
1992-07-23,69.75,72.25,68.75,71.00,68441600,1.497458
1992-07-22,71.75,71.75,69.50,70.00,59008000,1.476367
1992-07-21,70.00,72.75,69.50,71.75,45907200,1.513276
1992-07-20,69.50,70.25,68.50,69.25,48707200,1.460549
1992-07-17,71.75,72.00,69.75,70.25,59865600,1.48164
1992-07-16,71.00,72.25,70.75,72.25,42291200,1.523821
1992-07-15,71.75,73.25,71.00,71.50,80172800,1.508003
1992-07-14,70.50,71.50,70.25,71.125,41116800,1.500094
1992-07-13,69.75,71.25,68.50,70.00,35113600,1.476367
1992-07-10,69.25,70.00,67.625,69.50,28905600,1.465821
1992-07-09,69.00,70.75,68.25,69.00,61174400,1.455276
1992-07-08,68.00,69.00,65.50,68.625,93417600,1.447367
1992-07-07,69.75,69.75,67.25,68.00,54396800,1.434185
1992-07-06,70.00,70.25,67.75,69.50,36224000,1.465821
1992-07-02,72.75,73.00,68.75,69.875,80563200,1.47373
1992-07-01,70.25,72.75,69.50,72.125,45136000,1.521185
1992-06-30,72.75,73.00,69.50,70.00,74048000,1.476367
1992-06-29,68.50,72.75,68.25,72.25,90963200,1.523821
1992-06-26,69.50,69.75,65.75,66.75,140982400,1.407821
1992-06-25,72.25,72.25,66.50,70.00,165340800,1.476367
1992-06-24,73.75,73.75,71.75,72.25,34096000,1.523821
1992-06-23,74.75,75.75,72.75,73.50,57420800,1.550185
1992-06-22,73.25,74.50,71.50,74.25,54080000,1.566003
1992-06-19,73.50,74.25,72.75,73.50,43110400,1.550185
1992-06-18,73.00,74.75,71.00,72.25,53356800,1.523821
1992-06-17,72.50,73.25,71.50,72.375,70032000,1.526458
1992-06-16,75.50,76.50,72.50,72.75,57376000,1.534367
1992-06-15,75.00,78.00,75.00,75.75,54940800,1.59764
1992-06-12,110.25,113.000004,108.875004,112.50,138028800,1.581822
1992-06-11,112.50,115.250004,107.499996,108.00,130732800,1.518549
1992-06-10,115.250004,115.50,111.999996,112.50,65456000,1.581822
1992-06-09,118.50,119.000004,114.00,114.999996,84604800,1.616973
1992-06-08,120.75,120.999996,118.250004,118.250004,40227200,1.66267
1992-06-05,122.499996,123.00,120.75,120.999996,40937600,1.701337
1992-06-04,123.249996,123.500004,122.499996,122.625,41753600,1.724186
1992-06-03,122.499996,124.250004,122.499996,123.00,28188800,1.729458
1992-06-02,124.250004,124.50,122.25,122.874996,42585600,1.727701
1992-06-01,120.500004,124.250004,120.00,124.250004,68528000,1.747034
1992-05-29,119.750004,122.25,119.499996,120.999996,89916800,1.701337
1992-05-28,114.75,119.499996,114.500004,119.000004,62700800,1.673216
1992-05-27,115.749996,116.25,114.75,114.999996,31164800,1.616973
1992-05-26,116.000004,117.00,114.999996,115.50,38217600,1.624003
1992-05-22,117.00,117.00,114.999996,115.749996,36969600,1.627519
1992-05-21,117.00,117.00,115.250004,116.625,48566400,1.639822
1992-05-20,114.500004,117.00,114.500004,116.750004,58800000,1.641579
1992-05-19,113.25,114.500004,113.25,114.500004,51238400,1.609943
1992-05-18,110.750004,113.499996,110.499996,112.749996,37526400,1.585337
1992-05-15,110.25,111.500004,109.50,110.000004,40812800,1.54667
1992-05-14,112.749996,113.000004,109.250004,110.750004,72307200,1.557216
1992-05-13,113.750004,114.249996,111.00,112.749996,64320000,1.585337
1992-05-12,114.75,115.250004,112.749996,114.249996,49904000,1.606428
1992-05-11,114.75,115.250004,113.25,114.00,41110400,1.602913
1992-05-08,116.000004,117.00,113.25,114.500004,59820800,1.609943
1992-05-07,116.000004,116.499996,114.249996,114.999996,40579200,1.616973
1992-05-06,117.00,117.249996,115.50,116.000004,50016000,1.631034
1992-05-05,113.750004,117.500004,113.25,116.499996,59244800,1.638064
1992-05-04,113.499996,116.000004,112.50,114.00,73920000,1.602913
1992-05-01,110.499996,114.00,110.25,113.750004,62083200,1.599397
1992-04-30,111.999996,112.749996,109.749996,110.25,95868800,1.550185
1992-04-29,109.50,111.500004,108.249996,111.375,137308800,1.566003
1992-04-28,113.750004,114.500004,107.000004,108.999996,199875200,1.532609
1992-04-27,112.50,116.499996,112.50,113.25,99584000,1.592367
1992-04-24,116.000004,116.750004,111.999996,112.250004,90393600,1.578306
1992-04-23,118.50,119.000004,112.250004,115.749996,115334400,1.627519
1992-04-22,116.499996,118.50,114.500004,117.624996,61788800,1.653882
1992-04-21,118.250004,118.50,115.50,116.124996,99244800,1.632791
1992-04-20,124.50,125.000004,115.50,118.125,226118400,1.660913
1992-04-16,129.00,129.00,126.999996,127.625004,66393600,1.794489
1992-04-15,128.750004,129.249996,126.500004,128.874996,223305600,1.812064
1992-04-14,118.250004,120.249996,116.499996,117.00,72806400,1.645094
1992-04-13,116.750004,118.125,114.249996,117.500004,45552000,1.652125
1992-04-10,121.250004,122.000004,114.00,116.000004,126444800,1.631034
1992-04-09,118.250004,120.249996,116.625,120.00,70006400,1.687276
1992-04-08,115.749996,117.500004,113.25,117.249996,105388800,1.64861
1992-04-07,122.000004,122.499996,115.749996,116.000004,72758400,1.631034
1992-04-06,117.75,121.625004,117.75,121.250004,40121600,1.704852
1992-04-03,117.500004,119.25,116.750004,117.500004,59532800,1.652125
1992-04-02,120.500004,121.50,116.750004,117.00,56918400,1.645094
1992-04-01,117.249996,120.75,117.00,120.500004,74201600,1.694307
1992-03-31,120.500004,122.000004,117.75,118.50,86700800,1.666185
1992-03-30,121.50,122.000004,120.00,120.00,40713600,1.687276
1992-03-27,124.50,125.000004,119.499996,121.250004,89971200,1.704852
1992-03-26,128.750004,129.00,124.250004,125.000004,60403200,1.75758
1992-03-25,127.50,129.249996,126.999996,128.499996,36739200,1.806792
1992-03-24,129.00,129.875004,126.500004,127.50,70227200,1.792731
1992-03-23,128.499996,129.249996,127.749996,128.499996,37843200,1.806792
1992-03-20,127.50,129.00,127.50,128.499996,35772800,1.806792
1992-03-19,126.999996,130.250004,126.249996,127.50,111574400,1.792731
1992-03-18,128.499996,129.00,126.00,126.375,69228800,1.776913
1992-03-17,125.375004,128.750004,124.749996,128.000004,94473600,1.799762
1992-03-16,120.999996,124.250004,120.500004,124.250004,55132800,1.747034
1992-03-13,122.499996,123.00,120.500004,120.999996,36761600,1.701337
1992-03-12,120.249996,121.50,118.50,121.125,50025600,1.703095
1992-03-11,122.25,123.249996,119.25,120.249996,39532800,1.690791
1992-03-10,119.499996,122.750004,119.25,121.749996,45478400,1.711882
1992-03-09,118.749996,120.500004,118.250004,119.000004,30425600,1.673216
1992-03-06,120.75,122.000004,116.750004,118.250004,61865600,1.66267
1992-03-05,122.499996,123.249996,119.25,121.250004,55689600,1.704852
1992-03-04,123.249996,124.250004,121.749996,122.499996,33084800,1.722428
1992-03-03,123.500004,125.25,122.499996,123.249996,27734400,1.732973
1992-03-02,123.75,125.750004,121.749996,123.00,34876800,1.729458
1992-02-28,125.000004,126.500004,122.25,123.500004,58275200,1.736489
1992-02-27,122.750004,125.25,122.750004,124.875,79577600,1.755822
1992-02-26,116.000004,122.000004,116.000004,122.000004,100668800,1.715398
1992-02-25,114.999996,116.499996,113.25,115.749996,57388800,1.627519
1992-02-24,114.500004,116.499996,113.000004,114.875004,59049600,1.615216
1992-02-21,117.00,118.50,113.750004,114.500004,91116800,1.609943
1992-02-20,116.000004,119.25,115.749996,117.500004,74323200,1.652125
1992-02-19,117.999996,117.999996,113.499996,115.125,145372800,1.618731
1992-02-18,119.25,122.25,117.999996,118.250004,73692800,1.66267
1992-02-14,122.25,122.499996,117.999996,118.50,82630400,1.666185
1992-02-13,125.499996,126.500004,121.50,122.499996,97356800,1.722428
1992-02-12,118.625004,126.75,118.625004,125.750004,83340800,1.768125
1992-02-11,124.250004,124.749996,121.50,122.499996,41078400,1.722428
1992-02-10,125.625,126.00,122.000004,124.50,41369600,1.750549
1992-02-07,126.249996,127.50,123.999996,125.750004,36499200,1.768125
1992-02-06,126.500004,129.00,125.750004,126.249996,62355200,1.775155
1992-02-05,124.749996,128.499996,123.500004,127.250004,71212800,1.789216
1992-02-04,125.25,126.00,122.499996,124.50,58438400,1.750549
1992-02-03,118.250004,125.499996,117.500004,125.000004,80265600,1.75758
1992-01-31,123.500004,123.75,119.750004,120.249996,49948800,1.690791
1992-01-30,124.50,124.749996,121.50,123.500004,41923200,1.736489
1992-01-29,122.499996,125.750004,121.749996,124.50,97344000,1.750549
1992-01-28,120.999996,121.749996,116.000004,120.75,95539200,1.697822
1992-01-27,124.749996,125.499996,120.500004,120.624996,46233600,1.696064
1992-01-24,124.50,125.499996,123.999996,124.625004,37756800,1.752307
1992-01-23,125.499996,129.375,123.75,125.000004,75590400,1.75758
1992-01-22,120.00,125.499996,119.000004,125.499996,56131200,1.76461
1992-01-21,122.25,123.00,116.000004,119.375004,120019200,1.678489
1992-01-20,127.250004,127.250004,122.499996,122.499996,58860800,1.722428
1992-01-17,127.749996,129.500004,123.75,126.500004,85027200,1.778671
1992-01-16,131.25,132.00,127.50,127.749996,58761600,1.796246
1992-01-15,128.750004,133.250004,128.25,131.499996,65292800,1.848974
1992-01-14,127.50,128.499996,126.00,128.25,44006400,1.803277
1992-01-13,123.999996,128.874996,122.750004,127.125,52803200,1.787458
1992-01-10,126.999996,127.749996,123.999996,125.25,64640000,1.761095
1992-01-09,124.250004,129.00,123.999996,127.250004,88348800,1.789216
1992-01-08,119.000004,125.750004,118.749996,124.250004,90761600,1.747034
1992-01-07,116.499996,120.249996,115.749996,120.00,64361600,1.687276
1992-01-06,113.25,117.75,112.374996,116.499996,63056000,1.638064
1992-01-03,114.00,114.249996,111.75,113.000004,38246400,1.588852
1992-01-02,110.750004,114.75,109.50,114.00,74265600,1.602913
1991-12-31,110.750004,111.999996,108.75,111.249996,40512000,1.564246
1991-12-30,110.499996,111.249996,109.50,110.750004,35523200,1.557216
1991-12-27,108.249996,111.500004,107.750004,110.375004,36656000,1.551943
1991-12-26,106.250004,108.249996,105.75,107.874996,24326400,1.516791
1991-12-24,106.749996,107.499996,105.999996,106.250004,23993600,1.493943
1991-12-23,103.250004,106.749996,102.500004,106.749996,46112000,1.500973
1991-12-20,104.000004,105.00,102.249996,103.250004,35356800,1.451761
1991-12-19,102.375,103.250004,101.25,102.75,38115200,1.44473
1991-12-18,102.00,103.250004,101.25,102.875004,33561600,1.446488
1991-12-17,102.00,103.50,100.250004,101.874996,27478400,1.432427
1991-12-16,102.00,102.249996,100.749996,102.125004,27225600,1.435943
1991-12-13,102.249996,102.75,101.499996,102.00,26192000,1.434185
1991-12-12,101.000004,103.250004,100.50,102.00,36979200,1.434185
1991-12-11,102.125004,102.75,99.500004,100.749996,39132800,1.416609
1991-12-10,102.00,102.00,99.999996,101.750004,46252800,1.43067
1991-12-09,103.250004,103.749996,101.25,102.00,57718400,1.434185
1991-12-06,101.499996,105.249996,101.000004,104.25,51580800,1.465821
1991-12-05,101.750004,102.249996,100.749996,101.750004,24892800,1.43067
1991-12-04,101.750004,102.999996,99.999996,102.00,36297600,1.434185
1991-12-03,101.000004,102.75,99.500004,101.375004,64995200,1.425397
1991-12-02,96.249996,101.499996,96.00,101.25,55852800,1.423639
1991-11-29,94.750002,97.749996,94.750002,97.250004,20524800,1.367397
1991-11-27,94.249998,95.500002,94.000002,95.25,15008000,1.339276
1991-11-26,96.125004,96.249996,92.749998,94.50,58809600,1.32873
1991-11-25,95.749998,96.999996,95.25,95.625,33724800,1.344548
1991-11-22,96.999996,97.50,95.25,96.00,38102400,1.349821
1991-11-21,96.249996,97.250004,95.749998,97.250004,35558400,1.367397
1991-11-20,96.999996,97.50,96.00,96.500004,36441600,1.356851
1991-11-19,96.249996,97.374996,94.249998,96.249996,71974400,1.353336
1991-11-18,95.25,97.749996,94.999998,97.250004,72432000,1.367397
1991-11-15,99.00,100.50,94.750002,94.999998,71590400,1.33576
1991-11-14,101.499996,101.499996,98.750004,99.249996,44371200,1.395518
1991-11-13,99.500004,101.750004,98.750004,101.000004,57523200,1.420124
1991-11-12,98.25,100.749996,98.000004,99.875004,80035200,1.404306
1991-11-11,96.00,98.000004,95.625,97.50,40563200,1.370912
1991-11-08,94.999998,96.75,94.999998,95.25,36492800,1.339276
1991-11-07,95.500002,95.749998,94.50,94.750002,20892800,1.332245
1991-11-06,94.000002,95.500002,93.250002,95.25,38307200,1.339276
1991-11-05,91.249998,94.50,91.000002,93.75,51737600,1.318185
1991-11-04,92.25,92.500002,90.75,91.000002,28838400,1.279518
1991-11-01,93.499998,93.75,91.999998,92.625,34294400,1.302366
1991-10-31,94.50,95.25,93.250002,93.874998,41091200,1.319942
1991-10-30,90.75,94.750002,90.75,94.50,65590400,1.32873
1991-10-29,90.250002,90.75,89.749998,90.75,36521600,1.276003
1991-10-28,89.500002,90.250002,87.75,90.250002,37952000,1.268972
1991-10-25,90.250002,90.75,89.25,89.500002,28080000,1.258427
1991-10-24,90.499998,90.499998,89.25,90.250002,26940800,1.268972
1991-10-23,91.750002,91.999998,89.749998,90.250002,36723200,1.268972
1991-10-22,91.50,92.749998,91.249998,91.375002,32496000,1.284791
1991-10-21,90.00,91.50,89.749998,91.000002,28704000,1.279518
1991-10-18,90.00,91.249998,89.749998,90.00,37843200,1.265457
1991-10-17,90.75,90.75,88.50,89.25,95561600,1.254912
1991-10-16,91.50,91.50,89.875002,90.75,100198400,1.276003
1991-10-15,92.25,92.25,90.75,91.375002,57852800,1.284791
1991-10-14,90.00,92.25,90.00,92.25,50624000,1.297094
1991-10-11,90.75,91.000002,87.75,89.625,69920000,1.260185
1991-10-10,90.499998,90.499998,88.50,89.749998,42048000,1.261942
1991-10-09,89.500002,91.249998,89.25,89.500002,60931200,1.258427
1991-10-08,88.000002,89.500002,88.000002,89.25,37708800,1.254912
1991-10-07,87.250002,88.875,86.749998,88.50,27187200,1.244366
1991-10-04,88.000002,88.999998,87.499998,88.125,26457600,1.239094
1991-10-03,86.500002,88.249998,86.25,87.499998,34630400,1.230306
1991-10-02,88.50,90.499998,86.25,87.00,67219200,1.223275
1991-10-01,88.999998,89.25,88.000002,88.875,19625600,1.249639
1991-09-30,88.249998,89.500002,87.00,88.999998,27699200,1.251397
1991-09-27,89.500002,89.500002,87.75,88.249998,33273600,1.240851
1991-09-26,87.499998,90.00,87.250002,89.25,48000000,1.254912
1991-09-25,88.000002,88.375002,86.500002,87.75,25766400,1.233821
1991-09-24,85.249998,88.249998,85.249998,88.000002,47625600,1.237336
1991-09-23,86.25,86.500002,84.499998,84.874998,49769600,1.193396
1991-09-20,86.749998,87.00,85.999998,86.500002,30316800,1.216245
1991-09-19,85.000002,87.250002,84.75,86.25,51363200,1.21273
1991-09-18,84.00,85.50,83.749998,84.75,26940800,1.191639
1991-09-17,82.750002,84.75,82.000002,84.499998,23366400,1.188124
1991-09-16,82.999998,83.500002,82.249998,82.999998,21686400,1.167033
1991-09-13,85.50,85.750002,82.50,82.999998,51360000,1.167033
1991-09-12,82.999998,85.750002,82.999998,85.624998,53808000,1.203942
1991-09-11,80.500002,82.249998,80.500002,82.000002,64032000,1.152972
1991-09-10,82.000002,82.50,79.999998,79.999998,65936000,1.124851
1991-09-09,80.749998,81.499998,80.25,80.749998,31913600,1.135396
1991-09-06,81.00,82.249998,80.25,80.749998,50787200,1.135396
1991-09-05,82.999998,82.999998,79.999998,80.500002,58457600,1.131881
1991-09-04,83.25,83.500002,81.00,82.624998,38467200,1.16176
1991-09-03,85.000002,85.000002,82.50,83.125002,33494400,1.16879
1991-08-30,85.750002,86.25,84.499998,85.249998,22032000,1.198669
1991-08-29,85.999998,86.500002,85.000002,85.750002,27974400,1.2057
1991-08-28,84.75,86.749998,84.499998,85.624998,41558400,1.203942
1991-08-27,84.75,85.000002,84.00,84.75,34204800,1.191639
1991-08-26,84.75,85.249998,83.500002,85.249998,44134400,1.198669
1991-08-23,84.00,86.500002,84.00,85.249998,43161600,1.198669
1991-08-22,84.250002,85.249998,83.25,84.00,43625600,1.181093
1991-08-21,82.000002,84.499998,81.75,84.00,73212800,1.181093
1991-08-20,80.625,81.874998,79.999998,80.500002,57324800,1.131881
1991-08-19,77.500002,81.250002,76.999998,80.25,85424000,1.128366
1991-08-16,80.749998,82.375002,80.25,81.75,52073600,1.149457
1991-08-15,82.50,83.25,81.00,81.499998,45459200,1.145942
1991-08-14,82.750002,83.500002,82.000002,82.50,67008000,1.160002
1991-08-13,83.749998,83.749998,82.249998,82.50,94496000,1.160002
1991-08-12,79.750002,83.749998,79.750002,82.999998,56899200,1.167033
1991-08-09,78.75,82.000002,78.250002,80.749998,114806400,1.135396
1991-08-08,76.000002,79.249998,76.000002,79.000002,91852800,1.11079
1991-08-07,74.749998,76.50,74.500002,76.000002,69235200,1.068608
1991-08-06,72.250002,75.00,72.250002,74.500002,53097600,1.047517
1991-08-05,73.249998,73.249998,71.749998,72.250002,28252800,1.015881
1991-08-02,73.750002,74.749998,73.249998,73.249998,81369600,1.029942
1991-08-01,73.750002,73.999998,73.000002,73.249998,53942400,1.029942
1991-07-31,73.000002,73.999998,72.75,73.50,111628800,1.033457
1991-07-30,70.50,73.000002,69.75,72.75,78038400,1.022911
1991-07-29,70.999998,71.25,68.749998,70.249998,136467200,0.98776
1991-07-26,67.000002,71.749998,66.75,70.999998,149292800,0.998305
1991-07-25,67.000002,67.999998,65.875002,66.00,90211200,0.928002
1991-07-24,67.000002,67.249998,64.999998,65.500002,54320000,0.920972
1991-07-23,67.999998,68.25,66.499998,66.499998,35596800,0.935032
1991-07-22,66.75,68.749998,66.499998,67.50,35136000,0.949093
1991-07-19,67.50,67.999998,66.00,67.750002,24441600,0.952608
1991-07-18,67.999998,69.250002,66.75,67.000002,25654400,0.942063
1991-07-17,65.749998,67.750002,64.999998,67.750002,40524800,0.952608
1991-07-16,70.000002,70.000002,67.50,67.50,42732800,0.949093
1991-07-15,68.749998,70.249998,68.500002,69.874998,36761600,0.982487
1991-07-12,67.000002,68.500002,66.00,67.999998,35174400,0.956123
1991-07-11,65.749998,66.75,64.999998,66.250002,51148800,0.931517
1991-07-10,68.25,68.749998,64.999998,65.25,67308800,0.917457
1991-07-09,67.50,68.749998,66.499998,67.875,76947200,0.954366
1991-07-08,60.75,67.249998,60.499998,67.000002,109184000,0.942063
1991-07-05,63.75,63.75,61.50,61.750002,78758400,0.868244
1991-07-03,64.50,64.999998,61.750002,64.000002,191628800,0.899881
1991-07-02,71.25,72.250002,67.999998,68.125002,43920000,0.957881
1991-07-01,68.749998,71.625,67.750002,71.374998,72387200,1.003578
1991-06-28,67.750002,68.749998,65.500002,68.125002,61526400,0.957881
1991-06-27,67.750002,68.25,66.75,67.999998,56508800,0.956123
1991-06-26,99.00,101.499999,98.250003,100.750002,96636800,0.944406
1991-06-25,99.249999,100.250004,98.000004,98.750001,97228800,0.925659
1991-06-24,101.000001,101.499999,97.499997,98.124999,79692800,0.9198
1991-06-21,101.25,103.000002,101.25,102.249996,67680000,0.958467
1991-06-20,101.000001,101.749998,99.00,100.750002,187996800,0.944406
1991-06-19,109.750002,109.750002,103.000002,103.374996,157036800,0.969012
1991-06-18,113.249997,113.499996,109.750002,111.500004,46848000,1.045174
1991-06-17,113.750004,114.75,112.50,113.499996,29417600,1.063921
1991-06-14,111.249996,113.750004,110.999997,113.499996,46358400,1.063921
1991-06-13,110.999997,112.250001,110.499999,110.999997,38000000,1.040487
1991-06-12,110.749998,112.250001,110.25,111.125001,51065600,1.041659
1991-06-11,110.999997,112.999998,110.499999,110.625003,41846400,1.036972
1991-06-10,110.25,110.999997,109.750002,110.499999,29494400,1.0358
1991-06-07,109.750002,110.25,108.749997,110.25,51984000,1.033457
1991-06-06,112.749999,112.999998,110.499999,111.125001,32678400,1.041659
1991-06-05,112.50,114.250002,112.000002,112.000002,41385600,1.049861
1991-06-04,112.000002,113.499996,110.499999,112.999998,35033600,1.059235
1991-06-03,109.500003,112.250001,108.999996,112.000002,46947200,1.049861
1991-05-31,110.499999,110.999997,108.00,109.750002,81782400,1.02877
1991-05-30,110.124996,111.750003,108.999996,110.25,61833600,1.033457
1991-05-29,111.249996,112.000002,109.750002,110.25,64198400,1.033457
1991-05-28,110.499999,111.750003,110.000001,110.749998,43939200,1.038144
1991-05-24,110.000001,112.50,109.500003,110.000001,67929600,1.031113
1991-05-23,107.000004,109.750002,107.000004,109.500003,67750400,1.026426
1991-05-22,102.750003,106.749996,102.249996,106.749996,88780800,1.000649
1991-05-21,99.749997,103.250001,99.499998,101.999997,83568000,0.956123
1991-05-20,99.499998,99.999996,97.749996,99.125004,65936000,0.929174
1991-05-17,99.00,99.499998,98.000004,99.249999,44812800,0.930345
1991-05-16,99.249999,99.999996,98.500002,99.375003,70243200,0.931517
1991-05-15,100.250004,100.500003,96.624996,98.000004,111158400,0.918628
1991-05-14,102.624999,103.250001,100.750002,101.25,58812800,0.949093
1991-05-13,103.250001,103.749999,101.25,103.124997,68745600,0.966669
1991-05-10,106.249998,107.000004,101.999997,102.750003,52070400,0.963154
1991-05-09,103.250001,105.999999,102.750003,105.75,76294400,0.991275
1991-05-08,101.000001,103.250001,100.250004,103.000002,57590400,0.965497
1991-05-07,103.250001,103.749999,101.25,101.25,50902400,0.949093
1991-05-06,100.500003,103.250001,100.250004,102.750003,44755200,0.963154
1991-05-03,100.500003,101.25,99.749997,101.25,23043200,0.949093
1991-05-02,101.25,102.500004,100.250004,100.500003,66886400,0.942063
1991-05-01,98.500002,100.750002,96.999999,100.750002,111628800,0.944406
1991-04-30,97.749996,99.249999,96.000003,99.00,115174400,0.928002
1991-04-29,101.25,101.499999,97.749996,97.749996,71254400,0.916285
1991-04-26,100.250004,102.249996,98.750001,100.750002,88371200,0.944406
1991-04-25,102.500004,103.749999,100.500003,100.750002,65705600,0.944406
1991-04-24,101.499999,104.750004,100.500003,103.000002,82128000,0.965497
1991-04-23,102.249996,103.000002,100.500003,101.625003,103910400,0.952608
1991-04-22,105.999999,106.249998,101.749998,102.125001,139708800,0.957295
1991-04-19,106.249998,109.500003,105.000003,107.250003,96585600,1.005336
1991-04-18,111.249996,112.000002,108.00,110.000001,88083200,1.031113
1991-04-17,114.000003,117.499998,111.125001,111.500004,128380800,1.045174
1991-04-16,113.750004,114.500001,110.000001,112.250001,81331200,1.052204
1991-04-15,105.999999,114.250002,105.000003,113.750004,88819200,1.066265
1991-04-12,109.500003,110.000001,103.749999,107.250003,176729600,1.005336
1991-04-11,108.499998,111.500004,108.00,110.999997,47936000,1.040487
1991-04-10,109.750002,110.25,105.500001,107.500002,74336000,1.007679
1991-04-09,111.500004,113.249997,109.750002,110.25,60768000,1.033457
1991-04-08,110.000001,113.249997,109.500003,111.375,46524800,1.044002
1991-04-05,114.000003,114.250002,108.999996,110.000001,108912000,1.031113
1991-04-04,114.000003,116.750001,112.749999,113.750004,73846400,1.066265
1991-04-03,112.749999,116.750001,112.749999,113.750004,91776000,1.066265
1991-04-02,107.500002,112.50,106.749996,112.250001,96252800,1.052204
1991-04-01,105.999999,107.750001,104.499996,106.749996,59203200,1.000649
1991-03-28,107.250003,108.249999,105.999999,106.125003,30489600,0.99479
1991-03-27,105.000003,109.250004,105.000003,107.750001,91932800,1.010022
1991-03-26,98.750001,105.250002,98.750001,105.124998,89926400,0.985416
1991-03-25,94.000002,98.750001,94.000002,98.250003,59820800,0.920972
1991-03-22,94.50,95.499996,92.999997,93.750003,95686400,0.87879
1991-03-21,99.499998,100.750002,94.000002,94.749999,119187200,0.888164
1991-03-20,99.00,101.000001,98.750001,99.00,83216000,0.928002
1991-03-19,98.250003,101.000001,96.75,99.00,92505600,0.928002
1991-03-18,96.250002,99.749997,96.000003,99.249999,66214400,0.930345
1991-03-15,98.250003,98.750001,96.250002,96.624996,76928000,0.905739
1991-03-14,101.499999,101.499999,96.999999,98.000004,100214400,0.918628
1991-03-13,96.000003,101.124996,96.000003,100.500003,110265600,0.942063
1991-03-12,98.250003,98.874996,95.625,95.750004,152883200,0.897537
1991-03-11,101.749998,102.500004,97.749996,99.249999,160966400,0.930345
1991-03-08,104.499996,105.999999,101.749998,102.500004,134697600,0.96081
1991-03-07,104.249997,107.500002,103.50,103.999998,165388800,0.974871
1991-03-06,112.50,112.999998,106.749996,107.250003,101088000,1.005336
1991-03-05,107.250003,112.50,107.000004,111.500004,76352000,1.045174
1991-03-04,105.75,107.500002,104.499996,107.000004,47020800,1.002992
1991-03-01,103.000002,106.249998,101.999997,105.75,77721600,0.991275
1991-02-28,105.999999,106.249998,103.250001,103.749999,55008000,0.972527
1991-02-27,102.249996,105.75,101.25,105.250002,87670400,0.986588
1991-02-26,101.499999,102.500004,100.500003,101.749998,55539200,0.95378
1991-02-25,103.250001,103.999998,101.499999,103.000002,88521600,0.965497
1991-02-22,99.749997,104.499996,99.749997,102.249996,105340800,0.958467
1991-02-21,103.000002,103.50,99.999996,99.999996,68275200,0.937376
1991-02-20,101.749998,103.999998,101.499999,102.750003,52550400,0.963154
1991-02-19,102.249996,103.50,101.499999,102.500004,66560000,0.96081
1991-02-15,101.499999,104.249997,101.25,103.250001,115449600,0.96784
1991-02-14,105.250002,105.500001,99.00,100.750002,133702400,0.944406
1991-02-13,102.500004,105.624996,101.749998,105.500001,95491200,0.988931
1991-02-12,103.250001,104.750004,102.500004,103.250001,96204800,0.96784
1991-02-11,104.125002,104.499996,102.249996,104.249997,152336000,0.977214
1991-02-08,103.000002,104.750004,101.749998,103.999998,74230400,0.974871
1991-02-07,106.249998,108.999996,102.249996,103.000002,133462400,0.965497
1991-02-06,101.000001,106.499997,100.500003,105.75,106348800,0.991275
1991-02-05,99.249999,101.999997,98.000004,101.25,88736000,0.949093
1991-02-04,99.999996,100.750002,98.000004,99.125004,88233600,0.929174
1991-02-01,99.00,101.000001,97.249998,99.749997,117878400,0.935032
1991-01-31,96.500001,99.499998,96.000003,98.124999,111417600,0.9198
1991-01-30,92.499999,96.500001,91.500003,96.250002,148582400,0.902224
1991-01-29,92.25,94.374996,90.00,92.499999,146979200,0.867073
1991-01-28,89.000004,94.000002,89.000004,92.25,130985600,0.864729
1991-01-25,90.749997,90.999996,89.000004,89.500002,86889600,0.838951
1991-01-24,89.250003,90.875001,88.749996,90.499998,86083200,0.848325
1991-01-23,88.249998,90.249999,88.249998,89.000004,77081600,0.834264
1991-01-22,89.624997,90.999996,87.374997,88.875,113715200,0.833093
1991-01-21,84.624999,90.00,84.624999,89.500002,154512000,0.838951
1991-01-18,82.500003,85.50,82.250004,85.250001,103030400,0.799113
1991-01-17,85.999998,86.249997,83.749998,83.999997,163526400,0.787396
1991-01-16,78.500001,82.874997,78.250002,82.250004,139913600,0.770992
1991-01-15,76.749999,79.499997,76.749999,78.374997,83436800,0.734668
1991-01-14,77.249997,77.499996,75.500004,76.749999,58656000,0.719436
1991-01-11,78.500001,78.999999,76.749999,78.000003,62006400,0.731153
1991-01-10,74.25,78.75,74.25,78.250002,123888000,0.733497
1991-01-09,74.000001,75.750003,73.500003,74.000001,115622400,0.693658
1991-01-08,74.749998,75.249996,72.999996,73.500003,76438400,0.688971
1991-01-07,75.249996,77.750004,74.749998,74.875002,87552000,0.70186
1991-01-04,74.999997,76.50,74.999997,75.874998,58483200,0.711234
1991-01-03,74.749998,76.000002,74.749998,75.249996,52822400,0.705375
1991-01-02,74.999997,75.249996,74.749998,74.749998,38105600,0.700688
1990-12-31,74.999997,75.249996,74.499999,75.249996,23702400,0.705375
1990-12-28,74.499999,75.249996,74.25,74.999997,20265600,0.703032
1990-12-27,74.999997,75.249996,74.499999,74.749998,22627200,0.700688
1990-12-26,75.249996,75.750003,74.499999,74.999997,16214400,0.703032
1990-12-24,75.500004,75.500004,74.749998,75.249996,13548800,0.705375
1990-12-21,75.750003,76.000002,75.249996,75.750003,33468800,0.710062
1990-12-20,74.25,76.000002,74.000001,75.500004,46992000,0.707719
1990-12-19,75.375,75.750003,74.749998,74.875002,34262400,0.70186
1990-12-18,74.499999,75.750003,74.25,75.249996,51872000,0.705375
1990-12-17,72.999996,74.25,72.499998,74.000001,27286400,0.693658
1990-12-14,72.999996,74.25,72.499998,73.624998,48633600,0.690143
1990-12-13,72.999996,73.500003,71.750001,72.749997,50707200,0.681941
1990-12-12,71.750001,72.749997,70.500001,72.499998,71558400,0.679597
1990-12-11,73.250004,74.499999,72.00,72.125004,61766400,0.676082
1990-12-10,73.250004,75.375,72.749997,74.000001,55526400,0.693658
1990-12-07,74.25,75.249996,72.249999,74.25,81920000,0.696001
1990-12-06,76.250001,76.749999,74.000001,74.749998,108201600,0.700688
1990-12-05,74.499999,75.750003,74.25,75.249996,68630400,0.705375
1990-12-04,73.500003,75.249996,72.999996,74.499999,54547200,0.698345
1990-12-03,73.250004,74.499999,72.749997,73.874997,68240000,0.692486
1990-11-30,71.249999,74.25,70.500001,72.249999,72163200,0.677254
1990-11-29,70.249998,71.249999,69.75,71.249999,65865600,0.66788
1990-11-28,72.249999,72.749997,70.249998,70.375002,77619200,0.659678
1990-11-27,70.500001,72.249999,69.75,71.875,63417600,0.673739
1990-11-26,68.50,70.500001,67.749999,70.249998,47577600,0.658506
1990-11-23,69.250002,70.249998,68.50,68.75,22060800,0.644446
1990-11-21,67.999998,68.999999,67.000002,68.75,60739200,0.644446
1990-11-20,69.250002,70.500001,68.125002,68.250001,68864000,0.639759
1990-11-19,67.999998,69.75,67.999998,69.500001,45552000,0.651476
1990-11-16,67.50,68.75,67.250001,67.999998,67075200,0.637415
1990-11-15,68.999999,69.250002,67.250001,67.874999,63129600,0.636244
1990-11-14,68.50,69.999999,68.250001,69.500001,59721600,0.651476
1990-11-13,68.75,69.500001,67.749999,68.625,67654400,0.643274
1990-11-12,66.000001,69.250002,66.000001,68.874999,87657600,0.645618
1990-11-09,64.750002,65.499999,64.499999,64.750002,43344000,0.606951
1990-11-08,63.499998,64.750002,63.00,63.499998,43462400,0.595234
1990-11-07,63.750001,64.750002,63.499998,63.750001,63100800,0.597577
1990-11-06,65.749998,66.50,63.499998,64.25,59212800,0.602264
1990-11-05,65.25,66.000001,64.750002,65.624999,50700800,0.615153
1990-11-02,63.499998,65.749998,63.249999,65.000001,74764800,0.609294
1990-11-01,63.00,64.25,62.750001,63.499998,49440000,0.595234
1990-10-31,64.499999,65.25,63.750001,63.750001,61200000,0.597577
1990-10-30,62.500002,64.25,62.00,63.875001,52563200,0.598749
1990-10-29,63.750001,64.25,62.00,62.500002,67881600,0.58586
1990-10-26,63.750001,64.499999,63.249999,63.374999,59126400,0.594062
1990-10-25,65.499999,66.25,64.00,64.750002,51497600,0.606951
1990-10-24,63.499998,65.499999,63.249999,65.375,54732800,0.612809
1990-10-23,63.750001,65.749998,63.249999,64.25,71884800,0.602264
1990-10-22,62.00,64.750002,61.75,64.00,80294400,0.59992
1990-10-19,62.00,63.249999,60.500001,62.00,170336000,0.581173
1990-10-18,57.000001,61.500001,56.749998,61.124999,123737600,0.572971
1990-10-17,54.750001,56.749998,53.500002,56.499999,135820800,0.529617
1990-10-16,56.749998,57.624999,54.00,54.625002,300886400,0.512042
1990-10-15,57.749999,58.000002,55.499999,56.499999,130332800,0.529617
1990-10-12,58.50,58.749999,54.00,57.000001,109251200,0.534304
1990-10-11,59.75,60.250002,57.000001,58.000002,83811200,0.543678
1990-10-10,62.00,62.249999,58.999998,59.50,115593600,0.557739
1990-10-09,65.25,66.000001,62.500002,63.00,66374400,0.590547
1990-10-08,66.000001,66.50,64.499999,66.000001,38678400,0.618668
1990-10-05,63.00,65.749998,62.249999,64.750002,82099200,0.606951
1990-10-04,65.25,65.749998,64.00,64.125,69292800,0.601092
1990-10-03,65.499999,67.375,65.25,65.749998,57600000,0.616325
1990-10-02,68.250001,68.50,65.499999,65.875002,83465600,0.617496
1990-10-01,64.750002,67.50,64.499999,67.125001,131619200,0.629213
1990-09-28,58.250001,63.499998,58.000002,63.00,97980800,0.590547
1990-09-27,60.999999,61.500001,58.250001,59.250001,65724800,0.555395
1990-09-26,60.500001,60.75,59.50,60.250002,39267200,0.564769
1990-09-25,59.625,60.500001,58.749999,60.375001,53308800,0.565941
1990-09-24,59.50,59.999999,57.50,58.50,81436800,0.548365
1990-09-21,59.75,60.75,58.50,60.500001,79891200,0.567112
1990-09-20,61.500001,62.00,59.75,59.75,52444800,0.560082
1990-09-19,63.00,63.249999,61.75,62.00,52694400,0.581173
1990-09-18,60.625,62.374998,59.75,61.75,60636800,0.57883
1990-09-17,59.50,61.75,59.250001,60.75,70390400,0.569456
1990-09-14,57.000001,60.250002,56.375,59.75,67670400,0.560082
1990-09-13,58.000002,58.50,57.000001,57.50,49865600,0.538991
1990-09-12,56.25,57.749999,55.750002,57.375,75014400,0.537819
1990-09-11,56.000001,56.499999,54.499998,55.499999,78867200,0.520244
1990-09-10,58.749999,59.999999,55.750002,55.750002,74246400,0.522587
1990-09-07,57.000001,58.999998,56.499999,57.749999,53702400,0.541334
1990-09-06,58.000002,58.50,56.25,57.50,115616000,0.538991
1990-09-05,62.500002,63.00,58.50,58.999998,54675200,0.553052
1990-09-04,60.999999,62.500002,60.75,62.249999,47376000,0.583516
1990-08-31,59.999999,62.00,59.250001,61.500001,40736000,0.576486
1990-08-30,60.75,62.374998,59.999999,59.999999,65379200,0.562425
1990-08-29,62.500002,63.750001,59.999999,60.500001,77952000,0.567112
1990-08-28,60.250002,63.249999,59.999999,62.875,79824000,0.589375
1990-08-27,58.999998,61.249998,58.999998,60.75,110115200,0.569456
1990-08-24,52.249998,57.749999,52.249998,57.25,95443200,0.536648
1990-08-23,52.500001,53.750001,50.999999,51.75,107443200,0.485092
1990-08-22,55.00,55.499999,53.374998,53.750001,79232000,0.503839
1990-08-21,54.249999,54.750001,50.75,54.249999,165648000,0.508526
1990-08-20,60.250002,60.500001,55.499999,55.499999,113600000,0.520244
1990-08-17,60.999999,61.75,59.999999,60.250002,95225600,0.564769
1990-08-16,64.00,64.499999,61.75,61.75,53328000,0.57883
1990-08-15,64.750002,65.749998,64.25,64.25,51408000,0.602264
1990-08-14,65.25,65.875002,63.750001,64.25,33708800,0.602264
1990-08-13,63.750001,65.499999,63.249999,65.000001,53942400,0.609294
1990-08-10,65.125,65.749998,62.750001,64.499999,73184000,0.604607
1990-08-09,64.00,65.749998,63.249999,65.125,77052800,0.610466
1990-08-08,62.500002,64.00,62.00,63.499998,86259200,0.595234
1990-08-07,61.249998,62.249999,59.999999,61.249998,91065600,0.574143
1990-08-06,61.500001,62.00,58.50,60.500001,113184000,0.567112
1990-08-03,65.499999,65.749998,60.375001,63.249999,117177600,0.59289
1990-08-02,65.499999,66.749999,64.25,66.000001,91769600,0.618668
1990-08-01,66.25,67.250001,63.750001,66.749999,111113600,0.625698
1990-07-31,68.250001,68.625,66.000001,66.50,42307200,0.623355
1990-07-30,68.50,68.999999,65.749998,67.999998,87955200,0.637415
1990-07-27,68.50,69.999999,67.749999,68.999999,51017600,0.646789
1990-07-26,71.249999,74.000001,66.000001,68.75,303321600,0.644446
1990-07-25,69.999999,71.750001,68.75,71.500002,60147200,0.670224
1990-07-24,72.499998,72.499998,66.749999,69.500001,137100800,0.651476
1990-07-23,73.250004,74.000001,71.249999,72.00,74201600,0.674911
1990-07-20,76.999998,78.250002,72.999996,73.250004,87724800,0.686628
1990-07-19,75.375,76.749999,73.750002,76.749999,63132800,0.719436
1990-07-18,77.249997,77.750004,75.500004,76.000002,41849600,0.712406
1990-07-17,79.375002,79.499997,76.999998,77.750004,54473600,0.72881
1990-07-16,78.75,80.750001,78.500001,79.249998,48729600,0.74287
1990-07-13,77.750004,80.500002,77.499996,78.374997,93628800,0.734668
1990-07-12,75.249996,77.750004,75.249996,77.499996,89040000,0.726466
1990-07-11,74.000001,75.750003,73.250004,75.500004,28918400,0.707719
1990-07-10,74.25,74.999997,73.500003,73.750002,29696000,0.691315
1990-07-09,73.500003,74.749998,73.250004,74.25,37315200,0.696001
1990-07-06,72.125004,74.000001,71.750001,73.250004,41801600,0.686628
1990-07-05,71.500002,72.499998,70.75,72.249999,61852800,0.677254
1990-07-03,73.374999,73.500003,71.500002,72.00,79257600,0.674911
1990-07-02,76.000002,76.000002,73.624998,73.750002,35472000,0.691315
1990-06-29,76.50,76.50,75.249996,76.000002,34953600,0.712406
1990-06-28,76.625004,77.249997,76.124997,76.50,30051200,0.717092
1990-06-27,74.749998,76.50,74.499999,76.250001,35760000,0.714749
1990-06-26,75.249996,75.624999,74.499999,74.749998,50198400,0.700688
1990-06-25,75.624999,76.50,74.25,74.499999,68979200,0.698345
1990-06-22,77.249997,77.750004,75.500004,75.750003,34032000,0.710062
1990-06-21,77.499996,77.750004,76.000002,76.999998,34304000,0.721779
1990-06-20,75.375,77.750004,74.999997,77.625,39561600,0.727638
1990-06-19,74.749998,75.500004,73.750002,74.999997,41715200,0.703032
1990-06-18,75.750003,76.250001,74.499999,74.875002,52790400,0.70186
1990-06-15,74.499999,76.999998,74.499999,76.000002,51552000,0.712406
1990-06-14,76.50,76.749999,74.25,75.500004,58204800,0.707719
1990-06-13,75.874998,77.750004,75.125001,76.50,80265600,0.717092
1990-06-12,75.500004,76.000002,74.499999,75.874998,46656000,0.711234
1990-06-11,72.999996,75.500004,72.999996,74.875002,58236800,0.70186
1990-06-08,72.00,73.750002,71.500002,73.500003,63766400,0.688971
1990-06-07,73.250004,73.750002,71.00,72.00,90118400,0.674911
1990-06-06,73.250004,74.499999,72.499998,72.999996,86288000,0.684284
1990-06-05,77.249997,77.499996,72.749997,73.374999,80256000,0.687799
1990-06-04,74.875002,77.249997,74.000001,76.50,59158400,0.717092
1990-06-01,73.250004,75.249996,72.999996,75.125001,69065600,0.704204
1990-05-31,74.749998,75.500004,72.499998,72.999996,69436800,0.684284
1990-05-30,76.124997,76.50,74.749998,75.500004,65072000,0.707719
1990-05-29,74.25,75.500004,74.000001,75.249996,61478400,0.705375
1990-05-25,74.25,76.250001,74.000001,74.25,104688000,0.696001
1990-05-24,76.749999,78.75,76.000002,76.50,146649600,0.717092
1990-05-23,72.00,76.000002,71.875,75.874998,141180800,0.711234
1990-05-22,71.00,72.249999,68.999999,71.500002,142435200,0.670224
1990-05-21,68.75,72.249999,68.75,70.249998,159593600,0.658506
1990-05-18,64.624998,69.250002,64.499999,68.250001,101820800,0.639759
1990-05-17,64.750002,65.25,64.25,64.750002,41731200,0.606951
1990-05-16,64.499999,64.750002,63.499998,64.750002,38553600,0.606951
1990-05-15,65.499999,65.749998,64.25,64.750002,54118400,0.606951
1990-05-14,66.25,66.50,65.499999,65.749998,47232000,0.616325
1990-05-11,65.000001,66.000001,63.249999,65.499999,49164800,0.613981
1990-05-10,63.249999,65.000001,62.750001,64.499999,48800000,0.604607
1990-05-09,62.875,63.249999,62.00,62.750001,35164800,0.588203
1990-05-08,62.750001,63.499998,62.249999,62.750001,50822400,0.588203
1990-05-07,62.00,66.000001,61.500001,64.00,97347200,0.59992
1990-05-04,59.50,61.75,58.999998,61.75,47811200,0.57883
1990-05-03,58.50,59.75,58.250001,58.999998,45891200,0.553052
1990-05-02,57.25,58.50,57.25,58.250001,33264000,0.546021
1990-05-01,58.749999,58.749999,56.749998,57.125001,52473600,0.535476
1990-04-30,56.25,58.000002,55.750002,58.000002,51449600,0.543678
1990-04-27,57.125001,57.25,55.624998,56.25,57123200,0.527274
1990-04-26,58.50,58.749999,57.25,57.375,46294400,0.537819
1990-04-25,58.250001,58.749999,57.000001,58.000002,53868800,0.543678
1990-04-24,59.75,59.75,56.499999,58.000002,47913600,0.543678
1990-04-23,58.874999,59.50,57.25,58.999998,64876800,0.553052
1990-04-20,59.999999,60.500001,58.749999,59.250001,44659200,0.555395
1990-04-19,59.999999,61.249998,59.250001,59.50,58003200,0.557739
1990-04-18,61.625001,61.75,58.749999,60.625,97795200,0.568284
1990-04-17,60.625,63.00,59.75,62.00,66777600,0.581173
1990-04-16,60.999999,61.75,60.124998,60.75,39468800,0.569456
1990-04-12,121.749999,121.999998,119.999997,120.750003,48252800,0.565941
1990-04-11,118.500003,121.000002,118.250004,121.000002,70371200,0.567112
1990-04-10,114.624996,117.999996,114.500001,117.999996,45187200,0.553052
1990-04-09,113.750004,115.249998,113.750004,114.500001,31174400,0.536648
1990-04-06,114.75,115.249998,113.249997,114.250002,72876800,0.535476
1990-04-05,116.874996,117.125004,114.500001,114.500001,66368000,0.536648
1990-04-04,116.000004,118.750002,115.499997,117.00,79644800,0.548365
1990-04-03,112.749999,116.250003,112.50,116.000004,84643200,0.543678
1990-04-02,109.750002,112.374996,109.250004,111.500004,74057600,0.522587
1990-03-30,110.000001,110.999997,109.250004,110.749998,36691200,0.519072
1990-03-29,110.375004,112.749999,110.000001,110.499999,64784000,0.5179
1990-03-28,112.250001,112.250001,108.499998,110.999997,99532800,0.520244
1990-03-27,111.125001,112.999998,110.749998,112.50,52515200,0.527274
1990-03-26,110.499999,112.50,110.375004,111.500004,55929600,0.522587
1990-03-23,112.000002,113.249997,108.999996,110.25,53596800,0.516728
1990-03-22,113.499996,113.750004,110.25,111.249996,92419200,0.521415
1990-03-21,112.875003,115.499997,112.250001,113.249997,69840000,0.530789
1990-03-20,116.500002,116.750001,112.50,112.999998,92144000,0.529617
1990-03-19,113.750004,117.00,112.999998,116.500002,81171200,0.546021
1990-03-16,112.000002,115.249998,111.750003,114.000003,118899200,0.534304
1990-03-15,107.874996,111.750003,107.750001,110.999997,81676800,0.520244
1990-03-14,107.250003,108.749997,105.999999,107.874996,130966400,0.505597
1990-03-13,108.499998,108.999996,106.249998,106.249998,85203200,0.497981
1990-03-12,106.249998,108.749997,105.999999,108.249999,68873600,0.507355
1990-03-09,105.999999,108.00,105.250002,106.499997,75744000,0.499153
1990-03-08,103.000002,107.250003,101.749998,106.249998,88976000,0.497981
1990-03-07,104.750004,105.500001,102.750003,102.750003,47606400,0.481577
1990-03-06,104.750004,105.000003,102.500004,104.499996,68630400,0.489779
1990-03-05,103.50,105.75,102.249996,105.250002,75526400,0.493294
1990-03-02,100.250004,104.375001,100.125,103.749999,100208000,0.486264
1990-03-01,98.500002,101.749998,98.500002,99.999996,76867200,0.468688
1990-02-28,98.000004,99.749997,98.000004,98.750001,39312000,0.462829
1990-02-27,99.499998,99.499998,98.000004,98.000004,62019200,0.459314
1990-02-26,97.499997,99.999996,97.249998,99.249999,69219200,0.465173
1990-02-23,95.750004,97.749996,95.499996,97.499997,56851200,0.456971
1990-02-22,96.75,98.250003,96.250002,96.374997,60809600,0.451698
1990-02-21,98.750001,99.999996,95.750004,96.124998,103347200,0.450526
1990-02-20,97.749996,100.500003,96.999999,100.250004,132652800,0.46986
1990-02-16,98.250003,98.750001,97.749996,98.000004,70876800,0.459314
1990-02-15,94.999998,98.000004,94.999998,96.999999,89494400,0.454627
1990-02-14,95.249997,95.249997,94.50,94.999998,35868800,0.445253
1990-02-13,94.999998,95.249997,94.50,94.749999,58752000,0.444082
1990-02-12,94.50,95.499996,94.000002,94.749999,56086400,0.444082
1990-02-09,94.250001,94.749999,94.000002,94.50,62380800,0.44291
1990-02-08,93.624999,94.999998,93.249996,94.250001,95225600,0.441738
1990-02-07,93.500004,94.749999,92.999997,93.249996,134150400,0.437051
1990-02-06,94.000002,94.250001,92.25,94.000002,81964800,0.440567
1990-02-05,93.624999,94.250001,93.249996,94.250001,59731200,0.441738
1990-02-02,92.999997,95.499996,92.999997,93.750003,71395200,0.439395
1990-02-01,92.499999,94.250001,92.499999,93.750003,89193600,0.439395
1990-01-31,92.000001,92.499999,91.250004,92.499999,112937600,0.433536
1990-01-30,91.750002,92.499999,90.00,91.250004,73107200,0.427678
1990-01-29,91.500003,92.25,90.249999,91.500003,55078400,0.428849
1990-01-26,90.499998,91.250004,90.00,90.749997,68083200,0.425334
1990-01-25,91.500003,92.499999,90.499998,90.749997,112752000,0.425334
1990-01-24,87.999999,90.749997,87.124998,90.749997,180345600,0.425334
1990-01-23,90.999996,91.250004,89.250003,89.750001,139347200,0.420647
1990-01-22,94.000002,94.000002,90.499998,90.749997,167686400,0.425334
1990-01-19,95.249997,96.000003,93.500004,94.124997,99257600,0.441152
1990-01-18,89.624997,94.999998,89.500002,94.999998,292361600,0.445253
1990-01-17,87.999999,90.499998,87.000003,87.500001,97587200,0.410102
1990-01-16,85.50,89.250003,84.500004,88.749996,80092800,0.41596
1990-01-15,85.749999,87.000003,85.250001,86.125002,62467200,0.403657
1990-01-12,85.124997,87.250002,83.999997,86.125002,148908800,0.403657
1990-01-11,88.749996,89.500002,85.000002,86.499996,95772800,0.405415
1990-01-10,90.00,91.250004,88.125003,88.249998,103766400,0.413617
1990-01-09,90.999996,92.000001,90.249999,90.749997,70300800,0.425334
1990-01-08,89.500002,90.999996,88.499997,90.999996,58982400,0.426506
1990-01-05,91.500003,92.000001,89.500002,89.624997,69564800,0.420061
1990-01-04,89.250003,92.000001,88.749996,91.874997,125740800,0.430607
1990-01-03,89.500002,90.249999,88.499997,89.250003,113772800,0.418304
1990-01-02,87.250002,88.749996,86.125002,88.749996,53033600,0.41596
1989-12-29,85.50,88.249998,85.250001,87.000003,77628800,0.407758
1989-12-28,83.499999,85.749999,83.000001,85.250001,123091200,0.399556
1989-12-27,85.999998,87.000003,85.250001,86.249997,62796800,0.404243
1989-12-26,85.875003,86.375001,84.750003,85.50,23817600,0.400728
1989-12-22,83.499999,86.249997,82.750002,85.749999,54892800,0.4019
1989-12-21,82.750002,83.499999,81.249999,83.499999,55020800,0.391354
1989-12-20,81.249999,83.000001,80.750001,82.750002,111008000,0.387839
1989-12-19,78.250002,80.500002,77.750004,80.374998,70473600,0.376708
1989-12-18,77.249997,78.999999,76.999998,78.250002,78435200,0.366748
1989-12-15,78.250002,78.500001,74.999997,76.999998,107164800,0.36089
1989-12-14,78.999999,79.749996,78.000003,78.000003,61516800,0.365577
1989-12-13,80.750001,82.500003,79.249998,80.000004,95788800,0.37495
1989-12-12,83.749998,83.749998,80.500002,82.500003,93628800,0.386668
1989-12-11,84.750003,84.750003,81.999996,83.000001,103376000,0.389011
1989-12-08,85.50,85.999998,83.000001,84.750003,107625600,0.397213
1989-12-07,83.999997,86.249997,83.999997,85.50,40348800,0.400728
1989-12-06,86.499996,87.000003,84.500004,85.250001,57382400,0.399556
1989-12-05,86.750004,87.250002,85.999998,86.750004,44048000,0.406587
1989-12-04,85.000002,87.250002,84.375,86.249997,40534400,0.404243
1989-12-01,87.124998,87.75,84.874998,85.000002,52070400,0.398385
1989-11-30,83.999997,87.250002,83.749998,87.000003,111209600,0.407758
1989-11-29,87.500001,87.999999,84.249996,85.50,85894400,0.400728
1989-11-28,87.000003,88.249998,86.249997,87.000003,56662400,0.407758
1989-11-27,87.500001,87.75,85.749999,86.750004,37280000,0.406587
1989-11-24,88.875,89.000004,87.500001,87.624996,17971200,0.410688
1989-11-22,88.249998,88.499997,87.500001,88.249998,38230400,0.413617
1989-11-21,86.499996,88.499997,86.499996,88.125003,67116800,0.413031
1989-11-20,86.750004,86.750004,84.500004,86.499996,56937600,0.405415
1989-11-17,87.624996,88.249998,86.750004,86.874999,31651200,0.407173
1989-11-16,89.000004,89.250003,86.249997,87.500001,68054400,0.410102
1989-11-15,86.750004,89.250003,86.249997,88.499997,94492800,0.414789
1989-11-14,88.749996,89.250003,85.999998,86.499996,95241600,0.405415
1989-11-13,84.500004,88.249998,83.749998,88.125003,178905600,0.413031
1989-11-10,83.999997,85.000002,83.749998,84.500004,59168000,0.396041
1989-11-09,83.999997,84.500004,82.500003,83.749998,111526400,0.392526
1989-11-08,82.125,84.500004,81.999996,83.25,106486400,0.390183
1989-11-07,77.499996,82.374999,77.249997,81.00,131542400,0.379637
1989-11-06,78.250002,79.749996,76.50,77.249997,88025600,0.362061
1989-11-03,76.50,78.75,76.250001,78.250002,98755200,0.366748
1989-11-02,80.874996,80.874996,76.000002,76.250001,226051200,0.357375
1989-11-01,81.749997,83.000001,81.749997,82.125,74649600,0.38491
1989-10-31,80.250003,81.999996,80.000004,81.749997,56563200,0.383152
1989-10-30,78.000003,79.749996,77.874999,79.625001,45920000,0.373193
1989-10-27,77.750004,78.000003,76.250001,76.999998,97040000,0.36089
1989-10-26,78.75,80.250003,77.499996,77.750004,135459200,0.364405
1989-10-25,81.499998,82.750002,79.249998,79.749996,71481600,0.373779
1989-10-24,82.500003,82.500003,78.75,80.874996,157088000,0.379051
1989-10-23,84.750003,85.749999,82.500003,83.124996,60912000,0.389597
1989-10-20,83.999997,85.50,82.500003,85.250001,93542400,0.399556
1989-10-19,81.00,85.999998,80.250003,84.249996,179424000,0.39487
1989-10-18,78.875004,80.750001,78.500001,80.500002,134784000,0.377294
1989-10-17,75.249996,81.499998,74.25,78.624996,177206400,0.368506
1989-10-16,70.75,76.250001,68.999999,75.750003,253065600,0.355031
1989-10-13,77.750004,78.000003,72.999996,73.500003,102643200,0.344486
1989-10-12,80.000004,80.500002,78.250002,78.500001,58880000,0.36792
1989-10-11,80.250003,80.500002,78.999999,80.000004,106400000,0.37495
1989-10-10,82.500003,83.000001,80.750001,81.249999,68297600,0.380809
1989-10-09,79.499997,81.999996,78.999999,81.749997,58534400,0.383152
1989-10-06,79.625001,80.500002,78.250002,79.749996,87609600,0.373779
1989-10-05,75.500004,82.250004,75.249996,79.249998,284758400,0.371435
1989-10-04,68.999999,75.750003,68.50,75.500004,260019200,0.353859
1989-10-03,70.500001,70.500001,68.874999,68.999999,68918400,0.323395
1989-10-02,68.250001,69.999999,67.999998,69.625,50428800,0.326324
1989-09-29,67.999998,69.500001,67.749999,68.50,64323200,0.321051
1989-09-28,66.50,67.999998,66.50,67.999998,41427200,0.318708
1989-09-27,66.25,67.375,65.749998,66.624999,69235200,0.312263
1989-09-26,67.000002,67.50,66.50,67.250001,39987200,0.315193
1989-09-25,66.000001,67.999998,65.499999,67.000002,69939200,0.314021
1989-09-22,65.499999,66.000001,64.750002,66.000001,43948800,0.309334
1989-09-21,65.749998,66.749999,64.499999,65.499999,89350400,0.306991
1989-09-20,62.750001,65.000001,62.249999,65.000001,72128000,0.304647
1989-09-19,63.750001,64.00,62.500002,62.500002,49203200,0.29293
1989-09-18,62.500002,63.499998,62.500002,63.499998,39110400,0.297617
1989-09-15,64.00,64.499999,62.500002,62.750001,89148800,0.294102
1989-09-14,62.750001,64.499999,62.249999,63.750001,78163200,0.298789
1989-09-13,60.999999,63.499998,60.500001,62.249999,181020800,0.291758
1989-09-12,59.50,60.999999,59.250001,60.250002,67795200,0.282384
1989-09-11,58.749999,59.50,58.50,59.375001,27907200,0.278283
1989-09-08,58.000002,59.50,57.749999,58.999998,39785600,0.276526
1989-09-07,58.999998,59.250001,58.000002,58.250001,41904000,0.273011
1989-09-06,59.75,59.999999,58.749999,59.250001,42377600,0.277698
1989-09-05,59.75,60.999999,59.625,59.999999,93340800,0.281213
1989-09-01,58.999998,60.250002,58.749999,59.874999,44409600,0.280627
1989-08-31,59.50,59.75,58.749999,58.749999,14198400,0.275354
1989-08-30,58.749999,59.625,58.50,59.250001,40377600,0.277698
1989-08-29,59.874999,59.999999,58.375,58.50,54416000,0.274182
1989-08-28,58.749999,59.50,58.250001,59.125002,28540800,0.277112
1989-08-25,58.749999,59.250001,57.749999,58.874999,85145600,0.27594
1989-08-24,59.874999,60.500001,58.250001,58.999998,92764800,0.276526
1989-08-23,58.625,59.625,58.000002,59.250001,46092800,0.277698
1989-08-22,56.000001,58.749999,56.000001,58.375,64771200,0.273597
1989-08-21,57.50,57.874998,56.000001,56.125,32096000,0.263051
1989-08-18,56.499999,57.749999,56.499999,57.50,24912000,0.269496
1989-08-17,55.750002,56.749998,55.25,56.499999,39958400,0.264809
1989-08-16,57.749999,58.000002,55.499999,55.875001,46668800,0.261879
1989-08-15,57.000001,58.000002,56.624999,57.50,17856000,0.269496
1989-08-14,57.749999,57.749999,57.000001,57.000001,68988800,0.267152
1989-08-11,58.999998,59.50,57.749999,57.749999,61472000,0.270667
1989-08-10,58.999998,58.999998,58.250001,58.50,48339200,0.274182
1989-08-09,58.874999,59.999999,58.749999,58.749999,113772800,0.275354
1989-08-08,57.50,59.250001,57.50,58.999998,110547200,0.276526
1989-08-07,57.749999,58.000002,57.000001,57.749999,93571200,0.270667
1989-08-04,54.750001,57.50,54.499998,57.000001,178128000,0.267152
1989-08-03,54.374999,55.25,54.249999,55.00,27590400,0.257778
1989-08-02,54.00,54.750001,54.00,54.249999,28368000,0.254263
1989-08-01,54.750001,55.25,54.00,54.249999,62134400,0.254263
1989-07-31,54.00,55.00,53.750001,54.750001,33334400,0.256607
1989-07-28,54.00,54.499998,53.249999,54.249999,29216000,0.254263
1989-07-27,53.625001,54.00,53.249999,53.750001,45561600,0.25192
1989-07-26,52.75,53.249999,51.999999,52.75,123638400,0.247233
1989-07-25,55.00,57.000001,51.500001,51.999999,326028800,0.243718
1989-07-24,54.750001,55.750002,54.249999,55.25,38361600,0.25895
1989-07-21,53.00,56.499999,52.75,55.25,99763200,0.25895
1989-07-20,54.249999,55.25,53.500002,53.500002,44524800,0.250748
1989-07-19,54.00,54.499998,53.249999,54.125,29763200,0.253677
1989-07-18,53.249999,54.249999,53.249999,53.500002,42982400,0.250748
1989-07-17,52.75,53.500002,52.500001,53.249999,31289600,0.249576
1989-07-14,53.249999,53.500002,51.75,52.75,42768000,0.247233
1989-07-13,53.124999,53.750001,52.500001,53.00,33408000,0.248405
1989-07-12,53.00,53.500002,51.999999,53.249999,52156800,0.249576
1989-07-11,54.875001,55.499999,53.249999,53.500002,43488000,0.250748
1989-07-10,53.750001,55.00,53.500002,54.875001,27257600,0.257192
1989-07-07,52.75,54.249999,52.625001,53.500002,41456000,0.250748
1989-07-06,55.750002,56.000001,52.375002,52.75,94780800,0.247233
1989-07-05,54.499998,55.499999,54.00,55.25,26537600,0.25895
1989-07-03,53.124999,54.249999,53.124999,54.00,14688000,0.253091
1989-06-30,51.999999,53.500002,51.250002,53.00,67248000,0.248405
1989-06-29,52.875,52.875,51.250002,51.999999,77196800,0.243718
1989-06-28,54.00,54.00,51.999999,52.75,57456000,0.247233
1989-06-27,54.750001,55.25,53.750001,53.875,35897600,0.252506
1989-06-26,55.25,55.499999,54.249999,54.750001,30240000,0.256607
1989-06-23,55.499999,56.000001,55.25,55.374999,33536000,0.259536
1989-06-22,55.25,55.499999,55.00,55.499999,36070400,0.260122
1989-06-21,53.249999,56.000001,53.249999,55.00,80496000,0.257778
1989-06-20,56.499999,56.749998,54.499998,54.499998,45804800,0.255435
1989-06-19,57.000001,57.000001,55.499999,56.499999,27158400,0.264809
1989-06-16,56.624999,57.000001,56.25,56.749998,47360000,0.26598
1989-06-15,57.749999,57.749999,56.25,56.749998,52112000,0.26598
1989-06-14,57.749999,58.000002,56.499999,57.749999,47302400,0.270667
1989-06-13,58.375,58.50,57.25,57.25,40563200,0.268324
1989-06-12,59.75,60.250002,58.625,58.999998,51680000,0.276526
1989-06-09,59.75,60.124998,59.250001,59.75,36144000,0.280041
1989-06-08,59.75,60.250002,59.50,59.75,29216000,0.280041
1989-06-07,58.749999,59.999999,58.749999,59.75,44928000,0.280041
1989-06-06,56.749998,58.625,56.499999,58.50,53897600,0.274182
1989-06-05,58.50,58.50,56.499999,56.749998,61414400,0.26598
1989-06-02,60.124998,60.250002,58.250001,58.250001,54041600,0.273011
1989-06-01,60.250002,60.75,59.75,59.999999,62796800,0.281213
1989-05-31,58.999998,60.999999,58.999998,60.500001,80969600,0.283556
1989-05-30,58.999998,59.625,58.50,58.999998,63907200,0.276526
1989-05-26,58.000002,58.999998,57.749999,58.874999,37884800,0.27594
1989-05-25,57.50,58.50,57.000001,57.50,33840000,0.269496
1989-05-24,56.125,57.50,55.750002,57.50,69363200,0.269496
1989-05-23,58.250001,58.999998,56.25,56.624999,97545600,0.265395
1989-05-22,58.250001,59.50,57.749999,59.250001,74275200,0.277698
1989-05-19,58.125001,59.50,58.125001,58.250001,62566400,0.273011
1989-05-18,57.25,58.625,57.25,58.250001,52572800,0.273011
1989-05-17,56.375,58.000002,56.375,57.375,89811200,0.26891
1989-05-16,54.750001,56.499999,54.499998,56.25,83433600,0.263637
1989-05-15,54.125,55.00,54.00,54.750001,74736000,0.256607
1989-05-12,54.625002,55.00,53.500002,54.249999,71091200,0.254263
1989-05-11,54.249999,54.249999,53.500002,54.00,34400000,0.253091
1989-05-10,53.500002,54.750001,53.249999,54.00,58752000,0.253091
1989-05-09,51.75,53.500002,51.500001,53.00,54588800,0.248405
1989-05-08,51.999999,52.249998,50.999999,51.500001,49001600,0.241374
1989-05-05,53.249999,53.249999,51.75,51.999999,35827200,0.243718
1989-05-04,54.249999,54.249999,52.249998,52.500001,37424000,0.246061
1989-05-03,54.00,54.750001,54.00,54.00,28857600,0.253091
1989-05-02,54.750001,55.00,53.500002,54.00,34371200,0.253091
1989-05-01,55.374999,56.000001,54.249999,54.625002,33737600,0.256021
1989-04-28,54.750001,56.25,53.750001,55.875001,69782400,0.261879
1989-04-27,54.00,54.875001,54.00,54.750001,34588800,0.256607
1989-04-26,55.00,55.00,53.625001,54.00,44508800,0.253091
1989-04-25,55.499999,55.750002,54.499998,54.750001,24896000,0.256607
1989-04-24,55.00,55.499999,54.499998,55.125,29331200,0.258364
1989-04-21,56.000001,56.000001,55.00,55.25,58188800,0.25895
1989-04-20,55.00,56.499999,54.499998,56.000001,138800000,0.262465
1989-04-19,55.00,55.750002,54.499998,54.875001,168969600,0.257192
1989-04-18,52.500001,53.249999,51.999999,53.249999,69334400,0.249576
1989-04-17,51.250002,52.375002,50.75,51.500001,51638400,0.241374
1989-04-14,49.250001,51.250002,49.250001,50.75,62624000,0.237859
1989-04-13,47.749998,50.375001,47.499999,48.749999,92880000,0.228485
1989-04-12,51.75,51.75,47.624999,48.125001,71020800,0.225556
1989-04-11,51.500001,51.999999,50.375001,51.375001,28726400,0.240788
1989-04-10,51.250002,52.249998,51.250002,51.375001,28668800,0.240788
1989-04-07,51.250002,51.75,50.999999,51.250002,29446400,0.240203
1989-04-06,50.50,51.500001,50.250001,51.250002,51680000,0.240203
1989-04-05,49.999998,50.50,49.749999,50.375001,19641600,0.236102
1989-04-04,50.250001,50.250001,49.50,49.999998,25027200,0.234344
1989-04-03,49.999998,50.75,49.625,50.250001,35049600,0.235516
1989-03-31,49.999998,50.250001,49.50,49.874999,29734400,0.233758
1989-03-30,49.749999,49.999998,49.125001,49.874999,46742400,0.233758
1989-03-29,49.749999,49.749999,49.250001,49.50,30009600,0.232
1989-03-28,50.250001,50.50,49.250001,49.749999,70803200,0.233172
1989-03-27,49.999998,50.625,49.50,49.749999,75542400,0.233172
1989-03-23,48.749999,50.250001,48.749999,50.250001,87811200,0.235516
1989-03-22,49.50,49.749999,48.50,49.000002,167024000,0.229657
1989-03-21,46.750002,49.999998,46.25,49.874999,224467200,0.233758
1989-03-20,46.374999,46.499999,45.750001,46.499999,238995200,0.21794
1989-03-17,50.250001,50.50,46.00,46.499999,245577600,0.21794
1989-03-16,50.75,51.500001,50.50,51.250002,102886400,0.240203
1989-03-15,52.75,52.75,50.250001,50.250001,104889600,0.235516
1989-03-14,53.249999,53.249999,52.249998,52.75,63718400,0.247233
1989-03-13,51.999999,52.75,51.75,52.75,60204800,0.247233
1989-03-10,51.500001,52.500001,50.999999,51.75,66902400,0.242546
1989-03-09,52.75,52.75,51.500001,51.75,123305600,0.242546
1989-03-08,53.750001,54.499998,52.375002,52.500001,253612800,0.246061
1989-03-07,59.75,59.999999,53.249999,53.500002,788688000,0.250748
1989-03-06,61.75,62.249999,60.999999,62.00,56633600,0.290586
1989-03-03,60.75,62.00,60.500001,61.75,68947200,0.289415
1989-03-02,59.250001,60.999999,59.250001,60.75,92304000,0.284728
1989-03-01,59.999999,60.250002,59.250001,59.250001,59888000,0.277698
1989-02-28,59.999999,60.250002,58.999998,59.50,43443200,0.278869
1989-02-27,58.749999,60.250002,58.50,59.75,68787200,0.280041
1989-02-24,60.250002,60.75,58.749999,58.749999,76016000,0.275354
1989-02-23,60.250002,60.75,59.250001,60.375001,75945600,0.28297
1989-02-22,61.500001,61.75,59.999999,59.999999,95513600,0.281213
1989-02-21,62.249999,62.750001,61.500001,61.75,33753600,0.289415
1989-02-17,63.00,63.249999,62.249999,62.500002,29692800,0.29293
1989-02-16,62.500002,63.499998,61.249998,62.750001,61385600,0.294102
1989-02-15,60.500001,62.249999,60.250002,62.249999,81936000,0.291758
1989-02-14,61.875,62.249999,59.999999,60.250002,62956800,0.282384
1989-02-13,61.500001,62.00,60.999999,61.249998,94073600,0.287071
1989-02-10,63.00,63.499998,61.625001,61.875,129036800,0.290001
1989-02-09,62.00,64.750002,61.75,63.750001,199036800,0.298789
1989-02-08,62.00,64.00,61.500001,62.500002,133315200,0.29293
1989-02-07,60.625,62.500002,60.500001,62.124999,127094400,0.291172
1989-02-06,60.75,60.999999,59.75,60.500001,87580800,0.283556
1989-02-03,60.500001,62.500002,59.999999,60.999999,91324800,0.2859
1989-02-02,59.50,63.00,59.250001,60.875,180028800,0.285314
1989-02-01,59.50,59.75,58.999998,59.250001,131212800,0.277698
1989-01-31,58.999998,60.250002,58.50,59.625,125091200,0.279455
1989-01-30,55.499999,58.749999,55.25,58.50,110086400,0.274182
1989-01-27,54.125,56.499999,53.750001,55.374999,166419200,0.259536
1989-01-26,52.625001,54.499998,52.500001,54.249999,87132800,0.254263
1989-01-25,53.00,53.249999,52.500001,53.00,49046400,0.248405
1989-01-24,53.00,53.500002,52.500001,52.75,56217600,0.247233
1989-01-23,54.00,54.00,52.875,53.00,52227200,0.248405
1989-01-20,53.500002,54.374999,53.249999,54.125,61027200,0.253677
1989-01-19,52.249998,53.750001,52.249998,53.500002,84297600,0.250748
1989-01-18,51.75,51.75,50.250001,51.500001,63632000,0.241374
1989-01-17,52.625001,52.875,51.250002,51.500001,41744000,0.241374
1989-01-16,53.249999,54.125,52.75,53.124999,27532800,0.24899
1989-01-13,52.500001,53.249999,52.500001,53.00,35568000,0.248405
1989-01-12,52.249998,53.750001,52.249998,52.500001,54588800,0.246061
1989-01-11,51.875,52.500001,51.500001,52.500001,48297600,0.246061
1989-01-10,52.249998,52.500001,51.75,51.999999,54128000,0.243718
1989-01-09,53.00,53.249999,52.124999,52.500001,46006400,0.246061
1989-01-06,53.500002,53.750001,53.00,53.00,59052800,0.248405
1989-01-05,54.750001,54.750001,53.249999,53.374998,47244800,0.250162
1989-01-04,53.500002,54.875001,53.500002,54.249999,53897600,0.254263
1989-01-03,53.500002,53.750001,52.75,53.625001,51824000,0.251334
1988-12-30,53.500002,54.249999,53.249999,53.249999,63820800,0.249576
1988-12-29,51.999999,53.500002,51.999999,53.249999,38275200,0.249576
1988-12-28,51.999999,52.249998,51.75,52.249998,21267200,0.244889
1988-12-27,51.999999,52.500001,51.75,51.75,30771200,0.242546
1988-12-23,51.75,51.999999,51.500001,51.999999,17120000,0.243718
1988-12-22,52.500001,53.00,51.75,51.999999,74592000,0.243718
1988-12-21,51.500001,52.500001,51.250002,52.249998,46438400,0.244889
1988-12-20,51.375001,52.500001,50.999999,51.250002,92188800,0.240203
1988-12-19,50.625,51.500001,50.50,50.75,83532800,0.237859
1988-12-16,48.749999,50.250001,48.749999,49.749999,51795200,0.233172
1988-12-15,49.000002,49.250001,48.50,49.000002,23196800,0.229657
1988-12-14,47.749998,48.749999,47.499999,48.375,28006400,0.226728
1988-12-13,47.25,47.749998,47.25,47.749998,39168000,0.223798
1988-12-12,48.749999,49.000002,47.375,47.375,38892800,0.222041
1988-12-09,48.749999,49.250001,48.50,49.000002,22304000,0.229657
1988-12-08,49.250001,49.50,48.749999,49.000002,40176000,0.229657
1988-12-07,49.50,49.999998,49.125001,49.250001,30886400,0.230829
1988-12-06,49.50,49.749999,49.000002,49.749999,44364800,0.233172
1988-12-05,49.749999,50.50,48.749999,49.50,70140800,0.232
1988-12-02,48.50,50.250001,48.50,49.749999,91497600,0.233172
1988-12-01,47.499999,49.50,47.000001,49.000002,82006400,0.229657
1988-11-30,47.25,47.749998,47.25,47.25,35193600,0.221455
1988-11-29,47.000001,47.499999,46.750002,47.499999,21872000,0.222627
1988-11-28,46.25,47.499999,46.25,47.000001,58736000,0.220283
1988-11-25,46.25,46.499999,45.750001,46.374999,11462400,0.217354
1988-11-23,46.25,47.000001,46.00,46.875001,56547200,0.219697
1988-11-22,46.00,46.499999,45.499998,46.00,30310400,0.215596
1988-11-21,46.00,46.25,45.249999,46.00,47100800,0.215596
1988-11-18,46.25,46.750002,45.750001,46.624998,34428800,0.218526
1988-11-17,46.25,46.750002,45.750001,46.00,65865600,0.215596
1988-11-16,47.125,47.25,45.499998,46.25,199008000,0.216768
1988-11-15,48.50,48.50,46.499999,47.000001,93900800,0.220283
1988-11-14,48.000001,48.749999,47.499999,48.50,34329600,0.227314
1988-11-11,48.50,49.000002,47.499999,47.624999,54934400,0.223213
1988-11-10,49.749999,50.50,49.000002,49.000002,78796800,0.229657
1988-11-09,48.000001,49.999998,47.749998,49.749999,124732800,0.233172
1988-11-08,47.25,49.000002,47.000001,48.624999,56604800,0.227899
1988-11-07,46.499999,47.000001,46.00,46.750002,55065600,0.219112
1988-11-04,46.499999,47.749998,46.499999,46.499999,106601600,0.21794
1988-11-03,47.25,47.749998,46.125,47.25,118339200,0.221455
1988-11-02,48.749999,48.749999,46.750002,47.25,221801600,0.221455
1988-11-01,49.000002,49.749999,48.749999,48.749999,53280000,0.228485
1988-10-31,49.250001,49.250001,48.50,49.000002,41283200,0.229657
1988-10-28,49.250001,49.749999,48.50,49.50,46540800,0.232
1988-10-27,49.250001,49.50,47.749998,49.50,114336000,0.232
1988-10-26,50.250001,50.50,48.50,49.749999,157420800,0.233172
1988-10-25,51.999999,52.249998,49.999998,50.50,74547200,0.236687
1988-10-24,53.249999,53.249999,51.875,51.999999,28627200,0.243718
1988-10-21,53.00,53.500002,52.500001,53.00,24262400,0.248405
1988-10-20,52.75,54.00,52.75,53.500002,73296000,0.250748
1988-10-19,53.500002,53.750001,52.249998,53.249999,80681600,0.249576
1988-10-18,51.75,52.75,51.250002,52.500001,37222400,0.246061
1988-10-17,51.250002,52.500001,51.250002,51.999999,25673600,0.243718
1988-10-14,51.999999,52.249998,50.999999,51.250002,56764800,0.240203
1988-10-13,50.375001,52.249998,50.250001,51.500001,82467200,0.241374
1988-10-12,49.50,51.75,49.000002,50.625,137532800,0.237273
1988-10-11,49.749999,50.50,49.000002,49.749999,65952000,0.233172
1988-10-10,49.999998,49.999998,47.749998,49.250001,106358400,0.230829
1988-10-07,49.999998,50.250001,47.875002,49.749999,208064000,0.233172
1988-10-06,50.250001,50.75,49.999998,49.999998,33609600,0.234344
1988-10-05,51.250002,51.250002,49.999998,50.250001,67088000,0.235516
1988-10-04,51.500001,51.999999,50.874999,51.124998,29260800,0.239617
1988-10-03,51.250002,51.75,50.50,51.375001,41097600,0.240788
1988-09-30,52.75,53.00,51.75,52.249998,37251200,0.244889
1988-09-29,52.75,53.500002,52.500001,53.00,56460800,0.248405
1988-09-28,52.249998,53.00,51.75,53.00,25516800,0.248405
1988-09-27,51.999999,52.249998,51.500001,51.999999,35366400,0.243718
1988-09-26,53.750001,54.00,51.75,52.375002,50211200,0.245475
1988-09-23,54.499998,54.499998,53.750001,53.750001,35091200,0.25192
1988-09-22,54.00,55.00,53.750001,54.499998,59686400,0.255435
1988-09-21,53.500002,54.00,53.500002,53.750001,16054400,0.25192
1988-09-20,51.999999,53.249999,51.75,53.249999,53625600,0.249576
1988-09-19,52.500001,52.500001,50.999999,51.75,44697600,0.242546
1988-09-16,52.249998,52.500001,51.75,51.999999,48700800,0.243718
1988-09-15,54.00,54.249999,51.999999,52.249998,72921600,0.244889
1988-09-14,54.875001,55.25,53.750001,54.00,79212800,0.253091
1988-09-13,53.249999,54.249999,52.75,54.00,40608000,0.253091
1988-09-12,53.750001,55.00,53.500002,53.750001,43257600,0.25192
1988-09-09,51.75,54.750001,51.500001,54.00,111123200,0.253091
1988-09-08,51.500001,53.249999,51.250002,51.999999,69206400,0.243718
1988-09-07,52.249998,52.75,50.75,51.75,72115200,0.242546
1988-09-06,51.500001,52.500001,51.250002,51.999999,67750400,0.243718
1988-09-02,49.749999,51.75,49.50,51.500001,115328000,0.241374
1988-09-01,49.50,49.749999,48.000001,48.874998,82380800,0.229071
1988-08-31,51.500001,51.75,49.250001,49.999998,71884800,0.234344
1988-08-30,51.999999,52.249998,50.999999,51.250002,20966400,0.240203
1988-08-29,51.999999,52.500001,51.75,52.124999,35033600,0.244304
1988-08-26,50.75,51.75,50.75,51.375001,24451200,0.240788
1988-08-25,50.250001,51.500001,49.999998,50.75,72633600,0.237859
1988-08-24,49.50,51.625,49.250001,51.500001,102585600,0.241374
1988-08-23,48.25,49.749999,47.749998,49.375,88313600,0.231415
1988-08-22,50.250001,50.50,47.749998,48.000001,110172800,0.22497
1988-08-19,52.75,53.00,50.250001,50.50,67376000,0.236687
1988-08-18,52.75,53.249999,52.500001,52.75,32025600,0.247233
1988-08-17,52.500001,53.875,51.375001,52.500001,59110400,0.246061
1988-08-16,50.50,52.75,50.250001,52.500001,90876800,0.246061
1988-08-15,51.999999,52.249998,49.999998,50.75,41081600,0.237859
1988-08-12,51.75,52.249998,51.500001,51.999999,58262400,0.243718
1988-08-11,50.999999,51.999999,49.999998,51.75,123104000,0.242546
1988-08-10,51.250002,51.75,49.999998,50.50,113168000,0.236687
1988-08-09,53.00,53.249999,50.999999,51.75,138828800,0.242546
1988-08-08,53.750001,53.750001,52.75,53.249999,148320000,0.249576
1988-08-05,55.499999,55.499999,51.75,53.500002,201600000,0.250748
1988-08-04,56.25,56.499999,55.499999,55.499999,53494400,0.260122
1988-08-03,57.25,57.50,55.499999,56.25,91987200,0.263637
1988-08-02,58.50,58.749999,56.749998,57.50,65475200,0.269496
1988-08-01,59.75,59.999999,58.50,58.50,51824000,0.274182
1988-07-29,58.50,59.999999,58.250001,59.50,59385600,0.278869
1988-07-28,57.50,58.50,57.000001,58.250001,57945600,0.273011
1988-07-27,58.250001,58.999998,57.50,57.624999,68140800,0.270081
1988-07-26,58.000002,58.999998,56.749998,58.000002,228960000,0.271839
1988-07-25,62.00,62.500002,60.250002,60.500001,52704000,0.283556
1988-07-22,60.75,62.500002,60.500001,61.75,68816000,0.289415
1988-07-21,63.750001,64.00,60.500001,60.999999,128937600,0.2859
1988-07-20,66.50,66.50,63.750001,64.00,111094400,0.29996
1988-07-19,67.250001,67.50,65.749998,66.000001,36460800,0.309334
1988-07-18,67.250001,67.749999,67.000002,67.50,20102400,0.316364
1988-07-15,67.000002,67.250001,66.25,67.000002,31577600,0.314021
1988-07-14,66.749999,67.000002,66.000001,67.000002,34848000,0.314021
1988-07-13,65.499999,66.749999,65.000001,66.749999,57427200,0.312849
1988-07-12,67.000002,67.250001,64.750002,65.624999,90000000,0.307576
1988-07-11,68.75,68.75,66.749999,66.749999,65763200,0.312849
1988-07-08,67.999998,68.75,67.749999,68.50,40089600,0.321051
1988-07-07,68.250001,68.999999,67.749999,68.75,68428800,0.322223
1988-07-06,69.75,70.500001,68.50,68.75,89379200,0.322223
1988-07-05,67.50,69.75,67.000002,69.625,48096000,0.326324
1988-07-01,67.000002,67.999998,66.749999,67.999998,42940800,0.318708
1988-06-30,66.25,67.000002,66.000001,67.000002,31548800,0.314021
1988-06-29,66.000001,66.50,65.499999,65.749998,49808000,0.308162
1988-06-28,64.00,66.000001,63.750001,65.749998,32140800,0.308162
1988-06-27,65.25,65.25,64.00,64.00,23628800,0.29996
1988-06-24,66.000001,66.25,65.000001,65.25,28553600,0.305819
1988-06-23,67.000002,67.250001,65.749998,66.000001,41052800,0.309334
1988-06-22,65.000001,67.50,64.374999,67.000002,127324800,0.314021
1988-06-21,62.500002,64.00,62.500002,64.00,39715200,0.29996
1988-06-20,62.750001,63.00,62.00,62.750001,28137600,0.294102
1988-06-17,63.499998,64.25,62.750001,63.00,42105600,0.295273
1988-06-16,63.249999,63.750001,63.00,63.499998,73712000,0.297617
1988-06-15,62.750001,64.00,62.500002,64.00,51033600,0.29996
1988-06-14,63.00,63.499998,62.750001,63.00,60377600,0.295273
1988-06-13,62.500002,63.00,62.249999,62.374998,31116800,0.292344
1988-06-10,61.75,62.750001,61.249998,62.249999,45014400,0.291758
1988-06-09,62.249999,62.875,61.625001,61.75,69264000,0.289415
1988-06-08,60.75,62.500002,60.75,62.00,66281600,0.290586
1988-06-07,60.999999,62.00,60.375001,60.999999,82166400,0.2859
1988-06-06,59.50,60.999999,59.250001,60.75,81747200,0.284728
1988-06-03,58.999998,59.75,58.749999,59.50,34832000,0.278869
1988-06-02,59.50,59.999999,58.749999,58.999998,63228800,0.276526
1988-06-01,58.250001,59.999999,57.749999,59.250001,95788800,0.277698
1988-05-31,55.499999,58.250001,55.25,58.000002,44048000,0.271839
1988-05-27,56.25,56.25,55.499999,55.499999,33148800,0.260122
1988-05-26,56.000001,57.000001,55.750002,56.125,43385600,0.263051
1988-05-25,56.499999,57.000001,55.499999,55.750002,53580800,0.261294
1988-05-24,55.00,56.749998,54.750001,56.749998,55324800,0.26598
1988-05-23,56.25,56.499999,54.499998,55.00,50227200,0.257778
1988-05-20,57.25,57.749999,56.000001,56.25,42521600,0.263637
1988-05-19,56.000001,57.25,55.750002,57.000001,57728000,0.267152
1988-05-18,58.000002,58.375,56.499999,56.749998,81372800,0.26598
1988-05-17,58.999998,59.250001,58.000002,58.000002,70428800,0.271839
1988-05-16,56.749998,58.874999,56.749998,58.250001,59788800,0.273011
1988-05-13,56.499999,57.000001,56.25,56.749998,17913600,0.26598
1988-05-12,55.750002,56.499999,55.499999,56.000001,26409600,0.262465
1988-05-11,56.499999,56.499999,55.00,55.750002,59484800,0.261294
1988-05-10,57.25,57.624999,56.25,57.000001,46828800,0.267152
1988-05-09,57.25,58.250001,56.749998,57.25,34790400,0.268324
1988-05-06,56.749998,58.000002,56.749998,57.25,43977600,0.268324
1988-05-05,56.749998,57.25,56.25,57.000001,24883200,0.267152
1988-05-04,56.749998,57.749999,56.000001,57.125001,75152000,0.267738
1988-05-03,55.25,57.000001,55.25,56.499999,62739200,0.264809
1988-05-02,54.499998,55.25,53.500002,55.00,49260800,0.257778
1988-04-29,55.00,55.00,54.249999,54.499998,64771200,0.255435
1988-04-28,55.499999,55.750002,55.00,55.374999,28467200,0.259536
1988-04-27,55.750002,56.000001,54.249999,55.499999,47894400,0.260122
1988-04-26,55.750002,56.499999,55.25,55.750002,46454400,0.261294
1988-04-25,55.25,55.750002,54.750001,55.125,23385600,0.258364
1988-04-22,54.499998,55.750002,54.499998,55.25,33926400,0.25895
1988-04-21,55.00,55.499999,53.750001,54.374999,63977600,0.254849
1988-04-20,54.249999,55.00,53.750001,54.499998,65404800,0.255435
1988-04-19,54.750001,57.000001,54.00,54.249999,75772800,0.254263
1988-04-18,54.00,55.25,53.750001,54.750001,48051200,0.256607
1988-04-15,53.249999,55.00,52.75,54.249999,114220800,0.254263
1988-04-14,55.499999,56.499999,52.75,53.00,110028800,0.248405
1988-04-13,56.000001,57.000001,55.499999,57.000001,42204800,0.267152
1988-04-12,57.25,57.749999,55.00,55.750002,52444800,0.261294
1988-04-11,58.50,58.50,57.000001,57.50,40406400,0.269496
1988-04-08,57.50,58.50,57.125001,58.000002,57974400,0.271839
1988-04-07,58.250001,58.749999,57.25,57.25,74921600,0.268324
1988-04-06,56.000001,58.250001,55.750002,58.125001,75296000,0.272425
1988-04-05,55.499999,56.000001,54.499998,56.000001,41760000,0.262465
1988-04-04,56.000001,56.499999,54.499998,55.25,47721600,0.25895
1988-03-31,54.499998,56.499999,54.499998,56.499999,50256000,0.264809
1988-03-30,56.749998,57.000001,54.249999,54.750001,100713600,0.256607
1988-03-29,57.25,58.250001,56.25,56.499999,80710400,0.264809
1988-03-28,55.499999,57.000001,55.00,56.875002,67145600,0.266566
1988-03-25,56.749998,57.624999,55.750002,56.125,47331200,0.263051
1988-03-24,58.749999,58.749999,55.750002,56.499999,159840000,0.264809
1988-03-23,61.75,62.374998,58.749999,58.999998,151200000,0.276526
1988-03-22,58.749999,60.75,58.749999,60.250002,115833600,0.282384
1988-03-21,58.50,58.749999,56.749998,58.749999,198720000,0.275354
1988-03-18,63.750001,64.00,58.250001,58.250001,169920000,0.273011
1988-03-17,65.000001,65.499999,63.750001,63.875001,125308800,0.299374
1988-03-16,62.750001,64.750002,62.00,64.750002,54547200,0.303475
1988-03-15,63.750001,63.750001,62.249999,62.500002,43760000,0.29293
1988-03-14,62.249999,63.750001,61.500001,63.625002,46281600,0.298203
1988-03-11,62.500002,63.00,60.999999,62.500002,84297600,0.29293
1988-03-10,64.25,65.000001,62.374998,62.750001,97948800,0.294102
1988-03-09,63.499998,64.499999,63.249999,64.00,81734400,0.29996
1988-03-08,63.00,64.750002,62.750001,63.875001,96896000,0.299374
1988-03-07,60.999999,62.750001,60.75,62.625001,78003200,0.293516
1988-03-04,60.999999,61.249998,59.75,60.75,68355200,0.284728
1988-03-03,59.999999,61.500001,59.75,60.999999,83664000,0.2859
1988-03-02,58.999998,60.75,58.749999,59.50,67894400,0.278869
1988-03-01,59.75,59.999999,58.50,58.999998,43299200,0.276526
1988-02-29,58.50,59.50,58.000002,59.375001,39324800,0.278283
1988-02-26,58.250001,58.749999,57.25,58.250001,29923200,0.273011
1988-02-25,59.75,60.500001,57.874998,58.125001,61558400,0.272425
1988-02-24,59.50,60.75,59.50,59.874999,79558400,0.280627
1988-02-23,58.749999,59.999999,58.749999,59.50,91728000,0.278869
1988-02-22,58.749999,58.999998,58.000002,58.749999,52227200,0.275354
1988-02-19,58.250001,58.749999,57.749999,58.749999,53164800,0.275354
1988-02-18,57.25,58.999998,57.000001,58.000002,84153600,0.271839
1988-02-17,58.000002,58.749999,57.25,57.50,101318400,0.269496
1988-02-16,55.00,57.749999,54.499998,57.50,67334400,0.269496
1988-02-12,54.750001,56.25,54.499998,55.25,80220800,0.25895
1988-02-11,54.00,54.750001,53.750001,54.750001,69436800,0.256607
1988-02-10,53.00,54.00,52.500001,53.750001,77024000,0.25192
1988-02-09,52.249998,53.00,51.999999,52.75,49939200,0.247233
1988-02-08,50.75,52.500001,50.75,51.75,72876800,0.242546
1988-02-05,51.999999,53.500002,51.250002,51.500001,94102400,0.241374
1988-02-04,53.00,53.249999,49.749999,50.999999,114710400,0.239031
1988-02-03,55.750002,55.750002,52.249998,52.75,75801600,0.247233
1988-02-02,55.25,56.000001,54.750001,55.750002,60752000,0.261294
1988-02-01,56.749998,57.000001,55.00,55.25,48729600,0.25895
1988-01-29,56.499999,57.000001,54.499998,55.750002,66700800,0.261294
1988-01-28,56.000001,56.749998,56.000001,56.499999,29318400,0.264809
1988-01-27,54.750001,56.25,54.750001,55.750002,100409600,0.261294
1988-01-26,55.00,55.875001,54.249999,54.499998,43558400,0.255435
1988-01-25,54.249999,56.25,54.249999,55.750002,75497600,0.261294
1988-01-22,55.624998,56.125,52.75,53.875,75296000,0.252506
1988-01-21,54.249999,56.25,54.249999,55.00,125107200,0.257778
1988-01-20,56.749998,57.25,52.500001,54.00,208800000,0.253091
1988-01-19,56.000001,58.250001,55.750002,57.25,47417600,0.268324
1988-01-18,58.000002,58.000002,56.25,57.25,30038400,0.268324
1988-01-15,58.999998,59.250001,57.749999,57.749999,92172800,0.270667
1988-01-14,57.25,58.000002,56.000001,56.25,40608000,0.263637
1988-01-13,56.000001,58.50,54.750001,56.749998,96147200,0.26598
1988-01-12,58.000002,58.50,54.249999,56.749998,168480000,0.26598
1988-01-11,55.750002,58.000002,54.750001,57.874998,143568000,0.271253
1988-01-08,60.250002,61.75,55.624998,56.000001,145440000,0.262465
1988-01-07,58.000002,60.625,57.50,60.500001,90675200,0.283556
1988-01-06,57.25,59.75,57.000001,58.50,121680000,0.274182
1988-01-05,57.25,58.000002,56.499999,57.000001,155520000,0.267152
1988-01-04,54.750001,56.499999,54.499998,56.000001,110345600,0.262465
1987-12-31,55.25,55.750002,53.750001,54.249999,61545600,0.254263
1987-12-30,54.499998,56.000001,54.249999,55.750002,70704000,0.261294
1987-12-29,51.250002,55.00,50.50,54.499998,79459200,0.255435
1987-12-28,53.00,53.249999,49.999998,51.250002,50716800,0.240203
1987-12-24,53.249999,53.750001,53.00,53.249999,12672000,0.249576
1987-12-23,53.249999,53.750001,52.249998,53.249999,60710400,0.249576
1987-12-22,51.500001,53.00,49.999998,52.500001,41772800,0.246061
1987-12-21,52.500001,53.500002,50.75,51.500001,51161600,0.241374
1987-12-18,52.500001,53.750001,51.999999,51.999999,52486400,0.243718
1987-12-17,54.750001,54.750001,51.75,51.999999,94016000,0.243718
1987-12-16,50.50,54.750001,50.250001,54.249999,105536000,0.254263
1987-12-15,51.250002,51.875,49.999998,51.250002,112217600,0.240203
1987-12-14,48.000001,50.999999,47.749998,50.75,95110400,0.237859
1987-12-11,47.749998,48.50,46.750002,48.000001,72473600,0.22497
1987-12-10,45.499998,49.50,44.249999,47.499999,165600000,0.222627
1987-12-09,47.25,48.25,46.00,46.25,83792000,0.216768
1987-12-08,43.249998,47.499999,42.999999,47.499999,112521600,0.222627
1987-12-07,42.999999,43.75,42.250002,43.249998,66211200,0.202707
1987-12-04,40.250001,42.375001,40.000002,41.999999,121750400,0.196849
1987-12-03,44.249999,44.750001,40.250001,40.375,127670400,0.189233
1987-12-02,43.500001,44.750001,42.75,44.00,68515200,0.206223
1987-12-01,44.500002,45.750001,42.999999,43.75,73539200,0.205051
1987-11-30,44.249999,45.00,40.50,44.750001,164160000,0.209738
1987-11-27,46.00,46.25,45.00,45.249999,18316800,0.212081
1987-11-25,47.499999,47.749998,46.00,46.00,32153600,0.215596
1987-11-24,48.50,49.000002,45.499998,47.499999,72230400,0.222627
1987-11-23,47.25,48.749999,47.000001,47.749998,44640000,0.223798
1987-11-20,45.499998,47.749998,44.750001,47.499999,82467200,0.222627
1987-11-19,48.25,48.50,46.00,46.25,75024000,0.216768
1987-11-18,47.499999,48.000001,45.00,48.000001,89308800,0.22497
1987-11-17,46.750002,47.499999,45.249999,46.750002,69321600,0.219112
1987-11-16,48.749999,49.749999,47.499999,47.749998,59472000,0.223798
1987-11-13,49.999998,50.250001,48.25,48.25,58492800,0.226142
1987-11-12,50.75,51.999999,49.000002,49.999998,99171200,0.234344
1987-11-11,47.499999,49.250001,47.25,49.000002,54617600,0.229657
1987-11-10,46.499999,48.50,45.499998,47.000001,91164800,0.220283
1987-11-09,46.750002,47.499999,45.499998,47.000001,86585600,0.220283
1987-11-06,50.250001,50.50,47.000001,47.499999,75353600,0.222627
1987-11-05,49.000002,51.250002,48.749999,50.50,81430400,0.236687
1987-11-04,47.000001,50.75,46.00,48.749999,95340800,0.228485
1987-11-03,49.250001,49.999998,43.75,48.000001,116150400,0.22497
1987-11-02,49.250001,50.999999,48.50,50.250001,84771200,0.235516
1987-10-30,49.749999,52.249998,48.50,49.749999,168480000,0.233172
1987-10-29,41.250001,48.749999,41.250001,47.749998,167040000,0.223798
1987-10-28,40.000002,42.500001,38.499999,41.250001,149760000,0.193334
1987-10-27,40.749999,42.999999,39.25,41.250001,234720000,0.193334
1987-10-26,46.499999,48.000001,37.25,39.25,148320000,0.18396
1987-10-23,52.500001,53.00,47.499999,48.25,112764800,0.226142
1987-10-22,56.749998,58.000002,50.999999,53.249999,223200000,0.249576
1987-10-21,51.75,60.500001,49.999998,56.624999,262080000,0.265395
1987-10-20,46.00,51.999999,42.999999,48.000001,324000000,0.22497
1987-10-19,61.500001,63.499998,45.00,45.249999,146880000,0.212081
1987-10-16,70.500001,74.499999,64.25,64.750002,210240000,0.303475
1987-10-15,70.500001,72.749997,69.999999,70.500001,128822400,0.330425
1987-10-14,73.250004,74.749998,70.75,71.249999,114220800,0.33394
1987-10-13,72.249999,74.000001,71.00,73.250004,96809600,0.343314
1987-10-12,72.00,72.999996,68.999999,71.500002,117187200,0.335112
1987-10-09,72.249999,75.249996,71.750001,71.750001,93888000,0.336284
1987-10-08,73.250004,74.25,69.500001,72.00,96940800,0.337455
1987-10-07,74.000001,75.249996,71.500002,72.999996,125638400,0.342142
1987-10-06,78.999999,79.249998,73.374999,73.750002,203040000,0.345657
1987-10-05,73.500003,78.999999,73.500003,78.999999,184320000,0.370263
1987-10-02,68.999999,72.749997,68.75,72.499998,131644800,0.339799
1987-10-01,66.25,68.75,66.000001,68.50,127222400,0.321051
1987-09-30,64.00,66.624999,64.00,66.25,85680000,0.310506
1987-09-29,64.499999,65.25,63.625002,64.25,57411200,0.301132
1987-09-28,62.00,65.25,61.75,64.00,95542400,0.29996
1987-09-25,61.500001,65.000001,61.249998,62.00,82454400,0.290586
1987-09-24,59.999999,63.249999,59.999999,61.249998,118438400,0.287071
1987-09-23,57.749999,60.375001,57.749999,60.250002,107696000,0.282384
1987-09-22,53.500002,57.749999,53.00,57.25,82006400,0.268324
1987-09-21,53.500002,57.25,53.00,53.500002,85548800,0.250748
1987-09-18,116.000004,116.000004,114.000003,114.999999,31651200,0.269496
1987-09-17,117.00,117.499998,113.750004,116.000004,69436800,0.271839
1987-09-16,117.999996,119.999997,116.750001,116.750001,57715200,0.273597
1987-09-15,119.499999,119.499999,116.250003,117.875001,39052800,0.276233
1987-09-14,116.500002,119.999997,116.500002,119.25,94464000,0.279455
1987-09-11,114.500001,116.500002,114.000003,116.250003,41040000,0.272425
1987-09-10,113.249997,115.749996,112.999998,114.500001,58176000,0.268324
1987-09-09,112.000002,114.000003,111.500004,112.749999,60710400,0.264223
1987-09-08,111.750003,112.000002,108.249999,111.500004,96336000,0.261294
1987-09-04,115.249998,115.499997,111.750003,112.000002,48355200,0.262465
1987-09-03,116.250003,117.749997,113.750004,115.249998,70934400,0.270081
1987-09-02,112.50,115.249998,112.250001,114.999999,78393600,0.269496
1987-09-01,117.999996,118.750002,112.999998,113.499996,93859200,0.26598
1987-08-31,119.749998,120.249996,116.750001,118.750002,84326400,0.278283
1987-08-28,116.000004,121.250001,116.000004,120.249996,114796800,0.281799
1987-08-27,115.499997,116.250003,114.250002,115.749996,72432000,0.271253
1987-08-26,114.75,117.999996,114.250002,115.499997,114105600,0.270667
1987-08-25,112.749999,116.750001,111.500004,114.75,185961600,0.26891
1987-08-24,107.000004,112.250001,105.500001,111.750003,97747200,0.261879
1987-08-21,105.000003,108.249999,105.000003,107.000004,68976000,0.250748
1987-08-20,102.500004,105.75,102.500004,105.250002,82051200,0.246647
1987-08-19,102.500004,102.750003,100.500003,102.500004,48902400,0.240203
1987-08-18,103.50,103.999998,101.499999,102.500004,46944000,0.240203
1987-08-17,103.50,104.249997,103.000002,104.249997,33667200,0.244304
1987-08-14,103.000002,103.749999,102.500004,103.50,50832000,0.242546
1987-08-13,99.999996,104.499996,99.999996,103.000002,80640000,0.241374
1987-08-12,101.499999,101.749998,99.999996,99.999996,42364800,0.234344
1987-08-11,103.999998,104.499996,101.000001,101.499999,68544000,0.237859
1987-08-10,103.749999,103.999998,102.500004,103.50,56448000,0.242546
1987-08-07,101.000001,104.499996,100.750002,103.50,171014400,0.242546
1987-08-06,97.499997,101.625003,97.499997,101.000001,152553600,0.236687
1987-08-05,94.000002,98.500002,93.750003,97.249998,211190400,0.227899
1987-08-04,91.750002,93.750003,91.750002,93.750003,135072000,0.219697
1987-08-03,94.000002,94.50,91.250004,91.750002,116352000,0.215011
1987-07-31,96.500001,96.500001,92.000001,94.000002,186624000,0.220283
1987-07-30,99.249999,99.249999,96.000003,96.999999,55555200,0.227314
1987-07-29,99.499998,99.749997,97.749996,99.249999,27676800,0.232586
1987-07-28,100.250004,101.749998,99.249999,99.499998,38160000,0.233172
1987-07-27,98.500002,99.749997,96.999999,99.749997,41817600,0.233758
1987-07-24,98.000004,99.499998,97.749996,98.500002,57744000,0.230829
1987-07-23,99.999996,99.999996,94.000002,97.749996,148492800,0.229071
1987-07-22,99.249999,100.500003,98.500002,99.999996,53366400,0.234344
1987-07-21,99.499998,101.000001,98.500002,99.249999,36547200,0.232586
1987-07-20,101.999997,101.999997,99.249999,99.499998,42019200,0.233172
1987-07-17,101.999997,103.999998,101.749998,102.249996,51264000,0.239617
1987-07-16,102.500004,103.000002,99.999996,101.999997,72979200,0.239031
1987-07-15,105.000003,105.75,102.249996,102.249996,96768000,0.239617
1987-07-14,99.999996,105.250002,99.499998,105.000003,152812800,0.246061
1987-07-13,96.999999,99.499998,96.000003,99.249999,48326400,0.232586
1987-07-10,95.249997,97.499997,94.000002,96.999999,75830400,0.227314
1987-07-09,93.750003,98.000004,93.249996,95.750004,92707200,0.224384
1987-07-08,90.999996,94.749999,88.499997,93.249996,193449600,0.218526
1987-07-07,97.249998,97.249998,89.500002,90.249999,197078400,0.211495
1987-07-06,99.749997,101.000001,96.999999,97.499997,65491200,0.228485
1987-07-02,102.750003,102.750003,98.750001,99.999996,56880000,0.234344
1987-07-01,101.749998,103.250001,101.499999,102.500004,21945600,0.240203
1987-06-30,104.499996,104.750004,101.749998,101.999997,38332800,0.239031
1987-06-29,104.750004,104.750004,102.500004,104.249997,25632000,0.244304
1987-06-26,104.750004,105.250002,103.749999,104.750004,21945600,0.245475
1987-06-25,104.499996,105.000003,103.50,104.499996,44035200,0.244889
1987-06-24,103.250001,105.999999,103.250001,104.750004,82684800,0.245475
1987-06-23,103.749999,103.749999,100.500003,102.750003,100771200,0.240788
1987-06-22,105.000003,105.000003,103.000002,103.749999,87436800,0.243132
1987-06-19,105.250002,106.249998,103.999998,104.499996,40809600,0.244889
1987-06-18,103.50,105.000003,101.999997,104.874999,56188800,0.245768
1987-06-17,100.750002,103.999998,100.750002,103.749999,71078400,0.243132
1987-06-16,98.250003,101.499999,98.000004,100.250004,73526400,0.23493
1987-06-15,98.250003,99.749997,96.250002,98.250003,125222400,0.230243
1987-06-12,97.499997,101.499999,97.249998,98.250003,196156800,0.230243
1987-06-11,105.250002,105.75,97.249998,97.499997,268704000,0.228485
1987-06-10,108.999996,109.500003,101.25,103.50,176256000,0.242546
1987-06-09,109.750002,110.000001,108.499998,108.999996,25833600,0.255435
1987-06-08,109.250004,110.000001,107.500002,109.750002,111571200,0.257192
1987-06-05,112.50,112.999998,107.000004,109.250004,59270400,0.256021
1987-06-04,113.249997,113.249997,111.750003,112.50,20390400,0.263637
1987-06-03,112.999998,114.75,112.999998,113.249997,21628800,0.265395
1987-06-02,112.999998,114.75,110.999997,112.50,51552000,0.263637
1987-06-01,115.249998,115.249998,112.999998,112.999998,30326400,0.264809
1987-05-29,116.250003,118.250004,114.999999,115.249998,80380800,0.270081
1987-05-28,109.500003,116.500002,109.250004,116.250003,108662400,0.272425
1987-05-27,109.500003,112.000002,108.999996,109.500003,48758400,0.256607
1987-05-26,108.249999,110.000001,108.00,109.500003,46886400,0.256607
1987-05-22,111.500004,112.000002,107.750001,108.249999,64627200,0.253677
1987-05-21,109.750002,112.749999,109.750002,111.500004,93312000,0.261294
1987-05-20,110.749998,110.749998,107.250003,109.500003,228355200,0.256607
1987-05-19,115.249998,115.249998,111.249996,111.249996,78336000,0.260708
1987-05-18,119.25,119.25,112.000002,115.249998,172598400,0.270081
1987-05-15,122.499996,122.499996,119.25,119.25,84326400,0.279455
1987-05-14,121.749999,125.000004,121.749999,122.750004,59961600,0.287657
1987-05-13,119.499999,122.249997,119.499999,121.749999,73382400,0.285314
1987-05-12,123.000003,124.249998,117.00,118.750002,148464000,0.278283
1987-05-11,126.499998,126.499998,122.874999,123.000003,127382400,0.288243
1987-05-08,118.500003,128.25,118.500003,126.499998,150048000,0.296445
1987-05-07,112.999998,118.500003,112.250001,118.250004,289699200,0.277112
1987-05-06,115.749996,116.750001,112.50,112.999998,153504000,0.264809
1987-05-05,107.250003,115.749996,107.250003,115.749996,110995200,0.271253
1987-05-04,105.000003,107.750001,104.499996,107.000004,34531200,0.250748
1987-05-01,103.999998,105.250002,102.750003,105.000003,37843200,0.246061
1987-04-30,103.250001,106.249998,101.749998,103.999998,88041600,0.243718
1987-04-29,106.249998,108.999996,103.250001,103.250001,85161600,0.24196
1987-04-28,99.00,106.499997,98.000004,106.249998,111081600,0.24899
1987-04-27,99.00,99.749997,97.249998,99.00,53107200,0.232
1987-04-24,98.500002,99.499998,97.249998,99.00,54172800,0.232
1987-04-23,98.500002,99.499998,96.999999,98.500002,48326400,0.230829
1987-04-22,97.249998,98.750001,97.249998,98.500002,74678400,0.230829
1987-04-21,95.750004,98.000004,93.750003,97.249998,113184000,0.227899
1987-04-20,98.500002,99.499998,95.499996,95.750004,100310400,0.224384
1987-04-16,96.000003,100.500003,95.750004,98.500002,188092800,0.230829
1987-04-15,94.749999,96.999999,94.749999,96.000003,95961600,0.22497
1987-04-14,92.499999,95.499996,90.999996,94.000002,87379200,0.220283
1987-04-13,95.499996,95.499996,92.000001,92.499999,50256000,0.216768
1987-04-10,94.999998,95.750004,94.749999,95.625,43372800,0.224091
1987-04-09,96.75,96.75,94.250001,94.999998,71568000,0.222627
1987-04-08,94.000002,97.749996,94.000002,96.75,106214400,0.226728
1987-04-07,99.249999,99.249999,94.000002,94.000002,73728000,0.220283
1987-04-06,99.749997,99.999996,97.499997,99.249999,98956800,0.232586
1987-04-03,94.999998,100.250004,94.999998,99.749997,155606400,0.233758
1987-04-02,92.499999,96.999999,92.499999,94.999998,159955200,0.222627
1987-04-01,96.75,98.750001,90.499998,90.999996,259430400,0.213253
1987-03-31,95.499996,99.00,95.499996,96.75,125337600,0.226728
1987-03-30,91.750002,96.75,88.499997,96.75,186134400,0.226728
1987-03-27,89.750001,93.750003,89.750001,91.750002,120873600,0.215011
1987-03-26,89.874996,90.00,89.000004,89.250003,33379200,0.209152
1987-03-25,90.249999,90.749997,89.250003,89.874996,33840000,0.210617
1987-03-24,87.500001,90.749997,87.500001,90.249999,69609600,0.211495
1987-03-23,90.249999,91.500003,88.749996,89.624997,67478400,0.210031
1987-03-20,91.250004,91.250004,89.750001,90.249999,38246400,0.211495
1987-03-19,89.500002,91.250004,87.999999,91.250004,62812800,0.213839
1987-03-18,85.50,90.249999,85.50,89.500002,119347200,0.209738
1987-03-17,82.250004,85.50,81.999996,85.000002,54547200,0.199192
1987-03-16,82.500003,82.500003,79.749996,82.250004,88473600,0.192748
1987-03-13,85.875003,86.499996,81.00,82.750002,105120000,0.19392
1987-03-12,85.50,86.499996,83.499999,85.875003,71337600,0.201243
1987-03-11,85.50,85.999998,84.500004,85.50,43862400,0.200364
1987-03-10,81.749997,85.250001,81.499998,84.249996,74102400,0.197435
1987-03-09,83.25,83.499999,81.249999,81.749997,38275200,0.191576
1987-03-06,83.499999,83.999997,81.249999,83.25,63561600,0.195091
1987-03-05,79.749996,85.250001,79.749996,83.499999,128188800,0.195677
1987-03-04,74.499999,80.000004,74.25,79.749996,98179200,0.186889
1987-03-03,74.499999,75.249996,73.500003,74.499999,81100800,0.174586
1987-03-02,76.749999,76.749999,74.000001,74.499999,79516800,0.174586
1987-02-27,77.249997,77.750004,75.500004,76.749999,37555200,0.179859
1987-02-26,74.499999,79.499997,72.999996,77.249997,145209600,0.181031
1987-02-25,75.750003,77.125002,74.000001,74.499999,65001600,0.174586
1987-02-24,72.249999,76.000002,72.249999,75.750003,120816000,0.177516
1987-02-23,67.999998,73.250004,66.50,72.249999,125913600,0.169313
1987-02-20,68.75,68.75,67.000002,67.999998,87897600,0.159354
1987-02-19,71.500002,71.500002,67.999998,68.75,317750400,0.161111
1987-02-18,76.50,77.750004,71.500002,71.750001,128592000,0.168142
1987-02-17,76.000002,76.749999,74.25,76.50,70732800,0.179273
1987-02-13,76.749999,77.750004,74.25,76.000002,81763200,0.178101
1987-02-12,71.750001,77.125002,71.750001,76.749999,185731200,0.179859
1987-02-11,68.75,71.750001,68.75,71.750001,60307200,0.168142
1987-02-10,68.250001,68.50,66.749999,68.50,44668800,0.160526
1987-02-09,68.75,68.75,67.874999,68.250001,136080000,0.15994
1987-02-06,71.500002,71.875,68.50,68.874999,45619200,0.161404
1987-02-05,72.00,72.499998,70.75,71.500002,42652800,0.167556
1987-02-04,71.750001,72.249999,71.00,72.00,31737600,0.168728
1987-02-03,72.999996,73.750002,70.500001,71.750001,59328000,0.168142
1987-02-02,73.125,74.499999,72.999996,72.999996,46915200,0.171071
1987-01-30,68.75,73.250004,67.749999,73.125,104169600,0.171364
1987-01-29,71.750001,72.499998,67.250001,68.75,79228800,0.161111
1987-01-28,71.500002,72.749997,69.500001,71.750001,76723200,0.168142
1987-01-27,68.75,72.499998,68.75,71.500002,114105600,0.167556
1987-01-26,67.999998,69.500001,65.749998,68.75,116553600,0.161111
1987-01-23,74.499999,77.499996,67.50,67.50,317894400,0.158182
1987-01-22,67.749999,74.749998,65.749998,74.499999,116035200,0.174586
1987-01-21,65.000001,69.500001,63.750001,67.749999,108489600,0.158768
1987-01-20,64.00,66.50,63.750001,65.000001,95760000,0.152324
1987-01-19,61.75,64.00,60.500001,64.00,88243200,0.14998
1987-01-16,63.249999,63.249999,60.500001,61.75,65433600,0.144707
1987-01-15,59.999999,64.750002,59.999999,63.249999,117014400,0.148223
1987-01-14,59.999999,60.250002,58.749999,59.999999,69465600,0.140606
1987-01-13,61.249998,61.249998,58.999998,59.999999,76320000,0.140606
1987-01-12,58.000002,62.249999,57.50,61.75,128793600,0.144707
1987-01-09,55.750002,58.250001,55.499999,58.000002,63705600,0.135919
1987-01-08,54.249999,56.25,54.249999,55.750002,61488000,0.130647
1987-01-07,51.250002,54.00,51.250002,54.00,60998400,0.126546
1987-01-06,50.50,51.500001,50.250001,51.250002,40032000,0.120101
1987-01-05,47.749998,50.999999,47.499999,50.50,48499200,0.118344
1987-01-02,48.25,48.749999,47.499999,47.749998,12643200,0.111899
1986-12-31,47.749998,49.000002,47.749998,48.25,23356800,0.113071
1986-12-30,47.25,48.000001,46.750002,47.749998,25401600,0.111899
1986-12-29,49.250001,49.749999,47.25,47.25,41702400,0.110728
1986-12-26,49.375,49.749999,49.250001,49.250001,3715200,0.115414
1986-12-24,49.50,49.50,49.250001,49.375,7027200,0.115707
1986-12-23,49.000002,49.50,49.000002,49.50,23788800,0.116
1986-12-22,48.50,49.50,48.50,49.000002,18316800,0.114829
1986-12-19,47.499999,49.000002,47.499999,48.50,56592000,0.113657
1986-12-18,47.000001,47.499999,46.750002,47.375,12672000,0.11102
1986-12-17,46.499999,47.25,46.499999,47.000001,23356800,0.110142
1986-12-16,46.25,47.25,46.25,46.499999,77299200,0.10897
1986-12-15,47.25,47.499999,45.249999,46.00,50774400,0.107798
1986-12-12,49.000002,49.000002,47.25,47.25,25286400,0.110728
1986-12-11,48.624999,49.250001,48.50,49.000002,11635200,0.114829
1986-12-10,48.25,48.749999,47.749998,48.624999,27590400,0.11395
1986-12-09,48.50,48.749999,48.000001,48.25,16099200,0.113071
1986-12-08,49.000002,49.50,47.749998,48.50,22665600,0.113657
1986-12-05,49.250001,49.50,49.000002,49.000002,107510400,0.114829
1986-12-04,48.624999,49.749999,48.25,49.250001,42508800,0.115414
1986-12-03,49.000002,49.50,48.50,48.624999,35164800,0.11395
1986-12-02,49.000002,49.999998,49.000002,49.000002,28771200,0.114829
1986-12-01,49.749999,49.999998,48.50,48.749999,40291200,0.114243
1986-11-28,50.50,50.75,49.250001,49.749999,41328000,0.116586
1986-11-26,50.999999,51.250002,50.50,50.50,38793600,0.118344
1986-11-25,50.50,51.250002,50.250001,50.999999,95788800,0.119515
1986-11-24,46.750002,50.75,45.249999,50.50,173836800,0.118344
1986-11-21,45.499998,47.25,45.499998,46.750002,91065600,0.109556
1986-11-20,41.999999,45.249999,41.999999,45.249999,98179200,0.106041
1986-11-19,40.50,42.250002,40.50,41.999999,48729600,0.098424
1986-11-18,42.75,42.999999,40.50,40.50,59673600,0.094909
1986-11-17,42.500001,43.249998,41.999999,42.75,24307200,0.100182
1986-11-14,42.124998,42.500001,41.250001,42.500001,18720000,0.099596
1986-11-13,42.75,42.999999,41.999999,42.124998,30211200,0.098717
1986-11-12,42.75,43.75,42.250002,42.75,34156800,0.100182
1986-11-11,42.75,43.249998,42.75,42.75,11894400,0.100182
1986-11-10,44.249999,44.249999,42.250002,42.500001,28684800,0.099596
1986-11-07,44.500002,44.750001,43.500001,44.249999,44323200,0.103697
1986-11-06,43.500001,45.499998,43.249998,44.500002,72576000,0.104283
1986-11-05,40.999998,43.75,40.749999,43.500001,45100800,0.10194
1986-11-04,39.50,40.999998,39.50,40.999998,54403200,0.096081
1986-11-03,39.000001,39.749999,39.000001,39.50,42192000,0.092566
1986-10-31,39.25,39.749999,38.499999,38.749998,63734400,0.090808
1986-10-30,38.499999,39.749999,38.25,39.25,44380800,0.09198
1986-10-29,39.624999,39.749999,38.000001,38.499999,53222400,0.090222
1986-10-28,38.749998,40.250001,38.749998,39.624999,142646400,0.092859
1986-10-27,37.750002,38.749998,37.750002,38.749998,125654400,0.090808
1986-10-24,37.750002,37.750002,36.499998,37.499999,101376000,0.087879
1986-10-23,37.750002,38.000001,37.374999,37.750002,70444800,0.088465
1986-10-22,37.750002,38.125,37.499999,37.750002,54576000,0.088465
1986-10-21,36.499998,37.750002,36.499998,37.750002,112377600,0.088465
1986-10-20,36.00,36.750001,35.250001,36.249999,43545600,0.08495
1986-10-17,35.00,36.249999,35.00,36.00,124444800,0.084364
1986-10-16,35.00,35.250001,34.75,35.00,21859200,0.08202
1986-10-15,33.500001,35.250001,33.500001,35.00,63532800,0.08202
1986-10-14,33.25,33.75,33.25,33.500001,12873600,0.078505
1986-10-13,34.499999,34.499999,33.000001,33.000001,27129600,0.077334
1986-10-10,33.000001,35.250001,32.50,34.499999,76752000,0.080849
1986-10-09,32.00,33.75,32.00,33.000001,92563200,0.077334
1986-10-08,31.124999,32.375001,30.750001,32.00,119606400,0.07499
1986-10-07,30.50,31.749999,30.50,31.124999,59788800,0.07294
1986-10-06,29.000001,31.00,29.000001,30.50,85334400,0.071475
1986-10-03,28.00,28.500001,28.00,28.25,14716800,0.066202
1986-10-02,28.00,28.500001,27.749999,28.00,22723200,0.065616
1986-10-01,28.25,28.75,27.50,28.00,32428800,0.065616
1986-09-30,28.25,28.75,28.25,28.25,5184000,0.066202
1986-09-29,29.000001,29.000001,28.25,28.25,6192000,0.066202
1986-09-26,29.000001,29.25,28.75,29.000001,2332800,0.06796
1986-09-25,29.625001,29.75,29.000001,29.000001,5155200,0.06796
1986-09-24,29.999999,29.999999,29.499999,29.625001,4780800,0.069424
1986-09-23,29.499999,30.25,29.499999,29.999999,5961600,0.070303
1986-09-22,29.75,29.75,29.499999,29.499999,4492800,0.069131
1986-09-19,29.75,29.999999,29.499999,29.75,2505600,0.069717
1986-09-18,29.499999,30.25,29.499999,29.75,5356800,0.069717
1986-09-17,28.75,29.999999,28.500001,29.499999,8035200,0.069131
1986-09-16,28.75,29.000001,28.25,28.75,5184000,0.067374
1986-09-15,28.25,28.75,27.749999,28.75,22492800,0.067374
1986-09-12,29.000001,29.25,28.25,28.25,24451200,0.066202
1986-09-11,30.25,30.50,29.000001,29.000001,35654400,0.06796
1986-09-10,30.750001,31.00,30.25,30.25,10886400,0.070889
1986-09-09,30.25,31.50,30.25,30.750001,37526400,0.072061
1986-09-08,30.50,30.750001,30.25,30.25,9619200,0.070889
1986-09-05,29.25,30.50,29.000001,30.50,26352000,0.071475
1986-09-04,27.50,29.25,27.50,29.25,39427200,0.068546
1986-09-03,27.50,27.50,26.250001,27.00,18316800,0.063273
1986-09-02,28.500001,28.500001,27.375001,27.749999,5212800,0.06503
1986-08-29,29.25,29.499999,28.00,28.500001,25430400,0.066788
1986-08-28,29.25,29.499999,29.25,29.25,3427200,0.068546
1986-08-27,29.25,29.499999,29.000001,29.25,9532800,0.068546
1986-08-26,29.499999,29.499999,29.25,29.25,10857600,0.068546
1986-08-25,29.499999,29.499999,29.000001,29.499999,2419200,0.069131
1986-08-22,29.999999,30.25,29.000001,29.499999,5760000,0.069131
1986-08-21,29.999999,30.50,29.999999,29.999999,49536000,0.070303
1986-08-20,30.25,30.25,29.999999,29.999999,20764800,0.070303
1986-08-19,30.25,30.375,29.75,30.25,20390400,0.070889
1986-08-18,30.624999,30.750001,30.25,30.25,12787200,0.070889
1986-08-15,30.50,30.750001,30.25,30.624999,6105600,0.071768
1986-08-14,29.75,30.750001,29.75,30.50,20131200,0.071475
1986-08-13,29.499999,29.75,29.25,29.75,6883200,0.069717
1986-08-12,28.75,29.499999,28.75,29.499999,9993600,0.069131
1986-08-11,28.25,29.000001,28.25,28.75,7948800,0.067374
1986-08-08,27.50,28.25,27.50,27.749999,4147200,0.06503
1986-08-07,27.749999,28.00,27.249999,27.50,3657600,0.064445
1986-08-06,28.00,28.25,27.249999,27.749999,18316800,0.06503
1986-08-05,28.25,28.500001,28.00,28.00,2822400,0.065616
1986-08-04,28.25,28.25,27.50,28.25,12441600,0.066202
1986-08-01,28.500001,28.75,28.00,28.25,12902400,0.066202
1986-07-31,28.75,29.000001,28.500001,28.500001,15638400,0.066788
1986-07-30,29.75,29.75,27.749999,28.75,26409600,0.067374
1986-07-29,30.50,30.750001,29.25,29.75,14054400,0.069717
1986-07-28,31.250001,31.250001,30.50,30.50,11808000,0.071475
1986-07-25,31.00,31.50,31.00,31.250001,20448000,0.073232
1986-07-24,30.50,31.50,30.50,31.00,14140800,0.072647
1986-07-23,30.750001,31.250001,29.999999,29.999999,20793600,0.070303
1986-07-22,29.75,30.750001,29.75,30.750001,10512000,0.072061
1986-07-21,29.75,30.25,29.75,29.75,3513600,0.069717
1986-07-18,29.499999,29.999999,28.75,29.75,12326400,0.069717
1986-07-17,29.000001,29.499999,28.75,29.499999,6940800,0.069131
1986-07-16,28.25,29.000001,28.25,29.000001,9360000,0.06796
1986-07-15,27.625,28.500001,27.249999,28.00,13190400,0.065616
1986-07-14,27.249999,28.25,27.249999,27.625,28598400,0.064738
1986-07-11,27.249999,28.500001,27.249999,28.00,17395200,0.065616
1986-07-10,28.00,28.25,26.00,27.249999,46886400,0.063859
1986-07-09,29.25,29.25,27.749999,28.00,46137600,0.065616
1986-07-08,29.999999,29.999999,29.000001,29.25,14256000,0.068546
1986-07-07,31.250001,31.250001,29.999999,29.999999,14054400,0.070303
1986-07-03,31.00,31.50,31.00,31.250001,14140800,0.073232
1986-07-02,30.750001,30.750001,30.50,30.750001,52617600,0.072061
1986-07-01,30.750001,30.750001,30.50,30.750001,47577600,0.072061
1986-06-30,29.75,31.50,29.499999,30.750001,62352000,0.072061
1986-06-27,29.999999,30.25,29.499999,29.75,10396800,0.069717
1986-06-26,31.00,31.250001,29.999999,29.999999,19152000,0.070303
1986-06-25,31.50,31.749999,31.00,31.00,15235200,0.072647
1986-06-24,31.749999,32.00,31.250001,31.50,14572800,0.073818
1986-06-23,31.375,31.749999,30.750001,31.749999,46195200,0.074404
1986-06-20,31.250001,31.50,31.250001,31.375,3801600,0.073525
1986-06-19,31.50,31.749999,31.00,31.250001,8467200,0.073232
1986-06-18,31.749999,31.749999,31.00,31.50,4348800,0.073818
1986-06-17,31.50,32.249999,31.50,31.749999,13075200,0.074404
1986-06-16,31.50,31.749999,31.00,31.250001,9590400,0.073232
1986-06-13,31.50,31.749999,31.250001,31.50,7891200,0.073818
1986-06-12,32.75,32.75,31.250001,31.50,13708800,0.073818
1986-06-11,32.75,32.75,32.249999,32.75,2304000,0.076748
1986-06-10,32.75,32.75,32.249999,32.75,3427200,0.076748
1986-06-09,34.25,34.25,32.75,32.75,12672000,0.076748
1986-06-06,34.25,34.25,33.75,34.25,3427200,0.080263
1986-06-05,33.75,34.25,33.500001,34.25,13708800,0.080263
1986-06-04,33.999999,34.25,33.500001,33.75,4723200,0.079091
1986-06-03,33.999999,33.999999,33.500001,33.999999,5011200,0.079677
1986-06-02,35.00,35.00,33.999999,33.999999,19728000,0.079677
1986-05-30,33.999999,35.50,33.999999,35.00,27072000,0.08202
1986-05-29,33.000001,34.25,32.75,33.75,45676800,0.079091
1986-05-28,32.00,33.000001,32.00,33.000001,15523200,0.077334
1986-05-27,31.00,32.00,31.00,32.00,13881600,0.07499
1986-05-23,31.00,31.50,31.00,31.00,4089600,0.072647
1986-05-22,31.00,31.250001,31.00,31.00,4406400,0.072647
1986-05-21,31.50,31.749999,31.00,31.00,8092800,0.072647
1986-05-20,31.749999,31.749999,31.250001,31.50,61977600,0.073818
1986-05-19,32.249999,32.249999,31.50,31.749999,11001600,0.074404
1986-05-16,32.00,33.000001,32.00,32.249999,11952000,0.075576
1986-05-15,32.00,32.50,32.00,32.00,3801600,0.07499
1986-05-14,32.249999,32.249999,32.00,32.00,9302400,0.07499
1986-05-13,32.00,32.50,32.00,32.249999,3830400,0.075576
1986-05-12,31.749999,32.75,31.749999,32.00,10483200,0.07499
1986-05-09,32.00,32.00,31.749999,31.749999,6076800,0.074404
1986-05-08,31.749999,32.00,31.50,32.00,3542400,0.07499
1986-05-07,31.749999,32.00,31.250001,31.749999,5155200,0.074404
1986-05-06,31.749999,32.249999,31.749999,31.749999,9734400,0.074404
1986-05-05,31.749999,31.749999,31.50,31.50,3254400,0.073818
1986-05-02,31.749999,32.249999,31.50,31.749999,20246400,0.074404
1986-05-01,32.249999,32.249999,31.250001,31.749999,54345600,0.074404
1986-04-30,33.000001,33.25,31.50,32.249999,30902400,0.075576
1986-04-29,33.999999,33.999999,32.75,33.000001,30326400,0.077334
1986-04-28,33.75,34.25,33.500001,33.999999,28886400,0.079677
1986-04-25,32.00,35.124999,32.00,33.75,85795200,0.079091
1986-04-24,28.874999,32.249999,28.75,31.749999,62352000,0.074404
1986-04-23,28.75,29.000001,28.500001,28.874999,15609600,0.067667
1986-04-22,29.25,29.25,28.75,28.75,15552000,0.067374
1986-04-21,29.25,29.499999,28.500001,29.25,22924800,0.068546
1986-04-18,30.25,30.25,29.000001,29.25,21628800,0.068546
1986-04-17,29.999999,30.25,29.999999,30.25,22003200,0.070889
1986-04-16,29.000001,30.25,28.75,29.999999,31910400,0.070303
1986-04-15,29.000001,29.000001,28.00,29.000001,9302400,0.06796
1986-04-14,28.75,29.25,28.75,29.000001,12153600,0.06796
1986-04-11,28.500001,29.25,28.500001,28.75,17222400,0.067374
1986-04-10,28.00,28.500001,27.50,28.25,13881600,0.066202
1986-04-09,27.50,28.25,27.50,28.00,12153600,0.065616
1986-04-08,27.249999,28.00,27.249999,27.50,10252800,0.064445
1986-04-07,27.749999,28.00,26.750001,27.249999,16560000,0.063859
1986-04-04,27.749999,28.00,27.749999,27.749999,26582400,0.06503
1986-04-03,27.749999,28.500001,27.749999,27.749999,23040000,0.06503
1986-04-02,27.249999,28.00,27.249999,27.50,27014400,0.064445
1986-04-01,27.50,27.50,27.249999,27.249999,11088000,0.063859
1986-03-31,27.749999,27.749999,27.00,27.50,12873600,0.064445
1986-03-27,27.249999,27.749999,27.249999,27.749999,16848000,0.06503
1986-03-26,26.50,27.50,26.250001,27.249999,22752000,0.063859
1986-03-25,26.00,26.50,25.75,26.50,32083200,0.062101
1986-03-24,26.750001,26.750001,25.75,26.00,65289600,0.060929
1986-03-21,27.50,28.00,26.250001,26.750001,59990400,0.062687
1986-03-20,28.25,28.25,27.249999,27.50,58435200,0.064445
1986-03-19,28.75,29.000001,28.00,28.25,47894400,0.066202
1986-03-18,29.499999,29.75,28.500001,28.75,67766400,0.067374
1986-03-17,29.000001,29.75,29.000001,29.499999,133171200,0.069131
1986-03-14,28.00,29.499999,28.00,29.000001,308160000,0.06796
1986-03-13,25.499999,29.25,25.499999,28.00,1031788800,0.065616


================================================
FILE: examples/libraries/rapidcsv/tests/perftest.h
================================================
#pragma once

#include <chrono>

namespace perftest
{
  class Timer
  {
  public:
    void Start()
    {
      // Timestamp
      start = std::chrono::high_resolution_clock::now();
    }

    void Stop()
    {
      // Timestamps
      stop = std::chrono::high_resolution_clock::now();
      poststop = std::chrono::high_resolution_clock::now();

      // Calculate duration
      std::chrono::duration<double> span =
        std::chrono::duration_cast<std::chrono::duration<double>>(stop - start - (poststop - stop));

      // Store
      lastspan = span.count();
      spans.push_back(lastspan);
    }

    double GetLastDurationSec()
    {
      return lastspan;
    }

    double GetLastDurationUs()
    {
      return GetLastDurationSec() * 1000000.0;
    }

    double GetMedianDurationSec()
    {
      double median = 0;
      if (spans.size() > 0)
      {
        sort(spans.begin(), spans.end());
        median = spans.at(spans.size() / 2);
      }

      return median;
    }

    double GetMedianDurationUs()
    {
      return GetMedianDurationSec() * 1000000.0;
    }

    void ReportMedian()
    {
      std::cout << "Test median duration                           Elapsed   ";
      std::cout << static_cast<long long>(round(GetMedianDurationUs())) << " us\n";
    }

  private:
    std::chrono::high_resolution_clock::time_point start;
    std::chrono::high_resolution_clock::time_point stop;
    std::chrono::high_resolution_clock::time_point poststop;
    double lastspan;
    std::vector<double> spans;
  };
}


================================================
FILE: examples/libraries/rapidcsv/tests/ptest001.cpp
================================================
// ptest001.cpp - file load and get data by column, row and cell

#include <rapidcsv.h>
#include "perftest.h"
#include "unittest.h"

int main()
{
  int rv = 0;

  try
  {
    perftest::Timer timer;

    for (int i = 0; i < 10; ++i)
    {
      timer.Start();

      rapidcsv::Document doc("../tests/msft.csv", rapidcsv::LabelParams(0, 0));
      const std::vector<double>& column = doc.GetColumn<double>("Close");
      const std::vector<double>& row = doc.GetRow<double>("2016-05-23");
      const double cell = doc.GetCell<double>("Close", "2016-05-23");

      timer.Stop();

      // dummy usage of variables
      (void) column;
      (void) row;
      (void) cell;
    }

    timer.ReportMedian();
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/ptest002.cpp
================================================
// ptest002.cpp - file load

#include <rapidcsv.h>
#include "perftest.h"
#include "unittest.h"

int main()
{
  int rv = 0;

  try
  {
    perftest::Timer timer;

    for (int i = 0; i < 10; ++i)
    {
      timer.Start();

      rapidcsv::Document doc("../tests/msft.csv");

      timer.Stop();
    }

    timer.ReportMedian();
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test001.cpp
================================================
// test001.cpp - read cell value

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test002.cpp
================================================
// test002.cpp - set cell value

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string csv =
    "-,A,B,C\n"
    "1,0,0,0\n"
    "2,0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>("A", "2", "4");
    doc.SetCell<std::string>("B", "2", "16");
    doc.SetCell<std::string>("C", "2", "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test003.cpp
================================================
// test003.cpp - read column values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    ints = doc.GetColumn<int>("B");
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 9);
    unittest::ExpectEqual(int, ints.at(1), 16);

    strs = doc.GetColumn<std::string>(2);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "81");
    unittest::ExpectEqual(std::string, strs.at(1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test004.cpp
================================================
// test004.cpp - set column values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string csv =
    "-,A,B,C\n"
    "1,0,0,0\n"
    "2,0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetColumn<int>(0, std::vector<int>({ 3, 4 }));
    doc.SetColumn<int>("B", std::vector<int>({ 9, 16 }));
    doc.SetColumn<std::string>(2, std::vector<std::string>({ "81", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    strs = doc.GetColumn<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "9");
    unittest::ExpectEqual(std::string, strs.at(1), "16");

    ints = doc.GetColumn<int>("C");
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 81);
    unittest::ExpectEqual(int, ints.at(1), 256);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test005.cpp
================================================
// test005.cpp - read row values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>("2");
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test006.cpp
================================================
// test006.cpp - set row values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string csv =
    "-,A,B,C\n"
    "1,0,0,0\n"
    "2,0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetRow<int>(0, std::vector<int>({ 3, 9, 81 }));
    doc.SetRow<std::string>("2", std::vector<std::string>({ "4", "16", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>("1");
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test007.cpp
================================================
// test007.cpp - delete columns

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,B,D\n"
    "0,4,256\n"
    "1,9,6561\n"
    "2,16,65536\n"
    "3,25,390625\n"
  ;

  std::string csv =
    "-,A,B,C,D\n"
    "0,2,4,16,256\n"
    "1,3,9,81,6561\n"
    "2,4,16,256,65536\n"
    "3,5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.RemoveColumn("C");
    doc.RemoveColumn(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test008.cpp
================================================
// test008.cpp - delete rows

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C,D\n"
    "1,3,9,81,6561\n"
    "2,4,16,256,65536\n"
  ;

  std::string csv =
    "-,A,B,C,D\n"
    "0,2,4,16,256\n"
    "1,3,9,81,6561\n"
    "2,4,16,256,65536\n"
    "3,5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.RemoveRow("3");
    doc.RemoveRow(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test009.cpp
================================================
// test009.cpp - generate new document by row

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    ",A,B,C,D\n"
    "0,2,4,16,256\n"
    "1,3,9,81,6561\n"
    "2,4,16,256,65536\n"
    "3,5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false));

    doc.SetRow<int>(0, std::vector<int>({ 2, 4 }));
    doc.SetRow<int>(1, std::vector<int>({ 3, 9, 81, 6561 }));
    doc.SetRow<int>(2, std::vector<int>({ 4, 16, 256, 65536 }));
    doc.SetRow<int>(3, std::vector<int>({ 5, 25, 625, 390625 }));

    doc.SetCell<int>(2, 0, 16);
    doc.SetCell<int>(3, 0, 256);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");
    doc.SetColumnName(3, "D");

    doc.SetRowName(0, "0");
    doc.SetRowName(1, "1");
    doc.SetRowName(2, "2");
    doc.SetRowName(3, "3");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test010.cpp
================================================
// test010.cpp - generate new document by column

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    ",A,B,C,D\n"
    "0,2,4,16,256\n"
    "1,3,9,81,6561\n"
    "2,4,16,256,65536\n"
    "3,5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false));

    doc.SetColumn<int>(0, std::vector<int>({ 2, 3 }));
    doc.SetColumn<int>(1, std::vector<int>({ 4, 9, 16, 25 }));
    doc.SetColumn<int>(2, std::vector<int>({ 16, 81, 256, 625 }));
    doc.SetColumn<int>(3, std::vector<int>({ 256, 6561, 65536, 390625 }));

    doc.SetCell<int>(0, 2, 4);
    doc.SetCell<int>(0, 3, 5);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");
    doc.SetColumnName(3, "D");

    doc.SetRowName(0, "0");
    doc.SetRowName(1, "1");
    doc.SetRowName(2, "2");
    doc.SetRowName(3, "3");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test011.cpp
================================================
// test011.cpp - generate new document by cell

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    ",A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<int>(0, 1, 4);
    doc.SetCell<int>(1, 1, 16);
    doc.SetCell<int>(2, 1, 256);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");

    doc.SetRowName(0, "1");
    doc.SetRowName(1, "2");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test012.cpp
================================================
// test012.cpp - read cell value, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test013.cpp
================================================
// test013.cpp - set cell value, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "A,B,C\n"
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>(0, 1, "4");
    doc.SetCell<std::string>(1, 1, "16");
    doc.SetCell<std::string>(2, 1, "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test014.cpp
================================================
// test014.cpp - read column values, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    ints = doc.GetColumn<int>("B");
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 9);
    unittest::ExpectEqual(int, ints.at(1), 16);

    strs = doc.GetColumn<std::string>(2);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "81");
    unittest::ExpectEqual(std::string, strs.at(1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test015.cpp
================================================
// test015.cpp - set column values, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "A,B,C\n"
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    doc.SetColumn<int>(0, std::vector<int>({ 3, 4 }));
    doc.SetColumn<int>("B", std::vector<int>({ 9, 16 }));
    doc.SetColumn<std::string>(2, std::vector<std::string>({ "81", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    strs = doc.GetColumn<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "9");
    unittest::ExpectEqual(std::string, strs.at(1), "16");

    ints = doc.GetColumn<int>("C");
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 81);
    unittest::ExpectEqual(int, ints.at(1), 256);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test016.cpp
================================================
// test016.cpp - read row values, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test017.cpp
================================================
// test017.cpp - set row values, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "A,B,C\n"
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    doc.SetRow<int>(0, std::vector<int>({ 3, 9, 81 }));
    doc.SetRow<std::string>(1, std::vector<std::string>({ "4", "16", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test018.cpp
================================================
// test018.cpp - delete columns, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "B,D\n"
    "4,256\n"
    "9,6561\n"
    "16,65536\n"
    "25,390625\n"
  ;

  std::string csv =
    "A,B,C,D\n"
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    doc.RemoveColumn("C");
    doc.RemoveColumn(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test019.cpp
================================================
// test019.cpp - delete rows, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C,D\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
  ;

  std::string csv =
    "A,B,C,D\n"
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path);

    doc.RemoveRow(3);
    doc.RemoveRow(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test020.cpp
================================================
// test020.cpp - generate new document by row, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C,D\n"
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false));

    doc.SetRow<int>(0, std::vector<int>({ 2, 4 }));
    doc.SetRow<int>(1, std::vector<int>({ 3, 9, 81, 6561 }));
    doc.SetRow<int>(2, std::vector<int>({ 4, 16, 256, 65536 }));
    doc.SetRow<int>(3, std::vector<int>({ 5, 25, 625, 390625 }));

    doc.SetCell<int>(2, 0, 16);
    doc.SetCell<int>(3, 0, 256);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");
    doc.SetColumnName(3, "D");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test021.cpp
================================================
// test021.cpp - generate new document by column, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C,D\n"
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false));

    doc.SetColumn<int>(0, std::vector<int>({ 2, 3 }));
    doc.SetColumn<int>(1, std::vector<int>({ 4, 9, 16, 25 }));
    doc.SetColumn<int>(2, std::vector<int>({ 16, 81, 256, 625 }));
    doc.SetColumn<int>(3, std::vector<int>({ 256, 6561, 65536, 390625 }));

    doc.SetCell<int>(0, 2, 4);
    doc.SetCell<int>(0, 3, 5);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");
    doc.SetColumnName(3, "D");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test022.cpp
================================================
// test022.cpp - generate new document by cell, no row labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "A,B,C\n"
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<int>(0, 1, 4);
    doc.SetCell<int>(1, 1, 16);
    doc.SetCell<int>(2, 1, 256);

    doc.SetColumnName(0, "A");
    doc.SetColumnName(1, "B");
    doc.SetColumnName(2, "C");

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test023.cpp
================================================
// test023.cpp - read cell value, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test024.cpp
================================================
// test024.cpp - set cell value, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>(0, 1, "4");
    doc.SetCell<std::string>(1, 1, "16");
    doc.SetCell<std::string>(2, 1, "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test025.cpp
================================================
// test025.cpp - read column values, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    ints = doc.GetColumn<int>(1);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 9);
    unittest::ExpectEqual(int, ints.at(1), 16);

    strs = doc.GetColumn<std::string>(2);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "81");
    unittest::ExpectEqual(std::string, strs.at(1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test026.cpp
================================================
// test026.cpp - set column values, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    doc.SetColumn<int>(0, std::vector<int>({ 3, 4 }));
    doc.SetColumn<int>(1, std::vector<int>({ 9, 16 }));
    doc.SetColumn<std::string>(2, std::vector<std::string>({ "81", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetColumn<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 4);

    strs = doc.GetColumn<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 2);
    unittest::ExpectEqual(std::string, strs.at(0), "9");
    unittest::ExpectEqual(std::string, strs.at(1), "16");

    ints = doc.GetColumn<int>(2);
    unittest::ExpectEqual(size_t, ints.size(), 2);
    unittest::ExpectEqual(int, ints.at(0), 81);
    unittest::ExpectEqual(int, ints.at(1), 256);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test027.cpp
================================================
// test027.cpp - read row values, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test028.cpp
================================================
// test028.cpp - set row values, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string csv =
    "0,0,0\n"
    "0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    doc.SetRow<int>(0, std::vector<int>({ 3, 9, 81 }));
    doc.SetRow<std::string>(1, std::vector<std::string>({ "4", "16", "256" }));

    std::vector<int> ints;
    std::vector<std::string> strs;

    ints = doc.GetRow<int>(0);
    unittest::ExpectEqual(size_t, ints.size(), 3);
    unittest::ExpectEqual(int, ints.at(0), 3);
    unittest::ExpectEqual(int, ints.at(1), 9);
    unittest::ExpectEqual(int, ints.at(2), 81);

    strs = doc.GetRow<std::string>(1);
    unittest::ExpectEqual(size_t, strs.size(), 3);
    unittest::ExpectEqual(std::string, strs.at(0), "4");
    unittest::ExpectEqual(std::string, strs.at(1), "16");
    unittest::ExpectEqual(std::string, strs.at(2), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test029.cpp
================================================
// test029.cpp - delete columns, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "4,256\n"
    "9,6561\n"
    "16,65536\n"
    "25,390625\n"
  ;

  std::string csv =
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    doc.RemoveColumn(2);
    doc.RemoveColumn(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test030.cpp
================================================
// test030.cpp - delete rows, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "3,9,81,6561\n"
    "4,16,256,65536\n"
  ;

  std::string csv =
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    doc.RemoveRow(3);
    doc.RemoveRow(0);

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test031.cpp
================================================
// test031.cpp - generate new document by row, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false));

    doc.SetRow<int>(0, std::vector<int>({ 2, 4 }));
    doc.SetRow<int>(1, std::vector<int>({ 3, 9, 81, 6561 }));
    doc.SetRow<int>(2, std::vector<int>({ 4, 16, 256, 65536 }));
    doc.SetRow<int>(3, std::vector<int>({ 5, 25, 625, 390625 }));

    doc.SetCell<int>(2, 0, 16);
    doc.SetCell<int>(3, 0, 256);

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test032.cpp
================================================
// test032.cpp - generate new document by column, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "2,4,16,256\n"
    "3,9,81,6561\n"
    "4,16,256,65536\n"
    "5,25,625,390625\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false));

    doc.SetColumn<int>(0, std::vector<int>({ 2, 3 }));
    doc.SetColumn<int>(1, std::vector<int>({ 4, 9, 16, 25 }));
    doc.SetColumn<int>(2, std::vector<int>({ 16, 81, 256, 625 }));
    doc.SetColumn<int>(3, std::vector<int>({ 256, 6561, 65536, 390625 }));

    doc.SetCell<int>(0, 2, 4);
    doc.SetCell<int>(0, 3, 5);

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test033.cpp
================================================
// test033.cpp - generate new document by cell, no row/column labels

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "3,9,81\n"
    "4,16,256\n"
  ;

  std::string path = unittest::TempPath();

  try
  {
    rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<int>(0, 1, 4);
    doc.SetCell<int>(1, 1, 16);
    doc.SetCell<int>(2, 1, 256);

    doc.Save(path);

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test034.cpp
================================================
// test034.cpp - copy document

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  std::string pathcopy = unittest::TempPath();

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    rapidcsv::Document doccopy(doc);

    doccopy.Save(pathcopy);

    std::string csvread = unittest::ReadFile(pathcopy);

    unittest::ExpectEqual(std::string, csv, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);
  unittest::DeleteFile(pathcopy);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test035.cpp
================================================
// test035.cpp - custom conversion

#include <iomanip>
#include <math.h>
#include <rapidcsv.h>
#include "unittest.h"

// Data requested as ints to be converted to fixed-point two decimal numbers
namespace rapidcsv
{
  template<>
  void Converter<int>::ToVal(const std::string& pStr, int& pVal) const
  {
    pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
  }

  template<>
  void Converter<int>::ToStr(const int& pVal, std::string& pStr) const
  {
    std::ostringstream out;
    out << std::fixed << std::setprecision(2) << static_cast<float>(pVal) / 100.0f;
    pStr = out.str();
  }
}

int main()
{
  int rv = 0;

  std::string csv =
    "1,10,100,1000\n"
    "0.1,0.01,0.001,0.006\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 100);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 1000);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 10000);
    unittest::ExpectEqual(int, doc.GetCell<int>(3, 0), 100000);

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 1), 10);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 1), 1);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 1), 0);
    unittest::ExpectEqual(int, doc.GetCell<int>(3, 1), 1);

    doc.SetCell<int>(0, 0, 12345);
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 0), "123.45");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test036.cpp
================================================
// test036.cpp - supported datatypes

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "int,32767\n"
    "long,2147483647\n"
    "long long,9223372036854775807\n"
    "unsigned,65535\n"
    "unsigned long,4294967295\n"
    "unsigned long long,18446744073709551615\n"
    "float,3.3E38\n"
    "double,1.6E308\n"
    "long double,1.6E308\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 32767);
    unittest::ExpectEqual(long, doc.GetCell<long>(1, 1), 2147483647);
    unittest::ExpectEqual(long long, doc.GetCell<long long>(1, 2), 9223372036854775807);

    unittest::ExpectEqual(unsigned, doc.GetCell<unsigned>(1, 3), 65535);
    unittest::ExpectEqual(unsigned long, doc.GetCell<unsigned long>(1, 4), 4294967295);
    unittest::ExpectEqual(unsigned long long, doc.GetCell<unsigned long long>(1, 5), 18446744073709551615llu);

    float floatval = doc.GetCell<float>(1, 6);
    unittest::ExpectTrue((floatval > 3.2E38) && (floatval < 3.4E38));

    double doubleval = doc.GetCell<double>(1, 7);
    unittest::ExpectTrue((doubleval > 1.5E308) && (doubleval < 1.7E308));

    long double longdoubleval = doc.GetCell<long double>(1, 8);
    unittest::ExpectTrue((longdoubleval > 1.5E308) && (longdoubleval < 1.7E308));
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test037.cpp
================================================
// test036.cpp - double quote handling

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "1997,Ford,,Truck\n"
    " 1997, Ford, E350, Truck\n"
    " 1997 , Ford , E350 , Truck \n"
    "\"1997\",\"Ford\",\"E350\",\"Truck\"\n"
    "1997,Ford,E350,\"Super, luxurious truck\"\n"
    "1997,Ford,E350,\"Super, \"\"luxurious, fast\"\" truck\"\n"

    "Los Angeles,34°03'N,118°15'W,US\n"
    "New York City,40°42'46\"N,74°00'21\"W,US\n"
    "Paris,48°51'24\"N,2°21'03\"E,France\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1));

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 0), "1997");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 0), "Ford");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 0), "");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 0), "Truck");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), " 1997");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), " Ford");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), " E350");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 1), " Truck");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 2), " 1997 ");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 2), " Ford ");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 2), " E350 ");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 2), " Truck ");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 3), "\"1997\"");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 3), "\"Ford\"");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 3), "\"E350\"");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 3), "\"Truck\"");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 4), "1997");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 4), "Ford");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 4), "E350");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 4), "\"Super, luxurious truck\"");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 5), "1997");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 5), "Ford");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 5), "E350");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 5), "\"Super, \"\"luxurious, fast\"\" truck\"");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 6), "Los Angeles");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 6), "34°03'N");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 6), "118°15'W");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 6), "US");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 7), "New York City");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 7), "40°42'46\"N");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 7), "74°00'21\"W");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 7), "US");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 8), "Paris");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 8), "48°51'24\"N");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 8), "2°21'03\"E");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 8), "France");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test038.cpp
================================================
// test038.cpp - read windows CR/LF linebreaks

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\r\n"
    "2,4,16,256\r\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 0), "3");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 0), "9");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 0), "81");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test039.cpp
================================================
// test039.cpp - write windows CR/LF linebreaks

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\r\n"
    "1,3,9,81\r\n"
    "2,4,16,256\r\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 0), "3");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 0), "9");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 0), "81");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 1), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 1), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 1), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csv, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test040.cpp
================================================
// test040.cpp - multiple translation units, part 1

#include <rapidcsv.h>
#include "unittest.h"

int help_func();

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");

    rv += help_func();
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test040b.cpp
================================================
// test040b.cpp - multiple translation units, part 2

#include <rapidcsv.h>
#include "unittest.h"

int help_func()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test041.cpp
================================================
// test041.cpp - handling no linebreak at end of last line

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test042.cpp
================================================
// test042.cpp - test GetColumnCount() and GetRowCount()

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(size_t, doc1.GetColumnCount(), 3);
    unittest::ExpectEqual(size_t, doc1.GetRowCount(), 2);

    rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, -1));
    unittest::ExpectEqual(size_t, doc2.GetColumnCount(), 4);
    unittest::ExpectEqual(size_t, doc2.GetRowCount(), 3);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test043.cpp
================================================
// test043.cpp - read column and row values as char

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,a,b,c\n"
    "2,x,y,z\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    std::vector<char> chars;

    chars = doc.GetColumn<char>(0);
    unittest::ExpectEqual(size_t, chars.size(), 2);
    unittest::ExpectEqual(char, chars.at(0), 'a');
    unittest::ExpectEqual(char, chars.at(1), 'x');

    chars = doc.GetColumn<char>("B");
    unittest::ExpectEqual(size_t, chars.size(), 2);
    unittest::ExpectEqual(char, chars.at(0), 'b');
    unittest::ExpectEqual(char, chars.at(1), 'y');

    chars = doc.GetRow<char>("2");
    unittest::ExpectEqual(size_t, chars.size(), 3);
    unittest::ExpectEqual(char, chars.at(0), 'x');
    unittest::ExpectEqual(char, chars.at(1), 'y');
    unittest::ExpectEqual(char, chars.at(2), 'z');
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test044.cpp
================================================
// test044.cpp - set column values as char

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C\n"
    "1,a,b,c\n"
    "2,x,y,z\n"
  ;

  std::string csv =
    "-,A,B,C\n"
    "1,0,0,0\n"
    "2,0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetColumn<char>(0, std::vector<char>({ 'a', 'x' }));
    doc.SetColumn<char>(1, std::vector<char>({ 'b', 'y' }));
    doc.SetColumn<char>("C", std::vector<char>({ 'c', 'z' }));

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test045.cpp
================================================
// test045.cpp - read data with custom separator

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-;A;B;C\n"
    "1;3;9;81\n"
    "2;4;16;256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(';'));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test046.cpp
================================================
// test046.cpp - write data with custom separator

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-;A;B;C\n"
    "1;3;9;81\n"
    "2;4;16;256\n"
  ;

  std::string csv =
    "-;A;B;C\n"
    "1;0;0;0\n"
    "2;0;0;0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(';'));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>("A", "2", "4");
    doc.SetCell<std::string>("B", "2", "16");
    doc.SetCell<std::string>("C", "2", "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test047.cpp
================================================
// test047.cpp - exception on invalid conversion

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,,x,#\n"
    "2,,y,$\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    ExpectException(doc.GetCell<int>(0, 0), std::invalid_argument);
    ExpectException(doc.GetCell<int>(1, 0), std::invalid_argument);
    ExpectException(doc.GetCell<int>(2, 0), std::invalid_argument);

    ExpectException(doc.GetCell<double>(0, 1), std::invalid_argument);
    ExpectException(doc.GetCell<double>(1, 1), std::invalid_argument);
    ExpectException(doc.GetCell<double>(2, 1), std::invalid_argument);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test048.cpp
================================================
// test048.cpp - default conversion to default values

#include <cmath>
#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,,x,#\n"
    "2,,y,$\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(),
                           rapidcsv::ConverterParams(true));

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 0);
    unittest::ExpectEqual(long long, doc.GetCell<long long>(1, 0), 0);
    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(2, 0), 0);

    unittest::ExpectTrue(std::isnan(doc.GetCell<double>(0, 1)));
    unittest::ExpectTrue(std::isnan(doc.GetCell<long double>(1, 1)));
    unittest::ExpectTrue(std::isnan(doc.GetCell<float>(2, 1)));
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test049.cpp
================================================
// test049.cpp - default conversion to custom values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,,x,#\n"
    "2,,y,$\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(),
                           rapidcsv::ConverterParams(true, 0.0, 1));

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 1);
    unittest::ExpectEqual(long long, doc.GetCell<long long>(1, 0), 1);
    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(2, 0), 1);

    unittest::ExpectEqual(double, doc.GetCell<double>(0, 1), 0.0);
    unittest::ExpectEqual(long double, doc.GetCell<long double>(1, 1), 0.0);
    unittest::ExpectEqual(float, doc.GetCell<float>(2, 1), 0.0);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test050.cpp
================================================
// test050.cpp - read column header / label by index

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(std::string, doc.GetColumnName(0), "A");
    unittest::ExpectEqual(std::string, doc.GetColumnName(1), "B");
    unittest::ExpectEqual(std::string, doc.GetColumnName(2), "C");
    ExpectException(doc.GetColumnName(3), std::out_of_range);

    rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, -1));
    ExpectException(doc2.GetColumnName(0), std::out_of_range);

    rapidcsv::Document doc3(path, rapidcsv::LabelParams(0, -1));
    unittest::ExpectEqual(std::string, doc3.GetColumnName(0), "-");
    unittest::ExpectEqual(std::string, doc3.GetColumnName(1), "A");
    unittest::ExpectEqual(std::string, doc3.GetColumnName(2), "B");
    unittest::ExpectEqual(std::string, doc3.GetColumnName(3), "C");
    ExpectException(doc3.GetColumnName(4), std::out_of_range);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test051.cpp
================================================
// test051.cpp - get column and row names

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    std::vector<std::string> columnNames = doc.GetColumnNames();
    unittest::ExpectEqual(size_t, columnNames.size(), 3);
    unittest::ExpectEqual(std::string, columnNames[0], "A");
    unittest::ExpectEqual(std::string, columnNames[1], "B");
    unittest::ExpectEqual(std::string, columnNames[2], "C");

    std::vector<std::string> rowNames = doc.GetRowNames();
    unittest::ExpectEqual(size_t, rowNames.size(), 2);
    unittest::ExpectEqual(std::string, rowNames[0], "1");
    unittest::ExpectEqual(std::string, rowNames[1], "2");

    rapidcsv::Document doc2(path, rapidcsv::LabelParams(0, -1));
    std::vector<std::string> columnNames2 = doc2.GetColumnNames();
    unittest::ExpectEqual(size_t, columnNames2.size(), 4);
    unittest::ExpectEqual(std::string, columnNames2[0], "-");
    unittest::ExpectEqual(std::string, columnNames2[1], "A");
    unittest::ExpectEqual(std::string, columnNames2[2], "B");
    unittest::ExpectEqual(std::string, columnNames2[3], "C");

    rapidcsv::Document doc3(path, rapidcsv::LabelParams(-1, 0));
    std::vector<std::string> rowNames2 = doc3.GetRowNames();
    unittest::ExpectEqual(size_t, rowNames2.size(), 3);
    unittest::ExpectEqual(std::string, rowNames2[0], "-");
    unittest::ExpectEqual(std::string, rowNames2[1], "1");
    unittest::ExpectEqual(std::string, rowNames2[2], "2");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test052.cpp
================================================
// test052.cpp - read numbers with scientific notation

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,1.2e10,2.00E-07,1e100\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    double eps1 = 1.0e7;
    double exp1 = 1.2e10;
    double val1 = doc.GetCell<double>("A", "1");
    unittest::ExpectTrue(fabs(val1 - exp1) < eps1);

    double eps2 = 1.0e-10;
    double exp2 = 2.00e-07;
    double val2 = doc.GetCell<double>("B", "1");
    unittest::ExpectTrue(fabs(val2 - exp2) < eps2);

    double eps3 = 1e97;
    double exp3 = 1e100;
    double val3 = doc.GetCell<double>("C", "1");
    unittest::ExpectTrue(fabs(val3 - exp3) < eps3);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test053.cpp
================================================
// test053.cpp - write numbers with scientific notation

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvref =
    "-,A,B,C\n"
    "1,1.2e10,2.00E-07,1e100\n"
  ;

  std::string csv =
    "-,A,B,C\n"
    "1,0,0,0\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, 0));

    doc1.SetCell<double>("A", "1", 1.2e10);
    doc1.SetCell<double>("B", "1", 2.00E-07);
    doc1.SetCell<double>("C", "1", 1e100);

    doc1.Save();

    rapidcsv::Document doc2(path, rapidcsv::LabelParams(0, 0));

    double eps1 = 1.0e7;
    double exp1 = 1.2e10;
    double val1 = doc2.GetCell<double>("A", "1");
    unittest::ExpectTrue(fabs(val1 - exp1) < eps1);

    double eps2 = 1.0e-10;
    double exp2 = 2.00e-07;
    double val2 = doc2.GetCell<double>("B", "1");
    unittest::ExpectTrue(fabs(val2 - exp2) < eps2);

    double eps3 = 1e97;
    double exp3 = 1e100;
    double val3 = doc2.GetCell<double>("C", "1");
    unittest::ExpectTrue(fabs(val3 - exp3) < eps3);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test054.cpp
================================================
// test054.cpp - read from stream

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    // stream from file
    std::ifstream fstream;
    fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    fstream.open(path, std::ios::binary | std::ios::ate);
    rapidcsv::Document doc1(fstream, rapidcsv::LabelParams(0, 0));
    fstream.close();

    unittest::ExpectEqual(int, doc1.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc1.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc1.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc1.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc1.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc1.GetCell<std::string>("C", "2"), "256");

    // stream from string
    std::istringstream sstream(csv);
    rapidcsv::Document doc2(sstream, rapidcsv::LabelParams(0, 0));

    unittest::ExpectEqual(int, doc2.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc2.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc2.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc2.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc2.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc2.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test055.cpp
================================================
// test055.cpp - write to stream

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  std::string outpath = unittest::TempPath();

  try
  {
    // to file stream
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    std::ofstream ostream;
    ostream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    ostream.open(outpath, std::ios::binary | std::ios::ate);
    doc.Save(ostream);
    ostream.close();

    std::string csvread = unittest::ReadFile(outpath);
    unittest::ExpectEqual(std::string, csv, csvread);

    // to string stream
    std::ostringstream sstream;
    doc.Save(sstream);
    unittest::ExpectEqual(std::string, csv, sstream.str());
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test056.cpp
================================================
// test056.cpp - write cells containing separator character

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,\"3,8\",9,81\n"
    "2,4,16,\"256,8\"\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);
  std::string outpath = unittest::TempPath();

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    doc.SetCell<std::string>("C", "2", "256,8");
    doc.Save(outpath);
    std::string csvread = unittest::ReadFile(outpath);
    unittest::ExpectEqual(std::string, csv, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);
  unittest::DeleteFile(outpath);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test057.cpp
================================================
// test057.cpp - read UTF-16 LE

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  const unsigned char u16le[] =
  {
    0xff, 0xfe,
    0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00,
    0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 0x00,
    0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 0x00,
    0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 0x00,
    0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a, 0x00
  };
  const unsigned int u16le_len = 58;

  std::string csv(reinterpret_cast<const char *>(u16le), u16le_len);
  // "-,A,B,C\n"
  // "1,3,9,81\n"
  // "2,4,16,256\n"

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test058.cpp
================================================
// test058.cpp - read UTF-16 BE

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  const unsigned char u16be[] =
  {
    0xfe, 0xff,
    0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c,
    0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c,
    0x00, 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32,
    0x00, 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c,
    0x00, 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a
  };
  const unsigned int u16be_len = 58;

  std::string csv(reinterpret_cast<const char *>(u16be), u16be_len);
  // "-,A,B,C\n"
  // "1,3,9,81\n"
  // "2,4,16,256\n"

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test059.cpp
================================================
// test059.cpp - write UTF-16 LE

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  const unsigned char refu16le[] =
  {
    0xff, 0xfe,
    0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00,
    0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 0x00,
    0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 0x00,
    0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 0x00,
    0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a, 0x00
  };
  const unsigned int refu16le_len = 58;

  std::string csvref(reinterpret_cast<const char *>(refu16le), refu16le_len);
  // "-,A,B,C\n"
  // "1,3,9,81\n"
  // "2,4,16,256\n"

  const unsigned char u16le[] =
  {
    0xff, 0xfe,
    0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00,
    0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00,
    0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x32, 0x00, 0x2c, 0x00,
    0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00
  };
  const unsigned int u16le_len = 50;

  std::string csv(reinterpret_cast<const char *>(u16le), u16le_len);
  // "-,A,B,C\n"
  // "1,0,0,0\n"
  // "2,0,0,0\n"

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>("A", "2", "4");
    doc.SetCell<std::string>("B", "2", "16");
    doc.SetCell<std::string>("C", "2", "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test060.cpp
================================================
// test060.cpp - write UTF-16 BE

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  const unsigned char refu16be[] =
  {
    0xfe, 0xff,
    0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c,
    0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c,
    0x00, 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32,
    0x00, 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c,
    0x00, 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a
  };
  const unsigned int refu16be_len = 58;

  std::string csvref(reinterpret_cast<const char *>(refu16be), refu16be_len);
  // "-,A,B,C\n"
  // "1,3,9,81\n"
  // "2,4,16,256\n"

  const unsigned char u16be[] =
  {
    0xfe, 0xff,
    0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c,
    0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c,
    0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x32, 0x00, 0x2c,
    0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a
  };
  const unsigned int u16be_len = 50;

  std::string csv(reinterpret_cast<const char *>(u16be), u16be_len);
  // "-,A,B,C\n"
  // "1,0,0,0\n"
  // "2,0,0,0\n"

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    doc.SetCell<int>(0, 0, 3);
    doc.SetCell<int>(1, 0, 9);
    doc.SetCell<int>(2, 0, 81);

    doc.SetCell<std::string>("A", "2", "4");
    doc.SetCell<std::string>("B", "2", "16");
    doc.SetCell<std::string>("C", "2", "256");

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");

    doc.Save();

    std::string csvread = unittest::ReadFile(path);

    unittest::ExpectEqual(std::string, csvref, csvread);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test061.cpp
================================================
// test061.cpp - read trimmed cell values

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-, A,B , C \n"
    " 1,3 , 9 , 81\n"
    "2 ,4  , 16, 256  \n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', true));
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "1"), "3");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "1"), "9");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "1"), "81");

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("A", "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("B", "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>("C", "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test062.cpp
================================================
// test062.cpp - read cell value by mixed name / index

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));
    unittest::ExpectEqual(int, doc.GetCell<int>("A", 0), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>("B", 0), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>("C", 0), 81);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, "2"), "4");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, "2"), "16");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, "2"), "256");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test063.cpp
================================================
// test063.cpp - custom conversion per call

#include <iomanip>
#include <math.h>
#include <rapidcsv.h>
#include "unittest.h"

// Conversion function for int data to be converted to fixed-point two decimal numbers
void ToVal(const std::string& pStr, int& pVal)
{
  pVal = static_cast<int>(roundf(100.0f * std::stof(pStr)));
}

struct Struct
{
  int val = 0;
};

void ToStruct(const std::string& pStr, Struct& pVal)
{
  pVal.val = static_cast<int>(roundf(100.0f * std::stof(pStr)));
}

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,1,10,100,1000\n"
    "2,0.1,0.01,0.001,0.006\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0));

    // ToVal
    unittest::ExpectEqual(int, doc.GetCell<int>(0, 0, ToVal), 100);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, "1", ToVal), 1000);
    unittest::ExpectEqual(int, doc.GetCell<int>("A", 0, ToVal), 100);
    unittest::ExpectEqual(int, doc.GetCell<int>("B", "1", ToVal), 1000);

    unittest::ExpectEqual(int, doc.GetRow<int>(0, ToVal).at(0), 100);
    unittest::ExpectEqual(int, doc.GetRow<int>("2", ToVal).at(0), 10);

    unittest::ExpectEqual(int, doc.GetColumn<int>(0, ToVal).at(0), 100);
    unittest::ExpectEqual(int, doc.GetColumn<int>("B", ToVal).at(0), 1000);

    // ToStruct
    unittest::ExpectEqual(int, doc.GetCell<Struct>(0, 0, ToStruct).val, 100);
    unittest::ExpectEqual(int, doc.GetCell<Struct>(1, "1", ToStruct).val, 1000);
    unittest::ExpectEqual(int, doc.GetCell<Struct>("A", 0, ToStruct).val, 100);
    unittest::ExpectEqual(int, doc.GetCell<Struct>("B", "1", ToStruct).val, 1000);

    unittest::ExpectEqual(int, doc.GetRow<Struct>(0, ToStruct).at(0).val, 100);
    unittest::ExpectEqual(int, doc.GetRow<Struct>("2", ToStruct).at(0).val, 10);

    unittest::ExpectEqual(int, doc.GetColumn<Struct>(0, ToStruct).at(0).val, 100);
    unittest::ExpectEqual(int, doc.GetColumn<Struct>("B", ToStruct).at(0).val, 1000);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test064.cpp
================================================
// test063.cpp - linebreaks in quoted text

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csv =
    "-,A,B,C\n"
    "1,3,9,81\n"
    "2,4,16,256\n"
    "text,\"quoted text\",\"quoted\ntext\nwith\nlinebreaks\",\"\""
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csv);

  try
  {
    rapidcsv::SeparatorParams seppar;
    seppar.mQuotedLinebreaks = true;
    rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1), seppar, rapidcsv::ConverterParams());

    unittest::ExpectEqual(size_t, doc.GetRowCount(), 4);
    unittest::ExpectEqual(size_t, doc.GetColumnCount(), 4);

    unittest::ExpectEqual(char, doc.GetCell<char>(0, 0), '-');
    unittest::ExpectEqual(char, doc.GetCell<char>(1, 0), 'A');
    unittest::ExpectEqual(char, doc.GetCell<char>(2, 0), 'B');
    unittest::ExpectEqual(char, doc.GetCell<char>(3, 0), 'C');

    unittest::ExpectEqual(int, doc.GetCell<int>(0, 1), 1);
    unittest::ExpectEqual(int, doc.GetCell<int>(1, 1), 3);
    unittest::ExpectEqual(int, doc.GetCell<int>(2, 1), 9);
    unittest::ExpectEqual(int, doc.GetCell<int>(3, 1), 81);

    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(0, 2), 2);
    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(1, 2), 4);
    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(2, 2), 16);
    unittest::ExpectEqual(unsigned int, doc.GetCell<unsigned int>(3, 2), 256);

    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(0, 3), "text");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(1, 3), "\"quoted text\"");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(2, 3), "\"quoted\ntext\nwith\nlinebreaks\"");
    unittest::ExpectEqual(std::string, doc.GetCell<std::string>(3, 3), "\"\"");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test065.cpp
================================================
// test065.cpp - row/column count with header index out of data size

#include <rapidcsv.h>
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvEmpty = "";

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csvEmpty);

  try
  {
    // empty doc, column header index 0, no row header
    rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, -1));
    unittest::ExpectEqual(size_t, doc1.GetRowCount(), 0);
    unittest::ExpectEqual(size_t, doc1.GetColumnCount(), 0);

    // empty doc, row header index 0, no row header
    rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, 0));
    unittest::ExpectEqual(size_t, doc2.GetRowCount(), 0);
    unittest::ExpectEqual(size_t, doc2.GetColumnCount(), 0);

    std::string csv =
      "-,A,B,C\n"
      "1,3,9,81\n"
      "2,4,16,256\n"
    ;

    // doc with three rows, column header index 10, no row header
    std::istringstream sstream3(csv);
    rapidcsv::Document doc3(sstream3, rapidcsv::LabelParams(10, -1));
    unittest::ExpectEqual(size_t, doc3.GetRowCount(), 0);
    unittest::ExpectEqual(size_t, doc3.GetColumnCount(), 4);

    // doc with three rows, row header index 10, no column header
    std::istringstream sstream4(csv);
    rapidcsv::Document doc4(sstream4, rapidcsv::LabelParams(-1, 10));
    unittest::ExpectEqual(size_t, doc4.GetRowCount(), 3);
    unittest::ExpectEqual(size_t, doc4.GetColumnCount(), 0);
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/test066.cpp
================================================
// test066.cpp - test UTF-8 Byte order mark skipping

#include "rapidcsv.h"
#include "unittest.h"

int main()
{
  int rv = 0;

  std::string csvWithBom =
    "\xef\xbb\xbfID\n"
    "1\n"
  ;

  std::string path = unittest::TempPath();
  unittest::WriteFile(path, csvWithBom);

  try
  {
    rapidcsv::Document doc(path, rapidcsv::LabelParams(0, -1));
    unittest::ExpectEqual(size_t, doc.GetRowCount(), 1);
    unittest::ExpectEqual(std::string, doc.GetColumn<std::string>("ID")[0], "1");
  }
  catch (const std::exception& ex)
  {
    std::cout << ex.what() << std::endl;
    rv = 1;
  }

  unittest::DeleteFile(path);

  return rv;
}


================================================
FILE: examples/libraries/rapidcsv/tests/unittest.h
================================================
#pragma once

#ifndef _MSC_VER
#include <unistd.h>
#else
#include <io.h>
#endif

#include <fstream>
#include <string>
#include <sstream>


#define ExpectEqual(t, a, b) ExpectEqualFun<t>(a, b, #a, #b, __FILE__, __LINE__)
#define ExpectTrue(a) ExpectTrueFun(a, #a, __FILE__, __LINE__)

#define ExpectException(expr, excp)                                                           \
  do                                                                                          \
  {                                                                                           \
    bool success = false;                                                                     \
    try                                                                                       \
    {                                                                                         \
      expr;                                                                                   \
    }                                                                                         \
    catch (const excp &)                                                                      \
    {                                                                                         \
      success = true;                                                                         \
    }                                                                                         \
    catch (const std::exception& ex)                                                          \
    {                                                                                         \
      std::stringstream ss;                                                                   \
      ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__);          \
      ss << " ExpectException failed: unexpected exception '" << typeid(ex).name();           \
      ss << "' thrown." << std::endl;                                                         \
      throw std::runtime_error(ss.str());                                                     \
    }                                                                                         \
                                                                                              \
    if (!success)                                                                             \
    {                                                                                         \
      std::stringstream ss;                                                                   \
      ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__);          \
      ss << " ExpectException failed: expected exception '" << #excp << "' not thrown.";      \
      ss << std::endl;                                                                        \
      throw std::runtime_error(ss.str());                                                     \
    }                                                                                         \
  }                                                                                           \
  while (0)


namespace unittest
{
  namespace detail
  {
    inline std::string FileName(const std::string& pPath)
    {
      const std::size_t slash = pPath.rfind("/");
      std::string name = (slash != std::string::npos) ? pPath.substr(slash + 1) : pPath;
      return name;
    }
  }

  inline std::string TempPath()
  {
    char name[] = "rapidcsvtest.XXXXXX";
#ifndef _MSC_VER
    int fd = mkstemp(name);
    close(fd);
#else
    _mktemp_s(name, strlen(name) + 1);
#endif
    return std::string(name);
  }

  inline void WriteFile(const std::string& pPath, const std::string& pData)
  {
    std::ofstream outfile;
    outfile.open(pPath, std::ifstream::out | std::ifstream::binary);
    outfile << pData;
    outfile.close();
  }

  inline std::string ReadFile(const std::string& pPath)
  {
    std::ifstream infile;
    infile.open(pPath, std::ifstream::in | std::ifstream::binary);
    std::string data((std::istreambuf_iterator<char>(infile)), std::istreambuf_iterator<char>());
    infile.close();
    return data;
  }

  inline void DeleteFile(const std::string& pPath)
  {
    std::remove(pPath.c_str());
  }

  template<typename T>
  inline void ExpectEqualFun(T pTest, T pRef, const std::string& testName,
                             const std::string& refName, const std::string& filePath, int lineNo)
  {
    if (pTest != pRef)
    {
      std::stringstream ss;
      ss << detail::FileName(filePath) << ":" << std::to_string(lineNo);
      ss << " ExpectEqual failed: " << testName << " != " << refName << std::endl;
      ss << testName << " = '" << pTest << "'" << std::endl;
      ss << refName << " = '" << pRef << "'" << std::endl;

      throw std::runtime_error(ss.str());
    }
  }

  inline void ExpectTrueFun(bool pTest, const std::string& testName, const std::string& filePath,
                            int lineNo)
  {
    if (!pTest)
    {
      std::stringstream ss;
      ss << detail::FileName(filePath) << ":" << std::to_string(lineNo);
      ss << " ExpectTrue failed: " << testName << " == false" << std::endl;

      throw std::runtime_error(ss.str());
    }
  }
}


================================================
FILE: examples/libraries/rapidcsv/uncrustify.cfg
================================================
# Uncrustify 0.64

#
# General options
#

# The type of line endings. Default=Auto
newlines                        = lf       # auto/lf/crlf/cr

# The original size of tabs in the input. Default=8
input_tab_size                  = 2        # number

# The size of tabs in the output (only used if align_with_tabs=true). Default=8
output_tab_size                 = 2        # number

# The ASCII value of the string escape char, usually 92 (\) or 94 (^). (Pawn)
string_escape_char              = 92       # number

# Alternate string escape char for Pawn. Only works right before the quote char.
string_escape_char2             = 0        # number

# Replace tab characters found in string literals with the escape sequence \t instead.
string_replace_tab_chars        = false    # false/true

# Allow interpreting '>=' and '>>=' as part of a template in 'void f(list<list<B>>=val);'.
# If true, 'assert(x<0 && y>=3)' will be broken. Default=False
# Improvements to template detection may make this option obsolete.
tok_split_gte                   = false    # false/true

# Override the default ' *INDENT-OFF*' in comments for disabling processing of part of the file.
disable_processing_cmt          = ""         # string

# Override the default ' *INDENT-ON*' in comments for enabling processing of part of the file.
enable_processing_cmt           = ""         # string

# Enable parsing of digraphs. Default=False
enable_digraphs                 = false    # false/true

# Control what to do with the UTF-8 BOM (recommend 'remove')
utf8_bom                        = remove   # ignore/add/remove/force

# If the file contains bytes with values between 128 and 255, but is not UTF-8, then output as UTF-8
utf8_byte                       = false    # false/true

# Force the output encoding to UTF-8
utf8_force                      = false    # false/true

#
# Indenting
#

# The number of columns to indent per level.
# Usually 2, 3, 4, or 8. Default=8
indent_columns                  = 2        # number

# The continuation indent. If non-zero, this overrides the indent of '(' and '=' continuation indents.
# For FreeBSD, this is set to 4. Negative value is absolute and not increased for each ( level
indent_continue                 = 0        # number

# How to use tabs when indenting code
# 0=spaces only
# 1=indent with tabs to brace level, align with spaces (default)
# 2=indent and align with tabs, using spaces when not on a tabstop
indent_with_tabs                = 0        # number

# Comments that are not a brace level are indented with tabs on a tabstop.
# Requires indent_with_tabs=2. If false, will use spaces.
indent_cmt_with_tabs            = false    # false/true

# Whether to indent strings broken by '\' so that they line up
indent_align_string             = false    # false/true

# The number of spaces to indent multi-line XML strings.
# Requires indent_align_string=True
indent_xml_string               = 0        # number

# Spaces to indent '{' from level
indent_brace                    = 0        # number

# Whether braces are indented to the body level
indent_braces                   = false    # false/true

# Disabled indenting function braces if indent_braces is true
indent_braces_no_func           = false    # false/true

# Disabled indenting class braces if indent_braces is true
indent_braces_no_class          = false    # false/true

# Disabled indenting struct braces if indent_braces is true
indent_braces_no_struct         = false    # false/true

# Indent based on the size of the brace parent, i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc.
indent_brace_parent             = false    # false/true

# Indent based on the paren open instead of the brace open in '({\n', default is to indent by brace.
indent_paren_open_brace         = false    # false/true

# indent a C# delegate by another level, default is to not indent by another level.
indent_cs_delegate_brace        = false    # false/true

# Whether the 'namespace' body is indented
indent_namespace                = true     # false/true

# Only indent one namespace and no sub-namespaces.
# Requires indent_namespace=true.
indent_namespace_single_indent  = false    # false/true

# The number of spaces to indent a namespace block
indent_namespace_level          = 2        # number

# If the body of the namespace is longer than this number, it won't be indented.
# Requires indent_namespace=true. Default=0 (no limit)
indent_namespace_limit          = 0        # number

# Whether the 'extern "C"' body is indented
indent_extern                   = false    # false/true

# Whether the 'class' body is indented
indent_class                    = true     # false/true

# Whether to indent the stuff after a leading base class colon
indent_class_colon              = false    # false/true

# Indent based on a class colon instead of the stuff after the colon.
# Requires indent_class_colon=true. Default=False
indent_class_on_colon           = false    # false/true

# Whether to indent the stuff after a leading class initializer colon
indent_constr_colon             = false    # false/true

# Virtual indent from the ':' for member initializers. Default=2
indent_ctor_init_leading        = 2        # number

# Additional indenting for constructor initializer list
indent_ctor_init                = 0        # number

# False=treat 'else\nif' as 'else if' for indenting purposes
# True=indent the 'if' one level
indent_else_if                  = false    # false/true

# Amount to indent variable declarations after a open brace. neg=relative, pos=absolute
indent_var_def_blk              = 0        # number

# Indent continued variable declarations instead of aligning.
indent_var_def_cont             = false    # false/true

# Indent continued shift expressions ('<<' and '>>') instead of aligning.
# Turn align_left_shift off when enabling this.
indent_shift                    = false    # false/true

# True:  force indentation of function definition to start in column 1
# False: use the default behavior
indent_func_def_force_col1      = false    # false/true

# True:  indent continued function call parameters one indent level
# False: align parameters under the open paren
indent_func_call_param          = false    # false/true

# Same as indent_func_call_param, but for function defs
indent_func_def_param           = false    # false/true

# Same as indent_func_call_param, but for function protos
indent_func_proto_param         = false    # false/true

# Same as indent_func_call_param, but for class declarations
indent_func_class_param         = false    # false/true

# Same as indent_func_call_param, but for class variable constructors
indent_func_ctor_var_param      = false    # false/true

# Same as indent_func_call_param, but for templates
indent_template_param           = false    # false/true

# Double the indent for indent_func_xxx_param options
indent_func_param_double        = false    # false/true

# Indentation column for standalone 'const' function decl/proto qualifier
indent_func_const               = 0        # number

# Indentation column for standalone 'throw' function decl/proto qualifier
indent_func_throw               = 0        # number

# The number of spaces to indent a continued '->' or '.'
# Usually set to 0, 1, or indent_columns.
indent_member                   = 0        # number

# Spaces to indent single line ('//') comments on lines before code
indent_sing_line_comments       = 0        # number

# If set, will indent trailing single line ('//') comments relative
# to the code instead of trying to keep the same absolute column
indent_relative_single_line_comments = false    # false/true

# Spaces to indent 'case' from 'switch'
# Usually 0 or indent_columns.
indent_switch_case              = 0        # number

# Spaces to shift the 'case' line, without affecting any other lines
# Usually 0.
indent_case_shift               = 0        # number

# Spaces to indent '{' from 'case'.
# By default, the brace will appear under the 'c' in case.
# Usually set to 0 or indent_columns.
indent_case_brace               = 0        # number

# Whether to indent comments found in first column
indent_col1_comment             = false    # false/true

# How to indent goto labels
#   >0: absolute column where 1 is the leftmost column
#  <=0: subtract from brace indent
# Default=1
indent_label                    = 1        # number

# Same as indent_label, but for access specifiers that are followed by a colon. Default=1
indent_access_spec              = -2       # number

# Indent the code after an access specifier by one level.
# If set, this option forces 'indent_access_spec=0'
indent_access_spec_body         = false    # false/true

# If an open paren is followed by a newline, indent the next line so that it lines up after the open paren (not recommended)
indent_paren_nl                 = false    # false/true

# Controls the indent of a close paren after a newline.
# 0: Indent to body level
# 1: Align under the open paren
# 2: Indent to the brace level
indent_paren_close              = 0        # number

# Controls the indent of a comma when inside a paren.If TRUE, aligns under the open paren
indent_comma_paren              = false    # false/true

# Controls the indent of a BOOL operator when inside a paren.If TRUE, aligns under the open paren
indent_bool_paren               = false    # false/true

# If 'indent_bool_paren' is true, controls the indent of the first expression. If TRUE, aligns the first expression to the following ones
indent_first_bool_expr          = false    # false/true

# If an open square is followed by a newline, indent the next line so that it lines up after the open square (not recommended)
indent_square_nl                = false    # false/true

# Don't change the relative indent of ESQL/C 'EXEC SQL' bodies
indent_preserve_sql             = false    # false/true

# Align continued statements at the '='. Default=True
# If FALSE or the '=' is followed by a newline, the next line is indent one tab.
indent_align_assign             = false    # false/true

# Indent OC blocks at brace level instead of usual rules.
indent_oc_block                 = false    # false/true

# Indent OC blocks in a message relative to the parameter name.
# 0=use indent_oc_block rules, 1+=spaces to indent
indent_oc_block_msg             = 0        # number

# Minimum indent for subsequent parameters
indent_oc_msg_colon             = 0        # number

# If true, prioritize aligning with initial colon (and stripping spaces from lines, if necessary).
# Default=True.
indent_oc_msg_prioritize_first_colon = true     # false/true

# If indent_oc_block_msg and this option are on, blocks will be indented the way that Xcode does by default (from keyword if the parameter is on its own line; otherwise, from the previous indentation level).
indent_oc_block_msg_xcode_style = false    # false/true

# If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg keyword.
indent_oc_block_msg_from_keyword = false    # false/true

# If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is relative to a msg colon.
indent_oc_block_msg_from_colon  = false    # false/true

# If indent_oc_block_msg and this option are on, blocks will be indented from where the block caret is.
indent_oc_block_msg_from_caret  = false    # false/true

# If indent_oc_block_msg and this option are on, blocks will be indented from where the brace is.
indent_oc_block_msg_from_brace  = false    # false/true

# When identing after virtual brace open and newline add further spaces to reach this min. indent.
indent_min_vbrace_open          = 0        # number

# TRUE: When identing after virtual brace open and newline add further spaces after regular indent to reach next tabstop.
indent_vbrace_open_on_tabstop   = false    # false/true

# If true, a brace followed by another token (not a newline) will indent all contained lines to match the token.Default=True.
indent_token_after_brace        = true     # false/true

# If true, cpp lambda body will be indentedDefault=False.
indent_cpp_lambda_body          = false    # false/true

# Indent the continuation of ternary operator.
#  0: (Default) off
#  1: When the `if_false` is a continuation, indent it under `if_false`
#  2: When the `:` is a continuation, indent it under `?`
indent_ternary_operator         = 2

#
# Spacing options
#

# Add or remove space around arithmetic operator '+', '-', '/', '*', etc
# also '>>>' '<<' '>>' '%' '|'
sp_arith                        = force    # ignore/add/remove/force

# Add or remove space around assignment operator '=', '+=', etc
sp_assign                       = force    # ignore/add/remove/force

# Add or remove space around '=' in C++11 lambda capture specifications. Overrides sp_assign
sp_cpp_lambda_assign            = force    # ignore/add/remove/force

# Add or remove space after the capture specification in C++11 lambda.
sp_cpp_lambda_paren             = remove   # ignore/add/remove/force

# Add or remove space around assignment operator '=' in a prototype
sp_assign_default               = force    # ignore/add/remove/force

# Add or remove space before assignment operator '=', '+=', etc. Overrides sp_assign.
sp_before_assign                = force    # ignore/add/remove/force

# Add or remove space after assignment operator '=', '+=', etc. Overrides sp_assign.
sp_after_assign                 = force    # ignore/add/remove/force

# Add or remove space in 'NS_ENUM ('
sp_enum_paren                   = force    # ignore/add/remove/force

# Add or remove space around assignment '=' in enum
sp_enum_assign                  = force    # ignore/add/remove/force

# Add or remove space before assignment '=' in enum. Overrides sp_enum_assign.
sp_enum_before_assign           = force    # ignore/add/remove/force

# Add or remove space after assignment '=' in enum. Overrides sp_enum_assign.
sp_enum_after_assign            = force    # ignore/add/remove/force

# Add or remove space around preprocessor '##' concatenation operator. Default=Add
sp_pp_concat                    = add      # ignore/add/remove/force

# Add or remove space after preprocessor '#' stringify operator. Also affects the '#@' charizing operator.
sp_pp_stringify                 = ignore   # ignore/add/remove/force

# Add or remove space before preprocessor '#' stringify operator as in '#define x(y) L#y'.
sp_before_pp_stringify          = ignore   # ignore/add/remove/force

# Add or remove space around boolean operators '&&' and '||'
sp_bool                         = force    # ignore/add/remove/force

# Add or remove space around compare operator '<', '>', '==', etc
sp_compare                      = force    # ignore/add/remove/force

# Add or remove space inside '(' and ')'
sp_inside_paren                 = remove   # ignore/add/remove/force

# Add or remove space between nested parens: '((' vs ') )'
sp_paren_paren                  = remove   # ignore/add/remove/force

# Add or remove space between back-to-back parens: ')(' vs ') ('
sp_cparen_oparen                = remove   # ignore/add/remove/force

# Whether to balance spaces inside nested parens
sp_balance_nested_parens        = false    # false/true

# Add or remove space between ')' and '{'
sp_paren_brace                  = force    # ignore/add/remove/force

# Add or remove space before pointer star '*'
sp_before_ptr_star              = remove   # ignore/add/remove/force

# Add or remove space before pointer star '*' that isn't followed by a variable name
# If set to 'ignore', sp_before_ptr_star is used instead.
sp_before_unnamed_ptr_star      = force    # ignore/add/remove/force

# Add or remove space between pointer stars '*'
sp_between_ptr_star             = force    # ignore/add/remove/force

# Add or remove space after pointer star '*', if followed by a word.
sp_after_ptr_star               = force    # ignore/add/remove/force

# Add or remove space after pointer star '*', if followed by a qualifier.
sp_after_ptr_star_qualifier     = force    # ignore/add/remove/force

# Add or remove space after a pointer star '*', if followed by a func proto/def.
sp_after_ptr_star_func          = force    # ignore/add/remove/force

# Add or remove space after a pointer star '*', if followed by an open paren (function types).
sp_ptr_star_paren               = force    # ignore/add/remove/force

# Add or remove space before a pointer star '*', if followed by a func proto/def.
sp_before_ptr_star_func         = remove   # ignore/add/remove/force

# Add or remove space before a reference sign '&'
sp_before_byref                 = remove   # ignore/add/remove/force

# Add or remove space before a reference sign '&' that isn't followed by a variable name
# If set to 'ignore', sp_before_byref is used instead.
sp_before_unnamed_byref         = force    # ignore/add/remove/force

# Add or remove space after reference sign '&', if followed by a word.
sp_after_byref                  = force    # ignore/add/remove/force

# Add or remove space after a reference sign '&', if followed by a func proto/def.
sp_after_byref_func             = force    # ignore/add/remove/force

# Add or remove space before a reference sign '&', if followed by a func proto/def.
sp_before_byref_func            = remove   # ignore/add/remove/force

# Add or remove space between type and word. Default=Force
sp_after_type                   = force    # ignore/add/remove/force

# Add or remove space before the paren in the D constructs 'template Foo(' and 'class Foo('.
sp_before_template_paren        = force    # ignore/add/remove/force

# Add or remove space in 'template <' vs 'template<'.
# If set to ignore, sp_before_angle is used.
sp_template_angle               = remove   # ignore/add/remove/force

# Add or remove space before '<>'
sp_before_angle                 = remove   # ignore/add/remove/force

# Add or remove space inside '<' and '>'
sp_inside_angle                 = remove   # ignore/add/remove/force

# Add or remove space after '<>'
sp_after_angle                  = remove   # ignore/add/remove/force

# Add or remove space between '<>' and '(' as found in 'new List<byte>(foo);'
sp_angle_paren                  = remove   # ignore/add/remove/force

# Add or remove space between '<>' and '()' as found in 'new List<byte>();'
sp_angle_paren_empty            = remove   # ignore/add/remove/force

# Add or remove space between '<>' and a word as in 'List<byte> m;' or 'template <typename T> static ...'
sp_angle_word                   = force    # ignore/add/remove/force

# Add or remove space between '>' and '>' in '>>' (template stuff C++/C# only). Default=Add
sp_angle_shift                  = remove   # ignore/add/remove/force

# Permit removal of the space between '>>' in 'foo<bar<int> >' (C++11 only). Default=False
# sp_angle_shift cannot remove the space without this option.
sp_permit_cpp11_shift           = true     # false/true

# Add or remove space before '(' of 'if', 'for', 'switch', 'while', etc.
sp_before_sparen                = force    # ignore/add/remove/force

# Add or remove space inside if-condition '(' and ')'
sp_inside_sparen                = remove   # ignore/add/remove/force

# Add or remove space before if-condition ')'. Overrides sp_inside_sparen.
sp_inside_sparen_close          = remove   # ignore/add/remove/force

# Add or remove space after if-condition '('. Overrides sp_inside_sparen.
sp_inside_sparen_open           = remove   # ignore/add/remove/force

# Add or remove space after ')' of 'if', 'for', 'switch', and 'while', etc.
sp_after_sparen                 = remove   # ignore/add/remove/force

# Add or remove space between ')' and '{' of 'if', 'for', 'switch', and 'while', etc.
sp_sparen_brace                 = force    # ignore/add/remove/force

# Add or remove space between 'invariant' and '(' in the D language.
sp_invariant_paren              = force    # ignore/add/remove/force

# Add or remove space after the ')' in 'invariant (C) c' in the D language.
sp_after_invariant_paren        = force    # ignore/add/remove/force

# Add or remove space before empty statement ';' on 'if', 'for' and 'while'
sp_special_semi                 = force    # ignore/add/remove/force

# Add or remove space before ';'. Default=Remove
sp_before_semi                  = remove   # ignore/add/remove/force

# Add or remove space before ';' in non-empty 'for' statements
sp_before_semi_for              = remove   # ignore/add/remove/force

# Add or remove space before a semicolon of an empty part of a for statement.
sp_before_semi_for_empty        = remove   # ignore/add/remove/force

# Add or remove space after ';', except when followed by a comment. Default=Add
sp_after_semi                   = add      # ignore/add/remove/force

# Add or remove space after ';' in non-empty 'for' statements. Default=Force
sp_after_semi_for               = force    # ignore/add/remove/force

# Add or remove space after the final semicolon of an empty part of a for statement: for ( ; ; <here> ).
sp_after_semi_for_empty         = force    # ignore/add/remove/force

# Add or remove space before '[' (except '[]')
sp_before_square                = remove   # ignore/add/remove/force

# Add or remove space before '[]'
sp_before_squares               = remove   # ignore/add/remove/force

# Add or remove space inside a non-empty '[' and ']'
sp_inside_square                = remove   # ignore/add/remove/force

# Add or remove space after ','
sp_after_comma                  = force    # ignore/add/remove/force

# Add or remove space before ','. Default=Remove
sp_before_comma                 = remove   # ignore/add/remove/force

# Add or remove space between ',' and ']' in multidimensional array type 'int[,,]'
sp_after_mdatype_commas         = remove   # ignore/add/remove/force

# Add or remove space between '[' and ',' in multidimensional array type 'int[,,]'
sp_before_mdatype_commas        = remove   # ignore/add/remove/force

# Add or remove space between ',' in multidimensional array type 'int[,,]'
sp_between_mdatype_commas       = remove   # ignore/add/remove/force

# Add or remove space between an open paren and comma: '(,' vs '( ,'. Default=Force
sp_paren_comma                  = remove   # ignore/add/remove/force

# Add or remove space before the variadic '...' when preceded by a non-punctuator
sp_before_ellipsis              = remove   # ignore/add/remove/force

# Add or remove space after class ':'
sp_after_class_colon            = force    # ignore/add/remove/force

# Add or remove space before class ':'
sp_before_class_colon           = force    # ignore/add/remove/force

# Add or remove space after class constructor ':'
sp_after_constr_colon           = force    # ignore/add/remove/force

# Add or remove space before class constructor ':'
sp_before_constr_colon          = force    # ignore/add/remove/force

# Add or remove space before case ':'. Default=Remove
sp_before_case_colon            = remove   # ignore/add/remove/force

# Add or remove space between 'operator' and operator sign
sp_after_operator               = force    # ignore/add/remove/force

# Add or remove space between the operator symbol and the open paren, as in 'operator ++('
sp_after_operator_sym           = force    # ignore/add/remove/force

# Add or remove space between the operator symbol and the open paren when the operator has no arguments, as in 'operator *()'
sp_after_operator_sym_empty     = force    # ignore/add/remove/force

# Add or remove space after C/D cast, i.e. 'cast(int)a' vs 'cast(int) a' or '(int)a' vs '(int) a'
sp_after_cast                   = force    # ignore/add/remove/force

# Add or remove spaces inside cast parens
sp_inside_paren_cast            = remove   # ignore/add/remove/force

# Add or remove space between the type and open paren in a C++ cast, i.e. 'int(exp)' vs 'int (exp)'
sp_cpp_cast_paren               = remove   # ignore/add/remove/force

# Add or remove space between 'sizeof' and '('
sp_sizeof_paren                 = remove   # ignore/add/remove/force

# Add or remove space after the tag keyword (Pawn)
sp_after_tag                    = force    # ignore/add/remove/force

# Add or remove space inside enum '{' and '}'
sp_inside_braces_enum           = force    # ignore/add/remove/force

# Add or remove space inside struct/union '{' and '}'
sp_inside_braces_struct         = force    # ignore/add/remove/force

# Add or remove space inside '{' and '}'
sp_inside_braces                = force    # ignore/add/remove/force

# Add or remove space inside '{}'
sp_inside_braces_empty          = force    # ignore/add/remove/force

# Add or remove space between return type and function name
# A minimum of 1 is forced except for pointer return types.
sp_type_func                    = force    # ignore/add/remove/force

# Add or remove space between function name and '(' on function declaration
sp_func_proto_paren             = remove   # ignore/add/remove/force

# Add or remove space between function name and '()' on function declaration without parameters
sp_func_proto_paren_empty       = remove   # ignore/add/remove/force

# Add or remove space between function name and '(' on function definition
sp_func_def_paren               = remove   # ignore/add/remove/force

# Add or remove space between function name and '()' on function definition without parameters
sp_func_def_paren_empty         = remove   # ignore/add/remove/force

# Add or remove space inside empty function '()'
sp_inside_fparens               = remove   # ignore/add/remove/force

# Add or remove space inside function '(' and ')'
sp_inside_fparen                = remove   # ignore/add/remove/force

# Add or remove space inside the first parens in the function type: 'void (*x)(...)'
sp_inside_tparen                = remove   # ignore/add/remove/force

# Add or remove between the parens in the function type: 'void (*x)(...)'
sp_after_tparen_close           = remove   # ignore/add/remove/force

# Add or remove space between ']' and '(' when part of a function call.
sp_square_fparen                = remove   # ignore/add/remove/force

# Add or remove space between ')' and '{' of function
sp_fparen_brace                 = force    # ignore/add/remove/force

# Java: Add or remove space between ')' and '{{' of double brace initializer.
sp_fparen_dbrace                = force    # ignore/add/remove/force

# Add or remove space between function name and '(' on function calls
sp_func_call_paren              = remove   # ignore/add/remove/force

# Add or remove space between function name and '()' on function calls without parameters.
# If set to 'ignore' (the default), sp_func_call_paren is used.
sp_func_call_paren_empty        = remove   # ignore/add/remove/force

# Add or remove space between the user function name and '(' on function calls
# You need to set a keyword to be a user function, like this: 'set func_call_user _' in the config file.
sp_func_call_user_paren         = remove   # ignore/add/remove/force

# Add or remove space between a constructor/destructor and the open paren
sp_func_class_paren             = remove   # ignore/add/remove/force

# Add or remove space between a constructor without parameters or destructor and '()'
sp_func_class_paren_empty       = remove   # ignore/add/remove/force

# Add or remove space between 'return' and '('
sp_return_paren                 = force    # ignore/add/remove/force

# Add or remove space between '__attribute__' and '('
sp_attribute_paren              = force    # ignore/add/remove/force

# Add or remove space between 'defined' and '(' in '#if defined (FOO)'
sp_defined_paren                = remove   # ignore/add/remove/force

# Add or remove space between 'throw' and '(' in 'throw (something)'
sp_throw_paren                  = remove   # ignore/add/remove/force

# Add or remove space between 'throw' and anything other than '(' as in '@throw [...];'
sp_after_throw                  = force    # ignore/add/remove/force

# Add or remove space between 'catch' and '(' in 'catch (something) { }'
# If set to ignore, sp_before_sparen is used.
sp_catch_paren                  = force    # ignore/add/remove/force

# Add or remove space between 'version' and '(' in 'version (something) { }' (D language)
# If set to ignore, sp_before_sparen is used.
sp_version_paren                = force    # ignore/add/remove/force

# Add or remove space between 'scope' and '(' in 'scope (something) { }' (D language)
# If set to ignore, sp_before_sparen is used.
sp_scope_paren                  = force    # ignore/add/remove/force

# Add or remove space between 'super' and '(' in 'super (something)'. Default=Remove
sp_super_paren                  = remove   # ignore/add/remove/force

# Add or remove space between 'this' and '(' in 'this (something)'. Default=Remove
sp_this_paren                   = remove   # ignore/add/remove/force

# Add or remove space between macro and value
sp_macro                        = force    # ignore/add/remove/force

# Add or remove space between macro function ')' and value
sp_macro_func                   = force    # ignore/add/remove/force

# Add or remove space between 'else' and '{' if on the same line
sp_else_brace                   = force    # ignore/add/remove/force

# Add or remove space between '}' and 'else' if on the same line
sp_brace_else                   = force    # ignore/add/remove/force

# Add or remove space between '}' and the name of a typedef on the same line
sp_brace_typedef                = force    # ignore/add/remove/force

# Add or remove space between 'catch' and '{' if on the same line
sp_catch_brace                  = force    # ignore/add/remove/force

# Add or remove space between '}' and 'catch' if on the same line
sp_brace_catch                  = force    # ignore/add/remove/force

# Add or remove space between 'finally' and '{' if on the same line
sp_finally_brace                = force    # ignore/add/remove/force

# Add or remove space between '}' and 'finally' if on the same line
sp_brace_finally                = force    # ignore/add/remove/force

# Add or remove space between 'try' and '{' if on the same line
sp_try_brace                    = force    # ignore/add/remove/force

# Add or remove space between get/set and '{' if on the same line
sp_getset_brace                 = force    # ignore/add/remove/force

# Add or remove space between a variable and '{' for C++ uniform initialization. Default=Add
sp_word_brace                   = add      # ignore/add/remove/force

# Add or remove space between a variable and '{' for a namespace. Default=Add
sp_word_brace_ns                = add      # ignore/add/remove/force

# Add or remove space before the '::' operator
sp_before_dc                    = remove   # ignore/add/remove/force

# Add or remove space after the '::' operator
sp_after_dc                     = remove   # ignore/add/remove/force

# Add or remove around the D named array initializer ':' operator
sp_d_array_colon                = force    # ignore/add/remove/force

# Add or remove space after the '!' (not) operator. Default=Remove
sp_not                          = remove   # ignore/add/remove/force

# Add or remove space after the '~' (invert) operator. Default=Remove
sp_inv                          = remove   # ignore/add/remove/force

# Add or remove space after the '&' (address-of) operator. Default=Remove
# This does not affect the spacing after a '&' that is part of a type.
sp_addr                         = remove   # ignore/add/remove/force

# Add or remove space around the '.' or '->' operators. Default=Remove
sp_member                       = remove   # ignore/add/remove/force

# Add or remove space after the '*' (dereference) operator. Default=Remove
# This does not affect the spacing after a '*' that is part of a type.
sp_deref                        = remove   # ignore/add/remove/force

# Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. Default=Remove
sp_sign                         = remove   # ignore/add/remove/force

# Add or remove space before or after '++' and '--', as in '(--x)' or 'y++;'. Default=Remove
sp_incdec                       = remove   # ignore/add/remove/force

# Add or remove space before a backslash-newline at the end of a line. Default=Add
sp_before_nl_cont               = add      # ignore/add/remove/force

# Add or remove space after the scope '+' or '-', as in '-(void) foo;' or '+(int) bar;'
sp_after_oc_scope               = force    # ignore/add/remove/force

# Add or remove space after the colon in message specs
# '-(int) f:(int) x;' vs '-(int) f: (int) x;'
sp_after_oc_colon               = force    # ignore/add/remove/force

# Add or remove space before the colon in message specs
# '-(int) f: (int) x;' vs '-(int) f : (int) x;'
sp_before_oc_colon              = force    # ignore/add/remove/force

# Add or remove space after the colon in immutable dictionary expression
# 'NSDictionary *test = @{@"foo" :@"bar"};'
sp_after_oc_dict_colon          = force    # ignore/add/remove/force

# Add or remove space before the colon in immutable dictionary expression
# 'NSDictionary *test = @{@"foo" :@"bar"};'
sp_before_oc_dict_colon         = force    # ignore/add/remove/force

# Add or remove space after the colon in message specs
# '[object setValue:1];' vs '[object setValue: 1];'
sp_after_send_oc_colon          = force    # ignore/add/remove/force

# Add or remove space before the colon in message specs
# '[object setValue:1];' vs '[object setValue :1];'
sp_before_send_oc_colon         = force    # ignore/add/remove/force

# Add or remove space after the (type) in message specs
# '-(int)f: (int) x;' vs '-(int)f: (int)x;'
sp_after_oc_type                = force    # ignore/add/remove/force

# Add or remove space after the first (type) in message specs
# '-(int) f:(int)x;' vs '-(int)f:(int)x;'
sp_after_oc_return_type         = force    # ignore/add/remove/force

# Add or remove space between '@selector' and '('
# '@selector(msgName)' vs '@selector (msgName)'
# Also applies to @protocol() constructs
sp_after_oc_at_sel              = force    # ignore/add/remove/force

# Add or remove space between '@selector(x)' and the following word
# '@selector(foo) a:' vs '@selector(foo)a:'
sp_after_oc_at_sel_parens       = force    # ignore/add/remove/force

# Add or remove space inside '@selector' parens
# '@selector(foo)' vs '@selector( foo )'
# Also applies to @protocol() constructs
sp_inside_oc_at_sel_parens      = force    # ignore/add/remove/force

# Add or remove space before a block pointer caret
# '^int (int arg){...}' vs. ' ^int (int arg){...}'
sp_before_oc_block_caret        = force    # ignore/add/remove/force

# Add or remove space after a block pointer caret
# '^int (int arg){...}' vs. '^ int (int arg){...}'
sp_after_oc_block_caret         = force    # ignore/add/remove/force

# Add or remove space between the receiver and selector in a message.
# '[receiver selector ...]'
sp_after_oc_msg_receiver        = force    # ignore/add/remove/force

# Add or remove space after @property.
sp_after_oc_property            = force    # ignore/add/remove/force

# Add or remove space around the ':' in 'b ? t : f'
sp_cond_colon                   = force    # ignore/add/remove/force

# Add or remove space before the ':' in 'b ? t : f'. Overrides sp_cond_colon.
sp_cond_colon_before            = force    # ignore/add/remove/force

# Add or remove space after the ':' in 'b ? t : f'. Overrides sp_cond_colon.
sp_cond_colon_after             = force    # ignore/add/remove/force

# Add or remove space around the '?' in 'b ? t : f'
sp_cond_question                = force    # ignore/add/remove/force

# Add or remove space before the '?' in 'b ? t : f'. Overrides sp_cond_question.
sp_cond_question_before         = force    # ignore/add/remove/force

# Add or remove space after the '?' in 'b ? t : f'. Overrides sp_cond_question.
sp_cond_question_after          = force    # ignore/add/remove/force

# In the abbreviated ternary form (a ?: b), add/remove space between ? and :.'. Overrides all other sp_cond_* options.
sp_cond_ternary_short           = force    # ignore/add/remove/force

# Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make sense here.
sp_case_label                   = force    # ignore/add/remove/force

# Control the space around the D '..' operator.
sp_range                        = force    # ignore/add/remove/force

# Control the spacing after ':' in 'for (TYPE VAR : EXPR)'
sp_after_for_colon              = force    # ignore/add/remove/force

# Control the spacing before ':' in 'for (TYPE VAR : EXPR)'
sp_before_for_colon             = force    # ignore/add/remove/force

# Control the spacing in 'extern (C)' (D)
sp_extern_paren                 = force    # ignore/add/remove/force

# Control the space after the opening of a C++ comment '// A' vs '//A'
sp_cmt_cpp_start                = force    # ignore/add/remove/force

# TRUE: If space is added with sp_cmt_cpp_start, do it after doxygen sequences like '///', '///<', '//!' and '//!<'.
sp_cmt_cpp_doxygen              = false    # false/true

# TRUE: If space is added with sp_cmt_cpp_start, do it after Qt translator or meta-data comments like '//:', '//=', and '//~'.
sp_cmt_cpp_qttr                 = false    # false/true

# Controls the spaces between #else or #endif and a trailing comment
sp_endif_cmt                    = force    # ignore/add/remove/force

# Controls the spaces after 'new', 'delete' and 'delete[]'
sp_after_new                    = force    # ignore/add/remove/force

# Controls the spaces between new and '(' in 'new()'
sp_between_new_paren            = force    # ignore/add/remove/force

# Controls the spaces before a trailing or embedded comment
sp_before_tr_emb_cmt            = force    # ignore/add/remove/force

# Number of spaces before a trailing or embedded comment
sp_num_before_tr_emb_cmt        = 0        # number

# Control space between a Java annotation and the open paren.
sp_annotation_paren             = force    # ignore/add/remove/force

# If true, vbrace tokens are dropped to the previous token and skipped.
sp_skip_vbrace_tokens           = false    # false/true

#
# Code alignment (not left column spaces/tabs)
#

# Whether to keep non-indenting tabs
align_keep_tabs                 = false    # false/true

# Whether to use tabs for aligning
align_with_tabs                 = false    # false/true

# Whether to bump out to the next tab when aligning
align_on_tabstop                = false    # false/true

# Whether to left-align numbers
#align_number_left               = false    # false/true

# Whether to keep whitespace not required for alignment.
align_keep_extra_space          = false    # false/true

# Align variable definitions in prototypes and functions
align_func_params               = false    # false/true

# Align parameters in single-line functions that have the same name.
# The function names must already be aligned with each other.
align_same_func_call_params     = false    # false/true

# The span for aligning variable definitions (0=don't align)
align_var_def_span              = 0        # number

# How to align the star in variable definitions.
#  0=Part of the type     'void *   foo;'
#  1=Part of the variable 'void     *foo;'
#  2=Dangling             'void    *foo;'
align_var_def_star_style        = 0        # number

# How to align the '&' in variable definitions.
#  0=Part of the type
#  1=Part of the variable
#  2=Dangling
align_var_def_amp_style         = 0        # number

# The threshold for aligning variable definitions (0=no limit)
align_var_def_thresh            = 0        # number

# The gap for aligning variable definitions
align_var_def_gap               = 0        # number

# Whether to align the colon in struct bit fields
align_var_def_colon             = false    # false/true

# Whether to align any attribute after the variable name
align_var_def_attribute         = false    # false/true

# Whether to align inline struct/enum/union variable definitions
align_var_def_inline            = false    # false/true

# The span for aligning on '=' in assignments (0=don't align)
align_assign_span               = 0        # number

# The threshold for aligning on '=' in assignments (0=no limit)
align_assign_thresh             = 0        # number

# The span for aligning on '=' in enums (0=don't align)
align_enum_equ_span             = 0        # number

# The threshold for aligning on '=' in enums (0=no limit)
align_enum_equ_thresh           = 0        # number

# The span for aligning class (0=don't align)
align_var_class_span            = 0        # number

# The threshold for aligning class member definitions (0=no limit)
align_var_class_thresh          = 0        # number

# The gap for aligning class member definitions
align_var_class_gap             = 0        # number

# The span for aligning struct/union (0=don't align)
align_var_struct_span           = 0        # number

# The threshold for aligning struct/union member definitions (0=no limit)
align_var_struct_thresh         = 0        # number

# The gap for aligning struct/union member definitions
align_var_struct_gap            = 0        # number

# The span for aligning struct initializer values (0=don't align)
align_struct_init_span          = 0        # number

# The minimum space between the type and the synonym of a typedef
align_typedef_gap               = 0        # number

# The span for aligning single-line typedefs (0=don't align)
align_typedef_span              = 0        # number

# How to align typedef'd functions with other typedefs
# 0: Don't mix them at all
# 1: align the open paren with the types
# 2: align the function type name with the other type names
align_typedef_func              = 0        # number

# Controls the positioning of the '*' in typedefs. Just try it.
# 0: Align on typedef type, ignore '*'
# 1: The '*' is part of type name: typedef int  *pint;
# 2: The '*' is part of the type, but dangling: typedef int *pint;
align_typedef_star_style        = 0        # number

# Controls the positioning of the '&' in typedefs. Just try it.
# 0: Align on typedef type, ignore '&'
# 1: The '&' is part of type name: typedef int  &pint;
# 2: The '&' is part of the type, but dangling: typedef int &pint;
align_typedef_amp_style         = 0        # number

# The span for aligning comments that end lines (0=don't align)
align_right_cmt_span            = 0        # number

# If aligning comments, mix with comments after '}' and #endif with less than 3 spaces before the comment
align_right_cmt_mix             = false    # false/true

# If a trailing comment is more than this number of columns away from the text it follows,
# it will qualify for being aligned. This has to be > 0 to do anything.
align_right_cmt_gap             = 0        # number

# Align trailing comment at or beyond column N; 'pulls in' comments as a bonus side effect (0=ignore)
align_right_cmt_at_col          = 0        # number

# The span for aligning function prototypes (0=don't align)
align_func_proto_span           = 0        # number

# Minimum gap between the return type and the function name.
align_func_proto_gap            = 0        # number

# Align function protos on the 'operator' keyword instead of what follows
align_on_operator               = false    # false/true

# Whether to mix aligning prototype and variable declarations.
# If true, align_var_def_XXX options are used instead of align_func_proto_XXX options.
align_mix_var_proto             = false    # false/true

# Align single-line functions with function prototypes, uses align_func_proto_span
align_single_line_func          = false    # false/true

# Aligning the open brace of single-line functions.
# Requires align_single_line_func=true, uses align_func_proto_span
align_single_line_brace         = false    # false/true

# Gap for align_single_line_brace.
align_single_line_brace_gap     = 0        # number

# The span for aligning ObjC msg spec (0=don't align)
align_oc_msg_spec_span          = 0        # number

# Whether to align macros wrapped with a backslash and a newline.
# This will not work right if the macro contains a multi-line comment.
align_nl_cont                   = false    # false/true

# # Align macro functions and variables together
align_pp_define_together        = false    # false/true

# The minimum space between label and value of a preprocessor define
align_pp_define_gap             = 0        # number

# The span for aligning on '#define' bodies (0=don't align, other=number of lines including comments between blocks)
align_pp_define_span            = 0        # number

# Align lines that start with '<<' with previous '<<'. Default=True
align_left_shift                = true     # false/true

# Align text after asm volatile () colons.
align_asm_colon                 = false    # false/true

# Span for aligning parameters in an Obj-C message call on the ':' (0=don't align)
align_oc_msg_colon_span         = 0        # number

# If true, always align with the first parameter, even if it is too short.
align_oc_msg_colon_first        = false    # false/true

# Aligning parameters in an Obj-C '+' or '-' declaration on the ':'
align_oc_decl_colon             = false    # false/true

#
# Newline adding and removing options
#

# Whether to collapse empty blocks between '{' and '}'
nl_collapse_empty_body          = false    # false/true

# Don't split one-line braced assignments - 'foo_t f = { 1, 2 };'
nl_assign_leave_one_liners      = true     # false/true

# Don't split one-line braced statements inside a class xx { } body
nl_class_leave_one_liners       = false    # false/true

# Don't split one-line enums: 'enum foo { BAR = 15 };'
nl_enum_leave_one_liners        = false    # false/true

# Don't split one-line get or set functions
nl_getset_leave_one_liners      = false    # false/true

# Don't split one-line function definitions - 'int foo() { return 0; }'
nl_func_leave_one_liners        = false    # false/true

# Don't split one-line C++11 lambdas - '[]() { return 0; }'
nl_cpp_lambda_leave_one_liners  = true     # false/true

# Don't split one-line if/else statements - 'if(a) b++;'
nl_if_leave_one_liners          = false    # false/true

# Don't split one-line while statements - 'while(a) b++;'
nl_while_leave_one_liners       = false    # false/true

# Don't split one-line OC messages
nl_oc_msg_leave_one_liner       = false    # false/true

# Add or remove newline between Objective-C block signature and '{'
nl_oc_block_brace               = remove   # ignore/add/remove/force

# Add or remove newlines at the start of the file
nl_start_of_file                = force    # ignore/add/remove/force

# The number of newlines at the start of the file (only used if nl_start_of_file is 'add' or 'force'
nl_start_of_file_min            = 0        # number

# Add or remove newline at the end of the file
nl_end_of_file                  = force    # ignore/add/remove/force

# The number of newlines at the end of the file (only used if nl_end_of_file is 'add' or 'force')
nl_end_of_file_min              = 1        # number

# Add or remove newline between '=' and '{'
nl_assign_brace                 = remove   # ignore/add/remove/force

# Add or remove newline between '=' and '[' (D only)
nl_assign_square                = remove   # ignore/add/remove/force

# Add or remove newline after '= [' (D only). Will also affect the newline before the ']'
nl_after_square_assign          = remove   # ignore/add/remove/force

# The number of blank lines after a block of variable definitions at the top of a function body
# 0 = No change (default)
nl_func_var_def_blk             = 0        # number

# The number of newlines before a block of typedefs
# 0 = No change (default)
# the option 'nl_after_access_spec' takes preference over 'nl_typedef_blk_start'
nl_typedef_blk_start            = 0        # number

# The number of newlines after a block of typedefs
# 0 = No change (default)
nl_typedef_blk_end              = 0        # number

# The maximum consecutive newlines within a block of typedefs
# 0 = No change (default)
nl_typedef_blk_in               = 0        # number

# The number of newlines before a block of variable definitions not at the top of a function body
# 0 = No change (default)
# the option 'nl_after_access_spec' takes preference over 'nl_var_def_blk_start'
nl_var_def_blk_start            = 0        # number

# The number of newlines after a block of variable definitions not at the top of a function body
# 0 = No change (default)
nl_var_def_blk_end              = 0        # number

# The maximum consecutive newlines within a block of variable definitions
# 0 = No change (default)
nl_var_def_blk_in               = 0        # number

# Add or remove newline between a function call's ')' and '{', as in:
# list_for_each(item, &list) { }
nl_fcall_brace                  = force    # ignore/add/remove/force

# Add or remove newline between 'enum' and '{'
nl_enum_brace                   = force    # ignore/add/remove/force

# Add or remove newline between 'struct and '{'
nl_struct_brace                 = force    # ignore/add/remove/force

# Add or remove newline between 'union' and '{'
nl_union_brace                  = force    # ignore/add/remove/force

# Add or remove newline between 'if' and '{'
nl_if_brace                     = force    # ignore/add/remove/force

# Add or remove newline between '}' and 'else'
nl_brace_else                   = force    # ignore/add/remove/force

# Add or remove newline between 'else if' and '{'
# If set to ignore, nl_if_brace is used instead
nl_elseif_brace                 = force    # ignore/add/remove/force

# Add or remove newline between 'else' and '{'
nl_else_brace                   = force    # ignore/add/remove/force

# Add or remove newline between 'else' and 'if'
nl_else_if                      = remove   # ignore/add/remove/force

# Add or remove newline between '}' and 'finally'
nl_brace_finally                = force    # ignore/add/remove/force

# Add or remove newline between 'finally' and '{'
nl_finally_brace                = force    # ignore/add/remove/force

# Add or remove newline between 'try' and '{'
nl_try_brace                    = force    # ignore/add/remove/force

# Add or remove newline between get/set and '{'
nl_getset_brace                 = force    # ignore/add/remove/force

# Add or remove newline between 'for' and '{'
nl_for_brace                    = force    # ignore/add/remove/force

# Add or remove newline between 'catch' and '{'
nl_catch_brace                  = force    # ignore/add/remove/force

# Add or remove newline between '}' and 'catch'
nl_brace_catch                  = force    # ignore/add/remove/force

# Add or remove newline between '}' and ']'
nl_brace_square                 = force    # ignore/add/remove/force

# Add or remove newline between '}' and ')' in a function invocation
nl_brace_fparen                 = ignore   # ignore/add/remove/force

# Add or remove newline between 'while' and '{'
nl_while_brace                  = force    # ignore/add/remove/force

# Add or remove newline between 'scope (x)' and '{' (D)
nl_scope_brace                  = force    # ignore/add/remove/force

# Add or remove newline between 'unittest' and '{' (D)
nl_unittest_brace               = force    # ignore/add/remove/force

# Add or remove newline between 'version (x)' and '{' (D)
nl_version_brace                = force    # ignore/add/remove/force

# Add or remove newline between 'using' and '{'
nl_using_brace                  = force    # ignore/add/remove/force

# Add or remove newline between two open or close braces.
# Due to general newline/brace handling, REMOVE may not work.
nl_brace_brace                  = ignore   # ignore/add/remove/force

# Add or remove newline between 'do' and '{'
nl_do_brace                     = force    # ignore/add/remove/force

# Add or remove newline between '}' and 'while' of 'do' statement
nl_brace_while                  = force    # ignore/add/remove/force

# Add or remove newline between 'switch' and '{'
nl_switch_brace                 = force    # ignore/add/remove/force

# Add or remove newline between 'synchronized' and '{'
nl_synchronized_brace           = force    # ignore/add/remove/force

# Add a newline between ')' and '{' if the ')' is on a different line than the if/for/etc.
# Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and nl_catch_brace.
nl_multi_line_cond              = false    # false/true

# Force a newline in a define after the macro name for multi-line defines.
nl_multi_line_define            = false    # false/true

# Whether to put a newline before 'case' statement, not after the first 'case'
nl_before_case                  = false    # false/true

# Add or remove newline between ')' and 'throw'
nl_before_throw                 = force    # ignore/add/remove/force

# Whether to put a newline after 'case' statement
nl_after_case                   = false    # false/true

# Add or remove a newline between a case ':' and '{'. Overrides nl_after_case.
nl_case_colon_brace             = force    # ignore/add/remove/force

# Newline between namespace and {
nl_namespace_brace              = force    # ignore/add/remove/force

# Add or remove newline between 'template<>' and whatever follows.
nl_template_class               = force    # ignore/add/remove/force

# Add or remove newline between 'class' and '{'
nl_class_brace                  = force    # ignore/add/remove/force

# Add or remove newline before/after each ',' in the base class list,
#   (tied to pos_class_comma).
nl_class_init_args              = force    # ignore/add/remove/force

# Add or remove newline after each ',' in the constructor member initialization.
# Related to nl_constr_colon, pos_constr_colon and pos_constr_comma.
nl_constr_init_args             = force    # ignore/add/remove/force

# Add or remove newline before first element, after comma, and after last element in enum
nl_enum_own_lines               = force    # ignore/add/remove/force

# Add or remove newline between return type and function name in a function definition
nl_func_type_name               = remove   # ignore/add/remove/force

# Add or remove newline between return type and function name inside a class {}
# Uses nl_func_type_name or nl_func_proto_type_name if set to ignore.
nl_func_type_name_class         = remove   # ignore/add/remove/force

# Add or remove newline between class specification and '::' in 'void A::f() { }'
# Only appears in separate member implementation (does not appear with in-line implmementation)
nl_func_class_scope             = remove   # ignore/add/remove/force

# Add or remove newline between function scope and name
# Controls the newline after '::' in 'void A::f() { }'
nl_func_scope_name              = remove   # ignore/add/remove/force

# Add or remove newline between return type and function name in a prototype
nl_func_proto_type_name         = remove   # ignore/add/remove/force

# Add or remove newline between a function name and the opening '(' in the declaration
nl_func_paren                   = remove   # ignore/add/remove/force

# Add or remove newline between a function name and the opening '(' in the definition
nl_func_def_paren               = remove   # ignore/add/remove/force

# Add or remove newline after '(' in a function declaration
nl_func_decl_start              = remove   # ignore/add/remove/force

# Add or remove newline after '(' in a function definition
nl_func_def_start               = remove   # ignore/add/remove/force

# Overrides nl_func_decl_start when there is only one parameter.
nl_func_decl_start_single       = remove   # ignore/add/remove/force

# Overrides nl_func_def_start when there is only one parameter.
nl_func_def_start_single        = remove   # ignore/add/remove/force

# Whether to add newline after '(' in a function declaration if '(' and ')' are in different lines.
nl_func_decl_start_multi_line   = false    # false/true

# Whether to add newline after '(' in a function definition if '(' and ')' are in different lines.
nl_func_def_start_multi_line    = false    # false/true

# Add or remove newline after each ',' in a function declaration
nl_func_decl_args               = ignore   # ignore/add/remove/force

# Add or remove newline after each ',' in a function definition
nl_func_def_args                = ignore   # ignore/add/remove/force

# Whether to add newline after each ',' in a function declaration if '(' and ')' are in different lines.
nl_func_decl_args_multi_line    = false    # false/true

# Whether to add newline after each ',' in a function definition if '(' and ')' are in different lines.
nl_func_def_args_multi_line     = false    # false/true

# Add or remove newline before the ')' in a function declaration
nl_func_decl_end                = remove   # ignore/add/remove/force

# Add or remove newline before the ')' in a function definition
nl_func_def_end                 = remove   # ignore/add/remove/force

# Overrides nl_func_decl_end when there is only one parameter.
nl_func_decl_end_single         = remove   # ignore/add/remove/force

# Overrides nl_func_def_end when there is only one parameter.
nl_func_def_end_single          = remove   # ignore/add/remove/force

# Whether to add newline before ')' in a function declaration if '(' and ')' are in different lines.
nl_func_decl_end_multi_line     = false    # false/true

# Whether to add newline before ')' in a function definition if '(' and ')' are in different lines.
nl_func_def_end_multi_line      = false    # false/true

# Add or remove newline between '()' in a function declaration.
nl_func_decl_empty              = remove   # ignore/add/remove/force

# Add or remove newline between '()' in a function definition.
nl_func_def_empty               = remove   # ignore/add/remove/force

# Whether to add newline after '(' in a function call if '(' and ')' are in different lines.
nl_func_call_start_multi_line   = false    # false/true

# Whether to add newline after each ',' in a function call if '(' and ')' are in different lines.
nl_func_call_args_multi_line    = false    # false/true

# Whether to add newline before ')' in a function call if '(' and ')' are in different lines.
nl_func_call_end_multi_line     = false    # false/true

# Whether to put each OC message parameter on a separate line
# See nl_oc_msg_leave_one_liner
nl_oc_msg_args                  = false    # false/true

# Add or remove newline between function signature and '{'
nl_fdef_brace                   = force    # ignore/add/remove/force

# Add or remove newline between C++11 lambda signature and '{'
nl_cpp_ldef_brace               = force    # ignore/add/remove/force

# Add or remove a newline between the return keyword and return expression.
nl_return_expr                  = remove   # ignore/add/remove/force

# Whether to put a newline after semicolons, except in 'for' statements
nl_after_semicolon              = false    # false/true

# Java: Control the newline between the ')' and '{{' of the double brace initializer.
nl_paren_dbrace_open            = force    # ignore/add/remove/force

# Whether to put a newline after brace open.
# This also adds a newline before the matching brace close.
nl_after_brace_open             = false    # false/true

# If nl_after_brace_open and nl_after_brace_open_cmt are true, a newline is
# placed between the open brace and a trailing single-line comment.
nl_after_brace_open_cmt         = false    # false/true

# Whether to put a newline after a virtual brace open with a non-empty body.
# These occur in un-braced if/while/do/for statement bodies.
nl_after_vbrace_open            = false    # false/true

# Whether to put a newline after a virtual brace open with an empty body.
# These occur in un-braced if/while/do/for statement bodies.
nl_after_vbrace_open_empty      = false    # false/true

# Whether to put a newline after a brace close.
# Does not apply if followed by a necessary ';'.
nl_after_brace_close            = false    # false/true

# Whether to put a newline after a virtual brace close.
# Would add a newline before return in: 'if (foo) a++; return;'
nl_after_vbrace_close           = false    # false/true

# Control the newline between the close brace and 'b' in: 'struct { int a; } b;'
# Affects enums, unions and structures. If set to ignore, uses nl_after_brace_close
nl_brace_struct_var             = force    # ignore/add/remove/force

# Whether to alter newlines in '#define' macros
nl_define_macro                 = false    # false/true

# Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and '#endif'. Does not affect top-level #ifdefs.
nl_squeeze_ifdef                = false    # false/true

# Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well.
nl_squeeze_ifdef_top_level      = false    # false/true

# Add or remove blank line before 'if'
nl_before_if                    = ignore   # ignore/add/remove/force

# Add or remove blank line after 'if' statement
nl_after_if                     = ignore   # ignore/add/remove/force XXX

# Add or remove blank line before 'for'
nl_before_for                   = ignore   # ignore/add/remove/force

# Add or remove blank line after 'for' statement
nl_after_for                    = ignore   # ignore/add/remove/force XXX

# Add or remove blank line before 'while'
nl_before_while                 = force    # ignore/add/remove/force

# Add or remove blank line after 'while' statement
nl_after_while                  = ignore   # ignore/add/remove/force XXX

# Add or remove blank line before 'switch'
nl_before_switch                = force    # ignore/add/remove/force

# Add or remove blank line after 'switch' statement
nl_after_switch                 = ignore   # ignore/add/remove/force

# Add or remove blank line before 'synchronized'
nl_before_synchronized          = force    # ignore/add/remove/force

# Add or remove blank line after 'synchronized' statement
nl_after_synchronized           = force    # ignore/add/remove/force

# Add or remove blank line before 'do'
nl_before_do                    = force    # ignore/add/remove/force

# Add or remove blank line after 'do/while' statement
nl_after_do                     = force    # ignore/add/remove/force

# Whether to double-space commented-entries in struct/union/enum
nl_ds_struct_enum_cmt           = false    # false/true

# force nl before } of a struct/union/enum
# (lower priority than 'eat_blanks_before_close_brace')
nl_ds_struct_enum_close_brace   = false    # false/true

# Add or remove blank line before 'func_class_def'
nl_before_func_class_def        = 0        # number

# Add or remove blank line before 'func_class_proto'
nl_before_func_class_proto      = 0        # number

# Add or remove a newline before/after a class colon,
#   (tied to pos_class_colon).
nl_class_colon                  = remove   # ignore/add/remove/force

# Add or remove a newline around a class constructor colon.
# Related to nl_constr_init_args, pos_constr_colon and pos_constr_comma.
nl_constr_colon                 = force    # ignore/add/remove/force

# Change simple unbraced if statements into a one-liner
# 'if(b)\n i++;' => 'if(b) i++;'
nl_create_if_one_liner          = false    # false/true

# Change simple unbraced for statements into a one-liner
# 'for (i=0;i<5;i++)\n foo(i);' => 'for (i=0;i<5;i++) foo(i);'
nl_create_for_one_liner         = false    # false/true

# Change simple unbraced while statements into a one-liner
# 'while (i<5)\n foo(i++);' => 'while (i<5) foo(i++);'
nl_create_while_one_liner       = false    # false/true

#  Change a one-liner if statement into simple unbraced if
# 'if(b) i++;' => 'if(b) i++;'
nl_split_if_one_liner           = false    # false/true

# Change a one-liner for statement into simple unbraced for
# 'for (i=0;<5;i++) foo(i);' => 'for (i=0;<5;i++) foo(i);'
nl_split_for_one_liner          = false    # false/true

# Change simple unbraced while statements into a one-liner while
# 'while (i<5)\n foo(i++);' => 'while (i<5) foo(i++);'
nl_split_while_one_liner        = false    # false/true

#
# Positioning options
#

# The position of arithmetic operators in wrapped expressions
pos_arith                       = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of assignment in wrapped expressions.
# Do not affect '=' followed by '{'
pos_assign                      = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of boolean operators in wrapped expressions
pos_bool                        = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of comparison operators in wrapped expressions
pos_compare                     = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of conditional (b ? t : f) operators in wrapped expressions
pos_conditional                 = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of the comma in wrapped expressions
pos_comma                       = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of the comma in enum entries
pos_enum_comma                  = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of the comma in the base class list if there are more than one line,
#   (tied to nl_class_init_args).
pos_class_comma                 = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of the comma in the constructor initialization list.
# Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon.
pos_constr_comma                = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of trailing/leading class colon, between class and base class list
#   (tied to nl_class_colon).
pos_class_colon                 = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

# The position of colons between constructor and member initialization,
# (tied to UO_nl_constr_colon).
# Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma.
pos_constr_colon                = ignore   # ignore/join/lead/lead_break/lead_force/trail/trail_break/trail_force

#
# Line Splitting options
#

# Try to limit code width to N number of columns
code_width                      = 120      # number

# Whether to fully split long 'for' statements at semi-colons
ls_for_split_full               = false    # false/true

# Whether to fully split long function protos/calls at commas
ls_func_split_full              = false    # false/true

# Whether to split lines as close to code_width as possible and ignore some groupings
ls_code_width                   = false    # false/true

#
# Blank line options
#

# The maximum consecutive newlines (3 = 2 blank lines)
nl_max                          = 0        # number

# The number of newlines after a function prototype, if followed by another function prototype
nl_after_func_proto             = 0        # number

# The number of newlines after a function prototype, if not followed by another function prototype
nl_after_func_proto_group       = 0        # number

# The number of newlines after a function class prototype, if followed by another function class prototype
nl_after_func_class_proto       = 0        # number

# The number of newlines after a function class prototype, if not followed by another function class prototype
nl_after_func_class_proto_group = 0        # number

# The number of newlines before a multi-line function def body
nl_before_func_body_def         = 0        # number

# The number of newlines before a multi-line function prototype body
nl_before_func_body_proto       = 0        # number

# The number of newlines after '}' of a multi-line function body
nl_after_func_body              = 0        # number

# The number of newlines after '}' of a multi-line function body in a class declaration
nl_after_func_body_class        = 0        # number

# The number of newlines after '}' of a single line function body
nl_after_func_body_one_liner    = 0        # number

# The minimum number of newlines before a multi-line comment.
# Doesn't apply if after a brace open or another multi-line comment.
nl_before_block_comment         = 0        # number

# The minimum number of newlines before a single-line C comment.
# Doesn't apply if after a brace open or other single-line C comments.
nl_before_c_comment             = 0        # number

# The minimum number of newlines before a CPP comment.
# Doesn't apply if after a brace open or other CPP comments.
nl_before_cpp_comment           = 0        # number

# Whether to force a newline after a multi-line comment.
nl_after_multiline_comment      = false    # false/true

# Whether to force a newline after a label's colon.
nl_after_label_colon            = false    # false/true

# The number of newlines after '}' or ';' of a struct/enum/union definition
nl_after_struct                 = 0        # number

# The number of newlines before a class definition
nl_before_class                 = 0        # number

# The number of newlines after '}' or ';' of a class definition
nl_after_class                  = 0        # number

# The number of newlines before a 'private:', 'public:', 'protected:', 'signals:', or 'slots:' label.
# Will not change the newline count if after a brace open.
# 0 = No change.
nl_before_access_spec           = 0        # number

# The number of newlines after a 'private:', 'public:', 'protected:', 'signals:' or 'slots:' label.
# 0 = No change.
# the option 'nl_after_access_spec' takes preference over 'nl_typedef_blk_start' and 'nl_var_def_blk_start'
nl_after_access_spec            = 0        # number

# The number of newlines between a function def and the function comment.
# 0 = No change.
nl_comment_func_def             = 0        # number

# The number of newlines after a try-catch-finally block that isn't followed by a brace close.
# 0 = No change.
nl_after_try_catch_finally      = 0        # number

# The number of newlines before and after a property, indexer or event decl.
# 0 = No change.
nl_around_cs_property           = 0        # number

# The number of newlines between the get/set/add/remove handlers in C#.
# 0 = No change.
nl_between_get_set              = 0        # number

# Add or remove newline between C# property and the '{'
nl_property_brace               = force    # ignore/add/remove/force

# Whether to remove blank lines after '{'
eat_blanks_after_open_brace     = false    # false/true

# Whether to remove blank lines before '}'
eat_blanks_before_close_brace   = false    # false/true

# How aggressively to remove extra newlines not in preproc.
# 0: No change
# 1: Remove most newlines not handled by other config
# 2: Remove all newlines and reformat completely by config
nl_remove_extra_newlines        = 0        # number

# Whether to put a blank line before 'return' statements, unless after an open brace.
nl_before_return                = false    # false/true

# Whether to put a blank line after 'return' statements, unless followed by a close brace.
nl_after_return                 = false    # false/true

# Whether to put a newline after a Java annotation statement.
# Only affects annotations that are after a newline.
nl_after_annotation             = force    # ignore/add/remove/force

# Controls the newline between two annotations.
nl_between_annotation           = force    # ignore/add/remove/force

#
# Code modifying options (non-whitespace)
#

# Add or remove braces on single-line 'do' statement
mod_full_brace_do               = force    # ignore/add/remove/force

# Add or remove braces on single-line 'for' statement
mod_full_brace_for              = force    # ignore/add/remove/force

# Add or remove braces on single-line function definitions. (Pawn)
mod_full_brace_function         = force    # ignore/add/remove/force

# Add or remove braces on single-line 'if' statement. Will not remove the braces if they contain an 'else'.
mod_full_brace_if               = force    # ignore/add/remove/force

# Make all if/elseif/else statements in a chain be braced or not. Overrides mod_full_brace_if.
# If any must be braced, they are all braced.  If all can be unbraced, then the braces are removed.
mod_full_brace_if_chain         = false    # false/true

# Make all if/elseif/else statements with at least one 'else' or 'else if' fully braced.
# If mod_full_brace_if_chain is used together with this option, all if-else chains will get braces,
# and simple 'if' statements will lose them (if possible).
mod_full_brace_if_chain_only    = false    # false/true

# Don't remove braces around statements that span N newlines
mod_full_brace_nl               = 0        # number

# Add or remove braces on single-line 'while' statement
mod_full_brace_while            = force    # ignore/add/remove/force

# Add or remove braces on single-line 'using ()' statement
mod_full_brace_using            = force    # ignore/add/remove/force

# Add or remove unnecessary paren on 'return' statement
mod_paren_on_return             = remove   # ignore/add/remove/force

# Whether to change optional semicolons to real semicolons
mod_pawn_semicolon              = false    # false/true

# Add parens on 'while' and 'if' statement around bools
mod_full_paren_if_bool          = false    # false/true

# Whether to remove superfluous semicolons
mod_remove_extra_semicolon      = false    # false/true

# If a function body exceeds the specified number of newlines and doesn't have a comment after
# the close brace, a comment will be added.
mod_add_long_function_closebrace_comment = 0        # number

# If a namespace body exceeds the specified number of newlines and doesn't have a comment after
# the close brace, a comment will be added.
mod_add_long_namespace_closebrace_comment = 0        # number

# If a class body exceeds the specified number of newlines and doesn't have a comment after
# the close brace, a comment will be added.
mod_add_long_class_closebrace_comment = 0        # number

# If a switch body exceeds the specified number of newlines and doesn't have a comment after
# the close brace, a comment will be added.
mod_add_long_switch_closebrace_comment = 0        # number

# If an #ifdef body exceeds the specified number of newlines and doesn't have a comment after
# the #endif, a comment will be added.
mod_add_long_ifdef_endif_comment = 0        # number

# If an #ifdef or #else body exceeds the specified number of newlines and doesn't have a comment after
# the #else, a comment will be added.
mod_add_long_ifdef_else_comment = 0        # number

# If TRUE, will sort consecutive single-line 'import' statements [Java, D]
mod_sort_import                 = false    # false/true

# If TRUE, will sort consecutive single-line 'using' statements [C#]
mod_sort_using                  = false    # false/true

# If TRUE, will sort consecutive single-line '#include' statements [C/C++] and '#import' statements [Obj-C]
# This is generally a bad idea, as it may break your code.
mod_sort_include                = false    # false/true

# If TRUE, it will move a 'break' that appears after a fully braced 'case' before the close brace.
mod_move_case_break             = false    # false/true

# Will add or remove the braces around a fully braced case statement.
# Will only remove the braces if there are no variable declarations in the block.
mod_case_brace                  = force    # ignore/add/remove/force

# If TRUE, it will remove a void 'return;' that appears as the last statement in a function.
mod_remove_empty_return         = false    # false/true

# If TRUE, it will organize the properties (Obj-C)
mod_sort_oc_properties          = false    # false/true

# Determines weight of atomic/nonatomic (Obj-C)
mod_sort_oc_property_thread_safe_weight = 0        # number

# Determines weight of readwrite (Obj-C)
mod_sort_oc_property_readwrite_weight = 0        # number

# Determines weight of reference type (retain, copy, assign, weak, strong) (Obj-C)
mod_sort_oc_property_reference_weight = 0        # number

# Determines weight of getter type (getter=) (Obj-C)
mod_sort_oc_property_getter_weight = 0        # number

# Determines weight of setter type (setter=) (Obj-C)
mod_sort_oc_property_setter_weight = 0        # number

# Determines weight of nullability type (nullable/nonnull) (Obj-C)
mod_sort_oc_property_nullability_weight = 0        # number

#
# Comment modifications
#

# Try to wrap comments at cmt_width columns
cmt_width                       = 0        # number

# Set the comment reflow mode (default: 0)
# 0: no reflowing (apart from the line wrapping due to cmt_width)
# 1: no touching at all
# 2: full reflow
cmt_reflow_mode                 = 0        # number

# Whether to convert all tabs to spaces in comments. Default is to leave tabs inside comments alone, unless used for indenting.
cmt_convert_tab_to_spaces       = false    # false/true

# If false, disable all multi-line comment changes, including cmt_width. keyword substitution and leading chars.
# Default=True.
cmt_indent_multi                = true     # false/true

# Whether to group c-comments that look like they are in a block
cmt_c_group                     = false    # false/true

# Whether to put an empty '/*' on the first line of the combined c-comment
cmt_c_nl_start                  = false    # false/true

# Whether to put a newline before the closing '*/' of the combined c-comment
cmt_c_nl_end                    = false    # false/true

# Whether to group cpp-comments that look like they are in a block
cmt_cpp_group                   = false    # false/true

# Whether to put an empty '/*' on the first line of the combined cpp-comment
cmt_cpp_nl_start                = false    # false/true

# Whether to put a newline before the closing '*/' of the combined cpp-comment
cmt_cpp_nl_end                  = false    # false/true

# Whether to change cpp-comments into c-comments
cmt_cpp_to_c                    = false    # false/true

# Whether to put a star on subsequent comment lines
cmt_star_cont                   = false    # false/true

# The number of spaces to insert at the start of subsequent comment lines
cmt_sp_before_star_cont         = 0        # number

# The number of spaces to insert after the star on subsequent comment lines
cmt_sp_after_star_cont          = 0        # number

# For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of
# the comment are the same length. Default=True
cmt_multi_check_last            = true     # false/true

# For multi-line comments with a '*' lead, remove leading spaces if the first and last lines of
# the comment are the same length AND if the length is bigger as the first_len minimum. Default=4
cmt_multi_first_len_minimum     = 4        # number

# The filename that contains text to insert at the head of a file if the file doesn't start with a C/C++ comment.
# Will substitute $(filename) with the current file's name.
cmt_insert_file_header          = ""         # string

# The filename that contains text to insert at the end of a file if the file doesn't end with a C/C++ comment.
# Will substitute $(filename) with the current file's name.
cmt_insert_file_footer          = ""         # string

# The filename that contains text to insert before a function implementation if the function isn't preceded with a C/C++ comment.
# Will substitute $(function) with the function name and $(javaparam) with the javadoc @param and @return stuff.
# Will also substitute $(fclass) with the class name: void CFoo::Bar() { ... }
cmt_insert_func_header          = ""         # string

# The filename that contains text to insert before a class if the class isn't preceded with a C/C++ comment.
# Will substitute $(class) with the class name.
cmt_insert_class_header         = ""         # string

# The filename that contains text to insert before a Obj-C message specification if the method isn't preceded with a C/C++ comment.
# Will substitute $(message) with the function name and $(javaparam) with the javadoc @param and @return stuff.
cmt_insert_oc_msg_header        = ""         # string

# If a preprocessor is encountered when stepping backwards from a function name, then
# this option decides whether the comment should be inserted.
# Affects cmt_insert_oc_msg_header, cmt_insert_func_header and cmt_insert_class_header.
cmt_insert_before_preproc       = false    # false/true

# If a function is declared inline to a class definition, then
# this option decides whether the comment should be inserted.
# Affects cmt_insert_func_header.
cmt_insert_before_inlines       = true     # false/true

# If the function is a constructor/destructor, then
# this option decides whether the comment should be inserted.
# Affects cmt_insert_func_header.
cmt_insert_before_ctor_dtor     = false    # false/true

#
# Preprocessor options
#

# Control indent of preprocessors inside #if blocks at brace level 0 (file-level)
pp_indent                       = remove   # ignore/add/remove/force

# Whether to indent #if/#else/#endif at the brace level (true) or from column 1 (false)
pp_indent_at_level              = false    # false/true

# Specifies the number of columns to indent preprocessors per level at brace level 0 (file-level).
# If pp_indent_at_level=false, specifies the number of columns to indent preprocessors per level at brace level > 0 (function-level).
# Default=1.
pp_indent_count                 = 0        # number

# Add or remove space after # based on pp_level of #if blocks
pp_space                        = remove   # ignore/add/remove/force

# Sets the number of spaces added with pp_space
pp_space_count                  = 0        # number

# The indent for #region and #endregion in C# and '#pragma region' in C/C++
pp_indent_region                = 0        # number

# Whether to indent the code between #region and #endregion
pp_region_indent_code           = false    # false/true

# If pp_indent_at_level=true, sets the indent for #if, #else and #endif when not at file-level.
# 0:  indent preprocessors using output_tab_size.
# >0: column at which all preprocessors will be indented.
pp_indent_if                    = 0        # number

# Control whether to indent the code between #if, #else and #endif.
pp_if_indent_code               = false    # false/true

# Whether to indent '#define' at the brace level (true) or from column 1 (false)
pp_define_at_level              = 0        # false/true

#
# Use or Do not Use options
#

# True:  indent_func_call_param will be used (default)
# False: indent_func_call_param will NOT be used
use_indent_func_call_param      = true     # false/true

# The value of the indentation for a continuation line is calculate differently if the line is:
#   a declaration :your case with QString fileName ...
#   an assigment  :your case with pSettings = new QSettings( ...
# At the second case the option value might be used twice:
#   at the assigment
#   at the function call (if present)
# To prevent the double use of the option value, use this option with the value 'true'.
# True:  indent_continue will be used only once
# False: indent_continue will be used every time (default)
use_indent_continue_only_once   = false    # false/true

# SIGNAL/SLOT Qt macros have special formatting options. See options_for_QT.cpp for details.
# Default=True.
use_options_overriding_for_qt_macros = true     # false/true

#
# Warn levels - 1: error, 2: warning (default), 3: note
#

# Warning is given if doing tab-to-\t replacement and we have found one in a C# verbatim string literal.
warn_level_tabs_found_in_verbatim_string_literals = 2        # number

# You can force a token to be a type with the 'type' option.
# Example:
# type myfoo1 myfoo2
#
# You can create custom macro-based indentation using macro-open,
# macro-else and macro-close.
# Example:
# macro-open  BEGIN_TEMPLATE_MESSAGE_MAP
# macro-open  BEGIN_MESSAGE_MAP
# macro-close END_MESSAGE_MAP
#
# You can assign any keyword to any type with the set option.
# set func_call_user _ N_
#
# The full syntax description of all custom definition config entries
# is shown below:
#
# define custom tokens as:
# - embed whitespace in token using '' escape character, or
#   put token in quotes
# - these: ' " and ` are recognized as quote delimiters
#
# type token1 token2 token3 ...
#             ^ optionally specify multiple tokens on a single line
# define def_token output_token
#                  ^ output_token is optional, then NULL is assumed
# macro-open token
# macro-close token
# macro-else token
# set id token1 token2 ...
#               ^ optionally specify multiple tokens on a single line
#     ^ id is one of the names in token_enum.h sans the CT_ prefix,
#       e.g. PP_PRAGMA
#
# all tokens are separated by any mix of ',' commas, '=' equal signs
# and whitespace (space, tab)
#
# You can add support for other file extensions using the 'file_ext' command.
# The first arg is the language name used with the '-l' option.
# The remaining args are file extensions, matched with 'endswith'.
#   file_ext CPP .ch .cxx .cpp.in
#
# option(s) with 'not default' value: 0
#


================================================
FILE: examples/test.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "int x{7};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 10"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}